xprtsock.c 68.2 KB
Newer Older
1 2 3 4 5
/*
 * linux/net/sunrpc/xprtsock.c
 *
 * Client-side transport implementation for sockets.
 *
6 7
 * TCP callback races fixes (C) 1998 Red Hat
 * TCP send fixes (C) 1998 Red Hat
8 9 10 11 12 13
 * 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/svcsock.h>
36
#include <linux/sunrpc/xprtsock.h>
37
#include <linux/file.h>
R
Ricardo Labiaga 已提交
38 39 40
#ifdef CONFIG_NFS_V4_1
#include <linux/sunrpc/bc_xprt.h>
#endif
41 42 43 44 45 46

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

47
#include "sunrpc.h"
48 49 50 51 52 53 54 55 56
/*
 * 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;

57
#define XS_TCP_LINGER_TO	(15U * HZ)
58
static unsigned int xs_tcp_fin_timeout __read_mostly = XS_TCP_LINGER_TO;
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
/*
 * 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[] = {
	{
		.procname	= "udp_slot_table_entries",
		.data		= &xprt_udp_slot_table_entries,
		.maxlen		= sizeof(unsigned int),
		.mode		= 0644,
88
		.proc_handler	= proc_dointvec_minmax,
89 90 91 92 93 94 95 96
		.extra1		= &min_slot_table_size,
		.extra2		= &max_slot_table_size
	},
	{
		.procname	= "tcp_slot_table_entries",
		.data		= &xprt_tcp_slot_table_entries,
		.maxlen		= sizeof(unsigned int),
		.mode		= 0644,
97
		.proc_handler	= proc_dointvec_minmax,
98 99 100 101 102 103 104 105
		.extra1		= &min_slot_table_size,
		.extra2		= &max_slot_table_size
	},
	{
		.procname	= "min_resvport",
		.data		= &xprt_min_resvport,
		.maxlen		= sizeof(unsigned int),
		.mode		= 0644,
106
		.proc_handler	= proc_dointvec_minmax,
107 108 109 110 111 112 113 114
		.extra1		= &xprt_min_resvport_limit,
		.extra2		= &xprt_max_resvport_limit
	},
	{
		.procname	= "max_resvport",
		.data		= &xprt_max_resvport,
		.maxlen		= sizeof(unsigned int),
		.mode		= 0644,
115
		.proc_handler	= proc_dointvec_minmax,
116 117 118
		.extra1		= &xprt_min_resvport_limit,
		.extra2		= &xprt_max_resvport_limit
	},
119 120 121 122 123
	{
		.procname	= "tcp_fin_timeout",
		.data		= &xs_tcp_fin_timeout,
		.maxlen		= sizeof(xs_tcp_fin_timeout),
		.mode		= 0644,
124
		.proc_handler	= proc_dointvec_jiffies,
125
	},
126
	{ },
127 128 129 130 131 132 133 134
};

static ctl_table sunrpc_table[] = {
	{
		.procname	= "sunrpc",
		.mode		= 0555,
		.child		= xs_tunables_table
	},
135
	{ },
136 137 138 139
};

#endif

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 182 183
/*
 * 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)

184 185
#ifdef RPC_DEBUG
# undef  RPC_DEBUG_DATA
186
# define RPCDBG_FACILITY	RPCDBG_TRANS
187 188 189
#endif

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

195
	dprintk("RPC:       %s\n", msg);
196 197 198 199 200 201 202 203 204 205 206 207
	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
208
static inline void xs_pktdump(char *msg, u32 *packet, unsigned int count)
209 210 211 212 213
{
	/* NOP */
}
#endif

214 215
struct sock_xprt {
	struct rpc_xprt		xprt;
216 217 218 219 220 221

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

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

	u32			tcp_offset,
				tcp_reclen;

	unsigned long		tcp_copied,
				tcp_flags;
234 235 236 237

	/*
	 * Connection of transports
	 */
238
	struct delayed_work	connect_worker;
239 240
	struct sockaddr_storage	srcaddr;
	unsigned short		srcport;
241 242 243 244 245 246

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

	/*
	 * Saved socket callback addresses
	 */
	void			(*old_data_ready)(struct sock *, int);
	void			(*old_state_change)(struct sock *);
	void			(*old_write_space)(struct sock *);
254
	void			(*old_error_report)(struct sock *);
255 256
};

257 258 259 260 261 262 263
/*
 * 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)
264 265
#define TCP_RCV_READ_CALLDIR	(1UL << 4)
#define TCP_RCV_COPY_CALLDIR	(1UL << 5)
266 267 268 269

/*
 * TCP RPC flags
 */
270
#define TCP_RPC_REPLY		(1UL << 6)
271

272 273 274 275 276 277
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)
278
{
279 280 281 282 283 284 285 286
	return (struct sockaddr_in *) &xprt->addr;
}

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

287
static void xs_format_common_peer_addresses(struct rpc_xprt *xprt)
288
{
289
	struct sockaddr *sap = xs_addr(xprt);
290 291
	struct sockaddr_in6 *sin6;
	struct sockaddr_in *sin;
292
	char buf[128];
293

294 295
	(void)rpc_ntop(sap, buf, sizeof(buf));
	xprt->address_strings[RPC_DISPLAY_ADDR] = kstrdup(buf, GFP_KERNEL);
296

297 298 299
	switch (sap->sa_family) {
	case AF_INET:
		sin = xs_addr_in(xprt);
300
		snprintf(buf, sizeof(buf), "%08x", ntohl(sin->sin_addr.s_addr));
301 302 303
		break;
	case AF_INET6:
		sin6 = xs_addr_in6(xprt);
304
		snprintf(buf, sizeof(buf), "%pi6", &sin6->sin6_addr);
305 306 307
		break;
	default:
		BUG();
308
	}
309
	xprt->address_strings[RPC_DISPLAY_HEX_ADDR] = kstrdup(buf, GFP_KERNEL);
310 311
}

312
static void xs_format_common_peer_ports(struct rpc_xprt *xprt)
313
{
314 315
	struct sockaddr *sap = xs_addr(xprt);
	char buf[128];
316

317
	snprintf(buf, sizeof(buf), "%u", rpc_get_port(sap));
318
	xprt->address_strings[RPC_DISPLAY_PORT] = kstrdup(buf, GFP_KERNEL);
319

320
	snprintf(buf, sizeof(buf), "%4hx", rpc_get_port(sap));
321 322
	xprt->address_strings[RPC_DISPLAY_HEX_PORT] = kstrdup(buf, GFP_KERNEL);
}
323

324 325 326
static void xs_format_peer_addresses(struct rpc_xprt *xprt,
				     const char *protocol,
				     const char *netid)
327
{
328 329
	xprt->address_strings[RPC_DISPLAY_PROTO] = protocol;
	xprt->address_strings[RPC_DISPLAY_NETID] = netid;
330
	xs_format_common_peer_addresses(xprt);
331
	xs_format_common_peer_ports(xprt);
332
}
333

334
static void xs_update_peer_port(struct rpc_xprt *xprt)
335
{
336 337
	kfree(xprt->address_strings[RPC_DISPLAY_HEX_PORT]);
	kfree(xprt->address_strings[RPC_DISPLAY_PORT]);
338

339
	xs_format_common_peer_ports(xprt);
340 341 342 343
}

static void xs_free_peer_addresses(struct rpc_xprt *xprt)
{
344 345 346 347 348 349 350 351 352 353
	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]);
		}
354 355
}

356 357
#define XS_SENDMSG_FLAGS	(MSG_DONTWAIT | MSG_NOSIGNAL)

T
Trond Myklebust 已提交
358
static int xs_send_kvec(struct socket *sock, struct sockaddr *addr, int addrlen, struct kvec *vec, unsigned int base, int more)
359 360 361 362
{
	struct msghdr msg = {
		.msg_name	= addr,
		.msg_namelen	= addrlen,
T
Trond Myklebust 已提交
363 364 365 366 367
		.msg_flags	= XS_SENDMSG_FLAGS | (more ? MSG_MORE : 0),
	};
	struct kvec iov = {
		.iov_base	= vec->iov_base + base,
		.iov_len	= vec->iov_len - base,
368 369
	};

T
Trond Myklebust 已提交
370
	if (iov.iov_len != 0)
371 372 373 374
		return kernel_sendmsg(sock, &msg, &iov, 1, iov.iov_len);
	return kernel_sendmsg(sock, &msg, NULL, 0, 0);
}

T
Trond Myklebust 已提交
375
static int xs_send_pagedata(struct socket *sock, struct xdr_buf *xdr, unsigned int base, int more)
376
{
T
Trond Myklebust 已提交
377 378 379 380 381 382 383 384 385 386 387
	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;
388

T
Trond Myklebust 已提交
389 390 391 392 393 394 395 396 397 398 399 400 401 402 403
		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;
404 405
}

406 407 408 409 410 411 412 413
/**
 * 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
 *
414
 */
T
Trond Myklebust 已提交
415
static int xs_sendpages(struct socket *sock, struct sockaddr *addr, int addrlen, struct xdr_buf *xdr, unsigned int base)
416
{
T
Trond Myklebust 已提交
417 418
	unsigned int remainder = xdr->len - base;
	int err, sent = 0;
419

420
	if (unlikely(!sock))
421
		return -ENOTSOCK;
422 423

	clear_bit(SOCK_ASYNC_NOSPACE, &sock->flags);
T
Trond Myklebust 已提交
424 425 426 427
	if (base != 0) {
		addr = NULL;
		addrlen = 0;
	}
428

T
Trond Myklebust 已提交
429 430 431 432 433
	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)
434
			goto out;
T
Trond Myklebust 已提交
435
		sent += err;
436 437
		base = 0;
	} else
T
Trond Myklebust 已提交
438
		base -= xdr->head[0].iov_len;
439

T
Trond Myklebust 已提交
440 441 442 443 444
	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)
445
			goto out;
T
Trond Myklebust 已提交
446
		sent += err;
447
		base = 0;
T
Trond Myklebust 已提交
448 449 450 451 452 453
	} 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);
454
out:
T
Trond Myklebust 已提交
455 456 457 458 459
	if (sent == 0)
		return err;
	if (err > 0)
		sent += err;
	return sent;
460 461
}

462 463 464 465 466 467 468 469
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);
}

470
/**
471 472
 * xs_nospace - place task on wait queue if transmit was incomplete
 * @task: task to put to sleep
473
 *
474
 */
