1 files changed, 85 insertions, 57 deletions

diff --git a/fs/namei.c b/fs/namei.c
index 432d6bc6fab0..2892e68d3a86 100644
--- a/fs/namei.c
+++ b/fs/namei.c
@@ -372,6 +372,30 @@ void release_open_intent(struct nameidata *nd)
                 fput(nd->intent.open.file);
 }
 
+static inline struct dentry *
+do_revalidate(struct dentry *dentry, struct nameidata *nd)
+{
+        int status = dentry->d_op->d_revalidate(dentry, nd);
+        if (unlikely(status <= 0)) {
+                /*
+                 * The dentry failed validation.
+                 * If d_revalidate returned 0 attempt to invalidate
+                 * the dentry otherwise d_revalidate is asking us
+                 * to return a fail status.
+                 */
+                if (!status) {
+                        if (!d_invalidate(dentry)) {
+                                dput(dentry);
+                                dentry = NULL;
+                        }
+                } else {
+                        dput(dentry);
+                        dentry = ERR_PTR(status);
+                }
+        }
+        return dentry;
+}
+
 /*
  * Internal lookup() using the new generic dcache.
  * SMP-safe
@@ -386,12 +410,9 @@ static struct dentry * cached_lookup(struct dentry * parent, struct qstr * name,
         if (!dentry)
                 dentry = d_lookup(parent, name);
 
-        if (dentry && dentry->d_op && dentry->d_op->d_revalidate) {
-                if (!dentry->d_op->d_revalidate(dentry, nd) && !d_invalidate(dentry)) {
-                        dput(dentry);
-                        dentry = NULL;
-                }
-        }
+        if (dentry && dentry->d_op && dentry->d_op->d_revalidate)
+                dentry = do_revalidate(dentry, nd);
+
         return dentry;
 }
 
@@ -484,10 +505,9 @@ static struct dentry * real_lookup(struct dentry * parent, struct qstr * name, s
          */
         mutex_unlock(&dir->i_mutex);
         if (result->d_op && result->d_op->d_revalidate) {
-                if (!result->d_op->d_revalidate(result, nd) && !d_invalidate(result)) {
-                        dput(result);
+                result = do_revalidate(result, nd);
+                if (!result)
                         result = ERR_PTR(-ENOENT);
-                }
         }
         return result;
 }
