dir.c 25.0 KB
Newer Older
L
Linus Torvalds 已提交
1
/*
T
Tejun Heo 已提交
2 3 4 5 6 7 8 9 10
 * fs/sysfs/dir.c - sysfs core and dir operation implementation
 *
 * Copyright (c) 2001-3 Patrick Mochel
 * Copyright (c) 2007 SUSE Linux Products GmbH
 * Copyright (c) 2007 Tejun Heo <teheo@suse.de>
 *
 * This file is released under the GPLv2.
 *
 * Please see Documentation/filesystems/sysfs.txt for more information.
L
Linus Torvalds 已提交
11 12 13 14 15 16 17 18
 */

#undef DEBUG

#include <linux/fs.h>
#include <linux/mount.h>
#include <linux/module.h>
#include <linux/kobject.h>
19
#include <linux/namei.h>
20
#include <linux/idr.h>
21
#include <linux/completion.h>
D
Dave Young 已提交
22
#include <linux/mutex.h>
23
#include <linux/slab.h>
24
#include <linux/security.h>
25
#include <linux/hash.h>
L
Linus Torvalds 已提交
26 27
#include "sysfs.h"

28
DEFINE_MUTEX(sysfs_mutex);
R
Roel Kluin 已提交
29
DEFINE_SPINLOCK(sysfs_assoc_lock);
L
Linus Torvalds 已提交
30

31
#define to_sysfs_dirent(X) rb_entry((X), struct sysfs_dirent, s_rb)
32

R
Roel Kluin 已提交
33
static DEFINE_SPINLOCK(sysfs_ino_lock);
34 35
static DEFINE_IDA(sysfs_ino_ida);

36
/**
37 38
 *	sysfs_name_hash
 *	@name: Null terminated string to hash
T
Tejun Heo 已提交
39
 *	@ns:   Namespace tag to hash
40 41 42
 *
 *	Returns 31 bit hash of ns + name (so it fits in an off_t )
 */
T
Tejun Heo 已提交
43
static unsigned int sysfs_name_hash(const char *name, const void *ns)
44 45 46 47 48
{
	unsigned long hash = init_name_hash();
	unsigned int len = strlen(name);
	while (len--)
		hash = partial_name_hash(*name++, hash);
49
	hash = (end_name_hash(hash) ^ hash_ptr((void *)ns, 31));
50 51 52 53 54 55 56 57 58
	hash &= 0x7fffffffU;
	/* Reserve hash numbers 0, 1 and INT_MAX for magic directory entries */
	if (hash < 1)
		hash += 2;
	if (hash >= INT_MAX)
		hash = INT_MAX - 1;
	return hash;
}

T
Tejun Heo 已提交
59 60
static int sysfs_name_compare(unsigned int hash, const char *name,
			      const void *ns, const struct sysfs_dirent *sd)
61 62 63 64 65 66 67 68 69 70 71
{
	if (hash != sd->s_hash)
		return hash - sd->s_hash;
	if (ns != sd->s_ns)
		return ns - sd->s_ns;
	return strcmp(name, sd->s_name);
}

static int sysfs_sd_compare(const struct sysfs_dirent *left,
			    const struct sysfs_dirent *right)
{
T
Tejun Heo 已提交
72
	return sysfs_name_compare(left->s_hash, left->s_name, left->s_ns,
73 74 75 76
				  right);
}

/**
77
 *	sysfs_link_sibling - link sysfs_dirent into sibling rbtree
78 79
 *	@sd: sysfs_dirent of interest
 *
80
 *	Link @sd into its sibling rbtree which starts from
81
 *	sd->s_parent->s_dir.children.
82 83
 *
 *	Locking:
84
 *	mutex_lock(sysfs_mutex)
85 86 87
 *
 *	RETURNS:
 *	0 on susccess -EEXIST on failure.
88
 */
89
static int sysfs_link_sibling(struct sysfs_dirent *sd)
90
{
91 92
	struct rb_node **node = &sd->s_parent->s_dir.children.rb_node;
	struct rb_node *parent = NULL;
93

94 95 96
	if (sysfs_type(sd) == SYSFS_DIR)
		sd->s_parent->s_dir.subdirs++;

97 98 99 100 101 102 103 104 105 106 107 108 109
	while (*node) {
		struct sysfs_dirent *pos;
		int result;

		pos = to_sysfs_dirent(*node);
		parent = *node;
		result = sysfs_sd_compare(sd, pos);
		if (result < 0)
			node = &pos->s_rb.rb_left;
		else if (result > 0)
			node = &pos->s_rb.rb_right;
		else
			return -EEXIST;
110
	}
111 112 113
	/* add new node and rebalance the tree */
	rb_link_node(&sd->s_rb, parent, node);
	rb_insert_color(&sd->s_rb, &sd->s_parent->s_dir.children);
T
Tejun Heo 已提交
114 115 116 117 118

	/* if @sd has ns tag, mark the parent to enable ns filtering */
	if (sd->s_ns)
		sd->s_parent->s_flags |= SYSFS_FLAG_HAS_NS;

119
	return 0;
120 121 122
}

/**
123
 *	sysfs_unlink_sibling - unlink sysfs_dirent from sibling rbtree
124 125
 *	@sd: sysfs_dirent of interest
 *
126
 *	Unlink @sd from its sibling rbtree which starts from
127
 *	sd->s_parent->s_dir.children.
128 129
 *
 *	Locking:
130
 *	mutex_lock(sysfs_mutex)
131
 */
