xprt.h 11.6 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1
/*
2
 *  linux/include/linux/sunrpc/xprt.h
Linus Torvalds's avatar
Linus Torvalds committed
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>
16
#include <linux/ktime.h>
Linus Torvalds's avatar
Linus Torvalds committed
17
18
#include <linux/sunrpc/sched.h>
#include <linux/sunrpc/xdr.h>
19
#include <linux/sunrpc/msg_prot.h>
Linus Torvalds's avatar
Linus Torvalds committed
20

21
22
#ifdef __KERNEL__

Linus Torvalds's avatar
Linus Torvalds committed
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
#define RPC_MIN_SLOT_TABLE	(2U)
#define RPC_DEF_SLOT_TABLE	(16U)
#define RPC_MAX_SLOT_TABLE	(128U)

/*
 * 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;
};

38
39
40
41
enum rpc_display_format_t {
	RPC_DISPLAY_ADDR = 0,
	RPC_DISPLAY_PORT,
	RPC_DISPLAY_PROTO,
42
43
	RPC_DISPLAY_HEX_ADDR,
	RPC_DISPLAY_HEX_PORT,
44
	RPC_DISPLAY_NETID,
45
46
47
	RPC_DISPLAY_MAX,
};

48
49
struct rpc_task;
struct rpc_xprt;
50
struct seq_file;
51

Linus Torvalds's avatar
Linus Torvalds committed
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
/*
 * 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 */
67
	struct rpc_cred *	rq_cred;	/* Bound cred */
68
	__be32			rq_xid;		/* request XID */
Linus Torvalds's avatar
Linus Torvalds committed
69
70
	int			rq_cong;	/* has incremented xprt->cong */
	u32			rq_seqno;	/* gss seq no. used on req. */
71
72
73
74
	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 */
Linus Torvalds's avatar
Linus Torvalds committed
75
76
	struct list_head	rq_list;

77
	__u32 *			rq_buffer;	/* XDR encode buffer */
78
	size_t			rq_callsize,
79
				rq_rcvsize;
80
81
82
	size_t			rq_xmit_bytes_sent;	/* total bytes sent */
	size_t			rq_reply_bytes_recvd;	/* total reply bytes */
							/* received */
83

Linus Torvalds's avatar
Linus Torvalds committed
84
85
86
87
88
	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 */
89
	ktime_t			rq_rtt;		/* round-trip time */
Linus Torvalds's avatar
Linus Torvalds committed
90
	unsigned int		rq_retries;	/* # of retries */
91
92
93
94
	unsigned int		rq_connect_cookie;
						/* A cookie used to track the
						   state of the transport
						   connection */
Linus Torvalds's avatar
Linus Torvalds committed
95
96
97
98
99
100
	
	/*
	 * Partial send handling
	 */
	u32			rq_bytes_sent;	/* Bytes we have sent */

101
	ktime_t			rq_xtime;	/* transmit time stamp */
Linus Torvalds's avatar
Linus Torvalds committed
102
	int			rq_ntrans;
103
104
105
106
107
108

#if defined(CONFIG_NFS_V4_1)
	struct list_head	rq_bc_list;	/* Callback service list */
	unsigned long		rq_bc_pa_state;	/* Backchannel prealloc state */
	struct list_head	rq_bc_pa_list;	/* Backchannel prealloc list */
#endif /* CONFIG_NFS_V4_1 */
Linus Torvalds's avatar
Linus Torvalds committed
109
110
111
112
};
#define rq_svec			rq_snd_buf.head
#define rq_slen			rq_snd_buf.len

113
struct rpc_xprt_ops {
114
	void		(*set_buffer_size)(struct rpc_xprt *xprt, size_t sndsize, size_t rcvsize);
115
	int		(*reserve_xprt)(struct rpc_task *task);
116
	void		(*release_xprt)(struct rpc_xprt *xprt, struct rpc_task *task);
117
	void		(*rpcbind)(struct rpc_task *task);
118
	void		(*set_port)(struct rpc_xprt *xprt, unsigned short port);
119
	void		(*connect)(struct rpc_task *task);
120
	void *		(*buf_alloc)(struct rpc_task *task, size_t size);
121
	void		(*buf_free)(void *buffer);
122
	int		(*send_request)(struct rpc_task *task);
123
	void		(*set_retrans_timeout)(struct rpc_task *task);
124
	void		(*timer)(struct rpc_task *task);
125
	void		(*release_request)(struct rpc_task *task);
126
127
	void		(*close)(struct rpc_xprt *xprt);
	void		(*destroy)(struct rpc_xprt *xprt);
128
	void		(*print_stats)(struct rpc_xprt *xprt, struct seq_file *seq);
129
};
Linus Torvalds's avatar
Linus Torvalds committed
130

