xref: /openbmc/linux/fs/debugfs/inode.c (revision 9d56dd3b083a3bec56e9da35ce07baca81030b03)
1 /*
2  *  file.c - part of debugfs, a tiny little debug file system
3  *
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 
16 /* uncomment to get debug messages from the debug filesystem, ah the irony. */
17 /* #define DEBUG */
18 
19 #include <linux/module.h>
20 #include <linux/fs.h>
21 #include <linux/mount.h>
22 #include <linux/pagemap.h>
23 #include <linux/init.h>
24 #include <linux/kobject.h>
25 #include <linux/namei.h>
26 #include <linux/debugfs.h>
27 #include <linux/fsnotify.h>
28 #include <linux/string.h>
29 #include <linux/magic.h>
30 
31 static struct vfsmount *debugfs_mount;
32 static int debugfs_mount_count;
33 static bool debugfs_registered;
34 
35 static struct inode *debugfs_get_inode(struct super_block *sb, int mode, dev_t dev,
36 				       void *data, const struct file_operations *fops)
37 
38 {
39 	struct inode *inode = new_inode(sb);
40 
41 	if (inode) {
42 		inode->i_mode = mode;
43 		inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
44 		switch (mode & S_IFMT) {
45 		default:
46 			init_special_inode(inode, mode, dev);
47 			break;
48 		case S_IFREG:
49 			inode->i_fop = fops ? fops : &debugfs_file_operations;
50 			inode->i_private = data;
51 			break;
52 		case S_IFLNK:
53 			inode->i_op = &debugfs_link_operations;
54 			inode->i_fop = fops;
55 			inode->i_private = data;
56 			break;
57 		case S_IFDIR:
58 			inode->i_op = &simple_dir_inode_operations;
59 			inode->i_fop = fops ? fops : &simple_dir_operations;
60 			inode->i_private = data;
61 
62 			/* directory inodes start off with i_nlink == 2
63 			 * (for "." entry) */
64 			inc_nlink(inode);
65 			break;
66 		}
67 	}
68 	return inode;
69 }
70 
71 /* SMP-safe */
72 static int debugfs_mknod(struct inode *dir, struct dentry *dentry,
73 			 int mode, dev_t dev, void *data,
74 			 const struct file_operations *fops)
75 {
76 	struct inode *inode;
77 	int error = -EPERM;
78 
79 	if (dentry->d_inode)
80 		return -EEXIST;
81 
82 	inode = debugfs_get_inode(dir->i_sb, mode, dev, data, fops);
83 	if (inode) {
84 		d_instantiate(dentry, inode);
85 		dget(dentry);
86 		error = 0;
87 	}
88 	return error;
89 }
90 
91 static int debugfs_mkdir(struct inode *dir, struct dentry *dentry, int mode,
92 			 void *data, const struct file_operations *fops)
93 {
94 	int res;
95 
96 	mode = (mode & (S_IRWXUGO | S_ISVTX)) | S_IFDIR;
97 	res = debugfs_mknod(dir, dentry, mode, 0, data, fops);
98 	if (!res) {
99 		inc_nlink(dir);
100 		fsnotify_mkdir(dir, dentry);
101 	}
102 	return res;
103 }
104 
105 static int debugfs_link(struct inode *dir, struct dentry *dentry, int mode,
106 			void *data, const struct file_operations *fops)
107 {
108 	mode = (mode & S_IALLUGO) | S_IFLNK;
109 	return debugfs_mknod(dir, dentry, mode, 0, data, fops);
110 }
111 
112 static int debugfs_create(struct inode *dir, struct dentry *dentry, int mode,
113 			  void *data, const struct file_operations *fops)
114 {
115 	int res;
116 
117 	mode = (mode & S_IALLUGO) | S_IFREG;
118 	res = debugfs_mknod(dir, dentry, mode, 0, data, fops);
119 	if (!res)
120 		fsnotify_create(dir, dentry);
121 	return res;
122 }
123 
124 static inline int debugfs_positive(struct dentry *dentry)
125 {
126 	return dentry->d_inode && !d_unhashed(dentry);
127 }
128 
129 static int debug_fill_super(struct super_block *sb, void *data, int silent)
130 {
131 	static struct tree_descr debug_files[] = {{""}};
132 
133 	return simple_fill_super(sb, DEBUGFS_MAGIC, debug_files);
134 }
135 
136 static int debug_get_sb(struct file_system_type *fs_type,
137 			int flags, const char *dev_name,
138 			void *data, struct vfsmount *mnt)
139 {
140 	return get_sb_single(fs_type, flags, data, debug_fill_super, mnt);
141 }
142 
143 static struct file_system_type debug_fs_type = {
144 	.owner =	THIS_MODULE,
145 	.name =		"debugfs",
146 	.get_sb =	debug_get_sb,
147 	.kill_sb =	kill_litter_super,
148 };
149 
150 static int debugfs_create_by_name(const char *name, mode_t mode,
151 				  struct dentry *parent,
152 				  struct dentry **dentry,
153 				  void *data,
154 				  const struct file_operations *fops)
155 {
156 	int error = 0;
157 
158 	/* If the parent is not specified, we create it in the root.
159 	 * We need the root dentry to do this, which is in the super
160 	 * block. A pointer to that is in the struct vfsmount that we
161 	 * have around.
162 	 */
163 	if (!parent) {
164 		if (debugfs_mount && debugfs_mount->mnt_sb) {
165 			parent = debugfs_mount->mnt_sb->s_root;
166 		}
167 	}
168 	if (!parent) {
169 		pr_debug("debugfs: Ah! can not find a parent!\n");
170 		return -EFAULT;
171 	}
172 
173 	*dentry = NULL;
174 	mutex_lock(&parent->d_inode->i_mutex);
175 	*dentry = lookup_one_len(name, parent, strlen(name));
176 	if (!IS_ERR(*dentry)) {
177 		switch (mode & S_IFMT) {
178 		case S_IFDIR:
179 			error = debugfs_mkdir(parent->d_inode, *dentry, mode,
180 					      data, fops);
181 			break;
182 		case S_IFLNK:
183 			error = debugfs_link(parent->d_inode, *dentry, mode,
184 					     data, fops);
185 			break;
186 		default:
187 			error = debugfs_create(parent->d_inode, *dentry, mode,
188 					       data, fops);
189 			break;
190 		}
191 		dput(*dentry);
192 	} else
193 		error = PTR_ERR(*dentry);
194 	mutex_unlock(&parent->d_inode->i_mutex);
195 
196 	return error;
197 }
198 
199 /**
200  * debugfs_create_file - create a file in the debugfs filesystem
201  * @name: a pointer to a string containing the name of the file to create.
202  * @mode: the permission that the file should have.
203  * @parent: a pointer to the parent dentry for this file.  This should be a
204  *          directory dentry if set.  If this paramater is NULL, then the
205  *          file will be created in the root of the debugfs filesystem.
206  * @data: a pointer to something that the caller will want to get to later
207  *        on.  The inode.i_private pointer will point to this value on
208  *        the open() call.
209  * @fops: a pointer to a struct file_operations that should be used for
210  *        this file.
211  *
212  * This is the basic "create a file" function for debugfs.  It allows for a
213  * wide range of flexibility in creating a file, or a directory (if you want
214  * to create a directory, the debugfs_create_dir() function is
215  * recommended to be used instead.)
216  *
217  * This function will return a pointer to a dentry if it succeeds.  This
218  * pointer must be passed to the debugfs_remove() function when the file is
219  * to be removed (no automatic cleanup happens if your module is unloaded,
220  * you are responsible here.)  If an error occurs, %NULL will be returned.
221  *
222  * If debugfs is not enabled in the kernel, the value -%ENODEV will be
223  * returned.
224  */
225 struct dentry *debugfs_create_file(const char *name, mode_t mode,
226 				   struct dentry *parent, void *data,
227 				   const struct file_operations *fops)
228 {
229 	struct dentry *dentry = NULL;
230 	int error;
231 
232 	pr_debug("debugfs: creating file '%s'\n",name);
233 
234 	error = simple_pin_fs(&debug_fs_type, &debugfs_mount,
235 			      &debugfs_mount_count);
236 	if (error)
237 		goto exit;
238 
239 	error = debugfs_create_by_name(name, mode, parent, &dentry,
240 				       data, fops);
241 	if (error) {
242 		dentry = NULL;
243 		simple_release_fs(&debugfs_mount, &debugfs_mount_count);
244 		goto exit;
245 	}
246 exit:
247 	return dentry;
248 }
249 EXPORT_SYMBOL_GPL(debugfs_create_file);
250 
251 /**
252  * debugfs_create_dir - create a directory in the debugfs filesystem
253  * @name: a pointer to a string containing the name of the directory to
254  *        create.
255  * @parent: a pointer to the parent dentry for this file.  This should be a
256  *          directory dentry if set.  If this paramater is NULL, then the
257  *          directory will be created in the root of the debugfs filesystem.
258  *
259  * This function creates a directory in debugfs with the given name.
260  *
261  * This function will return a pointer to a dentry if it succeeds.  This
262  * pointer must be passed to the debugfs_remove() function when the file is
263  * to be removed (no automatic cleanup happens if your module is unloaded,
264  * you are responsible here.)  If an error occurs, %NULL will be returned.
265  *
266  * If debugfs is not enabled in the kernel, the value -%ENODEV will be
267  * returned.
268  */
269 struct dentry *debugfs_create_dir(const char *name, struct dentry *parent)
270 {
271 	return debugfs_create_file(name,
272 				   S_IFDIR | S_IRWXU | S_IRUGO | S_IXUGO,
273 				   parent, NULL, NULL);
274 }
275 EXPORT_SYMBOL_GPL(debugfs_create_dir);
276 
277 /**
278  * debugfs_create_symlink- create a symbolic link in the debugfs filesystem
279  * @name: a pointer to a string containing the name of the symbolic link to
280  *        create.
281  * @parent: a pointer to the parent dentry for this symbolic link.  This
282  *          should be a directory dentry if set.  If this paramater is NULL,
283  *          then the symbolic link will be created in the root of the debugfs
284  *          filesystem.
285  * @target: a pointer to a string containing the path to the target of the
286  *          symbolic link.
287  *
288  * This function creates a symbolic link with the given name in debugfs that
289  * links to the given target path.
290  *
291  * This function will return a pointer to a dentry if it succeeds.  This
292  * pointer must be passed to the debugfs_remove() function when the symbolic
293  * link is to be removed (no automatic cleanup happens if your module is
294  * unloaded, you are responsible here.)  If an error occurs, %NULL will be
295  * returned.
296  *
297  * If debugfs is not enabled in the kernel, the value -%ENODEV will be
298  * returned.
299  */
300 struct dentry *debugfs_create_symlink(const char *name, struct dentry *parent,
301 				      const char *target)
302 {
303 	struct dentry *result;
304 	char *link;
305 
306 	link = kstrdup(target, GFP_KERNEL);
307 	if (!link)
308 		return NULL;
309 
310 	result = debugfs_create_file(name, S_IFLNK | S_IRWXUGO, parent, link,
311 				     NULL);
312 	if (!result)
313 		kfree(link);
314 	return result;
315 }
316 EXPORT_SYMBOL_GPL(debugfs_create_symlink);
317 
318 static void __debugfs_remove(struct dentry *dentry, struct dentry *parent)
319 {
320 	int ret = 0;
321 
322 	if (debugfs_positive(dentry)) {
323 		if (dentry->d_inode) {
324 			dget(dentry);
325 			switch (dentry->d_inode->i_mode & S_IFMT) {
326 			case S_IFDIR:
327 				ret = simple_rmdir(parent->d_inode, dentry);
328 				break;
329 			case S_IFLNK:
330 				kfree(dentry->d_inode->i_private);
331 				/* fall through */
332 			default:
333 				simple_unlink(parent->d_inode, dentry);
334 				break;
335 			}
336 			if (!ret)
337 				d_delete(dentry);
338 			dput(dentry);
339 		}
340 	}
341 }
342 
343 /**
344  * debugfs_remove - removes a file or directory from the debugfs filesystem
345  * @dentry: a pointer to a the dentry of the file or directory to be
346  *          removed.
347  *
348  * This function removes a file or directory in debugfs that was previously
349  * created with a call to another debugfs function (like
350  * debugfs_create_file() or variants thereof.)
351  *
352  * This function is required to be called in order for the file to be
353  * removed, no automatic cleanup of files will happen when a module is
354  * removed, you are responsible here.
355  */
356 void debugfs_remove(struct dentry *dentry)
357 {
358 	struct dentry *parent;
359 
360 	if (!dentry)
361 		return;
362 
363 	parent = dentry->d_parent;
364 	if (!parent || !parent->d_inode)
365 		return;
366 
367 	mutex_lock(&parent->d_inode->i_mutex);
368 	__debugfs_remove(dentry, parent);
369 	mutex_unlock(&parent->d_inode->i_mutex);
370 	simple_release_fs(&debugfs_mount, &debugfs_mount_count);
371 }
372 EXPORT_SYMBOL_GPL(debugfs_remove);
373 
374 /**
375  * debugfs_remove_recursive - recursively removes a directory
376  * @dentry: a pointer to a the dentry of the directory to be removed.
377  *
378  * This function recursively removes a directory tree in debugfs that
379  * was previously created with a call to another debugfs function
380  * (like debugfs_create_file() or variants thereof.)
381  *
382  * This function is required to be called in order for the file to be
383  * removed, no automatic cleanup of files will happen when a module is
384  * removed, you are responsible here.
385  */
386 void debugfs_remove_recursive(struct dentry *dentry)
387 {
388 	struct dentry *child;
389 	struct dentry *parent;
390 
391 	if (!dentry)
392 		return;
393 
394 	parent = dentry->d_parent;
395 	if (!parent || !parent->d_inode)
396 		return;
397 
398 	parent = dentry;
399 	mutex_lock(&parent->d_inode->i_mutex);
400 
401 	while (1) {
402 		/*
403 		 * When all dentries under "parent" has been removed,
404 		 * walk up the tree until we reach our starting point.
405 		 */
406 		if (list_empty(&parent->d_subdirs)) {
407 			mutex_unlock(&parent->d_inode->i_mutex);
408 			if (parent == dentry)
409 				break;
410 			parent = parent->d_parent;
411 			mutex_lock(&parent->d_inode->i_mutex);
412 		}
413 		child = list_entry(parent->d_subdirs.next, struct dentry,
414 				d_u.d_child);
415  next_sibling:
416 
417 		/*
418 		 * If "child" isn't empty, walk down the tree and
419 		 * remove all its descendants first.
420 		 */
421 		if (!list_empty(&child->d_subdirs)) {
422 			mutex_unlock(&parent->d_inode->i_mutex);
423 			parent = child;
424 			mutex_lock(&parent->d_inode->i_mutex);
425 			continue;
426 		}
427 		__debugfs_remove(child, parent);
428 		if (parent->d_subdirs.next == &child->d_u.d_child) {
429 			/*
430 			 * Try the next sibling.
431 			 */
432 			if (child->d_u.d_child.next != &parent->d_subdirs) {
433 				child = list_entry(child->d_u.d_child.next,
434 						   struct dentry,
435 						   d_u.d_child);
436 				goto next_sibling;
437 			}
438 
439 			/*
440 			 * Avoid infinite loop if we fail to remove
441 			 * one dentry.
442 			 */
443 			mutex_unlock(&parent->d_inode->i_mutex);
444 			break;
445 		}
446 		simple_release_fs(&debugfs_mount, &debugfs_mount_count);
447 	}
448 
449 	parent = dentry->d_parent;
450 	mutex_lock(&parent->d_inode->i_mutex);
451 	__debugfs_remove(dentry, parent);
452 	mutex_unlock(&parent->d_inode->i_mutex);
453 	simple_release_fs(&debugfs_mount, &debugfs_mount_count);
454 }
455 EXPORT_SYMBOL_GPL(debugfs_remove_recursive);
456 
457 /**
458  * debugfs_rename - rename a file/directory in the debugfs filesystem
459  * @old_dir: a pointer to the parent dentry for the renamed object. This
460  *          should be a directory dentry.
461  * @old_dentry: dentry of an object to be renamed.
462  * @new_dir: a pointer to the parent dentry where the object should be
463  *          moved. This should be a directory dentry.
464  * @new_name: a pointer to a string containing the target name.
465  *
466  * This function renames a file/directory in debugfs.  The target must not
467  * exist for rename to succeed.
468  *
469  * This function will return a pointer to old_dentry (which is updated to
470  * reflect renaming) if it succeeds. If an error occurs, %NULL will be
471  * returned.
472  *
473  * If debugfs is not enabled in the kernel, the value -%ENODEV will be
474  * returned.
475  */
476 struct dentry *debugfs_rename(struct dentry *old_dir, struct dentry *old_dentry,
477 		struct dentry *new_dir, const char *new_name)
478 {
479 	int error;
480 	struct dentry *dentry = NULL, *trap;
481 	const char *old_name;
482 
483 	trap = lock_rename(new_dir, old_dir);
484 	/* Source or destination directories don't exist? */
485 	if (!old_dir->d_inode || !new_dir->d_inode)
486 		goto exit;
487 	/* Source does not exist, cyclic rename, or mountpoint? */
488 	if (!old_dentry->d_inode || old_dentry == trap ||
489 	    d_mountpoint(old_dentry))
490 		goto exit;
491 	dentry = lookup_one_len(new_name, new_dir, strlen(new_name));
492 	/* Lookup failed, cyclic rename or target exists? */
493 	if (IS_ERR(dentry) || dentry == trap || dentry->d_inode)
494 		goto exit;
495 
496 	old_name = fsnotify_oldname_init(old_dentry->d_name.name);
497 
498 	error = simple_rename(old_dir->d_inode, old_dentry, new_dir->d_inode,
499 		dentry);
500 	if (error) {
501 		fsnotify_oldname_free(old_name);
502 		goto exit;
503 	}
504 	d_move(old_dentry, dentry);
505 	fsnotify_move(old_dir->d_inode, new_dir->d_inode, old_name,
506 		old_dentry->d_name.name, S_ISDIR(old_dentry->d_inode->i_mode),
507 		NULL, old_dentry);
508 	fsnotify_oldname_free(old_name);
509 	unlock_rename(new_dir, old_dir);
510 	dput(dentry);
511 	return old_dentry;
512 exit:
513 	if (dentry && !IS_ERR(dentry))
514 		dput(dentry);
515 	unlock_rename(new_dir, old_dir);
516 	return NULL;
517 }
518 EXPORT_SYMBOL_GPL(debugfs_rename);
519 
520 /**
521  * debugfs_initialized - Tells whether debugfs has been registered
522  */
523 bool debugfs_initialized(void)
524 {
525 	return debugfs_registered;
526 }
527 EXPORT_SYMBOL_GPL(debugfs_initialized);
528 
529 
530 static struct kobject *debug_kobj;
531 
532 static int __init debugfs_init(void)
533 {
534 	int retval;
535 
536 	debug_kobj = kobject_create_and_add("debug", kernel_kobj);
537 	if (!debug_kobj)
538 		return -EINVAL;
539 
540 	retval = register_filesystem(&debug_fs_type);
541 	if (retval)
542 		kobject_put(debug_kobj);
543 	else
544 		debugfs_registered = true;
545 
546 	return retval;
547 }
548 
549 static void __exit debugfs_exit(void)
550 {
551 	debugfs_registered = false;
552 
553 	simple_release_fs(&debugfs_mount, &debugfs_mount_count);
554 	unregister_filesystem(&debug_fs_type);
555 	kobject_put(debug_kobj);
556 }
557 
558 core_initcall(debugfs_init);
559 module_exit(debugfs_exit);
560 MODULE_LICENSE("GPL");
561 
562