]>
Commit | Line | Data |
---|---|---|
1da177e4 LT |
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 | 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); | |
135 | void (*connect)(struct rpc_task *task); | |
136 | int (*send_request)(struct rpc_task *task); | |
137 | void (*close)(struct rpc_xprt *xprt); | |
138 | void (*destroy)(struct rpc_xprt *xprt); | |
139 | }; | |
1da177e4 LT |
140 | |
141 | struct rpc_xprt { | |
a246b010 | 142 | struct rpc_xprt_ops * ops; /* transport methods */ |
1da177e4 LT |
143 | struct socket * sock; /* BSD socket layer */ |
144 | struct sock * inet; /* INET layer */ | |
145 | ||
146 | struct rpc_timeout timeout; /* timeout parms */ | |
147 | struct sockaddr_in addr; /* server address */ | |
148 | int prot; /* IP protocol */ | |
149 | ||
150 | unsigned long cong; /* current congestion */ | |
151 | unsigned long cwnd; /* congestion window */ | |
152 | ||
153 | unsigned int rcvsize, /* socket receive buffer size */ | |
154 | sndsize; /* socket send buffer size */ | |
155 | ||
156 | size_t max_payload; /* largest RPC payload size, | |
157 | in bytes */ | |
158 | ||
159 | struct rpc_wait_queue sending; /* requests waiting to send */ | |
160 | struct rpc_wait_queue resend; /* requests waiting to resend */ | |
161 | struct rpc_wait_queue pending; /* requests in flight */ | |
162 | struct rpc_wait_queue backlog; /* waiting for slot */ | |
163 | struct list_head free; /* free slots */ | |
164 | struct rpc_rqst * slot; /* slot table storage */ | |
165 | unsigned int max_reqs; /* total slots */ | |
166 | unsigned long sockstate; /* Socket state */ | |
167 | unsigned char shutdown : 1, /* being shut down */ | |
168 | nocong : 1, /* no congestion control */ | |
169 | resvport : 1, /* use a reserved port */ | |
170 | stream : 1; /* TCP */ | |
171 | ||
172 | /* | |
173 | * XID | |
174 | */ | |
175 | __u32 xid; /* Next XID value to use */ | |
176 | ||
177 | /* | |
178 | * State of TCP reply receive stuff | |
179 | */ | |
180 | u32 tcp_recm, /* Fragment header */ | |
181 | tcp_xid, /* Current XID */ | |
182 | tcp_reclen, /* fragment length */ | |
183 | tcp_offset; /* fragment offset */ | |
184 | unsigned long tcp_copied, /* copied to request */ | |
185 | tcp_flags; | |
186 | /* | |
187 | * Connection of sockets | |
188 | */ | |
189 | struct work_struct sock_connect; | |
190 | unsigned short port; | |
191 | /* | |
192 | * Disconnection of idle sockets | |
193 | */ | |
194 | struct work_struct task_cleanup; | |
195 | struct timer_list timer; | |
196 | unsigned long last_used; | |
197 | ||
198 | /* | |
199 | * Send stuff | |
200 | */ | |
4a0f8c04 | 201 | spinlock_t transport_lock; /* lock transport info */ |
1da177e4 LT |
202 | spinlock_t xprt_lock; /* lock xprt info */ |
203 | struct rpc_task * snd_task; /* Task blocked in send */ | |
204 | ||
205 | struct list_head recv; | |
206 | ||
207 | ||
208 | void (*old_data_ready)(struct sock *, int); | |
209 | void (*old_state_change)(struct sock *); | |
210 | void (*old_write_space)(struct sock *); | |
211 | ||
212 | wait_queue_head_t cong_wait; | |
213 | }; | |
214 | ||
a246b010 CL |
215 | #define XPRT_LAST_FRAG (1 << 0) |
216 | #define XPRT_COPY_RECM (1 << 1) | |
217 | #define XPRT_COPY_XID (1 << 2) | |
218 | #define XPRT_COPY_DATA (1 << 3) | |
219 | ||
1da177e4 LT |
220 | #ifdef __KERNEL__ |
221 | ||
222 | struct rpc_xprt * xprt_create_proto(int proto, struct sockaddr_in *addr, | |
223 | struct rpc_timeout *toparms); | |
a246b010 | 224 | void xprt_disconnect(struct rpc_xprt *); |
1da177e4 LT |
225 | int xprt_destroy(struct rpc_xprt *); |
226 | void xprt_set_timeout(struct rpc_timeout *, unsigned int, | |
227 | unsigned long); | |
a246b010 CL |
228 | struct rpc_rqst * xprt_lookup_rqst(struct rpc_xprt *, u32); |
229 | void xprt_complete_rqst(struct rpc_xprt *, | |
230 | struct rpc_rqst *, int); | |
1da177e4 LT |
231 | void xprt_reserve(struct rpc_task *); |
232 | int xprt_prepare_transmit(struct rpc_task *); | |
233 | void xprt_transmit(struct rpc_task *); | |
234 | void xprt_receive(struct rpc_task *); | |
235 | int xprt_adjust_timeout(struct rpc_rqst *req); | |
236 | void xprt_release(struct rpc_task *); | |
237 | void xprt_connect(struct rpc_task *); | |
a246b010 CL |
238 | int xs_setup_udp(struct rpc_xprt *, |
239 | struct rpc_timeout *); | |
240 | int xs_setup_tcp(struct rpc_xprt *, | |
241 | struct rpc_timeout *); | |
1da177e4 LT |
242 | |
243 | #define XPRT_LOCKED 0 | |
244 | #define XPRT_CONNECT 1 | |
245 | #define XPRT_CONNECTING 2 | |
246 | ||
247 | #define xprt_connected(xp) (test_bit(XPRT_CONNECT, &(xp)->sockstate)) | |
248 | #define xprt_set_connected(xp) (set_bit(XPRT_CONNECT, &(xp)->sockstate)) | |
249 | #define xprt_test_and_set_connected(xp) (test_and_set_bit(XPRT_CONNECT, &(xp)->sockstate)) | |
250 | #define xprt_test_and_clear_connected(xp) \ | |
251 | (test_and_clear_bit(XPRT_CONNECT, &(xp)->sockstate)) | |
252 | #define xprt_clear_connected(xp) (clear_bit(XPRT_CONNECT, &(xp)->sockstate)) | |
253 | ||
254 | #endif /* __KERNEL__*/ | |
255 | ||
256 | #endif /* _LINUX_SUNRPC_XPRT_H */ |