dir.c 42.4 KB
Newer Older
1
// SPDX-License-Identifier: GPL-2.0-only
2 3 4 5 6 7 8
/*
 * fs/kernfs/dir.c - kernfs directory implementation
 *
 * Copyright (c) 2001-3 Patrick Mochel
 * Copyright (c) 2007 SUSE Linux Products GmbH
 * Copyright (c) 2007, 2013 Tejun Heo <tj@kernel.org>
 */
9

10
#include <linux/sched.h>
11 12 13 14 15 16 17 18 19
#include <linux/fs.h>
#include <linux/namei.h>
#include <linux/idr.h>
#include <linux/slab.h>
#include <linux/security.h>
#include <linux/hash.h>

#include "kernfs-internal.h"

20
DEFINE_MUTEX(kernfs_mutex);
21 22
static DEFINE_SPINLOCK(kernfs_rename_lock);	/* kn->parent and ->name */
static char kernfs_pr_cont_buf[PATH_MAX];	/* protected by rename_lock */
23
static DEFINE_SPINLOCK(kernfs_idr_lock);	/* root->ino_idr */
24

25
#define rb_to_kn(X) rb_entry((X), struct kernfs_node, rb)
26

T
Tejun Heo 已提交
27 28 29 30 31 32
static bool kernfs_active(struct kernfs_node *kn)
{
	lockdep_assert_held(&kernfs_mutex);
	return atomic_read(&kn->active) >= 0;
}

33 34 35 36 37 38 39 40 41
static bool kernfs_lockdep(struct kernfs_node *kn)
{
#ifdef CONFIG_DEBUG_LOCK_ALLOC
	return kn->flags & KERNFS_LOCKDEP;
#else
	return false;
#endif
}

42 43
static int kernfs_name_locked(struct kernfs_node *kn, char *buf, size_t buflen)
{
44 45 46
	if (!kn)
		return strlcpy(buf, "(null)", buflen);

47 48 49
	return strlcpy(buf, kn->parent ? kn->name : "/", buflen);
}

50 51
/* kernfs_node_depth - compute depth from @from to @to */
static size_t kernfs_depth(struct kernfs_node *from, struct kernfs_node *to)
52
{
53
	size_t depth = 0;
54

55 56 57 58 59 60
	while (to->parent && to != from) {
		depth++;
		to = to->parent;
	}
	return depth;
}
61

62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 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
static struct kernfs_node *kernfs_common_ancestor(struct kernfs_node *a,
						  struct kernfs_node *b)
{
	size_t da, db;
	struct kernfs_root *ra = kernfs_root(a), *rb = kernfs_root(b);

	if (ra != rb)
		return NULL;

	da = kernfs_depth(ra->kn, a);
	db = kernfs_depth(rb->kn, b);

	while (da > db) {
		a = a->parent;
		da--;
	}
	while (db > da) {
		b = b->parent;
		db--;
	}

	/* worst case b and a will be the same at root */
	while (b != a) {
		b = b->parent;
		a = a->parent;
	}

	return a;
}

/**
 * kernfs_path_from_node_locked - find a pseudo-absolute path to @kn_to,
 * where kn_from is treated as root of the path.
 * @kn_from: kernfs node which should be treated as root for the path
 * @kn_to: kernfs node to which path is needed
 * @buf: buffer to copy the path into
 * @buflen: size of @buf
 *
 * We need to handle couple of scenarios here:
 * [1] when @kn_from is an ancestor of @kn_to at some level
 * kn_from: /n1/n2/n3
 * kn_to:   /n1/n2/n3/n4/n5
 * result:  /n4/n5
 *
 * [2] when @kn_from is on a different hierarchy and we need to find common
 * ancestor between @kn_from and @kn_to.
 * kn_from: /n1/n2/n3/n4
 * kn_to:   /n1/n2/n5
 * result:  /../../n5
 * OR
 * kn_from: /n1/n2/n3/n4/n5   [depth=5]
 * kn_to:   /n1/n2/n3         [depth=3]
 * result:  /../..
 *
116 117
 * [3] when @kn_to is NULL result will be "(null)"
 *
118 119 120
 * Returns the length of the full path.  If the full length is equal to or
 * greater than @buflen, @buf contains the truncated path with the trailing
 * '\0'.  On error, -errno is returned.
121 122 123 124 125 126 127
 */
static int kernfs_path_from_node_locked(struct kernfs_node *kn_to,
					struct kernfs_node *kn_from,
					char *buf, size_t buflen)
{
	struct kernfs_node *kn, *common;
	const char parent_str[] = "/..";
128 129
	size_t depth_from, depth_to, len = 0;
	int i, j;
130

131 132 133
	if (!kn_to)
		return strlcpy(buf, "(null)", buflen);

134 135 136 137 138 139
	if (!kn_from)
		kn_from = kernfs_root(kn_to)->kn;

	if (kn_from == kn_to)
		return strlcpy(buf, "/", buflen);

140 141 142
	if (!buf)
		return -EINVAL;

143 144
	common = kernfs_common_ancestor(kn_from, kn_to);
	if (WARN_ON(!common))
145
		return -EINVAL;
146 147 148 149

	depth_to = kernfs_depth(common, kn_to);
	depth_from = kernfs_depth(common, kn_from);

150
	buf[0] = '\0';
151 152 153 154 155 156

	for (i = 0; i < depth_from; i++)
		len += strlcpy(buf + len, parent_str,
			       len < buflen ? buflen - len : 0);

	/* Calculate how many bytes we need for the rest */
157 158 159 160 161 162 163
	for (i = depth_to - 1; i >= 0; i--) {
		for (kn = kn_to, j = 0; j < i; j++)
			kn = kn->parent;
		len += strlcpy(buf + len, "/",
			       len < buflen ? buflen - len : 0);
		len += strlcpy(buf + len, kn->name,
			       len < buflen ? buflen - len : 0);
164
	}
165

166
	return len;
167 168 169 170 171 172 173 174 175 176 177 178
}

/**
 * kernfs_name - obtain the name of a given node
 * @kn: kernfs_node of interest
 * @buf: buffer to copy @kn's name into
 * @buflen: size of @buf
 *
 * Copies the name of @kn into @buf of @buflen bytes.  The behavior is
 * similar to strlcpy().  It returns the length of @kn's name and if @buf
 * isn't long enough, it's filled upto @buflen-1 and nul terminated.
 *
179 180
 * Fills buffer with "(null)" if @kn is NULL.
 *
181 182 183 184 185 186 187 188 189 190 191 192 193
 * This function can be called from any context.
 */
int kernfs_name(struct kernfs_node *kn, char *buf, size_t buflen)
{
	unsigned long flags;
	int ret;

	spin_lock_irqsave(&kernfs_rename_lock, flags);
	ret = kernfs_name_locked(kn, buf, buflen);
	spin_unlock_irqrestore(&kernfs_rename_lock, flags);
	return ret;
}

194 195 196 197 198 199 200 201 202 203 204 205
/**
 * kernfs_path_from_node - build path of node @to relative to @from.
 * @from: parent kernfs_node relative to which we need to build the path
 * @to: kernfs_node of interest
 * @buf: buffer to copy @to's path into
 * @buflen: size of @buf
 *
 * Builds @to's path relative to @from in @buf. @from and @to must
 * be on the same kernfs-root. If @from is not parent of @to, then a relative
 * path (which includes '..'s) as needed to reach from @from to @to is
 * returned.
 *
206 207 208
 * Returns the length of the full path.  If the full length is equal to or
 * greater than @buflen, @buf contains the truncated path with the trailing
 * '\0'.  On error, -errno is returned.
209 210 211 212 213 214 215 216 217 218 219 220 221 222
 */
