]> git.karo-electronics.de Git - karo-tx-linux.git/blob - fs/sysfs/dir.c
Merge remote-tracking branch 'mkp-scsi/4.9/scsi-fixes' into fixes
[karo-tx-linux.git] / fs / sysfs / dir.c
1 /*
2  * fs/sysfs/dir.c - sysfs core and dir operation implementation
3  *
4  * Copyright (c) 2001-3 Patrick Mochel
5  * Copyright (c) 2007 SUSE Linux Products GmbH
6  * Copyright (c) 2007 Tejun Heo <teheo@suse.de>
7  *
8  * This file is released under the GPLv2.
9  *
10  * Please see Documentation/filesystems/sysfs.txt for more information.
11  */
12
13 #undef DEBUG
14
15 #include <linux/fs.h>
16 #include <linux/kobject.h>
17 #include <linux/slab.h>
18 #include "sysfs.h"
19
20 DEFINE_SPINLOCK(sysfs_symlink_target_lock);
21
22 void sysfs_warn_dup(struct kernfs_node *parent, const char *name)
23 {
24         char *buf;
25
26         buf = kzalloc(PATH_MAX, GFP_KERNEL);
27         if (buf)
28                 kernfs_path(parent, buf, PATH_MAX);
29
30         WARN(1, KERN_WARNING "sysfs: cannot create duplicate filename '%s/%s'\n",
31              buf, name);
32
33         kfree(buf);
34 }
35
36 /**
37  * sysfs_create_dir_ns - create a directory for an object with a namespace tag
38  * @kobj: object we're creating directory for
39  * @ns: the namespace tag to use
40  */
41 int sysfs_create_dir_ns(struct kobject *kobj, const void *ns)
42 {
43         struct kernfs_node *parent, *kn;
44
45         BUG_ON(!kobj);
46
47         if (kobj->parent)
48                 parent = kobj->parent->sd;
49         else
50                 parent = sysfs_root_kn;
51
52         if (!parent)
53                 return -ENOENT;
54
55         kn = kernfs_create_dir_ns(parent, kobject_name(kobj),
56                                   S_IRWXU | S_IRUGO | S_IXUGO, kobj, ns);
57         if (IS_ERR(kn)) {
58                 if (PTR_ERR(kn) == -EEXIST)
59                         sysfs_warn_dup(parent, kobject_name(kobj));
60                 return PTR_ERR(kn);
61         }
62
63         kobj->sd = kn;
64         return 0;
65 }
66
67 /**
68  *      sysfs_remove_dir - remove an object's directory.
69  *      @kobj:  object.
70  *
71  *      The only thing special about this is that we remove any files in
72  *      the directory before we remove the directory, and we've inlined
73  *      what used to be sysfs_rmdir() below, instead of calling separately.
74  */
75 void sysfs_remove_dir(struct kobject *kobj)
76 {
77         struct kernfs_node *kn = kobj->sd;
78
79         /*
80          * In general, kboject owner is responsible for ensuring removal
81          * doesn't race with other operations and sysfs doesn't provide any
82          * protection; however, when @kobj is used as a symlink target, the
83          * symlinking entity usually doesn't own @kobj and thus has no
84          * control over removal.  @kobj->sd may be removed anytime
85          * and symlink code may end up dereferencing an already freed node.
86          *
87          * sysfs_symlink_target_lock synchronizes @kobj->sd
88          * disassociation against symlink operations so that symlink code
89          * can safely dereference @kobj->sd.
90          */
91         spin_lock(&sysfs_symlink_target_lock);
92         kobj->sd = NULL;
93         spin_unlock(&sysfs_symlink_target_lock);
94
95         if (kn) {
96                 WARN_ON_ONCE(kernfs_type(kn) != KERNFS_DIR);
97                 kernfs_remove(kn);
98         }
99 }
100
101 int sysfs_rename_dir_ns(struct kobject *kobj, const char *new_name,
102                         const void *new_ns)
103 {
104         struct kernfs_node *parent;
105         int ret;
106
107         parent = kernfs_get_parent(kobj->sd);
108         ret = kernfs_rename_ns(kobj->sd, parent, new_name, new_ns);
109         kernfs_put(parent);
110         return ret;
111 }
112
113 int sysfs_move_dir_ns(struct kobject *kobj, struct kobject *new_parent_kobj,
114                       const void *new_ns)
115 {
116         struct kernfs_node *kn = kobj->sd;
117         struct kernfs_node *new_parent;
118
119         new_parent = new_parent_kobj && new_parent_kobj->sd ?
120                 new_parent_kobj->sd : sysfs_root_kn;
121
122         return kernfs_rename_ns(kn, new_parent, kn->name, new_ns);
123 }
124
125 /**
126  * sysfs_create_mount_point - create an always empty directory
127  * @parent_kobj:  kobject that will contain this always empty directory
128  * @name: The name of the always empty directory to add
129  */
130 int sysfs_create_mount_point(struct kobject *parent_kobj, const char *name)
131 {
132         struct kernfs_node *kn, *parent = parent_kobj->sd;
133
134         kn = kernfs_create_empty_dir(parent, name);
135         if (IS_ERR(kn)) {
136                 if (PTR_ERR(kn) == -EEXIST)
137                         sysfs_warn_dup(parent, name);
138                 return PTR_ERR(kn);
139         }
140
141         return 0;
142 }
143 EXPORT_SYMBOL_GPL(sysfs_create_mount_point);
144
145 /**
146  *      sysfs_remove_mount_point - remove an always empty directory.
147  *      @parent_kobj: kobject that will contain this always empty directory
148  *      @name: The name of the always empty directory to remove
149  *
150  */
151 void sysfs_remove_mount_point(struct kobject *parent_kobj, const char *name)
152 {
153         struct kernfs_node *parent = parent_kobj->sd;
154
155         kernfs_remove_by_name_ns(parent, name, NULL);
156 }
157 EXPORT_SYMBOL_GPL(sysfs_remove_mount_point);