Merge tag 'nfs-for-3.10-1' of git://git.linux-nfs.org/projects/trondmy/linux-nfs

Pull NFS client bugfixes and cleanups from Trond Myklebust:

 - NLM: stable fix for NFSv2/v3 blocking locks

 - NFSv4.x: stable fixes for the delegation recall error handling code

 - NFSv4.x: Security flavour negotiation fixes and cleanups by Chuck
   Lever

 - SUNRPC: A number of RPCSEC_GSS fixes and cleanups also from Chuck

 - NFSv4.x assorted state management and reboot recovery bugfixes

 - NFSv4.1: In cases where we have already looked up a file, and hold a
   valid filehandle, use the new open-by-filehandle operation instead of
   opening by name.

 - Allow the NFSv4.1 callback thread to freeze

 - NFSv4.x: ensure that file unlock waits for readahead to complete

 - NFSv4.1: ensure that the RPC layer doesn't override the NFS session
   table size negotiation by limiting the number of slots.

 - NFSv4.x: Fix SETATTR spec compatibility issues

* tag 'nfs-for-3.10-1' of git://git.linux-nfs.org/projects/trondmy/linux-nfs: (67 commits)
  NFSv4: Warn once about servers that incorrectly apply open mode to setattr
  NFSv4: Servers should only check SETATTR stateid open mode on size change
  NFSv4: Don't recheck permissions on open in case of recovery cached open
  NFSv4.1: Don't do a delegated open for NFS4_OPEN_CLAIM_DELEG_CUR_FH modes
  NFSv4.1: Use the more efficient open_noattr call for open-by-filehandle
  NFS: Retry SETCLIENTID with AUTH_SYS instead of AUTH_NONE
  NFSv4: Ensure that we clear the NFS_OPEN_STATE flag when appropriate
  LOCKD: Ensure that nlmclnt_block resets block->b_status after a server reboot
  NFSv4: Ensure the LOCK call cannot use the delegation stateid
  NFSv4: Use the open stateid if the delegation has the wrong mode
  nfs: Send atime and mtime as a 64bit value
  NFSv4: Record the OPEN create mode used in the nfs4_opendata structure
  NFSv4.1: Set the RPC_CLNT_CREATE_INFINITE_SLOTS flag for NFSv4.1 transports
  SUNRPC: Allow rpc_create() to request that TCP slots be unlimited
  SUNRPC: Fix a livelock problem in the xprt->backlog queue
  NFSv4: Fix handling of revoked delegations by setattr
  NFSv4 release the sequence id in the return on close case
  nfs: remove unnecessary check for NULL inode->i_flock from nfs_delegation_claim_locks
  NFS: Ensure that NFS file unlock waits for readahead to complete
  NFS: Add functionality to allow waiting on all outstanding reads to complete
  ...

9 files changed, 275 insertions, 52 deletions

diff --git a/net/sunrpc/Kconfig b/net/sunrpc/Kconfig
index 516fe2caac2c..241b54f30204 100644
--- a/net/sunrpc/Kconfig
+++ b/net/sunrpc/Kconfig
@@ -3,6 +3,7 @@ config SUNRPC
 
 config SUNRPC_GSS
         tristate
+        select OID_REGISTRY
 
 config SUNRPC_BACKCHANNEL
         bool
@@ -24,7 +25,6 @@ config SUNRPC_XPRT_RDMA
 config SUNRPC_SWAP
         bool
         depends on SUNRPC
-        select NETVM
 
 config RPCSEC_GSS_KRB5
         tristate "Secure RPC: Kerberos V mechanism"
diff --git a/net/sunrpc/auth.c b/net/sunrpc/auth.c
index f5294047df77..ed2fdd210c0b 100644
--- a/net/sunrpc/auth.c
+++ b/net/sunrpc/auth.c
@@ -82,7 +82,7 @@ MODULE_PARM_DESC(auth_hashtable_size, "RPC credential cache hashtable size");
 
 static u32
 pseudoflavor_to_flavor(u32 flavor) {
-        if (flavor >= RPC_AUTH_MAXFLAVOR)
+        if (flavor > RPC_AUTH_MAXFLAVOR)
                 return RPC_AUTH_GSS;
         return flavor;
 }
