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 | ||
62 | /* RPC call and reply header size as number of 32bit words (verifier | |
63 | * size computed separately) | |
64 | */ | |
65 | #define RPC_CALLHDRSIZE 6 | |
66 | #define RPC_REPHDRSIZE 4 | |
67 | ||
68 | /* | |
69 | * This describes a timeout strategy | |
70 | */ | |
71 | struct rpc_timeout { | |
72 | unsigned long to_initval, /* initial timeout */ | |
73 | to_maxval, /* max timeout */ | |
74 | to_increment; /* if !exponential */ | |
75 | unsigned int to_retries; /* max # of retries */ | |
76 | unsigned char to_exponential; | |
77 | }; | |
78 | ||
79 | /* | |
80 | * This describes a complete RPC request | |
81 | */ | |
82 | struct rpc_rqst { | |
83 | /* | |
84 | * This is the user-visible part | |
85 | */ | |
86 | struct rpc_xprt * rq_xprt; /* RPC client */ | |
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 | int rq_cong; /* has incremented xprt->cong */ | |
96 | int rq_received; /* receive completed */ | |
97 | u32 rq_seqno; /* gss seq no. used on req. */ | |
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 | unsigned long rq_majortimeo; /* major timeout alarm */ | |
105 | unsigned long rq_timeout; /* Current timeout value */ | |
106 | unsigned int rq_retries; /* # of retries */ | |
107 | /* | |
108 | * For authentication (e.g. auth_des) | |
109 | */ | |
110 | u32 rq_creddata[2]; | |
111 | ||
112 | /* | |
113 | * Partial send handling | |
114 | */ | |
115 | ||
116 | u32 rq_bytes_sent; /* Bytes we have sent */ | |
117 | ||
118 | unsigned long rq_xtime; /* when transmitted */ | |
119 | int rq_ntrans; | |
120 | }; | |
121 | #define rq_svec rq_snd_buf.head | |
122 | #define rq_slen rq_snd_buf.len | |
123 | ||
124 | #define XPRT_LAST_FRAG (1 << 0) | |
125 | #define XPRT_COPY_RECM (1 << 1) | |
126 | #define XPRT_COPY_XID (1 << 2) | |
127 | #define XPRT_COPY_DATA (1 << 3) | |
128 | ||
129 | struct rpc_xprt { | |
130 | struct socket * sock; /* BSD socket layer */ | |
131 | struct sock * inet; /* INET layer */ | |
132 | ||
133 | struct rpc_timeout timeout; /* timeout parms */ | |
134 | struct sockaddr_in addr; /* server address */ | |
135 | int prot; /* IP protocol */ | |
136 | ||
137 | unsigned long cong; /* current congestion */ | |
138 | unsigned long cwnd; /* congestion window */ | |
139 | ||
140 | unsigned int rcvsize, /* socket receive buffer size */ | |
141 | sndsize; /* socket send buffer size */ | |
142 | ||
143 | size_t max_payload; /* largest RPC payload size, | |
144 | in bytes */ | |
145 | ||
146 | struct rpc_wait_queue sending; /* requests waiting to send */ | |
147 | struct rpc_wait_queue resend; /* requests waiting to resend */ | |
148 | struct rpc_wait_queue pending; /* requests in flight */ | |
149 | struct rpc_wait_queue backlog; /* waiting for slot */ | |
150 | struct list_head free; /* free slots */ | |
151 | struct rpc_rqst * slot; /* slot table storage */ | |
152 | unsigned int max_reqs; /* total slots */ | |
153 | unsigned long sockstate; /* Socket state */ | |
154 | unsigned char shutdown : 1, /* being shut down */ | |
155 | nocong : 1, /* no congestion control */ | |
156 | resvport : 1, /* use a reserved port */ | |
157 | stream : 1; /* TCP */ | |
158 | ||
159 | /* | |
160 | * XID | |
161 | */ | |
162 | __u32 xid; /* Next XID value to use */ | |
163 | ||
164 | /* | |
165 | * State of TCP reply receive stuff | |
166 | */ | |
167 | u32 tcp_recm, /* Fragment header */ | |
168 | tcp_xid, /* Current XID */ | |
169 | tcp_reclen, /* fragment length */ | |
170 | tcp_offset; /* fragment offset */ | |
171 | unsigned long tcp_copied, /* copied to request */ | |
172 | tcp_flags; | |
173 | /* | |
174 | * Connection of sockets | |
175 | */ | |
176 | struct work_struct sock_connect; | |
177 | unsigned short port; | |
178 | /* | |
179 | * Disconnection of idle sockets | |
180 | */ | |
181 | struct work_struct task_cleanup; | |
182 | struct timer_list timer; | |
183 | unsigned long last_used; | |
184 | ||
185 | /* | |
186 | * Send stuff | |
187 | */ | |
188 | spinlock_t sock_lock; /* lock socket info */ | |
189 | spinlock_t xprt_lock; /* lock xprt info */ | |
190 | struct rpc_task * snd_task; /* Task blocked in send */ | |
191 | ||
192 | struct list_head recv; | |
193 | ||
194 | ||
195 | void (*old_data_ready)(struct sock *, int); | |
196 | void (*old_state_change)(struct sock *); | |
197 | void (*old_write_space)(struct sock *); | |
198 | ||
199 | wait_queue_head_t cong_wait; | |
200 | }; | |
201 | ||
202 | #ifdef __KERNEL__ | |
203 | ||
204 | struct rpc_xprt * xprt_create_proto(int proto, struct sockaddr_in *addr, | |
205 | struct rpc_timeout *toparms); | |
206 | int xprt_destroy(struct rpc_xprt *); | |
207 | void xprt_set_timeout(struct rpc_timeout *, unsigned int, | |
208 | unsigned long); | |
209 | ||
210 | void xprt_reserve(struct rpc_task *); | |
211 | int xprt_prepare_transmit(struct rpc_task *); | |
212 | void xprt_transmit(struct rpc_task *); | |
213 | void xprt_receive(struct rpc_task *); | |
214 | int xprt_adjust_timeout(struct rpc_rqst *req); | |
215 | void xprt_release(struct rpc_task *); | |
216 | void xprt_connect(struct rpc_task *); | |
217 | void xprt_sock_setbufsize(struct rpc_xprt *); | |
218 | ||
219 | #define XPRT_LOCKED 0 | |
220 | #define XPRT_CONNECT 1 | |
221 | #define XPRT_CONNECTING 2 | |
222 | ||
223 | #define xprt_connected(xp) (test_bit(XPRT_CONNECT, &(xp)->sockstate)) | |
224 | #define xprt_set_connected(xp) (set_bit(XPRT_CONNECT, &(xp)->sockstate)) | |
225 | #define xprt_test_and_set_connected(xp) (test_and_set_bit(XPRT_CONNECT, &(xp)->sockstate)) | |
226 | #define xprt_test_and_clear_connected(xp) \ | |
227 | (test_and_clear_bit(XPRT_CONNECT, &(xp)->sockstate)) | |
228 | #define xprt_clear_connected(xp) (clear_bit(XPRT_CONNECT, &(xp)->sockstate)) | |
229 | ||
230 | #endif /* __KERNEL__*/ | |
231 | ||
232 | #endif /* _LINUX_SUNRPC_XPRT_H */ |