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

Commit 55aa4f58 authored by Chuck Lever's avatar Chuck Lever Committed by Trond Myklebust
Browse files

[PATCH] RPC: client-side transport switch cleanup 



 Clean-up: change some comments to reflect the realities of the new RPC
 transport switch mechanism.  Get rid of unused xprt_receive() prototype.

 Also, organize function prototypes in xprt.h by usage and scope.

 Test-plan:
 Compile kernel with CONFIG_NFS enabled.

 Version: Thu, 11 Aug 2005 16:07:21 -0400

 Signed-off-by: default avatarChuck Lever <cel@netapp.com>
 Signed-off-by: default avatarTrond Myklebust <Trond.Myklebust@netapp.com>
parent 44fbac22

include/linux/sunrpc/xprt.h

+35 −26
Original line number Diff line number Diff line 
/*

 *  linux/include/linux/sunrpc/clnt_xprt.h

 *  linux/include/linux/sunrpc/xprt.h

 *

 *  Declarations for the RPC transport interface.

 *
@@ -150,8 +150,8 @@ struct rpc_xprt { 
	unsigned long		cong;		/* current congestion */

	unsigned long		cwnd;		/* congestion window */



	unsigned int		rcvsize,	/* socket receive buffer size */

				sndsize;	/* socket send buffer size */

	unsigned int		rcvsize,	/* transport rcv buffer size */

				sndsize;	/* transport send buffer size */



	size_t			max_payload;	/* largest RPC payload size,

						   in bytes */
