xref: /openbmc/linux/fs/kernfs/dir.c (revision bacf743e)
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * fs/kernfs/dir.c - kernfs directory implementation
4  *
5  * Copyright (c) 2001-3 Patrick Mochel
6  * Copyright (c) 2007 SUSE Linux Products GmbH
7  * Copyright (c) 2007, 2013 Tejun Heo <tj@kernel.org>
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 static DEFINE_SPINLOCK(kernfs_rename_lock);	/* kn->parent and ->name */
21 static char kernfs_pr_cont_buf[PATH_MAX];	/* protected by rename_lock */
22 static DEFINE_SPINLOCK(kernfs_idr_lock);	/* root->ino_idr */
23 
24 #define rb_to_kn(X) rb_entry((X), struct kernfs_node, rb)
25 
26 static bool kernfs_active(struct kernfs_node *kn)
27 {
28 	lockdep_assert_held(&kernfs_root(kn)->kernfs_rwsem);
29 	return atomic_read(&kn->active) >= 0;
30 }
31 
32 static bool kernfs_lockdep(struct kernfs_node *kn)
33 {
34 #ifdef CONFIG_DEBUG_LOCK_ALLOC
35 	return kn->flags & KERNFS_LOCKDEP;
36 #else
37 	return false;
38 #endif
39 }
40 
41 static int kernfs_name_locked(struct kernfs_node *kn, char *buf, size_t buflen)
42 {
43 	if (!kn)
44 		return strlcpy(buf, "(null)", buflen);
45 
46 	return strlcpy(buf, kn->parent ? kn->name : "/", buflen);
47 }
48 
49 /* kernfs_node_depth - compute depth from @from to @to */
50 static size_t kernfs_depth(struct kernfs_node *from, struct kernfs_node *to)
51 {
52 	size_t depth = 0;
53 
54 	while (to->parent && to != from) {
55 		depth++;
56 		to = to->parent;
57 	}
58 	return depth;
59 }
60 
61 static struct kernfs_node *kernfs_common_ancestor(struct kernfs_node *a,
62 						  struct kernfs_node *b)
63 {
64 	size_t da, db;
65 	struct kernfs_root *ra = kernfs_root(a), *rb = kernfs_root(b);
66 
67 	if (ra != rb)
68 		return NULL;
69 
70 	da = kernfs_depth(ra->kn, a);
71 	db = kernfs_depth(rb->kn, b);
72 
73 	while (da > db) {
74 		a = a->parent;
75 		da--;
76 	}
77 	while (db > da) {
78 		b = b->parent;
79 		db--;
80 	}
81 
82 	/* worst case b and a will be the same at root */
83 	while (b != a) {
84 		b = b->parent;
85 		a = a->parent;
86 	}
87 
88 	return a;
89 }
90 
91 /**
92  * kernfs_path_from_node_locked - find a pseudo-absolute path to @kn_to,
93  * where kn_from is treated as root of the path.
94  * @kn_from: kernfs node which should be treated as root for the path
95  * @kn_to: kernfs node to which path is needed
96  * @buf: buffer to copy the path into
97  * @buflen: size of @buf
98  *
99  * We need to handle couple of scenarios here:
100  * [1] when @kn_from is an ancestor of @kn_to at some level
101  * kn_from: /n1/n2/n3
102  * kn_to:   /n1/n2/n3/n4/n5
103  * result:  /n4/n5
104  *
105  * [2] when @kn_from is on a different hierarchy and we need to find common
106  * ancestor between @kn_from and @kn_to.
107  * kn_from: /n1/n2/n3/n4
108  * kn_to:   /n1/n2/n5
109  * result:  /../../n5
110  * OR
111  * kn_from: /n1/n2/n3/n4/n5   [depth=5]
112  * kn_to:   /n1/n2/n3         [depth=3]
113  * result:  /../..
114  *
115  * [3] when @kn_to is NULL result will be "(null)"
116  *
117  * Returns the length of the full path.  If the full length is equal to or
118  * greater than @buflen, @buf contains the truncated path with the trailing
119  * '\0'.  On error, -errno is returned.
120  */
121 static int kernfs_path_from_node_locked(struct kernfs_node *kn_to,
122 					struct kernfs_node *kn_from,
123 					char *buf, size_t buflen)
124 {
125 	struct kernfs_node *kn, *common;
126 	const char parent_str[] = "/..";
127 	size_t depth_from, depth_to, len = 0;
128 	int i, j;
129 
130 	if (!kn_to)
131 		return strlcpy(buf, "(null)", buflen);
132 
133 	if (!kn_from)
134 		kn_from = kernfs_root(kn_to)->kn;
135 
136 	if (kn_from == kn_to)
137 		return strlcpy(buf, "/", buflen);
138 
139 	if (!buf)
140 		return -EINVAL;
141 
142 	common = kernfs_common_ancestor(kn_from, kn_to);
143 	if (WARN_ON(!common))
144 		return -EINVAL;
145 
146 	depth_to = kernfs_depth(common, kn_to);
147 	depth_from = kernfs_depth(common, kn_from);
148 
149 	buf[0] = '\0';
150 
151 	for (i = 0; i < depth_from; i++)
152 		len += strlcpy(buf + len, parent_str,
153 			       len < buflen ? buflen - len : 0);
154 
155 	/* Calculate how many bytes we need for the rest */
156 	for (i = depth_to - 1; i >= 0; i--) {
157 		for (kn = kn_to, j = 0; j < i; j++)
158 			kn = kn->parent;
159 		len += strlcpy(buf + len, "/",
160 			       len < buflen ? buflen - len : 0);
161 		len += strlcpy(buf + len, kn->name,
162 			       len < buflen ? buflen - len : 0);
163 	}
164 
165 	return len;
166 }
167 
168 /**
169  * kernfs_name - obtain the name of a given node
170  * @kn: kernfs_node of interest
171  * @buf: buffer to copy @kn's name into
172  * @buflen: size of @buf
173  *
174  * Copies the name of @kn into @buf of @buflen bytes.  The behavior is
175  * similar to strlcpy().  It returns the length of @kn's name and if @buf
176  * isn't long enough, it's filled upto @buflen-1 and nul terminated.
177  *
178  * Fills buffer with "(null)" if @kn is NULL.
179  *
180  * This function can be called from any context.
181  */
182 int kernfs_name(struct kernfs_node *kn, char *buf, size_t buflen)
183 {
184 	unsigned long flags;
185 	int ret;
186 
187 	spin_lock_irqsave(&kernfs_rename_lock, flags);
188 	ret = kernfs_name_locked(kn, buf, buflen);
189 	spin_unlock_irqrestore(&kernfs_rename_lock, flags);
190 	return ret;
191 }
192 
193 /**
194  * kernfs_path_from_node - build path of node @to relative to @from.
195  * @from: parent kernfs_node relative to which we need to build the path
196  * @to: kernfs_node of interest
197  * @buf: buffer to copy @to's path into
198  * @buflen: size of @buf
199  *
200  * Builds @to's path relative to @from in @buf. @from and @to must
201  * be on the same kernfs-root. If @from is not parent of @to, then a relative
202  * path (which includes '..'s) as needed to reach from @from to @to is
203  * returned.
204  *
205  * Returns the length of the full path.  If the full length is equal to or
206  * greater than @buflen, @buf contains the truncated path with the trailing
207  * '\0'.  On error, -errno is returned.
208  */
209 int kernfs_path_from_node(struct kernfs_node *to, struct kernfs_node *from,
210 			  char *buf, size_t buflen)
211 {
212 	unsigned long flags;
213 	int ret;
214 
215 	spin_lock_irqsave(&kernfs_rename_lock, flags);
216 	ret = kernfs_path_from_node_locked(to, from, buf, buflen);
217 	spin_unlock_irqrestore(&kernfs_rename_lock, flags);
218 	return ret;
219 }
220 EXPORT_SYMBOL_GPL(kernfs_path_from_node);
221 
222 /**
223  * pr_cont_kernfs_name - pr_cont name of a kernfs_node
224  * @kn: kernfs_node of interest
225  *
226  * This function can be called from any context.
227  */
228 void pr_cont_kernfs_name(struct kernfs_node *kn)
229 {
230 	unsigned long flags;
231 
232 	spin_lock_irqsave(&kernfs_rename_lock, flags);
233 
234 	kernfs_name_locked(kn, kernfs_pr_cont_buf, sizeof(kernfs_pr_cont_buf));
235 	pr_cont("%s", kernfs_pr_cont_buf);
236 
237 	spin_unlock_irqrestore(&kernfs_rename_lock, flags);
238 }
239 
240 /**
241  * pr_cont_kernfs_path - pr_cont path of a kernfs_node
242  * @kn: kernfs_node of interest
243  *
244  * This function can be called from any context.
245  */
246 void pr_cont_kernfs_path(struct kernfs_node *kn)
247 {
248 	unsigned long flags;
249 	int sz;
250 
251 	spin_lock_irqsave(&kernfs_rename_lock, flags);
252 
253 	sz = kernfs_path_from_node_locked(kn, NULL, kernfs_pr_cont_buf,
254 					  sizeof(kernfs_pr_cont_buf));
255 	if (sz < 0) {
256 		pr_cont("(error)");
257 		goto out;
258 	}
259 
260 	if (sz >= sizeof(kernfs_pr_cont_buf)) {
261 		pr_cont("(name too long)");
262 		goto out;
263 	}
264 
265 	pr_cont("%s", kernfs_pr_cont_buf);
266 
267 out:
268 	spin_unlock_irqrestore(&kernfs_rename_lock, flags);
269 }
270 
271 /**
272  * kernfs_get_parent - determine the parent node and pin it
273  * @kn: kernfs_node of interest
274  *
275  * Determines @kn's parent, pins and returns it.  This function can be
276  * called from any context.
277  */
278 struct kernfs_node *kernfs_get_parent(struct kernfs_node *kn)
279 {
280 	struct kernfs_node *parent;
281 	unsigned long flags;
282 
283 	spin_lock_irqsave(&kernfs_rename_lock, flags);
284 	parent = kn->parent;
285 	kernfs_get(parent);
286 	spin_unlock_irqrestore(&kernfs_rename_lock, flags);
287 
288 	return parent;
289 }
290 
291 /**
292  *	kernfs_name_hash
293  *	@name: Null terminated string to hash
294  *	@ns:   Namespace tag to hash
295  *
296  *	Returns 31 bit hash of ns + name (so it fits in an off_t )
297  */
298 static unsigned int kernfs_name_hash(const char *name, const void *ns)
299 {
300 	unsigned long hash = init_name_hash(ns);
301 	unsigned int len = strlen(name);
302 	while (len--)
303 		hash = partial_name_hash(*name++, hash);
304 	hash = end_name_hash(hash);
305 	hash &= 0x7fffffffU;
306 	/* Reserve hash numbers 0, 1 and INT_MAX for magic directory entries */
307 	if (hash < 2)
308 		hash += 2;
309 	if (hash >= INT_MAX)
310 		hash = INT_MAX - 1;
311 	return hash;
312 }
313 
314 static int kernfs_name_compare(unsigned int hash, const char *name,
315 			       const void *ns, const struct kernfs_node *kn)
316 {
317 	if (hash < kn->hash)
318 		return -1;
319 	if (hash > kn->hash)
320 		return 1;
321 	if (ns < kn->ns)
322 		return -1;
323 	if (ns > kn->ns)
324 		return 1;
325 	return strcmp(name, kn->name);
326 }
327 
328 static int kernfs_sd_compare(const struct kernfs_node *left,
329 			     const struct kernfs_node *right)
330 {
331 	return kernfs_name_compare(left->hash, left->name, left->ns, right);
332 }
333 
334 /**
335  *	kernfs_link_sibling - link kernfs_node into sibling rbtree
336  *	@kn: kernfs_node of interest
337  *
338  *	Link @kn into its sibling rbtree which starts from
339  *	@kn->parent->dir.children.
340  *
341  *	Locking:
342  *	kernfs_rwsem held exclusive
343  *
344  *	RETURNS:
345  *	0 on susccess -EEXIST on failure.
346  */
347 static int kernfs_link_sibling(struct kernfs_node *kn)
348 {
349 	struct rb_node **node = &kn->parent->dir.children.rb_node;
350 	struct rb_node *parent = NULL;
351 
352 	while (*node) {
353 		struct kernfs_node *pos;
354 		int result;
355 
356 		pos = rb_to_kn(*node);
357 		parent = *node;
358 		result = kernfs_sd_compare(kn, pos);
359 		if (result < 0)
360 			node = &pos->rb.rb_left;
361 		else if (result > 0)
362 			node = &pos->rb.rb_right;
363 		else
364 			return -EEXIST;
365 	}
366 
367 	/* add new node and rebalance the tree */
368 	rb_link_node(&kn->rb, parent, node);
369 	rb_insert_color(&kn->rb, &kn->parent->dir.children);
370 
371 	/* successfully added, account subdir number */
372 	if (kernfs_type(kn) == KERNFS_DIR)
373 		kn->parent->dir.subdirs++;
374 	kernfs_inc_rev(kn->parent);
375 
376 	return 0;
377 }
378 
379 /**
380  *	kernfs_unlink_sibling - unlink kernfs_node from sibling rbtree
381  *	@kn: kernfs_node of interest
382  *
383  *	Try to unlink @kn from its sibling rbtree which starts from
384  *	kn->parent->dir.children.  Returns %true if @kn was actually
385  *	removed, %false if @kn wasn't on the rbtree.
386  *
387  *	Locking:
388  *	kernfs_rwsem held exclusive
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 	kernfs_inc_rev(kn->parent);
398 
399 	rb_erase(&kn->rb, &kn->parent->dir.children);
400 	RB_CLEAR_NODE(&kn->rb);
401 	return true;
402 }
403 
404 /**
405  *	kernfs_get_active - get an active reference to kernfs_node
406  *	@kn: kernfs_node to get an active reference to
407  *
408  *	Get an active reference of @kn.  This function is noop if @kn
409  *	is NULL.
410  *
411  *	RETURNS:
412  *	Pointer to @kn on success, NULL on failure.
413  */
414 struct kernfs_node *kernfs_get_active(struct kernfs_node *kn)
415 {
416 	if (unlikely(!kn))
417 		return NULL;
418 
419 	if (!atomic_inc_unless_negative(&kn->active))
420 		return NULL;
421 
422 	if (kernfs_lockdep(kn))
423 		rwsem_acquire_read(&kn->dep_map, 0, 1, _RET_IP_);
424 	return kn;
425 }
426 
427 /**
428  *	kernfs_put_active - put an active reference to kernfs_node
429  *	@kn: kernfs_node to put an active reference to
430  *
431  *	Put an active reference to @kn.  This function is noop if @kn
432  *	is NULL.
433  */
434 void kernfs_put_active(struct kernfs_node *kn)
435 {
436 	int v;
437 
438 	if (unlikely(!kn))
439 		return;
440 
441 	if (kernfs_lockdep(kn))
442 		rwsem_release(&kn->dep_map, _RET_IP_);
443 	v = atomic_dec_return(&kn->active);
444 	if (likely(v != KN_DEACTIVATED_BIAS))
445 		return;
446 
447 	wake_up_all(&kernfs_root(kn)->deactivate_waitq);
448 }
449 
450 /**
451  * kernfs_drain - drain kernfs_node
452  * @kn: kernfs_node to drain
453  *
454  * Drain existing usages and nuke all existing mmaps of @kn.  Mutiple
455  * removers may invoke this function concurrently on @kn and all will
456  * return after draining is complete.
457  */
458 static void kernfs_drain(struct kernfs_node *kn)
459 	__releases(&kernfs_root(kn)->kernfs_rwsem)
460 	__acquires(&kernfs_root(kn)->kernfs_rwsem)
461 {
462 	struct kernfs_root *root = kernfs_root(kn);
463 
464 	lockdep_assert_held_write(&root->kernfs_rwsem);
465 	WARN_ON_ONCE(kernfs_active(kn));
466 
467 	up_write(&root->kernfs_rwsem);
468 
469 	if (kernfs_lockdep(kn)) {
470 		rwsem_acquire(&kn->dep_map, 0, 0, _RET_IP_);
471 		if (atomic_read(&kn->active) != KN_DEACTIVATED_BIAS)
472 			lock_contended(&kn->dep_map, _RET_IP_);
473 	}
474 
475 	/* but everyone should wait for draining */
476 	wait_event(root->deactivate_waitq,
477 		   atomic_read(&kn->active) == KN_DEACTIVATED_BIAS);
478 
479 	if (kernfs_lockdep(kn)) {
480 		lock_acquired(&kn->dep_map, _RET_IP_);
481 		rwsem_release(&kn->dep_map, _RET_IP_);
482 	}
483 
484 	kernfs_drain_open_files(kn);
485 
486 	down_write(&root->kernfs_rwsem);
487 }
488 
489 /**
490  * kernfs_get - get a reference count on a kernfs_node
491  * @kn: the target kernfs_node
492  */
493 void kernfs_get(struct kernfs_node *kn)
494 {
495 	if (kn) {
496 		WARN_ON(!atomic_read(&kn->count));
497 		atomic_inc(&kn->count);
498 	}
499 }
500 EXPORT_SYMBOL_GPL(kernfs_get);
501 
502 /**
503  * kernfs_put - put a reference count on a kernfs_node
504  * @kn: the target kernfs_node
505  *
506  * Put a reference count of @kn and destroy it if it reached zero.
507  */
508 void kernfs_put(struct kernfs_node *kn)
509 {
510 	struct kernfs_node *parent;
511 	struct kernfs_root *root;
512 
513 	if (!kn || !atomic_dec_and_test(&kn->count))
514 		return;
515 	root = kernfs_root(kn);
516  repeat:
517 	/*
518 	 * Moving/renaming is always done while holding reference.
519 	 * kn->parent won't change beneath us.
520 	 */
521 	parent = kn->parent;
522 
523 	WARN_ONCE(atomic_read(&kn->active) != KN_DEACTIVATED_BIAS,
524 		  "kernfs_put: %s/%s: released with incorrect active_ref %d\n",
525 		  parent ? parent->name : "", kn->name, atomic_read(&kn->active));
526 
527 	if (kernfs_type(kn) == KERNFS_LINK)
528 		kernfs_put(kn->symlink.target_kn);
529 
530 	kfree_const(kn->name);
531 
532 	if (kn->iattr) {
533 		simple_xattrs_free(&kn->iattr->xattrs);
534 		kmem_cache_free(kernfs_iattrs_cache, kn->iattr);
535 	}
536 	spin_lock(&kernfs_idr_lock);
537 	idr_remove(&root->ino_idr, (u32)kernfs_ino(kn));
538 	spin_unlock(&kernfs_idr_lock);
539 	kmem_cache_free(kernfs_node_cache, kn);
540 
541 	kn = parent;
542 	if (kn) {
543 		if (atomic_dec_and_test(&kn->count))
544 			goto repeat;
545 	} else {
546 		/* just released the root kn, free @root too */
547 		idr_destroy(&root->ino_idr);
548 		kfree(root);
549 	}
550 }
551 EXPORT_SYMBOL_GPL(kernfs_put);
552 
553 /**
554  * kernfs_node_from_dentry - determine kernfs_node associated with a dentry
555  * @dentry: the dentry in question
556  *
557  * Return the kernfs_node associated with @dentry.  If @dentry is not a
558  * kernfs one, %NULL is returned.
559  *
560  * While the returned kernfs_node will stay accessible as long as @dentry
561  * is accessible, the returned node can be in any state and the caller is
562  * fully responsible for determining what's accessible.
563  */
564 struct kernfs_node *kernfs_node_from_dentry(struct dentry *dentry)
565 {
566 	if (dentry->d_sb->s_op == &kernfs_sops)
567 		return kernfs_dentry_node(dentry);
568 	return NULL;
569 }
570 
571 static struct kernfs_node *__kernfs_new_node(struct kernfs_root *root,
572 					     struct kernfs_node *parent,
573 					     const char *name, umode_t mode,
574 					     kuid_t uid, kgid_t gid,
575 					     unsigned flags)
576 {
577 	struct kernfs_node *kn;
578 	u32 id_highbits;
579 	int ret;
580 
581 	name = kstrdup_const(name, GFP_KERNEL);
582 	if (!name)
583 		return NULL;
584 
585 	kn = kmem_cache_zalloc(kernfs_node_cache, GFP_KERNEL);
586 	if (!kn)
587 		goto err_out1;
588 
589 	idr_preload(GFP_KERNEL);
590 	spin_lock(&kernfs_idr_lock);
591 	ret = idr_alloc_cyclic(&root->ino_idr, kn, 1, 0, GFP_ATOMIC);
592 	if (ret >= 0 && ret < root->last_id_lowbits)
593 		root->id_highbits++;
594 	id_highbits = root->id_highbits;
595 	root->last_id_lowbits = ret;
596 	spin_unlock(&kernfs_idr_lock);
597 	idr_preload_end();
598 	if (ret < 0)
599 		goto err_out2;
600 
601 	kn->id = (u64)id_highbits << 32 | ret;
602 
603 	atomic_set(&kn->count, 1);
604 	atomic_set(&kn->active, KN_DEACTIVATED_BIAS);
605 	RB_CLEAR_NODE(&kn->rb);
606 
607 	kn->name = name;
608 	kn->mode = mode;
609 	kn->flags = flags;
610 
611 	if (!uid_eq(uid, GLOBAL_ROOT_UID) || !gid_eq(gid, GLOBAL_ROOT_GID)) {
612 		struct iattr iattr = {
613 			.ia_valid = ATTR_UID | ATTR_GID,
614 			.ia_uid = uid,
615 			.ia_gid = gid,
616 		};
617 
618 		ret = __kernfs_setattr(kn, &iattr);
619 		if (ret < 0)
620 			goto err_out3;
621 	}
622 
623 	if (parent) {
624 		ret = security_kernfs_init_security(parent, kn);
625 		if (ret)
626 			goto err_out3;
627 	}
628 
629 	return kn;
630 
631  err_out3:
632 	idr_remove(&root->ino_idr, (u32)kernfs_ino(kn));
633  err_out2:
634 	kmem_cache_free(kernfs_node_cache, kn);
635  err_out1:
636 	kfree_const(name);
637 	return NULL;
638 }
639 
640 struct kernfs_node *kernfs_new_node(struct kernfs_node *parent,
641 				    const char *name, umode_t mode,
642 				    kuid_t uid, kgid_t gid,
643 				    unsigned flags)
644 {
645 	struct kernfs_node *kn;
646 
647 	kn = __kernfs_new_node(kernfs_root(parent), parent,
648 			       name, mode, uid, gid, flags);
649 	if (kn) {
650 		kernfs_get(parent);
651 		kn->parent = parent;
652 	}
653 	return kn;
654 }
655 
656 /*
657  * kernfs_find_and_get_node_by_id - get kernfs_node from node id
658  * @root: the kernfs root
659  * @id: the target node id
660  *
661  * @id's lower 32bits encode ino and upper gen.  If the gen portion is
662  * zero, all generations are matched.
663  *
664  * RETURNS:
665  * NULL on failure. Return a kernfs node with reference counter incremented
666  */
667 struct kernfs_node *kernfs_find_and_get_node_by_id(struct kernfs_root *root,
668 						   u64 id)
669 {
670 	struct kernfs_node *kn;
671 	ino_t ino = kernfs_id_ino(id);
672 	u32 gen = kernfs_id_gen(id);
673 
674 	spin_lock(&kernfs_idr_lock);
675 
676 	kn = idr_find(&root->ino_idr, (u32)ino);
677 	if (!kn)
678 		goto err_unlock;
679 
680 	if (sizeof(ino_t) >= sizeof(u64)) {
681 		/* we looked up with the low 32bits, compare the whole */
682 		if (kernfs_ino(kn) != ino)
683 			goto err_unlock;
684 	} else {
685 		/* 0 matches all generations */
686 		if (unlikely(gen && kernfs_gen(kn) != gen))
687 			goto err_unlock;
688 	}
689 
690 	/*
691 	 * ACTIVATED is protected with kernfs_mutex but it was clear when
692 	 * @kn was added to idr and we just wanna see it set.  No need to
693 	 * grab kernfs_mutex.
694 	 */
695 	if (unlikely(!(kn->flags & KERNFS_ACTIVATED) ||
696 		     !atomic_inc_not_zero(&kn->count)))
697 		goto err_unlock;
698 
699 	spin_unlock(&kernfs_idr_lock);
700 	return kn;
701 err_unlock:
702 	spin_unlock(&kernfs_idr_lock);
703 	return NULL;
704 }
705 
706 /**
707  *	kernfs_add_one - add kernfs_node to parent without warning
708  *	@kn: kernfs_node to be added
709  *
710  *	The caller must already have initialized @kn->parent.  This
711  *	function increments nlink of the parent's inode if @kn is a
712  *	directory and link into the children list of the parent.
713  *
714  *	RETURNS:
715  *	0 on success, -EEXIST if entry with the given name already
716  *	exists.
717  */
718 int kernfs_add_one(struct kernfs_node *kn)
719 {
720 	struct kernfs_node *parent = kn->parent;
721 	struct kernfs_root *root = kernfs_root(parent);
722 	struct kernfs_iattrs *ps_iattr;
723 	bool has_ns;
724 	int ret;
725 
726 	down_write(&root->kernfs_rwsem);
727 
728 	ret = -EINVAL;
729 	has_ns = kernfs_ns_enabled(parent);
730 	if (WARN(has_ns != (bool)kn->ns, KERN_WARNING "kernfs: ns %s in '%s' for '%s'\n",
731 		 has_ns ? "required" : "invalid", parent->name, kn->name))
732 		goto out_unlock;
733 
734 	if (kernfs_type(parent) != KERNFS_DIR)
735 		goto out_unlock;
736 
737 	ret = -ENOENT;
738 	if (parent->flags & KERNFS_EMPTY_DIR)
739 		goto out_unlock;
740 
741 	if ((parent->flags & KERNFS_ACTIVATED) && !kernfs_active(parent))
742 		goto out_unlock;
743 
744 	kn->hash = kernfs_name_hash(kn->name, kn->ns);
745 
746 	ret = kernfs_link_sibling(kn);
747 	if (ret)
748 		goto out_unlock;
749 
750 	/* Update timestamps on the parent */
751 	ps_iattr = parent->iattr;
752 	if (ps_iattr) {
753 		ktime_get_real_ts64(&ps_iattr->ia_ctime);
754 		ps_iattr->ia_mtime = ps_iattr->ia_ctime;
755 	}
756 
757 	up_write(&root->kernfs_rwsem);
758 
759 	/*
760 	 * Activate the new node unless CREATE_DEACTIVATED is requested.
761 	 * If not activated here, the kernfs user is responsible for
762 	 * activating the node with kernfs_activate().  A node which hasn't
763 	 * been activated is not visible to userland and its removal won't
764 	 * trigger deactivation.
765 	 */
766 	if (!(kernfs_root(kn)->flags & KERNFS_ROOT_CREATE_DEACTIVATED))
767 		kernfs_activate(kn);
768 	return 0;
769 
770 out_unlock:
771 	up_write(&root->kernfs_rwsem);
772 	return ret;
773 }
774 
775 /**
776  * kernfs_find_ns - find kernfs_node with the given name
777  * @parent: kernfs_node to search under
778  * @name: name to look for
779  * @ns: the namespace tag to use
780  *
781  * Look for kernfs_node with name @name under @parent.  Returns pointer to
782  * the found kernfs_node on success, %NULL on failure.
783  */
784 static struct kernfs_node *kernfs_find_ns(struct kernfs_node *parent,
785 					  const unsigned char *name,
786 					  const void *ns)
787 {
788 	struct rb_node *node = parent->dir.children.rb_node;
789 	bool has_ns = kernfs_ns_enabled(parent);
790 	unsigned int hash;
791 
792 	lockdep_assert_held(&kernfs_root(parent)->kernfs_rwsem);
793 
794 	if (has_ns != (bool)ns) {
795 		WARN(1, KERN_WARNING "kernfs: ns %s in '%s' for '%s'\n",
796 		     has_ns ? "required" : "invalid", parent->name, name);
797 		return NULL;
798 	}
799 
800 	hash = kernfs_name_hash(name, ns);
801 	while (node) {
802 		struct kernfs_node *kn;
803 		int result;
804 
805 		kn = rb_to_kn(node);
806 		result = kernfs_name_compare(hash, name, ns, kn);
807 		if (result < 0)
808 			node = node->rb_left;
809 		else if (result > 0)
810 			node = node->rb_right;
811 		else
812 			return kn;
813 	}
814 	return NULL;
815 }
816 
817 static struct kernfs_node *kernfs_walk_ns(struct kernfs_node *parent,
818 					  const unsigned char *path,
819 					  const void *ns)
820 {
821 	size_t len;
822 	char *p, *name;
823 
824 	lockdep_assert_held_read(&kernfs_root(parent)->kernfs_rwsem);
825 
826 	/* grab kernfs_rename_lock to piggy back on kernfs_pr_cont_buf */
827 	spin_lock_irq(&kernfs_rename_lock);
828 
829 	len = strlcpy(kernfs_pr_cont_buf, path, sizeof(kernfs_pr_cont_buf));
830 
831 	if (len >= sizeof(kernfs_pr_cont_buf)) {
832 		spin_unlock_irq(&kernfs_rename_lock);
833 		return NULL;
834 	}
835 
836 	p = kernfs_pr_cont_buf;
837 
838 	while ((name = strsep(&p, "/")) && parent) {
839 		if (*name == '\0')
840 			continue;
841 		parent = kernfs_find_ns(parent, name, ns);
842 	}
843 
844 	spin_unlock_irq(&kernfs_rename_lock);
845 
846 	return parent;
847 }
848 
849 /**
850  * kernfs_find_and_get_ns - find and get kernfs_node with the given name
851  * @parent: kernfs_node to search under
852  * @name: name to look for
853  * @ns: the namespace tag to use
854  *
855  * Look for kernfs_node with name @name under @parent and get a reference
856  * if found.  This function may sleep and returns pointer to the found
857  * kernfs_node on success, %NULL on failure.
858  */
859 struct kernfs_node *kernfs_find_and_get_ns(struct kernfs_node *parent,
860 					   const char *name, const void *ns)
861 {
862 	struct kernfs_node *kn;
863 	struct kernfs_root *root = kernfs_root(parent);
864 
865 	down_read(&root->kernfs_rwsem);
866 	kn = kernfs_find_ns(parent, name, ns);
867 	kernfs_get(kn);
868 	up_read(&root->kernfs_rwsem);
869 
870 	return kn;
871 }
872 EXPORT_SYMBOL_GPL(kernfs_find_and_get_ns);
873 
874 /**
875  * kernfs_walk_and_get_ns - find and get kernfs_node with the given path
876  * @parent: kernfs_node to search under
877  * @path: path to look for
878  * @ns: the namespace tag to use
879  *
880  * Look for kernfs_node with path @path under @parent and get a reference
881  * if found.  This function may sleep and returns pointer to the found
882  * kernfs_node on success, %NULL on failure.
883  */
884 struct kernfs_node *kernfs_walk_and_get_ns(struct kernfs_node *parent,
885 					   const char *path, const void *ns)
886 {
887 	struct kernfs_node *kn;
888 	struct kernfs_root *root = kernfs_root(parent);
889 
890 	down_read(&root->kernfs_rwsem);
891 	kn = kernfs_walk_ns(parent, path, ns);
892 	kernfs_get(kn);
893 	up_read(&root->kernfs_rwsem);
894 
895 	return kn;
896 }
897 
898 /**
899  * kernfs_create_root - create a new kernfs hierarchy
900  * @scops: optional syscall operations for the hierarchy
901  * @flags: KERNFS_ROOT_* flags
902  * @priv: opaque data associated with the new directory
903  *
904  * Returns the root of the new hierarchy on success, ERR_PTR() value on
905  * failure.
906  */
907 struct 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 	idr_init(&root->ino_idr);
918 	init_rwsem(&root->kernfs_rwsem);
919 	INIT_LIST_HEAD(&root->supers);
920 
921 	/*
922 	 * On 64bit ino setups, id is ino.  On 32bit, low 32bits are ino.
923 	 * High bits generation.  The starting value for both ino and
924 	 * genenration is 1.  Initialize upper 32bit allocation
925 	 * accordingly.
926 	 */
927 	if (sizeof(ino_t) >= sizeof(u64))
928 		root->id_highbits = 0;
929 	else
930 		root->id_highbits = 1;
931 
932 	kn = __kernfs_new_node(root, NULL, "", S_IFDIR | S_IRUGO | S_IXUGO,
933 			       GLOBAL_ROOT_UID, GLOBAL_ROOT_GID,
934 			       KERNFS_DIR);
935 	if (!kn) {
936 		idr_destroy(&root->ino_idr);
937 		kfree(root);
938 		return ERR_PTR(-ENOMEM);
939 	}
940 
941 	kn->priv = priv;
942 	kn->dir.root = root;
943 
944 	root->syscall_ops = scops;
945 	root->flags = flags;
946 	root->kn = kn;
947 	init_waitqueue_head(&root->deactivate_waitq);
948 
949 	if (!(root->flags & KERNFS_ROOT_CREATE_DEACTIVATED))
950 		kernfs_activate(kn);
951 
952 	return root;
953 }
954 
955 /**
956  * kernfs_destroy_root - destroy a kernfs hierarchy
957  * @root: root of the hierarchy to destroy
958  *
959  * Destroy the hierarchy anchored at @root by removing all existing
960  * directories and destroying @root.
961  */
962 void kernfs_destroy_root(struct kernfs_root *root)
963 {
964 	/*
965 	 *  kernfs_remove holds kernfs_rwsem from the root so the root
966 	 *  shouldn't be freed during the operation.
967 	 */
968 	kernfs_get(root->kn);
969 	kernfs_remove(root->kn);
970 	kernfs_put(root->kn); /* will also free @root */
971 }
972 
973 /**
974  * kernfs_root_to_node - return the kernfs_node associated with a kernfs_root
975  * @root: root to use to lookup
976  */
977 struct kernfs_node *kernfs_root_to_node(struct kernfs_root *root)
978 {
979 	return root->kn;
980 }
981 
982 /**
983  * kernfs_create_dir_ns - create a directory
984  * @parent: parent in which to create a new directory
985  * @name: name of the new directory
986  * @mode: mode of the new directory
987  * @uid: uid of the new directory
988  * @gid: gid of the new directory
989  * @priv: opaque data associated with the new directory
990  * @ns: optional namespace tag of the directory
991  *
992  * Returns the created node on success, ERR_PTR() value on failure.
993  */
994 struct kernfs_node *kernfs_create_dir_ns(struct kernfs_node *parent,
995 					 const char *name, umode_t mode,
996 					 kuid_t uid, kgid_t gid,
997 					 void *priv, const void *ns)
998 {
999 	struct kernfs_node *kn;
1000 	int rc;
1001 
1002 	/* allocate */
1003 	kn = kernfs_new_node(parent, name, mode | S_IFDIR,
1004 			     uid, gid, KERNFS_DIR);
1005 	if (!kn)
1006 		return ERR_PTR(-ENOMEM);
1007 
1008 	kn->dir.root = parent->dir.root;
1009 	kn->ns = ns;
1010 	kn->priv = priv;
1011 
1012 	/* link in */
1013 	rc = kernfs_add_one(kn);
1014 	if (!rc)
1015 		return kn;
1016 
1017 	kernfs_put(kn);
1018 	return ERR_PTR(rc);
1019 }
1020 
1021 /**
1022  * kernfs_create_empty_dir - create an always empty directory
1023  * @parent: parent in which to create a new directory
1024  * @name: name of the new directory
1025  *
1026  * Returns the created node on success, ERR_PTR() value on failure.
1027  */
1028 struct kernfs_node *kernfs_create_empty_dir(struct kernfs_node *parent,
1029 					    const char *name)
1030 {
1031 	struct kernfs_node *kn;
1032 	int rc;
1033 
1034 	/* allocate */
1035 	kn = kernfs_new_node(parent, name, S_IRUGO|S_IXUGO|S_IFDIR,
1036 			     GLOBAL_ROOT_UID, GLOBAL_ROOT_GID, KERNFS_DIR);
1037 	if (!kn)
1038 		return ERR_PTR(-ENOMEM);
1039 
1040 	kn->flags |= KERNFS_EMPTY_DIR;
1041 	kn->dir.root = parent->dir.root;
1042 	kn->ns = NULL;
1043 	kn->priv = NULL;
1044 
1045 	/* link in */
1046 	rc = kernfs_add_one(kn);
1047 	if (!rc)
1048 		return kn;
1049 
1050 	kernfs_put(kn);
1051 	return ERR_PTR(rc);
1052 }
1053 
1054 static int kernfs_dop_revalidate(struct dentry *dentry, unsigned int flags)
1055 {
1056 	struct kernfs_node *kn;
1057 	struct kernfs_root *root;
1058 
1059 	if (flags & LOOKUP_RCU)
1060 		return -ECHILD;
1061 
1062 	/* Negative hashed dentry? */
1063 	if (d_really_is_negative(dentry)) {
1064 		struct kernfs_node *parent;
1065 
1066 		/* If the kernfs parent node has changed discard and
1067 		 * proceed to ->lookup.
1068 		 */
1069 		spin_lock(&dentry->d_lock);
1070 		parent = kernfs_dentry_node(dentry->d_parent);
1071 		if (parent) {
1072 			spin_unlock(&dentry->d_lock);
1073 			root = kernfs_root(parent);
1074 			down_read(&root->kernfs_rwsem);
1075 			if (kernfs_dir_changed(parent, dentry)) {
1076 				up_read(&root->kernfs_rwsem);
1077 				return 0;
1078 			}
1079 			up_read(&root->kernfs_rwsem);
1080 		} else
1081 			spin_unlock(&dentry->d_lock);
1082 
1083 		/* The kernfs parent node hasn't changed, leave the
1084 		 * dentry negative and return success.
1085 		 */
1086 		return 1;
1087 	}
1088 
1089 	kn = kernfs_dentry_node(dentry);
1090 	root = kernfs_root(kn);
1091 	down_read(&root->kernfs_rwsem);
1092 
1093 	/* The kernfs node has been deactivated */
1094 	if (!kernfs_active(kn))
1095 		goto out_bad;
1096 
1097 	/* The kernfs node has been moved? */
1098 	if (kernfs_dentry_node(dentry->d_parent) != kn->parent)
1099 		goto out_bad;
1100 
1101 	/* The kernfs node has been renamed */
1102 	if (strcmp(dentry->d_name.name, kn->name) != 0)
1103 		goto out_bad;
1104 
1105 	/* The kernfs node has been moved to a different namespace */
1106 	if (kn->parent && kernfs_ns_enabled(kn->parent) &&
1107 	    kernfs_info(dentry->d_sb)->ns != kn->ns)
1108 		goto out_bad;
1109 
1110 	up_read(&root->kernfs_rwsem);
1111 	return 1;
1112 out_bad:
1113 	up_read(&root->kernfs_rwsem);
1114 	return 0;
1115 }
1116 
1117 const struct dentry_operations kernfs_dops = {
1118 	.d_revalidate	= kernfs_dop_revalidate,
1119 };
1120 
1121 static struct dentry *kernfs_iop_lookup(struct inode *dir,
1122 					struct dentry *dentry,
1123 					unsigned int flags)
1124 {
1125 	struct kernfs_node *parent = dir->i_private;
1126 	struct kernfs_node *kn;
1127 	struct kernfs_root *root;
1128 	struct inode *inode = NULL;
1129 	const void *ns = NULL;
1130 
1131 	root = kernfs_root(parent);
1132 	down_read(&root->kernfs_rwsem);
1133 	if (kernfs_ns_enabled(parent))
1134 		ns = kernfs_info(dir->i_sb)->ns;
1135 
1136 	kn = kernfs_find_ns(parent, dentry->d_name.name, ns);
1137 	/* attach dentry and inode */
1138 	if (kn) {
1139 		/* Inactive nodes are invisible to the VFS so don't
1140 		 * create a negative.
1141 		 */
1142 		if (!kernfs_active(kn)) {
1143 			up_read(&root->kernfs_rwsem);
1144 			return NULL;
1145 		}
1146 		inode = kernfs_get_inode(dir->i_sb, kn);
1147 		if (!inode)
1148 			inode = ERR_PTR(-ENOMEM);
1149 	}
1150 	/*
1151 	 * Needed for negative dentry validation.
1152 	 * The negative dentry can be created in kernfs_iop_lookup()
1153 	 * or transforms from positive dentry in dentry_unlink_inode()
1154 	 * called from vfs_rmdir().
1155 	 */
1156 	if (!IS_ERR(inode))
1157 		kernfs_set_rev(parent, dentry);
1158 	up_read(&root->kernfs_rwsem);
1159 
1160 	/* instantiate and hash (possibly negative) dentry */
1161 	return d_splice_alias(inode, dentry);
1162 }
1163 
1164 static int kernfs_iop_mkdir(struct user_namespace *mnt_userns,
1165 			    struct inode *dir, struct dentry *dentry,
1166 			    umode_t mode)
1167 {
1168 	struct kernfs_node *parent = dir->i_private;
1169 	struct kernfs_syscall_ops *scops = kernfs_root(parent)->syscall_ops;
1170 	int ret;
1171 
1172 	if (!scops || !scops->mkdir)
1173 		return -EPERM;
1174 
1175 	if (!kernfs_get_active(parent))
1176 		return -ENODEV;
1177 
1178 	ret = scops->mkdir(parent, dentry->d_name.name, mode);
1179 
1180 	kernfs_put_active(parent);
1181 	return ret;
1182 }
1183 
1184 static int kernfs_iop_rmdir(struct inode *dir, struct dentry *dentry)
1185 {
1186 	struct kernfs_node *kn  = kernfs_dentry_node(dentry);
1187 	struct kernfs_syscall_ops *scops = kernfs_root(kn)->syscall_ops;
1188 	int ret;
1189 
1190 	if (!scops || !scops->rmdir)
1191 		return -EPERM;
1192 
1193 	if (!kernfs_get_active(kn))
1194 		return -ENODEV;
1195 
1196 	ret = scops->rmdir(kn);
1197 
1198 	kernfs_put_active(kn);
1199 	return ret;
1200 }
1201 
1202 static int kernfs_iop_rename(struct user_namespace *mnt_userns,
1203 			     struct inode *old_dir, struct dentry *old_dentry,
1204 			     struct inode *new_dir, struct dentry *new_dentry,
1205 			     unsigned int flags)
1206 {
1207 	struct kernfs_node *kn = kernfs_dentry_node(old_dentry);
1208 	struct kernfs_node *new_parent = new_dir->i_private;
1209 	struct kernfs_syscall_ops *scops = kernfs_root(kn)->syscall_ops;
1210 	int ret;
1211 
1212 	if (flags)
1213 		return -EINVAL;
1214 
1215 	if (!scops || !scops->rename)
1216 		return -EPERM;
1217 
1218 	if (!kernfs_get_active(kn))
1219 		return -ENODEV;
1220 
1221 	if (!kernfs_get_active(new_parent)) {
1222 		kernfs_put_active(kn);
1223 		return -ENODEV;
1224 	}
1225 
1226 	ret = scops->rename(kn, new_parent, new_dentry->d_name.name);
1227 
1228 	kernfs_put_active(new_parent);
1229 	kernfs_put_active(kn);
1230 	return ret;
1231 }
1232 
1233 const struct inode_operations kernfs_dir_iops = {
1234 	.lookup		= kernfs_iop_lookup,
1235 	.permission	= kernfs_iop_permission,
1236 	.setattr	= kernfs_iop_setattr,
1237 	.getattr	= kernfs_iop_getattr,
1238 	.listxattr	= kernfs_iop_listxattr,
1239 
1240 	.mkdir		= kernfs_iop_mkdir,
1241 	.rmdir		= kernfs_iop_rmdir,
1242 	.rename		= kernfs_iop_rename,
1243 };
1244 
1245 static struct kernfs_node *kernfs_leftmost_descendant(struct kernfs_node *pos)
1246 {
1247 	struct kernfs_node *last;
1248 
1249 	while (true) {
1250 		struct rb_node *rbn;
1251 
1252 		last = pos;
1253 
1254 		if (kernfs_type(pos) != KERNFS_DIR)
1255 			break;
1256 
1257 		rbn = rb_first(&pos->dir.children);
1258 		if (!rbn)
1259 			break;
1260 
1261 		pos = rb_to_kn(rbn);
1262 	}
1263 
1264 	return last;
1265 }
1266 
1267 /**
1268  * kernfs_next_descendant_post - find the next descendant for post-order walk
1269  * @pos: the current position (%NULL to initiate traversal)
1270  * @root: kernfs_node whose descendants to walk
1271  *
1272  * Find the next descendant to visit for post-order traversal of @root's
1273  * descendants.  @root is included in the iteration and the last node to be
1274  * visited.
1275  */
1276 static struct kernfs_node *kernfs_next_descendant_post(struct kernfs_node *pos,
1277 						       struct kernfs_node *root)
1278 {
1279 	struct rb_node *rbn;
1280 
1281 	lockdep_assert_held_write(&kernfs_root(root)->kernfs_rwsem);
1282 
1283 	/* if first iteration, visit leftmost descendant which may be root */
1284 	if (!pos)
1285 		return kernfs_leftmost_descendant(root);
1286 
1287 	/* if we visited @root, we're done */
1288 	if (pos == root)
1289 		return NULL;
1290 
1291 	/* if there's an unvisited sibling, visit its leftmost descendant */
1292 	rbn = rb_next(&pos->rb);
1293 	if (rbn)
1294 		return kernfs_leftmost_descendant(rb_to_kn(rbn));
1295 
1296 	/* no sibling left, visit parent */
1297 	return pos->parent;
1298 }
1299 
1300 /**
1301  * kernfs_activate - activate a node which started deactivated
1302  * @kn: kernfs_node whose subtree is to be activated
1303  *
1304  * If the root has KERNFS_ROOT_CREATE_DEACTIVATED set, a newly created node
1305  * needs to be explicitly activated.  A node which hasn't been activated
1306  * isn't visible to userland and deactivation is skipped during its
1307  * removal.  This is useful to construct atomic init sequences where
1308  * creation of multiple nodes should either succeed or fail atomically.
1309  *
1310  * The caller is responsible for ensuring that this function is not called
1311  * after kernfs_remove*() is invoked on @kn.
1312  */
1313 void kernfs_activate(struct kernfs_node *kn)
1314 {
1315 	struct kernfs_node *pos;
1316 	struct kernfs_root *root = kernfs_root(kn);
1317 
1318 	down_write(&root->kernfs_rwsem);
1319 
1320 	pos = NULL;
1321 	while ((pos = kernfs_next_descendant_post(pos, kn))) {
1322 		if (pos->flags & KERNFS_ACTIVATED)
1323 			continue;
1324 
1325 		WARN_ON_ONCE(pos->parent && RB_EMPTY_NODE(&pos->rb));
1326 		WARN_ON_ONCE(atomic_read(&pos->active) != KN_DEACTIVATED_BIAS);
1327 
1328 		atomic_sub(KN_DEACTIVATED_BIAS, &pos->active);
1329 		pos->flags |= KERNFS_ACTIVATED;
1330 	}
1331 
1332 	up_write(&root->kernfs_rwsem);
1333 }
1334 
1335 static void __kernfs_remove(struct kernfs_node *kn)
1336 {
1337 	struct kernfs_node *pos;
1338 
1339 	lockdep_assert_held_write(&kernfs_root(kn)->kernfs_rwsem);
1340 
1341 	/*
1342 	 * Short-circuit if non-root @kn has already finished removal.
1343 	 * This is for kernfs_remove_self() which plays with active ref
1344 	 * after removal.
1345 	 */
1346 	if (!kn || (kn->parent && RB_EMPTY_NODE(&kn->rb)))
1347 		return;
1348 
1349 	pr_debug("kernfs %s: removing\n", kn->name);
1350 
1351 	/* prevent any new usage under @kn by deactivating all nodes */
1352 	pos = NULL;
1353 	while ((pos = kernfs_next_descendant_post(pos, kn)))
1354 		if (kernfs_active(pos))
1355 			atomic_add(KN_DEACTIVATED_BIAS, &pos->active);
1356 
1357 	/* deactivate and unlink the subtree node-by-node */
1358 	do {
1359 		pos = kernfs_leftmost_descendant(kn);
1360 
1361 		/*
1362 		 * kernfs_drain() drops kernfs_rwsem temporarily and @pos's
1363 		 * base ref could have been put by someone else by the time
1364 		 * the function returns.  Make sure it doesn't go away
1365 		 * underneath us.
1366 		 */
1367 		kernfs_get(pos);
1368 
1369 		/*
1370 		 * Drain iff @kn was activated.  This avoids draining and
1371 		 * its lockdep annotations for nodes which have never been
1372 		 * activated and allows embedding kernfs_remove() in create
1373 		 * error paths without worrying about draining.
1374 		 */
1375 		if (kn->flags & KERNFS_ACTIVATED)
1376 			kernfs_drain(pos);
1377 		else
1378 			WARN_ON_ONCE(atomic_read(&kn->active) != KN_DEACTIVATED_BIAS);
1379 
1380 		/*
1381 		 * kernfs_unlink_sibling() succeeds once per node.  Use it
1382 		 * to decide who's responsible for cleanups.
1383 		 */
1384 		if (!pos->parent || kernfs_unlink_sibling(pos)) {
1385 			struct kernfs_iattrs *ps_iattr =
1386 				pos->parent ? pos->parent->iattr : NULL;
1387 
1388 			/* update timestamps on the parent */
1389 			if (ps_iattr) {
1390 				ktime_get_real_ts64(&ps_iattr->ia_ctime);
1391 				ps_iattr->ia_mtime = ps_iattr->ia_ctime;
1392 			}
1393 
1394 			kernfs_put(pos);
1395 		}
1396 
1397 		kernfs_put(pos);
1398 	} while (pos != kn);
1399 }
1400 
1401 /**
1402  * kernfs_remove - remove a kernfs_node recursively
1403  * @kn: the kernfs_node to remove
1404  *
1405  * Remove @kn along with all its subdirectories and files.
1406  */
1407 void kernfs_remove(struct kernfs_node *kn)
1408 {
1409 	struct kernfs_root *root = kernfs_root(kn);
1410 
1411 	down_write(&root->kernfs_rwsem);
1412 	__kernfs_remove(kn);
1413 	up_write(&root->kernfs_rwsem);
1414 }
1415 
1416 /**
1417  * kernfs_break_active_protection - break out of active protection
1418  * @kn: the self kernfs_node
1419  *
1420  * The caller must be running off of a kernfs operation which is invoked
1421  * with an active reference - e.g. one of kernfs_ops.  Each invocation of
1422  * this function must also be matched with an invocation of
1423  * kernfs_unbreak_active_protection().
1424  *
1425  * This function releases the active reference of @kn the caller is
1426  * holding.  Once this function is called, @kn may be removed at any point
1427  * and the caller is solely responsible for ensuring that the objects it
1428  * dereferences are accessible.
1429  */
1430 void kernfs_break_active_protection(struct kernfs_node *kn)
1431 {
1432 	/*
1433 	 * Take out ourself out of the active ref dependency chain.  If
1434 	 * we're called without an active ref, lockdep will complain.
1435 	 */
1436 	kernfs_put_active(kn);
1437 }
1438 
1439 /**
1440  * kernfs_unbreak_active_protection - undo kernfs_break_active_protection()
1441  * @kn: the self kernfs_node
1442  *
1443  * If kernfs_break_active_protection() was called, this function must be
1444  * invoked before finishing the kernfs operation.  Note that while this
1445  * function restores the active reference, it doesn't and can't actually
1446  * restore the active protection - @kn may already or be in the process of
1447  * being removed.  Once kernfs_break_active_protection() is invoked, that
1448  * protection is irreversibly gone for the kernfs operation instance.
1449  *
1450  * While this function may be called at any point after
1451  * kernfs_break_active_protection() is invoked, its most useful location
1452  * would be right before the enclosing kernfs operation returns.
1453  */
1454 void kernfs_unbreak_active_protection(struct kernfs_node *kn)
1455 {
1456 	/*
1457 	 * @kn->active could be in any state; however, the increment we do
1458 	 * here will be undone as soon as the enclosing kernfs operation
1459 	 * finishes and this temporary bump can't break anything.  If @kn
1460 	 * is alive, nothing changes.  If @kn is being deactivated, the
1461 	 * soon-to-follow put will either finish deactivation or restore
1462 	 * deactivated state.  If @kn is already removed, the temporary
1463 	 * bump is guaranteed to be gone before @kn is released.
1464 	 */
1465 	atomic_inc(&kn->active);
1466 	if (kernfs_lockdep(kn))
1467 		rwsem_acquire(&kn->dep_map, 0, 1, _RET_IP_);
1468 }
1469 
1470 /**
1471  * kernfs_remove_self - remove a kernfs_node from its own method
1472  * @kn: the self kernfs_node to remove
1473  *
1474  * The caller must be running off of a kernfs operation which is invoked
1475  * with an active reference - e.g. one of kernfs_ops.  This can be used to
1476  * implement a file operation which deletes itself.
1477  *
1478  * For example, the "delete" file for a sysfs device directory can be
1479  * implemented by invoking kernfs_remove_self() on the "delete" file
1480  * itself.  This function breaks the circular dependency of trying to
1481  * deactivate self while holding an active ref itself.  It isn't necessary
1482  * to modify the usual removal path to use kernfs_remove_self().  The
1483  * "delete" implementation can simply invoke kernfs_remove_self() on self
1484  * before proceeding with the usual removal path.  kernfs will ignore later
1485  * kernfs_remove() on self.
1486  *
1487  * kernfs_remove_self() can be called multiple times concurrently on the
1488  * same kernfs_node.  Only the first one actually performs removal and
1489  * returns %true.  All others will wait until the kernfs operation which
1490  * won self-removal finishes and return %false.  Note that the losers wait
1491  * for the completion of not only the winning kernfs_remove_self() but also
1492  * the whole kernfs_ops which won the arbitration.  This can be used to
1493  * guarantee, for example, all concurrent writes to a "delete" file to
1494  * finish only after the whole operation is complete.
1495  */
1496 bool kernfs_remove_self(struct kernfs_node *kn)
1497 {
1498 	bool ret;
1499 	struct kernfs_root *root = kernfs_root(kn);
1500 
1501 	down_write(&root->kernfs_rwsem);
1502 	kernfs_break_active_protection(kn);
1503 
1504 	/*
1505 	 * SUICIDAL is used to arbitrate among competing invocations.  Only
1506 	 * the first one will actually perform removal.  When the removal
1507 	 * is complete, SUICIDED is set and the active ref is restored
1508 	 * while kernfs_rwsem for held exclusive.  The ones which lost
1509 	 * arbitration waits for SUICIDED && drained which can happen only
1510 	 * after the enclosing kernfs operation which executed the winning
1511 	 * instance of kernfs_remove_self() finished.
1512 	 */
1513 	if (!(kn->flags & KERNFS_SUICIDAL)) {
1514 		kn->flags |= KERNFS_SUICIDAL;
1515 		__kernfs_remove(kn);
1516 		kn->flags |= KERNFS_SUICIDED;
1517 		ret = true;
1518 	} else {
1519 		wait_queue_head_t *waitq = &kernfs_root(kn)->deactivate_waitq;
1520 		DEFINE_WAIT(wait);
1521 
1522 		while (true) {
1523 			prepare_to_wait(waitq, &wait, TASK_UNINTERRUPTIBLE);
1524 
1525 			if ((kn->flags & KERNFS_SUICIDED) &&
1526 			    atomic_read(&kn->active) == KN_DEACTIVATED_BIAS)
1527 				break;
1528 
1529 			up_write(&root->kernfs_rwsem);
1530 			schedule();
1531 			down_write(&root->kernfs_rwsem);
1532 		}
1533 		finish_wait(waitq, &wait);
1534 		WARN_ON_ONCE(!RB_EMPTY_NODE(&kn->rb));
1535 		ret = false;
1536 	}
1537 
1538 	/*
1539 	 * This must be done while kernfs_rwsem held exclusive; otherwise,
1540 	 * waiting for SUICIDED && deactivated could finish prematurely.
1541 	 */
1542 	kernfs_unbreak_active_protection(kn);
1543 
1544 	up_write(&root->kernfs_rwsem);
1545 	return ret;
1546 }
1547 
1548 /**
1549  * kernfs_remove_by_name_ns - find a kernfs_node by name and remove it
1550  * @parent: parent of the target
1551  * @name: name of the kernfs_node to remove
1552  * @ns: namespace tag of the kernfs_node to remove
1553  *
1554  * Look for the kernfs_node with @name and @ns under @parent and remove it.
1555  * Returns 0 on success, -ENOENT if such entry doesn't exist.
1556  */
1557 int kernfs_remove_by_name_ns(struct kernfs_node *parent, const char *name,
1558 			     const void *ns)
1559 {
1560 	struct kernfs_node *kn;
1561 	struct kernfs_root *root;
1562 
1563 	if (!parent) {
1564 		WARN(1, KERN_WARNING "kernfs: can not remove '%s', no directory\n",
1565 			name);
1566 		return -ENOENT;
1567 	}
1568 
1569 	root = kernfs_root(parent);
1570 	down_write(&root->kernfs_rwsem);
1571 
1572 	kn = kernfs_find_ns(parent, name, ns);
1573 	if (kn)
1574 		__kernfs_remove(kn);
1575 
1576 	up_write(&root->kernfs_rwsem);
1577 
1578 	if (kn)
1579 		return 0;
1580 	else
1581 		return -ENOENT;
1582 }
1583 
1584 /**
1585  * kernfs_rename_ns - move and rename a kernfs_node
1586  * @kn: target node
1587  * @new_parent: new parent to put @sd under
1588  * @new_name: new name
1589  * @new_ns: new namespace tag
1590  */
1591 int kernfs_rename_ns(struct kernfs_node *kn, struct kernfs_node *new_parent,
1592 		     const char *new_name, const void *new_ns)
1593 {
1594 	struct kernfs_node *old_parent;
1595 	struct kernfs_root *root;
1596 	const char *old_name = NULL;
1597 	int error;
1598 
1599 	/* can't move or rename root */
1600 	if (!kn->parent)
1601 		return -EINVAL;
1602 
1603 	root = kernfs_root(kn);
1604 	down_write(&root->kernfs_rwsem);
1605 
1606 	error = -ENOENT;
1607 	if (!kernfs_active(kn) || !kernfs_active(new_parent) ||
1608 	    (new_parent->flags & KERNFS_EMPTY_DIR))
1609 		goto out;
1610 
1611 	error = 0;
1612 	if ((kn->parent == new_parent) && (kn->ns == new_ns) &&
1613 	    (strcmp(kn->name, new_name) == 0))
1614 		goto out;	/* nothing to rename */
1615 
1616 	error = -EEXIST;
1617 	if (kernfs_find_ns(new_parent, new_name, new_ns))
1618 		goto out;
1619 
1620 	/* rename kernfs_node */
1621 	if (strcmp(kn->name, new_name) != 0) {
1622 		error = -ENOMEM;
1623 		new_name = kstrdup_const(new_name, GFP_KERNEL);
1624 		if (!new_name)
1625 			goto out;
1626 	} else {
1627 		new_name = NULL;
1628 	}
1629 
1630 	/*
1631 	 * Move to the appropriate place in the appropriate directories rbtree.
1632 	 */
1633 	kernfs_unlink_sibling(kn);
1634 	kernfs_get(new_parent);
1635 
1636 	/* rename_lock protects ->parent and ->name accessors */
1637 	spin_lock_irq(&kernfs_rename_lock);
1638 
1639 	old_parent = kn->parent;
1640 	kn->parent = new_parent;
1641 
1642 	kn->ns = new_ns;
1643 	if (new_name) {
1644 		old_name = kn->name;
1645 		kn->name = new_name;
1646 	}
1647 
1648 	spin_unlock_irq(&kernfs_rename_lock);
1649 
1650 	kn->hash = kernfs_name_hash(kn->name, kn->ns);
1651 	kernfs_link_sibling(kn);
1652 
1653 	kernfs_put(old_parent);
1654 	kfree_const(old_name);
1655 
1656 	error = 0;
1657  out:
1658 	up_write(&root->kernfs_rwsem);
1659 	return error;
1660 }
1661 
1662 /* Relationship between mode and the DT_xxx types */
1663 static inline unsigned char dt_type(struct kernfs_node *kn)
1664 {
1665 	return (kn->mode >> 12) & 15;
1666 }
1667 
1668 static int kernfs_dir_fop_release(struct inode *inode, struct file *filp)
1669 {
1670 	kernfs_put(filp->private_data);
1671 	return 0;
1672 }
1673 
1674 static struct kernfs_node *kernfs_dir_pos(const void *ns,
1675 	struct kernfs_node *parent, loff_t hash, struct kernfs_node *pos)
1676 {
1677 	if (pos) {
1678 		int valid = kernfs_active(pos) &&
1679 			pos->parent == parent && hash == pos->hash;
1680 		kernfs_put(pos);
1681 		if (!valid)
1682 			pos = NULL;
1683 	}
1684 	if (!pos && (hash > 1) && (hash < INT_MAX)) {
1685 		struct rb_node *node = parent->dir.children.rb_node;
1686 		while (node) {
1687 			pos = rb_to_kn(node);
1688 
1689 			if (hash < pos->hash)
1690 				node = node->rb_left;
1691 			else if (hash > pos->hash)
1692 				node = node->rb_right;
1693 			else
1694 				break;
1695 		}
1696 	}
1697 	/* Skip over entries which are dying/dead or in the wrong namespace */
1698 	while (pos && (!kernfs_active(pos) || pos->ns != ns)) {
1699 		struct rb_node *node = rb_next(&pos->rb);
1700 		if (!node)
1701 			pos = NULL;
1702 		else
1703 			pos = rb_to_kn(node);
1704 	}
1705 	return pos;
1706 }
1707 
1708 static struct kernfs_node *kernfs_dir_next_pos(const void *ns,
1709 	struct kernfs_node *parent, ino_t ino, struct kernfs_node *pos)
1710 {
1711 	pos = kernfs_dir_pos(ns, parent, ino, pos);
1712 	if (pos) {
1713 		do {
1714 			struct rb_node *node = rb_next(&pos->rb);
1715 			if (!node)
1716 				pos = NULL;
1717 			else
1718 				pos = rb_to_kn(node);
1719 		} while (pos && (!kernfs_active(pos) || pos->ns != ns));
1720 	}
1721 	return pos;
1722 }
1723 
1724 static int kernfs_fop_readdir(struct file *file, struct dir_context *ctx)
1725 {
1726 	struct dentry *dentry = file->f_path.dentry;
1727 	struct kernfs_node *parent = kernfs_dentry_node(dentry);
1728 	struct kernfs_node *pos = file->private_data;
1729 	struct kernfs_root *root;
1730 	const void *ns = NULL;
1731 
1732 	if (!dir_emit_dots(file, ctx))
1733 		return 0;
1734 
1735 	root = kernfs_root(parent);
1736 	down_read(&root->kernfs_rwsem);
1737 
1738 	if (kernfs_ns_enabled(parent))
1739 		ns = kernfs_info(dentry->d_sb)->ns;
1740 
1741 	for (pos = kernfs_dir_pos(ns, parent, ctx->pos, pos);
1742 	     pos;
1743 	     pos = kernfs_dir_next_pos(ns, parent, ctx->pos, pos)) {
1744 		const char *name = pos->name;
1745 		unsigned int type = dt_type(pos);
1746 		int len = strlen(name);
1747 		ino_t ino = kernfs_ino(pos);
1748 
1749 		ctx->pos = pos->hash;
1750 		file->private_data = pos;
1751 		kernfs_get(pos);
1752 
1753 		up_read(&root->kernfs_rwsem);
1754 		if (!dir_emit(ctx, name, len, ino, type))
1755 			return 0;
1756 		down_read(&root->kernfs_rwsem);
1757 	}
1758 	up_read(&root->kernfs_rwsem);
1759 	file->private_data = NULL;
1760 	ctx->pos = INT_MAX;
1761 	return 0;
1762 }
1763 
1764 const struct file_operations kernfs_dir_fops = {
1765 	.read		= generic_read_dir,
1766 	.iterate_shared	= kernfs_fop_readdir,
1767 	.release	= kernfs_dir_fop_release,
1768 	.llseek		= generic_file_llseek,
1769 };
1770