Merge branch 'master' into devel and apply fixup from Stephen Rothwell:

vfs/nfs: fixup for nfs_open_context change

Signed-off-by: Stephen Rothwell <sfr@canb.auug.org.au>
Signed-off-by: Trond Myklebust <Trond.Myklebust@netapp.com>

13 files changed, 150 insertions, 142 deletions

diff --git a/fs/nfs/cache_lib.c b/fs/nfs/cache_lib.c
index 84690319e625..c98b439332fc 100644
--- a/fs/nfs/cache_lib.c
+++ b/fs/nfs/cache_lib.c
@@ -113,19 +113,18 @@ int nfs_cache_wait_for_upcall(struct nfs_cache_defer_req *dreq)
 
 int nfs_cache_register(struct cache_detail *cd)
 {
-        struct nameidata nd;
         struct vfsmount *mnt;
+        struct path path;
         int ret;
 
         mnt = rpc_get_mount();
         if (IS_ERR(mnt))
                 return PTR_ERR(mnt);
-        ret = vfs_path_lookup(mnt->mnt_root, mnt, "/cache", 0, &nd);
+        ret = vfs_path_lookup(mnt->mnt_root, mnt, "/cache", 0, &path);
         if (ret)
                 goto err;
-        ret = sunrpc_cache_register_pipefs(nd.path.dentry,
-                        cd->name, 0600, cd);
-        path_put(&nd.path);
+        ret = sunrpc_cache_register_pipefs(path.dentry, cd->name, 0600, cd);
+        path_put(&path);
         if (!ret)
                 return ret;
 err:
diff --git a/fs/nfs/dir.c b/fs/nfs/dir.c
index ededdbd0db38..57f578e2560a 100644
--- a/fs/nfs/dir.c
+++ b/fs/nfs/dir.c
@@ -56,7 +56,7 @@ static int nfs_link(struct dentry *, struct inode *, struct dentry *);
 static int nfs_mknod(struct inode *, struct dentry *, int, dev_t);
 static int nfs_rename(struct inode *, struct dentry *,
                       struct inode *, struct dentry *);
-static int nfs_fsync_dir(struct file *, int);
+static int nfs_fsync_dir(struct file *, loff_t, loff_t, int);
 static loff_t nfs_llseek_dir(struct file *, loff_t, int);
 static void nfs_readdir_clear_array(struct page*);
 
@@ -945,15 +945,19 @@ out:
  * All directory operations under NFS are synchronous, so fsync()
  * is a dummy operation.
  */
-static int nfs_fsync_dir(struct file *filp, int datasync)
+static int nfs_fsync_dir(struct file *filp, loff_t start, loff_t end,
+                         int datasync)
 {
         struct dentry *dentry = filp->f_path.dentry;
+        struct inode *inode = dentry->d_inode;
 
         dfprintk(FILE, "NFS: fsync dir(%s/%s) datasync %d\n",
                         dentry->d_parent->d_name.name, dentry->d_name.name,
                         datasync);
 
+        mutex_lock(&inode->i_mutex);
         nfs_inc_stats(dentry->d_inode, NFSIOS_VFSFSYNC);
+        mutex_unlock(&inode->i_mutex);
         return 0;
 }
 
@@ -997,14 +1001,12 @@ static int nfs_check_verifier(struct inode *dir, struct dentry *dentry)
  * Return the intent data that applies to this particular path component
  *
  * Note that the current set of intents only apply to the very last
- * component of the path.
- * We check for this using LOOKUP_CONTINUE and LOOKUP_PARENT.
+ * component of the path and none of them is set before that last
+ * component.
  */
 static inline unsigned int nfs_lookup_check_intent(struct nameidata *nd,
                                                 unsigned int mask)
 {
-        if (nd->flags & (LOOKUP_CONTINUE|LOOKUP_PARENT))
-                return 0;
         return nd->flags & mask;
 }
 
@@ -1338,25 +1340,31 @@ static int is_atomic_open(struct nameidata *nd)
                 return 0;
         /* Are we trying to write to a read only partition? */
         if (__mnt_is_readonly(nd->path.mnt) &&
-            (nd->intent.open.flags & (O_CREAT|O_TRUNC|FMODE_WRITE)))
+            (nd->intent.open.flags & (O_CREAT|O_TRUNC|O_ACCMODE)))
                 return 0;
         return 1;
 }
 
