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
30 #define DEBUGFS_MAGIC 0x64626720
31
32 static struct vfsmount *debugfs_mount;
33 static int debugfs_mount_count;
34
35 static struct inode *debugfs_get_inode(struct super_block *sb, int mode, dev_t dev)
36 {
37 struct inode *inode = new_inode(sb);
38
39 if (inode) {
40 inode->i_mode = mode;
41 inode->i_uid = 0;
42 inode->i_gid = 0;
43 inode->i_blocks = 0;
44 inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
45 switch (mode & S_IFMT) {
46 default:
47 init_special_inode(inode, mode, dev);
48 break;
49 case S_IFREG:
50 inode->i_fop = &debugfs_file_operations;
51 break;
52 case S_IFLNK:
53 inode->i_op = &debugfs_link_operations;
54 break;
55 case S_IFDIR:
56 inode->i_op = &simple_dir_inode_operations;
57 inode->i_fop = &simple_dir_operations;
58
59 /* directory inodes start off with i_nlink == 2
60 * (for "." entry) */
61 inc_nlink(inode);
62 break;
63 }
64 }
65 return inode;
66 }
67
68 /* SMP-safe */
69 static int debugfs_mknod(struct inode *dir, struct dentry *dentry,
70 int mode, dev_t dev)
71 {
72 struct inode *inode;
73 int error = -EPERM;
74
75 if (dentry->d_inode)
76 return -EEXIST;
77
78 inode = debugfs_get_inode(dir->i_sb, mode, dev);
79 if (inode) {
80 d_instantiate(dentry, inode);
81 dget(dentry);
82 error = 0;
83 }
84 return error;
85 }
86
87 static int debugfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
88 {
89 int res;
90
91 mode = (mode & (S_IRWXUGO | S_ISVTX)) | S_IFDIR;
92 res = debugfs_mknod(dir, dentry, mode, 0);
93 if (!res) {
94 inc_nlink(dir);
95 fsnotify_mkdir(dir, dentry);
96 }
97 return res;
98 }
99
100 static int debugfs_link(struct inode *dir, struct dentry *dentry, int mode)
101 {
102 mode = (mode & S_IALLUGO) | S_IFLNK;
103 return debugfs_mknod(dir, dentry, mode, 0);
104 }
105
106 static int debugfs_create(struct inode *dir, struct dentry *dentry, int mode)
107 {
108 int res;
109
110 mode = (mode & S_IALLUGO) | S_IFREG;
111 res = debugfs_mknod(dir, dentry, mode, 0);
112 if (!res)
113 fsnotify_create(dir, dentry);
114 return res;
115 }
116
117 static inline int debugfs_positive(struct dentry *dentry)
118 {
119 return dentry->d_inode && !d_unhashed(dentry);
120 }
121
122 static int debug_fill_super(struct super_block *sb, void *data, int silent)
123 {
124 static struct tree_descr debug_files[] = {{""}};
125
126 return simple_fill_super(sb, DEBUGFS_MAGIC, debug_files);
127 }
128
129 static int debug_get_sb(struct file_system_type *fs_type,
130 int flags, const char *dev_name,
131 void *data, struct vfsmount *mnt)
132 {
133 return get_sb_single(fs_type, flags, data, debug_fill_super, mnt);
134 }
135
136 static struct file_system_type debug_fs_type = {
137 .owner = THIS_MODULE,
138 .name = "debugfs",
139 .get_sb = debug_get_sb,
140 .kill_sb = kill_litter_super,
141 };
142
143 static int debugfs_create_by_name(const char *name, mode_t mode,
144 struct dentry *parent,
145 struct dentry **dentry)
146 {
147 int error = 0;
148
149 /* If the parent is not specified, we create it in the root.
150 * We need the root dentry to do this, which is in the super
151 * block. A pointer to that is in the struct vfsmount that we
152 * have around.
153 */
154 if (!parent) {
155 if (debugfs_mount && debugfs_mount->mnt_sb) {
156 parent = debugfs_mount->mnt_sb->s_root;
157 }
158 }
159 if (!parent) {
160 pr_debug("debugfs: Ah! can not find a parent!\n");
161 return -EFAULT;
162 }
163
164 *dentry = NULL;
165 mutex_lock(&parent->d_inode->i_mutex);
166 *dentry = lookup_one_len(name, parent, strlen(name));
167 if (!IS_ERR(*dentry)) {
168 switch (mode & S_IFMT) {
169 case S_IFDIR:
170 error = debugfs_mkdir(parent->d_inode, *dentry, mode);
171 break;
172 case S_IFLNK:
173 error = debugfs_link(parent->d_inode, *dentry, mode);
174 break;
175 default:
176 error = debugfs_create(parent->d_inode, *dentry, mode);
177 break;
178 }
179 dput(*dentry);
180 } else
181 error = PTR_ERR(*dentry);
182 mutex_unlock(&parent->d_inode->i_mutex);
183
184 return error;
185 }
186
187 /**
188 * debugfs_create_file - create a file in the debugfs filesystem
189 * @name: a pointer to a string containing the name of the file to create.
190 * @mode: the permission that the file should have
191 * @parent: a pointer to the parent dentry for this file. This should be a
192 * directory dentry if set. If this paramater is NULL, then the
193 * file will be created in the root of the debugfs filesystem.
194 * @data: a pointer to something that the caller will want to get to later
195 * on. The inode.i_private pointer will point to this value on
196 * the open() call.
197 * @fops: a pointer to a struct file_operations that should be used for
198 * this file.
199 *
200 * This is the basic "create a file" function for debugfs. It allows for a
201 * wide range of flexibility in createing a file, or a directory (if you
202 * want to create a directory, the debugfs_create_dir() function is
203 * recommended to be used instead.)
204 *
205 * This function will return a pointer to a dentry if it succeeds. This
206 * pointer must be passed to the debugfs_remove() function when the file is
207 * to be removed (no automatic cleanup happens if your module is unloaded,
208 * you are responsible here.) If an error occurs, %NULL will be returned.
209 *
210 * If debugfs is not enabled in the kernel, the value -%ENODEV will be
211 * returned.
212 */
213 struct dentry *debugfs_create_file(const char *name, mode_t mode,
214 struct dentry *parent, void *data,
215 const struct file_operations *fops)
216 {
217 struct dentry *dentry = NULL;
218 int error;
219
220 pr_debug("debugfs: creating file '%s'\n",name);
221
222 error = simple_pin_fs(&debug_fs_type, &debugfs_mount,
223 &debugfs_mount_count);
224 if (error)
225 goto exit;
226
227 error = debugfs_create_by_name(name, mode, parent, &dentry);
228 if (error) {
229 dentry = NULL;
230 simple_release_fs(&debugfs_mount, &debugfs_mount_count);
231 goto exit;
232 }
233
234 if (dentry->d_inode) {
235 if (data)
236 dentry->d_inode->i_private = data;
237 if (fops)
238 dentry->d_inode->i_fop = fops;
239 }
240 exit:
241 return dentry;
242 }
243 EXPORT_SYMBOL_GPL(debugfs_create_file);
244
245 /**
246 * debugfs_create_dir - create a directory in the debugfs filesystem
247 * @name: a pointer to a string containing the name of the directory to
248 * create.
249 * @parent: a pointer to the parent dentry for this file. This should be a
250 * directory dentry if set. If this paramater is NULL, then the
251 * directory will be created in the root of the debugfs filesystem.
252 *
253 * This function creates a directory in debugfs with the given name.
254 *
255 * This function will return a pointer to a dentry if it succeeds. This
256 * pointer must be passed to the debugfs_remove() function when the file is
257 * to be removed (no automatic cleanup happens if your module is unloaded,
258 * you are responsible here.) If an error occurs, %NULL will be returned.
259 *
260 * If debugfs is not enabled in the kernel, the value -%ENODEV will be
261 * returned.
262 */
263 struct dentry *debugfs_create_dir(const char *name, struct dentry *parent)
264 {
265 return debugfs_create_file(name,
266 S_IFDIR | S_IRWXU | S_IRUGO | S_IXUGO,
267 parent, NULL, NULL);
268 }
269 EXPORT_SYMBOL_GPL(debugfs_create_dir);
270
271 /**
272 * debugfs_create_symlink- create a symbolic link in the debugfs filesystem
273 * @name: a pointer to a string containing the name of the symbolic link to
274 * create.
275 * @parent: a pointer to the parent dentry for this symbolic link. This
276 * should be a directory dentry if set. If this paramater is NULL,
277 * then the symbolic link will be created in the root of the debugfs
278 * filesystem.
279 * @target: a pointer to a string containing the path to the target of the
280 * symbolic link.
281 *
282 * This function creates a symbolic link with the given name in debugfs that
283 * links to the given target path.
284 *
285 * This function will return a pointer to a dentry if it succeeds. This
286 * pointer must be passed to the debugfs_remove() function when the symbolic
287 * link is to be removed (no automatic cleanup happens if your module is
288 * unloaded, you are responsible here.) If an error occurs, %NULL will be
289 * returned.
290 *
291 * If debugfs is not enabled in the kernel, the value -%ENODEV will be
292 * returned.
293 */
294 struct dentry *debugfs_create_symlink(const char *name, struct dentry *parent,
295 const char *target)
296 {
297 struct dentry *result;
298 char *link;
299
300 link = kstrdup(target, GFP_KERNEL);
301 if (!link)
302 return NULL;
303
304 result = debugfs_create_file(name, S_IFLNK | S_IRWXUGO, parent, link,
305 NULL);
306 if (!result)
307 kfree(link);
308 return result;
309 }
310 EXPORT_SYMBOL_GPL(debugfs_create_symlink);
311
312 /**
313 * debugfs_remove - removes a file or directory from the debugfs filesystem
314 * @dentry: a pointer to a the dentry of the file or directory to be
315 * removed.
316 *
317 * This function removes a file or directory in debugfs that was previously
318 * created with a call to another debugfs function (like
319 * debugfs_create_file() or variants thereof.)
320 *
321 * This function is required to be called in order for the file to be
322 * removed, no automatic cleanup of files will happen when a module is
323 * removed, you are responsible here.
324 */
325 void debugfs_remove(struct dentry *dentry)
326 {
327 struct dentry *parent;
328 int ret = 0;
329
330 if (!dentry)
331 return;
332
333 parent = dentry->d_parent;
334 if (!parent || !parent->d_inode)
335 return;
336
337 mutex_lock(&parent->d_inode->i_mutex);
338 if (debugfs_positive(dentry)) {
339 if (dentry->d_inode) {
340 dget(dentry);
341 switch (dentry->d_inode->i_mode & S_IFMT) {
342 case S_IFDIR:
343 ret = simple_rmdir(parent->d_inode, dentry);
344 break;
345 case S_IFLNK:
346 kfree(dentry->d_inode->i_private);
347 /* fall through */
348 default:
349 simple_unlink(parent->d_inode, dentry);
350 break;
351 }
352 if (!ret)
353 d_delete(dentry);
354 dput(dentry);
355 }
356 }
357 mutex_unlock(&parent->d_inode->i_mutex);
358 simple_release_fs(&debugfs_mount, &debugfs_mount_count);
359 }
360 EXPORT_SYMBOL_GPL(debugfs_remove);
361
362 /**
363 * debugfs_rename - rename a file/directory in the debugfs filesystem
364 * @old_dir: a pointer to the parent dentry for the renamed object. This
365 * should be a directory dentry.
366 * @old_dentry: dentry of an object to be renamed.
367 * @new_dir: a pointer to the parent dentry where the object should be
368 * moved. This should be a directory dentry.
369 * @new_name: a pointer to a string containing the target name.
370 *
371 * This function renames a file/directory in debugfs. The target must not
372 * exist for rename to succeed.
373 *
374 * This function will return a pointer to old_dentry (which is updated to
375 * reflect renaming) if it succeeds. If an error occurs, %NULL will be
376 * returned.
377 *
378 * If debugfs is not enabled in the kernel, the value -%ENODEV will be
379 * returned.
380 */
381 struct dentry *debugfs_rename(struct dentry *old_dir, struct dentry *old_dentry,
382 struct dentry *new_dir, const char *new_name)
383 {
384 int error;
385 struct dentry *dentry = NULL, *trap;
386 const char *old_name;
387
388 trap = lock_rename(new_dir, old_dir);
389 /* Source or destination directories don't exist? */
390 if (!old_dir->d_inode || !new_dir->d_inode)
391 goto exit;
392 /* Source does not exist, cyclic rename, or mountpoint? */
393 if (!old_dentry->d_inode || old_dentry == trap ||
394 d_mountpoint(old_dentry))
395 goto exit;
396 dentry = lookup_one_len(new_name, new_dir, strlen(new_name));
397 /* Lookup failed, cyclic rename or target exists? */
398 if (IS_ERR(dentry) || dentry == trap || dentry->d_inode)
399 goto exit;
400
401 old_name = fsnotify_oldname_init(old_dentry->d_name.name);
402
403 error = simple_rename(old_dir->d_inode, old_dentry, new_dir->d_inode,
404 dentry);
405 if (error) {
406 fsnotify_oldname_free(old_name);
407 goto exit;
408 }
409 d_move(old_dentry, dentry);
410 fsnotify_move(old_dir->d_inode, new_dir->d_inode, old_name,
411 old_dentry->d_name.name, S_ISDIR(old_dentry->d_inode->i_mode),
412 NULL, old_dentry);
413 fsnotify_oldname_free(old_name);
414 unlock_rename(new_dir, old_dir);
415 dput(dentry);
416 return old_dentry;
417 exit:
418 if (dentry && !IS_ERR(dentry))
419 dput(dentry);
420 unlock_rename(new_dir, old_dir);
421 return NULL;
422 }
423 EXPORT_SYMBOL_GPL(debugfs_rename);
424
425 static struct kobject *debug_kobj;
426
427 static int __init debugfs_init(void)
428 {
429 int retval;
430
431 debug_kobj = kobject_create_and_add("debug", kernel_kobj);
432 if (!debug_kobj)
433 return -EINVAL;
434
435 retval = register_filesystem(&debug_fs_type);
436 if (retval)
437 kobject_put(debug_kobj);
438 return retval;
439 }
440
441 static void __exit debugfs_exit(void)
442 {
443 simple_release_fs(&debugfs_mount, &debugfs_mount_count);
444 unregister_filesystem(&debug_fs_type);
445 kobject_put(debug_kobj);
446 }
447
448 core_initcall(debugfs_init);
449 module_exit(debugfs_exit);
450 MODULE_LICENSE("GPL");
451
452
|
This page was automatically generated by the
LXR engine.
|