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