Commit | Line | Data |
---|---|---|
1da177e4 | 1 | /* |
55aa4f58 | 2 | * linux/include/linux/sunrpc/xprt.h |
1da177e4 LT |
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 | extern unsigned int xprt_udp_slot_table_entries; | |
33 | extern unsigned int xprt_tcp_slot_table_entries; | |
34 | ||
35 | #define RPC_MIN_SLOT_TABLE (2U) | |
36 | #define RPC_DEF_SLOT_TABLE (16U) | |
37 | #define RPC_MAX_SLOT_TABLE (128U) | |
38 | ||
39 | #define RPC_CWNDSHIFT (8U) | |
40 | #define RPC_CWNDSCALE (1U << RPC_CWNDSHIFT) | |
41 | #define RPC_INITCWND RPC_CWNDSCALE | |
42 | #define RPC_MAXCWND(xprt) ((xprt)->max_reqs << RPC_CWNDSHIFT) | |
43 | #define RPCXPRT_CONGESTED(xprt) ((xprt)->cong >= (xprt)->cwnd) | |
44 | ||
45 | /* Default timeout values */ | |
46 | #define RPC_MAX_UDP_TIMEOUT (60*HZ) | |
47 | #define RPC_MAX_TCP_TIMEOUT (600*HZ) | |
48 | ||
49 | /* | |
50 | * Wait duration for an RPC TCP connection to be established. Solaris | |
51 | * NFS over TCP uses 60 seconds, for example, which is in line with how | |
52 | * long a server takes to reboot. | |
53 | */ | |
54 | #define RPC_CONNECT_TIMEOUT (60*HZ) | |
55 | ||
56 | /* | |
57 | * Delay an arbitrary number of seconds before attempting to reconnect | |
58 | * after an error. | |
59 | */ | |
60 | #define RPC_REESTABLISH_TIMEOUT (15*HZ) | |
61 | ||
a246b010 CL |
62 | /* |
63 | * RPC transport idle timeout. | |
64 | */ | |
65 | #define RPC_IDLE_DISCONNECT_TIMEOUT (5*60*HZ) | |
66 | ||
67 | /* | |
68 | * RPC call and reply header size as number of 32bit words (verifier | |
1da177e4 LT |
69 | * size computed separately) |
70 | */ | |
71 | #define RPC_CALLHDRSIZE 6 | |
72 | #define RPC_REPHDRSIZE 4 | |
73 | ||
74 | /* | |
75 | * This describes a timeout strategy | |
76 | */ | |
77 | struct rpc_timeout { | |
78 | unsigned long to_initval, /* initial timeout */ | |
79 | to_maxval, /* max timeout */ | |
80 | to_increment; /* if !exponential */ | |
81 | unsigned int to_retries; /* max # of retries */ | |
82 | unsigned char to_exponential; | |
83 | }; | |
84 | ||
85 | /* | |
86 | * This describes a complete RPC request | |
87 | */ | |
88 | struct rpc_rqst { | |
89 | /* | |
90 | * This is the user-visible part | |
91 | */ | |
92 | struct rpc_xprt * rq_xprt; /* RPC client */ | |
93 | struct xdr_buf rq_snd_buf; /* send buffer */ | |
94 | struct xdr_buf rq_rcv_buf; /* recv buffer */ | |
95 | ||
96 | /* | |
97 | * This is the private part | |
98 | */ | |
99 | struct rpc_task * rq_task; /* RPC task data */ | |
100 | __u32 rq_xid; /* request XID */ | |
101 | int rq_cong; /* has incremented xprt->cong */ | |
102 | int rq_received; /* receive completed */ | |
103 | u32 rq_seqno; /* gss seq no. used on req. */ | |
104 | ||
105 | struct list_head rq_list; | |
106 | ||
107 | struct xdr_buf rq_private_buf; /* The receive buffer | |
108 | * used in the softirq. | |
109 | */ | |
110 | unsigned long rq_majortimeo; /* major timeout alarm */ | |
111 | unsigned long rq_timeout; /* Current timeout value */ | |
112 | unsigned int rq_retries; /* # of retries */ | |
113 | /* | |
114 | * For authentication (e.g. auth_des) | |
115 | */ | |
116 | u32 rq_creddata[2]; | |
117 | ||
118 | /* | |
119 | * Partial send handling | |
120 | */ | |
121 | ||
122 | u32 rq_bytes_sent; /* Bytes we have sent */ | |
123 | ||
124 | unsigned long rq_xtime; /* when transmitted */ | |
125 | int rq_ntrans; | |
126 | }; | |
127 | #define rq_svec rq_snd_buf.head | |
128 | #define rq_slen rq_snd_buf.len | |
129 | ||
a246b010 CL |
130 | struct rpc_task; |
131 | struct rpc_xprt; | |
132 | ||
133 | struct rpc_xprt_ops { | |
134 | void (*set_buffer_size)(struct rpc_xprt *xprt); | |
12a80469 | 135 | int (*reserve_xprt)(struct rpc_task *task); |
49e9a890 | 136 | void (*release_xprt)(struct rpc_xprt *xprt, struct rpc_task *task); |
a246b010 CL |
137 | void (*connect)(struct rpc_task *task); |
138 | int (*send_request)(struct rpc_task *task); | |
fe3aca29 | 139 | void (*set_retrans_timeout)(struct rpc_task *task); |
a246b010 CL |
140 | void (*close)(struct rpc_xprt *xprt); |
141 | void (*destroy)(struct rpc_xprt *xprt); | |
142 | }; | |
1da177e4 LT |
143 | |
144 | struct rpc_xprt { | |
a246b010 | 145 | struct rpc_xprt_ops * ops; /* transport methods */ |
1da177e4 LT |
146 | struct socket * sock; /* BSD socket layer */ |
147 | struct sock * inet; /* INET layer */ | |
148 | ||
149 | struct rpc_timeout timeout; /* timeout parms */ | |
150 | struct sockaddr_in addr; /* server address */ | |
151 | int prot; /* IP protocol */ | |
152 | ||
153 | unsigned long cong; /* current congestion */ | |
154 | unsigned long cwnd; /* congestion window */ | |
155 | ||
55aa4f58 CL |
156 | unsigned int rcvsize, /* transport rcv buffer size */ |
157 | sndsize; /* transport send buffer size */ | |
1da177e4 LT |
158 | |
159 | size_t max_payload; /* largest RPC payload size, | |
160 | in bytes */ | |
808012fb CL |
161 | unsigned int tsh_size; /* size of transport specific |
162 | header */ | |
1da177e4 LT |
163 | |
164 | struct rpc_wait_queue sending; /* requests waiting to send */ | |
165 | struct rpc_wait_queue resend; /* requests waiting to resend */ | |
166 | struct rpc_wait_queue pending; /* requests in flight */ | |
167 | struct rpc_wait_queue backlog; /* waiting for slot */ | |
168 | struct list_head free; /* free slots */ | |
169 | struct rpc_rqst * slot; /* slot table storage */ | |
170 | unsigned int max_reqs; /* total slots */ | |
2226feb6 | 171 | unsigned long state; /* transport state */ |
1da177e4 LT |
172 | unsigned char shutdown : 1, /* being shut down */ |
173 | nocong : 1, /* no congestion control */ | |
43118c29 | 174 | resvport : 1; /* use a reserved port */ |
1da177e4 LT |
175 | |
176 | /* | |
177 | * XID | |
178 | */ | |
179 | __u32 xid; /* Next XID value to use */ | |
180 | ||
181 | /* | |
182 | * State of TCP reply receive stuff | |
183 | */ | |
184 | u32 tcp_recm, /* Fragment header */ | |
185 | tcp_xid, /* Current XID */ | |
186 | tcp_reclen, /* fragment length */ | |
187 | tcp_offset; /* fragment offset */ | |
188 | unsigned long tcp_copied, /* copied to request */ | |
189 | tcp_flags; | |
190 | /* | |
55aa4f58 | 191 | * Connection of transports |
1da177e4 | 192 | */ |
55aa4f58 | 193 | struct work_struct connect_worker; |
1da177e4 LT |
194 | unsigned short port; |
195 | /* | |
55aa4f58 | 196 | * Disconnection of idle transports |
1da177e4 LT |
197 | */ |
198 | struct work_struct task_cleanup; | |
199 | struct timer_list timer; | |
200 | unsigned long last_used; | |
201 | ||
202 | /* | |
203 | * Send stuff | |
204 | */ | |
4a0f8c04 | 205 | spinlock_t transport_lock; /* lock transport info */ |
5dc07727 | 206 | spinlock_t reserve_lock; /* lock slot table */ |
1da177e4 LT |
207 | struct rpc_task * snd_task; /* Task blocked in send */ |
208 | ||
209 | struct list_head recv; | |
210 | ||
211 | ||
212 | void (*old_data_ready)(struct sock *, int); | |
213 | void (*old_state_change)(struct sock *); | |
214 | void (*old_write_space)(struct sock *); | |
215 | ||
216 | wait_queue_head_t cong_wait; | |
217 | }; | |
218 | ||
a246b010 CL |
219 | #define XPRT_LAST_FRAG (1 << 0) |
220 | #define XPRT_COPY_RECM (1 << 1) | |
221 | #define XPRT_COPY_XID (1 << 2) | |
222 | #define XPRT_COPY_DATA (1 << 3) | |
223 | ||
1da177e4 LT |
224 | #ifdef __KERNEL__ |
225 | ||
55aa4f58 CL |
226 | /* |
227 | * Transport operations used by ULPs | |
228 | */ | |
229 | struct rpc_xprt * xprt_create_proto(int proto, struct sockaddr_in *addr, struct rpc_timeout *to); | |
230 | void xprt_set_timeout(struct rpc_timeout *to, unsigned int retr, unsigned long incr); | |
231 | ||
232 | /* | |
233 | * Generic internal transport functions | |
234 | */ | |
235 | void xprt_connect(struct rpc_task *task); | |
236 | void xprt_reserve(struct rpc_task *task); | |
12a80469 CL |
237 | int xprt_reserve_xprt(struct rpc_task *task); |
238 | int xprt_reserve_xprt_cong(struct rpc_task *task); | |
55aa4f58 CL |
239 | int xprt_prepare_transmit(struct rpc_task *task); |
240 | void xprt_transmit(struct rpc_task *task); | |
1da177e4 | 241 | int xprt_adjust_timeout(struct rpc_rqst *req); |
49e9a890 CL |
242 | void xprt_release_xprt(struct rpc_xprt *xprt, struct rpc_task *task); |
243 | void xprt_release_xprt_cong(struct rpc_xprt *xprt, struct rpc_task *task); | |
55aa4f58 CL |
244 | void xprt_release(struct rpc_task *task); |
245 | int xprt_destroy(struct rpc_xprt *xprt); | |
246 | ||
808012fb CL |
247 | static inline u32 *xprt_skip_transport_header(struct rpc_xprt *xprt, u32 *p) |
248 | { | |
249 | return p + xprt->tsh_size; | |
250 | } | |
251 | ||
55aa4f58 CL |
252 | /* |
253 | * Transport switch helper functions | |
254 | */ | |
fe3aca29 CL |
255 | void xprt_set_retrans_timeout_def(struct rpc_task *task); |
256 | void xprt_set_retrans_timeout_rtt(struct rpc_task *task); | |
55aa4f58 | 257 | void xprt_wake_pending_tasks(struct rpc_xprt *xprt, int status); |
c7b2cae8 CL |
258 | void xprt_wait_for_buffer_space(struct rpc_task *task); |
259 | void xprt_write_space(struct rpc_xprt *xprt); | |
55aa4f58 CL |
260 | struct rpc_rqst * xprt_lookup_rqst(struct rpc_xprt *xprt, u32 xid); |
261 | void xprt_complete_rqst(struct rpc_xprt *xprt, struct rpc_rqst *req, int copied); | |
262 | void xprt_disconnect(struct rpc_xprt *xprt); | |
263 | ||
264 | /* | |
265 | * Socket transport setup operations | |
266 | */ | |
267 | int xs_setup_udp(struct rpc_xprt *xprt, struct rpc_timeout *to); | |
268 | int xs_setup_tcp(struct rpc_xprt *xprt, struct rpc_timeout *to); | |
1da177e4 | 269 | |
2226feb6 CL |
270 | /* |
271 | * Reserved bit positions in xprt->state | |
272 | */ | |
273 | #define XPRT_LOCKED (0) | |
274 | #define XPRT_CONNECTED (1) | |
275 | #define XPRT_CONNECTING (2) | |
276 | ||
277 | static inline void xprt_set_connected(struct rpc_xprt *xprt) | |
278 | { | |
279 | set_bit(XPRT_CONNECTED, &xprt->state); | |
280 | } | |
281 | ||
282 | static inline void xprt_clear_connected(struct rpc_xprt *xprt) | |
283 | { | |
284 | clear_bit(XPRT_CONNECTED, &xprt->state); | |
285 | } | |
286 | ||
287 | static inline int xprt_connected(struct rpc_xprt *xprt) | |
288 | { | |
289 | return test_bit(XPRT_CONNECTED, &xprt->state); | |
290 | } | |
291 | ||
292 | static inline int xprt_test_and_set_connected(struct rpc_xprt *xprt) | |
293 | { | |
294 | return test_and_set_bit(XPRT_CONNECTED, &xprt->state); | |
295 | } | |
296 | ||
297 | static inline int xprt_test_and_clear_connected(struct rpc_xprt *xprt) | |
298 | { | |
299 | return test_and_clear_bit(XPRT_CONNECTED, &xprt->state); | |
300 | } | |
301 | ||
302 | static inline void xprt_clear_connecting(struct rpc_xprt *xprt) | |
303 | { | |
304 | smp_mb__before_clear_bit(); | |
305 | clear_bit(XPRT_CONNECTING, &xprt->state); | |
306 | smp_mb__after_clear_bit(); | |
307 | } | |
308 | ||
309 | static inline int xprt_connecting(struct rpc_xprt *xprt) | |
310 | { | |
311 | return test_bit(XPRT_CONNECTING, &xprt->state); | |
312 | } | |
313 | ||
314 | static inline int xprt_test_and_set_connecting(struct rpc_xprt *xprt) | |
315 | { | |
316 | return test_and_set_bit(XPRT_CONNECTING, &xprt->state); | |
317 | } | |
1da177e4 LT |
318 | |
319 | #endif /* __KERNEL__*/ | |
320 | ||
321 | #endif /* _LINUX_SUNRPC_XPRT_H */ |