WebSVN - shark - Blame - Rev 423 - /shark/trunk/drivers/linuxc26/include/linux/sunrpc/xprt.h

Rev	Author	Line No.	Line
423	giacomo	1	/*
		2	* linux/include/linux/sunrpc/clnt_xprt.h
		3	*
		4	* Declarations for the RPC transport interface.
		5	*
		6	* Copyright (C) 1995, 1996 Olaf Kirch <okir@monad.swb.de>
		7	*/
		8
		9	#ifndef _LINUX_SUNRPC_XPRT_H
		10	#define _LINUX_SUNRPC_XPRT_H
		11
		12	#include <linux/uio.h>
		13	#include <linux/socket.h>
		14	#include <linux/in.h>
		15	#include <linux/sunrpc/sched.h>
		16	#include <linux/sunrpc/xdr.h>
		17
		18	/*
		19	* The transport code maintains an estimate on the maximum number of out-
		20	* standing RPC requests, using a smoothed version of the congestion
		21	* avoidance implemented in 44BSD. This is basically the Van Jacobson
		22	* congestion algorithm: If a retransmit occurs, the congestion window is
		23	* halved; otherwise, it is incremented by 1/cwnd when
		24	*
		25	* - a reply is received and
		26	* - a full number of requests are outstanding and
		27	* - the congestion window hasn't been updated recently.
		28	*
		29	* Upper procedures may check whether a request would block waiting for
		30	* a free RPC slot by using the RPC_CONGESTED() macro.
		31	*
		32	* Note: on machines with low memory we should probably use a smaller
		33	* MAXREQS value: At 32 outstanding reqs with 8 megs of RAM, fragment
		34	* reassembly will frequently run out of memory.
		35	*/
		36	#define RPC_MAXCONG (16)
		37	#define RPC_MAXREQS RPC_MAXCONG
		38	#define RPC_CWNDSCALE (256)
		39	#define RPC_MAXCWND (RPC_MAXCONG * RPC_CWNDSCALE)
		40	#define RPC_INITCWND RPC_CWNDSCALE
		41	#define RPCXPRT_CONGESTED(xprt) ((xprt)->cong >= (xprt)->cwnd)
		42
		43	/* Default timeout values */
		44	#define RPC_MAX_UDP_TIMEOUT (60*HZ)
		45	#define RPC_MAX_TCP_TIMEOUT (600*HZ)
		46
		47	/*
		48	* Wait duration for an RPC TCP connection to be established. Solaris
		49	* NFS over TCP uses 60 seconds, for example, which is in line with how
		50	* long a server takes to reboot.
		51	*/
		52	#define RPC_CONNECT_TIMEOUT (60*HZ)
		53
		54	/*
		55	* Delay an arbitrary number of seconds before attempting to reconnect
		56	* after an error.
		57	*/
		58	#define RPC_REESTABLISH_TIMEOUT (15*HZ)
		59
		60	/* RPC call and reply header size as number of 32bit words (verifier
		61	* size computed separately)
		62	*/
		63	#define RPC_CALLHDRSIZE 6
		64	#define RPC_REPHDRSIZE 4
		65
		66	/*
		67	* This describes a timeout strategy
		68	*/
		69	struct rpc_timeout {
		70	unsigned long to_current, /* current timeout */
		71	to_initval, /* initial timeout */
		72	to_maxval, /* max timeout */
		73	to_increment; /* if !exponential */
		74	unsigned int to_retries; /* max # of retries */
		75	unsigned char to_exponential;
		76	};
		77
		78	/*
		79	* This describes a complete RPC request
		80	*/
		81	struct rpc_rqst {
		82	/*
		83	* This is the user-visible part
		84	*/
		85	struct rpc_xprt * rq_xprt; /* RPC client */
		86	struct rpc_timeout rq_timeout; /* timeout parms */
		87	struct xdr_buf rq_snd_buf; /* send buffer */
		88	struct xdr_buf rq_rcv_buf; /* recv buffer */
		89
		90	/*
		91	* This is the private part
		92	*/
		93	struct rpc_task * rq_task; /* RPC task data */
		94	__u32 rq_xid; /* request XID */
		95	struct rpc_rqst * rq_next; /* free list */
		96	int rq_cong; /* has incremented xprt->cong */
		97	int rq_received; /* receive completed */
		98
		99	struct list_head rq_list;
		100
		101	struct xdr_buf rq_private_buf; /* The receive buffer
		102	* used in the softirq.
		103	*/
		104
		105	/*
		106	* For authentication (e.g. auth_des)
		107	*/
		108	u32 rq_creddata[2];
		109
		110	/*
		111	* Partial send handling
		112	*/
		113
		114	u32 rq_bytes_sent; /* Bytes we have sent */
		115
		116	unsigned long rq_xtime; /* when transmitted */
		117	int rq_ntimeo;
		118	int rq_ntrans;
		119	};
		120	#define rq_svec rq_snd_buf.head
		121	#define rq_slen rq_snd_buf.len
		122	#define rq_rvec rq_rcv_buf.head
		123	#define rq_rlen rq_rcv_buf.len
		124
		125	#define XPRT_LAST_FRAG (1 << 0)
		126	#define XPRT_COPY_RECM (1 << 1)
		127	#define XPRT_COPY_XID (1 << 2)
		128	#define XPRT_COPY_DATA (1 << 3)
		129
		130	struct rpc_xprt {
		131	struct socket * sock; /* BSD socket layer */
		132	struct sock * inet; /* INET layer */
		133
		134	struct rpc_timeout timeout; /* timeout parms */
		135	struct sockaddr_in addr; /* server address */
		136	int prot; /* IP protocol */
		137
		138	unsigned long cong; /* current congestion */
		139	unsigned long cwnd; /* congestion window */
		140
		141	unsigned int rcvsize, /* socket receive buffer size */
		142	sndsize; /* socket send buffer size */
		143
		144	struct rpc_wait_queue sending; /* requests waiting to send */
		145	struct rpc_wait_queue resend; /* requests waiting to resend */
		146	struct rpc_wait_queue pending; /* requests in flight */
		147	struct rpc_wait_queue backlog; /* waiting for slot */
		148	struct rpc_rqst * free; /* free slots */
		149	struct rpc_rqst slot[RPC_MAXREQS];
		150	unsigned long sockstate; /* Socket state */
		151	unsigned char shutdown : 1, /* being shut down */
		152	nocong : 1, /* no congestion control */
		153	resvport : 1, /* use a reserved port */
		154	stream : 1; /* TCP */
		155
		156	/*
		157	* State of TCP reply receive stuff
		158	*/
		159	u32 tcp_recm, /* Fragment header */
		160	tcp_xid, /* Current XID */
		161	tcp_reclen, /* fragment length */
		162	tcp_offset; /* fragment offset */
		163	unsigned long tcp_copied, /* copied to request */
		164	tcp_flags;
		165
		166	/*
		167	* Send stuff
		168	*/
		169	spinlock_t sock_lock; /* lock socket info */
		170	spinlock_t xprt_lock; /* lock xprt info */
		171	struct rpc_task * snd_task; /* Task blocked in send */
		172
		173	struct list_head recv;
		174
		175
		176	void (old_data_ready)(struct sock , int);
		177	void (old_state_change)(struct sock );
		178	void (old_write_space)(struct sock );
		179
		180	wait_queue_head_t cong_wait;
		181	};
		182
		183	#ifdef __KERNEL__
		184
		185	struct rpc_xprt * xprt_create_proto(int proto, struct sockaddr_in *addr,
		186	struct rpc_timeout *toparms);
		187	int xprt_destroy(struct rpc_xprt *);
		188	void xprt_shutdown(struct rpc_xprt *);
		189	void xprt_default_timeout(struct rpc_timeout *, int);
		190	void xprt_set_timeout(struct rpc_timeout *, unsigned int,
		191	unsigned long);
		192
		193	void xprt_reserve(struct rpc_task *);
		194	int xprt_prepare_transmit(struct rpc_task *);
		195	void xprt_transmit(struct rpc_task *);
		196	void xprt_receive(struct rpc_task *);
		197	int xprt_adjust_timeout(struct rpc_timeout *);
		198	void xprt_release(struct rpc_task *);
		199	void xprt_connect(struct rpc_task *);
		200	int xprt_clear_backlog(struct rpc_xprt *);
		201	void xprt_sock_setbufsize(struct rpc_xprt *);
		202
		203	#define XPRT_CONNECT 0
		204
		205	#define xprt_connected(xp) (test_bit(XPRT_CONNECT, &(xp)->sockstate))
		206	#define xprt_set_connected(xp) (set_bit(XPRT_CONNECT, &(xp)->sockstate))
		207	#define xprt_test_and_set_connected(xp) (test_and_set_bit(XPRT_CONNECT, &(xp)->sockstate))
		208	#define xprt_clear_connected(xp) (clear_bit(XPRT_CONNECT, &(xp)->sockstate))
		209
		210	#endif /* __KERNEL__*/
		211
		212	#endif /* _LINUX_SUNRPC_XPRT_H */

Subversion Repositories shark

(root)/shark/trunk/drivers/linuxc26/include/linux/sunrpc/xprt.h - Rev 423