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