@@ -124,6 +124,79 @@ rpcauth_unregister(const struct rpc_authops *ops)
 EXPORT_SYMBOL_GPL(rpcauth_unregister);
 
 /**
+ * rpcauth_get_pseudoflavor - check if security flavor is supported
+ * @flavor: a security flavor
+ * @info: a GSS mech OID, quality of protection, and service value
+ *
+ * Verifies that an appropriate kernel module is available or already loaded.
+ * Returns an equivalent pseudoflavor, or RPC_AUTH_MAXFLAVOR if "flavor" is
+ * not supported locally.
+ */
+rpc_authflavor_t
+rpcauth_get_pseudoflavor(rpc_authflavor_t flavor, struct rpcsec_gss_info *info)
+{
+        const struct rpc_authops *ops;
+        rpc_authflavor_t pseudoflavor;
+
+        ops = auth_flavors[flavor];
+        if (ops == NULL)
+                request_module("rpc-auth-%u", flavor);
+        spin_lock(&rpc_authflavor_lock);
+        ops = auth_flavors[flavor];
+        if (ops == NULL || !try_module_get(ops->owner)) {
+                spin_unlock(&rpc_authflavor_lock);
+                return RPC_AUTH_MAXFLAVOR;
+        }
+        spin_unlock(&rpc_authflavor_lock);
+
+        pseudoflavor = flavor;
+        if (ops->info2flavor != NULL)
+                pseudoflavor = ops->info2flavor(info);
+
+        module_put(ops->owner);
+        return pseudoflavor;
+}
+EXPORT_SYMBOL_GPL(rpcauth_get_pseudoflavor);
+
+/**
+ * rpcauth_get_gssinfo - find GSS tuple matching a GSS pseudoflavor
+ * @pseudoflavor: GSS pseudoflavor to match
+ * @info: rpcsec_gss_info structure to fill in
+ *
+ * Returns zero and fills in "info" if pseudoflavor matches a
+ * supported mechanism.
+ */
+int
+rpcauth_get_gssinfo(rpc_authflavor_t pseudoflavor, struct rpcsec_gss_info *info)
+{
+        rpc_authflavor_t flavor = pseudoflavor_to_flavor(pseudoflavor);
+        const struct rpc_authops *ops;
+        int result;
+
+        if (flavor >= RPC_AUTH_MAXFLAVOR)
+                return -EINVAL;
+
+        ops = auth_flavors[flavor];
+        if (ops == NULL)
+                request_module("rpc-auth-%u", flavor);
+        spin_lock(&rpc_authflavor_lock);
+        ops = auth_flavors[flavor];
+        if (ops == NULL || !try_module_get(ops->owner)) {
+                spin_unlock(&rpc_authflavor_lock);
+                return -ENOENT;
+        }
+        spin_unlock(&rpc_authflavor_lock);
+
+        result = -ENOENT;
+        if (ops->flavor2info != NULL)
+                result = ops->flavor2info(pseudoflavor, info);
+
+        module_put(ops->owner);
+        return result;
+}
+EXPORT_SYMBOL_GPL(rpcauth_get_gssinfo);
+
+/**
  * rpcauth_list_flavors - discover registered flavors and pseudoflavors
  * @array: array to fill in
  * @size: size of "array"
diff --git a/net/sunrpc/auth_gss/auth_gss.c b/net/sunrpc/auth_gss/auth_gss.c
index 5257d2982ba5..51415b07174e 100644
--- a/net/sunrpc/auth_gss/auth_gss.c
+++ b/net/sunrpc/auth_gss/auth_gss.c
@@ -1641,6 +1641,8 @@ static const struct rpc_authops authgss_ops = {
         .pipes_create   = gss_pipes_dentries_create,
         .pipes_destroy  = gss_pipes_dentries_destroy,
         .list_pseudoflavors = gss_mech_list_pseudoflavors,
+        .info2flavor    = gss_mech_info2flavor,
+        .flavor2info    = gss_mech_flavor2info,
 };
 
 static const struct rpc_credops gss_credops = {
@@ -1733,6 +1735,7 @@ static void __exit exit_rpcsec_gss(void)
         rcu_barrier(); /* Wait for completion of call_rcu()'s */
 }
 
