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