475
static int xs_nospace(struct rpc_task *task)
476
{
477 478
	struct rpc_rqst *req = task->tk_rqstp;
	struct rpc_xprt *xprt = req->rq_xprt;
479
	struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
480
	int ret = 0;
481

482
	dprintk("RPC: %5u xmit incomplete (%u left of %u)\n",
483 484 485
			task->tk_pid, req->rq_slen - req->rq_bytes_sent,
			req->rq_slen);

486 487 488 489 490 491
	/* 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)) {
492
			ret = -EAGAIN;
493 494 495 496 497 498 499 500 501 502 503
			/*
			 * 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);
504
		ret = -ENOTCONN;
505
	}
506

507
	spin_unlock_bh(&xprt->transport_lock);
508
	return ret;
509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525
}

/**
 * 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;
526
	struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
527 528
	struct xdr_buf *xdr = &req->rq_snd_buf;
	int status;
529

530
	xs_pktdump("packet data:",
531 532 533
				req->rq_svec->iov_base,
				req->rq_svec->iov_len);

534 535
	if (!xprt_bound(xprt))
		return -ENOTCONN;
536
	status = xs_sendpages(transport->sock,
537
			      xs_addr(xprt),
538 539
			      xprt->addrlen, xdr,
			      req->rq_bytes_sent);
540

541
	dprintk("RPC:       xs_udp_send_request(%u) = %d\n",
542
			xdr->len - req->rq_bytes_sent, status);
543

544 545 546 547 548
	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. */
549
		status = -EAGAIN;
550
	}
551

552
	switch (status) {
553 554 555 556
	case -ENOTSOCK:
		status = -ENOTCONN;
		/* Should we call xs_close() here? */
		break;
557
	case -EAGAIN:
558
		status = xs_nospace(task);
559
		break;
560 561 562
	default:
		dprintk("RPC:       sendmsg returned unrecognized error %d\n",
			-status);
563 564
	case -ENETUNREACH:
	case -EPIPE:
565 566
	case -ECONNREFUSED:
		/* When the server has died, an ICMP port unreachable message
567
		 * prompts ECONNREFUSED. */
568
		clear_bit(SOCK_ASYNC_NOSPACE, &transport->sock->flags);
569
	}
570

571
	return status;
572 573
}

574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589
/**
 * 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);
}

590 591 592 593 594 595 596
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);
}

597
/**
598
 * xs_tcp_send_request - write an RPC request to a TCP socket
599 600 601
 * @task: address of RPC task that manages the state of an RPC request
 *
 * Return values:
602 603 604 605 606
 *        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
607 608
 *
 * XXX: In the case of soft timeouts, should we eventually give up
609
 *	if sendmsg is not able to make progress?
610
 */
611
static int xs_tcp_send_request(struct rpc_task *task)
612 613 614
{
	struct rpc_rqst *req = task->tk_rqstp;
	struct rpc_xprt *xprt = req->rq_xprt;
615
	struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
616
	struct xdr_buf *xdr = &req->rq_snd_buf;
617
	int status;
618

619
	xs_encode_tcp_record_marker(&req->rq_snd_buf);
620

621 622 623
	xs_pktdump("packet data:",
				req->rq_svec->iov_base,
				req->rq_svec->iov_len);
624 625 626

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

632
		dprintk("RPC:       xs_tcp_send_request(%u) = %d\n",
633
				xdr->len - req->rq_bytes_sent, status);
634

635
		if (unlikely(status < 0))
636 637
			break;

638 639 640
		/* If we've sent the entire packet, immediately
		 * reset the count of bytes sent. */
		req->rq_bytes_sent += status;
641
		task->tk_bytes_sent += status;
642 643 644 645
		if (likely(req->rq_bytes_sent >= req->rq_slen)) {
			req->rq_bytes_sent = 0;
			return 0;
		}
646

647 648
		if (status != 0)
			continue;
649
		status = -EAGAIN;
650
		break;
651 652
	}

653
	switch (status) {
654 655 656 657
	case -ENOTSOCK:
		status = -ENOTCONN;
		/* Should we call xs_close() here? */
		break;
658
	case -EAGAIN:
659
		status = xs_nospace(task);
660
		break;
661 662 663
	default:
		dprintk("RPC:       sendmsg returned unrecognized error %d\n",
			-status);
664
	case -ECONNRESET:
665
	case -EPIPE:
666 667
		xs_tcp_shutdown(xprt);
	case -ECONNREFUSED:
668
	case -ENOTCONN:
669
		clear_bit(SOCK_ASYNC_NOSPACE, &transport->sock->flags);
670
	}
671

672 673 674
	return status;
}

675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701
/**
 * 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);
}

702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717
static void xs_save_old_callbacks(struct sock_xprt *transport, struct sock *sk)
{
	transport->old_data_ready = sk->sk_data_ready;
	transport->old_state_change = sk->sk_state_change;
	transport->old_write_space = sk->sk_write_space;
	transport->old_error_report = sk->sk_error_report;
}

static void xs_restore_old_callbacks(struct sock_xprt *transport, struct sock *sk)
{
	sk->sk_data_ready = transport->old_data_ready;
	sk->sk_state_change = transport->old_state_change;
	sk->sk_write_space = transport->old_write_space;
	sk->sk_error_report = transport->old_error_report;
}

718
static void xs_reset_transport(struct sock_xprt *transport)
719
{
720 721
	struct socket *sock = transport->sock;
	struct sock *sk = transport->inet;
722

723 724
	if (sk == NULL)
		return;
725

726
	write_lock_bh(&sk->sk_callback_lock);
727 728
	transport->inet = NULL;
	transport->sock = NULL;
729

730
	sk->sk_user_data = NULL;
731 732

	xs_restore_old_callbacks(transport, sk);
733 734
	write_unlock_bh(&sk->sk_callback_lock);

735
	sk->sk_no_check = 0;
736 737

	sock_release(sock);
738 739 740 741 742 743 744 745
}

/**
 * xs_close - close a socket
 * @xprt: transport
 *
 * This is used when all requests are complete; ie, no DRC state remains
 * on the server we want to save.
746 747 748
 *
 * The caller _must_ be holding XPRT_LOCKED in order to avoid issues with
 * xs_reset_transport() zeroing the socket from underneath a writer.
749 750 751 752 753 754 755 756
 */
static void xs_close(struct rpc_xprt *xprt)
{
	struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);

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

	xs_reset_transport(transport);
757
	xprt->reestablish_timeout = 0;
758

759
	smp_mb__before_clear_bit();
760
	clear_bit(XPRT_CONNECTION_ABORT, &xprt->state);
761
	clear_bit(XPRT_CLOSE_WAIT, &xprt->state);
762
	clear_bit(XPRT_CLOSING, &xprt->state);
763
	smp_mb__after_clear_bit();
764
	xprt_disconnect_done(xprt);
765 766
}

767 768 769 770 771 772 773 774
static void xs_tcp_close(struct rpc_xprt *xprt)
{
	if (test_and_clear_bit(XPRT_CONNECTION_CLOSE, &xprt->state))
		xs_close(xprt);
	else
		xs_tcp_shutdown(xprt);
}

775 776 777 778 779 780
/**
 * xs_destroy - prepare to shutdown a transport
 * @xprt: doomed transport
 *
 */
static void xs_destroy(struct rpc_xprt *xprt)
781
{
782 783
	struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);

784
	dprintk("RPC:       xs_destroy xprt %p\n", xprt);
785

786
	cancel_rearming_delayed_work(&transport->connect_worker);
787

788
	xs_close(xprt);
789
	xs_free_peer_addresses(xprt);
790
	kfree(xprt->slot);
791
	kfree(xprt);
792
	module_put(THIS_MODULE);
793 794
}

795 796 797 798 799 800 801 802 803 804
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
 *
805
 */
806
static void xs_udp_data_ready(struct sock *sk, int len)
807
{
808 809
	struct rpc_task *task;
	struct rpc_xprt *xprt;
810
	struct rpc_rqst *rovr;
811
	struct sk_buff *skb;
812
	int err, repsize, copied;
813 814
	u32 _xid;
	__be32 *xp;
815 816

	read_lock(&sk->sk_callback_lock);
817
	dprintk("RPC:       xs_udp_data_ready...\n");
818
	if (!(xprt = xprt_from_sock(sk)))
819 820 821 822 823 824 825 826 827 828
		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) {
829
		dprintk("RPC:       impossible RPC reply size %d!\n", repsize);
830 831 832 833 834 835 836 837 838 839
		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 已提交
840
	spin_lock(&xprt->transport_lock);
841 842 843 844 845 846 847 848 849
	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. */
850 851
	if (csum_partial_copy_to_xdr(&rovr->rq_private_buf, skb)) {
		UDPX_INC_STATS_BH(sk, UDP_MIB_INERRORS);
852
		goto out_unlock;
853 854 855
	}

	UDPX_INC_STATS_BH(sk, UDP_MIB_INDATAGRAMS);
856 857

	/* Something worked... */
E
Eric Dumazet 已提交
858
	dst_confirm(skb_dst(skb));
859

860 861 862
	xprt_adjust_cwnd(task, copied);
	xprt_update_rtt(task);
	xprt_complete_rqst(task, copied);
863 864

 out_unlock:
C
Chuck Lever 已提交
865
	spin_unlock(&xprt->transport_lock);
866 867 868 869 870 871
 dropit:
	skb_free_datagram(sk, skb);
 out:
	read_unlock(&sk->sk_callback_lock);
}

872
static inline void xs_tcp_read_fraghdr(struct rpc_xprt *xprt, struct xdr_skb_reader *desc)
873
{
874
	struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
875 876 877
	size_t len, used;
	char *p;

878 879
	p = ((char *) &transport->tcp_fraghdr) + transport->tcp_offset;
	len = sizeof(transport->tcp_fraghdr) - transport->tcp_offset;
880
	used = xdr_skb_read_bits(desc, p, len);
881
	transport->tcp_offset += used;
882 883
	if (used != len)
		return;
884

885 886
	transport->tcp_reclen = ntohl(transport->tcp_fraghdr);
	if (transport->tcp_reclen & RPC_LAST_STREAM_FRAGMENT)
887
		transport->tcp_flags |= TCP_RCV_LAST_FRAG;
888
	else
889
		transport->tcp_flags &= ~TCP_RCV_LAST_FRAG;
890
	transport->tcp_reclen &= RPC_FRAGMENT_SIZE_MASK;
891

892
	transport->tcp_flags &= ~TCP_RCV_COPY_FRAGHDR;
893
	transport->tcp_offset = 0;
894

895
	/* Sanity check of the record length */
896
	if (unlikely(transport->tcp_reclen < 8)) {
897
		dprintk("RPC:       invalid TCP record fragment length\n");
898
		xprt_force_disconnect(xprt);
899
		return;
900
	}
901
	dprintk("RPC:       reading TCP record fragment of length %d\n",
902
			transport->tcp_reclen);
903 904
}

