namei.c 82.5 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
/*
 *  linux/fs/namei.c
 *
 *  Copyright (C) 1991, 1992  Linus Torvalds
 */

/*
 * Some corrections by tytso.
 */

/* [Feb 1997 T. Schoebel-Theuer] Complete rewrite of the pathname
 * lookup logic.
 */
/* [Feb-Apr 2000, AV] Rewrite to the new namespace architecture.
 */

#include <linux/init.h>
18
#include <linux/export.h>
Linus Torvalds's avatar
Linus Torvalds committed
19 20 21 22
#include <linux/slab.h>
#include <linux/fs.h>
#include <linux/namei.h>
#include <linux/pagemap.h>
Robert Love's avatar
Robert Love committed
23
#include <linux/fsnotify.h>
Linus Torvalds's avatar
Linus Torvalds committed
24 25
#include <linux/personality.h>
#include <linux/security.h>
Mimi Zohar's avatar
Mimi Zohar committed
26
#include <linux/ima.h>
Linus Torvalds's avatar
Linus Torvalds committed
27 28 29
#include <linux/syscalls.h>
#include <linux/mount.h>
#include <linux/audit.h>
30
#include <linux/capability.h>
31
#include <linux/file.h>
32
#include <linux/fcntl.h>
33
#include <linux/device_cgroup.h>
34
#include <linux/fs_struct.h>
35
#include <linux/posix_acl.h>
Linus Torvalds's avatar
Linus Torvalds committed
36 37
#include <asm/uaccess.h>

38
#include "internal.h"
39
#include "mount.h"
40

Linus Torvalds's avatar
Linus Torvalds committed
41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74
/* [Feb-1997 T. Schoebel-Theuer]
 * Fundamental changes in the pathname lookup mechanisms (namei)
 * were necessary because of omirr.  The reason is that omirr needs
 * to know the _real_ pathname, not the user-supplied one, in case
 * of symlinks (and also when transname replacements occur).
 *
 * The new code replaces the old recursive symlink resolution with
 * an iterative one (in case of non-nested symlink chains).  It does
 * this with calls to <fs>_follow_link().
 * As a side effect, dir_namei(), _namei() and follow_link() are now 
 * replaced with a single function lookup_dentry() that can handle all 
 * the special cases of the former code.
 *
 * With the new dcache, the pathname is stored at each inode, at least as
 * long as the refcount of the inode is positive.  As a side effect, the
 * size of the dcache depends on the inode cache and thus is dynamic.
 *
 * [29-Apr-1998 C. Scott Ananian] Updated above description of symlink
 * resolution to correspond with current state of the code.
 *
 * Note that the symlink resolution is not *completely* iterative.
 * There is still a significant amount of tail- and mid- recursion in
 * the algorithm.  Also, note that <fs>_readlink() is not used in
 * lookup_dentry(): lookup_dentry() on the result of <fs>_readlink()
 * may return different results than <fs>_follow_link().  Many virtual
 * filesystems (including /proc) exhibit this behavior.
 */

/* [24-Feb-97 T. Schoebel-Theuer] Side effects caused by new implementation:
 * New symlink semantics: when open() is called with flags O_CREAT | O_EXCL
 * and the name already exists in form of a symlink, try to create the new
 * name indicated by the symlink. The old code always complained that the
 * name already exists, due to not following the symlink even if its target
 * is nonexistent.  The new semantics affects also mknod() and link() when
Lucas De Marchi's avatar
Lucas De Marchi committed
75
 * the name is a symlink pointing to a non-existent name.
Linus Torvalds's avatar
Linus Torvalds committed
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
 *
 * I don't know which semantics is the right one, since I have no access
 * to standards. But I found by trial that HP-UX 9.0 has the full "new"
 * semantics implemented, while SunOS 4.1.1 and Solaris (SunOS 5.4) have the
 * "old" one. Personally, I think the new semantics is much more logical.
 * Note that "ln old new" where "new" is a symlink pointing to a non-existing
 * file does succeed in both HP-UX and SunOs, but not in Solaris
 * and in the old Linux semantics.
 */

/* [16-Dec-97 Kevin Buhr] For security reasons, we change some symlink
 * semantics.  See the comments in "open_namei" and "do_link" below.
 *
 * [10-Sep-98 Alan Modra] Another symlink change.
 */

/* [Feb-Apr 2000 AV] Complete rewrite. Rules for symlinks:
 *	inside the path - always follow.
 *	in the last component in creation/removal/renaming - never follow.
 *	if LOOKUP_FOLLOW passed - follow.
 *	if the pathname has trailing slashes - follow.
 *	otherwise - don't follow.
 * (applied in that order).
 *
 * [Jun 2000 AV] Inconsistent behaviour of open() in case if flags==O_CREAT
 * restored for 2.4. This is the last surviving part of old 4.2BSD bug.
 * During the 2.4 we need to fix the userland stuff depending on it -
 * hopefully we will be able to get rid of that wart in 2.5. So far only
 * XEmacs seems to be relying on it...
 */
/*
 * [Sep 2001 AV] Single-semaphore locking scheme (kudos to David Holland)
108
 * implemented.  Let's see if raised priority of ->s_vfs_rename_mutex gives
Linus Torvalds's avatar
Linus Torvalds committed
109 110 111 112 113 114 115 116 117 118
 * any extra contention...
 */

/* In order to reduce some races, while at the same time doing additional
 * checking and hopefully speeding things up, we copy filenames to the
 * kernel data space before using them..
 *
 * POSIX.1 2.4: an empty pathname is invalid (ENOENT).
 * PATH_MAX includes the nul terminator --RR.
 */
119
static int do_getname(const char __user *filename, char *page)
Linus Torvalds's avatar
Linus Torvalds committed
120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140
{
	int retval;
	unsigned long len = PATH_MAX;

	if (!segment_eq(get_fs(), KERNEL_DS)) {
		if ((unsigned long) filename >= TASK_SIZE)
			return -EFAULT;
		if (TASK_SIZE - (unsigned long) filename < PATH_MAX)
			len = TASK_SIZE - (unsigned long) filename;
	}

	retval = strncpy_from_user(page, filename, len);
	if (retval > 0) {
		if (retval < len)
			return 0;
		return -ENAMETOOLONG;
	} else if (!retval)
		retval = -ENOENT;
	return retval;
}

