xprtsock.c 53.8 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13
/*
 * linux/net/sunrpc/xprtsock.c
 *
 * Client-side transport implementation for sockets.
 *
 * TCP callback races fixes (C) 1998 Red Hat Software <alan@redhat.com>
 * TCP send fixes (C) 1998 Red Hat Software <alan@redhat.com>
 * TCP NFS related read + write fixes
 *  (C) 1999 Dave Airlie, University of Limerick, Ireland <airlied@linux.ie>
 *
 * Rewrite of larges part of the code in order to stabilize TCP stuff.
 * Fix behaviour when socket buffer is full.
 *  (C) 1999 Trond Myklebust <trond.myklebust@fys.uio.no>
14 15
 *
 * IP socket transport implementation, (C) 2005 Chuck Lever <cel@netapp.com>
16 17 18
 *
 * IPv6 support contributed by Gilles Quillard, Bull Open Source, 2005.
 *   <gilles.quillard@bull.net>
19 20 21 22
 */

#include <linux/types.h>
#include <linux/slab.h>
23
#include <linux/module.h>
24 25 26 27 28 29 30 31 32 33
#include <linux/capability.h>
#include <linux/pagemap.h>
#include <linux/errno.h>
#include <linux/socket.h>
#include <linux/in.h>
#include <linux/net.h>
#include <linux/mm.h>
#include <linux/udp.h>
#include <linux/tcp.h>
#include <linux/sunrpc/clnt.h>
34
#include <linux/sunrpc/sched.h>
35
#include <linux/sunrpc/xprtsock.h>
36 37 38 39 40 41 42
#include <linux/file.h>

#include <net/sock.h>
#include <net/checksum.h>
#include <net/udp.h>
#include <net/tcp.h>

43 44 45 46 47 48 49 50 51
/*
 * xprtsock tunables
 */
unsigned int xprt_udp_slot_table_entries = RPC_DEF_SLOT_TABLE;
unsigned int xprt_tcp_slot_table_entries = RPC_DEF_SLOT_TABLE;

unsigned int xprt_min_resvport = RPC_DEF_MIN_RESVPORT;
unsigned int xprt_max_resvport = RPC_DEF_MAX_RESVPORT;

52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137
/*
 * We can register our own files under /proc/sys/sunrpc by
 * calling register_sysctl_table() again.  The files in that
 * directory become the union of all files registered there.
 *
 * We simply need to make sure that we don't collide with
 * someone else's file names!
 */

#ifdef RPC_DEBUG

static unsigned int min_slot_table_size = RPC_MIN_SLOT_TABLE;
static unsigned int max_slot_table_size = RPC_MAX_SLOT_TABLE;
static unsigned int xprt_min_resvport_limit = RPC_MIN_RESVPORT;
static unsigned int xprt_max_resvport_limit = RPC_MAX_RESVPORT;

static struct ctl_table_header *sunrpc_table_header;

/*
 * FIXME: changing the UDP slot table size should also resize the UDP
 *        socket buffers for existing UDP transports
 */
static ctl_table xs_tunables_table[] = {
	{
		.ctl_name	= CTL_SLOTTABLE_UDP,
		.procname	= "udp_slot_table_entries",
		.data		= &xprt_udp_slot_table_entries,
		.maxlen		= sizeof(unsigned int),
		.mode		= 0644,
		.proc_handler	= &proc_dointvec_minmax,
		.strategy	= &sysctl_intvec,
		.extra1		= &min_slot_table_size,
		.extra2		= &max_slot_table_size
	},
	{
		.ctl_name	= CTL_SLOTTABLE_TCP,
		.procname	= "tcp_slot_table_entries",
		.data		= &xprt_tcp_slot_table_entries,
		.maxlen		= sizeof(unsigned int),
		.mode		= 0644,
		.proc_handler	= &proc_dointvec_minmax,
		.strategy	= &sysctl_intvec,
		.extra1		= &min_slot_table_size,
		.extra2		= &max_slot_table_size
	},
	{
		.ctl_name	= CTL_MIN_RESVPORT,
		.procname	= "min_resvport",
		.data		= &xprt_min_resvport,
		.maxlen		= sizeof(unsigned int),
		.mode		= 0644,
		.proc_handler	= &proc_dointvec_minmax,
		.strategy	= &sysctl_intvec,
		.extra1		= &xprt_min_resvport_limit,
		.extra2		= &xprt_max_resvport_limit
	},
	{
		.ctl_name	= CTL_MAX_RESVPORT,
		.procname	= "max_resvport",
		.data		= &xprt_max_resvport,
		.maxlen		= sizeof(unsigned int),
		.mode		= 0644,
		.proc_handler	= &proc_dointvec_minmax,
		.strategy	= &sysctl_intvec,
		.extra1		= &xprt_min_resvport_limit,
		.extra2		= &xprt_max_resvport_limit
	},
	{
		.ctl_name = 0,
	},
};

static ctl_table sunrpc_table[] = {
	{
		.ctl_name	= CTL_SUNRPC,
		.procname	= "sunrpc",
		.mode		= 0555,
		.child		= xs_tunables_table
	},
	{
		.ctl_name = 0,
	},
};

#endif

138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181
/*
 * Time out for an RPC UDP socket connect.  UDP socket connects are
 * synchronous, but we set a timeout anyway in case of resource
 * exhaustion on the local host.
 */
#define XS_UDP_CONN_TO		(5U * HZ)

/*
 * Wait duration for an RPC TCP connection to be established.  Solaris
 * NFS over TCP uses 60 seconds, for example, which is in line with how
 * long a server takes to reboot.
 */
#define XS_TCP_CONN_TO		(60U * HZ)

/*
 * Wait duration for a reply from the RPC portmapper.
 */
#define XS_BIND_TO		(60U * HZ)

/*
 * Delay if a UDP socket connect error occurs.  This is most likely some
 * kind of resource problem on the local host.
 */
#define XS_UDP_REEST_TO		(2U * HZ)

/*
 * The reestablish timeout allows clients to delay for a bit before attempting
 * to reconnect to a server that just dropped our connection.
 *
 * We implement an exponential backoff when trying to reestablish a TCP
 * transport connection with the server.  Some servers like to drop a TCP
 * connection when they are overworked, so we start with a short timeout and
 * increase over time if the server is down or not responding.
 */
#define XS_TCP_INIT_REEST_TO	(3U * HZ)
#define XS_TCP_MAX_REEST_TO	(5U * 60 * HZ)

/*
 * TCP idle timeout; client drops the transport socket if it is idle
 * for this long.  Note that we also timeout UDP sockets to prevent
 * holding port numbers when there is no RPC traffic.
 */
#define XS_IDLE_DISC_TO		(5U * 60 * HZ)

182 183
#ifdef RPC_DEBUG
# undef  RPC_DEBUG_DATA
184
# define RPCDBG_FACILITY	RPCDBG_TRANS
185 186 187
#endif

#ifdef RPC_DEBUG_DATA
188
static void xs_pktdump(char *msg, u32 *packet, unsigned int count)
189
{
190 191
	u8 *buf = (u8 *) packet;
	int j;
192

193
	dprintk("RPC:       %s\n", msg);
194 195 196 197 198 199 200 201 202 203 204 205
	for (j = 0; j < count && j < 128; j += 4) {
		if (!(j & 31)) {
			if (j)
				dprintk("\n");
			dprintk("0x%04x ", j);
		}
		dprintk("%02x%02x%02x%02x ",
			buf[j], buf[j+1], buf[j+2], buf[j+3]);
	}
	dprintk("\n");
}
#else
206
static inline void xs_pktdump(char *msg, u32 *packet, unsigned int count)
207 208 209 210 211
{
	/* NOP */
}
#endif

212 213
struct sock_xprt {
	struct rpc_xprt		xprt;
214 215 216 217 218 219

	/*
	 * Network layer
	 */
	struct socket *		sock;
	struct sock *		inet;
220 221 222 223 224 225 226 227 228 229 230 231

	/*
	 * State of TCP reply receive
	 */
	__be32			tcp_fraghdr,
				tcp_xid;

	u32			tcp_offset,
				tcp_reclen;

	unsigned long		tcp_copied,
				tcp_flags;
232 233 234 235

	/*
	 * Connection of transports
	 */
236
	struct delayed_work	connect_worker;
237
	struct sockaddr_storage	addr;
238
	unsigned short		port;
239 240 241 242 243 244

	/*
	 * UDP socket buffer size parameters
	 */
	size_t			rcvsize,
				sndsize;
245 246 247 248 249 250 251

	/*
	 * Saved socket callback addresses
	 */
	void			(*old_data_ready)(struct sock *, int);
	void			(*old_state_change)(struct sock *);
	void			(*old_write_space)(struct sock *);
252 253
};

254 255 256 257 258 259 260 261
/*
 * TCP receive state flags
 */
#define TCP_RCV_LAST_FRAG	(1UL << 0)
#define TCP_RCV_COPY_FRAGHDR	(1UL << 1)
#define TCP_RCV_COPY_XID	(1UL << 2)
#define TCP_RCV_COPY_DATA	(1UL << 3)

262 263 264 265 266 267
static inline struct sockaddr *xs_addr(struct rpc_xprt *xprt)
{
	return (struct sockaddr *) &xprt->addr;
}

static inline struct sockaddr_in *xs_addr_in(struct rpc_xprt *xprt)
268
{
269 270 271 272 273 274 275 276
	return (struct sockaddr_in *) &xprt->addr;
}

static inline struct sockaddr_in6 *xs_addr_in6(struct rpc_xprt *xprt)
{
	return (struct sockaddr_in6 *) &xprt->addr;
}

277 278 279
static void xs_format_ipv4_peer_addresses(struct rpc_xprt *xprt,
					  const char *protocol,
					  const char *netid)
280
{
281
	struct sockaddr_in *addr = xs_addr_in(xprt);
282 283 284 285
	char *buf;

	buf = kzalloc(20, GFP_KERNEL);
	if (buf) {
286
		snprintf(buf, 20, NIPQUAD_FMT,
287 288 289 290 291 292 293 294 295 296 297
				NIPQUAD(addr->sin_addr.s_addr));
	}
	xprt->address_strings[RPC_DISPLAY_ADDR] = buf;

	buf = kzalloc(8, GFP_KERNEL);
	if (buf) {
		snprintf(buf, 8, "%u",
				ntohs(addr->sin_port));
	}
	xprt->address_strings[RPC_DISPLAY_PORT] = buf;

298
	xprt->address_strings[RPC_DISPLAY_PROTO] = protocol;
299 300 301

	buf = kzalloc(48, GFP_KERNEL);
	if (buf) {
302
		snprintf(buf, 48, "addr="NIPQUAD_FMT" port=%u proto=%s",
303 304
			NIPQUAD(addr->sin_addr.s_addr),
			ntohs(addr->sin_port),
305
			protocol);
306 307
	}
	xprt->address_strings[RPC_DISPLAY_ALL] = buf;
308 309 310 311 312 313 314 315 316 317 318 319 320 321

	buf = kzalloc(10, GFP_KERNEL);
	if (buf) {
		snprintf(buf, 10, "%02x%02x%02x%02x",
				NIPQUAD(addr->sin_addr.s_addr));
	}
	xprt->address_strings[RPC_DISPLAY_HEX_ADDR] = buf;

	buf = kzalloc(8, GFP_KERNEL);
	if (buf) {
		snprintf(buf, 8, "%4hx",
				ntohs(addr->sin_port));
	}
	xprt->address_strings[RPC_DISPLAY_HEX_PORT] = buf;
322 323 324 325 326 327 328 329 330

	buf = kzalloc(30, GFP_KERNEL);
	if (buf) {
		snprintf(buf, 30, NIPQUAD_FMT".%u.%u",
				NIPQUAD(addr->sin_addr.s_addr),
				ntohs(addr->sin_port) >> 8,
				ntohs(addr->sin_port) & 0xff);
	}
	xprt->address_strings[RPC_DISPLAY_UNIVERSAL_ADDR] = buf;
331

332
	xprt->address_strings[RPC_DISPLAY_NETID] = netid;
333 334
}

335 336 337
static void xs_format_ipv6_peer_addresses(struct rpc_xprt *xprt,
					  const char *protocol,
					  const char *netid)
338
{
339
	struct sockaddr_in6 *addr = xs_addr_in6(xprt);
340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355
	char *buf;

	buf = kzalloc(40, GFP_KERNEL);
	if (buf) {
		snprintf(buf, 40, NIP6_FMT,
				NIP6(addr->sin6_addr));
	}
	xprt->address_strings[RPC_DISPLAY_ADDR] = buf;

	buf = kzalloc(8, GFP_KERNEL);
	if (buf) {
		snprintf(buf, 8, "%u",
				ntohs(addr->sin6_port));
	}
	xprt->address_strings[RPC_DISPLAY_PORT] = buf;

356
	xprt->address_strings[RPC_DISPLAY_PROTO] = protocol;
357 358 359 360 361 362

	buf = kzalloc(64, GFP_KERNEL);
	if (buf) {
		snprintf(buf, 64, "addr="NIP6_FMT" port=%u proto=%s",
				NIP6(addr->sin6_addr),
				ntohs(addr->sin6_port),
363
				protocol);
364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379
	}
	xprt->address_strings[RPC_DISPLAY_ALL] = buf;

	buf = kzalloc(36, GFP_KERNEL);
	if (buf) {
		snprintf(buf, 36, NIP6_SEQFMT,
				NIP6(addr->sin6_addr));
	}
	xprt->address_strings[RPC_DISPLAY_HEX_ADDR] = buf;

	buf = kzalloc(8, GFP_KERNEL);
	if (buf) {
		snprintf(buf, 8, "%4hx",
				ntohs(addr->sin6_port));
	}
	xprt->address_strings[RPC_DISPLAY_HEX_PORT] = buf;
380 381 382 383 384 385 386 387 388

	buf = kzalloc(50, GFP_KERNEL);
	if (buf) {
		snprintf(buf, 50, NIP6_FMT".%u.%u",
				NIP6(addr->sin6_addr),
				ntohs(addr->sin6_port) >> 8,
				ntohs(addr->sin6_port) & 0xff);
	}
	xprt->address_strings[RPC_DISPLAY_UNIVERSAL_ADDR] = buf;
389

390
	xprt->address_strings[RPC_DISPLAY_NETID] = netid;
391 392 393 394
}

static void xs_free_peer_addresses(struct rpc_xprt *xprt)
{
395 396 397 398 399 400 401 402 403 404
	unsigned int i;

	for (i = 0; i < RPC_DISPLAY_MAX; i++)
		switch (i) {
		case RPC_DISPLAY_PROTO:
		case RPC_DISPLAY_NETID:
			continue;
		default:
			kfree(xprt->address_strings[i]);
		}
405 406
}

407 408
#define XS_SENDMSG_FLAGS	(MSG_DONTWAIT | MSG_NOSIGNAL)

T
Trond Myklebust 已提交
409
static int xs_send_kvec(struct socket *sock, struct sockaddr *addr, int addrlen, struct kvec *vec, unsigned int base, int more)
410 411 412 413
{
	struct msghdr msg = {
		.msg_name	= addr,
		.msg_namelen	= addrlen,
T
Trond Myklebust 已提交
414 415 416 417 418
		.msg_flags	= XS_SENDMSG_FLAGS | (more ? MSG_MORE : 0),
	};
	struct kvec iov = {
		.iov_base	= vec->iov_base + base,
		.iov_len	= vec->iov_len - base,
419 420
	};

T
Trond Myklebust 已提交
421
	if (iov.iov_len != 0)
422 423 424 425
		return kernel_sendmsg(sock, &msg, &iov, 1, iov.iov_len);
	return kernel_sendmsg(sock, &msg, NULL, 0, 0);
}

T
Trond Myklebust 已提交
426
static int xs_send_pagedata(struct socket *sock, struct xdr_buf *xdr, unsigned int base, int more)
427
{
T
Trond Myklebust 已提交
428 429 430 431 432 433 434 435 436 437 438
	struct page **ppage;
	unsigned int remainder;
	int err, sent = 0;

	remainder = xdr->page_len - base;
	base += xdr->page_base;
	ppage = xdr->pages + (base >> PAGE_SHIFT);
	base &= ~PAGE_MASK;
	for(;;) {
		unsigned int len = min_t(unsigned int, PAGE_SIZE - base, remainder);
		int flags = XS_SENDMSG_FLAGS;
439

T
Trond Myklebust 已提交
440 441 442 443 444 445 446 447 448 449 450 451 452 453 454
		remainder -= len;
		if (remainder != 0 || more)
			flags |= MSG_MORE;
		err = sock->ops->sendpage(sock, *ppage, base, len, flags);
		if (remainder == 0 || err != len)
			break;
		sent += err;
		ppage++;
		base = 0;
	}
	if (sent == 0)
		return err;
	if (err > 0)
		sent += err;
	return sent;
455 456
}

457 458 459 460 461 462 463 464
/**
 * xs_sendpages - write pages directly to a socket
 * @sock: socket to send on
 * @addr: UDP only -- address of destination
 * @addrlen: UDP only -- length of destination address
 * @xdr: buffer containing this request
 * @base: starting position in the buffer
 *
465
 */
T
Trond Myklebust 已提交
466
static int xs_sendpages(struct socket *sock, struct sockaddr *addr, int addrlen, struct xdr_buf *xdr, unsigned int base)
467
{
T
Trond Myklebust 已提交
468 469
	unsigned int remainder = xdr->len - base;
	int err, sent = 0;
470

471 472 473 474
	if (unlikely(!sock))
		return -ENOTCONN;

	clear_bit(SOCK_ASYNC_NOSPACE, &sock->flags);
T
Trond Myklebust 已提交
475 476 477 478
	if (base != 0) {
		addr = NULL;
		addrlen = 0;
	}
479

T
Trond Myklebust 已提交
480 481 482 483 484
	if (base < xdr->head[0].iov_len || addr != NULL) {
		unsigned int len = xdr->head[0].iov_len - base;
		remainder -= len;
		err = xs_send_kvec(sock, addr, addrlen, &xdr->head[0], base, remainder != 0);
		if (remainder == 0 || err != len)
485
			goto out;
T
Trond Myklebust 已提交
486
		sent += err;
487 488
		base = 0;
	} else
T
Trond Myklebust 已提交
489
		base -= xdr->head[0].iov_len;
490

T
Trond Myklebust 已提交
491 492 493 494 495
	if (base < xdr->page_len) {
		unsigned int len = xdr->page_len - base;
		remainder -= len;
		err = xs_send_pagedata(sock, xdr, base, remainder != 0);
		if (remainder == 0 || err != len)
496
			goto out;
T
Trond Myklebust 已提交
497
		sent += err;
498
		base = 0;
T
Trond Myklebust 已提交
499 500 501 502 503 504
	} else
		base -= xdr->page_len;

	if (base >= xdr->tail[0].iov_len)
		return sent;
	err = xs_send_kvec(sock, NULL, 0, &xdr->tail[0], base, 0);
505
out:
T
Trond Myklebust 已提交
506 507 508 509 510
	if (sent == 0)
		return err;
	if (err > 0)
		sent += err;
	return sent;
511 512
}

513 514 515 516 517 518 519 520
static void xs_nospace_callback(struct rpc_task *task)
{
	struct sock_xprt *transport = container_of(task->tk_rqstp->rq_xprt, struct sock_xprt, xprt);

	transport->inet->sk_write_pending--;
	clear_bit(SOCK_ASYNC_NOSPACE, &transport->sock->flags);
}

521
/**
522 523
 * xs_nospace - place task on wait queue if transmit was incomplete
 * @task: task to put to sleep
524
 *
525
 */
526
static void xs_nospace(struct rpc_task *task)
527
{
528 529
	struct rpc_rqst *req = task->tk_rqstp;
	struct rpc_xprt *xprt = req->rq_xprt;
530
	struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
531

532
	dprintk("RPC: %5u xmit incomplete (%u left of %u)\n",
533 534 535
			task->tk_pid, req->rq_slen - req->rq_bytes_sent,
			req->rq_slen);

536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554
	/* Protect against races with write_space */
	spin_lock_bh(&xprt->transport_lock);

	/* Don't race with disconnect */
	if (xprt_connected(xprt)) {
		if (test_bit(SOCK_ASYNC_NOSPACE, &transport->sock->flags)) {
			/*
			 * Notify TCP that we're limited by the application
			 * window size
			 */
			set_bit(SOCK_NOSPACE, &transport->sock->flags);
			transport->inet->sk_write_pending++;
			/* ...and wait for more buffer space */
			xprt_wait_for_buffer_space(task, xs_nospace_callback);
		}
	} else {
		clear_bit(SOCK_ASYNC_NOSPACE, &transport->sock->flags);
		task->tk_status = -ENOTCONN;
	}
555

556
	spin_unlock_bh(&xprt->transport_lock);
557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573
}

