1// SPDX-License-Identifier: GPL-2.0 2/* 3 * inode.c - part of debugfs, a tiny little debug file system 4 * 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: " fmt 14 15#include <linux/module.h> 16#include <linux/fs.h> 17#include <linux/mount.h> 18#include <linux/pagemap.h> 19#include <linux/init.h> 20#include <linux/kobject.h> 21#include <linux/namei.h> 22#include <linux/debugfs.h> 23#include <linux/fsnotify.h> 24#include <linux/string.h> 25#include <linux/seq_file.h> 26#include <linux/parser.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 0700 34 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 down 42 * so that we can use the file mode as part of a heuristic to determine whether 43 * 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_mount_opts { 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_err 93}; 94 95static const match_table_t tokens = { 96 {Opt_uid, "uid=%u"}, 97 {Opt_gid, "gid=%u"}, 98 {Opt_mode, "mode=%o"}, 99 {Opt_err, NULL} 100}; 101 102struct debugfs_fs_info { 103 struct debugfs_mount_opts mount_opts; 104}; 105 106static int debugfs_parse_options(char *data, struct debugfs_mount_opts *opts) 107{ 108 substring_t args[MAX_OPT_ARGS]; 109 int option; 110 int token; 111 kuid_t uid; 112 kgid_t gid; 113 char *p; 114 115 opts->opts = 0; 116 opts->mode = DEBUGFS_DEFAULT_MODE; 117 118 while ((p = strsep(&data, ",")) != NULL) { 119 if (!*p) 120 continue; 121 122 token = match_token(p, tokens, args); 123 switch (token) { 124 case Opt_uid: 125 if (match_int(&args[0], &option)) 126 return -EINVAL; 127 uid = make_kuid(current_user_ns(), option); 128 if (!uid_valid(uid)) 129 return -EINVAL; 130 opts->uid = uid; 131 break; 132 case Opt_gid: 133 if (match_int(&args[0], &option)) 134 return -EINVAL; 135 gid = make_kgid(current_user_ns(), option); 136 if (!gid_valid(gid)) 137 return -EINVAL; 138 opts->gid = gid; 139 break; 140 case Opt_mode: 141 if (match_octal(&args[0], &option)) 142 return -EINVAL; 143 opts->mode = option & S_IALLUGO; 144 break; 145 /* 146 * We might like to report bad mount options here; 147 * but traditionally debugfs has ignored all mount options 148 */ 149 } 150 151 opts->opts |= BIT(token); 152 } 153 154 return 0; 155} 156 157static void _debugfs_apply_options(struct super_block *sb, bool remount) 158{ 159 struct debugfs_fs_info *fsi = sb->s_fs_info; 160 struct inode *inode = d_inode(sb->s_root); 161 struct debugfs_mount_opts *opts = &fsi->mount_opts; 162 163 /* 164 * On remount, only reset mode/uid/gid if they were provided as mount 165 * options. 166 */ 167 168 if (!remount || opts->opts & BIT(Opt_mode)) { 169 inode->i_mode &= ~S_IALLUGO; 170 inode->i_mode |= opts->mode; 171 } 172 173 if (!remount || opts->opts & BIT(Opt_uid)) 174 inode->i_uid = opts->uid; 175 176 if (!remount || opts->opts & BIT(Opt_gid)) 177 inode->i_gid = opts->gid; 178} 179 180static void debugfs_apply_options(struct super_block *sb) 181{ 182 _debugfs_apply_options(sb, false); 183} 184 185static void debugfs_apply_options_remount(struct super_block *sb) 186{ 187 _debugfs_apply_options(sb, true); 188} 189 190static int debugfs_remount(struct super_block *sb, int *flags, char *data) 191{ 192 int err; 193 struct debugfs_fs_info *fsi = sb->s_fs_info; 194 195 sync_filesystem(sb); 196 err = debugfs_parse_options(data, &fsi->mount_opts); 197 if (err) 198 goto fail; 199 200 debugfs_apply_options_remount(sb); 201 202fail: 203 return err; 204} 205 206static int debugfs_show_options(struct seq_file *m, struct dentry *root) 207{ 208 struct debugfs_fs_info *fsi = root->d_sb->s_fs_info; 209 struct debugfs_mount_opts *opts = &fsi->mount_opts; 210 211 if (!uid_eq(opts->uid, GLOBAL_ROOT_UID)) 212 seq_printf(m, ",uid=%u", 213 from_kuid_munged(&init_user_ns, opts->uid)); 214 if (!gid_eq(opts->gid, GLOBAL_ROOT_GID)) 215 seq_printf(m, ",gid=%u", 216 from_kgid_munged(&init_user_ns, opts->gid)); 217 if (opts->mode != DEBUGFS_DEFAULT_MODE) 218 seq_printf(m, ",mode=%o", opts->mode); 219 220 return 0; 221} 222 223static void debugfs_free_inode(struct inode *inode) 224{ 225 if (S_ISLNK(inode->i_mode)) 226 kfree(inode->i_link); 227 free_inode_nonrcu(inode); 228} 229 230static const struct super_operations debugfs_super_operations = { 231 .statfs = simple_statfs, 232 .remount_fs = debugfs_remount, 233 .show_options = debugfs_show_options, 234 .free_inode = debugfs_free_inode, 235}; 236 237static void debugfs_release_dentry(struct dentry *dentry) 238{ 239 struct debugfs_fsdata *fsd = dentry->d_fsdata; 240 241 if ((unsigned long)fsd & DEBUGFS_FSDATA_IS_REAL_FOPS_BIT) 242 return; 243 244 /* check it wasn't a dir (no fsdata) or automount (no real_fops) */ 245 if (fsd && fsd->real_fops) { 246 WARN_ON(!list_empty(&fsd->cancellations)); 247 mutex_destroy(&fsd->cancellations_mtx); 248 } 249 250 kfree(fsd); 251} 252 253static struct vfsmount *debugfs_automount(struct path *path) 254{ 255 struct debugfs_fsdata *fsd = path->dentry->d_fsdata; 256 257 return fsd->automount(path->dentry, d_inode(path->dentry)->i_private); 258} 259 260static const struct dentry_operations debugfs_dops = { 261 .d_delete = always_delete_dentry, 262 .d_release = debugfs_release_dentry, 263 .d_automount = debugfs_automount, 264}; 265 266static int debug_fill_super(struct super_block *sb, void *data, int silent) 267{ 268 static const struct tree_descr debug_files[] = {{""}}; 269 struct debugfs_fs_info *fsi; 270 int err; 271 272 fsi = kzalloc(sizeof(struct debugfs_fs_info), GFP_KERNEL); 273 sb->s_fs_info = fsi; 274 if (!fsi) { 275 err = -ENOMEM; 276 goto fail; 277 } 278 279 err = debugfs_parse_options(data, &fsi->mount_opts); 280 if (err) 281 goto fail; 282 283 err = simple_fill_super(sb, DEBUGFS_MAGIC, debug_files); 284 if (err) 285 goto fail; 286 287 sb->s_op = &debugfs_super_operations; 288 sb->s_d_op = &debugfs_dops; 289 290 debugfs_apply_options(sb); 291 292 return 0; 293 294fail: 295 kfree(fsi); 296 sb->s_fs_info = NULL; 297 return err; 298} 299 300static struct dentry *debug_mount(struct file_system_type *fs_type, 301 int flags, const char *dev_name, 302 void *data) 303{ 304 if (!(debugfs_allow & DEBUGFS_ALLOW_API)) 305 return ERR_PTR(-EPERM); 306 307 return mount_single(fs_type, flags, data, debug_fill_super); 308} 309 310static struct file_system_type debug_fs_type = { 311 .owner = THIS_MODULE, 312 .name = "debugfs", 313 .mount = debug_mount, 314 .kill_sb = kill_litter_super, 315}; 316MODULE_ALIAS_FS("debugfs"); 317 318/** 319 * debugfs_lookup() - look up an existing debugfs file 320 * @name: a pointer to a string containing the name of the file to look up. 321 * @parent: a pointer to the parent dentry of the file. 322 * 323 * This function will return a pointer to a dentry if it succeeds. If the file 324 * doesn't exist or an error occurs, %NULL will be returned. The returned 325 * dentry must be passed to dput() when it is no longer needed. 326 * 327 * If debugfs is not enabled in the kernel, the value -%ENODEV will be 328 * returned. 329 */ 330struct dentry *debugfs_lookup(const char *name, struct dentry *parent) 331{ 332 struct dentry *dentry; 333 334 if (!debugfs_initialized() || IS_ERR_OR_NULL(name) || IS_ERR(parent)) 335 return NULL; 336 337 if (!parent) 338 parent = debugfs_mount->mnt_root; 339 340 dentry = lookup_positive_unlocked(name, parent, strlen(name)); 341 if (IS_ERR(dentry)) 342 return NULL; 343 return dentry; 344} 345EXPORT_SYMBOL_GPL(debugfs_lookup); 346 347static struct dentry *start_creating(const char *name, struct dentry *parent) 348{ 349 struct dentry *dentry; 350 int error; 351 352 if (!(debugfs_allow & DEBUGFS_ALLOW_API)) 353 return ERR_PTR(-EPERM); 354 355 if (!debugfs_initialized()) 356 return ERR_PTR(-ENOENT); 357 358 pr_debug("creating file '%s'\n", name); 359 360 if (IS_ERR(parent)) 361 return parent; 362 363 error = simple_pin_fs(&debug_fs_type, &debugfs_mount, 364 &debugfs_mount_count); 365 if (error) { 366 pr_err("Unable to pin filesystem for file '%s'\n", name); 367 return ERR_PTR(error); 368 } 369 370 /* If the parent is not specified, we create it in the root. 371 * We need the root dentry to do this, which is in the super 372 * block. A pointer to that is in the struct vfsmount that we 373 * have around. 374 */ 375 if (!parent) 376 parent = debugfs_mount->mnt_root; 377 378 inode_lock(d_inode(parent)); 379 if (unlikely(IS_DEADDIR(d_inode(parent)))) 380 dentry = ERR_PTR(-ENOENT); 381 else 382 dentry = lookup_one_len(name, parent, strlen(name)); 383 if (!IS_ERR(dentry) && d_really_is_positive(dentry)) { 384 if (d_is_dir(dentry)) 385 pr_err("Directory '%s' with parent '%s' already present!\n", 386 name, parent->d_name.name); 387 else 388 pr_err("File '%s' in directory '%s' already present!\n", 389 name, parent->d_name.name); 390 dput(dentry); 391 dentry = ERR_PTR(-EEXIST); 392 } 393 394 if (IS_ERR(dentry)) { 395 inode_unlock(d_inode(parent)); 396 simple_release_fs(&debugfs_mount, &debugfs_mount_count); 397 } 398 399 return dentry; 400} 401 402static struct dentry *failed_creating(struct dentry *dentry) 403{ 404 inode_unlock(d_inode(dentry->d_parent)); 405 dput(dentry); 406 simple_release_fs(&debugfs_mount, &debugfs_mount_count); 407 return ERR_PTR(-ENOMEM); 408} 409 410static struct dentry *end_creating(struct dentry *dentry) 411{ 412 inode_unlock(d_inode(dentry->d_parent)); 413 return dentry; 414} 415 416static struct dentry *__debugfs_create_file(const char *name, umode_t mode, 417 struct dentry *parent, void *data, 418 const struct file_operations *proxy_fops, 419 const struct file_operations *real_fops) 420{ 421 struct dentry *dentry; 422 struct inode *inode; 423 424 if (!(mode & S_IFMT)) 425 mode |= S_IFREG; 426 BUG_ON(!S_ISREG(mode)); 427 dentry = start_creating(name, parent); 428 429 if (IS_ERR(dentry)) 430 return dentry; 431 432 if (!(debugfs_allow & DEBUGFS_ALLOW_API)) { 433 failed_creating(dentry); 434 return ERR_PTR(-EPERM); 435 } 436 437 inode = debugfs_get_inode(dentry->d_sb); 438 if (unlikely(!inode)) { 439 pr_err("out of free dentries, can not create file '%s'\n", 440 name); 441 return failed_creating(dentry); 442 } 443 444 inode->i_mode = mode; 445 inode->i_private = data; 446 447 inode->i_op = &debugfs_file_inode_operations; 448 inode->i_fop = proxy_fops; 449 dentry->d_fsdata = (void *)((unsigned long)real_fops | 450 DEBUGFS_FSDATA_IS_REAL_FOPS_BIT); 451 452 d_instantiate(dentry, inode); 453 fsnotify_create(d_inode(dentry->d_parent), dentry); 454 return end_creating(dentry); 455} 456 457/** 458 * debugfs_create_file - create a file in the debugfs filesystem 459 * @name: a pointer to a string containing the name of the file to create. 460 * @mode: the permission that the file should have. 461 * @parent: a pointer to the parent dentry for this file. This should be a 462 * directory dentry if set. If this parameter is NULL, then the 463 * file will be created in the root of the debugfs filesystem. 464 * @data: a pointer to something that the caller will want to get to later 465 * on. The inode.i_private pointer will point to this value on 466 * the open() call. 467 * @fops: a pointer to a struct file_operations that should be used for 468 * this file. 469 * 470 * This is the basic "create a file" function for debugfs. It allows for a 471 * wide range of flexibility in creating a file, or a directory (if you want 472 * to create a directory, the debugfs_create_dir() function is 473 * recommended to be used instead.) 474 * 475 * This function will return a pointer to a dentry if it succeeds. This 476 * pointer must be passed to the debugfs_remove() function when the file is 477 * to be removed (no automatic cleanup happens if your module is unloaded, 478 * you are responsible here.) If an error occurs, ERR_PTR(-ERROR) will be 479 * returned. 480 * 481 * If debugfs is not enabled in the kernel, the value -%ENODEV will be 482 * returned. 483 * 484 * NOTE: it's expected that most callers should _ignore_ the errors returned 485 * by this function. Other debugfs functions handle the fact that the "dentry" 486 * passed to them could be an error and they don't crash in that case. 487 * Drivers should generally work fine even if debugfs fails to init anyway. 488 */ 489struct dentry *debugfs_create_file(const char *name, umode_t mode, 490 struct dentry *parent, void *data, 491 const struct file_operations *fops) 492{ 493 494 return __debugfs_create_file(name, mode, parent, data, 495 fops ? &debugfs_full_proxy_file_operations : 496 &debugfs_noop_file_operations, 497 fops); 498} 499EXPORT_SYMBOL_GPL(debugfs_create_file); 500 501/** 502 * debugfs_create_file_unsafe - create a file in the debugfs filesystem 503 * @name: a pointer to a string containing the name of the file to create. 504 * @mode: the permission that the file should have. 505 * @parent: a pointer to the parent dentry for this file. This should be a 506 * directory dentry if set. If this parameter is NULL, then the 507 * file will be created in the root of the debugfs filesystem. 508 * @data: a pointer to something that the caller will want to get to later 509 * on. The inode.i_private pointer will point to this value on 510 * the open() call. 511 * @fops: a pointer to a struct file_operations that should be used for 512 * this file. 513 * 514 * debugfs_create_file_unsafe() is completely analogous to 515 * debugfs_create_file(), the only difference being that the fops 516 * handed it will not get protected against file removals by the 517 * debugfs core. 518 * 519 * It is your responsibility to protect your struct file_operation 520 * methods against file removals by means of debugfs_file_get() 521 * and debugfs_file_put(). ->open() is still protected by 522 * debugfs though. 523 * 524 * Any struct file_operations defined by means of 525 * DEFINE_DEBUGFS_ATTRIBUTE() is protected against file removals and 526 * thus, may be used here. 527 */ 528struct dentry *debugfs_create_file_unsafe(const char *name, umode_t mode, 529 struct dentry *parent, void *data, 530 const struct file_operations *fops) 531{ 532 533 return __debugfs_create_file(name, mode, parent, data, 534 fops ? &debugfs_open_proxy_file_operations : 535 &debugfs_noop_file_operations, 536 fops); 537} 538EXPORT_SYMBOL_GPL(debugfs_create_file_unsafe); 539 540/** 541 * debugfs_create_file_size - create a file in the debugfs filesystem 542 * @name: a pointer to a string containing the name of the file to create. 543 * @mode: the permission that the file should have. 544 * @parent: a pointer to the parent dentry for this file. This should be a 545 * directory dentry if set. If this parameter is NULL, then the 546 * file will be created in the root of the debugfs filesystem. 547 * @data: a pointer to something that the caller will want to get to later 548 * on. The inode.i_private pointer will point to this value on 549 * the open() call. 550 * @fops: a pointer to a struct file_operations that should be used for 551 * this file. 552 * @file_size: initial file size 553 * 554 * This is the basic "create a file" function for debugfs. It allows for a 555 * wide range of flexibility in creating a file, or a directory (if you want 556 * to create a directory, the debugfs_create_dir() function is 557 * recommended to be used instead.) 558 */ 559void debugfs_create_file_size(const char *name, umode_t mode, 560 struct dentry *parent, void *data, 561 const struct file_operations *fops, 562 loff_t file_size) 563{ 564 struct dentry *de = debugfs_create_file(name, mode, parent, data, fops); 565 566 if (!IS_ERR(de)) 567 d_inode(de)->i_size = file_size; 568} 569EXPORT_SYMBOL_GPL(debugfs_create_file_size); 570 571/** 572 * debugfs_create_dir - create a directory in the debugfs filesystem 573 * @name: a pointer to a string containing the name of the directory to 574 * create. 575 * @parent: a pointer to the parent dentry for this file. This should be a 576 * directory dentry if set. If this parameter is NULL, then the 577 * directory will be created in the root of the debugfs filesystem. 578 * 579 * This function creates a directory in debugfs with the given name. 580 * 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 585 * returned. 586 * 587 * If debugfs is not enabled in the kernel, the value -%ENODEV will be 588 * returned. 589 * 590 * NOTE: it's expected that most callers should _ignore_ the errors returned 591 * by this function. Other debugfs functions handle the fact that the "dentry" 592 * passed to them could be an error and they don't crash in that case. 593 * Drivers should generally work fine even if debugfs fails to init anyway. 594 */ 595struct dentry *debugfs_create_dir(const char *name, struct dentry *parent) 596{ 597 struct dentry *dentry = start_creating(name, parent); 598 struct inode *inode; 599 600 if (IS_ERR(dentry)) 601 return dentry; 602 603 if (!(debugfs_allow & DEBUGFS_ALLOW_API)) { 604 failed_creating(dentry); 605 return ERR_PTR(-EPERM); 606 } 607 608 inode = debugfs_get_inode(dentry->d_sb); 609 if (unlikely(!inode)) { 610 pr_err("out of free dentries, can not create directory '%s'\n", 611 name); 612 return failed_creating(dentry); 613 } 614 615 inode->i_mode = S_IFDIR | S_IRWXU | S_IRUGO | S_IXUGO; 616 inode->i_op = &debugfs_dir_inode_operations; 617 inode->i_fop = &simple_dir_operations; 618 619 /* directory inodes start off with i_nlink == 2 (for "." entry) */ 620 inc_nlink(inode); 621 d_instantiate(dentry, inode); 622 inc_nlink(d_inode(dentry->d_parent)); 623 fsnotify_mkdir(d_inode(dentry->d_parent), dentry); 624 return end_creating(dentry); 625} 626EXPORT_SYMBOL_GPL(debugfs_create_dir); 627 628/** 629 * debugfs_create_automount - create automount point in the debugfs filesystem 630 * @name: a pointer to a string containing the name of the file to create. 631 * @parent: a pointer to the parent dentry for this file. This should be a 632 * directory dentry if set. If this parameter is NULL, then the 633 * file will be created in the root of the debugfs filesystem. 634 * @f: function to be called when pathname resolution steps on that one. 635 * @data: opaque argument to pass to f(). 636 * 637 * @f should return what ->d_automount() would. 638 */ 639struct dentry *debugfs_create_automount(const char *name, 640 struct dentry *parent, 641 debugfs_automount_t f, 642 void *data) 643{ 644 struct dentry *dentry = start_creating(name, parent); 645 struct debugfs_fsdata *fsd; 646 struct inode *inode; 647 648 if (IS_ERR(dentry)) 649 return dentry; 650 651 fsd = kzalloc(sizeof(*fsd), GFP_KERNEL); 652 if (!fsd) { 653 failed_creating(dentry); 654 return ERR_PTR(-ENOMEM); 655 } 656 657 fsd->automount = f; 658 659 if (!(debugfs_allow & DEBUGFS_ALLOW_API)) { 660 failed_creating(dentry); 661 kfree(fsd); 662 return ERR_PTR(-EPERM); 663 } 664 665 inode = debugfs_get_inode(dentry->d_sb); 666 if (unlikely(!inode)) { 667 pr_err("out of free dentries, can not create automount '%s'\n", 668 name); 669 kfree(fsd); 670 return failed_creating(dentry); 671 } 672 673 make_empty_dir_inode(inode); 674 inode->i_flags |= S_AUTOMOUNT; 675 inode->i_private = data; 676 dentry->d_fsdata = fsd; 677 /* directory inodes start off with i_nlink == 2 (for "." entry) */ 678 inc_nlink(inode); 679 d_instantiate(dentry, inode); 680 inc_nlink(d_inode(dentry->d_parent)); 681 fsnotify_mkdir(d_inode(dentry->d_parent), dentry); 682 return end_creating(dentry); 683} 684EXPORT_SYMBOL(debugfs_create_automount); 685 686/** 687 * debugfs_create_symlink- create a symbolic link in the debugfs filesystem 688 * @name: a pointer to a string containing the name of the symbolic link to 689 * create. 690 * @parent: a pointer to the parent dentry for this symbolic link. This 691 * should be a directory dentry if set. If this parameter is NULL, 692 * then the symbolic link will be created in the root of the debugfs 693 * filesystem. 694 * @target: a pointer to a string containing the path to the target of the 695 * symbolic link. 696 * 697 * This function creates a symbolic link with the given name in debugfs that 698 * links to the given target path. 699 * 700 * This function will return a pointer to a dentry if it succeeds. This 701 * pointer must be passed to the debugfs_remove() function when the symbolic 702 * link is to be removed (no automatic cleanup happens if your module is 703 * unloaded, you are responsible here.) If an error occurs, ERR_PTR(-ERROR) 704 * will be returned. 705 * 706 * If debugfs is not enabled in the kernel, the value -%ENODEV will be 707 * returned. 708 */ 709struct dentry *debugfs_create_symlink(const char *name, struct dentry *parent, 710 const char *target) 711{ 712 struct dentry *dentry; 713 struct inode *inode; 714 char *link = kstrdup(target, GFP_KERNEL); 715 if (!link) 716 return ERR_PTR(-ENOMEM); 717 718 dentry = start_creating(name, parent); 719 if (IS_ERR(dentry)) { 720 kfree(link); 721 return dentry; 722 } 723 724 inode = debugfs_get_inode(dentry->d_sb); 725 if (unlikely(!inode)) { 726 pr_err("out of free dentries, can not create symlink '%s'\n", 727 name); 728 kfree(link); 729 return failed_creating(dentry); 730 } 731 inode->i_mode = S_IFLNK | S_IRWXUGO; 732 inode->i_op = &debugfs_symlink_inode_operations; 733 inode->i_link = link; 734 d_instantiate(dentry, inode); 735 return end_creating(dentry); 736} 737EXPORT_SYMBOL_GPL(debugfs_create_symlink); 738 739static void __debugfs_file_removed(struct dentry *dentry) 740{ 741 struct debugfs_fsdata *fsd; 742 743 /* 744 * Paired with the closing smp_mb() implied by a successful 745 * cmpxchg() in debugfs_file_get(): either 746 * debugfs_file_get() must see a dead dentry or we must see a 747 * debugfs_fsdata instance at ->d_fsdata here (or both). 748 */ 749 smp_mb(); 750 fsd = READ_ONCE(dentry->d_fsdata); 751 if ((unsigned long)fsd & DEBUGFS_FSDATA_IS_REAL_FOPS_BIT) 752 return; 753 754 /* if this was the last reference, we're done */ 755 if (refcount_dec_and_test(&fsd->active_users)) 756 return; 757 758 /* 759 * If there's still a reference, the code that obtained it can 760 * be in different states: 761 * - The common case of not using cancellations, or already 762 * after debugfs_leave_cancellation(), where we just need 763 * to wait for debugfs_file_put() which signals the completion; 764 * - inside a cancellation section, i.e. between 765 * debugfs_enter_cancellation() and debugfs_leave_cancellation(), 766 * in which case we need to trigger the ->cancel() function, 767 * and then wait for debugfs_file_put() just like in the 768 * previous case; 769 * - before debugfs_enter_cancellation() (but obviously after 770 * debugfs_file_get()), in which case we may not see the 771 * cancellation in the list on the first round of the loop, 772 * but debugfs_enter_cancellation() signals the completion 773 * after adding it, so this code gets woken up to call the 774 * ->cancel() function. 775 */ 776 while (refcount_read(&fsd->active_users)) { 777 struct debugfs_cancellation *c; 778 779 /* 780 * Lock the cancellations. Note that the cancellations 781 * structs are meant to be on the stack, so we need to 782 * ensure we either use them here or don't touch them, 783 * and debugfs_leave_cancellation() will wait for this 784 * to be finished processing before exiting one. It may 785 * of course win and remove the cancellation, but then 786 * chances are we never even got into this bit, we only 787 * do if the refcount isn't zero already. 788 */ 789 mutex_lock(&fsd->cancellations_mtx); 790 while ((c = list_first_entry_or_null(&fsd->cancellations, 791 typeof(*c), list))) { 792 list_del_init(&c->list); 793 c->cancel(dentry, c->cancel_data); 794 } 795 mutex_unlock(&fsd->cancellations_mtx); 796 797 wait_for_completion(&fsd->active_users_drained); 798 } 799} 800 801static void remove_one(struct dentry *victim) 802{ 803 if (d_is_reg(victim)) 804 __debugfs_file_removed(victim); 805 simple_release_fs(&debugfs_mount, &debugfs_mount_count); 806} 807 808/** 809 * debugfs_remove - recursively removes a directory 810 * @dentry: a pointer to a the dentry of the directory to be removed. If this 811 * parameter is NULL or an error value, nothing will be done. 812 * 813 * This function recursively removes a directory tree in debugfs that 814 * was previously created with a call to another debugfs function 815 * (like debugfs_create_file() or variants thereof.) 816 * 817 * This function is required to be called in order for the file to be 818 * removed, no automatic cleanup of files will happen when a module is 819 * removed, you are responsible here. 820 */ 821void debugfs_remove(struct dentry *dentry) 822{ 823 if (IS_ERR_OR_NULL(dentry)) 824 return; 825 826 simple_pin_fs(&debug_fs_type, &debugfs_mount, &debugfs_mount_count); 827 simple_recursive_removal(dentry, remove_one); 828 simple_release_fs(&debugfs_mount, &debugfs_mount_count); 829} 830EXPORT_SYMBOL_GPL(debugfs_remove); 831 832/** 833 * debugfs_lookup_and_remove - lookup a directory or file and recursively remove it 834 * @name: a pointer to a string containing the name of the item to look up. 835 * @parent: a pointer to the parent dentry of the item. 836 * 837 * This is the equlivant of doing something like 838 * debugfs_remove(debugfs_lookup(..)) but with the proper reference counting 839 * handled for the directory being looked up. 840 */ 841void debugfs_lookup_and_remove(const char *name, struct dentry *parent) 842{ 843 struct dentry *dentry; 844 845 dentry = debugfs_lookup(name, parent); 846 if (!dentry) 847 return; 848 849 debugfs_remove(dentry); 850 dput(dentry); 851} 852EXPORT_SYMBOL_GPL(debugfs_lookup_and_remove); 853 854/** 855 * debugfs_rename - rename a file/directory in the debugfs filesystem 856 * @old_dir: a pointer to the parent dentry for the renamed object. This 857 * should be a directory dentry. 858 * @old_dentry: dentry of an object to be renamed. 859 * @new_dir: a pointer to the parent dentry where the object should be 860 * moved. This should be a directory dentry. 861 * @new_name: a pointer to a string containing the target name. 862 * 863 * This function renames a file/directory in debugfs. The target must not 864 * exist for rename to succeed. 865 * 866 * This function will return a pointer to old_dentry (which is updated to 867 * reflect renaming) if it succeeds. If an error occurs, ERR_PTR(-ERROR) 868 * will be returned. 869 * 870 * If debugfs is not enabled in the kernel, the value -%ENODEV will be 871 * returned. 872 */ 873struct dentry *debugfs_rename(struct dentry *old_dir, struct dentry *old_dentry, 874 struct dentry *new_dir, const char *new_name) 875{ 876 int error; 877 struct dentry *dentry = NULL, *trap; 878 struct name_snapshot old_name; 879 880 if (IS_ERR(old_dir)) 881 return old_dir; 882 if (IS_ERR(new_dir)) 883 return new_dir; 884 if (IS_ERR_OR_NULL(old_dentry)) 885 return old_dentry; 886 887 trap = lock_rename(new_dir, old_dir); 888 /* Source or destination directories don't exist? */ 889 if (d_really_is_negative(old_dir) || d_really_is_negative(new_dir)) 890 goto exit; 891 /* Source does not exist, cyclic rename, or mountpoint? */ 892 if (d_really_is_negative(old_dentry) || old_dentry == trap || 893 d_mountpoint(old_dentry)) 894 goto exit; 895 dentry = lookup_one_len(new_name, new_dir, strlen(new_name)); 896 /* Lookup failed, cyclic rename or target exists? */ 897 if (IS_ERR(dentry) || dentry == trap || d_really_is_positive(dentry)) 898 goto exit; 899 900 take_dentry_name_snapshot(&old_name, old_dentry); 901 902 error = simple_rename(&nop_mnt_idmap, d_inode(old_dir), old_dentry, 903 d_inode(new_dir), dentry, 0); 904 if (error) { 905 release_dentry_name_snapshot(&old_name); 906 goto exit; 907 } 908 d_move(old_dentry, dentry); 909 fsnotify_move(d_inode(old_dir), d_inode(new_dir), &old_name.name, 910 d_is_dir(old_dentry), 911 NULL, old_dentry); 912 release_dentry_name_snapshot(&old_name); 913 unlock_rename(new_dir, old_dir); 914 dput(dentry); 915 return old_dentry; 916exit: 917 if (dentry && !IS_ERR(dentry)) 918 dput(dentry); 919 unlock_rename(new_dir, old_dir); 920 if (IS_ERR(dentry)) 921 return dentry; 922 return ERR_PTR(-EINVAL); 923} 924EXPORT_SYMBOL_GPL(debugfs_rename); 925 926/** 927 * debugfs_initialized - Tells whether debugfs has been registered 928 */ 929bool debugfs_initialized(void) 930{ 931 return debugfs_registered; 932} 933EXPORT_SYMBOL_GPL(debugfs_initialized); 934 935static int __init debugfs_kernel(char *str) 936{ 937 if (str) { 938 if (!strcmp(str, "on")) 939 debugfs_allow = DEBUGFS_ALLOW_API | DEBUGFS_ALLOW_MOUNT; 940 else if (!strcmp(str, "no-mount")) 941 debugfs_allow = DEBUGFS_ALLOW_API; 942 else if (!strcmp(str, "off")) 943 debugfs_allow = 0; 944 } 945 946 return 0; 947} 948early_param("debugfs", debugfs_kernel); 949static int __init debugfs_init(void) 950{ 951 int retval; 952 953 if (!(debugfs_allow & DEBUGFS_ALLOW_MOUNT)) 954 return -EPERM; 955 956 retval = sysfs_create_mount_point(kernel_kobj, "debug"); 957 if (retval) 958 return retval; 959 960 retval = register_filesystem(&debug_fs_type); 961 if (retval) 962 sysfs_remove_mount_point(kernel_kobj, "debug"); 963 else 964 debugfs_registered = true; 965 966 return retval; 967} 968core_initcall(debugfs_init); 969