2 * file.c - operations for regular (text) files.
5 #include <linux/module.h>
6 #include <linux/fsnotify.h>
7 #include <linux/kobject.h>
8 #include <linux/namei.h>
9 #include <linux/poll.h>
10 #include <linux/list.h>
11 #include <asm/uaccess.h>
12 #include <asm/semaphore.h>
16 #define to_sattr(a) container_of(a,struct subsys_attribute, attr)
19 * Subsystem file operations.
20 * These operations allow subsystems to have files that can be
24 subsys_attr_show(struct kobject
* kobj
, struct attribute
* attr
, char * page
)
26 struct kset
*kset
= to_kset(kobj
);
27 struct subsys_attribute
* sattr
= to_sattr(attr
);
31 ret
= sattr
->show(kset
, page
);
36 subsys_attr_store(struct kobject
* kobj
, struct attribute
* attr
,
37 const char * page
, size_t count
)
39 struct kset
*kset
= to_kset(kobj
);
40 struct subsys_attribute
* sattr
= to_sattr(attr
);
44 ret
= sattr
->store(kset
, page
, count
);
48 static struct sysfs_ops subsys_sysfs_ops
= {
49 .show
= subsys_attr_show
,
50 .store
= subsys_attr_store
,
57 struct sysfs_ops
* ops
;
64 * fill_read_buffer - allocate and fill buffer from object.
65 * @dentry: dentry pointer.
66 * @buffer: data buffer for file.
68 * Allocate @buffer->page, if it hasn't been already, then call the
69 * kobject's show() method to fill the buffer with this attribute's
71 * This is called only once, on the file's first read unless an error
74 static int fill_read_buffer(struct dentry
* dentry
, struct sysfs_buffer
* buffer
)
76 struct sysfs_dirent
*attr_sd
= dentry
->d_fsdata
;
77 struct kobject
*kobj
= attr_sd
->s_parent
->s_elem
.dir
.kobj
;
78 struct sysfs_ops
* ops
= buffer
->ops
;
83 buffer
->page
= (char *) get_zeroed_page(GFP_KERNEL
);
87 /* need attr_sd for attr and ops, its parent for kobj */
88 if (!sysfs_get_active_two(attr_sd
))
91 buffer
->event
= atomic_read(&attr_sd
->s_event
);
92 count
= ops
->show(kobj
, attr_sd
->s_elem
.attr
.attr
, buffer
->page
);
94 sysfs_put_active_two(attr_sd
);
96 BUG_ON(count
> (ssize_t
)PAGE_SIZE
);
98 buffer
->needs_read_fill
= 0;
99 buffer
->count
= count
;
107 * sysfs_read_file - read an attribute.
108 * @file: file pointer.
109 * @buf: buffer to fill.
110 * @count: number of bytes to read.
111 * @ppos: starting offset in file.
113 * Userspace wants to read an attribute file. The attribute descriptor
114 * is in the file's ->d_fsdata. The target object is in the directory's
117 * We call fill_read_buffer() to allocate and fill the buffer from the
118 * object's show() method exactly once (if the read is happening from
119 * the beginning of the file). That should fill the entire buffer with
120 * all the data the object has to offer for that attribute.
121 * We then call flush_read_buffer() to copy the buffer to userspace
122 * in the increments specified.
126 sysfs_read_file(struct file
*file
, char __user
*buf
, size_t count
, loff_t
*ppos
)
128 struct sysfs_buffer
* buffer
= file
->private_data
;
132 if (buffer
->needs_read_fill
) {
133 retval
= fill_read_buffer(file
->f_path
.dentry
,buffer
);
137 pr_debug("%s: count = %zd, ppos = %lld, buf = %s\n",
138 __FUNCTION__
, count
, *ppos
, buffer
->page
);
139 retval
= simple_read_from_buffer(buf
, count
, ppos
, buffer
->page
,
147 * fill_write_buffer - copy buffer from userspace.
148 * @buffer: data buffer for file.
149 * @buf: data from user.
150 * @count: number of bytes in @userbuf.
152 * Allocate @buffer->page if it hasn't been already, then
153 * copy the user-supplied buffer into it.
157 fill_write_buffer(struct sysfs_buffer
* buffer
, const char __user
* buf
, size_t count
)
162 buffer
->page
= (char *)get_zeroed_page(GFP_KERNEL
);
166 if (count
>= PAGE_SIZE
)
167 count
= PAGE_SIZE
- 1;
168 error
= copy_from_user(buffer
->page
,buf
,count
);
169 buffer
->needs_read_fill
= 1;
170 /* if buf is assumed to contain a string, terminate it by \0,
171 so e.g. sscanf() can scan the string easily */
172 buffer
->page
[count
] = 0;
173 return error
? -EFAULT
: count
;
178 * flush_write_buffer - push buffer to kobject.
179 * @dentry: dentry to the attribute
180 * @buffer: data buffer for file.
181 * @count: number of bytes
183 * Get the correct pointers for the kobject and the attribute we're
184 * dealing with, then call the store() method for the attribute,
185 * passing the buffer that we acquired in fill_write_buffer().
189 flush_write_buffer(struct dentry
* dentry
, struct sysfs_buffer
* buffer
, size_t count
)
191 struct sysfs_dirent
*attr_sd
= dentry
->d_fsdata
;
192 struct kobject
*kobj
= attr_sd
->s_parent
->s_elem
.dir
.kobj
;
193 struct sysfs_ops
* ops
= buffer
->ops
;
196 /* need attr_sd for attr and ops, its parent for kobj */
197 if (!sysfs_get_active_two(attr_sd
))
200 rc
= ops
->store(kobj
, attr_sd
->s_elem
.attr
.attr
, buffer
->page
, count
);
202 sysfs_put_active_two(attr_sd
);
209 * sysfs_write_file - write an attribute.
210 * @file: file pointer
211 * @buf: data to write
212 * @count: number of bytes
213 * @ppos: starting offset
215 * Similar to sysfs_read_file(), though working in the opposite direction.
216 * We allocate and fill the data from the user in fill_write_buffer(),
217 * then push it to the kobject in flush_write_buffer().
218 * There is no easy way for us to know if userspace is only doing a partial
219 * write, so we don't support them. We expect the entire buffer to come
220 * on the first write.
221 * Hint: if you're writing a value, first read the file, modify only the
222 * the value you're changing, then write entire buffer back.
226 sysfs_write_file(struct file
*file
, const char __user
*buf
, size_t count
, loff_t
*ppos
)
228 struct sysfs_buffer
* buffer
= file
->private_data
;
232 len
= fill_write_buffer(buffer
, buf
, count
);
234 len
= flush_write_buffer(file
->f_path
.dentry
, buffer
, len
);
241 static int sysfs_open_file(struct inode
*inode
, struct file
*file
)
243 struct sysfs_dirent
*attr_sd
= file
->f_path
.dentry
->d_fsdata
;
244 struct kobject
*kobj
= attr_sd
->s_parent
->s_elem
.dir
.kobj
;
245 struct sysfs_buffer
* buffer
;
246 struct sysfs_ops
* ops
= NULL
;
249 /* need attr_sd for attr and ops, its parent for kobj */
250 if (!sysfs_get_active_two(attr_sd
))
253 /* if the kobject has no ktype, then we assume that it is a subsystem
254 * itself, and use ops for it.
256 if (kobj
->kset
&& kobj
->kset
->ktype
)
257 ops
= kobj
->kset
->ktype
->sysfs_ops
;
258 else if (kobj
->ktype
)
259 ops
= kobj
->ktype
->sysfs_ops
;
261 ops
= &subsys_sysfs_ops
;
265 /* No sysfs operations, either from having no subsystem,
266 * or the subsystem have no operations.
271 /* File needs write support.
272 * The inode's perms must say it's ok,
273 * and we must have a store method.
275 if (file
->f_mode
& FMODE_WRITE
) {
276 if (!(inode
->i_mode
& S_IWUGO
) || !ops
->store
)
280 /* File needs read support.
281 * The inode's perms must say it's ok, and we there
282 * must be a show method for it.
284 if (file
->f_mode
& FMODE_READ
) {
285 if (!(inode
->i_mode
& S_IRUGO
) || !ops
->show
)
289 /* No error? Great, allocate a buffer for the file, and store it
290 * it in file->private_data for easy access.
293 buffer
= kzalloc(sizeof(struct sysfs_buffer
), GFP_KERNEL
);
297 init_MUTEX(&buffer
->sem
);
298 buffer
->needs_read_fill
= 1;
300 file
->private_data
= buffer
;
302 /* open succeeded, put active references and pin attr_sd */
303 sysfs_put_active_two(attr_sd
);
308 sysfs_put_active_two(attr_sd
);
312 static int sysfs_release(struct inode
* inode
, struct file
* filp
)
314 struct sysfs_dirent
*attr_sd
= filp
->f_path
.dentry
->d_fsdata
;
315 struct sysfs_buffer
*buffer
= filp
->private_data
;
321 free_page((unsigned long)buffer
->page
);
327 /* Sysfs attribute files are pollable. The idea is that you read
328 * the content and then you use 'poll' or 'select' to wait for
329 * the content to change. When the content changes (assuming the
330 * manager for the kobject supports notification), poll will
331 * return POLLERR|POLLPRI, and select will return the fd whether
332 * it is waiting for read, write, or exceptions.
333 * Once poll/select indicates that the value has changed, you
334 * need to close and re-open the file, as simply seeking and reading
335 * again will not get new data, or reset the state of 'poll'.
336 * Reminder: this only works for attributes which actively support
337 * it, and it is not possible to test an attribute from userspace
338 * to see if it supports poll (Nether 'poll' or 'select' return
339 * an appropriate error code). When in doubt, set a suitable timeout value.
341 static unsigned int sysfs_poll(struct file
*filp
, poll_table
*wait
)
343 struct sysfs_buffer
* buffer
= filp
->private_data
;
344 struct sysfs_dirent
*attr_sd
= filp
->f_path
.dentry
->d_fsdata
;
345 struct kobject
*kobj
= attr_sd
->s_parent
->s_elem
.dir
.kobj
;
347 /* need parent for the kobj, grab both */
348 if (!sysfs_get_active_two(attr_sd
))
351 poll_wait(filp
, &kobj
->poll
, wait
);
353 sysfs_put_active_two(attr_sd
);
355 if (buffer
->event
!= atomic_read(&attr_sd
->s_event
))
361 buffer
->needs_read_fill
= 1;
362 return POLLERR
|POLLPRI
;
365 void sysfs_notify(struct kobject
*k
, char *dir
, char *attr
)
367 struct sysfs_dirent
*sd
= k
->sd
;
369 mutex_lock(&sysfs_mutex
);
372 sd
= sysfs_find_dirent(sd
, dir
);
374 sd
= sysfs_find_dirent(sd
, attr
);
376 atomic_inc(&sd
->s_event
);
377 wake_up_interruptible(&k
->poll
);
380 mutex_unlock(&sysfs_mutex
);
382 EXPORT_SYMBOL_GPL(sysfs_notify
);
384 const struct file_operations sysfs_file_operations
= {
385 .read
= sysfs_read_file
,
386 .write
= sysfs_write_file
,
387 .llseek
= generic_file_llseek
,
388 .open
= sysfs_open_file
,
389 .release
= sysfs_release
,
394 int sysfs_add_file(struct sysfs_dirent
*dir_sd
, const struct attribute
*attr
,
397 umode_t mode
= (attr
->mode
& S_IALLUGO
) | S_IFREG
;
398 struct sysfs_addrm_cxt acxt
;
399 struct sysfs_dirent
*sd
;
401 sd
= sysfs_new_dirent(attr
->name
, mode
, type
);
404 sd
->s_elem
.attr
.attr
= (void *)attr
;
406 sysfs_addrm_start(&acxt
, dir_sd
);
408 if (!sysfs_find_dirent(dir_sd
, attr
->name
)) {
409 sysfs_add_one(&acxt
, sd
);
410 sysfs_link_sibling(sd
);
413 if (sysfs_addrm_finish(&acxt
))
422 * sysfs_create_file - create an attribute file for an object.
423 * @kobj: object we're creating for.
424 * @attr: atrribute descriptor.
427 int sysfs_create_file(struct kobject
* kobj
, const struct attribute
* attr
)
429 BUG_ON(!kobj
|| !kobj
->sd
|| !attr
);
431 return sysfs_add_file(kobj
->sd
, attr
, SYSFS_KOBJ_ATTR
);
437 * sysfs_add_file_to_group - add an attribute file to a pre-existing group.
438 * @kobj: object we're acting for.
439 * @attr: attribute descriptor.
440 * @group: group name.
442 int sysfs_add_file_to_group(struct kobject
*kobj
,
443 const struct attribute
*attr
, const char *group
)
445 struct sysfs_dirent
*dir_sd
;
448 dir_sd
= sysfs_get_dirent(kobj
->sd
, group
);
452 error
= sysfs_add_file(dir_sd
, attr
, SYSFS_KOBJ_ATTR
);
457 EXPORT_SYMBOL_GPL(sysfs_add_file_to_group
);
461 * sysfs_update_file - update the modified timestamp on an object attribute.
462 * @kobj: object we're acting for.
463 * @attr: attribute descriptor.
465 int sysfs_update_file(struct kobject
* kobj
, const struct attribute
* attr
)
467 struct sysfs_dirent
*victim_sd
= NULL
;
468 struct dentry
*victim
= NULL
;
472 victim_sd
= sysfs_get_dirent(kobj
->sd
, attr
->name
);
476 victim
= sysfs_get_dentry(victim_sd
);
477 if (IS_ERR(victim
)) {
478 rc
= PTR_ERR(victim
);
483 mutex_lock(&victim
->d_inode
->i_mutex
);
484 victim
->d_inode
->i_mtime
= CURRENT_TIME
;
485 fsnotify_modify(victim
);
486 mutex_unlock(&victim
->d_inode
->i_mutex
);
490 sysfs_put(victim_sd
);
496 * sysfs_chmod_file - update the modified mode value on an object attribute.
497 * @kobj: object we're acting for.
498 * @attr: attribute descriptor.
499 * @mode: file permissions.
502 int sysfs_chmod_file(struct kobject
*kobj
, struct attribute
*attr
, mode_t mode
)
504 struct sysfs_dirent
*victim_sd
= NULL
;
505 struct dentry
*victim
= NULL
;
506 struct inode
* inode
;
507 struct iattr newattrs
;
511 victim_sd
= sysfs_get_dirent(kobj
->sd
, attr
->name
);
515 victim
= sysfs_get_dentry(victim_sd
);
516 if (IS_ERR(victim
)) {
517 rc
= PTR_ERR(victim
);
522 inode
= victim
->d_inode
;
523 mutex_lock(&inode
->i_mutex
);
524 newattrs
.ia_mode
= (mode
& S_IALLUGO
) | (inode
->i_mode
& ~S_IALLUGO
);
525 newattrs
.ia_valid
= ATTR_MODE
| ATTR_CTIME
;
526 rc
= notify_change(victim
, &newattrs
);
527 mutex_unlock(&inode
->i_mutex
);
530 sysfs_put(victim_sd
);
533 EXPORT_SYMBOL_GPL(sysfs_chmod_file
);
537 * sysfs_remove_file - remove an object attribute.
538 * @kobj: object we're acting for.
539 * @attr: attribute descriptor.
541 * Hash the attribute name and kill the victim.
544 void sysfs_remove_file(struct kobject
* kobj
, const struct attribute
* attr
)
546 sysfs_hash_and_remove(kobj
->sd
, attr
->name
);
551 * sysfs_remove_file_from_group - remove an attribute file from a group.
552 * @kobj: object we're acting for.
553 * @attr: attribute descriptor.
554 * @group: group name.
556 void sysfs_remove_file_from_group(struct kobject
*kobj
,
557 const struct attribute
*attr
, const char *group
)
559 struct sysfs_dirent
*dir_sd
;
561 dir_sd
= sysfs_get_dirent(kobj
->sd
, group
);
563 sysfs_hash_and_remove(dir_sd
, attr
->name
);
567 EXPORT_SYMBOL_GPL(sysfs_remove_file_from_group
);
569 struct sysfs_schedule_callback_struct
{
570 struct kobject
*kobj
;
571 void (*func
)(void *);
573 struct module
*owner
;
574 struct work_struct work
;
577 static void sysfs_schedule_callback_work(struct work_struct
*work
)
579 struct sysfs_schedule_callback_struct
*ss
= container_of(work
,
580 struct sysfs_schedule_callback_struct
, work
);
582 (ss
->func
)(ss
->data
);
583 kobject_put(ss
->kobj
);
584 module_put(ss
->owner
);
589 * sysfs_schedule_callback - helper to schedule a callback for a kobject
590 * @kobj: object we're acting for.
591 * @func: callback function to invoke later.
592 * @data: argument to pass to @func.
593 * @owner: module owning the callback code
595 * sysfs attribute methods must not unregister themselves or their parent
596 * kobject (which would amount to the same thing). Attempts to do so will
597 * deadlock, since unregistration is mutually exclusive with driver
600 * Instead methods can call this routine, which will attempt to allocate
601 * and schedule a workqueue request to call back @func with @data as its
602 * argument in the workqueue's process context. @kobj will be pinned
603 * until @func returns.
605 * Returns 0 if the request was submitted, -ENOMEM if storage could not
606 * be allocated, -ENODEV if a reference to @owner isn't available.
608 int sysfs_schedule_callback(struct kobject
*kobj
, void (*func
)(void *),
609 void *data
, struct module
*owner
)
611 struct sysfs_schedule_callback_struct
*ss
;
613 if (!try_module_get(owner
))
615 ss
= kmalloc(sizeof(*ss
), GFP_KERNEL
);
625 INIT_WORK(&ss
->work
, sysfs_schedule_callback_work
);
626 schedule_work(&ss
->work
);
629 EXPORT_SYMBOL_GPL(sysfs_schedule_callback
);
632 EXPORT_SYMBOL_GPL(sysfs_create_file
);
633 EXPORT_SYMBOL_GPL(sysfs_remove_file
);
634 EXPORT_SYMBOL_GPL(sysfs_update_file
);