@@ -184,12 +184,12 @@ struct rpc_xprt { 
	unsigned long		tcp_copied,	/* copied to request */

				tcp_flags;

	/*

	 * Connection of sockets

	 * Connection of transports

	 */

	struct work_struct	sock_connect;

	struct work_struct	connect_worker;

	unsigned short		port;

	/*

	 * Disconnection of idle sockets

	 * Disconnection of idle transports

	 */

	struct work_struct	task_cleanup;

	struct timer_list	timer;
@@ -219,27 +219,36 @@ struct rpc_xprt { 


#ifdef __KERNEL__



struct rpc_xprt *	xprt_create_proto(int proto, struct sockaddr_in *addr,

					struct rpc_timeout *toparms);

void			xprt_disconnect(struct rpc_xprt *);

int			xprt_destroy(struct rpc_xprt *);

void			xprt_set_timeout(struct rpc_timeout *, unsigned int,

					unsigned long);

struct rpc_rqst *	xprt_lookup_rqst(struct rpc_xprt *, u32);

void			xprt_complete_rqst(struct rpc_xprt *,

					struct rpc_rqst *, int);

void			xprt_reserve(struct rpc_task *);

int			xprt_prepare_transmit(struct rpc_task *);

void			xprt_transmit(struct rpc_task *);

void			xprt_receive(struct rpc_task *);

void			xprt_wake_pending_tasks(struct rpc_xprt *, int);

/*

 * Transport operations used by ULPs

 */

struct rpc_xprt *	xprt_create_proto(int proto, struct sockaddr_in *addr, struct rpc_timeout *to);

void			xprt_set_timeout(struct rpc_timeout *to, unsigned int retr, unsigned long incr);



/*

 * Generic internal transport functions

 */

void			xprt_connect(struct rpc_task *task);

void			xprt_reserve(struct rpc_task *task);

int			xprt_prepare_transmit(struct rpc_task *task);

void			xprt_transmit(struct rpc_task *task);

int			xprt_adjust_timeout(struct rpc_rqst *req);

void			xprt_release(struct rpc_task *);

void			xprt_connect(struct rpc_task *);

int			xs_setup_udp(struct rpc_xprt *,

					struct rpc_timeout *);

int			xs_setup_tcp(struct rpc_xprt *,

					struct rpc_timeout *);

void			xprt_release(struct rpc_task *task);

int			xprt_destroy(struct rpc_xprt *xprt);



/*

 * Transport switch helper functions

 */

void			xprt_wake_pending_tasks(struct rpc_xprt *xprt, int status);

struct rpc_rqst *	xprt_lookup_rqst(struct rpc_xprt *xprt, u32 xid);

void			xprt_complete_rqst(struct rpc_xprt *xprt, struct rpc_rqst *req, int copied);

void			xprt_disconnect(struct rpc_xprt *xprt);



/*

 * Socket transport setup operations

 */

int			xs_setup_udp(struct rpc_xprt *xprt, struct rpc_timeout *to);

int			xs_setup_tcp(struct rpc_xprt *xprt, struct rpc_timeout *to);



/*

 * Reserved bit positions in xprt->state

net/sunrpc/clnt.c

+1 −1
Original line number Diff line number Diff line 
/*

 *  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

net/sunrpc/xprt.c

+12 −14
Original line number Diff line number Diff line
@@ -10,12 +10,12 @@ 
 *	one is available. Otherwise, it sleeps on the backlog queue

 *	(xprt_reserve).

 *  -	Next, the caller puts together the RPC message, stuffs it into

 *	the request struct, and calls xprt_call().

 *  -	xprt_call transmits the message and installs the caller on the

 *	socket's wait list. At the same time, it installs a timer that

 *	the request struct, and calls xprt_transmit().

 *  -	xprt_transmit sends the message and installs the caller on the

 *	transport's wait list. At the same time, it installs a timer that

 *	is run after the packet's timeout has expired.

 *  -	When a packet arrives, the data_ready handler walks the list of

 *	pending requests for that socket. If a matching XID is found, the

 *	pending requests for that transport. If a matching XID is found, the

 *	caller is woken up, and the timer removed.

 *  -	When no reply arrives within the timeout interval, the timer is

 *	fired by the kernel and runs xprt_timer(). It either adjusts the
@@ -32,6 +32,8 @@ 
 *  tasks that rely on callbacks.

 *

 *  Copyright (C) 1995-1997, Olaf Kirch <okir@monad.swb.de>

 *

 *  Transport switch API copyright (C) 2005, Chuck Lever <cel@netapp.com>

 */



#include <linux/module.h>
@@ -52,8 +54,6 @@ 
# define RPCDBG_FACILITY	RPCDBG_XPRT

#endif



#define XPRT_MAX_BACKOFF	(8)



/*

 * Local functions

 */
@@ -65,9 +65,9 @@ static int __xprt_get_cong(struct rpc_xprt *, struct rpc_task *); 
static int	xprt_clear_backlog(struct rpc_xprt *xprt);



/*

 * Serialize write access to sockets, in order to prevent different

 * Serialize write access to transports, in order to prevent different

 * requests from interfering with each other.

 * Also prevents TCP socket connects from colliding with writes.

 * Also prevents transport connects from colliding with writes.

 */

static int

__xprt_lock_write(struct rpc_xprt *xprt, struct rpc_task *task)
@@ -91,7 +91,7 @@ __xprt_lock_write(struct rpc_xprt *xprt, struct rpc_task *task) 
	clear_bit(XPRT_LOCKED, &xprt->state);

	smp_mb__after_clear_bit();

out_sleep:

	dprintk("RPC: %4d failed to lock socket %p\n", task->tk_pid, xprt);

	dprintk("RPC: %4d failed to lock transport %p\n", task->tk_pid, xprt);

	task->tk_timeout = 0;

	task->tk_status = -EAGAIN;

	if (req && req->rq_ntrans)
@@ -144,7 +144,7 @@ __xprt_lock_write_next(struct rpc_xprt *xprt) 
}



/*

 * Releases the socket for use by other requests.

 * Releases the transport for use by other requests.

 */

static void

__xprt_release_write(struct rpc_xprt *xprt, struct rpc_task *task)
@@ -294,8 +294,7 @@ int xprt_adjust_timeout(struct rpc_rqst *req) 
	return status;

}