132
static void sysfs_unlink_sibling(struct sysfs_dirent *sd)
133
{
134 135 136
	if (sysfs_type(sd) == SYSFS_DIR)
		sd->s_parent->s_dir.subdirs--;

137
	rb_erase(&sd->s_rb, &sd->s_parent->s_dir.children);
T
Tejun Heo 已提交
138 139 140 141 142 143 144

	/*
	 * Either all or none of the children have tags.  Clearing HAS_NS
	 * when there's no child left is enough to keep the flag synced.
	 */
	if (RB_EMPTY_ROOT(&sd->s_parent->s_dir.children))
		sd->s_parent->s_flags &= ~SYSFS_FLAG_HAS_NS;
145 146
}

147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164
#ifdef CONFIG_DEBUG_LOCK_ALLOC

/* Test for attributes that want to ignore lockdep for read-locking */
static bool ignore_lockdep(struct sysfs_dirent *sd)
{
	return sysfs_type(sd) == SYSFS_KOBJ_ATTR &&
			sd->s_attr.attr->ignore_lockdep;
}

#else

static inline bool ignore_lockdep(struct sysfs_dirent *sd)
{
	return true;
}

#endif

165 166 167 168 169 170 171 172 173 174
/**
 *	sysfs_get_active - get an active reference to sysfs_dirent
 *	@sd: sysfs_dirent to get an active reference to
 *
 *	Get an active reference of @sd.  This function is noop if @sd
 *	is NULL.
 *
 *	RETURNS:
 *	Pointer to @sd on success, NULL on failure.
 */
175
struct sysfs_dirent *sysfs_get_active(struct sysfs_dirent *sd)
176
{
177 178 179
	if (unlikely(!sd))
		return NULL;

180 181
	if (!atomic_inc_unless_negative(&sd->s_active))
		return NULL;
182 183 184 185

	if (likely(!ignore_lockdep(sd)))
		rwsem_acquire_read(&sd->dep_map, 0, 1, _RET_IP_);
	return sd;
186 187 188 189 190 191 192 193 194
}

/**
 *	sysfs_put_active - put an active reference to sysfs_dirent
 *	@sd: sysfs_dirent to put an active reference to
 *
 *	Put an active reference to @sd.  This function is noop if @sd
 *	is NULL.
 */
195
void sysfs_put_active(struct sysfs_dirent *sd)
196
{
197 198 199 200 201
	int v;

	if (unlikely(!sd))
		return;

202 203
	if (likely(!ignore_lockdep(sd)))
		rwsem_release(&sd->dep_map, 1, _RET_IP_);
204 205 206 207 208
	v = atomic_dec_return(&sd->s_active);
	if (likely(v != SD_DEACTIVATED_BIAS))
		return;

	/* atomic_dec_return() is a mb(), we'll always see the updated
M
Mikulas Patocka 已提交
209
	 * sd->u.completion.
210
	 */
M
Mikulas Patocka 已提交
211
	complete(sd->u.completion);
212 213 214 215 216 217
}

/**
 *	sysfs_deactivate - deactivate sysfs_dirent
 *	@sd: sysfs_dirent to deactivate
 *
218
 *	Deny new active references and drain existing ones.
219
 */
220
static void sysfs_deactivate(struct sysfs_dirent *sd)
221
{
222 223
	DECLARE_COMPLETION_ONSTACK(wait);
	int v;
224

M
Mikulas Patocka 已提交
225
	BUG_ON(!(sd->s_flags & SYSFS_FLAG_REMOVED));
226 227 228 229

	if (!(sysfs_type(sd) & SYSFS_ACTIVE_REF))
		return;

M
Mikulas Patocka 已提交
230
	sd->u.completion = (void *)&wait;
231

232
	rwsem_acquire(&sd->dep_map, 0, 0, _RET_IP_);
233
	/* atomic_add_return() is a mb(), put_active() will always see
M
Mikulas Patocka 已提交
234
	 * the updated sd->u.completion.
235
	 */
236 237
	v = atomic_add_return(SD_DEACTIVATED_BIAS, &sd->s_active);

238 239
	if (v != SD_DEACTIVATED_BIAS) {
		lock_contended(&sd->dep_map, _RET_IP_);
240
		wait_for_completion(&wait);
241
	}
242

243 244
	lock_acquired(&sd->dep_map, _RET_IP_);
	rwsem_release(&sd->dep_map, 1, _RET_IP_);
245 246
}

247
static int sysfs_alloc_ino(unsigned int *pino)
248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265
{
	int ino, rc;

 retry:
	spin_lock(&sysfs_ino_lock);
	rc = ida_get_new_above(&sysfs_ino_ida, 2, &ino);
	spin_unlock(&sysfs_ino_lock);

	if (rc == -EAGAIN) {
		if (ida_pre_get(&sysfs_ino_ida, GFP_KERNEL))
			goto retry;
		rc = -ENOMEM;
	}

	*pino = ino;
	return rc;
}

266
static void sysfs_free_ino(unsigned int ino)
267 268 269 270 271 272
{
	spin_lock(&sysfs_ino_lock);
	ida_remove(&sysfs_ino_ida, ino);
	spin_unlock(&sysfs_ino_lock);
}

