Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/vfs

Pull vfs changes from Al Viro.
 "A lot of misc stuff.  The obvious groups:
   * Miklos' atomic_open series; kills the damn abuse of
     ->d_revalidate() by NFS, which was the major stumbling block for
     all work in that area.
   * ripping security_file_mmap() and dealing with deadlocks in the
     area; sanitizing the neighborhood of vm_mmap()/vm_munmap() in
     general.
   * ->encode_fh() switched to saner API; insane fake dentry in
     mm/cleancache.c gone.
   * assorted annotations in fs (endianness, __user)
   * parts of Artem's ->s_dirty work (jff2 and reiserfs parts)
   * ->update_time() work from Josef.
   * other bits and pieces all over the place.

  Normally it would've been in two or three pull requests, but
  signal.git stuff had eaten a lot of time during this cycle ;-/"

Fix up trivial conflicts in Documentation/filesystems/vfs.txt (the
'truncate_range' inode method was removed by the VM changes, the VFS
update adds an 'update_time()' method), and in fs/btrfs/ulist.[ch] (due
to sparse fix added twice, with other changes nearby).

* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/vfs: (95 commits)
  nfs: don't open in ->d_revalidate
  vfs: retry last component if opening stale dentry
  vfs: nameidata_to_filp(): don't throw away file on error
  vfs: nameidata_to_filp(): inline __dentry_open()
  vfs: do_dentry_open(): don't put filp
  vfs: split __dentry_open()
  vfs: do_last() common post lookup
  vfs: do_last(): add audit_inode before open
  vfs: do_last(): only return EISDIR for O_CREAT
  vfs: do_last(): check LOOKUP_DIRECTORY
  vfs: do_last(): make ENOENT exit RCU safe
  vfs: make follow_link check RCU safe
  vfs: do_last(): use inode variable
  vfs: do_last(): inline walk_component()
  vfs: do_last(): make exit RCU safe
  vfs: split do_lookup()
  Btrfs: move over to use ->update_time
  fs: introduce inode operation ->update_time
  reiserfs: get rid of resierfs_sync_super
  reiserfs: mark the superblock as dirty a bit later
  ...

1 files changed, 127 insertions, 50 deletions

diff --git a/fs/namei.c b/fs/namei.c
index c651f02c9fec..7d694194024a 100644
--- a/fs/namei.c
+++ b/fs/namei.c
@@ -449,7 +449,7 @@ static int unlazy_walk(struct nameidata *nd, struct dentry *dentry)
         mntget(nd->path.mnt);
 
         rcu_read_unlock();
-        br_read_unlock(vfsmount_lock);
+        br_read_unlock(&vfsmount_lock);
         nd->flags &= ~LOOKUP_RCU;
         return 0;
 
@@ -507,14 +507,14 @@ static int complete_walk(struct nameidata *nd)
                 if (unlikely(!__d_rcu_to_refcount(dentry, nd->seq))) {
                         spin_unlock(&dentry->d_lock);
                         rcu_read_unlock();
-                        br_read_unlock(vfsmount_lock);
+                        br_read_unlock(&vfsmount_lock);
                         return -ECHILD;
                 }
                 BUG_ON(nd->inode != dentry->d_inode);
                 spin_unlock(&dentry->d_lock);
                 mntget(nd->path.mnt);
                 rcu_read_unlock();
-                br_read_unlock(vfsmount_lock);
+                br_read_unlock(&vfsmount_lock);
         }
 
         if (likely(!(nd->flags & LOOKUP_JUMPED)))
@@ -681,15 +681,15 @@ int follow_up(struct path *path)
         struct mount *parent;
         struct dentry *mountpoint;
 
-        br_read_lock(vfsmount_lock);
+        br_read_lock(&vfsmount_lock);
         parent = mnt->mnt_parent;
         if (&parent->mnt == path->mnt) {
-                br_read_unlock(vfsmount_lock);
+                br_read_unlock(&vfsmount_lock);
                 return 0;
         }
         mntget(&parent->mnt);
         mountpoint = dget(mnt->mnt_mountpoint);