int kernfs_path_from_node(struct kernfs_node *to, struct kernfs_node *from,
			  char *buf, size_t buflen)
{
	unsigned long flags;
	int ret;

	spin_lock_irqsave(&kernfs_rename_lock, flags);
	ret = kernfs_path_from_node_locked(to, from, buf, buflen);
	spin_unlock_irqrestore(&kernfs_rename_lock, flags);
	return ret;
}
EXPORT_SYMBOL_GPL(kernfs_path_from_node);

223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249
/**
 * pr_cont_kernfs_name - pr_cont name of a kernfs_node
 * @kn: kernfs_node of interest
 *
 * This function can be called from any context.
 */
void pr_cont_kernfs_name(struct kernfs_node *kn)
{
	unsigned long flags;

	spin_lock_irqsave(&kernfs_rename_lock, flags);

	kernfs_name_locked(kn, kernfs_pr_cont_buf, sizeof(kernfs_pr_cont_buf));
	pr_cont("%s", kernfs_pr_cont_buf);

	spin_unlock_irqrestore(&kernfs_rename_lock, flags);
}

/**
 * pr_cont_kernfs_path - pr_cont path of a kernfs_node
 * @kn: kernfs_node of interest
 *
 * This function can be called from any context.
 */
void pr_cont_kernfs_path(struct kernfs_node *kn)
{
	unsigned long flags;
250
	int sz;
251 252 253

	spin_lock_irqsave(&kernfs_rename_lock, flags);

254 255 256 257 258 259 260 261 262 263 264 265 266
	sz = kernfs_path_from_node_locked(kn, NULL, kernfs_pr_cont_buf,
					  sizeof(kernfs_pr_cont_buf));
	if (sz < 0) {
		pr_cont("(error)");
		goto out;
	}

	if (sz >= sizeof(kernfs_pr_cont_buf)) {
		pr_cont("(name too long)");
		goto out;
	}

	pr_cont("%s", kernfs_pr_cont_buf);
267

268
out:
269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291
	spin_unlock_irqrestore(&kernfs_rename_lock, flags);
}

/**
 * kernfs_get_parent - determine the parent node and pin it
 * @kn: kernfs_node of interest
 *
 * Determines @kn's parent, pins and returns it.  This function can be
 * called from any context.
 */
struct kernfs_node *kernfs_get_parent(struct kernfs_node *kn)
{
	struct kernfs_node *parent;
	unsigned long flags;

	spin_lock_irqsave(&kernfs_rename_lock, flags);
	parent = kn->parent;
	kernfs_get(parent);
	spin_unlock_irqrestore(&kernfs_rename_lock, flags);

	return parent;
}

292
/**
293
 *	kernfs_name_hash
294 295 296 297 298
 *	@name: Null terminated string to hash
 *	@ns:   Namespace tag to hash
 *
 *	Returns 31 bit hash of ns + name (so it fits in an off_t )
 */
299
static unsigned int kernfs_name_hash(const char *name, const void *ns)
300
{
301
	unsigned long hash = init_name_hash(ns);
302 303 304
	unsigned int len = strlen(name);
	while (len--)
		hash = partial_name_hash(*name++, hash);
305
	hash = end_name_hash(hash);
306 307
	hash &= 0x7fffffffU;
	/* Reserve hash numbers 0, 1 and INT_MAX for magic directory entries */
R
Richard Cochran 已提交
308
	if (hash < 2)
309 310 311 312 313 314
		hash += 2;
	if (hash >= INT_MAX)
		hash = INT_MAX - 1;
	return hash;
}

315 316
static int kernfs_name_compare(unsigned int hash, const char *name,
			       const void *ns, const struct kernfs_node *kn)
317
{
318 319 320 321 322 323 324 325
	if (hash < kn->hash)
		return -1;
	if (hash > kn->hash)
		return 1;
	if (ns < kn->ns)
		return -1;
	if (ns > kn->ns)
		return 1;
326
	return strcmp(name, kn->name);
327 328
}

329 330
static int kernfs_sd_compare(const struct kernfs_node *left,
			     const struct kernfs_node *right)
331
{
332
	return kernfs_name_compare(left->hash, left->name, left->ns, right);
333 334 335
}

/**
336
 *	kernfs_link_sibling - link kernfs_node into sibling rbtree
337
 *	@kn: kernfs_node of interest
338
 *
339
 *	Link @kn into its sibling rbtree which starts from
340
 *	@kn->parent->dir.children.
341 342
 *
 *	Locking:
343
 *	mutex_lock(kernfs_mutex)
344 345 346 347
 *
 *	RETURNS:
 *	0 on susccess -EEXIST on failure.
 */
348
static int kernfs_link_sibling(struct kernfs_node *kn)
349
{
350
	struct rb_node **node = &kn->parent->dir.children.rb_node;
351 352 353
	struct rb_node *parent = NULL;

	while (*node) {
354
		struct kernfs_node *pos;
355 356
		int result;

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 365 366
		else
			return -EEXIST;
	}
J
Jianyu Zhan 已提交
367

368
	/* add new node and rebalance the tree */
369 370
	rb_link_node(&kn->rb, parent, node);
	rb_insert_color(&kn->rb, &kn->parent->dir.children);
J
Jianyu Zhan 已提交
371 372 373 374 375

	/* successfully added, account subdir number */
	if (kernfs_type(kn) == KERNFS_DIR)
		kn->parent->dir.subdirs++;

376 377 378 379
	return 0;
}

/**
380
 *	kernfs_unlink_sibling - unlink kernfs_node from sibling rbtree
381
 *	@kn: kernfs_node of interest
382
 *
383 384 385
 *	Try to unlink @kn from its sibling rbtree which starts from
 *	kn->parent->dir.children.  Returns %true if @kn was actually
 *	removed, %false if @kn wasn't on the rbtree.
386 387
 *
 *	Locking:
388
 *	mutex_lock(kernfs_mutex)
389
 */
390
static bool kernfs_unlink_sibling(struct kernfs_node *kn)
391
{
392 393 394
	if (RB_EMPTY_NODE(&kn->rb))
		return false;

T
Tejun Heo 已提交
395
	if (kernfs_type(kn) == KERNFS_DIR)
396
		kn->parent->dir.subdirs--;
397

398
	rb_erase(&kn->rb, &kn->parent->dir.children);
399 400
	RB_CLEAR_NODE(&kn->rb);
	return true;
401 402 403
}

/**
404
 *	kernfs_get_active - get an active reference to kernfs_node
405
 *	@kn: kernfs_node to get an active reference to
406
 *
407
 *	Get an active reference of @kn.  This function is noop if @kn
408 409 410
 *	is NULL.
 *
 *	RETURNS:
411
 *	Pointer to @kn on success, NULL on failure.
412
 */
413
struct kernfs_node *kernfs_get_active(struct kernfs_node *kn)
414
{
415
	if (unlikely(!kn))
416 417
		return NULL;

418 419
	if (!atomic_inc_unless_negative(&kn->active))
		return NULL;
420

421
	if (kernfs_lockdep(kn))
422 423
		rwsem_acquire_read(&kn->dep_map, 0, 1, _RET_IP_);
	return kn;
424 425 426
}

