Linux Audio

Check our new training course

Loading...
v5.9
   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
  67/**
  68 * debugfs_file_get - mark the beginning of file data access
  69 * @dentry: the dentry object whose data is being accessed.
 
  70 *
  71 * Up to a matching call to debugfs_file_put(), any successive call
  72 * into the file removing functions debugfs_remove() and
  73 * debugfs_remove_recursive() will block. Since associated private
  74 * file data may only get freed after a successful return of any of
  75 * the removal functions, you may safely access it after a successful
  76 * call to debugfs_file_get() without worrying about lifetime issues.
 
  77 *
  78 * If -%EIO is returned, the file has already been removed and thus,
  79 * it is not safe to access any of its data. If, on the other hand,
  80 * it is allowed to access the file data, zero is returned.
 
 
 
 
  81 */
  82int debugfs_file_get(struct dentry *dentry)
 
  83{
  84	struct debugfs_fsdata *fsd;
  85	void *d_fsd;
  86
  87	d_fsd = READ_ONCE(dentry->d_fsdata);
  88	if (!((unsigned long)d_fsd & DEBUGFS_FSDATA_IS_REAL_FOPS_BIT)) {
  89		fsd = d_fsd;
  90	} else {
  91		fsd = kmalloc(sizeof(*fsd), GFP_KERNEL);
  92		if (!fsd)
  93			return -ENOMEM;
  94
  95		fsd->real_fops = (void *)((unsigned long)d_fsd &
  96					~DEBUGFS_FSDATA_IS_REAL_FOPS_BIT);
  97		refcount_set(&fsd->active_users, 1);
  98		init_completion(&fsd->active_users_drained);
  99		if (cmpxchg(&dentry->d_fsdata, d_fsd, fsd) != d_fsd) {
 100			kfree(fsd);
 101			fsd = READ_ONCE(dentry->d_fsdata);
 102		}
 103	}
 104
 105	/*
 106	 * In case of a successful cmpxchg() above, this check is
 107	 * strictly necessary and must follow it, see the comment in
 108	 * __debugfs_remove_file().
 109	 * OTOH, if the cmpxchg() hasn't been executed or wasn't
 110	 * successful, this serves the purpose of not starving
 111	 * removers.
 112	 */
 113	if (d_unlinked(dentry))
 114		return -EIO;
 115
 116	if (!refcount_inc_not_zero(&fsd->active_users))
 117		return -EIO;
 118
 119	return 0;
 120}
 121EXPORT_SYMBOL_GPL(debugfs_file_get);
 122
 123/**
 124 * debugfs_file_put - mark the end of file data access
 125 * @dentry: the dentry object formerly passed to
 126 *          debugfs_file_get().
 127 *
 128 * Allow any ongoing concurrent call into debugfs_remove() or
 129 * debugfs_remove_recursive() blocked by a former call to
 130 * debugfs_file_get() to proceed and return to its caller.
 131 */
 132void debugfs_file_put(struct dentry *dentry)
 133{
 134	struct debugfs_fsdata *fsd = READ_ONCE(dentry->d_fsdata);
 135
 136	if (refcount_dec_and_test(&fsd->active_users))
 137		complete(&fsd->active_users_drained);
 138}
 139EXPORT_SYMBOL_GPL(debugfs_file_put);
 140
 141/*
 142 * Only permit access to world-readable files when the kernel is locked down.
 143 * We also need to exclude any file that has ways to write or alter it as root
 144 * can bypass the permissions check.
 145 */
 146static int debugfs_locked_down(struct inode *inode,
 147			       struct file *filp,
 148			       const struct file_operations *real_fops)
 149{
 150	if ((inode->i_mode & 07777) == 0444 &&
 151	    !(filp->f_mode & FMODE_WRITE) &&
 152	    !real_fops->unlocked_ioctl &&
 153	    !real_fops->compat_ioctl &&
 154	    !real_fops->mmap)
 155		return 0;
 156
 157	if (security_locked_down(LOCKDOWN_DEBUGFS))
 158		return -EPERM;
 159
 160	return 0;
 161}
 162
 163static int open_proxy_open(struct inode *inode, struct file *filp)
 164{
 165	struct dentry *dentry = F_DENTRY(filp);
 166	const struct file_operations *real_fops = NULL;
 167	int r;
 168
 169	r = debugfs_file_get(dentry);
 170	if (r)
 171		return r == -EIO ? -ENOENT : r;
 172
 173	real_fops = debugfs_real_fops(filp);
 174
 175	r = debugfs_locked_down(inode, filp, real_fops);
 176	if (r)
 177		goto out;
 
 178
 179	if (!fops_get(real_fops)) {
 180#ifdef CONFIG_MODULES
 181		if (real_fops->owner &&
 182		    real_fops->owner->state == MODULE_STATE_GOING)
 183			goto out;
 184#endif
 185
 186		/* Huh? Module did not clean up after itself at exit? */
 187		WARN(1, "debugfs file owner did not clean up at exit: %pd",
 188			dentry);
 189		r = -ENXIO;
 190		goto out;
 191	}
 192	replace_fops(filp, real_fops);
 193
 194	if (real_fops->open)
 195		r = real_fops->open(inode, filp);
 196
 197out:
 198	debugfs_file_put(dentry);
 199	return r;
 200}
 201
 202const struct file_operations debugfs_open_proxy_file_operations = {
 203	.open = open_proxy_open,
 204};
 205
 206#define PROTO(args...) args
 207#define ARGS(args...) args
 208
 209#define FULL_PROXY_FUNC(name, ret_type, filp, proto, args)		\
 210static ret_type full_proxy_ ## name(proto)				\
 211{									\
 212	struct dentry *dentry = F_DENTRY(filp);			\
 213	const struct file_operations *real_fops;			\
 
 
 214	ret_type r;							\
 215									\
 216	r = debugfs_file_get(dentry);					\
 217	if (unlikely(r))						\
 218		return r;						\
 219	real_fops = debugfs_real_fops(filp);				\
 220	r = real_fops->name(args);					\
 221	debugfs_file_put(dentry);					\
 222	return r;							\
 223}
 224
 225FULL_PROXY_FUNC(llseek, loff_t, filp,
 226		PROTO(struct file *filp, loff_t offset, int whence),
 227		ARGS(filp, offset, whence));
 228
 229FULL_PROXY_FUNC(read, ssize_t, filp,
 230		PROTO(struct file *filp, char __user *buf, size_t size,
 231			loff_t *ppos),
 232		ARGS(filp, buf, size, ppos));
 233
 234FULL_PROXY_FUNC(write, ssize_t, filp,
 235		PROTO(struct file *filp, const char __user *buf, size_t size,
 236			loff_t *ppos),
 237		ARGS(filp, buf, size, ppos));
 238
 239FULL_PROXY_FUNC(unlocked_ioctl, long, filp,
 240		PROTO(struct file *filp, unsigned int cmd, unsigned long arg),
 241		ARGS(filp, cmd, arg));
 242
 243static __poll_t full_proxy_poll(struct file *filp,
 244				struct poll_table_struct *wait)
 245{
 246	struct dentry *dentry = F_DENTRY(filp);
 247	__poll_t r = 0;
 248	const struct file_operations *real_fops;
 
 249
 250	if (debugfs_file_get(dentry))
 251		return EPOLLHUP;
 
 
 252
 253	real_fops = debugfs_real_fops(filp);
 254	r = real_fops->poll(filp, wait);
 255	debugfs_file_put(dentry);
 256	return r;
 257}
 258
 259static int full_proxy_release(struct inode *inode, struct file *filp)
 260{
 261	const struct dentry *dentry = F_DENTRY(filp);
 262	const struct file_operations *real_fops = debugfs_real_fops(filp);
 263	const struct file_operations *proxy_fops = filp->f_op;
 264	int r = 0;
 265
 266	/*
 267	 * We must not protect this against removal races here: the
 268	 * original releaser should be called unconditionally in order
 269	 * not to leak any resources. Releasers must not assume that
 270	 * ->i_private is still being meaningful here.
 271	 */
 272	if (real_fops->release)
 273		r = real_fops->release(inode, filp);
 274
 275	replace_fops(filp, d_inode(dentry)->i_fop);
 276	kfree(proxy_fops);
 277	fops_put(real_fops);
 278	return r;
 279}
 280
 281static void __full_proxy_fops_init(struct file_operations *proxy_fops,
 282				const struct file_operations *real_fops)
 283{
 284	proxy_fops->release = full_proxy_release;
 285	if (real_fops->llseek)
 286		proxy_fops->llseek = full_proxy_llseek;
 287	if (real_fops->read)
 288		proxy_fops->read = full_proxy_read;
 289	if (real_fops->write)
 290		proxy_fops->write = full_proxy_write;
 291	if (real_fops->poll)
 292		proxy_fops->poll = full_proxy_poll;
 293	if (real_fops->unlocked_ioctl)
 294		proxy_fops->unlocked_ioctl = full_proxy_unlocked_ioctl;
 295}
 296
 297static int full_proxy_open(struct inode *inode, struct file *filp)
 298{
 299	struct dentry *dentry = F_DENTRY(filp);
 300	const struct file_operations *real_fops = NULL;
 301	struct file_operations *proxy_fops = NULL;
 302	int r;
 303
 304	r = debugfs_file_get(dentry);
 305	if (r)
 306		return r == -EIO ? -ENOENT : r;
 307
 308	real_fops = debugfs_real_fops(filp);
 309
 310	r = debugfs_locked_down(inode, filp, real_fops);
 311	if (r)
 
 312		goto out;
 
 313
 314	if (!fops_get(real_fops)) {
 315#ifdef CONFIG_MODULES
 316		if (real_fops->owner &&
 317		    real_fops->owner->state == MODULE_STATE_GOING)
 318			goto out;
 319#endif
 320
 321		/* Huh? Module did not cleanup after itself at exit? */
 322		WARN(1, "debugfs file owner did not clean up at exit: %pd",
 323			dentry);
 324		r = -ENXIO;
 325		goto out;
 326	}
 327
 328	proxy_fops = kzalloc(sizeof(*proxy_fops), GFP_KERNEL);
 329	if (!proxy_fops) {
 330		r = -ENOMEM;
 331		goto free_proxy;
 332	}
 333	__full_proxy_fops_init(proxy_fops, real_fops);
 334	replace_fops(filp, proxy_fops);
 335
 336	if (real_fops->open) {
 337		r = real_fops->open(inode, filp);
 338		if (r) {
 339			replace_fops(filp, d_inode(dentry)->i_fop);
 340			goto free_proxy;
 341		} else if (filp->f_op != proxy_fops) {
 342			/* No protection against file removal anymore. */
 343			WARN(1, "debugfs file owner replaced proxy fops: %pd",
 344				dentry);
 345			goto free_proxy;
 346		}
 347	}
 348
 349	goto out;
 350free_proxy:
 351	kfree(proxy_fops);
 352	fops_put(real_fops);
 353out:
 354	debugfs_file_put(dentry);
 355	return r;
 356}
 357
 358const struct file_operations debugfs_full_proxy_file_operations = {
 359	.open = full_proxy_open,
 360};
 361
 362ssize_t debugfs_attr_read(struct file *file, char __user *buf,
 363			size_t len, loff_t *ppos)
 364{
 365	struct dentry *dentry = F_DENTRY(file);
 366	ssize_t ret;
 
 367
 368	ret = debugfs_file_get(dentry);
 369	if (unlikely(ret))
 370		return ret;
 371	ret = simple_attr_read(file, buf, len, ppos);
 372	debugfs_file_put(dentry);
 373	return ret;
 374}
 375EXPORT_SYMBOL_GPL(debugfs_attr_read);
 376
 377ssize_t debugfs_attr_write(struct file *file, const char __user *buf,
 378			 size_t len, loff_t *ppos)
 379{
 380	struct dentry *dentry = F_DENTRY(file);
 381	ssize_t ret;
 
 382
 383	ret = debugfs_file_get(dentry);
 384	if (unlikely(ret))
 385		return ret;
 386	ret = simple_attr_write(file, buf, len, ppos);
 387	debugfs_file_put(dentry);
 388	return ret;
 389}
 390EXPORT_SYMBOL_GPL(debugfs_attr_write);
 391
 392static struct dentry *debugfs_create_mode_unsafe(const char *name, umode_t mode,
 393					struct dentry *parent, void *value,
 394					const struct file_operations *fops,
 395					const struct file_operations *fops_ro,
 396					const struct file_operations *fops_wo)
 397{
 398	/* if there are no write bits set, make read only */
 399	if (!(mode & S_IWUGO))
 400		return debugfs_create_file_unsafe(name, mode, parent, value,
 401						fops_ro);
 402	/* if there are no read bits set, make write only */
 403	if (!(mode & S_IRUGO))
 404		return debugfs_create_file_unsafe(name, mode, parent, value,
 405						fops_wo);
 406
 407	return debugfs_create_file_unsafe(name, mode, parent, value, fops);
 408}
 409
 410static int debugfs_u8_set(void *data, u64 val)
 411{
 412	*(u8 *)data = val;
 413	return 0;
 414}
 415static int debugfs_u8_get(void *data, u64 *val)
 416{
 417	*val = *(u8 *)data;
 418	return 0;
 419}
 420DEFINE_DEBUGFS_ATTRIBUTE(fops_u8, debugfs_u8_get, debugfs_u8_set, "%llu\n");
 421DEFINE_DEBUGFS_ATTRIBUTE(fops_u8_ro, debugfs_u8_get, NULL, "%llu\n");
 422DEFINE_DEBUGFS_ATTRIBUTE(fops_u8_wo, NULL, debugfs_u8_set, "%llu\n");
 423
 424/**
 425 * debugfs_create_u8 - create a debugfs file that is used to read and write an unsigned 8-bit value
 426 * @name: a pointer to a string containing the name of the file to create.
 427 * @mode: the permission that the file should have
 428 * @parent: a pointer to the parent dentry for this file.  This should be a
 429 *          directory dentry if set.  If this parameter is %NULL, then the
 430 *          file will be created in the root of the debugfs filesystem.
 431 * @value: a pointer to the variable that the file should read to and write
 432 *         from.
 433 *
 434 * This function creates a file in debugfs with the given name that
 435 * contains the value of the variable @value.  If the @mode variable is so
 436 * set, it can be read from, and written to.
 
 
 
 
 
 
 
 
 
 
 437 */
 438void debugfs_create_u8(const char *name, umode_t mode, struct dentry *parent,
 439		       u8 *value)
 440{
 441	debugfs_create_mode_unsafe(name, mode, parent, value, &fops_u8,
 442				   &fops_u8_ro, &fops_u8_wo);
 443}
 444EXPORT_SYMBOL_GPL(debugfs_create_u8);
 445
 446static int debugfs_u16_set(void *data, u64 val)
 447{
 448	*(u16 *)data = val;
 449	return 0;
 450}
 451static int debugfs_u16_get(void *data, u64 *val)
 452{
 453	*val = *(u16 *)data;
 454	return 0;
 455}
 456DEFINE_DEBUGFS_ATTRIBUTE(fops_u16, debugfs_u16_get, debugfs_u16_set, "%llu\n");
 457DEFINE_DEBUGFS_ATTRIBUTE(fops_u16_ro, debugfs_u16_get, NULL, "%llu\n");
 458DEFINE_DEBUGFS_ATTRIBUTE(fops_u16_wo, NULL, debugfs_u16_set, "%llu\n");
 459
 460/**
 461 * debugfs_create_u16 - create a debugfs file that is used to read and write an unsigned 16-bit value
 462 * @name: a pointer to a string containing the name of the file to create.
 463 * @mode: the permission that the file should have
 464 * @parent: a pointer to the parent dentry for this file.  This should be a
 465 *          directory dentry if set.  If this parameter is %NULL, then the
 466 *          file will be created in the root of the debugfs filesystem.
 467 * @value: a pointer to the variable that the file should read to and write
 468 *         from.
 469 *
 470 * This function creates a file in debugfs with the given name that
 471 * contains the value of the variable @value.  If the @mode variable is so
 472 * set, it can be read from, and written to.
 
 
 
 
 
 
 
 
 
 
 473 */
 474void debugfs_create_u16(const char *name, umode_t mode, struct dentry *parent,
 475			u16 *value)
 476{
 477	debugfs_create_mode_unsafe(name, mode, parent, value, &fops_u16,
 478				   &fops_u16_ro, &fops_u16_wo);
 479}
 480EXPORT_SYMBOL_GPL(debugfs_create_u16);
 481
 482static int debugfs_u32_set(void *data, u64 val)
 483{
 484	*(u32 *)data = val;
 485	return 0;
 486}
 487static int debugfs_u32_get(void *data, u64 *val)
 488{
 489	*val = *(u32 *)data;
 490	return 0;
 491}
 492DEFINE_DEBUGFS_ATTRIBUTE(fops_u32, debugfs_u32_get, debugfs_u32_set, "%llu\n");
 493DEFINE_DEBUGFS_ATTRIBUTE(fops_u32_ro, debugfs_u32_get, NULL, "%llu\n");
 494DEFINE_DEBUGFS_ATTRIBUTE(fops_u32_wo, NULL, debugfs_u32_set, "%llu\n");
 495
 496/**
 497 * debugfs_create_u32 - create a debugfs file that is used to read and write an unsigned 32-bit value
 498 * @name: a pointer to a string containing the name of the file to create.
 499 * @mode: the permission that the file should have
 500 * @parent: a pointer to the parent dentry for this file.  This should be a
 501 *          directory dentry if set.  If this parameter is %NULL, then the
 502 *          file will be created in the root of the debugfs filesystem.
 503 * @value: a pointer to the variable that the file should read to and write
 504 *         from.
 505 *
 506 * This function creates a file in debugfs with the given name that
 507 * contains the value of the variable @value.  If the @mode variable is so
 508 * set, it can be read from, and written to.
 
 
 
 
 
 
 
 
 
 
 509 */
 510void debugfs_create_u32(const char *name, umode_t mode, struct dentry *parent,
 511			u32 *value)
 512{
 513	debugfs_create_mode_unsafe(name, mode, parent, value, &fops_u32,
 514				   &fops_u32_ro, &fops_u32_wo);
 515}
 516EXPORT_SYMBOL_GPL(debugfs_create_u32);
 517
 518static int debugfs_u64_set(void *data, u64 val)
 519{
 520	*(u64 *)data = val;
 521	return 0;
 522}
 523
 524static int debugfs_u64_get(void *data, u64 *val)
 525{
 526	*val = *(u64 *)data;
 527	return 0;
 528}
 529DEFINE_DEBUGFS_ATTRIBUTE(fops_u64, debugfs_u64_get, debugfs_u64_set, "%llu\n");
 530DEFINE_DEBUGFS_ATTRIBUTE(fops_u64_ro, debugfs_u64_get, NULL, "%llu\n");
 531DEFINE_DEBUGFS_ATTRIBUTE(fops_u64_wo, NULL, debugfs_u64_set, "%llu\n");
 532
 533/**
 534 * debugfs_create_u64 - create a debugfs file that is used to read and write an unsigned 64-bit value
 535 * @name: a pointer to a string containing the name of the file to create.
 536 * @mode: the permission that the file should have
 537 * @parent: a pointer to the parent dentry for this file.  This should be a
 538 *          directory dentry if set.  If this parameter is %NULL, then the
 539 *          file will be created in the root of the debugfs filesystem.
 540 * @value: a pointer to the variable that the file should read to and write
 541 *         from.
 542 *
 543 * This function creates a file in debugfs with the given name that
 544 * contains the value of the variable @value.  If the @mode variable is so
 545 * set, it can be read from, and written to.
 
 
 
 
 
 
 
 
 
 
 546 */
 547void debugfs_create_u64(const char *name, umode_t mode, struct dentry *parent,
 548			u64 *value)
 549{
 550	debugfs_create_mode_unsafe(name, mode, parent, value, &fops_u64,
 551				   &fops_u64_ro, &fops_u64_wo);
 552}
 553EXPORT_SYMBOL_GPL(debugfs_create_u64);
 554
 555static int debugfs_ulong_set(void *data, u64 val)
 556{
 557	*(unsigned long *)data = val;
 558	return 0;
 559}
 560
 561static int debugfs_ulong_get(void *data, u64 *val)
 562{
 563	*val = *(unsigned long *)data;
 564	return 0;
 565}
 566DEFINE_DEBUGFS_ATTRIBUTE(fops_ulong, debugfs_ulong_get, debugfs_ulong_set,
 567			"%llu\n");
 568DEFINE_DEBUGFS_ATTRIBUTE(fops_ulong_ro, debugfs_ulong_get, NULL, "%llu\n");
 569DEFINE_DEBUGFS_ATTRIBUTE(fops_ulong_wo, NULL, debugfs_ulong_set, "%llu\n");
 570
 571/**
 572 * debugfs_create_ulong - create a debugfs file that is used to read and write
 573 * an unsigned long value.
 574 * @name: a pointer to a string containing the name of the file to create.
 575 * @mode: the permission that the file should have
 576 * @parent: a pointer to the parent dentry for this file.  This should be a
 577 *          directory dentry if set.  If this parameter is %NULL, then the
 578 *          file will be created in the root of the debugfs filesystem.
 579 * @value: a pointer to the variable that the file should read to and write
 580 *         from.
 581 *
 582 * This function creates a file in debugfs with the given name that
 583 * contains the value of the variable @value.  If the @mode variable is so
 584 * set, it can be read from, and written to.
 585 *
 586 * This function will return a pointer to a dentry if it succeeds.  This
 587 * pointer must be passed to the debugfs_remove() function when the file is
 588 * to be removed (no automatic cleanup happens if your module is unloaded,
 589 * you are responsible here.)  If an error occurs, ERR_PTR(-ERROR) will be
 590 * returned.
 591 *
 592 * If debugfs is not enabled in the kernel, the value ERR_PTR(-ENODEV) will
 593 * be returned.
 
 
 594 */
 595struct dentry *debugfs_create_ulong(const char *name, umode_t mode,
 596				    struct dentry *parent, unsigned long *value)
 597{
 598	return debugfs_create_mode_unsafe(name, mode, parent, value,
 599					&fops_ulong, &fops_ulong_ro,
 600					&fops_ulong_wo);
 601}
 602EXPORT_SYMBOL_GPL(debugfs_create_ulong);
 603
 604DEFINE_DEBUGFS_ATTRIBUTE(fops_x8, debugfs_u8_get, debugfs_u8_set, "0x%02llx\n");
 605DEFINE_DEBUGFS_ATTRIBUTE(fops_x8_ro, debugfs_u8_get, NULL, "0x%02llx\n");
 606DEFINE_DEBUGFS_ATTRIBUTE(fops_x8_wo, NULL, debugfs_u8_set, "0x%02llx\n");
 607
 608DEFINE_DEBUGFS_ATTRIBUTE(fops_x16, debugfs_u16_get, debugfs_u16_set,
 609			"0x%04llx\n");
 610DEFINE_DEBUGFS_ATTRIBUTE(fops_x16_ro, debugfs_u16_get, NULL, "0x%04llx\n");
 611DEFINE_DEBUGFS_ATTRIBUTE(fops_x16_wo, NULL, debugfs_u16_set, "0x%04llx\n");
 612
 613DEFINE_DEBUGFS_ATTRIBUTE(fops_x32, debugfs_u32_get, debugfs_u32_set,
 614			"0x%08llx\n");
 615DEFINE_DEBUGFS_ATTRIBUTE(fops_x32_ro, debugfs_u32_get, NULL, "0x%08llx\n");
 616DEFINE_DEBUGFS_ATTRIBUTE(fops_x32_wo, NULL, debugfs_u32_set, "0x%08llx\n");
 617
 618DEFINE_DEBUGFS_ATTRIBUTE(fops_x64, debugfs_u64_get, debugfs_u64_set,
 619			"0x%016llx\n");
 620DEFINE_DEBUGFS_ATTRIBUTE(fops_x64_ro, debugfs_u64_get, NULL, "0x%016llx\n");
 621DEFINE_DEBUGFS_ATTRIBUTE(fops_x64_wo, NULL, debugfs_u64_set, "0x%016llx\n");
 622
 623/*
 624 * 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
 625 *
 626 * These functions are exactly the same as the above functions (but use a hex
 627 * output for the decimal challenged). For details look at the above unsigned
 628 * decimal functions.
 629 */
 630
 631/**
 632 * debugfs_create_x8 - create a debugfs file that is used to read and write an unsigned 8-bit value
 633 * @name: a pointer to a string containing the name of the file to create.
 634 * @mode: the permission that the file should have
 635 * @parent: a pointer to the parent dentry for this file.  This should be a
 636 *          directory dentry if set.  If this parameter is %NULL, then the
 637 *          file will be created in the root of the debugfs filesystem.
 638 * @value: a pointer to the variable that the file should read to and write
 639 *         from.
 640 */
 641void debugfs_create_x8(const char *name, umode_t mode, struct dentry *parent,
 642		       u8 *value)
 643{
 644	debugfs_create_mode_unsafe(name, mode, parent, value, &fops_x8,
 645				   &fops_x8_ro, &fops_x8_wo);
 646}
 647EXPORT_SYMBOL_GPL(debugfs_create_x8);
 648
 649/**
 650 * debugfs_create_x16 - create a debugfs file that is used to read and write an unsigned 16-bit value
 651 * @name: a pointer to a string containing the name of the file to create.
 652 * @mode: the permission that the file should have
 653 * @parent: a pointer to the parent dentry for this file.  This should be a
 654 *          directory dentry if set.  If this parameter is %NULL, then the
 655 *          file will be created in the root of the debugfs filesystem.
 656 * @value: a pointer to the variable that the file should read to and write
 657 *         from.
 658 */
 659void debugfs_create_x16(const char *name, umode_t mode, struct dentry *parent,
 660			u16 *value)
 661{
 662	debugfs_create_mode_unsafe(name, mode, parent, value, &fops_x16,
 663				   &fops_x16_ro, &fops_x16_wo);
 664}
 665EXPORT_SYMBOL_GPL(debugfs_create_x16);
 666
 667/**
 668 * debugfs_create_x32 - create a debugfs file that is used to read and write an unsigned 32-bit value
 669 * @name: a pointer to a string containing the name of the file to create.
 670 * @mode: the permission that the file should have
 671 * @parent: a pointer to the parent dentry for this file.  This should be a
 672 *          directory dentry if set.  If this parameter is %NULL, then the
 673 *          file will be created in the root of the debugfs filesystem.
 674 * @value: a pointer to the variable that the file should read to and write
 675 *         from.
 676 */
 677void debugfs_create_x32(const char *name, umode_t mode, struct dentry *parent,
 678			u32 *value)
 679{
 680	debugfs_create_mode_unsafe(name, mode, parent, value, &fops_x32,
 681				   &fops_x32_ro, &fops_x32_wo);
 682}
 683EXPORT_SYMBOL_GPL(debugfs_create_x32);
 684
 685/**
 686 * debugfs_create_x64 - create a debugfs file that is used to read and write an unsigned 64-bit value
 687 * @name: a pointer to a string containing the name of the file to create.
 688 * @mode: the permission that the file should have
 689 * @parent: a pointer to the parent dentry for this file.  This should be a
 690 *          directory dentry if set.  If this parameter is %NULL, then the
 691 *          file will be created in the root of the debugfs filesystem.
 692 * @value: a pointer to the variable that the file should read to and write
 693 *         from.
 694 */
 695void debugfs_create_x64(const char *name, umode_t mode, struct dentry *parent,
 696			u64 *value)
 697{
 698	debugfs_create_mode_unsafe(name, mode, parent, value, &fops_x64,
 699				   &fops_x64_ro, &fops_x64_wo);
 700}
 701EXPORT_SYMBOL_GPL(debugfs_create_x64);
 702
 703
 704static int debugfs_size_t_set(void *data, u64 val)
 705{
 706	*(size_t *)data = val;
 707	return 0;
 708}
 709static int debugfs_size_t_get(void *data, u64 *val)
 710{
 711	*val = *(size_t *)data;
 712	return 0;
 713}
 714DEFINE_DEBUGFS_ATTRIBUTE(fops_size_t, debugfs_size_t_get, debugfs_size_t_set,
 715			"%llu\n"); /* %llu and %zu are more or less the same */
 716DEFINE_DEBUGFS_ATTRIBUTE(fops_size_t_ro, debugfs_size_t_get, NULL, "%llu\n");
 717DEFINE_DEBUGFS_ATTRIBUTE(fops_size_t_wo, NULL, debugfs_size_t_set, "%llu\n");
 718
 719/**
 720 * debugfs_create_size_t - create a debugfs file that is used to read and write an size_t value
 721 * @name: a pointer to a string containing the name of the file to create.
 722 * @mode: the permission that the file should have
 723 * @parent: a pointer to the parent dentry for this file.  This should be a
 724 *          directory dentry if set.  If this parameter is %NULL, then the
 725 *          file will be created in the root of the debugfs filesystem.
 726 * @value: a pointer to the variable that the file should read to and write
 727 *         from.
 728 */
 729void debugfs_create_size_t(const char *name, umode_t mode,
 730			   struct dentry *parent, size_t *value)
 731{
 732	debugfs_create_mode_unsafe(name, mode, parent, value, &fops_size_t,
 733				   &fops_size_t_ro, &fops_size_t_wo);
 
 734}
 735EXPORT_SYMBOL_GPL(debugfs_create_size_t);
 736
 737static int debugfs_atomic_t_set(void *data, u64 val)
 738{
 739	atomic_set((atomic_t *)data, val);
 740	return 0;
 741}
 742static int debugfs_atomic_t_get(void *data, u64 *val)
 743{
 744	*val = atomic_read((atomic_t *)data);
 745	return 0;
 746}
 747DEFINE_DEBUGFS_ATTRIBUTE(fops_atomic_t, debugfs_atomic_t_get,
 748			debugfs_atomic_t_set, "%lld\n");
 749DEFINE_DEBUGFS_ATTRIBUTE(fops_atomic_t_ro, debugfs_atomic_t_get, NULL,
 750			"%lld\n");
 751DEFINE_DEBUGFS_ATTRIBUTE(fops_atomic_t_wo, NULL, debugfs_atomic_t_set,
 752			"%lld\n");
 753
 754/**
 755 * debugfs_create_atomic_t - create a debugfs file that is used to read and
 756 * write an atomic_t value
 757 * @name: a pointer to a string containing the name of the file to create.
 758 * @mode: the permission that the file should have
 759 * @parent: a pointer to the parent dentry for this file.  This should be a
 760 *          directory dentry if set.  If this parameter is %NULL, then the
 761 *          file will be created in the root of the debugfs filesystem.
 762 * @value: a pointer to the variable that the file should read to and write
 763 *         from.
 764 */
 765void debugfs_create_atomic_t(const char *name, umode_t mode,
 766			     struct dentry *parent, atomic_t *value)
 767{
 768	debugfs_create_mode_unsafe(name, mode, parent, value, &fops_atomic_t,
 769				   &fops_atomic_t_ro, &fops_atomic_t_wo);
 
 770}
 771EXPORT_SYMBOL_GPL(debugfs_create_atomic_t);
 772
 773ssize_t debugfs_read_file_bool(struct file *file, char __user *user_buf,
 774			       size_t count, loff_t *ppos)
 775{
 776	char buf[3];
 777	bool val;
 778	int r;
 779	struct dentry *dentry = F_DENTRY(file);
 780
 781	r = debugfs_file_get(dentry);
 782	if (unlikely(r))
 
 
 
 783		return r;
 784	val = *(bool *)file->private_data;
 785	debugfs_file_put(dentry);
 786
 787	if (val)
 788		buf[0] = 'Y';
 789	else
 790		buf[0] = 'N';
 791	buf[1] = '\n';
 792	buf[2] = 0x00;
 793	return simple_read_from_buffer(user_buf, count, ppos, buf, 2);
 794}
 795EXPORT_SYMBOL_GPL(debugfs_read_file_bool);
 796
 797ssize_t debugfs_write_file_bool(struct file *file, const char __user *user_buf,
 798				size_t count, loff_t *ppos)
 799{
 
 
 800	bool bv;
 801	int r;
 802	bool *val = file->private_data;
 803	struct dentry *dentry = F_DENTRY(file);
 804
 805	r = kstrtobool_from_user(user_buf, count, &bv);
 806	if (!r) {
 807		r = debugfs_file_get(dentry);
 808		if (unlikely(r))
 
 
 
 
 
 
 
 809			return r;
 810		*val = bv;
 811		debugfs_file_put(dentry);
 812	}
 813
 814	return count;
 815}
 816EXPORT_SYMBOL_GPL(debugfs_write_file_bool);
 817
 818static const struct file_operations fops_bool = {
 819	.read =		debugfs_read_file_bool,
 820	.write =	debugfs_write_file_bool,
 821	.open =		simple_open,
 822	.llseek =	default_llseek,
 823};
 824
 825static const struct file_operations fops_bool_ro = {
 826	.read =		debugfs_read_file_bool,
 827	.open =		simple_open,
 828	.llseek =	default_llseek,
 829};
 830
 831static const struct file_operations fops_bool_wo = {
 832	.write =	debugfs_write_file_bool,
 833	.open =		simple_open,
 834	.llseek =	default_llseek,
 835};
 836
 837/**
 838 * debugfs_create_bool - create a debugfs file that is used to read and write a boolean 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 *
 847 * This function creates a file in debugfs with the given name that
 848 * contains the value of the variable @value.  If the @mode variable is so
 849 * set, it can be read from, and written to.
 850 *
 851 * This function will return a pointer to a dentry if it succeeds.  This
 852 * pointer must be passed to the debugfs_remove() function when the file is
 853 * to be removed (no automatic cleanup happens if your module is unloaded,
 854 * you are responsible here.)  If an error occurs, ERR_PTR(-ERROR) will be
 855 * returned.
 856 *
 857 * If debugfs is not enabled in the kernel, the value ERR_PTR(-ENODEV) will
 858 * be returned.
 
 
 859 */
 860struct dentry *debugfs_create_bool(const char *name, umode_t mode,
 861				   struct dentry *parent, bool *value)
 862{
 863	return debugfs_create_mode_unsafe(name, mode, parent, value, &fops_bool,
 864				   &fops_bool_ro, &fops_bool_wo);
 865}
 866EXPORT_SYMBOL_GPL(debugfs_create_bool);
 867
 868static ssize_t read_file_blob(struct file *file, char __user *user_buf,
 869			      size_t count, loff_t *ppos)
 870{
 871	struct debugfs_blob_wrapper *blob = file->private_data;
 872	struct dentry *dentry = F_DENTRY(file);
 873	ssize_t r;
 
 874
 875	r = debugfs_file_get(dentry);
 876	if (unlikely(r))
 877		return r;
 878	r = simple_read_from_buffer(user_buf, count, ppos, blob->data,
 879				blob->size);
 880	debugfs_file_put(dentry);
 881	return r;
 882}
 883
 884static const struct file_operations fops_blob = {
 885	.read =		read_file_blob,
 886	.open =		simple_open,
 887	.llseek =	default_llseek,
 888};
 889
 890/**
 891 * debugfs_create_blob - create a debugfs file that is used to read a binary blob
 892 * @name: a pointer to a string containing the name of the file to create.
 893 * @mode: the permission that the file should have
 894 * @parent: a pointer to the parent dentry for this file.  This should be a
 895 *          directory dentry if set.  If this parameter is %NULL, then the
 896 *          file will be created in the root of the debugfs filesystem.
 897 * @blob: a pointer to a struct debugfs_blob_wrapper which contains a pointer
 898 *        to the blob data and the size of the data.
 899 *
 900 * This function creates a file in debugfs with the given name that exports
 901 * @blob->data as a binary blob. If the @mode variable is so set it can be
 902 * read from. Writing is not supported.
 903 *
 904 * This function will return a pointer to a dentry if it succeeds.  This
 905 * pointer must be passed to the debugfs_remove() function when the file is
 906 * to be removed (no automatic cleanup happens if your module is unloaded,
 907 * you are responsible here.)  If an error occurs, ERR_PTR(-ERROR) will be
 908 * returned.
 909 *
 910 * If debugfs is not enabled in the kernel, the value ERR_PTR(-ENODEV) will
 911 * be returned.
 
 
 912 */
 913struct dentry *debugfs_create_blob(const char *name, umode_t mode,
 914				   struct dentry *parent,
 915				   struct debugfs_blob_wrapper *blob)
 916{
 917	return debugfs_create_file_unsafe(name, mode, parent, blob, &fops_blob);
 918}
 919EXPORT_SYMBOL_GPL(debugfs_create_blob);
 920
 
 
 
 
 
 921static size_t u32_format_array(char *buf, size_t bufsize,
 922			       u32 *array, int array_size)
 923{
 924	size_t ret = 0;
 925
 926	while (--array_size >= 0) {
 927		size_t len;
 928		char term = array_size ? ' ' : '\n';
 929
 930		len = snprintf(buf, bufsize, "%u%c", *array++, term);
 931		ret += len;
 932
 933		buf += len;
 934		bufsize -= len;
 935	}
 936	return ret;
 937}
 938
 939static int u32_array_open(struct inode *inode, struct file *file)
 940{
 941	struct debugfs_u32_array *data = inode->i_private;
 942	int size, elements = data->n_elements;
 943	char *buf;
 944
 945	/*
 946	 * Max size:
 947	 *  - 10 digits + ' '/'\n' = 11 bytes per number
 948	 *  - terminating NUL character
 949	 */
 950	size = elements*11;
 951	buf = kmalloc(size+1, GFP_KERNEL);
 952	if (!buf)
 953		return -ENOMEM;
 954	buf[size] = 0;
 955
 956	file->private_data = buf;
 957	u32_format_array(buf, size, data->array, data->n_elements);
 958
 959	return nonseekable_open(inode, file);
 960}
 961
 962static ssize_t u32_array_read(struct file *file, char __user *buf, size_t len,
 963			      loff_t *ppos)
 964{
 965	size_t size = strlen(file->private_data);
 966
 967	return simple_read_from_buffer(buf, len, ppos,
 968					file->private_data, size);
 969}
 970
 971static int u32_array_release(struct inode *inode, struct file *file)
 972{
 973	kfree(file->private_data);
 974
 975	return 0;
 976}
 977
 978static const struct file_operations u32_array_fops = {
 979	.owner	 = THIS_MODULE,
 980	.open	 = u32_array_open,
 981	.release = u32_array_release,
 982	.read	 = u32_array_read,
 983	.llseek  = no_llseek,
 984};
 985
 986/**
 987 * debugfs_create_u32_array - create a debugfs file that is used to read u32
 988 * array.
 989 * @name: a pointer to a string containing the name of the file to create.
 990 * @mode: the permission that the file should have.
 991 * @parent: a pointer to the parent dentry for this file.  This should be a
 992 *          directory dentry if set.  If this parameter is %NULL, then the
 993 *          file will be created in the root of the debugfs filesystem.
 994 * @array: wrapper struct containing data pointer and size of the array.
 
 995 *
 996 * This function creates a file in debugfs with the given name that exports
 997 * @array as data. If the @mode variable is so set it can be read from.
 998 * Writing is not supported. Seek within the file is also not supported.
 999 * Once array is created its size can not be changed.
 
 
 
1000 */
1001void debugfs_create_u32_array(const char *name, umode_t mode,
1002			      struct dentry *parent,
1003			      struct debugfs_u32_array *array)
1004{
1005	debugfs_create_file_unsafe(name, mode, parent, array, &u32_array_fops);
 
 
 
 
 
 
 
 
 
1006}
1007EXPORT_SYMBOL_GPL(debugfs_create_u32_array);
1008
1009#ifdef CONFIG_HAS_IOMEM
1010
1011/*
1012 * The regset32 stuff is used to print 32-bit registers using the
1013 * seq_file utilities. We offer printing a register set in an already-opened
1014 * sequential file or create a debugfs file that only prints a regset32.
1015 */
1016
1017/**
1018 * debugfs_print_regs32 - use seq_print to describe a set of registers
1019 * @s: the seq_file structure being used to generate output
1020 * @regs: an array if struct debugfs_reg32 structures
1021 * @nregs: the length of the above array
1022 * @base: the base address to be used in reading the registers
1023 * @prefix: a string to be prefixed to every output line
1024 *
1025 * This function outputs a text block describing the current values of
1026 * some 32-bit hardware registers. It is meant to be used within debugfs
1027 * files based on seq_file that need to show registers, intermixed with other
1028 * information. The prefix argument may be used to specify a leading string,
1029 * because some peripherals have several blocks of identical registers,
1030 * for example configuration of dma channels
1031 */
1032void debugfs_print_regs32(struct seq_file *s, const struct debugfs_reg32 *regs,
1033			  int nregs, void __iomem *base, char *prefix)
1034{
1035	int i;
1036
1037	for (i = 0; i < nregs; i++, regs++) {
1038		if (prefix)
1039			seq_printf(s, "%s", prefix);
1040		seq_printf(s, "%s = 0x%08x\n", regs->name,
1041			   readl(base + regs->offset));
1042		if (seq_has_overflowed(s))
1043			break;
1044	}
1045}
1046EXPORT_SYMBOL_GPL(debugfs_print_regs32);
1047
1048static int debugfs_show_regset32(struct seq_file *s, void *data)
1049{
1050	struct debugfs_regset32 *regset = s->private;
1051
1052	if (regset->dev)
1053		pm_runtime_get_sync(regset->dev);
1054
1055	debugfs_print_regs32(s, regset->regs, regset->nregs, regset->base, "");
1056
1057	if (regset->dev)
1058		pm_runtime_put(regset->dev);
1059
1060	return 0;
1061}
1062
1063static int debugfs_open_regset32(struct inode *inode, struct file *file)
1064{
1065	return single_open(file, debugfs_show_regset32, inode->i_private);
1066}
1067
1068static const struct file_operations fops_regset32 = {
1069	.open =		debugfs_open_regset32,
1070	.read =		seq_read,
1071	.llseek =	seq_lseek,
1072	.release =	single_release,
1073};
1074
1075/**
1076 * debugfs_create_regset32 - create a debugfs file that returns register values
1077 * @name: a pointer to a string containing the name of the file to create.
1078 * @mode: the permission that the file should have
1079 * @parent: a pointer to the parent dentry for this file.  This should be a
1080 *          directory dentry if set.  If this parameter is %NULL, then the
1081 *          file will be created in the root of the debugfs filesystem.
1082 * @regset: a pointer to a struct debugfs_regset32, which contains a pointer
1083 *          to an array of register definitions, the array size and the base
1084 *          address where the register bank is to be found.
1085 *
1086 * This function creates a file in debugfs with the given name that reports
1087 * the names and values of a set of 32-bit registers. If the @mode variable
1088 * is so set it can be read from. Writing is not supported.
1089 */
1090void debugfs_create_regset32(const char *name, umode_t mode,
1091			     struct dentry *parent,
1092			     struct debugfs_regset32 *regset)
 
 
 
 
 
 
 
 
 
 
1093{
1094	debugfs_create_file(name, mode, parent, regset, &fops_regset32);
1095}
1096EXPORT_SYMBOL_GPL(debugfs_create_regset32);
1097
1098#endif /* CONFIG_HAS_IOMEM */
1099
1100struct debugfs_devm_entry {
1101	int (*read)(struct seq_file *seq, void *data);
1102	struct device *dev;
1103};
1104
1105static int debugfs_devm_entry_open(struct inode *inode, struct file *f)
1106{
1107	struct debugfs_devm_entry *entry = inode->i_private;
1108
1109	return single_open(f, entry->read, entry->dev);
1110}
1111
1112static const struct file_operations debugfs_devm_entry_ops = {
1113	.owner = THIS_MODULE,
1114	.open = debugfs_devm_entry_open,
1115	.release = single_release,
1116	.read = seq_read,
1117	.llseek = seq_lseek
1118};
1119
1120/**
1121 * debugfs_create_devm_seqfile - create a debugfs file that is bound to device.
1122 *
1123 * @dev: device related to this debugfs file.
1124 * @name: name of the debugfs file.
1125 * @parent: a pointer to the parent dentry for this file.  This should be a
1126 *	directory dentry if set.  If this parameter is %NULL, then the
1127 *	file will be created in the root of the debugfs filesystem.
1128 * @read_fn: function pointer called to print the seq_file content.
1129 */
1130struct dentry *debugfs_create_devm_seqfile(struct device *dev, const char *name,
1131					   struct dentry *parent,
1132					   int (*read_fn)(struct seq_file *s,
1133							  void *data))
1134{
1135	struct debugfs_devm_entry *entry;
1136
1137	if (IS_ERR(parent))
1138		return ERR_PTR(-ENOENT);
1139
1140	entry = devm_kzalloc(dev, sizeof(*entry), GFP_KERNEL);
1141	if (!entry)
1142		return ERR_PTR(-ENOMEM);
1143
1144	entry->read = read_fn;
1145	entry->dev = dev;
1146
1147	return debugfs_create_file(name, S_IRUGO, parent, entry,
1148				   &debugfs_devm_entry_ops);
1149}
1150EXPORT_SYMBOL_GPL(debugfs_create_devm_seqfile);
v4.10.11
 
   1/*
   2 *  file.c - part of debugfs, a tiny little debug file system
   3 *
   4 *  Copyright (C) 2004 Greg Kroah-Hartman <greg@kroah.com>
   5 *  Copyright (C) 2004 IBM Inc.
   6 *
   7 *	This program is free software; you can redistribute it and/or
   8 *	modify it under the terms of the GNU General Public License version
   9 *	2 as published by the Free Software Foundation.
  10 *
  11 *  debugfs is for people to use instead of /proc or /sys.
  12 *  See Documentation/DocBook/filesystems for more details.
  13 *
  14 */
  15
  16#include <linux/module.h>
  17#include <linux/fs.h>
  18#include <linux/seq_file.h>
  19#include <linux/pagemap.h>
  20#include <linux/debugfs.h>
  21#include <linux/io.h>
  22#include <linux/slab.h>
  23#include <linux/atomic.h>
  24#include <linux/device.h>
  25#include <linux/srcu.h>
  26#include <asm/poll.h>
 
  27
  28#include "internal.h"
  29
  30struct poll_table_struct;
  31
  32static ssize_t default_read_file(struct file *file, char __user *buf,
  33				 size_t count, loff_t *ppos)
  34{
  35	return 0;
  36}
  37
  38static ssize_t default_write_file(struct file *file, const char __user *buf,
  39				   size_t count, loff_t *ppos)
  40{
  41	return count;
  42}
  43
  44const struct file_operations debugfs_noop_file_operations = {
  45	.read =		default_read_file,
  46	.write =	default_write_file,
  47	.open =		simple_open,
  48	.llseek =	noop_llseek,
  49};
  50
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
  51/**
  52 * debugfs_use_file_start - mark the beginning of file data access
  53 * @dentry: the dentry object whose data is being accessed.
  54 * @srcu_idx: a pointer to some memory to store a SRCU index in.
  55 *
  56 * Up to a matching call to debugfs_use_file_finish(), any
  57 * successive call into the file removing functions debugfs_remove()
  58 * and debugfs_remove_recursive() will block. Since associated private
  59 * file data may only get freed after a successful return of any of
  60 * the removal functions, you may safely access it after a successful
  61 * call to debugfs_use_file_start() without worrying about
  62 * lifetime issues.
  63 *
  64 * If -%EIO is returned, the file has already been removed and thus,
  65 * it is not safe to access any of its data. If, on the other hand,
  66 * it is allowed to access the file data, zero is returned.
  67 *
  68 * Regardless of the return code, any call to
  69 * debugfs_use_file_start() must be followed by a matching call
  70 * to debugfs_use_file_finish().
  71 */
  72int debugfs_use_file_start(const struct dentry *dentry, int *srcu_idx)
  73	__acquires(&debugfs_srcu)
  74{
  75	*srcu_idx = srcu_read_lock(&debugfs_srcu);
  76	barrier();
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
  77	if (d_unlinked(dentry))
  78		return -EIO;
 
 
 
 
  79	return 0;
  80}
  81EXPORT_SYMBOL_GPL(debugfs_use_file_start);
  82
  83/**
  84 * debugfs_use_file_finish - mark the end of file data access
  85 * @srcu_idx: the SRCU index "created" by a former call to
  86 *            debugfs_use_file_start().
  87 *
  88 * Allow any ongoing concurrent call into debugfs_remove() or
  89 * debugfs_remove_recursive() blocked by a former call to
  90 * debugfs_use_file_start() to proceed and return to its caller.
  91 */
  92void debugfs_use_file_finish(int srcu_idx) __releases(&debugfs_srcu)
  93{
  94	srcu_read_unlock(&debugfs_srcu, srcu_idx);
 
 
 
  95}
  96EXPORT_SYMBOL_GPL(debugfs_use_file_finish);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
  97
  98#define F_DENTRY(filp) ((filp)->f_path.dentry)
 
  99
 100static int open_proxy_open(struct inode *inode, struct file *filp)
 101{
 102	const struct dentry *dentry = F_DENTRY(filp);
 103	const struct file_operations *real_fops = NULL;
 104	int srcu_idx, r;
 105
 106	r = debugfs_use_file_start(dentry, &srcu_idx);
 107	if (r) {
 108		r = -ENOENT;
 
 
 
 
 
 109		goto out;
 110	}
 111
 112	real_fops = debugfs_real_fops(filp);
 113	real_fops = fops_get(real_fops);
 114	if (!real_fops) {
 
 
 
 
 115		/* Huh? Module did not clean up after itself at exit? */
 116		WARN(1, "debugfs file owner did not clean up at exit: %pd",
 117			dentry);
 118		r = -ENXIO;
 119		goto out;
 120	}
 121	replace_fops(filp, real_fops);
 122
 123	if (real_fops->open)
 124		r = real_fops->open(inode, filp);
 125
 126out:
 127	debugfs_use_file_finish(srcu_idx);
 128	return r;
 129}
 130
 131const struct file_operations debugfs_open_proxy_file_operations = {
 132	.open = open_proxy_open,
 133};
 134
 135#define PROTO(args...) args
 136#define ARGS(args...) args
 137
 138#define FULL_PROXY_FUNC(name, ret_type, filp, proto, args)		\
 139static ret_type full_proxy_ ## name(proto)				\
 140{									\
 141	const struct dentry *dentry = F_DENTRY(filp);			\
 142	const struct file_operations *real_fops =			\
 143		debugfs_real_fops(filp);				\
 144	int srcu_idx;							\
 145	ret_type r;							\
 146									\
 147	r = debugfs_use_file_start(dentry, &srcu_idx);			\
 148	if (likely(!r))						\
 149		r = real_fops->name(args);				\
 150	debugfs_use_file_finish(srcu_idx);				\
 
 
 151	return r;							\
 152}
 153
 154FULL_PROXY_FUNC(llseek, loff_t, filp,
 155		PROTO(struct file *filp, loff_t offset, int whence),
 156		ARGS(filp, offset, whence));
 157
 158FULL_PROXY_FUNC(read, ssize_t, filp,
 159		PROTO(struct file *filp, char __user *buf, size_t size,
 160			loff_t *ppos),
 161		ARGS(filp, buf, size, ppos));
 162
 163FULL_PROXY_FUNC(write, ssize_t, filp,
 164		PROTO(struct file *filp, const char __user *buf, size_t size,
 165			loff_t *ppos),
 166		ARGS(filp, buf, size, ppos));
 167
 168FULL_PROXY_FUNC(unlocked_ioctl, long, filp,
 169		PROTO(struct file *filp, unsigned int cmd, unsigned long arg),
 170		ARGS(filp, cmd, arg));
 171
 172static unsigned int full_proxy_poll(struct file *filp,
 173				struct poll_table_struct *wait)
 174{
 175	const struct dentry *dentry = F_DENTRY(filp);
 176	const struct file_operations *real_fops = debugfs_real_fops(filp);
 177	int srcu_idx;
 178	unsigned int r = 0;
 179
 180	if (debugfs_use_file_start(dentry, &srcu_idx)) {
 181		debugfs_use_file_finish(srcu_idx);
 182		return POLLHUP;
 183	}
 184
 
 185	r = real_fops->poll(filp, wait);
 186	debugfs_use_file_finish(srcu_idx);
 187	return r;
 188}
 189
 190static int full_proxy_release(struct inode *inode, struct file *filp)
 191{
 192	const struct dentry *dentry = F_DENTRY(filp);
 193	const struct file_operations *real_fops = debugfs_real_fops(filp);
 194	const struct file_operations *proxy_fops = filp->f_op;
 195	int r = 0;
 196
 197	/*
 198	 * We must not protect this against removal races here: the
 199	 * original releaser should be called unconditionally in order
 200	 * not to leak any resources. Releasers must not assume that
 201	 * ->i_private is still being meaningful here.
 202	 */
 203	if (real_fops->release)
 204		r = real_fops->release(inode, filp);
 205
 206	replace_fops(filp, d_inode(dentry)->i_fop);
 207	kfree((void *)proxy_fops);
 208	fops_put(real_fops);
 209	return r;
 210}
 211
 212static void __full_proxy_fops_init(struct file_operations *proxy_fops,
 213				const struct file_operations *real_fops)
 214{
 215	proxy_fops->release = full_proxy_release;
 216	if (real_fops->llseek)
 217		proxy_fops->llseek = full_proxy_llseek;
 218	if (real_fops->read)
 219		proxy_fops->read = full_proxy_read;
 220	if (real_fops->write)
 221		proxy_fops->write = full_proxy_write;
 222	if (real_fops->poll)
 223		proxy_fops->poll = full_proxy_poll;
 224	if (real_fops->unlocked_ioctl)
 225		proxy_fops->unlocked_ioctl = full_proxy_unlocked_ioctl;
 226}
 227
 228static int full_proxy_open(struct inode *inode, struct file *filp)
 229{
 230	const struct dentry *dentry = F_DENTRY(filp);
 231	const struct file_operations *real_fops = NULL;
 232	struct file_operations *proxy_fops = NULL;
 233	int srcu_idx, r;
 
 
 
 
 
 
 234
 235	r = debugfs_use_file_start(dentry, &srcu_idx);
 236	if (r) {
 237		r = -ENOENT;
 238		goto out;
 239	}
 240
 241	real_fops = debugfs_real_fops(filp);
 242	real_fops = fops_get(real_fops);
 243	if (!real_fops) {
 
 
 
 
 244		/* Huh? Module did not cleanup after itself at exit? */
 245		WARN(1, "debugfs file owner did not clean up at exit: %pd",
 246			dentry);
 247		r = -ENXIO;
 248		goto out;
 249	}
 250
 251	proxy_fops = kzalloc(sizeof(*proxy_fops), GFP_KERNEL);
 252	if (!proxy_fops) {
 253		r = -ENOMEM;
 254		goto free_proxy;
 255	}
 256	__full_proxy_fops_init(proxy_fops, real_fops);
 257	replace_fops(filp, proxy_fops);
 258
 259	if (real_fops->open) {
 260		r = real_fops->open(inode, filp);
 261		if (r) {
 262			replace_fops(filp, d_inode(dentry)->i_fop);
 263			goto free_proxy;
 264		} else if (filp->f_op != proxy_fops) {
 265			/* No protection against file removal anymore. */
 266			WARN(1, "debugfs file owner replaced proxy fops: %pd",
 267				dentry);
 268			goto free_proxy;
 269		}
 270	}
 271
 272	goto out;
 273free_proxy:
 274	kfree(proxy_fops);
 275	fops_put(real_fops);
 276out:
 277	debugfs_use_file_finish(srcu_idx);
 278	return r;
 279}
 280
 281const struct file_operations debugfs_full_proxy_file_operations = {
 282	.open = full_proxy_open,
 283};
 284
 285ssize_t debugfs_attr_read(struct file *file, char __user *buf,
 286			size_t len, loff_t *ppos)
 287{
 
 288	ssize_t ret;
 289	int srcu_idx;
 290
 291	ret = debugfs_use_file_start(F_DENTRY(file), &srcu_idx);
 292	if (likely(!ret))
 293		ret = simple_attr_read(file, buf, len, ppos);
 294	debugfs_use_file_finish(srcu_idx);
 
 295	return ret;
 296}
 297EXPORT_SYMBOL_GPL(debugfs_attr_read);
 298
 299ssize_t debugfs_attr_write(struct file *file, const char __user *buf,
 300			 size_t len, loff_t *ppos)
 301{
 
 302	ssize_t ret;
 303	int srcu_idx;
 304
 305	ret = debugfs_use_file_start(F_DENTRY(file), &srcu_idx);
 306	if (likely(!ret))
 307		ret = simple_attr_write(file, buf, len, ppos);
 308	debugfs_use_file_finish(srcu_idx);
 
 309	return ret;
 310}
 311EXPORT_SYMBOL_GPL(debugfs_attr_write);
 312
 313static struct dentry *debugfs_create_mode_unsafe(const char *name, umode_t mode,
 314					struct dentry *parent, void *value,
 315					const struct file_operations *fops,
 316					const struct file_operations *fops_ro,
 317					const struct file_operations *fops_wo)
 318{
 319	/* if there are no write bits set, make read only */
 320	if (!(mode & S_IWUGO))
 321		return debugfs_create_file_unsafe(name, mode, parent, value,
 322						fops_ro);
 323	/* if there are no read bits set, make write only */
 324	if (!(mode & S_IRUGO))
 325		return debugfs_create_file_unsafe(name, mode, parent, value,
 326						fops_wo);
 327
 328	return debugfs_create_file_unsafe(name, mode, parent, value, fops);
 329}
 330
 331static int debugfs_u8_set(void *data, u64 val)
 332{
 333	*(u8 *)data = val;
 334	return 0;
 335}
 336static int debugfs_u8_get(void *data, u64 *val)
 337{
 338	*val = *(u8 *)data;
 339	return 0;
 340}
 341DEFINE_DEBUGFS_ATTRIBUTE(fops_u8, debugfs_u8_get, debugfs_u8_set, "%llu\n");
 342DEFINE_DEBUGFS_ATTRIBUTE(fops_u8_ro, debugfs_u8_get, NULL, "%llu\n");
 343DEFINE_DEBUGFS_ATTRIBUTE(fops_u8_wo, NULL, debugfs_u8_set, "%llu\n");
 344
 345/**
 346 * debugfs_create_u8 - create a debugfs file that is used to read and write an unsigned 8-bit value
 347 * @name: a pointer to a string containing the name of the file to create.
 348 * @mode: the permission that the file should have
 349 * @parent: a pointer to the parent dentry for this file.  This should be a
 350 *          directory dentry if set.  If this parameter is %NULL, then the
 351 *          file will be created in the root of the debugfs filesystem.
 352 * @value: a pointer to the variable that the file should read to and write
 353 *         from.
 354 *
 355 * This function creates a file in debugfs with the given name that
 356 * contains the value of the variable @value.  If the @mode variable is so
 357 * set, it can be read from, and written to.
 358 *
 359 * This function will return a pointer to a dentry if it succeeds.  This
 360 * pointer must be passed to the debugfs_remove() function when the file is
 361 * to be removed (no automatic cleanup happens if your module is unloaded,
 362 * you are responsible here.)  If an error occurs, %NULL will be returned.
 363 *
 364 * If debugfs is not enabled in the kernel, the value -%ENODEV will be
 365 * returned.  It is not wise to check for this value, but rather, check for
 366 * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
 367 * code.
 368 */
 369struct dentry *debugfs_create_u8(const char *name, umode_t mode,
 370				 struct dentry *parent, u8 *value)
 371{
 372	return debugfs_create_mode_unsafe(name, mode, parent, value, &fops_u8,
 373				   &fops_u8_ro, &fops_u8_wo);
 374}
 375EXPORT_SYMBOL_GPL(debugfs_create_u8);
 376
 377static int debugfs_u16_set(void *data, u64 val)
 378{
 379	*(u16 *)data = val;
 380	return 0;
 381}
 382static int debugfs_u16_get(void *data, u64 *val)
 383{
 384	*val = *(u16 *)data;
 385	return 0;
 386}
 387DEFINE_DEBUGFS_ATTRIBUTE(fops_u16, debugfs_u16_get, debugfs_u16_set, "%llu\n");
 388DEFINE_DEBUGFS_ATTRIBUTE(fops_u16_ro, debugfs_u16_get, NULL, "%llu\n");
 389DEFINE_DEBUGFS_ATTRIBUTE(fops_u16_wo, NULL, debugfs_u16_set, "%llu\n");
 390
 391/**
 392 * debugfs_create_u16 - create a debugfs file that is used to read and write an unsigned 16-bit value
 393 * @name: a pointer to a string containing the name of the file to create.
 394 * @mode: the permission that the file should have
 395 * @parent: a pointer to the parent dentry for this file.  This should be a
 396 *          directory dentry if set.  If this parameter is %NULL, then the
 397 *          file will be created in the root of the debugfs filesystem.
 398 * @value: a pointer to the variable that the file should read to and write
 399 *         from.
 400 *
 401 * This function creates a file in debugfs with the given name that
 402 * contains the value of the variable @value.  If the @mode variable is so
 403 * set, it can be read from, and written to.
 404 *
 405 * This function will return a pointer to a dentry if it succeeds.  This
 406 * pointer must be passed to the debugfs_remove() function when the file is
 407 * to be removed (no automatic cleanup happens if your module is unloaded,
 408 * you are responsible here.)  If an error occurs, %NULL will be returned.
 409 *
 410 * If debugfs is not enabled in the kernel, the value -%ENODEV will be
 411 * returned.  It is not wise to check for this value, but rather, check for
 412 * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
 413 * code.
 414 */
 415struct dentry *debugfs_create_u16(const char *name, umode_t mode,
 416				  struct dentry *parent, u16 *value)
 417{
 418	return debugfs_create_mode_unsafe(name, mode, parent, value, &fops_u16,
 419				   &fops_u16_ro, &fops_u16_wo);
 420}
 421EXPORT_SYMBOL_GPL(debugfs_create_u16);
 422
 423static int debugfs_u32_set(void *data, u64 val)
 424{
 425	*(u32 *)data = val;
 426	return 0;
 427}
 428static int debugfs_u32_get(void *data, u64 *val)
 429{
 430	*val = *(u32 *)data;
 431	return 0;
 432}
 433DEFINE_DEBUGFS_ATTRIBUTE(fops_u32, debugfs_u32_get, debugfs_u32_set, "%llu\n");
 434DEFINE_DEBUGFS_ATTRIBUTE(fops_u32_ro, debugfs_u32_get, NULL, "%llu\n");
 435DEFINE_DEBUGFS_ATTRIBUTE(fops_u32_wo, NULL, debugfs_u32_set, "%llu\n");
 436
 437/**
 438 * debugfs_create_u32 - create a debugfs file that is used to read and write an unsigned 32-bit value
 439 * @name: a pointer to a string containing the name of the file to create.
 440 * @mode: the permission that the file should have
 441 * @parent: a pointer to the parent dentry for this file.  This should be a
 442 *          directory dentry if set.  If this parameter is %NULL, then the
 443 *          file will be created in the root of the debugfs filesystem.
 444 * @value: a pointer to the variable that the file should read to and write
 445 *         from.
 446 *
 447 * This function creates a file in debugfs with the given name that
 448 * contains the value of the variable @value.  If the @mode variable is so
 449 * set, it can be read from, and written to.
 450 *
 451 * This function will return a pointer to a dentry if it succeeds.  This
 452 * pointer must be passed to the debugfs_remove() function when the file is
 453 * to be removed (no automatic cleanup happens if your module is unloaded,
 454 * you are responsible here.)  If an error occurs, %NULL will be returned.
 455 *
 456 * If debugfs is not enabled in the kernel, the value -%ENODEV will be
 457 * returned.  It is not wise to check for this value, but rather, check for
 458 * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
 459 * code.
 460 */
 461struct dentry *debugfs_create_u32(const char *name, umode_t mode,
 462				 struct dentry *parent, u32 *value)
 463{
 464	return debugfs_create_mode_unsafe(name, mode, parent, value, &fops_u32,
 465				   &fops_u32_ro, &fops_u32_wo);
 466}
 467EXPORT_SYMBOL_GPL(debugfs_create_u32);
 468
 469static int debugfs_u64_set(void *data, u64 val)
 470{
 471	*(u64 *)data = val;
 472	return 0;
 473}
 474
 475static int debugfs_u64_get(void *data, u64 *val)
 476{
 477	*val = *(u64 *)data;
 478	return 0;
 479}
 480DEFINE_DEBUGFS_ATTRIBUTE(fops_u64, debugfs_u64_get, debugfs_u64_set, "%llu\n");
 481DEFINE_DEBUGFS_ATTRIBUTE(fops_u64_ro, debugfs_u64_get, NULL, "%llu\n");
 482DEFINE_DEBUGFS_ATTRIBUTE(fops_u64_wo, NULL, debugfs_u64_set, "%llu\n");
 483
 484/**
 485 * debugfs_create_u64 - create a debugfs file that is used to read and write an unsigned 64-bit value
 486 * @name: a pointer to a string containing the name of the file to create.
 487 * @mode: the permission that the file should have
 488 * @parent: a pointer to the parent dentry for this file.  This should be a
 489 *          directory dentry if set.  If this parameter is %NULL, then the
 490 *          file will be created in the root of the debugfs filesystem.
 491 * @value: a pointer to the variable that the file should read to and write
 492 *         from.
 493 *
 494 * This function creates a file in debugfs with the given name that
 495 * contains the value of the variable @value.  If the @mode variable is so
 496 * set, it can be read from, and written to.
 497 *
 498 * This function will return a pointer to a dentry if it succeeds.  This
 499 * pointer must be passed to the debugfs_remove() function when the file is
 500 * to be removed (no automatic cleanup happens if your module is unloaded,
 501 * you are responsible here.)  If an error occurs, %NULL will be returned.
 502 *
 503 * If debugfs is not enabled in the kernel, the value -%ENODEV will be
 504 * returned.  It is not wise to check for this value, but rather, check for
 505 * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
 506 * code.
 507 */
 508struct dentry *debugfs_create_u64(const char *name, umode_t mode,
 509				 struct dentry *parent, u64 *value)
 510{
 511	return debugfs_create_mode_unsafe(name, mode, parent, value, &fops_u64,
 512				   &fops_u64_ro, &fops_u64_wo);
 513}
 514EXPORT_SYMBOL_GPL(debugfs_create_u64);
 515
 516static int debugfs_ulong_set(void *data, u64 val)
 517{
 518	*(unsigned long *)data = val;
 519	return 0;
 520}
 521
 522static int debugfs_ulong_get(void *data, u64 *val)
 523{
 524	*val = *(unsigned long *)data;
 525	return 0;
 526}
 527DEFINE_DEBUGFS_ATTRIBUTE(fops_ulong, debugfs_ulong_get, debugfs_ulong_set,
 528			"%llu\n");
 529DEFINE_DEBUGFS_ATTRIBUTE(fops_ulong_ro, debugfs_ulong_get, NULL, "%llu\n");
 530DEFINE_DEBUGFS_ATTRIBUTE(fops_ulong_wo, NULL, debugfs_ulong_set, "%llu\n");
 531
 532/**
 533 * debugfs_create_ulong - create a debugfs file that is used to read and write
 534 * an unsigned long value.
 535 * @name: a pointer to a string containing the name of the file to create.
 536 * @mode: the permission that the file should have
 537 * @parent: a pointer to the parent dentry for this file.  This should be a
 538 *          directory dentry if set.  If this parameter is %NULL, then the
 539 *          file will be created in the root of the debugfs filesystem.
 540 * @value: a pointer to the variable that the file should read to and write
 541 *         from.
 542 *
 543 * This function creates a file in debugfs with the given name that
 544 * contains the value of the variable @value.  If the @mode variable is so
 545 * set, it can be read from, and written to.
 546 *
 547 * This function will return a pointer to a dentry if it succeeds.  This
 548 * pointer must be passed to the debugfs_remove() function when the file is
 549 * to be removed (no automatic cleanup happens if your module is unloaded,
 550 * you are responsible here.)  If an error occurs, %NULL will be returned.
 
 551 *
 552 * If debugfs is not enabled in the kernel, the value -%ENODEV will be
 553 * returned.  It is not wise to check for this value, but rather, check for
 554 * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
 555 * code.
 556 */
 557struct dentry *debugfs_create_ulong(const char *name, umode_t mode,
 558				    struct dentry *parent, unsigned long *value)
 559{
 560	return debugfs_create_mode_unsafe(name, mode, parent, value,
 561					&fops_ulong, &fops_ulong_ro,
 562					&fops_ulong_wo);
 563}
 564EXPORT_SYMBOL_GPL(debugfs_create_ulong);
 565
 566DEFINE_DEBUGFS_ATTRIBUTE(fops_x8, debugfs_u8_get, debugfs_u8_set, "0x%02llx\n");
 567DEFINE_DEBUGFS_ATTRIBUTE(fops_x8_ro, debugfs_u8_get, NULL, "0x%02llx\n");
 568DEFINE_DEBUGFS_ATTRIBUTE(fops_x8_wo, NULL, debugfs_u8_set, "0x%02llx\n");
 569
 570DEFINE_DEBUGFS_ATTRIBUTE(fops_x16, debugfs_u16_get, debugfs_u16_set,
 571			"0x%04llx\n");
 572DEFINE_DEBUGFS_ATTRIBUTE(fops_x16_ro, debugfs_u16_get, NULL, "0x%04llx\n");
 573DEFINE_DEBUGFS_ATTRIBUTE(fops_x16_wo, NULL, debugfs_u16_set, "0x%04llx\n");
 574
 575DEFINE_DEBUGFS_ATTRIBUTE(fops_x32, debugfs_u32_get, debugfs_u32_set,
 576			"0x%08llx\n");
 577DEFINE_DEBUGFS_ATTRIBUTE(fops_x32_ro, debugfs_u32_get, NULL, "0x%08llx\n");
 578DEFINE_DEBUGFS_ATTRIBUTE(fops_x32_wo, NULL, debugfs_u32_set, "0x%08llx\n");
 579
 580DEFINE_DEBUGFS_ATTRIBUTE(fops_x64, debugfs_u64_get, debugfs_u64_set,
 581			"0x%016llx\n");
 582DEFINE_DEBUGFS_ATTRIBUTE(fops_x64_ro, debugfs_u64_get, NULL, "0x%016llx\n");
 583DEFINE_DEBUGFS_ATTRIBUTE(fops_x64_wo, NULL, debugfs_u64_set, "0x%016llx\n");
 584
 585/*
 586 * 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
 587 *
 588 * These functions are exactly the same as the above functions (but use a hex
 589 * output for the decimal challenged). For details look at the above unsigned
 590 * decimal functions.
 591 */
 592
 593/**
 594 * debugfs_create_x8 - create a debugfs file that is used to read and write an unsigned 8-bit value
 595 * @name: a pointer to a string containing the name of the file to create.
 596 * @mode: the permission that the file should have
 597 * @parent: a pointer to the parent dentry for this file.  This should be a
 598 *          directory dentry if set.  If this parameter is %NULL, then the
 599 *          file will be created in the root of the debugfs filesystem.
 600 * @value: a pointer to the variable that the file should read to and write
 601 *         from.
 602 */
 603struct dentry *debugfs_create_x8(const char *name, umode_t mode,
 604				 struct dentry *parent, u8 *value)
 605{
 606	return debugfs_create_mode_unsafe(name, mode, parent, value, &fops_x8,
 607				   &fops_x8_ro, &fops_x8_wo);
 608}
 609EXPORT_SYMBOL_GPL(debugfs_create_x8);
 610
 611/**
 612 * debugfs_create_x16 - create a debugfs file that is used to read and write an unsigned 16-bit value
 613 * @name: a pointer to a string containing the name of the file to create.
 614 * @mode: the permission that the file should have
 615 * @parent: a pointer to the parent dentry for this file.  This should be a
 616 *          directory dentry if set.  If this parameter is %NULL, then the
 617 *          file will be created in the root of the debugfs filesystem.
 618 * @value: a pointer to the variable that the file should read to and write
 619 *         from.
 620 */
 621struct dentry *debugfs_create_x16(const char *name, umode_t mode,
 622				 struct dentry *parent, u16 *value)
 623{
 624	return debugfs_create_mode_unsafe(name, mode, parent, value, &fops_x16,
 625				   &fops_x16_ro, &fops_x16_wo);
 626}
 627EXPORT_SYMBOL_GPL(debugfs_create_x16);
 628
 629/**
 630 * debugfs_create_x32 - create a debugfs file that is used to read and write an unsigned 32-bit value
 631 * @name: a pointer to a string containing the name of the file to create.
 632 * @mode: the permission that the file should have
 633 * @parent: a pointer to the parent dentry for this file.  This should be a
 634 *          directory dentry if set.  If this parameter is %NULL, then the
 635 *          file will be created in the root of the debugfs filesystem.
 636 * @value: a pointer to the variable that the file should read to and write
 637 *         from.
 638 */
 639struct dentry *debugfs_create_x32(const char *name, umode_t mode,
 640				 struct dentry *parent, u32 *value)
 641{
 642	return debugfs_create_mode_unsafe(name, mode, parent, value, &fops_x32,
 643				   &fops_x32_ro, &fops_x32_wo);
 644}
 645EXPORT_SYMBOL_GPL(debugfs_create_x32);
 646
 647/**
 648 * debugfs_create_x64 - create a debugfs file that is used to read and write an unsigned 64-bit value
 649 * @name: a pointer to a string containing the name of the file to create.
 650 * @mode: the permission that the file should have
 651 * @parent: a pointer to the parent dentry for this file.  This should be a
 652 *          directory dentry if set.  If this parameter is %NULL, then the
 653 *          file will be created in the root of the debugfs filesystem.
 654 * @value: a pointer to the variable that the file should read to and write
 655 *         from.
 656 */
 657struct dentry *debugfs_create_x64(const char *name, umode_t mode,
 658				 struct dentry *parent, u64 *value)
 659{
 660	return debugfs_create_mode_unsafe(name, mode, parent, value, &fops_x64,
 661				   &fops_x64_ro, &fops_x64_wo);
 662}
 663EXPORT_SYMBOL_GPL(debugfs_create_x64);
 664
 665
 666static int debugfs_size_t_set(void *data, u64 val)
 667{
 668	*(size_t *)data = val;
 669	return 0;
 670}
 671static int debugfs_size_t_get(void *data, u64 *val)
 672{
 673	*val = *(size_t *)data;
 674	return 0;
 675}
 676DEFINE_DEBUGFS_ATTRIBUTE(fops_size_t, debugfs_size_t_get, debugfs_size_t_set,
 677			"%llu\n"); /* %llu and %zu are more or less the same */
 678DEFINE_DEBUGFS_ATTRIBUTE(fops_size_t_ro, debugfs_size_t_get, NULL, "%llu\n");
 679DEFINE_DEBUGFS_ATTRIBUTE(fops_size_t_wo, NULL, debugfs_size_t_set, "%llu\n");
 680
 681/**
 682 * debugfs_create_size_t - create a debugfs file that is used to read and write an size_t value
 683 * @name: a pointer to a string containing the name of the file to create.
 684 * @mode: the permission that the file should have
 685 * @parent: a pointer to the parent dentry for this file.  This should be a
 686 *          directory dentry if set.  If this parameter is %NULL, then the
 687 *          file will be created in the root of the debugfs filesystem.
 688 * @value: a pointer to the variable that the file should read to and write
 689 *         from.
 690 */
 691struct dentry *debugfs_create_size_t(const char *name, umode_t mode,
 692				     struct dentry *parent, size_t *value)
 693{
 694	return debugfs_create_mode_unsafe(name, mode, parent, value,
 695					&fops_size_t, &fops_size_t_ro,
 696					&fops_size_t_wo);
 697}
 698EXPORT_SYMBOL_GPL(debugfs_create_size_t);
 699
 700static int debugfs_atomic_t_set(void *data, u64 val)
 701{
 702	atomic_set((atomic_t *)data, val);
 703	return 0;
 704}
 705static int debugfs_atomic_t_get(void *data, u64 *val)
 706{
 707	*val = atomic_read((atomic_t *)data);
 708	return 0;
 709}
 710DEFINE_DEBUGFS_ATTRIBUTE(fops_atomic_t, debugfs_atomic_t_get,
 711			debugfs_atomic_t_set, "%lld\n");
 712DEFINE_DEBUGFS_ATTRIBUTE(fops_atomic_t_ro, debugfs_atomic_t_get, NULL,
 713			"%lld\n");
 714DEFINE_DEBUGFS_ATTRIBUTE(fops_atomic_t_wo, NULL, debugfs_atomic_t_set,
 715			"%lld\n");
 716
 717/**
 718 * debugfs_create_atomic_t - create a debugfs file that is used to read and
 719 * write an atomic_t value
 720 * @name: a pointer to a string containing the name of the file to create.
 721 * @mode: the permission that the file should have
 722 * @parent: a pointer to the parent dentry for this file.  This should be a
 723 *          directory dentry if set.  If this parameter is %NULL, then the
 724 *          file will be created in the root of the debugfs filesystem.
 725 * @value: a pointer to the variable that the file should read to and write
 726 *         from.
 727 */
 728struct dentry *debugfs_create_atomic_t(const char *name, umode_t mode,
 729				 struct dentry *parent, atomic_t *value)
 730{
 731	return debugfs_create_mode_unsafe(name, mode, parent, value,
 732					&fops_atomic_t, &fops_atomic_t_ro,
 733					&fops_atomic_t_wo);
 734}
 735EXPORT_SYMBOL_GPL(debugfs_create_atomic_t);
 736
 737ssize_t debugfs_read_file_bool(struct file *file, char __user *user_buf,
 738			       size_t count, loff_t *ppos)
 739{
 740	char buf[3];
 741	bool val;
 742	int r, srcu_idx;
 
 743
 744	r = debugfs_use_file_start(F_DENTRY(file), &srcu_idx);
 745	if (likely(!r))
 746		val = *(bool *)file->private_data;
 747	debugfs_use_file_finish(srcu_idx);
 748	if (r)
 749		return r;
 
 
 750
 751	if (val)
 752		buf[0] = 'Y';
 753	else
 754		buf[0] = 'N';
 755	buf[1] = '\n';
 756	buf[2] = 0x00;
 757	return simple_read_from_buffer(user_buf, count, ppos, buf, 2);
 758}
 759EXPORT_SYMBOL_GPL(debugfs_read_file_bool);
 760
 761ssize_t debugfs_write_file_bool(struct file *file, const char __user *user_buf,
 762				size_t count, loff_t *ppos)
 763{
 764	char buf[32];
 765	size_t buf_size;
 766	bool bv;
 767	int r, srcu_idx;
 768	bool *val = file->private_data;
 
 769
 770	buf_size = min(count, (sizeof(buf)-1));
 771	if (copy_from_user(buf, user_buf, buf_size))
 772		return -EFAULT;
 773
 774	buf[buf_size] = '\0';
 775	if (strtobool(buf, &bv) == 0) {
 776		r = debugfs_use_file_start(F_DENTRY(file), &srcu_idx);
 777		if (likely(!r))
 778			*val = bv;
 779		debugfs_use_file_finish(srcu_idx);
 780		if (r)
 781			return r;
 
 
 782	}
 783
 784	return count;
 785}
 786EXPORT_SYMBOL_GPL(debugfs_write_file_bool);
 787
 788static const struct file_operations fops_bool = {
 789	.read =		debugfs_read_file_bool,
 790	.write =	debugfs_write_file_bool,
 791	.open =		simple_open,
 792	.llseek =	default_llseek,
 793};
 794
 795static const struct file_operations fops_bool_ro = {
 796	.read =		debugfs_read_file_bool,
 797	.open =		simple_open,
 798	.llseek =	default_llseek,
 799};
 800
 801static const struct file_operations fops_bool_wo = {
 802	.write =	debugfs_write_file_bool,
 803	.open =		simple_open,
 804	.llseek =	default_llseek,
 805};
 806
 807/**
 808 * debugfs_create_bool - create a debugfs file that is used to read and write a boolean value
 809 * @name: a pointer to a string containing the name of the file to create.
 810 * @mode: the permission that the file should have
 811 * @parent: a pointer to the parent dentry for this file.  This should be a
 812 *          directory dentry if set.  If this parameter is %NULL, then the
 813 *          file will be created in the root of the debugfs filesystem.
 814 * @value: a pointer to the variable that the file should read to and write
 815 *         from.
 816 *
 817 * This function creates a file in debugfs with the given name that
 818 * contains the value of the variable @value.  If the @mode variable is so
 819 * set, it can be read from, and written to.
 820 *
 821 * This function will return a pointer to a dentry if it succeeds.  This
 822 * pointer must be passed to the debugfs_remove() function when the file is
 823 * to be removed (no automatic cleanup happens if your module is unloaded,
 824 * you are responsible here.)  If an error occurs, %NULL will be returned.
 
 825 *
 826 * If debugfs is not enabled in the kernel, the value -%ENODEV will be
 827 * returned.  It is not wise to check for this value, but rather, check for
 828 * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
 829 * code.
 830 */
 831struct dentry *debugfs_create_bool(const char *name, umode_t mode,
 832				   struct dentry *parent, bool *value)
 833{
 834	return debugfs_create_mode_unsafe(name, mode, parent, value, &fops_bool,
 835				   &fops_bool_ro, &fops_bool_wo);
 836}
 837EXPORT_SYMBOL_GPL(debugfs_create_bool);
 838
 839static ssize_t read_file_blob(struct file *file, char __user *user_buf,
 840			      size_t count, loff_t *ppos)
 841{
 842	struct debugfs_blob_wrapper *blob = file->private_data;
 
 843	ssize_t r;
 844	int srcu_idx;
 845
 846	r = debugfs_use_file_start(F_DENTRY(file), &srcu_idx);
 847	if (likely(!r))
 848		r = simple_read_from_buffer(user_buf, count, ppos, blob->data,
 849					blob->size);
 850	debugfs_use_file_finish(srcu_idx);
 
 851	return r;
 852}
 853
 854static const struct file_operations fops_blob = {
 855	.read =		read_file_blob,
 856	.open =		simple_open,
 857	.llseek =	default_llseek,
 858};
 859
 860/**
 861 * debugfs_create_blob - create a debugfs file that is used to read a binary blob
 862 * @name: a pointer to a string containing the name of the file to create.
 863 * @mode: the permission that the file should have
 864 * @parent: a pointer to the parent dentry for this file.  This should be a
 865 *          directory dentry if set.  If this parameter is %NULL, then the
 866 *          file will be created in the root of the debugfs filesystem.
 867 * @blob: a pointer to a struct debugfs_blob_wrapper which contains a pointer
 868 *        to the blob data and the size of the data.
 869 *
 870 * This function creates a file in debugfs with the given name that exports
 871 * @blob->data as a binary blob. If the @mode variable is so set it can be
 872 * read from. Writing is not supported.
 873 *
 874 * This function will return a pointer to a dentry if it succeeds.  This
 875 * pointer must be passed to the debugfs_remove() function when the file is
 876 * to be removed (no automatic cleanup happens if your module is unloaded,
 877 * you are responsible here.)  If an error occurs, %NULL will be returned.
 
 878 *
 879 * If debugfs is not enabled in the kernel, the value -%ENODEV will be
 880 * returned.  It is not wise to check for this value, but rather, check for
 881 * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
 882 * code.
 883 */
 884struct dentry *debugfs_create_blob(const char *name, umode_t mode,
 885				   struct dentry *parent,
 886				   struct debugfs_blob_wrapper *blob)
 887{
 888	return debugfs_create_file_unsafe(name, mode, parent, blob, &fops_blob);
 889}
 890EXPORT_SYMBOL_GPL(debugfs_create_blob);
 891
 892struct array_data {
 893	void *array;
 894	u32 elements;
 895};
 896
 897static size_t u32_format_array(char *buf, size_t bufsize,
 898			       u32 *array, int array_size)
 899{
 900	size_t ret = 0;
 901
 902	while (--array_size >= 0) {
 903		size_t len;
 904		char term = array_size ? ' ' : '\n';
 905
 906		len = snprintf(buf, bufsize, "%u%c", *array++, term);
 907		ret += len;
 908
 909		buf += len;
 910		bufsize -= len;
 911	}
 912	return ret;
 913}
 914
 915static int u32_array_open(struct inode *inode, struct file *file)
 916{
 917	struct array_data *data = inode->i_private;
 918	int size, elements = data->elements;
 919	char *buf;
 920
 921	/*
 922	 * Max size:
 923	 *  - 10 digits + ' '/'\n' = 11 bytes per number
 924	 *  - terminating NUL character
 925	 */
 926	size = elements*11;
 927	buf = kmalloc(size+1, GFP_KERNEL);
 928	if (!buf)
 929		return -ENOMEM;
 930	buf[size] = 0;
 931
 932	file->private_data = buf;
 933	u32_format_array(buf, size, data->array, data->elements);
 934
 935	return nonseekable_open(inode, file);
 936}
 937
 938static ssize_t u32_array_read(struct file *file, char __user *buf, size_t len,
 939			      loff_t *ppos)
 940{
 941	size_t size = strlen(file->private_data);
 942
 943	return simple_read_from_buffer(buf, len, ppos,
 944					file->private_data, size);
 945}
 946
 947static int u32_array_release(struct inode *inode, struct file *file)
 948{
 949	kfree(file->private_data);
 950
 951	return 0;
 952}
 953
 954static const struct file_operations u32_array_fops = {
 955	.owner	 = THIS_MODULE,
 956	.open	 = u32_array_open,
 957	.release = u32_array_release,
 958	.read	 = u32_array_read,
 959	.llseek  = no_llseek,
 960};
 961
 962/**
 963 * debugfs_create_u32_array - create a debugfs file that is used to read u32
 964 * array.
 965 * @name: a pointer to a string containing the name of the file to create.
 966 * @mode: the permission that the file should have.
 967 * @parent: a pointer to the parent dentry for this file.  This should be a
 968 *          directory dentry if set.  If this parameter is %NULL, then the
 969 *          file will be created in the root of the debugfs filesystem.
 970 * @array: u32 array that provides data.
 971 * @elements: total number of elements in the array.
 972 *
 973 * This function creates a file in debugfs with the given name that exports
 974 * @array as data. If the @mode variable is so set it can be read from.
 975 * Writing is not supported. Seek within the file is also not supported.
 976 * Once array is created its size can not be changed.
 977 *
 978 * The function returns a pointer to dentry on success. If debugfs is not
 979 * enabled in the kernel, the value -%ENODEV will be returned.
 980 */
 981struct dentry *debugfs_create_u32_array(const char *name, umode_t mode,
 982					    struct dentry *parent,
 983					    u32 *array, u32 elements)
 984{
 985	struct array_data *data = kmalloc(sizeof(*data), GFP_KERNEL);
 986
 987	if (data == NULL)
 988		return NULL;
 989
 990	data->array = array;
 991	data->elements = elements;
 992
 993	return debugfs_create_file_unsafe(name, mode, parent, data,
 994					&u32_array_fops);
 995}
 996EXPORT_SYMBOL_GPL(debugfs_create_u32_array);
 997
 998#ifdef CONFIG_HAS_IOMEM
 999