131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
/*
 * RPC transport identifiers
 *
 * To preserve compatibility with the historical use of raw IP protocol
 * id's for transport selection, UDP and TCP identifiers are specified
 * with the previous values. No such restriction exists for new transports,
 * except that they may not collide with these values (17 and 6,
 * respectively).
 */
#define XPRT_TRANSPORT_BC       (1 << 31)
enum xprt_transports {
	XPRT_TRANSPORT_UDP	= IPPROTO_UDP,
	XPRT_TRANSPORT_TCP	= IPPROTO_TCP,
	XPRT_TRANSPORT_BC_TCP	= IPPROTO_TCP | XPRT_TRANSPORT_BC,
	XPRT_TRANSPORT_RDMA	= 256
};

Linus Torvalds's avatar
Linus Torvalds committed
148
struct rpc_xprt {
149
	struct kref		kref;		/* Reference count */
150
	struct rpc_xprt_ops *	ops;		/* transport methods */
Linus Torvalds's avatar
Linus Torvalds committed
151

152
	const struct rpc_timeout *timeout;	/* timeout parms */
153
154
	struct sockaddr_storage	addr;		/* server address */
	size_t			addrlen;	/* size of server address */
Linus Torvalds's avatar
Linus Torvalds committed
155
156
157
158
159
160
161
	int			prot;		/* IP protocol */

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

	size_t			max_payload;	/* largest RPC payload size,
						   in bytes */
162
163
	unsigned int		tsh_size;	/* size of transport specific
						   header */
Linus Torvalds's avatar
Linus Torvalds committed
164

165
	struct rpc_wait_queue	binding;	/* requests waiting on rpcbind */
Linus Torvalds's avatar
Linus Torvalds committed
166
167
168
169
170
171
172
	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 */
173
	unsigned long		state;		/* transport state */
Linus Torvalds's avatar
Linus Torvalds committed
174
	unsigned char		shutdown   : 1,	/* being shut down */
175
				resvport   : 1; /* use a reserved port */
176
	unsigned int		bind_index;	/* bind function index */
Linus Torvalds's avatar
Linus Torvalds committed
177
178

	/*
179
	 * Connection of transports
Linus Torvalds's avatar
Linus Torvalds committed
180
	 */
181
	unsigned long		bind_timeout,
182
				reestablish_timeout;
183
184
185
	unsigned int		connect_cookie;	/* A cookie that gets bumped
						   every time the transport
						   is reconnected */
186

Linus Torvalds's avatar
Linus Torvalds committed
187
	/*
188
	 * Disconnection of idle transports
Linus Torvalds's avatar
Linus Torvalds committed
189
190
191
	 */
	struct work_struct	task_cleanup;
	struct timer_list	timer;
192
193
	unsigned long		last_used,
				idle_timeout;
Linus Torvalds's avatar
Linus Torvalds committed
194
195
196
197

	/*
	 * Send stuff
	 */
Chuck Lever's avatar
Chuck Lever committed
198
	spinlock_t		transport_lock;	/* lock transport info */
Chuck Lever's avatar
Chuck Lever committed
199
	spinlock_t		reserve_lock;	/* lock slot table */
200
	u32			xid;		/* Next XID value to use */
Linus Torvalds's avatar
Linus Torvalds committed
201
	struct rpc_task *	snd_task;	/* Task blocked in send */
202
	struct svc_xprt		*bc_xprt;	/* NFSv4.1 backchannel */
203
204
205
#if defined(CONFIG_NFS_V4_1)
	struct svc_serv		*bc_serv;       /* The RPC service which will */
						/* process the callback */
206
	unsigned int		bc_alloc_count;	/* Total number of preallocs */
207
208
209
210
211
	spinlock_t		bc_pa_lock;	/* Protects the preallocated
						 * items */
	struct list_head	bc_pa_list;	/* List of preallocated
						 * backchannel rpc_rqst's */
#endif /* CONFIG_NFS_V4_1 */
Linus Torvalds's avatar
Linus Torvalds committed
212
213
	struct list_head	recv;

214
215
216
217
218
219
220
221
222
223
224
225
	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;
Linus Torvalds's avatar
Linus Torvalds committed
226

227
	struct net		*xprt_net;
228
	const char		*address_strings[RPC_DISPLAY_MAX];
Linus Torvalds's avatar
Linus Torvalds committed
229
230
};

231
232
233
234
235
236
237
238
#if defined(CONFIG_NFS_V4_1)
/*
 * Backchannel flags
 */
#define	RPC_BC_PA_IN_USE	0x0001		/* Preallocated backchannel */
						/* buffer in use */
