xprtsock.c (dea034b963c8901bdcc3d3880c04f0d75c95112f) xprtsock.c (75eb6af7acdf566c68d61e98e67ee2f235201c02)
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * linux/net/sunrpc/xprtsock.c
4 *
5 * Client-side transport implementation for sockets.
6 *
7 * TCP callback races fixes (C) 1998 Red Hat
8 * TCP send fixes (C) 1998 Red Hat

--- 34 unchanged lines hidden (view full) ---

43#include <linux/sunrpc/bc_xprt.h>
44#endif
45
46#include <net/sock.h>
47#include <net/checksum.h>
48#include <net/udp.h>
49#include <net/tcp.h>
50#include <net/tls.h>
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * linux/net/sunrpc/xprtsock.c
4 *
5 * Client-side transport implementation for sockets.
6 *
7 * TCP callback races fixes (C) 1998 Red Hat
8 * TCP send fixes (C) 1998 Red Hat

--- 34 unchanged lines hidden (view full) ---

43#include <linux/sunrpc/bc_xprt.h>
44#endif
45
46#include <net/sock.h>
47#include <net/checksum.h>
48#include <net/udp.h>
49#include <net/tcp.h>
50#include <net/tls.h>
51#include <net/handshake.h>
51
52#include <linux/bvec.h>
53#include <linux/highmem.h>
54#include <linux/uio.h>
55#include <linux/sched/mm.h>
56
57#include <trace/events/sock.h>
58#include <trace/events/sunrpc.h>

--- 34 unchanged lines hidden (view full) ---

93static unsigned int xprt_min_resvport_limit = RPC_MIN_RESVPORT;
94static unsigned int xprt_max_resvport_limit = RPC_MAX_RESVPORT;
95
96static struct ctl_table_header *sunrpc_table_header;
97
98static struct xprt_class xs_local_transport;
99static struct xprt_class xs_udp_transport;
100static struct xprt_class xs_tcp_transport;
52
53#include <linux/bvec.h>
54#include <linux/highmem.h>
55#include <linux/uio.h>
56#include <linux/sched/mm.h>
57
58#include <trace/events/sock.h>
59#include <trace/events/sunrpc.h>

--- 34 unchanged lines hidden (view full) ---