/**
 * xs_udp_send_request - write an RPC request to a UDP socket
 * @task: address of RPC task that manages the state of an RPC request
 *
 * Return values:
 *        0:	The request has been sent
 *   EAGAIN:	The socket was blocked, please call again later to
 *		complete the request
 * ENOTCONN:	Caller needs to invoke connect logic then call again
 *    other:	Some other error occured, the request was not sent
 */
static int xs_udp_send_request(struct rpc_task *task)
{
	struct rpc_rqst *req = task->tk_rqstp;
	struct rpc_xprt *xprt = req->rq_xprt;
574
	struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
575 576
	struct xdr_buf *xdr = &req->rq_snd_buf;
	int status;
577

578
	xs_pktdump("packet data:",
579 580 581
				req->rq_svec->iov_base,
				req->rq_svec->iov_len);

582
	status = xs_sendpages(transport->sock,
583
			      xs_addr(xprt),
584 585
			      xprt->addrlen, xdr,
			      req->rq_bytes_sent);
586

587
	dprintk("RPC:       xs_udp_send_request(%u) = %d\n",
588
			xdr->len - req->rq_bytes_sent, status);
589

590 591 592 593 594
	if (status >= 0) {
		task->tk_bytes_sent += status;
		if (status >= req->rq_slen)
			return 0;
		/* Still some bytes left; set up for a retry later. */
595
		status = -EAGAIN;
596
	}
597

598
	switch (status) {
599 600 601
	case -EAGAIN:
		xs_nospace(task);
		break;
602 603
	case -ENETUNREACH:
	case -EPIPE:
604 605
	case -ECONNREFUSED:
		/* When the server has died, an ICMP port unreachable message
606
		 * prompts ECONNREFUSED. */
607
		clear_bit(SOCK_ASYNC_NOSPACE, &transport->sock->flags);
608 609
		break;
	default:
610
		clear_bit(SOCK_ASYNC_NOSPACE, &transport->sock->flags);
611
		dprintk("RPC:       sendmsg returned unrecognized error %d\n",
612
			-status);
613
	}
614 615

	return status;
616 617
}

618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633
/**
 * xs_tcp_shutdown - gracefully shut down a TCP socket
 * @xprt: transport
 *
 * Initiates a graceful shutdown of the TCP socket by calling the
 * equivalent of shutdown(SHUT_WR);
 */
static void xs_tcp_shutdown(struct rpc_xprt *xprt)
{
	struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
	struct socket *sock = transport->sock;

	if (sock != NULL)
		kernel_sock_shutdown(sock, SHUT_WR);
}

634 635 636 637 638 639 640
static inline void xs_encode_tcp_record_marker(struct xdr_buf *buf)
{
	u32 reclen = buf->len - sizeof(rpc_fraghdr);
	rpc_fraghdr *base = buf->head[0].iov_base;
	*base = htonl(RPC_LAST_STREAM_FRAGMENT | reclen);
}

641
/**
642
 * xs_tcp_send_request - write an RPC request to a TCP socket
643 644 645
 * @task: address of RPC task that manages the state of an RPC request
 *
 * Return values:
646 647 648 649 650
 *        0:	The request has been sent
 *   EAGAIN:	The socket was blocked, please call again later to
 *		complete the request
 * ENOTCONN:	Caller needs to invoke connect logic then call again
 *    other:	Some other error occured, the request was not sent
651 652
 *
 * XXX: In the case of soft timeouts, should we eventually give up
653
 *	if sendmsg is not able to make progress?
654
 */
655
static int xs_tcp_send_request(struct rpc_task *task)
656 657 658
{
	struct rpc_rqst *req = task->tk_rqstp;
	struct rpc_xprt *xprt = req->rq_xprt;
659
	struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
660
	struct xdr_buf *xdr = &req->rq_snd_buf;
661
	int status;
662

663
	xs_encode_tcp_record_marker(&req->rq_snd_buf);
664

665 666 667
	xs_pktdump("packet data:",
				req->rq_svec->iov_base,
				req->rq_svec->iov_len);
668 669 670

	/* Continue transmitting the packet/record. We must be careful
	 * to cope with writespace callbacks arriving _after_ we have
671
	 * called sendmsg(). */
672
	while (1) {
673 674
		status = xs_sendpages(transport->sock,
					NULL, 0, xdr, req->rq_bytes_sent);
675

676
		dprintk("RPC:       xs_tcp_send_request(%u) = %d\n",
677
				xdr->len - req->rq_bytes_sent, status);
678

679
		if (unlikely(status < 0))
680 681
			break;

682 683 684
		/* If we've sent the entire packet, immediately
		 * reset the count of bytes sent. */
		req->rq_bytes_sent += status;
685
		task->tk_bytes_sent += status;
686 687 688 689
		if (likely(req->rq_bytes_sent >= req->rq_slen)) {
			req->rq_bytes_sent = 0;
			return 0;
		}
690

691 692
		if (status != 0)
			continue;
693
		status = -EAGAIN;
694
		break;
695 696
	}

697 698 699 700 701 702 703 704 705
	switch (status) {
	case -EAGAIN:
		xs_nospace(task);
		break;
	case -ECONNREFUSED:
	case -ECONNRESET:
	case -ENOTCONN:
	case -EPIPE:
		status = -ENOTCONN;
706
		clear_bit(SOCK_ASYNC_NOSPACE, &transport->sock->flags);
707 708
		break;
	default:
709
		dprintk("RPC:       sendmsg returned unrecognized error %d\n",
710
			-status);
711
		clear_bit(SOCK_ASYNC_NOSPACE, &transport->sock->flags);
712
		xs_tcp_shutdown(xprt);
713
	}
714

715 716 717
	return status;
}

718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744
/**
 * xs_tcp_release_xprt - clean up after a tcp transmission
 * @xprt: transport
 * @task: rpc task
 *
 * This cleans up if an error causes us to abort the transmission of a request.
 * In this case, the socket may need to be reset in order to avoid confusing
 * the server.
 */
static void xs_tcp_release_xprt(struct rpc_xprt *xprt, struct rpc_task *task)
{
	struct rpc_rqst *req;

	if (task != xprt->snd_task)
		return;
	if (task == NULL)
		goto out_release;
	req = task->tk_rqstp;
	if (req->rq_bytes_sent == 0)
		goto out_release;
	if (req->rq_bytes_sent == req->rq_snd_buf.len)
		goto out_release;
	set_bit(XPRT_CLOSE_WAIT, &task->tk_xprt->state);
out_release:
	xprt_release_xprt(xprt, task);
}

745 746 747 748
/**
 * xs_close - close a socket
 * @xprt: transport
 *
749 750
 * This is used when all requests are complete; ie, no DRC state remains
 * on the server we want to save.
751
 */
752
static void xs_close(struct rpc_xprt *xprt)
753
{
754 755 756
	struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
	struct socket *sock = transport->sock;
	struct sock *sk = transport->inet;
757 758

	if (!sk)
759
		goto clear_close_wait;
760

761
	dprintk("RPC:       xs_close xprt %p\n", xprt);
762

763
	write_lock_bh(&sk->sk_callback_lock);
764 765
	transport->inet = NULL;
	transport->sock = NULL;
766

767
	sk->sk_user_data = NULL;
768 769 770
	sk->sk_data_ready = transport->old_data_ready;
	sk->sk_state_change = transport->old_state_change;
	sk->sk_write_space = transport->old_write_space;
771 772
	write_unlock_bh(&sk->sk_callback_lock);

773
	sk->sk_no_check = 0;
774 775

	sock_release(sock);
776 777 778
clear_close_wait:
	smp_mb__before_clear_bit();
	clear_bit(XPRT_CLOSE_WAIT, &xprt->state);
779
	clear_bit(XPRT_CLOSING, &xprt->state);
780
	smp_mb__after_clear_bit();
781
	xprt_disconnect_done(xprt);
782 783
}

784 785 786 787 788 789
/**
 * xs_destroy - prepare to shutdown a transport
 * @xprt: doomed transport
 *
 */
static void xs_destroy(struct rpc_xprt *xprt)
790
{
791 792
	struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);

793
	dprintk("RPC:       xs_destroy xprt %p\n", xprt);
794

795
	cancel_rearming_delayed_work(&transport->connect_worker);
796

797
	xs_close(xprt);
798
	xs_free_peer_addresses(xprt);
799
	kfree(xprt->slot);
800
	kfree(xprt);
801
	module_put(THIS_MODULE);
802 803
}

804 805 806 807 808 809 810 811 812 813
static inline struct rpc_xprt *xprt_from_sock(struct sock *sk)
{
	return (struct rpc_xprt *) sk->sk_user_data;
}

/**
 * xs_udp_data_ready - "data ready" callback for UDP sockets
 * @sk: socket with data to read
 * @len: how much data to read
 *
814
 */
