SUNRPC: Refactor xprt_request_wait_receive()

Convert the transport callback to actually put the request to sleep
instead of just setting a timeout. This is in preparation for
rpc_sleep_on_timeout().

Signed-off-by: Trond Myklebust <trond.myklebust@hammerspace.com>
Signed-off-by: Anna Schumaker <Anna.Schumaker@Netapp.com>

diff --git a/include/linux/sunrpc/xprt.h b/include/linux/sunrpc/xprt.h
index 3a391544299e8dc1c39f85cb4d81ff491391c7d5..a6d9fce7f20ebd146d1160a665667ba1239d1f48 100644 (file)
--- a/include/linux/sunrpc/xprt.h
+++ b/include/linux/sunrpc/xprt.h
@@ -143,7 +143,7 @@ struct rpc_xprt_ops {
        void            (*buf_free)(struct rpc_task *task);
        void            (*prepare_request)(struct rpc_rqst *req);
        int             (*send_request)(struct rpc_rqst *req);
-       void            (*set_retrans_timeout)(struct rpc_task *task);
+       void            (*wait_for_reply_request)(struct rpc_task *task);
        void            (*timer)(struct rpc_xprt *xprt, struct rpc_task *task);
        void            (*release_request)(struct rpc_task *task);
        void            (*close)(struct rpc_xprt *xprt);
@@ -378,8 +378,8 @@ xprt_disable_swap(struct rpc_xprt *xprt)
 int                    xprt_register_transport(struct xprt_class *type);
 int                    xprt_unregister_transport(struct xprt_class *type);
 int                    xprt_load_transport(const char *);
-void                   xprt_set_retrans_timeout_def(struct rpc_task *task);
-void                   xprt_set_retrans_timeout_rtt(struct rpc_task *task);
+void                   xprt_wait_for_reply_request_def(struct rpc_task *task);
+void                   xprt_wait_for_reply_request_rtt(struct rpc_task *task);
 void                   xprt_wake_pending_tasks(struct rpc_xprt *xprt, int status);
 void                   xprt_wait_for_buffer_space(struct rpc_xprt *xprt);
 bool                   xprt_write_space(struct rpc_xprt *xprt);

diff --git a/net/sunrpc/xprt.c b/net/sunrpc/xprt.c
index 3a4156cb0134522513abb5f82371dc7003c0dd2d..5afffa669d048a56bf5f6ff02b966b3bc6e0508a 100644 (file)
--- a/net/sunrpc/xprt.c
+++ b/net/sunrpc/xprt.c
@@ -554,41 +554,6 @@ bool xprt_write_space(struct rpc_xprt *xprt)
 }
 EXPORT_SYMBOL_GPL(xprt_write_space);
 
-/**
- * xprt_set_retrans_timeout_def - set a request's retransmit timeout
- * @task: task whose timeout is to be set
- *
- * Set a request's retransmit timeout based on the transport's
- * default timeout parameters.  Used by transports that don't adjust
- * the retransmit timeout based on round-trip time estimation.
- */
-void xprt_set_retrans_timeout_def(struct rpc_task *task)
-{
-       task->tk_timeout = task->tk_rqstp->rq_timeout;
-}
-EXPORT_SYMBOL_GPL(xprt_set_retrans_timeout_def);
-
-/**
- * xprt_set_retrans_timeout_rtt - set a request's retransmit timeout
- * @task: task whose timeout is to be set
- *
- * Set a request's retransmit timeout using the RTT estimator.
- */
-void xprt_set_retrans_timeout_rtt(struct rpc_task *task)
-{
-       int timer = task->tk_msg.rpc_proc->p_timer;
-       struct rpc_clnt *clnt = task->tk_client;
-       struct rpc_rtt *rtt = clnt->cl_rtt;
-       struct rpc_rqst *req = task->tk_rqstp;
-       unsigned long max_timeout = clnt->cl_timeout->to_maxval;
-
-       task->tk_timeout = rpc_calc_rto(rtt, timer);
-       task->tk_timeout <<= rpc_ntimeo(rtt, timer) + req->rq_retries;
-       if (task->tk_timeout > max_timeout || task->tk_timeout == 0)
-               task->tk_timeout = max_timeout;
-}
-EXPORT_SYMBOL_GPL(xprt_set_retrans_timeout_rtt);
-
 static void xprt_reset_majortimeo(struct rpc_rqst *req)
 {
        const struct rpc_timeout *to = req->rq_task->tk_client->cl_timeout;
@@ -1102,6 +1067,47 @@ static void xprt_timer(struct rpc_task *task)
                task->tk_status = 0;
 }
 