/**
427
 *	kernfs_put_active - put an active reference to kernfs_node
428
 *	@kn: kernfs_node to put an active reference to
429
 *
430
 *	Put an active reference to @kn.  This function is noop if @kn
431 432
 *	is NULL.
 */
433
void kernfs_put_active(struct kernfs_node *kn)
434 435 436
{
	int v;

437
	if (unlikely(!kn))
438 439
		return;

440
	if (kernfs_lockdep(kn))
441
		rwsem_release(&kn->dep_map, 1, _RET_IP_);
442
	v = atomic_dec_return(&kn->active);
T
Tejun Heo 已提交
443
	if (likely(v != KN_DEACTIVATED_BIAS))
444 445
		return;

446
	wake_up_all(&kernfs_root(kn)->deactivate_waitq);
447 448 449
}

/**
T
Tejun Heo 已提交
450 451
 * kernfs_drain - drain kernfs_node
 * @kn: kernfs_node to drain
452
 *
T
Tejun Heo 已提交
453 454 455
 * Drain existing usages and nuke all existing mmaps of @kn.  Mutiple
 * removers may invoke this function concurrently on @kn and all will
 * return after draining is complete.
456
 */
T
Tejun Heo 已提交
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);
T
Tejun Heo 已提交
463
	WARN_ON_ONCE(kernfs_active(kn));
464

465
	mutex_unlock(&kernfs_mutex);
466

467
	if (kernfs_lockdep(kn)) {
468 469 470 471
		rwsem_acquire(&kn->dep_map, 0, 0, _RET_IP_);
		if (atomic_read(&kn->active) != KN_DEACTIVATED_BIAS)
			lock_contended(&kn->dep_map, _RET_IP_);
	}
472

473
	/* but everyone should wait for draining */
474 475
	wait_event(root->deactivate_waitq,
		   atomic_read(&kn->active) == KN_DEACTIVATED_BIAS);
476

477
	if (kernfs_lockdep(kn)) {
478 479 480
		lock_acquired(&kn->dep_map, _RET_IP_);
		rwsem_release(&kn->dep_map, 1, _RET_IP_);
	}
481

482
	kernfs_drain_open_files(kn);
483

484
	mutex_lock(&kernfs_mutex);
485 486 487
}

/**
488 489
 * kernfs_get - get a reference count on a kernfs_node
 * @kn: the target kernfs_node
490
 */
491
void kernfs_get(struct kernfs_node *kn)
492
{
493
	if (kn) {
494 495
		WARN_ON(!atomic_read(&kn->count));
		atomic_inc(&kn->count);
496 497 498 499 500
	}
}
EXPORT_SYMBOL_GPL(kernfs_get);

/**
501 502
 * kernfs_put - put a reference count on a kernfs_node
 * @kn: the target kernfs_node
503
 *
504
 * Put a reference count of @kn and destroy it if it reached zero.
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
	/*
	 * kernfs_node is freed with ->count 0, kernfs_find_and_get_node_by_ino
	 * depends on this to filter reused stale node
	 */
515
	if (!kn || !atomic_dec_and_test(&kn->count))
516
		return;
517
	root = kernfs_root(kn);
518
 repeat:
T
Tejun Heo 已提交
519 520
	/*
	 * Moving/renaming is always done while holding reference.
521
	 * kn->parent won't change beneath us.
522
	 */
523
	parent = kn->parent;
524

T
Tejun Heo 已提交
525 526 527
	WARN_ONCE(atomic_read(&kn->active) != KN_DEACTIVATED_BIAS,
		  "kernfs_put: %s/%s: released with incorrect active_ref %d\n",
		  parent ? parent->name : "", kn->name, atomic_read(&kn->active));
528

T
Tejun Heo 已提交
529
	if (kernfs_type(kn) == KERNFS_LINK)
530
		kernfs_put(kn->symlink.target_kn);
T
Tejun Heo 已提交
531 532 533

	kfree_const(kn->name);

534 535
	if (kn->iattr) {
		simple_xattrs_free(&kn->iattr->xattrs);
536
		kmem_cache_free(kernfs_iattrs_cache, kn->iattr);
537
	}
538
	spin_lock(&kernfs_idr_lock);
S
Shaohua Li 已提交
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 544
	kn = parent;
	if (kn) {
545
		if (atomic_dec_and_test(&kn->count))
546 547
			goto repeat;
	} else {
548
		/* just released the root kn, free @root too */
549
		idr_destroy(&root->ino_idr);
550 551
		kfree(root);
	}
552 553 554
}
EXPORT_SYMBOL_GPL(kernfs_put);

555
static int kernfs_dop_revalidate(struct dentry *dentry, unsigned int flags)
556
{
557
	struct kernfs_node *kn;
558 559 560 561

	if (flags & LOOKUP_RCU)
		return -ECHILD;

T
Tejun Heo 已提交
562
	/* Always perform fresh lookup for negatives */
563
	if (d_really_is_negative(dentry))
T
Tejun Heo 已提交
564 565
		goto out_bad_unlocked;

S
Shaohua Li 已提交
566
	kn = kernfs_dentry_node(dentry);
567
	mutex_lock(&kernfs_mutex);
568

T
Tejun Heo 已提交
569 570
	/* The kernfs node has been deactivated */
	if (!kernfs_active(kn))
571 572
		goto out_bad;

573
	/* The kernfs node has been moved? */
S
Shaohua Li 已提交
574
	if (kernfs_dentry_node(dentry->d_parent) != kn->parent)
575 576
		goto out_bad;

577
	/* The kernfs node has been renamed */
578
	if (strcmp(dentry->d_name.name, kn->name) != 0)
579 580
		goto out_bad;

581
	/* The kernfs node has been moved to a different namespace */
582
	if (kn->parent && kernfs_ns_enabled(kn->parent) &&
583
	    kernfs_info(dentry->d_sb)->ns != kn->ns)
584 585
		goto out_bad;

586
	mutex_unlock(&kernfs_mutex);
587 588
	return 1;
out_bad:
589
	mutex_unlock(&kernfs_mutex);
T
Tejun Heo 已提交
590
out_bad_unlocked:
591 592 593
	return 0;
}

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 610
/**
 * kernfs_node_from_dentry - determine kernfs_node associated with a dentry
 * @dentry: the dentry in question
 *
 * Return the kernfs_node associated with @dentry.  If @dentry is not a
 * kernfs one, %NULL is returned.
 *
 * While the returned kernfs_node will stay accessible as long as @dentry
 * is accessible, the returned node can be in any state and the caller is
 * fully responsible for determining what's accessible.
 */
struct kernfs_node *kernfs_node_from_dentry(struct dentry *dentry)
{
S
Shaohua Li 已提交
611 612 613
	if (dentry->d_sb->s_op == &kernfs_sops &&
	    !d_really_is_negative(dentry))
		return kernfs_dentry_node(dentry);
614 615 616
	return NULL;
}

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;
S
Shaohua Li 已提交
624
	u32 gen;
625
	int ret;
626

T
Tejun Heo 已提交
627 628 629
	name = kstrdup_const(name, GFP_KERNEL);
	if (!name)
		return NULL;
630

