xprt.h 9.3 KB
Newer Older
L
Linus Torvalds 已提交
1
/*
2
 *  linux/include/linux/sunrpc/xprt.h
L
Linus Torvalds 已提交
3 4 5 6 7 8 9 10 11 12 13 14
 *
 *  Declarations for the RPC transport interface.
 *
 *  Copyright (C) 1995, 1996 Olaf Kirch <okir@monad.swb.de>
 */

#ifndef _LINUX_SUNRPC_XPRT_H
#define _LINUX_SUNRPC_XPRT_H

#include <linux/uio.h>
#include <linux/socket.h>
#include <linux/in.h>
15
#include <linux/kref.h>
L
Linus Torvalds 已提交
16 17
#include <linux/sunrpc/sched.h>
#include <linux/sunrpc/xdr.h>
18
#include <linux/sunrpc/msg_prot.h>
L
Linus Torvalds 已提交
19 20 21 22 23 24 25 26

extern unsigned int xprt_udp_slot_table_entries;
extern unsigned int xprt_tcp_slot_table_entries;

#define RPC_MIN_SLOT_TABLE	(2U)
#define RPC_DEF_SLOT_TABLE	(16U)
#define RPC_MAX_SLOT_TABLE	(128U)

27 28 29 30 31 32 33 34
/*
 * Parameters for choosing a free port
 */
extern unsigned int xprt_min_resvport;
extern unsigned int xprt_max_resvport;

#define RPC_MIN_RESVPORT	(1U)
#define RPC_MAX_RESVPORT	(65535U)
35
#define RPC_DEF_MIN_RESVPORT	(665U)
36 37
#define RPC_DEF_MAX_RESVPORT	(1023U)

L
Linus Torvalds 已提交
38 39 40 41 42 43 44 45 46 47 48
/*
 * This describes a timeout strategy
 */
struct rpc_timeout {
	unsigned long		to_initval,		/* initial timeout */
				to_maxval,		/* max timeout */
				to_increment;		/* if !exponential */
	unsigned int		to_retries;		/* max # of retries */
	unsigned char		to_exponential;
};

49 50 51 52 53 54 55 56
enum rpc_display_format_t {
	RPC_DISPLAY_ADDR = 0,
	RPC_DISPLAY_PORT,
	RPC_DISPLAY_PROTO,
	RPC_DISPLAY_ALL,
	RPC_DISPLAY_MAX,
};

57 58
struct rpc_task;
struct rpc_xprt;
59
struct seq_file;
60

L
Linus Torvalds 已提交
61 62 63 64 65 66 67 68 69 70 71 72 73 74 75
/*
 * This describes a complete RPC request
 */
struct rpc_rqst {
	/*
	 * This is the user-visible part
	 */
	struct rpc_xprt *	rq_xprt;		/* RPC client */
	struct xdr_buf		rq_snd_buf;		/* send buffer */
	struct xdr_buf		rq_rcv_buf;		/* recv buffer */

	/*
	 * This is the private part
	 */
	struct rpc_task *	rq_task;	/* RPC task data */
76
	__be32			rq_xid;		/* request XID */
L
Linus Torvalds 已提交
77 78 79
	int			rq_cong;	/* has incremented xprt->cong */
	int			rq_received;	/* receive completed */
	u32			rq_seqno;	/* gss seq no. used on req. */
80 81 82 83
	int			rq_enc_pages_num;
	struct page		**rq_enc_pages;	/* scratch pages for use by
						   gss privacy code */
	void (*rq_release_snd_buf)(struct rpc_rqst *); /* release rq_enc_pages */
L
Linus Torvalds 已提交
84 85
	struct list_head	rq_list;

86
	__u32 *			rq_buffer;	/* XDR encode buffer */
87 88 89
	size_t			rq_bufsize,
				rq_callsize,
				rq_rcvsize;
90

L
Linus Torvalds 已提交
91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108
	struct xdr_buf		rq_private_buf;		/* The receive buffer
							 * used in the softirq.
							 */
	unsigned long		rq_majortimeo;	/* major timeout alarm */
	unsigned long		rq_timeout;	/* Current timeout value */
	unsigned int		rq_retries;	/* # of retries */
	
	/*
	 * Partial send handling
	 */
	u32			rq_bytes_sent;	/* Bytes we have sent */

	unsigned long		rq_xtime;	/* when transmitted */
	int			rq_ntrans;
};
#define rq_svec			rq_snd_buf.head
#define rq_slen			rq_snd_buf.len

