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 519b6ddf64fSTrond Myklebust static void xs_nospace_callback(struct rpc_task *task) 520b6ddf64fSTrond Myklebust { 521b6ddf64fSTrond Myklebust struct sock_xprt *transport = container_of(task->tk_rqstp->rq_xprt, struct sock_xprt, xprt); 522b6ddf64fSTrond Myklebust 523b6ddf64fSTrond Myklebust transport->inet->sk_write_pending--; 524b6ddf64fSTrond Myklebust clear_bit(SOCK_ASYNC_NOSPACE, &transport->sock->flags); 525b6ddf64fSTrond Myklebust } 526b6ddf64fSTrond Myklebust 5279903cd1cSChuck Lever /** 528262965f5SChuck Lever * xs_nospace - place task on wait queue if transmit was incomplete 529262965f5SChuck Lever * @task: task to put to sleep 5309903cd1cSChuck Lever * 531a246b010SChuck Lever */ 532262965f5SChuck Lever static void xs_nospace(struct rpc_task *task) 533a246b010SChuck Lever { 534262965f5SChuck Lever struct rpc_rqst *req = task->tk_rqstp; 535262965f5SChuck Lever struct rpc_xprt *xprt = req->rq_xprt; 536ee0ac0c2SChuck Lever struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt); 537a246b010SChuck Lever 53846121cf7SChuck Lever dprintk("RPC: %5u xmit incomplete (%u left of %u)\n", 539262965f5SChuck Lever task->tk_pid, req->rq_slen - req->rq_bytes_sent, 540262965f5SChuck Lever req->rq_slen); 541a246b010SChuck Lever 542262965f5SChuck Lever /* Protect against races with write_space */ 543262965f5SChuck Lever spin_lock_bh(&xprt->transport_lock); 544a246b010SChuck Lever 545262965f5SChuck Lever /* Don't race with disconnect */ 546b6ddf64fSTrond Myklebust if (xprt_connected(xprt)) { 547b6ddf64fSTrond Myklebust if (test_bit(SOCK_ASYNC_NOSPACE, &transport->sock->flags)) { 548b6ddf64fSTrond Myklebust /* 549b6ddf64fSTrond Myklebust * Notify TCP that we're limited by the application 550b6ddf64fSTrond Myklebust * window size 551b6ddf64fSTrond Myklebust */ 552b6ddf64fSTrond Myklebust set_bit(SOCK_NOSPACE, &transport->sock->flags); 553b6ddf64fSTrond Myklebust transport->inet->sk_write_pending++; 554b6ddf64fSTrond Myklebust /* ...and wait for more buffer space */ 555b6ddf64fSTrond Myklebust xprt_wait_for_buffer_space(task, xs_nospace_callback); 556b6ddf64fSTrond Myklebust } 557b6ddf64fSTrond Myklebust } else { 558b6ddf64fSTrond Myklebust clear_bit(SOCK_ASYNC_NOSPACE, &transport->sock->flags); 559262965f5SChuck Lever task->tk_status = -ENOTCONN; 560b6ddf64fSTrond Myklebust } 561a246b010SChuck Lever 562262965f5SChuck Lever spin_unlock_bh(&xprt->transport_lock); 563a246b010SChuck Lever } 564a246b010SChuck Lever 5659903cd1cSChuck Lever /** 566262965f5SChuck Lever * xs_udp_send_request - write an RPC request to a UDP socket 5679903cd1cSChuck Lever * @task: address of RPC task that manages the state of an RPC request 5689903cd1cSChuck Lever * 5699903cd1cSChuck Lever * Return values: 5709903cd1cSChuck Lever * 0: The request has been sent 5719903cd1cSChuck Lever * EAGAIN: The socket was blocked, please call again later to 5729903cd1cSChuck Lever * complete the request 573262965f5SChuck Lever * ENOTCONN: Caller needs to invoke connect logic then call again 5749903cd1cSChuck Lever * other: Some other error occured, the request was not sent 5759903cd1cSChuck Lever */ 576262965f5SChuck Lever static int xs_udp_send_request(struct rpc_task *task) 577a246b010SChuck Lever { 578a246b010SChuck Lever struct rpc_rqst *req = task->tk_rqstp; 579a246b010SChuck Lever struct rpc_xprt *xprt = req->rq_xprt; 580ee0ac0c2SChuck Lever struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt); 581262965f5SChuck Lever struct xdr_buf *xdr = &req->rq_snd_buf; 582262965f5SChuck Lever int status; 583262965f5SChuck Lever 584262965f5SChuck Lever xs_pktdump("packet data:", 585262965f5SChuck Lever req->rq_svec->iov_base, 586262965f5SChuck Lever req->rq_svec->iov_len); 587262965f5SChuck Lever 588262965f5SChuck Lever req->rq_xtime = jiffies; 589ee0ac0c2SChuck Lever status = xs_sendpages(transport->sock, 59095392c59SChuck Lever xs_addr(xprt), 591ee0ac0c2SChuck Lever xprt->addrlen, xdr, 592ee0ac0c2SChuck Lever req->rq_bytes_sent); 593262965f5SChuck Lever 594262965f5SChuck Lever dprintk("RPC: xs_udp_send_request(%u) = %d\n", 595262965f5SChuck Lever xdr->len - req->rq_bytes_sent, status); 596262965f5SChuck Lever 5972199700fSTrond Myklebust if (status >= 0) { 5981321d8d9SChuck Lever task->tk_bytes_sent += status; 5992199700fSTrond Myklebust if (status >= req->rq_slen) 600262965f5SChuck Lever return 0; 601262965f5SChuck Lever /* Still some bytes left; set up for a retry later. */ 602262965f5SChuck Lever status = -EAGAIN; 6032199700fSTrond Myklebust } 604262965f5SChuck Lever 605262965f5SChuck Lever switch (status) { 606b6ddf64fSTrond Myklebust case -EAGAIN: 607b6ddf64fSTrond Myklebust xs_nospace(task); 608b6ddf64fSTrond Myklebust break; 609262965f5SChuck Lever case -ENETUNREACH: 610262965f5SChuck Lever case -EPIPE: 611262965f5SChuck Lever case -ECONNREFUSED: 612262965f5SChuck Lever /* When the server has died, an ICMP port unreachable message 613262965f5SChuck Lever * prompts ECONNREFUSED. */ 614b6ddf64fSTrond Myklebust clear_bit(SOCK_ASYNC_NOSPACE, &transport->sock->flags); 615262965f5SChuck Lever break; 616262965f5SChuck Lever default: 617b6ddf64fSTrond Myklebust clear_bit(SOCK_ASYNC_NOSPACE, &transport->sock->flags); 618262965f5SChuck Lever dprintk("RPC: sendmsg returned unrecognized error %d\n", 619262965f5SChuck Lever -status); 620262965f5SChuck Lever } 621262965f5SChuck Lever 622262965f5SChuck Lever return status; 623262965f5SChuck Lever } 624262965f5SChuck Lever 625e06799f9STrond Myklebust /** 626e06799f9STrond Myklebust * xs_tcp_shutdown - gracefully shut down a TCP socket 627e06799f9STrond Myklebust * @xprt: transport 628e06799f9STrond Myklebust * 629e06799f9STrond Myklebust * Initiates a graceful shutdown of the TCP socket by calling the 630e06799f9STrond Myklebust * equivalent of shutdown(SHUT_WR); 631e06799f9STrond Myklebust */ 632e06799f9STrond Myklebust static void xs_tcp_shutdown(struct rpc_xprt *xprt) 633e06799f9STrond Myklebust { 634e06799f9STrond Myklebust struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt); 635e06799f9STrond Myklebust struct socket *sock = transport->sock; 636e06799f9STrond Myklebust 637e06799f9STrond Myklebust if (sock != NULL) 638e06799f9STrond Myklebust kernel_sock_shutdown(sock, SHUT_WR); 639e06799f9STrond Myklebust } 640e06799f9STrond Myklebust 641808012fbSChuck Lever static inline void xs_encode_tcp_record_marker(struct xdr_buf *buf) 642808012fbSChuck Lever { 643808012fbSChuck Lever u32 reclen = buf->len - sizeof(rpc_fraghdr); 644808012fbSChuck Lever rpc_fraghdr *base = buf->head[0].iov_base; 645808012fbSChuck Lever *base = htonl(RPC_LAST_STREAM_FRAGMENT | reclen); 646808012fbSChuck Lever } 647808012fbSChuck Lever 648262965f5SChuck Lever /** 649262965f5SChuck Lever * xs_tcp_send_request - write an RPC request to a TCP socket 650262965f5SChuck Lever * @task: address of RPC task that manages the state of an RPC request 651262965f5SChuck Lever * 652262965f5SChuck Lever * Return values: 653262965f5SChuck Lever * 0: The request has been sent 654262965f5SChuck Lever * EAGAIN: The socket was blocked, please call again later to 655262965f5SChuck Lever * complete the request 656262965f5SChuck Lever * ENOTCONN: Caller needs to invoke connect logic then call again 657262965f5SChuck Lever * other: Some other error occured, the request was not sent 658262965f5SChuck Lever * 659262965f5SChuck Lever * XXX: In the case of soft timeouts, should we eventually give up 660262965f5SChuck Lever * if sendmsg is not able to make progress? 661262965f5SChuck Lever */ 662262965f5SChuck Lever static int xs_tcp_send_request(struct rpc_task *task) 663262965f5SChuck Lever { 664262965f5SChuck Lever struct rpc_rqst *req = task->tk_rqstp; 665262965f5SChuck Lever struct rpc_xprt *xprt = req->rq_xprt; 666ee0ac0c2SChuck Lever struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt); 667262965f5SChuck Lever struct xdr_buf *xdr = &req->rq_snd_buf; 668b595bb15SChuck Lever int status; 669b595bb15SChuck Lever unsigned int retry = 0; 670a246b010SChuck Lever 671808012fbSChuck Lever xs_encode_tcp_record_marker(&req->rq_snd_buf); 672262965f5SChuck Lever 673262965f5SChuck Lever xs_pktdump("packet data:", 674262965f5SChuck Lever req->rq_svec->iov_base, 675262965f5SChuck Lever req->rq_svec->iov_len); 676a246b010SChuck Lever 677a246b010SChuck Lever /* Continue transmitting the packet/record. We must be careful 678a246b010SChuck Lever * to cope with writespace callbacks arriving _after_ we have 679262965f5SChuck Lever * called sendmsg(). */ 680a246b010SChuck Lever while (1) { 681a246b010SChuck Lever req->rq_xtime = jiffies; 682ee0ac0c2SChuck Lever status = xs_sendpages(transport->sock, 683ee0ac0c2SChuck Lever NULL, 0, xdr, req->rq_bytes_sent); 684a246b010SChuck Lever 685262965f5SChuck Lever dprintk("RPC: xs_tcp_send_request(%u) = %d\n", 686262965f5SChuck Lever xdr->len - req->rq_bytes_sent, status); 687262965f5SChuck Lever 688262965f5SChuck Lever if (unlikely(status < 0)) 689a246b010SChuck Lever break; 690a246b010SChuck Lever 691a246b010SChuck Lever /* If we've sent the entire packet, immediately 692a246b010SChuck Lever * reset the count of bytes sent. */ 693262965f5SChuck Lever req->rq_bytes_sent += status; 694ef759a2eSChuck Lever task->tk_bytes_sent += status; 695262965f5SChuck Lever if (likely(req->rq_bytes_sent >= req->rq_slen)) { 696a246b010SChuck Lever req->rq_bytes_sent = 0; 697a246b010SChuck Lever return 0; 698a246b010SChuck Lever } 699262965f5SChuck Lever 700a246b010SChuck Lever status = -EAGAIN; 701262965f5SChuck Lever if (retry++ > XS_SENDMSG_RETRY) 702a246b010SChuck Lever break; 703a246b010SChuck Lever } 704a246b010SChuck Lever 705262965f5SChuck Lever switch (status) { 706262965f5SChuck Lever case -EAGAIN: 707262965f5SChuck Lever xs_nospace(task); 708262965f5SChuck Lever break; 709262965f5SChuck Lever case -ECONNREFUSED: 710262965f5SChuck Lever case -ECONNRESET: 711262965f5SChuck Lever case -ENOTCONN: 712262965f5SChuck Lever case -EPIPE: 713262965f5SChuck Lever status = -ENOTCONN; 714b6ddf64fSTrond Myklebust clear_bit(SOCK_ASYNC_NOSPACE, &transport->sock->flags); 715262965f5SChuck Lever break; 716262965f5SChuck Lever default: 717262965f5SChuck Lever dprintk("RPC: sendmsg returned unrecognized error %d\n", 718262965f5SChuck Lever -status); 719b6ddf64fSTrond Myklebust clear_bit(SOCK_ASYNC_NOSPACE, &transport->sock->flags); 720e06799f9STrond Myklebust xs_tcp_shutdown(xprt); 721a246b010SChuck Lever } 722a246b010SChuck Lever 723a246b010SChuck Lever return status; 724a246b010SChuck Lever } 725a246b010SChuck Lever 7269903cd1cSChuck Lever /** 727e0ab53deSTrond Myklebust * xs_tcp_release_xprt - clean up after a tcp transmission 728e0ab53deSTrond Myklebust * @xprt: transport 729e0ab53deSTrond Myklebust * @task: rpc task 730e0ab53deSTrond Myklebust * 731e0ab53deSTrond Myklebust * This cleans up if an error causes us to abort the transmission of a request. 732e0ab53deSTrond Myklebust * In this case, the socket may need to be reset in order to avoid confusing 733e0ab53deSTrond Myklebust * the server. 734e0ab53deSTrond Myklebust */ 735e0ab53deSTrond Myklebust static void xs_tcp_release_xprt(struct rpc_xprt *xprt, struct rpc_task *task) 736e0ab53deSTrond Myklebust { 737e0ab53deSTrond Myklebust struct rpc_rqst *req; 738e0ab53deSTrond Myklebust 739e0ab53deSTrond Myklebust if (task != xprt->snd_task) 740e0ab53deSTrond Myklebust return; 741e0ab53deSTrond Myklebust if (task == NULL) 742e0ab53deSTrond Myklebust goto out_release; 743e0ab53deSTrond Myklebust req = task->tk_rqstp; 744e0ab53deSTrond Myklebust if (req->rq_bytes_sent == 0) 745e0ab53deSTrond Myklebust goto out_release; 746e0ab53deSTrond Myklebust if (req->rq_bytes_sent == req->rq_snd_buf.len) 747e0ab53deSTrond Myklebust goto out_release; 748e0ab53deSTrond Myklebust set_bit(XPRT_CLOSE_WAIT, &task->tk_xprt->state); 749e0ab53deSTrond Myklebust out_release: 750e0ab53deSTrond Myklebust xprt_release_xprt(xprt, task); 751e0ab53deSTrond Myklebust } 752e0ab53deSTrond Myklebust 753e0ab53deSTrond Myklebust /** 7549903cd1cSChuck Lever * xs_close - close a socket 7559903cd1cSChuck Lever * @xprt: transport 7569903cd1cSChuck Lever * 7573167e12cSChuck Lever * This is used when all requests are complete; ie, no DRC state remains 7583167e12cSChuck Lever * on the server we want to save. 759a246b010SChuck Lever */ 7609903cd1cSChuck Lever static void xs_close(struct rpc_xprt *xprt) 761a246b010SChuck Lever { 762ee0ac0c2SChuck Lever struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt); 763ee0ac0c2SChuck Lever struct socket *sock = transport->sock; 764ee0ac0c2SChuck Lever struct sock *sk = transport->inet; 765a246b010SChuck Lever 766a246b010SChuck Lever if (!sk) 767632e3bdcSTrond Myklebust goto clear_close_wait; 768a246b010SChuck Lever 7699903cd1cSChuck Lever dprintk("RPC: xs_close xprt %p\n", xprt); 7709903cd1cSChuck Lever 771a246b010SChuck Lever write_lock_bh(&sk->sk_callback_lock); 772ee0ac0c2SChuck Lever transport->inet = NULL; 773ee0ac0c2SChuck Lever transport->sock = NULL; 774a246b010SChuck Lever 775a246b010SChuck Lever sk->sk_user_data = NULL; 776314dfd79SChuck Lever sk->sk_data_ready = transport->old_data_ready; 777314dfd79SChuck Lever sk->sk_state_change = transport->old_state_change; 778314dfd79SChuck Lever sk->sk_write_space = transport->old_write_space; 779a246b010SChuck Lever write_unlock_bh(&sk->sk_callback_lock); 780a246b010SChuck Lever 781a246b010SChuck Lever sk->sk_no_check = 0; 782a246b010SChuck Lever 783a246b010SChuck Lever sock_release(sock); 784632e3bdcSTrond Myklebust clear_close_wait: 785632e3bdcSTrond Myklebust smp_mb__before_clear_bit(); 786632e3bdcSTrond Myklebust clear_bit(XPRT_CLOSE_WAIT, &xprt->state); 7873b948ae5STrond Myklebust clear_bit(XPRT_CLOSING, &xprt->state); 788632e3bdcSTrond Myklebust smp_mb__after_clear_bit(); 78962da3b24STrond Myklebust xprt_disconnect_done(xprt); 790a246b010SChuck Lever } 791a246b010SChuck Lever 7929903cd1cSChuck Lever /** 7939903cd1cSChuck Lever * xs_destroy - prepare to shutdown a transport 7949903cd1cSChuck Lever * @xprt: doomed transport 7959903cd1cSChuck Lever * 7969903cd1cSChuck Lever */ 7979903cd1cSChuck Lever static void xs_destroy(struct rpc_xprt *xprt) 798a246b010SChuck Lever { 799c8475461SChuck Lever struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt); 800c8475461SChuck Lever 8019903cd1cSChuck Lever dprintk("RPC: xs_destroy xprt %p\n", xprt); 8029903cd1cSChuck Lever 803c1384c9cSTrond Myklebust cancel_rearming_delayed_work(&transport->connect_worker); 804a246b010SChuck Lever 8059903cd1cSChuck Lever xs_close(xprt); 806edb267a6SChuck Lever xs_free_peer_addresses(xprt); 807a246b010SChuck Lever kfree(xprt->slot); 808c8541ecdSChuck Lever kfree(xprt); 809bc25571eS\"Talpey, Thomas\ module_put(THIS_MODULE); 810a246b010SChuck Lever } 811a246b010SChuck Lever 8129903cd1cSChuck Lever static inline struct rpc_xprt *xprt_from_sock(struct sock *sk) 8139903cd1cSChuck Lever { 8149903cd1cSChuck Lever return (struct rpc_xprt *) sk->sk_user_data; 8159903cd1cSChuck Lever } 8169903cd1cSChuck Lever 8179903cd1cSChuck Lever /** 8189903cd1cSChuck Lever * xs_udp_data_ready - "data ready" callback for UDP sockets 8199903cd1cSChuck Lever * @sk: socket with data to read 8209903cd1cSChuck Lever * @len: how much data to read 8219903cd1cSChuck Lever * 822a246b010SChuck Lever */ 8239903cd1cSChuck Lever static void xs_udp_data_ready(struct sock *sk, int len) 824a246b010SChuck Lever { 825a246b010SChuck Lever struct rpc_task *task; 826a246b010SChuck Lever struct rpc_xprt *xprt; 827a246b010SChuck Lever struct rpc_rqst *rovr; 828a246b010SChuck Lever struct sk_buff *skb; 829a246b010SChuck Lever int err, repsize, copied; 830d8ed029dSAlexey Dobriyan u32 _xid; 831d8ed029dSAlexey Dobriyan __be32 *xp; 832a246b010SChuck Lever 833a246b010SChuck Lever read_lock(&sk->sk_callback_lock); 8349903cd1cSChuck Lever dprintk("RPC: xs_udp_data_ready...\n"); 8359903cd1cSChuck Lever if (!(xprt = xprt_from_sock(sk))) 836a246b010SChuck Lever goto out; 837a246b010SChuck Lever 838a246b010SChuck Lever if ((skb = skb_recv_datagram(sk, 0, 1, &err)) == NULL) 839a246b010SChuck Lever goto out; 840a246b010SChuck Lever 841a246b010SChuck Lever if (xprt->shutdown) 842a246b010SChuck Lever goto dropit; 843a246b010SChuck Lever 844a246b010SChuck Lever repsize = skb->len - sizeof(struct udphdr); 845a246b010SChuck Lever if (repsize < 4) { 8469903cd1cSChuck Lever dprintk("RPC: impossible RPC reply size %d!\n", repsize); 847a246b010SChuck Lever goto dropit; 848a246b010SChuck Lever } 849a246b010SChuck Lever 850a246b010SChuck Lever /* Copy the XID from the skb... */ 851a246b010SChuck Lever xp = skb_header_pointer(skb, sizeof(struct udphdr), 852a246b010SChuck Lever sizeof(_xid), &_xid); 853a246b010SChuck Lever if (xp == NULL) 854a246b010SChuck Lever goto dropit; 855a246b010SChuck Lever 856a246b010SChuck Lever /* Look up and lock the request corresponding to the given XID */ 8574a0f8c04SChuck Lever spin_lock(&xprt->transport_lock); 858a246b010SChuck Lever rovr = xprt_lookup_rqst(xprt, *xp); 859a246b010SChuck Lever if (!rovr) 860a246b010SChuck Lever goto out_unlock; 861a246b010SChuck Lever task = rovr->rq_task; 862a246b010SChuck Lever 863a246b010SChuck Lever if ((copied = rovr->rq_private_buf.buflen) > repsize) 864a246b010SChuck Lever copied = repsize; 865a246b010SChuck Lever 866a246b010SChuck Lever /* Suck it into the iovec, verify checksum if not done by hw. */ 8671781f7f5SHerbert Xu if (csum_partial_copy_to_xdr(&rovr->rq_private_buf, skb)) { 8681781f7f5SHerbert Xu UDPX_INC_STATS_BH(sk, UDP_MIB_INERRORS); 869a246b010SChuck Lever goto out_unlock; 8701781f7f5SHerbert Xu } 8711781f7f5SHerbert Xu 8721781f7f5SHerbert Xu UDPX_INC_STATS_BH(sk, UDP_MIB_INDATAGRAMS); 873a246b010SChuck Lever 874a246b010SChuck Lever /* Something worked... */ 875a246b010SChuck Lever dst_confirm(skb->dst); 876a246b010SChuck Lever 8771570c1e4SChuck Lever xprt_adjust_cwnd(task, copied); 8781570c1e4SChuck Lever xprt_update_rtt(task); 8791570c1e4SChuck Lever xprt_complete_rqst(task, copied); 880a246b010SChuck Lever 881a246b010SChuck Lever out_unlock: 8824a0f8c04SChuck Lever spin_unlock(&xprt->transport_lock); 883a246b010SChuck Lever dropit: 884a246b010SChuck Lever skb_free_datagram(sk, skb); 885a246b010SChuck Lever out: 886a246b010SChuck Lever read_unlock(&sk->sk_callback_lock); 887a246b010SChuck Lever } 888a246b010SChuck Lever 889dd456471SChuck Lever static inline void xs_tcp_read_fraghdr(struct rpc_xprt *xprt, struct xdr_skb_reader *desc) 890a246b010SChuck Lever { 89151971139SChuck Lever struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt); 892a246b010SChuck Lever size_t len, used; 893a246b010SChuck Lever char *p; 894a246b010SChuck Lever 89551971139SChuck Lever p = ((char *) &transport->tcp_fraghdr) + transport->tcp_offset; 89651971139SChuck Lever len = sizeof(transport->tcp_fraghdr) - transport->tcp_offset; 8979d292316SChuck Lever used = xdr_skb_read_bits(desc, p, len); 89851971139SChuck Lever transport->tcp_offset += used; 899a246b010SChuck Lever if (used != len) 900a246b010SChuck Lever return; 901808012fbSChuck Lever 90251971139SChuck Lever transport->tcp_reclen = ntohl(transport->tcp_fraghdr); 90351971139SChuck Lever if (transport->tcp_reclen & RPC_LAST_STREAM_FRAGMENT) 904e136d092SChuck Lever transport->tcp_flags |= TCP_RCV_LAST_FRAG; 905a246b010SChuck Lever else 906e136d092SChuck Lever transport->tcp_flags &= ~TCP_RCV_LAST_FRAG; 90751971139SChuck Lever transport->tcp_reclen &= RPC_FRAGMENT_SIZE_MASK; 908808012fbSChuck Lever 909e136d092SChuck Lever transport->tcp_flags &= ~TCP_RCV_COPY_FRAGHDR; 91051971139SChuck Lever transport->tcp_offset = 0; 911808012fbSChuck Lever 912a246b010SChuck Lever /* Sanity check of the record length */ 91351971139SChuck Lever if (unlikely(transport->tcp_reclen < 4)) { 9149903cd1cSChuck Lever dprintk("RPC: invalid TCP record fragment length\n"); 9153ebb067dSTrond Myklebust xprt_force_disconnect(xprt); 9169903cd1cSChuck Lever return; 917a246b010SChuck Lever } 918a246b010SChuck Lever dprintk("RPC: reading TCP record fragment of length %d\n", 91951971139SChuck Lever transport->tcp_reclen); 920a246b010SChuck Lever } 921a246b010SChuck Lever 92251971139SChuck Lever static void xs_tcp_check_fraghdr(struct sock_xprt *transport) 923a246b010SChuck Lever { 92451971139SChuck Lever if (transport->tcp_offset == transport->tcp_reclen) { 925e136d092SChuck Lever transport->tcp_flags |= TCP_RCV_COPY_FRAGHDR; 92651971139SChuck Lever transport->tcp_offset = 0; 927e136d092SChuck Lever if (transport->tcp_flags & TCP_RCV_LAST_FRAG) { 928e136d092SChuck Lever transport->tcp_flags &= ~TCP_RCV_COPY_DATA; 929e136d092SChuck Lever transport->tcp_flags |= TCP_RCV_COPY_XID; 93051971139SChuck Lever transport->tcp_copied = 0; 931a246b010SChuck Lever } 932a246b010SChuck Lever } 933a246b010SChuck Lever } 934a246b010SChuck Lever 935dd456471SChuck Lever static inline void xs_tcp_read_xid(struct sock_xprt *transport, struct xdr_skb_reader *desc) 936a246b010SChuck Lever { 937a246b010SChuck Lever size_t len, used; 938a246b010SChuck Lever char *p; 939a246b010SChuck Lever 94051971139SChuck Lever len = sizeof(transport->tcp_xid) - transport->tcp_offset; 941a246b010SChuck Lever dprintk("RPC: reading XID (%Zu bytes)\n", len); 94251971139SChuck Lever p = ((char *) &transport->tcp_xid) + transport->tcp_offset; 9439d292316SChuck Lever used = xdr_skb_read_bits(desc, p, len); 94451971139SChuck Lever transport->tcp_offset += used; 945a246b010SChuck Lever if (used != len) 946a246b010SChuck Lever return; 947e136d092SChuck Lever transport->tcp_flags &= ~TCP_RCV_COPY_XID; 948e136d092SChuck Lever transport->tcp_flags |= TCP_RCV_COPY_DATA; 94951971139SChuck Lever transport->tcp_copied = 4; 950a246b010SChuck Lever dprintk("RPC: reading reply for XID %08x\n", 95151971139SChuck Lever ntohl(transport->tcp_xid)); 95251971139SChuck Lever xs_tcp_check_fraghdr(transport); 953a246b010SChuck Lever } 954a246b010SChuck Lever 955dd456471SChuck Lever static inline void xs_tcp_read_request(struct rpc_xprt *xprt, struct xdr_skb_reader *desc) 956a246b010SChuck Lever { 95751971139SChuck Lever struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt); 958a246b010SChuck Lever struct rpc_rqst *req; 959a246b010SChuck Lever struct xdr_buf *rcvbuf; 960a246b010SChuck Lever size_t len; 961a246b010SChuck Lever ssize_t r; 962a246b010SChuck Lever 963a246b010SChuck Lever /* Find and lock the request corresponding to this xid */ 9644a0f8c04SChuck Lever spin_lock(&xprt->transport_lock); 96551971139SChuck Lever req = xprt_lookup_rqst(xprt, transport->tcp_xid); 966a246b010SChuck Lever if (!req) { 967e136d092SChuck Lever transport->tcp_flags &= ~TCP_RCV_COPY_DATA; 968a246b010SChuck Lever dprintk("RPC: XID %08x request not found!\n", 96951971139SChuck Lever ntohl(transport->tcp_xid)); 9704a0f8c04SChuck Lever spin_unlock(&xprt->transport_lock); 971a246b010SChuck Lever return; 972a246b010SChuck Lever } 973a246b010SChuck Lever 974a246b010SChuck Lever rcvbuf = &req->rq_private_buf; 975a246b010SChuck Lever len = desc->count; 97651971139SChuck Lever if (len > transport->tcp_reclen - transport->tcp_offset) { 977dd456471SChuck Lever struct xdr_skb_reader my_desc; 978a246b010SChuck Lever 97951971139SChuck Lever len = transport->tcp_reclen - transport->tcp_offset; 980a246b010SChuck Lever memcpy(&my_desc, desc, sizeof(my_desc)); 981a246b010SChuck Lever my_desc.count = len; 98251971139SChuck Lever r = xdr_partial_copy_from_skb(rcvbuf, transport->tcp_copied, 9839d292316SChuck Lever &my_desc, xdr_skb_read_bits); 984a246b010SChuck Lever desc->count -= r; 985a246b010SChuck Lever desc->offset += r; 986a246b010SChuck Lever } else 98751971139SChuck Lever r = xdr_partial_copy_from_skb(rcvbuf, transport->tcp_copied, 9889d292316SChuck Lever desc, xdr_skb_read_bits); 989a246b010SChuck Lever 990a246b010SChuck Lever if (r > 0) { 99151971139SChuck Lever transport->tcp_copied += r; 99251971139SChuck Lever transport->tcp_offset += r; 993a246b010SChuck Lever } 994a246b010SChuck Lever if (r != len) { 995a246b010SChuck Lever /* Error when copying to the receive buffer, 996a246b010SChuck Lever * usually because we weren't able to allocate 997a246b010SChuck Lever * additional buffer pages. All we can do now 998e136d092SChuck Lever * is turn off TCP_RCV_COPY_DATA, so the request 999a246b010SChuck Lever * will not receive any additional updates, 1000a246b010SChuck Lever * and time out. 1001a246b010SChuck Lever * Any remaining data from this record will 1002a246b010SChuck Lever * be discarded. 1003a246b010SChuck Lever */ 1004e136d092SChuck Lever transport->tcp_flags &= ~TCP_RCV_COPY_DATA; 1005a246b010SChuck Lever dprintk("RPC: XID %08x truncated request\n", 100651971139SChuck Lever ntohl(transport->tcp_xid)); 100746121cf7SChuck Lever dprintk("RPC: xprt = %p, tcp_copied = %lu, " 100846121cf7SChuck Lever "tcp_offset = %u, tcp_reclen = %u\n", 100946121cf7SChuck Lever xprt, transport->tcp_copied, 101046121cf7SChuck Lever transport->tcp_offset, transport->tcp_reclen); 1011a246b010SChuck Lever goto out; 1012a246b010SChuck Lever } 1013a246b010SChuck Lever 1014a246b010SChuck Lever dprintk("RPC: XID %08x read %Zd bytes\n", 101551971139SChuck Lever ntohl(transport->tcp_xid), r); 101646121cf7SChuck Lever dprintk("RPC: xprt = %p, tcp_copied = %lu, tcp_offset = %u, " 101746121cf7SChuck Lever "tcp_reclen = %u\n", xprt, transport->tcp_copied, 101846121cf7SChuck Lever transport->tcp_offset, transport->tcp_reclen); 1019a246b010SChuck Lever 102051971139SChuck Lever if (transport->tcp_copied == req->rq_private_buf.buflen) 1021e136d092SChuck Lever transport->tcp_flags &= ~TCP_RCV_COPY_DATA; 102251971139SChuck Lever else if (transport->tcp_offset == transport->tcp_reclen) { 1023e136d092SChuck Lever if (transport->tcp_flags & TCP_RCV_LAST_FRAG) 1024e136d092SChuck Lever transport->tcp_flags &= ~TCP_RCV_COPY_DATA; 1025a246b010SChuck Lever } 1026a246b010SChuck Lever 1027a246b010SChuck Lever out: 1028e136d092SChuck Lever if (!(transport->tcp_flags & TCP_RCV_COPY_DATA)) 102951971139SChuck Lever xprt_complete_rqst(req->rq_task, transport->tcp_copied); 10304a0f8c04SChuck Lever spin_unlock(&xprt->transport_lock); 103151971139SChuck Lever xs_tcp_check_fraghdr(transport); 1032a246b010SChuck Lever } 1033a246b010SChuck Lever 1034dd456471SChuck Lever static inline void xs_tcp_read_discard(struct sock_xprt *transport, struct xdr_skb_reader *desc) 1035a246b010SChuck Lever { 1036a246b010SChuck Lever size_t len; 1037a246b010SChuck Lever 103851971139SChuck Lever len = transport->tcp_reclen - transport->tcp_offset; 1039a246b010SChuck Lever if (len > desc->count) 1040a246b010SChuck Lever len = desc->count; 1041a246b010SChuck Lever desc->count -= len; 1042a246b010SChuck Lever desc->offset += len; 104351971139SChuck Lever transport->tcp_offset += len; 1044a246b010SChuck Lever dprintk("RPC: discarded %Zu bytes\n", len); 104551971139SChuck Lever xs_tcp_check_fraghdr(transport); 1046a246b010SChuck Lever } 1047a246b010SChuck Lever 10489903cd1cSChuck Lever static int xs_tcp_data_recv(read_descriptor_t *rd_desc, struct sk_buff *skb, unsigned int offset, size_t len) 1049a246b010SChuck Lever { 1050a246b010SChuck Lever struct rpc_xprt *xprt = rd_desc->arg.data; 105151971139SChuck Lever struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt); 1052dd456471SChuck Lever struct xdr_skb_reader desc = { 1053a246b010SChuck Lever .skb = skb, 1054a246b010SChuck Lever .offset = offset, 1055a246b010SChuck Lever .count = len, 1056a246b010SChuck Lever }; 1057a246b010SChuck Lever 10589903cd1cSChuck Lever dprintk("RPC: xs_tcp_data_recv started\n"); 1059a246b010SChuck Lever do { 1060a246b010SChuck Lever /* Read in a new fragment marker if necessary */ 1061a246b010SChuck Lever /* Can we ever really expect to get completely empty fragments? */ 1062e136d092SChuck Lever if (transport->tcp_flags & TCP_RCV_COPY_FRAGHDR) { 10639903cd1cSChuck Lever xs_tcp_read_fraghdr(xprt, &desc); 1064a246b010SChuck Lever continue; 1065a246b010SChuck Lever } 1066a246b010SChuck Lever /* Read in the xid if necessary */ 1067e136d092SChuck Lever if (transport->tcp_flags & TCP_RCV_COPY_XID) { 106851971139SChuck Lever xs_tcp_read_xid(transport, &desc); 1069a246b010SChuck Lever continue; 1070a246b010SChuck Lever } 1071a246b010SChuck Lever /* Read in the request data */ 1072e136d092SChuck Lever if (transport->tcp_flags & TCP_RCV_COPY_DATA) { 10739903cd1cSChuck Lever xs_tcp_read_request(xprt, &desc); 1074a246b010SChuck Lever continue; 1075a246b010SChuck Lever } 1076a246b010SChuck Lever /* Skip over any trailing bytes on short reads */ 107751971139SChuck Lever xs_tcp_read_discard(transport, &desc); 1078a246b010SChuck Lever } while (desc.count); 10799903cd1cSChuck Lever dprintk("RPC: xs_tcp_data_recv done\n"); 1080a246b010SChuck Lever return len - desc.count; 1081a246b010SChuck Lever } 1082a246b010SChuck Lever 10839903cd1cSChuck Lever /** 10849903cd1cSChuck Lever * xs_tcp_data_ready - "data ready" callback for TCP sockets 10859903cd1cSChuck Lever * @sk: socket with data to read 10869903cd1cSChuck Lever * @bytes: how much data to read 10879903cd1cSChuck Lever * 10889903cd1cSChuck Lever */ 10899903cd1cSChuck Lever static void xs_tcp_data_ready(struct sock *sk, int bytes) 1090a246b010SChuck Lever { 1091a246b010SChuck Lever struct rpc_xprt *xprt; 1092a246b010SChuck Lever read_descriptor_t rd_desc; 1093ff2d7db8STrond Myklebust int read; 1094a246b010SChuck Lever 10959903cd1cSChuck Lever dprintk("RPC: xs_tcp_data_ready...\n"); 109646121cf7SChuck Lever 109746121cf7SChuck Lever read_lock(&sk->sk_callback_lock); 10989903cd1cSChuck Lever if (!(xprt = xprt_from_sock(sk))) 1099a246b010SChuck Lever goto out; 1100a246b010SChuck Lever if (xprt->shutdown) 1101a246b010SChuck Lever goto out; 1102a246b010SChuck Lever 11039903cd1cSChuck Lever /* We use rd_desc to pass struct xprt to xs_tcp_data_recv */ 1104a246b010SChuck Lever rd_desc.arg.data = xprt; 1105ff2d7db8STrond Myklebust do { 1106a246b010SChuck Lever rd_desc.count = 65536; 1107ff2d7db8STrond Myklebust read = tcp_read_sock(sk, &rd_desc, xs_tcp_data_recv); 1108ff2d7db8STrond Myklebust } while (read > 0); 1109a246b010SChuck Lever out: 1110a246b010SChuck Lever read_unlock(&sk->sk_callback_lock); 1111a246b010SChuck Lever } 1112a246b010SChuck Lever 11139903cd1cSChuck Lever /** 11149903cd1cSChuck Lever * xs_tcp_state_change - callback to handle TCP socket state changes 11159903cd1cSChuck Lever * @sk: socket whose state has changed 11169903cd1cSChuck Lever * 11179903cd1cSChuck Lever */ 11189903cd1cSChuck Lever static void xs_tcp_state_change(struct sock *sk) 1119a246b010SChuck Lever { 1120a246b010SChuck Lever struct rpc_xprt *xprt; 1121a246b010SChuck Lever 1122a246b010SChuck Lever read_lock(&sk->sk_callback_lock); 1123a246b010SChuck Lever if (!(xprt = xprt_from_sock(sk))) 1124a246b010SChuck Lever goto out; 11259903cd1cSChuck Lever dprintk("RPC: xs_tcp_state_change client %p...\n", xprt); 1126a246b010SChuck Lever dprintk("RPC: state %x conn %d dead %d zapped %d\n", 1127a246b010SChuck Lever sk->sk_state, xprt_connected(xprt), 1128a246b010SChuck Lever sock_flag(sk, SOCK_DEAD), 1129a246b010SChuck Lever sock_flag(sk, SOCK_ZAPPED)); 1130a246b010SChuck Lever 1131a246b010SChuck Lever switch (sk->sk_state) { 1132a246b010SChuck Lever case TCP_ESTABLISHED: 11334a0f8c04SChuck Lever spin_lock_bh(&xprt->transport_lock); 1134a246b010SChuck Lever if (!xprt_test_and_set_connected(xprt)) { 113551971139SChuck Lever struct sock_xprt *transport = container_of(xprt, 113651971139SChuck Lever struct sock_xprt, xprt); 113751971139SChuck Lever 1138a246b010SChuck Lever /* Reset TCP record info */ 113951971139SChuck Lever transport->tcp_offset = 0; 114051971139SChuck Lever transport->tcp_reclen = 0; 114151971139SChuck Lever transport->tcp_copied = 0; 1142e136d092SChuck Lever transport->tcp_flags = 1143e136d092SChuck Lever TCP_RCV_COPY_FRAGHDR | TCP_RCV_COPY_XID; 114451971139SChuck Lever 114544fbac22SChuck Lever xprt_wake_pending_tasks(xprt, 0); 1146a246b010SChuck Lever } 11474a0f8c04SChuck Lever spin_unlock_bh(&xprt->transport_lock); 1148a246b010SChuck Lever break; 11493b948ae5STrond Myklebust case TCP_FIN_WAIT1: 11503b948ae5STrond Myklebust /* The client initiated a shutdown of the socket */ 1151663b8858STrond Myklebust xprt->reestablish_timeout = 0; 11523b948ae5STrond Myklebust set_bit(XPRT_CLOSING, &xprt->state); 11533b948ae5STrond Myklebust smp_mb__before_clear_bit(); 11543b948ae5STrond Myklebust clear_bit(XPRT_CONNECTED, &xprt->state); 1155ef803670STrond Myklebust clear_bit(XPRT_CLOSE_WAIT, &xprt->state); 11563b948ae5STrond Myklebust smp_mb__after_clear_bit(); 1157a246b010SChuck Lever break; 1158632e3bdcSTrond Myklebust case TCP_CLOSE_WAIT: 11593b948ae5STrond Myklebust /* The server initiated a shutdown of the socket */ 11603b948ae5STrond Myklebust set_bit(XPRT_CLOSING, &xprt->state); 116166af1e55STrond Myklebust xprt_force_disconnect(xprt); 1162663b8858STrond Myklebust case TCP_SYN_SENT: 1163663b8858STrond Myklebust case TCP_CLOSING: 1164663b8858STrond Myklebust /* 1165663b8858STrond Myklebust * If the server closed down the connection, make sure that 1166663b8858STrond Myklebust * we back off before reconnecting 1167663b8858STrond Myklebust */ 1168663b8858STrond Myklebust if (xprt->reestablish_timeout < XS_TCP_INIT_REEST_TO) 1169663b8858STrond Myklebust xprt->reestablish_timeout = XS_TCP_INIT_REEST_TO; 11703b948ae5STrond Myklebust break; 11713b948ae5STrond Myklebust case TCP_LAST_ACK: 11723b948ae5STrond Myklebust smp_mb__before_clear_bit(); 11733b948ae5STrond Myklebust clear_bit(XPRT_CONNECTED, &xprt->state); 11743b948ae5STrond Myklebust smp_mb__after_clear_bit(); 11753b948ae5STrond Myklebust break; 11763b948ae5STrond Myklebust case TCP_CLOSE: 11773b948ae5STrond Myklebust smp_mb__before_clear_bit(); 1178ef803670STrond Myklebust clear_bit(XPRT_CLOSE_WAIT, &xprt->state); 11793b948ae5STrond Myklebust clear_bit(XPRT_CLOSING, &xprt->state); 11803b948ae5STrond Myklebust smp_mb__after_clear_bit(); 11813b948ae5STrond Myklebust /* Mark transport as closed and wake up all pending tasks */ 118262da3b24STrond Myklebust xprt_disconnect_done(xprt); 1183a246b010SChuck Lever } 1184a246b010SChuck Lever out: 1185a246b010SChuck Lever read_unlock(&sk->sk_callback_lock); 1186a246b010SChuck Lever } 1187a246b010SChuck Lever 11889903cd1cSChuck Lever /** 1189c7b2cae8SChuck Lever * xs_udp_write_space - callback invoked when socket buffer space 1190c7b2cae8SChuck Lever * becomes available 11919903cd1cSChuck Lever * @sk: socket whose state has changed 11929903cd1cSChuck Lever * 1193a246b010SChuck Lever * Called when more output buffer space is available for this socket. 1194a246b010SChuck Lever * We try not to wake our writers until they can make "significant" 1195c7b2cae8SChuck Lever * progress, otherwise we'll waste resources thrashing kernel_sendmsg 1196a246b010SChuck Lever * with a bunch of small requests. 1197a246b010SChuck Lever */ 1198c7b2cae8SChuck Lever static void xs_udp_write_space(struct sock *sk) 1199a246b010SChuck Lever { 1200a246b010SChuck Lever read_lock(&sk->sk_callback_lock); 1201c7b2cae8SChuck Lever 1202c7b2cae8SChuck Lever /* from net/core/sock.c:sock_def_write_space */ 1203c7b2cae8SChuck Lever if (sock_writeable(sk)) { 1204c7b2cae8SChuck Lever struct socket *sock; 1205c7b2cae8SChuck Lever struct rpc_xprt *xprt; 1206c7b2cae8SChuck Lever 1207c7b2cae8SChuck Lever if (unlikely(!(sock = sk->sk_socket))) 1208a246b010SChuck Lever goto out; 1209b6ddf64fSTrond Myklebust clear_bit(SOCK_NOSPACE, &sock->flags); 1210b6ddf64fSTrond Myklebust 1211c7b2cae8SChuck Lever if (unlikely(!(xprt = xprt_from_sock(sk)))) 1212c7b2cae8SChuck Lever goto out; 1213b6ddf64fSTrond Myklebust if (test_and_clear_bit(SOCK_ASYNC_NOSPACE, &sock->flags) == 0) 1214a246b010SChuck Lever goto out; 1215a246b010SChuck Lever 1216c7b2cae8SChuck Lever xprt_write_space(xprt); 1217a246b010SChuck Lever } 1218a246b010SChuck Lever 1219c7b2cae8SChuck Lever out: 1220c7b2cae8SChuck Lever read_unlock(&sk->sk_callback_lock); 1221c7b2cae8SChuck Lever } 1222c7b2cae8SChuck Lever 1223c7b2cae8SChuck Lever /** 1224c7b2cae8SChuck Lever * xs_tcp_write_space - callback invoked when socket buffer space 1225c7b2cae8SChuck Lever * becomes available 1226c7b2cae8SChuck Lever * @sk: socket whose state has changed 1227c7b2cae8SChuck Lever * 1228c7b2cae8SChuck Lever * Called when more output buffer space is available for this socket. 1229c7b2cae8SChuck Lever * We try not to wake our writers until they can make "significant" 1230c7b2cae8SChuck Lever * progress, otherwise we'll waste resources thrashing kernel_sendmsg 1231c7b2cae8SChuck Lever * with a bunch of small requests. 1232c7b2cae8SChuck Lever */ 1233c7b2cae8SChuck Lever static void xs_tcp_write_space(struct sock *sk) 1234c7b2cae8SChuck Lever { 1235c7b2cae8SChuck Lever read_lock(&sk->sk_callback_lock); 1236c7b2cae8SChuck Lever 1237c7b2cae8SChuck Lever /* from net/core/stream.c:sk_stream_write_space */ 1238c7b2cae8SChuck Lever if (sk_stream_wspace(sk) >= sk_stream_min_wspace(sk)) { 1239c7b2cae8SChuck Lever struct socket *sock; 1240c7b2cae8SChuck Lever struct rpc_xprt *xprt; 1241c7b2cae8SChuck Lever 1242c7b2cae8SChuck Lever if (unlikely(!(sock = sk->sk_socket))) 1243c7b2cae8SChuck Lever goto out; 1244b6ddf64fSTrond Myklebust clear_bit(SOCK_NOSPACE, &sock->flags); 1245b6ddf64fSTrond Myklebust 1246c7b2cae8SChuck Lever if (unlikely(!(xprt = xprt_from_sock(sk)))) 1247c7b2cae8SChuck Lever goto out; 1248b6ddf64fSTrond Myklebust if (test_and_clear_bit(SOCK_ASYNC_NOSPACE, &sock->flags) == 0) 1249a246b010SChuck Lever goto out; 1250a246b010SChuck Lever 1251c7b2cae8SChuck Lever xprt_write_space(xprt); 1252c7b2cae8SChuck Lever } 1253c7b2cae8SChuck Lever 1254a246b010SChuck Lever out: 1255a246b010SChuck Lever read_unlock(&sk->sk_callback_lock); 1256a246b010SChuck Lever } 1257a246b010SChuck Lever 1258470056c2SChuck Lever static void xs_udp_do_set_buffer_size(struct rpc_xprt *xprt) 1259a246b010SChuck Lever { 1260ee0ac0c2SChuck Lever struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt); 1261ee0ac0c2SChuck Lever struct sock *sk = transport->inet; 1262a246b010SChuck Lever 12637c6e066eSChuck Lever if (transport->rcvsize) { 1264a246b010SChuck Lever sk->sk_userlocks |= SOCK_RCVBUF_LOCK; 12657c6e066eSChuck Lever sk->sk_rcvbuf = transport->rcvsize * xprt->max_reqs * 2; 1266a246b010SChuck Lever } 12677c6e066eSChuck Lever if (transport->sndsize) { 1268a246b010SChuck Lever sk->sk_userlocks |= SOCK_SNDBUF_LOCK; 12697c6e066eSChuck Lever sk->sk_sndbuf = transport->sndsize * xprt->max_reqs * 2; 1270a246b010SChuck Lever sk->sk_write_space(sk); 1271a246b010SChuck Lever } 1272a246b010SChuck Lever } 1273a246b010SChuck Lever 127443118c29SChuck Lever /** 1275470056c2SChuck Lever * xs_udp_set_buffer_size - set send and receive limits 127643118c29SChuck Lever * @xprt: generic transport 1277470056c2SChuck Lever * @sndsize: requested size of send buffer, in bytes 1278470056c2SChuck Lever * @rcvsize: requested size of receive buffer, in bytes 127943118c29SChuck Lever * 1280470056c2SChuck Lever * Set socket send and receive buffer size limits. 128143118c29SChuck Lever */ 1282470056c2SChuck Lever static void xs_udp_set_buffer_size(struct rpc_xprt *xprt, size_t sndsize, size_t rcvsize) 128343118c29SChuck Lever { 12847c6e066eSChuck Lever struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt); 12857c6e066eSChuck Lever 12867c6e066eSChuck Lever transport->sndsize = 0; 1287470056c2SChuck Lever if (sndsize) 12887c6e066eSChuck Lever transport->sndsize = sndsize + 1024; 12897c6e066eSChuck Lever transport->rcvsize = 0; 1290470056c2SChuck Lever if (rcvsize) 12917c6e066eSChuck Lever transport->rcvsize = rcvsize + 1024; 1292470056c2SChuck Lever 1293470056c2SChuck Lever xs_udp_do_set_buffer_size(xprt); 129443118c29SChuck Lever } 129543118c29SChuck Lever 129646c0ee8bSChuck Lever /** 129746c0ee8bSChuck Lever * xs_udp_timer - called when a retransmit timeout occurs on a UDP transport 129846c0ee8bSChuck Lever * @task: task that timed out 129946c0ee8bSChuck Lever * 130046c0ee8bSChuck Lever * Adjust the congestion window after a retransmit timeout has occurred. 130146c0ee8bSChuck Lever */ 130246c0ee8bSChuck Lever static void xs_udp_timer(struct rpc_task *task) 130346c0ee8bSChuck Lever { 130446c0ee8bSChuck Lever xprt_adjust_cwnd(task, -ETIMEDOUT); 130546c0ee8bSChuck Lever } 130646c0ee8bSChuck Lever 1307b85d8806SChuck Lever static unsigned short xs_get_random_port(void) 1308b85d8806SChuck Lever { 1309b85d8806SChuck Lever unsigned short range = xprt_max_resvport - xprt_min_resvport; 1310b85d8806SChuck Lever unsigned short rand = (unsigned short) net_random() % range; 1311b85d8806SChuck Lever return rand + xprt_min_resvport; 1312b85d8806SChuck Lever } 1313b85d8806SChuck Lever 131492200412SChuck Lever /** 131592200412SChuck Lever * xs_set_port - reset the port number in the remote endpoint address 131692200412SChuck Lever * @xprt: generic transport 131792200412SChuck Lever * @port: new port number 131892200412SChuck Lever * 131992200412SChuck Lever */ 132092200412SChuck Lever static void xs_set_port(struct rpc_xprt *xprt, unsigned short port) 132192200412SChuck Lever { 132295392c59SChuck Lever struct sockaddr *addr = xs_addr(xprt); 1323c4efcb1dSChuck Lever 132492200412SChuck Lever dprintk("RPC: setting port for xprt %p to %u\n", xprt, port); 1325c4efcb1dSChuck Lever 132620612005SChuck Lever switch (addr->sa_family) { 132720612005SChuck Lever case AF_INET: 132820612005SChuck Lever ((struct sockaddr_in *)addr)->sin_port = htons(port); 132920612005SChuck Lever break; 133020612005SChuck Lever case AF_INET6: 133120612005SChuck Lever ((struct sockaddr_in6 *)addr)->sin6_port = htons(port); 133220612005SChuck Lever break; 133320612005SChuck Lever default: 133420612005SChuck Lever BUG(); 133520612005SChuck Lever } 133692200412SChuck Lever } 133792200412SChuck Lever 133867a391d7STrond Myklebust static unsigned short xs_get_srcport(struct sock_xprt *transport, struct socket *sock) 133967a391d7STrond Myklebust { 134067a391d7STrond Myklebust unsigned short port = transport->port; 134167a391d7STrond Myklebust 134267a391d7STrond Myklebust if (port == 0 && transport->xprt.resvport) 134367a391d7STrond Myklebust port = xs_get_random_port(); 134467a391d7STrond Myklebust return port; 134567a391d7STrond Myklebust } 134667a391d7STrond Myklebust 134767a391d7STrond Myklebust static unsigned short xs_next_srcport(struct sock_xprt *transport, struct socket *sock, unsigned short port) 134867a391d7STrond Myklebust { 134967a391d7STrond Myklebust if (transport->port != 0) 135067a391d7STrond Myklebust transport->port = 0; 135167a391d7STrond Myklebust if (!transport->xprt.resvport) 135267a391d7STrond Myklebust return 0; 135367a391d7STrond Myklebust if (port <= xprt_min_resvport || port > xprt_max_resvport) 135467a391d7STrond Myklebust return xprt_max_resvport; 135567a391d7STrond Myklebust return --port; 135667a391d7STrond Myklebust } 135767a391d7STrond Myklebust 13587dc753f0SChuck Lever static int xs_bind4(struct sock_xprt *transport, struct socket *sock) 1359a246b010SChuck Lever { 1360a246b010SChuck Lever struct sockaddr_in myaddr = { 1361a246b010SChuck Lever .sin_family = AF_INET, 1362a246b010SChuck Lever }; 1363d3bc9a1dSFrank van Maarseveen struct sockaddr_in *sa; 136467a391d7STrond Myklebust int err, nloop = 0; 136567a391d7STrond Myklebust unsigned short port = xs_get_srcport(transport, sock); 136667a391d7STrond Myklebust unsigned short last; 1367a246b010SChuck Lever 1368d3bc9a1dSFrank van Maarseveen sa = (struct sockaddr_in *)&transport->addr; 1369d3bc9a1dSFrank van Maarseveen myaddr.sin_addr = sa->sin_addr; 1370a246b010SChuck Lever do { 1371a246b010SChuck Lever myaddr.sin_port = htons(port); 1372e6242e92SSridhar Samudrala err = kernel_bind(sock, (struct sockaddr *) &myaddr, 1373a246b010SChuck Lever sizeof(myaddr)); 137467a391d7STrond Myklebust if (port == 0) 1375d3bc9a1dSFrank van Maarseveen break; 1376a246b010SChuck Lever if (err == 0) { 1377c8475461SChuck Lever transport->port = port; 1378d3bc9a1dSFrank van Maarseveen break; 1379a246b010SChuck Lever } 138067a391d7STrond Myklebust last = port; 138167a391d7STrond Myklebust port = xs_next_srcport(transport, sock, port); 138267a391d7STrond Myklebust if (port > last) 138367a391d7STrond Myklebust nloop++; 138467a391d7STrond Myklebust } while (err == -EADDRINUSE && nloop != 2); 13857dc753f0SChuck Lever dprintk("RPC: %s "NIPQUAD_FMT":%u: %s (%d)\n", 13867dc753f0SChuck Lever __FUNCTION__, NIPQUAD(myaddr.sin_addr), 13877dc753f0SChuck Lever port, err ? "failed" : "ok", err); 1388a246b010SChuck Lever return err; 1389a246b010SChuck Lever } 1390a246b010SChuck Lever 139190058d37SChuck Lever static int xs_bind6(struct sock_xprt *transport, struct socket *sock) 139290058d37SChuck Lever { 139390058d37SChuck Lever struct sockaddr_in6 myaddr = { 139490058d37SChuck Lever .sin6_family = AF_INET6, 139590058d37SChuck Lever }; 139690058d37SChuck Lever struct sockaddr_in6 *sa; 139767a391d7STrond Myklebust int err, nloop = 0; 139867a391d7STrond Myklebust unsigned short port = xs_get_srcport(transport, sock); 139967a391d7STrond Myklebust unsigned short last; 140090058d37SChuck Lever 140190058d37SChuck Lever sa = (struct sockaddr_in6 *)&transport->addr; 140290058d37SChuck Lever myaddr.sin6_addr = sa->sin6_addr; 140390058d37SChuck Lever do { 140490058d37SChuck Lever myaddr.sin6_port = htons(port); 140590058d37SChuck Lever err = kernel_bind(sock, (struct sockaddr *) &myaddr, 140690058d37SChuck Lever sizeof(myaddr)); 140767a391d7STrond Myklebust if (port == 0) 140890058d37SChuck Lever break; 140990058d37SChuck Lever if (err == 0) { 141090058d37SChuck Lever transport->port = port; 141190058d37SChuck Lever break; 141290058d37SChuck Lever } 141367a391d7STrond Myklebust last = port; 141467a391d7STrond Myklebust port = xs_next_srcport(transport, sock, port); 141567a391d7STrond Myklebust if (port > last) 141667a391d7STrond Myklebust nloop++; 141767a391d7STrond Myklebust } while (err == -EADDRINUSE && nloop != 2); 141890058d37SChuck Lever dprintk("RPC: xs_bind6 "NIP6_FMT":%u: %s (%d)\n", 141990058d37SChuck Lever NIP6(myaddr.sin6_addr), port, err ? "failed" : "ok", err); 1420a246b010SChuck Lever return err; 1421a246b010SChuck Lever } 1422a246b010SChuck Lever 1423ed07536eSPeter Zijlstra #ifdef CONFIG_DEBUG_LOCK_ALLOC 1424ed07536eSPeter Zijlstra static struct lock_class_key xs_key[2]; 1425ed07536eSPeter Zijlstra static struct lock_class_key xs_slock_key[2]; 1426ed07536eSPeter Zijlstra 14278945ee5eSChuck Lever static inline void xs_reclassify_socket4(struct socket *sock) 1428ed07536eSPeter Zijlstra { 1429ed07536eSPeter Zijlstra struct sock *sk = sock->sk; 14308945ee5eSChuck Lever 143102b3d346SJohn Heffner BUG_ON(sock_owned_by_user(sk)); 14328945ee5eSChuck Lever sock_lock_init_class_and_name(sk, "slock-AF_INET-RPC", 14338945ee5eSChuck Lever &xs_slock_key[0], "sk_lock-AF_INET-RPC", &xs_key[0]); 1434ed07536eSPeter Zijlstra } 14358945ee5eSChuck Lever 14368945ee5eSChuck Lever static inline void xs_reclassify_socket6(struct socket *sock) 14378945ee5eSChuck Lever { 14388945ee5eSChuck Lever struct sock *sk = sock->sk; 14398945ee5eSChuck Lever 1440f4921affSLinus Torvalds BUG_ON(sock_owned_by_user(sk)); 14418945ee5eSChuck Lever sock_lock_init_class_and_name(sk, "slock-AF_INET6-RPC", 14428945ee5eSChuck Lever &xs_slock_key[1], "sk_lock-AF_INET6-RPC", &xs_key[1]); 1443ed07536eSPeter Zijlstra } 1444ed07536eSPeter Zijlstra #else 14458945ee5eSChuck Lever static inline void xs_reclassify_socket4(struct socket *sock) 14468945ee5eSChuck Lever { 14478945ee5eSChuck Lever } 14488945ee5eSChuck Lever 14498945ee5eSChuck Lever static inline void xs_reclassify_socket6(struct socket *sock) 1450ed07536eSPeter Zijlstra { 1451ed07536eSPeter Zijlstra } 1452ed07536eSPeter Zijlstra #endif 1453ed07536eSPeter Zijlstra 145416be2d20SChuck Lever static void xs_udp_finish_connecting(struct rpc_xprt *xprt, struct socket *sock) 1455a246b010SChuck Lever { 145616be2d20SChuck Lever struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt); 1457edb267a6SChuck Lever 1458ee0ac0c2SChuck Lever if (!transport->inet) { 1459b0d93ad5SChuck Lever struct sock *sk = sock->sk; 1460b0d93ad5SChuck Lever 1461b0d93ad5SChuck Lever write_lock_bh(&sk->sk_callback_lock); 1462b0d93ad5SChuck Lever 1463b0d93ad5SChuck Lever sk->sk_user_data = xprt; 1464314dfd79SChuck Lever transport->old_data_ready = sk->sk_data_ready; 1465314dfd79SChuck Lever transport->old_state_change = sk->sk_state_change; 1466314dfd79SChuck Lever transport->old_write_space = sk->sk_write_space; 1467b0d93ad5SChuck Lever sk->sk_data_ready = xs_udp_data_ready; 1468b0d93ad5SChuck Lever sk->sk_write_space = xs_udp_write_space; 1469b0d93ad5SChuck Lever sk->sk_no_check = UDP_CSUM_NORCV; 1470b079fa7bSTrond Myklebust sk->sk_allocation = GFP_ATOMIC; 1471b0d93ad5SChuck Lever 1472b0d93ad5SChuck Lever xprt_set_connected(xprt); 1473b0d93ad5SChuck Lever 1474b0d93ad5SChuck Lever /* Reset to new socket */ 1475ee0ac0c2SChuck Lever transport->sock = sock; 1476ee0ac0c2SChuck Lever transport->inet = sk; 1477b0d93ad5SChuck Lever 1478b0d93ad5SChuck Lever write_unlock_bh(&sk->sk_callback_lock); 1479b0d93ad5SChuck Lever } 1480470056c2SChuck Lever xs_udp_do_set_buffer_size(xprt); 148116be2d20SChuck Lever } 148216be2d20SChuck Lever 1483a246b010SChuck Lever /** 14849c3d72deSChuck Lever * xs_udp_connect_worker4 - set up a UDP socket 1485a246b010SChuck Lever * @work: RPC transport to connect 1486a246b010SChuck Lever * 1487a246b010SChuck Lever * Invoked by a work queue tasklet. 1488a246b010SChuck Lever */ 14899c3d72deSChuck Lever static void xs_udp_connect_worker4(struct work_struct *work) 1490a246b010SChuck Lever { 1491a246b010SChuck Lever struct sock_xprt *transport = 1492a246b010SChuck Lever container_of(work, struct sock_xprt, connect_worker.work); 1493a246b010SChuck Lever struct rpc_xprt *xprt = &transport->xprt; 1494a246b010SChuck Lever struct socket *sock = transport->sock; 1495a246b010SChuck Lever int err, status = -EIO; 1496a246b010SChuck Lever 1497a246b010SChuck Lever if (xprt->shutdown || !xprt_bound(xprt)) 14989903cd1cSChuck Lever goto out; 14999903cd1cSChuck Lever 1500a246b010SChuck Lever /* Start by resetting any existing state */ 1501a246b010SChuck Lever xs_close(xprt); 1502a246b010SChuck Lever 15039903cd1cSChuck Lever if ((err = sock_create_kern(PF_INET, SOCK_DGRAM, IPPROTO_UDP, &sock)) < 0) { 15049903cd1cSChuck Lever dprintk("RPC: can't create UDP transport socket (%d).\n", -err); 1505a246b010SChuck Lever goto out; 1506a246b010SChuck Lever } 15078945ee5eSChuck Lever xs_reclassify_socket4(sock); 1508a246b010SChuck Lever 15097dc753f0SChuck Lever if (xs_bind4(transport, sock)) { 15109903cd1cSChuck Lever sock_release(sock); 15119903cd1cSChuck Lever goto out; 1512a246b010SChuck Lever } 1513b0d93ad5SChuck Lever 1514b0d93ad5SChuck Lever dprintk("RPC: worker connecting xprt %p to address: %s\n", 1515b0d93ad5SChuck Lever xprt, xprt->address_strings[RPC_DISPLAY_ALL]); 1516b0d93ad5SChuck Lever 151716be2d20SChuck Lever xs_udp_finish_connecting(xprt, sock); 1518a246b010SChuck Lever status = 0; 1519b0d93ad5SChuck Lever out: 1520b0d93ad5SChuck Lever xprt_wake_pending_tasks(xprt, status); 1521b0d93ad5SChuck Lever xprt_clear_connecting(xprt); 1522b0d93ad5SChuck Lever } 1523b0d93ad5SChuck Lever 152468e220bdSChuck Lever /** 152568e220bdSChuck Lever * xs_udp_connect_worker6 - set up a UDP socket 152668e220bdSChuck Lever * @work: RPC transport to connect 152768e220bdSChuck Lever * 152868e220bdSChuck Lever * Invoked by a work queue tasklet. 152968e220bdSChuck Lever */ 153068e220bdSChuck Lever static void xs_udp_connect_worker6(struct work_struct *work) 153168e220bdSChuck Lever { 153268e220bdSChuck Lever struct sock_xprt *transport = 153368e220bdSChuck Lever container_of(work, struct sock_xprt, connect_worker.work); 153468e220bdSChuck Lever struct rpc_xprt *xprt = &transport->xprt; 153568e220bdSChuck Lever struct socket *sock = transport->sock; 153668e220bdSChuck Lever int err, status = -EIO; 153768e220bdSChuck Lever 153868e220bdSChuck Lever if (xprt->shutdown || !xprt_bound(xprt)) 153968e220bdSChuck Lever goto out; 154068e220bdSChuck Lever 154168e220bdSChuck Lever /* Start by resetting any existing state */ 154268e220bdSChuck Lever xs_close(xprt); 154368e220bdSChuck Lever 154468e220bdSChuck Lever if ((err = sock_create_kern(PF_INET6, SOCK_DGRAM, IPPROTO_UDP, &sock)) < 0) { 154568e220bdSChuck Lever dprintk("RPC: can't create UDP transport socket (%d).\n", -err); 154668e220bdSChuck Lever goto out; 154768e220bdSChuck Lever } 15488945ee5eSChuck Lever xs_reclassify_socket6(sock); 154968e220bdSChuck Lever 155068e220bdSChuck Lever if (xs_bind6(transport, sock) < 0) { 155168e220bdSChuck Lever sock_release(sock); 155268e220bdSChuck Lever goto out; 155368e220bdSChuck Lever } 155468e220bdSChuck Lever 155568e220bdSChuck Lever dprintk("RPC: worker connecting xprt %p to address: %s\n", 155668e220bdSChuck Lever xprt, xprt->address_strings[RPC_DISPLAY_ALL]); 155768e220bdSChuck Lever 155868e220bdSChuck Lever xs_udp_finish_connecting(xprt, sock); 1559a246b010SChuck Lever status = 0; 1560b0d93ad5SChuck Lever out: 1561b0d93ad5SChuck Lever xprt_wake_pending_tasks(xprt, status); 1562b0d93ad5SChuck Lever xprt_clear_connecting(xprt); 1563b0d93ad5SChuck Lever } 1564b0d93ad5SChuck Lever 15653167e12cSChuck Lever /* 15663167e12cSChuck Lever * We need to preserve the port number so the reply cache on the server can 15673167e12cSChuck Lever * find our cached RPC replies when we get around to reconnecting. 15683167e12cSChuck Lever */ 15693167e12cSChuck Lever static void xs_tcp_reuse_connection(struct rpc_xprt *xprt) 15703167e12cSChuck Lever { 15713167e12cSChuck Lever int result; 1572ee0ac0c2SChuck Lever struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt); 15733167e12cSChuck Lever struct sockaddr any; 15743167e12cSChuck Lever 15753167e12cSChuck Lever dprintk("RPC: disconnecting xprt %p to reuse port\n", xprt); 15763167e12cSChuck Lever 15773167e12cSChuck Lever /* 15783167e12cSChuck Lever * Disconnect the transport socket by doing a connect operation 15793167e12cSChuck Lever * with AF_UNSPEC. This should return immediately... 15803167e12cSChuck Lever */ 15813167e12cSChuck Lever memset(&any, 0, sizeof(any)); 15823167e12cSChuck Lever any.sa_family = AF_UNSPEC; 1583ee0ac0c2SChuck Lever result = kernel_connect(transport->sock, &any, sizeof(any), 0); 15843167e12cSChuck Lever if (result) 15853167e12cSChuck Lever dprintk("RPC: AF_UNSPEC connect return code %d\n", 15863167e12cSChuck Lever result); 15873167e12cSChuck Lever } 15883167e12cSChuck Lever 158916be2d20SChuck Lever static int xs_tcp_finish_connecting(struct rpc_xprt *xprt, struct socket *sock) 1590b0d93ad5SChuck Lever { 159116be2d20SChuck Lever struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt); 1592edb267a6SChuck Lever 1593ee0ac0c2SChuck Lever if (!transport->inet) { 1594b0d93ad5SChuck Lever struct sock *sk = sock->sk; 1595b0d93ad5SChuck Lever 1596b0d93ad5SChuck Lever write_lock_bh(&sk->sk_callback_lock); 1597b0d93ad5SChuck Lever 1598b0d93ad5SChuck Lever sk->sk_user_data = xprt; 1599314dfd79SChuck Lever transport->old_data_ready = sk->sk_data_ready; 1600314dfd79SChuck Lever transport->old_state_change = sk->sk_state_change; 1601314dfd79SChuck Lever transport->old_write_space = sk->sk_write_space; 1602b0d93ad5SChuck Lever sk->sk_data_ready = xs_tcp_data_ready; 1603b0d93ad5SChuck Lever sk->sk_state_change = xs_tcp_state_change; 1604b0d93ad5SChuck Lever sk->sk_write_space = xs_tcp_write_space; 1605b079fa7bSTrond Myklebust sk->sk_allocation = GFP_ATOMIC; 16063167e12cSChuck Lever 16073167e12cSChuck Lever /* socket options */ 16083167e12cSChuck Lever sk->sk_userlocks |= SOCK_BINDPORT_LOCK; 16093167e12cSChuck Lever sock_reset_flag(sk, SOCK_LINGER); 16103167e12cSChuck Lever tcp_sk(sk)->linger2 = 0; 16113167e12cSChuck Lever tcp_sk(sk)->nonagle |= TCP_NAGLE_OFF; 1612b0d93ad5SChuck Lever 1613b0d93ad5SChuck Lever xprt_clear_connected(xprt); 1614b0d93ad5SChuck Lever 1615b0d93ad5SChuck Lever /* Reset to new socket */ 1616ee0ac0c2SChuck Lever transport->sock = sock; 1617ee0ac0c2SChuck Lever transport->inet = sk; 1618b0d93ad5SChuck Lever 1619b0d93ad5SChuck Lever write_unlock_bh(&sk->sk_callback_lock); 1620b0d93ad5SChuck Lever } 1621b0d93ad5SChuck Lever 1622b0d93ad5SChuck Lever /* Tell the socket layer to start connecting... */ 1623262ca07dSChuck Lever xprt->stat.connect_count++; 1624262ca07dSChuck Lever xprt->stat.connect_start = jiffies; 162595392c59SChuck Lever return kernel_connect(sock, xs_addr(xprt), xprt->addrlen, O_NONBLOCK); 162616be2d20SChuck Lever } 162716be2d20SChuck Lever 162816be2d20SChuck Lever /** 16299c3d72deSChuck Lever * xs_tcp_connect_worker4 - connect a TCP socket to a remote endpoint 163016be2d20SChuck Lever * @work: RPC transport to connect 163116be2d20SChuck Lever * 163216be2d20SChuck Lever * Invoked by a work queue tasklet. 163316be2d20SChuck Lever */ 16349c3d72deSChuck Lever static void xs_tcp_connect_worker4(struct work_struct *work) 163516be2d20SChuck Lever { 163616be2d20SChuck Lever struct sock_xprt *transport = 163716be2d20SChuck Lever container_of(work, struct sock_xprt, connect_worker.work); 163816be2d20SChuck Lever struct rpc_xprt *xprt = &transport->xprt; 163916be2d20SChuck Lever struct socket *sock = transport->sock; 164016be2d20SChuck Lever int err, status = -EIO; 164116be2d20SChuck Lever 164216be2d20SChuck Lever if (xprt->shutdown || !xprt_bound(xprt)) 164316be2d20SChuck Lever goto out; 164416be2d20SChuck Lever 164516be2d20SChuck Lever if (!sock) { 164616be2d20SChuck Lever /* start from scratch */ 164716be2d20SChuck Lever if ((err = sock_create_kern(PF_INET, SOCK_STREAM, IPPROTO_TCP, &sock)) < 0) { 164816be2d20SChuck Lever dprintk("RPC: can't create TCP transport socket (%d).\n", -err); 164916be2d20SChuck Lever goto out; 165016be2d20SChuck Lever } 16518945ee5eSChuck Lever xs_reclassify_socket4(sock); 165216be2d20SChuck Lever 165316be2d20SChuck Lever if (xs_bind4(transport, sock) < 0) { 165416be2d20SChuck Lever sock_release(sock); 165516be2d20SChuck Lever goto out; 165616be2d20SChuck Lever } 165716be2d20SChuck Lever } else 165816be2d20SChuck Lever /* "close" the socket, preserving the local port */ 165916be2d20SChuck Lever xs_tcp_reuse_connection(xprt); 166016be2d20SChuck Lever 166116be2d20SChuck Lever dprintk("RPC: worker connecting xprt %p to address: %s\n", 166216be2d20SChuck Lever xprt, xprt->address_strings[RPC_DISPLAY_ALL]); 166316be2d20SChuck Lever 166416be2d20SChuck Lever status = xs_tcp_finish_connecting(xprt, sock); 1665a246b010SChuck Lever dprintk("RPC: %p connect status %d connected %d sock state %d\n", 166646121cf7SChuck Lever xprt, -status, xprt_connected(xprt), 166746121cf7SChuck Lever sock->sk->sk_state); 1668a246b010SChuck Lever if (status < 0) { 1669a246b010SChuck Lever switch (status) { 1670a246b010SChuck Lever case -EINPROGRESS: 1671a246b010SChuck Lever case -EALREADY: 1672a246b010SChuck Lever goto out_clear; 16733167e12cSChuck Lever case -ECONNREFUSED: 16743167e12cSChuck Lever case -ECONNRESET: 16753167e12cSChuck Lever /* retry with existing socket, after a delay */ 16763167e12cSChuck Lever break; 16773167e12cSChuck Lever default: 16783167e12cSChuck Lever /* get rid of existing socket, and retry */ 1679e06799f9STrond Myklebust xs_tcp_shutdown(xprt); 1680a246b010SChuck Lever } 1681a246b010SChuck Lever } 1682a246b010SChuck Lever out: 168344fbac22SChuck Lever xprt_wake_pending_tasks(xprt, status); 1684a246b010SChuck Lever out_clear: 16852226feb6SChuck Lever xprt_clear_connecting(xprt); 1686a246b010SChuck Lever } 1687a246b010SChuck Lever 16889903cd1cSChuck Lever /** 168968e220bdSChuck Lever * xs_tcp_connect_worker6 - connect a TCP socket to a remote endpoint 169068e220bdSChuck Lever * @work: RPC transport to connect 169168e220bdSChuck Lever * 169268e220bdSChuck Lever * Invoked by a work queue tasklet. 169368e220bdSChuck Lever */ 169468e220bdSChuck Lever static void xs_tcp_connect_worker6(struct work_struct *work) 169568e220bdSChuck Lever { 169668e220bdSChuck Lever struct sock_xprt *transport = 169768e220bdSChuck Lever container_of(work, struct sock_xprt, connect_worker.work); 169868e220bdSChuck Lever struct rpc_xprt *xprt = &transport->xprt; 169968e220bdSChuck Lever struct socket *sock = transport->sock; 170068e220bdSChuck Lever int err, status = -EIO; 170168e220bdSChuck Lever 170268e220bdSChuck Lever if (xprt->shutdown || !xprt_bound(xprt)) 170368e220bdSChuck Lever goto out; 170468e220bdSChuck Lever 170568e220bdSChuck Lever if (!sock) { 170668e220bdSChuck Lever /* start from scratch */ 170768e220bdSChuck Lever if ((err = sock_create_kern(PF_INET6, SOCK_STREAM, IPPROTO_TCP, &sock)) < 0) { 170868e220bdSChuck Lever dprintk("RPC: can't create TCP transport socket (%d).\n", -err); 170968e220bdSChuck Lever goto out; 171068e220bdSChuck Lever } 17118945ee5eSChuck Lever xs_reclassify_socket6(sock); 171268e220bdSChuck Lever 171368e220bdSChuck Lever if (xs_bind6(transport, sock) < 0) { 171468e220bdSChuck Lever sock_release(sock); 171568e220bdSChuck Lever goto out; 171668e220bdSChuck Lever } 171768e220bdSChuck Lever } else 171868e220bdSChuck Lever /* "close" the socket, preserving the local port */ 171968e220bdSChuck Lever xs_tcp_reuse_connection(xprt); 172068e220bdSChuck Lever 172168e220bdSChuck Lever dprintk("RPC: worker connecting xprt %p to address: %s\n", 172268e220bdSChuck Lever xprt, xprt->address_strings[RPC_DISPLAY_ALL]); 172368e220bdSChuck Lever 172468e220bdSChuck Lever status = xs_tcp_finish_connecting(xprt, sock); 172568e220bdSChuck Lever dprintk("RPC: %p connect status %d connected %d sock state %d\n", 172668e220bdSChuck Lever xprt, -status, xprt_connected(xprt), sock->sk->sk_state); 172768e220bdSChuck Lever if (status < 0) { 172868e220bdSChuck Lever switch (status) { 172968e220bdSChuck Lever case -EINPROGRESS: 173068e220bdSChuck Lever case -EALREADY: 173168e220bdSChuck Lever goto out_clear; 173268e220bdSChuck Lever case -ECONNREFUSED: 173368e220bdSChuck Lever case -ECONNRESET: 173468e220bdSChuck Lever /* retry with existing socket, after a delay */ 173568e220bdSChuck Lever break; 173668e220bdSChuck Lever default: 173768e220bdSChuck Lever /* get rid of existing socket, and retry */ 1738e06799f9STrond Myklebust xs_tcp_shutdown(xprt); 173968e220bdSChuck Lever } 174068e220bdSChuck Lever } 174168e220bdSChuck Lever out: 174268e220bdSChuck Lever xprt_wake_pending_tasks(xprt, status); 174368e220bdSChuck Lever out_clear: 174468e220bdSChuck Lever xprt_clear_connecting(xprt); 174568e220bdSChuck Lever } 174668e220bdSChuck Lever 174768e220bdSChuck Lever /** 17489903cd1cSChuck Lever * xs_connect - connect a socket to a remote endpoint 17499903cd1cSChuck Lever * @task: address of RPC task that manages state of connect request 17509903cd1cSChuck Lever * 17519903cd1cSChuck Lever * TCP: If the remote end dropped the connection, delay reconnecting. 175203bf4b70SChuck Lever * 175303bf4b70SChuck Lever * UDP socket connects are synchronous, but we use a work queue anyway 175403bf4b70SChuck Lever * to guarantee that even unprivileged user processes can set up a 175503bf4b70SChuck Lever * socket on a privileged port. 175603bf4b70SChuck Lever * 175703bf4b70SChuck Lever * If a UDP socket connect fails, the delay behavior here prevents 175803bf4b70SChuck Lever * retry floods (hard mounts). 17599903cd1cSChuck Lever */ 17609903cd1cSChuck Lever static void xs_connect(struct rpc_task *task) 1761a246b010SChuck Lever { 1762a246b010SChuck Lever struct rpc_xprt *xprt = task->tk_xprt; 1763ee0ac0c2SChuck Lever struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt); 1764a246b010SChuck Lever 1765b0d93ad5SChuck Lever if (xprt_test_and_set_connecting(xprt)) 1766b0d93ad5SChuck Lever return; 1767b0d93ad5SChuck Lever 1768ee0ac0c2SChuck Lever if (transport->sock != NULL) { 176946121cf7SChuck Lever dprintk("RPC: xs_connect delayed xprt %p for %lu " 177046121cf7SChuck Lever "seconds\n", 177103bf4b70SChuck Lever xprt, xprt->reestablish_timeout / HZ); 1772c1384c9cSTrond Myklebust queue_delayed_work(rpciod_workqueue, 1773c1384c9cSTrond Myklebust &transport->connect_worker, 177403bf4b70SChuck Lever xprt->reestablish_timeout); 177503bf4b70SChuck Lever xprt->reestablish_timeout <<= 1; 177603bf4b70SChuck Lever if (xprt->reestablish_timeout > XS_TCP_MAX_REEST_TO) 177703bf4b70SChuck Lever xprt->reestablish_timeout = XS_TCP_MAX_REEST_TO; 17789903cd1cSChuck Lever } else { 17799903cd1cSChuck Lever dprintk("RPC: xs_connect scheduled xprt %p\n", xprt); 1780c1384c9cSTrond Myklebust queue_delayed_work(rpciod_workqueue, 1781c1384c9cSTrond Myklebust &transport->connect_worker, 0); 1782a246b010SChuck Lever } 1783a246b010SChuck Lever } 1784a246b010SChuck Lever 1785e06799f9STrond Myklebust static void xs_tcp_connect(struct rpc_task *task) 1786e06799f9STrond Myklebust { 1787e06799f9STrond Myklebust struct rpc_xprt *xprt = task->tk_xprt; 1788e06799f9STrond Myklebust 1789e06799f9STrond Myklebust /* Initiate graceful shutdown of the socket if not already done */ 1790e06799f9STrond Myklebust if (test_bit(XPRT_CONNECTED, &xprt->state)) 1791e06799f9STrond Myklebust xs_tcp_shutdown(xprt); 1792e06799f9STrond Myklebust /* Exit if we need to wait for socket shutdown to complete */ 1793e06799f9STrond Myklebust if (test_bit(XPRT_CLOSING, &xprt->state)) 1794e06799f9STrond Myklebust return; 1795e06799f9STrond Myklebust xs_connect(task); 1796e06799f9STrond Myklebust } 1797e06799f9STrond Myklebust 1798262ca07dSChuck Lever /** 1799262ca07dSChuck Lever * xs_udp_print_stats - display UDP socket-specifc stats 1800262ca07dSChuck Lever * @xprt: rpc_xprt struct containing statistics 1801262ca07dSChuck Lever * @seq: output file 1802262ca07dSChuck Lever * 1803262ca07dSChuck Lever */ 1804262ca07dSChuck Lever static void xs_udp_print_stats(struct rpc_xprt *xprt, struct seq_file *seq) 1805262ca07dSChuck Lever { 1806c8475461SChuck Lever struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt); 1807c8475461SChuck Lever 1808262ca07dSChuck Lever seq_printf(seq, "\txprt:\tudp %u %lu %lu %lu %lu %Lu %Lu\n", 1809c8475461SChuck Lever transport->port, 1810262ca07dSChuck Lever xprt->stat.bind_count, 1811262ca07dSChuck Lever xprt->stat.sends, 1812262ca07dSChuck Lever xprt->stat.recvs, 1813262ca07dSChuck Lever xprt->stat.bad_xids, 1814262ca07dSChuck Lever xprt->stat.req_u, 1815262ca07dSChuck Lever xprt->stat.bklog_u); 1816262ca07dSChuck Lever } 1817262ca07dSChuck Lever 1818262ca07dSChuck Lever /** 1819262ca07dSChuck Lever * xs_tcp_print_stats - display TCP socket-specifc stats 1820262ca07dSChuck Lever * @xprt: rpc_xprt struct containing statistics 1821262ca07dSChuck Lever * @seq: output file 1822262ca07dSChuck Lever * 1823262ca07dSChuck Lever */ 1824262ca07dSChuck Lever static void xs_tcp_print_stats(struct rpc_xprt *xprt, struct seq_file *seq) 1825262ca07dSChuck Lever { 1826c8475461SChuck Lever struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt); 1827262ca07dSChuck Lever long idle_time = 0; 1828262ca07dSChuck Lever 1829262ca07dSChuck Lever if (xprt_connected(xprt)) 1830262ca07dSChuck Lever idle_time = (long)(jiffies - xprt->last_used) / HZ; 1831262ca07dSChuck Lever 1832262ca07dSChuck Lever seq_printf(seq, "\txprt:\ttcp %u %lu %lu %lu %ld %lu %lu %lu %Lu %Lu\n", 1833c8475461SChuck Lever transport->port, 1834262ca07dSChuck Lever xprt->stat.bind_count, 1835262ca07dSChuck Lever xprt->stat.connect_count, 1836262ca07dSChuck Lever xprt->stat.connect_time, 1837262ca07dSChuck Lever idle_time, 1838262ca07dSChuck Lever xprt->stat.sends, 1839262ca07dSChuck Lever xprt->stat.recvs, 1840262ca07dSChuck Lever xprt->stat.bad_xids, 1841262ca07dSChuck Lever xprt->stat.req_u, 1842262ca07dSChuck Lever xprt->stat.bklog_u); 1843262ca07dSChuck Lever } 1844262ca07dSChuck Lever 1845262965f5SChuck Lever static struct rpc_xprt_ops xs_udp_ops = { 184643118c29SChuck Lever .set_buffer_size = xs_udp_set_buffer_size, 184712a80469SChuck Lever .reserve_xprt = xprt_reserve_xprt_cong, 184849e9a890SChuck Lever .release_xprt = xprt_release_xprt_cong, 184945160d62SChuck Lever .rpcbind = rpcb_getport_async, 185092200412SChuck Lever .set_port = xs_set_port, 18519903cd1cSChuck Lever .connect = xs_connect, 185202107148SChuck Lever .buf_alloc = rpc_malloc, 185302107148SChuck Lever .buf_free = rpc_free, 1854262965f5SChuck Lever .send_request = xs_udp_send_request, 1855fe3aca29SChuck Lever .set_retrans_timeout = xprt_set_retrans_timeout_rtt, 185646c0ee8bSChuck Lever .timer = xs_udp_timer, 1857a58dd398SChuck Lever .release_request = xprt_release_rqst_cong, 1858262965f5SChuck Lever .close = xs_close, 1859262965f5SChuck Lever .destroy = xs_destroy, 1860262ca07dSChuck Lever .print_stats = xs_udp_print_stats, 1861262965f5SChuck Lever }; 1862262965f5SChuck Lever 1863262965f5SChuck Lever static struct rpc_xprt_ops xs_tcp_ops = { 186412a80469SChuck Lever .reserve_xprt = xprt_reserve_xprt, 1865e0ab53deSTrond Myklebust .release_xprt = xs_tcp_release_xprt, 186645160d62SChuck Lever .rpcbind = rpcb_getport_async, 186792200412SChuck Lever .set_port = xs_set_port, 1868e06799f9STrond Myklebust .connect = xs_tcp_connect, 186902107148SChuck Lever .buf_alloc = rpc_malloc, 187002107148SChuck Lever .buf_free = rpc_free, 1871262965f5SChuck Lever .send_request = xs_tcp_send_request, 1872fe3aca29SChuck Lever .set_retrans_timeout = xprt_set_retrans_timeout_def, 1873e06799f9STrond Myklebust .close = xs_tcp_shutdown, 18749903cd1cSChuck Lever .destroy = xs_destroy, 1875262ca07dSChuck Lever .print_stats = xs_tcp_print_stats, 1876a246b010SChuck Lever }; 1877a246b010SChuck Lever 18783c341b0bS\"Talpey, Thomas\ static struct rpc_xprt *xs_setup_xprt(struct xprt_create *args, 1879bc25571eS\"Talpey, Thomas\ unsigned int slot_table_size) 1880c8541ecdSChuck Lever { 1881c8541ecdSChuck Lever struct rpc_xprt *xprt; 1882ffc2e518SChuck Lever struct sock_xprt *new; 1883c8541ecdSChuck Lever 188496802a09SFrank van Maarseveen if (args->addrlen > sizeof(xprt->addr)) { 1885c8541ecdSChuck Lever dprintk("RPC: xs_setup_xprt: address too large\n"); 1886c8541ecdSChuck Lever return ERR_PTR(-EBADF); 1887c8541ecdSChuck Lever } 1888c8541ecdSChuck Lever 1889ffc2e518SChuck Lever new = kzalloc(sizeof(*new), GFP_KERNEL); 1890ffc2e518SChuck Lever if (new == NULL) { 189146121cf7SChuck Lever dprintk("RPC: xs_setup_xprt: couldn't allocate " 189246121cf7SChuck Lever "rpc_xprt\n"); 1893c8541ecdSChuck Lever return ERR_PTR(-ENOMEM); 1894c8541ecdSChuck Lever } 1895ffc2e518SChuck Lever xprt = &new->xprt; 1896c8541ecdSChuck Lever 1897c8541ecdSChuck Lever xprt->max_reqs = slot_table_size; 1898c8541ecdSChuck Lever xprt->slot = kcalloc(xprt->max_reqs, sizeof(struct rpc_rqst), GFP_KERNEL); 1899c8541ecdSChuck Lever if (xprt->slot == NULL) { 1900c8541ecdSChuck Lever kfree(xprt); 190146121cf7SChuck Lever dprintk("RPC: xs_setup_xprt: couldn't allocate slot " 190246121cf7SChuck Lever "table\n"); 1903c8541ecdSChuck Lever return ERR_PTR(-ENOMEM); 1904c8541ecdSChuck Lever } 1905c8541ecdSChuck Lever 190696802a09SFrank van Maarseveen memcpy(&xprt->addr, args->dstaddr, args->addrlen); 190796802a09SFrank van Maarseveen xprt->addrlen = args->addrlen; 1908d3bc9a1dSFrank van Maarseveen if (args->srcaddr) 1909d3bc9a1dSFrank van Maarseveen memcpy(&new->addr, args->srcaddr, args->addrlen); 1910c8541ecdSChuck Lever 1911c8541ecdSChuck Lever return xprt; 1912c8541ecdSChuck Lever } 1913c8541ecdSChuck Lever 19142881ae74STrond Myklebust static const struct rpc_timeout xs_udp_default_timeout = { 19152881ae74STrond Myklebust .to_initval = 5 * HZ, 19162881ae74STrond Myklebust .to_maxval = 30 * HZ, 19172881ae74STrond Myklebust .to_increment = 5 * HZ, 19182881ae74STrond Myklebust .to_retries = 5, 19192881ae74STrond Myklebust }; 19202881ae74STrond Myklebust 19219903cd1cSChuck Lever /** 19229903cd1cSChuck Lever * xs_setup_udp - Set up transport to use a UDP socket 192396802a09SFrank van Maarseveen * @args: rpc transport creation arguments 19249903cd1cSChuck Lever * 19259903cd1cSChuck Lever */ 1926483066d6SAdrian Bunk static struct rpc_xprt *xs_setup_udp(struct xprt_create *args) 1927a246b010SChuck Lever { 19288f9d5b1aSChuck Lever struct sockaddr *addr = args->dstaddr; 1929c8541ecdSChuck Lever struct rpc_xprt *xprt; 1930c8475461SChuck Lever struct sock_xprt *transport; 1931a246b010SChuck Lever 193296802a09SFrank van Maarseveen xprt = xs_setup_xprt(args, xprt_udp_slot_table_entries); 1933c8541ecdSChuck Lever if (IS_ERR(xprt)) 1934c8541ecdSChuck Lever return xprt; 1935c8475461SChuck Lever transport = container_of(xprt, struct sock_xprt, xprt); 1936a246b010SChuck Lever 1937ec739ef0SChuck Lever xprt->prot = IPPROTO_UDP; 1938808012fbSChuck Lever xprt->tsh_size = 0; 1939a246b010SChuck Lever /* XXX: header size can vary due to auth type, IPv6, etc. */ 1940a246b010SChuck Lever xprt->max_payload = (1U << 16) - (MAX_HEADER << 3); 1941a246b010SChuck Lever 194203bf4b70SChuck Lever xprt->bind_timeout = XS_BIND_TO; 194303bf4b70SChuck Lever xprt->connect_timeout = XS_UDP_CONN_TO; 194403bf4b70SChuck Lever xprt->reestablish_timeout = XS_UDP_REEST_TO; 194503bf4b70SChuck Lever xprt->idle_timeout = XS_IDLE_DISC_TO; 1946a246b010SChuck Lever 1947262965f5SChuck Lever xprt->ops = &xs_udp_ops; 1948a246b010SChuck Lever 1949ba7392bbSTrond Myklebust xprt->timeout = &xs_udp_default_timeout; 1950a246b010SChuck Lever 19518f9d5b1aSChuck Lever switch (addr->sa_family) { 19528f9d5b1aSChuck Lever case AF_INET: 19538f9d5b1aSChuck Lever if (((struct sockaddr_in *)addr)->sin_port != htons(0)) 19548f9d5b1aSChuck Lever xprt_set_bound(xprt); 19558f9d5b1aSChuck Lever 19568f9d5b1aSChuck Lever INIT_DELAYED_WORK(&transport->connect_worker, 19578f9d5b1aSChuck Lever xs_udp_connect_worker4); 1958b454ae90SChuck Lever xs_format_ipv4_peer_addresses(xprt, "udp", RPCBIND_NETID_UDP); 19598f9d5b1aSChuck Lever break; 19608f9d5b1aSChuck Lever case AF_INET6: 19618f9d5b1aSChuck Lever if (((struct sockaddr_in6 *)addr)->sin6_port != htons(0)) 19628f9d5b1aSChuck Lever xprt_set_bound(xprt); 19638f9d5b1aSChuck Lever 19648f9d5b1aSChuck Lever INIT_DELAYED_WORK(&transport->connect_worker, 19658f9d5b1aSChuck Lever xs_udp_connect_worker6); 1966b454ae90SChuck Lever xs_format_ipv6_peer_addresses(xprt, "udp", RPCBIND_NETID_UDP6); 19678f9d5b1aSChuck Lever break; 19688f9d5b1aSChuck Lever default: 19698f9d5b1aSChuck Lever kfree(xprt); 19708f9d5b1aSChuck Lever return ERR_PTR(-EAFNOSUPPORT); 19718f9d5b1aSChuck Lever } 19728f9d5b1aSChuck Lever 1973edb267a6SChuck Lever dprintk("RPC: set up transport to address %s\n", 19747559c7a2SChuck Lever xprt->address_strings[RPC_DISPLAY_ALL]); 1975edb267a6SChuck Lever 1976bc25571eS\"Talpey, Thomas\ if (try_module_get(THIS_MODULE)) 1977c8541ecdSChuck Lever return xprt; 1978bc25571eS\"Talpey, Thomas\ 1979bc25571eS\"Talpey, Thomas\ kfree(xprt->slot); 1980bc25571eS\"Talpey, Thomas\ kfree(xprt); 1981bc25571eS\"Talpey, Thomas\ return ERR_PTR(-EINVAL); 1982a246b010SChuck Lever } 1983a246b010SChuck Lever 19842881ae74STrond Myklebust static const struct rpc_timeout xs_tcp_default_timeout = { 19852881ae74STrond Myklebust .to_initval = 60 * HZ, 19862881ae74STrond Myklebust .to_maxval = 60 * HZ, 19872881ae74STrond Myklebust .to_retries = 2, 19882881ae74STrond Myklebust }; 19892881ae74STrond Myklebust 19909903cd1cSChuck Lever /** 19919903cd1cSChuck Lever * xs_setup_tcp - Set up transport to use a TCP socket 199296802a09SFrank van Maarseveen * @args: rpc transport creation arguments 19939903cd1cSChuck Lever * 19949903cd1cSChuck Lever */ 1995483066d6SAdrian Bunk static struct rpc_xprt *xs_setup_tcp(struct xprt_create *args) 1996a246b010SChuck Lever { 19978f9d5b1aSChuck Lever struct sockaddr *addr = args->dstaddr; 1998c8541ecdSChuck Lever struct rpc_xprt *xprt; 1999c8475461SChuck Lever struct sock_xprt *transport; 2000a246b010SChuck Lever 200196802a09SFrank van Maarseveen xprt = xs_setup_xprt(args, xprt_tcp_slot_table_entries); 2002c8541ecdSChuck Lever if (IS_ERR(xprt)) 2003c8541ecdSChuck Lever return xprt; 2004c8475461SChuck Lever transport = container_of(xprt, struct sock_xprt, xprt); 2005a246b010SChuck Lever 2006ec739ef0SChuck Lever xprt->prot = IPPROTO_TCP; 2007808012fbSChuck Lever xprt->tsh_size = sizeof(rpc_fraghdr) / sizeof(u32); 2008808012fbSChuck Lever xprt->max_payload = RPC_MAX_FRAGMENT_SIZE; 2009a246b010SChuck Lever 201003bf4b70SChuck Lever xprt->bind_timeout = XS_BIND_TO; 201103bf4b70SChuck Lever xprt->connect_timeout = XS_TCP_CONN_TO; 201203bf4b70SChuck Lever xprt->reestablish_timeout = XS_TCP_INIT_REEST_TO; 201303bf4b70SChuck Lever xprt->idle_timeout = XS_IDLE_DISC_TO; 2014a246b010SChuck Lever 2015262965f5SChuck Lever xprt->ops = &xs_tcp_ops; 2016ba7392bbSTrond Myklebust xprt->timeout = &xs_tcp_default_timeout; 2017a246b010SChuck Lever 20188f9d5b1aSChuck Lever switch (addr->sa_family) { 20198f9d5b1aSChuck Lever case AF_INET: 20208f9d5b1aSChuck Lever if (((struct sockaddr_in *)addr)->sin_port != htons(0)) 20218f9d5b1aSChuck Lever xprt_set_bound(xprt); 20228f9d5b1aSChuck Lever 20238f9d5b1aSChuck Lever INIT_DELAYED_WORK(&transport->connect_worker, xs_tcp_connect_worker4); 2024b454ae90SChuck Lever xs_format_ipv4_peer_addresses(xprt, "tcp", RPCBIND_NETID_TCP); 20258f9d5b1aSChuck Lever break; 20268f9d5b1aSChuck Lever case AF_INET6: 20278f9d5b1aSChuck Lever if (((struct sockaddr_in6 *)addr)->sin6_port != htons(0)) 20288f9d5b1aSChuck Lever xprt_set_bound(xprt); 20298f9d5b1aSChuck Lever 20308f9d5b1aSChuck Lever INIT_DELAYED_WORK(&transport->connect_worker, xs_tcp_connect_worker6); 2031b454ae90SChuck Lever xs_format_ipv6_peer_addresses(xprt, "tcp", RPCBIND_NETID_TCP6); 20328f9d5b1aSChuck Lever break; 20338f9d5b1aSChuck Lever default: 20348f9d5b1aSChuck Lever kfree(xprt); 20358f9d5b1aSChuck Lever return ERR_PTR(-EAFNOSUPPORT); 20368f9d5b1aSChuck Lever } 20378f9d5b1aSChuck Lever 2038edb267a6SChuck Lever dprintk("RPC: set up transport to address %s\n", 20397559c7a2SChuck Lever xprt->address_strings[RPC_DISPLAY_ALL]); 2040edb267a6SChuck Lever 2041bc25571eS\"Talpey, Thomas\ if (try_module_get(THIS_MODULE)) 2042c8541ecdSChuck Lever return xprt; 2043bc25571eS\"Talpey, Thomas\ 2044bc25571eS\"Talpey, Thomas\ kfree(xprt->slot); 2045bc25571eS\"Talpey, Thomas\ kfree(xprt); 2046bc25571eS\"Talpey, Thomas\ return ERR_PTR(-EINVAL); 2047a246b010SChuck Lever } 2048282b32e1SChuck Lever 2049bc25571eS\"Talpey, Thomas\ static struct xprt_class xs_udp_transport = { 2050bc25571eS\"Talpey, Thomas\ .list = LIST_HEAD_INIT(xs_udp_transport.list), 2051bc25571eS\"Talpey, Thomas\ .name = "udp", 2052bc25571eS\"Talpey, Thomas\ .owner = THIS_MODULE, 20534fa016ebS\"Talpey, Thomas\ .ident = IPPROTO_UDP, 2054bc25571eS\"Talpey, Thomas\ .setup = xs_setup_udp, 2055bc25571eS\"Talpey, Thomas\ }; 2056bc25571eS\"Talpey, Thomas\ 2057bc25571eS\"Talpey, Thomas\ static struct xprt_class xs_tcp_transport = { 2058bc25571eS\"Talpey, Thomas\ .list = LIST_HEAD_INIT(xs_tcp_transport.list), 2059bc25571eS\"Talpey, Thomas\ .name = "tcp", 2060bc25571eS\"Talpey, Thomas\ .owner = THIS_MODULE, 20614fa016ebS\"Talpey, Thomas\ .ident = IPPROTO_TCP, 2062bc25571eS\"Talpey, Thomas\ .setup = xs_setup_tcp, 2063bc25571eS\"Talpey, Thomas\ }; 2064bc25571eS\"Talpey, Thomas\ 2065282b32e1SChuck Lever /** 2066bc25571eS\"Talpey, Thomas\ * init_socket_xprt - set up xprtsock's sysctls, register with RPC client 2067282b32e1SChuck Lever * 2068282b32e1SChuck Lever */ 2069282b32e1SChuck Lever int init_socket_xprt(void) 2070282b32e1SChuck Lever { 2071fbf76683SChuck Lever #ifdef RPC_DEBUG 20722b1bec5fSEric W. Biederman if (!sunrpc_table_header) 20730b4d4147SEric W. Biederman sunrpc_table_header = register_sysctl_table(sunrpc_table); 2074fbf76683SChuck Lever #endif 2075fbf76683SChuck Lever 2076bc25571eS\"Talpey, Thomas\ xprt_register_transport(&xs_udp_transport); 2077bc25571eS\"Talpey, Thomas\ xprt_register_transport(&xs_tcp_transport); 2078bc25571eS\"Talpey, Thomas\ 2079282b32e1SChuck Lever return 0; 2080282b32e1SChuck Lever } 2081282b32e1SChuck Lever 2082282b32e1SChuck Lever /** 2083bc25571eS\"Talpey, Thomas\ * cleanup_socket_xprt - remove xprtsock's sysctls, unregister 2084282b32e1SChuck Lever * 2085282b32e1SChuck Lever */ 2086282b32e1SChuck Lever void cleanup_socket_xprt(void) 2087282b32e1SChuck Lever { 2088fbf76683SChuck Lever #ifdef RPC_DEBUG 2089fbf76683SChuck Lever if (sunrpc_table_header) { 2090fbf76683SChuck Lever unregister_sysctl_table(sunrpc_table_header); 2091fbf76683SChuck Lever sunrpc_table_header = NULL; 2092fbf76683SChuck Lever } 2093fbf76683SChuck Lever #endif 2094bc25571eS\"Talpey, Thomas\ 2095bc25571eS\"Talpey, Thomas\ xprt_unregister_transport(&xs_udp_transport); 2096bc25571eS\"Talpey, Thomas\ xprt_unregister_transport(&xs_tcp_transport); 2097282b32e1SChuck Lever } 2098