273
void release_sysfs_dirent(struct sysfs_dirent *sd)
274
{
T
Tejun Heo 已提交
275 276 277
	struct sysfs_dirent *parent_sd;

 repeat:
278 279 280
	/* Moving/renaming is always done while holding reference.
	 * sd->s_parent won't change beneath us.
	 */
T
Tejun Heo 已提交
281 282
	parent_sd = sd->s_parent;

283 284 285 286
	WARN(!(sd->s_flags & SYSFS_FLAG_REMOVED),
		"sysfs: free using entry: %s/%s\n",
		parent_sd ? parent_sd->s_name : "", sd->s_name);

287
	if (sysfs_type(sd) == SYSFS_KOBJ_LINK)
T
Tejun Heo 已提交
288
		sysfs_put(sd->s_symlink.target_sd);
289
	if (sysfs_type(sd) & SYSFS_COPY_NAME)
T
Tejun Heo 已提交
290
		kfree(sd->s_name);
291 292 293
	if (sd->s_iattr && sd->s_iattr->ia_secdata)
		security_release_secctx(sd->s_iattr->ia_secdata,
					sd->s_iattr->ia_secdata_len);
294
	kfree(sd->s_iattr);
295
	sysfs_free_ino(sd->s_ino);
296
	kmem_cache_free(sysfs_dir_cachep, sd);
T
Tejun Heo 已提交
297 298 299 300

	sd = parent_sd;
	if (sd && atomic_dec_and_test(&sd->s_count))
		goto repeat;
301 302
}

N
Nick Piggin 已提交
303
static int sysfs_dentry_delete(const struct dentry *dentry)
304 305
{
	struct sysfs_dirent *sd = dentry->d_fsdata;
306
	return !(sd && !(sd->s_flags & SYSFS_FLAG_REMOVED));
307 308
}

309
static int sysfs_dentry_revalidate(struct dentry *dentry, unsigned int flags)
310
{
311
	struct sysfs_dirent *sd;
312

313
	if (flags & LOOKUP_RCU)
314 315 316
		return -ECHILD;

	sd = dentry->d_fsdata;
317 318 319 320 321 322
	mutex_lock(&sysfs_mutex);

	/* The sysfs dirent has been deleted */
	if (sd->s_flags & SYSFS_FLAG_REMOVED)
		goto out_bad;

323 324 325 326 327 328 329 330
	/* The sysfs dirent has been moved? */
	if (dentry->d_parent->d_fsdata != sd->s_parent)
		goto out_bad;

	/* The sysfs dirent has been renamed */
	if (strcmp(dentry->d_name.name, sd->s_name) != 0)
		goto out_bad;

331
	/* The sysfs dirent has been moved to a different namespace */
T
Tejun Heo 已提交
332 333
	if (sd->s_ns && sd->s_ns != sysfs_info(dentry->d_sb)->ns)
		goto out_bad;
334

335 336 337 338 339 340 341
	mutex_unlock(&sysfs_mutex);
out_valid:
	return 1;
out_bad:
	/* Remove the dentry from the dcache hashes.
	 * If this is a deleted dentry we use d_drop instead of d_delete
	 * so sysfs doesn't need to cope with negative dentries.
342 343 344 345 346 347
	 *
	 * If this is a dentry that has simply been renamed we
	 * use d_drop to remove it from the dcache lookup on its
	 * old parent.  If this dentry persists later when a lookup
	 * is performed at its new name the dentry will be readded
	 * to the dcache hashes.
348 349
	 */
	mutex_unlock(&sysfs_mutex);
350 351 352 353 354 355 356 357

	/* If we have submounts we must allow the vfs caches
	 * to lie about the state of the filesystem to prevent
	 * leaks and other nasty things.
	 */
	if (check_submounts_and_drop(dentry) != 0)
		goto out_valid;

358 359 360
	return 0;
}

361
static void sysfs_dentry_release(struct dentry *dentry)
L
Linus Torvalds 已提交
362
{
363
	sysfs_put(dentry->d_fsdata);
L
Linus Torvalds 已提交
364 365
}

366
const struct dentry_operations sysfs_dentry_ops = {
367 368
	.d_revalidate	= sysfs_dentry_revalidate,
	.d_delete	= sysfs_dentry_delete,
369
	.d_release	= sysfs_dentry_release,
L
Linus Torvalds 已提交
370 371
};

372
struct sysfs_dirent *sysfs_new_dirent(const char *name, umode_t mode, int type)
L
Linus Torvalds 已提交
373
{
T
Tejun Heo 已提交
374
	char *dup_name = NULL;
375
	struct sysfs_dirent *sd;
T
Tejun Heo 已提交
376 377 378 379

	if (type & SYSFS_COPY_NAME) {
		name = dup_name = kstrdup(name, GFP_KERNEL);
		if (!name)
380
			return NULL;
T
Tejun Heo 已提交
381
	}
L
Linus Torvalds 已提交
382

383
	sd = kmem_cache_zalloc(sysfs_dir_cachep, GFP_KERNEL);
L
Linus Torvalds 已提交
384
	if (!sd)
385
		goto err_out1;
L
Linus Torvalds 已提交
386

T
Tejun Heo 已提交
387
	if (sysfs_alloc_ino(&sd->s_ino))
388
		goto err_out2;
389

L
Linus Torvalds 已提交
390
	atomic_set(&sd->s_count, 1);
391
	atomic_set(&sd->s_active, 0);
392

T
Tejun Heo 已提交
393
	sd->s_name = name;
394
	sd->s_mode = mode;
395
	sd->s_flags = type | SYSFS_FLAG_REMOVED;
L
Linus Torvalds 已提交
396 397

	return sd;
T
Tejun Heo 已提交
398

399
 err_out2:
T
Tejun Heo 已提交
400
	kmem_cache_free(sysfs_dir_cachep, sd);
401 402
 err_out1:
	kfree(dup_name);
T
Tejun Heo 已提交
403
	return NULL;
L
Linus Torvalds 已提交
404 405
}

