11de7c39ff76efb5fed2e09f34f0ac212df58cf0
[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,
173                 int (*check_acl)(struct inode *inode, int mask))
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);
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  *
206  * Used to check for read/write/execute permissions on a file.
207  * We use "fsuid" for this, letting us set arbitrary permissions
208  * for filesystem access without changing the "normal" uids which
209  * are used for other things..
210  */
211 int generic_permission(struct inode *inode, int mask,
212                 int (*check_acl)(struct inode *inode, int mask))
213 {
214         int ret;
215
216         /*
217          * Do the basic POSIX ACL permission checks.
218          */
219         ret = acl_permission_check(inode, mask, check_acl);
220         if (ret != -EACCES)
221                 return ret;
222
223         /*
224          * Read/write DACs are always overridable.
225          * Executable DACs are overridable if at least one exec bit is set.
226          */
227         if (!(mask & MAY_EXEC) || execute_ok(inode))
228                 if (capable(CAP_DAC_OVERRIDE))
229                         return 0;
230
231         /*
232          * Searching includes executable on directories, else just read.
233          */
234         mask &= MAY_READ | MAY_WRITE | MAY_EXEC;
235         if (mask == MAY_READ || (S_ISDIR(inode->i_mode) && !(mask & MAY_WRITE)))
236                 if (capable(CAP_DAC_READ_SEARCH))
237                         return 0;
238
239         return -EACCES;
240 }
241
242 /**
243  * inode_permission  -  check for access rights to a given inode
244  * @inode:      inode to check permission on
245  * @mask:       right to check for (%MAY_READ, %MAY_WRITE, %MAY_EXEC)
246  *
247  * Used to check for read/write/execute permissions on an inode.
248  * We use "fsuid" for this, letting us set arbitrary permissions
249  * for filesystem access without changing the "normal" uids which
250  * are used for other things.
251  */
252 int inode_permission(struct inode *inode, int mask)
253 {
254         int retval;
255
256         if (mask & MAY_WRITE) {
257                 umode_t mode = inode->i_mode;
258
259                 /*
260                  * Nobody gets write access to a read-only fs.
261                  */
262                 if (IS_RDONLY(inode) &&
263                     (S_ISREG(mode) || S_ISDIR(mode) || S_ISLNK(mode)))
264                         return -EROFS;
265
266                 /*
267                  * Nobody gets write access to an immutable file.
268                  */
269                 if (IS_IMMUTABLE(inode))
270                         return -EACCES;
271         }
272
273         if (inode->i_op->permission)
274                 retval = inode->i_op->permission(inode, mask);
275         else
276                 retval = generic_permission(inode, mask, inode->i_op->check_acl);
277
278         if (retval)
279                 return retval;
280
281         retval = devcgroup_inode_permission(inode, mask);
282         if (retval)
283                 return retval;
284
285         return security_inode_permission(inode, mask);
286 }
287
288 /**
289  * file_permission  -  check for additional access rights to a given file
290  * @file:       file to check access rights for
291  * @mask:       right to check for (%MAY_READ, %MAY_WRITE, %MAY_EXEC)
292  *
293  * Used to check for read/write/execute permissions on an already opened
294  * file.
295  *
296  * Note:
297  *      Do not use this function in new code.  All access checks should
298  *      be done using inode_permission().
299  */
300 int file_permission(struct file *file, int mask)
301 {
302         return inode_permission(file->f_path.dentry->d_inode, mask);
303 }
304
305 /*
306  * get_write_access() gets write permission for a file.
307  * put_write_access() releases this write permission.
308  * This is used for regular files.
309  * We cannot support write (and maybe mmap read-write shared) accesses and
310  * MAP_DENYWRITE mmappings simultaneously. The i_writecount field of an inode
311  * can have the following values:
312  * 0: no writers, no VM_DENYWRITE mappings
313  * < 0: (-i_writecount) vm_area_structs with VM_DENYWRITE set exist
314  * > 0: (i_writecount) users are writing to the file.
315  *
316  * Normally we operate on that counter with atomic_{inc,dec} and it's safe
317  * except for the cases where we don't hold i_writecount yet. Then we need to
318  * use {get,deny}_write_access() - these functions check the sign and refuse
319  * to do the change if sign is wrong. Exclusion between them is provided by
320  * the inode->i_lock spinlock.
321  */
322
323 int get_write_access(struct inode * inode)
324 {
325         spin_lock(&inode->i_lock);
326         if (atomic_read(&inode->i_writecount) < 0) {
327                 spin_unlock(&inode->i_lock);
328                 return -ETXTBSY;
329         }
330         atomic_inc(&inode->i_writecount);
331         spin_unlock(&inode->i_lock);
332
333         return 0;
334 }
335
336 int deny_write_access(struct file * file)
337 {
338         struct inode *inode = file->f_path.dentry->d_inode;
339
340         spin_lock(&inode->i_lock);
341         if (atomic_read(&inode->i_writecount) > 0) {
342                 spin_unlock(&inode->i_lock);
343                 return -ETXTBSY;
344         }
345         atomic_dec(&inode->i_writecount);
346         spin_unlock(&inode->i_lock);
347
348         return 0;
349 }
350
351 /**
352  * path_get - get a reference to a path
353  * @path: path to get the reference to
354  *
355  * Given a path increment the reference count to the dentry and the vfsmount.
356  */
357 void path_get(struct path *path)
358 {
359         mntget(path->mnt);
360         dget(path->dentry);
361 }
362 EXPORT_SYMBOL(path_get);
363
364 /**
365  * path_put - put a reference to a path
366  * @path: path to put the reference to
367  *
368  * Given a path decrement the reference count to the dentry and the vfsmount.
369  */
370 void path_put(struct path *path)
371 {
372         dput(path->dentry);
373         mntput(path->mnt);
374 }
375 EXPORT_SYMBOL(path_put);
376
377 /**
378  * release_open_intent - free up open intent resources
379  * @nd: pointer to nameidata
380  */
381 void release_open_intent(struct nameidata *nd)
382 {
383         if (nd->intent.open.file->f_path.dentry == NULL)
384                 put_filp(nd->intent.open.file);
385         else
386                 fput(nd->intent.open.file);
387 }
388
389 static inline struct dentry *
390 do_revalidate(struct dentry *dentry, struct nameidata *nd)
391 {
392         int status = dentry->d_op->d_revalidate(dentry, nd);
393         if (unlikely(status <= 0)) {
394                 /*
395                  * The dentry failed validation.
396                  * If d_revalidate returned 0 attempt to invalidate
397                  * the dentry otherwise d_revalidate is asking us
398                  * to return a fail status.
399                  */
400                 if (!status) {
401                         if (!d_invalidate(dentry)) {
402                                 dput(dentry);
403                                 dentry = NULL;
404                         }
405                 } else {
406                         dput(dentry);
407                         dentry = ERR_PTR(status);
408                 }
409         }
410         return dentry;
411 }
412
413 /*
414  * force_reval_path - force revalidation of a dentry
415  *
416  * In some situations the path walking code will trust dentries without
417  * revalidating them. This causes problems for filesystems that depend on
418  * d_revalidate to handle file opens (e.g. NFSv4). When FS_REVAL_DOT is set
419  * (which indicates that it's possible for the dentry to go stale), force
420  * a d_revalidate call before proceeding.
421  *
422  * Returns 0 if the revalidation was successful. If the revalidation fails,
423  * either return the error returned by d_revalidate or -ESTALE if the
424  * revalidation it just returned 0. If d_revalidate returns 0, we attempt to
425  * invalidate the dentry. It's up to the caller to handle putting references
426  * to the path if necessary.
427  */
428 static int
429 force_reval_path(struct path *path, struct nameidata *nd)
430 {
431         int status;
432         struct dentry *dentry = path->dentry;
433
434         /*
435          * only check on filesystems where it's possible for the dentry to
436          * become stale. It's assumed that if this flag is set then the
437          * d_revalidate op will also be defined.
438          */
439         if (!(dentry->d_sb->s_type->fs_flags & FS_REVAL_DOT))
440                 return 0;
441
442         status = dentry->d_op->d_revalidate(dentry, nd);
443         if (status > 0)
444                 return 0;
445
446         if (!status) {
447                 d_invalidate(dentry);
448                 status = -ESTALE;
449         }
450         return status;
451 }
452
453 /*
454  * Short-cut version of permission(), for calling on directories
455  * during pathname resolution.  Combines parts of permission()
456  * and generic_permission(), and tests ONLY for MAY_EXEC permission.
457  *
458  * If appropriate, check DAC only.  If not appropriate, or
459  * short-cut DAC fails, then call ->permission() to do more
460  * complete permission check.
461  */
462 static int exec_permission(struct inode *inode)
463 {
464         int ret;
465
466         if (inode->i_op->permission) {
467                 ret = inode->i_op->permission(inode, MAY_EXEC);
468                 if (!ret)
469                         goto ok;
470                 return ret;
471         }
472         ret = acl_permission_check(inode, MAY_EXEC, inode->i_op->check_acl);
473         if (!ret)
474                 goto ok;
475
476         if (capable(CAP_DAC_OVERRIDE) || capable(CAP_DAC_READ_SEARCH))
477                 goto ok;
478
479         return ret;
480 ok:
481         return security_inode_permission(inode, MAY_EXEC);
482 }
483
484 static __always_inline void set_root(struct nameidata *nd)
485 {
486         if (!nd->root.mnt)
487                 get_fs_root(current->fs, &nd->root);
488 }
489
490 static int link_path_walk(const char *, struct nameidata *);
491
492 static __always_inline int __vfs_follow_link(struct nameidata *nd, const char *link)
493 {
494         if (IS_ERR(link))
495                 goto fail;
496
497         if (*link == '/') {
498                 set_root(nd);
499                 path_put(&nd->path);
500                 nd->path = nd->root;
501                 path_get(&nd->root);
502         }
503
504         return link_path_walk(link, nd);
505 fail:
506         path_put(&nd->path);
507         return PTR_ERR(link);
508 }
509
510 static void path_put_conditional(struct path *path, struct nameidata *nd)
511 {
512         dput(path->dentry);
513         if (path->mnt != nd->path.mnt)
514                 mntput(path->mnt);
515 }
516
517 static inline void path_to_nameidata(struct path *path, struct nameidata *nd)
518 {
519         dput(nd->path.dentry);
520         if (nd->path.mnt != path->mnt) {
521                 mntput(nd->path.mnt);
522                 nd->path.mnt = path->mnt;
523         }
524         nd->path.dentry = path->dentry;
525 }
526
527 static __always_inline int
528 __do_follow_link(struct path *path, struct nameidata *nd, void **p)
529 {
530         int error;
531         struct dentry *dentry = path->dentry;
532
533         touch_atime(path->mnt, dentry);
534         nd_set_link(nd, NULL);
535
536         if (path->mnt != nd->path.mnt) {
537                 path_to_nameidata(path, nd);
538                 dget(dentry);
539         }
540         mntget(path->mnt);
541         nd->last_type = LAST_BIND;
542         *p = dentry->d_inode->i_op->follow_link(dentry, nd);
543         error = PTR_ERR(*p);
544         if (!IS_ERR(*p)) {
545                 char *s = nd_get_link(nd);
546                 error = 0;
547                 if (s)
548                         error = __vfs_follow_link(nd, s);
549                 else if (nd->last_type == LAST_BIND) {
550                         error = force_reval_path(&nd->path, nd);
551                         if (error)
552                                 path_put(&nd->path);
553                 }
554         }
555         return error;
556 }
557
558 /*
559  * This limits recursive symlink follows to 8, while
560  * limiting consecutive symlinks to 40.
561  *
562  * Without that kind of total limit, nasty chains of consecutive
563  * symlinks can cause almost arbitrarily long lookups. 
564  */
565 static inline int do_follow_link(struct path *path, struct nameidata *nd)
566 {
567         void *cookie;
568         int err = -ELOOP;
569         if (current->link_count >= MAX_NESTED_LINKS)
570                 goto loop;
571         if (current->total_link_count >= 40)
572                 goto loop;
573         BUG_ON(nd->depth >= MAX_NESTED_LINKS);
574         cond_resched();
575         err = security_inode_follow_link(path->dentry, nd);
576         if (err)
577                 goto loop;
578         current->link_count++;
579         current->total_link_count++;
580         nd->depth++;
581         err = __do_follow_link(path, nd, &cookie);
582         if (!IS_ERR(cookie) && path->dentry->d_inode->i_op->put_link)
583                 path->dentry->d_inode->i_op->put_link(path->dentry, nd, cookie);
584         path_put(path);
585         current->link_count--;
586         nd->depth--;
587         return err;
588 loop:
589         path_put_conditional(path, nd);
590         path_put(&nd->path);
591         return err;
592 }
593
594 int follow_up(struct path *path)
595 {
596         struct vfsmount *parent;
597         struct dentry *mountpoint;
598         spin_lock(&vfsmount_lock);
599         parent = path->mnt->mnt_parent;
600         if (parent == path->mnt) {
601                 spin_unlock(&vfsmount_lock);
602                 return 0;
603         }
604         mntget(parent);
605         mountpoint = dget(path->mnt->mnt_mountpoint);
606         spin_unlock(&vfsmount_lock);
607         dput(path->dentry);
608         path->dentry = mountpoint;
609         mntput(path->mnt);
610         path->mnt = parent;
611         return 1;
612 }
613
614 /* no need for dcache_lock, as serialization is taken care in
615  * namespace.c
616  */
617 static int __follow_mount(struct path *path)
618 {
619         int res = 0;
620         while (d_mountpoint(path->dentry)) {
621                 struct vfsmount *mounted = lookup_mnt(path);
622                 if (!mounted)
623                         break;
624                 dput(path->dentry);
625                 if (res)
626                         mntput(path->mnt);
627                 path->mnt = mounted;
628                 path->dentry = dget(mounted->mnt_root);
629                 res = 1;
630         }
631         return res;
632 }
633
634 static void follow_mount(struct path *path)
635 {
636         while (d_mountpoint(path->dentry)) {
637                 struct vfsmount *mounted = lookup_mnt(path);
638                 if (!mounted)
639                         break;
640                 dput(path->dentry);
641                 mntput(path->mnt);
642                 path->mnt = mounted;
643                 path->dentry = dget(mounted->mnt_root);
644         }
645 }
646
647 /* no need for dcache_lock, as serialization is taken care in
648  * namespace.c
649  */
650 int follow_down(struct path *path)
651 {
652         struct vfsmount *mounted;
653
654         mounted = lookup_mnt(path);
655         if (mounted) {
656                 dput(path->dentry);
657                 mntput(path->mnt);
658                 path->mnt = mounted;
659                 path->dentry = dget(mounted->mnt_root);
660                 return 1;
661         }
662         return 0;
663 }
664
665 static __always_inline void follow_dotdot(struct nameidata *nd)
666 {
667         set_root(nd);
668
669         while(1) {
670                 struct dentry *old = nd->path.dentry;
671
672                 if (nd->path.dentry == nd->root.dentry &&
673                     nd->path.mnt == nd->root.mnt) {
674                         break;
675                 }
676                 if (nd->path.dentry != nd->path.mnt->mnt_root) {
677                         /* rare case of legitimate dget_parent()... */
678                         nd->path.dentry = dget_parent(nd->path.dentry);
679                         dput(old);
680                         break;
681                 }
682                 if (!follow_up(&nd->path))
683                         break;
684         }
685         follow_mount(&nd->path);
686 }
687
688 /*
689  * Allocate a dentry with name and parent, and perform a parent
690  * directory ->lookup on it. Returns the new dentry, or ERR_PTR
691  * on error. parent->d_inode->i_mutex must be held. d_lookup must
692  * have verified that no child exists while under i_mutex.
693  */
694 static struct dentry *d_alloc_and_lookup(struct dentry *parent,
695                                 struct qstr *name, struct nameidata *nd)
696 {
697         struct inode *inode = parent->d_inode;
698         struct dentry *dentry;
699         struct dentry *old;
700
701         /* Don't create child dentry for a dead directory. */
702         if (unlikely(IS_DEADDIR(inode)))
703                 return ERR_PTR(-ENOENT);
704
705         dentry = d_alloc(parent, name);
706         if (unlikely(!dentry))
707                 return ERR_PTR(-ENOMEM);
708
709         old = inode->i_op->lookup(inode, dentry, nd);
710         if (unlikely(old)) {
711                 dput(dentry);
712                 dentry = old;
713         }
714         return dentry;
715 }
716
717 /*
718  *  It's more convoluted than I'd like it to be, but... it's still fairly
719  *  small and for now I'd prefer to have fast path as straight as possible.
720  *  It _is_ time-critical.
721  */
722 static int do_lookup(struct nameidata *nd, struct qstr *name,
723                      struct path *path)
724 {
725         struct vfsmount *mnt = nd->path.mnt;
726         struct dentry *dentry, *parent;
727         struct inode *dir;
728         /*
729          * See if the low-level filesystem might want
730          * to use its own hash..
731          */
732         if (nd->path.dentry->d_op && nd->path.dentry->d_op->d_hash) {
733                 int err = nd->path.dentry->d_op->d_hash(nd->path.dentry, name);
734                 if (err < 0)
735                         return err;
736         }
737
738         /*
739          * Rename seqlock is not required here because in the off chance
740          * of a false negative due to a concurrent rename, we're going to
741          * do the non-racy lookup, below.
742          */
743         dentry = __d_lookup(nd->path.dentry, name);
744         if (!dentry)
745                 goto need_lookup;
746 found:
747         if (dentry->d_op && dentry->d_op->d_revalidate)
748                 goto need_revalidate;
749 done:
750         path->mnt = mnt;
751         path->dentry = dentry;
752         __follow_mount(path);
753         return 0;
754
755 need_lookup:
756         parent = nd->path.dentry;
757         dir = parent->d_inode;
758
759         mutex_lock(&dir->i_mutex);
760         /*
761          * First re-do the cached lookup just in case it was created
762          * while we waited for the directory semaphore, or the first
763          * lookup failed due to an unrelated rename.
764          *
765          * This could use version numbering or similar to avoid unnecessary
766          * cache lookups, but then we'd have to do the first lookup in the
767          * non-racy way. However in the common case here, everything should
768          * be hot in cache, so would it be a big win?
769          */
770         dentry = d_lookup(parent, name);
771         if (likely(!dentry)) {
772                 dentry = d_alloc_and_lookup(parent, name, nd);
773                 mutex_unlock(&dir->i_mutex);
774                 if (IS_ERR(dentry))
775                         goto fail;
776                 goto done;
777         }
778         /*
779          * Uhhuh! Nasty case: the cache was re-populated while
780          * we waited on the semaphore. Need to revalidate.
781          */
782         mutex_unlock(&dir->i_mutex);
783         goto found;
784
785 need_revalidate:
786         dentry = do_revalidate(dentry, nd);
787         if (!dentry)
788                 goto need_lookup;
789         if (IS_ERR(dentry))
790                 goto fail;
791         goto done;
792
793 fail:
794         return PTR_ERR(dentry);
795 }
796
797 /*
798  * This is a temporary kludge to deal with "automount" symlinks; proper
799  * solution is to trigger them on follow_mount(), so that do_lookup()
800  * would DTRT.  To be killed before 2.6.34-final.
801  */
802 static inline int follow_on_final(struct inode *inode, unsigned lookup_flags)
803 {
804         return inode && unlikely(inode->i_op->follow_link) &&
805                 ((lookup_flags & LOOKUP_FOLLOW) || S_ISDIR(inode->i_mode));
806 }
807
808 /*
809  * Name resolution.
810  * This is the basic name resolution function, turning a pathname into
811  * the final dentry. We expect 'base' to be positive and a directory.
812  *
813  * Returns 0 and nd will have valid dentry and mnt on success.
814  * Returns error and drops reference to input namei data on failure.
815  */
816 static int link_path_walk(const char *name, struct nameidata *nd)
817 {
818         struct path next;
819         struct inode *inode;
820         int err;
821         unsigned int lookup_flags = nd->flags;
822         
823         while (*name=='/')
824                 name++;
825         if (!*name)
826                 goto return_reval;
827
828         inode = nd->path.dentry->d_inode;
829         if (nd->depth)
830                 lookup_flags = LOOKUP_FOLLOW | (nd->flags & LOOKUP_CONTINUE);
831
832         /* At this point we know we have a real path component. */
833         for(;;) {
834                 unsigned long hash;
835                 struct qstr this;
836                 unsigned int c;
837
838                 nd->flags |= LOOKUP_CONTINUE;
839                 err = exec_permission(inode);
840                 if (err)
841                         break;
842
843                 this.name = name;
844                 c = *(const unsigned char *)name;
845
846                 hash = init_name_hash();
847                 do {
848                         name++;
849                         hash = partial_name_hash(c, hash);
850                         c = *(const unsigned char *)name;
851                 } while (c && (c != '/'));
852                 this.len = name - (const char *) this.name;
853                 this.hash = end_name_hash(hash);
854
855                 /* remove trailing slashes? */
856                 if (!c)
857                         goto last_component;
858                 while (*++name == '/');
859                 if (!*name)
860                         goto last_with_slashes;
861
862                 /*
863                  * "." and ".." are special - ".." especially so because it has
864                  * to be able to know about the current root directory and
865                  * parent relationships.
866                  */
867                 if (this.name[0] == '.') switch (this.len) {
868                         default:
869                                 break;
870                         case 2: 
871                                 if (this.name[1] != '.')
872                                         break;
873                                 follow_dotdot(nd);
874                                 inode = nd->path.dentry->d_inode;
875                                 /* fallthrough */
876                         case 1:
877                                 continue;
878                 }
879                 /* This does the actual lookups.. */
880                 err = do_lookup(nd, &this, &next);
881                 if (err)
882                         break;
883
884                 err = -ENOENT;
885                 inode = next.dentry->d_inode;
886                 if (!inode)
887                         goto out_dput;
888
889                 if (inode->i_op->follow_link) {
890                         err = do_follow_link(&next, nd);
891                         if (err)
892                                 goto return_err;
893                         err = -ENOENT;
894                         inode = nd->path.dentry->d_inode;
895                         if (!inode)
896                                 break;
897                 } else
898                         path_to_nameidata(&next, nd);
899                 err = -ENOTDIR; 
900                 if (!inode->i_op->lookup)
901                         break;
902                 continue;
903                 /* here ends the main loop */
904
905 last_with_slashes:
906                 lookup_flags |= LOOKUP_FOLLOW | LOOKUP_DIRECTORY;
907 last_component:
908                 /* Clear LOOKUP_CONTINUE iff it was previously unset */
909                 nd->flags &= lookup_flags | ~LOOKUP_CONTINUE;
910                 if (lookup_flags & LOOKUP_PARENT)
911                         goto lookup_parent;
912                 if (this.name[0] == '.') switch (this.len) {
913                         default:
914                                 break;
915                         case 2: 
916                                 if (this.name[1] != '.')
917                                         break;
918                                 follow_dotdot(nd);
919                                 inode = nd->path.dentry->d_inode;
920                                 /* fallthrough */
921                         case 1:
922                                 goto return_reval;
923                 }
924                 err = do_lookup(nd, &this, &next);
925                 if (err)
926                         break;
927                 inode = next.dentry->d_inode;
928                 if (follow_on_final(inode, lookup_flags)) {
929                         err = do_follow_link(&next, nd);
930                         if (err)
931                                 goto return_err;
932                         inode = nd->path.dentry->d_inode;
933                 } else
934                         path_to_nameidata(&next, nd);
935                 err = -ENOENT;
936                 if (!inode)
937                         break;
938                 if (lookup_flags & LOOKUP_DIRECTORY) {
939                         err = -ENOTDIR; 
940                         if (!inode->i_op->lookup)
941                                 break;
942                 }
943                 goto return_base;
944 lookup_parent:
945                 nd->last = this;
946                 nd->last_type = LAST_NORM;
947                 if (this.name[0] != '.')
948                         goto return_base;
949                 if (this.len == 1)
950                         nd->last_type = LAST_DOT;
951                 else if (this.len == 2 && this.name[1] == '.')
952                         nd->last_type = LAST_DOTDOT;
953                 else
954                         goto return_base;
955 return_reval:
956                 /*
957                  * We bypassed the ordinary revalidation routines.
958                  * We may need to check the cached dentry for staleness.
959                  */
960                 if (nd->path.dentry && nd->path.dentry->d_sb &&
961                     (nd->path.dentry->d_sb->s_type->fs_flags & FS_REVAL_DOT)) {
962                         err = -ESTALE;
963                         /* Note: we do not d_invalidate() */
964                         if (!nd->path.dentry->d_op->d_revalidate(
965                                         nd->path.dentry, nd))
966                                 break;
967                 }
968 return_base:
969                 return 0;
970 out_dput:
971                 path_put_conditional(&next, nd);
972                 break;
973         }
974         path_put(&nd->path);
975 return_err:
976         return err;
977 }
978
979 static int path_walk(const char *name, struct nameidata *nd)
980 {
981         struct path save = nd->path;
982         int result;
983
984         current->total_link_count = 0;
985
986         /* make sure the stuff we saved doesn't go away */
987         path_get(&save);
988
989         result = link_path_walk(name, nd);
990         if (result == -ESTALE) {
991                 /* nd->path had been dropped */
992                 current->total_link_count = 0;
993                 nd->path = save;
994                 path_get(&nd->path);
995                 nd->flags |= LOOKUP_REVAL;
996                 result = link_path_walk(name, nd);
997         }
998
999         path_put(&save);
1000
1001         return result;
1002 }
1003
1004 static int path_init(int dfd, const char *name, unsigned int flags, struct nameidata *nd)
1005 {
1006         int retval = 0;
1007         int fput_needed;
1008         struct file *file;
1009
1010         nd->last_type = LAST_ROOT; /* if there are only slashes... */
1011         nd->flags = flags;
1012         nd->depth = 0;
1013         nd->root.mnt = NULL;
1014
1015         if (*name=='/') {
1016                 set_root(nd);
1017                 nd->path = nd->root;
1018                 path_get(&nd->root);
1019         } else if (dfd == AT_FDCWD) {
1020                 get_fs_pwd(current->fs, &nd->path);
1021         } else {
1022                 struct dentry *dentry;
1023
1024                 file = fget_light(dfd, &fput_needed);
1025                 retval = -EBADF;
1026                 if (!file)
1027                         goto out_fail;
1028
1029                 dentry = file->f_path.dentry;
1030
1031                 retval = -ENOTDIR;
1032                 if (!S_ISDIR(dentry->d_inode->i_mode))
1033                         goto fput_fail;
1034
1035                 retval = file_permission(file, MAY_EXEC);
1036                 if (retval)
1037                         goto fput_fail;
1038
1039                 nd->path = file->f_path;
1040                 path_get(&file->f_path);
1041
1042                 fput_light(file, fput_needed);
1043         }
1044         return 0;
1045
1046 fput_fail:
1047         fput_light(file, fput_needed);
1048 out_fail:
1049         return retval;
1050 }
1051
1052 /* Returns 0 and nd will be valid on success; Retuns error, otherwise. */
1053 static int do_path_lookup(int dfd, const char *name,
1054                                 unsigned int flags, struct nameidata *nd)
1055 {
1056         int retval = path_init(dfd, name, flags, nd);
1057         if (!retval)
1058                 retval = path_walk(name, nd);
1059         if (unlikely(!retval && !audit_dummy_context() && nd->path.dentry &&
1060                                 nd->path.dentry->d_inode))
1061                 audit_inode(name, nd->path.dentry);
1062         if (nd->root.mnt) {
1063                 path_put(&nd->root);
1064                 nd->root.mnt = NULL;
1065         }
1066         return retval;
1067 }
1068
1069 int path_lookup(const char *name, unsigned int flags,
1070                         struct nameidata *nd)
1071 {
1072         return do_path_lookup(AT_FDCWD, name, flags, nd);
1073 }
1074
1075 int kern_path(const char *name, unsigned int flags, struct path *path)
1076 {
1077         struct nameidata nd;
1078         int res = do_path_lookup(AT_FDCWD, name, flags, &nd);
1079         if (!res)
1080                 *path = nd.path;
1081         return res;
1082 }
1083
1084 /**
1085  * vfs_path_lookup - lookup a file path relative to a dentry-vfsmount pair
1086  * @dentry:  pointer to dentry of the base directory
1087  * @mnt: pointer to vfs mount of the base directory
1088  * @name: pointer to file name
1089  * @flags: lookup flags
1090  * @nd: pointer to nameidata
1091  */
1092 int vfs_path_lookup(struct dentry *dentry, struct vfsmount *mnt,
1093                     const char *name, unsigned int flags,
1094                     struct nameidata *nd)
1095 {
1096         int retval;
1097
1098         /* same as do_path_lookup */
1099         nd->last_type = LAST_ROOT;
1100         nd->flags = flags;
1101         nd->depth = 0;
1102
1103         nd->path.dentry = dentry;
1104         nd->path.mnt = mnt;
1105         path_get(&nd->path);
1106         nd->root = nd->path;
1107         path_get(&nd->root);
1108
1109         retval = path_walk(name, nd);
1110         if (unlikely(!retval && !audit_dummy_context() && nd->path.dentry &&
1111                                 nd->path.dentry->d_inode))
1112                 audit_inode(name, nd->path.dentry);
1113
1114         path_put(&nd->root);
1115         nd->root.mnt = NULL;
1116
1117         return retval;
1118 }
1119
1120 static struct dentry *__lookup_hash(struct qstr *name,
1121                 struct dentry *base, struct nameidata *nd)
1122 {
1123         struct dentry *dentry;
1124         struct inode *inode;
1125         int err;
1126
1127         inode = base->d_inode;
1128
1129         /*
1130          * See if the low-level filesystem might want
1131          * to use its own hash..
1132          */
1133         if (base->d_op && base->d_op->d_hash) {
1134                 err = base->d_op->d_hash(base, name);
1135                 dentry = ERR_PTR(err);
1136                 if (err < 0)
1137                         goto out;
1138         }
1139
1140         /*
1141          * Don't bother with __d_lookup: callers are for creat as
1142          * well as unlink, so a lot of the time it would cost
1143          * a double lookup.
1144          */
1145         dentry = d_lookup(base, name);
1146
1147         if (dentry && dentry->d_op && dentry->d_op->d_revalidate)
1148                 dentry = do_revalidate(dentry, nd);
1149
1150         if (!dentry)
1151                 dentry = d_alloc_and_lookup(base, name, nd);
1152 out:
1153         return dentry;
1154 }
1155
1156 /*
1157  * Restricted form of lookup. Doesn't follow links, single-component only,
1158  * needs parent already locked. Doesn't follow mounts.
1159  * SMP-safe.
1160  */
1161 static struct dentry *lookup_hash(struct nameidata *nd)
1162 {
1163         int err;
1164
1165         err = exec_permission(nd->path.dentry->d_inode);
1166         if (err)
1167                 return ERR_PTR(err);
1168         return __lookup_hash(&nd->last, nd->path.dentry, nd);
1169 }
1170
1171 static int __lookup_one_len(const char *name, struct qstr *this,
1172                 struct dentry *base, int len)
1173 {
1174         unsigned long hash;
1175         unsigned int c;
1176
1177         this->name = name;
1178         this->len = len;
1179         if (!len)
1180                 return -EACCES;
1181
1182         hash = init_name_hash();
1183         while (len--) {
1184                 c = *(const unsigned char *)name++;
1185                 if (c == '/' || c == '\0')
1186                         return -EACCES;
1187                 hash = partial_name_hash(c, hash);
1188         }
1189         this->hash = end_name_hash(hash);
1190         return 0;
1191 }
1192
1193 /**
1194  * lookup_one_len - filesystem helper to lookup single pathname component
1195  * @name:       pathname component to lookup
1196  * @base:       base directory to lookup from
1197  * @len:        maximum length @len should be interpreted to
1198  *
1199  * Note that this routine is purely a helper for filesystem usage and should
1200  * not be called by generic code.  Also note that by using this function the
1201  * nameidata argument is passed to the filesystem methods and a filesystem
1202  * using this helper needs to be prepared for that.
1203  */
1204 struct dentry *lookup_one_len(const char *name, struct dentry *base, int len)
1205 {
1206         int err;
1207         struct qstr this;
1208
1209         WARN_ON_ONCE(!mutex_is_locked(&base->d_inode->i_mutex));
1210
1211         err = __lookup_one_len(name, &this, base, len);
1212         if (err)
1213                 return ERR_PTR(err);
1214
1215         err = exec_permission(base->d_inode);
1216         if (err)
1217                 return ERR_PTR(err);
1218         return __lookup_hash(&this, base, NULL);
1219 }
1220
1221 int user_path_at(int dfd, const char __user *name, unsigned flags,
1222                  struct path *path)
1223 {
1224         struct nameidata nd;
1225         char *tmp = getname(name);
1226         int err = PTR_ERR(tmp);
1227         if (!IS_ERR(tmp)) {
1228
1229                 BUG_ON(flags & LOOKUP_PARENT);
1230
1231                 err = do_path_lookup(dfd, tmp, flags, &nd);
1232                 putname(tmp);
1233                 if (!err)
1234                         *path = nd.path;
1235         }
1236         return err;
1237 }
1238
1239 static int user_path_parent(int dfd, const char __user *path,
1240                         struct nameidata *nd, char **name)
1241 {
1242         char *s = getname(path);
1243         int error;
1244
1245         if (IS_ERR(s))
1246                 return PTR_ERR(s);
1247
1248         error = do_path_lookup(dfd, s, LOOKUP_PARENT, nd);
1249         if (error)
1250                 putname(s);
1251         else
1252                 *name = s;
1253
1254         return error;
1255 }
1256
1257 /*
1258  * It's inline, so penalty for filesystems that don't use sticky bit is
1259  * minimal.
1260  */
1261 static inline int check_sticky(struct inode *dir, struct inode *inode)
1262 {
1263         uid_t fsuid = current_fsuid();
1264
1265         if (!(dir->i_mode & S_ISVTX))
1266                 return 0;
1267         if (inode->i_uid == fsuid)
1268                 return 0;
1269         if (dir->i_uid == fsuid)
1270                 return 0;
1271         return !capable(CAP_FOWNER);
1272 }
1273
1274 /*
1275  *      Check whether we can remove a link victim from directory dir, check
1276  *  whether the type of victim is right.
1277  *  1. We can't do it if dir is read-only (done in permission())
1278  *  2. We should have write and exec permissions on dir
1279  *  3. We can't remove anything from append-only dir
1280  *  4. We can't do anything with immutable dir (done in permission())
1281  *  5. If the sticky bit on dir is set we should either
1282  *      a. be owner of dir, or
1283  *      b. be owner of victim, or
1284  *      c. have CAP_FOWNER capability
1285  *  6. If the victim is append-only or immutable we can't do antyhing with
1286  *     links pointing to it.
1287  *  7. If we were asked to remove a directory and victim isn't one - ENOTDIR.
1288  *  8. If we were asked to remove a non-directory and victim isn't one - EISDIR.
1289  *  9. We can't remove a root or mountpoint.
1290  * 10. We don't allow removal of NFS sillyrenamed files; it's handled by
1291  *     nfs_async_unlink().
1292  */
1293 static int may_delete(struct inode *dir,struct dentry *victim,int isdir)
1294 {
1295         int error;
1296
1297         if (!victim->d_inode)
1298                 return -ENOENT;
1299
1300         BUG_ON(victim->d_parent->d_inode != dir);
1301         audit_inode_child(victim, dir);
1302
1303         error = inode_permission(dir, MAY_WRITE | MAY_EXEC);
1304         if (error)
1305                 return error;
1306         if (IS_APPEND(dir))
1307                 return -EPERM;
1308         if (check_sticky(dir, victim->d_inode)||IS_APPEND(victim->d_inode)||
1309             IS_IMMUTABLE(victim->d_inode) || IS_SWAPFILE(victim->d_inode))
1310                 return -EPERM;
1311         if (isdir) {
1312                 if (!S_ISDIR(victim->d_inode->i_mode))
1313                         return -ENOTDIR;
1314                 if (IS_ROOT(victim))
1315                         return -EBUSY;
1316         } else if (S_ISDIR(victim->d_inode->i_mode))
1317                 return -EISDIR;
1318         if (IS_DEADDIR(dir))
1319                 return -ENOENT;
1320         if (victim->d_flags & DCACHE_NFSFS_RENAMED)
1321                 return -EBUSY;
1322         return 0;
1323 }
1324
1325 /*      Check whether we can create an object with dentry child in directory
1326  *  dir.
1327  *  1. We can't do it if child already exists (open has special treatment for
1328  *     this case, but since we are inlined it's OK)
1329  *  2. We can't do it if dir is read-only (done in permission())
1330  *  3. We should have write and exec permissions on dir
1331  *  4. We can't do it if dir is immutable (done in permission())
1332  */
1333 static inline int may_create(struct inode *dir, struct dentry *child)
1334 {
1335         if (child->d_inode)
1336                 return -EEXIST;
1337         if (IS_DEADDIR(dir))
1338                 return -ENOENT;
1339         return inode_permission(dir, MAY_WRITE | MAY_EXEC);
1340 }
1341
1342 /*
1343  * p1 and p2 should be directories on the same fs.
1344  */
1345 struct dentry *lock_rename(struct dentry *p1, struct dentry *p2)
1346 {
1347         struct dentry *p;
1348
1349         if (p1 == p2) {
1350                 mutex_lock_nested(&p1->d_inode->i_mutex, I_MUTEX_PARENT);
1351                 return NULL;
1352         }
1353
1354         mutex_lock(&p1->d_inode->i_sb->s_vfs_rename_mutex);
1355
1356         p = d_ancestor(p2, p1);
1357         if (p) {
1358                 mutex_lock_nested(&p2->d_inode->i_mutex, I_MUTEX_PARENT);
1359                 mutex_lock_nested(&p1->d_inode->i_mutex, I_MUTEX_CHILD);
1360                 return p;
1361         }
1362
1363         p = d_ancestor(p1, p2);
1364         if (p) {
1365                 mutex_lock_nested(&p1->d_inode->i_mutex, I_MUTEX_PARENT);
1366                 mutex_lock_nested(&p2->d_inode->i_mutex, I_MUTEX_CHILD);
1367                 return p;
1368         }
1369
1370         mutex_lock_nested(&p1->d_inode->i_mutex, I_MUTEX_PARENT);
1371         mutex_lock_nested(&p2->d_inode->i_mutex, I_MUTEX_CHILD);
1372         return NULL;
1373 }
1374
1375 void unlock_rename(struct dentry *p1, struct dentry *p2)
1376 {
1377         mutex_unlock(&p1->d_inode->i_mutex);
1378         if (p1 != p2) {
1379                 mutex_unlock(&p2->d_inode->i_mutex);
1380                 mutex_unlock(&p1->d_inode->i_sb->s_vfs_rename_mutex);
1381         }
1382 }
1383
1384 int vfs_create(struct inode *dir, struct dentry *dentry, int mode,
1385                 struct nameidata *nd)
1386 {
1387         int error = may_create(dir, dentry);
1388
1389         if (error)
1390                 return error;
1391
1392         if (!dir->i_op->create)
1393                 return -EACCES; /* shouldn't it be ENOSYS? */
1394         mode &= S_IALLUGO;
1395         mode |= S_IFREG;
1396         error = security_inode_create(dir, dentry, mode);
1397         if (error)
1398                 return error;
1399         error = dir->i_op->create(dir, dentry, mode, nd);
1400         if (!error)
1401                 fsnotify_create(dir, dentry);
1402         return error;
1403 }
1404
1405 int may_open(struct path *path, int acc_mode, int flag)
1406 {
1407         struct dentry *dentry = path->dentry;
1408         struct inode *inode = dentry->d_inode;
1409         int error;
1410
1411         if (!inode)
1412                 return -ENOENT;
1413
1414         switch (inode->i_mode & S_IFMT) {
1415         case S_IFLNK:
1416                 return -ELOOP;
1417         case S_IFDIR:
1418                 if (acc_mode & MAY_WRITE)
1419                         return -EISDIR;
1420                 break;
1421         case S_IFBLK:
1422         case S_IFCHR:
1423                 if (path->mnt->mnt_flags & MNT_NODEV)
1424                         return -EACCES;
1425                 /*FALLTHRU*/
1426         case S_IFIFO:
1427         case S_IFSOCK:
1428                 flag &= ~O_TRUNC;
1429                 break;
1430         }
1431
1432         error = inode_permission(inode, acc_mode);
1433         if (error)
1434                 return error;
1435
1436         /*
1437          * An append-only file must be opened in append mode for writing.
1438          */
1439         if (IS_APPEND(inode)) {
1440                 if  ((flag & O_ACCMODE) != O_RDONLY && !(flag & O_APPEND))
1441                         return -EPERM;
1442                 if (flag & O_TRUNC)
1443                         return -EPERM;
1444         }
1445
1446         /* O_NOATIME can only be set by the owner or superuser */
1447         if (flag & O_NOATIME && !is_owner_or_cap(inode))
1448                 return -EPERM;
1449
1450         /*
1451          * Ensure there are no outstanding leases on the file.
1452          */
1453         return break_lease(inode, flag);
1454 }
1455
1456 static int handle_truncate(struct path *path)
1457 {
1458         struct inode *inode = path->dentry->d_inode;
1459         int error = get_write_access(inode);
1460         if (error)
1461                 return error;
1462         /*
1463          * Refuse to truncate files with mandatory locks held on them.
1464          */
1465         error = locks_verify_locked(inode);
1466         if (!error)
1467                 error = security_path_truncate(path);
1468         if (!error) {
1469                 error = do_truncate(path->dentry, 0,
1470                                     ATTR_MTIME|ATTR_CTIME|ATTR_OPEN,
1471                                     NULL);
1472         }
1473         put_write_access(inode);
1474         return error;
1475 }
1476
1477 /*
1478  * Be careful about ever adding any more callers of this
1479  * function.  Its flags must be in the namei format, not
1480  * what get passed to sys_open().
1481  */
1482 static int __open_namei_create(struct nameidata *nd, struct path *path,
1483                                 int open_flag, int mode)
1484 {
1485         int error;
1486         struct dentry *dir = nd->path.dentry;
1487
1488         if (!IS_POSIXACL(dir->d_inode))
1489                 mode &= ~current_umask();
1490         error = security_path_mknod(&nd->path, path->dentry, mode, 0);
1491         if (error)
1492                 goto out_unlock;
1493         error = vfs_create(dir->d_inode, path->dentry, mode, nd);
1494 out_unlock:
1495         mutex_unlock(&dir->d_inode->i_mutex);
1496         dput(nd->path.dentry);
1497         nd->path.dentry = path->dentry;
1498         if (error)
1499                 return error;
1500         /* Don't check for write permission, don't truncate */
1501         return may_open(&nd->path, 0, open_flag & ~O_TRUNC);
1502 }
1503
1504 /*
1505  * Note that while the flag value (low two bits) for sys_open means:
1506  *      00 - read-only
1507  *      01 - write-only
1508  *      10 - read-write
1509  *      11 - special
1510  * it is changed into
1511  *      00 - no permissions needed
1512  *      01 - read-permission
1513  *      10 - write-permission
1514  *      11 - read-write
1515  * for the internal routines (ie open_namei()/follow_link() etc)
1516  * This is more logical, and also allows the 00 "no perm needed"
1517  * to be used for symlinks (where the permissions are checked
1518  * later).
1519  *
1520 */
1521 static inline int open_to_namei_flags(int flag)
1522 {
1523         if ((flag+1) & O_ACCMODE)
1524                 flag++;
1525         return flag;
1526 }
1527
1528 static int open_will_truncate(int flag, struct inode *inode)
1529 {
1530         /*
1531          * We'll never write to the fs underlying
1532          * a device file.
1533          */
1534         if (special_file(inode->i_mode))
1535                 return 0;
1536         return (flag & O_TRUNC);
1537 }
1538
1539 static struct file *finish_open(struct nameidata *nd,
1540                                 int open_flag, int acc_mode)
1541 {
1542         struct file *filp;
1543         int will_truncate;
1544         int error;
1545
1546         will_truncate = open_will_truncate(open_flag, nd->path.dentry->d_inode);
1547         if (will_truncate) {
1548                 error = mnt_want_write(nd->path.mnt);
1549                 if (error)
1550                         goto exit;
1551         }
1552         error = may_open(&nd->path, acc_mode, open_flag);
1553         if (error) {
1554                 if (will_truncate)
1555                         mnt_drop_write(nd->path.mnt);
1556                 goto exit;
1557         }
1558         filp = nameidata_to_filp(nd);
1559         if (!IS_ERR(filp)) {
1560                 error = ima_file_check(filp, acc_mode);
1561                 if (error) {
1562                         fput(filp);
1563                         filp = ERR_PTR(error);
1564                 }
1565         }
1566         if (!IS_ERR(filp)) {
1567                 if (will_truncate) {
1568                         error = handle_truncate(&nd->path);
1569                         if (error) {
1570                                 fput(filp);
1571                                 filp = ERR_PTR(error);
1572                         }
1573                 }
1574         }
1575         /*
1576          * It is now safe to drop the mnt write
1577          * because the filp has had a write taken
1578          * on its behalf.
1579          */
1580         if (will_truncate)
1581                 mnt_drop_write(nd->path.mnt);
1582         return filp;
1583
1584 exit:
1585         if (!IS_ERR(nd->intent.open.file))
1586                 release_open_intent(nd);
1587         path_put(&nd->path);
1588         return ERR_PTR(error);
1589 }
1590
1591 static struct file *do_last(struct nameidata *nd, struct path *path,
1592                             int open_flag, int acc_mode,
1593                             int mode, const char *pathname)
1594 {
1595         struct dentry *dir = nd->path.dentry;
1596         struct file *filp;
1597         int error = -EISDIR;
1598
1599         switch (nd->last_type) {
1600         case LAST_DOTDOT:
1601                 follow_dotdot(nd);
1602                 dir = nd->path.dentry;
1603         case LAST_DOT:
1604                 if (nd->path.mnt->mnt_sb->s_type->fs_flags & FS_REVAL_DOT) {
1605                         if (!dir->d_op->d_revalidate(dir, nd)) {
1606                                 error = -ESTALE;
1607                                 goto exit;
1608                         }
1609                 }
1610                 /* fallthrough */
1611         case LAST_ROOT:
1612                 if (open_flag & O_CREAT)
1613                         goto exit;
1614                 /* fallthrough */
1615         case LAST_BIND:
1616                 audit_inode(pathname, dir);
1617                 goto ok;
1618         }
1619
1620         /* trailing slashes? */
1621         if (nd->last.name[nd->last.len]) {
1622                 if (open_flag & O_CREAT)
1623                         goto exit;
1624                 nd->flags |= LOOKUP_DIRECTORY | LOOKUP_FOLLOW;
1625         }
1626
1627         /* just plain open? */
1628         if (!(open_flag & O_CREAT)) {
1629                 error = do_lookup(nd, &nd->last, path);
1630                 if (error)
1631                         goto exit;
1632                 error = -ENOENT;
1633                 if (!path->dentry->d_inode)
1634                         goto exit_dput;
1635                 if (path->dentry->d_inode->i_op->follow_link)
1636                         return NULL;
1637                 error = -ENOTDIR;
1638                 if (nd->flags & LOOKUP_DIRECTORY) {
1639                         if (!path->dentry->d_inode->i_op->lookup)
1640                                 goto exit_dput;
1641                 }
1642                 path_to_nameidata(path, nd);
1643                 audit_inode(pathname, nd->path.dentry);
1644                 goto ok;
1645         }
1646
1647         /* OK, it's O_CREAT */
1648         mutex_lock(&dir->d_inode->i_mutex);
1649
1650         path->dentry = lookup_hash(nd);
1651         path->mnt = nd->path.mnt;
1652
1653         error = PTR_ERR(path->dentry);
1654         if (IS_ERR(path->dentry)) {
1655                 mutex_unlock(&dir->d_inode->i_mutex);
1656                 goto exit;
1657         }
1658
1659         if (IS_ERR(nd->intent.open.file)) {
1660                 error = PTR_ERR(nd->intent.open.file);
1661                 goto exit_mutex_unlock;
1662         }
1663
1664         /* Negative dentry, just create the file */
1665         if (!path->dentry->d_inode) {
1666                 /*
1667                  * This write is needed to ensure that a
1668                  * ro->rw transition does not occur between
1669                  * the time when the file is created and when
1670                  * a permanent write count is taken through
1671                  * the 'struct file' in nameidata_to_filp().
1672                  */
1673                 error = mnt_want_write(nd->path.mnt);
1674                 if (error)
1675                         goto exit_mutex_unlock;
1676                 error = __open_namei_create(nd, path, open_flag, mode);
1677                 if (error) {
1678                         mnt_drop_write(nd->path.mnt);
1679                         goto exit;
1680                 }
1681                 filp = nameidata_to_filp(nd);
1682                 mnt_drop_write(nd->path.mnt);
1683                 if (!IS_ERR(filp)) {
1684                         error = ima_file_check(filp, acc_mode);
1685                         if (error) {
1686                                 fput(filp);
1687                                 filp = ERR_PTR(error);
1688                         }
1689                 }
1690                 return filp;
1691         }
1692
1693         /*
1694          * It already exists.
1695          */
1696         mutex_unlock(&dir->d_inode->i_mutex);
1697         audit_inode(pathname, path->dentry);
1698
1699         error = -EEXIST;
1700         if (open_flag & O_EXCL)
1701                 goto exit_dput;
1702
1703         if (__follow_mount(path)) {
1704                 error = -ELOOP;
1705                 if (open_flag & O_NOFOLLOW)
1706                         goto exit_dput;
1707         }
1708
1709         error = -ENOENT;
1710         if (!path->dentry->d_inode)
1711                 goto exit_dput;
1712
1713         if (path->dentry->d_inode->i_op->follow_link)
1714                 return NULL;
1715
1716         path_to_nameidata(path, nd);
1717         error = -EISDIR;
1718         if (S_ISDIR(path->dentry->d_inode->i_mode))
1719                 goto exit;
1720 ok:
1721         filp = finish_open(nd, open_flag, acc_mode);
1722         return filp;
1723
1724 exit_mutex_unlock:
1725         mutex_unlock(&dir->d_inode->i_mutex);
1726 exit_dput:
1727         path_put_conditional(path, nd);
1728 exit:
1729         if (!IS_ERR(nd->intent.open.file))
1730                 release_open_intent(nd);
1731         path_put(&nd->path);
1732         return ERR_PTR(error);
1733 }
1734
1735 /*
1736  * Note that the low bits of the passed in "open_flag"
1737  * are not the same as in the local variable "flag". See
1738  * open_to_namei_flags() for more details.
1739  */
1740 struct file *do_filp_open(int dfd, const char *pathname,
1741                 int open_flag, int mode, int acc_mode)
1742 {
1743         struct file *filp;
1744         struct nameidata nd;
1745         int error;
1746         struct path path;
1747         int count = 0;
1748         int flag = open_to_namei_flags(open_flag);
1749         int force_reval = 0;
1750
1751         if (!(open_flag & O_CREAT))
1752                 mode = 0;
1753
1754         /*
1755          * O_SYNC is implemented as __O_SYNC|O_DSYNC.  As many places only
1756          * check for O_DSYNC if the need any syncing at all we enforce it's
1757          * always set instead of having to deal with possibly weird behaviour
1758          * for malicious applications setting only __O_SYNC.
1759          */
1760         if (open_flag & __O_SYNC)
1761                 open_flag |= O_DSYNC;
1762
1763         if (!acc_mode)
1764                 acc_mode = MAY_OPEN | ACC_MODE(open_flag);
1765
1766         /* O_TRUNC implies we need access checks for write permissions */
1767         if (open_flag & O_TRUNC)
1768                 acc_mode |= MAY_WRITE;
1769
1770         /* Allow the LSM permission hook to distinguish append 
1771            access from general write access. */
1772         if (open_flag & O_APPEND)
1773                 acc_mode |= MAY_APPEND;
1774
1775         /* find the parent */
1776 reval:
1777         error = path_init(dfd, pathname, LOOKUP_PARENT, &nd);
1778         if (error)
1779                 return ERR_PTR(error);
1780         if (force_reval)
1781                 nd.flags |= LOOKUP_REVAL;
1782
1783         current->total_link_count = 0;
1784         error = link_path_walk(pathname, &nd);
1785         if (error) {
1786                 filp = ERR_PTR(error);
1787                 goto out;
1788         }
1789         if (unlikely(!audit_dummy_context()) && (open_flag & O_CREAT))
1790                 audit_inode(pathname, nd.path.dentry);
1791
1792         /*
1793          * We have the parent and last component.
1794          */
1795
1796         error = -ENFILE;
1797         filp = get_empty_filp();
1798         if (filp == NULL)
1799                 goto exit_parent;
1800         nd.intent.open.file = filp;
1801         filp->f_flags = open_flag;
1802         nd.intent.open.flags = flag;
1803         nd.intent.open.create_mode = mode;
1804         nd.flags &= ~LOOKUP_PARENT;
1805         nd.flags |= LOOKUP_OPEN;
1806         if (open_flag & O_CREAT) {
1807                 nd.flags |= LOOKUP_CREATE;
1808                 if (open_flag & O_EXCL)
1809                         nd.flags |= LOOKUP_EXCL;
1810         }
1811         if (open_flag & O_DIRECTORY)
1812                 nd.flags |= LOOKUP_DIRECTORY;
1813         if (!(open_flag & O_NOFOLLOW))
1814                 nd.flags |= LOOKUP_FOLLOW;
1815         filp = do_last(&nd, &path, open_flag, acc_mode, mode, pathname);
1816         while (unlikely(!filp)) { /* trailing symlink */
1817                 struct path holder;
1818                 struct inode *inode = path.dentry->d_inode;
1819                 void *cookie;
1820                 error = -ELOOP;
1821                 /* S_ISDIR part is a temporary automount kludge */
1822                 if (!(nd.flags & LOOKUP_FOLLOW) && !S_ISDIR(inode->i_mode))
1823                         goto exit_dput;
1824                 if (count++ == 32)
1825                         goto exit_dput;
1826                 /*
1827                  * This is subtle. Instead of calling do_follow_link() we do
1828                  * the thing by hands. The reason is that this way we have zero
1829                  * link_count and path_walk() (called from ->follow_link)
1830                  * honoring LOOKUP_PARENT.  After that we have the parent and
1831                  * last component, i.e. we are in the same situation as after
1832                  * the first path_walk().  Well, almost - if the last component
1833                  * is normal we get its copy stored in nd->last.name and we will
1834                  * have to putname() it when we are done. Procfs-like symlinks
1835                  * just set LAST_BIND.
1836                  */
1837                 nd.flags |= LOOKUP_PARENT;
1838                 error = security_inode_follow_link(path.dentry, &nd);
1839                 if (error)
1840                         goto exit_dput;
1841                 error = __do_follow_link(&path, &nd, &cookie);
1842                 if (unlikely(error)) {
1843                         /* nd.path had been dropped */
1844                         if (!IS_ERR(cookie) && inode->i_op->put_link)
1845                                 inode->i_op->put_link(path.dentry, &nd, cookie);
1846                         path_put(&path);
1847                         release_open_intent(&nd);
1848                         filp = ERR_PTR(error);
1849                         goto out;
1850                 }
1851                 holder = path;
1852                 nd.flags &= ~LOOKUP_PARENT;
1853                 filp = do_last(&nd, &path, open_flag, acc_mode, mode, pathname);
1854                 if (inode->i_op->put_link)
1855                         inode->i_op->put_link(holder.dentry, &nd, cookie);
1856                 path_put(&holder);
1857         }
1858 out:
1859         if (nd.root.mnt)
1860                 path_put(&nd.root);
1861         if (filp == ERR_PTR(-ESTALE) && !force_reval) {
1862                 force_reval = 1;
1863                 goto reval;
1864         }
1865         return filp;
1866
1867 exit_dput:
1868         path_put_conditional(&path, &nd);
1869         if (!IS_ERR(nd.intent.open.file))
1870                 release_open_intent(&nd);
1871 exit_parent:
1872         path_put(&nd.path);
1873         filp = ERR_PTR(error);
1874         goto out;
1875 }
1876
1877 /**
1878  * filp_open - open file and return file pointer
1879  *
1880  * @filename:   path to open
1881  * @flags:      open flags as per the open(2) second argument
1882  * @mode:       mode for the new file if O_CREAT is set, else ignored
1883  *
1884  * This is the helper to open a file from kernelspace if you really
1885  * have to.  But in generally you should not do this, so please move
1886  * along, nothing to see here..
1887  */
1888 struct file *filp_open(const char *filename, int flags, int mode)
1889 {
1890         return do_filp_open(AT_FDCWD, filename, flags, mode, 0);
1891 }
1892 EXPORT_SYMBOL(filp_open);
1893
1894 /**
1895  * lookup_create - lookup a dentry, creating it if it doesn't exist
1896  * @nd: nameidata info
1897  * @is_dir: directory flag
1898  *
1899  * Simple function to lookup and return a dentry and create it
1900  * if it doesn't exist.  Is SMP-safe.
1901  *
1902  * Returns with nd->path.dentry->d_inode->i_mutex locked.
1903  */
1904 struct dentry *lookup_create(struct nameidata *nd, int is_dir)
1905 {
1906         struct dentry *dentry = ERR_PTR(-EEXIST);
1907
1908         mutex_lock_nested(&nd->path.dentry->d_inode->i_mutex, I_MUTEX_PARENT);
1909         /*
1910          * Yucky last component or no last component at all?
1911          * (foo/., foo/.., /////)
1912          */
1913         if (nd->last_type != LAST_NORM)
1914                 goto fail;
1915         nd->flags &= ~LOOKUP_PARENT;
1916         nd->flags |= LOOKUP_CREATE | LOOKUP_EXCL;
1917         nd->intent.open.flags = O_EXCL;
1918
1919         /*
1920          * Do the final lookup.
1921          */
1922         dentry = lookup_hash(nd);
1923         if (IS_ERR(dentry))
1924                 goto fail;
1925
1926         if (dentry->d_inode)
1927                 goto eexist;
1928         /*
1929          * Special case - lookup gave negative, but... we had foo/bar/
1930          * From the vfs_mknod() POV we just have a negative dentry -
1931          * all is fine. Let's be bastards - you had / on the end, you've
1932          * been asking for (non-existent) directory. -ENOENT for you.
1933          */
1934         if (unlikely(!is_dir && nd->last.name[nd->last.len])) {
1935                 dput(dentry);
1936                 dentry = ERR_PTR(-ENOENT);
1937         }
1938         return dentry;
1939 eexist:
1940         dput(dentry);
1941         dentry = ERR_PTR(-EEXIST);
1942 fail:
1943         return dentry;
1944 }
1945 EXPORT_SYMBOL_GPL(lookup_create);
1946
1947 int vfs_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t dev)
1948 {
1949         int error = may_create(dir, dentry);
1950
1951         if (error)
1952                 return error;
1953
1954         if ((S_ISCHR(mode) || S_ISBLK(mode)) && !capable(CAP_MKNOD))
1955                 return -EPERM;
1956
1957         if (!dir->i_op->mknod)
1958                 return -EPERM;
1959
1960         error = devcgroup_inode_mknod(mode, dev);
1961         if (error)
1962                 return error;
1963
1964         error = security_inode_mknod(dir, dentry, mode, dev);
1965         if (error)
1966                 return error;
1967
1968         error = dir->i_op->mknod(dir, dentry, mode, dev);
1969         if (!error)
1970                 fsnotify_create(dir, dentry);
1971         return error;
1972 }
1973
1974 static int may_mknod(mode_t mode)
1975 {
1976         switch (mode & S_IFMT) {
1977         case S_IFREG:
1978         case S_IFCHR:
1979         case S_IFBLK:
1980         case S_IFIFO:
1981         case S_IFSOCK:
1982         case 0: /* zero mode translates to S_IFREG */
1983                 return 0;
1984         case S_IFDIR:
1985                 return -EPERM;
1986         default:
1987                 return -EINVAL;
1988         }
1989 }
1990
1991 SYSCALL_DEFINE4(mknodat, int, dfd, const char __user *, filename, int, mode,
1992                 unsigned, dev)
1993 {
1994         int error;
1995         char *tmp;
1996         struct dentry *dentry;
1997         struct nameidata nd;
1998
1999         if (S_ISDIR(mode))
2000                 return -EPERM;
2001
2002         error = user_path_parent(dfd, filename, &nd, &tmp);
2003         if (error)
2004                 return error;
2005
2006         dentry = lookup_create(&nd, 0);
2007         if (IS_ERR(dentry)) {
2008                 error = PTR_ERR(dentry);
2009                 goto out_unlock;
2010         }
2011         if (!IS_POSIXACL(nd.path.dentry->d_inode))
2012                 mode &= ~current_umask();
2013         error = may_mknod(mode);
2014         if (error)
2015                 goto out_dput;
2016         error = mnt_want_write(nd.path.mnt);
2017         if (error)
2018                 goto out_dput;
2019         error = security_path_mknod(&nd.path, dentry, mode, dev);
2020         if (error)
2021                 goto out_drop_write;
2022         switch (mode & S_IFMT) {
2023                 case 0: case S_IFREG:
2024                         error = vfs_create(nd.path.dentry->d_inode,dentry,mode,&nd);
2025                         break;
2026                 case S_IFCHR: case S_IFBLK:
2027                         error = vfs_mknod(nd.path.dentry->d_inode,dentry,mode,
2028                                         new_decode_dev(dev));
2029                         break;
2030                 case S_IFIFO: case S_IFSOCK:
2031                         error = vfs_mknod(nd.path.dentry->d_inode,dentry,mode,0);
2032                         break;
2033         }
2034 out_drop_write:
2035         mnt_drop_write(nd.path.mnt);
2036 out_dput:
2037         dput(dentry);
2038 out_unlock:
2039         mutex_unlock(&nd.path.dentry->d_inode->i_mutex);
2040         path_put(&nd.path);
2041         putname(tmp);
2042
2043         return error;
2044 }
2045
2046 SYSCALL_DEFINE3(mknod, const char __user *, filename, int, mode, unsigned, dev)
2047 {
2048         return sys_mknodat(AT_FDCWD, filename, mode, dev);
2049 }
2050
2051 int vfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
2052 {
2053         int error = may_create(dir, dentry);
2054
2055         if (error)
2056                 return error;
2057
2058         if (!dir->i_op->mkdir)
2059                 return -EPERM;
2060
2061         mode &= (S_IRWXUGO|S_ISVTX);
2062         error = security_inode_mkdir(dir, dentry, mode);
2063         if (error)
2064                 return error;
2065
2066         error = dir->i_op->mkdir(dir, dentry, mode);
2067         if (!error)
2068                 fsnotify_mkdir(dir, dentry);
2069         return error;
2070 }
2071
2072 SYSCALL_DEFINE3(mkdirat, int, dfd, const char __user *, pathname, int, mode)
2073 {
2074         int error = 0;
2075         char * tmp;
2076         struct dentry *dentry;
2077         struct nameidata nd;
2078
2079         error = user_path_parent(dfd, pathname, &nd, &tmp);
2080         if (error)
2081                 goto out_err;
2082
2083         dentry = lookup_create(&nd, 1);
2084         error = PTR_ERR(dentry);
2085         if (IS_ERR(dentry))
2086                 goto out_unlock;
2087
2088         if (!IS_POSIXACL(nd.path.dentry->d_inode))
2089                 mode &= ~current_umask();
2090         error = mnt_want_write(nd.path.mnt);
2091         if (error)
2092                 goto out_dput;
2093         error = security_path_mkdir(&nd.path, dentry, mode);
2094         if (error)
2095                 goto out_drop_write;
2096         error = vfs_mkdir(nd.path.dentry->d_inode, dentry, mode);
2097 out_drop_write:
2098         mnt_drop_write(nd.path.mnt);
2099 out_dput:
2100         dput(dentry);
2101 out_unlock:
2102         mutex_unlock(&nd.path.dentry->d_inode->i_mutex);
2103         path_put(&nd.path);
2104         putname(tmp);
2105 out_err:
2106         return error;
2107 }
2108
2109 SYSCALL_DEFINE2(mkdir, const char __user *, pathname, int, mode)
2110 {
2111         return sys_mkdirat(AT_FDCWD, pathname, mode);
2112 }
2113
2114 /*
2115  * We try to drop the dentry early: we should have
2116  * a usage count of 2 if we're the only user of this
2117  * dentry, and if that is true (possibly after pruning
2118  * the dcache), then we drop the dentry now.
2119  *
2120  * A low-level filesystem can, if it choses, legally
2121  * do a
2122  *
2123  *      if (!d_unhashed(dentry))
2124  *              return -EBUSY;
2125  *
2126  * if it cannot handle the case of removing a directory
2127  * that is still in use by something else..
2128  */
2129 void dentry_unhash(struct dentry *dentry)
2130 {
2131         dget(dentry);
2132         shrink_dcache_parent(dentry);
2133         spin_lock(&dcache_lock);
2134         spin_lock(&dentry->d_lock);
2135         if (atomic_read(&dentry->d_count) == 2)
2136                 __d_drop(dentry);
2137         spin_unlock(&dentry->d_lock);
2138         spin_unlock(&dcache_lock);
2139 }
2140
2141 int vfs_rmdir(struct inode *dir, struct dentry *dentry)
2142 {
2143         int error = may_delete(dir, dentry, 1);
2144
2145         if (error)
2146                 return error;
2147
2148         if (!dir->i_op->rmdir)
2149                 return -EPERM;
2150
2151         mutex_lock(&dentry->d_inode->i_mutex);
2152         dentry_unhash(dentry);
2153         if (d_mountpoint(dentry))
2154                 error = -EBUSY;
2155         else {
2156                 error = security_inode_rmdir(dir, dentry);
2157                 if (!error) {
2158                         error = dir->i_op->rmdir(dir, dentry);
2159                         if (!error) {
2160                                 dentry->d_inode->i_flags |= S_DEAD;
2161                                 dont_mount(dentry);
2162                         }
2163                 }
2164         }
2165         mutex_unlock(&dentry->d_inode->i_mutex);
2166         if (!error) {
2167                 d_delete(dentry);
2168         }
2169         dput(dentry);
2170
2171         return error;
2172 }
2173
2174 static long do_rmdir(int dfd, const char __user *pathname)
2175 {
2176         int error = 0;
2177         char * name;
2178         struct dentry *dentry;
2179         struct nameidata nd;
2180
2181         error = user_path_parent(dfd, pathname, &nd, &name);
2182         if (error)
2183                 return error;
2184
2185         switch(nd.last_type) {
2186         case LAST_DOTDOT:
2187                 error = -ENOTEMPTY;
2188                 goto exit1;
2189         case LAST_DOT:
2190                 error = -EINVAL;
2191                 goto exit1;
2192         case LAST_ROOT:
2193                 error = -EBUSY;
2194                 goto exit1;
2195         }
2196
2197         nd.flags &= ~LOOKUP_PARENT;
2198
2199         mutex_lock_nested(&nd.path.dentry->d_inode->i_mutex, I_MUTEX_PARENT);
2200         dentry = lookup_hash(&nd);
2201         error = PTR_ERR(dentry);
2202         if (IS_ERR(dentry))
2203                 goto exit2;
2204         error = mnt_want_write(nd.path.mnt);
2205         if (error)
2206                 goto exit3;
2207         error = security_path_rmdir(&nd.path, dentry);
2208         if (error)
2209                 goto exit4;
2210         error = vfs_rmdir(nd.path.dentry->d_inode, dentry);
2211 exit4:
2212         mnt_drop_write(nd.path.mnt);
2213 exit3:
2214         dput(dentry);
2215 exit2:
2216         mutex_unlock(&nd.path.dentry->d_inode->i_mutex);
2217 exit1:
2218         path_put(&nd.path);
2219         putname(name);
2220         return error;
2221 }
2222
2223 SYSCALL_DEFINE1(rmdir, const char __user *, pathname)
2224 {
2225         return do_rmdir(AT_FDCWD, pathname);
2226 }
2227
2228 int vfs_unlink(struct inode *dir, struct dentry *dentry)
2229 {
2230         int error = may_delete(dir, dentry, 0);
2231
2232         if (error)
2233                 return error;
2234
2235         if (!dir->i_op->unlink)
2236                 return -EPERM;
2237
2238         mutex_lock(&dentry->d_inode->i_mutex);
2239         if (d_mountpoint(dentry))
2240                 error = -EBUSY;
2241         else {
2242                 error = security_inode_unlink(dir, dentry);
2243                 if (!error) {
2244                         error = dir->i_op->unlink(dir, dentry);
2245                         if (!error)
2246                                 dont_mount(dentry);
2247                 }
2248         }
2249         mutex_unlock(&dentry->d_inode->i_mutex);
2250
2251         /* We don't d_delete() NFS sillyrenamed files--they still exist. */
2252         if (!error && !(dentry->d_flags & DCACHE_NFSFS_RENAMED)) {
2253                 fsnotify_link_count(dentry->d_inode);
2254                 d_delete(dentry);
2255         }
2256
2257         return error;
2258 }
2259
2260 /*
2261  * Make sure that the actual truncation of the file will occur outside its
2262  * directory's i_mutex.  Truncate can take a long time if there is a lot of
2263  * writeout happening, and we don't want to prevent access to the directory
2264  * while waiting on the I/O.
2265  */
2266 static long do_unlinkat(int dfd, const char __user *pathname)
2267 {
2268         int error;
2269         char *name;
2270         struct dentry *dentry;
2271         struct nameidata nd;
2272         struct inode *inode = NULL;
2273
2274         error = user_path_parent(dfd, pathname, &nd, &name);
2275         if (error)
2276                 return error;
2277
2278         error = -EISDIR;
2279         if (nd.last_type != LAST_NORM)
2280                 goto exit1;
2281
2282         nd.flags &= ~LOOKUP_PARENT;
2283
2284         mutex_lock_nested(&nd.path.dentry->d_inode->i_mutex, I_MUTEX_PARENT);
2285         dentry = lookup_hash(&nd);
2286         error = PTR_ERR(dentry);
2287         if (!IS_ERR(dentry)) {
2288                 /* Why not before? Because we want correct error value */
2289                 if (nd.last.name[nd.last.len])
2290                         goto slashes;
2291                 inode = dentry->d_inode;
2292                 if (inode)
2293                         atomic_inc(&inode->i_count);
2294                 error = mnt_want_write(nd.path.mnt);
2295                 if (error)
2296                         goto exit2;
2297                 error = security_path_unlink(&nd.path, dentry);
2298                 if (error)
2299                         goto exit3;
2300                 error = vfs_unlink(nd.path.dentry->d_inode, dentry);
2301 exit3:
2302                 mnt_drop_write(nd.path.mnt);
2303         exit2:
2304                 dput(dentry);
2305         }
2306         mutex_unlock(&nd.path.dentry->d_inode->i_mutex);
2307         if (inode)
2308                 iput(inode);    /* truncate the inode here */
2309 exit1:
2310         path_put(&nd.path);
2311         putname(name);
2312         return error;
2313
2314 slashes:
2315         error = !dentry->d_inode ? -ENOENT :
2316                 S_ISDIR(dentry->d_inode->i_mode) ? -EISDIR : -ENOTDIR;
2317         goto exit2;
2318 }
2319
2320 SYSCALL_DEFINE3(unlinkat, int, dfd, const char __user *, pathname, int, flag)
2321 {
2322         if ((flag & ~AT_REMOVEDIR) != 0)
2323                 return -EINVAL;
2324
2325         if (flag & AT_REMOVEDIR)
2326                 return do_rmdir(dfd, pathname);
2327
2328         return do_unlinkat(dfd, pathname);
2329 }
2330
2331 SYSCALL_DEFINE1(unlink, const char __user *, pathname)
2332 {
2333         return do_unlinkat(AT_FDCWD, pathname);
2334 }
2335
2336 int vfs_symlink(struct inode *dir, struct dentry *dentry, const char *oldname)
2337 {
2338         int error = may_create(dir, dentry);
2339
2340         if (error)
2341                 return error;
2342
2343         if (!dir->i_op->symlink)
2344                 return -EPERM;
2345
2346         error = security_inode_symlink(dir, dentry, oldname);
2347         if (error)
2348                 return error;
2349
2350         error = dir->i_op->symlink(dir, dentry, oldname);
2351         if (!error)
2352                 fsnotify_create(dir, dentry);
2353         return error;
2354 }
2355
2356 SYSCALL_DEFINE3(symlinkat, const char __user *, oldname,
2357                 int, newdfd, const char __user *, newname)
2358 {
2359         int error;
2360         char *from;
2361         char *to;
2362         struct dentry *dentry;
2363         struct nameidata nd;
2364
2365         from = getname(oldname);
2366         if (IS_ERR(from))
2367                 return PTR_ERR(from);
2368
2369         error = user_path_parent(newdfd, newname, &nd, &to);
2370         if (error)
2371                 goto out_putname;
2372
2373         dentry = lookup_create(&nd, 0);
2374         error = PTR_ERR(dentry);
2375         if (IS_ERR(dentry))
2376                 goto out_unlock;
2377
2378         error = mnt_want_write(nd.path.mnt);
2379         if (error)
2380                 goto out_dput;
2381         error = security_path_symlink(&nd.path, dentry, from);
2382         if (error)
2383                 goto out_drop_write;
2384         error = vfs_symlink(nd.path.dentry->d_inode, dentry, from);
2385 out_drop_write:
2386         mnt_drop_write(nd.path.mnt);
2387 out_dput:
2388         dput(dentry);
2389 out_unlock:
2390         mutex_unlock(&nd.path.dentry->d_inode->i_mutex);
2391         path_put(&nd.path);
2392         putname(to);
2393 out_putname:
2394         putname(from);
2395         return error;
2396 }
2397
2398 SYSCALL_DEFINE2(symlink, const char __user *, oldname, const char __user *, newname)
2399 {
2400         return sys_symlinkat(oldname, AT_FDCWD, newname);
2401 }
2402
2403 int vfs_link(struct dentry *old_dentry, struct inode *dir, struct dentry *new_dentry)
2404 {
2405         struct inode *inode = old_dentry->d_inode;
2406         int error;
2407
2408         if (!inode)
2409                 return -ENOENT;
2410
2411         error = may_create(dir, new_dentry);
2412         if (error)
2413                 return error;
2414
2415         if (dir->i_sb != inode->i_sb)
2416                 return -EXDEV;
2417
2418         /*
2419          * A link to an append-only or immutable file cannot be created.
2420          */
2421         if (IS_APPEND(inode) || IS_IMMUTABLE(inode))
2422                 return -EPERM;
2423         if (!dir->i_op->link)
2424                 return -EPERM;
2425         if (S_ISDIR(inode->i_mode))
2426                 return -EPERM;
2427
2428         error = security_inode_link(old_dentry, dir, new_dentry);
2429         if (error)
2430                 return error;
2431
2432         mutex_lock(&inode->i_mutex);
2433         error = dir->i_op->link(old_dentry, dir, new_dentry);
2434         mutex_unlock(&inode->i_mutex);
2435         if (!error)
2436                 fsnotify_link(dir, inode, new_dentry);
2437         return error;
2438 }
2439
2440 /*
2441  * Hardlinks are often used in delicate situations.  We avoid
2442  * security-related surprises by not following symlinks on the
2443  * newname.  --KAB
2444  *
2445  * We don't follow them on the oldname either to be compatible
2446  * with linux 2.0, and to avoid hard-linking to directories
2447  * and other special files.  --ADM
2448  */
2449 SYSCALL_DEFINE5(linkat, int, olddfd, const char __user *, oldname,
2450                 int, newdfd, const char __user *, newname, int, flags)
2451 {
2452         struct dentry *new_dentry;
2453         struct nameidata nd;
2454         struct path old_path;
2455         int error;
2456         char *to;
2457
2458         if ((flags & ~AT_SYMLINK_FOLLOW) != 0)
2459                 return -EINVAL;
2460
2461         error = user_path_at(olddfd, oldname,
2462                              flags & AT_SYMLINK_FOLLOW ? LOOKUP_FOLLOW : 0,
2463                              &old_path);
2464         if (error)
2465                 return error;
2466
2467         error = user_path_parent(newdfd, newname, &nd, &to);
2468         if (error)
2469                 goto out;
2470         error = -EXDEV;
2471         if (old_path.mnt != nd.path.mnt)
2472                 goto out_release;
2473         new_dentry = lookup_create(&nd, 0);
2474         error = PTR_ERR(new_dentry);
2475         if (IS_ERR(new_dentry))
2476                 goto out_unlock;
2477         error = mnt_want_write(nd.path.mnt);
2478         if (error)
2479                 goto out_dput;
2480         error = security_path_link(old_path.dentry, &nd.path, new_dentry);
2481         if (error)
2482                 goto out_drop_write;
2483         error = vfs_link(old_path.dentry, nd.path.dentry->d_inode, new_dentry);
2484 out_drop_write:
2485         mnt_drop_write(nd.path.mnt);
2486 out_dput:
2487         dput(new_dentry);
2488 out_unlock:
2489         mutex_unlock(&nd.path.dentry->d_inode->i_mutex);
2490 out_release:
2491         path_put(&nd.path);
2492         putname(to);
2493 out:
2494         path_put(&old_path);
2495
2496         return error;
2497 }
2498
2499 SYSCALL_DEFINE2(link, const char __user *, oldname, const char __user *, newname)
2500 {
2501         return sys_linkat(AT_FDCWD, oldname, AT_FDCWD, newname, 0);
2502 }
2503
2504 /*
2505  * The worst of all namespace operations - renaming directory. "Perverted"
2506  * doesn't even start to describe it. Somebody in UCB had a heck of a trip...
2507  * Problems:
2508  *      a) we can get into loop creation. Check is done in is_subdir().
2509  *      b) race potential - two innocent renames can create a loop together.
2510  *         That's where 4.4 screws up. Current fix: serialization on
2511  *         sb->s_vfs_rename_mutex. We might be more accurate, but that's another
2512  *         story.
2513  *      c) we have to lock _three_ objects - parents and victim (if it exists).
2514  *         And that - after we got ->i_mutex on parents (until then we don't know
2515  *         whether the target exists).  Solution: try to be smart with locking
2516  *         order for inodes.  We rely on the fact that tree topology may change
2517  *         only under ->s_vfs_rename_mutex _and_ that parent of the object we
2518  *         move will be locked.  Thus we can rank directories by the tree
2519  *         (ancestors first) and rank all non-directories after them.
2520  *         That works since everybody except rename does "lock parent, lookup,
2521  *         lock child" and rename is under ->s_vfs_rename_mutex.
2522  *         HOWEVER, it relies on the assumption that any object with ->lookup()
2523  *         has no more than 1 dentry.  If "hybrid" objects will ever appear,
2524  *         we'd better make sure that there's no link(2) for them.
2525  *      d) some filesystems don't support opened-but-unlinked directories,
2526  *         either because of layout or because they are not ready to deal with
2527  *         all cases correctly. The latter will be fixed (taking this sort of
2528  *         stuff into VFS), but the former is not going away. Solution: the same
2529  *         trick as in rmdir().
2530  *      e) conversion from fhandle to dentry may come in the wrong moment - when
2531  *         we are removing the target. Solution: we will have to grab ->i_mutex
2532  *         in the fhandle_to_dentry code. [FIXME - current nfsfh.c relies on
2533  *         ->i_mutex on parents, which works but leads to some truly excessive
2534  *         locking].
2535  */
2536 static int vfs_rename_dir(struct inode *old_dir, struct dentry *old_dentry,
2537                           struct inode *new_dir, struct dentry *new_dentry)
2538 {
2539         int error = 0;
2540         struct inode *target;
2541
2542         /*
2543          * If we are going to change the parent - check write permissions,
2544          * we'll need to flip '..'.
2545          */
2546         if (new_dir != old_dir) {
2547                 error = inode_permission(old_dentry->d_inode, MAY_WRITE);
2548                 if (error)
2549                         return error;
2550         }
2551
2552         error = security_inode_rename(old_dir, old_dentry, new_dir, new_dentry);
2553         if (error)
2554                 return error;
2555
2556         target = new_dentry->d_inode;
2557         if (target)
2558                 mutex_lock(&target->i_mutex);
2559         if (d_mountpoint(old_dentry)||d_mountpoint(new_dentry))
2560                 error = -EBUSY;
2561         else {
2562                 if (target)
2563                         dentry_unhash(new_dentry);
2564                 error = old_dir->i_op->rename(old_dir, old_dentry, new_dir, new_dentry);
2565         }
2566         if (target) {
2567                 if (!error) {
2568                         target->i_flags |= S_DEAD;
2569                         dont_mount(new_dentry);
2570                 }
2571                 mutex_unlock(&target->i_mutex);
2572                 if (d_unhashed(new_dentry))
2573                         d_rehash(new_dentry);
2574                 dput(new_dentry);
2575         }
2576         if (!error)
2577                 if (!(old_dir->i_sb->s_type->fs_flags & FS_RENAME_DOES_D_MOVE))
2578                         d_move(old_dentry,new_dentry);
2579         return error;
2580 }
2581
2582 static int vfs_rename_other(struct inode *old_dir, struct dentry *old_dentry,
2583                             struct inode *new_dir, struct dentry *new_dentry)
2584 {
2585         struct inode *target;
2586         int error;
2587
2588         error = security_inode_rename(old_dir, old_dentry, new_dir, new_dentry);
2589         if (error)
2590                 return error;
2591
2592         dget(new_dentry);
2593         target = new_dentry->d_inode;
2594         if (target)
2595                 mutex_lock(&target->i_mutex);
2596         if (d_mountpoint(old_dentry)||d_mountpoint(new_dentry))
2597                 error = -EBUSY;
2598         else
2599                 error = old_dir->i_op->rename(old_dir, old_dentry, new_dir, new_dentry);
2600         if (!error) {
2601                 if (target)
2602                         dont_mount(new_dentry);
2603                 if (!(old_dir->i_sb->s_type->fs_flags & FS_RENAME_DOES_D_MOVE))
2604                         d_move(old_dentry, new_dentry);
2605         }
2606         if (target)
2607                 mutex_unlock(&target->i_mutex);
2608         dput(new_dentry);
2609         return error;
2610 }
2611
2612 int vfs_rename(struct inode *old_dir, struct dentry *old_dentry,
2613                struct inode *new_dir, struct dentry *new_dentry)
2614 {
2615         int error;
2616         int is_dir = S_ISDIR(old_dentry->d_inode->i_mode);
2617         const unsigned char *old_name;
2618
2619         if (old_dentry->d_inode == new_dentry->d_inode)
2620                 return 0;
2621  
2622         error = may_delete(old_dir, old_dentry, is_dir);
2623         if (error)
2624                 return error;
2625
2626         if (!new_dentry->d_inode)
2627                 error = may_create(new_dir, new_dentry);
2628         else
2629                 error = may_delete(new_dir, new_dentry, is_dir);
2630         if (error)
2631                 return error;
2632
2633         if (!old_dir->i_op->rename)
2634                 return -EPERM;
2635
2636         old_name = fsnotify_oldname_init(old_dentry->d_name.name);
2637
2638         if (is_dir)
2639                 error = vfs_rename_dir(old_dir,old_dentry,new_dir,new_dentry);
2640         else
2641                 error = vfs_rename_other(old_dir,old_dentry,new_dir,new_dentry);
2642         if (!error)
2643                 fsnotify_move(old_dir, new_dir, old_name, is_dir,
2644                               new_dentry->d_inode, old_dentry);
2645         fsnotify_oldname_free(old_name);
2646
2647         return error;
2648 }
2649
2650 SYSCALL_DEFINE4(renameat, int, olddfd, const char __user *, oldname,
2651                 int, newdfd, const char __user *, newname)
2652 {
2653         struct dentry *old_dir, *new_dir;
2654         struct dentry *old_dentry, *new_dentry;
2655         struct dentry *trap;
2656         struct nameidata oldnd, newnd;
2657         char *from;
2658         char *to;
2659         int error;
2660
2661         error = user_path_parent(olddfd, oldname, &oldnd, &from);
2662         if (error)
2663                 goto exit;
2664
2665         error = user_path_parent(newdfd, newname, &newnd, &to);
2666         if (error)
2667                 goto exit1;
2668
2669         error = -EXDEV;
2670         if (oldnd.path.mnt != newnd.path.mnt)
2671                 goto exit2;
2672
2673         old_dir = oldnd.path.dentry;
2674         error = -EBUSY;
2675         if (oldnd.last_type != LAST_NORM)
2676                 goto exit2;
2677
2678         new_dir = newnd.path.dentry;
2679         if (newnd.last_type != LAST_NORM)
2680                 goto exit2;
2681
2682         oldnd.flags &= ~LOOKUP_PARENT;
2683         newnd.flags &= ~LOOKUP_PARENT;
2684         newnd.flags |= LOOKUP_RENAME_TARGET;
2685
2686         trap = lock_rename(new_dir, old_dir);
2687
2688         old_dentry = lookup_hash(&oldnd);
2689         error = PTR_ERR(old_dentry);
2690         if (IS_ERR(old_dentry))
2691                 goto exit3;
2692         /* source must exist */
2693         error = -ENOENT;
2694         if (!old_dentry->d_inode)
2695                 goto exit4;
2696         /* unless the source is a directory trailing slashes give -ENOTDIR */
2697         if (!S_ISDIR(old_dentry->d_inode->i_mode)) {
2698                 error = -ENOTDIR;
2699                 if (oldnd.last.name[oldnd.last.len])
2700                         goto exit4;
2701                 if (newnd.last.name[newnd.last.len])
2702                         goto exit4;
2703         }
2704         /* source should not be ancestor of target */
2705         error = -EINVAL;
2706         if (old_dentry == trap)
2707                 goto exit4;
2708         new_dentry = lookup_hash(&newnd);
2709         error = PTR_ERR(new_dentry);
2710         if (IS_ERR(new_dentry))
2711                 goto exit4;
2712         /* target should not be an ancestor of source */
2713         error = -ENOTEMPTY;
2714         if (new_dentry == trap)
2715                 goto exit5;
2716
2717         error = mnt_want_write(oldnd.path.mnt);
2718         if (error)
2719                 goto exit5;
2720         error = security_path_rename(&oldnd.path, old_dentry,
2721                                      &newnd.path, new_dentry);
2722         if (error)
2723                 goto exit6;
2724         error = vfs_rename(old_dir->d_inode, old_dentry,
2725                                    new_dir->d_inode, new_dentry);
2726 exit6:
2727         mnt_drop_write(oldnd.path.mnt);
2728 exit5:
2729         dput(new_dentry);
2730 exit4:
2731         dput(old_dentry);
2732 exit3:
2733         unlock_rename(new_dir, old_dir);
2734 exit2:
2735         path_put(&newnd.path);
2736         putname(to);
2737 exit1:
2738         path_put(&oldnd.path);
2739         putname(from);
2740 exit:
2741         return error;
2742 }
2743
2744 SYSCALL_DEFINE2(rename, const char __user *, oldname, const char __user *, newname)
2745 {
2746         return sys_renameat(AT_FDCWD, oldname, AT_FDCWD, newname);
2747 }
2748
2749 int vfs_readlink(struct dentry *dentry, char __user *buffer, int buflen, const char *link)
2750 {
2751         int len;
2752
2753         len = PTR_ERR(link);
2754         if (IS_ERR(link))
2755                 goto out;
2756
2757         len = strlen(link);
2758         if (len > (unsigned) buflen)
2759                 len = buflen;
2760         if (copy_to_user(buffer, link, len))
2761                 len = -EFAULT;
2762 out:
2763         return len;
2764 }
2765
2766 /*
2767  * A helper for ->readlink().  This should be used *ONLY* for symlinks that
2768  * have ->follow_link() touching nd only in nd_set_link().  Using (or not
2769  * using) it for any given inode is up to filesystem.
2770  */
2771 int generic_readlink(struct dentry *dentry, char __user *buffer, int buflen)
2772 {
2773         struct nameidata nd;
2774         void *cookie;
2775         int res;
2776
2777         nd.depth = 0;
2778         cookie = dentry->d_inode->i_op->follow_link(dentry, &nd);
2779         if (IS_ERR(cookie))
2780                 return PTR_ERR(cookie);
2781
2782         res = vfs_readlink(dentry, buffer, buflen, nd_get_link(&nd));
2783         if (dentry->d_inode->i_op->put_link)
2784                 dentry->d_inode->i_op->put_link(dentry, &nd, cookie);
2785         return res;
2786 }
2787
2788 int vfs_follow_link(struct nameidata *nd, const char *link)
2789 {
2790         return __vfs_follow_link(nd, link);
2791 }
2792
2793 /* get the link contents into pagecache */
2794 static char *page_getlink(struct dentry * dentry, struct page **ppage)
2795 {
2796         char *kaddr;
2797         struct page *page;
2798         struct address_space *mapping = dentry->d_inode->i_mapping;
2799         page = read_mapping_page(mapping, 0, NULL);
2800         if (IS_ERR(page))
2801                 return (char*)page;
2802         *ppage = page;
2803         kaddr = kmap(page);
2804         nd_terminate_link(kaddr, dentry->d_inode->i_size, PAGE_SIZE - 1);
2805         return kaddr;
2806 }
2807
2808 int page_readlink(struct dentry *dentry, char __user *buffer, int buflen)
2809 {
2810         struct page *page = NULL;
2811         char *s = page_getlink(dentry, &page);
2812         int res = vfs_readlink(dentry,buffer,buflen,s);
2813         if (page) {
2814                 kunmap(page);
2815                 page_cache_release(page);
2816         }
2817         return res;
2818 }
2819
2820 void *page_follow_link_light(struct dentry *dentry, struct nameidata *nd)
2821 {
2822         struct page *page = NULL;
2823         nd_set_link(nd, page_getlink(dentry, &page));
2824         return page;
2825 }
2826
2827 void page_put_link(struct dentry *dentry, struct nameidata *nd, void *cookie)
2828 {
2829         struct page *page = cookie;
2830
2831         if (page) {
2832                 kunmap(page);
2833                 page_cache_release(page);
2834         }
2835 }
2836
2837 /*
2838  * The nofs argument instructs pagecache_write_begin to pass AOP_FLAG_NOFS
2839  */
2840 int __page_symlink(struct inode *inode, const char *symname, int len, int nofs)
2841 {
2842         struct address_space *mapping = inode->i_mapping;
2843         struct page *page;
2844         void *fsdata;
2845         int err;
2846         char *kaddr;
2847         unsigned int flags = AOP_FLAG_UNINTERRUPTIBLE;
2848         if (nofs)
2849                 flags |= AOP_FLAG_NOFS;
2850
2851 retry:
2852         err = pagecache_write_begin(NULL, mapping, 0, len-1,
2853                                 flags, &page, &fsdata);
2854         if (err)
2855                 goto fail;
2856
2857         kaddr = kmap_atomic(page, KM_USER0);
2858         memcpy(kaddr, symname, len-1);
2859         kunmap_atomic(kaddr, KM_USER0);
2860
2861         err = pagecache_write_end(NULL, mapping, 0, len-1, len-1,
2862                                                         page, fsdata);
2863         if (err < 0)
2864                 goto fail;
2865         if (err < len-1)
2866                 goto retry;
2867
2868         mark_inode_dirty(inode);
2869         return 0;
2870 fail:
2871         return err;
2872 }
2873
2874 int page_symlink(struct inode *inode, const char *symname, int len)
2875 {
2876         return __page_symlink(inode, symname, len,
2877                         !(mapping_gfp_mask(inode->i_mapping) & __GFP_FS));
2878 }
2879
2880 const struct inode_operations page_symlink_inode_operations = {
2881         .readlink       = generic_readlink,
2882         .follow_link    = page_follow_link_light,
2883         .put_link       = page_put_link,
2884 };
2885
2886 EXPORT_SYMBOL(user_path_at);
2887 EXPORT_SYMBOL(follow_down);
2888 EXPORT_SYMBOL(follow_up);
2889 EXPORT_SYMBOL(get_write_access); /* binfmt_aout */
2890 EXPORT_SYMBOL(getname);
2891 EXPORT_SYMBOL(lock_rename);
2892 EXPORT_SYMBOL(lookup_one_len);
2893 EXPORT_SYMBOL(page_follow_link_light);
2894 EXPORT_SYMBOL(page_put_link);
2895 EXPORT_SYMBOL(page_readlink);
2896 EXPORT_SYMBOL(__page_symlink);
2897 EXPORT_SYMBOL(page_symlink);
2898 EXPORT_SYMBOL(page_symlink_inode_operations);
2899 EXPORT_SYMBOL(path_lookup);
2900 EXPORT_SYMBOL(kern_path);
2901 EXPORT_SYMBOL(vfs_path_lookup);
2902 EXPORT_SYMBOL(inode_permission);
2903 EXPORT_SYMBOL(file_permission);
2904 EXPORT_SYMBOL(unlock_rename);
2905 EXPORT_SYMBOL(vfs_create);
2906 EXPORT_SYMBOL(vfs_follow_link);
2907 EXPORT_SYMBOL(vfs_link);
2908 EXPORT_SYMBOL(vfs_mkdir);
2909 EXPORT_SYMBOL(vfs_mknod);
2910 EXPORT_SYMBOL(generic_permission);
2911 EXPORT_SYMBOL(vfs_readlink);
2912 EXPORT_SYMBOL(vfs_rename);
2913 EXPORT_SYMBOL(vfs_rmdir);
2914 EXPORT_SYMBOL(vfs_symlink);
2915 EXPORT_SYMBOL(vfs_unlink);
2916 EXPORT_SYMBOL(dentry_unhash);
2917 EXPORT_SYMBOL(generic_readlink);