109
struct rpc_xprt_ops {
110
	void		(*set_buffer_size)(struct rpc_xprt *xprt, size_t sndsize, size_t rcvsize);
111
	int		(*reserve_xprt)(struct rpc_task *task);
112
	void		(*release_xprt)(struct rpc_xprt *xprt, struct rpc_task *task);
113
	void		(*rpcbind)(struct rpc_task *task);
114
	void		(*set_port)(struct rpc_xprt *xprt, unsigned short port);
115
	void		(*connect)(struct rpc_task *task);
116
	void *		(*buf_alloc)(struct rpc_task *task, size_t size);
117
	void		(*buf_free)(void *buffer);
118
	int		(*send_request)(struct rpc_task *task);
119
	void		(*set_retrans_timeout)(struct rpc_task *task);
120
	void		(*timer)(struct rpc_task *task);
121
	void		(*release_request)(struct rpc_task *task);
122 123
	void		(*close)(struct rpc_xprt *xprt);
	void		(*destroy)(struct rpc_xprt *xprt);
124
	void		(*print_stats)(struct rpc_xprt *xprt, struct seq_file *seq);
125
};
L
Linus Torvalds 已提交
126 127

struct rpc_xprt {
128
	struct kref		kref;		/* Reference count */
129
	struct rpc_xprt_ops *	ops;		/* transport methods */
L
Linus Torvalds 已提交
130 131

	struct rpc_timeout	timeout;	/* timeout parms */
132 133
	struct sockaddr_storage	addr;		/* server address */
	size_t			addrlen;	/* size of server address */
L
Linus Torvalds 已提交
134 135 136 137 138 139 140
	int			prot;		/* IP protocol */

	unsigned long		cong;		/* current congestion */
	unsigned long		cwnd;		/* congestion window */

	size_t			max_payload;	/* largest RPC payload size,
						   in bytes */
141 142
	unsigned int		tsh_size;	/* size of transport specific
						   header */
L
Linus Torvalds 已提交
143

144
	struct rpc_wait_queue	binding;	/* requests waiting on rpcbind */
L
Linus Torvalds 已提交
145 146 147 148 149 150 151
	struct rpc_wait_queue	sending;	/* requests waiting to send */
	struct rpc_wait_queue	resend;		/* requests waiting to resend */
	struct rpc_wait_queue	pending;	/* requests in flight */
	struct rpc_wait_queue	backlog;	/* waiting for slot */
	struct list_head	free;		/* free slots */
	struct rpc_rqst *	slot;		/* slot table storage */
	unsigned int		max_reqs;	/* total slots */
152
	unsigned long		state;		/* transport state */
L
Linus Torvalds 已提交
153
	unsigned char		shutdown   : 1,	/* being shut down */
154
				resvport   : 1; /* use a reserved port */
L
Linus Torvalds 已提交
155 156

	/*
157
	 * Connection of transports
L
Linus Torvalds 已提交
158
	 */
159 160 161 162
	unsigned long		connect_timeout,
				bind_timeout,
				reestablish_timeout;

L
Linus Torvalds 已提交
163
	/*
164
	 * Disconnection of idle transports
L
Linus Torvalds 已提交
165 166 167
	 */
	struct work_struct	task_cleanup;
	struct timer_list	timer;
168 169
	unsigned long		last_used,
				idle_timeout;
L
Linus Torvalds 已提交
170 171 172 173

	/*
	 * Send stuff
	 */
C
Chuck Lever 已提交
174
	spinlock_t		transport_lock;	/* lock transport info */
C
Chuck Lever 已提交
175
	spinlock_t		reserve_lock;	/* lock slot table */
176
	u32			xid;		/* Next XID value to use */
L
Linus Torvalds 已提交
177 178 179
	struct rpc_task *	snd_task;	/* Task blocked in send */
	struct list_head	recv;

180 181 182 183 184 185 186 187 188 189 190 191
	struct {
		unsigned long		bind_count,	/* total number of binds */
					connect_count,	/* total number of connects */
					connect_start,	/* connect start timestamp */
					connect_time,	/* jiffies waiting for connect */
					sends,		/* how many complete requests */
					recvs,		/* how many complete requests */
					bad_xids;	/* lookup_rqst didn't find XID */

		unsigned long long	req_u,		/* average requests on the wire */
					bklog_u;	/* backlog queue utilization */
	} stat;
L
Linus Torvalds 已提交
192

193
	char *			address_strings[RPC_DISPLAY_MAX];
L
Linus Torvalds 已提交
194 195 196 197
};

#ifdef __KERNEL__

198 199 200 201 202 203 204 205
/*
 * Transport operations used by ULPs
 */
void			xprt_set_timeout(struct rpc_timeout *to, unsigned int retr, unsigned long incr);

/*
 * Generic internal transport functions
 */