406
/**
407 408
 *	sysfs_addrm_start - prepare for sysfs_dirent add/remove
 *	@acxt: pointer to sysfs_addrm_cxt to be used
409
 *
410 411 412
 *	This function is called when the caller is about to add or remove
 *	sysfs_dirent.  This function acquires sysfs_mutex.  @acxt is used
 *	to keep and pass context to other addrm functions.
413 414
 *
 *	LOCKING:
415
 *	Kernel thread context (may sleep).  sysfs_mutex is locked on
416
 *	return.
417
 */
418 419
void sysfs_addrm_start(struct sysfs_addrm_cxt *acxt)
	__acquires(sysfs_mutex)
420
{
421 422 423 424 425 426
	memset(acxt, 0, sizeof(*acxt));

	mutex_lock(&sysfs_mutex);
}

/**
427
 *	__sysfs_add_one - add sysfs_dirent to parent without warning
428 429
 *	@acxt: addrm context to use
 *	@sd: sysfs_dirent to be added
430
 *	@parent_sd: the parent sysfs_dirent to add @sd to
431
 *
432 433 434
 *	Get @parent_sd and set @sd->s_parent to it and increment nlink of
 *	the parent inode if @sd is a directory and link into the children
 *	list of the parent.
435 436 437 438 439 440 441
 *
 *	This function should be called between calls to
 *	sysfs_addrm_start() and sysfs_addrm_finish() and should be
 *	passed the same @acxt as passed to sysfs_addrm_start().
 *
 *	LOCKING:
 *	Determined by sysfs_addrm_start().
442 443 444 445
 *
 *	RETURNS:
 *	0 on success, -EEXIST if entry with the given name already
 *	exists.
446
 */
447 448
int __sysfs_add_one(struct sysfs_addrm_cxt *acxt, struct sysfs_dirent *sd,
		    struct sysfs_dirent *parent_sd)
449
{
450
	struct sysfs_inode_attrs *ps_iattr;
451
	int ret;
452

T
Tejun Heo 已提交
453
	sd->s_hash = sysfs_name_hash(sd->s_name, sd->s_ns);
454
	sd->s_parent = sysfs_get(parent_sd);
455

456 457 458
	ret = sysfs_link_sibling(sd);
	if (ret)
		return ret;
459

460
	/* Update timestamps on the parent */
461
	ps_iattr = parent_sd->s_iattr;
462 463 464 465 466
	if (ps_iattr) {
		struct iattr *ps_iattrs = &ps_iattr->ia_iattr;
		ps_iattrs->ia_ctime = ps_iattrs->ia_mtime = CURRENT_TIME;
	}

467 468 469
	/* Mark the entry added into directory tree */
	sd->s_flags &= ~SYSFS_FLAG_REMOVED;

470
	return 0;
471 472
}

473 474 475
/**
 *	sysfs_pathname - return full path to sysfs dirent
 *	@sd: sysfs_dirent whose path we want
476
 *	@path: caller allocated buffer of size PATH_MAX
477 478 479 480 481 482 483 484
 *
 *	Gives the name "/" to the sysfs_root entry; any path returned
 *	is relative to wherever sysfs is mounted.
 */
static char *sysfs_pathname(struct sysfs_dirent *sd, char *path)
{
	if (sd->s_parent) {
		sysfs_pathname(sd->s_parent, path);
485
		strlcat(path, "/", PATH_MAX);
486
	}
487
	strlcat(path, sd->s_name, PATH_MAX);
488 489 490
	return path;
}

491 492 493 494
/**
 *	sysfs_add_one - add sysfs_dirent to parent
 *	@acxt: addrm context to use
 *	@sd: sysfs_dirent to be added
495
 *	@parent_sd: the parent sysfs_dirent to add @sd to
496
 *
497 498 499
 *	Get @parent_sd and set @sd->s_parent to it and increment nlink of
 *	the parent inode if @sd is a directory and link into the children
 *	list of the parent.
500 501 502 503 504 505 506 507 508 509 510 511
 *
 *	This function should be called between calls to
 *	sysfs_addrm_start() and sysfs_addrm_finish() and should be
 *	passed the same @acxt as passed to sysfs_addrm_start().
 *
 *	LOCKING:
 *	Determined by sysfs_addrm_start().
 *
 *	RETURNS:
 *	0 on success, -EEXIST if entry with the given name already
 *	exists.
 */
512 513
int sysfs_add_one(struct sysfs_addrm_cxt *acxt, struct sysfs_dirent *sd,
		  struct sysfs_dirent *parent_sd)
514 515 516
{
	int ret;

517
	ret = __sysfs_add_one(acxt, sd, parent_sd);
518 519 520 521
	if (ret == -EEXIST) {
		char *path = kzalloc(PATH_MAX, GFP_KERNEL);
		WARN(1, KERN_WARNING
		     "sysfs: cannot create duplicate filename '%s'\n",
522
		     (path == NULL) ? sd->s_name
523
				    : (sysfs_pathname(parent_sd, path),
524 525 526
				       strlcat(path, "/", PATH_MAX),
				       strlcat(path, sd->s_name, PATH_MAX),
				       path));
527 528 529
		kfree(path);
	}

530 531 532
	return ret;
}