905
static void xs_tcp_check_fraghdr(struct sock_xprt *transport)
906
{
907
	if (transport->tcp_offset == transport->tcp_reclen) {
908
		transport->tcp_flags |= TCP_RCV_COPY_FRAGHDR;
909
		transport->tcp_offset = 0;
910 911 912
		if (transport->tcp_flags & TCP_RCV_LAST_FRAG) {
			transport->tcp_flags &= ~TCP_RCV_COPY_DATA;
			transport->tcp_flags |= TCP_RCV_COPY_XID;
913
			transport->tcp_copied = 0;
914 915 916 917
		}
	}
}

918
static inline void xs_tcp_read_xid(struct sock_xprt *transport, struct xdr_skb_reader *desc)
919 920 921 922
{
	size_t len, used;
	char *p;

923
	len = sizeof(transport->tcp_xid) - transport->tcp_offset;
924
	dprintk("RPC:       reading XID (%Zu bytes)\n", len);
925
	p = ((char *) &transport->tcp_xid) + transport->tcp_offset;
926
	used = xdr_skb_read_bits(desc, p, len);
927
	transport->tcp_offset += used;
928 929
	if (used != len)
		return;
930
	transport->tcp_flags &= ~TCP_RCV_COPY_XID;
931
	transport->tcp_flags |= TCP_RCV_READ_CALLDIR;
932
	transport->tcp_copied = 4;
933 934 935
	dprintk("RPC:       reading %s XID %08x\n",
			(transport->tcp_flags & TCP_RPC_REPLY) ? "reply for"
							      : "request with",
936 937
			ntohl(transport->tcp_xid));
	xs_tcp_check_fraghdr(transport);
938 939
}

940 941
static inline void xs_tcp_read_calldir(struct sock_xprt *transport,
				       struct xdr_skb_reader *desc)
942
{
943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959
	size_t len, used;
	u32 offset;
	__be32	calldir;

	/*
	 * We want transport->tcp_offset to be 8 at the end of this routine
	 * (4 bytes for the xid and 4 bytes for the call/reply flag).
	 * When this function is called for the first time,
	 * transport->tcp_offset is 4 (after having already read the xid).
	 */
	offset = transport->tcp_offset - sizeof(transport->tcp_xid);
	len = sizeof(calldir) - offset;
	dprintk("RPC:       reading CALL/REPLY flag (%Zu bytes)\n", len);
	used = xdr_skb_read_bits(desc, &calldir, len);
	transport->tcp_offset += used;
	if (used != len)
		return;
960 961
	transport->tcp_flags &= ~TCP_RCV_READ_CALLDIR;
	transport->tcp_flags |= TCP_RCV_COPY_CALLDIR;
962
	transport->tcp_flags |= TCP_RCV_COPY_DATA;
963 964 965 966
	/*
	 * We don't yet have the XDR buffer, so we will write the calldir
	 * out after we get the buffer from the 'struct rpc_rqst'
	 */
967 968 969 970 971 972 973 974 975 976
	if (ntohl(calldir) == RPC_REPLY)
		transport->tcp_flags |= TCP_RPC_REPLY;
	else
		transport->tcp_flags &= ~TCP_RPC_REPLY;
	dprintk("RPC:       reading %s CALL/REPLY flag %08x\n",
			(transport->tcp_flags & TCP_RPC_REPLY) ?
				"reply for" : "request with", calldir);
	xs_tcp_check_fraghdr(transport);
}

R
Ricardo Labiaga 已提交
977 978 979
static inline void xs_tcp_read_common(struct rpc_xprt *xprt,
				     struct xdr_skb_reader *desc,
				     struct rpc_rqst *req)
980
{
R
Ricardo Labiaga 已提交
981 982
	struct sock_xprt *transport =
				container_of(xprt, struct sock_xprt, xprt);
983 984 985 986 987
	struct xdr_buf *rcvbuf;
	size_t len;
	ssize_t r;

	rcvbuf = &req->rq_private_buf;
988 989 990 991 992 993 994 995 996 997 998 999

	if (transport->tcp_flags & TCP_RCV_COPY_CALLDIR) {
		/*
		 * Save the RPC direction in the XDR buffer
		 */
		__be32	calldir = transport->tcp_flags & TCP_RPC_REPLY ?
					htonl(RPC_REPLY) : 0;

		memcpy(rcvbuf->head[0].iov_base + transport->tcp_copied,
			&calldir, sizeof(calldir));
		transport->tcp_copied += sizeof(calldir);
		transport->tcp_flags &= ~TCP_RCV_COPY_CALLDIR;
1000 1001 1002
	}

	len = desc->count;
1003
	if (len > transport->tcp_reclen - transport->tcp_offset) {
1004
		struct xdr_skb_reader my_desc;
1005

1006
		len = transport->tcp_reclen - transport->tcp_offset;
1007 1008
		memcpy(&my_desc, desc, sizeof(my_desc));
		my_desc.count = len;
1009
		r = xdr_partial_copy_from_skb(rcvbuf, transport->tcp_copied,
1010
					  &my_desc, xdr_skb_read_bits);
1011 1012 1013
		desc->count -= r;
		desc->offset += r;
	} else
1014
		r = xdr_partial_copy_from_skb(rcvbuf, transport->tcp_copied,
1015
					  desc, xdr_skb_read_bits);
1016 1017

	if (r > 0) {
1018 1019
		transport->tcp_copied += r;
		transport->tcp_offset += r;
1020 1021 1022 1023 1024
	}
	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
1025
		 * is turn off TCP_RCV_COPY_DATA, so the request
1026 1027 1028 1029 1030
		 * will not receive any additional updates,
		 * and time out.
		 * Any remaining data from this record will
		 * be discarded.
		 */
1031
		transport->tcp_flags &= ~TCP_RCV_COPY_DATA;
1032
		dprintk("RPC:       XID %08x truncated request\n",
1033
				ntohl(transport->tcp_xid));
1034 1035 1036 1037
		dprintk("RPC:       xprt = %p, tcp_copied = %lu, "
				"tcp_offset = %u, tcp_reclen = %u\n",
				xprt, transport->tcp_copied,
				transport->tcp_offset, transport->tcp_reclen);
R
Ricardo Labiaga 已提交
1038
		return;
1039 1040
	}

1041
	dprintk("RPC:       XID %08x read %Zd bytes\n",
1042
			ntohl(transport->tcp_xid), r);
1043 1044 1045
	dprintk("RPC:       xprt = %p, tcp_copied = %lu, tcp_offset = %u, "
			"tcp_reclen = %u\n", xprt, transport->tcp_copied,
			transport->tcp_offset, transport->tcp_reclen);
1046 1047

	if (transport->tcp_copied == req->rq_private_buf.buflen)
1048
		transport->tcp_flags &= ~TCP_RCV_COPY_DATA;
1049
	else if (transport->tcp_offset == transport->tcp_reclen) {
1050 1051
		if (transport->tcp_flags & TCP_RCV_LAST_FRAG)
			transport->tcp_flags &= ~TCP_RCV_COPY_DATA;
1052 1053
	}

R
Ricardo Labiaga 已提交
1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081
	return;
}

/*
 * Finds the request corresponding to the RPC xid and invokes the common
 * tcp read code to read the data.
 */
static inline int xs_tcp_read_reply(struct rpc_xprt *xprt,
				    struct xdr_skb_reader *desc)
{
	struct sock_xprt *transport =
				container_of(xprt, struct sock_xprt, xprt);
	struct rpc_rqst *req;

	dprintk("RPC:       read reply XID %08x\n", ntohl(transport->tcp_xid));

	/* Find and lock the request corresponding to this xid */
	spin_lock(&xprt->transport_lock);
	req = xprt_lookup_rqst(xprt, transport->tcp_xid);
	if (!req) {
		dprintk("RPC:       XID %08x request not found!\n",
				ntohl(transport->tcp_xid));
		spin_unlock(&xprt->transport_lock);
		return -1;
	}

	xs_tcp_read_common(xprt, desc, req);

1082
	if (!(transport->tcp_flags & TCP_RCV_COPY_DATA))
1083
		xprt_complete_rqst(req->rq_task, transport->tcp_copied);
R
Ricardo Labiaga 已提交
1084

C
Chuck Lever 已提交
1085
	spin_unlock(&xprt->transport_lock);
R
Ricardo Labiaga 已提交
1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172
	return 0;
}

#if defined(CONFIG_NFS_V4_1)
/*
 * Obtains an rpc_rqst previously allocated and invokes the common
 * tcp read code to read the data.  The result is placed in the callback
 * queue.
 * If we're unable to obtain the rpc_rqst we schedule the closing of the
 * connection and return -1.
 */
static inline int xs_tcp_read_callback(struct rpc_xprt *xprt,
				       struct xdr_skb_reader *desc)
{
	struct sock_xprt *transport =
				container_of(xprt, struct sock_xprt, xprt);
	struct rpc_rqst *req;

	req = xprt_alloc_bc_request(xprt);
	if (req == NULL) {
		printk(KERN_WARNING "Callback slot table overflowed\n");
		xprt_force_disconnect(xprt);
		return -1;
	}

	req->rq_xid = transport->tcp_xid;
	dprintk("RPC:       read callback  XID %08x\n", ntohl(req->rq_xid));
	xs_tcp_read_common(xprt, desc, req);

	if (!(transport->tcp_flags & TCP_RCV_COPY_DATA)) {
		struct svc_serv *bc_serv = xprt->bc_serv;

		/*
		 * Add callback request to callback list.  The callback
		 * service sleeps on the sv_cb_waitq waiting for new
		 * requests.  Wake it up after adding enqueing the
		 * request.
		 */
		dprintk("RPC:       add callback request to list\n");
		spin_lock(&bc_serv->sv_cb_lock);
		list_add(&req->rq_bc_list, &bc_serv->sv_cb_list);
		spin_unlock(&bc_serv->sv_cb_lock);
		wake_up(&bc_serv->sv_cb_waitq);
	}

	req->rq_private_buf.len = transport->tcp_copied;

	return 0;
}

static inline int _xs_tcp_read_data(struct rpc_xprt *xprt,
					struct xdr_skb_reader *desc)
{
	struct sock_xprt *transport =
				container_of(xprt, struct sock_xprt, xprt);

	return (transport->tcp_flags & TCP_RPC_REPLY) ?
		xs_tcp_read_reply(xprt, desc) :
		xs_tcp_read_callback(xprt, desc);
}
#else
static inline int _xs_tcp_read_data(struct rpc_xprt *xprt,
					struct xdr_skb_reader *desc)
{
	return xs_tcp_read_reply(xprt, desc);
}
#endif /* CONFIG_NFS_V4_1 */