static void

xprt_socket_autoclose(void *args)

static void xprt_autoclose(void *args)

{

	struct rpc_xprt *xprt = (struct rpc_xprt *)args;
@@ -329,7 +328,6 @@ xprt_init_autodisconnect(unsigned long data) 
	if (test_and_set_bit(XPRT_LOCKED, &xprt->state))

		goto out_abort;

	spin_unlock(&xprt->transport_lock);

	/* Let keventd close the socket */

	if (xprt_connecting(xprt))

		xprt_release_write(xprt, NULL);

	else
@@ -770,7 +768,7 @@ static struct rpc_xprt *xprt_setup(int proto, struct sockaddr_in *ap, struct rpc 


	INIT_LIST_HEAD(&xprt->free);

	INIT_LIST_HEAD(&xprt->recv);

	INIT_WORK(&xprt->task_cleanup, xprt_socket_autoclose, xprt);

	INIT_WORK(&xprt->task_cleanup, xprt_autoclose, xprt);

	init_timer(&xprt->timer);

	xprt->timer.function = xprt_init_autodisconnect;

	xprt->timer.data = (unsigned long) xprt;

net/sunrpc/xprtsock.c

+7 −5
Original line number Diff line number Diff line
@@ -11,6 +11,8 @@ 
 * Rewrite of larges part of the code in order to stabilize TCP stuff.

 * Fix behaviour when socket buffer is full.

 *  (C) 1999 Trond Myklebust <trond.myklebust@fys.uio.no>

 *

 * IP socket transport implementation, (C) 2005 Chuck Lever <cel@netapp.com>

 */



#include <linux/types.h>
@@ -363,7 +365,7 @@ static void xs_destroy(struct rpc_xprt *xprt) 
{

	dprintk("RPC:      xs_destroy xprt %p\n", xprt);



	cancel_delayed_work(&xprt->sock_connect);

	cancel_delayed_work(&xprt->connect_worker);

	flush_scheduled_work();



	xprt_disconnect(xprt);
@@ -938,11 +940,11 @@ static void xs_connect(struct rpc_task *task) 
	if (!xprt_test_and_set_connecting(xprt)) {

		if (xprt->sock != NULL) {

			dprintk("RPC:      xs_connect delayed xprt %p\n", xprt);

			schedule_delayed_work(&xprt->sock_connect,

			schedule_delayed_work(&xprt->connect_worker,

					RPC_REESTABLISH_TIMEOUT);

		} else {

			dprintk("RPC:      xs_connect scheduled xprt %p\n", xprt);

			schedule_work(&xprt->sock_connect);

			schedule_work(&xprt->connect_worker);

			/* flush_scheduled_work can sleep... */

			if (!RPC_IS_ASYNC(task))

				flush_scheduled_work();
@@ -989,7 +991,7 @@ int xs_setup_udp(struct rpc_xprt *xprt, struct rpc_timeout *to) 
	/* XXX: header size can vary due to auth type, IPv6, etc. */

	xprt->max_payload = (1U << 16) - (MAX_HEADER << 3);



	INIT_WORK(&xprt->sock_connect, xs_connect_worker, xprt);

	INIT_WORK(&xprt->connect_worker, xs_connect_worker, xprt);



	xprt->ops = &xs_ops;
@@ -1028,7 +1030,7 @@ int xs_setup_tcp(struct rpc_xprt *xprt, struct rpc_timeout *to) 
	xprt->resvport = capable(CAP_NET_BIND_SERVICE) ? 1 : 0;

	xprt->max_payload = (1U << 31) - 1;



	INIT_WORK(&xprt->sock_connect, xs_connect_worker, xprt);

	INIT_WORK(&xprt->connect_worker, xs_connect_worker, xprt);



	xprt->ops = &xs_ops;