815
static void xs_udp_data_ready(struct sock *sk, int len)
816
{
817 818
	struct rpc_task *task;
	struct rpc_xprt *xprt;
819
	struct rpc_rqst *rovr;
820
	struct sk_buff *skb;
821
	int err, repsize, copied;
822 823
	u32 _xid;
	__be32 *xp;
824 825

	read_lock(&sk->sk_callback_lock);
826
	dprintk("RPC:       xs_udp_data_ready...\n");
827
	if (!(xprt = xprt_from_sock(sk)))
828 829 830 831 832 833 834 835 836 837
		goto out;

	if ((skb = skb_recv_datagram(sk, 0, 1, &err)) == NULL)
		goto out;

	if (xprt->shutdown)
		goto dropit;

	repsize = skb->len - sizeof(struct udphdr);
	if (repsize < 4) {
838
		dprintk("RPC:       impossible RPC reply size %d!\n", repsize);
839 840 841 842 843 844 845 846 847 848
		goto dropit;
	}

	/* Copy the XID from the skb... */
	xp = skb_header_pointer(skb, sizeof(struct udphdr),
				sizeof(_xid), &_xid);
	if (xp == NULL)
		goto dropit;

	/* Look up and lock the request corresponding to the given XID */
C
Chuck Lever 已提交
849
	spin_lock(&xprt->transport_lock);
850 851 852 853 854 855 856 857 858
	rovr = xprt_lookup_rqst(xprt, *xp);
	if (!rovr)
		goto out_unlock;
	task = rovr->rq_task;

	if ((copied = rovr->rq_private_buf.buflen) > repsize)
		copied = repsize;

	/* Suck it into the iovec, verify checksum if not done by hw. */
859 860
	if (csum_partial_copy_to_xdr(&rovr->rq_private_buf, skb)) {
		UDPX_INC_STATS_BH(sk, UDP_MIB_INERRORS);
861
		goto out_unlock;
862 863 864
	}

	UDPX_INC_STATS_BH(sk, UDP_MIB_INDATAGRAMS);
865 866 867 868

	/* Something worked... */
	dst_confirm(skb->dst);

869 870 871
	xprt_adjust_cwnd(task, copied);
	xprt_update_rtt(task);
	xprt_complete_rqst(task, copied);
872 873

 out_unlock:
C
Chuck Lever 已提交
874
	spin_unlock(&xprt->transport_lock);
875 876 877 878 879 880
 dropit:
	skb_free_datagram(sk, skb);
 out:
	read_unlock(&sk->sk_callback_lock);
}

881
static inline void xs_tcp_read_fraghdr(struct rpc_xprt *xprt, struct xdr_skb_reader *desc)
882
{
883
	struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
884 885 886
	size_t len, used;
	char *p;

887 888
	p = ((char *) &transport->tcp_fraghdr) + transport->tcp_offset;
	len = sizeof(transport->tcp_fraghdr) - transport->tcp_offset;
889
	used = xdr_skb_read_bits(desc, p, len);
890
	transport->tcp_offset += used;
891 892
	if (used != len)
		return;
893

894 895
	transport->tcp_reclen = ntohl(transport->tcp_fraghdr);
	if (transport->tcp_reclen & RPC_LAST_STREAM_FRAGMENT)
896
		transport->tcp_flags |= TCP_RCV_LAST_FRAG;
897
	else
898
		transport->tcp_flags &= ~TCP_RCV_LAST_FRAG;
899
	transport->tcp_reclen &= RPC_FRAGMENT_SIZE_MASK;
900

901
	transport->tcp_flags &= ~TCP_RCV_COPY_FRAGHDR;
902
	transport->tcp_offset = 0;
903

904
	/* Sanity check of the record length */
905
	if (unlikely(transport->tcp_reclen < 4)) {
906
		dprintk("RPC:       invalid TCP record fragment length\n");
907
		xprt_force_disconnect(xprt);
908
		return;
909
	}
910
	dprintk("RPC:       reading TCP record fragment of length %d\n",
911
			transport->tcp_reclen);
912 913
}

914
static void xs_tcp_check_fraghdr(struct sock_xprt *transport)
915
{
916
	if (transport->tcp_offset == transport->tcp_reclen) {
917
		transport->tcp_flags |= TCP_RCV_COPY_FRAGHDR;
918
		transport->tcp_offset = 0;
919 920 921
		if (transport->tcp_flags & TCP_RCV_LAST_FRAG) {
			transport->tcp_flags &= ~TCP_RCV_COPY_DATA;
			transport->tcp_flags |= TCP_RCV_COPY_XID;
922
			transport->tcp_copied = 0;
923 924 925 926
		}
	}
}

927
static inline void xs_tcp_read_xid(struct sock_xprt *transport, struct xdr_skb_reader *desc)
928 929 930 931
{
	size_t len, used;
	char *p;

932
	len = sizeof(transport->tcp_xid) - transport->tcp_offset;
933
	dprintk("RPC:       reading XID (%Zu bytes)\n", len);
934
	p = ((char *) &transport->tcp_xid) + transport->tcp_offset;
935
	used = xdr_skb_read_bits(desc, p, len);
936
	transport->tcp_offset += used;
937 938
	if (used != len)
		return;
939 940
	transport->tcp_flags &= ~TCP_RCV_COPY_XID;
	transport->tcp_flags |= TCP_RCV_COPY_DATA;
941
	transport->tcp_copied = 4;
942
	dprintk("RPC:       reading reply for XID %08x\n",
943 944
			ntohl(transport->tcp_xid));
	xs_tcp_check_fraghdr(transport);
945 946
}

947
static inline void xs_tcp_read_request(struct rpc_xprt *xprt, struct xdr_skb_reader *desc)
948
{
949
	struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
950 951 952 953 954 955
	struct rpc_rqst *req;
	struct xdr_buf *rcvbuf;
	size_t len;
	ssize_t r;

	/* Find and lock the request corresponding to this xid */
C
Chuck Lever 已提交
956
	spin_lock(&xprt->transport_lock);
957
	req = xprt_lookup_rqst(xprt, transport->tcp_xid);
958
	if (!req) {
959
		transport->tcp_flags &= ~TCP_RCV_COPY_DATA;
960
		dprintk("RPC:       XID %08x request not found!\n",
961
				ntohl(transport->tcp_xid));
C
Chuck Lever 已提交
962
		spin_unlock(&xprt->transport_lock);
963 964 965 966 967
		return;
	}

	rcvbuf = &req->rq_private_buf;
	len = desc->count;
968
	if (len > transport->tcp_reclen - transport->tcp_offset) {
969
		struct xdr_skb_reader my_desc;
970

971
		len = transport->tcp_reclen - transport->tcp_offset;
972 973
		memcpy(&my_desc, desc, sizeof(my_desc));
		my_desc.count = len;
974
		r = xdr_partial_copy_from_skb(rcvbuf, transport->tcp_copied,
975
					  &my_desc, xdr_skb_read_bits);
976 977 978
		desc->count -= r;
		desc->offset += r;
	} else
979
		r = xdr_partial_copy_from_skb(rcvbuf, transport->tcp_copied,
980
					  desc, xdr_skb_read_bits);
981 982

	if (r > 0) {
983 984
		transport->tcp_copied += r;
		transport->tcp_offset += r;
985 986 987 988 989
	}
	if (r != len) {
		/* Error when copying to the receive buffer,
		 * usually because we weren't able to allocate
		 * additional buffer pages. All we can do now
990
		 * is turn off TCP_RCV_COPY_DATA, so the request
991 992 993 994 995
		 * will not receive any additional updates,
		 * and time out.
		 * Any remaining data from this record will
		 * be discarded.
		 */
996
		transport->tcp_flags &= ~TCP_RCV_COPY_DATA;
997
		dprintk("RPC:       XID %08x truncated request\n",
998
				ntohl(transport->tcp_xid));
999 1000 1001 1002
		dprintk("RPC:       xprt = %p, tcp_copied = %lu, "
				"tcp_offset = %u, tcp_reclen = %u\n",
				xprt, transport->tcp_copied,
				transport->tcp_offset, transport->tcp_reclen);
1003 1004 1005
		goto out;
	}

1006
	dprintk("RPC:       XID %08x read %Zd bytes\n",
1007
			ntohl(transport->tcp_xid), r);
1008 1009 1010
	dprintk("RPC:       xprt = %p, tcp_copied = %lu, tcp_offset = %u, "
			"tcp_reclen = %u\n", xprt, transport->tcp_copied,
			transport->tcp_offset, transport->tcp_reclen);
1011 1012

	if (transport->tcp_copied == req->rq_private_buf.buflen)
1013
		transport->tcp_flags &= ~TCP_RCV_COPY_DATA;
1014
	else if (transport->tcp_offset == transport->tcp_reclen) {
1015 1016
		if (transport->tcp_flags & TCP_RCV_LAST_FRAG)
			transport->tcp_flags &= ~TCP_RCV_COPY_DATA;
1017 1018 1019
	}

out:
1020
	if (!(transport->tcp_flags & TCP_RCV_COPY_DATA))
1021
		xprt_complete_rqst(req->rq_task, transport->tcp_copied);
C
Chuck Lever 已提交
1022
	spin_unlock(&xprt->transport_lock);
1023
	xs_tcp_check_fraghdr(transport);
1024 1025
}

1026
static inline void xs_tcp_read_discard(struct sock_xprt *transport, struct xdr_skb_reader *desc)
1027 1028 1029
{
	size_t len;

1030
	len = transport->tcp_reclen - transport->tcp_offset;
1031 1032 1033 1034
	if (len > desc->count)
		len = desc->count;
	desc->count -= len;
	desc->offset += len;
1035
	transport->tcp_offset += len;
1036
	dprintk("RPC:       discarded %Zu bytes\n", len);
1037
	xs_tcp_check_fraghdr(transport);
1038 1039
}

1040
static int xs_tcp_data_recv(read_descriptor_t *rd_desc, struct sk_buff *skb, unsigned int offset, size_t len)
1041 1042
{
	struct rpc_xprt *xprt = rd_desc->arg.data;
1043
	struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
1044
	struct xdr_skb_reader desc = {
1045 1046 1047
		.skb	= skb,
		.offset	= offset,
		.count	= len,
1048
	};
1049

1050
	dprintk("RPC:       xs_tcp_data_recv started\n");
1051 1052 1053
	do {
		/* Read in a new fragment marker if necessary */
		/* Can we ever really expect to get completely empty fragments? */
1054
		if (transport->tcp_flags & TCP_RCV_COPY_FRAGHDR) {
1055
			xs_tcp_read_fraghdr(xprt, &desc);
1056 1057 1058
			continue;
		}
		/* Read in the xid if necessary */
1059
		if (transport->tcp_flags & TCP_RCV_COPY_XID) {
1060
			xs_tcp_read_xid(transport, &desc);
1061 1062 1063
			continue;
		}
		/* Read in the request data */
1064
		if (transport->tcp_flags & TCP_RCV_COPY_DATA) {
1065
			xs_tcp_read_request(xprt, &desc);
1066 1067 1068
			continue;
		}
		/* Skip over any trailing bytes on short reads */
1069
		xs_tcp_read_discard(transport, &desc);
1070
	} while (desc.count);
1071
	dprintk("RPC:       xs_tcp_data_recv done\n");
1072 1073 1074
	return len - desc.count;
}