-        br_read_unlock(vfsmount_lock);
+        br_read_unlock(&vfsmount_lock);
         dput(path->dentry);
         path->dentry = mountpoint;
         mntput(path->mnt);
@@ -947,7 +947,7 @@ failed:
         if (!(nd->flags & LOOKUP_ROOT))
                 nd->root.mnt = NULL;
         rcu_read_unlock();
-        br_read_unlock(vfsmount_lock);
+        br_read_unlock(&vfsmount_lock);
         return -ECHILD;
 }
 
@@ -1125,8 +1125,8 @@ static struct dentry *__lookup_hash(struct qstr *name,
  *  small and for now I'd prefer to have fast path as straight as possible.
  *  It _is_ time-critical.
  */
-static int do_lookup(struct nameidata *nd, struct qstr *name,
-                        struct path *path, struct inode **inode)
+static int lookup_fast(struct nameidata *nd, struct qstr *name,
+                       struct path *path, struct inode **inode)
 {
         struct vfsmount *mnt = nd->path.mnt;
         struct dentry *dentry, *parent = nd->path.dentry;
@@ -1208,7 +1208,7 @@ unlazy:
                         goto need_lookup;
                 }
         }
-done:
+
         path->mnt = mnt;
         path->dentry = dentry;
         err = follow_managed(path, nd->flags);
@@ -1222,6 +1222,17 @@ done:
         return 0;
 
 need_lookup:
+        return 1;
+}
+
+/* Fast lookup failed, do it the slow way */
+static int lookup_slow(struct nameidata *nd, struct qstr *name,
+                       struct path *path)
+{
+        struct dentry *dentry, *parent;
+        int err;
+
+        parent = nd->path.dentry;
         BUG_ON(nd->inode != parent->d_inode);
 
         mutex_lock(&parent->d_inode->i_mutex);
@@ -1229,7 +1240,16 @@ need_lookup:
         mutex_unlock(&parent->d_inode->i_mutex);
         if (IS_ERR(dentry))
                 return PTR_ERR(dentry);
-        goto done;
+        path->mnt = nd->path.mnt;
+        path->dentry = dentry;
+        err = follow_managed(path, nd->flags);
+        if (unlikely(err < 0)) {
+                path_put_conditional(path, nd);
+                return err;
+        }
+        if (err)
+                nd->flags |= LOOKUP_JUMPED;
+        return 0;
 }
 
 static inline int may_lookup(struct nameidata *nd)
@@ -1265,7 +1285,7 @@ static void terminate_walk(struct nameidata *nd)
                 if (!(nd->flags & LOOKUP_ROOT))
                         nd->root.mnt = NULL;
                 rcu_read_unlock();
-                br_read_unlock(vfsmount_lock);
+                br_read_unlock(&vfsmount_lock);
         }
 }
 
