965 lines · c
1// SPDX-License-Identifier: GPL-2.02/*3 * inode.c - part of debugfs, a tiny little debug file system4 *5 * Copyright (C) 2004,2019 Greg Kroah-Hartman <greg@kroah.com>6 * Copyright (C) 2004 IBM Inc.7 * Copyright (C) 2019 Linux Foundation <gregkh@linuxfoundation.org>8 *9 * debugfs is for people to use instead of /proc or /sys.10 * See ./Documentation/core-api/kernel-api.rst for more details.11 */12 13#define pr_fmt(fmt) "debugfs: " fmt14 15#include <linux/module.h>16#include <linux/fs.h>17#include <linux/fs_context.h>18#include <linux/fs_parser.h>19#include <linux/pagemap.h>20#include <linux/init.h>21#include <linux/kobject.h>22#include <linux/namei.h>23#include <linux/debugfs.h>24#include <linux/fsnotify.h>25#include <linux/string.h>26#include <linux/seq_file.h>27#include <linux/magic.h>28#include <linux/slab.h>29#include <linux/security.h>30 31#include "internal.h"32 33#define DEBUGFS_DEFAULT_MODE 070034 35static struct vfsmount *debugfs_mount;36static int debugfs_mount_count;37static bool debugfs_registered;38static unsigned int debugfs_allow __ro_after_init = DEFAULT_DEBUGFS_ALLOW_BITS;39 40/*41 * Don't allow access attributes to be changed whilst the kernel is locked down42 * so that we can use the file mode as part of a heuristic to determine whether43 * to lock down individual files.44 */45static int debugfs_setattr(struct mnt_idmap *idmap,46 struct dentry *dentry, struct iattr *ia)47{48 int ret;49 50 if (ia->ia_valid & (ATTR_MODE | ATTR_UID | ATTR_GID)) {51 ret = security_locked_down(LOCKDOWN_DEBUGFS);52 if (ret)53 return ret;54 }55 return simple_setattr(&nop_mnt_idmap, dentry, ia);56}57 58static const struct inode_operations debugfs_file_inode_operations = {59 .setattr = debugfs_setattr,60};61static const struct inode_operations debugfs_dir_inode_operations = {62 .lookup = simple_lookup,63 .setattr = debugfs_setattr,64};65static const struct inode_operations debugfs_symlink_inode_operations = {66 .get_link = simple_get_link,67 .setattr = debugfs_setattr,68};69 70static struct inode *debugfs_get_inode(struct super_block *sb)71{72 struct inode *inode = new_inode(sb);73 if (inode) {74 inode->i_ino = get_next_ino();75 simple_inode_init_ts(inode);76 }77 return inode;78}79 80struct debugfs_fs_info {81 kuid_t uid;82 kgid_t gid;83 umode_t mode;84 /* Opt_* bitfield. */85 unsigned int opts;86};87 88enum {89 Opt_uid,90 Opt_gid,91 Opt_mode,92 Opt_source,93};94 95static const struct fs_parameter_spec debugfs_param_specs[] = {96 fsparam_gid ("gid", Opt_gid),97 fsparam_u32oct ("mode", Opt_mode),98 fsparam_uid ("uid", Opt_uid),99 fsparam_string ("source", Opt_source),100 {}101};102 103static int debugfs_parse_param(struct fs_context *fc, struct fs_parameter *param)104{105 struct debugfs_fs_info *opts = fc->s_fs_info;106 struct fs_parse_result result;107 int opt;108 109 opt = fs_parse(fc, debugfs_param_specs, param, &result);110 if (opt < 0) {111 /*112 * We might like to report bad mount options here; but113 * traditionally debugfs has ignored all mount options114 */115 if (opt == -ENOPARAM)116 return 0;117 118 return opt;119 }120 121 switch (opt) {122 case Opt_uid:123 opts->uid = result.uid;124 break;125 case Opt_gid:126 opts->gid = result.gid;127 break;128 case Opt_mode:129 opts->mode = result.uint_32 & S_IALLUGO;130 break;131 case Opt_source:132 if (fc->source)133 return invalfc(fc, "Multiple sources specified");134 fc->source = param->string;135 param->string = NULL;136 break;137 /*138 * We might like to report bad mount options here;139 * but traditionally debugfs has ignored all mount options140 */141 }142 143 opts->opts |= BIT(opt);144 145 return 0;146}147 148static void _debugfs_apply_options(struct super_block *sb, bool remount)149{150 struct debugfs_fs_info *fsi = sb->s_fs_info;151 struct inode *inode = d_inode(sb->s_root);152 153 /*154 * On remount, only reset mode/uid/gid if they were provided as mount155 * options.156 */157 158 if (!remount || fsi->opts & BIT(Opt_mode)) {159 inode->i_mode &= ~S_IALLUGO;160 inode->i_mode |= fsi->mode;161 }162 163 if (!remount || fsi->opts & BIT(Opt_uid))164 inode->i_uid = fsi->uid;165 166 if (!remount || fsi->opts & BIT(Opt_gid))167 inode->i_gid = fsi->gid;168}169 170static void debugfs_apply_options(struct super_block *sb)171{172 _debugfs_apply_options(sb, false);173}174 175static void debugfs_apply_options_remount(struct super_block *sb)176{177 _debugfs_apply_options(sb, true);178}179 180static int debugfs_reconfigure(struct fs_context *fc)181{182 struct super_block *sb = fc->root->d_sb;183 struct debugfs_fs_info *sb_opts = sb->s_fs_info;184 struct debugfs_fs_info *new_opts = fc->s_fs_info;185 186 sync_filesystem(sb);187 188 /* structure copy of new mount options to sb */189 *sb_opts = *new_opts;190 debugfs_apply_options_remount(sb);191 192 return 0;193}194 195static int debugfs_show_options(struct seq_file *m, struct dentry *root)196{197 struct debugfs_fs_info *fsi = root->d_sb->s_fs_info;198 199 if (!uid_eq(fsi->uid, GLOBAL_ROOT_UID))200 seq_printf(m, ",uid=%u",201 from_kuid_munged(&init_user_ns, fsi->uid));202 if (!gid_eq(fsi->gid, GLOBAL_ROOT_GID))203 seq_printf(m, ",gid=%u",204 from_kgid_munged(&init_user_ns, fsi->gid));205 if (fsi->mode != DEBUGFS_DEFAULT_MODE)206 seq_printf(m, ",mode=%o", fsi->mode);207 208 return 0;209}210 211static void debugfs_free_inode(struct inode *inode)212{213 if (S_ISLNK(inode->i_mode))214 kfree(inode->i_link);215 free_inode_nonrcu(inode);216}217 218static const struct super_operations debugfs_super_operations = {219 .statfs = simple_statfs,220 .show_options = debugfs_show_options,221 .free_inode = debugfs_free_inode,222};223 224static void debugfs_release_dentry(struct dentry *dentry)225{226 struct debugfs_fsdata *fsd = dentry->d_fsdata;227 228 if ((unsigned long)fsd & DEBUGFS_FSDATA_IS_REAL_FOPS_BIT)229 return;230 231 /* check it wasn't a dir (no fsdata) or automount (no real_fops) */232 if (fsd && fsd->real_fops) {233 WARN_ON(!list_empty(&fsd->cancellations));234 mutex_destroy(&fsd->cancellations_mtx);235 }236 237 kfree(fsd);238}239 240static struct vfsmount *debugfs_automount(struct path *path)241{242 struct debugfs_fsdata *fsd = path->dentry->d_fsdata;243 244 return fsd->automount(path->dentry, d_inode(path->dentry)->i_private);245}246 247static const struct dentry_operations debugfs_dops = {248 .d_delete = always_delete_dentry,249 .d_release = debugfs_release_dentry,250 .d_automount = debugfs_automount,251};252 253static int debugfs_fill_super(struct super_block *sb, struct fs_context *fc)254{255 static const struct tree_descr debug_files[] = {{""}};256 int err;257 258 err = simple_fill_super(sb, DEBUGFS_MAGIC, debug_files);259 if (err)260 return err;261 262 sb->s_op = &debugfs_super_operations;263 sb->s_d_op = &debugfs_dops;264 265 debugfs_apply_options(sb);266 267 return 0;268}269 270static int debugfs_get_tree(struct fs_context *fc)271{272 if (!(debugfs_allow & DEBUGFS_ALLOW_API))273 return -EPERM;274 275 return get_tree_single(fc, debugfs_fill_super);276}277 278static void debugfs_free_fc(struct fs_context *fc)279{280 kfree(fc->s_fs_info);281}282 283static const struct fs_context_operations debugfs_context_ops = {284 .free = debugfs_free_fc,285 .parse_param = debugfs_parse_param,286 .get_tree = debugfs_get_tree,287 .reconfigure = debugfs_reconfigure,288};289 290static int debugfs_init_fs_context(struct fs_context *fc)291{292 struct debugfs_fs_info *fsi;293 294 fsi = kzalloc(sizeof(struct debugfs_fs_info), GFP_KERNEL);295 if (!fsi)296 return -ENOMEM;297 298 fsi->mode = DEBUGFS_DEFAULT_MODE;299 300 fc->s_fs_info = fsi;301 fc->ops = &debugfs_context_ops;302 return 0;303}304 305static struct file_system_type debug_fs_type = {306 .owner = THIS_MODULE,307 .name = "debugfs",308 .init_fs_context = debugfs_init_fs_context,309 .parameters = debugfs_param_specs,310 .kill_sb = kill_litter_super,311};312MODULE_ALIAS_FS("debugfs");313 314/**315 * debugfs_lookup() - look up an existing debugfs file316 * @name: a pointer to a string containing the name of the file to look up.317 * @parent: a pointer to the parent dentry of the file.318 *319 * This function will return a pointer to a dentry if it succeeds. If the file320 * doesn't exist or an error occurs, %NULL will be returned. The returned321 * dentry must be passed to dput() when it is no longer needed.322 *323 * If debugfs is not enabled in the kernel, the value -%ENODEV will be324 * returned.325 */326struct dentry *debugfs_lookup(const char *name, struct dentry *parent)327{328 struct dentry *dentry;329 330 if (!debugfs_initialized() || IS_ERR_OR_NULL(name) || IS_ERR(parent))331 return NULL;332 333 if (!parent)334 parent = debugfs_mount->mnt_root;335 336 dentry = lookup_positive_unlocked(name, parent, strlen(name));337 if (IS_ERR(dentry))338 return NULL;339 return dentry;340}341EXPORT_SYMBOL_GPL(debugfs_lookup);342 343static struct dentry *start_creating(const char *name, struct dentry *parent)344{345 struct dentry *dentry;346 int error;347 348 if (!(debugfs_allow & DEBUGFS_ALLOW_API))349 return ERR_PTR(-EPERM);350 351 if (!debugfs_initialized())352 return ERR_PTR(-ENOENT);353 354 pr_debug("creating file '%s'\n", name);355 356 if (IS_ERR(parent))357 return parent;358 359 error = simple_pin_fs(&debug_fs_type, &debugfs_mount,360 &debugfs_mount_count);361 if (error) {362 pr_err("Unable to pin filesystem for file '%s'\n", name);363 return ERR_PTR(error);364 }365 366 /* If the parent is not specified, we create it in the root.367 * We need the root dentry to do this, which is in the super368 * block. A pointer to that is in the struct vfsmount that we369 * have around.370 */371 if (!parent)372 parent = debugfs_mount->mnt_root;373 374 inode_lock(d_inode(parent));375 if (unlikely(IS_DEADDIR(d_inode(parent))))376 dentry = ERR_PTR(-ENOENT);377 else378 dentry = lookup_one_len(name, parent, strlen(name));379 if (!IS_ERR(dentry) && d_really_is_positive(dentry)) {380 if (d_is_dir(dentry))381 pr_err("Directory '%s' with parent '%s' already present!\n",382 name, parent->d_name.name);383 else384 pr_err("File '%s' in directory '%s' already present!\n",385 name, parent->d_name.name);386 dput(dentry);387 dentry = ERR_PTR(-EEXIST);388 }389 390 if (IS_ERR(dentry)) {391 inode_unlock(d_inode(parent));392 simple_release_fs(&debugfs_mount, &debugfs_mount_count);393 }394 395 return dentry;396}397 398static struct dentry *failed_creating(struct dentry *dentry)399{400 inode_unlock(d_inode(dentry->d_parent));401 dput(dentry);402 simple_release_fs(&debugfs_mount, &debugfs_mount_count);403 return ERR_PTR(-ENOMEM);404}405 406static struct dentry *end_creating(struct dentry *dentry)407{408 inode_unlock(d_inode(dentry->d_parent));409 return dentry;410}411 412static struct dentry *__debugfs_create_file(const char *name, umode_t mode,413 struct dentry *parent, void *data,414 const struct file_operations *proxy_fops,415 const struct file_operations *real_fops)416{417 struct dentry *dentry;418 struct inode *inode;419 420 if (!(mode & S_IFMT))421 mode |= S_IFREG;422 BUG_ON(!S_ISREG(mode));423 dentry = start_creating(name, parent);424 425 if (IS_ERR(dentry))426 return dentry;427 428 if (!(debugfs_allow & DEBUGFS_ALLOW_API)) {429 failed_creating(dentry);430 return ERR_PTR(-EPERM);431 }432 433 inode = debugfs_get_inode(dentry->d_sb);434 if (unlikely(!inode)) {435 pr_err("out of free dentries, can not create file '%s'\n",436 name);437 return failed_creating(dentry);438 }439 440 inode->i_mode = mode;441 inode->i_private = data;442 443 inode->i_op = &debugfs_file_inode_operations;444 inode->i_fop = proxy_fops;445 dentry->d_fsdata = (void *)((unsigned long)real_fops |446 DEBUGFS_FSDATA_IS_REAL_FOPS_BIT);447 448 d_instantiate(dentry, inode);449 fsnotify_create(d_inode(dentry->d_parent), dentry);450 return end_creating(dentry);451}452 453/**454 * debugfs_create_file - create a file in the debugfs filesystem455 * @name: a pointer to a string containing the name of the file to create.456 * @mode: the permission that the file should have.457 * @parent: a pointer to the parent dentry for this file. This should be a458 * directory dentry if set. If this parameter is NULL, then the459 * file will be created in the root of the debugfs filesystem.460 * @data: a pointer to something that the caller will want to get to later461 * on. The inode.i_private pointer will point to this value on462 * the open() call.463 * @fops: a pointer to a struct file_operations that should be used for464 * this file.465 *466 * This is the basic "create a file" function for debugfs. It allows for a467 * wide range of flexibility in creating a file, or a directory (if you want468 * to create a directory, the debugfs_create_dir() function is469 * recommended to be used instead.)470 *471 * This function will return a pointer to a dentry if it succeeds. This472 * pointer must be passed to the debugfs_remove() function when the file is473 * to be removed (no automatic cleanup happens if your module is unloaded,474 * you are responsible here.) If an error occurs, ERR_PTR(-ERROR) will be475 * returned.476 *477 * If debugfs is not enabled in the kernel, the value -%ENODEV will be478 * returned.479 *480 * NOTE: it's expected that most callers should _ignore_ the errors returned481 * by this function. Other debugfs functions handle the fact that the "dentry"482 * passed to them could be an error and they don't crash in that case.483 * Drivers should generally work fine even if debugfs fails to init anyway.484 */485struct dentry *debugfs_create_file(const char *name, umode_t mode,486 struct dentry *parent, void *data,487 const struct file_operations *fops)488{489 490 return __debugfs_create_file(name, mode, parent, data,491 fops ? &debugfs_full_proxy_file_operations :492 &debugfs_noop_file_operations,493 fops);494}495EXPORT_SYMBOL_GPL(debugfs_create_file);496 497/**498 * debugfs_create_file_unsafe - create a file in the debugfs filesystem499 * @name: a pointer to a string containing the name of the file to create.500 * @mode: the permission that the file should have.501 * @parent: a pointer to the parent dentry for this file. This should be a502 * directory dentry if set. If this parameter is NULL, then the503 * file will be created in the root of the debugfs filesystem.504 * @data: a pointer to something that the caller will want to get to later505 * on. The inode.i_private pointer will point to this value on506 * the open() call.507 * @fops: a pointer to a struct file_operations that should be used for508 * this file.509 *510 * debugfs_create_file_unsafe() is completely analogous to511 * debugfs_create_file(), the only difference being that the fops512 * handed it will not get protected against file removals by the513 * debugfs core.514 *515 * It is your responsibility to protect your struct file_operation516 * methods against file removals by means of debugfs_file_get()517 * and debugfs_file_put(). ->open() is still protected by518 * debugfs though.519 *520 * Any struct file_operations defined by means of521 * DEFINE_DEBUGFS_ATTRIBUTE() is protected against file removals and522 * thus, may be used here.523 */524struct dentry *debugfs_create_file_unsafe(const char *name, umode_t mode,525 struct dentry *parent, void *data,526 const struct file_operations *fops)527{528 529 return __debugfs_create_file(name, mode, parent, data,530 fops ? &debugfs_open_proxy_file_operations :531 &debugfs_noop_file_operations,532 fops);533}534EXPORT_SYMBOL_GPL(debugfs_create_file_unsafe);535 536/**537 * debugfs_create_file_size - create a file in the debugfs filesystem538 * @name: a pointer to a string containing the name of the file to create.539 * @mode: the permission that the file should have.540 * @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 * @data: a pointer to something that the caller will want to get to later544 * on. The inode.i_private pointer will point to this value on545 * the open() call.546 * @fops: a pointer to a struct file_operations that should be used for547 * this file.548 * @file_size: initial file size549 *550 * This is the basic "create a file" function for debugfs. It allows for a551 * wide range of flexibility in creating a file, or a directory (if you want552 * to create a directory, the debugfs_create_dir() function is553 * recommended to be used instead.)554 */555void debugfs_create_file_size(const char *name, umode_t mode,556 struct dentry *parent, void *data,557 const struct file_operations *fops,558 loff_t file_size)559{560 struct dentry *de = debugfs_create_file(name, mode, parent, data, fops);561 562 if (!IS_ERR(de))563 d_inode(de)->i_size = file_size;564}565EXPORT_SYMBOL_GPL(debugfs_create_file_size);566 567/**568 * debugfs_create_dir - create a directory in the debugfs filesystem569 * @name: a pointer to a string containing the name of the directory to570 * create.571 * @parent: a pointer to the parent dentry for this file. This should be a572 * directory dentry if set. If this parameter is NULL, then the573 * directory will be created in the root of the debugfs filesystem.574 *575 * This function creates a directory in debugfs with the given name.576 *577 * This function will return a pointer to a dentry if it succeeds. This578 * pointer must be passed to the debugfs_remove() function when the file is579 * to be removed (no automatic cleanup happens if your module is unloaded,580 * you are responsible here.) If an error occurs, ERR_PTR(-ERROR) will be581 * returned.582 *583 * If debugfs is not enabled in the kernel, the value -%ENODEV will be584 * returned.585 *586 * NOTE: it's expected that most callers should _ignore_ the errors returned587 * by this function. Other debugfs functions handle the fact that the "dentry"588 * passed to them could be an error and they don't crash in that case.589 * Drivers should generally work fine even if debugfs fails to init anyway.590 */591struct dentry *debugfs_create_dir(const char *name, struct dentry *parent)592{593 struct dentry *dentry = start_creating(name, parent);594 struct inode *inode;595 596 if (IS_ERR(dentry))597 return dentry;598 599 if (!(debugfs_allow & DEBUGFS_ALLOW_API)) {600 failed_creating(dentry);601 return ERR_PTR(-EPERM);602 }603 604 inode = debugfs_get_inode(dentry->d_sb);605 if (unlikely(!inode)) {606 pr_err("out of free dentries, can not create directory '%s'\n",607 name);608 return failed_creating(dentry);609 }610 611 inode->i_mode = S_IFDIR | S_IRWXU | S_IRUGO | S_IXUGO;612 inode->i_op = &debugfs_dir_inode_operations;613 inode->i_fop = &simple_dir_operations;614 615 /* directory inodes start off with i_nlink == 2 (for "." entry) */616 inc_nlink(inode);617 d_instantiate(dentry, inode);618 inc_nlink(d_inode(dentry->d_parent));619 fsnotify_mkdir(d_inode(dentry->d_parent), dentry);620 return end_creating(dentry);621}622EXPORT_SYMBOL_GPL(debugfs_create_dir);623 624/**625 * debugfs_create_automount - create automount point in the debugfs filesystem626 * @name: a pointer to a string containing the name of the file to create.627 * @parent: a pointer to the parent dentry for this file. This should be a628 * directory dentry if set. If this parameter is NULL, then the629 * file will be created in the root of the debugfs filesystem.630 * @f: function to be called when pathname resolution steps on that one.631 * @data: opaque argument to pass to f().632 *633 * @f should return what ->d_automount() would.634 */635struct dentry *debugfs_create_automount(const char *name,636 struct dentry *parent,637 debugfs_automount_t f,638 void *data)639{640 struct dentry *dentry = start_creating(name, parent);641 struct debugfs_fsdata *fsd;642 struct inode *inode;643 644 if (IS_ERR(dentry))645 return dentry;646 647 fsd = kzalloc(sizeof(*fsd), GFP_KERNEL);648 if (!fsd) {649 failed_creating(dentry);650 return ERR_PTR(-ENOMEM);651 }652 653 fsd->automount = f;654 655 if (!(debugfs_allow & DEBUGFS_ALLOW_API)) {656 failed_creating(dentry);657 kfree(fsd);658 return ERR_PTR(-EPERM);659 }660 661 inode = debugfs_get_inode(dentry->d_sb);662 if (unlikely(!inode)) {663 pr_err("out of free dentries, can not create automount '%s'\n",664 name);665 kfree(fsd);666 return failed_creating(dentry);667 }668 669 make_empty_dir_inode(inode);670 inode->i_flags |= S_AUTOMOUNT;671 inode->i_private = data;672 dentry->d_fsdata = fsd;673 /* directory inodes start off with i_nlink == 2 (for "." entry) */674 inc_nlink(inode);675 d_instantiate(dentry, inode);676 inc_nlink(d_inode(dentry->d_parent));677 fsnotify_mkdir(d_inode(dentry->d_parent), dentry);678 return end_creating(dentry);679}680EXPORT_SYMBOL(debugfs_create_automount);681 682/**683 * debugfs_create_symlink- create a symbolic link in the debugfs filesystem684 * @name: a pointer to a string containing the name of the symbolic link to685 * create.686 * @parent: a pointer to the parent dentry for this symbolic link. This687 * should be a directory dentry if set. If this parameter is NULL,688 * then the symbolic link will be created in the root of the debugfs689 * filesystem.690 * @target: a pointer to a string containing the path to the target of the691 * symbolic link.692 *693 * This function creates a symbolic link with the given name in debugfs that694 * links to the given target path.695 *696 * This function will return a pointer to a dentry if it succeeds. This697 * pointer must be passed to the debugfs_remove() function when the symbolic698 * link is to be removed (no automatic cleanup happens if your module is699 * unloaded, you are responsible here.) If an error occurs, ERR_PTR(-ERROR)700 * will be returned.701 *702 * If debugfs is not enabled in the kernel, the value -%ENODEV will be703 * returned.704 */705struct dentry *debugfs_create_symlink(const char *name, struct dentry *parent,706 const char *target)707{708 struct dentry *dentry;709 struct inode *inode;710 char *link = kstrdup(target, GFP_KERNEL);711 if (!link)712 return ERR_PTR(-ENOMEM);713 714 dentry = start_creating(name, parent);715 if (IS_ERR(dentry)) {716 kfree(link);717 return dentry;718 }719 720 inode = debugfs_get_inode(dentry->d_sb);721 if (unlikely(!inode)) {722 pr_err("out of free dentries, can not create symlink '%s'\n",723 name);724 kfree(link);725 return failed_creating(dentry);726 }727 inode->i_mode = S_IFLNK | S_IRWXUGO;728 inode->i_op = &debugfs_symlink_inode_operations;729 inode->i_link = link;730 d_instantiate(dentry, inode);731 return end_creating(dentry);732}733EXPORT_SYMBOL_GPL(debugfs_create_symlink);734 735static void __debugfs_file_removed(struct dentry *dentry)736{737 struct debugfs_fsdata *fsd;738 739 /*740 * Paired with the closing smp_mb() implied by a successful741 * cmpxchg() in debugfs_file_get(): either742 * debugfs_file_get() must see a dead dentry or we must see a743 * debugfs_fsdata instance at ->d_fsdata here (or both).744 */745 smp_mb();746 fsd = READ_ONCE(dentry->d_fsdata);747 if ((unsigned long)fsd & DEBUGFS_FSDATA_IS_REAL_FOPS_BIT)748 return;749 750 /* if this was the last reference, we're done */751 if (refcount_dec_and_test(&fsd->active_users))752 return;753 754 /*755 * If there's still a reference, the code that obtained it can756 * be in different states:757 * - The common case of not using cancellations, or already758 * after debugfs_leave_cancellation(), where we just need759 * to wait for debugfs_file_put() which signals the completion;760 * - inside a cancellation section, i.e. between761 * debugfs_enter_cancellation() and debugfs_leave_cancellation(),762 * in which case we need to trigger the ->cancel() function,763 * and then wait for debugfs_file_put() just like in the764 * previous case;765 * - before debugfs_enter_cancellation() (but obviously after766 * debugfs_file_get()), in which case we may not see the767 * cancellation in the list on the first round of the loop,768 * but debugfs_enter_cancellation() signals the completion769 * after adding it, so this code gets woken up to call the770 * ->cancel() function.771 */772 while (refcount_read(&fsd->active_users)) {773 struct debugfs_cancellation *c;774 775 /*776 * Lock the cancellations. Note that the cancellations777 * structs are meant to be on the stack, so we need to778 * ensure we either use them here or don't touch them,779 * and debugfs_leave_cancellation() will wait for this780 * to be finished processing before exiting one. It may781 * of course win and remove the cancellation, but then782 * chances are we never even got into this bit, we only783 * do if the refcount isn't zero already.784 */785 mutex_lock(&fsd->cancellations_mtx);786 while ((c = list_first_entry_or_null(&fsd->cancellations,787 typeof(*c), list))) {788 list_del_init(&c->list);789 c->cancel(dentry, c->cancel_data);790 }791 mutex_unlock(&fsd->cancellations_mtx);792 793 wait_for_completion(&fsd->active_users_drained);794 }795}796 797static void remove_one(struct dentry *victim)798{799 if (d_is_reg(victim))800 __debugfs_file_removed(victim);801 simple_release_fs(&debugfs_mount, &debugfs_mount_count);802}803 804/**805 * debugfs_remove - recursively removes a directory806 * @dentry: a pointer to a the dentry of the directory to be removed. If this807 * parameter is NULL or an error value, nothing will be done.808 *809 * This function recursively removes a directory tree in debugfs that810 * was previously created with a call to another debugfs function811 * (like debugfs_create_file() or variants thereof.)812 *813 * This function is required to be called in order for the file to be814 * removed, no automatic cleanup of files will happen when a module is815 * removed, you are responsible here.816 */817void debugfs_remove(struct dentry *dentry)818{819 if (IS_ERR_OR_NULL(dentry))820 return;821 822 simple_pin_fs(&debug_fs_type, &debugfs_mount, &debugfs_mount_count);823 simple_recursive_removal(dentry, remove_one);824 simple_release_fs(&debugfs_mount, &debugfs_mount_count);825}826EXPORT_SYMBOL_GPL(debugfs_remove);827 828/**829 * debugfs_lookup_and_remove - lookup a directory or file and recursively remove it830 * @name: a pointer to a string containing the name of the item to look up.831 * @parent: a pointer to the parent dentry of the item.832 *833 * This is the equlivant of doing something like834 * debugfs_remove(debugfs_lookup(..)) but with the proper reference counting835 * handled for the directory being looked up.836 */837void debugfs_lookup_and_remove(const char *name, struct dentry *parent)838{839 struct dentry *dentry;840 841 dentry = debugfs_lookup(name, parent);842 if (!dentry)843 return;844 845 debugfs_remove(dentry);846 dput(dentry);847}848EXPORT_SYMBOL_GPL(debugfs_lookup_and_remove);849 850/**851 * debugfs_rename - rename a file/directory in the debugfs filesystem852 * @old_dir: a pointer to the parent dentry for the renamed object. This853 * should be a directory dentry.854 * @old_dentry: dentry of an object to be renamed.855 * @new_dir: a pointer to the parent dentry where the object should be856 * moved. This should be a directory dentry.857 * @new_name: a pointer to a string containing the target name.858 *859 * This function renames a file/directory in debugfs. The target must not860 * exist for rename to succeed.861 *862 * This function will return a pointer to old_dentry (which is updated to863 * reflect renaming) if it succeeds. If an error occurs, ERR_PTR(-ERROR)864 * will be returned.865 *866 * If debugfs is not enabled in the kernel, the value -%ENODEV will be867 * returned.868 */869struct dentry *debugfs_rename(struct dentry *old_dir, struct dentry *old_dentry,870 struct dentry *new_dir, const char *new_name)871{872 int error;873 struct dentry *dentry = NULL, *trap;874 struct name_snapshot old_name;875 876 if (IS_ERR(old_dir))877 return old_dir;878 if (IS_ERR(new_dir))879 return new_dir;880 if (IS_ERR_OR_NULL(old_dentry))881 return old_dentry;882 883 trap = lock_rename(new_dir, old_dir);884 /* Source or destination directories don't exist? */885 if (d_really_is_negative(old_dir) || d_really_is_negative(new_dir))886 goto exit;887 /* Source does not exist, cyclic rename, or mountpoint? */888 if (d_really_is_negative(old_dentry) || old_dentry == trap ||889 d_mountpoint(old_dentry))890 goto exit;891 dentry = lookup_one_len(new_name, new_dir, strlen(new_name));892 /* Lookup failed, cyclic rename or target exists? */893 if (IS_ERR(dentry) || dentry == trap || d_really_is_positive(dentry))894 goto exit;895 896 take_dentry_name_snapshot(&old_name, old_dentry);897 898 error = simple_rename(&nop_mnt_idmap, d_inode(old_dir), old_dentry,899 d_inode(new_dir), dentry, 0);900 if (error) {901 release_dentry_name_snapshot(&old_name);902 goto exit;903 }904 d_move(old_dentry, dentry);905 fsnotify_move(d_inode(old_dir), d_inode(new_dir), &old_name.name,906 d_is_dir(old_dentry),907 NULL, old_dentry);908 release_dentry_name_snapshot(&old_name);909 unlock_rename(new_dir, old_dir);910 dput(dentry);911 return old_dentry;912exit:913 if (dentry && !IS_ERR(dentry))914 dput(dentry);915 unlock_rename(new_dir, old_dir);916 if (IS_ERR(dentry))917 return dentry;918 return ERR_PTR(-EINVAL);919}920EXPORT_SYMBOL_GPL(debugfs_rename);921 922/**923 * debugfs_initialized - Tells whether debugfs has been registered924 */925bool debugfs_initialized(void)926{927 return debugfs_registered;928}929EXPORT_SYMBOL_GPL(debugfs_initialized);930 931static int __init debugfs_kernel(char *str)932{933 if (str) {934 if (!strcmp(str, "on"))935 debugfs_allow = DEBUGFS_ALLOW_API | DEBUGFS_ALLOW_MOUNT;936 else if (!strcmp(str, "no-mount"))937 debugfs_allow = DEBUGFS_ALLOW_API;938 else if (!strcmp(str, "off"))939 debugfs_allow = 0;940 }941 942 return 0;943}944early_param("debugfs", debugfs_kernel);945static int __init debugfs_init(void)946{947 int retval;948 949 if (!(debugfs_allow & DEBUGFS_ALLOW_MOUNT))950 return -EPERM;951 952 retval = sysfs_create_mount_point(kernel_kobj, "debug");953 if (retval)954 return retval;955 956 retval = register_filesystem(&debug_fs_type);957 if (retval)958 sysfs_remove_mount_point(kernel_kobj, "debug");959 else960 debugfs_registered = true;961 962 return retval;963}964core_initcall(debugfs_init);965