-static struct nfs_open_context *nameidata_to_nfs_open_context(struct dentry *dentry, struct nameidata *nd)
+static fmode_t flags_to_mode(int flags)
+{
+        fmode_t res = (__force fmode_t)flags & FMODE_EXEC;
+        if ((flags & O_ACCMODE) != O_WRONLY)
+                res |= FMODE_READ;
+        if ((flags & O_ACCMODE) != O_RDONLY)
+                res |= FMODE_WRITE;
+        return res;
+}
+
+static struct nfs_open_context *create_nfs_open_context(struct dentry *dentry, int open_flags)
 {
-        struct path path = {
-                .mnt = nd->path.mnt,
-                .dentry = dentry,
-        };
         struct nfs_open_context *ctx;
         struct rpc_cred *cred;
-        fmode_t fmode = nd->intent.open.flags & (FMODE_READ | FMODE_WRITE | FMODE_EXEC);
+        fmode_t fmode = flags_to_mode(open_flags);
 
         cred = rpc_lookup_cred();
         if (IS_ERR(cred))
                 return ERR_CAST(cred);
-        ctx = alloc_nfs_open_context(&path, cred, fmode);
+        ctx = alloc_nfs_open_context(dentry, cred, fmode);
         put_rpccred(cred);
         if (ctx == NULL)
                 return ERR_PTR(-ENOMEM);
@@ -1376,13 +1384,13 @@ static int nfs_intent_set_file(struct nameidata *nd, struct nfs_open_context *ct
 
         /* If the open_intent is for execute, we have an extra check to make */
         if (ctx->mode & FMODE_EXEC) {
-                ret = nfs_may_open(ctx->path.dentry->d_inode,
+                ret = nfs_may_open(ctx->dentry->d_inode,
                                 ctx->cred,
                                 nd->intent.open.flags);
                 if (ret < 0)
                         goto out;
         }
-        filp = lookup_instantiate_filp(nd, ctx->path.dentry, do_open);
+        filp = lookup_instantiate_filp(nd, ctx->dentry, do_open);
         if (IS_ERR(filp))
                 ret = PTR_ERR(filp);
         else
@@ -1420,12 +1428,13 @@ static struct dentry *nfs_atomic_lookup(struct inode *dir, struct dentry *dentry
                 goto out;
         }
 
-        ctx = nameidata_to_nfs_open_context(dentry, nd);
+        open_flags = nd->intent.open.flags;
+
+        ctx = create_nfs_open_context(dentry, open_flags);
         res = ERR_CAST(ctx);
         if (IS_ERR(ctx))
                 goto out;
 
-        open_flags = nd->intent.open.flags;
         if (nd->flags & LOOKUP_CREATE) {
                 attr.ia_mode = nd->intent.open.create_mode;
                 attr.ia_valid = ATTR_MODE;
@@ -1463,8 +1472,8 @@ static struct dentry *nfs_atomic_lookup(struct inode *dir, struct dentry *dentry
         res = d_add_unique(dentry, inode);
         nfs_unblock_sillyrename(dentry->d_parent);
         if (res != NULL) {
-                dput(ctx->path.dentry);
-                ctx->path.dentry = dget(res);
+                dput(ctx->dentry);
+                ctx->dentry = dget(res);
                 dentry = res;
         }
         err = nfs_intent_set_file(nd, ctx);
@@ -1517,7 +1526,7 @@ static int nfs_open_revalidate(struct dentry *dentry, struct nameidata *nd)
         /* We can't create new files, or truncate existing ones here */
         openflags &= ~(O_CREAT|O_EXCL|O_TRUNC);
 
-        ctx = nameidata_to_nfs_open_context(dentry, nd);
+        ctx = create_nfs_open_context(dentry, openflags);
         ret = PTR_ERR(ctx);
         if (IS_ERR(ctx))
                 goto out;
@@ -1570,7 +1579,7 @@ static int nfs_open_create(struct inode *dir, struct dentry *dentry, int mode,
         struct nfs_open_context *ctx = NULL;
         struct iattr attr;
         int error;
-        int open_flags = 0;
+        int open_flags = O_CREAT|O_EXCL;
 
         dfprintk(VFS, "NFS: create(%s/%ld), %s\n",
                         dir->i_sb->s_id, dir->i_ino, dentry->d_name.name);
@@ -1578,27 +1587,27 @@ static int nfs_open_create(struct inode *dir, struct dentry *dentry, int mode,
         attr.ia_mode = mode;
         attr.ia_valid = ATTR_MODE;
 
-        if ((nd->flags & LOOKUP_CREATE) != 0) {
+        if (nd)
                 open_flags = nd->intent.open.flags;
 
-                ctx = nameidata_to_nfs_open_context(dentry, nd);
-                error = PTR_ERR(ctx);
-                if (IS_ERR(ctx))
-                        goto out_err_drop;
-        }
+        ctx = create_nfs_open_context(dentry, open_flags);
+        error = PTR_ERR(ctx);
+        if (IS_ERR(ctx))
+                goto out_err_drop;
 
         error = NFS_PROTO(dir)->create(dir, dentry, &attr, open_flags, ctx);
         if (error != 0)
                 goto out_put_ctx;
-        if (ctx != NULL) {
+        if (nd) {
                 error = nfs_intent_set_file(nd, ctx);
                 if (error < 0)
                         goto out_err;
+        } else {
+                put_nfs_open_context(ctx);
         }
         return 0;
 out_put_ctx:
-        if (ctx != NULL)
-                put_nfs_open_context(ctx);
+        put_nfs_open_context(ctx);
 out_err_drop:
         d_drop(dentry);
 out_err:
@@ -1660,7 +1669,7 @@ static int nfs_create(struct inode *dir, struct dentry *dentry, int mode,
 {
         struct iattr attr;
         int error;
-        int open_flags = 0;
+        int open_flags = O_CREAT|O_EXCL;
 
         dfprintk(VFS, "NFS: create(%s/%ld), %s\n",
                         dir->i_sb->s_id, dir->i_ino, dentry->d_name.name);
@@ -1668,7 +1677,7 @@ static int nfs_create(struct inode *dir, struct dentry *dentry, int mode,
         attr.ia_mode = mode;
         attr.ia_valid = ATTR_MODE;
 
-        if ((nd->flags & LOOKUP_CREATE) != 0)
+        if (nd)
                 open_flags = nd->intent.open.flags;
 
         error = NFS_PROTO(dir)->create(dir, dentry, &attr, open_flags, NULL);
@@ -2259,11 +2268,11 @@ static int nfs_open_permission_mask(int openflags)
 {
         int mask = 0;
 
-        if (openflags & FMODE_READ)
+        if ((openflags & O_ACCMODE) != O_WRONLY)
                 mask |= MAY_READ;
-        if (openflags & FMODE_WRITE)
+        if ((openflags & O_ACCMODE) != O_RDONLY)
                 mask |= MAY_WRITE;
-        if (openflags & FMODE_EXEC)
+        if (openflags & __FMODE_EXEC)
                 mask |= MAY_EXEC;
         return mask;
 }
@@ -2273,12 +2282,12 @@ int nfs_may_open(struct inode *inode, struct rpc_cred *cred, int openflags)
         return nfs_do_access(inode, cred, nfs_open_permission_mask(openflags));
 }
 
-int nfs_permission(struct inode *inode, int mask, unsigned int flags)
+int nfs_permission(struct inode *inode, int mask)
 {
         struct rpc_cred *cred;
         int res = 0;
 
-        if (flags & IPERM_FLAG_RCU)
+        if (mask & MAY_NOT_BLOCK)
                 return -ECHILD;
 
         nfs_inc_stats(inode, NFSIOS_VFSACCESS);
@@ -2328,7 +2337,7 @@ out:
 out_notsup:
         res = nfs_revalidate_inode(NFS_SERVER(inode), inode);
         if (res == 0)
-                res = generic_permission(inode, mask, flags, NULL);
+                res = generic_permission(inode, mask);
         goto out;
 }
 
diff --git a/fs/nfs/direct.c b/fs/nfs/direct.c
index 8eea25366717..b35d25b98da6 100644
--- a/fs/nfs/direct.c
+++ b/fs/nfs/direct.c
@@ -284,7 +284,7 @@ static ssize_t nfs_direct_read_schedule_segment(struct nfs_direct_req *dreq,
                                                 loff_t pos)
 {
         struct nfs_open_context *ctx = dreq->ctx;
-        struct inode *inode = ctx->path.dentry->d_inode;
+        struct inode *inode = ctx->dentry->d_inode;
         unsigned long user_addr = (unsigned long)iov->iov_base;
         size_t count = iov->iov_len;
         size_t rsize = NFS_SERVER(inode)->rsize;
@@ -715,7 +715,7 @@ static ssize_t nfs_direct_write_schedule_segment(struct nfs_direct_req *dreq,
                                                  loff_t pos, int sync)
 {
         struct nfs_open_context *ctx = dreq->ctx;
-        struct inode *inode = ctx->path.dentry->d_inode;
+        struct inode *inode = ctx->dentry->d_inode;
         unsigned long user_addr = (unsigned long)iov->iov_base;
         size_t count = iov->iov_len;
         struct rpc_task *task;
diff --git a/fs/nfs/file.c b/fs/nfs/file.c
index 2f093ed16980..28b8c3f3cda3 100644
--- a/fs/nfs/file.c
+++ b/fs/nfs/file.c
@@ -55,7 +55,7 @@ static ssize_t nfs_file_splice_write(struct pipe_inode_info *pipe,
 static ssize_t nfs_file_write(struct kiocb *, const struct iovec *iov,
                                 unsigned long nr_segs, loff_t pos);
 static int  nfs_file_flush(struct file *, fl_owner_t id);
-static int  nfs_file_fsync(struct file *, int datasync);
+static int  nfs_file_fsync(struct file *, loff_t, loff_t, int datasync);
 static int nfs_check_flags(int flags);
 static int nfs_lock(struct file *filp, int cmd, struct file_lock *fl);
 static int nfs_flock(struct file *filp, int cmd, struct file_lock *fl);
@@ -187,8 +187,11 @@ static loff_t nfs_file_llseek(struct file *filp, loff_t offset, int origin)
                         filp->f_path.dentry->d_name.name,
                         offset, origin);
 
-        /* origin == SEEK_END => we must revalidate the cached file length */
-        if (origin == SEEK_END) {
+        /*
+         * origin == SEEK_END || SEEK_DATA || SEEK_HOLE => we must revalidate
+         * the cached file length
+         */
+        if (origin != SEEK_SET || origin != SEEK_CUR) {
                 struct inode *inode = filp->f_mapping->host;
 
                 int retval = nfs_revalidate_file_size(inode, filp);
@@ -305,7 +308,7 @@ nfs_file_mmap(struct file * file, struct vm_area_struct * vma)
  * fall back to doing a synchronous write.
  */
 static int
-nfs_file_fsync(struct file *file, int datasync)
+nfs_file_fsync(struct file *file, loff_t start, loff_t end, int datasync)
 {
         struct dentry *dentry = file->f_path.dentry;
         struct nfs_open_context *ctx = nfs_file_open_context(file);
@@ -313,11 +316,15 @@ nfs_file_fsync(struct file *file, int datasync)
         int have_error, status;
         int ret = 0;
 
-
         dprintk("NFS: fsync file(%s/%s) datasync %d\n",
                         dentry->d_parent->d_name.name, dentry->d_name.name,
                         datasync);
 
+        ret = filemap_write_and_wait_range(inode->i_mapping, start, end);
+        if (ret)
+                return ret;
+        mutex_lock(&inode->i_mutex);
+
         nfs_inc_stats(inode, NFSIOS_VFSFSYNC);
         have_error = test_and_clear_bit(NFS_CONTEXT_ERROR_WRITE, &ctx->flags);
         status = nfs_commit_inode(inode, FLUSH_SYNC);
@@ -329,6 +336,7 @@ nfs_file_fsync(struct file *file, int datasync)
         if (!ret && !datasync)
                 /* application has asked for meta-data sync */
                 ret = pnfs_layoutcommit_inode(inode, true);
+        mutex_unlock(&inode->i_mutex);
         return ret;
 }
 
diff --git a/fs/nfs/fscache.c b/fs/nfs/fscache.c
index ce153a6b3aec..419119c371bf 100644
--- a/fs/nfs/fscache.c
+++ b/fs/nfs/fscache.c
@@ -259,12 +259,10 @@ static void nfs_fscache_disable_inode_cookie(struct inode *inode)
                 dfprintk(FSCACHE,
                          "NFS: nfsi 0x%p turning cache off\n", NFS_I(inode));
 
-                /* Need to invalidate any mapped pages that were read in before
-                 * turning off the cache.
+                /* Need to uncache any pages attached to this inode that
+                 * fscache knows about before turning off the cache.
                  */
-                if (inode->i_mapping && inode->i_mapping->nrpages)
-                        invalidate_inode_pages2(inode->i_mapping);
-
+                fscache_uncache_all_inode_pages(NFS_I(inode)->fscache, inode);
                 nfs_fscache_zap_inode_cookie(inode);
         }
 }
diff --git a/fs/nfs/inode.c b/fs/nfs/inode.c
index 6f4850deb272..fe1203797b2b 100644
--- a/fs/nfs/inode.c
+++ b/fs/nfs/inode.c
@@ -567,7 +567,7 @@ static struct nfs_lock_context *__nfs_find_lock_context(struct nfs_open_context
 struct nfs_lock_context *nfs_get_lock_context(struct nfs_open_context *ctx)
 {
         struct nfs_lock_context *res, *new = NULL;
-        struct inode *inode = ctx->path.dentry->d_inode;
+        struct inode *inode = ctx->dentry->d_inode;
 
         spin_lock(&inode->i_lock);
         res = __nfs_find_lock_context(ctx);
@@ -594,7 +594,7 @@ struct nfs_lock_context *nfs_get_lock_context(struct nfs_open_context *ctx)
 void nfs_put_lock_context(struct nfs_lock_context *l_ctx)
 {
         struct nfs_open_context *ctx = l_ctx->open_context;
-        struct inode *inode = ctx->path.dentry->d_inode;
+        struct inode *inode = ctx->dentry->d_inode;
 
         if (!atomic_dec_and_lock(&l_ctx->count, &inode->i_lock))
                 return;
@@ -620,7 +620,7 @@ void nfs_close_context(struct nfs_open_context *ctx, int is_sync)
                 return;
         if (!is_sync)
                 return;
-        inode = ctx->path.dentry->d_inode;
+        inode = ctx->dentry->d_inode;
         if (!list_empty(&NFS_I(inode)->open_files))
                 return;
         server = NFS_SERVER(inode);
@@ -629,14 +629,14 @@ void nfs_close_context(struct nfs_open_context *ctx, int is_sync)
         nfs_revalidate_inode(server, inode);
 }
 
-struct nfs_open_context *alloc_nfs_open_context(struct path *path, struct rpc_cred *cred, fmode_t f_mode)
+struct nfs_open_context *alloc_nfs_open_context(struct dentry *dentry, struct rpc_cred *cred, fmode_t f_mode)
 {
         struct nfs_open_context *ctx;
 
         ctx = kmalloc(sizeof(*ctx), GFP_KERNEL);
         if (ctx != NULL) {
-                ctx->path = *path;
-                path_get(&ctx->path);
+                nfs_sb_active(dentry->d_sb);
+                ctx->dentry = dget(dentry);
                 ctx->cred = get_rpccred(cred);
                 ctx->state = NULL;
                 ctx->mode = f_mode;
@@ -658,7 +658,8 @@ struct nfs_open_context *get_nfs_open_context(struct nfs_open_context *ctx)
 
 static void __put_nfs_open_context(struct nfs_open_context *ctx, int is_sync)
 {
-        struct inode *inode = ctx->path.dentry->d_inode;
+        struct inode *inode = ctx->dentry->d_inode;
+        struct super_block *sb = ctx->dentry->d_sb;
 
         if (!list_empty(&ctx->list)) {
                 if (!atomic_dec_and_lock(&ctx->lock_context.count, &inode->i_lock))
@@ -671,7 +672,8 @@ static void __put_nfs_open_context(struct nfs_open_context *ctx, int is_sync)
                 NFS_PROTO(inode)->close_context(ctx, is_sync);
         if (ctx->cred != NULL)
                 put_rpccred(ctx->cred);
-        path_put(&ctx->path);
+        dput(ctx->dentry);
+        nfs_sb_deactive(sb);
         kfree(ctx);
 }
 
@@ -741,7 +743,7 @@ int nfs_open(struct inode *inode, struct file *filp)
         cred = rpc_lookup_cred();
         if (IS_ERR(cred))
                 return PTR_ERR(cred);
-        ctx = alloc_nfs_open_context(&filp->f_path, cred, filp->f_mode);
+        ctx = alloc_nfs_open_context(filp->f_path.dentry, cred, filp->f_mode);
         put_rpccred(cred);
         if (ctx == NULL)
                 return -ENOMEM;
diff --git a/fs/nfs/nfs4_fs.h b/fs/nfs/nfs4_fs.h
index c30aed2c70f4..1909ee8be350 100644
--- a/fs/nfs/nfs4_fs.h
+++ b/fs/nfs/nfs4_fs.h
@@ -241,7 +241,7 @@ extern int nfs4_proc_async_renew(struct nfs_client *, struct rpc_cred *);
 extern int nfs4_proc_renew(struct nfs_client *, struct rpc_cred *);
 extern int nfs4_init_clientid(struct nfs_client *, struct rpc_cred *);
 extern int nfs41_init_clientid(struct nfs_client *, struct rpc_cred *);
-extern int nfs4_do_close(struct path *path, struct nfs4_state *state, gfp_t gfp_mask, int wait, bool roc);
+extern int nfs4_do_close(struct nfs4_state *state, gfp_t gfp_mask, int wait, bool roc);
 extern int nfs4_server_capabilities(struct nfs_server *server, struct nfs_fh *fhandle);
 extern int nfs4_proc_fs_locations(struct inode *dir, const struct qstr *name,
                 struct nfs4_fs_locations *fs_locations, struct page *page);
@@ -344,8 +344,8 @@ extern struct nfs4_state_owner * nfs4_get_state_owner(struct nfs_server *, struc
 extern void nfs4_put_state_owner(struct nfs4_state_owner *);
 extern struct nfs4_state * nfs4_get_open_state(struct inode *, struct nfs4_state_owner *);
 extern void nfs4_put_open_state(struct nfs4_state *);
-extern void nfs4_close_state(struct path *, struct nfs4_state *, fmode_t);
-extern void nfs4_close_sync(struct path *, struct nfs4_state *, fmode_t);
+extern void nfs4_close_state(struct nfs4_state *, fmode_t);
+extern void nfs4_close_sync(struct nfs4_state *, fmode_t);
 extern void nfs4_state_set_mode_locked(struct nfs4_state *, fmode_t);
 extern void nfs4_schedule_lease_recovery(struct nfs_client *);
 extern void nfs4_schedule_state_manager(struct nfs_client *);
@@ -378,8 +378,8 @@ extern struct svc_version nfs4_callback_version4;
 
 #else
 
-#define nfs4_close_state(a, b, c) do { } while (0)
-#define nfs4_close_sync(a, b, c) do { } while (0)
+#define nfs4_close_state(a, b) do { } while (0)
+#define nfs4_close_sync(a, b) do { } while (0)
 
 #endif /* CONFIG_NFS_V4 */
 #endif /* __LINUX_FS_NFS_NFS4_FS.H */
diff --git a/fs/nfs/nfs4proc.c b/fs/nfs/nfs4proc.c
index 93ef77666efc..079614deca3f 100644
--- a/fs/nfs/nfs4proc.c
+++ b/fs/nfs/nfs4proc.c
@@ -766,8 +766,8 @@ struct nfs4_opendata {
         struct nfs_open_confirmres c_res;
         struct nfs_fattr f_attr;
         struct nfs_fattr dir_attr;
-        struct path path;
         struct dentry *dir;
+        struct dentry *dentry;
         struct nfs4_state_owner *owner;
         struct nfs4_state *state;
         struct iattr attrs;
@@ -789,12 +789,12 @@ static void nfs4_init_opendata_res(struct nfs4_opendata *p)
         nfs_fattr_init(&p->dir_attr);
 }
 
-static struct nfs4_opendata *nfs4_opendata_alloc(struct path *path,
+static struct nfs4_opendata *nfs4_opendata_alloc(struct dentry *dentry,
                 struct nfs4_state_owner *sp, fmode_t fmode, int flags,
                 const struct iattr *attrs,
                 gfp_t gfp_mask)
 {
-        struct dentry *parent = dget_parent(path->dentry);
+        struct dentry *parent = dget_parent(dentry);
         struct inode *dir = parent->d_inode;
         struct nfs_server *server = NFS_SERVER(dir);
         struct nfs4_opendata *p;
@@ -805,8 +805,8 @@ static struct nfs4_opendata *nfs4_opendata_alloc(struct path *path,
         p->o_arg.seqid = nfs_alloc_seqid(&sp->so_seqid, gfp_mask);
         if (p->o_arg.seqid == NULL)
                 goto err_free;
-        path_get(path);
-        p->path = *path;
+        nfs_sb_active(dentry->d_sb);
+        p->dentry = dget(dentry);
         p->dir = parent;
         p->owner = sp;
         atomic_inc(&sp->so_count);
@@ -815,7 +815,7 @@ static struct nfs4_opendata *nfs4_opendata_alloc(struct path *path,
         p->o_arg.fmode = fmode & (FMODE_READ|FMODE_WRITE);
         p->o_arg.clientid = server->nfs_client->cl_clientid;
         p->o_arg.id = sp->so_owner_id.id;
-        p->o_arg.name = &p->path.dentry->d_name;
+        p->o_arg.name = &dentry->d_name;
         p->o_arg.server = server;
         p->o_arg.bitmask = server->attr_bitmask;
         p->o_arg.claim = NFS4_OPEN_CLAIM_NULL;
@@ -845,13 +845,15 @@ static void nfs4_opendata_free(struct kref *kref)
 {
         struct nfs4_opendata *p = container_of(kref,
                         struct nfs4_opendata, kref);
+        struct super_block *sb = p->dentry->d_sb;
 
         nfs_free_seqid(p->o_arg.seqid);
         if (p->state != NULL)
                 nfs4_put_open_state(p->state);
         nfs4_put_state_owner(p->owner);
         dput(p->dir);
-        path_put(&p->path);
+        dput(p->dentry);
+        nfs_sb_deactive(sb);
         kfree(p);
 }
 
@@ -1133,7 +1135,7 @@ static struct nfs4_opendata *nfs4_open_recoverdata_alloc(struct nfs_open_context
 {
         struct nfs4_opendata *opendata;
 
-        opendata = nfs4_opendata_alloc(&ctx->path, state->owner, 0, 0, NULL, GFP_NOFS);
+        opendata = nfs4_opendata_alloc(ctx->dentry, state->owner, 0, 0, NULL, GFP_NOFS);
         if (opendata == NULL)
                 return ERR_PTR(-ENOMEM);
         opendata->state = state;
@@ -1157,7 +1159,7 @@ static int nfs4_open_recover_helper(struct nfs4_opendata *opendata, fmode_t fmod
         newstate = nfs4_opendata_to_nfs4_state(opendata);
         if (IS_ERR(newstate))
                 return PTR_ERR(newstate);
-        nfs4_close_state(&opendata->path, newstate, fmode);
+        nfs4_close_state(newstate, fmode);
         *res = newstate;
         return 0;
 }
@@ -1355,7 +1357,7 @@ static void nfs4_open_confirm_release(void *calldata)
                 goto out_free;
         state = nfs4_opendata_to_nfs4_state(data);
         if (!IS_ERR(state))
-                nfs4_close_state(&data->path, state, data->o_arg.fmode);
+                nfs4_close_state(state, data->o_arg.fmode);
 out_free:
         nfs4_opendata_put(data);
 }
@@ -1500,7 +1502,7 @@ static void nfs4_open_release(void *calldata)
                 goto out_free;
         state = nfs4_opendata_to_nfs4_state(data);
         if (!IS_ERR(state))
-                nfs4_close_state(&data->path, state, data->o_arg.fmode);
+                nfs4_close_state(state, data->o_arg.fmode);
 out_free:
         nfs4_opendata_put(data);
 }
@@ -1651,7 +1653,7 @@ static int _nfs4_open_expired(struct nfs_open_context *ctx, struct nfs4_state *s
                 return PTR_ERR(opendata);
         ret = nfs4_open_recover(opendata, state);
         if (ret == -ESTALE)
-                d_drop(ctx->path.dentry);
+                d_drop(ctx->dentry);
         nfs4_opendata_put(opendata);
         return ret;
 }
@@ -1723,7 +1725,7 @@ static inline void nfs4_exclusive_attrset(struct nfs4_opendata *opendata, struct
 /*
  * Returns a referenced nfs4_state
  */
-static int _nfs4_do_open(struct inode *dir, struct path *path, fmode_t fmode, int flags, struct iattr *sattr, struct rpc_cred *cred, struct nfs4_state **res)
+static int _nfs4_do_open(struct inode *dir, struct dentry *dentry, fmode_t fmode, int flags, struct iattr *sattr, struct rpc_cred *cred, struct nfs4_state **res)
 {
         struct nfs4_state_owner  *sp;
         struct nfs4_state     *state = NULL;
@@ -1740,15 +1742,15 @@ static int _nfs4_do_open(struct inode *dir, struct path *path, fmode_t fmode, in
         status = nfs4_recover_expired_lease(server);
         if (status != 0)
                 goto err_put_state_owner;
-        if (path->dentry->d_inode != NULL)
-                nfs4_return_incompatible_delegation(path->dentry->d_inode, fmode);
+        if (dentry->d_inode != NULL)
+                nfs4_return_incompatible_delegation(dentry->d_inode, fmode);
         status = -ENOMEM;
-        opendata = nfs4_opendata_alloc(path, sp, fmode, flags, sattr, GFP_KERNEL);
+        opendata = nfs4_opendata_alloc(dentry, sp, fmode, flags, sattr, GFP_KERNEL);
         if (opendata == NULL)
                 goto err_put_state_owner;
 
-        if (path->dentry->d_inode != NULL)
-                opendata->state = nfs4_get_open_state(path->dentry->d_inode, sp);
+        if (dentry->d_inode != NULL)
+                opendata->state = nfs4_get_open_state(dentry->d_inode, sp);
 
         status = _nfs4_proc_open(opendata);
         if (status != 0)
@@ -1786,14 +1788,14 @@ out_err:
 }
 
 
-static struct nfs4_state *nfs4_do_open(struct inode *dir, struct path *path, fmode_t fmode, int flags, struct iattr *sattr, struct rpc_cred *cred)
+static struct nfs4_state *nfs4_do_open(struct inode *dir, struct dentry *dentry, fmode_t fmode, int flags, struct iattr *sattr, struct rpc_cred *cred)
 {
         struct nfs4_exception exception = { };
         struct nfs4_state *res;
         int status;
 
         do {
-                status = _nfs4_do_open(dir, path, fmode, flags, sattr, cred, &res);
+                status = _nfs4_do_open(dir, dentry, fmode, flags, sattr, cred, &res);
                 if (status == 0)
                         break;
                 /* NOTE: BAD_SEQID means the server and client disagree about the
@@ -1890,7 +1892,6 @@ static int nfs4_do_setattr(struct inode *inode, struct rpc_cred *cred,
 }
 
 struct nfs4_closedata {
-        struct path path;
         struct inode *inode;
         struct nfs4_state *state;
         struct nfs_closeargs arg;
@@ -1905,13 +1906,14 @@ static void nfs4_free_closedata(void *data)
 {
         struct nfs4_closedata *calldata = data;
         struct nfs4_state_owner *sp = calldata->state->owner;
+        struct super_block *sb = calldata->state->inode->i_sb;
 
         if (calldata->roc)
                 pnfs_roc_release(calldata->state->inode);
         nfs4_put_open_state(calldata->state);
         nfs_free_seqid(calldata->arg.seqid);
         nfs4_put_state_owner(sp);
-        path_put(&calldata->path);
+        nfs_sb_deactive(sb);
         kfree(calldata);
 }
 
@@ -2031,7 +2033,7 @@ static const struct rpc_call_ops nfs4_close_ops = {
  *
  * NOTE: Caller must be holding the sp->so_owner semaphore!
  */
-int nfs4_do_close(struct path *path, struct nfs4_state *state, gfp_t gfp_mask, int wait, bool roc)
+int nfs4_do_close(struct nfs4_state *state, gfp_t gfp_mask, int wait, bool roc)
 {
         struct nfs_server *server = NFS_SERVER(state->inode);
         struct nfs4_closedata *calldata;
@@ -2067,8 +2069,7 @@ int nfs4_do_close(struct path *path, struct nfs4_state *state, gfp_t gfp_mask, i
         calldata->res.seqid = calldata->arg.seqid;
         calldata->res.server = server;
         calldata->roc = roc;
-        path_get(path);
-        calldata->path = *path;
+        nfs_sb_active(calldata->inode->i_sb);
 
         msg.rpc_argp = &calldata->arg;
         msg.rpc_resp = &calldata->res;
@@ -2097,7 +2098,7 @@ nfs4_atomic_open(struct inode *dir, struct nfs_open_context *ctx, int open_flags
         struct nfs4_state *state;
 
         /* Protect against concurrent sillydeletes */
-        state = nfs4_do_open(dir, &ctx->path, ctx->mode, open_flags, attr, ctx->cred);
+        state = nfs4_do_open(dir, ctx->dentry, ctx->mode, open_flags, attr, ctx->cred);
         if (IS_ERR(state))
                 return ERR_CAST(state);
         ctx->state = state;
@@ -2109,9 +2110,9 @@ static void nfs4_close_context(struct nfs_open_context *ctx, int is_sync)
         if (ctx->state == NULL)
                 return;
         if (is_sync)
-                nfs4_close_sync(&ctx->path, ctx->state, ctx->mode);
+                nfs4_close_sync(ctx->state, ctx->mode);
         else
-                nfs4_close_state(&ctx->path, ctx->state, ctx->mode);
+                nfs4_close_state(ctx->state, ctx->mode);
 }
 
 static int _nfs4_server_capabilities(struct nfs_server *server, struct nfs_fh *fhandle)
@@ -2634,10 +2635,7 @@ static int
 nfs4_proc_create(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
                  int flags, struct nfs_open_context *ctx)
 {
-        struct path my_path = {
-                .dentry = dentry,
-        };
-        struct path *path = &my_path;
+        struct dentry *de = dentry;
         struct nfs4_state *state;
         struct rpc_cred *cred = NULL;
         fmode_t fmode = 0;
@@ -2645,11 +2643,11 @@ nfs4_proc_create(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
 
         if (ctx != NULL) {
                 cred = ctx->cred;
-                path = &ctx->path;
+                de = ctx->dentry;
                 fmode = ctx->mode;
         }
         sattr->ia_mode &= ~current_umask();
-        state = nfs4_do_open(dir, path, fmode, flags, sattr, cred);
+        state = nfs4_do_open(dir, de, fmode, flags, sattr, cred);
         d_drop(dentry);
         if (IS_ERR(state)) {
                 status = PTR_ERR(state);
@@ -2660,7 +2658,7 @@ nfs4_proc_create(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
         if (ctx != NULL)
                 ctx->state = state;
         else
-                nfs4_close_sync(path, state, fmode);
+                nfs4_close_sync(state, fmode);
 out:
         return status;
 }
@@ -4312,7 +4310,7 @@ static void nfs4_lock_done(struct rpc_task *task, void *calldata)
                 memcpy(data->lsp->ls_stateid.data, data->res.stateid.data,
                                         sizeof(data->lsp->ls_stateid.data));
                 data->lsp->ls_flags |= NFS_LOCK_INITIALIZED;
-                renew_lease(NFS_SERVER(data->ctx->path.dentry->d_inode), data->timestamp);
+                renew_lease(NFS_SERVER(data->ctx->dentry->d_inode), data->timestamp);
         }
 out:
         dprintk("%s: done, ret = %d!\n", __func__, data->rpc_status);
diff --git a/fs/nfs/nfs4state.c b/fs/nfs/nfs4state.c
index 5d744a52b4e1..72ab97ef3d61 100644
--- a/fs/nfs/nfs4state.c
+++ b/fs/nfs/nfs4state.c
@@ -641,7 +641,7 @@ void nfs4_put_open_state(struct nfs4_state *state)
 /*
  * Close the current file.
  */
-static void __nfs4_close(struct path *path, struct nfs4_state *state,
+static void __nfs4_close(struct nfs4_state *state,
                 fmode_t fmode, gfp_t gfp_mask, int wait)
 {
         struct nfs4_state_owner *owner = state->owner;
@@ -685,18 +685,18 @@ static void __nfs4_close(struct path *path, struct nfs4_state *state,
         } else {
                 bool roc = pnfs_roc(state->inode);
 
-                nfs4_do_close(path, state, gfp_mask, wait, roc);
+                nfs4_do_close(state, gfp_mask, wait, roc);
         }
 }
 
-void nfs4_close_state(struct path *path, struct nfs4_state *state, fmode_t fmode)
+void nfs4_close_state(struct nfs4_state *state, fmode_t fmode)
 {
-        __nfs4_close(path, state, fmode, GFP_NOFS, 0);
+        __nfs4_close(state, fmode, GFP_NOFS, 0);
 }
 
-void nfs4_close_sync(struct path *path, struct nfs4_state *state, fmode_t fmode)
+void nfs4_close_sync(struct nfs4_state *state, fmode_t fmode)
 {
-        __nfs4_close(path, state, fmode, GFP_KERNEL, 1);
+        __nfs4_close(state, fmode, GFP_KERNEL, 1);
 }
 
 /*
diff --git a/fs/nfs/pagelist.c b/fs/nfs/pagelist.c
index 7139dbf8784e..b60970cc7f1f 100644
--- a/fs/nfs/pagelist.c
+++ b/fs/nfs/pagelist.c
@@ -114,7 +114,7 @@ int nfs_set_page_tag_locked(struct nfs_page *req)
         if (!nfs_lock_request_dontget(req))
                 return 0;
         if (test_bit(PG_MAPPED, &req->wb_flags))
-                radix_tree_tag_set(&NFS_I(req->wb_context->path.dentry->d_inode)->nfs_page_tree, req->wb_index, NFS_PAGE_TAG_LOCKED);
+                radix_tree_tag_set(&NFS_I(req->wb_context->dentry->d_inode)->nfs_page_tree, req->wb_index, NFS_PAGE_TAG_LOCKED);
         return 1;
 }
 
@@ -124,7 +124,7 @@ int nfs_set_page_tag_locked(struct nfs_page *req)
 void nfs_clear_page_tag_locked(struct nfs_page *req)
 {
         if (test_bit(PG_MAPPED, &req->wb_flags)) {
-                struct inode *inode = req->wb_context->path.dentry->d_inode;
+                struct inode *inode = req->wb_context->dentry->d_inode;
                 struct nfs_inode *nfsi = NFS_I(inode);
 
                 spin_lock(&inode->i_lock);
diff --git a/fs/nfs/read.c b/fs/nfs/read.c
index 7cba2280e2b8..2171c043ab08 100644
--- a/fs/nfs/read.c
+++ b/fs/nfs/read.c
@@ -159,7 +159,7 @@ int nfs_readpage_async(struct nfs_open_context *ctx, struct inode *inode,
 
 static void nfs_readpage_release(struct nfs_page *req)
 {
-        struct inode *d_inode = req->wb_context->path.dentry->d_inode;
+        struct inode *d_inode = req->wb_context->dentry->d_inode;
 
         if (PageUptodate(req->wb_page))
                 nfs_readpage_to_fscache(d_inode, req->wb_page, 0);
@@ -167,8 +167,8 @@ static void nfs_readpage_release(struct nfs_page *req)
         unlock_page(req->wb_page);
 
         dprintk("NFS: read done (%s/%Ld %d@%Ld)\n",
-                        req->wb_context->path.dentry->d_inode->i_sb->s_id,
-                        (long long)NFS_FILEID(req->wb_context->path.dentry->d_inode),
+                        req->wb_context->dentry->d_inode->i_sb->s_id,
+                        (long long)NFS_FILEID(req->wb_context->dentry->d_inode),
                         req->wb_bytes,
                         (long long)req_offset(req));
         nfs_release_request(req);
@@ -220,7 +220,7 @@ EXPORT_SYMBOL_GPL(nfs_initiate_read);
 static void nfs_read_rpcsetup(struct nfs_page *req, struct nfs_read_data *data,
                 unsigned int count, unsigned int offset)
 {
-        struct inode *inode = req->wb_context->path.dentry->d_inode;
+        struct inode *inode = req->wb_context->dentry->d_inode;
 
         data->req         = req;
         data->inode       = inode;
@@ -243,7 +243,7 @@ static void nfs_read_rpcsetup(struct nfs_page *req, struct nfs_read_data *data,
 static int nfs_do_read(struct nfs_read_data *data,
                 const struct rpc_call_ops *call_ops)
 {
-        struct inode *inode = data->args.context->path.dentry->d_inode;
+        struct inode *inode = data->args.context->dentry->d_inode;
 
         return nfs_initiate_read(data, NFS_CLIENT(inode), call_ops);
 }
diff --git a/fs/nfs/super.c b/fs/nfs/super.c
index ce40e5c568ba..b961ceac66b4 100644
--- a/fs/nfs/super.c
+++ b/fs/nfs/super.c
@@ -2773,16 +2773,12 @@ static void nfs_referral_loop_unprotect(void)
 static struct dentry *nfs_follow_remote_path(struct vfsmount *root_mnt,
                 const char *export_path)
 {
-        struct nameidata *nd = NULL;
         struct mnt_namespace *ns_private;
         struct super_block *s;
         struct dentry *dentry;
+        struct path path;
         int ret;
 
-        nd = kmalloc(sizeof(*nd), GFP_KERNEL);
-        if (nd == NULL)
-                return ERR_PTR(-ENOMEM);
-
         ns_private = create_mnt_ns(root_mnt);
         ret = PTR_ERR(ns_private);
         if (IS_ERR(ns_private))
@@ -2793,7 +2789,7 @@ static struct dentry *nfs_follow_remote_path(struct vfsmount *root_mnt,
                 goto out_put_mnt_ns;
 
         ret = vfs_path_lookup(root_mnt->mnt_root, root_mnt,
-                        export_path, LOOKUP_FOLLOW, nd);
+                        export_path, LOOKUP_FOLLOW, &path);
 
         nfs_referral_loop_unprotect();
         put_mnt_ns(ns_private);
@@ -2801,12 +2797,11 @@ static struct dentry *nfs_follow_remote_path(struct vfsmount *root_mnt,
         if (ret != 0)
                 goto out_err;
 
-        s = nd->path.mnt->mnt_sb;
+        s = path.mnt->mnt_sb;
         atomic_inc(&s->s_active);
-        dentry = dget(nd->path.dentry);
+        dentry = dget(path.dentry);
 
-        path_put(&nd->path);
-        kfree(nd);
+        path_put(&path);
         down_write(&s->s_umount);
         return dentry;
 out_put_mnt_ns:
@@ -2814,7 +2809,6 @@ out_put_mnt_ns:
 out_mntput:
         mntput(root_mnt);
 out_err:
-        kfree(nd);
         return ERR_PTR(ret);
 }
 
diff --git a/fs/nfs/write.c b/fs/nfs/write.c
index 9fba5270b1a8..ebed5183f420 100644
--- a/fs/nfs/write.c
+++ b/fs/nfs/write.c
@@ -409,7 +409,7 @@ out:
  */
 static void nfs_inode_remove_request(struct nfs_page *req)
 {
-        struct inode *inode = req->wb_context->path.dentry->d_inode;
+        struct inode *inode = req->wb_context->dentry->d_inode;
         struct nfs_inode *nfsi = NFS_I(inode);
 
         BUG_ON (!NFS_WBACK_BUSY(req));
@@ -438,7 +438,7 @@ nfs_mark_request_dirty(struct nfs_page *req)
 static void
 nfs_mark_request_commit(struct nfs_page *req, struct pnfs_layout_segment *lseg)
 {
-        struct inode *inode = req->wb_context->path.dentry->d_inode;
+        struct inode *inode = req->wb_context->dentry->d_inode;
         struct nfs_inode *nfsi = NFS_I(inode);
 
         spin_lock(&inode->i_lock);
@@ -850,13 +850,13 @@ static void nfs_write_rpcsetup(struct nfs_page *req,
                 unsigned int count, unsigned int offset,
                 int how)
 {
-        struct inode *inode = req->wb_context->path.dentry->d_inode;
+        struct inode *inode = req->wb_context->dentry->d_inode;
 
         /* Set up the RPC argument and reply structs
          * NB: take care not to mess about with data->commit et al. */
 
         data->req = req;
-        data->inode = inode = req->wb_context->path.dentry->d_inode;
+        data->inode = inode = req->wb_context->dentry->d_inode;
         data->cred = req->wb_context->cred;
 
         data->args.fh     = NFS_FH(inode);
@@ -889,7 +889,7 @@ static int nfs_do_write(struct nfs_write_data *data,
                 const struct rpc_call_ops *call_ops,
                 int how)
 {
-        struct inode *inode = data->args.context->path.dentry->d_inode;
+        struct inode *inode = data->args.context->dentry->d_inode;
 
         return nfs_initiate_write(data, NFS_CLIENT(inode), call_ops, how);
 }
@@ -1081,9 +1081,9 @@ static void nfs_writeback_done_partial(struct rpc_task *task, void *calldata)
 
         dprintk("NFS: %5u write(%s/%lld %d@%lld)",
                 task->tk_pid,
-                data->req->wb_context->path.dentry->d_inode->i_sb->s_id,
+                data->req->wb_context->dentry->d_inode->i_sb->s_id,
                 (long long)
-                  NFS_FILEID(data->req->wb_context->path.dentry->d_inode),
+                  NFS_FILEID(data->req->wb_context->dentry->d_inode),
                 data->req->wb_bytes, (long long)req_offset(data->req));
 
         nfs_writeback_done(task, data);
@@ -1176,8 +1176,8 @@ static void nfs_writeback_release_full(void *calldata)
 
                 dprintk("NFS: %5u write (%s/%lld %d@%lld)",
                         data->task.tk_pid,
-                        req->wb_context->path.dentry->d_inode->i_sb->s_id,
-                        (long long)NFS_FILEID(req->wb_context->path.dentry->d_inode),
+                        req->wb_context->dentry->d_inode->i_sb->s_id,
+                        (long long)NFS_FILEID(req->wb_context->dentry->d_inode),
                         req->wb_bytes,
                         (long long)req_offset(req));
 
@@ -1375,7 +1375,7 @@ void nfs_init_commit(struct nfs_write_data *data,
                             struct pnfs_layout_segment *lseg)
 {
         struct nfs_page *first = nfs_list_entry(head->next);
-        struct inode *inode = first->wb_context->path.dentry->d_inode;
+        struct inode *inode = first->wb_context->dentry->d_inode;
 
         /* Set up the RPC argument and reply structs
          * NB: take care not to mess about with data->commit et al. */
@@ -1463,8 +1463,8 @@ void nfs_commit_release_pages(struct nfs_write_data *data)
                 nfs_clear_request_commit(req);
 
                 dprintk("NFS:       commit (%s/%lld %d@%lld)",
-                        req->wb_context->path.dentry->d_inode->i_sb->s_id,
-                        (long long)NFS_FILEID(req->wb_context->path.dentry->d_inode),
+                        req->wb_context->dentry->d_sb->s_id,
+                        (long long)NFS_FILEID(req->wb_context->dentry->d_inode),
                         req->wb_bytes,
                         (long long)req_offset(req));
                 if (status < 0) {