1a246b010SChuck Lever /* 2a246b010SChuck Lever * linux/net/sunrpc/xprtsock.c 3a246b010SChuck Lever * 4a246b010SChuck Lever * Client-side transport implementation for sockets. 5a246b010SChuck Lever * 6a246b010SChuck Lever * TCP callback races fixes (C) 1998 Red Hat Software <alan@redhat.com> 7a246b010SChuck Lever * TCP send fixes (C) 1998 Red Hat Software <alan@redhat.com> 8a246b010SChuck Lever * TCP NFS related read + write fixes 9a246b010SChuck Lever * (C) 1999 Dave Airlie, University of Limerick, Ireland <airlied@linux.ie> 10a246b010SChuck Lever * 11a246b010SChuck Lever * Rewrite of larges part of the code in order to stabilize TCP stuff. 12a246b010SChuck Lever * Fix behaviour when socket buffer is full. 13a246b010SChuck Lever * (C) 1999 Trond Myklebust <trond.myklebust@fys.uio.no> 1455aa4f58SChuck Lever * 1555aa4f58SChuck Lever * IP socket transport implementation, (C) 2005 Chuck Lever <cel@netapp.com> 168f9d5b1aSChuck Lever * 178f9d5b1aSChuck Lever * IPv6 support contributed by Gilles Quillard, Bull Open Source, 2005. 188f9d5b1aSChuck Lever * <gilles.quillard@bull.net> 19a246b010SChuck Lever */ 20a246b010SChuck Lever 21a246b010SChuck Lever #include <linux/types.h> 22a246b010SChuck Lever #include <linux/slab.h> 23bc25571eS\"Talpey, Thomas\ #include <linux/module.h> 24a246b010SChuck Lever #include <linux/capability.h> 25a246b010SChuck Lever #include <linux/pagemap.h> 26a246b010SChuck Lever #include <linux/errno.h> 27a246b010SChuck Lever #include <linux/socket.h> 28a246b010SChuck Lever #include <linux/in.h> 29a246b010SChuck Lever #include <linux/net.h> 30a246b010SChuck Lever #include <linux/mm.h> 31a246b010SChuck Lever #include <linux/udp.h> 32a246b010SChuck Lever #include <linux/tcp.h> 33a246b010SChuck Lever #include <linux/sunrpc/clnt.h> 3402107148SChuck Lever #include <linux/sunrpc/sched.h> 3549c36fccS\"Talpey, Thomas\ #include <linux/sunrpc/xprtsock.h> 36a246b010SChuck Lever #include <linux/file.h> 37a246b010SChuck Lever 38a246b010SChuck Lever #include <net/sock.h> 39a246b010SChuck Lever #include <net/checksum.h> 40a246b010SChuck Lever #include <net/udp.h> 41a246b010SChuck Lever #include <net/tcp.h> 42a246b010SChuck Lever 439903cd1cSChuck Lever /* 44c556b754SChuck Lever * xprtsock tunables 45c556b754SChuck Lever */ 46c556b754SChuck Lever unsigned int xprt_udp_slot_table_entries = RPC_DEF_SLOT_TABLE; 47c556b754SChuck Lever unsigned int xprt_tcp_slot_table_entries = RPC_DEF_SLOT_TABLE; 48c556b754SChuck Lever 49c556b754SChuck Lever unsigned int xprt_min_resvport = RPC_DEF_MIN_RESVPORT; 50c556b754SChuck Lever unsigned int xprt_max_resvport = RPC_DEF_MAX_RESVPORT; 51c556b754SChuck Lever 52c556b754SChuck Lever /* 53fbf76683SChuck Lever * We can register our own files under /proc/sys/sunrpc by 54fbf76683SChuck Lever * calling register_sysctl_table() again. The files in that 55fbf76683SChuck Lever * directory become the union of all files registered there. 56fbf76683SChuck Lever * 57fbf76683SChuck Lever * We simply need to make sure that we don't collide with 58fbf76683SChuck Lever * someone else's file names! 59fbf76683SChuck Lever */ 60fbf76683SChuck Lever 61fbf76683SChuck Lever #ifdef RPC_DEBUG 62fbf76683SChuck Lever 63fbf76683SChuck Lever static unsigned int min_slot_table_size = RPC_MIN_SLOT_TABLE; 64fbf76683SChuck Lever static unsigned int max_slot_table_size = RPC_MAX_SLOT_TABLE; 65fbf76683SChuck Lever static unsigned int xprt_min_resvport_limit = RPC_MIN_RESVPORT; 66fbf76683SChuck Lever static unsigned int xprt_max_resvport_limit = RPC_MAX_RESVPORT; 67fbf76683SChuck Lever 68fbf76683SChuck Lever static struct ctl_table_header *sunrpc_table_header; 69fbf76683SChuck Lever 70fbf76683SChuck Lever /* 71fbf76683SChuck Lever * FIXME: changing the UDP slot table size should also resize the UDP 72fbf76683SChuck Lever * socket buffers for existing UDP transports 73fbf76683SChuck Lever */ 74fbf76683SChuck Lever static ctl_table xs_tunables_table[] = { 75fbf76683SChuck Lever { 76fbf76683SChuck Lever .ctl_name = CTL_SLOTTABLE_UDP, 77fbf76683SChuck Lever .procname = "udp_slot_table_entries", 78fbf76683SChuck Lever .data = &xprt_udp_slot_table_entries, 79fbf76683SChuck Lever .maxlen = sizeof(unsigned int), 80fbf76683SChuck Lever .mode = 0644, 81fbf76683SChuck Lever .proc_handler = &proc_dointvec_minmax, 82fbf76683SChuck Lever .strategy = &sysctl_intvec, 83fbf76683SChuck Lever .extra1 = &min_slot_table_size, 84fbf76683SChuck Lever .extra2 = &max_slot_table_size 85fbf76683SChuck Lever }, 86fbf76683SChuck Lever { 87fbf76683SChuck Lever .ctl_name = CTL_SLOTTABLE_TCP, 88fbf76683SChuck Lever .procname = "tcp_slot_table_entries", 89fbf76683SChuck Lever .data = &xprt_tcp_slot_table_entries, 90fbf76683SChuck Lever .maxlen = sizeof(unsigned int), 91fbf76683SChuck Lever .mode = 0644, 92fbf76683SChuck Lever .proc_handler = &proc_dointvec_minmax, 93fbf76683SChuck Lever .strategy = &sysctl_intvec, 94fbf76683SChuck Lever .extra1 = &min_slot_table_size, 95fbf76683SChuck Lever .extra2 = &max_slot_table_size 96fbf76683SChuck Lever }, 97fbf76683SChuck Lever { 98fbf76683SChuck Lever .ctl_name = CTL_MIN_RESVPORT, 99fbf76683SChuck Lever .procname = "min_resvport", 100fbf76683SChuck Lever .data = &xprt_min_resvport, 101fbf76683SChuck Lever .maxlen = sizeof(unsigned int), 102fbf76683SChuck Lever .mode = 0644, 103fbf76683SChuck Lever .proc_handler = &proc_dointvec_minmax, 104fbf76683SChuck Lever .strategy = &sysctl_intvec, 105fbf76683SChuck Lever .extra1 = &xprt_min_resvport_limit, 106fbf76683SChuck Lever .extra2 = &xprt_max_resvport_limit 107fbf76683SChuck Lever }, 108fbf76683SChuck Lever { 109fbf76683SChuck Lever .ctl_name = CTL_MAX_RESVPORT, 110fbf76683SChuck Lever .procname = "max_resvport", 111fbf76683SChuck Lever .data = &xprt_max_resvport, 112fbf76683SChuck Lever .maxlen = sizeof(unsigned int), 113fbf76683SChuck Lever .mode = 0644, 114fbf76683SChuck Lever .proc_handler = &proc_dointvec_minmax, 115fbf76683SChuck Lever .strategy = &sysctl_intvec, 116fbf76683SChuck Lever .extra1 = &xprt_min_resvport_limit, 117fbf76683SChuck Lever .extra2 = &xprt_max_resvport_limit 118fbf76683SChuck Lever }, 119fbf76683SChuck Lever { 120fbf76683SChuck Lever .ctl_name = 0, 121fbf76683SChuck Lever }, 122fbf76683SChuck Lever }; 123fbf76683SChuck Lever 124fbf76683SChuck Lever static ctl_table sunrpc_table[] = { 125fbf76683SChuck Lever { 126fbf76683SChuck Lever .ctl_name = CTL_SUNRPC, 127fbf76683SChuck Lever .procname = "sunrpc", 128fbf76683SChuck Lever .mode = 0555, 129fbf76683SChuck Lever .child = xs_tunables_table 130fbf76683SChuck Lever }, 131fbf76683SChuck Lever { 132fbf76683SChuck Lever .ctl_name = 0, 133fbf76683SChuck Lever }, 134fbf76683SChuck Lever }; 135fbf76683SChuck Lever 136fbf76683SChuck Lever #endif 137fbf76683SChuck Lever 138fbf76683SChuck Lever /* 139262965f5SChuck Lever * How many times to try sending a request on a socket before waiting 140262965f5SChuck Lever * for the socket buffer to clear. 141262965f5SChuck Lever */ 142262965f5SChuck Lever #define XS_SENDMSG_RETRY (10U) 143262965f5SChuck Lever 14403bf4b70SChuck Lever /* 14503bf4b70SChuck Lever * Time out for an RPC UDP socket connect. UDP socket connects are 14603bf4b70SChuck Lever * synchronous, but we set a timeout anyway in case of resource 14703bf4b70SChuck Lever * exhaustion on the local host. 14803bf4b70SChuck Lever */ 14903bf4b70SChuck Lever #define XS_UDP_CONN_TO (5U * HZ) 15003bf4b70SChuck Lever 15103bf4b70SChuck Lever /* 15203bf4b70SChuck Lever * Wait duration for an RPC TCP connection to be established. Solaris 15303bf4b70SChuck Lever * NFS over TCP uses 60 seconds, for example, which is in line with how 15403bf4b70SChuck Lever * long a server takes to reboot. 15503bf4b70SChuck Lever */ 15603bf4b70SChuck Lever #define XS_TCP_CONN_TO (60U * HZ) 15703bf4b70SChuck Lever 15803bf4b70SChuck Lever /* 15903bf4b70SChuck Lever * Wait duration for a reply from the RPC portmapper. 16003bf4b70SChuck Lever */ 16103bf4b70SChuck Lever #define XS_BIND_TO (60U * HZ) 16203bf4b70SChuck Lever 16303bf4b70SChuck Lever /* 16403bf4b70SChuck Lever * Delay if a UDP socket connect error occurs. This is most likely some 16503bf4b70SChuck Lever * kind of resource problem on the local host. 16603bf4b70SChuck Lever */ 16703bf4b70SChuck Lever #define XS_UDP_REEST_TO (2U * HZ) 16803bf4b70SChuck Lever 16903bf4b70SChuck Lever /* 17003bf4b70SChuck Lever * The reestablish timeout allows clients to delay for a bit before attempting 17103bf4b70SChuck Lever * to reconnect to a server that just dropped our connection. 17203bf4b70SChuck Lever * 17303bf4b70SChuck Lever * We implement an exponential backoff when trying to reestablish a TCP 17403bf4b70SChuck Lever * transport connection with the server. Some servers like to drop a TCP 17503bf4b70SChuck Lever * connection when they are overworked, so we start with a short timeout and 17603bf4b70SChuck Lever * increase over time if the server is down or not responding. 17703bf4b70SChuck Lever */ 17803bf4b70SChuck Lever #define XS_TCP_INIT_REEST_TO (3U * HZ) 17903bf4b70SChuck Lever #define XS_TCP_MAX_REEST_TO (5U * 60 * HZ) 18003bf4b70SChuck Lever 18103bf4b70SChuck Lever /* 18203bf4b70SChuck Lever * TCP idle timeout; client drops the transport socket if it is idle 18303bf4b70SChuck Lever * for this long. Note that we also timeout UDP sockets to prevent 18403bf4b70SChuck Lever * holding port numbers when there is no RPC traffic. 18503bf4b70SChuck Lever */ 18603bf4b70SChuck Lever #define XS_IDLE_DISC_TO (5U * 60 * HZ) 18703bf4b70SChuck Lever 188a246b010SChuck Lever #ifdef RPC_DEBUG 189a246b010SChuck Lever # undef RPC_DEBUG_DATA 1909903cd1cSChuck Lever # define RPCDBG_FACILITY RPCDBG_TRANS 191a246b010SChuck Lever #endif 192a246b010SChuck Lever 193a246b010SChuck Lever #ifdef RPC_DEBUG_DATA 1949903cd1cSChuck Lever static void xs_pktdump(char *msg, u32 *packet, unsigned int count) 195a246b010SChuck Lever { 196a246b010SChuck Lever u8 *buf = (u8 *) packet; 197a246b010SChuck Lever int j; 198a246b010SChuck Lever 199a246b010SChuck Lever dprintk("RPC: %s\n", msg); 200a246b010SChuck Lever for (j = 0; j < count && j < 128; j += 4) { 201a246b010SChuck Lever if (!(j & 31)) { 202a246b010SChuck Lever if (j) 203a246b010SChuck Lever dprintk("\n"); 204a246b010SChuck Lever dprintk("0x%04x ", j); 205a246b010SChuck Lever } 206a246b010SChuck Lever dprintk("%02x%02x%02x%02x ", 207a246b010SChuck Lever buf[j], buf[j+1], buf[j+2], buf[j+3]); 208a246b010SChuck Lever } 209a246b010SChuck Lever dprintk("\n"); 210a246b010SChuck Lever } 211a246b010SChuck Lever #else 2129903cd1cSChuck Lever static inline void xs_pktdump(char *msg, u32 *packet, unsigned int count) 213a246b010SChuck Lever { 214a246b010SChuck Lever /* NOP */ 215a246b010SChuck Lever } 216a246b010SChuck Lever #endif 217a246b010SChuck Lever 218ffc2e518SChuck Lever struct sock_xprt { 219ffc2e518SChuck Lever struct rpc_xprt xprt; 220ee0ac0c2SChuck Lever 221ee0ac0c2SChuck Lever /* 222ee0ac0c2SChuck Lever * Network layer 223ee0ac0c2SChuck Lever */ 224ee0ac0c2SChuck Lever struct socket * sock; 225ee0ac0c2SChuck Lever struct sock * inet; 22651971139SChuck Lever 22751971139SChuck Lever /* 22851971139SChuck Lever * State of TCP reply receive 22951971139SChuck Lever */ 23051971139SChuck Lever __be32 tcp_fraghdr, 23151971139SChuck Lever tcp_xid; 23251971139SChuck Lever 23351971139SChuck Lever u32 tcp_offset, 23451971139SChuck Lever tcp_reclen; 23551971139SChuck Lever 23651971139SChuck Lever unsigned long tcp_copied, 23751971139SChuck Lever tcp_flags; 238c8475461SChuck Lever 239c8475461SChuck Lever /* 240c8475461SChuck Lever * Connection of transports 241c8475461SChuck Lever */ 24234161db6STrond Myklebust struct delayed_work connect_worker; 243d3bc9a1dSFrank van Maarseveen struct sockaddr_storage addr; 244c8475461SChuck Lever unsigned short port; 2457c6e066eSChuck Lever 2467c6e066eSChuck Lever /* 2477c6e066eSChuck Lever * UDP socket buffer size parameters 2487c6e066eSChuck Lever */ 2497c6e066eSChuck Lever size_t rcvsize, 2507c6e066eSChuck Lever sndsize; 251314dfd79SChuck Lever 252314dfd79SChuck Lever /* 253314dfd79SChuck Lever * Saved socket callback addresses 254314dfd79SChuck Lever */ 255314dfd79SChuck Lever void (*old_data_ready)(struct sock *, int); 256314dfd79SChuck Lever void (*old_state_change)(struct sock *); 257314dfd79SChuck Lever void (*old_write_space)(struct sock *); 258ffc2e518SChuck Lever }; 259ffc2e518SChuck Lever 260e136d092SChuck Lever /* 261e136d092SChuck Lever * TCP receive state flags 262e136d092SChuck Lever */ 263e136d092SChuck Lever #define TCP_RCV_LAST_FRAG (1UL << 0) 264e136d092SChuck Lever #define TCP_RCV_COPY_FRAGHDR (1UL << 1) 265e136d092SChuck Lever #define TCP_RCV_COPY_XID (1UL << 2) 266e136d092SChuck Lever #define TCP_RCV_COPY_DATA (1UL << 3) 267e136d092SChuck Lever 26895392c59SChuck Lever static inline struct sockaddr *xs_addr(struct rpc_xprt *xprt) 269edb267a6SChuck Lever { 27095392c59SChuck Lever return (struct sockaddr *) &xprt->addr; 27195392c59SChuck Lever } 27295392c59SChuck Lever 27395392c59SChuck Lever static inline struct sockaddr_in *xs_addr_in(struct rpc_xprt *xprt) 27495392c59SChuck Lever { 27595392c59SChuck Lever return (struct sockaddr_in *) &xprt->addr; 27695392c59SChuck Lever } 27795392c59SChuck Lever 27895392c59SChuck Lever static inline struct sockaddr_in6 *xs_addr_in6(struct rpc_xprt *xprt) 27995392c59SChuck Lever { 28095392c59SChuck Lever return (struct sockaddr_in6 *) &xprt->addr; 28195392c59SChuck Lever } 28295392c59SChuck Lever 283b454ae90SChuck Lever static void xs_format_ipv4_peer_addresses(struct rpc_xprt *xprt, 284b454ae90SChuck Lever const char *protocol, 285b454ae90SChuck Lever const char *netid) 286edb267a6SChuck Lever { 28795392c59SChuck Lever struct sockaddr_in *addr = xs_addr_in(xprt); 288edb267a6SChuck Lever char *buf; 289edb267a6SChuck Lever 290edb267a6SChuck Lever buf = kzalloc(20, GFP_KERNEL); 291edb267a6SChuck Lever if (buf) { 292bda243dfSChuck Lever snprintf(buf, 20, NIPQUAD_FMT, 293edb267a6SChuck Lever NIPQUAD(addr->sin_addr.s_addr)); 294edb267a6SChuck Lever } 295edb267a6SChuck Lever xprt->address_strings[RPC_DISPLAY_ADDR] = buf; 296edb267a6SChuck Lever 297edb267a6SChuck Lever buf = kzalloc(8, GFP_KERNEL); 298edb267a6SChuck Lever if (buf) { 299edb267a6SChuck Lever snprintf(buf, 8, "%u", 300edb267a6SChuck Lever ntohs(addr->sin_port)); 301edb267a6SChuck Lever } 302edb267a6SChuck Lever xprt->address_strings[RPC_DISPLAY_PORT] = buf; 303edb267a6SChuck Lever 304b454ae90SChuck Lever xprt->address_strings[RPC_DISPLAY_PROTO] = protocol; 305edb267a6SChuck Lever 306edb267a6SChuck Lever buf = kzalloc(48, GFP_KERNEL); 307edb267a6SChuck Lever if (buf) { 308bda243dfSChuck Lever snprintf(buf, 48, "addr="NIPQUAD_FMT" port=%u proto=%s", 309edb267a6SChuck Lever NIPQUAD(addr->sin_addr.s_addr), 310edb267a6SChuck Lever ntohs(addr->sin_port), 311b454ae90SChuck Lever protocol); 312edb267a6SChuck Lever } 313edb267a6SChuck Lever xprt->address_strings[RPC_DISPLAY_ALL] = buf; 314fbfe3cc6SChuck Lever 315fbfe3cc6SChuck Lever buf = kzalloc(10, GFP_KERNEL); 316fbfe3cc6SChuck Lever if (buf) { 317fbfe3cc6SChuck Lever snprintf(buf, 10, "%02x%02x%02x%02x", 318fbfe3cc6SChuck Lever NIPQUAD(addr->sin_addr.s_addr)); 319fbfe3cc6SChuck Lever } 320fbfe3cc6SChuck Lever xprt->address_strings[RPC_DISPLAY_HEX_ADDR] = buf; 321fbfe3cc6SChuck Lever 322fbfe3cc6SChuck Lever buf = kzalloc(8, GFP_KERNEL); 323fbfe3cc6SChuck Lever if (buf) { 324fbfe3cc6SChuck Lever snprintf(buf, 8, "%4hx", 325fbfe3cc6SChuck Lever ntohs(addr->sin_port)); 326fbfe3cc6SChuck Lever } 327fbfe3cc6SChuck Lever xprt->address_strings[RPC_DISPLAY_HEX_PORT] = buf; 328756805e7SChuck Lever 329756805e7SChuck Lever buf = kzalloc(30, GFP_KERNEL); 330756805e7SChuck Lever if (buf) { 331756805e7SChuck Lever snprintf(buf, 30, NIPQUAD_FMT".%u.%u", 332756805e7SChuck Lever NIPQUAD(addr->sin_addr.s_addr), 333756805e7SChuck Lever ntohs(addr->sin_port) >> 8, 334756805e7SChuck Lever ntohs(addr->sin_port) & 0xff); 335756805e7SChuck Lever } 336756805e7SChuck Lever xprt->address_strings[RPC_DISPLAY_UNIVERSAL_ADDR] = buf; 3374417c8c4S\"Talpey, Thomas\ 338b454ae90SChuck Lever xprt->address_strings[RPC_DISPLAY_NETID] = netid; 339edb267a6SChuck Lever } 340edb267a6SChuck Lever 341b454ae90SChuck Lever static void xs_format_ipv6_peer_addresses(struct rpc_xprt *xprt, 342b454ae90SChuck Lever const char *protocol, 343b454ae90SChuck Lever const char *netid) 3444b6473fbSChuck Lever { 34595392c59SChuck Lever struct sockaddr_in6 *addr = xs_addr_in6(xprt); 3464b6473fbSChuck Lever char *buf; 3474b6473fbSChuck Lever 3484b6473fbSChuck Lever buf = kzalloc(40, GFP_KERNEL); 3494b6473fbSChuck Lever if (buf) { 3504b6473fbSChuck Lever snprintf(buf, 40, NIP6_FMT, 3514b6473fbSChuck Lever NIP6(addr->sin6_addr)); 3524b6473fbSChuck Lever } 3534b6473fbSChuck Lever xprt->address_strings[RPC_DISPLAY_ADDR] = buf; 3544b6473fbSChuck Lever 3554b6473fbSChuck Lever buf = kzalloc(8, GFP_KERNEL); 3564b6473fbSChuck Lever if (buf) { 3574b6473fbSChuck Lever snprintf(buf, 8, "%u", 3584b6473fbSChuck Lever ntohs(addr->sin6_port)); 3594b6473fbSChuck Lever } 3604b6473fbSChuck Lever xprt->address_strings[RPC_DISPLAY_PORT] = buf; 3614b6473fbSChuck Lever 362b454ae90SChuck Lever xprt->address_strings[RPC_DISPLAY_PROTO] = protocol; 3634b6473fbSChuck Lever 3644b6473fbSChuck Lever buf = kzalloc(64, GFP_KERNEL); 3654b6473fbSChuck Lever if (buf) { 3664b6473fbSChuck Lever snprintf(buf, 64, "addr="NIP6_FMT" port=%u proto=%s", 3674b6473fbSChuck Lever NIP6(addr->sin6_addr), 3684b6473fbSChuck Lever ntohs(addr->sin6_port), 369b454ae90SChuck Lever protocol); 3704b6473fbSChuck Lever } 3714b6473fbSChuck Lever xprt->address_strings[RPC_DISPLAY_ALL] = buf; 3724b6473fbSChuck Lever 3734b6473fbSChuck Lever buf = kzalloc(36, GFP_KERNEL); 3744b6473fbSChuck Lever if (buf) { 3754b6473fbSChuck Lever snprintf(buf, 36, NIP6_SEQFMT, 3764b6473fbSChuck Lever NIP6(addr->sin6_addr)); 3774b6473fbSChuck Lever } 3784b6473fbSChuck Lever xprt->address_strings[RPC_DISPLAY_HEX_ADDR] = buf; 3794b6473fbSChuck Lever 3804b6473fbSChuck Lever buf = kzalloc(8, GFP_KERNEL); 3814b6473fbSChuck Lever if (buf) { 3824b6473fbSChuck Lever snprintf(buf, 8, "%4hx", 3834b6473fbSChuck Lever ntohs(addr->sin6_port)); 3844b6473fbSChuck Lever } 3854b6473fbSChuck Lever xprt->address_strings[RPC_DISPLAY_HEX_PORT] = buf; 386756805e7SChuck Lever 387756805e7SChuck Lever buf = kzalloc(50, GFP_KERNEL); 388756805e7SChuck Lever if (buf) { 389756805e7SChuck Lever snprintf(buf, 50, NIP6_FMT".%u.%u", 390756805e7SChuck Lever NIP6(addr->sin6_addr), 391756805e7SChuck Lever ntohs(addr->sin6_port) >> 8, 392756805e7SChuck Lever ntohs(addr->sin6_port) & 0xff); 393756805e7SChuck Lever } 394756805e7SChuck Lever xprt->address_strings[RPC_DISPLAY_UNIVERSAL_ADDR] = buf; 3954417c8c4S\"Talpey, Thomas\ 396b454ae90SChuck Lever xprt->address_strings[RPC_DISPLAY_NETID] = netid; 397edb267a6SChuck Lever } 398edb267a6SChuck Lever 399edb267a6SChuck Lever static void xs_free_peer_addresses(struct rpc_xprt *xprt) 400edb267a6SChuck Lever { 40133e01dc7SChuck Lever unsigned int i; 40233e01dc7SChuck Lever 40333e01dc7SChuck Lever for (i = 0; i < RPC_DISPLAY_MAX; i++) 40433e01dc7SChuck Lever switch (i) { 40533e01dc7SChuck Lever case RPC_DISPLAY_PROTO: 40633e01dc7SChuck Lever case RPC_DISPLAY_NETID: 40733e01dc7SChuck Lever continue; 40833e01dc7SChuck Lever default: 40933e01dc7SChuck Lever kfree(xprt->address_strings[i]); 41033e01dc7SChuck Lever } 411edb267a6SChuck Lever } 412edb267a6SChuck Lever 413b4b5cc85SChuck Lever #define XS_SENDMSG_FLAGS (MSG_DONTWAIT | MSG_NOSIGNAL) 414b4b5cc85SChuck Lever 41524c5684bSTrond Myklebust static int xs_send_kvec(struct socket *sock, struct sockaddr *addr, int addrlen, struct kvec *vec, unsigned int base, int more) 416b4b5cc85SChuck Lever { 417b4b5cc85SChuck Lever struct msghdr msg = { 418b4b5cc85SChuck Lever .msg_name = addr, 419b4b5cc85SChuck Lever .msg_namelen = addrlen, 42024c5684bSTrond Myklebust .msg_flags = XS_SENDMSG_FLAGS | (more ? MSG_MORE : 0), 42124c5684bSTrond Myklebust }; 42224c5684bSTrond Myklebust struct kvec iov = { 42324c5684bSTrond Myklebust .iov_base = vec->iov_base + base, 42424c5684bSTrond Myklebust .iov_len = vec->iov_len - base, 425b4b5cc85SChuck Lever }; 426b4b5cc85SChuck Lever 42724c5684bSTrond Myklebust if (iov.iov_len != 0) 428b4b5cc85SChuck Lever return kernel_sendmsg(sock, &msg, &iov, 1, iov.iov_len); 429b4b5cc85SChuck Lever return kernel_sendmsg(sock, &msg, NULL, 0, 0); 430b4b5cc85SChuck Lever } 431b4b5cc85SChuck Lever 43224c5684bSTrond Myklebust static int xs_send_pagedata(struct socket *sock, struct xdr_buf *xdr, unsigned int base, int more) 433b4b5cc85SChuck Lever { 43424c5684bSTrond Myklebust struct page **ppage; 43524c5684bSTrond Myklebust unsigned int remainder; 43624c5684bSTrond Myklebust int err, sent = 0; 437b4b5cc85SChuck Lever 43824c5684bSTrond Myklebust remainder = xdr->page_len - base; 43924c5684bSTrond Myklebust base += xdr->page_base; 44024c5684bSTrond Myklebust ppage = xdr->pages + (base >> PAGE_SHIFT); 44124c5684bSTrond Myklebust base &= ~PAGE_MASK; 44224c5684bSTrond Myklebust for(;;) { 44324c5684bSTrond Myklebust unsigned int len = min_t(unsigned int, PAGE_SIZE - base, remainder); 44424c5684bSTrond Myklebust int flags = XS_SENDMSG_FLAGS; 44524c5684bSTrond Myklebust 44624c5684bSTrond Myklebust remainder -= len; 44724c5684bSTrond Myklebust if (remainder != 0 || more) 44824c5684bSTrond Myklebust flags |= MSG_MORE; 44924c5684bSTrond Myklebust err = sock->ops->sendpage(sock, *ppage, base, len, flags); 45024c5684bSTrond Myklebust if (remainder == 0 || err != len) 45124c5684bSTrond Myklebust break; 45224c5684bSTrond Myklebust sent += err; 45324c5684bSTrond Myklebust ppage++; 45424c5684bSTrond Myklebust base = 0; 45524c5684bSTrond Myklebust } 45624c5684bSTrond Myklebust if (sent == 0) 45724c5684bSTrond Myklebust return err; 45824c5684bSTrond Myklebust if (err > 0) 45924c5684bSTrond Myklebust sent += err; 46024c5684bSTrond Myklebust return sent; 461b4b5cc85SChuck Lever } 462b4b5cc85SChuck Lever 4639903cd1cSChuck Lever /** 4649903cd1cSChuck Lever * xs_sendpages - write pages directly to a socket 4659903cd1cSChuck Lever * @sock: socket to send on 4669903cd1cSChuck Lever * @addr: UDP only -- address of destination 4679903cd1cSChuck Lever * @addrlen: UDP only -- length of destination address 4689903cd1cSChuck Lever * @xdr: buffer containing this request 4699903cd1cSChuck Lever * @base: starting position in the buffer 4709903cd1cSChuck Lever * 471a246b010SChuck Lever */ 47224c5684bSTrond Myklebust static int xs_sendpages(struct socket *sock, struct sockaddr *addr, int addrlen, struct xdr_buf *xdr, unsigned int base) 473a246b010SChuck Lever { 47424c5684bSTrond Myklebust unsigned int remainder = xdr->len - base; 47524c5684bSTrond Myklebust int err, sent = 0; 476a246b010SChuck Lever 477262965f5SChuck Lever if (unlikely(!sock)) 478262965f5SChuck Lever return -ENOTCONN; 479262965f5SChuck Lever 480262965f5SChuck Lever clear_bit(SOCK_ASYNC_NOSPACE, &sock->flags); 48124c5684bSTrond Myklebust if (base != 0) { 48224c5684bSTrond Myklebust addr = NULL; 48324c5684bSTrond Myklebust addrlen = 0; 48424c5684bSTrond Myklebust } 485262965f5SChuck Lever 48624c5684bSTrond Myklebust if (base < xdr->head[0].iov_len || addr != NULL) { 48724c5684bSTrond Myklebust unsigned int len = xdr->head[0].iov_len - base; 48824c5684bSTrond Myklebust remainder -= len; 48924c5684bSTrond Myklebust err = xs_send_kvec(sock, addr, addrlen, &xdr->head[0], base, remainder != 0); 49024c5684bSTrond Myklebust if (remainder == 0 || err != len) 491a246b010SChuck Lever goto out; 49224c5684bSTrond Myklebust sent += err; 493a246b010SChuck Lever base = 0; 494a246b010SChuck Lever } else 49524c5684bSTrond Myklebust base -= xdr->head[0].iov_len; 496a246b010SChuck Lever 49724c5684bSTrond Myklebust if (base < xdr->page_len) { 49824c5684bSTrond Myklebust unsigned int len = xdr->page_len - base; 49924c5684bSTrond Myklebust remainder -= len; 50024c5684bSTrond Myklebust err = xs_send_pagedata(sock, xdr, base, remainder != 0); 50124c5684bSTrond Myklebust if (remainder == 0 || err != len) 502a246b010SChuck Lever goto out; 50324c5684bSTrond Myklebust sent += err; 504a246b010SChuck Lever base = 0; 50524c5684bSTrond Myklebust } else 50624c5684bSTrond Myklebust base -= xdr->page_len; 50724c5684bSTrond Myklebust 50824c5684bSTrond Myklebust if (base >= xdr->tail[0].iov_len) 50924c5684bSTrond Myklebust return sent; 51024c5684bSTrond Myklebust err = xs_send_kvec(sock, NULL, 0, &xdr->tail[0], base, 0); 511a246b010SChuck Lever out: 51224c5684bSTrond Myklebust if (sent == 0) 51324c5684bSTrond Myklebust return err; 51424c5684bSTrond Myklebust if (err > 0) 51524c5684bSTrond Myklebust sent += err; 51624c5684bSTrond Myklebust return sent; 517a246b010SChuck Lever } 518a246b010SChuck Lever 5199903cd1cSChuck Lever /** 520262965f5SChuck Lever * xs_nospace - place task on wait queue if transmit was incomplete 521262965f5SChuck Lever * @task: task to put to sleep 5229903cd1cSChuck Lever * 523a246b010SChuck Lever */ 524262965f5SChuck Lever static void xs_nospace(struct rpc_task *task) 525a246b010SChuck Lever { 526262965f5SChuck Lever struct rpc_rqst *req = task->tk_rqstp; 527262965f5SChuck Lever struct rpc_xprt *xprt = req->rq_xprt; 528ee0ac0c2SChuck Lever struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt); 529a246b010SChuck Lever 53046121cf7SChuck Lever dprintk("RPC: %5u xmit incomplete (%u left of %u)\n", 531262965f5SChuck Lever task->tk_pid, req->rq_slen - req->rq_bytes_sent, 532262965f5SChuck Lever req->rq_slen); 533a246b010SChuck Lever 534ee0ac0c2SChuck Lever if (test_bit(SOCK_ASYNC_NOSPACE, &transport->sock->flags)) { 535262965f5SChuck Lever /* Protect against races with write_space */ 536262965f5SChuck Lever spin_lock_bh(&xprt->transport_lock); 537a246b010SChuck Lever 538262965f5SChuck Lever /* Don't race with disconnect */ 539262965f5SChuck Lever if (!xprt_connected(xprt)) 540262965f5SChuck Lever task->tk_status = -ENOTCONN; 541ee0ac0c2SChuck Lever else if (test_bit(SOCK_NOSPACE, &transport->sock->flags)) 542262965f5SChuck Lever xprt_wait_for_buffer_space(task); 543a246b010SChuck Lever 544262965f5SChuck Lever spin_unlock_bh(&xprt->transport_lock); 545262965f5SChuck Lever } else 546262965f5SChuck Lever /* Keep holding the socket if it is blocked */ 547262965f5SChuck Lever rpc_delay(task, HZ>>4); 548a246b010SChuck Lever } 549a246b010SChuck Lever 5509903cd1cSChuck Lever /** 551262965f5SChuck Lever * xs_udp_send_request - write an RPC request to a UDP socket 5529903cd1cSChuck Lever * @task: address of RPC task that manages the state of an RPC request 5539903cd1cSChuck Lever * 5549903cd1cSChuck Lever * Return values: 5559903cd1cSChuck Lever * 0: The request has been sent 5569903cd1cSChuck Lever * EAGAIN: The socket was blocked, please call again later to 5579903cd1cSChuck Lever * complete the request 558262965f5SChuck Lever * ENOTCONN: Caller needs to invoke connect logic then call again 5599903cd1cSChuck Lever * other: Some other error occured, the request was not sent 5609903cd1cSChuck Lever */ 561262965f5SChuck Lever static int xs_udp_send_request(struct rpc_task *task) 562a246b010SChuck Lever { 563a246b010SChuck Lever struct rpc_rqst *req = task->tk_rqstp; 564a246b010SChuck Lever struct rpc_xprt *xprt = req->rq_xprt; 565ee0ac0c2SChuck Lever struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt); 566262965f5SChuck Lever struct xdr_buf *xdr = &req->rq_snd_buf; 567262965f5SChuck Lever int status; 568262965f5SChuck Lever 569262965f5SChuck Lever xs_pktdump("packet data:", 570262965f5SChuck Lever req->rq_svec->iov_base, 571262965f5SChuck Lever req->rq_svec->iov_len); 572262965f5SChuck Lever 573262965f5SChuck Lever req->rq_xtime = jiffies; 574ee0ac0c2SChuck Lever status = xs_sendpages(transport->sock, 57595392c59SChuck Lever xs_addr(xprt), 576ee0ac0c2SChuck Lever xprt->addrlen, xdr, 577ee0ac0c2SChuck Lever req->rq_bytes_sent); 578262965f5SChuck Lever 579262965f5SChuck Lever dprintk("RPC: xs_udp_send_request(%u) = %d\n", 580262965f5SChuck Lever xdr->len - req->rq_bytes_sent, status); 581262965f5SChuck Lever 5822199700fSTrond Myklebust if (status >= 0) { 5831321d8d9SChuck Lever task->tk_bytes_sent += status; 5842199700fSTrond Myklebust if (status >= req->rq_slen) 585262965f5SChuck Lever return 0; 586262965f5SChuck Lever /* Still some bytes left; set up for a retry later. */ 587262965f5SChuck Lever status = -EAGAIN; 5882199700fSTrond Myklebust } 589262965f5SChuck Lever 590262965f5SChuck Lever switch (status) { 591262965f5SChuck Lever case -ENETUNREACH: 592262965f5SChuck Lever case -EPIPE: 593262965f5SChuck Lever case -ECONNREFUSED: 594262965f5SChuck Lever /* When the server has died, an ICMP port unreachable message 595262965f5SChuck Lever * prompts ECONNREFUSED. */ 596262965f5SChuck Lever break; 597262965f5SChuck Lever case -EAGAIN: 598262965f5SChuck Lever xs_nospace(task); 599262965f5SChuck Lever break; 600262965f5SChuck Lever default: 601262965f5SChuck Lever dprintk("RPC: sendmsg returned unrecognized error %d\n", 602262965f5SChuck Lever -status); 603262965f5SChuck Lever break; 604262965f5SChuck Lever } 605262965f5SChuck Lever 606262965f5SChuck Lever return status; 607262965f5SChuck Lever } 608262965f5SChuck Lever 609e06799f9STrond Myklebust /** 610e06799f9STrond Myklebust * xs_tcp_shutdown - gracefully shut down a TCP socket 611e06799f9STrond Myklebust * @xprt: transport 612e06799f9STrond Myklebust * 613e06799f9STrond Myklebust * Initiates a graceful shutdown of the TCP socket by calling the 614e06799f9STrond Myklebust * equivalent of shutdown(SHUT_WR); 615e06799f9STrond Myklebust */ 616e06799f9STrond Myklebust static void xs_tcp_shutdown(struct rpc_xprt *xprt) 617e06799f9STrond Myklebust { 618e06799f9STrond Myklebust struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt); 619e06799f9STrond Myklebust struct socket *sock = transport->sock; 620e06799f9STrond Myklebust 621e06799f9STrond Myklebust if (sock != NULL) 622e06799f9STrond Myklebust kernel_sock_shutdown(sock, SHUT_WR); 623e06799f9STrond Myklebust } 624e06799f9STrond Myklebust 625808012fbSChuck Lever static inline void xs_encode_tcp_record_marker(struct xdr_buf *buf) 626808012fbSChuck Lever { 627808012fbSChuck Lever u32 reclen = buf->len - sizeof(rpc_fraghdr); 628808012fbSChuck Lever rpc_fraghdr *base = buf->head[0].iov_base; 629808012fbSChuck Lever *base = htonl(RPC_LAST_STREAM_FRAGMENT | reclen); 630808012fbSChuck Lever } 631808012fbSChuck Lever 632262965f5SChuck Lever /** 633262965f5SChuck Lever * xs_tcp_send_request - write an RPC request to a TCP socket 634262965f5SChuck Lever * @task: address of RPC task that manages the state of an RPC request 635262965f5SChuck Lever * 636262965f5SChuck Lever * Return values: 637262965f5SChuck Lever * 0: The request has been sent 638262965f5SChuck Lever * EAGAIN: The socket was blocked, please call again later to 639262965f5SChuck Lever * complete the request 640262965f5SChuck Lever * ENOTCONN: Caller needs to invoke connect logic then call again 641262965f5SChuck Lever * other: Some other error occured, the request was not sent 642262965f5SChuck Lever * 643262965f5SChuck Lever * XXX: In the case of soft timeouts, should we eventually give up 644262965f5SChuck Lever * if sendmsg is not able to make progress? 645262965f5SChuck Lever */ 646262965f5SChuck Lever static int xs_tcp_send_request(struct rpc_task *task) 647262965f5SChuck Lever { 648262965f5SChuck Lever struct rpc_rqst *req = task->tk_rqstp; 649262965f5SChuck Lever struct rpc_xprt *xprt = req->rq_xprt; 650ee0ac0c2SChuck Lever struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt); 651262965f5SChuck Lever struct xdr_buf *xdr = &req->rq_snd_buf; 652b595bb15SChuck Lever int status; 653b595bb15SChuck Lever unsigned int retry = 0; 654a246b010SChuck Lever 655808012fbSChuck Lever xs_encode_tcp_record_marker(&req->rq_snd_buf); 656262965f5SChuck Lever 657262965f5SChuck Lever xs_pktdump("packet data:", 658262965f5SChuck Lever req->rq_svec->iov_base, 659262965f5SChuck Lever req->rq_svec->iov_len); 660a246b010SChuck Lever 661a246b010SChuck Lever /* Continue transmitting the packet/record. We must be careful 662a246b010SChuck Lever * to cope with writespace callbacks arriving _after_ we have 663262965f5SChuck Lever * called sendmsg(). */ 664a246b010SChuck Lever while (1) { 665a246b010SChuck Lever req->rq_xtime = jiffies; 666ee0ac0c2SChuck Lever status = xs_sendpages(transport->sock, 667ee0ac0c2SChuck Lever NULL, 0, xdr, req->rq_bytes_sent); 668a246b010SChuck Lever 669262965f5SChuck Lever dprintk("RPC: xs_tcp_send_request(%u) = %d\n", 670262965f5SChuck Lever xdr->len - req->rq_bytes_sent, status); 671262965f5SChuck Lever 672262965f5SChuck Lever if (unlikely(status < 0)) 673a246b010SChuck Lever break; 674a246b010SChuck Lever 675a246b010SChuck Lever /* If we've sent the entire packet, immediately 676a246b010SChuck Lever * reset the count of bytes sent. */ 677262965f5SChuck Lever req->rq_bytes_sent += status; 678ef759a2eSChuck Lever task->tk_bytes_sent += status; 679262965f5SChuck Lever if (likely(req->rq_bytes_sent >= req->rq_slen)) { 680a246b010SChuck Lever req->rq_bytes_sent = 0; 681a246b010SChuck Lever return 0; 682a246b010SChuck Lever } 683262965f5SChuck Lever 684a246b010SChuck Lever status = -EAGAIN; 685262965f5SChuck Lever if (retry++ > XS_SENDMSG_RETRY) 686a246b010SChuck Lever break; 687a246b010SChuck Lever } 688a246b010SChuck Lever 689262965f5SChuck Lever switch (status) { 690262965f5SChuck Lever case -EAGAIN: 691262965f5SChuck Lever xs_nospace(task); 692262965f5SChuck Lever break; 693262965f5SChuck Lever case -ECONNREFUSED: 694262965f5SChuck Lever case -ECONNRESET: 695262965f5SChuck Lever case -ENOTCONN: 696262965f5SChuck Lever case -EPIPE: 697262965f5SChuck Lever status = -ENOTCONN; 698262965f5SChuck Lever break; 699262965f5SChuck Lever default: 700262965f5SChuck Lever dprintk("RPC: sendmsg returned unrecognized error %d\n", 701262965f5SChuck Lever -status); 702e06799f9STrond Myklebust xs_tcp_shutdown(xprt); 703a246b010SChuck Lever break; 704a246b010SChuck Lever } 705a246b010SChuck Lever 706a246b010SChuck Lever return status; 707a246b010SChuck Lever } 708a246b010SChuck Lever 7099903cd1cSChuck Lever /** 710e0ab53deSTrond Myklebust * xs_tcp_release_xprt - clean up after a tcp transmission 711e0ab53deSTrond Myklebust * @xprt: transport 712e0ab53deSTrond Myklebust * @task: rpc task 713e0ab53deSTrond Myklebust * 714e0ab53deSTrond Myklebust * This cleans up if an error causes us to abort the transmission of a request. 715e0ab53deSTrond Myklebust * In this case, the socket may need to be reset in order to avoid confusing 716e0ab53deSTrond Myklebust * the server. 717e0ab53deSTrond Myklebust */ 718e0ab53deSTrond Myklebust static void xs_tcp_release_xprt(struct rpc_xprt *xprt, struct rpc_task *task) 719e0ab53deSTrond Myklebust { 720e0ab53deSTrond Myklebust struct rpc_rqst *req; 721e0ab53deSTrond Myklebust 722e0ab53deSTrond Myklebust if (task != xprt->snd_task) 723e0ab53deSTrond Myklebust return; 724e0ab53deSTrond Myklebust if (task == NULL) 725e0ab53deSTrond Myklebust goto out_release; 726e0ab53deSTrond Myklebust req = task->tk_rqstp; 727e0ab53deSTrond Myklebust if (req->rq_bytes_sent == 0) 728e0ab53deSTrond Myklebust goto out_release; 729e0ab53deSTrond Myklebust if (req->rq_bytes_sent == req->rq_snd_buf.len) 730e0ab53deSTrond Myklebust goto out_release; 731e0ab53deSTrond Myklebust set_bit(XPRT_CLOSE_WAIT, &task->tk_xprt->state); 732e0ab53deSTrond Myklebust out_release: 733e0ab53deSTrond Myklebust xprt_release_xprt(xprt, task); 734e0ab53deSTrond Myklebust } 735e0ab53deSTrond Myklebust 736e0ab53deSTrond Myklebust /** 7379903cd1cSChuck Lever * xs_close - close a socket 7389903cd1cSChuck Lever * @xprt: transport 7399903cd1cSChuck Lever * 7403167e12cSChuck Lever * This is used when all requests are complete; ie, no DRC state remains 7413167e12cSChuck Lever * on the server we want to save. 742a246b010SChuck Lever */ 7439903cd1cSChuck Lever static void xs_close(struct rpc_xprt *xprt) 744a246b010SChuck Lever { 745ee0ac0c2SChuck Lever struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt); 746ee0ac0c2SChuck Lever struct socket *sock = transport->sock; 747ee0ac0c2SChuck Lever struct sock *sk = transport->inet; 748a246b010SChuck Lever 749a246b010SChuck Lever if (!sk) 750632e3bdcSTrond Myklebust goto clear_close_wait; 751a246b010SChuck Lever 7529903cd1cSChuck Lever dprintk("RPC: xs_close xprt %p\n", xprt); 7539903cd1cSChuck Lever 754a246b010SChuck Lever write_lock_bh(&sk->sk_callback_lock); 755ee0ac0c2SChuck Lever transport->inet = NULL; 756ee0ac0c2SChuck Lever transport->sock = NULL; 757a246b010SChuck Lever 758a246b010SChuck Lever sk->sk_user_data = NULL; 759314dfd79SChuck Lever sk->sk_data_ready = transport->old_data_ready; 760314dfd79SChuck Lever sk->sk_state_change = transport->old_state_change; 761314dfd79SChuck Lever sk->sk_write_space = transport->old_write_space; 762a246b010SChuck Lever write_unlock_bh(&sk->sk_callback_lock); 763a246b010SChuck Lever 764a246b010SChuck Lever sk->sk_no_check = 0; 765a246b010SChuck Lever 766a246b010SChuck Lever sock_release(sock); 767632e3bdcSTrond Myklebust clear_close_wait: 768632e3bdcSTrond Myklebust smp_mb__before_clear_bit(); 769632e3bdcSTrond Myklebust clear_bit(XPRT_CLOSE_WAIT, &xprt->state); 7703b948ae5STrond Myklebust clear_bit(XPRT_CLOSING, &xprt->state); 771632e3bdcSTrond Myklebust smp_mb__after_clear_bit(); 77262da3b24STrond Myklebust xprt_disconnect_done(xprt); 773a246b010SChuck Lever } 774a246b010SChuck Lever 7759903cd1cSChuck Lever /** 7769903cd1cSChuck Lever * xs_destroy - prepare to shutdown a transport 7779903cd1cSChuck Lever * @xprt: doomed transport 7789903cd1cSChuck Lever * 7799903cd1cSChuck Lever */ 7809903cd1cSChuck Lever static void xs_destroy(struct rpc_xprt *xprt) 781a246b010SChuck Lever { 782c8475461SChuck Lever struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt); 783c8475461SChuck Lever 7849903cd1cSChuck Lever dprintk("RPC: xs_destroy xprt %p\n", xprt); 7859903cd1cSChuck Lever 786c1384c9cSTrond Myklebust cancel_rearming_delayed_work(&transport->connect_worker); 787a246b010SChuck Lever 7889903cd1cSChuck Lever xs_close(xprt); 789edb267a6SChuck Lever xs_free_peer_addresses(xprt); 790a246b010SChuck Lever kfree(xprt->slot); 791c8541ecdSChuck Lever kfree(xprt); 792bc25571eS\"Talpey, Thomas\ module_put(THIS_MODULE); 793a246b010SChuck Lever } 794a246b010SChuck Lever 7959903cd1cSChuck Lever static inline struct rpc_xprt *xprt_from_sock(struct sock *sk) 7969903cd1cSChuck Lever { 7979903cd1cSChuck Lever return (struct rpc_xprt *) sk->sk_user_data; 7989903cd1cSChuck Lever } 7999903cd1cSChuck Lever 8009903cd1cSChuck Lever /** 8019903cd1cSChuck Lever * xs_udp_data_ready - "data ready" callback for UDP sockets 8029903cd1cSChuck Lever * @sk: socket with data to read 8039903cd1cSChuck Lever * @len: how much data to read 8049903cd1cSChuck Lever * 805a246b010SChuck Lever */ 8069903cd1cSChuck Lever static void xs_udp_data_ready(struct sock *sk, int len) 807a246b010SChuck Lever { 808a246b010SChuck Lever struct rpc_task *task; 809a246b010SChuck Lever struct rpc_xprt *xprt; 810a246b010SChuck Lever struct rpc_rqst *rovr; 811a246b010SChuck Lever struct sk_buff *skb; 812a246b010SChuck Lever int err, repsize, copied; 813d8ed029dSAlexey Dobriyan u32 _xid; 814d8ed029dSAlexey Dobriyan __be32 *xp; 815a246b010SChuck Lever 816a246b010SChuck Lever read_lock(&sk->sk_callback_lock); 8179903cd1cSChuck Lever dprintk("RPC: xs_udp_data_ready...\n"); 8189903cd1cSChuck Lever if (!(xprt = xprt_from_sock(sk))) 819a246b010SChuck Lever goto out; 820a246b010SChuck Lever 821a246b010SChuck Lever if ((skb = skb_recv_datagram(sk, 0, 1, &err)) == NULL) 822a246b010SChuck Lever goto out; 823a246b010SChuck Lever 824a246b010SChuck Lever if (xprt->shutdown) 825a246b010SChuck Lever goto dropit; 826a246b010SChuck Lever 827a246b010SChuck Lever repsize = skb->len - sizeof(struct udphdr); 828a246b010SChuck Lever if (repsize < 4) { 8299903cd1cSChuck Lever dprintk("RPC: impossible RPC reply size %d!\n", repsize); 830a246b010SChuck Lever goto dropit; 831a246b010SChuck Lever } 832a246b010SChuck Lever 833a246b010SChuck Lever /* Copy the XID from the skb... */ 834a246b010SChuck Lever xp = skb_header_pointer(skb, sizeof(struct udphdr), 835a246b010SChuck Lever sizeof(_xid), &_xid); 836a246b010SChuck Lever if (xp == NULL) 837a246b010SChuck Lever goto dropit; 838a246b010SChuck Lever 839a246b010SChuck Lever /* Look up and lock the request corresponding to the given XID */ 8404a0f8c04SChuck Lever spin_lock(&xprt->transport_lock); 841a246b010SChuck Lever rovr = xprt_lookup_rqst(xprt, *xp); 842a246b010SChuck Lever if (!rovr) 843a246b010SChuck Lever goto out_unlock; 844a246b010SChuck Lever task = rovr->rq_task; 845a246b010SChuck Lever 846a246b010SChuck Lever if ((copied = rovr->rq_private_buf.buflen) > repsize) 847a246b010SChuck Lever copied = repsize; 848a246b010SChuck Lever 849a246b010SChuck Lever /* Suck it into the iovec, verify checksum if not done by hw. */ 8501781f7f5SHerbert Xu if (csum_partial_copy_to_xdr(&rovr->rq_private_buf, skb)) { 8511781f7f5SHerbert Xu UDPX_INC_STATS_BH(sk, UDP_MIB_INERRORS); 852a246b010SChuck Lever goto out_unlock; 8531781f7f5SHerbert Xu } 8541781f7f5SHerbert Xu 8551781f7f5SHerbert Xu UDPX_INC_STATS_BH(sk, UDP_MIB_INDATAGRAMS); 856a246b010SChuck Lever 857a246b010SChuck Lever /* Something worked... */ 858a246b010SChuck Lever dst_confirm(skb->dst); 859a246b010SChuck Lever 8601570c1e4SChuck Lever xprt_adjust_cwnd(task, copied); 8611570c1e4SChuck Lever xprt_update_rtt(task); 8621570c1e4SChuck Lever xprt_complete_rqst(task, copied); 863a246b010SChuck Lever 864a246b010SChuck Lever out_unlock: 8654a0f8c04SChuck Lever spin_unlock(&xprt->transport_lock); 866a246b010SChuck Lever dropit: 867a246b010SChuck Lever skb_free_datagram(sk, skb); 868a246b010SChuck Lever out: 869a246b010SChuck Lever read_unlock(&sk->sk_callback_lock); 870a246b010SChuck Lever } 871a246b010SChuck Lever 872dd456471SChuck Lever static inline void xs_tcp_read_fraghdr(struct rpc_xprt *xprt, struct xdr_skb_reader *desc) 873a246b010SChuck Lever { 87451971139SChuck Lever struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt); 875a246b010SChuck Lever size_t len, used; 876a246b010SChuck Lever char *p; 877a246b010SChuck Lever 87851971139SChuck Lever p = ((char *) &transport->tcp_fraghdr) + transport->tcp_offset; 87951971139SChuck Lever len = sizeof(transport->tcp_fraghdr) - transport->tcp_offset; 8809d292316SChuck Lever used = xdr_skb_read_bits(desc, p, len); 88151971139SChuck Lever transport->tcp_offset += used; 882a246b010SChuck Lever if (used != len) 883a246b010SChuck Lever return; 884808012fbSChuck Lever 88551971139SChuck Lever transport->tcp_reclen = ntohl(transport->tcp_fraghdr); 88651971139SChuck Lever if (transport->tcp_reclen & RPC_LAST_STREAM_FRAGMENT) 887e136d092SChuck Lever transport->tcp_flags |= TCP_RCV_LAST_FRAG; 888a246b010SChuck Lever else 889e136d092SChuck Lever transport->tcp_flags &= ~TCP_RCV_LAST_FRAG; 89051971139SChuck Lever transport->tcp_reclen &= RPC_FRAGMENT_SIZE_MASK; 891808012fbSChuck Lever 892e136d092SChuck Lever transport->tcp_flags &= ~TCP_RCV_COPY_FRAGHDR; 89351971139SChuck Lever transport->tcp_offset = 0; 894808012fbSChuck Lever 895a246b010SChuck Lever /* Sanity check of the record length */ 89651971139SChuck Lever if (unlikely(transport->tcp_reclen < 4)) { 8979903cd1cSChuck Lever dprintk("RPC: invalid TCP record fragment length\n"); 8983ebb067dSTrond Myklebust xprt_force_disconnect(xprt); 8999903cd1cSChuck Lever return; 900a246b010SChuck Lever } 901a246b010SChuck Lever dprintk("RPC: reading TCP record fragment of length %d\n", 90251971139SChuck Lever transport->tcp_reclen); 903a246b010SChuck Lever } 904a246b010SChuck Lever 90551971139SChuck Lever static void xs_tcp_check_fraghdr(struct sock_xprt *transport) 906a246b010SChuck Lever { 90751971139SChuck Lever if (transport->tcp_offset == transport->tcp_reclen) { 908e136d092SChuck Lever transport->tcp_flags |= TCP_RCV_COPY_FRAGHDR; 90951971139SChuck Lever transport->tcp_offset = 0; 910e136d092SChuck Lever if (transport->tcp_flags & TCP_RCV_LAST_FRAG) { 911e136d092SChuck Lever transport->tcp_flags &= ~TCP_RCV_COPY_DATA; 912e136d092SChuck Lever transport->tcp_flags |= TCP_RCV_COPY_XID; 91351971139SChuck Lever transport->tcp_copied = 0; 914a246b010SChuck Lever } 915a246b010SChuck Lever } 916a246b010SChuck Lever } 917a246b010SChuck Lever 918dd456471SChuck Lever static inline void xs_tcp_read_xid(struct sock_xprt *transport, struct xdr_skb_reader *desc) 919a246b010SChuck Lever { 920a246b010SChuck Lever size_t len, used; 921a246b010SChuck Lever char *p; 922a246b010SChuck Lever 92351971139SChuck Lever len = sizeof(transport->tcp_xid) - transport->tcp_offset; 924a246b010SChuck Lever dprintk("RPC: reading XID (%Zu bytes)\n", len); 92551971139SChuck Lever p = ((char *) &transport->tcp_xid) + transport->tcp_offset; 9269d292316SChuck Lever used = xdr_skb_read_bits(desc, p, len); 92751971139SChuck Lever transport->tcp_offset += used; 928a246b010SChuck Lever if (used != len) 929a246b010SChuck Lever return; 930e136d092SChuck Lever transport->tcp_flags &= ~TCP_RCV_COPY_XID; 931e136d092SChuck Lever transport->tcp_flags |= TCP_RCV_COPY_DATA; 93251971139SChuck Lever transport->tcp_copied = 4; 933a246b010SChuck Lever dprintk("RPC: reading reply for XID %08x\n", 93451971139SChuck Lever ntohl(transport->tcp_xid)); 93551971139SChuck Lever xs_tcp_check_fraghdr(transport); 936a246b010SChuck Lever } 937a246b010SChuck Lever 938dd456471SChuck Lever static inline void xs_tcp_read_request(struct rpc_xprt *xprt, struct xdr_skb_reader *desc) 939a246b010SChuck Lever { 94051971139SChuck Lever struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt); 941a246b010SChuck Lever struct rpc_rqst *req; 942a246b010SChuck Lever struct xdr_buf *rcvbuf; 943a246b010SChuck Lever size_t len; 944a246b010SChuck Lever ssize_t r; 945a246b010SChuck Lever 946a246b010SChuck Lever /* Find and lock the request corresponding to this xid */ 9474a0f8c04SChuck Lever spin_lock(&xprt->transport_lock); 94851971139SChuck Lever req = xprt_lookup_rqst(xprt, transport->tcp_xid); 949a246b010SChuck Lever if (!req) { 950e136d092SChuck Lever transport->tcp_flags &= ~TCP_RCV_COPY_DATA; 951a246b010SChuck Lever dprintk("RPC: XID %08x request not found!\n", 95251971139SChuck Lever ntohl(transport->tcp_xid)); 9534a0f8c04SChuck Lever spin_unlock(&xprt->transport_lock); 954a246b010SChuck Lever return; 955a246b010SChuck Lever } 956a246b010SChuck Lever 957a246b010SChuck Lever rcvbuf = &req->rq_private_buf; 958a246b010SChuck Lever len = desc->count; 95951971139SChuck Lever if (len > transport->tcp_reclen - transport->tcp_offset) { 960dd456471SChuck Lever struct xdr_skb_reader my_desc; 961a246b010SChuck Lever 96251971139SChuck Lever len = transport->tcp_reclen - transport->tcp_offset; 963a246b010SChuck Lever memcpy(&my_desc, desc, sizeof(my_desc)); 964a246b010SChuck Lever my_desc.count = len; 96551971139SChuck Lever r = xdr_partial_copy_from_skb(rcvbuf, transport->tcp_copied, 9669d292316SChuck Lever &my_desc, xdr_skb_read_bits); 967a246b010SChuck Lever desc->count -= r; 968a246b010SChuck Lever desc->offset += r; 969a246b010SChuck Lever } else 97051971139SChuck Lever r = xdr_partial_copy_from_skb(rcvbuf, transport->tcp_copied, 9719d292316SChuck Lever desc, xdr_skb_read_bits); 972a246b010SChuck Lever 973a246b010SChuck Lever if (r > 0) { 97451971139SChuck Lever transport->tcp_copied += r; 97551971139SChuck Lever transport->tcp_offset += r; 976a246b010SChuck Lever } 977a246b010SChuck Lever if (r != len) { 978a246b010SChuck Lever /* Error when copying to the receive buffer, 979a246b010SChuck Lever * usually because we weren't able to allocate 980a246b010SChuck Lever * additional buffer pages. All we can do now 981e136d092SChuck Lever * is turn off TCP_RCV_COPY_DATA, so the request 982a246b010SChuck Lever * will not receive any additional updates, 983a246b010SChuck Lever * and time out. 984a246b010SChuck Lever * Any remaining data from this record will 985a246b010SChuck Lever * be discarded. 986a246b010SChuck Lever */ 987e136d092SChuck Lever transport->tcp_flags &= ~TCP_RCV_COPY_DATA; 988a246b010SChuck Lever dprintk("RPC: XID %08x truncated request\n", 98951971139SChuck Lever ntohl(transport->tcp_xid)); 99046121cf7SChuck Lever dprintk("RPC: xprt = %p, tcp_copied = %lu, " 99146121cf7SChuck Lever "tcp_offset = %u, tcp_reclen = %u\n", 99246121cf7SChuck Lever xprt, transport->tcp_copied, 99346121cf7SChuck Lever transport->tcp_offset, transport->tcp_reclen); 994a246b010SChuck Lever goto out; 995a246b010SChuck Lever } 996a246b010SChuck Lever 997a246b010SChuck Lever dprintk("RPC: XID %08x read %Zd bytes\n", 99851971139SChuck Lever ntohl(transport->tcp_xid), r); 99946121cf7SChuck Lever dprintk("RPC: xprt = %p, tcp_copied = %lu, tcp_offset = %u, " 100046121cf7SChuck Lever "tcp_reclen = %u\n", xprt, transport->tcp_copied, 100146121cf7SChuck Lever transport->tcp_offset, transport->tcp_reclen); 1002a246b010SChuck Lever 100351971139SChuck Lever if (transport->tcp_copied == req->rq_private_buf.buflen) 1004e136d092SChuck Lever transport->tcp_flags &= ~TCP_RCV_COPY_DATA; 100551971139SChuck Lever else if (transport->tcp_offset == transport->tcp_reclen) { 1006e136d092SChuck Lever if (transport->tcp_flags & TCP_RCV_LAST_FRAG) 1007e136d092SChuck Lever transport->tcp_flags &= ~TCP_RCV_COPY_DATA; 1008a246b010SChuck Lever } 1009a246b010SChuck Lever 1010a246b010SChuck Lever out: 1011e136d092SChuck Lever if (!(transport->tcp_flags & TCP_RCV_COPY_DATA)) 101251971139SChuck Lever xprt_complete_rqst(req->rq_task, transport->tcp_copied); 10134a0f8c04SChuck Lever spin_unlock(&xprt->transport_lock); 101451971139SChuck Lever xs_tcp_check_fraghdr(transport); 1015a246b010SChuck Lever } 1016a246b010SChuck Lever 1017dd456471SChuck Lever static inline void xs_tcp_read_discard(struct sock_xprt *transport, struct xdr_skb_reader *desc) 1018a246b010SChuck Lever { 1019a246b010SChuck Lever size_t len; 1020a246b010SChuck Lever 102151971139SChuck Lever len = transport->tcp_reclen - transport->tcp_offset; 1022a246b010SChuck Lever if (len > desc->count) 1023a246b010SChuck Lever len = desc->count; 1024a246b010SChuck Lever desc->count -= len; 1025a246b010SChuck Lever desc->offset += len; 102651971139SChuck Lever transport->tcp_offset += len; 1027a246b010SChuck Lever dprintk("RPC: discarded %Zu bytes\n", len); 102851971139SChuck Lever xs_tcp_check_fraghdr(transport); 1029a246b010SChuck Lever } 1030a246b010SChuck Lever 10319903cd1cSChuck Lever static int xs_tcp_data_recv(read_descriptor_t *rd_desc, struct sk_buff *skb, unsigned int offset, size_t len) 1032a246b010SChuck Lever { 1033a246b010SChuck Lever struct rpc_xprt *xprt = rd_desc->arg.data; 103451971139SChuck Lever struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt); 1035dd456471SChuck Lever struct xdr_skb_reader desc = { 1036a246b010SChuck Lever .skb = skb, 1037a246b010SChuck Lever .offset = offset, 1038a246b010SChuck Lever .count = len, 1039a246b010SChuck Lever }; 1040a246b010SChuck Lever 10419903cd1cSChuck Lever dprintk("RPC: xs_tcp_data_recv started\n"); 1042a246b010SChuck Lever do { 1043a246b010SChuck Lever /* Read in a new fragment marker if necessary */ 1044a246b010SChuck Lever /* Can we ever really expect to get completely empty fragments? */ 1045e136d092SChuck Lever if (transport->tcp_flags & TCP_RCV_COPY_FRAGHDR) { 10469903cd1cSChuck Lever xs_tcp_read_fraghdr(xprt, &desc); 1047a246b010SChuck Lever continue; 1048a246b010SChuck Lever } 1049a246b010SChuck Lever /* Read in the xid if necessary */ 1050e136d092SChuck Lever if (transport->tcp_flags & TCP_RCV_COPY_XID) { 105151971139SChuck Lever xs_tcp_read_xid(transport, &desc); 1052a246b010SChuck Lever continue; 1053a246b010SChuck Lever } 1054a246b010SChuck Lever /* Read in the request data */ 1055e136d092SChuck Lever if (transport->tcp_flags & TCP_RCV_COPY_DATA) { 10569903cd1cSChuck Lever xs_tcp_read_request(xprt, &desc); 1057a246b010SChuck Lever continue; 1058a246b010SChuck Lever } 1059a246b010SChuck Lever /* Skip over any trailing bytes on short reads */ 106051971139SChuck Lever xs_tcp_read_discard(transport, &desc); 1061a246b010SChuck Lever } while (desc.count); 10629903cd1cSChuck Lever dprintk("RPC: xs_tcp_data_recv done\n"); 1063a246b010SChuck Lever return len - desc.count; 1064a246b010SChuck Lever } 1065a246b010SChuck Lever 10669903cd1cSChuck Lever /** 10679903cd1cSChuck Lever * xs_tcp_data_ready - "data ready" callback for TCP sockets 10689903cd1cSChuck Lever * @sk: socket with data to read 10699903cd1cSChuck Lever * @bytes: how much data to read 10709903cd1cSChuck Lever * 10719903cd1cSChuck Lever */ 10729903cd1cSChuck Lever static void xs_tcp_data_ready(struct sock *sk, int bytes) 1073a246b010SChuck Lever { 1074a246b010SChuck Lever struct rpc_xprt *xprt; 1075a246b010SChuck Lever read_descriptor_t rd_desc; 1076ff2d7db8STrond Myklebust int read; 1077a246b010SChuck Lever 10789903cd1cSChuck Lever dprintk("RPC: xs_tcp_data_ready...\n"); 107946121cf7SChuck Lever 108046121cf7SChuck Lever read_lock(&sk->sk_callback_lock); 10819903cd1cSChuck Lever if (!(xprt = xprt_from_sock(sk))) 1082a246b010SChuck Lever goto out; 1083a246b010SChuck Lever if (xprt->shutdown) 1084a246b010SChuck Lever goto out; 1085a246b010SChuck Lever 10869903cd1cSChuck Lever /* We use rd_desc to pass struct xprt to xs_tcp_data_recv */ 1087a246b010SChuck Lever rd_desc.arg.data = xprt; 1088ff2d7db8STrond Myklebust do { 1089a246b010SChuck Lever rd_desc.count = 65536; 1090ff2d7db8STrond Myklebust read = tcp_read_sock(sk, &rd_desc, xs_tcp_data_recv); 1091ff2d7db8STrond Myklebust } while (read > 0); 1092a246b010SChuck Lever out: 1093a246b010SChuck Lever read_unlock(&sk->sk_callback_lock); 1094a246b010SChuck Lever } 1095a246b010SChuck Lever 10969903cd1cSChuck Lever /** 10979903cd1cSChuck Lever * xs_tcp_state_change - callback to handle TCP socket state changes 10989903cd1cSChuck Lever * @sk: socket whose state has changed 10999903cd1cSChuck Lever * 11009903cd1cSChuck Lever */ 11019903cd1cSChuck Lever static void xs_tcp_state_change(struct sock *sk) 1102a246b010SChuck Lever { 1103a246b010SChuck Lever struct rpc_xprt *xprt; 1104a246b010SChuck Lever 1105a246b010SChuck Lever read_lock(&sk->sk_callback_lock); 1106a246b010SChuck Lever if (!(xprt = xprt_from_sock(sk))) 1107a246b010SChuck Lever goto out; 11089903cd1cSChuck Lever dprintk("RPC: xs_tcp_state_change client %p...\n", xprt); 1109a246b010SChuck Lever dprintk("RPC: state %x conn %d dead %d zapped %d\n", 1110a246b010SChuck Lever sk->sk_state, xprt_connected(xprt), 1111a246b010SChuck Lever sock_flag(sk, SOCK_DEAD), 1112a246b010SChuck Lever sock_flag(sk, SOCK_ZAPPED)); 1113a246b010SChuck Lever 1114a246b010SChuck Lever switch (sk->sk_state) { 1115a246b010SChuck Lever case TCP_ESTABLISHED: 11164a0f8c04SChuck Lever spin_lock_bh(&xprt->transport_lock); 1117a246b010SChuck Lever if (!xprt_test_and_set_connected(xprt)) { 111851971139SChuck Lever struct sock_xprt *transport = container_of(xprt, 111951971139SChuck Lever struct sock_xprt, xprt); 112051971139SChuck Lever 1121a246b010SChuck Lever /* Reset TCP record info */ 112251971139SChuck Lever transport->tcp_offset = 0; 112351971139SChuck Lever transport->tcp_reclen = 0; 112451971139SChuck Lever transport->tcp_copied = 0; 1125e136d092SChuck Lever transport->tcp_flags = 1126e136d092SChuck Lever TCP_RCV_COPY_FRAGHDR | TCP_RCV_COPY_XID; 112751971139SChuck Lever 112844fbac22SChuck Lever xprt_wake_pending_tasks(xprt, 0); 1129a246b010SChuck Lever } 11304a0f8c04SChuck Lever spin_unlock_bh(&xprt->transport_lock); 1131a246b010SChuck Lever break; 11323b948ae5STrond Myklebust case TCP_FIN_WAIT1: 11333b948ae5STrond Myklebust /* The client initiated a shutdown of the socket */ 1134663b8858STrond Myklebust xprt->reestablish_timeout = 0; 11353b948ae5STrond Myklebust set_bit(XPRT_CLOSING, &xprt->state); 11363b948ae5STrond Myklebust smp_mb__before_clear_bit(); 11373b948ae5STrond Myklebust clear_bit(XPRT_CONNECTED, &xprt->state); 1138ef803670STrond Myklebust clear_bit(XPRT_CLOSE_WAIT, &xprt->state); 11393b948ae5STrond Myklebust smp_mb__after_clear_bit(); 1140a246b010SChuck Lever break; 1141632e3bdcSTrond Myklebust case TCP_CLOSE_WAIT: 11423b948ae5STrond Myklebust /* The server initiated a shutdown of the socket */ 11433b948ae5STrond Myklebust set_bit(XPRT_CLOSING, &xprt->state); 114466af1e55STrond Myklebust xprt_force_disconnect(xprt); 1145663b8858STrond Myklebust case TCP_SYN_SENT: 1146663b8858STrond Myklebust case TCP_CLOSING: 1147663b8858STrond Myklebust /* 1148663b8858STrond Myklebust * If the server closed down the connection, make sure that 1149663b8858STrond Myklebust * we back off before reconnecting 1150663b8858STrond Myklebust */ 1151663b8858STrond Myklebust if (xprt->reestablish_timeout < XS_TCP_INIT_REEST_TO) 1152663b8858STrond Myklebust xprt->reestablish_timeout = XS_TCP_INIT_REEST_TO; 11533b948ae5STrond Myklebust break; 11543b948ae5STrond Myklebust case TCP_LAST_ACK: 11553b948ae5STrond Myklebust smp_mb__before_clear_bit(); 11563b948ae5STrond Myklebust clear_bit(XPRT_CONNECTED, &xprt->state); 11573b948ae5STrond Myklebust smp_mb__after_clear_bit(); 11583b948ae5STrond Myklebust break; 11593b948ae5STrond Myklebust case TCP_CLOSE: 11603b948ae5STrond Myklebust smp_mb__before_clear_bit(); 1161ef803670STrond Myklebust clear_bit(XPRT_CLOSE_WAIT, &xprt->state); 11623b948ae5STrond Myklebust clear_bit(XPRT_CLOSING, &xprt->state); 11633b948ae5STrond Myklebust smp_mb__after_clear_bit(); 11643b948ae5STrond Myklebust /* Mark transport as closed and wake up all pending tasks */ 116562da3b24STrond Myklebust xprt_disconnect_done(xprt); 1166a246b010SChuck Lever } 1167a246b010SChuck Lever out: 1168a246b010SChuck Lever read_unlock(&sk->sk_callback_lock); 1169a246b010SChuck Lever } 1170a246b010SChuck Lever 11719903cd1cSChuck Lever /** 1172c7b2cae8SChuck Lever * xs_udp_write_space - callback invoked when socket buffer space 1173c7b2cae8SChuck Lever * becomes available 11749903cd1cSChuck Lever * @sk: socket whose state has changed 11759903cd1cSChuck Lever * 1176a246b010SChuck Lever * Called when more output buffer space is available for this socket. 1177a246b010SChuck Lever * We try not to wake our writers until they can make "significant" 1178c7b2cae8SChuck Lever * progress, otherwise we'll waste resources thrashing kernel_sendmsg 1179a246b010SChuck Lever * with a bunch of small requests. 1180a246b010SChuck Lever */ 1181c7b2cae8SChuck Lever static void xs_udp_write_space(struct sock *sk) 1182a246b010SChuck Lever { 1183a246b010SChuck Lever read_lock(&sk->sk_callback_lock); 1184c7b2cae8SChuck Lever 1185c7b2cae8SChuck Lever /* from net/core/sock.c:sock_def_write_space */ 1186c7b2cae8SChuck Lever if (sock_writeable(sk)) { 1187c7b2cae8SChuck Lever struct socket *sock; 1188c7b2cae8SChuck Lever struct rpc_xprt *xprt; 1189c7b2cae8SChuck Lever 1190c7b2cae8SChuck Lever if (unlikely(!(sock = sk->sk_socket))) 1191a246b010SChuck Lever goto out; 1192c7b2cae8SChuck Lever if (unlikely(!(xprt = xprt_from_sock(sk)))) 1193c7b2cae8SChuck Lever goto out; 1194c7b2cae8SChuck Lever if (unlikely(!test_and_clear_bit(SOCK_NOSPACE, &sock->flags))) 1195a246b010SChuck Lever goto out; 1196a246b010SChuck Lever 1197c7b2cae8SChuck Lever xprt_write_space(xprt); 1198a246b010SChuck Lever } 1199a246b010SChuck Lever 1200c7b2cae8SChuck Lever out: 1201c7b2cae8SChuck Lever read_unlock(&sk->sk_callback_lock); 1202c7b2cae8SChuck Lever } 1203c7b2cae8SChuck Lever 1204c7b2cae8SChuck Lever /** 1205c7b2cae8SChuck Lever * xs_tcp_write_space - callback invoked when socket buffer space 1206c7b2cae8SChuck Lever * becomes available 1207c7b2cae8SChuck Lever * @sk: socket whose state has changed 1208c7b2cae8SChuck Lever * 1209c7b2cae8SChuck Lever * Called when more output buffer space is available for this socket. 1210c7b2cae8SChuck Lever * We try not to wake our writers until they can make "significant" 1211c7b2cae8SChuck Lever * progress, otherwise we'll waste resources thrashing kernel_sendmsg 1212c7b2cae8SChuck Lever * with a bunch of small requests. 1213c7b2cae8SChuck Lever */ 1214c7b2cae8SChuck Lever static void xs_tcp_write_space(struct sock *sk) 1215c7b2cae8SChuck Lever { 1216c7b2cae8SChuck Lever read_lock(&sk->sk_callback_lock); 1217c7b2cae8SChuck Lever 1218c7b2cae8SChuck Lever /* from net/core/stream.c:sk_stream_write_space */ 1219c7b2cae8SChuck Lever if (sk_stream_wspace(sk) >= sk_stream_min_wspace(sk)) { 1220c7b2cae8SChuck Lever struct socket *sock; 1221c7b2cae8SChuck Lever struct rpc_xprt *xprt; 1222c7b2cae8SChuck Lever 1223c7b2cae8SChuck Lever if (unlikely(!(sock = sk->sk_socket))) 1224c7b2cae8SChuck Lever goto out; 1225c7b2cae8SChuck Lever if (unlikely(!(xprt = xprt_from_sock(sk)))) 1226c7b2cae8SChuck Lever goto out; 1227c7b2cae8SChuck Lever if (unlikely(!test_and_clear_bit(SOCK_NOSPACE, &sock->flags))) 1228a246b010SChuck Lever goto out; 1229a246b010SChuck Lever 1230c7b2cae8SChuck Lever xprt_write_space(xprt); 1231c7b2cae8SChuck Lever } 1232c7b2cae8SChuck Lever 1233a246b010SChuck Lever out: 1234a246b010SChuck Lever read_unlock(&sk->sk_callback_lock); 1235a246b010SChuck Lever } 1236a246b010SChuck Lever 1237470056c2SChuck Lever static void xs_udp_do_set_buffer_size(struct rpc_xprt *xprt) 1238a246b010SChuck Lever { 1239ee0ac0c2SChuck Lever struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt); 1240ee0ac0c2SChuck Lever struct sock *sk = transport->inet; 1241a246b010SChuck Lever 12427c6e066eSChuck Lever if (transport->rcvsize) { 1243a246b010SChuck Lever sk->sk_userlocks |= SOCK_RCVBUF_LOCK; 12447c6e066eSChuck Lever sk->sk_rcvbuf = transport->rcvsize * xprt->max_reqs * 2; 1245a246b010SChuck Lever } 12467c6e066eSChuck Lever if (transport->sndsize) { 1247a246b010SChuck Lever sk->sk_userlocks |= SOCK_SNDBUF_LOCK; 12487c6e066eSChuck Lever sk->sk_sndbuf = transport->sndsize * xprt->max_reqs * 2; 1249a246b010SChuck Lever sk->sk_write_space(sk); 1250a246b010SChuck Lever } 1251a246b010SChuck Lever } 1252a246b010SChuck Lever 125343118c29SChuck Lever /** 1254470056c2SChuck Lever * xs_udp_set_buffer_size - set send and receive limits 125543118c29SChuck Lever * @xprt: generic transport 1256470056c2SChuck Lever * @sndsize: requested size of send buffer, in bytes 1257470056c2SChuck Lever * @rcvsize: requested size of receive buffer, in bytes 125843118c29SChuck Lever * 1259470056c2SChuck Lever * Set socket send and receive buffer size limits. 126043118c29SChuck Lever */ 1261470056c2SChuck Lever static void xs_udp_set_buffer_size(struct rpc_xprt *xprt, size_t sndsize, size_t rcvsize) 126243118c29SChuck Lever { 12637c6e066eSChuck Lever struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt); 12647c6e066eSChuck Lever 12657c6e066eSChuck Lever transport->sndsize = 0; 1266470056c2SChuck Lever if (sndsize) 12677c6e066eSChuck Lever transport->sndsize = sndsize + 1024; 12687c6e066eSChuck Lever transport->rcvsize = 0; 1269470056c2SChuck Lever if (rcvsize) 12707c6e066eSChuck Lever transport->rcvsize = rcvsize + 1024; 1271470056c2SChuck Lever 1272470056c2SChuck Lever xs_udp_do_set_buffer_size(xprt); 127343118c29SChuck Lever } 127443118c29SChuck Lever 127546c0ee8bSChuck Lever /** 127646c0ee8bSChuck Lever * xs_udp_timer - called when a retransmit timeout occurs on a UDP transport 127746c0ee8bSChuck Lever * @task: task that timed out 127846c0ee8bSChuck Lever * 127946c0ee8bSChuck Lever * Adjust the congestion window after a retransmit timeout has occurred. 128046c0ee8bSChuck Lever */ 128146c0ee8bSChuck Lever static void xs_udp_timer(struct rpc_task *task) 128246c0ee8bSChuck Lever { 128346c0ee8bSChuck Lever xprt_adjust_cwnd(task, -ETIMEDOUT); 128446c0ee8bSChuck Lever } 128546c0ee8bSChuck Lever 1286b85d8806SChuck Lever static unsigned short xs_get_random_port(void) 1287b85d8806SChuck Lever { 1288b85d8806SChuck Lever unsigned short range = xprt_max_resvport - xprt_min_resvport; 1289b85d8806SChuck Lever unsigned short rand = (unsigned short) net_random() % range; 1290b85d8806SChuck Lever return rand + xprt_min_resvport; 1291b85d8806SChuck Lever } 1292b85d8806SChuck Lever 129392200412SChuck Lever /** 129492200412SChuck Lever * xs_set_port - reset the port number in the remote endpoint address 129592200412SChuck Lever * @xprt: generic transport 129692200412SChuck Lever * @port: new port number 129792200412SChuck Lever * 129892200412SChuck Lever */ 129992200412SChuck Lever static void xs_set_port(struct rpc_xprt *xprt, unsigned short port) 130092200412SChuck Lever { 130195392c59SChuck Lever struct sockaddr *addr = xs_addr(xprt); 1302c4efcb1dSChuck Lever 130392200412SChuck Lever dprintk("RPC: setting port for xprt %p to %u\n", xprt, port); 1304c4efcb1dSChuck Lever 130520612005SChuck Lever switch (addr->sa_family) { 130620612005SChuck Lever case AF_INET: 130720612005SChuck Lever ((struct sockaddr_in *)addr)->sin_port = htons(port); 130820612005SChuck Lever break; 130920612005SChuck Lever case AF_INET6: 131020612005SChuck Lever ((struct sockaddr_in6 *)addr)->sin6_port = htons(port); 131120612005SChuck Lever break; 131220612005SChuck Lever default: 131320612005SChuck Lever BUG(); 131420612005SChuck Lever } 131592200412SChuck Lever } 131692200412SChuck Lever 131767a391d7STrond Myklebust static unsigned short xs_get_srcport(struct sock_xprt *transport, struct socket *sock) 131867a391d7STrond Myklebust { 131967a391d7STrond Myklebust unsigned short port = transport->port; 132067a391d7STrond Myklebust 132167a391d7STrond Myklebust if (port == 0 && transport->xprt.resvport) 132267a391d7STrond Myklebust port = xs_get_random_port(); 132367a391d7STrond Myklebust return port; 132467a391d7STrond Myklebust } 132567a391d7STrond Myklebust 132667a391d7STrond Myklebust static unsigned short xs_next_srcport(struct sock_xprt *transport, struct socket *sock, unsigned short port) 132767a391d7STrond Myklebust { 132867a391d7STrond Myklebust if (transport->port != 0) 132967a391d7STrond Myklebust transport->port = 0; 133067a391d7STrond Myklebust if (!transport->xprt.resvport) 133167a391d7STrond Myklebust return 0; 133267a391d7STrond Myklebust if (port <= xprt_min_resvport || port > xprt_max_resvport) 133367a391d7STrond Myklebust return xprt_max_resvport; 133467a391d7STrond Myklebust return --port; 133567a391d7STrond Myklebust } 133667a391d7STrond Myklebust 13377dc753f0SChuck Lever static int xs_bind4(struct sock_xprt *transport, struct socket *sock) 1338a246b010SChuck Lever { 1339a246b010SChuck Lever struct sockaddr_in myaddr = { 1340a246b010SChuck Lever .sin_family = AF_INET, 1341a246b010SChuck Lever }; 1342d3bc9a1dSFrank van Maarseveen struct sockaddr_in *sa; 134367a391d7STrond Myklebust int err, nloop = 0; 134467a391d7STrond Myklebust unsigned short port = xs_get_srcport(transport, sock); 134567a391d7STrond Myklebust unsigned short last; 1346a246b010SChuck Lever 1347d3bc9a1dSFrank van Maarseveen sa = (struct sockaddr_in *)&transport->addr; 1348d3bc9a1dSFrank van Maarseveen myaddr.sin_addr = sa->sin_addr; 1349a246b010SChuck Lever do { 1350a246b010SChuck Lever myaddr.sin_port = htons(port); 1351e6242e92SSridhar Samudrala err = kernel_bind(sock, (struct sockaddr *) &myaddr, 1352a246b010SChuck Lever sizeof(myaddr)); 135367a391d7STrond Myklebust if (port == 0) 1354d3bc9a1dSFrank van Maarseveen break; 1355a246b010SChuck Lever if (err == 0) { 1356c8475461SChuck Lever transport->port = port; 1357d3bc9a1dSFrank van Maarseveen break; 1358a246b010SChuck Lever } 135967a391d7STrond Myklebust last = port; 136067a391d7STrond Myklebust port = xs_next_srcport(transport, sock, port); 136167a391d7STrond Myklebust if (port > last) 136267a391d7STrond Myklebust nloop++; 136367a391d7STrond Myklebust } while (err == -EADDRINUSE && nloop != 2); 13647dc753f0SChuck Lever dprintk("RPC: %s "NIPQUAD_FMT":%u: %s (%d)\n", 13657dc753f0SChuck Lever __FUNCTION__, NIPQUAD(myaddr.sin_addr), 13667dc753f0SChuck Lever port, err ? "failed" : "ok", err); 1367a246b010SChuck Lever return err; 1368a246b010SChuck Lever } 1369a246b010SChuck Lever 137090058d37SChuck Lever static int xs_bind6(struct sock_xprt *transport, struct socket *sock) 137190058d37SChuck Lever { 137290058d37SChuck Lever struct sockaddr_in6 myaddr = { 137390058d37SChuck Lever .sin6_family = AF_INET6, 137490058d37SChuck Lever }; 137590058d37SChuck Lever struct sockaddr_in6 *sa; 137667a391d7STrond Myklebust int err, nloop = 0; 137767a391d7STrond Myklebust unsigned short port = xs_get_srcport(transport, sock); 137867a391d7STrond Myklebust unsigned short last; 137990058d37SChuck Lever 138090058d37SChuck Lever sa = (struct sockaddr_in6 *)&transport->addr; 138190058d37SChuck Lever myaddr.sin6_addr = sa->sin6_addr; 138290058d37SChuck Lever do { 138390058d37SChuck Lever myaddr.sin6_port = htons(port); 138490058d37SChuck Lever err = kernel_bind(sock, (struct sockaddr *) &myaddr, 138590058d37SChuck Lever sizeof(myaddr)); 138667a391d7STrond Myklebust if (port == 0) 138790058d37SChuck Lever break; 138890058d37SChuck Lever if (err == 0) { 138990058d37SChuck Lever transport->port = port; 139090058d37SChuck Lever break; 139190058d37SChuck Lever } 139267a391d7STrond Myklebust last = port; 139367a391d7STrond Myklebust port = xs_next_srcport(transport, sock, port); 139467a391d7STrond Myklebust if (port > last) 139567a391d7STrond Myklebust nloop++; 139667a391d7STrond Myklebust } while (err == -EADDRINUSE && nloop != 2); 139790058d37SChuck Lever dprintk("RPC: xs_bind6 "NIP6_FMT":%u: %s (%d)\n", 139890058d37SChuck Lever NIP6(myaddr.sin6_addr), port, err ? "failed" : "ok", err); 1399a246b010SChuck Lever return err; 1400a246b010SChuck Lever } 1401a246b010SChuck Lever 1402ed07536eSPeter Zijlstra #ifdef CONFIG_DEBUG_LOCK_ALLOC 1403ed07536eSPeter Zijlstra static struct lock_class_key xs_key[2]; 1404ed07536eSPeter Zijlstra static struct lock_class_key xs_slock_key[2]; 1405ed07536eSPeter Zijlstra 14068945ee5eSChuck Lever static inline void xs_reclassify_socket4(struct socket *sock) 1407ed07536eSPeter Zijlstra { 1408ed07536eSPeter Zijlstra struct sock *sk = sock->sk; 14098945ee5eSChuck Lever 141002b3d346SJohn Heffner BUG_ON(sock_owned_by_user(sk)); 14118945ee5eSChuck Lever sock_lock_init_class_and_name(sk, "slock-AF_INET-RPC", 14128945ee5eSChuck Lever &xs_slock_key[0], "sk_lock-AF_INET-RPC", &xs_key[0]); 1413ed07536eSPeter Zijlstra } 14148945ee5eSChuck Lever 14158945ee5eSChuck Lever static inline void xs_reclassify_socket6(struct socket *sock) 14168945ee5eSChuck Lever { 14178945ee5eSChuck Lever struct sock *sk = sock->sk; 14188945ee5eSChuck Lever 1419f4921affSLinus Torvalds BUG_ON(sock_owned_by_user(sk)); 14208945ee5eSChuck Lever sock_lock_init_class_and_name(sk, "slock-AF_INET6-RPC", 14218945ee5eSChuck Lever &xs_slock_key[1], "sk_lock-AF_INET6-RPC", &xs_key[1]); 1422ed07536eSPeter Zijlstra } 1423ed07536eSPeter Zijlstra #else 14248945ee5eSChuck Lever static inline void xs_reclassify_socket4(struct socket *sock) 14258945ee5eSChuck Lever { 14268945ee5eSChuck Lever } 14278945ee5eSChuck Lever 14288945ee5eSChuck Lever static inline void xs_reclassify_socket6(struct socket *sock) 1429ed07536eSPeter Zijlstra { 1430ed07536eSPeter Zijlstra } 1431ed07536eSPeter Zijlstra #endif 1432ed07536eSPeter Zijlstra 143316be2d20SChuck Lever static void xs_udp_finish_connecting(struct rpc_xprt *xprt, struct socket *sock) 1434a246b010SChuck Lever { 143516be2d20SChuck Lever struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt); 1436edb267a6SChuck Lever 1437ee0ac0c2SChuck Lever if (!transport->inet) { 1438b0d93ad5SChuck Lever struct sock *sk = sock->sk; 1439b0d93ad5SChuck Lever 1440b0d93ad5SChuck Lever write_lock_bh(&sk->sk_callback_lock); 1441b0d93ad5SChuck Lever 1442b0d93ad5SChuck Lever sk->sk_user_data = xprt; 1443314dfd79SChuck Lever transport->old_data_ready = sk->sk_data_ready; 1444314dfd79SChuck Lever transport->old_state_change = sk->sk_state_change; 1445314dfd79SChuck Lever transport->old_write_space = sk->sk_write_space; 1446b0d93ad5SChuck Lever sk->sk_data_ready = xs_udp_data_ready; 1447b0d93ad5SChuck Lever sk->sk_write_space = xs_udp_write_space; 1448b0d93ad5SChuck Lever sk->sk_no_check = UDP_CSUM_NORCV; 1449b079fa7bSTrond Myklebust sk->sk_allocation = GFP_ATOMIC; 1450b0d93ad5SChuck Lever 1451b0d93ad5SChuck Lever xprt_set_connected(xprt); 1452b0d93ad5SChuck Lever 1453b0d93ad5SChuck Lever /* Reset to new socket */ 1454ee0ac0c2SChuck Lever transport->sock = sock; 1455ee0ac0c2SChuck Lever transport->inet = sk; 1456b0d93ad5SChuck Lever 1457b0d93ad5SChuck Lever write_unlock_bh(&sk->sk_callback_lock); 1458b0d93ad5SChuck Lever } 1459470056c2SChuck Lever xs_udp_do_set_buffer_size(xprt); 146016be2d20SChuck Lever } 146116be2d20SChuck Lever 1462a246b010SChuck Lever /** 14639c3d72deSChuck Lever * xs_udp_connect_worker4 - set up a UDP socket 1464a246b010SChuck Lever * @work: RPC transport to connect 1465a246b010SChuck Lever * 1466a246b010SChuck Lever * Invoked by a work queue tasklet. 1467a246b010SChuck Lever */ 14689c3d72deSChuck Lever static void xs_udp_connect_worker4(struct work_struct *work) 1469a246b010SChuck Lever { 1470a246b010SChuck Lever struct sock_xprt *transport = 1471a246b010SChuck Lever container_of(work, struct sock_xprt, connect_worker.work); 1472a246b010SChuck Lever struct rpc_xprt *xprt = &transport->xprt; 1473a246b010SChuck Lever struct socket *sock = transport->sock; 1474a246b010SChuck Lever int err, status = -EIO; 1475a246b010SChuck Lever 1476a246b010SChuck Lever if (xprt->shutdown || !xprt_bound(xprt)) 14779903cd1cSChuck Lever goto out; 14789903cd1cSChuck Lever 1479a246b010SChuck Lever /* Start by resetting any existing state */ 1480a246b010SChuck Lever xs_close(xprt); 1481a246b010SChuck Lever 14829903cd1cSChuck Lever if ((err = sock_create_kern(PF_INET, SOCK_DGRAM, IPPROTO_UDP, &sock)) < 0) { 14839903cd1cSChuck Lever dprintk("RPC: can't create UDP transport socket (%d).\n", -err); 1484a246b010SChuck Lever goto out; 1485a246b010SChuck Lever } 14868945ee5eSChuck Lever xs_reclassify_socket4(sock); 1487a246b010SChuck Lever 14887dc753f0SChuck Lever if (xs_bind4(transport, sock)) { 14899903cd1cSChuck Lever sock_release(sock); 14909903cd1cSChuck Lever goto out; 1491a246b010SChuck Lever } 1492b0d93ad5SChuck Lever 1493b0d93ad5SChuck Lever dprintk("RPC: worker connecting xprt %p to address: %s\n", 1494b0d93ad5SChuck Lever xprt, xprt->address_strings[RPC_DISPLAY_ALL]); 1495b0d93ad5SChuck Lever 149616be2d20SChuck Lever xs_udp_finish_connecting(xprt, sock); 1497a246b010SChuck Lever status = 0; 1498b0d93ad5SChuck Lever out: 1499b0d93ad5SChuck Lever xprt_wake_pending_tasks(xprt, status); 1500b0d93ad5SChuck Lever xprt_clear_connecting(xprt); 1501b0d93ad5SChuck Lever } 1502b0d93ad5SChuck Lever 150368e220bdSChuck Lever /** 150468e220bdSChuck Lever * xs_udp_connect_worker6 - set up a UDP socket 150568e220bdSChuck Lever * @work: RPC transport to connect 150668e220bdSChuck Lever * 150768e220bdSChuck Lever * Invoked by a work queue tasklet. 150868e220bdSChuck Lever */ 150968e220bdSChuck Lever static void xs_udp_connect_worker6(struct work_struct *work) 151068e220bdSChuck Lever { 151168e220bdSChuck Lever struct sock_xprt *transport = 151268e220bdSChuck Lever container_of(work, struct sock_xprt, connect_worker.work); 151368e220bdSChuck Lever struct rpc_xprt *xprt = &transport->xprt; 151468e220bdSChuck Lever struct socket *sock = transport->sock; 151568e220bdSChuck Lever int err, status = -EIO; 151668e220bdSChuck Lever 151768e220bdSChuck Lever if (xprt->shutdown || !xprt_bound(xprt)) 151868e220bdSChuck Lever goto out; 151968e220bdSChuck Lever 152068e220bdSChuck Lever /* Start by resetting any existing state */ 152168e220bdSChuck Lever xs_close(xprt); 152268e220bdSChuck Lever 152368e220bdSChuck Lever if ((err = sock_create_kern(PF_INET6, SOCK_DGRAM, IPPROTO_UDP, &sock)) < 0) { 152468e220bdSChuck Lever dprintk("RPC: can't create UDP transport socket (%d).\n", -err); 152568e220bdSChuck Lever goto out; 152668e220bdSChuck Lever } 15278945ee5eSChuck Lever xs_reclassify_socket6(sock); 152868e220bdSChuck Lever 152968e220bdSChuck Lever if (xs_bind6(transport, sock) < 0) { 153068e220bdSChuck Lever sock_release(sock); 153168e220bdSChuck Lever goto out; 153268e220bdSChuck Lever } 153368e220bdSChuck Lever 153468e220bdSChuck Lever dprintk("RPC: worker connecting xprt %p to address: %s\n", 153568e220bdSChuck Lever xprt, xprt->address_strings[RPC_DISPLAY_ALL]); 153668e220bdSChuck Lever 153768e220bdSChuck Lever xs_udp_finish_connecting(xprt, sock); 1538a246b010SChuck Lever status = 0; 1539b0d93ad5SChuck Lever out: 1540b0d93ad5SChuck Lever xprt_wake_pending_tasks(xprt, status); 1541b0d93ad5SChuck Lever xprt_clear_connecting(xprt); 1542b0d93ad5SChuck Lever } 1543b0d93ad5SChuck Lever 15443167e12cSChuck Lever /* 15453167e12cSChuck Lever * We need to preserve the port number so the reply cache on the server can 15463167e12cSChuck Lever * find our cached RPC replies when we get around to reconnecting. 15473167e12cSChuck Lever */ 15483167e12cSChuck Lever static void xs_tcp_reuse_connection(struct rpc_xprt *xprt) 15493167e12cSChuck Lever { 15503167e12cSChuck Lever int result; 1551ee0ac0c2SChuck Lever struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt); 15523167e12cSChuck Lever struct sockaddr any; 15533167e12cSChuck Lever 15543167e12cSChuck Lever dprintk("RPC: disconnecting xprt %p to reuse port\n", xprt); 15553167e12cSChuck Lever 15563167e12cSChuck Lever /* 15573167e12cSChuck Lever * Disconnect the transport socket by doing a connect operation 15583167e12cSChuck Lever * with AF_UNSPEC. This should return immediately... 15593167e12cSChuck Lever */ 15603167e12cSChuck Lever memset(&any, 0, sizeof(any)); 15613167e12cSChuck Lever any.sa_family = AF_UNSPEC; 1562ee0ac0c2SChuck Lever result = kernel_connect(transport->sock, &any, sizeof(any), 0); 15633167e12cSChuck Lever if (result) 15643167e12cSChuck Lever dprintk("RPC: AF_UNSPEC connect return code %d\n", 15653167e12cSChuck Lever result); 15663167e12cSChuck Lever } 15673167e12cSChuck Lever 156816be2d20SChuck Lever static int xs_tcp_finish_connecting(struct rpc_xprt *xprt, struct socket *sock) 1569b0d93ad5SChuck Lever { 157016be2d20SChuck Lever struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt); 1571edb267a6SChuck Lever 1572ee0ac0c2SChuck Lever if (!transport->inet) { 1573b0d93ad5SChuck Lever struct sock *sk = sock->sk; 1574b0d93ad5SChuck Lever 1575b0d93ad5SChuck Lever write_lock_bh(&sk->sk_callback_lock); 1576b0d93ad5SChuck Lever 1577b0d93ad5SChuck Lever sk->sk_user_data = xprt; 1578314dfd79SChuck Lever transport->old_data_ready = sk->sk_data_ready; 1579314dfd79SChuck Lever transport->old_state_change = sk->sk_state_change; 1580314dfd79SChuck Lever transport->old_write_space = sk->sk_write_space; 1581b0d93ad5SChuck Lever sk->sk_data_ready = xs_tcp_data_ready; 1582b0d93ad5SChuck Lever sk->sk_state_change = xs_tcp_state_change; 1583b0d93ad5SChuck Lever sk->sk_write_space = xs_tcp_write_space; 1584b079fa7bSTrond Myklebust sk->sk_allocation = GFP_ATOMIC; 15853167e12cSChuck Lever 15863167e12cSChuck Lever /* socket options */ 15873167e12cSChuck Lever sk->sk_userlocks |= SOCK_BINDPORT_LOCK; 15883167e12cSChuck Lever sock_reset_flag(sk, SOCK_LINGER); 15893167e12cSChuck Lever tcp_sk(sk)->linger2 = 0; 15903167e12cSChuck Lever tcp_sk(sk)->nonagle |= TCP_NAGLE_OFF; 1591b0d93ad5SChuck Lever 1592b0d93ad5SChuck Lever xprt_clear_connected(xprt); 1593b0d93ad5SChuck Lever 1594b0d93ad5SChuck Lever /* Reset to new socket */ 1595ee0ac0c2SChuck Lever transport->sock = sock; 1596ee0ac0c2SChuck Lever transport->inet = sk; 1597b0d93ad5SChuck Lever 1598b0d93ad5SChuck Lever write_unlock_bh(&sk->sk_callback_lock); 1599b0d93ad5SChuck Lever } 1600b0d93ad5SChuck Lever 1601b0d93ad5SChuck Lever /* Tell the socket layer to start connecting... */ 1602262ca07dSChuck Lever xprt->stat.connect_count++; 1603262ca07dSChuck Lever xprt->stat.connect_start = jiffies; 160495392c59SChuck Lever return kernel_connect(sock, xs_addr(xprt), xprt->addrlen, O_NONBLOCK); 160516be2d20SChuck Lever } 160616be2d20SChuck Lever 160716be2d20SChuck Lever /** 16089c3d72deSChuck Lever * xs_tcp_connect_worker4 - connect a TCP socket to a remote endpoint 160916be2d20SChuck Lever * @work: RPC transport to connect 161016be2d20SChuck Lever * 161116be2d20SChuck Lever * Invoked by a work queue tasklet. 161216be2d20SChuck Lever */ 16139c3d72deSChuck Lever static void xs_tcp_connect_worker4(struct work_struct *work) 161416be2d20SChuck Lever { 161516be2d20SChuck Lever struct sock_xprt *transport = 161616be2d20SChuck Lever container_of(work, struct sock_xprt, connect_worker.work); 161716be2d20SChuck Lever struct rpc_xprt *xprt = &transport->xprt; 161816be2d20SChuck Lever struct socket *sock = transport->sock; 161916be2d20SChuck Lever int err, status = -EIO; 162016be2d20SChuck Lever 162116be2d20SChuck Lever if (xprt->shutdown || !xprt_bound(xprt)) 162216be2d20SChuck Lever goto out; 162316be2d20SChuck Lever 162416be2d20SChuck Lever if (!sock) { 162516be2d20SChuck Lever /* start from scratch */ 162616be2d20SChuck Lever if ((err = sock_create_kern(PF_INET, SOCK_STREAM, IPPROTO_TCP, &sock)) < 0) { 162716be2d20SChuck Lever dprintk("RPC: can't create TCP transport socket (%d).\n", -err); 162816be2d20SChuck Lever goto out; 162916be2d20SChuck Lever } 16308945ee5eSChuck Lever xs_reclassify_socket4(sock); 163116be2d20SChuck Lever 163216be2d20SChuck Lever if (xs_bind4(transport, sock) < 0) { 163316be2d20SChuck Lever sock_release(sock); 163416be2d20SChuck Lever goto out; 163516be2d20SChuck Lever } 163616be2d20SChuck Lever } else 163716be2d20SChuck Lever /* "close" the socket, preserving the local port */ 163816be2d20SChuck Lever xs_tcp_reuse_connection(xprt); 163916be2d20SChuck Lever 164016be2d20SChuck Lever dprintk("RPC: worker connecting xprt %p to address: %s\n", 164116be2d20SChuck Lever xprt, xprt->address_strings[RPC_DISPLAY_ALL]); 164216be2d20SChuck Lever 164316be2d20SChuck Lever status = xs_tcp_finish_connecting(xprt, sock); 1644a246b010SChuck Lever dprintk("RPC: %p connect status %d connected %d sock state %d\n", 164546121cf7SChuck Lever xprt, -status, xprt_connected(xprt), 164646121cf7SChuck Lever sock->sk->sk_state); 1647a246b010SChuck Lever if (status < 0) { 1648a246b010SChuck Lever switch (status) { 1649a246b010SChuck Lever case -EINPROGRESS: 1650a246b010SChuck Lever case -EALREADY: 1651a246b010SChuck Lever goto out_clear; 16523167e12cSChuck Lever case -ECONNREFUSED: 16533167e12cSChuck Lever case -ECONNRESET: 16543167e12cSChuck Lever /* retry with existing socket, after a delay */ 16553167e12cSChuck Lever break; 16563167e12cSChuck Lever default: 16573167e12cSChuck Lever /* get rid of existing socket, and retry */ 1658e06799f9STrond Myklebust xs_tcp_shutdown(xprt); 1659a246b010SChuck Lever } 1660a246b010SChuck Lever } 1661a246b010SChuck Lever out: 166244fbac22SChuck Lever xprt_wake_pending_tasks(xprt, status); 1663a246b010SChuck Lever out_clear: 16642226feb6SChuck Lever xprt_clear_connecting(xprt); 1665a246b010SChuck Lever } 1666a246b010SChuck Lever 16679903cd1cSChuck Lever /** 166868e220bdSChuck Lever * xs_tcp_connect_worker6 - connect a TCP socket to a remote endpoint 166968e220bdSChuck Lever * @work: RPC transport to connect 167068e220bdSChuck Lever * 167168e220bdSChuck Lever * Invoked by a work queue tasklet. 167268e220bdSChuck Lever */ 167368e220bdSChuck Lever static void xs_tcp_connect_worker6(struct work_struct *work) 167468e220bdSChuck Lever { 167568e220bdSChuck Lever struct sock_xprt *transport = 167668e220bdSChuck Lever container_of(work, struct sock_xprt, connect_worker.work); 167768e220bdSChuck Lever struct rpc_xprt *xprt = &transport->xprt; 167868e220bdSChuck Lever struct socket *sock = transport->sock; 167968e220bdSChuck Lever int err, status = -EIO; 168068e220bdSChuck Lever 168168e220bdSChuck Lever if (xprt->shutdown || !xprt_bound(xprt)) 168268e220bdSChuck Lever goto out; 168368e220bdSChuck Lever 168468e220bdSChuck Lever if (!sock) { 168568e220bdSChuck Lever /* start from scratch */ 168668e220bdSChuck Lever if ((err = sock_create_kern(PF_INET6, SOCK_STREAM, IPPROTO_TCP, &sock)) < 0) { 168768e220bdSChuck Lever dprintk("RPC: can't create TCP transport socket (%d).\n", -err); 168868e220bdSChuck Lever goto out; 168968e220bdSChuck Lever } 16908945ee5eSChuck Lever xs_reclassify_socket6(sock); 169168e220bdSChuck Lever 169268e220bdSChuck Lever if (xs_bind6(transport, sock) < 0) { 169368e220bdSChuck Lever sock_release(sock); 169468e220bdSChuck Lever goto out; 169568e220bdSChuck Lever } 169668e220bdSChuck Lever } else 169768e220bdSChuck Lever /* "close" the socket, preserving the local port */ 169868e220bdSChuck Lever xs_tcp_reuse_connection(xprt); 169968e220bdSChuck Lever 170068e220bdSChuck Lever dprintk("RPC: worker connecting xprt %p to address: %s\n", 170168e220bdSChuck Lever xprt, xprt->address_strings[RPC_DISPLAY_ALL]); 170268e220bdSChuck Lever 170368e220bdSChuck Lever status = xs_tcp_finish_connecting(xprt, sock); 170468e220bdSChuck Lever dprintk("RPC: %p connect status %d connected %d sock state %d\n", 170568e220bdSChuck Lever xprt, -status, xprt_connected(xprt), sock->sk->sk_state); 170668e220bdSChuck Lever if (status < 0) { 170768e220bdSChuck Lever switch (status) { 170868e220bdSChuck Lever case -EINPROGRESS: 170968e220bdSChuck Lever case -EALREADY: 171068e220bdSChuck Lever goto out_clear; 171168e220bdSChuck Lever case -ECONNREFUSED: 171268e220bdSChuck Lever case -ECONNRESET: 171368e220bdSChuck Lever /* retry with existing socket, after a delay */ 171468e220bdSChuck Lever break; 171568e220bdSChuck Lever default: 171668e220bdSChuck Lever /* get rid of existing socket, and retry */ 1717e06799f9STrond Myklebust xs_tcp_shutdown(xprt); 171868e220bdSChuck Lever } 171968e220bdSChuck Lever } 172068e220bdSChuck Lever out: 172168e220bdSChuck Lever xprt_wake_pending_tasks(xprt, status); 172268e220bdSChuck Lever out_clear: 172368e220bdSChuck Lever xprt_clear_connecting(xprt); 172468e220bdSChuck Lever } 172568e220bdSChuck Lever 172668e220bdSChuck Lever /** 17279903cd1cSChuck Lever * xs_connect - connect a socket to a remote endpoint 17289903cd1cSChuck Lever * @task: address of RPC task that manages state of connect request 17299903cd1cSChuck Lever * 17309903cd1cSChuck Lever * TCP: If the remote end dropped the connection, delay reconnecting. 173103bf4b70SChuck Lever * 173203bf4b70SChuck Lever * UDP socket connects are synchronous, but we use a work queue anyway 173303bf4b70SChuck Lever * to guarantee that even unprivileged user processes can set up a 173403bf4b70SChuck Lever * socket on a privileged port. 173503bf4b70SChuck Lever * 173603bf4b70SChuck Lever * If a UDP socket connect fails, the delay behavior here prevents 173703bf4b70SChuck Lever * retry floods (hard mounts). 17389903cd1cSChuck Lever */ 17399903cd1cSChuck Lever static void xs_connect(struct rpc_task *task) 1740a246b010SChuck Lever { 1741a246b010SChuck Lever struct rpc_xprt *xprt = task->tk_xprt; 1742ee0ac0c2SChuck Lever struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt); 1743a246b010SChuck Lever 1744b0d93ad5SChuck Lever if (xprt_test_and_set_connecting(xprt)) 1745b0d93ad5SChuck Lever return; 1746b0d93ad5SChuck Lever 1747ee0ac0c2SChuck Lever if (transport->sock != NULL) { 174846121cf7SChuck Lever dprintk("RPC: xs_connect delayed xprt %p for %lu " 174946121cf7SChuck Lever "seconds\n", 175003bf4b70SChuck Lever xprt, xprt->reestablish_timeout / HZ); 1751c1384c9cSTrond Myklebust queue_delayed_work(rpciod_workqueue, 1752c1384c9cSTrond Myklebust &transport->connect_worker, 175303bf4b70SChuck Lever xprt->reestablish_timeout); 175403bf4b70SChuck Lever xprt->reestablish_timeout <<= 1; 175503bf4b70SChuck Lever if (xprt->reestablish_timeout > XS_TCP_MAX_REEST_TO) 175603bf4b70SChuck Lever xprt->reestablish_timeout = XS_TCP_MAX_REEST_TO; 17579903cd1cSChuck Lever } else { 17589903cd1cSChuck Lever dprintk("RPC: xs_connect scheduled xprt %p\n", xprt); 1759c1384c9cSTrond Myklebust queue_delayed_work(rpciod_workqueue, 1760c1384c9cSTrond Myklebust &transport->connect_worker, 0); 1761a246b010SChuck Lever } 1762a246b010SChuck Lever } 1763a246b010SChuck Lever 1764e06799f9STrond Myklebust static void xs_tcp_connect(struct rpc_task *task) 1765e06799f9STrond Myklebust { 1766e06799f9STrond Myklebust struct rpc_xprt *xprt = task->tk_xprt; 1767e06799f9STrond Myklebust 1768e06799f9STrond Myklebust /* Initiate graceful shutdown of the socket if not already done */ 1769e06799f9STrond Myklebust if (test_bit(XPRT_CONNECTED, &xprt->state)) 1770e06799f9STrond Myklebust xs_tcp_shutdown(xprt); 1771e06799f9STrond Myklebust /* Exit if we need to wait for socket shutdown to complete */ 1772e06799f9STrond Myklebust if (test_bit(XPRT_CLOSING, &xprt->state)) 1773e06799f9STrond Myklebust return; 1774e06799f9STrond Myklebust xs_connect(task); 1775e06799f9STrond Myklebust } 1776e06799f9STrond Myklebust 1777262ca07dSChuck Lever /** 1778262ca07dSChuck Lever * xs_udp_print_stats - display UDP socket-specifc stats 1779262ca07dSChuck Lever * @xprt: rpc_xprt struct containing statistics 1780262ca07dSChuck Lever * @seq: output file 1781262ca07dSChuck Lever * 1782262ca07dSChuck Lever */ 1783262ca07dSChuck Lever static void xs_udp_print_stats(struct rpc_xprt *xprt, struct seq_file *seq) 1784262ca07dSChuck Lever { 1785c8475461SChuck Lever struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt); 1786c8475461SChuck Lever 1787262ca07dSChuck Lever seq_printf(seq, "\txprt:\tudp %u %lu %lu %lu %lu %Lu %Lu\n", 1788c8475461SChuck Lever transport->port, 1789262ca07dSChuck Lever xprt->stat.bind_count, 1790262ca07dSChuck Lever xprt->stat.sends, 1791262ca07dSChuck Lever xprt->stat.recvs, 1792262ca07dSChuck Lever xprt->stat.bad_xids, 1793262ca07dSChuck Lever xprt->stat.req_u, 1794262ca07dSChuck Lever xprt->stat.bklog_u); 1795262ca07dSChuck Lever } 1796262ca07dSChuck Lever 1797262ca07dSChuck Lever /** 1798262ca07dSChuck Lever * xs_tcp_print_stats - display TCP socket-specifc stats 1799262ca07dSChuck Lever * @xprt: rpc_xprt struct containing statistics 1800262ca07dSChuck Lever * @seq: output file 1801262ca07dSChuck Lever * 1802262ca07dSChuck Lever */ 1803262ca07dSChuck Lever static void xs_tcp_print_stats(struct rpc_xprt *xprt, struct seq_file *seq) 1804262ca07dSChuck Lever { 1805c8475461SChuck Lever struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt); 1806262ca07dSChuck Lever long idle_time = 0; 1807262ca07dSChuck Lever 1808262ca07dSChuck Lever if (xprt_connected(xprt)) 1809262ca07dSChuck Lever idle_time = (long)(jiffies - xprt->last_used) / HZ; 1810262ca07dSChuck Lever 1811262ca07dSChuck Lever seq_printf(seq, "\txprt:\ttcp %u %lu %lu %lu %ld %lu %lu %lu %Lu %Lu\n", 1812c8475461SChuck Lever transport->port, 1813262ca07dSChuck Lever xprt->stat.bind_count, 1814262ca07dSChuck Lever xprt->stat.connect_count, 1815262ca07dSChuck Lever xprt->stat.connect_time, 1816262ca07dSChuck Lever idle_time, 1817262ca07dSChuck Lever xprt->stat.sends, 1818262ca07dSChuck Lever xprt->stat.recvs, 1819262ca07dSChuck Lever xprt->stat.bad_xids, 1820262ca07dSChuck Lever xprt->stat.req_u, 1821262ca07dSChuck Lever xprt->stat.bklog_u); 1822262ca07dSChuck Lever } 1823262ca07dSChuck Lever 1824262965f5SChuck Lever static struct rpc_xprt_ops xs_udp_ops = { 182543118c29SChuck Lever .set_buffer_size = xs_udp_set_buffer_size, 182612a80469SChuck Lever .reserve_xprt = xprt_reserve_xprt_cong, 182749e9a890SChuck Lever .release_xprt = xprt_release_xprt_cong, 182845160d62SChuck Lever .rpcbind = rpcb_getport_async, 182992200412SChuck Lever .set_port = xs_set_port, 18309903cd1cSChuck Lever .connect = xs_connect, 183102107148SChuck Lever .buf_alloc = rpc_malloc, 183202107148SChuck Lever .buf_free = rpc_free, 1833262965f5SChuck Lever .send_request = xs_udp_send_request, 1834fe3aca29SChuck Lever .set_retrans_timeout = xprt_set_retrans_timeout_rtt, 183546c0ee8bSChuck Lever .timer = xs_udp_timer, 1836a58dd398SChuck Lever .release_request = xprt_release_rqst_cong, 1837262965f5SChuck Lever .close = xs_close, 1838262965f5SChuck Lever .destroy = xs_destroy, 1839262ca07dSChuck Lever .print_stats = xs_udp_print_stats, 1840262965f5SChuck Lever }; 1841262965f5SChuck Lever 1842262965f5SChuck Lever static struct rpc_xprt_ops xs_tcp_ops = { 184312a80469SChuck Lever .reserve_xprt = xprt_reserve_xprt, 1844e0ab53deSTrond Myklebust .release_xprt = xs_tcp_release_xprt, 184545160d62SChuck Lever .rpcbind = rpcb_getport_async, 184692200412SChuck Lever .set_port = xs_set_port, 1847e06799f9STrond Myklebust .connect = xs_tcp_connect, 184802107148SChuck Lever .buf_alloc = rpc_malloc, 184902107148SChuck Lever .buf_free = rpc_free, 1850262965f5SChuck Lever .send_request = xs_tcp_send_request, 1851fe3aca29SChuck Lever .set_retrans_timeout = xprt_set_retrans_timeout_def, 1852e06799f9STrond Myklebust .close = xs_tcp_shutdown, 18539903cd1cSChuck Lever .destroy = xs_destroy, 1854262ca07dSChuck Lever .print_stats = xs_tcp_print_stats, 1855a246b010SChuck Lever }; 1856a246b010SChuck Lever 18573c341b0bS\"Talpey, Thomas\ static struct rpc_xprt *xs_setup_xprt(struct xprt_create *args, 1858bc25571eS\"Talpey, Thomas\ unsigned int slot_table_size) 1859c8541ecdSChuck Lever { 1860c8541ecdSChuck Lever struct rpc_xprt *xprt; 1861ffc2e518SChuck Lever struct sock_xprt *new; 1862c8541ecdSChuck Lever 186396802a09SFrank van Maarseveen if (args->addrlen > sizeof(xprt->addr)) { 1864c8541ecdSChuck Lever dprintk("RPC: xs_setup_xprt: address too large\n"); 1865c8541ecdSChuck Lever return ERR_PTR(-EBADF); 1866c8541ecdSChuck Lever } 1867c8541ecdSChuck Lever 1868ffc2e518SChuck Lever new = kzalloc(sizeof(*new), GFP_KERNEL); 1869ffc2e518SChuck Lever if (new == NULL) { 187046121cf7SChuck Lever dprintk("RPC: xs_setup_xprt: couldn't allocate " 187146121cf7SChuck Lever "rpc_xprt\n"); 1872c8541ecdSChuck Lever return ERR_PTR(-ENOMEM); 1873c8541ecdSChuck Lever } 1874ffc2e518SChuck Lever xprt = &new->xprt; 1875c8541ecdSChuck Lever 1876c8541ecdSChuck Lever xprt->max_reqs = slot_table_size; 1877c8541ecdSChuck Lever xprt->slot = kcalloc(xprt->max_reqs, sizeof(struct rpc_rqst), GFP_KERNEL); 1878c8541ecdSChuck Lever if (xprt->slot == NULL) { 1879c8541ecdSChuck Lever kfree(xprt); 188046121cf7SChuck Lever dprintk("RPC: xs_setup_xprt: couldn't allocate slot " 188146121cf7SChuck Lever "table\n"); 1882c8541ecdSChuck Lever return ERR_PTR(-ENOMEM); 1883c8541ecdSChuck Lever } 1884c8541ecdSChuck Lever 188596802a09SFrank van Maarseveen memcpy(&xprt->addr, args->dstaddr, args->addrlen); 188696802a09SFrank van Maarseveen xprt->addrlen = args->addrlen; 1887d3bc9a1dSFrank van Maarseveen if (args->srcaddr) 1888d3bc9a1dSFrank van Maarseveen memcpy(&new->addr, args->srcaddr, args->addrlen); 1889c8541ecdSChuck Lever 1890c8541ecdSChuck Lever return xprt; 1891c8541ecdSChuck Lever } 1892c8541ecdSChuck Lever 18932881ae74STrond Myklebust static const struct rpc_timeout xs_udp_default_timeout = { 18942881ae74STrond Myklebust .to_initval = 5 * HZ, 18952881ae74STrond Myklebust .to_maxval = 30 * HZ, 18962881ae74STrond Myklebust .to_increment = 5 * HZ, 18972881ae74STrond Myklebust .to_retries = 5, 18982881ae74STrond Myklebust }; 18992881ae74STrond Myklebust 19009903cd1cSChuck Lever /** 19019903cd1cSChuck Lever * xs_setup_udp - Set up transport to use a UDP socket 190296802a09SFrank van Maarseveen * @args: rpc transport creation arguments 19039903cd1cSChuck Lever * 19049903cd1cSChuck Lever */ 1905483066d6SAdrian Bunk static struct rpc_xprt *xs_setup_udp(struct xprt_create *args) 1906a246b010SChuck Lever { 19078f9d5b1aSChuck Lever struct sockaddr *addr = args->dstaddr; 1908c8541ecdSChuck Lever struct rpc_xprt *xprt; 1909c8475461SChuck Lever struct sock_xprt *transport; 1910a246b010SChuck Lever 191196802a09SFrank van Maarseveen xprt = xs_setup_xprt(args, xprt_udp_slot_table_entries); 1912c8541ecdSChuck Lever if (IS_ERR(xprt)) 1913c8541ecdSChuck Lever return xprt; 1914c8475461SChuck Lever transport = container_of(xprt, struct sock_xprt, xprt); 1915a246b010SChuck Lever 1916ec739ef0SChuck Lever xprt->prot = IPPROTO_UDP; 1917808012fbSChuck Lever xprt->tsh_size = 0; 1918a246b010SChuck Lever /* XXX: header size can vary due to auth type, IPv6, etc. */ 1919a246b010SChuck Lever xprt->max_payload = (1U << 16) - (MAX_HEADER << 3); 1920a246b010SChuck Lever 192103bf4b70SChuck Lever xprt->bind_timeout = XS_BIND_TO; 192203bf4b70SChuck Lever xprt->connect_timeout = XS_UDP_CONN_TO; 192303bf4b70SChuck Lever xprt->reestablish_timeout = XS_UDP_REEST_TO; 192403bf4b70SChuck Lever xprt->idle_timeout = XS_IDLE_DISC_TO; 1925a246b010SChuck Lever 1926262965f5SChuck Lever xprt->ops = &xs_udp_ops; 1927a246b010SChuck Lever 1928ba7392bbSTrond Myklebust xprt->timeout = &xs_udp_default_timeout; 1929a246b010SChuck Lever 19308f9d5b1aSChuck Lever switch (addr->sa_family) { 19318f9d5b1aSChuck Lever case AF_INET: 19328f9d5b1aSChuck Lever if (((struct sockaddr_in *)addr)->sin_port != htons(0)) 19338f9d5b1aSChuck Lever xprt_set_bound(xprt); 19348f9d5b1aSChuck Lever 19358f9d5b1aSChuck Lever INIT_DELAYED_WORK(&transport->connect_worker, 19368f9d5b1aSChuck Lever xs_udp_connect_worker4); 1937b454ae90SChuck Lever xs_format_ipv4_peer_addresses(xprt, "udp", RPCBIND_NETID_UDP); 19388f9d5b1aSChuck Lever break; 19398f9d5b1aSChuck Lever case AF_INET6: 19408f9d5b1aSChuck Lever if (((struct sockaddr_in6 *)addr)->sin6_port != htons(0)) 19418f9d5b1aSChuck Lever xprt_set_bound(xprt); 19428f9d5b1aSChuck Lever 19438f9d5b1aSChuck Lever INIT_DELAYED_WORK(&transport->connect_worker, 19448f9d5b1aSChuck Lever xs_udp_connect_worker6); 1945b454ae90SChuck Lever xs_format_ipv6_peer_addresses(xprt, "udp", RPCBIND_NETID_UDP6); 19468f9d5b1aSChuck Lever break; 19478f9d5b1aSChuck Lever default: 19488f9d5b1aSChuck Lever kfree(xprt); 19498f9d5b1aSChuck Lever return ERR_PTR(-EAFNOSUPPORT); 19508f9d5b1aSChuck Lever } 19518f9d5b1aSChuck Lever 1952edb267a6SChuck Lever dprintk("RPC: set up transport to address %s\n", 19537559c7a2SChuck Lever xprt->address_strings[RPC_DISPLAY_ALL]); 1954edb267a6SChuck Lever 1955bc25571eS\"Talpey, Thomas\ if (try_module_get(THIS_MODULE)) 1956c8541ecdSChuck Lever return xprt; 1957bc25571eS\"Talpey, Thomas\ 1958bc25571eS\"Talpey, Thomas\ kfree(xprt->slot); 1959bc25571eS\"Talpey, Thomas\ kfree(xprt); 1960bc25571eS\"Talpey, Thomas\ return ERR_PTR(-EINVAL); 1961a246b010SChuck Lever } 1962a246b010SChuck Lever 19632881ae74STrond Myklebust static const struct rpc_timeout xs_tcp_default_timeout = { 19642881ae74STrond Myklebust .to_initval = 60 * HZ, 19652881ae74STrond Myklebust .to_maxval = 60 * HZ, 19662881ae74STrond Myklebust .to_retries = 2, 19672881ae74STrond Myklebust }; 19682881ae74STrond Myklebust 19699903cd1cSChuck Lever /** 19709903cd1cSChuck Lever * xs_setup_tcp - Set up transport to use a TCP socket 197196802a09SFrank van Maarseveen * @args: rpc transport creation arguments 19729903cd1cSChuck Lever * 19739903cd1cSChuck Lever */ 1974483066d6SAdrian Bunk static struct rpc_xprt *xs_setup_tcp(struct xprt_create *args) 1975a246b010SChuck Lever { 19768f9d5b1aSChuck Lever struct sockaddr *addr = args->dstaddr; 1977c8541ecdSChuck Lever struct rpc_xprt *xprt; 1978c8475461SChuck Lever struct sock_xprt *transport; 1979a246b010SChuck Lever 198096802a09SFrank van Maarseveen xprt = xs_setup_xprt(args, xprt_tcp_slot_table_entries); 1981c8541ecdSChuck Lever if (IS_ERR(xprt)) 1982c8541ecdSChuck Lever return xprt; 1983c8475461SChuck Lever transport = container_of(xprt, struct sock_xprt, xprt); 1984a246b010SChuck Lever 1985ec739ef0SChuck Lever xprt->prot = IPPROTO_TCP; 1986808012fbSChuck Lever xprt->tsh_size = sizeof(rpc_fraghdr) / sizeof(u32); 1987808012fbSChuck Lever xprt->max_payload = RPC_MAX_FRAGMENT_SIZE; 1988a246b010SChuck Lever 198903bf4b70SChuck Lever xprt->bind_timeout = XS_BIND_TO; 199003bf4b70SChuck Lever xprt->connect_timeout = XS_TCP_CONN_TO; 199103bf4b70SChuck Lever xprt->reestablish_timeout = XS_TCP_INIT_REEST_TO; 199203bf4b70SChuck Lever xprt->idle_timeout = XS_IDLE_DISC_TO; 1993a246b010SChuck Lever 1994262965f5SChuck Lever xprt->ops = &xs_tcp_ops; 1995ba7392bbSTrond Myklebust xprt->timeout = &xs_tcp_default_timeout; 1996a246b010SChuck Lever 19978f9d5b1aSChuck Lever switch (addr->sa_family) { 19988f9d5b1aSChuck Lever case AF_INET: 19998f9d5b1aSChuck Lever if (((struct sockaddr_in *)addr)->sin_port != htons(0)) 20008f9d5b1aSChuck Lever xprt_set_bound(xprt); 20018f9d5b1aSChuck Lever 20028f9d5b1aSChuck Lever INIT_DELAYED_WORK(&transport->connect_worker, xs_tcp_connect_worker4); 2003b454ae90SChuck Lever xs_format_ipv4_peer_addresses(xprt, "tcp", RPCBIND_NETID_TCP); 20048f9d5b1aSChuck Lever break; 20058f9d5b1aSChuck Lever case AF_INET6: 20068f9d5b1aSChuck Lever if (((struct sockaddr_in6 *)addr)->sin6_port != htons(0)) 20078f9d5b1aSChuck Lever xprt_set_bound(xprt); 20088f9d5b1aSChuck Lever 20098f9d5b1aSChuck Lever INIT_DELAYED_WORK(&transport->connect_worker, xs_tcp_connect_worker6); 2010b454ae90SChuck Lever xs_format_ipv6_peer_addresses(xprt, "tcp", RPCBIND_NETID_TCP6); 20118f9d5b1aSChuck Lever break; 20128f9d5b1aSChuck Lever default: 20138f9d5b1aSChuck Lever kfree(xprt); 20148f9d5b1aSChuck Lever return ERR_PTR(-EAFNOSUPPORT); 20158f9d5b1aSChuck Lever } 20168f9d5b1aSChuck Lever 2017edb267a6SChuck Lever dprintk("RPC: set up transport to address %s\n", 20187559c7a2SChuck Lever xprt->address_strings[RPC_DISPLAY_ALL]); 2019edb267a6SChuck Lever 2020bc25571eS\"Talpey, Thomas\ if (try_module_get(THIS_MODULE)) 2021c8541ecdSChuck Lever return xprt; 2022bc25571eS\"Talpey, Thomas\ 2023bc25571eS\"Talpey, Thomas\ kfree(xprt->slot); 2024bc25571eS\"Talpey, Thomas\ kfree(xprt); 2025bc25571eS\"Talpey, Thomas\ return ERR_PTR(-EINVAL); 2026a246b010SChuck Lever } 2027282b32e1SChuck Lever 2028bc25571eS\"Talpey, Thomas\ static struct xprt_class xs_udp_transport = { 2029bc25571eS\"Talpey, Thomas\ .list = LIST_HEAD_INIT(xs_udp_transport.list), 2030bc25571eS\"Talpey, Thomas\ .name = "udp", 2031bc25571eS\"Talpey, Thomas\ .owner = THIS_MODULE, 20324fa016ebS\"Talpey, Thomas\ .ident = IPPROTO_UDP, 2033bc25571eS\"Talpey, Thomas\ .setup = xs_setup_udp, 2034bc25571eS\"Talpey, Thomas\ }; 2035bc25571eS\"Talpey, Thomas\ 2036bc25571eS\"Talpey, Thomas\ static struct xprt_class xs_tcp_transport = { 2037bc25571eS\"Talpey, Thomas\ .list = LIST_HEAD_INIT(xs_tcp_transport.list), 2038bc25571eS\"Talpey, Thomas\ .name = "tcp", 2039bc25571eS\"Talpey, Thomas\ .owner = THIS_MODULE, 20404fa016ebS\"Talpey, Thomas\ .ident = IPPROTO_TCP, 2041bc25571eS\"Talpey, Thomas\ .setup = xs_setup_tcp, 2042bc25571eS\"Talpey, Thomas\ }; 2043bc25571eS\"Talpey, Thomas\ 2044282b32e1SChuck Lever /** 2045bc25571eS\"Talpey, Thomas\ * init_socket_xprt - set up xprtsock's sysctls, register with RPC client 2046282b32e1SChuck Lever * 2047282b32e1SChuck Lever */ 2048282b32e1SChuck Lever int init_socket_xprt(void) 2049282b32e1SChuck Lever { 2050fbf76683SChuck Lever #ifdef RPC_DEBUG 20512b1bec5fSEric W. Biederman if (!sunrpc_table_header) 20520b4d4147SEric W. Biederman sunrpc_table_header = register_sysctl_table(sunrpc_table); 2053fbf76683SChuck Lever #endif 2054fbf76683SChuck Lever 2055bc25571eS\"Talpey, Thomas\ xprt_register_transport(&xs_udp_transport); 2056bc25571eS\"Talpey, Thomas\ xprt_register_transport(&xs_tcp_transport); 2057bc25571eS\"Talpey, Thomas\ 2058282b32e1SChuck Lever return 0; 2059282b32e1SChuck Lever } 2060282b32e1SChuck Lever 2061282b32e1SChuck Lever /** 2062bc25571eS\"Talpey, Thomas\ * cleanup_socket_xprt - remove xprtsock's sysctls, unregister 2063282b32e1SChuck Lever * 2064282b32e1SChuck Lever */ 2065282b32e1SChuck Lever void cleanup_socket_xprt(void) 2066282b32e1SChuck Lever { 2067fbf76683SChuck Lever #ifdef RPC_DEBUG 2068fbf76683SChuck Lever if (sunrpc_table_header) { 2069fbf76683SChuck Lever unregister_sysctl_table(sunrpc_table_header); 2070fbf76683SChuck Lever sunrpc_table_header = NULL; 2071fbf76683SChuck Lever } 2072fbf76683SChuck Lever #endif 2073bc25571eS\"Talpey, Thomas\ 2074bc25571eS\"Talpey, Thomas\ xprt_unregister_transport(&xs_udp_transport); 2075bc25571eS\"Talpey, Thomas\ xprt_unregister_transport(&xs_tcp_transport); 2076282b32e1SChuck Lever } 2077