/*
 * Read data off the transport.  This can be either an RPC_CALL or an
 * RPC_REPLY.  Relay the processing to helper functions.
 */
static void xs_tcp_read_data(struct rpc_xprt *xprt,
				    struct xdr_skb_reader *desc)
{
	struct sock_xprt *transport =
				container_of(xprt, struct sock_xprt, xprt);

	if (_xs_tcp_read_data(xprt, desc) == 0)
		xs_tcp_check_fraghdr(transport);
	else {
		/*
		 * The transport_lock protects the request handling.
		 * There's no need to hold it to update the tcp_flags.
		 */
		transport->tcp_flags &= ~TCP_RCV_COPY_DATA;
	}
1173 1174
}

1175
static inline void xs_tcp_read_discard(struct sock_xprt *transport, struct xdr_skb_reader *desc)
1176 1177 1178
{
	size_t len;

1179
	len = transport->tcp_reclen - transport->tcp_offset;
1180 1181 1182 1183
	if (len > desc->count)
		len = desc->count;
	desc->count -= len;
	desc->offset += len;
1184
	transport->tcp_offset += len;
1185
	dprintk("RPC:       discarded %Zu bytes\n", len);
1186
	xs_tcp_check_fraghdr(transport);
1187 1188
}

1189
static int xs_tcp_data_recv(read_descriptor_t *rd_desc, struct sk_buff *skb, unsigned int offset, size_t len)
1190 1191
{
	struct rpc_xprt *xprt = rd_desc->arg.data;
1192
	struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
1193
	struct xdr_skb_reader desc = {
1194 1195 1196
		.skb	= skb,
		.offset	= offset,
		.count	= len,
1197
	};
1198

1199
	dprintk("RPC:       xs_tcp_data_recv started\n");
1200 1201 1202
	do {
		/* Read in a new fragment marker if necessary */
		/* Can we ever really expect to get completely empty fragments? */
1203
		if (transport->tcp_flags & TCP_RCV_COPY_FRAGHDR) {
1204
			xs_tcp_read_fraghdr(xprt, &desc);
1205 1206 1207
			continue;
		}
		/* Read in the xid if necessary */
1208
		if (transport->tcp_flags & TCP_RCV_COPY_XID) {
1209
			xs_tcp_read_xid(transport, &desc);
1210 1211
			continue;
		}
1212
		/* Read in the call/reply flag */
1213
		if (transport->tcp_flags & TCP_RCV_READ_CALLDIR) {
1214 1215 1216
			xs_tcp_read_calldir(transport, &desc);
			continue;
		}
1217
		/* Read in the request data */
1218
		if (transport->tcp_flags & TCP_RCV_COPY_DATA) {
R
Ricardo Labiaga 已提交
1219
			xs_tcp_read_data(xprt, &desc);
1220 1221 1222
			continue;
		}
		/* Skip over any trailing bytes on short reads */
1223
		xs_tcp_read_discard(transport, &desc);
1224
	} while (desc.count);
1225
	dprintk("RPC:       xs_tcp_data_recv done\n");
1226 1227 1228
	return len - desc.count;
}

1229 1230 1231 1232 1233 1234 1235
/**
 * 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)
1236 1237 1238
{
	struct rpc_xprt *xprt;
	read_descriptor_t rd_desc;
1239
	int read;
1240

1241 1242
	dprintk("RPC:       xs_tcp_data_ready...\n");

1243
	read_lock(&sk->sk_callback_lock);
1244
	if (!(xprt = xprt_from_sock(sk)))
1245 1246 1247 1248
		goto out;
	if (xprt->shutdown)
		goto out;

1249 1250 1251 1252 1253 1254
	/* Any data means we had a useful conversation, so
	 * the we don't need to delay the next reconnect
	 */
	if (xprt->reestablish_timeout)
		xprt->reestablish_timeout = 0;

1255
	/* We use rd_desc to pass struct xprt to xs_tcp_data_recv */
1256
	rd_desc.arg.data = xprt;
1257 1258 1259 1260
	do {
		rd_desc.count = 65536;
		read = tcp_read_sock(sk, &rd_desc, xs_tcp_data_recv);
	} while (read > 0);
1261 1262 1263 1264
out:
	read_unlock(&sk->sk_callback_lock);
}

1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305
/*
 * Do the equivalent of linger/linger2 handling for dealing with
 * broken servers that don't close the socket in a timely
 * fashion
 */
static void xs_tcp_schedule_linger_timeout(struct rpc_xprt *xprt,
		unsigned long timeout)
{
	struct sock_xprt *transport;

	if (xprt_test_and_set_connecting(xprt))
		return;
	set_bit(XPRT_CONNECTION_ABORT, &xprt->state);
	transport = container_of(xprt, struct sock_xprt, xprt);
	queue_delayed_work(rpciod_workqueue, &transport->connect_worker,
			   timeout);
}

static void xs_tcp_cancel_linger_timeout(struct rpc_xprt *xprt)
{
	struct sock_xprt *transport;

	transport = container_of(xprt, struct sock_xprt, xprt);

	if (!test_bit(XPRT_CONNECTION_ABORT, &xprt->state) ||
	    !cancel_delayed_work(&transport->connect_worker))
		return;
	clear_bit(XPRT_CONNECTION_ABORT, &xprt->state);
	xprt_clear_connecting(xprt);
}

static void xs_sock_mark_closed(struct rpc_xprt *xprt)
{
	smp_mb__before_clear_bit();
	clear_bit(XPRT_CLOSE_WAIT, &xprt->state);
	clear_bit(XPRT_CLOSING, &xprt->state);
	smp_mb__after_clear_bit();
	/* Mark transport as closed and wake up all pending tasks */
	xprt_disconnect_done(xprt);
}

1306 1307 1308 1309 1310 1311
/**
 * 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)
1312
{
1313
	struct rpc_xprt *xprt;
1314 1315 1316 1317

	read_lock(&sk->sk_callback_lock);
	if (!(xprt = xprt_from_sock(sk)))
		goto out;
1318 1319 1320 1321 1322
	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));
1323 1324 1325

	switch (sk->sk_state) {
	case TCP_ESTABLISHED:
C
Chuck Lever 已提交
1326
		spin_lock_bh(&xprt->transport_lock);
1327
		if (!xprt_test_and_set_connected(xprt)) {
1328 1329 1330
			struct sock_xprt *transport = container_of(xprt,
					struct sock_xprt, xprt);

1331
			/* Reset TCP record info */
1332 1333 1334
			transport->tcp_offset = 0;
			transport->tcp_reclen = 0;
			transport->tcp_copied = 0;
1335 1336
			transport->tcp_flags =
				TCP_RCV_COPY_FRAGHDR | TCP_RCV_COPY_XID;
1337

1338
			xprt_wake_pending_tasks(xprt, -EAGAIN);
1339
		}
C
Chuck Lever 已提交
1340
		spin_unlock_bh(&xprt->transport_lock);
1341
		break;
1342 1343
	case TCP_FIN_WAIT1:
		/* The client initiated a shutdown of the socket */
1344
		xprt->connect_cookie++;
1345
		xprt->reestablish_timeout = 0;
1346 1347 1348
		set_bit(XPRT_CLOSING, &xprt->state);
		smp_mb__before_clear_bit();
		clear_bit(XPRT_CONNECTED, &xprt->state);
1349
		clear_bit(XPRT_CLOSE_WAIT, &xprt->state);
1350
		smp_mb__after_clear_bit();
1351
		xs_tcp_schedule_linger_timeout(xprt, xs_tcp_fin_timeout);
1352
		break;
1353
	case TCP_CLOSE_WAIT:
1354
		/* The server initiated a shutdown of the socket */
1355
		xprt_force_disconnect(xprt);
1356
	case TCP_SYN_SENT:
1357
		xprt->connect_cookie++;
1358 1359 1360 1361 1362 1363 1364
	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;
1365 1366
		break;
	case TCP_LAST_ACK:
1367
		set_bit(XPRT_CLOSING, &xprt->state);
1368
		xs_tcp_schedule_linger_timeout(xprt, xs_tcp_fin_timeout);
1369 1370 1371 1372 1373
		smp_mb__before_clear_bit();
		clear_bit(XPRT_CONNECTED, &xprt->state);
		smp_mb__after_clear_bit();
		break;
	case TCP_CLOSE:
1374 1375
		xs_tcp_cancel_linger_timeout(xprt);
		xs_sock_mark_closed(xprt);
1376 1377 1378 1379 1380
	}
 out:
	read_unlock(&sk->sk_callback_lock);
}

1381
/**
1382
 * xs_error_report - callback mainly for catching socket errors
1383 1384
 * @sk: socket
 */
1385
static void xs_error_report(struct sock *sk)
1386 1387 1388 1389 1390 1391 1392 1393 1394
{
	struct rpc_xprt *xprt;

	read_lock(&sk->sk_callback_lock);
	if (!(xprt = xprt_from_sock(sk)))
		goto out;
	dprintk("RPC:       %s client %p...\n"
			"RPC:       error %d\n",
			__func__, xprt, sk->sk_err);
1395
	xprt_wake_pending_tasks(xprt, -EAGAIN);
1396 1397 1398 1399
out:
	read_unlock(&sk->sk_callback_lock);
}

1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416
static void xs_write_space(struct sock *sk)
{
	struct socket *sock;
	struct rpc_xprt *xprt;

	if (unlikely(!(sock = sk->sk_socket)))
		return;
	clear_bit(SOCK_NOSPACE, &sock->flags);

	if (unlikely(!(xprt = xprt_from_sock(sk))))
		return;
	if (test_and_clear_bit(SOCK_ASYNC_NOSPACE, &sock->flags) == 0)
		return;

	xprt_write_space(xprt);
}

1417
/**
1418 1419
 * xs_udp_write_space - callback invoked when socket buffer space
 *                             becomes available
1420 1421
 * @sk: socket whose state has changed
 *
1422 1423
 * Called when more output buffer space is available for this socket.
 * We try not to wake our writers until they can make "significant"
1424
 * progress, otherwise we'll waste resources thrashing kernel_sendmsg
1425 1426
 * with a bunch of small requests.
 */
1427
static void xs_udp_write_space(struct sock *sk)
1428 1429 1430
{
	read_lock(&sk->sk_callback_lock);

1431
	/* from net/core/sock.c:sock_def_write_space */
1432 1433
	if (sock_writeable(sk))
		xs_write_space(sk);
1434

1435 1436
	read_unlock(&sk->sk_callback_lock);
}
1437

1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452
/**
 * 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 */
1453 1454
	if (sk_stream_wspace(sk) >= sk_stream_min_wspace(sk))
		xs_write_space(sk);
1455

1456 1457 1458
	read_unlock(&sk->sk_callback_lock);
}