631
	kn = kmem_cache_zalloc(kernfs_node_cache, GFP_KERNEL);
632
	if (!kn)
633 634
		goto err_out1;

635 636
	idr_preload(GFP_KERNEL);
	spin_lock(&kernfs_idr_lock);
S
Shaohua Li 已提交
637
	ret = idr_alloc_cyclic(&root->ino_idr, kn, 1, 0, GFP_ATOMIC);
T
Tejun Heo 已提交
638
	if (ret >= 0 && ret < root->last_ino)
S
Shaohua Li 已提交
639 640
		root->next_generation++;
	gen = root->next_generation;
T
Tejun Heo 已提交
641
	root->last_ino = ret;
642 643
	spin_unlock(&kernfs_idr_lock);
	idr_preload_end();
644
	if (ret < 0)
645
		goto err_out2;
S
Shaohua Li 已提交
646 647
	kn->id.ino = ret;
	kn->id.generation = gen;
648

649
	/*
650
	 * set ino first. This RELEASE is paired with atomic_inc_not_zero in
651 652
	 * kernfs_find_and_get_node_by_ino
	 */
653
	atomic_set_release(&kn->count, 1);
T
Tejun Heo 已提交
654
	atomic_set(&kn->active, KN_DEACTIVATED_BIAS);
655
	RB_CLEAR_NODE(&kn->rb);
656

657 658
	kn->name = name;
	kn->mode = mode;
T
Tejun Heo 已提交
659
	kn->flags = flags;
660

661 662 663 664 665 666 667 668 669 670 671 672
	if (!uid_eq(uid, GLOBAL_ROOT_UID) || !gid_eq(gid, GLOBAL_ROOT_GID)) {
		struct iattr iattr = {
			.ia_valid = ATTR_UID | ATTR_GID,
			.ia_uid = uid,
			.ia_gid = gid,
		};

		ret = __kernfs_setattr(kn, &iattr);
		if (ret < 0)
			goto err_out3;
	}

673 674 675 676 677 678
	if (parent) {
		ret = security_kernfs_init_security(parent, kn);
		if (ret)
			goto err_out3;
	}

679
	return kn;
680

681 682
 err_out3:
	idr_remove(&root->ino_idr, kn->id.ino);
683
 err_out2:
684
	kmem_cache_free(kernfs_node_cache, kn);
685
 err_out1:
T
Tejun Heo 已提交
686
	kfree_const(name);
687 688 689
	return NULL;
}

690 691
struct kernfs_node *kernfs_new_node(struct kernfs_node *parent,
				    const char *name, umode_t mode,
692
				    kuid_t uid, kgid_t gid,
693 694 695 696
				    unsigned flags)
{
	struct kernfs_node *kn;

697
	kn = __kernfs_new_node(kernfs_root(parent), parent,
698
			       name, mode, uid, gid, flags);
699 700 701 702 703 704 705
	if (kn) {
		kernfs_get(parent);
		kn->parent = parent;
	}
	return kn;
}

706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742
/*
 * kernfs_find_and_get_node_by_ino - get kernfs_node from inode number
 * @root: the kernfs root
 * @ino: inode number
 *
 * RETURNS:
 * NULL on failure. Return a kernfs node with reference counter incremented
 */
struct kernfs_node *kernfs_find_and_get_node_by_ino(struct kernfs_root *root,
						    unsigned int ino)
{
	struct kernfs_node *kn;

	rcu_read_lock();
	kn = idr_find(&root->ino_idr, ino);
	if (!kn)
		goto out;

	/*
	 * Since kernfs_node is freed in RCU, it's possible an old node for ino
	 * is freed, but reused before RCU grace period. But a freed node (see
	 * kernfs_put) or an incompletedly initialized node (see
	 * __kernfs_new_node) should have 'count' 0. We can use this fact to
	 * filter out such node.
	 */
	if (!atomic_inc_not_zero(&kn->count)) {
		kn = NULL;
		goto out;
	}

	/*
	 * The node could be a new node or a reused node. If it's a new node,
	 * we are ok. If it's reused because of RCU (because of
	 * SLAB_TYPESAFE_BY_RCU), the __kernfs_new_node always sets its 'ino'
	 * before 'count'. So if 'count' is uptodate, 'ino' should be uptodate,
	 * hence we can use 'ino' to filter stale node.
	 */
S
Shaohua Li 已提交
743
	if (kn->id.ino != ino)
744 745 746 747 748 749 750 751 752 753
		goto out;
	rcu_read_unlock();

	return kn;
out:
	rcu_read_unlock();
	kernfs_put(kn);
	return NULL;
}

754
/**
755
 *	kernfs_add_one - add kernfs_node to parent without warning
756
 *	@kn: kernfs_node to be added
757
 *
758 759 760
 *	The caller must already have initialized @kn->parent.  This
 *	function increments nlink of the parent's inode if @kn is a
 *	directory and link into the children list of the parent.
761 762 763 764 765
 *
 *	RETURNS:
 *	0 on success, -EEXIST if entry with the given name already
 *	exists.
 */
T
Tejun Heo 已提交
766
int kernfs_add_one(struct kernfs_node *kn)
767
{
768
	struct kernfs_node *parent = kn->parent;
769
	struct kernfs_iattrs *ps_iattr;
T
Tejun Heo 已提交
770
	bool has_ns;
771 772
	int ret;

T
Tejun Heo 已提交
773 774 775 776 777 778 779
	mutex_lock(&kernfs_mutex);

	ret = -EINVAL;
	has_ns = kernfs_ns_enabled(parent);
	if (WARN(has_ns != (bool)kn->ns, KERN_WARNING "kernfs: ns %s in '%s' for '%s'\n",
		 has_ns ? "required" : "invalid", parent->name, kn->name))
		goto out_unlock;
780

T
Tejun Heo 已提交
781
	if (kernfs_type(parent) != KERNFS_DIR)
T
Tejun Heo 已提交
782
		goto out_unlock;
783

T
Tejun Heo 已提交
784
	ret = -ENOENT;
785 786 787
	if (parent->flags & KERNFS_EMPTY_DIR)
		goto out_unlock;

788
	if ((parent->flags & KERNFS_ACTIVATED) && !kernfs_active(parent))
T
Tejun Heo 已提交
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)
T
Tejun Heo 已提交
795
		goto out_unlock;
796 797

	/* Update timestamps on the parent */
798
	ps_iattr = parent->iattr;
799
	if (ps_iattr) {
800 801
		ktime_get_real_ts64(&ps_iattr->ia_ctime);
		ps_iattr->ia_mtime = ps_iattr->ia_ctime;
802 803
	}

804 805 806 807 808 809 810 811 812 813 814 815 816
	mutex_unlock(&kernfs_mutex);

	/*
	 * Activate the new node unless CREATE_DEACTIVATED is requested.
	 * If not activated here, the kernfs user is responsible for
	 * activating the node with kernfs_activate().  A node which hasn't
	 * been activated is not visible to userland and its removal won't
	 * trigger deactivation.
	 */
	if (!(kernfs_root(kn)->flags & KERNFS_ROOT_CREATE_DEACTIVATED))
		kernfs_activate(kn);
	return 0;

T
Tejun Heo 已提交
817
out_unlock:
818
	mutex_unlock(&kernfs_mutex);
T
Tejun Heo 已提交
819
	return ret;
820 821 822
}