533 534 535
/**
 *	sysfs_remove_one - remove sysfs_dirent from parent
 *	@acxt: addrm context to use
536
 *	@sd: sysfs_dirent to be removed
537 538
 *
 *	Mark @sd removed and drop nlink of parent inode if @sd is a
539
 *	directory.  @sd is unlinked from the children list.
540 541 542 543 544 545 546 547 548 549
 *
 *	This function should be called between calls to
 *	sysfs_addrm_start() and sysfs_addrm_finish() and should be
 *	passed the same @acxt as passed to sysfs_addrm_start().
 *
 *	LOCKING:
 *	Determined by sysfs_addrm_start().
 */
void sysfs_remove_one(struct sysfs_addrm_cxt *acxt, struct sysfs_dirent *sd)
{
550 551
	struct sysfs_inode_attrs *ps_iattr;

552 553 554 555 556 557
	/*
	 * Removal can be called multiple times on the same node.  Only the
	 * first invocation is effective and puts the base ref.
	 */
	if (sd->s_flags & SYSFS_FLAG_REMOVED)
		return;
558 559

	sysfs_unlink_sibling(sd);
560

561
	/* Update timestamps on the parent */
562
	ps_iattr = sd->s_parent->s_iattr;
563 564 565 566 567
	if (ps_iattr) {
		struct iattr *ps_iattrs = &ps_iattr->ia_iattr;
		ps_iattrs->ia_ctime = ps_iattrs->ia_mtime = CURRENT_TIME;
	}

568
	sd->s_flags |= SYSFS_FLAG_REMOVED;
M
Mikulas Patocka 已提交
569
	sd->u.removed_list = acxt->removed;
570
	acxt->removed = sd;
571 572
}

573 574 575 576 577 578
/**
 *	sysfs_addrm_finish - finish up sysfs_dirent add/remove
 *	@acxt: addrm context to finish up
 *
 *	Finish up sysfs_dirent add/remove.  Resources acquired by
 *	sysfs_addrm_start() are released and removed sysfs_dirents are
579
 *	cleaned up.
580 581
 *
 *	LOCKING:
582
 *	sysfs_mutex is released.
583
 */
584
void sysfs_addrm_finish(struct sysfs_addrm_cxt *acxt)
585
	__releases(sysfs_mutex)
586 587 588 589 590 591 592 593
{
	/* release resources acquired by sysfs_addrm_start() */
	mutex_unlock(&sysfs_mutex);

	/* kill removed sysfs_dirents */
	while (acxt->removed) {
		struct sysfs_dirent *sd = acxt->removed;

M
Mikulas Patocka 已提交
594
		acxt->removed = sd->u.removed_list;
595 596

		sysfs_deactivate(sd);
597
		unmap_bin_file(sd);
598
		sysfs_put(sd);
T
Tejun Heo 已提交
599
	}
600 601
}

602 603 604 605
/**
 *	sysfs_find_dirent - find sysfs_dirent with the given name
 *	@parent_sd: sysfs_dirent to search under
 *	@name: name to look for
T
Tejun Heo 已提交
606
 *	@ns: the namespace tag to use
607 608
 *
 *	Look for sysfs_dirent with name @name under @parent_sd.
609
 *
610
 *	LOCKING:
611
 *	mutex_lock(sysfs_mutex)
612
 *
613 614
 *	RETURNS:
 *	Pointer to sysfs_dirent if found, NULL if not.
615
 */
616
struct sysfs_dirent *sysfs_find_dirent(struct sysfs_dirent *parent_sd,
T
Tejun Heo 已提交
617 618
				       const unsigned char *name,
				       const void *ns)
619
{
620 621
	struct rb_node *node = parent_sd->s_dir.children.rb_node;
	unsigned int hash;
622

T
Tejun Heo 已提交
623
	hash = sysfs_name_hash(name, ns);
624 625 626 627 628
	while (node) {
		struct sysfs_dirent *sd;
		int result;

		sd = to_sysfs_dirent(node);
T
Tejun Heo 已提交
629
		result = sysfs_name_compare(hash, name, ns, sd);
630 631 632 633 634 635
		if (result < 0)
			node = node->rb_left;
		else if (result > 0)
			node = node->rb_right;
		else
			return sd;
636
	}
637
	return NULL;
638
}
639

640
/**
T
Tejun Heo 已提交
641
 *	sysfs_get_dirent_ns - find and get sysfs_dirent with the given name
642 643
 *	@parent_sd: sysfs_dirent to search under
 *	@name: name to look for
T
Tejun Heo 已提交
644
 *	@ns: the namespace tag to use
645 646 647 648 649
 *
 *	Look for sysfs_dirent with name @name under @parent_sd and get
 *	it if found.
 *
 *	LOCKING:
650
 *	Kernel thread context (may sleep).  Grabs sysfs_mutex.
651 652 653 654
 *
 *	RETURNS:
 *	Pointer to sysfs_dirent if found, NULL if not.
 */
T
Tejun Heo 已提交
655 656 657
struct sysfs_dirent *sysfs_get_dirent_ns(struct sysfs_dirent *parent_sd,
					 const unsigned char *name,
					 const void *ns)
658 659 660
{
	struct sysfs_dirent *sd;

661
	mutex_lock(&sysfs_mutex);
T
Tejun Heo 已提交
662
	sd = sysfs_find_dirent(parent_sd, name, ns);
663
	sysfs_get(sd);
664
	mutex_unlock(&sysfs_mutex);
665 666

	return sd;
667
}
T
Tejun Heo 已提交
668
EXPORT_SYMBOL_GPL(sysfs_get_dirent_ns);
669