1459
static void xs_udp_do_set_buffer_size(struct rpc_xprt *xprt)
1460
{
1461 1462
	struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
	struct sock *sk = transport->inet;
1463

1464
	if (transport->rcvsize) {
1465
		sk->sk_userlocks |= SOCK_RCVBUF_LOCK;
1466
		sk->sk_rcvbuf = transport->rcvsize * xprt->max_reqs * 2;
1467
	}
1468
	if (transport->sndsize) {
1469
		sk->sk_userlocks |= SOCK_SNDBUF_LOCK;
1470
		sk->sk_sndbuf = transport->sndsize * xprt->max_reqs * 2;
1471 1472 1473 1474
		sk->sk_write_space(sk);
	}
}

1475
/**
1476
 * xs_udp_set_buffer_size - set send and receive limits
1477
 * @xprt: generic transport
1478 1479
 * @sndsize: requested size of send buffer, in bytes
 * @rcvsize: requested size of receive buffer, in bytes
1480
 *
1481
 * Set socket send and receive buffer size limits.
1482
 */
1483
static void xs_udp_set_buffer_size(struct rpc_xprt *xprt, size_t sndsize, size_t rcvsize)
1484
{
1485 1486 1487
	struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);

	transport->sndsize = 0;
1488
	if (sndsize)
1489 1490
		transport->sndsize = sndsize + 1024;
	transport->rcvsize = 0;
1491
	if (rcvsize)
1492
		transport->rcvsize = rcvsize + 1024;
1493 1494

	xs_udp_do_set_buffer_size(xprt);
1495 1496
}

1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507
/**
 * 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);
}

1508 1509 1510 1511 1512 1513 1514
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;
}

1515 1516 1517 1518 1519 1520 1521 1522
/**
 * 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)
{
1523
	dprintk("RPC:       setting port for xprt %p to %u\n", xprt, port);
1524

1525 1526
	rpc_set_port(xs_addr(xprt), port);
	xs_update_peer_port(xprt);
1527 1528
}

1529 1530
static unsigned short xs_get_srcport(struct sock_xprt *transport, struct socket *sock)
{
1531
	unsigned short port = transport->srcport;
1532 1533 1534 1535 1536 1537 1538 1539

	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)
{
1540 1541
	if (transport->srcport != 0)
		transport->srcport = 0;
1542 1543 1544 1545 1546 1547 1548
	if (!transport->xprt.resvport)
		return 0;
	if (port <= xprt_min_resvport || port > xprt_max_resvport)
		return xprt_max_resvport;
	return --port;
}

1549
static int xs_bind4(struct sock_xprt *transport, struct socket *sock)
1550 1551 1552 1553
{
	struct sockaddr_in myaddr = {
		.sin_family = AF_INET,
	};
1554
	struct sockaddr_in *sa;
1555 1556 1557
	int err, nloop = 0;
	unsigned short port = xs_get_srcport(transport, sock);
	unsigned short last;
1558

1559
	sa = (struct sockaddr_in *)&transport->srcaddr;
1560
	myaddr.sin_addr = sa->sin_addr;
1561 1562
	do {
		myaddr.sin_port = htons(port);
1563
		err = kernel_bind(sock, (struct sockaddr *) &myaddr,
1564
						sizeof(myaddr));
1565
		if (port == 0)
1566
			break;
1567
		if (err == 0) {
1568
			transport->srcport = port;
1569
			break;
1570
		}
1571 1572 1573 1574 1575
		last = port;
		port = xs_next_srcport(transport, sock, port);
		if (port > last)
			nloop++;
	} while (err == -EADDRINUSE && nloop != 2);
H
Harvey Harrison 已提交
1576 1577
	dprintk("RPC:       %s %pI4:%u: %s (%d)\n",
			__func__, &myaddr.sin_addr,
1578
			port, err ? "failed" : "ok", err);
1579 1580 1581
	return err;
}

1582 1583 1584 1585 1586 1587
static int xs_bind6(struct sock_xprt *transport, struct socket *sock)
{
	struct sockaddr_in6 myaddr = {
		.sin6_family = AF_INET6,
	};
	struct sockaddr_in6 *sa;
1588 1589 1590
	int err, nloop = 0;
	unsigned short port = xs_get_srcport(transport, sock);
	unsigned short last;
1591

1592
	sa = (struct sockaddr_in6 *)&transport->srcaddr;
1593 1594 1595 1596 1597
	myaddr.sin6_addr = sa->sin6_addr;
	do {
		myaddr.sin6_port = htons(port);
		err = kernel_bind(sock, (struct sockaddr *) &myaddr,
						sizeof(myaddr));
1598
		if (port == 0)
1599 1600
			break;
		if (err == 0) {
1601
			transport->srcport = port;
1602 1603
			break;
		}
1604 1605 1606 1607 1608
		last = port;
		port = xs_next_srcport(transport, sock, port);
		if (port > last)
			nloop++;
	} while (err == -EADDRINUSE && nloop != 2);
H
Harvey Harrison 已提交
1609
	dprintk("RPC:       xs_bind6 %pI6:%u: %s (%d)\n",
1610
		&myaddr.sin6_addr, port, err ? "failed" : "ok", err);
1611 1612 1613
	return err;
}

1614 1615 1616 1617
#ifdef CONFIG_DEBUG_LOCK_ALLOC
static struct lock_class_key xs_key[2];
static struct lock_class_key xs_slock_key[2];

1618
static inline void xs_reclassify_socket4(struct socket *sock)
1619 1620
{
	struct sock *sk = sock->sk;
1621

1622
	BUG_ON(sock_owned_by_user(sk));
1623 1624 1625
	sock_lock_init_class_and_name(sk, "slock-AF_INET-RPC",
		&xs_slock_key[0], "sk_lock-AF_INET-RPC", &xs_key[0]);
}
1626

1627 1628 1629
static inline void xs_reclassify_socket6(struct socket *sock)
{
	struct sock *sk = sock->sk;
1630

1631
	BUG_ON(sock_owned_by_user(sk));
1632 1633
	sock_lock_init_class_and_name(sk, "slock-AF_INET6-RPC",
		&xs_slock_key[1], "sk_lock-AF_INET6-RPC", &xs_key[1]);
1634 1635
}
#else
1636 1637 1638 1639 1640
static inline void xs_reclassify_socket4(struct socket *sock)
{
}

static inline void xs_reclassify_socket6(struct socket *sock)
1641 1642 1643 1644
{
}
#endif

1645 1646 1647 1648 1649 1650 1651 1652 1653
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);

1654 1655
		xs_save_old_callbacks(transport, sk);

1656 1657 1658
		sk->sk_user_data = xprt;
		sk->sk_data_ready = xs_udp_data_ready;
		sk->sk_write_space = xs_udp_write_space;
1659
		sk->sk_error_report = xs_error_report;
1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673
		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);
}

1674
/**
C
Chuck Lever 已提交
1675
 * xs_udp_connect_worker4 - set up a UDP socket
1676
 * @work: RPC transport to connect
1677 1678 1679
 *
 * Invoked by a work queue tasklet.
 */
C
Chuck Lever 已提交
1680
static void xs_udp_connect_worker4(struct work_struct *work)
1681
{
1682 1683
	struct sock_xprt *transport =
		container_of(work, struct sock_xprt, connect_worker.work);
1684
	struct rpc_xprt *xprt = &transport->xprt;
1685
	struct socket *sock = transport->sock;
1686
	int err, status = -EIO;
1687

1688
	if (xprt->shutdown)
1689
		goto out;
1690

1691
	/* Start by resetting any existing state */
1692
	xs_reset_transport(transport);
1693

1694 1695
	err = sock_create_kern(PF_INET, SOCK_DGRAM, IPPROTO_UDP, &sock);
	if (err < 0) {
1696
		dprintk("RPC:       can't create UDP transport socket (%d).\n", -err);
1697 1698
		goto out;
	}
1699
	xs_reclassify_socket4(sock);
1700

1701
	if (xs_bind4(transport, sock)) {
1702 1703 1704
		sock_release(sock);
		goto out;
	}
1705

C
Chuck Lever 已提交
1706 1707 1708 1709 1710
	dprintk("RPC:       worker connecting xprt %p via %s to "
				"%s (port %s)\n", xprt,
			xprt->address_strings[RPC_DISPLAY_PROTO],
			xprt->address_strings[RPC_DISPLAY_ADDR],
			xprt->address_strings[RPC_DISPLAY_PORT]);
1711

1712
	xs_udp_finish_connecting(xprt, sock);
1713 1714 1715
	status = 0;
out:
	xprt_clear_connecting(xprt);
1716
	xprt_wake_pending_tasks(xprt, status);
1717 1718
}

1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731
/**
 * 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;
1732

1733
	if (xprt->shutdown)
1734
		goto out;
1735

1736
	/* Start by resetting any existing state */
1737
	xs_reset_transport(transport);
1738

1739 1740
	err = sock_create_kern(PF_INET6, SOCK_DGRAM, IPPROTO_UDP, &sock);
	if (err < 0) {
1741 1742 1743
		dprintk("RPC:       can't create UDP transport socket (%d).\n", -err);
		goto out;
	}
1744
	xs_reclassify_socket6(sock);
1745

1746 1747 1748
	if (xs_bind6(transport, sock) < 0) {
		sock_release(sock);
		goto out;
1749
	}
1750

C
Chuck Lever 已提交
1751 1752 1753 1754 1755
	dprintk("RPC:       worker connecting xprt %p via %s to "
				"%s (port %s)\n", xprt,
			xprt->address_strings[RPC_DISPLAY_PROTO],
			xprt->address_strings[RPC_DISPLAY_ADDR],
			xprt->address_strings[RPC_DISPLAY_PORT]);
1756 1757

	xs_udp_finish_connecting(xprt, sock);
1758 1759 1760
	status = 0;
out:
	xprt_clear_connecting(xprt);
1761
	xprt_wake_pending_tasks(xprt, status);
1762 1763
}

1764 1765 1766 1767
/*
 * 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.
 */
