4 files changed, 234 insertions, 81 deletions

diff --git a/net/sunrpc/auth_gss/auth_gss.c b/net/sunrpc/auth_gss/auth_gss.c
index 084656671d6e..97912b40c254 100644
--- a/net/sunrpc/auth_gss/auth_gss.c
+++ b/net/sunrpc/auth_gss/auth_gss.c
@@ -420,41 +420,53 @@ static void gss_encode_v0_msg(struct gss_upcall_msg *gss_msg)
         memcpy(gss_msg->databuf, &uid, sizeof(uid));
         gss_msg->msg.data = gss_msg->databuf;
         gss_msg->msg.len = sizeof(uid);
-        BUG_ON(sizeof(uid) > UPCALL_BUF_LEN);
+
+        BUILD_BUG_ON(sizeof(uid) > sizeof(gss_msg->databuf));
 }
 
-static void gss_encode_v1_msg(struct gss_upcall_msg *gss_msg,
+static int gss_encode_v1_msg(struct gss_upcall_msg *gss_msg,
                                 const char *service_name,
                                 const char *target_name)
 {
         struct gss_api_mech *mech = gss_msg->auth->mech;
         char *p = gss_msg->databuf;
-        int len = 0;
-
-        gss_msg->msg.len = sprintf(gss_msg->databuf, "mech=%s uid=%d ",
-                                   mech->gm_name,
-                                   from_kuid(&init_user_ns, gss_msg->uid));
-        p += gss_msg->msg.len;
+        size_t buflen = sizeof(gss_msg->databuf);
+        int len;
+
+        len = scnprintf(p, buflen, "mech=%s uid=%d ", mech->gm_name,
+                        from_kuid(&init_user_ns, gss_msg->uid));
+        buflen -= len;
+        p += len;
+        gss_msg->msg.len = len;
         if (target_name) {
-                len = sprintf(p, "target=%s ", target_name);
+                len = scnprintf(p, buflen, "target=%s ", target_name);
+                buflen -= len;
                 p += len;
                 gss_msg->msg.len += len;
         }
         if (service_name != NULL) {
-                len = sprintf(p, "service=%s ", service_name);
+                len = scnprintf(p, buflen, "service=%s ", service_name);
+                buflen -= len;
                 p += len;
                 gss_msg->msg.len += len;
         }
         if (mech->gm_upcall_enctypes) {
-                len = sprintf(p, "enctypes=%s ", mech->gm_upcall_enctypes);
+                len = scnprintf(p, buflen, "enctypes=%s ",
+                                mech->gm_upcall_enctypes);
+                buflen -= len;
                 p += len;
                 gss_msg->msg.len += len;
         }
-        len = sprintf(p, "\n");
+        len = scnprintf(p, buflen, "\n");
+        if (len == 0)
+                goto out_overflow;
         gss_msg->msg.len += len;
 
         gss_msg->msg.data = gss_msg->databuf;
-        BUG_ON(gss_msg->msg.len > UPCALL_BUF_LEN);
+        return 0;
+out_overflow:
+        WARN_ON_ONCE(1);
+        return -ENOMEM;
 }
 
 static struct gss_upcall_msg *
@@ -463,15 +475,15 @@ gss_alloc_msg(struct gss_auth *gss_auth,
 {
         struct gss_upcall_msg *gss_msg;
         int vers;
+        int err = -ENOMEM;
 
         gss_msg = kzalloc(sizeof(*gss_msg), GFP_NOFS);
         if (gss_msg == NULL)
-                return ERR_PTR(-ENOMEM);
+                goto err;
         vers = get_pipe_version(gss_auth->net);
-        if (vers < 0) {
-                kfree(gss_msg);
-                return ERR_PTR(vers);
-        }
+        err = vers;
+        if (err < 0)
+                goto err_free_msg;
         gss_msg->pipe = gss_auth->gss_pipe[vers]->pipe;
         INIT_LIST_HEAD(&gss_msg->list);
         rpc_init_wait_queue(&gss_msg->rpc_waitqueue, "RPCSEC_GSS upcall waitq");
@@ -482,10 +494,17 @@ gss_alloc_msg(struct gss_auth *gss_auth,
         switch (vers) {
         case 0:
                 gss_encode_v0_msg(gss_msg);
+                break;
         default:
-                gss_encode_v1_msg(gss_msg, service_name, gss_auth->target_name);
+                err = gss_encode_v1_msg(gss_msg, service_name, gss_auth->target_name);
+                if (err)
+                        goto err_free_msg;
         };
         return gss_msg;
+err_free_msg:
+        kfree(gss_msg);
+err:
+        return ERR_PTR(err);
 }
 
 static struct gss_upcall_msg *
diff --git a/net/sunrpc/clnt.c b/net/sunrpc/clnt.c
index 77479606a971..dab09dac8fc7 100644
--- a/net/sunrpc/clnt.c
+++ b/net/sunrpc/clnt.c
@@ -25,12 +25,12 @@
 #include <linux/namei.h>
 #include <linux/mount.h>
 #include <linux/slab.h>
+#include <linux/rcupdate.h>
 #include <linux/utsname.h>
 #include <linux/workqueue.h>
 #include <linux/in.h>
 #include <linux/in6.h>
 #include <linux/un.h>
-#include <linux/rcupdate.h>
 
 #include <linux/sunrpc/clnt.h>
 #include <linux/sunrpc/addr.h>
@@ -264,6 +264,26 @@ void rpc_clients_notifier_unregister(void)
         return rpc_pipefs_notifier_unregister(&rpc_clients_block);
 }
 
+static struct rpc_xprt *rpc_clnt_set_transport(struct rpc_clnt *clnt,
+                struct rpc_xprt *xprt,
+                const struct rpc_timeout *timeout)
+{
+        struct rpc_xprt *old;
+
+        spin_lock(&clnt->cl_lock);
+        old = rcu_dereference_protected(clnt->cl_xprt,
+                        lockdep_is_held(&clnt->cl_lock));
+
+        if (!xprt_bound(xprt))
+                clnt->cl_autobind = 1;
+
+        clnt->cl_timeout = timeout;
+        rcu_assign_pointer(clnt->cl_xprt, xprt);
+        spin_unlock(&clnt->cl_lock);
+
+        return old;
+}
+
 static void rpc_clnt_set_nodename(struct rpc_clnt *clnt, const char *nodename)
 {
         clnt->cl_nodelen = strlen(nodename);
@@ -272,12 +292,13 @@ 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)
+static int rpc_client_register(struct rpc_clnt *clnt,
+                               rpc_authflavor_t pseudoflavor,
+                               const char *client_name)
 {
         struct rpc_auth_create_args auth_args = {
-                .pseudoflavor = args->authflavor,
-                .target_name = args->client_name,
+                .pseudoflavor = pseudoflavor,
+                .target_name = client_name,
         };
         struct rpc_auth *auth;
         struct net *net = rpc_net_ns(clnt);
@@ -298,7 +319,7 @@ static int rpc_client_register(const struct rpc_create_args *args,
         auth = rpcauth_create(&auth_args, clnt);
         if (IS_ERR(auth)) {
                 dprintk("RPC:       Couldn't create auth handle (flavor %u)\n",
-                                args->authflavor);
+                                pseudoflavor);
                 err = PTR_ERR(auth);
                 goto err_auth;
         }
@@ -337,7 +358,8 @@ static struct rpc_clnt * rpc_new_client(const struct rpc_create_args *args,
 {
         const struct rpc_program *program = args->program;
         const struct rpc_version *version;
-        struct rpc_clnt         *clnt = NULL;
+        struct rpc_clnt *clnt = NULL;
+        const struct rpc_timeout *timeout;
         int err;
 
         /* sanity check the name before trying to print it */
@@ -365,7 +387,6 @@ static struct rpc_clnt * rpc_new_client(const struct rpc_create_args *args,
         if (err)
                 goto out_no_clid;
 
-        rcu_assign_pointer(clnt->cl_xprt, xprt);
         clnt->cl_procinfo = version->procs;
         clnt->cl_maxproc  = version->nrprocs;
         clnt->cl_prog     = args->prognumber ? : program->number;
@@ -380,16 +401,15 @@ static struct rpc_clnt * rpc_new_client(const struct rpc_create_args *args,
         INIT_LIST_HEAD(&clnt->cl_tasks);
         spin_lock_init(&clnt->cl_lock);
 
-        if (!xprt_bound(xprt))
-                clnt->cl_autobind = 1;
-
-        clnt->cl_timeout = xprt->timeout;
+        timeout = xprt->timeout;
         if (args->timeout != NULL) {
                 memcpy(&clnt->cl_timeout_default, args->timeout,
                                 sizeof(clnt->cl_timeout_default));
-                clnt->cl_timeout = &clnt->cl_timeout_default;
+                timeout = &clnt->cl_timeout_default;
         }
 
+        rpc_clnt_set_transport(clnt, xprt, timeout);
+
         clnt->cl_rtt = &clnt->cl_rtt_default;
         rpc_init_rtt(&clnt->cl_rtt_default, clnt->cl_timeout->to_initval);
 
@@ -398,7 +418,7 @@ static struct rpc_clnt * rpc_new_client(const struct rpc_create_args *args,
         /* save the nodename */
         rpc_clnt_set_nodename(clnt, utsname()->nodename);
 
-        err = rpc_client_register(args, clnt);
+        err = rpc_client_register(clnt, args->authflavor, args->client_name);
         if (err)
                 goto out_no_path;
         if (parent)
@@ -600,6 +620,80 @@ rpc_clone_client_set_auth(struct rpc_clnt *clnt, rpc_authflavor_t flavor)
 }
 EXPORT_SYMBOL_GPL(rpc_clone_client_set_auth);
 
+/**
+ * rpc_switch_client_transport: switch the RPC transport on the fly
+ * @clnt: pointer to a struct rpc_clnt
+ * @args: pointer to the new transport arguments
+ * @timeout: pointer to the new timeout parameters
+ *
+ * This function allows the caller to switch the RPC transport for the
+ * rpc_clnt structure 'clnt' to allow it to connect to a mirrored NFS
+ * server, for instance.  It assumes that the caller has ensured that
+ * there are no active RPC tasks by using some form of locking.
+ *
+ * Returns zero if "clnt" is now using the new xprt.  Otherwise a
+ * negative errno is returned, and "clnt" continues to use the old
+ * xprt.
+ */
+int rpc_switch_client_transport(struct rpc_clnt *clnt,
+                struct xprt_create *args,
+                const struct rpc_timeout *timeout)
+{
+        const struct rpc_timeout *old_timeo;
+        rpc_authflavor_t pseudoflavor;
+        struct rpc_xprt *xprt, *old;
+        struct rpc_clnt *parent;
+        int err;
+
+        xprt = xprt_create_transport(args);
+        if (IS_ERR(xprt)) {
+                dprintk("RPC:       failed to create new xprt for clnt %p\n",
+                        clnt);
+                return PTR_ERR(xprt);
+        }
+
+        pseudoflavor = clnt->cl_auth->au_flavor;
+
+        old_timeo = clnt->cl_timeout;
+        old = rpc_clnt_set_transport(clnt, xprt, timeout);
+
+        rpc_unregister_client(clnt);
+        __rpc_clnt_remove_pipedir(clnt);
+
+        /*
+         * A new transport was created.  "clnt" therefore
+         * becomes the root of a new cl_parent tree.  clnt's
+         * children, if it has any, still point to the old xprt.
+         */
+        parent = clnt->cl_parent;
+        clnt->cl_parent = clnt;
+
+        /*
+         * The old rpc_auth cache cannot be re-used.  GSS
+         * contexts in particular are between a single
+         * client and server.
+         */
+        err = rpc_client_register(clnt, pseudoflavor, NULL);
+        if (err)
+                goto out_revert;
+
+        synchronize_rcu();
+        if (parent != clnt)
+                rpc_release_client(parent);
+        xprt_put(old);
+        dprintk("RPC:       replaced xprt for clnt %p\n", clnt);
+        return 0;
+
+out_revert:
+        rpc_clnt_set_transport(clnt, old, old_timeo);
+        clnt->cl_parent = parent;
+        rpc_client_register(clnt, pseudoflavor, NULL);
+        xprt_put(xprt);
+        dprintk("RPC:       failed to switch xprt for clnt %p\n", clnt);
+        return err;
+}
+EXPORT_SYMBOL_GPL(rpc_switch_client_transport);
+
 /*
  * Kill all tasks for the given client.
  * XXX: kill their descendants as well?
@@ -772,6 +866,8 @@ void rpc_task_set_client(struct rpc_task *task, struct rpc_clnt *clnt)
                 atomic_inc(&clnt->cl_count);
                 if (clnt->cl_softrtry)
                         task->tk_flags |= RPC_TASK_SOFT;
+                if (clnt->cl_noretranstimeo)
+                        task->tk_flags |= RPC_TASK_NO_RETRANS_TIMEOUT;
                 if (sk_memalloc_socks()) {
                         struct rpc_xprt *xprt;
 
@@ -1690,6 +1786,7 @@ call_connect_status(struct rpc_task *task)
         dprint_status(task);
 
         trace_rpc_connect_status(task, status);
+        task->tk_status = 0;
         switch (status) {
                 /* if soft mounted, test if we've timed out */
         case -ETIMEDOUT:
@@ -1698,12 +1795,14 @@ call_connect_status(struct rpc_task *task)
         case -ECONNREFUSED:
         case -ECONNRESET:
         case -ENETUNREACH:
+                /* retry with existing socket, after a delay */
+                rpc_delay(task, 3*HZ);
                 if (RPC_IS_SOFTCONN(task))
                         break;
-                /* retry with existing socket, after a delay */
-        case 0:
         case -EAGAIN:
-                task->tk_status = 0;
+                task->tk_action = call_bind;
+                return;
+        case 0:
                 clnt->cl_stats->netreconn++;
                 task->tk_action = call_transmit;
                 return;
@@ -1717,13 +1816,14 @@ call_connect_status(struct rpc_task *task)
 static void
 call_transmit(struct rpc_task *task)
 {
+        int is_retrans = RPC_WAS_SENT(task);
+
         dprint_status(task);
 
         task->tk_action = call_status;
         if (task->tk_status < 0)
                 return;
-        task->tk_status = xprt_prepare_transmit(task);
-        if (task->tk_status != 0)
+        if (!xprt_prepare_transmit(task))
                 return;
         task->tk_action = call_transmit_status;
         /* Encode here so that rpcsec_gss can use correct sequence number. */
@@ -1742,6 +1842,8 @@ call_transmit(struct rpc_task *task)
         xprt_transmit(task);
         if (task->tk_status < 0)
                 return;
+        if (is_retrans)
+                task->tk_client->cl_stats->rpcretrans++;
         /*
          * On success, ensure that we call xprt_end_transmit() before sleeping
          * in order to allow access to the socket to other RPC requests.
@@ -1811,8 +1913,7 @@ call_bc_transmit(struct rpc_task *task)
 {
         struct rpc_rqst *req = task->tk_rqstp;
 
-        task->tk_status = xprt_prepare_transmit(task);
-        if (task->tk_status == -EAGAIN) {
+        if (!xprt_prepare_transmit(task)) {
                 /*
                  * Could not reserve the transport. Try again after the
                  * transport is released.
@@ -1900,7 +2001,8 @@ call_status(struct rpc_task *task)
                 rpc_delay(task, 3*HZ);
         case -ETIMEDOUT:
                 task->tk_action = call_timeout;
-                if (task->tk_client->cl_discrtry)
+                if (!(task->tk_flags & RPC_TASK_NO_RETRANS_TIMEOUT)
+                    && task->tk_client->cl_discrtry)
                         xprt_conditional_disconnect(req->rq_xprt,
                                         req->rq_connect_cookie);
                 break;
@@ -1982,7 +2084,6 @@ call_timeout(struct rpc_task *task)
         rpcauth_invalcred(task);
 
 retry:
-        clnt->cl_stats->rpcretrans++;
         task->tk_action = call_bind;
         task->tk_status = 0;
 }
@@ -2025,7 +2126,6 @@ call_decode(struct rpc_task *task)
         if (req->rq_rcv_buf.len < 12) {
                 if (!RPC_IS_SOFT(task)) {
                         task->tk_action = call_bind;
-                        clnt->cl_stats->rpcretrans++;
                         goto out_retry;
                 }
                 dprintk("RPC:       %s: too small RPC reply size (%d bytes)\n",
diff --git a/net/sunrpc/xprt.c b/net/sunrpc/xprt.c
index 095363eee764..04199bc8416f 100644
--- a/net/sunrpc/xprt.c
+++ b/net/sunrpc/xprt.c
@@ -205,10 +205,8 @@ int xprt_reserve_xprt(struct rpc_xprt *xprt, struct rpc_task *task)
                 goto out_sleep;
         }
         xprt->snd_task = task;
-        if (req != NULL) {
-                req->rq_bytes_sent = 0;
+        if (req != NULL)
                 req->rq_ntrans++;
-        }
 
         return 1;
 
@@ -263,7 +261,6 @@ int xprt_reserve_xprt_cong(struct rpc_xprt *xprt, struct rpc_task *task)
         }
         if (__xprt_get_cong(xprt, task)) {
                 xprt->snd_task = task;
-                req->rq_bytes_sent = 0;
                 req->rq_ntrans++;
                 return 1;
         }
@@ -300,10 +297,8 @@ static bool __xprt_lock_write_func(struct rpc_task *task, void *data)
 
         req = task->tk_rqstp;
         xprt->snd_task = task;
-        if (req) {
-                req->rq_bytes_sent = 0;
+        if (req)
                 req->rq_ntrans++;
-        }
         return true;
 }
 
@@ -329,7 +324,6 @@ static bool __xprt_lock_write_cong_func(struct rpc_task *task, void *data)
         }
         if (__xprt_get_cong(xprt, task)) {
                 xprt->snd_task = task;
-                req->rq_bytes_sent = 0;
                 req->rq_ntrans++;
                 return true;
         }
@@ -358,6 +352,11 @@ out_unlock:
 void xprt_release_xprt(struct rpc_xprt *xprt, struct rpc_task *task)
 {
         if (xprt->snd_task == task) {
+                if (task != NULL) {
+                        struct rpc_rqst *req = task->tk_rqstp;
+                        if (req != NULL)
+                                req->rq_bytes_sent = 0;
+                }
                 xprt_clear_locked(xprt);
                 __xprt_lock_write_next(xprt);
         }
@@ -375,6 +374,11 @@ EXPORT_SYMBOL_GPL(xprt_release_xprt);
 void xprt_release_xprt_cong(struct rpc_xprt *xprt, struct rpc_task *task)
 {
         if (xprt->snd_task == task) {
+                if (task != NULL) {
+                        struct rpc_rqst *req = task->tk_rqstp;
+                        if (req != NULL)
+                                req->rq_bytes_sent = 0;
+                }
                 xprt_clear_locked(xprt);
                 __xprt_lock_write_next_cong(xprt);
         }
@@ -854,24 +858,36 @@ static inline int xprt_has_timer(struct rpc_xprt *xprt)
  * @task: RPC task about to send a request
  *
  */
-int xprt_prepare_transmit(struct rpc_task *task)
+bool xprt_prepare_transmit(struct rpc_task *task)
 {
         struct rpc_rqst *req = task->tk_rqstp;
         struct rpc_xprt *xprt = req->rq_xprt;
-        int err = 0;
+        bool ret = false;
 
         dprintk("RPC: %5u xprt_prepare_transmit\n", task->tk_pid);
 
         spin_lock_bh(&xprt->transport_lock);
-        if (req->rq_reply_bytes_recvd && !req->rq_bytes_sent) {
-                err = req->rq_reply_bytes_recvd;
+        if (!req->rq_bytes_sent) {
+                if (req->rq_reply_bytes_recvd) {
+                        task->tk_status = req->rq_reply_bytes_recvd;
+                        goto out_unlock;
+                }
+                if ((task->tk_flags & RPC_TASK_NO_RETRANS_TIMEOUT)
+                    && xprt_connected(xprt)
+                    && req->rq_connect_cookie == xprt->connect_cookie) {
+                        xprt->ops->set_retrans_timeout(task);
+                        rpc_sleep_on(&xprt->pending, task, xprt_timer);
+                        goto out_unlock;
+                }
+        }
+        if (!xprt->ops->reserve_xprt(xprt, task)) {
+                task->tk_status = -EAGAIN;
                 goto out_unlock;
         }
-        if (!xprt->ops->reserve_xprt(xprt, task))
-                err = -EAGAIN;
+        ret = true;
 out_unlock:
         spin_unlock_bh(&xprt->transport_lock);
-        return err;
+        return ret;
 }
 
 void xprt_end_transmit(struct rpc_task *task)
@@ -912,7 +928,6 @@ void xprt_transmit(struct rpc_task *task)
         } else if (!req->rq_bytes_sent)
                 return;
 
-        req->rq_connect_cookie = xprt->connect_cookie;
         req->rq_xtime = ktime_get();
         status = xprt->ops->send_request(task);
         if (status != 0) {
@@ -938,12 +953,14 @@ void xprt_transmit(struct rpc_task *task)
         /* Don't race with disconnect */
         if (!xprt_connected(xprt))
                 task->tk_status = -ENOTCONN;
-        else if (!req->rq_reply_bytes_recvd && rpc_reply_expected(task)) {
+        else {
                 /*
                  * Sleep on the pending queue since
                  * we're expecting a reply.
                  */
-                rpc_sleep_on(&xprt->pending, task, xprt_timer);
+                if (!req->rq_reply_bytes_recvd && rpc_reply_expected(task))
+                        rpc_sleep_on(&xprt->pending, task, xprt_timer);
+                req->rq_connect_cookie = xprt->connect_cookie;
         }
         spin_unlock_bh(&xprt->transport_lock);
 }
@@ -1087,11 +1104,9 @@ struct rpc_xprt *xprt_alloc(struct net *net, size_t size,
         for (i = 0; i < num_prealloc; i++) {
                 req = kzalloc(sizeof(struct rpc_rqst), GFP_KERNEL);
                 if (!req)
-                        break;
+                        goto out_free;
                 list_add(&req->rq_list, &xprt->free);
         }
-        if (i < num_prealloc)
-                goto out_free;
         if (max_alloc > num_prealloc)
                 xprt->max_reqs = max_alloc;
         else
@@ -1186,6 +1201,12 @@ static void xprt_request_init(struct rpc_task *task, struct rpc_xprt *xprt)
         req->rq_xprt    = xprt;
         req->rq_buffer  = NULL;
         req->rq_xid     = xprt_alloc_xid(xprt);
+        req->rq_connect_cookie = xprt->connect_cookie - 1;
+        req->rq_bytes_sent = 0;
+        req->rq_snd_buf.len = 0;
+        req->rq_snd_buf.buflen = 0;
+        req->rq_rcv_buf.len = 0;
+        req->rq_rcv_buf.buflen = 0;
         req->rq_release_snd_buf = NULL;
         xprt_reset_majortimeo(req);
         dprintk("RPC: %5u reserved req %p xid %08x\n", task->tk_pid,
diff --git a/net/sunrpc/xprtsock.c b/net/sunrpc/xprtsock.c
index ee03d35677d9..17c88928b7db 100644
--- a/net/sunrpc/xprtsock.c
+++ b/net/sunrpc/xprtsock.c
@@ -835,6 +835,8 @@ static void xs_close(struct rpc_xprt *xprt)
 
         dprintk("RPC:       xs_close xprt %p\n", xprt);
 
+        cancel_delayed_work_sync(&transport->connect_worker);
+
         xs_reset_transport(transport);
         xprt->reestablish_timeout = 0;
 
@@ -854,14 +856,6 @@ static void xs_tcp_close(struct rpc_xprt *xprt)
                 xs_tcp_shutdown(xprt);
 }
 
-static void xs_local_destroy(struct rpc_xprt *xprt)
-{
-        xs_close(xprt);
-        xs_free_peer_addresses(xprt);
-        xprt_free(xprt);
-        module_put(THIS_MODULE);
-}
-
 /**
  * xs_destroy - prepare to shutdown a transport
  * @xprt: doomed transport
@@ -869,13 +863,12 @@ static void xs_local_destroy(struct rpc_xprt *xprt)
  */
 static void xs_destroy(struct rpc_xprt *xprt)
 {
-        struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
-
         dprintk("RPC:       xs_destroy xprt %p\n", xprt);
 
-        cancel_delayed_work_sync(&transport->connect_worker);
-
-        xs_local_destroy(xprt);
+        xs_close(xprt);
+        xs_free_peer_addresses(xprt);
+        xprt_free(xprt);
+        module_put(THIS_MODULE);
 }
 
 static inline struct rpc_xprt *xprt_from_sock(struct sock *sk)
@@ -1511,6 +1504,7 @@ static void xs_tcp_state_change(struct sock *sk)
                         transport->tcp_copied = 0;
                         transport->tcp_flags =
                                 TCP_RCV_COPY_FRAGHDR | TCP_RCV_COPY_XID;
+                        xprt->connect_cookie++;
 
                         xprt_wake_pending_tasks(xprt, -EAGAIN);
                 }
@@ -1816,6 +1810,10 @@ static inline void xs_reclassify_socket(int family, struct socket *sock)
 }
 #endif
 
+static void xs_dummy_setup_socket(struct work_struct *work)
+{
+}
+
 static struct socket *xs_create_sock(struct rpc_xprt *xprt,
                 struct sock_xprt *transport, int family, int type, int protocol)
 {
@@ -2112,6 +2110,19 @@ static int xs_tcp_finish_connecting(struct rpc_xprt *xprt, struct socket *sock)
 
         if (!transport->inet) {
                 struct sock *sk = sock->sk;
+                unsigned int keepidle = xprt->timeout->to_initval / HZ;
+                unsigned int keepcnt = xprt->timeout->to_retries + 1;
+                unsigned int opt_on = 1;
+
+                /* TCP Keepalive options */
+                kernel_setsockopt(sock, SOL_SOCKET, SO_KEEPALIVE,
+                                (char *)&opt_on, sizeof(opt_on));
+                kernel_setsockopt(sock, SOL_TCP, TCP_KEEPIDLE,
+                                (char *)&keepidle, sizeof(keepidle));
+                kernel_setsockopt(sock, SOL_TCP, TCP_KEEPINTVL,
+                                (char *)&keepidle, sizeof(keepidle));
+                kernel_setsockopt(sock, SOL_TCP, TCP_KEEPCNT,
+                                (char *)&keepcnt, sizeof(keepcnt));
 
                 write_lock_bh(&sk->sk_callback_lock);
 
@@ -2151,7 +2162,6 @@ static int xs_tcp_finish_connecting(struct rpc_xprt *xprt, struct socket *sock)
         case 0:
         case -EINPROGRESS:
                 /* SYN_SENT! */
-                xprt->connect_cookie++;
                 if (xprt->reestablish_timeout < XS_TCP_INIT_REEST_TO)
                         xprt->reestablish_timeout = XS_TCP_INIT_REEST_TO;
         }
@@ -2498,7 +2508,7 @@ static struct rpc_xprt_ops xs_local_ops = {
         .send_request           = xs_local_send_request,
         .set_retrans_timeout    = xprt_set_retrans_timeout_def,
         .close                  = xs_close,
-        .destroy                = xs_local_destroy,
+        .destroy                = xs_destroy,
         .print_stats            = xs_local_print_stats,
 };
 
@@ -2655,6 +2665,9 @@ static struct rpc_xprt *xs_setup_local(struct xprt_create *args)
         xprt->ops = &xs_local_ops;
         xprt->timeout = &xs_local_default_timeout;
 
+        INIT_DELAYED_WORK(&transport->connect_worker,
+                        xs_dummy_setup_socket);
+
         switch (sun->sun_family) {
         case AF_LOCAL:
                 if (sun->sun_path[0] != '/') {
@@ -2859,8 +2872,8 @@ static struct rpc_xprt *xs_setup_bc_tcp(struct xprt_create *args)
         if (args->bc_xprt->xpt_bc_xprt) {
                 /*
                  * This server connection already has a backchannel
-                 * export; we can't create a new one, as we wouldn't be
-                 * able to match replies based on xid any more.  So,
+                 * transport; we can't create a new one, as we wouldn't
+                 * be able to match replies based on xid any more.  So,
                  * reuse the already-existing one:
                  */
                  return args->bc_xprt->xpt_bc_xprt;