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