blob: 3f81f73c241a42fca6e0ee8c5d9a393e97673b7e [file] [log] [blame]
Greg Kroah-Hartman3bce94fd2017-11-07 16:59:23 +01001// SPDX-License-Identifier: GPL-2.0
Linus Torvalds1da177e2005-04-16 15:20:36 -07002/*
Harry Weibd33d122011-07-16 16:45:13 +08003 * inode.c - part of debugfs, a tiny little debug file system
Linus Torvalds1da177e2005-04-16 15:20:36 -07004 *
Greg Kroah-Hartman43e23b62019-07-03 09:16:53 +02005 * Copyright (C) 2004,2019 Greg Kroah-Hartman <greg@kroah.com>
Linus Torvalds1da177e2005-04-16 15:20:36 -07006 * Copyright (C) 2004 IBM Inc.
Greg Kroah-Hartman43e23b62019-07-03 09:16:53 +02007 * Copyright (C) 2019 Linux Foundation <gregkh@linuxfoundation.org>
Linus Torvalds1da177e2005-04-16 15:20:36 -07008 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07009 * debugfs is for people to use instead of /proc or /sys.
Mauro Carvalho Chehabe1511a82017-05-14 12:09:53 -030010 * See ./Documentation/core-api/kernel-api.rst for more details.
Linus Torvalds1da177e2005-04-16 15:20:36 -070011 */
12
Greg Kroah-Hartmand03ae472019-07-03 09:16:52 +020013#define pr_fmt(fmt) "debugfs: " fmt
14
Linus Torvalds1da177e2005-04-16 15:20:36 -070015#include <linux/module.h>
16#include <linux/fs.h>
17#include <linux/mount.h>
18#include <linux/pagemap.h>
19#include <linux/init.h>
Randy Dunlap4d8ebdd2006-11-25 11:09:26 -080020#include <linux/kobject.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070021#include <linux/namei.h>
22#include <linux/debugfs.h>
Mathieu Desnoyers4f365572006-11-24 13:45:37 -050023#include <linux/fsnotify.h>
Peter Oberparleiter66f54962007-02-13 12:13:54 +010024#include <linux/string.h>
Ludwig Nusseld6e48682012-01-25 11:52:28 +010025#include <linux/seq_file.h>
26#include <linux/parser.h>
Mimi Zohar92562922008-10-07 14:00:12 -040027#include <linux/magic.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090028#include <linux/slab.h>
David Howells54961972019-08-19 17:18:02 -070029#include <linux/security.h>
Nicolai Stange9fd4dce2016-03-22 14:11:13 +010030
31#include "internal.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070032
Kees Cook82aceae42012-08-27 13:32:15 -070033#define DEBUGFS_DEFAULT_MODE 0700
Ludwig Nusseld6e48682012-01-25 11:52:28 +010034
Linus Torvalds1da177e2005-04-16 15:20:36 -070035static struct vfsmount *debugfs_mount;
36static int debugfs_mount_count;
Frederic Weisbeckerc0f92ba2009-03-22 23:10:44 +010037static bool debugfs_registered;
Kees Cook312723a2021-04-05 14:39:59 -070038static unsigned int debugfs_allow __ro_after_init = DEFAULT_DEBUGFS_ALLOW_BITS;
Linus Torvalds1da177e2005-04-16 15:20:36 -070039
David Howells54961972019-08-19 17:18:02 -070040/*
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 */
Christian Braunerc1632a02023-01-13 12:49:11 +010045static int debugfs_setattr(struct mnt_idmap *idmap,
Christian Brauner549c7292021-01-21 14:19:43 +010046 struct dentry *dentry, struct iattr *ia)
David Howells54961972019-08-19 17:18:02 -070047{
Ondrej Mosnacek5881fa82021-05-07 14:53:04 +020048 int ret;
David Howells54961972019-08-19 17:18:02 -070049
Ondrej Mosnacek5881fa82021-05-07 14:53:04 +020050 if (ia->ia_valid & (ATTR_MODE | ATTR_UID | ATTR_GID)) {
51 ret = security_locked_down(LOCKDOWN_DEBUGFS);
52 if (ret)
53 return ret;
54 }
Christian Braunerc1632a02023-01-13 12:49:11 +010055 return simple_setattr(&nop_mnt_idmap, dentry, ia);
David Howells54961972019-08-19 17:18:02 -070056}
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
Al Viroedac65ea2015-01-25 14:36:18 -050070static struct inode *debugfs_get_inode(struct super_block *sb)
Linus Torvalds1da177e2005-04-16 15:20:36 -070071{
72 struct inode *inode = new_inode(sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -070073 if (inode) {
Christoph Hellwig85fe4022010-10-23 11:19:54 -040074 inode->i_ino = get_next_ino();
Deepa Dinamani1b48b532016-02-22 07:17:47 -080075 inode->i_atime = inode->i_mtime =
Deepa Dinamanic2050a42016-09-14 07:48:06 -070076 inode->i_ctime = current_time(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -070077 }
Rahul Bedarkar88e412e2014-06-06 23:12:04 +053078 return inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -070079}
80
Ludwig Nusseld6e48682012-01-25 11:52:28 +010081struct debugfs_mount_opts {
Eric W. Biederman7dc05882012-04-03 14:01:31 -070082 kuid_t uid;
83 kgid_t gid;
Ludwig Nusseld6e48682012-01-25 11:52:28 +010084 umode_t mode;
Brian Norrisb8de524c2022-09-12 16:31:42 -070085 /* Opt_* bitfield. */
86 unsigned int opts;
Ludwig Nusseld6e48682012-01-25 11:52:28 +010087};
88
89enum {
90 Opt_uid,
91 Opt_gid,
92 Opt_mode,
93 Opt_err
94};
95
96static const match_table_t tokens = {
97 {Opt_uid, "uid=%u"},
98 {Opt_gid, "gid=%u"},
99 {Opt_mode, "mode=%o"},
100 {Opt_err, NULL}
101};
102
103struct debugfs_fs_info {
104 struct debugfs_mount_opts mount_opts;
105};
106
107static int debugfs_parse_options(char *data, struct debugfs_mount_opts *opts)
108{
109 substring_t args[MAX_OPT_ARGS];
110 int option;
111 int token;
Eric W. Biederman7dc05882012-04-03 14:01:31 -0700112 kuid_t uid;
113 kgid_t gid;
Ludwig Nusseld6e48682012-01-25 11:52:28 +0100114 char *p;
115
Brian Norrisb8de524c2022-09-12 16:31:42 -0700116 opts->opts = 0;
Ludwig Nusseld6e48682012-01-25 11:52:28 +0100117 opts->mode = DEBUGFS_DEFAULT_MODE;
118
119 while ((p = strsep(&data, ",")) != NULL) {
120 if (!*p)
121 continue;
122
123 token = match_token(p, tokens, args);
124 switch (token) {
125 case Opt_uid:
126 if (match_int(&args[0], &option))
127 return -EINVAL;
Eric W. Biederman7dc05882012-04-03 14:01:31 -0700128 uid = make_kuid(current_user_ns(), option);
129 if (!uid_valid(uid))
130 return -EINVAL;
131 opts->uid = uid;
Ludwig Nusseld6e48682012-01-25 11:52:28 +0100132 break;
133 case Opt_gid:
Dave Reisnerf1688e02013-01-02 08:54:37 -0500134 if (match_int(&args[0], &option))
Ludwig Nusseld6e48682012-01-25 11:52:28 +0100135 return -EINVAL;
Eric W. Biederman7dc05882012-04-03 14:01:31 -0700136 gid = make_kgid(current_user_ns(), option);
137 if (!gid_valid(gid))
138 return -EINVAL;
139 opts->gid = gid;
Ludwig Nusseld6e48682012-01-25 11:52:28 +0100140 break;
141 case Opt_mode:
142 if (match_octal(&args[0], &option))
143 return -EINVAL;
144 opts->mode = option & S_IALLUGO;
145 break;
146 /*
147 * We might like to report bad mount options here;
148 * but traditionally debugfs has ignored all mount options
149 */
150 }
Brian Norrisb8de524c2022-09-12 16:31:42 -0700151
152 opts->opts |= BIT(token);
Ludwig Nusseld6e48682012-01-25 11:52:28 +0100153 }
154
155 return 0;
156}
157
Brian Norrisb8de524c2022-09-12 16:31:42 -0700158static void _debugfs_apply_options(struct super_block *sb, bool remount)
Ludwig Nusseld6e48682012-01-25 11:52:28 +0100159{
160 struct debugfs_fs_info *fsi = sb->s_fs_info;
David Howells2b0143b2015-03-17 22:25:59 +0000161 struct inode *inode = d_inode(sb->s_root);
Ludwig Nusseld6e48682012-01-25 11:52:28 +0100162 struct debugfs_mount_opts *opts = &fsi->mount_opts;
163
Brian Norrisb8de524c2022-09-12 16:31:42 -0700164 /*
165 * On remount, only reset mode/uid/gid if they were provided as mount
166 * options.
167 */
Ludwig Nusseld6e48682012-01-25 11:52:28 +0100168
Brian Norrisb8de524c2022-09-12 16:31:42 -0700169 if (!remount || opts->opts & BIT(Opt_mode)) {
170 inode->i_mode &= ~S_IALLUGO;
171 inode->i_mode |= opts->mode;
172 }
Ludwig Nusseld6e48682012-01-25 11:52:28 +0100173
Brian Norrisb8de524c2022-09-12 16:31:42 -0700174 if (!remount || opts->opts & BIT(Opt_uid))
175 inode->i_uid = opts->uid;
176
177 if (!remount || opts->opts & BIT(Opt_gid))
178 inode->i_gid = opts->gid;
179}
180
181static void debugfs_apply_options(struct super_block *sb)
182{
183 _debugfs_apply_options(sb, false);
184}
185
186static void debugfs_apply_options_remount(struct super_block *sb)
187{
188 _debugfs_apply_options(sb, true);
Ludwig Nusseld6e48682012-01-25 11:52:28 +0100189}
190
191static int debugfs_remount(struct super_block *sb, int *flags, char *data)
192{
193 int err;
194 struct debugfs_fs_info *fsi = sb->s_fs_info;
195
Theodore Ts'o02b99842014-03-13 10:14:33 -0400196 sync_filesystem(sb);
Ludwig Nusseld6e48682012-01-25 11:52:28 +0100197 err = debugfs_parse_options(data, &fsi->mount_opts);
198 if (err)
199 goto fail;
200
Brian Norrisb8de524c2022-09-12 16:31:42 -0700201 debugfs_apply_options_remount(sb);
Ludwig Nusseld6e48682012-01-25 11:52:28 +0100202
203fail:
204 return err;
205}
206
207static int debugfs_show_options(struct seq_file *m, struct dentry *root)
208{
209 struct debugfs_fs_info *fsi = root->d_sb->s_fs_info;
210 struct debugfs_mount_opts *opts = &fsi->mount_opts;
211
Eric W. Biederman7dc05882012-04-03 14:01:31 -0700212 if (!uid_eq(opts->uid, GLOBAL_ROOT_UID))
213 seq_printf(m, ",uid=%u",
214 from_kuid_munged(&init_user_ns, opts->uid));
215 if (!gid_eq(opts->gid, GLOBAL_ROOT_GID))
216 seq_printf(m, ",gid=%u",
217 from_kgid_munged(&init_user_ns, opts->gid));
Ludwig Nusseld6e48682012-01-25 11:52:28 +0100218 if (opts->mode != DEBUGFS_DEFAULT_MODE)
219 seq_printf(m, ",mode=%o", opts->mode);
220
221 return 0;
222}
223
Al Viro6234ddf2019-04-14 23:19:45 -0400224static void debugfs_free_inode(struct inode *inode)
Al Viro0db59e52015-02-21 22:05:11 -0500225{
Al Viro0db59e52015-02-21 22:05:11 -0500226 if (S_ISLNK(inode->i_mode))
Al Viro5723cb02015-05-02 10:27:18 -0400227 kfree(inode->i_link);
Al Viro93b919d2019-03-26 01:43:37 +0000228 free_inode_nonrcu(inode);
229}
230
Ludwig Nusseld6e48682012-01-25 11:52:28 +0100231static const struct super_operations debugfs_super_operations = {
232 .statfs = simple_statfs,
233 .remount_fs = debugfs_remount,
234 .show_options = debugfs_show_options,
Al Viro6234ddf2019-04-14 23:19:45 -0400235 .free_inode = debugfs_free_inode,
Ludwig Nusseld6e48682012-01-25 11:52:28 +0100236};
237
Nicolai Stange7c8d4692017-10-31 00:15:47 +0100238static void debugfs_release_dentry(struct dentry *dentry)
239{
Nicolai Stange7d39bc52017-10-31 00:15:54 +0100240 void *fsd = dentry->d_fsdata;
241
242 if (!((unsigned long)fsd & DEBUGFS_FSDATA_IS_REAL_FOPS_BIT))
243 kfree(dentry->d_fsdata);
Nicolai Stange7c8d4692017-10-31 00:15:47 +0100244}
245
Al Viro77b3da62015-01-25 15:10:32 -0500246static struct vfsmount *debugfs_automount(struct path *path)
247{
Eric W. Biederman93faccbb2017-02-01 06:06:16 +1300248 debugfs_automount_t f;
249 f = (debugfs_automount_t)path->dentry->d_fsdata;
250 return f(path->dentry, d_inode(path->dentry)->i_private);
Al Viro77b3da62015-01-25 15:10:32 -0500251}
252
253static const struct dentry_operations debugfs_dops = {
254 .d_delete = always_delete_dentry,
Nicolai Stange7c8d4692017-10-31 00:15:47 +0100255 .d_release = debugfs_release_dentry,
Al Viro77b3da62015-01-25 15:10:32 -0500256 .d_automount = debugfs_automount,
257};
258
Linus Torvalds1da177e2005-04-16 15:20:36 -0700259static int debug_fill_super(struct super_block *sb, void *data, int silent)
260{
Eric Biggerscda37122017-03-25 21:15:37 -0700261 static const struct tree_descr debug_files[] = {{""}};
Ludwig Nusseld6e48682012-01-25 11:52:28 +0100262 struct debugfs_fs_info *fsi;
263 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700264
Ludwig Nusseld6e48682012-01-25 11:52:28 +0100265 fsi = kzalloc(sizeof(struct debugfs_fs_info), GFP_KERNEL);
266 sb->s_fs_info = fsi;
267 if (!fsi) {
268 err = -ENOMEM;
269 goto fail;
270 }
271
272 err = debugfs_parse_options(data, &fsi->mount_opts);
273 if (err)
274 goto fail;
275
276 err = simple_fill_super(sb, DEBUGFS_MAGIC, debug_files);
277 if (err)
278 goto fail;
279
280 sb->s_op = &debugfs_super_operations;
Al Viro77b3da62015-01-25 15:10:32 -0500281 sb->s_d_op = &debugfs_dops;
Ludwig Nusseld6e48682012-01-25 11:52:28 +0100282
283 debugfs_apply_options(sb);
284
285 return 0;
286
287fail:
288 kfree(fsi);
289 sb->s_fs_info = NULL;
290 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291}
292
Al Virofc14f2f2010-07-25 01:48:30 +0400293static struct dentry *debug_mount(struct file_system_type *fs_type,
David Howells454e2392006-06-23 02:02:57 -0700294 int flags, const char *dev_name,
Al Virofc14f2f2010-07-25 01:48:30 +0400295 void *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700296{
Peter Enderborga24c6f72020-07-16 09:15:11 +0200297 if (!(debugfs_allow & DEBUGFS_ALLOW_API))
298 return ERR_PTR(-EPERM);
299
Al Virofc14f2f2010-07-25 01:48:30 +0400300 return mount_single(fs_type, flags, data, debug_fill_super);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700301}
302
303static struct file_system_type debug_fs_type = {
304 .owner = THIS_MODULE,
305 .name = "debugfs",
Al Virofc14f2f2010-07-25 01:48:30 +0400306 .mount = debug_mount,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700307 .kill_sb = kill_litter_super,
308};
Eric W. Biederman7f78e032013-03-02 19:39:14 -0800309MODULE_ALIAS_FS("debugfs");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700310
Omar Sandovala7c54372017-01-31 14:53:17 -0800311/**
312 * debugfs_lookup() - look up an existing debugfs file
313 * @name: a pointer to a string containing the name of the file to look up.
314 * @parent: a pointer to the parent dentry of the file.
315 *
316 * This function will return a pointer to a dentry if it succeeds. If the file
317 * doesn't exist or an error occurs, %NULL will be returned. The returned
318 * dentry must be passed to dput() when it is no longer needed.
319 *
320 * If debugfs is not enabled in the kernel, the value -%ENODEV will be
321 * returned.
322 */
323struct dentry *debugfs_lookup(const char *name, struct dentry *parent)
324{
325 struct dentry *dentry;
326
Greg Kroah-Hartmanbc6de802021-02-18 11:08:17 +0100327 if (!debugfs_initialized() || IS_ERR_OR_NULL(name) || IS_ERR(parent))
Omar Sandovala7c54372017-01-31 14:53:17 -0800328 return NULL;
329
330 if (!parent)
331 parent = debugfs_mount->mnt_root;
332
Al Viro6c2d47982019-10-31 01:21:58 -0400333 dentry = lookup_positive_unlocked(name, parent, strlen(name));
Omar Sandovala7c54372017-01-31 14:53:17 -0800334 if (IS_ERR(dentry))
335 return NULL;
Omar Sandovala7c54372017-01-31 14:53:17 -0800336 return dentry;
337}
338EXPORT_SYMBOL_GPL(debugfs_lookup);
339
Al Viro190afd82015-01-25 13:55:55 -0500340static struct dentry *start_creating(const char *name, struct dentry *parent)
Al Viroc3b1a352012-06-09 20:28:22 -0400341{
Al Viro190afd82015-01-25 13:55:55 -0500342 struct dentry *dentry;
Al Viroc3b1a352012-06-09 20:28:22 -0400343 int error;
344
Peter Enderborga24c6f72020-07-16 09:15:11 +0200345 if (!(debugfs_allow & DEBUGFS_ALLOW_API))
346 return ERR_PTR(-EPERM);
347
Greg Kroah-Hartman56348562021-02-18 11:08:18 +0100348 if (!debugfs_initialized())
349 return ERR_PTR(-ENOENT);
350
Greg Kroah-Hartmand03ae472019-07-03 09:16:52 +0200351 pr_debug("creating file '%s'\n", name);
Al Viroc3b1a352012-06-09 20:28:22 -0400352
Greg KHc9e15f22015-03-30 14:59:15 +0200353 if (IS_ERR(parent))
354 return parent;
355
Al Viroc3b1a352012-06-09 20:28:22 -0400356 error = simple_pin_fs(&debug_fs_type, &debugfs_mount,
357 &debugfs_mount_count);
Greg Kroah-Hartman43e23b62019-07-03 09:16:53 +0200358 if (error) {
359 pr_err("Unable to pin filesystem for file '%s'\n", name);
Al Viro190afd82015-01-25 13:55:55 -0500360 return ERR_PTR(error);
Greg Kroah-Hartman43e23b62019-07-03 09:16:53 +0200361 }
Al Viroc3b1a352012-06-09 20:28:22 -0400362
Al Virocfa57c12012-06-09 20:33:28 -0400363 /* If the parent is not specified, we create it in the root.
Rahul Bedarkar88e412e2014-06-06 23:12:04 +0530364 * We need the root dentry to do this, which is in the super
Al Virocfa57c12012-06-09 20:33:28 -0400365 * block. A pointer to that is in the struct vfsmount that we
366 * have around.
367 */
368 if (!parent)
369 parent = debugfs_mount->mnt_root;
370
Al Viro59551022016-01-22 15:40:57 -0500371 inode_lock(d_inode(parent));
Al Viroa3d1e7e2019-11-18 09:43:10 -0500372 if (unlikely(IS_DEADDIR(d_inode(parent))))
373 dentry = ERR_PTR(-ENOENT);
374 else
375 dentry = lookup_one_len(name, parent, strlen(name));
David Howells2b0143b2015-03-17 22:25:59 +0000376 if (!IS_ERR(dentry) && d_really_is_positive(dentry)) {
Greg Kroah-Hartmanc33d4422019-07-06 17:42:56 +0200377 if (d_is_dir(dentry))
378 pr_err("Directory '%s' with parent '%s' already present!\n",
379 name, parent->d_name.name);
380 else
381 pr_err("File '%s' in directory '%s' already present!\n",
382 name, parent->d_name.name);
Al Virocfa57c12012-06-09 20:33:28 -0400383 dput(dentry);
Al Viro190afd82015-01-25 13:55:55 -0500384 dentry = ERR_PTR(-EEXIST);
385 }
Daniel Borkmann0ee96082015-11-05 00:01:51 +0100386
387 if (IS_ERR(dentry)) {
Al Viro59551022016-01-22 15:40:57 -0500388 inode_unlock(d_inode(parent));
Daniel Borkmann0ee96082015-11-05 00:01:51 +0100389 simple_release_fs(&debugfs_mount, &debugfs_mount_count);
390 }
391
Al Viro190afd82015-01-25 13:55:55 -0500392 return dentry;
393}
394
Al Viro5233e312015-01-25 14:39:49 -0500395static struct dentry *failed_creating(struct dentry *dentry)
Al Viro190afd82015-01-25 13:55:55 -0500396{
Al Viro59551022016-01-22 15:40:57 -0500397 inode_unlock(d_inode(dentry->d_parent));
Al Viro190afd82015-01-25 13:55:55 -0500398 dput(dentry);
Al Viro5233e312015-01-25 14:39:49 -0500399 simple_release_fs(&debugfs_mount, &debugfs_mount_count);
Greg Kroah-Hartmanff9fb722019-01-23 11:28:14 +0100400 return ERR_PTR(-ENOMEM);
Al Viro5233e312015-01-25 14:39:49 -0500401}
Al Virocfa57c12012-06-09 20:33:28 -0400402
Al Viro5233e312015-01-25 14:39:49 -0500403static struct dentry *end_creating(struct dentry *dentry)
404{
Al Viro59551022016-01-22 15:40:57 -0500405 inode_unlock(d_inode(dentry->d_parent));
Al Viroc3b1a352012-06-09 20:28:22 -0400406 return dentry;
407}
408
Nicolai Stange49d200d2016-03-22 14:11:14 +0100409static struct dentry *__debugfs_create_file(const char *name, umode_t mode,
410 struct dentry *parent, void *data,
411 const struct file_operations *proxy_fops,
412 const struct file_operations *real_fops)
413{
414 struct dentry *dentry;
415 struct inode *inode;
416
417 if (!(mode & S_IFMT))
418 mode |= S_IFREG;
419 BUG_ON(!S_ISREG(mode));
420 dentry = start_creating(name, parent);
421
Nicolai Stange7d39bc52017-10-31 00:15:54 +0100422 if (IS_ERR(dentry))
Greg Kroah-Hartmanff9fb722019-01-23 11:28:14 +0100423 return dentry;
Nicolai Stange49d200d2016-03-22 14:11:14 +0100424
Peter Enderborga24c6f72020-07-16 09:15:11 +0200425 if (!(debugfs_allow & DEBUGFS_ALLOW_API)) {
426 failed_creating(dentry);
427 return ERR_PTR(-EPERM);
428 }
429
Nicolai Stange49d200d2016-03-22 14:11:14 +0100430 inode = debugfs_get_inode(dentry->d_sb);
Greg Kroah-Hartman43e23b62019-07-03 09:16:53 +0200431 if (unlikely(!inode)) {
432 pr_err("out of free dentries, can not create file '%s'\n",
433 name);
Nicolai Stange49d200d2016-03-22 14:11:14 +0100434 return failed_creating(dentry);
Greg Kroah-Hartman43e23b62019-07-03 09:16:53 +0200435 }
Nicolai Stange49d200d2016-03-22 14:11:14 +0100436
437 inode->i_mode = mode;
438 inode->i_private = data;
439
David Howells54961972019-08-19 17:18:02 -0700440 inode->i_op = &debugfs_file_inode_operations;
Nicolai Stange49d200d2016-03-22 14:11:14 +0100441 inode->i_fop = proxy_fops;
Nicolai Stange7d39bc52017-10-31 00:15:54 +0100442 dentry->d_fsdata = (void *)((unsigned long)real_fops |
443 DEBUGFS_FSDATA_IS_REAL_FOPS_BIT);
Nicolai Stange49d200d2016-03-22 14:11:14 +0100444
445 d_instantiate(dentry, inode);
446 fsnotify_create(d_inode(dentry->d_parent), dentry);
447 return end_creating(dentry);
448}
449
Linus Torvalds1da177e2005-04-16 15:20:36 -0700450/**
451 * debugfs_create_file - create a file in the debugfs filesystem
Linus Torvalds1da177e2005-04-16 15:20:36 -0700452 * @name: a pointer to a string containing the name of the file to create.
Alberto Bertoglibe030e62009-10-31 18:26:52 -0300453 * @mode: the permission that the file should have.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700454 * @parent: a pointer to the parent dentry for this file. This should be a
Masanari Iidae2278672014-02-18 22:54:36 +0900455 * directory dentry if set. If this parameter is NULL, then the
Linus Torvalds1da177e2005-04-16 15:20:36 -0700456 * file will be created in the root of the debugfs filesystem.
457 * @data: a pointer to something that the caller will want to get to later
Theodore Ts'o8e18e292006-09-27 01:50:46 -0700458 * on. The inode.i_private pointer will point to this value on
Linus Torvalds1da177e2005-04-16 15:20:36 -0700459 * the open() call.
460 * @fops: a pointer to a struct file_operations that should be used for
461 * this file.
462 *
463 * This is the basic "create a file" function for debugfs. It allows for a
Alberto Bertoglibe030e62009-10-31 18:26:52 -0300464 * wide range of flexibility in creating a file, or a directory (if you want
465 * to create a directory, the debugfs_create_dir() function is
Linus Torvalds1da177e2005-04-16 15:20:36 -0700466 * recommended to be used instead.)
467 *
468 * This function will return a pointer to a dentry if it succeeds. This
469 * pointer must be passed to the debugfs_remove() function when the file is
470 * to be removed (no automatic cleanup happens if your module is unloaded,
Daniel W. S. Almeidaadc92dd2019-12-26 22:00:33 -0300471 * you are responsible here.) If an error occurs, ERR_PTR(-ERROR) will be
Greg Kroah-Hartmanff9fb722019-01-23 11:28:14 +0100472 * returned.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700473 *
Randy Dunlap6468b3a2006-07-20 08:16:42 -0700474 * If debugfs is not enabled in the kernel, the value -%ENODEV will be
Cornelia Huck873760f2007-02-14 07:57:47 +0100475 * returned.
Douglas Anderson8bcbde22022-02-22 15:46:00 -0800476 *
477 * NOTE: it's expected that most callers should _ignore_ the errors returned
478 * by this function. Other debugfs functions handle the fact that the "dentry"
479 * passed to them could be an error and they don't crash in that case.
480 * Drivers should generally work fine even if debugfs fails to init anyway.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700481 */
Al Virof4ae40a62011-07-24 04:33:43 -0400482struct dentry *debugfs_create_file(const char *name, umode_t mode,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700483 struct dentry *parent, void *data,
Arjan van de Ven99ac48f2006-03-28 01:56:41 -0800484 const struct file_operations *fops)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700485{
Al Viroc3b1a352012-06-09 20:28:22 -0400486
Nicolai Stange49d200d2016-03-22 14:11:14 +0100487 return __debugfs_create_file(name, mode, parent, data,
488 fops ? &debugfs_full_proxy_file_operations :
489 &debugfs_noop_file_operations,
490 fops);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700491}
492EXPORT_SYMBOL_GPL(debugfs_create_file);
493
Nicolai Stangec6468802016-03-22 14:11:15 +0100494/**
495 * debugfs_create_file_unsafe - create a file in the debugfs filesystem
496 * @name: a pointer to a string containing the name of the file to create.
497 * @mode: the permission that the file should have.
498 * @parent: a pointer to the parent dentry for this file. This should be a
499 * directory dentry if set. If this parameter is NULL, then the
500 * file will be created in the root of the debugfs filesystem.
501 * @data: a pointer to something that the caller will want to get to later
502 * on. The inode.i_private pointer will point to this value on
503 * the open() call.
504 * @fops: a pointer to a struct file_operations that should be used for
505 * this file.
506 *
507 * debugfs_create_file_unsafe() is completely analogous to
508 * debugfs_create_file(), the only difference being that the fops
509 * handed it will not get protected against file removals by the
510 * debugfs core.
511 *
512 * It is your responsibility to protect your struct file_operation
Sergey Senozhatsky0eeb2732018-12-30 12:46:52 +0900513 * methods against file removals by means of debugfs_file_get()
514 * and debugfs_file_put(). ->open() is still protected by
Nicolai Stangec6468802016-03-22 14:11:15 +0100515 * debugfs though.
516 *
517 * Any struct file_operations defined by means of
518 * DEFINE_DEBUGFS_ATTRIBUTE() is protected against file removals and
519 * thus, may be used here.
520 */
Nicolai Stange49d200d2016-03-22 14:11:14 +0100521struct dentry *debugfs_create_file_unsafe(const char *name, umode_t mode,
522 struct dentry *parent, void *data,
523 const struct file_operations *fops)
524{
525
526 return __debugfs_create_file(name, mode, parent, data,
527 fops ? &debugfs_open_proxy_file_operations :
528 &debugfs_noop_file_operations,
529 fops);
530}
Nicolai Stangec6468802016-03-22 14:11:15 +0100531EXPORT_SYMBOL_GPL(debugfs_create_file_unsafe);
Nicolai Stange49d200d2016-03-22 14:11:14 +0100532
Linus Torvalds1da177e2005-04-16 15:20:36 -0700533/**
David Howellse59b4e92015-01-21 20:03:40 +0000534 * debugfs_create_file_size - create a file in the debugfs filesystem
535 * @name: a pointer to a string containing the name of the file to create.
536 * @mode: the permission that the file should have.
537 * @parent: a pointer to the parent dentry for this file. This should be a
538 * directory dentry if set. If this parameter is NULL, then the
539 * file will be created in the root of the debugfs filesystem.
540 * @data: a pointer to something that the caller will want to get to later
541 * on. The inode.i_private pointer will point to this value on
542 * the open() call.
543 * @fops: a pointer to a struct file_operations that should be used for
544 * this file.
545 * @file_size: initial file size
546 *
547 * This is the basic "create a file" function for debugfs. It allows for a
548 * wide range of flexibility in creating a file, or a directory (if you want
549 * to create a directory, the debugfs_create_dir() function is
550 * recommended to be used instead.)
David Howellse59b4e92015-01-21 20:03:40 +0000551 */
Greg Kroah-Hartman526ee722020-03-09 17:36:40 +0100552void debugfs_create_file_size(const char *name, umode_t mode,
553 struct dentry *parent, void *data,
554 const struct file_operations *fops,
555 loff_t file_size)
David Howellse59b4e92015-01-21 20:03:40 +0000556{
557 struct dentry *de = debugfs_create_file(name, mode, parent, data, fops);
558
Nirmoy Dasaf505ca2021-09-02 12:29:17 +0200559 if (!IS_ERR(de))
David Howells2b0143b2015-03-17 22:25:59 +0000560 d_inode(de)->i_size = file_size;
David Howellse59b4e92015-01-21 20:03:40 +0000561}
562EXPORT_SYMBOL_GPL(debugfs_create_file_size);
563
564/**
Linus Torvalds1da177e2005-04-16 15:20:36 -0700565 * debugfs_create_dir - create a directory in the debugfs filesystem
Linus Torvalds1da177e2005-04-16 15:20:36 -0700566 * @name: a pointer to a string containing the name of the directory to
567 * create.
568 * @parent: a pointer to the parent dentry for this file. This should be a
Masanari Iidae2278672014-02-18 22:54:36 +0900569 * directory dentry if set. If this parameter is NULL, then the
Linus Torvalds1da177e2005-04-16 15:20:36 -0700570 * directory will be created in the root of the debugfs filesystem.
571 *
572 * This function creates a directory in debugfs with the given name.
573 *
574 * This function will return a pointer to a dentry if it succeeds. This
575 * pointer must be passed to the debugfs_remove() function when the file is
576 * to be removed (no automatic cleanup happens if your module is unloaded,
Daniel W. S. Almeidaadc92dd2019-12-26 22:00:33 -0300577 * you are responsible here.) If an error occurs, ERR_PTR(-ERROR) will be
Greg Kroah-Hartmanff9fb722019-01-23 11:28:14 +0100578 * returned.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700579 *
Randy Dunlap6468b3a2006-07-20 08:16:42 -0700580 * If debugfs is not enabled in the kernel, the value -%ENODEV will be
Cornelia Huck873760f2007-02-14 07:57:47 +0100581 * returned.
Douglas Anderson8bcbde22022-02-22 15:46:00 -0800582 *
583 * NOTE: it's expected that most callers should _ignore_ the errors returned
584 * by this function. Other debugfs functions handle the fact that the "dentry"
585 * passed to them could be an error and they don't crash in that case.
586 * Drivers should generally work fine even if debugfs fails to init anyway.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700587 */
588struct dentry *debugfs_create_dir(const char *name, struct dentry *parent)
589{
Al Viroad5abd52015-01-25 14:02:31 -0500590 struct dentry *dentry = start_creating(name, parent);
Al Viro680b3022015-01-25 14:31:32 -0500591 struct inode *inode;
Al Viroad5abd52015-01-25 14:02:31 -0500592
593 if (IS_ERR(dentry))
Greg Kroah-Hartmanff9fb722019-01-23 11:28:14 +0100594 return dentry;
Al Viroad5abd52015-01-25 14:02:31 -0500595
Peter Enderborga24c6f72020-07-16 09:15:11 +0200596 if (!(debugfs_allow & DEBUGFS_ALLOW_API)) {
597 failed_creating(dentry);
598 return ERR_PTR(-EPERM);
599 }
600
Al Viroedac65ea2015-01-25 14:36:18 -0500601 inode = debugfs_get_inode(dentry->d_sb);
Greg Kroah-Hartman43e23b62019-07-03 09:16:53 +0200602 if (unlikely(!inode)) {
603 pr_err("out of free dentries, can not create directory '%s'\n",
604 name);
Al Viro5233e312015-01-25 14:39:49 -0500605 return failed_creating(dentry);
Greg Kroah-Hartman43e23b62019-07-03 09:16:53 +0200606 }
Al Viro680b3022015-01-25 14:31:32 -0500607
Linus Torvaldsf5b7769e2018-06-12 20:52:16 -0700608 inode->i_mode = S_IFDIR | S_IRWXU | S_IRUGO | S_IXUGO;
David Howells54961972019-08-19 17:18:02 -0700609 inode->i_op = &debugfs_dir_inode_operations;
Al Viroedac65ea2015-01-25 14:36:18 -0500610 inode->i_fop = &simple_dir_operations;
611
612 /* directory inodes start off with i_nlink == 2 (for "." entry) */
613 inc_nlink(inode);
Al Viro680b3022015-01-25 14:31:32 -0500614 d_instantiate(dentry, inode);
David Howells2b0143b2015-03-17 22:25:59 +0000615 inc_nlink(d_inode(dentry->d_parent));
616 fsnotify_mkdir(d_inode(dentry->d_parent), dentry);
Al Viro5233e312015-01-25 14:39:49 -0500617 return end_creating(dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700618}
619EXPORT_SYMBOL_GPL(debugfs_create_dir);
620
621/**
Al Viro77b3da62015-01-25 15:10:32 -0500622 * debugfs_create_automount - create automount point in the debugfs filesystem
623 * @name: a pointer to a string containing the name of the file to create.
624 * @parent: a pointer to the parent dentry for this file. This should be a
625 * directory dentry if set. If this parameter is NULL, then the
626 * file will be created in the root of the debugfs filesystem.
627 * @f: function to be called when pathname resolution steps on that one.
628 * @data: opaque argument to pass to f().
629 *
630 * @f should return what ->d_automount() would.
631 */
632struct dentry *debugfs_create_automount(const char *name,
633 struct dentry *parent,
Eric W. Biederman93faccbb2017-02-01 06:06:16 +1300634 debugfs_automount_t f,
Al Viro77b3da62015-01-25 15:10:32 -0500635 void *data)
636{
637 struct dentry *dentry = start_creating(name, parent);
638 struct inode *inode;
639
640 if (IS_ERR(dentry))
Greg Kroah-Hartmanff9fb722019-01-23 11:28:14 +0100641 return dentry;
Al Viro77b3da62015-01-25 15:10:32 -0500642
Peter Enderborga24c6f72020-07-16 09:15:11 +0200643 if (!(debugfs_allow & DEBUGFS_ALLOW_API)) {
644 failed_creating(dentry);
645 return ERR_PTR(-EPERM);
646 }
647
Al Viro77b3da62015-01-25 15:10:32 -0500648 inode = debugfs_get_inode(dentry->d_sb);
Greg Kroah-Hartman43e23b62019-07-03 09:16:53 +0200649 if (unlikely(!inode)) {
650 pr_err("out of free dentries, can not create automount '%s'\n",
651 name);
Al Viro77b3da62015-01-25 15:10:32 -0500652 return failed_creating(dentry);
Greg Kroah-Hartman43e23b62019-07-03 09:16:53 +0200653 }
Al Viro77b3da62015-01-25 15:10:32 -0500654
Seth Forshee87243de2016-03-09 09:18:07 -0600655 make_empty_dir_inode(inode);
Al Viro77b3da62015-01-25 15:10:32 -0500656 inode->i_flags |= S_AUTOMOUNT;
657 inode->i_private = data;
658 dentry->d_fsdata = (void *)f;
Roman Pena8f324a2016-02-09 11:30:29 +0100659 /* directory inodes start off with i_nlink == 2 (for "." entry) */
660 inc_nlink(inode);
Al Viro77b3da62015-01-25 15:10:32 -0500661 d_instantiate(dentry, inode);
Roman Pena8f324a2016-02-09 11:30:29 +0100662 inc_nlink(d_inode(dentry->d_parent));
663 fsnotify_mkdir(d_inode(dentry->d_parent), dentry);
Al Viro77b3da62015-01-25 15:10:32 -0500664 return end_creating(dentry);
665}
666EXPORT_SYMBOL(debugfs_create_automount);
667
668/**
Peter Oberparleiter66f54962007-02-13 12:13:54 +0100669 * debugfs_create_symlink- create a symbolic link in the debugfs filesystem
670 * @name: a pointer to a string containing the name of the symbolic link to
671 * create.
672 * @parent: a pointer to the parent dentry for this symbolic link. This
Masanari Iidae2278672014-02-18 22:54:36 +0900673 * should be a directory dentry if set. If this parameter is NULL,
Peter Oberparleiter66f54962007-02-13 12:13:54 +0100674 * then the symbolic link will be created in the root of the debugfs
675 * filesystem.
676 * @target: a pointer to a string containing the path to the target of the
677 * symbolic link.
678 *
679 * This function creates a symbolic link with the given name in debugfs that
680 * links to the given target path.
681 *
682 * This function will return a pointer to a dentry if it succeeds. This
683 * pointer must be passed to the debugfs_remove() function when the symbolic
684 * link is to be removed (no automatic cleanup happens if your module is
Daniel W. S. Almeidaadc92dd2019-12-26 22:00:33 -0300685 * unloaded, you are responsible here.) If an error occurs, ERR_PTR(-ERROR)
Greg Kroah-Hartmanff9fb722019-01-23 11:28:14 +0100686 * will be returned.
Peter Oberparleiter66f54962007-02-13 12:13:54 +0100687 *
688 * If debugfs is not enabled in the kernel, the value -%ENODEV will be
Cornelia Huck873760f2007-02-14 07:57:47 +0100689 * returned.
Peter Oberparleiter66f54962007-02-13 12:13:54 +0100690 */
691struct dentry *debugfs_create_symlink(const char *name, struct dentry *parent,
692 const char *target)
693{
Al Viroad5abd52015-01-25 14:02:31 -0500694 struct dentry *dentry;
Al Viro680b3022015-01-25 14:31:32 -0500695 struct inode *inode;
696 char *link = kstrdup(target, GFP_KERNEL);
Peter Oberparleiter66f54962007-02-13 12:13:54 +0100697 if (!link)
Greg Kroah-Hartmanff9fb722019-01-23 11:28:14 +0100698 return ERR_PTR(-ENOMEM);
Peter Oberparleiter66f54962007-02-13 12:13:54 +0100699
Al Viroad5abd52015-01-25 14:02:31 -0500700 dentry = start_creating(name, parent);
Al Viroad5abd52015-01-25 14:02:31 -0500701 if (IS_ERR(dentry)) {
Peter Oberparleiter66f54962007-02-13 12:13:54 +0100702 kfree(link);
Greg Kroah-Hartmanff9fb722019-01-23 11:28:14 +0100703 return dentry;
Al Viroad5abd52015-01-25 14:02:31 -0500704 }
705
Al Viroedac65ea2015-01-25 14:36:18 -0500706 inode = debugfs_get_inode(dentry->d_sb);
Al Viro680b3022015-01-25 14:31:32 -0500707 if (unlikely(!inode)) {
Greg Kroah-Hartman43e23b62019-07-03 09:16:53 +0200708 pr_err("out of free dentries, can not create symlink '%s'\n",
709 name);
Al Viroad5abd52015-01-25 14:02:31 -0500710 kfree(link);
Al Viro5233e312015-01-25 14:39:49 -0500711 return failed_creating(dentry);
Al Viro680b3022015-01-25 14:31:32 -0500712 }
Al Viroedac65ea2015-01-25 14:36:18 -0500713 inode->i_mode = S_IFLNK | S_IRWXUGO;
David Howells54961972019-08-19 17:18:02 -0700714 inode->i_op = &debugfs_symlink_inode_operations;
Al Viro5723cb02015-05-02 10:27:18 -0400715 inode->i_link = link;
Al Viro680b3022015-01-25 14:31:32 -0500716 d_instantiate(dentry, inode);
Al Viro5233e312015-01-25 14:39:49 -0500717 return end_creating(dentry);
Peter Oberparleiter66f54962007-02-13 12:13:54 +0100718}
719EXPORT_SYMBOL_GPL(debugfs_create_symlink);
720
Amir Goldstein823e5452019-05-26 17:34:07 +0300721static void __debugfs_file_removed(struct dentry *dentry)
Nicolai Stangee9117a52017-10-31 00:15:48 +0100722{
723 struct debugfs_fsdata *fsd;
724
Nicolai Stange7d39bc52017-10-31 00:15:54 +0100725 /*
726 * Paired with the closing smp_mb() implied by a successful
727 * cmpxchg() in debugfs_file_get(): either
728 * debugfs_file_get() must see a dead dentry or we must see a
729 * debugfs_fsdata instance at ->d_fsdata here (or both).
730 */
731 smp_mb();
732 fsd = READ_ONCE(dentry->d_fsdata);
733 if ((unsigned long)fsd & DEBUGFS_FSDATA_IS_REAL_FOPS_BIT)
734 return;
Nicolai Stangee9117a52017-10-31 00:15:48 +0100735 if (!refcount_dec_and_test(&fsd->active_users))
736 wait_for_completion(&fsd->active_users_drained);
737}
738
Al Viroa3d1e7e2019-11-18 09:43:10 -0500739static void remove_one(struct dentry *victim)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700740{
Al Viroa3d1e7e2019-11-18 09:43:10 -0500741 if (d_is_reg(victim))
742 __debugfs_file_removed(victim);
743 simple_release_fs(&debugfs_mount, &debugfs_mount_count);
Haavard Skinnemoen9505e632008-07-01 15:14:51 +0200744}
745
746/**
Al Viroa3d1e7e2019-11-18 09:43:10 -0500747 * debugfs_remove - recursively removes a directory
Ulf Magnusson398dc4a2015-09-07 19:03:15 +0200748 * @dentry: a pointer to a the dentry of the directory to be removed. If this
749 * parameter is NULL or an error value, nothing will be done.
Haavard Skinnemoen9505e632008-07-01 15:14:51 +0200750 *
751 * This function recursively removes a directory tree in debugfs that
752 * was previously created with a call to another debugfs function
753 * (like debugfs_create_file() or variants thereof.)
754 *
755 * This function is required to be called in order for the file to be
756 * removed, no automatic cleanup of files will happen when a module is
757 * removed, you are responsible here.
758 */
Al Viroa3d1e7e2019-11-18 09:43:10 -0500759void debugfs_remove(struct dentry *dentry)
Haavard Skinnemoen9505e632008-07-01 15:14:51 +0200760{
Arend van Spriela59d6292012-05-23 15:13:07 +0200761 if (IS_ERR_OR_NULL(dentry))
Haavard Skinnemoen9505e632008-07-01 15:14:51 +0200762 return;
763
Al Viroa3d1e7e2019-11-18 09:43:10 -0500764 simple_pin_fs(&debug_fs_type, &debugfs_mount, &debugfs_mount_count);
765 simple_recursive_removal(dentry, remove_one);
766 simple_release_fs(&debugfs_mount, &debugfs_mount_count);
Haavard Skinnemoen9505e632008-07-01 15:14:51 +0200767}
Al Viroa3d1e7e2019-11-18 09:43:10 -0500768EXPORT_SYMBOL_GPL(debugfs_remove);
Haavard Skinnemoen9505e632008-07-01 15:14:51 +0200769
770/**
Greg Kroah-Hartmandec9b2f2022-09-02 16:59:15 +0200771 * debugfs_lookup_and_remove - lookup a directory or file and recursively remove it
772 * @name: a pointer to a string containing the name of the item to look up.
773 * @parent: a pointer to the parent dentry of the item.
774 *
775 * This is the equlivant of doing something like
776 * debugfs_remove(debugfs_lookup(..)) but with the proper reference counting
777 * handled for the directory being looked up.
778 */
779void debugfs_lookup_and_remove(const char *name, struct dentry *parent)
780{
781 struct dentry *dentry;
782
783 dentry = debugfs_lookup(name, parent);
784 if (!dentry)
785 return;
786
787 debugfs_remove(dentry);
788 dput(dentry);
789}
790EXPORT_SYMBOL_GPL(debugfs_lookup_and_remove);
791
792/**
Jan Karacfc94cd2007-05-09 13:19:52 +0200793 * debugfs_rename - rename a file/directory in the debugfs filesystem
794 * @old_dir: a pointer to the parent dentry for the renamed object. This
795 * should be a directory dentry.
796 * @old_dentry: dentry of an object to be renamed.
797 * @new_dir: a pointer to the parent dentry where the object should be
798 * moved. This should be a directory dentry.
799 * @new_name: a pointer to a string containing the target name.
800 *
801 * This function renames a file/directory in debugfs. The target must not
802 * exist for rename to succeed.
803 *
804 * This function will return a pointer to old_dentry (which is updated to
Bagas Sanjaya88cd6182023-02-20 19:47:21 +0700805 * reflect renaming) if it succeeds. If an error occurs, ERR_PTR(-ERROR)
Qi Zhengd3002462023-02-08 11:56:34 +0800806 * will be returned.
Jan Karacfc94cd2007-05-09 13:19:52 +0200807 *
808 * If debugfs is not enabled in the kernel, the value -%ENODEV will be
809 * returned.
810 */
811struct dentry *debugfs_rename(struct dentry *old_dir, struct dentry *old_dentry,
812 struct dentry *new_dir, const char *new_name)
813{
814 int error;
815 struct dentry *dentry = NULL, *trap;
Al Viro49d31c22017-07-07 14:51:19 -0400816 struct name_snapshot old_name;
Jan Karacfc94cd2007-05-09 13:19:52 +0200817
Greg Kroah-Hartmand88c93f2019-01-23 11:27:02 +0100818 if (IS_ERR(old_dir))
819 return old_dir;
820 if (IS_ERR(new_dir))
821 return new_dir;
822 if (IS_ERR_OR_NULL(old_dentry))
823 return old_dentry;
824
Jan Karacfc94cd2007-05-09 13:19:52 +0200825 trap = lock_rename(new_dir, old_dir);
826 /* Source or destination directories don't exist? */
David Howells2b0143b2015-03-17 22:25:59 +0000827 if (d_really_is_negative(old_dir) || d_really_is_negative(new_dir))
Jan Karacfc94cd2007-05-09 13:19:52 +0200828 goto exit;
829 /* Source does not exist, cyclic rename, or mountpoint? */
David Howells2b0143b2015-03-17 22:25:59 +0000830 if (d_really_is_negative(old_dentry) || old_dentry == trap ||
Jan Karacfc94cd2007-05-09 13:19:52 +0200831 d_mountpoint(old_dentry))
832 goto exit;
833 dentry = lookup_one_len(new_name, new_dir, strlen(new_name));
834 /* Lookup failed, cyclic rename or target exists? */
David Howells2b0143b2015-03-17 22:25:59 +0000835 if (IS_ERR(dentry) || dentry == trap || d_really_is_positive(dentry))
Jan Karacfc94cd2007-05-09 13:19:52 +0200836 goto exit;
837
Al Viro49d31c22017-07-07 14:51:19 -0400838 take_dentry_name_snapshot(&old_name, old_dentry);
Jan Karacfc94cd2007-05-09 13:19:52 +0200839
Christian Braunere18275a2023-01-13 12:49:17 +0100840 error = simple_rename(&nop_mnt_idmap, d_inode(old_dir), old_dentry,
Christian Brauner549c7292021-01-21 14:19:43 +0100841 d_inode(new_dir), dentry, 0);
Jan Karacfc94cd2007-05-09 13:19:52 +0200842 if (error) {
Al Viro49d31c22017-07-07 14:51:19 -0400843 release_dentry_name_snapshot(&old_name);
Jan Karacfc94cd2007-05-09 13:19:52 +0200844 goto exit;
845 }
846 d_move(old_dentry, dentry);
Al Virof4ec3a32019-04-26 13:21:24 -0400847 fsnotify_move(d_inode(old_dir), d_inode(new_dir), &old_name.name,
David Howellse36cb0b2015-01-29 12:02:35 +0000848 d_is_dir(old_dentry),
Al Viro5a190ae2007-06-07 12:19:32 -0400849 NULL, old_dentry);
Al Viro49d31c22017-07-07 14:51:19 -0400850 release_dentry_name_snapshot(&old_name);
Jan Karacfc94cd2007-05-09 13:19:52 +0200851 unlock_rename(new_dir, old_dir);
852 dput(dentry);
853 return old_dentry;
854exit:
855 if (dentry && !IS_ERR(dentry))
856 dput(dentry);
857 unlock_rename(new_dir, old_dir);
Greg Kroah-Hartmanff9fb722019-01-23 11:28:14 +0100858 if (IS_ERR(dentry))
859 return dentry;
860 return ERR_PTR(-EINVAL);
Jan Karacfc94cd2007-05-09 13:19:52 +0200861}
862EXPORT_SYMBOL_GPL(debugfs_rename);
863
Frederic Weisbeckerc0f92ba2009-03-22 23:10:44 +0100864/**
865 * debugfs_initialized - Tells whether debugfs has been registered
866 */
867bool debugfs_initialized(void)
868{
869 return debugfs_registered;
870}
871EXPORT_SYMBOL_GPL(debugfs_initialized);
872
Peter Enderborga24c6f72020-07-16 09:15:11 +0200873static int __init debugfs_kernel(char *str)
874{
875 if (str) {
876 if (!strcmp(str, "on"))
877 debugfs_allow = DEBUGFS_ALLOW_API | DEBUGFS_ALLOW_MOUNT;
878 else if (!strcmp(str, "no-mount"))
879 debugfs_allow = DEBUGFS_ALLOW_API;
880 else if (!strcmp(str, "off"))
881 debugfs_allow = 0;
882 }
883
884 return 0;
885}
886early_param("debugfs", debugfs_kernel);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700887static int __init debugfs_init(void)
888{
889 int retval;
890
Peter Enderborga24c6f72020-07-16 09:15:11 +0200891 if (!(debugfs_allow & DEBUGFS_ALLOW_MOUNT))
892 return -EPERM;
893
Eric W. Biedermanf9bb4882015-05-13 17:35:41 -0500894 retval = sysfs_create_mount_point(kernel_kobj, "debug");
895 if (retval)
896 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700897
898 retval = register_filesystem(&debug_fs_type);
899 if (retval)
Eric W. Biedermanf9bb4882015-05-13 17:35:41 -0500900 sysfs_remove_mount_point(kernel_kobj, "debug");
Frederic Weisbeckerc0f92ba2009-03-22 23:10:44 +0100901 else
902 debugfs_registered = true;
903
Linus Torvalds1da177e2005-04-16 15:20:36 -0700904 return retval;
905}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700906core_initcall(debugfs_init);