1// SPDX-License-Identifier: GPL-2.0
   2/*
   3 *  file.c - part of debugfs, a tiny little debug file system
   4 *
   5 *  Copyright (C) 2004 Greg Kroah-Hartman <greg@kroah.com>
   6 *  Copyright (C) 2004 IBM Inc.
   7 *
 
 
 
 
   8 *  debugfs is for people to use instead of /proc or /sys.
   9 *  See Documentation/filesystems/ for more details.
 
  10 */
  11
  12#include <linux/module.h>
  13#include <linux/fs.h>
  14#include <linux/seq_file.h>
  15#include <linux/pagemap.h>
  16#include <linux/debugfs.h>
  17#include <linux/io.h>
  18#include <linux/slab.h>
  19#include <linux/atomic.h>
  20#include <linux/device.h>
  21#include <linux/pm_runtime.h>
  22#include <linux/poll.h>
  23#include <linux/security.h>
  24
  25#include "internal.h"
  26
  27struct poll_table_struct;
  28
  29static ssize_t default_read_file(struct file *file, char __user *buf,
  30				 size_t count, loff_t *ppos)
  31{
  32	return 0;
  33}
  34
  35static ssize_t default_write_file(struct file *file, const char __user *buf,
  36				   size_t count, loff_t *ppos)
  37{
  38	return count;
  39}
  40
  41const struct file_operations debugfs_noop_file_operations = {
  42	.read =		default_read_file,
  43	.write =	default_write_file,
  44	.open =		simple_open,
  45	.llseek =	noop_llseek,
  46};
  47
  48#define F_DENTRY(filp) ((filp)->f_path.dentry)
  49
  50const struct file_operations *debugfs_real_fops(const struct file *filp)
  51{
  52	struct debugfs_fsdata *fsd = F_DENTRY(filp)->d_fsdata;
  53
  54	if ((unsigned long)fsd & DEBUGFS_FSDATA_IS_REAL_FOPS_BIT) {
  55		/*
  56		 * Urgh, we've been called w/o a protecting
  57		 * debugfs_file_get().
  58		 */
  59		WARN_ON(1);
  60		return NULL;
  61	}
  62
  63	return fsd->real_fops;
  64}
  65EXPORT_SYMBOL_GPL(debugfs_real_fops);
  66
  67enum dbgfs_get_mode {
  68	DBGFS_GET_ALREADY,
  69	DBGFS_GET_REGULAR,
  70	DBGFS_GET_SHORT,
  71};
  72
  73static int __debugfs_file_get(struct dentry *dentry, enum dbgfs_get_mode mode)
  74{
  75	struct debugfs_fsdata *fsd;
  76	void *d_fsd;
  77
  78	/*
  79	 * This could only happen if some debugfs user erroneously calls
  80	 * debugfs_file_get() on a dentry that isn't even a file, let
  81	 * them know about it.
  82	 */
  83	if (WARN_ON(!d_is_reg(dentry)))
  84		return -EINVAL;
  85
  86	d_fsd = READ_ONCE(dentry->d_fsdata);
  87	if (!((unsigned long)d_fsd & DEBUGFS_FSDATA_IS_REAL_FOPS_BIT)) {
  88		fsd = d_fsd;
  89	} else {
  90		if (WARN_ON(mode == DBGFS_GET_ALREADY))
  91			return -EINVAL;
  92
  93		fsd = kmalloc(sizeof(*fsd), GFP_KERNEL);
  94		if (!fsd)
  95			return -ENOMEM;
  96
  97		if (mode == DBGFS_GET_SHORT) {
  98			fsd->real_fops = NULL;
  99			fsd->short_fops = (void *)((unsigned long)d_fsd &
 100						~DEBUGFS_FSDATA_IS_REAL_FOPS_BIT);
 101		} else {
 102			fsd->real_fops = (void *)((unsigned long)d_fsd &
 103						~DEBUGFS_FSDATA_IS_REAL_FOPS_BIT);
 104			fsd->short_fops = NULL;
 105		}
 106		refcount_set(&fsd->active_users, 1);
 107		init_completion(&fsd->active_users_drained);
 108		INIT_LIST_HEAD(&fsd->cancellations);
 109		mutex_init(&fsd->cancellations_mtx);
 110
 111		if (cmpxchg(&dentry->d_fsdata, d_fsd, fsd) != d_fsd) {
 112			mutex_destroy(&fsd->cancellations_mtx);
 113			kfree(fsd);
 114			fsd = READ_ONCE(dentry->d_fsdata);
 115		}
 116	}
 117
 118	/*
 119	 * In case of a successful cmpxchg() above, this check is
 120	 * strictly necessary and must follow it, see the comment in
 121	 * __debugfs_remove_file().
 122	 * OTOH, if the cmpxchg() hasn't been executed or wasn't
 123	 * successful, this serves the purpose of not starving
 124	 * removers.
 125	 */
 126	if (d_unlinked(dentry))
 127		return -EIO;
 128
 129	if (!refcount_inc_not_zero(&fsd->active_users))
 130		return -EIO;
 131
 132	return 0;
 133}
 134
 135/**
 136 * debugfs_file_get - mark the beginning of file data access
 137 * @dentry: the dentry object whose data is being accessed.
 138 *
 139 * Up to a matching call to debugfs_file_put(), any successive call
 140 * into the file removing functions debugfs_remove() and
 141 * debugfs_remove_recursive() will block. Since associated private
 142 * file data may only get freed after a successful return of any of
 143 * the removal functions, you may safely access it after a successful
 144 * call to debugfs_file_get() without worrying about lifetime issues.
 145 *
 146 * If -%EIO is returned, the file has already been removed and thus,
 147 * it is not safe to access any of its data. If, on the other hand,
 148 * it is allowed to access the file data, zero is returned.
 149 */
 150int debugfs_file_get(struct dentry *dentry)
 151{
 152	return __debugfs_file_get(dentry, DBGFS_GET_ALREADY);
 153}
 154EXPORT_SYMBOL_GPL(debugfs_file_get);
 155
 156/**
 157 * debugfs_file_put - mark the end of file data access
 158 * @dentry: the dentry object formerly passed to
 159 *          debugfs_file_get().
 160 *
 161 * Allow any ongoing concurrent call into debugfs_remove() or
 162 * debugfs_remove_recursive() blocked by a former call to
 163 * debugfs_file_get() to proceed and return to its caller.
 164 */
 165void debugfs_file_put(struct dentry *dentry)
 166{
 167	struct debugfs_fsdata *fsd = READ_ONCE(dentry->d_fsdata);
 168
 169	if (refcount_dec_and_test(&fsd->active_users))
 170		complete(&fsd->active_users_drained);
 171}
 172EXPORT_SYMBOL_GPL(debugfs_file_put);
 173
 174/**
 175 * debugfs_enter_cancellation - enter a debugfs cancellation
 176 * @file: the file being accessed
 177 * @cancellation: the cancellation object, the cancel callback
 178 *	inside of it must be initialized
 179 *
 180 * When a debugfs file is removed it needs to wait for all active
 181 * operations to complete. However, the operation itself may need
 182 * to wait for hardware or completion of some asynchronous process
 183 * or similar. As such, it may need to be cancelled to avoid long
 184 * waits or even deadlocks.
 185 *
 186 * This function can be used inside a debugfs handler that may
 187 * need to be cancelled. As soon as this function is called, the
 188 * cancellation's 'cancel' callback may be called, at which point
 189 * the caller should proceed to call debugfs_leave_cancellation()
 190 * and leave the debugfs handler function as soon as possible.
 191 * Note that the 'cancel' callback is only ever called in the
 192 * context of some kind of debugfs_remove().
 193 *
 194 * This function must be paired with debugfs_leave_cancellation().
 195 */
 196void debugfs_enter_cancellation(struct file *file,
 197				struct debugfs_cancellation *cancellation)
 198{
 199	struct debugfs_fsdata *fsd;
 200	struct dentry *dentry = F_DENTRY(file);
 201
 202	INIT_LIST_HEAD(&cancellation->list);
 203
 204	if (WARN_ON(!d_is_reg(dentry)))
 205		return;
 206
 207	if (WARN_ON(!cancellation->cancel))
 208		return;
 209
 210	fsd = READ_ONCE(dentry->d_fsdata);
 211	if (WARN_ON(!fsd ||
 212		    ((unsigned long)fsd & DEBUGFS_FSDATA_IS_REAL_FOPS_BIT)))
 213		return;
 214
 215	mutex_lock(&fsd->cancellations_mtx);
 216	list_add(&cancellation->list, &fsd->cancellations);
 217	mutex_unlock(&fsd->cancellations_mtx);
 218
 219	/* if we're already removing wake it up to cancel */
 220	if (d_unlinked(dentry))
 221		complete(&fsd->active_users_drained);
 222}
 223EXPORT_SYMBOL_GPL(debugfs_enter_cancellation);
 224
 225/**
 226 * debugfs_leave_cancellation - leave cancellation section
 227 * @file: the file being accessed
 228 * @cancellation: the cancellation previously registered with
 229 *	debugfs_enter_cancellation()
 230 *
 231 * See the documentation of debugfs_enter_cancellation().
 232 */
 233void debugfs_leave_cancellation(struct file *file,
 234				struct debugfs_cancellation *cancellation)
 235{
 236	struct debugfs_fsdata *fsd;
 237	struct dentry *dentry = F_DENTRY(file);
 238
 239	if (WARN_ON(!d_is_reg(dentry)))
 240		return;
 241
 242	fsd = READ_ONCE(dentry->d_fsdata);
 243	if (WARN_ON(!fsd ||
 244		    ((unsigned long)fsd & DEBUGFS_FSDATA_IS_REAL_FOPS_BIT)))
 245		return;
 246
 247	mutex_lock(&fsd->cancellations_mtx);
 248	if (!list_empty(&cancellation->list))
 249		list_del(&cancellation->list);
 250	mutex_unlock(&fsd->cancellations_mtx);
 251}
 252EXPORT_SYMBOL_GPL(debugfs_leave_cancellation);
 253
 254/*
 255 * Only permit access to world-readable files when the kernel is locked down.
 256 * We also need to exclude any file that has ways to write or alter it as root
 257 * can bypass the permissions check.
 258 */
 259static int debugfs_locked_down(struct inode *inode,
 260			       struct file *filp,
 261			       const struct file_operations *real_fops)
 262{
 263	if ((inode->i_mode & 07777 & ~0444) == 0 &&
 264	    !(filp->f_mode & FMODE_WRITE) &&
 265	    (!real_fops ||
 266	     (!real_fops->unlocked_ioctl &&
 267	      !real_fops->compat_ioctl &&
 268	      !real_fops->mmap)))
 269		return 0;
 270
 271	if (security_locked_down(LOCKDOWN_DEBUGFS))
 272		return -EPERM;
 273
 274	return 0;
 275}
 276
 277static int open_proxy_open(struct inode *inode, struct file *filp)
 278{
 279	struct dentry *dentry = F_DENTRY(filp);
 280	const struct file_operations *real_fops = NULL;
 281	int r;
 282
 283	r = __debugfs_file_get(dentry, DBGFS_GET_REGULAR);
 284	if (r)
 285		return r == -EIO ? -ENOENT : r;
 286
 287	real_fops = debugfs_real_fops(filp);
 288
 289	r = debugfs_locked_down(inode, filp, real_fops);
 290	if (r)
 291		goto out;
 292
 293	if (!fops_get(real_fops)) {
 294#ifdef CONFIG_MODULES
 295		if (real_fops->owner &&
 296		    real_fops->owner->state == MODULE_STATE_GOING) {
 297			r = -ENXIO;
 298			goto out;
 299		}
 300#endif
 301
 302		/* Huh? Module did not clean up after itself at exit? */
 303		WARN(1, "debugfs file owner did not clean up at exit: %pd",
 304			dentry);
 305		r = -ENXIO;
 306		goto out;
 307	}
 308	replace_fops(filp, real_fops);
 309
 310	if (real_fops->open)
 311		r = real_fops->open(inode, filp);
 312
 313out:
 314	debugfs_file_put(dentry);
 315	return r;
 316}
 317
 318const struct file_operations debugfs_open_proxy_file_operations = {
 319	.open = open_proxy_open,
 320};
 321
 322#define PROTO(args...) args
 323#define ARGS(args...) args
 324
 325#define FULL_PROXY_FUNC(name, ret_type, filp, proto, args)		\
 326static ret_type full_proxy_ ## name(proto)				\
 327{									\
 328	struct dentry *dentry = F_DENTRY(filp);			\
 329	const struct file_operations *real_fops;			\
 330	ret_type r;							\
 331									\
 332	r = debugfs_file_get(dentry);					\
 333	if (unlikely(r))						\
 334		return r;						\
 335	real_fops = debugfs_real_fops(filp);				\
 336	r = real_fops->name(args);					\
 337	debugfs_file_put(dentry);					\
 338	return r;							\
 339}
 340
 341#define FULL_PROXY_FUNC_BOTH(name, ret_type, filp, proto, args)		\
 342static ret_type full_proxy_ ## name(proto)				\
 343{									\
 344	struct dentry *dentry = F_DENTRY(filp);				\
 345	struct debugfs_fsdata *fsd;					\
 346	ret_type r;							\
 347									\
 348	r = debugfs_file_get(dentry);					\
 349	if (unlikely(r))						\
 350		return r;						\
 351	fsd = dentry->d_fsdata;						\
 352	if (fsd->real_fops)						\
 353		r = fsd->real_fops->name(args);				\
 354	else								\
 355		r = fsd->short_fops->name(args);			\
 356	debugfs_file_put(dentry);					\
 357	return r;							\
 358}
 359
 360FULL_PROXY_FUNC_BOTH(llseek, loff_t, filp,
 361		     PROTO(struct file *filp, loff_t offset, int whence),
 362		     ARGS(filp, offset, whence));
 363
 364FULL_PROXY_FUNC_BOTH(read, ssize_t, filp,
 365		     PROTO(struct file *filp, char __user *buf, size_t size,
 366			   loff_t *ppos),
 367		     ARGS(filp, buf, size, ppos));
 368
 369FULL_PROXY_FUNC_BOTH(write, ssize_t, filp,
 370		     PROTO(struct file *filp, const char __user *buf,
 371			   size_t size, loff_t *ppos),
 372		     ARGS(filp, buf, size, ppos));
 373
 374FULL_PROXY_FUNC(unlocked_ioctl, long, filp,
 375		PROTO(struct file *filp, unsigned int cmd, unsigned long arg),
 376		ARGS(filp, cmd, arg));
 377
 378static __poll_t full_proxy_poll(struct file *filp,
 379				struct poll_table_struct *wait)
 380{
 381	struct dentry *dentry = F_DENTRY(filp);
 382	__poll_t r = 0;
 383	const struct file_operations *real_fops;
 384
 385	if (debugfs_file_get(dentry))
 386		return EPOLLHUP;
 387
 388	real_fops = debugfs_real_fops(filp);
 389	r = real_fops->poll(filp, wait);
 390	debugfs_file_put(dentry);
 391	return r;
 392}
 393
 394static int full_proxy_release(struct inode *inode, struct file *filp)
 395{
 396	const struct dentry *dentry = F_DENTRY(filp);
 397	const struct file_operations *real_fops = debugfs_real_fops(filp);
 398	const struct file_operations *proxy_fops = filp->f_op;
 399	int r = 0;
 400
 401	/*
 402	 * We must not protect this against removal races here: the
 403	 * original releaser should be called unconditionally in order
 404	 * not to leak any resources. Releasers must not assume that
 405	 * ->i_private is still being meaningful here.
 406	 */
 407	if (real_fops && real_fops->release)
 408		r = real_fops->release(inode, filp);
 409
 410	replace_fops(filp, d_inode(dentry)->i_fop);
 411	kfree(proxy_fops);
 412	fops_put(real_fops);
 413	return r;
 414}
 415
 416static void __full_proxy_fops_init(struct file_operations *proxy_fops,
 417				   struct debugfs_fsdata *fsd)
 418{
 419	proxy_fops->release = full_proxy_release;
 420
 421	if ((fsd->real_fops && fsd->real_fops->llseek) ||
 422	    (fsd->short_fops && fsd->short_fops->llseek))
 423		proxy_fops->llseek = full_proxy_llseek;
 424
 425	if ((fsd->real_fops && fsd->real_fops->read) ||
 426	    (fsd->short_fops && fsd->short_fops->read))
 427		proxy_fops->read = full_proxy_read;
 428
 429	if ((fsd->real_fops && fsd->real_fops->write) ||
 430	    (fsd->short_fops && fsd->short_fops->write))
 431		proxy_fops->write = full_proxy_write;
 432
 433	if (fsd->real_fops && fsd->real_fops->poll)
 434		proxy_fops->poll = full_proxy_poll;
 435
 436	if (fsd->real_fops && fsd->real_fops->unlocked_ioctl)
 437		proxy_fops->unlocked_ioctl = full_proxy_unlocked_ioctl;
 438}
 439
 440static int full_proxy_open(struct inode *inode, struct file *filp,
 441			   enum dbgfs_get_mode mode)
 442{
 443	struct dentry *dentry = F_DENTRY(filp);
 444	const struct file_operations *real_fops;
 445	struct file_operations *proxy_fops = NULL;
 446	struct debugfs_fsdata *fsd;
 447	int r;
 448
 449	r = __debugfs_file_get(dentry, mode);
 450	if (r)
 451		return r == -EIO ? -ENOENT : r;
 452
 453	fsd = dentry->d_fsdata;
 454	real_fops = fsd->real_fops;
 455	r = debugfs_locked_down(inode, filp, real_fops);
 456	if (r)
 457		goto out;
 458
 459	if (real_fops && !fops_get(real_fops)) {
 460#ifdef CONFIG_MODULES
 461		if (real_fops->owner &&
 462		    real_fops->owner->state == MODULE_STATE_GOING) {
 463			r = -ENXIO;
 464			goto out;
 465		}
 466#endif
 467
 468		/* Huh? Module did not cleanup after itself at exit? */
 469		WARN(1, "debugfs file owner did not clean up at exit: %pd",
 470			dentry);
 471		r = -ENXIO;
 472		goto out;
 473	}
 474
 475	proxy_fops = kzalloc(sizeof(*proxy_fops), GFP_KERNEL);
 476	if (!proxy_fops) {
 477		r = -ENOMEM;
 478		goto free_proxy;
 479	}
 480	__full_proxy_fops_init(proxy_fops, fsd);
 481	replace_fops(filp, proxy_fops);
 482
 483	if (!real_fops || real_fops->open) {
 484		if (real_fops)
 485			r = real_fops->open(inode, filp);
 486		else
 487			r = simple_open(inode, filp);
 488		if (r) {
 489			replace_fops(filp, d_inode(dentry)->i_fop);
 490			goto free_proxy;
 491		} else if (filp->f_op != proxy_fops) {
 492			/* No protection against file removal anymore. */
 493			WARN(1, "debugfs file owner replaced proxy fops: %pd",
 494				dentry);
 495			goto free_proxy;
 496		}
 497	}
 498
 499	goto out;
 500free_proxy:
 501	kfree(proxy_fops);
 502	fops_put(real_fops);
 503out:
 504	debugfs_file_put(dentry);
 505	return r;
 506}
 507
 508static int full_proxy_open_regular(struct inode *inode, struct file *filp)
 509{
 510	return full_proxy_open(inode, filp, DBGFS_GET_REGULAR);
 511}
 512
 513const struct file_operations debugfs_full_proxy_file_operations = {
 514	.open = full_proxy_open_regular,
 515};
 516
 517static int full_proxy_open_short(struct inode *inode, struct file *filp)
 518{
 519	return full_proxy_open(inode, filp, DBGFS_GET_SHORT);
 520}
 521
 522const struct file_operations debugfs_full_short_proxy_file_operations = {
 523	.open = full_proxy_open_short,
 524};
 525
 526ssize_t debugfs_attr_read(struct file *file, char __user *buf,
 527			size_t len, loff_t *ppos)
 528{
 529	struct dentry *dentry = F_DENTRY(file);
 530	ssize_t ret;
 531
 532	ret = debugfs_file_get(dentry);
 533	if (unlikely(ret))
 534		return ret;
 535	ret = simple_attr_read(file, buf, len, ppos);
 536	debugfs_file_put(dentry);
 537	return ret;
 538}
 539EXPORT_SYMBOL_GPL(debugfs_attr_read);
 540
 541static ssize_t debugfs_attr_write_xsigned(struct file *file, const char __user *buf,
 542			 size_t len, loff_t *ppos, bool is_signed)
 543{
 544	struct dentry *dentry = F_DENTRY(file);
 545	ssize_t ret;
 546
 547	ret = debugfs_file_get(dentry);
 548	if (unlikely(ret))
 549		return ret;
 550	if (is_signed)
 551		ret = simple_attr_write_signed(file, buf, len, ppos);
 552	else
 553		ret = simple_attr_write(file, buf, len, ppos);
 554	debugfs_file_put(dentry);
 555	return ret;
 556}
 557
 558ssize_t debugfs_attr_write(struct file *file, const char __user *buf,
 559			 size_t len, loff_t *ppos)
 560{
 561	return debugfs_attr_write_xsigned(file, buf, len, ppos, false);
 562}
 563EXPORT_SYMBOL_GPL(debugfs_attr_write);
 564
 565ssize_t debugfs_attr_write_signed(struct file *file, const char __user *buf,
 566			 size_t len, loff_t *ppos)
 567{
 568	return debugfs_attr_write_xsigned(file, buf, len, ppos, true);
 569}
 570EXPORT_SYMBOL_GPL(debugfs_attr_write_signed);
 571
 572static struct dentry *debugfs_create_mode_unsafe(const char *name, umode_t mode,
 573					struct dentry *parent, void *value,
 574					const struct file_operations *fops,
 575					const struct file_operations *fops_ro,
 576					const struct file_operations *fops_wo)
 577{
 578	/* if there are no write bits set, make read only */
 579	if (!(mode & S_IWUGO))
 580		return debugfs_create_file_unsafe(name, mode, parent, value,
 581						fops_ro);
 582	/* if there are no read bits set, make write only */
 583	if (!(mode & S_IRUGO))
 584		return debugfs_create_file_unsafe(name, mode, parent, value,
 585						fops_wo);
 586
 587	return debugfs_create_file_unsafe(name, mode, parent, value, fops);
 588}
 589
 590static int debugfs_u8_set(void *data, u64 val)
 591{
 592	*(u8 *)data = val;
 593	return 0;
 594}
 595static int debugfs_u8_get(void *data, u64 *val)
 596{
 597	*val = *(u8 *)data;
 598	return 0;
 599}
 600DEFINE_DEBUGFS_ATTRIBUTE(fops_u8, debugfs_u8_get, debugfs_u8_set, "%llu\n");
 601DEFINE_DEBUGFS_ATTRIBUTE(fops_u8_ro, debugfs_u8_get, NULL, "%llu\n");
 602DEFINE_DEBUGFS_ATTRIBUTE(fops_u8_wo, NULL, debugfs_u8_set, "%llu\n");
 603
 604/**
 605 * debugfs_create_u8 - create a debugfs file that is used to read and write an unsigned 8-bit value
 606 * @name: a pointer to a string containing the name of the file to create.
 607 * @mode: the permission that the file should have
 608 * @parent: a pointer to the parent dentry for this file.  This should be a
 609 *          directory dentry if set.  If this parameter is %NULL, then the
 610 *          file will be created in the root of the debugfs filesystem.
 611 * @value: a pointer to the variable that the file should read to and write
 612 *         from.
 613 *
 614 * This function creates a file in debugfs with the given name that
 615 * contains the value of the variable @value.  If the @mode variable is so
 616 * set, it can be read from, and written to.
 
 
 
 
 
 
 
 
 
 
 617 */
 618void debugfs_create_u8(const char *name, umode_t mode, struct dentry *parent,
 619		       u8 *value)
 620{
 621	debugfs_create_mode_unsafe(name, mode, parent, value, &fops_u8,
 622				   &fops_u8_ro, &fops_u8_wo);
 623}
 624EXPORT_SYMBOL_GPL(debugfs_create_u8);
 625
 626static int debugfs_u16_set(void *data, u64 val)
 627{
 628	*(u16 *)data = val;
 629	return 0;
 630}
 631static int debugfs_u16_get(void *data, u64 *val)
 632{
 633	*val = *(u16 *)data;
 634	return 0;
 635}
 636DEFINE_DEBUGFS_ATTRIBUTE(fops_u16, debugfs_u16_get, debugfs_u16_set, "%llu\n");
 637DEFINE_DEBUGFS_ATTRIBUTE(fops_u16_ro, debugfs_u16_get, NULL, "%llu\n");
 638DEFINE_DEBUGFS_ATTRIBUTE(fops_u16_wo, NULL, debugfs_u16_set, "%llu\n");
 639
 640/**
 641 * debugfs_create_u16 - create a debugfs file that is used to read and write an unsigned 16-bit value
 642 * @name: a pointer to a string containing the name of the file to create.
 643 * @mode: the permission that the file should have
 644 * @parent: a pointer to the parent dentry for this file.  This should be a
 645 *          directory dentry if set.  If this parameter is %NULL, then the
 646 *          file will be created in the root of the debugfs filesystem.
 647 * @value: a pointer to the variable that the file should read to and write
 648 *         from.
 649 *
 650 * This function creates a file in debugfs with the given name that
 651 * contains the value of the variable @value.  If the @mode variable is so
 652 * set, it can be read from, and written to.
 
 
 
 
 
 
 
 
 
 
 653 */
 654void debugfs_create_u16(const char *name, umode_t mode, struct dentry *parent,
 655			u16 *value)
 656{
 657	debugfs_create_mode_unsafe(name, mode, parent, value, &fops_u16,
 658				   &fops_u16_ro, &fops_u16_wo);
 659}
 660EXPORT_SYMBOL_GPL(debugfs_create_u16);
 661
 662static int debugfs_u32_set(void *data, u64 val)
 663{
 664	*(u32 *)data = val;
 665	return 0;
 666}
 667static int debugfs_u32_get(void *data, u64 *val)
 668{
 669	*val = *(u32 *)data;
 670	return 0;
 671}
 672DEFINE_DEBUGFS_ATTRIBUTE(fops_u32, debugfs_u32_get, debugfs_u32_set, "%llu\n");
 673DEFINE_DEBUGFS_ATTRIBUTE(fops_u32_ro, debugfs_u32_get, NULL, "%llu\n");
 674DEFINE_DEBUGFS_ATTRIBUTE(fops_u32_wo, NULL, debugfs_u32_set, "%llu\n");
 675
 676/**
 677 * debugfs_create_u32 - create a debugfs file that is used to read and write an unsigned 32-bit value
 678 * @name: a pointer to a string containing the name of the file to create.
 679 * @mode: the permission that the file should have
 680 * @parent: a pointer to the parent dentry for this file.  This should be a
 681 *          directory dentry if set.  If this parameter is %NULL, then the
 682 *          file will be created in the root of the debugfs filesystem.
 683 * @value: a pointer to the variable that the file should read to and write
 684 *         from.
 685 *
 686 * This function creates a file in debugfs with the given name that
 687 * contains the value of the variable @value.  If the @mode variable is so
 688 * set, it can be read from, and written to.
 
 
 
 
 
 
 
 
 
 
 689 */
 690void debugfs_create_u32(const char *name, umode_t mode, struct dentry *parent,
 691			u32 *value)
 692{
 693	debugfs_create_mode_unsafe(name, mode, parent, value, &fops_u32,
 694				   &fops_u32_ro, &fops_u32_wo);
 695}
 696EXPORT_SYMBOL_GPL(debugfs_create_u32);
 697
 698static int debugfs_u64_set(void *data, u64 val)
 699{
 700	*(u64 *)data = val;
 701	return 0;
 702}
 703
 704static int debugfs_u64_get(void *data, u64 *val)
 705{
 706	*val = *(u64 *)data;
 707	return 0;
 708}
 709DEFINE_DEBUGFS_ATTRIBUTE(fops_u64, debugfs_u64_get, debugfs_u64_set, "%llu\n");
 710DEFINE_DEBUGFS_ATTRIBUTE(fops_u64_ro, debugfs_u64_get, NULL, "%llu\n");
 711DEFINE_DEBUGFS_ATTRIBUTE(fops_u64_wo, NULL, debugfs_u64_set, "%llu\n");
 712
 713/**
 714 * debugfs_create_u64 - create a debugfs file that is used to read and write an unsigned 64-bit value
 715 * @name: a pointer to a string containing the name of the file to create.
 716 * @mode: the permission that the file should have
 717 * @parent: a pointer to the parent dentry for this file.  This should be a
 718 *          directory dentry if set.  If this parameter is %NULL, then the
 719 *          file will be created in the root of the debugfs filesystem.
 720 * @value: a pointer to the variable that the file should read to and write
 721 *         from.
 722 *
 723 * This function creates a file in debugfs with the given name that
 724 * contains the value of the variable @value.  If the @mode variable is so
 725 * set, it can be read from, and written to.
 
 
 
 
 
 
 
 
 
 
 726 */
 727void debugfs_create_u64(const char *name, umode_t mode, struct dentry *parent,
 728			u64 *value)
 729{
 730	debugfs_create_mode_unsafe(name, mode, parent, value, &fops_u64,
 731				   &fops_u64_ro, &fops_u64_wo);
 732}
 733EXPORT_SYMBOL_GPL(debugfs_create_u64);
 734
 735static int debugfs_ulong_set(void *data, u64 val)
 736{
 737	*(unsigned long *)data = val;
 738	return 0;
 739}
 740
 741static int debugfs_ulong_get(void *data, u64 *val)
 742{
 743	*val = *(unsigned long *)data;
 744	return 0;
 745}
 746DEFINE_DEBUGFS_ATTRIBUTE(fops_ulong, debugfs_ulong_get, debugfs_ulong_set,
 747			"%llu\n");
 748DEFINE_DEBUGFS_ATTRIBUTE(fops_ulong_ro, debugfs_ulong_get, NULL, "%llu\n");
 749DEFINE_DEBUGFS_ATTRIBUTE(fops_ulong_wo, NULL, debugfs_ulong_set, "%llu\n");
 750
 751/**
 752 * debugfs_create_ulong - create a debugfs file that is used to read and write
 753 * an unsigned long value.
 754 * @name: a pointer to a string containing the name of the file to create.
 755 * @mode: the permission that the file should have
 756 * @parent: a pointer to the parent dentry for this file.  This should be a
 757 *          directory dentry if set.  If this parameter is %NULL, then the
 758 *          file will be created in the root of the debugfs filesystem.
 759 * @value: a pointer to the variable that the file should read to and write
 760 *         from.
 761 *
 762 * This function creates a file in debugfs with the given name that
 763 * contains the value of the variable @value.  If the @mode variable is so
 764 * set, it can be read from, and written to.
 
 
 
 
 
 
 
 
 
 
 765 */
 766void debugfs_create_ulong(const char *name, umode_t mode, struct dentry *parent,
 767			  unsigned long *value)
 768{
 769	debugfs_create_mode_unsafe(name, mode, parent, value, &fops_ulong,
 770				   &fops_ulong_ro, &fops_ulong_wo);
 771}
 772EXPORT_SYMBOL_GPL(debugfs_create_ulong);
 773
 774DEFINE_DEBUGFS_ATTRIBUTE(fops_x8, debugfs_u8_get, debugfs_u8_set, "0x%02llx\n");
 775DEFINE_DEBUGFS_ATTRIBUTE(fops_x8_ro, debugfs_u8_get, NULL, "0x%02llx\n");
 776DEFINE_DEBUGFS_ATTRIBUTE(fops_x8_wo, NULL, debugfs_u8_set, "0x%02llx\n");
 777
 778DEFINE_DEBUGFS_ATTRIBUTE(fops_x16, debugfs_u16_get, debugfs_u16_set,
 779			"0x%04llx\n");
 780DEFINE_DEBUGFS_ATTRIBUTE(fops_x16_ro, debugfs_u16_get, NULL, "0x%04llx\n");
 781DEFINE_DEBUGFS_ATTRIBUTE(fops_x16_wo, NULL, debugfs_u16_set, "0x%04llx\n");
 782
 783DEFINE_DEBUGFS_ATTRIBUTE(fops_x32, debugfs_u32_get, debugfs_u32_set,
 784			"0x%08llx\n");
 785DEFINE_DEBUGFS_ATTRIBUTE(fops_x32_ro, debugfs_u32_get, NULL, "0x%08llx\n");
 786DEFINE_DEBUGFS_ATTRIBUTE(fops_x32_wo, NULL, debugfs_u32_set, "0x%08llx\n");
 787
 788DEFINE_DEBUGFS_ATTRIBUTE(fops_x64, debugfs_u64_get, debugfs_u64_set,
 789			"0x%016llx\n");
 790DEFINE_DEBUGFS_ATTRIBUTE(fops_x64_ro, debugfs_u64_get, NULL, "0x%016llx\n");
 791DEFINE_DEBUGFS_ATTRIBUTE(fops_x64_wo, NULL, debugfs_u64_set, "0x%016llx\n");
 792
 793/*
 794 * debugfs_create_x{8,16,32,64} - create a debugfs file that is used to read and write an unsigned {8,16,32,64}-bit value
 795 *
 796 * These functions are exactly the same as the above functions (but use a hex
 797 * output for the decimal challenged). For details look at the above unsigned
 798 * decimal functions.
 799 */
 800
 801/**
 802 * debugfs_create_x8 - create a debugfs file that is used to read and write an unsigned 8-bit value
 803 * @name: a pointer to a string containing the name of the file to create.
 804 * @mode: the permission that the file should have
 805 * @parent: a pointer to the parent dentry for this file.  This should be a
 806 *          directory dentry if set.  If this parameter is %NULL, then the
 807 *          file will be created in the root of the debugfs filesystem.
 808 * @value: a pointer to the variable that the file should read to and write
 809 *         from.
 810 */
 811void debugfs_create_x8(const char *name, umode_t mode, struct dentry *parent,
 812		       u8 *value)
 813{
 814	debugfs_create_mode_unsafe(name, mode, parent, value, &fops_x8,
 815				   &fops_x8_ro, &fops_x8_wo);
 816}
 817EXPORT_SYMBOL_GPL(debugfs_create_x8);
 818
 819/**
 820 * debugfs_create_x16 - create a debugfs file that is used to read and write an unsigned 16-bit value
 821 * @name: a pointer to a string containing the name of the file to create.
 822 * @mode: the permission that the file should have
 823 * @parent: a pointer to the parent dentry for this file.  This should be a
 824 *          directory dentry if set.  If this parameter is %NULL, then the
 825 *          file will be created in the root of the debugfs filesystem.
 826 * @value: a pointer to the variable that the file should read to and write
 827 *         from.
 828 */
 829void debugfs_create_x16(const char *name, umode_t mode, struct dentry *parent,
 830			u16 *value)
 831{
 832	debugfs_create_mode_unsafe(name, mode, parent, value, &fops_x16,
 833				   &fops_x16_ro, &fops_x16_wo);
 834}
 835EXPORT_SYMBOL_GPL(debugfs_create_x16);
 836
 837/**
 838 * debugfs_create_x32 - create a debugfs file that is used to read and write an unsigned 32-bit value
 839 * @name: a pointer to a string containing the name of the file to create.
 840 * @mode: the permission that the file should have
 841 * @parent: a pointer to the parent dentry for this file.  This should be a
 842 *          directory dentry if set.  If this parameter is %NULL, then the
 843 *          file will be created in the root of the debugfs filesystem.
 844 * @value: a pointer to the variable that the file should read to and write
 845 *         from.
 846 */
 847void debugfs_create_x32(const char *name, umode_t mode, struct dentry *parent,
 848			u32 *value)
 849{
 850	debugfs_create_mode_unsafe(name, mode, parent, value, &fops_x32,
 851				   &fops_x32_ro, &fops_x32_wo);
 852}
 853EXPORT_SYMBOL_GPL(debugfs_create_x32);
 854
 855/**
 856 * debugfs_create_x64 - create a debugfs file that is used to read and write an unsigned 64-bit value
 857 * @name: a pointer to a string containing the name of the file to create.
 858 * @mode: the permission that the file should have
 859 * @parent: a pointer to the parent dentry for this file.  This should be a
 860 *          directory dentry if set.  If this parameter is %NULL, then the
 861 *          file will be created in the root of the debugfs filesystem.
 862 * @value: a pointer to the variable that the file should read to and write
 863 *         from.
 864 */
 865void debugfs_create_x64(const char *name, umode_t mode, struct dentry *parent,
 866			u64 *value)
 867{
 868	debugfs_create_mode_unsafe(name, mode, parent, value, &fops_x64,
 869				   &fops_x64_ro, &fops_x64_wo);
 870}
 871EXPORT_SYMBOL_GPL(debugfs_create_x64);
 872
 873
 874static int debugfs_size_t_set(void *data, u64 val)
 875{
 876	*(size_t *)data = val;
 877	return 0;
 878}
 879static int debugfs_size_t_get(void *data, u64 *val)
 880{
 881	*val = *(size_t *)data;
 882	return 0;
 883}
 884DEFINE_DEBUGFS_ATTRIBUTE(fops_size_t, debugfs_size_t_get, debugfs_size_t_set,
 885			"%llu\n"); /* %llu and %zu are more or less the same */
 886DEFINE_DEBUGFS_ATTRIBUTE(fops_size_t_ro, debugfs_size_t_get, NULL, "%llu\n");
 887DEFINE_DEBUGFS_ATTRIBUTE(fops_size_t_wo, NULL, debugfs_size_t_set, "%llu\n");
 888
 889/**
 890 * debugfs_create_size_t - create a debugfs file that is used to read and write an size_t value
 891 * @name: a pointer to a string containing the name of the file to create.
 892 * @mode: the permission that the file should have
 893 * @parent: a pointer to the parent dentry for this file.  This should be a
 894 *          directory dentry if set.  If this parameter is %NULL, then the
 895 *          file will be created in the root of the debugfs filesystem.
 896 * @value: a pointer to the variable that the file should read to and write
 897 *         from.
 898 */
 899void debugfs_create_size_t(const char *name, umode_t mode,
 900			   struct dentry *parent, size_t *value)
 901{
 902	debugfs_create_mode_unsafe(name, mode, parent, value, &fops_size_t,
 903				   &fops_size_t_ro, &fops_size_t_wo);
 904}
 905EXPORT_SYMBOL_GPL(debugfs_create_size_t);
 906
 907static int debugfs_atomic_t_set(void *data, u64 val)
 908{
 909	atomic_set((atomic_t *)data, val);
 910	return 0;
 911}
 912static int debugfs_atomic_t_get(void *data, u64 *val)
 913{
 914	*val = atomic_read((atomic_t *)data);
 915	return 0;
 916}
 917DEFINE_DEBUGFS_ATTRIBUTE_SIGNED(fops_atomic_t, debugfs_atomic_t_get,
 918			debugfs_atomic_t_set, "%lld\n");
 919DEFINE_DEBUGFS_ATTRIBUTE_SIGNED(fops_atomic_t_ro, debugfs_atomic_t_get, NULL,
 920			"%lld\n");
 921DEFINE_DEBUGFS_ATTRIBUTE_SIGNED(fops_atomic_t_wo, NULL, debugfs_atomic_t_set,
 922			"%lld\n");
 923
 924/**
 925 * debugfs_create_atomic_t - create a debugfs file that is used to read and
 926 * write an atomic_t value
 927 * @name: a pointer to a string containing the name of the file to create.
 928 * @mode: the permission that the file should have
 929 * @parent: a pointer to the parent dentry for this file.  This should be a
 930 *          directory dentry if set.  If this parameter is %NULL, then the
 931 *          file will be created in the root of the debugfs filesystem.
 932 * @value: a pointer to the variable that the file should read to and write
 933 *         from.
 934 */
 935void debugfs_create_atomic_t(const char *name, umode_t mode,
 936			     struct dentry *parent, atomic_t *value)
 937{
 938	debugfs_create_mode_unsafe(name, mode, parent, value, &fops_atomic_t,
 939				   &fops_atomic_t_ro, &fops_atomic_t_wo);
 940}
 941EXPORT_SYMBOL_GPL(debugfs_create_atomic_t);
 942
 943ssize_t debugfs_read_file_bool(struct file *file, char __user *user_buf,
 944			       size_t count, loff_t *ppos)
 945{
 946	char buf[2];
 947	bool val;
 948	int r;
 949	struct dentry *dentry = F_DENTRY(file);
 950
 951	r = debugfs_file_get(dentry);
 952	if (unlikely(r))
 953		return r;
 954	val = *(bool *)file->private_data;
 955	debugfs_file_put(dentry);
 956
 957	if (val)
 958		buf[0] = 'Y';
 959	else
 960		buf[0] = 'N';
 961	buf[1] = '\n';
 
 962	return simple_read_from_buffer(user_buf, count, ppos, buf, 2);
 963}
 964EXPORT_SYMBOL_GPL(debugfs_read_file_bool);
 965
 966ssize_t debugfs_write_file_bool(struct file *file, const char __user *user_buf,
 967				size_t count, loff_t *ppos)
 968{
 
 
 969	bool bv;
 970	int r;
 971	bool *val = file->private_data;
 972	struct dentry *dentry = F_DENTRY(file);
 973
 974	r = kstrtobool_from_user(user_buf, count, &bv);
 975	if (!r) {
 976		r = debugfs_file_get(dentry);
 977		if (unlikely(r))
 978			return r;
 
 979		*val = bv;
 980		debugfs_file_put(dentry);
 981	}
 982
 983	return count;
 984}
 985EXPORT_SYMBOL_GPL(debugfs_write_file_bool);
 986
 987static const struct file_operations fops_bool = {
 988	.read =		debugfs_read_file_bool,
 989	.write =	debugfs_write_file_bool,
 990	.open =		simple_open,
 991	.llseek =	default_llseek,
 992};
 993
 994static const struct file_operations fops_bool_ro = {
 995	.read =		debugfs_read_file_bool,
 996	.open =		simple_open,
 997	.llseek =	default_llseek,
 998};
 999