+MODULE_ALIAS("rpc-auth-6");
 MODULE_LICENSE("GPL");
 module_param_named(expired_cred_retry_delay,
                    gss_expired_cred_retry_delay,
diff --git a/net/sunrpc/auth_gss/gss_krb5_mech.c b/net/sunrpc/auth_gss/gss_krb5_mech.c
index d3611f11a8df..33255ff889c0 100644
--- a/net/sunrpc/auth_gss/gss_krb5_mech.c
+++ b/net/sunrpc/auth_gss/gss_krb5_mech.c
@@ -729,16 +729,19 @@ static const struct gss_api_ops gss_kerberos_ops = {
 static struct pf_desc gss_kerberos_pfs[] = {
         [0] = {
                 .pseudoflavor = RPC_AUTH_GSS_KRB5,
+                .qop = GSS_C_QOP_DEFAULT,
                 .service = RPC_GSS_SVC_NONE,
                 .name = "krb5",
         },
         [1] = {
                 .pseudoflavor = RPC_AUTH_GSS_KRB5I,
+                .qop = GSS_C_QOP_DEFAULT,
                 .service = RPC_GSS_SVC_INTEGRITY,
                 .name = "krb5i",
         },
         [2] = {
                 .pseudoflavor = RPC_AUTH_GSS_KRB5P,
+                .qop = GSS_C_QOP_DEFAULT,
                 .service = RPC_GSS_SVC_PRIVACY,
                 .name = "krb5p",
         },
@@ -750,11 +753,12 @@ MODULE_ALIAS("rpc-auth-gss-krb5p");
 MODULE_ALIAS("rpc-auth-gss-390003");
 MODULE_ALIAS("rpc-auth-gss-390004");
 MODULE_ALIAS("rpc-auth-gss-390005");
+MODULE_ALIAS("rpc-auth-gss-1.2.840.113554.1.2.2");
 
 static struct gss_api_mech gss_kerberos_mech = {
         .gm_name        = "krb5",
         .gm_owner       = THIS_MODULE,
-        .gm_oid         = {9, (void *)"\x2a\x86\x48\x86\xf7\x12\x01\x02\x02"},
+        .gm_oid         = { 9, "\x2a\x86\x48\x86\xf7\x12\x01\x02\x02" },
         .gm_ops         = &gss_kerberos_ops,
         .gm_pf_num      = ARRAY_SIZE(gss_kerberos_pfs),
         .gm_pfs         = gss_kerberos_pfs,
diff --git a/net/sunrpc/auth_gss/gss_mech_switch.c b/net/sunrpc/auth_gss/gss_mech_switch.c
index f0f4eee63a35..79881d6e68a1 100644
--- a/net/sunrpc/auth_gss/gss_mech_switch.c
+++ b/net/sunrpc/auth_gss/gss_mech_switch.c
@@ -36,6 +36,7 @@
 #include <linux/types.h>
 #include <linux/slab.h>
 #include <linux/module.h>
+#include <linux/oid_registry.h>
 #include <linux/sunrpc/msg_prot.h>
 #include <linux/sunrpc/gss_asn1.h>
 #include <linux/sunrpc/auth_gss.h>
@@ -102,8 +103,13 @@ out:
         return status;
 }
 
-int
-gss_mech_register(struct gss_api_mech *gm)
+/**
+ * gss_mech_register - register a GSS mechanism
+ * @gm: GSS mechanism handle
+ *
+ * Returns zero if successful, or a negative errno.
+ */
+int gss_mech_register(struct gss_api_mech *gm)
 {
         int status;
 
@@ -116,11 +122,14 @@ gss_mech_register(struct gss_api_mech *gm)
         dprintk("RPC:       registered gss mechanism %s\n", gm->gm_name);
         return 0;
 }
-
 EXPORT_SYMBOL_GPL(gss_mech_register);
 
-void
-gss_mech_unregister(struct gss_api_mech *gm)
+/**
+ * gss_mech_unregister - release a GSS mechanism
+ * @gm: GSS mechanism handle
+ *
+ */
+void gss_mech_unregister(struct gss_api_mech *gm)
 {
         spin_lock(&registered_mechs_lock);
         list_del(&gm->gm_list);
@@ -128,18 +137,14 @@ gss_mech_unregister(struct gss_api_mech *gm)
         dprintk("RPC:       unregistered gss mechanism %s\n", gm->gm_name);
         gss_mech_free(gm);
 }
-
 EXPORT_SYMBOL_GPL(gss_mech_unregister);
 
-struct gss_api_mech *
-gss_mech_get(struct gss_api_mech *gm)
+static struct gss_api_mech *gss_mech_get(struct gss_api_mech *gm)
 {
         __module_get(gm->gm_owner);
         return gm;
 }
 
-EXPORT_SYMBOL_GPL(gss_mech_get);
-
 static struct gss_api_mech *
 _gss_mech_get_by_name(const char *name)
 {
@@ -169,12 +174,16 @@ struct gss_api_mech * gss_mech_get_by_name(const char *name)
         }
         return gm;
 }
-EXPORT_SYMBOL_GPL(gss_mech_get_by_name);
 
-struct gss_api_mech *
-gss_mech_get_by_OID(struct xdr_netobj *obj)
+static struct gss_api_mech *gss_mech_get_by_OID(struct rpcsec_gss_oid *obj)
 {
         struct gss_api_mech     *pos, *gm = NULL;
+        char buf[32];
+
+        if (sprint_oid(obj->data, obj->len, buf, sizeof(buf)) < 0)
+                return NULL;
+        dprintk("RPC:       %s(%s)\n", __func__, buf);
+        request_module("rpc-auth-gss-%s", buf);
 
         spin_lock(&registered_mechs_lock);
         list_for_each_entry(pos, &registered_mechs, gm_list) {
@@ -188,11 +197,8 @@ gss_mech_get_by_OID(struct xdr_netobj *obj)
         }
         spin_unlock(&registered_mechs_lock);
         return gm;
-
 }
 
-EXPORT_SYMBOL_GPL(gss_mech_get_by_OID);
-
 static inline int
 mech_supports_pseudoflavor(struct gss_api_mech *gm, u32 pseudoflavor)
 {
@@ -237,8 +243,6 @@ gss_mech_get_by_pseudoflavor(u32 pseudoflavor)
         return gm;
 }
 
-EXPORT_SYMBOL_GPL(gss_mech_get_by_pseudoflavor);
-
 /**
  * gss_mech_list_pseudoflavors - Discover registered GSS pseudoflavors
  * @array: array to fill in
@@ -268,19 +272,82 @@ int gss_mech_list_pseudoflavors(rpc_authflavor_t *array_ptr, int size)
         return i;
 }
 
-u32
-gss_svc_to_pseudoflavor(struct gss_api_mech *gm, u32 service)
+/**
+ * gss_svc_to_pseudoflavor - map a GSS service number to a pseudoflavor
+ * @gm: GSS mechanism handle
+ * @qop: GSS quality-of-protection value
+ * @service: GSS service value
+ *
+ * Returns a matching security flavor, or RPC_AUTH_MAXFLAVOR if none is found.
+ */
+rpc_authflavor_t gss_svc_to_pseudoflavor(struct gss_api_mech *gm, u32 qop,
+                                         u32 service)
 {
         int i;
 
         for (i = 0; i < gm->gm_pf_num; i++) {
-                if (gm->gm_pfs[i].service == service) {
+                if (gm->gm_pfs[i].qop == qop &&
+                    gm->gm_pfs[i].service == service) {
                         return gm->gm_pfs[i].pseudoflavor;
                 }
         }
-        return RPC_AUTH_MAXFLAVOR; /* illegal value */
+        return RPC_AUTH_MAXFLAVOR;
+}
+
+/**
+ * gss_mech_info2flavor - look up a pseudoflavor given a GSS tuple
+ * @info: a GSS mech OID, quality of protection, and service value
+ *
+ * Returns a matching pseudoflavor, or RPC_AUTH_MAXFLAVOR if the tuple is
+ * not supported.
+ */
+rpc_authflavor_t gss_mech_info2flavor(struct rpcsec_gss_info *info)
+{
+        rpc_authflavor_t pseudoflavor;
+        struct gss_api_mech *gm;
+
+        gm = gss_mech_get_by_OID(&info->oid);
+        if (gm == NULL)
+                return RPC_AUTH_MAXFLAVOR;
+
+        pseudoflavor = gss_svc_to_pseudoflavor(gm, info->qop, info->service);
+
+        gss_mech_put(gm);
+        return pseudoflavor;
+}
+
+/**
+ * gss_mech_flavor2info - look up a GSS tuple for a given pseudoflavor
+ * @pseudoflavor: GSS pseudoflavor to match
+ * @info: rpcsec_gss_info structure to fill in
+ *
+ * Returns zero and fills in "info" if pseudoflavor matches a
+ * supported mechanism.  Otherwise a negative errno is returned.
+ */
+int gss_mech_flavor2info(rpc_authflavor_t pseudoflavor,
+                         struct rpcsec_gss_info *info)
+{
+        struct gss_api_mech *gm;
+        int i;
+
+        gm = gss_mech_get_by_pseudoflavor(pseudoflavor);
+        if (gm == NULL)
+                return -ENOENT;
+
+        for (i = 0; i < gm->gm_pf_num; i++) {
+                if (gm->gm_pfs[i].pseudoflavor == pseudoflavor) {
+                        memcpy(info->oid.data, gm->gm_oid.data, gm->gm_oid.len);
+                        info->oid.len = gm->gm_oid.len;
+                        info->qop = gm->gm_pfs[i].qop;
+                        info->service = gm->gm_pfs[i].service;
+                        gss_mech_put(gm);
+                        return 0;
+                }
+        }
+
+        gss_mech_put(gm);
+        return -ENOENT;
 }
-EXPORT_SYMBOL_GPL(gss_svc_to_pseudoflavor);
 
 u32
 gss_pseudoflavor_to_service(struct gss_api_mech *gm, u32 pseudoflavor)
@@ -294,8 +361,6 @@ gss_pseudoflavor_to_service(struct gss_api_mech *gm, u32 pseudoflavor)
         return 0;
 }
 
-EXPORT_SYMBOL_GPL(gss_pseudoflavor_to_service);
-
 char *
 gss_service_to_auth_domain_name(struct gss_api_mech *gm, u32 service)
 {
@@ -308,8 +373,6 @@ gss_service_to_auth_domain_name(struct gss_api_mech *gm, u32 service)
         return NULL;
 }
 
-EXPORT_SYMBOL_GPL(gss_service_to_auth_domain_name);
-
 void
 gss_mech_put(struct gss_api_mech * gm)
 {
@@ -317,8 +380,6 @@ gss_mech_put(struct gss_api_mech * gm)
                 module_put(gm->gm_owner);
 }
 
-EXPORT_SYMBOL_GPL(gss_mech_put);
-
 /* The mech could probably be determined from the token instead, but it's just
  * as easy for now to pass it in. */
 int
diff --git a/net/sunrpc/auth_gss/svcauth_gss.c b/net/sunrpc/auth_gss/svcauth_gss.c
index 5ead60550895..c3ba570222dc 100644
--- a/net/sunrpc/auth_gss/svcauth_gss.c
+++ b/net/sunrpc/auth_gss/svcauth_gss.c
@@ -1220,7 +1220,9 @@ svcauth_gss_accept(struct svc_rqst *rqstp, __be32 *authp)
                 svcdata->rsci = rsci;
                 cache_get(&rsci->h);
                 rqstp->rq_cred.cr_flavor = gss_svc_to_pseudoflavor(
-                                        rsci->mechctx->mech_type, gc->gc_svc);
+                                        rsci->mechctx->mech_type,
+                                        GSS_C_QOP_DEFAULT,
+                                        gc->gc_svc);
                 ret = SVC_OK;
                 goto out;
         }
