1 files changed, 102 insertions, 45 deletions

diff --git a/net/sunrpc/clnt.c b/net/sunrpc/clnt.c
index f17e6153b688..702ede309b06 100644
--- a/net/sunrpc/clnt.c
+++ b/net/sunrpc/clnt.c
@@ -1,5 +1,5 @@
 /*
- *  linux/net/sunrpc/rpcclnt.c
+ *  linux/net/sunrpc/clnt.c
  *
  *  This file contains the high-level RPC interface.
  *  It is modeled as a finite state machine to support both synchronous
@@ -27,7 +27,6 @@
 #include <linux/types.h>
 #include <linux/mm.h>
 #include <linux/slab.h>
-#include <linux/in.h>
 #include <linux/utsname.h>
 
 #include <linux/sunrpc/clnt.h>
@@ -53,6 +52,7 @@ static void	call_allocate(struct rpc_task *task);
 static void     call_encode(struct rpc_task *task);
 static void     call_decode(struct rpc_task *task);
 static void     call_bind(struct rpc_task *task);
+static void     call_bind_status(struct rpc_task *task);
 static void     call_transmit(struct rpc_task *task);
 static void     call_status(struct rpc_task *task);
 static void     call_refresh(struct rpc_task *task);
@@ -517,15 +517,8 @@ void
 rpc_setbufsize(struct rpc_clnt *clnt, unsigned int sndsize, unsigned int rcvsize)
 {
         struct rpc_xprt *xprt = clnt->cl_xprt;
-
-        xprt->sndsize = 0;
-        if (sndsize)
-                xprt->sndsize = sndsize + RPC_SLACK_SPACE;
-        xprt->rcvsize = 0;
-        if (rcvsize)
-                xprt->rcvsize = rcvsize + RPC_SLACK_SPACE;
-        if (xprt_connected(xprt))
-                xprt_sock_setbufsize(xprt);
+        if (xprt->ops->set_buffer_size)
+                xprt->ops->set_buffer_size(xprt, sndsize, rcvsize);
 }
 
 /*
@@ -685,13 +678,11 @@ call_allocate(struct rpc_task *task)
 static void
 call_encode(struct rpc_task *task)
 {
-        struct rpc_clnt *clnt = task->tk_client;
         struct rpc_rqst *req = task->tk_rqstp;
         struct xdr_buf *sndbuf = &req->rq_snd_buf;
         struct xdr_buf *rcvbuf = &req->rq_rcv_buf;
         unsigned int    bufsiz;
         kxdrproc_t      encode;
-        int             status;
         u32             *p;
 
         dprintk("RPC: %4d call_encode (status %d)\n", 
@@ -719,11 +710,15 @@ call_encode(struct rpc_task *task)
                 rpc_exit(task, -EIO);
                 return;
         }
-        if (encode && (status = rpcauth_wrap_req(task, encode, req, p,
-                                                 task->tk_msg.rpc_argp)) < 0) {
-                printk(KERN_WARNING "%s: can't encode arguments: %d\n",
-                                clnt->cl_protname, -status);
-                rpc_exit(task, status);
+        if (encode == NULL)
+                return;
+
+        task->tk_status = rpcauth_wrap_req(task, encode, req, p,
+                        task->tk_msg.rpc_argp);
+        if (task->tk_status == -ENOMEM) {
+                /* XXX: Is this sane? */
+                rpc_delay(task, 3*HZ);
+                task->tk_status = -EAGAIN;
         }
 }
 
