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/fsnotify.h>
18 #include <linux/namei.h>
19 #include <linux/poll.h>
20 #include <linux/list.h>
21 #include <linux/mutex.h>
22 #include <asm/uaccess.h>
27 * There's one sysfs_buffer for each open file and one
28 * sysfs_open_dirent for each sysfs_dirent with one or more open
31 * filp->private_data points to sysfs_buffer and
32 * sysfs_dirent->s_attr.open points to sysfs_open_dirent. s_attr.open
33 * is protected by sysfs_open_dirent_lock.
35 static DEFINE_SPINLOCK(sysfs_open_dirent_lock
);
37 struct sysfs_open_dirent
{
40 wait_queue_head_t poll
;
41 struct list_head buffers
; /* goes through sysfs_buffer.list */
48 struct sysfs_ops
* ops
;
52 struct list_head list
;
56 * fill_read_buffer - allocate and fill buffer from object.
57 * @dentry: dentry pointer.
58 * @buffer: data buffer for file.
60 * Allocate @buffer->page, if it hasn't been already, then call the
61 * kobject's show() method to fill the buffer with this attribute's
63 * This is called only once, on the file's first read unless an error
66 static int fill_read_buffer(struct dentry
* dentry
, struct sysfs_buffer
* buffer
)
68 struct sysfs_dirent
*attr_sd
= dentry
->d_fsdata
;
69 struct kobject
*kobj
= attr_sd
->s_parent
->s_dir
.kobj
;
70 struct sysfs_ops
* ops
= buffer
->ops
;
75 buffer
->page
= (char *) get_zeroed_page(GFP_KERNEL
);
79 /* need attr_sd for attr and ops, its parent for kobj */
80 if (!sysfs_get_active_two(attr_sd
))
83 buffer
->event
= atomic_read(&attr_sd
->s_attr
.open
->event
);
84 count
= ops
->show(kobj
, attr_sd
->s_attr
.attr
, buffer
->page
);
86 sysfs_put_active_two(attr_sd
);
89 * The code works fine with PAGE_SIZE return but it's likely to
90 * indicate truncated result or overflow in normal use cases.
92 if (count
>= (ssize_t
)PAGE_SIZE
) {
93 print_symbol("fill_read_buffer: %s returned bad count\n",
94 (unsigned long)ops
->show
);
95 /* Try to struggle along */
96 count
= PAGE_SIZE
- 1;
99 buffer
->needs_read_fill
= 0;
100 buffer
->count
= count
;
108 * sysfs_read_file - read an attribute.
109 * @file: file pointer.
110 * @buf: buffer to fill.
111 * @count: number of bytes to read.
112 * @ppos: starting offset in file.
114 * Userspace wants to read an attribute file. The attribute descriptor
115 * is in the file's ->d_fsdata. The target object is in the directory's
118 * We call fill_read_buffer() to allocate and fill the buffer from the
119 * object's show() method exactly once (if the read is happening from
120 * the beginning of the file). That should fill the entire buffer with
121 * all the data the object has to offer for that attribute.
122 * We then call flush_read_buffer() to copy the buffer to userspace
123 * in the increments specified.
127 sysfs_read_file(struct file
*file
, char __user
*buf
, size_t count
, loff_t
*ppos
)
129 struct sysfs_buffer
* buffer
= file
->private_data
;
132 mutex_lock(&buffer
->mutex
);
133 if (buffer
->needs_read_fill
|| *ppos
== 0) {
134 retval
= fill_read_buffer(file
->f_path
.dentry
,buffer
);
138 pr_debug("%s: count = %zd, ppos = %lld, buf = %s\n",
139 __func__
, count
, *ppos
, buffer
->page
);
140 retval
= simple_read_from_buffer(buf
, count
, ppos
, buffer
->page
,
143 mutex_unlock(&buffer
->mutex
);
148 * fill_write_buffer - copy buffer from userspace.
149 * @buffer: data buffer for file.
150 * @buf: data from user.
151 * @count: number of bytes in @userbuf.
153 * Allocate @buffer->page if it hasn't been already, then
154 * copy the user-supplied buffer into it.
158 fill_write_buffer(struct sysfs_buffer
* buffer
, const char __user
* buf
, size_t count
)
163 buffer
->page
= (char *)get_zeroed_page(GFP_KERNEL
);
167 if (count
>= PAGE_SIZE
)
168 count
= PAGE_SIZE
- 1;
169 error
= copy_from_user(buffer
->page
,buf
,count
);
170 buffer
->needs_read_fill
= 1;
171 /* if buf is assumed to contain a string, terminate it by \0,
172 so e.g. sscanf() can scan the string easily */
173 buffer
->page
[count
] = 0;
174 return error
? -EFAULT
: count
;
179 * flush_write_buffer - push buffer to kobject.
180 * @dentry: dentry to the attribute
181 * @buffer: data buffer for file.
182 * @count: number of bytes
184 * Get the correct pointers for the kobject and the attribute we're
185 * dealing with, then call the store() method for the attribute,
186 * passing the buffer that we acquired in fill_write_buffer().
190 flush_write_buffer(struct dentry
* dentry
, struct sysfs_buffer
* buffer
, size_t count
)
192 struct sysfs_dirent
*attr_sd
= dentry
->d_fsdata
;
193 struct kobject
*kobj
= attr_sd
->s_parent
->s_dir
.kobj
;
194 struct sysfs_ops
* ops
= buffer
->ops
;
197 /* need attr_sd for attr and ops, its parent for kobj */
198 if (!sysfs_get_active_two(attr_sd
))
201 rc
= ops
->store(kobj
, attr_sd
->s_attr
.attr
, buffer
->page
, count
);
203 sysfs_put_active_two(attr_sd
);
210 * sysfs_write_file - write an attribute.
211 * @file: file pointer
212 * @buf: data to write
213 * @count: number of bytes
214 * @ppos: starting offset
216 * Similar to sysfs_read_file(), though working in the opposite direction.
217 * We allocate and fill the data from the user in fill_write_buffer(),
218 * then push it to the kobject in flush_write_buffer().
219 * There is no easy way for us to know if userspace is only doing a partial
220 * write, so we don't support them. We expect the entire buffer to come
221 * on the first write.
222 * Hint: if you're writing a value, first read the file, modify only the
223 * the value you're changing, then write entire buffer back.
227 sysfs_write_file(struct file
*file
, const char __user
*buf
, size_t count
, loff_t
*ppos
)
229 struct sysfs_buffer
* buffer
= file
->private_data
;
232 mutex_lock(&buffer
->mutex
);
233 len
= fill_write_buffer(buffer
, buf
, count
);
235 len
= flush_write_buffer(file
->f_path
.dentry
, buffer
, len
);
238 mutex_unlock(&buffer
->mutex
);
243 * sysfs_get_open_dirent - get or create sysfs_open_dirent
244 * @sd: target sysfs_dirent
245 * @buffer: sysfs_buffer for this instance of open
247 * If @sd->s_attr.open exists, increment its reference count;
248 * otherwise, create one. @buffer is chained to the buffers
252 * Kernel thread context (may sleep).
255 * 0 on success, -errno on failure.
257 static int sysfs_get_open_dirent(struct sysfs_dirent
*sd
,
258 struct sysfs_buffer
*buffer
)
260 struct sysfs_open_dirent
*od
, *new_od
= NULL
;
263 spin_lock(&sysfs_open_dirent_lock
);
265 if (!sd
->s_attr
.open
&& new_od
) {
266 sd
->s_attr
.open
= new_od
;
270 od
= sd
->s_attr
.open
;
272 atomic_inc(&od
->refcnt
);
273 list_add_tail(&buffer
->list
, &od
->buffers
);
276 spin_unlock(&sysfs_open_dirent_lock
);
283 /* not there, initialize a new one and retry */
284 new_od
= kmalloc(sizeof(*new_od
), GFP_KERNEL
);
288 atomic_set(&new_od
->refcnt
, 0);
289 atomic_set(&new_od
->event
, 1);
290 init_waitqueue_head(&new_od
->poll
);
291 INIT_LIST_HEAD(&new_od
->buffers
);
296 * sysfs_put_open_dirent - put sysfs_open_dirent
297 * @sd: target sysfs_dirent
298 * @buffer: associated sysfs_buffer
300 * Put @sd->s_attr.open and unlink @buffer from the buffers list.
301 * If reference count reaches zero, disassociate and free it.
306 static void sysfs_put_open_dirent(struct sysfs_dirent
*sd
,
307 struct sysfs_buffer
*buffer
)
309 struct sysfs_open_dirent
*od
= sd
->s_attr
.open
;
311 spin_lock(&sysfs_open_dirent_lock
);
313 list_del(&buffer
->list
);
314 if (atomic_dec_and_test(&od
->refcnt
))
315 sd
->s_attr
.open
= NULL
;
319 spin_unlock(&sysfs_open_dirent_lock
);
324 static int sysfs_open_file(struct inode
*inode
, struct file
*file
)
326 struct sysfs_dirent
*attr_sd
= file
->f_path
.dentry
->d_fsdata
;
327 struct kobject
*kobj
= attr_sd
->s_parent
->s_dir
.kobj
;
328 struct sysfs_buffer
*buffer
;
329 struct sysfs_ops
*ops
;
332 /* need attr_sd for attr and ops, its parent for kobj */
333 if (!sysfs_get_active_two(attr_sd
))
336 /* every kobject with an attribute needs a ktype assigned */
337 if (kobj
->ktype
&& kobj
->ktype
->sysfs_ops
)
338 ops
= kobj
->ktype
->sysfs_ops
;
340 printk(KERN_ERR
"missing sysfs attribute operations for "
341 "kobject: %s\n", kobject_name(kobj
));
346 /* File needs write support.
347 * The inode's perms must say it's ok,
348 * and we must have a store method.
350 if (file
->f_mode
& FMODE_WRITE
) {
351 if (!(inode
->i_mode
& S_IWUGO
) || !ops
->store
)
355 /* File needs read support.
356 * The inode's perms must say it's ok, and we there
357 * must be a show method for it.
359 if (file
->f_mode
& FMODE_READ
) {
360 if (!(inode
->i_mode
& S_IRUGO
) || !ops
->show
)
364 /* No error? Great, allocate a buffer for the file, and store it
365 * it in file->private_data for easy access.
368 buffer
= kzalloc(sizeof(struct sysfs_buffer
), GFP_KERNEL
);
372 mutex_init(&buffer
->mutex
);
373 buffer
->needs_read_fill
= 1;
375 file
->private_data
= buffer
;
377 /* make sure we have open dirent struct */
378 error
= sysfs_get_open_dirent(attr_sd
, buffer
);
382 /* open succeeded, put active references */
383 sysfs_put_active_two(attr_sd
);
389 sysfs_put_active_two(attr_sd
);
393 static int sysfs_release(struct inode
*inode
, struct file
*filp
)
395 struct sysfs_dirent
*sd
= filp
->f_path
.dentry
->d_fsdata
;
396 struct sysfs_buffer
*buffer
= filp
->private_data
;
398 sysfs_put_open_dirent(sd
, buffer
);
401 free_page((unsigned long)buffer
->page
);
407 /* Sysfs attribute files are pollable. The idea is that you read
408 * the content and then you use 'poll' or 'select' to wait for
409 * the content to change. When the content changes (assuming the
410 * manager for the kobject supports notification), poll will
411 * return POLLERR|POLLPRI, and select will return the fd whether
412 * it is waiting for read, write, or exceptions.
413 * Once poll/select indicates that the value has changed, you
414 * need to close and re-open the file, or seek to 0 and read again.
415 * Reminder: this only works for attributes which actively support
416 * it, and it is not possible to test an attribute from userspace
417 * to see if it supports poll (Neither 'poll' nor 'select' return
418 * an appropriate error code). When in doubt, set a suitable timeout value.
420 static unsigned int sysfs_poll(struct file
*filp
, poll_table
*wait
)
422 struct sysfs_buffer
* buffer
= filp
->private_data
;
423 struct sysfs_dirent
*attr_sd
= filp
->f_path
.dentry
->d_fsdata
;
424 struct sysfs_open_dirent
*od
= attr_sd
->s_attr
.open
;
426 /* need parent for the kobj, grab both */
427 if (!sysfs_get_active_two(attr_sd
))
430 poll_wait(filp
, &od
->poll
, wait
);
432 sysfs_put_active_two(attr_sd
);
434 if (buffer
->event
!= atomic_read(&od
->event
))
440 buffer
->needs_read_fill
= 1;
441 return POLLERR
|POLLPRI
;
444 void sysfs_notify(struct kobject
*k
, char *dir
, char *attr
)
446 struct sysfs_dirent
*sd
= k
->sd
;
448 mutex_lock(&sysfs_mutex
);
451 sd
= sysfs_find_dirent(sd
, dir
);
453 sd
= sysfs_find_dirent(sd
, attr
);
455 struct sysfs_open_dirent
*od
;
457 spin_lock(&sysfs_open_dirent_lock
);
459 od
= sd
->s_attr
.open
;
461 atomic_inc(&od
->event
);
462 wake_up_interruptible(&od
->poll
);
465 spin_unlock(&sysfs_open_dirent_lock
);
468 mutex_unlock(&sysfs_mutex
);
470 EXPORT_SYMBOL_GPL(sysfs_notify
);
472 const struct file_operations sysfs_file_operations
= {
473 .read
= sysfs_read_file
,
474 .write
= sysfs_write_file
,
475 .llseek
= generic_file_llseek
,
476 .open
= sysfs_open_file
,
477 .release
= sysfs_release
,
481 int sysfs_add_file_mode(struct sysfs_dirent
*dir_sd
,
482 const struct attribute
*attr
, int type
, mode_t amode
)
484 umode_t mode
= (amode
& S_IALLUGO
) | S_IFREG
;
485 struct sysfs_addrm_cxt acxt
;
486 struct sysfs_dirent
*sd
;
489 sd
= sysfs_new_dirent(attr
->name
, mode
, type
);
492 sd
->s_attr
.attr
= (void *)attr
;
494 sysfs_addrm_start(&acxt
, dir_sd
);
495 rc
= sysfs_add_one(&acxt
, sd
);
496 sysfs_addrm_finish(&acxt
);
505 int sysfs_add_file(struct sysfs_dirent
*dir_sd
, const struct attribute
*attr
,
508 return sysfs_add_file_mode(dir_sd
, attr
, type
, attr
->mode
);
513 * sysfs_create_file - create an attribute file for an object.
514 * @kobj: object we're creating for.
515 * @attr: attribute descriptor.
518 int sysfs_create_file(struct kobject
* kobj
, const struct attribute
* attr
)
520 BUG_ON(!kobj
|| !kobj
->sd
|| !attr
);
522 return sysfs_add_file(kobj
->sd
, attr
, SYSFS_KOBJ_ATTR
);
528 * sysfs_add_file_to_group - add an attribute file to a pre-existing group.
529 * @kobj: object we're acting for.
530 * @attr: attribute descriptor.
531 * @group: group name.
533 int sysfs_add_file_to_group(struct kobject
*kobj
,
534 const struct attribute
*attr
, const char *group
)
536 struct sysfs_dirent
*dir_sd
;
540 dir_sd
= sysfs_get_dirent(kobj
->sd
, group
);
542 dir_sd
= sysfs_get(kobj
->sd
);
547 error
= sysfs_add_file(dir_sd
, attr
, SYSFS_KOBJ_ATTR
);
552 EXPORT_SYMBOL_GPL(sysfs_add_file_to_group
);
555 * sysfs_chmod_file - update the modified mode value on an object attribute.
556 * @kobj: object we're acting for.
557 * @attr: attribute descriptor.
558 * @mode: file permissions.
561 int sysfs_chmod_file(struct kobject
*kobj
, struct attribute
*attr
, mode_t mode
)
563 struct sysfs_dirent
*victim_sd
= NULL
;
564 struct dentry
*victim
= NULL
;
565 struct inode
* inode
;
566 struct iattr newattrs
;
570 victim_sd
= sysfs_get_dirent(kobj
->sd
, attr
->name
);
574 mutex_lock(&sysfs_rename_mutex
);
575 victim
= sysfs_get_dentry(victim_sd
);
576 mutex_unlock(&sysfs_rename_mutex
);
577 if (IS_ERR(victim
)) {
578 rc
= PTR_ERR(victim
);
583 inode
= victim
->d_inode
;
585 mutex_lock(&inode
->i_mutex
);
587 newattrs
.ia_mode
= (mode
& S_IALLUGO
) | (inode
->i_mode
& ~S_IALLUGO
);
588 newattrs
.ia_valid
= ATTR_MODE
| ATTR_CTIME
;
589 newattrs
.ia_ctime
= current_fs_time(inode
->i_sb
);
590 rc
= sysfs_setattr(victim
, &newattrs
);
593 fsnotify_change(victim
, newattrs
.ia_valid
);
594 mutex_lock(&sysfs_mutex
);
595 victim_sd
->s_mode
= newattrs
.ia_mode
;
596 mutex_unlock(&sysfs_mutex
);
599 mutex_unlock(&inode
->i_mutex
);
602 sysfs_put(victim_sd
);
605 EXPORT_SYMBOL_GPL(sysfs_chmod_file
);
609 * sysfs_remove_file - remove an object attribute.
610 * @kobj: object we're acting for.
611 * @attr: attribute descriptor.
613 * Hash the attribute name and kill the victim.
616 void sysfs_remove_file(struct kobject
* kobj
, const struct attribute
* attr
)
618 sysfs_hash_and_remove(kobj
->sd
, attr
->name
);
623 * sysfs_remove_file_from_group - remove an attribute file from a group.
624 * @kobj: object we're acting for.
625 * @attr: attribute descriptor.
626 * @group: group name.
628 void sysfs_remove_file_from_group(struct kobject
*kobj
,
629 const struct attribute
*attr
, const char *group
)
631 struct sysfs_dirent
*dir_sd
;
634 dir_sd
= sysfs_get_dirent(kobj
->sd
, group
);
636 dir_sd
= sysfs_get(kobj
->sd
);
638 sysfs_hash_and_remove(dir_sd
, attr
->name
);
642 EXPORT_SYMBOL_GPL(sysfs_remove_file_from_group
);
644 struct sysfs_schedule_callback_struct
{
645 struct kobject
*kobj
;
646 void (*func
)(void *);
648 struct module
*owner
;
649 struct work_struct work
;
652 static void sysfs_schedule_callback_work(struct work_struct
*work
)
654 struct sysfs_schedule_callback_struct
*ss
= container_of(work
,
655 struct sysfs_schedule_callback_struct
, work
);
657 (ss
->func
)(ss
->data
);
658 kobject_put(ss
->kobj
);
659 module_put(ss
->owner
);
664 * sysfs_schedule_callback - helper to schedule a callback for a kobject
665 * @kobj: object we're acting for.
666 * @func: callback function to invoke later.
667 * @data: argument to pass to @func.
668 * @owner: module owning the callback code
670 * sysfs attribute methods must not unregister themselves or their parent
671 * kobject (which would amount to the same thing). Attempts to do so will
672 * deadlock, since unregistration is mutually exclusive with driver
675 * Instead methods can call this routine, which will attempt to allocate
676 * and schedule a workqueue request to call back @func with @data as its
677 * argument in the workqueue's process context. @kobj will be pinned
678 * until @func returns.
680 * Returns 0 if the request was submitted, -ENOMEM if storage could not
681 * be allocated, -ENODEV if a reference to @owner isn't available.
683 int sysfs_schedule_callback(struct kobject
*kobj
, void (*func
)(void *),
684 void *data
, struct module
*owner
)
686 struct sysfs_schedule_callback_struct
*ss
;
688 if (!try_module_get(owner
))
690 ss
= kmalloc(sizeof(*ss
), GFP_KERNEL
);
700 INIT_WORK(&ss
->work
, sysfs_schedule_callback_work
);
701 schedule_work(&ss
->work
);
704 EXPORT_SYMBOL_GPL(sysfs_schedule_callback
);
707 EXPORT_SYMBOL_GPL(sysfs_create_file
);
708 EXPORT_SYMBOL_GPL(sysfs_remove_file
);