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