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