namei.c 70.2 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
/*
 *  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>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/fs.h>
#include <linux/namei.h>
#include <linux/quotaops.h>
#include <linux/pagemap.h>
R
Robert Love 已提交
24
#include <linux/fsnotify.h>
L
Linus Torvalds 已提交
25 26 27 28 29
#include <linux/personality.h>
#include <linux/security.h>
#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>
L
Linus Torvalds 已提交
34 35 36 37 38 39 40 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 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
#include <asm/uaccess.h>

#define ACC_MODE(x) ("\000\004\002\006"[(x)&O_ACCMODE])

/* [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
 * the name is a symlink pointing to a non-existant name.
 *
 * 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)
105
 * implemented.  Let's see if raised priority of ->s_vfs_rename_mutex gives
L
Linus Torvalds 已提交
106 107 108
 * any extra contention...
 */

109
static int __link_path_walk(const char *name, struct nameidata *nd);
110

L
Linus Torvalds 已提交
111 112 113 114 115 116 117
/* 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.
 */
118
static int do_getname(const char __user *filename, char *page)
L
Linus Torvalds 已提交
119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161
{
	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;
}

char * getname(const char __user * filename)
{
	char *tmp, *result;

	result = ERR_PTR(-ENOMEM);
	tmp = __getname();
	if (tmp)  {
		int retval = do_getname(filename, tmp);

		result = tmp;
		if (retval < 0) {
			__putname(tmp);
			result = ERR_PTR(retval);
		}
	}
	audit_getname(result);
	return result;
}

#ifdef CONFIG_AUDITSYSCALL
void putname(const char *name)
{
162
	if (unlikely(!audit_dummy_context()))
L
Linus Torvalds 已提交
163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186
		audit_putname(name);
	else
		__putname(name);
}
EXPORT_SYMBOL(putname);
#endif


/**
 * generic_permission  -  check for access rights on a Posix-like filesystem
 * @inode:	inode to check access rights for
 * @mask:	right to check for (%MAY_READ, %MAY_WRITE, %MAY_EXEC)
 * @check_acl:	optional callback to check for Posix ACLs
 *
 * 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
 * are used for other things..
 */