1000static const struct file_operations fops_bool_wo = {
1001	.write =	debugfs_write_file_bool,
1002	.open =		simple_open,
1003	.llseek =	default_llseek,
1004};
1005
1006/**
1007 * debugfs_create_bool - create a debugfs file that is used to read and write a boolean value
1008 * @name: a pointer to a string containing the name of the file to create.
1009 * @mode: the permission that the file should have
1010 * @parent: a pointer to the parent dentry for this file.  This should be a
1011 *          directory dentry if set.  If this parameter is %NULL, then the
1012 *          file will be created in the root of the debugfs filesystem.
1013 * @value: a pointer to the variable that the file should read to and write
1014 *         from.
1015 *
1016 * This function creates a file in debugfs with the given name that
1017 * contains the value of the variable @value.  If the @mode variable is so
1018 * set, it can be read from, and written to.
 
 
 
 
 
 
 
 
 
 
1019 */
1020void debugfs_create_bool(const char *name, umode_t mode, struct dentry *parent,
1021			 bool *value)
1022{
1023	debugfs_create_mode_unsafe(name, mode, parent, value, &fops_bool,
1024				   &fops_bool_ro, &fops_bool_wo);
1025}
1026EXPORT_SYMBOL_GPL(debugfs_create_bool);
1027
1028ssize_t debugfs_read_file_str(struct file *file, char __user *user_buf,
1029			      size_t count, loff_t *ppos)
1030{
1031	struct dentry *dentry = F_DENTRY(file);
1032	char *str, *copy = NULL;
1033	int copy_len, len;
1034	ssize_t ret;
1035
1036	ret = debugfs_file_get(dentry);
1037	if (unlikely(ret))
1038		return ret;
1039
1040	str = *(char **)file->private_data;
1041	len = strlen(str) + 1;
1042	copy = kmalloc(len, GFP_KERNEL);
1043	if (!copy) {
1044		debugfs_file_put(dentry);
1045		return -ENOMEM;
1046	}
1047
1048	copy_len = strscpy(copy, str, len);
1049	debugfs_file_put(dentry);
1050	if (copy_len < 0) {
1051		kfree(copy);
1052		return copy_len;
1053	}
1054
1055	copy[copy_len] = '\n';
1056
1057	ret = simple_read_from_buffer(user_buf, count, ppos, copy, len);
1058	kfree(copy);
1059
1060	return ret;
1061}
1062EXPORT_SYMBOL_GPL(debugfs_create_str);
1063
1064static ssize_t debugfs_write_file_str(struct file *file, const char __user *user_buf,
1065				      size_t count, loff_t *ppos)
1066{
1067	struct dentry *dentry = F_DENTRY(file);
1068	char *old, *new = NULL;
1069	int pos = *ppos;
1070	int r;
1071
1072	r = debugfs_file_get(dentry);
1073	if (unlikely(r))
1074		return r;
1075
1076	old = *(char **)file->private_data;
1077
1078	/* only allow strict concatenation */
1079	r = -EINVAL;
1080	if (pos && pos != strlen(old))
1081		goto error;
1082
1083	r = -E2BIG;
1084	if (pos + count + 1 > PAGE_SIZE)
1085		goto error;
1086
1087	r = -ENOMEM;
1088	new = kmalloc(pos + count + 1, GFP_KERNEL);
1089	if (!new)
1090		goto error;
1091
1092	if (pos)
1093		memcpy(new, old, pos);
1094
1095	r = -EFAULT;
1096	if (copy_from_user(new + pos, user_buf, count))
1097		goto error;
1098
1099	new[pos + count] = '\0';
1100	strim(new);
1101
1102	rcu_assign_pointer(*(char __rcu **)file->private_data, new);
1103	synchronize_rcu();
1104	kfree(old);
1105
1106	debugfs_file_put(dentry);
1107	return count;
1108
1109error:
1110	kfree(new);
1111	debugfs_file_put(dentry);
1112	return r;
1113}
1114
1115static const struct file_operations fops_str = {
1116	.read =		debugfs_read_file_str,
1117	.write =	debugfs_write_file_str,
1118	.open =		simple_open,
1119	.llseek =	default_llseek,
1120};
1121
1122static const struct file_operations fops_str_ro = {
1123	.read =		debugfs_read_file_str,
1124	.open =		simple_open,
1125	.llseek =	default_llseek,
1126};
1127
1128static const struct file_operations fops_str_wo = {
1129	.write =	debugfs_write_file_str,
1130	.open =		simple_open,
1131	.llseek =	default_llseek,
1132};
1133
1134/**
1135 * debugfs_create_str - create a debugfs file that is used to read and write a string value
1136 * @name: a pointer to a string containing the name of the file to create.
1137 * @mode: the permission that the file should have
1138 * @parent: a pointer to the parent dentry for this file.  This should be a
1139 *          directory dentry if set.  If this parameter is %NULL, then the
1140 *          file will be created in the root of the debugfs filesystem.
1141 * @value: a pointer to the variable that the file should read to and write
1142 *         from.
1143 *
1144 * This function creates a file in debugfs with the given name that
1145 * contains the value of the variable @value.  If the @mode variable is so
1146 * set, it can be read from, and written to.
1147 */
1148void debugfs_create_str(const char *name, umode_t mode,
1149			struct dentry *parent, char **value)
1150{
1151	debugfs_create_mode_unsafe(name, mode, parent, value, &fops_str,
1152				   &fops_str_ro, &fops_str_wo);
1153}
1154
1155static ssize_t read_file_blob(struct file *file, char __user *user_buf,
1156			      size_t count, loff_t *ppos)
1157{
1158	struct debugfs_blob_wrapper *blob = file->private_data;
1159	struct dentry *dentry = F_DENTRY(file);
1160	ssize_t r;
1161
1162	r = debugfs_file_get(dentry);
1163	if (unlikely(r))
1164		return r;
1165	r = simple_read_from_buffer(user_buf, count, ppos, blob->data,
1166				blob->size);
1167	debugfs_file_put(dentry);
1168	return r;
1169}
1170
1171static ssize_t write_file_blob(struct file *file, const char __user *user_buf,
1172			       size_t count, loff_t *ppos)
1173{
1174	struct debugfs_blob_wrapper *blob = file->private_data;
1175	struct dentry *dentry = F_DENTRY(file);
1176	ssize_t r;
1177
1178	r = debugfs_file_get(dentry);
1179	if (unlikely(r))
1180		return r;
1181	r = simple_write_to_buffer(blob->data, blob->size, ppos, user_buf,
1182				   count);
1183
1184	debugfs_file_put(dentry);
1185	return r;
1186}
1187
1188static const struct file_operations fops_blob = {
1189	.read =		read_file_blob,
1190	.write =	write_file_blob,
1191	.open =		simple_open,
1192	.llseek =	default_llseek,
1193};
1194
1195/**
1196 * debugfs_create_blob - create a debugfs file that is used to read and write
1197 * a binary blob
1198 * @name: a pointer to a string containing the name of the file to create.
1199 * @mode: the permission that the file should have
1200 * @parent: a pointer to the parent dentry for this file.  This should be a
1201 *          directory dentry if set.  If this parameter is %NULL, then the
1202 *          file will be created in the root of the debugfs filesystem.
1203 * @blob: a pointer to a struct debugfs_blob_wrapper which contains a pointer
1204 *        to the blob data and the size of the data.
1205 *
1206 * This function creates a file in debugfs with the given name that exports
1207 * @blob->data as a binary blob. If the @mode variable is so set it can be
1208 * read from and written to.
1209 *
1210 * This function will return a pointer to a dentry if it succeeds.  This
1211 * pointer must be passed to the debugfs_remove() function when the file is
1212 * to be removed (no automatic cleanup happens if your module is unloaded,
1213 * you are responsible here.)  If an error occurs, ERR_PTR(-ERROR) will be
1214 * returned.
1215 *
1216 * If debugfs is not enabled in the kernel, the value ERR_PTR(-ENODEV) will
1217 * be returned.
 
 
1218 */
1219struct dentry *debugfs_create_blob(const char *name, umode_t mode,
1220				   struct dentry *parent,
1221				   struct debugfs_blob_wrapper *blob)
1222{
1223	return debugfs_create_file_unsafe(name, mode & 0644, parent, blob, &fops_blob);
1224}
1225EXPORT_SYMBOL_GPL(debugfs_create_blob);
1226
 
 
 
 
 
