Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 8ba6a92d authored by Trond Myklebust's avatar Trond Myklebust Committed by Anna Schumaker
Browse files

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: default avatarTrond Myklebust <trond.myklebust@hammerspace.com>
Signed-off-by: default avatarAnna Schumaker <Anna.Schumaker@Netapp.com>
parent 9e6fa0bb

include/linux/sunrpc/xprt.h

+3 −3
Original line number Diff line number Diff line
@@ -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);

net/sunrpc/xprt.c

+42 −37
Original line number Diff line number Diff line
@@ -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

net/sunrpc/xprtrdma/svc_rdma_backchannel.c

+1 −1
Original line number Diff line number Diff line
@@ -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

net/sunrpc/xprtrdma/transport.c

+1 −1
Original line number Diff line number Diff line
@@ -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,

net/sunrpc/xprtsock.c

+4 −4
Original line number Diff line number Diff line
@@ -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,