blob: 7eaec88ea970d1a6ea8422465857deaefd2b7052 [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>
Linus Torvalds1da177e2005-04-16 15:20:36 -070030
Kees Cook82aceae42012-08-27 13:32:15 -070031#define DEBUGFS_DEFAULT_MODE 0700
Ludwig Nusseld6e48682012-01-25 11:52:28 +010032
Linus Torvalds1da177e2005-04-16 15:20:36 -070033static struct vfsmount *debugfs_mount;
34static int debugfs_mount_count;
Frederic Weisbeckerc0f92ba2009-03-22 23:10:44 +010035static bool debugfs_registered;
Linus Torvalds1da177e2005-04-16 15:20:36 -070036
Al Viroedac65e2015-01-25 14:36:18 -050037static struct inode *debugfs_get_inode(struct super_block *sb)
Linus Torvalds1da177e2005-04-16 15:20:36 -070038{
39 struct inode *inode = new_inode(sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -070040 if (inode) {
Christoph Hellwig85fe4022010-10-23 11:19:54 -040041 inode->i_ino = get_next_ino();
Linus Torvalds1da177e2005-04-16 15:20:36 -070042 inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
Linus Torvalds1da177e2005-04-16 15:20:36 -070043 }
Rahul Bedarkar88e412e2014-06-06 23:12:04 +053044 return inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -070045}
46
Linus Torvalds1da177e2005-04-16 15:20:36 -070047static inline int debugfs_positive(struct dentry *dentry)
48{
David Howells2b0143b2015-03-17 22:25:59 +000049 return d_really_is_positive(dentry) && !d_unhashed(dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -070050}
51
Ludwig Nusseld6e48682012-01-25 11:52:28 +010052struct debugfs_mount_opts {
Eric W. Biederman7dc05882012-04-03 14:01:31 -070053 kuid_t uid;
54 kgid_t gid;
Ludwig Nusseld6e48682012-01-25 11:52:28 +010055 umode_t mode;
56};
57
58enum {
59 Opt_uid,
60 Opt_gid,
61 Opt_mode,
62 Opt_err
63};
64
65static const match_table_t tokens = {
66 {Opt_uid, "uid=%u"},
67 {Opt_gid, "gid=%u"},
68 {Opt_mode, "mode=%o"},
69 {Opt_err, NULL}
70};
71
72struct debugfs_fs_info {
73 struct debugfs_mount_opts mount_opts;
74};
75
76static int debugfs_parse_options(char *data, struct debugfs_mount_opts *opts)
77{
78 substring_t args[MAX_OPT_ARGS];
79 int option;
80 int token;
Eric W. Biederman7dc05882012-04-03 14:01:31 -070081 kuid_t uid;
82 kgid_t gid;
Ludwig Nusseld6e48682012-01-25 11:52:28 +010083 char *p;
84
85 opts->mode = DEBUGFS_DEFAULT_MODE;
86
87 while ((p = strsep(&data, ",")) != NULL) {
88 if (!*p)
89 continue;
90
91 token = match_token(p, tokens, args);
92 switch (token) {
93 case Opt_uid:
94 if (match_int(&args[0], &option))
95 return -EINVAL;
Eric W. Biederman7dc05882012-04-03 14:01:31 -070096 uid = make_kuid(current_user_ns(), option);
97 if (!uid_valid(uid))
98 return -EINVAL;
99 opts->uid = uid;
Ludwig Nusseld6e48682012-01-25 11:52:28 +0100100 break;
101 case Opt_gid:
Dave Reisnerf1688e02013-01-02 08:54:37 -0500102 if (match_int(&args[0], &option))
Ludwig Nusseld6e48682012-01-25 11:52:28 +0100103 return -EINVAL;
Eric W. Biederman7dc05882012-04-03 14:01:31 -0700104 gid = make_kgid(current_user_ns(), option);
105 if (!gid_valid(gid))
106 return -EINVAL;
107 opts->gid = gid;
Ludwig Nusseld6e48682012-01-25 11:52:28 +0100108 break;
109 case Opt_mode:
110 if (match_octal(&args[0], &option))
111 return -EINVAL;
112 opts->mode = option & S_IALLUGO;
113 break;
114 /*
115 * We might like to report bad mount options here;
116 * but traditionally debugfs has ignored all mount options
117 */
118 }
119 }
120
121 return 0;
122}
123
124static int debugfs_apply_options(struct super_block *sb)
125{
126 struct debugfs_fs_info *fsi = sb->s_fs_info;
David Howells2b0143b2015-03-17 22:25:59 +0000127 struct inode *inode = d_inode(sb->s_root);
Ludwig Nusseld6e48682012-01-25 11:52:28 +0100128 struct debugfs_mount_opts *opts = &fsi->mount_opts;
129
130 inode->i_mode &= ~S_IALLUGO;
131 inode->i_mode |= opts->mode;
132
133 inode->i_uid = opts->uid;
134 inode->i_gid = opts->gid;
135
136 return 0;
137}
138
139static int debugfs_remount(struct super_block *sb, int *flags, char *data)
140{
141 int err;
142 struct debugfs_fs_info *fsi = sb->s_fs_info;
143
Theodore Ts'o02b99842014-03-13 10:14:33 -0400144 sync_filesystem(sb);
Ludwig Nusseld6e48682012-01-25 11:52:28 +0100145 err = debugfs_parse_options(data, &fsi->mount_opts);
146 if (err)
147 goto fail;
148
149 debugfs_apply_options(sb);
150
151fail:
152 return err;
153}
154
155static int debugfs_show_options(struct seq_file *m, struct dentry *root)
156{
157 struct debugfs_fs_info *fsi = root->d_sb->s_fs_info;
158 struct debugfs_mount_opts *opts = &fsi->mount_opts;
159
Eric W. Biederman7dc05882012-04-03 14:01:31 -0700160 if (!uid_eq(opts->uid, GLOBAL_ROOT_UID))
161 seq_printf(m, ",uid=%u",
162 from_kuid_munged(&init_user_ns, opts->uid));
163 if (!gid_eq(opts->gid, GLOBAL_ROOT_GID))
164 seq_printf(m, ",gid=%u",
165 from_kgid_munged(&init_user_ns, opts->gid));
Ludwig Nusseld6e48682012-01-25 11:52:28 +0100166 if (opts->mode != DEBUGFS_DEFAULT_MODE)
167 seq_printf(m, ",mode=%o", opts->mode);
168
169 return 0;
170}
171
Al Viro0db59e52015-02-21 22:05:11 -0500172static void debugfs_evict_inode(struct inode *inode)
173{
174 truncate_inode_pages_final(&inode->i_data);
175 clear_inode(inode);
176 if (S_ISLNK(inode->i_mode))
Al Viro5723cb02015-05-02 10:27:18 -0400177 kfree(inode->i_link);
Al Viro0db59e52015-02-21 22:05:11 -0500178}
179
Ludwig Nusseld6e48682012-01-25 11:52:28 +0100180static const struct super_operations debugfs_super_operations = {
181 .statfs = simple_statfs,
182 .remount_fs = debugfs_remount,
183 .show_options = debugfs_show_options,
Al Viro0db59e52015-02-21 22:05:11 -0500184 .evict_inode = debugfs_evict_inode,
Ludwig Nusseld6e48682012-01-25 11:52:28 +0100185};
186
Al Viro77b3da62015-01-25 15:10:32 -0500187static struct vfsmount *debugfs_automount(struct path *path)
188{
189 struct vfsmount *(*f)(void *);
190 f = (struct vfsmount *(*)(void *))path->dentry->d_fsdata;
David Howells2b0143b2015-03-17 22:25:59 +0000191 return f(d_inode(path->dentry)->i_private);
Al Viro77b3da62015-01-25 15:10:32 -0500192}
193
194static const struct dentry_operations debugfs_dops = {
195 .d_delete = always_delete_dentry,
196 .d_automount = debugfs_automount,
197};
198
Linus Torvalds1da177e2005-04-16 15:20:36 -0700199static int debug_fill_super(struct super_block *sb, void *data, int silent)
200{
201 static struct tree_descr debug_files[] = {{""}};
Ludwig Nusseld6e48682012-01-25 11:52:28 +0100202 struct debugfs_fs_info *fsi;
203 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700204
Ludwig Nusseld6e48682012-01-25 11:52:28 +0100205 save_mount_options(sb, data);
206
207 fsi = kzalloc(sizeof(struct debugfs_fs_info), GFP_KERNEL);
208 sb->s_fs_info = fsi;
209 if (!fsi) {
210 err = -ENOMEM;
211 goto fail;
212 }
213
214 err = debugfs_parse_options(data, &fsi->mount_opts);
215 if (err)
216 goto fail;
217
218 err = simple_fill_super(sb, DEBUGFS_MAGIC, debug_files);
219 if (err)
220 goto fail;
221
222 sb->s_op = &debugfs_super_operations;
Al Viro77b3da62015-01-25 15:10:32 -0500223 sb->s_d_op = &debugfs_dops;
Ludwig Nusseld6e48682012-01-25 11:52:28 +0100224
225 debugfs_apply_options(sb);
226
227 return 0;
228
229fail:
230 kfree(fsi);
231 sb->s_fs_info = NULL;
232 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700233}
234
Al Virofc14f2f2010-07-25 01:48:30 +0400235static struct dentry *debug_mount(struct file_system_type *fs_type,
David Howells454e2392006-06-23 02:02:57 -0700236 int flags, const char *dev_name,
Al Virofc14f2f2010-07-25 01:48:30 +0400237 void *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700238{
Al Virofc14f2f2010-07-25 01:48:30 +0400239 return mount_single(fs_type, flags, data, debug_fill_super);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700240}
241
242static struct file_system_type debug_fs_type = {
243 .owner = THIS_MODULE,
244 .name = "debugfs",
Al Virofc14f2f2010-07-25 01:48:30 +0400245 .mount = debug_mount,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700246 .kill_sb = kill_litter_super,
247};
Eric W. Biederman7f78e032013-03-02 19:39:14 -0800248MODULE_ALIAS_FS("debugfs");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700249
Al Viro190afd82015-01-25 13:55:55 -0500250static struct dentry *start_creating(const char *name, struct dentry *parent)
Al Viroc3b1a352012-06-09 20:28:22 -0400251{
Al Viro190afd82015-01-25 13:55:55 -0500252 struct dentry *dentry;
Al Viroc3b1a352012-06-09 20:28:22 -0400253 int error;
254
255 pr_debug("debugfs: creating file '%s'\n",name);
256
Greg KHc9e15f22015-03-30 14:59:15 +0200257 if (IS_ERR(parent))
258 return parent;
259
Al Viroc3b1a352012-06-09 20:28:22 -0400260 error = simple_pin_fs(&debug_fs_type, &debugfs_mount,
261 &debugfs_mount_count);
262 if (error)
Al Viro190afd82015-01-25 13:55:55 -0500263 return ERR_PTR(error);
Al Viroc3b1a352012-06-09 20:28:22 -0400264
Al Virocfa57c12012-06-09 20:33:28 -0400265 /* If the parent is not specified, we create it in the root.
Rahul Bedarkar88e412e2014-06-06 23:12:04 +0530266 * We need the root dentry to do this, which is in the super
Al Virocfa57c12012-06-09 20:33:28 -0400267 * block. A pointer to that is in the struct vfsmount that we
268 * have around.
269 */
270 if (!parent)
271 parent = debugfs_mount->mnt_root;
272
David Howells2b0143b2015-03-17 22:25:59 +0000273 mutex_lock(&d_inode(parent)->i_mutex);
Al Virocfa57c12012-06-09 20:33:28 -0400274 dentry = lookup_one_len(name, parent, strlen(name));
David Howells2b0143b2015-03-17 22:25:59 +0000275 if (!IS_ERR(dentry) && d_really_is_positive(dentry)) {
Al Virocfa57c12012-06-09 20:33:28 -0400276 dput(dentry);
Al Viro190afd82015-01-25 13:55:55 -0500277 dentry = ERR_PTR(-EEXIST);
278 }
279 if (IS_ERR(dentry))
David Howells2b0143b2015-03-17 22:25:59 +0000280 mutex_unlock(&d_inode(parent)->i_mutex);
Al Viro190afd82015-01-25 13:55:55 -0500281 return dentry;
282}
283
Al Viro5233e312015-01-25 14:39:49 -0500284static struct dentry *failed_creating(struct dentry *dentry)
Al Viro190afd82015-01-25 13:55:55 -0500285{
David Howells2b0143b2015-03-17 22:25:59 +0000286 mutex_unlock(&d_inode(dentry->d_parent)->i_mutex);
Al Viro190afd82015-01-25 13:55:55 -0500287 dput(dentry);
Al Viro5233e312015-01-25 14:39:49 -0500288 simple_release_fs(&debugfs_mount, &debugfs_mount_count);
289 return NULL;
290}
Al Virocfa57c12012-06-09 20:33:28 -0400291
Al Viro5233e312015-01-25 14:39:49 -0500292static struct dentry *end_creating(struct dentry *dentry)
293{
David Howells2b0143b2015-03-17 22:25:59 +0000294 mutex_unlock(&d_inode(dentry->d_parent)->i_mutex);
Al Viroc3b1a352012-06-09 20:28:22 -0400295 return dentry;
296}
297
Linus Torvalds1da177e2005-04-16 15:20:36 -0700298/**
299 * debugfs_create_file - create a file in the debugfs filesystem
Linus Torvalds1da177e2005-04-16 15:20:36 -0700300 * @name: a pointer to a string containing the name of the file to create.
Alberto Bertoglibe030e62009-10-31 18:26:52 -0300301 * @mode: the permission that the file should have.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700302 * @parent: a pointer to the parent dentry for this file. This should be a
Masanari Iidae2278672014-02-18 22:54:36 +0900303 * directory dentry if set. If this parameter is NULL, then the
Linus Torvalds1da177e2005-04-16 15:20:36 -0700304 * file will be created in the root of the debugfs filesystem.
305 * @data: a pointer to something that the caller will want to get to later
Theodore Ts'o8e18e292006-09-27 01:50:46 -0700306 * on. The inode.i_private pointer will point to this value on
Linus Torvalds1da177e2005-04-16 15:20:36 -0700307 * the open() call.
308 * @fops: a pointer to a struct file_operations that should be used for
309 * this file.
310 *
311 * This is the basic "create a file" function for debugfs. It allows for a
Alberto Bertoglibe030e62009-10-31 18:26:52 -0300312 * wide range of flexibility in creating a file, or a directory (if you want
313 * to create a directory, the debugfs_create_dir() function is
Linus Torvalds1da177e2005-04-16 15:20:36 -0700314 * recommended to be used instead.)
315 *
316 * This function will return a pointer to a dentry if it succeeds. This
317 * pointer must be passed to the debugfs_remove() function when the file is
318 * to be removed (no automatic cleanup happens if your module is unloaded,
Randy Dunlap6468b3a2006-07-20 08:16:42 -0700319 * you are responsible here.) If an error occurs, %NULL will be returned.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700320 *
Randy Dunlap6468b3a2006-07-20 08:16:42 -0700321 * If debugfs is not enabled in the kernel, the value -%ENODEV will be
Cornelia Huck873760f2007-02-14 07:57:47 +0100322 * returned.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700323 */
Al Virof4ae40a2011-07-24 04:33:43 -0400324struct dentry *debugfs_create_file(const char *name, umode_t mode,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700325 struct dentry *parent, void *data,
Arjan van de Ven99ac48f2006-03-28 01:56:41 -0800326 const struct file_operations *fops)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700327{
Al Viroad5abd52015-01-25 14:02:31 -0500328 struct dentry *dentry;
Al Viro680b3022015-01-25 14:31:32 -0500329 struct inode *inode;
Al Viroc3b1a352012-06-09 20:28:22 -0400330
Al Viroad5abd52015-01-25 14:02:31 -0500331 if (!(mode & S_IFMT))
332 mode |= S_IFREG;
333 BUG_ON(!S_ISREG(mode));
334 dentry = start_creating(name, parent);
335
336 if (IS_ERR(dentry))
337 return NULL;
338
Al Viroedac65e2015-01-25 14:36:18 -0500339 inode = debugfs_get_inode(dentry->d_sb);
Al Viro680b3022015-01-25 14:31:32 -0500340 if (unlikely(!inode))
Al Viro5233e312015-01-25 14:39:49 -0500341 return failed_creating(dentry);
Al Viro680b3022015-01-25 14:31:32 -0500342
Al Viroedac65e2015-01-25 14:36:18 -0500343 inode->i_mode = mode;
344 inode->i_fop = fops ? fops : &debugfs_file_operations;
345 inode->i_private = data;
Al Viro680b3022015-01-25 14:31:32 -0500346 d_instantiate(dentry, inode);
David Howells2b0143b2015-03-17 22:25:59 +0000347 fsnotify_create(d_inode(dentry->d_parent), dentry);
Al Viro5233e312015-01-25 14:39:49 -0500348 return end_creating(dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349}
350EXPORT_SYMBOL_GPL(debugfs_create_file);
351
352/**
David Howellse59b4e92015-01-21 20:03:40 +0000353 * debugfs_create_file_size - create a file in the debugfs filesystem
354 * @name: a pointer to a string containing the name of the file to create.
355 * @mode: the permission that the file should have.
356 * @parent: a pointer to the parent dentry for this file. This should be a
357 * directory dentry if set. If this parameter is NULL, then the
358 * file will be created in the root of the debugfs filesystem.
359 * @data: a pointer to something that the caller will want to get to later
360 * on. The inode.i_private pointer will point to this value on
361 * the open() call.
362 * @fops: a pointer to a struct file_operations that should be used for
363 * this file.
364 * @file_size: initial file size
365 *
366 * This is the basic "create a file" function for debugfs. It allows for a
367 * wide range of flexibility in creating a file, or a directory (if you want
368 * to create a directory, the debugfs_create_dir() function is
369 * recommended to be used instead.)
370 *
371 * This function will return a pointer to a dentry if it succeeds. This
372 * pointer must be passed to the debugfs_remove() function when the file is
373 * to be removed (no automatic cleanup happens if your module is unloaded,
374 * you are responsible here.) If an error occurs, %NULL will be returned.
375 *
376 * If debugfs is not enabled in the kernel, the value -%ENODEV will be
377 * returned.
378 */
379struct dentry *debugfs_create_file_size(const char *name, umode_t mode,
380 struct dentry *parent, void *data,
381 const struct file_operations *fops,
382 loff_t file_size)
383{
384 struct dentry *de = debugfs_create_file(name, mode, parent, data, fops);
385
386 if (de)
David Howells2b0143b2015-03-17 22:25:59 +0000387 d_inode(de)->i_size = file_size;
David Howellse59b4e92015-01-21 20:03:40 +0000388 return de;
389}
390EXPORT_SYMBOL_GPL(debugfs_create_file_size);
391
392/**
Linus Torvalds1da177e2005-04-16 15:20:36 -0700393 * debugfs_create_dir - create a directory in the debugfs filesystem
Linus Torvalds1da177e2005-04-16 15:20:36 -0700394 * @name: a pointer to a string containing the name of the directory to
395 * create.
396 * @parent: a pointer to the parent dentry for this file. This should be a
Masanari Iidae2278672014-02-18 22:54:36 +0900397 * directory dentry if set. If this parameter is NULL, then the
Linus Torvalds1da177e2005-04-16 15:20:36 -0700398 * directory will be created in the root of the debugfs filesystem.
399 *
400 * This function creates a directory in debugfs with the given name.
401 *
402 * This function will return a pointer to a dentry if it succeeds. This
403 * pointer must be passed to the debugfs_remove() function when the file is
404 * to be removed (no automatic cleanup happens if your module is unloaded,
Randy Dunlap6468b3a2006-07-20 08:16:42 -0700405 * you are responsible here.) If an error occurs, %NULL will be returned.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700406 *
Randy Dunlap6468b3a2006-07-20 08:16:42 -0700407 * If debugfs is not enabled in the kernel, the value -%ENODEV will be
Cornelia Huck873760f2007-02-14 07:57:47 +0100408 * returned.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700409 */
410struct dentry *debugfs_create_dir(const char *name, struct dentry *parent)
411{
Al Viroad5abd52015-01-25 14:02:31 -0500412 struct dentry *dentry = start_creating(name, parent);
Al Viro680b3022015-01-25 14:31:32 -0500413 struct inode *inode;
Al Viroad5abd52015-01-25 14:02:31 -0500414
415 if (IS_ERR(dentry))
416 return NULL;
417
Al Viroedac65e2015-01-25 14:36:18 -0500418 inode = debugfs_get_inode(dentry->d_sb);
Al Viro680b3022015-01-25 14:31:32 -0500419 if (unlikely(!inode))
Al Viro5233e312015-01-25 14:39:49 -0500420 return failed_creating(dentry);
Al Viro680b3022015-01-25 14:31:32 -0500421
Al Viroedac65e2015-01-25 14:36:18 -0500422 inode->i_mode = S_IFDIR | S_IRWXU | S_IRUGO | S_IXUGO;
423 inode->i_op = &simple_dir_inode_operations;
424 inode->i_fop = &simple_dir_operations;
425
426 /* directory inodes start off with i_nlink == 2 (for "." entry) */
427 inc_nlink(inode);
Al Viro680b3022015-01-25 14:31:32 -0500428 d_instantiate(dentry, inode);
David Howells2b0143b2015-03-17 22:25:59 +0000429 inc_nlink(d_inode(dentry->d_parent));
430 fsnotify_mkdir(d_inode(dentry->d_parent), dentry);
Al Viro5233e312015-01-25 14:39:49 -0500431 return end_creating(dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700432}
433EXPORT_SYMBOL_GPL(debugfs_create_dir);
434
435/**
Al Viro77b3da62015-01-25 15:10:32 -0500436 * debugfs_create_automount - create automount point in the debugfs filesystem
437 * @name: a pointer to a string containing the name of the file to create.
438 * @parent: a pointer to the parent dentry for this file. This should be a
439 * directory dentry if set. If this parameter is NULL, then the
440 * file will be created in the root of the debugfs filesystem.
441 * @f: function to be called when pathname resolution steps on that one.
442 * @data: opaque argument to pass to f().
443 *
444 * @f should return what ->d_automount() would.
445 */
446struct dentry *debugfs_create_automount(const char *name,
447 struct dentry *parent,
448 struct vfsmount *(*f)(void *),
449 void *data)
450{
451 struct dentry *dentry = start_creating(name, parent);
452 struct inode *inode;
453
454 if (IS_ERR(dentry))
455 return NULL;
456
457 inode = debugfs_get_inode(dentry->d_sb);
458 if (unlikely(!inode))
459 return failed_creating(dentry);
460
461 inode->i_mode = S_IFDIR | S_IRWXU | S_IRUGO | S_IXUGO;
462 inode->i_flags |= S_AUTOMOUNT;
463 inode->i_private = data;
464 dentry->d_fsdata = (void *)f;
465 d_instantiate(dentry, inode);
466 return end_creating(dentry);
467}
468EXPORT_SYMBOL(debugfs_create_automount);
469
470/**
Peter Oberparleiter66f54962007-02-13 12:13:54 +0100471 * debugfs_create_symlink- create a symbolic link in the debugfs filesystem
472 * @name: a pointer to a string containing the name of the symbolic link to
473 * create.
474 * @parent: a pointer to the parent dentry for this symbolic link. This
Masanari Iidae2278672014-02-18 22:54:36 +0900475 * should be a directory dentry if set. If this parameter is NULL,
Peter Oberparleiter66f54962007-02-13 12:13:54 +0100476 * then the symbolic link will be created in the root of the debugfs
477 * filesystem.
478 * @target: a pointer to a string containing the path to the target of the
479 * symbolic link.
480 *
481 * This function creates a symbolic link with the given name in debugfs that
482 * links to the given target path.
483 *
484 * This function will return a pointer to a dentry if it succeeds. This
485 * pointer must be passed to the debugfs_remove() function when the symbolic
486 * link is to be removed (no automatic cleanup happens if your module is
487 * unloaded, you are responsible here.) If an error occurs, %NULL will be
488 * returned.
489 *
490 * If debugfs is not enabled in the kernel, the value -%ENODEV will be
Cornelia Huck873760f2007-02-14 07:57:47 +0100491 * returned.
Peter Oberparleiter66f54962007-02-13 12:13:54 +0100492 */
493struct dentry *debugfs_create_symlink(const char *name, struct dentry *parent,
494 const char *target)
495{
Al Viroad5abd52015-01-25 14:02:31 -0500496 struct dentry *dentry;
Al Viro680b3022015-01-25 14:31:32 -0500497 struct inode *inode;
498 char *link = kstrdup(target, GFP_KERNEL);
Peter Oberparleiter66f54962007-02-13 12:13:54 +0100499 if (!link)
500 return NULL;
501
Al Viroad5abd52015-01-25 14:02:31 -0500502 dentry = start_creating(name, parent);
Al Viroad5abd52015-01-25 14:02:31 -0500503 if (IS_ERR(dentry)) {
Peter Oberparleiter66f54962007-02-13 12:13:54 +0100504 kfree(link);
Al Viroad5abd52015-01-25 14:02:31 -0500505 return NULL;
506 }
507
Al Viroedac65e2015-01-25 14:36:18 -0500508 inode = debugfs_get_inode(dentry->d_sb);
Al Viro680b3022015-01-25 14:31:32 -0500509 if (unlikely(!inode)) {
Al Viroad5abd52015-01-25 14:02:31 -0500510 kfree(link);
Al Viro5233e312015-01-25 14:39:49 -0500511 return failed_creating(dentry);
Al Viro680b3022015-01-25 14:31:32 -0500512 }
Al Viroedac65e2015-01-25 14:36:18 -0500513 inode->i_mode = S_IFLNK | S_IRWXUGO;
Al Viro5723cb02015-05-02 10:27:18 -0400514 inode->i_op = &simple_symlink_inode_operations;
515 inode->i_link = link;
Al Viro680b3022015-01-25 14:31:32 -0500516 d_instantiate(dentry, inode);
Al Viro5233e312015-01-25 14:39:49 -0500517 return end_creating(dentry);
Peter Oberparleiter66f54962007-02-13 12:13:54 +0100518}
519EXPORT_SYMBOL_GPL(debugfs_create_symlink);
520
Jan Kara25d41d82011-02-07 15:00:27 +0100521static int __debugfs_remove(struct dentry *dentry, struct dentry *parent)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700522{
Mathieu Desnoyers65c33332006-11-24 13:50:09 -0500523 int ret = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700524
Linus Torvalds1da177e2005-04-16 15:20:36 -0700525 if (debugfs_positive(dentry)) {
Al Viro0db59e52015-02-21 22:05:11 -0500526 dget(dentry);
David Howells7ceab502015-03-05 12:46:49 +0000527 if (d_is_dir(dentry))
David Howells2b0143b2015-03-17 22:25:59 +0000528 ret = simple_rmdir(d_inode(parent), dentry);
Al Viro0db59e52015-02-21 22:05:11 -0500529 else
David Howells2b0143b2015-03-17 22:25:59 +0000530 simple_unlink(d_inode(parent), dentry);
Al Viro0db59e52015-02-21 22:05:11 -0500531 if (!ret)
532 d_delete(dentry);
533 dput(dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700534 }
Jan Kara25d41d82011-02-07 15:00:27 +0100535 return ret;
Haavard Skinnemoen9505e632008-07-01 15:14:51 +0200536}
537
538/**
539 * debugfs_remove - removes a file or directory from the debugfs filesystem
540 * @dentry: a pointer to a the dentry of the file or directory to be
541 * removed.
542 *
543 * This function removes a file or directory in debugfs that was previously
544 * created with a call to another debugfs function (like
545 * debugfs_create_file() or variants thereof.)
546 *
547 * This function is required to be called in order for the file to be
548 * removed, no automatic cleanup of files will happen when a module is
549 * removed, you are responsible here.
550 */
551void debugfs_remove(struct dentry *dentry)
552{
553 struct dentry *parent;
Jan Kara25d41d82011-02-07 15:00:27 +0100554 int ret;
555
Arend van Spriela59d6292012-05-23 15:13:07 +0200556 if (IS_ERR_OR_NULL(dentry))
Haavard Skinnemoen9505e632008-07-01 15:14:51 +0200557 return;
558
559 parent = dentry->d_parent;
David Howells2b0143b2015-03-17 22:25:59 +0000560 if (!parent || d_really_is_negative(parent))
Haavard Skinnemoen9505e632008-07-01 15:14:51 +0200561 return;
562
David Howells2b0143b2015-03-17 22:25:59 +0000563 mutex_lock(&d_inode(parent)->i_mutex);
Jan Kara25d41d82011-02-07 15:00:27 +0100564 ret = __debugfs_remove(dentry, parent);
David Howells2b0143b2015-03-17 22:25:59 +0000565 mutex_unlock(&d_inode(parent)->i_mutex);
Jan Kara25d41d82011-02-07 15:00:27 +0100566 if (!ret)
567 simple_release_fs(&debugfs_mount, &debugfs_mount_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700568}
569EXPORT_SYMBOL_GPL(debugfs_remove);
570
Jan Karacfc94cd2007-05-09 13:19:52 +0200571/**
Haavard Skinnemoen9505e632008-07-01 15:14:51 +0200572 * debugfs_remove_recursive - recursively removes a directory
573 * @dentry: a pointer to a the dentry of the directory to be removed.
574 *
575 * This function recursively removes a directory tree in debugfs that
576 * was previously created with a call to another debugfs function
577 * (like debugfs_create_file() or variants thereof.)
578 *
579 * This function is required to be called in order for the file to be
580 * removed, no automatic cleanup of files will happen when a module is
581 * removed, you are responsible here.
582 */
583void debugfs_remove_recursive(struct dentry *dentry)
584{
Steven Rostedt485d4402014-06-09 14:06:07 -0400585 struct dentry *child, *parent;
Haavard Skinnemoen9505e632008-07-01 15:14:51 +0200586
Arend van Spriela59d6292012-05-23 15:13:07 +0200587 if (IS_ERR_OR_NULL(dentry))
Haavard Skinnemoen9505e632008-07-01 15:14:51 +0200588 return;
589
590 parent = dentry->d_parent;
David Howells2b0143b2015-03-17 22:25:59 +0000591 if (!parent || d_really_is_negative(parent))
Haavard Skinnemoen9505e632008-07-01 15:14:51 +0200592 return;
593
594 parent = dentry;
Oleg Nesterov776164c2013-07-26 17:12:56 +0200595 down:
David Howells2b0143b2015-03-17 22:25:59 +0000596 mutex_lock(&d_inode(parent)->i_mutex);
Steven Rostedt485d4402014-06-09 14:06:07 -0400597 loop:
598 /*
599 * The parent->d_subdirs is protected by the d_lock. Outside that
600 * lock, the child can be unlinked and set to be freed which can
601 * use the d_u.d_child as the rcu head and corrupt this list.
602 */
603 spin_lock(&parent->d_lock);
Al Viro946e51f2014-10-26 19:19:16 -0400604 list_for_each_entry(child, &parent->d_subdirs, d_child) {
Oleg Nesterov776164c2013-07-26 17:12:56 +0200605 if (!debugfs_positive(child))
606 continue;
Haavard Skinnemoen9505e632008-07-01 15:14:51 +0200607
Oleg Nesterov776164c2013-07-26 17:12:56 +0200608 /* perhaps simple_empty(child) makes more sense */
Haavard Skinnemoen9505e632008-07-01 15:14:51 +0200609 if (!list_empty(&child->d_subdirs)) {
Steven Rostedt485d4402014-06-09 14:06:07 -0400610 spin_unlock(&parent->d_lock);
David Howells2b0143b2015-03-17 22:25:59 +0000611 mutex_unlock(&d_inode(parent)->i_mutex);
Haavard Skinnemoen9505e632008-07-01 15:14:51 +0200612 parent = child;
Oleg Nesterov776164c2013-07-26 17:12:56 +0200613 goto down;
Haavard Skinnemoen9505e632008-07-01 15:14:51 +0200614 }
Steven Rostedt485d4402014-06-09 14:06:07 -0400615
616 spin_unlock(&parent->d_lock);
617
Oleg Nesterov776164c2013-07-26 17:12:56 +0200618 if (!__debugfs_remove(child, parent))
619 simple_release_fs(&debugfs_mount, &debugfs_mount_count);
Steven Rostedt485d4402014-06-09 14:06:07 -0400620
621 /*
622 * The parent->d_lock protects agaist child from unlinking
623 * from d_subdirs. When releasing the parent->d_lock we can
624 * no longer trust that the next pointer is valid.
625 * Restart the loop. We'll skip this one with the
626 * debugfs_positive() check.
627 */
628 goto loop;
Haavard Skinnemoen9505e632008-07-01 15:14:51 +0200629 }
Steven Rostedt485d4402014-06-09 14:06:07 -0400630 spin_unlock(&parent->d_lock);
Haavard Skinnemoen9505e632008-07-01 15:14:51 +0200631
David Howells2b0143b2015-03-17 22:25:59 +0000632 mutex_unlock(&d_inode(parent)->i_mutex);
Oleg Nesterov776164c2013-07-26 17:12:56 +0200633 child = parent;
634 parent = parent->d_parent;
David Howells2b0143b2015-03-17 22:25:59 +0000635 mutex_lock(&d_inode(parent)->i_mutex);
Oleg Nesterov776164c2013-07-26 17:12:56 +0200636
Steven Rostedt485d4402014-06-09 14:06:07 -0400637 if (child != dentry)
638 /* go up */
639 goto loop;
Oleg Nesterov776164c2013-07-26 17:12:56 +0200640
641 if (!__debugfs_remove(child, parent))
642 simple_release_fs(&debugfs_mount, &debugfs_mount_count);
David Howells2b0143b2015-03-17 22:25:59 +0000643 mutex_unlock(&d_inode(parent)->i_mutex);
Haavard Skinnemoen9505e632008-07-01 15:14:51 +0200644}
645EXPORT_SYMBOL_GPL(debugfs_remove_recursive);
646
647/**
Jan Karacfc94cd2007-05-09 13:19:52 +0200648 * debugfs_rename - rename a file/directory in the debugfs filesystem
649 * @old_dir: a pointer to the parent dentry for the renamed object. This
650 * should be a directory dentry.
651 * @old_dentry: dentry of an object to be renamed.
652 * @new_dir: a pointer to the parent dentry where the object should be
653 * moved. This should be a directory dentry.
654 * @new_name: a pointer to a string containing the target name.
655 *
656 * This function renames a file/directory in debugfs. The target must not
657 * exist for rename to succeed.
658 *
659 * This function will return a pointer to old_dentry (which is updated to
660 * reflect renaming) if it succeeds. If an error occurs, %NULL will be
661 * returned.
662 *
663 * If debugfs is not enabled in the kernel, the value -%ENODEV will be
664 * returned.
665 */
666struct dentry *debugfs_rename(struct dentry *old_dir, struct dentry *old_dentry,
667 struct dentry *new_dir, const char *new_name)
668{
669 int error;
670 struct dentry *dentry = NULL, *trap;
671 const char *old_name;
672
673 trap = lock_rename(new_dir, old_dir);
674 /* Source or destination directories don't exist? */
David Howells2b0143b2015-03-17 22:25:59 +0000675 if (d_really_is_negative(old_dir) || d_really_is_negative(new_dir))
Jan Karacfc94cd2007-05-09 13:19:52 +0200676 goto exit;
677 /* Source does not exist, cyclic rename, or mountpoint? */
David Howells2b0143b2015-03-17 22:25:59 +0000678 if (d_really_is_negative(old_dentry) || old_dentry == trap ||
Jan Karacfc94cd2007-05-09 13:19:52 +0200679 d_mountpoint(old_dentry))
680 goto exit;
681 dentry = lookup_one_len(new_name, new_dir, strlen(new_name));
682 /* Lookup failed, cyclic rename or target exists? */
David Howells2b0143b2015-03-17 22:25:59 +0000683 if (IS_ERR(dentry) || dentry == trap || d_really_is_positive(dentry))
Jan Karacfc94cd2007-05-09 13:19:52 +0200684 goto exit;
685
686 old_name = fsnotify_oldname_init(old_dentry->d_name.name);
687
David Howells2b0143b2015-03-17 22:25:59 +0000688 error = simple_rename(d_inode(old_dir), old_dentry, d_inode(new_dir),
Jan Karacfc94cd2007-05-09 13:19:52 +0200689 dentry);
690 if (error) {
691 fsnotify_oldname_free(old_name);
692 goto exit;
693 }
694 d_move(old_dentry, dentry);
David Howells2b0143b2015-03-17 22:25:59 +0000695 fsnotify_move(d_inode(old_dir), d_inode(new_dir), old_name,
David Howellse36cb0b2015-01-29 12:02:35 +0000696 d_is_dir(old_dentry),
Al Viro5a190ae2007-06-07 12:19:32 -0400697 NULL, old_dentry);
Jan Karacfc94cd2007-05-09 13:19:52 +0200698 fsnotify_oldname_free(old_name);
699 unlock_rename(new_dir, old_dir);
700 dput(dentry);
701 return old_dentry;
702exit:
703 if (dentry && !IS_ERR(dentry))
704 dput(dentry);
705 unlock_rename(new_dir, old_dir);
706 return NULL;
707}
708EXPORT_SYMBOL_GPL(debugfs_rename);
709
Frederic Weisbeckerc0f92ba2009-03-22 23:10:44 +0100710/**
711 * debugfs_initialized - Tells whether debugfs has been registered
712 */
713bool debugfs_initialized(void)
714{
715 return debugfs_registered;
716}
717EXPORT_SYMBOL_GPL(debugfs_initialized);
718
719
Greg Kroah-Hartman191e1862007-10-29 20:13:17 +0100720static struct kobject *debug_kobj;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700721
722static int __init debugfs_init(void)
723{
724 int retval;
725
Greg Kroah-Hartman0ff21e42007-11-06 10:36:58 -0800726 debug_kobj = kobject_create_and_add("debug", kernel_kobj);
Greg Kroah-Hartman191e1862007-10-29 20:13:17 +0100727 if (!debug_kobj)
728 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700729
730 retval = register_filesystem(&debug_fs_type);
731 if (retval)
Greg Kroah-Hartman197b12d2007-12-20 08:13:05 -0800732 kobject_put(debug_kobj);
Frederic Weisbeckerc0f92ba2009-03-22 23:10:44 +0100733 else
734 debugfs_registered = true;
735
Linus Torvalds1da177e2005-04-16 15:20:36 -0700736 return retval;
737}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700738core_initcall(debugfs_init);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700739