@@ -1301,21 +1321,26 @@ static inline int walk_component(struct nameidata *nd, struct path *path,
          */
         if (unlikely(type != LAST_NORM))
                 return handle_dots(nd, type);
-        err = do_lookup(nd, name, path, &inode);
+        err = lookup_fast(nd, name, path, &inode);
         if (unlikely(err)) {
-                terminate_walk(nd);
-                return err;
-        }
-        if (!inode) {
-                path_to_nameidata(path, nd);
-                terminate_walk(nd);
-                return -ENOENT;
+                if (err < 0)
+                        goto out_err;
+
+                err = lookup_slow(nd, name, path);
+                if (err < 0)
+                        goto out_err;
+
+                inode = path->dentry->d_inode;
         }
+        err = -ENOENT;
+        if (!inode)
+                goto out_path_put;
+
         if (should_follow_link(inode, follow)) {
                 if (nd->flags & LOOKUP_RCU) {
                         if (unlikely(unlazy_walk(nd, path->dentry))) {
-                                terminate_walk(nd);
-                                return -ECHILD;
+                                err = -ECHILD;
+                                goto out_err;
                         }
                 }
                 BUG_ON(inode != path->dentry->d_inode);
@@ -1324,6 +1349,12 @@ static inline int walk_component(struct nameidata *nd, struct path *path,
         path_to_nameidata(path, nd);
         nd->inode = inode;
         return 0;
+
+out_path_put:
+        path_to_nameidata(path, nd);
+out_err:
+        terminate_walk(nd);
+        return err;
 }
 
 /*
@@ -1620,7 +1651,7 @@ static int path_init(int dfd, const char *name, unsigned int flags,
                 nd->path = nd->root;
                 nd->inode = inode;
                 if (flags & LOOKUP_RCU) {
-                        br_read_lock(vfsmount_lock);
+                        br_read_lock(&vfsmount_lock);
                         rcu_read_lock();
                         nd->seq = __read_seqcount_begin(&nd->path.dentry->d_seq);
                 } else {
@@ -1633,7 +1664,7 @@ static int path_init(int dfd, const char *name, unsigned int flags,
 
         if (*name=='/') {
                 if (flags & LOOKUP_RCU) {
-                        br_read_lock(vfsmount_lock);
+                        br_read_lock(&vfsmount_lock);
                         rcu_read_lock();
                         set_root_rcu(nd);
                 } else {
@@ -1646,7 +1677,7 @@ static int path_init(int dfd, const char *name, unsigned int flags,
                         struct fs_struct *fs = current->fs;
                         unsigned seq;
 
-                        br_read_lock(vfsmount_lock);
+                        br_read_lock(&vfsmount_lock);
                         rcu_read_lock();
 
                         do {
@@ -1682,7 +1713,7 @@ static int path_init(int dfd, const char *name, unsigned int flags,
                         if (fput_needed)
                                 *fp = file;
                         nd->seq = __read_seqcount_begin(&nd->path.dentry->d_seq);
-                        br_read_lock(vfsmount_lock);
+                        br_read_lock(&vfsmount_lock);
                         rcu_read_lock();
                 } else {
                         path_get(&file->f_path);
@@ -2169,6 +2200,10 @@ static struct file *do_last(struct nameidata *nd, struct path *path,
         int want_write = 0;
         int acc_mode = op->acc_mode;
         struct file *filp;
+        struct inode *inode;
+        int symlink_ok = 0;
+        struct path save_parent = { .dentry = NULL, .mnt = NULL };
+        bool retried = false;
         int error;
 
         nd->flags &= ~LOOKUP_PARENT;
@@ -2200,30 +2235,23 @@ static struct file *do_last(struct nameidata *nd, struct path *path,
         }
 
         if (!(open_flag & O_CREAT)) {
-                int symlink_ok = 0;
                 if (nd->last.name[nd->last.len])
                         nd->flags |= LOOKUP_FOLLOW | LOOKUP_DIRECTORY;
                 if (open_flag & O_PATH && !(nd->flags & LOOKUP_FOLLOW))
                         symlink_ok = 1;
                 /* we _can_ be in RCU mode here */
-                error = walk_component(nd, path, &nd->last, LAST_NORM,
-                                        !symlink_ok);
-                if (error < 0)
-                        return ERR_PTR(error);
-                if (error) /* symlink */
-                        return NULL;
-                /* sayonara */
-                error = complete_walk(nd);
-                if (error)
-                        return ERR_PTR(error);
+                error = lookup_fast(nd, &nd->last, path, &inode);
+                if (unlikely(error)) {
+                        if (error < 0)
+                                goto exit;
 
-                error = -ENOTDIR;
-                if (nd->flags & LOOKUP_DIRECTORY) {
-                        if (!nd->inode->i_op->lookup)
+                        error = lookup_slow(nd, &nd->last, path);
+                        if (error < 0)
                                 goto exit;
+
+                        inode = path->dentry->d_inode;
                 }
-                audit_inode(pathname, nd->path.dentry);
-                goto ok;
+                goto finish_lookup;
         }
 
         /* create side of things */
@@ -2241,6 +2269,7 @@ static struct file *do_last(struct nameidata *nd, struct path *path,
         if (nd->last.name[nd->last.len])
                 goto exit;
 
+retry_lookup:
         mutex_lock(&dir->d_inode->i_mutex);
 
         dentry = lookup_hash(nd);
@@ -2302,22 +2331,49 @@ static struct file *do_last(struct nameidata *nd, struct path *path,
         if (error)
                 nd->flags |= LOOKUP_JUMPED;
 
+        BUG_ON(nd->flags & LOOKUP_RCU);
+        inode = path->dentry->d_inode;
+finish_lookup:
+        /* we _can_ be in RCU mode here */
         error = -ENOENT;
-        if (!path->dentry->d_inode)
-                goto exit_dput;
+        if (!inode) {
+                path_to_nameidata(path, nd);
+                goto exit;
+        }
 
-        if (path->dentry->d_inode->i_op->follow_link)
+        if (should_follow_link(inode, !symlink_ok)) {
+                if (nd->flags & LOOKUP_RCU) {
+                        if (unlikely(unlazy_walk(nd, path->dentry))) {
+                                error = -ECHILD;
+                                goto exit;
+                        }
+                }
+                BUG_ON(inode != path->dentry->d_inode);
                 return NULL;
+        }
 
-        path_to_nameidata(path, nd);
-        nd->inode = path->dentry->d_inode;
+        if ((nd->flags & LOOKUP_RCU) || nd->path.mnt != path->mnt) {
+                path_to_nameidata(path, nd);
+        } else {
+                save_parent.dentry = nd->path.dentry;
+                save_parent.mnt = mntget(path->mnt);
+                nd->path.dentry = path->dentry;
+
+        }
+        nd->inode = inode;
         /* Why this, you ask?  _Now_ we might have grown LOOKUP_JUMPED... */
         error = complete_walk(nd);
-        if (error)
+        if (error) {
+                path_put(&save_parent);
                 return ERR_PTR(error);
+        }
         error = -EISDIR;
-        if (S_ISDIR(nd->inode->i_mode))
+        if ((open_flag & O_CREAT) && S_ISDIR(nd->inode->i_mode))
+                goto exit;
+        error = -ENOTDIR;
+        if ((nd->flags & LOOKUP_DIRECTORY) && !nd->inode->i_op->lookup)
                 goto exit;
+        audit_inode(pathname, nd->path.dentry);
 ok:
         if (!S_ISREG(nd->inode->i_mode))
                 will_truncate = 0;
@@ -2333,6 +2389,20 @@ common:
         if (error)
                 goto exit;
         filp = nameidata_to_filp(nd);
+        if (filp == ERR_PTR(-EOPENSTALE) && save_parent.dentry && !retried) {
+                BUG_ON(save_parent.dentry != dir);
+                path_put(&nd->path);
+                nd->path = save_parent;
+                nd->inode = dir->d_inode;
+                save_parent.mnt = NULL;
+                save_parent.dentry = NULL;
+                if (want_write) {
+                        mnt_drop_write(nd->path.mnt);
+                        want_write = 0;
+                }
+                retried = true;
+                goto retry_lookup;
+        }
         if (!IS_ERR(filp)) {
                 error = ima_file_check(filp, op->acc_mode);
                 if (error) {
@@ -2352,7 +2422,8 @@ common:
 out:
         if (want_write)
                 mnt_drop_write(nd->path.mnt);
-        path_put(&nd->path);
+        path_put(&save_parent);
+        terminate_walk(nd);
         return filp;
 
 exit_mutex_unlock:
@@ -2415,6 +2486,12 @@ out:
         if (base)
                 fput(base);
         release_open_intent(nd);
+        if (filp == ERR_PTR(-EOPENSTALE)) {
+                if (flags & LOOKUP_RCU)
+                        filp = ERR_PTR(-ECHILD);
+                else
+                        filp = ERR_PTR(-ESTALE);
+        }
         return filp;
 
 out_filp: