pull security_inode_follow_link() into __do_follow_link()
[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                             int open_flag, int acc_mode,
2177                             int mode, const char *pathname)
2178 {
2179         struct dentry *dir = nd->path.dentry;
2180         struct file *filp;
2181         int error;
2182
2183         switch (nd->last_type) {
2184         case LAST_DOTDOT:
2185                 follow_dotdot(nd);
2186                 dir = nd->path.dentry;
2187         case LAST_DOT:
2188                 /* fallthrough */
2189         case LAST_ROOT:
2190                 error = handle_reval_path(nd);
2191                 if (error)
2192                         goto exit;
2193                 error = -EISDIR;
2194                 goto exit;
2195         case LAST_BIND:
2196                 error = handle_reval_path(nd);
2197                 if (error)
2198                         goto exit;
2199                 audit_inode(pathname, dir);
2200                 goto ok;
2201         }
2202
2203         error = -EISDIR;
2204         /* trailing slashes? */
2205         if (nd->last.name[nd->last.len])
2206                 goto exit;
2207
2208         mutex_lock(&dir->d_inode->i_mutex);
2209
2210         path->dentry = lookup_hash(nd);
2211         path->mnt = nd->path.mnt;
2212
2213         error = PTR_ERR(path->dentry);
2214         if (IS_ERR(path->dentry)) {
2215                 mutex_unlock(&dir->d_inode->i_mutex);
2216                 goto exit;
2217         }
2218
2219         if (IS_ERR(nd->intent.open.file)) {
2220                 error = PTR_ERR(nd->intent.open.file);
2221                 goto exit_mutex_unlock;
2222         }
2223
2224         /* Negative dentry, just create the file */
2225         if (!path->dentry->d_inode) {
2226                 /*
2227                  * This write is needed to ensure that a
2228                  * ro->rw transition does not occur between
2229                  * the time when the file is created and when
2230                  * a permanent write count is taken through
2231                  * the 'struct file' in nameidata_to_filp().
2232                  */
2233                 error = mnt_want_write(nd->path.mnt);
2234                 if (error)
2235                         goto exit_mutex_unlock;
2236                 error = __open_namei_create(nd, path, open_flag, mode);
2237                 if (error) {
2238                         mnt_drop_write(nd->path.mnt);
2239                         goto exit;
2240                 }
2241                 filp = nameidata_to_filp(nd);
2242                 mnt_drop_write(nd->path.mnt);
2243                 path_put(&nd->path);
2244                 if (!IS_ERR(filp)) {
2245                         error = ima_file_check(filp, acc_mode);
2246                         if (error) {
2247                                 fput(filp);
2248                                 filp = ERR_PTR(error);
2249                         }
2250                 }
2251                 return filp;
2252         }
2253
2254         /*
2255          * It already exists.
2256          */
2257         mutex_unlock(&dir->d_inode->i_mutex);
2258         audit_inode(pathname, path->dentry);
2259
2260         error = -EEXIST;
2261         if (open_flag & O_EXCL)
2262                 goto exit_dput;
2263
2264         error = follow_managed(path, nd->flags);
2265         if (error < 0)
2266                 goto exit_dput;
2267
2268         error = -ENOENT;
2269         if (!path->dentry->d_inode)
2270                 goto exit_dput;
2271
2272         if (path->dentry->d_inode->i_op->follow_link)
2273                 return NULL;
2274
2275         path_to_nameidata(path, nd);
2276         nd->inode = path->dentry->d_inode;
2277         error = -EISDIR;
2278         if (S_ISDIR(nd->inode->i_mode))
2279                 goto exit;
2280 ok:
2281         filp = finish_open(nd, open_flag, acc_mode);
2282         return filp;
2283
2284 exit_mutex_unlock:
2285         mutex_unlock(&dir->d_inode->i_mutex);
2286 exit_dput:
2287         path_put_conditional(path, nd);
2288 exit:
2289         path_put(&nd->path);
2290         return ERR_PTR(error);
2291 }
2292
2293 /*
2294  * Note that the low bits of the passed in "open_flag"
2295  * are not the same as in the local variable "flag". See
2296  * open_to_namei_flags() for more details.
2297  */
2298 struct file *do_filp_open(int dfd, const char *pathname,
2299                 int open_flag, int mode, int acc_mode)
2300 {
2301         struct file *filp;
2302         struct nameidata nd;
2303         int error;
2304         struct path path;
2305         int count = 0;
2306         int flag = open_to_namei_flags(open_flag);
2307         int flags;
2308
2309         if (!(open_flag & O_CREAT))
2310                 mode = 0;
2311
2312         /* Must never be set by userspace */
2313         open_flag &= ~FMODE_NONOTIFY;
2314
2315         /*
2316          * O_SYNC is implemented as __O_SYNC|O_DSYNC.  As many places only
2317          * check for O_DSYNC if the need any syncing at all we enforce it's
2318          * always set instead of having to deal with possibly weird behaviour
2319          * for malicious applications setting only __O_SYNC.
2320          */
2321         if (open_flag & __O_SYNC)
2322                 open_flag |= O_DSYNC;
2323
2324         if (!acc_mode)
2325                 acc_mode = MAY_OPEN | ACC_MODE(open_flag);
2326
2327         /* O_TRUNC implies we need access checks for write permissions */
2328         if (open_flag & O_TRUNC)
2329                 acc_mode |= MAY_WRITE;
2330
2331         /* Allow the LSM permission hook to distinguish append 
2332            access from general write access. */
2333         if (open_flag & O_APPEND)
2334                 acc_mode |= MAY_APPEND;
2335
2336         flags = LOOKUP_OPEN;
2337         if (open_flag & O_CREAT) {
2338                 flags |= LOOKUP_CREATE;
2339                 if (open_flag & O_EXCL)
2340                         flags |= LOOKUP_EXCL;
2341         }
2342         if (open_flag & O_DIRECTORY)
2343                 flags |= LOOKUP_DIRECTORY;
2344         if (!(open_flag & O_NOFOLLOW))
2345                 flags |= LOOKUP_FOLLOW;
2346
2347         filp = get_empty_filp();
2348         if (!filp)
2349                 return ERR_PTR(-ENFILE);
2350
2351         filp->f_flags = open_flag;
2352         nd.intent.open.file = filp;
2353         nd.intent.open.flags = flag;
2354         nd.intent.open.create_mode = mode;
2355
2356         if (open_flag & O_CREAT)
2357                 goto creat;
2358
2359         /* !O_CREAT, simple open */
2360         error = do_path_lookup(dfd, pathname, flags, &nd);
2361         if (unlikely(error))
2362                 goto out_filp2;
2363         error = -ELOOP;
2364         if (!(nd.flags & LOOKUP_FOLLOW)) {
2365                 if (nd.inode->i_op->follow_link)
2366                         goto out_path2;
2367         }
2368         error = -ENOTDIR;
2369         if (nd.flags & LOOKUP_DIRECTORY) {
2370                 if (!nd.inode->i_op->lookup)
2371                         goto out_path2;
2372         }
2373         audit_inode(pathname, nd.path.dentry);
2374         filp = finish_open(&nd, open_flag, acc_mode);
2375 out2:
2376         release_open_intent(&nd);
2377         return filp;
2378
2379 out_path2:
2380         path_put(&nd.path);
2381 out_filp2:
2382         filp = ERR_PTR(error);
2383         goto out2;
2384
2385 creat:
2386         /* OK, have to create the file. Find the parent. */
2387         error = path_lookupat(dfd, pathname, LOOKUP_PARENT | LOOKUP_RCU, &nd);
2388         if (unlikely(error == -ECHILD))
2389                 error = path_lookupat(dfd, pathname, LOOKUP_PARENT, &nd);
2390         if (unlikely(error == -ESTALE)) {
2391 reval:
2392                 flags |= LOOKUP_REVAL;
2393                 error = path_lookupat(dfd, pathname,
2394                                 LOOKUP_PARENT | LOOKUP_REVAL, &nd);
2395         }
2396         if (unlikely(error))
2397                 goto out_filp;
2398         if (unlikely(!audit_dummy_context()))
2399                 audit_inode(pathname, nd.path.dentry);
2400
2401         /*
2402          * We have the parent and last component.
2403          */
2404         nd.flags = (nd.flags & ~LOOKUP_PARENT) | flags;
2405         filp = do_last(&nd, &path, open_flag, acc_mode, mode, pathname);
2406         while (unlikely(!filp)) { /* trailing symlink */
2407                 struct path link = path;
2408                 struct inode *linki = link.dentry->d_inode;
2409                 void *cookie;
2410                 error = -ELOOP;
2411                 if (!(nd.flags & LOOKUP_FOLLOW))
2412                         goto exit_dput;
2413                 if (count++ == 32)
2414                         goto exit_dput;
2415                 /*
2416                  * This is subtle. Instead of calling do_follow_link() we do
2417                  * the thing by hands. The reason is that this way we have zero
2418                  * link_count and path_walk() (called from ->follow_link)
2419                  * honoring LOOKUP_PARENT.  After that we have the parent and
2420                  * last component, i.e. we are in the same situation as after
2421                  * the first path_walk().  Well, almost - if the last component
2422                  * is normal we get its copy stored in nd->last.name and we will
2423                  * have to putname() it when we are done. Procfs-like symlinks
2424                  * just set LAST_BIND.
2425                  */
2426                 nd.flags |= LOOKUP_PARENT;
2427                 error = __do_follow_link(&link, &nd, &cookie);
2428                 if (unlikely(error)) {
2429                         if (!IS_ERR(cookie) && linki->i_op->put_link)
2430                                 linki->i_op->put_link(link.dentry, &nd, cookie);
2431                         /* nd.path had been dropped */
2432                         nd.path = link;
2433                         goto out_path;
2434                 }
2435                 nd.flags &= ~LOOKUP_PARENT;
2436                 filp = do_last(&nd, &path, open_flag, acc_mode, mode, pathname);
2437                 if (linki->i_op->put_link)
2438                         linki->i_op->put_link(link.dentry, &nd, cookie);
2439                 path_put(&link);
2440         }
2441 out:
2442         if (nd.root.mnt)
2443                 path_put(&nd.root);
2444         if (filp == ERR_PTR(-ESTALE) && !(flags & LOOKUP_REVAL))
2445                 goto reval;
2446         release_open_intent(&nd);
2447         return filp;
2448
2449 exit_dput:
2450         path_put_conditional(&path, &nd);
2451 out_path:
2452         path_put(&nd.path);
2453 out_filp:
2454         filp = ERR_PTR(error);
2455         goto out;
2456 }
2457
2458 /**
2459  * filp_open - open file and return file pointer
2460  *
2461  * @filename:   path to open
2462  * @flags:      open flags as per the open(2) second argument
2463  * @mode:       mode for the new file if O_CREAT is set, else ignored
2464  *
2465  * This is the helper to open a file from kernelspace if you really
2466  * have to.  But in generally you should not do this, so please move
2467  * along, nothing to see here..
2468  */
2469 struct file *filp_open(const char *filename, int flags, int mode)
2470 {
2471         return do_filp_open(AT_FDCWD, filename, flags, mode, 0);
2472 }
2473 EXPORT_SYMBOL(filp_open);
2474
2475 /**
2476  * lookup_create - lookup a dentry, creating it if it doesn't exist
2477  * @nd: nameidata info
2478  * @is_dir: directory flag
2479  *
2480  * Simple function to lookup and return a dentry and create it
2481  * if it doesn't exist.  Is SMP-safe.
2482  *
2483  * Returns with nd->path.dentry->d_inode->i_mutex locked.
2484  */
2485 struct dentry *lookup_create(struct nameidata *nd, int is_dir)
2486 {
2487         struct dentry *dentry = ERR_PTR(-EEXIST);
2488
2489         mutex_lock_nested(&nd->path.dentry->d_inode->i_mutex, I_MUTEX_PARENT);
2490         /*
2491          * Yucky last component or no last component at all?
2492          * (foo/., foo/.., /////)
2493          */
2494         if (nd->last_type != LAST_NORM)
2495                 goto fail;
2496         nd->flags &= ~LOOKUP_PARENT;
2497         nd->flags |= LOOKUP_CREATE | LOOKUP_EXCL;
2498         nd->intent.open.flags = O_EXCL;
2499
2500         /*
2501          * Do the final lookup.
2502          */
2503         dentry = lookup_hash(nd);
2504         if (IS_ERR(dentry))
2505                 goto fail;
2506
2507         if (dentry->d_inode)
2508                 goto eexist;
2509         /*
2510          * Special case - lookup gave negative, but... we had foo/bar/
2511          * From the vfs_mknod() POV we just have a negative dentry -
2512          * all is fine. Let's be bastards - you had / on the end, you've
2513          * been asking for (non-existent) directory. -ENOENT for you.
2514          */
2515         if (unlikely(!is_dir && nd->last.name[nd->last.len])) {
2516                 dput(dentry);
2517                 dentry = ERR_PTR(-ENOENT);
2518         }
2519         return dentry;
2520 eexist:
2521         dput(dentry);
2522         dentry = ERR_PTR(-EEXIST);
2523 fail:
2524         return dentry;
2525 }
2526 EXPORT_SYMBOL_GPL(lookup_create);
2527
2528 int vfs_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t dev)
2529 {
2530         int error = may_create(dir, dentry);
2531
2532         if (error)
2533                 return error;
2534
2535         if ((S_ISCHR(mode) || S_ISBLK(mode)) && !capable(CAP_MKNOD))
2536                 return -EPERM;
2537
2538         if (!dir->i_op->mknod)
2539                 return -EPERM;
2540
2541         error = devcgroup_inode_mknod(mode, dev);
2542         if (error)
2543                 return error;
2544
2545         error = security_inode_mknod(dir, dentry, mode, dev);
2546         if (error)
2547                 return error;
2548
2549         error = dir->i_op->mknod(dir, dentry, mode, dev);
2550         if (!error)
2551                 fsnotify_create(dir, dentry);
2552         return error;
2553 }
2554
2555 static int may_mknod(mode_t mode)
2556 {
2557         switch (mode & S_IFMT) {
2558         case S_IFREG:
2559         case S_IFCHR:
2560         case S_IFBLK:
2561         case S_IFIFO:
2562         case S_IFSOCK:
2563         case 0: /* zero mode translates to S_IFREG */
2564                 return 0;
2565         case S_IFDIR:
2566                 return -EPERM;
2567         default:
2568                 return -EINVAL;
2569         }
2570 }
2571
2572 SYSCALL_DEFINE4(mknodat, int, dfd, const char __user *, filename, int, mode,
2573                 unsigned, dev)
2574 {
2575         int error;
2576         char *tmp;
2577         struct dentry *dentry;
2578         struct nameidata nd;
2579
2580         if (S_ISDIR(mode))
2581                 return -EPERM;
2582
2583         error = user_path_parent(dfd, filename, &nd, &tmp);
2584         if (error)
2585                 return error;
2586
2587         dentry = lookup_create(&nd, 0);
2588         if (IS_ERR(dentry)) {
2589                 error = PTR_ERR(dentry);
2590                 goto out_unlock;
2591         }
2592         if (!IS_POSIXACL(nd.path.dentry->d_inode))
2593                 mode &= ~current_umask();
2594         error = may_mknod(mode);
2595         if (error)
2596                 goto out_dput;
2597         error = mnt_want_write(nd.path.mnt);
2598         if (error)
2599                 goto out_dput;
2600         error = security_path_mknod(&nd.path, dentry, mode, dev);
2601         if (error)
2602                 goto out_drop_write;
2603         switch (mode & S_IFMT) {
2604                 case 0: case S_IFREG:
2605                         error = vfs_create(nd.path.dentry->d_inode,dentry,mode,&nd);
2606                         break;
2607                 case S_IFCHR: case S_IFBLK:
2608                         error = vfs_mknod(nd.path.dentry->d_inode,dentry,mode,
2609                                         new_decode_dev(dev));
2610                         break;
2611                 case S_IFIFO: case S_IFSOCK:
2612                         error = vfs_mknod(nd.path.dentry->d_inode,dentry,mode,0);
2613                         break;
2614         }
2615 out_drop_write:
2616         mnt_drop_write(nd.path.mnt);
2617 out_dput:
2618         dput(dentry);
2619 out_unlock:
2620         mutex_unlock(&nd.path.dentry->d_inode->i_mutex);
2621         path_put(&nd.path);
2622         putname(tmp);
2623
2624         return error;
2625 }
2626
2627 SYSCALL_DEFINE3(mknod, const char __user *, filename, int, mode, unsigned, dev)
2628 {
2629         return sys_mknodat(AT_FDCWD, filename, mode, dev);
2630 }
2631
2632 int vfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
2633 {
2634         int error = may_create(dir, dentry);
2635
2636         if (error)
2637                 return error;
2638
2639         if (!dir->i_op->mkdir)
2640                 return -EPERM;
2641
2642         mode &= (S_IRWXUGO|S_ISVTX);
2643         error = security_inode_mkdir(dir, dentry, mode);
2644         if (error)
2645                 return error;
2646
2647         error = dir->i_op->mkdir(dir, dentry, mode);
2648         if (!error)
2649                 fsnotify_mkdir(dir, dentry);
2650         return error;
2651 }
2652
2653 SYSCALL_DEFINE3(mkdirat, int, dfd, const char __user *, pathname, int, mode)
2654 {
2655         int error = 0;
2656         char * tmp;
2657         struct dentry *dentry;
2658         struct nameidata nd;
2659
2660         error = user_path_parent(dfd, pathname, &nd, &tmp);
2661         if (error)
2662                 goto out_err;
2663
2664         dentry = lookup_create(&nd, 1);
2665         error = PTR_ERR(dentry);
2666         if (IS_ERR(dentry))
2667                 goto out_unlock;
2668
2669         if (!IS_POSIXACL(nd.path.dentry->d_inode))
2670                 mode &= ~current_umask();
2671         error = mnt_want_write(nd.path.mnt);
2672         if (error)
2673                 goto out_dput;
2674         error = security_path_mkdir(&nd.path, dentry, mode);
2675         if (error)
2676                 goto out_drop_write;
2677         error = vfs_mkdir(nd.path.dentry->d_inode, dentry, mode);
2678 out_drop_write:
2679         mnt_drop_write(nd.path.mnt);
2680 out_dput:
2681         dput(dentry);
2682 out_unlock:
2683         mutex_unlock(&nd.path.dentry->d_inode->i_mutex);
2684         path_put(&nd.path);
2685         putname(tmp);
2686 out_err:
2687         return error;
2688 }
2689
2690 SYSCALL_DEFINE2(mkdir, const char __user *, pathname, int, mode)
2691 {
2692         return sys_mkdirat(AT_FDCWD, pathname, mode);
2693 }
2694
2695 /*
2696  * We try to drop the dentry early: we should have
2697  * a usage count of 2 if we're the only user of this
2698  * dentry, and if that is true (possibly after pruning
2699  * the dcache), then we drop the dentry now.
2700  *
2701  * A low-level filesystem can, if it choses, legally
2702  * do a
2703  *
2704  *      if (!d_unhashed(dentry))
2705  *              return -EBUSY;
2706  *
2707  * if it cannot handle the case of removing a directory
2708  * that is still in use by something else..
2709  */
2710 void dentry_unhash(struct dentry *dentry)
2711 {
2712         dget(dentry);
2713         shrink_dcache_parent(dentry);
2714         spin_lock(&dentry->d_lock);
2715         if (dentry->d_count == 2)
2716                 __d_drop(dentry);
2717         spin_unlock(&dentry->d_lock);
2718 }
2719
2720 int vfs_rmdir(struct inode *dir, struct dentry *dentry)
2721 {
2722         int error = may_delete(dir, dentry, 1);
2723
2724         if (error)
2725                 return error;
2726
2727         if (!dir->i_op->rmdir)
2728                 return -EPERM;
2729
2730         mutex_lock(&dentry->d_inode->i_mutex);
2731         dentry_unhash(dentry);
2732         if (d_mountpoint(dentry))
2733                 error = -EBUSY;
2734         else {
2735                 error = security_inode_rmdir(dir, dentry);
2736                 if (!error) {
2737                         error = dir->i_op->rmdir(dir, dentry);
2738                         if (!error) {
2739                                 dentry->d_inode->i_flags |= S_DEAD;
2740                                 dont_mount(dentry);
2741                         }
2742                 }
2743         }
2744         mutex_unlock(&dentry->d_inode->i_mutex);
2745         if (!error) {
2746                 d_delete(dentry);
2747         }
2748         dput(dentry);
2749
2750         return error;
2751 }
2752
2753 static long do_rmdir(int dfd, const char __user *pathname)
2754 {
2755         int error = 0;
2756         char * name;
2757         struct dentry *dentry;
2758         struct nameidata nd;
2759
2760         error = user_path_parent(dfd, pathname, &nd, &name);
2761         if (error)
2762                 return error;
2763
2764         switch(nd.last_type) {
2765         case LAST_DOTDOT:
2766                 error = -ENOTEMPTY;
2767                 goto exit1;
2768         case LAST_DOT:
2769                 error = -EINVAL;
2770                 goto exit1;
2771         case LAST_ROOT:
2772                 error = -EBUSY;
2773                 goto exit1;
2774         }
2775
2776         nd.flags &= ~LOOKUP_PARENT;
2777
2778         mutex_lock_nested(&nd.path.dentry->d_inode->i_mutex, I_MUTEX_PARENT);
2779         dentry = lookup_hash(&nd);
2780         error = PTR_ERR(dentry);
2781         if (IS_ERR(dentry))
2782                 goto exit2;
2783         error = mnt_want_write(nd.path.mnt);
2784         if (error)
2785                 goto exit3;
2786         error = security_path_rmdir(&nd.path, dentry);
2787         if (error)
2788                 goto exit4;
2789         error = vfs_rmdir(nd.path.dentry->d_inode, dentry);
2790 exit4:
2791         mnt_drop_write(nd.path.mnt);
2792 exit3:
2793         dput(dentry);
2794 exit2:
2795         mutex_unlock(&nd.path.dentry->d_inode->i_mutex);
2796 exit1:
2797         path_put(&nd.path);
2798         putname(name);
2799         return error;
2800 }
2801
2802 SYSCALL_DEFINE1(rmdir, const char __user *, pathname)
2803 {
2804         return do_rmdir(AT_FDCWD, pathname);
2805 }
2806
2807 int vfs_unlink(struct inode *dir, struct dentry *dentry)
2808 {
2809         int error = may_delete(dir, dentry, 0);
2810
2811         if (error)
2812                 return error;
2813
2814         if (!dir->i_op->unlink)
2815                 return -EPERM;
2816
2817         mutex_lock(&dentry->d_inode->i_mutex);
2818         if (d_mountpoint(dentry))
2819                 error = -EBUSY;
2820         else {
2821                 error = security_inode_unlink(dir, dentry);
2822                 if (!error) {
2823                         error = dir->i_op->unlink(dir, dentry);
2824                         if (!error)
2825                                 dont_mount(dentry);
2826                 }
2827         }
2828         mutex_unlock(&dentry->d_inode->i_mutex);
2829
2830         /* We don't d_delete() NFS sillyrenamed files--they still exist. */
2831         if (!error && !(dentry->d_flags & DCACHE_NFSFS_RENAMED)) {
2832                 fsnotify_link_count(dentry->d_inode);
2833                 d_delete(dentry);
2834         }
2835
2836         return error;
2837 }
2838
2839 /*
2840  * Make sure that the actual truncation of the file will occur outside its
2841  * directory's i_mutex.  Truncate can take a long time if there is a lot of
2842  * writeout happening, and we don't want to prevent access to the directory
2843  * while waiting on the I/O.
2844  */
2845 static long do_unlinkat(int dfd, const char __user *pathname)
2846 {
2847         int error;
2848         char *name;
2849         struct dentry *dentry;
2850         struct nameidata nd;
2851         struct inode *inode = NULL;
2852
2853         error = user_path_parent(dfd, pathname, &nd, &name);
2854         if (error)
2855                 return error;
2856
2857         error = -EISDIR;
2858         if (nd.last_type != LAST_NORM)
2859                 goto exit1;
2860
2861         nd.flags &= ~LOOKUP_PARENT;
2862
2863         mutex_lock_nested(&nd.path.dentry->d_inode->i_mutex, I_MUTEX_PARENT);
2864         dentry = lookup_hash(&nd);
2865         error = PTR_ERR(dentry);
2866         if (!IS_ERR(dentry)) {
2867                 /* Why not before? Because we want correct error value */
2868                 if (nd.last.name[nd.last.len])
2869                         goto slashes;
2870                 inode = dentry->d_inode;
2871                 if (inode)
2872                         ihold(inode);
2873                 error = mnt_want_write(nd.path.mnt);
2874                 if (error)
2875                         goto exit2;
2876                 error = security_path_unlink(&nd.path, dentry);
2877                 if (error)
2878                         goto exit3;
2879                 error = vfs_unlink(nd.path.dentry->d_inode, dentry);
2880 exit3:
2881                 mnt_drop_write(nd.path.mnt);
2882         exit2:
2883                 dput(dentry);
2884         }
2885         mutex_unlock(&nd.path.dentry->d_inode->i_mutex);
2886         if (inode)
2887                 iput(inode);    /* truncate the inode here */
2888 exit1:
2889         path_put(&nd.path);
2890         putname(name);
2891         return error;
2892
2893 slashes:
2894         error = !dentry->d_inode ? -ENOENT :
2895                 S_ISDIR(dentry->d_inode->i_mode) ? -EISDIR : -ENOTDIR;
2896         goto exit2;
2897 }
2898
2899 SYSCALL_DEFINE3(unlinkat, int, dfd, const char __user *, pathname, int, flag)
2900 {
2901         if ((flag & ~AT_REMOVEDIR) != 0)
2902                 return -EINVAL;
2903
2904         if (flag & AT_REMOVEDIR)
2905                 return do_rmdir(dfd, pathname);
2906
2907         return do_unlinkat(dfd, pathname);
2908 }
2909
2910 SYSCALL_DEFINE1(unlink, const char __user *, pathname)
2911 {
2912         return do_unlinkat(AT_FDCWD, pathname);
2913 }
2914
2915 int vfs_symlink(struct inode *dir, struct dentry *dentry, const char *oldname)
2916 {
2917         int error = may_create(dir, dentry);
2918
2919         if (error)
2920                 return error;
2921
2922         if (!dir->i_op->symlink)
2923                 return -EPERM;
2924
2925         error = security_inode_symlink(dir, dentry, oldname);
2926         if (error)
2927                 return error;
2928
2929         error = dir->i_op->symlink(dir, dentry, oldname);
2930         if (!error)
2931                 fsnotify_create(dir, dentry);
2932         return error;
2933 }
2934
2935 SYSCALL_DEFINE3(symlinkat, const char __user *, oldname,
2936                 int, newdfd, const char __user *, newname)
2937 {
2938         int error;
2939         char *from;
2940         char *to;
2941         struct dentry *dentry;
2942         struct nameidata nd;
2943
2944         from = getname(oldname);
2945         if (IS_ERR(from))
2946                 return PTR_ERR(from);
2947
2948         error = user_path_parent(newdfd, newname, &nd, &to);
2949         if (error)
2950                 goto out_putname;
2951
2952         dentry = lookup_create(&nd, 0);
2953         error = PTR_ERR(dentry);
2954         if (IS_ERR(dentry))
2955                 goto out_unlock;
2956
2957         error = mnt_want_write(nd.path.mnt);
2958         if (error)
2959                 goto out_dput;
2960         error = security_path_symlink(&nd.path, dentry, from);
2961         if (error)
2962                 goto out_drop_write;
2963         error = vfs_symlink(nd.path.dentry->d_inode, dentry, from);
2964 out_drop_write:
2965         mnt_drop_write(nd.path.mnt);
2966 out_dput:
2967         dput(dentry);
2968 out_unlock:
2969         mutex_unlock(&nd.path.dentry->d_inode->i_mutex);
2970         path_put(&nd.path);
2971         putname(to);
2972 out_putname:
2973         putname(from);
2974         return error;
2975 }
2976
2977 SYSCALL_DEFINE2(symlink, const char __user *, oldname, const char __user *, newname)
2978 {
2979         return sys_symlinkat(oldname, AT_FDCWD, newname);
2980 }
2981
2982 int vfs_link(struct dentry *old_dentry, struct inode *dir, struct dentry *new_dentry)
2983 {
2984         struct inode *inode = old_dentry->d_inode;
2985         int error;
2986
2987         if (!inode)
2988                 return -ENOENT;
2989
2990         error = may_create(dir, new_dentry);
2991         if (error)
2992                 return error;
2993
2994         if (dir->i_sb != inode->i_sb)
2995                 return -EXDEV;
2996
2997         /*
2998          * A link to an append-only or immutable file cannot be created.
2999          */
3000         if (IS_APPEND(inode) || IS_IMMUTABLE(inode))
3001                 return -EPERM;
3002         if (!dir->i_op->link)
3003                 return -EPERM;
3004         if (S_ISDIR(inode->i_mode))
3005                 return -EPERM;
3006
3007         error = security_inode_link(old_dentry, dir, new_dentry);
3008         if (error)
3009                 return error;
3010
3011         mutex_lock(&inode->i_mutex);
3012         error = dir->i_op->link(old_dentry, dir, new_dentry);
3013         mutex_unlock(&inode->i_mutex);
3014         if (!error)
3015                 fsnotify_link(dir, inode, new_dentry);
3016         return error;
3017 }
3018
3019 /*
3020  * Hardlinks are often used in delicate situations.  We avoid
3021  * security-related surprises by not following symlinks on the
3022  * newname.  --KAB
3023  *
3024  * We don't follow them on the oldname either to be compatible
3025  * with linux 2.0, and to avoid hard-linking to directories
3026  * and other special files.  --ADM
3027  */
3028 SYSCALL_DEFINE5(linkat, int, olddfd, const char __user *, oldname,
3029                 int, newdfd, const char __user *, newname, int, flags)
3030 {
3031         struct dentry *new_dentry;
3032         struct nameidata nd;
3033         struct path old_path;
3034         int error;
3035         char *to;
3036
3037         if ((flags & ~AT_SYMLINK_FOLLOW) != 0)
3038                 return -EINVAL;
3039
3040         error = user_path_at(olddfd, oldname,
3041                              flags & AT_SYMLINK_FOLLOW ? LOOKUP_FOLLOW : 0,
3042                              &old_path);
3043         if (error)
3044                 return error;
3045
3046         error = user_path_parent(newdfd, newname, &nd, &to);
3047         if (error)
3048                 goto out;
3049         error = -EXDEV;
3050         if (old_path.mnt != nd.path.mnt)
3051                 goto out_release;
3052         new_dentry = lookup_create(&nd, 0);
3053         error = PTR_ERR(new_dentry);
3054         if (IS_ERR(new_dentry))
3055                 goto out_unlock;
3056         error = mnt_want_write(nd.path.mnt);
3057         if (error)
3058                 goto out_dput;
3059         error = security_path_link(old_path.dentry, &nd.path, new_dentry);
3060         if (error)
3061                 goto out_drop_write;
3062         error = vfs_link(old_path.dentry, nd.path.dentry->d_inode, new_dentry);
3063 out_drop_write:
3064         mnt_drop_write(nd.path.mnt);
3065 out_dput:
3066         dput(new_dentry);
3067 out_unlock:
3068         mutex_unlock(&nd.path.dentry->d_inode->i_mutex);
3069 out_release:
3070         path_put(&nd.path);
3071         putname(to);
3072 out:
3073         path_put(&old_path);
3074
3075         return error;
3076 }
3077
3078 SYSCALL_DEFINE2(link, const char __user *, oldname, const char __user *, newname)
3079 {
3080         return sys_linkat(AT_FDCWD, oldname, AT_FDCWD, newname, 0);
3081 }
3082
3083 /*
3084  * The worst of all namespace operations - renaming directory. "Perverted"
3085  * doesn't even start to describe it. Somebody in UCB had a heck of a trip...
3086  * Problems:
3087  *      a) we can get into loop creation. Check is done in is_subdir().
3088  *      b) race potential - two innocent renames can create a loop together.
3089  *         That's where 4.4 screws up. Current fix: serialization on
3090  *         sb->s_vfs_rename_mutex. We might be more accurate, but that's another
3091  *         story.
3092  *      c) we have to lock _three_ objects - parents and victim (if it exists).
3093  *         And that - after we got ->i_mutex on parents (until then we don't know
3094  *         whether the target exists).  Solution: try to be smart with locking
3095  *         order for inodes.  We rely on the fact that tree topology may change
3096  *         only under ->s_vfs_rename_mutex _and_ that parent of the object we
3097  *         move will be locked.  Thus we can rank directories by the tree
3098  *         (ancestors first) and rank all non-directories after them.
3099  *         That works since everybody except rename does "lock parent, lookup,
3100  *         lock child" and rename is under ->s_vfs_rename_mutex.
3101  *         HOWEVER, it relies on the assumption that any object with ->lookup()
3102  *         has no more than 1 dentry.  If "hybrid" objects will ever appear,
3103  *         we'd better make sure that there's no link(2) for them.
3104  *      d) some filesystems don't support opened-but-unlinked directories,
3105  *         either because of layout or because they are not ready to deal with
3106  *         all cases correctly. The latter will be fixed (taking this sort of
3107  *         stuff into VFS), but the former is not going away. Solution: the same
3108  *         trick as in rmdir().
3109  *      e) conversion from fhandle to dentry may come in the wrong moment - when
3110  *         we are removing the target. Solution: we will have to grab ->i_mutex
3111  *         in the fhandle_to_dentry code. [FIXME - current nfsfh.c relies on
3112  *         ->i_mutex on parents, which works but leads to some truly excessive
3113  *         locking].
3114  */
3115 static int vfs_rename_dir(struct inode *old_dir, struct dentry *old_dentry,
3116                           struct inode *new_dir, struct dentry *new_dentry)
3117 {
3118         int error = 0;
3119         struct inode *target;
3120
3121         /*
3122          * If we are going to change the parent - check write permissions,
3123          * we'll need to flip '..'.
3124          */
3125         if (new_dir != old_dir) {
3126                 error = inode_permission(old_dentry->d_inode, MAY_WRITE);
3127                 if (error)
3128                         return error;
3129         }
3130
3131         error = security_inode_rename(old_dir, old_dentry, new_dir, new_dentry);
3132         if (error)
3133                 return error;
3134
3135         target = new_dentry->d_inode;
3136         if (target)
3137                 mutex_lock(&target->i_mutex);
3138         if (d_mountpoint(old_dentry)||d_mountpoint(new_dentry))
3139                 error = -EBUSY;
3140         else {
3141                 if (target)
3142                         dentry_unhash(new_dentry);
3143                 error = old_dir->i_op->rename(old_dir, old_dentry, new_dir, new_dentry);
3144         }
3145         if (target) {
3146                 if (!error) {
3147                         target->i_flags |= S_DEAD;
3148                         dont_mount(new_dentry);
3149                 }
3150                 mutex_unlock(&target->i_mutex);
3151                 if (d_unhashed(new_dentry))
3152                         d_rehash(new_dentry);
3153                 dput(new_dentry);
3154         }
3155         if (!error)
3156                 if (!(old_dir->i_sb->s_type->fs_flags & FS_RENAME_DOES_D_MOVE))
3157                         d_move(old_dentry,new_dentry);
3158         return error;
3159 }
3160
3161 static int vfs_rename_other(struct inode *old_dir, struct dentry *old_dentry,
3162                             struct inode *new_dir, struct dentry *new_dentry)
3163 {
3164         struct inode *target;
3165         int error;
3166
3167         error = security_inode_rename(old_dir, old_dentry, new_dir, new_dentry);
3168         if (error)
3169                 return error;
3170
3171         dget(new_dentry);
3172         target = new_dentry->d_inode;
3173         if (target)
3174                 mutex_lock(&target->i_mutex);
3175         if (d_mountpoint(old_dentry)||d_mountpoint(new_dentry))
3176                 error = -EBUSY;
3177         else
3178                 error = old_dir->i_op->rename(old_dir, old_dentry, new_dir, new_dentry);
3179         if (!error) {
3180                 if (target)
3181                         dont_mount(new_dentry);
3182                 if (!(old_dir->i_sb->s_type->fs_flags & FS_RENAME_DOES_D_MOVE))
3183                         d_move(old_dentry, new_dentry);
3184         }
3185         if (target)
3186                 mutex_unlock(&target->i_mutex);
3187         dput(new_dentry);
3188         return error;
3189 }
3190
3191 int vfs_rename(struct inode *old_dir, struct dentry *old_dentry,
3192                struct inode *new_dir, struct dentry *new_dentry)
3193 {
3194         int error;
3195         int is_dir = S_ISDIR(old_dentry->d_inode->i_mode);
3196         const unsigned char *old_name;
3197
3198         if (old_dentry->d_inode == new_dentry->d_inode)
3199                 return 0;
3200  
3201         error = may_delete(old_dir, old_dentry, is_dir);
3202         if (error)
3203                 return error;
3204
3205         if (!new_dentry->d_inode)
3206                 error = may_create(new_dir, new_dentry);
3207         else
3208                 error = may_delete(new_dir, new_dentry, is_dir);
3209         if (error)
3210                 return error;
3211
3212         if (!old_dir->i_op->rename)
3213                 return -EPERM;
3214
3215         old_name = fsnotify_oldname_init(old_dentry->d_name.name);
3216
3217         if (is_dir)
3218                 error = vfs_rename_dir(old_dir,old_dentry,new_dir,new_dentry);
3219         else
3220                 error = vfs_rename_other(old_dir,old_dentry,new_dir,new_dentry);
3221         if (!error)
3222                 fsnotify_move(old_dir, new_dir, old_name, is_dir,
3223                               new_dentry->d_inode, old_dentry);
3224         fsnotify_oldname_free(old_name);
3225
3226         return error;
3227 }
3228
3229 SYSCALL_DEFINE4(renameat, int, olddfd, const char __user *, oldname,
3230                 int, newdfd, const char __user *, newname)
3231 {
3232         struct dentry *old_dir, *new_dir;
3233         struct dentry *old_dentry, *new_dentry;
3234         struct dentry *trap;
3235         struct nameidata oldnd, newnd;
3236         char *from;
3237         char *to;
3238         int error;
3239
3240         error = user_path_parent(olddfd, oldname, &oldnd, &from);
3241         if (error)
3242                 goto exit;
3243
3244         error = user_path_parent(newdfd, newname, &newnd, &to);
3245         if (error)
3246                 goto exit1;
3247
3248         error = -EXDEV;
3249         if (oldnd.path.mnt != newnd.path.mnt)
3250                 goto exit2;
3251
3252         old_dir = oldnd.path.dentry;
3253         error = -EBUSY;
3254         if (oldnd.last_type != LAST_NORM)
3255                 goto exit2;
3256
3257         new_dir = newnd.path.dentry;
3258         if (newnd.last_type != LAST_NORM)
3259                 goto exit2;
3260
3261         oldnd.flags &= ~LOOKUP_PARENT;
3262         newnd.flags &= ~LOOKUP_PARENT;
3263         newnd.flags |= LOOKUP_RENAME_TARGET;
3264
3265         trap = lock_rename(new_dir, old_dir);
3266
3267         old_dentry = lookup_hash(&oldnd);
3268         error = PTR_ERR(old_dentry);
3269         if (IS_ERR(old_dentry))
3270                 goto exit3;
3271         /* source must exist */
3272         error = -ENOENT;
3273         if (!old_dentry->d_inode)
3274                 goto exit4;
3275         /* unless the source is a directory trailing slashes give -ENOTDIR */
3276         if (!S_ISDIR(old_dentry->d_inode->i_mode)) {
3277                 error = -ENOTDIR;
3278                 if (oldnd.last.name[oldnd.last.len])
3279                         goto exit4;
3280                 if (newnd.last.name[newnd.last.len])
3281                         goto exit4;
3282         }
3283         /* source should not be ancestor of target */
3284         error = -EINVAL;
3285         if (old_dentry == trap)
3286                 goto exit4;
3287         new_dentry = lookup_hash(&newnd);
3288         error = PTR_ERR(new_dentry);
3289         if (IS_ERR(new_dentry))
3290                 goto exit4;
3291         /* target should not be an ancestor of source */
3292         error = -ENOTEMPTY;
3293         if (new_dentry == trap)
3294                 goto exit5;
3295
3296         error = mnt_want_write(oldnd.path.mnt);
3297         if (error)
3298                 goto exit5;
3299         error = security_path_rename(&oldnd.path, old_dentry,
3300                                      &newnd.path, new_dentry);
3301         if (error)
3302                 goto exit6;
3303         error = vfs_rename(old_dir->d_inode, old_dentry,
3304                                    new_dir->d_inode, new_dentry);
3305 exit6:
3306         mnt_drop_write(oldnd.path.mnt);
3307 exit5:
3308         dput(new_dentry);
3309 exit4:
3310         dput(old_dentry);
3311 exit3:
3312         unlock_rename(new_dir, old_dir);
3313 exit2:
3314         path_put(&newnd.path);
3315         putname(to);
3316 exit1:
3317         path_put(&oldnd.path);
3318         putname(from);
3319 exit:
3320         return error;
3321 }
3322
3323 SYSCALL_DEFINE2(rename, const char __user *, oldname, const char __user *, newname)
3324 {
3325         return sys_renameat(AT_FDCWD, oldname, AT_FDCWD, newname);
3326 }
3327
3328 int vfs_readlink(struct dentry *dentry, char __user *buffer, int buflen, const char *link)
3329 {
3330         int len;
3331
3332         len = PTR_ERR(link);
3333         if (IS_ERR(link))
3334                 goto out;
3335
3336         len = strlen(link);
3337         if (len > (unsigned) buflen)
3338                 len = buflen;
3339         if (copy_to_user(buffer, link, len))
3340                 len = -EFAULT;
3341 out:
3342         return len;
3343 }
3344
3345 /*
3346  * A helper for ->readlink().  This should be used *ONLY* for symlinks that
3347  * have ->follow_link() touching nd only in nd_set_link().  Using (or not
3348  * using) it for any given inode is up to filesystem.
3349  */
3350 int generic_readlink(struct dentry *dentry, char __user *buffer, int buflen)
3351 {
3352         struct nameidata nd;
3353         void *cookie;
3354         int res;
3355
3356         nd.depth = 0;
3357         cookie = dentry->d_inode->i_op->follow_link(dentry, &nd);
3358         if (IS_ERR(cookie))
3359                 return PTR_ERR(cookie);
3360
3361         res = vfs_readlink(dentry, buffer, buflen, nd_get_link(&nd));
3362         if (dentry->d_inode->i_op->put_link)
3363                 dentry->d_inode->i_op->put_link(dentry, &nd, cookie);
3364         return res;
3365 }
3366
3367 int vfs_follow_link(struct nameidata *nd, const char *link)
3368 {
3369         return __vfs_follow_link(nd, link);
3370 }
3371
3372 /* get the link contents into pagecache */
3373 static char *page_getlink(struct dentry * dentry, struct page **ppage)
3374 {
3375         char *kaddr;
3376         struct page *page;
3377         struct address_space *mapping = dentry->d_inode->i_mapping;
3378         page = read_mapping_page(mapping, 0, NULL);
3379         if (IS_ERR(page))
3380                 return (char*)page;
3381         *ppage = page;
3382         kaddr = kmap(page);
3383         nd_terminate_link(kaddr, dentry->d_inode->i_size, PAGE_SIZE - 1);
3384         return kaddr;
3385 }
3386
3387 int page_readlink(struct dentry *dentry, char __user *buffer, int buflen)
3388 {
3389         struct page *page = NULL;
3390         char *s = page_getlink(dentry, &page);
3391         int res = vfs_readlink(dentry,buffer,buflen,s);
3392         if (page) {
3393                 kunmap(page);
3394                 page_cache_release(page);
3395         }
3396         return res;
3397 }
3398
3399 void *page_follow_link_light(struct dentry *dentry, struct nameidata *nd)
3400 {
3401         struct page *page = NULL;
3402         nd_set_link(nd, page_getlink(dentry, &page));
3403         return page;
3404 }
3405
3406 void page_put_link(struct dentry *dentry, struct nameidata *nd, void *cookie)
3407 {
3408         struct page *page = cookie;
3409
3410         if (page) {
3411                 kunmap(page);
3412                 page_cache_release(page);
3413         }
3414 }
3415
3416 /*
3417  * The nofs argument instructs pagecache_write_begin to pass AOP_FLAG_NOFS
3418  */
3419 int __page_symlink(struct inode *inode, const char *symname, int len, int nofs)
3420 {
3421         struct address_space *mapping = inode->i_mapping;
3422         struct page *page;
3423         void *fsdata;
3424         int err;
3425         char *kaddr;
3426         unsigned int flags = AOP_FLAG_UNINTERRUPTIBLE;
3427         if (nofs)
3428                 flags |= AOP_FLAG_NOFS;
3429
3430 retry:
3431         err = pagecache_write_begin(NULL, mapping, 0, len-1,
3432                                 flags, &page, &fsdata);
3433         if (err)
3434                 goto fail;
3435
3436         kaddr = kmap_atomic(page, KM_USER0);
3437         memcpy(kaddr, symname, len-1);
3438         kunmap_atomic(kaddr, KM_USER0);
3439
3440         err = pagecache_write_end(NULL, mapping, 0, len-1, len-1,
3441                                                         page, fsdata);
3442         if (err < 0)
3443                 goto fail;
3444         if (err < len-1)
3445                 goto retry;
3446
3447         mark_inode_dirty(inode);
3448         return 0;
3449 fail:
3450         return err;
3451 }
3452
3453 int page_symlink(struct inode *inode, const char *symname, int len)
3454 {
3455         return __page_symlink(inode, symname, len,
3456                         !(mapping_gfp_mask(inode->i_mapping) & __GFP_FS));
3457 }
3458
3459 const struct inode_operations page_symlink_inode_operations = {
3460         .readlink       = generic_readlink,
3461         .follow_link    = page_follow_link_light,
3462         .put_link       = page_put_link,
3463 };
3464
3465 EXPORT_SYMBOL(user_path_at);
3466 EXPORT_SYMBOL(follow_down_one);
3467 EXPORT_SYMBOL(follow_down);
3468 EXPORT_SYMBOL(follow_up);
3469 EXPORT_SYMBOL(get_write_access); /* binfmt_aout */
3470 EXPORT_SYMBOL(getname);
3471 EXPORT_SYMBOL(lock_rename);
3472 EXPORT_SYMBOL(lookup_one_len);
3473 EXPORT_SYMBOL(page_follow_link_light);
3474 EXPORT_SYMBOL(page_put_link);
3475 EXPORT_SYMBOL(page_readlink);
3476 EXPORT_SYMBOL(__page_symlink);
3477 EXPORT_SYMBOL(page_symlink);
3478 EXPORT_SYMBOL(page_symlink_inode_operations);
3479 EXPORT_SYMBOL(kern_path_parent);
3480 EXPORT_SYMBOL(kern_path);
3481 EXPORT_SYMBOL(vfs_path_lookup);
3482 EXPORT_SYMBOL(inode_permission);
3483 EXPORT_SYMBOL(file_permission);
3484 EXPORT_SYMBOL(unlock_rename);
3485 EXPORT_SYMBOL(vfs_create);
3486 EXPORT_SYMBOL(vfs_follow_link);
3487 EXPORT_SYMBOL(vfs_link);
3488 EXPORT_SYMBOL(vfs_mkdir);
3489 EXPORT_SYMBOL(vfs_mknod);
3490 EXPORT_SYMBOL(generic_permission);
3491 EXPORT_SYMBOL(vfs_readlink);
3492 EXPORT_SYMBOL(vfs_rename);
3493 EXPORT_SYMBOL(vfs_rmdir);
3494 EXPORT_SYMBOL(vfs_symlink);
3495 EXPORT_SYMBOL(vfs_unlink);
3496 EXPORT_SYMBOL(dentry_unhash);
3497 EXPORT_SYMBOL(generic_readlink);