141
static char *getname_flags(const char __user *filename, int flags, int *empty)
Linus Torvalds's avatar
Linus Torvalds committed
142
{
143 144 145 146 147 148 149 150 151 152 153 154 155
	char *result = __getname();
	int retval;

	if (!result)
		return ERR_PTR(-ENOMEM);

	retval = do_getname(filename, result);
	if (retval < 0) {
		if (retval == -ENOENT && empty)
			*empty = 1;
		if (retval != -ENOENT || !(flags & LOOKUP_EMPTY)) {
			__putname(result);
			return ERR_PTR(retval);
Linus Torvalds's avatar
Linus Torvalds committed
156 157 158 159 160 161
		}
	}
	audit_getname(result);
	return result;
}

Al Viro's avatar
Al Viro committed
162 163
char *getname(const char __user * filename)
{
164
	return getname_flags(filename, 0, 0);
Al Viro's avatar
Al Viro committed
165 166
}

Linus Torvalds's avatar
Linus Torvalds committed
167 168 169
#ifdef CONFIG_AUDITSYSCALL
void putname(const char *name)
{
170
	if (unlikely(!audit_dummy_context()))
Linus Torvalds's avatar
Linus Torvalds committed
171 172 173 174 175 176 177
		audit_putname(name);
	else
		__putname(name);
}
EXPORT_SYMBOL(putname);
#endif

178 179
static int check_acl(struct inode *inode, int mask)
{
180
#ifdef CONFIG_FS_POSIX_ACL
181 182 183
	struct posix_acl *acl;

	if (mask & MAY_NOT_BLOCK) {
184 185
		acl = get_cached_acl_rcu(inode, ACL_TYPE_ACCESS);
	        if (!acl)
186
	                return -EAGAIN;
187 188 189
		/* no ->get_acl() calls in RCU mode... */
		if (acl == ACL_NOT_CACHED)
			return -ECHILD;
190
	        return posix_acl_permission(inode, acl, mask & ~MAY_NOT_BLOCK);
191 192 193 194 195
	}

	acl = get_cached_acl(inode, ACL_TYPE_ACCESS);

	/*
196 197 198
	 * A filesystem can force a ACL callback by just never filling the
	 * ACL cache. But normally you'd fill the cache either at inode
	 * instantiation time, or on the first ->get_acl call.
199
	 *
200 201
	 * If the filesystem doesn't have a get_acl() function at all, we'll
	 * just create the negative cache entry.
202 203
	 */
	if (acl == ACL_NOT_CACHED) {
204 205 206 207 208 209 210 211
	        if (inode->i_op->get_acl) {
			acl = inode->i_op->get_acl(inode, ACL_TYPE_ACCESS);
			if (IS_ERR(acl))
				return PTR_ERR(acl);
		} else {
		        set_cached_acl(inode, ACL_TYPE_ACCESS, NULL);
		        return -EAGAIN;
		}
212 213 214 215 216 217 218
	}

	if (acl) {
	        int error = posix_acl_permission(inode, acl, mask);
	        posix_acl_release(acl);
	        return error;
	}
219
#endif
220 221 222 223

	return -EAGAIN;
}

224
/*
225
 * This does the basic permission checking
Linus Torvalds's avatar
Linus Torvalds committed
226
 */
227
static int acl_permission_check(struct inode *inode, int mask)
Linus Torvalds's avatar
Linus Torvalds committed
228
{
229
	unsigned int mode = inode->i_mode;
Linus Torvalds's avatar
Linus Torvalds committed
230

231 232 233
	if (current_user_ns() != inode_userns(inode))
		goto other_perms;

234
	if (likely(current_fsuid() == inode->i_uid))
Linus Torvalds's avatar
Linus Torvalds committed
235 236
		mode >>= 6;
	else {
237
		if (IS_POSIXACL(inode) && (mode & S_IRWXG)) {
238
			int error = check_acl(inode, mask);
239 240
			if (error != -EAGAIN)
				return error;
Linus Torvalds's avatar
Linus Torvalds committed
241 242 243 244 245 246
		}

		if (in_group_p(inode->i_gid))
			mode >>= 3;
	}

247
other_perms:
Linus Torvalds's avatar
Linus Torvalds committed
248 249 250
	/*
	 * If the DACs are ok we don't need any capability check.
	 */
251
	if ((mask & ~mode & (MAY_READ | MAY_WRITE | MAY_EXEC)) == 0)
Linus Torvalds's avatar
Linus Torvalds committed
252
		return 0;
253 254 255 256
	return -EACCES;
}

/**
257
 * generic_permission -  check for access rights on a Posix-like filesystem
258
 * @inode:	inode to check access rights for
259
 * @mask:	right to check for (%MAY_READ, %MAY_WRITE, %MAY_EXEC, ...)
260 261 262 263
 *
 * Used to check for read/write/execute permissions on a file.
 * We use "fsuid" for this, letting us set arbitrary permissions
 * for filesystem access without changing the "normal" uids which
264 265 266 267 268
 * are used for other things.
 *
 * generic_permission is rcu-walk aware. It returns -ECHILD in case an rcu-walk
 * request cannot be satisfied (eg. requires blocking or too much complexity).
 * It would then be called again in ref-walk mode.
269
 */
270
int generic_permission(struct inode *inode, int mask)
271 272 273 274
{
	int ret;

	/*
275
	 * Do the basic permission checks.
276
	 */
277
	ret = acl_permission_check(inode, mask);
278 279
	if (ret != -EACCES)
		return ret;
Linus Torvalds's avatar
Linus Torvalds committed
280

281 282 283 284 285 286 287 288 289
	if (S_ISDIR(inode->i_mode)) {
		/* DACs are overridable for directories */
		if (ns_capable(inode_userns(inode), CAP_DAC_OVERRIDE))
			return 0;
		if (!(mask & MAY_WRITE))
			if (ns_capable(inode_userns(inode), CAP_DAC_READ_SEARCH))
				return 0;
		return -EACCES;
	}
Linus Torvalds's avatar
Linus Torvalds committed
290 291
	/*
	 * Read/write DACs are always overridable.
292 293
	 * Executable DACs are overridable when there is
	 * at least one exec bit set.
Linus Torvalds's avatar
Linus Torvalds committed
294
	 */
295
	if (!(mask & MAY_EXEC) || (inode->i_mode & S_IXUGO))
296
		if (ns_capable(inode_userns(inode), CAP_DAC_OVERRIDE))
Linus Torvalds's avatar
Linus Torvalds committed
297 298 299 300 301
			return 0;

	/*
	 * Searching includes executable on directories, else just read.
	 */
302
	mask &= MAY_READ | MAY_WRITE | MAY_EXEC;
303
	if (mask == MAY_READ)
304
		if (ns_capable(inode_userns(inode), CAP_DAC_READ_SEARCH))
Linus Torvalds's avatar
Linus Torvalds committed
305 306 307 308 309
			return 0;

	return -EACCES;
}