670
static int create_dir(struct kobject *kobj, struct sysfs_dirent *parent_sd,
T
Tejun Heo 已提交
671 672
		      const char *name, const void *ns,
		      struct sysfs_dirent **p_sd)
L
Linus Torvalds 已提交
673
{
674
	umode_t mode = S_IFDIR | S_IRWXU | S_IRUGO | S_IXUGO;
675
	struct sysfs_addrm_cxt acxt;
676
	struct sysfs_dirent *sd;
677
	int rc;
L
Linus Torvalds 已提交
678

679
	/* allocate */
680
	sd = sysfs_new_dirent(name, mode, SYSFS_DIR);
681
	if (!sd)
682
		return -ENOMEM;
683 684

	sd->s_ns = ns;
T
Tejun Heo 已提交
685
	sd->s_dir.kobj = kobj;
686

687
	/* link in */
688 689
	sysfs_addrm_start(&acxt);
	rc = sysfs_add_one(&acxt, sd, parent_sd);
690
	sysfs_addrm_finish(&acxt);
691

692 693 694
	if (rc == 0)
		*p_sd = sd;
	else
695
		sysfs_put(sd);
696

697
	return rc;
L
Linus Torvalds 已提交
698 699
}

700 701
int sysfs_create_subdir(struct kobject *kobj, const char *name,
			struct sysfs_dirent **p_sd)
L
Linus Torvalds 已提交
702
{
T
Tejun Heo 已提交
703
	return create_dir(kobj, kobj->sd, name, NULL, p_sd);
L
Linus Torvalds 已提交
704 705 706
}

/**
707 708 709
 * sysfs_create_dir_ns - create a directory for an object with a namespace tag
 * @kobj: object we're creating directory for
 * @ns: the namespace tag to use
L
Linus Torvalds 已提交
710
 */
711
int sysfs_create_dir_ns(struct kobject *kobj, const void *ns)
L
Linus Torvalds 已提交
712
{
713
	struct sysfs_dirent *parent_sd, *sd;
L
Linus Torvalds 已提交
714 715 716 717
	int error = 0;

	BUG_ON(!kobj);

718
	if (kobj->parent)
719
		parent_sd = kobj->parent->sd;
L
Linus Torvalds 已提交
720
	else
E
Eric W. Biederman 已提交
721
		parent_sd = &sysfs_root;
L
Linus Torvalds 已提交
722

723 724 725
	if (!parent_sd)
		return -ENOENT;

T
Tejun Heo 已提交
726
	error = create_dir(kobj, parent_sd, kobject_name(kobj), ns, &sd);
L
Linus Torvalds 已提交
727
	if (!error)
728
		kobj->sd = sd;
L
Linus Torvalds 已提交
729 730 731
	return error;
}

732 733
static struct dentry *sysfs_lookup(struct inode *dir, struct dentry *dentry,
				   unsigned int flags)
L
Linus Torvalds 已提交
734
{
735
	struct dentry *ret = NULL;
736 737
	struct dentry *parent = dentry->d_parent;
	struct sysfs_dirent *parent_sd = parent->d_fsdata;
738
	struct sysfs_dirent *sd;
739
	struct inode *inode;
T
Tejun Heo 已提交
740
	const void *ns = NULL;
L
Linus Torvalds 已提交
741

742 743
	mutex_lock(&sysfs_mutex);

T
Tejun Heo 已提交
744 745
	if (parent_sd->s_flags & SYSFS_FLAG_HAS_NS)
		ns = sysfs_info(dir->i_sb)->ns;
746

T
Tejun Heo 已提交
747
	sd = sysfs_find_dirent(parent_sd, dentry->d_name.name, ns);
L
Linus Torvalds 已提交
748

749
	/* no such entry */
750 751
	if (!sd) {
		ret = ERR_PTR(-ENOENT);
752
		goto out_unlock;
753
	}
754
	dentry->d_fsdata = sysfs_get(sd);
755 756

	/* attach dentry and inode */
757
	inode = sysfs_get_inode(dir->i_sb, sd);
758 759 760 761
	if (!inode) {
		ret = ERR_PTR(-ENOMEM);
		goto out_unlock;
	}
762

T
Tejun Heo 已提交
763
	/* instantiate and hash dentry */
A
Al Viro 已提交
764
	ret = d_materialise_unique(dentry, inode);
765
 out_unlock:
766
	mutex_unlock(&sysfs_mutex);
767
	return ret;
L
Linus Torvalds 已提交
768 769
}

770
const struct inode_operations sysfs_dir_inode_operations = {
L
Linus Torvalds 已提交
771
	.lookup		= sysfs_lookup,
772
	.permission	= sysfs_permission,
773
	.setattr	= sysfs_setattr,
774
	.getattr	= sysfs_getattr,
775
	.setxattr	= sysfs_setxattr,
L
Linus Torvalds 已提交
776 777
};

778
static void remove_dir(struct sysfs_dirent *sd)
L
Linus Torvalds 已提交
779
{
780
	struct sysfs_addrm_cxt acxt;
L
Linus Torvalds 已提交
781

782
	sysfs_addrm_start(&acxt);
783 784
	sysfs_remove_one(&acxt, sd);
	sysfs_addrm_finish(&acxt);
L
Linus Torvalds 已提交
785 786
}

787
void sysfs_remove_subdir(struct sysfs_dirent *sd)
L
Linus Torvalds 已提交
788
{
789
	remove_dir(sd);
L
Linus Torvalds 已提交
790 791
}

