aboutsummaryrefslogtreecommitdiffstats
path: root/net/sunrpc/xprtsock.c
diff options
context:
space:
mode:
Diffstat (limited to 'net/sunrpc/xprtsock.c')
-rw-r--r--net/sunrpc/xprtsock.c961
1 files changed, 630 insertions, 331 deletions
diff --git a/net/sunrpc/xprtsock.c b/net/sunrpc/xprtsock.c
index 5cbb404c4cdf..62438f3a914d 100644
--- a/net/sunrpc/xprtsock.c
+++ b/net/sunrpc/xprtsock.c
@@ -34,6 +34,9 @@
34#include <linux/sunrpc/sched.h> 34#include <linux/sunrpc/sched.h>
35#include <linux/sunrpc/xprtsock.h> 35#include <linux/sunrpc/xprtsock.h>
36#include <linux/file.h> 36#include <linux/file.h>
37#ifdef CONFIG_NFS_V4_1
38#include <linux/sunrpc/bc_xprt.h>
39#endif
37 40
38#include <net/sock.h> 41#include <net/sock.h>
39#include <net/checksum.h> 42#include <net/checksum.h>
@@ -49,6 +52,9 @@ unsigned int xprt_tcp_slot_table_entries = RPC_DEF_SLOT_TABLE;
49unsigned int xprt_min_resvport = RPC_DEF_MIN_RESVPORT; 52unsigned int xprt_min_resvport = RPC_DEF_MIN_RESVPORT;
50unsigned int xprt_max_resvport = RPC_DEF_MAX_RESVPORT; 53unsigned int xprt_max_resvport = RPC_DEF_MAX_RESVPORT;
51 54
55#define XS_TCP_LINGER_TO (15U * HZ)
56static unsigned int xs_tcp_fin_timeout __read_mostly = XS_TCP_LINGER_TO;
57
52/* 58/*
53 * We can register our own files under /proc/sys/sunrpc by 59 * We can register our own files under /proc/sys/sunrpc by
54 * calling register_sysctl_table() again. The files in that 60 * calling register_sysctl_table() again. The files in that
@@ -117,6 +123,14 @@ static ctl_table xs_tunables_table[] = {
117 .extra2 = &xprt_max_resvport_limit 123 .extra2 = &xprt_max_resvport_limit
118 }, 124 },
119 { 125 {
126 .procname = "tcp_fin_timeout",
127 .data = &xs_tcp_fin_timeout,
128 .maxlen = sizeof(xs_tcp_fin_timeout),
129 .mode = 0644,
130 .proc_handler = &proc_dointvec_jiffies,
131 .strategy = sysctl_jiffies
132 },
133 {
120 .ctl_name = 0, 134 .ctl_name = 0,
121 }, 135 },
122}; 136};
@@ -234,8 +248,8 @@ struct sock_xprt {
234 * Connection of transports 248 * Connection of transports
235 */ 249 */
236 struct delayed_work connect_worker; 250 struct delayed_work connect_worker;
237 struct sockaddr_storage addr; 251 struct sockaddr_storage srcaddr;
238 unsigned short port; 252 unsigned short srcport;
239 253
240 /* 254 /*
241 * UDP socket buffer size parameters 255 * UDP socket buffer size parameters
@@ -259,6 +273,13 @@ struct sock_xprt {
259#define TCP_RCV_COPY_FRAGHDR (1UL << 1) 273#define TCP_RCV_COPY_FRAGHDR (1UL << 1)
260#define TCP_RCV_COPY_XID (1UL << 2) 274#define TCP_RCV_COPY_XID (1UL << 2)
261#define TCP_RCV_COPY_DATA (1UL << 3) 275#define TCP_RCV_COPY_DATA (1UL << 3)
276#define TCP_RCV_READ_CALLDIR (1UL << 4)
277#define TCP_RCV_COPY_CALLDIR (1UL << 5)
278
279/*
280 * TCP RPC flags
281 */
282#define TCP_RPC_REPLY (1UL << 6)
262 283
263static inline struct sockaddr *xs_addr(struct rpc_xprt *xprt) 284static inline struct sockaddr *xs_addr(struct rpc_xprt *xprt)
264{ 285{
@@ -275,117 +296,60 @@ static inline struct sockaddr_in6 *xs_addr_in6(struct rpc_xprt *xprt)
275 return (struct sockaddr_in6 *) &xprt->addr; 296 return (struct sockaddr_in6 *) &xprt->addr;
276} 297}
277 298
278static void xs_format_ipv4_peer_addresses(struct rpc_xprt *xprt, 299static void xs_format_common_peer_addresses(struct rpc_xprt *xprt)
279 const char *protocol,
280 const char *netid)
281{ 300{
282 struct sockaddr_in *addr = xs_addr_in(xprt); 301 struct sockaddr *sap = xs_addr(xprt);
283 char *buf; 302 struct sockaddr_in6 *sin6;
284 303 struct sockaddr_in *sin;
285 buf = kzalloc(20, GFP_KERNEL); 304 char buf[128];
286 if (buf) {
287 snprintf(buf, 20, "%pI4", &addr->sin_addr.s_addr);
288 }
289 xprt->address_strings[RPC_DISPLAY_ADDR] = buf;
290 305
291 buf = kzalloc(8, GFP_KERNEL); 306 (void)rpc_ntop(sap, buf, sizeof(buf));
292 if (buf) { 307 xprt->address_strings[RPC_DISPLAY_ADDR] = kstrdup(buf, GFP_KERNEL);
293 snprintf(buf, 8, "%u",
294 ntohs(addr->sin_port));
295 }
296 xprt->address_strings[RPC_DISPLAY_PORT] = buf;
297
298 xprt->address_strings[RPC_DISPLAY_PROTO] = protocol;
299 308
300 buf = kzalloc(48, GFP_KERNEL); 309 switch (sap->sa_family) {
301 if (buf) { 310 case AF_INET:
302 snprintf(buf, 48, "addr=%pI4 port=%u proto=%s", 311 sin = xs_addr_in(xprt);
303 &addr->sin_addr.s_addr, 312 (void)snprintf(buf, sizeof(buf), "%02x%02x%02x%02x",
304 ntohs(addr->sin_port), 313 NIPQUAD(sin->sin_addr.s_addr));
305 protocol); 314 break;
306 } 315 case AF_INET6:
307 xprt->address_strings[RPC_DISPLAY_ALL] = buf; 316 sin6 = xs_addr_in6(xprt);
308 317 (void)snprintf(buf, sizeof(buf), "%pi6", &sin6->sin6_addr);
309 buf = kzalloc(10, GFP_KERNEL); 318 break;
310 if (buf) { 319 default:
311 snprintf(buf, 10, "%02x%02x%02x%02x", 320 BUG();
312 NIPQUAD(addr->sin_addr.s_addr));
313 }
314 xprt->address_strings[RPC_DISPLAY_HEX_ADDR] = buf;
315
316 buf = kzalloc(8, GFP_KERNEL);
317 if (buf) {
318 snprintf(buf, 8, "%4hx",
319 ntohs(addr->sin_port));
320 }
321 xprt->address_strings[RPC_DISPLAY_HEX_PORT] = buf;
322
323 buf = kzalloc(30, GFP_KERNEL);
324 if (buf) {
325 snprintf(buf, 30, "%pI4.%u.%u",
326 &addr->sin_addr.s_addr,
327 ntohs(addr->sin_port) >> 8,
328 ntohs(addr->sin_port) & 0xff);
329 } 321 }
330 xprt->address_strings[RPC_DISPLAY_UNIVERSAL_ADDR] = buf; 322 xprt->address_strings[RPC_DISPLAY_HEX_ADDR] = kstrdup(buf, GFP_KERNEL);
331
332 xprt->address_strings[RPC_DISPLAY_NETID] = netid;
333} 323}
334 324
335static void xs_format_ipv6_peer_addresses(struct rpc_xprt *xprt, 325static void xs_format_common_peer_ports(struct rpc_xprt *xprt)
336 const char *protocol,
337 const char *netid)
338{ 326{
339 struct sockaddr_in6 *addr = xs_addr_in6(xprt); 327 struct sockaddr *sap = xs_addr(xprt);
340 char *buf; 328 char buf[128];
341 329
342 buf = kzalloc(40, GFP_KERNEL); 330 (void)snprintf(buf, sizeof(buf), "%u", rpc_get_port(sap));
343 if (buf) { 331 xprt->address_strings[RPC_DISPLAY_PORT] = kstrdup(buf, GFP_KERNEL);
344 snprintf(buf, 40, "%pI6",&addr->sin6_addr);
345 }
346 xprt->address_strings[RPC_DISPLAY_ADDR] = buf;
347 332
348 buf = kzalloc(8, GFP_KERNEL); 333 (void)snprintf(buf, sizeof(buf), "%4hx", rpc_get_port(sap));
349 if (buf) { 334 xprt->address_strings[RPC_DISPLAY_HEX_PORT] = kstrdup(buf, GFP_KERNEL);
350 snprintf(buf, 8, "%u", 335}
351 ntohs(addr->sin6_port));
352 }
353 xprt->address_strings[RPC_DISPLAY_PORT] = buf;
354 336
337static void xs_format_peer_addresses(struct rpc_xprt *xprt,
338 const char *protocol,
339 const char *netid)
340{
355 xprt->address_strings[RPC_DISPLAY_PROTO] = protocol; 341 xprt->address_strings[RPC_DISPLAY_PROTO] = protocol;
342 xprt->address_strings[RPC_DISPLAY_NETID] = netid;
343 xs_format_common_peer_addresses(xprt);
344 xs_format_common_peer_ports(xprt);
345}
356 346
357 buf = kzalloc(64, GFP_KERNEL); 347static void xs_update_peer_port(struct rpc_xprt *xprt)
358 if (buf) { 348{
359 snprintf(buf, 64, "addr=%pI6 port=%u proto=%s", 349 kfree(xprt->address_strings[RPC_DISPLAY_HEX_PORT]);
360 &addr->sin6_addr, 350 kfree(xprt->address_strings[RPC_DISPLAY_PORT]);
361 ntohs(addr->sin6_port),
362 protocol);
363 }
364 xprt->address_strings[RPC_DISPLAY_ALL] = buf;
365
366 buf = kzalloc(36, GFP_KERNEL);
367 if (buf)
368 snprintf(buf, 36, "%pi6", &addr->sin6_addr);
369
370 xprt->address_strings[RPC_DISPLAY_HEX_ADDR] = buf;
371
372 buf = kzalloc(8, GFP_KERNEL);
373 if (buf) {
374 snprintf(buf, 8, "%4hx",
375 ntohs(addr->sin6_port));
376 }
377 xprt->address_strings[RPC_DISPLAY_HEX_PORT] = buf;
378
379 buf = kzalloc(50, GFP_KERNEL);
380 if (buf) {
381 snprintf(buf, 50, "%pI6.%u.%u",
382 &addr->sin6_addr,
383 ntohs(addr->sin6_port) >> 8,
384 ntohs(addr->sin6_port) & 0xff);
385 }
386 xprt->address_strings[RPC_DISPLAY_UNIVERSAL_ADDR] = buf;
387 351
388 xprt->address_strings[RPC_DISPLAY_NETID] = netid; 352 xs_format_common_peer_ports(xprt);
389} 353}
390 354
391static void xs_free_peer_addresses(struct rpc_xprt *xprt) 355static void xs_free_peer_addresses(struct rpc_xprt *xprt)
@@ -467,7 +431,7 @@ static int xs_sendpages(struct socket *sock, struct sockaddr *addr, int addrlen,
467 int err, sent = 0; 431 int err, sent = 0;
468 432
469 if (unlikely(!sock)) 433 if (unlikely(!sock))
470 return -ENOTCONN; 434 return -ENOTSOCK;
471 435
472 clear_bit(SOCK_ASYNC_NOSPACE, &sock->flags); 436 clear_bit(SOCK_ASYNC_NOSPACE, &sock->flags);
473 if (base != 0) { 437 if (base != 0) {
@@ -521,11 +485,12 @@ static void xs_nospace_callback(struct rpc_task *task)
521 * @task: task to put to sleep 485 * @task: task to put to sleep
522 * 486 *
523 */ 487 */
524static void xs_nospace(struct rpc_task *task) 488static int xs_nospace(struct rpc_task *task)
525{ 489{
526 struct rpc_rqst *req = task->tk_rqstp; 490 struct rpc_rqst *req = task->tk_rqstp;
527 struct rpc_xprt *xprt = req->rq_xprt; 491 struct rpc_xprt *xprt = req->rq_xprt;
528 struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt); 492 struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
493 int ret = 0;
529 494
530 dprintk("RPC: %5u xmit incomplete (%u left of %u)\n", 495 dprintk("RPC: %5u xmit incomplete (%u left of %u)\n",
531 task->tk_pid, req->rq_slen - req->rq_bytes_sent, 496 task->tk_pid, req->rq_slen - req->rq_bytes_sent,
@@ -537,6 +502,7 @@ static void xs_nospace(struct rpc_task *task)
537 /* Don't race with disconnect */ 502 /* Don't race with disconnect */
538 if (xprt_connected(xprt)) { 503 if (xprt_connected(xprt)) {
539 if (test_bit(SOCK_ASYNC_NOSPACE, &transport->sock->flags)) { 504 if (test_bit(SOCK_ASYNC_NOSPACE, &transport->sock->flags)) {
505 ret = -EAGAIN;
540 /* 506 /*
541 * Notify TCP that we're limited by the application 507 * Notify TCP that we're limited by the application
542 * window size 508 * window size
@@ -548,10 +514,11 @@ static void xs_nospace(struct rpc_task *task)
548 } 514 }
549 } else { 515 } else {
550 clear_bit(SOCK_ASYNC_NOSPACE, &transport->sock->flags); 516 clear_bit(SOCK_ASYNC_NOSPACE, &transport->sock->flags);
551 task->tk_status = -ENOTCONN; 517 ret = -ENOTCONN;
552 } 518 }
553 519
554 spin_unlock_bh(&xprt->transport_lock); 520 spin_unlock_bh(&xprt->transport_lock);
521 return ret;
555} 522}
556 523
557/** 524/**
@@ -577,6 +544,8 @@ static int xs_udp_send_request(struct rpc_task *task)
577 req->rq_svec->iov_base, 544 req->rq_svec->iov_base,
578 req->rq_svec->iov_len); 545 req->rq_svec->iov_len);
579 546
547 if (!xprt_bound(xprt))
548 return -ENOTCONN;
580 status = xs_sendpages(transport->sock, 549 status = xs_sendpages(transport->sock,
581 xs_addr(xprt), 550 xs_addr(xprt),
582 xprt->addrlen, xdr, 551 xprt->addrlen, xdr,
@@ -592,24 +561,28 @@ static int xs_udp_send_request(struct rpc_task *task)
592 /* Still some bytes left; set up for a retry later. */ 561 /* Still some bytes left; set up for a retry later. */
593 status = -EAGAIN; 562 status = -EAGAIN;
594 } 563 }
564 if (!transport->sock)
565 goto out;
595 566
596 switch (status) { 567 switch (status) {
568 case -ENOTSOCK:
569 status = -ENOTCONN;
570 /* Should we call xs_close() here? */
571 break;
597 case -EAGAIN: 572 case -EAGAIN:
598 xs_nospace(task); 573 status = xs_nospace(task);
599 break; 574 break;
575 default:
576 dprintk("RPC: sendmsg returned unrecognized error %d\n",
577 -status);
600 case -ENETUNREACH: 578 case -ENETUNREACH:
601 case -EPIPE: 579 case -EPIPE:
602 case -ECONNREFUSED: 580 case -ECONNREFUSED:
603 /* When the server has died, an ICMP port unreachable message 581 /* When the server has died, an ICMP port unreachable message
604 * prompts ECONNREFUSED. */ 582 * prompts ECONNREFUSED. */
605 clear_bit(SOCK_ASYNC_NOSPACE, &transport->sock->flags); 583 clear_bit(SOCK_ASYNC_NOSPACE, &transport->sock->flags);
606 break;
607 default:
608 clear_bit(SOCK_ASYNC_NOSPACE, &transport->sock->flags);
609 dprintk("RPC: sendmsg returned unrecognized error %d\n",
610 -status);
611 } 584 }
612 585out:
613 return status; 586 return status;
614} 587}
615 588
@@ -691,26 +664,28 @@ static int xs_tcp_send_request(struct rpc_task *task)
691 status = -EAGAIN; 664 status = -EAGAIN;
692 break; 665 break;
693 } 666 }
667 if (!transport->sock)
668 goto out;
694 669
695 switch (status) { 670 switch (status) {
671 case -ENOTSOCK:
672 status = -ENOTCONN;
673 /* Should we call xs_close() here? */
674 break;
696 case -EAGAIN: 675 case -EAGAIN:
697 xs_nospace(task); 676 status = xs_nospace(task);
698 break; 677 break;
678 default:
679 dprintk("RPC: sendmsg returned unrecognized error %d\n",
680 -status);
699 case -ECONNRESET: 681 case -ECONNRESET:
682 case -EPIPE:
700 xs_tcp_shutdown(xprt); 683 xs_tcp_shutdown(xprt);
701 case -ECONNREFUSED: 684 case -ECONNREFUSED:
702 case -ENOTCONN: 685 case -ENOTCONN:
703 case -EPIPE:
704 status = -ENOTCONN;
705 clear_bit(SOCK_ASYNC_NOSPACE, &transport->sock->flags);
706 break;
707 default:
708 dprintk("RPC: sendmsg returned unrecognized error %d\n",
709 -status);
710 clear_bit(SOCK_ASYNC_NOSPACE, &transport->sock->flags); 686 clear_bit(SOCK_ASYNC_NOSPACE, &transport->sock->flags);
711 xs_tcp_shutdown(xprt);
712 } 687 }
713 688out:
714 return status; 689 return status;
715} 690}
716 691
@@ -757,23 +732,13 @@ static void xs_restore_old_callbacks(struct sock_xprt *transport, struct sock *s
757 sk->sk_error_report = transport->old_error_report; 732 sk->sk_error_report = transport->old_error_report;
758} 733}
759 734
760/** 735static void xs_reset_transport(struct sock_xprt *transport)
761 * xs_close - close a socket
762 * @xprt: transport
763 *
764 * This is used when all requests are complete; ie, no DRC state remains
765 * on the server we want to save.
766 */
767static void xs_close(struct rpc_xprt *xprt)
768{ 736{
769 struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
770 struct socket *sock = transport->sock; 737 struct socket *sock = transport->sock;
771 struct sock *sk = transport->inet; 738 struct sock *sk = transport->inet;
772 739
773 if (!sk) 740 if (sk == NULL)
774 goto clear_close_wait; 741 return;
775
776 dprintk("RPC: xs_close xprt %p\n", xprt);
777 742
778 write_lock_bh(&sk->sk_callback_lock); 743 write_lock_bh(&sk->sk_callback_lock);
779 transport->inet = NULL; 744 transport->inet = NULL;
@@ -787,14 +752,42 @@ static void xs_close(struct rpc_xprt *xprt)
787 sk->sk_no_check = 0; 752 sk->sk_no_check = 0;
788 753
789 sock_release(sock); 754 sock_release(sock);
790clear_close_wait: 755}
756
757/**
758 * xs_close - close a socket
759 * @xprt: transport
760 *
761 * This is used when all requests are complete; ie, no DRC state remains
762 * on the server we want to save.
763 *
764 * The caller _must_ be holding XPRT_LOCKED in order to avoid issues with
765 * xs_reset_transport() zeroing the socket from underneath a writer.
766 */
767static void xs_close(struct rpc_xprt *xprt)
768{
769 struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
770
771 dprintk("RPC: xs_close xprt %p\n", xprt);
772
773 xs_reset_transport(transport);
774
791 smp_mb__before_clear_bit(); 775 smp_mb__before_clear_bit();
776 clear_bit(XPRT_CONNECTION_ABORT, &xprt->state);
792 clear_bit(XPRT_CLOSE_WAIT, &xprt->state); 777 clear_bit(XPRT_CLOSE_WAIT, &xprt->state);
793 clear_bit(XPRT_CLOSING, &xprt->state); 778 clear_bit(XPRT_CLOSING, &xprt->state);
794 smp_mb__after_clear_bit(); 779 smp_mb__after_clear_bit();
795 xprt_disconnect_done(xprt); 780 xprt_disconnect_done(xprt);
796} 781}
797 782
783static void xs_tcp_close(struct rpc_xprt *xprt)
784{
785 if (test_and_clear_bit(XPRT_CONNECTION_CLOSE, &xprt->state))
786 xs_close(xprt);
787 else
788 xs_tcp_shutdown(xprt);
789}
790
798/** 791/**
799 * xs_destroy - prepare to shutdown a transport 792 * xs_destroy - prepare to shutdown a transport
800 * @xprt: doomed transport 793 * @xprt: doomed transport
@@ -878,7 +871,7 @@ static void xs_udp_data_ready(struct sock *sk, int len)
878 UDPX_INC_STATS_BH(sk, UDP_MIB_INDATAGRAMS); 871 UDPX_INC_STATS_BH(sk, UDP_MIB_INDATAGRAMS);
879 872
880 /* Something worked... */ 873 /* Something worked... */
881 dst_confirm(skb->dst); 874 dst_confirm(skb_dst(skb));
882 875
883 xprt_adjust_cwnd(task, copied); 876 xprt_adjust_cwnd(task, copied);
884 xprt_update_rtt(task); 877 xprt_update_rtt(task);
@@ -916,7 +909,7 @@ static inline void xs_tcp_read_fraghdr(struct rpc_xprt *xprt, struct xdr_skb_rea
916 transport->tcp_offset = 0; 909 transport->tcp_offset = 0;
917 910
918 /* Sanity check of the record length */ 911 /* Sanity check of the record length */
919 if (unlikely(transport->tcp_reclen < 4)) { 912 if (unlikely(transport->tcp_reclen < 8)) {
920 dprintk("RPC: invalid TCP record fragment length\n"); 913 dprintk("RPC: invalid TCP record fragment length\n");
921 xprt_force_disconnect(xprt); 914 xprt_force_disconnect(xprt);
922 return; 915 return;
@@ -951,33 +944,77 @@ static inline void xs_tcp_read_xid(struct sock_xprt *transport, struct xdr_skb_r
951 if (used != len) 944 if (used != len)
952 return; 945 return;
953 transport->tcp_flags &= ~TCP_RCV_COPY_XID; 946 transport->tcp_flags &= ~TCP_RCV_COPY_XID;
954 transport->tcp_flags |= TCP_RCV_COPY_DATA; 947 transport->tcp_flags |= TCP_RCV_READ_CALLDIR;
955 transport->tcp_copied = 4; 948 transport->tcp_copied = 4;
956 dprintk("RPC: reading reply for XID %08x\n", 949 dprintk("RPC: reading %s XID %08x\n",
950 (transport->tcp_flags & TCP_RPC_REPLY) ? "reply for"
951 : "request with",
957 ntohl(transport->tcp_xid)); 952 ntohl(transport->tcp_xid));
958 xs_tcp_check_fraghdr(transport); 953 xs_tcp_check_fraghdr(transport);
959} 954}
960 955
961static inline void xs_tcp_read_request(struct rpc_xprt *xprt, struct xdr_skb_reader *desc) 956static inline void xs_tcp_read_calldir(struct sock_xprt *transport,
957 struct xdr_skb_reader *desc)
962{ 958{
963 struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt); 959 size_t len, used;
964 struct rpc_rqst *req; 960 u32 offset;
961 __be32 calldir;
962
963 /*
964 * We want transport->tcp_offset to be 8 at the end of this routine
965 * (4 bytes for the xid and 4 bytes for the call/reply flag).
966 * When this function is called for the first time,
967 * transport->tcp_offset is 4 (after having already read the xid).
968 */
969 offset = transport->tcp_offset - sizeof(transport->tcp_xid);
970 len = sizeof(calldir) - offset;
971 dprintk("RPC: reading CALL/REPLY flag (%Zu bytes)\n", len);
972 used = xdr_skb_read_bits(desc, &calldir, len);
973 transport->tcp_offset += used;
974 if (used != len)
975 return;
976 transport->tcp_flags &= ~TCP_RCV_READ_CALLDIR;
977 transport->tcp_flags |= TCP_RCV_COPY_CALLDIR;
978 transport->tcp_flags |= TCP_RCV_COPY_DATA;
979 /*
980 * We don't yet have the XDR buffer, so we will write the calldir
981 * out after we get the buffer from the 'struct rpc_rqst'
982 */
983 if (ntohl(calldir) == RPC_REPLY)
984 transport->tcp_flags |= TCP_RPC_REPLY;
985 else
986 transport->tcp_flags &= ~TCP_RPC_REPLY;
987 dprintk("RPC: reading %s CALL/REPLY flag %08x\n",
988 (transport->tcp_flags & TCP_RPC_REPLY) ?
989 "reply for" : "request with", calldir);
990 xs_tcp_check_fraghdr(transport);
991}
992
993static inline void xs_tcp_read_common(struct rpc_xprt *xprt,
994 struct xdr_skb_reader *desc,
995 struct rpc_rqst *req)
996{
997 struct sock_xprt *transport =
998 container_of(xprt, struct sock_xprt, xprt);
965 struct xdr_buf *rcvbuf; 999 struct xdr_buf *rcvbuf;
966 size_t len; 1000 size_t len;
967 ssize_t r; 1001 ssize_t r;
968 1002
969 /* Find and lock the request corresponding to this xid */ 1003 rcvbuf = &req->rq_private_buf;
970 spin_lock(&xprt->transport_lock); 1004
971 req = xprt_lookup_rqst(xprt, transport->tcp_xid); 1005 if (transport->tcp_flags & TCP_RCV_COPY_CALLDIR) {
972 if (!req) { 1006 /*
973 transport->tcp_flags &= ~TCP_RCV_COPY_DATA; 1007 * Save the RPC direction in the XDR buffer
974 dprintk("RPC: XID %08x request not found!\n", 1008 */
975 ntohl(transport->tcp_xid)); 1009 __be32 calldir = transport->tcp_flags & TCP_RPC_REPLY ?
976 spin_unlock(&xprt->transport_lock); 1010 htonl(RPC_REPLY) : 0;
977 return; 1011
1012 memcpy(rcvbuf->head[0].iov_base + transport->tcp_copied,
1013 &calldir, sizeof(calldir));
1014 transport->tcp_copied += sizeof(calldir);
1015 transport->tcp_flags &= ~TCP_RCV_COPY_CALLDIR;
978 } 1016 }
979 1017
980 rcvbuf = &req->rq_private_buf;
981 len = desc->count; 1018 len = desc->count;
982 if (len > transport->tcp_reclen - transport->tcp_offset) { 1019 if (len > transport->tcp_reclen - transport->tcp_offset) {
983 struct xdr_skb_reader my_desc; 1020 struct xdr_skb_reader my_desc;
@@ -1014,7 +1051,7 @@ static inline void xs_tcp_read_request(struct rpc_xprt *xprt, struct xdr_skb_rea
1014 "tcp_offset = %u, tcp_reclen = %u\n", 1051 "tcp_offset = %u, tcp_reclen = %u\n",
1015 xprt, transport->tcp_copied, 1052 xprt, transport->tcp_copied,
1016 transport->tcp_offset, transport->tcp_reclen); 1053 transport->tcp_offset, transport->tcp_reclen);
1017 goto out; 1054 return;
1018 } 1055 }
1019 1056
1020 dprintk("RPC: XID %08x read %Zd bytes\n", 1057 dprintk("RPC: XID %08x read %Zd bytes\n",
@@ -1030,11 +1067,125 @@ static inline void xs_tcp_read_request(struct rpc_xprt *xprt, struct xdr_skb_rea
1030 transport->tcp_flags &= ~TCP_RCV_COPY_DATA; 1067 transport->tcp_flags &= ~TCP_RCV_COPY_DATA;
1031 } 1068 }
1032 1069
1033out: 1070 return;
1071}
1072
1073/*
1074 * Finds the request corresponding to the RPC xid and invokes the common
1075 * tcp read code to read the data.
1076 */
1077static inline int xs_tcp_read_reply(struct rpc_xprt *xprt,
1078 struct xdr_skb_reader *desc)
1079{
1080 struct sock_xprt *transport =
1081 container_of(xprt, struct sock_xprt, xprt);
1082 struct rpc_rqst *req;
1083
1084 dprintk("RPC: read reply XID %08x\n", ntohl(transport->tcp_xid));
1085
1086 /* Find and lock the request corresponding to this xid */
1087 spin_lock(&xprt->transport_lock);
1088 req = xprt_lookup_rqst(xprt, transport->tcp_xid);
1089 if (!req) {
1090 dprintk("RPC: XID %08x request not found!\n",
1091 ntohl(transport->tcp_xid));
1092 spin_unlock(&xprt->transport_lock);
1093 return -1;
1094 }
1095
1096 xs_tcp_read_common(xprt, desc, req);
1097
1034 if (!(transport->tcp_flags & TCP_RCV_COPY_DATA)) 1098 if (!(transport->tcp_flags & TCP_RCV_COPY_DATA))
1035 xprt_complete_rqst(req->rq_task, transport->tcp_copied); 1099 xprt_complete_rqst(req->rq_task, transport->tcp_copied);
1100
1036 spin_unlock(&xprt->transport_lock); 1101 spin_unlock(&xprt->transport_lock);
1037 xs_tcp_check_fraghdr(transport); 1102 return 0;
1103}
1104
1105#if defined(CONFIG_NFS_V4_1)
1106/*
1107 * Obtains an rpc_rqst previously allocated and invokes the common
1108 * tcp read code to read the data. The result is placed in the callback
1109 * queue.
1110 * If we're unable to obtain the rpc_rqst we schedule the closing of the
1111 * connection and return -1.
1112 */
1113static inline int xs_tcp_read_callback(struct rpc_xprt *xprt,
1114 struct xdr_skb_reader *desc)
1115{
1116 struct sock_xprt *transport =
1117 container_of(xprt, struct sock_xprt, xprt);
1118 struct rpc_rqst *req;
1119
1120 req = xprt_alloc_bc_request(xprt);
1121 if (req == NULL) {
1122 printk(KERN_WARNING "Callback slot table overflowed\n");
1123 xprt_force_disconnect(xprt);
1124 return -1;
1125 }
1126
1127 req->rq_xid = transport->tcp_xid;
1128 dprintk("RPC: read callback XID %08x\n", ntohl(req->rq_xid));
1129 xs_tcp_read_common(xprt, desc, req);
1130
1131 if (!(transport->tcp_flags & TCP_RCV_COPY_DATA)) {
1132 struct svc_serv *bc_serv = xprt->bc_serv;
1133
1134 /*
1135 * Add callback request to callback list. The callback
1136 * service sleeps on the sv_cb_waitq waiting for new
1137 * requests. Wake it up after adding enqueing the
1138 * request.
1139 */
1140 dprintk("RPC: add callback request to list\n");
1141 spin_lock(&bc_serv->sv_cb_lock);
1142 list_add(&req->rq_bc_list, &bc_serv->sv_cb_list);
1143 spin_unlock(&bc_serv->sv_cb_lock);
1144 wake_up(&bc_serv->sv_cb_waitq);
1145 }
1146
1147 req->rq_private_buf.len = transport->tcp_copied;
1148
1149 return 0;
1150}
1151
1152static inline int _xs_tcp_read_data(struct rpc_xprt *xprt,
1153 struct xdr_skb_reader *desc)
1154{
1155 struct sock_xprt *transport =
1156 container_of(xprt, struct sock_xprt, xprt);
1157
1158 return (transport->tcp_flags & TCP_RPC_REPLY) ?
1159 xs_tcp_read_reply(xprt, desc) :
1160 xs_tcp_read_callback(xprt, desc);
1161}
1162#else
1163static inline int _xs_tcp_read_data(struct rpc_xprt *xprt,
1164 struct xdr_skb_reader *desc)
1165{
1166 return xs_tcp_read_reply(xprt, desc);
1167}
1168#endif /* CONFIG_NFS_V4_1 */
1169
1170/*
1171 * Read data off the transport. This can be either an RPC_CALL or an
1172 * RPC_REPLY. Relay the processing to helper functions.
1173 */
1174static void xs_tcp_read_data(struct rpc_xprt *xprt,
1175 struct xdr_skb_reader *desc)
1176{
1177 struct sock_xprt *transport =
1178 container_of(xprt, struct sock_xprt, xprt);
1179
1180 if (_xs_tcp_read_data(xprt, desc) == 0)
1181 xs_tcp_check_fraghdr(transport);
1182 else {
1183 /*
1184 * The transport_lock protects the request handling.
1185 * There's no need to hold it to update the tcp_flags.
1186 */
1187 transport->tcp_flags &= ~TCP_RCV_COPY_DATA;
1188 }
1038} 1189}
1039 1190
1040static inline void xs_tcp_read_discard(struct sock_xprt *transport, struct xdr_skb_reader *desc) 1191static inline void xs_tcp_read_discard(struct sock_xprt *transport, struct xdr_skb_reader *desc)
@@ -1074,9 +1225,14 @@ static int xs_tcp_data_recv(read_descriptor_t *rd_desc, struct sk_buff *skb, uns
1074 xs_tcp_read_xid(transport, &desc); 1225 xs_tcp_read_xid(transport, &desc);
1075 continue; 1226 continue;
1076 } 1227 }
1228 /* Read in the call/reply flag */
1229 if (transport->tcp_flags & TCP_RCV_READ_CALLDIR) {
1230 xs_tcp_read_calldir(transport, &desc);
1231 continue;
1232 }
1077 /* Read in the request data */ 1233 /* Read in the request data */
1078 if (transport->tcp_flags & TCP_RCV_COPY_DATA) { 1234 if (transport->tcp_flags & TCP_RCV_COPY_DATA) {
1079 xs_tcp_read_request(xprt, &desc); 1235 xs_tcp_read_data(xprt, &desc);
1080 continue; 1236 continue;
1081 } 1237 }
1082 /* Skip over any trailing bytes on short reads */ 1238 /* Skip over any trailing bytes on short reads */
@@ -1116,6 +1272,47 @@ out:
1116 read_unlock(&sk->sk_callback_lock); 1272 read_unlock(&sk->sk_callback_lock);
1117} 1273}
1118 1274
1275/*
1276 * Do the equivalent of linger/linger2 handling for dealing with
1277 * broken servers that don't close the socket in a timely
1278 * fashion
1279 */
1280static void xs_tcp_schedule_linger_timeout(struct rpc_xprt *xprt,
1281 unsigned long timeout)
1282{
1283 struct sock_xprt *transport;
1284
1285 if (xprt_test_and_set_connecting(xprt))
1286 return;
1287 set_bit(XPRT_CONNECTION_ABORT, &xprt->state);
1288 transport = container_of(xprt, struct sock_xprt, xprt);
1289 queue_delayed_work(rpciod_workqueue, &transport->connect_worker,
1290 timeout);
1291}
1292
1293static void xs_tcp_cancel_linger_timeout(struct rpc_xprt *xprt)
1294{
1295 struct sock_xprt *transport;
1296
1297 transport = container_of(xprt, struct sock_xprt, xprt);
1298
1299 if (!test_bit(XPRT_CONNECTION_ABORT, &xprt->state) ||
1300 !cancel_delayed_work(&transport->connect_worker))
1301 return;
1302 clear_bit(XPRT_CONNECTION_ABORT, &xprt->state);
1303 xprt_clear_connecting(xprt);
1304}
1305
1306static void xs_sock_mark_closed(struct rpc_xprt *xprt)
1307{
1308 smp_mb__before_clear_bit();
1309 clear_bit(XPRT_CLOSE_WAIT, &xprt->state);
1310 clear_bit(XPRT_CLOSING, &xprt->state);
1311 smp_mb__after_clear_bit();
1312 /* Mark transport as closed and wake up all pending tasks */
1313 xprt_disconnect_done(xprt);
1314}
1315
1119/** 1316/**
1120 * xs_tcp_state_change - callback to handle TCP socket state changes 1317 * xs_tcp_state_change - callback to handle TCP socket state changes
1121 * @sk: socket whose state has changed 1318 * @sk: socket whose state has changed
@@ -1148,7 +1345,7 @@ static void xs_tcp_state_change(struct sock *sk)
1148 transport->tcp_flags = 1345 transport->tcp_flags =
1149 TCP_RCV_COPY_FRAGHDR | TCP_RCV_COPY_XID; 1346 TCP_RCV_COPY_FRAGHDR | TCP_RCV_COPY_XID;
1150 1347
1151 xprt_wake_pending_tasks(xprt, 0); 1348 xprt_wake_pending_tasks(xprt, -EAGAIN);
1152 } 1349 }
1153 spin_unlock_bh(&xprt->transport_lock); 1350 spin_unlock_bh(&xprt->transport_lock);
1154 break; 1351 break;
@@ -1161,10 +1358,10 @@ static void xs_tcp_state_change(struct sock *sk)
1161 clear_bit(XPRT_CONNECTED, &xprt->state); 1358 clear_bit(XPRT_CONNECTED, &xprt->state);
1162 clear_bit(XPRT_CLOSE_WAIT, &xprt->state); 1359 clear_bit(XPRT_CLOSE_WAIT, &xprt->state);
1163 smp_mb__after_clear_bit(); 1360 smp_mb__after_clear_bit();
1361 xs_tcp_schedule_linger_timeout(xprt, xs_tcp_fin_timeout);
1164 break; 1362 break;
1165 case TCP_CLOSE_WAIT: 1363 case TCP_CLOSE_WAIT:
1166 /* The server initiated a shutdown of the socket */ 1364 /* The server initiated a shutdown of the socket */
1167 set_bit(XPRT_CLOSING, &xprt->state);
1168 xprt_force_disconnect(xprt); 1365 xprt_force_disconnect(xprt);
1169 case TCP_SYN_SENT: 1366 case TCP_SYN_SENT:
1170 xprt->connect_cookie++; 1367 xprt->connect_cookie++;
@@ -1177,44 +1374,56 @@ static void xs_tcp_state_change(struct sock *sk)
1177 xprt->reestablish_timeout = XS_TCP_INIT_REEST_TO; 1374 xprt->reestablish_timeout = XS_TCP_INIT_REEST_TO;
1178 break; 1375 break;
1179 case TCP_LAST_ACK: 1376 case TCP_LAST_ACK:
1377 set_bit(XPRT_CLOSING, &xprt->state);
1378 xs_tcp_schedule_linger_timeout(xprt, xs_tcp_fin_timeout);
1180 smp_mb__before_clear_bit(); 1379 smp_mb__before_clear_bit();
1181 clear_bit(XPRT_CONNECTED, &xprt->state); 1380 clear_bit(XPRT_CONNECTED, &xprt->state);
1182 smp_mb__after_clear_bit(); 1381 smp_mb__after_clear_bit();
1183 break; 1382 break;
1184 case TCP_CLOSE: 1383 case TCP_CLOSE:
1185 smp_mb__before_clear_bit(); 1384 xs_tcp_cancel_linger_timeout(xprt);
1186 clear_bit(XPRT_CLOSE_WAIT, &xprt->state); 1385 xs_sock_mark_closed(xprt);
1187 clear_bit(XPRT_CLOSING, &xprt->state);
1188 smp_mb__after_clear_bit();
1189 /* Mark transport as closed and wake up all pending tasks */
1190 xprt_disconnect_done(xprt);
1191 } 1386 }
1192 out: 1387 out:
1193 read_unlock(&sk->sk_callback_lock); 1388 read_unlock(&sk->sk_callback_lock);
1194} 1389}
1195 1390
1196/** 1391/**
1197 * xs_tcp_error_report - callback mainly for catching RST events 1392 * xs_error_report - callback mainly for catching socket errors
1198 * @sk: socket 1393 * @sk: socket
1199 */ 1394 */
1200static void xs_tcp_error_report(struct sock *sk) 1395static void xs_error_report(struct sock *sk)
1201{ 1396{
1202 struct rpc_xprt *xprt; 1397 struct rpc_xprt *xprt;
1203 1398
1204 read_lock(&sk->sk_callback_lock); 1399 read_lock(&sk->sk_callback_lock);
1205 if (sk->sk_err != ECONNRESET || sk->sk_state != TCP_ESTABLISHED)
1206 goto out;
1207 if (!(xprt = xprt_from_sock(sk))) 1400 if (!(xprt = xprt_from_sock(sk)))
1208 goto out; 1401 goto out;
1209 dprintk("RPC: %s client %p...\n" 1402 dprintk("RPC: %s client %p...\n"
1210 "RPC: error %d\n", 1403 "RPC: error %d\n",
1211 __func__, xprt, sk->sk_err); 1404 __func__, xprt, sk->sk_err);
1212 1405 xprt_wake_pending_tasks(xprt, -EAGAIN);
1213 xprt_force_disconnect(xprt);
1214out: 1406out:
1215 read_unlock(&sk->sk_callback_lock); 1407 read_unlock(&sk->sk_callback_lock);
1216} 1408}
1217 1409
1410static void xs_write_space(struct sock *sk)
1411{
1412 struct socket *sock;
1413 struct rpc_xprt *xprt;
1414
1415 if (unlikely(!(sock = sk->sk_socket)))
1416 return;
1417 clear_bit(SOCK_NOSPACE, &sock->flags);
1418
1419 if (unlikely(!(xprt = xprt_from_sock(sk))))
1420 return;
1421 if (test_and_clear_bit(SOCK_ASYNC_NOSPACE, &sock->flags) == 0)
1422 return;
1423
1424 xprt_write_space(xprt);
1425}
1426
1218/** 1427/**
1219 * xs_udp_write_space - callback invoked when socket buffer space 1428 * xs_udp_write_space - callback invoked when socket buffer space
1220 * becomes available 1429 * becomes available
@@ -1230,23 +1439,9 @@ static void xs_udp_write_space(struct sock *sk)
1230 read_lock(&sk->sk_callback_lock); 1439 read_lock(&sk->sk_callback_lock);
1231 1440
1232 /* from net/core/sock.c:sock_def_write_space */ 1441 /* from net/core/sock.c:sock_def_write_space */
1233 if (sock_writeable(sk)) { 1442 if (sock_writeable(sk))
1234 struct socket *sock; 1443 xs_write_space(sk);
1235 struct rpc_xprt *xprt;
1236
1237 if (unlikely(!(sock = sk->sk_socket)))
1238 goto out;
1239 clear_bit(SOCK_NOSPACE, &sock->flags);
1240
1241 if (unlikely(!(xprt = xprt_from_sock(sk))))
1242 goto out;
1243 if (test_and_clear_bit(SOCK_ASYNC_NOSPACE, &sock->flags) == 0)
1244 goto out;
1245 1444
1246 xprt_write_space(xprt);
1247 }
1248
1249 out:
1250 read_unlock(&sk->sk_callback_lock); 1445 read_unlock(&sk->sk_callback_lock);
1251} 1446}
1252 1447
@@ -1265,23 +1460,9 @@ static void xs_tcp_write_space(struct sock *sk)
1265 read_lock(&sk->sk_callback_lock); 1460 read_lock(&sk->sk_callback_lock);
1266 1461
1267 /* from net/core/stream.c:sk_stream_write_space */ 1462 /* from net/core/stream.c:sk_stream_write_space */
1268 if (sk_stream_wspace(sk) >= sk_stream_min_wspace(sk)) { 1463 if (sk_stream_wspace(sk) >= sk_stream_min_wspace(sk))
1269 struct socket *sock; 1464 xs_write_space(sk);
1270 struct rpc_xprt *xprt;
1271 1465
1272 if (unlikely(!(sock = sk->sk_socket)))
1273 goto out;
1274 clear_bit(SOCK_NOSPACE, &sock->flags);
1275
1276 if (unlikely(!(xprt = xprt_from_sock(sk))))
1277 goto out;
1278 if (test_and_clear_bit(SOCK_ASYNC_NOSPACE, &sock->flags) == 0)
1279 goto out;
1280
1281 xprt_write_space(xprt);
1282 }
1283
1284 out:
1285 read_unlock(&sk->sk_callback_lock); 1466 read_unlock(&sk->sk_callback_lock);
1286} 1467}
1287 1468
@@ -1349,25 +1530,15 @@ static unsigned short xs_get_random_port(void)
1349 */ 1530 */
1350static void xs_set_port(struct rpc_xprt *xprt, unsigned short port) 1531static void xs_set_port(struct rpc_xprt *xprt, unsigned short port)
1351{ 1532{
1352 struct sockaddr *addr = xs_addr(xprt);
1353
1354 dprintk("RPC: setting port for xprt %p to %u\n", xprt, port); 1533 dprintk("RPC: setting port for xprt %p to %u\n", xprt, port);
1355 1534
1356 switch (addr->sa_family) { 1535 rpc_set_port(xs_addr(xprt), port);
1357 case AF_INET: 1536 xs_update_peer_port(xprt);
1358 ((struct sockaddr_in *)addr)->sin_port = htons(port);
1359 break;
1360 case AF_INET6:
1361 ((struct sockaddr_in6 *)addr)->sin6_port = htons(port);
1362 break;
1363 default:
1364 BUG();
1365 }
1366} 1537}
1367 1538
1368static unsigned short xs_get_srcport(struct sock_xprt *transport, struct socket *sock) 1539static unsigned short xs_get_srcport(struct sock_xprt *transport, struct socket *sock)
1369{ 1540{
1370 unsigned short port = transport->port; 1541 unsigned short port = transport->srcport;
1371 1542
1372 if (port == 0 && transport->xprt.resvport) 1543 if (port == 0 && transport->xprt.resvport)
1373 port = xs_get_random_port(); 1544 port = xs_get_random_port();
@@ -1376,8 +1547,8 @@ static unsigned short xs_get_srcport(struct sock_xprt *transport, struct socket
1376 1547
1377static unsigned short xs_next_srcport(struct sock_xprt *transport, struct socket *sock, unsigned short port) 1548static unsigned short xs_next_srcport(struct sock_xprt *transport, struct socket *sock, unsigned short port)
1378{ 1549{
1379 if (transport->port != 0) 1550 if (transport->srcport != 0)
1380 transport->port = 0; 1551 transport->srcport = 0;
1381 if (!transport->xprt.resvport) 1552 if (!transport->xprt.resvport)
1382 return 0; 1553 return 0;
1383 if (port <= xprt_min_resvport || port > xprt_max_resvport) 1554 if (port <= xprt_min_resvport || port > xprt_max_resvport)
@@ -1395,7 +1566,7 @@ static int xs_bind4(struct sock_xprt *transport, struct socket *sock)
1395 unsigned short port = xs_get_srcport(transport, sock); 1566 unsigned short port = xs_get_srcport(transport, sock);
1396 unsigned short last; 1567 unsigned short last;
1397 1568
1398 sa = (struct sockaddr_in *)&transport->addr; 1569 sa = (struct sockaddr_in *)&transport->srcaddr;
1399 myaddr.sin_addr = sa->sin_addr; 1570 myaddr.sin_addr = sa->sin_addr;
1400 do { 1571 do {
1401 myaddr.sin_port = htons(port); 1572 myaddr.sin_port = htons(port);
@@ -1404,7 +1575,7 @@ static int xs_bind4(struct sock_xprt *transport, struct socket *sock)
1404 if (port == 0) 1575 if (port == 0)
1405 break; 1576 break;
1406 if (err == 0) { 1577 if (err == 0) {
1407 transport->port = port; 1578 transport->srcport = port;
1408 break; 1579 break;
1409 } 1580 }
1410 last = port; 1581 last = port;
@@ -1428,7 +1599,7 @@ static int xs_bind6(struct sock_xprt *transport, struct socket *sock)
1428 unsigned short port = xs_get_srcport(transport, sock); 1599 unsigned short port = xs_get_srcport(transport, sock);
1429 unsigned short last; 1600 unsigned short last;
1430 1601
1431 sa = (struct sockaddr_in6 *)&transport->addr; 1602 sa = (struct sockaddr_in6 *)&transport->srcaddr;
1432 myaddr.sin6_addr = sa->sin6_addr; 1603 myaddr.sin6_addr = sa->sin6_addr;
1433 do { 1604 do {
1434 myaddr.sin6_port = htons(port); 1605 myaddr.sin6_port = htons(port);
@@ -1437,7 +1608,7 @@ static int xs_bind6(struct sock_xprt *transport, struct socket *sock)
1437 if (port == 0) 1608 if (port == 0)
1438 break; 1609 break;
1439 if (err == 0) { 1610 if (err == 0) {
1440 transport->port = port; 1611 transport->srcport = port;
1441 break; 1612 break;
1442 } 1613 }
1443 last = port; 1614 last = port;
@@ -1495,6 +1666,7 @@ static void xs_udp_finish_connecting(struct rpc_xprt *xprt, struct socket *sock)
1495 sk->sk_user_data = xprt; 1666 sk->sk_user_data = xprt;
1496 sk->sk_data_ready = xs_udp_data_ready; 1667 sk->sk_data_ready = xs_udp_data_ready;
1497 sk->sk_write_space = xs_udp_write_space; 1668 sk->sk_write_space = xs_udp_write_space;
1669 sk->sk_error_report = xs_error_report;
1498 sk->sk_no_check = UDP_CSUM_NORCV; 1670 sk->sk_no_check = UDP_CSUM_NORCV;
1499 sk->sk_allocation = GFP_ATOMIC; 1671 sk->sk_allocation = GFP_ATOMIC;
1500 1672
@@ -1523,13 +1695,14 @@ static void xs_udp_connect_worker4(struct work_struct *work)
1523 struct socket *sock = transport->sock; 1695 struct socket *sock = transport->sock;
1524 int err, status = -EIO; 1696 int err, status = -EIO;
1525 1697
1526 if (xprt->shutdown || !xprt_bound(xprt)) 1698 if (xprt->shutdown)
1527 goto out; 1699 goto out;
1528 1700
1529 /* Start by resetting any existing state */ 1701 /* Start by resetting any existing state */
1530 xs_close(xprt); 1702 xs_reset_transport(transport);
1531 1703
1532 if ((err = sock_create_kern(PF_INET, SOCK_DGRAM, IPPROTO_UDP, &sock)) < 0) { 1704 err = sock_create_kern(PF_INET, SOCK_DGRAM, IPPROTO_UDP, &sock);
1705 if (err < 0) {
1533 dprintk("RPC: can't create UDP transport socket (%d).\n", -err); 1706 dprintk("RPC: can't create UDP transport socket (%d).\n", -err);
1534 goto out; 1707 goto out;
1535 } 1708 }
@@ -1540,14 +1713,17 @@ static void xs_udp_connect_worker4(struct work_struct *work)
1540 goto out; 1713 goto out;
1541 } 1714 }
1542 1715
1543 dprintk("RPC: worker connecting xprt %p to address: %s\n", 1716 dprintk("RPC: worker connecting xprt %p via %s to "
1544 xprt, xprt->address_strings[RPC_DISPLAY_ALL]); 1717 "%s (port %s)\n", xprt,
1718 xprt->address_strings[RPC_DISPLAY_PROTO],
1719 xprt->address_strings[RPC_DISPLAY_ADDR],
1720 xprt->address_strings[RPC_DISPLAY_PORT]);
1545 1721
1546 xs_udp_finish_connecting(xprt, sock); 1722 xs_udp_finish_connecting(xprt, sock);
1547 status = 0; 1723 status = 0;
1548out: 1724out:
1549 xprt_wake_pending_tasks(xprt, status);
1550 xprt_clear_connecting(xprt); 1725 xprt_clear_connecting(xprt);
1726 xprt_wake_pending_tasks(xprt, status);
1551} 1727}
1552 1728
1553/** 1729/**
@@ -1564,13 +1740,14 @@ static void xs_udp_connect_worker6(struct work_struct *work)
1564 struct socket *sock = transport->sock; 1740 struct socket *sock = transport->sock;
1565 int err, status = -EIO; 1741 int err, status = -EIO;
1566 1742
1567 if (xprt->shutdown || !xprt_bound(xprt)) 1743 if (xprt->shutdown)
1568 goto out; 1744 goto out;
1569 1745
1570 /* Start by resetting any existing state */ 1746 /* Start by resetting any existing state */
1571 xs_close(xprt); 1747 xs_reset_transport(transport);
1572 1748
1573 if ((err = sock_create_kern(PF_INET6, SOCK_DGRAM, IPPROTO_UDP, &sock)) < 0) { 1749 err = sock_create_kern(PF_INET6, SOCK_DGRAM, IPPROTO_UDP, &sock);
1750 if (err < 0) {
1574 dprintk("RPC: can't create UDP transport socket (%d).\n", -err); 1751 dprintk("RPC: can't create UDP transport socket (%d).\n", -err);
1575 goto out; 1752 goto out;
1576 } 1753 }
@@ -1581,24 +1758,26 @@ static void xs_udp_connect_worker6(struct work_struct *work)
1581 goto out; 1758 goto out;
1582 } 1759 }
1583 1760
1584 dprintk("RPC: worker connecting xprt %p to address: %s\n", 1761 dprintk("RPC: worker connecting xprt %p via %s to "
1585 xprt, xprt->address_strings[RPC_DISPLAY_ALL]); 1762 "%s (port %s)\n", xprt,
1763 xprt->address_strings[RPC_DISPLAY_PROTO],
1764 xprt->address_strings[RPC_DISPLAY_ADDR],
1765 xprt->address_strings[RPC_DISPLAY_PORT]);
1586 1766
1587 xs_udp_finish_connecting(xprt, sock); 1767 xs_udp_finish_connecting(xprt, sock);
1588 status = 0; 1768 status = 0;
1589out: 1769out:
1590 xprt_wake_pending_tasks(xprt, status);
1591 xprt_clear_connecting(xprt); 1770 xprt_clear_connecting(xprt);
1771 xprt_wake_pending_tasks(xprt, status);
1592} 1772}
1593 1773
1594/* 1774/*
1595 * We need to preserve the port number so the reply cache on the server can 1775 * We need to preserve the port number so the reply cache on the server can
1596 * find our cached RPC replies when we get around to reconnecting. 1776 * find our cached RPC replies when we get around to reconnecting.
1597 */ 1777 */
1598static void xs_tcp_reuse_connection(struct rpc_xprt *xprt) 1778static void xs_abort_connection(struct rpc_xprt *xprt, struct sock_xprt *transport)
1599{ 1779{
1600 int result; 1780 int result;
1601 struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
1602 struct sockaddr any; 1781 struct sockaddr any;
1603 1782
1604 dprintk("RPC: disconnecting xprt %p to reuse port\n", xprt); 1783 dprintk("RPC: disconnecting xprt %p to reuse port\n", xprt);
@@ -1610,11 +1789,24 @@ static void xs_tcp_reuse_connection(struct rpc_xprt *xprt)
1610 memset(&any, 0, sizeof(any)); 1789 memset(&any, 0, sizeof(any));
1611 any.sa_family = AF_UNSPEC; 1790 any.sa_family = AF_UNSPEC;
1612 result = kernel_connect(transport->sock, &any, sizeof(any), 0); 1791 result = kernel_connect(transport->sock, &any, sizeof(any), 0);
1613 if (result) 1792 if (!result)
1793 xs_sock_mark_closed(xprt);
1794 else
1614 dprintk("RPC: AF_UNSPEC connect return code %d\n", 1795 dprintk("RPC: AF_UNSPEC connect return code %d\n",
1615 result); 1796 result);
1616} 1797}
1617 1798
1799static void xs_tcp_reuse_connection(struct rpc_xprt *xprt, struct sock_xprt *transport)
1800{
1801 unsigned int state = transport->inet->sk_state;
1802
1803 if (state == TCP_CLOSE && transport->sock->state == SS_UNCONNECTED)
1804 return;
1805 if ((1 << state) & (TCPF_ESTABLISHED|TCPF_SYN_SENT))
1806 return;
1807 xs_abort_connection(xprt, transport);
1808}
1809
1618static int xs_tcp_finish_connecting(struct rpc_xprt *xprt, struct socket *sock) 1810static int xs_tcp_finish_connecting(struct rpc_xprt *xprt, struct socket *sock)
1619{ 1811{
1620 struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt); 1812 struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
@@ -1630,7 +1822,7 @@ static int xs_tcp_finish_connecting(struct rpc_xprt *xprt, struct socket *sock)
1630 sk->sk_data_ready = xs_tcp_data_ready; 1822 sk->sk_data_ready = xs_tcp_data_ready;
1631 sk->sk_state_change = xs_tcp_state_change; 1823 sk->sk_state_change = xs_tcp_state_change;
1632 sk->sk_write_space = xs_tcp_write_space; 1824 sk->sk_write_space = xs_tcp_write_space;
1633 sk->sk_error_report = xs_tcp_error_report; 1825 sk->sk_error_report = xs_error_report;
1634 sk->sk_allocation = GFP_ATOMIC; 1826 sk->sk_allocation = GFP_ATOMIC;
1635 1827
1636 /* socket options */ 1828 /* socket options */
@@ -1648,6 +1840,9 @@ static int xs_tcp_finish_connecting(struct rpc_xprt *xprt, struct socket *sock)
1648 write_unlock_bh(&sk->sk_callback_lock); 1840 write_unlock_bh(&sk->sk_callback_lock);
1649 } 1841 }
1650 1842
1843 if (!xprt_bound(xprt))
1844 return -ENOTCONN;
1845
1651 /* Tell the socket layer to start connecting... */ 1846 /* Tell the socket layer to start connecting... */
1652 xprt->stat.connect_count++; 1847 xprt->stat.connect_count++;
1653 xprt->stat.connect_start = jiffies; 1848 xprt->stat.connect_start = jiffies;
@@ -1655,122 +1850,157 @@ static int xs_tcp_finish_connecting(struct rpc_xprt *xprt, struct socket *sock)
1655} 1850}
1656 1851
1657/** 1852/**
1658 * xs_tcp_connect_worker4 - connect a TCP socket to a remote endpoint 1853 * xs_tcp_setup_socket - create a TCP socket and connect to a remote endpoint
1659 * @work: RPC transport to connect 1854 * @xprt: RPC transport to connect
1855 * @transport: socket transport to connect
1856 * @create_sock: function to create a socket of the correct type
1660 * 1857 *
1661 * Invoked by a work queue tasklet. 1858 * Invoked by a work queue tasklet.
1662 */ 1859 */
1663static void xs_tcp_connect_worker4(struct work_struct *work) 1860static void xs_tcp_setup_socket(struct rpc_xprt *xprt,
1861 struct sock_xprt *transport,
1862 struct socket *(*create_sock)(struct rpc_xprt *,
1863 struct sock_xprt *))
1664{ 1864{
1665 struct sock_xprt *transport =
1666 container_of(work, struct sock_xprt, connect_worker.work);
1667 struct rpc_xprt *xprt = &transport->xprt;
1668 struct socket *sock = transport->sock; 1865 struct socket *sock = transport->sock;
1669 int err, status = -EIO; 1866 int status = -EIO;
1670 1867
1671 if (xprt->shutdown || !xprt_bound(xprt)) 1868 if (xprt->shutdown)
1672 goto out; 1869 goto out;
1673 1870
1674 if (!sock) { 1871 if (!sock) {
1675 /* start from scratch */ 1872 clear_bit(XPRT_CONNECTION_ABORT, &xprt->state);
1676 if ((err = sock_create_kern(PF_INET, SOCK_STREAM, IPPROTO_TCP, &sock)) < 0) { 1873 sock = create_sock(xprt, transport);
1677 dprintk("RPC: can't create TCP transport socket (%d).\n", -err); 1874 if (IS_ERR(sock)) {
1875 status = PTR_ERR(sock);
1678 goto out; 1876 goto out;
1679 } 1877 }
1680 xs_reclassify_socket4(sock); 1878 } else {
1879 int abort_and_exit;
1681 1880
1682 if (xs_bind4(transport, sock) < 0) { 1881 abort_and_exit = test_and_clear_bit(XPRT_CONNECTION_ABORT,
1683 sock_release(sock); 1882 &xprt->state);
1684 goto out;
1685 }
1686 } else
1687 /* "close" the socket, preserving the local port */ 1883 /* "close" the socket, preserving the local port */
1688 xs_tcp_reuse_connection(xprt); 1884 xs_tcp_reuse_connection(xprt, transport);
1885
1886 if (abort_and_exit)
1887 goto out_eagain;
1888 }
1689 1889
1690 dprintk("RPC: worker connecting xprt %p to address: %s\n", 1890 dprintk("RPC: worker connecting xprt %p via %s to "
1691 xprt, xprt->address_strings[RPC_DISPLAY_ALL]); 1891 "%s (port %s)\n", xprt,
1892 xprt->address_strings[RPC_DISPLAY_PROTO],
1893 xprt->address_strings[RPC_DISPLAY_ADDR],
1894 xprt->address_strings[RPC_DISPLAY_PORT]);
1692 1895
1693 status = xs_tcp_finish_connecting(xprt, sock); 1896 status = xs_tcp_finish_connecting(xprt, sock);
1694 dprintk("RPC: %p connect status %d connected %d sock state %d\n", 1897 dprintk("RPC: %p connect status %d connected %d sock state %d\n",
1695 xprt, -status, xprt_connected(xprt), 1898 xprt, -status, xprt_connected(xprt),
1696 sock->sk->sk_state); 1899 sock->sk->sk_state);
1697 if (status < 0) { 1900 switch (status) {
1698 switch (status) { 1901 default:
1699 case -EINPROGRESS: 1902 printk("%s: connect returned unhandled error %d\n",
1700 case -EALREADY: 1903 __func__, status);
1701 goto out_clear; 1904 case -EADDRNOTAVAIL:
1702 case -ECONNREFUSED: 1905 /* We're probably in TIME_WAIT. Get rid of existing socket,
1703 case -ECONNRESET: 1906 * and retry
1704 /* retry with existing socket, after a delay */ 1907 */
1705 break; 1908 set_bit(XPRT_CONNECTION_CLOSE, &xprt->state);
1706 default: 1909 xprt_force_disconnect(xprt);
1707 /* get rid of existing socket, and retry */ 1910 break;
1708 xs_tcp_shutdown(xprt); 1911 case -ECONNREFUSED:
1709 } 1912 case -ECONNRESET:
1913 case -ENETUNREACH:
1914 /* retry with existing socket, after a delay */
1915 case 0:
1916 case -EINPROGRESS:
1917 case -EALREADY:
1918 xprt_clear_connecting(xprt);
1919 return;
1710 } 1920 }
1921out_eagain:
1922 status = -EAGAIN;
1711out: 1923out:
1712 xprt_wake_pending_tasks(xprt, status);
1713out_clear:
1714 xprt_clear_connecting(xprt); 1924 xprt_clear_connecting(xprt);
1925 xprt_wake_pending_tasks(xprt, status);
1926}
1927
1928static struct socket *xs_create_tcp_sock4(struct rpc_xprt *xprt,
1929 struct sock_xprt *transport)
1930{
1931 struct socket *sock;
1932 int err;
1933
1934 /* start from scratch */
1935 err = sock_create_kern(PF_INET, SOCK_STREAM, IPPROTO_TCP, &sock);
1936 if (err < 0) {
1937 dprintk("RPC: can't create TCP transport socket (%d).\n",
1938 -err);
1939 goto out_err;
1940 }
1941 xs_reclassify_socket4(sock);
1942
1943 if (xs_bind4(transport, sock) < 0) {
1944 sock_release(sock);
1945 goto out_err;
1946 }
1947 return sock;
1948out_err:
1949 return ERR_PTR(-EIO);
1715} 1950}
1716 1951
1717/** 1952/**
1718 * xs_tcp_connect_worker6 - connect a TCP socket to a remote endpoint 1953 * xs_tcp_connect_worker4 - connect a TCP socket to a remote endpoint
1719 * @work: RPC transport to connect 1954 * @work: RPC transport to connect
1720 * 1955 *
1721 * Invoked by a work queue tasklet. 1956 * Invoked by a work queue tasklet.
1722 */ 1957 */
1723static void xs_tcp_connect_worker6(struct work_struct *work) 1958static void xs_tcp_connect_worker4(struct work_struct *work)
1724{ 1959{
1725 struct sock_xprt *transport = 1960 struct sock_xprt *transport =
1726 container_of(work, struct sock_xprt, connect_worker.work); 1961 container_of(work, struct sock_xprt, connect_worker.work);
1727 struct rpc_xprt *xprt = &transport->xprt; 1962 struct rpc_xprt *xprt = &transport->xprt;
1728 struct socket *sock = transport->sock;
1729 int err, status = -EIO;
1730 1963
1731 if (xprt->shutdown || !xprt_bound(xprt)) 1964 xs_tcp_setup_socket(xprt, transport, xs_create_tcp_sock4);
1732 goto out; 1965}
1733
1734 if (!sock) {
1735 /* start from scratch */
1736 if ((err = sock_create_kern(PF_INET6, SOCK_STREAM, IPPROTO_TCP, &sock)) < 0) {
1737 dprintk("RPC: can't create TCP transport socket (%d).\n", -err);
1738 goto out;
1739 }
1740 xs_reclassify_socket6(sock);
1741 1966
1742 if (xs_bind6(transport, sock) < 0) { 1967static struct socket *xs_create_tcp_sock6(struct rpc_xprt *xprt,
1743 sock_release(sock); 1968 struct sock_xprt *transport)
1744 goto out; 1969{
1745 } 1970 struct socket *sock;
1746 } else 1971 int err;
1747 /* "close" the socket, preserving the local port */
1748 xs_tcp_reuse_connection(xprt);
1749 1972
1750 dprintk("RPC: worker connecting xprt %p to address: %s\n", 1973 /* start from scratch */
1751 xprt, xprt->address_strings[RPC_DISPLAY_ALL]); 1974 err = sock_create_kern(PF_INET6, SOCK_STREAM, IPPROTO_TCP, &sock);
1975 if (err < 0) {
1976 dprintk("RPC: can't create TCP transport socket (%d).\n",
1977 -err);
1978 goto out_err;
1979 }
1980 xs_reclassify_socket6(sock);
1752 1981
1753 status = xs_tcp_finish_connecting(xprt, sock); 1982 if (xs_bind6(transport, sock) < 0) {
1754 dprintk("RPC: %p connect status %d connected %d sock state %d\n", 1983 sock_release(sock);
1755 xprt, -status, xprt_connected(xprt), sock->sk->sk_state); 1984 goto out_err;
1756 if (status < 0) {
1757 switch (status) {
1758 case -EINPROGRESS:
1759 case -EALREADY:
1760 goto out_clear;
1761 case -ECONNREFUSED:
1762 case -ECONNRESET:
1763 /* retry with existing socket, after a delay */
1764 break;
1765 default:
1766 /* get rid of existing socket, and retry */
1767 xs_tcp_shutdown(xprt);
1768 }
1769 } 1985 }
1770out: 1986 return sock;
1771 xprt_wake_pending_tasks(xprt, status); 1987out_err:
1772out_clear: 1988 return ERR_PTR(-EIO);
1773 xprt_clear_connecting(xprt); 1989}
1990
1991/**
1992 * xs_tcp_connect_worker6 - connect a TCP socket to a remote endpoint
1993 * @work: RPC transport to connect
1994 *
1995 * Invoked by a work queue tasklet.
1996 */
1997static void xs_tcp_connect_worker6(struct work_struct *work)
1998{
1999 struct sock_xprt *transport =
2000 container_of(work, struct sock_xprt, connect_worker.work);
2001 struct rpc_xprt *xprt = &transport->xprt;
2002
2003 xs_tcp_setup_socket(xprt, transport, xs_create_tcp_sock6);
1774} 2004}
1775 2005
1776/** 2006/**
@@ -1815,9 +2045,6 @@ static void xs_tcp_connect(struct rpc_task *task)
1815{ 2045{
1816 struct rpc_xprt *xprt = task->tk_xprt; 2046 struct rpc_xprt *xprt = task->tk_xprt;
1817 2047
1818 /* Initiate graceful shutdown of the socket if not already done */
1819 if (test_bit(XPRT_CONNECTED, &xprt->state))
1820 xs_tcp_shutdown(xprt);
1821 /* Exit if we need to wait for socket shutdown to complete */ 2048 /* Exit if we need to wait for socket shutdown to complete */
1822 if (test_bit(XPRT_CLOSING, &xprt->state)) 2049 if (test_bit(XPRT_CLOSING, &xprt->state))
1823 return; 2050 return;
@@ -1835,7 +2062,7 @@ static void xs_udp_print_stats(struct rpc_xprt *xprt, struct seq_file *seq)
1835 struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt); 2062 struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
1836 2063
1837 seq_printf(seq, "\txprt:\tudp %u %lu %lu %lu %lu %Lu %Lu\n", 2064 seq_printf(seq, "\txprt:\tudp %u %lu %lu %lu %lu %Lu %Lu\n",
1838 transport->port, 2065 transport->srcport,
1839 xprt->stat.bind_count, 2066 xprt->stat.bind_count,
1840 xprt->stat.sends, 2067 xprt->stat.sends,
1841 xprt->stat.recvs, 2068 xprt->stat.recvs,
@@ -1859,7 +2086,7 @@ static void xs_tcp_print_stats(struct rpc_xprt *xprt, struct seq_file *seq)
1859 idle_time = (long)(jiffies - xprt->last_used) / HZ; 2086 idle_time = (long)(jiffies - xprt->last_used) / HZ;
1860 2087
1861 seq_printf(seq, "\txprt:\ttcp %u %lu %lu %lu %ld %lu %lu %lu %Lu %Lu\n", 2088 seq_printf(seq, "\txprt:\ttcp %u %lu %lu %lu %ld %lu %lu %lu %Lu %Lu\n",
1862 transport->port, 2089 transport->srcport,
1863 xprt->stat.bind_count, 2090 xprt->stat.bind_count,
1864 xprt->stat.connect_count, 2091 xprt->stat.connect_count,
1865 xprt->stat.connect_time, 2092 xprt->stat.connect_time,
@@ -1899,7 +2126,10 @@ static struct rpc_xprt_ops xs_tcp_ops = {
1899 .buf_free = rpc_free, 2126 .buf_free = rpc_free,
1900 .send_request = xs_tcp_send_request, 2127 .send_request = xs_tcp_send_request,
1901 .set_retrans_timeout = xprt_set_retrans_timeout_def, 2128 .set_retrans_timeout = xprt_set_retrans_timeout_def,
1902 .close = xs_tcp_shutdown, 2129#if defined(CONFIG_NFS_V4_1)
2130 .release_request = bc_release_request,
2131#endif /* CONFIG_NFS_V4_1 */
2132 .close = xs_tcp_close,
1903 .destroy = xs_destroy, 2133 .destroy = xs_destroy,
1904 .print_stats = xs_tcp_print_stats, 2134 .print_stats = xs_tcp_print_stats,
1905}; 2135};
@@ -1935,7 +2165,7 @@ static struct rpc_xprt *xs_setup_xprt(struct xprt_create *args,
1935 memcpy(&xprt->addr, args->dstaddr, args->addrlen); 2165 memcpy(&xprt->addr, args->dstaddr, args->addrlen);
1936 xprt->addrlen = args->addrlen; 2166 xprt->addrlen = args->addrlen;
1937 if (args->srcaddr) 2167 if (args->srcaddr)
1938 memcpy(&new->addr, args->srcaddr, args->addrlen); 2168 memcpy(&new->srcaddr, args->srcaddr, args->addrlen);
1939 2169
1940 return xprt; 2170 return xprt;
1941} 2171}
@@ -1984,7 +2214,7 @@ static struct rpc_xprt *xs_setup_udp(struct xprt_create *args)
1984 2214
1985 INIT_DELAYED_WORK(&transport->connect_worker, 2215 INIT_DELAYED_WORK(&transport->connect_worker,
1986 xs_udp_connect_worker4); 2216 xs_udp_connect_worker4);
1987 xs_format_ipv4_peer_addresses(xprt, "udp", RPCBIND_NETID_UDP); 2217 xs_format_peer_addresses(xprt, "udp", RPCBIND_NETID_UDP);
1988 break; 2218 break;
1989 case AF_INET6: 2219 case AF_INET6:
1990 if (((struct sockaddr_in6 *)addr)->sin6_port != htons(0)) 2220 if (((struct sockaddr_in6 *)addr)->sin6_port != htons(0))
@@ -1992,15 +2222,22 @@ static struct rpc_xprt *xs_setup_udp(struct xprt_create *args)
1992 2222
1993 INIT_DELAYED_WORK(&transport->connect_worker, 2223 INIT_DELAYED_WORK(&transport->connect_worker,
1994 xs_udp_connect_worker6); 2224 xs_udp_connect_worker6);
1995 xs_format_ipv6_peer_addresses(xprt, "udp", RPCBIND_NETID_UDP6); 2225 xs_format_peer_addresses(xprt, "udp", RPCBIND_NETID_UDP6);
1996 break; 2226 break;
1997 default: 2227 default:
1998 kfree(xprt); 2228 kfree(xprt);
1999 return ERR_PTR(-EAFNOSUPPORT); 2229 return ERR_PTR(-EAFNOSUPPORT);
2000 } 2230 }
2001 2231
2002 dprintk("RPC: set up transport to address %s\n", 2232 if (xprt_bound(xprt))
2003 xprt->address_strings[RPC_DISPLAY_ALL]); 2233 dprintk("RPC: set up xprt to %s (port %s) via %s\n",
2234 xprt->address_strings[RPC_DISPLAY_ADDR],
2235 xprt->address_strings[RPC_DISPLAY_PORT],
2236 xprt->address_strings[RPC_DISPLAY_PROTO]);
2237 else
2238 dprintk("RPC: set up xprt to %s (autobind) via %s\n",
2239 xprt->address_strings[RPC_DISPLAY_ADDR],
2240 xprt->address_strings[RPC_DISPLAY_PROTO]);
2004 2241
2005 if (try_module_get(THIS_MODULE)) 2242 if (try_module_get(THIS_MODULE))
2006 return xprt; 2243 return xprt;
@@ -2049,23 +2286,33 @@ static struct rpc_xprt *xs_setup_tcp(struct xprt_create *args)
2049 if (((struct sockaddr_in *)addr)->sin_port != htons(0)) 2286 if (((struct sockaddr_in *)addr)->sin_port != htons(0))
2050 xprt_set_bound(xprt); 2287 xprt_set_bound(xprt);
2051 2288
2052 INIT_DELAYED_WORK(&transport->connect_worker, xs_tcp_connect_worker4); 2289 INIT_DELAYED_WORK(&transport->connect_worker,
2053 xs_format_ipv4_peer_addresses(xprt, "tcp", RPCBIND_NETID_TCP); 2290 xs_tcp_connect_worker4);
2291 xs_format_peer_addresses(xprt, "tcp", RPCBIND_NETID_TCP);
2054 break; 2292 break;
2055 case AF_INET6: 2293 case AF_INET6:
2056 if (((struct sockaddr_in6 *)addr)->sin6_port != htons(0)) 2294 if (((struct sockaddr_in6 *)addr)->sin6_port != htons(0))
2057 xprt_set_bound(xprt); 2295 xprt_set_bound(xprt);
2058 2296
2059 INIT_DELAYED_WORK(&transport->connect_worker, xs_tcp_connect_worker6); 2297 INIT_DELAYED_WORK(&transport->connect_worker,
2060 xs_format_ipv6_peer_addresses(xprt, "tcp", RPCBIND_NETID_TCP6); 2298 xs_tcp_connect_worker6);
2299 xs_format_peer_addresses(xprt, "tcp", RPCBIND_NETID_TCP6);
2061 break; 2300 break;
2062 default: 2301 default:
2063 kfree(xprt); 2302 kfree(xprt);
2064 return ERR_PTR(-EAFNOSUPPORT); 2303 return ERR_PTR(-EAFNOSUPPORT);
2065 } 2304 }
2066 2305
2067 dprintk("RPC: set up transport to address %s\n", 2306 if (xprt_bound(xprt))
2068 xprt->address_strings[RPC_DISPLAY_ALL]); 2307 dprintk("RPC: set up xprt to %s (port %s) via %s\n",
2308 xprt->address_strings[RPC_DISPLAY_ADDR],
2309 xprt->address_strings[RPC_DISPLAY_PORT],
2310 xprt->address_strings[RPC_DISPLAY_PROTO]);
2311 else
2312 dprintk("RPC: set up xprt to %s (autobind) via %s\n",
2313 xprt->address_strings[RPC_DISPLAY_ADDR],
2314 xprt->address_strings[RPC_DISPLAY_PROTO]);
2315
2069 2316
2070 if (try_module_get(THIS_MODULE)) 2317 if (try_module_get(THIS_MODULE))
2071 return xprt; 2318 return xprt;
@@ -2124,3 +2371,55 @@ void cleanup_socket_xprt(void)
2124 xprt_unregister_transport(&xs_udp_transport); 2371 xprt_unregister_transport(&xs_udp_transport);
2125 xprt_unregister_transport(&xs_tcp_transport); 2372 xprt_unregister_transport(&xs_tcp_transport);
2126} 2373}
2374
2375static int param_set_uint_minmax(const char *val, struct kernel_param *kp,
2376 unsigned int min, unsigned int max)
2377{
2378 unsigned long num;
2379 int ret;
2380
2381 if (!val)
2382 return -EINVAL;
2383 ret = strict_strtoul(val, 0, &num);
2384 if (ret == -EINVAL || num < min || num > max)
2385 return -EINVAL;
2386 *((unsigned int *)kp->arg) = num;
2387 return 0;
2388}
2389
2390static int param_set_portnr(const char *val, struct kernel_param *kp)
2391{
2392 return param_set_uint_minmax(val, kp,
2393 RPC_MIN_RESVPORT,
2394 RPC_MAX_RESVPORT);
2395}
2396
2397static int param_get_portnr(char *buffer, struct kernel_param *kp)
2398{
2399 return param_get_uint(buffer, kp);
2400}
2401#define param_check_portnr(name, p) \
2402 __param_check(name, p, unsigned int);
2403
2404module_param_named(min_resvport, xprt_min_resvport, portnr, 0644);
2405module_param_named(max_resvport, xprt_max_resvport, portnr, 0644);
2406
2407static int param_set_slot_table_size(const char *val, struct kernel_param *kp)
2408{
2409 return param_set_uint_minmax(val, kp,
2410 RPC_MIN_SLOT_TABLE,
2411 RPC_MAX_SLOT_TABLE);
2412}
2413
2414static int param_get_slot_table_size(char *buffer, struct kernel_param *kp)
2415{
2416 return param_get_uint(buffer, kp);
2417}
2418#define param_check_slot_table_size(name, p) \
2419 __param_check(name, p, unsigned int);
2420
2421module_param_named(tcp_slot_table_entries, xprt_tcp_slot_table_entries,
2422 slot_table_size, 0644);
2423module_param_named(udp_slot_table_entries, xprt_udp_slot_table_entries,
2424 slot_table_size, 0644);
2425
generated by cgit v1.2.2 (git 2.25.0) at 2025-09-17 22:10:39 -0400