xref: /openbmc/linux/fs/namei.c (revision 9d56dd3b083a3bec56e9da35ce07baca81030b03)
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  * Name resolution.
827  * This is the basic name resolution function, turning a pathname into
828  * the final dentry. We expect 'base' to be positive and a directory.
829  *
830  * Returns 0 and nd will have valid dentry and mnt on success.
831  * Returns error and drops reference to input namei data on failure.
832  */
833 static int link_path_walk(const char *name, struct nameidata *nd)
834 {
835 	struct path next;
836 	struct inode *inode;
837 	int err;
838 	unsigned int lookup_flags = nd->flags;
839 
840 	while (*name=='/')
841 		name++;
842 	if (!*name)
843 		goto return_reval;
844 
845 	inode = nd->path.dentry->d_inode;
846 	if (nd->depth)
847 		lookup_flags = LOOKUP_FOLLOW | (nd->flags & LOOKUP_CONTINUE);
848 
849 	/* At this point we know we have a real path component. */
850 	for(;;) {
851 		unsigned long hash;
852 		struct qstr this;
853 		unsigned int c;
854 
855 		nd->flags |= LOOKUP_CONTINUE;
856 		err = exec_permission(inode);
857  		if (err)
858 			break;
859 
860 		this.name = name;
861 		c = *(const unsigned char *)name;
862 
863 		hash = init_name_hash();
864 		do {
865 			name++;
866 			hash = partial_name_hash(c, hash);
867 			c = *(const unsigned char *)name;
868 		} while (c && (c != '/'));
869 		this.len = name - (const char *) this.name;
870 		this.hash = end_name_hash(hash);
871 
872 		/* remove trailing slashes? */
873 		if (!c)
874 			goto last_component;
875 		while (*++name == '/');
876 		if (!*name)
877 			goto last_with_slashes;
878 
879 		/*
880 		 * "." and ".." are special - ".." especially so because it has
881 		 * to be able to know about the current root directory and
882 		 * parent relationships.
883 		 */
884 		if (this.name[0] == '.') switch (this.len) {
885 			default:
886 				break;
887 			case 2:
888 				if (this.name[1] != '.')
889 					break;
890 				follow_dotdot(nd);
891 				inode = nd->path.dentry->d_inode;
892 				/* fallthrough */
893 			case 1:
894 				continue;
895 		}
896 		/* This does the actual lookups.. */
897 		err = do_lookup(nd, &this, &next);
898 		if (err)
899 			break;
900 
901 		err = -ENOENT;
902 		inode = next.dentry->d_inode;
903 		if (!inode)
904 			goto out_dput;
905 
906 		if (inode->i_op->follow_link) {
907 			err = do_follow_link(&next, nd);
908 			if (err)
909 				goto return_err;
910 			err = -ENOENT;
911 			inode = nd->path.dentry->d_inode;
912 			if (!inode)
913 				break;
914 		} else
915 			path_to_nameidata(&next, nd);
916 		err = -ENOTDIR;
917 		if (!inode->i_op->lookup)
918 			break;
919 		continue;
920 		/* here ends the main loop */
921 
922 last_with_slashes:
923 		lookup_flags |= LOOKUP_FOLLOW | LOOKUP_DIRECTORY;
924 last_component:
925 		/* Clear LOOKUP_CONTINUE iff it was previously unset */
926 		nd->flags &= lookup_flags | ~LOOKUP_CONTINUE;
927 		if (lookup_flags & LOOKUP_PARENT)
928 			goto lookup_parent;
929 		if (this.name[0] == '.') switch (this.len) {
930 			default:
931 				break;
932 			case 2:
933 				if (this.name[1] != '.')
934 					break;
935 				follow_dotdot(nd);
936 				inode = nd->path.dentry->d_inode;
937 				/* fallthrough */
938 			case 1:
939 				goto return_reval;
940 		}
941 		err = do_lookup(nd, &this, &next);
942 		if (err)
943 			break;
944 		inode = next.dentry->d_inode;
945 		if ((lookup_flags & LOOKUP_FOLLOW)
946 		    && inode && inode->i_op->follow_link) {
947 			err = do_follow_link(&next, nd);
948 			if (err)
949 				goto return_err;
950 			inode = nd->path.dentry->d_inode;
951 		} else
952 			path_to_nameidata(&next, nd);
953 		err = -ENOENT;
954 		if (!inode)
955 			break;
956 		if (lookup_flags & LOOKUP_DIRECTORY) {
957 			err = -ENOTDIR;
958 			if (!inode->i_op->lookup)
959 				break;
960 		}
961 		goto return_base;
962 lookup_parent:
963 		nd->last = this;
964 		nd->last_type = LAST_NORM;
965 		if (this.name[0] != '.')
966 			goto return_base;
967 		if (this.len == 1)
968 			nd->last_type = LAST_DOT;
969 		else if (this.len == 2 && this.name[1] == '.')
970 			nd->last_type = LAST_DOTDOT;
971 		else
972 			goto return_base;
973 return_reval:
974 		/*
975 		 * We bypassed the ordinary revalidation routines.
976 		 * We may need to check the cached dentry for staleness.
977 		 */
978 		if (nd->path.dentry && nd->path.dentry->d_sb &&
979 		    (nd->path.dentry->d_sb->s_type->fs_flags & FS_REVAL_DOT)) {
980 			err = -ESTALE;
981 			/* Note: we do not d_invalidate() */
982 			if (!nd->path.dentry->d_op->d_revalidate(
983 					nd->path.dentry, nd))
984 				break;
985 		}
986 return_base:
987 		return 0;
988 out_dput:
989 		path_put_conditional(&next, nd);
990 		break;
991 	}
992 	path_put(&nd->path);
993 return_err:
994 	return err;
995 }
996 
997 static int path_walk(const char *name, struct nameidata *nd)
998 {
999 	struct path save = nd->path;
1000 	int result;
1001 
1002 	current->total_link_count = 0;
1003 
1004 	/* make sure the stuff we saved doesn't go away */
1005 	path_get(&save);
1006 
1007 	result = link_path_walk(name, nd);
1008 	if (result == -ESTALE) {
1009 		/* nd->path had been dropped */
1010 		current->total_link_count = 0;
1011 		nd->path = save;
1012 		path_get(&nd->path);
1013 		nd->flags |= LOOKUP_REVAL;
1014 		result = link_path_walk(name, nd);
1015 	}
1016 
1017 	path_put(&save);
1018 
1019 	return result;
1020 }
1021 
1022 static int path_init(int dfd, const char *name, unsigned int flags, struct nameidata *nd)
1023 {
1024 	int retval = 0;
1025 	int fput_needed;
1026 	struct file *file;
1027 
1028 	nd->last_type = LAST_ROOT; /* if there are only slashes... */
1029 	nd->flags = flags;
1030 	nd->depth = 0;
1031 	nd->root.mnt = NULL;
1032 
1033 	if (*name=='/') {
1034 		set_root(nd);
1035 		nd->path = nd->root;
1036 		path_get(&nd->root);
1037 	} else if (dfd == AT_FDCWD) {
1038 		struct fs_struct *fs = current->fs;
1039 		read_lock(&fs->lock);
1040 		nd->path = fs->pwd;
1041 		path_get(&fs->pwd);
1042 		read_unlock(&fs->lock);
1043 	} else {
1044 		struct dentry *dentry;
1045 
1046 		file = fget_light(dfd, &fput_needed);
1047 		retval = -EBADF;
1048 		if (!file)
1049 			goto out_fail;
1050 
1051 		dentry = file->f_path.dentry;
1052 
1053 		retval = -ENOTDIR;
1054 		if (!S_ISDIR(dentry->d_inode->i_mode))
1055 			goto fput_fail;
1056 
1057 		retval = file_permission(file, MAY_EXEC);
1058 		if (retval)
1059 			goto fput_fail;
1060 
1061 		nd->path = file->f_path;
1062 		path_get(&file->f_path);
1063 
1064 		fput_light(file, fput_needed);
1065 	}
1066 	return 0;
1067 
1068 fput_fail:
1069 	fput_light(file, fput_needed);
1070 out_fail:
1071 	return retval;
1072 }
1073 
1074 /* Returns 0 and nd will be valid on success; Retuns error, otherwise. */
1075 static int do_path_lookup(int dfd, const char *name,
1076 				unsigned int flags, struct nameidata *nd)
1077 {
1078 	int retval = path_init(dfd, name, flags, nd);
1079 	if (!retval)
1080 		retval = path_walk(name, nd);
1081 	if (unlikely(!retval && !audit_dummy_context() && nd->path.dentry &&
1082 				nd->path.dentry->d_inode))
1083 		audit_inode(name, nd->path.dentry);
1084 	if (nd->root.mnt) {
1085 		path_put(&nd->root);
1086 		nd->root.mnt = NULL;
1087 	}
1088 	return retval;
1089 }
1090 
1091 int path_lookup(const char *name, unsigned int flags,
1092 			struct nameidata *nd)
1093 {
1094 	return do_path_lookup(AT_FDCWD, name, flags, nd);
1095 }
1096 
1097 int kern_path(const char *name, unsigned int flags, struct path *path)
1098 {
1099 	struct nameidata nd;
1100 	int res = do_path_lookup(AT_FDCWD, name, flags, &nd);
1101 	if (!res)
1102 		*path = nd.path;
1103 	return res;
1104 }
1105 
1106 /**
1107  * vfs_path_lookup - lookup a file path relative to a dentry-vfsmount pair
1108  * @dentry:  pointer to dentry of the base directory
1109  * @mnt: pointer to vfs mount of the base directory
1110  * @name: pointer to file name
1111  * @flags: lookup flags
1112  * @nd: pointer to nameidata
1113  */
1114 int vfs_path_lookup(struct dentry *dentry, struct vfsmount *mnt,
1115 		    const char *name, unsigned int flags,
1116 		    struct nameidata *nd)
1117 {
1118 	int retval;
1119 
1120 	/* same as do_path_lookup */
1121 	nd->last_type = LAST_ROOT;
1122 	nd->flags = flags;
1123 	nd->depth = 0;
1124 
1125 	nd->path.dentry = dentry;
1126 	nd->path.mnt = mnt;
1127 	path_get(&nd->path);
1128 	nd->root = nd->path;
1129 	path_get(&nd->root);
1130 
1131 	retval = path_walk(name, nd);
1132 	if (unlikely(!retval && !audit_dummy_context() && nd->path.dentry &&
1133 				nd->path.dentry->d_inode))
1134 		audit_inode(name, nd->path.dentry);
1135 
1136 	path_put(&nd->root);
1137 	nd->root.mnt = NULL;
1138 
1139 	return retval;
1140 }
1141 
1142 static struct dentry *__lookup_hash(struct qstr *name,
1143 		struct dentry *base, struct nameidata *nd)
1144 {
1145 	struct dentry *dentry;
1146 	struct inode *inode;
1147 	int err;
1148 
1149 	inode = base->d_inode;
1150 
1151 	/*
1152 	 * See if the low-level filesystem might want
1153 	 * to use its own hash..
1154 	 */
1155 	if (base->d_op && base->d_op->d_hash) {
1156 		err = base->d_op->d_hash(base, name);
1157 		dentry = ERR_PTR(err);
1158 		if (err < 0)
1159 			goto out;
1160 	}
1161 
1162 	dentry = __d_lookup(base, name);
1163 
1164 	/* lockess __d_lookup may fail due to concurrent d_move()
1165 	 * in some unrelated directory, so try with d_lookup
1166 	 */
1167 	if (!dentry)
1168 		dentry = d_lookup(base, name);
1169 
1170 	if (dentry && dentry->d_op && dentry->d_op->d_revalidate)
1171 		dentry = do_revalidate(dentry, nd);
1172 
1173 	if (!dentry) {
1174 		struct dentry *new;
1175 
1176 		/* Don't create child dentry for a dead directory. */
1177 		dentry = ERR_PTR(-ENOENT);
1178 		if (IS_DEADDIR(inode))
1179 			goto out;
1180 
1181 		new = d_alloc(base, name);
1182 		dentry = ERR_PTR(-ENOMEM);
1183 		if (!new)
1184 			goto out;
1185 		dentry = inode->i_op->lookup(inode, new, nd);
1186 		if (!dentry)
1187 			dentry = new;
1188 		else
1189 			dput(new);
1190 	}
1191 out:
1192 	return dentry;
1193 }
1194 
1195 /*
1196  * Restricted form of lookup. Doesn't follow links, single-component only,
1197  * needs parent already locked. Doesn't follow mounts.
1198  * SMP-safe.
1199  */
1200 static struct dentry *lookup_hash(struct nameidata *nd)
1201 {
1202 	int err;
1203 
1204 	err = exec_permission(nd->path.dentry->d_inode);
1205 	if (err)
1206 		return ERR_PTR(err);
1207 	return __lookup_hash(&nd->last, nd->path.dentry, nd);
1208 }
1209 
1210 static int __lookup_one_len(const char *name, struct qstr *this,
1211 		struct dentry *base, int len)
1212 {
1213 	unsigned long hash;
1214 	unsigned int c;
1215 
1216 	this->name = name;
1217 	this->len = len;
1218 	if (!len)
1219 		return -EACCES;
1220 
1221 	hash = init_name_hash();
1222 	while (len--) {
1223 		c = *(const unsigned char *)name++;
1224 		if (c == '/' || c == '\0')
1225 			return -EACCES;
1226 		hash = partial_name_hash(c, hash);
1227 	}
1228 	this->hash = end_name_hash(hash);
1229 	return 0;
1230 }
1231 
1232 /**
1233  * lookup_one_len - filesystem helper to lookup single pathname component
1234  * @name:	pathname component to lookup
1235  * @base:	base directory to lookup from
1236  * @len:	maximum length @len should be interpreted to
1237  *
1238  * Note that this routine is purely a helper for filesystem usage and should
1239  * not be called by generic code.  Also note that by using this function the
1240  * nameidata argument is passed to the filesystem methods and a filesystem
1241  * using this helper needs to be prepared for that.
1242  */
1243 struct dentry *lookup_one_len(const char *name, struct dentry *base, int len)
1244 {
1245 	int err;
1246 	struct qstr this;
1247 
1248 	WARN_ON_ONCE(!mutex_is_locked(&base->d_inode->i_mutex));
1249 
1250 	err = __lookup_one_len(name, &this, base, len);
1251 	if (err)
1252 		return ERR_PTR(err);
1253 
1254 	err = exec_permission(base->d_inode);
1255 	if (err)
1256 		return ERR_PTR(err);
1257 	return __lookup_hash(&this, base, NULL);
1258 }
1259 
1260 int user_path_at(int dfd, const char __user *name, unsigned flags,
1261 		 struct path *path)
1262 {
1263 	struct nameidata nd;
1264 	char *tmp = getname(name);
1265 	int err = PTR_ERR(tmp);
1266 	if (!IS_ERR(tmp)) {
1267 
1268 		BUG_ON(flags & LOOKUP_PARENT);
1269 
1270 		err = do_path_lookup(dfd, tmp, flags, &nd);
1271 		putname(tmp);
1272 		if (!err)
1273 			*path = nd.path;
1274 	}
1275 	return err;
1276 }
1277 
1278 static int user_path_parent(int dfd, const char __user *path,
1279 			struct nameidata *nd, char **name)
1280 {
1281 	char *s = getname(path);
1282 	int error;
1283 
1284 	if (IS_ERR(s))
1285 		return PTR_ERR(s);
1286 
1287 	error = do_path_lookup(dfd, s, LOOKUP_PARENT, nd);
1288 	if (error)
1289 		putname(s);
1290 	else
1291 		*name = s;
1292 
1293 	return error;
1294 }
1295 
1296 /*
1297  * It's inline, so penalty for filesystems that don't use sticky bit is
1298  * minimal.
1299  */
1300 static inline int check_sticky(struct inode *dir, struct inode *inode)
1301 {
1302 	uid_t fsuid = current_fsuid();
1303 
1304 	if (!(dir->i_mode & S_ISVTX))
1305 		return 0;
1306 	if (inode->i_uid == fsuid)
1307 		return 0;
1308 	if (dir->i_uid == fsuid)
1309 		return 0;
1310 	return !capable(CAP_FOWNER);
1311 }
1312 
1313 /*
1314  *	Check whether we can remove a link victim from directory dir, check
1315  *  whether the type of victim is right.
1316  *  1. We can't do it if dir is read-only (done in permission())
1317  *  2. We should have write and exec permissions on dir
1318  *  3. We can't remove anything from append-only dir
1319  *  4. We can't do anything with immutable dir (done in permission())
1320  *  5. If the sticky bit on dir is set we should either
1321  *	a. be owner of dir, or
1322  *	b. be owner of victim, or
1323  *	c. have CAP_FOWNER capability
1324  *  6. If the victim is append-only or immutable we can't do antyhing with
1325  *     links pointing to it.
1326  *  7. If we were asked to remove a directory and victim isn't one - ENOTDIR.
1327  *  8. If we were asked to remove a non-directory and victim isn't one - EISDIR.
1328  *  9. We can't remove a root or mountpoint.
1329  * 10. We don't allow removal of NFS sillyrenamed files; it's handled by
1330  *     nfs_async_unlink().
1331  */
1332 static int may_delete(struct inode *dir,struct dentry *victim,int isdir)
1333 {
1334 	int error;
1335 
1336 	if (!victim->d_inode)
1337 		return -ENOENT;
1338 
1339 	BUG_ON(victim->d_parent->d_inode != dir);
1340 	audit_inode_child(victim->d_name.name, victim, dir);
1341 
1342 	error = inode_permission(dir, MAY_WRITE | MAY_EXEC);
1343 	if (error)
1344 		return error;
1345 	if (IS_APPEND(dir))
1346 		return -EPERM;
1347 	if (check_sticky(dir, victim->d_inode)||IS_APPEND(victim->d_inode)||
1348 	    IS_IMMUTABLE(victim->d_inode) || IS_SWAPFILE(victim->d_inode))
1349 		return -EPERM;
1350 	if (isdir) {
1351 		if (!S_ISDIR(victim->d_inode->i_mode))
1352 			return -ENOTDIR;
1353 		if (IS_ROOT(victim))
1354 			return -EBUSY;
1355 	} else if (S_ISDIR(victim->d_inode->i_mode))
1356 		return -EISDIR;
1357 	if (IS_DEADDIR(dir))
1358 		return -ENOENT;
1359 	if (victim->d_flags & DCACHE_NFSFS_RENAMED)
1360 		return -EBUSY;
1361 	return 0;
1362 }
1363 
1364 /*	Check whether we can create an object with dentry child in directory
1365  *  dir.
1366  *  1. We can't do it if child already exists (open has special treatment for
1367  *     this case, but since we are inlined it's OK)
1368  *  2. We can't do it if dir is read-only (done in permission())
1369  *  3. We should have write and exec permissions on dir
1370  *  4. We can't do it if dir is immutable (done in permission())
1371  */
1372 static inline int may_create(struct inode *dir, struct dentry *child)
1373 {
1374 	if (child->d_inode)
1375 		return -EEXIST;
1376 	if (IS_DEADDIR(dir))
1377 		return -ENOENT;
1378 	return inode_permission(dir, MAY_WRITE | MAY_EXEC);
1379 }
1380 
1381 /*
1382  * O_DIRECTORY translates into forcing a directory lookup.
1383  */
1384 static inline int lookup_flags(unsigned int f)
1385 {
1386 	unsigned long retval = LOOKUP_FOLLOW;
1387 
1388 	if (f & O_NOFOLLOW)
1389 		retval &= ~LOOKUP_FOLLOW;
1390 
1391 	if (f & O_DIRECTORY)
1392 		retval |= LOOKUP_DIRECTORY;
1393 
1394 	return retval;
1395 }
1396 
1397 /*
1398  * p1 and p2 should be directories on the same fs.
1399  */
1400 struct dentry *lock_rename(struct dentry *p1, struct dentry *p2)
1401 {
1402 	struct dentry *p;
1403 
1404 	if (p1 == p2) {
1405 		mutex_lock_nested(&p1->d_inode->i_mutex, I_MUTEX_PARENT);
1406 		return NULL;
1407 	}
1408 
1409 	mutex_lock(&p1->d_inode->i_sb->s_vfs_rename_mutex);
1410 
1411 	p = d_ancestor(p2, p1);
1412 	if (p) {
1413 		mutex_lock_nested(&p2->d_inode->i_mutex, I_MUTEX_PARENT);
1414 		mutex_lock_nested(&p1->d_inode->i_mutex, I_MUTEX_CHILD);
1415 		return p;
1416 	}
1417 
1418 	p = d_ancestor(p1, p2);
1419 	if (p) {
1420 		mutex_lock_nested(&p1->d_inode->i_mutex, I_MUTEX_PARENT);
1421 		mutex_lock_nested(&p2->d_inode->i_mutex, I_MUTEX_CHILD);
1422 		return p;
1423 	}
1424 
1425 	mutex_lock_nested(&p1->d_inode->i_mutex, I_MUTEX_PARENT);
1426 	mutex_lock_nested(&p2->d_inode->i_mutex, I_MUTEX_CHILD);
1427 	return NULL;
1428 }
1429 
1430 void unlock_rename(struct dentry *p1, struct dentry *p2)
1431 {
1432 	mutex_unlock(&p1->d_inode->i_mutex);
1433 	if (p1 != p2) {
1434 		mutex_unlock(&p2->d_inode->i_mutex);
1435 		mutex_unlock(&p1->d_inode->i_sb->s_vfs_rename_mutex);
1436 	}
1437 }
1438 
1439 int vfs_create(struct inode *dir, struct dentry *dentry, int mode,
1440 		struct nameidata *nd)
1441 {
1442 	int error = may_create(dir, dentry);
1443 
1444 	if (error)
1445 		return error;
1446 
1447 	if (!dir->i_op->create)
1448 		return -EACCES;	/* shouldn't it be ENOSYS? */
1449 	mode &= S_IALLUGO;
1450 	mode |= S_IFREG;
1451 	error = security_inode_create(dir, dentry, mode);
1452 	if (error)
1453 		return error;
1454 	vfs_dq_init(dir);
1455 	error = dir->i_op->create(dir, dentry, mode, nd);
1456 	if (!error)
1457 		fsnotify_create(dir, dentry);
1458 	return error;
1459 }
1460 
1461 int may_open(struct path *path, int acc_mode, int flag)
1462 {
1463 	struct dentry *dentry = path->dentry;
1464 	struct inode *inode = dentry->d_inode;
1465 	int error;
1466 
1467 	if (!inode)
1468 		return -ENOENT;
1469 
1470 	switch (inode->i_mode & S_IFMT) {
1471 	case S_IFLNK:
1472 		return -ELOOP;
1473 	case S_IFDIR:
1474 		if (acc_mode & MAY_WRITE)
1475 			return -EISDIR;
1476 		break;
1477 	case S_IFBLK:
1478 	case S_IFCHR:
1479 		if (path->mnt->mnt_flags & MNT_NODEV)
1480 			return -EACCES;
1481 		/*FALLTHRU*/
1482 	case S_IFIFO:
1483 	case S_IFSOCK:
1484 		flag &= ~O_TRUNC;
1485 		break;
1486 	}
1487 
1488 	error = inode_permission(inode, acc_mode);
1489 	if (error)
1490 		return error;
1491 
1492 	/*
1493 	 * An append-only file must be opened in append mode for writing.
1494 	 */
1495 	if (IS_APPEND(inode)) {
1496 		if  ((flag & FMODE_WRITE) && !(flag & O_APPEND))
1497 			return -EPERM;
1498 		if (flag & O_TRUNC)
1499 			return -EPERM;
1500 	}
1501 
1502 	/* O_NOATIME can only be set by the owner or superuser */
1503 	if (flag & O_NOATIME && !is_owner_or_cap(inode))
1504 		return -EPERM;
1505 
1506 	/*
1507 	 * Ensure there are no outstanding leases on the file.
1508 	 */
1509 	return break_lease(inode, flag);
1510 }
1511 
1512 static int handle_truncate(struct path *path)
1513 {
1514 	struct inode *inode = path->dentry->d_inode;
1515 	int error = get_write_access(inode);
1516 	if (error)
1517 		return error;
1518 	/*
1519 	 * Refuse to truncate files with mandatory locks held on them.
1520 	 */
1521 	error = locks_verify_locked(inode);
1522 	if (!error)
1523 		error = security_path_truncate(path, 0,
1524 				       ATTR_MTIME|ATTR_CTIME|ATTR_OPEN);
1525 	if (!error) {
1526 		error = do_truncate(path->dentry, 0,
1527 				    ATTR_MTIME|ATTR_CTIME|ATTR_OPEN,
1528 				    NULL);
1529 	}
1530 	put_write_access(inode);
1531 	return error;
1532 }
1533 
1534 /*
1535  * Be careful about ever adding any more callers of this
1536  * function.  Its flags must be in the namei format, not
1537  * what get passed to sys_open().
1538  */
1539 static int __open_namei_create(struct nameidata *nd, struct path *path,
1540 				int flag, int mode)
1541 {
1542 	int error;
1543 	struct dentry *dir = nd->path.dentry;
1544 
1545 	if (!IS_POSIXACL(dir->d_inode))
1546 		mode &= ~current_umask();
1547 	error = security_path_mknod(&nd->path, path->dentry, mode, 0);
1548 	if (error)
1549 		goto out_unlock;
1550 	error = vfs_create(dir->d_inode, path->dentry, mode, nd);
1551 out_unlock:
1552 	mutex_unlock(&dir->d_inode->i_mutex);
1553 	dput(nd->path.dentry);
1554 	nd->path.dentry = path->dentry;
1555 	if (error)
1556 		return error;
1557 	/* Don't check for write permission, don't truncate */
1558 	return may_open(&nd->path, 0, flag & ~O_TRUNC);
1559 }
1560 
1561 /*
1562  * Note that while the flag value (low two bits) for sys_open means:
1563  *	00 - read-only
1564  *	01 - write-only
1565  *	10 - read-write
1566  *	11 - special
1567  * it is changed into
1568  *	00 - no permissions needed
1569  *	01 - read-permission
1570  *	10 - write-permission
1571  *	11 - read-write
1572  * for the internal routines (ie open_namei()/follow_link() etc)
1573  * This is more logical, and also allows the 00 "no perm needed"
1574  * to be used for symlinks (where the permissions are checked
1575  * later).
1576  *
1577 */
1578 static inline int open_to_namei_flags(int flag)
1579 {
1580 	if ((flag+1) & O_ACCMODE)
1581 		flag++;
1582 	return flag;
1583 }
1584 
1585 static int open_will_truncate(int flag, struct inode *inode)
1586 {
1587 	/*
1588 	 * We'll never write to the fs underlying
1589 	 * a device file.
1590 	 */
1591 	if (special_file(inode->i_mode))
1592 		return 0;
1593 	return (flag & O_TRUNC);
1594 }
1595 
1596 /*
1597  * Note that the low bits of the passed in "open_flag"
1598  * are not the same as in the local variable "flag". See
1599  * open_to_namei_flags() for more details.
1600  */
1601 struct file *do_filp_open(int dfd, const char *pathname,
1602 		int open_flag, int mode, int acc_mode)
1603 {
1604 	struct file *filp;
1605 	struct nameidata nd;
1606 	int error;
1607 	struct path path;
1608 	struct dentry *dir;
1609 	int count = 0;
1610 	int will_truncate;
1611 	int flag = open_to_namei_flags(open_flag);
1612 	int force_reval = 0;
1613 
1614 	/*
1615 	 * O_SYNC is implemented as __O_SYNC|O_DSYNC.  As many places only
1616 	 * check for O_DSYNC if the need any syncing at all we enforce it's
1617 	 * always set instead of having to deal with possibly weird behaviour
1618 	 * for malicious applications setting only __O_SYNC.
1619 	 */
1620 	if (open_flag & __O_SYNC)
1621 		open_flag |= O_DSYNC;
1622 
1623 	if (!acc_mode)
1624 		acc_mode = MAY_OPEN | ACC_MODE(open_flag);
1625 
1626 	/* O_TRUNC implies we need access checks for write permissions */
1627 	if (flag & O_TRUNC)
1628 		acc_mode |= MAY_WRITE;
1629 
1630 	/* Allow the LSM permission hook to distinguish append
1631 	   access from general write access. */
1632 	if (flag & O_APPEND)
1633 		acc_mode |= MAY_APPEND;
1634 
1635 	/*
1636 	 * The simplest case - just a plain lookup.
1637 	 */
1638 	if (!(flag & O_CREAT)) {
1639 		filp = get_empty_filp();
1640 
1641 		if (filp == NULL)
1642 			return ERR_PTR(-ENFILE);
1643 		nd.intent.open.file = filp;
1644 		filp->f_flags = open_flag;
1645 		nd.intent.open.flags = flag;
1646 		nd.intent.open.create_mode = 0;
1647 		error = do_path_lookup(dfd, pathname,
1648 					lookup_flags(flag)|LOOKUP_OPEN, &nd);
1649 		if (IS_ERR(nd.intent.open.file)) {
1650 			if (error == 0) {
1651 				error = PTR_ERR(nd.intent.open.file);
1652 				path_put(&nd.path);
1653 			}
1654 		} else if (error)
1655 			release_open_intent(&nd);
1656 		if (error)
1657 			return ERR_PTR(error);
1658 		goto ok;
1659 	}
1660 
1661 	/*
1662 	 * Create - we need to know the parent.
1663 	 */
1664 reval:
1665 	error = path_init(dfd, pathname, LOOKUP_PARENT, &nd);
1666 	if (error)
1667 		return ERR_PTR(error);
1668 	if (force_reval)
1669 		nd.flags |= LOOKUP_REVAL;
1670 	error = path_walk(pathname, &nd);
1671 	if (error) {
1672 		if (nd.root.mnt)
1673 			path_put(&nd.root);
1674 		return ERR_PTR(error);
1675 	}
1676 	if (unlikely(!audit_dummy_context()))
1677 		audit_inode(pathname, nd.path.dentry);
1678 
1679 	/*
1680 	 * We have the parent and last component. First of all, check
1681 	 * that we are not asked to creat(2) an obvious directory - that
1682 	 * will not do.
1683 	 */
1684 	error = -EISDIR;
1685 	if (nd.last_type != LAST_NORM || nd.last.name[nd.last.len])
1686 		goto exit_parent;
1687 
1688 	error = -ENFILE;
1689 	filp = get_empty_filp();
1690 	if (filp == NULL)
1691 		goto exit_parent;
1692 	nd.intent.open.file = filp;
1693 	filp->f_flags = open_flag;
1694 	nd.intent.open.flags = flag;
1695 	nd.intent.open.create_mode = mode;
1696 	dir = nd.path.dentry;
1697 	nd.flags &= ~LOOKUP_PARENT;
1698 	nd.flags |= LOOKUP_CREATE | LOOKUP_OPEN;
1699 	if (flag & O_EXCL)
1700 		nd.flags |= LOOKUP_EXCL;
1701 	mutex_lock(&dir->d_inode->i_mutex);
1702 	path.dentry = lookup_hash(&nd);
1703 	path.mnt = nd.path.mnt;
1704 
1705 do_last:
1706 	error = PTR_ERR(path.dentry);
1707 	if (IS_ERR(path.dentry)) {
1708 		mutex_unlock(&dir->d_inode->i_mutex);
1709 		goto exit;
1710 	}
1711 
1712 	if (IS_ERR(nd.intent.open.file)) {
1713 		error = PTR_ERR(nd.intent.open.file);
1714 		goto exit_mutex_unlock;
1715 	}
1716 
1717 	/* Negative dentry, just create the file */
1718 	if (!path.dentry->d_inode) {
1719 		/*
1720 		 * This write is needed to ensure that a
1721 		 * ro->rw transition does not occur between
1722 		 * the time when the file is created and when
1723 		 * a permanent write count is taken through
1724 		 * the 'struct file' in nameidata_to_filp().
1725 		 */
1726 		error = mnt_want_write(nd.path.mnt);
1727 		if (error)
1728 			goto exit_mutex_unlock;
1729 		error = __open_namei_create(&nd, &path, flag, mode);
1730 		if (error) {
1731 			mnt_drop_write(nd.path.mnt);
1732 			goto exit;
1733 		}
1734 		filp = nameidata_to_filp(&nd);
1735 		mnt_drop_write(nd.path.mnt);
1736 		if (nd.root.mnt)
1737 			path_put(&nd.root);
1738 		if (!IS_ERR(filp)) {
1739 			error = ima_path_check(&filp->f_path, filp->f_mode &
1740 				       (MAY_READ | MAY_WRITE | MAY_EXEC));
1741 			if (error) {
1742 				fput(filp);
1743 				filp = ERR_PTR(error);
1744 			}
1745 		}
1746 		return filp;
1747 	}
1748 
1749 	/*
1750 	 * It already exists.
1751 	 */
1752 	mutex_unlock(&dir->d_inode->i_mutex);
1753 	audit_inode(pathname, path.dentry);
1754 
1755 	error = -EEXIST;
1756 	if (flag & O_EXCL)
1757 		goto exit_dput;
1758 
1759 	if (__follow_mount(&path)) {
1760 		error = -ELOOP;
1761 		if (flag & O_NOFOLLOW)
1762 			goto exit_dput;
1763 	}
1764 
1765 	error = -ENOENT;
1766 	if (!path.dentry->d_inode)
1767 		goto exit_dput;
1768 	if (path.dentry->d_inode->i_op->follow_link)
1769 		goto do_link;
1770 
1771 	path_to_nameidata(&path, &nd);
1772 	error = -EISDIR;
1773 	if (S_ISDIR(path.dentry->d_inode->i_mode))
1774 		goto exit;
1775 ok:
1776 	/*
1777 	 * Consider:
1778 	 * 1. may_open() truncates a file
1779 	 * 2. a rw->ro mount transition occurs
1780 	 * 3. nameidata_to_filp() fails due to
1781 	 *    the ro mount.
1782 	 * That would be inconsistent, and should
1783 	 * be avoided. Taking this mnt write here
1784 	 * ensures that (2) can not occur.
1785 	 */
1786 	will_truncate = open_will_truncate(flag, nd.path.dentry->d_inode);
1787 	if (will_truncate) {
1788 		error = mnt_want_write(nd.path.mnt);
1789 		if (error)
1790 			goto exit;
1791 	}
1792 	error = may_open(&nd.path, acc_mode, flag);
1793 	if (error) {
1794 		if (will_truncate)
1795 			mnt_drop_write(nd.path.mnt);
1796 		goto exit;
1797 	}
1798 	filp = nameidata_to_filp(&nd);
1799 	if (!IS_ERR(filp)) {
1800 		error = ima_path_check(&filp->f_path, filp->f_mode &
1801 			       (MAY_READ | MAY_WRITE | MAY_EXEC));
1802 		if (error) {
1803 			fput(filp);
1804 			filp = ERR_PTR(error);
1805 		}
1806 	}
1807 	if (!IS_ERR(filp)) {
1808 		if (acc_mode & MAY_WRITE)
1809 			vfs_dq_init(nd.path.dentry->d_inode);
1810 
1811 		if (will_truncate) {
1812 			error = handle_truncate(&nd.path);
1813 			if (error) {
1814 				fput(filp);
1815 				filp = ERR_PTR(error);
1816 			}
1817 		}
1818 	}
1819 	/*
1820 	 * It is now safe to drop the mnt write
1821 	 * because the filp has had a write taken
1822 	 * on its behalf.
1823 	 */
1824 	if (will_truncate)
1825 		mnt_drop_write(nd.path.mnt);
1826 	if (nd.root.mnt)
1827 		path_put(&nd.root);
1828 	return filp;
1829 
1830 exit_mutex_unlock:
1831 	mutex_unlock(&dir->d_inode->i_mutex);
1832 exit_dput:
1833 	path_put_conditional(&path, &nd);
1834 exit:
1835 	if (!IS_ERR(nd.intent.open.file))
1836 		release_open_intent(&nd);
1837 exit_parent:
1838 	if (nd.root.mnt)
1839 		path_put(&nd.root);
1840 	path_put(&nd.path);
1841 	return ERR_PTR(error);
1842 
1843 do_link:
1844 	error = -ELOOP;
1845 	if (flag & O_NOFOLLOW)
1846 		goto exit_dput;
1847 	/*
1848 	 * This is subtle. Instead of calling do_follow_link() we do the
1849 	 * thing by hands. The reason is that this way we have zero link_count
1850 	 * and path_walk() (called from ->follow_link) honoring LOOKUP_PARENT.
1851 	 * After that we have the parent and last component, i.e.
1852 	 * we are in the same situation as after the first path_walk().
1853 	 * Well, almost - if the last component is normal we get its copy
1854 	 * stored in nd->last.name and we will have to putname() it when we
1855 	 * are done. Procfs-like symlinks just set LAST_BIND.
1856 	 */
1857 	nd.flags |= LOOKUP_PARENT;
1858 	error = security_inode_follow_link(path.dentry, &nd);
1859 	if (error)
1860 		goto exit_dput;
1861 	error = __do_follow_link(&path, &nd);
1862 	path_put(&path);
1863 	if (error) {
1864 		/* Does someone understand code flow here? Or it is only
1865 		 * me so stupid? Anathema to whoever designed this non-sense
1866 		 * with "intent.open".
1867 		 */
1868 		release_open_intent(&nd);
1869 		if (nd.root.mnt)
1870 			path_put(&nd.root);
1871 		if (error == -ESTALE && !force_reval) {
1872 			force_reval = 1;
1873 			goto reval;
1874 		}
1875 		return ERR_PTR(error);
1876 	}
1877 	nd.flags &= ~LOOKUP_PARENT;
1878 	if (nd.last_type == LAST_BIND)
1879 		goto ok;
1880 	error = -EISDIR;
1881 	if (nd.last_type != LAST_NORM)
1882 		goto exit;
1883 	if (nd.last.name[nd.last.len]) {
1884 		__putname(nd.last.name);
1885 		goto exit;
1886 	}
1887 	error = -ELOOP;
1888 	if (count++==32) {
1889 		__putname(nd.last.name);
1890 		goto exit;
1891 	}
1892 	dir = nd.path.dentry;
1893 	mutex_lock(&dir->d_inode->i_mutex);
1894 	path.dentry = lookup_hash(&nd);
1895 	path.mnt = nd.path.mnt;
1896 	__putname(nd.last.name);
1897 	goto do_last;
1898 }
1899 
1900 /**
1901  * filp_open - open file and return file pointer
1902  *
1903  * @filename:	path to open
1904  * @flags:	open flags as per the open(2) second argument
1905  * @mode:	mode for the new file if O_CREAT is set, else ignored
1906  *
1907  * This is the helper to open a file from kernelspace if you really
1908  * have to.  But in generally you should not do this, so please move
1909  * along, nothing to see here..
1910  */
1911 struct file *filp_open(const char *filename, int flags, int mode)
1912 {
1913 	return do_filp_open(AT_FDCWD, filename, flags, mode, 0);
1914 }
1915 EXPORT_SYMBOL(filp_open);
1916 
1917 /**
1918  * lookup_create - lookup a dentry, creating it if it doesn't exist
1919  * @nd: nameidata info
1920  * @is_dir: directory flag
1921  *
1922  * Simple function to lookup and return a dentry and create it
1923  * if it doesn't exist.  Is SMP-safe.
1924  *
1925  * Returns with nd->path.dentry->d_inode->i_mutex locked.
1926  */
1927 struct dentry *lookup_create(struct nameidata *nd, int is_dir)
1928 {
1929 	struct dentry *dentry = ERR_PTR(-EEXIST);
1930 
1931 	mutex_lock_nested(&nd->path.dentry->d_inode->i_mutex, I_MUTEX_PARENT);
1932 	/*
1933 	 * Yucky last component or no last component at all?
1934 	 * (foo/., foo/.., /////)
1935 	 */
1936 	if (nd->last_type != LAST_NORM)
1937 		goto fail;
1938 	nd->flags &= ~LOOKUP_PARENT;
1939 	nd->flags |= LOOKUP_CREATE | LOOKUP_EXCL;
1940 	nd->intent.open.flags = O_EXCL;
1941 
1942 	/*
1943 	 * Do the final lookup.
1944 	 */
1945 	dentry = lookup_hash(nd);
1946 	if (IS_ERR(dentry))
1947 		goto fail;
1948 
1949 	if (dentry->d_inode)
1950 		goto eexist;
1951 	/*
1952 	 * Special case - lookup gave negative, but... we had foo/bar/
1953 	 * From the vfs_mknod() POV we just have a negative dentry -
1954 	 * all is fine. Let's be bastards - you had / on the end, you've
1955 	 * been asking for (non-existent) directory. -ENOENT for you.
1956 	 */
1957 	if (unlikely(!is_dir && nd->last.name[nd->last.len])) {
1958 		dput(dentry);
1959 		dentry = ERR_PTR(-ENOENT);
1960 	}
1961 	return dentry;
1962 eexist:
1963 	dput(dentry);
1964 	dentry = ERR_PTR(-EEXIST);
1965 fail:
1966 	return dentry;
1967 }
1968 EXPORT_SYMBOL_GPL(lookup_create);
1969 
1970 int vfs_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t dev)
1971 {
1972 	int error = may_create(dir, dentry);
1973 
1974 	if (error)
1975 		return error;
1976 
1977 	if ((S_ISCHR(mode) || S_ISBLK(mode)) && !capable(CAP_MKNOD))
1978 		return -EPERM;
1979 
1980 	if (!dir->i_op->mknod)
1981 		return -EPERM;
1982 
1983 	error = devcgroup_inode_mknod(mode, dev);
1984 	if (error)
1985 		return error;
1986 
1987 	error = security_inode_mknod(dir, dentry, mode, dev);
1988 	if (error)
1989 		return error;
1990 
1991 	vfs_dq_init(dir);
1992 	error = dir->i_op->mknod(dir, dentry, mode, dev);
1993 	if (!error)
1994 		fsnotify_create(dir, dentry);
1995 	return error;
1996 }
1997 
1998 static int may_mknod(mode_t mode)
1999 {
2000 	switch (mode & S_IFMT) {
2001 	case S_IFREG:
2002 	case S_IFCHR:
2003 	case S_IFBLK:
2004 	case S_IFIFO:
2005 	case S_IFSOCK:
2006 	case 0: /* zero mode translates to S_IFREG */
2007 		return 0;
2008 	case S_IFDIR:
2009 		return -EPERM;
2010 	default:
2011 		return -EINVAL;
2012 	}
2013 }
2014 
2015 SYSCALL_DEFINE4(mknodat, int, dfd, const char __user *, filename, int, mode,
2016 		unsigned, dev)
2017 {
2018 	int error;
2019 	char *tmp;
2020 	struct dentry *dentry;
2021 	struct nameidata nd;
2022 
2023 	if (S_ISDIR(mode))
2024 		return -EPERM;
2025 
2026 	error = user_path_parent(dfd, filename, &nd, &tmp);
2027 	if (error)
2028 		return error;
2029 
2030 	dentry = lookup_create(&nd, 0);
2031 	if (IS_ERR(dentry)) {
2032 		error = PTR_ERR(dentry);
2033 		goto out_unlock;
2034 	}
2035 	if (!IS_POSIXACL(nd.path.dentry->d_inode))
2036 		mode &= ~current_umask();
2037 	error = may_mknod(mode);
2038 	if (error)
2039 		goto out_dput;
2040 	error = mnt_want_write(nd.path.mnt);
2041 	if (error)
2042 		goto out_dput;
2043 	error = security_path_mknod(&nd.path, dentry, mode, dev);
2044 	if (error)
2045 		goto out_drop_write;
2046 	switch (mode & S_IFMT) {
2047 		case 0: case S_IFREG:
2048 			error = vfs_create(nd.path.dentry->d_inode,dentry,mode,&nd);
2049 			break;
2050 		case S_IFCHR: case S_IFBLK:
2051 			error = vfs_mknod(nd.path.dentry->d_inode,dentry,mode,
2052 					new_decode_dev(dev));
2053 			break;
2054 		case S_IFIFO: case S_IFSOCK:
2055 			error = vfs_mknod(nd.path.dentry->d_inode,dentry,mode,0);
2056 			break;
2057 	}
2058 out_drop_write:
2059 	mnt_drop_write(nd.path.mnt);
2060 out_dput:
2061 	dput(dentry);
2062 out_unlock:
2063 	mutex_unlock(&nd.path.dentry->d_inode->i_mutex);
2064 	path_put(&nd.path);
2065 	putname(tmp);
2066 
2067 	return error;
2068 }
2069 
2070 SYSCALL_DEFINE3(mknod, const char __user *, filename, int, mode, unsigned, dev)
2071 {
2072 	return sys_mknodat(AT_FDCWD, filename, mode, dev);
2073 }
2074 
2075 int vfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
2076 {
2077 	int error = may_create(dir, dentry);
2078 
2079 	if (error)
2080 		return error;
2081 
2082 	if (!dir->i_op->mkdir)
2083 		return -EPERM;
2084 
2085 	mode &= (S_IRWXUGO|S_ISVTX);
2086 	error = security_inode_mkdir(dir, dentry, mode);
2087 	if (error)
2088 		return error;
2089 
2090 	vfs_dq_init(dir);
2091 	error = dir->i_op->mkdir(dir, dentry, mode);
2092 	if (!error)
2093 		fsnotify_mkdir(dir, dentry);
2094 	return error;
2095 }
2096 
2097 SYSCALL_DEFINE3(mkdirat, int, dfd, const char __user *, pathname, int, mode)
2098 {
2099 	int error = 0;
2100 	char * tmp;
2101 	struct dentry *dentry;
2102 	struct nameidata nd;
2103 
2104 	error = user_path_parent(dfd, pathname, &nd, &tmp);
2105 	if (error)
2106 		goto out_err;
2107 
2108 	dentry = lookup_create(&nd, 1);
2109 	error = PTR_ERR(dentry);
2110 	if (IS_ERR(dentry))
2111 		goto out_unlock;
2112 
2113 	if (!IS_POSIXACL(nd.path.dentry->d_inode))
2114 		mode &= ~current_umask();
2115 	error = mnt_want_write(nd.path.mnt);
2116 	if (error)
2117 		goto out_dput;
2118 	error = security_path_mkdir(&nd.path, dentry, mode);
2119 	if (error)
2120 		goto out_drop_write;
2121 	error = vfs_mkdir(nd.path.dentry->d_inode, dentry, mode);
2122 out_drop_write:
2123 	mnt_drop_write(nd.path.mnt);
2124 out_dput:
2125 	dput(dentry);
2126 out_unlock:
2127 	mutex_unlock(&nd.path.dentry->d_inode->i_mutex);
2128 	path_put(&nd.path);
2129 	putname(tmp);
2130 out_err:
2131 	return error;
2132 }
2133 
2134 SYSCALL_DEFINE2(mkdir, const char __user *, pathname, int, mode)
2135 {
2136 	return sys_mkdirat(AT_FDCWD, pathname, mode);
2137 }
2138 
2139 /*
2140  * We try to drop the dentry early: we should have
2141  * a usage count of 2 if we're the only user of this
2142  * dentry, and if that is true (possibly after pruning
2143  * the dcache), then we drop the dentry now.
2144  *
2145  * A low-level filesystem can, if it choses, legally
2146  * do a
2147  *
2148  *	if (!d_unhashed(dentry))
2149  *		return -EBUSY;
2150  *
2151  * if it cannot handle the case of removing a directory
2152  * that is still in use by something else..
2153  */
2154 void dentry_unhash(struct dentry *dentry)
2155 {
2156 	dget(dentry);
2157 	shrink_dcache_parent(dentry);
2158 	spin_lock(&dcache_lock);
2159 	spin_lock(&dentry->d_lock);
2160 	if (atomic_read(&dentry->d_count) == 2)
2161 		__d_drop(dentry);
2162 	spin_unlock(&dentry->d_lock);
2163 	spin_unlock(&dcache_lock);
2164 }
2165 
2166 int vfs_rmdir(struct inode *dir, struct dentry *dentry)
2167 {
2168 	int error = may_delete(dir, dentry, 1);
2169 
2170 	if (error)
2171 		return error;
2172 
2173 	if (!dir->i_op->rmdir)
2174 		return -EPERM;
2175 
2176 	vfs_dq_init(dir);
2177 
2178 	mutex_lock(&dentry->d_inode->i_mutex);
2179 	dentry_unhash(dentry);
2180 	if (d_mountpoint(dentry))
2181 		error = -EBUSY;
2182 	else {
2183 		error = security_inode_rmdir(dir, dentry);
2184 		if (!error) {
2185 			error = dir->i_op->rmdir(dir, dentry);
2186 			if (!error)
2187 				dentry->d_inode->i_flags |= S_DEAD;
2188 		}
2189 	}
2190 	mutex_unlock(&dentry->d_inode->i_mutex);
2191 	if (!error) {
2192 		d_delete(dentry);
2193 	}
2194 	dput(dentry);
2195 
2196 	return error;
2197 }
2198 
2199 static long do_rmdir(int dfd, const char __user *pathname)
2200 {
2201 	int error = 0;
2202 	char * name;
2203 	struct dentry *dentry;
2204 	struct nameidata nd;
2205 
2206 	error = user_path_parent(dfd, pathname, &nd, &name);
2207 	if (error)
2208 		return error;
2209 
2210 	switch(nd.last_type) {
2211 	case LAST_DOTDOT:
2212 		error = -ENOTEMPTY;
2213 		goto exit1;
2214 	case LAST_DOT:
2215 		error = -EINVAL;
2216 		goto exit1;
2217 	case LAST_ROOT:
2218 		error = -EBUSY;
2219 		goto exit1;
2220 	}
2221 
2222 	nd.flags &= ~LOOKUP_PARENT;
2223 
2224 	mutex_lock_nested(&nd.path.dentry->d_inode->i_mutex, I_MUTEX_PARENT);
2225 	dentry = lookup_hash(&nd);
2226 	error = PTR_ERR(dentry);
2227 	if (IS_ERR(dentry))
2228 		goto exit2;
2229 	error = mnt_want_write(nd.path.mnt);
2230 	if (error)
2231 		goto exit3;
2232 	error = security_path_rmdir(&nd.path, dentry);
2233 	if (error)
2234 		goto exit4;
2235 	error = vfs_rmdir(nd.path.dentry->d_inode, dentry);
2236 exit4:
2237 	mnt_drop_write(nd.path.mnt);
2238 exit3:
2239 	dput(dentry);
2240 exit2:
2241 	mutex_unlock(&nd.path.dentry->d_inode->i_mutex);
2242 exit1:
2243 	path_put(&nd.path);
2244 	putname(name);
2245 	return error;
2246 }
2247 
2248 SYSCALL_DEFINE1(rmdir, const char __user *, pathname)
2249 {
2250 	return do_rmdir(AT_FDCWD, pathname);
2251 }
2252 
2253 int vfs_unlink(struct inode *dir, struct dentry *dentry)
2254 {
2255 	int error = may_delete(dir, dentry, 0);
2256 
2257 	if (error)
2258 		return error;
2259 
2260 	if (!dir->i_op->unlink)
2261 		return -EPERM;
2262 
2263 	vfs_dq_init(dir);
2264 
2265 	mutex_lock(&dentry->d_inode->i_mutex);
2266 	if (d_mountpoint(dentry))
2267 		error = -EBUSY;
2268 	else {
2269 		error = security_inode_unlink(dir, dentry);
2270 		if (!error)
2271 			error = dir->i_op->unlink(dir, dentry);
2272 	}
2273 	mutex_unlock(&dentry->d_inode->i_mutex);
2274 
2275 	/* We don't d_delete() NFS sillyrenamed files--they still exist. */
2276 	if (!error && !(dentry->d_flags & DCACHE_NFSFS_RENAMED)) {
2277 		fsnotify_link_count(dentry->d_inode);
2278 		d_delete(dentry);
2279 	}
2280 
2281 	return error;
2282 }
2283 
2284 /*
2285  * Make sure that the actual truncation of the file will occur outside its
2286  * directory's i_mutex.  Truncate can take a long time if there is a lot of
2287  * writeout happening, and we don't want to prevent access to the directory
2288  * while waiting on the I/O.
2289  */
2290 static long do_unlinkat(int dfd, const char __user *pathname)
2291 {
2292 	int error;
2293 	char *name;
2294 	struct dentry *dentry;
2295 	struct nameidata nd;
2296 	struct inode *inode = NULL;
2297 
2298 	error = user_path_parent(dfd, pathname, &nd, &name);
2299 	if (error)
2300 		return error;
2301 
2302 	error = -EISDIR;
2303 	if (nd.last_type != LAST_NORM)
2304 		goto exit1;
2305 
2306 	nd.flags &= ~LOOKUP_PARENT;
2307 
2308 	mutex_lock_nested(&nd.path.dentry->d_inode->i_mutex, I_MUTEX_PARENT);
2309 	dentry = lookup_hash(&nd);
2310 	error = PTR_ERR(dentry);
2311 	if (!IS_ERR(dentry)) {
2312 		/* Why not before? Because we want correct error value */
2313 		if (nd.last.name[nd.last.len])
2314 			goto slashes;
2315 		inode = dentry->d_inode;
2316 		if (inode)
2317 			atomic_inc(&inode->i_count);
2318 		error = mnt_want_write(nd.path.mnt);
2319 		if (error)
2320 			goto exit2;
2321 		error = security_path_unlink(&nd.path, dentry);
2322 		if (error)
2323 			goto exit3;
2324 		error = vfs_unlink(nd.path.dentry->d_inode, dentry);
2325 exit3:
2326 		mnt_drop_write(nd.path.mnt);
2327 	exit2:
2328 		dput(dentry);
2329 	}
2330 	mutex_unlock(&nd.path.dentry->d_inode->i_mutex);
2331 	if (inode)
2332 		iput(inode);	/* truncate the inode here */
2333 exit1:
2334 	path_put(&nd.path);
2335 	putname(name);
2336 	return error;
2337 
2338 slashes:
2339 	error = !dentry->d_inode ? -ENOENT :
2340 		S_ISDIR(dentry->d_inode->i_mode) ? -EISDIR : -ENOTDIR;
2341 	goto exit2;
2342 }
2343 
2344 SYSCALL_DEFINE3(unlinkat, int, dfd, const char __user *, pathname, int, flag)
2345 {
2346 	if ((flag & ~AT_REMOVEDIR) != 0)
2347 		return -EINVAL;
2348 
2349 	if (flag & AT_REMOVEDIR)
2350 		return do_rmdir(dfd, pathname);
2351 
2352 	return do_unlinkat(dfd, pathname);
2353 }
2354 
2355 SYSCALL_DEFINE1(unlink, const char __user *, pathname)
2356 {
2357 	return do_unlinkat(AT_FDCWD, pathname);
2358 }
2359 
2360 int vfs_symlink(struct inode *dir, struct dentry *dentry, const char *oldname)
2361 {
2362 	int error = may_create(dir, dentry);
2363 
2364 	if (error)
2365 		return error;
2366 
2367 	if (!dir->i_op->symlink)
2368 		return -EPERM;
2369 
2370 	error = security_inode_symlink(dir, dentry, oldname);
2371 	if (error)
2372 		return error;
2373 
2374 	vfs_dq_init(dir);
2375 	error = dir->i_op->symlink(dir, dentry, oldname);
2376 	if (!error)
2377 		fsnotify_create(dir, dentry);
2378 	return error;
2379 }
2380 
2381 SYSCALL_DEFINE3(symlinkat, const char __user *, oldname,
2382 		int, newdfd, const char __user *, newname)
2383 {
2384 	int error;
2385 	char *from;
2386 	char *to;
2387 	struct dentry *dentry;
2388 	struct nameidata nd;
2389 
2390 	from = getname(oldname);
2391 	if (IS_ERR(from))
2392 		return PTR_ERR(from);
2393 
2394 	error = user_path_parent(newdfd, newname, &nd, &to);
2395 	if (error)
2396 		goto out_putname;
2397 
2398 	dentry = lookup_create(&nd, 0);
2399 	error = PTR_ERR(dentry);
2400 	if (IS_ERR(dentry))
2401 		goto out_unlock;
2402 
2403 	error = mnt_want_write(nd.path.mnt);
2404 	if (error)
2405 		goto out_dput;
2406 	error = security_path_symlink(&nd.path, dentry, from);
2407 	if (error)
2408 		goto out_drop_write;
2409 	error = vfs_symlink(nd.path.dentry->d_inode, dentry, from);
2410 out_drop_write:
2411 	mnt_drop_write(nd.path.mnt);
2412 out_dput:
2413 	dput(dentry);
2414 out_unlock:
2415 	mutex_unlock(&nd.path.dentry->d_inode->i_mutex);
2416 	path_put(&nd.path);
2417 	putname(to);
2418 out_putname:
2419 	putname(from);
2420 	return error;
2421 }
2422 
2423 SYSCALL_DEFINE2(symlink, const char __user *, oldname, const char __user *, newname)
2424 {
2425 	return sys_symlinkat(oldname, AT_FDCWD, newname);
2426 }
2427 
2428 int vfs_link(struct dentry *old_dentry, struct inode *dir, struct dentry *new_dentry)
2429 {
2430 	struct inode *inode = old_dentry->d_inode;
2431 	int error;
2432 
2433 	if (!inode)
2434 		return -ENOENT;
2435 
2436 	error = may_create(dir, new_dentry);
2437 	if (error)
2438 		return error;
2439 
2440 	if (dir->i_sb != inode->i_sb)
2441 		return -EXDEV;
2442 
2443 	/*
2444 	 * A link to an append-only or immutable file cannot be created.
2445 	 */
2446 	if (IS_APPEND(inode) || IS_IMMUTABLE(inode))
2447 		return -EPERM;
2448 	if (!dir->i_op->link)
2449 		return -EPERM;
2450 	if (S_ISDIR(inode->i_mode))
2451 		return -EPERM;
2452 
2453 	error = security_inode_link(old_dentry, dir, new_dentry);
2454 	if (error)
2455 		return error;
2456 
2457 	mutex_lock(&inode->i_mutex);
2458 	vfs_dq_init(dir);
2459 	error = dir->i_op->link(old_dentry, dir, new_dentry);
2460 	mutex_unlock(&inode->i_mutex);
2461 	if (!error)
2462 		fsnotify_link(dir, inode, new_dentry);
2463 	return error;
2464 }
2465 
2466 /*
2467  * Hardlinks are often used in delicate situations.  We avoid
2468  * security-related surprises by not following symlinks on the
2469  * newname.  --KAB
2470  *
2471  * We don't follow them on the oldname either to be compatible
2472  * with linux 2.0, and to avoid hard-linking to directories
2473  * and other special files.  --ADM
2474  */
2475 SYSCALL_DEFINE5(linkat, int, olddfd, const char __user *, oldname,
2476 		int, newdfd, const char __user *, newname, int, flags)
2477 {
2478 	struct dentry *new_dentry;
2479 	struct nameidata nd;
2480 	struct path old_path;
2481 	int error;
2482 	char *to;
2483 
2484 	if ((flags & ~AT_SYMLINK_FOLLOW) != 0)
2485 		return -EINVAL;
2486 
2487 	error = user_path_at(olddfd, oldname,
2488 			     flags & AT_SYMLINK_FOLLOW ? LOOKUP_FOLLOW : 0,
2489 			     &old_path);
2490 	if (error)
2491 		return error;
2492 
2493 	error = user_path_parent(newdfd, newname, &nd, &to);
2494 	if (error)
2495 		goto out;
2496 	error = -EXDEV;
2497 	if (old_path.mnt != nd.path.mnt)
2498 		goto out_release;
2499 	new_dentry = lookup_create(&nd, 0);
2500 	error = PTR_ERR(new_dentry);
2501 	if (IS_ERR(new_dentry))
2502 		goto out_unlock;
2503 	error = mnt_want_write(nd.path.mnt);
2504 	if (error)
2505 		goto out_dput;
2506 	error = security_path_link(old_path.dentry, &nd.path, new_dentry);
2507 	if (error)
2508 		goto out_drop_write;
2509 	error = vfs_link(old_path.dentry, nd.path.dentry->d_inode, new_dentry);
2510 out_drop_write:
2511 	mnt_drop_write(nd.path.mnt);
2512 out_dput:
2513 	dput(new_dentry);
2514 out_unlock:
2515 	mutex_unlock(&nd.path.dentry->d_inode->i_mutex);
2516 out_release:
2517 	path_put(&nd.path);
2518 	putname(to);
2519 out:
2520 	path_put(&old_path);
2521 
2522 	return error;
2523 }
2524 
2525 SYSCALL_DEFINE2(link, const char __user *, oldname, const char __user *, newname)
2526 {
2527 	return sys_linkat(AT_FDCWD, oldname, AT_FDCWD, newname, 0);
2528 }
2529 
2530 /*
2531  * The worst of all namespace operations - renaming directory. "Perverted"
2532  * doesn't even start to describe it. Somebody in UCB had a heck of a trip...
2533  * Problems:
2534  *	a) we can get into loop creation. Check is done in is_subdir().
2535  *	b) race potential - two innocent renames can create a loop together.
2536  *	   That's where 4.4 screws up. Current fix: serialization on
2537  *	   sb->s_vfs_rename_mutex. We might be more accurate, but that's another
2538  *	   story.
2539  *	c) we have to lock _three_ objects - parents and victim (if it exists).
2540  *	   And that - after we got ->i_mutex on parents (until then we don't know
2541  *	   whether the target exists).  Solution: try to be smart with locking
2542  *	   order for inodes.  We rely on the fact that tree topology may change
2543  *	   only under ->s_vfs_rename_mutex _and_ that parent of the object we
2544  *	   move will be locked.  Thus we can rank directories by the tree
2545  *	   (ancestors first) and rank all non-directories after them.
2546  *	   That works since everybody except rename does "lock parent, lookup,
2547  *	   lock child" and rename is under ->s_vfs_rename_mutex.
2548  *	   HOWEVER, it relies on the assumption that any object with ->lookup()
2549  *	   has no more than 1 dentry.  If "hybrid" objects will ever appear,
2550  *	   we'd better make sure that there's no link(2) for them.
2551  *	d) some filesystems don't support opened-but-unlinked directories,
2552  *	   either because of layout or because they are not ready to deal with
2553  *	   all cases correctly. The latter will be fixed (taking this sort of
2554  *	   stuff into VFS), but the former is not going away. Solution: the same
2555  *	   trick as in rmdir().
2556  *	e) conversion from fhandle to dentry may come in the wrong moment - when
2557  *	   we are removing the target. Solution: we will have to grab ->i_mutex
2558  *	   in the fhandle_to_dentry code. [FIXME - current nfsfh.c relies on
2559  *	   ->i_mutex on parents, which works but leads to some truely excessive
2560  *	   locking].
2561  */
2562 static int vfs_rename_dir(struct inode *old_dir, struct dentry *old_dentry,
2563 			  struct inode *new_dir, struct dentry *new_dentry)
2564 {
2565 	int error = 0;
2566 	struct inode *target;
2567 
2568 	/*
2569 	 * If we are going to change the parent - check write permissions,
2570 	 * we'll need to flip '..'.
2571 	 */
2572 	if (new_dir != old_dir) {
2573 		error = inode_permission(old_dentry->d_inode, MAY_WRITE);
2574 		if (error)
2575 			return error;
2576 	}
2577 
2578 	error = security_inode_rename(old_dir, old_dentry, new_dir, new_dentry);
2579 	if (error)
2580 		return error;
2581 
2582 	target = new_dentry->d_inode;
2583 	if (target) {
2584 		mutex_lock(&target->i_mutex);
2585 		dentry_unhash(new_dentry);
2586 	}
2587 	if (d_mountpoint(old_dentry)||d_mountpoint(new_dentry))
2588 		error = -EBUSY;
2589 	else
2590 		error = old_dir->i_op->rename(old_dir, old_dentry, new_dir, new_dentry);
2591 	if (target) {
2592 		if (!error)
2593 			target->i_flags |= S_DEAD;
2594 		mutex_unlock(&target->i_mutex);
2595 		if (d_unhashed(new_dentry))
2596 			d_rehash(new_dentry);
2597 		dput(new_dentry);
2598 	}
2599 	if (!error)
2600 		if (!(old_dir->i_sb->s_type->fs_flags & FS_RENAME_DOES_D_MOVE))
2601 			d_move(old_dentry,new_dentry);
2602 	return error;
2603 }
2604 
2605 static int vfs_rename_other(struct inode *old_dir, struct dentry *old_dentry,
2606 			    struct inode *new_dir, struct dentry *new_dentry)
2607 {
2608 	struct inode *target;
2609 	int error;
2610 
2611 	error = security_inode_rename(old_dir, old_dentry, new_dir, new_dentry);
2612 	if (error)
2613 		return error;
2614 
2615 	dget(new_dentry);
2616 	target = new_dentry->d_inode;
2617 	if (target)
2618 		mutex_lock(&target->i_mutex);
2619 	if (d_mountpoint(old_dentry)||d_mountpoint(new_dentry))
2620 		error = -EBUSY;
2621 	else
2622 		error = old_dir->i_op->rename(old_dir, old_dentry, new_dir, new_dentry);
2623 	if (!error) {
2624 		if (!(old_dir->i_sb->s_type->fs_flags & FS_RENAME_DOES_D_MOVE))
2625 			d_move(old_dentry, new_dentry);
2626 	}
2627 	if (target)
2628 		mutex_unlock(&target->i_mutex);
2629 	dput(new_dentry);
2630 	return error;
2631 }
2632 
2633 int vfs_rename(struct inode *old_dir, struct dentry *old_dentry,
2634 	       struct inode *new_dir, struct dentry *new_dentry)
2635 {
2636 	int error;
2637 	int is_dir = S_ISDIR(old_dentry->d_inode->i_mode);
2638 	const char *old_name;
2639 
2640 	if (old_dentry->d_inode == new_dentry->d_inode)
2641  		return 0;
2642 
2643 	error = may_delete(old_dir, old_dentry, is_dir);
2644 	if (error)
2645 		return error;
2646 
2647 	if (!new_dentry->d_inode)
2648 		error = may_create(new_dir, new_dentry);
2649 	else
2650 		error = may_delete(new_dir, new_dentry, is_dir);
2651 	if (error)
2652 		return error;
2653 
2654 	if (!old_dir->i_op->rename)
2655 		return -EPERM;
2656 
2657 	vfs_dq_init(old_dir);
2658 	vfs_dq_init(new_dir);
2659 
2660 	old_name = fsnotify_oldname_init(old_dentry->d_name.name);
2661 
2662 	if (is_dir)
2663 		error = vfs_rename_dir(old_dir,old_dentry,new_dir,new_dentry);
2664 	else
2665 		error = vfs_rename_other(old_dir,old_dentry,new_dir,new_dentry);
2666 	if (!error) {
2667 		const char *new_name = old_dentry->d_name.name;
2668 		fsnotify_move(old_dir, new_dir, old_name, new_name, is_dir,
2669 			      new_dentry->d_inode, old_dentry);
2670 	}
2671 	fsnotify_oldname_free(old_name);
2672 
2673 	return error;
2674 }
2675 
2676 SYSCALL_DEFINE4(renameat, int, olddfd, const char __user *, oldname,
2677 		int, newdfd, const char __user *, newname)
2678 {
2679 	struct dentry *old_dir, *new_dir;
2680 	struct dentry *old_dentry, *new_dentry;
2681 	struct dentry *trap;
2682 	struct nameidata oldnd, newnd;
2683 	char *from;
2684 	char *to;
2685 	int error;
2686 
2687 	error = user_path_parent(olddfd, oldname, &oldnd, &from);
2688 	if (error)
2689 		goto exit;
2690 
2691 	error = user_path_parent(newdfd, newname, &newnd, &to);
2692 	if (error)
2693 		goto exit1;
2694 
2695 	error = -EXDEV;
2696 	if (oldnd.path.mnt != newnd.path.mnt)
2697 		goto exit2;
2698 
2699 	old_dir = oldnd.path.dentry;
2700 	error = -EBUSY;
2701 	if (oldnd.last_type != LAST_NORM)
2702 		goto exit2;
2703 
2704 	new_dir = newnd.path.dentry;
2705 	if (newnd.last_type != LAST_NORM)
2706 		goto exit2;
2707 
2708 	oldnd.flags &= ~LOOKUP_PARENT;
2709 	newnd.flags &= ~LOOKUP_PARENT;
2710 	newnd.flags |= LOOKUP_RENAME_TARGET;
2711 
2712 	trap = lock_rename(new_dir, old_dir);
2713 
2714 	old_dentry = lookup_hash(&oldnd);
2715 	error = PTR_ERR(old_dentry);
2716 	if (IS_ERR(old_dentry))
2717 		goto exit3;
2718 	/* source must exist */
2719 	error = -ENOENT;
2720 	if (!old_dentry->d_inode)
2721 		goto exit4;
2722 	/* unless the source is a directory trailing slashes give -ENOTDIR */
2723 	if (!S_ISDIR(old_dentry->d_inode->i_mode)) {
2724 		error = -ENOTDIR;
2725 		if (oldnd.last.name[oldnd.last.len])
2726 			goto exit4;
2727 		if (newnd.last.name[newnd.last.len])
2728 			goto exit4;
2729 	}
2730 	/* source should not be ancestor of target */
2731 	error = -EINVAL;
2732 	if (old_dentry == trap)
2733 		goto exit4;
2734 	new_dentry = lookup_hash(&newnd);
2735 	error = PTR_ERR(new_dentry);
2736 	if (IS_ERR(new_dentry))
2737 		goto exit4;
2738 	/* target should not be an ancestor of source */
2739 	error = -ENOTEMPTY;
2740 	if (new_dentry == trap)
2741 		goto exit5;
2742 
2743 	error = mnt_want_write(oldnd.path.mnt);
2744 	if (error)
2745 		goto exit5;
2746 	error = security_path_rename(&oldnd.path, old_dentry,
2747 				     &newnd.path, new_dentry);
2748 	if (error)
2749 		goto exit6;
2750 	error = vfs_rename(old_dir->d_inode, old_dentry,
2751 				   new_dir->d_inode, new_dentry);
2752 exit6:
2753 	mnt_drop_write(oldnd.path.mnt);
2754 exit5:
2755 	dput(new_dentry);
2756 exit4:
2757 	dput(old_dentry);
2758 exit3:
2759 	unlock_rename(new_dir, old_dir);
2760 exit2:
2761 	path_put(&newnd.path);
2762 	putname(to);
2763 exit1:
2764 	path_put(&oldnd.path);
2765 	putname(from);
2766 exit:
2767 	return error;
2768 }
2769 
2770 SYSCALL_DEFINE2(rename, const char __user *, oldname, const char __user *, newname)
2771 {
2772 	return sys_renameat(AT_FDCWD, oldname, AT_FDCWD, newname);
2773 }
2774 
2775 int vfs_readlink(struct dentry *dentry, char __user *buffer, int buflen, const char *link)
2776 {
2777 	int len;
2778 
2779 	len = PTR_ERR(link);
2780 	if (IS_ERR(link))
2781 		goto out;
2782 
2783 	len = strlen(link);
2784 	if (len > (unsigned) buflen)
2785 		len = buflen;
2786 	if (copy_to_user(buffer, link, len))
2787 		len = -EFAULT;
2788 out:
2789 	return len;
2790 }
2791 
2792 /*
2793  * A helper for ->readlink().  This should be used *ONLY* for symlinks that
2794  * have ->follow_link() touching nd only in nd_set_link().  Using (or not
2795  * using) it for any given inode is up to filesystem.
2796  */
2797 int generic_readlink(struct dentry *dentry, char __user *buffer, int buflen)
2798 {
2799 	struct nameidata nd;
2800 	void *cookie;
2801 	int res;
2802 
2803 	nd.depth = 0;
2804 	cookie = dentry->d_inode->i_op->follow_link(dentry, &nd);
2805 	if (IS_ERR(cookie))
2806 		return PTR_ERR(cookie);
2807 
2808 	res = vfs_readlink(dentry, buffer, buflen, nd_get_link(&nd));
2809 	if (dentry->d_inode->i_op->put_link)
2810 		dentry->d_inode->i_op->put_link(dentry, &nd, cookie);
2811 	return res;
2812 }
2813 
2814 int vfs_follow_link(struct nameidata *nd, const char *link)
2815 {
2816 	return __vfs_follow_link(nd, link);
2817 }
2818 
2819 /* get the link contents into pagecache */
2820 static char *page_getlink(struct dentry * dentry, struct page **ppage)
2821 {
2822 	char *kaddr;
2823 	struct page *page;
2824 	struct address_space *mapping = dentry->d_inode->i_mapping;
2825 	page = read_mapping_page(mapping, 0, NULL);
2826 	if (IS_ERR(page))
2827 		return (char*)page;
2828 	*ppage = page;
2829 	kaddr = kmap(page);
2830 	nd_terminate_link(kaddr, dentry->d_inode->i_size, PAGE_SIZE - 1);
2831 	return kaddr;
2832 }
2833 
2834 int page_readlink(struct dentry *dentry, char __user *buffer, int buflen)
2835 {
2836 	struct page *page = NULL;
2837 	char *s = page_getlink(dentry, &page);
2838 	int res = vfs_readlink(dentry,buffer,buflen,s);
2839 	if (page) {
2840 		kunmap(page);
2841 		page_cache_release(page);
2842 	}
2843 	return res;
2844 }
2845 
2846 void *page_follow_link_light(struct dentry *dentry, struct nameidata *nd)
2847 {
2848 	struct page *page = NULL;
2849 	nd_set_link(nd, page_getlink(dentry, &page));
2850 	return page;
2851 }
2852 
2853 void page_put_link(struct dentry *dentry, struct nameidata *nd, void *cookie)
2854 {
2855 	struct page *page = cookie;
2856 
2857 	if (page) {
2858 		kunmap(page);
2859 		page_cache_release(page);
2860 	}
2861 }
2862 
2863 /*
2864  * The nofs argument instructs pagecache_write_begin to pass AOP_FLAG_NOFS
2865  */
2866 int __page_symlink(struct inode *inode, const char *symname, int len, int nofs)
2867 {
2868 	struct address_space *mapping = inode->i_mapping;
2869 	struct page *page;
2870 	void *fsdata;
2871 	int err;
2872 	char *kaddr;
2873 	unsigned int flags = AOP_FLAG_UNINTERRUPTIBLE;
2874 	if (nofs)
2875 		flags |= AOP_FLAG_NOFS;
2876 
2877 retry:
2878 	err = pagecache_write_begin(NULL, mapping, 0, len-1,
2879 				flags, &page, &fsdata);
2880 	if (err)
2881 		goto fail;
2882 
2883 	kaddr = kmap_atomic(page, KM_USER0);
2884 	memcpy(kaddr, symname, len-1);
2885 	kunmap_atomic(kaddr, KM_USER0);
2886 
2887 	err = pagecache_write_end(NULL, mapping, 0, len-1, len-1,
2888 							page, fsdata);
2889 	if (err < 0)
2890 		goto fail;
2891 	if (err < len-1)
2892 		goto retry;
2893 
2894 	mark_inode_dirty(inode);
2895 	return 0;
2896 fail:
2897 	return err;
2898 }
2899 
2900 int page_symlink(struct inode *inode, const char *symname, int len)
2901 {
2902 	return __page_symlink(inode, symname, len,
2903 			!(mapping_gfp_mask(inode->i_mapping) & __GFP_FS));
2904 }
2905 
2906 const struct inode_operations page_symlink_inode_operations = {
2907 	.readlink	= generic_readlink,
2908 	.follow_link	= page_follow_link_light,
2909 	.put_link	= page_put_link,
2910 };
2911 
2912 EXPORT_SYMBOL(user_path_at);
2913 EXPORT_SYMBOL(follow_down);
2914 EXPORT_SYMBOL(follow_up);
2915 EXPORT_SYMBOL(get_write_access); /* binfmt_aout */
2916 EXPORT_SYMBOL(getname);
2917 EXPORT_SYMBOL(lock_rename);
2918 EXPORT_SYMBOL(lookup_one_len);
2919 EXPORT_SYMBOL(page_follow_link_light);
2920 EXPORT_SYMBOL(page_put_link);
2921 EXPORT_SYMBOL(page_readlink);
2922 EXPORT_SYMBOL(__page_symlink);
2923 EXPORT_SYMBOL(page_symlink);
2924 EXPORT_SYMBOL(page_symlink_inode_operations);
2925 EXPORT_SYMBOL(path_lookup);
2926 EXPORT_SYMBOL(kern_path);
2927 EXPORT_SYMBOL(vfs_path_lookup);
2928 EXPORT_SYMBOL(inode_permission);
2929 EXPORT_SYMBOL(file_permission);
2930 EXPORT_SYMBOL(unlock_rename);
2931 EXPORT_SYMBOL(vfs_create);
2932 EXPORT_SYMBOL(vfs_follow_link);
2933 EXPORT_SYMBOL(vfs_link);
2934 EXPORT_SYMBOL(vfs_mkdir);
2935 EXPORT_SYMBOL(vfs_mknod);
2936 EXPORT_SYMBOL(generic_permission);
2937 EXPORT_SYMBOL(vfs_readlink);
2938 EXPORT_SYMBOL(vfs_rename);
2939 EXPORT_SYMBOL(vfs_rmdir);
2940 EXPORT_SYMBOL(vfs_symlink);
2941 EXPORT_SYMBOL(vfs_unlink);
2942 EXPORT_SYMBOL(dentry_unhash);
2943 EXPORT_SYMBOL(generic_readlink);
2944