blob: 9dca4da059b322fdb42e611999b4a507cc974bf1 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Harry Weibd33d122011-07-16 16:45:13 +08002 * inode.c - part of debugfs, a tiny little debug file system
Linus Torvalds1da177e2005-04-16 15:20:36 -07003 *
4 * Copyright (C) 2004 Greg Kroah-Hartman <greg@kroah.com>
5 * Copyright (C) 2004 IBM Inc.
6 *
7 * This program is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License version
9 * 2 as published by the Free Software Foundation.
10 *
11 * debugfs is for people to use instead of /proc or /sys.
Mauro Carvalho Chehabe1511a82017-05-14 12:09:53 -030012 * See ./Documentation/core-api/kernel-api.rst for more details.
Linus Torvalds1da177e2005-04-16 15:20:36 -070013 *
14 */
15
Linus Torvalds1da177e2005-04-16 15:20:36 -070016#include <linux/module.h>
17#include <linux/fs.h>
18#include <linux/mount.h>
19#include <linux/pagemap.h>
20#include <linux/init.h>
Randy Dunlap4d8ebdd2006-11-25 11:09:26 -080021#include <linux/kobject.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070022#include <linux/namei.h>
23#include <linux/debugfs.h>
Mathieu Desnoyers4f365572006-11-24 13:45:37 -050024#include <linux/fsnotify.h>
Peter Oberparleiter66f54962007-02-13 12:13:54 +010025#include <linux/string.h>
Ludwig Nusseld6e48682012-01-25 11:52:28 +010026#include <linux/seq_file.h>
27#include <linux/parser.h>
Mimi Zohar92562922008-10-07 14:00:12 -040028#include <linux/magic.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090029#include <linux/slab.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;
Linus Torvalds1da177e2005-04-16 15:20:36 -070038
Al Viroedac65ea2015-01-25 14:36:18 -050039static struct inode *debugfs_get_inode(struct super_block *sb)
Linus Torvalds1da177e2005-04-16 15:20:36 -070040{
41 struct inode *inode = new_inode(sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -070042 if (inode) {
Christoph Hellwig85fe4022010-10-23 11:19:54 -040043 inode->i_ino = get_next_ino();
Deepa Dinamani1b48b532016-02-22 07:17:47 -080044 inode->i_atime = inode->i_mtime =
Deepa Dinamanic2050a42016-09-14 07:48:06 -070045 inode->i_ctime = current_time(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -070046 }
Rahul Bedarkar88e412e2014-06-06 23:12:04 +053047 return inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -070048}
49
Ludwig Nusseld6e48682012-01-25 11:52:28 +010050struct debugfs_mount_opts {
Eric W. Biederman7dc05882012-04-03 14:01:31 -070051 kuid_t uid;
52 kgid_t gid;
Ludwig Nusseld6e48682012-01-25 11:52:28 +010053 umode_t mode;
54};
55
56enum {
57 Opt_uid,
58 Opt_gid,
59 Opt_mode,
60 Opt_err
61};
62
63static const match_table_t tokens = {
64 {Opt_uid, "uid=%u"},
65 {Opt_gid, "gid=%u"},
66 {Opt_mode, "mode=%o"},
67 {Opt_err, NULL}
68};
69
70struct debugfs_fs_info {
71 struct debugfs_mount_opts mount_opts;
72};
73
74static int debugfs_parse_options(char *data, struct debugfs_mount_opts *opts)
75{
76 substring_t args[MAX_OPT_ARGS];
77 int option;
78 int token;
Eric W. Biederman7dc05882012-04-03 14:01:31 -070079 kuid_t uid;
80 kgid_t gid;
Ludwig Nusseld6e48682012-01-25 11:52:28 +010081 char *p;
82
83 opts->mode = DEBUGFS_DEFAULT_MODE;
84
85 while ((p = strsep(&data, ",")) != NULL) {
86 if (!*p)
87 continue;
88
89 token = match_token(p, tokens, args);
90 switch (token) {
91 case Opt_uid:
92 if (match_int(&args[0], &option))
93 return -EINVAL;
Eric W. Biederman7dc05882012-04-03 14:01:31 -070094 uid = make_kuid(current_user_ns(), option);
95 if (!uid_valid(uid))
96 return -EINVAL;
97 opts->uid = uid;
Ludwig Nusseld6e48682012-01-25 11:52:28 +010098 break;
99 case Opt_gid:
Dave Reisnerf1688e02013-01-02 08:54:37 -0500100 if (match_int(&args[0], &option))
Ludwig Nusseld6e48682012-01-25 11:52:28 +0100101 return -EINVAL;
Eric W. Biederman7dc05882012-04-03 14:01:31 -0700102 gid = make_kgid(current_user_ns(), option);
103 if (!gid_valid(gid))
104 return -EINVAL;
105 opts->gid = gid;
Ludwig Nusseld6e48682012-01-25 11:52:28 +0100106 break;
107 case Opt_mode:
108 if (match_octal(&args[0], &option))
109 return -EINVAL;
110 opts->mode = option & S_IALLUGO;
111 break;
112 /*
113 * We might like to report bad mount options here;
114 * but traditionally debugfs has ignored all mount options
115 */
116 }
117 }
118
119 return 0;
120}
121
122static int debugfs_apply_options(struct super_block *sb)
123{
124 struct debugfs_fs_info *fsi = sb->s_fs_info;
David Howells2b0143b2015-03-17 22:25:59 +0000125 struct inode *inode = d_inode(sb->s_root);
Ludwig Nusseld6e48682012-01-25 11:52:28 +0100126 struct debugfs_mount_opts *opts = &fsi->mount_opts;
127
128 inode->i_mode &= ~S_IALLUGO;
129 inode->i_mode |= opts->mode;
130
131 inode->i_uid = opts->uid;
132 inode->i_gid = opts->gid;
133
134 return 0;
135}
136
137static int debugfs_remount(struct super_block *sb, int *flags, char *data)
138{
139 int err;
140 struct debugfs_fs_info *fsi = sb->s_fs_info;
141
Theodore Ts'o02b99842014-03-13 10:14:33 -0400142 sync_filesystem(sb);
Ludwig Nusseld6e48682012-01-25 11:52:28 +0100143 err = debugfs_parse_options(data, &fsi->mount_opts);
144 if (err)
145 goto fail;
146
147 debugfs_apply_options(sb);
148
149fail:
150 return err;
151}
152
153static int debugfs_show_options(struct seq_file *m, struct dentry *root)
154{
155 struct debugfs_fs_info *fsi = root->d_sb->s_fs_info;
156 struct debugfs_mount_opts *opts = &fsi->mount_opts;
157
Eric W. Biederman7dc05882012-04-03 14:01:31 -0700158 if (!uid_eq(opts->uid, GLOBAL_ROOT_UID))
159 seq_printf(m, ",uid=%u",
160 from_kuid_munged(&init_user_ns, opts->uid));
161 if (!gid_eq(opts->gid, GLOBAL_ROOT_GID))
162 seq_printf(m, ",gid=%u",
163 from_kgid_munged(&init_user_ns, opts->gid));
Ludwig Nusseld6e48682012-01-25 11:52:28 +0100164 if (opts->mode != DEBUGFS_DEFAULT_MODE)
165 seq_printf(m, ",mode=%o", opts->mode);
166
167 return 0;
168}
169
Al Viro0db59e52015-02-21 22:05:11 -0500170static void debugfs_evict_inode(struct inode *inode)
171{
172 truncate_inode_pages_final(&inode->i_data);
173 clear_inode(inode);
174 if (S_ISLNK(inode->i_mode))
Al Viro5723cb02015-05-02 10:27:18 -0400175 kfree(inode->i_link);
Al Viro0db59e52015-02-21 22:05:11 -0500176}
177
Ludwig Nusseld6e48682012-01-25 11:52:28 +0100178static const struct super_operations debugfs_super_operations = {
179 .statfs = simple_statfs,
180 .remount_fs = debugfs_remount,
181 .show_options = debugfs_show_options,
Al Viro0db59e52015-02-21 22:05:11 -0500182 .evict_inode = debugfs_evict_inode,
Ludwig Nusseld6e48682012-01-25 11:52:28 +0100183};
184
Nicolai Stange7c8d4692017-10-31 00:15:47 +0100185static void debugfs_release_dentry(struct dentry *dentry)
186{
Nicolai Stange7d39bc52017-10-31 00:15:54 +0100187 void *fsd = dentry->d_fsdata;
188
189 if (!((unsigned long)fsd & DEBUGFS_FSDATA_IS_REAL_FOPS_BIT))
190 kfree(dentry->d_fsdata);
Nicolai Stange7c8d4692017-10-31 00:15:47 +0100191}
192
Al Viro77b3da62015-01-25 15:10:32 -0500193static struct vfsmount *debugfs_automount(struct path *path)
194{
Eric W. Biederman93faccbb2017-02-01 06:06:16 +1300195 debugfs_automount_t f;
196 f = (debugfs_automount_t)path->dentry->d_fsdata;
197 return f(path->dentry, d_inode(path->dentry)->i_private);
Al Viro77b3da62015-01-25 15:10:32 -0500198}
199
200static const struct dentry_operations debugfs_dops = {
201 .d_delete = always_delete_dentry,
Nicolai Stange7c8d4692017-10-31 00:15:47 +0100202 .d_release = debugfs_release_dentry,
Al Viro77b3da62015-01-25 15:10:32 -0500203 .d_automount = debugfs_automount,
204};
205
Linus Torvalds1da177e2005-04-16 15:20:36 -0700206static int debug_fill_super(struct super_block *sb, void *data, int silent)
207{
Eric Biggerscda37122017-03-25 21:15:37 -0700208 static const struct tree_descr debug_files[] = {{""}};
Ludwig Nusseld6e48682012-01-25 11:52:28 +0100209 struct debugfs_fs_info *fsi;
210 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700211
Ludwig Nusseld6e48682012-01-25 11:52:28 +0100212 fsi = kzalloc(sizeof(struct debugfs_fs_info), GFP_KERNEL);
213 sb->s_fs_info = fsi;
214 if (!fsi) {
215 err = -ENOMEM;
216 goto fail;
217 }
218
219 err = debugfs_parse_options(data, &fsi->mount_opts);
220 if (err)
221 goto fail;
222
223 err = simple_fill_super(sb, DEBUGFS_MAGIC, debug_files);
224 if (err)
225 goto fail;
226
227 sb->s_op = &debugfs_super_operations;
Al Viro77b3da62015-01-25 15:10:32 -0500228 sb->s_d_op = &debugfs_dops;
Ludwig Nusseld6e48682012-01-25 11:52:28 +0100229
230 debugfs_apply_options(sb);
231
232 return 0;
233
234fail:
235 kfree(fsi);
236 sb->s_fs_info = NULL;
237 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700238}
239
Al Virofc14f2f2010-07-25 01:48:30 +0400240static struct dentry *debug_mount(struct file_system_type *fs_type,
David Howells454e2392006-06-23 02:02:57 -0700241 int flags, const char *dev_name,
Al Virofc14f2f2010-07-25 01:48:30 +0400242 void *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700243{
Al Virofc14f2f2010-07-25 01:48:30 +0400244 return mount_single(fs_type, flags, data, debug_fill_super);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700245}
246
247static struct file_system_type debug_fs_type = {
248 .owner = THIS_MODULE,
249 .name = "debugfs",
Al Virofc14f2f2010-07-25 01:48:30 +0400250 .mount = debug_mount,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700251 .kill_sb = kill_litter_super,
252};
Eric W. Biederman7f78e032013-03-02 19:39:14 -0800253MODULE_ALIAS_FS("debugfs");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700254
Omar Sandovala7c54372017-01-31 14:53:17 -0800255/**
256 * debugfs_lookup() - look up an existing debugfs file
257 * @name: a pointer to a string containing the name of the file to look up.
258 * @parent: a pointer to the parent dentry of the file.
259 *
260 * This function will return a pointer to a dentry if it succeeds. If the file
261 * doesn't exist or an error occurs, %NULL will be returned. The returned
262 * dentry must be passed to dput() when it is no longer needed.
263 *
264 * If debugfs is not enabled in the kernel, the value -%ENODEV will be
265 * returned.
266 */
267struct dentry *debugfs_lookup(const char *name, struct dentry *parent)
268{
269 struct dentry *dentry;
270
271 if (IS_ERR(parent))
272 return NULL;
273
274 if (!parent)
275 parent = debugfs_mount->mnt_root;
276
277 inode_lock(d_inode(parent));
278 dentry = lookup_one_len(name, parent, strlen(name));
279 inode_unlock(d_inode(parent));
280
281 if (IS_ERR(dentry))
282 return NULL;
283 if (!d_really_is_positive(dentry)) {
284 dput(dentry);
285 return NULL;
286 }
287 return dentry;
288}
289EXPORT_SYMBOL_GPL(debugfs_lookup);
290
Al Viro190afd82015-01-25 13:55:55 -0500291static struct dentry *start_creating(const char *name, struct dentry *parent)
Al Viroc3b1a352012-06-09 20:28:22 -0400292{
Al Viro190afd82015-01-25 13:55:55 -0500293 struct dentry *dentry;
Al Viroc3b1a352012-06-09 20:28:22 -0400294 int error;
295
296 pr_debug("debugfs: creating file '%s'\n",name);
297
Greg KHc9e15f22015-03-30 14:59:15 +0200298 if (IS_ERR(parent))
299 return parent;
300
Al Viroc3b1a352012-06-09 20:28:22 -0400301 error = simple_pin_fs(&debug_fs_type, &debugfs_mount,
302 &debugfs_mount_count);
303 if (error)
Al Viro190afd82015-01-25 13:55:55 -0500304 return ERR_PTR(error);
Al Viroc3b1a352012-06-09 20:28:22 -0400305
Al Virocfa57c12012-06-09 20:33:28 -0400306 /* If the parent is not specified, we create it in the root.
Rahul Bedarkar88e412e2014-06-06 23:12:04 +0530307 * We need the root dentry to do this, which is in the super
Al Virocfa57c12012-06-09 20:33:28 -0400308 * block. A pointer to that is in the struct vfsmount that we
309 * have around.
310 */
311 if (!parent)
312 parent = debugfs_mount->mnt_root;
313
Al Viro59551022016-01-22 15:40:57 -0500314 inode_lock(d_inode(parent));
Al Virocfa57c12012-06-09 20:33:28 -0400315 dentry = lookup_one_len(name, parent, strlen(name));
David Howells2b0143b2015-03-17 22:25:59 +0000316 if (!IS_ERR(dentry) && d_really_is_positive(dentry)) {
Al Virocfa57c12012-06-09 20:33:28 -0400317 dput(dentry);
Al Viro190afd82015-01-25 13:55:55 -0500318 dentry = ERR_PTR(-EEXIST);
319 }
Daniel Borkmann0ee96082015-11-05 00:01:51 +0100320
321 if (IS_ERR(dentry)) {
Al Viro59551022016-01-22 15:40:57 -0500322 inode_unlock(d_inode(parent));
Daniel Borkmann0ee96082015-11-05 00:01:51 +0100323 simple_release_fs(&debugfs_mount, &debugfs_mount_count);
324 }
325
Al Viro190afd82015-01-25 13:55:55 -0500326 return dentry;
327}
328
Al Viro5233e312015-01-25 14:39:49 -0500329static struct dentry *failed_creating(struct dentry *dentry)
Al Viro190afd82015-01-25 13:55:55 -0500330{
Al Viro59551022016-01-22 15:40:57 -0500331 inode_unlock(d_inode(dentry->d_parent));
Al Viro190afd82015-01-25 13:55:55 -0500332 dput(dentry);
Al Viro5233e312015-01-25 14:39:49 -0500333 simple_release_fs(&debugfs_mount, &debugfs_mount_count);
334 return NULL;
335}
Al Virocfa57c12012-06-09 20:33:28 -0400336
Al Viro5233e312015-01-25 14:39:49 -0500337static struct dentry *end_creating(struct dentry *dentry)
338{
Al Viro59551022016-01-22 15:40:57 -0500339 inode_unlock(d_inode(dentry->d_parent));
Al Viroc3b1a352012-06-09 20:28:22 -0400340 return dentry;
341}
342
Nicolai Stange49d200d2016-03-22 14:11:14 +0100343static struct dentry *__debugfs_create_file(const char *name, umode_t mode,
344 struct dentry *parent, void *data,
345 const struct file_operations *proxy_fops,
346 const struct file_operations *real_fops)
347{
348 struct dentry *dentry;
349 struct inode *inode;
350
351 if (!(mode & S_IFMT))
352 mode |= S_IFREG;
353 BUG_ON(!S_ISREG(mode));
354 dentry = start_creating(name, parent);
355
Nicolai Stange7d39bc52017-10-31 00:15:54 +0100356 if (IS_ERR(dentry))
Nicolai Stange49d200d2016-03-22 14:11:14 +0100357 return NULL;
358
359 inode = debugfs_get_inode(dentry->d_sb);
Nicolai Stange7d39bc52017-10-31 00:15:54 +0100360 if (unlikely(!inode))
Nicolai Stange49d200d2016-03-22 14:11:14 +0100361 return failed_creating(dentry);
362
363 inode->i_mode = mode;
364 inode->i_private = data;
365
366 inode->i_fop = proxy_fops;
Nicolai Stange7d39bc52017-10-31 00:15:54 +0100367 dentry->d_fsdata = (void *)((unsigned long)real_fops |
368 DEBUGFS_FSDATA_IS_REAL_FOPS_BIT);
Nicolai Stange49d200d2016-03-22 14:11:14 +0100369
370 d_instantiate(dentry, inode);
371 fsnotify_create(d_inode(dentry->d_parent), dentry);
372 return end_creating(dentry);
373}
374
Linus Torvalds1da177e2005-04-16 15:20:36 -0700375/**
376 * debugfs_create_file - create a file in the debugfs filesystem
Linus Torvalds1da177e2005-04-16 15:20:36 -0700377 * @name: a pointer to a string containing the name of the file to create.
Alberto Bertoglibe030e62009-10-31 18:26:52 -0300378 * @mode: the permission that the file should have.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379 * @parent: a pointer to the parent dentry for this file. This should be a
Masanari Iidae2278672014-02-18 22:54:36 +0900380 * directory dentry if set. If this parameter is NULL, then the
Linus Torvalds1da177e2005-04-16 15:20:36 -0700381 * file will be created in the root of the debugfs filesystem.
382 * @data: a pointer to something that the caller will want to get to later
Theodore Ts'o8e18e292006-09-27 01:50:46 -0700383 * on. The inode.i_private pointer will point to this value on
Linus Torvalds1da177e2005-04-16 15:20:36 -0700384 * the open() call.
385 * @fops: a pointer to a struct file_operations that should be used for
386 * this file.
387 *
388 * This is the basic "create a file" function for debugfs. It allows for a
Alberto Bertoglibe030e62009-10-31 18:26:52 -0300389 * wide range of flexibility in creating a file, or a directory (if you want
390 * to create a directory, the debugfs_create_dir() function is
Linus Torvalds1da177e2005-04-16 15:20:36 -0700391 * recommended to be used instead.)
392 *
393 * This function will return a pointer to a dentry if it succeeds. This
394 * pointer must be passed to the debugfs_remove() function when the file is
395 * to be removed (no automatic cleanup happens if your module is unloaded,
Randy Dunlap6468b3a2006-07-20 08:16:42 -0700396 * you are responsible here.) If an error occurs, %NULL will be returned.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700397 *
Randy Dunlap6468b3a2006-07-20 08:16:42 -0700398 * If debugfs is not enabled in the kernel, the value -%ENODEV will be
Cornelia Huck873760f2007-02-14 07:57:47 +0100399 * returned.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400 */
Al Virof4ae40a62011-07-24 04:33:43 -0400401struct dentry *debugfs_create_file(const char *name, umode_t mode,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700402 struct dentry *parent, void *data,
Arjan van de Ven99ac48f2006-03-28 01:56:41 -0800403 const struct file_operations *fops)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700404{
Al Viroc3b1a352012-06-09 20:28:22 -0400405
Nicolai Stange49d200d2016-03-22 14:11:14 +0100406 return __debugfs_create_file(name, mode, parent, data,
407 fops ? &debugfs_full_proxy_file_operations :
408 &debugfs_noop_file_operations,
409 fops);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700410}
411EXPORT_SYMBOL_GPL(debugfs_create_file);
412
Nicolai Stangec6468802016-03-22 14:11:15 +0100413/**
414 * debugfs_create_file_unsafe - create a file in the debugfs filesystem
415 * @name: a pointer to a string containing the name of the file to create.
416 * @mode: the permission that the file should have.
417 * @parent: a pointer to the parent dentry for this file. This should be a
418 * directory dentry if set. If this parameter is NULL, then the
419 * file will be created in the root of the debugfs filesystem.
420 * @data: a pointer to something that the caller will want to get to later
421 * on. The inode.i_private pointer will point to this value on
422 * the open() call.
423 * @fops: a pointer to a struct file_operations that should be used for
424 * this file.
425 *
426 * debugfs_create_file_unsafe() is completely analogous to
427 * debugfs_create_file(), the only difference being that the fops
428 * handed it will not get protected against file removals by the
429 * debugfs core.
430 *
431 * It is your responsibility to protect your struct file_operation
432 * methods against file removals by means of debugfs_use_file_start()
433 * and debugfs_use_file_finish(). ->open() is still protected by
434 * debugfs though.
435 *
436 * Any struct file_operations defined by means of
437 * DEFINE_DEBUGFS_ATTRIBUTE() is protected against file removals and
438 * thus, may be used here.
439 */
Nicolai Stange49d200d2016-03-22 14:11:14 +0100440struct dentry *debugfs_create_file_unsafe(const char *name, umode_t mode,
441 struct dentry *parent, void *data,
442 const struct file_operations *fops)
443{
444
445 return __debugfs_create_file(name, mode, parent, data,
446 fops ? &debugfs_open_proxy_file_operations :
447 &debugfs_noop_file_operations,
448 fops);
449}
Nicolai Stangec6468802016-03-22 14:11:15 +0100450EXPORT_SYMBOL_GPL(debugfs_create_file_unsafe);
Nicolai Stange49d200d2016-03-22 14:11:14 +0100451
Linus Torvalds1da177e2005-04-16 15:20:36 -0700452/**
David Howellse59b4e92015-01-21 20:03:40 +0000453 * debugfs_create_file_size - create a file in the debugfs filesystem
454 * @name: a pointer to a string containing the name of the file to create.
455 * @mode: the permission that the file should have.
456 * @parent: a pointer to the parent dentry for this file. This should be a
457 * directory dentry if set. If this parameter is NULL, then the
458 * file will be created in the root of the debugfs filesystem.
459 * @data: a pointer to something that the caller will want to get to later
460 * on. The inode.i_private pointer will point to this value on
461 * the open() call.
462 * @fops: a pointer to a struct file_operations that should be used for
463 * this file.
464 * @file_size: initial file size
465 *
466 * This is the basic "create a file" function for debugfs. It allows for a
467 * wide range of flexibility in creating a file, or a directory (if you want
468 * to create a directory, the debugfs_create_dir() function is
469 * recommended to be used instead.)
470 *
471 * This function will return a pointer to a dentry if it succeeds. This
472 * pointer must be passed to the debugfs_remove() function when the file is
473 * to be removed (no automatic cleanup happens if your module is unloaded,
474 * you are responsible here.) If an error occurs, %NULL will be returned.
475 *
476 * If debugfs is not enabled in the kernel, the value -%ENODEV will be
477 * returned.
478 */
479struct dentry *debugfs_create_file_size(const char *name, umode_t mode,
480 struct dentry *parent, void *data,
481 const struct file_operations *fops,
482 loff_t file_size)
483{
484 struct dentry *de = debugfs_create_file(name, mode, parent, data, fops);
485
486 if (de)
David Howells2b0143b2015-03-17 22:25:59 +0000487 d_inode(de)->i_size = file_size;
David Howellse59b4e92015-01-21 20:03:40 +0000488 return de;
489}
490EXPORT_SYMBOL_GPL(debugfs_create_file_size);
491
492/**
Linus Torvalds1da177e2005-04-16 15:20:36 -0700493 * debugfs_create_dir - create a directory in the debugfs filesystem
Linus Torvalds1da177e2005-04-16 15:20:36 -0700494 * @name: a pointer to a string containing the name of the directory to
495 * create.
496 * @parent: a pointer to the parent dentry for this file. This should be a
Masanari Iidae2278672014-02-18 22:54:36 +0900497 * directory dentry if set. If this parameter is NULL, then the
Linus Torvalds1da177e2005-04-16 15:20:36 -0700498 * directory will be created in the root of the debugfs filesystem.
499 *
500 * This function creates a directory in debugfs with the given name.
501 *
502 * This function will return a pointer to a dentry if it succeeds. This
503 * pointer must be passed to the debugfs_remove() function when the file is
504 * to be removed (no automatic cleanup happens if your module is unloaded,
Randy Dunlap6468b3a2006-07-20 08:16:42 -0700505 * you are responsible here.) If an error occurs, %NULL will be returned.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700506 *
Randy Dunlap6468b3a2006-07-20 08:16:42 -0700507 * If debugfs is not enabled in the kernel, the value -%ENODEV will be
Cornelia Huck873760f2007-02-14 07:57:47 +0100508 * returned.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700509 */
510struct dentry *debugfs_create_dir(const char *name, struct dentry *parent)
511{
Al Viroad5abd52015-01-25 14:02:31 -0500512 struct dentry *dentry = start_creating(name, parent);
Al Viro680b3022015-01-25 14:31:32 -0500513 struct inode *inode;
Al Viroad5abd52015-01-25 14:02:31 -0500514
515 if (IS_ERR(dentry))
516 return NULL;
517
Al Viroedac65ea2015-01-25 14:36:18 -0500518 inode = debugfs_get_inode(dentry->d_sb);
Al Viro680b3022015-01-25 14:31:32 -0500519 if (unlikely(!inode))
Al Viro5233e312015-01-25 14:39:49 -0500520 return failed_creating(dentry);
Al Viro680b3022015-01-25 14:31:32 -0500521
Al Viroedac65ea2015-01-25 14:36:18 -0500522 inode->i_mode = S_IFDIR | S_IRWXU | S_IRUGO | S_IXUGO;
523 inode->i_op = &simple_dir_inode_operations;
524 inode->i_fop = &simple_dir_operations;
525
526 /* directory inodes start off with i_nlink == 2 (for "." entry) */
527 inc_nlink(inode);
Al Viro680b3022015-01-25 14:31:32 -0500528 d_instantiate(dentry, inode);
David Howells2b0143b2015-03-17 22:25:59 +0000529 inc_nlink(d_inode(dentry->d_parent));
530 fsnotify_mkdir(d_inode(dentry->d_parent), dentry);
Al Viro5233e312015-01-25 14:39:49 -0500531 return end_creating(dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700532}
533EXPORT_SYMBOL_GPL(debugfs_create_dir);
534
535/**
Al Viro77b3da62015-01-25 15:10:32 -0500536 * debugfs_create_automount - create automount point in the debugfs filesystem
537 * @name: a pointer to a string containing the name of the file to create.
538 * @parent: a pointer to the parent dentry for this file. This should be a
539 * directory dentry if set. If this parameter is NULL, then the
540 * file will be created in the root of the debugfs filesystem.
541 * @f: function to be called when pathname resolution steps on that one.
542 * @data: opaque argument to pass to f().
543 *
544 * @f should return what ->d_automount() would.
545 */
546struct dentry *debugfs_create_automount(const char *name,
547 struct dentry *parent,
Eric W. Biederman93faccbb2017-02-01 06:06:16 +1300548 debugfs_automount_t f,
Al Viro77b3da62015-01-25 15:10:32 -0500549 void *data)
550{
551 struct dentry *dentry = start_creating(name, parent);
552 struct inode *inode;
553
554 if (IS_ERR(dentry))
555 return NULL;
556
557 inode = debugfs_get_inode(dentry->d_sb);
558 if (unlikely(!inode))
559 return failed_creating(dentry);
560
Seth Forshee87243de2016-03-09 09:18:07 -0600561 make_empty_dir_inode(inode);
Al Viro77b3da62015-01-25 15:10:32 -0500562 inode->i_flags |= S_AUTOMOUNT;
563 inode->i_private = data;
564 dentry->d_fsdata = (void *)f;
Roman Pena8f324a2016-02-09 11:30:29 +0100565 /* directory inodes start off with i_nlink == 2 (for "." entry) */
566 inc_nlink(inode);
Al Viro77b3da62015-01-25 15:10:32 -0500567 d_instantiate(dentry, inode);
Roman Pena8f324a2016-02-09 11:30:29 +0100568 inc_nlink(d_inode(dentry->d_parent));
569 fsnotify_mkdir(d_inode(dentry->d_parent), dentry);
Al Viro77b3da62015-01-25 15:10:32 -0500570 return end_creating(dentry);
571}
572EXPORT_SYMBOL(debugfs_create_automount);
573
574/**
Peter Oberparleiter66f54962007-02-13 12:13:54 +0100575 * debugfs_create_symlink- create a symbolic link in the debugfs filesystem
576 * @name: a pointer to a string containing the name of the symbolic link to
577 * create.
578 * @parent: a pointer to the parent dentry for this symbolic link. This
Masanari Iidae2278672014-02-18 22:54:36 +0900579 * should be a directory dentry if set. If this parameter is NULL,
Peter Oberparleiter66f54962007-02-13 12:13:54 +0100580 * then the symbolic link will be created in the root of the debugfs
581 * filesystem.
582 * @target: a pointer to a string containing the path to the target of the
583 * symbolic link.
584 *
585 * This function creates a symbolic link with the given name in debugfs that
586 * links to the given target path.
587 *
588 * This function will return a pointer to a dentry if it succeeds. This
589 * pointer must be passed to the debugfs_remove() function when the symbolic
590 * link is to be removed (no automatic cleanup happens if your module is
591 * unloaded, you are responsible here.) If an error occurs, %NULL will be
592 * returned.
593 *
594 * If debugfs is not enabled in the kernel, the value -%ENODEV will be
Cornelia Huck873760f2007-02-14 07:57:47 +0100595 * returned.
Peter Oberparleiter66f54962007-02-13 12:13:54 +0100596 */
597struct dentry *debugfs_create_symlink(const char *name, struct dentry *parent,
598 const char *target)
599{
Al Viroad5abd52015-01-25 14:02:31 -0500600 struct dentry *dentry;
Al Viro680b3022015-01-25 14:31:32 -0500601 struct inode *inode;
602 char *link = kstrdup(target, GFP_KERNEL);
Peter Oberparleiter66f54962007-02-13 12:13:54 +0100603 if (!link)
604 return NULL;
605
Al Viroad5abd52015-01-25 14:02:31 -0500606 dentry = start_creating(name, parent);
Al Viroad5abd52015-01-25 14:02:31 -0500607 if (IS_ERR(dentry)) {
Peter Oberparleiter66f54962007-02-13 12:13:54 +0100608 kfree(link);
Al Viroad5abd52015-01-25 14:02:31 -0500609 return NULL;
610 }
611
Al Viroedac65ea2015-01-25 14:36:18 -0500612 inode = debugfs_get_inode(dentry->d_sb);
Al Viro680b3022015-01-25 14:31:32 -0500613 if (unlikely(!inode)) {
Al Viroad5abd52015-01-25 14:02:31 -0500614 kfree(link);
Al Viro5233e312015-01-25 14:39:49 -0500615 return failed_creating(dentry);
Al Viro680b3022015-01-25 14:31:32 -0500616 }
Al Viroedac65ea2015-01-25 14:36:18 -0500617 inode->i_mode = S_IFLNK | S_IRWXUGO;
Al Viro5723cb02015-05-02 10:27:18 -0400618 inode->i_op = &simple_symlink_inode_operations;
619 inode->i_link = link;
Al Viro680b3022015-01-25 14:31:32 -0500620 d_instantiate(dentry, inode);
Al Viro5233e312015-01-25 14:39:49 -0500621 return end_creating(dentry);
Peter Oberparleiter66f54962007-02-13 12:13:54 +0100622}
623EXPORT_SYMBOL_GPL(debugfs_create_symlink);
624
Nicolai Stangee9117a52017-10-31 00:15:48 +0100625static void __debugfs_remove_file(struct dentry *dentry, struct dentry *parent)
626{
627 struct debugfs_fsdata *fsd;
628
629 simple_unlink(d_inode(parent), dentry);
630 d_delete(dentry);
Nicolai Stange7d39bc52017-10-31 00:15:54 +0100631
632 /*
633 * Paired with the closing smp_mb() implied by a successful
634 * cmpxchg() in debugfs_file_get(): either
635 * debugfs_file_get() must see a dead dentry or we must see a
636 * debugfs_fsdata instance at ->d_fsdata here (or both).
637 */
638 smp_mb();
639 fsd = READ_ONCE(dentry->d_fsdata);
640 if ((unsigned long)fsd & DEBUGFS_FSDATA_IS_REAL_FOPS_BIT)
641 return;
Nicolai Stangee9117a52017-10-31 00:15:48 +0100642 if (!refcount_dec_and_test(&fsd->active_users))
643 wait_for_completion(&fsd->active_users_drained);
644}
645
Jan Kara25d41d82011-02-07 15:00:27 +0100646static int __debugfs_remove(struct dentry *dentry, struct dentry *parent)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700647{
Mathieu Desnoyers65c33332006-11-24 13:50:09 -0500648 int ret = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700649
Al Virodc3f4192015-05-18 10:10:34 -0400650 if (simple_positive(dentry)) {
Al Viro0db59e52015-02-21 22:05:11 -0500651 dget(dentry);
Nicolai Stangee9117a52017-10-31 00:15:48 +0100652 if (!d_is_reg(dentry)) {
653 if (d_is_dir(dentry))
654 ret = simple_rmdir(d_inode(parent), dentry);
655 else
656 simple_unlink(d_inode(parent), dentry);
657 if (!ret)
658 d_delete(dentry);
659 } else {
660 __debugfs_remove_file(dentry, parent);
661 }
Al Viro0db59e52015-02-21 22:05:11 -0500662 dput(dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700663 }
Jan Kara25d41d82011-02-07 15:00:27 +0100664 return ret;
Haavard Skinnemoen9505e632008-07-01 15:14:51 +0200665}
666
667/**
668 * debugfs_remove - removes a file or directory from the debugfs filesystem
669 * @dentry: a pointer to a the dentry of the file or directory to be
Ulf Magnusson398dc4a2015-09-07 19:03:15 +0200670 * removed. If this parameter is NULL or an error value, nothing
671 * will be done.
Haavard Skinnemoen9505e632008-07-01 15:14:51 +0200672 *
673 * This function removes a file or directory in debugfs that was previously
674 * created with a call to another debugfs function (like
675 * debugfs_create_file() or variants thereof.)
676 *
677 * This function is required to be called in order for the file to be
678 * removed, no automatic cleanup of files will happen when a module is
679 * removed, you are responsible here.
680 */
681void debugfs_remove(struct dentry *dentry)
682{
683 struct dentry *parent;
Jan Kara25d41d82011-02-07 15:00:27 +0100684 int ret;
685
Arend van Spriela59d6292012-05-23 15:13:07 +0200686 if (IS_ERR_OR_NULL(dentry))
Haavard Skinnemoen9505e632008-07-01 15:14:51 +0200687 return;
688
689 parent = dentry->d_parent;
Al Viro59551022016-01-22 15:40:57 -0500690 inode_lock(d_inode(parent));
Jan Kara25d41d82011-02-07 15:00:27 +0100691 ret = __debugfs_remove(dentry, parent);
Al Viro59551022016-01-22 15:40:57 -0500692 inode_unlock(d_inode(parent));
Jan Kara25d41d82011-02-07 15:00:27 +0100693 if (!ret)
694 simple_release_fs(&debugfs_mount, &debugfs_mount_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700695}
696EXPORT_SYMBOL_GPL(debugfs_remove);
697
Jan Karacfc94cd2007-05-09 13:19:52 +0200698/**
Haavard Skinnemoen9505e632008-07-01 15:14:51 +0200699 * debugfs_remove_recursive - recursively removes a directory
Ulf Magnusson398dc4a2015-09-07 19:03:15 +0200700 * @dentry: a pointer to a the dentry of the directory to be removed. If this
701 * parameter is NULL or an error value, nothing will be done.
Haavard Skinnemoen9505e632008-07-01 15:14:51 +0200702 *
703 * This function recursively removes a directory tree in debugfs that
704 * was previously created with a call to another debugfs function
705 * (like debugfs_create_file() or variants thereof.)
706 *
707 * This function is required to be called in order for the file to be
708 * removed, no automatic cleanup of files will happen when a module is
709 * removed, you are responsible here.
710 */
711void debugfs_remove_recursive(struct dentry *dentry)
712{
Steven Rostedt485d4402014-06-09 14:06:07 -0400713 struct dentry *child, *parent;
Haavard Skinnemoen9505e632008-07-01 15:14:51 +0200714
Arend van Spriela59d6292012-05-23 15:13:07 +0200715 if (IS_ERR_OR_NULL(dentry))
Haavard Skinnemoen9505e632008-07-01 15:14:51 +0200716 return;
717
Haavard Skinnemoen9505e632008-07-01 15:14:51 +0200718 parent = dentry;
Oleg Nesterov776164c2013-07-26 17:12:56 +0200719 down:
Al Viro59551022016-01-22 15:40:57 -0500720 inode_lock(d_inode(parent));
Steven Rostedt485d4402014-06-09 14:06:07 -0400721 loop:
722 /*
723 * The parent->d_subdirs is protected by the d_lock. Outside that
724 * lock, the child can be unlinked and set to be freed which can
725 * use the d_u.d_child as the rcu head and corrupt this list.
726 */
727 spin_lock(&parent->d_lock);
Al Viro946e51f2014-10-26 19:19:16 -0400728 list_for_each_entry(child, &parent->d_subdirs, d_child) {
Al Virodc3f4192015-05-18 10:10:34 -0400729 if (!simple_positive(child))
Oleg Nesterov776164c2013-07-26 17:12:56 +0200730 continue;
Haavard Skinnemoen9505e632008-07-01 15:14:51 +0200731
Oleg Nesterov776164c2013-07-26 17:12:56 +0200732 /* perhaps simple_empty(child) makes more sense */
Haavard Skinnemoen9505e632008-07-01 15:14:51 +0200733 if (!list_empty(&child->d_subdirs)) {
Steven Rostedt485d4402014-06-09 14:06:07 -0400734 spin_unlock(&parent->d_lock);
Al Viro59551022016-01-22 15:40:57 -0500735 inode_unlock(d_inode(parent));
Haavard Skinnemoen9505e632008-07-01 15:14:51 +0200736 parent = child;
Oleg Nesterov776164c2013-07-26 17:12:56 +0200737 goto down;
Haavard Skinnemoen9505e632008-07-01 15:14:51 +0200738 }
Steven Rostedt485d4402014-06-09 14:06:07 -0400739
740 spin_unlock(&parent->d_lock);
741
Oleg Nesterov776164c2013-07-26 17:12:56 +0200742 if (!__debugfs_remove(child, parent))
743 simple_release_fs(&debugfs_mount, &debugfs_mount_count);
Steven Rostedt485d4402014-06-09 14:06:07 -0400744
745 /*
746 * The parent->d_lock protects agaist child from unlinking
747 * from d_subdirs. When releasing the parent->d_lock we can
748 * no longer trust that the next pointer is valid.
749 * Restart the loop. We'll skip this one with the
Al Virodc3f4192015-05-18 10:10:34 -0400750 * simple_positive() check.
Steven Rostedt485d4402014-06-09 14:06:07 -0400751 */
752 goto loop;
Haavard Skinnemoen9505e632008-07-01 15:14:51 +0200753 }
Steven Rostedt485d4402014-06-09 14:06:07 -0400754 spin_unlock(&parent->d_lock);
Haavard Skinnemoen9505e632008-07-01 15:14:51 +0200755
Al Viro59551022016-01-22 15:40:57 -0500756 inode_unlock(d_inode(parent));
Oleg Nesterov776164c2013-07-26 17:12:56 +0200757 child = parent;
758 parent = parent->d_parent;
Al Viro59551022016-01-22 15:40:57 -0500759 inode_lock(d_inode(parent));
Oleg Nesterov776164c2013-07-26 17:12:56 +0200760
Steven Rostedt485d4402014-06-09 14:06:07 -0400761 if (child != dentry)
762 /* go up */
763 goto loop;
Oleg Nesterov776164c2013-07-26 17:12:56 +0200764
765 if (!__debugfs_remove(child, parent))
766 simple_release_fs(&debugfs_mount, &debugfs_mount_count);
Al Viro59551022016-01-22 15:40:57 -0500767 inode_unlock(d_inode(parent));
Haavard Skinnemoen9505e632008-07-01 15:14:51 +0200768}
769EXPORT_SYMBOL_GPL(debugfs_remove_recursive);
770
771/**
Jan Karacfc94cd2007-05-09 13:19:52 +0200772 * debugfs_rename - rename a file/directory in the debugfs filesystem
773 * @old_dir: a pointer to the parent dentry for the renamed object. This
774 * should be a directory dentry.
775 * @old_dentry: dentry of an object to be renamed.
776 * @new_dir: a pointer to the parent dentry where the object should be
777 * moved. This should be a directory dentry.
778 * @new_name: a pointer to a string containing the target name.
779 *
780 * This function renames a file/directory in debugfs. The target must not
781 * exist for rename to succeed.
782 *
783 * This function will return a pointer to old_dentry (which is updated to
784 * reflect renaming) if it succeeds. If an error occurs, %NULL will be
785 * returned.
786 *
787 * If debugfs is not enabled in the kernel, the value -%ENODEV will be
788 * returned.
789 */
790struct dentry *debugfs_rename(struct dentry *old_dir, struct dentry *old_dentry,
791 struct dentry *new_dir, const char *new_name)
792{
793 int error;
794 struct dentry *dentry = NULL, *trap;
Al Viro49d31c22017-07-07 14:51:19 -0400795 struct name_snapshot old_name;
Jan Karacfc94cd2007-05-09 13:19:52 +0200796
797 trap = lock_rename(new_dir, old_dir);
798 /* Source or destination directories don't exist? */
David Howells2b0143b2015-03-17 22:25:59 +0000799 if (d_really_is_negative(old_dir) || d_really_is_negative(new_dir))
Jan Karacfc94cd2007-05-09 13:19:52 +0200800 goto exit;
801 /* Source does not exist, cyclic rename, or mountpoint? */
David Howells2b0143b2015-03-17 22:25:59 +0000802 if (d_really_is_negative(old_dentry) || old_dentry == trap ||
Jan Karacfc94cd2007-05-09 13:19:52 +0200803 d_mountpoint(old_dentry))
804 goto exit;
805 dentry = lookup_one_len(new_name, new_dir, strlen(new_name));
806 /* Lookup failed, cyclic rename or target exists? */
David Howells2b0143b2015-03-17 22:25:59 +0000807 if (IS_ERR(dentry) || dentry == trap || d_really_is_positive(dentry))
Jan Karacfc94cd2007-05-09 13:19:52 +0200808 goto exit;
809
Al Viro49d31c22017-07-07 14:51:19 -0400810 take_dentry_name_snapshot(&old_name, old_dentry);
Jan Karacfc94cd2007-05-09 13:19:52 +0200811
David Howells2b0143b2015-03-17 22:25:59 +0000812 error = simple_rename(d_inode(old_dir), old_dentry, d_inode(new_dir),
Miklos Szeredie0e0be82016-09-27 11:03:57 +0200813 dentry, 0);
Jan Karacfc94cd2007-05-09 13:19:52 +0200814 if (error) {
Al Viro49d31c22017-07-07 14:51:19 -0400815 release_dentry_name_snapshot(&old_name);
Jan Karacfc94cd2007-05-09 13:19:52 +0200816 goto exit;
817 }
818 d_move(old_dentry, dentry);
Al Viro49d31c22017-07-07 14:51:19 -0400819 fsnotify_move(d_inode(old_dir), d_inode(new_dir), old_name.name,
David Howellse36cb0b2015-01-29 12:02:35 +0000820 d_is_dir(old_dentry),
Al Viro5a190ae2007-06-07 12:19:32 -0400821 NULL, old_dentry);
Al Viro49d31c22017-07-07 14:51:19 -0400822 release_dentry_name_snapshot(&old_name);
Jan Karacfc94cd2007-05-09 13:19:52 +0200823 unlock_rename(new_dir, old_dir);
824 dput(dentry);
825 return old_dentry;
826exit:
827 if (dentry && !IS_ERR(dentry))
828 dput(dentry);
829 unlock_rename(new_dir, old_dir);
830 return NULL;
831}
832EXPORT_SYMBOL_GPL(debugfs_rename);
833
Frederic Weisbeckerc0f92ba2009-03-22 23:10:44 +0100834/**
835 * debugfs_initialized - Tells whether debugfs has been registered
836 */
837bool debugfs_initialized(void)
838{
839 return debugfs_registered;
840}
841EXPORT_SYMBOL_GPL(debugfs_initialized);
842
Linus Torvalds1da177e2005-04-16 15:20:36 -0700843static int __init debugfs_init(void)
844{
845 int retval;
846
Eric W. Biedermanf9bb4882015-05-13 17:35:41 -0500847 retval = sysfs_create_mount_point(kernel_kobj, "debug");
848 if (retval)
849 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700850
851 retval = register_filesystem(&debug_fs_type);
852 if (retval)
Eric W. Biedermanf9bb4882015-05-13 17:35:41 -0500853 sysfs_remove_mount_point(kernel_kobj, "debug");
Frederic Weisbeckerc0f92ba2009-03-22 23:10:44 +0100854 else
855 debugfs_registered = true;
856
Linus Torvalds1da177e2005-04-16 15:20:36 -0700857 return retval;
858}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700859core_initcall(debugfs_init);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700860