792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845
static struct sysfs_dirent *sysfs_leftmost_descendant(struct sysfs_dirent *pos)
{
	struct sysfs_dirent *last;

	while (true) {
		struct rb_node *rbn;

		last = pos;

		if (sysfs_type(pos) != SYSFS_DIR)
			break;

		rbn = rb_first(&pos->s_dir.children);
		if (!rbn)
			break;

		pos = to_sysfs_dirent(rbn);
	}

	return last;
}

/**
 * sysfs_next_descendant_post - find the next descendant for post-order walk
 * @pos: the current position (%NULL to initiate traversal)
 * @root: sysfs_dirent whose descendants to walk
 *
 * 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.
 */
static struct sysfs_dirent *sysfs_next_descendant_post(struct sysfs_dirent *pos,
						       struct sysfs_dirent *root)
{
	struct rb_node *rbn;

	lockdep_assert_held(&sysfs_mutex);

	/* if first iteration, visit leftmost descendant which may be root */
	if (!pos)
		return sysfs_leftmost_descendant(root);

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

	/* if there's an unvisited sibling, visit its leftmost descendant */
	rbn = rb_next(&pos->s_rb);
	if (rbn)
		return sysfs_leftmost_descendant(to_sysfs_dirent(rbn));

	/* no sibling left, visit parent */
	return pos->s_parent;
}
L
Linus Torvalds 已提交
846

847
static void __sysfs_remove_dir(struct sysfs_dirent *dir_sd)
L
Linus Torvalds 已提交
848
{
849
	struct sysfs_addrm_cxt acxt;
850
	struct sysfs_dirent *pos, *next;
L
Linus Torvalds 已提交
851

852
	if (!dir_sd)
L
Linus Torvalds 已提交
853 854
		return;

855
	pr_debug("sysfs %s: removing dir\n", dir_sd->s_name);
856
	sysfs_addrm_start(&acxt);
857

858 859 860 861 862 863 864 865 866
	next = NULL;
	do {
		pos = next;
		next = sysfs_next_descendant_post(pos, dir_sd);
		if (pos)
			sysfs_remove_one(&acxt, pos);
	} while (next);

	sysfs_addrm_finish(&acxt);
867 868 869 870 871 872 873 874 875 876
}

/**
 *	sysfs_remove_dir - remove an object's directory.
 *	@kobj:	object.
 *
 *	The only thing special about this is that we remove any files in
 *	the directory before we remove the directory, and we've inlined
 *	what used to be sysfs_rmdir() below, instead of calling separately.
 */
877
void sysfs_remove_dir(struct kobject *kobj)
878
{
879
	struct sysfs_dirent *sd = kobj->sd;
880

T
Tejun Heo 已提交
881
	spin_lock(&sysfs_assoc_lock);
882
	kobj->sd = NULL;
T
Tejun Heo 已提交
883
	spin_unlock(&sysfs_assoc_lock);
884

885
	__sysfs_remove_dir(sd);
L
Linus Torvalds 已提交
886 887
}

T
Tejun Heo 已提交
888 889
int sysfs_rename(struct sysfs_dirent *sd, struct sysfs_dirent *new_parent_sd,
		 const char *new_name, const void *new_ns)
L
Linus Torvalds 已提交
890
{
891
	int error;
L
Linus Torvalds 已提交
892

893
	mutex_lock(&sysfs_mutex);
894

895
	error = 0;
896
	if ((sd->s_parent == new_parent_sd) && (sd->s_ns == new_ns) &&
897
	    (strcmp(sd->s_name, new_name) == 0))
898 899 900
		goto out;	/* nothing to rename */

	error = -EEXIST;
T
Tejun Heo 已提交
901
	if (sysfs_find_dirent(new_parent_sd, new_name, new_ns))
902
		goto out;
903

904
	/* rename sysfs_dirent */
905 906
	if (strcmp(sd->s_name, new_name) != 0) {
		error = -ENOMEM;
907
		new_name = kstrdup(new_name, GFP_KERNEL);
908 909 910
		if (!new_name)
			goto out;

911
		kfree(sd->s_name);
912 913
		sd->s_name = new_name;
	}
T
Tejun Heo 已提交
914

915 916 917
	/*
	 * Move to the appropriate place in the appropriate directories rbtree.
	 */
918 919 920
	sysfs_unlink_sibling(sd);
	sysfs_get(new_parent_sd);
	sysfs_put(sd->s_parent);
921
	sd->s_ns = new_ns;
T
Tejun Heo 已提交
922
	sd->s_hash = sysfs_name_hash(sd->s_name, sd->s_ns);
923 924
	sd->s_parent = new_parent_sd;
	sysfs_link_sibling(sd);
T
Tejun Heo 已提交
925

926
	error = 0;
927
 out:
928
	mutex_unlock(&sysfs_mutex);
L
Linus Torvalds 已提交
929 930 931
	return error;
}

932 933
int sysfs_rename_dir_ns(struct kobject *kobj, const char *new_name,
			const void *new_ns)
934
{
935 936
	struct sysfs_dirent *parent_sd = kobj->sd->s_parent;

T
Tejun Heo 已提交
937
	return sysfs_rename(kobj->sd, parent_sd, new_name, new_ns);
938 939
}

940 941
int sysfs_move_dir_ns(struct kobject *kobj, struct kobject *new_parent_kobj,
		      const void *new_ns)
