source: src/linux/universal/linux-4.9/fs/debugfs/inode.c @ 31662

Last change on this file since 31662 was 31662, checked in by brainslayer, 2 months ago

use new squashfs in all kernels

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