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