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