1000/*
1001 * The regset32 stuff is used to print 32-bit registers using the
1002 * seq_file utilities. We offer printing a register set in an already-opened
1003 * sequential file or create a debugfs file that only prints a regset32.
1004 */
1005
1006/**
1007 * debugfs_print_regs32 - use seq_print to describe a set of registers
1008 * @s: the seq_file structure being used to generate output
1009 * @regs: an array if struct debugfs_reg32 structures
1010 * @nregs: the length of the above array
1011 * @base: the base address to be used in reading the registers
1012 * @prefix: a string to be prefixed to every output line
1013 *
1014 * This function outputs a text block describing the current values of
1015 * some 32-bit hardware registers. It is meant to be used within debugfs
1016 * files based on seq_file that need to show registers, intermixed with other
1017 * information. The prefix argument may be used to specify a leading string,
1018 * because some peripherals have several blocks of identical registers,
1019 * for example configuration of dma channels
1020 */
1021void debugfs_print_regs32(struct seq_file *s, const struct debugfs_reg32 *regs,
1022			  int nregs, void __iomem *base, char *prefix)
1023{
1024	int i;
1025
1026	for (i = 0; i < nregs; i++, regs++) {
1027		if (prefix)
1028			seq_printf(s, "%s", prefix);
1029		seq_printf(s, "%s = 0x%08x\n", regs->name,
1030			   readl(base + regs->offset));
1031		if (seq_has_overflowed(s))
1032			break;
1033	}
1034}
1035EXPORT_SYMBOL_GPL(debugfs_print_regs32);
1036
1037static int debugfs_show_regset32(struct seq_file *s, void *data)
1038{
1039	struct debugfs_regset32 *regset = s->private;
1040
 
 
 
1041	debugfs_print_regs32(s, regset->regs, regset->nregs, regset->base, "");
 
 
 
 
1042	return 0;
1043}
1044
1045static int debugfs_open_regset32(struct inode *inode, struct file *file)
1046{
1047	return single_open(file, debugfs_show_regset32, inode->i_private);
1048}
1049
1050static const struct file_operations fops_regset32 = {
1051	.open =		debugfs_open_regset32,
1052	.read =		seq_read,
1053	.llseek =	seq_lseek,
1054	.release =	single_release,
1055};
1056
1057/**
1058 * debugfs_create_regset32 - create a debugfs file that returns register values
1059 * @name: a pointer to a string containing the name of the file to create.
1060 * @mode: the permission that the file should have
1061 * @parent: a pointer to the parent dentry for this file.  This should be a
1062 *          directory dentry if set.  If this parameter is %NULL, then the
1063 *          file will be created in the root of the debugfs filesystem.
1064 * @regset: a pointer to a struct debugfs_regset32, which contains a pointer
1065 *          to an array of register definitions, the array size and the base
1066 *          address where the register bank is to be found.
1067 *
1068 * This function creates a file in debugfs with the given name that reports
1069 * the names and values of a set of 32-bit registers. If the @mode variable
1070 * is so set it can be read from. Writing is not supported.
1071 *
1072 * This function will return a pointer to a dentry if it succeeds.  This
1073 * pointer must be passed to the debugfs_remove() function when the file is
1074 * to be removed (no automatic cleanup happens if your module is unloaded,
1075 * you are responsible here.)  If an error occurs, %NULL will be returned.
1076 *
1077 * If debugfs is not enabled in the kernel, the value -%ENODEV will be
1078 * returned.  It is not wise to check for this value, but rather, check for
1079 * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
1080 * code.
1081 */
1082struct dentry *debugfs_create_regset32(const char *name, umode_t mode,
1083				       struct dentry *parent,
1084				       struct debugfs_regset32 *regset)
1085{
1086	return debugfs_create_file(name, mode, parent, regset, &fops_regset32);
1087}
1088EXPORT_SYMBOL_GPL(debugfs_create_regset32);
1089
1090#endif /* CONFIG_HAS_IOMEM */
1091
1092struct debugfs_devm_entry {
1093	int (*read)(struct seq_file *seq, void *data);
1094	struct device *dev;
1095};
1096
1097static int debugfs_devm_entry_open(struct inode *inode, struct file *f)
1098{
1099	struct debugfs_devm_entry *entry = inode->i_private;
1100
1101	return single_open(f, entry->read, entry->dev);
1102}
1103
1104static const struct file_operations debugfs_devm_entry_ops = {
1105	.owner = THIS_MODULE,
1106	.open = debugfs_devm_entry_open,
1107	.release = single_release,
1108	.read = seq_read,
1109	.llseek = seq_lseek
1110};
1111
1112/**
1113 * debugfs_create_devm_seqfile - create a debugfs file that is bound to device.
1114 *
1115 * @dev: device related to this debugfs file.
1116 * @name: name of the debugfs file.
1117 * @parent: a pointer to the parent dentry for this file.  This should be a
1118 *	directory dentry if set.  If this parameter is %NULL, then the
1119 *	file will be created in the root of the debugfs filesystem.
1120 * @read_fn: function pointer called to print the seq_file content.
1121 */
1122struct dentry *debugfs_create_devm_seqfile(struct device *dev, const char *name,
1123					   struct dentry *parent,
1124					   int (*read_fn)(struct seq_file *s,
1125							  void *data))
1126{
1127	struct debugfs_devm_entry *entry;
1128
1129	if (IS_ERR(parent))
1130		return ERR_PTR(-ENOENT);
1131
1132	entry = devm_kzalloc(dev, sizeof(*entry), GFP_KERNEL);
1133	if (!entry)
1134		return ERR_PTR(-ENOMEM);
1135
1136	entry->read = read_fn;
1137	entry->dev = dev;
1138
1139	return debugfs_create_file(name, S_IRUGO, parent, entry,
1140				   &debugfs_devm_entry_ops);
1141}
1142EXPORT_SYMBOL_GPL(debugfs_create_devm_seqfile);
1143