diff --git a/net/sunrpc/clnt.c b/net/sunrpc/clnt.c
index d5f35f15af98..d259fa966927 100644
--- a/net/sunrpc/clnt.c
+++ b/net/sunrpc/clnt.c
@@ -411,6 +411,8 @@ struct rpc_clnt *rpc_create(struct rpc_create_args *args)
         };
         char servername[48];
 
+        if (args->flags & RPC_CLNT_CREATE_INFINITE_SLOTS)
+                xprtargs.flags |= XPRT_CREATE_INFINITE_SLOTS;
         /*
          * If the caller chooses not to specify a hostname, whip
          * up a string representation of the passed-in address.
@@ -1301,6 +1303,8 @@ call_reserve(struct rpc_task *task)
         xprt_reserve(task);
 }
 
+static void call_retry_reserve(struct rpc_task *task);
+
 /*
  * 1b.  Grok the result of xprt_reserve()
  */
@@ -1342,7 +1346,7 @@ call_reserveresult(struct rpc_task *task)
         case -ENOMEM:
                 rpc_delay(task, HZ >> 2);
         case -EAGAIN:   /* woken up; retry */
-                task->tk_action = call_reserve;
+                task->tk_action = call_retry_reserve;
                 return;
         case -EIO:      /* probably a shutdown */
                 break;