1075 1076 1077 1078 1079 1080 1081
/**
 * xs_tcp_data_ready - "data ready" callback for TCP sockets
 * @sk: socket with data to read
 * @bytes: how much data to read
 *
 */
static void xs_tcp_data_ready(struct sock *sk, int bytes)
1082 1083 1084
{
	struct rpc_xprt *xprt;
	read_descriptor_t rd_desc;
1085
	int read;
1086

1087 1088
	dprintk("RPC:       xs_tcp_data_ready...\n");

1089
	read_lock(&sk->sk_callback_lock);
1090
	if (!(xprt = xprt_from_sock(sk)))
1091 1092 1093 1094
		goto out;
	if (xprt->shutdown)
		goto out;

1095
	/* We use rd_desc to pass struct xprt to xs_tcp_data_recv */
1096
	rd_desc.arg.data = xprt;
1097 1098 1099 1100
	do {
		rd_desc.count = 65536;
		read = tcp_read_sock(sk, &rd_desc, xs_tcp_data_recv);
	} while (read > 0);
1101 1102 1103 1104
out:
	read_unlock(&sk->sk_callback_lock);
}

1105 1106 1107 1108 1109 1110
/**
 * xs_tcp_state_change - callback to handle TCP socket state changes
 * @sk: socket whose state has changed
 *
 */
static void xs_tcp_state_change(struct sock *sk)
1111
{
1112
	struct rpc_xprt *xprt;
1113 1114 1115 1116

	read_lock(&sk->sk_callback_lock);
	if (!(xprt = xprt_from_sock(sk)))
		goto out;
1117 1118 1119 1120 1121
	dprintk("RPC:       xs_tcp_state_change client %p...\n", xprt);
	dprintk("RPC:       state %x conn %d dead %d zapped %d\n",
			sk->sk_state, xprt_connected(xprt),
			sock_flag(sk, SOCK_DEAD),
			sock_flag(sk, SOCK_ZAPPED));
1122 1123 1124

	switch (sk->sk_state) {
	case TCP_ESTABLISHED:
C
Chuck Lever 已提交
1125
		spin_lock_bh(&xprt->transport_lock);
1126
		if (!xprt_test_and_set_connected(xprt)) {
1127 1128 1129
			struct sock_xprt *transport = container_of(xprt,
					struct sock_xprt, xprt);

1130
			/* Reset TCP record info */
1131 1132 1133
			transport->tcp_offset = 0;
			transport->tcp_reclen = 0;
			transport->tcp_copied = 0;
1134 1135
			transport->tcp_flags =
				TCP_RCV_COPY_FRAGHDR | TCP_RCV_COPY_XID;
1136

1137
			xprt_wake_pending_tasks(xprt, 0);
1138
		}
C
Chuck Lever 已提交
1139
		spin_unlock_bh(&xprt->transport_lock);
1140
		break;
1141 1142
	case TCP_FIN_WAIT1:
		/* The client initiated a shutdown of the socket */
1143
		xprt->connect_cookie++;
1144
		xprt->reestablish_timeout = 0;
1145 1146 1147
		set_bit(XPRT_CLOSING, &xprt->state);
		smp_mb__before_clear_bit();
		clear_bit(XPRT_CONNECTED, &xprt->state);
1148
		clear_bit(XPRT_CLOSE_WAIT, &xprt->state);
1149
		smp_mb__after_clear_bit();
1150
		break;
1151
	case TCP_CLOSE_WAIT:
1152 1153
		/* The server initiated a shutdown of the socket */
		set_bit(XPRT_CLOSING, &xprt->state);
1154
		xprt_force_disconnect(xprt);
1155
	case TCP_SYN_SENT:
1156
		xprt->connect_cookie++;
1157 1158 1159 1160 1161 1162 1163
	case TCP_CLOSING:
		/*
		 * If the server closed down the connection, make sure that
		 * we back off before reconnecting
		 */
		if (xprt->reestablish_timeout < XS_TCP_INIT_REEST_TO)
			xprt->reestablish_timeout = XS_TCP_INIT_REEST_TO;
1164 1165 1166 1167 1168 1169 1170 1171
		break;
	case TCP_LAST_ACK:
		smp_mb__before_clear_bit();
		clear_bit(XPRT_CONNECTED, &xprt->state);
		smp_mb__after_clear_bit();
		break;
	case TCP_CLOSE:
		smp_mb__before_clear_bit();
1172
		clear_bit(XPRT_CLOSE_WAIT, &xprt->state);
1173 1174 1175
		clear_bit(XPRT_CLOSING, &xprt->state);
		smp_mb__after_clear_bit();
		/* Mark transport as closed and wake up all pending tasks */
1176
		xprt_disconnect_done(xprt);
1177 1178 1179 1180 1181
	}
 out:
	read_unlock(&sk->sk_callback_lock);
}

1182
/**
1183 1184
 * xs_udp_write_space - callback invoked when socket buffer space
 *                             becomes available
1185 1186
 * @sk: socket whose state has changed
 *
1187 1188
 * Called when more output buffer space is available for this socket.
 * We try not to wake our writers until they can make "significant"
1189
 * progress, otherwise we'll waste resources thrashing kernel_sendmsg
1190 1191
 * with a bunch of small requests.
 */
1192
static void xs_udp_write_space(struct sock *sk)
1193 1194 1195
{
	read_lock(&sk->sk_callback_lock);

1196 1197 1198 1199 1200 1201
	/* from net/core/sock.c:sock_def_write_space */
	if (sock_writeable(sk)) {
		struct socket *sock;
		struct rpc_xprt *xprt;

		if (unlikely(!(sock = sk->sk_socket)))
1202
			goto out;
1203 1204
		clear_bit(SOCK_NOSPACE, &sock->flags);

1205 1206
		if (unlikely(!(xprt = xprt_from_sock(sk))))
			goto out;
1207
		if (test_and_clear_bit(SOCK_ASYNC_NOSPACE, &sock->flags) == 0)
1208
			goto out;
1209 1210

		xprt_write_space(xprt);
1211 1212
	}

1213 1214 1215
 out:
	read_unlock(&sk->sk_callback_lock);
}
1216

1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237
/**
 * xs_tcp_write_space - callback invoked when socket buffer space
 *                             becomes available
 * @sk: socket whose state has changed
 *
 * Called when more output buffer space is available for this socket.
 * We try not to wake our writers until they can make "significant"
 * progress, otherwise we'll waste resources thrashing kernel_sendmsg
 * with a bunch of small requests.
 */
static void xs_tcp_write_space(struct sock *sk)
{
	read_lock(&sk->sk_callback_lock);

	/* from net/core/stream.c:sk_stream_write_space */
	if (sk_stream_wspace(sk) >= sk_stream_min_wspace(sk)) {
		struct socket *sock;
		struct rpc_xprt *xprt;

		if (unlikely(!(sock = sk->sk_socket)))
			goto out;
1238 1239
		clear_bit(SOCK_NOSPACE, &sock->flags);

1240 1241
		if (unlikely(!(xprt = xprt_from_sock(sk))))
			goto out;
1242
		if (test_and_clear_bit(SOCK_ASYNC_NOSPACE, &sock->flags) == 0)
1243 1244 1245 1246 1247 1248
			goto out;

		xprt_write_space(xprt);
	}

 out:
1249 1250 1251
	read_unlock(&sk->sk_callback_lock);
}

1252
static void xs_udp_do_set_buffer_size(struct rpc_xprt *xprt)
1253
{
1254 1255
	struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
	struct sock *sk = transport->inet;
1256

1257
	if (transport->rcvsize) {
1258
		sk->sk_userlocks |= SOCK_RCVBUF_LOCK;
1259
		sk->sk_rcvbuf = transport->rcvsize * xprt->max_reqs * 2;
1260
	}
1261
	if (transport->sndsize) {
1262
		sk->sk_userlocks |= SOCK_SNDBUF_LOCK;
1263
		sk->sk_sndbuf = transport->sndsize * xprt->max_reqs * 2;
1264 1265 1266 1267
		sk->sk_write_space(sk);
	}
}

1268
/**
1269
 * xs_udp_set_buffer_size - set send and receive limits
1270
 * @xprt: generic transport
1271 1272
 * @sndsize: requested size of send buffer, in bytes
 * @rcvsize: requested size of receive buffer, in bytes
1273
 *
1274
 * Set socket send and receive buffer size limits.
1275
 */
1276
static void xs_udp_set_buffer_size(struct rpc_xprt *xprt, size_t sndsize, size_t rcvsize)
1277
{
1278 1279 1280
	struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);

	transport->sndsize = 0;
1281
	if (sndsize)
1282 1283
		transport->sndsize = sndsize + 1024;
	transport->rcvsize = 0;
1284
	if (rcvsize)
1285
		transport->rcvsize = rcvsize + 1024;
1286 1287

	xs_udp_do_set_buffer_size(xprt);
1288 1289
}

1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300
/**
 * xs_udp_timer - called when a retransmit timeout occurs on a UDP transport
 * @task: task that timed out
 *
 * Adjust the congestion window after a retransmit timeout has occurred.
 */
static void xs_udp_timer(struct rpc_task *task)
{
	xprt_adjust_cwnd(task, -ETIMEDOUT);
}

1301 1302 1303 1304 1305 1306 1307
static unsigned short xs_get_random_port(void)
{
	unsigned short range = xprt_max_resvport - xprt_min_resvport;
	unsigned short rand = (unsigned short) net_random() % range;
	return rand + xprt_min_resvport;
}

1308 1309 1310 1311 1312 1313 1314 1315
/**
 * xs_set_port - reset the port number in the remote endpoint address
 * @xprt: generic transport
 * @port: new port number
 *
 */
static void xs_set_port(struct rpc_xprt *xprt, unsigned short port)
{
1316
	struct sockaddr *addr = xs_addr(xprt);
1317

1318
	dprintk("RPC:       setting port for xprt %p to %u\n", xprt, port);
1319

1320 1321 1322 1323 1324 1325 1326 1327 1328 1329
	switch (addr->sa_family) {
	case AF_INET:
		((struct sockaddr_in *)addr)->sin_port = htons(port);
		break;
	case AF_INET6:
		((struct sockaddr_in6 *)addr)->sin6_port = htons(port);
		break;
	default:
		BUG();
	}
1330 1331
}

