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