+/**
+ * xprt_wait_for_reply_request_def - wait for reply
+ * @task: pointer to rpc_task
+ *
+ * Set a request's retransmit timeout based on the transport's
+ * default timeout parameters.  Used by transports that don't adjust
+ * the retransmit timeout based on round-trip time estimation,
+ * and put the task to sleep on the pending queue.
+ */
+void xprt_wait_for_reply_request_def(struct rpc_task *task)
+{
+       struct rpc_rqst *req = task->tk_rqstp;
+
+       task->tk_timeout = req->rq_timeout;
+       rpc_sleep_on(&req->rq_xprt->pending, task, xprt_timer);
+}
+EXPORT_SYMBOL_GPL(xprt_wait_for_reply_request_def);
+
+/**
+ * xprt_wait_for_reply_request_rtt - wait for reply using RTT estimator
+ * @task: pointer to rpc_task
+ *
+ * Set a request's retransmit timeout using the RTT estimator,
+ * and put the task to sleep on the pending queue.
+ */
+void xprt_wait_for_reply_request_rtt(struct rpc_task *task)
+{
+       int timer = task->tk_msg.rpc_proc->p_timer;
+       struct rpc_clnt *clnt = task->tk_client;
+       struct rpc_rtt *rtt = clnt->cl_rtt;
+       struct rpc_rqst *req = task->tk_rqstp;
+       unsigned long max_timeout = clnt->cl_timeout->to_maxval;
+
+       task->tk_timeout = rpc_calc_rto(rtt, timer);
+       task->tk_timeout <<= rpc_ntimeo(rtt, timer) + req->rq_retries;
+       if (task->tk_timeout > max_timeout || task->tk_timeout == 0)
+               task->tk_timeout = max_timeout;
+       rpc_sleep_on(&req->rq_xprt->pending, task, xprt_timer);
+}
+EXPORT_SYMBOL_GPL(xprt_wait_for_reply_request_rtt);
+
 /**
  * xprt_request_wait_receive - wait for the reply to an RPC request
  * @task: RPC task about to send a request
@@ -1121,8 +1127,7 @@ void xprt_request_wait_receive(struct rpc_task *task)
         */
        spin_lock(&xprt->queue_lock);
        if (test_bit(RPC_TASK_NEED_RECV, &task->tk_runstate)) {
-               xprt->ops->set_retrans_timeout(task);
-               rpc_sleep_on(&xprt->pending, task, xprt_timer);
+               xprt->ops->wait_for_reply_request(task);
                /*
                 * Send an extra queue wakeup call if the
                 * connection was dropped in case the call to

diff --git a/net/sunrpc/xprtrdma/svc_rdma_backchannel.c b/net/sunrpc/xprtrdma/svc_rdma_backchannel.c
index 907464c2a9f038642f551a5874c90cd1759df18b..bed57d8b5c1969d39e9524cd38d640555df68fc6 100644 (file)
--- a/net/sunrpc/xprtrdma/svc_rdma_backchannel.c
+++ b/net/sunrpc/xprtrdma/svc_rdma_backchannel.c
@@ -261,7 +261,7 @@ static const struct rpc_xprt_ops xprt_rdma_bc_procs = {
        .buf_alloc              = xprt_rdma_bc_allocate,
        .buf_free               = xprt_rdma_bc_free,
        .send_request           = xprt_rdma_bc_send_request,
-       .set_retrans_timeout    = xprt_set_retrans_timeout_def,
+       .wait_for_reply_request = xprt_wait_for_reply_request_def,
        .close                  = xprt_rdma_bc_close,
        .destroy                = xprt_rdma_bc_put,
        .print_stats            = xprt_rdma_print_stats

diff --git a/net/sunrpc/xprtrdma/transport.c b/net/sunrpc/xprtrdma/transport.c
index 5d261353bd90228c58d7d40a9ccf6f1824acb45f..7e73abe01cfe2aad12a29b03d5725f420904b15d 100644 (file)
--- a/net/sunrpc/xprtrdma/transport.c
+++ b/net/sunrpc/xprtrdma/transport.c
@@ -815,7 +815,7 @@ static const struct rpc_xprt_ops xprt_rdma_procs = {
        .alloc_slot             = xprt_rdma_alloc_slot,
        .free_slot              = xprt_rdma_free_slot,
        .release_request        = xprt_release_rqst_cong,       /* ditto */
-       .set_retrans_timeout    = xprt_set_retrans_timeout_def, /* ditto */
+       .wait_for_reply_request = xprt_wait_for_reply_request_def, /* ditto */
        .timer                  = xprt_rdma_timer,
        .rpcbind                = rpcb_getport_async,   /* sunrpc/rpcb_clnt.c */
        .set_port               = xprt_rdma_set_port,

diff --git a/net/sunrpc/xprtsock.c b/net/sunrpc/xprtsock.c
index 732d4b57411a2562ad8dc4ee2633c8441f204ba0..b4b4b8db143cbec8d3049652fd66d30c09782af4 100644 (file)
--- a/net/sunrpc/xprtsock.c
+++ b/net/sunrpc/xprtsock.c
@@ -2690,7 +2690,7 @@ static const struct rpc_xprt_ops xs_local_ops = {
        .buf_free               = rpc_free,
        .prepare_request        = xs_stream_prepare_request,
        .send_request           = xs_local_send_request,
-       .set_retrans_timeout    = xprt_set_retrans_timeout_def,
+       .wait_for_reply_request = xprt_wait_for_reply_request_def,
        .close                  = xs_close,
        .destroy                = xs_destroy,
        .print_stats            = xs_local_print_stats,
@@ -2710,7 +2710,7 @@ static const struct rpc_xprt_ops xs_udp_ops = {
        .buf_alloc              = rpc_malloc,
        .buf_free               = rpc_free,
        .send_request           = xs_udp_send_request,
-       .set_retrans_timeout    = xprt_set_retrans_timeout_rtt,
+       .wait_for_reply_request = xprt_wait_for_reply_request_rtt,
        .timer                  = xs_udp_timer,
        .release_request        = xprt_release_rqst_cong,
        .close                  = xs_close,
@@ -2733,7 +2733,7 @@ static const struct rpc_xprt_ops xs_tcp_ops = {
        .buf_free               = rpc_free,
        .prepare_request        = xs_stream_prepare_request,
        .send_request           = xs_tcp_send_request,
-       .set_retrans_timeout    = xprt_set_retrans_timeout_def,
+       .wait_for_reply_request = xprt_wait_for_reply_request_def,
        .close                  = xs_tcp_shutdown,
        .destroy                = xs_destroy,
        .set_connect_timeout    = xs_tcp_set_connect_timeout,
@@ -2761,7 +2761,7 @@ static const struct rpc_xprt_ops bc_tcp_ops = {
        .buf_alloc              = bc_malloc,
        .buf_free               = bc_free,
        .send_request           = bc_send_request,
-       .set_retrans_timeout    = xprt_set_retrans_timeout_def,
+       .wait_for_reply_request = xprt_wait_for_reply_request_def,
        .close                  = bc_close,
        .destroy                = bc_destroy,
        .print_stats            = xs_tcp_print_stats,