1768
static void xs_abort_connection(struct rpc_xprt *xprt, struct sock_xprt *transport)
1769 1770 1771 1772
{
	int result;
	struct sockaddr any;

1773
	dprintk("RPC:       disconnecting xprt %p to reuse port\n", xprt);
1774 1775 1776 1777 1778 1779 1780

	/*
	 * 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;
1781
	result = kernel_connect(transport->sock, &any, sizeof(any), 0);
1782 1783 1784
	if (!result)
		xs_sock_mark_closed(xprt);
	else
1785
		dprintk("RPC:       AF_UNSPEC connect return code %d\n",
1786 1787 1788
				result);
}

1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799
static void xs_tcp_reuse_connection(struct rpc_xprt *xprt, struct sock_xprt *transport)
{
	unsigned int state = transport->inet->sk_state;

	if (state == TCP_CLOSE && transport->sock->state == SS_UNCONNECTED)
		return;
	if ((1 << state) & (TCPF_ESTABLISHED|TCPF_SYN_SENT))
		return;
	xs_abort_connection(xprt, transport);
}

1800
static int xs_tcp_finish_connecting(struct rpc_xprt *xprt, struct socket *sock)
1801
{
1802
	struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
1803

1804
	if (!transport->inet) {
1805 1806 1807 1808
		struct sock *sk = sock->sk;

		write_lock_bh(&sk->sk_callback_lock);

1809 1810
		xs_save_old_callbacks(transport, sk);

1811 1812 1813 1814
		sk->sk_user_data = xprt;
		sk->sk_data_ready = xs_tcp_data_ready;
		sk->sk_state_change = xs_tcp_state_change;
		sk->sk_write_space = xs_tcp_write_space;
1815
		sk->sk_error_report = xs_error_report;
1816
		sk->sk_allocation = GFP_ATOMIC;
1817 1818 1819 1820 1821 1822

		/* 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;
1823 1824 1825 1826

		xprt_clear_connected(xprt);

		/* Reset to new socket */
1827 1828
		transport->sock = sock;
		transport->inet = sk;
1829 1830 1831 1832

		write_unlock_bh(&sk->sk_callback_lock);
	}

1833 1834 1835
	if (!xprt_bound(xprt))
		return -ENOTCONN;

1836
	/* Tell the socket layer to start connecting... */
1837 1838
	xprt->stat.connect_count++;
	xprt->stat.connect_start = jiffies;
1839
	return kernel_connect(sock, xs_addr(xprt), xprt->addrlen, O_NONBLOCK);
1840 1841
}

1842
/**
1843 1844 1845 1846
 * xs_tcp_setup_socket - create a TCP socket and connect to a remote endpoint
 * @xprt: RPC transport to connect
 * @transport: socket transport to connect
 * @create_sock: function to create a socket of the correct type
1847 1848
 *
 * Invoked by a work queue tasklet.
1849
 */
1850 1851 1852 1853
static void xs_tcp_setup_socket(struct rpc_xprt *xprt,
		struct sock_xprt *transport,
		struct socket *(*create_sock)(struct rpc_xprt *,
			struct sock_xprt *))
1854
{
1855
	struct socket *sock = transport->sock;
1856
	int status = -EIO;
1857

1858
	if (xprt->shutdown)
1859 1860
		goto out;

1861
	if (!sock) {
1862
		clear_bit(XPRT_CONNECTION_ABORT, &xprt->state);
1863 1864 1865
		sock = create_sock(xprt, transport);
		if (IS_ERR(sock)) {
			status = PTR_ERR(sock);
1866 1867
			goto out;
		}
1868 1869
	} else {
		int abort_and_exit;
1870

1871 1872
		abort_and_exit = test_and_clear_bit(XPRT_CONNECTION_ABORT,
				&xprt->state);
1873
		/* "close" the socket, preserving the local port */
1874
		xs_tcp_reuse_connection(xprt, transport);
1875

1876 1877 1878
		if (abort_and_exit)
			goto out_eagain;
	}
1879

C
Chuck Lever 已提交
1880 1881 1882 1883 1884
	dprintk("RPC:       worker connecting xprt %p via %s to "
				"%s (port %s)\n", xprt,
			xprt->address_strings[RPC_DISPLAY_PROTO],
			xprt->address_strings[RPC_DISPLAY_ADDR],
			xprt->address_strings[RPC_DISPLAY_PORT]);
1885

1886
	status = xs_tcp_finish_connecting(xprt, sock);
1887 1888 1889
	dprintk("RPC:       %p connect status %d connected %d sock state %d\n",
			xprt, -status, xprt_connected(xprt),
			sock->sk->sk_state);
1890
	switch (status) {
1891 1892 1893 1894 1895 1896 1897 1898 1899
	default:
		printk("%s: connect returned unhandled error %d\n",
			__func__, status);
	case -EADDRNOTAVAIL:
		/* We're probably in TIME_WAIT. Get rid of existing socket,
		 * and retry
		 */
		set_bit(XPRT_CONNECTION_CLOSE, &xprt->state);
		xprt_force_disconnect(xprt);
1900
		break;
1901 1902 1903 1904
	case -ECONNREFUSED:
	case -ECONNRESET:
	case -ENETUNREACH:
		/* retry with existing socket, after a delay */
1905 1906 1907
	case 0:
	case -EINPROGRESS:
	case -EALREADY:
1908 1909
		xprt_clear_connecting(xprt);
		return;
1910 1911 1912 1913 1914
	case -EINVAL:
		/* Happens, for instance, if the user specified a link
		 * local IPv6 address without a scope-id.
		 */
		goto out;
1915
	}
1916
out_eagain:
1917
	status = -EAGAIN;
1918
out:
1919
	xprt_clear_connecting(xprt);
1920
	xprt_wake_pending_tasks(xprt, status);
1921
}
1922

1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 1940 1941 1942 1943 1944
static struct socket *xs_create_tcp_sock4(struct rpc_xprt *xprt,
		struct sock_xprt *transport)
{
	struct socket *sock;
	int err;

	/* start from scratch */
	err = sock_create_kern(PF_INET, SOCK_STREAM, IPPROTO_TCP, &sock);
	if (err < 0) {
		dprintk("RPC:       can't create TCP transport socket (%d).\n",
				-err);
		goto out_err;
	}
	xs_reclassify_socket4(sock);

	if (xs_bind4(transport, sock) < 0) {
		sock_release(sock);
		goto out_err;
	}
	return sock;
out_err:
	return ERR_PTR(-EIO);
1945
}
1946

1947
/**
1948
 * xs_tcp_connect_worker4 - connect a TCP socket to a remote endpoint
1949 1950 1951 1952
 * @work: RPC transport to connect
 *
 * Invoked by a work queue tasklet.
 */
1953
static void xs_tcp_connect_worker4(struct work_struct *work)
1954 1955 1956 1957
{
	struct sock_xprt *transport =
		container_of(work, struct sock_xprt, connect_worker.work);
	struct rpc_xprt *xprt = &transport->xprt;
1958

1959 1960
	xs_tcp_setup_socket(xprt, transport, xs_create_tcp_sock4);
}
1961

1962 1963 1964 1965 1966
static struct socket *xs_create_tcp_sock6(struct rpc_xprt *xprt,
		struct sock_xprt *transport)
{
	struct socket *sock;
	int err;
1967

1968 1969 1970 1971 1972 1973 1974 1975
	/* start from scratch */
	err = sock_create_kern(PF_INET6, SOCK_STREAM, IPPROTO_TCP, &sock);
	if (err < 0) {
		dprintk("RPC:       can't create TCP transport socket (%d).\n",
				-err);
		goto out_err;
	}
	xs_reclassify_socket6(sock);
1976

1977 1978 1979
	if (xs_bind6(transport, sock) < 0) {
		sock_release(sock);
		goto out_err;
1980
	}
1981 1982 1983 1984
	return sock;
out_err:
	return ERR_PTR(-EIO);
}
1985

1986 1987 1988 1989 1990 1991 1992 1993 1994 1995 1996
/**
 * 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;
1997

1998
	xs_tcp_setup_socket(xprt, transport, xs_create_tcp_sock6);
1999 2000
}

2001 2002 2003 2004 2005
/**
 * 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.
2006 2007 2008 2009 2010 2011 2012
 *
 * 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).
2013 2014
 */
static void xs_connect(struct rpc_task *task)
2015 2016
{
	struct rpc_xprt *xprt = task->tk_xprt;
2017
	struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
2018

2019 2020 2021
	if (xprt_test_and_set_connecting(xprt))
		return;

2022
	if (transport->sock != NULL && !RPC_IS_SOFTCONN(task)) {
2023 2024
		dprintk("RPC:       xs_connect delayed xprt %p for %lu "
				"seconds\n",
2025
				xprt, xprt->reestablish_timeout / HZ);
2026 2027 2028
		queue_delayed_work(rpciod_workqueue,
				   &transport->connect_worker,
				   xprt->reestablish_timeout);
2029
		xprt->reestablish_timeout <<= 1;
2030 2031
		if (xprt->reestablish_timeout < XS_TCP_INIT_REEST_TO)
			xprt->reestablish_timeout = XS_TCP_INIT_REEST_TO;
2032 2033
		if (xprt->reestablish_timeout > XS_TCP_MAX_REEST_TO)
			xprt->reestablish_timeout = XS_TCP_MAX_REEST_TO;
2034
	} else {
2035
		dprintk("RPC:       xs_connect scheduled xprt %p\n", xprt);
2036 2037
		queue_delayed_work(rpciod_workqueue,
				   &transport->connect_worker, 0);
2038 2039 2040
	}
}

2041 2042 2043 2044 2045 2046 2047 2048 2049 2050
static void xs_tcp_connect(struct rpc_task *task)
{
	struct rpc_xprt *xprt = task->tk_xprt;

	/* Exit if we need to wait for socket shutdown to complete */
	if (test_bit(XPRT_CLOSING, &xprt->state))
		return;
	xs_connect(task);
}

2051 2052 2053 2054 2055 2056 2057 2058
/**
 * 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)
{
2059 2060
	struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);

2061
	seq_printf(seq, "\txprt:\tudp %u %lu %lu %lu %lu %Lu %Lu\n",
2062
			transport->srcport,
2063 2064 2065 2066 2067 2068 2069 2070 2071 2072 2073 2074 2075 2076 2077 2078
			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)
{
2079
	struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
2080 2081 2082 2083 2084 2085
	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",
2086
			transport->srcport,
2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097
			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);
}

2098 2099 2100 2101 2102
/*
 * Allocate a bunch of pages for a scratch buffer for the rpc code. The reason
 * we allocate pages instead doing a kmalloc like rpc_malloc is because we want
 * to use the server side send routines.
 */
2103
static void *bc_malloc(struct rpc_task *task, size_t size)
2104 2105 2106 2107 2108 2109 2110 2111 2112 2113 2114 2115 2116 2117 2118 2119 2120 2121 2122
{
	struct page *page;
	struct rpc_buffer *buf;

	BUG_ON(size > PAGE_SIZE - sizeof(struct rpc_buffer));
	page = alloc_page(GFP_KERNEL);

	if (!page)
		return NULL;

	buf = page_address(page);
	buf->len = PAGE_SIZE;

	return buf->data;
}

/*
 * Free the space allocated in the bc_alloc routine
 */
