blob: 2fcf66473436bb672259a0ef4171c8728bfc942b [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;
Peter Enderborga24c6f72020-07-16 09:15:11 +020038static unsigned int debugfs_allow = 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 */
45static int debugfs_setattr(struct dentry *dentry, struct iattr *ia)
46{
47 int ret = security_locked_down(LOCKDOWN_DEBUGFS);
48
49 if (ret && (ia->ia_valid & (ATTR_MODE | ATTR_UID | ATTR_GID)))
50 return ret;
51 return simple_setattr(dentry, ia);
52}
53
54static const struct inode_operations debugfs_file_inode_operations = {
55 .setattr = debugfs_setattr,
56};
57static const struct inode_operations debugfs_dir_inode_operations = {
58 .lookup = simple_lookup,
59 .setattr = debugfs_setattr,
60};
61static const struct inode_operations debugfs_symlink_inode_operations = {
62 .get_link = simple_get_link,
63 .setattr = debugfs_setattr,
64};
65
Al Viroedac65ea2015-01-25 14:36:18 -050066static struct inode *debugfs_get_inode(struct super_block *sb)
Linus Torvalds1da177e2005-04-16 15:20:36 -070067{
68 struct inode *inode = new_inode(sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -070069 if (inode) {
Christoph Hellwig85fe4022010-10-23 11:19:54 -040070 inode->i_ino = get_next_ino();
Deepa Dinamani1b48b532016-02-22 07:17:47 -080071 inode->i_atime = inode->i_mtime =
Deepa Dinamanic2050a42016-09-14 07:48:06 -070072 inode->i_ctime = current_time(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -070073 }
Rahul Bedarkar88e412e2014-06-06 23:12:04 +053074 return inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -070075}
76
Ludwig Nusseld6e48682012-01-25 11:52:28 +010077struct debugfs_mount_opts {
Eric W. Biederman7dc05882012-04-03 14:01:31 -070078 kuid_t uid;
79 kgid_t gid;
Ludwig Nusseld6e48682012-01-25 11:52:28 +010080 umode_t mode;
81};
82
83enum {
84 Opt_uid,
85 Opt_gid,
86 Opt_mode,
87 Opt_err
88};
89
90static const match_table_t tokens = {
91 {Opt_uid, "uid=%u"},
92 {Opt_gid, "gid=%u"},
93 {Opt_mode, "mode=%o"},
94 {Opt_err, NULL}
95};
96
97struct debugfs_fs_info {
98 struct debugfs_mount_opts mount_opts;
99};
100
101static int debugfs_parse_options(char *data, struct debugfs_mount_opts *opts)
102{
103 substring_t args[MAX_OPT_ARGS];
104 int option;
105 int token;
Eric W. Biederman7dc05882012-04-03 14:01:31 -0700106 kuid_t uid;
107 kgid_t gid;
Ludwig Nusseld6e48682012-01-25 11:52:28 +0100108 char *p;
109
110 opts->mode = DEBUGFS_DEFAULT_MODE;
111
112 while ((p = strsep(&data, ",")) != NULL) {
113 if (!*p)
114 continue;
115
116 token = match_token(p, tokens, args);
117 switch (token) {
118 case Opt_uid:
119 if (match_int(&args[0], &option))
120 return -EINVAL;
Eric W. Biederman7dc05882012-04-03 14:01:31 -0700121 uid = make_kuid(current_user_ns(), option);
122 if (!uid_valid(uid))
123 return -EINVAL;
124 opts->uid = uid;
Ludwig Nusseld6e48682012-01-25 11:52:28 +0100125 break;
126 case Opt_gid:
Dave Reisnerf1688e02013-01-02 08:54:37 -0500127 if (match_int(&args[0], &option))
Ludwig Nusseld6e48682012-01-25 11:52:28 +0100128 return -EINVAL;
Eric W. Biederman7dc05882012-04-03 14:01:31 -0700129 gid = make_kgid(current_user_ns(), option);
130 if (!gid_valid(gid))
131 return -EINVAL;
132 opts->gid = gid;
Ludwig Nusseld6e48682012-01-25 11:52:28 +0100133 break;
134 case Opt_mode:
135 if (match_octal(&args[0], &option))
136 return -EINVAL;
137 opts->mode = option & S_IALLUGO;
138 break;
139 /*
140 * We might like to report bad mount options here;
141 * but traditionally debugfs has ignored all mount options
142 */
143 }
144 }
145
146 return 0;
147}
148
149static int debugfs_apply_options(struct super_block *sb)
150{
151 struct debugfs_fs_info *fsi = sb->s_fs_info;
David Howells2b0143b2015-03-17 22:25:59 +0000152 struct inode *inode = d_inode(sb->s_root);
Ludwig Nusseld6e48682012-01-25 11:52:28 +0100153 struct debugfs_mount_opts *opts = &fsi->mount_opts;
154
155 inode->i_mode &= ~S_IALLUGO;
156 inode->i_mode |= opts->mode;
157
158 inode->i_uid = opts->uid;
159 inode->i_gid = opts->gid;
160
161 return 0;
162}
163
164static int debugfs_remount(struct super_block *sb, int *flags, char *data)
165{
166 int err;
167 struct debugfs_fs_info *fsi = sb->s_fs_info;
168
Theodore Ts'o02b99842014-03-13 10:14:33 -0400169 sync_filesystem(sb);
Ludwig Nusseld6e48682012-01-25 11:52:28 +0100170 err = debugfs_parse_options(data, &fsi->mount_opts);
171 if (err)
172 goto fail;
173
174 debugfs_apply_options(sb);
175
176fail:
177 return err;
178}
179
180static int debugfs_show_options(struct seq_file *m, struct dentry *root)
181{
182 struct debugfs_fs_info *fsi = root->d_sb->s_fs_info;
183 struct debugfs_mount_opts *opts = &fsi->mount_opts;
184
Eric W. Biederman7dc05882012-04-03 14:01:31 -0700185 if (!uid_eq(opts->uid, GLOBAL_ROOT_UID))
186 seq_printf(m, ",uid=%u",
187 from_kuid_munged(&init_user_ns, opts->uid));
188 if (!gid_eq(opts->gid, GLOBAL_ROOT_GID))
189 seq_printf(m, ",gid=%u",
190 from_kgid_munged(&init_user_ns, opts->gid));
Ludwig Nusseld6e48682012-01-25 11:52:28 +0100191 if (opts->mode != DEBUGFS_DEFAULT_MODE)
192 seq_printf(m, ",mode=%o", opts->mode);
193
194 return 0;
195}
196
Al Viro6234ddf2019-04-14 23:19:45 -0400197static void debugfs_free_inode(struct inode *inode)
Al Viro0db59e52015-02-21 22:05:11 -0500198{
Al Viro0db59e52015-02-21 22:05:11 -0500199 if (S_ISLNK(inode->i_mode))
Al Viro5723cb02015-05-02 10:27:18 -0400200 kfree(inode->i_link);
Al Viro93b919d2019-03-26 01:43:37 +0000201 free_inode_nonrcu(inode);
202}
203
Ludwig Nusseld6e48682012-01-25 11:52:28 +0100204static const struct super_operations debugfs_super_operations = {
205 .statfs = simple_statfs,
206 .remount_fs = debugfs_remount,
207 .show_options = debugfs_show_options,
Al Viro6234ddf2019-04-14 23:19:45 -0400208 .free_inode = debugfs_free_inode,
Ludwig Nusseld6e48682012-01-25 11:52:28 +0100209};
210
Nicolai Stange7c8d4692017-10-31 00:15:47 +0100211static void debugfs_release_dentry(struct dentry *dentry)
212{
Nicolai Stange7d39bc52017-10-31 00:15:54 +0100213 void *fsd = dentry->d_fsdata;
214
215 if (!((unsigned long)fsd & DEBUGFS_FSDATA_IS_REAL_FOPS_BIT))
216 kfree(dentry->d_fsdata);
Nicolai Stange7c8d4692017-10-31 00:15:47 +0100217}
218
Al Viro77b3da62015-01-25 15:10:32 -0500219static struct vfsmount *debugfs_automount(struct path *path)
220{
Eric W. Biederman93faccbb2017-02-01 06:06:16 +1300221 debugfs_automount_t f;
222 f = (debugfs_automount_t)path->dentry->d_fsdata;
223 return f(path->dentry, d_inode(path->dentry)->i_private);
Al Viro77b3da62015-01-25 15:10:32 -0500224}
225
226static const struct dentry_operations debugfs_dops = {
227 .d_delete = always_delete_dentry,
Nicolai Stange7c8d4692017-10-31 00:15:47 +0100228 .d_release = debugfs_release_dentry,
Al Viro77b3da62015-01-25 15:10:32 -0500229 .d_automount = debugfs_automount,
230};
231
Linus Torvalds1da177e2005-04-16 15:20:36 -0700232static int debug_fill_super(struct super_block *sb, void *data, int silent)
233{
Eric Biggerscda37122017-03-25 21:15:37 -0700234 static const struct tree_descr debug_files[] = {{""}};
Ludwig Nusseld6e48682012-01-25 11:52:28 +0100235 struct debugfs_fs_info *fsi;
236 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700237
Ludwig Nusseld6e48682012-01-25 11:52:28 +0100238 fsi = kzalloc(sizeof(struct debugfs_fs_info), GFP_KERNEL);
239 sb->s_fs_info = fsi;
240 if (!fsi) {
241 err = -ENOMEM;
242 goto fail;
243 }
244
245 err = debugfs_parse_options(data, &fsi->mount_opts);
246 if (err)
247 goto fail;
248
249 err = simple_fill_super(sb, DEBUGFS_MAGIC, debug_files);
250 if (err)
251 goto fail;
252
253 sb->s_op = &debugfs_super_operations;
Al Viro77b3da62015-01-25 15:10:32 -0500254 sb->s_d_op = &debugfs_dops;
Ludwig Nusseld6e48682012-01-25 11:52:28 +0100255
256 debugfs_apply_options(sb);
257
258 return 0;
259
260fail:
261 kfree(fsi);
262 sb->s_fs_info = NULL;
263 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700264}
265
Al Virofc14f2f2010-07-25 01:48:30 +0400266static struct dentry *debug_mount(struct file_system_type *fs_type,
David Howells454e2392006-06-23 02:02:57 -0700267 int flags, const char *dev_name,
Al Virofc14f2f2010-07-25 01:48:30 +0400268 void *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700269{
Peter Enderborga24c6f72020-07-16 09:15:11 +0200270 if (!(debugfs_allow & DEBUGFS_ALLOW_API))
271 return ERR_PTR(-EPERM);
272
Al Virofc14f2f2010-07-25 01:48:30 +0400273 return mount_single(fs_type, flags, data, debug_fill_super);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700274}
275
276static struct file_system_type debug_fs_type = {
277 .owner = THIS_MODULE,
278 .name = "debugfs",
Al Virofc14f2f2010-07-25 01:48:30 +0400279 .mount = debug_mount,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700280 .kill_sb = kill_litter_super,
281};
Eric W. Biederman7f78e032013-03-02 19:39:14 -0800282MODULE_ALIAS_FS("debugfs");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700283
Omar Sandovala7c54372017-01-31 14:53:17 -0800284/**
285 * debugfs_lookup() - look up an existing debugfs file
286 * @name: a pointer to a string containing the name of the file to look up.
287 * @parent: a pointer to the parent dentry of the file.
288 *
289 * This function will return a pointer to a dentry if it succeeds. If the file
290 * doesn't exist or an error occurs, %NULL will be returned. The returned
291 * dentry must be passed to dput() when it is no longer needed.
292 *
293 * If debugfs is not enabled in the kernel, the value -%ENODEV will be
294 * returned.
295 */
296struct dentry *debugfs_lookup(const char *name, struct dentry *parent)
297{
298 struct dentry *dentry;
299
300 if (IS_ERR(parent))
301 return NULL;
302
303 if (!parent)
304 parent = debugfs_mount->mnt_root;
305
Al Viro6c2d47982019-10-31 01:21:58 -0400306 dentry = lookup_positive_unlocked(name, parent, strlen(name));
Omar Sandovala7c54372017-01-31 14:53:17 -0800307 if (IS_ERR(dentry))
308 return NULL;
Omar Sandovala7c54372017-01-31 14:53:17 -0800309 return dentry;
310}
311EXPORT_SYMBOL_GPL(debugfs_lookup);
312
Al Viro190afd82015-01-25 13:55:55 -0500313static struct dentry *start_creating(const char *name, struct dentry *parent)
Al Viroc3b1a352012-06-09 20:28:22 -0400314{
Al Viro190afd82015-01-25 13:55:55 -0500315 struct dentry *dentry;
Al Viroc3b1a352012-06-09 20:28:22 -0400316 int error;
317
Peter Enderborga24c6f72020-07-16 09:15:11 +0200318 if (!(debugfs_allow & DEBUGFS_ALLOW_API))
319 return ERR_PTR(-EPERM);
320
Greg Kroah-Hartmand03ae472019-07-03 09:16:52 +0200321 pr_debug("creating file '%s'\n", name);
Al Viroc3b1a352012-06-09 20:28:22 -0400322
Greg KHc9e15f22015-03-30 14:59:15 +0200323 if (IS_ERR(parent))
324 return parent;
325
Al Viroc3b1a352012-06-09 20:28:22 -0400326 error = simple_pin_fs(&debug_fs_type, &debugfs_mount,
327 &debugfs_mount_count);
Greg Kroah-Hartman43e23b62019-07-03 09:16:53 +0200328 if (error) {
329 pr_err("Unable to pin filesystem for file '%s'\n", name);
Al Viro190afd82015-01-25 13:55:55 -0500330 return ERR_PTR(error);
Greg Kroah-Hartman43e23b62019-07-03 09:16:53 +0200331 }
Al Viroc3b1a352012-06-09 20:28:22 -0400332
Al Virocfa57c12012-06-09 20:33:28 -0400333 /* If the parent is not specified, we create it in the root.
Rahul Bedarkar88e412e2014-06-06 23:12:04 +0530334 * We need the root dentry to do this, which is in the super
Al Virocfa57c12012-06-09 20:33:28 -0400335 * block. A pointer to that is in the struct vfsmount that we
336 * have around.
337 */
338 if (!parent)
339 parent = debugfs_mount->mnt_root;
340
Al Viro59551022016-01-22 15:40:57 -0500341 inode_lock(d_inode(parent));
Al Viroa3d1e7e2019-11-18 09:43:10 -0500342 if (unlikely(IS_DEADDIR(d_inode(parent))))
343 dentry = ERR_PTR(-ENOENT);
344 else
345 dentry = lookup_one_len(name, parent, strlen(name));
David Howells2b0143b2015-03-17 22:25:59 +0000346 if (!IS_ERR(dentry) && d_really_is_positive(dentry)) {
Greg Kroah-Hartmanc33d4422019-07-06 17:42:56 +0200347 if (d_is_dir(dentry))
348 pr_err("Directory '%s' with parent '%s' already present!\n",
349 name, parent->d_name.name);
350 else
351 pr_err("File '%s' in directory '%s' already present!\n",
352 name, parent->d_name.name);
Al Virocfa57c12012-06-09 20:33:28 -0400353 dput(dentry);
Al Viro190afd82015-01-25 13:55:55 -0500354 dentry = ERR_PTR(-EEXIST);
355 }
Daniel Borkmann0ee96082015-11-05 00:01:51 +0100356
357 if (IS_ERR(dentry)) {
Al Viro59551022016-01-22 15:40:57 -0500358 inode_unlock(d_inode(parent));
Daniel Borkmann0ee96082015-11-05 00:01:51 +0100359 simple_release_fs(&debugfs_mount, &debugfs_mount_count);
360 }
361
Al Viro190afd82015-01-25 13:55:55 -0500362 return dentry;
363}
364
Al Viro5233e312015-01-25 14:39:49 -0500365static struct dentry *failed_creating(struct dentry *dentry)
Al Viro190afd82015-01-25 13:55:55 -0500366{
Al Viro59551022016-01-22 15:40:57 -0500367 inode_unlock(d_inode(dentry->d_parent));
Al Viro190afd82015-01-25 13:55:55 -0500368 dput(dentry);
Al Viro5233e312015-01-25 14:39:49 -0500369 simple_release_fs(&debugfs_mount, &debugfs_mount_count);
Greg Kroah-Hartmanff9fb722019-01-23 11:28:14 +0100370 return ERR_PTR(-ENOMEM);
Al Viro5233e312015-01-25 14:39:49 -0500371}
Al Virocfa57c12012-06-09 20:33:28 -0400372
Al Viro5233e312015-01-25 14:39:49 -0500373static struct dentry *end_creating(struct dentry *dentry)
374{
Al Viro59551022016-01-22 15:40:57 -0500375 inode_unlock(d_inode(dentry->d_parent));
Al Viroc3b1a352012-06-09 20:28:22 -0400376 return dentry;
377}
378
Nicolai Stange49d200d2016-03-22 14:11:14 +0100379static struct dentry *__debugfs_create_file(const char *name, umode_t mode,
380 struct dentry *parent, void *data,
381 const struct file_operations *proxy_fops,
382 const struct file_operations *real_fops)
383{
384 struct dentry *dentry;
385 struct inode *inode;
386
387 if (!(mode & S_IFMT))
388 mode |= S_IFREG;
389 BUG_ON(!S_ISREG(mode));
390 dentry = start_creating(name, parent);
391
Nicolai Stange7d39bc52017-10-31 00:15:54 +0100392 if (IS_ERR(dentry))
Greg Kroah-Hartmanff9fb722019-01-23 11:28:14 +0100393 return dentry;
Nicolai Stange49d200d2016-03-22 14:11:14 +0100394
Peter Enderborga24c6f72020-07-16 09:15:11 +0200395 if (!(debugfs_allow & DEBUGFS_ALLOW_API)) {
396 failed_creating(dentry);
397 return ERR_PTR(-EPERM);
398 }
399
Nicolai Stange49d200d2016-03-22 14:11:14 +0100400 inode = debugfs_get_inode(dentry->d_sb);
Greg Kroah-Hartman43e23b62019-07-03 09:16:53 +0200401 if (unlikely(!inode)) {
402 pr_err("out of free dentries, can not create file '%s'\n",
403 name);
Nicolai Stange49d200d2016-03-22 14:11:14 +0100404 return failed_creating(dentry);
Greg Kroah-Hartman43e23b62019-07-03 09:16:53 +0200405 }
Nicolai Stange49d200d2016-03-22 14:11:14 +0100406
407 inode->i_mode = mode;
408 inode->i_private = data;
409
David Howells54961972019-08-19 17:18:02 -0700410 inode->i_op = &debugfs_file_inode_operations;
Nicolai Stange49d200d2016-03-22 14:11:14 +0100411 inode->i_fop = proxy_fops;
Nicolai Stange7d39bc52017-10-31 00:15:54 +0100412 dentry->d_fsdata = (void *)((unsigned long)real_fops |
413 DEBUGFS_FSDATA_IS_REAL_FOPS_BIT);
Nicolai Stange49d200d2016-03-22 14:11:14 +0100414
415 d_instantiate(dentry, inode);
416 fsnotify_create(d_inode(dentry->d_parent), dentry);
417 return end_creating(dentry);
418}
419
Linus Torvalds1da177e2005-04-16 15:20:36 -0700420/**
421 * debugfs_create_file - create a file in the debugfs filesystem
Linus Torvalds1da177e2005-04-16 15:20:36 -0700422 * @name: a pointer to a string containing the name of the file to create.
Alberto Bertoglibe030e62009-10-31 18:26:52 -0300423 * @mode: the permission that the file should have.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700424 * @parent: a pointer to the parent dentry for this file. This should be a
Masanari Iidae2278672014-02-18 22:54:36 +0900425 * directory dentry if set. If this parameter is NULL, then the
Linus Torvalds1da177e2005-04-16 15:20:36 -0700426 * file will be created in the root of the debugfs filesystem.
427 * @data: a pointer to something that the caller will want to get to later
Theodore Ts'o8e18e292006-09-27 01:50:46 -0700428 * on. The inode.i_private pointer will point to this value on
Linus Torvalds1da177e2005-04-16 15:20:36 -0700429 * the open() call.
430 * @fops: a pointer to a struct file_operations that should be used for
431 * this file.
432 *
433 * This is the basic "create a file" function for debugfs. It allows for a
Alberto Bertoglibe030e62009-10-31 18:26:52 -0300434 * wide range of flexibility in creating a file, or a directory (if you want
435 * to create a directory, the debugfs_create_dir() function is
Linus Torvalds1da177e2005-04-16 15:20:36 -0700436 * recommended to be used instead.)
437 *
438 * This function will return a pointer to a dentry if it succeeds. This
439 * pointer must be passed to the debugfs_remove() function when the file is
440 * to be removed (no automatic cleanup happens if your module is unloaded,
Daniel W. S. Almeidaadc92dd2019-12-26 22:00:33 -0300441 * you are responsible here.) If an error occurs, ERR_PTR(-ERROR) will be
Greg Kroah-Hartmanff9fb722019-01-23 11:28:14 +0100442 * returned.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700443 *
Randy Dunlap6468b3a2006-07-20 08:16:42 -0700444 * If debugfs is not enabled in the kernel, the value -%ENODEV will be
Cornelia Huck873760f2007-02-14 07:57:47 +0100445 * returned.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700446 */
Al Virof4ae40a62011-07-24 04:33:43 -0400447struct dentry *debugfs_create_file(const char *name, umode_t mode,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700448 struct dentry *parent, void *data,
Arjan van de Ven99ac48f2006-03-28 01:56:41 -0800449 const struct file_operations *fops)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700450{
Al Viroc3b1a352012-06-09 20:28:22 -0400451
Nicolai Stange49d200d2016-03-22 14:11:14 +0100452 return __debugfs_create_file(name, mode, parent, data,
453 fops ? &debugfs_full_proxy_file_operations :
454 &debugfs_noop_file_operations,
455 fops);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700456}
457EXPORT_SYMBOL_GPL(debugfs_create_file);
458
Nicolai Stangec6468802016-03-22 14:11:15 +0100459/**
460 * debugfs_create_file_unsafe - create a file in the debugfs filesystem
461 * @name: a pointer to a string containing the name of the file to create.
462 * @mode: the permission that the file should have.
463 * @parent: a pointer to the parent dentry for this file. This should be a
464 * directory dentry if set. If this parameter is NULL, then the
465 * file will be created in the root of the debugfs filesystem.
466 * @data: a pointer to something that the caller will want to get to later
467 * on. The inode.i_private pointer will point to this value on
468 * the open() call.
469 * @fops: a pointer to a struct file_operations that should be used for
470 * this file.
471 *
472 * debugfs_create_file_unsafe() is completely analogous to
473 * debugfs_create_file(), the only difference being that the fops
474 * handed it will not get protected against file removals by the
475 * debugfs core.
476 *
477 * It is your responsibility to protect your struct file_operation
Sergey Senozhatsky0eeb2732018-12-30 12:46:52 +0900478 * methods against file removals by means of debugfs_file_get()
479 * and debugfs_file_put(). ->open() is still protected by
Nicolai Stangec6468802016-03-22 14:11:15 +0100480 * debugfs though.
481 *
482 * Any struct file_operations defined by means of
483 * DEFINE_DEBUGFS_ATTRIBUTE() is protected against file removals and
484 * thus, may be used here.
485 */
Nicolai Stange49d200d2016-03-22 14:11:14 +0100486struct dentry *debugfs_create_file_unsafe(const char *name, umode_t mode,
487 struct dentry *parent, void *data,
488 const struct file_operations *fops)
489{
490
491 return __debugfs_create_file(name, mode, parent, data,
492 fops ? &debugfs_open_proxy_file_operations :
493 &debugfs_noop_file_operations,
494 fops);
495}
Nicolai Stangec6468802016-03-22 14:11:15 +0100496EXPORT_SYMBOL_GPL(debugfs_create_file_unsafe);
Nicolai Stange49d200d2016-03-22 14:11:14 +0100497
Linus Torvalds1da177e2005-04-16 15:20:36 -0700498/**
David Howellse59b4e92015-01-21 20:03:40 +0000499 * debugfs_create_file_size - create a file in the debugfs filesystem
500 * @name: a pointer to a string containing the name of the file to create.
501 * @mode: the permission that the file should have.
502 * @parent: a pointer to the parent dentry for this file. This should be a
503 * directory dentry if set. If this parameter is NULL, then the
504 * file will be created in the root of the debugfs filesystem.
505 * @data: a pointer to something that the caller will want to get to later
506 * on. The inode.i_private pointer will point to this value on
507 * the open() call.
508 * @fops: a pointer to a struct file_operations that should be used for
509 * this file.
510 * @file_size: initial file size
511 *
512 * This is the basic "create a file" function for debugfs. It allows for a
513 * wide range of flexibility in creating a file, or a directory (if you want
514 * to create a directory, the debugfs_create_dir() function is
515 * recommended to be used instead.)
David Howellse59b4e92015-01-21 20:03:40 +0000516 */
Greg Kroah-Hartman526ee722020-03-09 17:36:40 +0100517void debugfs_create_file_size(const char *name, umode_t mode,
518 struct dentry *parent, void *data,
519 const struct file_operations *fops,
520 loff_t file_size)
David Howellse59b4e92015-01-21 20:03:40 +0000521{
522 struct dentry *de = debugfs_create_file(name, mode, parent, data, fops);
523
524 if (de)
David Howells2b0143b2015-03-17 22:25:59 +0000525 d_inode(de)->i_size = file_size;
David Howellse59b4e92015-01-21 20:03:40 +0000526}
527EXPORT_SYMBOL_GPL(debugfs_create_file_size);
528
529/**
Linus Torvalds1da177e2005-04-16 15:20:36 -0700530 * debugfs_create_dir - create a directory in the debugfs filesystem
Linus Torvalds1da177e2005-04-16 15:20:36 -0700531 * @name: a pointer to a string containing the name of the directory to
532 * create.
533 * @parent: a pointer to the parent dentry for this file. This should be a
Masanari Iidae2278672014-02-18 22:54:36 +0900534 * directory dentry if set. If this parameter is NULL, then the
Linus Torvalds1da177e2005-04-16 15:20:36 -0700535 * directory will be created in the root of the debugfs filesystem.
536 *
537 * This function creates a directory in debugfs with the given name.
538 *
539 * This function will return a pointer to a dentry if it succeeds. This
540 * pointer must be passed to the debugfs_remove() function when the file is
541 * to be removed (no automatic cleanup happens if your module is unloaded,
Daniel W. S. Almeidaadc92dd2019-12-26 22:00:33 -0300542 * you are responsible here.) If an error occurs, ERR_PTR(-ERROR) will be
Greg Kroah-Hartmanff9fb722019-01-23 11:28:14 +0100543 * returned.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700544 *
Randy Dunlap6468b3a2006-07-20 08:16:42 -0700545 * If debugfs is not enabled in the kernel, the value -%ENODEV will be
Cornelia Huck873760f2007-02-14 07:57:47 +0100546 * returned.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700547 */
548struct dentry *debugfs_create_dir(const char *name, struct dentry *parent)
549{
Al Viroad5abd52015-01-25 14:02:31 -0500550 struct dentry *dentry = start_creating(name, parent);
Al Viro680b3022015-01-25 14:31:32 -0500551 struct inode *inode;
Al Viroad5abd52015-01-25 14:02:31 -0500552
553 if (IS_ERR(dentry))
Greg Kroah-Hartmanff9fb722019-01-23 11:28:14 +0100554 return dentry;
Al Viroad5abd52015-01-25 14:02:31 -0500555
Peter Enderborga24c6f72020-07-16 09:15:11 +0200556 if (!(debugfs_allow & DEBUGFS_ALLOW_API)) {
557 failed_creating(dentry);
558 return ERR_PTR(-EPERM);
559 }
560
Al Viroedac65ea2015-01-25 14:36:18 -0500561 inode = debugfs_get_inode(dentry->d_sb);
Greg Kroah-Hartman43e23b62019-07-03 09:16:53 +0200562 if (unlikely(!inode)) {
563 pr_err("out of free dentries, can not create directory '%s'\n",
564 name);
Al Viro5233e312015-01-25 14:39:49 -0500565 return failed_creating(dentry);
Greg Kroah-Hartman43e23b62019-07-03 09:16:53 +0200566 }
Al Viro680b3022015-01-25 14:31:32 -0500567
Linus Torvaldsf5b7769e2018-06-12 20:52:16 -0700568 inode->i_mode = S_IFDIR | S_IRWXU | S_IRUGO | S_IXUGO;
David Howells54961972019-08-19 17:18:02 -0700569 inode->i_op = &debugfs_dir_inode_operations;
Al Viroedac65ea2015-01-25 14:36:18 -0500570 inode->i_fop = &simple_dir_operations;
571
572 /* directory inodes start off with i_nlink == 2 (for "." entry) */
573 inc_nlink(inode);
Al Viro680b3022015-01-25 14:31:32 -0500574 d_instantiate(dentry, inode);
David Howells2b0143b2015-03-17 22:25:59 +0000575 inc_nlink(d_inode(dentry->d_parent));
576 fsnotify_mkdir(d_inode(dentry->d_parent), dentry);
Al Viro5233e312015-01-25 14:39:49 -0500577 return end_creating(dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700578}
579EXPORT_SYMBOL_GPL(debugfs_create_dir);
580
581/**
Al Viro77b3da62015-01-25 15:10:32 -0500582 * debugfs_create_automount - create automount point in the debugfs filesystem
583 * @name: a pointer to a string containing the name of the file to create.
584 * @parent: a pointer to the parent dentry for this file. This should be a
585 * directory dentry if set. If this parameter is NULL, then the
586 * file will be created in the root of the debugfs filesystem.
587 * @f: function to be called when pathname resolution steps on that one.
588 * @data: opaque argument to pass to f().
589 *
590 * @f should return what ->d_automount() would.
591 */
592struct dentry *debugfs_create_automount(const char *name,
593 struct dentry *parent,
Eric W. Biederman93faccbb2017-02-01 06:06:16 +1300594 debugfs_automount_t f,
Al Viro77b3da62015-01-25 15:10:32 -0500595 void *data)
596{
597 struct dentry *dentry = start_creating(name, parent);
598 struct inode *inode;
599
600 if (IS_ERR(dentry))
Greg Kroah-Hartmanff9fb722019-01-23 11:28:14 +0100601 return dentry;
Al Viro77b3da62015-01-25 15:10:32 -0500602
Peter Enderborga24c6f72020-07-16 09:15:11 +0200603 if (!(debugfs_allow & DEBUGFS_ALLOW_API)) {
604 failed_creating(dentry);
605 return ERR_PTR(-EPERM);
606 }
607
Al Viro77b3da62015-01-25 15:10:32 -0500608 inode = debugfs_get_inode(dentry->d_sb);
Greg Kroah-Hartman43e23b62019-07-03 09:16:53 +0200609 if (unlikely(!inode)) {
610 pr_err("out of free dentries, can not create automount '%s'\n",
611 name);
Al Viro77b3da62015-01-25 15:10:32 -0500612 return failed_creating(dentry);
Greg Kroah-Hartman43e23b62019-07-03 09:16:53 +0200613 }
Al Viro77b3da62015-01-25 15:10:32 -0500614
Seth Forshee87243de2016-03-09 09:18:07 -0600615 make_empty_dir_inode(inode);
Al Viro77b3da62015-01-25 15:10:32 -0500616 inode->i_flags |= S_AUTOMOUNT;
617 inode->i_private = data;
618 dentry->d_fsdata = (void *)f;
Roman Pena8f324a2016-02-09 11:30:29 +0100619 /* directory inodes start off with i_nlink == 2 (for "." entry) */
620 inc_nlink(inode);
Al Viro77b3da62015-01-25 15:10:32 -0500621 d_instantiate(dentry, inode);
Roman Pena8f324a2016-02-09 11:30:29 +0100622 inc_nlink(d_inode(dentry->d_parent));
623 fsnotify_mkdir(d_inode(dentry->d_parent), dentry);
Al Viro77b3da62015-01-25 15:10:32 -0500624 return end_creating(dentry);
625}
626EXPORT_SYMBOL(debugfs_create_automount);
627
628/**
Peter Oberparleiter66f54962007-02-13 12:13:54 +0100629 * debugfs_create_symlink- create a symbolic link in the debugfs filesystem
630 * @name: a pointer to a string containing the name of the symbolic link to
631 * create.
632 * @parent: a pointer to the parent dentry for this symbolic link. This
Masanari Iidae2278672014-02-18 22:54:36 +0900633 * should be a directory dentry if set. If this parameter is NULL,
Peter Oberparleiter66f54962007-02-13 12:13:54 +0100634 * then the symbolic link will be created in the root of the debugfs
635 * filesystem.
636 * @target: a pointer to a string containing the path to the target of the
637 * symbolic link.
638 *
639 * This function creates a symbolic link with the given name in debugfs that
640 * links to the given target path.
641 *
642 * This function will return a pointer to a dentry if it succeeds. This
643 * pointer must be passed to the debugfs_remove() function when the symbolic
644 * link is to be removed (no automatic cleanup happens if your module is
Daniel W. S. Almeidaadc92dd2019-12-26 22:00:33 -0300645 * unloaded, you are responsible here.) If an error occurs, ERR_PTR(-ERROR)
Greg Kroah-Hartmanff9fb722019-01-23 11:28:14 +0100646 * will be returned.
Peter Oberparleiter66f54962007-02-13 12:13:54 +0100647 *
648 * If debugfs is not enabled in the kernel, the value -%ENODEV will be
Cornelia Huck873760f2007-02-14 07:57:47 +0100649 * returned.
Peter Oberparleiter66f54962007-02-13 12:13:54 +0100650 */
651struct dentry *debugfs_create_symlink(const char *name, struct dentry *parent,
652 const char *target)
653{
Al Viroad5abd52015-01-25 14:02:31 -0500654 struct dentry *dentry;
Al Viro680b3022015-01-25 14:31:32 -0500655 struct inode *inode;
656 char *link = kstrdup(target, GFP_KERNEL);
Peter Oberparleiter66f54962007-02-13 12:13:54 +0100657 if (!link)
Greg Kroah-Hartmanff9fb722019-01-23 11:28:14 +0100658 return ERR_PTR(-ENOMEM);
Peter Oberparleiter66f54962007-02-13 12:13:54 +0100659
Al Viroad5abd52015-01-25 14:02:31 -0500660 dentry = start_creating(name, parent);
Al Viroad5abd52015-01-25 14:02:31 -0500661 if (IS_ERR(dentry)) {
Peter Oberparleiter66f54962007-02-13 12:13:54 +0100662 kfree(link);
Greg Kroah-Hartmanff9fb722019-01-23 11:28:14 +0100663 return dentry;
Al Viroad5abd52015-01-25 14:02:31 -0500664 }
665
Al Viroedac65ea2015-01-25 14:36:18 -0500666 inode = debugfs_get_inode(dentry->d_sb);
Al Viro680b3022015-01-25 14:31:32 -0500667 if (unlikely(!inode)) {
Greg Kroah-Hartman43e23b62019-07-03 09:16:53 +0200668 pr_err("out of free dentries, can not create symlink '%s'\n",
669 name);
Al Viroad5abd52015-01-25 14:02:31 -0500670 kfree(link);
Al Viro5233e312015-01-25 14:39:49 -0500671 return failed_creating(dentry);
Al Viro680b3022015-01-25 14:31:32 -0500672 }
Al Viroedac65ea2015-01-25 14:36:18 -0500673 inode->i_mode = S_IFLNK | S_IRWXUGO;
David Howells54961972019-08-19 17:18:02 -0700674 inode->i_op = &debugfs_symlink_inode_operations;
Al Viro5723cb02015-05-02 10:27:18 -0400675 inode->i_link = link;
Al Viro680b3022015-01-25 14:31:32 -0500676 d_instantiate(dentry, inode);
Al Viro5233e312015-01-25 14:39:49 -0500677 return end_creating(dentry);
Peter Oberparleiter66f54962007-02-13 12:13:54 +0100678}
679EXPORT_SYMBOL_GPL(debugfs_create_symlink);
680
Amir Goldstein823e5452019-05-26 17:34:07 +0300681static void __debugfs_file_removed(struct dentry *dentry)
Nicolai Stangee9117a52017-10-31 00:15:48 +0100682{
683 struct debugfs_fsdata *fsd;
684
Nicolai Stange7d39bc52017-10-31 00:15:54 +0100685 /*
686 * Paired with the closing smp_mb() implied by a successful
687 * cmpxchg() in debugfs_file_get(): either
688 * debugfs_file_get() must see a dead dentry or we must see a
689 * debugfs_fsdata instance at ->d_fsdata here (or both).
690 */
691 smp_mb();
692 fsd = READ_ONCE(dentry->d_fsdata);
693 if ((unsigned long)fsd & DEBUGFS_FSDATA_IS_REAL_FOPS_BIT)
694 return;
Nicolai Stangee9117a52017-10-31 00:15:48 +0100695 if (!refcount_dec_and_test(&fsd->active_users))
696 wait_for_completion(&fsd->active_users_drained);
697}
698
Al Viroa3d1e7e2019-11-18 09:43:10 -0500699static void remove_one(struct dentry *victim)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700700{
Al Viroa3d1e7e2019-11-18 09:43:10 -0500701 if (d_is_reg(victim))
702 __debugfs_file_removed(victim);
703 simple_release_fs(&debugfs_mount, &debugfs_mount_count);
Haavard Skinnemoen9505e632008-07-01 15:14:51 +0200704}
705
706/**
Al Viroa3d1e7e2019-11-18 09:43:10 -0500707 * debugfs_remove - recursively removes a directory
Ulf Magnusson398dc4a2015-09-07 19:03:15 +0200708 * @dentry: a pointer to a the dentry of the directory to be removed. If this
709 * parameter is NULL or an error value, nothing will be done.
Haavard Skinnemoen9505e632008-07-01 15:14:51 +0200710 *
711 * This function recursively removes a directory tree in debugfs that
712 * was previously created with a call to another debugfs function
713 * (like debugfs_create_file() or variants thereof.)
714 *
715 * This function is required to be called in order for the file to be
716 * removed, no automatic cleanup of files will happen when a module is
717 * removed, you are responsible here.
718 */
Al Viroa3d1e7e2019-11-18 09:43:10 -0500719void debugfs_remove(struct dentry *dentry)
Haavard Skinnemoen9505e632008-07-01 15:14:51 +0200720{
Arend van Spriela59d6292012-05-23 15:13:07 +0200721 if (IS_ERR_OR_NULL(dentry))
Haavard Skinnemoen9505e632008-07-01 15:14:51 +0200722 return;
723
Al Viroa3d1e7e2019-11-18 09:43:10 -0500724 simple_pin_fs(&debug_fs_type, &debugfs_mount, &debugfs_mount_count);
725 simple_recursive_removal(dentry, remove_one);
726 simple_release_fs(&debugfs_mount, &debugfs_mount_count);
Haavard Skinnemoen9505e632008-07-01 15:14:51 +0200727}
Al Viroa3d1e7e2019-11-18 09:43:10 -0500728EXPORT_SYMBOL_GPL(debugfs_remove);
Haavard Skinnemoen9505e632008-07-01 15:14:51 +0200729
730/**
Jan Karacfc94cd2007-05-09 13:19:52 +0200731 * debugfs_rename - rename a file/directory in the debugfs filesystem
732 * @old_dir: a pointer to the parent dentry for the renamed object. This
733 * should be a directory dentry.
734 * @old_dentry: dentry of an object to be renamed.
735 * @new_dir: a pointer to the parent dentry where the object should be
736 * moved. This should be a directory dentry.
737 * @new_name: a pointer to a string containing the target name.
738 *
739 * This function renames a file/directory in debugfs. The target must not
740 * exist for rename to succeed.
741 *
742 * This function will return a pointer to old_dentry (which is updated to
743 * reflect renaming) if it succeeds. If an error occurs, %NULL will be
744 * returned.
745 *
746 * If debugfs is not enabled in the kernel, the value -%ENODEV will be
747 * returned.
748 */
749struct dentry *debugfs_rename(struct dentry *old_dir, struct dentry *old_dentry,
750 struct dentry *new_dir, const char *new_name)
751{
752 int error;
753 struct dentry *dentry = NULL, *trap;
Al Viro49d31c22017-07-07 14:51:19 -0400754 struct name_snapshot old_name;
Jan Karacfc94cd2007-05-09 13:19:52 +0200755
Greg Kroah-Hartmand88c93f2019-01-23 11:27:02 +0100756 if (IS_ERR(old_dir))
757 return old_dir;
758 if (IS_ERR(new_dir))
759 return new_dir;
760 if (IS_ERR_OR_NULL(old_dentry))
761 return old_dentry;
762
Jan Karacfc94cd2007-05-09 13:19:52 +0200763 trap = lock_rename(new_dir, old_dir);
764 /* Source or destination directories don't exist? */
David Howells2b0143b2015-03-17 22:25:59 +0000765 if (d_really_is_negative(old_dir) || d_really_is_negative(new_dir))
Jan Karacfc94cd2007-05-09 13:19:52 +0200766 goto exit;
767 /* Source does not exist, cyclic rename, or mountpoint? */
David Howells2b0143b2015-03-17 22:25:59 +0000768 if (d_really_is_negative(old_dentry) || old_dentry == trap ||
Jan Karacfc94cd2007-05-09 13:19:52 +0200769 d_mountpoint(old_dentry))
770 goto exit;
771 dentry = lookup_one_len(new_name, new_dir, strlen(new_name));
772 /* Lookup failed, cyclic rename or target exists? */
David Howells2b0143b2015-03-17 22:25:59 +0000773 if (IS_ERR(dentry) || dentry == trap || d_really_is_positive(dentry))
Jan Karacfc94cd2007-05-09 13:19:52 +0200774 goto exit;
775
Al Viro49d31c22017-07-07 14:51:19 -0400776 take_dentry_name_snapshot(&old_name, old_dentry);
Jan Karacfc94cd2007-05-09 13:19:52 +0200777
David Howells2b0143b2015-03-17 22:25:59 +0000778 error = simple_rename(d_inode(old_dir), old_dentry, d_inode(new_dir),
Miklos Szeredie0e0be82016-09-27 11:03:57 +0200779 dentry, 0);
Jan Karacfc94cd2007-05-09 13:19:52 +0200780 if (error) {
Al Viro49d31c22017-07-07 14:51:19 -0400781 release_dentry_name_snapshot(&old_name);
Jan Karacfc94cd2007-05-09 13:19:52 +0200782 goto exit;
783 }
784 d_move(old_dentry, dentry);
Al Virof4ec3a32019-04-26 13:21:24 -0400785 fsnotify_move(d_inode(old_dir), d_inode(new_dir), &old_name.name,
David Howellse36cb0b2015-01-29 12:02:35 +0000786 d_is_dir(old_dentry),
Al Viro5a190ae2007-06-07 12:19:32 -0400787 NULL, old_dentry);
Al Viro49d31c22017-07-07 14:51:19 -0400788 release_dentry_name_snapshot(&old_name);
Jan Karacfc94cd2007-05-09 13:19:52 +0200789 unlock_rename(new_dir, old_dir);
790 dput(dentry);
791 return old_dentry;
792exit:
793 if (dentry && !IS_ERR(dentry))
794 dput(dentry);
795 unlock_rename(new_dir, old_dir);
Greg Kroah-Hartmanff9fb722019-01-23 11:28:14 +0100796 if (IS_ERR(dentry))
797 return dentry;
798 return ERR_PTR(-EINVAL);
Jan Karacfc94cd2007-05-09 13:19:52 +0200799}
800EXPORT_SYMBOL_GPL(debugfs_rename);
801
Frederic Weisbeckerc0f92ba2009-03-22 23:10:44 +0100802/**
803 * debugfs_initialized - Tells whether debugfs has been registered
804 */
805bool debugfs_initialized(void)
806{
807 return debugfs_registered;
808}
809EXPORT_SYMBOL_GPL(debugfs_initialized);
810
Peter Enderborga24c6f72020-07-16 09:15:11 +0200811static int __init debugfs_kernel(char *str)
812{
813 if (str) {
814 if (!strcmp(str, "on"))
815 debugfs_allow = DEBUGFS_ALLOW_API | DEBUGFS_ALLOW_MOUNT;
816 else if (!strcmp(str, "no-mount"))
817 debugfs_allow = DEBUGFS_ALLOW_API;
818 else if (!strcmp(str, "off"))
819 debugfs_allow = 0;
820 }
821
822 return 0;
823}
824early_param("debugfs", debugfs_kernel);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700825static int __init debugfs_init(void)
826{
827 int retval;
828
Peter Enderborga24c6f72020-07-16 09:15:11 +0200829 if (!(debugfs_allow & DEBUGFS_ALLOW_MOUNT))
830 return -EPERM;
831
Eric W. Biedermanf9bb4882015-05-13 17:35:41 -0500832 retval = sysfs_create_mount_point(kernel_kobj, "debug");
833 if (retval)
834 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700835
836 retval = register_filesystem(&debug_fs_type);
837 if (retval)
Eric W. Biedermanf9bb4882015-05-13 17:35:41 -0500838 sysfs_remove_mount_point(kernel_kobj, "debug");
Frederic Weisbeckerc0f92ba2009-03-22 23:10:44 +0100839 else
840 debugfs_registered = true;
841
Linus Torvalds1da177e2005-04-16 15:20:36 -0700842 return retval;
843}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700844core_initcall(debugfs_init);