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