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 128ffc2e518SChuck Lever struct sock_xprt { 129ffc2e518SChuck Lever struct rpc_xprt xprt; 130ee0ac0c2SChuck Lever 131ee0ac0c2SChuck Lever /* 132ee0ac0c2SChuck Lever * Network layer 133ee0ac0c2SChuck Lever */ 134ee0ac0c2SChuck Lever struct socket * sock; 135ee0ac0c2SChuck Lever struct sock * inet; 13651971139SChuck Lever 13751971139SChuck Lever /* 13851971139SChuck Lever * State of TCP reply receive 13951971139SChuck Lever */ 14051971139SChuck Lever __be32 tcp_fraghdr, 14151971139SChuck Lever tcp_xid; 14251971139SChuck Lever 14351971139SChuck Lever u32 tcp_offset, 14451971139SChuck Lever tcp_reclen; 14551971139SChuck Lever 14651971139SChuck Lever unsigned long tcp_copied, 14751971139SChuck Lever tcp_flags; 148c8475461SChuck Lever 149c8475461SChuck Lever /* 150c8475461SChuck Lever * Connection of transports 151c8475461SChuck Lever */ 152c8475461SChuck Lever struct work_struct connect_worker; 153c8475461SChuck Lever unsigned short port; 154ffc2e518SChuck Lever }; 155ffc2e518SChuck Lever 156e136d092SChuck Lever /* 157e136d092SChuck Lever * TCP receive state flags 158e136d092SChuck Lever */ 159e136d092SChuck Lever #define TCP_RCV_LAST_FRAG (1UL << 0) 160e136d092SChuck Lever #define TCP_RCV_COPY_FRAGHDR (1UL << 1) 161e136d092SChuck Lever #define TCP_RCV_COPY_XID (1UL << 2) 162e136d092SChuck Lever #define TCP_RCV_COPY_DATA (1UL << 3) 163e136d092SChuck Lever 164edb267a6SChuck Lever static void xs_format_peer_addresses(struct rpc_xprt *xprt) 165edb267a6SChuck Lever { 166edb267a6SChuck Lever struct sockaddr_in *addr = (struct sockaddr_in *) &xprt->addr; 167edb267a6SChuck Lever char *buf; 168edb267a6SChuck Lever 169edb267a6SChuck Lever buf = kzalloc(20, GFP_KERNEL); 170edb267a6SChuck Lever if (buf) { 171edb267a6SChuck Lever snprintf(buf, 20, "%u.%u.%u.%u", 172edb267a6SChuck Lever NIPQUAD(addr->sin_addr.s_addr)); 173edb267a6SChuck Lever } 174edb267a6SChuck Lever xprt->address_strings[RPC_DISPLAY_ADDR] = buf; 175edb267a6SChuck Lever 176edb267a6SChuck Lever buf = kzalloc(8, GFP_KERNEL); 177edb267a6SChuck Lever if (buf) { 178edb267a6SChuck Lever snprintf(buf, 8, "%u", 179edb267a6SChuck Lever ntohs(addr->sin_port)); 180edb267a6SChuck Lever } 181edb267a6SChuck Lever xprt->address_strings[RPC_DISPLAY_PORT] = buf; 182edb267a6SChuck Lever 183edb267a6SChuck Lever if (xprt->prot == IPPROTO_UDP) 184edb267a6SChuck Lever xprt->address_strings[RPC_DISPLAY_PROTO] = "udp"; 185edb267a6SChuck Lever else 186edb267a6SChuck Lever xprt->address_strings[RPC_DISPLAY_PROTO] = "tcp"; 187edb267a6SChuck Lever 188edb267a6SChuck Lever buf = kzalloc(48, GFP_KERNEL); 189edb267a6SChuck Lever if (buf) { 190edb267a6SChuck Lever snprintf(buf, 48, "addr=%u.%u.%u.%u port=%u proto=%s", 191edb267a6SChuck Lever NIPQUAD(addr->sin_addr.s_addr), 192edb267a6SChuck Lever ntohs(addr->sin_port), 193edb267a6SChuck Lever xprt->prot == IPPROTO_UDP ? "udp" : "tcp"); 194edb267a6SChuck Lever } 195edb267a6SChuck Lever xprt->address_strings[RPC_DISPLAY_ALL] = buf; 196edb267a6SChuck Lever } 197edb267a6SChuck Lever 198edb267a6SChuck Lever static void xs_free_peer_addresses(struct rpc_xprt *xprt) 199edb267a6SChuck Lever { 200edb267a6SChuck Lever kfree(xprt->address_strings[RPC_DISPLAY_ADDR]); 201edb267a6SChuck Lever kfree(xprt->address_strings[RPC_DISPLAY_PORT]); 202edb267a6SChuck Lever kfree(xprt->address_strings[RPC_DISPLAY_ALL]); 203edb267a6SChuck Lever } 204edb267a6SChuck Lever 205b4b5cc85SChuck Lever #define XS_SENDMSG_FLAGS (MSG_DONTWAIT | MSG_NOSIGNAL) 206b4b5cc85SChuck Lever 20724c5684bSTrond Myklebust static int xs_send_kvec(struct socket *sock, struct sockaddr *addr, int addrlen, struct kvec *vec, unsigned int base, int more) 208b4b5cc85SChuck Lever { 209b4b5cc85SChuck Lever struct msghdr msg = { 210b4b5cc85SChuck Lever .msg_name = addr, 211b4b5cc85SChuck Lever .msg_namelen = addrlen, 21224c5684bSTrond Myklebust .msg_flags = XS_SENDMSG_FLAGS | (more ? MSG_MORE : 0), 21324c5684bSTrond Myklebust }; 21424c5684bSTrond Myklebust struct kvec iov = { 21524c5684bSTrond Myklebust .iov_base = vec->iov_base + base, 21624c5684bSTrond Myklebust .iov_len = vec->iov_len - base, 217b4b5cc85SChuck Lever }; 218b4b5cc85SChuck Lever 21924c5684bSTrond Myklebust if (iov.iov_len != 0) 220b4b5cc85SChuck Lever return kernel_sendmsg(sock, &msg, &iov, 1, iov.iov_len); 221b4b5cc85SChuck Lever return kernel_sendmsg(sock, &msg, NULL, 0, 0); 222b4b5cc85SChuck Lever } 223b4b5cc85SChuck Lever 22424c5684bSTrond Myklebust static int xs_send_pagedata(struct socket *sock, struct xdr_buf *xdr, unsigned int base, int more) 225b4b5cc85SChuck Lever { 22624c5684bSTrond Myklebust struct page **ppage; 22724c5684bSTrond Myklebust unsigned int remainder; 22824c5684bSTrond Myklebust int err, sent = 0; 229b4b5cc85SChuck Lever 23024c5684bSTrond Myklebust remainder = xdr->page_len - base; 23124c5684bSTrond Myklebust base += xdr->page_base; 23224c5684bSTrond Myklebust ppage = xdr->pages + (base >> PAGE_SHIFT); 23324c5684bSTrond Myklebust base &= ~PAGE_MASK; 23424c5684bSTrond Myklebust for(;;) { 23524c5684bSTrond Myklebust unsigned int len = min_t(unsigned int, PAGE_SIZE - base, remainder); 23624c5684bSTrond Myklebust int flags = XS_SENDMSG_FLAGS; 23724c5684bSTrond Myklebust 23824c5684bSTrond Myklebust remainder -= len; 23924c5684bSTrond Myklebust if (remainder != 0 || more) 24024c5684bSTrond Myklebust flags |= MSG_MORE; 24124c5684bSTrond Myklebust err = sock->ops->sendpage(sock, *ppage, base, len, flags); 24224c5684bSTrond Myklebust if (remainder == 0 || err != len) 24324c5684bSTrond Myklebust break; 24424c5684bSTrond Myklebust sent += err; 24524c5684bSTrond Myklebust ppage++; 24624c5684bSTrond Myklebust base = 0; 24724c5684bSTrond Myklebust } 24824c5684bSTrond Myklebust if (sent == 0) 24924c5684bSTrond Myklebust return err; 25024c5684bSTrond Myklebust if (err > 0) 25124c5684bSTrond Myklebust sent += err; 25224c5684bSTrond Myklebust return sent; 253b4b5cc85SChuck Lever } 254b4b5cc85SChuck Lever 2559903cd1cSChuck Lever /** 2569903cd1cSChuck Lever * xs_sendpages - write pages directly to a socket 2579903cd1cSChuck Lever * @sock: socket to send on 2589903cd1cSChuck Lever * @addr: UDP only -- address of destination 2599903cd1cSChuck Lever * @addrlen: UDP only -- length of destination address 2609903cd1cSChuck Lever * @xdr: buffer containing this request 2619903cd1cSChuck Lever * @base: starting position in the buffer 2629903cd1cSChuck Lever * 263a246b010SChuck Lever */ 26424c5684bSTrond Myklebust static int xs_sendpages(struct socket *sock, struct sockaddr *addr, int addrlen, struct xdr_buf *xdr, unsigned int base) 265a246b010SChuck Lever { 26624c5684bSTrond Myklebust unsigned int remainder = xdr->len - base; 26724c5684bSTrond Myklebust int err, sent = 0; 268a246b010SChuck Lever 269262965f5SChuck Lever if (unlikely(!sock)) 270262965f5SChuck Lever return -ENOTCONN; 271262965f5SChuck Lever 272262965f5SChuck Lever clear_bit(SOCK_ASYNC_NOSPACE, &sock->flags); 27324c5684bSTrond Myklebust if (base != 0) { 27424c5684bSTrond Myklebust addr = NULL; 27524c5684bSTrond Myklebust addrlen = 0; 27624c5684bSTrond Myklebust } 277262965f5SChuck Lever 27824c5684bSTrond Myklebust if (base < xdr->head[0].iov_len || addr != NULL) { 27924c5684bSTrond Myklebust unsigned int len = xdr->head[0].iov_len - base; 28024c5684bSTrond Myklebust remainder -= len; 28124c5684bSTrond Myklebust err = xs_send_kvec(sock, addr, addrlen, &xdr->head[0], base, remainder != 0); 28224c5684bSTrond Myklebust if (remainder == 0 || err != len) 283a246b010SChuck Lever goto out; 28424c5684bSTrond Myklebust sent += err; 285a246b010SChuck Lever base = 0; 286a246b010SChuck Lever } else 28724c5684bSTrond Myklebust base -= xdr->head[0].iov_len; 288a246b010SChuck Lever 28924c5684bSTrond Myklebust if (base < xdr->page_len) { 29024c5684bSTrond Myklebust unsigned int len = xdr->page_len - base; 29124c5684bSTrond Myklebust remainder -= len; 29224c5684bSTrond Myklebust err = xs_send_pagedata(sock, xdr, base, remainder != 0); 29324c5684bSTrond Myklebust if (remainder == 0 || err != len) 294a246b010SChuck Lever goto out; 29524c5684bSTrond Myklebust sent += err; 296a246b010SChuck Lever base = 0; 29724c5684bSTrond Myklebust } else 29824c5684bSTrond Myklebust base -= xdr->page_len; 29924c5684bSTrond Myklebust 30024c5684bSTrond Myklebust if (base >= xdr->tail[0].iov_len) 30124c5684bSTrond Myklebust return sent; 30224c5684bSTrond Myklebust err = xs_send_kvec(sock, NULL, 0, &xdr->tail[0], base, 0); 303a246b010SChuck Lever out: 30424c5684bSTrond Myklebust if (sent == 0) 30524c5684bSTrond Myklebust return err; 30624c5684bSTrond Myklebust if (err > 0) 30724c5684bSTrond Myklebust sent += err; 30824c5684bSTrond Myklebust return sent; 309a246b010SChuck Lever } 310a246b010SChuck Lever 3119903cd1cSChuck Lever /** 312262965f5SChuck Lever * xs_nospace - place task on wait queue if transmit was incomplete 313262965f5SChuck Lever * @task: task to put to sleep 3149903cd1cSChuck Lever * 315a246b010SChuck Lever */ 316262965f5SChuck Lever static void xs_nospace(struct rpc_task *task) 317a246b010SChuck Lever { 318262965f5SChuck Lever struct rpc_rqst *req = task->tk_rqstp; 319262965f5SChuck Lever struct rpc_xprt *xprt = req->rq_xprt; 320ee0ac0c2SChuck Lever struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt); 321a246b010SChuck Lever 322262965f5SChuck Lever dprintk("RPC: %4d xmit incomplete (%u left of %u)\n", 323262965f5SChuck Lever task->tk_pid, req->rq_slen - req->rq_bytes_sent, 324262965f5SChuck Lever req->rq_slen); 325a246b010SChuck Lever 326ee0ac0c2SChuck Lever if (test_bit(SOCK_ASYNC_NOSPACE, &transport->sock->flags)) { 327262965f5SChuck Lever /* Protect against races with write_space */ 328262965f5SChuck Lever spin_lock_bh(&xprt->transport_lock); 329a246b010SChuck Lever 330262965f5SChuck Lever /* Don't race with disconnect */ 331262965f5SChuck Lever if (!xprt_connected(xprt)) 332262965f5SChuck Lever task->tk_status = -ENOTCONN; 333ee0ac0c2SChuck Lever else if (test_bit(SOCK_NOSPACE, &transport->sock->flags)) 334262965f5SChuck Lever xprt_wait_for_buffer_space(task); 335a246b010SChuck Lever 336262965f5SChuck Lever spin_unlock_bh(&xprt->transport_lock); 337262965f5SChuck Lever } else 338262965f5SChuck Lever /* Keep holding the socket if it is blocked */ 339262965f5SChuck Lever rpc_delay(task, HZ>>4); 340a246b010SChuck Lever } 341a246b010SChuck Lever 3429903cd1cSChuck Lever /** 343262965f5SChuck Lever * xs_udp_send_request - write an RPC request to a UDP socket 3449903cd1cSChuck Lever * @task: address of RPC task that manages the state of an RPC request 3459903cd1cSChuck Lever * 3469903cd1cSChuck Lever * Return values: 3479903cd1cSChuck Lever * 0: The request has been sent 3489903cd1cSChuck Lever * EAGAIN: The socket was blocked, please call again later to 3499903cd1cSChuck Lever * complete the request 350262965f5SChuck Lever * ENOTCONN: Caller needs to invoke connect logic then call again 3519903cd1cSChuck Lever * other: Some other error occured, the request was not sent 3529903cd1cSChuck Lever */ 353262965f5SChuck Lever static int xs_udp_send_request(struct rpc_task *task) 354a246b010SChuck Lever { 355a246b010SChuck Lever struct rpc_rqst *req = task->tk_rqstp; 356a246b010SChuck Lever struct rpc_xprt *xprt = req->rq_xprt; 357ee0ac0c2SChuck Lever struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt); 358262965f5SChuck Lever struct xdr_buf *xdr = &req->rq_snd_buf; 359262965f5SChuck Lever int status; 360262965f5SChuck Lever 361262965f5SChuck Lever xs_pktdump("packet data:", 362262965f5SChuck Lever req->rq_svec->iov_base, 363262965f5SChuck Lever req->rq_svec->iov_len); 364262965f5SChuck Lever 365262965f5SChuck Lever req->rq_xtime = jiffies; 366ee0ac0c2SChuck Lever status = xs_sendpages(transport->sock, 367ee0ac0c2SChuck Lever (struct sockaddr *) &xprt->addr, 368ee0ac0c2SChuck Lever xprt->addrlen, xdr, 369ee0ac0c2SChuck Lever req->rq_bytes_sent); 370262965f5SChuck Lever 371262965f5SChuck Lever dprintk("RPC: xs_udp_send_request(%u) = %d\n", 372262965f5SChuck Lever xdr->len - req->rq_bytes_sent, status); 373262965f5SChuck Lever 374262965f5SChuck Lever if (likely(status >= (int) req->rq_slen)) 375262965f5SChuck Lever return 0; 376262965f5SChuck Lever 377262965f5SChuck Lever /* Still some bytes left; set up for a retry later. */ 378262965f5SChuck Lever if (status > 0) 379262965f5SChuck Lever status = -EAGAIN; 380262965f5SChuck Lever 381262965f5SChuck Lever switch (status) { 382262965f5SChuck Lever case -ENETUNREACH: 383262965f5SChuck Lever case -EPIPE: 384262965f5SChuck Lever case -ECONNREFUSED: 385262965f5SChuck Lever /* When the server has died, an ICMP port unreachable message 386262965f5SChuck Lever * prompts ECONNREFUSED. */ 387262965f5SChuck Lever break; 388262965f5SChuck Lever case -EAGAIN: 389262965f5SChuck Lever xs_nospace(task); 390262965f5SChuck Lever break; 391262965f5SChuck Lever default: 392262965f5SChuck Lever dprintk("RPC: sendmsg returned unrecognized error %d\n", 393262965f5SChuck Lever -status); 394262965f5SChuck Lever break; 395262965f5SChuck Lever } 396262965f5SChuck Lever 397262965f5SChuck Lever return status; 398262965f5SChuck Lever } 399262965f5SChuck Lever 400808012fbSChuck Lever static inline void xs_encode_tcp_record_marker(struct xdr_buf *buf) 401808012fbSChuck Lever { 402808012fbSChuck Lever u32 reclen = buf->len - sizeof(rpc_fraghdr); 403808012fbSChuck Lever rpc_fraghdr *base = buf->head[0].iov_base; 404808012fbSChuck Lever *base = htonl(RPC_LAST_STREAM_FRAGMENT | reclen); 405808012fbSChuck Lever } 406808012fbSChuck Lever 407262965f5SChuck Lever /** 408262965f5SChuck Lever * xs_tcp_send_request - write an RPC request to a TCP socket 409262965f5SChuck Lever * @task: address of RPC task that manages the state of an RPC request 410262965f5SChuck Lever * 411262965f5SChuck Lever * Return values: 412262965f5SChuck Lever * 0: The request has been sent 413262965f5SChuck Lever * EAGAIN: The socket was blocked, please call again later to 414262965f5SChuck Lever * complete the request 415262965f5SChuck Lever * ENOTCONN: Caller needs to invoke connect logic then call again 416262965f5SChuck Lever * other: Some other error occured, the request was not sent 417262965f5SChuck Lever * 418262965f5SChuck Lever * XXX: In the case of soft timeouts, should we eventually give up 419262965f5SChuck Lever * if sendmsg is not able to make progress? 420262965f5SChuck Lever */ 421262965f5SChuck Lever static int xs_tcp_send_request(struct rpc_task *task) 422262965f5SChuck Lever { 423262965f5SChuck Lever struct rpc_rqst *req = task->tk_rqstp; 424262965f5SChuck Lever struct rpc_xprt *xprt = req->rq_xprt; 425ee0ac0c2SChuck Lever struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt); 426262965f5SChuck Lever struct xdr_buf *xdr = &req->rq_snd_buf; 427a246b010SChuck Lever int status, retry = 0; 428a246b010SChuck Lever 429808012fbSChuck Lever xs_encode_tcp_record_marker(&req->rq_snd_buf); 430262965f5SChuck Lever 431262965f5SChuck Lever xs_pktdump("packet data:", 432262965f5SChuck Lever req->rq_svec->iov_base, 433262965f5SChuck Lever req->rq_svec->iov_len); 434a246b010SChuck Lever 435a246b010SChuck Lever /* Continue transmitting the packet/record. We must be careful 436a246b010SChuck Lever * to cope with writespace callbacks arriving _after_ we have 437262965f5SChuck Lever * called sendmsg(). */ 438a246b010SChuck Lever while (1) { 439a246b010SChuck Lever req->rq_xtime = jiffies; 440ee0ac0c2SChuck Lever status = xs_sendpages(transport->sock, 441ee0ac0c2SChuck Lever NULL, 0, xdr, req->rq_bytes_sent); 442a246b010SChuck Lever 443262965f5SChuck Lever dprintk("RPC: xs_tcp_send_request(%u) = %d\n", 444262965f5SChuck Lever xdr->len - req->rq_bytes_sent, status); 445262965f5SChuck Lever 446262965f5SChuck Lever if (unlikely(status < 0)) 447a246b010SChuck Lever break; 448a246b010SChuck Lever 449a246b010SChuck Lever /* If we've sent the entire packet, immediately 450a246b010SChuck Lever * reset the count of bytes sent. */ 451262965f5SChuck Lever req->rq_bytes_sent += status; 452ef759a2eSChuck Lever task->tk_bytes_sent += status; 453262965f5SChuck Lever if (likely(req->rq_bytes_sent >= req->rq_slen)) { 454a246b010SChuck Lever req->rq_bytes_sent = 0; 455a246b010SChuck Lever return 0; 456a246b010SChuck Lever } 457262965f5SChuck Lever 458a246b010SChuck Lever status = -EAGAIN; 459262965f5SChuck Lever if (retry++ > XS_SENDMSG_RETRY) 460a246b010SChuck Lever break; 461a246b010SChuck Lever } 462a246b010SChuck Lever 463262965f5SChuck Lever switch (status) { 464262965f5SChuck Lever case -EAGAIN: 465262965f5SChuck Lever xs_nospace(task); 466262965f5SChuck Lever break; 467262965f5SChuck Lever case -ECONNREFUSED: 468262965f5SChuck Lever case -ECONNRESET: 469262965f5SChuck Lever case -ENOTCONN: 470262965f5SChuck Lever case -EPIPE: 471262965f5SChuck Lever status = -ENOTCONN; 472262965f5SChuck Lever break; 473262965f5SChuck Lever default: 474262965f5SChuck Lever dprintk("RPC: sendmsg returned unrecognized error %d\n", 475262965f5SChuck Lever -status); 47643118c29SChuck Lever xprt_disconnect(xprt); 477a246b010SChuck Lever break; 478a246b010SChuck Lever } 479a246b010SChuck Lever 480a246b010SChuck Lever return status; 481a246b010SChuck Lever } 482a246b010SChuck Lever 4839903cd1cSChuck Lever /** 484e0ab53deSTrond Myklebust * xs_tcp_release_xprt - clean up after a tcp transmission 485e0ab53deSTrond Myklebust * @xprt: transport 486e0ab53deSTrond Myklebust * @task: rpc task 487e0ab53deSTrond Myklebust * 488e0ab53deSTrond Myklebust * This cleans up if an error causes us to abort the transmission of a request. 489e0ab53deSTrond Myklebust * In this case, the socket may need to be reset in order to avoid confusing 490e0ab53deSTrond Myklebust * the server. 491e0ab53deSTrond Myklebust */ 492e0ab53deSTrond Myklebust static void xs_tcp_release_xprt(struct rpc_xprt *xprt, struct rpc_task *task) 493e0ab53deSTrond Myklebust { 494e0ab53deSTrond Myklebust struct rpc_rqst *req; 495e0ab53deSTrond Myklebust 496e0ab53deSTrond Myklebust if (task != xprt->snd_task) 497e0ab53deSTrond Myklebust return; 498e0ab53deSTrond Myklebust if (task == NULL) 499e0ab53deSTrond Myklebust goto out_release; 500e0ab53deSTrond Myklebust req = task->tk_rqstp; 501e0ab53deSTrond Myklebust if (req->rq_bytes_sent == 0) 502e0ab53deSTrond Myklebust goto out_release; 503e0ab53deSTrond Myklebust if (req->rq_bytes_sent == req->rq_snd_buf.len) 504e0ab53deSTrond Myklebust goto out_release; 505e0ab53deSTrond Myklebust set_bit(XPRT_CLOSE_WAIT, &task->tk_xprt->state); 506e0ab53deSTrond Myklebust out_release: 507e0ab53deSTrond Myklebust xprt_release_xprt(xprt, task); 508e0ab53deSTrond Myklebust } 509e0ab53deSTrond Myklebust 510e0ab53deSTrond Myklebust /** 5119903cd1cSChuck Lever * xs_close - close a socket 5129903cd1cSChuck Lever * @xprt: transport 5139903cd1cSChuck Lever * 5143167e12cSChuck Lever * This is used when all requests are complete; ie, no DRC state remains 5153167e12cSChuck Lever * on the server we want to save. 516a246b010SChuck Lever */ 5179903cd1cSChuck Lever static void xs_close(struct rpc_xprt *xprt) 518a246b010SChuck Lever { 519ee0ac0c2SChuck Lever struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt); 520ee0ac0c2SChuck Lever struct socket *sock = transport->sock; 521ee0ac0c2SChuck Lever struct sock *sk = transport->inet; 522a246b010SChuck Lever 523a246b010SChuck Lever if (!sk) 524632e3bdcSTrond Myklebust goto clear_close_wait; 525a246b010SChuck Lever 5269903cd1cSChuck Lever dprintk("RPC: xs_close xprt %p\n", xprt); 5279903cd1cSChuck Lever 528a246b010SChuck Lever write_lock_bh(&sk->sk_callback_lock); 529ee0ac0c2SChuck Lever transport->inet = NULL; 530ee0ac0c2SChuck Lever transport->sock = NULL; 531a246b010SChuck Lever 532a246b010SChuck Lever sk->sk_user_data = NULL; 533a246b010SChuck Lever sk->sk_data_ready = xprt->old_data_ready; 534a246b010SChuck Lever sk->sk_state_change = xprt->old_state_change; 535a246b010SChuck Lever sk->sk_write_space = xprt->old_write_space; 536a246b010SChuck Lever write_unlock_bh(&sk->sk_callback_lock); 537a246b010SChuck Lever 538a246b010SChuck Lever sk->sk_no_check = 0; 539a246b010SChuck Lever 540a246b010SChuck Lever sock_release(sock); 541632e3bdcSTrond Myklebust clear_close_wait: 542632e3bdcSTrond Myklebust smp_mb__before_clear_bit(); 543632e3bdcSTrond Myklebust clear_bit(XPRT_CLOSE_WAIT, &xprt->state); 544632e3bdcSTrond Myklebust smp_mb__after_clear_bit(); 545a246b010SChuck Lever } 546a246b010SChuck Lever 5479903cd1cSChuck Lever /** 5489903cd1cSChuck Lever * xs_destroy - prepare to shutdown a transport 5499903cd1cSChuck Lever * @xprt: doomed transport 5509903cd1cSChuck Lever * 5519903cd1cSChuck Lever */ 5529903cd1cSChuck Lever static void xs_destroy(struct rpc_xprt *xprt) 553a246b010SChuck Lever { 554c8475461SChuck Lever struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt); 555c8475461SChuck Lever 5569903cd1cSChuck Lever dprintk("RPC: xs_destroy xprt %p\n", xprt); 5579903cd1cSChuck Lever 558c8475461SChuck Lever cancel_delayed_work(&transport->connect_worker); 559a246b010SChuck Lever flush_scheduled_work(); 560a246b010SChuck Lever 561a246b010SChuck Lever xprt_disconnect(xprt); 5629903cd1cSChuck Lever xs_close(xprt); 563edb267a6SChuck Lever xs_free_peer_addresses(xprt); 564a246b010SChuck Lever kfree(xprt->slot); 565c8541ecdSChuck Lever kfree(xprt); 566a246b010SChuck Lever } 567a246b010SChuck Lever 5689903cd1cSChuck Lever static inline struct rpc_xprt *xprt_from_sock(struct sock *sk) 5699903cd1cSChuck Lever { 5709903cd1cSChuck Lever return (struct rpc_xprt *) sk->sk_user_data; 5719903cd1cSChuck Lever } 5729903cd1cSChuck Lever 5739903cd1cSChuck Lever /** 5749903cd1cSChuck Lever * xs_udp_data_ready - "data ready" callback for UDP sockets 5759903cd1cSChuck Lever * @sk: socket with data to read 5769903cd1cSChuck Lever * @len: how much data to read 5779903cd1cSChuck Lever * 578a246b010SChuck Lever */ 5799903cd1cSChuck Lever static void xs_udp_data_ready(struct sock *sk, int len) 580a246b010SChuck Lever { 581a246b010SChuck Lever struct rpc_task *task; 582a246b010SChuck Lever struct rpc_xprt *xprt; 583a246b010SChuck Lever struct rpc_rqst *rovr; 584a246b010SChuck Lever struct sk_buff *skb; 585a246b010SChuck Lever int err, repsize, copied; 586d8ed029dSAlexey Dobriyan u32 _xid; 587d8ed029dSAlexey Dobriyan __be32 *xp; 588a246b010SChuck Lever 589a246b010SChuck Lever read_lock(&sk->sk_callback_lock); 5909903cd1cSChuck Lever dprintk("RPC: xs_udp_data_ready...\n"); 5919903cd1cSChuck Lever if (!(xprt = xprt_from_sock(sk))) 592a246b010SChuck Lever goto out; 593a246b010SChuck Lever 594a246b010SChuck Lever if ((skb = skb_recv_datagram(sk, 0, 1, &err)) == NULL) 595a246b010SChuck Lever goto out; 596a246b010SChuck Lever 597a246b010SChuck Lever if (xprt->shutdown) 598a246b010SChuck Lever goto dropit; 599a246b010SChuck Lever 600a246b010SChuck Lever repsize = skb->len - sizeof(struct udphdr); 601a246b010SChuck Lever if (repsize < 4) { 6029903cd1cSChuck Lever dprintk("RPC: impossible RPC reply size %d!\n", repsize); 603a246b010SChuck Lever goto dropit; 604a246b010SChuck Lever } 605a246b010SChuck Lever 606a246b010SChuck Lever /* Copy the XID from the skb... */ 607a246b010SChuck Lever xp = skb_header_pointer(skb, sizeof(struct udphdr), 608a246b010SChuck Lever sizeof(_xid), &_xid); 609a246b010SChuck Lever if (xp == NULL) 610a246b010SChuck Lever goto dropit; 611a246b010SChuck Lever 612a246b010SChuck Lever /* Look up and lock the request corresponding to the given XID */ 6134a0f8c04SChuck Lever spin_lock(&xprt->transport_lock); 614a246b010SChuck Lever rovr = xprt_lookup_rqst(xprt, *xp); 615a246b010SChuck Lever if (!rovr) 616a246b010SChuck Lever goto out_unlock; 617a246b010SChuck Lever task = rovr->rq_task; 618a246b010SChuck Lever 619a246b010SChuck Lever if ((copied = rovr->rq_private_buf.buflen) > repsize) 620a246b010SChuck Lever copied = repsize; 621a246b010SChuck Lever 622a246b010SChuck Lever /* Suck it into the iovec, verify checksum if not done by hw. */ 623a246b010SChuck Lever if (csum_partial_copy_to_xdr(&rovr->rq_private_buf, skb)) 624a246b010SChuck Lever goto out_unlock; 625a246b010SChuck Lever 626a246b010SChuck Lever /* Something worked... */ 627a246b010SChuck Lever dst_confirm(skb->dst); 628a246b010SChuck Lever 6291570c1e4SChuck Lever xprt_adjust_cwnd(task, copied); 6301570c1e4SChuck Lever xprt_update_rtt(task); 6311570c1e4SChuck Lever xprt_complete_rqst(task, copied); 632a246b010SChuck Lever 633a246b010SChuck Lever out_unlock: 6344a0f8c04SChuck Lever spin_unlock(&xprt->transport_lock); 635a246b010SChuck Lever dropit: 636a246b010SChuck Lever skb_free_datagram(sk, skb); 637a246b010SChuck Lever out: 638a246b010SChuck Lever read_unlock(&sk->sk_callback_lock); 639a246b010SChuck Lever } 640a246b010SChuck Lever 6419903cd1cSChuck Lever static inline size_t xs_tcp_copy_data(skb_reader_t *desc, void *p, size_t len) 642a246b010SChuck Lever { 643a246b010SChuck Lever if (len > desc->count) 644a246b010SChuck Lever len = desc->count; 645a246b010SChuck Lever if (skb_copy_bits(desc->skb, desc->offset, p, len)) { 646a246b010SChuck Lever dprintk("RPC: failed to copy %zu bytes from skb. %zu bytes remain\n", 647a246b010SChuck Lever len, desc->count); 648a246b010SChuck Lever return 0; 649a246b010SChuck Lever } 650a246b010SChuck Lever desc->offset += len; 651a246b010SChuck Lever desc->count -= len; 652a246b010SChuck Lever dprintk("RPC: copied %zu bytes from skb. %zu bytes remain\n", 653a246b010SChuck Lever len, desc->count); 654a246b010SChuck Lever return len; 655a246b010SChuck Lever } 656a246b010SChuck Lever 6579903cd1cSChuck Lever static inline void xs_tcp_read_fraghdr(struct rpc_xprt *xprt, skb_reader_t *desc) 658a246b010SChuck Lever { 65951971139SChuck Lever struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt); 660a246b010SChuck Lever size_t len, used; 661a246b010SChuck Lever char *p; 662a246b010SChuck Lever 66351971139SChuck Lever p = ((char *) &transport->tcp_fraghdr) + transport->tcp_offset; 66451971139SChuck Lever len = sizeof(transport->tcp_fraghdr) - transport->tcp_offset; 6659903cd1cSChuck Lever used = xs_tcp_copy_data(desc, p, len); 66651971139SChuck Lever transport->tcp_offset += used; 667a246b010SChuck Lever if (used != len) 668a246b010SChuck Lever return; 669808012fbSChuck Lever 67051971139SChuck Lever transport->tcp_reclen = ntohl(transport->tcp_fraghdr); 67151971139SChuck Lever if (transport->tcp_reclen & RPC_LAST_STREAM_FRAGMENT) 672e136d092SChuck Lever transport->tcp_flags |= TCP_RCV_LAST_FRAG; 673a246b010SChuck Lever else 674e136d092SChuck Lever transport->tcp_flags &= ~TCP_RCV_LAST_FRAG; 67551971139SChuck Lever transport->tcp_reclen &= RPC_FRAGMENT_SIZE_MASK; 676808012fbSChuck Lever 677e136d092SChuck Lever transport->tcp_flags &= ~TCP_RCV_COPY_FRAGHDR; 67851971139SChuck Lever transport->tcp_offset = 0; 679808012fbSChuck Lever 680a246b010SChuck Lever /* Sanity check of the record length */ 68151971139SChuck Lever if (unlikely(transport->tcp_reclen < 4)) { 6829903cd1cSChuck Lever dprintk("RPC: invalid TCP record fragment length\n"); 683a246b010SChuck Lever xprt_disconnect(xprt); 6849903cd1cSChuck Lever return; 685a246b010SChuck Lever } 686a246b010SChuck Lever dprintk("RPC: reading TCP record fragment of length %d\n", 68751971139SChuck Lever transport->tcp_reclen); 688a246b010SChuck Lever } 689a246b010SChuck Lever 69051971139SChuck Lever static void xs_tcp_check_fraghdr(struct sock_xprt *transport) 691a246b010SChuck Lever { 69251971139SChuck Lever if (transport->tcp_offset == transport->tcp_reclen) { 693e136d092SChuck Lever transport->tcp_flags |= TCP_RCV_COPY_FRAGHDR; 69451971139SChuck Lever transport->tcp_offset = 0; 695e136d092SChuck Lever if (transport->tcp_flags & TCP_RCV_LAST_FRAG) { 696e136d092SChuck Lever transport->tcp_flags &= ~TCP_RCV_COPY_DATA; 697e136d092SChuck Lever transport->tcp_flags |= TCP_RCV_COPY_XID; 69851971139SChuck Lever transport->tcp_copied = 0; 699a246b010SChuck Lever } 700a246b010SChuck Lever } 701a246b010SChuck Lever } 702a246b010SChuck Lever 70351971139SChuck Lever static inline void xs_tcp_read_xid(struct sock_xprt *transport, skb_reader_t *desc) 704a246b010SChuck Lever { 705a246b010SChuck Lever size_t len, used; 706a246b010SChuck Lever char *p; 707a246b010SChuck Lever 70851971139SChuck Lever len = sizeof(transport->tcp_xid) - transport->tcp_offset; 709a246b010SChuck Lever dprintk("RPC: reading XID (%Zu bytes)\n", len); 71051971139SChuck Lever p = ((char *) &transport->tcp_xid) + transport->tcp_offset; 7119903cd1cSChuck Lever used = xs_tcp_copy_data(desc, p, len); 71251971139SChuck Lever transport->tcp_offset += used; 713a246b010SChuck Lever if (used != len) 714a246b010SChuck Lever return; 715e136d092SChuck Lever transport->tcp_flags &= ~TCP_RCV_COPY_XID; 716e136d092SChuck Lever transport->tcp_flags |= TCP_RCV_COPY_DATA; 71751971139SChuck Lever transport->tcp_copied = 4; 718a246b010SChuck Lever dprintk("RPC: reading reply for XID %08x\n", 71951971139SChuck Lever ntohl(transport->tcp_xid)); 72051971139SChuck Lever xs_tcp_check_fraghdr(transport); 721a246b010SChuck Lever } 722a246b010SChuck Lever 7239903cd1cSChuck Lever static inline void xs_tcp_read_request(struct rpc_xprt *xprt, skb_reader_t *desc) 724a246b010SChuck Lever { 72551971139SChuck Lever struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt); 726a246b010SChuck Lever struct rpc_rqst *req; 727a246b010SChuck Lever struct xdr_buf *rcvbuf; 728a246b010SChuck Lever size_t len; 729a246b010SChuck Lever ssize_t r; 730a246b010SChuck Lever 731a246b010SChuck Lever /* Find and lock the request corresponding to this xid */ 7324a0f8c04SChuck Lever spin_lock(&xprt->transport_lock); 73351971139SChuck Lever req = xprt_lookup_rqst(xprt, transport->tcp_xid); 734a246b010SChuck Lever if (!req) { 735e136d092SChuck Lever transport->tcp_flags &= ~TCP_RCV_COPY_DATA; 736a246b010SChuck Lever dprintk("RPC: XID %08x request not found!\n", 73751971139SChuck Lever ntohl(transport->tcp_xid)); 7384a0f8c04SChuck Lever spin_unlock(&xprt->transport_lock); 739a246b010SChuck Lever return; 740a246b010SChuck Lever } 741a246b010SChuck Lever 742a246b010SChuck Lever rcvbuf = &req->rq_private_buf; 743a246b010SChuck Lever len = desc->count; 74451971139SChuck Lever if (len > transport->tcp_reclen - transport->tcp_offset) { 745a246b010SChuck Lever skb_reader_t my_desc; 746a246b010SChuck Lever 74751971139SChuck Lever len = transport->tcp_reclen - transport->tcp_offset; 748a246b010SChuck Lever memcpy(&my_desc, desc, sizeof(my_desc)); 749a246b010SChuck Lever my_desc.count = len; 75051971139SChuck Lever r = xdr_partial_copy_from_skb(rcvbuf, transport->tcp_copied, 7519903cd1cSChuck Lever &my_desc, xs_tcp_copy_data); 752a246b010SChuck Lever desc->count -= r; 753a246b010SChuck Lever desc->offset += r; 754a246b010SChuck Lever } else 75551971139SChuck Lever r = xdr_partial_copy_from_skb(rcvbuf, transport->tcp_copied, 7569903cd1cSChuck Lever desc, xs_tcp_copy_data); 757a246b010SChuck Lever 758a246b010SChuck Lever if (r > 0) { 75951971139SChuck Lever transport->tcp_copied += r; 76051971139SChuck Lever transport->tcp_offset += r; 761a246b010SChuck Lever } 762a246b010SChuck Lever if (r != len) { 763a246b010SChuck Lever /* Error when copying to the receive buffer, 764a246b010SChuck Lever * usually because we weren't able to allocate 765a246b010SChuck Lever * additional buffer pages. All we can do now 766e136d092SChuck Lever * is turn off TCP_RCV_COPY_DATA, so the request 767a246b010SChuck Lever * will not receive any additional updates, 768a246b010SChuck Lever * and time out. 769a246b010SChuck Lever * Any remaining data from this record will 770a246b010SChuck Lever * be discarded. 771a246b010SChuck Lever */ 772e136d092SChuck Lever transport->tcp_flags &= ~TCP_RCV_COPY_DATA; 773a246b010SChuck Lever dprintk("RPC: XID %08x truncated request\n", 77451971139SChuck Lever ntohl(transport->tcp_xid)); 775a246b010SChuck Lever dprintk("RPC: xprt = %p, tcp_copied = %lu, tcp_offset = %u, tcp_reclen = %u\n", 77651971139SChuck Lever xprt, transport->tcp_copied, transport->tcp_offset, 77751971139SChuck Lever transport->tcp_reclen); 778a246b010SChuck Lever goto out; 779a246b010SChuck Lever } 780a246b010SChuck Lever 781a246b010SChuck Lever dprintk("RPC: XID %08x read %Zd bytes\n", 78251971139SChuck Lever ntohl(transport->tcp_xid), r); 783a246b010SChuck Lever dprintk("RPC: xprt = %p, tcp_copied = %lu, tcp_offset = %u, tcp_reclen = %u\n", 78451971139SChuck Lever xprt, transport->tcp_copied, transport->tcp_offset, 78551971139SChuck Lever transport->tcp_reclen); 786a246b010SChuck Lever 78751971139SChuck Lever if (transport->tcp_copied == req->rq_private_buf.buflen) 788e136d092SChuck Lever transport->tcp_flags &= ~TCP_RCV_COPY_DATA; 78951971139SChuck Lever else if (transport->tcp_offset == transport->tcp_reclen) { 790e136d092SChuck Lever if (transport->tcp_flags & TCP_RCV_LAST_FRAG) 791e136d092SChuck Lever transport->tcp_flags &= ~TCP_RCV_COPY_DATA; 792a246b010SChuck Lever } 793a246b010SChuck Lever 794a246b010SChuck Lever out: 795e136d092SChuck Lever if (!(transport->tcp_flags & TCP_RCV_COPY_DATA)) 79651971139SChuck Lever xprt_complete_rqst(req->rq_task, transport->tcp_copied); 7974a0f8c04SChuck Lever spin_unlock(&xprt->transport_lock); 79851971139SChuck Lever xs_tcp_check_fraghdr(transport); 799a246b010SChuck Lever } 800a246b010SChuck Lever 80151971139SChuck Lever static inline void xs_tcp_read_discard(struct sock_xprt *transport, skb_reader_t *desc) 802a246b010SChuck Lever { 803a246b010SChuck Lever size_t len; 804a246b010SChuck Lever 80551971139SChuck Lever len = transport->tcp_reclen - transport->tcp_offset; 806a246b010SChuck Lever if (len > desc->count) 807a246b010SChuck Lever len = desc->count; 808a246b010SChuck Lever desc->count -= len; 809a246b010SChuck Lever desc->offset += len; 81051971139SChuck Lever transport->tcp_offset += len; 811a246b010SChuck Lever dprintk("RPC: discarded %Zu bytes\n", len); 81251971139SChuck Lever xs_tcp_check_fraghdr(transport); 813a246b010SChuck Lever } 814a246b010SChuck Lever 8159903cd1cSChuck Lever static int xs_tcp_data_recv(read_descriptor_t *rd_desc, struct sk_buff *skb, unsigned int offset, size_t len) 816a246b010SChuck Lever { 817a246b010SChuck Lever struct rpc_xprt *xprt = rd_desc->arg.data; 81851971139SChuck Lever struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt); 819a246b010SChuck Lever skb_reader_t desc = { 820a246b010SChuck Lever .skb = skb, 821a246b010SChuck Lever .offset = offset, 822a246b010SChuck Lever .count = len, 823a246b010SChuck Lever }; 824a246b010SChuck Lever 8259903cd1cSChuck Lever dprintk("RPC: xs_tcp_data_recv started\n"); 826a246b010SChuck Lever do { 827a246b010SChuck Lever /* Read in a new fragment marker if necessary */ 828a246b010SChuck Lever /* Can we ever really expect to get completely empty fragments? */ 829e136d092SChuck Lever if (transport->tcp_flags & TCP_RCV_COPY_FRAGHDR) { 8309903cd1cSChuck Lever xs_tcp_read_fraghdr(xprt, &desc); 831a246b010SChuck Lever continue; 832a246b010SChuck Lever } 833a246b010SChuck Lever /* Read in the xid if necessary */ 834e136d092SChuck Lever if (transport->tcp_flags & TCP_RCV_COPY_XID) { 83551971139SChuck Lever xs_tcp_read_xid(transport, &desc); 836a246b010SChuck Lever continue; 837a246b010SChuck Lever } 838a246b010SChuck Lever /* Read in the request data */ 839e136d092SChuck Lever if (transport->tcp_flags & TCP_RCV_COPY_DATA) { 8409903cd1cSChuck Lever xs_tcp_read_request(xprt, &desc); 841a246b010SChuck Lever continue; 842a246b010SChuck Lever } 843a246b010SChuck Lever /* Skip over any trailing bytes on short reads */ 84451971139SChuck Lever xs_tcp_read_discard(transport, &desc); 845a246b010SChuck Lever } while (desc.count); 8469903cd1cSChuck Lever dprintk("RPC: xs_tcp_data_recv done\n"); 847a246b010SChuck Lever return len - desc.count; 848a246b010SChuck Lever } 849a246b010SChuck Lever 8509903cd1cSChuck Lever /** 8519903cd1cSChuck Lever * xs_tcp_data_ready - "data ready" callback for TCP sockets 8529903cd1cSChuck Lever * @sk: socket with data to read 8539903cd1cSChuck Lever * @bytes: how much data to read 8549903cd1cSChuck Lever * 8559903cd1cSChuck Lever */ 8569903cd1cSChuck Lever static void xs_tcp_data_ready(struct sock *sk, int bytes) 857a246b010SChuck Lever { 858a246b010SChuck Lever struct rpc_xprt *xprt; 859a246b010SChuck Lever read_descriptor_t rd_desc; 860a246b010SChuck Lever 861a246b010SChuck Lever read_lock(&sk->sk_callback_lock); 8629903cd1cSChuck Lever dprintk("RPC: xs_tcp_data_ready...\n"); 8639903cd1cSChuck Lever if (!(xprt = xprt_from_sock(sk))) 864a246b010SChuck Lever goto out; 865a246b010SChuck Lever if (xprt->shutdown) 866a246b010SChuck Lever goto out; 867a246b010SChuck Lever 8689903cd1cSChuck Lever /* We use rd_desc to pass struct xprt to xs_tcp_data_recv */ 869a246b010SChuck Lever rd_desc.arg.data = xprt; 870a246b010SChuck Lever rd_desc.count = 65536; 8719903cd1cSChuck Lever tcp_read_sock(sk, &rd_desc, xs_tcp_data_recv); 872a246b010SChuck Lever out: 873a246b010SChuck Lever read_unlock(&sk->sk_callback_lock); 874a246b010SChuck Lever } 875a246b010SChuck Lever 8769903cd1cSChuck Lever /** 8779903cd1cSChuck Lever * xs_tcp_state_change - callback to handle TCP socket state changes 8789903cd1cSChuck Lever * @sk: socket whose state has changed 8799903cd1cSChuck Lever * 8809903cd1cSChuck Lever */ 8819903cd1cSChuck Lever static void xs_tcp_state_change(struct sock *sk) 882a246b010SChuck Lever { 883a246b010SChuck Lever struct rpc_xprt *xprt; 884a246b010SChuck Lever 885a246b010SChuck Lever read_lock(&sk->sk_callback_lock); 886a246b010SChuck Lever if (!(xprt = xprt_from_sock(sk))) 887a246b010SChuck Lever goto out; 8889903cd1cSChuck Lever dprintk("RPC: xs_tcp_state_change client %p...\n", xprt); 889a246b010SChuck Lever dprintk("RPC: state %x conn %d dead %d zapped %d\n", 890a246b010SChuck Lever sk->sk_state, xprt_connected(xprt), 891a246b010SChuck Lever sock_flag(sk, SOCK_DEAD), 892a246b010SChuck Lever sock_flag(sk, SOCK_ZAPPED)); 893a246b010SChuck Lever 894a246b010SChuck Lever switch (sk->sk_state) { 895a246b010SChuck Lever case TCP_ESTABLISHED: 8964a0f8c04SChuck Lever spin_lock_bh(&xprt->transport_lock); 897a246b010SChuck Lever if (!xprt_test_and_set_connected(xprt)) { 89851971139SChuck Lever struct sock_xprt *transport = container_of(xprt, 89951971139SChuck Lever struct sock_xprt, xprt); 90051971139SChuck Lever 901a246b010SChuck Lever /* Reset TCP record info */ 90251971139SChuck Lever transport->tcp_offset = 0; 90351971139SChuck Lever transport->tcp_reclen = 0; 90451971139SChuck Lever transport->tcp_copied = 0; 905e136d092SChuck Lever transport->tcp_flags = 906e136d092SChuck Lever TCP_RCV_COPY_FRAGHDR | TCP_RCV_COPY_XID; 90751971139SChuck Lever 90803bf4b70SChuck Lever xprt->reestablish_timeout = XS_TCP_INIT_REEST_TO; 90944fbac22SChuck Lever xprt_wake_pending_tasks(xprt, 0); 910a246b010SChuck Lever } 9114a0f8c04SChuck Lever spin_unlock_bh(&xprt->transport_lock); 912a246b010SChuck Lever break; 913a246b010SChuck Lever case TCP_SYN_SENT: 914a246b010SChuck Lever case TCP_SYN_RECV: 915a246b010SChuck Lever break; 916632e3bdcSTrond Myklebust case TCP_CLOSE_WAIT: 917632e3bdcSTrond Myklebust /* Try to schedule an autoclose RPC calls */ 918632e3bdcSTrond Myklebust set_bit(XPRT_CLOSE_WAIT, &xprt->state); 919632e3bdcSTrond Myklebust if (test_and_set_bit(XPRT_LOCKED, &xprt->state) == 0) 920632e3bdcSTrond Myklebust schedule_work(&xprt->task_cleanup); 921a246b010SChuck Lever default: 922a246b010SChuck Lever xprt_disconnect(xprt); 923a246b010SChuck Lever } 924a246b010SChuck Lever out: 925a246b010SChuck Lever read_unlock(&sk->sk_callback_lock); 926a246b010SChuck Lever } 927a246b010SChuck Lever 9289903cd1cSChuck Lever /** 929c7b2cae8SChuck Lever * xs_udp_write_space - callback invoked when socket buffer space 930c7b2cae8SChuck Lever * becomes available 9319903cd1cSChuck Lever * @sk: socket whose state has changed 9329903cd1cSChuck Lever * 933a246b010SChuck Lever * Called when more output buffer space is available for this socket. 934a246b010SChuck Lever * We try not to wake our writers until they can make "significant" 935c7b2cae8SChuck Lever * progress, otherwise we'll waste resources thrashing kernel_sendmsg 936a246b010SChuck Lever * with a bunch of small requests. 937a246b010SChuck Lever */ 938c7b2cae8SChuck Lever static void xs_udp_write_space(struct sock *sk) 939a246b010SChuck Lever { 940a246b010SChuck Lever read_lock(&sk->sk_callback_lock); 941c7b2cae8SChuck Lever 942c7b2cae8SChuck Lever /* from net/core/sock.c:sock_def_write_space */ 943c7b2cae8SChuck Lever if (sock_writeable(sk)) { 944c7b2cae8SChuck Lever struct socket *sock; 945c7b2cae8SChuck Lever struct rpc_xprt *xprt; 946c7b2cae8SChuck Lever 947c7b2cae8SChuck Lever if (unlikely(!(sock = sk->sk_socket))) 948a246b010SChuck Lever goto out; 949c7b2cae8SChuck Lever if (unlikely(!(xprt = xprt_from_sock(sk)))) 950c7b2cae8SChuck Lever goto out; 951c7b2cae8SChuck Lever if (unlikely(!test_and_clear_bit(SOCK_NOSPACE, &sock->flags))) 952a246b010SChuck Lever goto out; 953a246b010SChuck Lever 954c7b2cae8SChuck Lever xprt_write_space(xprt); 955a246b010SChuck Lever } 956a246b010SChuck Lever 957c7b2cae8SChuck Lever out: 958c7b2cae8SChuck Lever read_unlock(&sk->sk_callback_lock); 959c7b2cae8SChuck Lever } 960c7b2cae8SChuck Lever 961c7b2cae8SChuck Lever /** 962c7b2cae8SChuck Lever * xs_tcp_write_space - callback invoked when socket buffer space 963c7b2cae8SChuck Lever * becomes available 964c7b2cae8SChuck Lever * @sk: socket whose state has changed 965c7b2cae8SChuck Lever * 966c7b2cae8SChuck Lever * Called when more output buffer space is available for this socket. 967c7b2cae8SChuck Lever * We try not to wake our writers until they can make "significant" 968c7b2cae8SChuck Lever * progress, otherwise we'll waste resources thrashing kernel_sendmsg 969c7b2cae8SChuck Lever * with a bunch of small requests. 970c7b2cae8SChuck Lever */ 971c7b2cae8SChuck Lever static void xs_tcp_write_space(struct sock *sk) 972c7b2cae8SChuck Lever { 973c7b2cae8SChuck Lever read_lock(&sk->sk_callback_lock); 974c7b2cae8SChuck Lever 975c7b2cae8SChuck Lever /* from net/core/stream.c:sk_stream_write_space */ 976c7b2cae8SChuck Lever if (sk_stream_wspace(sk) >= sk_stream_min_wspace(sk)) { 977c7b2cae8SChuck Lever struct socket *sock; 978c7b2cae8SChuck Lever struct rpc_xprt *xprt; 979c7b2cae8SChuck Lever 980c7b2cae8SChuck Lever if (unlikely(!(sock = sk->sk_socket))) 981c7b2cae8SChuck Lever goto out; 982c7b2cae8SChuck Lever if (unlikely(!(xprt = xprt_from_sock(sk)))) 983c7b2cae8SChuck Lever goto out; 984c7b2cae8SChuck Lever if (unlikely(!test_and_clear_bit(SOCK_NOSPACE, &sock->flags))) 985a246b010SChuck Lever goto out; 986a246b010SChuck Lever 987c7b2cae8SChuck Lever xprt_write_space(xprt); 988c7b2cae8SChuck Lever } 989c7b2cae8SChuck Lever 990a246b010SChuck Lever out: 991a246b010SChuck Lever read_unlock(&sk->sk_callback_lock); 992a246b010SChuck Lever } 993a246b010SChuck Lever 994470056c2SChuck Lever static void xs_udp_do_set_buffer_size(struct rpc_xprt *xprt) 995a246b010SChuck Lever { 996ee0ac0c2SChuck Lever struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt); 997ee0ac0c2SChuck Lever struct sock *sk = transport->inet; 998a246b010SChuck Lever 999a246b010SChuck Lever if (xprt->rcvsize) { 1000a246b010SChuck Lever sk->sk_userlocks |= SOCK_RCVBUF_LOCK; 1001a246b010SChuck Lever sk->sk_rcvbuf = xprt->rcvsize * xprt->max_reqs * 2; 1002a246b010SChuck Lever } 1003a246b010SChuck Lever if (xprt->sndsize) { 1004a246b010SChuck Lever sk->sk_userlocks |= SOCK_SNDBUF_LOCK; 1005a246b010SChuck Lever sk->sk_sndbuf = xprt->sndsize * xprt->max_reqs * 2; 1006a246b010SChuck Lever sk->sk_write_space(sk); 1007a246b010SChuck Lever } 1008a246b010SChuck Lever } 1009a246b010SChuck Lever 101043118c29SChuck Lever /** 1011470056c2SChuck Lever * xs_udp_set_buffer_size - set send and receive limits 101243118c29SChuck Lever * @xprt: generic transport 1013470056c2SChuck Lever * @sndsize: requested size of send buffer, in bytes 1014470056c2SChuck Lever * @rcvsize: requested size of receive buffer, in bytes 101543118c29SChuck Lever * 1016470056c2SChuck Lever * Set socket send and receive buffer size limits. 101743118c29SChuck Lever */ 1018470056c2SChuck Lever static void xs_udp_set_buffer_size(struct rpc_xprt *xprt, size_t sndsize, size_t rcvsize) 101943118c29SChuck Lever { 1020470056c2SChuck Lever xprt->sndsize = 0; 1021470056c2SChuck Lever if (sndsize) 1022470056c2SChuck Lever xprt->sndsize = sndsize + 1024; 1023470056c2SChuck Lever xprt->rcvsize = 0; 1024470056c2SChuck Lever if (rcvsize) 1025470056c2SChuck Lever xprt->rcvsize = rcvsize + 1024; 1026470056c2SChuck Lever 1027470056c2SChuck Lever xs_udp_do_set_buffer_size(xprt); 102843118c29SChuck Lever } 102943118c29SChuck Lever 103046c0ee8bSChuck Lever /** 103146c0ee8bSChuck Lever * xs_udp_timer - called when a retransmit timeout occurs on a UDP transport 103246c0ee8bSChuck Lever * @task: task that timed out 103346c0ee8bSChuck Lever * 103446c0ee8bSChuck Lever * Adjust the congestion window after a retransmit timeout has occurred. 103546c0ee8bSChuck Lever */ 103646c0ee8bSChuck Lever static void xs_udp_timer(struct rpc_task *task) 103746c0ee8bSChuck Lever { 103846c0ee8bSChuck Lever xprt_adjust_cwnd(task, -ETIMEDOUT); 103946c0ee8bSChuck Lever } 104046c0ee8bSChuck Lever 1041b85d8806SChuck Lever static unsigned short xs_get_random_port(void) 1042b85d8806SChuck Lever { 1043b85d8806SChuck Lever unsigned short range = xprt_max_resvport - xprt_min_resvport; 1044b85d8806SChuck Lever unsigned short rand = (unsigned short) net_random() % range; 1045b85d8806SChuck Lever return rand + xprt_min_resvport; 1046b85d8806SChuck Lever } 1047b85d8806SChuck Lever 104892200412SChuck Lever /** 1049edb267a6SChuck Lever * xs_print_peer_address - format an IPv4 address for printing 1050edb267a6SChuck Lever * @xprt: generic transport 1051edb267a6SChuck Lever * @format: flags field indicating which parts of the address to render 1052edb267a6SChuck Lever */ 1053edb267a6SChuck Lever static char *xs_print_peer_address(struct rpc_xprt *xprt, enum rpc_display_format_t format) 1054edb267a6SChuck Lever { 1055edb267a6SChuck Lever if (xprt->address_strings[format] != NULL) 1056edb267a6SChuck Lever return xprt->address_strings[format]; 1057edb267a6SChuck Lever else 1058edb267a6SChuck Lever return "unprintable"; 1059edb267a6SChuck Lever } 1060edb267a6SChuck Lever 1061edb267a6SChuck Lever /** 106292200412SChuck Lever * xs_set_port - reset the port number in the remote endpoint address 106392200412SChuck Lever * @xprt: generic transport 106492200412SChuck Lever * @port: new port number 106592200412SChuck Lever * 106692200412SChuck Lever */ 106792200412SChuck Lever static void xs_set_port(struct rpc_xprt *xprt, unsigned short port) 106892200412SChuck Lever { 1069c4efcb1dSChuck Lever struct sockaddr_in *sap = (struct sockaddr_in *) &xprt->addr; 1070c4efcb1dSChuck Lever 107192200412SChuck Lever dprintk("RPC: setting port for xprt %p to %u\n", xprt, port); 1072c4efcb1dSChuck Lever 1073c4efcb1dSChuck Lever sap->sin_port = htons(port); 107492200412SChuck Lever } 107592200412SChuck Lever 1076c8475461SChuck Lever static int xs_bindresvport(struct sock_xprt *transport, struct socket *sock) 1077a246b010SChuck Lever { 1078a246b010SChuck Lever struct sockaddr_in myaddr = { 1079a246b010SChuck Lever .sin_family = AF_INET, 1080a246b010SChuck Lever }; 1081529b33c6SChuck Lever int err; 1082c8475461SChuck Lever unsigned short port = transport->port; 1083a246b010SChuck Lever 1084a246b010SChuck Lever do { 1085a246b010SChuck Lever myaddr.sin_port = htons(port); 1086e6242e92SSridhar Samudrala err = kernel_bind(sock, (struct sockaddr *) &myaddr, 1087a246b010SChuck Lever sizeof(myaddr)); 1088a246b010SChuck Lever if (err == 0) { 1089c8475461SChuck Lever transport->port = port; 10909903cd1cSChuck Lever dprintk("RPC: xs_bindresvport bound to port %u\n", 10919903cd1cSChuck Lever port); 1092a246b010SChuck Lever return 0; 1093a246b010SChuck Lever } 1094529b33c6SChuck Lever if (port <= xprt_min_resvport) 1095529b33c6SChuck Lever port = xprt_max_resvport; 1096529b33c6SChuck Lever else 1097529b33c6SChuck Lever port--; 1098c8475461SChuck Lever } while (err == -EADDRINUSE && port != transport->port); 1099a246b010SChuck Lever 11009903cd1cSChuck Lever dprintk("RPC: can't bind to reserved port (%d).\n", -err); 1101a246b010SChuck Lever return err; 1102a246b010SChuck Lever } 1103a246b010SChuck Lever 11049903cd1cSChuck Lever /** 1105b0d93ad5SChuck Lever * xs_udp_connect_worker - set up a UDP socket 11069903cd1cSChuck Lever * @args: RPC transport to connect 11079903cd1cSChuck Lever * 11089903cd1cSChuck Lever * Invoked by a work queue tasklet. 1109a246b010SChuck Lever */ 1110b0d93ad5SChuck Lever static void xs_udp_connect_worker(void *args) 1111a246b010SChuck Lever { 1112c8475461SChuck Lever struct sock_xprt *transport = (struct sock_xprt *)args; 1113c8475461SChuck Lever struct rpc_xprt *xprt = &transport->xprt; 1114ee0ac0c2SChuck Lever struct socket *sock = transport->sock; 1115b0d93ad5SChuck Lever int err, status = -EIO; 1116a246b010SChuck Lever 1117ec739ef0SChuck Lever if (xprt->shutdown || !xprt_bound(xprt)) 1118a246b010SChuck Lever goto out; 1119a246b010SChuck Lever 1120b0d93ad5SChuck Lever /* Start by resetting any existing state */ 11219903cd1cSChuck Lever xs_close(xprt); 1122b0d93ad5SChuck Lever 1123b0d93ad5SChuck Lever if ((err = sock_create_kern(PF_INET, SOCK_DGRAM, IPPROTO_UDP, &sock)) < 0) { 1124b0d93ad5SChuck Lever dprintk("RPC: can't create UDP transport socket (%d).\n", -err); 1125a246b010SChuck Lever goto out; 1126a246b010SChuck Lever } 1127a246b010SChuck Lever 1128c8475461SChuck Lever if (xprt->resvport && xs_bindresvport(transport, sock) < 0) { 1129b0d93ad5SChuck Lever sock_release(sock); 1130b0d93ad5SChuck Lever goto out; 1131b0d93ad5SChuck Lever } 1132b0d93ad5SChuck Lever 1133edb267a6SChuck Lever dprintk("RPC: worker connecting xprt %p to address: %s\n", 1134edb267a6SChuck Lever xprt, xs_print_peer_address(xprt, RPC_DISPLAY_ALL)); 1135edb267a6SChuck Lever 1136ee0ac0c2SChuck Lever if (!transport->inet) { 1137b0d93ad5SChuck Lever struct sock *sk = sock->sk; 1138b0d93ad5SChuck Lever 1139b0d93ad5SChuck Lever write_lock_bh(&sk->sk_callback_lock); 1140b0d93ad5SChuck Lever 1141b0d93ad5SChuck Lever sk->sk_user_data = xprt; 1142b0d93ad5SChuck Lever xprt->old_data_ready = sk->sk_data_ready; 1143b0d93ad5SChuck Lever xprt->old_state_change = sk->sk_state_change; 1144b0d93ad5SChuck Lever xprt->old_write_space = sk->sk_write_space; 1145b0d93ad5SChuck Lever sk->sk_data_ready = xs_udp_data_ready; 1146b0d93ad5SChuck Lever sk->sk_write_space = xs_udp_write_space; 1147b0d93ad5SChuck Lever sk->sk_no_check = UDP_CSUM_NORCV; 1148b079fa7bSTrond Myklebust sk->sk_allocation = GFP_ATOMIC; 1149b0d93ad5SChuck Lever 1150b0d93ad5SChuck Lever xprt_set_connected(xprt); 1151b0d93ad5SChuck Lever 1152b0d93ad5SChuck Lever /* Reset to new socket */ 1153ee0ac0c2SChuck Lever transport->sock = sock; 1154ee0ac0c2SChuck Lever transport->inet = sk; 1155b0d93ad5SChuck Lever 1156b0d93ad5SChuck Lever write_unlock_bh(&sk->sk_callback_lock); 1157b0d93ad5SChuck Lever } 1158470056c2SChuck Lever xs_udp_do_set_buffer_size(xprt); 1159a246b010SChuck Lever status = 0; 1160b0d93ad5SChuck Lever out: 1161b0d93ad5SChuck Lever xprt_wake_pending_tasks(xprt, status); 1162b0d93ad5SChuck Lever xprt_clear_connecting(xprt); 1163b0d93ad5SChuck Lever } 1164b0d93ad5SChuck Lever 11653167e12cSChuck Lever /* 11663167e12cSChuck Lever * We need to preserve the port number so the reply cache on the server can 11673167e12cSChuck Lever * find our cached RPC replies when we get around to reconnecting. 11683167e12cSChuck Lever */ 11693167e12cSChuck Lever static void xs_tcp_reuse_connection(struct rpc_xprt *xprt) 11703167e12cSChuck Lever { 11713167e12cSChuck Lever int result; 1172ee0ac0c2SChuck Lever struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt); 11733167e12cSChuck Lever struct sockaddr any; 11743167e12cSChuck Lever 11753167e12cSChuck Lever dprintk("RPC: disconnecting xprt %p to reuse port\n", xprt); 11763167e12cSChuck Lever 11773167e12cSChuck Lever /* 11783167e12cSChuck Lever * Disconnect the transport socket by doing a connect operation 11793167e12cSChuck Lever * with AF_UNSPEC. This should return immediately... 11803167e12cSChuck Lever */ 11813167e12cSChuck Lever memset(&any, 0, sizeof(any)); 11823167e12cSChuck Lever any.sa_family = AF_UNSPEC; 1183ee0ac0c2SChuck Lever result = kernel_connect(transport->sock, &any, sizeof(any), 0); 11843167e12cSChuck Lever if (result) 11853167e12cSChuck Lever dprintk("RPC: AF_UNSPEC connect return code %d\n", 11863167e12cSChuck Lever result); 11873167e12cSChuck Lever } 11883167e12cSChuck Lever 1189b0d93ad5SChuck Lever /** 1190b0d93ad5SChuck Lever * xs_tcp_connect_worker - connect a TCP socket to a remote endpoint 1191b0d93ad5SChuck Lever * @args: RPC transport to connect 1192b0d93ad5SChuck Lever * 1193b0d93ad5SChuck Lever * Invoked by a work queue tasklet. 1194b0d93ad5SChuck Lever */ 1195b0d93ad5SChuck Lever static void xs_tcp_connect_worker(void *args) 1196b0d93ad5SChuck Lever { 1197c8475461SChuck Lever struct sock_xprt *transport = (struct sock_xprt *)args; 1198c8475461SChuck Lever struct rpc_xprt *xprt = &transport->xprt; 1199ee0ac0c2SChuck Lever struct socket *sock = transport->sock; 1200b0d93ad5SChuck Lever int err, status = -EIO; 1201b0d93ad5SChuck Lever 1202ec739ef0SChuck Lever if (xprt->shutdown || !xprt_bound(xprt)) 1203a246b010SChuck Lever goto out; 1204a246b010SChuck Lever 1205ee0ac0c2SChuck Lever if (!sock) { 12063167e12cSChuck Lever /* start from scratch */ 1207b0d93ad5SChuck Lever if ((err = sock_create_kern(PF_INET, SOCK_STREAM, IPPROTO_TCP, &sock)) < 0) { 1208b0d93ad5SChuck Lever dprintk("RPC: can't create TCP transport socket (%d).\n", -err); 1209b0d93ad5SChuck Lever goto out; 1210b0d93ad5SChuck Lever } 1211b0d93ad5SChuck Lever 1212c8475461SChuck Lever if (xprt->resvport && xs_bindresvport(transport, sock) < 0) { 1213b0d93ad5SChuck Lever sock_release(sock); 1214b0d93ad5SChuck Lever goto out; 1215b0d93ad5SChuck Lever } 12163167e12cSChuck Lever } else 12173167e12cSChuck Lever /* "close" the socket, preserving the local port */ 12183167e12cSChuck Lever xs_tcp_reuse_connection(xprt); 1219b0d93ad5SChuck Lever 1220edb267a6SChuck Lever dprintk("RPC: worker connecting xprt %p to address: %s\n", 1221edb267a6SChuck Lever xprt, xs_print_peer_address(xprt, RPC_DISPLAY_ALL)); 1222edb267a6SChuck Lever 1223ee0ac0c2SChuck Lever if (!transport->inet) { 1224b0d93ad5SChuck Lever struct sock *sk = sock->sk; 1225b0d93ad5SChuck Lever 1226b0d93ad5SChuck Lever write_lock_bh(&sk->sk_callback_lock); 1227b0d93ad5SChuck Lever 1228b0d93ad5SChuck Lever sk->sk_user_data = xprt; 1229b0d93ad5SChuck Lever xprt->old_data_ready = sk->sk_data_ready; 1230b0d93ad5SChuck Lever xprt->old_state_change = sk->sk_state_change; 1231b0d93ad5SChuck Lever xprt->old_write_space = sk->sk_write_space; 1232b0d93ad5SChuck Lever sk->sk_data_ready = xs_tcp_data_ready; 1233b0d93ad5SChuck Lever sk->sk_state_change = xs_tcp_state_change; 1234b0d93ad5SChuck Lever sk->sk_write_space = xs_tcp_write_space; 1235b079fa7bSTrond Myklebust sk->sk_allocation = GFP_ATOMIC; 12363167e12cSChuck Lever 12373167e12cSChuck Lever /* socket options */ 12383167e12cSChuck Lever sk->sk_userlocks |= SOCK_BINDPORT_LOCK; 12393167e12cSChuck Lever sock_reset_flag(sk, SOCK_LINGER); 12403167e12cSChuck Lever tcp_sk(sk)->linger2 = 0; 12413167e12cSChuck Lever tcp_sk(sk)->nonagle |= TCP_NAGLE_OFF; 1242b0d93ad5SChuck Lever 1243b0d93ad5SChuck Lever xprt_clear_connected(xprt); 1244b0d93ad5SChuck Lever 1245b0d93ad5SChuck Lever /* Reset to new socket */ 1246ee0ac0c2SChuck Lever transport->sock = sock; 1247ee0ac0c2SChuck Lever transport->inet = sk; 1248b0d93ad5SChuck Lever 1249b0d93ad5SChuck Lever write_unlock_bh(&sk->sk_callback_lock); 1250b0d93ad5SChuck Lever } 1251b0d93ad5SChuck Lever 1252b0d93ad5SChuck Lever /* Tell the socket layer to start connecting... */ 1253262ca07dSChuck Lever xprt->stat.connect_count++; 1254262ca07dSChuck Lever xprt->stat.connect_start = jiffies; 1255e6242e92SSridhar Samudrala status = kernel_connect(sock, (struct sockaddr *) &xprt->addr, 1256c4efcb1dSChuck Lever xprt->addrlen, O_NONBLOCK); 1257a246b010SChuck Lever dprintk("RPC: %p connect status %d connected %d sock state %d\n", 1258a246b010SChuck Lever xprt, -status, xprt_connected(xprt), sock->sk->sk_state); 1259a246b010SChuck Lever if (status < 0) { 1260a246b010SChuck Lever switch (status) { 1261a246b010SChuck Lever case -EINPROGRESS: 1262a246b010SChuck Lever case -EALREADY: 1263a246b010SChuck Lever goto out_clear; 12643167e12cSChuck Lever case -ECONNREFUSED: 12653167e12cSChuck Lever case -ECONNRESET: 12663167e12cSChuck Lever /* retry with existing socket, after a delay */ 12673167e12cSChuck Lever break; 12683167e12cSChuck Lever default: 12693167e12cSChuck Lever /* get rid of existing socket, and retry */ 12703167e12cSChuck Lever xs_close(xprt); 12713167e12cSChuck Lever break; 1272a246b010SChuck Lever } 1273a246b010SChuck Lever } 1274a246b010SChuck Lever out: 127544fbac22SChuck Lever xprt_wake_pending_tasks(xprt, status); 1276a246b010SChuck Lever out_clear: 12772226feb6SChuck Lever xprt_clear_connecting(xprt); 1278a246b010SChuck Lever } 1279a246b010SChuck Lever 12809903cd1cSChuck Lever /** 12819903cd1cSChuck Lever * xs_connect - connect a socket to a remote endpoint 12829903cd1cSChuck Lever * @task: address of RPC task that manages state of connect request 12839903cd1cSChuck Lever * 12849903cd1cSChuck Lever * TCP: If the remote end dropped the connection, delay reconnecting. 128503bf4b70SChuck Lever * 128603bf4b70SChuck Lever * UDP socket connects are synchronous, but we use a work queue anyway 128703bf4b70SChuck Lever * to guarantee that even unprivileged user processes can set up a 128803bf4b70SChuck Lever * socket on a privileged port. 128903bf4b70SChuck Lever * 129003bf4b70SChuck Lever * If a UDP socket connect fails, the delay behavior here prevents 129103bf4b70SChuck Lever * retry floods (hard mounts). 12929903cd1cSChuck Lever */ 12939903cd1cSChuck Lever static void xs_connect(struct rpc_task *task) 1294a246b010SChuck Lever { 1295a246b010SChuck Lever struct rpc_xprt *xprt = task->tk_xprt; 1296ee0ac0c2SChuck Lever struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt); 1297a246b010SChuck Lever 1298b0d93ad5SChuck Lever if (xprt_test_and_set_connecting(xprt)) 1299b0d93ad5SChuck Lever return; 1300b0d93ad5SChuck Lever 1301ee0ac0c2SChuck Lever if (transport->sock != NULL) { 130203bf4b70SChuck Lever dprintk("RPC: xs_connect delayed xprt %p for %lu seconds\n", 130303bf4b70SChuck Lever xprt, xprt->reestablish_timeout / HZ); 1304c8475461SChuck Lever schedule_delayed_work(&transport->connect_worker, 130503bf4b70SChuck Lever xprt->reestablish_timeout); 130603bf4b70SChuck Lever xprt->reestablish_timeout <<= 1; 130703bf4b70SChuck Lever if (xprt->reestablish_timeout > XS_TCP_MAX_REEST_TO) 130803bf4b70SChuck Lever xprt->reestablish_timeout = XS_TCP_MAX_REEST_TO; 13099903cd1cSChuck Lever } else { 13109903cd1cSChuck Lever dprintk("RPC: xs_connect scheduled xprt %p\n", xprt); 1311c8475461SChuck Lever schedule_work(&transport->connect_worker); 1312b0d93ad5SChuck Lever 1313a246b010SChuck Lever /* flush_scheduled_work can sleep... */ 1314a246b010SChuck Lever if (!RPC_IS_ASYNC(task)) 1315a246b010SChuck Lever flush_scheduled_work(); 1316a246b010SChuck Lever } 1317a246b010SChuck Lever } 1318a246b010SChuck Lever 1319262ca07dSChuck Lever /** 1320262ca07dSChuck Lever * xs_udp_print_stats - display UDP socket-specifc stats 1321262ca07dSChuck Lever * @xprt: rpc_xprt struct containing statistics 1322262ca07dSChuck Lever * @seq: output file 1323262ca07dSChuck Lever * 1324262ca07dSChuck Lever */ 1325262ca07dSChuck Lever static void xs_udp_print_stats(struct rpc_xprt *xprt, struct seq_file *seq) 1326262ca07dSChuck Lever { 1327c8475461SChuck Lever struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt); 1328c8475461SChuck Lever 1329262ca07dSChuck Lever seq_printf(seq, "\txprt:\tudp %u %lu %lu %lu %lu %Lu %Lu\n", 1330c8475461SChuck Lever transport->port, 1331262ca07dSChuck Lever xprt->stat.bind_count, 1332262ca07dSChuck Lever xprt->stat.sends, 1333262ca07dSChuck Lever xprt->stat.recvs, 1334262ca07dSChuck Lever xprt->stat.bad_xids, 1335262ca07dSChuck Lever xprt->stat.req_u, 1336262ca07dSChuck Lever xprt->stat.bklog_u); 1337262ca07dSChuck Lever } 1338262ca07dSChuck Lever 1339262ca07dSChuck Lever /** 1340262ca07dSChuck Lever * xs_tcp_print_stats - display TCP socket-specifc stats 1341262ca07dSChuck Lever * @xprt: rpc_xprt struct containing statistics 1342262ca07dSChuck Lever * @seq: output file 1343262ca07dSChuck Lever * 1344262ca07dSChuck Lever */ 1345262ca07dSChuck Lever static void xs_tcp_print_stats(struct rpc_xprt *xprt, struct seq_file *seq) 1346262ca07dSChuck Lever { 1347c8475461SChuck Lever struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt); 1348262ca07dSChuck Lever long idle_time = 0; 1349262ca07dSChuck Lever 1350262ca07dSChuck Lever if (xprt_connected(xprt)) 1351262ca07dSChuck Lever idle_time = (long)(jiffies - xprt->last_used) / HZ; 1352262ca07dSChuck Lever 1353262ca07dSChuck Lever seq_printf(seq, "\txprt:\ttcp %u %lu %lu %lu %ld %lu %lu %lu %Lu %Lu\n", 1354c8475461SChuck Lever transport->port, 1355262ca07dSChuck Lever xprt->stat.bind_count, 1356262ca07dSChuck Lever xprt->stat.connect_count, 1357262ca07dSChuck Lever xprt->stat.connect_time, 1358262ca07dSChuck Lever idle_time, 1359262ca07dSChuck Lever xprt->stat.sends, 1360262ca07dSChuck Lever xprt->stat.recvs, 1361262ca07dSChuck Lever xprt->stat.bad_xids, 1362262ca07dSChuck Lever xprt->stat.req_u, 1363262ca07dSChuck Lever xprt->stat.bklog_u); 1364262ca07dSChuck Lever } 1365262ca07dSChuck Lever 1366262965f5SChuck Lever static struct rpc_xprt_ops xs_udp_ops = { 136743118c29SChuck Lever .set_buffer_size = xs_udp_set_buffer_size, 1368edb267a6SChuck Lever .print_addr = xs_print_peer_address, 136912a80469SChuck Lever .reserve_xprt = xprt_reserve_xprt_cong, 137049e9a890SChuck Lever .release_xprt = xprt_release_xprt_cong, 1371bbf7c1ddSChuck Lever .rpcbind = rpc_getport, 137292200412SChuck Lever .set_port = xs_set_port, 13739903cd1cSChuck Lever .connect = xs_connect, 137402107148SChuck Lever .buf_alloc = rpc_malloc, 137502107148SChuck Lever .buf_free = rpc_free, 1376262965f5SChuck Lever .send_request = xs_udp_send_request, 1377fe3aca29SChuck Lever .set_retrans_timeout = xprt_set_retrans_timeout_rtt, 137846c0ee8bSChuck Lever .timer = xs_udp_timer, 1379a58dd398SChuck Lever .release_request = xprt_release_rqst_cong, 1380262965f5SChuck Lever .close = xs_close, 1381262965f5SChuck Lever .destroy = xs_destroy, 1382262ca07dSChuck Lever .print_stats = xs_udp_print_stats, 1383262965f5SChuck Lever }; 1384262965f5SChuck Lever 1385262965f5SChuck Lever static struct rpc_xprt_ops xs_tcp_ops = { 1386edb267a6SChuck Lever .print_addr = xs_print_peer_address, 138712a80469SChuck Lever .reserve_xprt = xprt_reserve_xprt, 1388e0ab53deSTrond Myklebust .release_xprt = xs_tcp_release_xprt, 1389bbf7c1ddSChuck Lever .rpcbind = rpc_getport, 139092200412SChuck Lever .set_port = xs_set_port, 1391262965f5SChuck Lever .connect = xs_connect, 139202107148SChuck Lever .buf_alloc = rpc_malloc, 139302107148SChuck Lever .buf_free = rpc_free, 1394262965f5SChuck Lever .send_request = xs_tcp_send_request, 1395fe3aca29SChuck Lever .set_retrans_timeout = xprt_set_retrans_timeout_def, 13969903cd1cSChuck Lever .close = xs_close, 13979903cd1cSChuck Lever .destroy = xs_destroy, 1398262ca07dSChuck Lever .print_stats = xs_tcp_print_stats, 1399a246b010SChuck Lever }; 1400a246b010SChuck Lever 1401c8541ecdSChuck Lever static struct rpc_xprt *xs_setup_xprt(struct sockaddr *addr, size_t addrlen, unsigned int slot_table_size) 1402c8541ecdSChuck Lever { 1403c8541ecdSChuck Lever struct rpc_xprt *xprt; 1404ffc2e518SChuck Lever struct sock_xprt *new; 1405c8541ecdSChuck Lever 1406c8541ecdSChuck Lever if (addrlen > sizeof(xprt->addr)) { 1407c8541ecdSChuck Lever dprintk("RPC: xs_setup_xprt: address too large\n"); 1408c8541ecdSChuck Lever return ERR_PTR(-EBADF); 1409c8541ecdSChuck Lever } 1410c8541ecdSChuck Lever 1411ffc2e518SChuck Lever new = kzalloc(sizeof(*new), GFP_KERNEL); 1412ffc2e518SChuck Lever if (new == NULL) { 1413c8541ecdSChuck Lever dprintk("RPC: xs_setup_xprt: couldn't allocate rpc_xprt\n"); 1414c8541ecdSChuck Lever return ERR_PTR(-ENOMEM); 1415c8541ecdSChuck Lever } 1416ffc2e518SChuck Lever xprt = &new->xprt; 1417c8541ecdSChuck Lever 1418c8541ecdSChuck Lever xprt->max_reqs = slot_table_size; 1419c8541ecdSChuck Lever xprt->slot = kcalloc(xprt->max_reqs, sizeof(struct rpc_rqst), GFP_KERNEL); 1420c8541ecdSChuck Lever if (xprt->slot == NULL) { 1421c8541ecdSChuck Lever kfree(xprt); 1422c8541ecdSChuck Lever dprintk("RPC: xs_setup_xprt: couldn't allocate slot table\n"); 1423c8541ecdSChuck Lever return ERR_PTR(-ENOMEM); 1424c8541ecdSChuck Lever } 1425c8541ecdSChuck Lever 1426c8541ecdSChuck Lever memcpy(&xprt->addr, addr, addrlen); 1427c8541ecdSChuck Lever xprt->addrlen = addrlen; 1428c8475461SChuck Lever new->port = xs_get_random_port(); 1429c8541ecdSChuck Lever 1430c8541ecdSChuck Lever return xprt; 1431c8541ecdSChuck Lever } 1432c8541ecdSChuck Lever 14339903cd1cSChuck Lever /** 14349903cd1cSChuck Lever * xs_setup_udp - Set up transport to use a UDP socket 1435c8541ecdSChuck Lever * @addr: address of remote server 1436c8541ecdSChuck Lever * @addrlen: length of address in bytes 14379903cd1cSChuck Lever * @to: timeout parameters 14389903cd1cSChuck Lever * 14399903cd1cSChuck Lever */ 1440c8541ecdSChuck Lever struct rpc_xprt *xs_setup_udp(struct sockaddr *addr, size_t addrlen, struct rpc_timeout *to) 1441a246b010SChuck Lever { 1442c8541ecdSChuck Lever struct rpc_xprt *xprt; 1443c8475461SChuck Lever struct sock_xprt *transport; 1444a246b010SChuck Lever 1445c8541ecdSChuck Lever xprt = xs_setup_xprt(addr, addrlen, xprt_udp_slot_table_entries); 1446c8541ecdSChuck Lever if (IS_ERR(xprt)) 1447c8541ecdSChuck Lever return xprt; 1448c8475461SChuck Lever transport = container_of(xprt, struct sock_xprt, xprt); 1449a246b010SChuck Lever 1450c8541ecdSChuck Lever if (ntohs(((struct sockaddr_in *)addr)->sin_port) != 0) 1451ec739ef0SChuck Lever xprt_set_bound(xprt); 1452ec739ef0SChuck Lever 1453ec739ef0SChuck Lever xprt->prot = IPPROTO_UDP; 1454808012fbSChuck Lever xprt->tsh_size = 0; 1455a246b010SChuck Lever /* XXX: header size can vary due to auth type, IPv6, etc. */ 1456a246b010SChuck Lever xprt->max_payload = (1U << 16) - (MAX_HEADER << 3); 1457a246b010SChuck Lever 1458c8475461SChuck Lever INIT_WORK(&transport->connect_worker, xs_udp_connect_worker, transport); 145903bf4b70SChuck Lever xprt->bind_timeout = XS_BIND_TO; 146003bf4b70SChuck Lever xprt->connect_timeout = XS_UDP_CONN_TO; 146103bf4b70SChuck Lever xprt->reestablish_timeout = XS_UDP_REEST_TO; 146203bf4b70SChuck Lever xprt->idle_timeout = XS_IDLE_DISC_TO; 1463a246b010SChuck Lever 1464262965f5SChuck Lever xprt->ops = &xs_udp_ops; 1465a246b010SChuck Lever 1466a246b010SChuck Lever if (to) 1467a246b010SChuck Lever xprt->timeout = *to; 1468a246b010SChuck Lever else 14699903cd1cSChuck Lever xprt_set_timeout(&xprt->timeout, 5, 5 * HZ); 1470a246b010SChuck Lever 1471edb267a6SChuck Lever xs_format_peer_addresses(xprt); 1472edb267a6SChuck Lever dprintk("RPC: set up transport to address %s\n", 1473edb267a6SChuck Lever xs_print_peer_address(xprt, RPC_DISPLAY_ALL)); 1474edb267a6SChuck Lever 1475c8541ecdSChuck Lever return xprt; 1476a246b010SChuck Lever } 1477a246b010SChuck Lever 14789903cd1cSChuck Lever /** 14799903cd1cSChuck Lever * xs_setup_tcp - Set up transport to use a TCP socket 1480c8541ecdSChuck Lever * @addr: address of remote server 1481c8541ecdSChuck Lever * @addrlen: length of address in bytes 14829903cd1cSChuck Lever * @to: timeout parameters 14839903cd1cSChuck Lever * 14849903cd1cSChuck Lever */ 1485c8541ecdSChuck Lever struct rpc_xprt *xs_setup_tcp(struct sockaddr *addr, size_t addrlen, struct rpc_timeout *to) 1486a246b010SChuck Lever { 1487c8541ecdSChuck Lever struct rpc_xprt *xprt; 1488c8475461SChuck Lever struct sock_xprt *transport; 1489a246b010SChuck Lever 1490c8541ecdSChuck Lever xprt = xs_setup_xprt(addr, addrlen, xprt_tcp_slot_table_entries); 1491c8541ecdSChuck Lever if (IS_ERR(xprt)) 1492c8541ecdSChuck Lever return xprt; 1493c8475461SChuck Lever transport = container_of(xprt, struct sock_xprt, xprt); 1494a246b010SChuck Lever 1495c8541ecdSChuck Lever if (ntohs(((struct sockaddr_in *)addr)->sin_port) != 0) 1496ec739ef0SChuck Lever xprt_set_bound(xprt); 1497ec739ef0SChuck Lever 1498ec739ef0SChuck Lever xprt->prot = IPPROTO_TCP; 1499808012fbSChuck Lever xprt->tsh_size = sizeof(rpc_fraghdr) / sizeof(u32); 1500808012fbSChuck Lever xprt->max_payload = RPC_MAX_FRAGMENT_SIZE; 1501a246b010SChuck Lever 1502c8475461SChuck Lever INIT_WORK(&transport->connect_worker, xs_tcp_connect_worker, transport); 150303bf4b70SChuck Lever xprt->bind_timeout = XS_BIND_TO; 150403bf4b70SChuck Lever xprt->connect_timeout = XS_TCP_CONN_TO; 150503bf4b70SChuck Lever xprt->reestablish_timeout = XS_TCP_INIT_REEST_TO; 150603bf4b70SChuck Lever xprt->idle_timeout = XS_IDLE_DISC_TO; 1507a246b010SChuck Lever 1508262965f5SChuck Lever xprt->ops = &xs_tcp_ops; 1509a246b010SChuck Lever 1510a246b010SChuck Lever if (to) 1511a246b010SChuck Lever xprt->timeout = *to; 1512a246b010SChuck Lever else 15139903cd1cSChuck Lever xprt_set_timeout(&xprt->timeout, 2, 60 * HZ); 1514a246b010SChuck Lever 1515edb267a6SChuck Lever xs_format_peer_addresses(xprt); 1516edb267a6SChuck Lever dprintk("RPC: set up transport to address %s\n", 1517edb267a6SChuck Lever xs_print_peer_address(xprt, RPC_DISPLAY_ALL)); 1518edb267a6SChuck Lever 1519c8541ecdSChuck Lever return xprt; 1520a246b010SChuck Lever } 1521