/**
823 824
 * kernfs_find_ns - find kernfs_node with the given name
 * @parent: kernfs_node to search under
825 826 827
 * @name: name to look for
 * @ns: the namespace tag to use
 *
828 829
 * Look for kernfs_node with name @name under @parent.  Returns pointer to
 * the found kernfs_node on success, %NULL on failure.
830
 */
831 832 833
static struct kernfs_node *kernfs_find_ns(struct kernfs_node *parent,
					  const unsigned char *name,
					  const void *ns)
834
{
835
	struct rb_node *node = parent->dir.children.rb_node;
836
	bool has_ns = kernfs_ns_enabled(parent);
837 838
	unsigned int hash;

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 845 846
		return NULL;
	}

847
	hash = kernfs_name_hash(name, ns);
848
	while (node) {
849
		struct kernfs_node *kn;
850 851
		int result;

852
		kn = rb_to_kn(node);
853
		result = kernfs_name_compare(hash, name, ns, kn);
854 855 856 857 858
		if (result < 0)
			node = node->rb_left;
		else if (result > 0)
			node = node->rb_right;
		else
859
			return kn;
860 861 862 863
	}
	return NULL;
}

864 865 866 867
static struct kernfs_node *kernfs_walk_ns(struct kernfs_node *parent,
					  const unsigned char *path,
					  const void *ns)
{
868 869
	size_t len;
	char *p, *name;
870 871 872

	lockdep_assert_held(&kernfs_mutex);

873 874 875 876 877 878 879
	/* grab kernfs_rename_lock to piggy back on kernfs_pr_cont_buf */
	spin_lock_irq(&kernfs_rename_lock);

	len = strlcpy(kernfs_pr_cont_buf, path, sizeof(kernfs_pr_cont_buf));

	if (len >= sizeof(kernfs_pr_cont_buf)) {
		spin_unlock_irq(&kernfs_rename_lock);
880
		return NULL;
881 882 883
	}

	p = kernfs_pr_cont_buf;
884 885 886 887 888 889 890

	while ((name = strsep(&p, "/")) && parent) {
		if (*name == '\0')
			continue;
		parent = kernfs_find_ns(parent, name, ns);
	}

891 892
	spin_unlock_irq(&kernfs_rename_lock);

893 894 895
	return parent;
}

896
/**
897 898
 * kernfs_find_and_get_ns - find and get kernfs_node with the given name
 * @parent: kernfs_node to search under
899 900 901
 * @name: name to look for
 * @ns: the namespace tag to use
 *
902
 * Look for kernfs_node with name @name under @parent and get a reference
903
 * if found.  This function may sleep and returns pointer to the found
904
 * kernfs_node on success, %NULL on failure.
905
 */
906 907
struct kernfs_node *kernfs_find_and_get_ns(struct kernfs_node *parent,
					   const char *name, const void *ns)
908
{
909
	struct kernfs_node *kn;
910

911
	mutex_lock(&kernfs_mutex);
912 913
	kn = kernfs_find_ns(parent, name, ns);
	kernfs_get(kn);
914
	mutex_unlock(&kernfs_mutex);
915

916
	return kn;
917 918 919
}
EXPORT_SYMBOL_GPL(kernfs_find_and_get_ns);

920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942
/**
 * kernfs_walk_and_get_ns - find and get kernfs_node with the given path
 * @parent: kernfs_node to search under
 * @path: path to look for
 * @ns: the namespace tag to use
 *
 * Look for kernfs_node with path @path under @parent and get a reference
 * if found.  This function may sleep and returns pointer to the found
 * kernfs_node on success, %NULL on failure.
 */
struct kernfs_node *kernfs_walk_and_get_ns(struct kernfs_node *parent,
					   const char *path, const void *ns)
{
	struct kernfs_node *kn;

	mutex_lock(&kernfs_mutex);
	kn = kernfs_walk_ns(parent, path, ns);
	kernfs_get(kn);
	mutex_unlock(&kernfs_mutex);

	return kn;
}

943 944
/**
 * kernfs_create_root - create a new kernfs hierarchy
945
 * @scops: optional syscall operations for the hierarchy
946
 * @flags: KERNFS_ROOT_* flags
947 948 949 950 951
 * @priv: opaque data associated with the new directory
 *
 * Returns the root of the new hierarchy on success, ERR_PTR() value on
 * failure.
 */
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 959 960 961

	root = kzalloc(sizeof(*root), GFP_KERNEL);
	if (!root)
		return ERR_PTR(-ENOMEM);

962
	idr_init(&root->ino_idr);
963
	INIT_LIST_HEAD(&root->supers);
S
Shaohua Li 已提交
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 972 973 974
		kfree(root);
		return ERR_PTR(-ENOMEM);
	}

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 984 985
	if (!(root->flags & KERNFS_ROOT_CREATE_DEACTIVATED))
		kernfs_activate(kn);

986 987 988 989 990 991 992 993 994 995 996 997
	return root;
}

/**
 * kernfs_destroy_root - destroy a kernfs hierarchy
 * @root: root of the hierarchy to destroy
 *
 * Destroy the hierarchy anchored at @root by removing all existing
 * directories and destroying @root.
 */
void kernfs_destroy_root(struct kernfs_root *root)
{
998
	kernfs_remove(root->kn);	/* will also free @root */
999 1000
}

1001 1002 1003 1004
/**
 * kernfs_create_dir_ns - create a directory
 * @parent: parent in which to create a new directory
 * @name: name of the new directory
1005
 * @mode: mode of the new directory
1006 1007
 * @uid: uid of the new directory
 * @gid: gid of the new directory
1008 1009 1010 1011 1012
 * @priv: opaque data associated with the new directory
 * @ns: optional namespace tag of the directory
 *
 * Returns the created node on success, ERR_PTR() value on failure.
 */
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 1020 1021
	int rc;

	/* allocate */
1022 1023
	kn = kernfs_new_node(parent, name, mode | S_IFDIR,
			     uid, gid, KERNFS_DIR);
1024
	if (!kn)
1025 1026
		return ERR_PTR(-ENOMEM);

1027 1028
	kn->dir.root = parent->dir.root;
	kn->ns = ns;
1029
	kn->priv = priv;
1030 1031

	/* link in */
T
Tejun Heo 已提交
1032
	rc = kernfs_add_one(kn);
1033
	if (!rc)
1034
		return kn;
1035

1036
	kernfs_put(kn);
1037 1038 1039
	return ERR_PTR(rc);
}

1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053
/**
 * kernfs_create_empty_dir - create an always empty directory
 * @parent: parent in which to create a new directory
 * @name: name of the new directory
 *
 * Returns the created node on success, ERR_PTR() value on failure.
 */
struct kernfs_node *kernfs_create_empty_dir(struct kernfs_node *parent,
					    const char *name)
{
	struct kernfs_node *kn;
	int rc;

	/* allocate */
1054 1055
	kn = kernfs_new_node(parent, name, S_IRUGO|S_IXUGO|S_IFDIR,
			     GLOBAL_ROOT_UID, GLOBAL_ROOT_GID, KERNFS_DIR);
1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072
	if (!kn)
		return ERR_PTR(-ENOMEM);

	kn->flags |= KERNFS_EMPTY_DIR;
	kn->dir.root = parent->dir.root;
	kn->ns = NULL;
	kn->priv = NULL;

	/* link in */
	rc = kernfs_add_one(kn);
	if (!rc)
		return kn;

	kernfs_put(kn);
	return ERR_PTR(rc);
}