310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329
/*
 * We _really_ want to just do "generic_permission()" without
 * even looking at the inode->i_op values. So we keep a cache
 * flag in inode->i_opflags, that says "this has not special
 * permission function, use the fast case".
 */
static inline int do_inode_permission(struct inode *inode, int mask)
{
	if (unlikely(!(inode->i_opflags & IOP_FASTPERM))) {
		if (likely(inode->i_op->permission))
			return inode->i_op->permission(inode, mask);

		/* This gets set once for the inode lifetime */
		spin_lock(&inode->i_lock);
		inode->i_opflags |= IOP_FASTPERM;
		spin_unlock(&inode->i_lock);
	}
	return generic_permission(inode, mask);
}

Christoph Hellwig's avatar
Christoph Hellwig committed
330 331 332
/**
 * inode_permission  -  check for access rights to a given inode
 * @inode:	inode to check permission on
333
 * @mask:	right to check for (%MAY_READ, %MAY_WRITE, %MAY_EXEC, ...)
Christoph Hellwig's avatar
Christoph Hellwig committed
334 335 336 337 338
 *
 * Used to check for read/write/execute permissions on an inode.
 * We use "fsuid" for this, letting us set arbitrary permissions
 * for filesystem access without changing the "normal" uids which
 * are used for other things.
339 340
 *
 * When checking for MAY_APPEND, MAY_WRITE must also be set in @mask.
Christoph Hellwig's avatar
Christoph Hellwig committed
341
 */
342
int inode_permission(struct inode *inode, int mask)
Linus Torvalds's avatar
Linus Torvalds committed
343
{
344
	int retval;
Linus Torvalds's avatar
Linus Torvalds committed
345

346
	if (unlikely(mask & MAY_WRITE)) {
347
		umode_t mode = inode->i_mode;
Linus Torvalds's avatar
Linus Torvalds committed
348 349 350 351 352 353 354 355 356 357 358 359 360 361 362

		/*
		 * Nobody gets write access to a read-only fs.
		 */
		if (IS_RDONLY(inode) &&
		    (S_ISREG(mode) || S_ISDIR(mode) || S_ISLNK(mode)))
			return -EROFS;

		/*
		 * Nobody gets write access to an immutable file.
		 */
		if (IS_IMMUTABLE(inode))
			return -EACCES;
	}

363
	retval = do_inode_permission(inode, mask);
Linus Torvalds's avatar
Linus Torvalds committed
364 365 366
	if (retval)
		return retval;

367 368 369 370
	retval = devcgroup_inode_permission(inode, mask);
	if (retval)
		return retval;

371
	return security_inode_permission(inode, mask);
Linus Torvalds's avatar
Linus Torvalds committed
372 373
}

Jan Blunck's avatar
Jan Blunck committed
374 375 376 377 378 379 380 381 382 383 384 385 386
/**
 * path_get - get a reference to a path
 * @path: path to get the reference to
 *
 * Given a path increment the reference count to the dentry and the vfsmount.
 */
void path_get(struct path *path)
{
	mntget(path->mnt);
	dget(path->dentry);
}
EXPORT_SYMBOL(path_get);

Jan Blunck's avatar
Jan Blunck committed
387 388 389 390 391 392 393
/**
 * path_put - put a reference to a path
 * @path: path to put the reference to
 *
 * Given a path decrement the reference count to the dentry and the vfsmount.
 */
void path_put(struct path *path)
Linus Torvalds's avatar
Linus Torvalds committed
394
{
Jan Blunck's avatar
Jan Blunck committed
395 396
	dput(path->dentry);
	mntput(path->mnt);
Linus Torvalds's avatar
Linus Torvalds committed
397
}
Jan Blunck's avatar
Jan Blunck committed
398
EXPORT_SYMBOL(path_put);
Linus Torvalds's avatar
Linus Torvalds committed
399

Al Viro's avatar
Al Viro committed
400
/*
Nick Piggin's avatar
Nick Piggin committed
401
 * Path walking has 2 modes, rcu-walk and ref-walk (see
Al Viro's avatar
Al Viro committed
402 403 404 405 406 407 408
 * Documentation/filesystems/path-lookup.txt).  In situations when we can't
 * continue in RCU mode, we attempt to drop out of rcu-walk mode and grab
 * normal reference counts on dentries and vfsmounts to transition to rcu-walk
 * mode.  Refcounts are grabbed at the last known good point before rcu-walk
 * got stuck, so ref-walk may continue from there. If this is not successful
 * (eg. a seqcount has changed), then failure is returned and it's up to caller
 * to restart the path walk from the beginning in ref-walk mode.
Nick Piggin's avatar
Nick Piggin committed
409 410 411
 */

/**
Al Viro's avatar
Al Viro committed
412 413 414
 * unlazy_walk - try to switch to ref-walk mode.
 * @nd: nameidata pathwalk data
 * @dentry: child of nd->path.dentry or NULL
415
 * Returns: 0 on success, -ECHILD on failure
Nick Piggin's avatar
Nick Piggin committed
416
 *
Al Viro's avatar
Al Viro committed
417 418 419
 * unlazy_walk attempts to legitimize the current nd->path, nd->root and dentry
 * for ref-walk mode.  @dentry must be a path found by a do_lookup call on
 * @nd or NULL.  Must be called from rcu-walk context.
Nick Piggin's avatar
Nick Piggin committed
420
 */
