1
2
3
4
5
6
7
8
9
10
11#include <linux/sched.h>
12#include <linux/fs.h>
13#include <linux/namei.h>
14#include <linux/idr.h>
15#include <linux/slab.h>
16#include <linux/security.h>
17#include <linux/hash.h>
18
19#include "kernfs-internal.h"
20
21DEFINE_MUTEX(kernfs_mutex);
22static DEFINE_SPINLOCK(kernfs_rename_lock);
23static char kernfs_pr_cont_buf[PATH_MAX];
24
25#define rb_to_kn(X) rb_entry((X), struct kernfs_node, rb)
26
27static bool kernfs_active(struct kernfs_node *kn)
28{
29 lockdep_assert_held(&kernfs_mutex);
30 return atomic_read(&kn->active) >= 0;
31}
32
33static bool kernfs_lockdep(struct kernfs_node *kn)
34{
35#ifdef CONFIG_DEBUG_LOCK_ALLOC
36 return kn->flags & KERNFS_LOCKDEP;
37#else
38 return false;
39#endif
40}
41
42static int kernfs_name_locked(struct kernfs_node *kn, char *buf, size_t buflen)
43{
44 return strlcpy(buf, kn->parent ? kn->name : "/", buflen);
45}
46
47
48static size_t kernfs_depth(struct kernfs_node *from, struct kernfs_node *to)
49{
50 size_t depth = 0;
51
52 while (to->parent && to != from) {
53 depth++;
54 to = to->parent;
55 }
56 return depth;
57}
58
59static struct kernfs_node *kernfs_common_ancestor(struct kernfs_node *a,
60 struct kernfs_node *b)
61{
62 size_t da, db;
63 struct kernfs_root *ra = kernfs_root(a), *rb = kernfs_root(b);
64
65 if (ra != rb)
66 return NULL;
67
68 da = kernfs_depth(ra->kn, a);
69 db = kernfs_depth(rb->kn, b);
70
71 while (da > db) {
72 a = a->parent;
73 da--;
74 }
75 while (db > da) {
76 b = b->parent;
77 db--;
78 }
79
80
81 while (b != a) {
82 b = b->parent;
83 a = a->parent;
84 }
85
86 return a;
87}
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116static int kernfs_path_from_node_locked(struct kernfs_node *kn_to,
117 struct kernfs_node *kn_from,
118 char *buf, size_t buflen)
119{
120 struct kernfs_node *kn, *common;
121 const char parent_str[] = "/..";
122 size_t depth_from, depth_to, len = 0, nlen = 0;
123 char *p;
124 int i;
125
126 if (!kn_from)
127 kn_from = kernfs_root(kn_to)->kn;
128
129 if (kn_from == kn_to)
130 return strlcpy(buf, "/", buflen);
131
132 common = kernfs_common_ancestor(kn_from, kn_to);
133 if (WARN_ON(!common))
134 return -1;
135
136 depth_to = kernfs_depth(common, kn_to);
137 depth_from = kernfs_depth(common, kn_from);
138
139 if (buf)
140 buf[0] = '\0';
141
142 for (i = 0; i < depth_from; i++)
143 len += strlcpy(buf + len, parent_str,
144 len < buflen ? buflen - len : 0);
145
146
147 for (kn = kn_to; kn != common; kn = kn->parent)
148 nlen += strlen(kn->name) + 1;
149
150 if (len + nlen >= buflen)
151 return len + nlen;
152
153 p = buf + len + nlen;
154 *p = '\0';
155 for (kn = kn_to; kn != common; kn = kn->parent) {
156 size_t tmp = strlen(kn->name);
157 p -= tmp;
158 memcpy(p, kn->name, tmp);
159 *(--p) = '/';
160 }
161
162 return len + nlen;
163}
164
165
166
167
168
169
170
171
172
173
174
175
176
177int kernfs_name(struct kernfs_node *kn, char *buf, size_t buflen)
178{
179 unsigned long flags;
180 int ret;
181
182 spin_lock_irqsave(&kernfs_rename_lock, flags);
183 ret = kernfs_name_locked(kn, buf, buflen);
184 spin_unlock_irqrestore(&kernfs_rename_lock, flags);
185 return ret;
186}
187
188
189
190
191
192
193
194size_t kernfs_path_len(struct kernfs_node *kn)
195{
196 size_t len = 0;
197 unsigned long flags;
198
199 spin_lock_irqsave(&kernfs_rename_lock, flags);
200
201 do {
202 len += strlen(kn->name) + 1;
203 kn = kn->parent;
204 } while (kn && kn->parent);
205
206 spin_unlock_irqrestore(&kernfs_rename_lock, flags);
207
208 return len;
209}
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226int kernfs_path_from_node(struct kernfs_node *to, struct kernfs_node *from,
227 char *buf, size_t buflen)
228{
229 unsigned long flags;
230 int ret;
231
232 spin_lock_irqsave(&kernfs_rename_lock, flags);
233 ret = kernfs_path_from_node_locked(to, from, buf, buflen);
234 spin_unlock_irqrestore(&kernfs_rename_lock, flags);
235 return ret;
236}
237EXPORT_SYMBOL_GPL(kernfs_path_from_node);
238
239
240
241
242
243
244
245
246
247
248
249
250char *kernfs_path(struct kernfs_node *kn, char *buf, size_t buflen)
251{
252 int ret;
253
254 ret = kernfs_path_from_node(kn, NULL, buf, buflen);
255 if (ret < 0 || ret >= buflen)
256 return NULL;
257 return buf;
258}
259EXPORT_SYMBOL_GPL(kernfs_path);
260
261
262
263
264
265
266
267void pr_cont_kernfs_name(struct kernfs_node *kn)
268{
269 unsigned long flags;
270
271 spin_lock_irqsave(&kernfs_rename_lock, flags);
272
273 kernfs_name_locked(kn, kernfs_pr_cont_buf, sizeof(kernfs_pr_cont_buf));
274 pr_cont("%s", kernfs_pr_cont_buf);
275
276 spin_unlock_irqrestore(&kernfs_rename_lock, flags);
277}
278
279
280
281
282
283
284
285void pr_cont_kernfs_path(struct kernfs_node *kn)
286{
287 unsigned long flags;
288 int sz;
289
290 spin_lock_irqsave(&kernfs_rename_lock, flags);
291
292 sz = kernfs_path_from_node_locked(kn, NULL, kernfs_pr_cont_buf,
293 sizeof(kernfs_pr_cont_buf));
294 if (sz < 0) {
295 pr_cont("(error)");
296 goto out;
297 }
298
299 if (sz >= sizeof(kernfs_pr_cont_buf)) {
300 pr_cont("(name too long)");
301 goto out;
302 }
303
304 pr_cont("%s", kernfs_pr_cont_buf);
305
306out:
307 spin_unlock_irqrestore(&kernfs_rename_lock, flags);
308}
309
310
311
312
313
314
315
316
317struct kernfs_node *kernfs_get_parent(struct kernfs_node *kn)
318{
319 struct kernfs_node *parent;
320 unsigned long flags;
321
322 spin_lock_irqsave(&kernfs_rename_lock, flags);
323 parent = kn->parent;
324 kernfs_get(parent);
325 spin_unlock_irqrestore(&kernfs_rename_lock, flags);
326
327 return parent;
328}
329
330
331
332
333
334
335
336
337static unsigned int kernfs_name_hash(const char *name, const void *ns)
338{
339 unsigned long hash = init_name_hash();
340 unsigned int len = strlen(name);
341 while (len--)
342 hash = partial_name_hash(*name++, hash);
343 hash = (end_name_hash(hash) ^ hash_ptr((void *)ns, 31));
344 hash &= 0x7fffffffU;
345
346 if (hash < 2)
347 hash += 2;
348 if (hash >= INT_MAX)
349 hash = INT_MAX - 1;
350 return hash;
351}
352
353static int kernfs_name_compare(unsigned int hash, const char *name,
354 const void *ns, const struct kernfs_node *kn)
355{
356 if (hash < kn->hash)
357 return -1;
358 if (hash > kn->hash)
359 return 1;
360 if (ns < kn->ns)
361 return -1;
362 if (ns > kn->ns)
363 return 1;
364 return strcmp(name, kn->name);
365}
366
367static int kernfs_sd_compare(const struct kernfs_node *left,
368 const struct kernfs_node *right)
369{
370 return kernfs_name_compare(left->hash, left->name, left->ns, right);
371}
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386static int kernfs_link_sibling(struct kernfs_node *kn)
387{
388 struct rb_node **node = &kn->parent->dir.children.rb_node;
389 struct rb_node *parent = NULL;
390
391 while (*node) {
392 struct kernfs_node *pos;
393 int result;
394
395 pos = rb_to_kn(*node);
396 parent = *node;
397 result = kernfs_sd_compare(kn, pos);
398 if (result < 0)
399 node = &pos->rb.rb_left;
400 else if (result > 0)
401 node = &pos->rb.rb_right;
402 else
403 return -EEXIST;
404 }
405
406
407 rb_link_node(&kn->rb, parent, node);
408 rb_insert_color(&kn->rb, &kn->parent->dir.children);
409
410
411 if (kernfs_type(kn) == KERNFS_DIR)
412 kn->parent->dir.subdirs++;
413
414 return 0;
415}
416
417
418
419
420
421
422
423
424
425
426
427
428static bool kernfs_unlink_sibling(struct kernfs_node *kn)
429{
430 if (RB_EMPTY_NODE(&kn->rb))
431 return false;
432
433 if (kernfs_type(kn) == KERNFS_DIR)
434 kn->parent->dir.subdirs--;
435
436 rb_erase(&kn->rb, &kn->parent->dir.children);
437 RB_CLEAR_NODE(&kn->rb);
438 return true;
439}
440
441
442
443
444
445
446
447
448
449
450
451struct kernfs_node *kernfs_get_active(struct kernfs_node *kn)
452{
453 if (unlikely(!kn))
454 return NULL;
455
456 if (!atomic_inc_unless_negative(&kn->active))
457 return NULL;
458
459 if (kernfs_lockdep(kn))
460 rwsem_acquire_read(&kn->dep_map, 0, 1, _RET_IP_);
461 return kn;
462}
463
464
465
466
467
468
469
470
471void kernfs_put_active(struct kernfs_node *kn)
472{
473 struct kernfs_root *root = kernfs_root(kn);
474 int v;
475
476 if (unlikely(!kn))
477 return;
478
479 if (kernfs_lockdep(kn))
480 rwsem_release(&kn->dep_map, 1, _RET_IP_);
481 v = atomic_dec_return(&kn->active);
482 if (likely(v != KN_DEACTIVATED_BIAS))
483 return;
484
485 wake_up_all(&root->deactivate_waitq);
486}
487
488
489
490
491
492
493
494
495
496static void kernfs_drain(struct kernfs_node *kn)
497 __releases(&kernfs_mutex) __acquires(&kernfs_mutex)
498{
499 struct kernfs_root *root = kernfs_root(kn);
500
501 lockdep_assert_held(&kernfs_mutex);
502 WARN_ON_ONCE(kernfs_active(kn));
503
504 mutex_unlock(&kernfs_mutex);
505
506 if (kernfs_lockdep(kn)) {
507 rwsem_acquire(&kn->dep_map, 0, 0, _RET_IP_);
508 if (atomic_read(&kn->active) != KN_DEACTIVATED_BIAS)
509 lock_contended(&kn->dep_map, _RET_IP_);
510 }
511
512
513 wait_event(root->deactivate_waitq,
514 atomic_read(&kn->active) == KN_DEACTIVATED_BIAS);
515
516 if (kernfs_lockdep(kn)) {
517 lock_acquired(&kn->dep_map, _RET_IP_);
518 rwsem_release(&kn->dep_map, 1, _RET_IP_);
519 }
520
521 kernfs_unmap_bin_file(kn);
522
523 mutex_lock(&kernfs_mutex);
524}
525
526
527
528
529
530void kernfs_get(struct kernfs_node *kn)
531{
532 if (kn) {
533 WARN_ON(!atomic_read(&kn->count));
534 atomic_inc(&kn->count);
535 }
536}
537EXPORT_SYMBOL_GPL(kernfs_get);
538
539
540
541
542
543
544
545void kernfs_put(struct kernfs_node *kn)
546{
547 struct kernfs_node *parent;
548 struct kernfs_root *root;
549
550 if (!kn || !atomic_dec_and_test(&kn->count))
551 return;
552 root = kernfs_root(kn);
553 repeat:
554
555
556
557
558 parent = kn->parent;
559
560 WARN_ONCE(atomic_read(&kn->active) != KN_DEACTIVATED_BIAS,
561 "kernfs_put: %s/%s: released with incorrect active_ref %d\n",
562 parent ? parent->name : "", kn->name, atomic_read(&kn->active));
563
564 if (kernfs_type(kn) == KERNFS_LINK)
565 kernfs_put(kn->symlink.target_kn);
566
567 kfree_const(kn->name);
568
569 if (kn->iattr) {
570 if (kn->iattr->ia_secdata)
571 security_release_secctx(kn->iattr->ia_secdata,
572 kn->iattr->ia_secdata_len);
573 simple_xattrs_free(&kn->iattr->xattrs);
574 }
575 kfree(kn->iattr);
576 ida_simple_remove(&root->ino_ida, kn->ino);
577 kmem_cache_free(kernfs_node_cache, kn);
578
579 kn = parent;
580 if (kn) {
581 if (atomic_dec_and_test(&kn->count))
582 goto repeat;
583 } else {
584
585 ida_destroy(&root->ino_ida);
586 kfree(root);
587 }
588}
589EXPORT_SYMBOL_GPL(kernfs_put);
590
591static int kernfs_dop_revalidate(struct dentry *dentry, unsigned int flags)
592{
593 struct kernfs_node *kn;
594
595 if (flags & LOOKUP_RCU)
596 return -ECHILD;
597
598
599 if (d_really_is_negative(dentry))
600 goto out_bad_unlocked;
601
602 kn = dentry->d_fsdata;
603 mutex_lock(&kernfs_mutex);
604
605
606 if (!kernfs_active(kn))
607 goto out_bad;
608
609
610 if (dentry->d_parent->d_fsdata != kn->parent)
611 goto out_bad;
612
613
614 if (strcmp(dentry->d_name.name, kn->name) != 0)
615 goto out_bad;
616
617
618 if (kn->parent && kernfs_ns_enabled(kn->parent) &&
619 kernfs_info(dentry->d_sb)->ns != kn->ns)
620 goto out_bad;
621
622 mutex_unlock(&kernfs_mutex);
623 return 1;
624out_bad:
625 mutex_unlock(&kernfs_mutex);
626out_bad_unlocked:
627 return 0;
628}
629
630static void kernfs_dop_release(struct dentry *dentry)
631{
632 kernfs_put(dentry->d_fsdata);
633}
634
635const struct dentry_operations kernfs_dops = {
636 .d_revalidate = kernfs_dop_revalidate,
637 .d_release = kernfs_dop_release,
638};
639
640
641
642
643
644
645
646
647
648
649
650
651struct kernfs_node *kernfs_node_from_dentry(struct dentry *dentry)
652{
653 if (dentry->d_sb->s_op == &kernfs_sops)
654 return dentry->d_fsdata;
655 return NULL;
656}
657
658static struct kernfs_node *__kernfs_new_node(struct kernfs_root *root,
659 const char *name, umode_t mode,
660 unsigned flags)
661{
662 struct kernfs_node *kn;
663 int ret;
664
665 name = kstrdup_const(name, GFP_KERNEL);
666 if (!name)
667 return NULL;
668
669 kn = kmem_cache_zalloc(kernfs_node_cache, GFP_KERNEL);
670 if (!kn)
671 goto err_out1;
672
673 ret = ida_simple_get(&root->ino_ida, 1, 0, GFP_KERNEL);
674 if (ret < 0)
675 goto err_out2;
676 kn->ino = ret;
677
678 atomic_set(&kn->count, 1);
679 atomic_set(&kn->active, KN_DEACTIVATED_BIAS);
680 RB_CLEAR_NODE(&kn->rb);
681
682 kn->name = name;
683 kn->mode = mode;
684 kn->flags = flags;
685
686 return kn;
687
688 err_out2:
689 kmem_cache_free(kernfs_node_cache, kn);
690 err_out1:
691 kfree_const(name);
692 return NULL;
693}
694
695struct kernfs_node *kernfs_new_node(struct kernfs_node *parent,
696 const char *name, umode_t mode,
697 unsigned flags)
698{
699 struct kernfs_node *kn;
700
701 kn = __kernfs_new_node(kernfs_root(parent), name, mode, flags);
702 if (kn) {
703 kernfs_get(parent);
704 kn->parent = parent;
705 }
706 return kn;
707}
708
709
710
711
712
713
714
715
716
717
718
719
720
721int kernfs_add_one(struct kernfs_node *kn)
722{
723 struct kernfs_node *parent = kn->parent;
724 struct kernfs_iattrs *ps_iattr;
725 bool has_ns;
726 int ret;
727
728 mutex_lock(&kernfs_mutex);
729
730 ret = -EINVAL;
731 has_ns = kernfs_ns_enabled(parent);
732 if (WARN(has_ns != (bool)kn->ns, KERN_WARNING "kernfs: ns %s in '%s' for '%s'\n",
733 has_ns ? "required" : "invalid", parent->name, kn->name))
734 goto out_unlock;
735
736 if (kernfs_type(parent) != KERNFS_DIR)
737 goto out_unlock;
738
739 ret = -ENOENT;
740 if (parent->flags & KERNFS_EMPTY_DIR)
741 goto out_unlock;
742
743 if ((parent->flags & KERNFS_ACTIVATED) && !kernfs_active(parent))
744 goto out_unlock;
745
746 kn->hash = kernfs_name_hash(kn->name, kn->ns);
747
748 ret = kernfs_link_sibling(kn);
749 if (ret)
750 goto out_unlock;
751
752
753 ps_iattr = parent->iattr;
754 if (ps_iattr) {
755 struct iattr *ps_iattrs = &ps_iattr->ia_iattr;
756 ps_iattrs->ia_ctime = ps_iattrs->ia_mtime = CURRENT_TIME;
757 }
758
759 mutex_unlock(&kernfs_mutex);
760
761
762
763
764
765
766
767
768 if (!(kernfs_root(kn)->flags & KERNFS_ROOT_CREATE_DEACTIVATED))
769 kernfs_activate(kn);
770 return 0;
771
772out_unlock:
773 mutex_unlock(&kernfs_mutex);
774 return ret;
775}
776
777
778
779
780
781
782
783
784
785
786static struct kernfs_node *kernfs_find_ns(struct kernfs_node *parent,
787 const unsigned char *name,
788 const void *ns)
789{
790 struct rb_node *node = parent->dir.children.rb_node;
791 bool has_ns = kernfs_ns_enabled(parent);
792 unsigned int hash;
793
794 lockdep_assert_held(&kernfs_mutex);
795
796 if (has_ns != (bool)ns) {
797 WARN(1, KERN_WARNING "kernfs: ns %s in '%s' for '%s'\n",
798 has_ns ? "required" : "invalid", parent->name, name);
799 return NULL;
800 }
801
802 hash = kernfs_name_hash(name, ns);
803 while (node) {
804 struct kernfs_node *kn;
805 int result;
806
807 kn = rb_to_kn(node);
808 result = kernfs_name_compare(hash, name, ns, kn);
809 if (result < 0)
810 node = node->rb_left;
811 else if (result > 0)
812 node = node->rb_right;
813 else
814 return kn;
815 }
816 return NULL;
817}
818
819static struct kernfs_node *kernfs_walk_ns(struct kernfs_node *parent,
820 const unsigned char *path,
821 const void *ns)
822{
823 size_t len;
824 char *p, *name;
825
826 lockdep_assert_held(&kernfs_mutex);
827
828
829 spin_lock_irq(&kernfs_rename_lock);
830
831 len = strlcpy(kernfs_pr_cont_buf, path, sizeof(kernfs_pr_cont_buf));
832
833 if (len >= sizeof(kernfs_pr_cont_buf)) {
834 spin_unlock_irq(&kernfs_rename_lock);
835 return NULL;
836 }
837
838 p = kernfs_pr_cont_buf;
839
840 while ((name = strsep(&p, "/")) && parent) {
841 if (*name == '\0')
842 continue;
843 parent = kernfs_find_ns(parent, name, ns);
844 }
845
846 spin_unlock_irq(&kernfs_rename_lock);
847
848 return parent;
849}
850
851
852
853
854
855
856
857
858
859
860
861struct kernfs_node *kernfs_find_and_get_ns(struct kernfs_node *parent,
862 const char *name, const void *ns)
863{
864 struct kernfs_node *kn;
865
866 mutex_lock(&kernfs_mutex);
867 kn = kernfs_find_ns(parent, name, ns);
868 kernfs_get(kn);
869 mutex_unlock(&kernfs_mutex);
870
871 return kn;
872}
873EXPORT_SYMBOL_GPL(kernfs_find_and_get_ns);
874
875
876
877
878
879
880
881
882
883
884
885struct kernfs_node *kernfs_walk_and_get_ns(struct kernfs_node *parent,
886 const char *path, const void *ns)
887{
888 struct kernfs_node *kn;
889
890 mutex_lock(&kernfs_mutex);
891 kn = kernfs_walk_ns(parent, path, ns);
892 kernfs_get(kn);
893 mutex_unlock(&kernfs_mutex);
894
895 return kn;
896}
897
898
899
900
901
902
903
904
905
906
907struct kernfs_root *kernfs_create_root(struct kernfs_syscall_ops *scops,
908 unsigned int flags, void *priv)
909{
910 struct kernfs_root *root;
911 struct kernfs_node *kn;
912
913 root = kzalloc(sizeof(*root), GFP_KERNEL);
914 if (!root)
915 return ERR_PTR(-ENOMEM);
916
917 ida_init(&root->ino_ida);
918 INIT_LIST_HEAD(&root->supers);
919
920 kn = __kernfs_new_node(root, "", S_IFDIR | S_IRUGO | S_IXUGO,
921 KERNFS_DIR);
922 if (!kn) {
923 ida_destroy(&root->ino_ida);
924 kfree(root);
925 return ERR_PTR(-ENOMEM);
926 }
927
928 kn->priv = priv;
929 kn->dir.root = root;
930
931 root->syscall_ops = scops;
932 root->flags = flags;
933 root->kn = kn;
934 init_waitqueue_head(&root->deactivate_waitq);
935
936 if (!(root->flags & KERNFS_ROOT_CREATE_DEACTIVATED))
937 kernfs_activate(kn);
938
939 return root;
940}
941
942
943
944
945
946
947
948
949void kernfs_destroy_root(struct kernfs_root *root)
950{
951 kernfs_remove(root->kn);
952}
953
954
955
956
957
958
959
960
961
962
963
964struct kernfs_node *kernfs_create_dir_ns(struct kernfs_node *parent,
965 const char *name, umode_t mode,
966 void *priv, const void *ns)
967{
968 struct kernfs_node *kn;
969 int rc;
970
971
972 kn = kernfs_new_node(parent, name, mode | S_IFDIR, KERNFS_DIR);
973 if (!kn)
974 return ERR_PTR(-ENOMEM);
975
976 kn->dir.root = parent->dir.root;
977 kn->ns = ns;
978 kn->priv = priv;
979
980
981 rc = kernfs_add_one(kn);
982 if (!rc)
983 return kn;
984
985 kernfs_put(kn);
986 return ERR_PTR(rc);
987}
988
989
990
991
992
993
994
995
996struct kernfs_node *kernfs_create_empty_dir(struct kernfs_node *parent,
997 const char *name)
998{
999 struct kernfs_node *kn;
1000 int rc;
1001
1002
1003 kn = kernfs_new_node(parent, name, S_IRUGO|S_IXUGO|S_IFDIR, KERNFS_DIR);
1004 if (!kn)
1005 return ERR_PTR(-ENOMEM);
1006
1007 kn->flags |= KERNFS_EMPTY_DIR;
1008 kn->dir.root = parent->dir.root;
1009 kn->ns = NULL;
1010 kn->priv = NULL;
1011
1012
1013 rc = kernfs_add_one(kn);
1014 if (!rc)
1015 return kn;
1016
1017 kernfs_put(kn);
1018 return ERR_PTR(rc);
1019}
1020
1021static struct dentry *kernfs_iop_lookup(struct inode *dir,
1022 struct dentry *dentry,
1023 unsigned int flags)
1024{
1025 struct dentry *ret;
1026 struct kernfs_node *parent = dentry->d_parent->d_fsdata;
1027 struct kernfs_node *kn;
1028 struct inode *inode;
1029 const void *ns = NULL;
1030
1031 mutex_lock(&kernfs_mutex);
1032
1033 if (kernfs_ns_enabled(parent))
1034 ns = kernfs_info(dir->i_sb)->ns;
1035
1036 kn = kernfs_find_ns(parent, dentry->d_name.name, ns);
1037
1038
1039 if (!kn || !kernfs_active(kn)) {
1040 ret = NULL;
1041 goto out_unlock;
1042 }
1043 kernfs_get(kn);
1044 dentry->d_fsdata = kn;
1045
1046
1047 inode = kernfs_get_inode(dir->i_sb, kn);
1048 if (!inode) {
1049 ret = ERR_PTR(-ENOMEM);
1050 goto out_unlock;
1051 }
1052
1053
1054 ret = d_splice_alias(inode, dentry);
1055 out_unlock:
1056 mutex_unlock(&kernfs_mutex);
1057 return ret;
1058}
1059
1060static int kernfs_iop_mkdir(struct inode *dir, struct dentry *dentry,
1061 umode_t mode)
1062{
1063 struct kernfs_node *parent = dir->i_private;
1064 struct kernfs_syscall_ops *scops = kernfs_root(parent)->syscall_ops;
1065 int ret;
1066
1067 if (!scops || !scops->mkdir)
1068 return -EPERM;
1069
1070 if (!kernfs_get_active(parent))
1071 return -ENODEV;
1072
1073 ret = scops->mkdir(parent, dentry->d_name.name, mode);
1074
1075 kernfs_put_active(parent);
1076 return ret;
1077}
1078
1079static int kernfs_iop_rmdir(struct inode *dir, struct dentry *dentry)
1080{
1081 struct kernfs_node *kn = dentry->d_fsdata;
1082 struct kernfs_syscall_ops *scops = kernfs_root(kn)->syscall_ops;
1083 int ret;
1084
1085 if (!scops || !scops->rmdir)
1086 return -EPERM;
1087
1088 if (!kernfs_get_active(kn))
1089 return -ENODEV;
1090
1091 ret = scops->rmdir(kn);
1092
1093 kernfs_put_active(kn);
1094 return ret;
1095}
1096
1097static int kernfs_iop_rename(struct inode *old_dir, struct dentry *old_dentry,
1098 struct inode *new_dir, struct dentry *new_dentry)
1099{
1100 struct kernfs_node *kn = old_dentry->d_fsdata;
1101 struct kernfs_node *new_parent = new_dir->i_private;
1102 struct kernfs_syscall_ops *scops = kernfs_root(kn)->syscall_ops;
1103 int ret;
1104
1105 if (!scops || !scops->rename)
1106 return -EPERM;
1107
1108 if (!kernfs_get_active(kn))
1109 return -ENODEV;
1110
1111 if (!kernfs_get_active(new_parent)) {
1112 kernfs_put_active(kn);
1113 return -ENODEV;
1114 }
1115
1116 ret = scops->rename(kn, new_parent, new_dentry->d_name.name);
1117
1118 kernfs_put_active(new_parent);
1119 kernfs_put_active(kn);
1120 return ret;
1121}
1122
1123const struct inode_operations kernfs_dir_iops = {
1124 .lookup = kernfs_iop_lookup,
1125 .permission = kernfs_iop_permission,
1126 .setattr = kernfs_iop_setattr,
1127 .getattr = kernfs_iop_getattr,
1128 .setxattr = kernfs_iop_setxattr,
1129 .removexattr = kernfs_iop_removexattr,
1130 .getxattr = kernfs_iop_getxattr,
1131 .listxattr = kernfs_iop_listxattr,
1132
1133 .mkdir = kernfs_iop_mkdir,
1134 .rmdir = kernfs_iop_rmdir,
1135 .rename = kernfs_iop_rename,
1136};
1137
1138static struct kernfs_node *kernfs_leftmost_descendant(struct kernfs_node *pos)
1139{
1140 struct kernfs_node *last;
1141
1142 while (true) {
1143 struct rb_node *rbn;
1144
1145 last = pos;
1146
1147 if (kernfs_type(pos) != KERNFS_DIR)
1148 break;
1149
1150 rbn = rb_first(&pos->dir.children);
1151 if (!rbn)
1152 break;
1153
1154 pos = rb_to_kn(rbn);
1155 }
1156
1157 return last;
1158}
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169static struct kernfs_node *kernfs_next_descendant_post(struct kernfs_node *pos,
1170 struct kernfs_node *root)
1171{
1172 struct rb_node *rbn;
1173
1174 lockdep_assert_held(&kernfs_mutex);
1175
1176
1177 if (!pos)
1178 return kernfs_leftmost_descendant(root);
1179
1180
1181 if (pos == root)
1182 return NULL;
1183
1184
1185 rbn = rb_next(&pos->rb);
1186 if (rbn)
1187 return kernfs_leftmost_descendant(rb_to_kn(rbn));
1188
1189
1190 return pos->parent;
1191}
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206void kernfs_activate(struct kernfs_node *kn)
1207{
1208 struct kernfs_node *pos;
1209
1210 mutex_lock(&kernfs_mutex);
1211
1212 pos = NULL;
1213 while ((pos = kernfs_next_descendant_post(pos, kn))) {
1214 if (!pos || (pos->flags & KERNFS_ACTIVATED))
1215 continue;
1216
1217 WARN_ON_ONCE(pos->parent && RB_EMPTY_NODE(&pos->rb));
1218 WARN_ON_ONCE(atomic_read(&pos->active) != KN_DEACTIVATED_BIAS);
1219
1220 atomic_sub(KN_DEACTIVATED_BIAS, &pos->active);
1221 pos->flags |= KERNFS_ACTIVATED;
1222 }
1223
1224 mutex_unlock(&kernfs_mutex);
1225}
1226
1227static void __kernfs_remove(struct kernfs_node *kn)
1228{
1229 struct kernfs_node *pos;
1230
1231 lockdep_assert_held(&kernfs_mutex);
1232
1233
1234
1235
1236
1237
1238 if (!kn || (kn->parent && RB_EMPTY_NODE(&kn->rb)))
1239 return;
1240
1241 pr_debug("kernfs %s: removing\n", kn->name);
1242
1243
1244 pos = NULL;
1245 while ((pos = kernfs_next_descendant_post(pos, kn)))
1246 if (kernfs_active(pos))
1247 atomic_add(KN_DEACTIVATED_BIAS, &pos->active);
1248
1249
1250 do {
1251 pos = kernfs_leftmost_descendant(kn);
1252
1253
1254
1255
1256
1257
1258
1259 kernfs_get(pos);
1260
1261
1262
1263
1264
1265
1266
1267 if (kn->flags & KERNFS_ACTIVATED)
1268 kernfs_drain(pos);
1269 else
1270 WARN_ON_ONCE(atomic_read(&kn->active) != KN_DEACTIVATED_BIAS);
1271
1272
1273
1274
1275
1276 if (!pos->parent || kernfs_unlink_sibling(pos)) {
1277 struct kernfs_iattrs *ps_iattr =
1278 pos->parent ? pos->parent->iattr : NULL;
1279
1280
1281 if (ps_iattr) {
1282 ps_iattr->ia_iattr.ia_ctime = CURRENT_TIME;
1283 ps_iattr->ia_iattr.ia_mtime = CURRENT_TIME;
1284 }
1285
1286 kernfs_put(pos);
1287 }
1288
1289 kernfs_put(pos);
1290 } while (pos != kn);
1291}
1292
1293
1294
1295
1296
1297
1298
1299void kernfs_remove(struct kernfs_node *kn)
1300{
1301 mutex_lock(&kernfs_mutex);
1302 __kernfs_remove(kn);
1303 mutex_unlock(&kernfs_mutex);
1304}
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320void kernfs_break_active_protection(struct kernfs_node *kn)
1321{
1322
1323
1324
1325
1326 kernfs_put_active(kn);
1327}
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343
1344void kernfs_unbreak_active_protection(struct kernfs_node *kn)
1345{
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355 atomic_inc(&kn->active);
1356 if (kernfs_lockdep(kn))
1357 rwsem_acquire(&kn->dep_map, 0, 1, _RET_IP_);
1358}
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386bool kernfs_remove_self(struct kernfs_node *kn)
1387{
1388 bool ret;
1389
1390 mutex_lock(&kernfs_mutex);
1391 kernfs_break_active_protection(kn);
1392
1393
1394
1395
1396
1397
1398
1399
1400
1401
1402 if (!(kn->flags & KERNFS_SUICIDAL)) {
1403 kn->flags |= KERNFS_SUICIDAL;
1404 __kernfs_remove(kn);
1405 kn->flags |= KERNFS_SUICIDED;
1406 ret = true;
1407 } else {
1408 wait_queue_head_t *waitq = &kernfs_root(kn)->deactivate_waitq;
1409 DEFINE_WAIT(wait);
1410
1411 while (true) {
1412 prepare_to_wait(waitq, &wait, TASK_UNINTERRUPTIBLE);
1413
1414 if ((kn->flags & KERNFS_SUICIDED) &&
1415 atomic_read(&kn->active) == KN_DEACTIVATED_BIAS)
1416 break;
1417
1418 mutex_unlock(&kernfs_mutex);
1419 schedule();
1420 mutex_lock(&kernfs_mutex);
1421 }
1422 finish_wait(waitq, &wait);
1423 WARN_ON_ONCE(!RB_EMPTY_NODE(&kn->rb));
1424 ret = false;
1425 }
1426
1427
1428
1429
1430
1431 kernfs_unbreak_active_protection(kn);
1432
1433 mutex_unlock(&kernfs_mutex);
1434 return ret;
1435}
1436
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446int kernfs_remove_by_name_ns(struct kernfs_node *parent, const char *name,
1447 const void *ns)
1448{
1449 struct kernfs_node *kn;
1450
1451 if (!parent) {
1452 WARN(1, KERN_WARNING "kernfs: can not remove '%s', no directory\n",
1453 name);
1454 return -ENOENT;
1455 }
1456
1457 mutex_lock(&kernfs_mutex);
1458
1459 kn = kernfs_find_ns(parent, name, ns);
1460 if (kn)
1461 __kernfs_remove(kn);
1462
1463 mutex_unlock(&kernfs_mutex);
1464
1465 if (kn)
1466 return 0;
1467 else
1468 return -ENOENT;
1469}
1470
1471
1472
1473
1474
1475
1476
1477
1478int kernfs_rename_ns(struct kernfs_node *kn, struct kernfs_node *new_parent,
1479 const char *new_name, const void *new_ns)
1480{
1481 struct kernfs_node *old_parent;
1482 const char *old_name = NULL;
1483 int error;
1484
1485
1486 if (!kn->parent)
1487 return -EINVAL;
1488
1489 mutex_lock(&kernfs_mutex);
1490
1491 error = -ENOENT;
1492 if (!kernfs_active(kn) || !kernfs_active(new_parent) ||
1493 (new_parent->flags & KERNFS_EMPTY_DIR))
1494 goto out;
1495
1496 error = 0;
1497 if ((kn->parent == new_parent) && (kn->ns == new_ns) &&
1498 (strcmp(kn->name, new_name) == 0))
1499 goto out;
1500
1501 error = -EEXIST;
1502 if (kernfs_find_ns(new_parent, new_name, new_ns))
1503 goto out;
1504
1505
1506 if (strcmp(kn->name, new_name) != 0) {
1507 error = -ENOMEM;
1508 new_name = kstrdup_const(new_name, GFP_KERNEL);
1509 if (!new_name)
1510 goto out;
1511 } else {
1512 new_name = NULL;
1513 }
1514
1515
1516
1517
1518 kernfs_unlink_sibling(kn);
1519 kernfs_get(new_parent);
1520
1521
1522 spin_lock_irq(&kernfs_rename_lock);
1523
1524 old_parent = kn->parent;
1525 kn->parent = new_parent;
1526
1527 kn->ns = new_ns;
1528 if (new_name) {
1529 old_name = kn->name;
1530 kn->name = new_name;
1531 }
1532
1533 spin_unlock_irq(&kernfs_rename_lock);
1534
1535 kn->hash = kernfs_name_hash(kn->name, kn->ns);
1536 kernfs_link_sibling(kn);
1537
1538 kernfs_put(old_parent);
1539 kfree_const(old_name);
1540
1541 error = 0;
1542 out:
1543 mutex_unlock(&kernfs_mutex);
1544 return error;
1545}
1546
1547
1548static inline unsigned char dt_type(struct kernfs_node *kn)
1549{
1550 return (kn->mode >> 12) & 15;
1551}
1552
1553static int kernfs_dir_fop_release(struct inode *inode, struct file *filp)
1554{
1555 kernfs_put(filp->private_data);
1556 return 0;
1557}
1558
1559static struct kernfs_node *kernfs_dir_pos(const void *ns,
1560 struct kernfs_node *parent, loff_t hash, struct kernfs_node *pos)
1561{
1562 if (pos) {
1563 int valid = kernfs_active(pos) &&
1564 pos->parent == parent && hash == pos->hash;
1565 kernfs_put(pos);
1566 if (!valid)
1567 pos = NULL;
1568 }
1569 if (!pos && (hash > 1) && (hash < INT_MAX)) {
1570 struct rb_node *node = parent->dir.children.rb_node;
1571 while (node) {
1572 pos = rb_to_kn(node);
1573
1574 if (hash < pos->hash)
1575 node = node->rb_left;
1576 else if (hash > pos->hash)
1577 node = node->rb_right;
1578 else
1579 break;
1580 }
1581 }
1582
1583 while (pos && (!kernfs_active(pos) || pos->ns != ns)) {
1584 struct rb_node *node = rb_next(&pos->rb);
1585 if (!node)
1586 pos = NULL;
1587 else
1588 pos = rb_to_kn(node);
1589 }
1590 return pos;
1591}
1592
1593static struct kernfs_node *kernfs_dir_next_pos(const void *ns,
1594 struct kernfs_node *parent, ino_t ino, struct kernfs_node *pos)
1595{
1596 pos = kernfs_dir_pos(ns, parent, ino, pos);
1597 if (pos) {
1598 do {
1599 struct rb_node *node = rb_next(&pos->rb);
1600 if (!node)
1601 pos = NULL;
1602 else
1603 pos = rb_to_kn(node);
1604 } while (pos && (!kernfs_active(pos) || pos->ns != ns));
1605 }
1606 return pos;
1607}
1608
1609static int kernfs_fop_readdir(struct file *file, struct dir_context *ctx)
1610{
1611 struct dentry *dentry = file->f_path.dentry;
1612 struct kernfs_node *parent = dentry->d_fsdata;
1613 struct kernfs_node *pos = file->private_data;
1614 const void *ns = NULL;
1615
1616 if (!dir_emit_dots(file, ctx))
1617 return 0;
1618 mutex_lock(&kernfs_mutex);
1619
1620 if (kernfs_ns_enabled(parent))
1621 ns = kernfs_info(dentry->d_sb)->ns;
1622
1623 for (pos = kernfs_dir_pos(ns, parent, ctx->pos, pos);
1624 pos;
1625 pos = kernfs_dir_next_pos(ns, parent, ctx->pos, pos)) {
1626 const char *name = pos->name;
1627 unsigned int type = dt_type(pos);
1628 int len = strlen(name);
1629 ino_t ino = pos->ino;
1630
1631 ctx->pos = pos->hash;
1632 file->private_data = pos;
1633 kernfs_get(pos);
1634
1635 mutex_unlock(&kernfs_mutex);
1636 if (!dir_emit(ctx, name, len, ino, type))
1637 return 0;
1638 mutex_lock(&kernfs_mutex);
1639 }
1640 mutex_unlock(&kernfs_mutex);
1641 file->private_data = NULL;
1642 ctx->pos = INT_MAX;
1643 return 0;
1644}
1645
1646static loff_t kernfs_dir_fop_llseek(struct file *file, loff_t offset,
1647 int whence)
1648{
1649 struct inode *inode = file_inode(file);
1650 loff_t ret;
1651
1652 inode_lock(inode);
1653 ret = generic_file_llseek(file, offset, whence);
1654 inode_unlock(inode);
1655
1656 return ret;
1657}
1658
1659const struct file_operations kernfs_dir_fops = {
1660 .read = generic_read_dir,
1661 .iterate = kernfs_fop_readdir,
1662 .release = kernfs_dir_fop_release,
1663 .llseek = kernfs_dir_fop_llseek,
1664};
1665