1
2
3
4
5
6
7
8
9
10
11
12
13#undef DEBUG
14
15#include <linux/fs.h>
16#include <linux/mount.h>
17#include <linux/module.h>
18#include <linux/kobject.h>
19#include <linux/namei.h>
20#include <linux/idr.h>
21#include <linux/completion.h>
22#include <linux/mutex.h>
23#include <linux/slab.h>
24#include "sysfs.h"
25
26DEFINE_MUTEX(sysfs_mutex);
27DEFINE_MUTEX(sysfs_rename_mutex);
28DEFINE_SPINLOCK(sysfs_assoc_lock);
29
30static DEFINE_SPINLOCK(sysfs_ino_lock);
31static DEFINE_IDA(sysfs_ino_ida);
32
33
34
35
36
37
38
39
40
41
42
43static void sysfs_link_sibling(struct sysfs_dirent *sd)
44{
45 struct sysfs_dirent *parent_sd = sd->s_parent;
46 struct sysfs_dirent **pos;
47
48 BUG_ON(sd->s_sibling);
49
50
51
52
53
54 for (pos = &parent_sd->s_dir.children; *pos; pos = &(*pos)->s_sibling) {
55 if (sd->s_ino < (*pos)->s_ino)
56 break;
57 }
58 sd->s_sibling = *pos;
59 *pos = sd;
60}
61
62
63
64
65
66
67
68
69
70
71
72static void sysfs_unlink_sibling(struct sysfs_dirent *sd)
73{
74 struct sysfs_dirent **pos;
75
76 for (pos = &sd->s_parent->s_dir.children; *pos;
77 pos = &(*pos)->s_sibling) {
78 if (*pos == sd) {
79 *pos = sd->s_sibling;
80 sd->s_sibling = NULL;
81 break;
82 }
83 }
84}
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100struct dentry *sysfs_get_dentry(struct sysfs_dirent *sd)
101{
102 struct dentry *dentry = dget(sysfs_sb->s_root);
103
104 while (dentry->d_fsdata != sd) {
105 struct sysfs_dirent *cur;
106 struct dentry *parent;
107
108
109 cur = sd;
110 while (cur->s_parent != dentry->d_fsdata)
111 cur = cur->s_parent;
112
113
114 parent = dentry;
115 mutex_lock(&parent->d_inode->i_mutex);
116 dentry = lookup_one_noperm(cur->s_name, parent);
117 mutex_unlock(&parent->d_inode->i_mutex);
118 dput(parent);
119
120 if (IS_ERR(dentry))
121 break;
122 }
123 return dentry;
124}
125
126
127
128
129
130
131
132
133
134
135
136static struct sysfs_dirent *sysfs_get_active(struct sysfs_dirent *sd)
137{
138 if (unlikely(!sd))
139 return NULL;
140
141 while (1) {
142 int v, t;
143
144 v = atomic_read(&sd->s_active);
145 if (unlikely(v < 0))
146 return NULL;
147
148 t = atomic_cmpxchg(&sd->s_active, v, v + 1);
149 if (likely(t == v))
150 return sd;
151 if (t < 0)
152 return NULL;
153
154 cpu_relax();
155 }
156}
157
158
159
160
161
162
163
164
165static void sysfs_put_active(struct sysfs_dirent *sd)
166{
167 struct completion *cmpl;
168 int v;
169
170 if (unlikely(!sd))
171 return;
172
173 v = atomic_dec_return(&sd->s_active);
174 if (likely(v != SD_DEACTIVATED_BIAS))
175 return;
176
177
178
179
180 cmpl = (void *)sd->s_sibling;
181 complete(cmpl);
182}
183
184
185
186
187
188
189
190
191
192
193
194
195struct sysfs_dirent *sysfs_get_active_two(struct sysfs_dirent *sd)
196{
197 if (sd) {
198 if (sd->s_parent && unlikely(!sysfs_get_active(sd->s_parent)))
199 return NULL;
200 if (unlikely(!sysfs_get_active(sd))) {
201 sysfs_put_active(sd->s_parent);
202 return NULL;
203 }
204 }
205 return sd;
206}
207
208
209
210
211
212
213
214
215void sysfs_put_active_two(struct sysfs_dirent *sd)
216{
217 if (sd) {
218 sysfs_put_active(sd);
219 sysfs_put_active(sd->s_parent);
220 }
221}
222
223
224
225
226
227
228
229static void sysfs_deactivate(struct sysfs_dirent *sd)
230{
231 DECLARE_COMPLETION_ONSTACK(wait);
232 int v;
233
234 BUG_ON(sd->s_sibling || !(sd->s_flags & SYSFS_FLAG_REMOVED));
235 sd->s_sibling = (void *)&wait;
236
237
238
239
240 v = atomic_add_return(SD_DEACTIVATED_BIAS, &sd->s_active);
241
242 if (v != SD_DEACTIVATED_BIAS)
243 wait_for_completion(&wait);
244
245 sd->s_sibling = NULL;
246}
247
248static int sysfs_alloc_ino(ino_t *pino)
249{
250 int ino, rc;
251
252 retry:
253 spin_lock(&sysfs_ino_lock);
254 rc = ida_get_new_above(&sysfs_ino_ida, 2, &ino);
255 spin_unlock(&sysfs_ino_lock);
256
257 if (rc == -EAGAIN) {
258 if (ida_pre_get(&sysfs_ino_ida, GFP_KERNEL))
259 goto retry;
260 rc = -ENOMEM;
261 }
262
263 *pino = ino;
264 return rc;
265}
266
267static void sysfs_free_ino(ino_t ino)
268{
269 spin_lock(&sysfs_ino_lock);
270 ida_remove(&sysfs_ino_ida, ino);
271 spin_unlock(&sysfs_ino_lock);
272}
273
274void release_sysfs_dirent(struct sysfs_dirent * sd)
275{
276 struct sysfs_dirent *parent_sd;
277
278 repeat:
279
280
281
282 parent_sd = sd->s_parent;
283
284 if (sysfs_type(sd) == SYSFS_KOBJ_LINK)
285 sysfs_put(sd->s_symlink.target_sd);
286 if (sysfs_type(sd) & SYSFS_COPY_NAME)
287 kfree(sd->s_name);
288 kfree(sd->s_iattr);
289 sysfs_free_ino(sd->s_ino);
290 kmem_cache_free(sysfs_dir_cachep, sd);
291
292 sd = parent_sd;
293 if (sd && atomic_dec_and_test(&sd->s_count))
294 goto repeat;
295}
296
297static void sysfs_d_iput(struct dentry * dentry, struct inode * inode)
298{
299 struct sysfs_dirent * sd = dentry->d_fsdata;
300
301 sysfs_put(sd);
302 iput(inode);
303}
304
305static struct dentry_operations sysfs_dentry_ops = {
306 .d_iput = sysfs_d_iput,
307};
308
309struct sysfs_dirent *sysfs_new_dirent(const char *name, umode_t mode, int type)
310{
311 char *dup_name = NULL;
312 struct sysfs_dirent *sd;
313
314 if (type & SYSFS_COPY_NAME) {
315 name = dup_name = kstrdup(name, GFP_KERNEL);
316 if (!name)
317 return NULL;
318 }
319
320 sd = kmem_cache_zalloc(sysfs_dir_cachep, GFP_KERNEL);
321 if (!sd)
322 goto err_out1;
323
324 if (sysfs_alloc_ino(&sd->s_ino))
325 goto err_out2;
326
327 atomic_set(&sd->s_count, 1);
328 atomic_set(&sd->s_active, 0);
329
330 sd->s_name = name;
331 sd->s_mode = mode;
332 sd->s_flags = type;
333
334 return sd;
335
336 err_out2:
337 kmem_cache_free(sysfs_dir_cachep, sd);
338 err_out1:
339 kfree(dup_name);
340 return NULL;
341}
342
343static int sysfs_ilookup_test(struct inode *inode, void *arg)
344{
345 struct sysfs_dirent *sd = arg;
346 return inode->i_ino == sd->s_ino;
347}
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365void sysfs_addrm_start(struct sysfs_addrm_cxt *acxt,
366 struct sysfs_dirent *parent_sd)
367{
368 struct inode *inode;
369
370 memset(acxt, 0, sizeof(*acxt));
371 acxt->parent_sd = parent_sd;
372
373
374
375
376
377 mutex_lock(&sysfs_mutex);
378
379 inode = ilookup5(sysfs_sb, parent_sd->s_ino, sysfs_ilookup_test,
380 parent_sd);
381 if (inode) {
382 WARN_ON(inode->i_state & I_NEW);
383
384
385 acxt->parent_inode = inode;
386
387
388
389
390
391 if (!mutex_trylock(&inode->i_mutex)) {
392 mutex_unlock(&sysfs_mutex);
393 mutex_lock(&inode->i_mutex);
394 mutex_lock(&sysfs_mutex);
395 }
396 }
397}
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419int __sysfs_add_one(struct sysfs_addrm_cxt *acxt, struct sysfs_dirent *sd)
420{
421 if (sysfs_find_dirent(acxt->parent_sd, sd->s_name))
422 return -EEXIST;
423
424 sd->s_parent = sysfs_get(acxt->parent_sd);
425
426 if (sysfs_type(sd) == SYSFS_DIR && acxt->parent_inode)
427 inc_nlink(acxt->parent_inode);
428
429 acxt->cnt++;
430
431 sysfs_link_sibling(sd);
432
433 return 0;
434}
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456int sysfs_add_one(struct sysfs_addrm_cxt *acxt, struct sysfs_dirent *sd)
457{
458 int ret;
459
460 ret = __sysfs_add_one(acxt, sd);
461 WARN(ret == -EEXIST, KERN_WARNING "sysfs: duplicate filename '%s' "
462 "can not be created\n", sd->s_name);
463 return ret;
464}
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481void sysfs_remove_one(struct sysfs_addrm_cxt *acxt, struct sysfs_dirent *sd)
482{
483 BUG_ON(sd->s_flags & SYSFS_FLAG_REMOVED);
484
485 sysfs_unlink_sibling(sd);
486
487 sd->s_flags |= SYSFS_FLAG_REMOVED;
488 sd->s_sibling = acxt->removed;
489 acxt->removed = sd;
490
491 if (sysfs_type(sd) == SYSFS_DIR && acxt->parent_inode)
492 drop_nlink(acxt->parent_inode);
493
494 acxt->cnt++;
495}
496
497
498
499
500
501
502
503
504
505static void sysfs_drop_dentry(struct sysfs_dirent *sd)
506{
507 struct inode *inode;
508 struct dentry *dentry;
509
510 inode = ilookup(sysfs_sb, sd->s_ino);
511 if (!inode)
512 return;
513
514
515
516
517
518
519
520
521repeat:
522 spin_lock(&dcache_lock);
523 list_for_each_entry(dentry, &inode->i_dentry, d_alias) {
524 if (d_unhashed(dentry))
525 continue;
526 dget_locked(dentry);
527 spin_lock(&dentry->d_lock);
528 __d_drop(dentry);
529 spin_unlock(&dentry->d_lock);
530 spin_unlock(&dcache_lock);
531 dput(dentry);
532 goto repeat;
533 }
534 spin_unlock(&dcache_lock);
535
536
537 mutex_lock(&inode->i_mutex);
538
539 inode->i_ctime = CURRENT_TIME;
540 drop_nlink(inode);
541 if (sysfs_type(sd) == SYSFS_DIR)
542 drop_nlink(inode);
543
544 mutex_unlock(&inode->i_mutex);
545
546 iput(inode);
547}
548
549
550
551
552
553
554
555
556
557
558
559
560void sysfs_addrm_finish(struct sysfs_addrm_cxt *acxt)
561{
562
563 mutex_unlock(&sysfs_mutex);
564 if (acxt->parent_inode) {
565 struct inode *inode = acxt->parent_inode;
566
567
568 if (acxt->cnt)
569 inode->i_ctime = inode->i_mtime = CURRENT_TIME;
570
571 mutex_unlock(&inode->i_mutex);
572 iput(inode);
573 }
574
575
576 while (acxt->removed) {
577 struct sysfs_dirent *sd = acxt->removed;
578
579 acxt->removed = sd->s_sibling;
580 sd->s_sibling = NULL;
581
582 sysfs_drop_dentry(sd);
583 sysfs_deactivate(sd);
584 sysfs_put(sd);
585 }
586}
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601struct sysfs_dirent *sysfs_find_dirent(struct sysfs_dirent *parent_sd,
602 const unsigned char *name)
603{
604 struct sysfs_dirent *sd;
605
606 for (sd = parent_sd->s_dir.children; sd; sd = sd->s_sibling)
607 if (!strcmp(sd->s_name, name))
608 return sd;
609 return NULL;
610}
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626struct sysfs_dirent *sysfs_get_dirent(struct sysfs_dirent *parent_sd,
627 const unsigned char *name)
628{
629 struct sysfs_dirent *sd;
630
631 mutex_lock(&sysfs_mutex);
632 sd = sysfs_find_dirent(parent_sd, name);
633 sysfs_get(sd);
634 mutex_unlock(&sysfs_mutex);
635
636 return sd;
637}
638EXPORT_SYMBOL_GPL(sysfs_get_dirent);
639
640static int create_dir(struct kobject *kobj, struct sysfs_dirent *parent_sd,
641 const char *name, struct sysfs_dirent **p_sd)
642{
643 umode_t mode = S_IFDIR| S_IRWXU | S_IRUGO | S_IXUGO;
644 struct sysfs_addrm_cxt acxt;
645 struct sysfs_dirent *sd;
646 int rc;
647
648
649 sd = sysfs_new_dirent(name, mode, SYSFS_DIR);
650 if (!sd)
651 return -ENOMEM;
652 sd->s_dir.kobj = kobj;
653
654
655 sysfs_addrm_start(&acxt, parent_sd);
656 rc = sysfs_add_one(&acxt, sd);
657 sysfs_addrm_finish(&acxt);
658
659 if (rc == 0)
660 *p_sd = sd;
661 else
662 sysfs_put(sd);
663
664 return rc;
665}
666
667int sysfs_create_subdir(struct kobject *kobj, const char *name,
668 struct sysfs_dirent **p_sd)
669{
670 return create_dir(kobj, kobj->sd, name, p_sd);
671}
672
673
674
675
676
677int sysfs_create_dir(struct kobject * kobj)
678{
679 struct sysfs_dirent *parent_sd, *sd;
680 int error = 0;
681
682 BUG_ON(!kobj);
683
684 if (kobj->parent)
685 parent_sd = kobj->parent->sd;
686 else
687 parent_sd = &sysfs_root;
688
689 error = create_dir(kobj, parent_sd, kobject_name(kobj), &sd);
690 if (!error)
691 kobj->sd = sd;
692 return error;
693}
694
695static struct dentry * sysfs_lookup(struct inode *dir, struct dentry *dentry,
696 struct nameidata *nd)
697{
698 struct dentry *ret = NULL;
699 struct sysfs_dirent *parent_sd = dentry->d_parent->d_fsdata;
700 struct sysfs_dirent *sd;
701 struct inode *inode;
702
703 mutex_lock(&sysfs_mutex);
704
705 sd = sysfs_find_dirent(parent_sd, dentry->d_name.name);
706
707
708 if (!sd) {
709 ret = ERR_PTR(-ENOENT);
710 goto out_unlock;
711 }
712
713
714 inode = sysfs_get_inode(sd);
715 if (!inode) {
716 ret = ERR_PTR(-ENOMEM);
717 goto out_unlock;
718 }
719
720
721 dentry->d_op = &sysfs_dentry_ops;
722 dentry->d_fsdata = sysfs_get(sd);
723 d_instantiate(dentry, inode);
724 d_rehash(dentry);
725
726 out_unlock:
727 mutex_unlock(&sysfs_mutex);
728 return ret;
729}
730
731const struct inode_operations sysfs_dir_inode_operations = {
732 .lookup = sysfs_lookup,
733 .setattr = sysfs_setattr,
734};
735
736static void remove_dir(struct sysfs_dirent *sd)
737{
738 struct sysfs_addrm_cxt acxt;
739
740 sysfs_addrm_start(&acxt, sd->s_parent);
741 sysfs_remove_one(&acxt, sd);
742 sysfs_addrm_finish(&acxt);
743}
744
745void sysfs_remove_subdir(struct sysfs_dirent *sd)
746{
747 remove_dir(sd);
748}
749
750
751static void __sysfs_remove_dir(struct sysfs_dirent *dir_sd)
752{
753 struct sysfs_addrm_cxt acxt;
754 struct sysfs_dirent **pos;
755
756 if (!dir_sd)
757 return;
758
759 pr_debug("sysfs %s: removing dir\n", dir_sd->s_name);
760 sysfs_addrm_start(&acxt, dir_sd);
761 pos = &dir_sd->s_dir.children;
762 while (*pos) {
763 struct sysfs_dirent *sd = *pos;
764
765 if (sysfs_type(sd) != SYSFS_DIR)
766 sysfs_remove_one(&acxt, sd);
767 else
768 pos = &(*pos)->s_sibling;
769 }
770 sysfs_addrm_finish(&acxt);
771
772 remove_dir(dir_sd);
773}
774
775
776
777
778
779
780
781
782
783
784void sysfs_remove_dir(struct kobject * kobj)
785{
786 struct sysfs_dirent *sd = kobj->sd;
787
788 spin_lock(&sysfs_assoc_lock);
789 kobj->sd = NULL;
790 spin_unlock(&sysfs_assoc_lock);
791
792 __sysfs_remove_dir(sd);
793}
794
795int sysfs_rename_dir(struct kobject * kobj, const char *new_name)
796{
797 struct sysfs_dirent *sd = kobj->sd;
798 struct dentry *parent = NULL;
799 struct dentry *old_dentry = NULL, *new_dentry = NULL;
800 const char *dup_name = NULL;
801 int error;
802
803 mutex_lock(&sysfs_rename_mutex);
804
805 error = 0;
806 if (strcmp(sd->s_name, new_name) == 0)
807 goto out;
808
809
810 old_dentry = sysfs_get_dentry(sd);
811 if (IS_ERR(old_dentry)) {
812 error = PTR_ERR(old_dentry);
813 old_dentry = NULL;
814 goto out;
815 }
816
817 parent = old_dentry->d_parent;
818
819
820 mutex_lock(&parent->d_inode->i_mutex);
821 mutex_lock(&sysfs_mutex);
822
823 error = -EEXIST;
824 if (sysfs_find_dirent(sd->s_parent, new_name))
825 goto out_unlock;
826
827 error = -ENOMEM;
828 new_dentry = d_alloc_name(parent, new_name);
829 if (!new_dentry)
830 goto out_unlock;
831
832
833 error = -ENOMEM;
834 new_name = dup_name = kstrdup(new_name, GFP_KERNEL);
835 if (!new_name)
836 goto out_unlock;
837
838 dup_name = sd->s_name;
839 sd->s_name = new_name;
840
841
842 d_add(new_dentry, NULL);
843 d_move(old_dentry, new_dentry);
844
845 error = 0;
846 out_unlock:
847 mutex_unlock(&sysfs_mutex);
848 mutex_unlock(&parent->d_inode->i_mutex);
849 kfree(dup_name);
850 dput(old_dentry);
851 dput(new_dentry);
852 out:
853 mutex_unlock(&sysfs_rename_mutex);
854 return error;
855}
856
857int sysfs_move_dir(struct kobject *kobj, struct kobject *new_parent_kobj)
858{
859 struct sysfs_dirent *sd = kobj->sd;
860 struct sysfs_dirent *new_parent_sd;
861 struct dentry *old_parent, *new_parent = NULL;
862 struct dentry *old_dentry = NULL, *new_dentry = NULL;
863 int error;
864
865 mutex_lock(&sysfs_rename_mutex);
866 BUG_ON(!sd->s_parent);
867 new_parent_sd = new_parent_kobj->sd ? new_parent_kobj->sd : &sysfs_root;
868
869 error = 0;
870 if (sd->s_parent == new_parent_sd)
871 goto out;
872
873
874 old_dentry = sysfs_get_dentry(sd);
875 if (IS_ERR(old_dentry)) {
876 error = PTR_ERR(old_dentry);
877 old_dentry = NULL;
878 goto out;
879 }
880 old_parent = old_dentry->d_parent;
881
882 new_parent = sysfs_get_dentry(new_parent_sd);
883 if (IS_ERR(new_parent)) {
884 error = PTR_ERR(new_parent);
885 new_parent = NULL;
886 goto out;
887 }
888
889again:
890 mutex_lock(&old_parent->d_inode->i_mutex);
891 if (!mutex_trylock(&new_parent->d_inode->i_mutex)) {
892 mutex_unlock(&old_parent->d_inode->i_mutex);
893 goto again;
894 }
895 mutex_lock(&sysfs_mutex);
896
897 error = -EEXIST;
898 if (sysfs_find_dirent(new_parent_sd, sd->s_name))
899 goto out_unlock;
900
901 error = -ENOMEM;
902 new_dentry = d_alloc_name(new_parent, sd->s_name);
903 if (!new_dentry)
904 goto out_unlock;
905
906 error = 0;
907 d_add(new_dentry, NULL);
908 d_move(old_dentry, new_dentry);
909
910
911 sysfs_unlink_sibling(sd);
912 sysfs_get(new_parent_sd);
913 sysfs_put(sd->s_parent);
914 sd->s_parent = new_parent_sd;
915 sysfs_link_sibling(sd);
916
917 out_unlock:
918 mutex_unlock(&sysfs_mutex);
919 mutex_unlock(&new_parent->d_inode->i_mutex);
920 mutex_unlock(&old_parent->d_inode->i_mutex);
921 out:
922 dput(new_parent);
923 dput(old_dentry);
924 dput(new_dentry);
925 mutex_unlock(&sysfs_rename_mutex);
926 return error;
927}
928
929
930static inline unsigned char dt_type(struct sysfs_dirent *sd)
931{
932 return (sd->s_mode >> 12) & 15;
933}
934
935static int sysfs_readdir(struct file * filp, void * dirent, filldir_t filldir)
936{
937 struct dentry *dentry = filp->f_path.dentry;
938 struct sysfs_dirent * parent_sd = dentry->d_fsdata;
939 struct sysfs_dirent *pos;
940 ino_t ino;
941
942 if (filp->f_pos == 0) {
943 ino = parent_sd->s_ino;
944 if (filldir(dirent, ".", 1, filp->f_pos, ino, DT_DIR) == 0)
945 filp->f_pos++;
946 }
947 if (filp->f_pos == 1) {
948 if (parent_sd->s_parent)
949 ino = parent_sd->s_parent->s_ino;
950 else
951 ino = parent_sd->s_ino;
952 if (filldir(dirent, "..", 2, filp->f_pos, ino, DT_DIR) == 0)
953 filp->f_pos++;
954 }
955 if ((filp->f_pos > 1) && (filp->f_pos < INT_MAX)) {
956 mutex_lock(&sysfs_mutex);
957
958
959 pos = parent_sd->s_dir.children;
960 while (pos && (filp->f_pos > pos->s_ino))
961 pos = pos->s_sibling;
962
963 for ( ; pos; pos = pos->s_sibling) {
964 const char * name;
965 int len;
966
967 name = pos->s_name;
968 len = strlen(name);
969 filp->f_pos = ino = pos->s_ino;
970
971 if (filldir(dirent, name, len, filp->f_pos, ino,
972 dt_type(pos)) < 0)
973 break;
974 }
975 if (!pos)
976 filp->f_pos = INT_MAX;
977 mutex_unlock(&sysfs_mutex);
978 }
979 return 0;
980}
981
982
983const struct file_operations sysfs_dir_operations = {
984 .read = generic_read_dir,
985 .readdir = sysfs_readdir,
986 .llseek = generic_file_llseek,
987};