Al Viro's avatar
Al Viro committed
421
static int unlazy_walk(struct nameidata *nd, struct dentry *dentry)
Nick Piggin's avatar
Nick Piggin committed
422 423 424
{
	struct fs_struct *fs = current->fs;
	struct dentry *parent = nd->path.dentry;
425
	int want_root = 0;
Nick Piggin's avatar
Nick Piggin committed
426 427

	BUG_ON(!(nd->flags & LOOKUP_RCU));
428 429
	if (nd->root.mnt && !(nd->flags & LOOKUP_ROOT)) {
		want_root = 1;
Nick Piggin's avatar
Nick Piggin committed
430 431 432 433 434 435
		spin_lock(&fs->lock);
		if (nd->root.mnt != fs->root.mnt ||
				nd->root.dentry != fs->root.dentry)
			goto err_root;
	}
	spin_lock(&parent->d_lock);
Al Viro's avatar
Al Viro committed
436 437 438 439 440
	if (!dentry) {
		if (!__d_rcu_to_refcount(parent, nd->seq))
			goto err_parent;
		BUG_ON(nd->inode != parent->d_inode);
	} else {
441 442
		if (dentry->d_parent != parent)
			goto err_parent;
Al Viro's avatar
Al Viro committed
443 444 445 446 447 448 449 450 451 452 453 454 455 456
		spin_lock_nested(&dentry->d_lock, DENTRY_D_LOCK_NESTED);
		if (!__d_rcu_to_refcount(dentry, nd->seq))
			goto err_child;
		/*
		 * If the sequence check on the child dentry passed, then
		 * the child has not been removed from its parent. This
		 * means the parent dentry must be valid and able to take
		 * a reference at this point.
		 */
		BUG_ON(!IS_ROOT(dentry) && dentry->d_parent != parent);
		BUG_ON(!parent->d_count);
		parent->d_count++;
		spin_unlock(&dentry->d_lock);
	}
Nick Piggin's avatar
Nick Piggin committed
457
	spin_unlock(&parent->d_lock);
458
	if (want_root) {
Nick Piggin's avatar
Nick Piggin committed
459 460 461 462 463 464 465 466 467
		path_get(&nd->root);
		spin_unlock(&fs->lock);
	}
	mntget(nd->path.mnt);

	rcu_read_unlock();
	br_read_unlock(vfsmount_lock);
	nd->flags &= ~LOOKUP_RCU;
	return 0;
Al Viro's avatar
Al Viro committed
468 469

err_child:
Nick Piggin's avatar
Nick Piggin committed
470
	spin_unlock(&dentry->d_lock);
Al Viro's avatar
Al Viro committed
471
err_parent:
Nick Piggin's avatar
Nick Piggin committed
472 473
	spin_unlock(&parent->d_lock);
err_root:
474
	if (want_root)
Nick Piggin's avatar
Nick Piggin committed
475 476 477 478
		spin_unlock(&fs->lock);
	return -ECHILD;
}

479 480 481 482 483 484
/**
 * release_open_intent - free up open intent resources
 * @nd: pointer to nameidata
 */
void release_open_intent(struct nameidata *nd)
{
485 486 487 488 489 490 491 492
	struct file *file = nd->intent.open.file;

	if (file && !IS_ERR(file)) {
		if (file->f_path.dentry == NULL)
			put_filp(file);
		else
			fput(file);
	}
493 494
}

Al Viro's avatar
Al Viro committed
495
static inline int d_revalidate(struct dentry *dentry, struct nameidata *nd)
496
{
Al Viro's avatar
Al Viro committed
497
	return dentry->d_op->d_revalidate(dentry, nd);
498 499
}

500 501 502
/**
 * complete_walk - successful completion of path walk
 * @nd:  pointer nameidata
503
 *
504 505 506 507 508
 * If we had been in RCU mode, drop out of it and legitimize nd->path.
 * Revalidate the final result, unless we'd already done that during
 * the path walk or the filesystem doesn't ask for it.  Return 0 on
 * success, -error on failure.  In case of failure caller does not
 * need to drop nd->path.
509
 */
510
static int complete_walk(struct nameidata *nd)
511
{
Al Viro's avatar
Al Viro committed
512
	struct dentry *dentry = nd->path.dentry;
513 514
	int status;

515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532
	if (nd->flags & LOOKUP_RCU) {
		nd->flags &= ~LOOKUP_RCU;
		if (!(nd->flags & LOOKUP_ROOT))
			nd->root.mnt = NULL;
		spin_lock(&dentry->d_lock);
		if (unlikely(!__d_rcu_to_refcount(dentry, nd->seq))) {
			spin_unlock(&dentry->d_lock);
			rcu_read_unlock();
			br_read_unlock(vfsmount_lock);
			return -ECHILD;
		}
		BUG_ON(nd->inode != dentry->d_inode);
		spin_unlock(&dentry->d_lock);
		mntget(nd->path.mnt);
		rcu_read_unlock();
		br_read_unlock(vfsmount_lock);
	}

Al Viro's avatar
Al Viro committed
533 534 535 536
	if (likely(!(nd->flags & LOOKUP_JUMPED)))
		return 0;

	if (likely(!(dentry->d_flags & DCACHE_OP_REVALIDATE)))
537 538
		return 0;

Al Viro's avatar
Al Viro committed
539 540 541 542
	if (likely(!(dentry->d_sb->s_type->fs_flags & FS_REVAL_DOT)))
		return 0;

	/* Note: we do not d_invalidate() */
543
	status = d_revalidate(dentry, nd);
544 545 546
	if (status > 0)
		return 0;

Al Viro's avatar
Al Viro committed
547
	if (!status)
548
		status = -ESTALE;
Al Viro's avatar
Al Viro committed
549

550
	path_put(&nd->path);
551 552 553
	return status;
}

Al Viro's avatar
Al Viro committed
554 555
static __always_inline void set_root(struct nameidata *nd)
{
556 557
	if (!nd->root.mnt)
		get_fs_root(current->fs, &nd->root);
Al Viro's avatar
Al Viro committed
558 559
}

560 561
static int link_path_walk(const char *, struct nameidata *);

