1 // SPDX-License-Identifier: GPL-2.0
3 * inode.c - part of debugfs, a tiny little debug file system
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>
9 * debugfs is for people to use instead of /proc or /sys.
10 * See ./Documentation/core-api/kernel-api.rst for more details.
13 #define pr_fmt(fmt) "debugfs: " fmt
15 #include <linux/module.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>
33 #define DEBUGFS_DEFAULT_MODE 0700
35 static struct vfsmount
*debugfs_mount
;
36 static int debugfs_mount_count
;
37 static bool debugfs_registered
;
38 static unsigned int debugfs_allow __ro_after_init
= DEFAULT_DEBUGFS_ALLOW_BITS
;
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.
45 static int debugfs_setattr(struct user_namespace
*mnt_userns
,
46 struct dentry
*dentry
, struct iattr
*ia
)
50 if (ia
->ia_valid
& (ATTR_MODE
| ATTR_UID
| ATTR_GID
)) {
51 ret
= security_locked_down(LOCKDOWN_DEBUGFS
);
55 return simple_setattr(&init_user_ns
, dentry
, ia
);
58 static const struct inode_operations debugfs_file_inode_operations
= {
59 .setattr
= debugfs_setattr
,
61 static const struct inode_operations debugfs_dir_inode_operations
= {
62 .lookup
= simple_lookup
,
63 .setattr
= debugfs_setattr
,
65 static const struct inode_operations debugfs_symlink_inode_operations
= {
66 .get_link
= simple_get_link
,
67 .setattr
= debugfs_setattr
,
70 static struct inode
*debugfs_get_inode(struct super_block
*sb
)
72 struct inode
*inode
= new_inode(sb
);
74 inode
->i_ino
= get_next_ino();
75 inode
->i_atime
= inode
->i_mtime
=
76 inode
->i_ctime
= current_time(inode
);
81 struct debugfs_mount_opts
{
94 static const match_table_t tokens
= {
97 {Opt_mode
, "mode=%o"},
101 struct debugfs_fs_info
{
102 struct debugfs_mount_opts mount_opts
;
105 static int debugfs_parse_options(char *data
, struct debugfs_mount_opts
*opts
)
107 substring_t args
[MAX_OPT_ARGS
];
114 opts
->mode
= DEBUGFS_DEFAULT_MODE
;
116 while ((p
= strsep(&data
, ",")) != NULL
) {
120 token
= match_token(p
, tokens
, args
);
123 if (match_int(&args
[0], &option
))
125 uid
= make_kuid(current_user_ns(), option
);
131 if (match_int(&args
[0], &option
))
133 gid
= make_kgid(current_user_ns(), option
);
139 if (match_octal(&args
[0], &option
))
141 opts
->mode
= option
& S_IALLUGO
;
144 * We might like to report bad mount options here;
145 * but traditionally debugfs has ignored all mount options
153 static int debugfs_apply_options(struct super_block
*sb
)
155 struct debugfs_fs_info
*fsi
= sb
->s_fs_info
;
156 struct inode
*inode
= d_inode(sb
->s_root
);
157 struct debugfs_mount_opts
*opts
= &fsi
->mount_opts
;
159 inode
->i_mode
&= ~S_IALLUGO
;
160 inode
->i_mode
|= opts
->mode
;
162 inode
->i_uid
= opts
->uid
;
163 inode
->i_gid
= opts
->gid
;
168 static int debugfs_remount(struct super_block
*sb
, int *flags
, char *data
)
171 struct debugfs_fs_info
*fsi
= sb
->s_fs_info
;
174 err
= debugfs_parse_options(data
, &fsi
->mount_opts
);
178 debugfs_apply_options(sb
);
184 static int debugfs_show_options(struct seq_file
*m
, struct dentry
*root
)
186 struct debugfs_fs_info
*fsi
= root
->d_sb
->s_fs_info
;
187 struct debugfs_mount_opts
*opts
= &fsi
->mount_opts
;
189 if (!uid_eq(opts
->uid
, GLOBAL_ROOT_UID
))
190 seq_printf(m
, ",uid=%u",
191 from_kuid_munged(&init_user_ns
, opts
->uid
));
192 if (!gid_eq(opts
->gid
, GLOBAL_ROOT_GID
))
193 seq_printf(m
, ",gid=%u",
194 from_kgid_munged(&init_user_ns
, opts
->gid
));
195 if (opts
->mode
!= DEBUGFS_DEFAULT_MODE
)
196 seq_printf(m
, ",mode=%o", opts
->mode
);
201 static void debugfs_free_inode(struct inode
*inode
)
203 if (S_ISLNK(inode
->i_mode
))
204 kfree(inode
->i_link
);
205 free_inode_nonrcu(inode
);
208 static const struct super_operations debugfs_super_operations
= {
209 .statfs
= simple_statfs
,
210 .remount_fs
= debugfs_remount
,
211 .show_options
= debugfs_show_options
,
212 .free_inode
= debugfs_free_inode
,
215 static void debugfs_release_dentry(struct dentry
*dentry
)
217 void *fsd
= dentry
->d_fsdata
;
219 if (!((unsigned long)fsd
& DEBUGFS_FSDATA_IS_REAL_FOPS_BIT
))
220 kfree(dentry
->d_fsdata
);
223 static struct vfsmount
*debugfs_automount(struct path
*path
)
225 debugfs_automount_t f
;
226 f
= (debugfs_automount_t
)path
->dentry
->d_fsdata
;
227 return f(path
->dentry
, d_inode(path
->dentry
)->i_private
);
230 static const struct dentry_operations debugfs_dops
= {
231 .d_delete
= always_delete_dentry
,
232 .d_release
= debugfs_release_dentry
,
233 .d_automount
= debugfs_automount
,
236 static int debug_fill_super(struct super_block
*sb
, void *data
, int silent
)
238 static const struct tree_descr debug_files
[] = {{""}};
239 struct debugfs_fs_info
*fsi
;
242 fsi
= kzalloc(sizeof(struct debugfs_fs_info
), GFP_KERNEL
);
249 err
= debugfs_parse_options(data
, &fsi
->mount_opts
);
253 err
= simple_fill_super(sb
, DEBUGFS_MAGIC
, debug_files
);
257 sb
->s_op
= &debugfs_super_operations
;
258 sb
->s_d_op
= &debugfs_dops
;
260 debugfs_apply_options(sb
);
266 sb
->s_fs_info
= NULL
;
270 static struct dentry
*debug_mount(struct file_system_type
*fs_type
,
271 int flags
, const char *dev_name
,
274 if (!(debugfs_allow
& DEBUGFS_ALLOW_API
))
275 return ERR_PTR(-EPERM
);
277 return mount_single(fs_type
, flags
, data
, debug_fill_super
);
280 static struct file_system_type debug_fs_type
= {
281 .owner
= THIS_MODULE
,
283 .mount
= debug_mount
,
284 .kill_sb
= kill_litter_super
,
286 MODULE_ALIAS_FS("debugfs");
289 * debugfs_lookup() - look up an existing debugfs file
290 * @name: a pointer to a string containing the name of the file to look up.
291 * @parent: a pointer to the parent dentry of the file.
293 * This function will return a pointer to a dentry if it succeeds. If the file
294 * doesn't exist or an error occurs, %NULL will be returned. The returned
295 * dentry must be passed to dput() when it is no longer needed.
297 * If debugfs is not enabled in the kernel, the value -%ENODEV will be
300 struct dentry
*debugfs_lookup(const char *name
, struct dentry
*parent
)
302 struct dentry
*dentry
;
304 if (!debugfs_initialized() || IS_ERR_OR_NULL(name
) || IS_ERR(parent
))
308 parent
= debugfs_mount
->mnt_root
;
310 dentry
= lookup_positive_unlocked(name
, parent
, strlen(name
));
315 EXPORT_SYMBOL_GPL(debugfs_lookup
);
317 static struct dentry
*start_creating(const char *name
, struct dentry
*parent
)
319 struct dentry
*dentry
;
322 if (!(debugfs_allow
& DEBUGFS_ALLOW_API
))
323 return ERR_PTR(-EPERM
);
325 if (!debugfs_initialized())
326 return ERR_PTR(-ENOENT
);
328 pr_debug("creating file '%s'\n", name
);
333 error
= simple_pin_fs(&debug_fs_type
, &debugfs_mount
,
334 &debugfs_mount_count
);
336 pr_err("Unable to pin filesystem for file '%s'\n", name
);
337 return ERR_PTR(error
);
340 /* If the parent is not specified, we create it in the root.
341 * We need the root dentry to do this, which is in the super
342 * block. A pointer to that is in the struct vfsmount that we
346 parent
= debugfs_mount
->mnt_root
;
348 inode_lock(d_inode(parent
));
349 if (unlikely(IS_DEADDIR(d_inode(parent
))))
350 dentry
= ERR_PTR(-ENOENT
);
352 dentry
= lookup_one_len(name
, parent
, strlen(name
));
353 if (!IS_ERR(dentry
) && d_really_is_positive(dentry
)) {
354 if (d_is_dir(dentry
))
355 pr_err("Directory '%s' with parent '%s' already present!\n",
356 name
, parent
->d_name
.name
);
358 pr_err("File '%s' in directory '%s' already present!\n",
359 name
, parent
->d_name
.name
);
361 dentry
= ERR_PTR(-EEXIST
);
364 if (IS_ERR(dentry
)) {
365 inode_unlock(d_inode(parent
));
366 simple_release_fs(&debugfs_mount
, &debugfs_mount_count
);
372 static struct dentry
*failed_creating(struct dentry
*dentry
)
374 inode_unlock(d_inode(dentry
->d_parent
));
376 simple_release_fs(&debugfs_mount
, &debugfs_mount_count
);
377 return ERR_PTR(-ENOMEM
);
380 static struct dentry
*end_creating(struct dentry
*dentry
)
382 inode_unlock(d_inode(dentry
->d_parent
));
386 static struct dentry
*__debugfs_create_file(const char *name
, umode_t mode
,
387 struct dentry
*parent
, void *data
,
388 const struct file_operations
*proxy_fops
,
389 const struct file_operations
*real_fops
)
391 struct dentry
*dentry
;
394 if (!(mode
& S_IFMT
))
396 BUG_ON(!S_ISREG(mode
));
397 dentry
= start_creating(name
, parent
);
402 if (!(debugfs_allow
& DEBUGFS_ALLOW_API
)) {
403 failed_creating(dentry
);
404 return ERR_PTR(-EPERM
);
407 inode
= debugfs_get_inode(dentry
->d_sb
);
408 if (unlikely(!inode
)) {
409 pr_err("out of free dentries, can not create file '%s'\n",
411 return failed_creating(dentry
);
414 inode
->i_mode
= mode
;
415 inode
->i_private
= data
;
417 inode
->i_op
= &debugfs_file_inode_operations
;
418 inode
->i_fop
= proxy_fops
;
419 dentry
->d_fsdata
= (void *)((unsigned long)real_fops
|
420 DEBUGFS_FSDATA_IS_REAL_FOPS_BIT
);
422 d_instantiate(dentry
, inode
);
423 fsnotify_create(d_inode(dentry
->d_parent
), dentry
);
424 return end_creating(dentry
);
428 * debugfs_create_file - create a file in the debugfs filesystem
429 * @name: a pointer to a string containing the name of the file to create.
430 * @mode: the permission that the file should have.
431 * @parent: a pointer to the parent dentry for this file. This should be a
432 * directory dentry if set. If this parameter is NULL, then the
433 * file will be created in the root of the debugfs filesystem.
434 * @data: a pointer to something that the caller will want to get to later
435 * on. The inode.i_private pointer will point to this value on
437 * @fops: a pointer to a struct file_operations that should be used for
440 * This is the basic "create a file" function for debugfs. It allows for a
441 * wide range of flexibility in creating a file, or a directory (if you want
442 * to create a directory, the debugfs_create_dir() function is
443 * recommended to be used instead.)
445 * This function will return a pointer to a dentry if it succeeds. This
446 * pointer must be passed to the debugfs_remove() function when the file is
447 * to be removed (no automatic cleanup happens if your module is unloaded,
448 * you are responsible here.) If an error occurs, ERR_PTR(-ERROR) will be
451 * If debugfs is not enabled in the kernel, the value -%ENODEV will be
454 * NOTE: it's expected that most callers should _ignore_ the errors returned
455 * by this function. Other debugfs functions handle the fact that the "dentry"
456 * passed to them could be an error and they don't crash in that case.
457 * Drivers should generally work fine even if debugfs fails to init anyway.
459 struct dentry
*debugfs_create_file(const char *name
, umode_t mode
,
460 struct dentry
*parent
, void *data
,
461 const struct file_operations
*fops
)
464 return __debugfs_create_file(name
, mode
, parent
, data
,
465 fops
? &debugfs_full_proxy_file_operations
:
466 &debugfs_noop_file_operations
,
469 EXPORT_SYMBOL_GPL(debugfs_create_file
);
472 * debugfs_create_file_unsafe - create a file in the debugfs filesystem
473 * @name: a pointer to a string containing the name of the file to create.
474 * @mode: the permission that the file should have.
475 * @parent: a pointer to the parent dentry for this file. This should be a
476 * directory dentry if set. If this parameter is NULL, then the
477 * file will be created in the root of the debugfs filesystem.
478 * @data: a pointer to something that the caller will want to get to later
479 * on. The inode.i_private pointer will point to this value on
481 * @fops: a pointer to a struct file_operations that should be used for
484 * debugfs_create_file_unsafe() is completely analogous to
485 * debugfs_create_file(), the only difference being that the fops
486 * handed it will not get protected against file removals by the
489 * It is your responsibility to protect your struct file_operation
490 * methods against file removals by means of debugfs_file_get()
491 * and debugfs_file_put(). ->open() is still protected by
494 * Any struct file_operations defined by means of
495 * DEFINE_DEBUGFS_ATTRIBUTE() is protected against file removals and
496 * thus, may be used here.
498 struct dentry
*debugfs_create_file_unsafe(const char *name
, umode_t mode
,
499 struct dentry
*parent
, void *data
,
500 const struct file_operations
*fops
)
503 return __debugfs_create_file(name
, mode
, parent
, data
,
504 fops
? &debugfs_open_proxy_file_operations
:
505 &debugfs_noop_file_operations
,
508 EXPORT_SYMBOL_GPL(debugfs_create_file_unsafe
);
511 * debugfs_create_file_size - create a file in the debugfs filesystem
512 * @name: a pointer to a string containing the name of the file to create.
513 * @mode: the permission that the file should have.
514 * @parent: a pointer to the parent dentry for this file. This should be a
515 * directory dentry if set. If this parameter is NULL, then the
516 * file will be created in the root of the debugfs filesystem.
517 * @data: a pointer to something that the caller will want to get to later
518 * on. The inode.i_private pointer will point to this value on
520 * @fops: a pointer to a struct file_operations that should be used for
522 * @file_size: initial file size
524 * This is the basic "create a file" function for debugfs. It allows for a
525 * wide range of flexibility in creating a file, or a directory (if you want
526 * to create a directory, the debugfs_create_dir() function is
527 * recommended to be used instead.)
529 void debugfs_create_file_size(const char *name
, umode_t mode
,
530 struct dentry
*parent
, void *data
,
531 const struct file_operations
*fops
,
534 struct dentry
*de
= debugfs_create_file(name
, mode
, parent
, data
, fops
);
537 d_inode(de
)->i_size
= file_size
;
539 EXPORT_SYMBOL_GPL(debugfs_create_file_size
);
542 * debugfs_create_dir - create a directory in the debugfs filesystem
543 * @name: a pointer to a string containing the name of the directory to
545 * @parent: a pointer to the parent dentry for this file. This should be a
546 * directory dentry if set. If this parameter is NULL, then the
547 * directory will be created in the root of the debugfs filesystem.
549 * This function creates a directory in debugfs with the given name.
551 * This function will return a pointer to a dentry if it succeeds. This
552 * pointer must be passed to the debugfs_remove() function when the file is
553 * to be removed (no automatic cleanup happens if your module is unloaded,
554 * you are responsible here.) If an error occurs, ERR_PTR(-ERROR) will be
557 * If debugfs is not enabled in the kernel, the value -%ENODEV will be
560 * NOTE: it's expected that most callers should _ignore_ the errors returned
561 * by this function. Other debugfs functions handle the fact that the "dentry"
562 * passed to them could be an error and they don't crash in that case.
563 * Drivers should generally work fine even if debugfs fails to init anyway.
565 struct dentry
*debugfs_create_dir(const char *name
, struct dentry
*parent
)
567 struct dentry
*dentry
= start_creating(name
, parent
);
573 if (!(debugfs_allow
& DEBUGFS_ALLOW_API
)) {
574 failed_creating(dentry
);
575 return ERR_PTR(-EPERM
);
578 inode
= debugfs_get_inode(dentry
->d_sb
);
579 if (unlikely(!inode
)) {
580 pr_err("out of free dentries, can not create directory '%s'\n",
582 return failed_creating(dentry
);
585 inode
->i_mode
= S_IFDIR
| S_IRWXU
| S_IRUGO
| S_IXUGO
;
586 inode
->i_op
= &debugfs_dir_inode_operations
;
587 inode
->i_fop
= &simple_dir_operations
;
589 /* directory inodes start off with i_nlink == 2 (for "." entry) */
591 d_instantiate(dentry
, inode
);
592 inc_nlink(d_inode(dentry
->d_parent
));
593 fsnotify_mkdir(d_inode(dentry
->d_parent
), dentry
);
594 return end_creating(dentry
);
596 EXPORT_SYMBOL_GPL(debugfs_create_dir
);
599 * debugfs_create_automount - create automount point in the debugfs filesystem
600 * @name: a pointer to a string containing the name of the file to create.
601 * @parent: a pointer to the parent dentry for this file. This should be a
602 * directory dentry if set. If this parameter is NULL, then the
603 * file will be created in the root of the debugfs filesystem.
604 * @f: function to be called when pathname resolution steps on that one.
605 * @data: opaque argument to pass to f().
607 * @f should return what ->d_automount() would.
609 struct dentry
*debugfs_create_automount(const char *name
,
610 struct dentry
*parent
,
611 debugfs_automount_t f
,
614 struct dentry
*dentry
= start_creating(name
, parent
);
620 if (!(debugfs_allow
& DEBUGFS_ALLOW_API
)) {
621 failed_creating(dentry
);
622 return ERR_PTR(-EPERM
);
625 inode
= debugfs_get_inode(dentry
->d_sb
);
626 if (unlikely(!inode
)) {
627 pr_err("out of free dentries, can not create automount '%s'\n",
629 return failed_creating(dentry
);
632 make_empty_dir_inode(inode
);
633 inode
->i_flags
|= S_AUTOMOUNT
;
634 inode
->i_private
= data
;
635 dentry
->d_fsdata
= (void *)f
;
636 /* directory inodes start off with i_nlink == 2 (for "." entry) */
638 d_instantiate(dentry
, inode
);
639 inc_nlink(d_inode(dentry
->d_parent
));
640 fsnotify_mkdir(d_inode(dentry
->d_parent
), dentry
);
641 return end_creating(dentry
);
643 EXPORT_SYMBOL(debugfs_create_automount
);
646 * debugfs_create_symlink- create a symbolic link in the debugfs filesystem
647 * @name: a pointer to a string containing the name of the symbolic link to
649 * @parent: a pointer to the parent dentry for this symbolic link. This
650 * should be a directory dentry if set. If this parameter is NULL,
651 * then the symbolic link will be created in the root of the debugfs
653 * @target: a pointer to a string containing the path to the target of the
656 * This function creates a symbolic link with the given name in debugfs that
657 * links to the given target path.
659 * This function will return a pointer to a dentry if it succeeds. This
660 * pointer must be passed to the debugfs_remove() function when the symbolic
661 * link is to be removed (no automatic cleanup happens if your module is
662 * unloaded, you are responsible here.) If an error occurs, ERR_PTR(-ERROR)
665 * If debugfs is not enabled in the kernel, the value -%ENODEV will be
668 struct dentry
*debugfs_create_symlink(const char *name
, struct dentry
*parent
,
671 struct dentry
*dentry
;
673 char *link
= kstrdup(target
, GFP_KERNEL
);
675 return ERR_PTR(-ENOMEM
);
677 dentry
= start_creating(name
, parent
);
678 if (IS_ERR(dentry
)) {
683 inode
= debugfs_get_inode(dentry
->d_sb
);
684 if (unlikely(!inode
)) {
685 pr_err("out of free dentries, can not create symlink '%s'\n",
688 return failed_creating(dentry
);
690 inode
->i_mode
= S_IFLNK
| S_IRWXUGO
;
691 inode
->i_op
= &debugfs_symlink_inode_operations
;
692 inode
->i_link
= link
;
693 d_instantiate(dentry
, inode
);
694 return end_creating(dentry
);
696 EXPORT_SYMBOL_GPL(debugfs_create_symlink
);
698 static void __debugfs_file_removed(struct dentry
*dentry
)
700 struct debugfs_fsdata
*fsd
;
703 * Paired with the closing smp_mb() implied by a successful
704 * cmpxchg() in debugfs_file_get(): either
705 * debugfs_file_get() must see a dead dentry or we must see a
706 * debugfs_fsdata instance at ->d_fsdata here (or both).
709 fsd
= READ_ONCE(dentry
->d_fsdata
);
710 if ((unsigned long)fsd
& DEBUGFS_FSDATA_IS_REAL_FOPS_BIT
)
712 if (!refcount_dec_and_test(&fsd
->active_users
))
713 wait_for_completion(&fsd
->active_users_drained
);
716 static void remove_one(struct dentry
*victim
)
718 if (d_is_reg(victim
))
719 __debugfs_file_removed(victim
);
720 simple_release_fs(&debugfs_mount
, &debugfs_mount_count
);
724 * debugfs_remove - recursively removes a directory
725 * @dentry: a pointer to a the dentry of the directory to be removed. If this
726 * parameter is NULL or an error value, nothing will be done.
728 * This function recursively removes a directory tree in debugfs that
729 * was previously created with a call to another debugfs function
730 * (like debugfs_create_file() or variants thereof.)
732 * This function is required to be called in order for the file to be
733 * removed, no automatic cleanup of files will happen when a module is
734 * removed, you are responsible here.
736 void debugfs_remove(struct dentry
*dentry
)
738 if (IS_ERR_OR_NULL(dentry
))
741 simple_pin_fs(&debug_fs_type
, &debugfs_mount
, &debugfs_mount_count
);
742 simple_recursive_removal(dentry
, remove_one
);
743 simple_release_fs(&debugfs_mount
, &debugfs_mount_count
);
745 EXPORT_SYMBOL_GPL(debugfs_remove
);
748 * debugfs_lookup_and_remove - lookup a directory or file and recursively remove it
749 * @name: a pointer to a string containing the name of the item to look up.
750 * @parent: a pointer to the parent dentry of the item.
752 * This is the equlivant of doing something like
753 * debugfs_remove(debugfs_lookup(..)) but with the proper reference counting
754 * handled for the directory being looked up.
756 void debugfs_lookup_and_remove(const char *name
, struct dentry
*parent
)
758 struct dentry
*dentry
;
760 dentry
= debugfs_lookup(name
, parent
);
764 debugfs_remove(dentry
);
767 EXPORT_SYMBOL_GPL(debugfs_lookup_and_remove
);
770 * debugfs_rename - rename a file/directory in the debugfs filesystem
771 * @old_dir: a pointer to the parent dentry for the renamed object. This
772 * should be a directory dentry.
773 * @old_dentry: dentry of an object to be renamed.
774 * @new_dir: a pointer to the parent dentry where the object should be
775 * moved. This should be a directory dentry.
776 * @new_name: a pointer to a string containing the target name.
778 * This function renames a file/directory in debugfs. The target must not
779 * exist for rename to succeed.
781 * This function will return a pointer to old_dentry (which is updated to
782 * reflect renaming) if it succeeds. If an error occurs, %NULL will be
785 * If debugfs is not enabled in the kernel, the value -%ENODEV will be
788 struct dentry
*debugfs_rename(struct dentry
*old_dir
, struct dentry
*old_dentry
,
789 struct dentry
*new_dir
, const char *new_name
)
792 struct dentry
*dentry
= NULL
, *trap
;
793 struct name_snapshot old_name
;
799 if (IS_ERR_OR_NULL(old_dentry
))
802 trap
= lock_rename(new_dir
, old_dir
);
803 /* Source or destination directories don't exist? */
804 if (d_really_is_negative(old_dir
) || d_really_is_negative(new_dir
))
806 /* Source does not exist, cyclic rename, or mountpoint? */
807 if (d_really_is_negative(old_dentry
) || old_dentry
== trap
||
808 d_mountpoint(old_dentry
))
810 dentry
= lookup_one_len(new_name
, new_dir
, strlen(new_name
));
811 /* Lookup failed, cyclic rename or target exists? */
812 if (IS_ERR(dentry
) || dentry
== trap
|| d_really_is_positive(dentry
))
815 take_dentry_name_snapshot(&old_name
, old_dentry
);
817 error
= simple_rename(&init_user_ns
, d_inode(old_dir
), old_dentry
,
818 d_inode(new_dir
), dentry
, 0);
820 release_dentry_name_snapshot(&old_name
);
823 d_move(old_dentry
, dentry
);
824 fsnotify_move(d_inode(old_dir
), d_inode(new_dir
), &old_name
.name
,
825 d_is_dir(old_dentry
),
827 release_dentry_name_snapshot(&old_name
);
828 unlock_rename(new_dir
, old_dir
);
832 if (dentry
&& !IS_ERR(dentry
))
834 unlock_rename(new_dir
, old_dir
);
837 return ERR_PTR(-EINVAL
);
839 EXPORT_SYMBOL_GPL(debugfs_rename
);
842 * debugfs_initialized - Tells whether debugfs has been registered
844 bool debugfs_initialized(void)
846 return debugfs_registered
;
848 EXPORT_SYMBOL_GPL(debugfs_initialized
);
850 static int __init
debugfs_kernel(char *str
)
853 if (!strcmp(str
, "on"))
854 debugfs_allow
= DEBUGFS_ALLOW_API
| DEBUGFS_ALLOW_MOUNT
;
855 else if (!strcmp(str
, "no-mount"))
856 debugfs_allow
= DEBUGFS_ALLOW_API
;
857 else if (!strcmp(str
, "off"))
863 early_param("debugfs", debugfs_kernel
);
864 static int __init
debugfs_init(void)
868 if (!(debugfs_allow
& DEBUGFS_ALLOW_MOUNT
))
871 retval
= sysfs_create_mount_point(kernel_kobj
, "debug");
875 retval
= register_filesystem(&debug_fs_type
);
877 sysfs_remove_mount_point(kernel_kobj
, "debug");
879 debugfs_registered
= true;
883 core_initcall(debugfs_init
);