]>
Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * fs/sysfs/group.c - Operations for adding/removing multiple files at once. | |
3 | * | |
4 | * Copyright (c) 2003 Patrick Mochel | |
5 | * Copyright (c) 2003 Open Source Development Lab | |
9e2a47ed GKH |
6 | * Copyright (c) 2013 Greg Kroah-Hartman |
7 | * Copyright (c) 2013 The Linux Foundation | |
1da177e4 | 8 | * |
e6c56920 | 9 | * This file is released undert the GPL v2. |
1da177e4 LT |
10 | * |
11 | */ | |
12 | ||
13 | #include <linux/kobject.h> | |
14 | #include <linux/module.h> | |
15 | #include <linux/dcache.h> | |
5f45f1a7 | 16 | #include <linux/namei.h> |
1da177e4 LT |
17 | #include <linux/err.h> |
18 | #include "sysfs.h" | |
19 | ||
20 | ||
9f70a401 | 21 | static void remove_files(struct kernfs_node *parent, |
608e266a | 22 | const struct attribute_group *grp) |
1da177e4 | 23 | { |
995d8ed9 GKH |
24 | struct attribute *const *attr; |
25 | struct bin_attribute *const *bin_attr; | |
1da177e4 | 26 | |
6ab9cea1 GKH |
27 | if (grp->attrs) |
28 | for (attr = grp->attrs; *attr; attr++) | |
324a56e1 | 29 | kernfs_remove_by_name(parent, (*attr)->name); |
6ab9cea1 GKH |
30 | if (grp->bin_attrs) |
31 | for (bin_attr = grp->bin_attrs; *bin_attr; bin_attr++) | |
9f70a401 | 32 | kernfs_remove_by_name(parent, (*bin_attr)->attr.name); |
1da177e4 LT |
33 | } |
34 | ||
324a56e1 | 35 | static int create_files(struct kernfs_node *parent, struct kobject *kobj, |
0f423895 | 36 | const struct attribute_group *grp, int update) |
1da177e4 | 37 | { |
995d8ed9 GKH |
38 | struct attribute *const *attr; |
39 | struct bin_attribute *const *bin_attr; | |
d4acd722 | 40 | int error = 0, i; |
1da177e4 | 41 | |
6ab9cea1 GKH |
42 | if (grp->attrs) { |
43 | for (i = 0, attr = grp->attrs; *attr && !error; i++, attr++) { | |
da4759c7 | 44 | umode_t mode = (*attr)->mode; |
0f423895 | 45 | |
6ab9cea1 GKH |
46 | /* |
47 | * In update mode, we're changing the permissions or | |
48 | * visibility. Do this by first removing then | |
49 | * re-adding (if required) the file. | |
50 | */ | |
51 | if (update) | |
324a56e1 | 52 | kernfs_remove_by_name(parent, (*attr)->name); |
6ab9cea1 GKH |
53 | if (grp->is_visible) { |
54 | mode = grp->is_visible(kobj, *attr, i); | |
55 | if (!mode) | |
56 | continue; | |
57 | } | |
324a56e1 | 58 | error = sysfs_add_file_mode_ns(parent, *attr, false, |
da4759c7 | 59 | mode, NULL); |
6ab9cea1 GKH |
60 | if (unlikely(error)) |
61 | break; | |
62 | } | |
63 | if (error) { | |
9f70a401 | 64 | remove_files(parent, grp); |
6ab9cea1 GKH |
65 | goto exit; |
66 | } | |
67 | } | |
68 | ||
69 | if (grp->bin_attrs) { | |
70 | for (bin_attr = grp->bin_attrs; *bin_attr; bin_attr++) { | |
71 | if (update) | |
aabaf4c2 CS |
72 | kernfs_remove_by_name(parent, |
73 | (*bin_attr)->attr.name); | |
74 | error = sysfs_add_file_mode_ns(parent, | |
75 | &(*bin_attr)->attr, true, | |
76 | (*bin_attr)->attr.mode, NULL); | |
6ab9cea1 GKH |
77 | if (error) |
78 | break; | |
0f423895 | 79 | } |
6ab9cea1 | 80 | if (error) |
9f70a401 | 81 | remove_files(parent, grp); |
0f423895 | 82 | } |
6ab9cea1 | 83 | exit: |
1da177e4 LT |
84 | return error; |
85 | } | |
86 | ||
87 | ||
0f423895 JB |
88 | static int internal_create_group(struct kobject *kobj, int update, |
89 | const struct attribute_group *grp) | |
1da177e4 | 90 | { |
324a56e1 | 91 | struct kernfs_node *kn; |
1da177e4 LT |
92 | int error; |
93 | ||
0f423895 JB |
94 | BUG_ON(!kobj || (!update && !kobj->sd)); |
95 | ||
96 | /* Updates may happen before the object has been instantiated */ | |
97 | if (unlikely(update && !kobj->sd)) | |
98 | return -EINVAL; | |
388a8c35 OS |
99 | if (!grp->attrs && !grp->bin_attrs) { |
100 | WARN(1, "sysfs: (bin_)attrs not set by subsystem for group: %s/%s\n", | |
adf305f7 | 101 | kobj->name, grp->name ?: ""); |
5631f2c1 BP |
102 | return -EINVAL; |
103 | } | |
1da177e4 | 104 | if (grp->name) { |
bb8b9d09 TH |
105 | kn = kernfs_create_dir(kobj->sd, grp->name, |
106 | S_IRWXU | S_IRUGO | S_IXUGO, kobj); | |
324a56e1 TH |
107 | if (IS_ERR(kn)) { |
108 | if (PTR_ERR(kn) == -EEXIST) | |
93b2b8e4 | 109 | sysfs_warn_dup(kobj->sd, grp->name); |
324a56e1 | 110 | return PTR_ERR(kn); |
93b2b8e4 | 111 | } |
1da177e4 | 112 | } else |
324a56e1 TH |
113 | kn = kobj->sd; |
114 | kernfs_get(kn); | |
115 | error = create_files(kn, kobj, grp, update); | |
608e266a | 116 | if (error) { |
1da177e4 | 117 | if (grp->name) |
324a56e1 | 118 | kernfs_remove(kn); |
1da177e4 | 119 | } |
324a56e1 | 120 | kernfs_put(kn); |
1da177e4 LT |
121 | return error; |
122 | } | |
123 | ||
0f423895 JB |
124 | /** |
125 | * sysfs_create_group - given a directory kobject, create an attribute group | |
126 | * @kobj: The kobject to create the group on | |
127 | * @grp: The attribute group to create | |
128 | * | |
129 | * This function creates a group for the first time. It will explicitly | |
130 | * warn and error if any of the attribute files being created already exist. | |
131 | * | |
132 | * Returns 0 on success or error. | |
133 | */ | |
134 | int sysfs_create_group(struct kobject *kobj, | |
135 | const struct attribute_group *grp) | |
136 | { | |
137 | return internal_create_group(kobj, 0, grp); | |
138 | } | |
d363bc53 | 139 | EXPORT_SYMBOL_GPL(sysfs_create_group); |
0f423895 | 140 | |
3e9b2bae GKH |
141 | /** |
142 | * sysfs_create_groups - given a directory kobject, create a bunch of attribute groups | |
143 | * @kobj: The kobject to create the group on | |
144 | * @groups: The attribute groups to create, NULL terminated | |
145 | * | |
146 | * This function creates a bunch of attribute groups. If an error occurs when | |
147 | * creating a group, all previously created groups will be removed, unwinding | |
148 | * everything back to the original state when this function was called. | |
149 | * It will explicitly warn and error if any of the attribute files being | |
150 | * created already exist. | |
151 | * | |
09239ed4 | 152 | * Returns 0 on success or error code from sysfs_create_group on error. |
3e9b2bae GKH |
153 | */ |
154 | int sysfs_create_groups(struct kobject *kobj, | |
155 | const struct attribute_group **groups) | |
156 | { | |
157 | int error = 0; | |
158 | int i; | |
159 | ||
160 | if (!groups) | |
161 | return 0; | |
162 | ||
163 | for (i = 0; groups[i]; i++) { | |
164 | error = sysfs_create_group(kobj, groups[i]); | |
165 | if (error) { | |
166 | while (--i >= 0) | |
167 | sysfs_remove_group(kobj, groups[i]); | |
168 | break; | |
169 | } | |
170 | } | |
171 | return error; | |
172 | } | |
173 | EXPORT_SYMBOL_GPL(sysfs_create_groups); | |
174 | ||
0f423895 | 175 | /** |
1f8e1cda RD |
176 | * sysfs_update_group - given a directory kobject, update an attribute group |
177 | * @kobj: The kobject to update the group on | |
178 | * @grp: The attribute group to update | |
0f423895 JB |
179 | * |
180 | * This function updates an attribute group. Unlike | |
181 | * sysfs_create_group(), it will explicitly not warn or error if any | |
182 | * of the attribute files being created already exist. Furthermore, | |
183 | * if the visibility of the files has changed through the is_visible() | |
184 | * callback, it will update the permissions and add or remove the | |
185 | * relevant files. | |
186 | * | |
187 | * The primary use for this function is to call it after making a change | |
188 | * that affects group visibility. | |
189 | * | |
190 | * Returns 0 on success or error. | |
191 | */ | |
192 | int sysfs_update_group(struct kobject *kobj, | |
193 | const struct attribute_group *grp) | |
194 | { | |
195 | return internal_create_group(kobj, 1, grp); | |
196 | } | |
d363bc53 | 197 | EXPORT_SYMBOL_GPL(sysfs_update_group); |
0f423895 | 198 | |
f9ae443b GKH |
199 | /** |
200 | * sysfs_remove_group: remove a group from a kobject | |
201 | * @kobj: kobject to remove the group from | |
202 | * @grp: group to remove | |
203 | * | |
204 | * This function removes a group of attributes from a kobject. The attributes | |
205 | * previously have to have been created for this group, otherwise it will fail. | |
206 | */ | |
995d8ed9 GKH |
207 | void sysfs_remove_group(struct kobject *kobj, |
208 | const struct attribute_group *grp) | |
1da177e4 | 209 | { |
324a56e1 TH |
210 | struct kernfs_node *parent = kobj->sd; |
211 | struct kernfs_node *kn; | |
1da177e4 | 212 | |
057f6c01 | 213 | if (grp->name) { |
324a56e1 TH |
214 | kn = kernfs_find_and_get(parent, grp->name); |
215 | if (!kn) { | |
216 | WARN(!kn, KERN_WARNING | |
16aebf1c GKH |
217 | "sysfs group %p not found for kobject '%s'\n", |
218 | grp, kobject_name(kobj)); | |
969affd2 GKH |
219 | return; |
220 | } | |
ccf73cf3 | 221 | } else { |
324a56e1 TH |
222 | kn = parent; |
223 | kernfs_get(kn); | |
ccf73cf3 | 224 | } |
1da177e4 | 225 | |
9f70a401 | 226 | remove_files(kn, grp); |
1da177e4 | 227 | if (grp->name) |
324a56e1 | 228 | kernfs_remove(kn); |
608e266a | 229 | |
324a56e1 | 230 | kernfs_put(kn); |
1da177e4 | 231 | } |
d363bc53 | 232 | EXPORT_SYMBOL_GPL(sysfs_remove_group); |
1da177e4 | 233 | |
3e9b2bae GKH |
234 | /** |
235 | * sysfs_remove_groups - remove a list of groups | |
236 | * | |
f9ae443b GKH |
237 | * @kobj: The kobject for the groups to be removed from |
238 | * @groups: NULL terminated list of groups to be removed | |
3e9b2bae | 239 | * |
09239ed4 | 240 | * If groups is not NULL, remove the specified groups from the kobject. |
3e9b2bae GKH |
241 | */ |
242 | void sysfs_remove_groups(struct kobject *kobj, | |
243 | const struct attribute_group **groups) | |
244 | { | |
245 | int i; | |
246 | ||
247 | if (!groups) | |
248 | return; | |
249 | for (i = 0; groups[i]; i++) | |
250 | sysfs_remove_group(kobj, groups[i]); | |
251 | } | |
252 | EXPORT_SYMBOL_GPL(sysfs_remove_groups); | |
253 | ||
69d44ffb AS |
254 | /** |
255 | * sysfs_merge_group - merge files into a pre-existing attribute group. | |
256 | * @kobj: The kobject containing the group. | |
257 | * @grp: The files to create and the attribute group they belong to. | |
258 | * | |
259 | * This function returns an error if the group doesn't exist or any of the | |
260 | * files already exist in that group, in which case none of the new files | |
261 | * are created. | |
262 | */ | |
263 | int sysfs_merge_group(struct kobject *kobj, | |
264 | const struct attribute_group *grp) | |
265 | { | |
324a56e1 | 266 | struct kernfs_node *parent; |
69d44ffb AS |
267 | int error = 0; |
268 | struct attribute *const *attr; | |
269 | int i; | |
270 | ||
324a56e1 TH |
271 | parent = kernfs_find_and_get(kobj->sd, grp->name); |
272 | if (!parent) | |
69d44ffb AS |
273 | return -ENOENT; |
274 | ||
275 | for ((i = 0, attr = grp->attrs); *attr && !error; (++i, ++attr)) | |
324a56e1 | 276 | error = sysfs_add_file(parent, *attr, false); |
69d44ffb AS |
277 | if (error) { |
278 | while (--i >= 0) | |
324a56e1 | 279 | kernfs_remove_by_name(parent, (*--attr)->name); |
69d44ffb | 280 | } |
324a56e1 | 281 | kernfs_put(parent); |
69d44ffb AS |
282 | |
283 | return error; | |
284 | } | |
285 | EXPORT_SYMBOL_GPL(sysfs_merge_group); | |
286 | ||
287 | /** | |
288 | * sysfs_unmerge_group - remove files from a pre-existing attribute group. | |
289 | * @kobj: The kobject containing the group. | |
290 | * @grp: The files to remove and the attribute group they belong to. | |
291 | */ | |
292 | void sysfs_unmerge_group(struct kobject *kobj, | |
293 | const struct attribute_group *grp) | |
294 | { | |
324a56e1 | 295 | struct kernfs_node *parent; |
69d44ffb AS |
296 | struct attribute *const *attr; |
297 | ||
324a56e1 TH |
298 | parent = kernfs_find_and_get(kobj->sd, grp->name); |
299 | if (parent) { | |
69d44ffb | 300 | for (attr = grp->attrs; *attr; ++attr) |
324a56e1 TH |
301 | kernfs_remove_by_name(parent, (*attr)->name); |
302 | kernfs_put(parent); | |
69d44ffb AS |
303 | } |
304 | } | |
305 | EXPORT_SYMBOL_GPL(sysfs_unmerge_group); | |
306 | ||
0bb8f3d6 RW |
307 | /** |
308 | * sysfs_add_link_to_group - add a symlink to an attribute group. | |
309 | * @kobj: The kobject containing the group. | |
310 | * @group_name: The name of the group. | |
311 | * @target: The target kobject of the symlink to create. | |
312 | * @link_name: The name of the symlink to create. | |
313 | */ | |
314 | int sysfs_add_link_to_group(struct kobject *kobj, const char *group_name, | |
315 | struct kobject *target, const char *link_name) | |
316 | { | |
324a56e1 | 317 | struct kernfs_node *parent; |
0bb8f3d6 RW |
318 | int error = 0; |
319 | ||
324a56e1 TH |
320 | parent = kernfs_find_and_get(kobj->sd, group_name); |
321 | if (!parent) | |
0bb8f3d6 RW |
322 | return -ENOENT; |
323 | ||
324a56e1 TH |
324 | error = sysfs_create_link_sd(parent, target, link_name); |
325 | kernfs_put(parent); | |
0bb8f3d6 RW |
326 | |
327 | return error; | |
328 | } | |
329 | EXPORT_SYMBOL_GPL(sysfs_add_link_to_group); | |
330 | ||
331 | /** | |
332 | * sysfs_remove_link_from_group - remove a symlink from an attribute group. | |
333 | * @kobj: The kobject containing the group. | |
334 | * @group_name: The name of the group. | |
335 | * @link_name: The name of the symlink to remove. | |
336 | */ | |
337 | void sysfs_remove_link_from_group(struct kobject *kobj, const char *group_name, | |
338 | const char *link_name) | |
339 | { | |
324a56e1 | 340 | struct kernfs_node *parent; |
0bb8f3d6 | 341 | |
324a56e1 TH |
342 | parent = kernfs_find_and_get(kobj->sd, group_name); |
343 | if (parent) { | |
344 | kernfs_remove_by_name(parent, link_name); | |
345 | kernfs_put(parent); | |
0bb8f3d6 RW |
346 | } |
347 | } | |
348 | EXPORT_SYMBOL_GPL(sysfs_remove_link_from_group); |