?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
GUI: Fix Tomato RAF theme for all builds. Compilation typo.
[tomato.git] / release / src-rt-6.x.4708 / linux / linux-2.6.36 / net / sunrpc / xprtsock.c
blob16f1ed343fffd48756549ef999119b03daba8da5
1 /*
2 * linux/net/sunrpc/xprtsock.c
3 *
4 * Client-side transport implementation for sockets.
5 *
6 * TCP callback races fixes (C) 1998 Red Hat
7 * TCP send fixes (C) 1998 Red Hat
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>
14 *
15 * IP socket transport implementation, (C) 2005 Chuck Lever <cel@netapp.com>
16 *
17 * IPv6 support contributed by Gilles Quillard, Bull Open Source, 2005.
18 * <gilles.quillard@bull.net>
19 */
20
21 #include <linux/types.h>
22 #include <linux/slab.h>
23 #include <linux/module.h>
24 #include <linux/capability.h>
25 #include <linux/pagemap.h>
26 #include <linux/errno.h>
27 #include <linux/socket.h>
28 #include <linux/in.h>
29 #include <linux/net.h>
30 #include <linux/mm.h>
31 #include <linux/udp.h>
32 #include <linux/tcp.h>
33 #include <linux/sunrpc/clnt.h>
34 #include <linux/sunrpc/sched.h>
35 #include <linux/sunrpc/svcsock.h>
36 #include <linux/sunrpc/xprtsock.h>
37 #include <linux/file.h>
38 #ifdef CONFIG_NFS_V4_1
39 #include <linux/sunrpc/bc_xprt.h>
40 #endif
41
42 #include <net/sock.h>
43 #include <net/checksum.h>
44 #include <net/udp.h>
45 #include <net/tcp.h>
46
47 #include "sunrpc.h"
48 /*
49 * xprtsock tunables
50 */
51 unsigned int xprt_udp_slot_table_entries = RPC_DEF_SLOT_TABLE;
52 unsigned int xprt_tcp_slot_table_entries = RPC_DEF_SLOT_TABLE;
53
54 unsigned int xprt_min_resvport = RPC_DEF_MIN_RESVPORT;
55 unsigned int xprt_max_resvport = RPC_DEF_MAX_RESVPORT;
56
57 #define XS_TCP_LINGER_TO (15U * HZ)
58 static unsigned int xs_tcp_fin_timeout __read_mostly = XS_TCP_LINGER_TO;
59
60 /*
61 * We can register our own files under /proc/sys/sunrpc by
62 * calling register_sysctl_table() again. The files in that
63 * directory become the union of all files registered there.
64 *
65 * We simply need to make sure that we don't collide with
66 * someone else's file names!
67 */
68
69 #ifdef RPC_DEBUG
70
71 static unsigned int min_slot_table_size = RPC_MIN_SLOT_TABLE;
72 static unsigned int max_slot_table_size = RPC_MAX_SLOT_TABLE;
73 static unsigned int xprt_min_resvport_limit = RPC_MIN_RESVPORT;
74 static unsigned int xprt_max_resvport_limit = RPC_MAX_RESVPORT;
75
76 static struct ctl_table_header *sunrpc_table_header;
77
78 static ctl_table xs_tunables_table[] = {
79 {
80 .procname = "udp_slot_table_entries",
81 .data = &xprt_udp_slot_table_entries,
82 .maxlen = sizeof(unsigned int),
83 .mode = 0644,
84 .proc_handler = proc_dointvec_minmax,
85 .extra1 = &min_slot_table_size,
86 .extra2 = &max_slot_table_size
87 },
88 {
89 .procname = "tcp_slot_table_entries",
90 .data = &xprt_tcp_slot_table_entries,
91 .maxlen = sizeof(unsigned int),
92 .mode = 0644,
93 .proc_handler = proc_dointvec_minmax,
94 .extra1 = &min_slot_table_size,
95 .extra2 = &max_slot_table_size
96 },
97 {
98 .procname = "min_resvport",
99 .data = &xprt_min_resvport,
100 .maxlen = sizeof(unsigned int),
101 .mode = 0644,
102 .proc_handler = proc_dointvec_minmax,
103 .extra1 = &xprt_min_resvport_limit,
104 .extra2 = &xprt_max_resvport_limit
105 },
106 {
107 .procname = "max_resvport",
108 .data = &xprt_max_resvport,
109 .maxlen = sizeof(unsigned int),
110 .mode = 0644,
111 .proc_handler = proc_dointvec_minmax,
112 .extra1 = &xprt_min_resvport_limit,
113 .extra2 = &xprt_max_resvport_limit
114 },
115 {
116 .procname = "tcp_fin_timeout",
117 .data = &xs_tcp_fin_timeout,
118 .maxlen = sizeof(xs_tcp_fin_timeout),
119 .mode = 0644,
120 .proc_handler = proc_dointvec_jiffies,
121 },
122 { },
123 };
124
125 static ctl_table sunrpc_table[] = {
126 {
127 .procname = "sunrpc",
128 .mode = 0555,
129 .child = xs_tunables_table
130 },
131 { },
132 };
133
134 #endif
135
136 /*
137 * Wait duration for a reply from the RPC portmapper.
138 */
139 #define XS_BIND_TO (60U * HZ)
140
141 /*
142 * Delay if a UDP socket connect error occurs. This is most likely some
143 * kind of resource problem on the local host.
144 */
145 #define XS_UDP_REEST_TO (2U * HZ)
146
147 /*
148 * The reestablish timeout allows clients to delay for a bit before attempting
149 * to reconnect to a server that just dropped our connection.
150 *
151 * We implement an exponential backoff when trying to reestablish a TCP
152 * transport connection with the server. Some servers like to drop a TCP
153 * connection when they are overworked, so we start with a short timeout and
154 * increase over time if the server is down or not responding.
155 */
156 #define XS_TCP_INIT_REEST_TO (3U * HZ)
157 #define XS_TCP_MAX_REEST_TO (5U * 60 * HZ)
158
159 /*
160 * TCP idle timeout; client drops the transport socket if it is idle
161 * for this long. Note that we also timeout UDP sockets to prevent
162 * holding port numbers when there is no RPC traffic.
163 */
164 #define XS_IDLE_DISC_TO (5U * 60 * HZ)
165
166 #ifdef RPC_DEBUG
167 # undef RPC_DEBUG_DATA
168 # define RPCDBG_FACILITY RPCDBG_TRANS
169 #endif
170
171 #ifdef RPC_DEBUG_DATA
172 static void xs_pktdump(char *msg, u32 *packet, unsigned int count)
173 {
174 u8 *buf = (u8 *) packet;
175 int j;
176
177 dprintk("RPC: %s\n", msg);
178 for (j = 0; j < count && j < 128; j += 4) {
179 if (!(j & 31)) {
180 if (j)
181 dprintk("\n");
182 dprintk("0x%04x ", j);
183 }
184 dprintk("%02x%02x%02x%02x ",
185 buf[j], buf[j+1], buf[j+2], buf[j+3]);
186 }
187 dprintk("\n");
188 }
189 #else
190 static inline void xs_pktdump(char *msg, u32 *packet, unsigned int count)
191 {
192 /* NOP */
193 }
194 #endif
195
196 struct sock_xprt {
197 struct rpc_xprt xprt;
198
199 /*
200 * Network layer
201 */
202 struct socket * sock;
203 struct sock * inet;
204
205 /*
206 * State of TCP reply receive
207 */
208 __be32 tcp_fraghdr,
209 tcp_xid,
210 tcp_calldir;
211
212 u32 tcp_offset,
213 tcp_reclen;
214
215 unsigned long tcp_copied,
216 tcp_flags;
217
218 /*
219 * Connection of transports
220 */
221 struct delayed_work connect_worker;
222 struct sockaddr_storage srcaddr;
223 unsigned short srcport;
224
225 /*
226 * UDP socket buffer size parameters
227 */
228 size_t rcvsize,
229 sndsize;
230
231 /*
232 * Saved socket callback addresses
233 */
234 void (*old_data_ready)(struct sock *, int);
235 void (*old_state_change)(struct sock *);
236 void (*old_write_space)(struct sock *);
237 void (*old_error_report)(struct sock *);
238 };
239
240 /*
241 * TCP receive state flags
242 */
243 #define TCP_RCV_LAST_FRAG (1UL << 0)
244 #define TCP_RCV_COPY_FRAGHDR (1UL << 1)
245 #define TCP_RCV_COPY_XID (1UL << 2)
246 #define TCP_RCV_COPY_DATA (1UL << 3)
247 #define TCP_RCV_READ_CALLDIR (1UL << 4)
248 #define TCP_RCV_COPY_CALLDIR (1UL << 5)
249
250 /*
251 * TCP RPC flags
252 */
253 #define TCP_RPC_REPLY (1UL << 6)
254
255 static inline struct sockaddr *xs_addr(struct rpc_xprt *xprt)
256 {
257 return (struct sockaddr *) &xprt->addr;
258 }
259
260 static inline struct sockaddr_in *xs_addr_in(struct rpc_xprt *xprt)
261 {
262 return (struct sockaddr_in *) &xprt->addr;
263 }
264
265 static inline struct sockaddr_in6 *xs_addr_in6(struct rpc_xprt *xprt)
266 {
267 return (struct sockaddr_in6 *) &xprt->addr;
268 }
269
270 static void xs_format_common_peer_addresses(struct rpc_xprt *xprt)
271 {
272 struct sockaddr *sap = xs_addr(xprt);
273 struct sockaddr_in6 *sin6;
274 struct sockaddr_in *sin;
275 char buf[128];
276
277 (void)rpc_ntop(sap, buf, sizeof(buf));
278 xprt->address_strings[RPC_DISPLAY_ADDR] = kstrdup(buf, GFP_KERNEL);
279
280 switch (sap->sa_family) {
281 case AF_INET:
282 sin = xs_addr_in(xprt);
283 snprintf(buf, sizeof(buf), "%08x", ntohl(sin->sin_addr.s_addr));
284 break;
285 case AF_INET6:
286 sin6 = xs_addr_in6(xprt);
287 snprintf(buf, sizeof(buf), "%pi6", &sin6->sin6_addr);
288 break;
289 default:
290 BUG();
291 }
292 xprt->address_strings[RPC_DISPLAY_HEX_ADDR] = kstrdup(buf, GFP_KERNEL);
293 }
294
295 static void xs_format_common_peer_ports(struct rpc_xprt *xprt)
296 {
297 struct sockaddr *sap = xs_addr(xprt);
298 char buf[128];
299
300 snprintf(buf, sizeof(buf), "%u", rpc_get_port(sap));
301 xprt->address_strings[RPC_DISPLAY_PORT] = kstrdup(buf, GFP_KERNEL);
302
303 snprintf(buf, sizeof(buf), "%4hx", rpc_get_port(sap));
304 xprt->address_strings[RPC_DISPLAY_HEX_PORT] = kstrdup(buf, GFP_KERNEL);
305 }
306
307 static void xs_format_peer_addresses(struct rpc_xprt *xprt,
308 const char *protocol,
309 const char *netid)
310 {
311 xprt->address_strings[RPC_DISPLAY_PROTO] = protocol;
312 xprt->address_strings[RPC_DISPLAY_NETID] = netid;
313 xs_format_common_peer_addresses(xprt);
314 xs_format_common_peer_ports(xprt);
315 }
316
317 static void xs_update_peer_port(struct rpc_xprt *xprt)
318 {
319 kfree(xprt->address_strings[RPC_DISPLAY_HEX_PORT]);
320 kfree(xprt->address_strings[RPC_DISPLAY_PORT]);
321
322 xs_format_common_peer_ports(xprt);
323 }
324
325 static void xs_free_peer_addresses(struct rpc_xprt *xprt)
326 {
327 unsigned int i;
328
329 for (i = 0; i < RPC_DISPLAY_MAX; i++)
330 switch (i) {
331 case RPC_DISPLAY_PROTO:
332 case RPC_DISPLAY_NETID:
333 continue;
334 default:
335 kfree(xprt->address_strings[i]);
336 }
337 }
338
339 #define XS_SENDMSG_FLAGS (MSG_DONTWAIT | MSG_NOSIGNAL)
340
341 static int xs_send_kvec(struct socket *sock, struct sockaddr *addr, int addrlen, struct kvec *vec, unsigned int base, int more)
342 {
343 struct msghdr msg = {
344 .msg_name = addr,
345 .msg_namelen = addrlen,
346 .msg_flags = XS_SENDMSG_FLAGS | (more ? MSG_MORE : 0),
347 };
348 struct kvec iov = {
349 .iov_base = vec->iov_base + base,
350 .iov_len = vec->iov_len - base,
351 };
352
353 if (iov.iov_len != 0)
354 return kernel_sendmsg(sock, &msg, &iov, 1, iov.iov_len);
355 return kernel_sendmsg(sock, &msg, NULL, 0, 0);
356 }
357
358 static int xs_send_pagedata(struct socket *sock, struct xdr_buf *xdr, unsigned int base, int more)
359 {
360 struct page **ppage;
361 unsigned int remainder;
362 int err, sent = 0;
363
364 remainder = xdr->page_len - base;
365 base += xdr->page_base;
366 ppage = xdr->pages + (base >> PAGE_SHIFT);
367 base &= ~PAGE_MASK;
368 for(;;) {
369 unsigned int len = min_t(unsigned int, PAGE_SIZE - base, remainder);
370 int flags = XS_SENDMSG_FLAGS;
371
372 remainder -= len;
373 if (remainder != 0 || more)
374 flags |= MSG_MORE;
375 err = sock->ops->sendpage(sock, *ppage, base, len, flags);
376 if (remainder == 0 || err != len)
377 break;
378 sent += err;
379 ppage++;
380 base = 0;
381 }
382 if (sent == 0)
383 return err;
384 if (err > 0)
385 sent += err;
386 return sent;
387 }
388
389 /**
390 * xs_sendpages - write pages directly to a socket
391 * @sock: socket to send on
392 * @addr: UDP only -- address of destination
393 * @addrlen: UDP only -- length of destination address
394 * @xdr: buffer containing this request
395 * @base: starting position in the buffer
396 *
397 */
398 static int xs_sendpages(struct socket *sock, struct sockaddr *addr, int addrlen, struct xdr_buf *xdr, unsigned int base)
399 {
400 unsigned int remainder = xdr->len - base;
401 int err, sent = 0;
402
403 if (unlikely(!sock))
404 return -ENOTSOCK;
405
406 clear_bit(SOCK_ASYNC_NOSPACE, &sock->flags);
407 if (base != 0) {
408 addr = NULL;
409 addrlen = 0;
410 }
411
412 if (base < xdr->head[0].iov_len || addr != NULL) {
413 unsigned int len = xdr->head[0].iov_len - base;
414 remainder -= len;
415 err = xs_send_kvec(sock, addr, addrlen, &xdr->head[0], base, remainder != 0);
416 if (remainder == 0 || err != len)
417 goto out;
418 sent += err;
419 base = 0;
420 } else
421 base -= xdr->head[0].iov_len;
422
423 if (base < xdr->page_len) {
424 unsigned int len = xdr->page_len - base;
425 remainder -= len;
426 err = xs_send_pagedata(sock, xdr, base, remainder != 0);
427 if (remainder == 0 || err != len)
428 goto out;
429 sent += err;
430 base = 0;
431 } else
432 base -= xdr->page_len;
433
434 if (base >= xdr->tail[0].iov_len)
435 return sent;
436 err = xs_send_kvec(sock, NULL, 0, &xdr->tail[0], base, 0);
437 out:
438 if (sent == 0)
439 return err;
440 if (err > 0)
441 sent += err;
442 return sent;
443 }
444
445 static void xs_nospace_callback(struct rpc_task *task)
446 {
447 struct sock_xprt *transport = container_of(task->tk_rqstp->rq_xprt, struct sock_xprt, xprt);
448
449 transport->inet->sk_write_pending--;
450 clear_bit(SOCK_ASYNC_NOSPACE, &transport->sock->flags);
451 }
452
453 /**
454 * xs_nospace - place task on wait queue if transmit was incomplete
455 * @task: task to put to sleep
456 *
457 */
458 static int xs_nospace(struct rpc_task *task)
459 {
460 struct rpc_rqst *req = task->tk_rqstp;
461 struct rpc_xprt *xprt = req->rq_xprt;
462 struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
463 int ret = 0;
464
465 dprintk("RPC: %5u xmit incomplete (%u left of %u)\n",
466 task->tk_pid, req->rq_slen - req->rq_bytes_sent,
467 req->rq_slen);
468
469 /* Protect against races with write_space */
470 spin_lock_bh(&xprt->transport_lock);
471
472 /* Don't race with disconnect */
473 if (xprt_connected(xprt)) {
474 if (test_bit(SOCK_ASYNC_NOSPACE, &transport->sock->flags)) {
475 ret = -EAGAIN;
476 /*
477 * Notify TCP that we're limited by the application
478 * window size
479 */
480 set_bit(SOCK_NOSPACE, &transport->sock->flags);
481 transport->inet->sk_write_pending++;
482 /* ...and wait for more buffer space */
483 xprt_wait_for_buffer_space(task, xs_nospace_callback);
484 }
485 } else {
486 clear_bit(SOCK_ASYNC_NOSPACE, &transport->sock->flags);
487 ret = -ENOTCONN;
488 }
489
490 spin_unlock_bh(&xprt->transport_lock);
491 return ret;
492 }
493
494 /**
495 * xs_udp_send_request - write an RPC request to a UDP socket
496 * @task: address of RPC task that manages the state of an RPC request
497 *
498 * Return values:
499 * 0: The request has been sent
500 * EAGAIN: The socket was blocked, please call again later to
501 * complete the request
502 * ENOTCONN: Caller needs to invoke connect logic then call again
503 * other: Some other error occured, the request was not sent
504 */
505 static int xs_udp_send_request(struct rpc_task *task)
506 {
507 struct rpc_rqst *req = task->tk_rqstp;
508 struct rpc_xprt *xprt = req->rq_xprt;
509 struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
510 struct xdr_buf *xdr = &req->rq_snd_buf;
511 int status;
512
513 xs_pktdump("packet data:",
514 req->rq_svec->iov_base,
515 req->rq_svec->iov_len);
516
517 if (!xprt_bound(xprt))
518 return -ENOTCONN;
519 status = xs_sendpages(transport->sock,
520 xs_addr(xprt),
521 xprt->addrlen, xdr,
522 req->rq_bytes_sent);
523
524 dprintk("RPC: xs_udp_send_request(%u) = %d\n",
525 xdr->len - req->rq_bytes_sent, status);
526
527 if (status >= 0) {
528 req->rq_xmit_bytes_sent += status;
529 if (status >= req->rq_slen)
530 return 0;
531 /* Still some bytes left; set up for a retry later. */
532 status = -EAGAIN;
533 }
534
535 switch (status) {
536 case -ENOTSOCK:
537 status = -ENOTCONN;
538 /* Should we call xs_close() here? */
539 break;
540 case -EAGAIN:
541 status = xs_nospace(task);
542 break;
543 default:
544 dprintk("RPC: sendmsg returned unrecognized error %d\n",
545 -status);
546 case -ENETUNREACH:
547 case -EPIPE:
548 case -ECONNREFUSED:
549 /* When the server has died, an ICMP port unreachable message
550 * prompts ECONNREFUSED. */
551 clear_bit(SOCK_ASYNC_NOSPACE, &transport->sock->flags);
552 }
553
554 return status;
555 }
556
557 /**
558 * xs_tcp_shutdown - gracefully shut down a TCP socket
559 * @xprt: transport
560 *
561 * Initiates a graceful shutdown of the TCP socket by calling the
562 * equivalent of shutdown(SHUT_WR);
563 */
564 static void xs_tcp_shutdown(struct rpc_xprt *xprt)
565 {
566 struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
567 struct socket *sock = transport->sock;
568
569 if (sock != NULL)
570 kernel_sock_shutdown(sock, SHUT_WR);
571 }
572
573 static inline void xs_encode_tcp_record_marker(struct xdr_buf *buf)
574 {
575 u32 reclen = buf->len - sizeof(rpc_fraghdr);
576 rpc_fraghdr *base = buf->head[0].iov_base;
577 *base = htonl(RPC_LAST_STREAM_FRAGMENT | reclen);
578 }
579
580 static int xs_tcp_send_request(struct rpc_task *task)
581 {
582 struct rpc_rqst *req = task->tk_rqstp;
583 struct rpc_xprt *xprt = req->rq_xprt;
584 struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
585 struct xdr_buf *xdr = &req->rq_snd_buf;
586 int status;
587
588 xs_encode_tcp_record_marker(&req->rq_snd_buf);
589
590 xs_pktdump("packet data:",
591 req->rq_svec->iov_base,
592 req->rq_svec->iov_len);
593
594 /* Continue transmitting the packet/record. We must be careful
595 * to cope with writespace callbacks arriving _after_ we have
596 * called sendmsg(). */
597 while (1) {
598 status = xs_sendpages(transport->sock,
599 NULL, 0, xdr, req->rq_bytes_sent);
600
601 dprintk("RPC: xs_tcp_send_request(%u) = %d\n",
602 xdr->len - req->rq_bytes_sent, status);
603
604 if (unlikely(status < 0))
605 break;
606
607 /* If we've sent the entire packet, immediately
608 * reset the count of bytes sent. */
609 req->rq_bytes_sent += status;
610 req->rq_xmit_bytes_sent += status;
611 if (likely(req->rq_bytes_sent >= req->rq_slen)) {
612 req->rq_bytes_sent = 0;
613 return 0;
614 }
615
616 if (status != 0)
617 continue;
618 status = -EAGAIN;
619 break;
620 }
621
622 switch (status) {
623 case -ENOTSOCK:
624 status = -ENOTCONN;
625 /* Should we call xs_close() here? */
626 break;
627 case -EAGAIN:
628 status = xs_nospace(task);
629 break;
630 default:
631 dprintk("RPC: sendmsg returned unrecognized error %d\n",
632 -status);
633 case -ECONNRESET:
634 case -EPIPE:
635 xs_tcp_shutdown(xprt);
636 case -ECONNREFUSED:
637 case -ENOTCONN:
638 clear_bit(SOCK_ASYNC_NOSPACE, &transport->sock->flags);
639 }
640
641 return status;
642 }
643
644 /**
645 * xs_tcp_release_xprt - clean up after a tcp transmission
646 * @xprt: transport
647 * @task: rpc task
648 *
649 * This cleans up if an error causes us to abort the transmission of a request.
650 * In this case, the socket may need to be reset in order to avoid confusing
651 * the server.
652 */
653 static void xs_tcp_release_xprt(struct rpc_xprt *xprt, struct rpc_task *task)
654 {
655 struct rpc_rqst *req;
656
657 if (task != xprt->snd_task)
658 return;
659 if (task == NULL)
660 goto out_release;
661 req = task->tk_rqstp;
662 if (req->rq_bytes_sent == 0)
663 goto out_release;
664 if (req->rq_bytes_sent == req->rq_snd_buf.len)
665 goto out_release;
666 set_bit(XPRT_CLOSE_WAIT, &task->tk_xprt->state);
667 out_release:
668 xprt_release_xprt(xprt, task);
669 }
670
671 static void xs_save_old_callbacks(struct sock_xprt *transport, struct sock *sk)
672 {
673 transport->old_data_ready = sk->sk_data_ready;
674 transport->old_state_change = sk->sk_state_change;
675 transport->old_write_space = sk->sk_write_space;
676 transport->old_error_report = sk->sk_error_report;
677 }
678
679 static void xs_restore_old_callbacks(struct sock_xprt *transport, struct sock *sk)
680 {
681 sk->sk_data_ready = transport->old_data_ready;
682 sk->sk_state_change = transport->old_state_change;
683 sk->sk_write_space = transport->old_write_space;
684 sk->sk_error_report = transport->old_error_report;
685 }
686
687 static void xs_reset_transport(struct sock_xprt *transport)
688 {
689 struct socket *sock = transport->sock;
690 struct sock *sk = transport->inet;
691
692 if (sk == NULL)
693 return;
694
695 write_lock_bh(&sk->sk_callback_lock);
696 transport->inet = NULL;
697 transport->sock = NULL;
698
699 sk->sk_user_data = NULL;
700
701 xs_restore_old_callbacks(transport, sk);
702 write_unlock_bh(&sk->sk_callback_lock);
703
704 sk->sk_no_check = 0;
705
706 sock_release(sock);
707 }
708
709 /**
710 * xs_close - close a socket
711 * @xprt: transport
712 *
713 * This is used when all requests are complete; ie, no DRC state remains
714 * on the server we want to save.
715 *
716 * The caller _must_ be holding XPRT_LOCKED in order to avoid issues with
717 * xs_reset_transport() zeroing the socket from underneath a writer.
718 */
719 static void xs_close(struct rpc_xprt *xprt)
720 {
721 struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
722
723 dprintk("RPC: xs_close xprt %p\n", xprt);
724
725 xs_reset_transport(transport);
726 xprt->reestablish_timeout = 0;
727
728 smp_mb__before_clear_bit();
729 clear_bit(XPRT_CONNECTION_ABORT, &xprt->state);
730 clear_bit(XPRT_CLOSE_WAIT, &xprt->state);
731 clear_bit(XPRT_CLOSING, &xprt->state);
732 smp_mb__after_clear_bit();
733 xprt_disconnect_done(xprt);
734 }
735
736 static void xs_tcp_close(struct rpc_xprt *xprt)
737 {
738 if (test_and_clear_bit(XPRT_CONNECTION_CLOSE, &xprt->state))
739 xs_close(xprt);
740 else
741 xs_tcp_shutdown(xprt);
742 }
743
744 /**
745 * xs_destroy - prepare to shutdown a transport
746 * @xprt: doomed transport
747 *
748 */
749 static void xs_destroy(struct rpc_xprt *xprt)
750 {
751 struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
752
753 dprintk("RPC: xs_destroy xprt %p\n", xprt);
754
755 cancel_rearming_delayed_work(&transport->connect_worker);
756
757 xs_close(xprt);
758 xs_free_peer_addresses(xprt);
759 kfree(xprt->slot);
760 kfree(xprt);
761 module_put(THIS_MODULE);
762 }
763
764 static inline struct rpc_xprt *xprt_from_sock(struct sock *sk)
765 {
766 return (struct rpc_xprt *) sk->sk_user_data;
767 }
768
769 /**
770 * xs_udp_data_ready - "data ready" callback for UDP sockets
771 * @sk: socket with data to read
772 * @len: how much data to read
773 *
774 */
775 static void xs_udp_data_ready(struct sock *sk, int len)
776 {
777 struct rpc_task *task;
778 struct rpc_xprt *xprt;
779 struct rpc_rqst *rovr;
780 struct sk_buff *skb;
781 int err, repsize, copied;
782 u32 _xid;
783 __be32 *xp;
784
785 read_lock_bh(&sk->sk_callback_lock);
786 dprintk("RPC: xs_udp_data_ready...\n");
787 if (!(xprt = xprt_from_sock(sk)))
788 goto out;
789
790 if ((skb = skb_recv_datagram(sk, 0, 1, &err)) == NULL)
791 goto out;
792
793 if (xprt->shutdown)
794 goto dropit;
795
796 repsize = skb->len - sizeof(struct udphdr);
797 if (repsize < 4) {
798 dprintk("RPC: impossible RPC reply size %d!\n", repsize);
799 goto dropit;
800 }
801
802 /* Copy the XID from the skb... */
803 xp = skb_header_pointer(skb, sizeof(struct udphdr),
804 sizeof(_xid), &_xid);
805 if (xp == NULL)
806 goto dropit;
807
808 /* Look up and lock the request corresponding to the given XID */
809 spin_lock(&xprt->transport_lock);
810 rovr = xprt_lookup_rqst(xprt, *xp);
811 if (!rovr)
812 goto out_unlock;
813 task = rovr->rq_task;
814
815 if ((copied = rovr->rq_private_buf.buflen) > repsize)
816 copied = repsize;
817
818 /* Suck it into the iovec, verify checksum if not done by hw. */
819 if (csum_partial_copy_to_xdr(&rovr->rq_private_buf, skb)) {
820 UDPX_INC_STATS_BH(sk, UDP_MIB_INERRORS);
821 goto out_unlock;
822 }
823
824 UDPX_INC_STATS_BH(sk, UDP_MIB_INDATAGRAMS);
825
826 /* Something worked... */
827 dst_confirm(skb_dst(skb));
828
829 xprt_adjust_cwnd(task, copied);
830 xprt_complete_rqst(task, copied);
831
832 out_unlock:
833 spin_unlock(&xprt->transport_lock);
834 dropit:
835 skb_free_datagram(sk, skb);
836 out:
837 read_unlock_bh(&sk->sk_callback_lock);
838 }
839
840 static inline void xs_tcp_read_fraghdr(struct rpc_xprt *xprt, struct xdr_skb_reader *desc)
841 {
842 struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
843 size_t len, used;
844 char *p;
845
846 p = ((char *) &transport->tcp_fraghdr) + transport->tcp_offset;
847 len = sizeof(transport->tcp_fraghdr) - transport->tcp_offset;
848 used = xdr_skb_read_bits(desc, p, len);
849 transport->tcp_offset += used;
850 if (used != len)
851 return;
852
853 transport->tcp_reclen = ntohl(transport->tcp_fraghdr);
854 if (transport->tcp_reclen & RPC_LAST_STREAM_FRAGMENT)
855 transport->tcp_flags |= TCP_RCV_LAST_FRAG;
856 else
857 transport->tcp_flags &= ~TCP_RCV_LAST_FRAG;
858 transport->tcp_reclen &= RPC_FRAGMENT_SIZE_MASK;
859
860 transport->tcp_flags &= ~TCP_RCV_COPY_FRAGHDR;
861 transport->tcp_offset = 0;
862
863 /* Sanity check of the record length */
864 if (unlikely(transport->tcp_reclen < 8)) {
865 dprintk("RPC: invalid TCP record fragment length\n");
866 xprt_force_disconnect(xprt);
867 return;
868 }
869 dprintk("RPC: reading TCP record fragment of length %d\n",
870 transport->tcp_reclen);
871 }
872
873 static void xs_tcp_check_fraghdr(struct sock_xprt *transport)
874 {
875 if (transport->tcp_offset == transport->tcp_reclen) {
876 transport->tcp_flags |= TCP_RCV_COPY_FRAGHDR;
877 transport->tcp_offset = 0;
878 if (transport->tcp_flags & TCP_RCV_LAST_FRAG) {
879 transport->tcp_flags &= ~TCP_RCV_COPY_DATA;
880 transport->tcp_flags |= TCP_RCV_COPY_XID;
881 transport->tcp_copied = 0;
882 }
883 }
884 }
885
886 static inline void xs_tcp_read_xid(struct sock_xprt *transport, struct xdr_skb_reader *desc)
887 {
888 size_t len, used;
889 char *p;
890
891 len = sizeof(transport->tcp_xid) - transport->tcp_offset;
892 dprintk("RPC: reading XID (%Zu bytes)\n", len);
893 p = ((char *) &transport->tcp_xid) + transport->tcp_offset;
894 used = xdr_skb_read_bits(desc, p, len);
895 transport->tcp_offset += used;
896 if (used != len)
897 return;
898 transport->tcp_flags &= ~TCP_RCV_COPY_XID;
899 transport->tcp_flags |= TCP_RCV_READ_CALLDIR;
900 transport->tcp_copied = 4;
901 dprintk("RPC: reading %s XID %08x\n",
902 (transport->tcp_flags & TCP_RPC_REPLY) ? "reply for"
903 : "request with",
904 ntohl(transport->tcp_xid));
905 xs_tcp_check_fraghdr(transport);
906 }
907
908 static inline void xs_tcp_read_calldir(struct sock_xprt *transport,
909 struct xdr_skb_reader *desc)
910 {
911 size_t len, used;
912 u32 offset;
913 char *p;
914
915 /*
916 * We want transport->tcp_offset to be 8 at the end of this routine
917 * (4 bytes for the xid and 4 bytes for the call/reply flag).
918 * When this function is called for the first time,
919 * transport->tcp_offset is 4 (after having already read the xid).
920 */
921 offset = transport->tcp_offset - sizeof(transport->tcp_xid);
922 len = sizeof(transport->tcp_calldir) - offset;
923 dprintk("RPC: reading CALL/REPLY flag (%Zu bytes)\n", len);
924 p = ((char *) &transport->tcp_calldir) + offset;
925 used = xdr_skb_read_bits(desc, p, len);
926 transport->tcp_offset += used;
927 if (used != len)
928 return;
929 transport->tcp_flags &= ~TCP_RCV_READ_CALLDIR;
930 /*
931 * We don't yet have the XDR buffer, so we will write the calldir
932 * out after we get the buffer from the 'struct rpc_rqst'
933 */
934 switch (ntohl(transport->tcp_calldir)) {
935 case RPC_REPLY:
936 transport->tcp_flags |= TCP_RCV_COPY_CALLDIR;
937 transport->tcp_flags |= TCP_RCV_COPY_DATA;
938 transport->tcp_flags |= TCP_RPC_REPLY;
939 break;
940 case RPC_CALL:
941 transport->tcp_flags |= TCP_RCV_COPY_CALLDIR;
942 transport->tcp_flags |= TCP_RCV_COPY_DATA;
943 transport->tcp_flags &= ~TCP_RPC_REPLY;
944 break;
945 default:
946 dprintk("RPC: invalid request message type\n");
947 xprt_force_disconnect(&transport->xprt);
948 }
949 xs_tcp_check_fraghdr(transport);
950 }
951
952 static inline void xs_tcp_read_common(struct rpc_xprt *xprt,
953 struct xdr_skb_reader *desc,
954 struct rpc_rqst *req)
955 {
956 struct sock_xprt *transport =
957 container_of(xprt, struct sock_xprt, xprt);
958 struct xdr_buf *rcvbuf;
959 size_t len;
960 ssize_t r;
961
962 rcvbuf = &req->rq_private_buf;
963
964 if (transport->tcp_flags & TCP_RCV_COPY_CALLDIR) {
965 /*
966 * Save the RPC direction in the XDR buffer
967 */
968 memcpy(rcvbuf->head[0].iov_base + transport->tcp_copied,
969 &transport->tcp_calldir,
970 sizeof(transport->tcp_calldir));
971 transport->tcp_copied += sizeof(transport->tcp_calldir);
972 transport->tcp_flags &= ~TCP_RCV_COPY_CALLDIR;
973 }
974
975 len = desc->count;
976 if (len > transport->tcp_reclen - transport->tcp_offset) {
977 struct xdr_skb_reader my_desc;
978
979 len = transport->tcp_reclen - transport->tcp_offset;
980 memcpy(&my_desc, desc, sizeof(my_desc));
981 my_desc.count = len;
982 r = xdr_partial_copy_from_skb(rcvbuf, transport->tcp_copied,
983 &my_desc, xdr_skb_read_bits);
984 desc->count -= r;
985 desc->offset += r;
986 } else
987 r = xdr_partial_copy_from_skb(rcvbuf, transport->tcp_copied,
988 desc, xdr_skb_read_bits);
989
990 if (r > 0) {
991 transport->tcp_copied += r;
992 transport->tcp_offset += r;
993 }
994 if (r != len) {
995 /* Error when copying to the receive buffer,
996 * usually because we weren't able to allocate
997 * additional buffer pages. All we can do now
998 * is turn off TCP_RCV_COPY_DATA, so the request
999 * will not receive any additional updates,
1000 * and time out.
1001 * Any remaining data from this record will
1002 * be discarded.
1003 */
1004 transport->tcp_flags &= ~TCP_RCV_COPY_DATA;
1005 dprintk("RPC: XID %08x truncated request\n",
1006 ntohl(transport->tcp_xid));
1007 dprintk("RPC: xprt = %p, tcp_copied = %lu, "
1008 "tcp_offset = %u, tcp_reclen = %u\n",
1009 xprt, transport->tcp_copied,
1010 transport->tcp_offset, transport->tcp_reclen);
1011 return;
1012 }
1013
1014 dprintk("RPC: XID %08x read %Zd bytes\n",
1015 ntohl(transport->tcp_xid), r);
1016 dprintk("RPC: xprt = %p, tcp_copied = %lu, tcp_offset = %u, "
1017 "tcp_reclen = %u\n", xprt, transport->tcp_copied,
1018 transport->tcp_offset, transport->tcp_reclen);
1019
1020 if (transport->tcp_copied == req->rq_private_buf.buflen)
1021 transport->tcp_flags &= ~TCP_RCV_COPY_DATA;
1022 else if (transport->tcp_offset == transport->tcp_reclen) {
1023 if (transport->tcp_flags & TCP_RCV_LAST_FRAG)
1024 transport->tcp_flags &= ~TCP_RCV_COPY_DATA;
1025 }
1026 }
1027
1028 /*
1029 * Finds the request corresponding to the RPC xid and invokes the common
1030 * tcp read code to read the data.
1031 */
1032 static inline int xs_tcp_read_reply(struct rpc_xprt *xprt,
1033 struct xdr_skb_reader *desc)
1034 {
1035 struct sock_xprt *transport =
1036 container_of(xprt, struct sock_xprt, xprt);
1037 struct rpc_rqst *req;
1038
1039 dprintk("RPC: read reply XID %08x\n", ntohl(transport->tcp_xid));
1040
1041 /* Find and lock the request corresponding to this xid */
1042 spin_lock(&xprt->transport_lock);
1043 req = xprt_lookup_rqst(xprt, transport->tcp_xid);
1044 if (!req) {
1045 dprintk("RPC: XID %08x request not found!\n",
1046 ntohl(transport->tcp_xid));
1047 spin_unlock(&xprt->transport_lock);
1048 return -1;
1049 }
1050
1051 xs_tcp_read_common(xprt, desc, req);
1052
1053 if (!(transport->tcp_flags & TCP_RCV_COPY_DATA))
1054 xprt_complete_rqst(req->rq_task, transport->tcp_copied);
1055
1056 spin_unlock(&xprt->transport_lock);
1057 return 0;
1058 }
1059
1060 #if defined(CONFIG_NFS_V4_1)
1061 /*
1062 * Obtains an rpc_rqst previously allocated and invokes the common
1063 * tcp read code to read the data. The result is placed in the callback
1064 * queue.
1065 * If we're unable to obtain the rpc_rqst we schedule the closing of the
1066 * connection and return -1.
1067 */
1068 static inline int xs_tcp_read_callback(struct rpc_xprt *xprt,
1069 struct xdr_skb_reader *desc)
1070 {
1071 struct sock_xprt *transport =
1072 container_of(xprt, struct sock_xprt, xprt);
1073 struct rpc_rqst *req;
1074
1075 req = xprt_alloc_bc_request(xprt);
1076 if (req == NULL) {
1077 printk(KERN_WARNING "Callback slot table overflowed\n");
1078 xprt_force_disconnect(xprt);
1079 return -1;
1080 }
1081
1082 req->rq_xid = transport->tcp_xid;
1083 dprintk("RPC: read callback XID %08x\n", ntohl(req->rq_xid));
1084 xs_tcp_read_common(xprt, desc, req);
1085
1086 if (!(transport->tcp_flags & TCP_RCV_COPY_DATA)) {
1087 struct svc_serv *bc_serv = xprt->bc_serv;
1088
1089 /*
1090 * Add callback request to callback list. The callback
1091 * service sleeps on the sv_cb_waitq waiting for new
1092 * requests. Wake it up after adding enqueing the
1093 * request.
1094 */
1095 dprintk("RPC: add callback request to list\n");
1096 spin_lock(&bc_serv->sv_cb_lock);
1097 list_add(&req->rq_bc_list, &bc_serv->sv_cb_list);
1098 spin_unlock(&bc_serv->sv_cb_lock);
1099 wake_up(&bc_serv->sv_cb_waitq);
1100 }
1101
1102 req->rq_private_buf.len = transport->tcp_copied;
1103
1104 return 0;
1105 }
1106
1107 static inline int _xs_tcp_read_data(struct rpc_xprt *xprt,
1108 struct xdr_skb_reader *desc)
1109 {
1110 struct sock_xprt *transport =
1111 container_of(xprt, struct sock_xprt, xprt);
1112
1113 return (transport->tcp_flags & TCP_RPC_REPLY) ?
1114 xs_tcp_read_reply(xprt, desc) :
1115 xs_tcp_read_callback(xprt, desc);
1116 }
1117 #else
1118 static inline int _xs_tcp_read_data(struct rpc_xprt *xprt,
1119 struct xdr_skb_reader *desc)
1120 {
1121 return xs_tcp_read_reply(xprt, desc);
1122 }
1123 #endif /* CONFIG_NFS_V4_1 */
1124
1125 /*
1126 * Read data off the transport. This can be either an RPC_CALL or an
1127 * RPC_REPLY. Relay the processing to helper functions.
1128 */
1129 static void xs_tcp_read_data(struct rpc_xprt *xprt,
1130 struct xdr_skb_reader *desc)
1131 {
1132 struct sock_xprt *transport =
1133 container_of(xprt, struct sock_xprt, xprt);
1134
1135 if (_xs_tcp_read_data(xprt, desc) == 0)
1136 xs_tcp_check_fraghdr(transport);
1137 else {
1138 /*
1139 * The transport_lock protects the request handling.
1140 * There's no need to hold it to update the tcp_flags.
1141 */
1142 transport->tcp_flags &= ~TCP_RCV_COPY_DATA;
1143 }
1144 }
1145
1146 static inline void xs_tcp_read_discard(struct sock_xprt *transport, struct xdr_skb_reader *desc)
1147 {
1148 size_t len;
1149
1150 len = transport->tcp_reclen - transport->tcp_offset;
1151 if (len > desc->count)
1152 len = desc->count;
1153 desc->count -= len;
1154 desc->offset += len;
1155 transport->tcp_offset += len;
1156 dprintk("RPC: discarded %Zu bytes\n", len);
1157 xs_tcp_check_fraghdr(transport);
1158 }
1159
1160 static int xs_tcp_data_recv(read_descriptor_t *rd_desc, struct sk_buff *skb, unsigned int offset, size_t len)
1161 {
1162 struct rpc_xprt *xprt = rd_desc->arg.data;
1163 struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
1164 struct xdr_skb_reader desc = {
1165 .skb = skb,
1166 .offset = offset,
1167 .count = len,
1168 };
1169
1170 dprintk("RPC: xs_tcp_data_recv started\n");
1171 do {
1172 /* Read in a new fragment marker if necessary */
1173 /* Can we ever really expect to get completely empty fragments? */
1174 if (transport->tcp_flags & TCP_RCV_COPY_FRAGHDR) {
1175 xs_tcp_read_fraghdr(xprt, &desc);
1176 continue;
1177 }
1178 /* Read in the xid if necessary */
1179 if (transport->tcp_flags & TCP_RCV_COPY_XID) {
1180 xs_tcp_read_xid(transport, &desc);
1181 continue;
1182 }
1183 /* Read in the call/reply flag */
1184 if (transport->tcp_flags & TCP_RCV_READ_CALLDIR) {
1185 xs_tcp_read_calldir(transport, &desc);
1186 continue;
1187 }
1188 /* Read in the request data */
1189 if (transport->tcp_flags & TCP_RCV_COPY_DATA) {
1190 xs_tcp_read_data(xprt, &desc);
1191 continue;
1192 }
1193 /* Skip over any trailing bytes on short reads */
1194 xs_tcp_read_discard(transport, &desc);
1195 } while (desc.count);
1196 dprintk("RPC: xs_tcp_data_recv done\n");
1197 return len - desc.count;
1198 }
1199
1200 /**
1201 * xs_tcp_data_ready - "data ready" callback for TCP sockets
1202 * @sk: socket with data to read
1203 * @bytes: how much data to read
1204 *
1205 */
1206 static void xs_tcp_data_ready(struct sock *sk, int bytes)
1207 {
1208 struct rpc_xprt *xprt;
1209 read_descriptor_t rd_desc;
1210 int read;
1211
1212 dprintk("RPC: xs_tcp_data_ready...\n");
1213
1214 read_lock_bh(&sk->sk_callback_lock);
1215 if (!(xprt = xprt_from_sock(sk)))
1216 goto out;
1217 if (xprt->shutdown)
1218 goto out;
1219
1220 /* Any data means we had a useful conversation, so
1221 * the we don't need to delay the next reconnect
1222 */
1223 if (xprt->reestablish_timeout)
1224 xprt->reestablish_timeout = 0;
1225
1226 /* We use rd_desc to pass struct xprt to xs_tcp_data_recv */
1227 rd_desc.arg.data = xprt;
1228 do {
1229 rd_desc.count = 65536;
1230 read = tcp_read_sock(sk, &rd_desc, xs_tcp_data_recv);
1231 } while (read > 0);
1232 out:
1233 read_unlock_bh(&sk->sk_callback_lock);
1234 }
1235
1236 /*
1237 * Do the equivalent of linger/linger2 handling for dealing with
1238 * broken servers that don't close the socket in a timely
1239 * fashion
1240 */
1241 static void xs_tcp_schedule_linger_timeout(struct rpc_xprt *xprt,
1242 unsigned long timeout)
1243 {
1244 struct sock_xprt *transport;
1245
1246 if (xprt_test_and_set_connecting(xprt))
1247 return;
1248 set_bit(XPRT_CONNECTION_ABORT, &xprt->state);
1249 transport = container_of(xprt, struct sock_xprt, xprt);
1250 queue_delayed_work(rpciod_workqueue, &transport->connect_worker,
1251 timeout);
1252 }
1253
1254 static void xs_tcp_cancel_linger_timeout(struct rpc_xprt *xprt)
1255 {
1256 struct sock_xprt *transport;
1257
1258 transport = container_of(xprt, struct sock_xprt, xprt);
1259
1260 if (!test_bit(XPRT_CONNECTION_ABORT, &xprt->state) ||
1261 !cancel_delayed_work(&transport->connect_worker))
1262 return;
1263 clear_bit(XPRT_CONNECTION_ABORT, &xprt->state);
1264 xprt_clear_connecting(xprt);
1265 }
1266
1267 static void xs_sock_mark_closed(struct rpc_xprt *xprt)
1268 {
1269 smp_mb__before_clear_bit();
1270 clear_bit(XPRT_CLOSE_WAIT, &xprt->state);
1271 clear_bit(XPRT_CLOSING, &xprt->state);
1272 smp_mb__after_clear_bit();
1273 /* Mark transport as closed and wake up all pending tasks */
1274 xprt_disconnect_done(xprt);
1275 }
1276
1277 /**
1278 * xs_tcp_state_change - callback to handle TCP socket state changes
1279 * @sk: socket whose state has changed
1280 *
1281 */
1282 static void xs_tcp_state_change(struct sock *sk)
1283 {
1284 struct rpc_xprt *xprt;
1285
1286 read_lock_bh(&sk->sk_callback_lock);
1287 if (!(xprt = xprt_from_sock(sk)))
1288 goto out;
1289 dprintk("RPC: xs_tcp_state_change client %p...\n", xprt);
1290 dprintk("RPC: state %x conn %d dead %d zapped %d sk_shutdown %d\n",
1291 sk->sk_state, xprt_connected(xprt),
1292 sock_flag(sk, SOCK_DEAD),
1293 sock_flag(sk, SOCK_ZAPPED),
1294 sk->sk_shutdown);
1295
1296 switch (sk->sk_state) {
1297 case TCP_ESTABLISHED:
1298 spin_lock(&xprt->transport_lock);
1299 if (!xprt_test_and_set_connected(xprt)) {
1300 struct sock_xprt *transport = container_of(xprt,
1301 struct sock_xprt, xprt);
1302
1303 /* Reset TCP record info */
1304 transport->tcp_offset = 0;
1305 transport->tcp_reclen = 0;
1306 transport->tcp_copied = 0;
1307 transport->tcp_flags =
1308 TCP_RCV_COPY_FRAGHDR | TCP_RCV_COPY_XID;
1309
1310 xprt_wake_pending_tasks(xprt, -EAGAIN);
1311 }
1312 spin_unlock(&xprt->transport_lock);
1313 break;
1314 case TCP_FIN_WAIT1:
1315 /* The client initiated a shutdown of the socket */
1316 xprt->connect_cookie++;
1317 xprt->reestablish_timeout = 0;
1318 set_bit(XPRT_CLOSING, &xprt->state);
1319 smp_mb__before_clear_bit();
1320 clear_bit(XPRT_CONNECTED, &xprt->state);
1321 clear_bit(XPRT_CLOSE_WAIT, &xprt->state);
1322 smp_mb__after_clear_bit();
1323 xs_tcp_schedule_linger_timeout(xprt, xs_tcp_fin_timeout);
1324 break;
1325 case TCP_CLOSE_WAIT:
1326 /* The server initiated a shutdown of the socket */
1327 xprt_force_disconnect(xprt);
1328 case TCP_SYN_SENT:
1329 xprt->connect_cookie++;
1330 case TCP_CLOSING:
1331 /*
1332 * If the server closed down the connection, make sure that
1333 * we back off before reconnecting
1334 */
1335 if (xprt->reestablish_timeout < XS_TCP_INIT_REEST_TO)
1336 xprt->reestablish_timeout = XS_TCP_INIT_REEST_TO;
1337 break;
1338 case TCP_LAST_ACK:
1339 set_bit(XPRT_CLOSING, &xprt->state);
1340 xs_tcp_schedule_linger_timeout(xprt, xs_tcp_fin_timeout);
1341 smp_mb__before_clear_bit();
1342 clear_bit(XPRT_CONNECTED, &xprt->state);
1343 smp_mb__after_clear_bit();
1344 break;
1345 case TCP_CLOSE:
1346 xs_tcp_cancel_linger_timeout(xprt);
1347 xs_sock_mark_closed(xprt);
1348 }
1349 out:
1350 read_unlock_bh(&sk->sk_callback_lock);
1351 }
1352
1353 /**
1354 * xs_error_report - callback mainly for catching socket errors
1355 * @sk: socket
1356 */
1357 static void xs_error_report(struct sock *sk)
1358 {
1359 struct rpc_xprt *xprt;
1360
1361 read_lock_bh(&sk->sk_callback_lock);
1362 if (!(xprt = xprt_from_sock(sk)))
1363 goto out;
1364 dprintk("RPC: %s client %p...\n"
1365 "RPC: error %d\n",
1366 __func__, xprt, sk->sk_err);
1367 xprt_wake_pending_tasks(xprt, -EAGAIN);
1368 out:
1369 read_unlock_bh(&sk->sk_callback_lock);
1370 }
1371
1372 static void xs_write_space(struct sock *sk)
1373 {
1374 struct socket *sock;
1375 struct rpc_xprt *xprt;
1376
1377 if (unlikely(!(sock = sk->sk_socket)))
1378 return;
1379 clear_bit(SOCK_NOSPACE, &sock->flags);
1380
1381 if (unlikely(!(xprt = xprt_from_sock(sk))))
1382 return;
1383 if (test_and_clear_bit(SOCK_ASYNC_NOSPACE, &sock->flags) == 0)
1384 return;
1385
1386 xprt_write_space(xprt);
1387 }
1388
1389 /**
1390 * xs_udp_write_space - callback invoked when socket buffer space
1391 * becomes available
1392 * @sk: socket whose state has changed
1393 *
1394 * Called when more output buffer space is available for this socket.
1395 * We try not to wake our writers until they can make "significant"
1396 * progress, otherwise we'll waste resources thrashing kernel_sendmsg
1397 * with a bunch of small requests.
1398 */
1399 static void xs_udp_write_space(struct sock *sk)
1400 {
1401 read_lock_bh(&sk->sk_callback_lock);
1402
1403 /* from net/core/sock.c:sock_def_write_space */
1404 if (sock_writeable(sk))
1405 xs_write_space(sk);
1406
1407 read_unlock_bh(&sk->sk_callback_lock);
1408 }
1409
1410 /**
1411 * xs_tcp_write_space - callback invoked when socket buffer space
1412 * becomes available
1413 * @sk: socket whose state has changed
1414 *
1415 * Called when more output buffer space is available for this socket.
1416 * We try not to wake our writers until they can make "significant"
1417 * progress, otherwise we'll waste resources thrashing kernel_sendmsg
1418 * with a bunch of small requests.
1419 */
1420 static void xs_tcp_write_space(struct sock *sk)
1421 {
1422 read_lock_bh(&sk->sk_callback_lock);
1423
1424 /* from net/core/stream.c:sk_stream_write_space */
1425 if (sk_stream_wspace(sk) >= sk_stream_min_wspace(sk))
1426 xs_write_space(sk);
1427
1428 read_unlock_bh(&sk->sk_callback_lock);
1429 }
1430
1431 static void xs_udp_do_set_buffer_size(struct rpc_xprt *xprt)
1432 {
1433 struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
1434 struct sock *sk = transport->inet;
1435
1436 if (transport->rcvsize) {
1437 sk->sk_userlocks |= SOCK_RCVBUF_LOCK;
1438 sk->sk_rcvbuf = transport->rcvsize * xprt->max_reqs * 2;
1439 }
1440 if (transport->sndsize) {
1441 sk->sk_userlocks |= SOCK_SNDBUF_LOCK;
1442 sk->sk_sndbuf = transport->sndsize * xprt->max_reqs * 2;
1443 sk->sk_write_space(sk);
1444 }
1445 }
1446
1447 /**
1448 * xs_udp_set_buffer_size - set send and receive limits
1449 * @xprt: generic transport
1450 * @sndsize: requested size of send buffer, in bytes
1451 * @rcvsize: requested size of receive buffer, in bytes
1452 *
1453 * Set socket send and receive buffer size limits.
1454 */
1455 static void xs_udp_set_buffer_size(struct rpc_xprt *xprt, size_t sndsize, size_t rcvsize)
1456 {
1457 struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
1458
1459 transport->sndsize = 0;
1460 if (sndsize)
1461 transport->sndsize = sndsize + 1024;
1462 transport->rcvsize = 0;
1463 if (rcvsize)
1464 transport->rcvsize = rcvsize + 1024;
1465
1466 xs_udp_do_set_buffer_size(xprt);
1467 }
1468
1469 /**
1470 * xs_udp_timer - called when a retransmit timeout occurs on a UDP transport
1471 * @task: task that timed out
1472 *
1473 * Adjust the congestion window after a retransmit timeout has occurred.
1474 */
1475 static void xs_udp_timer(struct rpc_task *task)
1476 {
1477 xprt_adjust_cwnd(task, -ETIMEDOUT);
1478 }
1479
1480 static unsigned short xs_get_random_port(void)
1481 {
1482 unsigned short range = xprt_max_resvport - xprt_min_resvport;
1483 unsigned short rand = (unsigned short) net_random() % range;
1484 return rand + xprt_min_resvport;
1485 }
1486
1487 /**
1488 * xs_set_port - reset the port number in the remote endpoint address
1489 * @xprt: generic transport
1490 * @port: new port number
1491 *
1492 */
1493 static void xs_set_port(struct rpc_xprt *xprt, unsigned short port)
1494 {
1495 dprintk("RPC: setting port for xprt %p to %u\n", xprt, port);
1496
1497 rpc_set_port(xs_addr(xprt), port);
1498 xs_update_peer_port(xprt);
1499 }
1500
1501 static unsigned short xs_get_srcport(struct sock_xprt *transport, struct socket *sock)
1502 {
1503 unsigned short port = transport->srcport;
1504
1505 if (port == 0 && transport->xprt.resvport)
1506 port = xs_get_random_port();
1507 return port;
1508 }
1509
1510 static unsigned short xs_next_srcport(struct sock_xprt *transport, struct socket *sock, unsigned short port)
1511 {
1512 if (transport->srcport != 0)
1513 transport->srcport = 0;
1514 if (!transport->xprt.resvport)
1515 return 0;
1516 if (port <= xprt_min_resvport || port > xprt_max_resvport)
1517 return xprt_max_resvport;
1518 return --port;
1519 }
1520
1521 static int xs_bind4(struct sock_xprt *transport, struct socket *sock)
1522 {
1523 struct sockaddr_in myaddr = {
1524 .sin_family = AF_INET,
1525 };
1526 struct sockaddr_in *sa;
1527 int err, nloop = 0;
1528 unsigned short port = xs_get_srcport(transport, sock);
1529 unsigned short last;
1530
1531 sa = (struct sockaddr_in *)&transport->srcaddr;
1532 myaddr.sin_addr = sa->sin_addr;
1533 do {
1534 myaddr.sin_port = htons(port);
1535 err = kernel_bind(sock, (struct sockaddr *) &myaddr,
1536 sizeof(myaddr));
1537 if (port == 0)
1538 break;
1539 if (err == 0) {
1540 transport->srcport = port;
1541 break;
1542 }
1543 last = port;
1544 port = xs_next_srcport(transport, sock, port);
1545 if (port > last)
1546 nloop++;
1547 } while (err == -EADDRINUSE && nloop != 2);
1548 dprintk("RPC: %s %pI4:%u: %s (%d)\n",
1549 __func__, &myaddr.sin_addr,
1550 port, err ? "failed" : "ok", err);
1551 return err;
1552 }
1553
1554 static int xs_bind6(struct sock_xprt *transport, struct socket *sock)
1555 {
1556 struct sockaddr_in6 myaddr = {
1557 .sin6_family = AF_INET6,
1558 };
1559 struct sockaddr_in6 *sa;
1560 int err, nloop = 0;
1561 unsigned short port = xs_get_srcport(transport, sock);
1562 unsigned short last;
1563
1564 sa = (struct sockaddr_in6 *)&transport->srcaddr;
1565 myaddr.sin6_addr = sa->sin6_addr;
1566 do {
1567 myaddr.sin6_port = htons(port);
1568 err = kernel_bind(sock, (struct sockaddr *) &myaddr,
1569 sizeof(myaddr));
1570 if (port == 0)
1571 break;
1572 if (err == 0) {
1573 transport->srcport = port;
1574 break;
1575 }
1576 last = port;
1577 port = xs_next_srcport(transport, sock, port);
1578 if (port > last)
1579 nloop++;
1580 } while (err == -EADDRINUSE && nloop != 2);
1581 dprintk("RPC: xs_bind6 %pI6:%u: %s (%d)\n",
1582 &myaddr.sin6_addr, port, err ? "failed" : "ok", err);
1583 return err;
1584 }
1585
1586 #ifdef CONFIG_DEBUG_LOCK_ALLOC
1587 static struct lock_class_key xs_key[2];
1588 static struct lock_class_key xs_slock_key[2];
1589
1590 static inline void xs_reclassify_socket4(struct socket *sock)
1591 {
1592 struct sock *sk = sock->sk;
1593
1594 BUG_ON(sock_owned_by_user(sk));
1595 sock_lock_init_class_and_name(sk, "slock-AF_INET-RPC",
1596 &xs_slock_key[0], "sk_lock-AF_INET-RPC", &xs_key[0]);
1597 }
1598
1599 static inline void xs_reclassify_socket6(struct socket *sock)
1600 {
1601 struct sock *sk = sock->sk;
1602
1603 BUG_ON(sock_owned_by_user(sk));
1604 sock_lock_init_class_and_name(sk, "slock-AF_INET6-RPC",
1605 &xs_slock_key[1], "sk_lock-AF_INET6-RPC", &xs_key[1]);
1606 }
1607 #else
1608 static inline void xs_reclassify_socket4(struct socket *sock)
1609 {
1610 }
1611
1612 static inline void xs_reclassify_socket6(struct socket *sock)
1613 {
1614 }
1615 #endif
1616
1617 static void xs_udp_finish_connecting(struct rpc_xprt *xprt, struct socket *sock)
1618 {
1619 struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
1620
1621 if (!transport->inet) {
1622 struct sock *sk = sock->sk;
1623
1624 write_lock_bh(&sk->sk_callback_lock);
1625
1626 xs_save_old_callbacks(transport, sk);
1627
1628 sk->sk_user_data = xprt;
1629 sk->sk_data_ready = xs_udp_data_ready;
1630 sk->sk_write_space = xs_udp_write_space;
1631 sk->sk_error_report = xs_error_report;
1632 sk->sk_no_check = UDP_CSUM_NORCV;
1633 sk->sk_allocation = GFP_ATOMIC;
1634
1635 xprt_set_connected(xprt);
1636
1637 /* Reset to new socket */
1638 transport->sock = sock;
1639 transport->inet = sk;
1640
1641 write_unlock_bh(&sk->sk_callback_lock);
1642 }
1643 xs_udp_do_set_buffer_size(xprt);
1644 }
1645
1646 /**
1647 * xs_udp_connect_worker4 - set up a UDP socket
1648 * @work: RPC transport to connect
1649 *
1650 * Invoked by a work queue tasklet.
1651 */
1652 static void xs_udp_connect_worker4(struct work_struct *work)
1653 {
1654 struct sock_xprt *transport =
1655 container_of(work, struct sock_xprt, connect_worker.work);
1656 struct rpc_xprt *xprt = &transport->xprt;
1657 struct socket *sock = transport->sock;
1658 int err, status = -EIO;
1659
1660 if (xprt->shutdown)
1661 goto out;
1662
1663 /* Start by resetting any existing state */
1664 xs_reset_transport(transport);
1665
1666 err = sock_create_kern(PF_INET, SOCK_DGRAM, IPPROTO_UDP, &sock);
1667 if (err < 0) {
1668 dprintk("RPC: can't create UDP transport socket (%d).\n", -err);
1669 goto out;
1670 }
1671 xs_reclassify_socket4(sock);
1672
1673 if (xs_bind4(transport, sock)) {
1674 sock_release(sock);
1675 goto out;
1676 }
1677
1678 dprintk("RPC: worker connecting xprt %p via %s to "
1679 "%s (port %s)\n", xprt,
1680 xprt->address_strings[RPC_DISPLAY_PROTO],
1681 xprt->address_strings[RPC_DISPLAY_ADDR],
1682 xprt->address_strings[RPC_DISPLAY_PORT]);
1683
1684 xs_udp_finish_connecting(xprt, sock);
1685 status = 0;
1686 out:
1687 xprt_clear_connecting(xprt);
1688 xprt_wake_pending_tasks(xprt, status);
1689 }
1690
1691 /**
1692 * xs_udp_connect_worker6 - set up a UDP socket
1693 * @work: RPC transport to connect
1694 *
1695 * Invoked by a work queue tasklet.
1696 */
1697 static void xs_udp_connect_worker6(struct work_struct *work)
1698 {
1699 struct sock_xprt *transport =
1700 container_of(work, struct sock_xprt, connect_worker.work);
1701 struct rpc_xprt *xprt = &transport->xprt;
1702 struct socket *sock = transport->sock;
1703 int err, status = -EIO;
1704
1705 if (xprt->shutdown)
1706 goto out;
1707
1708 /* Start by resetting any existing state */
1709 xs_reset_transport(transport);
1710
1711 err = sock_create_kern(PF_INET6, SOCK_DGRAM, IPPROTO_UDP, &sock);
1712 if (err < 0) {
1713 dprintk("RPC: can't create UDP transport socket (%d).\n", -err);
1714 goto out;
1715 }
1716 xs_reclassify_socket6(sock);
1717
1718 if (xs_bind6(transport, sock) < 0) {
1719 sock_release(sock);
1720 goto out;
1721 }
1722
1723 dprintk("RPC: worker connecting xprt %p via %s to "
1724 "%s (port %s)\n", xprt,
1725 xprt->address_strings[RPC_DISPLAY_PROTO],
1726 xprt->address_strings[RPC_DISPLAY_ADDR],
1727 xprt->address_strings[RPC_DISPLAY_PORT]);
1728
1729 xs_udp_finish_connecting(xprt, sock);
1730 status = 0;
1731 out:
1732 xprt_clear_connecting(xprt);
1733 xprt_wake_pending_tasks(xprt, status);
1734 }
1735
1736 /*
1737 * We need to preserve the port number so the reply cache on the server can
1738 * find our cached RPC replies when we get around to reconnecting.
1739 */
1740 static void xs_abort_connection(struct rpc_xprt *xprt, struct sock_xprt *transport)
1741 {
1742 int result;
1743 struct sockaddr any;
1744
1745 dprintk("RPC: disconnecting xprt %p to reuse port\n", xprt);
1746
1747 /*
1748 * Disconnect the transport socket by doing a connect operation
1749 * with AF_UNSPEC. This should return immediately...
1750 */
1751 memset(&any, 0, sizeof(any));
1752 any.sa_family = AF_UNSPEC;
1753 result = kernel_connect(transport->sock, &any, sizeof(any), 0);
1754 if (!result)
1755 xs_sock_mark_closed(xprt);
1756 else
1757 dprintk("RPC: AF_UNSPEC connect return code %d\n",
1758 result);
1759 }
1760
1761 static void xs_tcp_reuse_connection(struct rpc_xprt *xprt, struct sock_xprt *transport)
1762 {
1763 unsigned int state = transport->inet->sk_state;
1764
1765 if (state == TCP_CLOSE && transport->sock->state == SS_UNCONNECTED) {
1766 /* we don't need to abort the connection if the socket
1767 * hasn't undergone a shutdown
1768 */
1769 if (transport->inet->sk_shutdown == 0)
1770 return;
1771 dprintk("RPC: %s: TCP_CLOSEd and sk_shutdown set to %d\n",
1772 __func__, transport->inet->sk_shutdown);
1773 }
1774 if ((1 << state) & (TCPF_ESTABLISHED|TCPF_SYN_SENT)) {
1775 /* we don't need to abort the connection if the socket
1776 * hasn't undergone a shutdown
1777 */
1778 if (transport->inet->sk_shutdown == 0)
1779 return;
1780 dprintk("RPC: %s: ESTABLISHED/SYN_SENT "
1781 "sk_shutdown set to %d\n",
1782 __func__, transport->inet->sk_shutdown);
1783 }
1784 xs_abort_connection(xprt, transport);
1785 }
1786
1787 static int xs_tcp_finish_connecting(struct rpc_xprt *xprt, struct socket *sock)
1788 {
1789 struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
1790
1791 if (!transport->inet) {
1792 struct sock *sk = sock->sk;
1793
1794 write_lock_bh(&sk->sk_callback_lock);
1795
1796 xs_save_old_callbacks(transport, sk);
1797
1798 sk->sk_user_data = xprt;
1799 sk->sk_data_ready = xs_tcp_data_ready;
1800 sk->sk_state_change = xs_tcp_state_change;
1801 sk->sk_write_space = xs_tcp_write_space;
1802 sk->sk_error_report = xs_error_report;
1803 sk->sk_allocation = GFP_ATOMIC;
1804
1805 /* socket options */
1806 sk->sk_userlocks |= SOCK_BINDPORT_LOCK;
1807 sock_reset_flag(sk, SOCK_LINGER);
1808 tcp_sk(sk)->linger2 = 0;
1809 tcp_sk(sk)->nonagle |= TCP_NAGLE_OFF;
1810
1811 xprt_clear_connected(xprt);
1812
1813 /* Reset to new socket */
1814 transport->sock = sock;
1815 transport->inet = sk;
1816
1817 write_unlock_bh(&sk->sk_callback_lock);
1818 }
1819
1820 if (!xprt_bound(xprt))
1821 return -ENOTCONN;
1822
1823 /* Tell the socket layer to start connecting... */
1824 xprt->stat.connect_count++;
1825 xprt->stat.connect_start = jiffies;
1826 return kernel_connect(sock, xs_addr(xprt), xprt->addrlen, O_NONBLOCK);
1827 }
1828
1829 /**
1830 * xs_tcp_setup_socket - create a TCP socket and connect to a remote endpoint
1831 * @xprt: RPC transport to connect
1832 * @transport: socket transport to connect
1833 * @create_sock: function to create a socket of the correct type
1834 *
1835 * Invoked by a work queue tasklet.
1836 */
1837 static void xs_tcp_setup_socket(struct rpc_xprt *xprt,
1838 struct sock_xprt *transport,
1839 struct socket *(*create_sock)(struct rpc_xprt *,
1840 struct sock_xprt *))
1841 {
1842 struct socket *sock = transport->sock;
1843 int status = -EIO;
1844
1845 if (xprt->shutdown)
1846 goto out;
1847
1848 if (!sock) {
1849 clear_bit(XPRT_CONNECTION_ABORT, &xprt->state);
1850 sock = create_sock(xprt, transport);
1851 if (IS_ERR(sock)) {
1852 status = PTR_ERR(sock);
1853 goto out;
1854 }
1855 } else {
1856 int abort_and_exit;
1857
1858 abort_and_exit = test_and_clear_bit(XPRT_CONNECTION_ABORT,
1859 &xprt->state);
1860 /* "close" the socket, preserving the local port */
1861 xs_tcp_reuse_connection(xprt, transport);
1862
1863 if (abort_and_exit)
1864 goto out_eagain;
1865 }
1866
1867 dprintk("RPC: worker connecting xprt %p via %s to "
1868 "%s (port %s)\n", xprt,
1869 xprt->address_strings[RPC_DISPLAY_PROTO],
1870 xprt->address_strings[RPC_DISPLAY_ADDR],
1871 xprt->address_strings[RPC_DISPLAY_PORT]);
1872
1873 status = xs_tcp_finish_connecting(xprt, sock);
1874 dprintk("RPC: %p connect status %d connected %d sock state %d\n",
1875 xprt, -status, xprt_connected(xprt),
1876 sock->sk->sk_state);
1877 switch (status) {
1878 default:
1879 printk("%s: connect returned unhandled error %d\n",
1880 __func__, status);
1881 case -EADDRNOTAVAIL:
1882 /* We're probably in TIME_WAIT. Get rid of existing socket,
1883 * and retry
1884 */
1885 set_bit(XPRT_CONNECTION_CLOSE, &xprt->state);
1886 xprt_force_disconnect(xprt);
1887 break;
1888 case -ECONNREFUSED:
1889 case -ECONNRESET:
1890 case -ENETUNREACH:
1891 /* retry with existing socket, after a delay */
1892 case 0:
1893 case -EINPROGRESS:
1894 case -EALREADY:
1895 xprt_clear_connecting(xprt);
1896 return;
1897 case -EINVAL:
1898 /* Happens, for instance, if the user specified a link
1899 * local IPv6 address without a scope-id.
1900 */
1901 goto out;
1902 }
1903 out_eagain:
1904 status = -EAGAIN;
1905 out:
1906 xprt_clear_connecting(xprt);
1907 xprt_wake_pending_tasks(xprt, status);
1908 }
1909
1910 static struct socket *xs_create_tcp_sock4(struct rpc_xprt *xprt,
1911 struct sock_xprt *transport)
1912 {
1913 struct socket *sock;
1914 int err;
1915
1916 /* start from scratch */
1917 err = sock_create_kern(PF_INET, SOCK_STREAM, IPPROTO_TCP, &sock);
1918 if (err < 0) {
1919 dprintk("RPC: can't create TCP transport socket (%d).\n",
1920 -err);
1921 goto out_err;
1922 }
1923 xs_reclassify_socket4(sock);
1924
1925 if (xs_bind4(transport, sock) < 0) {
1926 sock_release(sock);
1927 goto out_err;
1928 }
1929 return sock;
1930 out_err:
1931 return ERR_PTR(-EIO);
1932 }
1933
1934 /**
1935 * xs_tcp_connect_worker4 - connect a TCP socket to a remote endpoint
1936 * @work: RPC transport to connect
1937 *
1938 * Invoked by a work queue tasklet.
1939 */
1940 static void xs_tcp_connect_worker4(struct work_struct *work)
1941 {
1942 struct sock_xprt *transport =
1943 container_of(work, struct sock_xprt, connect_worker.work);
1944 struct rpc_xprt *xprt = &transport->xprt;
1945
1946 xs_tcp_setup_socket(xprt, transport, xs_create_tcp_sock4);
1947 }
1948
1949 static struct socket *xs_create_tcp_sock6(struct rpc_xprt *xprt,
1950 struct sock_xprt *transport)
1951 {
1952 struct socket *sock;
1953 int err;
1954
1955 /* start from scratch */
1956 err = sock_create_kern(PF_INET6, SOCK_STREAM, IPPROTO_TCP, &sock);
1957 if (err < 0) {
1958 dprintk("RPC: can't create TCP transport socket (%d).\n",
1959 -err);
1960 goto out_err;
1961 }
1962 xs_reclassify_socket6(sock);
1963
1964 if (xs_bind6(transport, sock) < 0) {
1965 sock_release(sock);
1966 goto out_err;
1967 }
1968 return sock;
1969 out_err:
1970 return ERR_PTR(-EIO);
1971 }
1972
1973 /**
1974 * xs_tcp_connect_worker6 - connect a TCP socket to a remote endpoint
1975 * @work: RPC transport to connect
1976 *
1977 * Invoked by a work queue tasklet.
1978 */
1979 static void xs_tcp_connect_worker6(struct work_struct *work)
1980 {
1981 struct sock_xprt *transport =
1982 container_of(work, struct sock_xprt, connect_worker.work);
1983 struct rpc_xprt *xprt = &transport->xprt;
1984
1985 xs_tcp_setup_socket(xprt, transport, xs_create_tcp_sock6);
1986 }
1987
1988 /**
1989 * xs_connect - connect a socket to a remote endpoint
1990 * @task: address of RPC task that manages state of connect request
1991 *
1992 * TCP: If the remote end dropped the connection, delay reconnecting.
1993 *
1994 * UDP socket connects are synchronous, but we use a work queue anyway
1995 * to guarantee that even unprivileged user processes can set up a
1996 * socket on a privileged port.
1997 *
1998 * If a UDP socket connect fails, the delay behavior here prevents
1999 * retry floods (hard mounts).
2000 */
2001 static void xs_connect(struct rpc_task *task)
2002 {
2003 struct rpc_xprt *xprt = task->tk_xprt;
2004 struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
2005
2006 if (transport->sock != NULL && !RPC_IS_SOFTCONN(task)) {
2007 dprintk("RPC: xs_connect delayed xprt %p for %lu "
2008 "seconds\n",
2009 xprt, xprt->reestablish_timeout / HZ);
2010 queue_delayed_work(rpciod_workqueue,
2011 &transport->connect_worker,
2012 xprt->reestablish_timeout);
2013 xprt->reestablish_timeout <<= 1;
2014 if (xprt->reestablish_timeout < XS_TCP_INIT_REEST_TO)
2015 xprt->reestablish_timeout = XS_TCP_INIT_REEST_TO;
2016 if (xprt->reestablish_timeout > XS_TCP_MAX_REEST_TO)
2017 xprt->reestablish_timeout = XS_TCP_MAX_REEST_TO;
2018 } else {
2019 dprintk("RPC: xs_connect scheduled xprt %p\n", xprt);
2020 queue_delayed_work(rpciod_workqueue,
2021 &transport->connect_worker, 0);
2022 }
2023 }
2024
2025 /**
2026 * xs_udp_print_stats - display UDP socket-specifc stats
2027 * @xprt: rpc_xprt struct containing statistics
2028 * @seq: output file
2029 *
2030 */
2031 static void xs_udp_print_stats(struct rpc_xprt *xprt, struct seq_file *seq)
2032 {
2033 struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
2034
2035 seq_printf(seq, "\txprt:\tudp %u %lu %lu %lu %lu %Lu %Lu\n",
2036 transport->srcport,
2037 xprt->stat.bind_count,
2038 xprt->stat.sends,
2039 xprt->stat.recvs,
2040 xprt->stat.bad_xids,
2041 xprt->stat.req_u,
2042 xprt->stat.bklog_u);
2043 }
2044
2045 /**
2046 * xs_tcp_print_stats - display TCP socket-specifc stats
2047 * @xprt: rpc_xprt struct containing statistics
2048 * @seq: output file
2049 *
2050 */
2051 static void xs_tcp_print_stats(struct rpc_xprt *xprt, struct seq_file *seq)
2052 {
2053 struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
2054 long idle_time = 0;
2055
2056 if (xprt_connected(xprt))
2057 idle_time = (long)(jiffies - xprt->last_used) / HZ;
2058
2059 seq_printf(seq, "\txprt:\ttcp %u %lu %lu %lu %ld %lu %lu %lu %Lu %Lu\n",
2060 transport->srcport,
2061 xprt->stat.bind_count,
2062 xprt->stat.connect_count,
2063 xprt->stat.connect_time,
2064 idle_time,
2065 xprt->stat.sends,
2066 xprt->stat.recvs,
2067 xprt->stat.bad_xids,
2068 xprt->stat.req_u,
2069 xprt->stat.bklog_u);
2070 }
2071
2072 /*
2073 * Allocate a bunch of pages for a scratch buffer for the rpc code. The reason
2074 * we allocate pages instead doing a kmalloc like rpc_malloc is because we want
2075 * to use the server side send routines.
2076 */
2077 static void *bc_malloc(struct rpc_task *task, size_t size)
2078 {
2079 struct page *page;
2080 struct rpc_buffer *buf;
2081
2082 BUG_ON(size > PAGE_SIZE - sizeof(struct rpc_buffer));
2083 page = alloc_page(GFP_KERNEL);
2084
2085 if (!page)
2086 return NULL;
2087
2088 buf = page_address(page);
2089 buf->len = PAGE_SIZE;
2090
2091 return buf->data;
2092 }
2093
2094 /*
2095 * Free the space allocated in the bc_alloc routine
2096 */
2097 static void bc_free(void *buffer)
2098 {
2099 struct rpc_buffer *buf;
2100
2101 if (!buffer)
2102 return;
2103
2104 buf = container_of(buffer, struct rpc_buffer, data);
2105 free_page((unsigned long)buf);
2106 }
2107
2108 /*
2109 * Use the svc_sock to send the callback. Must be called with svsk->sk_mutex
2110 * held. Borrows heavily from svc_tcp_sendto and xs_tcp_send_request.
2111 */
2112 static int bc_sendto(struct rpc_rqst *req)
2113 {
2114 int len;
2115 struct xdr_buf *xbufp = &req->rq_snd_buf;
2116 struct rpc_xprt *xprt = req->rq_xprt;
2117 struct sock_xprt *transport =
2118 container_of(xprt, struct sock_xprt, xprt);
2119 struct socket *sock = transport->sock;
2120 unsigned long headoff;
2121 unsigned long tailoff;
2122
2123 /*
2124 * Set up the rpc header and record marker stuff
2125 */
2126 xs_encode_tcp_record_marker(xbufp);
2127
2128 tailoff = (unsigned long)xbufp->tail[0].iov_base & ~PAGE_MASK;
2129 headoff = (unsigned long)xbufp->head[0].iov_base & ~PAGE_MASK;
2130 len = svc_send_common(sock, xbufp,
2131 virt_to_page(xbufp->head[0].iov_base), headoff,
2132 xbufp->tail[0].iov_base, tailoff);
2133
2134 if (len != xbufp->len) {
2135 printk(KERN_NOTICE "Error sending entire callback!\n");
2136 len = -EAGAIN;
2137 }
2138
2139 return len;
2140 }
2141
2142 /*
2143 * The send routine. Borrows from svc_send
2144 */
2145 static int bc_send_request(struct rpc_task *task)
2146 {
2147 struct rpc_rqst *req = task->tk_rqstp;
2148 struct svc_xprt *xprt;
2149 struct svc_sock *svsk;
2150 u32 len;
2151
2152 dprintk("sending request with xid: %08x\n", ntohl(req->rq_xid));
2153 /*
2154 * Get the server socket associated with this callback xprt
2155 */
2156 xprt = req->rq_xprt->bc_xprt;
2157 svsk = container_of(xprt, struct svc_sock, sk_xprt);
2158
2159 /*
2160 * Grab the mutex to serialize data as the connection is shared
2161 * with the fore channel
2162 */
2163 if (!mutex_trylock(&xprt->xpt_mutex)) {
2164 rpc_sleep_on(&xprt->xpt_bc_pending, task, NULL);
2165 if (!mutex_trylock(&xprt->xpt_mutex))
2166 return -EAGAIN;
2167 rpc_wake_up_queued_task(&xprt->xpt_bc_pending, task);
2168 }
2169 if (test_bit(XPT_DEAD, &xprt->xpt_flags))
2170 len = -ENOTCONN;
2171 else
2172 len = bc_sendto(req);
2173 mutex_unlock(&xprt->xpt_mutex);
2174
2175 if (len > 0)
2176 len = 0;
2177
2178 return len;
2179 }
2180
2181 /*
2182 * The close routine. Since this is client initiated, we do nothing
2183 */
2184
2185 static void bc_close(struct rpc_xprt *xprt)
2186 {
2187 }
2188
2189 /*
2190 * The xprt destroy routine. Again, because this connection is client
2191 * initiated, we do nothing
2192 */
2193
2194 static void bc_destroy(struct rpc_xprt *xprt)
2195 {
2196 }
2197
2198 static struct rpc_xprt_ops xs_udp_ops = {
2199 .set_buffer_size = xs_udp_set_buffer_size,
2200 .reserve_xprt = xprt_reserve_xprt_cong,
2201 .release_xprt = xprt_release_xprt_cong,
2202 .rpcbind = rpcb_getport_async,
2203 .set_port = xs_set_port,
2204 .connect = xs_connect,
2205 .buf_alloc = rpc_malloc,
2206 .buf_free = rpc_free,
2207 .send_request = xs_udp_send_request,
2208 .set_retrans_timeout = xprt_set_retrans_timeout_rtt,
2209 .timer = xs_udp_timer,
2210 .release_request = xprt_release_rqst_cong,
2211 .close = xs_close,
2212 .destroy = xs_destroy,
2213 .print_stats = xs_udp_print_stats,
2214 };
2215
2216 static struct rpc_xprt_ops xs_tcp_ops = {
2217 .reserve_xprt = xprt_reserve_xprt,
2218 .release_xprt = xs_tcp_release_xprt,
2219 .rpcbind = rpcb_getport_async,
2220 .set_port = xs_set_port,
2221 .connect = xs_connect,
2222 .buf_alloc = rpc_malloc,
2223 .buf_free = rpc_free,
2224 .send_request = xs_tcp_send_request,
2225 .set_retrans_timeout = xprt_set_retrans_timeout_def,
2226 .close = xs_tcp_close,
2227 .destroy = xs_destroy,
2228 .print_stats = xs_tcp_print_stats,
2229 };
2230
2231 /*
2232 * The rpc_xprt_ops for the server backchannel
2233 */
2234
2235 static struct rpc_xprt_ops bc_tcp_ops = {
2236 .reserve_xprt = xprt_reserve_xprt,
2237 .release_xprt = xprt_release_xprt,
2238 .buf_alloc = bc_malloc,
2239 .buf_free = bc_free,
2240 .send_request = bc_send_request,
2241 .set_retrans_timeout = xprt_set_retrans_timeout_def,
2242 .close = bc_close,
2243 .destroy = bc_destroy,
2244 .print_stats = xs_tcp_print_stats,
2245 };
2246
2247 static struct rpc_xprt *xs_setup_xprt(struct xprt_create *args,
2248 unsigned int slot_table_size)
2249 {
2250 struct rpc_xprt *xprt;
2251 struct sock_xprt *new;
2252
2253 if (args->addrlen > sizeof(xprt->addr)) {
2254 dprintk("RPC: xs_setup_xprt: address too large\n");
2255 return ERR_PTR(-EBADF);
2256 }
2257
2258 new = kzalloc(sizeof(*new), GFP_KERNEL);
2259 if (new == NULL) {
2260 dprintk("RPC: xs_setup_xprt: couldn't allocate "
2261 "rpc_xprt\n");
2262 return ERR_PTR(-ENOMEM);
2263 }
2264 xprt = &new->xprt;
2265
2266 xprt->max_reqs = slot_table_size;
2267 xprt->slot = kcalloc(xprt->max_reqs, sizeof(struct rpc_rqst), GFP_KERNEL);
2268 if (xprt->slot == NULL) {
2269 kfree(xprt);
2270 dprintk("RPC: xs_setup_xprt: couldn't allocate slot "
2271 "table\n");
2272 return ERR_PTR(-ENOMEM);
2273 }
2274
2275 memcpy(&xprt->addr, args->dstaddr, args->addrlen);
2276 xprt->addrlen = args->addrlen;
2277 if (args->srcaddr)
2278 memcpy(&new->srcaddr, args->srcaddr, args->addrlen);
2279
2280 return xprt;
2281 }
2282
2283 static const struct rpc_timeout xs_udp_default_timeout = {
2284 .to_initval = 5 * HZ,
2285 .to_maxval = 30 * HZ,
2286 .to_increment = 5 * HZ,
2287 .to_retries = 5,
2288 };
2289
2290 /**
2291 * xs_setup_udp - Set up transport to use a UDP socket
2292 * @args: rpc transport creation arguments
2293 *
2294 */
2295 static struct rpc_xprt *xs_setup_udp(struct xprt_create *args)
2296 {
2297 struct sockaddr *addr = args->dstaddr;
2298 struct rpc_xprt *xprt;
2299 struct sock_xprt *transport;
2300 struct rpc_xprt *ret;
2301
2302 xprt = xs_setup_xprt(args, xprt_udp_slot_table_entries);
2303 if (IS_ERR(xprt))
2304 return xprt;
2305 transport = container_of(xprt, struct sock_xprt, xprt);
2306
2307 xprt->prot = IPPROTO_UDP;
2308 xprt->tsh_size = 0;
2309 xprt->max_payload = (1U << 16) - (MAX_HEADER << 3);
2310
2311 xprt->bind_timeout = XS_BIND_TO;
2312 xprt->reestablish_timeout = XS_UDP_REEST_TO;
2313 xprt->idle_timeout = XS_IDLE_DISC_TO;
2314
2315 xprt->ops = &xs_udp_ops;
2316
2317 xprt->timeout = &xs_udp_default_timeout;
2318
2319 switch (addr->sa_family) {
2320 case AF_INET:
2321 if (((struct sockaddr_in *)addr)->sin_port != htons(0))
2322 xprt_set_bound(xprt);
2323
2324 INIT_DELAYED_WORK(&transport->connect_worker,
2325 xs_udp_connect_worker4);
2326 xs_format_peer_addresses(xprt, "udp", RPCBIND_NETID_UDP);
2327 break;
2328 case AF_INET6:
2329 if (((struct sockaddr_in6 *)addr)->sin6_port != htons(0))
2330 xprt_set_bound(xprt);
2331
2332 INIT_DELAYED_WORK(&transport->connect_worker,
2333 xs_udp_connect_worker6);
2334 xs_format_peer_addresses(xprt, "udp", RPCBIND_NETID_UDP6);
2335 break;
2336 default:
2337 ret = ERR_PTR(-EAFNOSUPPORT);
2338 goto out_err;
2339 }
2340
2341 if (xprt_bound(xprt))
2342 dprintk("RPC: set up xprt to %s (port %s) via %s\n",
2343 xprt->address_strings[RPC_DISPLAY_ADDR],
2344 xprt->address_strings[RPC_DISPLAY_PORT],
2345 xprt->address_strings[RPC_DISPLAY_PROTO]);
2346 else
2347 dprintk("RPC: set up xprt to %s (autobind) via %s\n",
2348 xprt->address_strings[RPC_DISPLAY_ADDR],
2349 xprt->address_strings[RPC_DISPLAY_PROTO]);
2350
2351 if (try_module_get(THIS_MODULE))
2352 return xprt;
2353 ret = ERR_PTR(-EINVAL);
2354 out_err:
2355 kfree(xprt->slot);
2356 kfree(xprt);
2357 return ret;
2358 }
2359
2360 static const struct rpc_timeout xs_tcp_default_timeout = {
2361 .to_initval = 60 * HZ,
2362 .to_maxval = 60 * HZ,
2363 .to_retries = 2,
2364 };
2365
2366 /**
2367 * xs_setup_tcp - Set up transport to use a TCP socket
2368 * @args: rpc transport creation arguments
2369 *
2370 */
2371 static struct rpc_xprt *xs_setup_tcp(struct xprt_create *args)
2372 {
2373 struct sockaddr *addr = args->dstaddr;
2374 struct rpc_xprt *xprt;
2375 struct sock_xprt *transport;
2376 struct rpc_xprt *ret;
2377
2378 xprt = xs_setup_xprt(args, xprt_tcp_slot_table_entries);
2379 if (IS_ERR(xprt))
2380 return xprt;
2381 transport = container_of(xprt, struct sock_xprt, xprt);
2382
2383 xprt->prot = IPPROTO_TCP;
2384 xprt->tsh_size = sizeof(rpc_fraghdr) / sizeof(u32);
2385 xprt->max_payload = RPC_MAX_FRAGMENT_SIZE;
2386
2387 xprt->bind_timeout = XS_BIND_TO;
2388 xprt->reestablish_timeout = XS_TCP_INIT_REEST_TO;
2389 xprt->idle_timeout = XS_IDLE_DISC_TO;
2390
2391 xprt->ops = &xs_tcp_ops;
2392 xprt->timeout = &xs_tcp_default_timeout;
2393
2394 switch (addr->sa_family) {
2395 case AF_INET:
2396 if (((struct sockaddr_in *)addr)->sin_port != htons(0))
2397 xprt_set_bound(xprt);
2398
2399 INIT_DELAYED_WORK(&transport->connect_worker,
2400 xs_tcp_connect_worker4);
2401 xs_format_peer_addresses(xprt, "tcp", RPCBIND_NETID_TCP);
2402 break;
2403 case AF_INET6:
2404 if (((struct sockaddr_in6 *)addr)->sin6_port != htons(0))
2405 xprt_set_bound(xprt);
2406
2407 INIT_DELAYED_WORK(&transport->connect_worker,
2408 xs_tcp_connect_worker6);
2409 xs_format_peer_addresses(xprt, "tcp", RPCBIND_NETID_TCP6);
2410 break;
2411 default:
2412 ret = ERR_PTR(-EAFNOSUPPORT);
2413 goto out_err;
2414 }
2415
2416 if (xprt_bound(xprt))
2417 dprintk("RPC: set up xprt to %s (port %s) via %s\n",
2418 xprt->address_strings[RPC_DISPLAY_ADDR],
2419 xprt->address_strings[RPC_DISPLAY_PORT],
2420 xprt->address_strings[RPC_DISPLAY_PROTO]);
2421 else
2422 dprintk("RPC: set up xprt to %s (autobind) via %s\n",
2423 xprt->address_strings[RPC_DISPLAY_ADDR],
2424 xprt->address_strings[RPC_DISPLAY_PROTO]);
2425
2426
2427 if (try_module_get(THIS_MODULE))
2428 return xprt;
2429 ret = ERR_PTR(-EINVAL);
2430 out_err:
2431 kfree(xprt->slot);
2432 kfree(xprt);
2433 return ret;
2434 }
2435
2436 /**
2437 * xs_setup_bc_tcp - Set up transport to use a TCP backchannel socket
2438 * @args: rpc transport creation arguments
2439 *
2440 */
2441 static struct rpc_xprt *xs_setup_bc_tcp(struct xprt_create *args)
2442 {
2443 struct sockaddr *addr = args->dstaddr;
2444 struct rpc_xprt *xprt;
2445 struct sock_xprt *transport;
2446 struct svc_sock *bc_sock;
2447 struct rpc_xprt *ret;
2448
2449 xprt = xs_setup_xprt(args, xprt_tcp_slot_table_entries);
2450 if (IS_ERR(xprt))
2451 return xprt;
2452 transport = container_of(xprt, struct sock_xprt, xprt);
2453
2454 xprt->prot = IPPROTO_TCP;
2455 xprt->tsh_size = sizeof(rpc_fraghdr) / sizeof(u32);
2456 xprt->max_payload = RPC_MAX_FRAGMENT_SIZE;
2457 xprt->timeout = &xs_tcp_default_timeout;
2458
2459 /* backchannel */
2460 xprt_set_bound(xprt);
2461 xprt->bind_timeout = 0;
2462 xprt->reestablish_timeout = 0;
2463 xprt->idle_timeout = 0;
2464
2465 /*
2466 * The backchannel uses the same socket connection as the
2467 * forechannel
2468 */
2469 xprt->bc_xprt = args->bc_xprt;
2470 bc_sock = container_of(args->bc_xprt, struct svc_sock, sk_xprt);
2471 bc_sock->sk_bc_xprt = xprt;
2472 transport->sock = bc_sock->sk_sock;
2473 transport->inet = bc_sock->sk_sk;
2474
2475 xprt->ops = &bc_tcp_ops;
2476
2477 switch (addr->sa_family) {
2478 case AF_INET:
2479 xs_format_peer_addresses(xprt, "tcp",
2480 RPCBIND_NETID_TCP);
2481 break;
2482 case AF_INET6:
2483 xs_format_peer_addresses(xprt, "tcp",
2484 RPCBIND_NETID_TCP6);
2485 break;
2486 default:
2487 ret = ERR_PTR(-EAFNOSUPPORT);
2488 goto out_err;
2489 }
2490
2491 if (xprt_bound(xprt))
2492 dprintk("RPC: set up xprt to %s (port %s) via %s\n",
2493 xprt->address_strings[RPC_DISPLAY_ADDR],
2494 xprt->address_strings[RPC_DISPLAY_PORT],
2495 xprt->address_strings[RPC_DISPLAY_PROTO]);
2496 else
2497 dprintk("RPC: set up xprt to %s (autobind) via %s\n",
2498 xprt->address_strings[RPC_DISPLAY_ADDR],
2499 xprt->address_strings[RPC_DISPLAY_PROTO]);
2500
2501 /*
2502 * Since we don't want connections for the backchannel, we set
2503 * the xprt status to connected
2504 */
2505 xprt_set_connected(xprt);
2506
2507
2508 if (try_module_get(THIS_MODULE))
2509 return xprt;
2510 ret = ERR_PTR(-EINVAL);
2511 out_err:
2512 kfree(xprt->slot);
2513 kfree(xprt);
2514 return ret;
2515 }
2516
2517 static struct xprt_class xs_udp_transport = {
2518 .list = LIST_HEAD_INIT(xs_udp_transport.list),
2519 .name = "udp",
2520 .owner = THIS_MODULE,
2521 .ident = XPRT_TRANSPORT_UDP,
2522 .setup = xs_setup_udp,
2523 };
2524
2525 static struct xprt_class xs_tcp_transport = {
2526 .list = LIST_HEAD_INIT(xs_tcp_transport.list),
2527 .name = "tcp",
2528 .owner = THIS_MODULE,
2529 .ident = XPRT_TRANSPORT_TCP,
2530 .setup = xs_setup_tcp,
2531 };
2532
2533 static struct xprt_class xs_bc_tcp_transport = {
2534 .list = LIST_HEAD_INIT(xs_bc_tcp_transport.list),
2535 .name = "tcp NFSv4.1 backchannel",
2536 .owner = THIS_MODULE,
2537 .ident = XPRT_TRANSPORT_BC_TCP,
2538 .setup = xs_setup_bc_tcp,
2539 };
2540
2541 /**
2542 * init_socket_xprt - set up xprtsock's sysctls, register with RPC client
2543 *
2544 */
2545 int init_socket_xprt(void)
2546 {
2547 #ifdef RPC_DEBUG
2548 if (!sunrpc_table_header)
2549 sunrpc_table_header = register_sysctl_table(sunrpc_table);
2550 #endif
2551
2552 xprt_register_transport(&xs_udp_transport);
2553 xprt_register_transport(&xs_tcp_transport);
2554 xprt_register_transport(&xs_bc_tcp_transport);
2555
2556 return 0;
2557 }
2558
2559 /**
2560 * cleanup_socket_xprt - remove xprtsock's sysctls, unregister
2561 *
2562 */
2563 void cleanup_socket_xprt(void)
2564 {
2565 #ifdef RPC_DEBUG
2566 if (sunrpc_table_header) {
2567 unregister_sysctl_table(sunrpc_table_header);
2568 sunrpc_table_header = NULL;
2569 }
2570 #endif
2571
2572 xprt_unregister_transport(&xs_udp_transport);
2573 xprt_unregister_transport(&xs_tcp_transport);
2574 xprt_unregister_transport(&xs_bc_tcp_transport);
2575 }
2576
2577 static int param_set_uint_minmax(const char *val,
2578 const struct kernel_param *kp,
2579 unsigned int min, unsigned int max)
2580 {
2581 unsigned long num;
2582 int ret;
2583
2584 if (!val)
2585 return -EINVAL;
2586 ret = strict_strtoul(val, 0, &num);
2587 if (ret == -EINVAL || num < min || num > max)
2588 return -EINVAL;
2589 *((unsigned int *)kp->arg) = num;
2590 return 0;
2591 }
2592
2593 static int param_set_portnr(const char *val, const struct kernel_param *kp)
2594 {
2595 return param_set_uint_minmax(val, kp,
2596 RPC_MIN_RESVPORT,
2597 RPC_MAX_RESVPORT);
2598 }
2599
2600 static struct kernel_param_ops param_ops_portnr = {
2601 .set = param_set_portnr,
2602 .get = param_get_uint,
2603 };
2604
2605 #define param_check_portnr(name, p) \
2606 __param_check(name, p, unsigned int);
2607
2608 module_param_named(min_resvport, xprt_min_resvport, portnr, 0644);
2609 module_param_named(max_resvport, xprt_max_resvport, portnr, 0644);
2610
2611 static int param_set_slot_table_size(const char *val,
2612 const struct kernel_param *kp)
2613 {
2614 return param_set_uint_minmax(val, kp,
2615 RPC_MIN_SLOT_TABLE,
2616 RPC_MAX_SLOT_TABLE);
2617 }
2618
2619 static struct kernel_param_ops param_ops_slot_table_size = {
2620 .set = param_set_slot_table_size,
2621 .get = param_get_uint,
2622 };
2623
2624 #define param_check_slot_table_size(name, p) \
2625 __param_check(name, p, unsigned int);
2626
2627 module_param_named(tcp_slot_table_entries, xprt_tcp_slot_table_entries,
2628 slot_table_size, 0644);
2629 module_param_named(udp_slot_table_entries, xprt_udp_slot_table_entries,
2630 slot_table_size, 0644);
Tomato firmware and modifications.