blob: c737acf61c7510f432280d0c97fd6440e57aa3a9 [file] [log] [blame]
Chuck Levera246b012005-08-11 16:25:23 -04001/*
2 * linux/net/sunrpc/xprtsock.c
3 *
4 * Client-side transport implementation for sockets.
5 *
6 * TCP callback races fixes (C) 1998 Red Hat Software <alan@redhat.com>
7 * TCP send fixes (C) 1998 Red Hat Software <alan@redhat.com>
8 * TCP NFS related read + write fixes
9 * (C) 1999 Dave Airlie, University of Limerick, Ireland <airlied@linux.ie>
10 *
11 * Rewrite of larges part of the code in order to stabilize TCP stuff.
12 * Fix behaviour when socket buffer is full.
13 * (C) 1999 Trond Myklebust <trond.myklebust@fys.uio.no>
Chuck Lever55aa4f52005-08-11 16:25:47 -040014 *
15 * IP socket transport implementation, (C) 2005 Chuck Lever <cel@netapp.com>
Chuck Levera246b012005-08-11 16:25:23 -040016 */
17
18#include <linux/types.h>
19#include <linux/slab.h>
20#include <linux/capability.h>
21#include <linux/sched.h>
22#include <linux/pagemap.h>
23#include <linux/errno.h>
24#include <linux/socket.h>
25#include <linux/in.h>
26#include <linux/net.h>
27#include <linux/mm.h>
28#include <linux/udp.h>
29#include <linux/tcp.h>
30#include <linux/sunrpc/clnt.h>
Chuck Lever02107142006-01-03 09:55:49 +010031#include <linux/sunrpc/sched.h>
Chuck Levera246b012005-08-11 16:25:23 -040032#include <linux/file.h>
33
34#include <net/sock.h>
35#include <net/checksum.h>
36#include <net/udp.h>
37#include <net/tcp.h>
38
Chuck Lever9903cd12005-08-11 16:25:26 -040039/*
Chuck Leverc556b752005-11-01 12:24:48 -050040 * xprtsock tunables
41 */
42unsigned int xprt_udp_slot_table_entries = RPC_DEF_SLOT_TABLE;
43unsigned int xprt_tcp_slot_table_entries = RPC_DEF_SLOT_TABLE;
44
45unsigned int xprt_min_resvport = RPC_DEF_MIN_RESVPORT;
46unsigned int xprt_max_resvport = RPC_DEF_MAX_RESVPORT;
47
48/*
Chuck Lever262965f2005-08-11 16:25:56 -040049 * How many times to try sending a request on a socket before waiting
50 * for the socket buffer to clear.
51 */
52#define XS_SENDMSG_RETRY (10U)
53
Chuck Lever03bf4b72005-08-25 16:25:55 -070054/*
55 * Time out for an RPC UDP socket connect. UDP socket connects are
56 * synchronous, but we set a timeout anyway in case of resource
57 * exhaustion on the local host.
58 */
59#define XS_UDP_CONN_TO (5U * HZ)
60
61/*
62 * Wait duration for an RPC TCP connection to be established. Solaris
63 * NFS over TCP uses 60 seconds, for example, which is in line with how
64 * long a server takes to reboot.
65 */
66#define XS_TCP_CONN_TO (60U * HZ)
67
68/*
69 * Wait duration for a reply from the RPC portmapper.
70 */
71#define XS_BIND_TO (60U * HZ)
72
73/*
74 * Delay if a UDP socket connect error occurs. This is most likely some
75 * kind of resource problem on the local host.
76 */
77#define XS_UDP_REEST_TO (2U * HZ)
78
79/*
80 * The reestablish timeout allows clients to delay for a bit before attempting
81 * to reconnect to a server that just dropped our connection.
82 *
83 * We implement an exponential backoff when trying to reestablish a TCP
84 * transport connection with the server. Some servers like to drop a TCP
85 * connection when they are overworked, so we start with a short timeout and
86 * increase over time if the server is down or not responding.
87 */
88#define XS_TCP_INIT_REEST_TO (3U * HZ)
89#define XS_TCP_MAX_REEST_TO (5U * 60 * HZ)
90
91/*
92 * TCP idle timeout; client drops the transport socket if it is idle
93 * for this long. Note that we also timeout UDP sockets to prevent
94 * holding port numbers when there is no RPC traffic.
95 */
96#define XS_IDLE_DISC_TO (5U * 60 * HZ)
97
Chuck Levera246b012005-08-11 16:25:23 -040098#ifdef RPC_DEBUG
99# undef RPC_DEBUG_DATA
Chuck Lever9903cd12005-08-11 16:25:26 -0400100# define RPCDBG_FACILITY RPCDBG_TRANS
Chuck Levera246b012005-08-11 16:25:23 -0400101#endif
102
Chuck Levera246b012005-08-11 16:25:23 -0400103#ifdef RPC_DEBUG_DATA
Chuck Lever9903cd12005-08-11 16:25:26 -0400104static void xs_pktdump(char *msg, u32 *packet, unsigned int count)
Chuck Levera246b012005-08-11 16:25:23 -0400105{
Chuck Lever9903cd12005-08-11 16:25:26 -0400106 u8 *buf = (u8 *) packet;
107 int j;
Chuck Levera246b012005-08-11 16:25:23 -0400108
109 dprintk("RPC: %s\n", msg);
110 for (j = 0; j < count && j < 128; j += 4) {
111 if (!(j & 31)) {
112 if (j)
113 dprintk("\n");
114 dprintk("0x%04x ", j);
115 }
116 dprintk("%02x%02x%02x%02x ",
117 buf[j], buf[j+1], buf[j+2], buf[j+3]);
118 }
119 dprintk("\n");
120}
121#else
Chuck Lever9903cd12005-08-11 16:25:26 -0400122static inline void xs_pktdump(char *msg, u32 *packet, unsigned int count)
Chuck Levera246b012005-08-11 16:25:23 -0400123{
124 /* NOP */
125}
126#endif
127
Chuck Leverffc2e512006-12-05 16:35:11 -0500128struct sock_xprt {
129 struct rpc_xprt xprt;
Chuck Leveree0ac0c2006-12-05 16:35:15 -0500130
131 /*
132 * Network layer
133 */
134 struct socket * sock;
135 struct sock * inet;
Chuck Lever51971132006-12-05 16:35:19 -0500136
137 /*
138 * State of TCP reply receive
139 */
140 __be32 tcp_fraghdr,
141 tcp_xid;
142
143 u32 tcp_offset,
144 tcp_reclen;
145
146 unsigned long tcp_copied,
147 tcp_flags;
Chuck Leverffc2e512006-12-05 16:35:11 -0500148};
149
Chuck Levere136d092006-12-05 16:35:23 -0500150/*
151 * TCP receive state flags
152 */
153#define TCP_RCV_LAST_FRAG (1UL << 0)
154#define TCP_RCV_COPY_FRAGHDR (1UL << 1)
155#define TCP_RCV_COPY_XID (1UL << 2)
156#define TCP_RCV_COPY_DATA (1UL << 3)
157
Chuck Leveredb267a2006-08-22 20:06:18 -0400158static void xs_format_peer_addresses(struct rpc_xprt *xprt)
159{
160 struct sockaddr_in *addr = (struct sockaddr_in *) &xprt->addr;
161 char *buf;
162
163 buf = kzalloc(20, GFP_KERNEL);
164 if (buf) {
165 snprintf(buf, 20, "%u.%u.%u.%u",
166 NIPQUAD(addr->sin_addr.s_addr));
167 }
168 xprt->address_strings[RPC_DISPLAY_ADDR] = buf;
169
170 buf = kzalloc(8, GFP_KERNEL);
171 if (buf) {
172 snprintf(buf, 8, "%u",
173 ntohs(addr->sin_port));
174 }
175 xprt->address_strings[RPC_DISPLAY_PORT] = buf;
176
177 if (xprt->prot == IPPROTO_UDP)
178 xprt->address_strings[RPC_DISPLAY_PROTO] = "udp";
179 else
180 xprt->address_strings[RPC_DISPLAY_PROTO] = "tcp";
181
182 buf = kzalloc(48, GFP_KERNEL);
183 if (buf) {
184 snprintf(buf, 48, "addr=%u.%u.%u.%u port=%u proto=%s",
185 NIPQUAD(addr->sin_addr.s_addr),
186 ntohs(addr->sin_port),
187 xprt->prot == IPPROTO_UDP ? "udp" : "tcp");
188 }
189 xprt->address_strings[RPC_DISPLAY_ALL] = buf;
190}
191
192static void xs_free_peer_addresses(struct rpc_xprt *xprt)
193{
194 kfree(xprt->address_strings[RPC_DISPLAY_ADDR]);
195 kfree(xprt->address_strings[RPC_DISPLAY_PORT]);
196 kfree(xprt->address_strings[RPC_DISPLAY_ALL]);
197}
198
Chuck Leverb4b5cc82005-08-11 16:25:29 -0400199#define XS_SENDMSG_FLAGS (MSG_DONTWAIT | MSG_NOSIGNAL)
200
Trond Myklebust24c56842006-10-17 15:06:22 -0400201static int xs_send_kvec(struct socket *sock, struct sockaddr *addr, int addrlen, struct kvec *vec, unsigned int base, int more)
Chuck Leverb4b5cc82005-08-11 16:25:29 -0400202{
Chuck Leverb4b5cc82005-08-11 16:25:29 -0400203 struct msghdr msg = {
204 .msg_name = addr,
205 .msg_namelen = addrlen,
Trond Myklebust24c56842006-10-17 15:06:22 -0400206 .msg_flags = XS_SENDMSG_FLAGS | (more ? MSG_MORE : 0),
207 };
208 struct kvec iov = {
209 .iov_base = vec->iov_base + base,
210 .iov_len = vec->iov_len - base,
Chuck Leverb4b5cc82005-08-11 16:25:29 -0400211 };
212
Trond Myklebust24c56842006-10-17 15:06:22 -0400213 if (iov.iov_len != 0)
Chuck Leverb4b5cc82005-08-11 16:25:29 -0400214 return kernel_sendmsg(sock, &msg, &iov, 1, iov.iov_len);
215 return kernel_sendmsg(sock, &msg, NULL, 0, 0);
216}
217
Trond Myklebust24c56842006-10-17 15:06:22 -0400218static int xs_send_pagedata(struct socket *sock, struct xdr_buf *xdr, unsigned int base, int more)
Chuck Leverb4b5cc82005-08-11 16:25:29 -0400219{
Trond Myklebust24c56842006-10-17 15:06:22 -0400220 struct page **ppage;
221 unsigned int remainder;
222 int err, sent = 0;
Chuck Leverb4b5cc82005-08-11 16:25:29 -0400223
Trond Myklebust24c56842006-10-17 15:06:22 -0400224 remainder = xdr->page_len - base;
225 base += xdr->page_base;
226 ppage = xdr->pages + (base >> PAGE_SHIFT);
227 base &= ~PAGE_MASK;
228 for(;;) {
229 unsigned int len = min_t(unsigned int, PAGE_SIZE - base, remainder);
230 int flags = XS_SENDMSG_FLAGS;
231
232 remainder -= len;
233 if (remainder != 0 || more)
234 flags |= MSG_MORE;
235 err = sock->ops->sendpage(sock, *ppage, base, len, flags);
236 if (remainder == 0 || err != len)
237 break;
238 sent += err;
239 ppage++;
240 base = 0;
241 }
242 if (sent == 0)
243 return err;
244 if (err > 0)
245 sent += err;
246 return sent;
Chuck Leverb4b5cc82005-08-11 16:25:29 -0400247}
248
Chuck Lever9903cd12005-08-11 16:25:26 -0400249/**
250 * xs_sendpages - write pages directly to a socket
251 * @sock: socket to send on
252 * @addr: UDP only -- address of destination
253 * @addrlen: UDP only -- length of destination address
254 * @xdr: buffer containing this request
255 * @base: starting position in the buffer
256 *
Chuck Levera246b012005-08-11 16:25:23 -0400257 */
Trond Myklebust24c56842006-10-17 15:06:22 -0400258static int xs_sendpages(struct socket *sock, struct sockaddr *addr, int addrlen, struct xdr_buf *xdr, unsigned int base)
Chuck Levera246b012005-08-11 16:25:23 -0400259{
Trond Myklebust24c56842006-10-17 15:06:22 -0400260 unsigned int remainder = xdr->len - base;
261 int err, sent = 0;
Chuck Levera246b012005-08-11 16:25:23 -0400262
Chuck Lever262965f2005-08-11 16:25:56 -0400263 if (unlikely(!sock))
264 return -ENOTCONN;
265
266 clear_bit(SOCK_ASYNC_NOSPACE, &sock->flags);
Trond Myklebust24c56842006-10-17 15:06:22 -0400267 if (base != 0) {
268 addr = NULL;
269 addrlen = 0;
270 }
Chuck Lever262965f2005-08-11 16:25:56 -0400271
Trond Myklebust24c56842006-10-17 15:06:22 -0400272 if (base < xdr->head[0].iov_len || addr != NULL) {
273 unsigned int len = xdr->head[0].iov_len - base;
274 remainder -= len;
275 err = xs_send_kvec(sock, addr, addrlen, &xdr->head[0], base, remainder != 0);
276 if (remainder == 0 || err != len)
Chuck Levera246b012005-08-11 16:25:23 -0400277 goto out;
Trond Myklebust24c56842006-10-17 15:06:22 -0400278 sent += err;
Chuck Levera246b012005-08-11 16:25:23 -0400279 base = 0;
280 } else
Trond Myklebust24c56842006-10-17 15:06:22 -0400281 base -= xdr->head[0].iov_len;
Chuck Levera246b012005-08-11 16:25:23 -0400282
Trond Myklebust24c56842006-10-17 15:06:22 -0400283 if (base < xdr->page_len) {
284 unsigned int len = xdr->page_len - base;
285 remainder -= len;
286 err = xs_send_pagedata(sock, xdr, base, remainder != 0);
287 if (remainder == 0 || err != len)
Chuck Levera246b012005-08-11 16:25:23 -0400288 goto out;
Trond Myklebust24c56842006-10-17 15:06:22 -0400289 sent += err;
Chuck Levera246b012005-08-11 16:25:23 -0400290 base = 0;
Trond Myklebust24c56842006-10-17 15:06:22 -0400291 } else
292 base -= xdr->page_len;
293
294 if (base >= xdr->tail[0].iov_len)
295 return sent;
296 err = xs_send_kvec(sock, NULL, 0, &xdr->tail[0], base, 0);
Chuck Levera246b012005-08-11 16:25:23 -0400297out:
Trond Myklebust24c56842006-10-17 15:06:22 -0400298 if (sent == 0)
299 return err;
300 if (err > 0)
301 sent += err;
302 return sent;
Chuck Levera246b012005-08-11 16:25:23 -0400303}
304
Chuck Lever9903cd12005-08-11 16:25:26 -0400305/**
Chuck Lever262965f2005-08-11 16:25:56 -0400306 * xs_nospace - place task on wait queue if transmit was incomplete
307 * @task: task to put to sleep
Chuck Lever9903cd12005-08-11 16:25:26 -0400308 *
Chuck Levera246b012005-08-11 16:25:23 -0400309 */
Chuck Lever262965f2005-08-11 16:25:56 -0400310static void xs_nospace(struct rpc_task *task)
Chuck Levera246b012005-08-11 16:25:23 -0400311{
Chuck Lever262965f2005-08-11 16:25:56 -0400312 struct rpc_rqst *req = task->tk_rqstp;
313 struct rpc_xprt *xprt = req->rq_xprt;
Chuck Leveree0ac0c2006-12-05 16:35:15 -0500314 struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
Chuck Levera246b012005-08-11 16:25:23 -0400315
Chuck Lever262965f2005-08-11 16:25:56 -0400316 dprintk("RPC: %4d xmit incomplete (%u left of %u)\n",
317 task->tk_pid, req->rq_slen - req->rq_bytes_sent,
318 req->rq_slen);
319
Chuck Leveree0ac0c2006-12-05 16:35:15 -0500320 if (test_bit(SOCK_ASYNC_NOSPACE, &transport->sock->flags)) {
Chuck Lever262965f2005-08-11 16:25:56 -0400321 /* Protect against races with write_space */
322 spin_lock_bh(&xprt->transport_lock);
323
324 /* Don't race with disconnect */
325 if (!xprt_connected(xprt))
326 task->tk_status = -ENOTCONN;
Chuck Leveree0ac0c2006-12-05 16:35:15 -0500327 else if (test_bit(SOCK_NOSPACE, &transport->sock->flags))
Chuck Lever262965f2005-08-11 16:25:56 -0400328 xprt_wait_for_buffer_space(task);
329
330 spin_unlock_bh(&xprt->transport_lock);
331 } else
332 /* Keep holding the socket if it is blocked */
333 rpc_delay(task, HZ>>4);
334}
335
336/**
337 * xs_udp_send_request - write an RPC request to a UDP socket
338 * @task: address of RPC task that manages the state of an RPC request
339 *
340 * Return values:
341 * 0: The request has been sent
342 * EAGAIN: The socket was blocked, please call again later to
343 * complete the request
344 * ENOTCONN: Caller needs to invoke connect logic then call again
345 * other: Some other error occured, the request was not sent
346 */
347static int xs_udp_send_request(struct rpc_task *task)
348{
349 struct rpc_rqst *req = task->tk_rqstp;
350 struct rpc_xprt *xprt = req->rq_xprt;
Chuck Leveree0ac0c2006-12-05 16:35:15 -0500351 struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
Chuck Lever262965f2005-08-11 16:25:56 -0400352 struct xdr_buf *xdr = &req->rq_snd_buf;
353 int status;
Chuck Levera246b012005-08-11 16:25:23 -0400354
Chuck Lever9903cd12005-08-11 16:25:26 -0400355 xs_pktdump("packet data:",
Chuck Levera246b012005-08-11 16:25:23 -0400356 req->rq_svec->iov_base,
357 req->rq_svec->iov_len);
358
Chuck Lever262965f2005-08-11 16:25:56 -0400359 req->rq_xtime = jiffies;
Chuck Leveree0ac0c2006-12-05 16:35:15 -0500360 status = xs_sendpages(transport->sock,
361 (struct sockaddr *) &xprt->addr,
362 xprt->addrlen, xdr,
363 req->rq_bytes_sent);
Chuck Levera246b012005-08-11 16:25:23 -0400364
Chuck Lever262965f2005-08-11 16:25:56 -0400365 dprintk("RPC: xs_udp_send_request(%u) = %d\n",
366 xdr->len - req->rq_bytes_sent, status);
Chuck Levera246b012005-08-11 16:25:23 -0400367
Chuck Lever262965f2005-08-11 16:25:56 -0400368 if (likely(status >= (int) req->rq_slen))
369 return 0;
Chuck Levera246b012005-08-11 16:25:23 -0400370
Chuck Lever262965f2005-08-11 16:25:56 -0400371 /* Still some bytes left; set up for a retry later. */
372 if (status > 0)
373 status = -EAGAIN;
Chuck Levera246b012005-08-11 16:25:23 -0400374
Chuck Lever262965f2005-08-11 16:25:56 -0400375 switch (status) {
376 case -ENETUNREACH:
377 case -EPIPE:
Chuck Levera246b012005-08-11 16:25:23 -0400378 case -ECONNREFUSED:
379 /* When the server has died, an ICMP port unreachable message
Chuck Lever9903cd12005-08-11 16:25:26 -0400380 * prompts ECONNREFUSED. */
Chuck Levera246b012005-08-11 16:25:23 -0400381 break;
Chuck Lever262965f2005-08-11 16:25:56 -0400382 case -EAGAIN:
383 xs_nospace(task);
Chuck Levera246b012005-08-11 16:25:23 -0400384 break;
385 default:
Chuck Lever262965f2005-08-11 16:25:56 -0400386 dprintk("RPC: sendmsg returned unrecognized error %d\n",
387 -status);
Chuck Lever9903cd12005-08-11 16:25:26 -0400388 break;
Chuck Levera246b012005-08-11 16:25:23 -0400389 }
Chuck Lever262965f2005-08-11 16:25:56 -0400390
391 return status;
Chuck Levera246b012005-08-11 16:25:23 -0400392}
393
Chuck Lever808012f2005-08-25 16:25:49 -0700394static inline void xs_encode_tcp_record_marker(struct xdr_buf *buf)
395{
396 u32 reclen = buf->len - sizeof(rpc_fraghdr);
397 rpc_fraghdr *base = buf->head[0].iov_base;
398 *base = htonl(RPC_LAST_STREAM_FRAGMENT | reclen);
399}
400
Chuck Lever9903cd12005-08-11 16:25:26 -0400401/**
Chuck Lever262965f2005-08-11 16:25:56 -0400402 * xs_tcp_send_request - write an RPC request to a TCP socket
Chuck Lever9903cd12005-08-11 16:25:26 -0400403 * @task: address of RPC task that manages the state of an RPC request
404 *
405 * Return values:
Chuck Lever262965f2005-08-11 16:25:56 -0400406 * 0: The request has been sent
407 * EAGAIN: The socket was blocked, please call again later to
408 * complete the request
409 * ENOTCONN: Caller needs to invoke connect logic then call again
410 * other: Some other error occured, the request was not sent
Chuck Lever9903cd12005-08-11 16:25:26 -0400411 *
412 * XXX: In the case of soft timeouts, should we eventually give up
Chuck Lever262965f2005-08-11 16:25:56 -0400413 * if sendmsg is not able to make progress?
Chuck Lever9903cd12005-08-11 16:25:26 -0400414 */
Chuck Lever262965f2005-08-11 16:25:56 -0400415static int xs_tcp_send_request(struct rpc_task *task)
Chuck Levera246b012005-08-11 16:25:23 -0400416{
417 struct rpc_rqst *req = task->tk_rqstp;
418 struct rpc_xprt *xprt = req->rq_xprt;
Chuck Leveree0ac0c2006-12-05 16:35:15 -0500419 struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
Chuck Lever262965f2005-08-11 16:25:56 -0400420 struct xdr_buf *xdr = &req->rq_snd_buf;
Chuck Levera246b012005-08-11 16:25:23 -0400421 int status, retry = 0;
422
Chuck Lever808012f2005-08-25 16:25:49 -0700423 xs_encode_tcp_record_marker(&req->rq_snd_buf);
Chuck Levera246b012005-08-11 16:25:23 -0400424
Chuck Lever262965f2005-08-11 16:25:56 -0400425 xs_pktdump("packet data:",
426 req->rq_svec->iov_base,
427 req->rq_svec->iov_len);
Chuck Levera246b012005-08-11 16:25:23 -0400428
429 /* Continue transmitting the packet/record. We must be careful
430 * to cope with writespace callbacks arriving _after_ we have
Chuck Lever262965f2005-08-11 16:25:56 -0400431 * called sendmsg(). */
Chuck Levera246b012005-08-11 16:25:23 -0400432 while (1) {
433 req->rq_xtime = jiffies;
Chuck Leveree0ac0c2006-12-05 16:35:15 -0500434 status = xs_sendpages(transport->sock,
435 NULL, 0, xdr, req->rq_bytes_sent);
Chuck Levera246b012005-08-11 16:25:23 -0400436
Chuck Lever262965f2005-08-11 16:25:56 -0400437 dprintk("RPC: xs_tcp_send_request(%u) = %d\n",
438 xdr->len - req->rq_bytes_sent, status);
439
440 if (unlikely(status < 0))
Chuck Levera246b012005-08-11 16:25:23 -0400441 break;
442
Chuck Lever262965f2005-08-11 16:25:56 -0400443 /* If we've sent the entire packet, immediately
444 * reset the count of bytes sent. */
445 req->rq_bytes_sent += status;
Chuck Leveref759a22006-03-20 13:44:17 -0500446 task->tk_bytes_sent += status;
Chuck Lever262965f2005-08-11 16:25:56 -0400447 if (likely(req->rq_bytes_sent >= req->rq_slen)) {
448 req->rq_bytes_sent = 0;
449 return 0;
Chuck Levera246b012005-08-11 16:25:23 -0400450 }
451
Chuck Levera246b012005-08-11 16:25:23 -0400452 status = -EAGAIN;
Chuck Lever262965f2005-08-11 16:25:56 -0400453 if (retry++ > XS_SENDMSG_RETRY)
Chuck Levera246b012005-08-11 16:25:23 -0400454 break;
455 }
456
Chuck Lever262965f2005-08-11 16:25:56 -0400457 switch (status) {
458 case -EAGAIN:
459 xs_nospace(task);
460 break;
461 case -ECONNREFUSED:
462 case -ECONNRESET:
463 case -ENOTCONN:
464 case -EPIPE:
465 status = -ENOTCONN;
466 break;
467 default:
468 dprintk("RPC: sendmsg returned unrecognized error %d\n",
469 -status);
Chuck Lever43118c22005-08-25 16:25:49 -0700470 xprt_disconnect(xprt);
Chuck Lever262965f2005-08-11 16:25:56 -0400471 break;
Chuck Levera246b012005-08-11 16:25:23 -0400472 }
Chuck Lever262965f2005-08-11 16:25:56 -0400473
Chuck Levera246b012005-08-11 16:25:23 -0400474 return status;
475}
476
Chuck Lever9903cd12005-08-11 16:25:26 -0400477/**
Trond Myklebuste0ab53d2006-07-27 17:22:50 -0400478 * xs_tcp_release_xprt - clean up after a tcp transmission
479 * @xprt: transport
480 * @task: rpc task
481 *
482 * This cleans up if an error causes us to abort the transmission of a request.
483 * In this case, the socket may need to be reset in order to avoid confusing
484 * the server.
485 */
486static void xs_tcp_release_xprt(struct rpc_xprt *xprt, struct rpc_task *task)
487{
488 struct rpc_rqst *req;
489
490 if (task != xprt->snd_task)
491 return;
492 if (task == NULL)
493 goto out_release;
494 req = task->tk_rqstp;
495 if (req->rq_bytes_sent == 0)
496 goto out_release;
497 if (req->rq_bytes_sent == req->rq_snd_buf.len)
498 goto out_release;
499 set_bit(XPRT_CLOSE_WAIT, &task->tk_xprt->state);
500out_release:
501 xprt_release_xprt(xprt, task);
502}
503
504/**
Chuck Lever9903cd12005-08-11 16:25:26 -0400505 * xs_close - close a socket
506 * @xprt: transport
507 *
Chuck Lever3167e122005-08-25 16:25:55 -0700508 * This is used when all requests are complete; ie, no DRC state remains
509 * on the server we want to save.
Chuck Levera246b012005-08-11 16:25:23 -0400510 */
Chuck Lever9903cd12005-08-11 16:25:26 -0400511static void xs_close(struct rpc_xprt *xprt)
Chuck Levera246b012005-08-11 16:25:23 -0400512{
Chuck Leveree0ac0c2006-12-05 16:35:15 -0500513 struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
514 struct socket *sock = transport->sock;
515 struct sock *sk = transport->inet;
Chuck Levera246b012005-08-11 16:25:23 -0400516
517 if (!sk)
Trond Myklebust632e3bd2006-01-03 09:55:55 +0100518 goto clear_close_wait;
Chuck Levera246b012005-08-11 16:25:23 -0400519
Chuck Lever9903cd12005-08-11 16:25:26 -0400520 dprintk("RPC: xs_close xprt %p\n", xprt);
521
Chuck Levera246b012005-08-11 16:25:23 -0400522 write_lock_bh(&sk->sk_callback_lock);
Chuck Leveree0ac0c2006-12-05 16:35:15 -0500523 transport->inet = NULL;
524 transport->sock = NULL;
Chuck Levera246b012005-08-11 16:25:23 -0400525
Chuck Lever9903cd12005-08-11 16:25:26 -0400526 sk->sk_user_data = NULL;
527 sk->sk_data_ready = xprt->old_data_ready;
Chuck Levera246b012005-08-11 16:25:23 -0400528 sk->sk_state_change = xprt->old_state_change;
Chuck Lever9903cd12005-08-11 16:25:26 -0400529 sk->sk_write_space = xprt->old_write_space;
Chuck Levera246b012005-08-11 16:25:23 -0400530 write_unlock_bh(&sk->sk_callback_lock);
531
Chuck Lever9903cd12005-08-11 16:25:26 -0400532 sk->sk_no_check = 0;
Chuck Levera246b012005-08-11 16:25:23 -0400533
534 sock_release(sock);
Trond Myklebust632e3bd2006-01-03 09:55:55 +0100535clear_close_wait:
536 smp_mb__before_clear_bit();
537 clear_bit(XPRT_CLOSE_WAIT, &xprt->state);
538 smp_mb__after_clear_bit();
Chuck Levera246b012005-08-11 16:25:23 -0400539}
540
Chuck Lever9903cd12005-08-11 16:25:26 -0400541/**
542 * xs_destroy - prepare to shutdown a transport
543 * @xprt: doomed transport
544 *
545 */
546static void xs_destroy(struct rpc_xprt *xprt)
Chuck Levera246b012005-08-11 16:25:23 -0400547{
Chuck Lever9903cd12005-08-11 16:25:26 -0400548 dprintk("RPC: xs_destroy xprt %p\n", xprt);
549
Chuck Lever55aa4f52005-08-11 16:25:47 -0400550 cancel_delayed_work(&xprt->connect_worker);
Chuck Levera246b012005-08-11 16:25:23 -0400551 flush_scheduled_work();
552
553 xprt_disconnect(xprt);
Chuck Lever9903cd12005-08-11 16:25:26 -0400554 xs_close(xprt);
Chuck Leveredb267a2006-08-22 20:06:18 -0400555 xs_free_peer_addresses(xprt);
Chuck Levera246b012005-08-11 16:25:23 -0400556 kfree(xprt->slot);
Chuck Leverc8541ec2006-10-17 14:44:27 -0400557 kfree(xprt);
Chuck Levera246b012005-08-11 16:25:23 -0400558}
559
Chuck Lever9903cd12005-08-11 16:25:26 -0400560static inline struct rpc_xprt *xprt_from_sock(struct sock *sk)
Chuck Levera246b012005-08-11 16:25:23 -0400561{
Chuck Lever9903cd12005-08-11 16:25:26 -0400562 return (struct rpc_xprt *) sk->sk_user_data;
563}
564
565/**
566 * xs_udp_data_ready - "data ready" callback for UDP sockets
567 * @sk: socket with data to read
568 * @len: how much data to read
569 *
570 */
571static void xs_udp_data_ready(struct sock *sk, int len)
572{
573 struct rpc_task *task;
574 struct rpc_xprt *xprt;
Chuck Levera246b012005-08-11 16:25:23 -0400575 struct rpc_rqst *rovr;
Chuck Lever9903cd12005-08-11 16:25:26 -0400576 struct sk_buff *skb;
Chuck Levera246b012005-08-11 16:25:23 -0400577 int err, repsize, copied;
Alexey Dobriyand8ed0292006-09-26 22:29:38 -0700578 u32 _xid;
579 __be32 *xp;
Chuck Levera246b012005-08-11 16:25:23 -0400580
581 read_lock(&sk->sk_callback_lock);
Chuck Lever9903cd12005-08-11 16:25:26 -0400582 dprintk("RPC: xs_udp_data_ready...\n");
583 if (!(xprt = xprt_from_sock(sk)))
Chuck Levera246b012005-08-11 16:25:23 -0400584 goto out;
Chuck Levera246b012005-08-11 16:25:23 -0400585
586 if ((skb = skb_recv_datagram(sk, 0, 1, &err)) == NULL)
587 goto out;
588
589 if (xprt->shutdown)
590 goto dropit;
591
592 repsize = skb->len - sizeof(struct udphdr);
593 if (repsize < 4) {
Chuck Lever9903cd12005-08-11 16:25:26 -0400594 dprintk("RPC: impossible RPC reply size %d!\n", repsize);
Chuck Levera246b012005-08-11 16:25:23 -0400595 goto dropit;
596 }
597
598 /* Copy the XID from the skb... */
599 xp = skb_header_pointer(skb, sizeof(struct udphdr),
600 sizeof(_xid), &_xid);
601 if (xp == NULL)
602 goto dropit;
603
604 /* Look up and lock the request corresponding to the given XID */
Chuck Lever4a0f8c02005-08-11 16:25:32 -0400605 spin_lock(&xprt->transport_lock);
Chuck Levera246b012005-08-11 16:25:23 -0400606 rovr = xprt_lookup_rqst(xprt, *xp);
607 if (!rovr)
608 goto out_unlock;
609 task = rovr->rq_task;
610
Chuck Levera246b012005-08-11 16:25:23 -0400611 if ((copied = rovr->rq_private_buf.buflen) > repsize)
612 copied = repsize;
613
614 /* Suck it into the iovec, verify checksum if not done by hw. */
615 if (csum_partial_copy_to_xdr(&rovr->rq_private_buf, skb))
616 goto out_unlock;
617
618 /* Something worked... */
619 dst_confirm(skb->dst);
620
Chuck Lever1570c1e2005-08-25 16:25:52 -0700621 xprt_adjust_cwnd(task, copied);
622 xprt_update_rtt(task);
623 xprt_complete_rqst(task, copied);
Chuck Levera246b012005-08-11 16:25:23 -0400624
625 out_unlock:
Chuck Lever4a0f8c02005-08-11 16:25:32 -0400626 spin_unlock(&xprt->transport_lock);
Chuck Levera246b012005-08-11 16:25:23 -0400627 dropit:
628 skb_free_datagram(sk, skb);
629 out:
630 read_unlock(&sk->sk_callback_lock);
631}
632
Chuck Lever9903cd12005-08-11 16:25:26 -0400633static inline size_t xs_tcp_copy_data(skb_reader_t *desc, void *p, size_t len)
Chuck Levera246b012005-08-11 16:25:23 -0400634{
635 if (len > desc->count)
636 len = desc->count;
637 if (skb_copy_bits(desc->skb, desc->offset, p, len)) {
638 dprintk("RPC: failed to copy %zu bytes from skb. %zu bytes remain\n",
639 len, desc->count);
640 return 0;
641 }
642 desc->offset += len;
643 desc->count -= len;
644 dprintk("RPC: copied %zu bytes from skb. %zu bytes remain\n",
645 len, desc->count);
646 return len;
647}
648
Chuck Lever9903cd12005-08-11 16:25:26 -0400649static inline void xs_tcp_read_fraghdr(struct rpc_xprt *xprt, skb_reader_t *desc)
Chuck Levera246b012005-08-11 16:25:23 -0400650{
Chuck Lever51971132006-12-05 16:35:19 -0500651 struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
Chuck Levera246b012005-08-11 16:25:23 -0400652 size_t len, used;
653 char *p;
654
Chuck Lever51971132006-12-05 16:35:19 -0500655 p = ((char *) &transport->tcp_fraghdr) + transport->tcp_offset;
656 len = sizeof(transport->tcp_fraghdr) - transport->tcp_offset;
Chuck Lever9903cd12005-08-11 16:25:26 -0400657 used = xs_tcp_copy_data(desc, p, len);
Chuck Lever51971132006-12-05 16:35:19 -0500658 transport->tcp_offset += used;
Chuck Levera246b012005-08-11 16:25:23 -0400659 if (used != len)
660 return;
Chuck Lever808012f2005-08-25 16:25:49 -0700661
Chuck Lever51971132006-12-05 16:35:19 -0500662 transport->tcp_reclen = ntohl(transport->tcp_fraghdr);
663 if (transport->tcp_reclen & RPC_LAST_STREAM_FRAGMENT)
Chuck Levere136d092006-12-05 16:35:23 -0500664 transport->tcp_flags |= TCP_RCV_LAST_FRAG;
Chuck Levera246b012005-08-11 16:25:23 -0400665 else
Chuck Levere136d092006-12-05 16:35:23 -0500666 transport->tcp_flags &= ~TCP_RCV_LAST_FRAG;
Chuck Lever51971132006-12-05 16:35:19 -0500667 transport->tcp_reclen &= RPC_FRAGMENT_SIZE_MASK;
Chuck Lever808012f2005-08-25 16:25:49 -0700668
Chuck Levere136d092006-12-05 16:35:23 -0500669 transport->tcp_flags &= ~TCP_RCV_COPY_FRAGHDR;
Chuck Lever51971132006-12-05 16:35:19 -0500670 transport->tcp_offset = 0;
Chuck Lever808012f2005-08-25 16:25:49 -0700671
Chuck Levera246b012005-08-11 16:25:23 -0400672 /* Sanity check of the record length */
Chuck Lever51971132006-12-05 16:35:19 -0500673 if (unlikely(transport->tcp_reclen < 4)) {
Chuck Lever9903cd12005-08-11 16:25:26 -0400674 dprintk("RPC: invalid TCP record fragment length\n");
Chuck Levera246b012005-08-11 16:25:23 -0400675 xprt_disconnect(xprt);
Chuck Lever9903cd12005-08-11 16:25:26 -0400676 return;
Chuck Levera246b012005-08-11 16:25:23 -0400677 }
678 dprintk("RPC: reading TCP record fragment of length %d\n",
Chuck Lever51971132006-12-05 16:35:19 -0500679 transport->tcp_reclen);
Chuck Levera246b012005-08-11 16:25:23 -0400680}
681
Chuck Lever51971132006-12-05 16:35:19 -0500682static void xs_tcp_check_fraghdr(struct sock_xprt *transport)
Chuck Levera246b012005-08-11 16:25:23 -0400683{
Chuck Lever51971132006-12-05 16:35:19 -0500684 if (transport->tcp_offset == transport->tcp_reclen) {
Chuck Levere136d092006-12-05 16:35:23 -0500685 transport->tcp_flags |= TCP_RCV_COPY_FRAGHDR;
Chuck Lever51971132006-12-05 16:35:19 -0500686 transport->tcp_offset = 0;
Chuck Levere136d092006-12-05 16:35:23 -0500687 if (transport->tcp_flags & TCP_RCV_LAST_FRAG) {
688 transport->tcp_flags &= ~TCP_RCV_COPY_DATA;
689 transport->tcp_flags |= TCP_RCV_COPY_XID;
Chuck Lever51971132006-12-05 16:35:19 -0500690 transport->tcp_copied = 0;
Chuck Levera246b012005-08-11 16:25:23 -0400691 }
692 }
693}
694
Chuck Lever51971132006-12-05 16:35:19 -0500695static inline void xs_tcp_read_xid(struct sock_xprt *transport, skb_reader_t *desc)
Chuck Levera246b012005-08-11 16:25:23 -0400696{
697 size_t len, used;
698 char *p;
699
Chuck Lever51971132006-12-05 16:35:19 -0500700 len = sizeof(transport->tcp_xid) - transport->tcp_offset;
Chuck Levera246b012005-08-11 16:25:23 -0400701 dprintk("RPC: reading XID (%Zu bytes)\n", len);
Chuck Lever51971132006-12-05 16:35:19 -0500702 p = ((char *) &transport->tcp_xid) + transport->tcp_offset;
Chuck Lever9903cd12005-08-11 16:25:26 -0400703 used = xs_tcp_copy_data(desc, p, len);
Chuck Lever51971132006-12-05 16:35:19 -0500704 transport->tcp_offset += used;
Chuck Levera246b012005-08-11 16:25:23 -0400705 if (used != len)
706 return;
Chuck Levere136d092006-12-05 16:35:23 -0500707 transport->tcp_flags &= ~TCP_RCV_COPY_XID;
708 transport->tcp_flags |= TCP_RCV_COPY_DATA;
Chuck Lever51971132006-12-05 16:35:19 -0500709 transport->tcp_copied = 4;
Chuck Levera246b012005-08-11 16:25:23 -0400710 dprintk("RPC: reading reply for XID %08x\n",
Chuck Lever51971132006-12-05 16:35:19 -0500711 ntohl(transport->tcp_xid));
712 xs_tcp_check_fraghdr(transport);
Chuck Levera246b012005-08-11 16:25:23 -0400713}
714
Chuck Lever9903cd12005-08-11 16:25:26 -0400715static inline void xs_tcp_read_request(struct rpc_xprt *xprt, skb_reader_t *desc)
Chuck Levera246b012005-08-11 16:25:23 -0400716{
Chuck Lever51971132006-12-05 16:35:19 -0500717 struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
Chuck Levera246b012005-08-11 16:25:23 -0400718 struct rpc_rqst *req;
719 struct xdr_buf *rcvbuf;
720 size_t len;
721 ssize_t r;
722
723 /* Find and lock the request corresponding to this xid */
Chuck Lever4a0f8c02005-08-11 16:25:32 -0400724 spin_lock(&xprt->transport_lock);
Chuck Lever51971132006-12-05 16:35:19 -0500725 req = xprt_lookup_rqst(xprt, transport->tcp_xid);
Chuck Levera246b012005-08-11 16:25:23 -0400726 if (!req) {
Chuck Levere136d092006-12-05 16:35:23 -0500727 transport->tcp_flags &= ~TCP_RCV_COPY_DATA;
Chuck Levera246b012005-08-11 16:25:23 -0400728 dprintk("RPC: XID %08x request not found!\n",
Chuck Lever51971132006-12-05 16:35:19 -0500729 ntohl(transport->tcp_xid));
Chuck Lever4a0f8c02005-08-11 16:25:32 -0400730 spin_unlock(&xprt->transport_lock);
Chuck Levera246b012005-08-11 16:25:23 -0400731 return;
732 }
733
734 rcvbuf = &req->rq_private_buf;
735 len = desc->count;
Chuck Lever51971132006-12-05 16:35:19 -0500736 if (len > transport->tcp_reclen - transport->tcp_offset) {
Chuck Levera246b012005-08-11 16:25:23 -0400737 skb_reader_t my_desc;
738
Chuck Lever51971132006-12-05 16:35:19 -0500739 len = transport->tcp_reclen - transport->tcp_offset;
Chuck Levera246b012005-08-11 16:25:23 -0400740 memcpy(&my_desc, desc, sizeof(my_desc));
741 my_desc.count = len;
Chuck Lever51971132006-12-05 16:35:19 -0500742 r = xdr_partial_copy_from_skb(rcvbuf, transport->tcp_copied,
Chuck Lever9903cd12005-08-11 16:25:26 -0400743 &my_desc, xs_tcp_copy_data);
Chuck Levera246b012005-08-11 16:25:23 -0400744 desc->count -= r;
745 desc->offset += r;
746 } else
Chuck Lever51971132006-12-05 16:35:19 -0500747 r = xdr_partial_copy_from_skb(rcvbuf, transport->tcp_copied,
Chuck Lever9903cd12005-08-11 16:25:26 -0400748 desc, xs_tcp_copy_data);
Chuck Levera246b012005-08-11 16:25:23 -0400749
750 if (r > 0) {
Chuck Lever51971132006-12-05 16:35:19 -0500751 transport->tcp_copied += r;
752 transport->tcp_offset += r;
Chuck Levera246b012005-08-11 16:25:23 -0400753 }
754 if (r != len) {
755 /* Error when copying to the receive buffer,
756 * usually because we weren't able to allocate
757 * additional buffer pages. All we can do now
Chuck Levere136d092006-12-05 16:35:23 -0500758 * is turn off TCP_RCV_COPY_DATA, so the request
Chuck Levera246b012005-08-11 16:25:23 -0400759 * will not receive any additional updates,
760 * and time out.
761 * Any remaining data from this record will
762 * be discarded.
763 */
Chuck Levere136d092006-12-05 16:35:23 -0500764 transport->tcp_flags &= ~TCP_RCV_COPY_DATA;
Chuck Levera246b012005-08-11 16:25:23 -0400765 dprintk("RPC: XID %08x truncated request\n",
Chuck Lever51971132006-12-05 16:35:19 -0500766 ntohl(transport->tcp_xid));
Chuck Levera246b012005-08-11 16:25:23 -0400767 dprintk("RPC: xprt = %p, tcp_copied = %lu, tcp_offset = %u, tcp_reclen = %u\n",
Chuck Lever51971132006-12-05 16:35:19 -0500768 xprt, transport->tcp_copied, transport->tcp_offset,
769 transport->tcp_reclen);
Chuck Levera246b012005-08-11 16:25:23 -0400770 goto out;
771 }
772
773 dprintk("RPC: XID %08x read %Zd bytes\n",
Chuck Lever51971132006-12-05 16:35:19 -0500774 ntohl(transport->tcp_xid), r);
Chuck Levera246b012005-08-11 16:25:23 -0400775 dprintk("RPC: xprt = %p, tcp_copied = %lu, tcp_offset = %u, tcp_reclen = %u\n",
Chuck Lever51971132006-12-05 16:35:19 -0500776 xprt, transport->tcp_copied, transport->tcp_offset,
777 transport->tcp_reclen);
Chuck Levera246b012005-08-11 16:25:23 -0400778
Chuck Lever51971132006-12-05 16:35:19 -0500779 if (transport->tcp_copied == req->rq_private_buf.buflen)
Chuck Levere136d092006-12-05 16:35:23 -0500780 transport->tcp_flags &= ~TCP_RCV_COPY_DATA;
Chuck Lever51971132006-12-05 16:35:19 -0500781 else if (transport->tcp_offset == transport->tcp_reclen) {
Chuck Levere136d092006-12-05 16:35:23 -0500782 if (transport->tcp_flags & TCP_RCV_LAST_FRAG)
783 transport->tcp_flags &= ~TCP_RCV_COPY_DATA;
Chuck Levera246b012005-08-11 16:25:23 -0400784 }
785
786out:
Chuck Levere136d092006-12-05 16:35:23 -0500787 if (!(transport->tcp_flags & TCP_RCV_COPY_DATA))
Chuck Lever51971132006-12-05 16:35:19 -0500788 xprt_complete_rqst(req->rq_task, transport->tcp_copied);
Chuck Lever4a0f8c02005-08-11 16:25:32 -0400789 spin_unlock(&xprt->transport_lock);
Chuck Lever51971132006-12-05 16:35:19 -0500790 xs_tcp_check_fraghdr(transport);
Chuck Levera246b012005-08-11 16:25:23 -0400791}
792
Chuck Lever51971132006-12-05 16:35:19 -0500793static inline void xs_tcp_read_discard(struct sock_xprt *transport, skb_reader_t *desc)
Chuck Levera246b012005-08-11 16:25:23 -0400794{
795 size_t len;
796
Chuck Lever51971132006-12-05 16:35:19 -0500797 len = transport->tcp_reclen - transport->tcp_offset;
Chuck Levera246b012005-08-11 16:25:23 -0400798 if (len > desc->count)
799 len = desc->count;
800 desc->count -= len;
801 desc->offset += len;
Chuck Lever51971132006-12-05 16:35:19 -0500802 transport->tcp_offset += len;
Chuck Levera246b012005-08-11 16:25:23 -0400803 dprintk("RPC: discarded %Zu bytes\n", len);
Chuck Lever51971132006-12-05 16:35:19 -0500804 xs_tcp_check_fraghdr(transport);
Chuck Levera246b012005-08-11 16:25:23 -0400805}
806
Chuck Lever9903cd12005-08-11 16:25:26 -0400807static int xs_tcp_data_recv(read_descriptor_t *rd_desc, struct sk_buff *skb, unsigned int offset, size_t len)
Chuck Levera246b012005-08-11 16:25:23 -0400808{
809 struct rpc_xprt *xprt = rd_desc->arg.data;
Chuck Lever51971132006-12-05 16:35:19 -0500810 struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
Chuck Levera246b012005-08-11 16:25:23 -0400811 skb_reader_t desc = {
812 .skb = skb,
813 .offset = offset,
814 .count = len,
Chuck Lever9903cd12005-08-11 16:25:26 -0400815 };
Chuck Levera246b012005-08-11 16:25:23 -0400816
Chuck Lever9903cd12005-08-11 16:25:26 -0400817 dprintk("RPC: xs_tcp_data_recv started\n");
Chuck Levera246b012005-08-11 16:25:23 -0400818 do {
819 /* Read in a new fragment marker if necessary */
820 /* Can we ever really expect to get completely empty fragments? */
Chuck Levere136d092006-12-05 16:35:23 -0500821 if (transport->tcp_flags & TCP_RCV_COPY_FRAGHDR) {
Chuck Lever9903cd12005-08-11 16:25:26 -0400822 xs_tcp_read_fraghdr(xprt, &desc);
Chuck Levera246b012005-08-11 16:25:23 -0400823 continue;
824 }
825 /* Read in the xid if necessary */
Chuck Levere136d092006-12-05 16:35:23 -0500826 if (transport->tcp_flags & TCP_RCV_COPY_XID) {
Chuck Lever51971132006-12-05 16:35:19 -0500827 xs_tcp_read_xid(transport, &desc);
Chuck Levera246b012005-08-11 16:25:23 -0400828 continue;
829 }
830 /* Read in the request data */
Chuck Levere136d092006-12-05 16:35:23 -0500831 if (transport->tcp_flags & TCP_RCV_COPY_DATA) {
Chuck Lever9903cd12005-08-11 16:25:26 -0400832 xs_tcp_read_request(xprt, &desc);
Chuck Levera246b012005-08-11 16:25:23 -0400833 continue;
834 }
835 /* Skip over any trailing bytes on short reads */
Chuck Lever51971132006-12-05 16:35:19 -0500836 xs_tcp_read_discard(transport, &desc);
Chuck Levera246b012005-08-11 16:25:23 -0400837 } while (desc.count);
Chuck Lever9903cd12005-08-11 16:25:26 -0400838 dprintk("RPC: xs_tcp_data_recv done\n");
Chuck Levera246b012005-08-11 16:25:23 -0400839 return len - desc.count;
840}
841
Chuck Lever9903cd12005-08-11 16:25:26 -0400842/**
843 * xs_tcp_data_ready - "data ready" callback for TCP sockets
844 * @sk: socket with data to read
845 * @bytes: how much data to read
846 *
847 */
848static void xs_tcp_data_ready(struct sock *sk, int bytes)
Chuck Levera246b012005-08-11 16:25:23 -0400849{
850 struct rpc_xprt *xprt;
851 read_descriptor_t rd_desc;
852
853 read_lock(&sk->sk_callback_lock);
Chuck Lever9903cd12005-08-11 16:25:26 -0400854 dprintk("RPC: xs_tcp_data_ready...\n");
855 if (!(xprt = xprt_from_sock(sk)))
Chuck Levera246b012005-08-11 16:25:23 -0400856 goto out;
Chuck Levera246b012005-08-11 16:25:23 -0400857 if (xprt->shutdown)
858 goto out;
859
Chuck Lever9903cd12005-08-11 16:25:26 -0400860 /* We use rd_desc to pass struct xprt to xs_tcp_data_recv */
Chuck Levera246b012005-08-11 16:25:23 -0400861 rd_desc.arg.data = xprt;
862 rd_desc.count = 65536;
Chuck Lever9903cd12005-08-11 16:25:26 -0400863 tcp_read_sock(sk, &rd_desc, xs_tcp_data_recv);
Chuck Levera246b012005-08-11 16:25:23 -0400864out:
865 read_unlock(&sk->sk_callback_lock);
866}
867
Chuck Lever9903cd12005-08-11 16:25:26 -0400868/**
869 * xs_tcp_state_change - callback to handle TCP socket state changes
870 * @sk: socket whose state has changed
871 *
872 */
873static void xs_tcp_state_change(struct sock *sk)
Chuck Levera246b012005-08-11 16:25:23 -0400874{
Chuck Lever9903cd12005-08-11 16:25:26 -0400875 struct rpc_xprt *xprt;
Chuck Levera246b012005-08-11 16:25:23 -0400876
877 read_lock(&sk->sk_callback_lock);
878 if (!(xprt = xprt_from_sock(sk)))
879 goto out;
Chuck Lever9903cd12005-08-11 16:25:26 -0400880 dprintk("RPC: xs_tcp_state_change client %p...\n", xprt);
Chuck Levera246b012005-08-11 16:25:23 -0400881 dprintk("RPC: state %x conn %d dead %d zapped %d\n",
882 sk->sk_state, xprt_connected(xprt),
883 sock_flag(sk, SOCK_DEAD),
884 sock_flag(sk, SOCK_ZAPPED));
885
886 switch (sk->sk_state) {
887 case TCP_ESTABLISHED:
Chuck Lever4a0f8c02005-08-11 16:25:32 -0400888 spin_lock_bh(&xprt->transport_lock);
Chuck Levera246b012005-08-11 16:25:23 -0400889 if (!xprt_test_and_set_connected(xprt)) {
Chuck Lever51971132006-12-05 16:35:19 -0500890 struct sock_xprt *transport = container_of(xprt,
891 struct sock_xprt, xprt);
892
Chuck Levera246b012005-08-11 16:25:23 -0400893 /* Reset TCP record info */
Chuck Lever51971132006-12-05 16:35:19 -0500894 transport->tcp_offset = 0;
895 transport->tcp_reclen = 0;
896 transport->tcp_copied = 0;
Chuck Levere136d092006-12-05 16:35:23 -0500897 transport->tcp_flags =
898 TCP_RCV_COPY_FRAGHDR | TCP_RCV_COPY_XID;
Chuck Lever51971132006-12-05 16:35:19 -0500899
Chuck Lever03bf4b72005-08-25 16:25:55 -0700900 xprt->reestablish_timeout = XS_TCP_INIT_REEST_TO;
Chuck Lever44fbac22005-08-11 16:25:44 -0400901 xprt_wake_pending_tasks(xprt, 0);
Chuck Levera246b012005-08-11 16:25:23 -0400902 }
Chuck Lever4a0f8c02005-08-11 16:25:32 -0400903 spin_unlock_bh(&xprt->transport_lock);
Chuck Levera246b012005-08-11 16:25:23 -0400904 break;
905 case TCP_SYN_SENT:
906 case TCP_SYN_RECV:
907 break;
Trond Myklebust632e3bd2006-01-03 09:55:55 +0100908 case TCP_CLOSE_WAIT:
909 /* Try to schedule an autoclose RPC calls */
910 set_bit(XPRT_CLOSE_WAIT, &xprt->state);
911 if (test_and_set_bit(XPRT_LOCKED, &xprt->state) == 0)
912 schedule_work(&xprt->task_cleanup);
Chuck Levera246b012005-08-11 16:25:23 -0400913 default:
914 xprt_disconnect(xprt);
Chuck Levera246b012005-08-11 16:25:23 -0400915 }
916 out:
917 read_unlock(&sk->sk_callback_lock);
918}
919
Chuck Lever9903cd12005-08-11 16:25:26 -0400920/**
Chuck Leverc7b2cae2005-08-11 16:25:50 -0400921 * xs_udp_write_space - callback invoked when socket buffer space
922 * becomes available
Chuck Lever9903cd12005-08-11 16:25:26 -0400923 * @sk: socket whose state has changed
924 *
Chuck Levera246b012005-08-11 16:25:23 -0400925 * Called when more output buffer space is available for this socket.
926 * We try not to wake our writers until they can make "significant"
Chuck Leverc7b2cae2005-08-11 16:25:50 -0400927 * progress, otherwise we'll waste resources thrashing kernel_sendmsg
Chuck Levera246b012005-08-11 16:25:23 -0400928 * with a bunch of small requests.
929 */
Chuck Leverc7b2cae2005-08-11 16:25:50 -0400930static void xs_udp_write_space(struct sock *sk)
Chuck Levera246b012005-08-11 16:25:23 -0400931{
Chuck Levera246b012005-08-11 16:25:23 -0400932 read_lock(&sk->sk_callback_lock);
Chuck Levera246b012005-08-11 16:25:23 -0400933
Chuck Leverc7b2cae2005-08-11 16:25:50 -0400934 /* from net/core/sock.c:sock_def_write_space */
935 if (sock_writeable(sk)) {
936 struct socket *sock;
937 struct rpc_xprt *xprt;
938
939 if (unlikely(!(sock = sk->sk_socket)))
Chuck Levera246b012005-08-11 16:25:23 -0400940 goto out;
Chuck Leverc7b2cae2005-08-11 16:25:50 -0400941 if (unlikely(!(xprt = xprt_from_sock(sk))))
Chuck Levera246b012005-08-11 16:25:23 -0400942 goto out;
Chuck Leverc7b2cae2005-08-11 16:25:50 -0400943 if (unlikely(!test_and_clear_bit(SOCK_NOSPACE, &sock->flags)))
944 goto out;
945
946 xprt_write_space(xprt);
Chuck Levera246b012005-08-11 16:25:23 -0400947 }
948
Chuck Leverc7b2cae2005-08-11 16:25:50 -0400949 out:
950 read_unlock(&sk->sk_callback_lock);
951}
Chuck Levera246b012005-08-11 16:25:23 -0400952
Chuck Leverc7b2cae2005-08-11 16:25:50 -0400953/**
954 * xs_tcp_write_space - callback invoked when socket buffer space
955 * becomes available
956 * @sk: socket whose state has changed
957 *
958 * Called when more output buffer space is available for this socket.
959 * We try not to wake our writers until they can make "significant"
960 * progress, otherwise we'll waste resources thrashing kernel_sendmsg
961 * with a bunch of small requests.
962 */
963static void xs_tcp_write_space(struct sock *sk)
964{
965 read_lock(&sk->sk_callback_lock);
966
967 /* from net/core/stream.c:sk_stream_write_space */
968 if (sk_stream_wspace(sk) >= sk_stream_min_wspace(sk)) {
969 struct socket *sock;
970 struct rpc_xprt *xprt;
971
972 if (unlikely(!(sock = sk->sk_socket)))
973 goto out;
974 if (unlikely(!(xprt = xprt_from_sock(sk))))
975 goto out;
976 if (unlikely(!test_and_clear_bit(SOCK_NOSPACE, &sock->flags)))
977 goto out;
978
979 xprt_write_space(xprt);
980 }
981
982 out:
Chuck Levera246b012005-08-11 16:25:23 -0400983 read_unlock(&sk->sk_callback_lock);
984}
985
Chuck Lever470056c2005-08-25 16:25:56 -0700986static void xs_udp_do_set_buffer_size(struct rpc_xprt *xprt)
Chuck Levera246b012005-08-11 16:25:23 -0400987{
Chuck Leveree0ac0c2006-12-05 16:35:15 -0500988 struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
989 struct sock *sk = transport->inet;
Chuck Levera246b012005-08-11 16:25:23 -0400990
Chuck Levera246b012005-08-11 16:25:23 -0400991 if (xprt->rcvsize) {
992 sk->sk_userlocks |= SOCK_RCVBUF_LOCK;
993 sk->sk_rcvbuf = xprt->rcvsize * xprt->max_reqs * 2;
994 }
995 if (xprt->sndsize) {
996 sk->sk_userlocks |= SOCK_SNDBUF_LOCK;
997 sk->sk_sndbuf = xprt->sndsize * xprt->max_reqs * 2;
998 sk->sk_write_space(sk);
999 }
1000}
1001
Chuck Lever43118c22005-08-25 16:25:49 -07001002/**
Chuck Lever470056c2005-08-25 16:25:56 -07001003 * xs_udp_set_buffer_size - set send and receive limits
Chuck Lever43118c22005-08-25 16:25:49 -07001004 * @xprt: generic transport
Chuck Lever470056c2005-08-25 16:25:56 -07001005 * @sndsize: requested size of send buffer, in bytes
1006 * @rcvsize: requested size of receive buffer, in bytes
Chuck Lever43118c22005-08-25 16:25:49 -07001007 *
Chuck Lever470056c2005-08-25 16:25:56 -07001008 * Set socket send and receive buffer size limits.
Chuck Lever43118c22005-08-25 16:25:49 -07001009 */
Chuck Lever470056c2005-08-25 16:25:56 -07001010static void xs_udp_set_buffer_size(struct rpc_xprt *xprt, size_t sndsize, size_t rcvsize)
Chuck Lever43118c22005-08-25 16:25:49 -07001011{
Chuck Lever470056c2005-08-25 16:25:56 -07001012 xprt->sndsize = 0;
1013 if (sndsize)
1014 xprt->sndsize = sndsize + 1024;
1015 xprt->rcvsize = 0;
1016 if (rcvsize)
1017 xprt->rcvsize = rcvsize + 1024;
1018
1019 xs_udp_do_set_buffer_size(xprt);
Chuck Lever43118c22005-08-25 16:25:49 -07001020}
1021
Chuck Lever46c0ee82005-08-25 16:25:52 -07001022/**
1023 * xs_udp_timer - called when a retransmit timeout occurs on a UDP transport
1024 * @task: task that timed out
1025 *
1026 * Adjust the congestion window after a retransmit timeout has occurred.
1027 */
1028static void xs_udp_timer(struct rpc_task *task)
1029{
1030 xprt_adjust_cwnd(task, -ETIMEDOUT);
1031}
1032
Chuck Leverb85d8802006-05-25 01:40:49 -04001033static unsigned short xs_get_random_port(void)
1034{
1035 unsigned short range = xprt_max_resvport - xprt_min_resvport;
1036 unsigned short rand = (unsigned short) net_random() % range;
1037 return rand + xprt_min_resvport;
1038}
1039
Chuck Lever92200412006-01-03 09:55:51 +01001040/**
Chuck Leveredb267a2006-08-22 20:06:18 -04001041 * xs_print_peer_address - format an IPv4 address for printing
1042 * @xprt: generic transport
1043 * @format: flags field indicating which parts of the address to render
1044 */
1045static char *xs_print_peer_address(struct rpc_xprt *xprt, enum rpc_display_format_t format)
1046{
1047 if (xprt->address_strings[format] != NULL)
1048 return xprt->address_strings[format];
1049 else
1050 return "unprintable";
1051}
1052
1053/**
Chuck Lever92200412006-01-03 09:55:51 +01001054 * xs_set_port - reset the port number in the remote endpoint address
1055 * @xprt: generic transport
1056 * @port: new port number
1057 *
1058 */
1059static void xs_set_port(struct rpc_xprt *xprt, unsigned short port)
1060{
Chuck Leverc4efcb12006-08-22 20:06:19 -04001061 struct sockaddr_in *sap = (struct sockaddr_in *) &xprt->addr;
1062
Chuck Lever92200412006-01-03 09:55:51 +01001063 dprintk("RPC: setting port for xprt %p to %u\n", xprt, port);
Chuck Leverc4efcb12006-08-22 20:06:19 -04001064
1065 sap->sin_port = htons(port);
Chuck Lever92200412006-01-03 09:55:51 +01001066}
1067
Chuck Lever9903cd12005-08-11 16:25:26 -04001068static int xs_bindresvport(struct rpc_xprt *xprt, struct socket *sock)
Chuck Levera246b012005-08-11 16:25:23 -04001069{
1070 struct sockaddr_in myaddr = {
1071 .sin_family = AF_INET,
1072 };
Chuck Lever529b33c2005-08-25 16:25:54 -07001073 int err;
1074 unsigned short port = xprt->port;
Chuck Levera246b012005-08-11 16:25:23 -04001075
Chuck Levera246b012005-08-11 16:25:23 -04001076 do {
1077 myaddr.sin_port = htons(port);
Sridhar Samudralae6242e92006-08-07 20:58:01 -07001078 err = kernel_bind(sock, (struct sockaddr *) &myaddr,
Chuck Levera246b012005-08-11 16:25:23 -04001079 sizeof(myaddr));
1080 if (err == 0) {
1081 xprt->port = port;
Chuck Lever9903cd12005-08-11 16:25:26 -04001082 dprintk("RPC: xs_bindresvport bound to port %u\n",
1083 port);
Chuck Levera246b012005-08-11 16:25:23 -04001084 return 0;
1085 }
Chuck Lever529b33c2005-08-25 16:25:54 -07001086 if (port <= xprt_min_resvport)
1087 port = xprt_max_resvport;
1088 else
1089 port--;
Chuck Levera246b012005-08-11 16:25:23 -04001090 } while (err == -EADDRINUSE && port != xprt->port);
1091
Chuck Lever9903cd12005-08-11 16:25:26 -04001092 dprintk("RPC: can't bind to reserved port (%d).\n", -err);
Chuck Levera246b012005-08-11 16:25:23 -04001093 return err;
1094}
1095
Chuck Lever9903cd12005-08-11 16:25:26 -04001096/**
Chuck Leverb0d93ad2005-08-11 16:25:53 -04001097 * xs_udp_connect_worker - set up a UDP socket
Chuck Lever9903cd12005-08-11 16:25:26 -04001098 * @args: RPC transport to connect
1099 *
1100 * Invoked by a work queue tasklet.
Chuck Levera246b012005-08-11 16:25:23 -04001101 */
Chuck Leverb0d93ad2005-08-11 16:25:53 -04001102static void xs_udp_connect_worker(void *args)
Chuck Levera246b012005-08-11 16:25:23 -04001103{
Chuck Leverb0d93ad2005-08-11 16:25:53 -04001104 struct rpc_xprt *xprt = (struct rpc_xprt *) args;
Chuck Leveree0ac0c2006-12-05 16:35:15 -05001105 struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
1106 struct socket *sock = transport->sock;
Chuck Leverb0d93ad2005-08-11 16:25:53 -04001107 int err, status = -EIO;
Chuck Levera246b012005-08-11 16:25:23 -04001108
Chuck Leverec739ef2006-08-22 20:06:15 -04001109 if (xprt->shutdown || !xprt_bound(xprt))
Chuck Levera246b012005-08-11 16:25:23 -04001110 goto out;
1111
Chuck Leverb0d93ad2005-08-11 16:25:53 -04001112 /* Start by resetting any existing state */
Chuck Lever9903cd12005-08-11 16:25:26 -04001113 xs_close(xprt);
Chuck Leverb0d93ad2005-08-11 16:25:53 -04001114
1115 if ((err = sock_create_kern(PF_INET, SOCK_DGRAM, IPPROTO_UDP, &sock)) < 0) {
1116 dprintk("RPC: can't create UDP transport socket (%d).\n", -err);
Chuck Levera246b012005-08-11 16:25:23 -04001117 goto out;
1118 }
Chuck Levera246b012005-08-11 16:25:23 -04001119
Chuck Leverb0d93ad2005-08-11 16:25:53 -04001120 if (xprt->resvport && xs_bindresvport(xprt, sock) < 0) {
1121 sock_release(sock);
1122 goto out;
1123 }
1124
Chuck Leveredb267a2006-08-22 20:06:18 -04001125 dprintk("RPC: worker connecting xprt %p to address: %s\n",
1126 xprt, xs_print_peer_address(xprt, RPC_DISPLAY_ALL));
1127
Chuck Leveree0ac0c2006-12-05 16:35:15 -05001128 if (!transport->inet) {
Chuck Leverb0d93ad2005-08-11 16:25:53 -04001129 struct sock *sk = sock->sk;
1130
1131 write_lock_bh(&sk->sk_callback_lock);
1132
1133 sk->sk_user_data = xprt;
1134 xprt->old_data_ready = sk->sk_data_ready;
1135 xprt->old_state_change = sk->sk_state_change;
1136 xprt->old_write_space = sk->sk_write_space;
1137 sk->sk_data_ready = xs_udp_data_ready;
1138 sk->sk_write_space = xs_udp_write_space;
1139 sk->sk_no_check = UDP_CSUM_NORCV;
Trond Myklebustb079fa7b2005-12-13 16:13:52 -05001140 sk->sk_allocation = GFP_ATOMIC;
Chuck Leverb0d93ad2005-08-11 16:25:53 -04001141
1142 xprt_set_connected(xprt);
1143
1144 /* Reset to new socket */
Chuck Leveree0ac0c2006-12-05 16:35:15 -05001145 transport->sock = sock;
1146 transport->inet = sk;
Chuck Leverb0d93ad2005-08-11 16:25:53 -04001147
1148 write_unlock_bh(&sk->sk_callback_lock);
1149 }
Chuck Lever470056c2005-08-25 16:25:56 -07001150 xs_udp_do_set_buffer_size(xprt);
Chuck Levera246b012005-08-11 16:25:23 -04001151 status = 0;
Chuck Leverb0d93ad2005-08-11 16:25:53 -04001152out:
1153 xprt_wake_pending_tasks(xprt, status);
1154 xprt_clear_connecting(xprt);
1155}
1156
Chuck Lever3167e122005-08-25 16:25:55 -07001157/*
1158 * We need to preserve the port number so the reply cache on the server can
1159 * find our cached RPC replies when we get around to reconnecting.
1160 */
1161static void xs_tcp_reuse_connection(struct rpc_xprt *xprt)
1162{
1163 int result;
Chuck Leveree0ac0c2006-12-05 16:35:15 -05001164 struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
Chuck Lever3167e122005-08-25 16:25:55 -07001165 struct sockaddr any;
1166
1167 dprintk("RPC: disconnecting xprt %p to reuse port\n", xprt);
1168
1169 /*
1170 * Disconnect the transport socket by doing a connect operation
1171 * with AF_UNSPEC. This should return immediately...
1172 */
1173 memset(&any, 0, sizeof(any));
1174 any.sa_family = AF_UNSPEC;
Chuck Leveree0ac0c2006-12-05 16:35:15 -05001175 result = kernel_connect(transport->sock, &any, sizeof(any), 0);
Chuck Lever3167e122005-08-25 16:25:55 -07001176 if (result)
1177 dprintk("RPC: AF_UNSPEC connect return code %d\n",
1178 result);
1179}
1180
Chuck Leverb0d93ad2005-08-11 16:25:53 -04001181/**
1182 * xs_tcp_connect_worker - connect a TCP socket to a remote endpoint
1183 * @args: RPC transport to connect
1184 *
1185 * Invoked by a work queue tasklet.
1186 */
1187static void xs_tcp_connect_worker(void *args)
1188{
1189 struct rpc_xprt *xprt = (struct rpc_xprt *)args;
Chuck Leveree0ac0c2006-12-05 16:35:15 -05001190 struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
1191 struct socket *sock = transport->sock;
Chuck Leverb0d93ad2005-08-11 16:25:53 -04001192 int err, status = -EIO;
1193
Chuck Leverec739ef2006-08-22 20:06:15 -04001194 if (xprt->shutdown || !xprt_bound(xprt))
Chuck Levera246b012005-08-11 16:25:23 -04001195 goto out;
1196
Chuck Leveree0ac0c2006-12-05 16:35:15 -05001197 if (!sock) {
Chuck Lever3167e122005-08-25 16:25:55 -07001198 /* start from scratch */
1199 if ((err = sock_create_kern(PF_INET, SOCK_STREAM, IPPROTO_TCP, &sock)) < 0) {
1200 dprintk("RPC: can't create TCP transport socket (%d).\n", -err);
1201 goto out;
1202 }
Chuck Leverb0d93ad2005-08-11 16:25:53 -04001203
Chuck Lever3167e122005-08-25 16:25:55 -07001204 if (xprt->resvport && xs_bindresvport(xprt, sock) < 0) {
1205 sock_release(sock);
1206 goto out;
1207 }
1208 } else
1209 /* "close" the socket, preserving the local port */
1210 xs_tcp_reuse_connection(xprt);
Chuck Leverb0d93ad2005-08-11 16:25:53 -04001211
Chuck Leveredb267a2006-08-22 20:06:18 -04001212 dprintk("RPC: worker connecting xprt %p to address: %s\n",
1213 xprt, xs_print_peer_address(xprt, RPC_DISPLAY_ALL));
1214
Chuck Leveree0ac0c2006-12-05 16:35:15 -05001215 if (!transport->inet) {
Chuck Leverb0d93ad2005-08-11 16:25:53 -04001216 struct sock *sk = sock->sk;
1217
1218 write_lock_bh(&sk->sk_callback_lock);
1219
1220 sk->sk_user_data = xprt;
1221 xprt->old_data_ready = sk->sk_data_ready;
1222 xprt->old_state_change = sk->sk_state_change;
1223 xprt->old_write_space = sk->sk_write_space;
1224 sk->sk_data_ready = xs_tcp_data_ready;
1225 sk->sk_state_change = xs_tcp_state_change;
1226 sk->sk_write_space = xs_tcp_write_space;
Trond Myklebustb079fa7b2005-12-13 16:13:52 -05001227 sk->sk_allocation = GFP_ATOMIC;
Chuck Lever3167e122005-08-25 16:25:55 -07001228
1229 /* socket options */
1230 sk->sk_userlocks |= SOCK_BINDPORT_LOCK;
1231 sock_reset_flag(sk, SOCK_LINGER);
1232 tcp_sk(sk)->linger2 = 0;
1233 tcp_sk(sk)->nonagle |= TCP_NAGLE_OFF;
Chuck Leverb0d93ad2005-08-11 16:25:53 -04001234
1235 xprt_clear_connected(xprt);
1236
1237 /* Reset to new socket */
Chuck Leveree0ac0c2006-12-05 16:35:15 -05001238 transport->sock = sock;
1239 transport->inet = sk;
Chuck Leverb0d93ad2005-08-11 16:25:53 -04001240
1241 write_unlock_bh(&sk->sk_callback_lock);
1242 }
1243
1244 /* Tell the socket layer to start connecting... */
Chuck Lever262ca072006-03-20 13:44:16 -05001245 xprt->stat.connect_count++;
1246 xprt->stat.connect_start = jiffies;
Sridhar Samudralae6242e92006-08-07 20:58:01 -07001247 status = kernel_connect(sock, (struct sockaddr *) &xprt->addr,
Chuck Leverc4efcb12006-08-22 20:06:19 -04001248 xprt->addrlen, O_NONBLOCK);
Chuck Levera246b012005-08-11 16:25:23 -04001249 dprintk("RPC: %p connect status %d connected %d sock state %d\n",
1250 xprt, -status, xprt_connected(xprt), sock->sk->sk_state);
1251 if (status < 0) {
1252 switch (status) {
1253 case -EINPROGRESS:
1254 case -EALREADY:
1255 goto out_clear;
Chuck Lever3167e122005-08-25 16:25:55 -07001256 case -ECONNREFUSED:
1257 case -ECONNRESET:
1258 /* retry with existing socket, after a delay */
1259 break;
1260 default:
1261 /* get rid of existing socket, and retry */
1262 xs_close(xprt);
1263 break;
Chuck Levera246b012005-08-11 16:25:23 -04001264 }
1265 }
1266out:
Chuck Lever44fbac22005-08-11 16:25:44 -04001267 xprt_wake_pending_tasks(xprt, status);
Chuck Levera246b012005-08-11 16:25:23 -04001268out_clear:
Chuck Lever2226feb2005-08-11 16:25:38 -04001269 xprt_clear_connecting(xprt);
Chuck Levera246b012005-08-11 16:25:23 -04001270}
1271
Chuck Lever9903cd12005-08-11 16:25:26 -04001272/**
1273 * xs_connect - connect a socket to a remote endpoint
1274 * @task: address of RPC task that manages state of connect request
1275 *
1276 * TCP: If the remote end dropped the connection, delay reconnecting.
Chuck Lever03bf4b72005-08-25 16:25:55 -07001277 *
1278 * UDP socket connects are synchronous, but we use a work queue anyway
1279 * to guarantee that even unprivileged user processes can set up a
1280 * socket on a privileged port.
1281 *
1282 * If a UDP socket connect fails, the delay behavior here prevents
1283 * retry floods (hard mounts).
Chuck Lever9903cd12005-08-11 16:25:26 -04001284 */
1285static void xs_connect(struct rpc_task *task)
Chuck Levera246b012005-08-11 16:25:23 -04001286{
1287 struct rpc_xprt *xprt = task->tk_xprt;
Chuck Leveree0ac0c2006-12-05 16:35:15 -05001288 struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
Chuck Levera246b012005-08-11 16:25:23 -04001289
Chuck Leverb0d93ad2005-08-11 16:25:53 -04001290 if (xprt_test_and_set_connecting(xprt))
1291 return;
1292
Chuck Leveree0ac0c2006-12-05 16:35:15 -05001293 if (transport->sock != NULL) {
Chuck Lever03bf4b72005-08-25 16:25:55 -07001294 dprintk("RPC: xs_connect delayed xprt %p for %lu seconds\n",
1295 xprt, xprt->reestablish_timeout / HZ);
Chuck Leverb0d93ad2005-08-11 16:25:53 -04001296 schedule_delayed_work(&xprt->connect_worker,
Chuck Lever03bf4b72005-08-25 16:25:55 -07001297 xprt->reestablish_timeout);
1298 xprt->reestablish_timeout <<= 1;
1299 if (xprt->reestablish_timeout > XS_TCP_MAX_REEST_TO)
1300 xprt->reestablish_timeout = XS_TCP_MAX_REEST_TO;
Chuck Leverb0d93ad2005-08-11 16:25:53 -04001301 } else {
1302 dprintk("RPC: xs_connect scheduled xprt %p\n", xprt);
1303 schedule_work(&xprt->connect_worker);
1304
1305 /* flush_scheduled_work can sleep... */
1306 if (!RPC_IS_ASYNC(task))
1307 flush_scheduled_work();
Chuck Levera246b012005-08-11 16:25:23 -04001308 }
1309}
1310
Chuck Lever262ca072006-03-20 13:44:16 -05001311/**
1312 * xs_udp_print_stats - display UDP socket-specifc stats
1313 * @xprt: rpc_xprt struct containing statistics
1314 * @seq: output file
1315 *
1316 */
1317static void xs_udp_print_stats(struct rpc_xprt *xprt, struct seq_file *seq)
1318{
1319 seq_printf(seq, "\txprt:\tudp %u %lu %lu %lu %lu %Lu %Lu\n",
1320 xprt->port,
1321 xprt->stat.bind_count,
1322 xprt->stat.sends,
1323 xprt->stat.recvs,
1324 xprt->stat.bad_xids,
1325 xprt->stat.req_u,
1326 xprt->stat.bklog_u);
1327}
1328
1329/**
1330 * xs_tcp_print_stats - display TCP socket-specifc stats
1331 * @xprt: rpc_xprt struct containing statistics
1332 * @seq: output file
1333 *
1334 */
1335static void xs_tcp_print_stats(struct rpc_xprt *xprt, struct seq_file *seq)
1336{
1337 long idle_time = 0;
1338
1339 if (xprt_connected(xprt))
1340 idle_time = (long)(jiffies - xprt->last_used) / HZ;
1341
1342 seq_printf(seq, "\txprt:\ttcp %u %lu %lu %lu %ld %lu %lu %lu %Lu %Lu\n",
1343 xprt->port,
1344 xprt->stat.bind_count,
1345 xprt->stat.connect_count,
1346 xprt->stat.connect_time,
1347 idle_time,
1348 xprt->stat.sends,
1349 xprt->stat.recvs,
1350 xprt->stat.bad_xids,
1351 xprt->stat.req_u,
1352 xprt->stat.bklog_u);
1353}
1354
Chuck Lever262965f2005-08-11 16:25:56 -04001355static struct rpc_xprt_ops xs_udp_ops = {
Chuck Lever43118c22005-08-25 16:25:49 -07001356 .set_buffer_size = xs_udp_set_buffer_size,
Chuck Leveredb267a2006-08-22 20:06:18 -04001357 .print_addr = xs_print_peer_address,
Chuck Lever12a80462005-08-25 16:25:51 -07001358 .reserve_xprt = xprt_reserve_xprt_cong,
Chuck Lever49e9a892005-08-25 16:25:51 -07001359 .release_xprt = xprt_release_xprt_cong,
Chuck Leverbbf7c1d2006-08-22 20:06:16 -04001360 .rpcbind = rpc_getport,
Chuck Lever92200412006-01-03 09:55:51 +01001361 .set_port = xs_set_port,
Chuck Lever9903cd12005-08-11 16:25:26 -04001362 .connect = xs_connect,
Chuck Lever02107142006-01-03 09:55:49 +01001363 .buf_alloc = rpc_malloc,
1364 .buf_free = rpc_free,
Chuck Lever262965f2005-08-11 16:25:56 -04001365 .send_request = xs_udp_send_request,
Chuck Leverfe3aca22005-08-25 16:25:50 -07001366 .set_retrans_timeout = xprt_set_retrans_timeout_rtt,
Chuck Lever46c0ee82005-08-25 16:25:52 -07001367 .timer = xs_udp_timer,
Chuck Levera58dd392005-08-25 16:25:53 -07001368 .release_request = xprt_release_rqst_cong,
Chuck Lever262965f2005-08-11 16:25:56 -04001369 .close = xs_close,
1370 .destroy = xs_destroy,
Chuck Lever262ca072006-03-20 13:44:16 -05001371 .print_stats = xs_udp_print_stats,
Chuck Lever262965f2005-08-11 16:25:56 -04001372};
1373
1374static struct rpc_xprt_ops xs_tcp_ops = {
Chuck Leveredb267a2006-08-22 20:06:18 -04001375 .print_addr = xs_print_peer_address,
Chuck Lever12a80462005-08-25 16:25:51 -07001376 .reserve_xprt = xprt_reserve_xprt,
Trond Myklebuste0ab53d2006-07-27 17:22:50 -04001377 .release_xprt = xs_tcp_release_xprt,
Chuck Leverbbf7c1d2006-08-22 20:06:16 -04001378 .rpcbind = rpc_getport,
Chuck Lever92200412006-01-03 09:55:51 +01001379 .set_port = xs_set_port,
Chuck Lever262965f2005-08-11 16:25:56 -04001380 .connect = xs_connect,
Chuck Lever02107142006-01-03 09:55:49 +01001381 .buf_alloc = rpc_malloc,
1382 .buf_free = rpc_free,
Chuck Lever262965f2005-08-11 16:25:56 -04001383 .send_request = xs_tcp_send_request,
Chuck Leverfe3aca22005-08-25 16:25:50 -07001384 .set_retrans_timeout = xprt_set_retrans_timeout_def,
Chuck Lever9903cd12005-08-11 16:25:26 -04001385 .close = xs_close,
1386 .destroy = xs_destroy,
Chuck Lever262ca072006-03-20 13:44:16 -05001387 .print_stats = xs_tcp_print_stats,
Chuck Levera246b012005-08-11 16:25:23 -04001388};
1389
Chuck Leverc8541ec2006-10-17 14:44:27 -04001390static struct rpc_xprt *xs_setup_xprt(struct sockaddr *addr, size_t addrlen, unsigned int slot_table_size)
1391{
1392 struct rpc_xprt *xprt;
Chuck Leverffc2e512006-12-05 16:35:11 -05001393 struct sock_xprt *new;
Chuck Leverc8541ec2006-10-17 14:44:27 -04001394
1395 if (addrlen > sizeof(xprt->addr)) {
1396 dprintk("RPC: xs_setup_xprt: address too large\n");
1397 return ERR_PTR(-EBADF);
1398 }
1399
Chuck Leverffc2e512006-12-05 16:35:11 -05001400 new = kzalloc(sizeof(*new), GFP_KERNEL);
1401 if (new == NULL) {
Chuck Leverc8541ec2006-10-17 14:44:27 -04001402 dprintk("RPC: xs_setup_xprt: couldn't allocate rpc_xprt\n");
1403 return ERR_PTR(-ENOMEM);
1404 }
Chuck Leverffc2e512006-12-05 16:35:11 -05001405 xprt = &new->xprt;
Chuck Leverc8541ec2006-10-17 14:44:27 -04001406
1407 xprt->max_reqs = slot_table_size;
1408 xprt->slot = kcalloc(xprt->max_reqs, sizeof(struct rpc_rqst), GFP_KERNEL);
1409 if (xprt->slot == NULL) {
1410 kfree(xprt);
1411 dprintk("RPC: xs_setup_xprt: couldn't allocate slot table\n");
1412 return ERR_PTR(-ENOMEM);
1413 }
1414
1415 memcpy(&xprt->addr, addr, addrlen);
1416 xprt->addrlen = addrlen;
1417 xprt->port = xs_get_random_port();
1418
1419 return xprt;
1420}
1421
Chuck Lever9903cd12005-08-11 16:25:26 -04001422/**
1423 * xs_setup_udp - Set up transport to use a UDP socket
Chuck Leverc8541ec2006-10-17 14:44:27 -04001424 * @addr: address of remote server
1425 * @addrlen: length of address in bytes
Chuck Lever9903cd12005-08-11 16:25:26 -04001426 * @to: timeout parameters
1427 *
1428 */
Chuck Leverc8541ec2006-10-17 14:44:27 -04001429struct rpc_xprt *xs_setup_udp(struct sockaddr *addr, size_t addrlen, struct rpc_timeout *to)
Chuck Levera246b012005-08-11 16:25:23 -04001430{
Chuck Leverc8541ec2006-10-17 14:44:27 -04001431 struct rpc_xprt *xprt;
Chuck Levera246b012005-08-11 16:25:23 -04001432
Chuck Leverc8541ec2006-10-17 14:44:27 -04001433 xprt = xs_setup_xprt(addr, addrlen, xprt_udp_slot_table_entries);
1434 if (IS_ERR(xprt))
1435 return xprt;
Chuck Levera246b012005-08-11 16:25:23 -04001436
Chuck Leverc8541ec2006-10-17 14:44:27 -04001437 if (ntohs(((struct sockaddr_in *)addr)->sin_port) != 0)
Chuck Leverec739ef2006-08-22 20:06:15 -04001438 xprt_set_bound(xprt);
Chuck Leverec739ef2006-08-22 20:06:15 -04001439
1440 xprt->prot = IPPROTO_UDP;
Chuck Lever808012f2005-08-25 16:25:49 -07001441 xprt->tsh_size = 0;
Chuck Levera246b012005-08-11 16:25:23 -04001442 /* XXX: header size can vary due to auth type, IPv6, etc. */
1443 xprt->max_payload = (1U << 16) - (MAX_HEADER << 3);
1444
Chuck Leverb0d93ad2005-08-11 16:25:53 -04001445 INIT_WORK(&xprt->connect_worker, xs_udp_connect_worker, xprt);
Chuck Lever03bf4b72005-08-25 16:25:55 -07001446 xprt->bind_timeout = XS_BIND_TO;
1447 xprt->connect_timeout = XS_UDP_CONN_TO;
1448 xprt->reestablish_timeout = XS_UDP_REEST_TO;
1449 xprt->idle_timeout = XS_IDLE_DISC_TO;
Chuck Levera246b012005-08-11 16:25:23 -04001450
Chuck Lever262965f2005-08-11 16:25:56 -04001451 xprt->ops = &xs_udp_ops;
Chuck Levera246b012005-08-11 16:25:23 -04001452
1453 if (to)
1454 xprt->timeout = *to;
1455 else
Chuck Lever9903cd12005-08-11 16:25:26 -04001456 xprt_set_timeout(&xprt->timeout, 5, 5 * HZ);
Chuck Levera246b012005-08-11 16:25:23 -04001457
Chuck Leveredb267a2006-08-22 20:06:18 -04001458 xs_format_peer_addresses(xprt);
1459 dprintk("RPC: set up transport to address %s\n",
1460 xs_print_peer_address(xprt, RPC_DISPLAY_ALL));
1461
Chuck Leverc8541ec2006-10-17 14:44:27 -04001462 return xprt;
Chuck Levera246b012005-08-11 16:25:23 -04001463}
1464
Chuck Lever9903cd12005-08-11 16:25:26 -04001465/**
1466 * xs_setup_tcp - Set up transport to use a TCP socket
Chuck Leverc8541ec2006-10-17 14:44:27 -04001467 * @addr: address of remote server
1468 * @addrlen: length of address in bytes
Chuck Lever9903cd12005-08-11 16:25:26 -04001469 * @to: timeout parameters
1470 *
1471 */
Chuck Leverc8541ec2006-10-17 14:44:27 -04001472struct rpc_xprt *xs_setup_tcp(struct sockaddr *addr, size_t addrlen, struct rpc_timeout *to)
Chuck Levera246b012005-08-11 16:25:23 -04001473{
Chuck Leverc8541ec2006-10-17 14:44:27 -04001474 struct rpc_xprt *xprt;
Chuck Levera246b012005-08-11 16:25:23 -04001475
Chuck Leverc8541ec2006-10-17 14:44:27 -04001476 xprt = xs_setup_xprt(addr, addrlen, xprt_tcp_slot_table_entries);
1477 if (IS_ERR(xprt))
1478 return xprt;
Chuck Levera246b012005-08-11 16:25:23 -04001479
Chuck Leverc8541ec2006-10-17 14:44:27 -04001480 if (ntohs(((struct sockaddr_in *)addr)->sin_port) != 0)
Chuck Leverec739ef2006-08-22 20:06:15 -04001481 xprt_set_bound(xprt);
Chuck Leverec739ef2006-08-22 20:06:15 -04001482
1483 xprt->prot = IPPROTO_TCP;
Chuck Lever808012f2005-08-25 16:25:49 -07001484 xprt->tsh_size = sizeof(rpc_fraghdr) / sizeof(u32);
Chuck Lever808012f2005-08-25 16:25:49 -07001485 xprt->max_payload = RPC_MAX_FRAGMENT_SIZE;
Chuck Levera246b012005-08-11 16:25:23 -04001486
Chuck Leverb0d93ad2005-08-11 16:25:53 -04001487 INIT_WORK(&xprt->connect_worker, xs_tcp_connect_worker, xprt);
Chuck Lever03bf4b72005-08-25 16:25:55 -07001488 xprt->bind_timeout = XS_BIND_TO;
1489 xprt->connect_timeout = XS_TCP_CONN_TO;
1490 xprt->reestablish_timeout = XS_TCP_INIT_REEST_TO;
1491 xprt->idle_timeout = XS_IDLE_DISC_TO;
Chuck Levera246b012005-08-11 16:25:23 -04001492
Chuck Lever262965f2005-08-11 16:25:56 -04001493 xprt->ops = &xs_tcp_ops;
Chuck Levera246b012005-08-11 16:25:23 -04001494
1495 if (to)
1496 xprt->timeout = *to;
1497 else
Chuck Lever9903cd12005-08-11 16:25:26 -04001498 xprt_set_timeout(&xprt->timeout, 2, 60 * HZ);
Chuck Levera246b012005-08-11 16:25:23 -04001499
Chuck Leveredb267a2006-08-22 20:06:18 -04001500 xs_format_peer_addresses(xprt);
1501 dprintk("RPC: set up transport to address %s\n",
1502 xs_print_peer_address(xprt, RPC_DISPLAY_ALL));
1503
Chuck Leverc8541ec2006-10-17 14:44:27 -04001504 return xprt;
Chuck Levera246b012005-08-11 16:25:23 -04001505}