2 * fs/sysfs/file.c - sysfs regular (text) file implementation
4 * Copyright (c) 2001-3 Patrick Mochel
5 * Copyright (c) 2007 SUSE Linux Products GmbH
6 * Copyright (c) 2007 Tejun Heo <teheo@suse.de>
8 * This file is released under the GPLv2.
10 * Please see Documentation/filesystems/sysfs.txt for more information.
13 #include <linux/module.h>
14 #include <linux/kobject.h>
15 #include <linux/kallsyms.h>
16 #include <linux/slab.h>
17 #include <linux/list.h>
18 #include <linux/mutex.h>
19 #include <linux/seq_file.h>
22 #include "../kernfs/kernfs-internal.h"
25 * Determine ktype->sysfs_ops for the given kernfs_node. This function
26 * must be called while holding an active reference.
28 static const struct sysfs_ops
*sysfs_file_ops(struct kernfs_node
*kn
)
30 struct kobject
*kobj
= kn
->parent
->priv
;
32 if (kn
->flags
& KERNFS_LOCKDEP
)
33 lockdep_assert_held(kn
);
34 return kobj
->ktype
? kobj
->ktype
->sysfs_ops
: NULL
;
38 * Reads on sysfs are handled through seq_file, which takes care of hairy
39 * details like buffering and seeking. The following function pipes
40 * sysfs_ops->show() result through seq_file.
42 static int sysfs_kf_seq_show(struct seq_file
*sf
, void *v
)
44 struct kernfs_open_file
*of
= sf
->private;
45 struct kobject
*kobj
= of
->kn
->parent
->priv
;
46 const struct sysfs_ops
*ops
= sysfs_file_ops(of
->kn
);
50 /* acquire buffer and ensure that it's >= PAGE_SIZE and clear */
51 count
= seq_get_buf(sf
, &buf
);
52 if (count
< PAGE_SIZE
) {
56 memset(buf
, 0, PAGE_SIZE
);
59 * Invoke show(). Control may reach here via seq file lseek even
60 * if @ops->show() isn't implemented.
63 count
= ops
->show(kobj
, of
->kn
->priv
, buf
);
69 * The code works fine with PAGE_SIZE return but it's likely to
70 * indicate truncated result or overflow in normal use cases.
72 if (count
>= (ssize_t
)PAGE_SIZE
) {
73 print_symbol("fill_read_buffer: %s returned bad count\n",
74 (unsigned long)ops
->show
);
75 /* Try to struggle along */
76 count
= PAGE_SIZE
- 1;
78 seq_commit(sf
, count
);
82 static ssize_t
sysfs_kf_bin_read(struct kernfs_open_file
*of
, char *buf
,
83 size_t count
, loff_t pos
)
85 struct bin_attribute
*battr
= of
->kn
->priv
;
86 struct kobject
*kobj
= of
->kn
->parent
->priv
;
87 loff_t size
= file_inode(of
->file
)->i_size
;
95 if (pos
+ count
> size
)
102 return battr
->read(of
->file
, kobj
, battr
, buf
, pos
, count
);
105 /* kernfs read callback for regular sysfs files with pre-alloc */
106 static ssize_t
sysfs_kf_read(struct kernfs_open_file
*of
, char *buf
,
107 size_t count
, loff_t pos
)
109 const struct sysfs_ops
*ops
= sysfs_file_ops(of
->kn
);
110 struct kobject
*kobj
= of
->kn
->parent
->priv
;
114 * If buf != of->prealloc_buf, we don't know how
115 * large it is, so cannot safely pass it to ->show
117 if (WARN_ON_ONCE(buf
!= of
->prealloc_buf
))
119 len
= ops
->show(kobj
, of
->kn
->priv
, buf
);
126 memmove(buf
, buf
+ pos
, len
);
128 return min_t(ssize_t
, count
, len
);
131 /* kernfs write callback for regular sysfs files */
132 static ssize_t
sysfs_kf_write(struct kernfs_open_file
*of
, char *buf
,
133 size_t count
, loff_t pos
)
135 const struct sysfs_ops
*ops
= sysfs_file_ops(of
->kn
);
136 struct kobject
*kobj
= of
->kn
->parent
->priv
;
141 return ops
->store(kobj
, of
->kn
->priv
, buf
, count
);
144 /* kernfs write callback for bin sysfs files */
145 static ssize_t
sysfs_kf_bin_write(struct kernfs_open_file
*of
, char *buf
,
146 size_t count
, loff_t pos
)
148 struct bin_attribute
*battr
= of
->kn
->priv
;
149 struct kobject
*kobj
= of
->kn
->parent
->priv
;
150 loff_t size
= file_inode(of
->file
)->i_size
;
155 count
= min_t(ssize_t
, count
, size
- pos
);
163 return battr
->write(of
->file
, kobj
, battr
, buf
, pos
, count
);
166 static int sysfs_kf_bin_mmap(struct kernfs_open_file
*of
,
167 struct vm_area_struct
*vma
)
169 struct bin_attribute
*battr
= of
->kn
->priv
;
170 struct kobject
*kobj
= of
->kn
->parent
->priv
;
172 return battr
->mmap(of
->file
, kobj
, battr
, vma
);
175 void sysfs_notify(struct kobject
*kobj
, const char *dir
, const char *attr
)
177 struct kernfs_node
*kn
= kobj
->sd
, *tmp
;
180 kn
= kernfs_find_and_get(kn
, dir
);
185 tmp
= kernfs_find_and_get(kn
, attr
);
195 EXPORT_SYMBOL_GPL(sysfs_notify
);
197 static const struct kernfs_ops sysfs_file_kfops_empty
= {
200 static const struct kernfs_ops sysfs_file_kfops_ro
= {
201 .seq_show
= sysfs_kf_seq_show
,
204 static const struct kernfs_ops sysfs_file_kfops_wo
= {
205 .write
= sysfs_kf_write
,
208 static const struct kernfs_ops sysfs_file_kfops_rw
= {
209 .seq_show
= sysfs_kf_seq_show
,
210 .write
= sysfs_kf_write
,
213 static const struct kernfs_ops sysfs_prealloc_kfops_ro
= {
214 .read
= sysfs_kf_read
,
218 static const struct kernfs_ops sysfs_prealloc_kfops_wo
= {
219 .write
= sysfs_kf_write
,
223 static const struct kernfs_ops sysfs_prealloc_kfops_rw
= {
224 .read
= sysfs_kf_read
,
225 .write
= sysfs_kf_write
,
229 static const struct kernfs_ops sysfs_bin_kfops_ro
= {
230 .read
= sysfs_kf_bin_read
,
233 static const struct kernfs_ops sysfs_bin_kfops_wo
= {
234 .write
= sysfs_kf_bin_write
,
237 static const struct kernfs_ops sysfs_bin_kfops_rw
= {
238 .read
= sysfs_kf_bin_read
,
239 .write
= sysfs_kf_bin_write
,
242 static const struct kernfs_ops sysfs_bin_kfops_mmap
= {
243 .read
= sysfs_kf_bin_read
,
244 .write
= sysfs_kf_bin_write
,
245 .mmap
= sysfs_kf_bin_mmap
,
248 int sysfs_add_file_mode_ns(struct kernfs_node
*parent
,
249 const struct attribute
*attr
, bool is_bin
,
250 umode_t mode
, kuid_t uid
, kgid_t gid
, const void *ns
)
252 struct lock_class_key
*key
= NULL
;
253 const struct kernfs_ops
*ops
;
254 struct kernfs_node
*kn
;
258 struct kobject
*kobj
= parent
->priv
;
259 const struct sysfs_ops
*sysfs_ops
= kobj
->ktype
->sysfs_ops
;
261 /* every kobject with an attribute needs a ktype assigned */
262 if (WARN(!sysfs_ops
, KERN_ERR
263 "missing sysfs attribute operations for kobject: %s\n",
267 if (sysfs_ops
->show
&& sysfs_ops
->store
) {
268 if (mode
& SYSFS_PREALLOC
)
269 ops
= &sysfs_prealloc_kfops_rw
;
271 ops
= &sysfs_file_kfops_rw
;
272 } else if (sysfs_ops
->show
) {
273 if (mode
& SYSFS_PREALLOC
)
274 ops
= &sysfs_prealloc_kfops_ro
;
276 ops
= &sysfs_file_kfops_ro
;
277 } else if (sysfs_ops
->store
) {
278 if (mode
& SYSFS_PREALLOC
)
279 ops
= &sysfs_prealloc_kfops_wo
;
281 ops
= &sysfs_file_kfops_wo
;
283 ops
= &sysfs_file_kfops_empty
;
287 struct bin_attribute
*battr
= (void *)attr
;
290 ops
= &sysfs_bin_kfops_mmap
;
291 else if (battr
->read
&& battr
->write
)
292 ops
= &sysfs_bin_kfops_rw
;
293 else if (battr
->read
)
294 ops
= &sysfs_bin_kfops_ro
;
295 else if (battr
->write
)
296 ops
= &sysfs_bin_kfops_wo
;
298 ops
= &sysfs_file_kfops_empty
;
303 #ifdef CONFIG_DEBUG_LOCK_ALLOC
304 if (!attr
->ignore_lockdep
)
305 key
= attr
->key
?: (struct lock_class_key
*)&attr
->skey
;
308 kn
= __kernfs_create_file(parent
, attr
->name
, mode
& 0777, uid
, gid
,
309 size
, ops
, (void *)attr
, ns
, key
);
311 if (PTR_ERR(kn
) == -EEXIST
)
312 sysfs_warn_dup(parent
, attr
->name
);
319 * sysfs_create_file_ns - create an attribute file for an object with custom ns
320 * @kobj: object we're creating for
321 * @attr: attribute descriptor
322 * @ns: namespace the new file should belong to
324 int sysfs_create_file_ns(struct kobject
*kobj
, const struct attribute
*attr
,
330 BUG_ON(!kobj
|| !kobj
->sd
|| !attr
);
332 kobject_get_ownership(kobj
, &uid
, &gid
);
333 return sysfs_add_file_mode_ns(kobj
->sd
, attr
, false, attr
->mode
,
337 EXPORT_SYMBOL_GPL(sysfs_create_file_ns
);
339 int sysfs_create_files(struct kobject
*kobj
, const struct attribute
**ptr
)
344 for (i
= 0; ptr
[i
] && !err
; i
++)
345 err
= sysfs_create_file(kobj
, ptr
[i
]);
348 sysfs_remove_file(kobj
, ptr
[i
]);
351 EXPORT_SYMBOL_GPL(sysfs_create_files
);
354 * sysfs_add_file_to_group - add an attribute file to a pre-existing group.
355 * @kobj: object we're acting for.
356 * @attr: attribute descriptor.
357 * @group: group name.
359 int sysfs_add_file_to_group(struct kobject
*kobj
,
360 const struct attribute
*attr
, const char *group
)
362 struct kernfs_node
*parent
;
368 parent
= kernfs_find_and_get(kobj
->sd
, group
);
377 kobject_get_ownership(kobj
, &uid
, &gid
);
378 error
= sysfs_add_file_mode_ns(parent
, attr
, false,
379 attr
->mode
, uid
, gid
, NULL
);
384 EXPORT_SYMBOL_GPL(sysfs_add_file_to_group
);
387 * sysfs_chmod_file - update the modified mode value on an object attribute.
388 * @kobj: object we're acting for.
389 * @attr: attribute descriptor.
390 * @mode: file permissions.
393 int sysfs_chmod_file(struct kobject
*kobj
, const struct attribute
*attr
,
396 struct kernfs_node
*kn
;
397 struct iattr newattrs
;
400 kn
= kernfs_find_and_get(kobj
->sd
, attr
->name
);
404 newattrs
.ia_mode
= (mode
& S_IALLUGO
) | (kn
->mode
& ~S_IALLUGO
);
405 newattrs
.ia_valid
= ATTR_MODE
;
407 rc
= kernfs_setattr(kn
, &newattrs
);
412 EXPORT_SYMBOL_GPL(sysfs_chmod_file
);
415 * sysfs_break_active_protection - break "active" protection
416 * @kobj: The kernel object @attr is associated with.
417 * @attr: The attribute to break the "active" protection for.
419 * With sysfs, just like kernfs, deletion of an attribute is postponed until
420 * all active .show() and .store() callbacks have finished unless this function
421 * is called. Hence this function is useful in methods that implement self
424 struct kernfs_node
*sysfs_break_active_protection(struct kobject
*kobj
,
425 const struct attribute
*attr
)
427 struct kernfs_node
*kn
;
430 kn
= kernfs_find_and_get(kobj
->sd
, attr
->name
);
432 kernfs_break_active_protection(kn
);
435 EXPORT_SYMBOL_GPL(sysfs_break_active_protection
);
438 * sysfs_unbreak_active_protection - restore "active" protection
439 * @kn: Pointer returned by sysfs_break_active_protection().
441 * Undo the effects of sysfs_break_active_protection(). Since this function
442 * calls kernfs_put() on the kernfs node that corresponds to the 'attr'
443 * argument passed to sysfs_break_active_protection() that attribute may have
444 * been removed between the sysfs_break_active_protection() and
445 * sysfs_unbreak_active_protection() calls, it is not safe to access @kn after
446 * this function has returned.
448 void sysfs_unbreak_active_protection(struct kernfs_node
*kn
)
450 struct kobject
*kobj
= kn
->parent
->priv
;
452 kernfs_unbreak_active_protection(kn
);
456 EXPORT_SYMBOL_GPL(sysfs_unbreak_active_protection
);
459 * sysfs_remove_file_ns - remove an object attribute with a custom ns tag
460 * @kobj: object we're acting for
461 * @attr: attribute descriptor
462 * @ns: namespace tag of the file to remove
464 * Hash the attribute name and namespace tag and kill the victim.
466 void sysfs_remove_file_ns(struct kobject
*kobj
, const struct attribute
*attr
,
469 struct kernfs_node
*parent
= kobj
->sd
;
471 kernfs_remove_by_name_ns(parent
, attr
->name
, ns
);
473 EXPORT_SYMBOL_GPL(sysfs_remove_file_ns
);
476 * sysfs_remove_file_self - remove an object attribute from its own method
477 * @kobj: object we're acting for
478 * @attr: attribute descriptor
480 * See kernfs_remove_self() for details.
482 bool sysfs_remove_file_self(struct kobject
*kobj
, const struct attribute
*attr
)
484 struct kernfs_node
*parent
= kobj
->sd
;
485 struct kernfs_node
*kn
;
488 kn
= kernfs_find_and_get(parent
, attr
->name
);
489 if (WARN_ON_ONCE(!kn
))
492 ret
= kernfs_remove_self(kn
);
498 void sysfs_remove_files(struct kobject
*kobj
, const struct attribute
**ptr
)
501 for (i
= 0; ptr
[i
]; i
++)
502 sysfs_remove_file(kobj
, ptr
[i
]);
504 EXPORT_SYMBOL_GPL(sysfs_remove_files
);
507 * sysfs_remove_file_from_group - remove an attribute file from a group.
508 * @kobj: object we're acting for.
509 * @attr: attribute descriptor.
510 * @group: group name.
512 void sysfs_remove_file_from_group(struct kobject
*kobj
,
513 const struct attribute
*attr
, const char *group
)
515 struct kernfs_node
*parent
;
518 parent
= kernfs_find_and_get(kobj
->sd
, group
);
525 kernfs_remove_by_name(parent
, attr
->name
);
529 EXPORT_SYMBOL_GPL(sysfs_remove_file_from_group
);
532 * sysfs_create_bin_file - create binary file for object.
534 * @attr: attribute descriptor.
536 int sysfs_create_bin_file(struct kobject
*kobj
,
537 const struct bin_attribute
*attr
)
542 BUG_ON(!kobj
|| !kobj
->sd
|| !attr
);
544 kobject_get_ownership(kobj
, &uid
, &gid
);
545 return sysfs_add_file_mode_ns(kobj
->sd
, &attr
->attr
, true,
546 attr
->attr
.mode
, uid
, gid
, NULL
);
548 EXPORT_SYMBOL_GPL(sysfs_create_bin_file
);
551 * sysfs_remove_bin_file - remove binary file for object.
553 * @attr: attribute descriptor.
555 void sysfs_remove_bin_file(struct kobject
*kobj
,
556 const struct bin_attribute
*attr
)
558 kernfs_remove_by_name(kobj
->sd
, attr
->attr
.name
);
560 EXPORT_SYMBOL_GPL(sysfs_remove_bin_file
);