#endif /* CONFIG_NFS_V4_1 */

239
240
241
242
243
244
245
246
247
248
249
250
#if defined(CONFIG_NFS_V4_1)
static inline int bc_prealloc(struct rpc_rqst *req)
{
	return test_bit(RPC_BC_PA_IN_USE, &req->rq_bc_pa_state);
}
#else
static inline int bc_prealloc(struct rpc_rqst *req)
{
	return 0;
}
#endif /* CONFIG_NFS_V4_1 */

251
struct xprt_create {
252
	int			ident;		/* XPRT_TRANSPORT identifier */
253
	struct net *		net;
254
	struct sockaddr *	srcaddr;	/* optional local address */
255
256
	struct sockaddr *	dstaddr;	/* remote peer address */
	size_t			addrlen;
257
	struct svc_xprt		*bc_xprt;	/* NFSv4.1 backchannel */
258
};
Linus Torvalds's avatar
Linus Torvalds committed
259

260
261
struct xprt_class {
	struct list_head	list;
262
	int			ident;		/* XPRT_TRANSPORT identifier */
263
	struct rpc_xprt *	(*setup)(struct xprt_create *);
264
265
266
267
	struct module		*owner;
	char			name[32];
};

268
269
270
/*
 * Generic internal transport functions
 */
271
struct rpc_xprt		*xprt_create_transport(struct xprt_create *args);
272
273
void			xprt_connect(struct rpc_task *task);
void			xprt_reserve(struct rpc_task *task);
274
275
int			xprt_reserve_xprt(struct rpc_task *task);
int			xprt_reserve_xprt_cong(struct rpc_task *task);
276
277
int			xprt_prepare_transmit(struct rpc_task *task);
void			xprt_transmit(struct rpc_task *task);
278
void			xprt_end_transmit(struct rpc_task *task);
Linus Torvalds's avatar
Linus Torvalds committed
279
int			xprt_adjust_timeout(struct rpc_rqst *req);
280
281
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);
282
void			xprt_release(struct rpc_task *task);
283
284
struct rpc_xprt *	xprt_get(struct rpc_xprt *xprt);
void			xprt_put(struct rpc_xprt *xprt);
285
struct rpc_xprt *	xprt_alloc(struct net *net, int size, int max_req);
286
void			xprt_free(struct rpc_xprt *);
287

288
static inline __be32 *xprt_skip_transport_header(struct rpc_xprt *xprt, __be32 *p)
289
290
291
292
{
	return p + xprt->tsh_size;
}

293
294
295
/*
 * Transport switch helper functions
 */
296
297
int			xprt_register_transport(struct xprt_class *type);
int			xprt_unregister_transport(struct xprt_class *type);
298
int			xprt_load_transport(const char *);
299
300
void			xprt_set_retrans_timeout_def(struct rpc_task *task);
void			xprt_set_retrans_timeout_rtt(struct rpc_task *task);
301
void			xprt_wake_pending_tasks(struct rpc_xprt *xprt, int status);
302
void			xprt_wait_for_buffer_space(struct rpc_task *task, rpc_action action);
303
void			xprt_write_space(struct rpc_xprt *xprt);
304
void			xprt_adjust_cwnd(struct rpc_task *task, int result);
305
struct rpc_rqst *	xprt_lookup_rqst(struct rpc_xprt *xprt, __be32 xid);
306
void			xprt_complete_rqst(struct rpc_task *task, int copied);
307
void			xprt_release_rqst_cong(struct rpc_task *task);
308
void			xprt_disconnect_done(struct rpc_xprt *xprt);
309
void			xprt_force_disconnect(struct rpc_xprt *xprt);
310
void			xprt_conditional_disconnect(struct rpc_xprt *xprt, unsigned int cookie);
311

312
313
314
315
316
317
/*
 * Reserved bit positions in xprt->state
 */
#define XPRT_LOCKED		(0)
#define XPRT_CONNECTED		(1)
#define XPRT_CONNECTING		(2)
318
#define XPRT_CLOSE_WAIT		(3)
319
#define XPRT_BOUND		(4)
320
#define XPRT_BINDING		(5)
321
#define XPRT_CLOSING		(6)
322
#define XPRT_CONNECTION_ABORT	(7)
323
#define XPRT_CONNECTION_CLOSE	(8)
324
#define XPRT_INITIALIZED	(9)
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366

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);
}
Linus Torvalds's avatar
Linus Torvalds committed
367

368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
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);
}

383
384
385
386
387
388
389
390
391
392
393
394
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);
}

Linus Torvalds's avatar
Linus Torvalds committed
395
396
397
#endif /* __KERNEL__*/

#endif /* _LINUX_SUNRPC_XPRT_H */