@@ -1355,6 +1359,19 @@ call_reserveresult(struct rpc_task *task)
 }
 
 /*
+ * 1c.  Retry reserving an RPC call slot
+ */
+static void
+call_retry_reserve(struct rpc_task *task)
+{
+        dprint_status(task);
+
+        task->tk_status  = 0;
+        task->tk_action  = call_reserveresult;
+        xprt_retry_reserve(task);
+}
+
+/*
  * 2.   Bind and/or refresh the credentials
  */
 static void
@@ -1639,22 +1656,26 @@ call_connect_status(struct rpc_task *task)
 
         dprint_status(task);
 
-        task->tk_status = 0;
-        if (status >= 0 || status == -EAGAIN) {
-                clnt->cl_stats->netreconn++;
-                task->tk_action = call_transmit;
-                return;
-        }
-
         trace_rpc_connect_status(task, status);
         switch (status) {
                 /* if soft mounted, test if we've timed out */
         case -ETIMEDOUT:
                 task->tk_action = call_timeout;
-                break;
-        default:
-                rpc_exit(task, -EIO);
+                return;
+        case -ECONNREFUSED:
+        case -ECONNRESET:
+        case -ENETUNREACH:
+                if (RPC_IS_SOFTCONN(task))
+                        break;
+                /* retry with existing socket, after a delay */
+        case 0:
+        case -EAGAIN:
+                task->tk_status = 0;
+                clnt->cl_stats->netreconn++;
+                task->tk_action = call_transmit;
+                return;
         }
