xref: /openbmc/linux/fs/namei.c (revision 14b9f27886ce69c5f11445d107dd020f6fc5754b)
1 /*
2  *  linux/fs/namei.c
3  *
4  *  Copyright (C) 1991, 1992  Linus Torvalds
5  */
6 
7 /*
8  * Some corrections by tytso.
9  */
10 
11 /* [Feb 1997 T. Schoebel-Theuer] Complete rewrite of the pathname
12  * lookup logic.
13  */
14 /* [Feb-Apr 2000, AV] Rewrite to the new namespace architecture.
15  */
16 
17 #include <linux/init.h>
18 #include <linux/module.h>
19 #include <linux/slab.h>
20 #include <linux/fs.h>
21 #include <linux/namei.h>
22 #include <linux/pagemap.h>
23 #include <linux/fsnotify.h>
24 #include <linux/personality.h>
25 #include <linux/security.h>
26 #include <linux/ima.h>
27 #include <linux/syscalls.h>
28 #include <linux/mount.h>
29 #include <linux/audit.h>
30 #include <linux/capability.h>
31 #include <linux/file.h>
32 #include <linux/fcntl.h>
33 #include <linux/device_cgroup.h>
34 #include <linux/fs_struct.h>
35 #include <asm/uaccess.h>
36 
37 #include "internal.h"
38 
39 /* [Feb-1997 T. Schoebel-Theuer]
40  * Fundamental changes in the pathname lookup mechanisms (namei)
41  * were necessary because of omirr.  The reason is that omirr needs
42  * to know the _real_ pathname, not the user-supplied one, in case
43  * of symlinks (and also when transname replacements occur).
44  *
45  * The new code replaces the old recursive symlink resolution with
46  * an iterative one (in case of non-nested symlink chains).  It does
47  * this with calls to <fs>_follow_link().
48  * As a side effect, dir_namei(), _namei() and follow_link() are now
49  * replaced with a single function lookup_dentry() that can handle all
50  * the special cases of the former code.
51  *
52  * With the new dcache, the pathname is stored at each inode, at least as
53  * long as the refcount of the inode is positive.  As a side effect, the
54  * size of the dcache depends on the inode cache and thus is dynamic.
55  *
56  * [29-Apr-1998 C. Scott Ananian] Updated above description of symlink
57  * resolution to correspond with current state of the code.
58  *
59  * Note that the symlink resolution is not *completely* iterative.
60  * There is still a significant amount of tail- and mid- recursion in
61  * the algorithm.  Also, note that <fs>_readlink() is not used in
62  * lookup_dentry(): lookup_dentry() on the result of <fs>_readlink()
63  * may return different results than <fs>_follow_link().  Many virtual
64  * filesystems (including /proc) exhibit this behavior.
65  */
66 
67 /* [24-Feb-97 T. Schoebel-Theuer] Side effects caused by new implementation:
68  * New symlink semantics: when open() is called with flags O_CREAT | O_EXCL
69  * and the name already exists in form of a symlink, try to create the new
70  * name indicated by the symlink. The old code always complained that the
71  * name already exists, due to not following the symlink even if its target
72  * is nonexistent.  The new semantics affects also mknod() and link() when
73  * the name is a symlink pointing to a non-existent name.
74  *
75  * I don't know which semantics is the right one, since I have no access
76  * to standards. But I found by trial that HP-UX 9.0 has the full "new"
77  * semantics implemented, while SunOS 4.1.1 and Solaris (SunOS 5.4) have the
78  * "old" one. Personally, I think the new semantics is much more logical.
79  * Note that "ln old new" where "new" is a symlink pointing to a non-existing
80  * file does succeed in both HP-UX and SunOs, but not in Solaris
81  * and in the old Linux semantics.
82  */
83 
84 /* [16-Dec-97 Kevin Buhr] For security reasons, we change some symlink
85  * semantics.  See the comments in "open_namei" and "do_link" below.
86  *
87  * [10-Sep-98 Alan Modra] Another symlink change.
88  */
89 
90 /* [Feb-Apr 2000 AV] Complete rewrite. Rules for symlinks:
91  *	inside the path - always follow.
92  *	in the last component in creation/removal/renaming - never follow.
93  *	if LOOKUP_FOLLOW passed - follow.
94  *	if the pathname has trailing slashes - follow.
95  *	otherwise - don't follow.
96  * (applied in that order).
97  *
98  * [Jun 2000 AV] Inconsistent behaviour of open() in case if flags==O_CREAT
99  * restored for 2.4. This is the last surviving part of old 4.2BSD bug.
100  * During the 2.4 we need to fix the userland stuff depending on it -
101  * hopefully we will be able to get rid of that wart in 2.5. So far only
102  * XEmacs seems to be relying on it...
103  */
104 /*
105  * [Sep 2001 AV] Single-semaphore locking scheme (kudos to David Holland)
106  * implemented.  Let's see if raised priority of ->s_vfs_rename_mutex gives
107  * any extra contention...
108  */
109 
110 /* In order to reduce some races, while at the same time doing additional
111  * checking and hopefully speeding things up, we copy filenames to the
112  * kernel data space before using them..
113  *
114  * POSIX.1 2.4: an empty pathname is invalid (ENOENT).
115  * PATH_MAX includes the nul terminator --RR.
116  */
117 static int do_getname(const char __user *filename, char *page)
118 {
119 	int retval;
120 	unsigned long len = PATH_MAX;
121 
122 	if (!segment_eq(get_fs(), KERNEL_DS)) {
123 		if ((unsigned long) filename >= TASK_SIZE)
124 			return -EFAULT;
125 		if (TASK_SIZE - (unsigned long) filename < PATH_MAX)
126 			len = TASK_SIZE - (unsigned long) filename;
127 	}
128 
129 	retval = strncpy_from_user(page, filename, len);
130 	if (retval > 0) {
131 		if (retval < len)
132 			return 0;
133 		return -ENAMETOOLONG;
134 	} else if (!retval)
135 		retval = -ENOENT;
136 	return retval;
137 }
138 
139 static char *getname_flags(const char __user * filename, int flags)
140 {
141 	char *tmp, *result;
142 
143 	result = ERR_PTR(-ENOMEM);
144 	tmp = __getname();
145 	if (tmp)  {
146 		int retval = do_getname(filename, tmp);
147 
148 		result = tmp;
149 		if (retval < 0) {
150 			if (retval != -ENOENT || !(flags & LOOKUP_EMPTY)) {
151 				__putname(tmp);
152 				result = ERR_PTR(retval);
153 			}
154 		}
155 	}
156 	audit_getname(result);
157 	return result;
158 }
159 
160 char *getname(const char __user * filename)
161 {
162 	return getname_flags(filename, 0);
163 }
164 
165 #ifdef CONFIG_AUDITSYSCALL
166 void putname(const char *name)
167 {
168 	if (unlikely(!audit_dummy_context()))
169 		audit_putname(name);
170 	else
171 		__putname(name);
172 }
173 EXPORT_SYMBOL(putname);
174 #endif
175 
176 /*
177  * This does basic POSIX ACL permission checking
178  */
179 static int acl_permission_check(struct inode *inode, int mask, unsigned int flags,
180 		int (*check_acl)(struct inode *inode, int mask, unsigned int flags))
181 {
182 	unsigned int mode = inode->i_mode;
183 
184 	mask &= MAY_READ | MAY_WRITE | MAY_EXEC;
185 
186 	if (current_user_ns() != inode_userns(inode))
187 		goto other_perms;
188 
189 	if (current_fsuid() == inode->i_uid)
190 		mode >>= 6;
191 	else {
192 		if (IS_POSIXACL(inode) && (mode & S_IRWXG) && check_acl) {
193 			int error = check_acl(inode, mask, flags);
194 			if (error != -EAGAIN)
195 				return error;
196 		}
197 
198 		if (in_group_p(inode->i_gid))
199 			mode >>= 3;
200 	}
201 
202 other_perms:
203 	/*
204 	 * If the DACs are ok we don't need any capability check.
205 	 */
206 	if ((mask & ~mode) == 0)
207 		return 0;
208 	return -EACCES;
209 }
210 
211 /**
212  * generic_permission -  check for access rights on a Posix-like filesystem
213  * @inode:	inode to check access rights for
214  * @mask:	right to check for (%MAY_READ, %MAY_WRITE, %MAY_EXEC)
215  * @check_acl:	optional callback to check for Posix ACLs
216  * @flags:	IPERM_FLAG_ flags.
217  *
218  * Used to check for read/write/execute permissions on a file.
219  * We use "fsuid" for this, letting us set arbitrary permissions
220  * for filesystem access without changing the "normal" uids which
221  * are used for other things.
222  *
223  * generic_permission is rcu-walk aware. It returns -ECHILD in case an rcu-walk
224  * request cannot be satisfied (eg. requires blocking or too much complexity).
225  * It would then be called again in ref-walk mode.
226  */
227 int generic_permission(struct inode *inode, int mask, unsigned int flags,
228 	int (*check_acl)(struct inode *inode, int mask, unsigned int flags))
229 {
230 	int ret;
231 
232 	/*
233 	 * Do the basic POSIX ACL permission checks.
234 	 */
235 	ret = acl_permission_check(inode, mask, flags, check_acl);
236 	if (ret != -EACCES)
237 		return ret;
238 
239 	/*
240 	 * Read/write DACs are always overridable.
241 	 * Executable DACs are overridable for all directories and
242 	 * for non-directories that have least one exec bit set.
243 	 */
244 	if (!(mask & MAY_EXEC) || execute_ok(inode))
245 		if (ns_capable(inode_userns(inode), CAP_DAC_OVERRIDE))
246 			return 0;
247 
248 	/*
249 	 * Searching includes executable on directories, else just read.
250 	 */
251 	mask &= MAY_READ | MAY_WRITE | MAY_EXEC;
252 	if (mask == MAY_READ || (S_ISDIR(inode->i_mode) && !(mask & MAY_WRITE)))
253 		if (ns_capable(inode_userns(inode), CAP_DAC_READ_SEARCH))
254 			return 0;
255 
256 	return -EACCES;
257 }
258 
259 /**
260  * inode_permission  -  check for access rights to a given inode
261  * @inode:	inode to check permission on
262  * @mask:	right to check for (%MAY_READ, %MAY_WRITE, %MAY_EXEC)
263  *
264  * Used to check for read/write/execute permissions on an inode.
265  * We use "fsuid" for this, letting us set arbitrary permissions
266  * for filesystem access without changing the "normal" uids which
267  * are used for other things.
268  */
269 int inode_permission(struct inode *inode, int mask)
270 {
271 	int retval;
272 
273 	if (mask & MAY_WRITE) {
274 		umode_t mode = inode->i_mode;
275 
276 		/*
277 		 * Nobody gets write access to a read-only fs.
278 		 */
279 		if (IS_RDONLY(inode) &&
280 		    (S_ISREG(mode) || S_ISDIR(mode) || S_ISLNK(mode)))
281 			return -EROFS;
282 
283 		/*
284 		 * Nobody gets write access to an immutable file.
285 		 */
286 		if (IS_IMMUTABLE(inode))
287 			return -EACCES;
288 	}
289 
290 	if (inode->i_op->permission)
291 		retval = inode->i_op->permission(inode, mask, 0);
292 	else
293 		retval = generic_permission(inode, mask, 0,
294 				inode->i_op->check_acl);
295 
296 	if (retval)
297 		return retval;
298 
299 	retval = devcgroup_inode_permission(inode, mask);
300 	if (retval)
301 		return retval;
302 
303 	return security_inode_permission(inode, mask);
304 }
305 
306 /**
307  * file_permission  -  check for additional access rights to a given file
308  * @file:	file to check access rights for
309  * @mask:	right to check for (%MAY_READ, %MAY_WRITE, %MAY_EXEC)
310  *
311  * Used to check for read/write/execute permissions on an already opened
312  * file.
313  *
314  * Note:
315  *	Do not use this function in new code.  All access checks should
316  *	be done using inode_permission().
317  */
318 int file_permission(struct file *file, int mask)
319 {
320 	return inode_permission(file->f_path.dentry->d_inode, mask);
321 }
322 
323 /*
324  * get_write_access() gets write permission for a file.
325  * put_write_access() releases this write permission.
326  * This is used for regular files.
327  * We cannot support write (and maybe mmap read-write shared) accesses and
328  * MAP_DENYWRITE mmappings simultaneously. The i_writecount field of an inode
329  * can have the following values:
330  * 0: no writers, no VM_DENYWRITE mappings
331  * < 0: (-i_writecount) vm_area_structs with VM_DENYWRITE set exist
332  * > 0: (i_writecount) users are writing to the file.
333  *
334  * Normally we operate on that counter with atomic_{inc,dec} and it's safe
335  * except for the cases where we don't hold i_writecount yet. Then we need to
336  * use {get,deny}_write_access() - these functions check the sign and refuse
337  * to do the change if sign is wrong. Exclusion between them is provided by
338  * the inode->i_lock spinlock.
339  */
340 
341 int get_write_access(struct inode * inode)
342 {
343 	spin_lock(&inode->i_lock);
344 	if (atomic_read(&inode->i_writecount) < 0) {
345 		spin_unlock(&inode->i_lock);
346 		return -ETXTBSY;
347 	}
348 	atomic_inc(&inode->i_writecount);
349 	spin_unlock(&inode->i_lock);
350 
351 	return 0;
352 }
353 
354 int deny_write_access(struct file * file)
355 {
356 	struct inode *inode = file->f_path.dentry->d_inode;
357 
358 	spin_lock(&inode->i_lock);
359 	if (atomic_read(&inode->i_writecount) > 0) {
360 		spin_unlock(&inode->i_lock);
361 		return -ETXTBSY;
362 	}
363 	atomic_dec(&inode->i_writecount);
364 	spin_unlock(&inode->i_lock);
365 
366 	return 0;
367 }
368 
369 /**
370  * path_get - get a reference to a path
371  * @path: path to get the reference to
372  *
373  * Given a path increment the reference count to the dentry and the vfsmount.
374  */
375 void path_get(struct path *path)
376 {
377 	mntget(path->mnt);
378 	dget(path->dentry);
379 }
380 EXPORT_SYMBOL(path_get);
381 
382 /**
383  * path_put - put a reference to a path
384  * @path: path to put the reference to
385  *
386  * Given a path decrement the reference count to the dentry and the vfsmount.
387  */
388 void path_put(struct path *path)
389 {
390 	dput(path->dentry);
391 	mntput(path->mnt);
392 }
393 EXPORT_SYMBOL(path_put);
394 
395 /*
396  * Path walking has 2 modes, rcu-walk and ref-walk (see
397  * Documentation/filesystems/path-lookup.txt).  In situations when we can't
398  * continue in RCU mode, we attempt to drop out of rcu-walk mode and grab
399  * normal reference counts on dentries and vfsmounts to transition to rcu-walk
400  * mode.  Refcounts are grabbed at the last known good point before rcu-walk
401  * got stuck, so ref-walk may continue from there. If this is not successful
402  * (eg. a seqcount has changed), then failure is returned and it's up to caller
403  * to restart the path walk from the beginning in ref-walk mode.
404  */
405 
406 /**
407  * unlazy_walk - try to switch to ref-walk mode.
408  * @nd: nameidata pathwalk data
409  * @dentry: child of nd->path.dentry or NULL
410  * Returns: 0 on success, -ECHILD on failure
411  *
412  * unlazy_walk attempts to legitimize the current nd->path, nd->root and dentry
413  * for ref-walk mode.  @dentry must be a path found by a do_lookup call on
414  * @nd or NULL.  Must be called from rcu-walk context.
415  */
416 static int unlazy_walk(struct nameidata *nd, struct dentry *dentry)
417 {
418 	struct fs_struct *fs = current->fs;
419 	struct dentry *parent = nd->path.dentry;
420 	int want_root = 0;
421 
422 	BUG_ON(!(nd->flags & LOOKUP_RCU));
423 	if (nd->root.mnt && !(nd->flags & LOOKUP_ROOT)) {
424 		want_root = 1;
425 		spin_lock(&fs->lock);
426 		if (nd->root.mnt != fs->root.mnt ||
427 				nd->root.dentry != fs->root.dentry)
428 			goto err_root;
429 	}
430 	spin_lock(&parent->d_lock);
431 	if (!dentry) {
432 		if (!__d_rcu_to_refcount(parent, nd->seq))
433 			goto err_parent;
434 		BUG_ON(nd->inode != parent->d_inode);
435 	} else {
436 		if (dentry->d_parent != parent)
437 			goto err_parent;
438 		spin_lock_nested(&dentry->d_lock, DENTRY_D_LOCK_NESTED);
439 		if (!__d_rcu_to_refcount(dentry, nd->seq))
440 			goto err_child;
441 		/*
442 		 * If the sequence check on the child dentry passed, then
443 		 * the child has not been removed from its parent. This
444 		 * means the parent dentry must be valid and able to take
445 		 * a reference at this point.
446 		 */
447 		BUG_ON(!IS_ROOT(dentry) && dentry->d_parent != parent);
448 		BUG_ON(!parent->d_count);
449 		parent->d_count++;
450 		spin_unlock(&dentry->d_lock);
451 	}
452 	spin_unlock(&parent->d_lock);
453 	if (want_root) {
454 		path_get(&nd->root);
455 		spin_unlock(&fs->lock);
456 	}
457 	mntget(nd->path.mnt);
458 
459 	rcu_read_unlock();
460 	br_read_unlock(vfsmount_lock);
461 	nd->flags &= ~LOOKUP_RCU;
462 	return 0;
463 
464 err_child:
465 	spin_unlock(&dentry->d_lock);
466 err_parent:
467 	spin_unlock(&parent->d_lock);
468 err_root:
469 	if (want_root)
470 		spin_unlock(&fs->lock);
471 	return -ECHILD;
472 }
473 
474 /**
475  * release_open_intent - free up open intent resources
476  * @nd: pointer to nameidata
477  */
478 void release_open_intent(struct nameidata *nd)
479 {
480 	struct file *file = nd->intent.open.file;
481 
482 	if (file && !IS_ERR(file)) {
483 		if (file->f_path.dentry == NULL)
484 			put_filp(file);
485 		else
486 			fput(file);
487 	}
488 }
489 
490 static inline int d_revalidate(struct dentry *dentry, struct nameidata *nd)
491 {
492 	return dentry->d_op->d_revalidate(dentry, nd);
493 }
494 
495 static struct dentry *
496 do_revalidate(struct dentry *dentry, struct nameidata *nd)
497 {
498 	int status = d_revalidate(dentry, nd);
499 	if (unlikely(status <= 0)) {
500 		/*
501 		 * The dentry failed validation.
502 		 * If d_revalidate returned 0 attempt to invalidate
503 		 * the dentry otherwise d_revalidate is asking us
504 		 * to return a fail status.
505 		 */
506 		if (status < 0) {
507 			dput(dentry);
508 			dentry = ERR_PTR(status);
509 		} else if (!d_invalidate(dentry)) {
510 			dput(dentry);
511 			dentry = NULL;
512 		}
513 	}
514 	return dentry;
515 }
516 
517 /**
518  * complete_walk - successful completion of path walk
519  * @nd:  pointer nameidata
520  *
521  * If we had been in RCU mode, drop out of it and legitimize nd->path.
522  * Revalidate the final result, unless we'd already done that during
523  * the path walk or the filesystem doesn't ask for it.  Return 0 on
524  * success, -error on failure.  In case of failure caller does not
525  * need to drop nd->path.
526  */
527 static int complete_walk(struct nameidata *nd)
528 {
529 	struct dentry *dentry = nd->path.dentry;
530 	int status;
531 
532 	if (nd->flags & LOOKUP_RCU) {
533 		nd->flags &= ~LOOKUP_RCU;
534 		if (!(nd->flags & LOOKUP_ROOT))
535 			nd->root.mnt = NULL;
536 		spin_lock(&dentry->d_lock);
537 		if (unlikely(!__d_rcu_to_refcount(dentry, nd->seq))) {
538 			spin_unlock(&dentry->d_lock);
539 			rcu_read_unlock();
540 			br_read_unlock(vfsmount_lock);
541 			return -ECHILD;
542 		}
543 		BUG_ON(nd->inode != dentry->d_inode);
544 		spin_unlock(&dentry->d_lock);
545 		mntget(nd->path.mnt);
546 		rcu_read_unlock();
547 		br_read_unlock(vfsmount_lock);
548 	}
549 
550 	if (likely(!(nd->flags & LOOKUP_JUMPED)))
551 		return 0;
552 
553 	if (likely(!(dentry->d_flags & DCACHE_OP_REVALIDATE)))
554 		return 0;
555 
556 	if (likely(!(dentry->d_sb->s_type->fs_flags & FS_REVAL_DOT)))
557 		return 0;
558 
559 	/* Note: we do not d_invalidate() */
560 	status = d_revalidate(dentry, nd);
561 	if (status > 0)
562 		return 0;
563 
564 	if (!status)
565 		status = -ESTALE;
566 
567 	path_put(&nd->path);
568 	return status;
569 }
570 
571 /*
572  * Short-cut version of permission(), for calling on directories
573  * during pathname resolution.  Combines parts of permission()
574  * and generic_permission(), and tests ONLY for MAY_EXEC permission.
575  *
576  * If appropriate, check DAC only.  If not appropriate, or
577  * short-cut DAC fails, then call ->permission() to do more
578  * complete permission check.
579  */
580 static inline int exec_permission(struct inode *inode, unsigned int flags)
581 {
582 	int ret;
583 	struct user_namespace *ns = inode_userns(inode);
584 
585 	if (inode->i_op->permission) {
586 		ret = inode->i_op->permission(inode, MAY_EXEC, flags);
587 	} else {
588 		ret = acl_permission_check(inode, MAY_EXEC, flags,
589 				inode->i_op->check_acl);
590 	}
591 	if (likely(!ret))
592 		goto ok;
593 	if (ret == -ECHILD)
594 		return ret;
595 
596 	if (ns_capable(ns, CAP_DAC_OVERRIDE) ||
597 			ns_capable(ns, CAP_DAC_READ_SEARCH))
598 		goto ok;
599 
600 	return ret;
601 ok:
602 	return security_inode_exec_permission(inode, flags);
603 }
604 
605 static __always_inline void set_root(struct nameidata *nd)
606 {
607 	if (!nd->root.mnt)
608 		get_fs_root(current->fs, &nd->root);
609 }
610 
611 static int link_path_walk(const char *, struct nameidata *);
612 
613 static __always_inline void set_root_rcu(struct nameidata *nd)
614 {
615 	if (!nd->root.mnt) {
616 		struct fs_struct *fs = current->fs;
617 		unsigned seq;
618 
619 		do {
620 			seq = read_seqcount_begin(&fs->seq);
621 			nd->root = fs->root;
622 			nd->seq = __read_seqcount_begin(&nd->root.dentry->d_seq);
623 		} while (read_seqcount_retry(&fs->seq, seq));
624 	}
625 }
626 
627 static __always_inline int __vfs_follow_link(struct nameidata *nd, const char *link)
628 {
629 	int ret;
630 
631 	if (IS_ERR(link))
632 		goto fail;
633 
634 	if (*link == '/') {
635 		set_root(nd);
636 		path_put(&nd->path);
637 		nd->path = nd->root;
638 		path_get(&nd->root);
639 		nd->flags |= LOOKUP_JUMPED;
640 	}
641 	nd->inode = nd->path.dentry->d_inode;
642 
643 	ret = link_path_walk(link, nd);
644 	return ret;
645 fail:
646 	path_put(&nd->path);
647 	return PTR_ERR(link);
648 }
649 
650 static void path_put_conditional(struct path *path, struct nameidata *nd)
651 {
652 	dput(path->dentry);
653 	if (path->mnt != nd->path.mnt)
654 		mntput(path->mnt);
655 }
656 
657 static inline void path_to_nameidata(const struct path *path,
658 					struct nameidata *nd)
659 {
660 	if (!(nd->flags & LOOKUP_RCU)) {
661 		dput(nd->path.dentry);
662 		if (nd->path.mnt != path->mnt)
663 			mntput(nd->path.mnt);
664 	}
665 	nd->path.mnt = path->mnt;
666 	nd->path.dentry = path->dentry;
667 }
668 
669 static inline void put_link(struct nameidata *nd, struct path *link, void *cookie)
670 {
671 	struct inode *inode = link->dentry->d_inode;
672 	if (!IS_ERR(cookie) && inode->i_op->put_link)
673 		inode->i_op->put_link(link->dentry, nd, cookie);
674 	path_put(link);
675 }
676 
677 static __always_inline int
678 follow_link(struct path *link, struct nameidata *nd, void **p)
679 {
680 	int error;
681 	struct dentry *dentry = link->dentry;
682 
683 	BUG_ON(nd->flags & LOOKUP_RCU);
684 
685 	if (link->mnt == nd->path.mnt)
686 		mntget(link->mnt);
687 
688 	if (unlikely(current->total_link_count >= 40)) {
689 		*p = ERR_PTR(-ELOOP); /* no ->put_link(), please */
690 		path_put(&nd->path);
691 		return -ELOOP;
692 	}
693 	cond_resched();
694 	current->total_link_count++;
695 
696 	touch_atime(link->mnt, dentry);
697 	nd_set_link(nd, NULL);
698 
699 	error = security_inode_follow_link(link->dentry, nd);
700 	if (error) {
701 		*p = ERR_PTR(error); /* no ->put_link(), please */
702 		path_put(&nd->path);
703 		return error;
704 	}
705 
706 	nd->last_type = LAST_BIND;
707 	*p = dentry->d_inode->i_op->follow_link(dentry, nd);
708 	error = PTR_ERR(*p);
709 	if (!IS_ERR(*p)) {
710 		char *s = nd_get_link(nd);
711 		error = 0;
712 		if (s)
713 			error = __vfs_follow_link(nd, s);
714 		else if (nd->last_type == LAST_BIND) {
715 			nd->flags |= LOOKUP_JUMPED;
716 			nd->inode = nd->path.dentry->d_inode;
717 			if (nd->inode->i_op->follow_link) {
718 				/* stepped on a _really_ weird one */
719 				path_put(&nd->path);
720 				error = -ELOOP;
721 			}
722 		}
723 	}
724 	return error;
725 }
726 
727 static int follow_up_rcu(struct path *path)
728 {
729 	struct vfsmount *parent;
730 	struct dentry *mountpoint;
731 
732 	parent = path->mnt->mnt_parent;
733 	if (parent == path->mnt)
734 		return 0;
735 	mountpoint = path->mnt->mnt_mountpoint;
736 	path->dentry = mountpoint;
737 	path->mnt = parent;
738 	return 1;
739 }
740 
741 int follow_up(struct path *path)
742 {
743 	struct vfsmount *parent;
744 	struct dentry *mountpoint;
745 
746 	br_read_lock(vfsmount_lock);
747 	parent = path->mnt->mnt_parent;
748 	if (parent == path->mnt) {
749 		br_read_unlock(vfsmount_lock);
750 		return 0;
751 	}
752 	mntget(parent);
753 	mountpoint = dget(path->mnt->mnt_mountpoint);
754 	br_read_unlock(vfsmount_lock);
755 	dput(path->dentry);
756 	path->dentry = mountpoint;
757 	mntput(path->mnt);
758 	path->mnt = parent;
759 	return 1;
760 }
761 
762 /*
763  * Perform an automount
764  * - return -EISDIR to tell follow_managed() to stop and return the path we
765  *   were called with.
766  */
767 static int follow_automount(struct path *path, unsigned flags,
768 			    bool *need_mntput)
769 {
770 	struct vfsmount *mnt;
771 	int err;
772 
773 	if (!path->dentry->d_op || !path->dentry->d_op->d_automount)
774 		return -EREMOTE;
775 
776 	/* We don't want to mount if someone supplied AT_NO_AUTOMOUNT
777 	 * and this is the terminal part of the path.
778 	 */
779 	if ((flags & LOOKUP_NO_AUTOMOUNT) && !(flags & LOOKUP_CONTINUE))
780 		return -EISDIR; /* we actually want to stop here */
781 
782 	/* We want to mount if someone is trying to open/create a file of any
783 	 * type under the mountpoint, wants to traverse through the mountpoint
784 	 * or wants to open the mounted directory.
785 	 *
786 	 * We don't want to mount if someone's just doing a stat and they've
787 	 * set AT_SYMLINK_NOFOLLOW - unless they're stat'ing a directory and
788 	 * appended a '/' to the name.
789 	 */
790 	if (!(flags & LOOKUP_FOLLOW) &&
791 	    !(flags & (LOOKUP_CONTINUE | LOOKUP_DIRECTORY |
792 		       LOOKUP_OPEN | LOOKUP_CREATE)))
793 		return -EISDIR;
794 
795 	current->total_link_count++;
796 	if (current->total_link_count >= 40)
797 		return -ELOOP;
798 
799 	mnt = path->dentry->d_op->d_automount(path);
800 	if (IS_ERR(mnt)) {
801 		/*
802 		 * The filesystem is allowed to return -EISDIR here to indicate
803 		 * it doesn't want to automount.  For instance, autofs would do
804 		 * this so that its userspace daemon can mount on this dentry.
805 		 *
806 		 * However, we can only permit this if it's a terminal point in
807 		 * the path being looked up; if it wasn't then the remainder of
808 		 * the path is inaccessible and we should say so.
809 		 */
810 		if (PTR_ERR(mnt) == -EISDIR && (flags & LOOKUP_CONTINUE))
811 			return -EREMOTE;
812 		return PTR_ERR(mnt);
813 	}
814 
815 	if (!mnt) /* mount collision */
816 		return 0;
817 
818 	if (!*need_mntput) {
819 		/* lock_mount() may release path->mnt on error */
820 		mntget(path->mnt);
821 		*need_mntput = true;
822 	}
823 	err = finish_automount(mnt, path);
824 
825 	switch (err) {
826 	case -EBUSY:
827 		/* Someone else made a mount here whilst we were busy */
828 		return 0;
829 	case 0:
830 		path_put(path);
831 		path->mnt = mnt;
832 		path->dentry = dget(mnt->mnt_root);
833 		return 0;
834 	default:
835 		return err;
836 	}
837 
838 }
839 
840 /*
841  * Handle a dentry that is managed in some way.
842  * - Flagged for transit management (autofs)
843  * - Flagged as mountpoint
844  * - Flagged as automount point
845  *
846  * This may only be called in refwalk mode.
847  *
848  * Serialization is taken care of in namespace.c
849  */
850 static int follow_managed(struct path *path, unsigned flags)
851 {
852 	struct vfsmount *mnt = path->mnt; /* held by caller, must be left alone */
853 	unsigned managed;
854 	bool need_mntput = false;
855 	int ret = 0;
856 
857 	/* Given that we're not holding a lock here, we retain the value in a
858 	 * local variable for each dentry as we look at it so that we don't see
859 	 * the components of that value change under us */
860 	while (managed = ACCESS_ONCE(path->dentry->d_flags),
861 	       managed &= DCACHE_MANAGED_DENTRY,
862 	       unlikely(managed != 0)) {
863 		/* Allow the filesystem to manage the transit without i_mutex
864 		 * being held. */
865 		if (managed & DCACHE_MANAGE_TRANSIT) {
866 			BUG_ON(!path->dentry->d_op);
867 			BUG_ON(!path->dentry->d_op->d_manage);
868 			ret = path->dentry->d_op->d_manage(path->dentry, false);
869 			if (ret < 0)
870 				break;
871 		}
872 
873 		/* Transit to a mounted filesystem. */
874 		if (managed & DCACHE_MOUNTED) {
875 			struct vfsmount *mounted = lookup_mnt(path);
876 			if (mounted) {
877 				dput(path->dentry);
878 				if (need_mntput)
879 					mntput(path->mnt);
880 				path->mnt = mounted;
881 				path->dentry = dget(mounted->mnt_root);
882 				need_mntput = true;
883 				continue;
884 			}
885 
886 			/* Something is mounted on this dentry in another
887 			 * namespace and/or whatever was mounted there in this
888 			 * namespace got unmounted before we managed to get the
889 			 * vfsmount_lock */
890 		}
891 
892 		/* Handle an automount point */
893 		if (managed & DCACHE_NEED_AUTOMOUNT) {
894 			ret = follow_automount(path, flags, &need_mntput);
895 			if (ret < 0)
896 				break;
897 			continue;
898 		}
899 
900 		/* We didn't change the current path point */
901 		break;
902 	}
903 
904 	if (need_mntput && path->mnt == mnt)
905 		mntput(path->mnt);
906 	if (ret == -EISDIR)
907 		ret = 0;
908 	return ret;
909 }
910 
911 int follow_down_one(struct path *path)
912 {
913 	struct vfsmount *mounted;
914 
915 	mounted = lookup_mnt(path);
916 	if (mounted) {
917 		dput(path->dentry);
918 		mntput(path->mnt);
919 		path->mnt = mounted;
920 		path->dentry = dget(mounted->mnt_root);
921 		return 1;
922 	}
923 	return 0;
924 }
925 
926 static inline bool managed_dentry_might_block(struct dentry *dentry)
927 {
928 	return (dentry->d_flags & DCACHE_MANAGE_TRANSIT &&
929 		dentry->d_op->d_manage(dentry, true) < 0);
930 }
931 
932 /*
933  * Try to skip to top of mountpoint pile in rcuwalk mode.  Fail if
934  * we meet a managed dentry that would need blocking.
935  */
936 static bool __follow_mount_rcu(struct nameidata *nd, struct path *path,
937 			       struct inode **inode)
938 {
939 	for (;;) {
940 		struct vfsmount *mounted;
941 		/*
942 		 * Don't forget we might have a non-mountpoint managed dentry
943 		 * that wants to block transit.
944 		 */
945 		if (unlikely(managed_dentry_might_block(path->dentry)))
946 			return false;
947 
948 		if (!d_mountpoint(path->dentry))
949 			break;
950 
951 		mounted = __lookup_mnt(path->mnt, path->dentry, 1);
952 		if (!mounted)
953 			break;
954 		path->mnt = mounted;
955 		path->dentry = mounted->mnt_root;
956 		nd->seq = read_seqcount_begin(&path->dentry->d_seq);
957 		/*
958 		 * Update the inode too. We don't need to re-check the
959 		 * dentry sequence number here after this d_inode read,
960 		 * because a mount-point is always pinned.
961 		 */
962 		*inode = path->dentry->d_inode;
963 	}
964 	return true;
965 }
966 
967 static void follow_mount_rcu(struct nameidata *nd)
968 {
969 	while (d_mountpoint(nd->path.dentry)) {
970 		struct vfsmount *mounted;
971 		mounted = __lookup_mnt(nd->path.mnt, nd->path.dentry, 1);
972 		if (!mounted)
973 			break;
974 		nd->path.mnt = mounted;
975 		nd->path.dentry = mounted->mnt_root;
976 		nd->seq = read_seqcount_begin(&nd->path.dentry->d_seq);
977 	}
978 }
979 
980 static int follow_dotdot_rcu(struct nameidata *nd)
981 {
982 	set_root_rcu(nd);
983 
984 	while (1) {
985 		if (nd->path.dentry == nd->root.dentry &&
986 		    nd->path.mnt == nd->root.mnt) {
987 			break;
988 		}
989 		if (nd->path.dentry != nd->path.mnt->mnt_root) {
990 			struct dentry *old = nd->path.dentry;
991 			struct dentry *parent = old->d_parent;
992 			unsigned seq;
993 
994 			seq = read_seqcount_begin(&parent->d_seq);
995 			if (read_seqcount_retry(&old->d_seq, nd->seq))
996 				goto failed;
997 			nd->path.dentry = parent;
998 			nd->seq = seq;
999 			break;
1000 		}
1001 		if (!follow_up_rcu(&nd->path))
1002 			break;
1003 		nd->seq = read_seqcount_begin(&nd->path.dentry->d_seq);
1004 	}
1005 	follow_mount_rcu(nd);
1006 	nd->inode = nd->path.dentry->d_inode;
1007 	return 0;
1008 
1009 failed:
1010 	nd->flags &= ~LOOKUP_RCU;
1011 	if (!(nd->flags & LOOKUP_ROOT))
1012 		nd->root.mnt = NULL;
1013 	rcu_read_unlock();
1014 	br_read_unlock(vfsmount_lock);
1015 	return -ECHILD;
1016 }
1017 
1018 /*
1019  * Follow down to the covering mount currently visible to userspace.  At each
1020  * point, the filesystem owning that dentry may be queried as to whether the
1021  * caller is permitted to proceed or not.
1022  */
1023 int follow_down(struct path *path)
1024 {
1025 	unsigned managed;
1026 	int ret;
1027 
1028 	while (managed = ACCESS_ONCE(path->dentry->d_flags),
1029 	       unlikely(managed & DCACHE_MANAGED_DENTRY)) {
1030 		/* Allow the filesystem to manage the transit without i_mutex
1031 		 * being held.
1032 		 *
1033 		 * We indicate to the filesystem if someone is trying to mount
1034 		 * something here.  This gives autofs the chance to deny anyone
1035 		 * other than its daemon the right to mount on its
1036 		 * superstructure.
1037 		 *
1038 		 * The filesystem may sleep at this point.
1039 		 */
1040 		if (managed & DCACHE_MANAGE_TRANSIT) {
1041 			BUG_ON(!path->dentry->d_op);
1042 			BUG_ON(!path->dentry->d_op->d_manage);
1043 			ret = path->dentry->d_op->d_manage(
1044 				path->dentry, false);
1045 			if (ret < 0)
1046 				return ret == -EISDIR ? 0 : ret;
1047 		}
1048 
1049 		/* Transit to a mounted filesystem. */
1050 		if (managed & DCACHE_MOUNTED) {
1051 			struct vfsmount *mounted = lookup_mnt(path);
1052 			if (!mounted)
1053 				break;
1054 			dput(path->dentry);
1055 			mntput(path->mnt);
1056 			path->mnt = mounted;
1057 			path->dentry = dget(mounted->mnt_root);
1058 			continue;
1059 		}
1060 
1061 		/* Don't handle automount points here */
1062 		break;
1063 	}
1064 	return 0;
1065 }
1066 
1067 /*
1068  * Skip to top of mountpoint pile in refwalk mode for follow_dotdot()
1069  */
1070 static void follow_mount(struct path *path)
1071 {
1072 	while (d_mountpoint(path->dentry)) {
1073 		struct vfsmount *mounted = lookup_mnt(path);
1074 		if (!mounted)
1075 			break;
1076 		dput(path->dentry);
1077 		mntput(path->mnt);
1078 		path->mnt = mounted;
1079 		path->dentry = dget(mounted->mnt_root);
1080 	}
1081 }
1082 
1083 static void follow_dotdot(struct nameidata *nd)
1084 {
1085 	set_root(nd);
1086 
1087 	while(1) {
1088 		struct dentry *old = nd->path.dentry;
1089 
1090 		if (nd->path.dentry == nd->root.dentry &&
1091 		    nd->path.mnt == nd->root.mnt) {
1092 			break;
1093 		}
1094 		if (nd->path.dentry != nd->path.mnt->mnt_root) {
1095 			/* rare case of legitimate dget_parent()... */
1096 			nd->path.dentry = dget_parent(nd->path.dentry);
1097 			dput(old);
1098 			break;
1099 		}
1100 		if (!follow_up(&nd->path))
1101 			break;
1102 	}
1103 	follow_mount(&nd->path);
1104 	nd->inode = nd->path.dentry->d_inode;
1105 }
1106 
1107 /*
1108  * Allocate a dentry with name and parent, and perform a parent
1109  * directory ->lookup on it. Returns the new dentry, or ERR_PTR
1110  * on error. parent->d_inode->i_mutex must be held. d_lookup must
1111  * have verified that no child exists while under i_mutex.
1112  */
1113 static struct dentry *d_alloc_and_lookup(struct dentry *parent,
1114 				struct qstr *name, struct nameidata *nd)
1115 {
1116 	struct inode *inode = parent->d_inode;
1117 	struct dentry *dentry;
1118 	struct dentry *old;
1119 
1120 	/* Don't create child dentry for a dead directory. */
1121 	if (unlikely(IS_DEADDIR(inode)))
1122 		return ERR_PTR(-ENOENT);
1123 
1124 	dentry = d_alloc(parent, name);
1125 	if (unlikely(!dentry))
1126 		return ERR_PTR(-ENOMEM);
1127 
1128 	old = inode->i_op->lookup(inode, dentry, nd);
1129 	if (unlikely(old)) {
1130 		dput(dentry);
1131 		dentry = old;
1132 	}
1133 	return dentry;
1134 }
1135 
1136 /*
1137  *  It's more convoluted than I'd like it to be, but... it's still fairly
1138  *  small and for now I'd prefer to have fast path as straight as possible.
1139  *  It _is_ time-critical.
1140  */
1141 static int do_lookup(struct nameidata *nd, struct qstr *name,
1142 			struct path *path, struct inode **inode)
1143 {
1144 	struct vfsmount *mnt = nd->path.mnt;
1145 	struct dentry *dentry, *parent = nd->path.dentry;
1146 	int need_reval = 1;
1147 	int status = 1;
1148 	int err;
1149 
1150 	/*
1151 	 * Rename seqlock is not required here because in the off chance
1152 	 * of a false negative due to a concurrent rename, we're going to
1153 	 * do the non-racy lookup, below.
1154 	 */
1155 	if (nd->flags & LOOKUP_RCU) {
1156 		unsigned seq;
1157 		*inode = nd->inode;
1158 		dentry = __d_lookup_rcu(parent, name, &seq, inode);
1159 		if (!dentry)
1160 			goto unlazy;
1161 
1162 		/* Memory barrier in read_seqcount_begin of child is enough */
1163 		if (__read_seqcount_retry(&parent->d_seq, nd->seq))
1164 			return -ECHILD;
1165 		nd->seq = seq;
1166 
1167 		if (unlikely(dentry->d_flags & DCACHE_OP_REVALIDATE)) {
1168 			status = d_revalidate(dentry, nd);
1169 			if (unlikely(status <= 0)) {
1170 				if (status != -ECHILD)
1171 					need_reval = 0;
1172 				goto unlazy;
1173 			}
1174 		}
1175 		path->mnt = mnt;
1176 		path->dentry = dentry;
1177 		if (unlikely(!__follow_mount_rcu(nd, path, inode)))
1178 			goto unlazy;
1179 		if (unlikely(path->dentry->d_flags & DCACHE_NEED_AUTOMOUNT))
1180 			goto unlazy;
1181 		return 0;
1182 unlazy:
1183 		if (unlazy_walk(nd, dentry))
1184 			return -ECHILD;
1185 	} else {
1186 		dentry = __d_lookup(parent, name);
1187 	}
1188 
1189 retry:
1190 	if (unlikely(!dentry)) {
1191 		struct inode *dir = parent->d_inode;
1192 		BUG_ON(nd->inode != dir);
1193 
1194 		mutex_lock(&dir->i_mutex);
1195 		dentry = d_lookup(parent, name);
1196 		if (likely(!dentry)) {
1197 			dentry = d_alloc_and_lookup(parent, name, nd);
1198 			if (IS_ERR(dentry)) {
1199 				mutex_unlock(&dir->i_mutex);
1200 				return PTR_ERR(dentry);
1201 			}
1202 			/* known good */
1203 			need_reval = 0;
1204 			status = 1;
1205 		}
1206 		mutex_unlock(&dir->i_mutex);
1207 	}
1208 	if (unlikely(dentry->d_flags & DCACHE_OP_REVALIDATE) && need_reval)
1209 		status = d_revalidate(dentry, nd);
1210 	if (unlikely(status <= 0)) {
1211 		if (status < 0) {
1212 			dput(dentry);
1213 			return status;
1214 		}
1215 		if (!d_invalidate(dentry)) {
1216 			dput(dentry);
1217 			dentry = NULL;
1218 			need_reval = 1;
1219 			goto retry;
1220 		}
1221 	}
1222 
1223 	path->mnt = mnt;
1224 	path->dentry = dentry;
1225 	err = follow_managed(path, nd->flags);
1226 	if (unlikely(err < 0)) {
1227 		path_put_conditional(path, nd);
1228 		return err;
1229 	}
1230 	*inode = path->dentry->d_inode;
1231 	return 0;
1232 }
1233 
1234 static inline int may_lookup(struct nameidata *nd)
1235 {
1236 	if (nd->flags & LOOKUP_RCU) {
1237 		int err = exec_permission(nd->inode, IPERM_FLAG_RCU);
1238 		if (err != -ECHILD)
1239 			return err;
1240 		if (unlazy_walk(nd, NULL))
1241 			return -ECHILD;
1242 	}
1243 	return exec_permission(nd->inode, 0);
1244 }
1245 
1246 static inline int handle_dots(struct nameidata *nd, int type)
1247 {
1248 	if (type == LAST_DOTDOT) {
1249 		if (nd->flags & LOOKUP_RCU) {
1250 			if (follow_dotdot_rcu(nd))
1251 				return -ECHILD;
1252 		} else
1253 			follow_dotdot(nd);
1254 	}
1255 	return 0;
1256 }
1257 
1258 static void terminate_walk(struct nameidata *nd)
1259 {
1260 	if (!(nd->flags & LOOKUP_RCU)) {
1261 		path_put(&nd->path);
1262 	} else {
1263 		nd->flags &= ~LOOKUP_RCU;
1264 		if (!(nd->flags & LOOKUP_ROOT))
1265 			nd->root.mnt = NULL;
1266 		rcu_read_unlock();
1267 		br_read_unlock(vfsmount_lock);
1268 	}
1269 }
1270 
1271 static inline int walk_component(struct nameidata *nd, struct path *path,
1272 		struct qstr *name, int type, int follow)
1273 {
1274 	struct inode *inode;
1275 	int err;
1276 	/*
1277 	 * "." and ".." are special - ".." especially so because it has
1278 	 * to be able to know about the current root directory and
1279 	 * parent relationships.
1280 	 */
1281 	if (unlikely(type != LAST_NORM))
1282 		return handle_dots(nd, type);
1283 	err = do_lookup(nd, name, path, &inode);
1284 	if (unlikely(err)) {
1285 		terminate_walk(nd);
1286 		return err;
1287 	}
1288 	if (!inode) {
1289 		path_to_nameidata(path, nd);
1290 		terminate_walk(nd);
1291 		return -ENOENT;
1292 	}
1293 	if (unlikely(inode->i_op->follow_link) && follow) {
1294 		if (nd->flags & LOOKUP_RCU) {
1295 			if (unlikely(unlazy_walk(nd, path->dentry))) {
1296 				terminate_walk(nd);
1297 				return -ECHILD;
1298 			}
1299 		}
1300 		BUG_ON(inode != path->dentry->d_inode);
1301 		return 1;
1302 	}
1303 	path_to_nameidata(path, nd);
1304 	nd->inode = inode;
1305 	return 0;
1306 }
1307 
1308 /*
1309  * This limits recursive symlink follows to 8, while
1310  * limiting consecutive symlinks to 40.
1311  *
1312  * Without that kind of total limit, nasty chains of consecutive
1313  * symlinks can cause almost arbitrarily long lookups.
1314  */
1315 static inline int nested_symlink(struct path *path, struct nameidata *nd)
1316 {
1317 	int res;
1318 
1319 	if (unlikely(current->link_count >= MAX_NESTED_LINKS)) {
1320 		path_put_conditional(path, nd);
1321 		path_put(&nd->path);
1322 		return -ELOOP;
1323 	}
1324 	BUG_ON(nd->depth >= MAX_NESTED_LINKS);
1325 
1326 	nd->depth++;
1327 	current->link_count++;
1328 
1329 	do {
1330 		struct path link = *path;
1331 		void *cookie;
1332 
1333 		res = follow_link(&link, nd, &cookie);
1334 		if (!res)
1335 			res = walk_component(nd, path, &nd->last,
1336 					     nd->last_type, LOOKUP_FOLLOW);
1337 		put_link(nd, &link, cookie);
1338 	} while (res > 0);
1339 
1340 	current->link_count--;
1341 	nd->depth--;
1342 	return res;
1343 }
1344 
1345 /*
1346  * Name resolution.
1347  * This is the basic name resolution function, turning a pathname into
1348  * the final dentry. We expect 'base' to be positive and a directory.
1349  *
1350  * Returns 0 and nd will have valid dentry and mnt on success.
1351  * Returns error and drops reference to input namei data on failure.
1352  */
1353 static int link_path_walk(const char *name, struct nameidata *nd)
1354 {
1355 	struct path next;
1356 	int err;
1357 	unsigned int lookup_flags = nd->flags;
1358 
1359 	while (*name=='/')
1360 		name++;
1361 	if (!*name)
1362 		return 0;
1363 
1364 	/* At this point we know we have a real path component. */
1365 	for(;;) {
1366 		unsigned long hash;
1367 		struct qstr this;
1368 		unsigned int c;
1369 		int type;
1370 
1371 		nd->flags |= LOOKUP_CONTINUE;
1372 
1373 		err = may_lookup(nd);
1374  		if (err)
1375 			break;
1376 
1377 		this.name = name;
1378 		c = *(const unsigned char *)name;
1379 
1380 		hash = init_name_hash();
1381 		do {
1382 			name++;
1383 			hash = partial_name_hash(c, hash);
1384 			c = *(const unsigned char *)name;
1385 		} while (c && (c != '/'));
1386 		this.len = name - (const char *) this.name;
1387 		this.hash = end_name_hash(hash);
1388 
1389 		type = LAST_NORM;
1390 		if (this.name[0] == '.') switch (this.len) {
1391 			case 2:
1392 				if (this.name[1] == '.') {
1393 					type = LAST_DOTDOT;
1394 					nd->flags |= LOOKUP_JUMPED;
1395 				}
1396 				break;
1397 			case 1:
1398 				type = LAST_DOT;
1399 		}
1400 		if (likely(type == LAST_NORM)) {
1401 			struct dentry *parent = nd->path.dentry;
1402 			nd->flags &= ~LOOKUP_JUMPED;
1403 			if (unlikely(parent->d_flags & DCACHE_OP_HASH)) {
1404 				err = parent->d_op->d_hash(parent, nd->inode,
1405 							   &this);
1406 				if (err < 0)
1407 					break;
1408 			}
1409 		}
1410 
1411 		/* remove trailing slashes? */
1412 		if (!c)
1413 			goto last_component;
1414 		while (*++name == '/');
1415 		if (!*name)
1416 			goto last_component;
1417 
1418 		err = walk_component(nd, &next, &this, type, LOOKUP_FOLLOW);
1419 		if (err < 0)
1420 			return err;
1421 
1422 		if (err) {
1423 			err = nested_symlink(&next, nd);
1424 			if (err)
1425 				return err;
1426 		}
1427 		err = -ENOTDIR;
1428 		if (!nd->inode->i_op->lookup)
1429 			break;
1430 		continue;
1431 		/* here ends the main loop */
1432 
1433 last_component:
1434 		/* Clear LOOKUP_CONTINUE iff it was previously unset */
1435 		nd->flags &= lookup_flags | ~LOOKUP_CONTINUE;
1436 		nd->last = this;
1437 		nd->last_type = type;
1438 		return 0;
1439 	}
1440 	terminate_walk(nd);
1441 	return err;
1442 }
1443 
1444 static int path_init(int dfd, const char *name, unsigned int flags,
1445 		     struct nameidata *nd, struct file **fp)
1446 {
1447 	int retval = 0;
1448 	int fput_needed;
1449 	struct file *file;
1450 
1451 	nd->last_type = LAST_ROOT; /* if there are only slashes... */
1452 	nd->flags = flags | LOOKUP_JUMPED;
1453 	nd->depth = 0;
1454 	if (flags & LOOKUP_ROOT) {
1455 		struct inode *inode = nd->root.dentry->d_inode;
1456 		if (*name) {
1457 			if (!inode->i_op->lookup)
1458 				return -ENOTDIR;
1459 			retval = inode_permission(inode, MAY_EXEC);
1460 			if (retval)
1461 				return retval;
1462 		}
1463 		nd->path = nd->root;
1464 		nd->inode = inode;
1465 		if (flags & LOOKUP_RCU) {
1466 			br_read_lock(vfsmount_lock);
1467 			rcu_read_lock();
1468 			nd->seq = __read_seqcount_begin(&nd->path.dentry->d_seq);
1469 		} else {
1470 			path_get(&nd->path);
1471 		}
1472 		return 0;
1473 	}
1474 
1475 	nd->root.mnt = NULL;
1476 
1477 	if (*name=='/') {
1478 		if (flags & LOOKUP_RCU) {
1479 			br_read_lock(vfsmount_lock);
1480 			rcu_read_lock();
1481 			set_root_rcu(nd);
1482 		} else {
1483 			set_root(nd);
1484 			path_get(&nd->root);
1485 		}
1486 		nd->path = nd->root;
1487 	} else if (dfd == AT_FDCWD) {
1488 		if (flags & LOOKUP_RCU) {
1489 			struct fs_struct *fs = current->fs;
1490 			unsigned seq;
1491 
1492 			br_read_lock(vfsmount_lock);
1493 			rcu_read_lock();
1494 
1495 			do {
1496 				seq = read_seqcount_begin(&fs->seq);
1497 				nd->path = fs->pwd;
1498 				nd->seq = __read_seqcount_begin(&nd->path.dentry->d_seq);
1499 			} while (read_seqcount_retry(&fs->seq, seq));
1500 		} else {
1501 			get_fs_pwd(current->fs, &nd->path);
1502 		}
1503 	} else {
1504 		struct dentry *dentry;
1505 
1506 		file = fget_raw_light(dfd, &fput_needed);
1507 		retval = -EBADF;
1508 		if (!file)
1509 			goto out_fail;
1510 
1511 		dentry = file->f_path.dentry;
1512 
1513 		if (*name) {
1514 			retval = -ENOTDIR;
1515 			if (!S_ISDIR(dentry->d_inode->i_mode))
1516 				goto fput_fail;
1517 
1518 			retval = file_permission(file, MAY_EXEC);
1519 			if (retval)
1520 				goto fput_fail;
1521 		}
1522 
1523 		nd->path = file->f_path;
1524 		if (flags & LOOKUP_RCU) {
1525 			if (fput_needed)
1526 				*fp = file;
1527 			nd->seq = __read_seqcount_begin(&nd->path.dentry->d_seq);
1528 			br_read_lock(vfsmount_lock);
1529 			rcu_read_lock();
1530 		} else {
1531 			path_get(&file->f_path);
1532 			fput_light(file, fput_needed);
1533 		}
1534 	}
1535 
1536 	nd->inode = nd->path.dentry->d_inode;
1537 	return 0;
1538 
1539 fput_fail:
1540 	fput_light(file, fput_needed);
1541 out_fail:
1542 	return retval;
1543 }
1544 
1545 static inline int lookup_last(struct nameidata *nd, struct path *path)
1546 {
1547 	if (nd->last_type == LAST_NORM && nd->last.name[nd->last.len])
1548 		nd->flags |= LOOKUP_FOLLOW | LOOKUP_DIRECTORY;
1549 
1550 	nd->flags &= ~LOOKUP_PARENT;
1551 	return walk_component(nd, path, &nd->last, nd->last_type,
1552 					nd->flags & LOOKUP_FOLLOW);
1553 }
1554 
1555 /* Returns 0 and nd will be valid on success; Retuns error, otherwise. */
1556 static int path_lookupat(int dfd, const char *name,
1557 				unsigned int flags, struct nameidata *nd)
1558 {
1559 	struct file *base = NULL;
1560 	struct path path;
1561 	int err;
1562 
1563 	/*
1564 	 * Path walking is largely split up into 2 different synchronisation
1565 	 * schemes, rcu-walk and ref-walk (explained in
1566 	 * Documentation/filesystems/path-lookup.txt). These share much of the
1567 	 * path walk code, but some things particularly setup, cleanup, and
1568 	 * following mounts are sufficiently divergent that functions are
1569 	 * duplicated. Typically there is a function foo(), and its RCU
1570 	 * analogue, foo_rcu().
1571 	 *
1572 	 * -ECHILD is the error number of choice (just to avoid clashes) that
1573 	 * is returned if some aspect of an rcu-walk fails. Such an error must
1574 	 * be handled by restarting a traditional ref-walk (which will always
1575 	 * be able to complete).
1576 	 */
1577 	err = path_init(dfd, name, flags | LOOKUP_PARENT, nd, &base);
1578 
1579 	if (unlikely(err))
1580 		return err;
1581 
1582 	current->total_link_count = 0;
1583 	err = link_path_walk(name, nd);
1584 
1585 	if (!err && !(flags & LOOKUP_PARENT)) {
1586 		err = lookup_last(nd, &path);
1587 		while (err > 0) {
1588 			void *cookie;
1589 			struct path link = path;
1590 			nd->flags |= LOOKUP_PARENT;
1591 			err = follow_link(&link, nd, &cookie);
1592 			if (!err)
1593 				err = lookup_last(nd, &path);
1594 			put_link(nd, &link, cookie);
1595 		}
1596 	}
1597 
1598 	if (!err)
1599 		err = complete_walk(nd);
1600 
1601 	if (!err && nd->flags & LOOKUP_DIRECTORY) {
1602 		if (!nd->inode->i_op->lookup) {
1603 			path_put(&nd->path);
1604 			err = -ENOTDIR;
1605 		}
1606 	}
1607 
1608 	if (base)
1609 		fput(base);
1610 
1611 	if (nd->root.mnt && !(nd->flags & LOOKUP_ROOT)) {
1612 		path_put(&nd->root);
1613 		nd->root.mnt = NULL;
1614 	}
1615 	return err;
1616 }
1617 
1618 static int do_path_lookup(int dfd, const char *name,
1619 				unsigned int flags, struct nameidata *nd)
1620 {
1621 	int retval = path_lookupat(dfd, name, flags | LOOKUP_RCU, nd);
1622 	if (unlikely(retval == -ECHILD))
1623 		retval = path_lookupat(dfd, name, flags, nd);
1624 	if (unlikely(retval == -ESTALE))
1625 		retval = path_lookupat(dfd, name, flags | LOOKUP_REVAL, nd);
1626 
1627 	if (likely(!retval)) {
1628 		if (unlikely(!audit_dummy_context())) {
1629 			if (nd->path.dentry && nd->inode)
1630 				audit_inode(name, nd->path.dentry);
1631 		}
1632 	}
1633 	return retval;
1634 }
1635 
1636 int kern_path_parent(const char *name, struct nameidata *nd)
1637 {
1638 	return do_path_lookup(AT_FDCWD, name, LOOKUP_PARENT, nd);
1639 }
1640 
1641 int kern_path(const char *name, unsigned int flags, struct path *path)
1642 {
1643 	struct nameidata nd;
1644 	int res = do_path_lookup(AT_FDCWD, name, flags, &nd);
1645 	if (!res)
1646 		*path = nd.path;
1647 	return res;
1648 }
1649 
1650 /**
1651  * vfs_path_lookup - lookup a file path relative to a dentry-vfsmount pair
1652  * @dentry:  pointer to dentry of the base directory
1653  * @mnt: pointer to vfs mount of the base directory
1654  * @name: pointer to file name
1655  * @flags: lookup flags
1656  * @nd: pointer to nameidata
1657  */
1658 int vfs_path_lookup(struct dentry *dentry, struct vfsmount *mnt,
1659 		    const char *name, unsigned int flags,
1660 		    struct nameidata *nd)
1661 {
1662 	nd->root.dentry = dentry;
1663 	nd->root.mnt = mnt;
1664 	/* the first argument of do_path_lookup() is ignored with LOOKUP_ROOT */
1665 	return do_path_lookup(AT_FDCWD, name, flags | LOOKUP_ROOT, nd);
1666 }
1667 
1668 static struct dentry *__lookup_hash(struct qstr *name,
1669 		struct dentry *base, struct nameidata *nd)
1670 {
1671 	struct inode *inode = base->d_inode;
1672 	struct dentry *dentry;
1673 	int err;
1674 
1675 	err = exec_permission(inode, 0);
1676 	if (err)
1677 		return ERR_PTR(err);
1678 
1679 	/*
1680 	 * Don't bother with __d_lookup: callers are for creat as
1681 	 * well as unlink, so a lot of the time it would cost
1682 	 * a double lookup.
1683 	 */
1684 	dentry = d_lookup(base, name);
1685 
1686 	if (dentry && (dentry->d_flags & DCACHE_OP_REVALIDATE))
1687 		dentry = do_revalidate(dentry, nd);
1688 
1689 	if (!dentry)
1690 		dentry = d_alloc_and_lookup(base, name, nd);
1691 
1692 	return dentry;
1693 }
1694 
1695 /*
1696  * Restricted form of lookup. Doesn't follow links, single-component only,
1697  * needs parent already locked. Doesn't follow mounts.
1698  * SMP-safe.
1699  */
1700 static struct dentry *lookup_hash(struct nameidata *nd)
1701 {
1702 	return __lookup_hash(&nd->last, nd->path.dentry, nd);
1703 }
1704 
1705 /**
1706  * lookup_one_len - filesystem helper to lookup single pathname component
1707  * @name:	pathname component to lookup
1708  * @base:	base directory to lookup from
1709  * @len:	maximum length @len should be interpreted to
1710  *
1711  * Note that this routine is purely a helper for filesystem usage and should
1712  * not be called by generic code.  Also note that by using this function the
1713  * nameidata argument is passed to the filesystem methods and a filesystem
1714  * using this helper needs to be prepared for that.
1715  */
1716 struct dentry *lookup_one_len(const char *name, struct dentry *base, int len)
1717 {
1718 	struct qstr this;
1719 	unsigned long hash;
1720 	unsigned int c;
1721 
1722 	WARN_ON_ONCE(!mutex_is_locked(&base->d_inode->i_mutex));
1723 
1724 	this.name = name;
1725 	this.len = len;
1726 	if (!len)
1727 		return ERR_PTR(-EACCES);
1728 
1729 	hash = init_name_hash();
1730 	while (len--) {
1731 		c = *(const unsigned char *)name++;
1732 		if (c == '/' || c == '\0')
1733 			return ERR_PTR(-EACCES);
1734 		hash = partial_name_hash(c, hash);
1735 	}
1736 	this.hash = end_name_hash(hash);
1737 	/*
1738 	 * See if the low-level filesystem might want
1739 	 * to use its own hash..
1740 	 */
1741 	if (base->d_flags & DCACHE_OP_HASH) {
1742 		int err = base->d_op->d_hash(base, base->d_inode, &this);
1743 		if (err < 0)
1744 			return ERR_PTR(err);
1745 	}
1746 
1747 	return __lookup_hash(&this, base, NULL);
1748 }
1749 
1750 int user_path_at(int dfd, const char __user *name, unsigned flags,
1751 		 struct path *path)
1752 {
1753 	struct nameidata nd;
1754 	char *tmp = getname_flags(name, flags);
1755 	int err = PTR_ERR(tmp);
1756 	if (!IS_ERR(tmp)) {
1757 
1758 		BUG_ON(flags & LOOKUP_PARENT);
1759 
1760 		err = do_path_lookup(dfd, tmp, flags, &nd);
1761 		putname(tmp);
1762 		if (!err)
1763 			*path = nd.path;
1764 	}
1765 	return err;
1766 }
1767 
1768 static int user_path_parent(int dfd, const char __user *path,
1769 			struct nameidata *nd, char **name)
1770 {
1771 	char *s = getname(path);
1772 	int error;
1773 
1774 	if (IS_ERR(s))
1775 		return PTR_ERR(s);
1776 
1777 	error = do_path_lookup(dfd, s, LOOKUP_PARENT, nd);
1778 	if (error)
1779 		putname(s);
1780 	else
1781 		*name = s;
1782 
1783 	return error;
1784 }
1785 
1786 /*
1787  * It's inline, so penalty for filesystems that don't use sticky bit is
1788  * minimal.
1789  */
1790 static inline int check_sticky(struct inode *dir, struct inode *inode)
1791 {
1792 	uid_t fsuid = current_fsuid();
1793 
1794 	if (!(dir->i_mode & S_ISVTX))
1795 		return 0;
1796 	if (current_user_ns() != inode_userns(inode))
1797 		goto other_userns;
1798 	if (inode->i_uid == fsuid)
1799 		return 0;
1800 	if (dir->i_uid == fsuid)
1801 		return 0;
1802 
1803 other_userns:
1804 	return !ns_capable(inode_userns(inode), CAP_FOWNER);
1805 }
1806 
1807 /*
1808  *	Check whether we can remove a link victim from directory dir, check
1809  *  whether the type of victim is right.
1810  *  1. We can't do it if dir is read-only (done in permission())
1811  *  2. We should have write and exec permissions on dir
1812  *  3. We can't remove anything from append-only dir
1813  *  4. We can't do anything with immutable dir (done in permission())
1814  *  5. If the sticky bit on dir is set we should either
1815  *	a. be owner of dir, or
1816  *	b. be owner of victim, or
1817  *	c. have CAP_FOWNER capability
1818  *  6. If the victim is append-only or immutable we can't do antyhing with
1819  *     links pointing to it.
1820  *  7. If we were asked to remove a directory and victim isn't one - ENOTDIR.
1821  *  8. If we were asked to remove a non-directory and victim isn't one - EISDIR.
1822  *  9. We can't remove a root or mountpoint.
1823  * 10. We don't allow removal of NFS sillyrenamed files; it's handled by
1824  *     nfs_async_unlink().
1825  */
1826 static int may_delete(struct inode *dir,struct dentry *victim,int isdir)
1827 {
1828 	int error;
1829 
1830 	if (!victim->d_inode)
1831 		return -ENOENT;
1832 
1833 	BUG_ON(victim->d_parent->d_inode != dir);
1834 	audit_inode_child(victim, dir);
1835 
1836 	error = inode_permission(dir, MAY_WRITE | MAY_EXEC);
1837 	if (error)
1838 		return error;
1839 	if (IS_APPEND(dir))
1840 		return -EPERM;
1841 	if (check_sticky(dir, victim->d_inode)||IS_APPEND(victim->d_inode)||
1842 	    IS_IMMUTABLE(victim->d_inode) || IS_SWAPFILE(victim->d_inode))
1843 		return -EPERM;
1844 	if (isdir) {
1845 		if (!S_ISDIR(victim->d_inode->i_mode))
1846 			return -ENOTDIR;
1847 		if (IS_ROOT(victim))
1848 			return -EBUSY;
1849 	} else if (S_ISDIR(victim->d_inode->i_mode))
1850 		return -EISDIR;
1851 	if (IS_DEADDIR(dir))
1852 		return -ENOENT;
1853 	if (victim->d_flags & DCACHE_NFSFS_RENAMED)
1854 		return -EBUSY;
1855 	return 0;
1856 }
1857 
1858 /*	Check whether we can create an object with dentry child in directory
1859  *  dir.
1860  *  1. We can't do it if child already exists (open has special treatment for
1861  *     this case, but since we are inlined it's OK)
1862  *  2. We can't do it if dir is read-only (done in permission())
1863  *  3. We should have write and exec permissions on dir
1864  *  4. We can't do it if dir is immutable (done in permission())
1865  */
1866 static inline int may_create(struct inode *dir, struct dentry *child)
1867 {
1868 	if (child->d_inode)
1869 		return -EEXIST;
1870 	if (IS_DEADDIR(dir))
1871 		return -ENOENT;
1872 	return inode_permission(dir, MAY_WRITE | MAY_EXEC);
1873 }
1874 
1875 /*
1876  * p1 and p2 should be directories on the same fs.
1877  */
1878 struct dentry *lock_rename(struct dentry *p1, struct dentry *p2)
1879 {
1880 	struct dentry *p;
1881 
1882 	if (p1 == p2) {
1883 		mutex_lock_nested(&p1->d_inode->i_mutex, I_MUTEX_PARENT);
1884 		return NULL;
1885 	}
1886 
1887 	mutex_lock(&p1->d_inode->i_sb->s_vfs_rename_mutex);
1888 
1889 	p = d_ancestor(p2, p1);
1890 	if (p) {
1891 		mutex_lock_nested(&p2->d_inode->i_mutex, I_MUTEX_PARENT);
1892 		mutex_lock_nested(&p1->d_inode->i_mutex, I_MUTEX_CHILD);
1893 		return p;
1894 	}
1895 
1896 	p = d_ancestor(p1, p2);
1897 	if (p) {
1898 		mutex_lock_nested(&p1->d_inode->i_mutex, I_MUTEX_PARENT);
1899 		mutex_lock_nested(&p2->d_inode->i_mutex, I_MUTEX_CHILD);
1900 		return p;
1901 	}
1902 
1903 	mutex_lock_nested(&p1->d_inode->i_mutex, I_MUTEX_PARENT);
1904 	mutex_lock_nested(&p2->d_inode->i_mutex, I_MUTEX_CHILD);
1905 	return NULL;
1906 }
1907 
1908 void unlock_rename(struct dentry *p1, struct dentry *p2)
1909 {
1910 	mutex_unlock(&p1->d_inode->i_mutex);
1911 	if (p1 != p2) {
1912 		mutex_unlock(&p2->d_inode->i_mutex);
1913 		mutex_unlock(&p1->d_inode->i_sb->s_vfs_rename_mutex);
1914 	}
1915 }
1916 
1917 int vfs_create(struct inode *dir, struct dentry *dentry, int mode,
1918 		struct nameidata *nd)
1919 {
1920 	int error = may_create(dir, dentry);
1921 
1922 	if (error)
1923 		return error;
1924 
1925 	if (!dir->i_op->create)
1926 		return -EACCES;	/* shouldn't it be ENOSYS? */
1927 	mode &= S_IALLUGO;
1928 	mode |= S_IFREG;
1929 	error = security_inode_create(dir, dentry, mode);
1930 	if (error)
1931 		return error;
1932 	error = dir->i_op->create(dir, dentry, mode, nd);
1933 	if (!error)
1934 		fsnotify_create(dir, dentry);
1935 	return error;
1936 }
1937 
1938 static int may_open(struct path *path, int acc_mode, int flag)
1939 {
1940 	struct dentry *dentry = path->dentry;
1941 	struct inode *inode = dentry->d_inode;
1942 	int error;
1943 
1944 	/* O_PATH? */
1945 	if (!acc_mode)
1946 		return 0;
1947 
1948 	if (!inode)
1949 		return -ENOENT;
1950 
1951 	switch (inode->i_mode & S_IFMT) {
1952 	case S_IFLNK:
1953 		return -ELOOP;
1954 	case S_IFDIR:
1955 		if (acc_mode & MAY_WRITE)
1956 			return -EISDIR;
1957 		break;
1958 	case S_IFBLK:
1959 	case S_IFCHR:
1960 		if (path->mnt->mnt_flags & MNT_NODEV)
1961 			return -EACCES;
1962 		/*FALLTHRU*/
1963 	case S_IFIFO:
1964 	case S_IFSOCK:
1965 		flag &= ~O_TRUNC;
1966 		break;
1967 	}
1968 
1969 	error = inode_permission(inode, acc_mode);
1970 	if (error)
1971 		return error;
1972 
1973 	/*
1974 	 * An append-only file must be opened in append mode for writing.
1975 	 */
1976 	if (IS_APPEND(inode)) {
1977 		if  ((flag & O_ACCMODE) != O_RDONLY && !(flag & O_APPEND))
1978 			return -EPERM;
1979 		if (flag & O_TRUNC)
1980 			return -EPERM;
1981 	}
1982 
1983 	/* O_NOATIME can only be set by the owner or superuser */
1984 	if (flag & O_NOATIME && !inode_owner_or_capable(inode))
1985 		return -EPERM;
1986 
1987 	/*
1988 	 * Ensure there are no outstanding leases on the file.
1989 	 */
1990 	return break_lease(inode, flag);
1991 }
1992 
1993 static int handle_truncate(struct file *filp)
1994 {
1995 	struct path *path = &filp->f_path;
1996 	struct inode *inode = path->dentry->d_inode;
1997 	int error = get_write_access(inode);
1998 	if (error)
1999 		return error;
2000 	/*
2001 	 * Refuse to truncate files with mandatory locks held on them.
2002 	 */
2003 	error = locks_verify_locked(inode);
2004 	if (!error)
2005 		error = security_path_truncate(path);
2006 	if (!error) {
2007 		error = do_truncate(path->dentry, 0,
2008 				    ATTR_MTIME|ATTR_CTIME|ATTR_OPEN,
2009 				    filp);
2010 	}
2011 	put_write_access(inode);
2012 	return error;
2013 }
2014 
2015 /*
2016  * Note that while the flag value (low two bits) for sys_open means:
2017  *	00 - read-only
2018  *	01 - write-only
2019  *	10 - read-write
2020  *	11 - special
2021  * it is changed into
2022  *	00 - no permissions needed
2023  *	01 - read-permission
2024  *	10 - write-permission
2025  *	11 - read-write
2026  * for the internal routines (ie open_namei()/follow_link() etc)
2027  * This is more logical, and also allows the 00 "no perm needed"
2028  * to be used for symlinks (where the permissions are checked
2029  * later).
2030  *
2031 */
2032 static inline int open_to_namei_flags(int flag)
2033 {
2034 	if ((flag+1) & O_ACCMODE)
2035 		flag++;
2036 	return flag;
2037 }
2038 
2039 /*
2040  * Handle the last step of open()
2041  */
2042 static struct file *do_last(struct nameidata *nd, struct path *path,
2043 			    const struct open_flags *op, const char *pathname)
2044 {
2045 	struct dentry *dir = nd->path.dentry;
2046 	struct dentry *dentry;
2047 	int open_flag = op->open_flag;
2048 	int will_truncate = open_flag & O_TRUNC;
2049 	int want_write = 0;
2050 	int acc_mode = op->acc_mode;
2051 	struct file *filp;
2052 	int error;
2053 
2054 	nd->flags &= ~LOOKUP_PARENT;
2055 	nd->flags |= op->intent;
2056 
2057 	switch (nd->last_type) {
2058 	case LAST_DOTDOT:
2059 	case LAST_DOT:
2060 		error = handle_dots(nd, nd->last_type);
2061 		if (error)
2062 			return ERR_PTR(error);
2063 		/* fallthrough */
2064 	case LAST_ROOT:
2065 		error = complete_walk(nd);
2066 		if (error)
2067 			return ERR_PTR(error);
2068 		audit_inode(pathname, nd->path.dentry);
2069 		if (open_flag & O_CREAT) {
2070 			error = -EISDIR;
2071 			goto exit;
2072 		}
2073 		goto ok;
2074 	case LAST_BIND:
2075 		error = complete_walk(nd);
2076 		if (error)
2077 			return ERR_PTR(error);
2078 		audit_inode(pathname, dir);
2079 		goto ok;
2080 	}
2081 
2082 	if (!(open_flag & O_CREAT)) {
2083 		int symlink_ok = 0;
2084 		if (nd->last.name[nd->last.len])
2085 			nd->flags |= LOOKUP_FOLLOW | LOOKUP_DIRECTORY;
2086 		if (open_flag & O_PATH && !(nd->flags & LOOKUP_FOLLOW))
2087 			symlink_ok = 1;
2088 		/* we _can_ be in RCU mode here */
2089 		error = walk_component(nd, path, &nd->last, LAST_NORM,
2090 					!symlink_ok);
2091 		if (error < 0)
2092 			return ERR_PTR(error);
2093 		if (error) /* symlink */
2094 			return NULL;
2095 		/* sayonara */
2096 		error = complete_walk(nd);
2097 		if (error)
2098 			return ERR_PTR(-ECHILD);
2099 
2100 		error = -ENOTDIR;
2101 		if (nd->flags & LOOKUP_DIRECTORY) {
2102 			if (!nd->inode->i_op->lookup)
2103 				goto exit;
2104 		}
2105 		audit_inode(pathname, nd->path.dentry);
2106 		goto ok;
2107 	}
2108 
2109 	/* create side of things */
2110 	error = complete_walk(nd);
2111 	if (error)
2112 		return ERR_PTR(error);
2113 
2114 	audit_inode(pathname, dir);
2115 	error = -EISDIR;
2116 	/* trailing slashes? */
2117 	if (nd->last.name[nd->last.len])
2118 		goto exit;
2119 
2120 	mutex_lock(&dir->d_inode->i_mutex);
2121 
2122 	dentry = lookup_hash(nd);
2123 	error = PTR_ERR(dentry);
2124 	if (IS_ERR(dentry)) {
2125 		mutex_unlock(&dir->d_inode->i_mutex);
2126 		goto exit;
2127 	}
2128 
2129 	path->dentry = dentry;
2130 	path->mnt = nd->path.mnt;
2131 
2132 	/* Negative dentry, just create the file */
2133 	if (!dentry->d_inode) {
2134 		int mode = op->mode;
2135 		if (!IS_POSIXACL(dir->d_inode))
2136 			mode &= ~current_umask();
2137 		/*
2138 		 * This write is needed to ensure that a
2139 		 * rw->ro transition does not occur between
2140 		 * the time when the file is created and when
2141 		 * a permanent write count is taken through
2142 		 * the 'struct file' in nameidata_to_filp().
2143 		 */
2144 		error = mnt_want_write(nd->path.mnt);
2145 		if (error)
2146 			goto exit_mutex_unlock;
2147 		want_write = 1;
2148 		/* Don't check for write permission, don't truncate */
2149 		open_flag &= ~O_TRUNC;
2150 		will_truncate = 0;
2151 		acc_mode = MAY_OPEN;
2152 		error = security_path_mknod(&nd->path, dentry, mode, 0);
2153 		if (error)
2154 			goto exit_mutex_unlock;
2155 		error = vfs_create(dir->d_inode, dentry, mode, nd);
2156 		if (error)
2157 			goto exit_mutex_unlock;
2158 		mutex_unlock(&dir->d_inode->i_mutex);
2159 		dput(nd->path.dentry);
2160 		nd->path.dentry = dentry;
2161 		goto common;
2162 	}
2163 
2164 	/*
2165 	 * It already exists.
2166 	 */
2167 	mutex_unlock(&dir->d_inode->i_mutex);
2168 	audit_inode(pathname, path->dentry);
2169 
2170 	error = -EEXIST;
2171 	if (open_flag & O_EXCL)
2172 		goto exit_dput;
2173 
2174 	error = follow_managed(path, nd->flags);
2175 	if (error < 0)
2176 		goto exit_dput;
2177 
2178 	error = -ENOENT;
2179 	if (!path->dentry->d_inode)
2180 		goto exit_dput;
2181 
2182 	if (path->dentry->d_inode->i_op->follow_link)
2183 		return NULL;
2184 
2185 	path_to_nameidata(path, nd);
2186 	nd->inode = path->dentry->d_inode;
2187 	error = -EISDIR;
2188 	if (S_ISDIR(nd->inode->i_mode))
2189 		goto exit;
2190 ok:
2191 	if (!S_ISREG(nd->inode->i_mode))
2192 		will_truncate = 0;
2193 
2194 	if (will_truncate) {
2195 		error = mnt_want_write(nd->path.mnt);
2196 		if (error)
2197 			goto exit;
2198 		want_write = 1;
2199 	}
2200 common:
2201 	error = may_open(&nd->path, acc_mode, open_flag);
2202 	if (error)
2203 		goto exit;
2204 	filp = nameidata_to_filp(nd);
2205 	if (!IS_ERR(filp)) {
2206 		error = ima_file_check(filp, op->acc_mode);
2207 		if (error) {
2208 			fput(filp);
2209 			filp = ERR_PTR(error);
2210 		}
2211 	}
2212 	if (!IS_ERR(filp)) {
2213 		if (will_truncate) {
2214 			error = handle_truncate(filp);
2215 			if (error) {
2216 				fput(filp);
2217 				filp = ERR_PTR(error);
2218 			}
2219 		}
2220 	}
2221 out:
2222 	if (want_write)
2223 		mnt_drop_write(nd->path.mnt);
2224 	path_put(&nd->path);
2225 	return filp;
2226 
2227 exit_mutex_unlock:
2228 	mutex_unlock(&dir->d_inode->i_mutex);
2229 exit_dput:
2230 	path_put_conditional(path, nd);
2231 exit:
2232 	filp = ERR_PTR(error);
2233 	goto out;
2234 }
2235 
2236 static struct file *path_openat(int dfd, const char *pathname,
2237 		struct nameidata *nd, const struct open_flags *op, int flags)
2238 {
2239 	struct file *base = NULL;
2240 	struct file *filp;
2241 	struct path path;
2242 	int error;
2243 
2244 	filp = get_empty_filp();
2245 	if (!filp)
2246 		return ERR_PTR(-ENFILE);
2247 
2248 	filp->f_flags = op->open_flag;
2249 	nd->intent.open.file = filp;
2250 	nd->intent.open.flags = open_to_namei_flags(op->open_flag);
2251 	nd->intent.open.create_mode = op->mode;
2252 
2253 	error = path_init(dfd, pathname, flags | LOOKUP_PARENT, nd, &base);
2254 	if (unlikely(error))
2255 		goto out_filp;
2256 
2257 	current->total_link_count = 0;
2258 	error = link_path_walk(pathname, nd);
2259 	if (unlikely(error))
2260 		goto out_filp;
2261 
2262 	filp = do_last(nd, &path, op, pathname);
2263 	while (unlikely(!filp)) { /* trailing symlink */
2264 		struct path link = path;
2265 		void *cookie;
2266 		if (!(nd->flags & LOOKUP_FOLLOW)) {
2267 			path_put_conditional(&path, nd);
2268 			path_put(&nd->path);
2269 			filp = ERR_PTR(-ELOOP);
2270 			break;
2271 		}
2272 		nd->flags |= LOOKUP_PARENT;
2273 		nd->flags &= ~(LOOKUP_OPEN|LOOKUP_CREATE|LOOKUP_EXCL);
2274 		error = follow_link(&link, nd, &cookie);
2275 		if (unlikely(error))
2276 			filp = ERR_PTR(error);
2277 		else
2278 			filp = do_last(nd, &path, op, pathname);
2279 		put_link(nd, &link, cookie);
2280 	}
2281 out:
2282 	if (nd->root.mnt && !(nd->flags & LOOKUP_ROOT))
2283 		path_put(&nd->root);
2284 	if (base)
2285 		fput(base);
2286 	release_open_intent(nd);
2287 	return filp;
2288 
2289 out_filp:
2290 	filp = ERR_PTR(error);
2291 	goto out;
2292 }
2293 
2294 struct file *do_filp_open(int dfd, const char *pathname,
2295 		const struct open_flags *op, int flags)
2296 {
2297 	struct nameidata nd;
2298 	struct file *filp;
2299 
2300 	filp = path_openat(dfd, pathname, &nd, op, flags | LOOKUP_RCU);
2301 	if (unlikely(filp == ERR_PTR(-ECHILD)))
2302 		filp = path_openat(dfd, pathname, &nd, op, flags);
2303 	if (unlikely(filp == ERR_PTR(-ESTALE)))
2304 		filp = path_openat(dfd, pathname, &nd, op, flags | LOOKUP_REVAL);
2305 	return filp;
2306 }
2307 
2308 struct file *do_file_open_root(struct dentry *dentry, struct vfsmount *mnt,
2309 		const char *name, const struct open_flags *op, int flags)
2310 {
2311 	struct nameidata nd;
2312 	struct file *file;
2313 
2314 	nd.root.mnt = mnt;
2315 	nd.root.dentry = dentry;
2316 
2317 	flags |= LOOKUP_ROOT;
2318 
2319 	if (dentry->d_inode->i_op->follow_link && op->intent & LOOKUP_OPEN)
2320 		return ERR_PTR(-ELOOP);
2321 
2322 	file = path_openat(-1, name, &nd, op, flags | LOOKUP_RCU);
2323 	if (unlikely(file == ERR_PTR(-ECHILD)))
2324 		file = path_openat(-1, name, &nd, op, flags);
2325 	if (unlikely(file == ERR_PTR(-ESTALE)))
2326 		file = path_openat(-1, name, &nd, op, flags | LOOKUP_REVAL);
2327 	return file;
2328 }
2329 
2330 /**
2331  * lookup_create - lookup a dentry, creating it if it doesn't exist
2332  * @nd: nameidata info
2333  * @is_dir: directory flag
2334  *
2335  * Simple function to lookup and return a dentry and create it
2336  * if it doesn't exist.  Is SMP-safe.
2337  *
2338  * Returns with nd->path.dentry->d_inode->i_mutex locked.
2339  */
2340 struct dentry *lookup_create(struct nameidata *nd, int is_dir)
2341 {
2342 	struct dentry *dentry = ERR_PTR(-EEXIST);
2343 
2344 	mutex_lock_nested(&nd->path.dentry->d_inode->i_mutex, I_MUTEX_PARENT);
2345 	/*
2346 	 * Yucky last component or no last component at all?
2347 	 * (foo/., foo/.., /////)
2348 	 */
2349 	if (nd->last_type != LAST_NORM)
2350 		goto fail;
2351 	nd->flags &= ~LOOKUP_PARENT;
2352 	nd->flags |= LOOKUP_CREATE | LOOKUP_EXCL;
2353 	nd->intent.open.flags = O_EXCL;
2354 
2355 	/*
2356 	 * Do the final lookup.
2357 	 */
2358 	dentry = lookup_hash(nd);
2359 	if (IS_ERR(dentry))
2360 		goto fail;
2361 
2362 	if (dentry->d_inode)
2363 		goto eexist;
2364 	/*
2365 	 * Special case - lookup gave negative, but... we had foo/bar/
2366 	 * From the vfs_mknod() POV we just have a negative dentry -
2367 	 * all is fine. Let's be bastards - you had / on the end, you've
2368 	 * been asking for (non-existent) directory. -ENOENT for you.
2369 	 */
2370 	if (unlikely(!is_dir && nd->last.name[nd->last.len])) {
2371 		dput(dentry);
2372 		dentry = ERR_PTR(-ENOENT);
2373 	}
2374 	return dentry;
2375 eexist:
2376 	dput(dentry);
2377 	dentry = ERR_PTR(-EEXIST);
2378 fail:
2379 	return dentry;
2380 }
2381 EXPORT_SYMBOL_GPL(lookup_create);
2382 
2383 int vfs_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t dev)
2384 {
2385 	int error = may_create(dir, dentry);
2386 
2387 	if (error)
2388 		return error;
2389 
2390 	if ((S_ISCHR(mode) || S_ISBLK(mode)) &&
2391 	    !ns_capable(inode_userns(dir), CAP_MKNOD))
2392 		return -EPERM;
2393 
2394 	if (!dir->i_op->mknod)
2395 		return -EPERM;
2396 
2397 	error = devcgroup_inode_mknod(mode, dev);
2398 	if (error)
2399 		return error;
2400 
2401 	error = security_inode_mknod(dir, dentry, mode, dev);
2402 	if (error)
2403 		return error;
2404 
2405 	error = dir->i_op->mknod(dir, dentry, mode, dev);
2406 	if (!error)
2407 		fsnotify_create(dir, dentry);
2408 	return error;
2409 }
2410 
2411 static int may_mknod(mode_t mode)
2412 {
2413 	switch (mode & S_IFMT) {
2414 	case S_IFREG:
2415 	case S_IFCHR:
2416 	case S_IFBLK:
2417 	case S_IFIFO:
2418 	case S_IFSOCK:
2419 	case 0: /* zero mode translates to S_IFREG */
2420 		return 0;
2421 	case S_IFDIR:
2422 		return -EPERM;
2423 	default:
2424 		return -EINVAL;
2425 	}
2426 }
2427 
2428 SYSCALL_DEFINE4(mknodat, int, dfd, const char __user *, filename, int, mode,
2429 		unsigned, dev)
2430 {
2431 	int error;
2432 	char *tmp;
2433 	struct dentry *dentry;
2434 	struct nameidata nd;
2435 
2436 	if (S_ISDIR(mode))
2437 		return -EPERM;
2438 
2439 	error = user_path_parent(dfd, filename, &nd, &tmp);
2440 	if (error)
2441 		return error;
2442 
2443 	dentry = lookup_create(&nd, 0);
2444 	if (IS_ERR(dentry)) {
2445 		error = PTR_ERR(dentry);
2446 		goto out_unlock;
2447 	}
2448 	if (!IS_POSIXACL(nd.path.dentry->d_inode))
2449 		mode &= ~current_umask();
2450 	error = may_mknod(mode);
2451 	if (error)
2452 		goto out_dput;
2453 	error = mnt_want_write(nd.path.mnt);
2454 	if (error)
2455 		goto out_dput;
2456 	error = security_path_mknod(&nd.path, dentry, mode, dev);
2457 	if (error)
2458 		goto out_drop_write;
2459 	switch (mode & S_IFMT) {
2460 		case 0: case S_IFREG:
2461 			error = vfs_create(nd.path.dentry->d_inode,dentry,mode,&nd);
2462 			break;
2463 		case S_IFCHR: case S_IFBLK:
2464 			error = vfs_mknod(nd.path.dentry->d_inode,dentry,mode,
2465 					new_decode_dev(dev));
2466 			break;
2467 		case S_IFIFO: case S_IFSOCK:
2468 			error = vfs_mknod(nd.path.dentry->d_inode,dentry,mode,0);
2469 			break;
2470 	}
2471 out_drop_write:
2472 	mnt_drop_write(nd.path.mnt);
2473 out_dput:
2474 	dput(dentry);
2475 out_unlock:
2476 	mutex_unlock(&nd.path.dentry->d_inode->i_mutex);
2477 	path_put(&nd.path);
2478 	putname(tmp);
2479 
2480 	return error;
2481 }
2482 
2483 SYSCALL_DEFINE3(mknod, const char __user *, filename, int, mode, unsigned, dev)
2484 {
2485 	return sys_mknodat(AT_FDCWD, filename, mode, dev);
2486 }
2487 
2488 int vfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
2489 {
2490 	int error = may_create(dir, dentry);
2491 
2492 	if (error)
2493 		return error;
2494 
2495 	if (!dir->i_op->mkdir)
2496 		return -EPERM;
2497 
2498 	mode &= (S_IRWXUGO|S_ISVTX);
2499 	error = security_inode_mkdir(dir, dentry, mode);
2500 	if (error)
2501 		return error;
2502 
2503 	error = dir->i_op->mkdir(dir, dentry, mode);
2504 	if (!error)
2505 		fsnotify_mkdir(dir, dentry);
2506 	return error;
2507 }
2508 
2509 SYSCALL_DEFINE3(mkdirat, int, dfd, const char __user *, pathname, int, mode)
2510 {
2511 	int error = 0;
2512 	char * tmp;
2513 	struct dentry *dentry;
2514 	struct nameidata nd;
2515 
2516 	error = user_path_parent(dfd, pathname, &nd, &tmp);
2517 	if (error)
2518 		goto out_err;
2519 
2520 	dentry = lookup_create(&nd, 1);
2521 	error = PTR_ERR(dentry);
2522 	if (IS_ERR(dentry))
2523 		goto out_unlock;
2524 
2525 	if (!IS_POSIXACL(nd.path.dentry->d_inode))
2526 		mode &= ~current_umask();
2527 	error = mnt_want_write(nd.path.mnt);
2528 	if (error)
2529 		goto out_dput;
2530 	error = security_path_mkdir(&nd.path, dentry, mode);
2531 	if (error)
2532 		goto out_drop_write;
2533 	error = vfs_mkdir(nd.path.dentry->d_inode, dentry, mode);
2534 out_drop_write:
2535 	mnt_drop_write(nd.path.mnt);
2536 out_dput:
2537 	dput(dentry);
2538 out_unlock:
2539 	mutex_unlock(&nd.path.dentry->d_inode->i_mutex);
2540 	path_put(&nd.path);
2541 	putname(tmp);
2542 out_err:
2543 	return error;
2544 }
2545 
2546 SYSCALL_DEFINE2(mkdir, const char __user *, pathname, int, mode)
2547 {
2548 	return sys_mkdirat(AT_FDCWD, pathname, mode);
2549 }
2550 
2551 /*
2552  * The dentry_unhash() helper will try to drop the dentry early: we
2553  * should have a usage count of 2 if we're the only user of this
2554  * dentry, and if that is true (possibly after pruning the dcache),
2555  * then we drop the dentry now.
2556  *
2557  * A low-level filesystem can, if it choses, legally
2558  * do a
2559  *
2560  *	if (!d_unhashed(dentry))
2561  *		return -EBUSY;
2562  *
2563  * if it cannot handle the case of removing a directory
2564  * that is still in use by something else..
2565  */
2566 void dentry_unhash(struct dentry *dentry)
2567 {
2568 	shrink_dcache_parent(dentry);
2569 	spin_lock(&dentry->d_lock);
2570 	if (dentry->d_count == 1)
2571 		__d_drop(dentry);
2572 	spin_unlock(&dentry->d_lock);
2573 }
2574 
2575 int vfs_rmdir(struct inode *dir, struct dentry *dentry)
2576 {
2577 	int error = may_delete(dir, dentry, 1);
2578 
2579 	if (error)
2580 		return error;
2581 
2582 	if (!dir->i_op->rmdir)
2583 		return -EPERM;
2584 
2585 	mutex_lock(&dentry->d_inode->i_mutex);
2586 
2587 	error = -EBUSY;
2588 	if (d_mountpoint(dentry))
2589 		goto out;
2590 
2591 	error = security_inode_rmdir(dir, dentry);
2592 	if (error)
2593 		goto out;
2594 
2595 	shrink_dcache_parent(dentry);
2596 	error = dir->i_op->rmdir(dir, dentry);
2597 	if (error)
2598 		goto out;
2599 
2600 	dentry->d_inode->i_flags |= S_DEAD;
2601 	dont_mount(dentry);
2602 
2603 out:
2604 	mutex_unlock(&dentry->d_inode->i_mutex);
2605 	if (!error)
2606 		d_delete(dentry);
2607 	return error;
2608 }
2609 
2610 static long do_rmdir(int dfd, const char __user *pathname)
2611 {
2612 	int error = 0;
2613 	char * name;
2614 	struct dentry *dentry;
2615 	struct nameidata nd;
2616 
2617 	error = user_path_parent(dfd, pathname, &nd, &name);
2618 	if (error)
2619 		return error;
2620 
2621 	switch(nd.last_type) {
2622 	case LAST_DOTDOT:
2623 		error = -ENOTEMPTY;
2624 		goto exit1;
2625 	case LAST_DOT:
2626 		error = -EINVAL;
2627 		goto exit1;
2628 	case LAST_ROOT:
2629 		error = -EBUSY;
2630 		goto exit1;
2631 	}
2632 
2633 	nd.flags &= ~LOOKUP_PARENT;
2634 
2635 	mutex_lock_nested(&nd.path.dentry->d_inode->i_mutex, I_MUTEX_PARENT);
2636 	dentry = lookup_hash(&nd);
2637 	error = PTR_ERR(dentry);
2638 	if (IS_ERR(dentry))
2639 		goto exit2;
2640 	if (!dentry->d_inode) {
2641 		error = -ENOENT;
2642 		goto exit3;
2643 	}
2644 	error = mnt_want_write(nd.path.mnt);
2645 	if (error)
2646 		goto exit3;
2647 	error = security_path_rmdir(&nd.path, dentry);
2648 	if (error)
2649 		goto exit4;
2650 	error = vfs_rmdir(nd.path.dentry->d_inode, dentry);
2651 exit4:
2652 	mnt_drop_write(nd.path.mnt);
2653 exit3:
2654 	dput(dentry);
2655 exit2:
2656 	mutex_unlock(&nd.path.dentry->d_inode->i_mutex);
2657 exit1:
2658 	path_put(&nd.path);
2659 	putname(name);
2660 	return error;
2661 }
2662 
2663 SYSCALL_DEFINE1(rmdir, const char __user *, pathname)
2664 {
2665 	return do_rmdir(AT_FDCWD, pathname);
2666 }
2667 
2668 int vfs_unlink(struct inode *dir, struct dentry *dentry)
2669 {
2670 	int error = may_delete(dir, dentry, 0);
2671 
2672 	if (error)
2673 		return error;
2674 
2675 	if (!dir->i_op->unlink)
2676 		return -EPERM;
2677 
2678 	mutex_lock(&dentry->d_inode->i_mutex);
2679 	if (d_mountpoint(dentry))
2680 		error = -EBUSY;
2681 	else {
2682 		error = security_inode_unlink(dir, dentry);
2683 		if (!error) {
2684 			error = dir->i_op->unlink(dir, dentry);
2685 			if (!error)
2686 				dont_mount(dentry);
2687 		}
2688 	}
2689 	mutex_unlock(&dentry->d_inode->i_mutex);
2690 
2691 	/* We don't d_delete() NFS sillyrenamed files--they still exist. */
2692 	if (!error && !(dentry->d_flags & DCACHE_NFSFS_RENAMED)) {
2693 		fsnotify_link_count(dentry->d_inode);
2694 		d_delete(dentry);
2695 	}
2696 
2697 	return error;
2698 }
2699 
2700 /*
2701  * Make sure that the actual truncation of the file will occur outside its
2702  * directory's i_mutex.  Truncate can take a long time if there is a lot of
2703  * writeout happening, and we don't want to prevent access to the directory
2704  * while waiting on the I/O.
2705  */
2706 static long do_unlinkat(int dfd, const char __user *pathname)
2707 {
2708 	int error;
2709 	char *name;
2710 	struct dentry *dentry;
2711 	struct nameidata nd;
2712 	struct inode *inode = NULL;
2713 
2714 	error = user_path_parent(dfd, pathname, &nd, &name);
2715 	if (error)
2716 		return error;
2717 
2718 	error = -EISDIR;
2719 	if (nd.last_type != LAST_NORM)
2720 		goto exit1;
2721 
2722 	nd.flags &= ~LOOKUP_PARENT;
2723 
2724 	mutex_lock_nested(&nd.path.dentry->d_inode->i_mutex, I_MUTEX_PARENT);
2725 	dentry = lookup_hash(&nd);
2726 	error = PTR_ERR(dentry);
2727 	if (!IS_ERR(dentry)) {
2728 		/* Why not before? Because we want correct error value */
2729 		if (nd.last.name[nd.last.len])
2730 			goto slashes;
2731 		inode = dentry->d_inode;
2732 		if (!inode)
2733 			goto slashes;
2734 		ihold(inode);
2735 		error = mnt_want_write(nd.path.mnt);
2736 		if (error)
2737 			goto exit2;
2738 		error = security_path_unlink(&nd.path, dentry);
2739 		if (error)
2740 			goto exit3;
2741 		error = vfs_unlink(nd.path.dentry->d_inode, dentry);
2742 exit3:
2743 		mnt_drop_write(nd.path.mnt);
2744 	exit2:
2745 		dput(dentry);
2746 	}
2747 	mutex_unlock(&nd.path.dentry->d_inode->i_mutex);
2748 	if (inode)
2749 		iput(inode);	/* truncate the inode here */
2750 exit1:
2751 	path_put(&nd.path);
2752 	putname(name);
2753 	return error;
2754 
2755 slashes:
2756 	error = !dentry->d_inode ? -ENOENT :
2757 		S_ISDIR(dentry->d_inode->i_mode) ? -EISDIR : -ENOTDIR;
2758 	goto exit2;
2759 }
2760 
2761 SYSCALL_DEFINE3(unlinkat, int, dfd, const char __user *, pathname, int, flag)
2762 {
2763 	if ((flag & ~AT_REMOVEDIR) != 0)
2764 		return -EINVAL;
2765 
2766 	if (flag & AT_REMOVEDIR)
2767 		return do_rmdir(dfd, pathname);
2768 
2769 	return do_unlinkat(dfd, pathname);
2770 }
2771 
2772 SYSCALL_DEFINE1(unlink, const char __user *, pathname)
2773 {
2774 	return do_unlinkat(AT_FDCWD, pathname);
2775 }
2776 
2777 int vfs_symlink(struct inode *dir, struct dentry *dentry, const char *oldname)
2778 {
2779 	int error = may_create(dir, dentry);
2780 
2781 	if (error)
2782 		return error;
2783 
2784 	if (!dir->i_op->symlink)
2785 		return -EPERM;
2786 
2787 	error = security_inode_symlink(dir, dentry, oldname);
2788 	if (error)
2789 		return error;
2790 
2791 	error = dir->i_op->symlink(dir, dentry, oldname);
2792 	if (!error)
2793 		fsnotify_create(dir, dentry);
2794 	return error;
2795 }
2796 
2797 SYSCALL_DEFINE3(symlinkat, const char __user *, oldname,
2798 		int, newdfd, const char __user *, newname)
2799 {
2800 	int error;
2801 	char *from;
2802 	char *to;
2803 	struct dentry *dentry;
2804 	struct nameidata nd;
2805 
2806 	from = getname(oldname);
2807 	if (IS_ERR(from))
2808 		return PTR_ERR(from);
2809 
2810 	error = user_path_parent(newdfd, newname, &nd, &to);
2811 	if (error)
2812 		goto out_putname;
2813 
2814 	dentry = lookup_create(&nd, 0);
2815 	error = PTR_ERR(dentry);
2816 	if (IS_ERR(dentry))
2817 		goto out_unlock;
2818 
2819 	error = mnt_want_write(nd.path.mnt);
2820 	if (error)
2821 		goto out_dput;
2822 	error = security_path_symlink(&nd.path, dentry, from);
2823 	if (error)
2824 		goto out_drop_write;
2825 	error = vfs_symlink(nd.path.dentry->d_inode, dentry, from);
2826 out_drop_write:
2827 	mnt_drop_write(nd.path.mnt);
2828 out_dput:
2829 	dput(dentry);
2830 out_unlock:
2831 	mutex_unlock(&nd.path.dentry->d_inode->i_mutex);
2832 	path_put(&nd.path);
2833 	putname(to);
2834 out_putname:
2835 	putname(from);
2836 	return error;
2837 }
2838 
2839 SYSCALL_DEFINE2(symlink, const char __user *, oldname, const char __user *, newname)
2840 {
2841 	return sys_symlinkat(oldname, AT_FDCWD, newname);
2842 }
2843 
2844 int vfs_link(struct dentry *old_dentry, struct inode *dir, struct dentry *new_dentry)
2845 {
2846 	struct inode *inode = old_dentry->d_inode;
2847 	int error;
2848 
2849 	if (!inode)
2850 		return -ENOENT;
2851 
2852 	error = may_create(dir, new_dentry);
2853 	if (error)
2854 		return error;
2855 
2856 	if (dir->i_sb != inode->i_sb)
2857 		return -EXDEV;
2858 
2859 	/*
2860 	 * A link to an append-only or immutable file cannot be created.
2861 	 */
2862 	if (IS_APPEND(inode) || IS_IMMUTABLE(inode))
2863 		return -EPERM;
2864 	if (!dir->i_op->link)
2865 		return -EPERM;
2866 	if (S_ISDIR(inode->i_mode))
2867 		return -EPERM;
2868 
2869 	error = security_inode_link(old_dentry, dir, new_dentry);
2870 	if (error)
2871 		return error;
2872 
2873 	mutex_lock(&inode->i_mutex);
2874 	/* Make sure we don't allow creating hardlink to an unlinked file */
2875 	if (inode->i_nlink == 0)
2876 		error =  -ENOENT;
2877 	else
2878 		error = dir->i_op->link(old_dentry, dir, new_dentry);
2879 	mutex_unlock(&inode->i_mutex);
2880 	if (!error)
2881 		fsnotify_link(dir, inode, new_dentry);
2882 	return error;
2883 }
2884 
2885 /*
2886  * Hardlinks are often used in delicate situations.  We avoid
2887  * security-related surprises by not following symlinks on the
2888  * newname.  --KAB
2889  *
2890  * We don't follow them on the oldname either to be compatible
2891  * with linux 2.0, and to avoid hard-linking to directories
2892  * and other special files.  --ADM
2893  */
2894 SYSCALL_DEFINE5(linkat, int, olddfd, const char __user *, oldname,
2895 		int, newdfd, const char __user *, newname, int, flags)
2896 {
2897 	struct dentry *new_dentry;
2898 	struct nameidata nd;
2899 	struct path old_path;
2900 	int how = 0;
2901 	int error;
2902 	char *to;
2903 
2904 	if ((flags & ~(AT_SYMLINK_FOLLOW | AT_EMPTY_PATH)) != 0)
2905 		return -EINVAL;
2906 	/*
2907 	 * To use null names we require CAP_DAC_READ_SEARCH
2908 	 * This ensures that not everyone will be able to create
2909 	 * handlink using the passed filedescriptor.
2910 	 */
2911 	if (flags & AT_EMPTY_PATH) {
2912 		if (!capable(CAP_DAC_READ_SEARCH))
2913 			return -ENOENT;
2914 		how = LOOKUP_EMPTY;
2915 	}
2916 
2917 	if (flags & AT_SYMLINK_FOLLOW)
2918 		how |= LOOKUP_FOLLOW;
2919 
2920 	error = user_path_at(olddfd, oldname, how, &old_path);
2921 	if (error)
2922 		return error;
2923 
2924 	error = user_path_parent(newdfd, newname, &nd, &to);
2925 	if (error)
2926 		goto out;
2927 	error = -EXDEV;
2928 	if (old_path.mnt != nd.path.mnt)
2929 		goto out_release;
2930 	new_dentry = lookup_create(&nd, 0);
2931 	error = PTR_ERR(new_dentry);
2932 	if (IS_ERR(new_dentry))
2933 		goto out_unlock;
2934 	error = mnt_want_write(nd.path.mnt);
2935 	if (error)
2936 		goto out_dput;
2937 	error = security_path_link(old_path.dentry, &nd.path, new_dentry);
2938 	if (error)
2939 		goto out_drop_write;
2940 	error = vfs_link(old_path.dentry, nd.path.dentry->d_inode, new_dentry);
2941 out_drop_write:
2942 	mnt_drop_write(nd.path.mnt);
2943 out_dput:
2944 	dput(new_dentry);
2945 out_unlock:
2946 	mutex_unlock(&nd.path.dentry->d_inode->i_mutex);
2947 out_release:
2948 	path_put(&nd.path);
2949 	putname(to);
2950 out:
2951 	path_put(&old_path);
2952 
2953 	return error;
2954 }
2955 
2956 SYSCALL_DEFINE2(link, const char __user *, oldname, const char __user *, newname)
2957 {
2958 	return sys_linkat(AT_FDCWD, oldname, AT_FDCWD, newname, 0);
2959 }
2960 
2961 /*
2962  * The worst of all namespace operations - renaming directory. "Perverted"
2963  * doesn't even start to describe it. Somebody in UCB had a heck of a trip...
2964  * Problems:
2965  *	a) we can get into loop creation. Check is done in is_subdir().
2966  *	b) race potential - two innocent renames can create a loop together.
2967  *	   That's where 4.4 screws up. Current fix: serialization on
2968  *	   sb->s_vfs_rename_mutex. We might be more accurate, but that's another
2969  *	   story.
2970  *	c) we have to lock _three_ objects - parents and victim (if it exists).
2971  *	   And that - after we got ->i_mutex on parents (until then we don't know
2972  *	   whether the target exists).  Solution: try to be smart with locking
2973  *	   order for inodes.  We rely on the fact that tree topology may change
2974  *	   only under ->s_vfs_rename_mutex _and_ that parent of the object we
2975  *	   move will be locked.  Thus we can rank directories by the tree
2976  *	   (ancestors first) and rank all non-directories after them.
2977  *	   That works since everybody except rename does "lock parent, lookup,
2978  *	   lock child" and rename is under ->s_vfs_rename_mutex.
2979  *	   HOWEVER, it relies on the assumption that any object with ->lookup()
2980  *	   has no more than 1 dentry.  If "hybrid" objects will ever appear,
2981  *	   we'd better make sure that there's no link(2) for them.
2982  *	d) conversion from fhandle to dentry may come in the wrong moment - when
2983  *	   we are removing the target. Solution: we will have to grab ->i_mutex
2984  *	   in the fhandle_to_dentry code. [FIXME - current nfsfh.c relies on
2985  *	   ->i_mutex on parents, which works but leads to some truly excessive
2986  *	   locking].
2987  */
2988 static int vfs_rename_dir(struct inode *old_dir, struct dentry *old_dentry,
2989 			  struct inode *new_dir, struct dentry *new_dentry)
2990 {
2991 	int error = 0;
2992 	struct inode *target = new_dentry->d_inode;
2993 
2994 	/*
2995 	 * If we are going to change the parent - check write permissions,
2996 	 * we'll need to flip '..'.
2997 	 */
2998 	if (new_dir != old_dir) {
2999 		error = inode_permission(old_dentry->d_inode, MAY_WRITE);
3000 		if (error)
3001 			return error;
3002 	}
3003 
3004 	error = security_inode_rename(old_dir, old_dentry, new_dir, new_dentry);
3005 	if (error)
3006 		return error;
3007 
3008 	if (target)
3009 		mutex_lock(&target->i_mutex);
3010 
3011 	error = -EBUSY;
3012 	if (d_mountpoint(old_dentry) || d_mountpoint(new_dentry))
3013 		goto out;
3014 
3015 	if (target)
3016 		shrink_dcache_parent(new_dentry);
3017 	error = old_dir->i_op->rename(old_dir, old_dentry, new_dir, new_dentry);
3018 	if (error)
3019 		goto out;
3020 
3021 	if (target) {
3022 		target->i_flags |= S_DEAD;
3023 		dont_mount(new_dentry);
3024 	}
3025 out:
3026 	if (target)
3027 		mutex_unlock(&target->i_mutex);
3028 	if (!error)
3029 		if (!(old_dir->i_sb->s_type->fs_flags & FS_RENAME_DOES_D_MOVE))
3030 			d_move(old_dentry,new_dentry);
3031 	return error;
3032 }
3033 
3034 static int vfs_rename_other(struct inode *old_dir, struct dentry *old_dentry,
3035 			    struct inode *new_dir, struct dentry *new_dentry)
3036 {
3037 	struct inode *target = new_dentry->d_inode;
3038 	int error;
3039 
3040 	error = security_inode_rename(old_dir, old_dentry, new_dir, new_dentry);
3041 	if (error)
3042 		return error;
3043 
3044 	dget(new_dentry);
3045 	if (target)
3046 		mutex_lock(&target->i_mutex);
3047 
3048 	error = -EBUSY;
3049 	if (d_mountpoint(old_dentry)||d_mountpoint(new_dentry))
3050 		goto out;
3051 
3052 	error = old_dir->i_op->rename(old_dir, old_dentry, new_dir, new_dentry);
3053 	if (error)
3054 		goto out;
3055 
3056 	if (target)
3057 		dont_mount(new_dentry);
3058 	if (!(old_dir->i_sb->s_type->fs_flags & FS_RENAME_DOES_D_MOVE))
3059 		d_move(old_dentry, new_dentry);
3060 out:
3061 	if (target)
3062 		mutex_unlock(&target->i_mutex);
3063 	dput(new_dentry);
3064 	return error;
3065 }
3066 
3067 int vfs_rename(struct inode *old_dir, struct dentry *old_dentry,
3068 	       struct inode *new_dir, struct dentry *new_dentry)
3069 {
3070 	int error;
3071 	int is_dir = S_ISDIR(old_dentry->d_inode->i_mode);
3072 	const unsigned char *old_name;
3073 
3074 	if (old_dentry->d_inode == new_dentry->d_inode)
3075  		return 0;
3076 
3077 	error = may_delete(old_dir, old_dentry, is_dir);
3078 	if (error)
3079 		return error;
3080 
3081 	if (!new_dentry->d_inode)
3082 		error = may_create(new_dir, new_dentry);
3083 	else
3084 		error = may_delete(new_dir, new_dentry, is_dir);
3085 	if (error)
3086 		return error;
3087 
3088 	if (!old_dir->i_op->rename)
3089 		return -EPERM;
3090 
3091 	old_name = fsnotify_oldname_init(old_dentry->d_name.name);
3092 
3093 	if (is_dir)
3094 		error = vfs_rename_dir(old_dir,old_dentry,new_dir,new_dentry);
3095 	else
3096 		error = vfs_rename_other(old_dir,old_dentry,new_dir,new_dentry);
3097 	if (!error)
3098 		fsnotify_move(old_dir, new_dir, old_name, is_dir,
3099 			      new_dentry->d_inode, old_dentry);
3100 	fsnotify_oldname_free(old_name);
3101 
3102 	return error;
3103 }
3104 
3105 SYSCALL_DEFINE4(renameat, int, olddfd, const char __user *, oldname,
3106 		int, newdfd, const char __user *, newname)
3107 {
3108 	struct dentry *old_dir, *new_dir;
3109 	struct dentry *old_dentry, *new_dentry;
3110 	struct dentry *trap;
3111 	struct nameidata oldnd, newnd;
3112 	char *from;
3113 	char *to;
3114 	int error;
3115 
3116 	error = user_path_parent(olddfd, oldname, &oldnd, &from);
3117 	if (error)
3118 		goto exit;
3119 
3120 	error = user_path_parent(newdfd, newname, &newnd, &to);
3121 	if (error)
3122 		goto exit1;
3123 
3124 	error = -EXDEV;
3125 	if (oldnd.path.mnt != newnd.path.mnt)
3126 		goto exit2;
3127 
3128 	old_dir = oldnd.path.dentry;
3129 	error = -EBUSY;
3130 	if (oldnd.last_type != LAST_NORM)
3131 		goto exit2;
3132 
3133 	new_dir = newnd.path.dentry;
3134 	if (newnd.last_type != LAST_NORM)
3135 		goto exit2;
3136 
3137 	oldnd.flags &= ~LOOKUP_PARENT;
3138 	newnd.flags &= ~LOOKUP_PARENT;
3139 	newnd.flags |= LOOKUP_RENAME_TARGET;
3140 
3141 	trap = lock_rename(new_dir, old_dir);
3142 
3143 	old_dentry = lookup_hash(&oldnd);
3144 	error = PTR_ERR(old_dentry);
3145 	if (IS_ERR(old_dentry))
3146 		goto exit3;
3147 	/* source must exist */
3148 	error = -ENOENT;
3149 	if (!old_dentry->d_inode)
3150 		goto exit4;
3151 	/* unless the source is a directory trailing slashes give -ENOTDIR */
3152 	if (!S_ISDIR(old_dentry->d_inode->i_mode)) {
3153 		error = -ENOTDIR;
3154 		if (oldnd.last.name[oldnd.last.len])
3155 			goto exit4;
3156 		if (newnd.last.name[newnd.last.len])
3157 			goto exit4;
3158 	}
3159 	/* source should not be ancestor of target */
3160 	error = -EINVAL;
3161 	if (old_dentry == trap)
3162 		goto exit4;
3163 	new_dentry = lookup_hash(&newnd);
3164 	error = PTR_ERR(new_dentry);
3165 	if (IS_ERR(new_dentry))
3166 		goto exit4;
3167 	/* target should not be an ancestor of source */
3168 	error = -ENOTEMPTY;
3169 	if (new_dentry == trap)
3170 		goto exit5;
3171 
3172 	error = mnt_want_write(oldnd.path.mnt);
3173 	if (error)
3174 		goto exit5;
3175 	error = security_path_rename(&oldnd.path, old_dentry,
3176 				     &newnd.path, new_dentry);
3177 	if (error)
3178 		goto exit6;
3179 	error = vfs_rename(old_dir->d_inode, old_dentry,
3180 				   new_dir->d_inode, new_dentry);
3181 exit6:
3182 	mnt_drop_write(oldnd.path.mnt);
3183 exit5:
3184 	dput(new_dentry);
3185 exit4:
3186 	dput(old_dentry);
3187 exit3:
3188 	unlock_rename(new_dir, old_dir);
3189 exit2:
3190 	path_put(&newnd.path);
3191 	putname(to);
3192 exit1:
3193 	path_put(&oldnd.path);
3194 	putname(from);
3195 exit:
3196 	return error;
3197 }
3198 
3199 SYSCALL_DEFINE2(rename, const char __user *, oldname, const char __user *, newname)
3200 {
3201 	return sys_renameat(AT_FDCWD, oldname, AT_FDCWD, newname);
3202 }
3203 
3204 int vfs_readlink(struct dentry *dentry, char __user *buffer, int buflen, const char *link)
3205 {
3206 	int len;
3207 
3208 	len = PTR_ERR(link);
3209 	if (IS_ERR(link))
3210 		goto out;
3211 
3212 	len = strlen(link);
3213 	if (len > (unsigned) buflen)
3214 		len = buflen;
3215 	if (copy_to_user(buffer, link, len))
3216 		len = -EFAULT;
3217 out:
3218 	return len;
3219 }
3220 
3221 /*
3222  * A helper for ->readlink().  This should be used *ONLY* for symlinks that
3223  * have ->follow_link() touching nd only in nd_set_link().  Using (or not
3224  * using) it for any given inode is up to filesystem.
3225  */
3226 int generic_readlink(struct dentry *dentry, char __user *buffer, int buflen)
3227 {
3228 	struct nameidata nd;
3229 	void *cookie;
3230 	int res;
3231 
3232 	nd.depth = 0;
3233 	cookie = dentry->d_inode->i_op->follow_link(dentry, &nd);
3234 	if (IS_ERR(cookie))
3235 		return PTR_ERR(cookie);
3236 
3237 	res = vfs_readlink(dentry, buffer, buflen, nd_get_link(&nd));
3238 	if (dentry->d_inode->i_op->put_link)
3239 		dentry->d_inode->i_op->put_link(dentry, &nd, cookie);
3240 	return res;
3241 }
3242 
3243 int vfs_follow_link(struct nameidata *nd, const char *link)
3244 {
3245 	return __vfs_follow_link(nd, link);
3246 }
3247 
3248 /* get the link contents into pagecache */
3249 static char *page_getlink(struct dentry * dentry, struct page **ppage)
3250 {
3251 	char *kaddr;
3252 	struct page *page;
3253 	struct address_space *mapping = dentry->d_inode->i_mapping;
3254 	page = read_mapping_page(mapping, 0, NULL);
3255 	if (IS_ERR(page))
3256 		return (char*)page;
3257 	*ppage = page;
3258 	kaddr = kmap(page);
3259 	nd_terminate_link(kaddr, dentry->d_inode->i_size, PAGE_SIZE - 1);
3260 	return kaddr;
3261 }
3262 
3263 int page_readlink(struct dentry *dentry, char __user *buffer, int buflen)
3264 {
3265 	struct page *page = NULL;
3266 	char *s = page_getlink(dentry, &page);
3267 	int res = vfs_readlink(dentry,buffer,buflen,s);
3268 	if (page) {
3269 		kunmap(page);
3270 		page_cache_release(page);
3271 	}
3272 	return res;
3273 }
3274 
3275 void *page_follow_link_light(struct dentry *dentry, struct nameidata *nd)
3276 {
3277 	struct page *page = NULL;
3278 	nd_set_link(nd, page_getlink(dentry, &page));
3279 	return page;
3280 }
3281 
3282 void page_put_link(struct dentry *dentry, struct nameidata *nd, void *cookie)
3283 {
3284 	struct page *page = cookie;
3285 
3286 	if (page) {
3287 		kunmap(page);
3288 		page_cache_release(page);
3289 	}
3290 }
3291 
3292 /*
3293  * The nofs argument instructs pagecache_write_begin to pass AOP_FLAG_NOFS
3294  */
3295 int __page_symlink(struct inode *inode, const char *symname, int len, int nofs)
3296 {
3297 	struct address_space *mapping = inode->i_mapping;
3298 	struct page *page;
3299 	void *fsdata;
3300 	int err;
3301 	char *kaddr;
3302 	unsigned int flags = AOP_FLAG_UNINTERRUPTIBLE;
3303 	if (nofs)
3304 		flags |= AOP_FLAG_NOFS;
3305 
3306 retry:
3307 	err = pagecache_write_begin(NULL, mapping, 0, len-1,
3308 				flags, &page, &fsdata);
3309 	if (err)
3310 		goto fail;
3311 
3312 	kaddr = kmap_atomic(page, KM_USER0);
3313 	memcpy(kaddr, symname, len-1);
3314 	kunmap_atomic(kaddr, KM_USER0);
3315 
3316 	err = pagecache_write_end(NULL, mapping, 0, len-1, len-1,
3317 							page, fsdata);
3318 	if (err < 0)
3319 		goto fail;
3320 	if (err < len-1)
3321 		goto retry;
3322 
3323 	mark_inode_dirty(inode);
3324 	return 0;
3325 fail:
3326 	return err;
3327 }
3328 
3329 int page_symlink(struct inode *inode, const char *symname, int len)
3330 {
3331 	return __page_symlink(inode, symname, len,
3332 			!(mapping_gfp_mask(inode->i_mapping) & __GFP_FS));
3333 }
3334 
3335 const struct inode_operations page_symlink_inode_operations = {
3336 	.readlink	= generic_readlink,
3337 	.follow_link	= page_follow_link_light,
3338 	.put_link	= page_put_link,
3339 };
3340 
3341 EXPORT_SYMBOL(user_path_at);
3342 EXPORT_SYMBOL(follow_down_one);
3343 EXPORT_SYMBOL(follow_down);
3344 EXPORT_SYMBOL(follow_up);
3345 EXPORT_SYMBOL(get_write_access); /* binfmt_aout */
3346 EXPORT_SYMBOL(getname);
3347 EXPORT_SYMBOL(lock_rename);
3348 EXPORT_SYMBOL(lookup_one_len);
3349 EXPORT_SYMBOL(page_follow_link_light);
3350 EXPORT_SYMBOL(page_put_link);
3351 EXPORT_SYMBOL(page_readlink);
3352 EXPORT_SYMBOL(__page_symlink);
3353 EXPORT_SYMBOL(page_symlink);
3354 EXPORT_SYMBOL(page_symlink_inode_operations);
3355 EXPORT_SYMBOL(kern_path_parent);
3356 EXPORT_SYMBOL(kern_path);
3357 EXPORT_SYMBOL(vfs_path_lookup);
3358 EXPORT_SYMBOL(inode_permission);
3359 EXPORT_SYMBOL(file_permission);
3360 EXPORT_SYMBOL(unlock_rename);
3361 EXPORT_SYMBOL(vfs_create);
3362 EXPORT_SYMBOL(vfs_follow_link);
3363 EXPORT_SYMBOL(vfs_link);
3364 EXPORT_SYMBOL(vfs_mkdir);
3365 EXPORT_SYMBOL(vfs_mknod);
3366 EXPORT_SYMBOL(generic_permission);
3367 EXPORT_SYMBOL(vfs_readlink);
3368 EXPORT_SYMBOL(vfs_rename);
3369 EXPORT_SYMBOL(vfs_rmdir);
3370 EXPORT_SYMBOL(vfs_symlink);
3371 EXPORT_SYMBOL(vfs_unlink);
3372 EXPORT_SYMBOL(dentry_unhash);
3373 EXPORT_SYMBOL(generic_readlink);
3374