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 | 15 | #include <linux/err.h> |
303a4276 | 16 | #include <linux/fs.h> |
1da177e4 LT |
17 | #include "sysfs.h" |
18 | ||
19 | ||
9f70a401 | 20 | static void remove_files(struct kernfs_node *parent, |
608e266a | 21 | const struct attribute_group *grp) |
1da177e4 | 22 | { |
995d8ed9 GKH |
23 | struct attribute *const *attr; |
24 | struct bin_attribute *const *bin_attr; | |
1da177e4 | 25 | |
6ab9cea1 GKH |
26 | if (grp->attrs) |
27 | for (attr = grp->attrs; *attr; attr++) | |
324a56e1 | 28 | kernfs_remove_by_name(parent, (*attr)->name); |
6ab9cea1 GKH |
29 | if (grp->bin_attrs) |
30 | for (bin_attr = grp->bin_attrs; *bin_attr; bin_attr++) | |
9f70a401 | 31 | kernfs_remove_by_name(parent, (*bin_attr)->attr.name); |
1da177e4 LT |
32 | } |
33 | ||
324a56e1 | 34 | static int create_files(struct kernfs_node *parent, struct kobject *kobj, |
5f81880d | 35 | kuid_t uid, kgid_t gid, |
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 | } | |
d8bf8c92 VD |
58 | |
59 | WARN(mode & ~(SYSFS_PREALLOC | 0664), | |
60 | "Attribute %s: Invalid permissions 0%o\n", | |
61 | (*attr)->name, mode); | |
62 | ||
63 | mode &= SYSFS_PREALLOC | 0664; | |
5cf3bb0d CH |
64 | error = sysfs_add_file_mode_ns(parent, *attr, mode, uid, |
65 | gid, NULL); | |
6ab9cea1 GKH |
66 | if (unlikely(error)) |
67 | break; | |
68 | } | |
69 | if (error) { | |
9f70a401 | 70 | remove_files(parent, grp); |
6ab9cea1 GKH |
71 | goto exit; |
72 | } | |
73 | } | |
74 | ||
75 | if (grp->bin_attrs) { | |
7f5028cf EL |
76 | for (i = 0, bin_attr = grp->bin_attrs; *bin_attr; i++, bin_attr++) { |
77 | umode_t mode = (*bin_attr)->attr.mode; | |
78 | ||
6ab9cea1 | 79 | if (update) |
aabaf4c2 CS |
80 | kernfs_remove_by_name(parent, |
81 | (*bin_attr)->attr.name); | |
7f5028cf EL |
82 | if (grp->is_bin_visible) { |
83 | mode = grp->is_bin_visible(kobj, *bin_attr, i); | |
84 | if (!mode) | |
85 | continue; | |
86 | } | |
87 | ||
88 | WARN(mode & ~(SYSFS_PREALLOC | 0664), | |
89 | "Attribute %s: Invalid permissions 0%o\n", | |
90 | (*bin_attr)->attr.name, mode); | |
91 | ||
92 | mode &= SYSFS_PREALLOC | 0664; | |
5cf3bb0d CH |
93 | error = sysfs_add_bin_file_mode_ns(parent, *bin_attr, |
94 | mode, uid, gid, | |
95 | NULL); | |
6ab9cea1 GKH |
96 | if (error) |
97 | break; | |
0f423895 | 98 | } |
6ab9cea1 | 99 | if (error) |
9f70a401 | 100 | remove_files(parent, grp); |
0f423895 | 101 | } |
6ab9cea1 | 102 | exit: |
1da177e4 LT |
103 | return error; |
104 | } | |
105 | ||
106 | ||
0f423895 JB |
107 | static int internal_create_group(struct kobject *kobj, int update, |
108 | const struct attribute_group *grp) | |
1da177e4 | 109 | { |
324a56e1 | 110 | struct kernfs_node *kn; |
5f81880d DT |
111 | kuid_t uid; |
112 | kgid_t gid; | |
1da177e4 LT |
113 | int error; |
114 | ||
de96e9fe GKH |
115 | if (WARN_ON(!kobj || (!update && !kobj->sd))) |
116 | return -EINVAL; | |
0f423895 JB |
117 | |
118 | /* Updates may happen before the object has been instantiated */ | |
119 | if (unlikely(update && !kobj->sd)) | |
120 | return -EINVAL; | |
388a8c35 OS |
121 | if (!grp->attrs && !grp->bin_attrs) { |
122 | WARN(1, "sysfs: (bin_)attrs not set by subsystem for group: %s/%s\n", | |
adf305f7 | 123 | kobj->name, grp->name ?: ""); |
5631f2c1 BP |
124 | return -EINVAL; |
125 | } | |
5f81880d | 126 | kobject_get_ownership(kobj, &uid, &gid); |
1da177e4 | 127 | if (grp->name) { |
c855cf27 RJ |
128 | if (update) { |
129 | kn = kernfs_find_and_get(kobj->sd, grp->name); | |
130 | if (!kn) { | |
131 | pr_warn("Can't update unknown attr grp name: %s/%s\n", | |
132 | kobj->name, grp->name); | |
133 | return -EINVAL; | |
134 | } | |
135 | } else { | |
a18d783f LT |
136 | kn = kernfs_create_dir_ns(kobj->sd, grp->name, |
137 | S_IRWXU | S_IRUGO | S_IXUGO, | |
138 | uid, gid, kobj, NULL); | |
c855cf27 RJ |
139 | if (IS_ERR(kn)) { |
140 | if (PTR_ERR(kn) == -EEXIST) | |
141 | sysfs_warn_dup(kobj->sd, grp->name); | |
142 | return PTR_ERR(kn); | |
143 | } | |
93b2b8e4 | 144 | } |
1da177e4 | 145 | } else |
324a56e1 TH |
146 | kn = kobj->sd; |
147 | kernfs_get(kn); | |
5f81880d | 148 | error = create_files(kn, kobj, uid, gid, grp, update); |
608e266a | 149 | if (error) { |
1da177e4 | 150 | if (grp->name) |
324a56e1 | 151 | kernfs_remove(kn); |
1da177e4 | 152 | } |
324a56e1 | 153 | kernfs_put(kn); |
c855cf27 RJ |
154 | |
155 | if (grp->name && update) | |
156 | kernfs_put(kn); | |
157 | ||
1da177e4 LT |
158 | return error; |
159 | } | |
160 | ||
0f423895 JB |
161 | /** |
162 | * sysfs_create_group - given a directory kobject, create an attribute group | |
163 | * @kobj: The kobject to create the group on | |
164 | * @grp: The attribute group to create | |
165 | * | |
166 | * This function creates a group for the first time. It will explicitly | |
167 | * warn and error if any of the attribute files being created already exist. | |
168 | * | |
ed1dc8a8 | 169 | * Returns 0 on success or error code on failure. |
0f423895 JB |
170 | */ |
171 | int sysfs_create_group(struct kobject *kobj, | |
172 | const struct attribute_group *grp) | |
173 | { | |
174 | return internal_create_group(kobj, 0, grp); | |
175 | } | |
d363bc53 | 176 | EXPORT_SYMBOL_GPL(sysfs_create_group); |
0f423895 | 177 | |
aac1f7f9 JO |
178 | static int internal_create_groups(struct kobject *kobj, int update, |
179 | const struct attribute_group **groups) | |
180 | { | |
181 | int error = 0; | |
182 | int i; | |
183 | ||
184 | if (!groups) | |
185 | return 0; | |
186 | ||
187 | for (i = 0; groups[i]; i++) { | |
188 | error = internal_create_group(kobj, update, groups[i]); | |
189 | if (error) { | |
190 | while (--i >= 0) | |
191 | sysfs_remove_group(kobj, groups[i]); | |
192 | break; | |
193 | } | |
194 | } | |
195 | return error; | |
196 | } | |
197 | ||
3e9b2bae GKH |
198 | /** |
199 | * sysfs_create_groups - given a directory kobject, create a bunch of attribute groups | |
200 | * @kobj: The kobject to create the group on | |
201 | * @groups: The attribute groups to create, NULL terminated | |
202 | * | |
203 | * This function creates a bunch of attribute groups. If an error occurs when | |
204 | * creating a group, all previously created groups will be removed, unwinding | |
205 | * everything back to the original state when this function was called. | |
206 | * It will explicitly warn and error if any of the attribute files being | |
207 | * created already exist. | |
208 | * | |
ed1dc8a8 | 209 | * Returns 0 on success or error code from sysfs_create_group on failure. |
3e9b2bae GKH |
210 | */ |
211 | int sysfs_create_groups(struct kobject *kobj, | |
212 | const struct attribute_group **groups) | |
213 | { | |
aac1f7f9 | 214 | return internal_create_groups(kobj, 0, groups); |
3e9b2bae GKH |
215 | } |
216 | EXPORT_SYMBOL_GPL(sysfs_create_groups); | |
217 | ||
aac1f7f9 JO |
218 | /** |
219 | * sysfs_update_groups - given a directory kobject, create a bunch of attribute groups | |
220 | * @kobj: The kobject to update the group on | |
221 | * @groups: The attribute groups to update, NULL terminated | |
222 | * | |
223 | * This function update a bunch of attribute groups. If an error occurs when | |
224 | * updating a group, all previously updated groups will be removed together | |
225 | * with already existing (not updated) attributes. | |
226 | * | |
227 | * Returns 0 on success or error code from sysfs_update_group on failure. | |
228 | */ | |
229 | int sysfs_update_groups(struct kobject *kobj, | |
230 | const struct attribute_group **groups) | |
231 | { | |
232 | return internal_create_groups(kobj, 1, groups); | |
233 | } | |
234 | EXPORT_SYMBOL_GPL(sysfs_update_groups); | |
235 | ||
0f423895 | 236 | /** |
1f8e1cda RD |
237 | * sysfs_update_group - given a directory kobject, update an attribute group |
238 | * @kobj: The kobject to update the group on | |
239 | * @grp: The attribute group to update | |
0f423895 JB |
240 | * |
241 | * This function updates an attribute group. Unlike | |
242 | * sysfs_create_group(), it will explicitly not warn or error if any | |
243 | * of the attribute files being created already exist. Furthermore, | |
244 | * if the visibility of the files has changed through the is_visible() | |
245 | * callback, it will update the permissions and add or remove the | |
c855cf27 RJ |
246 | * relevant files. Changing a group's name (subdirectory name under |
247 | * kobj's directory in sysfs) is not allowed. | |
0f423895 JB |
248 | * |
249 | * The primary use for this function is to call it after making a change | |
250 | * that affects group visibility. | |
251 | * | |
ed1dc8a8 | 252 | * Returns 0 on success or error code on failure. |
0f423895 JB |
253 | */ |
254 | int sysfs_update_group(struct kobject *kobj, | |
255 | const struct attribute_group *grp) | |
256 | { | |
257 | return internal_create_group(kobj, 1, grp); | |
258 | } | |
d363bc53 | 259 | EXPORT_SYMBOL_GPL(sysfs_update_group); |
0f423895 | 260 | |
f9ae443b GKH |
261 | /** |
262 | * sysfs_remove_group: remove a group from a kobject | |
263 | * @kobj: kobject to remove the group from | |
264 | * @grp: group to remove | |
265 | * | |
266 | * This function removes a group of attributes from a kobject. The attributes | |
267 | * previously have to have been created for this group, otherwise it will fail. | |
268 | */ | |
995d8ed9 GKH |
269 | void sysfs_remove_group(struct kobject *kobj, |
270 | const struct attribute_group *grp) | |
1da177e4 | 271 | { |
324a56e1 TH |
272 | struct kernfs_node *parent = kobj->sd; |
273 | struct kernfs_node *kn; | |
1da177e4 | 274 | |
057f6c01 | 275 | if (grp->name) { |
324a56e1 TH |
276 | kn = kernfs_find_and_get(parent, grp->name); |
277 | if (!kn) { | |
278 | WARN(!kn, KERN_WARNING | |
78618d39 JT |
279 | "sysfs group '%s' not found for kobject '%s'\n", |
280 | grp->name, kobject_name(kobj)); | |
969affd2 GKH |
281 | return; |
282 | } | |
ccf73cf3 | 283 | } else { |
324a56e1 TH |
284 | kn = parent; |
285 | kernfs_get(kn); | |
ccf73cf3 | 286 | } |
1da177e4 | 287 | |
9f70a401 | 288 | remove_files(kn, grp); |
1da177e4 | 289 | if (grp->name) |
324a56e1 | 290 | kernfs_remove(kn); |
608e266a | 291 | |
324a56e1 | 292 | kernfs_put(kn); |
1da177e4 | 293 | } |
d363bc53 | 294 | EXPORT_SYMBOL_GPL(sysfs_remove_group); |
1da177e4 | 295 | |
3e9b2bae GKH |
296 | /** |
297 | * sysfs_remove_groups - remove a list of groups | |
298 | * | |
f9ae443b GKH |
299 | * @kobj: The kobject for the groups to be removed from |
300 | * @groups: NULL terminated list of groups to be removed | |
3e9b2bae | 301 | * |
09239ed4 | 302 | * If groups is not NULL, remove the specified groups from the kobject. |
3e9b2bae GKH |
303 | */ |
304 | void sysfs_remove_groups(struct kobject *kobj, | |
305 | const struct attribute_group **groups) | |
306 | { | |
307 | int i; | |
308 | ||
309 | if (!groups) | |
310 | return; | |
311 | for (i = 0; groups[i]; i++) | |
312 | sysfs_remove_group(kobj, groups[i]); | |
313 | } | |
314 | EXPORT_SYMBOL_GPL(sysfs_remove_groups); | |
315 | ||
69d44ffb AS |
316 | /** |
317 | * sysfs_merge_group - merge files into a pre-existing attribute group. | |
318 | * @kobj: The kobject containing the group. | |
319 | * @grp: The files to create and the attribute group they belong to. | |
320 | * | |
321 | * This function returns an error if the group doesn't exist or any of the | |
322 | * files already exist in that group, in which case none of the new files | |
323 | * are created. | |
324 | */ | |
325 | int sysfs_merge_group(struct kobject *kobj, | |
326 | const struct attribute_group *grp) | |
327 | { | |
324a56e1 | 328 | struct kernfs_node *parent; |
5f81880d DT |
329 | kuid_t uid; |
330 | kgid_t gid; | |
69d44ffb AS |
331 | int error = 0; |
332 | struct attribute *const *attr; | |
333 | int i; | |
334 | ||
324a56e1 TH |
335 | parent = kernfs_find_and_get(kobj->sd, grp->name); |
336 | if (!parent) | |
69d44ffb AS |
337 | return -ENOENT; |
338 | ||
5f81880d DT |
339 | kobject_get_ownership(kobj, &uid, &gid); |
340 | ||
69d44ffb | 341 | for ((i = 0, attr = grp->attrs); *attr && !error; (++i, ++attr)) |
5cf3bb0d CH |
342 | error = sysfs_add_file_mode_ns(parent, *attr, (*attr)->mode, |
343 | uid, gid, NULL); | |
69d44ffb AS |
344 | if (error) { |
345 | while (--i >= 0) | |
324a56e1 | 346 | kernfs_remove_by_name(parent, (*--attr)->name); |
69d44ffb | 347 | } |
324a56e1 | 348 | kernfs_put(parent); |
69d44ffb AS |
349 | |
350 | return error; | |
351 | } | |
352 | EXPORT_SYMBOL_GPL(sysfs_merge_group); | |
353 | ||
354 | /** | |
355 | * sysfs_unmerge_group - remove files from a pre-existing attribute group. | |
356 | * @kobj: The kobject containing the group. | |
357 | * @grp: The files to remove and the attribute group they belong to. | |
358 | */ | |
359 | void sysfs_unmerge_group(struct kobject *kobj, | |
360 | const struct attribute_group *grp) | |
361 | { | |
324a56e1 | 362 | struct kernfs_node *parent; |
69d44ffb AS |
363 | struct attribute *const *attr; |
364 | ||
324a56e1 TH |
365 | parent = kernfs_find_and_get(kobj->sd, grp->name); |
366 | if (parent) { | |
69d44ffb | 367 | for (attr = grp->attrs; *attr; ++attr) |
324a56e1 TH |
368 | kernfs_remove_by_name(parent, (*attr)->name); |
369 | kernfs_put(parent); | |
69d44ffb AS |
370 | } |
371 | } | |
372 | EXPORT_SYMBOL_GPL(sysfs_unmerge_group); | |
373 | ||
0bb8f3d6 RW |
374 | /** |
375 | * sysfs_add_link_to_group - add a symlink to an attribute group. | |
376 | * @kobj: The kobject containing the group. | |
377 | * @group_name: The name of the group. | |
378 | * @target: The target kobject of the symlink to create. | |
379 | * @link_name: The name of the symlink to create. | |
380 | */ | |
381 | int sysfs_add_link_to_group(struct kobject *kobj, const char *group_name, | |
382 | struct kobject *target, const char *link_name) | |
383 | { | |
324a56e1 | 384 | struct kernfs_node *parent; |
0bb8f3d6 RW |
385 | int error = 0; |
386 | ||
324a56e1 TH |
387 | parent = kernfs_find_and_get(kobj->sd, group_name); |
388 | if (!parent) | |
0bb8f3d6 RW |
389 | return -ENOENT; |
390 | ||
324a56e1 TH |
391 | error = sysfs_create_link_sd(parent, target, link_name); |
392 | kernfs_put(parent); | |
0bb8f3d6 RW |
393 | |
394 | return error; | |
395 | } | |
396 | EXPORT_SYMBOL_GPL(sysfs_add_link_to_group); | |
397 | ||
398 | /** | |
399 | * sysfs_remove_link_from_group - remove a symlink from an attribute group. | |
400 | * @kobj: The kobject containing the group. | |
401 | * @group_name: The name of the group. | |
402 | * @link_name: The name of the symlink to remove. | |
403 | */ | |
404 | void sysfs_remove_link_from_group(struct kobject *kobj, const char *group_name, | |
405 | const char *link_name) | |
406 | { | |
324a56e1 | 407 | struct kernfs_node *parent; |
0bb8f3d6 | 408 | |
324a56e1 TH |
409 | parent = kernfs_find_and_get(kobj->sd, group_name); |
410 | if (parent) { | |
411 | kernfs_remove_by_name(parent, link_name); | |
412 | kernfs_put(parent); | |
0bb8f3d6 RW |
413 | } |
414 | } | |
415 | EXPORT_SYMBOL_GPL(sysfs_remove_link_from_group); | |
37c1c04c | 416 | |
9255782f SJ |
417 | /** |
418 | * compat_only_sysfs_link_entry_to_kobj - add a symlink to a kobject pointing | |
419 | * to a group or an attribute | |
420 | * @kobj: The kobject containing the group. | |
421 | * @target_kobj: The target kobject. | |
422 | * @target_name: The name of the target group or attribute. | |
423 | * @symlink_name: The name of the symlink file (target_name will be | |
424 | * considered if symlink_name is NULL). | |
425 | */ | |
426 | int compat_only_sysfs_link_entry_to_kobj(struct kobject *kobj, | |
427 | struct kobject *target_kobj, | |
428 | const char *target_name, | |
429 | const char *symlink_name) | |
37c1c04c JS |
430 | { |
431 | struct kernfs_node *target; | |
432 | struct kernfs_node *entry; | |
433 | struct kernfs_node *link; | |
434 | ||
435 | /* | |
436 | * We don't own @target_kobj and it may be removed at any time. | |
437 | * Synchronize using sysfs_symlink_target_lock. See sysfs_remove_dir() | |
438 | * for details. | |
439 | */ | |
440 | spin_lock(&sysfs_symlink_target_lock); | |
441 | target = target_kobj->sd; | |
442 | if (target) | |
443 | kernfs_get(target); | |
444 | spin_unlock(&sysfs_symlink_target_lock); | |
445 | if (!target) | |
446 | return -ENOENT; | |
447 | ||
d3ce1979 | 448 | entry = kernfs_find_and_get(target, target_name); |
37c1c04c JS |
449 | if (!entry) { |
450 | kernfs_put(target); | |
451 | return -ENOENT; | |
452 | } | |
453 | ||
9255782f SJ |
454 | if (!symlink_name) |
455 | symlink_name = target_name; | |
456 | ||
457 | link = kernfs_create_link(kobj->sd, symlink_name, entry); | |
45586c70 | 458 | if (PTR_ERR(link) == -EEXIST) |
9255782f | 459 | sysfs_warn_dup(kobj->sd, symlink_name); |
37c1c04c JS |
460 | |
461 | kernfs_put(entry); | |
462 | kernfs_put(target); | |
90b3d2f6 | 463 | return PTR_ERR_OR_ZERO(link); |
37c1c04c | 464 | } |
9255782f | 465 | EXPORT_SYMBOL_GPL(compat_only_sysfs_link_entry_to_kobj); |
303a4276 CB |
466 | |
467 | static int sysfs_group_attrs_change_owner(struct kernfs_node *grp_kn, | |
468 | const struct attribute_group *grp, | |
469 | struct iattr *newattrs) | |
470 | { | |
471 | struct kernfs_node *kn; | |
472 | int error; | |
473 | ||
474 | if (grp->attrs) { | |
475 | struct attribute *const *attr; | |
476 | ||
477 | for (attr = grp->attrs; *attr; attr++) { | |
478 | kn = kernfs_find_and_get(grp_kn, (*attr)->name); | |
479 | if (!kn) | |
480 | return -ENOENT; | |
481 | ||
482 | error = kernfs_setattr(kn, newattrs); | |
483 | kernfs_put(kn); | |
484 | if (error) | |
485 | return error; | |
486 | } | |
487 | } | |
488 | ||
489 | if (grp->bin_attrs) { | |
490 | struct bin_attribute *const *bin_attr; | |
491 | ||
492 | for (bin_attr = grp->bin_attrs; *bin_attr; bin_attr++) { | |
493 | kn = kernfs_find_and_get(grp_kn, (*bin_attr)->attr.name); | |
494 | if (!kn) | |
495 | return -ENOENT; | |
496 | ||
497 | error = kernfs_setattr(kn, newattrs); | |
498 | kernfs_put(kn); | |
499 | if (error) | |
500 | return error; | |
501 | } | |
502 | } | |
503 | ||
504 | return 0; | |
505 | } | |
506 | ||
507 | /** | |
508 | * sysfs_group_change_owner - change owner of an attribute group. | |
509 | * @kobj: The kobject containing the group. | |
510 | * @grp: The attribute group. | |
511 | * @kuid: new owner's kuid | |
512 | * @kgid: new owner's kgid | |
513 | * | |
514 | * Returns 0 on success or error code on failure. | |
515 | */ | |
516 | int sysfs_group_change_owner(struct kobject *kobj, | |
517 | const struct attribute_group *grp, kuid_t kuid, | |
518 | kgid_t kgid) | |
519 | { | |
520 | struct kernfs_node *grp_kn; | |
521 | int error; | |
522 | struct iattr newattrs = { | |
523 | .ia_valid = ATTR_UID | ATTR_GID, | |
524 | .ia_uid = kuid, | |
525 | .ia_gid = kgid, | |
526 | }; | |
527 | ||
528 | if (!kobj->state_in_sysfs) | |
529 | return -EINVAL; | |
530 | ||
531 | if (grp->name) { | |
532 | grp_kn = kernfs_find_and_get(kobj->sd, grp->name); | |
533 | } else { | |
534 | kernfs_get(kobj->sd); | |
535 | grp_kn = kobj->sd; | |
536 | } | |
537 | if (!grp_kn) | |
538 | return -ENOENT; | |
539 | ||
540 | error = kernfs_setattr(grp_kn, &newattrs); | |
541 | if (!error) | |
542 | error = sysfs_group_attrs_change_owner(grp_kn, grp, &newattrs); | |
543 | ||
544 | kernfs_put(grp_kn); | |
545 | ||
546 | return error; | |
547 | } | |
548 | EXPORT_SYMBOL_GPL(sysfs_group_change_owner); | |
549 | ||
550 | /** | |
551 | * sysfs_groups_change_owner - change owner of a set of attribute groups. | |
552 | * @kobj: The kobject containing the groups. | |
553 | * @groups: The attribute groups. | |
554 | * @kuid: new owner's kuid | |
555 | * @kgid: new owner's kgid | |
556 | * | |
557 | * Returns 0 on success or error code on failure. | |
558 | */ | |
559 | int sysfs_groups_change_owner(struct kobject *kobj, | |
560 | const struct attribute_group **groups, | |
561 | kuid_t kuid, kgid_t kgid) | |
562 | { | |
563 | int error = 0, i; | |
564 | ||
565 | if (!kobj->state_in_sysfs) | |
566 | return -EINVAL; | |
567 | ||
568 | if (!groups) | |
569 | return 0; | |
570 | ||
571 | for (i = 0; groups[i]; i++) { | |
572 | error = sysfs_group_change_owner(kobj, groups[i], kuid, kgid); | |
573 | if (error) | |
574 | break; | |
575 | } | |
576 | ||
577 | return error; | |
578 | } | |
579 | EXPORT_SYMBOL_GPL(sysfs_groups_change_owner); |