1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351
static unsigned short xs_get_srcport(struct sock_xprt *transport, struct socket *sock)
{
	unsigned short port = transport->port;

	if (port == 0 && transport->xprt.resvport)
		port = xs_get_random_port();
	return port;
}

static unsigned short xs_next_srcport(struct sock_xprt *transport, struct socket *sock, unsigned short port)
{
	if (transport->port != 0)
		transport->port = 0;
	if (!transport->xprt.resvport)
		return 0;
	if (port <= xprt_min_resvport || port > xprt_max_resvport)
		return xprt_max_resvport;
	return --port;
}

1352
static int xs_bind4(struct sock_xprt *transport, struct socket *sock)
1353 1354 1355 1356
{
	struct sockaddr_in myaddr = {
		.sin_family = AF_INET,
	};
1357
	struct sockaddr_in *sa;
1358 1359 1360
	int err, nloop = 0;
	unsigned short port = xs_get_srcport(transport, sock);
	unsigned short last;
1361

1362 1363
	sa = (struct sockaddr_in *)&transport->addr;
	myaddr.sin_addr = sa->sin_addr;
1364 1365
	do {
		myaddr.sin_port = htons(port);
1366
		err = kernel_bind(sock, (struct sockaddr *) &myaddr,
1367
						sizeof(myaddr));
1368
		if (port == 0)
1369
			break;
1370
		if (err == 0) {
1371
			transport->port = port;
1372
			break;
1373
		}
1374 1375 1376 1377 1378
		last = port;
		port = xs_next_srcport(transport, sock, port);
		if (port > last)
			nloop++;
	} while (err == -EADDRINUSE && nloop != 2);
1379
	dprintk("RPC:       %s "NIPQUAD_FMT":%u: %s (%d)\n",
1380
			__func__, NIPQUAD(myaddr.sin_addr),
1381
			port, err ? "failed" : "ok", err);
1382 1383 1384
	return err;
}

1385 1386 1387 1388 1389 1390
static int xs_bind6(struct sock_xprt *transport, struct socket *sock)
{
	struct sockaddr_in6 myaddr = {
		.sin6_family = AF_INET6,
	};
	struct sockaddr_in6 *sa;
1391 1392 1393
	int err, nloop = 0;
	unsigned short port = xs_get_srcport(transport, sock);
	unsigned short last;
1394 1395 1396 1397 1398 1399 1400

	sa = (struct sockaddr_in6 *)&transport->addr;
	myaddr.sin6_addr = sa->sin6_addr;
	do {
		myaddr.sin6_port = htons(port);
		err = kernel_bind(sock, (struct sockaddr *) &myaddr,
						sizeof(myaddr));
1401
		if (port == 0)
1402 1403 1404 1405 1406
			break;
		if (err == 0) {
			transport->port = port;
			break;
		}
1407 1408 1409 1410 1411
		last = port;
		port = xs_next_srcport(transport, sock, port);
		if (port > last)
			nloop++;
	} while (err == -EADDRINUSE && nloop != 2);
1412 1413
	dprintk("RPC:       xs_bind6 "NIP6_FMT":%u: %s (%d)\n",
		NIP6(myaddr.sin6_addr), port, err ? "failed" : "ok", err);
1414 1415 1416
	return err;
}

1417 1418 1419 1420
#ifdef CONFIG_DEBUG_LOCK_ALLOC
static struct lock_class_key xs_key[2];
static struct lock_class_key xs_slock_key[2];

1421
static inline void xs_reclassify_socket4(struct socket *sock)
1422 1423
{
	struct sock *sk = sock->sk;
1424

1425
	BUG_ON(sock_owned_by_user(sk));
1426 1427 1428
	sock_lock_init_class_and_name(sk, "slock-AF_INET-RPC",
		&xs_slock_key[0], "sk_lock-AF_INET-RPC", &xs_key[0]);
}
1429

1430 1431 1432
static inline void xs_reclassify_socket6(struct socket *sock)
{
	struct sock *sk = sock->sk;
1433

1434
	BUG_ON(sock_owned_by_user(sk));
1435 1436
	sock_lock_init_class_and_name(sk, "slock-AF_INET6-RPC",
		&xs_slock_key[1], "sk_lock-AF_INET6-RPC", &xs_key[1]);
1437 1438
}
#else
1439 1440 1441 1442 1443
static inline void xs_reclassify_socket4(struct socket *sock)
{
}

static inline void xs_reclassify_socket6(struct socket *sock)
1444 1445 1446 1447
{
}
#endif

1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476
static void xs_udp_finish_connecting(struct rpc_xprt *xprt, struct socket *sock)
{
	struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);

	if (!transport->inet) {
		struct sock *sk = sock->sk;

		write_lock_bh(&sk->sk_callback_lock);

		sk->sk_user_data = xprt;
		transport->old_data_ready = sk->sk_data_ready;
		transport->old_state_change = sk->sk_state_change;
		transport->old_write_space = sk->sk_write_space;
		sk->sk_data_ready = xs_udp_data_ready;
		sk->sk_write_space = xs_udp_write_space;
		sk->sk_no_check = UDP_CSUM_NORCV;
		sk->sk_allocation = GFP_ATOMIC;

		xprt_set_connected(xprt);

		/* Reset to new socket */
		transport->sock = sock;
		transport->inet = sk;

		write_unlock_bh(&sk->sk_callback_lock);
	}
	xs_udp_do_set_buffer_size(xprt);
}

1477
/**
C
Chuck Lever 已提交
1478
 * xs_udp_connect_worker4 - set up a UDP socket
1479
 * @work: RPC transport to connect
1480 1481 1482
 *
 * Invoked by a work queue tasklet.
 */
C
Chuck Lever 已提交
1483
static void xs_udp_connect_worker4(struct work_struct *work)
1484
{
1485 1486
	struct sock_xprt *transport =
		container_of(work, struct sock_xprt, connect_worker.work);
1487
	struct rpc_xprt *xprt = &transport->xprt;
1488
	struct socket *sock = transport->sock;
1489
	int err, status = -EIO;
1490

1491
	if (xprt->shutdown || !xprt_bound(xprt))
1492
		goto out;
1493

1494 1495
	/* Start by resetting any existing state */
	xs_close(xprt);
1496

1497
	if ((err = sock_create_kern(PF_INET, SOCK_DGRAM, IPPROTO_UDP, &sock)) < 0) {
1498
		dprintk("RPC:       can't create UDP transport socket (%d).\n", -err);
1499 1500
		goto out;
	}
1501
	xs_reclassify_socket4(sock);
1502

1503
	if (xs_bind4(transport, sock)) {
1504 1505 1506
		sock_release(sock);
		goto out;
	}
1507

1508
	dprintk("RPC:       worker connecting xprt %p to address: %s\n",
1509
			xprt, xprt->address_strings[RPC_DISPLAY_ALL]);
1510

1511
	xs_udp_finish_connecting(xprt, sock);
1512 1513 1514 1515
	status = 0;
out:
	xprt_wake_pending_tasks(xprt, status);
	xprt_clear_connecting(xprt);
1516 1517
}

1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530
/**
 * xs_udp_connect_worker6 - set up a UDP socket
 * @work: RPC transport to connect
 *
 * Invoked by a work queue tasklet.
 */
static void xs_udp_connect_worker6(struct work_struct *work)
{
	struct sock_xprt *transport =
		container_of(work, struct sock_xprt, connect_worker.work);
	struct rpc_xprt *xprt = &transport->xprt;
	struct socket *sock = transport->sock;
	int err, status = -EIO;
1531

1532 1533
	if (xprt->shutdown || !xprt_bound(xprt))
		goto out;
1534

1535 1536
	/* Start by resetting any existing state */
	xs_close(xprt);
1537

1538 1539 1540 1541
	if ((err = sock_create_kern(PF_INET6, SOCK_DGRAM, IPPROTO_UDP, &sock)) < 0) {
		dprintk("RPC:       can't create UDP transport socket (%d).\n", -err);
		goto out;
	}
1542
	xs_reclassify_socket6(sock);
1543

1544 1545 1546
	if (xs_bind6(transport, sock) < 0) {
		sock_release(sock);
		goto out;
1547
	}
1548 1549 1550 1551 1552

	dprintk("RPC:       worker connecting xprt %p to address: %s\n",
			xprt, xprt->address_strings[RPC_DISPLAY_ALL]);

	xs_udp_finish_connecting(xprt, sock);
1553 1554 1555 1556
	status = 0;
out:
	xprt_wake_pending_tasks(xprt, status);
	xprt_clear_connecting(xprt);
1557 1558
}

1559 1560 1561 1562 1563 1564 1565
/*
 * We need to preserve the port number so the reply cache on the server can
 * find our cached RPC replies when we get around to reconnecting.
 */
static void xs_tcp_reuse_connection(struct rpc_xprt *xprt)
{
	int result;
1566
	struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
1567 1568
	struct sockaddr any;

1569
	dprintk("RPC:       disconnecting xprt %p to reuse port\n", xprt);
1570 1571 1572 1573 1574 1575 1576

	/*
	 * Disconnect the transport socket by doing a connect operation
	 * with AF_UNSPEC.  This should return immediately...
	 */
	memset(&any, 0, sizeof(any));
	any.sa_family = AF_UNSPEC;
1577
	result = kernel_connect(transport->sock, &any, sizeof(any), 0);
1578
	if (result)
1579
		dprintk("RPC:       AF_UNSPEC connect return code %d\n",
1580 1581 1582
				result);
}