2123
static void bc_free(void *buffer)
2124 2125 2126 2127 2128 2129 2130 2131 2132 2133 2134 2135 2136 2137 2138 2139 2140 2141 2142 2143 2144 2145 2146 2147 2148 2149 2150 2151 2152 2153 2154 2155 2156 2157 2158 2159 2160 2161 2162 2163 2164 2165 2166 2167 2168 2169 2170 2171 2172 2173 2174 2175 2176 2177 2178 2179 2180 2181 2182 2183 2184 2185 2186 2187 2188 2189 2190 2191 2192 2193 2194 2195 2196 2197 2198 2199 2200 2201 2202 2203 2204 2205 2206 2207 2208 2209 2210 2211 2212 2213 2214 2215 2216 2217 2218 2219 2220 2221 2222 2223 2224 2225
{
	struct rpc_buffer *buf;

	if (!buffer)
		return;

	buf = container_of(buffer, struct rpc_buffer, data);
	free_page((unsigned long)buf);
}

/*
 * Use the svc_sock to send the callback. Must be called with svsk->sk_mutex
 * held. Borrows heavily from svc_tcp_sendto and xs_tcp_send_request.
 */
static int bc_sendto(struct rpc_rqst *req)
{
	int len;
	struct xdr_buf *xbufp = &req->rq_snd_buf;
	struct rpc_xprt *xprt = req->rq_xprt;
	struct sock_xprt *transport =
				container_of(xprt, struct sock_xprt, xprt);
	struct socket *sock = transport->sock;
	unsigned long headoff;
	unsigned long tailoff;

	/*
	 * Set up the rpc header and record marker stuff
	 */
	xs_encode_tcp_record_marker(xbufp);

	tailoff = (unsigned long)xbufp->tail[0].iov_base & ~PAGE_MASK;
	headoff = (unsigned long)xbufp->head[0].iov_base & ~PAGE_MASK;
	len = svc_send_common(sock, xbufp,
			      virt_to_page(xbufp->head[0].iov_base), headoff,
			      xbufp->tail[0].iov_base, tailoff);

	if (len != xbufp->len) {
		printk(KERN_NOTICE "Error sending entire callback!\n");
		len = -EAGAIN;
	}

	return len;
}

/*
 * The send routine. Borrows from svc_send
 */
static int bc_send_request(struct rpc_task *task)
{
	struct rpc_rqst *req = task->tk_rqstp;
	struct svc_xprt	*xprt;
	struct svc_sock         *svsk;
	u32                     len;

	dprintk("sending request with xid: %08x\n", ntohl(req->rq_xid));
	/*
	 * Get the server socket associated with this callback xprt
	 */
	xprt = req->rq_xprt->bc_xprt;
	svsk = container_of(xprt, struct svc_sock, sk_xprt);

	/*
	 * Grab the mutex to serialize data as the connection is shared
	 * with the fore channel
	 */
	if (!mutex_trylock(&xprt->xpt_mutex)) {
		rpc_sleep_on(&xprt->xpt_bc_pending, task, NULL);
		if (!mutex_trylock(&xprt->xpt_mutex))
			return -EAGAIN;
		rpc_wake_up_queued_task(&xprt->xpt_bc_pending, task);
	}
	if (test_bit(XPT_DEAD, &xprt->xpt_flags))
		len = -ENOTCONN;
	else
		len = bc_sendto(req);
	mutex_unlock(&xprt->xpt_mutex);

	if (len > 0)
		len = 0;

	return len;
}

/*
 * The close routine. Since this is client initiated, we do nothing
 */

static void bc_close(struct rpc_xprt *xprt)
{
	return;
}

/*
 * The xprt destroy routine. Again, because this connection is client
 * initiated, we do nothing
 */

static void bc_destroy(struct rpc_xprt *xprt)
{
	return;
}

2226
static struct rpc_xprt_ops xs_udp_ops = {
2227
	.set_buffer_size	= xs_udp_set_buffer_size,
2228
	.reserve_xprt		= xprt_reserve_xprt_cong,
2229
	.release_xprt		= xprt_release_xprt_cong,
2230
	.rpcbind		= rpcb_getport_async,
2231
	.set_port		= xs_set_port,
2232
	.connect		= xs_connect,
2233 2234
	.buf_alloc		= rpc_malloc,
	.buf_free		= rpc_free,
2235
	.send_request		= xs_udp_send_request,
2236
	.set_retrans_timeout	= xprt_set_retrans_timeout_rtt,
2237
	.timer			= xs_udp_timer,
2238
	.release_request	= xprt_release_rqst_cong,
2239 2240
	.close			= xs_close,
	.destroy		= xs_destroy,
2241
	.print_stats		= xs_udp_print_stats,
2242 2243 2244
};

static struct rpc_xprt_ops xs_tcp_ops = {
2245
	.reserve_xprt		= xprt_reserve_xprt,
2246
	.release_xprt		= xs_tcp_release_xprt,
2247
	.rpcbind		= rpcb_getport_async,
2248
	.set_port		= xs_set_port,
2249
	.connect		= xs_tcp_connect,
2250 2251
	.buf_alloc		= rpc_malloc,
	.buf_free		= rpc_free,
2252
	.send_request		= xs_tcp_send_request,
2253
	.set_retrans_timeout	= xprt_set_retrans_timeout_def,
2254
	.close			= xs_tcp_close,
2255
	.destroy		= xs_destroy,
2256
	.print_stats		= xs_tcp_print_stats,
2257 2258
};

2259 2260 2261 2262 2263 2264 2265 2266 2267 2268 2269 2270 2271 2272 2273 2274
/*
 * The rpc_xprt_ops for the server backchannel
 */

static struct rpc_xprt_ops bc_tcp_ops = {
	.reserve_xprt		= xprt_reserve_xprt,
	.release_xprt		= xprt_release_xprt,
	.buf_alloc		= bc_malloc,
	.buf_free		= bc_free,
	.send_request		= bc_send_request,
	.set_retrans_timeout	= xprt_set_retrans_timeout_def,
	.close			= bc_close,
	.destroy		= bc_destroy,
	.print_stats		= xs_tcp_print_stats,
};

2275
static struct rpc_xprt *xs_setup_xprt(struct xprt_create *args,
2276
				      unsigned int slot_table_size)
2277 2278
{
	struct rpc_xprt *xprt;
2279
	struct sock_xprt *new;
2280

2281
	if (args->addrlen > sizeof(xprt->addr)) {
2282
		dprintk("RPC:       xs_setup_xprt: address too large\n");
2283 2284 2285
		return ERR_PTR(-EBADF);
	}

2286 2287
	new = kzalloc(sizeof(*new), GFP_KERNEL);
	if (new == NULL) {
2288 2289
		dprintk("RPC:       xs_setup_xprt: couldn't allocate "
				"rpc_xprt\n");
2290 2291
		return ERR_PTR(-ENOMEM);
	}
2292
	xprt = &new->xprt;
2293 2294 2295 2296 2297

	xprt->max_reqs = slot_table_size;
	xprt->slot = kcalloc(xprt->max_reqs, sizeof(struct rpc_rqst), GFP_KERNEL);
	if (xprt->slot == NULL) {
		kfree(xprt);
2298 2299
		dprintk("RPC:       xs_setup_xprt: couldn't allocate slot "
				"table\n");
2300 2301 2302
		return ERR_PTR(-ENOMEM);
	}

2303 2304
	memcpy(&xprt->addr, args->dstaddr, args->addrlen);
	xprt->addrlen = args->addrlen;
2305
	if (args->srcaddr)
2306
		memcpy(&new->srcaddr, args->srcaddr, args->addrlen);
2307 2308 2309 2310

	return xprt;
}

2311 2312 2313 2314 2315 2316 2317
static const struct rpc_timeout xs_udp_default_timeout = {
	.to_initval = 5 * HZ,
	.to_maxval = 30 * HZ,
	.to_increment = 5 * HZ,
	.to_retries = 5,
};

2318 2319
/**
 * xs_setup_udp - Set up transport to use a UDP socket
2320
 * @args: rpc transport creation arguments
2321 2322
 *
 */
2323
static struct rpc_xprt *xs_setup_udp(struct xprt_create *args)
2324
{
2325
	struct sockaddr *addr = args->dstaddr;
2326
	struct rpc_xprt *xprt;
2327
	struct sock_xprt *transport;
2328

2329
	xprt = xs_setup_xprt(args, xprt_udp_slot_table_entries);
2330 2331
	if (IS_ERR(xprt))
		return xprt;
2332
	transport = container_of(xprt, struct sock_xprt, xprt);
2333

2334
	xprt->prot = IPPROTO_UDP;
2335
	xprt->tsh_size = 0;
2336 2337 2338
	/* XXX: header size can vary due to auth type, IPv6, etc. */
	xprt->max_payload = (1U << 16) - (MAX_HEADER << 3);

2339 2340 2341 2342
	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;
2343

2344
	xprt->ops = &xs_udp_ops;
2345

2346
	xprt->timeout = &xs_udp_default_timeout;
2347

2348 2349 2350 2351 2352 2353 2354
	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);
2355
		xs_format_peer_addresses(xprt, "udp", RPCBIND_NETID_UDP);
2356 2357 2358 2359 2360 2361 2362
		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);
2363
		xs_format_peer_addresses(xprt, "udp", RPCBIND_NETID_UDP6);
2364 2365 2366 2367 2368 2369
		break;
	default:
		kfree(xprt);
		return ERR_PTR(-EAFNOSUPPORT);
	}

C
Chuck Lever 已提交
2370 2371 2372 2373 2374 2375 2376 2377 2378
	if (xprt_bound(xprt))
		dprintk("RPC:       set up xprt to %s (port %s) via %s\n",
				xprt->address_strings[RPC_DISPLAY_ADDR],
				xprt->address_strings[RPC_DISPLAY_PORT],
				xprt->address_strings[RPC_DISPLAY_PROTO]);
	else
		dprintk("RPC:       set up xprt to %s (autobind) via %s\n",
				xprt->address_strings[RPC_DISPLAY_ADDR],
				xprt->address_strings[RPC_DISPLAY_PROTO]);
2379

2380 2381 2382 2383 2384 2385
	if (try_module_get(THIS_MODULE))
		return xprt;

	kfree(xprt->slot);
	kfree(xprt);
	return ERR_PTR(-EINVAL);
2386 2387
}

2388 2389 2390 2391 2392 2393
static const struct rpc_timeout xs_tcp_default_timeout = {
	.to_initval = 60 * HZ,
	.to_maxval = 60 * HZ,
	.to_retries = 2,
};

2394 2395
/**
 * xs_setup_tcp - Set up transport to use a TCP socket
2396
 * @args: rpc transport creation arguments
2397 2398
 *
 */
