Commit | Line | Data |
---|---|---|
619daeee | 1 | // SPDX-License-Identifier: GPL-2.0 |
1da177e4 | 2 | /* |
6d66f5cd TH |
3 | * fs/sysfs/file.c - sysfs regular (text) file implementation |
4 | * | |
5 | * Copyright (c) 2001-3 Patrick Mochel | |
6 | * Copyright (c) 2007 SUSE Linux Products GmbH | |
7 | * Copyright (c) 2007 Tejun Heo <teheo@suse.de> | |
8 | * | |
0c1bc6b8 | 9 | * Please see Documentation/filesystems/sysfs.rst for more information. |
1da177e4 LT |
10 | */ |
11 | ||
12 | #include <linux/module.h> | |
1da177e4 | 13 | #include <linux/kobject.h> |
c6f87733 | 14 | #include <linux/slab.h> |
94bebf4d | 15 | #include <linux/list.h> |
52e8c209 | 16 | #include <linux/mutex.h> |
13c589d5 | 17 | #include <linux/seq_file.h> |
2efc459d | 18 | #include <linux/mm.h> |
1da177e4 LT |
19 | |
20 | #include "sysfs.h" | |
f6acf8bb | 21 | |
375b611e | 22 | /* |
324a56e1 | 23 | * Determine ktype->sysfs_ops for the given kernfs_node. This function |
375b611e TH |
24 | * must be called while holding an active reference. |
25 | */ | |
324a56e1 | 26 | static const struct sysfs_ops *sysfs_file_ops(struct kernfs_node *kn) |
375b611e | 27 | { |
adc5e8b5 | 28 | struct kobject *kobj = kn->parent->priv; |
375b611e | 29 | |
df23fc39 | 30 | if (kn->flags & KERNFS_LOCKDEP) |
324a56e1 | 31 | lockdep_assert_held(kn); |
375b611e TH |
32 | return kobj->ktype ? kobj->ktype->sysfs_ops : NULL; |
33 | } | |
34 | ||
13c589d5 TH |
35 | /* |
36 | * Reads on sysfs are handled through seq_file, which takes care of hairy | |
37 | * details like buffering and seeking. The following function pipes | |
38 | * sysfs_ops->show() result through seq_file. | |
1da177e4 | 39 | */ |
c2b19daf | 40 | static int sysfs_kf_seq_show(struct seq_file *sf, void *v) |
1da177e4 | 41 | { |
c525aadd | 42 | struct kernfs_open_file *of = sf->private; |
adc5e8b5 | 43 | struct kobject *kobj = of->kn->parent->priv; |
324a56e1 | 44 | const struct sysfs_ops *ops = sysfs_file_ops(of->kn); |
1da177e4 | 45 | ssize_t count; |
c2b19daf | 46 | char *buf; |
1da177e4 | 47 | |
820879ee CH |
48 | if (WARN_ON_ONCE(!ops->show)) |
49 | return -EINVAL; | |
50 | ||
f5c16f29 | 51 | /* acquire buffer and ensure that it's >= PAGE_SIZE and clear */ |
13c589d5 TH |
52 | count = seq_get_buf(sf, &buf); |
53 | if (count < PAGE_SIZE) { | |
54 | seq_commit(sf, -1); | |
55 | return 0; | |
56 | } | |
f5c16f29 | 57 | memset(buf, 0, PAGE_SIZE); |
1da177e4 | 58 | |
820879ee CH |
59 | count = ops->show(kobj, of->kn->priv, buf); |
60 | if (count < 0) | |
61 | return count; | |
0ab66088 | 62 | |
8118a859 MX |
63 | /* |
64 | * The code works fine with PAGE_SIZE return but it's likely to | |
65 | * indicate truncated result or overflow in normal use cases. | |
66 | */ | |
815d2d50 | 67 | if (count >= (ssize_t)PAGE_SIZE) { |
9e6d35ff SS |
68 | printk("fill_read_buffer: %pS returned bad count\n", |
69 | ops->show); | |
815d2d50 AM |
70 | /* Try to struggle along */ |
71 | count = PAGE_SIZE - 1; | |
72 | } | |
13c589d5 TH |
73 | seq_commit(sf, count); |
74 | return 0; | |
1da177e4 LT |
75 | } |
76 | ||
c525aadd | 77 | static ssize_t sysfs_kf_bin_read(struct kernfs_open_file *of, char *buf, |
c2b19daf | 78 | size_t count, loff_t pos) |
2f0c6b75 | 79 | { |
324a56e1 | 80 | struct bin_attribute *battr = of->kn->priv; |
adc5e8b5 | 81 | struct kobject *kobj = of->kn->parent->priv; |
c2b19daf | 82 | loff_t size = file_inode(of->file)->i_size; |
2f0c6b75 | 83 | |
c2b19daf | 84 | if (!count) |
2f0c6b75 TH |
85 | return 0; |
86 | ||
87 | if (size) { | |
eaa5cd92 | 88 | if (pos >= size) |
2f0c6b75 | 89 | return 0; |
c2b19daf TH |
90 | if (pos + count > size) |
91 | count = size - pos; | |
2f0c6b75 TH |
92 | } |
93 | ||
c2b19daf TH |
94 | if (!battr->read) |
95 | return -EIO; | |
96 | ||
97 | return battr->read(of->file, kobj, battr, buf, pos, count); | |
98 | } | |
99 | ||
4ef67a8c N |
100 | /* kernfs read callback for regular sysfs files with pre-alloc */ |
101 | static ssize_t sysfs_kf_read(struct kernfs_open_file *of, char *buf, | |
102 | size_t count, loff_t pos) | |
103 | { | |
104 | const struct sysfs_ops *ops = sysfs_file_ops(of->kn); | |
105 | struct kobject *kobj = of->kn->parent->priv; | |
c8a139d0 | 106 | ssize_t len; |
4ef67a8c N |
107 | |
108 | /* | |
109 | * If buf != of->prealloc_buf, we don't know how | |
110 | * large it is, so cannot safely pass it to ->show | |
111 | */ | |
17d0774f | 112 | if (WARN_ON_ONCE(buf != of->prealloc_buf)) |
4ef67a8c | 113 | return 0; |
65da3484 | 114 | len = ops->show(kobj, of->kn->priv, buf); |
c8a139d0 N |
115 | if (len < 0) |
116 | return len; | |
17d0774f KK |
117 | if (pos) { |
118 | if (len <= pos) | |
119 | return 0; | |
120 | len -= pos; | |
121 | memmove(buf, buf + pos, len); | |
122 | } | |
c8a139d0 | 123 | return min_t(ssize_t, count, len); |
4ef67a8c N |
124 | } |
125 | ||
50b38ca0 | 126 | /* kernfs write callback for regular sysfs files */ |
c525aadd | 127 | static ssize_t sysfs_kf_write(struct kernfs_open_file *of, char *buf, |
50b38ca0 | 128 | size_t count, loff_t pos) |
1da177e4 | 129 | { |
324a56e1 | 130 | const struct sysfs_ops *ops = sysfs_file_ops(of->kn); |
adc5e8b5 | 131 | struct kobject *kobj = of->kn->parent->priv; |
0ab66088 | 132 | |
50b38ca0 TH |
133 | if (!count) |
134 | return 0; | |
0ab66088 | 135 | |
324a56e1 | 136 | return ops->store(kobj, of->kn->priv, buf, count); |
50b38ca0 | 137 | } |
f9b9a621 | 138 | |
50b38ca0 | 139 | /* kernfs write callback for bin sysfs files */ |
c525aadd | 140 | static ssize_t sysfs_kf_bin_write(struct kernfs_open_file *of, char *buf, |
50b38ca0 TH |
141 | size_t count, loff_t pos) |
142 | { | |
324a56e1 | 143 | struct bin_attribute *battr = of->kn->priv; |
adc5e8b5 | 144 | struct kobject *kobj = of->kn->parent->priv; |
50b38ca0 | 145 | loff_t size = file_inode(of->file)->i_size; |
f9b9a621 | 146 | |
50b38ca0 TH |
147 | if (size) { |
148 | if (size <= pos) | |
09368960 | 149 | return -EFBIG; |
50b38ca0 | 150 | count = min_t(ssize_t, count, size - pos); |
f9b9a621 | 151 | } |
50b38ca0 TH |
152 | if (!count) |
153 | return 0; | |
0ab66088 | 154 | |
50b38ca0 TH |
155 | if (!battr->write) |
156 | return -EIO; | |
1da177e4 | 157 | |
50b38ca0 | 158 | return battr->write(of->file, kobj, battr, buf, pos, count); |
1da177e4 LT |
159 | } |
160 | ||
c525aadd | 161 | static int sysfs_kf_bin_mmap(struct kernfs_open_file *of, |
fdbffaa4 TH |
162 | struct vm_area_struct *vma) |
163 | { | |
324a56e1 | 164 | struct bin_attribute *battr = of->kn->priv; |
adc5e8b5 | 165 | struct kobject *kobj = of->kn->parent->priv; |
fdbffaa4 | 166 | |
fdbffaa4 TH |
167 | return battr->mmap(of->file, kobj, battr, vma); |
168 | } | |
169 | ||
74b30195 DV |
170 | static int sysfs_kf_bin_open(struct kernfs_open_file *of) |
171 | { | |
172 | struct bin_attribute *battr = of->kn->priv; | |
173 | ||
f06aff92 KW |
174 | if (battr->f_mapping) |
175 | of->file->f_mapping = battr->f_mapping(); | |
74b30195 DV |
176 | |
177 | return 0; | |
178 | } | |
179 | ||
324a56e1 | 180 | void sysfs_notify(struct kobject *kobj, const char *dir, const char *attr) |
4508a7a7 | 181 | { |
324a56e1 | 182 | struct kernfs_node *kn = kobj->sd, *tmp; |
51225039 | 183 | |
324a56e1 TH |
184 | if (kn && dir) |
185 | kn = kernfs_find_and_get(kn, dir); | |
024f6471 | 186 | else |
324a56e1 | 187 | kernfs_get(kn); |
024f6471 | 188 | |
324a56e1 TH |
189 | if (kn && attr) { |
190 | tmp = kernfs_find_and_get(kn, attr); | |
191 | kernfs_put(kn); | |
192 | kn = tmp; | |
024f6471 | 193 | } |
51225039 | 194 | |
324a56e1 TH |
195 | if (kn) { |
196 | kernfs_notify(kn); | |
197 | kernfs_put(kn); | |
024f6471 | 198 | } |
4508a7a7 N |
199 | } |
200 | EXPORT_SYMBOL_GPL(sysfs_notify); | |
201 | ||
f6acf8bb TH |
202 | static const struct kernfs_ops sysfs_file_kfops_empty = { |
203 | }; | |
204 | ||
205 | static const struct kernfs_ops sysfs_file_kfops_ro = { | |
206 | .seq_show = sysfs_kf_seq_show, | |
207 | }; | |
208 | ||
209 | static const struct kernfs_ops sysfs_file_kfops_wo = { | |
210 | .write = sysfs_kf_write, | |
211 | }; | |
212 | ||
213 | static const struct kernfs_ops sysfs_file_kfops_rw = { | |
214 | .seq_show = sysfs_kf_seq_show, | |
215 | .write = sysfs_kf_write, | |
216 | }; | |
217 | ||
4ef67a8c N |
218 | static const struct kernfs_ops sysfs_prealloc_kfops_ro = { |
219 | .read = sysfs_kf_read, | |
220 | .prealloc = true, | |
221 | }; | |
222 | ||
2b75869b N |
223 | static const struct kernfs_ops sysfs_prealloc_kfops_wo = { |
224 | .write = sysfs_kf_write, | |
225 | .prealloc = true, | |
226 | }; | |
227 | ||
228 | static const struct kernfs_ops sysfs_prealloc_kfops_rw = { | |
4ef67a8c | 229 | .read = sysfs_kf_read, |
2b75869b N |
230 | .write = sysfs_kf_write, |
231 | .prealloc = true, | |
232 | }; | |
233 | ||
f6acf8bb TH |
234 | static const struct kernfs_ops sysfs_bin_kfops_ro = { |
235 | .read = sysfs_kf_bin_read, | |
236 | }; | |
237 | ||
238 | static const struct kernfs_ops sysfs_bin_kfops_wo = { | |
239 | .write = sysfs_kf_bin_write, | |
240 | }; | |
241 | ||
242 | static const struct kernfs_ops sysfs_bin_kfops_rw = { | |
243 | .read = sysfs_kf_bin_read, | |
244 | .write = sysfs_kf_bin_write, | |
9b2db6e1 TH |
245 | }; |
246 | ||
247 | static const struct kernfs_ops sysfs_bin_kfops_mmap = { | |
248 | .read = sysfs_kf_bin_read, | |
249 | .write = sysfs_kf_bin_write, | |
f6acf8bb | 250 | .mmap = sysfs_kf_bin_mmap, |
74b30195 | 251 | .open = sysfs_kf_bin_open, |
f6acf8bb TH |
252 | }; |
253 | ||
324a56e1 | 254 | int sysfs_add_file_mode_ns(struct kernfs_node *parent, |
5cf3bb0d CH |
255 | const struct attribute *attr, umode_t mode, kuid_t uid, |
256 | kgid_t gid, const void *ns) | |
1da177e4 | 257 | { |
5cf3bb0d CH |
258 | struct kobject *kobj = parent->priv; |
259 | const struct sysfs_ops *sysfs_ops = kobj->ktype->sysfs_ops; | |
517e64f5 | 260 | struct lock_class_key *key = NULL; |
d1a1a960 | 261 | const struct kernfs_ops *ops = NULL; |
324a56e1 | 262 | struct kernfs_node *kn; |
5cf3bb0d CH |
263 | |
264 | /* every kobject with an attribute needs a ktype assigned */ | |
265 | if (WARN(!sysfs_ops, KERN_ERR | |
266 | "missing sysfs attribute operations for kobject: %s\n", | |
267 | kobject_name(kobj))) | |
268 | return -EINVAL; | |
269 | ||
d1a1a960 CH |
270 | if (mode & SYSFS_PREALLOC) { |
271 | if (sysfs_ops->show && sysfs_ops->store) | |
5cf3bb0d | 272 | ops = &sysfs_prealloc_kfops_rw; |
d1a1a960 | 273 | else if (sysfs_ops->show) |
5cf3bb0d | 274 | ops = &sysfs_prealloc_kfops_ro; |
d1a1a960 | 275 | else if (sysfs_ops->store) |
5cf3bb0d | 276 | ops = &sysfs_prealloc_kfops_wo; |
d1a1a960 CH |
277 | } else { |
278 | if (sysfs_ops->show && sysfs_ops->store) | |
279 | ops = &sysfs_file_kfops_rw; | |
280 | else if (sysfs_ops->show) | |
281 | ops = &sysfs_file_kfops_ro; | |
282 | else if (sysfs_ops->store) | |
5cf3bb0d | 283 | ops = &sysfs_file_kfops_wo; |
d1a1a960 CH |
284 | } |
285 | ||
286 | if (!ops) | |
5cf3bb0d | 287 | ops = &sysfs_file_kfops_empty; |
471bd7b7 | 288 | |
5cf3bb0d CH |
289 | #ifdef CONFIG_DEBUG_LOCK_ALLOC |
290 | if (!attr->ignore_lockdep) | |
291 | key = attr->key ?: (struct lock_class_key *)&attr->skey; | |
292 | #endif | |
293 | ||
294 | kn = __kernfs_create_file(parent, attr->name, mode & 0777, uid, gid, | |
295 | PAGE_SIZE, ops, (void *)attr, ns, key); | |
296 | if (IS_ERR(kn)) { | |
297 | if (PTR_ERR(kn) == -EEXIST) | |
298 | sysfs_warn_dup(parent, attr->name); | |
299 | return PTR_ERR(kn); | |
f6acf8bb | 300 | } |
5cf3bb0d CH |
301 | return 0; |
302 | } | |
303 | ||
304 | int sysfs_add_bin_file_mode_ns(struct kernfs_node *parent, | |
305 | const struct bin_attribute *battr, umode_t mode, | |
306 | kuid_t uid, kgid_t gid, const void *ns) | |
307 | { | |
308 | const struct attribute *attr = &battr->attr; | |
309 | struct lock_class_key *key = NULL; | |
310 | const struct kernfs_ops *ops; | |
311 | struct kernfs_node *kn; | |
312 | ||
313 | if (battr->mmap) | |
314 | ops = &sysfs_bin_kfops_mmap; | |
315 | else if (battr->read && battr->write) | |
316 | ops = &sysfs_bin_kfops_rw; | |
317 | else if (battr->read) | |
318 | ops = &sysfs_bin_kfops_ro; | |
319 | else if (battr->write) | |
320 | ops = &sysfs_bin_kfops_wo; | |
321 | else | |
322 | ops = &sysfs_file_kfops_empty; | |
f6acf8bb | 323 | |
517e64f5 TH |
324 | #ifdef CONFIG_DEBUG_LOCK_ALLOC |
325 | if (!attr->ignore_lockdep) | |
326 | key = attr->key ?: (struct lock_class_key *)&attr->skey; | |
327 | #endif | |
5f81880d DT |
328 | |
329 | kn = __kernfs_create_file(parent, attr->name, mode & 0777, uid, gid, | |
5cf3bb0d | 330 | battr->size, ops, (void *)attr, ns, key); |
324a56e1 TH |
331 | if (IS_ERR(kn)) { |
332 | if (PTR_ERR(kn) == -EEXIST) | |
333 | sysfs_warn_dup(parent, attr->name); | |
334 | return PTR_ERR(kn); | |
496f7394 TH |
335 | } |
336 | return 0; | |
337 | } | |
338 | ||
1da177e4 | 339 | /** |
58292cbe TH |
340 | * sysfs_create_file_ns - create an attribute file for an object with custom ns |
341 | * @kobj: object we're creating for | |
342 | * @attr: attribute descriptor | |
343 | * @ns: namespace the new file should belong to | |
1da177e4 | 344 | */ |
58292cbe TH |
345 | int sysfs_create_file_ns(struct kobject *kobj, const struct attribute *attr, |
346 | const void *ns) | |
1da177e4 | 347 | { |
5f81880d DT |
348 | kuid_t uid; |
349 | kgid_t gid; | |
350 | ||
de96e9fe GKH |
351 | if (WARN_ON(!kobj || !kobj->sd || !attr)) |
352 | return -EINVAL; | |
1da177e4 | 353 | |
5f81880d | 354 | kobject_get_ownership(kobj, &uid, &gid); |
5cf3bb0d | 355 | return sysfs_add_file_mode_ns(kobj->sd, attr, attr->mode, uid, gid, ns); |
1da177e4 | 356 | } |
58292cbe | 357 | EXPORT_SYMBOL_GPL(sysfs_create_file_ns); |
1da177e4 | 358 | |
9ee4685c | 359 | int sysfs_create_files(struct kobject *kobj, const struct attribute * const *ptr) |
1c205ae1 AK |
360 | { |
361 | int err = 0; | |
362 | int i; | |
363 | ||
364 | for (i = 0; ptr[i] && !err; i++) | |
365 | err = sysfs_create_file(kobj, ptr[i]); | |
366 | if (err) | |
367 | while (--i >= 0) | |
368 | sysfs_remove_file(kobj, ptr[i]); | |
369 | return err; | |
370 | } | |
1b866757 | 371 | EXPORT_SYMBOL_GPL(sysfs_create_files); |
1da177e4 | 372 | |
dfa87c82 AS |
373 | /** |
374 | * sysfs_add_file_to_group - add an attribute file to a pre-existing group. | |
375 | * @kobj: object we're acting for. | |
376 | * @attr: attribute descriptor. | |
377 | * @group: group name. | |
378 | */ | |
379 | int sysfs_add_file_to_group(struct kobject *kobj, | |
380 | const struct attribute *attr, const char *group) | |
381 | { | |
324a56e1 | 382 | struct kernfs_node *parent; |
5f81880d DT |
383 | kuid_t uid; |
384 | kgid_t gid; | |
dfa87c82 AS |
385 | int error; |
386 | ||
ccf73cf3 | 387 | if (group) { |
324a56e1 | 388 | parent = kernfs_find_and_get(kobj->sd, group); |
ccf73cf3 | 389 | } else { |
324a56e1 TH |
390 | parent = kobj->sd; |
391 | kernfs_get(parent); | |
ccf73cf3 | 392 | } |
11f24fbd | 393 | |
324a56e1 | 394 | if (!parent) |
608e266a TH |
395 | return -ENOENT; |
396 | ||
5f81880d | 397 | kobject_get_ownership(kobj, &uid, &gid); |
5cf3bb0d CH |
398 | error = sysfs_add_file_mode_ns(parent, attr, attr->mode, uid, gid, |
399 | NULL); | |
324a56e1 | 400 | kernfs_put(parent); |
608e266a | 401 | |
dfa87c82 AS |
402 | return error; |
403 | } | |
404 | EXPORT_SYMBOL_GPL(sysfs_add_file_to_group); | |
405 | ||
31e5abe9 KS |
406 | /** |
407 | * sysfs_chmod_file - update the modified mode value on an object attribute. | |
408 | * @kobj: object we're acting for. | |
409 | * @attr: attribute descriptor. | |
410 | * @mode: file permissions. | |
411 | * | |
412 | */ | |
49c19400 | 413 | int sysfs_chmod_file(struct kobject *kobj, const struct attribute *attr, |
48176a97 | 414 | umode_t mode) |
31e5abe9 | 415 | { |
324a56e1 | 416 | struct kernfs_node *kn; |
bc062b1b | 417 | struct iattr newattrs; |
51225039 TH |
418 | int rc; |
419 | ||
324a56e1 TH |
420 | kn = kernfs_find_and_get(kobj->sd, attr->name); |
421 | if (!kn) | |
5d60418e | 422 | return -ENOENT; |
f88123ea | 423 | |
adc5e8b5 | 424 | newattrs.ia_mode = (mode & S_IALLUGO) | (kn->mode & ~S_IALLUGO); |
4c6974f5 | 425 | newattrs.ia_valid = ATTR_MODE; |
f88123ea | 426 | |
324a56e1 | 427 | rc = kernfs_setattr(kn, &newattrs); |
5d60418e | 428 | |
324a56e1 | 429 | kernfs_put(kn); |
51225039 | 430 | return rc; |
31e5abe9 KS |
431 | } |
432 | EXPORT_SYMBOL_GPL(sysfs_chmod_file); | |
433 | ||
2afc9166 BVA |
434 | /** |
435 | * sysfs_break_active_protection - break "active" protection | |
436 | * @kobj: The kernel object @attr is associated with. | |
437 | * @attr: The attribute to break the "active" protection for. | |
438 | * | |
439 | * With sysfs, just like kernfs, deletion of an attribute is postponed until | |
440 | * all active .show() and .store() callbacks have finished unless this function | |
441 | * is called. Hence this function is useful in methods that implement self | |
442 | * deletion. | |
443 | */ | |
444 | struct kernfs_node *sysfs_break_active_protection(struct kobject *kobj, | |
445 | const struct attribute *attr) | |
446 | { | |
447 | struct kernfs_node *kn; | |
448 | ||
449 | kobject_get(kobj); | |
450 | kn = kernfs_find_and_get(kobj->sd, attr->name); | |
451 | if (kn) | |
452 | kernfs_break_active_protection(kn); | |
453 | return kn; | |
454 | } | |
455 | EXPORT_SYMBOL_GPL(sysfs_break_active_protection); | |
456 | ||
457 | /** | |
458 | * sysfs_unbreak_active_protection - restore "active" protection | |
459 | * @kn: Pointer returned by sysfs_break_active_protection(). | |
460 | * | |
461 | * Undo the effects of sysfs_break_active_protection(). Since this function | |
462 | * calls kernfs_put() on the kernfs node that corresponds to the 'attr' | |
463 | * argument passed to sysfs_break_active_protection() that attribute may have | |
464 | * been removed between the sysfs_break_active_protection() and | |
465 | * sysfs_unbreak_active_protection() calls, it is not safe to access @kn after | |
466 | * this function has returned. | |
467 | */ | |
468 | void sysfs_unbreak_active_protection(struct kernfs_node *kn) | |
469 | { | |
470 | struct kobject *kobj = kn->parent->priv; | |
471 | ||
472 | kernfs_unbreak_active_protection(kn); | |
473 | kernfs_put(kn); | |
474 | kobject_put(kobj); | |
475 | } | |
476 | EXPORT_SYMBOL_GPL(sysfs_unbreak_active_protection); | |
477 | ||
1da177e4 | 478 | /** |
58292cbe TH |
479 | * sysfs_remove_file_ns - remove an object attribute with a custom ns tag |
480 | * @kobj: object we're acting for | |
481 | * @attr: attribute descriptor | |
482 | * @ns: namespace tag of the file to remove | |
1da177e4 | 483 | * |
58292cbe | 484 | * Hash the attribute name and namespace tag and kill the victim. |
1da177e4 | 485 | */ |
58292cbe TH |
486 | void sysfs_remove_file_ns(struct kobject *kobj, const struct attribute *attr, |
487 | const void *ns) | |
1da177e4 | 488 | { |
324a56e1 | 489 | struct kernfs_node *parent = kobj->sd; |
487505c2 | 490 | |
324a56e1 | 491 | kernfs_remove_by_name_ns(parent, attr->name, ns); |
1da177e4 | 492 | } |
58292cbe | 493 | EXPORT_SYMBOL_GPL(sysfs_remove_file_ns); |
1da177e4 | 494 | |
6b0afc2a TH |
495 | /** |
496 | * sysfs_remove_file_self - remove an object attribute from its own method | |
497 | * @kobj: object we're acting for | |
498 | * @attr: attribute descriptor | |
499 | * | |
500 | * See kernfs_remove_self() for details. | |
501 | */ | |
502 | bool sysfs_remove_file_self(struct kobject *kobj, const struct attribute *attr) | |
503 | { | |
504 | struct kernfs_node *parent = kobj->sd; | |
505 | struct kernfs_node *kn; | |
506 | bool ret; | |
507 | ||
508 | kn = kernfs_find_and_get(parent, attr->name); | |
509 | if (WARN_ON_ONCE(!kn)) | |
510 | return false; | |
511 | ||
512 | ret = kernfs_remove_self(kn); | |
513 | ||
514 | kernfs_put(kn); | |
515 | return ret; | |
516 | } | |
9ddacff1 | 517 | EXPORT_SYMBOL_GPL(sysfs_remove_file_self); |
6b0afc2a | 518 | |
9ee4685c | 519 | void sysfs_remove_files(struct kobject *kobj, const struct attribute * const *ptr) |
1c205ae1 AK |
520 | { |
521 | int i; | |
4bd4e92c | 522 | |
1c205ae1 AK |
523 | for (i = 0; ptr[i]; i++) |
524 | sysfs_remove_file(kobj, ptr[i]); | |
525 | } | |
1b866757 | 526 | EXPORT_SYMBOL_GPL(sysfs_remove_files); |
1da177e4 | 527 | |
dfa87c82 AS |
528 | /** |
529 | * sysfs_remove_file_from_group - remove an attribute file from a group. | |
530 | * @kobj: object we're acting for. | |
531 | * @attr: attribute descriptor. | |
532 | * @group: group name. | |
533 | */ | |
534 | void sysfs_remove_file_from_group(struct kobject *kobj, | |
535 | const struct attribute *attr, const char *group) | |
536 | { | |
324a56e1 | 537 | struct kernfs_node *parent; |
dfa87c82 | 538 | |
ccf73cf3 | 539 | if (group) { |
324a56e1 | 540 | parent = kernfs_find_and_get(kobj->sd, group); |
ccf73cf3 | 541 | } else { |
324a56e1 TH |
542 | parent = kobj->sd; |
543 | kernfs_get(parent); | |
ccf73cf3 TH |
544 | } |
545 | ||
324a56e1 TH |
546 | if (parent) { |
547 | kernfs_remove_by_name(parent, attr->name); | |
548 | kernfs_put(parent); | |
dfa87c82 AS |
549 | } |
550 | } | |
551 | EXPORT_SYMBOL_GPL(sysfs_remove_file_from_group); | |
552 | ||
3124eb16 TH |
553 | /** |
554 | * sysfs_create_bin_file - create binary file for object. | |
555 | * @kobj: object. | |
556 | * @attr: attribute descriptor. | |
557 | */ | |
558 | int sysfs_create_bin_file(struct kobject *kobj, | |
559 | const struct bin_attribute *attr) | |
560 | { | |
5f81880d DT |
561 | kuid_t uid; |
562 | kgid_t gid; | |
563 | ||
de96e9fe GKH |
564 | if (WARN_ON(!kobj || !kobj->sd || !attr)) |
565 | return -EINVAL; | |
3124eb16 | 566 | |
5f81880d | 567 | kobject_get_ownership(kobj, &uid, &gid); |
5cf3bb0d CH |
568 | return sysfs_add_bin_file_mode_ns(kobj->sd, attr, attr->attr.mode, uid, |
569 | gid, NULL); | |
3124eb16 TH |
570 | } |
571 | EXPORT_SYMBOL_GPL(sysfs_create_bin_file); | |
572 | ||
573 | /** | |
574 | * sysfs_remove_bin_file - remove binary file for object. | |
575 | * @kobj: object. | |
576 | * @attr: attribute descriptor. | |
577 | */ | |
578 | void sysfs_remove_bin_file(struct kobject *kobj, | |
579 | const struct bin_attribute *attr) | |
580 | { | |
879f40d1 | 581 | kernfs_remove_by_name(kobj->sd, attr->attr.name); |
3124eb16 TH |
582 | } |
583 | EXPORT_SYMBOL_GPL(sysfs_remove_bin_file); | |
f70ce185 CB |
584 | |
585 | static int internal_change_owner(struct kernfs_node *kn, kuid_t kuid, | |
586 | kgid_t kgid) | |
587 | { | |
588 | struct iattr newattrs = { | |
589 | .ia_valid = ATTR_UID | ATTR_GID, | |
590 | .ia_uid = kuid, | |
591 | .ia_gid = kgid, | |
592 | }; | |
593 | return kernfs_setattr(kn, &newattrs); | |
594 | } | |
595 | ||
0666a3ae CB |
596 | /** |
597 | * sysfs_link_change_owner - change owner of a sysfs file. | |
598 | * @kobj: object of the kernfs_node the symlink is located in. | |
599 | * @targ: object of the kernfs_node the symlink points to. | |
600 | * @name: name of the link. | |
601 | * @kuid: new owner's kuid | |
602 | * @kgid: new owner's kgid | |
603 | * | |
604 | * This function looks up the sysfs symlink entry @name under @kobj and changes | |
605 | * the ownership to @kuid/@kgid. The symlink is looked up in the namespace of | |
606 | * @targ. | |
607 | * | |
608 | * Returns 0 on success or error code on failure. | |
609 | */ | |
610 | int sysfs_link_change_owner(struct kobject *kobj, struct kobject *targ, | |
611 | const char *name, kuid_t kuid, kgid_t kgid) | |
612 | { | |
613 | struct kernfs_node *kn = NULL; | |
614 | int error; | |
615 | ||
616 | if (!name || !kobj->state_in_sysfs || !targ->state_in_sysfs) | |
617 | return -EINVAL; | |
618 | ||
619 | error = -ENOENT; | |
620 | kn = kernfs_find_and_get_ns(kobj->sd, name, targ->sd->ns); | |
621 | if (!kn) | |
622 | goto out; | |
623 | ||
624 | error = -EINVAL; | |
625 | if (kernfs_type(kn) != KERNFS_LINK) | |
626 | goto out; | |
627 | if (kn->symlink.target_kn->priv != targ) | |
628 | goto out; | |
629 | ||
630 | error = internal_change_owner(kn, kuid, kgid); | |
631 | ||
632 | out: | |
633 | kernfs_put(kn); | |
634 | return error; | |
635 | } | |
636 | ||
f70ce185 CB |
637 | /** |
638 | * sysfs_file_change_owner - change owner of a sysfs file. | |
639 | * @kobj: object. | |
640 | * @name: name of the file to change. | |
641 | * @kuid: new owner's kuid | |
642 | * @kgid: new owner's kgid | |
643 | * | |
644 | * This function looks up the sysfs entry @name under @kobj and changes the | |
645 | * ownership to @kuid/@kgid. | |
646 | * | |
647 | * Returns 0 on success or error code on failure. | |
648 | */ | |
649 | int sysfs_file_change_owner(struct kobject *kobj, const char *name, kuid_t kuid, | |
650 | kgid_t kgid) | |
651 | { | |
652 | struct kernfs_node *kn; | |
653 | int error; | |
654 | ||
655 | if (!name) | |
656 | return -EINVAL; | |
657 | ||
658 | if (!kobj->state_in_sysfs) | |
659 | return -EINVAL; | |
660 | ||
661 | kn = kernfs_find_and_get(kobj->sd, name); | |
662 | if (!kn) | |
663 | return -ENOENT; | |
664 | ||
665 | error = internal_change_owner(kn, kuid, kgid); | |
666 | ||
667 | kernfs_put(kn); | |
668 | ||
669 | return error; | |
670 | } | |
671 | EXPORT_SYMBOL_GPL(sysfs_file_change_owner); | |
2c4f9401 CB |
672 | |
673 | /** | |
674 | * sysfs_change_owner - change owner of the given object. | |
675 | * @kobj: object. | |
676 | * @kuid: new owner's kuid | |
677 | * @kgid: new owner's kgid | |
678 | * | |
679 | * Change the owner of the default directory, files, groups, and attributes of | |
680 | * @kobj to @kuid/@kgid. Note that sysfs_change_owner mirrors how the sysfs | |
681 | * entries for a kobject are added by driver core. In summary, | |
682 | * sysfs_change_owner() takes care of the default directory entry for @kobj, | |
683 | * the default attributes associated with the ktype of @kobj and the default | |
684 | * attributes associated with the ktype of @kobj. | |
685 | * Additional properties not added by driver core have to be changed by the | |
686 | * driver or subsystem which created them. This is similar to how | |
687 | * driver/subsystem specific entries are removed. | |
688 | * | |
689 | * Returns 0 on success or error code on failure. | |
690 | */ | |
691 | int sysfs_change_owner(struct kobject *kobj, kuid_t kuid, kgid_t kgid) | |
692 | { | |
693 | int error; | |
694 | const struct kobj_type *ktype; | |
695 | ||
696 | if (!kobj->state_in_sysfs) | |
697 | return -EINVAL; | |
698 | ||
699 | /* Change the owner of the kobject itself. */ | |
700 | error = internal_change_owner(kobj->sd, kuid, kgid); | |
701 | if (error) | |
702 | return error; | |
703 | ||
704 | ktype = get_ktype(kobj); | |
705 | if (ktype) { | |
2c4f9401 CB |
706 | /* |
707 | * Change owner of the default groups associated with the | |
708 | * ktype of @kobj. | |
709 | */ | |
710 | error = sysfs_groups_change_owner(kobj, ktype->default_groups, | |
711 | kuid, kgid); | |
712 | if (error) | |
713 | return error; | |
714 | } | |
715 | ||
716 | return 0; | |
717 | } | |
718 | EXPORT_SYMBOL_GPL(sysfs_change_owner); | |
2efc459d JP |
719 | |
720 | /** | |
721 | * sysfs_emit - scnprintf equivalent, aware of PAGE_SIZE buffer. | |
722 | * @buf: start of PAGE_SIZE buffer. | |
723 | * @fmt: format | |
724 | * @...: optional arguments to @format | |
725 | * | |
726 | * | |
727 | * Returns number of characters written to @buf. | |
728 | */ | |
729 | int sysfs_emit(char *buf, const char *fmt, ...) | |
730 | { | |
731 | va_list args; | |
732 | int len; | |
733 | ||
734 | if (WARN(!buf || offset_in_page(buf), | |
735 | "invalid sysfs_emit: buf:%p\n", buf)) | |
736 | return 0; | |
737 | ||
738 | va_start(args, fmt); | |
739 | len = vscnprintf(buf, PAGE_SIZE, fmt, args); | |
740 | va_end(args); | |
741 | ||
742 | return len; | |
743 | } | |
744 | EXPORT_SYMBOL_GPL(sysfs_emit); | |
745 | ||
746 | /** | |
747 | * sysfs_emit_at - scnprintf equivalent, aware of PAGE_SIZE buffer. | |
748 | * @buf: start of PAGE_SIZE buffer. | |
749 | * @at: offset in @buf to start write in bytes | |
750 | * @at must be >= 0 && < PAGE_SIZE | |
751 | * @fmt: format | |
752 | * @...: optional arguments to @fmt | |
753 | * | |
754 | * | |
755 | * Returns number of characters written starting at &@buf[@at]. | |
756 | */ | |
757 | int sysfs_emit_at(char *buf, int at, const char *fmt, ...) | |
758 | { | |
759 | va_list args; | |
760 | int len; | |
761 | ||
762 | if (WARN(!buf || offset_in_page(buf) || at < 0 || at >= PAGE_SIZE, | |
763 | "invalid sysfs_emit_at: buf:%p at:%d\n", buf, at)) | |
764 | return 0; | |
765 | ||
766 | va_start(args, fmt); | |
767 | len = vscnprintf(buf + at, PAGE_SIZE - at, fmt, args); | |
768 | va_end(args); | |
769 | ||
770 | return len; | |
771 | } | |
772 | EXPORT_SYMBOL_GPL(sysfs_emit_at); |