Nick Piggin's avatar
Nick Piggin committed
562 563 564 565
static __always_inline void set_root_rcu(struct nameidata *nd)
{
	if (!nd->root.mnt) {
		struct fs_struct *fs = current->fs;
Nick Piggin's avatar
Nick Piggin committed
566 567 568 569 570
		unsigned seq;

		do {
			seq = read_seqcount_begin(&fs->seq);
			nd->root = fs->root;
571
			nd->seq = __read_seqcount_begin(&nd->root.dentry->d_seq);
Nick Piggin's avatar
Nick Piggin committed
572
		} while (read_seqcount_retry(&fs->seq, seq));
Nick Piggin's avatar
Nick Piggin committed
573 574 575
	}
}

576
static __always_inline int __vfs_follow_link(struct nameidata *nd, const char *link)
Linus Torvalds's avatar
Linus Torvalds committed
577
{
Nick Piggin's avatar
Nick Piggin committed
578 579
	int ret;

Linus Torvalds's avatar
Linus Torvalds committed
580 581 582 583
	if (IS_ERR(link))
		goto fail;

	if (*link == '/') {
Al Viro's avatar
Al Viro committed
584
		set_root(nd);
Jan Blunck's avatar
Jan Blunck committed
585
		path_put(&nd->path);
Al Viro's avatar
Al Viro committed
586 587
		nd->path = nd->root;
		path_get(&nd->root);
Al Viro's avatar
Al Viro committed
588
		nd->flags |= LOOKUP_JUMPED;
Linus Torvalds's avatar
Linus Torvalds committed
589
	}
Nick Piggin's avatar
Nick Piggin committed
590
	nd->inode = nd->path.dentry->d_inode;
Christoph Hellwig's avatar
Christoph Hellwig committed
591

Nick Piggin's avatar
Nick Piggin committed
592 593
	ret = link_path_walk(link, nd);
	return ret;
Linus Torvalds's avatar
Linus Torvalds committed
594
fail:
Jan Blunck's avatar
Jan Blunck committed
595
	path_put(&nd->path);
Linus Torvalds's avatar
Linus Torvalds committed
596 597 598
	return PTR_ERR(link);
}

Jan Blunck's avatar
Jan Blunck committed
599
static void path_put_conditional(struct path *path, struct nameidata *nd)
600 601
{
	dput(path->dentry);
602
	if (path->mnt != nd->path.mnt)
603 604 605
		mntput(path->mnt);
}

606 607
static inline void path_to_nameidata(const struct path *path,
					struct nameidata *nd)
608
{
Nick Piggin's avatar
Nick Piggin committed
609 610 611 612
	if (!(nd->flags & LOOKUP_RCU)) {
		dput(nd->path.dentry);
		if (nd->path.mnt != path->mnt)
			mntput(nd->path.mnt);
613
	}
Nick Piggin's avatar
Nick Piggin committed
614
	nd->path.mnt = path->mnt;
615
	nd->path.dentry = path->dentry;
616 617
}

618 619 620 621 622 623 624 625
static inline void put_link(struct nameidata *nd, struct path *link, void *cookie)
{
	struct inode *inode = link->dentry->d_inode;
	if (!IS_ERR(cookie) && inode->i_op->put_link)
		inode->i_op->put_link(link->dentry, nd, cookie);
	path_put(link);
}

Al Viro's avatar
Al Viro committed
626
static __always_inline int
627
follow_link(struct path *link, struct nameidata *nd, void **p)
Linus Torvalds's avatar
Linus Torvalds committed
628 629
{
	int error;
630
	struct dentry *dentry = link->dentry;
Linus Torvalds's avatar
Linus Torvalds committed
631

632 633
	BUG_ON(nd->flags & LOOKUP_RCU);

Al Viro's avatar
Al Viro committed
634 635 636
	if (link->mnt == nd->path.mnt)
		mntget(link->mnt);

637 638 639 640 641 642 643 644
	if (unlikely(current->total_link_count >= 40)) {
		*p = ERR_PTR(-ELOOP); /* no ->put_link(), please */
		path_put(&nd->path);
		return -ELOOP;
	}
	cond_resched();
	current->total_link_count++;

645
	touch_atime(link->mnt, dentry);
Linus Torvalds's avatar
Linus Torvalds committed
646
	nd_set_link(nd, NULL);
Al Viro's avatar
Al Viro committed
647

648 649 650 651 652 653 654
	error = security_inode_follow_link(link->dentry, nd);
	if (error) {
		*p = ERR_PTR(error); /* no ->put_link(), please */
		path_put(&nd->path);
		return error;
	}

655
	nd->last_type = LAST_BIND;
Al Viro's avatar
Al Viro committed
656 657 658
	*p = dentry->d_inode->i_op->follow_link(dentry, nd);
	error = PTR_ERR(*p);
	if (!IS_ERR(*p)) {
Linus Torvalds's avatar
Linus Torvalds committed
659
		char *s = nd_get_link(nd);
660
		error = 0;
Linus Torvalds's avatar
Linus Torvalds committed
661 662
		if (s)
			error = __vfs_follow_link(nd, s);
Al Viro's avatar
Al Viro committed
663
		else if (nd->last_type == LAST_BIND) {
Al Viro's avatar
Al Viro committed
664
			nd->flags |= LOOKUP_JUMPED;
665 666
			nd->inode = nd->path.dentry->d_inode;
			if (nd->inode->i_op->follow_link) {
Al Viro's avatar
Al Viro committed
667 668 669 670 671
				/* stepped on a _really_ weird one */
				path_put(&nd->path);
				error = -ELOOP;
			}
		}
Linus Torvalds's avatar
Linus Torvalds committed
672 673 674 675
	}
	return error;
}

Nick Piggin's avatar
Nick Piggin committed
676 677
static int follow_up_rcu(struct path *path)
{
678 679
	struct mount *mnt = real_mount(path->mnt);
	struct mount *parent;
Nick Piggin's avatar
Nick Piggin committed
680 681
	struct dentry *mountpoint;

682 683
	parent = mnt->mnt_parent;
	if (&parent->mnt == path->mnt)
Nick Piggin's avatar
Nick Piggin committed
684
		return 0;
685
	mountpoint = mnt->mnt_mountpoint;
Nick Piggin's avatar
Nick Piggin committed
686
	path->dentry = mountpoint;
687
	path->mnt = &parent->mnt;
Nick Piggin's avatar
Nick Piggin committed
688 689 690
	return 1;
}