94static unsigned int xprt_min_resvport_limit = RPC_MIN_RESVPORT;
95static unsigned int xprt_max_resvport_limit = RPC_MAX_RESVPORT;
96
97static struct ctl_table_header *sunrpc_table_header;
98
99static struct xprt_class xs_local_transport;
100static struct xprt_class xs_udp_transport;
101static struct xprt_class xs_tcp_transport;
102static struct xprt_class xs_tcp_tls_transport;
101static struct xprt_class xs_bc_tcp_transport;
102
103/*
104 * FIXME: changing the UDP slot table size should also resize the UDP
105 * socket buffers for existing UDP transports
106 */
107static struct ctl_table xs_tunables_table[] = {
108 {

--- 75 unchanged lines hidden (view full) ---

184
185/*
186 * TCP idle timeout; client drops the transport socket if it is idle
187 * for this long. Note that we also timeout UDP sockets to prevent
188 * holding port numbers when there is no RPC traffic.
189 */
190#define XS_IDLE_DISC_TO (5U * 60 * HZ)
191
103static struct xprt_class xs_bc_tcp_transport;
104
105/*
106 * FIXME: changing the UDP slot table size should also resize the UDP
107 * socket buffers for existing UDP transports
108 */
109static struct ctl_table xs_tunables_table[] = {
110 {

--- 75 unchanged lines hidden (view full) ---

186
187/*
188 * TCP idle timeout; client drops the transport socket if it is idle
189 * for this long. Note that we also timeout UDP sockets to prevent
190 * holding port numbers when there is no RPC traffic.
191 */
192#define XS_IDLE_DISC_TO (5U * 60 * HZ)
193
194/*
195 * TLS handshake timeout.
196 */
197#define XS_TLS_HANDSHAKE_TO (10U * HZ)
198
192#if IS_ENABLED(CONFIG_SUNRPC_DEBUG)
193# undef RPC_DEBUG_DATA
194# define RPCDBG_FACILITY RPCDBG_TRANS
195#endif
196
197#ifdef RPC_DEBUG_DATA
198static void xs_pktdump(char *msg, u32 *packet, unsigned int count)
199{

--- 1038 unchanged lines hidden (view full) ---

1238 WARN_ON_ONCE(1);
1239 set_bit(XPRT_CLOSE_WAIT, &xprt->state);
1240 return;
1241 }
1242
1243 if (atomic_read(&transport->xprt.swapper))
1244 sk_clear_memalloc(sk);
1245
199#if IS_ENABLED(CONFIG_SUNRPC_DEBUG)
200# undef RPC_DEBUG_DATA
201# define RPCDBG_FACILITY RPCDBG_TRANS
202#endif
203
204#ifdef RPC_DEBUG_DATA
205static void xs_pktdump(char *msg, u32 *packet, unsigned int count)
206{

--- 1038 unchanged lines hidden (view full) ---

1245 WARN_ON_ONCE(1);
1246 set_bit(XPRT_CLOSE_WAIT, &xprt->state);
1247 return;
1248 }
1249
1250 if (atomic_read(&transport->xprt.swapper))
1251 sk_clear_memalloc(sk);
1252
1253 tls_handshake_cancel(sk);
1254
1246 kernel_sock_shutdown(sock, SHUT_RDWR);
1247
1248 mutex_lock(&transport->recv_mutex);
1249 lock_sock(sk);
1250 transport->inet = NULL;
1251 transport->sock = NULL;
1252 transport->file = NULL;
1253

--- 1157 unchanged lines hidden (view full) ---

2411 xs_tcp_force_close(xprt);
2412out:
2413 xprt_clear_connecting(xprt);
2414out_unlock:
2415 xprt_unlock_connect(xprt, transport);
2416 current_restore_flags(pflags, PF_MEMALLOC);
2417}
2418
1255 kernel_sock_shutdown(sock, SHUT_RDWR);
1256
1257 mutex_lock(&transport->recv_mutex);
1258 lock_sock(sk);
1259 transport->inet = NULL;
1260 transport->sock = NULL;
1261 transport->file = NULL;
1262

--- 1157 unchanged lines hidden (view full) ---

2420 xs_tcp_force_close(xprt);
2421out:
2422 xprt_clear_connecting(xprt);
2423out_unlock:
2424 xprt_unlock_connect(xprt, transport);
2425 current_restore_flags(pflags, PF_MEMALLOC);
2426}
2427
2428/*
2429 * Transfer the connected socket to @upper_transport, then mark that
2430 * xprt CONNECTED.
2431 */
2432static int xs_tcp_tls_finish_connecting(struct rpc_xprt *lower_xprt,
2433 struct sock_xprt *upper_transport)
2434{
2435 struct sock_xprt *lower_transport =
2436 container_of(lower_xprt, struct sock_xprt, xprt);
2437 struct rpc_xprt *upper_xprt = &upper_transport->xprt;
2438
2439 if (!upper_transport->inet) {
2440 struct socket *sock = lower_transport->sock;
2441 struct sock *sk = sock->sk;
2442
2443 /* Avoid temporary address, they are bad for long-lived
2444 * connections such as NFS mounts.
2445 * RFC4941, section 3.6 suggests that:
2446 * Individual applications, which have specific
2447 * knowledge about the normal duration of connections,
2448 * MAY override this as appropriate.
2449 */
2450 if (xs_addr(upper_xprt)->sa_family == PF_INET6)
2451 ip6_sock_set_addr_preferences(sk, IPV6_PREFER_SRC_PUBLIC);
2452
2453 xs_tcp_set_socket_timeouts(upper_xprt, sock);
2454 tcp_sock_set_nodelay(sk);
2455
2456 lock_sock(sk);
2457
2458 /* @sk is already connected, so it now has the RPC callbacks.
2459 * Reach into @lower_transport to save the original ones.
2460 */
2461 upper_transport->old_data_ready = lower_transport->old_data_ready;
2462 upper_transport->old_state_change = lower_transport->old_state_change;
2463 upper_transport->old_write_space = lower_transport->old_write_space;
2464 upper_transport->old_error_report = lower_transport->old_error_report;
2465 sk->sk_user_data = upper_xprt;
2466
2467 /* socket options */
2468 sock_reset_flag(sk, SOCK_LINGER);
2469
2470 xprt_clear_connected(upper_xprt);
2471
2472 upper_transport->sock = sock;
2473 upper_transport->inet = sk;
2474 upper_transport->file = lower_transport->file;
2475
2476 release_sock(sk);
2477
2478 /* Reset lower_transport before shutting down its clnt */
2479 mutex_lock(&lower_transport->recv_mutex);
2480 lower_transport->inet = NULL;
2481 lower_transport->sock = NULL;
2482 lower_transport->file = NULL;
2483
2484 xprt_clear_connected(lower_xprt);
2485 xs_sock_reset_connection_flags(lower_xprt);
2486 xs_stream_reset_connect(lower_transport);
2487 mutex_unlock(&lower_transport->recv_mutex);
2488 }
2489
2490 if (!xprt_bound(upper_xprt))
2491 return -ENOTCONN;
2492
2493 xs_set_memalloc(upper_xprt);
2494
2495 if (!xprt_test_and_set_connected(upper_xprt)) {
2496 upper_xprt->connect_cookie++;
2497 clear_bit(XPRT_SOCK_CONNECTING, &upper_transport->sock_state);
2498 xprt_clear_connecting(upper_xprt);
2499
2500 upper_xprt->stat.connect_count++;
2501 upper_xprt->stat.connect_time += (long)jiffies -
2502 upper_xprt->stat.connect_start;
2503 xs_run_error_worker(upper_transport, XPRT_SOCK_WAKE_PENDING);
2504 }
2505 return 0;
2506}
2507
2419/**
2508/**
2509 * xs_tls_handshake_done - TLS handshake completion handler
2510 * @data: address of xprt to wake
2511 * @status: status of handshake
2512 * @peerid: serial number of key containing the remote's identity
2513 *
2514 */
2515static void xs_tls_handshake_done(void *data, int status, key_serial_t peerid)
2516{
2517 struct rpc_xprt *lower_xprt = data;
2518 struct sock_xprt *lower_transport =
2519 container_of(lower_xprt, struct sock_xprt, xprt);
2520
2521 lower_transport->xprt_err = status ? -EACCES : 0;
2522 complete(&lower_transport->handshake_done);
2523 xprt_put(lower_xprt);
2524}
2525
2526static int xs_tls_handshake_sync(struct rpc_xprt *lower_xprt, struct xprtsec_parms *xprtsec)
2527{
2528 struct sock_xprt *lower_transport =
2529 container_of(lower_xprt, struct sock_xprt, xprt);
2530 struct tls_handshake_args args = {
2531 .ta_sock = lower_transport->sock,
2532 .ta_done = xs_tls_handshake_done,
2533 .ta_data = xprt_get(lower_xprt),
2534 .ta_peername = lower_xprt->servername,
2535 };
2536 struct sock *sk = lower_transport->inet;
2537 int rc;
2538
2539 init_completion(&lower_transport->handshake_done);
2540 set_bit(XPRT_SOCK_IGNORE_RECV, &lower_transport->sock_state);
2541 lower_transport->xprt_err = -ETIMEDOUT;
2542 switch (xprtsec->policy) {
2543 case RPC_XPRTSEC_TLS_ANON:
2544 rc = tls_client_hello_anon(&args, GFP_KERNEL);
2545 if (rc)
2546 goto out_put_xprt;
2547 break;
2548 case RPC_XPRTSEC_TLS_X509:
2549 args.ta_my_cert = xprtsec->cert_serial;
2550 args.ta_my_privkey = xprtsec->privkey_serial;
2551 rc = tls_client_hello_x509(&args, GFP_KERNEL);
2552 if (rc)
2553 goto out_put_xprt;
2554 break;
2555 default:
2556 rc = -EACCES;
2557 goto out_put_xprt;
2558 }
2559
2560 rc = wait_for_completion_interruptible_timeout(&lower_transport->handshake_done,
2561 XS_TLS_HANDSHAKE_TO);
2562 if (rc <= 0) {
2563 if (!tls_handshake_cancel(sk)) {
2564 if (rc == 0)
2565 rc = -ETIMEDOUT;
2566 goto out_put_xprt;
2567 }
2568 }
2569
2570 rc = lower_transport->xprt_err;
2571
2572out:
2573 xs_stream_reset_connect(lower_transport);
2574 clear_bit(XPRT_SOCK_IGNORE_RECV, &lower_transport->sock_state);
2575 return rc;
2576
2577out_put_xprt:
2578 xprt_put(lower_xprt);
2579 goto out;
2580}
2581
2582/**
2583 * xs_tcp_tls_setup_socket - establish a TLS session on a TCP socket
2584 * @work: queued work item
2585 *
2586 * Invoked by a work queue tasklet.
2587 *
2588 * For RPC-with-TLS, there is a two-stage connection process.
2589 *
2590 * The "upper-layer xprt" is visible to the RPC consumer. Once it has
2591 * been marked connected, the consumer knows that a TCP connection and
2592 * a TLS session have been established.
2593 *
2594 * A "lower-layer xprt", created in this function, handles the mechanics
2595 * of connecting the TCP socket, performing the RPC_AUTH_TLS probe, and
2596 * then driving the TLS handshake. Once all that is complete, the upper
2597 * layer xprt is marked connected.
2598 */
2599static void xs_tcp_tls_setup_socket(struct work_struct *work)
2600{
2601 struct sock_xprt *upper_transport =
2602 container_of(work, struct sock_xprt, connect_worker.work);
2603 struct rpc_clnt *upper_clnt = upper_transport->clnt;
2604 struct rpc_xprt *upper_xprt = &upper_transport->xprt;
2605 struct rpc_create_args args = {
2606 .net = upper_xprt->xprt_net,
2607 .protocol = upper_xprt->prot,
2608 .address = (struct sockaddr *)&upper_xprt->addr,
2609 .addrsize = upper_xprt->addrlen,
2610 .timeout = upper_clnt->cl_timeout,
2611 .servername = upper_xprt->servername,
2612 .program = upper_clnt->cl_program,
2613 .prognumber = upper_clnt->cl_prog,
2614 .version = upper_clnt->cl_vers,
2615 .authflavor = RPC_AUTH_TLS,
2616 .cred = upper_clnt->cl_cred,
2617 .xprtsec = {
2618 .policy = RPC_XPRTSEC_NONE,
2619 },
2620 };
2621 unsigned int pflags = current->flags;
2622 struct rpc_clnt *lower_clnt;
2623 struct rpc_xprt *lower_xprt;
2624 int status;
2625
2626 if (atomic_read(&upper_xprt->swapper))
2627 current->flags |= PF_MEMALLOC;
2628
2629 xs_stream_start_connect(upper_transport);
2630
2631 /* This implicitly sends an RPC_AUTH_TLS probe */
2632 lower_clnt = rpc_create(&args);
2633 if (IS_ERR(lower_clnt)) {
2634 trace_rpc_tls_unavailable(upper_clnt, upper_xprt);
2635 clear_bit(XPRT_SOCK_CONNECTING, &upper_transport->sock_state);
2636 xprt_clear_connecting(upper_xprt);
2637 xprt_wake_pending_tasks(upper_xprt, PTR_ERR(lower_clnt));
2638 xs_run_error_worker(upper_transport, XPRT_SOCK_WAKE_PENDING);
2639 goto out_unlock;
2640 }
2641
2642 /* RPC_AUTH_TLS probe was successful. Try a TLS handshake on
2643 * the lower xprt.
2644 */
2645 rcu_read_lock();
2646 lower_xprt = rcu_dereference(lower_clnt->cl_xprt);
2647 rcu_read_unlock();
2648 status = xs_tls_handshake_sync(lower_xprt, &upper_xprt->xprtsec);
2649 if (status) {
2650 trace_rpc_tls_not_started(upper_clnt, upper_xprt);
2651 goto out_close;
2652 }
2653
2654 status = xs_tcp_tls_finish_connecting(lower_xprt, upper_transport);
2655 if (status)
2656 goto out_close;
2657
2658 trace_rpc_socket_connect(upper_xprt, upper_transport->sock, 0);
2659 if (!xprt_test_and_set_connected(upper_xprt)) {
2660 upper_xprt->connect_cookie++;
2661 clear_bit(XPRT_SOCK_CONNECTING, &upper_transport->sock_state);
2662 xprt_clear_connecting(upper_xprt);
2663
2664 upper_xprt->stat.connect_count++;
2665 upper_xprt->stat.connect_time += (long)jiffies -
2666 upper_xprt->stat.connect_start;
2667 xs_run_error_worker(upper_transport, XPRT_SOCK_WAKE_PENDING);
2668 }
2669 rpc_shutdown_client(lower_clnt);
2670
2671out_unlock:
2672 current_restore_flags(pflags, PF_MEMALLOC);
2673 upper_transport->clnt = NULL;
2674 xprt_unlock_connect(upper_xprt, upper_transport);
2675 return;
2676
2677out_close:
2678 rpc_shutdown_client(lower_clnt);
2679
2680 /* xprt_force_disconnect() wakes tasks with a fixed tk_status code.
2681 * Wake them first here to ensure they get our tk_status code.
2682 */
2683 xprt_wake_pending_tasks(upper_xprt, status);
2684 xs_tcp_force_close(upper_xprt);
2685 xprt_clear_connecting(upper_xprt);
2686 goto out_unlock;
2687}
2688
2689/**
2420 * xs_connect - connect a socket to a remote endpoint
2421 * @xprt: pointer to transport structure
2422 * @task: address of RPC task that manages state of connect request
2423 *
2424 * TCP: If the remote end dropped the connection, delay reconnecting.
2425 *
2426 * UDP socket connects are synchronous, but we use a work queue anyway
2427 * to guarantee that even unprivileged user processes can set up a

--- 14 unchanged lines hidden (view full) ---

2442 "seconds\n", xprt, xprt->reestablish_timeout / HZ);
2443
2444 delay = xprt_reconnect_delay(xprt);
2445 xprt_reconnect_backoff(xprt, XS_TCP_INIT_REEST_TO);
2446
2447 } else
2448 dprintk("RPC: xs_connect scheduled xprt %p\n", xprt);
2449
2690 * xs_connect - connect a socket to a remote endpoint
2691 * @xprt: pointer to transport structure
2692 * @task: address of RPC task that manages state of connect request
2693 *
2694 * TCP: If the remote end dropped the connection, delay reconnecting.
2695 *
2696 * UDP socket connects are synchronous, but we use a work queue anyway
2697 * to guarantee that even unprivileged user processes can set up a

--- 14 unchanged lines hidden (view full) ---

2712 "seconds\n", xprt, xprt->reestablish_timeout / HZ);
2713
2714 delay = xprt_reconnect_delay(xprt);
2715 xprt_reconnect_backoff(xprt, XS_TCP_INIT_REEST_TO);
2716
2717 } else
2718 dprintk("RPC: xs_connect scheduled xprt %p\n", xprt);
2719
2720 transport->clnt = task->tk_client;
2450 queue_delayed_work(xprtiod_workqueue,
2451 &transport->connect_worker,
2452 delay);
2453}
2454
2455static void xs_wake_disconnect(struct sock_xprt *transport)
2456{
2457 if (test_and_clear_bit(XPRT_SOCK_WAKE_DISCONNECT, &transport->sock_state))

--- 638 unchanged lines hidden (view full) ---

3096 return xprt;
3097 ret = ERR_PTR(-EINVAL);
3098out_err:
3099 xs_xprt_free(xprt);
3100 return ret;
3101}
3102
3103/**
2721 queue_delayed_work(xprtiod_workqueue,
2722 &transport->connect_worker,
2723 delay);
2724}
2725
2726static void xs_wake_disconnect(struct sock_xprt *transport)
2727{
2728 if (test_and_clear_bit(XPRT_SOCK_WAKE_DISCONNECT, &transport->sock_state))

--- 638 unchanged lines hidden (view full) ---

3367 return xprt;
3368 ret = ERR_PTR(-EINVAL);
3369out_err:
3370 xs_xprt_free(xprt);
3371 return ret;
3372}
3373
3374/**
3375 * xs_setup_tcp_tls - Set up transport to use a TCP with TLS
3376 * @args: rpc transport creation arguments
3377 *
3378 */
3379static struct rpc_xprt *xs_setup_tcp_tls(struct xprt_create *args)
3380{
3381 struct sockaddr *addr = args->dstaddr;
3382 struct rpc_xprt *xprt;
3383 struct sock_xprt *transport;
3384 struct rpc_xprt *ret;
3385 unsigned int max_slot_table_size = xprt_max_tcp_slot_table_entries;
3386
3387 if (args->flags & XPRT_CREATE_INFINITE_SLOTS)
3388 max_slot_table_size = RPC_MAX_SLOT_TABLE_LIMIT;
3389
3390 xprt = xs_setup_xprt(args, xprt_tcp_slot_table_entries,
3391 max_slot_table_size);
3392 if (IS_ERR(xprt))
3393 return xprt;
3394 transport = container_of(xprt, struct sock_xprt, xprt);
3395
3396 xprt->prot = IPPROTO_TCP;
3397 xprt->xprt_class = &xs_tcp_transport;
3398 xprt->max_payload = RPC_MAX_FRAGMENT_SIZE;
3399
3400 xprt->bind_timeout = XS_BIND_TO;
3401 xprt->reestablish_timeout = XS_TCP_INIT_REEST_TO;
3402 xprt->idle_timeout = XS_IDLE_DISC_TO;
3403
3404 xprt->ops = &xs_tcp_ops;
3405 xprt->timeout = &xs_tcp_default_timeout;
3406
3407 xprt->max_reconnect_timeout = xprt->timeout->to_maxval;
3408 xprt->connect_timeout = xprt->timeout->to_initval *
3409 (xprt->timeout->to_retries + 1);
3410
3411 INIT_WORK(&transport->recv_worker, xs_stream_data_receive_workfn);
3412 INIT_WORK(&transport->error_worker, xs_error_handle);
3413
3414 switch (args->xprtsec.policy) {
3415 case RPC_XPRTSEC_TLS_ANON:
3416 case RPC_XPRTSEC_TLS_X509:
3417 xprt->xprtsec = args->xprtsec;
3418 INIT_DELAYED_WORK(&transport->connect_worker,
3419 xs_tcp_tls_setup_socket);
3420 break;
3421 default:
3422 ret = ERR_PTR(-EACCES);
3423 goto out_err;
3424 }
3425
3426 switch (addr->sa_family) {
3427 case AF_INET:
3428 if (((struct sockaddr_in *)addr)->sin_port != htons(0))
3429 xprt_set_bound(xprt);
3430
3431 xs_format_peer_addresses(xprt, "tcp", RPCBIND_NETID_TCP);
3432 break;
3433 case AF_INET6:
3434 if (((struct sockaddr_in6 *)addr)->sin6_port != htons(0))
3435 xprt_set_bound(xprt);
3436
3437 xs_format_peer_addresses(xprt, "tcp", RPCBIND_NETID_TCP6);
3438 break;
3439 default:
3440 ret = ERR_PTR(-EAFNOSUPPORT);
3441 goto out_err;
3442 }
3443
3444 if (xprt_bound(xprt))
3445 dprintk("RPC: set up xprt to %s (port %s) via %s\n",
3446 xprt->address_strings[RPC_DISPLAY_ADDR],
3447 xprt->address_strings[RPC_DISPLAY_PORT],
3448 xprt->address_strings[RPC_DISPLAY_PROTO]);
3449 else
3450 dprintk("RPC: set up xprt to %s (autobind) via %s\n",
3451 xprt->address_strings[RPC_DISPLAY_ADDR],
3452 xprt->address_strings[RPC_DISPLAY_PROTO]);
3453
3454 if (try_module_get(THIS_MODULE))
3455 return xprt;
3456 ret = ERR_PTR(-EINVAL);
3457out_err:
3458 xs_xprt_free(xprt);
3459 return ret;
3460}
3461
3462/**
3104 * xs_setup_bc_tcp - Set up transport to use a TCP backchannel socket
3105 * @args: rpc transport creation arguments
3106 *
3107 */
3108static struct rpc_xprt *xs_setup_bc_tcp(struct xprt_create *args)
3109{
3110 struct sockaddr *addr = args->dstaddr;
3111 struct rpc_xprt *xprt;

--- 92 unchanged lines hidden (view full) ---

3204 .list = LIST_HEAD_INIT(xs_tcp_transport.list),
3205 .name = "tcp",
3206 .owner = THIS_MODULE,
3207 .ident = XPRT_TRANSPORT_TCP,
3208 .setup = xs_setup_tcp,
3209 .netid = { "tcp", "tcp6", "" },
3210};
3211
3463 * xs_setup_bc_tcp - Set up transport to use a TCP backchannel socket
3464 * @args: rpc transport creation arguments
3465 *
3466 */
3467static struct rpc_xprt *xs_setup_bc_tcp(struct xprt_create *args)
3468{
3469 struct sockaddr *addr = args->dstaddr;
3470 struct rpc_xprt *xprt;

--- 92 unchanged lines hidden (view full) ---

3563 .list = LIST_HEAD_INIT(xs_tcp_transport.list),
3564 .name = "tcp",
3565 .owner = THIS_MODULE,
3566 .ident = XPRT_TRANSPORT_TCP,
3567 .setup = xs_setup_tcp,
3568 .netid = { "tcp", "tcp6", "" },
3569};
3570
3571static struct xprt_class xs_tcp_tls_transport = {
3572 .list = LIST_HEAD_INIT(xs_tcp_tls_transport.list),
3573 .name = "tcp-with-tls",
3574 .owner = THIS_MODULE,
3575 .ident = XPRT_TRANSPORT_TCP_TLS,
3576 .setup = xs_setup_tcp_tls,
3577 .netid = { "tcp", "tcp6", "" },
3578};
3579
3212static struct xprt_class xs_bc_tcp_transport = {
3213 .list = LIST_HEAD_INIT(xs_bc_tcp_transport.list),
3214 .name = "tcp NFSv4.1 backchannel",
3215 .owner = THIS_MODULE,
3216 .ident = XPRT_TRANSPORT_BC_TCP,
3217 .setup = xs_setup_bc_tcp,
3218 .netid = { "" },
3219};

--- 5 unchanged lines hidden (view full) ---

3225int init_socket_xprt(void)
3226{
3227 if (!sunrpc_table_header)
3228 sunrpc_table_header = register_sysctl("sunrpc", xs_tunables_table);
3229
3230 xprt_register_transport(&xs_local_transport);
3231 xprt_register_transport(&xs_udp_transport);
3232 xprt_register_transport(&xs_tcp_transport);
3580static struct xprt_class xs_bc_tcp_transport = {
3581 .list = LIST_HEAD_INIT(xs_bc_tcp_transport.list),
3582 .name = "tcp NFSv4.1 backchannel",
3583 .owner = THIS_MODULE,
3584 .ident = XPRT_TRANSPORT_BC_TCP,
3585 .setup = xs_setup_bc_tcp,
3586 .netid = { "" },
3587};

--- 5 unchanged lines hidden (view full) ---

3593int init_socket_xprt(void)
3594{
3595 if (!sunrpc_table_header)
3596 sunrpc_table_header = register_sysctl("sunrpc", xs_tunables_table);
3597
3598 xprt_register_transport(&xs_local_transport);
3599 xprt_register_transport(&xs_udp_transport);
3600 xprt_register_transport(&xs_tcp_transport);
3601 xprt_register_transport(&xs_tcp_tls_transport);
3233 xprt_register_transport(&xs_bc_tcp_transport);
3234
3235 return 0;
3236}
3237
3238/**
3239 * cleanup_socket_xprt - remove xprtsock's sysctls, unregister
3240 *
3241 */
3242void cleanup_socket_xprt(void)
3243{
3244 if (sunrpc_table_header) {
3245 unregister_sysctl_table(sunrpc_table_header);
3246 sunrpc_table_header = NULL;
3247 }
3248
3249 xprt_unregister_transport(&xs_local_transport);
3250 xprt_unregister_transport(&xs_udp_transport);
3251 xprt_unregister_transport(&xs_tcp_transport);
3602 xprt_register_transport(&xs_bc_tcp_transport);
3603
3604 return 0;
3605}
3606
3607/**
3608 * cleanup_socket_xprt - remove xprtsock's sysctls, unregister
3609 *
3610 */
3611void cleanup_socket_xprt(void)
3612{
3613 if (sunrpc_table_header) {
3614 unregister_sysctl_table(sunrpc_table_header);
3615 sunrpc_table_header = NULL;
3616 }
3617
3618 xprt_unregister_transport(&xs_local_transport);
3619 xprt_unregister_transport(&xs_udp_transport);
3620 xprt_unregister_transport(&xs_tcp_transport);
3621 xprt_unregister_transport(&xs_tcp_tls_transport);
3252 xprt_unregister_transport(&xs_bc_tcp_transport);
3253}
3254
3255static int param_set_portnr(const char *val, const struct kernel_param *kp)
3256{
3257 return param_set_uint_minmax(val, kp,
3258 RPC_MIN_RESVPORT,
3259 RPC_MAX_RESVPORT);

--- 51 unchanged lines hidden --- 		3622 xprt_unregister_transport(&xs_bc_tcp_transport);
3623}
3624
3625static int param_set_portnr(const char *val, const struct kernel_param *kp)
3626{
3627 return param_set_uint_minmax(val, kp,
3628 RPC_MIN_RESVPORT,
3629 RPC_MAX_RESVPORT);

--- 51 unchanged lines hidden ---