1073 1074 1075
static struct dentry *kernfs_iop_lookup(struct inode *dir,
					struct dentry *dentry,
					unsigned int flags)
1076
{
T
Tejun Heo 已提交
1077
	struct dentry *ret;
S
Shaohua Li 已提交
1078
	struct kernfs_node *parent = dir->i_private;
1079
	struct kernfs_node *kn;
1080 1081 1082
	struct inode *inode;
	const void *ns = NULL;

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

	/* no such entry */
1091
	if (!kn || !kernfs_active(kn)) {
T
Tejun Heo 已提交
1092
		ret = NULL;
1093 1094 1095 1096
		goto out_unlock;
	}

	/* attach dentry and inode */
1097
	inode = kernfs_get_inode(dir->i_sb, kn);
1098 1099 1100 1101 1102 1103
	if (!inode) {
		ret = ERR_PTR(-ENOMEM);
		goto out_unlock;
	}

	/* instantiate and hash dentry */
1104
	ret = d_splice_alias(inode, dentry);
1105
 out_unlock:
1106
	mutex_unlock(&kernfs_mutex);
1107 1108 1109
	return ret;
}

T
Tejun Heo 已提交
1110 1111 1112 1113
static int kernfs_iop_mkdir(struct inode *dir, struct dentry *dentry,
			    umode_t mode)
{
	struct kernfs_node *parent = dir->i_private;
1114
	struct kernfs_syscall_ops *scops = kernfs_root(parent)->syscall_ops;
1115
	int ret;
T
Tejun Heo 已提交
1116

1117
	if (!scops || !scops->mkdir)
T
Tejun Heo 已提交
1118 1119
		return -EPERM;

1120 1121 1122
	if (!kernfs_get_active(parent))
		return -ENODEV;

1123
	ret = scops->mkdir(parent, dentry->d_name.name, mode);
1124 1125 1126

	kernfs_put_active(parent);
	return ret;
T
Tejun Heo 已提交
1127 1128 1129 1130
}

static int kernfs_iop_rmdir(struct inode *dir, struct dentry *dentry)
{
S
Shaohua Li 已提交
1131
	struct kernfs_node *kn  = kernfs_dentry_node(dentry);
1132
	struct kernfs_syscall_ops *scops = kernfs_root(kn)->syscall_ops;
1133
	int ret;
T
Tejun Heo 已提交
1134

1135
	if (!scops || !scops->rmdir)
T
Tejun Heo 已提交
1136 1137
		return -EPERM;

1138 1139 1140
	if (!kernfs_get_active(kn))
		return -ENODEV;

1141
	ret = scops->rmdir(kn);
1142 1143 1144

	kernfs_put_active(kn);
	return ret;
T
Tejun Heo 已提交
1145 1146 1147
}

static int kernfs_iop_rename(struct inode *old_dir, struct dentry *old_dentry,
1148 1149
			     struct inode *new_dir, struct dentry *new_dentry,
			     unsigned int flags)
T
Tejun Heo 已提交
1150
{
S
Shaohua Li 已提交
1151
	struct kernfs_node *kn = kernfs_dentry_node(old_dentry);
T
Tejun Heo 已提交
1152
	struct kernfs_node *new_parent = new_dir->i_private;
1153
	struct kernfs_syscall_ops *scops = kernfs_root(kn)->syscall_ops;
1154
	int ret;
T
Tejun Heo 已提交
1155

1156 1157 1158
	if (flags)
		return -EINVAL;

1159
	if (!scops || !scops->rename)
T
Tejun Heo 已提交
1160 1161
		return -EPERM;

1162 1163 1164 1165 1166 1167 1168 1169
	if (!kernfs_get_active(kn))
		return -ENODEV;

	if (!kernfs_get_active(new_parent)) {
		kernfs_put_active(kn);
		return -ENODEV;
	}

1170
	ret = scops->rename(kn, new_parent, new_dentry->d_name.name);
1171 1172 1173 1174

	kernfs_put_active(new_parent);
	kernfs_put_active(kn);
	return ret;
T
Tejun Heo 已提交
1175 1176
}

1177
const struct inode_operations kernfs_dir_iops = {
1178 1179 1180 1181 1182
	.lookup		= kernfs_iop_lookup,
	.permission	= kernfs_iop_permission,
	.setattr	= kernfs_iop_setattr,
	.getattr	= kernfs_iop_getattr,
	.listxattr	= kernfs_iop_listxattr,
T
Tejun Heo 已提交
1183 1184 1185 1186

	.mkdir		= kernfs_iop_mkdir,
	.rmdir		= kernfs_iop_rmdir,
	.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 1194 1195 1196 1197

	while (true) {
		struct rb_node *rbn;

		last = pos;

T
Tejun Heo 已提交
1198
		if (kernfs_type(pos) != KERNFS_DIR)
1199 1200
			break;

1201
		rbn = rb_first(&pos->dir.children);
1202 1203 1204
		if (!rbn)
			break;

1205
		pos = rb_to_kn(rbn);
1206 1207 1208 1209 1210 1211
	}

	return last;
}

/**
1212
 * kernfs_next_descendant_post - find the next descendant for post-order walk
1213
 * @pos: the current position (%NULL to initiate traversal)
1214
 * @root: kernfs_node whose descendants to walk
1215 1216 1217 1218 1219
 *
 * Find the next descendant to visit for post-order traversal of @root's
 * descendants.  @root is included in the iteration and the last node to be
 * visited.
 */
1220 1221
static struct kernfs_node *kernfs_next_descendant_post(struct kernfs_node *pos,
						       struct kernfs_node *root)
1222 1223 1224
{
	struct rb_node *rbn;

1225
	lockdep_assert_held(&kernfs_mutex);
1226 1227 1228

	/* if first iteration, visit leftmost descendant which may be root */
	if (!pos)
1229
		return kernfs_leftmost_descendant(root);
1230 1231 1232 1233 1234 1235

	/* if we visited @root, we're done */
	if (pos == root)
		return NULL;

	/* if there's an unvisited sibling, visit its leftmost descendant */
1236
	rbn = rb_next(&pos->rb);
1237
	if (rbn)
1238
		return kernfs_leftmost_descendant(rb_to_kn(rbn));
1239 1240

	/* no sibling left, visit parent */
1241
	return pos->parent;
1242 1243
}

1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277
/**
 * kernfs_activate - activate a node which started deactivated
 * @kn: kernfs_node whose subtree is to be activated
 *
 * If the root has KERNFS_ROOT_CREATE_DEACTIVATED set, a newly created node
 * needs to be explicitly activated.  A node which hasn't been activated
 * isn't visible to userland and deactivation is skipped during its
 * removal.  This is useful to construct atomic init sequences where
 * creation of multiple nodes should either succeed or fail atomically.
 *
 * The caller is responsible for ensuring that this function is not called
 * after kernfs_remove*() is invoked on @kn.
 */
