1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27#undef DEBUG
28
29#include <linux/fs.h>
30#include <linux/mount.h>
31#include <linux/module.h>
32#include <linux/slab.h>
33#include <linux/err.h>
34
35#include <linux/configfs.h>
36#include "configfs_internal.h"
37
38DECLARE_RWSEM(configfs_rename_sem);
39
40
41
42
43
44
45
46
47
48
49
50
51DEFINE_SPINLOCK(configfs_dirent_lock);
52
53static void configfs_d_iput(struct dentry * dentry,
54 struct inode * inode)
55{
56 struct configfs_dirent * sd = dentry->d_fsdata;
57
58 if (sd) {
59 BUG_ON(sd->s_dentry != dentry);
60 sd->s_dentry = NULL;
61 configfs_put(sd);
62 }
63 iput(inode);
64}
65
66
67
68
69
70static int configfs_d_delete(struct dentry *dentry)
71{
72 return 1;
73}
74
75static const struct dentry_operations configfs_dentry_ops = {
76 .d_iput = configfs_d_iput,
77
78 .d_delete = configfs_d_delete,
79};
80
81#ifdef CONFIG_LOCKDEP
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102static void configfs_init_dirent_depth(struct configfs_dirent *sd)
103{
104 sd->s_depth = -1;
105}
106
107static void configfs_set_dir_dirent_depth(struct configfs_dirent *parent_sd,
108 struct configfs_dirent *sd)
109{
110 int parent_depth = parent_sd->s_depth;
111
112 if (parent_depth >= 0)
113 sd->s_depth = parent_depth + 1;
114}
115
116static void
117configfs_adjust_dir_dirent_depth_before_populate(struct configfs_dirent *sd)
118{
119
120
121
122
123
124
125
126
127
128
129 if (sd->s_depth == -1)
130
131
132
133
134 sd->s_depth = 0;
135}
136
137static void
138configfs_adjust_dir_dirent_depth_after_populate(struct configfs_dirent *sd)
139{
140
141 sd->s_depth = -1;
142}
143
144#else
145
146static void configfs_init_dirent_depth(struct configfs_dirent *sd)
147{
148}
149
150static void configfs_set_dir_dirent_depth(struct configfs_dirent *parent_sd,
151 struct configfs_dirent *sd)
152{
153}
154
155static void
156configfs_adjust_dir_dirent_depth_before_populate(struct configfs_dirent *sd)
157{
158}
159
160static void
161configfs_adjust_dir_dirent_depth_after_populate(struct configfs_dirent *sd)
162{
163}
164
165#endif
166
167
168
169
170static struct configfs_dirent *configfs_new_dirent(struct configfs_dirent *parent_sd,
171 void *element, int type)
172{
173 struct configfs_dirent * sd;
174
175 sd = kmem_cache_zalloc(configfs_dir_cachep, GFP_KERNEL);
176 if (!sd)
177 return ERR_PTR(-ENOMEM);
178
179 atomic_set(&sd->s_count, 1);
180 INIT_LIST_HEAD(&sd->s_links);
181 INIT_LIST_HEAD(&sd->s_children);
182 sd->s_element = element;
183 sd->s_type = type;
184 configfs_init_dirent_depth(sd);
185 spin_lock(&configfs_dirent_lock);
186 if (parent_sd->s_type & CONFIGFS_USET_DROPPING) {
187 spin_unlock(&configfs_dirent_lock);
188 kmem_cache_free(configfs_dir_cachep, sd);
189 return ERR_PTR(-ENOENT);
190 }
191 list_add(&sd->s_sibling, &parent_sd->s_children);
192 spin_unlock(&configfs_dirent_lock);
193
194 return sd;
195}
196
197
198
199
200
201
202
203
204static int configfs_dirent_exists(struct configfs_dirent *parent_sd,
205 const unsigned char *new)
206{
207 struct configfs_dirent * sd;
208
209 list_for_each_entry(sd, &parent_sd->s_children, s_sibling) {
210 if (sd->s_element) {
211 const unsigned char *existing = configfs_get_name(sd);
212 if (strcmp(existing, new))
213 continue;
214 else
215 return -EEXIST;
216 }
217 }
218
219 return 0;
220}
221
222
223int configfs_make_dirent(struct configfs_dirent * parent_sd,
224 struct dentry * dentry, void * element,
225 umode_t mode, int type)
226{
227 struct configfs_dirent * sd;
228
229 sd = configfs_new_dirent(parent_sd, element, type);
230 if (IS_ERR(sd))
231 return PTR_ERR(sd);
232
233 sd->s_mode = mode;
234 sd->s_dentry = dentry;
235 if (dentry) {
236 dentry->d_fsdata = configfs_get(sd);
237 dentry->d_op = &configfs_dentry_ops;
238 }
239
240 return 0;
241}
242
243static int init_dir(struct inode * inode)
244{
245 inode->i_op = &configfs_dir_inode_operations;
246 inode->i_fop = &configfs_dir_operations;
247
248
249 inc_nlink(inode);
250 return 0;
251}
252
253static int configfs_init_file(struct inode * inode)
254{
255 inode->i_size = PAGE_SIZE;
256 inode->i_fop = &configfs_file_operations;
257 return 0;
258}
259
260static int init_symlink(struct inode * inode)
261{
262 inode->i_op = &configfs_symlink_inode_operations;
263 return 0;
264}
265
266static int create_dir(struct config_item * k, struct dentry * p,
267 struct dentry * d)
268{
269 int error;
270 umode_t mode = S_IFDIR| S_IRWXU | S_IRUGO | S_IXUGO;
271
272 error = configfs_dirent_exists(p->d_fsdata, d->d_name.name);
273 if (!error)
274 error = configfs_make_dirent(p->d_fsdata, d, k, mode,
275 CONFIGFS_DIR | CONFIGFS_USET_CREATING);
276 if (!error) {
277 configfs_set_dir_dirent_depth(p->d_fsdata, d->d_fsdata);
278 error = configfs_create(d, mode, init_dir);
279 if (!error) {
280 inc_nlink(p->d_inode);
281 (d)->d_op = &configfs_dentry_ops;
282 } else {
283 struct configfs_dirent *sd = d->d_fsdata;
284 if (sd) {
285 spin_lock(&configfs_dirent_lock);
286 list_del_init(&sd->s_sibling);
287 spin_unlock(&configfs_dirent_lock);
288 configfs_put(sd);
289 }
290 }
291 }
292 return error;
293}
294
295
296
297
298
299
300
301
302
303
304
305static int configfs_create_dir(struct config_item * item, struct dentry *dentry)
306{
307 struct dentry * parent;
308 int error = 0;
309
310 BUG_ON(!item);
311
312 if (item->ci_parent)
313 parent = item->ci_parent->ci_dentry;
314 else if (configfs_mount && configfs_mount->mnt_sb)
315 parent = configfs_mount->mnt_sb->s_root;
316 else
317 return -EFAULT;
318
319 error = create_dir(item,parent,dentry);
320 if (!error)
321 item->ci_dentry = dentry;
322 return error;
323}
324
325
326
327
328
329
330
331
332static void configfs_dir_set_ready(struct configfs_dirent *sd)
333{
334 struct configfs_dirent *child_sd;
335
336 sd->s_type &= ~CONFIGFS_USET_CREATING;
337 list_for_each_entry(child_sd, &sd->s_children, s_sibling)
338 if (child_sd->s_type & CONFIGFS_USET_CREATING)
339 configfs_dir_set_ready(child_sd);
340}
341
342
343
344
345
346
347
348
349
350
351
352int configfs_dirent_is_ready(struct configfs_dirent *sd)
353{
354 int ret;
355
356 spin_lock(&configfs_dirent_lock);
357 ret = !(sd->s_type & CONFIGFS_USET_CREATING);
358 spin_unlock(&configfs_dirent_lock);
359
360 return ret;
361}
362
363int configfs_create_link(struct configfs_symlink *sl,
364 struct dentry *parent,
365 struct dentry *dentry)
366{
367 int err = 0;
368 umode_t mode = S_IFLNK | S_IRWXUGO;
369
370 err = configfs_make_dirent(parent->d_fsdata, dentry, sl, mode,
371 CONFIGFS_ITEM_LINK);
372 if (!err) {
373 err = configfs_create(dentry, mode, init_symlink);
374 if (!err)
375 dentry->d_op = &configfs_dentry_ops;
376 else {
377 struct configfs_dirent *sd = dentry->d_fsdata;
378 if (sd) {
379 spin_lock(&configfs_dirent_lock);
380 list_del_init(&sd->s_sibling);
381 spin_unlock(&configfs_dirent_lock);
382 configfs_put(sd);
383 }
384 }
385 }
386 return err;
387}
388
389static void remove_dir(struct dentry * d)
390{
391 struct dentry * parent = dget(d->d_parent);
392 struct configfs_dirent * sd;
393
394 sd = d->d_fsdata;
395 spin_lock(&configfs_dirent_lock);
396 list_del_init(&sd->s_sibling);
397 spin_unlock(&configfs_dirent_lock);
398 configfs_put(sd);
399 if (d->d_inode)
400 simple_rmdir(parent->d_inode,d);
401
402 pr_debug(" o %s removing done (%d)\n",d->d_name.name,
403 atomic_read(&d->d_count));
404
405 dput(parent);
406}
407
408
409
410
411
412
413
414
415
416
417
418
419static void configfs_remove_dir(struct config_item * item)
420{
421 struct dentry * dentry = dget(item->ci_dentry);
422
423 if (!dentry)
424 return;
425
426 remove_dir(dentry);
427
428
429
430 dput(dentry);
431}
432
433
434
435
436
437static int configfs_attach_attr(struct configfs_dirent * sd, struct dentry * dentry)
438{
439 struct configfs_attribute * attr = sd->s_element;
440 int error;
441
442 dentry->d_fsdata = configfs_get(sd);
443 sd->s_dentry = dentry;
444 error = configfs_create(dentry, (attr->ca_mode & S_IALLUGO) | S_IFREG,
445 configfs_init_file);
446 if (error) {
447 configfs_put(sd);
448 return error;
449 }
450
451 dentry->d_op = &configfs_dentry_ops;
452 d_rehash(dentry);
453
454 return 0;
455}
456
457static struct dentry * configfs_lookup(struct inode *dir,
458 struct dentry *dentry,
459 struct nameidata *nd)
460{
461 struct configfs_dirent * parent_sd = dentry->d_parent->d_fsdata;
462 struct configfs_dirent * sd;
463 int found = 0;
464 int err;
465
466
467
468
469
470
471
472
473
474 err = -ENOENT;
475 if (!configfs_dirent_is_ready(parent_sd))
476 goto out;
477
478 list_for_each_entry(sd, &parent_sd->s_children, s_sibling) {
479 if (sd->s_type & CONFIGFS_NOT_PINNED) {
480 const unsigned char * name = configfs_get_name(sd);
481
482 if (strcmp(name, dentry->d_name.name))
483 continue;
484
485 found = 1;
486 err = configfs_attach_attr(sd, dentry);
487 break;
488 }
489 }
490
491 if (!found) {
492
493
494
495
496 return simple_lookup(dir, dentry, nd);
497 }
498
499out:
500 return ERR_PTR(err);
501}
502
503
504
505
506
507
508
509
510
511static int configfs_detach_prep(struct dentry *dentry, struct mutex **wait_mutex)
512{
513 struct configfs_dirent *parent_sd = dentry->d_fsdata;
514 struct configfs_dirent *sd;
515 int ret;
516
517
518 parent_sd->s_type |= CONFIGFS_USET_DROPPING;
519
520 ret = -EBUSY;
521 if (!list_empty(&parent_sd->s_links))
522 goto out;
523
524 ret = 0;
525 list_for_each_entry(sd, &parent_sd->s_children, s_sibling) {
526 if (!sd->s_element ||
527 (sd->s_type & CONFIGFS_NOT_PINNED))
528 continue;
529 if (sd->s_type & CONFIGFS_USET_DEFAULT) {
530
531 if (sd->s_type & CONFIGFS_USET_IN_MKDIR) {
532 if (wait_mutex)
533 *wait_mutex = &sd->s_dentry->d_inode->i_mutex;
534 return -EAGAIN;
535 }
536
537
538
539
540
541 ret = configfs_detach_prep(sd->s_dentry, wait_mutex);
542 if (!ret)
543 continue;
544 } else
545 ret = -ENOTEMPTY;
546
547 break;
548 }
549
550out:
551 return ret;
552}
553
554
555
556
557
558static void configfs_detach_rollback(struct dentry *dentry)
559{
560 struct configfs_dirent *parent_sd = dentry->d_fsdata;
561 struct configfs_dirent *sd;
562
563 parent_sd->s_type &= ~CONFIGFS_USET_DROPPING;
564
565 list_for_each_entry(sd, &parent_sd->s_children, s_sibling)
566 if (sd->s_type & CONFIGFS_USET_DEFAULT)
567 configfs_detach_rollback(sd->s_dentry);
568}
569
570static void detach_attrs(struct config_item * item)
571{
572 struct dentry * dentry = dget(item->ci_dentry);
573 struct configfs_dirent * parent_sd;
574 struct configfs_dirent * sd, * tmp;
575
576 if (!dentry)
577 return;
578
579 pr_debug("configfs %s: dropping attrs for dir\n",
580 dentry->d_name.name);
581
582 parent_sd = dentry->d_fsdata;
583 list_for_each_entry_safe(sd, tmp, &parent_sd->s_children, s_sibling) {
584 if (!sd->s_element || !(sd->s_type & CONFIGFS_NOT_PINNED))
585 continue;
586 spin_lock(&configfs_dirent_lock);
587 list_del_init(&sd->s_sibling);
588 spin_unlock(&configfs_dirent_lock);
589 configfs_drop_dentry(sd, dentry);
590 configfs_put(sd);
591 }
592
593
594
595
596 dput(dentry);
597}
598
599static int populate_attrs(struct config_item *item)
600{
601 struct config_item_type *t = item->ci_type;
602 struct configfs_attribute *attr;
603 int error = 0;
604 int i;
605
606 if (!t)
607 return -EINVAL;
608 if (t->ct_attrs) {
609 for (i = 0; (attr = t->ct_attrs[i]) != NULL; i++) {
610 if ((error = configfs_create_file(item, attr)))
611 break;
612 }
613 }
614
615 if (error)
616 detach_attrs(item);
617
618 return error;
619}
620
621static int configfs_attach_group(struct config_item *parent_item,
622 struct config_item *item,
623 struct dentry *dentry);
624static void configfs_detach_group(struct config_item *item);
625
626static void detach_groups(struct config_group *group)
627{
628 struct dentry * dentry = dget(group->cg_item.ci_dentry);
629 struct dentry *child;
630 struct configfs_dirent *parent_sd;
631 struct configfs_dirent *sd, *tmp;
632
633 if (!dentry)
634 return;
635
636 parent_sd = dentry->d_fsdata;
637 list_for_each_entry_safe(sd, tmp, &parent_sd->s_children, s_sibling) {
638 if (!sd->s_element ||
639 !(sd->s_type & CONFIGFS_USET_DEFAULT))
640 continue;
641
642 child = sd->s_dentry;
643
644 mutex_lock(&child->d_inode->i_mutex);
645
646 configfs_detach_group(sd->s_element);
647 child->d_inode->i_flags |= S_DEAD;
648
649 mutex_unlock(&child->d_inode->i_mutex);
650
651 d_delete(child);
652 dput(child);
653 }
654
655
656
657
658 dput(dentry);
659}
660
661
662
663
664
665
666
667
668
669static int create_default_group(struct config_group *parent_group,
670 struct config_group *group)
671{
672 int ret;
673 struct qstr name;
674 struct configfs_dirent *sd;
675
676 struct dentry *child, *parent = parent_group->cg_item.ci_dentry;
677
678 if (!group->cg_item.ci_name)
679 group->cg_item.ci_name = group->cg_item.ci_namebuf;
680 name.name = group->cg_item.ci_name;
681 name.len = strlen(name.name);
682 name.hash = full_name_hash(name.name, name.len);
683
684 ret = -ENOMEM;
685 child = d_alloc(parent, &name);
686 if (child) {
687 d_add(child, NULL);
688
689 ret = configfs_attach_group(&parent_group->cg_item,
690 &group->cg_item, child);
691 if (!ret) {
692 sd = child->d_fsdata;
693 sd->s_type |= CONFIGFS_USET_DEFAULT;
694 } else {
695 d_delete(child);
696 dput(child);
697 }
698 }
699
700 return ret;
701}
702
703static int populate_groups(struct config_group *group)
704{
705 struct config_group *new_group;
706 int ret = 0;
707 int i;
708
709 if (group->default_groups) {
710 for (i = 0; group->default_groups[i]; i++) {
711 new_group = group->default_groups[i];
712
713 ret = create_default_group(group, new_group);
714 if (ret) {
715 detach_groups(group);
716 break;
717 }
718 }
719 }
720
721 return ret;
722}
723
724
725
726
727
728
729static void unlink_obj(struct config_item *item)
730{
731 struct config_group *group;
732
733 group = item->ci_group;
734 if (group) {
735 list_del_init(&item->ci_entry);
736
737 item->ci_group = NULL;
738 item->ci_parent = NULL;
739
740
741 config_item_put(item);
742
743
744 config_group_put(group);
745 }
746}
747
748static void link_obj(struct config_item *parent_item, struct config_item *item)
749{
750
751
752
753
754 item->ci_parent = parent_item;
755
756
757
758
759
760 item->ci_group = config_group_get(to_config_group(parent_item));
761 list_add_tail(&item->ci_entry, &item->ci_group->cg_children);
762
763
764
765
766
767 config_item_get(item);
768}
769
770static void unlink_group(struct config_group *group)
771{
772 int i;
773 struct config_group *new_group;
774
775 if (group->default_groups) {
776 for (i = 0; group->default_groups[i]; i++) {
777 new_group = group->default_groups[i];
778 unlink_group(new_group);
779 }
780 }
781
782 group->cg_subsys = NULL;
783 unlink_obj(&group->cg_item);
784}
785
786static void link_group(struct config_group *parent_group, struct config_group *group)
787{
788 int i;
789 struct config_group *new_group;
790 struct configfs_subsystem *subsys = NULL;
791
792 link_obj(&parent_group->cg_item, &group->cg_item);
793
794 if (parent_group->cg_subsys)
795 subsys = parent_group->cg_subsys;
796 else if (configfs_is_root(&parent_group->cg_item))
797 subsys = to_configfs_subsystem(group);
798 else
799 BUG();
800 group->cg_subsys = subsys;
801
802 if (group->default_groups) {
803 for (i = 0; group->default_groups[i]; i++) {
804 new_group = group->default_groups[i];
805 link_group(group, new_group);
806 }
807 }
808}
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825static int configfs_attach_item(struct config_item *parent_item,
826 struct config_item *item,
827 struct dentry *dentry)
828{
829 int ret;
830
831 ret = configfs_create_dir(item, dentry);
832 if (!ret) {
833 ret = populate_attrs(item);
834 if (ret) {
835
836
837
838
839
840 mutex_lock(&dentry->d_inode->i_mutex);
841 configfs_remove_dir(item);
842 dentry->d_inode->i_flags |= S_DEAD;
843 mutex_unlock(&dentry->d_inode->i_mutex);
844 d_delete(dentry);
845 }
846 }
847
848 return ret;
849}
850
851
852static void configfs_detach_item(struct config_item *item)
853{
854 detach_attrs(item);
855 configfs_remove_dir(item);
856}
857
858static int configfs_attach_group(struct config_item *parent_item,
859 struct config_item *item,
860 struct dentry *dentry)
861{
862 int ret;
863 struct configfs_dirent *sd;
864
865 ret = configfs_attach_item(parent_item, item, dentry);
866 if (!ret) {
867 sd = dentry->d_fsdata;
868 sd->s_type |= CONFIGFS_USET_DIR;
869
870
871
872
873
874
875
876
877
878
879 mutex_lock_nested(&dentry->d_inode->i_mutex, I_MUTEX_CHILD);
880 configfs_adjust_dir_dirent_depth_before_populate(sd);
881 ret = populate_groups(to_config_group(item));
882 if (ret) {
883 configfs_detach_item(item);
884 dentry->d_inode->i_flags |= S_DEAD;
885 }
886 configfs_adjust_dir_dirent_depth_after_populate(sd);
887 mutex_unlock(&dentry->d_inode->i_mutex);
888 if (ret)
889 d_delete(dentry);
890 }
891
892 return ret;
893}
894
895
896static void configfs_detach_group(struct config_item *item)
897{
898 detach_groups(to_config_group(item));
899 configfs_detach_item(item);
900}
901
902
903
904
905
906
907
908
909
910
911static void client_disconnect_notify(struct config_item *parent_item,
912 struct config_item *item)
913{
914 struct config_item_type *type;
915
916 type = parent_item->ci_type;
917 BUG_ON(!type);
918
919 if (type->ct_group_ops && type->ct_group_ops->disconnect_notify)
920 type->ct_group_ops->disconnect_notify(to_config_group(parent_item),
921 item);
922}
923
924
925
926
927
928
929
930static void client_drop_item(struct config_item *parent_item,
931 struct config_item *item)
932{
933 struct config_item_type *type;
934
935 type = parent_item->ci_type;
936 BUG_ON(!type);
937
938
939
940
941
942 if (type->ct_group_ops && type->ct_group_ops->drop_item)
943 type->ct_group_ops->drop_item(to_config_group(parent_item),
944 item);
945 else
946 config_item_put(item);
947}
948
949#ifdef DEBUG
950static void configfs_dump_one(struct configfs_dirent *sd, int level)
951{
952 printk(KERN_INFO "%*s\"%s\":\n", level, " ", configfs_get_name(sd));
953
954#define type_print(_type) if (sd->s_type & _type) printk(KERN_INFO "%*s %s\n", level, " ", #_type);
955 type_print(CONFIGFS_ROOT);
956 type_print(CONFIGFS_DIR);
957 type_print(CONFIGFS_ITEM_ATTR);
958 type_print(CONFIGFS_ITEM_LINK);
959 type_print(CONFIGFS_USET_DIR);
960 type_print(CONFIGFS_USET_DEFAULT);
961 type_print(CONFIGFS_USET_DROPPING);
962#undef type_print
963}
964
965static int configfs_dump(struct configfs_dirent *sd, int level)
966{
967 struct configfs_dirent *child_sd;
968 int ret = 0;
969
970 configfs_dump_one(sd, level);
971
972 if (!(sd->s_type & (CONFIGFS_DIR|CONFIGFS_ROOT)))
973 return 0;
974
975 list_for_each_entry(child_sd, &sd->s_children, s_sibling) {
976 ret = configfs_dump(child_sd, level + 2);
977 if (ret)
978 break;
979 }
980
981 return ret;
982}
983#endif
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044static int configfs_depend_prep(struct dentry *origin,
1045 struct config_item *target)
1046{
1047 struct configfs_dirent *child_sd, *sd = origin->d_fsdata;
1048 int ret = 0;
1049
1050 BUG_ON(!origin || !sd);
1051
1052 if (sd->s_element == target)
1053 goto out;
1054
1055 list_for_each_entry(child_sd, &sd->s_children, s_sibling) {
1056 if ((child_sd->s_type & CONFIGFS_DIR) &&
1057 !(child_sd->s_type & CONFIGFS_USET_DROPPING) &&
1058 !(child_sd->s_type & CONFIGFS_USET_CREATING)) {
1059 ret = configfs_depend_prep(child_sd->s_dentry,
1060 target);
1061 if (!ret)
1062 goto out;
1063 }
1064 }
1065
1066
1067 ret = -ENOENT;
1068
1069out:
1070 return ret;
1071}
1072
1073int configfs_depend_item(struct configfs_subsystem *subsys,
1074 struct config_item *target)
1075{
1076 int ret;
1077 struct configfs_dirent *p, *root_sd, *subsys_sd = NULL;
1078 struct config_item *s_item = &subsys->su_group.cg_item;
1079
1080
1081
1082
1083
1084 ret = configfs_pin_fs();
1085 if (ret)
1086 return ret;
1087
1088
1089
1090
1091
1092
1093 mutex_lock(&configfs_sb->s_root->d_inode->i_mutex);
1094
1095 root_sd = configfs_sb->s_root->d_fsdata;
1096
1097 list_for_each_entry(p, &root_sd->s_children, s_sibling) {
1098 if (p->s_type & CONFIGFS_DIR) {
1099 if (p->s_element == s_item) {
1100 subsys_sd = p;
1101 break;
1102 }
1103 }
1104 }
1105
1106 if (!subsys_sd) {
1107 ret = -ENOENT;
1108 goto out_unlock_fs;
1109 }
1110
1111
1112
1113 spin_lock(&configfs_dirent_lock);
1114
1115 ret = configfs_depend_prep(subsys_sd->s_dentry, target);
1116 if (ret)
1117 goto out_unlock_dirent_lock;
1118
1119
1120
1121
1122
1123 p = target->ci_dentry->d_fsdata;
1124 p->s_dependent_count += 1;
1125
1126out_unlock_dirent_lock:
1127 spin_unlock(&configfs_dirent_lock);
1128out_unlock_fs:
1129 mutex_unlock(&configfs_sb->s_root->d_inode->i_mutex);
1130
1131
1132
1133
1134
1135 configfs_release_fs();
1136
1137 return ret;
1138}
1139EXPORT_SYMBOL(configfs_depend_item);
1140
1141
1142
1143
1144
1145
1146void configfs_undepend_item(struct configfs_subsystem *subsys,
1147 struct config_item *target)
1148{
1149 struct configfs_dirent *sd;
1150
1151
1152
1153
1154
1155 spin_lock(&configfs_dirent_lock);
1156
1157 sd = target->ci_dentry->d_fsdata;
1158 BUG_ON(sd->s_dependent_count < 1);
1159
1160 sd->s_dependent_count -= 1;
1161
1162
1163
1164
1165
1166 spin_unlock(&configfs_dirent_lock);
1167}
1168EXPORT_SYMBOL(configfs_undepend_item);
1169
1170static int configfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
1171{
1172 int ret = 0;
1173 int module_got = 0;
1174 struct config_group *group = NULL;
1175 struct config_item *item = NULL;
1176 struct config_item *parent_item;
1177 struct configfs_subsystem *subsys;
1178 struct configfs_dirent *sd;
1179 struct config_item_type *type;
1180 struct module *subsys_owner = NULL, *new_item_owner = NULL;
1181 char *name;
1182
1183 if (dentry->d_parent == configfs_sb->s_root) {
1184 ret = -EPERM;
1185 goto out;
1186 }
1187
1188 sd = dentry->d_parent->d_fsdata;
1189
1190
1191
1192
1193
1194 if (!configfs_dirent_is_ready(sd)) {
1195 ret = -ENOENT;
1196 goto out;
1197 }
1198
1199 if (!(sd->s_type & CONFIGFS_USET_DIR)) {
1200 ret = -EPERM;
1201 goto out;
1202 }
1203
1204
1205 parent_item = configfs_get_config_item(dentry->d_parent);
1206 type = parent_item->ci_type;
1207 subsys = to_config_group(parent_item)->cg_subsys;
1208 BUG_ON(!subsys);
1209
1210 if (!type || !type->ct_group_ops ||
1211 (!type->ct_group_ops->make_group &&
1212 !type->ct_group_ops->make_item)) {
1213 ret = -EPERM;
1214 goto out_put;
1215 }
1216
1217
1218
1219
1220
1221
1222 if (!subsys->su_group.cg_item.ci_type) {
1223 ret = -EINVAL;
1224 goto out_put;
1225 }
1226 subsys_owner = subsys->su_group.cg_item.ci_type->ct_owner;
1227 if (!try_module_get(subsys_owner)) {
1228 ret = -EINVAL;
1229 goto out_put;
1230 }
1231
1232 name = kmalloc(dentry->d_name.len + 1, GFP_KERNEL);
1233 if (!name) {
1234 ret = -ENOMEM;
1235 goto out_subsys_put;
1236 }
1237
1238 snprintf(name, dentry->d_name.len + 1, "%s", dentry->d_name.name);
1239
1240 mutex_lock(&subsys->su_mutex);
1241 if (type->ct_group_ops->make_group) {
1242 group = type->ct_group_ops->make_group(to_config_group(parent_item), name);
1243 if (!group)
1244 group = ERR_PTR(-ENOMEM);
1245 if (!IS_ERR(group)) {
1246 link_group(to_config_group(parent_item), group);
1247 item = &group->cg_item;
1248 } else
1249 ret = PTR_ERR(group);
1250 } else {
1251 item = type->ct_group_ops->make_item(to_config_group(parent_item), name);
1252 if (!item)
1253 item = ERR_PTR(-ENOMEM);
1254 if (!IS_ERR(item))
1255 link_obj(parent_item, item);
1256 else
1257 ret = PTR_ERR(item);
1258 }
1259 mutex_unlock(&subsys->su_mutex);
1260
1261 kfree(name);
1262 if (ret) {
1263
1264
1265
1266
1267 goto out_subsys_put;
1268 }
1269
1270
1271
1272
1273
1274
1275 type = item->ci_type;
1276 if (!type) {
1277 ret = -EINVAL;
1278 goto out_unlink;
1279 }
1280
1281 new_item_owner = type->ct_owner;
1282 if (!try_module_get(new_item_owner)) {
1283 ret = -EINVAL;
1284 goto out_unlink;
1285 }
1286
1287
1288
1289
1290
1291
1292 module_got = 1;
1293
1294
1295
1296
1297
1298
1299
1300 spin_lock(&configfs_dirent_lock);
1301
1302 sd->s_type |= CONFIGFS_USET_IN_MKDIR;
1303 spin_unlock(&configfs_dirent_lock);
1304
1305 if (group)
1306 ret = configfs_attach_group(parent_item, item, dentry);
1307 else
1308 ret = configfs_attach_item(parent_item, item, dentry);
1309
1310 spin_lock(&configfs_dirent_lock);
1311 sd->s_type &= ~CONFIGFS_USET_IN_MKDIR;
1312 if (!ret)
1313 configfs_dir_set_ready(dentry->d_fsdata);
1314 spin_unlock(&configfs_dirent_lock);
1315
1316out_unlink:
1317 if (ret) {
1318
1319 mutex_lock(&subsys->su_mutex);
1320
1321 client_disconnect_notify(parent_item, item);
1322 if (group)
1323 unlink_group(group);
1324 else
1325 unlink_obj(item);
1326 client_drop_item(parent_item, item);
1327
1328 mutex_unlock(&subsys->su_mutex);
1329
1330 if (module_got)
1331 module_put(new_item_owner);
1332 }
1333
1334out_subsys_put:
1335 if (ret)
1336 module_put(subsys_owner);
1337
1338out_put:
1339
1340
1341
1342
1343
1344 config_item_put(parent_item);
1345
1346out:
1347 return ret;
1348}
1349
1350static int configfs_rmdir(struct inode *dir, struct dentry *dentry)
1351{
1352 struct config_item *parent_item;
1353 struct config_item *item;
1354 struct configfs_subsystem *subsys;
1355 struct configfs_dirent *sd;
1356 struct module *subsys_owner = NULL, *dead_item_owner = NULL;
1357 int ret;
1358
1359 if (dentry->d_parent == configfs_sb->s_root)
1360 return -EPERM;
1361
1362 sd = dentry->d_fsdata;
1363 if (sd->s_type & CONFIGFS_USET_DEFAULT)
1364 return -EPERM;
1365
1366
1367 parent_item = configfs_get_config_item(dentry->d_parent);
1368 subsys = to_config_group(parent_item)->cg_subsys;
1369 BUG_ON(!subsys);
1370
1371 if (!parent_item->ci_type) {
1372 config_item_put(parent_item);
1373 return -EINVAL;
1374 }
1375
1376
1377 BUG_ON(!subsys->su_group.cg_item.ci_type);
1378 subsys_owner = subsys->su_group.cg_item.ci_type->ct_owner;
1379
1380
1381
1382
1383
1384 do {
1385 struct mutex *wait_mutex;
1386
1387 mutex_lock(&configfs_symlink_mutex);
1388 spin_lock(&configfs_dirent_lock);
1389
1390
1391
1392
1393
1394 ret = sd->s_dependent_count ? -EBUSY : 0;
1395 if (!ret) {
1396 ret = configfs_detach_prep(dentry, &wait_mutex);
1397 if (ret)
1398 configfs_detach_rollback(dentry);
1399 }
1400 spin_unlock(&configfs_dirent_lock);
1401 mutex_unlock(&configfs_symlink_mutex);
1402
1403 if (ret) {
1404 if (ret != -EAGAIN) {
1405 config_item_put(parent_item);
1406 return ret;
1407 }
1408
1409
1410 mutex_lock(wait_mutex);
1411 mutex_unlock(wait_mutex);
1412 }
1413 } while (ret == -EAGAIN);
1414
1415
1416 item = configfs_get_config_item(dentry);
1417
1418
1419 config_item_put(parent_item);
1420
1421 if (item->ci_type)
1422 dead_item_owner = item->ci_type->ct_owner;
1423
1424 if (sd->s_type & CONFIGFS_USET_DIR) {
1425 configfs_detach_group(item);
1426
1427 mutex_lock(&subsys->su_mutex);
1428 client_disconnect_notify(parent_item, item);
1429 unlink_group(to_config_group(item));
1430 } else {
1431 configfs_detach_item(item);
1432
1433 mutex_lock(&subsys->su_mutex);
1434 client_disconnect_notify(parent_item, item);
1435 unlink_obj(item);
1436 }
1437
1438 client_drop_item(parent_item, item);
1439 mutex_unlock(&subsys->su_mutex);
1440
1441
1442 config_item_put(item);
1443
1444 module_put(dead_item_owner);
1445 module_put(subsys_owner);
1446
1447 return 0;
1448}
1449
1450const struct inode_operations configfs_dir_inode_operations = {
1451 .mkdir = configfs_mkdir,
1452 .rmdir = configfs_rmdir,
1453 .symlink = configfs_symlink,
1454 .unlink = configfs_unlink,
1455 .lookup = configfs_lookup,
1456 .setattr = configfs_setattr,
1457};
1458
1459#if 0
1460int configfs_rename_dir(struct config_item * item, const char *new_name)
1461{
1462 int error = 0;
1463 struct dentry * new_dentry, * parent;
1464
1465 if (!strcmp(config_item_name(item), new_name))
1466 return -EINVAL;
1467
1468 if (!item->parent)
1469 return -EINVAL;
1470
1471 down_write(&configfs_rename_sem);
1472 parent = item->parent->dentry;
1473
1474 mutex_lock(&parent->d_inode->i_mutex);
1475
1476 new_dentry = lookup_one_len(new_name, parent, strlen(new_name));
1477 if (!IS_ERR(new_dentry)) {
1478 if (!new_dentry->d_inode) {
1479 error = config_item_set_name(item, "%s", new_name);
1480 if (!error) {
1481 d_add(new_dentry, NULL);
1482 d_move(item->dentry, new_dentry);
1483 }
1484 else
1485 d_delete(new_dentry);
1486 } else
1487 error = -EEXIST;
1488 dput(new_dentry);
1489 }
1490 mutex_unlock(&parent->d_inode->i_mutex);
1491 up_write(&configfs_rename_sem);
1492
1493 return error;
1494}
1495#endif
1496
1497static int configfs_dir_open(struct inode *inode, struct file *file)
1498{
1499 struct dentry * dentry = file->f_path.dentry;
1500 struct configfs_dirent * parent_sd = dentry->d_fsdata;
1501 int err;
1502
1503 mutex_lock(&dentry->d_inode->i_mutex);
1504
1505
1506
1507
1508 err = -ENOENT;
1509 if (configfs_dirent_is_ready(parent_sd)) {
1510 file->private_data = configfs_new_dirent(parent_sd, NULL, 0);
1511 if (IS_ERR(file->private_data))
1512 err = PTR_ERR(file->private_data);
1513 else
1514 err = 0;
1515 }
1516 mutex_unlock(&dentry->d_inode->i_mutex);
1517
1518 return err;
1519}
1520
1521static int configfs_dir_close(struct inode *inode, struct file *file)
1522{
1523 struct dentry * dentry = file->f_path.dentry;
1524 struct configfs_dirent * cursor = file->private_data;
1525
1526 mutex_lock(&dentry->d_inode->i_mutex);
1527 spin_lock(&configfs_dirent_lock);
1528 list_del_init(&cursor->s_sibling);
1529 spin_unlock(&configfs_dirent_lock);
1530 mutex_unlock(&dentry->d_inode->i_mutex);
1531
1532 release_configfs_dirent(cursor);
1533
1534 return 0;
1535}
1536
1537
1538static inline unsigned char dt_type(struct configfs_dirent *sd)
1539{
1540 return (sd->s_mode >> 12) & 15;
1541}
1542
1543static int configfs_readdir(struct file * filp, void * dirent, filldir_t filldir)
1544{
1545 struct dentry *dentry = filp->f_path.dentry;
1546 struct configfs_dirent * parent_sd = dentry->d_fsdata;
1547 struct configfs_dirent *cursor = filp->private_data;
1548 struct list_head *p, *q = &cursor->s_sibling;
1549 ino_t ino;
1550 int i = filp->f_pos;
1551
1552 switch (i) {
1553 case 0:
1554 ino = dentry->d_inode->i_ino;
1555 if (filldir(dirent, ".", 1, i, ino, DT_DIR) < 0)
1556 break;
1557 filp->f_pos++;
1558 i++;
1559
1560 case 1:
1561 ino = parent_ino(dentry);
1562 if (filldir(dirent, "..", 2, i, ino, DT_DIR) < 0)
1563 break;
1564 filp->f_pos++;
1565 i++;
1566
1567 default:
1568 if (filp->f_pos == 2) {
1569 spin_lock(&configfs_dirent_lock);
1570 list_move(q, &parent_sd->s_children);
1571 spin_unlock(&configfs_dirent_lock);
1572 }
1573 for (p=q->next; p!= &parent_sd->s_children; p=p->next) {
1574 struct configfs_dirent *next;
1575 const char * name;
1576 int len;
1577
1578 next = list_entry(p, struct configfs_dirent,
1579 s_sibling);
1580 if (!next->s_element)
1581 continue;
1582
1583 name = configfs_get_name(next);
1584 len = strlen(name);
1585 if (next->s_dentry)
1586 ino = next->s_dentry->d_inode->i_ino;
1587 else
1588 ino = iunique(configfs_sb, 2);
1589
1590 if (filldir(dirent, name, len, filp->f_pos, ino,
1591 dt_type(next)) < 0)
1592 return 0;
1593
1594 spin_lock(&configfs_dirent_lock);
1595 list_move(q, p);
1596 spin_unlock(&configfs_dirent_lock);
1597 p = q;
1598 filp->f_pos++;
1599 }
1600 }
1601 return 0;
1602}
1603
1604static loff_t configfs_dir_lseek(struct file * file, loff_t offset, int origin)
1605{
1606 struct dentry * dentry = file->f_path.dentry;
1607
1608 mutex_lock(&dentry->d_inode->i_mutex);
1609 switch (origin) {
1610 case 1:
1611 offset += file->f_pos;
1612 case 0:
1613 if (offset >= 0)
1614 break;
1615 default:
1616 mutex_unlock(&file->f_path.dentry->d_inode->i_mutex);
1617 return -EINVAL;
1618 }
1619 if (offset != file->f_pos) {
1620 file->f_pos = offset;
1621 if (file->f_pos >= 2) {
1622 struct configfs_dirent *sd = dentry->d_fsdata;
1623 struct configfs_dirent *cursor = file->private_data;
1624 struct list_head *p;
1625 loff_t n = file->f_pos - 2;
1626
1627 spin_lock(&configfs_dirent_lock);
1628 list_del(&cursor->s_sibling);
1629 p = sd->s_children.next;
1630 while (n && p != &sd->s_children) {
1631 struct configfs_dirent *next;
1632 next = list_entry(p, struct configfs_dirent,
1633 s_sibling);
1634 if (next->s_element)
1635 n--;
1636 p = p->next;
1637 }
1638 list_add_tail(&cursor->s_sibling, p);
1639 spin_unlock(&configfs_dirent_lock);
1640 }
1641 }
1642 mutex_unlock(&dentry->d_inode->i_mutex);
1643 return offset;
1644}
1645
1646const struct file_operations configfs_dir_operations = {
1647 .open = configfs_dir_open,
1648 .release = configfs_dir_close,
1649 .llseek = configfs_dir_lseek,
1650 .read = generic_read_dir,
1651 .readdir = configfs_readdir,
1652};
1653
1654int configfs_register_subsystem(struct configfs_subsystem *subsys)
1655{
1656 int err;
1657 struct config_group *group = &subsys->su_group;
1658 struct qstr name;
1659 struct dentry *dentry;
1660 struct configfs_dirent *sd;
1661
1662 err = configfs_pin_fs();
1663 if (err)
1664 return err;
1665
1666 if (!group->cg_item.ci_name)
1667 group->cg_item.ci_name = group->cg_item.ci_namebuf;
1668
1669 sd = configfs_sb->s_root->d_fsdata;
1670 link_group(to_config_group(sd->s_element), group);
1671
1672 mutex_lock_nested(&configfs_sb->s_root->d_inode->i_mutex,
1673 I_MUTEX_PARENT);
1674
1675 name.name = group->cg_item.ci_name;
1676 name.len = strlen(name.name);
1677 name.hash = full_name_hash(name.name, name.len);
1678
1679 err = -ENOMEM;
1680 dentry = d_alloc(configfs_sb->s_root, &name);
1681 if (dentry) {
1682 d_add(dentry, NULL);
1683
1684 err = configfs_attach_group(sd->s_element, &group->cg_item,
1685 dentry);
1686 if (err) {
1687 d_delete(dentry);
1688 dput(dentry);
1689 } else {
1690 spin_lock(&configfs_dirent_lock);
1691 configfs_dir_set_ready(dentry->d_fsdata);
1692 spin_unlock(&configfs_dirent_lock);
1693 }
1694 }
1695
1696 mutex_unlock(&configfs_sb->s_root->d_inode->i_mutex);
1697
1698 if (err) {
1699 unlink_group(group);
1700 configfs_release_fs();
1701 }
1702
1703 return err;
1704}
1705
1706void configfs_unregister_subsystem(struct configfs_subsystem *subsys)
1707{
1708 struct config_group *group = &subsys->su_group;
1709 struct dentry *dentry = group->cg_item.ci_dentry;
1710
1711 if (dentry->d_parent != configfs_sb->s_root) {
1712 printk(KERN_ERR "configfs: Tried to unregister non-subsystem!\n");
1713 return;
1714 }
1715
1716 mutex_lock_nested(&configfs_sb->s_root->d_inode->i_mutex,
1717 I_MUTEX_PARENT);
1718 mutex_lock_nested(&dentry->d_inode->i_mutex, I_MUTEX_CHILD);
1719 mutex_lock(&configfs_symlink_mutex);
1720 spin_lock(&configfs_dirent_lock);
1721 if (configfs_detach_prep(dentry, NULL)) {
1722 printk(KERN_ERR "configfs: Tried to unregister non-empty subsystem!\n");
1723 }
1724 spin_unlock(&configfs_dirent_lock);
1725 mutex_unlock(&configfs_symlink_mutex);
1726 configfs_detach_group(&group->cg_item);
1727 dentry->d_inode->i_flags |= S_DEAD;
1728 mutex_unlock(&dentry->d_inode->i_mutex);
1729
1730 d_delete(dentry);
1731
1732 mutex_unlock(&configfs_sb->s_root->d_inode->i_mutex);
1733
1734 dput(dentry);
1735
1736 unlink_group(group);
1737 configfs_release_fs();
1738}
1739
1740EXPORT_SYMBOL(configfs_register_subsystem);
1741EXPORT_SYMBOL(configfs_unregister_subsystem);
1742