1 // SPDX-License-Identifier: GPL-2.0
3 * file.c - part of debugfs, a tiny little debug file system
5 * Copyright (C) 2004 Greg Kroah-Hartman <greg@kroah.com>
6 * Copyright (C) 2004 IBM Inc.
8 * debugfs is for people to use instead of /proc or /sys.
9 * See Documentation/filesystems/ for more details.
12 #include <linux/module.h>
14 #include <linux/seq_file.h>
15 #include <linux/pagemap.h>
16 #include <linux/debugfs.h>
18 #include <linux/slab.h>
19 #include <linux/atomic.h>
20 #include <linux/device.h>
21 #include <linux/poll.h>
22 #include <linux/security.h>
26 struct poll_table_struct;
28 static ssize_t default_read_file(struct file *file, char __user *buf,
29 size_t count, loff_t *ppos)
34 static ssize_t default_write_file(struct file *file, const char __user *buf,
35 size_t count, loff_t *ppos)
40 const struct file_operations debugfs_noop_file_operations = {
41 .read = default_read_file,
42 .write = default_write_file,
44 .llseek = noop_llseek,
47 #define F_DENTRY(filp) ((filp)->f_path.dentry)
49 const struct file_operations *debugfs_real_fops(const struct file *filp)
51 struct debugfs_fsdata *fsd = F_DENTRY(filp)->d_fsdata;
53 if ((unsigned long)fsd & DEBUGFS_FSDATA_IS_REAL_FOPS_BIT) {
55 * Urgh, we've been called w/o a protecting
62 return fsd->real_fops;
64 EXPORT_SYMBOL_GPL(debugfs_real_fops);
67 * debugfs_file_get - mark the beginning of file data access
68 * @dentry: the dentry object whose data is being accessed.
70 * Up to a matching call to debugfs_file_put(), any successive call
71 * into the file removing functions debugfs_remove() and
72 * debugfs_remove_recursive() will block. Since associated private
73 * file data may only get freed after a successful return of any of
74 * the removal functions, you may safely access it after a successful
75 * call to debugfs_file_get() without worrying about lifetime issues.
77 * If -%EIO is returned, the file has already been removed and thus,
78 * it is not safe to access any of its data. If, on the other hand,
79 * it is allowed to access the file data, zero is returned.
81 int debugfs_file_get(struct dentry *dentry)
83 struct debugfs_fsdata *fsd;
86 d_fsd = READ_ONCE(dentry->d_fsdata);
87 if (!((unsigned long)d_fsd & DEBUGFS_FSDATA_IS_REAL_FOPS_BIT)) {
90 fsd = kmalloc(sizeof(*fsd), GFP_KERNEL);
94 fsd->real_fops = (void *)((unsigned long)d_fsd &
95 ~DEBUGFS_FSDATA_IS_REAL_FOPS_BIT);
96 refcount_set(&fsd->active_users, 1);
97 init_completion(&fsd->active_users_drained);
98 if (cmpxchg(&dentry->d_fsdata, d_fsd, fsd) != d_fsd) {
100 fsd = READ_ONCE(dentry->d_fsdata);
105 * In case of a successful cmpxchg() above, this check is
106 * strictly necessary and must follow it, see the comment in
107 * __debugfs_remove_file().
108 * OTOH, if the cmpxchg() hasn't been executed or wasn't
109 * successful, this serves the purpose of not starving
112 if (d_unlinked(dentry))
115 if (!refcount_inc_not_zero(&fsd->active_users))
120 EXPORT_SYMBOL_GPL(debugfs_file_get);
123 * debugfs_file_put - mark the end of file data access
124 * @dentry: the dentry object formerly passed to
125 * debugfs_file_get().
127 * Allow any ongoing concurrent call into debugfs_remove() or
128 * debugfs_remove_recursive() blocked by a former call to
129 * debugfs_file_get() to proceed and return to its caller.
131 void debugfs_file_put(struct dentry *dentry)
133 struct debugfs_fsdata *fsd = READ_ONCE(dentry->d_fsdata);
135 if (refcount_dec_and_test(&fsd->active_users))
136 complete(&fsd->active_users_drained);
138 EXPORT_SYMBOL_GPL(debugfs_file_put);
141 * Only permit access to world-readable files when the kernel is locked down.
142 * We also need to exclude any file that has ways to write or alter it as root
143 * can bypass the permissions check.
145 static bool debugfs_is_locked_down(struct inode *inode,
147 const struct file_operations *real_fops)
149 if ((inode->i_mode & 07777) == 0444 &&
150 !(filp->f_mode & FMODE_WRITE) &&
151 !real_fops->unlocked_ioctl &&
152 !real_fops->compat_ioctl &&
156 return security_locked_down(LOCKDOWN_DEBUGFS);
159 static int open_proxy_open(struct inode *inode, struct file *filp)
161 struct dentry *dentry = F_DENTRY(filp);
162 const struct file_operations *real_fops = NULL;
165 r = debugfs_file_get(dentry);
167 return r == -EIO ? -ENOENT : r;
169 real_fops = debugfs_real_fops(filp);
171 r = debugfs_is_locked_down(inode, filp, real_fops);
175 real_fops = fops_get(real_fops);
177 /* Huh? Module did not clean up after itself at exit? */
178 WARN(1, "debugfs file owner did not clean up at exit: %pd",
183 replace_fops(filp, real_fops);
186 r = real_fops->open(inode, filp);
189 debugfs_file_put(dentry);
193 const struct file_operations debugfs_open_proxy_file_operations = {
194 .open = open_proxy_open,
197 #define PROTO(args...) args
198 #define ARGS(args...) args
200 #define FULL_PROXY_FUNC(name, ret_type, filp, proto, args) \
201 static ret_type full_proxy_ ## name(proto) \
203 struct dentry *dentry = F_DENTRY(filp); \
204 const struct file_operations *real_fops; \
207 r = debugfs_file_get(dentry); \
210 real_fops = debugfs_real_fops(filp); \
211 r = real_fops->name(args); \
212 debugfs_file_put(dentry); \
216 FULL_PROXY_FUNC(llseek, loff_t, filp,
217 PROTO(struct file *filp, loff_t offset, int whence),
218 ARGS(filp, offset, whence));
220 FULL_PROXY_FUNC(read, ssize_t, filp,
221 PROTO(struct file *filp, char __user *buf, size_t size,
223 ARGS(filp, buf, size, ppos));
225 FULL_PROXY_FUNC(write, ssize_t, filp,
226 PROTO(struct file *filp, const char __user *buf, size_t size,
228 ARGS(filp, buf, size, ppos));
230 FULL_PROXY_FUNC(unlocked_ioctl, long, filp,
231 PROTO(struct file *filp, unsigned int cmd, unsigned long arg),
232 ARGS(filp, cmd, arg));
234 static __poll_t full_proxy_poll(struct file *filp,
235 struct poll_table_struct *wait)
237 struct dentry *dentry = F_DENTRY(filp);
239 const struct file_operations *real_fops;
241 if (debugfs_file_get(dentry))
244 real_fops = debugfs_real_fops(filp);
245 r = real_fops->poll(filp, wait);
246 debugfs_file_put(dentry);
250 static int full_proxy_release(struct inode *inode, struct file *filp)
252 const struct dentry *dentry = F_DENTRY(filp);
253 const struct file_operations *real_fops = debugfs_real_fops(filp);
254 const struct file_operations *proxy_fops = filp->f_op;
258 * We must not protect this against removal races here: the
259 * original releaser should be called unconditionally in order
260 * not to leak any resources. Releasers must not assume that
261 * ->i_private is still being meaningful here.
263 if (real_fops->release)
264 r = real_fops->release(inode, filp);
266 replace_fops(filp, d_inode(dentry)->i_fop);
267 kfree((void *)proxy_fops);
272 static void __full_proxy_fops_init(struct file_operations *proxy_fops,
273 const struct file_operations *real_fops)
275 proxy_fops->release = full_proxy_release;
276 if (real_fops->llseek)
277 proxy_fops->llseek = full_proxy_llseek;
279 proxy_fops->read = full_proxy_read;
280 if (real_fops->write)
281 proxy_fops->write = full_proxy_write;
283 proxy_fops->poll = full_proxy_poll;
284 if (real_fops->unlocked_ioctl)
285 proxy_fops->unlocked_ioctl = full_proxy_unlocked_ioctl;
288 static int full_proxy_open(struct inode *inode, struct file *filp)
290 struct dentry *dentry = F_DENTRY(filp);
291 const struct file_operations *real_fops = NULL;
292 struct file_operations *proxy_fops = NULL;
295 r = debugfs_file_get(dentry);
297 return r == -EIO ? -ENOENT : r;
299 real_fops = debugfs_real_fops(filp);
301 r = debugfs_is_locked_down(inode, filp, real_fops);
305 real_fops = fops_get(real_fops);
307 /* Huh? Module did not cleanup after itself at exit? */
308 WARN(1, "debugfs file owner did not clean up at exit: %pd",
314 proxy_fops = kzalloc(sizeof(*proxy_fops), GFP_KERNEL);
319 __full_proxy_fops_init(proxy_fops, real_fops);
320 replace_fops(filp, proxy_fops);
322 if (real_fops->open) {
323 r = real_fops->open(inode, filp);
325 replace_fops(filp, d_inode(dentry)->i_fop);
327 } else if (filp->f_op != proxy_fops) {
328 /* No protection against file removal anymore. */
329 WARN(1, "debugfs file owner replaced proxy fops: %pd",
340 debugfs_file_put(dentry);
344 const struct file_operations debugfs_full_proxy_file_operations = {
345 .open = full_proxy_open,
348 ssize_t debugfs_attr_read(struct file *file, char __user *buf,
349 size_t len, loff_t *ppos)
351 struct dentry *dentry = F_DENTRY(file);
354 ret = debugfs_file_get(dentry);
357 ret = simple_attr_read(file, buf, len, ppos);
358 debugfs_file_put(dentry);
361 EXPORT_SYMBOL_GPL(debugfs_attr_read);
363 ssize_t debugfs_attr_write(struct file *file, const char __user *buf,
364 size_t len, loff_t *ppos)
366 struct dentry *dentry = F_DENTRY(file);
369 ret = debugfs_file_get(dentry);
372 ret = simple_attr_write(file, buf, len, ppos);
373 debugfs_file_put(dentry);
376 EXPORT_SYMBOL_GPL(debugfs_attr_write);
378 static struct dentry *debugfs_create_mode_unsafe(const char *name, umode_t mode,
379 struct dentry *parent, void *value,
380 const struct file_operations *fops,
381 const struct file_operations *fops_ro,
382 const struct file_operations *fops_wo)
384 /* if there are no write bits set, make read only */
385 if (!(mode & S_IWUGO))
386 return debugfs_create_file_unsafe(name, mode, parent, value,
388 /* if there are no read bits set, make write only */
389 if (!(mode & S_IRUGO))
390 return debugfs_create_file_unsafe(name, mode, parent, value,
393 return debugfs_create_file_unsafe(name, mode, parent, value, fops);
396 static int debugfs_u8_set(void *data, u64 val)
401 static int debugfs_u8_get(void *data, u64 *val)
406 DEFINE_DEBUGFS_ATTRIBUTE(fops_u8, debugfs_u8_get, debugfs_u8_set, "%llu\n");
407 DEFINE_DEBUGFS_ATTRIBUTE(fops_u8_ro, debugfs_u8_get, NULL, "%llu\n");
408 DEFINE_DEBUGFS_ATTRIBUTE(fops_u8_wo, NULL, debugfs_u8_set, "%llu\n");
411 * debugfs_create_u8 - create a debugfs file that is used to read and write an unsigned 8-bit value
412 * @name: a pointer to a string containing the name of the file to create.
413 * @mode: the permission that the file should have
414 * @parent: a pointer to the parent dentry for this file. This should be a
415 * directory dentry if set. If this parameter is %NULL, then the
416 * file will be created in the root of the debugfs filesystem.
417 * @value: a pointer to the variable that the file should read to and write
420 * This function creates a file in debugfs with the given name that
421 * contains the value of the variable @value. If the @mode variable is so
422 * set, it can be read from, and written to.
424 void debugfs_create_u8(const char *name, umode_t mode, struct dentry *parent,
427 debugfs_create_mode_unsafe(name, mode, parent, value, &fops_u8,
428 &fops_u8_ro, &fops_u8_wo);
430 EXPORT_SYMBOL_GPL(debugfs_create_u8);
432 static int debugfs_u16_set(void *data, u64 val)
437 static int debugfs_u16_get(void *data, u64 *val)
442 DEFINE_DEBUGFS_ATTRIBUTE(fops_u16, debugfs_u16_get, debugfs_u16_set, "%llu\n");
443 DEFINE_DEBUGFS_ATTRIBUTE(fops_u16_ro, debugfs_u16_get, NULL, "%llu\n");
444 DEFINE_DEBUGFS_ATTRIBUTE(fops_u16_wo, NULL, debugfs_u16_set, "%llu\n");
447 * debugfs_create_u16 - create a debugfs file that is used to read and write an unsigned 16-bit value
448 * @name: a pointer to a string containing the name of the file to create.
449 * @mode: the permission that the file should have
450 * @parent: a pointer to the parent dentry for this file. This should be a
451 * directory dentry if set. If this parameter is %NULL, then the
452 * file will be created in the root of the debugfs filesystem.
453 * @value: a pointer to the variable that the file should read to and write
456 * This function creates a file in debugfs with the given name that
457 * contains the value of the variable @value. If the @mode variable is so
458 * set, it can be read from, and written to.
460 void debugfs_create_u16(const char *name, umode_t mode, struct dentry *parent,
463 debugfs_create_mode_unsafe(name, mode, parent, value, &fops_u16,
464 &fops_u16_ro, &fops_u16_wo);
466 EXPORT_SYMBOL_GPL(debugfs_create_u16);
468 static int debugfs_u32_set(void *data, u64 val)
473 static int debugfs_u32_get(void *data, u64 *val)
478 DEFINE_DEBUGFS_ATTRIBUTE(fops_u32, debugfs_u32_get, debugfs_u32_set, "%llu\n");
479 DEFINE_DEBUGFS_ATTRIBUTE(fops_u32_ro, debugfs_u32_get, NULL, "%llu\n");
480 DEFINE_DEBUGFS_ATTRIBUTE(fops_u32_wo, NULL, debugfs_u32_set, "%llu\n");
483 * debugfs_create_u32 - create a debugfs file that is used to read and write an unsigned 32-bit value
484 * @name: a pointer to a string containing the name of the file to create.
485 * @mode: the permission that the file should have
486 * @parent: a pointer to the parent dentry for this file. This should be a
487 * directory dentry if set. If this parameter is %NULL, then the
488 * file will be created in the root of the debugfs filesystem.
489 * @value: a pointer to the variable that the file should read to and write
492 * This function creates a file in debugfs with the given name that
493 * contains the value of the variable @value. If the @mode variable is so
494 * set, it can be read from, and written to.
496 * This function will return a pointer to a dentry if it succeeds. This
497 * pointer must be passed to the debugfs_remove() function when the file is
498 * to be removed (no automatic cleanup happens if your module is unloaded,
499 * you are responsible here.) If an error occurs, %ERR_PTR(-ERROR) will be
502 * If debugfs is not enabled in the kernel, the value %ERR_PTR(-ENODEV) will
505 struct dentry *debugfs_create_u32(const char *name, umode_t mode,
506 struct dentry *parent, u32 *value)
508 return debugfs_create_mode_unsafe(name, mode, parent, value, &fops_u32,
509 &fops_u32_ro, &fops_u32_wo);
511 EXPORT_SYMBOL_GPL(debugfs_create_u32);
513 static int debugfs_u64_set(void *data, u64 val)
519 static int debugfs_u64_get(void *data, u64 *val)
524 DEFINE_DEBUGFS_ATTRIBUTE(fops_u64, debugfs_u64_get, debugfs_u64_set, "%llu\n");
525 DEFINE_DEBUGFS_ATTRIBUTE(fops_u64_ro, debugfs_u64_get, NULL, "%llu\n");
526 DEFINE_DEBUGFS_ATTRIBUTE(fops_u64_wo, NULL, debugfs_u64_set, "%llu\n");
529 * debugfs_create_u64 - create a debugfs file that is used to read and write an unsigned 64-bit value
530 * @name: a pointer to a string containing the name of the file to create.
531 * @mode: the permission that the file should have
532 * @parent: a pointer to the parent dentry for this file. This should be a
533 * directory dentry if set. If this parameter is %NULL, then the
534 * file will be created in the root of the debugfs filesystem.
535 * @value: a pointer to the variable that the file should read to and write
538 * This function creates a file in debugfs with the given name that
539 * contains the value of the variable @value. If the @mode variable is so
540 * set, it can be read from, and written to.
542 void debugfs_create_u64(const char *name, umode_t mode, struct dentry *parent,
545 debugfs_create_mode_unsafe(name, mode, parent, value, &fops_u64,
546 &fops_u64_ro, &fops_u64_wo);
548 EXPORT_SYMBOL_GPL(debugfs_create_u64);
550 static int debugfs_ulong_set(void *data, u64 val)
552 *(unsigned long *)data = val;
556 static int debugfs_ulong_get(void *data, u64 *val)
558 *val = *(unsigned long *)data;
561 DEFINE_DEBUGFS_ATTRIBUTE(fops_ulong, debugfs_ulong_get, debugfs_ulong_set,
563 DEFINE_DEBUGFS_ATTRIBUTE(fops_ulong_ro, debugfs_ulong_get, NULL, "%llu\n");
564 DEFINE_DEBUGFS_ATTRIBUTE(fops_ulong_wo, NULL, debugfs_ulong_set, "%llu\n");
567 * debugfs_create_ulong - create a debugfs file that is used to read and write
568 * an unsigned long value.
569 * @name: a pointer to a string containing the name of the file to create.
570 * @mode: the permission that the file should have
571 * @parent: a pointer to the parent dentry for this file. This should be a
572 * directory dentry if set. If this parameter is %NULL, then the
573 * file will be created in the root of the debugfs filesystem.
574 * @value: a pointer to the variable that the file should read to and write
577 * This function creates a file in debugfs with the given name that
578 * contains the value of the variable @value. If the @mode variable is so
579 * set, it can be read from, and written to.
581 * This function will return a pointer to a dentry if it succeeds. This
582 * pointer must be passed to the debugfs_remove() function when the file is
583 * to be removed (no automatic cleanup happens if your module is unloaded,
584 * you are responsible here.) If an error occurs, %ERR_PTR(-ERROR) will be
587 * If debugfs is not enabled in the kernel, the value %ERR_PTR(-ENODEV) will
590 struct dentry *debugfs_create_ulong(const char *name, umode_t mode,
591 struct dentry *parent, unsigned long *value)
593 return debugfs_create_mode_unsafe(name, mode, parent, value,
594 &fops_ulong, &fops_ulong_ro,
597 EXPORT_SYMBOL_GPL(debugfs_create_ulong);
599 DEFINE_DEBUGFS_ATTRIBUTE(fops_x8, debugfs_u8_get, debugfs_u8_set, "0x%02llx\n");
600 DEFINE_DEBUGFS_ATTRIBUTE(fops_x8_ro, debugfs_u8_get, NULL, "0x%02llx\n");
601 DEFINE_DEBUGFS_ATTRIBUTE(fops_x8_wo, NULL, debugfs_u8_set, "0x%02llx\n");
603 DEFINE_DEBUGFS_ATTRIBUTE(fops_x16, debugfs_u16_get, debugfs_u16_set,
605 DEFINE_DEBUGFS_ATTRIBUTE(fops_x16_ro, debugfs_u16_get, NULL, "0x%04llx\n");
606 DEFINE_DEBUGFS_ATTRIBUTE(fops_x16_wo, NULL, debugfs_u16_set, "0x%04llx\n");
608 DEFINE_DEBUGFS_ATTRIBUTE(fops_x32, debugfs_u32_get, debugfs_u32_set,
610 DEFINE_DEBUGFS_ATTRIBUTE(fops_x32_ro, debugfs_u32_get, NULL, "0x%08llx\n");
611 DEFINE_DEBUGFS_ATTRIBUTE(fops_x32_wo, NULL, debugfs_u32_set, "0x%08llx\n");
613 DEFINE_DEBUGFS_ATTRIBUTE(fops_x64, debugfs_u64_get, debugfs_u64_set,
615 DEFINE_DEBUGFS_ATTRIBUTE(fops_x64_ro, debugfs_u64_get, NULL, "0x%016llx\n");
616 DEFINE_DEBUGFS_ATTRIBUTE(fops_x64_wo, NULL, debugfs_u64_set, "0x%016llx\n");
619 * 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
621 * These functions are exactly the same as the above functions (but use a hex
622 * output for the decimal challenged). For details look at the above unsigned
627 * debugfs_create_x8 - create a debugfs file that is used to read and write an unsigned 8-bit value
628 * @name: a pointer to a string containing the name of the file to create.
629 * @mode: the permission that the file should have
630 * @parent: a pointer to the parent dentry for this file. This should be a
631 * directory dentry if set. If this parameter is %NULL, then the
632 * file will be created in the root of the debugfs filesystem.
633 * @value: a pointer to the variable that the file should read to and write
636 void debugfs_create_x8(const char *name, umode_t mode, struct dentry *parent,
639 debugfs_create_mode_unsafe(name, mode, parent, value, &fops_x8,
640 &fops_x8_ro, &fops_x8_wo);
642 EXPORT_SYMBOL_GPL(debugfs_create_x8);
645 * debugfs_create_x16 - create a debugfs file that is used to read and write an unsigned 16-bit value
646 * @name: a pointer to a string containing the name of the file to create.
647 * @mode: the permission that the file should have
648 * @parent: a pointer to the parent dentry for this file. This should be a
649 * directory dentry if set. If this parameter is %NULL, then the
650 * file will be created in the root of the debugfs filesystem.
651 * @value: a pointer to the variable that the file should read to and write
654 void debugfs_create_x16(const char *name, umode_t mode, struct dentry *parent,
657 debugfs_create_mode_unsafe(name, mode, parent, value, &fops_x16,
658 &fops_x16_ro, &fops_x16_wo);
660 EXPORT_SYMBOL_GPL(debugfs_create_x16);
663 * debugfs_create_x32 - create a debugfs file that is used to read and write an unsigned 32-bit value
664 * @name: a pointer to a string containing the name of the file to create.
665 * @mode: the permission that the file should have
666 * @parent: a pointer to the parent dentry for this file. This should be a
667 * directory dentry if set. If this parameter is %NULL, then the
668 * file will be created in the root of the debugfs filesystem.
669 * @value: a pointer to the variable that the file should read to and write
672 void debugfs_create_x32(const char *name, umode_t mode, struct dentry *parent,
675 debugfs_create_mode_unsafe(name, mode, parent, value, &fops_x32,
676 &fops_x32_ro, &fops_x32_wo);
678 EXPORT_SYMBOL_GPL(debugfs_create_x32);
681 * debugfs_create_x64 - create a debugfs file that is used to read and write an unsigned 64-bit value
682 * @name: a pointer to a string containing the name of the file to create.
683 * @mode: the permission that the file should have
684 * @parent: a pointer to the parent dentry for this file. This should be a
685 * directory dentry if set. If this parameter is %NULL, then the
686 * file will be created in the root of the debugfs filesystem.
687 * @value: a pointer to the variable that the file should read to and write
690 void debugfs_create_x64(const char *name, umode_t mode, struct dentry *parent,
693 debugfs_create_mode_unsafe(name, mode, parent, value, &fops_x64,
694 &fops_x64_ro, &fops_x64_wo);
696 EXPORT_SYMBOL_GPL(debugfs_create_x64);
699 static int debugfs_size_t_set(void *data, u64 val)
701 *(size_t *)data = val;
704 static int debugfs_size_t_get(void *data, u64 *val)
706 *val = *(size_t *)data;
709 DEFINE_DEBUGFS_ATTRIBUTE(fops_size_t, debugfs_size_t_get, debugfs_size_t_set,
710 "%llu\n"); /* %llu and %zu are more or less the same */
711 DEFINE_DEBUGFS_ATTRIBUTE(fops_size_t_ro, debugfs_size_t_get, NULL, "%llu\n");
712 DEFINE_DEBUGFS_ATTRIBUTE(fops_size_t_wo, NULL, debugfs_size_t_set, "%llu\n");
715 * debugfs_create_size_t - create a debugfs file that is used to read and write an size_t value
716 * @name: a pointer to a string containing the name of the file to create.
717 * @mode: the permission that the file should have
718 * @parent: a pointer to the parent dentry for this file. This should be a
719 * directory dentry if set. If this parameter is %NULL, then the
720 * file will be created in the root of the debugfs filesystem.
721 * @value: a pointer to the variable that the file should read to and write
724 void debugfs_create_size_t(const char *name, umode_t mode,
725 struct dentry *parent, size_t *value)
727 debugfs_create_mode_unsafe(name, mode, parent, value, &fops_size_t,
728 &fops_size_t_ro, &fops_size_t_wo);
730 EXPORT_SYMBOL_GPL(debugfs_create_size_t);
732 static int debugfs_atomic_t_set(void *data, u64 val)
734 atomic_set((atomic_t *)data, val);
737 static int debugfs_atomic_t_get(void *data, u64 *val)
739 *val = atomic_read((atomic_t *)data);
742 DEFINE_DEBUGFS_ATTRIBUTE(fops_atomic_t, debugfs_atomic_t_get,
743 debugfs_atomic_t_set, "%lld\n");
744 DEFINE_DEBUGFS_ATTRIBUTE(fops_atomic_t_ro, debugfs_atomic_t_get, NULL,
746 DEFINE_DEBUGFS_ATTRIBUTE(fops_atomic_t_wo, NULL, debugfs_atomic_t_set,
750 * debugfs_create_atomic_t - create a debugfs file that is used to read and
751 * write an atomic_t value
752 * @name: a pointer to a string containing the name of the file to create.
753 * @mode: the permission that the file should have
754 * @parent: a pointer to the parent dentry for this file. This should be a
755 * directory dentry if set. If this parameter is %NULL, then the
756 * file will be created in the root of the debugfs filesystem.
757 * @value: a pointer to the variable that the file should read to and write
760 void debugfs_create_atomic_t(const char *name, umode_t mode,
761 struct dentry *parent, atomic_t *value)
763 debugfs_create_mode_unsafe(name, mode, parent, value, &fops_atomic_t,
764 &fops_atomic_t_ro, &fops_atomic_t_wo);
766 EXPORT_SYMBOL_GPL(debugfs_create_atomic_t);
768 ssize_t debugfs_read_file_bool(struct file *file, char __user *user_buf,
769 size_t count, loff_t *ppos)
774 struct dentry *dentry = F_DENTRY(file);
776 r = debugfs_file_get(dentry);
779 val = *(bool *)file->private_data;
780 debugfs_file_put(dentry);
788 return simple_read_from_buffer(user_buf, count, ppos, buf, 2);
790 EXPORT_SYMBOL_GPL(debugfs_read_file_bool);
792 ssize_t debugfs_write_file_bool(struct file *file, const char __user *user_buf,
793 size_t count, loff_t *ppos)
797 bool *val = file->private_data;
798 struct dentry *dentry = F_DENTRY(file);
800 r = kstrtobool_from_user(user_buf, count, &bv);
802 r = debugfs_file_get(dentry);
806 debugfs_file_put(dentry);
811 EXPORT_SYMBOL_GPL(debugfs_write_file_bool);
813 static const struct file_operations fops_bool = {
814 .read = debugfs_read_file_bool,
815 .write = debugfs_write_file_bool,
817 .llseek = default_llseek,
820 static const struct file_operations fops_bool_ro = {
821 .read = debugfs_read_file_bool,
823 .llseek = default_llseek,
826 static const struct file_operations fops_bool_wo = {
827 .write = debugfs_write_file_bool,
829 .llseek = default_llseek,
833 * debugfs_create_bool - create a debugfs file that is used to read and write a boolean value
834 * @name: a pointer to a string containing the name of the file to create.
835 * @mode: the permission that the file should have
836 * @parent: a pointer to the parent dentry for this file. This should be a
837 * directory dentry if set. If this parameter is %NULL, then the
838 * file will be created in the root of the debugfs filesystem.
839 * @value: a pointer to the variable that the file should read to and write
842 * This function creates a file in debugfs with the given name that
843 * contains the value of the variable @value. If the @mode variable is so
844 * set, it can be read from, and written to.
846 * This function will return a pointer to a dentry if it succeeds. This
847 * pointer must be passed to the debugfs_remove() function when the file is
848 * to be removed (no automatic cleanup happens if your module is unloaded,
849 * you are responsible here.) If an error occurs, %ERR_PTR(-ERROR) will be
852 * If debugfs is not enabled in the kernel, the value %ERR_PTR(-ENODEV) will
855 struct dentry *debugfs_create_bool(const char *name, umode_t mode,
856 struct dentry *parent, bool *value)
858 return debugfs_create_mode_unsafe(name, mode, parent, value, &fops_bool,
859 &fops_bool_ro, &fops_bool_wo);
861 EXPORT_SYMBOL_GPL(debugfs_create_bool);
863 static ssize_t read_file_blob(struct file *file, char __user *user_buf,
864 size_t count, loff_t *ppos)
866 struct debugfs_blob_wrapper *blob = file->private_data;
867 struct dentry *dentry = F_DENTRY(file);
870 r = debugfs_file_get(dentry);
873 r = simple_read_from_buffer(user_buf, count, ppos, blob->data,
875 debugfs_file_put(dentry);
879 static const struct file_operations fops_blob = {
880 .read = read_file_blob,
882 .llseek = default_llseek,
886 * debugfs_create_blob - create a debugfs file that is used to read a binary blob
887 * @name: a pointer to a string containing the name of the file to create.
888 * @mode: the permission that the file should have
889 * @parent: a pointer to the parent dentry for this file. This should be a
890 * directory dentry if set. If this parameter is %NULL, then the
891 * file will be created in the root of the debugfs filesystem.
892 * @blob: a pointer to a struct debugfs_blob_wrapper which contains a pointer
893 * to the blob data and the size of the data.
895 * This function creates a file in debugfs with the given name that exports
896 * @blob->data as a binary blob. If the @mode variable is so set it can be
897 * read from. Writing is not supported.
899 * This function will return a pointer to a dentry if it succeeds. This
900 * pointer must be passed to the debugfs_remove() function when the file is
901 * to be removed (no automatic cleanup happens if your module is unloaded,
902 * you are responsible here.) If an error occurs, %ERR_PTR(-ERROR) will be
905 * If debugfs is not enabled in the kernel, the value %ERR_PTR(-ENODEV) will
908 struct dentry *debugfs_create_blob(const char *name, umode_t mode,
909 struct dentry *parent,
910 struct debugfs_blob_wrapper *blob)
912 return debugfs_create_file_unsafe(name, mode, parent, blob, &fops_blob);
914 EXPORT_SYMBOL_GPL(debugfs_create_blob);
921 static size_t u32_format_array(char *buf, size_t bufsize,
922 u32 *array, int array_size)
926 while (--array_size >= 0) {
928 char term = array_size ? ' ' : '\n';
930 len = snprintf(buf, bufsize, "%u%c", *array++, term);
939 static int u32_array_open(struct inode *inode, struct file *file)
941 struct array_data *data = inode->i_private;
942 int size, elements = data->elements;
947 * - 10 digits + ' '/'\n' = 11 bytes per number
948 * - terminating NUL character
951 buf = kmalloc(size+1, GFP_KERNEL);
956 file->private_data = buf;
957 u32_format_array(buf, size, data->array, data->elements);
959 return nonseekable_open(inode, file);
962 static ssize_t u32_array_read(struct file *file, char __user *buf, size_t len,
965 size_t size = strlen(file->private_data);
967 return simple_read_from_buffer(buf, len, ppos,
968 file->private_data, size);
971 static int u32_array_release(struct inode *inode, struct file *file)
973 kfree(file->private_data);
978 static 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,
987 * debugfs_create_u32_array - create a debugfs file that is used to read u32
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: u32 array that provides data.
995 * @elements: total number of elements in the array.
997 * This function creates a file in debugfs with the given name that exports
998 * @array as data. If the @mode variable is so set it can be read from.
999 * Writing is not supported. Seek within the file is also not supported.
1000 * Once array is created its size can not be changed.
1002 void debugfs_create_u32_array(const char *name, umode_t mode,
1003 struct dentry *parent, u32 *array, u32 elements)
1005 struct array_data *data = kmalloc(sizeof(*data), GFP_KERNEL);
1010 data->array = array;
1011 data->elements = elements;
1013 debugfs_create_file_unsafe(name, mode, parent, data, &u32_array_fops);
1015 EXPORT_SYMBOL_GPL(debugfs_create_u32_array);
1017 #ifdef CONFIG_HAS_IOMEM
1020 * The regset32 stuff is used to print 32-bit registers using the
1021 * seq_file utilities. We offer printing a register set in an already-opened
1022 * sequential file or create a debugfs file that only prints a regset32.
1026 * debugfs_print_regs32 - use seq_print to describe a set of registers
1027 * @s: the seq_file structure being used to generate output
1028 * @regs: an array if struct debugfs_reg32 structures
1029 * @nregs: the length of the above array
1030 * @base: the base address to be used in reading the registers
1031 * @prefix: a string to be prefixed to every output line
1033 * This function outputs a text block describing the current values of
1034 * some 32-bit hardware registers. It is meant to be used within debugfs
1035 * files based on seq_file that need to show registers, intermixed with other
1036 * information. The prefix argument may be used to specify a leading string,
1037 * because some peripherals have several blocks of identical registers,
1038 * for example configuration of dma channels
1040 void debugfs_print_regs32(struct seq_file *s, const struct debugfs_reg32 *regs,
1041 int nregs, void __iomem *base, char *prefix)
1045 for (i = 0; i < nregs; i++, regs++) {
1047 seq_printf(s, "%s", prefix);
1048 seq_printf(s, "%s = 0x%08x\n", regs->name,
1049 readl(base + regs->offset));
1050 if (seq_has_overflowed(s))
1054 EXPORT_SYMBOL_GPL(debugfs_print_regs32);
1056 static int debugfs_show_regset32(struct seq_file *s, void *data)
1058 struct debugfs_regset32 *regset = s->private;
1060 debugfs_print_regs32(s, regset->regs, regset->nregs, regset->base, "");
1064 static int debugfs_open_regset32(struct inode *inode, struct file *file)
1066 return single_open(file, debugfs_show_regset32, inode->i_private);
1069 static const struct file_operations fops_regset32 = {
1070 .open = debugfs_open_regset32,
1072 .llseek = seq_lseek,
1073 .release = single_release,
1077 * debugfs_create_regset32 - create a debugfs file that returns register values
1078 * @name: a pointer to a string containing the name of the file to create.
1079 * @mode: the permission that the file should have
1080 * @parent: a pointer to the parent dentry for this file. This should be a
1081 * directory dentry if set. If this parameter is %NULL, then the
1082 * file will be created in the root of the debugfs filesystem.
1083 * @regset: a pointer to a struct debugfs_regset32, which contains a pointer
1084 * to an array of register definitions, the array size and the base
1085 * address where the register bank is to be found.
1087 * This function creates a file in debugfs with the given name that reports
1088 * the names and values of a set of 32-bit registers. If the @mode variable
1089 * is so set it can be read from. Writing is not supported.
1091 * This function will return a pointer to a dentry if it succeeds. This
1092 * pointer must be passed to the debugfs_remove() function when the file is
1093 * to be removed (no automatic cleanup happens if your module is unloaded,
1094 * you are responsible here.) If an error occurs, %ERR_PTR(-ERROR) will be
1097 * If debugfs is not enabled in the kernel, the value %ERR_PTR(-ENODEV) will
1100 struct dentry *debugfs_create_regset32(const char *name, umode_t mode,
1101 struct dentry *parent,
1102 struct debugfs_regset32 *regset)
1104 return debugfs_create_file(name, mode, parent, regset, &fops_regset32);
1106 EXPORT_SYMBOL_GPL(debugfs_create_regset32);
1108 #endif /* CONFIG_HAS_IOMEM */
1110 struct debugfs_devm_entry {
1111 int (*read)(struct seq_file *seq, void *data);
1115 static int debugfs_devm_entry_open(struct inode *inode, struct file *f)
1117 struct debugfs_devm_entry *entry = inode->i_private;
1119 return single_open(f, entry->read, entry->dev);
1122 static const struct file_operations debugfs_devm_entry_ops = {
1123 .owner = THIS_MODULE,
1124 .open = debugfs_devm_entry_open,
1125 .release = single_release,
1131 * debugfs_create_devm_seqfile - create a debugfs file that is bound to device.
1133 * @dev: device related to this debugfs file.
1134 * @name: name of the debugfs file.
1135 * @parent: a pointer to the parent dentry for this file. This should be a
1136 * directory dentry if set. If this parameter is %NULL, then the
1137 * file will be created in the root of the debugfs filesystem.
1138 * @read_fn: function pointer called to print the seq_file content.
1140 struct dentry *debugfs_create_devm_seqfile(struct device *dev, const char *name,
1141 struct dentry *parent,
1142 int (*read_fn)(struct seq_file *s,
1145 struct debugfs_devm_entry *entry;
1148 return ERR_PTR(-ENOENT);
1150 entry = devm_kzalloc(dev, sizeof(*entry), GFP_KERNEL);
1152 return ERR_PTR(-ENOMEM);
1154 entry->read = read_fn;
1157 return debugfs_create_file(name, S_IRUGO, parent, entry,
1158 &debugfs_devm_entry_ops);
1160 EXPORT_SYMBOL_GPL(debugfs_create_devm_seqfile);