1583
static int xs_tcp_finish_connecting(struct rpc_xprt *xprt, struct socket *sock)
1584
{
1585
	struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
1586

1587
	if (!transport->inet) {
1588 1589 1590 1591 1592
		struct sock *sk = sock->sk;

		write_lock_bh(&sk->sk_callback_lock);

		sk->sk_user_data = xprt;
1593 1594 1595
		transport->old_data_ready = sk->sk_data_ready;
		transport->old_state_change = sk->sk_state_change;
		transport->old_write_space = sk->sk_write_space;
1596 1597 1598
		sk->sk_data_ready = xs_tcp_data_ready;
		sk->sk_state_change = xs_tcp_state_change;
		sk->sk_write_space = xs_tcp_write_space;
1599
		sk->sk_allocation = GFP_ATOMIC;
1600 1601 1602 1603 1604 1605

		/* socket options */
		sk->sk_userlocks |= SOCK_BINDPORT_LOCK;
		sock_reset_flag(sk, SOCK_LINGER);
		tcp_sk(sk)->linger2 = 0;
		tcp_sk(sk)->nonagle |= TCP_NAGLE_OFF;
1606 1607 1608 1609

		xprt_clear_connected(xprt);

		/* Reset to new socket */
1610 1611
		transport->sock = sock;
		transport->inet = sk;
1612 1613 1614 1615 1616

		write_unlock_bh(&sk->sk_callback_lock);
	}

	/* Tell the socket layer to start connecting... */
1617 1618
	xprt->stat.connect_count++;
	xprt->stat.connect_start = jiffies;
1619
	return kernel_connect(sock, xs_addr(xprt), xprt->addrlen, O_NONBLOCK);
1620 1621
}

1622
/**
C
Chuck Lever 已提交
1623
 * xs_tcp_connect_worker4 - connect a TCP socket to a remote endpoint
1624
 * @work: RPC transport to connect
1625 1626
 *
 * Invoked by a work queue tasklet.
1627
 */
C
Chuck Lever 已提交
1628
static void xs_tcp_connect_worker4(struct work_struct *work)
1629
{
1630 1631
	struct sock_xprt *transport =
		container_of(work, struct sock_xprt, connect_worker.work);
1632
	struct rpc_xprt *xprt = &transport->xprt;
1633
	struct socket *sock = transport->sock;
1634
	int err, status = -EIO;
1635

1636
	if (xprt->shutdown || !xprt_bound(xprt))
1637 1638
		goto out;

1639
	if (!sock) {
1640 1641
		/* start from scratch */
		if ((err = sock_create_kern(PF_INET, SOCK_STREAM, IPPROTO_TCP, &sock)) < 0) {
1642
			dprintk("RPC:       can't create TCP transport socket (%d).\n", -err);
1643 1644
			goto out;
		}
1645
		xs_reclassify_socket4(sock);
1646

1647
		if (xs_bind4(transport, sock) < 0) {
1648 1649 1650 1651 1652 1653
			sock_release(sock);
			goto out;
		}
	} else
		/* "close" the socket, preserving the local port */
		xs_tcp_reuse_connection(xprt);
1654

1655
	dprintk("RPC:       worker connecting xprt %p to address: %s\n",
1656
			xprt, xprt->address_strings[RPC_DISPLAY_ALL]);
1657

1658
	status = xs_tcp_finish_connecting(xprt, sock);
1659 1660 1661
	dprintk("RPC:       %p connect status %d connected %d sock state %d\n",
			xprt, -status, xprt_connected(xprt),
			sock->sk->sk_state);
1662 1663 1664 1665 1666
	if (status < 0) {
		switch (status) {
			case -EINPROGRESS:
			case -EALREADY:
				goto out_clear;
1667 1668 1669 1670 1671 1672
			case -ECONNREFUSED:
			case -ECONNRESET:
				/* retry with existing socket, after a delay */
				break;
			default:
				/* get rid of existing socket, and retry */
1673
				xs_tcp_shutdown(xprt);
1674 1675 1676
		}
	}
out:
1677
	xprt_wake_pending_tasks(xprt, status);
1678 1679 1680
out_clear:
	xprt_clear_connecting(xprt);
}
1681

1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694
/**
 * xs_tcp_connect_worker6 - connect a TCP socket to a remote endpoint
 * @work: RPC transport to connect
 *
 * Invoked by a work queue tasklet.
 */
static void xs_tcp_connect_worker6(struct work_struct *work)
{
	struct sock_xprt *transport =
		container_of(work, struct sock_xprt, connect_worker.work);
	struct rpc_xprt *xprt = &transport->xprt;
	struct socket *sock = transport->sock;
	int err, status = -EIO;
1695

1696 1697
	if (xprt->shutdown || !xprt_bound(xprt))
		goto out;
1698

1699 1700 1701 1702 1703 1704
	if (!sock) {
		/* start from scratch */
		if ((err = sock_create_kern(PF_INET6, SOCK_STREAM, IPPROTO_TCP, &sock)) < 0) {
			dprintk("RPC:       can't create TCP transport socket (%d).\n", -err);
			goto out;
		}
1705
		xs_reclassify_socket6(sock);
1706

1707 1708 1709 1710 1711 1712 1713
		if (xs_bind6(transport, sock) < 0) {
			sock_release(sock);
			goto out;
		}
	} else
		/* "close" the socket, preserving the local port */
		xs_tcp_reuse_connection(xprt);
1714

1715 1716
	dprintk("RPC:       worker connecting xprt %p to address: %s\n",
			xprt, xprt->address_strings[RPC_DISPLAY_ALL]);
1717

1718
	status = xs_tcp_finish_connecting(xprt, sock);
1719
	dprintk("RPC:       %p connect status %d connected %d sock state %d\n",
1720
			xprt, -status, xprt_connected(xprt), sock->sk->sk_state);
1721 1722 1723 1724 1725
	if (status < 0) {
		switch (status) {
			case -EINPROGRESS:
			case -EALREADY:
				goto out_clear;
1726 1727 1728 1729 1730 1731
			case -ECONNREFUSED:
			case -ECONNRESET:
				/* retry with existing socket, after a delay */
				break;
			default:
				/* get rid of existing socket, and retry */
1732
				xs_tcp_shutdown(xprt);
1733 1734 1735
		}
	}
out:
1736
	xprt_wake_pending_tasks(xprt, status);
1737
out_clear:
1738
	xprt_clear_connecting(xprt);
1739 1740
}

1741 1742 1743 1744 1745
/**
 * xs_connect - connect a socket to a remote endpoint
 * @task: address of RPC task that manages state of connect request
 *
 * TCP: If the remote end dropped the connection, delay reconnecting.
1746 1747 1748 1749 1750 1751 1752
 *
 * UDP socket connects are synchronous, but we use a work queue anyway
 * to guarantee that even unprivileged user processes can set up a
 * socket on a privileged port.
 *
 * If a UDP socket connect fails, the delay behavior here prevents
 * retry floods (hard mounts).
1753 1754
 */
static void xs_connect(struct rpc_task *task)
1755 1756
{
	struct rpc_xprt *xprt = task->tk_xprt;
1757
	struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
1758

1759 1760 1761
	if (xprt_test_and_set_connecting(xprt))
		return;

1762
	if (transport->sock != NULL) {
1763 1764
		dprintk("RPC:       xs_connect delayed xprt %p for %lu "
				"seconds\n",
1765
				xprt, xprt->reestablish_timeout / HZ);
1766 1767 1768
		queue_delayed_work(rpciod_workqueue,
				   &transport->connect_worker,
				   xprt->reestablish_timeout);
1769 1770 1771
		xprt->reestablish_timeout <<= 1;
		if (xprt->reestablish_timeout > XS_TCP_MAX_REEST_TO)
			xprt->reestablish_timeout = XS_TCP_MAX_REEST_TO;
1772
	} else {
1773
		dprintk("RPC:       xs_connect scheduled xprt %p\n", xprt);
1774 1775
		queue_delayed_work(rpciod_workqueue,
				   &transport->connect_worker, 0);
1776 1777 1778
	}
}

1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791
static void xs_tcp_connect(struct rpc_task *task)
{
	struct rpc_xprt *xprt = task->tk_xprt;

	/* Initiate graceful shutdown of the socket if not already done */
	if (test_bit(XPRT_CONNECTED, &xprt->state))
		xs_tcp_shutdown(xprt);
	/* Exit if we need to wait for socket shutdown to complete */
	if (test_bit(XPRT_CLOSING, &xprt->state))
		return;
	xs_connect(task);
}

1792 1793 1794 1795 1796 1797 1798 1799
/**
 * xs_udp_print_stats - display UDP socket-specifc stats
 * @xprt: rpc_xprt struct containing statistics
 * @seq: output file
 *
 */
static void xs_udp_print_stats(struct rpc_xprt *xprt, struct seq_file *seq)
{
1800 1801
	struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);

1802
	seq_printf(seq, "\txprt:\tudp %u %lu %lu %lu %lu %Lu %Lu\n",
1803
			transport->port,
1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819
			xprt->stat.bind_count,
			xprt->stat.sends,
			xprt->stat.recvs,
			xprt->stat.bad_xids,
			xprt->stat.req_u,
			xprt->stat.bklog_u);
}

/**
 * xs_tcp_print_stats - display TCP socket-specifc stats
 * @xprt: rpc_xprt struct containing statistics
 * @seq: output file
 *
 */
static void xs_tcp_print_stats(struct rpc_xprt *xprt, struct seq_file *seq)
{
1820
	struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
1821 1822 1823 1824 1825 1826
	long idle_time = 0;

	if (xprt_connected(xprt))
		idle_time = (long)(jiffies - xprt->last_used) / HZ;

	seq_printf(seq, "\txprt:\ttcp %u %lu %lu %lu %ld %lu %lu %lu %Lu %Lu\n",
1827
			transport->port,
1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838
			xprt->stat.bind_count,
			xprt->stat.connect_count,
			xprt->stat.connect_time,
			idle_time,
			xprt->stat.sends,
			xprt->stat.recvs,
			xprt->stat.bad_xids,
			xprt->stat.req_u,
			xprt->stat.bklog_u);
}

1839
static struct rpc_xprt_ops xs_udp_ops = {
1840
	.set_buffer_size	= xs_udp_set_buffer_size,
1841
	.reserve_xprt		= xprt_reserve_xprt_cong,
1842
	.release_xprt		= xprt_release_xprt_cong,
1843
	.rpcbind		= rpcb_getport_async,
1844
	.set_port		= xs_set_port,
1845
	.connect		= xs_connect,
1846 1847
	.buf_alloc		= rpc_malloc,
	.buf_free		= rpc_free,
1848
	.send_request		= xs_udp_send_request,
1849
	.set_retrans_timeout	= xprt_set_retrans_timeout_rtt,
1850
	.timer			= xs_udp_timer,
1851
	.release_request	= xprt_release_rqst_cong,
1852 1853
	.close			= xs_close,
	.destroy		= xs_destroy,
1854
	.print_stats		= xs_udp_print_stats,
1855 1856 1857
};

