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) == 0 &&
 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			r = -ENXIO;
 184			goto out;
 185		}
 186#endif
 187
 188		/* Huh? Module did not clean up after itself at exit? */
 189		WARN(1, "debugfs file owner did not clean up at exit: %pd",
 190			dentry);
 191		r = -ENXIO;
 192		goto out;
 193	}
 194	replace_fops(filp, real_fops);
 195
 196	if (real_fops->open)
 197		r = real_fops->open(inode, filp);
 198
 199out:
 200	debugfs_file_put(dentry);
 201	return r;
 202}
 203
 204const struct file_operations debugfs_open_proxy_file_operations = {
 205	.open = open_proxy_open,
 206};
 207
 208#define PROTO(args...) args
 209#define ARGS(args...) args
 210
 211#define FULL_PROXY_FUNC(name, ret_type, filp, proto, args)		\
 212static ret_type full_proxy_ ## name(proto)				\
 213{									\
 214	struct dentry *dentry = F_DENTRY(filp);			\
 215	const struct file_operations *real_fops;			\
 216	ret_type r;							\
 217									\
 218	r = debugfs_file_get(dentry);					\
 219	if (unlikely(r))						\
 220		return r;						\
 221	real_fops = debugfs_real_fops(filp);				\
 222	r = real_fops->name(args);					\
 223	debugfs_file_put(dentry);					\
 224	return r;							\
 225}
 226
 227FULL_PROXY_FUNC(llseek, loff_t, filp,
 228		PROTO(struct file *filp, loff_t offset, int whence),
 229		ARGS(filp, offset, whence));
 230
 231FULL_PROXY_FUNC(read, ssize_t, filp,
 232		PROTO(struct file *filp, char __user *buf, size_t size,
 233			loff_t *ppos),
 234		ARGS(filp, buf, size, ppos));
 235
 236FULL_PROXY_FUNC(write, ssize_t, filp,
 237		PROTO(struct file *filp, const char __user *buf, size_t size,
 238			loff_t *ppos),
 239		ARGS(filp, buf, size, ppos));
 240
 241FULL_PROXY_FUNC(unlocked_ioctl, long, filp,
 242		PROTO(struct file *filp, unsigned int cmd, unsigned long arg),
 243		ARGS(filp, cmd, arg));
 244
 245static __poll_t full_proxy_poll(struct file *filp,
 246				struct poll_table_struct *wait)
 247{
 248	struct dentry *dentry = F_DENTRY(filp);
 249	__poll_t r = 0;
 250	const struct file_operations *real_fops;
 251
 252	if (debugfs_file_get(dentry))
 253		return EPOLLHUP;
 254
 255	real_fops = debugfs_real_fops(filp);
 256	r = real_fops->poll(filp, wait);
 257	debugfs_file_put(dentry);
 258	return r;
 259}
 260
 261static int full_proxy_release(struct inode *inode, struct file *filp)
 262{
 263	const struct dentry *dentry = F_DENTRY(filp);
 264	const struct file_operations *real_fops = debugfs_real_fops(filp);
 265	const struct file_operations *proxy_fops = filp->f_op;
 266	int r = 0;
 267
 268	/*
 269	 * We must not protect this against removal races here: the
 270	 * original releaser should be called unconditionally in order
 271	 * not to leak any resources. Releasers must not assume that
 272	 * ->i_private is still being meaningful here.
 273	 */
 274	if (real_fops->release)
 275		r = real_fops->release(inode, filp);
 276
 277	replace_fops(filp, d_inode(dentry)->i_fop);
 278	kfree(proxy_fops);
 279	fops_put(real_fops);
 280	return r;
 281}
 282
 283static void __full_proxy_fops_init(struct file_operations *proxy_fops,
 284				const struct file_operations *real_fops)
 285{
 286	proxy_fops->release = full_proxy_release;
 287	if (real_fops->llseek)
 288		proxy_fops->llseek = full_proxy_llseek;
 289	if (real_fops->read)
 290		proxy_fops->read = full_proxy_read;
 291	if (real_fops->write)
 292		proxy_fops->write = full_proxy_write;
 293	if (real_fops->poll)
 294		proxy_fops->poll = full_proxy_poll;
 295	if (real_fops->unlocked_ioctl)
 296		proxy_fops->unlocked_ioctl = full_proxy_unlocked_ioctl;
 297}
 298
 299static int full_proxy_open(struct inode *inode, struct file *filp)
 300{
 301	struct dentry *dentry = F_DENTRY(filp);
 302	const struct file_operations *real_fops = NULL;
 303	struct file_operations *proxy_fops = NULL;
 304	int r;
 305
 306	r = debugfs_file_get(dentry);
 307	if (r)
 308		return r == -EIO ? -ENOENT : r;
 309
 310	real_fops = debugfs_real_fops(filp);
 311
 312	r = debugfs_locked_down(inode, filp, real_fops);
 313	if (r)
 314		goto out;
 315
 316	if (!fops_get(real_fops)) {
 317#ifdef CONFIG_MODULES
 318		if (real_fops->owner &&
 319		    real_fops->owner->state == MODULE_STATE_GOING) {
 320			r = -ENXIO;
 321			goto out;
 322		}
 323#endif
 324
 325		/* Huh? Module did not cleanup after itself at exit? */
 326		WARN(1, "debugfs file owner did not clean up at exit: %pd",
 327			dentry);
 328		r = -ENXIO;
 329		goto out;
 330	}
 331
 332	proxy_fops = kzalloc(sizeof(*proxy_fops), GFP_KERNEL);
 333	if (!proxy_fops) {
 334		r = -ENOMEM;
 335		goto free_proxy;
 336	}
 337	__full_proxy_fops_init(proxy_fops, real_fops);
 338	replace_fops(filp, proxy_fops);
 339
 340	if (real_fops->open) {
 341		r = real_fops->open(inode, filp);
 342		if (r) {
 343			replace_fops(filp, d_inode(dentry)->i_fop);
 344			goto free_proxy;
 345		} else if (filp->f_op != proxy_fops) {
 346			/* No protection against file removal anymore. */
 347			WARN(1, "debugfs file owner replaced proxy fops: %pd",
 348				dentry);
 349			goto free_proxy;
 350		}
 351	}
 352
 353	goto out;
 354free_proxy:
 355	kfree(proxy_fops);
 356	fops_put(real_fops);
 357out:
 358	debugfs_file_put(dentry);
 359	return r;
 360}
 361
 362const struct file_operations debugfs_full_proxy_file_operations = {
 363	.open = full_proxy_open,
 364};
 365
 366ssize_t debugfs_attr_read(struct file *file, char __user *buf,
 367			size_t len, loff_t *ppos)
 368{
 369	struct dentry *dentry = F_DENTRY(file);
 370	ssize_t ret;
 371
 372	ret = debugfs_file_get(dentry);
 373	if (unlikely(ret))
 374		return ret;
 375	ret = simple_attr_read(file, buf, len, ppos);
 376	debugfs_file_put(dentry);
 377	return ret;
 378}
 379EXPORT_SYMBOL_GPL(debugfs_attr_read);
 380
 381static ssize_t debugfs_attr_write_xsigned(struct file *file, const char __user *buf,
 382			 size_t len, loff_t *ppos, bool is_signed)
 383{
 384	struct dentry *dentry = F_DENTRY(file);
 385	ssize_t ret;
 386
 387	ret = debugfs_file_get(dentry);
 388	if (unlikely(ret))
 389		return ret;
 390	if (is_signed)
 391		ret = simple_attr_write_signed(file, buf, len, ppos);
 392	else
 393		ret = simple_attr_write(file, buf, len, ppos);
 394	debugfs_file_put(dentry);
 395	return ret;
 396}
 397
 398ssize_t debugfs_attr_write(struct file *file, const char __user *buf,
 399			 size_t len, loff_t *ppos)
 400{
 401	return debugfs_attr_write_xsigned(file, buf, len, ppos, false);
 402}
 403EXPORT_SYMBOL_GPL(debugfs_attr_write);
 404
 405ssize_t debugfs_attr_write_signed(struct file *file, const char __user *buf,
 406			 size_t len, loff_t *ppos)
 407{
 408	return debugfs_attr_write_xsigned(file, buf, len, ppos, true);
 409}
 410EXPORT_SYMBOL_GPL(debugfs_attr_write_signed);
 411
 412static struct dentry *debugfs_create_mode_unsafe(const char *name, umode_t mode,
 413					struct dentry *parent, void *value,
 414					const struct file_operations *fops,
 415					const struct file_operations *fops_ro,
 416					const struct file_operations *fops_wo)
 417{
 418	/* if there are no write bits set, make read only */
 419	if (!(mode & S_IWUGO))
 420		return debugfs_create_file_unsafe(name, mode, parent, value,
 421						fops_ro);
 422	/* if there are no read bits set, make write only */
 423	if (!(mode & S_IRUGO))
 424		return debugfs_create_file_unsafe(name, mode, parent, value,
 425						fops_wo);
 426
 427	return debugfs_create_file_unsafe(name, mode, parent, value, fops);
 428}
 429
 430static int debugfs_u8_set(void *data, u64 val)
 431{
 432	*(u8 *)data = val;
 433	return 0;
 434}
 435static int debugfs_u8_get(void *data, u64 *val)
 436{
 437	*val = *(u8 *)data;
 438	return 0;
 439}
 440DEFINE_DEBUGFS_ATTRIBUTE(fops_u8, debugfs_u8_get, debugfs_u8_set, "%llu\n");
 441DEFINE_DEBUGFS_ATTRIBUTE(fops_u8_ro, debugfs_u8_get, NULL, "%llu\n");
 442DEFINE_DEBUGFS_ATTRIBUTE(fops_u8_wo, NULL, debugfs_u8_set, "%llu\n");
 443
 444/**
 445 * debugfs_create_u8 - create a debugfs file that is used to read and write an unsigned 8-bit value
 446 * @name: a pointer to a string containing the name of the file to create.
 447 * @mode: the permission that the file should have
 448 * @parent: a pointer to the parent dentry for this file.  This should be a
 449 *          directory dentry if set.  If this parameter is %NULL, then the
 450 *          file will be created in the root of the debugfs filesystem.
 451 * @value: a pointer to the variable that the file should read to and write
 452 *         from.
 453 *
 454 * This function creates a file in debugfs with the given name that
 455 * contains the value of the variable @value.  If the @mode variable is so
 456 * set, it can be read from, and written to.
 457 */
 458void debugfs_create_u8(const char *name, umode_t mode, struct dentry *parent,
 459		       u8 *value)
 460{
 461	debugfs_create_mode_unsafe(name, mode, parent, value, &fops_u8,
 462				   &fops_u8_ro, &fops_u8_wo);
 463}
 464EXPORT_SYMBOL_GPL(debugfs_create_u8);
 465
 466static int debugfs_u16_set(void *data, u64 val)
 467{
 468	*(u16 *)data = val;
 469	return 0;
 470}
 471static int debugfs_u16_get(void *data, u64 *val)
 472{
 473	*val = *(u16 *)data;
 474	return 0;
 475}
 476DEFINE_DEBUGFS_ATTRIBUTE(fops_u16, debugfs_u16_get, debugfs_u16_set, "%llu\n");
 477DEFINE_DEBUGFS_ATTRIBUTE(fops_u16_ro, debugfs_u16_get, NULL, "%llu\n");
 478DEFINE_DEBUGFS_ATTRIBUTE(fops_u16_wo, NULL, debugfs_u16_set, "%llu\n");
 479
 480/**
 481 * debugfs_create_u16 - create a debugfs file that is used to read and write an unsigned 16-bit value
 482 * @name: a pointer to a string containing the name of the file to create.
 483 * @mode: the permission that the file should have
 484 * @parent: a pointer to the parent dentry for this file.  This should be a
 485 *          directory dentry if set.  If this parameter is %NULL, then the
 486 *          file will be created in the root of the debugfs filesystem.
 487 * @value: a pointer to the variable that the file should read to and write
 488 *         from.
 489 *
 490 * This function creates a file in debugfs with the given name that
 491 * contains the value of the variable @value.  If the @mode variable is so
 492 * set, it can be read from, and written to.
 493 */
 494void debugfs_create_u16(const char *name, umode_t mode, struct dentry *parent,
 495			u16 *value)
 496{
 497	debugfs_create_mode_unsafe(name, mode, parent, value, &fops_u16,
 498				   &fops_u16_ro, &fops_u16_wo);
 499}
 500EXPORT_SYMBOL_GPL(debugfs_create_u16);
 501
 502static int debugfs_u32_set(void *data, u64 val)
 503{
 504	*(u32 *)data = val;
 505	return 0;
 506}
 507static int debugfs_u32_get(void *data, u64 *val)
 508{
 509	*val = *(u32 *)data;
 510	return 0;
 511}
 512DEFINE_DEBUGFS_ATTRIBUTE(fops_u32, debugfs_u32_get, debugfs_u32_set, "%llu\n");
 513DEFINE_DEBUGFS_ATTRIBUTE(fops_u32_ro, debugfs_u32_get, NULL, "%llu\n");
 514DEFINE_DEBUGFS_ATTRIBUTE(fops_u32_wo, NULL, debugfs_u32_set, "%llu\n");
 515
 516/**
 517 * debugfs_create_u32 - create a debugfs file that is used to read and write an unsigned 32-bit value
 518 * @name: a pointer to a string containing the name of the file to create.
 519 * @mode: the permission that the file should have
 520 * @parent: a pointer to the parent dentry for this file.  This should be a
 521 *          directory dentry if set.  If this parameter is %NULL, then the
 522 *          file will be created in the root of the debugfs filesystem.
 523 * @value: a pointer to the variable that the file should read to and write
 524 *         from.
 525 *
 526 * This function creates a file in debugfs with the given name that
 527 * contains the value of the variable @value.  If the @mode variable is so
 528 * set, it can be read from, and written to.
 529 */
 530void debugfs_create_u32(const char *name, umode_t mode, struct dentry *parent,
 531			u32 *value)
 532{
 533	debugfs_create_mode_unsafe(name, mode, parent, value, &fops_u32,
 534				   &fops_u32_ro, &fops_u32_wo);
 535}
 536EXPORT_SYMBOL_GPL(debugfs_create_u32);
 537
 538static int debugfs_u64_set(void *data, u64 val)
 539{
 540	*(u64 *)data = val;
 541	return 0;
 542}
 543
 544static int debugfs_u64_get(void *data, u64 *val)
 545{
 546	*val = *(u64 *)data;
 547	return 0;
 548}
 549DEFINE_DEBUGFS_ATTRIBUTE(fops_u64, debugfs_u64_get, debugfs_u64_set, "%llu\n");
 550DEFINE_DEBUGFS_ATTRIBUTE(fops_u64_ro, debugfs_u64_get, NULL, "%llu\n");
 551DEFINE_DEBUGFS_ATTRIBUTE(fops_u64_wo, NULL, debugfs_u64_set, "%llu\n");
 552
 553/**
 554 * debugfs_create_u64 - create a debugfs file that is used to read and write an unsigned 64-bit value
 555 * @name: a pointer to a string containing the name of the file to create.
 556 * @mode: the permission that the file should have
 557 * @parent: a pointer to the parent dentry for this file.  This should be a
 558 *          directory dentry if set.  If this parameter is %NULL, then the
 559 *          file will be created in the root of the debugfs filesystem.
 560 * @value: a pointer to the variable that the file should read to and write
 561 *         from.
 562 *
 563 * This function creates a file in debugfs with the given name that
 564 * contains the value of the variable @value.  If the @mode variable is so
 565 * set, it can be read from, and written to.
 566 */
 567void debugfs_create_u64(const char *name, umode_t mode, struct dentry *parent,
 568			u64 *value)
 569{
 570	debugfs_create_mode_unsafe(name, mode, parent, value, &fops_u64,
 571				   &fops_u64_ro, &fops_u64_wo);
 572}
 573EXPORT_SYMBOL_GPL(debugfs_create_u64);
 574
 575static int debugfs_ulong_set(void *data, u64 val)
 576{
 577	*(unsigned long *)data = val;
 578	return 0;
 579}
 580
 581static int debugfs_ulong_get(void *data, u64 *val)
 582{
 583	*val = *(unsigned long *)data;
 584	return 0;
 585}
 586DEFINE_DEBUGFS_ATTRIBUTE(fops_ulong, debugfs_ulong_get, debugfs_ulong_set,
 587			"%llu\n");
 588DEFINE_DEBUGFS_ATTRIBUTE(fops_ulong_ro, debugfs_ulong_get, NULL, "%llu\n");
 589DEFINE_DEBUGFS_ATTRIBUTE(fops_ulong_wo, NULL, debugfs_ulong_set, "%llu\n");
 590
 591/**
 592 * debugfs_create_ulong - create a debugfs file that is used to read and write
 593 * an unsigned long value.
 594 * @name: a pointer to a string containing the name of the file to create.
 595 * @mode: the permission that the file should have
 596 * @parent: a pointer to the parent dentry for this file.  This should be a
 597 *          directory dentry if set.  If this parameter is %NULL, then the
 598 *          file will be created in the root of the debugfs filesystem.
 599 * @value: a pointer to the variable that the file should read to and write
 600 *         from.
 601 *
 602 * This function creates a file in debugfs with the given name that
 603 * contains the value of the variable @value.  If the @mode variable is so
 604 * set, it can be read from, and written to.
 605 */
 606void debugfs_create_ulong(const char *name, umode_t mode, struct dentry *parent,
 607			  unsigned long *value)
 608{
 609	debugfs_create_mode_unsafe(name, mode, parent, value, &fops_ulong,
 610				   &fops_ulong_ro, &fops_ulong_wo);
 611}
 612EXPORT_SYMBOL_GPL(debugfs_create_ulong);
 613
 614DEFINE_DEBUGFS_ATTRIBUTE(fops_x8, debugfs_u8_get, debugfs_u8_set, "0x%02llx\n");
 615DEFINE_DEBUGFS_ATTRIBUTE(fops_x8_ro, debugfs_u8_get, NULL, "0x%02llx\n");
 616DEFINE_DEBUGFS_ATTRIBUTE(fops_x8_wo, NULL, debugfs_u8_set, "0x%02llx\n");
 617
 618DEFINE_DEBUGFS_ATTRIBUTE(fops_x16, debugfs_u16_get, debugfs_u16_set,
 619			"0x%04llx\n");
 620DEFINE_DEBUGFS_ATTRIBUTE(fops_x16_ro, debugfs_u16_get, NULL, "0x%04llx\n");
 621DEFINE_DEBUGFS_ATTRIBUTE(fops_x16_wo, NULL, debugfs_u16_set, "0x%04llx\n");
 622
 623DEFINE_DEBUGFS_ATTRIBUTE(fops_x32, debugfs_u32_get, debugfs_u32_set,
 624			"0x%08llx\n");
 625DEFINE_DEBUGFS_ATTRIBUTE(fops_x32_ro, debugfs_u32_get, NULL, "0x%08llx\n");
 626DEFINE_DEBUGFS_ATTRIBUTE(fops_x32_wo, NULL, debugfs_u32_set, "0x%08llx\n");
 627
 628DEFINE_DEBUGFS_ATTRIBUTE(fops_x64, debugfs_u64_get, debugfs_u64_set,
 629			"0x%016llx\n");
 630DEFINE_DEBUGFS_ATTRIBUTE(fops_x64_ro, debugfs_u64_get, NULL, "0x%016llx\n");
 631DEFINE_DEBUGFS_ATTRIBUTE(fops_x64_wo, NULL, debugfs_u64_set, "0x%016llx\n");
 632
 633/*
 634 * 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
 635 *
 636 * These functions are exactly the same as the above functions (but use a hex
 637 * output for the decimal challenged). For details look at the above unsigned
 638 * decimal functions.
 639 */
 640
 641/**
 642 * debugfs_create_x8 - create a debugfs file that is used to read and write an unsigned 8-bit value
 643 * @name: a pointer to a string containing the name of the file to create.
 644 * @mode: the permission that the file should have
 645 * @parent: a pointer to the parent dentry for this file.  This should be a
 646 *          directory dentry if set.  If this parameter is %NULL, then the
 647 *          file will be created in the root of the debugfs filesystem.
 648 * @value: a pointer to the variable that the file should read to and write
 649 *         from.
 650 */
 651void debugfs_create_x8(const char *name, umode_t mode, struct dentry *parent,
 652		       u8 *value)
 653{
 654	debugfs_create_mode_unsafe(name, mode, parent, value, &fops_x8,
 655				   &fops_x8_ro, &fops_x8_wo);
 656}
 657EXPORT_SYMBOL_GPL(debugfs_create_x8);
 658
 659/**
 660 * debugfs_create_x16 - create a debugfs file that is used to read and write an unsigned 16-bit value
 661 * @name: a pointer to a string containing the name of the file to create.
 662 * @mode: the permission that the file should have
 663 * @parent: a pointer to the parent dentry for this file.  This should be a
 664 *          directory dentry if set.  If this parameter is %NULL, then the
 665 *          file will be created in the root of the debugfs filesystem.
 666 * @value: a pointer to the variable that the file should read to and write
 667 *         from.
 668 */
 669void debugfs_create_x16(const char *name, umode_t mode, struct dentry *parent,
 670			u16 *value)
 671{
 672	debugfs_create_mode_unsafe(name, mode, parent, value, &fops_x16,
 673				   &fops_x16_ro, &fops_x16_wo);
 674}
 675EXPORT_SYMBOL_GPL(debugfs_create_x16);
 676
 677/**
 678 * debugfs_create_x32 - create a debugfs file that is used to read and write an unsigned 32-bit value
 679 * @name: a pointer to a string containing the name of the file to create.
 680 * @mode: the permission that the file should have
 681 * @parent: a pointer to the parent dentry for this file.  This should be a
 682 *          directory dentry if set.  If this parameter is %NULL, then the
 683 *          file will be created in the root of the debugfs filesystem.
 684 * @value: a pointer to the variable that the file should read to and write
 685 *         from.
 686 */
 687void debugfs_create_x32(const char *name, umode_t mode, struct dentry *parent,
 688			u32 *value)
 689{
 690	debugfs_create_mode_unsafe(name, mode, parent, value, &fops_x32,
 691				   &fops_x32_ro, &fops_x32_wo);
 692}
 693EXPORT_SYMBOL_GPL(debugfs_create_x32);
 694
 695/**
 696 * debugfs_create_x64 - create a debugfs file that is used to read and write an unsigned 64-bit value
 697 * @name: a pointer to a string containing the name of the file to create.
 698 * @mode: the permission that the file should have
 699 * @parent: a pointer to the parent dentry for this file.  This should be a
 700 *          directory dentry if set.  If this parameter is %NULL, then the
 701 *          file will be created in the root of the debugfs filesystem.
 702 * @value: a pointer to the variable that the file should read to and write
 703 *         from.
 704 */
 705void debugfs_create_x64(const char *name, umode_t mode, struct dentry *parent,
 706			u64 *value)
 707{
 708	debugfs_create_mode_unsafe(name, mode, parent, value, &fops_x64,
 709				   &fops_x64_ro, &fops_x64_wo);
 710}
 711EXPORT_SYMBOL_GPL(debugfs_create_x64);
 712
 713
 714static int debugfs_size_t_set(void *data, u64 val)
 715{
 716	*(size_t *)data = val;
 717	return 0;
 718}
 719static int debugfs_size_t_get(void *data, u64 *val)
 720{
 721	*val = *(size_t *)data;
 722	return 0;
 723}
 724DEFINE_DEBUGFS_ATTRIBUTE(fops_size_t, debugfs_size_t_get, debugfs_size_t_set,
 725			"%llu\n"); /* %llu and %zu are more or less the same */
 726DEFINE_DEBUGFS_ATTRIBUTE(fops_size_t_ro, debugfs_size_t_get, NULL, "%llu\n");
 727DEFINE_DEBUGFS_ATTRIBUTE(fops_size_t_wo, NULL, debugfs_size_t_set, "%llu\n");
 728
 729/**
 730 * debugfs_create_size_t - create a debugfs file that is used to read and write an size_t value
 731 * @name: a pointer to a string containing the name of the file to create.
 732 * @mode: the permission that the file should have
 733 * @parent: a pointer to the parent dentry for this file.  This should be a
 734 *          directory dentry if set.  If this parameter is %NULL, then the
 735 *          file will be created in the root of the debugfs filesystem.
 736 * @value: a pointer to the variable that the file should read to and write
 737 *         from.
 738 */
 739void debugfs_create_size_t(const char *name, umode_t mode,
 740			   struct dentry *parent, size_t *value)
 741{
 742	debugfs_create_mode_unsafe(name, mode, parent, value, &fops_size_t,
 743				   &fops_size_t_ro, &fops_size_t_wo);
 744}
 745EXPORT_SYMBOL_GPL(debugfs_create_size_t);
 746
 747static int debugfs_atomic_t_set(void *data, u64 val)
 748{
 749	atomic_set((atomic_t *)data, val);
 750	return 0;
 751}
 752static int debugfs_atomic_t_get(void *data, u64 *val)
 753{
 754	*val = atomic_read((atomic_t *)data);
 755	return 0;
 756}
 757DEFINE_DEBUGFS_ATTRIBUTE_SIGNED(fops_atomic_t, debugfs_atomic_t_get,
 758			debugfs_atomic_t_set, "%lld\n");
 759DEFINE_DEBUGFS_ATTRIBUTE_SIGNED(fops_atomic_t_ro, debugfs_atomic_t_get, NULL,
 760			"%lld\n");
 761DEFINE_DEBUGFS_ATTRIBUTE_SIGNED(fops_atomic_t_wo, NULL, debugfs_atomic_t_set,
 762			"%lld\n");
 763
 764/**
 765 * debugfs_create_atomic_t - create a debugfs file that is used to read and
 766 * write an atomic_t value
 767 * @name: a pointer to a string containing the name of the file to create.
 768 * @mode: the permission that the file should have
 769 * @parent: a pointer to the parent dentry for this file.  This should be a
 770 *          directory dentry if set.  If this parameter is %NULL, then the
 771 *          file will be created in the root of the debugfs filesystem.
 772 * @value: a pointer to the variable that the file should read to and write
 773 *         from.
 774 */
 775void debugfs_create_atomic_t(const char *name, umode_t mode,
 776			     struct dentry *parent, atomic_t *value)
 777{
 778	debugfs_create_mode_unsafe(name, mode, parent, value, &fops_atomic_t,
 779				   &fops_atomic_t_ro, &fops_atomic_t_wo);
 780}
 781EXPORT_SYMBOL_GPL(debugfs_create_atomic_t);
 782
 783ssize_t debugfs_read_file_bool(struct file *file, char __user *user_buf,
 784			       size_t count, loff_t *ppos)
 785{
 786	char buf[2];
 787	bool val;
 788	int r;
 789	struct dentry *dentry = F_DENTRY(file);
 790
 791	r = debugfs_file_get(dentry);
 792	if (unlikely(r))
 793		return r;
 794	val = *(bool *)file->private_data;
 795	debugfs_file_put(dentry);
 796
 797	if (val)
 798		buf[0] = 'Y';
 799	else
 800		buf[0] = 'N';
 801	buf[1] = '\n';
 802	return simple_read_from_buffer(user_buf, count, ppos, buf, 2);
 803}
 804EXPORT_SYMBOL_GPL(debugfs_read_file_bool);
 805
 806ssize_t debugfs_write_file_bool(struct file *file, const char __user *user_buf,
 807				size_t count, loff_t *ppos)
 808{
 809	bool bv;
 810	int r;
 811	bool *val = file->private_data;
 812	struct dentry *dentry = F_DENTRY(file);
 813
 814	r = kstrtobool_from_user(user_buf, count, &bv);
 815	if (!r) {
 816		r = debugfs_file_get(dentry);
 817		if (unlikely(r))
 818			return r;
 819		*val = bv;
 820		debugfs_file_put(dentry);
 821	}
 822
 823	return count;
 824}
 825EXPORT_SYMBOL_GPL(debugfs_write_file_bool);
 826
 827static const struct file_operations fops_bool = {
 828	.read =		debugfs_read_file_bool,
 829	.write =	debugfs_write_file_bool,
 830	.open =		simple_open,
 831	.llseek =	default_llseek,
 832};
 833
 834static const struct file_operations fops_bool_ro = {
 835	.read =		debugfs_read_file_bool,
 836	.open =		simple_open,
 837	.llseek =	default_llseek,
 838};
 839
 840static const struct file_operations fops_bool_wo = {
 841	.write =	debugfs_write_file_bool,
 842	.open =		simple_open,
 843	.llseek =	default_llseek,
 844};
 845
 846/**
 847 * debugfs_create_bool - create a debugfs file that is used to read and write a boolean value
 848 * @name: a pointer to a string containing the name of the file to create.
 849 * @mode: the permission that the file should have
 850 * @parent: a pointer to the parent dentry for this file.  This should be a
 851 *          directory dentry if set.  If this parameter is %NULL, then the
 852 *          file will be created in the root of the debugfs filesystem.
 853 * @value: a pointer to the variable that the file should read to and write
 854 *         from.
 855 *
 856 * This function creates a file in debugfs with the given name that
 857 * contains the value of the variable @value.  If the @mode variable is so
 858 * set, it can be read from, and written to.
 859 */
 860void debugfs_create_bool(const char *name, umode_t mode, struct dentry *parent,
 861			 bool *value)
 862{
 863	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
 868ssize_t debugfs_read_file_str(struct file *file, char __user *user_buf,
 869			      size_t count, loff_t *ppos)
 870{
 871	struct dentry *dentry = F_DENTRY(file);
 872	char *str, *copy = NULL;
 873	int copy_len, len;
 874	ssize_t ret;
 875
 876	ret = debugfs_file_get(dentry);
 877	if (unlikely(ret))
 878		return ret;
 879
 880	str = *(char **)file->private_data;
 881	len = strlen(str) + 1;
 882	copy = kmalloc(len, GFP_KERNEL);
 883	if (!copy) {
 884		debugfs_file_put(dentry);
 885		return -ENOMEM;
 886	}
 887
 888	copy_len = strscpy(copy, str, len);
 889	debugfs_file_put(dentry);
 890	if (copy_len < 0) {
 891		kfree(copy);
 892		return copy_len;
 893	}
 894
 895	copy[copy_len] = '\n';
 896
 897	ret = simple_read_from_buffer(user_buf, count, ppos, copy, len);
 898	kfree(copy);
 899
 900	return ret;
 901}
 902
 903static ssize_t debugfs_write_file_str(struct file *file, const char __user *user_buf,
 904				      size_t count, loff_t *ppos)
 905{
 906	/* This is really only for read-only strings */
 907	return -EINVAL;
 908}
 909
 910static const struct file_operations fops_str = {
 911	.read =		debugfs_read_file_str,
 912	.write =	debugfs_write_file_str,
 913	.open =		simple_open,
 914	.llseek =	default_llseek,
 915};
 916
 917static const struct file_operations fops_str_ro = {
 918	.read =		debugfs_read_file_str,
 919	.open =		simple_open,
 920	.llseek =	default_llseek,
 921};
 922
 923static const struct file_operations fops_str_wo = {
 924	.write =	debugfs_write_file_str,
 925	.open =		simple_open,
 926	.llseek =	default_llseek,
 927};
 928
 929/**
 930 * debugfs_create_str - create a debugfs file that is used to read and write a string value
 931 * @name: a pointer to a string containing the name of the file to create.
 932 * @mode: the permission that the file should have
 933 * @parent: a pointer to the parent dentry for this file.  This should be a
 934 *          directory dentry if set.  If this parameter is %NULL, then the
 935 *          file will be created in the root of the debugfs filesystem.
 936 * @value: a pointer to the variable that the file should read to and write
 937 *         from.
 938 *
 939 * This function creates a file in debugfs with the given name that
 940 * contains the value of the variable @value.  If the @mode variable is so
 941 * set, it can be read from, and written to.
 942 *
 943 * This function will return a pointer to a dentry if it succeeds.  This
 944 * pointer must be passed to the debugfs_remove() function when the file is
 945 * to be removed (no automatic cleanup happens if your module is unloaded,
 946 * you are responsible here.)  If an error occurs, ERR_PTR(-ERROR) will be
 947 * returned.
 948 *
 949 * If debugfs is not enabled in the kernel, the value ERR_PTR(-ENODEV) will
 950 * be returned.
 951 */
 952void debugfs_create_str(const char *name, umode_t mode,
 953			struct dentry *parent, char **value)
 954{
 955	debugfs_create_mode_unsafe(name, mode, parent, value, &fops_str,
 956				   &fops_str_ro, &fops_str_wo);
 957}
 958
 959static ssize_t read_file_blob(struct file *file, char __user *user_buf,
 960			      size_t count, loff_t *ppos)
 961{
 962	struct debugfs_blob_wrapper *blob = file->private_data;
 963	struct dentry *dentry = F_DENTRY(file);
 964	ssize_t r;
 965
 966	r = debugfs_file_get(dentry);
 967	if (unlikely(r))
 968		return r;
 969	r = simple_read_from_buffer(user_buf, count, ppos, blob->data,
 970				blob->size);
 971	debugfs_file_put(dentry);
 972	return r;
 973}
 974
 975static const struct file_operations fops_blob = {
 976	.read =		read_file_blob,
 977	.open =		simple_open,
 978	.llseek =	default_llseek,
 979};
 980
 981/**
 982 * debugfs_create_blob - create a debugfs file that is used to read a binary blob
 983 * @name: a pointer to a string containing the name of the file to create.
 984 * @mode: the read permission that the file should have (other permissions are
 985 *	  masked out)
 986 * @parent: a pointer to the parent dentry for this file.  This should be a
 987 *          directory dentry if set.  If this parameter is %NULL, then the
 988 *          file will be created in the root of the debugfs filesystem.
 989 * @blob: a pointer to a struct debugfs_blob_wrapper which contains a pointer
 990 *        to the blob data and the size of the data.
 991 *
 992 * This function creates a file in debugfs with the given name that exports
 993 * @blob->data as a binary blob. If the @mode variable is so set it can be
 994 * read from. Writing is not supported.
 995 *
 996 * This function will return a pointer to a dentry if it succeeds.  This
 997 * pointer must be passed to the debugfs_remove() function when the file is
 998 * to be removed (no automatic cleanup happens if your module is unloaded,
 999 * you are responsible here.)  If an error occurs, ERR_PTR(-ERROR) will be
1000 * returned.
1001 *
1002 * If debugfs is not enabled in the kernel, the value ERR_PTR(-ENODEV) will
1003 * be returned.
1004 */
1005struct dentry *debugfs_create_blob(const char *name, umode_t mode,
1006				   struct dentry *parent,
1007				   struct debugfs_blob_wrapper *blob)
1008{
1009	return debugfs_create_file_unsafe(name, mode & 0444, parent, blob, &fops_blob);
1010}
1011EXPORT_SYMBOL_GPL(debugfs_create_blob);
1012
1013static size_t u32_format_array(char *buf, size_t bufsize,
1014			       u32 *array, int array_size)
1015{
1016	size_t ret = 0;
1017
1018	while (--array_size >= 0) {
1019		size_t len;
1020		char term = array_size ? ' ' : '\n';
1021
1022		len = snprintf(buf, bufsize, "%u%c", *array++, term);
1023		ret += len;
1024
1025		buf += len;
1026		bufsize -= len;
1027	}
1028	return ret;
1029}
1030
1031static int u32_array_open(struct inode *inode, struct file *file)
1032{
1033	struct debugfs_u32_array *data = inode->i_private;
1034	int size, elements = data->n_elements;
1035	char *buf;
1036
1037	/*
1038	 * Max size:
1039	 *  - 10 digits + ' '/'\n' = 11 bytes per number
1040	 *  - terminating NUL character
1041	 */
1042	size = elements*11;
1043	buf = kmalloc(size+1, GFP_KERNEL);
1044	if (!buf)
1045		return -ENOMEM;
1046	buf[size] = 0;
1047
1048	file->private_data = buf;
1049	u32_format_array(buf, size, data->array, data->n_elements);
1050
1051	return nonseekable_open(inode, file);
1052}
1053
1054static ssize_t u32_array_read(struct file *file, char __user *buf, size_t len,
1055			      loff_t *ppos)
1056{
1057	size_t size = strlen(file->private_data);
1058
1059	return simple_read_from_buffer(buf, len, ppos,
1060					file->private_data, size);
1061}
1062
1063static int u32_array_release(struct inode *inode, struct file *file)
1064{
1065	kfree(file->private_data);
1066
1067	return 0;
1068}
1069
1070static const struct file_operations u32_array_fops = {
1071	.owner	 = THIS_MODULE,
1072	.open	 = u32_array_open,
1073	.release = u32_array_release,
1074	.read	 = u32_array_read,
1075	.llseek  = no_llseek,
1076};
1077
1078/**
1079 * debugfs_create_u32_array - create a debugfs file that is used to read u32
1080 * array.
1081 * @name: a pointer to a string containing the name of the file to create.
1082 * @mode: the permission that the file should have.
1083 * @parent: a pointer to the parent dentry for this file.  This should be a
1084 *          directory dentry if set.  If this parameter is %NULL, then the
1085 *          file will be created in the root of the debugfs filesystem.
1086 * @array: wrapper struct containing data pointer and size of the array.
1087 *
1088 * This function creates a file in debugfs with the given name that exports
1089 * @array as data. If the @mode variable is so set it can be read from.
1090 * Writing is not supported. Seek within the file is also not supported.
1091 * Once array is created its size can not be changed.
1092 */
1093void debugfs_create_u32_array(const char *name, umode_t mode,
1094			      struct dentry *parent,
1095			      struct debugfs_u32_array *array)
1096{
1097	debugfs_create_file_unsafe(name, mode, parent, array, &u32_array_fops);
1098}
1099EXPORT_SYMBOL_GPL(debugfs_create_u32_array);
1100
1101#ifdef CONFIG_HAS_IOMEM
1102
1103/*
1104 * The regset32 stuff is used to print 32-bit registers using the
1105 * seq_file utilities. We offer printing a register set in an already-opened
1106 * sequential file or create a debugfs file that only prints a regset32.
1107 */
1108
1109/**
1110 * debugfs_print_regs32 - use seq_print to describe a set of registers
1111 * @s: the seq_file structure being used to generate output
1112 * @regs: an array if struct debugfs_reg32 structures
1113 * @nregs: the length of the above array
1114 * @base: the base address to be used in reading the registers
1115 * @prefix: a string to be prefixed to every output line
1116 *
1117 * This function outputs a text block describing the current values of
1118 * some 32-bit hardware registers. It is meant to be used within debugfs
1119 * files based on seq_file that need to show registers, intermixed with other
1120 * information. The prefix argument may be used to specify a leading string,
1121 * because some peripherals have several blocks of identical registers,
1122 * for example configuration of dma channels
1123 */
1124void debugfs_print_regs32(struct seq_file *s, const struct debugfs_reg32 *regs,
1125			  int nregs, void __iomem *base, char *prefix)
1126{
1127	int i;
1128
1129	for (i = 0; i < nregs; i++, regs++) {
1130		if (prefix)
1131			seq_printf(s, "%s", prefix);
1132		seq_printf(s, "%s = 0x%08x\n", regs->name,
1133			   readl(base + regs->offset));
1134		if (seq_has_overflowed(s))
1135			break;
1136	}
1137}
1138EXPORT_SYMBOL_GPL(debugfs_print_regs32);
1139
1140static int debugfs_regset32_show(struct seq_file *s, void *data)
1141{
1142	struct debugfs_regset32 *regset = s->private;
1143
1144	if (regset->dev)
1145		pm_runtime_get_sync(regset->dev);
1146
1147	debugfs_print_regs32(s, regset->regs, regset->nregs, regset->base, "");
1148
1149	if (regset->dev)
1150		pm_runtime_put(regset->dev);
1151
1152	return 0;
1153}
1154
1155DEFINE_SHOW_ATTRIBUTE(debugfs_regset32);
 
 
 
 
 
 
 
 
 
 
1156
1157/**
1158 * debugfs_create_regset32 - create a debugfs file that returns register values
1159 * @name: a pointer to a string containing the name of the file to create.
1160 * @mode: the permission that the file should have
1161 * @parent: a pointer to the parent dentry for this file.  This should be a
1162 *          directory dentry if set.  If this parameter is %NULL, then the
1163 *          file will be created in the root of the debugfs filesystem.
1164 * @regset: a pointer to a struct debugfs_regset32, which contains a pointer
1165 *          to an array of register definitions, the array size and the base
1166 *          address where the register bank is to be found.
1167 *
1168 * This function creates a file in debugfs with the given name that reports
1169 * the names and values of a set of 32-bit registers. If the @mode variable
1170 * is so set it can be read from. Writing is not supported.
1171 */
1172void debugfs_create_regset32(const char *name, umode_t mode,
1173			     struct dentry *parent,
1174			     struct debugfs_regset32 *regset)
1175{
1176	debugfs_create_file(name, mode, parent, regset, &debugfs_regset32_fops);
1177}
1178EXPORT_SYMBOL_GPL(debugfs_create_regset32);
1179
1180#endif /* CONFIG_HAS_IOMEM */
1181
1182struct debugfs_devm_entry {
1183	int (*read)(struct seq_file *seq, void *data);
1184	struct device *dev;
1185};
1186
1187static int debugfs_devm_entry_open(struct inode *inode, struct file *f)
1188{
1189	struct debugfs_devm_entry *entry = inode->i_private;
1190
1191	return single_open(f, entry->read, entry->dev);
1192}
1193
1194static const struct file_operations debugfs_devm_entry_ops = {
1195	.owner = THIS_MODULE,
1196	.open = debugfs_devm_entry_open,
1197	.release = single_release,
1198	.read = seq_read,
1199	.llseek = seq_lseek
1200};
1201
1202/**
1203 * debugfs_create_devm_seqfile - create a debugfs file that is bound to device.
1204 *
1205 * @dev: device related to this debugfs file.
1206 * @name: name of the debugfs file.
1207 * @parent: a pointer to the parent dentry for this file.  This should be a
1208 *	directory dentry if set.  If this parameter is %NULL, then the
1209 *	file will be created in the root of the debugfs filesystem.
1210 * @read_fn: function pointer called to print the seq_file content.
1211 */
1212void debugfs_create_devm_seqfile(struct device *dev, const char *name,
1213				 struct dentry *parent,
1214				 int (*read_fn)(struct seq_file *s, void *data))
1215{
1216	struct debugfs_devm_entry *entry;
1217
1218	if (IS_ERR(parent))
1219		return;
1220
1221	entry = devm_kzalloc(dev, sizeof(*entry), GFP_KERNEL);
1222	if (!entry)
1223		return;
1224
1225	entry->read = read_fn;
1226	entry->dev = dev;
1227
1228	debugfs_create_file(name, S_IRUGO, parent, entry,
1229			    &debugfs_devm_entry_ops);
1230}
1231EXPORT_SYMBOL_GPL(debugfs_create_devm_seqfile);