Al Viro's avatar
Al Viro committed
691
int follow_up(struct path *path)
Linus Torvalds's avatar
Linus Torvalds committed
692
{
693 694
	struct mount *mnt = real_mount(path->mnt);
	struct mount *parent;
Linus Torvalds's avatar
Linus Torvalds committed
695
	struct dentry *mountpoint;
Nick Piggin's avatar
Nick Piggin committed
696 697

	br_read_lock(vfsmount_lock);
698 699
	parent = mnt->mnt_parent;
	if (&parent->mnt == path->mnt) {
Nick Piggin's avatar
Nick Piggin committed
700
		br_read_unlock(vfsmount_lock);
Linus Torvalds's avatar
Linus Torvalds committed
701 702
		return 0;
	}
703
	mntget(&parent->mnt);
704
	mountpoint = dget(mnt->mnt_mountpoint);
Nick Piggin's avatar
Nick Piggin committed
705
	br_read_unlock(vfsmount_lock);
Al Viro's avatar
Al Viro committed
706 707 708
	dput(path->dentry);
	path->dentry = mountpoint;
	mntput(path->mnt);
709
	path->mnt = &parent->mnt;
Linus Torvalds's avatar
Linus Torvalds committed
710 711 712
	return 1;
}

Nick Piggin's avatar
Nick Piggin committed
713
/*
714 715 716
 * Perform an automount
 * - return -EISDIR to tell follow_managed() to stop and return the path we
 *   were called with.
Linus Torvalds's avatar
Linus Torvalds committed
717
 */
718 719
static int follow_automount(struct path *path, unsigned flags,
			    bool *need_mntput)
Nick Piggin's avatar
Nick Piggin committed
720
{
721
	struct vfsmount *mnt;
722
	int err;
723 724 725 726

	if (!path->dentry->d_op || !path->dentry->d_op->d_automount)
		return -EREMOTE;

727 728 729 730 731 732 733 734 735 736
	/* We don't want to mount if someone's just doing a stat -
	 * unless they're stat'ing a directory and appended a '/' to
	 * the name.
	 *
	 * We do, however, want to mount if someone wants to open or
	 * create a file of any type under the mountpoint, wants to
	 * traverse through the mountpoint or wants to open the
	 * mounted directory.  Also, autofs may mark negative dentries
	 * as being automount points.  These will need the attentions
	 * of the daemon to instantiate them before they can be used.
737
	 */
738
	if (!(flags & (LOOKUP_PARENT | LOOKUP_DIRECTORY |
739
		     LOOKUP_OPEN | LOOKUP_CREATE | LOOKUP_AUTOMOUNT)) &&
740 741 742
	    path->dentry->d_inode)
		return -EISDIR;

743 744 745 746 747 748 749 750 751 752 753 754 755 756 757
	current->total_link_count++;
	if (current->total_link_count >= 40)
		return -ELOOP;

	mnt = path->dentry->d_op->d_automount(path);
	if (IS_ERR(mnt)) {
		/*
		 * The filesystem is allowed to return -EISDIR here to indicate
		 * it doesn't want to automount.  For instance, autofs would do
		 * this so that its userspace daemon can mount on this dentry.
		 *
		 * However, we can only permit this if it's a terminal point in
		 * the path being looked up; if it wasn't then the remainder of
		 * the path is inaccessible and we should say so.
		 */
Al Viro's avatar
Al Viro committed
758
		if (PTR_ERR(mnt) == -EISDIR && (flags & LOOKUP_PARENT))
759 760
			return -EREMOTE;
		return PTR_ERR(mnt);
Nick Piggin's avatar
Nick Piggin committed
761
	}
762

763 764
	if (!mnt) /* mount collision */
		return 0;
Nick Piggin's avatar
Nick Piggin committed
765

766 767 768 769 770
	if (!*need_mntput) {
		/* lock_mount() may release path->mnt on error */
		mntget(path->mnt);
		*need_mntput = true;
	}
771
	err = finish_automount(mnt, path);
772

773 774 775
	switch (err) {
	case -EBUSY:
		/* Someone else made a mount here whilst we were busy */
776
		return 0;
777
	case 0:
778
		path_put(path);
779 780 781
		path->mnt = mnt;
		path->dentry = dget(mnt->mnt_root);
		return 0;
782 783
	default:
		return err;
784
	}
785

Al Viro's avatar
Al Viro committed
786 787
}

788 789
/*
 * Handle a dentry that is managed in some way.
790
 * - Flagged for transit management (autofs)
791 792 793 794 795 796 797 798
 * - Flagged as mountpoint
 * - Flagged as automount point
 *
 * This may only be called in refwalk mode.
 *
 * Serialization is taken care of in namespace.c
 */