static struct rpc_xprt_ops xs_tcp_ops = {
1858
	.reserve_xprt		= xprt_reserve_xprt,
1859
	.release_xprt		= xs_tcp_release_xprt,
1860
	.rpcbind		= rpcb_getport_async,
1861
	.set_port		= xs_set_port,
1862
	.connect		= xs_tcp_connect,
1863 1864
	.buf_alloc		= rpc_malloc,
	.buf_free		= rpc_free,
1865
	.send_request		= xs_tcp_send_request,
1866
	.set_retrans_timeout	= xprt_set_retrans_timeout_def,
1867
	.close			= xs_tcp_shutdown,
1868
	.destroy		= xs_destroy,
1869
	.print_stats		= xs_tcp_print_stats,
1870 1871
};

1872
static struct rpc_xprt *xs_setup_xprt(struct xprt_create *args,
1873
				      unsigned int slot_table_size)
1874 1875
{
	struct rpc_xprt *xprt;
1876
	struct sock_xprt *new;
1877

1878
	if (args->addrlen > sizeof(xprt->addr)) {
1879
		dprintk("RPC:       xs_setup_xprt: address too large\n");
1880 1881 1882
		return ERR_PTR(-EBADF);
	}

1883 1884
	new = kzalloc(sizeof(*new), GFP_KERNEL);
	if (new == NULL) {
1885 1886
		dprintk("RPC:       xs_setup_xprt: couldn't allocate "
				"rpc_xprt\n");
1887 1888
		return ERR_PTR(-ENOMEM);
	}
1889
	xprt = &new->xprt;
1890 1891 1892 1893 1894

	xprt->max_reqs = slot_table_size;
	xprt->slot = kcalloc(xprt->max_reqs, sizeof(struct rpc_rqst), GFP_KERNEL);
	if (xprt->slot == NULL) {
		kfree(xprt);
1895 1896
		dprintk("RPC:       xs_setup_xprt: couldn't allocate slot "
				"table\n");
1897 1898 1899
		return ERR_PTR(-ENOMEM);
	}

1900 1901
	memcpy(&xprt->addr, args->dstaddr, args->addrlen);
	xprt->addrlen = args->addrlen;
1902 1903
	if (args->srcaddr)
		memcpy(&new->addr, args->srcaddr, args->addrlen);
1904 1905 1906 1907

	return xprt;
}

1908 1909 1910 1911 1912 1913 1914
static const struct rpc_timeout xs_udp_default_timeout = {
	.to_initval = 5 * HZ,
	.to_maxval = 30 * HZ,
	.to_increment = 5 * HZ,
	.to_retries = 5,
};

1915 1916
/**
 * xs_setup_udp - Set up transport to use a UDP socket
1917
 * @args: rpc transport creation arguments
1918 1919
 *
 */
1920
static struct rpc_xprt *xs_setup_udp(struct xprt_create *args)
1921
{
1922
	struct sockaddr *addr = args->dstaddr;
1923
	struct rpc_xprt *xprt;
1924
	struct sock_xprt *transport;
1925

1926
	xprt = xs_setup_xprt(args, xprt_udp_slot_table_entries);
1927 1928
	if (IS_ERR(xprt))
		return xprt;
1929
	transport = container_of(xprt, struct sock_xprt, xprt);
1930

1931
	xprt->prot = IPPROTO_UDP;
1932
	xprt->tsh_size = 0;
1933 1934 1935
	/* XXX: header size can vary due to auth type, IPv6, etc. */
	xprt->max_payload = (1U << 16) - (MAX_HEADER << 3);

1936 1937 1938 1939
	xprt->bind_timeout = XS_BIND_TO;
	xprt->connect_timeout = XS_UDP_CONN_TO;
	xprt->reestablish_timeout = XS_UDP_REEST_TO;
	xprt->idle_timeout = XS_IDLE_DISC_TO;
1940

1941
	xprt->ops = &xs_udp_ops;
1942

1943
	xprt->timeout = &xs_udp_default_timeout;
1944

1945 1946 1947 1948 1949 1950 1951
	switch (addr->sa_family) {
	case AF_INET:
		if (((struct sockaddr_in *)addr)->sin_port != htons(0))
			xprt_set_bound(xprt);

		INIT_DELAYED_WORK(&transport->connect_worker,
					xs_udp_connect_worker4);
1952
		xs_format_ipv4_peer_addresses(xprt, "udp", RPCBIND_NETID_UDP);
1953 1954 1955 1956 1957 1958 1959
		break;
	case AF_INET6:
		if (((struct sockaddr_in6 *)addr)->sin6_port != htons(0))
			xprt_set_bound(xprt);

		INIT_DELAYED_WORK(&transport->connect_worker,
					xs_udp_connect_worker6);
1960
		xs_format_ipv6_peer_addresses(xprt, "udp", RPCBIND_NETID_UDP6);
1961 1962 1963 1964 1965 1966
		break;
	default:
		kfree(xprt);
		return ERR_PTR(-EAFNOSUPPORT);
	}

1967
	dprintk("RPC:       set up transport to address %s\n",
1968
			xprt->address_strings[RPC_DISPLAY_ALL]);
1969

1970 1971 1972 1973 1974 1975
	if (try_module_get(THIS_MODULE))
		return xprt;

	kfree(xprt->slot);
	kfree(xprt);
	return ERR_PTR(-EINVAL);
1976 1977
}

1978 1979 1980 1981 1982 1983
static const struct rpc_timeout xs_tcp_default_timeout = {
	.to_initval = 60 * HZ,
	.to_maxval = 60 * HZ,
	.to_retries = 2,
};

1984 1985
/**
 * xs_setup_tcp - Set up transport to use a TCP socket
1986
 * @args: rpc transport creation arguments
1987 1988
 *
 */
1989
static struct rpc_xprt *xs_setup_tcp(struct xprt_create *args)
1990
{
1991
	struct sockaddr *addr = args->dstaddr;
1992
	struct rpc_xprt *xprt;
1993
	struct sock_xprt *transport;
1994

1995
	xprt = xs_setup_xprt(args, xprt_tcp_slot_table_entries);
1996 1997
	if (IS_ERR(xprt))
		return xprt;
1998
	transport = container_of(xprt, struct sock_xprt, xprt);
1999

2000
	xprt->prot = IPPROTO_TCP;
2001 2002
	xprt->tsh_size = sizeof(rpc_fraghdr) / sizeof(u32);
	xprt->max_payload = RPC_MAX_FRAGMENT_SIZE;
2003

2004 2005 2006 2007
	xprt->bind_timeout = XS_BIND_TO;
	xprt->connect_timeout = XS_TCP_CONN_TO;
	xprt->reestablish_timeout = XS_TCP_INIT_REEST_TO;
	xprt->idle_timeout = XS_IDLE_DISC_TO;
2008

2009
	xprt->ops = &xs_tcp_ops;
2010
	xprt->timeout = &xs_tcp_default_timeout;
2011

2012 2013 2014 2015 2016 2017
	switch (addr->sa_family) {
	case AF_INET:
		if (((struct sockaddr_in *)addr)->sin_port != htons(0))
			xprt_set_bound(xprt);

		INIT_DELAYED_WORK(&transport->connect_worker, xs_tcp_connect_worker4);
2018
		xs_format_ipv4_peer_addresses(xprt, "tcp", RPCBIND_NETID_TCP);
2019 2020 2021 2022 2023 2024
		break;
	case AF_INET6:
		if (((struct sockaddr_in6 *)addr)->sin6_port != htons(0))
			xprt_set_bound(xprt);

		INIT_DELAYED_WORK(&transport->connect_worker, xs_tcp_connect_worker6);
2025
		xs_format_ipv6_peer_addresses(xprt, "tcp", RPCBIND_NETID_TCP6);
2026 2027 2028 2029 2030 2031
		break;
	default:
		kfree(xprt);
		return ERR_PTR(-EAFNOSUPPORT);
	}

2032
	dprintk("RPC:       set up transport to address %s\n",
2033
			xprt->address_strings[RPC_DISPLAY_ALL]);
2034

2035 2036 2037 2038 2039 2040
	if (try_module_get(THIS_MODULE))
		return xprt;

	kfree(xprt->slot);
	kfree(xprt);
	return ERR_PTR(-EINVAL);
2041
}
2042

2043 2044 2045 2046
static struct xprt_class	xs_udp_transport = {
	.list		= LIST_HEAD_INIT(xs_udp_transport.list),
	.name		= "udp",
	.owner		= THIS_MODULE,
2047
	.ident		= IPPROTO_UDP,
2048 2049 2050 2051 2052 2053 2054
	.setup		= xs_setup_udp,
};

static struct xprt_class	xs_tcp_transport = {
	.list		= LIST_HEAD_INIT(xs_tcp_transport.list),
	.name		= "tcp",
	.owner		= THIS_MODULE,
2055
	.ident		= IPPROTO_TCP,
2056 2057 2058
	.setup		= xs_setup_tcp,
};

2059
/**
2060
 * init_socket_xprt - set up xprtsock's sysctls, register with RPC client
2061 2062 2063 2064
 *
 */
int init_socket_xprt(void)
{
2065
#ifdef RPC_DEBUG
2066
	if (!sunrpc_table_header)
2067
		sunrpc_table_header = register_sysctl_table(sunrpc_table);
2068 2069
#endif

2070 2071 2072
	xprt_register_transport(&xs_udp_transport);
	xprt_register_transport(&xs_tcp_transport);

2073 2074 2075 2076
	return 0;
}

/**
2077
 * cleanup_socket_xprt - remove xprtsock's sysctls, unregister
2078 2079 2080 2081
 *
 */
void cleanup_socket_xprt(void)
{
2082 2083 2084 2085 2086 2087
#ifdef RPC_DEBUG
	if (sunrpc_table_header) {
		unregister_sysctl_table(sunrpc_table_header);
		sunrpc_table_header = NULL;
	}
#endif
2088 2089 2090

	xprt_unregister_transport(&xs_udp_transport);
	xprt_unregister_transport(&xs_tcp_transport);
2091
}