void kernfs_activate(struct kernfs_node *kn)
{
	struct kernfs_node *pos;

	mutex_lock(&kernfs_mutex);

	pos = NULL;
	while ((pos = kernfs_next_descendant_post(pos, kn))) {
		if (!pos || (pos->flags & KERNFS_ACTIVATED))
			continue;

		WARN_ON_ONCE(pos->parent && RB_EMPTY_NODE(&pos->rb));
		WARN_ON_ONCE(atomic_read(&pos->active) != KN_DEACTIVATED_BIAS);

		atomic_sub(KN_DEACTIVATED_BIAS, &pos->active);
		pos->flags |= KERNFS_ACTIVATED;
	}

	mutex_unlock(&kernfs_mutex);
}

T
Tejun Heo 已提交
1278
static void __kernfs_remove(struct kernfs_node *kn)
1279
{
1280 1281 1282
	struct kernfs_node *pos;

	lockdep_assert_held(&kernfs_mutex);
1283

1284 1285 1286 1287 1288 1289
	/*
	 * Short-circuit if non-root @kn has already finished removal.
	 * This is for kernfs_remove_self() which plays with active ref
	 * after removal.
	 */
	if (!kn || (kn->parent && RB_EMPTY_NODE(&kn->rb)))
1290 1291
		return;

1292
	pr_debug("kernfs %s: removing\n", kn->name);
1293

T
Tejun Heo 已提交
1294
	/* prevent any new usage under @kn by deactivating all nodes */
1295 1296
	pos = NULL;
	while ((pos = kernfs_next_descendant_post(pos, kn)))
T
Tejun Heo 已提交
1297 1298
		if (kernfs_active(pos))
			atomic_add(KN_DEACTIVATED_BIAS, &pos->active);
1299 1300

	/* deactivate and unlink the subtree node-by-node */
1301
	do {
1302 1303 1304
		pos = kernfs_leftmost_descendant(kn);

		/*
T
Tejun Heo 已提交
1305 1306 1307 1308
		 * kernfs_drain() drops kernfs_mutex temporarily and @pos's
		 * base ref could have been put by someone else by the time
		 * the function returns.  Make sure it doesn't go away
		 * underneath us.
1309 1310 1311
		 */
		kernfs_get(pos);

1312 1313 1314 1315 1316 1317 1318 1319 1320 1321
		/*
		 * Drain iff @kn was activated.  This avoids draining and
		 * its lockdep annotations for nodes which have never been
		 * activated and allows embedding kernfs_remove() in create
		 * error paths without worrying about draining.
		 */
		if (kn->flags & KERNFS_ACTIVATED)
			kernfs_drain(pos);
		else
			WARN_ON_ONCE(atomic_read(&kn->active) != KN_DEACTIVATED_BIAS);
1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332

		/*
		 * kernfs_unlink_sibling() succeeds once per node.  Use it
		 * to decide who's responsible for cleanups.
		 */
		if (!pos->parent || kernfs_unlink_sibling(pos)) {
			struct kernfs_iattrs *ps_iattr =
				pos->parent ? pos->parent->iattr : NULL;

			/* update timestamps on the parent */
			if (ps_iattr) {
1333 1334
				ktime_get_real_ts64(&ps_iattr->ia_ctime);
				ps_iattr->ia_mtime = ps_iattr->ia_ctime;
1335 1336
			}

T
Tejun Heo 已提交
1337
			kernfs_put(pos);
1338 1339 1340 1341
		}

		kernfs_put(pos);
	} while (pos != kn);
1342 1343 1344
}

/**
1345 1346
 * kernfs_remove - remove a kernfs_node recursively
 * @kn: the kernfs_node to remove
1347
 *
1348
 * Remove @kn along with all its subdirectories and files.
1349
 */
1350
void kernfs_remove(struct kernfs_node *kn)
1351
{
T
Tejun Heo 已提交
1352 1353 1354
	mutex_lock(&kernfs_mutex);
	__kernfs_remove(kn);
	mutex_unlock(&kernfs_mutex);
1355 1356
}

1357 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 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 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 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487
/**
 * kernfs_break_active_protection - break out of active protection
 * @kn: the self kernfs_node
 *
 * The caller must be running off of a kernfs operation which is invoked
 * with an active reference - e.g. one of kernfs_ops.  Each invocation of
 * this function must also be matched with an invocation of
 * kernfs_unbreak_active_protection().
 *
 * This function releases the active reference of @kn the caller is
 * holding.  Once this function is called, @kn may be removed at any point
 * and the caller is solely responsible for ensuring that the objects it
 * dereferences are accessible.
 */
void kernfs_break_active_protection(struct kernfs_node *kn)
{
	/*
	 * Take out ourself out of the active ref dependency chain.  If
	 * we're called without an active ref, lockdep will complain.
	 */
	kernfs_put_active(kn);
}

/**
 * kernfs_unbreak_active_protection - undo kernfs_break_active_protection()
 * @kn: the self kernfs_node
 *
 * If kernfs_break_active_protection() was called, this function must be
 * invoked before finishing the kernfs operation.  Note that while this
 * function restores the active reference, it doesn't and can't actually
 * restore the active protection - @kn may already or be in the process of
 * being removed.  Once kernfs_break_active_protection() is invoked, that
 * protection is irreversibly gone for the kernfs operation instance.
 *
 * While this function may be called at any point after
 * kernfs_break_active_protection() is invoked, its most useful location
 * would be right before the enclosing kernfs operation returns.
 */
void kernfs_unbreak_active_protection(struct kernfs_node *kn)
{
	/*
	 * @kn->active could be in any state; however, the increment we do
	 * here will be undone as soon as the enclosing kernfs operation
	 * finishes and this temporary bump can't break anything.  If @kn
	 * is alive, nothing changes.  If @kn is being deactivated, the
	 * soon-to-follow put will either finish deactivation or restore
	 * deactivated state.  If @kn is already removed, the temporary
	 * bump is guaranteed to be gone before @kn is released.
	 */
	atomic_inc(&kn->active);
	if (kernfs_lockdep(kn))
		rwsem_acquire(&kn->dep_map, 0, 1, _RET_IP_);
}

/**
 * kernfs_remove_self - remove a kernfs_node from its own method
 * @kn: the self kernfs_node to remove
 *
 * The caller must be running off of a kernfs operation which is invoked
 * with an active reference - e.g. one of kernfs_ops.  This can be used to
 * implement a file operation which deletes itself.
 *
 * For example, the "delete" file for a sysfs device directory can be
 * implemented by invoking kernfs_remove_self() on the "delete" file
 * itself.  This function breaks the circular dependency of trying to
 * deactivate self while holding an active ref itself.  It isn't necessary
 * to modify the usual removal path to use kernfs_remove_self().  The
 * "delete" implementation can simply invoke kernfs_remove_self() on self
 * before proceeding with the usual removal path.  kernfs will ignore later
 * kernfs_remove() on self.
 *
 * kernfs_remove_self() can be called multiple times concurrently on the
 * same kernfs_node.  Only the first one actually performs removal and
 * returns %true.  All others will wait until the kernfs operation which
 * won self-removal finishes and return %false.  Note that the losers wait
 * for the completion of not only the winning kernfs_remove_self() but also
 * the whole kernfs_ops which won the arbitration.  This can be used to
 * guarantee, for example, all concurrent writes to a "delete" file to
 * finish only after the whole operation is complete.
 */