static int follow_managed(struct path *path, unsigned flags)
Linus Torvalds's avatar
Linus Torvalds committed
799
{
800
	struct vfsmount *mnt = path->mnt; /* held by caller, must be left alone */
801 802
	unsigned managed;
	bool need_mntput = false;
803
	int ret = 0;
804 805 806 807 808 809 810

	/* Given that we're not holding a lock here, we retain the value in a
	 * local variable for each dentry as we look at it so that we don't see
	 * the components of that value change under us */
	while (managed = ACCESS_ONCE(path->dentry->d_flags),
	       managed &= DCACHE_MANAGED_DENTRY,
	       unlikely(managed != 0)) {
811 812 813 814 815
		/* Allow the filesystem to manage the transit without i_mutex
		 * being held. */
		if (managed & DCACHE_MANAGE_TRANSIT) {
			BUG_ON(!path->dentry->d_op);
			BUG_ON(!path->dentry->d_op->d_manage);
816
			ret = path->dentry->d_op->d_manage(path->dentry, false);
817
			if (ret < 0)
818
				break;
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
		/* Transit to a mounted filesystem. */
		if (managed & DCACHE_MOUNTED) {
			struct vfsmount *mounted = lookup_mnt(path);
			if (mounted) {
				dput(path->dentry);
				if (need_mntput)
					mntput(path->mnt);
				path->mnt = mounted;
				path->dentry = dget(mounted->mnt_root);
				need_mntput = true;
				continue;
			}

			/* Something is mounted on this dentry in another
			 * namespace and/or whatever was mounted there in this
			 * namespace got unmounted before we managed to get the
			 * vfsmount_lock */
		}

		/* Handle an automount point */
		if (managed & DCACHE_NEED_AUTOMOUNT) {
			ret = follow_automount(path, flags, &need_mntput);
			if (ret < 0)
844
				break;
845 846 847 848 849
			continue;
		}

		/* We didn't change the current path point */
		break;
Linus Torvalds's avatar
Linus Torvalds committed
850
	}
851 852 853 854 855

	if (need_mntput && path->mnt == mnt)
		mntput(path->mnt);
	if (ret == -EISDIR)
		ret = 0;
856
	return ret < 0 ? ret : need_mntput;
Linus Torvalds's avatar
Linus Torvalds committed
857 858
}

859
int follow_down_one(struct path *path)
Linus Torvalds's avatar
Linus Torvalds committed
860 861 862
{
	struct vfsmount *mounted;

Al Viro's avatar
Al Viro committed
863
	mounted = lookup_mnt(path);
Linus Torvalds's avatar
Linus Torvalds committed
864
	if (mounted) {
Al Viro's avatar
Al Viro committed
865 866 867 868
		dput(path->dentry);
		mntput(path->mnt);
		path->mnt = mounted;
		path->dentry = dget(mounted->mnt_root);
Linus Torvalds's avatar
Linus Torvalds committed
869 870 871 872 873
		return 1;
	}
	return 0;
}

874 875 876 877 878 879
static inline bool managed_dentry_might_block(struct dentry *dentry)
{
	return (dentry->d_flags & DCACHE_MANAGE_TRANSIT &&
		dentry->d_op->d_manage(dentry, true) < 0);
}

880
/*
881 882
 * Try to skip to top of mountpoint pile in rcuwalk mode.  Fail if
 * we meet a managed dentry that would need blocking.
883 884
 */
static bool __follow_mount_rcu(struct nameidata *nd, struct path *path,
885
			       struct inode **inode)
886
{
887
	for (;;) {
888
		struct mount *mounted;
889 890 891 892
		/*
		 * Don't forget we might have a non-mountpoint managed dentry
		 * that wants to block transit.
		 */
893
		if (unlikely(managed_dentry_might_block(path->dentry)))
894
			return false;
895 896 897 898

		if (!d_mountpoint(path->dentry))
			break;

899 900 901
		mounted = __lookup_mnt(path->mnt, path->dentry, 1);
		if (!mounted)
			break;
902 903
		path->mnt = &mounted->mnt;
		path->dentry = mounted->mnt.mnt_root;
904
		nd->flags |= LOOKUP_JUMPED;
905
		nd->seq = read_seqcount_begin(&path->dentry->d_seq);
906 907 908 909 910 911
		/*
		 * Update the inode too. We don't need to re-check the
		 * dentry sequence number here after this d_inode read,
		 * because a mount-point is always pinned.
		 */
		*inode = path->dentry->d_inode;
912 913 914 915
	}
	return true;
}

916
static void follow_mount_rcu(struct nameidata *nd)
917
{
918
	while (d_mountpoint(nd->path.dentry)) {
919
		struct mount *mounted;
920
		mounted = __lookup_mnt(nd->path.mnt, nd->path.dentry, 1);
921 922
		if (!mounted)
			break;
923 924
		nd->path.mnt = &mounted->mnt;
		nd->path.dentry = mounted->mnt.mnt_root;
925
		nd->seq = read_seqcount_begin(&nd->path.dentry->d_seq);
926 927 928
	}
}

Nick Piggin's avatar
Nick Piggin committed
929 930 931 932
static int follow_dotdot_rcu(struct nameidata *nd)
{
	set_root_rcu(nd);

933
	while (1) {
Nick Piggin's avatar
Nick Piggin committed
934 935 936 937 938 939 940 941 942 943 944
		if (nd->path.dentry == nd->root.dentry &&
		    nd->path.mnt == nd->root.mnt) {
			break;
		}
		if (nd->path.dentry != nd->path.mnt->mnt_root) {
			struct dentry *old = nd->path.dentry;
			struct dentry *parent = old->d_parent;
			unsigned seq;

			seq = read_seqcount_begin(&parent->d_seq);
			if (read_seqcount_retry(&old->d_seq, nd->seq))
945
				goto failed;
Nick Piggin's avatar
Nick Piggin committed
946 947 948 949 950 951 952 953
			nd->path.dentry = parent;
			nd->seq = seq;
			break;
		}
		if (!follow_up_rcu(&nd->path))
			break;
		nd->seq = read_seqcount_begin(&nd->path.dentry->d_seq);
	}
954 955
	follow_mount_rcu(nd);
	nd->inode = nd->path.dentry->d_inode;
Nick Piggin's avatar
Nick Piggin committed
956
	return 0;
957 958 959

failed:
	nd->flags &= ~LOOKUP_RCU;
960 961
	if (!(nd->flags & LOOKUP_ROOT))
		nd->root.mnt = NULL;
962 963 964
	rcu_read_unlock();
	br_read_unlock(vfsmount_lock);
	return -ECHILD;
Nick Piggin's avatar
Nick Piggin committed
965 966
}

967 968 969 970 971
/*
 * Follow down to the covering mount currently visible to userspace.  At each
 * point, the filesystem owning that dentry may be queried as to whether the
 * caller is permitted to proceed or not.
 */
972
int follow_down(struct path *path)
973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991
{
	unsigned managed;
	int ret;

	while (managed = ACCESS_ONCE(path->dentry->d_flags),
	       unlikely(managed & DCACHE_MANAGED_DENTRY)) {
		/* Allow the filesystem to manage the transit without i_mutex
		 * being held.
		 *
		 * We indicate to the filesystem if someone is trying to mount
		 * something here.  This gives autofs the chance to deny anyone
		 * other than its daemon the right to mount on its
		 * superstructure.
		 *
		 * The filesystem may sleep at this point.
		 */
		if (managed & DCACHE_MANAGE_TRANSIT) {
			BUG_ON(!path->dentry->d_op);
			BUG_ON(!path->dentry->d_op->d_manage);
992
			ret = path->dentry->d_op->d_manage(
993
				path->dentry, false);
994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015
			if (ret < 0)
				return ret == -EISDIR ? 0 : ret;
		}

		/* Transit to a mounted filesystem. */
		if (managed & DCACHE_MOUNTED) {
			struct vfsmount *mounted = lookup_mnt(path);
			if (!mounted)
				break;
			dput(path->dentry);
			mntput(path->mnt);
			path->mnt = mounted;
			path->dentry = dget(mounted->mnt_root);
			continue;
		}

		/* Don't handle automount points here */
		break;
	}
	return 0;
}

1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031
/*
 * Skip to top of mountpoint pile in refwalk mode for follow_dotdot()
 */
static void follow_mount(struct path *path)
{
	while (d_mountpoint(path->dentry)) {
		struct vfsmount *mounted = lookup_mnt(path);
		if (!mounted)
			break;
		dput(path->dentry);
		mntput(path->mnt);
		path->mnt = mounted;
		path->dentry = dget(mounted->mnt_root);
	}
}

Nick Piggin's avatar
Nick Piggin committed
1032
static void follow_dotdot(struct nameidata *nd)
Linus Torvalds's avatar
Linus Torvalds committed
1033
{
Al Viro's avatar
Al Viro committed
1034
	set_root(nd);
1035

Linus Torvalds's avatar
Linus Torvalds committed
1036
	while(1) {
1037
		struct dentry *old = nd->path.dentry;
Linus Torvalds's avatar
Linus Torvalds committed
1038

Al Viro's avatar
Al Viro committed
1039 1040
		if (nd->path.dentry == nd->root.dentry &&
		    nd->path.mnt == nd->root.mnt) {
Linus Torvalds's avatar
Linus Torvalds committed
1041 1042
			break;
		}
1043
		if (nd->path.dentry != nd->path.mnt->mnt_root) {
Al Viro's avatar
Al Viro committed
1044 1045
			/* rare case of legitimate dget_parent()... */
			nd->path.dentry = dget_parent(nd->path.dentry);
Linus Torvalds's avatar
Linus Torvalds committed
1046 1047 1048
			dput(old);
			break;
		}
Al Viro's avatar
Al Viro committed
1049
		if (!follow_up(&nd->path))
Linus Torvalds's avatar
Linus Torvalds committed
1050 1051
			break;
	}
Al Viro's avatar
Al Viro committed
1052
	follow_mount(&nd->path);
Nick Piggin's avatar
Nick Piggin committed
1053
	nd->inode = nd->path.dentry->d_inode;
Linus Torvalds's avatar
Linus Torvalds committed
1054 1055
}

1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084
/*
 * Allocate a dentry with name and parent, and perform a parent
 * directory ->lookup on it. Returns the new dentry, or ERR_PTR
 * on error. parent->d_inode->i_mutex must be held. d_lookup must
 * have verified that no child exists while under i_mutex.
 */
static struct dentry *d_alloc_and_lookup(struct dentry *parent,
				struct qstr *name, struct nameidata *nd)
{
	struct inode *inode = parent->d_inode;
	struct dentry *dentry;
	struct dentry *old;

	/* Don't create child dentry for a dead directory. */
	if (unlikely(IS_DEADDIR(inode)))
		return ERR_PTR(-ENOENT);

	dentry = d_alloc(parent, name);
	if (unlikely(!dentry))
		return ERR_PTR(-ENOMEM);

	old = inode->i_op->lookup(inode, dentry, nd);
	if (unlikely(old)) {
		dput(dentry);
		dentry = old;
	}
	return dentry;
}

1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097
/*
 * We already have a dentry, but require a lookup to be performed on the parent
 * directory to fill in d_inode. Returns the new dentry, or ERR_PTR on error.
 * parent->d_inode->i_mutex must be held. d_lookup must have verified that no
 * child exists while under i_mutex.
 */
static struct dentry *d_inode_lookup(struct dentry *parent, struct dentry *dentry,
				     struct nameidata *nd)
{
	struct inode *inode = parent->d_inode;
	struct dentry *old;

	/* Don't create child dentry for a dead directory. */
1098 1099
	if (unlikely(IS_DEADDIR(inode))) {
		dput(dentry);
1100
		return ERR_PTR(-ENOENT);
1101
	}
1102 1103 1104 1105 1106 1107 1108 1109 1110

	old = inode->i_op->lookup(inode, dentry, nd);
	if (unlikely(old)) {
		dput(dentry);
		dentry = old;
	}
	return dentry;
}

Linus Torvalds's avatar
Linus Torvalds committed
1111 1112 1113 1114 1115 1116
/*
 *  It's more convoluted than I'd like it to be, but... it's still fairly
 *  small and for now I'd prefer to have fast path as straight as possible.
 *  It _is_ time-critical.
 */
static int do_lookup(struct nameidata *nd, struct qstr *name,
Nick Piggin's avatar
Nick Piggin committed
1117
			struct path *path, struct inode **inode)
Linus Torvalds's avatar
Linus Torvalds committed
1118
{
1119
	struct vfsmount *mnt = nd->path.mnt;
Nick Piggin's avatar
Nick Piggin committed
1120
	struct dentry *dentry, *parent = nd->path.dentry;
Al Viro's avatar
Al Viro committed
1121 1122
	int need_reval = 1;
	int status = 1;
1123 1124
	int err;

1125 1126 1127 1128 1129
	/*
	 * Rename seqlock is not required here because in the off chance
	 * of a false negative due to a concurrent rename, we're going to
	 * do the non-racy lookup, below.
	 */
Nick Piggin's avatar
Nick Piggin committed
1130 1131 1132 1133
	if (nd->flags & LOOKUP_RCU) {
		unsigned seq;
		*inode = nd->inode;
		dentry = __d_lookup_rcu(parent, name, &seq, inode);
Al Viro's avatar
Al Viro committed
1134 1135 1136
		if (!dentry)
			goto unlazy;

Nick Piggin's avatar
Nick Piggin committed
1137 1138 1139 1140
		/* Memory barrier in read_seqcount_begin of child is enough */
		if (__read_seqcount_retry(&parent->d_seq, nd->seq))
			return -ECHILD;
		nd->seq = seq;
Al Viro's avatar
Al Viro committed
1141

1142
		if (unlikely(dentry->d_flags & DCACHE_OP_REVALIDATE)) {
Al Viro's avatar
Al Viro committed
1143 1144 1145 1146 1147 1148
			status = d_revalidate(dentry, nd);
			if (unlikely(status <= 0)) {
				if (status != -ECHILD)
					need_reval = 0;
				goto unlazy;
			}
Al Viro's avatar