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
420static struct dentry * configfs_lookup(struct inode *dir,
421 struct dentry *dentry,
422 unsigned int flags)
423{
424 struct configfs_dirent * parent_sd = dentry->d_parent->d_fsdata;
425 struct configfs_dirent * sd;
426 struct inode *inode = NULL;
427
428 if (dentry->d_name.len > NAME_MAX)
429 return ERR_PTR(-ENAMETOOLONG);
430
431
432
433
434
435
436
437
438
439 if (!configfs_dirent_is_ready(parent_sd))
440 return ERR_PTR(-ENOENT);
441
442 spin_lock(&configfs_dirent_lock);
443 list_for_each_entry(sd, &parent_sd->s_children, s_sibling) {
444 if ((sd->s_type & CONFIGFS_NOT_PINNED) &&
445 !strcmp(configfs_get_name(sd), dentry->d_name.name)) {
446 struct configfs_attribute *attr = sd->s_element;
447 umode_t mode = (attr->ca_mode & S_IALLUGO) | S_IFREG;
448
449 dentry->d_fsdata = configfs_get(sd);
450 sd->s_dentry = dentry;
451 spin_unlock(&configfs_dirent_lock);
452
453 inode = configfs_create(dentry, mode);
454 if (IS_ERR(inode)) {
455 configfs_put(sd);
456 return ERR_CAST(inode);
457 }
458 if (sd->s_type & CONFIGFS_ITEM_BIN_ATTR) {
459 inode->i_size = 0;
460 inode->i_fop = &configfs_bin_file_operations;
461 } else {
462 inode->i_size = PAGE_SIZE;
463 inode->i_fop = &configfs_file_operations;
464 }
465 goto done;
466 }
467 }
468 spin_unlock(&configfs_dirent_lock);
469done:
470 d_add(dentry, inode);
471 return NULL;
472}
473
474
475
476
477
478
479
480
481
482static int configfs_detach_prep(struct dentry *dentry, struct dentry **wait)
483{
484 struct configfs_dirent *parent_sd = dentry->d_fsdata;
485 struct configfs_dirent *sd;
486 int ret;
487
488
489 parent_sd->s_type |= CONFIGFS_USET_DROPPING;
490
491 ret = -EBUSY;
492 if (parent_sd->s_links)
493 goto out;
494
495 ret = 0;
496 list_for_each_entry(sd, &parent_sd->s_children, s_sibling) {
497 if (!sd->s_element ||
498 (sd->s_type & CONFIGFS_NOT_PINNED))
499 continue;
500 if (sd->s_type & CONFIGFS_USET_DEFAULT) {
501
502 if (sd->s_type & CONFIGFS_USET_IN_MKDIR) {
503 if (wait)
504 *wait= dget(sd->s_dentry);
505 return -EAGAIN;
506 }
507
508
509
510
511
512 ret = configfs_detach_prep(sd->s_dentry, wait);
513 if (!ret)
514 continue;
515 } else
516 ret = -ENOTEMPTY;
517
518 break;
519 }
520
521out:
522 return ret;
523}
524
525
526
527
528
529static void configfs_detach_rollback(struct dentry *dentry)
530{
531 struct configfs_dirent *parent_sd = dentry->d_fsdata;
532 struct configfs_dirent *sd;
533
534 parent_sd->s_type &= ~CONFIGFS_USET_DROPPING;
535
536 list_for_each_entry(sd, &parent_sd->s_children, s_sibling)
537 if (sd->s_type & CONFIGFS_USET_DEFAULT)
538 configfs_detach_rollback(sd->s_dentry);
539}
540
541static void detach_attrs(struct config_item * item)
542{
543 struct dentry * dentry = dget(item->ci_dentry);
544 struct configfs_dirent * parent_sd;
545 struct configfs_dirent * sd, * tmp;
546
547 if (!dentry)
548 return;
549
550 pr_debug("configfs %s: dropping attrs for dir\n",
551 dentry->d_name.name);
552
553 parent_sd = dentry->d_fsdata;
554 list_for_each_entry_safe(sd, tmp, &parent_sd->s_children, s_sibling) {
555 if (!sd->s_element || !(sd->s_type & CONFIGFS_NOT_PINNED))
556 continue;
557 spin_lock(&configfs_dirent_lock);
558 list_del_init(&sd->s_sibling);
559 spin_unlock(&configfs_dirent_lock);
560 configfs_drop_dentry(sd, dentry);
561 configfs_put(sd);
562 }
563
564
565
566
567 dput(dentry);
568}
569
570static int populate_attrs(struct config_item *item)
571{
572 const struct config_item_type *t = item->ci_type;
573 struct configfs_attribute *attr;
574 struct configfs_bin_attribute *bin_attr;
575 int error = 0;
576 int i;
577
578 if (!t)
579 return -EINVAL;
580 if (t->ct_attrs) {
581 for (i = 0; (attr = t->ct_attrs[i]) != NULL; i++) {
582 if ((error = configfs_create_file(item, attr)))
583 break;
584 }
585 }
586 if (t->ct_bin_attrs) {
587 for (i = 0; (bin_attr = t->ct_bin_attrs[i]) != NULL; i++) {
588 error = configfs_create_bin_file(item, bin_attr);
589 if (error)
590 break;
591 }
592 }
593
594 if (error)
595 detach_attrs(item);
596
597 return error;
598}
599
600static int configfs_attach_group(struct config_item *parent_item,
601 struct config_item *item,
602 struct dentry *dentry,
603 struct configfs_fragment *frag);
604static void configfs_detach_group(struct config_item *item);
605
606static void detach_groups(struct config_group *group)
607{
608 struct dentry * dentry = dget(group->cg_item.ci_dentry);
609 struct dentry *child;
610 struct configfs_dirent *parent_sd;
611 struct configfs_dirent *sd, *tmp;
612
613 if (!dentry)
614 return;
615
616 parent_sd = dentry->d_fsdata;
617 list_for_each_entry_safe(sd, tmp, &parent_sd->s_children, s_sibling) {
618 if (!sd->s_element ||
619 !(sd->s_type & CONFIGFS_USET_DEFAULT))
620 continue;
621
622 child = sd->s_dentry;
623
624 inode_lock(d_inode(child));
625
626 configfs_detach_group(sd->s_element);
627 d_inode(child)->i_flags |= S_DEAD;
628 dont_mount(child);
629
630 inode_unlock(d_inode(child));
631
632 d_delete(child);
633 dput(child);
634 }
635
636
637
638
639 dput(dentry);
640}
641
642
643
644
645
646
647
648
649
650static int create_default_group(struct config_group *parent_group,
651 struct config_group *group,
652 struct configfs_fragment *frag)
653{
654 int ret;
655 struct configfs_dirent *sd;
656
657 struct dentry *child, *parent = parent_group->cg_item.ci_dentry;
658
659 if (!group->cg_item.ci_name)
660 group->cg_item.ci_name = group->cg_item.ci_namebuf;
661
662 ret = -ENOMEM;
663 child = d_alloc_name(parent, group->cg_item.ci_name);
664 if (child) {
665 d_add(child, NULL);
666
667 ret = configfs_attach_group(&parent_group->cg_item,
668 &group->cg_item, child, frag);
669 if (!ret) {
670 sd = child->d_fsdata;
671 sd->s_type |= CONFIGFS_USET_DEFAULT;
672 } else {
673 BUG_ON(d_inode(child));
674 d_drop(child);
675 dput(child);
676 }
677 }
678
679 return ret;
680}
681
682static int populate_groups(struct config_group *group,
683 struct configfs_fragment *frag)
684{
685 struct config_group *new_group;
686 int ret = 0;
687
688 list_for_each_entry(new_group, &group->default_groups, group_entry) {
689 ret = create_default_group(group, new_group, frag);
690 if (ret) {
691 detach_groups(group);
692 break;
693 }
694 }
695
696 return ret;
697}
698
699void configfs_remove_default_groups(struct config_group *group)
700{
701 struct config_group *g, *n;
702
703 list_for_each_entry_safe(g, n, &group->default_groups, group_entry) {
704 list_del(&g->group_entry);
705 config_item_put(&g->cg_item);
706 }
707}
708EXPORT_SYMBOL(configfs_remove_default_groups);
709
710
711
712
713
714
715static void unlink_obj(struct config_item *item)
716{
717 struct config_group *group;
718
719 group = item->ci_group;
720 if (group) {
721 list_del_init(&item->ci_entry);
722
723 item->ci_group = NULL;
724 item->ci_parent = NULL;
725
726
727 config_item_put(item);
728
729
730 config_group_put(group);
731 }
732}
733
734static void link_obj(struct config_item *parent_item, struct config_item *item)
735{
736
737
738
739
740 item->ci_parent = parent_item;
741
742
743
744
745
746 item->ci_group = config_group_get(to_config_group(parent_item));
747 list_add_tail(&item->ci_entry, &item->ci_group->cg_children);
748
749
750
751
752
753 config_item_get(item);
754}
755
756static void unlink_group(struct config_group *group)
757{
758 struct config_group *new_group;
759
760 list_for_each_entry(new_group, &group->default_groups, group_entry)
761 unlink_group(new_group);
762
763 group->cg_subsys = NULL;
764 unlink_obj(&group->cg_item);
765}
766
767static void link_group(struct config_group *parent_group, struct config_group *group)
768{
769 struct config_group *new_group;
770 struct configfs_subsystem *subsys = NULL;
771
772 link_obj(&parent_group->cg_item, &group->cg_item);
773
774 if (parent_group->cg_subsys)
775 subsys = parent_group->cg_subsys;
776 else if (configfs_is_root(&parent_group->cg_item))
777 subsys = to_configfs_subsystem(group);
778 else
779 BUG();
780 group->cg_subsys = subsys;
781
782 list_for_each_entry(new_group, &group->default_groups, group_entry)
783 link_group(group, new_group);
784}
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801static int configfs_attach_item(struct config_item *parent_item,
802 struct config_item *item,
803 struct dentry *dentry,
804 struct configfs_fragment *frag)
805{
806 int ret;
807
808 ret = configfs_create_dir(item, dentry, frag);
809 if (!ret) {
810 ret = populate_attrs(item);
811 if (ret) {
812
813
814
815
816
817 inode_lock(d_inode(dentry));
818 configfs_remove_dir(item);
819 d_inode(dentry)->i_flags |= S_DEAD;
820 dont_mount(dentry);
821 inode_unlock(d_inode(dentry));
822 d_delete(dentry);
823 }
824 }
825
826 return ret;
827}
828
829
830static void configfs_detach_item(struct config_item *item)
831{
832 detach_attrs(item);
833 configfs_remove_dir(item);
834}
835
836static int configfs_attach_group(struct config_item *parent_item,
837 struct config_item *item,
838 struct dentry *dentry,
839 struct configfs_fragment *frag)
840{
841 int ret;
842 struct configfs_dirent *sd;
843
844 ret = configfs_attach_item(parent_item, item, dentry, frag);
845 if (!ret) {
846 sd = dentry->d_fsdata;
847 sd->s_type |= CONFIGFS_USET_DIR;
848
849
850
851
852
853
854
855
856
857
858 inode_lock_nested(d_inode(dentry), I_MUTEX_CHILD);
859 configfs_adjust_dir_dirent_depth_before_populate(sd);
860 ret = populate_groups(to_config_group(item), frag);
861 if (ret) {
862 configfs_detach_item(item);
863 d_inode(dentry)->i_flags |= S_DEAD;
864 dont_mount(dentry);
865 }
866 configfs_adjust_dir_dirent_depth_after_populate(sd);
867 inode_unlock(d_inode(dentry));
868 if (ret)
869 d_delete(dentry);
870 }
871
872 return ret;
873}
874
875
876static void configfs_detach_group(struct config_item *item)
877{
878 detach_groups(to_config_group(item));
879 configfs_detach_item(item);
880}
881
882
883
884
885
886
887
888
889
890
891static void client_disconnect_notify(struct config_item *parent_item,
892 struct config_item *item)
893{
894 const struct config_item_type *type;
895
896 type = parent_item->ci_type;
897 BUG_ON(!type);
898
899 if (type->ct_group_ops && type->ct_group_ops->disconnect_notify)
900 type->ct_group_ops->disconnect_notify(to_config_group(parent_item),
901 item);
902}
903
904
905
906
907
908
909
910static void client_drop_item(struct config_item *parent_item,
911 struct config_item *item)
912{
913 const struct config_item_type *type;
914
915 type = parent_item->ci_type;
916 BUG_ON(!type);
917
918
919
920
921
922 if (type->ct_group_ops && type->ct_group_ops->drop_item)
923 type->ct_group_ops->drop_item(to_config_group(parent_item),
924 item);
925 else
926 config_item_put(item);
927}
928
929#ifdef DEBUG
930static void configfs_dump_one(struct configfs_dirent *sd, int level)
931{
932 pr_info("%*s\"%s\":\n", level, " ", configfs_get_name(sd));
933
934#define type_print(_type) if (sd->s_type & _type) pr_info("%*s %s\n", level, " ", #_type);
935 type_print(CONFIGFS_ROOT);
936 type_print(CONFIGFS_DIR);
937 type_print(CONFIGFS_ITEM_ATTR);
938 type_print(CONFIGFS_ITEM_LINK);
939 type_print(CONFIGFS_USET_DIR);
940 type_print(CONFIGFS_USET_DEFAULT);
941 type_print(CONFIGFS_USET_DROPPING);
942#undef type_print
943}
944
945static int configfs_dump(struct configfs_dirent *sd, int level)
946{
947 struct configfs_dirent *child_sd;
948 int ret = 0;
949
950 configfs_dump_one(sd, level);
951
952 if (!(sd->s_type & (CONFIGFS_DIR|CONFIGFS_ROOT)))
953 return 0;
954
955 list_for_each_entry(child_sd, &sd->s_children, s_sibling) {
956 ret = configfs_dump(child_sd, level + 2);
957 if (ret)
958 break;
959 }
960
961 return ret;
962}
963#endif
964
965
966
967
968
969
970
971
972
973
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
1024static int configfs_depend_prep(struct dentry *origin,
1025 struct config_item *target)
1026{
1027 struct configfs_dirent *child_sd, *sd;
1028 int ret = 0;
1029
1030 BUG_ON(!origin || !origin->d_fsdata);
1031 sd = origin->d_fsdata;
1032
1033 if (sd->s_element == target)
1034 goto out;
1035
1036 list_for_each_entry(child_sd, &sd->s_children, s_sibling) {
1037 if ((child_sd->s_type & CONFIGFS_DIR) &&
1038 !(child_sd->s_type & CONFIGFS_USET_DROPPING) &&
1039 !(child_sd->s_type & CONFIGFS_USET_CREATING)) {
1040 ret = configfs_depend_prep(child_sd->s_dentry,
1041 target);
1042 if (!ret)
1043 goto out;
1044 }
1045 }
1046
1047
1048 ret = -ENOENT;
1049
1050out:
1051 return ret;
1052}
1053
1054static int configfs_do_depend_item(struct dentry *subsys_dentry,
1055 struct config_item *target)
1056{
1057 struct configfs_dirent *p;
1058 int ret;
1059
1060 spin_lock(&configfs_dirent_lock);
1061
1062 ret = configfs_depend_prep(subsys_dentry, target);
1063 if (ret)
1064 goto out_unlock_dirent_lock;
1065
1066
1067
1068
1069
1070 p = target->ci_dentry->d_fsdata;
1071 p->s_dependent_count += 1;
1072
1073out_unlock_dirent_lock:
1074 spin_unlock(&configfs_dirent_lock);
1075
1076 return ret;
1077}
1078
1079static inline struct configfs_dirent *
1080configfs_find_subsys_dentry(struct configfs_dirent *root_sd,
1081 struct config_item *subsys_item)
1082{
1083 struct configfs_dirent *p;
1084 struct configfs_dirent *ret = NULL;
1085
1086 list_for_each_entry(p, &root_sd->s_children, s_sibling) {
1087 if (p->s_type & CONFIGFS_DIR &&
1088 p->s_element == subsys_item) {
1089 ret = p;
1090 break;
1091 }
1092 }
1093
1094 return ret;
1095}
1096
1097
1098int configfs_depend_item(struct configfs_subsystem *subsys,
1099 struct config_item *target)
1100{
1101 int ret;
1102 struct configfs_dirent *subsys_sd;
1103 struct config_item *s_item = &subsys->su_group.cg_item;
1104 struct dentry *root;
1105
1106
1107
1108
1109
1110 root = configfs_pin_fs();
1111 if (IS_ERR(root))
1112 return PTR_ERR(root);
1113
1114
1115
1116
1117
1118
1119 inode_lock(d_inode(root));
1120
1121 subsys_sd = configfs_find_subsys_dentry(root->d_fsdata, s_item);
1122 if (!subsys_sd) {
1123 ret = -ENOENT;
1124 goto out_unlock_fs;
1125 }
1126
1127
1128 ret = configfs_do_depend_item(subsys_sd->s_dentry, target);
1129
1130out_unlock_fs:
1131 inode_unlock(d_inode(root));
1132
1133
1134
1135
1136
1137 configfs_release_fs();
1138
1139 return ret;
1140}
1141EXPORT_SYMBOL(configfs_depend_item);
1142
1143
1144
1145
1146
1147
1148void configfs_undepend_item(struct config_item *target)
1149{
1150 struct configfs_dirent *sd;
1151
1152
1153
1154
1155
1156 spin_lock(&configfs_dirent_lock);
1157
1158 sd = target->ci_dentry->d_fsdata;
1159 BUG_ON(sd->s_dependent_count < 1);
1160
1161 sd->s_dependent_count -= 1;
1162
1163
1164
1165
1166
1167 spin_unlock(&configfs_dirent_lock);
1168}
1169EXPORT_SYMBOL(configfs_undepend_item);
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180int configfs_depend_item_unlocked(struct configfs_subsystem *caller_subsys,
1181 struct config_item *target)
1182{
1183 struct configfs_subsystem *target_subsys;
1184 struct config_group *root, *parent;
1185 struct configfs_dirent *subsys_sd;
1186 int ret = -ENOENT;
1187
1188
1189 if (configfs_is_root(target))
1190 return -EINVAL;
1191
1192 parent = target->ci_group;
1193
1194
1195
1196
1197 if (configfs_is_root(&parent->cg_item)) {
1198 target_subsys = to_configfs_subsystem(to_config_group(target));
1199 root = parent;
1200 } else {
1201 target_subsys = parent->cg_subsys;
1202
1203 for (root = parent; !configfs_is_root(&root->cg_item);
1204 root = root->cg_item.ci_group)
1205 ;
1206 }
1207
1208 if (target_subsys != caller_subsys) {
1209
1210
1211
1212
1213
1214 inode_lock(d_inode(root->cg_item.ci_dentry));
1215
1216
1217
1218
1219
1220 subsys_sd = configfs_find_subsys_dentry(
1221 root->cg_item.ci_dentry->d_fsdata,
1222 &target_subsys->su_group.cg_item);
1223 if (!subsys_sd)
1224 goto out_root_unlock;
1225 } else {
1226 subsys_sd = target_subsys->su_group.cg_item.ci_dentry->d_fsdata;
1227 }
1228
1229
1230 ret = configfs_do_depend_item(subsys_sd->s_dentry, target);
1231
1232 if (target_subsys != caller_subsys)
1233out_root_unlock:
1234
1235
1236
1237
1238 inode_unlock(d_inode(root->cg_item.ci_dentry));
1239
1240 return ret;
1241}
1242EXPORT_SYMBOL(configfs_depend_item_unlocked);
1243
1244static int configfs_mkdir(struct user_namespace *mnt_userns, struct inode *dir,
1245 struct dentry *dentry, umode_t mode)
1246{
1247 int ret = 0;
1248 int module_got = 0;
1249 struct config_group *group = NULL;
1250 struct config_item *item = NULL;
1251 struct config_item *parent_item;
1252 struct configfs_subsystem *subsys;
1253 struct configfs_dirent *sd;
1254 const struct config_item_type *type;
1255 struct module *subsys_owner = NULL, *new_item_owner = NULL;
1256 struct configfs_fragment *frag;
1257 char *name;
1258
1259 sd = dentry->d_parent->d_fsdata;
1260
1261
1262
1263
1264
1265 if (!configfs_dirent_is_ready(sd)) {
1266 ret = -ENOENT;
1267 goto out;
1268 }
1269
1270 if (!(sd->s_type & CONFIGFS_USET_DIR)) {
1271 ret = -EPERM;
1272 goto out;
1273 }
1274
1275 frag = new_fragment();
1276 if (!frag) {
1277 ret = -ENOMEM;
1278 goto out;
1279 }
1280
1281
1282 parent_item = configfs_get_config_item(dentry->d_parent);
1283 type = parent_item->ci_type;
1284 subsys = to_config_group(parent_item)->cg_subsys;
1285 BUG_ON(!subsys);
1286
1287 if (!type || !type->ct_group_ops ||
1288 (!type->ct_group_ops->make_group &&
1289 !type->ct_group_ops->make_item)) {
1290 ret = -EPERM;
1291 goto out_put;
1292 }
1293
1294
1295
1296
1297
1298
1299 if (!subsys->su_group.cg_item.ci_type) {
1300 ret = -EINVAL;
1301 goto out_put;
1302 }
1303 subsys_owner = subsys->su_group.cg_item.ci_type->ct_owner;
1304 if (!try_module_get(subsys_owner)) {
1305 ret = -EINVAL;
1306 goto out_put;
1307 }
1308
1309 name = kmalloc(dentry->d_name.len + 1, GFP_KERNEL);
1310 if (!name) {
1311 ret = -ENOMEM;
1312 goto out_subsys_put;
1313 }
1314
1315 snprintf(name, dentry->d_name.len + 1, "%s", dentry->d_name.name);
1316
1317 mutex_lock(&subsys->su_mutex);
1318 if (type->ct_group_ops->make_group) {
1319 group = type->ct_group_ops->make_group(to_config_group(parent_item), name);
1320 if (!group)
1321 group = ERR_PTR(-ENOMEM);
1322 if (!IS_ERR(group)) {
1323 link_group(to_config_group(parent_item), group);
1324 item = &group->cg_item;
1325 } else
1326 ret = PTR_ERR(group);
1327 } else {
1328 item = type->ct_group_ops->make_item(to_config_group(parent_item), name);
1329 if (!item)
1330 item = ERR_PTR(-ENOMEM);
1331 if (!IS_ERR(item))
1332 link_obj(parent_item, item);
1333 else
1334 ret = PTR_ERR(item);
1335 }
1336 mutex_unlock(&subsys->su_mutex);
1337
1338 kfree(name);
1339 if (ret) {
1340
1341
1342
1343
1344 goto out_subsys_put;
1345 }
1346
1347
1348
1349
1350
1351
1352 type = item->ci_type;
1353 if (!type) {
1354 ret = -EINVAL;
1355 goto out_unlink;
1356 }
1357
1358 new_item_owner = type->ct_owner;
1359 if (!try_module_get(new_item_owner)) {
1360 ret = -EINVAL;
1361 goto out_unlink;
1362 }
1363
1364
1365
1366
1367
1368
1369 module_got = 1;
1370
1371
1372
1373
1374
1375
1376
1377 spin_lock(&configfs_dirent_lock);
1378
1379 sd->s_type |= CONFIGFS_USET_IN_MKDIR;
1380 spin_unlock(&configfs_dirent_lock);
1381
1382 if (group)
1383 ret = configfs_attach_group(parent_item, item, dentry, frag);
1384 else
1385 ret = configfs_attach_item(parent_item, item, dentry, frag);
1386
1387 spin_lock(&configfs_dirent_lock);
1388 sd->s_type &= ~CONFIGFS_USET_IN_MKDIR;
1389 if (!ret)
1390 configfs_dir_set_ready(dentry->d_fsdata);
1391 spin_unlock(&configfs_dirent_lock);
1392
1393out_unlink:
1394 if (ret) {
1395
1396 mutex_lock(&subsys->su_mutex);
1397
1398 client_disconnect_notify(parent_item, item);
1399 if (group)
1400 unlink_group(group);
1401 else
1402 unlink_obj(item);
1403 client_drop_item(parent_item, item);
1404
1405 mutex_unlock(&subsys->su_mutex);
1406
1407 if (module_got)
1408 module_put(new_item_owner);
1409 }
1410
1411out_subsys_put:
1412 if (ret)
1413 module_put(subsys_owner);
1414
1415out_put:
1416
1417
1418
1419
1420
1421 config_item_put(parent_item);
1422 put_fragment(frag);
1423
1424out:
1425 return ret;
1426}
1427
1428static int configfs_rmdir(struct inode *dir, struct dentry *dentry)
1429{
1430 struct config_item *parent_item;
1431 struct config_item *item;
1432 struct configfs_subsystem *subsys;
1433 struct configfs_dirent *sd;
1434 struct configfs_fragment *frag;
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 frag = sd->s_frag;
1493 if (down_write_killable(&frag->frag_sem)) {
1494 spin_lock(&configfs_dirent_lock);
1495 configfs_detach_rollback(dentry);
1496 spin_unlock(&configfs_dirent_lock);
1497 config_item_put(parent_item);
1498 return -EINTR;
1499 }
1500 frag->frag_dead = true;
1501 up_write(&frag->frag_sem);
1502
1503
1504 item = configfs_get_config_item(dentry);
1505
1506
1507 config_item_put(parent_item);
1508
1509 if (item->ci_type)
1510 dead_item_owner = item->ci_type->ct_owner;
1511
1512 if (sd->s_type & CONFIGFS_USET_DIR) {
1513 configfs_detach_group(item);
1514
1515 mutex_lock(&subsys->su_mutex);
1516 client_disconnect_notify(parent_item, item);
1517 unlink_group(to_config_group(item));
1518 } else {
1519 configfs_detach_item(item);
1520
1521 mutex_lock(&subsys->su_mutex);
1522 client_disconnect_notify(parent_item, item);
1523 unlink_obj(item);
1524 }
1525
1526 client_drop_item(parent_item, item);
1527 mutex_unlock(&subsys->su_mutex);
1528
1529
1530 config_item_put(item);
1531
1532 module_put(dead_item_owner);
1533 module_put(subsys_owner);
1534
1535 return 0;
1536}
1537
1538const struct inode_operations configfs_dir_inode_operations = {
1539 .mkdir = configfs_mkdir,
1540 .rmdir = configfs_rmdir,
1541 .symlink = configfs_symlink,
1542 .unlink = configfs_unlink,
1543 .lookup = configfs_lookup,
1544 .setattr = configfs_setattr,
1545};
1546
1547const struct inode_operations configfs_root_inode_operations = {
1548 .lookup = configfs_lookup,
1549 .setattr = configfs_setattr,
1550};
1551
1552static int configfs_dir_open(struct inode *inode, struct file *file)
1553{
1554 struct dentry * dentry = file->f_path.dentry;
1555 struct configfs_dirent * parent_sd = dentry->d_fsdata;
1556 int err;
1557
1558 inode_lock(d_inode(dentry));
1559
1560
1561
1562
1563 err = -ENOENT;
1564 if (configfs_dirent_is_ready(parent_sd)) {
1565 file->private_data = configfs_new_dirent(parent_sd, NULL, 0, NULL);
1566 if (IS_ERR(file->private_data))
1567 err = PTR_ERR(file->private_data);
1568 else
1569 err = 0;
1570 }
1571 inode_unlock(d_inode(dentry));
1572
1573 return err;
1574}
1575
1576static int configfs_dir_close(struct inode *inode, struct file *file)
1577{
1578 struct dentry * dentry = file->f_path.dentry;
1579 struct configfs_dirent * cursor = file->private_data;
1580
1581 inode_lock(d_inode(dentry));
1582 spin_lock(&configfs_dirent_lock);
1583 list_del_init(&cursor->s_sibling);
1584 spin_unlock(&configfs_dirent_lock);
1585 inode_unlock(d_inode(dentry));
1586
1587 release_configfs_dirent(cursor);
1588
1589 return 0;
1590}
1591
1592
1593static inline unsigned char dt_type(struct configfs_dirent *sd)
1594{
1595 return (sd->s_mode >> 12) & 15;
1596}
1597
1598static int configfs_readdir(struct file *file, struct dir_context *ctx)
1599{
1600 struct dentry *dentry = file->f_path.dentry;
1601 struct super_block *sb = dentry->d_sb;
1602 struct configfs_dirent * parent_sd = dentry->d_fsdata;
1603 struct configfs_dirent *cursor = file->private_data;
1604 struct list_head *p, *q = &cursor->s_sibling;
1605 ino_t ino = 0;
1606
1607 if (!dir_emit_dots(file, ctx))
1608 return 0;
1609 spin_lock(&configfs_dirent_lock);
1610 if (ctx->pos == 2)
1611 list_move(q, &parent_sd->s_children);
1612 for (p = q->next; p != &parent_sd->s_children; p = p->next) {
1613 struct configfs_dirent *next;
1614 const char *name;
1615 int len;
1616 struct inode *inode = NULL;
1617
1618 next = list_entry(p, struct configfs_dirent, s_sibling);
1619 if (!next->s_element)
1620 continue;
1621
1622
1623
1624
1625
1626
1627
1628
1629
1630
1631
1632
1633
1634
1635 dentry = next->s_dentry;
1636 if (dentry)
1637 inode = d_inode(dentry);
1638 if (inode)
1639 ino = inode->i_ino;
1640 spin_unlock(&configfs_dirent_lock);
1641 if (!inode)
1642 ino = iunique(sb, 2);
1643
1644 name = configfs_get_name(next);
1645 len = strlen(name);
1646
1647 if (!dir_emit(ctx, name, len, ino, dt_type(next)))
1648 return 0;
1649
1650 spin_lock(&configfs_dirent_lock);
1651 list_move(q, p);
1652 p = q;
1653 ctx->pos++;
1654 }
1655 spin_unlock(&configfs_dirent_lock);
1656 return 0;
1657}
1658
1659static loff_t configfs_dir_lseek(struct file *file, loff_t offset, int whence)
1660{
1661 struct dentry * dentry = file->f_path.dentry;
1662
1663 switch (whence) {
1664 case 1:
1665 offset += file->f_pos;
1666 fallthrough;
1667 case 0:
1668 if (offset >= 0)
1669 break;
1670 fallthrough;
1671 default:
1672 return -EINVAL;
1673 }
1674 if (offset != file->f_pos) {
1675 file->f_pos = offset;
1676 if (file->f_pos >= 2) {
1677 struct configfs_dirent *sd = dentry->d_fsdata;
1678 struct configfs_dirent *cursor = file->private_data;
1679 struct list_head *p;
1680 loff_t n = file->f_pos - 2;
1681
1682 spin_lock(&configfs_dirent_lock);
1683 list_del(&cursor->s_sibling);
1684 p = sd->s_children.next;
1685 while (n && p != &sd->s_children) {
1686 struct configfs_dirent *next;
1687 next = list_entry(p, struct configfs_dirent,
1688 s_sibling);
1689 if (next->s_element)
1690 n--;
1691 p = p->next;
1692 }
1693 list_add_tail(&cursor->s_sibling, p);
1694 spin_unlock(&configfs_dirent_lock);
1695 }
1696 }
1697 return offset;
1698}
1699
1700const struct file_operations configfs_dir_operations = {
1701 .open = configfs_dir_open,
1702 .release = configfs_dir_close,
1703 .llseek = configfs_dir_lseek,
1704 .read = generic_read_dir,
1705 .iterate_shared = configfs_readdir,
1706};
1707
1708
1709
1710
1711
1712
1713
1714
1715
1716
1717
1718int configfs_register_group(struct config_group *parent_group,
1719 struct config_group *group)
1720{
1721 struct configfs_subsystem *subsys = parent_group->cg_subsys;
1722 struct dentry *parent;
1723 struct configfs_fragment *frag;
1724 int ret;
1725
1726 frag = new_fragment();
1727 if (!frag)
1728 return -ENOMEM;
1729
1730 mutex_lock(&subsys->su_mutex);
1731 link_group(parent_group, group);
1732 mutex_unlock(&subsys->su_mutex);
1733
1734 parent = parent_group->cg_item.ci_dentry;
1735
1736 inode_lock_nested(d_inode(parent), I_MUTEX_PARENT);
1737 ret = create_default_group(parent_group, group, frag);
1738 if (ret)
1739 goto err_out;
1740
1741 spin_lock(&configfs_dirent_lock);
1742 configfs_dir_set_ready(group->cg_item.ci_dentry->d_fsdata);
1743 spin_unlock(&configfs_dirent_lock);
1744 inode_unlock(d_inode(parent));
1745 put_fragment(frag);
1746 return 0;
1747err_out:
1748 inode_unlock(d_inode(parent));
1749 mutex_lock(&subsys->su_mutex);
1750 unlink_group(group);
1751 mutex_unlock(&subsys->su_mutex);
1752 put_fragment(frag);
1753 return ret;
1754}
1755EXPORT_SYMBOL(configfs_register_group);
1756
1757
1758
1759
1760
1761
1762
1763void configfs_unregister_group(struct config_group *group)
1764{
1765 struct configfs_subsystem *subsys = group->cg_subsys;
1766 struct dentry *dentry = group->cg_item.ci_dentry;
1767 struct dentry *parent = group->cg_item.ci_parent->ci_dentry;
1768 struct configfs_dirent *sd = dentry->d_fsdata;
1769 struct configfs_fragment *frag = sd->s_frag;
1770
1771 down_write(&frag->frag_sem);
1772 frag->frag_dead = true;
1773 up_write(&frag->frag_sem);
1774
1775 inode_lock_nested(d_inode(parent), I_MUTEX_PARENT);
1776 spin_lock(&configfs_dirent_lock);
1777 configfs_detach_prep(dentry, NULL);
1778 spin_unlock(&configfs_dirent_lock);
1779
1780 configfs_detach_group(&group->cg_item);
1781 d_inode(dentry)->i_flags |= S_DEAD;
1782 dont_mount(dentry);
1783 fsnotify_rmdir(d_inode(parent), dentry);
1784 d_delete(dentry);
1785 inode_unlock(d_inode(parent));
1786
1787 dput(dentry);
1788
1789 mutex_lock(&subsys->su_mutex);
1790 unlink_group(group);
1791 mutex_unlock(&subsys->su_mutex);
1792}
1793EXPORT_SYMBOL(configfs_unregister_group);
1794
1795
1796
1797
1798
1799
1800
1801
1802
1803
1804
1805
1806struct config_group *
1807configfs_register_default_group(struct config_group *parent_group,
1808 const char *name,
1809 const struct config_item_type *item_type)
1810{
1811 int ret;
1812 struct config_group *group;
1813
1814 group = kzalloc(sizeof(*group), GFP_KERNEL);
1815 if (!group)
1816 return ERR_PTR(-ENOMEM);
1817 config_group_init_type_name(group, name, item_type);
1818
1819 ret = configfs_register_group(parent_group, group);
1820 if (ret) {
1821 kfree(group);
1822 return ERR_PTR(ret);
1823 }
1824 return group;
1825}
1826EXPORT_SYMBOL(configfs_register_default_group);
1827
1828
1829
1830
1831
1832void configfs_unregister_default_group(struct config_group *group)
1833{
1834 configfs_unregister_group(group);
1835 kfree(group);
1836}
1837EXPORT_SYMBOL(configfs_unregister_default_group);
1838
1839int configfs_register_subsystem(struct configfs_subsystem *subsys)
1840{
1841 int err;
1842 struct config_group *group = &subsys->su_group;
1843 struct dentry *dentry;
1844 struct dentry *root;
1845 struct configfs_dirent *sd;
1846 struct configfs_fragment *frag;
1847
1848 frag = new_fragment();
1849 if (!frag)
1850 return -ENOMEM;
1851
1852 root = configfs_pin_fs();
1853 if (IS_ERR(root)) {
1854 put_fragment(frag);
1855 return PTR_ERR(root);
1856 }
1857
1858 if (!group->cg_item.ci_name)
1859 group->cg_item.ci_name = group->cg_item.ci_namebuf;
1860
1861 sd = root->d_fsdata;
1862 link_group(to_config_group(sd->s_element), group);
1863
1864 inode_lock_nested(d_inode(root), I_MUTEX_PARENT);
1865
1866 err = -ENOMEM;
1867 dentry = d_alloc_name(root, group->cg_item.ci_name);
1868 if (dentry) {
1869 d_add(dentry, NULL);
1870
1871 err = configfs_attach_group(sd->s_element, &group->cg_item,
1872 dentry, frag);
1873 if (err) {
1874 BUG_ON(d_inode(dentry));
1875 d_drop(dentry);
1876 dput(dentry);
1877 } else {
1878 spin_lock(&configfs_dirent_lock);
1879 configfs_dir_set_ready(dentry->d_fsdata);
1880 spin_unlock(&configfs_dirent_lock);
1881 }
1882 }
1883
1884 inode_unlock(d_inode(root));
1885
1886 if (err) {
1887 unlink_group(group);
1888 configfs_release_fs();
1889 }
1890 put_fragment(frag);
1891
1892 return err;
1893}
1894
1895void configfs_unregister_subsystem(struct configfs_subsystem *subsys)
1896{
1897 struct config_group *group = &subsys->su_group;
1898 struct dentry *dentry = group->cg_item.ci_dentry;
1899 struct dentry *root = dentry->d_sb->s_root;
1900 struct configfs_dirent *sd = dentry->d_fsdata;
1901 struct configfs_fragment *frag = sd->s_frag;
1902
1903 if (dentry->d_parent != root) {
1904 pr_err("Tried to unregister non-subsystem!\n");
1905 return;
1906 }
1907
1908 down_write(&frag->frag_sem);
1909 frag->frag_dead = true;
1910 up_write(&frag->frag_sem);
1911
1912 inode_lock_nested(d_inode(root),
1913 I_MUTEX_PARENT);
1914 inode_lock_nested(d_inode(dentry), I_MUTEX_CHILD);
1915 mutex_lock(&configfs_symlink_mutex);
1916 spin_lock(&configfs_dirent_lock);
1917 if (configfs_detach_prep(dentry, NULL)) {
1918 pr_err("Tried to unregister non-empty subsystem!\n");
1919 }
1920 spin_unlock(&configfs_dirent_lock);
1921 mutex_unlock(&configfs_symlink_mutex);
1922 configfs_detach_group(&group->cg_item);
1923 d_inode(dentry)->i_flags |= S_DEAD;
1924 dont_mount(dentry);
1925 fsnotify_rmdir(d_inode(root), dentry);
1926 inode_unlock(d_inode(dentry));
1927
1928 d_delete(dentry);
1929
1930 inode_unlock(d_inode(root));
1931
1932 dput(dentry);
1933
1934 unlink_group(group);
1935 configfs_release_fs();
1936}
1937
1938EXPORT_SYMBOL(configfs_register_subsystem);
1939EXPORT_SYMBOL(configfs_unregister_subsystem);
1940