+        rpc_exit(task, status);
 }
 
 /*
diff --git a/net/sunrpc/xprt.c b/net/sunrpc/xprt.c
index b7478d5e7ffd..745fca3cfd36 100644
--- a/net/sunrpc/xprt.c
+++ b/net/sunrpc/xprt.c
@@ -948,6 +948,34 @@ void xprt_transmit(struct rpc_task *task)
         spin_unlock_bh(&xprt->transport_lock);
 }
 
+static void xprt_add_backlog(struct rpc_xprt *xprt, struct rpc_task *task)
+{
+        set_bit(XPRT_CONGESTED, &xprt->state);
+        rpc_sleep_on(&xprt->backlog, task, NULL);
+}
+
+static void xprt_wake_up_backlog(struct rpc_xprt *xprt)
+{
+        if (rpc_wake_up_next(&xprt->backlog) == NULL)
+                clear_bit(XPRT_CONGESTED, &xprt->state);
+}
+
+static bool xprt_throttle_congested(struct rpc_xprt *xprt, struct rpc_task *task)
+{
+        bool ret = false;
+
+        if (!test_bit(XPRT_CONGESTED, &xprt->state))
+                goto out;
+        spin_lock(&xprt->reserve_lock);
+        if (test_bit(XPRT_CONGESTED, &xprt->state)) {
+                rpc_sleep_on(&xprt->backlog, task, NULL);
+                ret = true;
+        }
+        spin_unlock(&xprt->reserve_lock);
+out:
+        return ret;
+}
+
 static struct rpc_rqst *xprt_dynamic_alloc_slot(struct rpc_xprt *xprt, gfp_t gfp_flags)
 {
         struct rpc_rqst *req = ERR_PTR(-EAGAIN);
@@ -992,7 +1020,7 @@ void xprt_alloc_slot(struct rpc_xprt *xprt, struct rpc_task *task)
                 task->tk_status = -ENOMEM;
                 break;
         case -EAGAIN:
-                rpc_sleep_on(&xprt->backlog, task, NULL);
+                xprt_add_backlog(xprt, task);
                 dprintk("RPC:       waiting for request slot\n");
         default:
                 task->tk_status = -EAGAIN;
@@ -1028,7 +1056,7 @@ static void xprt_free_slot(struct rpc_xprt *xprt, struct rpc_rqst *req)
                 memset(req, 0, sizeof(*req));   /* mark unused */
                 list_add(&req->rq_list, &xprt->free);
         }