int generic_permission(struct inode *inode, int mask,
		int (*check_acl)(struct inode *inode, int mask))
{
	umode_t			mode = inode->i_mode;

187 188
	mask &= MAY_READ | MAY_WRITE | MAY_EXEC;

189
	if (current_fsuid() == inode->i_uid)
L
Linus Torvalds 已提交
190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206
		mode >>= 6;
	else {
		if (IS_POSIXACL(inode) && (mode & S_IRWXG) && check_acl) {
			int error = check_acl(inode, mask);
			if (error == -EACCES)
				goto check_capabilities;
			else if (error != -EAGAIN)
				return error;
		}

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

	/*
	 * If the DACs are ok we don't need any capability check.
	 */
207
	if ((mask & ~mode) == 0)
L
Linus Torvalds 已提交
208 209 210 211 212 213 214
		return 0;

 check_capabilities:
	/*
	 * Read/write DACs are always overridable.
	 * Executable DACs are overridable if at least one exec bit is set.
	 */
215
	if (!(mask & MAY_EXEC) || execute_ok(inode))
L
Linus Torvalds 已提交
216 217 218 219 220 221 222 223 224 225 226 227 228
		if (capable(CAP_DAC_OVERRIDE))
			return 0;

	/*
	 * Searching includes executable on directories, else just read.
	 */
	if (mask == MAY_READ || (S_ISDIR(inode->i_mode) && !(mask & MAY_WRITE)))
		if (capable(CAP_DAC_READ_SEARCH))
			return 0;

	return -EACCES;
}

229
int inode_permission(struct inode *inode, int mask)
L
Linus Torvalds 已提交
230
{
231
	int retval;
L
Linus Torvalds 已提交
232 233

	if (mask & MAY_WRITE) {
234
		umode_t mode = inode->i_mode;
L
Linus Torvalds 已提交
235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250

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

	/* Ordinary permission routines do not understand MAY_APPEND. */
251
	if (inode->i_op && inode->i_op->permission)
252
		retval = inode->i_op->permission(inode, mask);
253
	else
254
		retval = generic_permission(inode, mask, NULL);
255

L
Linus Torvalds 已提交
256 257 258
	if (retval)
		return retval;

259 260 261 262
	retval = devcgroup_inode_permission(inode, mask);
	if (retval)
		return retval;

263
	return security_inode_permission(inode,
264
			mask & (MAY_READ|MAY_WRITE|MAY_EXEC|MAY_APPEND));
L
Linus Torvalds 已提交
265 266
}

267 268 269 270 271 272 273 274 275 276 277 278
/**
 * vfs_permission  -  check for access rights to a given path
 * @nd:		lookup result that describes the path
 * @mask:	right to check for (%MAY_READ, %MAY_WRITE, %MAY_EXEC)
 *
 * Used to check for read/write/execute permissions on a path.
 * We use "fsuid" for this, letting us set arbitrary permissions
 * for filesystem access without changing the "normal" uids which
 * are used for other things.
 */
int vfs_permission(struct nameidata *nd, int mask)
{
279
	return inode_permission(nd->path.dentry->d_inode, mask);
280 281
}

282 283 284 285 286 287 288 289 290 291 292 293 294 295
/**
 * file_permission  -  check for additional access rights to a given file
 * @file:	file to check access rights for
 * @mask:	right to check for (%MAY_READ, %MAY_WRITE, %MAY_EXEC)
 *
 * Used to check for read/write/execute permissions on an already opened
 * file.
 *
 * Note:
 *	Do not use this function in new code.  All access checks should
 *	be done using vfs_permission().
 */
int file_permission(struct file *file, int mask)
{
296
	return inode_permission(file->f_path.dentry->d_inode, mask);
297 298
}

L
Linus Torvalds 已提交
299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331
/*
 * get_write_access() gets write permission for a file.
 * put_write_access() releases this write permission.
 * This is used for regular files.
 * We cannot support write (and maybe mmap read-write shared) accesses and
 * MAP_DENYWRITE mmappings simultaneously. The i_writecount field of an inode
 * can have the following values:
 * 0: no writers, no VM_DENYWRITE mappings
 * < 0: (-i_writecount) vm_area_structs with VM_DENYWRITE set exist
 * > 0: (i_writecount) users are writing to the file.
 *
 * Normally we operate on that counter with atomic_{inc,dec} and it's safe
 * except for the cases where we don't hold i_writecount yet. Then we need to
 * use {get,deny}_write_access() - these functions check the sign and refuse
 * to do the change if sign is wrong. Exclusion between them is provided by
 * the inode->i_lock spinlock.
 */

int get_write_access(struct inode * inode)
{
	spin_lock(&inode->i_lock);
	if (atomic_read(&inode->i_writecount) < 0) {
		spin_unlock(&inode->i_lock);
		return -ETXTBSY;
	}
	atomic_inc(&inode->i_writecount);
	spin_unlock(&inode->i_lock);

	return 0;
}

int deny_write_access(struct file * file)
{
332
	struct inode *inode = file->f_path.dentry->d_inode;
L
Linus Torvalds 已提交
333 334 335 336 337 338 339 340 341 342 343 344

	spin_lock(&inode->i_lock);
	if (atomic_read(&inode->i_writecount) > 0) {
		spin_unlock(&inode->i_lock);
		return -ETXTBSY;
	}
	atomic_dec(&inode->i_writecount);
	spin_unlock(&inode->i_lock);

	return 0;
}

J
Jan Blunck 已提交
345 346 347 348 349 350 351 352 353 354 355 356 357
/**
 * 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);

J
Jan Blunck 已提交
358 359 360 361 362 363 364
/**
 * 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)
L
Linus Torvalds 已提交
365
{
J
Jan Blunck 已提交
366 367
	dput(path->dentry);
	mntput(path->mnt);
L
Linus Torvalds 已提交
368
}
J
Jan Blunck 已提交
369
EXPORT_SYMBOL(path_put);
L
Linus Torvalds 已提交
370

371 372 373 374 375 376
/**
 * release_open_intent - free up open intent resources
 * @nd: pointer to nameidata
 */
void release_open_intent(struct nameidata *nd)
{
377
	if (nd->intent.open.file->f_path.dentry == NULL)
378 379 380 381 382
		put_filp(nd->intent.open.file);
	else
		fput(nd->intent.open.file);
}

383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406
static inline struct dentry *
do_revalidate(struct dentry *dentry, struct nameidata *nd)
{
	int status = dentry->d_op->d_revalidate(dentry, nd);
	if (unlikely(status <= 0)) {
		/*
		 * The dentry failed validation.
		 * If d_revalidate returned 0 attempt to invalidate
		 * the dentry otherwise d_revalidate is asking us
		 * to return a fail status.
		 */
		if (!status) {
			if (!d_invalidate(dentry)) {
				dput(dentry);
				dentry = NULL;
			}
		} else {
			dput(dentry);
			dentry = ERR_PTR(status);
		}
	}
	return dentry;
}

L
Linus Torvalds 已提交
407 408 409 410 411 412 413 414 415 416 417 418 419 420
/*
 * Internal lookup() using the new generic dcache.
 * SMP-safe
 */
static struct dentry * cached_lookup(struct dentry * parent, struct qstr * name, struct nameidata *nd)
{
	struct dentry * dentry = __d_lookup(parent, name);

	/* lockess __d_lookup may fail due to concurrent d_move() 
	 * in some unrelated directory, so try with d_lookup
	 */
	if (!dentry)
		dentry = d_lookup(parent, name);

421 422 423
	if (dentry && dentry->d_op && dentry->d_op->d_revalidate)
		dentry = do_revalidate(dentry, nd);

L
Linus Torvalds 已提交
424 425 426 427 428 429 430 431 432 433 434 435 436
	return dentry;
}

/*
 * Short-cut version of permission(), for calling by
 * path_walk(), when dcache lock is held.  Combines parts
 * of permission() and generic_permission(), and tests ONLY for
 * MAY_EXEC permission.
 *
 * If appropriate, check DAC only.  If not appropriate, or
 * short-cut DAC fails, then call permission() to do more
 * complete permission check.
 */
437
static int exec_permission_lite(struct inode *inode)
L
Linus Torvalds 已提交
438 439 440 441 442 443
{
	umode_t	mode = inode->i_mode;

	if (inode->i_op && inode->i_op->permission)
		return -EAGAIN;

444
	if (current_fsuid() == inode->i_uid)
L
Linus Torvalds 已提交
445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462
		mode >>= 6;
	else if (in_group_p(inode->i_gid))
		mode >>= 3;

	if (mode & MAY_EXEC)
		goto ok;

	if ((inode->i_mode & S_IXUGO) && capable(CAP_DAC_OVERRIDE))
		goto ok;

	if (S_ISDIR(inode->i_mode) && capable(CAP_DAC_OVERRIDE))
		goto ok;

	if (S_ISDIR(inode->i_mode) && capable(CAP_DAC_READ_SEARCH))
		goto ok;

	return -EACCES;
ok:
463
	return security_inode_permission(inode, MAY_EXEC);
L
Linus Torvalds 已提交
464 465 466 467 468 469 470 471 472 473 474 475 476 477 478
}

/*
 * This is called when everything else fails, and we actually have
 * to go to the low-level filesystem to find out what we should do..
 *
 * We get the directory semaphore, and after getting that we also
 * make sure that nobody added the entry to the dcache in the meantime..
 * SMP-safe
 */
static struct dentry * real_lookup(struct dentry * parent, struct qstr * name, struct nameidata *nd)
{
	struct dentry * result;
	struct inode *dir = parent->d_inode;

479
	mutex_lock(&dir->i_mutex);
L
Linus Torvalds 已提交
480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495
	/*
	 * First re-do the cached lookup just in case it was created
	 * while we waited for the directory semaphore..
	 *
	 * FIXME! This could use version numbering or similar to
	 * avoid unnecessary cache lookups.
	 *
	 * The "dcache_lock" is purely to protect the RCU list walker
	 * from concurrent renames at this point (we mustn't get false
	 * negatives from the RCU list walk here, unlike the optimistic
	 * fast walk).
	 *
	 * so doing d_lookup() (with seqlock), instead of lockfree __d_lookup
	 */
	result = d_lookup(parent, name);
	if (!result) {
496 497 498 499 500 501 502 503
		struct dentry *dentry;

		/* Don't create child dentry for a dead directory. */
		result = ERR_PTR(-ENOENT);
		if (IS_DEADDIR(dir))
			goto out_unlock;

		dentry = d_alloc(parent, name);
L
Linus Torvalds 已提交
504 505 506 507 508 509 510 511
		result = ERR_PTR(-ENOMEM);
		if (dentry) {
			result = dir->i_op->lookup(dir, dentry, nd);
			if (result)
				dput(dentry);
			else
				result = dentry;
		}
512
out_unlock:
513
		mutex_unlock(&dir->i_mutex);
L
Linus Torvalds 已提交
514 515 516 517 518 519 520
		return result;
	}

	/*
	 * Uhhuh! Nasty case: the cache was re-populated while
	 * we waited on the semaphore. Need to revalidate.
	 */
521
	mutex_unlock(&dir->i_mutex);
L
Linus Torvalds 已提交
522
	if (result->d_op && result->d_op->d_revalidate) {
523 524
		result = do_revalidate(result, nd);
		if (!result)
L
Linus Torvalds 已提交
525 526 527 528 529 530
			result = ERR_PTR(-ENOENT);
	}
	return result;
}

/* SMP-safe */
A
Al Viro 已提交
531
static __always_inline void
L
Linus Torvalds 已提交
532 533
walk_init_root(const char *name, struct nameidata *nd)
{
534 535 536
	struct fs_struct *fs = current->fs;

	read_lock(&fs->lock);
J
Jan Blunck 已提交
537 538
	nd->path = fs->root;
	path_get(&fs->root);
539
	read_unlock(&fs->lock);
L
Linus Torvalds 已提交
540 541
}

542 543 544 545 546 547 548 549 550 551 552 553 554
/*
 * Wrapper to retry pathname resolution whenever the underlying
 * file system returns an ESTALE.
 *
 * Retry the whole path once, forcing real lookup requests
 * instead of relying on the dcache.
 */
static __always_inline int link_path_walk(const char *name, struct nameidata *nd)
{
	struct path save = nd->path;
	int result;

	/* make sure the stuff we saved doesn't go away */
555
	path_get(&save);
556 557 558 559 560

	result = __link_path_walk(name, nd);
	if (result == -ESTALE) {
		/* nd->path had been dropped */
		nd->path = save;
561
		path_get(&nd->path);
562 563 564 565 566 567 568 569 570
		nd->flags |= LOOKUP_REVAL;
		result = __link_path_walk(name, nd);
	}

	path_put(&save);

	return result;
}

571
static __always_inline int __vfs_follow_link(struct nameidata *nd, const char *link)
L
Linus Torvalds 已提交
572 573 574 575 576 577 578
{
	int res = 0;
	char *name;
	if (IS_ERR(link))
		goto fail;

	if (*link == '/') {
J
Jan Blunck 已提交
579
		path_put(&nd->path);
A
Al Viro 已提交
580
		walk_init_root(link, nd);
L
Linus Torvalds 已提交
581 582 583 584 585 586 587 588 589 590 591
	}
	res = link_path_walk(link, nd);
	if (nd->depth || res || nd->last_type!=LAST_NORM)
		return res;
	/*
	 * If it is an iterative symlinks resolution in open_namei() we
	 * have to copy the last component. And all that crap because of
	 * bloody create() on broken symlinks. Furrfu...
	 */
	name = __getname();
	if (unlikely(!name)) {
J
Jan Blunck 已提交
592
		path_put(&nd->path);
L
Linus Torvalds 已提交
593 594 595 596 597 598
		return -ENOMEM;
	}
	strcpy(name, nd->last.name);
	nd->last.name = name;
	return 0;
fail:
J
Jan Blunck 已提交
599
	path_put(&nd->path);
L
Linus Torvalds 已提交
600 601 602
	return PTR_ERR(link);
}

J
Jan Blunck 已提交
603
static void path_put_conditional(struct path *path, struct nameidata *nd)
604 605
{
	dput(path->dentry);
606
	if (path->mnt != nd->path.mnt)
607 608 609 610 611
		mntput(path->mnt);
}

static inline void path_to_nameidata(struct path *path, struct nameidata *nd)
{
612 613 614 615 616
	dput(nd->path.dentry);
	if (nd->path.mnt != path->mnt)
		mntput(nd->path.mnt);
	nd->path.mnt = path->mnt;
	nd->path.dentry = path->dentry;
617 618
}

619
static __always_inline int __do_follow_link(struct path *path, struct nameidata *nd)
L
Linus Torvalds 已提交
620 621
{
	int error;
622
	void *cookie;
A
Al Viro 已提交
623
	struct dentry *dentry = path->dentry;
L
Linus Torvalds 已提交
624

A
Al Viro 已提交
625
	touch_atime(path->mnt, dentry);
L
Linus Torvalds 已提交
626
	nd_set_link(nd, NULL);
A
Al Viro 已提交
627

628
	if (path->mnt != nd->path.mnt) {
629 630 631 632
		path_to_nameidata(path, nd);
		dget(dentry);
	}
	mntget(path->mnt);
633 634 635
	cookie = dentry->d_inode->i_op->follow_link(dentry, nd);
	error = PTR_ERR(cookie);
	if (!IS_ERR(cookie)) {
L
Linus Torvalds 已提交
636
		char *s = nd_get_link(nd);
637
		error = 0;
L
Linus Torvalds 已提交
638 639 640
		if (s)
			error = __vfs_follow_link(nd, s);
		if (dentry->d_inode->i_op->put_link)
641
			dentry->d_inode->i_op->put_link(dentry, nd, cookie);
L
Linus Torvalds 已提交
642
	}
643
	path_put(path);
L
Linus Torvalds 已提交
644 645 646 647 648 649 650 651 652 653 654

	return error;
}

/*
 * This limits recursive symlink follows to 8, while
 * limiting consecutive symlinks to 40.
 *
 * Without that kind of total limit, nasty chains of consecutive
 * symlinks can cause almost arbitrarily long lookups. 
 */
A
Al Viro 已提交
655
static inline int do_follow_link(struct path *path, struct nameidata *nd)
L
Linus Torvalds 已提交
656 657 658 659 660 661 662 663
{
	int err = -ELOOP;
	if (current->link_count >= MAX_NESTED_LINKS)
		goto loop;
	if (current->total_link_count >= 40)
		goto loop;
	BUG_ON(nd->depth >= MAX_NESTED_LINKS);
	cond_resched();
A
Al Viro 已提交
664
	err = security_inode_follow_link(path->dentry, nd);
L
Linus Torvalds 已提交
665 666 667 668 669
	if (err)
		goto loop;
	current->link_count++;
	current->total_link_count++;
	nd->depth++;
A
Al Viro 已提交
670
	err = __do_follow_link(path, nd);
A
Al Viro 已提交
671 672
	current->link_count--;
	nd->depth--;
L
Linus Torvalds 已提交
673 674
	return err;
loop:
J
Jan Blunck 已提交
675 676
	path_put_conditional(path, nd);
	path_put(&nd->path);
L
Linus Torvalds 已提交
677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702
	return err;
}

int follow_up(struct vfsmount **mnt, struct dentry **dentry)
{
	struct vfsmount *parent;
	struct dentry *mountpoint;
	spin_lock(&vfsmount_lock);
	parent=(*mnt)->mnt_parent;
	if (parent == *mnt) {
		spin_unlock(&vfsmount_lock);
		return 0;
	}
	mntget(parent);
	mountpoint=dget((*mnt)->mnt_mountpoint);
	spin_unlock(&vfsmount_lock);
	dput(*dentry);
	*dentry = mountpoint;
	mntput(*mnt);
	*mnt = parent;
	return 1;
}

/* no need for dcache_lock, as serialization is taken care in
 * namespace.c
 */
A
Al Viro 已提交
703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719
static int __follow_mount(struct path *path)
{
	int res = 0;
	while (d_mountpoint(path->dentry)) {
		struct vfsmount *mounted = lookup_mnt(path->mnt, path->dentry);
		if (!mounted)
			break;
		dput(path->dentry);
		if (res)
			mntput(path->mnt);
		path->mnt = mounted;
		path->dentry = dget(mounted->mnt_root);
		res = 1;
	}
	return res;
}

A
Al Viro 已提交
720
static void follow_mount(struct vfsmount **mnt, struct dentry **dentry)
L
Linus Torvalds 已提交
721 722 723 724 725
{
	while (d_mountpoint(*dentry)) {
		struct vfsmount *mounted = lookup_mnt(*mnt, *dentry);
		if (!mounted)
			break;
A
Al Viro 已提交
726
		dput(*dentry);
L
Linus Torvalds 已提交
727 728 729 730 731 732 733 734 735
		mntput(*mnt);
		*mnt = mounted;
		*dentry = dget(mounted->mnt_root);
	}
}

/* no need for dcache_lock, as serialization is taken care in
 * namespace.c
 */
A
Al Viro 已提交
736
int follow_down(struct vfsmount **mnt, struct dentry **dentry)
L
Linus Torvalds 已提交
737 738 739 740 741
{
	struct vfsmount *mounted;

	mounted = lookup_mnt(*mnt, *dentry);
	if (mounted) {
A
Al Viro 已提交
742
		dput(*dentry);
L
Linus Torvalds 已提交
743 744 745 746 747 748 749 750
		mntput(*mnt);
		*mnt = mounted;
		*dentry = dget(mounted->mnt_root);
		return 1;
	}
	return 0;
}

751
static __always_inline void follow_dotdot(struct nameidata *nd)
L
Linus Torvalds 已提交
752
{
753 754
	struct fs_struct *fs = current->fs;

L
Linus Torvalds 已提交
755 756
	while(1) {
		struct vfsmount *parent;
757
		struct dentry *old = nd->path.dentry;
L
Linus Torvalds 已提交
758

759
                read_lock(&fs->lock);
J
Jan Blunck 已提交
760 761
		if (nd->path.dentry == fs->root.dentry &&
		    nd->path.mnt == fs->root.mnt) {
762
                        read_unlock(&fs->lock);
L
Linus Torvalds 已提交
763 764
			break;
		}
765
                read_unlock(&fs->lock);
L
Linus Torvalds 已提交
766
		spin_lock(&dcache_lock);
767 768
		if (nd->path.dentry != nd->path.mnt->mnt_root) {
			nd->path.dentry = dget(nd->path.dentry->d_parent);
L
Linus Torvalds 已提交
769 770 771 772 773 774
			spin_unlock(&dcache_lock);
			dput(old);
			break;
		}
		spin_unlock(&dcache_lock);
		spin_lock(&vfsmount_lock);
775 776
		parent = nd->path.mnt->mnt_parent;
		if (parent == nd->path.mnt) {
L
Linus Torvalds 已提交
777 778 779 780
			spin_unlock(&vfsmount_lock);
			break;
		}
		mntget(parent);
781
		nd->path.dentry = dget(nd->path.mnt->mnt_mountpoint);
L
Linus Torvalds 已提交
782 783
		spin_unlock(&vfsmount_lock);
		dput(old);
784 785
		mntput(nd->path.mnt);
		nd->path.mnt = parent;
L
Linus Torvalds 已提交
786
	}
787
	follow_mount(&nd->path.mnt, &nd->path.dentry);
L
Linus Torvalds 已提交
788 789 790 791 792 793 794 795 796 797
}

/*
 *  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,
		     struct path *path)
{
798 799
	struct vfsmount *mnt = nd->path.mnt;
	struct dentry *dentry = __d_lookup(nd->path.dentry, name);
L
Linus Torvalds 已提交
800 801 802 803 804 805 806 807

	if (!dentry)
		goto need_lookup;
	if (dentry->d_op && dentry->d_op->d_revalidate)
		goto need_revalidate;
done:
	path->mnt = mnt;
	path->dentry = dentry;
A
Al Viro 已提交
808
	__follow_mount(path);
L
Linus Torvalds 已提交
809 810 811
	return 0;

need_lookup:
812
	dentry = real_lookup(nd->path.dentry, name, nd);
L
Linus Torvalds 已提交
813 814 815 816 817
	if (IS_ERR(dentry))
		goto fail;
	goto done;

need_revalidate:
818 819 820 821 822 823
	dentry = do_revalidate(dentry, nd);
	if (!dentry)
		goto need_lookup;
	if (IS_ERR(dentry))
		goto fail;
	goto done;
L
Linus Torvalds 已提交
824 825 826 827 828 829 830

fail:
	return PTR_ERR(dentry);
}

/*
 * Name resolution.
831 832
 * This is the basic name resolution function, turning a pathname into
 * the final dentry. We expect 'base' to be positive and a directory.
L
Linus Torvalds 已提交
833
 *
834 835
 * Returns 0 and nd will have valid dentry and mnt on success.
 * Returns error and drops reference to input namei data on failure.
L
Linus Torvalds 已提交
836
 */
837
static int __link_path_walk(const char *name, struct nameidata *nd)
L
Linus Torvalds 已提交
838 839 840 841 842 843 844 845 846 847 848
{
	struct path next;
	struct inode *inode;
	int err;
	unsigned int lookup_flags = nd->flags;
	
	while (*name=='/')
		name++;
	if (!*name)
		goto return_reval;

849
	inode = nd->path.dentry->d_inode;
L
Linus Torvalds 已提交
850
	if (nd->depth)
851
		lookup_flags = LOOKUP_FOLLOW | (nd->flags & LOOKUP_CONTINUE);
L
Linus Torvalds 已提交
852 853 854 855 856 857 858

	/* At this point we know we have a real path component. */
	for(;;) {
		unsigned long hash;
		struct qstr this;
		unsigned int c;

859
		nd->flags |= LOOKUP_CONTINUE;
860
		err = exec_permission_lite(inode);
861 862
		if (err == -EAGAIN)
			err = vfs_permission(nd, MAY_EXEC);
L
Linus Torvalds 已提交
863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895
 		if (err)
			break;

		this.name = name;
		c = *(const unsigned char *)name;

		hash = init_name_hash();
		do {
			name++;
			hash = partial_name_hash(c, hash);
			c = *(const unsigned char *)name;
		} while (c && (c != '/'));
		this.len = name - (const char *) this.name;
		this.hash = end_name_hash(hash);

		/* remove trailing slashes? */
		if (!c)
			goto last_component;
		while (*++name == '/');
		if (!*name)
			goto last_with_slashes;

		/*
		 * "." and ".." are special - ".." especially so because it has
		 * to be able to know about the current root directory and
		 * parent relationships.
		 */
		if (this.name[0] == '.') switch (this.len) {
			default:
				break;
			case 2:	
				if (this.name[1] != '.')
					break;
A
Al Viro 已提交
896
				follow_dotdot(nd);
897
				inode = nd->path.dentry->d_inode;
L
Linus Torvalds 已提交
898 899 900 901 902 903 904 905
				/* fallthrough */
			case 1:
				continue;
		}
		/*
		 * See if the low-level filesystem might want
		 * to use its own hash..
		 */
906 907 908
		if (nd->path.dentry->d_op && nd->path.dentry->d_op->d_hash) {
			err = nd->path.dentry->d_op->d_hash(nd->path.dentry,
							    &this);
L
Linus Torvalds 已提交
909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925
			if (err < 0)
				break;
		}
		/* This does the actual lookups.. */
		err = do_lookup(nd, &this, &next);
		if (err)
			break;

		err = -ENOENT;
		inode = next.dentry->d_inode;
		if (!inode)
			goto out_dput;
		err = -ENOTDIR; 
		if (!inode->i_op)
			goto out_dput;

		if (inode->i_op->follow_link) {
A
Al Viro 已提交
926
			err = do_follow_link(&next, nd);
L
Linus Torvalds 已提交
927 928 929
			if (err)
				goto return_err;
			err = -ENOENT;
930
			inode = nd->path.dentry->d_inode;
L
Linus Torvalds 已提交
931 932 933 934 935
			if (!inode)
				break;
			err = -ENOTDIR; 
			if (!inode->i_op)
				break;
M
Miklos Szeredi 已提交
936 937
		} else
			path_to_nameidata(&next, nd);
L
Linus Torvalds 已提交
938 939 940 941 942 943 944 945 946
		err = -ENOTDIR; 
		if (!inode->i_op->lookup)
			break;
		continue;
		/* here ends the main loop */

last_with_slashes:
		lookup_flags |= LOOKUP_FOLLOW | LOOKUP_DIRECTORY;
last_component:
947 948
		/* Clear LOOKUP_CONTINUE iff it was previously unset */
		nd->flags &= lookup_flags | ~LOOKUP_CONTINUE;
L
Linus Torvalds 已提交
949 950 951 952 953 954 955 956
		if (lookup_flags & LOOKUP_PARENT)
			goto lookup_parent;
		if (this.name[0] == '.') switch (this.len) {
			default:
				break;
			case 2:	
				if (this.name[1] != '.')
					break;
A
Al Viro 已提交
957
				follow_dotdot(nd);
958
				inode = nd->path.dentry->d_inode;
L
Linus Torvalds 已提交
959 960 961 962
				/* fallthrough */
			case 1:
				goto return_reval;
		}
963 964 965
		if (nd->path.dentry->d_op && nd->path.dentry->d_op->d_hash) {
			err = nd->path.dentry->d_op->d_hash(nd->path.dentry,
							    &this);
L
Linus Torvalds 已提交
966 967 968 969 970 971 972 973 974
			if (err < 0)
				break;
		}
		err = do_lookup(nd, &this, &next);
		if (err)
			break;
		inode = next.dentry->d_inode;
		if ((lookup_flags & LOOKUP_FOLLOW)
		    && inode && inode->i_op && inode->i_op->follow_link) {
A
Al Viro 已提交
975
			err = do_follow_link(&next, nd);
L
Linus Torvalds 已提交
976 977
			if (err)
				goto return_err;
978
			inode = nd->path.dentry->d_inode;
M
Miklos Szeredi 已提交
979 980
		} else
			path_to_nameidata(&next, nd);
L
Linus Torvalds 已提交
981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005
		err = -ENOENT;
		if (!inode)
			break;
		if (lookup_flags & LOOKUP_DIRECTORY) {
			err = -ENOTDIR; 
			if (!inode->i_op || !inode->i_op->lookup)
				break;
		}
		goto return_base;
lookup_parent:
		nd->last = this;
		nd->last_type = LAST_NORM;
		if (this.name[0] != '.')
			goto return_base;
		if (this.len == 1)
			nd->last_type = LAST_DOT;
		else if (this.len == 2 && this.name[1] == '.')
			nd->last_type = LAST_DOTDOT;
		else
			goto return_base;
return_reval:
		/*
		 * We bypassed the ordinary revalidation routines.
		 * We may need to check the cached dentry for staleness.
		 */
1006 1007
		if (nd->path.dentry && nd->path.dentry->d_sb &&
		    (nd->path.dentry->d_sb->s_type->fs_flags & FS_REVAL_DOT)) {
L
Linus Torvalds 已提交
1008 1009
			err = -ESTALE;
			/* Note: we do not d_invalidate() */
1010 1011
			if (!nd->path.dentry->d_op->d_revalidate(
					nd->path.dentry, nd))
L
Linus Torvalds 已提交
1012 1013 1014 1015 1016
				break;
		}
return_base:
		return 0;
out_dput:
J
Jan Blunck 已提交
1017
		path_put_conditional(&next, nd);
L
Linus Torvalds 已提交
1018 1019
		break;
	}
J
Jan Blunck 已提交
1020
	path_put(&nd->path);
L
Linus Torvalds 已提交
1021 1022 1023 1024
return_err:
	return err;
}

1025
static int path_walk(const char *name, struct nameidata *nd)
L
Linus Torvalds 已提交
1026 1027 1028 1029 1030
{
	current->total_link_count = 0;
	return link_path_walk(name, nd);
}

1031
/* Returns 0 and nd will be valid on success; Retuns error, otherwise. */
1032
static int do_path_lookup(int dfd, const char *name,
1033
				unsigned int flags, struct nameidata *nd)
L
Linus Torvalds 已提交
1034
{
1035
	int retval = 0;
1036 1037
	int fput_needed;
	struct file *file;
1038
	struct fs_struct *fs = current->fs;
L
Linus Torvalds 已提交
1039 1040 1041 1042 1043 1044

	nd->last_type = LAST_ROOT; /* if there are only slashes... */
	nd->flags = flags;
	nd->depth = 0;

	if (*name=='/') {
1045
		read_lock(&fs->lock);
J
Jan Blunck 已提交
1046 1047
		nd->path = fs->root;
		path_get(&fs->root);
1048
		read_unlock(&fs->lock);
1049
	} else if (dfd == AT_FDCWD) {
1050
		read_lock(&fs->lock);
J
Jan Blunck 已提交
1051 1052
		nd->path = fs->pwd;
		path_get(&fs->pwd);
1053
		read_unlock(&fs->lock);
1054 1055 1056 1057
	} else {
		struct dentry *dentry;

		file = fget_light(dfd, &fput_needed);
1058 1059
		retval = -EBADF;
		if (!file)
1060
			goto out_fail;
1061

1062
		dentry = file->f_path.dentry;
1063

1064 1065
		retval = -ENOTDIR;
		if (!S_ISDIR(dentry->d_inode->i_mode))
1066
			goto fput_fail;
1067 1068

		retval = file_permission(file, MAY_EXEC);
1069
		if (retval)
1070
			goto fput_fail;
1071

J
Jan Blunck 已提交
1072 1073
		nd->path = file->f_path;
		path_get(&file->f_path);
1074 1075

		fput_light(file, fput_needed);
L
Linus Torvalds 已提交
1076
	}
1077 1078

	retval = path_walk(name, nd);
1079 1080 1081
	if (unlikely(!retval && !audit_dummy_context() && nd->path.dentry &&
				nd->path.dentry->d_inode))
		audit_inode(name, nd->path.dentry);
1082
out_fail:
1083 1084
	return retval;

1085
fput_fail:
1086
	fput_light(file, fput_needed);
1087
	goto out_fail;
L
Linus Torvalds 已提交
1088 1089
}

1090
int path_lookup(const char *name, unsigned int flags,
1091 1092 1093 1094 1095
			struct nameidata *nd)
{
	return do_path_lookup(AT_FDCWD, name, flags, nd);
}

A
Al Viro 已提交
1096 1097 1098 1099 1100 1101 1102 1103 1104
int kern_path(const char *name, unsigned int flags, struct path *path)
{
	struct nameidata nd;
	int res = do_path_lookup(AT_FDCWD, name, flags, &nd);
	if (!res)
		*path = nd.path;
	return res;
}

1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123
/**
 * vfs_path_lookup - lookup a file path relative to a dentry-vfsmount pair
 * @dentry:  pointer to dentry of the base directory
 * @mnt: pointer to vfs mount of the base directory
 * @name: pointer to file name
 * @flags: lookup flags
 * @nd: pointer to nameidata
 */
int vfs_path_lookup(struct dentry *dentry, struct vfsmount *mnt,
		    const char *name, unsigned int flags,
		    struct nameidata *nd)
{
	int retval;

	/* same as do_path_lookup */
	nd->last_type = LAST_ROOT;
	nd->flags = flags;
	nd->depth = 0;

1124 1125 1126
	nd->path.dentry = dentry;
	nd->path.mnt = mnt;
	path_get(&nd->path);
1127 1128

	retval = path_walk(name, nd);
1129 1130 1131
	if (unlikely(!retval && !audit_dummy_context() && nd->path.dentry &&
				nd->path.dentry->d_inode))
		audit_inode(name, nd->path.dentry);
1132 1133 1134 1135 1136

	return retval;

}

A
Al Viro 已提交
1137 1138 1139 1140 1141 1142 1143 1144 1145 1146
/**
 * path_lookup_open - lookup a file path with open intent
 * @dfd: the directory to use as base, or AT_FDCWD
 * @name: pointer to file name
 * @lookup_flags: lookup intent flags
 * @nd: pointer to nameidata
 * @open_flags: open intent flags
 */
int path_lookup_open(int dfd, const char *name, unsigned int lookup_flags,
		struct nameidata *nd, int open_flags)
1147 1148 1149 1150 1151 1152 1153 1154
{
	struct file *filp = get_empty_filp();
	int err;

	if (filp == NULL)
		return -ENFILE;
	nd->intent.open.file = filp;
	nd->intent.open.flags = open_flags;
A
Al Viro 已提交
1155
	nd->intent.open.create_mode = 0;
1156
	err = do_path_lookup(dfd, name, lookup_flags|LOOKUP_OPEN, nd);
1157 1158 1159
	if (IS_ERR(nd->intent.open.file)) {
		if (err == 0) {
			err = PTR_ERR(nd->intent.open.file);
J
Jan Blunck 已提交
1160
			path_put(&nd->path);
1161 1162 1163 1164 1165 1166
		}
	} else if (err != 0)
		release_open_intent(nd);
	return err;
}

1167 1168
static struct dentry *__lookup_hash(struct qstr *name,
		struct dentry *base, struct nameidata *nd)
L
Linus Torvalds 已提交
1169
{
1170
	struct dentry *dentry;
L
Linus Torvalds 已提交
1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188
	struct inode *inode;
	int err;

	inode = base->d_inode;

	/*
	 * See if the low-level filesystem might want
	 * to use its own hash..
	 */
	if (base->d_op && base->d_op->d_hash) {
		err = base->d_op->d_hash(base, name);
		dentry = ERR_PTR(err);
		if (err < 0)
			goto out;
	}

	dentry = cached_lookup(base, name, nd);
	if (!dentry) {
1189 1190 1191 1192 1193 1194 1195 1196
		struct dentry *new;

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

		new = d_alloc(base, name);
L
Linus Torvalds 已提交
1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209
		dentry = ERR_PTR(-ENOMEM);
		if (!new)
			goto out;
		dentry = inode->i_op->lookup(inode, new, nd);
		if (!dentry)
			dentry = new;
		else
			dput(new);
	}
out:
	return dentry;
}

1210 1211 1212 1213 1214
/*
 * Restricted form of lookup. Doesn't follow links, single-component only,
 * needs parent already locked. Doesn't follow mounts.
 * SMP-safe.
 */
1215
static struct dentry *lookup_hash(struct nameidata *nd)
1216 1217 1218
{
	int err;

1219
	err = inode_permission(nd->path.dentry->d_inode, MAY_EXEC);
1220
	if (err)
1221
		return ERR_PTR(err);
1222
	return __lookup_hash(&nd->last, nd->path.dentry, nd);
L
Linus Torvalds 已提交
1223 1224
}

1225 1226
static int __lookup_one_len(const char *name, struct qstr *this,
		struct dentry *base, int len)
L
Linus Torvalds 已提交
1227 1228 1229 1230
{
	unsigned long hash;
	unsigned int c;

1231 1232
	this->name = name;
	this->len = len;
L
Linus Torvalds 已提交
1233
	if (!len)
1234
		return -EACCES;
L
Linus Torvalds 已提交
1235 1236 1237 1238 1239

	hash = init_name_hash();
	while (len--) {
		c = *(const unsigned char *)name++;
		if (c == '/' || c == '\0')
1240
			return -EACCES;
L
Linus Torvalds 已提交
1241 1242
		hash = partial_name_hash(c, hash);
	}
1243 1244 1245
	this->hash = end_name_hash(hash);
	return 0;
}
L
Linus Torvalds 已提交
1246

1247
/**
1248
 * lookup_one_len - filesystem helper to lookup single pathname component
1249 1250 1251 1252
 * @name:	pathname component to lookup
 * @base:	base directory to lookup from
 * @len:	maximum length @len should be interpreted to
 *
1253 1254
 * Note that this routine is purely a helper for filesystem usage and should
 * not be called by generic code.  Also note that by using this function the
1255 1256 1257
 * nameidata argument is passed to the filesystem methods and a filesystem
 * using this helper needs to be prepared for that.
 */
1258 1259 1260 1261 1262 1263
struct dentry *lookup_one_len(const char *name, struct dentry *base, int len)
{
	int err;
	struct qstr this;

	err = __lookup_one_len(name, &this, base, len);
1264 1265 1266
	if (err)
		return ERR_PTR(err);

1267
	err = inode_permission(base->d_inode, MAY_EXEC);
1268 1269
	if (err)
		return ERR_PTR(err);
1270
	return __lookup_hash(&this, base, NULL);
1271 1272
}

1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284
/**
 * lookup_one_noperm - bad hack for sysfs
 * @name:	pathname component to lookup
 * @base:	base directory to lookup from
 *
 * This is a variant of lookup_one_len that doesn't perform any permission
 * checks.   It's a horrible hack to work around the braindead sysfs
 * architecture and should not be used anywhere else.
 *
 * DON'T USE THIS FUNCTION EVER, thanks.
 */
struct dentry *lookup_one_noperm(const char *name, struct dentry *base)
1285 1286 1287 1288
{
	int err;
	struct qstr this;

1289
	err = __lookup_one_len(name, &this, base, strlen(name));
1290 1291
	if (err)
		return ERR_PTR(err);
1292
	return __lookup_hash(&this, base, NULL);
L
Linus Torvalds 已提交
1293 1294
}

1295 1296
int user_path_at(int dfd, const char __user *name, unsigned flags,
		 struct path *path)
L
Linus Torvalds 已提交
1297
{
1298
	struct nameidata nd;
L
Linus Torvalds 已提交
1299 1300 1301
	char *tmp = getname(name);
	int err = PTR_ERR(tmp);
	if (!IS_ERR(tmp)) {
1302 1303 1304 1305

		BUG_ON(flags & LOOKUP_PARENT);

		err = do_path_lookup(dfd, tmp, flags, &nd);
L
Linus Torvalds 已提交
1306
		putname(tmp);
1307 1308
		if (!err)
			*path = nd.path;
L
Linus Torvalds 已提交
1309 1310 1311 1312
	}
	return err;
}

1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330
static int user_path_parent(int dfd, const char __user *path,
			struct nameidata *nd, char **name)
{
	char *s = getname(path);
	int error;

	if (IS_ERR(s))
		return PTR_ERR(s);

	error = do_path_lookup(dfd, s, LOOKUP_PARENT, nd);
	if (error)
		putname(s);
	else
		*name = s;

	return error;
}

L
Linus Torvalds 已提交
1331 1332 1333 1334 1335 1336
/*
 * It's inline, so penalty for filesystems that don't use sticky bit is
 * minimal.
 */
static inline int check_sticky(struct inode *dir, struct inode *inode)
{
1337 1338
	uid_t fsuid = current_fsuid();

L
Linus Torvalds 已提交
1339 1340
	if (!(dir->i_mode & S_ISVTX))
		return 0;
1341
	if (inode->i_uid == fsuid)
L
Linus Torvalds 已提交
1342
		return 0;
1343
	if (dir->i_uid == fsuid)
L
Linus Torvalds 已提交
1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366
		return 0;
	return !capable(CAP_FOWNER);
}

/*
 *	Check whether we can remove a link victim from directory dir, check
 *  whether the type of victim is right.
 *  1. We can't do it if dir is read-only (done in permission())
 *  2. We should have write and exec permissions on dir
 *  3. We can't remove anything from append-only dir
 *  4. We can't do anything with immutable dir (done in permission())
 *  5. If the sticky bit on dir is set we should either
 *	a. be owner of dir, or
 *	b. be owner of victim, or
 *	c. have CAP_FOWNER capability
 *  6. If the victim is append-only or immutable we can't do antyhing with
 *     links pointing to it.
 *  7. If we were asked to remove a directory and victim isn't one - ENOTDIR.
 *  8. If we were asked to remove a non-directory and victim isn't one - EISDIR.
 *  9. We can't remove a root or mountpoint.
 * 10. We don't allow removal of NFS sillyrenamed files; it's handled by
 *     nfs_async_unlink().
 */
1367
static int may_delete(struct inode *dir,struct dentry *victim,int isdir)
L
Linus Torvalds 已提交
1368 1369 1370 1371 1372 1373 1374
{
	int error;

	if (!victim->d_inode)
		return -ENOENT;

	BUG_ON(victim->d_parent->d_inode != dir);
1375
	audit_inode_child(victim->d_name.name, victim, dir);
L
Linus Torvalds 已提交
1376

1377
	error = inode_permission(dir, MAY_WRITE | MAY_EXEC);
L
Linus Torvalds 已提交
1378 1379 1380 1381 1382
	if (error)
		return error;
	if (IS_APPEND(dir))
		return -EPERM;
	if (check_sticky(dir, victim->d_inode)||IS_APPEND(victim->d_inode)||
H
Hugh Dickins 已提交
1383
	    IS_IMMUTABLE(victim->d_inode) || IS_SWAPFILE(victim->d_inode))
L
Linus Torvalds 已提交
1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406
		return -EPERM;
	if (isdir) {
		if (!S_ISDIR(victim->d_inode->i_mode))
			return -ENOTDIR;
		if (IS_ROOT(victim))
			return -EBUSY;
	} else if (S_ISDIR(victim->d_inode->i_mode))
		return -EISDIR;
	if (IS_DEADDIR(dir))
		return -ENOENT;
	if (victim->d_flags & DCACHE_NFSFS_RENAMED)
		return -EBUSY;
	return 0;
}

/*	Check whether we can create an object with dentry child in directory
 *  dir.
 *  1. We can't do it if child already exists (open has special treatment for
 *     this case, but since we are inlined it's OK)
 *  2. We can't do it if dir is read-only (done in permission())
 *  3. We should have write and exec permissions on dir
 *  4. We can't do it if dir is immutable (done in permission())
 */
1407
static inline int may_create(struct inode *dir, struct dentry *child)
L
Linus Torvalds 已提交
1408 1409 1410 1411 1412
{
	if (child->d_inode)
		return -EEXIST;
	if (IS_DEADDIR(dir))
		return -ENOENT;
1413
	return inode_permission(dir, MAY_WRITE | MAY_EXEC);
L
Linus Torvalds 已提交
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
}

/* 
 * O_DIRECTORY translates into forcing a directory lookup.
 */
static inline int lookup_flags(unsigned int f)
{
	unsigned long retval = LOOKUP_FOLLOW;

	if (f & O_NOFOLLOW)
		retval &= ~LOOKUP_FOLLOW;
	
	if (f & O_DIRECTORY)
		retval |= LOOKUP_DIRECTORY;

	return retval;
}

/*
 * p1 and p2 should be directories on the same fs.
 */
struct dentry *lock_rename(struct dentry *p1, struct dentry *p2)
{
	struct dentry *p;

	if (p1 == p2) {
I
Ingo Molnar 已提交
1440
		mutex_lock_nested(&p1->d_inode->i_mutex, I_MUTEX_PARENT);
L
Linus Torvalds 已提交
1441 1442 1443
		return NULL;
	}

1444
	mutex_lock(&p1->d_inode->i_sb->s_vfs_rename_mutex);
L
Linus Torvalds 已提交
1445

1446 1447 1448 1449 1450
	p = d_ancestor(p2, p1);
	if (p) {
		mutex_lock_nested(&p2->d_inode->i_mutex, I_MUTEX_PARENT);
		mutex_lock_nested(&p1->d_inode->i_mutex, I_MUTEX_CHILD);
		return p;
L
Linus Torvalds 已提交
1451 1452
	}

1453 1454 1455 1456 1457
	p = d_ancestor(p1, p2);
	if (p) {
		mutex_lock_nested(&p1->d_inode->i_mutex, I_MUTEX_PARENT);
		mutex_lock_nested(&p2->d_inode->i_mutex, I_MUTEX_CHILD);
		return p;
L
Linus Torvalds 已提交
1458 1459
	}

I
Ingo Molnar 已提交
1460 1461
	mutex_lock_nested(&p1->d_inode->i_mutex, I_MUTEX_PARENT);
	mutex_lock_nested(&p2->d_inode->i_mutex, I_MUTEX_CHILD);
L
Linus Torvalds 已提交
1462 1463 1464 1465 1466
	return NULL;
}

void unlock_rename(struct dentry *p1, struct dentry *p2)
{
1467
	mutex_unlock(&p1->d_inode->i_mutex);
L
Linus Torvalds 已提交
1468
	if (p1 != p2) {
1469
		mutex_unlock(&p2->d_inode->i_mutex);
1470
		mutex_unlock(&p1->d_inode->i_sb->s_vfs_rename_mutex);
L
Linus Torvalds 已提交
1471 1472 1473 1474 1475 1476
	}
}

int vfs_create(struct inode *dir, struct dentry *dentry, int mode,
		struct nameidata *nd)
{
1477
	int error = may_create(dir, dentry);
L
Linus Torvalds 已提交
1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490

	if (error)
		return error;

	if (!dir->i_op || !dir->i_op->create)
		return -EACCES;	/* shouldn't it be ENOSYS? */
	mode &= S_IALLUGO;
	mode |= S_IFREG;
	error = security_inode_create(dir, dentry, mode);
	if (error)
		return error;
	DQUOT_INIT(dir);
	error = dir->i_op->create(dir, dentry, mode, nd);
1491
	if (!error)
1492
		fsnotify_create(dir, dentry);
L
Linus Torvalds 已提交
1493 1494 1495 1496 1497
	return error;
}

int may_open(struct nameidata *nd, int acc_mode, int flag)
{
1498
	struct dentry *dentry = nd->path.dentry;
L
Linus Torvalds 已提交
1499 1500 1501 1502 1503 1504 1505 1506 1507
	struct inode *inode = dentry->d_inode;
	int error;

	if (!inode)
		return -ENOENT;

	if (S_ISLNK(inode->i_mode))
		return -ELOOP;
	
1508
	if (S_ISDIR(inode->i_mode) && (acc_mode & MAY_WRITE))
L
Linus Torvalds 已提交
1509 1510 1511 1512 1513 1514 1515 1516 1517 1518
		return -EISDIR;

	/*
	 * FIFO's, sockets and device files are special: they don't
	 * actually live on the filesystem itself, and as such you
	 * can write to them even if the filesystem is read-only.
	 */
	if (S_ISFIFO(inode->i_mode) || S_ISSOCK(inode->i_mode)) {
	    	flag &= ~O_TRUNC;
	} else if (S_ISBLK(inode->i_mode) || S_ISCHR(inode->i_mode)) {
1519
		if (nd->path.mnt->mnt_flags & MNT_NODEV)
L
Linus Torvalds 已提交
1520 1521 1522
			return -EACCES;

		flag &= ~O_TRUNC;
1523
	}
1524 1525 1526 1527

	error = vfs_permission(nd, acc_mode);
	if (error)
		return error;
L
Linus Torvalds 已提交
1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539
	/*
	 * An append-only file must be opened in append mode for writing.
	 */
	if (IS_APPEND(inode)) {
		if  ((flag & FMODE_WRITE) && !(flag & O_APPEND))
			return -EPERM;
		if (flag & O_TRUNC)
			return -EPERM;
	}

	/* O_NOATIME can only be set by the owner or superuser */
	if (flag & O_NOATIME)
1540
		if (!is_owner_or_cap(inode))
L
Linus Torvalds 已提交
1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558
			return -EPERM;

	/*
	 * Ensure there are no outstanding leases on the file.
	 */
	error = break_lease(inode, flag);
	if (error)
		return error;

	if (flag & O_TRUNC) {
		error = get_write_access(inode);
		if (error)
			return error;

		/*
		 * Refuse to truncate files with mandatory locks held on them.
		 */
		error = locks_verify_locked(inode);
1559 1560 1561
		if (!error)
			error = security_path_truncate(&nd->path, 0,
					       ATTR_MTIME|ATTR_CTIME|ATTR_OPEN);
L
Linus Torvalds 已提交
1562 1563
		if (!error) {
			DQUOT_INIT(inode);
1564 1565 1566 1567

			error = do_truncate(dentry, 0,
					    ATTR_MTIME|ATTR_CTIME|ATTR_OPEN,
					    NULL);
L
Linus Torvalds 已提交
1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578
		}
		put_write_access(inode);
		if (error)
			return error;
	} else
		if (flag & FMODE_WRITE)
			DQUOT_INIT(inode);

	return 0;
}

1579 1580 1581 1582 1583 1584
/*
 * Be careful about ever adding any more callers of this
 * function.  Its flags must be in the namei format, not
 * what get passed to sys_open().
 */
static int __open_namei_create(struct nameidata *nd, struct path *path,
1585 1586 1587
				int flag, int mode)
{
	int error;
1588
	struct dentry *dir = nd->path.dentry;
1589 1590 1591

	if (!IS_POSIXACL(dir->d_inode))
		mode &= ~current->fs->umask;
1592 1593 1594
	error = security_path_mknod(&nd->path, path->dentry, mode, 0);
	if (error)
		goto out_unlock;
1595
	error = vfs_create(dir->d_inode, path->dentry, mode, nd);
1596
out_unlock:
1597
	mutex_unlock(&dir->d_inode->i_mutex);
1598 1599
	dput(nd->path.dentry);
	nd->path.dentry = path->dentry;
1600 1601 1602 1603 1604 1605
	if (error)
		return error;
	/* Don't check for write permission, don't truncate */
	return may_open(nd, 0, flag & ~O_TRUNC);
}

1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629
/*
 * Note that while the flag value (low two bits) for sys_open means:
 *	00 - read-only
 *	01 - write-only
 *	10 - read-write
 *	11 - special
 * it is changed into
 *	00 - no permissions needed
 *	01 - read-permission
 *	10 - write-permission
 *	11 - read-write
 * for the internal routines (ie open_namei()/follow_link() etc)
 * This is more logical, and also allows the 00 "no perm needed"
 * to be used for symlinks (where the permissions are checked
 * later).
 *
*/
static inline int open_to_namei_flags(int flag)
{
	if ((flag+1) & O_ACCMODE)
		flag++;
	return flag;
}

1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640
static int open_will_write_to_fs(int flag, struct inode *inode)
{
	/*
	 * We'll never write to the fs underlying
	 * a device file.
	 */
	if (special_file(inode->i_mode))
		return 0;
	return (flag & O_TRUNC);
}

L
Linus Torvalds 已提交
1641
/*
1642 1643 1644
 * Note that the low bits of the passed in "open_flag"
 * are not the same as in the local variable "flag". See
 * open_to_namei_flags() for more details.
L
Linus Torvalds 已提交
1645
 */
1646 1647
struct file *do_filp_open(int dfd, const char *pathname,
		int open_flag, int mode)
L
Linus Torvalds 已提交
1648
{
1649
	struct file *filp;
1650
	struct nameidata nd;
1651
	int acc_mode, error;
A
Al Viro 已提交
1652
	struct path path;
L
Linus Torvalds 已提交
1653 1654
	struct dentry *dir;
	int count = 0;
1655
	int will_write;
1656
	int flag = open_to_namei_flags(open_flag);
L
Linus Torvalds 已提交
1657

1658
	acc_mode = MAY_OPEN | ACC_MODE(flag);
L
Linus Torvalds 已提交
1659

1660 1661 1662 1663
	/* O_TRUNC implies we need access checks for write permissions */
	if (flag & O_TRUNC)
		acc_mode |= MAY_WRITE;

L
Linus Torvalds 已提交
1664 1665 1666 1667 1668 1669 1670 1671 1672
	/* Allow the LSM permission hook to distinguish append 
	   access from general write access. */
	if (flag & O_APPEND)
		acc_mode |= MAY_APPEND;

	/*
	 * The simplest case - just a plain lookup.
	 */
	if (!(flag & O_CREAT)) {
1673
		error = path_lookup_open(dfd, pathname, lookup_flags(flag),
1674
					 &nd, flag);
L
Linus Torvalds 已提交
1675
		if (error)
1676
			return ERR_PTR(error);
L
Linus Torvalds 已提交
1677 1678 1679 1680 1681 1682
		goto ok;
	}

	/*
	 * Create - we need to know the parent.
	 */
A
Al Viro 已提交
1683
	error = do_path_lookup(dfd, pathname, LOOKUP_PARENT, &nd);
L
Linus Torvalds 已提交
1684
	if (error)
1685
		return ERR_PTR(error);
L
Linus Torvalds 已提交
1686 1687 1688 1689 1690 1691 1692

	/*
	 * We have the parent and last component. First of all, check
	 * that we are not asked to creat(2) an obvious directory - that
	 * will not do.
	 */
	error = -EISDIR;
1693
	if (nd.last_type != LAST_NORM || nd.last.name[nd.last.len])
A
Al Viro 已提交
1694
		goto exit_parent;
L
Linus Torvalds 已提交
1695

A
Al Viro 已提交
1696 1697 1698 1699 1700 1701 1702
	error = -ENFILE;
	filp = get_empty_filp();
	if (filp == NULL)
		goto exit_parent;
	nd.intent.open.file = filp;
	nd.intent.open.flags = flag;
	nd.intent.open.create_mode = mode;
1703 1704
	dir = nd.path.dentry;
	nd.flags &= ~LOOKUP_PARENT;
A
Al Viro 已提交
1705
	nd.flags |= LOOKUP_CREATE | LOOKUP_OPEN;
1706 1707
	if (flag & O_EXCL)
		nd.flags |= LOOKUP_EXCL;
1708
	mutex_lock(&dir->d_inode->i_mutex);
1709 1710
	path.dentry = lookup_hash(&nd);
	path.mnt = nd.path.mnt;
L
Linus Torvalds 已提交
1711 1712

do_last:
A
Al Viro 已提交
1713 1714
	error = PTR_ERR(path.dentry);
	if (IS_ERR(path.dentry)) {
1715
		mutex_unlock(&dir->d_inode->i_mutex);
L
Linus Torvalds 已提交
1716 1717 1718
		goto exit;
	}

1719 1720
	if (IS_ERR(nd.intent.open.file)) {
		error = PTR_ERR(nd.intent.open.file);
1721
		goto exit_mutex_unlock;
1722 1723
	}

L
Linus Torvalds 已提交
1724
	/* Negative dentry, just create the file */
A
Al Viro 已提交
1725
	if (!path.dentry->d_inode) {
1726 1727 1728 1729 1730 1731 1732 1733
		/*
		 * This write is needed to ensure that a
		 * ro->rw transition does not occur between
		 * the time when the file is created and when
		 * a permanent write count is taken through
		 * the 'struct file' in nameidata_to_filp().
		 */
		error = mnt_want_write(nd.path.mnt);
L
Linus Torvalds 已提交
1734
		if (error)
1735 1736 1737 1738
			goto exit_mutex_unlock;
		error = __open_namei_create(&nd, &path, flag, mode);
		if (error) {
			mnt_drop_write(nd.path.mnt);
L
Linus Torvalds 已提交
1739
			goto exit;
1740 1741 1742 1743
		}
		filp = nameidata_to_filp(&nd, open_flag);
		mnt_drop_write(nd.path.mnt);
		return filp;
L
Linus Torvalds 已提交
1744 1745 1746 1747 1748
	}

	/*
	 * It already exists.
	 */
1749
	mutex_unlock(&dir->d_inode->i_mutex);
1750
	audit_inode(pathname, path.dentry);
L
Linus Torvalds 已提交
1751 1752 1753 1754 1755

	error = -EEXIST;
	if (flag & O_EXCL)
		goto exit_dput;

A
Al Viro 已提交
1756
	if (__follow_mount(&path)) {
L
Linus Torvalds 已提交
1757
		error = -ELOOP;
A
Al Viro 已提交
1758 1759
		if (flag & O_NOFOLLOW)
			goto exit_dput;
L
Linus Torvalds 已提交
1760
	}
1761

L
Linus Torvalds 已提交
1762
	error = -ENOENT;
A
Al Viro 已提交
1763
	if (!path.dentry->d_inode)
L
Linus Torvalds 已提交
1764
		goto exit_dput;
A
Al Viro 已提交
1765
	if (path.dentry->d_inode->i_op && path.dentry->d_inode->i_op->follow_link)
L
Linus Torvalds 已提交
1766 1767
		goto do_link;

1768
	path_to_nameidata(&path, &nd);
L
Linus Torvalds 已提交
1769
	error = -EISDIR;
A
Al Viro 已提交
1770
	if (path.dentry->d_inode && S_ISDIR(path.dentry->d_inode->i_mode))
L
Linus Torvalds 已提交
1771 1772
		goto exit;
ok:
1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788
	/*
	 * Consider:
	 * 1. may_open() truncates a file
	 * 2. a rw->ro mount transition occurs
	 * 3. nameidata_to_filp() fails due to
	 *    the ro mount.
	 * That would be inconsistent, and should
	 * be avoided. Taking this mnt write here
	 * ensures that (2) can not occur.
	 */
	will_write = open_will_write_to_fs(flag, nd.path.dentry->d_inode);
	if (will_write) {
		error = mnt_want_write(nd.path.mnt);
		if (error)
			goto exit;
	}
1789
	error = may_open(&nd, acc_mode, flag);
1790 1791 1792
	if (error) {
		if (will_write)
			mnt_drop_write(nd.path.mnt);
L
Linus Torvalds 已提交
1793
		goto exit;
1794 1795 1796 1797 1798 1799 1800 1801 1802 1803
	}
	filp = nameidata_to_filp(&nd, open_flag);
	/*
	 * It is now safe to drop the mnt write
	 * because the filp has had a write taken
	 * on its behalf.
	 */
	if (will_write)
		mnt_drop_write(nd.path.mnt);
	return filp;
L
Linus Torvalds 已提交
1804

1805 1806
exit_mutex_unlock:
	mutex_unlock(&dir->d_inode->i_mutex);
L
Linus Torvalds 已提交
1807
exit_dput:
1808
	path_put_conditional(&path, &nd);
L
Linus Torvalds 已提交
1809
exit:
1810 1811
	if (!IS_ERR(nd.intent.open.file))
		release_open_intent(&nd);
A
Al Viro 已提交
1812
exit_parent:
1813 1814
	path_put(&nd.path);
	return ERR_PTR(error);
L
Linus Torvalds 已提交
1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829

do_link:
	error = -ELOOP;
	if (flag & O_NOFOLLOW)
		goto exit_dput;
	/*
	 * This is subtle. Instead of calling do_follow_link() we do the
	 * thing by hands. The reason is that this way we have zero link_count
	 * and path_walk() (called from ->follow_link) honoring LOOKUP_PARENT.
	 * After that we have the parent and last component, i.e.
	 * we are in the same situation as after the first path_walk().
	 * Well, almost - if the last component is normal we get its copy
	 * stored in nd->last.name and we will have to putname() it when we
	 * are done. Procfs-like symlinks just set LAST_BIND.
	 */
1830 1831
	nd.flags |= LOOKUP_PARENT;
	error = security_inode_follow_link(path.dentry, &nd);
L
Linus Torvalds 已提交
1832 1833
	if (error)
		goto exit_dput;
1834
	error = __do_follow_link(&path, &nd);
K
Kirill Korotaev 已提交
1835 1836 1837 1838 1839
	if (error) {
		/* Does someone understand code flow here? Or it is only
		 * me so stupid? Anathema to whoever designed this non-sense
		 * with "intent.open".
		 */
1840 1841
		release_open_intent(&nd);
		return ERR_PTR(error);
K
Kirill Korotaev 已提交
1842
	}
1843 1844
	nd.flags &= ~LOOKUP_PARENT;
	if (nd.last_type == LAST_BIND)
L
Linus Torvalds 已提交
1845 1846
		goto ok;
	error = -EISDIR;
1847
	if (nd.last_type != LAST_NORM)
L
Linus Torvalds 已提交
1848
		goto exit;
1849 1850
	if (nd.last.name[nd.last.len]) {
		__putname(nd.last.name);
L
Linus Torvalds 已提交
1851 1852 1853 1854
		goto exit;
	}
	error = -ELOOP;
	if (count++==32) {
1855
		__putname(nd.last.name);
L
Linus Torvalds 已提交
1856 1857
		goto exit;
	}
1858
	dir = nd.path.dentry;
1859
	mutex_lock(&dir->d_inode->i_mutex);
1860 1861 1862
	path.dentry = lookup_hash(&nd);
	path.mnt = nd.path.mnt;
	__putname(nd.last.name);
L
Linus Torvalds 已提交
1863 1864 1865
	goto do_last;
}

1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882
/**
 * filp_open - open file and return file pointer
 *
 * @filename:	path to open
 * @flags:	open flags as per the open(2) second argument
 * @mode:	mode for the new file if O_CREAT is set, else ignored
 *
 * This is the helper to open a file from kernelspace if you really
 * have to.  But in generally you should not do this, so please move
 * along, nothing to see here..
 */
struct file *filp_open(const char *filename, int flags, int mode)
{
	return do_filp_open(AT_FDCWD, filename, flags, mode);
}
EXPORT_SYMBOL(filp_open);

L
Linus Torvalds 已提交
1883 1884 1885 1886 1887 1888 1889
/**
 * lookup_create - lookup a dentry, creating it if it doesn't exist
 * @nd: nameidata info
 * @is_dir: directory flag
 *
 * Simple function to lookup and return a dentry and create it
 * if it doesn't exist.  Is SMP-safe.
1890
 *
1891
 * Returns with nd->path.dentry->d_inode->i_mutex locked.
L
Linus Torvalds 已提交
1892 1893 1894
 */
struct dentry *lookup_create(struct nameidata *nd, int is_dir)
{
1895
	struct dentry *dentry = ERR_PTR(-EEXIST);
L
Linus Torvalds 已提交
1896

1897
	mutex_lock_nested(&nd->path.dentry->d_inode->i_mutex, I_MUTEX_PARENT);
1898 1899 1900 1901
	/*
	 * Yucky last component or no last component at all?
	 * (foo/., foo/.., /////)
	 */
L
Linus Torvalds 已提交
1902 1903 1904
	if (nd->last_type != LAST_NORM)
		goto fail;
	nd->flags &= ~LOOKUP_PARENT;
1905
	nd->flags |= LOOKUP_CREATE | LOOKUP_EXCL;
1906
	nd->intent.open.flags = O_EXCL;
1907 1908 1909 1910

	/*
	 * Do the final lookup.
	 */
1911
	dentry = lookup_hash(nd);
L
Linus Torvalds 已提交
1912 1913
	if (IS_ERR(dentry))
		goto fail;
1914

1915 1916
	if (dentry->d_inode)
		goto eexist;
1917 1918 1919 1920 1921 1922
	/*
	 * Special case - lookup gave negative, but... we had foo/bar/
	 * From the vfs_mknod() POV we just have a negative dentry -
	 * all is fine. Let's be bastards - you had / on the end, you've
	 * been asking for (non-existent) directory. -ENOENT for you.
	 */
1923 1924 1925 1926
	if (unlikely(!is_dir && nd->last.name[nd->last.len])) {
		dput(dentry);
		dentry = ERR_PTR(-ENOENT);
	}
L
Linus Torvalds 已提交
1927
	return dentry;
1928
eexist:
L
Linus Torvalds 已提交
1929
	dput(dentry);
1930
	dentry = ERR_PTR(-EEXIST);
L
Linus Torvalds 已提交
1931 1932 1933
fail:
	return dentry;
}
1934
EXPORT_SYMBOL_GPL(lookup_create);
L
Linus Torvalds 已提交
1935 1936 1937

int vfs_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t dev)
{
1938
	int error = may_create(dir, dentry);
L
Linus Torvalds 已提交
1939 1940 1941 1942 1943 1944 1945 1946 1947 1948

	if (error)
		return error;

	if ((S_ISCHR(mode) || S_ISBLK(mode)) && !capable(CAP_MKNOD))
		return -EPERM;

	if (!dir->i_op || !dir->i_op->mknod)
		return -EPERM;

1949 1950 1951 1952
	error = devcgroup_inode_mknod(mode, dev);
	if (error)
		return error;

L
Linus Torvalds 已提交
1953 1954 1955 1956 1957 1958
	error = security_inode_mknod(dir, dentry, mode, dev);
	if (error)
		return error;

	DQUOT_INIT(dir);
	error = dir->i_op->mknod(dir, dentry, mode, dev);
1959
	if (!error)
1960
		fsnotify_create(dir, dentry);
L
Linus Torvalds 已提交
1961 1962 1963
	return error;
}

1964 1965 1966 1967 1968 1969 1970 1971 1972 1973 1974 1975 1976 1977 1978 1979 1980
static int may_mknod(mode_t mode)
{
	switch (mode & S_IFMT) {
	case S_IFREG:
	case S_IFCHR:
	case S_IFBLK:
	case S_IFIFO:
	case S_IFSOCK:
	case 0: /* zero mode translates to S_IFREG */
		return 0;
	case S_IFDIR:
		return -EPERM;
	default:
		return -EINVAL;
	}
}

1981 1982
asmlinkage long sys_mknodat(int dfd, const char __user *filename, int mode,
				unsigned dev)
L
Linus Torvalds 已提交
1983
{
1984 1985 1986
	int error;
	char *tmp;
	struct dentry *dentry;
L
Linus Torvalds 已提交
1987 1988 1989 1990 1991
	struct nameidata nd;

	if (S_ISDIR(mode))
		return -EPERM;

1992
	error = user_path_parent(dfd, filename, &nd, &tmp);
L
Linus Torvalds 已提交
1993
	if (error)
1994 1995
		return error;

L
Linus Torvalds 已提交
1996
	dentry = lookup_create(&nd, 0);
1997 1998 1999 2000
	if (IS_ERR(dentry)) {
		error = PTR_ERR(dentry);
		goto out_unlock;
	}
2001
	if (!IS_POSIXACL(nd.path.dentry->d_inode))
L
Linus Torvalds 已提交
2002
		mode &= ~current->fs->umask;
2003 2004 2005 2006 2007 2008
	error = may_mknod(mode);
	if (error)
		goto out_dput;
	error = mnt_want_write(nd.path.mnt);
	if (error)
		goto out_dput;
2009 2010 2011
	error = security_path_mknod(&nd.path, dentry, mode, dev);
	if (error)
		goto out_drop_write;
2012
	switch (mode & S_IFMT) {
L
Linus Torvalds 已提交
2013
		case 0: case S_IFREG:
2014
			error = vfs_create(nd.path.dentry->d_inode,dentry,mode,&nd);
L
Linus Torvalds 已提交
2015 2016
			break;
		case S_IFCHR: case S_IFBLK:
2017
			error = vfs_mknod(nd.path.dentry->d_inode,dentry,mode,
L
Linus Torvalds 已提交
2018 2019 2020
					new_decode_dev(dev));
			break;
		case S_IFIFO: case S_IFSOCK:
2021
			error = vfs_mknod(nd.path.dentry->d_inode,dentry,mode,0);
L
Linus Torvalds 已提交
2022 2023
			break;
	}
2024
out_drop_write:
2025 2026 2027 2028
	mnt_drop_write(nd.path.mnt);
out_dput:
	dput(dentry);
out_unlock:
2029
	mutex_unlock(&nd.path.dentry->d_inode->i_mutex);
J
Jan Blunck 已提交
2030
	path_put(&nd.path);
L
Linus Torvalds 已提交
2031 2032 2033 2034 2035
	putname(tmp);

	return error;
}

2036 2037 2038 2039 2040
asmlinkage long sys_mknod(const char __user *filename, int mode, unsigned dev)
{
	return sys_mknodat(AT_FDCWD, filename, mode, dev);
}

L
Linus Torvalds 已提交
2041 2042
int vfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
{
2043
	int error = may_create(dir, dentry);
L
Linus Torvalds 已提交
2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057

	if (error)
		return error;

	if (!dir->i_op || !dir->i_op->mkdir)
		return -EPERM;

	mode &= (S_IRWXUGO|S_ISVTX);
	error = security_inode_mkdir(dir, dentry, mode);
	if (error)
		return error;

	DQUOT_INIT(dir);
	error = dir->i_op->mkdir(dir, dentry, mode);
2058
	if (!error)
2059
		fsnotify_mkdir(dir, dentry);
L
Linus Torvalds 已提交
2060 2061 2062
	return error;
}

2063
asmlinkage long sys_mkdirat(int dfd, const char __user *pathname, int mode)
L
Linus Torvalds 已提交
2064 2065 2066
{
	int error = 0;
	char * tmp;
2067 2068
	struct dentry *dentry;
	struct nameidata nd;
L
Linus Torvalds 已提交
2069

2070 2071
	error = user_path_parent(dfd, pathname, &nd, &tmp);
	if (error)
2072
		goto out_err;
L
Linus Torvalds 已提交
2073

2074 2075 2076 2077
	dentry = lookup_create(&nd, 1);
	error = PTR_ERR(dentry);
	if (IS_ERR(dentry))
		goto out_unlock;
L
Linus Torvalds 已提交
2078

2079
	if (!IS_POSIXACL(nd.path.dentry->d_inode))
2080
		mode &= ~current->fs->umask;
2081 2082 2083
	error = mnt_want_write(nd.path.mnt);
	if (error)
		goto out_dput;
2084 2085 2086
	error = security_path_mkdir(&nd.path, dentry, mode);
	if (error)
		goto out_drop_write;
2087
	error = vfs_mkdir(nd.path.dentry->d_inode, dentry, mode);
2088
out_drop_write:
2089 2090
	mnt_drop_write(nd.path.mnt);
out_dput:
2091 2092
	dput(dentry);
out_unlock:
2093
	mutex_unlock(&nd.path.dentry->d_inode->i_mutex);
J
Jan Blunck 已提交
2094
	path_put(&nd.path);
2095 2096
	putname(tmp);
out_err:
L
Linus Torvalds 已提交
2097 2098 2099
	return error;
}

2100 2101 2102 2103 2104
asmlinkage long sys_mkdir(const char __user *pathname, int mode)
{
	return sys_mkdirat(AT_FDCWD, pathname, mode);
}

L
Linus Torvalds 已提交
2105 2106 2107 2108 2109 2110 2111 2112 2113 2114 2115 2116 2117 2118 2119 2120 2121 2122
/*
 * We try to drop the dentry early: we should have
 * a usage count of 2 if we're the only user of this
 * dentry, and if that is true (possibly after pruning
 * the dcache), then we drop the dentry now.
 *
 * A low-level filesystem can, if it choses, legally
 * do a
 *
 *	if (!d_unhashed(dentry))
 *		return -EBUSY;
 *
 * if it cannot handle the case of removing a directory
 * that is still in use by something else..
 */
void dentry_unhash(struct dentry *dentry)
{
	dget(dentry);
2123
	shrink_dcache_parent(dentry);
L
Linus Torvalds 已提交
2124 2125 2126 2127 2128 2129 2130 2131 2132 2133 2134 2135 2136 2137 2138 2139 2140 2141 2142 2143
	spin_lock(&dcache_lock);
	spin_lock(&dentry->d_lock);
	if (atomic_read(&dentry->d_count) == 2)
		__d_drop(dentry);
	spin_unlock(&dentry->d_lock);
	spin_unlock(&dcache_lock);
}

int vfs_rmdir(struct inode *dir, struct dentry *dentry)
{
	int error = may_delete(dir, dentry, 1);

	if (error)
		return error;

	if (!dir->i_op || !dir->i_op->rmdir)
		return -EPERM;

	DQUOT_INIT(dir);

2144
	mutex_lock(&dentry->d_inode->i_mutex);
L
Linus Torvalds 已提交
2145 2146 2147 2148 2149 2150 2151 2152 2153 2154 2155
	dentry_unhash(dentry);
	if (d_mountpoint(dentry))
		error = -EBUSY;
	else {
		error = security_inode_rmdir(dir, dentry);
		if (!error) {
			error = dir->i_op->rmdir(dir, dentry);
			if (!error)
				dentry->d_inode->i_flags |= S_DEAD;
		}
	}
2156
	mutex_unlock(&dentry->d_inode->i_mutex);
L
Linus Torvalds 已提交
2157 2158 2159 2160 2161 2162 2163 2164
	if (!error) {
		d_delete(dentry);
	}
	dput(dentry);

	return error;
}

2165
static long do_rmdir(int dfd, const char __user *pathname)
L
Linus Torvalds 已提交
2166 2167 2168 2169 2170 2171
{
	int error = 0;
	char * name;
	struct dentry *dentry;
	struct nameidata nd;

2172
	error = user_path_parent(dfd, pathname, &nd, &name);
L
Linus Torvalds 已提交
2173
	if (error)
2174
		return error;
L
Linus Torvalds 已提交
2175 2176

	switch(nd.last_type) {
2177 2178 2179 2180 2181 2182 2183 2184 2185
	case LAST_DOTDOT:
		error = -ENOTEMPTY;
		goto exit1;
	case LAST_DOT:
		error = -EINVAL;
		goto exit1;
	case LAST_ROOT:
		error = -EBUSY;
		goto exit1;
L
Linus Torvalds 已提交
2186
	}
2187 2188 2189

	nd.flags &= ~LOOKUP_PARENT;

2190
	mutex_lock_nested(&nd.path.dentry->d_inode->i_mutex, I_MUTEX_PARENT);
2191
	dentry = lookup_hash(&nd);
L
Linus Torvalds 已提交
2192
	error = PTR_ERR(dentry);
2193 2194
	if (IS_ERR(dentry))
		goto exit2;
2195 2196 2197
	error = mnt_want_write(nd.path.mnt);
	if (error)
		goto exit3;
2198 2199 2200
	error = security_path_rmdir(&nd.path, dentry);
	if (error)
		goto exit4;
2201
	error = vfs_rmdir(nd.path.dentry->d_inode, dentry);
2202
exit4:
2203 2204
	mnt_drop_write(nd.path.mnt);
exit3:
2205 2206
	dput(dentry);
exit2:
2207
	mutex_unlock(&nd.path.dentry->d_inode->i_mutex);
L
Linus Torvalds 已提交
2208
exit1:
J
Jan Blunck 已提交
2209
	path_put(&nd.path);
L
Linus Torvalds 已提交
2210 2211 2212 2213
	putname(name);
	return error;
}

2214 2215 2216 2217 2218
asmlinkage long sys_rmdir(const char __user *pathname)
{
	return do_rmdir(AT_FDCWD, pathname);
}

L
Linus Torvalds 已提交
2219 2220 2221 2222 2223 2224 2225 2226 2227 2228 2229 2230
int vfs_unlink(struct inode *dir, struct dentry *dentry)
{
	int error = may_delete(dir, dentry, 0);

	if (error)
		return error;

	if (!dir->i_op || !dir->i_op->unlink)
		return -EPERM;

	DQUOT_INIT(dir);

2231
	mutex_lock(&dentry->d_inode->i_mutex);
L
Linus Torvalds 已提交
2232 2233 2234 2235 2236 2237 2238
	if (d_mountpoint(dentry))
		error = -EBUSY;
	else {
		error = security_inode_unlink(dir, dentry);
		if (!error)
			error = dir->i_op->unlink(dir, dentry);
	}
2239
	mutex_unlock(&dentry->d_inode->i_mutex);
L
Linus Torvalds 已提交
2240 2241 2242

	/* We don't d_delete() NFS sillyrenamed files--they still exist. */
	if (!error && !(dentry->d_flags & DCACHE_NFSFS_RENAMED)) {
2243
		fsnotify_link_count(dentry->d_inode);
J
John McCutchan 已提交
2244
		d_delete(dentry);
L
Linus Torvalds 已提交
2245
	}
R
Robert Love 已提交
2246

L
Linus Torvalds 已提交
2247 2248 2249 2250 2251
	return error;
}

/*
 * Make sure that the actual truncation of the file will occur outside its
2252
 * directory's i_mutex.  Truncate can take a long time if there is a lot of
L
Linus Torvalds 已提交
2253 2254 2255
 * writeout happening, and we don't want to prevent access to the directory
 * while waiting on the I/O.
 */
2256
static long do_unlinkat(int dfd, const char __user *pathname)
L
Linus Torvalds 已提交
2257
{
2258 2259
	int error;
	char *name;
L
Linus Torvalds 已提交
2260 2261 2262 2263
	struct dentry *dentry;
	struct nameidata nd;
	struct inode *inode = NULL;

2264
	error = user_path_parent(dfd, pathname, &nd, &name);
L
Linus Torvalds 已提交
2265
	if (error)
2266 2267
		return error;

L
Linus Torvalds 已提交
2268 2269 2270
	error = -EISDIR;
	if (nd.last_type != LAST_NORM)
		goto exit1;
2271 2272 2273

	nd.flags &= ~LOOKUP_PARENT;

2274
	mutex_lock_nested(&nd.path.dentry->d_inode->i_mutex, I_MUTEX_PARENT);
2275
	dentry = lookup_hash(&nd);
L
Linus Torvalds 已提交
2276 2277 2278 2279 2280 2281 2282 2283
	error = PTR_ERR(dentry);
	if (!IS_ERR(dentry)) {
		/* Why not before? Because we want correct error value */
		if (nd.last.name[nd.last.len])
			goto slashes;
		inode = dentry->d_inode;
		if (inode)
			atomic_inc(&inode->i_count);
2284 2285 2286
		error = mnt_want_write(nd.path.mnt);
		if (error)
			goto exit2;
2287 2288 2289
		error = security_path_unlink(&nd.path, dentry);
		if (error)
			goto exit3;
2290
		error = vfs_unlink(nd.path.dentry->d_inode, dentry);
2291
exit3:
2292
		mnt_drop_write(nd.path.mnt);
L
Linus Torvalds 已提交
2293 2294 2295
	exit2:
		dput(dentry);
	}
2296
	mutex_unlock(&nd.path.dentry->d_inode->i_mutex);
L
Linus Torvalds 已提交
2297 2298 2299
	if (inode)
		iput(inode);	/* truncate the inode here */
exit1:
J
Jan Blunck 已提交
2300
	path_put(&nd.path);
L
Linus Torvalds 已提交
2301 2302 2303 2304 2305 2306 2307 2308 2309
	putname(name);
	return error;

slashes:
	error = !dentry->d_inode ? -ENOENT :
		S_ISDIR(dentry->d_inode->i_mode) ? -EISDIR : -ENOTDIR;
	goto exit2;
}

2310 2311 2312 2313 2314 2315 2316 2317 2318 2319 2320 2321 2322 2323 2324 2325
asmlinkage long sys_unlinkat(int dfd, const char __user *pathname, int flag)
{
	if ((flag & ~AT_REMOVEDIR) != 0)
		return -EINVAL;

	if (flag & AT_REMOVEDIR)
		return do_rmdir(dfd, pathname);

	return do_unlinkat(dfd, pathname);
}

asmlinkage long sys_unlink(const char __user *pathname)
{
	return do_unlinkat(AT_FDCWD, pathname);
}

2326
int vfs_symlink(struct inode *dir, struct dentry *dentry, const char *oldname)
L
Linus Torvalds 已提交
2327
{
2328
	int error = may_create(dir, dentry);
L
Linus Torvalds 已提交
2329 2330 2331 2332 2333 2334 2335 2336 2337 2338 2339 2340 2341

	if (error)
		return error;

	if (!dir->i_op || !dir->i_op->symlink)
		return -EPERM;

	error = security_inode_symlink(dir, dentry, oldname);
	if (error)
		return error;

	DQUOT_INIT(dir);
	error = dir->i_op->symlink(dir, dentry, oldname);
2342
	if (!error)
2343
		fsnotify_create(dir, dentry);
L
Linus Torvalds 已提交
2344 2345 2346
	return error;
}

2347 2348
asmlinkage long sys_symlinkat(const char __user *oldname,
			      int newdfd, const char __user *newname)
L
Linus Torvalds 已提交
2349
{
2350 2351 2352
	int error;
	char *from;
	char *to;
2353 2354
	struct dentry *dentry;
	struct nameidata nd;
L
Linus Torvalds 已提交
2355 2356

	from = getname(oldname);
2357
	if (IS_ERR(from))
L
Linus Torvalds 已提交
2358 2359
		return PTR_ERR(from);

2360
	error = user_path_parent(newdfd, newname, &nd, &to);
2361
	if (error)
2362 2363
		goto out_putname;

2364 2365 2366 2367 2368
	dentry = lookup_create(&nd, 0);
	error = PTR_ERR(dentry);
	if (IS_ERR(dentry))
		goto out_unlock;

2369 2370 2371
	error = mnt_want_write(nd.path.mnt);
	if (error)
		goto out_dput;
2372 2373 2374
	error = security_path_symlink(&nd.path, dentry, from);
	if (error)
		goto out_drop_write;
2375
	error = vfs_symlink(nd.path.dentry->d_inode, dentry, from);
2376
out_drop_write:
2377 2378
	mnt_drop_write(nd.path.mnt);
out_dput:
2379 2380
	dput(dentry);
out_unlock:
2381
	mutex_unlock(&nd.path.dentry->d_inode->i_mutex);
J
Jan Blunck 已提交
2382
	path_put(&nd.path);
2383 2384
	putname(to);
out_putname:
L
Linus Torvalds 已提交
2385 2386 2387 2388
	putname(from);
	return error;
}

2389 2390 2391 2392 2393
asmlinkage long sys_symlink(const char __user *oldname, const char __user *newname)
{
	return sys_symlinkat(oldname, AT_FDCWD, newname);
}

L
Linus Torvalds 已提交
2394 2395 2396 2397 2398 2399 2400 2401
int vfs_link(struct dentry *old_dentry, struct inode *dir, struct dentry *new_dentry)
{
	struct inode *inode = old_dentry->d_inode;
	int error;

	if (!inode)
		return -ENOENT;

2402
	error = may_create(dir, new_dentry);
L
Linus Torvalds 已提交
2403 2404 2405 2406 2407 2408 2409 2410 2411 2412 2413 2414 2415
	if (error)
		return error;

	if (dir->i_sb != inode->i_sb)
		return -EXDEV;

	/*
	 * A link to an append-only or immutable file cannot be created.
	 */
	if (IS_APPEND(inode) || IS_IMMUTABLE(inode))
		return -EPERM;
	if (!dir->i_op || !dir->i_op->link)
		return -EPERM;
2416
	if (S_ISDIR(inode->i_mode))
L
Linus Torvalds 已提交
2417 2418 2419 2420 2421 2422
		return -EPERM;

	error = security_inode_link(old_dentry, dir, new_dentry);
	if (error)
		return error;

2423
	mutex_lock(&inode->i_mutex);
L
Linus Torvalds 已提交
2424 2425
	DQUOT_INIT(dir);
	error = dir->i_op->link(old_dentry, dir, new_dentry);
2426
	mutex_unlock(&inode->i_mutex);
2427
	if (!error)
2428
		fsnotify_link(dir, inode, new_dentry);
L
Linus Torvalds 已提交
2429 2430 2431 2432 2433 2434 2435 2436 2437 2438 2439 2440
	return error;
}

/*
 * Hardlinks are often used in delicate situations.  We avoid
 * security-related surprises by not following symlinks on the
 * newname.  --KAB
 *
 * We don't follow them on the oldname either to be compatible
 * with linux 2.0, and to avoid hard-linking to directories
 * and other special files.  --ADM
 */
2441
asmlinkage long sys_linkat(int olddfd, const char __user *oldname,
2442 2443
			   int newdfd, const char __user *newname,
			   int flags)
L
Linus Torvalds 已提交
2444 2445
{
	struct dentry *new_dentry;
2446 2447
	struct nameidata nd;
	struct path old_path;
L
Linus Torvalds 已提交
2448
	int error;
2449
	char *to;
L
Linus Torvalds 已提交
2450

2451
	if ((flags & ~AT_SYMLINK_FOLLOW) != 0)
2452 2453
		return -EINVAL;

2454 2455 2456
	error = user_path_at(olddfd, oldname,
			     flags & AT_SYMLINK_FOLLOW ? LOOKUP_FOLLOW : 0,
			     &old_path);
L
Linus Torvalds 已提交
2457
	if (error)
2458 2459 2460
		return error;

	error = user_path_parent(newdfd, newname, &nd, &to);
L
Linus Torvalds 已提交
2461 2462 2463
	if (error)
		goto out;
	error = -EXDEV;
2464
	if (old_path.mnt != nd.path.mnt)
L
Linus Torvalds 已提交
2465 2466 2467
		goto out_release;
	new_dentry = lookup_create(&nd, 0);
	error = PTR_ERR(new_dentry);
2468 2469
	if (IS_ERR(new_dentry))
		goto out_unlock;
2470 2471 2472
	error = mnt_want_write(nd.path.mnt);
	if (error)
		goto out_dput;
2473 2474 2475
	error = security_path_link(old_path.dentry, &nd.path, new_dentry);
	if (error)
		goto out_drop_write;
2476
	error = vfs_link(old_path.dentry, nd.path.dentry->d_inode, new_dentry);
2477
out_drop_write:
2478 2479
	mnt_drop_write(nd.path.mnt);
out_dput:
2480 2481
	dput(new_dentry);
out_unlock:
2482
	mutex_unlock(&nd.path.dentry->d_inode->i_mutex);
L
Linus Torvalds 已提交
2483
out_release:
J
Jan Blunck 已提交
2484
	path_put(&nd.path);
2485
	putname(to);
L
Linus Torvalds 已提交
2486
out:
2487
	path_put(&old_path);
L
Linus Torvalds 已提交
2488 2489 2490 2491

	return error;
}

2492 2493
asmlinkage long sys_link(const char __user *oldname, const char __user *newname)
{
2494
	return sys_linkat(AT_FDCWD, oldname, AT_FDCWD, newname, 0);
2495 2496
}

L
Linus Torvalds 已提交
2497 2498 2499 2500 2501 2502 2503
/*
 * The worst of all namespace operations - renaming directory. "Perverted"
 * doesn't even start to describe it. Somebody in UCB had a heck of a trip...
 * Problems:
 *	a) we can get into loop creation. Check is done in is_subdir().
 *	b) race potential - two innocent renames can create a loop together.
 *	   That's where 4.4 screws up. Current fix: serialization on
2504
 *	   sb->s_vfs_rename_mutex. We might be more accurate, but that's another
L
Linus Torvalds 已提交
2505 2506
 *	   story.
 *	c) we have to lock _three_ objects - parents and victim (if it exists).
2507
 *	   And that - after we got ->i_mutex on parents (until then we don't know
L
Linus Torvalds 已提交
2508 2509
 *	   whether the target exists).  Solution: try to be smart with locking
 *	   order for inodes.  We rely on the fact that tree topology may change
2510
 *	   only under ->s_vfs_rename_mutex _and_ that parent of the object we
L
Linus Torvalds 已提交
2511 2512 2513
 *	   move will be locked.  Thus we can rank directories by the tree
 *	   (ancestors first) and rank all non-directories after them.
 *	   That works since everybody except rename does "lock parent, lookup,
2514
 *	   lock child" and rename is under ->s_vfs_rename_mutex.
L
Linus Torvalds 已提交
2515 2516 2517 2518 2519 2520 2521 2522 2523
 *	   HOWEVER, it relies on the assumption that any object with ->lookup()
 *	   has no more than 1 dentry.  If "hybrid" objects will ever appear,
 *	   we'd better make sure that there's no link(2) for them.
 *	d) some filesystems don't support opened-but-unlinked directories,
 *	   either because of layout or because they are not ready to deal with
 *	   all cases correctly. The latter will be fixed (taking this sort of
 *	   stuff into VFS), but the former is not going away. Solution: the same
 *	   trick as in rmdir().
 *	e) conversion from fhandle to dentry may come in the wrong moment - when
2524
 *	   we are removing the target. Solution: we will have to grab ->i_mutex
L
Linus Torvalds 已提交
2525
 *	   in the fhandle_to_dentry code. [FIXME - current nfsfh.c relies on
2526
 *	   ->i_mutex on parents, which works but leads to some truely excessive
L
Linus Torvalds 已提交
2527 2528
 *	   locking].
 */
A
Adrian Bunk 已提交
2529 2530
static int vfs_rename_dir(struct inode *old_dir, struct dentry *old_dentry,
			  struct inode *new_dir, struct dentry *new_dentry)
L
Linus Torvalds 已提交
2531 2532 2533 2534 2535 2536 2537 2538 2539
{
	int error = 0;
	struct inode *target;

	/*
	 * If we are going to change the parent - check write permissions,
	 * we'll need to flip '..'.
	 */
	if (new_dir != old_dir) {
2540
		error = inode_permission(old_dentry->d_inode, MAY_WRITE);
L
Linus Torvalds 已提交
2541 2542 2543 2544 2545 2546 2547 2548 2549 2550
		if (error)
			return error;
	}

	error = security_inode_rename(old_dir, old_dentry, new_dir, new_dentry);
	if (error)
		return error;

	target = new_dentry->d_inode;
	if (target) {
2551
		mutex_lock(&target->i_mutex);
L
Linus Torvalds 已提交
2552 2553 2554 2555 2556 2557 2558 2559 2560
		dentry_unhash(new_dentry);
	}
	if (d_mountpoint(old_dentry)||d_mountpoint(new_dentry))
		error = -EBUSY;
	else 
		error = old_dir->i_op->rename(old_dir, old_dentry, new_dir, new_dentry);
	if (target) {
		if (!error)
			target->i_flags |= S_DEAD;
2561
		mutex_unlock(&target->i_mutex);
L
Linus Torvalds 已提交
2562 2563 2564 2565
		if (d_unhashed(new_dentry))
			d_rehash(new_dentry);
		dput(new_dentry);
	}
2566
	if (!error)
2567 2568
		if (!(old_dir->i_sb->s_type->fs_flags & FS_RENAME_DOES_D_MOVE))
			d_move(old_dentry,new_dentry);
L
Linus Torvalds 已提交
2569 2570 2571
	return error;
}

A
Adrian Bunk 已提交
2572 2573
static int vfs_rename_other(struct inode *old_dir, struct dentry *old_dentry,
			    struct inode *new_dir, struct dentry *new_dentry)
L
Linus Torvalds 已提交
2574 2575 2576 2577 2578 2579 2580 2581 2582 2583 2584
{
	struct inode *target;
	int error;

	error = security_inode_rename(old_dir, old_dentry, new_dir, new_dentry);
	if (error)
		return error;

	dget(new_dentry);
	target = new_dentry->d_inode;
	if (target)
2585
		mutex_lock(&target->i_mutex);
L
Linus Torvalds 已提交
2586 2587 2588 2589 2590
	if (d_mountpoint(old_dentry)||d_mountpoint(new_dentry))
		error = -EBUSY;
	else
		error = old_dir->i_op->rename(old_dir, old_dentry, new_dir, new_dentry);
	if (!error) {
2591
		if (!(old_dir->i_sb->s_type->fs_flags & FS_RENAME_DOES_D_MOVE))
L
Linus Torvalds 已提交
2592 2593 2594
			d_move(old_dentry, new_dentry);
	}
	if (target)
2595
		mutex_unlock(&target->i_mutex);
L
Linus Torvalds 已提交
2596 2597 2598 2599 2600 2601 2602 2603 2604
	dput(new_dentry);
	return error;
}

int vfs_rename(struct inode *old_dir, struct dentry *old_dentry,
	       struct inode *new_dir, struct dentry *new_dentry)
{
	int error;
	int is_dir = S_ISDIR(old_dentry->d_inode->i_mode);
R
Robert Love 已提交
2605
	const char *old_name;
L
Linus Torvalds 已提交
2606 2607 2608 2609 2610 2611 2612 2613 2614

	if (old_dentry->d_inode == new_dentry->d_inode)
 		return 0;
 
	error = may_delete(old_dir, old_dentry, is_dir);
	if (error)
		return error;

	if (!new_dentry->d_inode)
2615
		error = may_create(new_dir, new_dentry);
L
Linus Torvalds 已提交
2616 2617 2618 2619 2620 2621 2622 2623 2624 2625 2626
	else
		error = may_delete(new_dir, new_dentry, is_dir);
	if (error)
		return error;

	if (!old_dir->i_op || !old_dir->i_op->rename)
		return -EPERM;

	DQUOT_INIT(old_dir);
	DQUOT_INIT(new_dir);

R
Robert Love 已提交
2627 2628
	old_name = fsnotify_oldname_init(old_dentry->d_name.name);

L
Linus Torvalds 已提交
2629 2630 2631 2632 2633
	if (is_dir)
		error = vfs_rename_dir(old_dir,old_dentry,new_dir,new_dentry);
	else
		error = vfs_rename_other(old_dir,old_dentry,new_dir,new_dentry);
	if (!error) {
R
Robert Love 已提交
2634
		const char *new_name = old_dentry->d_name.name;
2635
		fsnotify_move(old_dir, new_dir, old_name, new_name, is_dir,
2636
			      new_dentry->d_inode, old_dentry);
L
Linus Torvalds 已提交
2637
	}
R
Robert Love 已提交
2638 2639
	fsnotify_oldname_free(old_name);

L
Linus Torvalds 已提交
2640 2641 2642
	return error;
}

2643 2644
asmlinkage long sys_renameat(int olddfd, const char __user *oldname,
			     int newdfd, const char __user *newname)
L
Linus Torvalds 已提交
2645
{
2646 2647 2648
	struct dentry *old_dir, *new_dir;
	struct dentry *old_dentry, *new_dentry;
	struct dentry *trap;
L
Linus Torvalds 已提交
2649
	struct nameidata oldnd, newnd;
2650 2651 2652
	char *from;
	char *to;
	int error;
L
Linus Torvalds 已提交
2653

2654
	error = user_path_parent(olddfd, oldname, &oldnd, &from);
L
Linus Torvalds 已提交
2655 2656 2657
	if (error)
		goto exit;

2658
	error = user_path_parent(newdfd, newname, &newnd, &to);
L
Linus Torvalds 已提交
2659 2660 2661 2662
	if (error)
		goto exit1;

	error = -EXDEV;
2663
	if (oldnd.path.mnt != newnd.path.mnt)
L
Linus Torvalds 已提交
2664 2665
		goto exit2;

2666
	old_dir = oldnd.path.dentry;
L
Linus Torvalds 已提交
2667 2668 2669 2670
	error = -EBUSY;
	if (oldnd.last_type != LAST_NORM)
		goto exit2;

2671
	new_dir = newnd.path.dentry;
L
Linus Torvalds 已提交
2672 2673 2674
	if (newnd.last_type != LAST_NORM)
		goto exit2;

2675 2676
	oldnd.flags &= ~LOOKUP_PARENT;
	newnd.flags &= ~LOOKUP_PARENT;
2677
	newnd.flags |= LOOKUP_RENAME_TARGET;
2678

L
Linus Torvalds 已提交
2679 2680
	trap = lock_rename(new_dir, old_dir);

2681
	old_dentry = lookup_hash(&oldnd);
L
Linus Torvalds 已提交
2682 2683 2684 2685 2686 2687 2688 2689 2690 2691 2692 2693 2694 2695 2696 2697 2698 2699 2700
	error = PTR_ERR(old_dentry);
	if (IS_ERR(old_dentry))
		goto exit3;
	/* source must exist */
	error = -ENOENT;
	if (!old_dentry->d_inode)
		goto exit4;
	/* unless the source is a directory trailing slashes give -ENOTDIR */
	if (!S_ISDIR(old_dentry->d_inode->i_mode)) {
		error = -ENOTDIR;
		if (oldnd.last.name[oldnd.last.len])
			goto exit4;
		if (newnd.last.name[newnd.last.len])
			goto exit4;
	}
	/* source should not be ancestor of target */
	error = -EINVAL;
	if (old_dentry == trap)
		goto exit4;
2701
	new_dentry = lookup_hash(&newnd);
L
Linus Torvalds 已提交
2702 2703 2704 2705 2706 2707 2708 2709
	error = PTR_ERR(new_dentry);
	if (IS_ERR(new_dentry))
		goto exit4;
	/* target should not be an ancestor of source */
	error = -ENOTEMPTY;
	if (new_dentry == trap)
		goto exit5;

2710 2711 2712
	error = mnt_want_write(oldnd.path.mnt);
	if (error)
		goto exit5;
2713 2714 2715 2716
	error = security_path_rename(&oldnd.path, old_dentry,
				     &newnd.path, new_dentry);
	if (error)
		goto exit6;
L
Linus Torvalds 已提交
2717 2718
	error = vfs_rename(old_dir->d_inode, old_dentry,
				   new_dir->d_inode, new_dentry);
2719
exit6:
2720
	mnt_drop_write(oldnd.path.mnt);
L
Linus Torvalds 已提交
2721 2722 2723 2724 2725 2726 2727
exit5:
	dput(new_dentry);
exit4:
	dput(old_dentry);
exit3:
	unlock_rename(new_dir, old_dir);
exit2:
J
Jan Blunck 已提交
2728
	path_put(&newnd.path);
2729
	putname(to);
L
Linus Torvalds 已提交
2730
exit1:
J
Jan Blunck 已提交
2731
	path_put(&oldnd.path);
L
Linus Torvalds 已提交
2732
	putname(from);
2733
exit:
L
Linus Torvalds 已提交
2734 2735 2736
	return error;
}

2737 2738 2739 2740 2741
asmlinkage long sys_rename(const char __user *oldname, const char __user *newname)
{
	return sys_renameat(AT_FDCWD, oldname, AT_FDCWD, newname);
}

L
Linus Torvalds 已提交
2742 2743 2744 2745 2746 2747 2748 2749 2750 2751 2752 2753 2754 2755 2756 2757 2758 2759 2760 2761 2762 2763 2764 2765 2766
int vfs_readlink(struct dentry *dentry, char __user *buffer, int buflen, const char *link)
{
	int len;

	len = PTR_ERR(link);
	if (IS_ERR(link))
		goto out;

	len = strlen(link);
	if (len > (unsigned) buflen)
		len = buflen;
	if (copy_to_user(buffer, link, len))
		len = -EFAULT;
out:
	return len;
}

/*
 * A helper for ->readlink().  This should be used *ONLY* for symlinks that
 * have ->follow_link() touching nd only in nd_set_link().  Using (or not
 * using) it for any given inode is up to filesystem.
 */
int generic_readlink(struct dentry *dentry, char __user *buffer, int buflen)
{
	struct nameidata nd;
2767
	void *cookie;
2768
	int res;
2769

L
Linus Torvalds 已提交
2770
	nd.depth = 0;
2771
	cookie = dentry->d_inode->i_op->follow_link(dentry, &nd);
2772 2773 2774 2775 2776 2777 2778
	if (IS_ERR(cookie))
		return PTR_ERR(cookie);

	res = vfs_readlink(dentry, buffer, buflen, nd_get_link(&nd));
	if (dentry->d_inode->i_op->put_link)
		dentry->d_inode->i_op->put_link(dentry, &nd, cookie);
	return res;
L
Linus Torvalds 已提交
2779 2780 2781 2782 2783 2784 2785 2786 2787 2788 2789 2790
}

int vfs_follow_link(struct nameidata *nd, const char *link)
{
	return __vfs_follow_link(nd, link);
}

/* get the link contents into pagecache */
static char *page_getlink(struct dentry * dentry, struct page **ppage)
{
	struct page * page;
	struct address_space *mapping = dentry->d_inode->i_mapping;
2791
	page = read_mapping_page(mapping, 0, NULL);
L
Linus Torvalds 已提交
2792
	if (IS_ERR(page))
2793
		return (char*)page;
L
Linus Torvalds 已提交
2794 2795 2796 2797 2798 2799 2800 2801 2802 2803 2804 2805 2806 2807 2808 2809
	*ppage = page;
	return kmap(page);
}

int page_readlink(struct dentry *dentry, char __user *buffer, int buflen)
{
	struct page *page = NULL;
	char *s = page_getlink(dentry, &page);
	int res = vfs_readlink(dentry,buffer,buflen,s);
	if (page) {
		kunmap(page);
		page_cache_release(page);
	}
	return res;
}

2810
void *page_follow_link_light(struct dentry *dentry, struct nameidata *nd)
L
Linus Torvalds 已提交
2811
{
2812
	struct page *page = NULL;
L
Linus Torvalds 已提交
2813
	nd_set_link(nd, page_getlink(dentry, &page));
2814
	return page;
L
Linus Torvalds 已提交
2815 2816
}

2817
void page_put_link(struct dentry *dentry, struct nameidata *nd, void *cookie)
L
Linus Torvalds 已提交
2818
{
2819 2820 2821
	struct page *page = cookie;

	if (page) {
L
Linus Torvalds 已提交
2822 2823 2824 2825 2826
		kunmap(page);
		page_cache_release(page);
	}
}

2827 2828
int __page_symlink(struct inode *inode, const char *symname, int len,
		gfp_t gfp_mask)
L
Linus Torvalds 已提交
2829 2830
{
	struct address_space *mapping = inode->i_mapping;
2831
	struct page *page;
2832
	void *fsdata;
2833
	int err;
L
Linus Torvalds 已提交
2834 2835
	char *kaddr;

2836
retry:
2837 2838
	err = pagecache_write_begin(NULL, mapping, 0, len-1,
				AOP_FLAG_UNINTERRUPTIBLE, &page, &fsdata);
L
Linus Torvalds 已提交
2839
	if (err)
2840 2841
		goto fail;

L
Linus Torvalds 已提交
2842 2843 2844
	kaddr = kmap_atomic(page, KM_USER0);
	memcpy(kaddr, symname, len-1);
	kunmap_atomic(kaddr, KM_USER0);
2845 2846 2847

	err = pagecache_write_end(NULL, mapping, 0, len-1, len-1,
							page, fsdata);
L
Linus Torvalds 已提交
2848 2849
	if (err < 0)
		goto fail;
2850 2851 2852
	if (err < len-1)
		goto retry;

L
Linus Torvalds 已提交
2853 2854 2855 2856 2857 2858
	mark_inode_dirty(inode);
	return 0;
fail:
	return err;
}

2859 2860 2861 2862 2863 2864
int page_symlink(struct inode *inode, const char *symname, int len)
{
	return __page_symlink(inode, symname, len,
			mapping_gfp_mask(inode->i_mapping));
}

2865
const struct inode_operations page_symlink_inode_operations = {
L
Linus Torvalds 已提交
2866 2867 2868 2869 2870
	.readlink	= generic_readlink,
	.follow_link	= page_follow_link_light,
	.put_link	= page_put_link,
};

2871
EXPORT_SYMBOL(user_path_at);
L
Linus Torvalds 已提交
2872 2873 2874 2875 2876 2877 2878 2879 2880
EXPORT_SYMBOL(follow_down);
EXPORT_SYMBOL(follow_up);
EXPORT_SYMBOL(get_write_access); /* binfmt_aout */
EXPORT_SYMBOL(getname);
EXPORT_SYMBOL(lock_rename);
EXPORT_SYMBOL(lookup_one_len);
EXPORT_SYMBOL(page_follow_link_light);
EXPORT_SYMBOL(page_put_link);
EXPORT_SYMBOL(page_readlink);
2881
EXPORT_SYMBOL(__page_symlink);
L
Linus Torvalds 已提交
2882 2883 2884
EXPORT_SYMBOL(page_symlink);
EXPORT_SYMBOL(page_symlink_inode_operations);
EXPORT_SYMBOL(path_lookup);
A
Al Viro 已提交
2885
EXPORT_SYMBOL(kern_path);
2886
EXPORT_SYMBOL(vfs_path_lookup);
2887
EXPORT_SYMBOL(inode_permission);
2888
EXPORT_SYMBOL(vfs_permission);
2889
EXPORT_SYMBOL(file_permission);
L
Linus Torvalds 已提交
2890 2891 2892 2893 2894 2895 2896 2897 2898 2899 2900 2901 2902 2903
EXPORT_SYMBOL(unlock_rename);
EXPORT_SYMBOL(vfs_create);
EXPORT_SYMBOL(vfs_follow_link);
EXPORT_SYMBOL(vfs_link);
EXPORT_SYMBOL(vfs_mkdir);
EXPORT_SYMBOL(vfs_mknod);
EXPORT_SYMBOL(generic_permission);
EXPORT_SYMBOL(vfs_readlink);
EXPORT_SYMBOL(vfs_rename);
EXPORT_SYMBOL(vfs_rmdir);
EXPORT_SYMBOL(vfs_symlink);
EXPORT_SYMBOL(vfs_unlink);
EXPORT_SYMBOL(dentry_unhash);
EXPORT_SYMBOL(generic_readlink);