blob: 3d7de9f4f54520a9b4540121834233be19c6e10d [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.
12 * See Documentation/DocBook/kernel-api for more details.
13 *
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#include <linux/srcu.h>
31
32#include "internal.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070033
Kees Cook82aceae42012-08-27 13:32:15 -070034#define DEBUGFS_DEFAULT_MODE 0700
Ludwig Nusseld6e48682012-01-25 11:52:28 +010035
Nicolai Stange9fd4dce2016-03-22 14:11:13 +010036DEFINE_SRCU(debugfs_srcu);
37
Linus Torvalds1da177e2005-04-16 15:20:36 -070038static struct vfsmount *debugfs_mount;
39static int debugfs_mount_count;
Frederic Weisbeckerc0f92ba2009-03-22 23:10:44 +010040static bool debugfs_registered;
Linus Torvalds1da177e2005-04-16 15:20:36 -070041
Al Viroedac65e2015-01-25 14:36:18 -050042static struct inode *debugfs_get_inode(struct super_block *sb)
Linus Torvalds1da177e2005-04-16 15:20:36 -070043{
44 struct inode *inode = new_inode(sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -070045 if (inode) {
Christoph Hellwig85fe4022010-10-23 11:19:54 -040046 inode->i_ino = get_next_ino();
Deepa Dinamani1b48b532016-02-22 07:17:47 -080047 inode->i_atime = inode->i_mtime =
Deepa Dinamanic2050a42016-09-14 07:48:06 -070048 inode->i_ctime = current_time(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -070049 }
Rahul Bedarkar88e412e2014-06-06 23:12:04 +053050 return inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -070051}
52
Ludwig Nusseld6e48682012-01-25 11:52:28 +010053struct debugfs_mount_opts {
Eric W. Biederman7dc05882012-04-03 14:01:31 -070054 kuid_t uid;
55 kgid_t gid;
Ludwig Nusseld6e48682012-01-25 11:52:28 +010056 umode_t mode;
57};
58
59enum {
60 Opt_uid,
61 Opt_gid,
62 Opt_mode,
63 Opt_err
64};
65
66static const match_table_t tokens = {
67 {Opt_uid, "uid=%u"},
68 {Opt_gid, "gid=%u"},
69 {Opt_mode, "mode=%o"},
70 {Opt_err, NULL}
71};
72
73struct debugfs_fs_info {
74 struct debugfs_mount_opts mount_opts;
75};
76
77static int debugfs_parse_options(char *data, struct debugfs_mount_opts *opts)
78{
79 substring_t args[MAX_OPT_ARGS];
80 int option;
81 int token;
Eric W. Biederman7dc05882012-04-03 14:01:31 -070082 kuid_t uid;
83 kgid_t gid;
Ludwig Nusseld6e48682012-01-25 11:52:28 +010084 char *p;
85
86 opts->mode = DEBUGFS_DEFAULT_MODE;
87
88 while ((p = strsep(&data, ",")) != NULL) {
89 if (!*p)
90 continue;
91
92 token = match_token(p, tokens, args);
93 switch (token) {
94 case Opt_uid:
95 if (match_int(&args[0], &option))
96 return -EINVAL;
Eric W. Biederman7dc05882012-04-03 14:01:31 -070097 uid = make_kuid(current_user_ns(), option);
98 if (!uid_valid(uid))
99 return -EINVAL;
100 opts->uid = uid;
Ludwig Nusseld6e48682012-01-25 11:52:28 +0100101 break;
102 case Opt_gid:
Dave Reisnerf1688e02013-01-02 08:54:37 -0500103 if (match_int(&args[0], &option))
Ludwig Nusseld6e48682012-01-25 11:52:28 +0100104 return -EINVAL;
Eric W. Biederman7dc05882012-04-03 14:01:31 -0700105 gid = make_kgid(current_user_ns(), option);
106 if (!gid_valid(gid))
107 return -EINVAL;
108 opts->gid = gid;
Ludwig Nusseld6e48682012-01-25 11:52:28 +0100109 break;
110 case Opt_mode:
111 if (match_octal(&args[0], &option))
112 return -EINVAL;
113 opts->mode = option & S_IALLUGO;
114 break;
115 /*
116 * We might like to report bad mount options here;
117 * but traditionally debugfs has ignored all mount options
118 */
119 }
120 }
121
122 return 0;
123}
124
125static int debugfs_apply_options(struct super_block *sb)
126{
127 struct debugfs_fs_info *fsi = sb->s_fs_info;
David Howells2b0143b2015-03-17 22:25:59 +0000128 struct inode *inode = d_inode(sb->s_root);
Ludwig Nusseld6e48682012-01-25 11:52:28 +0100129 struct debugfs_mount_opts *opts = &fsi->mount_opts;
130
131 inode->i_mode &= ~S_IALLUGO;
132 inode->i_mode |= opts->mode;
133
134 inode->i_uid = opts->uid;
135 inode->i_gid = opts->gid;
136
137 return 0;
138}
139
140static int debugfs_remount(struct super_block *sb, int *flags, char *data)
141{
142 int err;
143 struct debugfs_fs_info *fsi = sb->s_fs_info;
144
Theodore Ts'o02b99842014-03-13 10:14:33 -0400145 sync_filesystem(sb);
Ludwig Nusseld6e48682012-01-25 11:52:28 +0100146 err = debugfs_parse_options(data, &fsi->mount_opts);
147 if (err)
148 goto fail;
149
150 debugfs_apply_options(sb);
151
152fail:
153 return err;
154}
155
156static int debugfs_show_options(struct seq_file *m, struct dentry *root)
157{
158 struct debugfs_fs_info *fsi = root->d_sb->s_fs_info;
159 struct debugfs_mount_opts *opts = &fsi->mount_opts;
160
Eric W. Biederman7dc05882012-04-03 14:01:31 -0700161 if (!uid_eq(opts->uid, GLOBAL_ROOT_UID))
162 seq_printf(m, ",uid=%u",
163 from_kuid_munged(&init_user_ns, opts->uid));
164 if (!gid_eq(opts->gid, GLOBAL_ROOT_GID))
165 seq_printf(m, ",gid=%u",
166 from_kgid_munged(&init_user_ns, opts->gid));
Ludwig Nusseld6e48682012-01-25 11:52:28 +0100167 if (opts->mode != DEBUGFS_DEFAULT_MODE)
168 seq_printf(m, ",mode=%o", opts->mode);
169
170 return 0;
171}
172
Al Viro0db59e52015-02-21 22:05:11 -0500173static void debugfs_evict_inode(struct inode *inode)
174{
175 truncate_inode_pages_final(&inode->i_data);
176 clear_inode(inode);
177 if (S_ISLNK(inode->i_mode))
Al Viro5723cb02015-05-02 10:27:18 -0400178 kfree(inode->i_link);
Al Viro0db59e52015-02-21 22:05:11 -0500179}
180
Ludwig Nusseld6e48682012-01-25 11:52:28 +0100181static const struct super_operations debugfs_super_operations = {
182 .statfs = simple_statfs,
183 .remount_fs = debugfs_remount,
184 .show_options = debugfs_show_options,
Al Viro0db59e52015-02-21 22:05:11 -0500185 .evict_inode = debugfs_evict_inode,
Ludwig Nusseld6e48682012-01-25 11:52:28 +0100186};
187
Al Viro77b3da62015-01-25 15:10:32 -0500188static struct vfsmount *debugfs_automount(struct path *path)
189{
Eric W. Biedermand3381fa2017-02-01 06:06:16 +1300190 debugfs_automount_t f;
191 f = (debugfs_automount_t)path->dentry->d_fsdata;
192 return f(path->dentry, d_inode(path->dentry)->i_private);
Al Viro77b3da62015-01-25 15:10:32 -0500193}
194
195static const struct dentry_operations debugfs_dops = {
196 .d_delete = always_delete_dentry,
197 .d_automount = debugfs_automount,
198};
199
Linus Torvalds1da177e2005-04-16 15:20:36 -0700200static int debug_fill_super(struct super_block *sb, void *data, int silent)
201{
202 static struct tree_descr debug_files[] = {{""}};
Ludwig Nusseld6e48682012-01-25 11:52:28 +0100203 struct debugfs_fs_info *fsi;
204 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205
Ludwig Nusseld6e48682012-01-25 11:52:28 +0100206 save_mount_options(sb, data);
207
208 fsi = kzalloc(sizeof(struct debugfs_fs_info), GFP_KERNEL);
209 sb->s_fs_info = fsi;
210 if (!fsi) {
211 err = -ENOMEM;
212 goto fail;
213 }
214
215 err = debugfs_parse_options(data, &fsi->mount_opts);
216 if (err)
217 goto fail;
218
219 err = simple_fill_super(sb, DEBUGFS_MAGIC, debug_files);
220 if (err)
221 goto fail;
222
223 sb->s_op = &debugfs_super_operations;
Al Viro77b3da62015-01-25 15:10:32 -0500224 sb->s_d_op = &debugfs_dops;
Ludwig Nusseld6e48682012-01-25 11:52:28 +0100225
226 debugfs_apply_options(sb);
227
228 return 0;
229
230fail:
231 kfree(fsi);
232 sb->s_fs_info = NULL;
233 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700234}
235
Al Virofc14f2f2010-07-25 01:48:30 +0400236static struct dentry *debug_mount(struct file_system_type *fs_type,
David Howells454e2392006-06-23 02:02:57 -0700237 int flags, const char *dev_name,
Al Virofc14f2f2010-07-25 01:48:30 +0400238 void *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700239{
Al Virofc14f2f2010-07-25 01:48:30 +0400240 return mount_single(fs_type, flags, data, debug_fill_super);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700241}
242
243static struct file_system_type debug_fs_type = {
244 .owner = THIS_MODULE,
245 .name = "debugfs",
Al Virofc14f2f2010-07-25 01:48:30 +0400246 .mount = debug_mount,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700247 .kill_sb = kill_litter_super,
248};
Eric W. Biederman7f78e032013-03-02 19:39:14 -0800249MODULE_ALIAS_FS("debugfs");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700250
Al Viro190afd82015-01-25 13:55:55 -0500251static struct dentry *start_creating(const char *name, struct dentry *parent)
Al Viroc3b1a352012-06-09 20:28:22 -0400252{
Al Viro190afd82015-01-25 13:55:55 -0500253 struct dentry *dentry;
Al Viroc3b1a352012-06-09 20:28:22 -0400254 int error;
255
256 pr_debug("debugfs: creating file '%s'\n",name);
257
Greg KHc9e15f22015-03-30 14:59:15 +0200258 if (IS_ERR(parent))
259 return parent;
260
Al Viroc3b1a352012-06-09 20:28:22 -0400261 error = simple_pin_fs(&debug_fs_type, &debugfs_mount,
262 &debugfs_mount_count);
263 if (error)
Al Viro190afd82015-01-25 13:55:55 -0500264 return ERR_PTR(error);
Al Viroc3b1a352012-06-09 20:28:22 -0400265
Al Virocfa57c12012-06-09 20:33:28 -0400266 /* If the parent is not specified, we create it in the root.
Rahul Bedarkar88e412e2014-06-06 23:12:04 +0530267 * We need the root dentry to do this, which is in the super
Al Virocfa57c12012-06-09 20:33:28 -0400268 * block. A pointer to that is in the struct vfsmount that we
269 * have around.
270 */
271 if (!parent)
272 parent = debugfs_mount->mnt_root;
273
Al Viro59551022016-01-22 15:40:57 -0500274 inode_lock(d_inode(parent));
Al Virocfa57c12012-06-09 20:33:28 -0400275 dentry = lookup_one_len(name, parent, strlen(name));
David Howells2b0143b2015-03-17 22:25:59 +0000276 if (!IS_ERR(dentry) && d_really_is_positive(dentry)) {
Al Virocfa57c12012-06-09 20:33:28 -0400277 dput(dentry);
Al Viro190afd82015-01-25 13:55:55 -0500278 dentry = ERR_PTR(-EEXIST);
279 }
Daniel Borkmann0ee96082015-11-05 00:01:51 +0100280
281 if (IS_ERR(dentry)) {
Al Viro59551022016-01-22 15:40:57 -0500282 inode_unlock(d_inode(parent));
Daniel Borkmann0ee96082015-11-05 00:01:51 +0100283 simple_release_fs(&debugfs_mount, &debugfs_mount_count);
284 }
285
Al Viro190afd82015-01-25 13:55:55 -0500286 return dentry;
287}
288
Al Viro5233e312015-01-25 14:39:49 -0500289static struct dentry *failed_creating(struct dentry *dentry)
Al Viro190afd82015-01-25 13:55:55 -0500290{
Al Viro59551022016-01-22 15:40:57 -0500291 inode_unlock(d_inode(dentry->d_parent));
Al Viro190afd82015-01-25 13:55:55 -0500292 dput(dentry);
Al Viro5233e312015-01-25 14:39:49 -0500293 simple_release_fs(&debugfs_mount, &debugfs_mount_count);
294 return NULL;
295}
Al Virocfa57c12012-06-09 20:33:28 -0400296
Al Viro5233e312015-01-25 14:39:49 -0500297static struct dentry *end_creating(struct dentry *dentry)
298{
Al Viro59551022016-01-22 15:40:57 -0500299 inode_unlock(d_inode(dentry->d_parent));
Al Viroc3b1a352012-06-09 20:28:22 -0400300 return dentry;
301}
302
Nicolai Stange49d200d2016-03-22 14:11:14 +0100303static struct dentry *__debugfs_create_file(const char *name, umode_t mode,
304 struct dentry *parent, void *data,
305 const struct file_operations *proxy_fops,
306 const struct file_operations *real_fops)
307{
308 struct dentry *dentry;
309 struct inode *inode;
310
311 if (!(mode & S_IFMT))
312 mode |= S_IFREG;
313 BUG_ON(!S_ISREG(mode));
314 dentry = start_creating(name, parent);
315
316 if (IS_ERR(dentry))
317 return NULL;
318
319 inode = debugfs_get_inode(dentry->d_sb);
320 if (unlikely(!inode))
321 return failed_creating(dentry);
322
323 inode->i_mode = mode;
324 inode->i_private = data;
325
326 inode->i_fop = proxy_fops;
327 dentry->d_fsdata = (void *)real_fops;
328
329 d_instantiate(dentry, inode);
330 fsnotify_create(d_inode(dentry->d_parent), dentry);
331 return end_creating(dentry);
332}
333
Linus Torvalds1da177e2005-04-16 15:20:36 -0700334/**
335 * debugfs_create_file - create a file in the debugfs filesystem
Linus Torvalds1da177e2005-04-16 15:20:36 -0700336 * @name: a pointer to a string containing the name of the file to create.
Alberto Bertoglibe030e62009-10-31 18:26:52 -0300337 * @mode: the permission that the file should have.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700338 * @parent: a pointer to the parent dentry for this file. This should be a
Masanari Iidae2278672014-02-18 22:54:36 +0900339 * directory dentry if set. If this parameter is NULL, then the
Linus Torvalds1da177e2005-04-16 15:20:36 -0700340 * file will be created in the root of the debugfs filesystem.
341 * @data: a pointer to something that the caller will want to get to later
Theodore Ts'o8e18e292006-09-27 01:50:46 -0700342 * on. The inode.i_private pointer will point to this value on
Linus Torvalds1da177e2005-04-16 15:20:36 -0700343 * the open() call.
344 * @fops: a pointer to a struct file_operations that should be used for
345 * this file.
346 *
347 * This is the basic "create a file" function for debugfs. It allows for a
Alberto Bertoglibe030e62009-10-31 18:26:52 -0300348 * wide range of flexibility in creating a file, or a directory (if you want
349 * to create a directory, the debugfs_create_dir() function is
Linus Torvalds1da177e2005-04-16 15:20:36 -0700350 * recommended to be used instead.)
351 *
352 * This function will return a pointer to a dentry if it succeeds. This
353 * pointer must be passed to the debugfs_remove() function when the file is
354 * to be removed (no automatic cleanup happens if your module is unloaded,
Randy Dunlap6468b3a2006-07-20 08:16:42 -0700355 * you are responsible here.) If an error occurs, %NULL will be returned.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356 *
Randy Dunlap6468b3a2006-07-20 08:16:42 -0700357 * If debugfs is not enabled in the kernel, the value -%ENODEV will be
Cornelia Huck873760f2007-02-14 07:57:47 +0100358 * returned.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700359 */
Al Virof4ae40a2011-07-24 04:33:43 -0400360struct dentry *debugfs_create_file(const char *name, umode_t mode,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700361 struct dentry *parent, void *data,
Arjan van de Ven99ac48f2006-03-28 01:56:41 -0800362 const struct file_operations *fops)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700363{
Al Viroc3b1a352012-06-09 20:28:22 -0400364
Nicolai Stange49d200d2016-03-22 14:11:14 +0100365 return __debugfs_create_file(name, mode, parent, data,
366 fops ? &debugfs_full_proxy_file_operations :
367 &debugfs_noop_file_operations,
368 fops);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700369}
370EXPORT_SYMBOL_GPL(debugfs_create_file);
371
Nicolai Stangec6468802016-03-22 14:11:15 +0100372/**
373 * debugfs_create_file_unsafe - create a file in the debugfs filesystem
374 * @name: a pointer to a string containing the name of the file to create.
375 * @mode: the permission that the file should have.
376 * @parent: a pointer to the parent dentry for this file. This should be a
377 * directory dentry if set. If this parameter is NULL, then the
378 * file will be created in the root of the debugfs filesystem.
379 * @data: a pointer to something that the caller will want to get to later
380 * on. The inode.i_private pointer will point to this value on
381 * the open() call.
382 * @fops: a pointer to a struct file_operations that should be used for
383 * this file.
384 *
385 * debugfs_create_file_unsafe() is completely analogous to
386 * debugfs_create_file(), the only difference being that the fops
387 * handed it will not get protected against file removals by the
388 * debugfs core.
389 *
390 * It is your responsibility to protect your struct file_operation
391 * methods against file removals by means of debugfs_use_file_start()
392 * and debugfs_use_file_finish(). ->open() is still protected by
393 * debugfs though.
394 *
395 * Any struct file_operations defined by means of
396 * DEFINE_DEBUGFS_ATTRIBUTE() is protected against file removals and
397 * thus, may be used here.
398 */
Nicolai Stange49d200d2016-03-22 14:11:14 +0100399struct dentry *debugfs_create_file_unsafe(const char *name, umode_t mode,
400 struct dentry *parent, void *data,
401 const struct file_operations *fops)
402{
403
404 return __debugfs_create_file(name, mode, parent, data,
405 fops ? &debugfs_open_proxy_file_operations :
406 &debugfs_noop_file_operations,
407 fops);
408}
Nicolai Stangec6468802016-03-22 14:11:15 +0100409EXPORT_SYMBOL_GPL(debugfs_create_file_unsafe);
Nicolai Stange49d200d2016-03-22 14:11:14 +0100410
Linus Torvalds1da177e2005-04-16 15:20:36 -0700411/**
David Howellse59b4e92015-01-21 20:03:40 +0000412 * debugfs_create_file_size - create a file in the debugfs filesystem
413 * @name: a pointer to a string containing the name of the file to create.
414 * @mode: the permission that the file should have.
415 * @parent: a pointer to the parent dentry for this file. This should be a
416 * directory dentry if set. If this parameter is NULL, then the
417 * file will be created in the root of the debugfs filesystem.
418 * @data: a pointer to something that the caller will want to get to later
419 * on. The inode.i_private pointer will point to this value on
420 * the open() call.
421 * @fops: a pointer to a struct file_operations that should be used for
422 * this file.
423 * @file_size: initial file size
424 *
425 * This is the basic "create a file" function for debugfs. It allows for a
426 * wide range of flexibility in creating a file, or a directory (if you want
427 * to create a directory, the debugfs_create_dir() function is
428 * recommended to be used instead.)
429 *
430 * This function will return a pointer to a dentry if it succeeds. This
431 * pointer must be passed to the debugfs_remove() function when the file is
432 * to be removed (no automatic cleanup happens if your module is unloaded,
433 * you are responsible here.) If an error occurs, %NULL will be returned.
434 *
435 * If debugfs is not enabled in the kernel, the value -%ENODEV will be
436 * returned.
437 */
438struct dentry *debugfs_create_file_size(const char *name, umode_t mode,
439 struct dentry *parent, void *data,
440 const struct file_operations *fops,
441 loff_t file_size)
442{
443 struct dentry *de = debugfs_create_file(name, mode, parent, data, fops);
444
445 if (de)
David Howells2b0143b2015-03-17 22:25:59 +0000446 d_inode(de)->i_size = file_size;
David Howellse59b4e92015-01-21 20:03:40 +0000447 return de;
448}
449EXPORT_SYMBOL_GPL(debugfs_create_file_size);
450
451/**
Linus Torvalds1da177e2005-04-16 15:20:36 -0700452 * debugfs_create_dir - create a directory in the debugfs filesystem
Linus Torvalds1da177e2005-04-16 15:20:36 -0700453 * @name: a pointer to a string containing the name of the directory to
454 * create.
455 * @parent: a pointer to the parent dentry for this file. This should be a
Masanari Iidae2278672014-02-18 22:54:36 +0900456 * directory dentry if set. If this parameter is NULL, then the
Linus Torvalds1da177e2005-04-16 15:20:36 -0700457 * directory will be created in the root of the debugfs filesystem.
458 *
459 * This function creates a directory in debugfs with the given name.
460 *
461 * This function will return a pointer to a dentry if it succeeds. This
462 * pointer must be passed to the debugfs_remove() function when the file is
463 * to be removed (no automatic cleanup happens if your module is unloaded,
Randy Dunlap6468b3a2006-07-20 08:16:42 -0700464 * you are responsible here.) If an error occurs, %NULL will be returned.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700465 *
Randy Dunlap6468b3a2006-07-20 08:16:42 -0700466 * If debugfs is not enabled in the kernel, the value -%ENODEV will be
Cornelia Huck873760f2007-02-14 07:57:47 +0100467 * returned.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700468 */
469struct dentry *debugfs_create_dir(const char *name, struct dentry *parent)
470{
Al Viroad5abd52015-01-25 14:02:31 -0500471 struct dentry *dentry = start_creating(name, parent);
Al Viro680b3022015-01-25 14:31:32 -0500472 struct inode *inode;
Al Viroad5abd52015-01-25 14:02:31 -0500473
474 if (IS_ERR(dentry))
475 return NULL;
476
Al Viroedac65e2015-01-25 14:36:18 -0500477 inode = debugfs_get_inode(dentry->d_sb);
Al Viro680b3022015-01-25 14:31:32 -0500478 if (unlikely(!inode))
Al Viro5233e312015-01-25 14:39:49 -0500479 return failed_creating(dentry);
Al Viro680b3022015-01-25 14:31:32 -0500480
Al Viroedac65e2015-01-25 14:36:18 -0500481 inode->i_mode = S_IFDIR | S_IRWXU | S_IRUGO | S_IXUGO;
482 inode->i_op = &simple_dir_inode_operations;
483 inode->i_fop = &simple_dir_operations;
484
485 /* directory inodes start off with i_nlink == 2 (for "." entry) */
486 inc_nlink(inode);
Al Viro680b3022015-01-25 14:31:32 -0500487 d_instantiate(dentry, inode);
David Howells2b0143b2015-03-17 22:25:59 +0000488 inc_nlink(d_inode(dentry->d_parent));
489 fsnotify_mkdir(d_inode(dentry->d_parent), dentry);
Al Viro5233e312015-01-25 14:39:49 -0500490 return end_creating(dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700491}
492EXPORT_SYMBOL_GPL(debugfs_create_dir);
493
494/**
Al Viro77b3da62015-01-25 15:10:32 -0500495 * debugfs_create_automount - create automount point in the debugfs filesystem
496 * @name: a pointer to a string containing the name of the file to create.
497 * @parent: a pointer to the parent dentry for this file. This should be a
498 * directory dentry if set. If this parameter is NULL, then the
499 * file will be created in the root of the debugfs filesystem.
500 * @f: function to be called when pathname resolution steps on that one.
501 * @data: opaque argument to pass to f().
502 *
503 * @f should return what ->d_automount() would.
504 */
505struct dentry *debugfs_create_automount(const char *name,
506 struct dentry *parent,
Eric W. Biedermand3381fa2017-02-01 06:06:16 +1300507 debugfs_automount_t f,
Al Viro77b3da62015-01-25 15:10:32 -0500508 void *data)
509{
510 struct dentry *dentry = start_creating(name, parent);
511 struct inode *inode;
512
513 if (IS_ERR(dentry))
514 return NULL;
515
516 inode = debugfs_get_inode(dentry->d_sb);
517 if (unlikely(!inode))
518 return failed_creating(dentry);
519
Seth Forshee87243de2016-03-09 09:18:07 -0600520 make_empty_dir_inode(inode);
Al Viro77b3da62015-01-25 15:10:32 -0500521 inode->i_flags |= S_AUTOMOUNT;
522 inode->i_private = data;
523 dentry->d_fsdata = (void *)f;
Roman Pena8f324a2016-02-09 11:30:29 +0100524 /* directory inodes start off with i_nlink == 2 (for "." entry) */
525 inc_nlink(inode);
Al Viro77b3da62015-01-25 15:10:32 -0500526 d_instantiate(dentry, inode);
Roman Pena8f324a2016-02-09 11:30:29 +0100527 inc_nlink(d_inode(dentry->d_parent));
528 fsnotify_mkdir(d_inode(dentry->d_parent), dentry);
Al Viro77b3da62015-01-25 15:10:32 -0500529 return end_creating(dentry);
530}
531EXPORT_SYMBOL(debugfs_create_automount);
532
533/**
Peter Oberparleiter66f54962007-02-13 12:13:54 +0100534 * debugfs_create_symlink- create a symbolic link in the debugfs filesystem
535 * @name: a pointer to a string containing the name of the symbolic link to
536 * create.
537 * @parent: a pointer to the parent dentry for this symbolic link. This
Masanari Iidae2278672014-02-18 22:54:36 +0900538 * should be a directory dentry if set. If this parameter is NULL,
Peter Oberparleiter66f54962007-02-13 12:13:54 +0100539 * then the symbolic link will be created in the root of the debugfs
540 * filesystem.
541 * @target: a pointer to a string containing the path to the target of the
542 * symbolic link.
543 *
544 * This function creates a symbolic link with the given name in debugfs that
545 * links to the given target path.
546 *
547 * This function will return a pointer to a dentry if it succeeds. This
548 * pointer must be passed to the debugfs_remove() function when the symbolic
549 * link is to be removed (no automatic cleanup happens if your module is
550 * unloaded, you are responsible here.) If an error occurs, %NULL will be
551 * returned.
552 *
553 * If debugfs is not enabled in the kernel, the value -%ENODEV will be
Cornelia Huck873760f2007-02-14 07:57:47 +0100554 * returned.
Peter Oberparleiter66f54962007-02-13 12:13:54 +0100555 */
556struct dentry *debugfs_create_symlink(const char *name, struct dentry *parent,
557 const char *target)
558{
Al Viroad5abd52015-01-25 14:02:31 -0500559 struct dentry *dentry;
Al Viro680b3022015-01-25 14:31:32 -0500560 struct inode *inode;
561 char *link = kstrdup(target, GFP_KERNEL);
Peter Oberparleiter66f54962007-02-13 12:13:54 +0100562 if (!link)
563 return NULL;
564
Al Viroad5abd52015-01-25 14:02:31 -0500565 dentry = start_creating(name, parent);
Al Viroad5abd52015-01-25 14:02:31 -0500566 if (IS_ERR(dentry)) {
Peter Oberparleiter66f54962007-02-13 12:13:54 +0100567 kfree(link);
Al Viroad5abd52015-01-25 14:02:31 -0500568 return NULL;
569 }
570
Al Viroedac65e2015-01-25 14:36:18 -0500571 inode = debugfs_get_inode(dentry->d_sb);
Al Viro680b3022015-01-25 14:31:32 -0500572 if (unlikely(!inode)) {
Al Viroad5abd52015-01-25 14:02:31 -0500573 kfree(link);
Al Viro5233e312015-01-25 14:39:49 -0500574 return failed_creating(dentry);
Al Viro680b3022015-01-25 14:31:32 -0500575 }
Al Viroedac65e2015-01-25 14:36:18 -0500576 inode->i_mode = S_IFLNK | S_IRWXUGO;
Al Viro5723cb02015-05-02 10:27:18 -0400577 inode->i_op = &simple_symlink_inode_operations;
578 inode->i_link = link;
Al Viro680b3022015-01-25 14:31:32 -0500579 d_instantiate(dentry, inode);
Al Viro5233e312015-01-25 14:39:49 -0500580 return end_creating(dentry);
Peter Oberparleiter66f54962007-02-13 12:13:54 +0100581}
582EXPORT_SYMBOL_GPL(debugfs_create_symlink);
583
Jan Kara25d41d82011-02-07 15:00:27 +0100584static int __debugfs_remove(struct dentry *dentry, struct dentry *parent)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700585{
Mathieu Desnoyers65c33332006-11-24 13:50:09 -0500586 int ret = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700587
Al Virodc3f4192015-05-18 10:10:34 -0400588 if (simple_positive(dentry)) {
Al Viro0db59e52015-02-21 22:05:11 -0500589 dget(dentry);
David Howells7ceab502015-03-05 12:46:49 +0000590 if (d_is_dir(dentry))
David Howells2b0143b2015-03-17 22:25:59 +0000591 ret = simple_rmdir(d_inode(parent), dentry);
Al Viro0db59e52015-02-21 22:05:11 -0500592 else
David Howells2b0143b2015-03-17 22:25:59 +0000593 simple_unlink(d_inode(parent), dentry);
Al Viro0db59e52015-02-21 22:05:11 -0500594 if (!ret)
595 d_delete(dentry);
596 dput(dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700597 }
Jan Kara25d41d82011-02-07 15:00:27 +0100598 return ret;
Haavard Skinnemoen9505e632008-07-01 15:14:51 +0200599}
600
601/**
602 * debugfs_remove - removes a file or directory from the debugfs filesystem
603 * @dentry: a pointer to a the dentry of the file or directory to be
Ulf Magnusson398dc4a2015-09-07 19:03:15 +0200604 * removed. If this parameter is NULL or an error value, nothing
605 * will be done.
Haavard Skinnemoen9505e632008-07-01 15:14:51 +0200606 *
607 * This function removes a file or directory in debugfs that was previously
608 * created with a call to another debugfs function (like
609 * debugfs_create_file() or variants thereof.)
610 *
611 * This function is required to be called in order for the file to be
612 * removed, no automatic cleanup of files will happen when a module is
613 * removed, you are responsible here.
614 */
615void debugfs_remove(struct dentry *dentry)
616{
617 struct dentry *parent;
Jan Kara25d41d82011-02-07 15:00:27 +0100618 int ret;
619
Arend van Spriela59d6292012-05-23 15:13:07 +0200620 if (IS_ERR_OR_NULL(dentry))
Haavard Skinnemoen9505e632008-07-01 15:14:51 +0200621 return;
622
623 parent = dentry->d_parent;
Al Viro59551022016-01-22 15:40:57 -0500624 inode_lock(d_inode(parent));
Jan Kara25d41d82011-02-07 15:00:27 +0100625 ret = __debugfs_remove(dentry, parent);
Al Viro59551022016-01-22 15:40:57 -0500626 inode_unlock(d_inode(parent));
Jan Kara25d41d82011-02-07 15:00:27 +0100627 if (!ret)
628 simple_release_fs(&debugfs_mount, &debugfs_mount_count);
Nicolai Stange49d200d2016-03-22 14:11:14 +0100629
Nicolai Stange9fd4dce2016-03-22 14:11:13 +0100630 synchronize_srcu(&debugfs_srcu);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700631}
632EXPORT_SYMBOL_GPL(debugfs_remove);
633
Jan Karacfc94cd2007-05-09 13:19:52 +0200634/**
Haavard Skinnemoen9505e632008-07-01 15:14:51 +0200635 * debugfs_remove_recursive - recursively removes a directory
Ulf Magnusson398dc4a2015-09-07 19:03:15 +0200636 * @dentry: a pointer to a the dentry of the directory to be removed. If this
637 * parameter is NULL or an error value, nothing will be done.
Haavard Skinnemoen9505e632008-07-01 15:14:51 +0200638 *
639 * This function recursively removes a directory tree in debugfs that
640 * was previously created with a call to another debugfs function
641 * (like debugfs_create_file() or variants thereof.)
642 *
643 * This function is required to be called in order for the file to be
644 * removed, no automatic cleanup of files will happen when a module is
645 * removed, you are responsible here.
646 */
647void debugfs_remove_recursive(struct dentry *dentry)
648{
Steven Rostedt485d4402014-06-09 14:06:07 -0400649 struct dentry *child, *parent;
Haavard Skinnemoen9505e632008-07-01 15:14:51 +0200650
Arend van Spriela59d6292012-05-23 15:13:07 +0200651 if (IS_ERR_OR_NULL(dentry))
Haavard Skinnemoen9505e632008-07-01 15:14:51 +0200652 return;
653
Haavard Skinnemoen9505e632008-07-01 15:14:51 +0200654 parent = dentry;
Oleg Nesterov776164c2013-07-26 17:12:56 +0200655 down:
Al Viro59551022016-01-22 15:40:57 -0500656 inode_lock(d_inode(parent));
Steven Rostedt485d4402014-06-09 14:06:07 -0400657 loop:
658 /*
659 * The parent->d_subdirs is protected by the d_lock. Outside that
660 * lock, the child can be unlinked and set to be freed which can
661 * use the d_u.d_child as the rcu head and corrupt this list.
662 */
663 spin_lock(&parent->d_lock);
Al Viro946e51f2014-10-26 19:19:16 -0400664 list_for_each_entry(child, &parent->d_subdirs, d_child) {
Al Virodc3f4192015-05-18 10:10:34 -0400665 if (!simple_positive(child))
Oleg Nesterov776164c2013-07-26 17:12:56 +0200666 continue;
Haavard Skinnemoen9505e632008-07-01 15:14:51 +0200667
Oleg Nesterov776164c2013-07-26 17:12:56 +0200668 /* perhaps simple_empty(child) makes more sense */
Haavard Skinnemoen9505e632008-07-01 15:14:51 +0200669 if (!list_empty(&child->d_subdirs)) {
Steven Rostedt485d4402014-06-09 14:06:07 -0400670 spin_unlock(&parent->d_lock);
Al Viro59551022016-01-22 15:40:57 -0500671 inode_unlock(d_inode(parent));
Haavard Skinnemoen9505e632008-07-01 15:14:51 +0200672 parent = child;
Oleg Nesterov776164c2013-07-26 17:12:56 +0200673 goto down;
Haavard Skinnemoen9505e632008-07-01 15:14:51 +0200674 }
Steven Rostedt485d4402014-06-09 14:06:07 -0400675
676 spin_unlock(&parent->d_lock);
677
Oleg Nesterov776164c2013-07-26 17:12:56 +0200678 if (!__debugfs_remove(child, parent))
679 simple_release_fs(&debugfs_mount, &debugfs_mount_count);
Steven Rostedt485d4402014-06-09 14:06:07 -0400680
681 /*
682 * The parent->d_lock protects agaist child from unlinking
683 * from d_subdirs. When releasing the parent->d_lock we can
684 * no longer trust that the next pointer is valid.
685 * Restart the loop. We'll skip this one with the
Al Virodc3f4192015-05-18 10:10:34 -0400686 * simple_positive() check.
Steven Rostedt485d4402014-06-09 14:06:07 -0400687 */
688 goto loop;
Haavard Skinnemoen9505e632008-07-01 15:14:51 +0200689 }
Steven Rostedt485d4402014-06-09 14:06:07 -0400690 spin_unlock(&parent->d_lock);
Haavard Skinnemoen9505e632008-07-01 15:14:51 +0200691
Al Viro59551022016-01-22 15:40:57 -0500692 inode_unlock(d_inode(parent));
Oleg Nesterov776164c2013-07-26 17:12:56 +0200693 child = parent;
694 parent = parent->d_parent;
Al Viro59551022016-01-22 15:40:57 -0500695 inode_lock(d_inode(parent));
Oleg Nesterov776164c2013-07-26 17:12:56 +0200696
Steven Rostedt485d4402014-06-09 14:06:07 -0400697 if (child != dentry)
698 /* go up */
699 goto loop;
Oleg Nesterov776164c2013-07-26 17:12:56 +0200700
701 if (!__debugfs_remove(child, parent))
702 simple_release_fs(&debugfs_mount, &debugfs_mount_count);
Al Viro59551022016-01-22 15:40:57 -0500703 inode_unlock(d_inode(parent));
Nicolai Stange49d200d2016-03-22 14:11:14 +0100704
Nicolai Stange9fd4dce2016-03-22 14:11:13 +0100705 synchronize_srcu(&debugfs_srcu);
Haavard Skinnemoen9505e632008-07-01 15:14:51 +0200706}
707EXPORT_SYMBOL_GPL(debugfs_remove_recursive);
708
709/**
Jan Karacfc94cd2007-05-09 13:19:52 +0200710 * debugfs_rename - rename a file/directory in the debugfs filesystem
711 * @old_dir: a pointer to the parent dentry for the renamed object. This
712 * should be a directory dentry.
713 * @old_dentry: dentry of an object to be renamed.
714 * @new_dir: a pointer to the parent dentry where the object should be
715 * moved. This should be a directory dentry.
716 * @new_name: a pointer to a string containing the target name.
717 *
718 * This function renames a file/directory in debugfs. The target must not
719 * exist for rename to succeed.
720 *
721 * This function will return a pointer to old_dentry (which is updated to
722 * reflect renaming) if it succeeds. If an error occurs, %NULL will be
723 * returned.
724 *
725 * If debugfs is not enabled in the kernel, the value -%ENODEV will be
726 * returned.
727 */
728struct dentry *debugfs_rename(struct dentry *old_dir, struct dentry *old_dentry,
729 struct dentry *new_dir, const char *new_name)
730{
731 int error;
732 struct dentry *dentry = NULL, *trap;
Al Viroad25f112017-07-07 14:51:19 -0400733 struct name_snapshot old_name;
Jan Karacfc94cd2007-05-09 13:19:52 +0200734
735 trap = lock_rename(new_dir, old_dir);
736 /* Source or destination directories don't exist? */
David Howells2b0143b2015-03-17 22:25:59 +0000737 if (d_really_is_negative(old_dir) || d_really_is_negative(new_dir))
Jan Karacfc94cd2007-05-09 13:19:52 +0200738 goto exit;
739 /* Source does not exist, cyclic rename, or mountpoint? */
David Howells2b0143b2015-03-17 22:25:59 +0000740 if (d_really_is_negative(old_dentry) || old_dentry == trap ||
Jan Karacfc94cd2007-05-09 13:19:52 +0200741 d_mountpoint(old_dentry))
742 goto exit;
743 dentry = lookup_one_len(new_name, new_dir, strlen(new_name));
744 /* Lookup failed, cyclic rename or target exists? */
David Howells2b0143b2015-03-17 22:25:59 +0000745 if (IS_ERR(dentry) || dentry == trap || d_really_is_positive(dentry))
Jan Karacfc94cd2007-05-09 13:19:52 +0200746 goto exit;
747
Al Viroad25f112017-07-07 14:51:19 -0400748 take_dentry_name_snapshot(&old_name, old_dentry);
Jan Karacfc94cd2007-05-09 13:19:52 +0200749
David Howells2b0143b2015-03-17 22:25:59 +0000750 error = simple_rename(d_inode(old_dir), old_dentry, d_inode(new_dir),
Miklos Szeredie0e0be82016-09-27 11:03:57 +0200751 dentry, 0);
Jan Karacfc94cd2007-05-09 13:19:52 +0200752 if (error) {
Al Viroad25f112017-07-07 14:51:19 -0400753 release_dentry_name_snapshot(&old_name);
Jan Karacfc94cd2007-05-09 13:19:52 +0200754 goto exit;
755 }
756 d_move(old_dentry, dentry);
Al Viroad25f112017-07-07 14:51:19 -0400757 fsnotify_move(d_inode(old_dir), d_inode(new_dir), old_name.name,
David Howellse36cb0b2015-01-29 12:02:35 +0000758 d_is_dir(old_dentry),
Al Viro5a190ae2007-06-07 12:19:32 -0400759 NULL, old_dentry);
Al Viroad25f112017-07-07 14:51:19 -0400760 release_dentry_name_snapshot(&old_name);
Jan Karacfc94cd2007-05-09 13:19:52 +0200761 unlock_rename(new_dir, old_dir);
762 dput(dentry);
763 return old_dentry;
764exit:
765 if (dentry && !IS_ERR(dentry))
766 dput(dentry);
767 unlock_rename(new_dir, old_dir);
768 return NULL;
769}
770EXPORT_SYMBOL_GPL(debugfs_rename);
771
Frederic Weisbeckerc0f92ba2009-03-22 23:10:44 +0100772/**
773 * debugfs_initialized - Tells whether debugfs has been registered
774 */
775bool debugfs_initialized(void)
776{
777 return debugfs_registered;
778}
779EXPORT_SYMBOL_GPL(debugfs_initialized);
780
Linus Torvalds1da177e2005-04-16 15:20:36 -0700781static int __init debugfs_init(void)
782{
783 int retval;
784
Eric W. Biedermanf9bb4882015-05-13 17:35:41 -0500785 retval = sysfs_create_mount_point(kernel_kobj, "debug");
786 if (retval)
787 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700788
789 retval = register_filesystem(&debug_fs_type);
790 if (retval)
Eric W. Biedermanf9bb4882015-05-13 17:35:41 -0500791 sysfs_remove_mount_point(kernel_kobj, "debug");
Frederic Weisbeckerc0f92ba2009-03-22 23:10:44 +0100792 else
793 debugfs_registered = true;
794
Linus Torvalds1da177e2005-04-16 15:20:36 -0700795 return retval;
796}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700797core_initcall(debugfs_init);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700798