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