206
struct rpc_xprt *	xprt_create_transport(int proto, struct sockaddr *addr, size_t size, struct rpc_timeout *toparms);
207 208
void			xprt_connect(struct rpc_task *task);
void			xprt_reserve(struct rpc_task *task);
209 210
int			xprt_reserve_xprt(struct rpc_task *task);
int			xprt_reserve_xprt_cong(struct rpc_task *task);
211 212
int			xprt_prepare_transmit(struct rpc_task *task);
void			xprt_transmit(struct rpc_task *task);
213
void			xprt_end_transmit(struct rpc_task *task);
L
Linus Torvalds 已提交
214
int			xprt_adjust_timeout(struct rpc_rqst *req);
215 216
void			xprt_release_xprt(struct rpc_xprt *xprt, struct rpc_task *task);
void			xprt_release_xprt_cong(struct rpc_xprt *xprt, struct rpc_task *task);
217
void			xprt_release(struct rpc_task *task);
218 219
struct rpc_xprt *	xprt_get(struct rpc_xprt *xprt);
void			xprt_put(struct rpc_xprt *xprt);
220

221
static inline __be32 *xprt_skip_transport_header(struct rpc_xprt *xprt, __be32 *p)
222 223 224 225
{
	return p + xprt->tsh_size;
}

226 227 228
/*
 * Transport switch helper functions
 */
229 230
void			xprt_set_retrans_timeout_def(struct rpc_task *task);
void			xprt_set_retrans_timeout_rtt(struct rpc_task *task);
231
void			xprt_wake_pending_tasks(struct rpc_xprt *xprt, int status);
232 233
void			xprt_wait_for_buffer_space(struct rpc_task *task);
void			xprt_write_space(struct rpc_xprt *xprt);
234
void			xprt_update_rtt(struct rpc_task *task);
235
void			xprt_adjust_cwnd(struct rpc_task *task, int result);
236
struct rpc_rqst *	xprt_lookup_rqst(struct rpc_xprt *xprt, __be32 xid);
237
void			xprt_complete_rqst(struct rpc_task *task, int copied);
238
void			xprt_release_rqst_cong(struct rpc_task *task);
239 240 241 242 243
void			xprt_disconnect(struct rpc_xprt *xprt);

/*
 * Socket transport setup operations
 */
244 245
struct rpc_xprt *	xs_setup_udp(struct sockaddr *addr, size_t addrlen, struct rpc_timeout *to);
struct rpc_xprt *	xs_setup_tcp(struct sockaddr *addr, size_t addrlen, struct rpc_timeout *to);
L
Linus Torvalds 已提交
246

247 248 249 250 251 252
/*
 * Reserved bit positions in xprt->state
 */
#define XPRT_LOCKED		(0)
#define XPRT_CONNECTED		(1)
#define XPRT_CONNECTING		(2)
253
#define XPRT_CLOSE_WAIT		(3)
254
#define XPRT_BOUND		(4)
255
#define XPRT_BINDING		(5)
256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297

static inline void xprt_set_connected(struct rpc_xprt *xprt)
{
	set_bit(XPRT_CONNECTED, &xprt->state);
}

static inline void xprt_clear_connected(struct rpc_xprt *xprt)
{
	clear_bit(XPRT_CONNECTED, &xprt->state);
}

static inline int xprt_connected(struct rpc_xprt *xprt)
{
	return test_bit(XPRT_CONNECTED, &xprt->state);
}

static inline int xprt_test_and_set_connected(struct rpc_xprt *xprt)
{
	return test_and_set_bit(XPRT_CONNECTED, &xprt->state);
}

static inline int xprt_test_and_clear_connected(struct rpc_xprt *xprt)
{
	return test_and_clear_bit(XPRT_CONNECTED, &xprt->state);
}

static inline void xprt_clear_connecting(struct rpc_xprt *xprt)
{
	smp_mb__before_clear_bit();
	clear_bit(XPRT_CONNECTING, &xprt->state);
	smp_mb__after_clear_bit();
}

static inline int xprt_connecting(struct rpc_xprt *xprt)
{
	return test_bit(XPRT_CONNECTING, &xprt->state);
}

static inline int xprt_test_and_set_connecting(struct rpc_xprt *xprt)
{
	return test_and_set_bit(XPRT_CONNECTING, &xprt->state);
}
L
Linus Torvalds 已提交
298

299 300 301 302 303 304 305 306 307 308 309 310 311 312 313
static inline void xprt_set_bound(struct rpc_xprt *xprt)
{
	test_and_set_bit(XPRT_BOUND, &xprt->state);
}

static inline int xprt_bound(struct rpc_xprt *xprt)
{
	return test_bit(XPRT_BOUND, &xprt->state);
}

static inline void xprt_clear_bound(struct rpc_xprt *xprt)
{
	clear_bit(XPRT_BOUND, &xprt->state);
}

314 315 316 317 318 319 320 321 322 323 324 325
static inline void xprt_clear_binding(struct rpc_xprt *xprt)
{
	smp_mb__before_clear_bit();
	clear_bit(XPRT_BINDING, &xprt->state);
	smp_mb__after_clear_bit();
}

static inline int xprt_test_and_set_binding(struct rpc_xprt *xprt)
{
	return test_and_set_bit(XPRT_BINDING, &xprt->state);
}

L
Linus Torvalds 已提交
326 327 328
#endif /* __KERNEL__*/

#endif /* _LINUX_SUNRPC_XPRT_H */