Version:  2.0.40 2.2.26 2.4.37 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1

Linux/fs/debugfs/inode.c

  1 /*
  2  *  inode.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 #include <linux/module.h>
 17 #include <linux/fs.h>
 18 #include <linux/mount.h>
 19 #include <linux/pagemap.h>
 20 #include <linux/init.h>
 21 #include <linux/kobject.h>
 22 #include <linux/namei.h>
 23 #include <linux/debugfs.h>
 24 #include <linux/fsnotify.h>
 25 #include <linux/string.h>
 26 #include <linux/seq_file.h>
 27 #include <linux/parser.h>
 28 #include <linux/magic.h>
 29 #include <linux/slab.h>
 30 
 31 #define DEBUGFS_DEFAULT_MODE    0700
 32 
 33 static struct vfsmount *debugfs_mount;
 34 static int debugfs_mount_count;
 35 static bool debugfs_registered;
 36 
 37 static struct inode *debugfs_get_inode(struct super_block *sb)
 38 {
 39         struct inode *inode = new_inode(sb);
 40         if (inode) {
 41                 inode->i_ino = get_next_ino();
 42                 inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
 43         }
 44         return inode;
 45 }
 46 
 47 static inline int debugfs_positive(struct dentry *dentry)
 48 {
 49         return d_really_is_positive(dentry) && !d_unhashed(dentry);
 50 }
 51 
 52 struct debugfs_mount_opts {
 53         kuid_t uid;
 54         kgid_t gid;
 55         umode_t mode;
 56 };
 57 
 58 enum {
 59         Opt_uid,
 60         Opt_gid,
 61         Opt_mode,
 62         Opt_err
 63 };
 64 
 65 static 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 
 72 struct debugfs_fs_info {
 73         struct debugfs_mount_opts mount_opts;
 74 };
 75 
 76 static 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;
 81         kuid_t uid;
 82         kgid_t gid;
 83         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;
 96                         uid = make_kuid(current_user_ns(), option);
 97                         if (!uid_valid(uid))
 98                                 return -EINVAL;
 99                         opts->uid = uid;
100                         break;
101                 case Opt_gid:
102                         if (match_int(&args[0], &option))
103                                 return -EINVAL;
104                         gid = make_kgid(current_user_ns(), option);
105                         if (!gid_valid(gid))
106                                 return -EINVAL;
107                         opts->gid = gid;
108                         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 
124 static int debugfs_apply_options(struct super_block *sb)
125 {
126         struct debugfs_fs_info *fsi = sb->s_fs_info;
127         struct inode *inode = d_inode(sb->s_root);
128         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 
139 static 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 
144         sync_filesystem(sb);
145         err = debugfs_parse_options(data, &fsi->mount_opts);
146         if (err)
147                 goto fail;
148 
149         debugfs_apply_options(sb);
150 
151 fail:
152         return err;
153 }
154 
155 static 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 
160         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));
166         if (opts->mode != DEBUGFS_DEFAULT_MODE)
167                 seq_printf(m, ",mode=%o", opts->mode);
168 
169         return 0;
170 }
171 
172 static 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))
177                 kfree(inode->i_private);
178 }
179 
180 static const struct super_operations debugfs_super_operations = {
181         .statfs         = simple_statfs,
182         .remount_fs     = debugfs_remount,
183         .show_options   = debugfs_show_options,
184         .evict_inode    = debugfs_evict_inode,
185 };
186 
187 static struct vfsmount *debugfs_automount(struct path *path)
188 {
189         struct vfsmount *(*f)(void *);
190         f = (struct vfsmount *(*)(void *))path->dentry->d_fsdata;
191         return f(d_inode(path->dentry)->i_private);
192 }
193 
194 static const struct dentry_operations debugfs_dops = {
195         .d_delete = always_delete_dentry,
196         .d_automount = debugfs_automount,
197 };
198 
199 static int debug_fill_super(struct super_block *sb, void *data, int silent)
200 {
201         static struct tree_descr debug_files[] = {{""}};
202         struct debugfs_fs_info *fsi;
203         int err;
204 
205         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;
223         sb->s_d_op = &debugfs_dops;
224 
225         debugfs_apply_options(sb);
226 
227         return 0;
228 
229 fail:
230         kfree(fsi);
231         sb->s_fs_info = NULL;
232         return err;
233 }
234 
235 static struct dentry *debug_mount(struct file_system_type *fs_type,
236                         int flags, const char *dev_name,
237                         void *data)
238 {
239         return mount_single(fs_type, flags, data, debug_fill_super);
240 }
241 
242 static struct file_system_type debug_fs_type = {
243         .owner =        THIS_MODULE,
244         .name =         "debugfs",
245         .mount =        debug_mount,
246         .kill_sb =      kill_litter_super,
247 };
248 MODULE_ALIAS_FS("debugfs");
249 
250 static struct dentry *start_creating(const char *name, struct dentry *parent)
251 {
252         struct dentry *dentry;
253         int error;
254 
255         pr_debug("debugfs: creating file '%s'\n",name);
256 
257         if (IS_ERR(parent))
258                 return parent;
259 
260         error = simple_pin_fs(&debug_fs_type, &debugfs_mount,
261                               &debugfs_mount_count);
262         if (error)
263                 return ERR_PTR(error);
264 
265         /* If the parent is not specified, we create it in the root.
266          * We need the root dentry to do this, which is in the super
267          * 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 
273         mutex_lock(&d_inode(parent)->i_mutex);
274         dentry = lookup_one_len(name, parent, strlen(name));
275         if (!IS_ERR(dentry) && d_really_is_positive(dentry)) {
276                 dput(dentry);
277                 dentry = ERR_PTR(-EEXIST);
278         }
279         if (IS_ERR(dentry))
280                 mutex_unlock(&d_inode(parent)->i_mutex);
281         return dentry;
282 }
283 
284 static struct dentry *failed_creating(struct dentry *dentry)
285 {
286         mutex_unlock(&d_inode(dentry->d_parent)->i_mutex);
287         dput(dentry);
288         simple_release_fs(&debugfs_mount, &debugfs_mount_count);
289         return NULL;
290 }
291 
292 static struct dentry *end_creating(struct dentry *dentry)
293 {
294         mutex_unlock(&d_inode(dentry->d_parent)->i_mutex);
295         return dentry;
296 }
297 
298 /**
299  * debugfs_create_file - create a file in the debugfs filesystem
300  * @name: a pointer to a string containing the name of the file to create.
301  * @mode: the permission that the file should have.
302  * @parent: a pointer to the parent dentry for this file.  This should be a
303  *          directory dentry if set.  If this parameter is NULL, then the
304  *          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
306  *        on.  The inode.i_private pointer will point to this value on
307  *        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
312  * 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
314  * 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,
319  * you are responsible here.)  If an error occurs, %NULL will be returned.
320  *
321  * If debugfs is not enabled in the kernel, the value -%ENODEV will be
322  * returned.
323  */
324 struct dentry *debugfs_create_file(const char *name, umode_t mode,
325                                    struct dentry *parent, void *data,
326                                    const struct file_operations *fops)
327 {
328         struct dentry *dentry;
329         struct inode *inode;
330 
331         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 
339         inode = debugfs_get_inode(dentry->d_sb);
340         if (unlikely(!inode))
341                 return failed_creating(dentry);
342 
343         inode->i_mode = mode;
344         inode->i_fop = fops ? fops : &debugfs_file_operations;
345         inode->i_private = data;
346         d_instantiate(dentry, inode);
347         fsnotify_create(d_inode(dentry->d_parent), dentry);
348         return end_creating(dentry);
349 }
350 EXPORT_SYMBOL_GPL(debugfs_create_file);
351 
352 /**
353  * 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  */
379 struct 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)
387                 d_inode(de)->i_size = file_size;
388         return de;
389 }
390 EXPORT_SYMBOL_GPL(debugfs_create_file_size);
391 
392 /**
393  * debugfs_create_dir - create a directory in the debugfs filesystem
394  * @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
397  *          directory dentry if set.  If this parameter is NULL, then the
398  *          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,
405  * you are responsible here.)  If an error occurs, %NULL will be returned.
406  *
407  * If debugfs is not enabled in the kernel, the value -%ENODEV will be
408  * returned.
409  */
410 struct dentry *debugfs_create_dir(const char *name, struct dentry *parent)
411 {
412         struct dentry *dentry = start_creating(name, parent);
413         struct inode *inode;
414 
415         if (IS_ERR(dentry))
416                 return NULL;
417 
418         inode = debugfs_get_inode(dentry->d_sb);
419         if (unlikely(!inode))
420                 return failed_creating(dentry);
421 
422         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);
428         d_instantiate(dentry, inode);
429         inc_nlink(d_inode(dentry->d_parent));
430         fsnotify_mkdir(d_inode(dentry->d_parent), dentry);
431         return end_creating(dentry);
432 }
433 EXPORT_SYMBOL_GPL(debugfs_create_dir);
434 
435 /**
436  * 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  */
446 struct 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 }
468 EXPORT_SYMBOL(debugfs_create_automount);
469 
470 /**
471  * 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
475  *          should be a directory dentry if set.  If this parameter is NULL,
476  *          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
491  * returned.
492  */
493 struct dentry *debugfs_create_symlink(const char *name, struct dentry *parent,
494                                       const char *target)
495 {
496         struct dentry *dentry;
497         struct inode *inode;
498         char *link = kstrdup(target, GFP_KERNEL);
499         if (!link)
500                 return NULL;
501 
502         dentry = start_creating(name, parent);
503         if (IS_ERR(dentry)) {
504                 kfree(link);
505                 return NULL;
506         }
507 
508         inode = debugfs_get_inode(dentry->d_sb);
509         if (unlikely(!inode)) {
510                 kfree(link);
511                 return failed_creating(dentry);
512         }
513         inode->i_mode = S_IFLNK | S_IRWXUGO;
514         inode->i_op = &debugfs_link_operations;
515         inode->i_private = link;
516         d_instantiate(dentry, inode);
517         return end_creating(dentry);
518 }
519 EXPORT_SYMBOL_GPL(debugfs_create_symlink);
520 
521 static int __debugfs_remove(struct dentry *dentry, struct dentry *parent)
522 {
523         int ret = 0;
524 
525         if (debugfs_positive(dentry)) {
526                 dget(dentry);
527                 if (d_is_dir(dentry))
528                         ret = simple_rmdir(d_inode(parent), dentry);
529                 else
530                         simple_unlink(d_inode(parent), dentry);
531                 if (!ret)
532                         d_delete(dentry);
533                 dput(dentry);
534         }
535         return ret;
536 }
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  */
551 void debugfs_remove(struct dentry *dentry)
552 {
553         struct dentry *parent;
554         int ret;
555 
556         if (IS_ERR_OR_NULL(dentry))
557                 return;
558 
559         parent = dentry->d_parent;
560         if (!parent || d_really_is_negative(parent))
561                 return;
562 
563         mutex_lock(&d_inode(parent)->i_mutex);
564         ret = __debugfs_remove(dentry, parent);
565         mutex_unlock(&d_inode(parent)->i_mutex);
566         if (!ret)
567                 simple_release_fs(&debugfs_mount, &debugfs_mount_count);
568 }
569 EXPORT_SYMBOL_GPL(debugfs_remove);
570 
571 /**
572  * 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  */
583 void debugfs_remove_recursive(struct dentry *dentry)
584 {
585         struct dentry *child, *parent;
586 
587         if (IS_ERR_OR_NULL(dentry))
588                 return;
589 
590         parent = dentry->d_parent;
591         if (!parent || d_really_is_negative(parent))
592                 return;
593 
594         parent = dentry;
595  down:
596         mutex_lock(&d_inode(parent)->i_mutex);
597  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);
604         list_for_each_entry(child, &parent->d_subdirs, d_child) {
605                 if (!debugfs_positive(child))
606                         continue;
607 
608                 /* perhaps simple_empty(child) makes more sense */
609                 if (!list_empty(&child->d_subdirs)) {
610                         spin_unlock(&parent->d_lock);
611                         mutex_unlock(&d_inode(parent)->i_mutex);
612                         parent = child;
613                         goto down;
614                 }
615 
616                 spin_unlock(&parent->d_lock);
617 
618                 if (!__debugfs_remove(child, parent))
619                         simple_release_fs(&debugfs_mount, &debugfs_mount_count);
620 
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;
629         }
630         spin_unlock(&parent->d_lock);
631 
632         mutex_unlock(&d_inode(parent)->i_mutex);
633         child = parent;
634         parent = parent->d_parent;
635         mutex_lock(&d_inode(parent)->i_mutex);
636 
637         if (child != dentry)
638                 /* go up */
639                 goto loop;
640 
641         if (!__debugfs_remove(child, parent))
642                 simple_release_fs(&debugfs_mount, &debugfs_mount_count);
643         mutex_unlock(&d_inode(parent)->i_mutex);
644 }
645 EXPORT_SYMBOL_GPL(debugfs_remove_recursive);
646 
647 /**
648  * 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  */
666 struct 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? */
675         if (d_really_is_negative(old_dir) || d_really_is_negative(new_dir))
676                 goto exit;
677         /* Source does not exist, cyclic rename, or mountpoint? */
678         if (d_really_is_negative(old_dentry) || old_dentry == trap ||
679             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? */
683         if (IS_ERR(dentry) || dentry == trap || d_really_is_positive(dentry))
684                 goto exit;
685 
686         old_name = fsnotify_oldname_init(old_dentry->d_name.name);
687 
688         error = simple_rename(d_inode(old_dir), old_dentry, d_inode(new_dir),
689                 dentry);
690         if (error) {
691                 fsnotify_oldname_free(old_name);
692                 goto exit;
693         }
694         d_move(old_dentry, dentry);
695         fsnotify_move(d_inode(old_dir), d_inode(new_dir), old_name,
696                 d_is_dir(old_dentry),
697                 NULL, old_dentry);
698         fsnotify_oldname_free(old_name);
699         unlock_rename(new_dir, old_dir);
700         dput(dentry);
701         return old_dentry;
702 exit:
703         if (dentry && !IS_ERR(dentry))
704                 dput(dentry);
705         unlock_rename(new_dir, old_dir);
706         return NULL;
707 }
708 EXPORT_SYMBOL_GPL(debugfs_rename);
709 
710 /**
711  * debugfs_initialized - Tells whether debugfs has been registered
712  */
713 bool debugfs_initialized(void)
714 {
715         return debugfs_registered;
716 }
717 EXPORT_SYMBOL_GPL(debugfs_initialized);
718 
719 
720 static struct kobject *debug_kobj;
721 
722 static int __init debugfs_init(void)
723 {
724         int retval;
725 
726         debug_kobj = kobject_create_and_add("debug", kernel_kobj);
727         if (!debug_kobj)
728                 return -EINVAL;
729 
730         retval = register_filesystem(&debug_fs_type);
731         if (retval)
732                 kobject_put(debug_kobj);
733         else
734                 debugfs_registered = true;
735 
736         return retval;
737 }
738 core_initcall(debugfs_init);
739 
740 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us