@@ -498,18 +518,20 @@ static int __emul_lookup_dentry(const char *, struct nameidata *);
 static __always_inline int
 walk_init_root(const char *name, struct nameidata *nd)
 {
-        read_lock(&current->fs->lock);
-        if (current->fs->altroot && !(nd->flags & LOOKUP_NOALT)) {
-                nd->mnt = mntget(current->fs->altrootmnt);
-                nd->dentry = dget(current->fs->altroot);
-                read_unlock(&current->fs->lock);
+        struct fs_struct *fs = current->fs;
+
+        read_lock(&fs->lock);
+        if (fs->altroot && !(nd->flags & LOOKUP_NOALT)) {
+                nd->mnt = mntget(fs->altrootmnt);
+                nd->dentry = dget(fs->altroot);
+                read_unlock(&fs->lock);
                 if (__emul_lookup_dentry(name,nd))
                         return 0;
-                read_lock(&current->fs->lock);
+                read_lock(&fs->lock);
         }
-        nd->mnt = mntget(current->fs->rootmnt);
-        nd->dentry = dget(current->fs->root);
-        read_unlock(&current->fs->lock);
+        nd->mnt = mntget(fs->rootmnt);
+        nd->dentry = dget(fs->root);
+        read_unlock(&fs->lock);
         return 1;
 }
 
@@ -704,17 +726,19 @@ int follow_down(struct vfsmount **mnt, struct dentry **dentry)
 
 static __always_inline void follow_dotdot(struct nameidata *nd)
 {
+        struct fs_struct *fs = current->fs;
+
         while(1) {
                 struct vfsmount *parent;
                 struct dentry *old = nd->dentry;
 
-                read_lock(&current->fs->lock);
-                if (nd->dentry == current->fs->root &&
-                    nd->mnt == current->fs->rootmnt) {
-                        read_unlock(&current->fs->lock);
+                read_lock(&fs->lock);
+                if (nd->dentry == fs->root &&
+                    nd->mnt == fs->rootmnt) {
+                        read_unlock(&fs->lock);
                         break;
                 }
-                read_unlock(&current->fs->lock);
+                read_unlock(&fs->lock);
                 spin_lock(&dcache_lock);
                 if (nd->dentry != nd->mnt->mnt_root) {
                         nd->dentry = dget(nd->dentry->d_parent);
@@ -767,12 +791,12 @@ need_lookup:
         goto done;
 
 need_revalidate:
-        if (dentry->d_op->d_revalidate(dentry, nd))
-                goto done;
-        if (d_invalidate(dentry))
-                goto done;
-        dput(dentry);
-        goto need_lookup;
+        dentry = do_revalidate(dentry, nd);
+        if (!dentry)
+                goto need_lookup;
+        if (IS_ERR(dentry))
+                goto fail;
+        goto done;
 
 fail:
         return PTR_ERR(dentry);
@@ -1022,15 +1046,17 @@ static int __emul_lookup_dentry(const char *name, struct nameidata *nd)
                 struct vfsmount *old_mnt = nd->mnt;
                 struct qstr last = nd->last;
                 int last_type = nd->last_type;
+                struct fs_struct *fs = current->fs;
+
                 /*
-                 * NAME was not found in alternate root or it's a directory.  Try to find
-                 * it in the normal root:
+                 * NAME was not found in alternate root or it's a directory.
+                 * Try to find it in the normal root:
                  */
                 nd->last_type = LAST_ROOT;
-                read_lock(&current->fs->lock);
-                nd->mnt = mntget(current->fs->rootmnt);
-                nd->dentry = dget(current->fs->root);
-                read_unlock(&current->fs->lock);
+                read_lock(&fs->lock);
+                nd->mnt = mntget(fs->rootmnt);
+                nd->dentry = dget(fs->root);
+                read_unlock(&fs->lock);
                 if (path_walk(name, nd) == 0) {
                         if (nd->dentry->d_inode) {
                                 dput(old_dentry);
@@ -1054,6 +1080,7 @@ void set_fs_altroot(void)
         struct vfsmount *mnt = NULL, *oldmnt;
         struct dentry *dentry = NULL, *olddentry;
         int err;
+        struct fs_struct *fs = current->fs;
 
         if (!emul)
                 goto set_it;
@@ -1063,12 +1090,12 @@ void set_fs_altroot(void)
                 dentry = nd.dentry;
         }
 set_it:
-        write_lock(&current->fs->lock);
-        oldmnt = current->fs->altrootmnt;
-        olddentry = current->fs->altroot;
-        current->fs->altrootmnt = mnt;
-        current->fs->altroot = dentry;
-        write_unlock(&current->fs->lock);
+        write_lock(&fs->lock);
+        oldmnt = fs->altrootmnt;
+        olddentry = fs->altroot;
+        fs->altrootmnt = mnt;
+        fs->altroot = dentry;
+        write_unlock(&fs->lock);
         if (olddentry) {
                 dput(olddentry);
                 mntput(oldmnt);
@@ -1082,29 +1109,30 @@ static int fastcall do_path_lookup(int dfd, const char *name,
         int retval = 0;
         int fput_needed;
         struct file *file;
+        struct fs_struct *fs = current->fs;
 
         nd->last_type = LAST_ROOT; /* if there are only slashes... */
         nd->flags = flags;
         nd->depth = 0;
 
         if (*name=='/') {
-                read_lock(&current->fs->lock);
-                if (current->fs->altroot && !(nd->flags & LOOKUP_NOALT)) {
-                        nd->mnt = mntget(current->fs->altrootmnt);
-                        nd->dentry = dget(current->fs->altroot);
-                        read_unlock(&current->fs->lock);
+                read_lock(&fs->lock);
+                if (fs->altroot && !(nd->flags & LOOKUP_NOALT)) {
+                        nd->mnt = mntget(fs->altrootmnt);
+                        nd->dentry = dget(fs->altroot);
+                        read_unlock(&fs->lock);
                         if (__emul_lookup_dentry(name,nd))
                                 goto out; /* found in altroot */
-                        read_lock(&current->fs->lock);
+                        read_lock(&fs->lock);
                 }
-                nd->mnt = mntget(current->fs->rootmnt);
-                nd->dentry = dget(current->fs->root);
-                read_unlock(&current->fs->lock);
+                nd->mnt = mntget(fs->rootmnt);
+                nd->dentry = dget(fs->root);
+                read_unlock(&fs->lock);
         } else if (dfd == AT_FDCWD) {
-                read_lock(&current->fs->lock);
-                nd->mnt = mntget(current->fs->pwdmnt);
-                nd->dentry = dget(current->fs->pwd);
-                read_unlock(&current->fs->lock);
+                read_lock(&fs->lock);
+                nd->mnt = mntget(fs->pwdmnt);
+                nd->dentry = dget(fs->pwd);
+                read_unlock(&fs->lock);
         } else {
                 struct dentry *dentry;
 
@@ -2370,7 +2398,8 @@ static int vfs_rename_dir(struct inode *old_dir, struct dentry *old_dentry,
                 dput(new_dentry);
         }
         if (!error)
-                d_move(old_dentry,new_dentry);
+                if (!(old_dir->i_sb->s_type->fs_flags & FS_RENAME_DOES_D_MOVE))
+                        d_move(old_dentry,new_dentry);
         return error;
 }
 
@@ -2393,8 +2422,7 @@ static int vfs_rename_other(struct inode *old_dir, struct dentry *old_dentry,
         else
                 error = old_dir->i_op->rename(old_dir, old_dentry, new_dir, new_dentry);
         if (!error) {
-                /* The following d_move() should become unconditional */
-                if (!(old_dir->i_sb->s_type->fs_flags & FS_ODD_RENAME))
+                if (!(old_dir->i_sb->s_type->fs_flags & FS_RENAME_DOES_D_MOVE))
                         d_move(old_dentry, new_dentry);
         }
         if (target)