1 files changed, 80 insertions, 38 deletions

diff --git a/fs/namei.c b/fs/namei.c
index 5f4cdf3ad913..43a97ee1d4c8 100644
--- a/fs/namei.c
+++ b/fs/namei.c
@@ -1275,9 +1275,7 @@ static struct dentry *lookup_dcache(struct qstr *name, struct dentry *dir,
         *need_lookup = false;
         dentry = d_lookup(dir, name);
         if (dentry) {
-                if (d_need_lookup(dentry)) {
-                        *need_lookup = true;
-                } else if (dentry->d_flags & DCACHE_OP_REVALIDATE) {
+                if (dentry->d_flags & DCACHE_OP_REVALIDATE) {
                         error = d_revalidate(dentry, flags);
                         if (unlikely(error <= 0)) {
                                 if (error < 0) {
@@ -1383,8 +1381,6 @@ static int lookup_fast(struct nameidata *nd, struct qstr *name,
                         return -ECHILD;
                 nd->seq = seq;
 
-                if (unlikely(d_need_lookup(dentry)))
-                        goto unlazy;
                 if (unlikely(dentry->d_flags & DCACHE_OP_REVALIDATE)) {
                         status = d_revalidate(dentry, nd->flags);
                         if (unlikely(status <= 0)) {
@@ -1410,11 +1406,6 @@ unlazy:
         if (unlikely(!dentry))
                 goto need_lookup;
 
-        if (unlikely(d_need_lookup(dentry))) {
-                dput(dentry);
-                goto need_lookup;
-        }
-
         if (unlikely(dentry->d_flags & DCACHE_OP_REVALIDATE) && need_reval)
                 status = d_revalidate(dentry, nd->flags);
         if (unlikely(status <= 0)) {
@@ -1859,7 +1850,7 @@ static int path_init(int dfd, const char *name, unsigned int flags,
         if (flags & LOOKUP_ROOT) {
                 struct inode *inode = nd->root.dentry->d_inode;
                 if (*name) {
-                        if (!inode->i_op->lookup)
+                        if (!can_lookup(inode))
                                 return -ENOTDIR;
                         retval = inode_permission(inode, MAY_EXEC);
                         if (retval)
@@ -1903,6 +1894,7 @@ static int path_init(int dfd, const char *name, unsigned int flags,
                         get_fs_pwd(current->fs, &nd->path);
                 }
         } else {
+                /* Caller must check execute permissions on the starting path component */
                 struct fd f = fdget_raw(dfd);
                 struct dentry *dentry;
 
@@ -1912,16 +1904,10 @@ static int path_init(int dfd, const char *name, unsigned int flags,
                 dentry = f.file->f_path.dentry;
 
                 if (*name) {
-                        if (!S_ISDIR(dentry->d_inode->i_mode)) {
+                        if (!can_lookup(dentry->d_inode)) {
                                 fdput(f);
                                 return -ENOTDIR;
                         }
-
-                        retval = inode_permission(dentry->d_inode, MAY_EXEC);
-                        if (retval) {
-                                fdput(f);
-                                return retval;
-                        }
                 }
 
                 nd->path = f.file->f_path;
@@ -2189,15 +2175,19 @@ int user_path_at(int dfd, const char __user *name, unsigned flags,
  *     path-walking is complete.
  */
 static struct filename *
-user_path_parent(int dfd, const char __user *path, struct nameidata *nd)
+user_path_parent(int dfd, const char __user *path, struct nameidata *nd,
+                 unsigned int flags)
 {
         struct filename *s = getname(path);
         int error;
 
+        /* only LOOKUP_REVAL is allowed in extra flags */
+        flags &= LOOKUP_REVAL;
+
         if (IS_ERR(s))
                 return s;
 
-        error = filename_lookup(dfd, s, LOOKUP_PARENT, nd);
+        error = filename_lookup(dfd, s, flags | LOOKUP_PARENT, nd);
         if (error) {
                 putname(s);
                 return ERR_PTR(error);
@@ -3044,12 +3034,22 @@ struct file *do_file_open_root(struct dentry *dentry, struct vfsmount *mnt,
         return file;
 }
 
-struct dentry *kern_path_create(int dfd, const char *pathname, struct path *path, int is_dir)
+struct dentry *kern_path_create(int dfd, const char *pathname,
+                                struct path *path, unsigned int lookup_flags)
 {
         struct dentry *dentry = ERR_PTR(-EEXIST);
         struct nameidata nd;
         int err2;
-        int error = do_path_lookup(dfd, pathname, LOOKUP_PARENT, &nd);
+        int error;
+        bool is_dir = (lookup_flags & LOOKUP_DIRECTORY);
+
+        /*
+         * Note that only LOOKUP_REVAL and LOOKUP_DIRECTORY matter here. Any
+         * other flags passed in are ignored!
+         */
+        lookup_flags &= LOOKUP_REVAL;
+
+        error = do_path_lookup(dfd, pathname, LOOKUP_PARENT|lookup_flags, &nd);
         if (error)
                 return ERR_PTR(error);
 
@@ -3113,13 +3113,14 @@ void done_path_create(struct path *path, struct dentry *dentry)
 }
 EXPORT_SYMBOL(done_path_create);
 
-struct dentry *user_path_create(int dfd, const char __user *pathname, struct path *path, int is_dir)
+struct dentry *user_path_create(int dfd, const char __user *pathname,
+                                struct path *path, unsigned int lookup_flags)
 {
         struct filename *tmp = getname(pathname);
         struct dentry *res;
         if (IS_ERR(tmp))
                 return ERR_CAST(tmp);
-        res = kern_path_create(dfd, tmp->name, path, is_dir);
+        res = kern_path_create(dfd, tmp->name, path, lookup_flags);
         putname(tmp);
         return res;
 }
@@ -3175,12 +3176,13 @@ SYSCALL_DEFINE4(mknodat, int, dfd, const char __user *, filename, umode_t, mode,
         struct dentry *dentry;
         struct path path;
         int error;
+        unsigned int lookup_flags = 0;
 
         error = may_mknod(mode);
         if (error)
                 return error;
-
-        dentry = user_path_create(dfd, filename, &path, 0);
+retry:
+        dentry = user_path_create(dfd, filename, &path, lookup_flags);
         if (IS_ERR(dentry))
                 return PTR_ERR(dentry);
 
@@ -3203,6 +3205,10 @@ SYSCALL_DEFINE4(mknodat, int, dfd, const char __user *, filename, umode_t, mode,
         }
 out:
         done_path_create(&path, dentry);
+        if (retry_estale(error, lookup_flags)) {
+                lookup_flags |= LOOKUP_REVAL;
+                goto retry;
+        }
         return error;
 }
 
@@ -3241,8 +3247,10 @@ SYSCALL_DEFINE3(mkdirat, int, dfd, const char __user *, pathname, umode_t, mode)
         struct dentry *dentry;
         struct path path;
         int error;
+        unsigned int lookup_flags = LOOKUP_DIRECTORY;
 
-        dentry = user_path_create(dfd, pathname, &path, 1);
+retry:
+        dentry = user_path_create(dfd, pathname, &path, lookup_flags);
         if (IS_ERR(dentry))
                 return PTR_ERR(dentry);
 
@@ -3252,6 +3260,10 @@ SYSCALL_DEFINE3(mkdirat, int, dfd, const char __user *, pathname, umode_t, mode)
         if (!error)
                 error = vfs_mkdir(path.dentry->d_inode, dentry, mode);
         done_path_create(&path, dentry);
+        if (retry_estale(error, lookup_flags)) {
+                lookup_flags |= LOOKUP_REVAL;
+                goto retry;
+        }
         return error;
 }
 
@@ -3327,8 +3339,9 @@ static long do_rmdir(int dfd, const char __user *pathname)
         struct filename *name;
         struct dentry *dentry;
         struct nameidata nd;
-
-        name = user_path_parent(dfd, pathname, &nd);
+        unsigned int lookup_flags = 0;
+retry:
+        name = user_path_parent(dfd, pathname, &nd, lookup_flags);
         if (IS_ERR(name))
                 return PTR_ERR(name);
 
@@ -3370,6 +3383,10 @@ exit2:
 exit1:
         path_put(&nd.path);
         putname(name);
+        if (retry_estale(error, lookup_flags)) {
+                lookup_flags |= LOOKUP_REVAL;
+                goto retry;
+        }
         return error;
 }
 
@@ -3423,8 +3440,9 @@ static long do_unlinkat(int dfd, const char __user *pathname)
         struct dentry *dentry;
         struct nameidata nd;
         struct inode *inode = NULL;
-
-        name = user_path_parent(dfd, pathname, &nd);
+        unsigned int lookup_flags = 0;
+retry:
+        name = user_path_parent(dfd, pathname, &nd, lookup_flags);
         if (IS_ERR(name))
                 return PTR_ERR(name);
 
@@ -3462,6 +3480,11 @@ exit2:
 exit1:
         path_put(&nd.path);
         putname(name);
+        if (retry_estale(error, lookup_flags)) {
+                lookup_flags |= LOOKUP_REVAL;
+                inode = NULL;
+                goto retry;
+        }
         return error;
 
 slashes:
@@ -3513,12 +3536,13 @@ SYSCALL_DEFINE3(symlinkat, const char __user *, oldname,
         struct filename *from;
         struct dentry *dentry;
         struct path path;
+        unsigned int lookup_flags = 0;
 
         from = getname(oldname);
         if (IS_ERR(from))
                 return PTR_ERR(from);
-
-        dentry = user_path_create(newdfd, newname, &path, 0);
+retry:
+        dentry = user_path_create(newdfd, newname, &path, lookup_flags);
         error = PTR_ERR(dentry);
         if (IS_ERR(dentry))
                 goto out_putname;
@@ -3527,6 +3551,10 @@ SYSCALL_DEFINE3(symlinkat, const char __user *, oldname,
         if (!error)
                 error = vfs_symlink(path.dentry->d_inode, dentry, from->name);
         done_path_create(&path, dentry);
+        if (retry_estale(error, lookup_flags)) {
+                lookup_flags |= LOOKUP_REVAL;
+                goto retry;
+        }
 out_putname:
         putname(from);
         return error;
@@ -3613,12 +3641,13 @@ SYSCALL_DEFINE5(linkat, int, olddfd, const char __user *, oldname,
 
         if (flags & AT_SYMLINK_FOLLOW)
                 how |= LOOKUP_FOLLOW;
-
+retry:
         error = user_path_at(olddfd, oldname, how, &old_path);
         if (error)
                 return error;
 
-        new_dentry = user_path_create(newdfd, newname, &new_path, 0);
+        new_dentry = user_path_create(newdfd, newname, &new_path,
+                                        (how & LOOKUP_REVAL));
         error = PTR_ERR(new_dentry);
         if (IS_ERR(new_dentry))
                 goto out;
@@ -3635,6 +3664,10 @@ SYSCALL_DEFINE5(linkat, int, olddfd, const char __user *, oldname,
         error = vfs_link(old_path.dentry, new_path.dentry->d_inode, new_dentry);
 out_dput:
         done_path_create(&new_path, new_dentry);
+        if (retry_estale(error, how)) {
+                how |= LOOKUP_REVAL;
+                goto retry;
+        }
 out:
         path_put(&old_path);
 
@@ -3807,15 +3840,17 @@ SYSCALL_DEFINE4(renameat, int, olddfd, const char __user *, oldname,
         struct nameidata oldnd, newnd;
         struct filename *from;
         struct filename *to;
+        unsigned int lookup_flags = 0;
+        bool should_retry = false;
         int error;
-
-        from = user_path_parent(olddfd, oldname, &oldnd);
+retry:
+        from = user_path_parent(olddfd, oldname, &oldnd, lookup_flags);
         if (IS_ERR(from)) {
                 error = PTR_ERR(from);
                 goto exit;
         }
 
-        to = user_path_parent(newdfd, newname, &newnd);
+        to = user_path_parent(newdfd, newname, &newnd, lookup_flags);
         if (IS_ERR(to)) {
                 error = PTR_ERR(to);
                 goto exit1;
@@ -3887,11 +3922,18 @@ exit3:
         unlock_rename(new_dir, old_dir);
         mnt_drop_write(oldnd.path.mnt);
 exit2:
+        if (retry_estale(error, lookup_flags))
+                should_retry = true;
         path_put(&newnd.path);
         putname(to);
 exit1:
         path_put(&oldnd.path);
         putname(from);
+        if (should_retry) {
+                should_retry = false;
+                lookup_flags |= LOOKUP_REVAL;
+                goto retry;
+        }
 exit:
         return error;
 }