942
{
943 944
	struct sysfs_dirent *sd = kobj->sd;
	struct sysfs_dirent *new_parent_sd;
945

946
	BUG_ON(!sd->s_parent);
947
	new_parent_sd = new_parent_kobj && new_parent_kobj->sd ?
948
		new_parent_kobj->sd : &sysfs_root;
949

T
Tejun Heo 已提交
950
	return sysfs_rename(sd, new_parent_sd, sd->s_name, new_ns);
951 952
}

L
Linus Torvalds 已提交
953 954 955 956 957 958
/* Relationship between s_mode and the DT_xxx types */
static inline unsigned char dt_type(struct sysfs_dirent *sd)
{
	return (sd->s_mode >> 12) & 15;
}

959 960 961 962 963 964
static int sysfs_dir_release(struct inode *inode, struct file *filp)
{
	sysfs_put(filp->private_data);
	return 0;
}

965
static struct sysfs_dirent *sysfs_dir_pos(const void *ns,
966
	struct sysfs_dirent *parent_sd,	loff_t hash, struct sysfs_dirent *pos)
967 968 969 970
{
	if (pos) {
		int valid = !(pos->s_flags & SYSFS_FLAG_REMOVED) &&
			pos->s_parent == parent_sd &&
971
			hash == pos->s_hash;
972
		sysfs_put(pos);
973 974
		if (!valid)
			pos = NULL;
975
	}
976 977 978 979 980 981 982 983 984 985
	if (!pos && (hash > 1) && (hash < INT_MAX)) {
		struct rb_node *node = parent_sd->s_dir.children.rb_node;
		while (node) {
			pos = to_sysfs_dirent(node);

			if (hash < pos->s_hash)
				node = node->rb_left;
			else if (hash > pos->s_hash)
				node = node->rb_right;
			else
986 987 988
				break;
		}
	}
989
	/* Skip over entries in the wrong namespace */
990
	while (pos && pos->s_ns != ns) {
991 992
		struct rb_node *node = rb_next(&pos->s_rb);
		if (!node)
993 994
			pos = NULL;
		else
995
			pos = to_sysfs_dirent(node);
996 997 998 999
	}
	return pos;
}

1000 1001
static struct sysfs_dirent *sysfs_dir_next_pos(const void *ns,
	struct sysfs_dirent *parent_sd,	ino_t ino, struct sysfs_dirent *pos)
1002
{
1003
	pos = sysfs_dir_pos(ns, parent_sd, ino, pos);
1004 1005 1006 1007 1008 1009 1010 1011
	if (pos)
		do {
			struct rb_node *node = rb_next(&pos->s_rb);
			if (!node)
				pos = NULL;
			else
				pos = to_sysfs_dirent(node);
		} while (pos && pos->s_ns != ns);
1012 1013 1014
	return pos;
}

A
Al Viro 已提交
1015
static int sysfs_readdir(struct file *file, struct dir_context *ctx)
L
Linus Torvalds 已提交
1016
{
A
Al Viro 已提交
1017
	struct dentry *dentry = file->f_path.dentry;
1018
	struct sysfs_dirent *parent_sd = dentry->d_fsdata;
A
Al Viro 已提交
1019
	struct sysfs_dirent *pos = file->private_data;
T
Tejun Heo 已提交
1020
	const void *ns = NULL;
1021

A
Al Viro 已提交
1022 1023
	if (!dir_emit_dots(file, ctx))
		return 0;
1024
	mutex_lock(&sysfs_mutex);
T
Tejun Heo 已提交
1025 1026 1027 1028

	if (parent_sd->s_flags & SYSFS_FLAG_HAS_NS)
		ns = sysfs_info(dentry->d_sb)->ns;

A
Al Viro 已提交
1029
	for (pos = sysfs_dir_pos(ns, parent_sd, ctx->pos, pos);
1030
	     pos;
A
Al Viro 已提交
1031 1032 1033 1034 1035 1036 1037
	     pos = sysfs_dir_next_pos(ns, parent_sd, ctx->pos, pos)) {
		const char *name = pos->s_name;
		unsigned int type = dt_type(pos);
		int len = strlen(name);
		ino_t ino = pos->s_ino;
		ctx->pos = pos->s_hash;
		file->private_data = sysfs_get(pos);
L
Linus Torvalds 已提交
1038

1039
		mutex_unlock(&sysfs_mutex);
A
Al Viro 已提交
1040 1041
		if (!dir_emit(ctx, name, len, ino, type))
			return 0;
1042 1043 1044
		mutex_lock(&sysfs_mutex);
	}
	mutex_unlock(&sysfs_mutex);
A
Al Viro 已提交
1045 1046
	file->private_data = NULL;
	ctx->pos = INT_MAX;
E
Eric W. Biederman 已提交
1047
	return 0;
L
Linus Torvalds 已提交
1048 1049
}

1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060
static loff_t sysfs_dir_llseek(struct file *file, loff_t offset, int whence)
{
	struct inode *inode = file_inode(file);
	loff_t ret;

	mutex_lock(&inode->i_mutex);
	ret = generic_file_llseek(file, offset, whence);
	mutex_unlock(&inode->i_mutex);

	return ret;
}
E
Eric W. Biederman 已提交
1061

1062
const struct file_operations sysfs_dir_operations = {
L
Linus Torvalds 已提交
1063
	.read		= generic_read_dir,
A
Al Viro 已提交
1064
	.iterate	= sysfs_readdir,
1065
	.release	= sysfs_dir_release,
1066
	.llseek		= sysfs_dir_llseek,
L
Linus Torvalds 已提交
1067
};