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