35 files changed, 515 insertions, 420 deletions

diff --git a/fs/nfs/Makefile b/fs/nfs/Makefile
index cce2c057bd2d..e0bb048e9576 100644
--- a/fs/nfs/Makefile
+++ b/fs/nfs/Makefile
@@ -6,8 +6,7 @@ obj-$(CONFIG_NFS_FS) += nfs.o
 
 nfs-y                   := client.o dir.o file.o getroot.o inode.o super.o \
                            direct.o pagelist.o read.o symlink.o unlink.o \
-                           write.o namespace.o mount_clnt.o \
-                           dns_resolve.o cache_lib.o
+                           write.o namespace.o mount_clnt.o
 nfs-$(CONFIG_ROOT_NFS)  += nfsroot.o
 nfs-$(CONFIG_SYSCTL)    += sysctl.o
 nfs-$(CONFIG_NFS_FSCACHE) += fscache.o fscache-index.o
@@ -22,7 +21,8 @@ nfsv3-$(CONFIG_NFS_V3_ACL) += nfs3acl.o
 obj-$(CONFIG_NFS_V4) += nfsv4.o
 nfsv4-y := nfs4proc.o nfs4xdr.o nfs4state.o nfs4renewd.o nfs4super.o nfs4file.o \
           delegation.o idmap.o callback.o callback_xdr.o callback_proc.o \
-          nfs4namespace.o nfs4getroot.o nfs4client.o
+          nfs4namespace.o nfs4getroot.o nfs4client.o dns_resolve.o
+nfsv4-$(CONFIG_NFS_USE_LEGACY_DNS) += cache_lib.o
 nfsv4-$(CONFIG_SYSCTL)  += nfs4sysctl.o
 nfsv4-$(CONFIG_NFS_V4_1)        += nfs4session.o pnfs.o pnfs_dev.o
 