1227static size_t u32_format_array(char *buf, size_t bufsize,
1228			       u32 *array, int array_size)
1229{
1230	size_t ret = 0;
1231
1232	while (--array_size >= 0) {
1233		size_t len;
1234		char term = array_size ? ' ' : '\n';
1235
1236		len = snprintf(buf, bufsize, "%u%c", *array++, term);
1237		ret += len;
1238
1239		buf += len;
1240		bufsize -= len;
1241	}
1242	return ret;
1243}
1244
1245static int u32_array_open(struct inode *inode, struct file *file)
1246{
1247	struct debugfs_u32_array *data = inode->i_private;
1248	int size, elements = data->n_elements;
1249	char *buf;
1250
1251	/*
1252	 * Max size:
1253	 *  - 10 digits + ' '/'\n' = 11 bytes per number
1254	 *  - terminating NUL character
1255	 */
1256	size = elements*11;
1257	buf = kmalloc(size+1, GFP_KERNEL);
1258	if (!buf)
1259		return -ENOMEM;
1260	buf[size] = 0;
1261
1262	file->private_data = buf;
1263	u32_format_array(buf, size, data->array, data->n_elements);
1264
1265	return nonseekable_open(inode, file);
1266}
1267
1268static ssize_t u32_array_read(struct file *file, char __user *buf, size_t len,
1269			      loff_t *ppos)
1270{
1271	size_t size = strlen(file->private_data);
1272
1273	return simple_read_from_buffer(buf, len, ppos,
1274					file->private_data, size);
1275}
1276
1277static int u32_array_release(struct inode *inode, struct file *file)
1278{
1279	kfree(file->private_data);
1280
1281	return 0;
1282}
1283
1284static const struct file_operations u32_array_fops = {
1285	.owner	 = THIS_MODULE,
1286	.open	 = u32_array_open,
1287	.release = u32_array_release,
1288	.read	 = u32_array_read,
 
1289};
1290
1291/**
1292 * debugfs_create_u32_array - create a debugfs file that is used to read u32
1293 * array.
1294 * @name: a pointer to a string containing the name of the file to create.
1295 * @mode: the permission that the file should have.
1296 * @parent: a pointer to the parent dentry for this file.  This should be a
1297 *          directory dentry if set.  If this parameter is %NULL, then the
1298 *          file will be created in the root of the debugfs filesystem.
1299 * @array: wrapper struct containing data pointer and size of the array.
 
1300 *
1301 * This function creates a file in debugfs with the given name that exports
1302 * @array as data. If the @mode variable is so set it can be read from.
1303 * Writing is not supported. Seek within the file is also not supported.
1304 * Once array is created its size can not be changed.
 
 
 
1305 */
1306void debugfs_create_u32_array(const char *name, umode_t mode,
1307			      struct dentry *parent,
1308			      struct debugfs_u32_array *array)
1309{
1310	debugfs_create_file_unsafe(name, mode, parent, array, &u32_array_fops);
 
 
 
 
 
 
 
 
1311}
1312EXPORT_SYMBOL_GPL(debugfs_create_u32_array);
1313
1314#ifdef CONFIG_HAS_IOMEM
1315
1316/*
1317 * The regset32 stuff is used to print 32-bit registers using the
1318 * seq_file utilities. We offer printing a register set in an already-opened
1319 * sequential file or create a debugfs file that only prints a regset32.
1320 */
1321
1322/**
1323 * debugfs_print_regs32 - use seq_print to describe a set of registers
1324 * @s: the seq_file structure being used to generate output
1325 * @regs: an array if struct debugfs_reg32 structures
1326 * @nregs: the length of the above array
1327 * @base: the base address to be used in reading the registers
1328 * @prefix: a string to be prefixed to every output line
1329 *
1330 * This function outputs a text block describing the current values of
1331 * some 32-bit hardware registers. It is meant to be used within debugfs
1332 * files based on seq_file that need to show registers, intermixed with other
1333 * information. The prefix argument may be used to specify a leading string,
1334 * because some peripherals have several blocks of identical registers,
1335 * for example configuration of dma channels
1336 */
1337void debugfs_print_regs32(struct seq_file *s, const struct debugfs_reg32 *regs,
1338			  int nregs, void __iomem *base, char *prefix)
1339{
1340	int i;
1341
1342	for (i = 0; i < nregs; i++, regs++) {
1343		if (prefix)
1344			seq_printf(s, "%s", prefix);
1345		seq_printf(s, "%s = 0x%08x\n", regs->name,
1346			   readl(base + regs->offset));
1347		if (seq_has_overflowed(s))
1348			break;
1349	}
1350}
1351EXPORT_SYMBOL_GPL(debugfs_print_regs32);
1352
1353static int debugfs_regset32_show(struct seq_file *s, void *data)
1354{
1355	struct debugfs_regset32 *regset = s->private;
1356
1357	if (regset->dev)
1358		pm_runtime_get_sync(regset->dev);
1359
1360	debugfs_print_regs32(s, regset->regs, regset->nregs, regset->base, "");
1361
1362	if (regset->dev)
1363		pm_runtime_put(regset->dev);
1364
1365	return 0;
1366}
1367
1368DEFINE_SHOW_ATTRIBUTE(debugfs_regset32);
 
 
 
 
 
 
 
 
 
 
1369
1370/**
1371 * debugfs_create_regset32 - create a debugfs file that returns register values
1372 * @name: a pointer to a string containing the name of the file to create.
1373 * @mode: the permission that the file should have
1374 * @parent: a pointer to the parent dentry for this file.  This should be a
1375 *          directory dentry if set.  If this parameter is %NULL, then the
1376 *          file will be created in the root of the debugfs filesystem.
1377 * @regset: a pointer to a struct debugfs_regset32, which contains a pointer
1378 *          to an array of register definitions, the array size and the base
1379 *          address where the register bank is to be found.
1380 *
1381 * This function creates a file in debugfs with the given name that reports
1382 * the names and values of a set of 32-bit registers. If the @mode variable
1383 * is so set it can be read from. Writing is not supported.
1384 */
1385void debugfs_create_regset32(const char *name, umode_t mode,
1386			     struct dentry *parent,
1387			     struct debugfs_regset32 *regset)
 
 
 
 
 
 
 
 
 
 
1388{
1389	debugfs_create_file(name, mode, parent, regset, &debugfs_regset32_fops);
1390}
1391EXPORT_SYMBOL_GPL(debugfs_create_regset32);
1392
1393#endif /* CONFIG_HAS_IOMEM */
1394
1395struct debugfs_devm_entry {
1396	int (*read)(struct seq_file *seq, void *data);
1397	struct device *dev;
1398};
1399
1400static int debugfs_devm_entry_open(struct inode *inode, struct file *f)
1401{
1402	struct debugfs_devm_entry *entry = inode->i_private;
1403
1404	return single_open(f, entry->read, entry->dev);
1405}
1406
1407static const struct file_operations debugfs_devm_entry_ops = {
1408	.owner = THIS_MODULE,
1409	.open = debugfs_devm_entry_open,
1410	.release = single_release,
1411	.read = seq_read,
1412	.llseek = seq_lseek
1413};
1414
1415/**
1416 * debugfs_create_devm_seqfile - create a debugfs file that is bound to device.
1417 *
1418 * @dev: device related to this debugfs file.
1419 * @name: name of the debugfs file.
1420 * @parent: a pointer to the parent dentry for this file.  This should be a
1421 *	directory dentry if set.  If this parameter is %NULL, then the
1422 *	file will be created in the root of the debugfs filesystem.
1423 * @read_fn: function pointer called to print the seq_file content.
1424 */
1425void debugfs_create_devm_seqfile(struct device *dev, const char *name,
1426				 struct dentry *parent,
1427				 int (*read_fn)(struct seq_file *s, void *data))
 
1428{
1429	struct debugfs_devm_entry *entry;
1430
1431	if (IS_ERR(parent))
1432		return;
1433
1434	entry = devm_kzalloc(dev, sizeof(*entry), GFP_KERNEL);
1435	if (!entry)
1436		return;
1437
1438	entry->read = read_fn;
1439	entry->dev = dev;
1440
1441	debugfs_create_file(name, S_IRUGO, parent, entry,
1442			    &debugfs_devm_entry_ops);
1443}
1444EXPORT_SYMBOL_GPL(debugfs_create_devm_seqfile);