-        rpc_wake_up_next(&xprt->backlog);
+        xprt_wake_up_backlog(xprt);
         spin_unlock(&xprt->reserve_lock);
 }
 
@@ -1092,7 +1120,8 @@ EXPORT_SYMBOL_GPL(xprt_free);
  * xprt_reserve - allocate an RPC request slot
  * @task: RPC task requesting a slot allocation
  *
- * If no more slots are available, place the task on the transport's
+ * If the transport is marked as being congested, or if no more
+ * slots are available, place the task on the transport's
  * backlog queue.
  */
 void xprt_reserve(struct rpc_task *task)
@@ -1107,6 +1136,32 @@ void xprt_reserve(struct rpc_task *task)
         task->tk_status = -EAGAIN;
         rcu_read_lock();
         xprt = rcu_dereference(task->tk_client->cl_xprt);
+        if (!xprt_throttle_congested(xprt, task))
+                xprt->ops->alloc_slot(xprt, task);
+        rcu_read_unlock();
+}
+
+/**
+ * xprt_retry_reserve - allocate an RPC request slot
+ * @task: RPC task requesting a slot allocation
+ *
+ * If no more slots are available, place the task on the transport's
+ * backlog queue.
+ * Note that the only difference with xprt_reserve is that we now
+ * ignore the value of the XPRT_CONGESTED flag.
+ */
+void xprt_retry_reserve(struct rpc_task *task)
+{
+        struct rpc_xprt *xprt;
+
+        task->tk_status = 0;
+        if (task->tk_rqstp != NULL)
+                return;
+
+        task->tk_timeout = 0;
+        task->tk_status = -EAGAIN;
+        rcu_read_lock();
+        xprt = rcu_dereference(task->tk_client->cl_xprt);
         xprt->ops->alloc_slot(xprt, task);
         rcu_read_unlock();
 }
diff --git a/net/sunrpc/xprtsock.c b/net/sunrpc/xprtsock.c
index 3d02130828da..9c2825827dec 100644
--- a/net/sunrpc/xprtsock.c
+++ b/net/sunrpc/xprtsock.c
@@ -2207,10 +2207,6 @@ static void xs_tcp_setup_socket(struct work_struct *work)
                  */
                 xs_tcp_force_close(xprt);
                 break;
-        case -ECONNREFUSED:
-        case -ECONNRESET:
-        case -ENETUNREACH:
-                /* retry with existing socket, after a delay */
         case 0:
         case -EINPROGRESS:
         case -EALREADY:
@@ -2221,6 +2217,10 @@ static void xs_tcp_setup_socket(struct work_struct *work)
                 /* Happens, for instance, if the user specified a link
                  * local IPv6 address without a scope-id.
                  */
+        case -ECONNREFUSED:
+        case -ECONNRESET:
+        case -ENETUNREACH:
+                /* retry with existing socket, after a delay */
                 goto out;
         }
 out_eagain:
@@ -2767,9 +2767,13 @@ static struct rpc_xprt *xs_setup_tcp(struct xprt_create *args)
         struct rpc_xprt *xprt;
         struct sock_xprt *transport;
         struct rpc_xprt *ret;
+        unsigned int max_slot_table_size = xprt_max_tcp_slot_table_entries;
+
+        if (args->flags & XPRT_CREATE_INFINITE_SLOTS)
+                max_slot_table_size = RPC_MAX_SLOT_TABLE_LIMIT;
 
         xprt = xs_setup_xprt(args, xprt_tcp_slot_table_entries,
-                        xprt_max_tcp_slot_table_entries);
+                        max_slot_table_size);
         if (IS_ERR(xprt))
                 return xprt;
         transport = container_of(xprt, struct sock_xprt, xprt);