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> 16a246b010SChuck Lever */ 17a246b010SChuck Lever 18a246b010SChuck Lever #include <linux/types.h> 19a246b010SChuck Lever #include <linux/slab.h> 20a246b010SChuck Lever #include <linux/capability.h> 21a246b010SChuck Lever #include <linux/sched.h> 22a246b010SChuck Lever #include <linux/pagemap.h> 23a246b010SChuck Lever #include <linux/errno.h> 24a246b010SChuck Lever #include <linux/socket.h> 25a246b010SChuck Lever #include <linux/in.h> 26a246b010SChuck Lever #include <linux/net.h> 27a246b010SChuck Lever #include <linux/mm.h> 28a246b010SChuck Lever #include <linux/udp.h> 29a246b010SChuck Lever #include <linux/tcp.h> 30a246b010SChuck Lever #include <linux/sunrpc/clnt.h> 3102107148SChuck Lever #include <linux/sunrpc/sched.h> 32a246b010SChuck Lever #include <linux/file.h> 33a246b010SChuck Lever 34a246b010SChuck Lever #include <net/sock.h> 35a246b010SChuck Lever #include <net/checksum.h> 36a246b010SChuck Lever #include <net/udp.h> 37a246b010SChuck Lever #include <net/tcp.h> 38a246b010SChuck Lever 399903cd1cSChuck Lever /* 40c556b754SChuck Lever * xprtsock tunables 41c556b754SChuck Lever */ 42c556b754SChuck Lever unsigned int xprt_udp_slot_table_entries = RPC_DEF_SLOT_TABLE; 43c556b754SChuck Lever unsigned int xprt_tcp_slot_table_entries = RPC_DEF_SLOT_TABLE; 44c556b754SChuck Lever 45c556b754SChuck Lever unsigned int xprt_min_resvport = RPC_DEF_MIN_RESVPORT; 46c556b754SChuck Lever unsigned int xprt_max_resvport = RPC_DEF_MAX_RESVPORT; 47c556b754SChuck Lever 48c556b754SChuck Lever /* 49262965f5SChuck Lever * How many times to try sending a request on a socket before waiting 50262965f5SChuck Lever * for the socket buffer to clear. 51262965f5SChuck Lever */ 52262965f5SChuck Lever #define XS_SENDMSG_RETRY (10U) 53262965f5SChuck Lever 5403bf4b70SChuck Lever /* 5503bf4b70SChuck Lever * Time out for an RPC UDP socket connect. UDP socket connects are 5603bf4b70SChuck Lever * synchronous, but we set a timeout anyway in case of resource 5703bf4b70SChuck Lever * exhaustion on the local host. 5803bf4b70SChuck Lever */ 5903bf4b70SChuck Lever #define XS_UDP_CONN_TO (5U * HZ) 6003bf4b70SChuck Lever 6103bf4b70SChuck Lever /* 6203bf4b70SChuck Lever * Wait duration for an RPC TCP connection to be established. Solaris 6303bf4b70SChuck Lever * NFS over TCP uses 60 seconds, for example, which is in line with how 6403bf4b70SChuck Lever * long a server takes to reboot. 6503bf4b70SChuck Lever */ 6603bf4b70SChuck Lever #define XS_TCP_CONN_TO (60U * HZ) 6703bf4b70SChuck Lever 6803bf4b70SChuck Lever /* 6903bf4b70SChuck Lever * Wait duration for a reply from the RPC portmapper. 7003bf4b70SChuck Lever */ 7103bf4b70SChuck Lever #define XS_BIND_TO (60U * HZ) 7203bf4b70SChuck Lever 7303bf4b70SChuck Lever /* 7403bf4b70SChuck Lever * Delay if a UDP socket connect error occurs. This is most likely some 7503bf4b70SChuck Lever * kind of resource problem on the local host. 7603bf4b70SChuck Lever */ 7703bf4b70SChuck Lever #define XS_UDP_REEST_TO (2U * HZ) 7803bf4b70SChuck Lever 7903bf4b70SChuck Lever /* 8003bf4b70SChuck Lever * The reestablish timeout allows clients to delay for a bit before attempting 8103bf4b70SChuck Lever * to reconnect to a server that just dropped our connection. 8203bf4b70SChuck Lever * 8303bf4b70SChuck Lever * We implement an exponential backoff when trying to reestablish a TCP 8403bf4b70SChuck Lever * transport connection with the server. Some servers like to drop a TCP 8503bf4b70SChuck Lever * connection when they are overworked, so we start with a short timeout and 8603bf4b70SChuck Lever * increase over time if the server is down or not responding. 8703bf4b70SChuck Lever */ 8803bf4b70SChuck Lever #define XS_TCP_INIT_REEST_TO (3U * HZ) 8903bf4b70SChuck Lever #define XS_TCP_MAX_REEST_TO (5U * 60 * HZ) 9003bf4b70SChuck Lever 9103bf4b70SChuck Lever /* 9203bf4b70SChuck Lever * TCP idle timeout; client drops the transport socket if it is idle 9303bf4b70SChuck Lever * for this long. Note that we also timeout UDP sockets to prevent 9403bf4b70SChuck Lever * holding port numbers when there is no RPC traffic. 9503bf4b70SChuck Lever */ 9603bf4b70SChuck Lever #define XS_IDLE_DISC_TO (5U * 60 * HZ) 9703bf4b70SChuck Lever 98a246b010SChuck Lever #ifdef RPC_DEBUG 99a246b010SChuck Lever # undef RPC_DEBUG_DATA 1009903cd1cSChuck Lever # define RPCDBG_FACILITY RPCDBG_TRANS 101a246b010SChuck Lever #endif 102a246b010SChuck Lever 103a246b010SChuck Lever #ifdef RPC_DEBUG_DATA 1049903cd1cSChuck Lever static void xs_pktdump(char *msg, u32 *packet, unsigned int count) 105a246b010SChuck Lever { 106a246b010SChuck Lever u8 *buf = (u8 *) packet; 107a246b010SChuck Lever int j; 108a246b010SChuck Lever 109a246b010SChuck Lever dprintk("RPC: %s\n", msg); 110a246b010SChuck Lever for (j = 0; j < count && j < 128; j += 4) { 111a246b010SChuck Lever if (!(j & 31)) { 112a246b010SChuck Lever if (j) 113a246b010SChuck Lever dprintk("\n"); 114a246b010SChuck Lever dprintk("0x%04x ", j); 115a246b010SChuck Lever } 116a246b010SChuck Lever dprintk("%02x%02x%02x%02x ", 117a246b010SChuck Lever buf[j], buf[j+1], buf[j+2], buf[j+3]); 118a246b010SChuck Lever } 119a246b010SChuck Lever dprintk("\n"); 120a246b010SChuck Lever } 121a246b010SChuck Lever #else 1229903cd1cSChuck Lever static inline void xs_pktdump(char *msg, u32 *packet, unsigned int count) 123a246b010SChuck Lever { 124a246b010SChuck Lever /* NOP */ 125a246b010SChuck Lever } 126a246b010SChuck Lever #endif 127a246b010SChuck Lever 128edb267a6SChuck Lever static void xs_format_peer_addresses(struct rpc_xprt *xprt) 129edb267a6SChuck Lever { 130edb267a6SChuck Lever struct sockaddr_in *addr = (struct sockaddr_in *) &xprt->addr; 131edb267a6SChuck Lever char *buf; 132edb267a6SChuck Lever 133edb267a6SChuck Lever buf = kzalloc(20, GFP_KERNEL); 134edb267a6SChuck Lever if (buf) { 135edb267a6SChuck Lever snprintf(buf, 20, "%u.%u.%u.%u", 136edb267a6SChuck Lever NIPQUAD(addr->sin_addr.s_addr)); 137edb267a6SChuck Lever } 138edb267a6SChuck Lever xprt->address_strings[RPC_DISPLAY_ADDR] = buf; 139edb267a6SChuck Lever 140edb267a6SChuck Lever buf = kzalloc(8, GFP_KERNEL); 141edb267a6SChuck Lever if (buf) { 142edb267a6SChuck Lever snprintf(buf, 8, "%u", 143edb267a6SChuck Lever ntohs(addr->sin_port)); 144edb267a6SChuck Lever } 145edb267a6SChuck Lever xprt->address_strings[RPC_DISPLAY_PORT] = buf; 146edb267a6SChuck Lever 147edb267a6SChuck Lever if (xprt->prot == IPPROTO_UDP) 148edb267a6SChuck Lever xprt->address_strings[RPC_DISPLAY_PROTO] = "udp"; 149edb267a6SChuck Lever else 150edb267a6SChuck Lever xprt->address_strings[RPC_DISPLAY_PROTO] = "tcp"; 151edb267a6SChuck Lever 152edb267a6SChuck Lever buf = kzalloc(48, GFP_KERNEL); 153edb267a6SChuck Lever if (buf) { 154edb267a6SChuck Lever snprintf(buf, 48, "addr=%u.%u.%u.%u port=%u proto=%s", 155edb267a6SChuck Lever NIPQUAD(addr->sin_addr.s_addr), 156edb267a6SChuck Lever ntohs(addr->sin_port), 157edb267a6SChuck Lever xprt->prot == IPPROTO_UDP ? "udp" : "tcp"); 158edb267a6SChuck Lever } 159edb267a6SChuck Lever xprt->address_strings[RPC_DISPLAY_ALL] = buf; 160edb267a6SChuck Lever } 161edb267a6SChuck Lever 162edb267a6SChuck Lever static void xs_free_peer_addresses(struct rpc_xprt *xprt) 163edb267a6SChuck Lever { 164edb267a6SChuck Lever kfree(xprt->address_strings[RPC_DISPLAY_ADDR]); 165edb267a6SChuck Lever kfree(xprt->address_strings[RPC_DISPLAY_PORT]); 166edb267a6SChuck Lever kfree(xprt->address_strings[RPC_DISPLAY_ALL]); 167edb267a6SChuck Lever } 168edb267a6SChuck Lever 169b4b5cc85SChuck Lever #define XS_SENDMSG_FLAGS (MSG_DONTWAIT | MSG_NOSIGNAL) 170b4b5cc85SChuck Lever 171b4b5cc85SChuck Lever static inline int xs_send_head(struct socket *sock, struct sockaddr *addr, int addrlen, struct xdr_buf *xdr, unsigned int base, unsigned int len) 172b4b5cc85SChuck Lever { 173b4b5cc85SChuck Lever struct kvec iov = { 174b4b5cc85SChuck Lever .iov_base = xdr->head[0].iov_base + base, 175b4b5cc85SChuck Lever .iov_len = len - base, 176b4b5cc85SChuck Lever }; 177b4b5cc85SChuck Lever struct msghdr msg = { 178b4b5cc85SChuck Lever .msg_name = addr, 179b4b5cc85SChuck Lever .msg_namelen = addrlen, 180b4b5cc85SChuck Lever .msg_flags = XS_SENDMSG_FLAGS, 181b4b5cc85SChuck Lever }; 182b4b5cc85SChuck Lever 183b4b5cc85SChuck Lever if (xdr->len > len) 184b4b5cc85SChuck Lever msg.msg_flags |= MSG_MORE; 185b4b5cc85SChuck Lever 186b4b5cc85SChuck Lever if (likely(iov.iov_len)) 187b4b5cc85SChuck Lever return kernel_sendmsg(sock, &msg, &iov, 1, iov.iov_len); 188b4b5cc85SChuck Lever return kernel_sendmsg(sock, &msg, NULL, 0, 0); 189b4b5cc85SChuck Lever } 190b4b5cc85SChuck Lever 191b4b5cc85SChuck Lever static int xs_send_tail(struct socket *sock, struct xdr_buf *xdr, unsigned int base, unsigned int len) 192b4b5cc85SChuck Lever { 193b4b5cc85SChuck Lever struct kvec iov = { 194b4b5cc85SChuck Lever .iov_base = xdr->tail[0].iov_base + base, 195b4b5cc85SChuck Lever .iov_len = len - base, 196b4b5cc85SChuck Lever }; 197b4b5cc85SChuck Lever struct msghdr msg = { 198b4b5cc85SChuck Lever .msg_flags = XS_SENDMSG_FLAGS, 199b4b5cc85SChuck Lever }; 200b4b5cc85SChuck Lever 201b4b5cc85SChuck Lever return kernel_sendmsg(sock, &msg, &iov, 1, iov.iov_len); 202b4b5cc85SChuck Lever } 203b4b5cc85SChuck Lever 2049903cd1cSChuck Lever /** 2059903cd1cSChuck Lever * xs_sendpages - write pages directly to a socket 2069903cd1cSChuck Lever * @sock: socket to send on 2079903cd1cSChuck Lever * @addr: UDP only -- address of destination 2089903cd1cSChuck Lever * @addrlen: UDP only -- length of destination address 2099903cd1cSChuck Lever * @xdr: buffer containing this request 2109903cd1cSChuck Lever * @base: starting position in the buffer 2119903cd1cSChuck Lever * 212a246b010SChuck Lever */ 213262965f5SChuck Lever static inline int xs_sendpages(struct socket *sock, struct sockaddr *addr, int addrlen, struct xdr_buf *xdr, unsigned int base) 214a246b010SChuck Lever { 215a246b010SChuck Lever struct page **ppage = xdr->pages; 216a246b010SChuck Lever unsigned int len, pglen = xdr->page_len; 217a246b010SChuck Lever int err, ret = 0; 218a246b010SChuck Lever ssize_t (*sendpage)(struct socket *, struct page *, int, size_t, int); 219a246b010SChuck Lever 220262965f5SChuck Lever if (unlikely(!sock)) 221262965f5SChuck Lever return -ENOTCONN; 222262965f5SChuck Lever 223262965f5SChuck Lever clear_bit(SOCK_ASYNC_NOSPACE, &sock->flags); 224262965f5SChuck Lever 225a246b010SChuck Lever len = xdr->head[0].iov_len; 226a246b010SChuck Lever if (base < len || (addr != NULL && base == 0)) { 227b4b5cc85SChuck Lever err = xs_send_head(sock, addr, addrlen, xdr, base, len); 228a246b010SChuck Lever if (ret == 0) 229a246b010SChuck Lever ret = err; 230a246b010SChuck Lever else if (err > 0) 231a246b010SChuck Lever ret += err; 232b4b5cc85SChuck Lever if (err != (len - base)) 233a246b010SChuck Lever goto out; 234a246b010SChuck Lever base = 0; 235a246b010SChuck Lever } else 236a246b010SChuck Lever base -= len; 237a246b010SChuck Lever 238b4b5cc85SChuck Lever if (unlikely(pglen == 0)) 239a246b010SChuck Lever goto copy_tail; 240b4b5cc85SChuck Lever if (unlikely(base >= pglen)) { 241a246b010SChuck Lever base -= pglen; 242a246b010SChuck Lever goto copy_tail; 243a246b010SChuck Lever } 244a246b010SChuck Lever if (base || xdr->page_base) { 245a246b010SChuck Lever pglen -= base; 246a246b010SChuck Lever base += xdr->page_base; 247a246b010SChuck Lever ppage += base >> PAGE_CACHE_SHIFT; 248a246b010SChuck Lever base &= ~PAGE_CACHE_MASK; 249a246b010SChuck Lever } 250a246b010SChuck Lever 251a246b010SChuck Lever sendpage = sock->ops->sendpage ? : sock_no_sendpage; 252a246b010SChuck Lever do { 253b4b5cc85SChuck Lever int flags = XS_SENDMSG_FLAGS; 254a246b010SChuck Lever 255a246b010SChuck Lever len = PAGE_CACHE_SIZE; 256a246b010SChuck Lever if (base) 257a246b010SChuck Lever len -= base; 258a246b010SChuck Lever if (pglen < len) 259a246b010SChuck Lever len = pglen; 260a246b010SChuck Lever 261a246b010SChuck Lever if (pglen != len || xdr->tail[0].iov_len != 0) 262a246b010SChuck Lever flags |= MSG_MORE; 263a246b010SChuck Lever 264a246b010SChuck Lever /* Hmm... We might be dealing with highmem pages */ 265a246b010SChuck Lever if (PageHighMem(*ppage)) 266a246b010SChuck Lever sendpage = sock_no_sendpage; 267a246b010SChuck Lever err = sendpage(sock, *ppage, base, len, flags); 268a246b010SChuck Lever if (ret == 0) 269a246b010SChuck Lever ret = err; 270a246b010SChuck Lever else if (err > 0) 271a246b010SChuck Lever ret += err; 272a246b010SChuck Lever if (err != len) 273a246b010SChuck Lever goto out; 274a246b010SChuck Lever base = 0; 275a246b010SChuck Lever ppage++; 276a246b010SChuck Lever } while ((pglen -= len) != 0); 277a246b010SChuck Lever copy_tail: 278a246b010SChuck Lever len = xdr->tail[0].iov_len; 279a246b010SChuck Lever if (base < len) { 280b4b5cc85SChuck Lever err = xs_send_tail(sock, xdr, base, len); 281a246b010SChuck Lever if (ret == 0) 282a246b010SChuck Lever ret = err; 283a246b010SChuck Lever else if (err > 0) 284a246b010SChuck Lever ret += err; 285a246b010SChuck Lever } 286a246b010SChuck Lever out: 287a246b010SChuck Lever return ret; 288a246b010SChuck Lever } 289a246b010SChuck Lever 2909903cd1cSChuck Lever /** 291262965f5SChuck Lever * xs_nospace - place task on wait queue if transmit was incomplete 292262965f5SChuck Lever * @task: task to put to sleep 2939903cd1cSChuck Lever * 294a246b010SChuck Lever */ 295262965f5SChuck Lever static void xs_nospace(struct rpc_task *task) 296a246b010SChuck Lever { 297262965f5SChuck Lever struct rpc_rqst *req = task->tk_rqstp; 298262965f5SChuck Lever struct rpc_xprt *xprt = req->rq_xprt; 299a246b010SChuck Lever 300262965f5SChuck Lever dprintk("RPC: %4d xmit incomplete (%u left of %u)\n", 301262965f5SChuck Lever task->tk_pid, req->rq_slen - req->rq_bytes_sent, 302262965f5SChuck Lever req->rq_slen); 303a246b010SChuck Lever 304262965f5SChuck Lever if (test_bit(SOCK_ASYNC_NOSPACE, &xprt->sock->flags)) { 305262965f5SChuck Lever /* Protect against races with write_space */ 306262965f5SChuck Lever spin_lock_bh(&xprt->transport_lock); 307a246b010SChuck Lever 308262965f5SChuck Lever /* Don't race with disconnect */ 309262965f5SChuck Lever if (!xprt_connected(xprt)) 310262965f5SChuck Lever task->tk_status = -ENOTCONN; 311262965f5SChuck Lever else if (test_bit(SOCK_NOSPACE, &xprt->sock->flags)) 312262965f5SChuck Lever xprt_wait_for_buffer_space(task); 313a246b010SChuck Lever 314262965f5SChuck Lever spin_unlock_bh(&xprt->transport_lock); 315262965f5SChuck Lever } else 316262965f5SChuck Lever /* Keep holding the socket if it is blocked */ 317262965f5SChuck Lever rpc_delay(task, HZ>>4); 318a246b010SChuck Lever } 319a246b010SChuck Lever 3209903cd1cSChuck Lever /** 321262965f5SChuck Lever * xs_udp_send_request - write an RPC request to a UDP socket 3229903cd1cSChuck Lever * @task: address of RPC task that manages the state of an RPC request 3239903cd1cSChuck Lever * 3249903cd1cSChuck Lever * Return values: 3259903cd1cSChuck Lever * 0: The request has been sent 3269903cd1cSChuck Lever * EAGAIN: The socket was blocked, please call again later to 3279903cd1cSChuck Lever * complete the request 328262965f5SChuck Lever * ENOTCONN: Caller needs to invoke connect logic then call again 3299903cd1cSChuck Lever * other: Some other error occured, the request was not sent 3309903cd1cSChuck Lever */ 331262965f5SChuck Lever static int xs_udp_send_request(struct rpc_task *task) 332a246b010SChuck Lever { 333a246b010SChuck Lever struct rpc_rqst *req = task->tk_rqstp; 334a246b010SChuck Lever struct rpc_xprt *xprt = req->rq_xprt; 335262965f5SChuck Lever struct xdr_buf *xdr = &req->rq_snd_buf; 336262965f5SChuck Lever int status; 337262965f5SChuck Lever 338262965f5SChuck Lever xs_pktdump("packet data:", 339262965f5SChuck Lever req->rq_svec->iov_base, 340262965f5SChuck Lever req->rq_svec->iov_len); 341262965f5SChuck Lever 342262965f5SChuck Lever req->rq_xtime = jiffies; 343262965f5SChuck Lever status = xs_sendpages(xprt->sock, (struct sockaddr *) &xprt->addr, 344*c4efcb1dSChuck Lever xprt->addrlen, xdr, req->rq_bytes_sent); 345262965f5SChuck Lever 346262965f5SChuck Lever dprintk("RPC: xs_udp_send_request(%u) = %d\n", 347262965f5SChuck Lever xdr->len - req->rq_bytes_sent, status); 348262965f5SChuck Lever 349262965f5SChuck Lever if (likely(status >= (int) req->rq_slen)) 350262965f5SChuck Lever return 0; 351262965f5SChuck Lever 352262965f5SChuck Lever /* Still some bytes left; set up for a retry later. */ 353262965f5SChuck Lever if (status > 0) 354262965f5SChuck Lever status = -EAGAIN; 355262965f5SChuck Lever 356262965f5SChuck Lever switch (status) { 357262965f5SChuck Lever case -ENETUNREACH: 358262965f5SChuck Lever case -EPIPE: 359262965f5SChuck Lever case -ECONNREFUSED: 360262965f5SChuck Lever /* When the server has died, an ICMP port unreachable message 361262965f5SChuck Lever * prompts ECONNREFUSED. */ 362262965f5SChuck Lever break; 363262965f5SChuck Lever case -EAGAIN: 364262965f5SChuck Lever xs_nospace(task); 365262965f5SChuck Lever break; 366262965f5SChuck Lever default: 367262965f5SChuck Lever dprintk("RPC: sendmsg returned unrecognized error %d\n", 368262965f5SChuck Lever -status); 369262965f5SChuck Lever break; 370262965f5SChuck Lever } 371262965f5SChuck Lever 372262965f5SChuck Lever return status; 373262965f5SChuck Lever } 374262965f5SChuck Lever 375808012fbSChuck Lever static inline void xs_encode_tcp_record_marker(struct xdr_buf *buf) 376808012fbSChuck Lever { 377808012fbSChuck Lever u32 reclen = buf->len - sizeof(rpc_fraghdr); 378808012fbSChuck Lever rpc_fraghdr *base = buf->head[0].iov_base; 379808012fbSChuck Lever *base = htonl(RPC_LAST_STREAM_FRAGMENT | reclen); 380808012fbSChuck Lever } 381808012fbSChuck Lever 382262965f5SChuck Lever /** 383262965f5SChuck Lever * xs_tcp_send_request - write an RPC request to a TCP socket 384262965f5SChuck Lever * @task: address of RPC task that manages the state of an RPC request 385262965f5SChuck Lever * 386262965f5SChuck Lever * Return values: 387262965f5SChuck Lever * 0: The request has been sent 388262965f5SChuck Lever * EAGAIN: The socket was blocked, please call again later to 389262965f5SChuck Lever * complete the request 390262965f5SChuck Lever * ENOTCONN: Caller needs to invoke connect logic then call again 391262965f5SChuck Lever * other: Some other error occured, the request was not sent 392262965f5SChuck Lever * 393262965f5SChuck Lever * XXX: In the case of soft timeouts, should we eventually give up 394262965f5SChuck Lever * if sendmsg is not able to make progress? 395262965f5SChuck Lever */ 396262965f5SChuck Lever static int xs_tcp_send_request(struct rpc_task *task) 397262965f5SChuck Lever { 398262965f5SChuck Lever struct rpc_rqst *req = task->tk_rqstp; 399262965f5SChuck Lever struct rpc_xprt *xprt = req->rq_xprt; 400262965f5SChuck Lever struct xdr_buf *xdr = &req->rq_snd_buf; 401a246b010SChuck Lever int status, retry = 0; 402a246b010SChuck Lever 403808012fbSChuck Lever xs_encode_tcp_record_marker(&req->rq_snd_buf); 404262965f5SChuck Lever 405262965f5SChuck Lever xs_pktdump("packet data:", 406262965f5SChuck Lever req->rq_svec->iov_base, 407262965f5SChuck Lever req->rq_svec->iov_len); 408a246b010SChuck Lever 409a246b010SChuck Lever /* Continue transmitting the packet/record. We must be careful 410a246b010SChuck Lever * to cope with writespace callbacks arriving _after_ we have 411262965f5SChuck Lever * called sendmsg(). */ 412a246b010SChuck Lever while (1) { 413a246b010SChuck Lever req->rq_xtime = jiffies; 414262965f5SChuck Lever status = xs_sendpages(xprt->sock, NULL, 0, xdr, 415262965f5SChuck Lever req->rq_bytes_sent); 416a246b010SChuck Lever 417262965f5SChuck Lever dprintk("RPC: xs_tcp_send_request(%u) = %d\n", 418262965f5SChuck Lever xdr->len - req->rq_bytes_sent, status); 419262965f5SChuck Lever 420262965f5SChuck Lever if (unlikely(status < 0)) 421a246b010SChuck Lever break; 422a246b010SChuck Lever 423a246b010SChuck Lever /* If we've sent the entire packet, immediately 424a246b010SChuck Lever * reset the count of bytes sent. */ 425262965f5SChuck Lever req->rq_bytes_sent += status; 426ef759a2eSChuck Lever task->tk_bytes_sent += status; 427262965f5SChuck Lever if (likely(req->rq_bytes_sent >= req->rq_slen)) { 428a246b010SChuck Lever req->rq_bytes_sent = 0; 429a246b010SChuck Lever return 0; 430a246b010SChuck Lever } 431262965f5SChuck Lever 432a246b010SChuck Lever status = -EAGAIN; 433262965f5SChuck Lever if (retry++ > XS_SENDMSG_RETRY) 434a246b010SChuck Lever break; 435a246b010SChuck Lever } 436a246b010SChuck Lever 437262965f5SChuck Lever switch (status) { 438262965f5SChuck Lever case -EAGAIN: 439262965f5SChuck Lever xs_nospace(task); 440262965f5SChuck Lever break; 441262965f5SChuck Lever case -ECONNREFUSED: 442262965f5SChuck Lever case -ECONNRESET: 443262965f5SChuck Lever case -ENOTCONN: 444262965f5SChuck Lever case -EPIPE: 445262965f5SChuck Lever status = -ENOTCONN; 446262965f5SChuck Lever break; 447262965f5SChuck Lever default: 448262965f5SChuck Lever dprintk("RPC: sendmsg returned unrecognized error %d\n", 449262965f5SChuck Lever -status); 45043118c29SChuck Lever xprt_disconnect(xprt); 451a246b010SChuck Lever break; 452a246b010SChuck Lever } 453a246b010SChuck Lever 454a246b010SChuck Lever return status; 455a246b010SChuck Lever } 456a246b010SChuck Lever 4579903cd1cSChuck Lever /** 458e0ab53deSTrond Myklebust * xs_tcp_release_xprt - clean up after a tcp transmission 459e0ab53deSTrond Myklebust * @xprt: transport 460e0ab53deSTrond Myklebust * @task: rpc task 461e0ab53deSTrond Myklebust * 462e0ab53deSTrond Myklebust * This cleans up if an error causes us to abort the transmission of a request. 463e0ab53deSTrond Myklebust * In this case, the socket may need to be reset in order to avoid confusing 464e0ab53deSTrond Myklebust * the server. 465e0ab53deSTrond Myklebust */ 466e0ab53deSTrond Myklebust static void xs_tcp_release_xprt(struct rpc_xprt *xprt, struct rpc_task *task) 467e0ab53deSTrond Myklebust { 468e0ab53deSTrond Myklebust struct rpc_rqst *req; 469e0ab53deSTrond Myklebust 470e0ab53deSTrond Myklebust if (task != xprt->snd_task) 471e0ab53deSTrond Myklebust return; 472e0ab53deSTrond Myklebust if (task == NULL) 473e0ab53deSTrond Myklebust goto out_release; 474e0ab53deSTrond Myklebust req = task->tk_rqstp; 475e0ab53deSTrond Myklebust if (req->rq_bytes_sent == 0) 476e0ab53deSTrond Myklebust goto out_release; 477e0ab53deSTrond Myklebust if (req->rq_bytes_sent == req->rq_snd_buf.len) 478e0ab53deSTrond Myklebust goto out_release; 479e0ab53deSTrond Myklebust set_bit(XPRT_CLOSE_WAIT, &task->tk_xprt->state); 480e0ab53deSTrond Myklebust out_release: 481e0ab53deSTrond Myklebust xprt_release_xprt(xprt, task); 482e0ab53deSTrond Myklebust } 483e0ab53deSTrond Myklebust 484e0ab53deSTrond Myklebust /** 4859903cd1cSChuck Lever * xs_close - close a socket 4869903cd1cSChuck Lever * @xprt: transport 4879903cd1cSChuck Lever * 4883167e12cSChuck Lever * This is used when all requests are complete; ie, no DRC state remains 4893167e12cSChuck Lever * on the server we want to save. 490a246b010SChuck Lever */ 4919903cd1cSChuck Lever static void xs_close(struct rpc_xprt *xprt) 492a246b010SChuck Lever { 493a246b010SChuck Lever struct socket *sock = xprt->sock; 494a246b010SChuck Lever struct sock *sk = xprt->inet; 495a246b010SChuck Lever 496a246b010SChuck Lever if (!sk) 497632e3bdcSTrond Myklebust goto clear_close_wait; 498a246b010SChuck Lever 4999903cd1cSChuck Lever dprintk("RPC: xs_close xprt %p\n", xprt); 5009903cd1cSChuck Lever 501a246b010SChuck Lever write_lock_bh(&sk->sk_callback_lock); 502a246b010SChuck Lever xprt->inet = NULL; 503a246b010SChuck Lever xprt->sock = NULL; 504a246b010SChuck Lever 505a246b010SChuck Lever sk->sk_user_data = NULL; 506a246b010SChuck Lever sk->sk_data_ready = xprt->old_data_ready; 507a246b010SChuck Lever sk->sk_state_change = xprt->old_state_change; 508a246b010SChuck Lever sk->sk_write_space = xprt->old_write_space; 509a246b010SChuck Lever write_unlock_bh(&sk->sk_callback_lock); 510a246b010SChuck Lever 511a246b010SChuck Lever sk->sk_no_check = 0; 512a246b010SChuck Lever 513a246b010SChuck Lever sock_release(sock); 514632e3bdcSTrond Myklebust clear_close_wait: 515632e3bdcSTrond Myklebust smp_mb__before_clear_bit(); 516632e3bdcSTrond Myklebust clear_bit(XPRT_CLOSE_WAIT, &xprt->state); 517632e3bdcSTrond Myklebust smp_mb__after_clear_bit(); 518a246b010SChuck Lever } 519a246b010SChuck Lever 5209903cd1cSChuck Lever /** 5219903cd1cSChuck Lever * xs_destroy - prepare to shutdown a transport 5229903cd1cSChuck Lever * @xprt: doomed transport 5239903cd1cSChuck Lever * 5249903cd1cSChuck Lever */ 5259903cd1cSChuck Lever static void xs_destroy(struct rpc_xprt *xprt) 526a246b010SChuck Lever { 5279903cd1cSChuck Lever dprintk("RPC: xs_destroy xprt %p\n", xprt); 5289903cd1cSChuck Lever 52955aa4f58SChuck Lever cancel_delayed_work(&xprt->connect_worker); 530a246b010SChuck Lever flush_scheduled_work(); 531a246b010SChuck Lever 532a246b010SChuck Lever xprt_disconnect(xprt); 5339903cd1cSChuck Lever xs_close(xprt); 534edb267a6SChuck Lever xs_free_peer_addresses(xprt); 535a246b010SChuck Lever kfree(xprt->slot); 536a246b010SChuck Lever } 537a246b010SChuck Lever 5389903cd1cSChuck Lever static inline struct rpc_xprt *xprt_from_sock(struct sock *sk) 5399903cd1cSChuck Lever { 5409903cd1cSChuck Lever return (struct rpc_xprt *) sk->sk_user_data; 5419903cd1cSChuck Lever } 5429903cd1cSChuck Lever 5439903cd1cSChuck Lever /** 5449903cd1cSChuck Lever * xs_udp_data_ready - "data ready" callback for UDP sockets 5459903cd1cSChuck Lever * @sk: socket with data to read 5469903cd1cSChuck Lever * @len: how much data to read 5479903cd1cSChuck Lever * 548a246b010SChuck Lever */ 5499903cd1cSChuck Lever static void xs_udp_data_ready(struct sock *sk, int len) 550a246b010SChuck Lever { 551a246b010SChuck Lever struct rpc_task *task; 552a246b010SChuck Lever struct rpc_xprt *xprt; 553a246b010SChuck Lever struct rpc_rqst *rovr; 554a246b010SChuck Lever struct sk_buff *skb; 555a246b010SChuck Lever int err, repsize, copied; 556a246b010SChuck Lever u32 _xid, *xp; 557a246b010SChuck Lever 558a246b010SChuck Lever read_lock(&sk->sk_callback_lock); 5599903cd1cSChuck Lever dprintk("RPC: xs_udp_data_ready...\n"); 5609903cd1cSChuck Lever if (!(xprt = xprt_from_sock(sk))) 561a246b010SChuck Lever goto out; 562a246b010SChuck Lever 563a246b010SChuck Lever if ((skb = skb_recv_datagram(sk, 0, 1, &err)) == NULL) 564a246b010SChuck Lever goto out; 565a246b010SChuck Lever 566a246b010SChuck Lever if (xprt->shutdown) 567a246b010SChuck Lever goto dropit; 568a246b010SChuck Lever 569a246b010SChuck Lever repsize = skb->len - sizeof(struct udphdr); 570a246b010SChuck Lever if (repsize < 4) { 5719903cd1cSChuck Lever dprintk("RPC: impossible RPC reply size %d!\n", repsize); 572a246b010SChuck Lever goto dropit; 573a246b010SChuck Lever } 574a246b010SChuck Lever 575a246b010SChuck Lever /* Copy the XID from the skb... */ 576a246b010SChuck Lever xp = skb_header_pointer(skb, sizeof(struct udphdr), 577a246b010SChuck Lever sizeof(_xid), &_xid); 578a246b010SChuck Lever if (xp == NULL) 579a246b010SChuck Lever goto dropit; 580a246b010SChuck Lever 581a246b010SChuck Lever /* Look up and lock the request corresponding to the given XID */ 5824a0f8c04SChuck Lever spin_lock(&xprt->transport_lock); 583a246b010SChuck Lever rovr = xprt_lookup_rqst(xprt, *xp); 584a246b010SChuck Lever if (!rovr) 585a246b010SChuck Lever goto out_unlock; 586a246b010SChuck Lever task = rovr->rq_task; 587a246b010SChuck Lever 588a246b010SChuck Lever if ((copied = rovr->rq_private_buf.buflen) > repsize) 589a246b010SChuck Lever copied = repsize; 590a246b010SChuck Lever 591a246b010SChuck Lever /* Suck it into the iovec, verify checksum if not done by hw. */ 592a246b010SChuck Lever if (csum_partial_copy_to_xdr(&rovr->rq_private_buf, skb)) 593a246b010SChuck Lever goto out_unlock; 594a246b010SChuck Lever 595a246b010SChuck Lever /* Something worked... */ 596a246b010SChuck Lever dst_confirm(skb->dst); 597a246b010SChuck Lever 5981570c1e4SChuck Lever xprt_adjust_cwnd(task, copied); 5991570c1e4SChuck Lever xprt_update_rtt(task); 6001570c1e4SChuck Lever xprt_complete_rqst(task, copied); 601a246b010SChuck Lever 602a246b010SChuck Lever out_unlock: 6034a0f8c04SChuck Lever spin_unlock(&xprt->transport_lock); 604a246b010SChuck Lever dropit: 605a246b010SChuck Lever skb_free_datagram(sk, skb); 606a246b010SChuck Lever out: 607a246b010SChuck Lever read_unlock(&sk->sk_callback_lock); 608a246b010SChuck Lever } 609a246b010SChuck Lever 6109903cd1cSChuck Lever static inline size_t xs_tcp_copy_data(skb_reader_t *desc, void *p, size_t len) 611a246b010SChuck Lever { 612a246b010SChuck Lever if (len > desc->count) 613a246b010SChuck Lever len = desc->count; 614a246b010SChuck Lever if (skb_copy_bits(desc->skb, desc->offset, p, len)) { 615a246b010SChuck Lever dprintk("RPC: failed to copy %zu bytes from skb. %zu bytes remain\n", 616a246b010SChuck Lever len, desc->count); 617a246b010SChuck Lever return 0; 618a246b010SChuck Lever } 619a246b010SChuck Lever desc->offset += len; 620a246b010SChuck Lever desc->count -= len; 621a246b010SChuck Lever dprintk("RPC: copied %zu bytes from skb. %zu bytes remain\n", 622a246b010SChuck Lever len, desc->count); 623a246b010SChuck Lever return len; 624a246b010SChuck Lever } 625a246b010SChuck Lever 6269903cd1cSChuck Lever static inline void xs_tcp_read_fraghdr(struct rpc_xprt *xprt, skb_reader_t *desc) 627a246b010SChuck Lever { 628a246b010SChuck Lever size_t len, used; 629a246b010SChuck Lever char *p; 630a246b010SChuck Lever 631a246b010SChuck Lever p = ((char *) &xprt->tcp_recm) + xprt->tcp_offset; 632a246b010SChuck Lever len = sizeof(xprt->tcp_recm) - xprt->tcp_offset; 6339903cd1cSChuck Lever used = xs_tcp_copy_data(desc, p, len); 634a246b010SChuck Lever xprt->tcp_offset += used; 635a246b010SChuck Lever if (used != len) 636a246b010SChuck Lever return; 637808012fbSChuck Lever 638a246b010SChuck Lever xprt->tcp_reclen = ntohl(xprt->tcp_recm); 639808012fbSChuck Lever if (xprt->tcp_reclen & RPC_LAST_STREAM_FRAGMENT) 640a246b010SChuck Lever xprt->tcp_flags |= XPRT_LAST_FRAG; 641a246b010SChuck Lever else 642a246b010SChuck Lever xprt->tcp_flags &= ~XPRT_LAST_FRAG; 643808012fbSChuck Lever xprt->tcp_reclen &= RPC_FRAGMENT_SIZE_MASK; 644808012fbSChuck Lever 645a246b010SChuck Lever xprt->tcp_flags &= ~XPRT_COPY_RECM; 646a246b010SChuck Lever xprt->tcp_offset = 0; 647808012fbSChuck Lever 648a246b010SChuck Lever /* Sanity check of the record length */ 649808012fbSChuck Lever if (unlikely(xprt->tcp_reclen < 4)) { 6509903cd1cSChuck Lever dprintk("RPC: invalid TCP record fragment length\n"); 651a246b010SChuck Lever xprt_disconnect(xprt); 6529903cd1cSChuck Lever return; 653a246b010SChuck Lever } 654a246b010SChuck Lever dprintk("RPC: reading TCP record fragment of length %d\n", 655a246b010SChuck Lever xprt->tcp_reclen); 656a246b010SChuck Lever } 657a246b010SChuck Lever 6589903cd1cSChuck Lever static void xs_tcp_check_recm(struct rpc_xprt *xprt) 659a246b010SChuck Lever { 660a246b010SChuck Lever dprintk("RPC: xprt = %p, tcp_copied = %lu, tcp_offset = %u, tcp_reclen = %u, tcp_flags = %lx\n", 661a246b010SChuck Lever xprt, xprt->tcp_copied, xprt->tcp_offset, xprt->tcp_reclen, xprt->tcp_flags); 662a246b010SChuck Lever if (xprt->tcp_offset == xprt->tcp_reclen) { 663a246b010SChuck Lever xprt->tcp_flags |= XPRT_COPY_RECM; 664a246b010SChuck Lever xprt->tcp_offset = 0; 665a246b010SChuck Lever if (xprt->tcp_flags & XPRT_LAST_FRAG) { 666a246b010SChuck Lever xprt->tcp_flags &= ~XPRT_COPY_DATA; 667a246b010SChuck Lever xprt->tcp_flags |= XPRT_COPY_XID; 668a246b010SChuck Lever xprt->tcp_copied = 0; 669a246b010SChuck Lever } 670a246b010SChuck Lever } 671a246b010SChuck Lever } 672a246b010SChuck Lever 6739903cd1cSChuck Lever static inline void xs_tcp_read_xid(struct rpc_xprt *xprt, skb_reader_t *desc) 674a246b010SChuck Lever { 675a246b010SChuck Lever size_t len, used; 676a246b010SChuck Lever char *p; 677a246b010SChuck Lever 678a246b010SChuck Lever len = sizeof(xprt->tcp_xid) - xprt->tcp_offset; 679a246b010SChuck Lever dprintk("RPC: reading XID (%Zu bytes)\n", len); 680a246b010SChuck Lever p = ((char *) &xprt->tcp_xid) + xprt->tcp_offset; 6819903cd1cSChuck Lever used = xs_tcp_copy_data(desc, p, len); 682a246b010SChuck Lever xprt->tcp_offset += used; 683a246b010SChuck Lever if (used != len) 684a246b010SChuck Lever return; 685a246b010SChuck Lever xprt->tcp_flags &= ~XPRT_COPY_XID; 686a246b010SChuck Lever xprt->tcp_flags |= XPRT_COPY_DATA; 687a246b010SChuck Lever xprt->tcp_copied = 4; 688a246b010SChuck Lever dprintk("RPC: reading reply for XID %08x\n", 689a246b010SChuck Lever ntohl(xprt->tcp_xid)); 6909903cd1cSChuck Lever xs_tcp_check_recm(xprt); 691a246b010SChuck Lever } 692a246b010SChuck Lever 6939903cd1cSChuck Lever static inline void xs_tcp_read_request(struct rpc_xprt *xprt, skb_reader_t *desc) 694a246b010SChuck Lever { 695a246b010SChuck Lever struct rpc_rqst *req; 696a246b010SChuck Lever struct xdr_buf *rcvbuf; 697a246b010SChuck Lever size_t len; 698a246b010SChuck Lever ssize_t r; 699a246b010SChuck Lever 700a246b010SChuck Lever /* Find and lock the request corresponding to this xid */ 7014a0f8c04SChuck Lever spin_lock(&xprt->transport_lock); 702a246b010SChuck Lever req = xprt_lookup_rqst(xprt, xprt->tcp_xid); 703a246b010SChuck Lever if (!req) { 704a246b010SChuck Lever xprt->tcp_flags &= ~XPRT_COPY_DATA; 705a246b010SChuck Lever dprintk("RPC: XID %08x request not found!\n", 706a246b010SChuck Lever ntohl(xprt->tcp_xid)); 7074a0f8c04SChuck Lever spin_unlock(&xprt->transport_lock); 708a246b010SChuck Lever return; 709a246b010SChuck Lever } 710a246b010SChuck Lever 711a246b010SChuck Lever rcvbuf = &req->rq_private_buf; 712a246b010SChuck Lever len = desc->count; 713a246b010SChuck Lever if (len > xprt->tcp_reclen - xprt->tcp_offset) { 714a246b010SChuck Lever skb_reader_t my_desc; 715a246b010SChuck Lever 716a246b010SChuck Lever len = xprt->tcp_reclen - xprt->tcp_offset; 717a246b010SChuck Lever memcpy(&my_desc, desc, sizeof(my_desc)); 718a246b010SChuck Lever my_desc.count = len; 719a246b010SChuck Lever r = xdr_partial_copy_from_skb(rcvbuf, xprt->tcp_copied, 7209903cd1cSChuck Lever &my_desc, xs_tcp_copy_data); 721a246b010SChuck Lever desc->count -= r; 722a246b010SChuck Lever desc->offset += r; 723a246b010SChuck Lever } else 724a246b010SChuck Lever r = xdr_partial_copy_from_skb(rcvbuf, xprt->tcp_copied, 7259903cd1cSChuck Lever desc, xs_tcp_copy_data); 726a246b010SChuck Lever 727a246b010SChuck Lever if (r > 0) { 728a246b010SChuck Lever xprt->tcp_copied += r; 729a246b010SChuck Lever xprt->tcp_offset += r; 730a246b010SChuck Lever } 731a246b010SChuck Lever if (r != len) { 732a246b010SChuck Lever /* Error when copying to the receive buffer, 733a246b010SChuck Lever * usually because we weren't able to allocate 734a246b010SChuck Lever * additional buffer pages. All we can do now 735a246b010SChuck Lever * is turn off XPRT_COPY_DATA, so the request 736a246b010SChuck Lever * will not receive any additional updates, 737a246b010SChuck Lever * and time out. 738a246b010SChuck Lever * Any remaining data from this record will 739a246b010SChuck Lever * be discarded. 740a246b010SChuck Lever */ 741a246b010SChuck Lever xprt->tcp_flags &= ~XPRT_COPY_DATA; 742a246b010SChuck Lever dprintk("RPC: XID %08x truncated request\n", 743a246b010SChuck Lever ntohl(xprt->tcp_xid)); 744a246b010SChuck Lever dprintk("RPC: xprt = %p, tcp_copied = %lu, tcp_offset = %u, tcp_reclen = %u\n", 745a246b010SChuck Lever xprt, xprt->tcp_copied, xprt->tcp_offset, xprt->tcp_reclen); 746a246b010SChuck Lever goto out; 747a246b010SChuck Lever } 748a246b010SChuck Lever 749a246b010SChuck Lever dprintk("RPC: XID %08x read %Zd bytes\n", 750a246b010SChuck Lever ntohl(xprt->tcp_xid), r); 751a246b010SChuck Lever dprintk("RPC: xprt = %p, tcp_copied = %lu, tcp_offset = %u, tcp_reclen = %u\n", 752a246b010SChuck Lever xprt, xprt->tcp_copied, xprt->tcp_offset, xprt->tcp_reclen); 753a246b010SChuck Lever 754a246b010SChuck Lever if (xprt->tcp_copied == req->rq_private_buf.buflen) 755a246b010SChuck Lever xprt->tcp_flags &= ~XPRT_COPY_DATA; 756a246b010SChuck Lever else if (xprt->tcp_offset == xprt->tcp_reclen) { 757a246b010SChuck Lever if (xprt->tcp_flags & XPRT_LAST_FRAG) 758a246b010SChuck Lever xprt->tcp_flags &= ~XPRT_COPY_DATA; 759a246b010SChuck Lever } 760a246b010SChuck Lever 761a246b010SChuck Lever out: 7621570c1e4SChuck Lever if (!(xprt->tcp_flags & XPRT_COPY_DATA)) 7631570c1e4SChuck Lever xprt_complete_rqst(req->rq_task, xprt->tcp_copied); 7644a0f8c04SChuck Lever spin_unlock(&xprt->transport_lock); 7659903cd1cSChuck Lever xs_tcp_check_recm(xprt); 766a246b010SChuck Lever } 767a246b010SChuck Lever 7689903cd1cSChuck Lever static inline void xs_tcp_read_discard(struct rpc_xprt *xprt, skb_reader_t *desc) 769a246b010SChuck Lever { 770a246b010SChuck Lever size_t len; 771a246b010SChuck Lever 772a246b010SChuck Lever len = xprt->tcp_reclen - xprt->tcp_offset; 773a246b010SChuck Lever if (len > desc->count) 774a246b010SChuck Lever len = desc->count; 775a246b010SChuck Lever desc->count -= len; 776a246b010SChuck Lever desc->offset += len; 777a246b010SChuck Lever xprt->tcp_offset += len; 778a246b010SChuck Lever dprintk("RPC: discarded %Zu bytes\n", len); 7799903cd1cSChuck Lever xs_tcp_check_recm(xprt); 780a246b010SChuck Lever } 781a246b010SChuck Lever 7829903cd1cSChuck Lever static int xs_tcp_data_recv(read_descriptor_t *rd_desc, struct sk_buff *skb, unsigned int offset, size_t len) 783a246b010SChuck Lever { 784a246b010SChuck Lever struct rpc_xprt *xprt = rd_desc->arg.data; 785a246b010SChuck Lever skb_reader_t desc = { 786a246b010SChuck Lever .skb = skb, 787a246b010SChuck Lever .offset = offset, 788a246b010SChuck Lever .count = len, 789a246b010SChuck Lever .csum = 0 790a246b010SChuck Lever }; 791a246b010SChuck Lever 7929903cd1cSChuck Lever dprintk("RPC: xs_tcp_data_recv started\n"); 793a246b010SChuck Lever do { 794a246b010SChuck Lever /* Read in a new fragment marker if necessary */ 795a246b010SChuck Lever /* Can we ever really expect to get completely empty fragments? */ 796a246b010SChuck Lever if (xprt->tcp_flags & XPRT_COPY_RECM) { 7979903cd1cSChuck Lever xs_tcp_read_fraghdr(xprt, &desc); 798a246b010SChuck Lever continue; 799a246b010SChuck Lever } 800a246b010SChuck Lever /* Read in the xid if necessary */ 801a246b010SChuck Lever if (xprt->tcp_flags & XPRT_COPY_XID) { 8029903cd1cSChuck Lever xs_tcp_read_xid(xprt, &desc); 803a246b010SChuck Lever continue; 804a246b010SChuck Lever } 805a246b010SChuck Lever /* Read in the request data */ 806a246b010SChuck Lever if (xprt->tcp_flags & XPRT_COPY_DATA) { 8079903cd1cSChuck Lever xs_tcp_read_request(xprt, &desc); 808a246b010SChuck Lever continue; 809a246b010SChuck Lever } 810a246b010SChuck Lever /* Skip over any trailing bytes on short reads */ 8119903cd1cSChuck Lever xs_tcp_read_discard(xprt, &desc); 812a246b010SChuck Lever } while (desc.count); 8139903cd1cSChuck Lever dprintk("RPC: xs_tcp_data_recv done\n"); 814a246b010SChuck Lever return len - desc.count; 815a246b010SChuck Lever } 816a246b010SChuck Lever 8179903cd1cSChuck Lever /** 8189903cd1cSChuck Lever * xs_tcp_data_ready - "data ready" callback for TCP sockets 8199903cd1cSChuck Lever * @sk: socket with data to read 8209903cd1cSChuck Lever * @bytes: how much data to read 8219903cd1cSChuck Lever * 8229903cd1cSChuck Lever */ 8239903cd1cSChuck Lever static void xs_tcp_data_ready(struct sock *sk, int bytes) 824a246b010SChuck Lever { 825a246b010SChuck Lever struct rpc_xprt *xprt; 826a246b010SChuck Lever read_descriptor_t rd_desc; 827a246b010SChuck Lever 828a246b010SChuck Lever read_lock(&sk->sk_callback_lock); 8299903cd1cSChuck Lever dprintk("RPC: xs_tcp_data_ready...\n"); 8309903cd1cSChuck Lever if (!(xprt = xprt_from_sock(sk))) 831a246b010SChuck Lever goto out; 832a246b010SChuck Lever if (xprt->shutdown) 833a246b010SChuck Lever goto out; 834a246b010SChuck Lever 8359903cd1cSChuck Lever /* We use rd_desc to pass struct xprt to xs_tcp_data_recv */ 836a246b010SChuck Lever rd_desc.arg.data = xprt; 837a246b010SChuck Lever rd_desc.count = 65536; 8389903cd1cSChuck Lever tcp_read_sock(sk, &rd_desc, xs_tcp_data_recv); 839a246b010SChuck Lever out: 840a246b010SChuck Lever read_unlock(&sk->sk_callback_lock); 841a246b010SChuck Lever } 842a246b010SChuck Lever 8439903cd1cSChuck Lever /** 8449903cd1cSChuck Lever * xs_tcp_state_change - callback to handle TCP socket state changes 8459903cd1cSChuck Lever * @sk: socket whose state has changed 8469903cd1cSChuck Lever * 8479903cd1cSChuck Lever */ 8489903cd1cSChuck Lever static void xs_tcp_state_change(struct sock *sk) 849a246b010SChuck Lever { 850a246b010SChuck Lever struct rpc_xprt *xprt; 851a246b010SChuck Lever 852a246b010SChuck Lever read_lock(&sk->sk_callback_lock); 853a246b010SChuck Lever if (!(xprt = xprt_from_sock(sk))) 854a246b010SChuck Lever goto out; 8559903cd1cSChuck Lever dprintk("RPC: xs_tcp_state_change client %p...\n", xprt); 856a246b010SChuck Lever dprintk("RPC: state %x conn %d dead %d zapped %d\n", 857a246b010SChuck Lever sk->sk_state, xprt_connected(xprt), 858a246b010SChuck Lever sock_flag(sk, SOCK_DEAD), 859a246b010SChuck Lever sock_flag(sk, SOCK_ZAPPED)); 860a246b010SChuck Lever 861a246b010SChuck Lever switch (sk->sk_state) { 862a246b010SChuck Lever case TCP_ESTABLISHED: 8634a0f8c04SChuck Lever spin_lock_bh(&xprt->transport_lock); 864a246b010SChuck Lever if (!xprt_test_and_set_connected(xprt)) { 865a246b010SChuck Lever /* Reset TCP record info */ 866a246b010SChuck Lever xprt->tcp_offset = 0; 867a246b010SChuck Lever xprt->tcp_reclen = 0; 868a246b010SChuck Lever xprt->tcp_copied = 0; 869a246b010SChuck Lever xprt->tcp_flags = XPRT_COPY_RECM | XPRT_COPY_XID; 87003bf4b70SChuck Lever xprt->reestablish_timeout = XS_TCP_INIT_REEST_TO; 87144fbac22SChuck Lever xprt_wake_pending_tasks(xprt, 0); 872a246b010SChuck Lever } 8734a0f8c04SChuck Lever spin_unlock_bh(&xprt->transport_lock); 874a246b010SChuck Lever break; 875a246b010SChuck Lever case TCP_SYN_SENT: 876a246b010SChuck Lever case TCP_SYN_RECV: 877a246b010SChuck Lever break; 878632e3bdcSTrond Myklebust case TCP_CLOSE_WAIT: 879632e3bdcSTrond Myklebust /* Try to schedule an autoclose RPC calls */ 880632e3bdcSTrond Myklebust set_bit(XPRT_CLOSE_WAIT, &xprt->state); 881632e3bdcSTrond Myklebust if (test_and_set_bit(XPRT_LOCKED, &xprt->state) == 0) 882632e3bdcSTrond Myklebust schedule_work(&xprt->task_cleanup); 883a246b010SChuck Lever default: 884a246b010SChuck Lever xprt_disconnect(xprt); 885a246b010SChuck Lever } 886a246b010SChuck Lever out: 887a246b010SChuck Lever read_unlock(&sk->sk_callback_lock); 888a246b010SChuck Lever } 889a246b010SChuck Lever 8909903cd1cSChuck Lever /** 891c7b2cae8SChuck Lever * xs_udp_write_space - callback invoked when socket buffer space 892c7b2cae8SChuck Lever * becomes available 8939903cd1cSChuck Lever * @sk: socket whose state has changed 8949903cd1cSChuck Lever * 895a246b010SChuck Lever * Called when more output buffer space is available for this socket. 896a246b010SChuck Lever * We try not to wake our writers until they can make "significant" 897c7b2cae8SChuck Lever * progress, otherwise we'll waste resources thrashing kernel_sendmsg 898a246b010SChuck Lever * with a bunch of small requests. 899a246b010SChuck Lever */ 900c7b2cae8SChuck Lever static void xs_udp_write_space(struct sock *sk) 901a246b010SChuck Lever { 902a246b010SChuck Lever read_lock(&sk->sk_callback_lock); 903c7b2cae8SChuck Lever 904c7b2cae8SChuck Lever /* from net/core/sock.c:sock_def_write_space */ 905c7b2cae8SChuck Lever if (sock_writeable(sk)) { 906c7b2cae8SChuck Lever struct socket *sock; 907c7b2cae8SChuck Lever struct rpc_xprt *xprt; 908c7b2cae8SChuck Lever 909c7b2cae8SChuck Lever if (unlikely(!(sock = sk->sk_socket))) 910a246b010SChuck Lever goto out; 911c7b2cae8SChuck Lever if (unlikely(!(xprt = xprt_from_sock(sk)))) 912c7b2cae8SChuck Lever goto out; 913c7b2cae8SChuck Lever if (unlikely(!test_and_clear_bit(SOCK_NOSPACE, &sock->flags))) 914a246b010SChuck Lever goto out; 915a246b010SChuck Lever 916c7b2cae8SChuck Lever xprt_write_space(xprt); 917a246b010SChuck Lever } 918a246b010SChuck Lever 919c7b2cae8SChuck Lever out: 920c7b2cae8SChuck Lever read_unlock(&sk->sk_callback_lock); 921c7b2cae8SChuck Lever } 922c7b2cae8SChuck Lever 923c7b2cae8SChuck Lever /** 924c7b2cae8SChuck Lever * xs_tcp_write_space - callback invoked when socket buffer space 925c7b2cae8SChuck Lever * becomes available 926c7b2cae8SChuck Lever * @sk: socket whose state has changed 927c7b2cae8SChuck Lever * 928c7b2cae8SChuck Lever * Called when more output buffer space is available for this socket. 929c7b2cae8SChuck Lever * We try not to wake our writers until they can make "significant" 930c7b2cae8SChuck Lever * progress, otherwise we'll waste resources thrashing kernel_sendmsg 931c7b2cae8SChuck Lever * with a bunch of small requests. 932c7b2cae8SChuck Lever */ 933c7b2cae8SChuck Lever static void xs_tcp_write_space(struct sock *sk) 934c7b2cae8SChuck Lever { 935c7b2cae8SChuck Lever read_lock(&sk->sk_callback_lock); 936c7b2cae8SChuck Lever 937c7b2cae8SChuck Lever /* from net/core/stream.c:sk_stream_write_space */ 938c7b2cae8SChuck Lever if (sk_stream_wspace(sk) >= sk_stream_min_wspace(sk)) { 939c7b2cae8SChuck Lever struct socket *sock; 940c7b2cae8SChuck Lever struct rpc_xprt *xprt; 941c7b2cae8SChuck Lever 942c7b2cae8SChuck Lever if (unlikely(!(sock = sk->sk_socket))) 943c7b2cae8SChuck Lever goto out; 944c7b2cae8SChuck Lever if (unlikely(!(xprt = xprt_from_sock(sk)))) 945c7b2cae8SChuck Lever goto out; 946c7b2cae8SChuck Lever if (unlikely(!test_and_clear_bit(SOCK_NOSPACE, &sock->flags))) 947a246b010SChuck Lever goto out; 948a246b010SChuck Lever 949c7b2cae8SChuck Lever xprt_write_space(xprt); 950c7b2cae8SChuck Lever } 951c7b2cae8SChuck Lever 952a246b010SChuck Lever out: 953a246b010SChuck Lever read_unlock(&sk->sk_callback_lock); 954a246b010SChuck Lever } 955a246b010SChuck Lever 956470056c2SChuck Lever static void xs_udp_do_set_buffer_size(struct rpc_xprt *xprt) 957a246b010SChuck Lever { 958a246b010SChuck Lever struct sock *sk = xprt->inet; 959a246b010SChuck Lever 960a246b010SChuck Lever if (xprt->rcvsize) { 961a246b010SChuck Lever sk->sk_userlocks |= SOCK_RCVBUF_LOCK; 962a246b010SChuck Lever sk->sk_rcvbuf = xprt->rcvsize * xprt->max_reqs * 2; 963a246b010SChuck Lever } 964a246b010SChuck Lever if (xprt->sndsize) { 965a246b010SChuck Lever sk->sk_userlocks |= SOCK_SNDBUF_LOCK; 966a246b010SChuck Lever sk->sk_sndbuf = xprt->sndsize * xprt->max_reqs * 2; 967a246b010SChuck Lever sk->sk_write_space(sk); 968a246b010SChuck Lever } 969a246b010SChuck Lever } 970a246b010SChuck Lever 97143118c29SChuck Lever /** 972470056c2SChuck Lever * xs_udp_set_buffer_size - set send and receive limits 97343118c29SChuck Lever * @xprt: generic transport 974470056c2SChuck Lever * @sndsize: requested size of send buffer, in bytes 975470056c2SChuck Lever * @rcvsize: requested size of receive buffer, in bytes 97643118c29SChuck Lever * 977470056c2SChuck Lever * Set socket send and receive buffer size limits. 97843118c29SChuck Lever */ 979470056c2SChuck Lever static void xs_udp_set_buffer_size(struct rpc_xprt *xprt, size_t sndsize, size_t rcvsize) 98043118c29SChuck Lever { 981470056c2SChuck Lever xprt->sndsize = 0; 982470056c2SChuck Lever if (sndsize) 983470056c2SChuck Lever xprt->sndsize = sndsize + 1024; 984470056c2SChuck Lever xprt->rcvsize = 0; 985470056c2SChuck Lever if (rcvsize) 986470056c2SChuck Lever xprt->rcvsize = rcvsize + 1024; 987470056c2SChuck Lever 988470056c2SChuck Lever xs_udp_do_set_buffer_size(xprt); 98943118c29SChuck Lever } 99043118c29SChuck Lever 99146c0ee8bSChuck Lever /** 99246c0ee8bSChuck Lever * xs_udp_timer - called when a retransmit timeout occurs on a UDP transport 99346c0ee8bSChuck Lever * @task: task that timed out 99446c0ee8bSChuck Lever * 99546c0ee8bSChuck Lever * Adjust the congestion window after a retransmit timeout has occurred. 99646c0ee8bSChuck Lever */ 99746c0ee8bSChuck Lever static void xs_udp_timer(struct rpc_task *task) 99846c0ee8bSChuck Lever { 99946c0ee8bSChuck Lever xprt_adjust_cwnd(task, -ETIMEDOUT); 100046c0ee8bSChuck Lever } 100146c0ee8bSChuck Lever 1002b85d8806SChuck Lever static unsigned short xs_get_random_port(void) 1003b85d8806SChuck Lever { 1004b85d8806SChuck Lever unsigned short range = xprt_max_resvport - xprt_min_resvport; 1005b85d8806SChuck Lever unsigned short rand = (unsigned short) net_random() % range; 1006b85d8806SChuck Lever return rand + xprt_min_resvport; 1007b85d8806SChuck Lever } 1008b85d8806SChuck Lever 100992200412SChuck Lever /** 1010edb267a6SChuck Lever * xs_print_peer_address - format an IPv4 address for printing 1011edb267a6SChuck Lever * @xprt: generic transport 1012edb267a6SChuck Lever * @format: flags field indicating which parts of the address to render 1013edb267a6SChuck Lever */ 1014edb267a6SChuck Lever static char *xs_print_peer_address(struct rpc_xprt *xprt, enum rpc_display_format_t format) 1015edb267a6SChuck Lever { 1016edb267a6SChuck Lever if (xprt->address_strings[format] != NULL) 1017edb267a6SChuck Lever return xprt->address_strings[format]; 1018edb267a6SChuck Lever else 1019edb267a6SChuck Lever return "unprintable"; 1020edb267a6SChuck Lever } 1021edb267a6SChuck Lever 1022edb267a6SChuck Lever /** 102392200412SChuck Lever * xs_set_port - reset the port number in the remote endpoint address 102492200412SChuck Lever * @xprt: generic transport 102592200412SChuck Lever * @port: new port number 102692200412SChuck Lever * 102792200412SChuck Lever */ 102892200412SChuck Lever static void xs_set_port(struct rpc_xprt *xprt, unsigned short port) 102992200412SChuck Lever { 1030*c4efcb1dSChuck Lever struct sockaddr_in *sap = (struct sockaddr_in *) &xprt->addr; 1031*c4efcb1dSChuck Lever 103292200412SChuck Lever dprintk("RPC: setting port for xprt %p to %u\n", xprt, port); 1033*c4efcb1dSChuck Lever 1034*c4efcb1dSChuck Lever sap->sin_port = htons(port); 103592200412SChuck Lever } 103692200412SChuck Lever 10379903cd1cSChuck Lever static int xs_bindresvport(struct rpc_xprt *xprt, struct socket *sock) 1038a246b010SChuck Lever { 1039a246b010SChuck Lever struct sockaddr_in myaddr = { 1040a246b010SChuck Lever .sin_family = AF_INET, 1041a246b010SChuck Lever }; 1042529b33c6SChuck Lever int err; 1043529b33c6SChuck Lever unsigned short port = xprt->port; 1044a246b010SChuck Lever 1045a246b010SChuck Lever do { 1046a246b010SChuck Lever myaddr.sin_port = htons(port); 1047a246b010SChuck Lever err = sock->ops->bind(sock, (struct sockaddr *) &myaddr, 1048a246b010SChuck Lever sizeof(myaddr)); 1049a246b010SChuck Lever if (err == 0) { 1050a246b010SChuck Lever xprt->port = port; 10519903cd1cSChuck Lever dprintk("RPC: xs_bindresvport bound to port %u\n", 10529903cd1cSChuck Lever port); 1053a246b010SChuck Lever return 0; 1054a246b010SChuck Lever } 1055529b33c6SChuck Lever if (port <= xprt_min_resvport) 1056529b33c6SChuck Lever port = xprt_max_resvport; 1057529b33c6SChuck Lever else 1058529b33c6SChuck Lever port--; 1059a246b010SChuck Lever } while (err == -EADDRINUSE && port != xprt->port); 1060a246b010SChuck Lever 10619903cd1cSChuck Lever dprintk("RPC: can't bind to reserved port (%d).\n", -err); 1062a246b010SChuck Lever return err; 1063a246b010SChuck Lever } 1064a246b010SChuck Lever 10659903cd1cSChuck Lever /** 1066b0d93ad5SChuck Lever * xs_udp_connect_worker - set up a UDP socket 10679903cd1cSChuck Lever * @args: RPC transport to connect 10689903cd1cSChuck Lever * 10699903cd1cSChuck Lever * Invoked by a work queue tasklet. 1070a246b010SChuck Lever */ 1071b0d93ad5SChuck Lever static void xs_udp_connect_worker(void *args) 1072a246b010SChuck Lever { 1073a246b010SChuck Lever struct rpc_xprt *xprt = (struct rpc_xprt *) args; 1074a246b010SChuck Lever struct socket *sock = xprt->sock; 1075b0d93ad5SChuck Lever int err, status = -EIO; 1076a246b010SChuck Lever 1077ec739ef0SChuck Lever if (xprt->shutdown || !xprt_bound(xprt)) 1078a246b010SChuck Lever goto out; 1079a246b010SChuck Lever 1080b0d93ad5SChuck Lever /* Start by resetting any existing state */ 10819903cd1cSChuck Lever xs_close(xprt); 1082b0d93ad5SChuck Lever 1083b0d93ad5SChuck Lever if ((err = sock_create_kern(PF_INET, SOCK_DGRAM, IPPROTO_UDP, &sock)) < 0) { 1084b0d93ad5SChuck Lever dprintk("RPC: can't create UDP transport socket (%d).\n", -err); 1085a246b010SChuck Lever goto out; 1086a246b010SChuck Lever } 1087a246b010SChuck Lever 1088b0d93ad5SChuck Lever if (xprt->resvport && xs_bindresvport(xprt, sock) < 0) { 1089b0d93ad5SChuck Lever sock_release(sock); 1090b0d93ad5SChuck Lever goto out; 1091b0d93ad5SChuck Lever } 1092b0d93ad5SChuck Lever 1093edb267a6SChuck Lever dprintk("RPC: worker connecting xprt %p to address: %s\n", 1094edb267a6SChuck Lever xprt, xs_print_peer_address(xprt, RPC_DISPLAY_ALL)); 1095edb267a6SChuck Lever 1096b0d93ad5SChuck Lever if (!xprt->inet) { 1097b0d93ad5SChuck Lever struct sock *sk = sock->sk; 1098b0d93ad5SChuck Lever 1099b0d93ad5SChuck Lever write_lock_bh(&sk->sk_callback_lock); 1100b0d93ad5SChuck Lever 1101b0d93ad5SChuck Lever sk->sk_user_data = xprt; 1102b0d93ad5SChuck Lever xprt->old_data_ready = sk->sk_data_ready; 1103b0d93ad5SChuck Lever xprt->old_state_change = sk->sk_state_change; 1104b0d93ad5SChuck Lever xprt->old_write_space = sk->sk_write_space; 1105b0d93ad5SChuck Lever sk->sk_data_ready = xs_udp_data_ready; 1106b0d93ad5SChuck Lever sk->sk_write_space = xs_udp_write_space; 1107b0d93ad5SChuck Lever sk->sk_no_check = UDP_CSUM_NORCV; 1108b079fa7bSTrond Myklebust sk->sk_allocation = GFP_ATOMIC; 1109b0d93ad5SChuck Lever 1110b0d93ad5SChuck Lever xprt_set_connected(xprt); 1111b0d93ad5SChuck Lever 1112b0d93ad5SChuck Lever /* Reset to new socket */ 1113b0d93ad5SChuck Lever xprt->sock = sock; 1114b0d93ad5SChuck Lever xprt->inet = sk; 1115b0d93ad5SChuck Lever 1116b0d93ad5SChuck Lever write_unlock_bh(&sk->sk_callback_lock); 1117b0d93ad5SChuck Lever } 1118470056c2SChuck Lever xs_udp_do_set_buffer_size(xprt); 1119a246b010SChuck Lever status = 0; 1120b0d93ad5SChuck Lever out: 1121b0d93ad5SChuck Lever xprt_wake_pending_tasks(xprt, status); 1122b0d93ad5SChuck Lever xprt_clear_connecting(xprt); 1123b0d93ad5SChuck Lever } 1124b0d93ad5SChuck Lever 11253167e12cSChuck Lever /* 11263167e12cSChuck Lever * We need to preserve the port number so the reply cache on the server can 11273167e12cSChuck Lever * find our cached RPC replies when we get around to reconnecting. 11283167e12cSChuck Lever */ 11293167e12cSChuck Lever static void xs_tcp_reuse_connection(struct rpc_xprt *xprt) 11303167e12cSChuck Lever { 11313167e12cSChuck Lever int result; 11323167e12cSChuck Lever struct socket *sock = xprt->sock; 11333167e12cSChuck Lever struct sockaddr any; 11343167e12cSChuck Lever 11353167e12cSChuck Lever dprintk("RPC: disconnecting xprt %p to reuse port\n", xprt); 11363167e12cSChuck Lever 11373167e12cSChuck Lever /* 11383167e12cSChuck Lever * Disconnect the transport socket by doing a connect operation 11393167e12cSChuck Lever * with AF_UNSPEC. This should return immediately... 11403167e12cSChuck Lever */ 11413167e12cSChuck Lever memset(&any, 0, sizeof(any)); 11423167e12cSChuck Lever any.sa_family = AF_UNSPEC; 11433167e12cSChuck Lever result = sock->ops->connect(sock, &any, sizeof(any), 0); 11443167e12cSChuck Lever if (result) 11453167e12cSChuck Lever dprintk("RPC: AF_UNSPEC connect return code %d\n", 11463167e12cSChuck Lever result); 11473167e12cSChuck Lever } 11483167e12cSChuck Lever 1149b0d93ad5SChuck Lever /** 1150b0d93ad5SChuck Lever * xs_tcp_connect_worker - connect a TCP socket to a remote endpoint 1151b0d93ad5SChuck Lever * @args: RPC transport to connect 1152b0d93ad5SChuck Lever * 1153b0d93ad5SChuck Lever * Invoked by a work queue tasklet. 1154b0d93ad5SChuck Lever */ 1155b0d93ad5SChuck Lever static void xs_tcp_connect_worker(void *args) 1156b0d93ad5SChuck Lever { 1157b0d93ad5SChuck Lever struct rpc_xprt *xprt = (struct rpc_xprt *)args; 1158b0d93ad5SChuck Lever struct socket *sock = xprt->sock; 1159b0d93ad5SChuck Lever int err, status = -EIO; 1160b0d93ad5SChuck Lever 1161ec739ef0SChuck Lever if (xprt->shutdown || !xprt_bound(xprt)) 1162a246b010SChuck Lever goto out; 1163a246b010SChuck Lever 11643167e12cSChuck Lever if (!xprt->sock) { 11653167e12cSChuck Lever /* start from scratch */ 1166b0d93ad5SChuck Lever if ((err = sock_create_kern(PF_INET, SOCK_STREAM, IPPROTO_TCP, &sock)) < 0) { 1167b0d93ad5SChuck Lever dprintk("RPC: can't create TCP transport socket (%d).\n", -err); 1168b0d93ad5SChuck Lever goto out; 1169b0d93ad5SChuck Lever } 1170b0d93ad5SChuck Lever 1171b0d93ad5SChuck Lever if (xprt->resvport && xs_bindresvport(xprt, sock) < 0) { 1172b0d93ad5SChuck Lever sock_release(sock); 1173b0d93ad5SChuck Lever goto out; 1174b0d93ad5SChuck Lever } 11753167e12cSChuck Lever } else 11763167e12cSChuck Lever /* "close" the socket, preserving the local port */ 11773167e12cSChuck Lever xs_tcp_reuse_connection(xprt); 1178b0d93ad5SChuck Lever 1179edb267a6SChuck Lever dprintk("RPC: worker connecting xprt %p to address: %s\n", 1180edb267a6SChuck Lever xprt, xs_print_peer_address(xprt, RPC_DISPLAY_ALL)); 1181edb267a6SChuck Lever 1182b0d93ad5SChuck Lever if (!xprt->inet) { 1183b0d93ad5SChuck Lever struct sock *sk = sock->sk; 1184b0d93ad5SChuck Lever 1185b0d93ad5SChuck Lever write_lock_bh(&sk->sk_callback_lock); 1186b0d93ad5SChuck Lever 1187b0d93ad5SChuck Lever sk->sk_user_data = xprt; 1188b0d93ad5SChuck Lever xprt->old_data_ready = sk->sk_data_ready; 1189b0d93ad5SChuck Lever xprt->old_state_change = sk->sk_state_change; 1190b0d93ad5SChuck Lever xprt->old_write_space = sk->sk_write_space; 1191b0d93ad5SChuck Lever sk->sk_data_ready = xs_tcp_data_ready; 1192b0d93ad5SChuck Lever sk->sk_state_change = xs_tcp_state_change; 1193b0d93ad5SChuck Lever sk->sk_write_space = xs_tcp_write_space; 1194b079fa7bSTrond Myklebust sk->sk_allocation = GFP_ATOMIC; 11953167e12cSChuck Lever 11963167e12cSChuck Lever /* socket options */ 11973167e12cSChuck Lever sk->sk_userlocks |= SOCK_BINDPORT_LOCK; 11983167e12cSChuck Lever sock_reset_flag(sk, SOCK_LINGER); 11993167e12cSChuck Lever tcp_sk(sk)->linger2 = 0; 12003167e12cSChuck Lever tcp_sk(sk)->nonagle |= TCP_NAGLE_OFF; 1201b0d93ad5SChuck Lever 1202b0d93ad5SChuck Lever xprt_clear_connected(xprt); 1203b0d93ad5SChuck Lever 1204b0d93ad5SChuck Lever /* Reset to new socket */ 1205b0d93ad5SChuck Lever xprt->sock = sock; 1206b0d93ad5SChuck Lever xprt->inet = sk; 1207b0d93ad5SChuck Lever 1208b0d93ad5SChuck Lever write_unlock_bh(&sk->sk_callback_lock); 1209b0d93ad5SChuck Lever } 1210b0d93ad5SChuck Lever 1211b0d93ad5SChuck Lever /* Tell the socket layer to start connecting... */ 1212262ca07dSChuck Lever xprt->stat.connect_count++; 1213262ca07dSChuck Lever xprt->stat.connect_start = jiffies; 1214a246b010SChuck Lever status = sock->ops->connect(sock, (struct sockaddr *) &xprt->addr, 1215*c4efcb1dSChuck Lever xprt->addrlen, O_NONBLOCK); 1216a246b010SChuck Lever dprintk("RPC: %p connect status %d connected %d sock state %d\n", 1217a246b010SChuck Lever xprt, -status, xprt_connected(xprt), sock->sk->sk_state); 1218a246b010SChuck Lever if (status < 0) { 1219a246b010SChuck Lever switch (status) { 1220a246b010SChuck Lever case -EINPROGRESS: 1221a246b010SChuck Lever case -EALREADY: 1222a246b010SChuck Lever goto out_clear; 12233167e12cSChuck Lever case -ECONNREFUSED: 12243167e12cSChuck Lever case -ECONNRESET: 12253167e12cSChuck Lever /* retry with existing socket, after a delay */ 12263167e12cSChuck Lever break; 12273167e12cSChuck Lever default: 12283167e12cSChuck Lever /* get rid of existing socket, and retry */ 12293167e12cSChuck Lever xs_close(xprt); 12303167e12cSChuck Lever break; 1231a246b010SChuck Lever } 1232a246b010SChuck Lever } 1233a246b010SChuck Lever out: 123444fbac22SChuck Lever xprt_wake_pending_tasks(xprt, status); 1235a246b010SChuck Lever out_clear: 12362226feb6SChuck Lever xprt_clear_connecting(xprt); 1237a246b010SChuck Lever } 1238a246b010SChuck Lever 12399903cd1cSChuck Lever /** 12409903cd1cSChuck Lever * xs_connect - connect a socket to a remote endpoint 12419903cd1cSChuck Lever * @task: address of RPC task that manages state of connect request 12429903cd1cSChuck Lever * 12439903cd1cSChuck Lever * TCP: If the remote end dropped the connection, delay reconnecting. 124403bf4b70SChuck Lever * 124503bf4b70SChuck Lever * UDP socket connects are synchronous, but we use a work queue anyway 124603bf4b70SChuck Lever * to guarantee that even unprivileged user processes can set up a 124703bf4b70SChuck Lever * socket on a privileged port. 124803bf4b70SChuck Lever * 124903bf4b70SChuck Lever * If a UDP socket connect fails, the delay behavior here prevents 125003bf4b70SChuck Lever * retry floods (hard mounts). 12519903cd1cSChuck Lever */ 12529903cd1cSChuck Lever static void xs_connect(struct rpc_task *task) 1253a246b010SChuck Lever { 1254a246b010SChuck Lever struct rpc_xprt *xprt = task->tk_xprt; 1255a246b010SChuck Lever 1256b0d93ad5SChuck Lever if (xprt_test_and_set_connecting(xprt)) 1257b0d93ad5SChuck Lever return; 1258b0d93ad5SChuck Lever 12599903cd1cSChuck Lever if (xprt->sock != NULL) { 126003bf4b70SChuck Lever dprintk("RPC: xs_connect delayed xprt %p for %lu seconds\n", 126103bf4b70SChuck Lever xprt, xprt->reestablish_timeout / HZ); 126255aa4f58SChuck Lever schedule_delayed_work(&xprt->connect_worker, 126303bf4b70SChuck Lever xprt->reestablish_timeout); 126403bf4b70SChuck Lever xprt->reestablish_timeout <<= 1; 126503bf4b70SChuck Lever if (xprt->reestablish_timeout > XS_TCP_MAX_REEST_TO) 126603bf4b70SChuck Lever xprt->reestablish_timeout = XS_TCP_MAX_REEST_TO; 12679903cd1cSChuck Lever } else { 12689903cd1cSChuck Lever dprintk("RPC: xs_connect scheduled xprt %p\n", xprt); 126955aa4f58SChuck Lever schedule_work(&xprt->connect_worker); 1270b0d93ad5SChuck Lever 1271a246b010SChuck Lever /* flush_scheduled_work can sleep... */ 1272a246b010SChuck Lever if (!RPC_IS_ASYNC(task)) 1273a246b010SChuck Lever flush_scheduled_work(); 1274a246b010SChuck Lever } 1275a246b010SChuck Lever } 1276a246b010SChuck Lever 1277262ca07dSChuck Lever /** 1278262ca07dSChuck Lever * xs_udp_print_stats - display UDP socket-specifc stats 1279262ca07dSChuck Lever * @xprt: rpc_xprt struct containing statistics 1280262ca07dSChuck Lever * @seq: output file 1281262ca07dSChuck Lever * 1282262ca07dSChuck Lever */ 1283262ca07dSChuck Lever static void xs_udp_print_stats(struct rpc_xprt *xprt, struct seq_file *seq) 1284262ca07dSChuck Lever { 1285262ca07dSChuck Lever seq_printf(seq, "\txprt:\tudp %u %lu %lu %lu %lu %Lu %Lu\n", 1286262ca07dSChuck Lever xprt->port, 1287262ca07dSChuck Lever xprt->stat.bind_count, 1288262ca07dSChuck Lever xprt->stat.sends, 1289262ca07dSChuck Lever xprt->stat.recvs, 1290262ca07dSChuck Lever xprt->stat.bad_xids, 1291262ca07dSChuck Lever xprt->stat.req_u, 1292262ca07dSChuck Lever xprt->stat.bklog_u); 1293262ca07dSChuck Lever } 1294262ca07dSChuck Lever 1295262ca07dSChuck Lever /** 1296262ca07dSChuck Lever * xs_tcp_print_stats - display TCP socket-specifc stats 1297262ca07dSChuck Lever * @xprt: rpc_xprt struct containing statistics 1298262ca07dSChuck Lever * @seq: output file 1299262ca07dSChuck Lever * 1300262ca07dSChuck Lever */ 1301262ca07dSChuck Lever static void xs_tcp_print_stats(struct rpc_xprt *xprt, struct seq_file *seq) 1302262ca07dSChuck Lever { 1303262ca07dSChuck Lever long idle_time = 0; 1304262ca07dSChuck Lever 1305262ca07dSChuck Lever if (xprt_connected(xprt)) 1306262ca07dSChuck Lever idle_time = (long)(jiffies - xprt->last_used) / HZ; 1307262ca07dSChuck Lever 1308262ca07dSChuck Lever seq_printf(seq, "\txprt:\ttcp %u %lu %lu %lu %ld %lu %lu %lu %Lu %Lu\n", 1309262ca07dSChuck Lever xprt->port, 1310262ca07dSChuck Lever xprt->stat.bind_count, 1311262ca07dSChuck Lever xprt->stat.connect_count, 1312262ca07dSChuck Lever xprt->stat.connect_time, 1313262ca07dSChuck Lever idle_time, 1314262ca07dSChuck Lever xprt->stat.sends, 1315262ca07dSChuck Lever xprt->stat.recvs, 1316262ca07dSChuck Lever xprt->stat.bad_xids, 1317262ca07dSChuck Lever xprt->stat.req_u, 1318262ca07dSChuck Lever xprt->stat.bklog_u); 1319262ca07dSChuck Lever } 1320262ca07dSChuck Lever 1321262965f5SChuck Lever static struct rpc_xprt_ops xs_udp_ops = { 132243118c29SChuck Lever .set_buffer_size = xs_udp_set_buffer_size, 1323edb267a6SChuck Lever .print_addr = xs_print_peer_address, 132412a80469SChuck Lever .reserve_xprt = xprt_reserve_xprt_cong, 132549e9a890SChuck Lever .release_xprt = xprt_release_xprt_cong, 1326bbf7c1ddSChuck Lever .rpcbind = rpc_getport, 132792200412SChuck Lever .set_port = xs_set_port, 13289903cd1cSChuck Lever .connect = xs_connect, 132902107148SChuck Lever .buf_alloc = rpc_malloc, 133002107148SChuck Lever .buf_free = rpc_free, 1331262965f5SChuck Lever .send_request = xs_udp_send_request, 1332fe3aca29SChuck Lever .set_retrans_timeout = xprt_set_retrans_timeout_rtt, 133346c0ee8bSChuck Lever .timer = xs_udp_timer, 1334a58dd398SChuck Lever .release_request = xprt_release_rqst_cong, 1335262965f5SChuck Lever .close = xs_close, 1336262965f5SChuck Lever .destroy = xs_destroy, 1337262ca07dSChuck Lever .print_stats = xs_udp_print_stats, 1338262965f5SChuck Lever }; 1339262965f5SChuck Lever 1340262965f5SChuck Lever static struct rpc_xprt_ops xs_tcp_ops = { 1341edb267a6SChuck Lever .print_addr = xs_print_peer_address, 134212a80469SChuck Lever .reserve_xprt = xprt_reserve_xprt, 1343e0ab53deSTrond Myklebust .release_xprt = xs_tcp_release_xprt, 1344bbf7c1ddSChuck Lever .rpcbind = rpc_getport, 134592200412SChuck Lever .set_port = xs_set_port, 1346262965f5SChuck Lever .connect = xs_connect, 134702107148SChuck Lever .buf_alloc = rpc_malloc, 134802107148SChuck Lever .buf_free = rpc_free, 1349262965f5SChuck Lever .send_request = xs_tcp_send_request, 1350fe3aca29SChuck Lever .set_retrans_timeout = xprt_set_retrans_timeout_def, 13519903cd1cSChuck Lever .close = xs_close, 13529903cd1cSChuck Lever .destroy = xs_destroy, 1353262ca07dSChuck Lever .print_stats = xs_tcp_print_stats, 1354a246b010SChuck Lever }; 1355a246b010SChuck Lever 13569903cd1cSChuck Lever /** 13579903cd1cSChuck Lever * xs_setup_udp - Set up transport to use a UDP socket 13589903cd1cSChuck Lever * @xprt: transport to set up 13599903cd1cSChuck Lever * @to: timeout parameters 13609903cd1cSChuck Lever * 13619903cd1cSChuck Lever */ 1362a246b010SChuck Lever int xs_setup_udp(struct rpc_xprt *xprt, struct rpc_timeout *to) 1363a246b010SChuck Lever { 1364a246b010SChuck Lever size_t slot_table_size; 1365*c4efcb1dSChuck Lever struct sockaddr_in *addr = (struct sockaddr_in *) &xprt->addr; 1366a246b010SChuck Lever 1367a246b010SChuck Lever xprt->max_reqs = xprt_udp_slot_table_entries; 1368a246b010SChuck Lever slot_table_size = xprt->max_reqs * sizeof(xprt->slot[0]); 13690da974f4SPanagiotis Issaris xprt->slot = kzalloc(slot_table_size, GFP_KERNEL); 1370a246b010SChuck Lever if (xprt->slot == NULL) 1371a246b010SChuck Lever return -ENOMEM; 1372a246b010SChuck Lever 1373*c4efcb1dSChuck Lever if (ntohs(addr->sin_port != 0)) 1374ec739ef0SChuck Lever xprt_set_bound(xprt); 1375b85d8806SChuck Lever xprt->port = xs_get_random_port(); 1376ec739ef0SChuck Lever 1377ec739ef0SChuck Lever xprt->prot = IPPROTO_UDP; 1378808012fbSChuck Lever xprt->tsh_size = 0; 1379a246b010SChuck Lever xprt->resvport = capable(CAP_NET_BIND_SERVICE) ? 1 : 0; 1380a246b010SChuck Lever /* XXX: header size can vary due to auth type, IPv6, etc. */ 1381a246b010SChuck Lever xprt->max_payload = (1U << 16) - (MAX_HEADER << 3); 1382a246b010SChuck Lever 1383b0d93ad5SChuck Lever INIT_WORK(&xprt->connect_worker, xs_udp_connect_worker, xprt); 138403bf4b70SChuck Lever xprt->bind_timeout = XS_BIND_TO; 138503bf4b70SChuck Lever xprt->connect_timeout = XS_UDP_CONN_TO; 138603bf4b70SChuck Lever xprt->reestablish_timeout = XS_UDP_REEST_TO; 138703bf4b70SChuck Lever xprt->idle_timeout = XS_IDLE_DISC_TO; 1388a246b010SChuck Lever 1389262965f5SChuck Lever xprt->ops = &xs_udp_ops; 1390a246b010SChuck Lever 1391a246b010SChuck Lever if (to) 1392a246b010SChuck Lever xprt->timeout = *to; 1393a246b010SChuck Lever else 13949903cd1cSChuck Lever xprt_set_timeout(&xprt->timeout, 5, 5 * HZ); 1395a246b010SChuck Lever 1396edb267a6SChuck Lever xs_format_peer_addresses(xprt); 1397edb267a6SChuck Lever dprintk("RPC: set up transport to address %s\n", 1398edb267a6SChuck Lever xs_print_peer_address(xprt, RPC_DISPLAY_ALL)); 1399edb267a6SChuck Lever 1400a246b010SChuck Lever return 0; 1401a246b010SChuck Lever } 1402a246b010SChuck Lever 14039903cd1cSChuck Lever /** 14049903cd1cSChuck Lever * xs_setup_tcp - Set up transport to use a TCP socket 14059903cd1cSChuck Lever * @xprt: transport to set up 14069903cd1cSChuck Lever * @to: timeout parameters 14079903cd1cSChuck Lever * 14089903cd1cSChuck Lever */ 1409a246b010SChuck Lever int xs_setup_tcp(struct rpc_xprt *xprt, struct rpc_timeout *to) 1410a246b010SChuck Lever { 1411a246b010SChuck Lever size_t slot_table_size; 1412*c4efcb1dSChuck Lever struct sockaddr_in *addr = (struct sockaddr_in *) &xprt->addr; 1413a246b010SChuck Lever 1414a246b010SChuck Lever xprt->max_reqs = xprt_tcp_slot_table_entries; 1415a246b010SChuck Lever slot_table_size = xprt->max_reqs * sizeof(xprt->slot[0]); 14160da974f4SPanagiotis Issaris xprt->slot = kzalloc(slot_table_size, GFP_KERNEL); 1417a246b010SChuck Lever if (xprt->slot == NULL) 1418a246b010SChuck Lever return -ENOMEM; 1419a246b010SChuck Lever 1420*c4efcb1dSChuck Lever if (ntohs(addr->sin_port) != 0) 1421ec739ef0SChuck Lever xprt_set_bound(xprt); 1422b85d8806SChuck Lever xprt->port = xs_get_random_port(); 1423ec739ef0SChuck Lever 1424ec739ef0SChuck Lever xprt->prot = IPPROTO_TCP; 1425808012fbSChuck Lever xprt->tsh_size = sizeof(rpc_fraghdr) / sizeof(u32); 1426a246b010SChuck Lever xprt->resvport = capable(CAP_NET_BIND_SERVICE) ? 1 : 0; 1427808012fbSChuck Lever xprt->max_payload = RPC_MAX_FRAGMENT_SIZE; 1428a246b010SChuck Lever 1429b0d93ad5SChuck Lever INIT_WORK(&xprt->connect_worker, xs_tcp_connect_worker, xprt); 143003bf4b70SChuck Lever xprt->bind_timeout = XS_BIND_TO; 143103bf4b70SChuck Lever xprt->connect_timeout = XS_TCP_CONN_TO; 143203bf4b70SChuck Lever xprt->reestablish_timeout = XS_TCP_INIT_REEST_TO; 143303bf4b70SChuck Lever xprt->idle_timeout = XS_IDLE_DISC_TO; 1434a246b010SChuck Lever 1435262965f5SChuck Lever xprt->ops = &xs_tcp_ops; 1436a246b010SChuck Lever 1437a246b010SChuck Lever if (to) 1438a246b010SChuck Lever xprt->timeout = *to; 1439a246b010SChuck Lever else 14409903cd1cSChuck Lever xprt_set_timeout(&xprt->timeout, 2, 60 * HZ); 1441a246b010SChuck Lever 1442edb267a6SChuck Lever xs_format_peer_addresses(xprt); 1443edb267a6SChuck Lever dprintk("RPC: set up transport to address %s\n", 1444edb267a6SChuck Lever xs_print_peer_address(xprt, RPC_DISPLAY_ALL)); 1445edb267a6SChuck Lever 1446a246b010SChuck Lever return 0; 1447a246b010SChuck Lever } 1448