2399
static struct rpc_xprt *xs_setup_tcp(struct xprt_create *args)
2400
{
2401
	struct sockaddr *addr = args->dstaddr;
2402
	struct rpc_xprt *xprt;
2403
	struct sock_xprt *transport;
2404

2405
	xprt = xs_setup_xprt(args, xprt_tcp_slot_table_entries);
2406 2407
	if (IS_ERR(xprt))
		return xprt;
2408
	transport = container_of(xprt, struct sock_xprt, xprt);
2409

2410
	xprt->prot = IPPROTO_TCP;
2411 2412
	xprt->tsh_size = sizeof(rpc_fraghdr) / sizeof(u32);
	xprt->max_payload = RPC_MAX_FRAGMENT_SIZE;
2413

2414 2415 2416 2417
	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;
2418

2419
	xprt->ops = &xs_tcp_ops;
2420
	xprt->timeout = &xs_tcp_default_timeout;
2421

2422 2423 2424 2425 2426
	switch (addr->sa_family) {
	case AF_INET:
		if (((struct sockaddr_in *)addr)->sin_port != htons(0))
			xprt_set_bound(xprt);

2427 2428 2429
		INIT_DELAYED_WORK(&transport->connect_worker,
					xs_tcp_connect_worker4);
		xs_format_peer_addresses(xprt, "tcp", RPCBIND_NETID_TCP);
2430 2431 2432 2433 2434
		break;
	case AF_INET6:
		if (((struct sockaddr_in6 *)addr)->sin6_port != htons(0))
			xprt_set_bound(xprt);

2435 2436 2437
		INIT_DELAYED_WORK(&transport->connect_worker,
					xs_tcp_connect_worker6);
		xs_format_peer_addresses(xprt, "tcp", RPCBIND_NETID_TCP6);
2438 2439 2440 2441 2442 2443
		break;
	default:
		kfree(xprt);
		return ERR_PTR(-EAFNOSUPPORT);
	}

C
Chuck Lever 已提交
2444 2445 2446 2447 2448 2449 2450 2451 2452 2453
	if (xprt_bound(xprt))
		dprintk("RPC:       set up xprt to %s (port %s) via %s\n",
				xprt->address_strings[RPC_DISPLAY_ADDR],
				xprt->address_strings[RPC_DISPLAY_PORT],
				xprt->address_strings[RPC_DISPLAY_PROTO]);
	else
		dprintk("RPC:       set up xprt to %s (autobind) via %s\n",
				xprt->address_strings[RPC_DISPLAY_ADDR],
				xprt->address_strings[RPC_DISPLAY_PROTO]);

2454

2455 2456 2457 2458 2459 2460
	if (try_module_get(THIS_MODULE))
		return xprt;

	kfree(xprt->slot);
	kfree(xprt);
	return ERR_PTR(-EINVAL);
2461
}
2462

2463 2464 2465 2466 2467 2468 2469 2470 2471 2472 2473 2474 2475 2476 2477 2478 2479 2480 2481 2482 2483 2484 2485 2486 2487 2488 2489 2490 2491 2492 2493 2494 2495 2496 2497 2498 2499 2500 2501 2502 2503 2504 2505 2506 2507 2508 2509 2510 2511 2512 2513 2514 2515 2516 2517 2518 2519 2520 2521 2522 2523 2524 2525 2526 2527 2528 2529 2530 2531 2532 2533 2534 2535 2536 2537 2538 2539 2540 2541 2542 2543 2544
/**
 * xs_setup_bc_tcp - Set up transport to use a TCP backchannel socket
 * @args: rpc transport creation arguments
 *
 */
static struct rpc_xprt *xs_setup_bc_tcp(struct xprt_create *args)
{
	struct sockaddr *addr = args->dstaddr;
	struct rpc_xprt *xprt;
	struct sock_xprt *transport;
	struct svc_sock *bc_sock;

	if (!args->bc_xprt)
		ERR_PTR(-EINVAL);

	xprt = xs_setup_xprt(args, xprt_tcp_slot_table_entries);
	if (IS_ERR(xprt))
		return xprt;
	transport = container_of(xprt, struct sock_xprt, xprt);

	xprt->prot = IPPROTO_TCP;
	xprt->tsh_size = sizeof(rpc_fraghdr) / sizeof(u32);
	xprt->max_payload = RPC_MAX_FRAGMENT_SIZE;
	xprt->timeout = &xs_tcp_default_timeout;

	/* backchannel */
	xprt_set_bound(xprt);
	xprt->bind_timeout = 0;
	xprt->connect_timeout = 0;
	xprt->reestablish_timeout = 0;
	xprt->idle_timeout = 0;

	/*
	 * The backchannel uses the same socket connection as the
	 * forechannel
	 */
	xprt->bc_xprt = args->bc_xprt;
	bc_sock = container_of(args->bc_xprt, struct svc_sock, sk_xprt);
	bc_sock->sk_bc_xprt = xprt;
	transport->sock = bc_sock->sk_sock;
	transport->inet = bc_sock->sk_sk;

	xprt->ops = &bc_tcp_ops;

	switch (addr->sa_family) {
	case AF_INET:
		xs_format_peer_addresses(xprt, "tcp",
					 RPCBIND_NETID_TCP);
		break;
	case AF_INET6:
		xs_format_peer_addresses(xprt, "tcp",
				   RPCBIND_NETID_TCP6);
		break;
	default:
		kfree(xprt);
		return ERR_PTR(-EAFNOSUPPORT);
	}

	if (xprt_bound(xprt))
		dprintk("RPC:       set up xprt to %s (port %s) via %s\n",
				xprt->address_strings[RPC_DISPLAY_ADDR],
				xprt->address_strings[RPC_DISPLAY_PORT],
				xprt->address_strings[RPC_DISPLAY_PROTO]);
	else
		dprintk("RPC:       set up xprt to %s (autobind) via %s\n",
				xprt->address_strings[RPC_DISPLAY_ADDR],
				xprt->address_strings[RPC_DISPLAY_PROTO]);

	/*
	 * Since we don't want connections for the backchannel, we set
	 * the xprt status to connected
	 */
	xprt_set_connected(xprt);


	if (try_module_get(THIS_MODULE))
		return xprt;
	kfree(xprt->slot);
	kfree(xprt);
	return ERR_PTR(-EINVAL);
}

2545 2546 2547 2548
static struct xprt_class	xs_udp_transport = {
	.list		= LIST_HEAD_INIT(xs_udp_transport.list),
	.name		= "udp",
	.owner		= THIS_MODULE,
2549
	.ident		= XPRT_TRANSPORT_UDP,
2550 2551 2552 2553 2554 2555 2556
	.setup		= xs_setup_udp,
};

static struct xprt_class	xs_tcp_transport = {
	.list		= LIST_HEAD_INIT(xs_tcp_transport.list),
	.name		= "tcp",
	.owner		= THIS_MODULE,
2557
	.ident		= XPRT_TRANSPORT_TCP,
2558 2559 2560
	.setup		= xs_setup_tcp,
};

2561 2562 2563 2564 2565 2566 2567 2568
static struct xprt_class	xs_bc_tcp_transport = {
	.list		= LIST_HEAD_INIT(xs_bc_tcp_transport.list),
	.name		= "tcp NFSv4.1 backchannel",
	.owner		= THIS_MODULE,
	.ident		= XPRT_TRANSPORT_BC_TCP,
	.setup		= xs_setup_bc_tcp,
};

2569
/**
2570
 * init_socket_xprt - set up xprtsock's sysctls, register with RPC client
2571 2572 2573 2574
 *
 */
int init_socket_xprt(void)
{
2575
#ifdef RPC_DEBUG
2576
	if (!sunrpc_table_header)
2577
		sunrpc_table_header = register_sysctl_table(sunrpc_table);
2578 2579
#endif

2580 2581
	xprt_register_transport(&xs_udp_transport);
	xprt_register_transport(&xs_tcp_transport);
2582
	xprt_register_transport(&xs_bc_tcp_transport);
2583

2584 2585 2586 2587
	return 0;
}

/**
2588
 * cleanup_socket_xprt - remove xprtsock's sysctls, unregister
2589 2590 2591 2592
 *
 */
void cleanup_socket_xprt(void)
{
2593 2594 2595 2596 2597 2598
#ifdef RPC_DEBUG
	if (sunrpc_table_header) {
		unregister_sysctl_table(sunrpc_table_header);
		sunrpc_table_header = NULL;
	}
#endif
2599 2600 2601

	xprt_unregister_transport(&xs_udp_transport);
	xprt_unregister_transport(&xs_tcp_transport);
2602
	xprt_unregister_transport(&xs_bc_tcp_transport);
2603
}
2604 2605 2606 2607 2608 2609 2610 2611 2612 2613 2614 2615 2616 2617 2618 2619 2620 2621 2622 2623 2624 2625 2626 2627 2628 2629 2630 2631 2632 2633 2634 2635 2636 2637 2638 2639 2640 2641 2642 2643 2644 2645 2646 2647 2648 2649 2650 2651 2652 2653 2654 2655

static int param_set_uint_minmax(const char *val, struct kernel_param *kp,
		unsigned int min, unsigned int max)
{
	unsigned long num;
	int ret;

	if (!val)
		return -EINVAL;
	ret = strict_strtoul(val, 0, &num);
	if (ret == -EINVAL || num < min || num > max)
		return -EINVAL;
	*((unsigned int *)kp->arg) = num;
	return 0;
}

static int param_set_portnr(const char *val, struct kernel_param *kp)
{
	return param_set_uint_minmax(val, kp,
			RPC_MIN_RESVPORT,
			RPC_MAX_RESVPORT);
}

static int param_get_portnr(char *buffer, struct kernel_param *kp)
{
	return param_get_uint(buffer, kp);
}
#define param_check_portnr(name, p) \
	__param_check(name, p, unsigned int);

module_param_named(min_resvport, xprt_min_resvport, portnr, 0644);
module_param_named(max_resvport, xprt_max_resvport, portnr, 0644);

static int param_set_slot_table_size(const char *val, struct kernel_param *kp)
{
	return param_set_uint_minmax(val, kp,
			RPC_MIN_SLOT_TABLE,
			RPC_MAX_SLOT_TABLE);
}

static int param_get_slot_table_size(char *buffer, struct kernel_param *kp)
{
	return param_get_uint(buffer, kp);
}
#define param_check_slot_table_size(name, p) \
	__param_check(name, p, unsigned int);

module_param_named(tcp_slot_table_entries, xprt_tcp_slot_table_entries,
		   slot_table_size, 0644);
module_param_named(udp_slot_table_entries, xprt_udp_slot_table_entries,
		   slot_table_size, 0644);