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