@@ -734,43 +729,95 @@ static void
 call_bind(struct rpc_task *task)
 {
         struct rpc_clnt *clnt = task->tk_client;
-        struct rpc_xprt *xprt = clnt->cl_xprt;
-
-        dprintk("RPC: %4d call_bind xprt %p %s connected\n", task->tk_pid,
-                        xprt, (xprt_connected(xprt) ? "is" : "is not"));
 
-        task->tk_action = (xprt_connected(xprt)) ? call_transmit : call_connect;
+        dprintk("RPC: %4d call_bind (status %d)\n",
+                                task->tk_pid, task->tk_status);
 
+        task->tk_action = call_connect;
         if (!clnt->cl_port) {
-                task->tk_action = call_connect;
-                task->tk_timeout = RPC_CONNECT_TIMEOUT;
+                task->tk_action = call_bind_status;
+                task->tk_timeout = task->tk_xprt->bind_timeout;
                 rpc_getport(task, clnt);
         }
 }
 
 /*
- * 4a.  Connect to the RPC server (TCP case)
+ * 4a.  Sort out bind result
+ */
+static void
+call_bind_status(struct rpc_task *task)
+{
+        int status = -EACCES;
+
+        if (task->tk_status >= 0) {
+                dprintk("RPC: %4d call_bind_status (status %d)\n",
+                                        task->tk_pid, task->tk_status);
+                task->tk_status = 0;
+                task->tk_action = call_connect;
+                return;
+        }
+
+        switch (task->tk_status) {
+        case -EACCES:
+                dprintk("RPC: %4d remote rpcbind: RPC program/version unavailable\n",
+                                task->tk_pid);
+                rpc_delay(task, 3*HZ);
+                goto retry_bind;
+        case -ETIMEDOUT:
+                dprintk("RPC: %4d rpcbind request timed out\n",
+                                task->tk_pid);
+                if (RPC_IS_SOFT(task)) {
+                        status = -EIO;
+                        break;
+                }
+                goto retry_bind;
+        case -EPFNOSUPPORT:
+                dprintk("RPC: %4d remote rpcbind service unavailable\n",
+                                task->tk_pid);
+                break;
+        case -EPROTONOSUPPORT:
+                dprintk("RPC: %4d remote rpcbind version 2 unavailable\n",
+                                task->tk_pid);
+                break;
+        default:
+                dprintk("RPC: %4d unrecognized rpcbind error (%d)\n",
+                                task->tk_pid, -task->tk_status);
+                status = -EIO;
+                break;
+        }
+
+        rpc_exit(task, status);
+        return;
+
+retry_bind:
+        task->tk_status = 0;
+        task->tk_action = call_bind;
+        return;
+}
+
+/*
+ * 4b.  Connect to the RPC server
  */
 static void
 call_connect(struct rpc_task *task)
 {
-        struct rpc_clnt *clnt = task->tk_client;
+        struct rpc_xprt *xprt = task->tk_xprt;
 
-        dprintk("RPC: %4d call_connect status %d\n",
-                                task->tk_pid, task->tk_status);
+        dprintk("RPC: %4d call_connect xprt %p %s connected\n",
+                        task->tk_pid, xprt,
+                        (xprt_connected(xprt) ? "is" : "is not"));
 
-        if (xprt_connected(clnt->cl_xprt)) {
-                task->tk_action = call_transmit;
-                return;
+        task->tk_action = call_transmit;
+        if (!xprt_connected(xprt)) {
+                task->tk_action = call_connect_status;
+                if (task->tk_status < 0)
+                        return;
+                xprt_connect(task);
         }
-        task->tk_action = call_connect_status;
-        if (task->tk_status < 0)
-                return;
-        xprt_connect(task);
 }
 
 /*
- * 4b. Sort out connect result
+ * 4c.  Sort out connect result
  */
 static void
 call_connect_status(struct rpc_task *task)
@@ -778,6 +825,9 @@ call_connect_status(struct rpc_task *task)
         struct rpc_clnt *clnt = task->tk_client;
         int status = task->tk_status;
 
+        dprintk("RPC: %5u call_connect_status (status %d)\n", 
+                                task->tk_pid, task->tk_status);
+
         task->tk_status = 0;
         if (status >= 0) {
                 clnt->cl_stats->netreconn++;
@@ -785,17 +835,19 @@ call_connect_status(struct rpc_task *task)
                 return;
         }
 
-        /* Something failed: we may have to rebind */
+        /* Something failed: remote service port may have changed */
         if (clnt->cl_autobind)
                 clnt->cl_port = 0;
+
         switch (status) {
         case -ENOTCONN:
         case -ETIMEDOUT:
         case -EAGAIN:
-                task->tk_action = (clnt->cl_port == 0) ? call_bind : call_connect;
+                task->tk_action = call_bind;
                 break;
         default:
                 rpc_exit(task, -EIO);
+                break;
         }
 }
 
@@ -815,10 +867,12 @@ call_transmit(struct rpc_task *task)
         if (task->tk_status != 0)
                 return;
         /* Encode here so that rpcsec_gss can use correct sequence number. */
-        if (!task->tk_rqstp->rq_bytes_sent)
+        if (task->tk_rqstp->rq_bytes_sent == 0) {
                 call_encode(task);
-        if (task->tk_status < 0)
-                return;
+                /* Did the encode result in an error condition? */
+                if (task->tk_status != 0)
+                        goto out_nosend;
+        }
         xprt_transmit(task);
         if (task->tk_status < 0)
                 return;
@@ -826,6 +880,10 @@ call_transmit(struct rpc_task *task)
                 task->tk_action = NULL;
                 rpc_wake_up_task(task);
         }
+        return;
+out_nosend:
+        /* release socket write lock before attempting to handle error */
+        xprt_abort_transmit(task);
 }
 
 /*
@@ -1020,13 +1078,12 @@ static u32 *
 call_header(struct rpc_task *task)
 {
         struct rpc_clnt *clnt = task->tk_client;
-        struct rpc_xprt *xprt = clnt->cl_xprt;
         struct rpc_rqst *req = task->tk_rqstp;
         u32             *p = req->rq_svec[0].iov_base;
 
         /* FIXME: check buffer size? */
-        if (xprt->stream)
-                *p++ = 0;               /* fill in later */
+
+        p = xprt_skip_transport_header(task->tk_xprt, p);
         *p++ = req->rq_xid;             /* XID */
         *p++ = htonl(RPC_CALL);         /* CALL */
         *p++ = htonl(RPC_VERSION);      /* RPC version */