bool kernfs_remove_self(struct kernfs_node *kn)
{
	bool ret;

	mutex_lock(&kernfs_mutex);
	kernfs_break_active_protection(kn);

	/*
	 * SUICIDAL is used to arbitrate among competing invocations.  Only
	 * the first one will actually perform removal.  When the removal
	 * is complete, SUICIDED is set and the active ref is restored
	 * while holding kernfs_mutex.  The ones which lost arbitration
	 * waits for SUICDED && drained which can happen only after the
	 * enclosing kernfs operation which executed the winning instance
	 * of kernfs_remove_self() finished.
	 */
	if (!(kn->flags & KERNFS_SUICIDAL)) {
		kn->flags |= KERNFS_SUICIDAL;
		__kernfs_remove(kn);
		kn->flags |= KERNFS_SUICIDED;
		ret = true;
	} else {
		wait_queue_head_t *waitq = &kernfs_root(kn)->deactivate_waitq;
		DEFINE_WAIT(wait);

		while (true) {
			prepare_to_wait(waitq, &wait, TASK_UNINTERRUPTIBLE);

			if ((kn->flags & KERNFS_SUICIDED) &&
			    atomic_read(&kn->active) == KN_DEACTIVATED_BIAS)
				break;

			mutex_unlock(&kernfs_mutex);
			schedule();
			mutex_lock(&kernfs_mutex);
		}
		finish_wait(waitq, &wait);
		WARN_ON_ONCE(!RB_EMPTY_NODE(&kn->rb));
		ret = false;
	}

	/*
	 * This must be done while holding kernfs_mutex; otherwise, waiting
	 * for SUICIDED && deactivated could finish prematurely.
	 */
	kernfs_unbreak_active_protection(kn);

	mutex_unlock(&kernfs_mutex);
	return ret;
}

1488
/**
1489 1490 1491 1492
 * kernfs_remove_by_name_ns - find a kernfs_node by name and remove it
 * @parent: parent of the target
 * @name: name of the kernfs_node to remove
 * @ns: namespace tag of the kernfs_node to remove
1493
 *
1494 1495
 * Look for the kernfs_node with @name and @ns under @parent and remove it.
 * Returns 0 on success, -ENOENT if such entry doesn't exist.
1496
 */
1497
int kernfs_remove_by_name_ns(struct kernfs_node *parent, const char *name,
1498 1499
			     const void *ns)
{
1500
	struct kernfs_node *kn;
1501

1502
	if (!parent) {
1503
		WARN(1, KERN_WARNING "kernfs: can not remove '%s', no directory\n",
1504 1505 1506 1507
			name);
		return -ENOENT;
	}

T
Tejun Heo 已提交
1508
	mutex_lock(&kernfs_mutex);
1509

1510 1511
	kn = kernfs_find_ns(parent, name, ns);
	if (kn)
T
Tejun Heo 已提交
1512
		__kernfs_remove(kn);
1513

T
Tejun Heo 已提交
1514
	mutex_unlock(&kernfs_mutex);
1515

1516
	if (kn)
1517 1518 1519 1520 1521 1522 1523
		return 0;
	else
		return -ENOENT;
}

/**
 * kernfs_rename_ns - move and rename a kernfs_node
1524
 * @kn: target node
1525 1526 1527 1528
 * @new_parent: new parent to put @sd under
 * @new_name: new name
 * @new_ns: new namespace tag
 */
1529
int kernfs_rename_ns(struct kernfs_node *kn, struct kernfs_node *new_parent,
1530 1531
		     const char *new_name, const void *new_ns)
{
1532 1533
	struct kernfs_node *old_parent;
	const char *old_name = NULL;
1534 1535
	int error;

1536 1537 1538 1539
	/* can't move or rename root */
	if (!kn->parent)
		return -EINVAL;

1540 1541
	mutex_lock(&kernfs_mutex);

1542
	error = -ENOENT;
1543 1544
	if (!kernfs_active(kn) || !kernfs_active(new_parent) ||
	    (new_parent->flags & KERNFS_EMPTY_DIR))
1545 1546
		goto out;

1547
	error = 0;
1548 1549
	if ((kn->parent == new_parent) && (kn->ns == new_ns) &&
	    (strcmp(kn->name, new_name) == 0))
1550
		goto out;	/* nothing to rename */
1551 1552 1553

	error = -EEXIST;
	if (kernfs_find_ns(new_parent, new_name, new_ns))
1554
		goto out;
1555

1556
	/* rename kernfs_node */
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 1563
	} else {
		new_name = NULL;
1564 1565 1566 1567 1568
	}

	/*
	 * Move to the appropriate place in the appropriate directories rbtree.
	 */
1569
	kernfs_unlink_sibling(kn);
1570
	kernfs_get(new_parent);
1571 1572 1573 1574 1575

	/* rename_lock protects ->parent and ->name accessors */
	spin_lock_irq(&kernfs_rename_lock);

	old_parent = kn->parent;
1576
	kn->parent = new_parent;
1577 1578 1579

	kn->ns = new_ns;
	if (new_name) {
T
Tejun Heo 已提交
1580
		old_name = kn->name;
1581 1582 1583 1584 1585
		kn->name = new_name;
	}

	spin_unlock_irq(&kernfs_rename_lock);

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 1596 1597 1598
	return error;
}

/* Relationship between s_mode and the DT_xxx types */
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 1607 1608 1609
{
	kernfs_put(filp->private_data);
	return 0;
}

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) {
T
Tejun Heo 已提交
1614
		int valid = kernfs_active(pos) &&
1615
			pos->parent == parent && hash == pos->hash;
1616 1617 1618 1619 1620
		kernfs_put(pos);
		if (!valid)
			pos = NULL;
	}
	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 1629 1630 1631 1632
				node = node->rb_right;
			else
				break;
		}
	}
1633 1634
	/* Skip over entries which are dying/dead or in the wrong namespace */
	while (pos && (!kernfs_active(pos) || pos->ns != ns)) {
1635
		struct rb_node *node = rb_next(&pos->rb);
1636 1637 1638
		if (!node)
			pos = NULL;
		else
1639
			pos = rb_to_kn(node);
1640 1641 1642 1643
	}
	return pos;
}

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 1652 1653
			if (!node)
				pos = NULL;
			else
1654
				pos = rb_to_kn(node);
1655 1656
		} while (pos && (!kernfs_active(pos) || pos->ns != ns));
	}
1657 1658 1659
	return pos;
}

1660
static int kernfs_fop_readdir(struct file *file, struct dir_context *ctx)
1661 1662
{
	struct dentry *dentry = file->f_path.dentry;
S
Shaohua Li 已提交
1663
	struct kernfs_node *parent = kernfs_dentry_node(dentry);
1664
	struct kernfs_node *pos = file->private_data;
1665 1666 1667 1668
	const void *ns = NULL;

	if (!dir_emit_dots(file, ctx))
		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 1679
		unsigned int type = dt_type(pos);
		int len = strlen(name);
S
Shaohua Li 已提交
1680
		ino_t ino = pos->id.ino;
1681

1682
		ctx->pos = pos->hash;
1683 1684 1685
		file->private_data = pos;
		kernfs_get(pos);

1686
		mutex_unlock(&kernfs_mutex);
1687 1688
		if (!dir_emit(ctx, name, len, ino, type))
			return 0;
1689
		mutex_lock(&kernfs_mutex);
1690
	}
1691
	mutex_unlock(&kernfs_mutex);
1692 1693 1694 1695 1696
	file->private_data = NULL;
	ctx->pos = INT_MAX;
	return 0;
}

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
};