diff --git a/fs/nfs/blocklayout/blocklayout.c b/fs/nfs/blocklayout/blocklayout.c
index 434b93ec0970..e242bbf72972 100644
--- a/fs/nfs/blocklayout/blocklayout.c
+++ b/fs/nfs/blocklayout/blocklayout.c
@@ -1089,9 +1089,10 @@ nfs4_blk_get_deviceinfo(struct nfs_server *server, const struct nfs_fh *fh,
         dev->pgbase = 0;
         dev->pglen = PAGE_SIZE * max_pages;
         dev->mincount = 0;
+        dev->maxcount = max_resp_sz - nfs41_maxgetdevinfo_overhead;
 
         dprintk("%s: dev_id: %s\n", __func__, dev->dev_id.data);
-        rc = nfs4_proc_getdeviceinfo(server, dev);
+        rc = nfs4_proc_getdeviceinfo(server, dev, NULL);
         dprintk("%s getdevice info returns %d\n", __func__, rc);
         if (rc) {
                 rv = ERR_PTR(rc);
diff --git a/fs/nfs/callback_proc.c b/fs/nfs/callback_proc.c
index 3d2af31e004c..e6ebc4c38c81 100644
--- a/fs/nfs/callback_proc.c
+++ b/fs/nfs/callback_proc.c
@@ -415,7 +415,7 @@ __be32 nfs4_callback_sequence(struct cb_sequenceargs *args,
 
         spin_lock(&tbl->slot_tbl_lock);
         /* state manager is resetting the session */
-        if (test_bit(NFS4_SESSION_DRAINING, &clp->cl_session->session_state)) {
+        if (test_bit(NFS4_SLOT_TBL_DRAINING, &tbl->slot_tbl_state)) {
                 spin_unlock(&tbl->slot_tbl_lock);
                 status = htonl(NFS4ERR_DELAY);
                 /* Return NFS4ERR_BADSESSION if we're draining the session
diff --git a/fs/nfs/callback_xdr.c b/fs/nfs/callback_xdr.c
index d450c21bc382..f4ccfe6521ec 100644
--- a/fs/nfs/callback_xdr.c
+++ b/fs/nfs/callback_xdr.c
@@ -763,7 +763,7 @@ static void nfs4_callback_free_slot(struct nfs4_session *session)
          * A single slot, so highest used slotid is either 0 or -1
          */
         tbl->highest_used_slotid = NFS4_NO_SLOT;
-        nfs4_session_drain_complete(session, tbl);
+        nfs4_slot_tbl_drain_complete(tbl);
         spin_unlock(&tbl->slot_tbl_lock);
 }
 
diff --git a/fs/nfs/client.c b/fs/nfs/client.c
index c426528deff4..340b1eff0267 100644
--- a/fs/nfs/client.c
+++ b/fs/nfs/client.c
@@ -753,8 +753,6 @@ static int nfs_init_server(struct nfs_server *server,
                         data->timeo, data->retrans);
         if (data->flags & NFS_MOUNT_NORESVPORT)
                 set_bit(NFS_CS_NORESVPORT, &cl_init.init_flags);
-        if (server->options & NFS_OPTION_MIGRATION)
-                set_bit(NFS_CS_MIGRATION, &cl_init.init_flags);
 
         /* Allocate or find a client reference we can use */
         clp = nfs_get_client(&cl_init, &timeparms, NULL, RPC_AUTH_UNIX);
diff --git a/fs/nfs/dir.c b/fs/nfs/dir.c
index 743d3b524fc5..c3f21888654f 100644
--- a/fs/nfs/dir.c
+++ b/fs/nfs/dir.c
@@ -1385,18 +1385,6 @@ static int nfs_finish_open(struct nfs_open_context *ctx,
 {
         int err;
 
-        if (ctx->dentry != dentry) {
-                dput(ctx->dentry);
-                ctx->dentry = dget(dentry);
-        }
-
-        /* If the open_intent is for execute, we have an extra check to make */
-        if (ctx->mode & FMODE_EXEC) {
-                err = nfs_may_open(dentry->d_inode, ctx->cred, open_flags);
-                if (err < 0)
-                        goto out;
-        }
-
         err = finish_open(file, dentry, do_open, opened);
         if (err)
                 goto out;
@@ -1455,13 +1443,13 @@ int nfs_atomic_open(struct inode *dir, struct dentry *dentry,
 
         nfs_block_sillyrename(dentry->d_parent);
         inode = NFS_PROTO(dir)->open_context(dir, ctx, open_flags, &attr);
-        d_drop(dentry);
+        nfs_unblock_sillyrename(dentry->d_parent);
         if (IS_ERR(inode)) {
-                nfs_unblock_sillyrename(dentry->d_parent);
                 put_nfs_open_context(ctx);
                 err = PTR_ERR(inode);
                 switch (err) {
                 case -ENOENT:
+                        d_drop(dentry);
                         d_add(dentry, NULL);
                         break;
                 case -EISDIR:
@@ -1477,16 +1465,8 @@ int nfs_atomic_open(struct inode *dir, struct dentry *dentry,
                 }
                 goto out;
         }
-        res = d_add_unique(dentry, inode);
-        if (res != NULL)
-                dentry = res;
-
-        nfs_unblock_sillyrename(dentry->d_parent);
-        nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
-
-        err = nfs_finish_open(ctx, dentry, file, open_flags, opened);
 
-        dput(res);
+        err = nfs_finish_open(ctx, ctx->dentry, file, open_flags, opened);
 out:
         return err;
 
diff --git a/fs/nfs/dns_resolve.c b/fs/nfs/dns_resolve.c
index 945527092295..fc0f95ec7358 100644
--- a/fs/nfs/dns_resolve.c
+++ b/fs/nfs/dns_resolve.c
@@ -29,7 +29,6 @@ ssize_t nfs_dns_resolve_name(struct net *net, char *name, size_t namelen,
         kfree(ip_addr);
         return ret;
 }
-EXPORT_SYMBOL_GPL(nfs_dns_resolve_name);
 
 #else
 
@@ -351,7 +350,6 @@ ssize_t nfs_dns_resolve_name(struct net *net, char *name,
                 ret = -ESRCH;
         return ret;
 }
-EXPORT_SYMBOL_GPL(nfs_dns_resolve_name);
 
 static struct cache_detail nfs_dns_resolve_template = {
         .owner          = THIS_MODULE,
@@ -396,6 +394,21 @@ void nfs_dns_resolver_cache_destroy(struct net *net)
         cache_destroy_net(nn->nfs_dns_resolve, net);
 }
 
+static int nfs4_dns_net_init(struct net *net)
+{
+        return nfs_dns_resolver_cache_init(net);
+}
+
+static void nfs4_dns_net_exit(struct net *net)
+{
+        nfs_dns_resolver_cache_destroy(net);
+}
+
+static struct pernet_operations nfs4_dns_resolver_ops = {
+        .init = nfs4_dns_net_init,
+        .exit = nfs4_dns_net_exit,
+};
+
 static int rpc_pipefs_event(struct notifier_block *nb, unsigned long event,
                            void *ptr)
 {
@@ -432,11 +445,24 @@ static struct notifier_block nfs_dns_resolver_block = {
 
 int nfs_dns_resolver_init(void)
 {
-        return rpc_pipefs_notifier_register(&nfs_dns_resolver_block);
+        int err;
+
+        err = register_pernet_subsys(&nfs4_dns_resolver_ops);
+        if (err < 0)
+                goto out;
+        err = rpc_pipefs_notifier_register(&nfs_dns_resolver_block);
+        if (err < 0)
+                goto out1;
+        return 0;
+out1:
+        unregister_pernet_subsys(&nfs4_dns_resolver_ops);
+out:
+        return err;
 }
 
 void nfs_dns_resolver_destroy(void)
 {
         rpc_pipefs_notifier_unregister(&nfs_dns_resolver_block);
+        unregister_pernet_subsys(&nfs4_dns_resolver_ops);
 }
 #endif
diff --git a/fs/nfs/idmap.c b/fs/nfs/idmap.c
index c516da5873fd..c2c4163d5683 100644
--- a/fs/nfs/idmap.c
+++ b/fs/nfs/idmap.c
@@ -262,29 +262,42 @@ static ssize_t nfs_idmap_get_desc(const char *name, size_t namelen,
         return desclen;
 }
 
-static ssize_t nfs_idmap_request_key(struct key_type *key_type,
-                                     const char *name, size_t namelen,
-                                     const char *type, void *data,
-                                     size_t data_size, struct idmap *idmap)
+static struct key *nfs_idmap_request_key(const char *name, size_t namelen,
+                                         const char *type, struct idmap *idmap)
 {
-        const struct cred *saved_cred;
-        struct key *rkey;
         char *desc;
-        struct user_key_payload *payload;
+        struct key *rkey;
         ssize_t ret;
 
         ret = nfs_idmap_get_desc(name, namelen, type, strlen(type), &desc);
         if (ret <= 0)
-                goto out;
+                return ERR_PTR(ret);
+
+        rkey = request_key(&key_type_id_resolver, desc, "");
+        if (IS_ERR(rkey)) {
+                mutex_lock(&idmap->idmap_mutex);
+                rkey = request_key_with_auxdata(&key_type_id_resolver_legacy,
+                                                desc, "", 0, idmap);
+                mutex_unlock(&idmap->idmap_mutex);
+        }
+
+        kfree(desc);
+        return rkey;
+}
+
+static ssize_t nfs_idmap_get_key(const char *name, size_t namelen,
+                                 const char *type, void *data,
+                                 size_t data_size, struct idmap *idmap)
+{
+        const struct cred *saved_cred;
+        struct key *rkey;
+        struct user_key_payload *payload;
+        ssize_t ret;
 
         saved_cred = override_creds(id_resolver_cache);
-        if (idmap)
-                rkey = request_key_with_auxdata(key_type, desc, "", 0, idmap);
-        else
-                rkey = request_key(&key_type_id_resolver, desc, "");
+        rkey = nfs_idmap_request_key(name, namelen, type, idmap);
         revert_creds(saved_cred);
 
-        kfree(desc);
         if (IS_ERR(rkey)) {
                 ret = PTR_ERR(rkey);
                 goto out;
@@ -316,23 +329,6 @@ out:
         return ret;
 }
 
-static ssize_t nfs_idmap_get_key(const char *name, size_t namelen,
-                                 const char *type, void *data,
-                                 size_t data_size, struct idmap *idmap)
-{
-        ssize_t ret = nfs_idmap_request_key(&key_type_id_resolver,
-                                            name, namelen, type, data,
-                                            data_size, NULL);
-        if (ret < 0) {
-                mutex_lock(&idmap->idmap_mutex);
-                ret = nfs_idmap_request_key(&key_type_id_resolver_legacy,
-                                            name, namelen, type, data,
-                                            data_size, idmap);
-                mutex_unlock(&idmap->idmap_mutex);
-        }
-        return ret;
-}
-
 /* ID -> Name */
 static ssize_t nfs_idmap_lookup_name(__u32 id, const char *type, char *buf,
                                      size_t buflen, struct idmap *idmap)
diff --git a/fs/nfs/inode.c b/fs/nfs/inode.c
index f908af672197..8ea62be3fefe 100644
--- a/fs/nfs/inode.c
+++ b/fs/nfs/inode.c
@@ -48,7 +48,6 @@
 #include "iostat.h"
 #include "internal.h"
 #include "fscache.h"
-#include "dns_resolve.h"
 #include "pnfs.h"
 #include "nfs.h"
 #include "netns.h"
@@ -785,16 +784,23 @@ EXPORT_SYMBOL_GPL(put_nfs_open_context);
  * Ensure that mmap has a recent RPC credential for use when writing out
  * shared pages
  */
-void nfs_file_set_open_context(struct file *filp, struct nfs_open_context *ctx)
+void nfs_inode_attach_open_context(struct nfs_open_context *ctx)
 {
-        struct inode *inode = file_inode(filp);
+        struct inode *inode = ctx->dentry->d_inode;
         struct nfs_inode *nfsi = NFS_I(inode);
 
-        filp->private_data = get_nfs_open_context(ctx);
         spin_lock(&inode->i_lock);
         list_add(&ctx->list, &nfsi->open_files);
         spin_unlock(&inode->i_lock);
 }
+EXPORT_SYMBOL_GPL(nfs_inode_attach_open_context);
+
+void nfs_file_set_open_context(struct file *filp, struct nfs_open_context *ctx)
+{
+        filp->private_data = get_nfs_open_context(ctx);
+        if (list_empty(&ctx->list))
+                nfs_inode_attach_open_context(ctx);
+}
 EXPORT_SYMBOL_GPL(nfs_file_set_open_context);
 
 /*
@@ -820,10 +826,11 @@ struct nfs_open_context *nfs_find_open_context(struct inode *inode, struct rpc_c
 
 static void nfs_file_clear_open_context(struct file *filp)
 {
-        struct inode *inode = file_inode(filp);
         struct nfs_open_context *ctx = nfs_file_open_context(filp);
 
         if (ctx) {
+                struct inode *inode = ctx->dentry->d_inode;
+
                 filp->private_data = NULL;
                 spin_lock(&inode->i_lock);
                 list_move_tail(&ctx->list, &NFS_I(inode)->open_files);
@@ -1723,12 +1730,11 @@ EXPORT_SYMBOL_GPL(nfs_net_id);
 static int nfs_net_init(struct net *net)
 {
         nfs_clients_init(net);
-        return nfs_dns_resolver_cache_init(net);
+        return 0;
 }
 
 static void nfs_net_exit(struct net *net)
 {
-        nfs_dns_resolver_cache_destroy(net);
         nfs_cleanup_cb_ident_idr(net);
 }
 
@@ -1746,10 +1752,6 @@ static int __init init_nfs_fs(void)
 {
         int err;
 
-        err = nfs_dns_resolver_init();
-        if (err < 0)
-                goto out10;;
-
         err = register_pernet_subsys(&nfs_net_ops);
         if (err < 0)
                 goto out9;
@@ -1815,8 +1817,6 @@ out7:
 out8:
         unregister_pernet_subsys(&nfs_net_ops);
 out9:
-        nfs_dns_resolver_destroy();
-out10:
         return err;
 }
 
@@ -1829,7 +1829,6 @@ static void __exit exit_nfs_fs(void)
         nfs_destroy_nfspagecache();
         nfs_fscache_unregister();
         unregister_pernet_subsys(&nfs_net_ops);
-        nfs_dns_resolver_destroy();
 #ifdef CONFIG_PROC_FS
         rpc_proc_unregister(&init_net, "nfs");
 #endif
diff --git a/fs/nfs/internal.h b/fs/nfs/internal.h
index 97ec2ef6a220..3c8373f90ab3 100644
--- a/fs/nfs/internal.h
+++ b/fs/nfs/internal.h
@@ -255,6 +255,7 @@ extern int nfs4_decode_dirent(struct xdr_stream *,
 #ifdef CONFIG_NFS_V4_1
 extern const u32 nfs41_maxread_overhead;
 extern const u32 nfs41_maxwrite_overhead;
+extern const u32 nfs41_maxgetdevinfo_overhead;
 #endif
 
 /* nfs4proc.c */
diff --git a/fs/nfs/mount_clnt.c b/fs/nfs/mount_clnt.c
index 91a6faf811ac..99a45283b9ee 100644
--- a/fs/nfs/mount_clnt.c
+++ b/fs/nfs/mount_clnt.c
@@ -139,7 +139,10 @@ struct mnt_fhstatus {
  * nfs_mount - Obtain an NFS file handle for the given host and path
  * @info: pointer to mount request arguments
  *
- * Uses default timeout parameters specified by underlying transport.
+ * Uses default timeout parameters specified by underlying transport. On
+ * successful return, the auth_flavs list and auth_flav_len will be populated
+ * with the list from the server or a faked-up list if the server didn't
+ * provide one.
  */
 int nfs_mount(struct nfs_mount_request *info)
 {
@@ -195,6 +198,15 @@ int nfs_mount(struct nfs_mount_request *info)
         dprintk("NFS: MNT request succeeded\n");
         status = 0;
 
+        /*
+         * If the server didn't provide a flavor list, allow the
+         * client to try any flavor.
+         */
+        if (info->version != NFS_MNT3_VERSION || *info->auth_flav_len == 0) {
+                dprintk("NFS: Faking up auth_flavs list\n");
+                info->auth_flavs[0] = RPC_AUTH_NULL;
+                *info->auth_flav_len = 1;
+        }
 out:
         return status;
 
diff --git a/fs/nfs/nfs4_fs.h b/fs/nfs/nfs4_fs.h
index 283fd284bdb8..ee81e354bce7 100644
--- a/fs/nfs/nfs4_fs.h
+++ b/fs/nfs/nfs4_fs.h
@@ -194,7 +194,7 @@ struct nfs4_state_recovery_ops {
         int (*recover_lock)(struct nfs4_state *, struct file_lock *);
         int (*establish_clid)(struct nfs_client *, struct rpc_cred *);
         struct rpc_cred * (*get_clid_cred)(struct nfs_client *);
-        int (*reclaim_complete)(struct nfs_client *);
+        int (*reclaim_complete)(struct nfs_client *, struct rpc_cred *);
         int (*detect_trunking)(struct nfs_client *, struct nfs_client **,
                 struct rpc_cred *);
 };
diff --git a/fs/nfs/nfs4client.c b/fs/nfs/nfs4client.c
index 18191919cc0b..90dce91dd5b5 100644
--- a/fs/nfs/nfs4client.c
+++ b/fs/nfs/nfs4client.c
@@ -208,7 +208,7 @@ struct nfs_client *nfs4_init_client(struct nfs_client *clp,
         __set_bit(NFS_CS_DISCRTRY, &clp->cl_flags);
         error = nfs_create_rpc_client(clp, timeparms, RPC_AUTH_GSS_KRB5I);
         if (error == -EINVAL)
-                error = nfs_create_rpc_client(clp, timeparms, RPC_AUTH_NULL);
+                error = nfs_create_rpc_client(clp, timeparms, RPC_AUTH_UNIX);
         if (error < 0)
                 goto error;
 
@@ -631,6 +631,8 @@ static int nfs4_set_client(struct nfs_server *server,
 
         if (server->flags & NFS_MOUNT_NORESVPORT)
                 set_bit(NFS_CS_NORESVPORT, &cl_init.init_flags);
+        if (server->options & NFS_OPTION_MIGRATION)
+                set_bit(NFS_CS_MIGRATION, &cl_init.init_flags);
 
         /* Allocate or find a client reference we can use */
         clp = nfs_get_client(&cl_init, timeparms, ip_addr, authflavour);
@@ -735,7 +737,7 @@ static int nfs4_server_common_setup(struct nfs_server *server,
                 return -ENOMEM;
 
         /* We must ensure the session is initialised first */
-        error = nfs4_init_session(server);
+        error = nfs4_init_session(server->nfs_client);
         if (error < 0)
                 goto out;
 
diff --git a/fs/nfs/nfs4file.c b/fs/nfs/nfs4file.c
index 13e6bb3e3fe5..e5b804dd944c 100644
--- a/fs/nfs/nfs4file.c
+++ b/fs/nfs/nfs4file.c
@@ -69,7 +69,6 @@ nfs4_file_open(struct inode *inode, struct file *filp)
                         goto out_drop;
                 }
         }
-        iput(inode);
         if (inode != dentry->d_inode)
                 goto out_drop;
 
diff --git a/fs/nfs/nfs4filelayout.c b/fs/nfs/nfs4filelayout.c
index 22d10623f5ee..17ed87ef9de8 100644
--- a/fs/nfs/nfs4filelayout.c
+++ b/fs/nfs/nfs4filelayout.c
@@ -643,7 +643,8 @@ filelayout_check_layout(struct pnfs_layout_hdr *lo,
         d = nfs4_find_get_deviceid(NFS_SERVER(lo->plh_inode)->pnfs_curr_ld,
                                    NFS_SERVER(lo->plh_inode)->nfs_client, id);
         if (d == NULL) {
-                dsaddr = filelayout_get_device_info(lo->plh_inode, id, gfp_flags);
+                dsaddr = filelayout_get_device_info(lo->plh_inode, id,
+                                lo->plh_lc_cred, gfp_flags);
                 if (dsaddr == NULL)
                         goto out;
         } else
diff --git a/fs/nfs/nfs4filelayout.h b/fs/nfs/nfs4filelayout.h
index 235ff952d3c8..cebd20e7e923 100644
--- a/fs/nfs/nfs4filelayout.h
+++ b/fs/nfs/nfs4filelayout.h
@@ -150,6 +150,7 @@ struct nfs4_pnfs_ds *nfs4_fl_prepare_ds(struct pnfs_layout_segment *lseg,
 extern void nfs4_fl_put_deviceid(struct nfs4_file_layout_dsaddr *dsaddr);
 extern void nfs4_fl_free_deviceid(struct nfs4_file_layout_dsaddr *dsaddr);
 struct nfs4_file_layout_dsaddr *
-filelayout_get_device_info(struct inode *inode, struct nfs4_deviceid *dev_id, gfp_t gfp_flags);
+filelayout_get_device_info(struct inode *inode, struct nfs4_deviceid *dev_id,
+                struct rpc_cred *cred, gfp_t gfp_flags);
 
 #endif /* FS_NFS_NFS4FILELAYOUT_H */
diff --git a/fs/nfs/nfs4filelayoutdev.c b/fs/nfs/nfs4filelayoutdev.c
index 661a0f611215..95604f64cab8 100644
--- a/fs/nfs/nfs4filelayoutdev.c
+++ b/fs/nfs/nfs4filelayoutdev.c
@@ -668,7 +668,10 @@ decode_and_add_device(struct inode *inode, struct pnfs_device *dev, gfp_t gfp_fl
  * of available devices, and return it.
  */
 struct nfs4_file_layout_dsaddr *
-filelayout_get_device_info(struct inode *inode, struct nfs4_deviceid *dev_id, gfp_t gfp_flags)
+filelayout_get_device_info(struct inode *inode,
+                struct nfs4_deviceid *dev_id,
+                struct rpc_cred *cred,
+                gfp_t gfp_flags)
 {
         struct pnfs_device *pdev = NULL;
         u32 max_resp_sz;
@@ -708,8 +711,9 @@ filelayout_get_device_info(struct inode *inode, struct nfs4_deviceid *dev_id, gf
         pdev->pgbase = 0;
         pdev->pglen = max_resp_sz;
         pdev->mincount = 0;
+        pdev->maxcount = max_resp_sz - nfs41_maxgetdevinfo_overhead;
 
-        rc = nfs4_proc_getdeviceinfo(server, pdev);
+        rc = nfs4_proc_getdeviceinfo(server, pdev, cred);
         dprintk("%s getdevice info returns %d\n", __func__, rc);
         if (rc)
                 goto out_free;
diff --git a/fs/nfs/nfs4proc.c b/fs/nfs/nfs4proc.c
index c0d3123b6eba..d95616f140ad 100644
--- a/fs/nfs/nfs4proc.c
+++ b/fs/nfs/nfs4proc.c
@@ -84,8 +84,10 @@ static int nfs4_do_setattr(struct inode *inode, struct rpc_cred *cred,
                             struct nfs4_state *state, struct nfs4_label *ilabel,
                             struct nfs4_label *olabel);
 #ifdef CONFIG_NFS_V4_1
-static int nfs41_test_stateid(struct nfs_server *, nfs4_stateid *);
-static int nfs41_free_stateid(struct nfs_server *, nfs4_stateid *);
+static int nfs41_test_stateid(struct nfs_server *, nfs4_stateid *,
+                struct rpc_cred *);
+static int nfs41_free_stateid(struct nfs_server *, nfs4_stateid *,
+                struct rpc_cred *);
 #endif
 
 #ifdef CONFIG_NFS_V4_SECURITY_LABEL
@@ -626,7 +628,7 @@ int nfs41_setup_sequence(struct nfs4_session *session,
         task->tk_timeout = 0;
 
         spin_lock(&tbl->slot_tbl_lock);
-        if (test_bit(NFS4_SESSION_DRAINING, &session->session_state) &&
+        if (test_bit(NFS4_SLOT_TBL_DRAINING, &tbl->slot_tbl_state) &&
             !args->sa_privileged) {
                 /* The state manager will wait until the slot table is empty */
                 dprintk("%s session is draining\n", __func__);
@@ -1147,7 +1149,7 @@ static struct nfs4_state *nfs4_try_open_cached(struct nfs4_opendata *opendata)
         struct nfs4_state *state = opendata->state;
         struct nfs_inode *nfsi = NFS_I(state->inode);
         struct nfs_delegation *delegation;
-        int open_mode = opendata->o_arg.open_flags & (O_EXCL|O_TRUNC);
+        int open_mode = opendata->o_arg.open_flags;
         fmode_t fmode = opendata->o_arg.fmode;
         nfs4_stateid stateid;
         int ret = -EAGAIN;
@@ -1926,18 +1928,30 @@ static void nfs41_clear_delegation_stateid(struct nfs4_state *state)
 {
         struct nfs_server *server = NFS_SERVER(state->inode);
         nfs4_stateid *stateid = &state->stateid;
-        int status;
+        struct nfs_delegation *delegation;
+        struct rpc_cred *cred = NULL;
+        int status = -NFS4ERR_BAD_STATEID;
 
         /* If a state reset has been done, test_stateid is unneeded */
         if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0)
                 return;
 
-        status = nfs41_test_stateid(server, stateid);
+        /* Get the delegation credential for use by test/free_stateid */
+        rcu_read_lock();
+        delegation = rcu_dereference(NFS_I(state->inode)->delegation);
+        if (delegation != NULL &&
+            nfs4_stateid_match(&delegation->stateid, stateid)) {
+                cred = get_rpccred(delegation->cred);
+                rcu_read_unlock();
+                status = nfs41_test_stateid(server, stateid, cred);
+        } else
+                rcu_read_unlock();
+
         if (status != NFS_OK) {
                 /* Free the stateid unless the server explicitly
                  * informs us the stateid is unrecognized. */
                 if (status != -NFS4ERR_BAD_STATEID)
-                        nfs41_free_stateid(server, stateid);
+                        nfs41_free_stateid(server, stateid, cred);
                 nfs_remove_bad_delegation(state->inode);
 
                 write_seqlock(&state->seqlock);
@@ -1945,6 +1959,9 @@ static void nfs41_clear_delegation_stateid(struct nfs4_state *state)
                 write_sequnlock(&state->seqlock);
                 clear_bit(NFS_DELEGATED_STATE, &state->flags);
         }
+
+        if (cred != NULL)
+                put_rpccred(cred);
 }
 
 /**
@@ -1959,6 +1976,7 @@ static int nfs41_check_open_stateid(struct nfs4_state *state)
 {
         struct nfs_server *server = NFS_SERVER(state->inode);
         nfs4_stateid *stateid = &state->open_stateid;
+        struct rpc_cred *cred = state->owner->so_cred;
         int status;
 
         /* If a state reset has been done, test_stateid is unneeded */
@@ -1967,12 +1985,12 @@ static int nfs41_check_open_stateid(struct nfs4_state *state)
             (test_bit(NFS_O_RDWR_STATE, &state->flags) == 0))
                 return -NFS4ERR_BAD_STATEID;
 
-        status = nfs41_test_stateid(server, stateid);
+        status = nfs41_test_stateid(server, stateid, cred);
         if (status != NFS_OK) {
                 /* Free the stateid unless the server explicitly
                  * informs us the stateid is unrecognized. */
                 if (status != -NFS4ERR_BAD_STATEID)
-                        nfs41_free_stateid(server, stateid);
+                        nfs41_free_stateid(server, stateid, cred);
 
                 clear_bit(NFS_O_RDONLY_STATE, &state->flags);
                 clear_bit(NFS_O_WRONLY_STATE, &state->flags);
@@ -2013,10 +2031,11 @@ static inline void nfs4_exclusive_attrset(struct nfs4_opendata *opendata, struct
 static int _nfs4_open_and_get_state(struct nfs4_opendata *opendata,
                 fmode_t fmode,
                 int flags,
-                struct nfs4_state **res)
+                struct nfs_open_context *ctx)
 {
         struct nfs4_state_owner *sp = opendata->owner;
         struct nfs_server *server = sp->so_server;
+        struct dentry *dentry;
         struct nfs4_state *state;
         unsigned int seq;
         int ret;
@@ -2034,13 +2053,31 @@ static int _nfs4_open_and_get_state(struct nfs4_opendata *opendata,
         if (server->caps & NFS_CAP_POSIX_LOCK)
                 set_bit(NFS_STATE_POSIX_LOCKS, &state->flags);
 
+        dentry = opendata->dentry;
+        if (dentry->d_inode == NULL) {
+                /* FIXME: Is this d_drop() ever needed? */
+                d_drop(dentry);
+                dentry = d_add_unique(dentry, igrab(state->inode));
+                if (dentry == NULL) {
+                        dentry = opendata->dentry;
+                } else if (dentry != ctx->dentry) {
+                        dput(ctx->dentry);
+                        ctx->dentry = dget(dentry);
+                }
+                nfs_set_verifier(dentry,
+                                nfs_save_change_attribute(opendata->dir->d_inode));
+        }
+
         ret = nfs4_opendata_access(sp->so_cred, opendata, state, fmode, flags);
         if (ret != 0)
                 goto out;
 
-        if (read_seqcount_retry(&sp->so_reclaim_seqcount, seq))
-                nfs4_schedule_stateid_recovery(server, state);
-        *res = state;
+        ctx->state = state;
+        if (dentry->d_inode == state->inode) {
+                nfs_inode_attach_open_context(ctx);
+                if (read_seqcount_retry(&sp->so_reclaim_seqcount, seq))
+                        nfs4_schedule_stateid_recovery(server, state);
+        }
 out:
         return ret;
 }
@@ -2049,19 +2086,19 @@ out:
  * Returns a referenced nfs4_state
  */
 static int _nfs4_do_open(struct inode *dir,
-                        struct dentry *dentry,
-                        fmode_t fmode,
+                        struct nfs_open_context *ctx,
                         int flags,
                         struct iattr *sattr,
-                        struct nfs4_label *label,
-                        struct rpc_cred *cred,
-                        struct nfs4_state **res,
-                        struct nfs4_threshold **ctx_th)
+                        struct nfs4_label *label)
 {
         struct nfs4_state_owner  *sp;
         struct nfs4_state     *state = NULL;
         struct nfs_server       *server = NFS_SERVER(dir);
         struct nfs4_opendata *opendata;
+        struct dentry *dentry = ctx->dentry;
+        struct rpc_cred *cred = ctx->cred;
+        struct nfs4_threshold **ctx_th = &ctx->mdsthreshold;
+        fmode_t fmode = ctx->mode & (FMODE_READ|FMODE_WRITE|FMODE_EXEC);
         enum open_claim_type4 claim = NFS4_OPEN_CLAIM_NULL;
         struct nfs4_label *olabel = NULL;
         int status;
@@ -2103,9 +2140,10 @@ static int _nfs4_do_open(struct inode *dir,
         if (dentry->d_inode != NULL)
                 opendata->state = nfs4_get_open_state(dentry->d_inode, sp);
 
-        status = _nfs4_open_and_get_state(opendata, fmode, flags, &state);
+        status = _nfs4_open_and_get_state(opendata, fmode, flags, ctx);
         if (status != 0)
                 goto err_free_label;
+        state = ctx->state;
 
         if ((opendata->o_arg.open_flags & O_EXCL) &&
             (opendata->o_arg.createmode != NFS4_CREATE_GUARDED)) {
@@ -2132,7 +2170,6 @@ static int _nfs4_do_open(struct inode *dir,
 
         nfs4_opendata_put(opendata);
         nfs4_put_state_owner(sp);
-        *res = state;
         return 0;
 err_free_label:
         nfs4_label_free(olabel);
@@ -2142,29 +2179,24 @@ err_opendata_put:
 err_put_state_owner:
         nfs4_put_state_owner(sp);
 out_err:
-        *res = NULL;
         return status;
 }
 
 
 static struct nfs4_state *nfs4_do_open(struct inode *dir,
-                                        struct dentry *dentry,
-                                        fmode_t fmode,
+                                        struct nfs_open_context *ctx,
                                         int flags,
                                         struct iattr *sattr,
-                                        struct nfs4_label *label,
-                                        struct rpc_cred *cred,
-                                        struct nfs4_threshold **ctx_th)
+                                        struct nfs4_label *label)
 {
         struct nfs_server *server = NFS_SERVER(dir);
         struct nfs4_exception exception = { };
         struct nfs4_state *res;
         int status;
 
-        fmode &= FMODE_READ|FMODE_WRITE|FMODE_EXEC;
         do {
-                status = _nfs4_do_open(dir, dentry, fmode, flags, sattr, label, cred,
-                                       &res, ctx_th);
+                status = _nfs4_do_open(dir, ctx, flags, sattr, label);
+                res = ctx->state;
                 if (status == 0)
                         break;
                 /* NOTE: BAD_SEQID means the server and client disagree about the
@@ -2527,15 +2559,13 @@ nfs4_atomic_open(struct inode *dir, struct nfs_open_context *ctx, int open_flags
         label = nfs4_label_init_security(dir, ctx->dentry, attr, &l);
 
         /* Protect against concurrent sillydeletes */
-        state = nfs4_do_open(dir, ctx->dentry, ctx->mode, open_flags, attr, label,
-                             ctx->cred, &ctx->mdsthreshold);
+        state = nfs4_do_open(dir, ctx, open_flags, attr, label);
 
         nfs4_label_release_security(label);
 
         if (IS_ERR(state))
                 return ERR_CAST(state);
-        ctx->state = state;
-        return igrab(state->inode);
+        return state->inode;
 }
 
 static void nfs4_close_context(struct nfs_open_context *ctx, int is_sync)
@@ -3186,17 +3216,11 @@ nfs4_proc_create(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
         ilabel = nfs4_label_init_security(dir, dentry, sattr, &l);
 
         sattr->ia_mode &= ~current_umask();
-        state = nfs4_do_open(dir, dentry, ctx->mode,
-                        flags, sattr, ilabel, ctx->cred,
-                        &ctx->mdsthreshold);
-        d_drop(dentry);
+        state = nfs4_do_open(dir, ctx, flags, sattr, ilabel);
         if (IS_ERR(state)) {
                 status = PTR_ERR(state);
                 goto out;
         }
-        d_add(dentry, igrab(state->inode));
-        nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
-        ctx->state = state;
 out:
         nfs4_label_release_security(ilabel);
         put_nfs_open_context(ctx);
@@ -4690,7 +4714,7 @@ int nfs4_proc_setclientid(struct nfs_client *clp, u32 program,
         /* cb_client4 */
         rcu_read_lock();
         setclientid.sc_netid_len = scnprintf(setclientid.sc_netid,
-                                sizeof(setclientid.sc_netid),
+                                sizeof(setclientid.sc_netid), "%s",
                                 rpc_peeraddr2str(clp->cl_rpcclient,
                                                         RPC_DISPLAY_NETID));
         rcu_read_unlock();
@@ -5401,13 +5425,18 @@ static int nfs41_check_expired_locks(struct nfs4_state *state)
 
         list_for_each_entry(lsp, &state->lock_states, ls_locks) {
                 if (test_bit(NFS_LOCK_INITIALIZED, &lsp->ls_flags)) {
-                        status = nfs41_test_stateid(server, &lsp->ls_stateid);
+                        struct rpc_cred *cred = lsp->ls_state->owner->so_cred;
+
+                        status = nfs41_test_stateid(server,
+                                        &lsp->ls_stateid,
+                                        cred);
                         if (status != NFS_OK) {
                                 /* Free the stateid unless the server
                                  * informs us the stateid is unrecognized. */
                                 if (status != -NFS4ERR_BAD_STATEID)
                                         nfs41_free_stateid(server,
-                                                        &lsp->ls_stateid);
+                                                        &lsp->ls_stateid,
+                                                        cred);
                                 clear_bit(NFS_LOCK_INITIALIZED, &lsp->ls_flags);
                                 ret = status;
                         }
@@ -5897,7 +5926,8 @@ int nfs4_proc_exchange_id(struct nfs_client *clp, struct rpc_cred *cred)
         struct nfs41_exchange_id_args args = {
                 .verifier = &verifier,
                 .client = clp,
-                .flags = EXCHGID4_FLAG_SUPP_MOVED_REFER,
+                .flags = EXCHGID4_FLAG_SUPP_MOVED_REFER |
+                        EXCHGID4_FLAG_BIND_PRINC_STATEID,
         };
         struct nfs41_exchange_id_res res = {
                 0
@@ -6154,17 +6184,14 @@ int nfs4_proc_get_lease_time(struct nfs_client *clp, struct nfs_fsinfo *fsinfo)
  */
 static void nfs4_init_channel_attrs(struct nfs41_create_session_args *args)
 {
-        struct nfs4_session *session = args->client->cl_session;
-        unsigned int mxrqst_sz = session->fc_target_max_rqst_sz,
-                     mxresp_sz = session->fc_target_max_resp_sz;
+        unsigned int max_rqst_sz, max_resp_sz;
+
+        max_rqst_sz = NFS_MAX_FILE_IO_SIZE + nfs41_maxwrite_overhead;
+        max_resp_sz = NFS_MAX_FILE_IO_SIZE + nfs41_maxread_overhead;
 
-        if (mxrqst_sz == 0)
-                mxrqst_sz = NFS_MAX_FILE_IO_SIZE;
-        if (mxresp_sz == 0)
-                mxresp_sz = NFS_MAX_FILE_IO_SIZE;
         /* Fore channel attributes */
-        args->fc_attrs.max_rqst_sz = mxrqst_sz;
-        args->fc_attrs.max_resp_sz = mxresp_sz;
+        args->fc_attrs.max_rqst_sz = max_rqst_sz;
+        args->fc_attrs.max_resp_sz = max_resp_sz;
         args->fc_attrs.max_ops = NFS4_MAX_OPS;
         args->fc_attrs.max_reqs = max_session_slots;
 
@@ -6551,12 +6578,14 @@ static const struct rpc_call_ops nfs4_reclaim_complete_call_ops = {
 /*
  * Issue a global reclaim complete.
  */
-static int nfs41_proc_reclaim_complete(struct nfs_client *clp)
+static int nfs41_proc_reclaim_complete(struct nfs_client *clp,
+                struct rpc_cred *cred)
 {
         struct nfs4_reclaim_complete_data *calldata;
         struct rpc_task *task;
         struct rpc_message msg = {
                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_RECLAIM_COMPLETE],
+                .rpc_cred = cred,
         };
         struct rpc_task_setup task_setup_data = {
                 .rpc_client = clp->cl_rpcclient,
@@ -6740,6 +6769,7 @@ nfs4_proc_layoutget(struct nfs4_layoutget *lgp, gfp_t gfp_flags)
                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LAYOUTGET],
                 .rpc_argp = &lgp->args,
                 .rpc_resp = &lgp->res,
+                .rpc_cred = lgp->cred,
         };
         struct rpc_task_setup task_setup_data = {
                 .rpc_client = server->client,
@@ -6843,6 +6873,7 @@ int nfs4_proc_layoutreturn(struct nfs4_layoutreturn *lrp)
                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LAYOUTRETURN],
                 .rpc_argp = &lrp->args,
                 .rpc_resp = &lrp->res,
+                .rpc_cred = lrp->cred,
         };
         struct rpc_task_setup task_setup_data = {
                 .rpc_client = lrp->clp->cl_rpcclient,
@@ -6912,7 +6943,9 @@ int nfs4_proc_getdevicelist(struct nfs_server *server,
 EXPORT_SYMBOL_GPL(nfs4_proc_getdevicelist);
 
 static int
-_nfs4_proc_getdeviceinfo(struct nfs_server *server, struct pnfs_device *pdev)
+_nfs4_proc_getdeviceinfo(struct nfs_server *server,
+                struct pnfs_device *pdev,
+                struct rpc_cred *cred)
 {
         struct nfs4_getdeviceinfo_args args = {
                 .pdev = pdev,
@@ -6924,6 +6957,7 @@ _nfs4_proc_getdeviceinfo(struct nfs_server *server, struct pnfs_device *pdev)
                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_GETDEVICEINFO],
                 .rpc_argp = &args,
                 .rpc_resp = &res,
+                .rpc_cred = cred,
         };
         int status;
 
@@ -6934,14 +6968,16 @@ _nfs4_proc_getdeviceinfo(struct nfs_server *server, struct pnfs_device *pdev)
         return status;
 }
 
-int nfs4_proc_getdeviceinfo(struct nfs_server *server, struct pnfs_device *pdev)
+int nfs4_proc_getdeviceinfo(struct nfs_server *server,
+                struct pnfs_device *pdev,
+                struct rpc_cred *cred)
 {
         struct nfs4_exception exception = { };
         int err;
 
         do {
                 err = nfs4_handle_exception(server,
-                                        _nfs4_proc_getdeviceinfo(server, pdev),
+                                        _nfs4_proc_getdeviceinfo(server, pdev, cred),
                                         &exception);
         } while (exception.retry);
         return err;
@@ -7125,7 +7161,9 @@ out:
         return err;
 }
 
-static int _nfs41_test_stateid(struct nfs_server *server, nfs4_stateid *stateid)
+static int _nfs41_test_stateid(struct nfs_server *server,
+                nfs4_stateid *stateid,
+                struct rpc_cred *cred)
 {
         int status;
         struct nfs41_test_stateid_args args = {
@@ -7136,6 +7174,7 @@ static int _nfs41_test_stateid(struct nfs_server *server, nfs4_stateid *stateid)
                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_TEST_STATEID],
                 .rpc_argp = &args,
                 .rpc_resp = &res,
+                .rpc_cred = cred,
         };
 
         dprintk("NFS call  test_stateid %p\n", stateid);
@@ -7156,17 +7195,20 @@ static int _nfs41_test_stateid(struct nfs_server *server, nfs4_stateid *stateid)
  *
  * @server: server / transport on which to perform the operation
  * @stateid: state ID to test
+ * @cred: credential
  *
  * Returns NFS_OK if the server recognizes that "stateid" is valid.
  * Otherwise a negative NFS4ERR value is returned if the operation
  * failed or the state ID is not currently valid.
  */
-static int nfs41_test_stateid(struct nfs_server *server, nfs4_stateid *stateid)
+static int nfs41_test_stateid(struct nfs_server *server,
+                nfs4_stateid *stateid,
+                struct rpc_cred *cred)
 {
         struct nfs4_exception exception = { };
         int err;
         do {
-                err = _nfs41_test_stateid(server, stateid);
+                err = _nfs41_test_stateid(server, stateid, cred);
                 if (err != -NFS4ERR_DELAY)
                         break;
                 nfs4_handle_exception(server, err, &exception);
@@ -7215,10 +7257,12 @@ const struct rpc_call_ops nfs41_free_stateid_ops = {
 
 static struct rpc_task *_nfs41_free_stateid(struct nfs_server *server,
                 nfs4_stateid *stateid,
+                struct rpc_cred *cred,
                 bool privileged)
 {
         struct rpc_message msg = {
                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_FREE_STATEID],
+                .rpc_cred = cred,
         };
         struct rpc_task_setup task_setup = {
                 .rpc_client = server->client,
@@ -7251,16 +7295,19 @@ static struct rpc_task *_nfs41_free_stateid(struct nfs_server *server,
  *
  * @server: server / transport on which to perform the operation
  * @stateid: state ID to release
+ * @cred: credential
  *
  * Returns NFS_OK if the server freed "stateid".  Otherwise a
  * negative NFS4ERR value is returned.
  */
-static int nfs41_free_stateid(struct nfs_server *server, nfs4_stateid *stateid)
+static int nfs41_free_stateid(struct nfs_server *server,
+                nfs4_stateid *stateid,
+                struct rpc_cred *cred)
 {
         struct rpc_task *task;
         int ret;
 
-        task = _nfs41_free_stateid(server, stateid, true);
+        task = _nfs41_free_stateid(server, stateid, cred, true);
         if (IS_ERR(task))
                 return PTR_ERR(task);
         ret = rpc_wait_for_completion_task(task);
@@ -7273,8 +7320,9 @@ static int nfs41_free_stateid(struct nfs_server *server, nfs4_stateid *stateid)
 static int nfs41_free_lock_state(struct nfs_server *server, struct nfs4_lock_state *lsp)
 {
         struct rpc_task *task;
+        struct rpc_cred *cred = lsp->ls_state->owner->so_cred;
 
-        task = _nfs41_free_stateid(server, &lsp->ls_stateid, false);
+        task = _nfs41_free_stateid(server, &lsp->ls_stateid, cred, false);
         nfs4_free_lock_state(server, lsp);
         if (IS_ERR(task))
                 return PTR_ERR(task);
diff --git a/fs/nfs/nfs4session.c b/fs/nfs/nfs4session.c
index ebda5f4a031b..36e21cb29d65 100644
--- a/fs/nfs/nfs4session.c
+++ b/fs/nfs/nfs4session.c
@@ -73,7 +73,7 @@ void nfs4_free_slot(struct nfs4_slot_table *tbl, struct nfs4_slot *slot)
                         tbl->highest_used_slotid = new_max;
                 else {
                         tbl->highest_used_slotid = NFS4_NO_SLOT;
-                        nfs4_session_drain_complete(tbl->session, tbl);
+                        nfs4_slot_tbl_drain_complete(tbl);
                 }
         }
         dprintk("%s: slotid %u highest_used_slotid %d\n", __func__,
@@ -226,7 +226,7 @@ static bool nfs41_assign_slot(struct rpc_task *task, void *pslot)
         struct nfs4_slot *slot = pslot;
         struct nfs4_slot_table *tbl = slot->table;
 
-        if (nfs4_session_draining(tbl->session) && !args->sa_privileged)
+        if (nfs4_slot_tbl_draining(tbl) && !args->sa_privileged)
                 return false;
         slot->generation = tbl->generation;
         args->sa_slot = slot;
@@ -478,48 +478,12 @@ static int nfs41_check_session_ready(struct nfs_client *clp)
         return 0;
 }
 
-int nfs4_init_session(struct nfs_server *server)
+int nfs4_init_session(struct nfs_client *clp)
 {
-        struct nfs_client *clp = server->nfs_client;
-        struct nfs4_session *session;
-        unsigned int target_max_rqst_sz = NFS_MAX_FILE_IO_SIZE;
-        unsigned int target_max_resp_sz = NFS_MAX_FILE_IO_SIZE;
-
         if (!nfs4_has_session(clp))
                 return 0;
 
-        if (server->rsize != 0)
-                target_max_resp_sz = server->rsize;
-        target_max_resp_sz += nfs41_maxread_overhead;
-
-        if (server->wsize != 0)
-                target_max_rqst_sz = server->wsize;
-        target_max_rqst_sz += nfs41_maxwrite_overhead;
-
-        session = clp->cl_session;
-        spin_lock(&clp->cl_lock);
-        if (test_and_clear_bit(NFS4_SESSION_INITING, &session->session_state)) {
-                /* Initialise targets and channel attributes */
-                session->fc_target_max_rqst_sz = target_max_rqst_sz;
-                session->fc_attrs.max_rqst_sz = target_max_rqst_sz;
-                session->fc_target_max_resp_sz = target_max_resp_sz;
-                session->fc_attrs.max_resp_sz = target_max_resp_sz;
-        } else {
-                /* Just adjust the targets */
-                if (target_max_rqst_sz > session->fc_target_max_rqst_sz) {
-                        session->fc_target_max_rqst_sz = target_max_rqst_sz;
-                        set_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state);
-                }
-                if (target_max_resp_sz > session->fc_target_max_resp_sz) {
-                        session->fc_target_max_resp_sz = target_max_resp_sz;
-                        set_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state);
-                }
-        }
-        spin_unlock(&clp->cl_lock);
-
-        if (test_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state))
-                nfs4_schedule_lease_recovery(clp);
-
+        clear_bit(NFS4_SESSION_INITING, &clp->cl_session->session_state);
         return nfs41_check_session_ready(clp);
 }
 
diff --git a/fs/nfs/nfs4session.h b/fs/nfs/nfs4session.h
index 6f3cb39386d4..3a153d82b90c 100644
--- a/fs/nfs/nfs4session.h
+++ b/fs/nfs/nfs4session.h
@@ -25,6 +25,10 @@ struct nfs4_slot {
 };
 
 /* Sessions */
+enum nfs4_slot_tbl_state {
+        NFS4_SLOT_TBL_DRAINING,
+};
+
 #define SLOT_TABLE_SZ DIV_ROUND_UP(NFS4_MAX_SLOT_TABLE, 8*sizeof(long))
 struct nfs4_slot_table {
         struct nfs4_session *session;           /* Parent session */
@@ -43,6 +47,7 @@ struct nfs4_slot_table {
         unsigned long   generation;             /* Generation counter for
                                                    target_highest_slotid */
         struct completion complete;
+        unsigned long   slot_tbl_state;
 };
 
 /*
@@ -61,14 +66,10 @@ struct nfs4_session {
         struct nfs4_channel_attrs       bc_attrs;
         struct nfs4_slot_table          bc_slot_table;
         struct nfs_client               *clp;
-        /* Create session arguments */
-        unsigned int                    fc_target_max_rqst_sz;
-        unsigned int                    fc_target_max_resp_sz;
 };
 
 enum nfs4_session_state {
         NFS4_SESSION_INITING,
-        NFS4_SESSION_DRAINING,
 };
 
 #if defined(CONFIG_NFS_V4_1)
@@ -85,15 +86,14 @@ extern int nfs4_setup_session_slot_tables(struct nfs4_session *ses);
 
 extern struct nfs4_session *nfs4_alloc_session(struct nfs_client *clp);
 extern void nfs4_destroy_session(struct nfs4_session *session);
-extern int nfs4_init_session(struct nfs_server *server);
+extern int nfs4_init_session(struct nfs_client *clp);
 extern int nfs4_init_ds_session(struct nfs_client *, unsigned long);
 
-extern void nfs4_session_drain_complete(struct nfs4_session *session,
-                struct nfs4_slot_table *tbl);
+extern void nfs4_slot_tbl_drain_complete(struct nfs4_slot_table *tbl);
 
-static inline bool nfs4_session_draining(struct nfs4_session *session)
+static inline bool nfs4_slot_tbl_draining(struct nfs4_slot_table *tbl)
 {
-        return !!test_bit(NFS4_SESSION_DRAINING, &session->session_state);
+        return !!test_bit(NFS4_SLOT_TBL_DRAINING, &tbl->slot_tbl_state);
 }
 
 bool nfs41_wake_and_assign_slot(struct nfs4_slot_table *tbl,
@@ -119,7 +119,7 @@ static inline int nfs4_has_persistent_session(const struct nfs_client *clp)
 
 #else /* defined(CONFIG_NFS_V4_1) */
 
-static inline int nfs4_init_session(struct nfs_server *server)
+static inline int nfs4_init_session(struct nfs_client *clp)
 {
         return 0;
 }
diff --git a/fs/nfs/nfs4state.c b/fs/nfs/nfs4state.c
index 300d17d85c0e..b0e42d7a19a1 100644
--- a/fs/nfs/nfs4state.c
+++ b/fs/nfs/nfs4state.c
@@ -228,38 +228,37 @@ static int nfs41_setup_state_renewal(struct nfs_client *clp)
         return status;
 }
 
-/*
- * Back channel returns NFS4ERR_DELAY for new requests when
- * NFS4_SESSION_DRAINING is set so there is no work to be done when draining
- * is ended.
- */
-static void nfs4_end_drain_session(struct nfs_client *clp)
+static void nfs4_end_drain_slot_table(struct nfs4_slot_table *tbl)
 {
-        struct nfs4_session *ses = clp->cl_session;
-        struct nfs4_slot_table *tbl;
-
-        if (ses == NULL)
-                return;
-        tbl = &ses->fc_slot_table;
-        if (test_and_clear_bit(NFS4_SESSION_DRAINING, &ses->session_state)) {
+        if (test_and_clear_bit(NFS4_SLOT_TBL_DRAINING, &tbl->slot_tbl_state)) {
                 spin_lock(&tbl->slot_tbl_lock);
                 nfs41_wake_slot_table(tbl);
                 spin_unlock(&tbl->slot_tbl_lock);
         }
 }
 
+static void nfs4_end_drain_session(struct nfs_client *clp)
+{
+        struct nfs4_session *ses = clp->cl_session;
+
+        if (ses != NULL) {
+                nfs4_end_drain_slot_table(&ses->bc_slot_table);
+                nfs4_end_drain_slot_table(&ses->fc_slot_table);
+        }
+}
+
 /*
  * Signal state manager thread if session fore channel is drained
  */
-void nfs4_session_drain_complete(struct nfs4_session *session,
-                struct nfs4_slot_table *tbl)
+void nfs4_slot_tbl_drain_complete(struct nfs4_slot_table *tbl)
 {
-        if (nfs4_session_draining(session))
+        if (nfs4_slot_tbl_draining(tbl))
                 complete(&tbl->complete);
 }
 
-static int nfs4_wait_on_slot_tbl(struct nfs4_slot_table *tbl)
+static int nfs4_drain_slot_tbl(struct nfs4_slot_table *tbl)
 {
+        set_bit(NFS4_SLOT_TBL_DRAINING, &tbl->slot_tbl_state);
         spin_lock(&tbl->slot_tbl_lock);
         if (tbl->highest_used_slotid != NFS4_NO_SLOT) {
                 INIT_COMPLETION(tbl->complete);
@@ -275,13 +274,12 @@ static int nfs4_begin_drain_session(struct nfs_client *clp)
         struct nfs4_session *ses = clp->cl_session;
         int ret = 0;
 
-        set_bit(NFS4_SESSION_DRAINING, &ses->session_state);
         /* back channel */
-        ret = nfs4_wait_on_slot_tbl(&ses->bc_slot_table);
+        ret = nfs4_drain_slot_tbl(&ses->bc_slot_table);
         if (ret)
                 return ret;
         /* fore channel */
-        return nfs4_wait_on_slot_tbl(&ses->fc_slot_table);
+        return nfs4_drain_slot_tbl(&ses->fc_slot_table);
 }
 
 static void nfs41_finish_session_reset(struct nfs_client *clp)
@@ -1564,11 +1562,12 @@ static void nfs4_state_start_reclaim_reboot(struct nfs_client *clp)
 }
 
 static void nfs4_reclaim_complete(struct nfs_client *clp,
-                                 const struct nfs4_state_recovery_ops *ops)
+                                 const struct nfs4_state_recovery_ops *ops,
+                                 struct rpc_cred *cred)
 {
         /* Notify the server we're done reclaiming our state */
         if (ops->reclaim_complete)
-                (void)ops->reclaim_complete(clp);
+                (void)ops->reclaim_complete(clp, cred);
 }
 
 static void nfs4_clear_reclaim_server(struct nfs_server *server)
@@ -1613,9 +1612,15 @@ static int nfs4_state_clear_reclaim_reboot(struct nfs_client *clp)
 
 static void nfs4_state_end_reclaim_reboot(struct nfs_client *clp)
 {
+        const struct nfs4_state_recovery_ops *ops;
+        struct rpc_cred *cred;
+
         if (!nfs4_state_clear_reclaim_reboot(clp))
                 return;
-        nfs4_reclaim_complete(clp, clp->cl_mvops->reboot_recovery_ops);
+        ops = clp->cl_mvops->reboot_recovery_ops;
+        cred = ops->get_clid_cred(clp);
+        nfs4_reclaim_complete(clp, ops, cred);
+        put_rpccred(cred);
 }
 
 static void nfs_delegation_clear_all(struct nfs_client *clp)
diff --git a/fs/nfs/nfs4super.c b/fs/nfs/nfs4super.c
index a5e1a3026d48..5dbe2d269210 100644
--- a/fs/nfs/nfs4super.c
+++ b/fs/nfs/nfs4super.c
@@ -9,6 +9,7 @@
 #include "delegation.h"
 #include "internal.h"
 #include "nfs4_fs.h"
+#include "dns_resolve.h"
 #include "pnfs.h"
 #include "nfs.h"
 
@@ -331,18 +332,24 @@ static int __init init_nfs_v4(void)
 {
         int err;
 
-        err = nfs_idmap_init();
+        err = nfs_dns_resolver_init();
         if (err)
                 goto out;
 
-        err = nfs4_register_sysctl();
+        err = nfs_idmap_init();
         if (err)
                 goto out1;
 
+        err = nfs4_register_sysctl();
+        if (err)
+                goto out2;
+
         register_nfs_version(&nfs_v4);
         return 0;
-out1:
+out2:
         nfs_idmap_quit();
+out1:
+        nfs_dns_resolver_destroy();
 out:
         return err;
 }
@@ -352,6 +359,7 @@ static void __exit exit_nfs_v4(void)
         unregister_nfs_version(&nfs_v4);
         nfs4_unregister_sysctl();
         nfs_idmap_quit();
+        nfs_dns_resolver_destroy();
 }
 
 MODULE_LICENSE("GPL");
diff --git a/fs/nfs/nfs4xdr.c b/fs/nfs/nfs4xdr.c
index 2a3f77e14db6..0abfb8466e79 100644
--- a/fs/nfs/nfs4xdr.c
+++ b/fs/nfs/nfs4xdr.c
@@ -867,6 +867,12 @@ const u32 nfs41_maxread_overhead = ((RPC_MAX_HEADER_WITH_AUTH +
                                      decode_sequence_maxsz +
                                      decode_putfh_maxsz) *
                                     XDR_UNIT);
+
+const u32 nfs41_maxgetdevinfo_overhead = ((RPC_MAX_REPHEADER_WITH_AUTH +
+                                           compound_decode_hdr_maxsz +
+                                           decode_sequence_maxsz) *
+                                          XDR_UNIT);
+EXPORT_SYMBOL_GPL(nfs41_maxgetdevinfo_overhead);
 #endif /* CONFIG_NFS_V4_1 */
 
 static const umode_t nfs_type2fmt[] = {
@@ -1924,7 +1930,7 @@ encode_getdeviceinfo(struct xdr_stream *xdr,
         p = xdr_encode_opaque_fixed(p, args->pdev->dev_id.data,
                                     NFS4_DEVICEID4_SIZE);
         *p++ = cpu_to_be32(args->pdev->layout_type);
-        *p++ = cpu_to_be32(args->pdev->pglen);          /* gdia_maxcount */
+        *p++ = cpu_to_be32(args->pdev->maxcount);       /* gdia_maxcount */
         *p++ = cpu_to_be32(0);                          /* bitmap length 0 */
 }
 
diff --git a/fs/nfs/objlayout/objlayout.c b/fs/nfs/objlayout/objlayout.c
index a9ebd817278b..e4f9cbfec67b 100644
--- a/fs/nfs/objlayout/objlayout.c
+++ b/fs/nfs/objlayout/objlayout.c
@@ -613,8 +613,10 @@ int objlayout_get_deviceinfo(struct pnfs_layout_hdr *pnfslay,
         pd.pgbase = 0;
         pd.pglen = PAGE_SIZE;
         pd.mincount = 0;
+        pd.maxcount = PAGE_SIZE;
 
-        err = nfs4_proc_getdeviceinfo(NFS_SERVER(pnfslay->plh_inode), &pd);
+        err = nfs4_proc_getdeviceinfo(NFS_SERVER(pnfslay->plh_inode), &pd,
+                        pnfslay->plh_lc_cred);
         dprintk("%s nfs_getdeviceinfo returned %d\n", __func__, err);
         if (err)
                 goto err_out;
diff --git a/fs/nfs/pnfs.c b/fs/nfs/pnfs.c
index c5bd758e5637..3a3a79d6bf15 100644
--- a/fs/nfs/pnfs.c
+++ b/fs/nfs/pnfs.c
@@ -360,7 +360,7 @@ pnfs_put_lseg(struct pnfs_layout_segment *lseg)
 }
 EXPORT_SYMBOL_GPL(pnfs_put_lseg);
 
-static inline u64
+static u64
 end_offset(u64 start, u64 len)
 {
         u64 end;
@@ -376,9 +376,9 @@ end_offset(u64 start, u64 len)
  *           start2           end2
  *           [----------------)
  */
-static inline int
-lo_seg_contained(struct pnfs_layout_range *l1,
-                 struct pnfs_layout_range *l2)
+static bool
+pnfs_lseg_range_contained(const struct pnfs_layout_range *l1,
+                 const struct pnfs_layout_range *l2)
 {
         u64 start1 = l1->offset;
         u64 end1 = end_offset(start1, l1->length);
@@ -395,9 +395,9 @@ lo_seg_contained(struct pnfs_layout_range *l1,
  *                              start2           end2
  *                              [----------------)
  */
-static inline int
-lo_seg_intersecting(struct pnfs_layout_range *l1,
-                    struct pnfs_layout_range *l2)
+static bool
+pnfs_lseg_range_intersecting(const struct pnfs_layout_range *l1,
+                    const struct pnfs_layout_range *l2)
 {
         u64 start1 = l1->offset;
         u64 end1 = end_offset(start1, l1->length);
@@ -409,12 +409,12 @@ lo_seg_intersecting(struct pnfs_layout_range *l1,
 }
 
 static bool
-should_free_lseg(struct pnfs_layout_range *lseg_range,
-                 struct pnfs_layout_range *recall_range)
+should_free_lseg(const struct pnfs_layout_range *lseg_range,
+                 const struct pnfs_layout_range *recall_range)
 {
         return (recall_range->iomode == IOMODE_ANY ||
                 lseg_range->iomode == recall_range->iomode) &&
-               lo_seg_intersecting(lseg_range, recall_range);
+               pnfs_lseg_range_intersecting(lseg_range, recall_range);
 }
 
 static bool pnfs_lseg_dec_and_remove_zero(struct pnfs_layout_segment *lseg,
@@ -766,6 +766,7 @@ send_layoutget(struct pnfs_layout_hdr *lo,
         lgp->args.inode = ino;
         lgp->args.ctx = get_nfs_open_context(ctx);
         lgp->gfp_flags = gfp_flags;
+        lgp->cred = lo->plh_lc_cred;
 
         /* Synchronously retrieve layout information from server and
          * store in lseg.
@@ -860,6 +861,7 @@ _pnfs_return_layout(struct inode *ino)
         lrp->args.inode = ino;
         lrp->args.layout = lo;
         lrp->clp = NFS_SERVER(ino)->nfs_client;
+        lrp->cred = lo->plh_lc_cred;
 
         status = nfs4_proc_layoutreturn(lrp);
 out:
@@ -984,8 +986,8 @@ out:
  * are seen first.
  */
 static s64
-cmp_layout(struct pnfs_layout_range *l1,
-           struct pnfs_layout_range *l2)
+pnfs_lseg_range_cmp(const struct pnfs_layout_range *l1,
+           const struct pnfs_layout_range *l2)
 {
         s64 d;
 
@@ -1012,7 +1014,7 @@ pnfs_layout_insert_lseg(struct pnfs_layout_hdr *lo,
         dprintk("%s:Begin\n", __func__);
 
         list_for_each_entry(lp, &lo->plh_segs, pls_list) {
-                if (cmp_layout(&lseg->pls_range, &lp->pls_range) > 0)
+                if (pnfs_lseg_range_cmp(&lseg->pls_range, &lp->pls_range) > 0)
                         continue;
                 list_add_tail(&lseg->pls_list, &lp->pls_list);
                 dprintk("%s: inserted lseg %p "
@@ -1050,7 +1052,7 @@ alloc_init_layout_hdr(struct inode *ino,
         INIT_LIST_HEAD(&lo->plh_segs);
         INIT_LIST_HEAD(&lo->plh_bulk_destroy);
         lo->plh_inode = ino;
-        lo->plh_lc_cred = get_rpccred(ctx->state->owner->so_cred);
+        lo->plh_lc_cred = get_rpccred(ctx->cred);
         return lo;
 }
 
@@ -1091,21 +1093,21 @@ out_existing:
  * READ         READ    true
  * READ         RW      true
  */
-static int
-is_matching_lseg(struct pnfs_layout_range *ls_range,
-                 struct pnfs_layout_range *range)
+static bool
+pnfs_lseg_range_match(const struct pnfs_layout_range *ls_range,
+                 const struct pnfs_layout_range *range)
 {
         struct pnfs_layout_range range1;
 
         if ((range->iomode == IOMODE_RW &&
              ls_range->iomode != IOMODE_RW) ||
-            !lo_seg_intersecting(ls_range, range))
+            !pnfs_lseg_range_intersecting(ls_range, range))
                 return 0;
 
         /* range1 covers only the first byte in the range */
         range1 = *range;
         range1.length = 1;
-        return lo_seg_contained(ls_range, &range1);
+        return pnfs_lseg_range_contained(ls_range, &range1);
 }
 
 /*
@@ -1121,7 +1123,7 @@ pnfs_find_lseg(struct pnfs_layout_hdr *lo,
 
         list_for_each_entry(lseg, &lo->plh_segs, pls_list) {
                 if (test_bit(NFS_LSEG_VALID, &lseg->pls_flags) &&
-                    is_matching_lseg(&lseg->pls_range, range)) {
+                    pnfs_lseg_range_match(&lseg->pls_range, range)) {
                         ret = pnfs_get_lseg(lseg);
                         break;
                 }
diff --git a/fs/nfs/pnfs.h b/fs/nfs/pnfs.h
index f5f8a470a647..a4f41810a7f4 100644
--- a/fs/nfs/pnfs.h
+++ b/fs/nfs/pnfs.h
@@ -149,9 +149,10 @@ struct pnfs_device {
         struct nfs4_deviceid dev_id;
         unsigned int  layout_type;
         unsigned int  mincount;
+        unsigned int  maxcount; /* gdia_maxcount */
         struct page **pages;
         unsigned int  pgbase;
-        unsigned int  pglen;
+        unsigned int  pglen;    /* reply buffer length */
 };
 
 #define NFS4_PNFS_GETDEVLIST_MAXNUM 16
@@ -170,7 +171,8 @@ extern int nfs4_proc_getdevicelist(struct nfs_server *server,
                                    const struct nfs_fh *fh,
                                    struct pnfs_devicelist *devlist);
 extern int nfs4_proc_getdeviceinfo(struct nfs_server *server,
-                                   struct pnfs_device *dev);
+                                   struct pnfs_device *dev,
+                                   struct rpc_cred *cred);
 extern struct pnfs_layout_segment* nfs4_proc_layoutget(struct nfs4_layoutget *lgp, gfp_t gfp_flags);
 extern int nfs4_proc_layoutreturn(struct nfs4_layoutreturn *lrp);
 
diff --git a/fs/nfs/super.c b/fs/nfs/super.c
index 76e1ee5d03ed..71fdc0dfa0d2 100644
--- a/fs/nfs/super.c
+++ b/fs/nfs/super.c
@@ -1614,29 +1614,13 @@ out_security_failure:
 }
 
 /*
- * Select a security flavor for this mount.  The selected flavor
- * is planted in args->auth_flavors[0].
- *
- * Returns 0 on success, -EACCES on failure.
+ * Ensure that the specified authtype in args->auth_flavors[0] is supported by
+ * the server. Returns 0 if it's ok, and -EACCES if not.
  */
-static int nfs_select_flavor(struct nfs_parsed_mount_data *args,
-                              struct nfs_mount_request *request)
+static int nfs_verify_authflavor(struct nfs_parsed_mount_data *args,
+                        rpc_authflavor_t *server_authlist, unsigned int count)
 {
-        unsigned int i, count = *(request->auth_flav_len);
-        rpc_authflavor_t flavor;
-
-        /*
-         * The NFSv2 MNT operation does not return a flavor list.
-         */
-        if (args->mount_server.version != NFS_MNT3_VERSION)
-                goto out_default;
-
-        /*
-         * Certain releases of Linux's mountd return an empty
-         * flavor list in some cases.
-         */
-        if (count == 0)
-                goto out_default;
+        unsigned int i;
 
         /*
          * If the sec= mount option is used, the specified flavor or AUTH_NULL
@@ -1646,60 +1630,19 @@ static int nfs_select_flavor(struct nfs_parsed_mount_data *args,
          * means that the server will ignore the rpc creds, so any flavor
          * can be used.
          */
-        if (args->auth_flavors[0] != RPC_AUTH_MAXFLAVOR) {
-                for (i = 0; i < count; i++) {
-                        if (args->auth_flavors[0] == request->auth_flavs[i] ||
-                            request->auth_flavs[i] == RPC_AUTH_NULL)
-                                goto out;
-                }
-                dfprintk(MOUNT, "NFS: auth flavor %d not supported by server\n",
-                        args->auth_flavors[0]);
-                goto out_err;
-        }
-
-        /*
-         * RFC 2623, section 2.7 suggests we SHOULD prefer the
-         * flavor listed first.  However, some servers list
-         * AUTH_NULL first.  Avoid ever choosing AUTH_NULL.
-         */
-        for (i = 0; i < count; i++) {
-                struct rpcsec_gss_info info;
-
-                flavor = request->auth_flavs[i];
-                switch (flavor) {
-                case RPC_AUTH_UNIX:
-                        goto out_set;
-                case RPC_AUTH_NULL:
-                        continue;
-                default:
-                        if (rpcauth_get_gssinfo(flavor, &info) == 0)
-                                goto out_set;
-                }
-        }
-
-        /*
-         * As a last chance, see if the server list contains AUTH_NULL -
-         * if it does, use the default flavor.
-         */
         for (i = 0; i < count; i++) {
-                if (request->auth_flavs[i] == RPC_AUTH_NULL)
-                        goto out_default;
+                if (args->auth_flavors[0] == server_authlist[i] ||
+                    server_authlist[i] == RPC_AUTH_NULL)
+                        goto out;
         }
 
-        dfprintk(MOUNT, "NFS: no auth flavors in common with server\n");
-        goto out_err;
+        dfprintk(MOUNT, "NFS: auth flavor %u not supported by server\n",
+                args->auth_flavors[0]);
+        return -EACCES;
 
-out_default:
-        /* use default if flavor not already set */
-        flavor = (args->auth_flavors[0] == RPC_AUTH_MAXFLAVOR) ?
-                RPC_AUTH_UNIX : args->auth_flavors[0];
-out_set:
-        args->auth_flavors[0] = flavor;
 out:
-        dfprintk(MOUNT, "NFS: using auth flavor %d\n", args->auth_flavors[0]);
+        dfprintk(MOUNT, "NFS: using auth flavor %u\n", args->auth_flavors[0]);
         return 0;
-out_err:
-        return -EACCES;
 }
 
 /*
@@ -1707,10 +1650,10 @@ out_err:
  * corresponding to the provided path.
  */
 static int nfs_request_mount(struct nfs_parsed_mount_data *args,
-                             struct nfs_fh *root_fh)
+                             struct nfs_fh *root_fh,
+                             rpc_authflavor_t *server_authlist,
+                             unsigned int *server_authlist_len)
 {
-        rpc_authflavor_t server_authlist[NFS_MAX_SECFLAVORS];
-        unsigned int server_authlist_len = ARRAY_SIZE(server_authlist);
         struct nfs_mount_request request = {
                 .sap            = (struct sockaddr *)
                                                 &args->mount_server.address,
@@ -1718,7 +1661,7 @@ static int nfs_request_mount(struct nfs_parsed_mount_data *args,
                 .protocol       = args->mount_server.protocol,
                 .fh             = root_fh,
                 .noresvport     = args->flags & NFS_MOUNT_NORESVPORT,
-                .auth_flav_len  = &server_authlist_len,
+                .auth_flav_len  = server_authlist_len,
                 .auth_flavs     = server_authlist,
                 .net            = args->net,
         };
@@ -1762,24 +1705,92 @@ static int nfs_request_mount(struct nfs_parsed_mount_data *args,
                 return status;
         }
 
-        return nfs_select_flavor(args, &request);
+        return 0;
 }
 
-struct dentry *nfs_try_mount(int flags, const char *dev_name,
-                             struct nfs_mount_info *mount_info,
-                             struct nfs_subversion *nfs_mod)
+static struct nfs_server *nfs_try_mount_request(struct nfs_mount_info *mount_info,
+                                        struct nfs_subversion *nfs_mod)
 {
         int status;
-        struct nfs_server *server;
+        unsigned int i;
+        bool tried_auth_unix = false;
+        bool auth_null_in_list = false;
+        struct nfs_server *server = ERR_PTR(-EACCES);
+        struct nfs_parsed_mount_data *args = mount_info->parsed;
+        rpc_authflavor_t authlist[NFS_MAX_SECFLAVORS];
+        unsigned int authlist_len = ARRAY_SIZE(authlist);
+
+        status = nfs_request_mount(args, mount_info->mntfh, authlist,
+                                        &authlist_len);
+        if (status)
+                return ERR_PTR(status);
 
-        if (mount_info->parsed->need_mount) {
-                status = nfs_request_mount(mount_info->parsed, mount_info->mntfh);
+        /*
+         * Was a sec= authflavor specified in the options? First, verify
+         * whether the server supports it, and then just try to use it if so.
+         */
+        if (args->auth_flavors[0] != RPC_AUTH_MAXFLAVOR) {
+                status = nfs_verify_authflavor(args, authlist, authlist_len);
+                dfprintk(MOUNT, "NFS: using auth flavor %u\n", args->auth_flavors[0]);
                 if (status)
                         return ERR_PTR(status);
+                return nfs_mod->rpc_ops->create_server(mount_info, nfs_mod);
         }
 
-        /* Get a volume representation */
-        server = nfs_mod->rpc_ops->create_server(mount_info, nfs_mod);
+        /*
+         * No sec= option was provided. RFC 2623, section 2.7 suggests we
+         * SHOULD prefer the flavor listed first. However, some servers list
+         * AUTH_NULL first. Avoid ever choosing AUTH_NULL.
+         */
+        for (i = 0; i < authlist_len; ++i) {
+                rpc_authflavor_t flavor;
+                struct rpcsec_gss_info info;
+
+                flavor = authlist[i];
+                switch (flavor) {
+                case RPC_AUTH_UNIX:
+                        tried_auth_unix = true;
+                        break;
+                case RPC_AUTH_NULL:
+                        auth_null_in_list = true;
+                        continue;
+                default:
+                        if (rpcauth_get_gssinfo(flavor, &info) != 0)
+                                continue;
+                        /* Fallthrough */
+                }
+                dfprintk(MOUNT, "NFS: attempting to use auth flavor %u\n", flavor);
+                args->auth_flavors[0] = flavor;
+                server = nfs_mod->rpc_ops->create_server(mount_info, nfs_mod);
+                if (!IS_ERR(server))
+                        return server;
+        }
+
+        /*
+         * Nothing we tried so far worked. At this point, give up if we've
+         * already tried AUTH_UNIX or if the server's list doesn't contain
+         * AUTH_NULL
+         */
+        if (tried_auth_unix || !auth_null_in_list)
+                return server;
+
+        /* Last chance! Try AUTH_UNIX */
+        dfprintk(MOUNT, "NFS: attempting to use auth flavor %u\n", RPC_AUTH_UNIX);
+        args->auth_flavors[0] = RPC_AUTH_UNIX;
+        return nfs_mod->rpc_ops->create_server(mount_info, nfs_mod);
+}
+
+struct dentry *nfs_try_mount(int flags, const char *dev_name,
+                             struct nfs_mount_info *mount_info,
+                             struct nfs_subversion *nfs_mod)
+{
+        struct nfs_server *server;
+
+        if (mount_info->parsed->need_mount)
+                server = nfs_try_mount_request(mount_info, nfs_mod);
+        else
+                server = nfs_mod->rpc_ops->create_server(mount_info, nfs_mod);
+
         if (IS_ERR(server))
                 return ERR_CAST(server);
 
@@ -1948,6 +1959,7 @@ static int nfs23_validate_mount_data(void *options,
                 args->namlen            = data->namlen;
                 args->bsize             = data->bsize;
 
+                args->auth_flavors[0] = RPC_AUTH_UNIX;
                 if (data->flags & NFS_MOUNT_SECFLAVOUR)
                         args->auth_flavors[0] = data->pseudoflavor;
                 if (!args->nfs_server.hostname)
@@ -2657,6 +2669,7 @@ static int nfs4_validate_mount_data(void *options,
                         goto out_no_address;
                 args->nfs_server.port = ntohs(((struct sockaddr_in *)sap)->sin_port);
 
+                args->auth_flavors[0] = RPC_AUTH_UNIX;
                 if (data->auth_flavourlen) {
                         if (data->auth_flavourlen > 1)
                                 goto out_inval_auth;
diff --git a/include/linux/nfs_fs.h b/include/linux/nfs_fs.h
index d4b003d9e78d..0b176297aaf6 100644
--- a/include/linux/nfs_fs.h
+++ b/include/linux/nfs_fs.h
@@ -359,6 +359,7 @@ extern struct nfs_open_context *get_nfs_open_context(struct nfs_open_context *ct
 extern void put_nfs_open_context(struct nfs_open_context *ctx);
 extern struct nfs_open_context *nfs_find_open_context(struct inode *inode, struct rpc_cred *cred, fmode_t mode);
 extern struct nfs_open_context *alloc_nfs_open_context(struct dentry *dentry, fmode_t f_mode);
+extern void nfs_inode_attach_open_context(struct nfs_open_context *ctx);
 extern void nfs_file_set_open_context(struct file *filp, struct nfs_open_context *ctx);
 extern struct nfs_lock_context *nfs_get_lock_context(struct nfs_open_context *ctx);
 extern void nfs_put_lock_context(struct nfs_lock_context *l_ctx);
diff --git a/include/linux/nfs_xdr.h b/include/linux/nfs_xdr.h
index ed31ba7a6f9e..8651574a305b 100644
--- a/include/linux/nfs_xdr.h
+++ b/include/linux/nfs_xdr.h
@@ -248,6 +248,7 @@ struct nfs4_layoutget_res {
 struct nfs4_layoutget {
         struct nfs4_layoutget_args args;
         struct nfs4_layoutget_res res;
+        struct rpc_cred *cred;
         gfp_t gfp_flags;
 };
 
diff --git a/include/linux/sunrpc/sched.h b/include/linux/sunrpc/sched.h
index 84ca436b76c2..6d870353674a 100644
--- a/include/linux/sunrpc/sched.h
+++ b/include/linux/sunrpc/sched.h
@@ -88,15 +88,6 @@ struct rpc_task {
                                 tk_rebind_retry : 2;
 };
 
-/* support walking a list of tasks on a wait queue */
-#define task_for_each(task, pos, head) \
-        list_for_each(pos, head) \
-                if ((task=list_entry(pos, struct rpc_task, u.tk_wait.list)),1)
-
-#define task_for_first(task, head) \
-        if (!list_empty(head) &&  \
-            ((task=list_entry((head)->next, struct rpc_task, u.tk_wait.list)),1))
-
 typedef void                    (*rpc_action)(struct rpc_task *);
 
 struct rpc_call_ops {
@@ -238,7 +229,6 @@ struct rpc_task *rpc_wake_up_first(struct rpc_wait_queue *,
                                         bool (*)(struct rpc_task *, void *),
                                         void *);
 void            rpc_wake_up_status(struct rpc_wait_queue *, int);
-int             rpc_queue_empty(struct rpc_wait_queue *);
 void            rpc_delay(struct rpc_task *, unsigned long);
 void *          rpc_malloc(struct rpc_task *, size_t);
 void            rpc_free(void *);
@@ -259,16 +249,6 @@ static inline int rpc_wait_for_completion_task(struct rpc_task *task)
         return __rpc_wait_for_completion_task(task, NULL);
 }
 
-static inline void rpc_task_set_priority(struct rpc_task *task, unsigned char prio)
-{
-        task->tk_priority = prio - RPC_PRIORITY_LOW;
-}
-
-static inline int rpc_task_has_priority(struct rpc_task *task, unsigned char prio)
-{
-        return (task->tk_priority + RPC_PRIORITY_LOW == prio);
-}
-
 #if defined(RPC_DEBUG) || defined (RPC_TRACEPOINTS)
 static inline const char * rpc_qname(const struct rpc_wait_queue *q)
 {
diff --git a/net/sunrpc/auth_gss/auth_gss.c b/net/sunrpc/auth_gss/auth_gss.c
index 7da6b457f66a..fc2f78d6a9b4 100644
--- a/net/sunrpc/auth_gss/auth_gss.c
+++ b/net/sunrpc/auth_gss/auth_gss.c
@@ -52,6 +52,8 @@
 #include <linux/sunrpc/gss_api.h>
 #include <asm/uaccess.h>
 
+#include "../netns.h"
+
 static const struct rpc_authops authgss_ops;
 
 static const struct rpc_credops gss_credops;
@@ -85,8 +87,6 @@ struct gss_auth {
 };
 
 /* pipe_version >= 0 if and only if someone has a pipe open. */
-static int pipe_version = -1;
-static atomic_t pipe_users = ATOMIC_INIT(0);
 static DEFINE_SPINLOCK(pipe_version_lock);
 static struct rpc_wait_queue pipe_version_rpc_waitqueue;
 static DECLARE_WAIT_QUEUE_HEAD(pipe_version_waitqueue);
@@ -266,24 +266,27 @@ struct gss_upcall_msg {
         char databuf[UPCALL_BUF_LEN];
 };
 
-static int get_pipe_version(void)
+static int get_pipe_version(struct net *net)
 {
+        struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
         int ret;
 
         spin_lock(&pipe_version_lock);
-        if (pipe_version >= 0) {
-                atomic_inc(&pipe_users);
-                ret = pipe_version;
+        if (sn->pipe_version >= 0) {
+                atomic_inc(&sn->pipe_users);
+                ret = sn->pipe_version;
         } else
                 ret = -EAGAIN;
         spin_unlock(&pipe_version_lock);
         return ret;
 }
 
-static void put_pipe_version(void)
+static void put_pipe_version(struct net *net)
 {
-        if (atomic_dec_and_lock(&pipe_users, &pipe_version_lock)) {
-                pipe_version = -1;
+        struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
+
+        if (atomic_dec_and_lock(&sn->pipe_users, &pipe_version_lock)) {
+                sn->pipe_version = -1;
                 spin_unlock(&pipe_version_lock);
         }
 }
@@ -291,9 +294,10 @@ static void put_pipe_version(void)
 static void
 gss_release_msg(struct gss_upcall_msg *gss_msg)
 {
+        struct net *net = rpc_net_ns(gss_msg->auth->client);
         if (!atomic_dec_and_test(&gss_msg->count))
                 return;
-        put_pipe_version();
+        put_pipe_version(net);
         BUG_ON(!list_empty(&gss_msg->list));
         if (gss_msg->ctx != NULL)
                 gss_put_ctx(gss_msg->ctx);
@@ -439,7 +443,10 @@ static void gss_encode_msg(struct gss_upcall_msg *gss_msg,
                                 struct rpc_clnt *clnt,
                                 const char *service_name)
 {
-        if (pipe_version == 0)
+        struct net *net = rpc_net_ns(clnt);
+        struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
+
+        if (sn->pipe_version == 0)
                 gss_encode_v0_msg(gss_msg);
         else /* pipe_version == 1 */
                 gss_encode_v1_msg(gss_msg, clnt, service_name);
@@ -455,7 +462,7 @@ gss_alloc_msg(struct gss_auth *gss_auth, struct rpc_clnt *clnt,
         gss_msg = kzalloc(sizeof(*gss_msg), GFP_NOFS);
         if (gss_msg == NULL)
                 return ERR_PTR(-ENOMEM);
-        vers = get_pipe_version();
+        vers = get_pipe_version(rpc_net_ns(clnt));
         if (vers < 0) {
                 kfree(gss_msg);
                 return ERR_PTR(vers);
@@ -559,24 +566,34 @@ out:
 static inline int
 gss_create_upcall(struct gss_auth *gss_auth, struct gss_cred *gss_cred)
 {
+        struct net *net = rpc_net_ns(gss_auth->client);
+        struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
         struct rpc_pipe *pipe;
         struct rpc_cred *cred = &gss_cred->gc_base;
         struct gss_upcall_msg *gss_msg;
+        unsigned long timeout;
         DEFINE_WAIT(wait);
-        int err = 0;
+        int err;
 
         dprintk("RPC:       %s for uid %u\n",
                 __func__, from_kuid(&init_user_ns, cred->cr_uid));
 retry:
+        err = 0;
+        /* Default timeout is 15s unless we know that gssd is not running */
+        timeout = 15 * HZ;
+        if (!sn->gssd_running)
+                timeout = HZ >> 2;
         gss_msg = gss_setup_upcall(gss_auth->client, gss_auth, cred);
         if (PTR_ERR(gss_msg) == -EAGAIN) {
                 err = wait_event_interruptible_timeout(pipe_version_waitqueue,
-                                pipe_version >= 0, 15*HZ);
-                if (pipe_version < 0) {
+                                sn->pipe_version >= 0, timeout);
+                if (sn->pipe_version < 0) {
+                        if (err == 0)
+                                sn->gssd_running = 0;
                         warn_gssd();
                         err = -EACCES;
                 }
-                if (err)
+                if (err < 0)
                         goto out;
                 goto retry;
         }
@@ -707,20 +724,22 @@ out:
 
 static int gss_pipe_open(struct inode *inode, int new_version)
 {
+        struct net *net = inode->i_sb->s_fs_info;
+        struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
         int ret = 0;
 
         spin_lock(&pipe_version_lock);
-        if (pipe_version < 0) {
+        if (sn->pipe_version < 0) {
                 /* First open of any gss pipe determines the version: */
-                pipe_version = new_version;
+                sn->pipe_version = new_version;
                 rpc_wake_up(&pipe_version_rpc_waitqueue);
                 wake_up(&pipe_version_waitqueue);
-        } else if (pipe_version != new_version) {
+        } else if (sn->pipe_version != new_version) {
                 /* Trying to open a pipe of a different version */
                 ret = -EBUSY;
                 goto out;
         }
-        atomic_inc(&pipe_users);
+        atomic_inc(&sn->pipe_users);
 out:
         spin_unlock(&pipe_version_lock);
         return ret;
@@ -740,6 +759,7 @@ static int gss_pipe_open_v1(struct inode *inode)
 static void
 gss_pipe_release(struct inode *inode)
 {
+        struct net *net = inode->i_sb->s_fs_info;
         struct rpc_pipe *pipe = RPC_I(inode)->pipe;
         struct gss_upcall_msg *gss_msg;
 
@@ -758,7 +778,7 @@ restart:
         }
         spin_unlock(&pipe->lock);
 
-        put_pipe_version();
+        put_pipe_version(net);
 }
 
 static void
diff --git a/net/sunrpc/clnt.c b/net/sunrpc/clnt.c
index 5a750b9c3640..f0339ae9bf37 100644
--- a/net/sunrpc/clnt.c
+++ b/net/sunrpc/clnt.c
@@ -157,20 +157,15 @@ static struct dentry *rpc_setup_pipedir_sb(struct super_block *sb,
 }
 
 static int
-rpc_setup_pipedir(struct rpc_clnt *clnt, const char *dir_name)
+rpc_setup_pipedir(struct rpc_clnt *clnt, const char *dir_name,
+                  struct super_block *pipefs_sb)
 {
-        struct net *net = rpc_net_ns(clnt);
-        struct super_block *pipefs_sb;
         struct dentry *dentry;
 
         clnt->cl_dentry = NULL;
         if (dir_name == NULL)
                 return 0;
-        pipefs_sb = rpc_get_sb_net(net);
-        if (!pipefs_sb)
-                return 0;
         dentry = rpc_setup_pipedir_sb(pipefs_sb, clnt, dir_name);
-        rpc_put_sb_net(net);
         if (IS_ERR(dentry))
                 return PTR_ERR(dentry);
         clnt->cl_dentry = dentry;
@@ -182,6 +177,8 @@ static inline int rpc_clnt_skip_event(struct rpc_clnt *clnt, unsigned long event
         if (((event == RPC_PIPEFS_MOUNT) && clnt->cl_dentry) ||
             ((event == RPC_PIPEFS_UMOUNT) && !clnt->cl_dentry))
                 return 1;
+        if ((event == RPC_PIPEFS_MOUNT) && atomic_read(&clnt->cl_count) == 0)
+                return 1;
         return 0;
 }
 
@@ -241,8 +238,6 @@ static struct rpc_clnt *rpc_get_client_for_event(struct net *net, int event)
                         continue;
                 if (rpc_clnt_skip_event(clnt, event))
                         continue;
-                if (atomic_inc_not_zero(&clnt->cl_count) == 0)
-                        continue;
                 spin_unlock(&sn->rpc_client_lock);
                 return clnt;
         }
@@ -259,7 +254,6 @@ static int rpc_pipefs_event(struct notifier_block *nb, unsigned long event,
 
         while ((clnt = rpc_get_client_for_event(sb->s_fs_info, event))) {
                 error = __rpc_pipefs_event(clnt, event, sb);
-                rpc_release_client(clnt);
                 if (error)
                         break;
         }
@@ -289,12 +283,46 @@ static void rpc_clnt_set_nodename(struct rpc_clnt *clnt, const char *nodename)
         memcpy(clnt->cl_nodename, nodename, clnt->cl_nodelen);
 }
 
+static int rpc_client_register(const struct rpc_create_args *args,
+                               struct rpc_clnt *clnt)
+{
+        const struct rpc_program *program = args->program;
+        struct rpc_auth *auth;
+        struct net *net = rpc_net_ns(clnt);
+        struct super_block *pipefs_sb;
+        int err = 0;
+
+        pipefs_sb = rpc_get_sb_net(net);
+        if (pipefs_sb) {
+                err = rpc_setup_pipedir(clnt, program->pipe_dir_name, pipefs_sb);
+                if (err)
+                        goto out;
+        }
+
+        auth = rpcauth_create(args->authflavor, clnt);
+        if (IS_ERR(auth)) {
+                dprintk("RPC:       Couldn't create auth handle (flavor %u)\n",
+                                args->authflavor);
+                err = PTR_ERR(auth);
+                goto err_auth;
+        }
+
+        rpc_register_client(clnt);
+out:
+        if (pipefs_sb)
+                rpc_put_sb_net(net);
+        return err;
+
+err_auth:
+        __rpc_clnt_remove_pipedir(clnt);
+        goto out;
+}
+
 static struct rpc_clnt * rpc_new_client(const struct rpc_create_args *args, struct rpc_xprt *xprt)
 {
         const struct rpc_program *program = args->program;
         const struct rpc_version *version;
         struct rpc_clnt         *clnt = NULL;
-        struct rpc_auth         *auth;
         int err;
 
         /* sanity check the name before trying to print it */
@@ -354,25 +382,14 @@ static struct rpc_clnt * rpc_new_client(const struct rpc_create_args *args, stru
 
         atomic_set(&clnt->cl_count, 1);
 
-        err = rpc_setup_pipedir(clnt, program->pipe_dir_name);
-        if (err < 0)
-                goto out_no_path;
-
-        auth = rpcauth_create(args->authflavor, clnt);
-        if (IS_ERR(auth)) {
-                dprintk("RPC:       Couldn't create auth handle (flavor %u)\n",
-                                args->authflavor);
-                err = PTR_ERR(auth);
-                goto out_no_auth;
-        }
-
         /* save the nodename */
         rpc_clnt_set_nodename(clnt, utsname()->nodename);
-        rpc_register_client(clnt);
+
+        err = rpc_client_register(args, clnt);
+        if (err)
+                goto out_no_path;
         return clnt;
 
-out_no_auth:
-        rpc_clnt_remove_pipedir(clnt);
 out_no_path:
         kfree(clnt->cl_principal);
 out_no_principal:
@@ -637,8 +654,8 @@ rpc_free_client(struct rpc_clnt *clnt)
                         rcu_dereference(clnt->cl_xprt)->servername);
         if (clnt->cl_parent != clnt)
                 rpc_release_client(clnt->cl_parent);
-        rpc_unregister_client(clnt);
         rpc_clnt_remove_pipedir(clnt);
+        rpc_unregister_client(clnt);
         rpc_free_iostats(clnt->cl_metrics);
         kfree(clnt->cl_principal);
         clnt->cl_metrics = NULL;
diff --git a/net/sunrpc/netns.h b/net/sunrpc/netns.h
index 7111a4c9113b..74d948f5d5a1 100644
--- a/net/sunrpc/netns.h
+++ b/net/sunrpc/netns.h
@@ -28,7 +28,11 @@ struct sunrpc_net {
         wait_queue_head_t gssp_wq;
         struct rpc_clnt *gssp_clnt;
         int use_gss_proxy;
+        int pipe_version;
+        atomic_t pipe_users;
         struct proc_dir_entry *use_gssp_proc;
+
+        unsigned int gssd_running;
 };
 
 extern int sunrpc_net_id;
diff --git a/net/sunrpc/rpc_pipe.c b/net/sunrpc/rpc_pipe.c
index a9129f8d7070..4679df5a6d50 100644
--- a/net/sunrpc/rpc_pipe.c
+++ b/net/sunrpc/rpc_pipe.c
@@ -216,11 +216,14 @@ rpc_destroy_inode(struct inode *inode)
 static int
 rpc_pipe_open(struct inode *inode, struct file *filp)
 {
+        struct net *net = inode->i_sb->s_fs_info;
+        struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
         struct rpc_pipe *pipe;
         int first_open;
         int res = -ENXIO;
 
         mutex_lock(&inode->i_mutex);
+        sn->gssd_running = 1;
         pipe = RPC_I(inode)->pipe;
         if (pipe == NULL)
                 goto out;
@@ -664,7 +667,8 @@ static struct dentry *__rpc_lookup_create_exclusive(struct dentry *parent,
                         return ERR_PTR(-ENOMEM);
         }
         if (dentry->d_inode == NULL) {
-                d_set_d_op(dentry, &rpc_dentry_operations);
+                if (!dentry->d_op)
+                        d_set_d_op(dentry, &rpc_dentry_operations);
                 return dentry;
         }
         dput(dentry);
@@ -1069,6 +1073,8 @@ void rpc_pipefs_init_net(struct net *net)
         struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
 
         mutex_init(&sn->pipefs_sb_lock);
+        sn->gssd_running = 1;
+        sn->pipe_version = -1;
 }
 
 /*
@@ -1121,6 +1127,7 @@ rpc_fill_super(struct super_block *sb, void *data, int silent)
                 return -ENOMEM;
         dprintk("RPC:       sending pipefs MOUNT notification for net %p%s\n",
                 net, NET_NAME(net));
+        mutex_lock(&sn->pipefs_sb_lock);
         sn->pipefs_sb = sb;
         err = blocking_notifier_call_chain(&rpc_pipefs_notifier_list,
                                            RPC_PIPEFS_MOUNT,
@@ -1128,6 +1135,7 @@ rpc_fill_super(struct super_block *sb, void *data, int silent)
         if (err)
                 goto err_depopulate;
         sb->s_fs_info = get_net(net);
+        mutex_unlock(&sn->pipefs_sb_lock);
         return 0;
 
 err_depopulate:
@@ -1136,6 +1144,7 @@ err_depopulate:
                                            sb);
         sn->pipefs_sb = NULL;
         __rpc_depopulate(root, files, RPCAUTH_lockd, RPCAUTH_RootEOF);
+        mutex_unlock(&sn->pipefs_sb_lock);
         return err;
 }
 
@@ -1157,12 +1166,12 @@ static void rpc_kill_sb(struct super_block *sb)
                 goto out;
         }
         sn->pipefs_sb = NULL;
-        mutex_unlock(&sn->pipefs_sb_lock);
         dprintk("RPC:       sending pipefs UMOUNT notification for net %p%s\n",
                 net, NET_NAME(net));
         blocking_notifier_call_chain(&rpc_pipefs_notifier_list,
                                            RPC_PIPEFS_UMOUNT,
                                            sb);
+        mutex_unlock(&sn->pipefs_sb_lock);
         put_net(net);
 out:
         kill_litter_super(sb);
diff --git a/net/sunrpc/sched.c b/net/sunrpc/sched.c
index f8529fc8e542..b7b32c34c18d 100644
--- a/net/sunrpc/sched.c
+++ b/net/sunrpc/sched.c
@@ -324,11 +324,17 @@ EXPORT_SYMBOL_GPL(__rpc_wait_for_completion_task);
  * Note: If the task is ASYNC, and is being made runnable after sitting on an
  * rpc_wait_queue, this must be called with the queue spinlock held to protect
  * the wait queue operation.
+ * Note the ordering of rpc_test_and_set_running() and rpc_clear_queued(),
+ * which is needed to ensure that __rpc_execute() doesn't loop (due to the
+ * lockless RPC_IS_QUEUED() test) before we've had a chance to test
+ * the RPC_TASK_RUNNING flag.
  */
 static void rpc_make_runnable(struct rpc_task *task)
 {
+        bool need_wakeup = !rpc_test_and_set_running(task);
+
         rpc_clear_queued(task);
-        if (rpc_test_and_set_running(task))
+        if (!need_wakeup)
                 return;
         if (RPC_IS_ASYNC(task)) {
                 INIT_WORK(&task->u.tk_work, rpc_async_schedule);
@@ -440,20 +446,6 @@ static void rpc_wake_up_task_queue_locked(struct rpc_wait_queue *queue, struct r
 }
 
 /*
- * Tests whether rpc queue is empty
- */
-int rpc_queue_empty(struct rpc_wait_queue *queue)
-{
-        int res;
-
-        spin_lock_bh(&queue->lock);
-        res = queue->qlen;
-        spin_unlock_bh(&queue->lock);
-        return res == 0;
-}
-EXPORT_SYMBOL_GPL(rpc_queue_empty);
-
-/*
  * Wake up a task on a specific queue
  */
 void rpc_wake_up_queued_task(struct rpc_wait_queue *queue, struct rpc_task *task)
@@ -798,7 +790,6 @@ static void __rpc_execute(struct rpc_task *task)
                         task->tk_flags |= RPC_TASK_KILLED;
                         rpc_exit(task, -ERESTARTSYS);
                 }
-                rpc_set_running(task);
                 dprintk("RPC: %5u sync task resuming\n", task->tk_pid);
         }
 
@@ -819,9 +810,11 @@ static void __rpc_execute(struct rpc_task *task)
  */
 void rpc_execute(struct rpc_task *task)
 {
+        bool is_async = RPC_IS_ASYNC(task);
+
         rpc_set_active(task);
         rpc_make_runnable(task);
-        if (!RPC_IS_ASYNC(task))
+        if (!is_async)
                 __rpc_execute(task);
 }