1377 lines · c
1// SPDX-License-Identifier: GPL-2.02/*3 * file.c - part of debugfs, a tiny little debug file system4 *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 protecting57 * 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 access69 * @dentry: the dentry object whose data is being accessed.70 *71 * Up to a matching call to debugfs_file_put(), any successive call72 * into the file removing functions debugfs_remove() and73 * debugfs_remove_recursive() will block. Since associated private74 * file data may only get freed after a successful return of any of75 * the removal functions, you may safely access it after a successful76 * 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 /*88 * This could only happen if some debugfs user erroneously calls89 * debugfs_file_get() on a dentry that isn't even a file, let90 * them know about it.91 */92 if (WARN_ON(!d_is_reg(dentry)))93 return -EINVAL;94 95 d_fsd = READ_ONCE(dentry->d_fsdata);96 if (!((unsigned long)d_fsd & DEBUGFS_FSDATA_IS_REAL_FOPS_BIT)) {97 fsd = d_fsd;98 } else {99 fsd = kmalloc(sizeof(*fsd), GFP_KERNEL);100 if (!fsd)101 return -ENOMEM;102 103 fsd->real_fops = (void *)((unsigned long)d_fsd &104 ~DEBUGFS_FSDATA_IS_REAL_FOPS_BIT);105 refcount_set(&fsd->active_users, 1);106 init_completion(&fsd->active_users_drained);107 INIT_LIST_HEAD(&fsd->cancellations);108 mutex_init(&fsd->cancellations_mtx);109 110 if (cmpxchg(&dentry->d_fsdata, d_fsd, fsd) != d_fsd) {111 mutex_destroy(&fsd->cancellations_mtx);112 kfree(fsd);113 fsd = READ_ONCE(dentry->d_fsdata);114 }115 }116 117 /*118 * In case of a successful cmpxchg() above, this check is119 * strictly necessary and must follow it, see the comment in120 * __debugfs_remove_file().121 * OTOH, if the cmpxchg() hasn't been executed or wasn't122 * successful, this serves the purpose of not starving123 * removers.124 */125 if (d_unlinked(dentry))126 return -EIO;127 128 if (!refcount_inc_not_zero(&fsd->active_users))129 return -EIO;130 131 return 0;132}133EXPORT_SYMBOL_GPL(debugfs_file_get);134 135/**136 * debugfs_file_put - mark the end of file data access137 * @dentry: the dentry object formerly passed to138 * debugfs_file_get().139 *140 * Allow any ongoing concurrent call into debugfs_remove() or141 * debugfs_remove_recursive() blocked by a former call to142 * debugfs_file_get() to proceed and return to its caller.143 */144void debugfs_file_put(struct dentry *dentry)145{146 struct debugfs_fsdata *fsd = READ_ONCE(dentry->d_fsdata);147 148 if (refcount_dec_and_test(&fsd->active_users))149 complete(&fsd->active_users_drained);150}151EXPORT_SYMBOL_GPL(debugfs_file_put);152 153/**154 * debugfs_enter_cancellation - enter a debugfs cancellation155 * @file: the file being accessed156 * @cancellation: the cancellation object, the cancel callback157 * inside of it must be initialized158 *159 * When a debugfs file is removed it needs to wait for all active160 * operations to complete. However, the operation itself may need161 * to wait for hardware or completion of some asynchronous process162 * or similar. As such, it may need to be cancelled to avoid long163 * waits or even deadlocks.164 *165 * This function can be used inside a debugfs handler that may166 * need to be cancelled. As soon as this function is called, the167 * cancellation's 'cancel' callback may be called, at which point168 * the caller should proceed to call debugfs_leave_cancellation()169 * and leave the debugfs handler function as soon as possible.170 * Note that the 'cancel' callback is only ever called in the171 * context of some kind of debugfs_remove().172 *173 * This function must be paired with debugfs_leave_cancellation().174 */175void debugfs_enter_cancellation(struct file *file,176 struct debugfs_cancellation *cancellation)177{178 struct debugfs_fsdata *fsd;179 struct dentry *dentry = F_DENTRY(file);180 181 INIT_LIST_HEAD(&cancellation->list);182 183 if (WARN_ON(!d_is_reg(dentry)))184 return;185 186 if (WARN_ON(!cancellation->cancel))187 return;188 189 fsd = READ_ONCE(dentry->d_fsdata);190 if (WARN_ON(!fsd ||191 ((unsigned long)fsd & DEBUGFS_FSDATA_IS_REAL_FOPS_BIT)))192 return;193 194 mutex_lock(&fsd->cancellations_mtx);195 list_add(&cancellation->list, &fsd->cancellations);196 mutex_unlock(&fsd->cancellations_mtx);197 198 /* if we're already removing wake it up to cancel */199 if (d_unlinked(dentry))200 complete(&fsd->active_users_drained);201}202EXPORT_SYMBOL_GPL(debugfs_enter_cancellation);203 204/**205 * debugfs_leave_cancellation - leave cancellation section206 * @file: the file being accessed207 * @cancellation: the cancellation previously registered with208 * debugfs_enter_cancellation()209 *210 * See the documentation of debugfs_enter_cancellation().211 */212void debugfs_leave_cancellation(struct file *file,213 struct debugfs_cancellation *cancellation)214{215 struct debugfs_fsdata *fsd;216 struct dentry *dentry = F_DENTRY(file);217 218 if (WARN_ON(!d_is_reg(dentry)))219 return;220 221 fsd = READ_ONCE(dentry->d_fsdata);222 if (WARN_ON(!fsd ||223 ((unsigned long)fsd & DEBUGFS_FSDATA_IS_REAL_FOPS_BIT)))224 return;225 226 mutex_lock(&fsd->cancellations_mtx);227 if (!list_empty(&cancellation->list))228 list_del(&cancellation->list);229 mutex_unlock(&fsd->cancellations_mtx);230}231EXPORT_SYMBOL_GPL(debugfs_leave_cancellation);232 233/*234 * Only permit access to world-readable files when the kernel is locked down.235 * We also need to exclude any file that has ways to write or alter it as root236 * can bypass the permissions check.237 */238static int debugfs_locked_down(struct inode *inode,239 struct file *filp,240 const struct file_operations *real_fops)241{242 if ((inode->i_mode & 07777 & ~0444) == 0 &&243 !(filp->f_mode & FMODE_WRITE) &&244 !real_fops->unlocked_ioctl &&245 !real_fops->compat_ioctl &&246 !real_fops->mmap)247 return 0;248 249 if (security_locked_down(LOCKDOWN_DEBUGFS))250 return -EPERM;251 252 return 0;253}254 255static int open_proxy_open(struct inode *inode, struct file *filp)256{257 struct dentry *dentry = F_DENTRY(filp);258 const struct file_operations *real_fops = NULL;259 int r;260 261 r = debugfs_file_get(dentry);262 if (r)263 return r == -EIO ? -ENOENT : r;264 265 real_fops = debugfs_real_fops(filp);266 267 r = debugfs_locked_down(inode, filp, real_fops);268 if (r)269 goto out;270 271 if (!fops_get(real_fops)) {272#ifdef CONFIG_MODULES273 if (real_fops->owner &&274 real_fops->owner->state == MODULE_STATE_GOING) {275 r = -ENXIO;276 goto out;277 }278#endif279 280 /* Huh? Module did not clean up after itself at exit? */281 WARN(1, "debugfs file owner did not clean up at exit: %pd",282 dentry);283 r = -ENXIO;284 goto out;285 }286 replace_fops(filp, real_fops);287 288 if (real_fops->open)289 r = real_fops->open(inode, filp);290 291out:292 debugfs_file_put(dentry);293 return r;294}295 296const struct file_operations debugfs_open_proxy_file_operations = {297 .open = open_proxy_open,298};299 300#define PROTO(args...) args301#define ARGS(args...) args302 303#define FULL_PROXY_FUNC(name, ret_type, filp, proto, args) \304static ret_type full_proxy_ ## name(proto) \305{ \306 struct dentry *dentry = F_DENTRY(filp); \307 const struct file_operations *real_fops; \308 ret_type r; \309 \310 r = debugfs_file_get(dentry); \311 if (unlikely(r)) \312 return r; \313 real_fops = debugfs_real_fops(filp); \314 r = real_fops->name(args); \315 debugfs_file_put(dentry); \316 return r; \317}318 319FULL_PROXY_FUNC(llseek, loff_t, filp,320 PROTO(struct file *filp, loff_t offset, int whence),321 ARGS(filp, offset, whence));322 323FULL_PROXY_FUNC(read, ssize_t, filp,324 PROTO(struct file *filp, char __user *buf, size_t size,325 loff_t *ppos),326 ARGS(filp, buf, size, ppos));327 328FULL_PROXY_FUNC(write, ssize_t, filp,329 PROTO(struct file *filp, const char __user *buf, size_t size,330 loff_t *ppos),331 ARGS(filp, buf, size, ppos));332 333FULL_PROXY_FUNC(unlocked_ioctl, long, filp,334 PROTO(struct file *filp, unsigned int cmd, unsigned long arg),335 ARGS(filp, cmd, arg));336 337static __poll_t full_proxy_poll(struct file *filp,338 struct poll_table_struct *wait)339{340 struct dentry *dentry = F_DENTRY(filp);341 __poll_t r = 0;342 const struct file_operations *real_fops;343 344 if (debugfs_file_get(dentry))345 return EPOLLHUP;346 347 real_fops = debugfs_real_fops(filp);348 r = real_fops->poll(filp, wait);349 debugfs_file_put(dentry);350 return r;351}352 353static int full_proxy_release(struct inode *inode, struct file *filp)354{355 const struct dentry *dentry = F_DENTRY(filp);356 const struct file_operations *real_fops = debugfs_real_fops(filp);357 const struct file_operations *proxy_fops = filp->f_op;358 int r = 0;359 360 /*361 * We must not protect this against removal races here: the362 * original releaser should be called unconditionally in order363 * not to leak any resources. Releasers must not assume that364 * ->i_private is still being meaningful here.365 */366 if (real_fops->release)367 r = real_fops->release(inode, filp);368 369 replace_fops(filp, d_inode(dentry)->i_fop);370 kfree(proxy_fops);371 fops_put(real_fops);372 return r;373}374 375static void __full_proxy_fops_init(struct file_operations *proxy_fops,376 const struct file_operations *real_fops)377{378 proxy_fops->release = full_proxy_release;379 if (real_fops->llseek)380 proxy_fops->llseek = full_proxy_llseek;381 if (real_fops->read)382 proxy_fops->read = full_proxy_read;383 if (real_fops->write)384 proxy_fops->write = full_proxy_write;385 if (real_fops->poll)386 proxy_fops->poll = full_proxy_poll;387 if (real_fops->unlocked_ioctl)388 proxy_fops->unlocked_ioctl = full_proxy_unlocked_ioctl;389}390 391static int full_proxy_open(struct inode *inode, struct file *filp)392{393 struct dentry *dentry = F_DENTRY(filp);394 const struct file_operations *real_fops = NULL;395 struct file_operations *proxy_fops = NULL;396 int r;397 398 r = debugfs_file_get(dentry);399 if (r)400 return r == -EIO ? -ENOENT : r;401 402 real_fops = debugfs_real_fops(filp);403 404 r = debugfs_locked_down(inode, filp, real_fops);405 if (r)406 goto out;407 408 if (!fops_get(real_fops)) {409#ifdef CONFIG_MODULES410 if (real_fops->owner &&411 real_fops->owner->state == MODULE_STATE_GOING) {412 r = -ENXIO;413 goto out;414 }415#endif416 417 /* Huh? Module did not cleanup after itself at exit? */418 WARN(1, "debugfs file owner did not clean up at exit: %pd",419 dentry);420 r = -ENXIO;421 goto out;422 }423 424 proxy_fops = kzalloc(sizeof(*proxy_fops), GFP_KERNEL);425 if (!proxy_fops) {426 r = -ENOMEM;427 goto free_proxy;428 }429 __full_proxy_fops_init(proxy_fops, real_fops);430 replace_fops(filp, proxy_fops);431 432 if (real_fops->open) {433 r = real_fops->open(inode, filp);434 if (r) {435 replace_fops(filp, d_inode(dentry)->i_fop);436 goto free_proxy;437 } else if (filp->f_op != proxy_fops) {438 /* No protection against file removal anymore. */439 WARN(1, "debugfs file owner replaced proxy fops: %pd",440 dentry);441 goto free_proxy;442 }443 }444 445 goto out;446free_proxy:447 kfree(proxy_fops);448 fops_put(real_fops);449out:450 debugfs_file_put(dentry);451 return r;452}453 454const struct file_operations debugfs_full_proxy_file_operations = {455 .open = full_proxy_open,456};457 458ssize_t debugfs_attr_read(struct file *file, char __user *buf,459 size_t len, loff_t *ppos)460{461 struct dentry *dentry = F_DENTRY(file);462 ssize_t ret;463 464 ret = debugfs_file_get(dentry);465 if (unlikely(ret))466 return ret;467 ret = simple_attr_read(file, buf, len, ppos);468 debugfs_file_put(dentry);469 return ret;470}471EXPORT_SYMBOL_GPL(debugfs_attr_read);472 473static ssize_t debugfs_attr_write_xsigned(struct file *file, const char __user *buf,474 size_t len, loff_t *ppos, bool is_signed)475{476 struct dentry *dentry = F_DENTRY(file);477 ssize_t ret;478 479 ret = debugfs_file_get(dentry);480 if (unlikely(ret))481 return ret;482 if (is_signed)483 ret = simple_attr_write_signed(file, buf, len, ppos);484 else485 ret = simple_attr_write(file, buf, len, ppos);486 debugfs_file_put(dentry);487 return ret;488}489 490ssize_t debugfs_attr_write(struct file *file, const char __user *buf,491 size_t len, loff_t *ppos)492{493 return debugfs_attr_write_xsigned(file, buf, len, ppos, false);494}495EXPORT_SYMBOL_GPL(debugfs_attr_write);496 497ssize_t debugfs_attr_write_signed(struct file *file, const char __user *buf,498 size_t len, loff_t *ppos)499{500 return debugfs_attr_write_xsigned(file, buf, len, ppos, true);501}502EXPORT_SYMBOL_GPL(debugfs_attr_write_signed);503 504static struct dentry *debugfs_create_mode_unsafe(const char *name, umode_t mode,505 struct dentry *parent, void *value,506 const struct file_operations *fops,507 const struct file_operations *fops_ro,508 const struct file_operations *fops_wo)509{510 /* if there are no write bits set, make read only */511 if (!(mode & S_IWUGO))512 return debugfs_create_file_unsafe(name, mode, parent, value,513 fops_ro);514 /* if there are no read bits set, make write only */515 if (!(mode & S_IRUGO))516 return debugfs_create_file_unsafe(name, mode, parent, value,517 fops_wo);518 519 return debugfs_create_file_unsafe(name, mode, parent, value, fops);520}521 522static int debugfs_u8_set(void *data, u64 val)523{524 *(u8 *)data = val;525 return 0;526}527static int debugfs_u8_get(void *data, u64 *val)528{529 *val = *(u8 *)data;530 return 0;531}532DEFINE_DEBUGFS_ATTRIBUTE(fops_u8, debugfs_u8_get, debugfs_u8_set, "%llu\n");533DEFINE_DEBUGFS_ATTRIBUTE(fops_u8_ro, debugfs_u8_get, NULL, "%llu\n");534DEFINE_DEBUGFS_ATTRIBUTE(fops_u8_wo, NULL, debugfs_u8_set, "%llu\n");535 536/**537 * debugfs_create_u8 - create a debugfs file that is used to read and write an unsigned 8-bit value538 * @name: a pointer to a string containing the name of the file to create.539 * @mode: the permission that the file should have540 * @parent: a pointer to the parent dentry for this file. This should be a541 * directory dentry if set. If this parameter is %NULL, then the542 * file will be created in the root of the debugfs filesystem.543 * @value: a pointer to the variable that the file should read to and write544 * from.545 *546 * This function creates a file in debugfs with the given name that547 * contains the value of the variable @value. If the @mode variable is so548 * set, it can be read from, and written to.549 */550void debugfs_create_u8(const char *name, umode_t mode, struct dentry *parent,551 u8 *value)552{553 debugfs_create_mode_unsafe(name, mode, parent, value, &fops_u8,554 &fops_u8_ro, &fops_u8_wo);555}556EXPORT_SYMBOL_GPL(debugfs_create_u8);557 558static int debugfs_u16_set(void *data, u64 val)559{560 *(u16 *)data = val;561 return 0;562}563static int debugfs_u16_get(void *data, u64 *val)564{565 *val = *(u16 *)data;566 return 0;567}568DEFINE_DEBUGFS_ATTRIBUTE(fops_u16, debugfs_u16_get, debugfs_u16_set, "%llu\n");569DEFINE_DEBUGFS_ATTRIBUTE(fops_u16_ro, debugfs_u16_get, NULL, "%llu\n");570DEFINE_DEBUGFS_ATTRIBUTE(fops_u16_wo, NULL, debugfs_u16_set, "%llu\n");571 572/**573 * debugfs_create_u16 - create a debugfs file that is used to read and write an unsigned 16-bit value574 * @name: a pointer to a string containing the name of the file to create.575 * @mode: the permission that the file should have576 * @parent: a pointer to the parent dentry for this file. This should be a577 * directory dentry if set. If this parameter is %NULL, then the578 * file will be created in the root of the debugfs filesystem.579 * @value: a pointer to the variable that the file should read to and write580 * from.581 *582 * This function creates a file in debugfs with the given name that583 * contains the value of the variable @value. If the @mode variable is so584 * set, it can be read from, and written to.585 */586void debugfs_create_u16(const char *name, umode_t mode, struct dentry *parent,587 u16 *value)588{589 debugfs_create_mode_unsafe(name, mode, parent, value, &fops_u16,590 &fops_u16_ro, &fops_u16_wo);591}592EXPORT_SYMBOL_GPL(debugfs_create_u16);593 594static int debugfs_u32_set(void *data, u64 val)595{596 *(u32 *)data = val;597 return 0;598}599static int debugfs_u32_get(void *data, u64 *val)600{601 *val = *(u32 *)data;602 return 0;603}604DEFINE_DEBUGFS_ATTRIBUTE(fops_u32, debugfs_u32_get, debugfs_u32_set, "%llu\n");605DEFINE_DEBUGFS_ATTRIBUTE(fops_u32_ro, debugfs_u32_get, NULL, "%llu\n");606DEFINE_DEBUGFS_ATTRIBUTE(fops_u32_wo, NULL, debugfs_u32_set, "%llu\n");607 608/**609 * debugfs_create_u32 - create a debugfs file that is used to read and write an unsigned 32-bit value610 * @name: a pointer to a string containing the name of the file to create.611 * @mode: the permission that the file should have612 * @parent: a pointer to the parent dentry for this file. This should be a613 * directory dentry if set. If this parameter is %NULL, then the614 * file will be created in the root of the debugfs filesystem.615 * @value: a pointer to the variable that the file should read to and write616 * from.617 *618 * This function creates a file in debugfs with the given name that619 * contains the value of the variable @value. If the @mode variable is so620 * set, it can be read from, and written to.621 */622void debugfs_create_u32(const char *name, umode_t mode, struct dentry *parent,623 u32 *value)624{625 debugfs_create_mode_unsafe(name, mode, parent, value, &fops_u32,626 &fops_u32_ro, &fops_u32_wo);627}628EXPORT_SYMBOL_GPL(debugfs_create_u32);629 630static int debugfs_u64_set(void *data, u64 val)631{632 *(u64 *)data = val;633 return 0;634}635 636static int debugfs_u64_get(void *data, u64 *val)637{638 *val = *(u64 *)data;639 return 0;640}641DEFINE_DEBUGFS_ATTRIBUTE(fops_u64, debugfs_u64_get, debugfs_u64_set, "%llu\n");642DEFINE_DEBUGFS_ATTRIBUTE(fops_u64_ro, debugfs_u64_get, NULL, "%llu\n");643DEFINE_DEBUGFS_ATTRIBUTE(fops_u64_wo, NULL, debugfs_u64_set, "%llu\n");644 645/**646 * debugfs_create_u64 - create a debugfs file that is used to read and write an unsigned 64-bit value647 * @name: a pointer to a string containing the name of the file to create.648 * @mode: the permission that the file should have649 * @parent: a pointer to the parent dentry for this file. This should be a650 * directory dentry if set. If this parameter is %NULL, then the651 * file will be created in the root of the debugfs filesystem.652 * @value: a pointer to the variable that the file should read to and write653 * from.654 *655 * This function creates a file in debugfs with the given name that656 * contains the value of the variable @value. If the @mode variable is so657 * set, it can be read from, and written to.658 */659void debugfs_create_u64(const char *name, umode_t mode, struct dentry *parent,660 u64 *value)661{662 debugfs_create_mode_unsafe(name, mode, parent, value, &fops_u64,663 &fops_u64_ro, &fops_u64_wo);664}665EXPORT_SYMBOL_GPL(debugfs_create_u64);666 667static int debugfs_ulong_set(void *data, u64 val)668{669 *(unsigned long *)data = val;670 return 0;671}672 673static int debugfs_ulong_get(void *data, u64 *val)674{675 *val = *(unsigned long *)data;676 return 0;677}678DEFINE_DEBUGFS_ATTRIBUTE(fops_ulong, debugfs_ulong_get, debugfs_ulong_set,679 "%llu\n");680DEFINE_DEBUGFS_ATTRIBUTE(fops_ulong_ro, debugfs_ulong_get, NULL, "%llu\n");681DEFINE_DEBUGFS_ATTRIBUTE(fops_ulong_wo, NULL, debugfs_ulong_set, "%llu\n");682 683/**684 * debugfs_create_ulong - create a debugfs file that is used to read and write685 * an unsigned long value.686 * @name: a pointer to a string containing the name of the file to create.687 * @mode: the permission that the file should have688 * @parent: a pointer to the parent dentry for this file. This should be a689 * directory dentry if set. If this parameter is %NULL, then the690 * file will be created in the root of the debugfs filesystem.691 * @value: a pointer to the variable that the file should read to and write692 * from.693 *694 * This function creates a file in debugfs with the given name that695 * contains the value of the variable @value. If the @mode variable is so696 * set, it can be read from, and written to.697 */698void debugfs_create_ulong(const char *name, umode_t mode, struct dentry *parent,699 unsigned long *value)700{701 debugfs_create_mode_unsafe(name, mode, parent, value, &fops_ulong,702 &fops_ulong_ro, &fops_ulong_wo);703}704EXPORT_SYMBOL_GPL(debugfs_create_ulong);705 706DEFINE_DEBUGFS_ATTRIBUTE(fops_x8, debugfs_u8_get, debugfs_u8_set, "0x%02llx\n");707DEFINE_DEBUGFS_ATTRIBUTE(fops_x8_ro, debugfs_u8_get, NULL, "0x%02llx\n");708DEFINE_DEBUGFS_ATTRIBUTE(fops_x8_wo, NULL, debugfs_u8_set, "0x%02llx\n");709 710DEFINE_DEBUGFS_ATTRIBUTE(fops_x16, debugfs_u16_get, debugfs_u16_set,711 "0x%04llx\n");712DEFINE_DEBUGFS_ATTRIBUTE(fops_x16_ro, debugfs_u16_get, NULL, "0x%04llx\n");713DEFINE_DEBUGFS_ATTRIBUTE(fops_x16_wo, NULL, debugfs_u16_set, "0x%04llx\n");714 715DEFINE_DEBUGFS_ATTRIBUTE(fops_x32, debugfs_u32_get, debugfs_u32_set,716 "0x%08llx\n");717DEFINE_DEBUGFS_ATTRIBUTE(fops_x32_ro, debugfs_u32_get, NULL, "0x%08llx\n");718DEFINE_DEBUGFS_ATTRIBUTE(fops_x32_wo, NULL, debugfs_u32_set, "0x%08llx\n");719 720DEFINE_DEBUGFS_ATTRIBUTE(fops_x64, debugfs_u64_get, debugfs_u64_set,721 "0x%016llx\n");722DEFINE_DEBUGFS_ATTRIBUTE(fops_x64_ro, debugfs_u64_get, NULL, "0x%016llx\n");723DEFINE_DEBUGFS_ATTRIBUTE(fops_x64_wo, NULL, debugfs_u64_set, "0x%016llx\n");724 725/*726 * 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 value727 *728 * These functions are exactly the same as the above functions (but use a hex729 * output for the decimal challenged). For details look at the above unsigned730 * decimal functions.731 */732 733/**734 * debugfs_create_x8 - create a debugfs file that is used to read and write an unsigned 8-bit value735 * @name: a pointer to a string containing the name of the file to create.736 * @mode: the permission that the file should have737 * @parent: a pointer to the parent dentry for this file. This should be a738 * directory dentry if set. If this parameter is %NULL, then the739 * file will be created in the root of the debugfs filesystem.740 * @value: a pointer to the variable that the file should read to and write741 * from.742 */743void debugfs_create_x8(const char *name, umode_t mode, struct dentry *parent,744 u8 *value)745{746 debugfs_create_mode_unsafe(name, mode, parent, value, &fops_x8,747 &fops_x8_ro, &fops_x8_wo);748}749EXPORT_SYMBOL_GPL(debugfs_create_x8);750 751/**752 * debugfs_create_x16 - create a debugfs file that is used to read and write an unsigned 16-bit value753 * @name: a pointer to a string containing the name of the file to create.754 * @mode: the permission that the file should have755 * @parent: a pointer to the parent dentry for this file. This should be a756 * directory dentry if set. If this parameter is %NULL, then the757 * file will be created in the root of the debugfs filesystem.758 * @value: a pointer to the variable that the file should read to and write759 * from.760 */761void debugfs_create_x16(const char *name, umode_t mode, struct dentry *parent,762 u16 *value)763{764 debugfs_create_mode_unsafe(name, mode, parent, value, &fops_x16,765 &fops_x16_ro, &fops_x16_wo);766}767EXPORT_SYMBOL_GPL(debugfs_create_x16);768 769/**770 * debugfs_create_x32 - create a debugfs file that is used to read and write an unsigned 32-bit value771 * @name: a pointer to a string containing the name of the file to create.772 * @mode: the permission that the file should have773 * @parent: a pointer to the parent dentry for this file. This should be a774 * directory dentry if set. If this parameter is %NULL, then the775 * file will be created in the root of the debugfs filesystem.776 * @value: a pointer to the variable that the file should read to and write777 * from.778 */779void debugfs_create_x32(const char *name, umode_t mode, struct dentry *parent,780 u32 *value)781{782 debugfs_create_mode_unsafe(name, mode, parent, value, &fops_x32,783 &fops_x32_ro, &fops_x32_wo);784}785EXPORT_SYMBOL_GPL(debugfs_create_x32);786 787/**788 * debugfs_create_x64 - create a debugfs file that is used to read and write an unsigned 64-bit value789 * @name: a pointer to a string containing the name of the file to create.790 * @mode: the permission that the file should have791 * @parent: a pointer to the parent dentry for this file. This should be a792 * directory dentry if set. If this parameter is %NULL, then the793 * file will be created in the root of the debugfs filesystem.794 * @value: a pointer to the variable that the file should read to and write795 * from.796 */797void debugfs_create_x64(const char *name, umode_t mode, struct dentry *parent,798 u64 *value)799{800 debugfs_create_mode_unsafe(name, mode, parent, value, &fops_x64,801 &fops_x64_ro, &fops_x64_wo);802}803EXPORT_SYMBOL_GPL(debugfs_create_x64);804 805 806static int debugfs_size_t_set(void *data, u64 val)807{808 *(size_t *)data = val;809 return 0;810}811static int debugfs_size_t_get(void *data, u64 *val)812{813 *val = *(size_t *)data;814 return 0;815}816DEFINE_DEBUGFS_ATTRIBUTE(fops_size_t, debugfs_size_t_get, debugfs_size_t_set,817 "%llu\n"); /* %llu and %zu are more or less the same */818DEFINE_DEBUGFS_ATTRIBUTE(fops_size_t_ro, debugfs_size_t_get, NULL, "%llu\n");819DEFINE_DEBUGFS_ATTRIBUTE(fops_size_t_wo, NULL, debugfs_size_t_set, "%llu\n");820 821/**822 * debugfs_create_size_t - create a debugfs file that is used to read and write an size_t value823 * @name: a pointer to a string containing the name of the file to create.824 * @mode: the permission that the file should have825 * @parent: a pointer to the parent dentry for this file. This should be a826 * directory dentry if set. If this parameter is %NULL, then the827 * file will be created in the root of the debugfs filesystem.828 * @value: a pointer to the variable that the file should read to and write829 * from.830 */831void debugfs_create_size_t(const char *name, umode_t mode,832 struct dentry *parent, size_t *value)833{834 debugfs_create_mode_unsafe(name, mode, parent, value, &fops_size_t,835 &fops_size_t_ro, &fops_size_t_wo);836}837EXPORT_SYMBOL_GPL(debugfs_create_size_t);838 839static int debugfs_atomic_t_set(void *data, u64 val)840{841 atomic_set((atomic_t *)data, val);842 return 0;843}844static int debugfs_atomic_t_get(void *data, u64 *val)845{846 *val = atomic_read((atomic_t *)data);847 return 0;848}849DEFINE_DEBUGFS_ATTRIBUTE_SIGNED(fops_atomic_t, debugfs_atomic_t_get,850 debugfs_atomic_t_set, "%lld\n");851DEFINE_DEBUGFS_ATTRIBUTE_SIGNED(fops_atomic_t_ro, debugfs_atomic_t_get, NULL,852 "%lld\n");853DEFINE_DEBUGFS_ATTRIBUTE_SIGNED(fops_atomic_t_wo, NULL, debugfs_atomic_t_set,854 "%lld\n");855 856/**857 * debugfs_create_atomic_t - create a debugfs file that is used to read and858 * write an atomic_t value859 * @name: a pointer to a string containing the name of the file to create.860 * @mode: the permission that the file should have861 * @parent: a pointer to the parent dentry for this file. This should be a862 * directory dentry if set. If this parameter is %NULL, then the863 * file will be created in the root of the debugfs filesystem.864 * @value: a pointer to the variable that the file should read to and write865 * from.866 */867void debugfs_create_atomic_t(const char *name, umode_t mode,868 struct dentry *parent, atomic_t *value)869{870 debugfs_create_mode_unsafe(name, mode, parent, value, &fops_atomic_t,871 &fops_atomic_t_ro, &fops_atomic_t_wo);872}873EXPORT_SYMBOL_GPL(debugfs_create_atomic_t);874 875ssize_t debugfs_read_file_bool(struct file *file, char __user *user_buf,876 size_t count, loff_t *ppos)877{878 char buf[2];879 bool val;880 int r;881 struct dentry *dentry = F_DENTRY(file);882 883 r = debugfs_file_get(dentry);884 if (unlikely(r))885 return r;886 val = *(bool *)file->private_data;887 debugfs_file_put(dentry);888 889 if (val)890 buf[0] = 'Y';891 else892 buf[0] = 'N';893 buf[1] = '\n';894 return simple_read_from_buffer(user_buf, count, ppos, buf, 2);895}896EXPORT_SYMBOL_GPL(debugfs_read_file_bool);897 898ssize_t debugfs_write_file_bool(struct file *file, const char __user *user_buf,899 size_t count, loff_t *ppos)900{901 bool bv;902 int r;903 bool *val = file->private_data;904 struct dentry *dentry = F_DENTRY(file);905 906 r = kstrtobool_from_user(user_buf, count, &bv);907 if (!r) {908 r = debugfs_file_get(dentry);909 if (unlikely(r))910 return r;911 *val = bv;912 debugfs_file_put(dentry);913 }914 915 return count;916}917EXPORT_SYMBOL_GPL(debugfs_write_file_bool);918 919static const struct file_operations fops_bool = {920 .read = debugfs_read_file_bool,921 .write = debugfs_write_file_bool,922 .open = simple_open,923 .llseek = default_llseek,924};925 926static const struct file_operations fops_bool_ro = {927 .read = debugfs_read_file_bool,928 .open = simple_open,929 .llseek = default_llseek,930};931 932static const struct file_operations fops_bool_wo = {933 .write = debugfs_write_file_bool,934 .open = simple_open,935 .llseek = default_llseek,936};937 938/**939 * debugfs_create_bool - create a debugfs file that is used to read and write a boolean value940 * @name: a pointer to a string containing the name of the file to create.941 * @mode: the permission that the file should have942 * @parent: a pointer to the parent dentry for this file. This should be a943 * directory dentry if set. If this parameter is %NULL, then the944 * file will be created in the root of the debugfs filesystem.945 * @value: a pointer to the variable that the file should read to and write946 * from.947 *948 * This function creates a file in debugfs with the given name that949 * contains the value of the variable @value. If the @mode variable is so950 * set, it can be read from, and written to.951 */952void debugfs_create_bool(const char *name, umode_t mode, struct dentry *parent,953 bool *value)954{955 debugfs_create_mode_unsafe(name, mode, parent, value, &fops_bool,956 &fops_bool_ro, &fops_bool_wo);957}958EXPORT_SYMBOL_GPL(debugfs_create_bool);959 960ssize_t debugfs_read_file_str(struct file *file, char __user *user_buf,961 size_t count, loff_t *ppos)962{963 struct dentry *dentry = F_DENTRY(file);964 char *str, *copy = NULL;965 int copy_len, len;966 ssize_t ret;967 968 ret = debugfs_file_get(dentry);969 if (unlikely(ret))970 return ret;971 972 str = *(char **)file->private_data;973 len = strlen(str) + 1;974 copy = kmalloc(len, GFP_KERNEL);975 if (!copy) {976 debugfs_file_put(dentry);977 return -ENOMEM;978 }979 980 copy_len = strscpy(copy, str, len);981 debugfs_file_put(dentry);982 if (copy_len < 0) {983 kfree(copy);984 return copy_len;985 }986 987 copy[copy_len] = '\n';988 989 ret = simple_read_from_buffer(user_buf, count, ppos, copy, len);990 kfree(copy);991 992 return ret;993}994EXPORT_SYMBOL_GPL(debugfs_create_str);995 996static ssize_t debugfs_write_file_str(struct file *file, const char __user *user_buf,997 size_t count, loff_t *ppos)998{999 struct dentry *dentry = F_DENTRY(file);1000 char *old, *new = NULL;1001 int pos = *ppos;1002 int r;1003 1004 r = debugfs_file_get(dentry);1005 if (unlikely(r))1006 return r;1007 1008 old = *(char **)file->private_data;1009 1010 /* only allow strict concatenation */1011 r = -EINVAL;1012 if (pos && pos != strlen(old))1013 goto error;1014 1015 r = -E2BIG;1016 if (pos + count + 1 > PAGE_SIZE)1017 goto error;1018 1019 r = -ENOMEM;1020 new = kmalloc(pos + count + 1, GFP_KERNEL);1021 if (!new)1022 goto error;1023 1024 if (pos)1025 memcpy(new, old, pos);1026 1027 r = -EFAULT;1028 if (copy_from_user(new + pos, user_buf, count))1029 goto error;1030 1031 new[pos + count] = '\0';1032 strim(new);1033 1034 rcu_assign_pointer(*(char __rcu **)file->private_data, new);1035 synchronize_rcu();1036 kfree(old);1037 1038 debugfs_file_put(dentry);1039 return count;1040 1041error:1042 kfree(new);1043 debugfs_file_put(dentry);1044 return r;1045}1046 1047static const struct file_operations fops_str = {1048 .read = debugfs_read_file_str,1049 .write = debugfs_write_file_str,1050 .open = simple_open,1051 .llseek = default_llseek,1052};1053 1054static const struct file_operations fops_str_ro = {1055 .read = debugfs_read_file_str,1056 .open = simple_open,1057 .llseek = default_llseek,1058};1059 1060static const struct file_operations fops_str_wo = {1061 .write = debugfs_write_file_str,1062 .open = simple_open,1063 .llseek = default_llseek,1064};1065 1066/**1067 * debugfs_create_str - create a debugfs file that is used to read and write a string value1068 * @name: a pointer to a string containing the name of the file to create.1069 * @mode: the permission that the file should have1070 * @parent: a pointer to the parent dentry for this file. This should be a1071 * directory dentry if set. If this parameter is %NULL, then the1072 * file will be created in the root of the debugfs filesystem.1073 * @value: a pointer to the variable that the file should read to and write1074 * from.1075 *1076 * This function creates a file in debugfs with the given name that1077 * contains the value of the variable @value. If the @mode variable is so1078 * set, it can be read from, and written to.1079 */1080void debugfs_create_str(const char *name, umode_t mode,1081 struct dentry *parent, char **value)1082{1083 debugfs_create_mode_unsafe(name, mode, parent, value, &fops_str,1084 &fops_str_ro, &fops_str_wo);1085}1086 1087static ssize_t read_file_blob(struct file *file, char __user *user_buf,1088 size_t count, loff_t *ppos)1089{1090 struct debugfs_blob_wrapper *blob = file->private_data;1091 struct dentry *dentry = F_DENTRY(file);1092 ssize_t r;1093 1094 r = debugfs_file_get(dentry);1095 if (unlikely(r))1096 return r;1097 r = simple_read_from_buffer(user_buf, count, ppos, blob->data,1098 blob->size);1099 debugfs_file_put(dentry);1100 return r;1101}1102 1103static ssize_t write_file_blob(struct file *file, const char __user *user_buf,1104 size_t count, loff_t *ppos)1105{1106 struct debugfs_blob_wrapper *blob = file->private_data;1107 struct dentry *dentry = F_DENTRY(file);1108 ssize_t r;1109 1110 r = debugfs_file_get(dentry);1111 if (unlikely(r))1112 return r;1113 r = simple_write_to_buffer(blob->data, blob->size, ppos, user_buf,1114 count);1115 1116 debugfs_file_put(dentry);1117 return r;1118}1119 1120static const struct file_operations fops_blob = {1121 .read = read_file_blob,1122 .write = write_file_blob,1123 .open = simple_open,1124 .llseek = default_llseek,1125};1126 1127/**1128 * debugfs_create_blob - create a debugfs file that is used to read and write1129 * a binary blob1130 * @name: a pointer to a string containing the name of the file to create.1131 * @mode: the permission that the file should have1132 * @parent: a pointer to the parent dentry for this file. This should be a1133 * directory dentry if set. If this parameter is %NULL, then the1134 * file will be created in the root of the debugfs filesystem.1135 * @blob: a pointer to a struct debugfs_blob_wrapper which contains a pointer1136 * to the blob data and the size of the data.1137 *1138 * This function creates a file in debugfs with the given name that exports1139 * @blob->data as a binary blob. If the @mode variable is so set it can be1140 * read from and written to.1141 *1142 * This function will return a pointer to a dentry if it succeeds. This1143 * pointer must be passed to the debugfs_remove() function when the file is1144 * to be removed (no automatic cleanup happens if your module is unloaded,1145 * you are responsible here.) If an error occurs, ERR_PTR(-ERROR) will be1146 * returned.1147 *1148 * If debugfs is not enabled in the kernel, the value ERR_PTR(-ENODEV) will1149 * be returned.1150 */1151struct dentry *debugfs_create_blob(const char *name, umode_t mode,1152 struct dentry *parent,1153 struct debugfs_blob_wrapper *blob)1154{1155 return debugfs_create_file_unsafe(name, mode & 0644, parent, blob, &fops_blob);1156}1157EXPORT_SYMBOL_GPL(debugfs_create_blob);1158 1159static size_t u32_format_array(char *buf, size_t bufsize,1160 u32 *array, int array_size)1161{1162 size_t ret = 0;1163 1164 while (--array_size >= 0) {1165 size_t len;1166 char term = array_size ? ' ' : '\n';1167 1168 len = snprintf(buf, bufsize, "%u%c", *array++, term);1169 ret += len;1170 1171 buf += len;1172 bufsize -= len;1173 }1174 return ret;1175}1176 1177static int u32_array_open(struct inode *inode, struct file *file)1178{1179 struct debugfs_u32_array *data = inode->i_private;1180 int size, elements = data->n_elements;1181 char *buf;1182 1183 /*1184 * Max size:1185 * - 10 digits + ' '/'\n' = 11 bytes per number1186 * - terminating NUL character1187 */1188 size = elements*11;1189 buf = kmalloc(size+1, GFP_KERNEL);1190 if (!buf)1191 return -ENOMEM;1192 buf[size] = 0;1193 1194 file->private_data = buf;1195 u32_format_array(buf, size, data->array, data->n_elements);1196 1197 return nonseekable_open(inode, file);1198}1199 1200static ssize_t u32_array_read(struct file *file, char __user *buf, size_t len,1201 loff_t *ppos)1202{1203 size_t size = strlen(file->private_data);1204 1205 return simple_read_from_buffer(buf, len, ppos,1206 file->private_data, size);1207}1208 1209static int u32_array_release(struct inode *inode, struct file *file)1210{1211 kfree(file->private_data);1212 1213 return 0;1214}1215 1216static const struct file_operations u32_array_fops = {1217 .owner = THIS_MODULE,1218 .open = u32_array_open,1219 .release = u32_array_release,1220 .read = u32_array_read,1221};1222 1223/**1224 * debugfs_create_u32_array - create a debugfs file that is used to read u321225 * array.1226 * @name: a pointer to a string containing the name of the file to create.1227 * @mode: the permission that the file should have.1228 * @parent: a pointer to the parent dentry for this file. This should be a1229 * directory dentry if set. If this parameter is %NULL, then the1230 * file will be created in the root of the debugfs filesystem.1231 * @array: wrapper struct containing data pointer and size of the array.1232 *1233 * This function creates a file in debugfs with the given name that exports1234 * @array as data. If the @mode variable is so set it can be read from.1235 * Writing is not supported. Seek within the file is also not supported.1236 * Once array is created its size can not be changed.1237 */1238void debugfs_create_u32_array(const char *name, umode_t mode,1239 struct dentry *parent,1240 struct debugfs_u32_array *array)1241{1242 debugfs_create_file_unsafe(name, mode, parent, array, &u32_array_fops);1243}1244EXPORT_SYMBOL_GPL(debugfs_create_u32_array);1245 1246#ifdef CONFIG_HAS_IOMEM1247 1248/*1249 * The regset32 stuff is used to print 32-bit registers using the1250 * seq_file utilities. We offer printing a register set in an already-opened1251 * sequential file or create a debugfs file that only prints a regset32.1252 */1253 1254/**1255 * debugfs_print_regs32 - use seq_print to describe a set of registers1256 * @s: the seq_file structure being used to generate output1257 * @regs: an array if struct debugfs_reg32 structures1258 * @nregs: the length of the above array1259 * @base: the base address to be used in reading the registers1260 * @prefix: a string to be prefixed to every output line1261 *1262 * This function outputs a text block describing the current values of1263 * some 32-bit hardware registers. It is meant to be used within debugfs1264 * files based on seq_file that need to show registers, intermixed with other1265 * information. The prefix argument may be used to specify a leading string,1266 * because some peripherals have several blocks of identical registers,1267 * for example configuration of dma channels1268 */1269void debugfs_print_regs32(struct seq_file *s, const struct debugfs_reg32 *regs,1270 int nregs, void __iomem *base, char *prefix)1271{1272 int i;1273 1274 for (i = 0; i < nregs; i++, regs++) {1275 if (prefix)1276 seq_printf(s, "%s", prefix);1277 seq_printf(s, "%s = 0x%08x\n", regs->name,1278 readl(base + regs->offset));1279 if (seq_has_overflowed(s))1280 break;1281 }1282}1283EXPORT_SYMBOL_GPL(debugfs_print_regs32);1284 1285static int debugfs_regset32_show(struct seq_file *s, void *data)1286{1287 struct debugfs_regset32 *regset = s->private;1288 1289 if (regset->dev)1290 pm_runtime_get_sync(regset->dev);1291 1292 debugfs_print_regs32(s, regset->regs, regset->nregs, regset->base, "");1293 1294 if (regset->dev)1295 pm_runtime_put(regset->dev);1296 1297 return 0;1298}1299 1300DEFINE_SHOW_ATTRIBUTE(debugfs_regset32);1301 1302/**1303 * debugfs_create_regset32 - create a debugfs file that returns register values1304 * @name: a pointer to a string containing the name of the file to create.1305 * @mode: the permission that the file should have1306 * @parent: a pointer to the parent dentry for this file. This should be a1307 * directory dentry if set. If this parameter is %NULL, then the1308 * file will be created in the root of the debugfs filesystem.1309 * @regset: a pointer to a struct debugfs_regset32, which contains a pointer1310 * to an array of register definitions, the array size and the base1311 * address where the register bank is to be found.1312 *1313 * This function creates a file in debugfs with the given name that reports1314 * the names and values of a set of 32-bit registers. If the @mode variable1315 * is so set it can be read from. Writing is not supported.1316 */1317void debugfs_create_regset32(const char *name, umode_t mode,1318 struct dentry *parent,1319 struct debugfs_regset32 *regset)1320{1321 debugfs_create_file(name, mode, parent, regset, &debugfs_regset32_fops);1322}1323EXPORT_SYMBOL_GPL(debugfs_create_regset32);1324 1325#endif /* CONFIG_HAS_IOMEM */1326 1327struct debugfs_devm_entry {1328 int (*read)(struct seq_file *seq, void *data);1329 struct device *dev;1330};1331 1332static int debugfs_devm_entry_open(struct inode *inode, struct file *f)1333{1334 struct debugfs_devm_entry *entry = inode->i_private;1335 1336 return single_open(f, entry->read, entry->dev);1337}1338 1339static const struct file_operations debugfs_devm_entry_ops = {1340 .owner = THIS_MODULE,1341 .open = debugfs_devm_entry_open,1342 .release = single_release,1343 .read = seq_read,1344 .llseek = seq_lseek1345};1346 1347/**1348 * debugfs_create_devm_seqfile - create a debugfs file that is bound to device.1349 *1350 * @dev: device related to this debugfs file.1351 * @name: name of the debugfs file.1352 * @parent: a pointer to the parent dentry for this file. This should be a1353 * directory dentry if set. If this parameter is %NULL, then the1354 * file will be created in the root of the debugfs filesystem.1355 * @read_fn: function pointer called to print the seq_file content.1356 */1357void debugfs_create_devm_seqfile(struct device *dev, const char *name,1358 struct dentry *parent,1359 int (*read_fn)(struct seq_file *s, void *data))1360{1361 struct debugfs_devm_entry *entry;1362 1363 if (IS_ERR(parent))1364 return;1365 1366 entry = devm_kzalloc(dev, sizeof(*entry), GFP_KERNEL);1367 if (!entry)1368 return;1369 1370 entry->read = read_fn;1371 entry->dev = dev;1372 1373 debugfs_create_file(name, S_IRUGO, parent, entry,1374 &debugfs_devm_entry_ops);1375}1376EXPORT_SYMBOL_GPL(debugfs_create_devm_seqfile);1377