1
2
3
4
5
6
7
8
9
10
11
12
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 <linux/limits.h>
23#include <asm/uaccess.h>
24
25#include "sysfs.h"
26
27
28
29
30
31
32
33
34
35
36static DEFINE_SPINLOCK(sysfs_open_dirent_lock);
37
38struct sysfs_open_dirent {
39 atomic_t refcnt;
40 atomic_t event;
41 wait_queue_head_t poll;
42 struct list_head buffers;
43};
44
45struct sysfs_buffer {
46 size_t count;
47 loff_t pos;
48 char * page;
49 const struct sysfs_ops * ops;
50 struct mutex mutex;
51 int needs_read_fill;
52 int event;
53 struct list_head list;
54};
55
56
57
58
59
60
61
62
63
64
65
66
67static int fill_read_buffer(struct dentry * dentry, struct sysfs_buffer * buffer)
68{
69 struct sysfs_dirent *attr_sd = dentry->d_fsdata;
70 struct kobject *kobj = attr_sd->s_parent->s_dir.kobj;
71 const struct sysfs_ops * ops = buffer->ops;
72 int ret = 0;
73 ssize_t count;
74
75 if (!buffer->page)
76 buffer->page = (char *) get_zeroed_page(GFP_KERNEL);
77 if (!buffer->page)
78 return -ENOMEM;
79
80
81 if (!sysfs_get_active(attr_sd))
82 return -ENODEV;
83
84 buffer->event = atomic_read(&attr_sd->s_attr.open->event);
85 count = ops->show(kobj, attr_sd->s_attr.attr, buffer->page);
86
87 sysfs_put_active(attr_sd);
88
89
90
91
92
93 if (count >= (ssize_t)PAGE_SIZE) {
94 print_symbol("fill_read_buffer: %s returned bad count\n",
95 (unsigned long)ops->show);
96
97 count = PAGE_SIZE - 1;
98 }
99 if (count >= 0) {
100 buffer->needs_read_fill = 0;
101 buffer->count = count;
102 } else {
103 ret = count;
104 }
105 return ret;
106}
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127static ssize_t
128sysfs_read_file(struct file *file, char __user *buf, size_t count, loff_t *ppos)
129{
130 struct sysfs_buffer * buffer = file->private_data;
131 ssize_t retval = 0;
132
133 mutex_lock(&buffer->mutex);
134 if (buffer->needs_read_fill || *ppos == 0) {
135 retval = fill_read_buffer(file->f_path.dentry,buffer);
136 if (retval)
137 goto out;
138 }
139 pr_debug("%s: count = %zd, ppos = %lld, buf = %s\n",
140 __func__, count, *ppos, buffer->page);
141 retval = simple_read_from_buffer(buf, count, ppos, buffer->page,
142 buffer->count);
143out:
144 mutex_unlock(&buffer->mutex);
145 return retval;
146}
147
148
149
150
151
152
153
154
155
156
157
158static int
159fill_write_buffer(struct sysfs_buffer * buffer, const char __user * buf, size_t count)
160{
161 int error;
162
163 if (!buffer->page)
164 buffer->page = (char *)get_zeroed_page(GFP_KERNEL);
165 if (!buffer->page)
166 return -ENOMEM;
167
168 if (count >= PAGE_SIZE)
169 count = PAGE_SIZE - 1;
170 error = copy_from_user(buffer->page,buf,count);
171 buffer->needs_read_fill = 1;
172
173
174 buffer->page[count] = 0;
175 return error ? -EFAULT : count;
176}
177
178
179
180
181
182
183
184
185
186
187
188
189
190static int
191flush_write_buffer(struct dentry * dentry, struct sysfs_buffer * buffer, size_t count)
192{
193 struct sysfs_dirent *attr_sd = dentry->d_fsdata;
194 struct kobject *kobj = attr_sd->s_parent->s_dir.kobj;
195 const struct sysfs_ops * ops = buffer->ops;
196 int rc;
197
198
199 if (!sysfs_get_active(attr_sd))
200 return -ENODEV;
201
202 rc = ops->store(kobj, attr_sd->s_attr.attr, buffer->page, count);
203
204 sysfs_put_active(attr_sd);
205
206 return rc;
207}
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227static ssize_t
228sysfs_write_file(struct file *file, const char __user *buf, size_t count, loff_t *ppos)
229{
230 struct sysfs_buffer * buffer = file->private_data;
231 ssize_t len;
232
233 mutex_lock(&buffer->mutex);
234 len = fill_write_buffer(buffer, buf, count);
235 if (len > 0)
236 len = flush_write_buffer(file->f_path.dentry, buffer, len);
237 if (len > 0)
238 *ppos += len;
239 mutex_unlock(&buffer->mutex);
240 return len;
241}
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258static int sysfs_get_open_dirent(struct sysfs_dirent *sd,
259 struct sysfs_buffer *buffer)
260{
261 struct sysfs_open_dirent *od, *new_od = NULL;
262
263 retry:
264 spin_lock_irq(&sysfs_open_dirent_lock);
265
266 if (!sd->s_attr.open && new_od) {
267 sd->s_attr.open = new_od;
268 new_od = NULL;
269 }
270
271 od = sd->s_attr.open;
272 if (od) {
273 atomic_inc(&od->refcnt);
274 list_add_tail(&buffer->list, &od->buffers);
275 }
276
277 spin_unlock_irq(&sysfs_open_dirent_lock);
278
279 if (od) {
280 kfree(new_od);
281 return 0;
282 }
283
284
285 new_od = kmalloc(sizeof(*new_od), GFP_KERNEL);
286 if (!new_od)
287 return -ENOMEM;
288
289 atomic_set(&new_od->refcnt, 0);
290 atomic_set(&new_od->event, 1);
291 init_waitqueue_head(&new_od->poll);
292 INIT_LIST_HEAD(&new_od->buffers);
293 goto retry;
294}
295
296
297
298
299
300
301
302
303
304
305
306
307static void sysfs_put_open_dirent(struct sysfs_dirent *sd,
308 struct sysfs_buffer *buffer)
309{
310 struct sysfs_open_dirent *od = sd->s_attr.open;
311 unsigned long flags;
312
313 spin_lock_irqsave(&sysfs_open_dirent_lock, flags);
314
315 list_del(&buffer->list);
316 if (atomic_dec_and_test(&od->refcnt))
317 sd->s_attr.open = NULL;
318 else
319 od = NULL;
320
321 spin_unlock_irqrestore(&sysfs_open_dirent_lock, flags);
322
323 kfree(od);
324}
325
326static int sysfs_open_file(struct inode *inode, struct file *file)
327{
328 struct sysfs_dirent *attr_sd = file->f_path.dentry->d_fsdata;
329 struct kobject *kobj = attr_sd->s_parent->s_dir.kobj;
330 struct sysfs_buffer *buffer;
331 const struct sysfs_ops *ops;
332 int error = -EACCES;
333
334
335 if (!sysfs_get_active(attr_sd))
336 return -ENODEV;
337
338
339 if (kobj->ktype && kobj->ktype->sysfs_ops)
340 ops = kobj->ktype->sysfs_ops;
341 else {
342 WARN(1, KERN_ERR "missing sysfs attribute operations for "
343 "kobject: %s\n", kobject_name(kobj));
344 goto err_out;
345 }
346
347
348
349
350
351 if (file->f_mode & FMODE_WRITE) {
352 if (!(inode->i_mode & S_IWUGO) || !ops->store)
353 goto err_out;
354 }
355
356
357
358
359
360 if (file->f_mode & FMODE_READ) {
361 if (!(inode->i_mode & S_IRUGO) || !ops->show)
362 goto err_out;
363 }
364
365
366
367
368 error = -ENOMEM;
369 buffer = kzalloc(sizeof(struct sysfs_buffer), GFP_KERNEL);
370 if (!buffer)
371 goto err_out;
372
373 mutex_init(&buffer->mutex);
374 buffer->needs_read_fill = 1;
375 buffer->ops = ops;
376 file->private_data = buffer;
377
378
379 error = sysfs_get_open_dirent(attr_sd, buffer);
380 if (error)
381 goto err_free;
382
383
384 sysfs_put_active(attr_sd);
385 return 0;
386
387 err_free:
388 kfree(buffer);
389 err_out:
390 sysfs_put_active(attr_sd);
391 return error;
392}
393
394static int sysfs_release(struct inode *inode, struct file *filp)
395{
396 struct sysfs_dirent *sd = filp->f_path.dentry->d_fsdata;
397 struct sysfs_buffer *buffer = filp->private_data;
398
399 sysfs_put_open_dirent(sd, buffer);
400
401 if (buffer->page)
402 free_page((unsigned long)buffer->page);
403 kfree(buffer);
404
405 return 0;
406}
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421static unsigned int sysfs_poll(struct file *filp, poll_table *wait)
422{
423 struct sysfs_buffer * buffer = filp->private_data;
424 struct sysfs_dirent *attr_sd = filp->f_path.dentry->d_fsdata;
425 struct sysfs_open_dirent *od = attr_sd->s_attr.open;
426
427
428 if (!sysfs_get_active(attr_sd))
429 goto trigger;
430
431 poll_wait(filp, &od->poll, wait);
432
433 sysfs_put_active(attr_sd);
434
435 if (buffer->event != atomic_read(&od->event))
436 goto trigger;
437
438 return DEFAULT_POLLMASK;
439
440 trigger:
441 buffer->needs_read_fill = 1;
442 return DEFAULT_POLLMASK|POLLERR|POLLPRI;
443}
444
445void sysfs_notify_dirent(struct sysfs_dirent *sd)
446{
447 struct sysfs_open_dirent *od;
448 unsigned long flags;
449
450 spin_lock_irqsave(&sysfs_open_dirent_lock, flags);
451
452 if (!WARN_ON(sysfs_type(sd) != SYSFS_KOBJ_ATTR)) {
453 od = sd->s_attr.open;
454 if (od) {
455 atomic_inc(&od->event);
456 wake_up_interruptible(&od->poll);
457 }
458 }
459
460 spin_unlock_irqrestore(&sysfs_open_dirent_lock, flags);
461}
462EXPORT_SYMBOL_GPL(sysfs_notify_dirent);
463
464void sysfs_notify(struct kobject *k, const char *dir, const char *attr)
465{
466 struct sysfs_dirent *sd = k->sd;
467
468 mutex_lock(&sysfs_mutex);
469
470 if (sd && dir)
471 sd = sysfs_find_dirent(sd, NULL, dir);
472 if (sd && attr)
473 sd = sysfs_find_dirent(sd, NULL, attr);
474 if (sd)
475 sysfs_notify_dirent(sd);
476
477 mutex_unlock(&sysfs_mutex);
478}
479EXPORT_SYMBOL_GPL(sysfs_notify);
480
481const struct file_operations sysfs_file_operations = {
482 .read = sysfs_read_file,
483 .write = sysfs_write_file,
484 .llseek = generic_file_llseek,
485 .open = sysfs_open_file,
486 .release = sysfs_release,
487 .poll = sysfs_poll,
488};
489
490static int sysfs_attr_ns(struct kobject *kobj, const struct attribute *attr,
491 const void **pns)
492{
493 struct sysfs_dirent *dir_sd = kobj->sd;
494 const struct sysfs_ops *ops;
495 const void *ns = NULL;
496 int err;
497
498 if (!dir_sd) {
499 WARN(1, KERN_ERR "sysfs: kobject %s without dirent\n",
500 kobject_name(kobj));
501 return -ENOENT;
502 }
503
504 err = 0;
505 if (!sysfs_ns_type(dir_sd))
506 goto out;
507
508 err = -EINVAL;
509 if (!kobj->ktype)
510 goto out;
511 ops = kobj->ktype->sysfs_ops;
512 if (!ops)
513 goto out;
514 if (!ops->namespace)
515 goto out;
516
517 err = 0;
518 ns = ops->namespace(kobj, attr);
519out:
520 if (err) {
521 WARN(1, KERN_ERR "missing sysfs namespace attribute operation for "
522 "kobject: %s\n", kobject_name(kobj));
523 }
524 *pns = ns;
525 return err;
526}
527
528int sysfs_add_file_mode(struct sysfs_dirent *dir_sd,
529 const struct attribute *attr, int type, umode_t amode)
530{
531 umode_t mode = (amode & S_IALLUGO) | S_IFREG;
532 struct sysfs_addrm_cxt acxt;
533 struct sysfs_dirent *sd;
534 const void *ns;
535 int rc;
536
537 rc = sysfs_attr_ns(dir_sd->s_dir.kobj, attr, &ns);
538 if (rc)
539 return rc;
540
541 sd = sysfs_new_dirent(attr->name, mode, type);
542 if (!sd)
543 return -ENOMEM;
544
545 sd->s_ns = ns;
546 sd->s_attr.attr = (void *)attr;
547 sysfs_dirent_init_lockdep(sd);
548
549 sysfs_addrm_start(&acxt, dir_sd);
550 rc = sysfs_add_one(&acxt, sd);
551 sysfs_addrm_finish(&acxt);
552
553 if (rc)
554 sysfs_put(sd);
555
556 return rc;
557}
558
559
560int sysfs_add_file(struct sysfs_dirent *dir_sd, const struct attribute *attr,
561 int type)
562{
563 return sysfs_add_file_mode(dir_sd, attr, type, attr->mode);
564}
565
566
567
568
569
570
571
572
573int sysfs_create_file(struct kobject * kobj, const struct attribute * attr)
574{
575 BUG_ON(!kobj || !kobj->sd || !attr);
576
577 return sysfs_add_file(kobj->sd, attr, SYSFS_KOBJ_ATTR);
578
579}
580
581int sysfs_create_files(struct kobject *kobj, const struct attribute **ptr)
582{
583 int err = 0;
584 int i;
585
586 for (i = 0; ptr[i] && !err; i++)
587 err = sysfs_create_file(kobj, ptr[i]);
588 if (err)
589 while (--i >= 0)
590 sysfs_remove_file(kobj, ptr[i]);
591 return err;
592}
593
594
595
596
597
598
599
600int sysfs_add_file_to_group(struct kobject *kobj,
601 const struct attribute *attr, const char *group)
602{
603 struct sysfs_dirent *dir_sd;
604 int error;
605
606 if (group)
607 dir_sd = sysfs_get_dirent(kobj->sd, NULL, group);
608 else
609 dir_sd = sysfs_get(kobj->sd);
610
611 if (!dir_sd)
612 return -ENOENT;
613
614 error = sysfs_add_file(dir_sd, attr, SYSFS_KOBJ_ATTR);
615 sysfs_put(dir_sd);
616
617 return error;
618}
619EXPORT_SYMBOL_GPL(sysfs_add_file_to_group);
620
621
622
623
624
625
626
627
628int sysfs_chmod_file(struct kobject *kobj, const struct attribute *attr,
629 umode_t mode)
630{
631 struct sysfs_dirent *sd;
632 struct iattr newattrs;
633 const void *ns;
634 int rc;
635
636 rc = sysfs_attr_ns(kobj, attr, &ns);
637 if (rc)
638 return rc;
639
640 mutex_lock(&sysfs_mutex);
641
642 rc = -ENOENT;
643 sd = sysfs_find_dirent(kobj->sd, ns, attr->name);
644 if (!sd)
645 goto out;
646
647 newattrs.ia_mode = (mode & S_IALLUGO) | (sd->s_mode & ~S_IALLUGO);
648 newattrs.ia_valid = ATTR_MODE;
649 rc = sysfs_sd_setattr(sd, &newattrs);
650
651 out:
652 mutex_unlock(&sysfs_mutex);
653 return rc;
654}
655EXPORT_SYMBOL_GPL(sysfs_chmod_file);
656
657
658
659
660
661
662
663
664
665
666void sysfs_remove_file(struct kobject * kobj, const struct attribute * attr)
667{
668 const void *ns;
669
670 if (sysfs_attr_ns(kobj, attr, &ns))
671 return;
672
673 sysfs_hash_and_remove(kobj->sd, ns, attr->name);
674}
675
676void sysfs_remove_files(struct kobject * kobj, const struct attribute **ptr)
677{
678 int i;
679 for (i = 0; ptr[i]; i++)
680 sysfs_remove_file(kobj, ptr[i]);
681}
682
683
684
685
686
687
688
689void sysfs_remove_file_from_group(struct kobject *kobj,
690 const struct attribute *attr, const char *group)
691{
692 struct sysfs_dirent *dir_sd;
693
694 if (group)
695 dir_sd = sysfs_get_dirent(kobj->sd, NULL, group);
696 else
697 dir_sd = sysfs_get(kobj->sd);
698 if (dir_sd) {
699 sysfs_hash_and_remove(dir_sd, NULL, attr->name);
700 sysfs_put(dir_sd);
701 }
702}
703EXPORT_SYMBOL_GPL(sysfs_remove_file_from_group);
704
705struct sysfs_schedule_callback_struct {
706 struct list_head workq_list;
707 struct kobject *kobj;
708 void (*func)(void *);
709 void *data;
710 struct module *owner;
711 struct work_struct work;
712};
713
714static struct workqueue_struct *sysfs_workqueue;
715static DEFINE_MUTEX(sysfs_workq_mutex);
716static LIST_HEAD(sysfs_workq);
717static void sysfs_schedule_callback_work(struct work_struct *work)
718{
719 struct sysfs_schedule_callback_struct *ss = container_of(work,
720 struct sysfs_schedule_callback_struct, work);
721
722 (ss->func)(ss->data);
723 kobject_put(ss->kobj);
724 module_put(ss->owner);
725 mutex_lock(&sysfs_workq_mutex);
726 list_del(&ss->workq_list);
727 mutex_unlock(&sysfs_workq_mutex);
728 kfree(ss);
729}
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752int sysfs_schedule_callback(struct kobject *kobj, void (*func)(void *),
753 void *data, struct module *owner)
754{
755 struct sysfs_schedule_callback_struct *ss, *tmp;
756
757 if (!try_module_get(owner))
758 return -ENODEV;
759
760 mutex_lock(&sysfs_workq_mutex);
761 list_for_each_entry_safe(ss, tmp, &sysfs_workq, workq_list)
762 if (ss->kobj == kobj) {
763 module_put(owner);
764 mutex_unlock(&sysfs_workq_mutex);
765 return -EAGAIN;
766 }
767 mutex_unlock(&sysfs_workq_mutex);
768
769 if (sysfs_workqueue == NULL) {
770 sysfs_workqueue = create_singlethread_workqueue("sysfsd");
771 if (sysfs_workqueue == NULL) {
772 module_put(owner);
773 return -ENOMEM;
774 }
775 }
776
777 ss = kmalloc(sizeof(*ss), GFP_KERNEL);
778 if (!ss) {
779 module_put(owner);
780 return -ENOMEM;
781 }
782 kobject_get(kobj);
783 ss->kobj = kobj;
784 ss->func = func;
785 ss->data = data;
786 ss->owner = owner;
787 INIT_WORK(&ss->work, sysfs_schedule_callback_work);
788 INIT_LIST_HEAD(&ss->workq_list);
789 mutex_lock(&sysfs_workq_mutex);
790 list_add_tail(&ss->workq_list, &sysfs_workq);
791 mutex_unlock(&sysfs_workq_mutex);
792 queue_work(sysfs_workqueue, &ss->work);
793 return 0;
794}
795EXPORT_SYMBOL_GPL(sysfs_schedule_callback);
796
797
798EXPORT_SYMBOL_GPL(sysfs_create_file);
799EXPORT_SYMBOL_GPL(sysfs_remove_file);
800EXPORT_SYMBOL_GPL(sysfs_remove_files);
801EXPORT_SYMBOL_GPL(sysfs_create_files);
802