1 /* 2 * inode.c - part of debugfs, a tiny little debug file system 3 * 4 * Copyright (C) 2004 Greg Kroah-Hartman <greg@kroah.com> 5 * Copyright (C) 2004 IBM Inc. 6 * 7 * This program is free software; you can redistribute it and/or 8 * modify it under the terms of the GNU General Public License version 9 * 2 as published by the Free Software Foundation. 10 * 11 * debugfs is for people to use instead of /proc or /sys. 12 * See ./Documentation/core-api/kernel-api.rst for more details. 13 * 14 */ 15 16 #include <linux/module.h> 17 #include <linux/fs.h> 18 #include <linux/mount.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/parser.h> 28 #include <linux/magic.h> 29 #include <linux/slab.h> 30 #include <linux/srcu.h> 31 32 #include "internal.h" 33 34 #define DEBUGFS_DEFAULT_MODE 0700 35 36 DEFINE_SRCU(debugfs_srcu); 37 38 static struct vfsmount *debugfs_mount; 39 static int debugfs_mount_count; 40 static bool debugfs_registered; 41 42 static struct inode *debugfs_get_inode(struct super_block *sb) 43 { 44 struct inode *inode = new_inode(sb); 45 if (inode) { 46 inode->i_ino = get_next_ino(); 47 inode->i_atime = inode->i_mtime = 48 inode->i_ctime = current_time(inode); 49 } 50 return inode; 51 } 52 53 struct debugfs_mount_opts { 54 kuid_t uid; 55 kgid_t gid; 56 umode_t mode; 57 }; 58 59 enum { 60 Opt_uid, 61 Opt_gid, 62 Opt_mode, 63 Opt_err 64 }; 65 66 static const match_table_t tokens = { 67 {Opt_uid, "uid=%u"}, 68 {Opt_gid, "gid=%u"}, 69 {Opt_mode, "mode=%o"}, 70 {Opt_err, NULL} 71 }; 72 73 struct debugfs_fs_info { 74 struct debugfs_mount_opts mount_opts; 75 }; 76 77 static int debugfs_parse_options(char *data, struct debugfs_mount_opts *opts) 78 { 79 substring_t args[MAX_OPT_ARGS]; 80 int option; 81 int token; 82 kuid_t uid; 83 kgid_t gid; 84 char *p; 85 86 opts->mode = DEBUGFS_DEFAULT_MODE; 87 88 while ((p = strsep(&data, ",")) != NULL) { 89 if (!*p) 90 continue; 91 92 token = match_token(p, tokens, args); 93 switch (token) { 94 case Opt_uid: 95 if (match_int(&args[0], &option)) 96 return -EINVAL; 97 uid = make_kuid(current_user_ns(), option); 98 if (!uid_valid(uid)) 99 return -EINVAL; 100 opts->uid = uid; 101 break; 102 case Opt_gid: 103 if (match_int(&args[0], &option)) 104 return -EINVAL; 105 gid = make_kgid(current_user_ns(), option); 106 if (!gid_valid(gid)) 107 return -EINVAL; 108 opts->gid = gid; 109 break; 110 case Opt_mode: 111 if (match_octal(&args[0], &option)) 112 return -EINVAL; 113 opts->mode = option & S_IALLUGO; 114 break; 115 /* 116 * We might like to report bad mount options here; 117 * but traditionally debugfs has ignored all mount options 118 */ 119 } 120 } 121 122 return 0; 123 } 124 125 static int debugfs_apply_options(struct super_block *sb) 126 { 127 struct debugfs_fs_info *fsi = sb->s_fs_info; 128 struct inode *inode = d_inode(sb->s_root); 129 struct debugfs_mount_opts *opts = &fsi->mount_opts; 130 131 inode->i_mode &= ~S_IALLUGO; 132 inode->i_mode |= opts->mode; 133 134 inode->i_uid = opts->uid; 135 inode->i_gid = opts->gid; 136 137 return 0; 138 } 139 140 static int debugfs_remount(struct super_block *sb, int *flags, char *data) 141 { 142 int err; 143 struct debugfs_fs_info *fsi = sb->s_fs_info; 144 145 sync_filesystem(sb); 146 err = debugfs_parse_options(data, &fsi->mount_opts); 147 if (err) 148 goto fail; 149 150 debugfs_apply_options(sb); 151 152 fail: 153 return err; 154 } 155 156 static int debugfs_show_options(struct seq_file *m, struct dentry *root) 157 { 158 struct debugfs_fs_info *fsi = root->d_sb->s_fs_info; 159 struct debugfs_mount_opts *opts = &fsi->mount_opts; 160 161 if (!uid_eq(opts->uid, GLOBAL_ROOT_UID)) 162 seq_printf(m, ",uid=%u", 163 from_kuid_munged(&init_user_ns, opts->uid)); 164 if (!gid_eq(opts->gid, GLOBAL_ROOT_GID)) 165 seq_printf(m, ",gid=%u", 166 from_kgid_munged(&init_user_ns, opts->gid)); 167 if (opts->mode != DEBUGFS_DEFAULT_MODE) 168 seq_printf(m, ",mode=%o", opts->mode); 169 170 return 0; 171 } 172 173 static void debugfs_evict_inode(struct inode *inode) 174 { 175 truncate_inode_pages_final(&inode->i_data); 176 clear_inode(inode); 177 if (S_ISLNK(inode->i_mode)) 178 kfree(inode->i_link); 179 } 180 181 static const struct super_operations debugfs_super_operations = { 182 .statfs = simple_statfs, 183 .remount_fs = debugfs_remount, 184 .show_options = debugfs_show_options, 185 .evict_inode = debugfs_evict_inode, 186 }; 187 188 static struct vfsmount *debugfs_automount(struct path *path) 189 { 190 debugfs_automount_t f; 191 f = (debugfs_automount_t)path->dentry->d_fsdata; 192 return f(path->dentry, d_inode(path->dentry)->i_private); 193 } 194 195 static const struct dentry_operations debugfs_dops = { 196 .d_delete = always_delete_dentry, 197 .d_automount = debugfs_automount, 198 }; 199 200 static int debug_fill_super(struct super_block *sb, void *data, int silent) 201 { 202 static const struct tree_descr debug_files[] = {{""}}; 203 struct debugfs_fs_info *fsi; 204 int err; 205 206 fsi = kzalloc(sizeof(struct debugfs_fs_info), GFP_KERNEL); 207 sb->s_fs_info = fsi; 208 if (!fsi) { 209 err = -ENOMEM; 210 goto fail; 211 } 212 213 err = debugfs_parse_options(data, &fsi->mount_opts); 214 if (err) 215 goto fail; 216 217 err = simple_fill_super(sb, DEBUGFS_MAGIC, debug_files); 218 if (err) 219 goto fail; 220 221 sb->s_op = &debugfs_super_operations; 222 sb->s_d_op = &debugfs_dops; 223 224 debugfs_apply_options(sb); 225 226 return 0; 227 228 fail: 229 kfree(fsi); 230 sb->s_fs_info = NULL; 231 return err; 232 } 233 234 static struct dentry *debug_mount(struct file_system_type *fs_type, 235 int flags, const char *dev_name, 236 void *data) 237 { 238 return mount_single(fs_type, flags, data, debug_fill_super); 239 } 240 241 static struct file_system_type debug_fs_type = { 242 .owner = THIS_MODULE, 243 .name = "debugfs", 244 .mount = debug_mount, 245 .kill_sb = kill_litter_super, 246 }; 247 MODULE_ALIAS_FS("debugfs"); 248 249 /** 250 * debugfs_lookup() - look up an existing debugfs file 251 * @name: a pointer to a string containing the name of the file to look up. 252 * @parent: a pointer to the parent dentry of the file. 253 * 254 * This function will return a pointer to a dentry if it succeeds. If the file 255 * doesn't exist or an error occurs, %NULL will be returned. The returned 256 * dentry must be passed to dput() when it is no longer needed. 257 * 258 * If debugfs is not enabled in the kernel, the value -%ENODEV will be 259 * returned. 260 */ 261 struct dentry *debugfs_lookup(const char *name, struct dentry *parent) 262 { 263 struct dentry *dentry; 264 265 if (IS_ERR(parent)) 266 return NULL; 267 268 if (!parent) 269 parent = debugfs_mount->mnt_root; 270 271 inode_lock(d_inode(parent)); 272 dentry = lookup_one_len(name, parent, strlen(name)); 273 inode_unlock(d_inode(parent)); 274 275 if (IS_ERR(dentry)) 276 return NULL; 277 if (!d_really_is_positive(dentry)) { 278 dput(dentry); 279 return NULL; 280 } 281 return dentry; 282 } 283 EXPORT_SYMBOL_GPL(debugfs_lookup); 284 285 static struct dentry *start_creating(const char *name, struct dentry *parent) 286 { 287 struct dentry *dentry; 288 int error; 289 290 pr_debug("debugfs: creating file '%s'\n",name); 291 292 if (IS_ERR(parent)) 293 return parent; 294 295 error = simple_pin_fs(&debug_fs_type, &debugfs_mount, 296 &debugfs_mount_count); 297 if (error) 298 return ERR_PTR(error); 299 300 /* If the parent is not specified, we create it in the root. 301 * We need the root dentry to do this, which is in the super 302 * block. A pointer to that is in the struct vfsmount that we 303 * have around. 304 */ 305 if (!parent) 306 parent = debugfs_mount->mnt_root; 307 308 inode_lock(d_inode(parent)); 309 dentry = lookup_one_len(name, parent, strlen(name)); 310 if (!IS_ERR(dentry) && d_really_is_positive(dentry)) { 311 dput(dentry); 312 dentry = ERR_PTR(-EEXIST); 313 } 314 315 if (IS_ERR(dentry)) { 316 inode_unlock(d_inode(parent)); 317 simple_release_fs(&debugfs_mount, &debugfs_mount_count); 318 } 319 320 return dentry; 321 } 322 323 static struct dentry *failed_creating(struct dentry *dentry) 324 { 325 inode_unlock(d_inode(dentry->d_parent)); 326 dput(dentry); 327 simple_release_fs(&debugfs_mount, &debugfs_mount_count); 328 return NULL; 329 } 330 331 static struct dentry *end_creating(struct dentry *dentry) 332 { 333 inode_unlock(d_inode(dentry->d_parent)); 334 return dentry; 335 } 336 337 static struct dentry *__debugfs_create_file(const char *name, umode_t mode, 338 struct dentry *parent, void *data, 339 const struct file_operations *proxy_fops, 340 const struct file_operations *real_fops) 341 { 342 struct dentry *dentry; 343 struct inode *inode; 344 345 if (!(mode & S_IFMT)) 346 mode |= S_IFREG; 347 BUG_ON(!S_ISREG(mode)); 348 dentry = start_creating(name, parent); 349 350 if (IS_ERR(dentry)) 351 return NULL; 352 353 inode = debugfs_get_inode(dentry->d_sb); 354 if (unlikely(!inode)) 355 return failed_creating(dentry); 356 357 inode->i_mode = mode; 358 inode->i_private = data; 359 360 inode->i_fop = proxy_fops; 361 dentry->d_fsdata = (void *)real_fops; 362 363 d_instantiate(dentry, inode); 364 fsnotify_create(d_inode(dentry->d_parent), dentry); 365 return end_creating(dentry); 366 } 367 368 /** 369 * debugfs_create_file - create a file in the debugfs filesystem 370 * @name: a pointer to a string containing the name of the file to create. 371 * @mode: the permission that the file should have. 372 * @parent: a pointer to the parent dentry for this file. This should be a 373 * directory dentry if set. If this parameter is NULL, then the 374 * file will be created in the root of the debugfs filesystem. 375 * @data: a pointer to something that the caller will want to get to later 376 * on. The inode.i_private pointer will point to this value on 377 * the open() call. 378 * @fops: a pointer to a struct file_operations that should be used for 379 * this file. 380 * 381 * This is the basic "create a file" function for debugfs. It allows for a 382 * wide range of flexibility in creating a file, or a directory (if you want 383 * to create a directory, the debugfs_create_dir() function is 384 * recommended to be used instead.) 385 * 386 * This function will return a pointer to a dentry if it succeeds. This 387 * pointer must be passed to the debugfs_remove() function when the file is 388 * to be removed (no automatic cleanup happens if your module is unloaded, 389 * you are responsible here.) If an error occurs, %NULL will be returned. 390 * 391 * If debugfs is not enabled in the kernel, the value -%ENODEV will be 392 * returned. 393 */ 394 struct dentry *debugfs_create_file(const char *name, umode_t mode, 395 struct dentry *parent, void *data, 396 const struct file_operations *fops) 397 { 398 399 return __debugfs_create_file(name, mode, parent, data, 400 fops ? &debugfs_full_proxy_file_operations : 401 &debugfs_noop_file_operations, 402 fops); 403 } 404 EXPORT_SYMBOL_GPL(debugfs_create_file); 405 406 /** 407 * debugfs_create_file_unsafe - create a file in the debugfs filesystem 408 * @name: a pointer to a string containing the name of the file to create. 409 * @mode: the permission that the file should have. 410 * @parent: a pointer to the parent dentry for this file. This should be a 411 * directory dentry if set. If this parameter is NULL, then the 412 * file will be created in the root of the debugfs filesystem. 413 * @data: a pointer to something that the caller will want to get to later 414 * on. The inode.i_private pointer will point to this value on 415 * the open() call. 416 * @fops: a pointer to a struct file_operations that should be used for 417 * this file. 418 * 419 * debugfs_create_file_unsafe() is completely analogous to 420 * debugfs_create_file(), the only difference being that the fops 421 * handed it will not get protected against file removals by the 422 * debugfs core. 423 * 424 * It is your responsibility to protect your struct file_operation 425 * methods against file removals by means of debugfs_use_file_start() 426 * and debugfs_use_file_finish(). ->open() is still protected by 427 * debugfs though. 428 * 429 * Any struct file_operations defined by means of 430 * DEFINE_DEBUGFS_ATTRIBUTE() is protected against file removals and 431 * thus, may be used here. 432 */ 433 struct dentry *debugfs_create_file_unsafe(const char *name, umode_t mode, 434 struct dentry *parent, void *data, 435 const struct file_operations *fops) 436 { 437 438 return __debugfs_create_file(name, mode, parent, data, 439 fops ? &debugfs_open_proxy_file_operations : 440 &debugfs_noop_file_operations, 441 fops); 442 } 443 EXPORT_SYMBOL_GPL(debugfs_create_file_unsafe); 444 445 /** 446 * debugfs_create_file_size - create a file in the debugfs filesystem 447 * @name: a pointer to a string containing the name of the file to create. 448 * @mode: the permission that the file should have. 449 * @parent: a pointer to the parent dentry for this file. This should be a 450 * directory dentry if set. If this parameter is NULL, then the 451 * file will be created in the root of the debugfs filesystem. 452 * @data: a pointer to something that the caller will want to get to later 453 * on. The inode.i_private pointer will point to this value on 454 * the open() call. 455 * @fops: a pointer to a struct file_operations that should be used for 456 * this file. 457 * @file_size: initial file size 458 * 459 * This is the basic "create a file" function for debugfs. It allows for a 460 * wide range of flexibility in creating a file, or a directory (if you want 461 * to create a directory, the debugfs_create_dir() function is 462 * recommended to be used instead.) 463 * 464 * This function will return a pointer to a dentry if it succeeds. This 465 * pointer must be passed to the debugfs_remove() function when the file is 466 * to be removed (no automatic cleanup happens if your module is unloaded, 467 * you are responsible here.) If an error occurs, %NULL will be returned. 468 * 469 * If debugfs is not enabled in the kernel, the value -%ENODEV will be 470 * returned. 471 */ 472 struct dentry *debugfs_create_file_size(const char *name, umode_t mode, 473 struct dentry *parent, void *data, 474 const struct file_operations *fops, 475 loff_t file_size) 476 { 477 struct dentry *de = debugfs_create_file(name, mode, parent, data, fops); 478 479 if (de) 480 d_inode(de)->i_size = file_size; 481 return de; 482 } 483 EXPORT_SYMBOL_GPL(debugfs_create_file_size); 484 485 /** 486 * debugfs_create_dir - create a directory in the debugfs filesystem 487 * @name: a pointer to a string containing the name of the directory to 488 * create. 489 * @parent: a pointer to the parent dentry for this file. This should be a 490 * directory dentry if set. If this parameter is NULL, then the 491 * directory will be created in the root of the debugfs filesystem. 492 * 493 * This function creates a directory in debugfs with the given name. 494 * 495 * This function will return a pointer to a dentry if it succeeds. This 496 * pointer must be passed to the debugfs_remove() function when the file is 497 * to be removed (no automatic cleanup happens if your module is unloaded, 498 * you are responsible here.) If an error occurs, %NULL will be returned. 499 * 500 * If debugfs is not enabled in the kernel, the value -%ENODEV will be 501 * returned. 502 */ 503 struct dentry *debugfs_create_dir(const char *name, struct dentry *parent) 504 { 505 struct dentry *dentry = start_creating(name, parent); 506 struct inode *inode; 507 508 if (IS_ERR(dentry)) 509 return NULL; 510 511 inode = debugfs_get_inode(dentry->d_sb); 512 if (unlikely(!inode)) 513 return failed_creating(dentry); 514 515 inode->i_mode = S_IFDIR | S_IRWXU | S_IRUGO | S_IXUGO; 516 inode->i_op = &simple_dir_inode_operations; 517 inode->i_fop = &simple_dir_operations; 518 519 /* directory inodes start off with i_nlink == 2 (for "." entry) */ 520 inc_nlink(inode); 521 d_instantiate(dentry, inode); 522 inc_nlink(d_inode(dentry->d_parent)); 523 fsnotify_mkdir(d_inode(dentry->d_parent), dentry); 524 return end_creating(dentry); 525 } 526 EXPORT_SYMBOL_GPL(debugfs_create_dir); 527 528 /** 529 * debugfs_create_automount - create automount point in the debugfs filesystem 530 * @name: a pointer to a string containing the name of the file to create. 531 * @parent: a pointer to the parent dentry for this file. This should be a 532 * directory dentry if set. If this parameter is NULL, then the 533 * file will be created in the root of the debugfs filesystem. 534 * @f: function to be called when pathname resolution steps on that one. 535 * @data: opaque argument to pass to f(). 536 * 537 * @f should return what ->d_automount() would. 538 */ 539 struct dentry *debugfs_create_automount(const char *name, 540 struct dentry *parent, 541 debugfs_automount_t f, 542 void *data) 543 { 544 struct dentry *dentry = start_creating(name, parent); 545 struct inode *inode; 546 547 if (IS_ERR(dentry)) 548 return NULL; 549 550 inode = debugfs_get_inode(dentry->d_sb); 551 if (unlikely(!inode)) 552 return failed_creating(dentry); 553 554 make_empty_dir_inode(inode); 555 inode->i_flags |= S_AUTOMOUNT; 556 inode->i_private = data; 557 dentry->d_fsdata = (void *)f; 558 /* directory inodes start off with i_nlink == 2 (for "." entry) */ 559 inc_nlink(inode); 560 d_instantiate(dentry, inode); 561 inc_nlink(d_inode(dentry->d_parent)); 562 fsnotify_mkdir(d_inode(dentry->d_parent), dentry); 563 return end_creating(dentry); 564 } 565 EXPORT_SYMBOL(debugfs_create_automount); 566 567 /** 568 * debugfs_create_symlink- create a symbolic link in the debugfs filesystem 569 * @name: a pointer to a string containing the name of the symbolic link to 570 * create. 571 * @parent: a pointer to the parent dentry for this symbolic link. This 572 * should be a directory dentry if set. If this parameter is NULL, 573 * then the symbolic link will be created in the root of the debugfs 574 * filesystem. 575 * @target: a pointer to a string containing the path to the target of the 576 * symbolic link. 577 * 578 * This function creates a symbolic link with the given name in debugfs that 579 * links to the given target path. 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 symbolic 583 * link is to be removed (no automatic cleanup happens if your module is 584 * unloaded, you are responsible here.) If an error occurs, %NULL will be 585 * returned. 586 * 587 * If debugfs is not enabled in the kernel, the value -%ENODEV will be 588 * returned. 589 */ 590 struct dentry *debugfs_create_symlink(const char *name, struct dentry *parent, 591 const char *target) 592 { 593 struct dentry *dentry; 594 struct inode *inode; 595 char *link = kstrdup(target, GFP_KERNEL); 596 if (!link) 597 return NULL; 598 599 dentry = start_creating(name, parent); 600 if (IS_ERR(dentry)) { 601 kfree(link); 602 return NULL; 603 } 604 605 inode = debugfs_get_inode(dentry->d_sb); 606 if (unlikely(!inode)) { 607 kfree(link); 608 return failed_creating(dentry); 609 } 610 inode->i_mode = S_IFLNK | S_IRWXUGO; 611 inode->i_op = &simple_symlink_inode_operations; 612 inode->i_link = link; 613 d_instantiate(dentry, inode); 614 return end_creating(dentry); 615 } 616 EXPORT_SYMBOL_GPL(debugfs_create_symlink); 617 618 static int __debugfs_remove(struct dentry *dentry, struct dentry *parent) 619 { 620 int ret = 0; 621 622 if (simple_positive(dentry)) { 623 dget(dentry); 624 if (d_is_dir(dentry)) 625 ret = simple_rmdir(d_inode(parent), dentry); 626 else 627 simple_unlink(d_inode(parent), dentry); 628 if (!ret) 629 d_delete(dentry); 630 dput(dentry); 631 } 632 return ret; 633 } 634 635 /** 636 * debugfs_remove - removes a file or directory from the debugfs filesystem 637 * @dentry: a pointer to a the dentry of the file or directory to be 638 * removed. If this parameter is NULL or an error value, nothing 639 * will be done. 640 * 641 * This function removes a file or directory in debugfs that was previously 642 * created with a call to another debugfs function (like 643 * debugfs_create_file() or variants thereof.) 644 * 645 * This function is required to be called in order for the file to be 646 * removed, no automatic cleanup of files will happen when a module is 647 * removed, you are responsible here. 648 */ 649 void debugfs_remove(struct dentry *dentry) 650 { 651 struct dentry *parent; 652 int ret; 653 654 if (IS_ERR_OR_NULL(dentry)) 655 return; 656 657 parent = dentry->d_parent; 658 inode_lock(d_inode(parent)); 659 ret = __debugfs_remove(dentry, parent); 660 inode_unlock(d_inode(parent)); 661 if (!ret) 662 simple_release_fs(&debugfs_mount, &debugfs_mount_count); 663 664 synchronize_srcu(&debugfs_srcu); 665 } 666 EXPORT_SYMBOL_GPL(debugfs_remove); 667 668 /** 669 * debugfs_remove_recursive - recursively removes a directory 670 * @dentry: a pointer to a the dentry of the directory to be removed. If this 671 * parameter is NULL or an error value, nothing will be done. 672 * 673 * This function recursively removes a directory tree in debugfs that 674 * was previously created with a call to another debugfs function 675 * (like debugfs_create_file() or variants thereof.) 676 * 677 * This function is required to be called in order for the file to be 678 * removed, no automatic cleanup of files will happen when a module is 679 * removed, you are responsible here. 680 */ 681 void debugfs_remove_recursive(struct dentry *dentry) 682 { 683 struct dentry *child, *parent; 684 685 if (IS_ERR_OR_NULL(dentry)) 686 return; 687 688 parent = dentry; 689 down: 690 inode_lock(d_inode(parent)); 691 loop: 692 /* 693 * The parent->d_subdirs is protected by the d_lock. Outside that 694 * lock, the child can be unlinked and set to be freed which can 695 * use the d_u.d_child as the rcu head and corrupt this list. 696 */ 697 spin_lock(&parent->d_lock); 698 list_for_each_entry(child, &parent->d_subdirs, d_child) { 699 if (!simple_positive(child)) 700 continue; 701 702 /* perhaps simple_empty(child) makes more sense */ 703 if (!list_empty(&child->d_subdirs)) { 704 spin_unlock(&parent->d_lock); 705 inode_unlock(d_inode(parent)); 706 parent = child; 707 goto down; 708 } 709 710 spin_unlock(&parent->d_lock); 711 712 if (!__debugfs_remove(child, parent)) 713 simple_release_fs(&debugfs_mount, &debugfs_mount_count); 714 715 /* 716 * The parent->d_lock protects agaist child from unlinking 717 * from d_subdirs. When releasing the parent->d_lock we can 718 * no longer trust that the next pointer is valid. 719 * Restart the loop. We'll skip this one with the 720 * simple_positive() check. 721 */ 722 goto loop; 723 } 724 spin_unlock(&parent->d_lock); 725 726 inode_unlock(d_inode(parent)); 727 child = parent; 728 parent = parent->d_parent; 729 inode_lock(d_inode(parent)); 730 731 if (child != dentry) 732 /* go up */ 733 goto loop; 734 735 if (!__debugfs_remove(child, parent)) 736 simple_release_fs(&debugfs_mount, &debugfs_mount_count); 737 inode_unlock(d_inode(parent)); 738 739 synchronize_srcu(&debugfs_srcu); 740 } 741 EXPORT_SYMBOL_GPL(debugfs_remove_recursive); 742 743 /** 744 * debugfs_rename - rename a file/directory in the debugfs filesystem 745 * @old_dir: a pointer to the parent dentry for the renamed object. This 746 * should be a directory dentry. 747 * @old_dentry: dentry of an object to be renamed. 748 * @new_dir: a pointer to the parent dentry where the object should be 749 * moved. This should be a directory dentry. 750 * @new_name: a pointer to a string containing the target name. 751 * 752 * This function renames a file/directory in debugfs. The target must not 753 * exist for rename to succeed. 754 * 755 * This function will return a pointer to old_dentry (which is updated to 756 * reflect renaming) if it succeeds. If an error occurs, %NULL will be 757 * returned. 758 * 759 * If debugfs is not enabled in the kernel, the value -%ENODEV will be 760 * returned. 761 */ 762 struct dentry *debugfs_rename(struct dentry *old_dir, struct dentry *old_dentry, 763 struct dentry *new_dir, const char *new_name) 764 { 765 int error; 766 struct dentry *dentry = NULL, *trap; 767 struct name_snapshot old_name; 768 769 trap = lock_rename(new_dir, old_dir); 770 /* Source or destination directories don't exist? */ 771 if (d_really_is_negative(old_dir) || d_really_is_negative(new_dir)) 772 goto exit; 773 /* Source does not exist, cyclic rename, or mountpoint? */ 774 if (d_really_is_negative(old_dentry) || old_dentry == trap || 775 d_mountpoint(old_dentry)) 776 goto exit; 777 dentry = lookup_one_len(new_name, new_dir, strlen(new_name)); 778 /* Lookup failed, cyclic rename or target exists? */ 779 if (IS_ERR(dentry) || dentry == trap || d_really_is_positive(dentry)) 780 goto exit; 781 782 take_dentry_name_snapshot(&old_name, old_dentry); 783 784 error = simple_rename(d_inode(old_dir), old_dentry, d_inode(new_dir), 785 dentry, 0); 786 if (error) { 787 release_dentry_name_snapshot(&old_name); 788 goto exit; 789 } 790 d_move(old_dentry, dentry); 791 fsnotify_move(d_inode(old_dir), d_inode(new_dir), old_name.name, 792 d_is_dir(old_dentry), 793 NULL, old_dentry); 794 release_dentry_name_snapshot(&old_name); 795 unlock_rename(new_dir, old_dir); 796 dput(dentry); 797 return old_dentry; 798 exit: 799 if (dentry && !IS_ERR(dentry)) 800 dput(dentry); 801 unlock_rename(new_dir, old_dir); 802 return NULL; 803 } 804 EXPORT_SYMBOL_GPL(debugfs_rename); 805 806 /** 807 * debugfs_initialized - Tells whether debugfs has been registered 808 */ 809 bool debugfs_initialized(void) 810 { 811 return debugfs_registered; 812 } 813 EXPORT_SYMBOL_GPL(debugfs_initialized); 814 815 static int __init debugfs_init(void) 816 { 817 int retval; 818 819 retval = sysfs_create_mount_point(kernel_kobj, "debug"); 820 if (retval) 821 return retval; 822 823 retval = register_filesystem(&debug_fs_type); 824 if (retval) 825 sysfs_remove_mount_point(kernel_kobj, "debug"); 826 else 827 debugfs_registered = true; 828 829 return retval; 830 } 831 core_initcall(debugfs_init); 832 833