~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/debugfs/inode.c

Version: ~ [ linux-5.1-rc5 ] ~ [ linux-5.0.7 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.34 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.111 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.168 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.178 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.138 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.65 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.39.4 ] ~ [ linux-2.6.38.8 ] ~ [ linux-2.6.37.6 ] ~ [ linux-2.6.36.4 ] ~ [ linux-2.6.35.14 ] ~ [ linux-2.6.34.15 ] ~ [ linux-2.6.33.20 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 // SPDX-License-Identifier: GPL-2.0
  2 /*
  3  *  inode.c - part of debugfs, a tiny little debug file system
  4  *
  5  *  Copyright (C) 2004 Greg Kroah-Hartman <greg@kroah.com>
  6  *  Copyright (C) 2004 IBM Inc.
  7  *
  8  *  debugfs is for people to use instead of /proc or /sys.
  9  *  See ./Documentation/core-api/kernel-api.rst for more details.
 10  */
 11 
 12 #include <linux/module.h>
 13 #include <linux/fs.h>
 14 #include <linux/mount.h>
 15 #include <linux/pagemap.h>
 16 #include <linux/init.h>
 17 #include <linux/kobject.h>
 18 #include <linux/namei.h>
 19 #include <linux/debugfs.h>
 20 #include <linux/fsnotify.h>
 21 #include <linux/string.h>
 22 #include <linux/seq_file.h>
 23 #include <linux/parser.h>
 24 #include <linux/magic.h>
 25 #include <linux/slab.h>
 26 
 27 #include "internal.h"
 28 
 29 #define DEBUGFS_DEFAULT_MODE    0700
 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)
 36 {
 37         struct inode *inode = new_inode(sb);
 38         if (inode) {
 39                 inode->i_ino = get_next_ino();
 40                 inode->i_atime = inode->i_mtime =
 41                         inode->i_ctime = current_time(inode);
 42         }
 43         return inode;
 44 }
 45 
 46 struct debugfs_mount_opts {
 47         kuid_t uid;
 48         kgid_t gid;
 49         umode_t mode;
 50 };
 51 
 52 enum {
 53         Opt_uid,
 54         Opt_gid,
 55         Opt_mode,
 56         Opt_err
 57 };
 58 
 59 static const match_table_t tokens = {
 60         {Opt_uid, "uid=%u"},
 61         {Opt_gid, "gid=%u"},
 62         {Opt_mode, "mode=%o"},
 63         {Opt_err, NULL}
 64 };
 65 
 66 struct debugfs_fs_info {
 67         struct debugfs_mount_opts mount_opts;
 68 };
 69 
 70 static int debugfs_parse_options(char *data, struct debugfs_mount_opts *opts)
 71 {
 72         substring_t args[MAX_OPT_ARGS];
 73         int option;
 74         int token;
 75         kuid_t uid;
 76         kgid_t gid;
 77         char *p;
 78 
 79         opts->mode = DEBUGFS_DEFAULT_MODE;
 80 
 81         while ((p = strsep(&data, ",")) != NULL) {
 82                 if (!*p)
 83                         continue;
 84 
 85                 token = match_token(p, tokens, args);
 86                 switch (token) {
 87                 case Opt_uid:
 88                         if (match_int(&args[0], &option))
 89                                 return -EINVAL;
 90                         uid = make_kuid(current_user_ns(), option);
 91                         if (!uid_valid(uid))
 92                                 return -EINVAL;
 93                         opts->uid = uid;
 94                         break;
 95                 case Opt_gid:
 96                         if (match_int(&args[0], &option))
 97                                 return -EINVAL;
 98                         gid = make_kgid(current_user_ns(), option);
 99                         if (!gid_valid(gid))
100                                 return -EINVAL;
101                         opts->gid = gid;
102                         break;
103                 case Opt_mode:
104                         if (match_octal(&args[0], &option))
105                                 return -EINVAL;
106                         opts->mode = option & S_IALLUGO;
107                         break;
108                 /*
109                  * We might like to report bad mount options here;
110                  * but traditionally debugfs has ignored all mount options
111                  */
112                 }
113         }
114 
115         return 0;
116 }
117 
118 static int debugfs_apply_options(struct super_block *sb)
119 {
120         struct debugfs_fs_info *fsi = sb->s_fs_info;
121         struct inode *inode = d_inode(sb->s_root);
122         struct debugfs_mount_opts *opts = &fsi->mount_opts;
123 
124         inode->i_mode &= ~S_IALLUGO;
125         inode->i_mode |= opts->mode;
126 
127         inode->i_uid = opts->uid;
128         inode->i_gid = opts->gid;
129 
130         return 0;
131 }
132 
133 static int debugfs_remount(struct super_block *sb, int *flags, char *data)
134 {
135         int err;
136         struct debugfs_fs_info *fsi = sb->s_fs_info;
137 
138         sync_filesystem(sb);
139         err = debugfs_parse_options(data, &fsi->mount_opts);
140         if (err)
141                 goto fail;
142 
143         debugfs_apply_options(sb);
144 
145 fail:
146         return err;
147 }
148 
149 static int debugfs_show_options(struct seq_file *m, struct dentry *root)
150 {
151         struct debugfs_fs_info *fsi = root->d_sb->s_fs_info;
152         struct debugfs_mount_opts *opts = &fsi->mount_opts;
153 
154         if (!uid_eq(opts->uid, GLOBAL_ROOT_UID))
155                 seq_printf(m, ",uid=%u",
156                            from_kuid_munged(&init_user_ns, opts->uid));
157         if (!gid_eq(opts->gid, GLOBAL_ROOT_GID))
158                 seq_printf(m, ",gid=%u",
159                            from_kgid_munged(&init_user_ns, opts->gid));
160         if (opts->mode != DEBUGFS_DEFAULT_MODE)
161                 seq_printf(m, ",mode=%o", opts->mode);
162 
163         return 0;
164 }
165 
166 static void debugfs_i_callback(struct rcu_head *head)
167 {
168         struct inode *inode = container_of(head, struct inode, i_rcu);
169         if (S_ISLNK(inode->i_mode))
170                 kfree(inode->i_link);
171         free_inode_nonrcu(inode);
172 }
173 
174 static void debugfs_destroy_inode(struct inode *inode)
175 {
176         call_rcu(&inode->i_rcu, debugfs_i_callback);
177 }
178 
179 static const struct super_operations debugfs_super_operations = {
180         .statfs         = simple_statfs,
181         .remount_fs     = debugfs_remount,
182         .show_options   = debugfs_show_options,
183         .destroy_inode  = debugfs_destroy_inode,
184 };
185 
186 static void debugfs_release_dentry(struct dentry *dentry)
187 {
188         void *fsd = dentry->d_fsdata;
189 
190         if (!((unsigned long)fsd & DEBUGFS_FSDATA_IS_REAL_FOPS_BIT))
191                 kfree(dentry->d_fsdata);
192 }
193 
194 static struct vfsmount *debugfs_automount(struct path *path)
195 {
196         debugfs_automount_t f;
197         f = (debugfs_automount_t)path->dentry->d_fsdata;
198         return f(path->dentry, d_inode(path->dentry)->i_private);
199 }
200 
201 static const struct dentry_operations debugfs_dops = {
202         .d_delete = always_delete_dentry,
203         .d_release = debugfs_release_dentry,
204         .d_automount = debugfs_automount,
205 };
206 
207 static int debug_fill_super(struct super_block *sb, void *data, int silent)
208 {
209         static const struct tree_descr debug_files[] = {{""}};
210         struct debugfs_fs_info *fsi;
211         int err;
212 
213         fsi = kzalloc(sizeof(struct debugfs_fs_info), GFP_KERNEL);
214         sb->s_fs_info = fsi;
215         if (!fsi) {
216                 err = -ENOMEM;
217                 goto fail;
218         }
219 
220         err = debugfs_parse_options(data, &fsi->mount_opts);
221         if (err)
222                 goto fail;
223 
224         err  =  simple_fill_super(sb, DEBUGFS_MAGIC, debug_files);
225         if (err)
226                 goto fail;
227 
228         sb->s_op = &debugfs_super_operations;
229         sb->s_d_op = &debugfs_dops;
230 
231         debugfs_apply_options(sb);
232 
233         return 0;
234 
235 fail:
236         kfree(fsi);
237         sb->s_fs_info = NULL;
238         return err;
239 }
240 
241 static struct dentry *debug_mount(struct file_system_type *fs_type,
242                         int flags, const char *dev_name,
243                         void *data)
244 {
245         return mount_single(fs_type, flags, data, debug_fill_super);
246 }
247 
248 static struct file_system_type debug_fs_type = {
249         .owner =        THIS_MODULE,
250         .name =         "debugfs",
251         .mount =        debug_mount,
252         .kill_sb =      kill_litter_super,
253 };
254 MODULE_ALIAS_FS("debugfs");
255 
256 /**
257  * debugfs_lookup() - look up an existing debugfs file
258  * @name: a pointer to a string containing the name of the file to look up.
259  * @parent: a pointer to the parent dentry of the file.
260  *
261  * This function will return a pointer to a dentry if it succeeds.  If the file
262  * doesn't exist or an error occurs, %NULL will be returned.  The returned
263  * dentry must be passed to dput() when it is no longer needed.
264  *
265  * If debugfs is not enabled in the kernel, the value -%ENODEV will be
266  * returned.
267  */
268 struct dentry *debugfs_lookup(const char *name, struct dentry *parent)
269 {
270         struct dentry *dentry;
271 
272         if (IS_ERR(parent))
273                 return NULL;
274 
275         if (!parent)
276                 parent = debugfs_mount->mnt_root;
277 
278         dentry = lookup_one_len_unlocked(name, parent, strlen(name));
279         if (IS_ERR(dentry))
280                 return NULL;
281         if (!d_really_is_positive(dentry)) {
282                 dput(dentry);
283                 return NULL;
284         }
285         return dentry;
286 }
287 EXPORT_SYMBOL_GPL(debugfs_lookup);
288 
289 static struct dentry *start_creating(const char *name, struct dentry *parent)
290 {
291         struct dentry *dentry;
292         int error;
293 
294         pr_debug("debugfs: creating file '%s'\n",name);
295 
296         if (IS_ERR(parent))
297                 return parent;
298 
299         error = simple_pin_fs(&debug_fs_type, &debugfs_mount,
300                               &debugfs_mount_count);
301         if (error)
302                 return ERR_PTR(error);
303 
304         /* If the parent is not specified, we create it in the root.
305          * We need the root dentry to do this, which is in the super
306          * block. A pointer to that is in the struct vfsmount that we
307          * have around.
308          */
309         if (!parent)
310                 parent = debugfs_mount->mnt_root;
311 
312         inode_lock(d_inode(parent));
313         dentry = lookup_one_len(name, parent, strlen(name));
314         if (!IS_ERR(dentry) && d_really_is_positive(dentry)) {
315                 dput(dentry);
316                 dentry = ERR_PTR(-EEXIST);
317         }
318 
319         if (IS_ERR(dentry)) {
320                 inode_unlock(d_inode(parent));
321                 simple_release_fs(&debugfs_mount, &debugfs_mount_count);
322         }
323 
324         return dentry;
325 }
326 
327 static struct dentry *failed_creating(struct dentry *dentry)
328 {
329         inode_unlock(d_inode(dentry->d_parent));
330         dput(dentry);
331         simple_release_fs(&debugfs_mount, &debugfs_mount_count);
332         return ERR_PTR(-ENOMEM);
333 }
334 
335 static struct dentry *end_creating(struct dentry *dentry)
336 {
337         inode_unlock(d_inode(dentry->d_parent));
338         return dentry;
339 }
340 
341 static struct dentry *__debugfs_create_file(const char *name, umode_t mode,
342                                 struct dentry *parent, void *data,
343                                 const struct file_operations *proxy_fops,
344                                 const struct file_operations *real_fops)
345 {
346         struct dentry *dentry;
347         struct inode *inode;
348 
349         if (!(mode & S_IFMT))
350                 mode |= S_IFREG;
351         BUG_ON(!S_ISREG(mode));
352         dentry = start_creating(name, parent);
353 
354         if (IS_ERR(dentry))
355                 return dentry;
356 
357         inode = debugfs_get_inode(dentry->d_sb);
358         if (unlikely(!inode))
359                 return failed_creating(dentry);
360 
361         inode->i_mode = mode;
362         inode->i_private = data;
363 
364         inode->i_fop = proxy_fops;
365         dentry->d_fsdata = (void *)((unsigned long)real_fops |
366                                 DEBUGFS_FSDATA_IS_REAL_FOPS_BIT);
367 
368         d_instantiate(dentry, inode);
369         fsnotify_create(d_inode(dentry->d_parent), dentry);
370         return end_creating(dentry);
371 }
372 
373 /**
374  * debugfs_create_file - create a file in the debugfs filesystem
375  * @name: a pointer to a string containing the name of the file to create.
376  * @mode: the permission that the file should have.
377  * @parent: a pointer to the parent dentry for this file.  This should be a
378  *          directory dentry if set.  If this parameter is NULL, then the
379  *          file will be created in the root of the debugfs filesystem.
380  * @data: a pointer to something that the caller will want to get to later
381  *        on.  The inode.i_private pointer will point to this value on
382  *        the open() call.
383  * @fops: a pointer to a struct file_operations that should be used for
384  *        this file.
385  *
386  * This is the basic "create a file" function for debugfs.  It allows for a
387  * wide range of flexibility in creating a file, or a directory (if you want
388  * to create a directory, the debugfs_create_dir() function is
389  * recommended to be used instead.)
390  *
391  * This function will return a pointer to a dentry if it succeeds.  This
392  * pointer must be passed to the debugfs_remove() function when the file is
393  * to be removed (no automatic cleanup happens if your module is unloaded,
394  * you are responsible here.)  If an error occurs, %ERR_PTR(-ERROR) will be
395  * returned.
396  *
397  * If debugfs is not enabled in the kernel, the value -%ENODEV will be
398  * returned.
399  */
400 struct dentry *debugfs_create_file(const char *name, umode_t mode,
401                                    struct dentry *parent, void *data,
402                                    const struct file_operations *fops)
403 {
404 
405         return __debugfs_create_file(name, mode, parent, data,
406                                 fops ? &debugfs_full_proxy_file_operations :
407                                         &debugfs_noop_file_operations,
408                                 fops);
409 }
410 EXPORT_SYMBOL_GPL(debugfs_create_file);
411 
412 /**
413  * debugfs_create_file_unsafe - create a file in the debugfs filesystem
414  * @name: a pointer to a string containing the name of the file to create.
415  * @mode: the permission that the file should have.
416  * @parent: a pointer to the parent dentry for this file.  This should be a
417  *          directory dentry if set.  If this parameter is NULL, then the
418  *          file will be created in the root of the debugfs filesystem.
419  * @data: a pointer to something that the caller will want to get to later
420  *        on.  The inode.i_private pointer will point to this value on
421  *        the open() call.
422  * @fops: a pointer to a struct file_operations that should be used for
423  *        this file.
424  *
425  * debugfs_create_file_unsafe() is completely analogous to
426  * debugfs_create_file(), the only difference being that the fops
427  * handed it will not get protected against file removals by the
428  * debugfs core.
429  *
430  * It is your responsibility to protect your struct file_operation
431  * methods against file removals by means of debugfs_file_get()
432  * and debugfs_file_put(). ->open() is still protected by
433  * debugfs though.
434  *
435  * Any struct file_operations defined by means of
436  * DEFINE_DEBUGFS_ATTRIBUTE() is protected against file removals and
437  * thus, may be used here.
438  */
439 struct dentry *debugfs_create_file_unsafe(const char *name, umode_t mode,
440                                    struct dentry *parent, void *data,
441                                    const struct file_operations *fops)
442 {
443 
444         return __debugfs_create_file(name, mode, parent, data,
445                                 fops ? &debugfs_open_proxy_file_operations :
446                                         &debugfs_noop_file_operations,
447                                 fops);
448 }
449 EXPORT_SYMBOL_GPL(debugfs_create_file_unsafe);
450 
451 /**
452  * debugfs_create_file_size - create a file in the debugfs filesystem
453  * @name: a pointer to a string containing the name of the file to create.
454  * @mode: the permission that the file should have.
455  * @parent: a pointer to the parent dentry for this file.  This should be a
456  *          directory dentry if set.  If this parameter is NULL, then the
457  *          file will be created in the root of the debugfs filesystem.
458  * @data: a pointer to something that the caller will want to get to later
459  *        on.  The inode.i_private pointer will point to this value on
460  *        the open() call.
461  * @fops: a pointer to a struct file_operations that should be used for
462  *        this file.
463  * @file_size: initial file size
464  *
465  * This is the basic "create a file" function for debugfs.  It allows for a
466  * wide range of flexibility in creating a file, or a directory (if you want
467  * to create a directory, the debugfs_create_dir() function is
468  * recommended to be used instead.)
469  *
470  * This function will return a pointer to a dentry if it succeeds.  This
471  * pointer must be passed to the debugfs_remove() function when the file is
472  * to be removed (no automatic cleanup happens if your module is unloaded,
473  * you are responsible here.)  If an error occurs, %ERR_PTR(-ERROR) will be
474  * returned.
475  *
476  * If debugfs is not enabled in the kernel, the value -%ENODEV will be
477  * returned.
478  */
479 struct dentry *debugfs_create_file_size(const char *name, umode_t mode,
480                                         struct dentry *parent, void *data,
481                                         const struct file_operations *fops,
482                                         loff_t file_size)
483 {
484         struct dentry *de = debugfs_create_file(name, mode, parent, data, fops);
485 
486         if (de)
487                 d_inode(de)->i_size = file_size;
488         return de;
489 }
490 EXPORT_SYMBOL_GPL(debugfs_create_file_size);
491 
492 /**
493  * debugfs_create_dir - create a directory in the debugfs filesystem
494  * @name: a pointer to a string containing the name of the directory to
495  *        create.
496  * @parent: a pointer to the parent dentry for this file.  This should be a
497  *          directory dentry if set.  If this parameter is NULL, then the
498  *          directory will be created in the root of the debugfs filesystem.
499  *
500  * This function creates a directory in debugfs with the given name.
501  *
502  * This function will return a pointer to a dentry if it succeeds.  This
503  * pointer must be passed to the debugfs_remove() function when the file is
504  * to be removed (no automatic cleanup happens if your module is unloaded,
505  * you are responsible here.)  If an error occurs, %ERR_PTR(-ERROR) will be
506  * returned.
507  *
508  * If debugfs is not enabled in the kernel, the value -%ENODEV will be
509  * returned.
510  */
511 struct dentry *debugfs_create_dir(const char *name, struct dentry *parent)
512 {
513         struct dentry *dentry = start_creating(name, parent);
514         struct inode *inode;
515 
516         if (IS_ERR(dentry))
517                 return dentry;
518 
519         inode = debugfs_get_inode(dentry->d_sb);
520         if (unlikely(!inode))
521                 return failed_creating(dentry);
522 
523         inode->i_mode = S_IFDIR | S_IRWXU | S_IRUGO | S_IXUGO;
524         inode->i_op = &simple_dir_inode_operations;
525         inode->i_fop = &simple_dir_operations;
526 
527         /* directory inodes start off with i_nlink == 2 (for "." entry) */
528         inc_nlink(inode);
529         d_instantiate(dentry, inode);
530         inc_nlink(d_inode(dentry->d_parent));
531         fsnotify_mkdir(d_inode(dentry->d_parent), dentry);
532         return end_creating(dentry);
533 }
534 EXPORT_SYMBOL_GPL(debugfs_create_dir);
535 
536 /**
537  * debugfs_create_automount - create automount point in the debugfs filesystem
538  * @name: a pointer to a string containing the name of the file to create.
539  * @parent: a pointer to the parent dentry for this file.  This should be a
540  *          directory dentry if set.  If this parameter is NULL, then the
541  *          file will be created in the root of the debugfs filesystem.
542  * @f: function to be called when pathname resolution steps on that one.
543  * @data: opaque argument to pass to f().
544  *
545  * @f should return what ->d_automount() would.
546  */
547 struct dentry *debugfs_create_automount(const char *name,
548                                         struct dentry *parent,
549                                         debugfs_automount_t f,
550                                         void *data)
551 {
552         struct dentry *dentry = start_creating(name, parent);
553         struct inode *inode;
554 
555         if (IS_ERR(dentry))
556                 return dentry;
557 
558         inode = debugfs_get_inode(dentry->d_sb);
559         if (unlikely(!inode))
560                 return failed_creating(dentry);
561 
562         make_empty_dir_inode(inode);
563         inode->i_flags |= S_AUTOMOUNT;
564         inode->i_private = data;
565         dentry->d_fsdata = (void *)f;
566         /* directory inodes start off with i_nlink == 2 (for "." entry) */
567         inc_nlink(inode);
568         d_instantiate(dentry, inode);
569         inc_nlink(d_inode(dentry->d_parent));
570         fsnotify_mkdir(d_inode(dentry->d_parent), dentry);
571         return end_creating(dentry);
572 }
573 EXPORT_SYMBOL(debugfs_create_automount);
574 
575 /**
576  * debugfs_create_symlink- create a symbolic link in the debugfs filesystem
577  * @name: a pointer to a string containing the name of the symbolic link to
578  *        create.
579  * @parent: a pointer to the parent dentry for this symbolic link.  This
580  *          should be a directory dentry if set.  If this parameter is NULL,
581  *          then the symbolic link will be created in the root of the debugfs
582  *          filesystem.
583  * @target: a pointer to a string containing the path to the target of the
584  *          symbolic link.
585  *
586  * This function creates a symbolic link with the given name in debugfs that
587  * links to the given target path.
588  *
589  * This function will return a pointer to a dentry if it succeeds.  This
590  * pointer must be passed to the debugfs_remove() function when the symbolic
591  * link is to be removed (no automatic cleanup happens if your module is
592  * unloaded, you are responsible here.)  If an error occurs, %ERR_PTR(-ERROR)
593  * will be returned.
594  *
595  * If debugfs is not enabled in the kernel, the value -%ENODEV will be
596  * returned.
597  */
598 struct dentry *debugfs_create_symlink(const char *name, struct dentry *parent,
599                                       const char *target)
600 {
601         struct dentry *dentry;
602         struct inode *inode;
603         char *link = kstrdup(target, GFP_KERNEL);
604         if (!link)
605                 return ERR_PTR(-ENOMEM);
606 
607         dentry = start_creating(name, parent);
608         if (IS_ERR(dentry)) {
609                 kfree(link);
610                 return dentry;
611         }
612 
613         inode = debugfs_get_inode(dentry->d_sb);
614         if (unlikely(!inode)) {
615                 kfree(link);
616                 return failed_creating(dentry);
617         }
618         inode->i_mode = S_IFLNK | S_IRWXUGO;
619         inode->i_op = &simple_symlink_inode_operations;
620         inode->i_link = link;
621         d_instantiate(dentry, inode);
622         return end_creating(dentry);
623 }
624 EXPORT_SYMBOL_GPL(debugfs_create_symlink);
625 
626 static void __debugfs_remove_file(struct dentry *dentry, struct dentry *parent)
627 {
628         struct debugfs_fsdata *fsd;
629 
630         simple_unlink(d_inode(parent), dentry);
631         d_delete(dentry);
632 
633         /*
634          * Paired with the closing smp_mb() implied by a successful
635          * cmpxchg() in debugfs_file_get(): either
636          * debugfs_file_get() must see a dead dentry or we must see a
637          * debugfs_fsdata instance at ->d_fsdata here (or both).
638          */
639         smp_mb();
640         fsd = READ_ONCE(dentry->d_fsdata);
641         if ((unsigned long)fsd & DEBUGFS_FSDATA_IS_REAL_FOPS_BIT)
642                 return;
643         if (!refcount_dec_and_test(&fsd->active_users))
644                 wait_for_completion(&fsd->active_users_drained);
645 }
646 
647 static int __debugfs_remove(struct dentry *dentry, struct dentry *parent)
648 {
649         int ret = 0;
650 
651         if (simple_positive(dentry)) {
652                 dget(dentry);
653                 if (!d_is_reg(dentry)) {
654                         if (d_is_dir(dentry))
655                                 ret = simple_rmdir(d_inode(parent), dentry);
656                         else
657                                 simple_unlink(d_inode(parent), dentry);
658                         if (!ret)
659                                 d_delete(dentry);
660                 } else {
661                         __debugfs_remove_file(dentry, parent);
662                 }
663                 dput(dentry);
664         }
665         return ret;
666 }
667 
668 /**
669  * debugfs_remove - removes a file or directory from the debugfs filesystem
670  * @dentry: a pointer to a the dentry of the file or directory to be
671  *          removed.  If this parameter is NULL or an error value, nothing
672  *          will be done.
673  *
674  * This function removes a file or directory in debugfs that was previously
675  * created with a call to another debugfs function (like
676  * debugfs_create_file() or variants thereof.)
677  *
678  * This function is required to be called in order for the file to be
679  * removed, no automatic cleanup of files will happen when a module is
680  * removed, you are responsible here.
681  */
682 void debugfs_remove(struct dentry *dentry)
683 {
684         struct dentry *parent;
685         int ret;
686 
687         if (IS_ERR_OR_NULL(dentry))
688                 return;
689 
690         parent = dentry->d_parent;
691         inode_lock(d_inode(parent));
692         ret = __debugfs_remove(dentry, parent);
693         inode_unlock(d_inode(parent));
694         if (!ret)
695                 simple_release_fs(&debugfs_mount, &debugfs_mount_count);
696 }
697 EXPORT_SYMBOL_GPL(debugfs_remove);
698 
699 /**
700  * debugfs_remove_recursive - recursively removes a directory
701  * @dentry: a pointer to a the dentry of the directory to be removed.  If this
702  *          parameter is NULL or an error value, nothing will be done.
703  *
704  * This function recursively removes a directory tree in debugfs that
705  * was previously created with a call to another debugfs function
706  * (like debugfs_create_file() or variants thereof.)
707  *
708  * This function is required to be called in order for the file to be
709  * removed, no automatic cleanup of files will happen when a module is
710  * removed, you are responsible here.
711  */
712 void debugfs_remove_recursive(struct dentry *dentry)
713 {
714         struct dentry *child, *parent;
715 
716         if (IS_ERR_OR_NULL(dentry))
717                 return;
718 
719         parent = dentry;
720  down:
721         inode_lock(d_inode(parent));
722  loop:
723         /*
724          * The parent->d_subdirs is protected by the d_lock. Outside that
725          * lock, the child can be unlinked and set to be freed which can
726          * use the d_u.d_child as the rcu head and corrupt this list.
727          */
728         spin_lock(&parent->d_lock);
729         list_for_each_entry(child, &parent->d_subdirs, d_child) {
730                 if (!simple_positive(child))
731                         continue;
732 
733                 /* perhaps simple_empty(child) makes more sense */
734                 if (!list_empty(&child->d_subdirs)) {
735                         spin_unlock(&parent->d_lock);
736                         inode_unlock(d_inode(parent));
737                         parent = child;
738                         goto down;
739                 }
740 
741                 spin_unlock(&parent->d_lock);
742 
743                 if (!__debugfs_remove(child, parent))
744                         simple_release_fs(&debugfs_mount, &debugfs_mount_count);
745 
746                 /*
747                  * The parent->d_lock protects agaist child from unlinking
748                  * from d_subdirs. When releasing the parent->d_lock we can
749                  * no longer trust that the next pointer is valid.
750                  * Restart the loop. We'll skip this one with the
751                  * simple_positive() check.
752                  */
753                 goto loop;
754         }
755         spin_unlock(&parent->d_lock);
756 
757         inode_unlock(d_inode(parent));
758         child = parent;
759         parent = parent->d_parent;
760         inode_lock(d_inode(parent));
761 
762         if (child != dentry)
763                 /* go up */
764                 goto loop;
765 
766         if (!__debugfs_remove(child, parent))
767                 simple_release_fs(&debugfs_mount, &debugfs_mount_count);
768         inode_unlock(d_inode(parent));
769 }
770 EXPORT_SYMBOL_GPL(debugfs_remove_recursive);
771 
772 /**
773  * debugfs_rename - rename a file/directory in the debugfs filesystem
774  * @old_dir: a pointer to the parent dentry for the renamed object. This
775  *          should be a directory dentry.
776  * @old_dentry: dentry of an object to be renamed.
777  * @new_dir: a pointer to the parent dentry where the object should be
778  *          moved. This should be a directory dentry.
779  * @new_name: a pointer to a string containing the target name.
780  *
781  * This function renames a file/directory in debugfs.  The target must not
782  * exist for rename to succeed.
783  *
784  * This function will return a pointer to old_dentry (which is updated to
785  * reflect renaming) if it succeeds. If an error occurs, %NULL will be
786  * returned.
787  *
788  * If debugfs is not enabled in the kernel, the value -%ENODEV will be
789  * returned.
790  */
791 struct dentry *debugfs_rename(struct dentry *old_dir, struct dentry *old_dentry,
792                 struct dentry *new_dir, const char *new_name)
793 {
794         int error;
795         struct dentry *dentry = NULL, *trap;
796         struct name_snapshot old_name;
797 
798         if (IS_ERR(old_dir))
799                 return old_dir;
800         if (IS_ERR(new_dir))
801                 return new_dir;
802         if (IS_ERR_OR_NULL(old_dentry))
803                 return old_dentry;
804 
805         trap = lock_rename(new_dir, old_dir);
806         /* Source or destination directories don't exist? */
807         if (d_really_is_negative(old_dir) || d_really_is_negative(new_dir))
808                 goto exit;
809         /* Source does not exist, cyclic rename, or mountpoint? */
810         if (d_really_is_negative(old_dentry) || old_dentry == trap ||
811             d_mountpoint(old_dentry))
812                 goto exit;
813         dentry = lookup_one_len(new_name, new_dir, strlen(new_name));
814         /* Lookup failed, cyclic rename or target exists? */
815         if (IS_ERR(dentry) || dentry == trap || d_really_is_positive(dentry))
816                 goto exit;
817 
818         take_dentry_name_snapshot(&old_name, old_dentry);
819 
820         error = simple_rename(d_inode(old_dir), old_dentry, d_inode(new_dir),
821                               dentry, 0);
822         if (error) {
823                 release_dentry_name_snapshot(&old_name);
824                 goto exit;
825         }
826         d_move(old_dentry, dentry);
827         fsnotify_move(d_inode(old_dir), d_inode(new_dir), old_name.name,
828                 d_is_dir(old_dentry),
829                 NULL, old_dentry);
830         release_dentry_name_snapshot(&old_name);
831         unlock_rename(new_dir, old_dir);
832         dput(dentry);
833         return old_dentry;
834 exit:
835         if (dentry && !IS_ERR(dentry))
836                 dput(dentry);
837         unlock_rename(new_dir, old_dir);
838         if (IS_ERR(dentry))
839                 return dentry;
840         return ERR_PTR(-EINVAL);
841 }
842 EXPORT_SYMBOL_GPL(debugfs_rename);
843 
844 /**
845  * debugfs_initialized - Tells whether debugfs has been registered
846  */
847 bool debugfs_initialized(void)
848 {
849         return debugfs_registered;
850 }
851 EXPORT_SYMBOL_GPL(debugfs_initialized);
852 
853 static int __init debugfs_init(void)
854 {
855         int retval;
856 
857         retval = sysfs_create_mount_point(kernel_kobj, "debug");
858         if (retval)
859                 return retval;
860 
861         retval = register_filesystem(&debug_fs_type);
862         if (retval)
863                 sysfs_remove_mount_point(kernel_kobj, "debug");
864         else
865                 debugfs_registered = true;
866 
867         return retval;
868 }
869 core_initcall(debugfs_init);
870 
871 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp