af_rxrpc.c

   1// SPDX-License-Identifier: GPL-2.0-or-later
   2/* AF_RXRPC implementation
   3 *
   4 * Copyright (C) 2007 Red Hat, Inc. All Rights Reserved.
   5 * Written by David Howells (dhowells@redhat.com)
   6 */
   7
   8#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
   9
  10#include <linux/module.h>
  11#include <linux/kernel.h>
  12#include <linux/net.h>
  13#include <linux/slab.h>
  14#include <linux/skbuff.h>
  15#include <linux/random.h>
  16#include <linux/poll.h>
  17#include <linux/proc_fs.h>
  18#include <linux/key-type.h>
  19#include <net/net_namespace.h>
  20#include <net/sock.h>
  21#include <net/af_rxrpc.h>
  22#define CREATE_TRACE_POINTS
  23#include "ar-internal.h"
  24
  25MODULE_DESCRIPTION("RxRPC network protocol");
  26MODULE_AUTHOR("Red Hat, Inc.");
  27MODULE_LICENSE("GPL");
  28MODULE_ALIAS_NETPROTO(PF_RXRPC);
  29
  30unsigned int rxrpc_debug; // = RXRPC_DEBUG_KPROTO;
  31module_param_named(debug, rxrpc_debug, uint, 0644);
  32MODULE_PARM_DESC(debug, "RxRPC debugging mask");
  33
  34static struct proto rxrpc_proto;
  35static const struct proto_ops rxrpc_rpc_ops;
  36
  37/* current debugging ID */
  38atomic_t rxrpc_debug_id;
  39EXPORT_SYMBOL(rxrpc_debug_id);
  40
  41/* count of skbs currently in use */
  42atomic_t rxrpc_n_rx_skbs;
  43
  44struct workqueue_struct *rxrpc_workqueue;
  45
  46static void rxrpc_sock_destructor(struct sock *);
  47
  48/*
  49 * see if an RxRPC socket is currently writable
  50 */
  51static inline int rxrpc_writable(struct sock *sk)
  52{
  53	return refcount_read(&sk->sk_wmem_alloc) < (size_t) sk->sk_sndbuf;
  54}
  55
  56/*
  57 * wait for write bufferage to become available
  58 */
  59static void rxrpc_write_space(struct sock *sk)
  60{
  61	_enter("%p", sk);
  62	rcu_read_lock();
  63	if (rxrpc_writable(sk)) {
  64		struct socket_wq *wq = rcu_dereference(sk->sk_wq);
  65
  66		if (skwq_has_sleeper(wq))
  67			wake_up_interruptible(&wq->wait);
  68		sk_wake_async_rcu(sk, SOCK_WAKE_SPACE, POLL_OUT);
  69	}
  70	rcu_read_unlock();
  71}
  72
  73/*
  74 * validate an RxRPC address
  75 */
  76static int rxrpc_validate_address(struct rxrpc_sock *rx,
  77				  struct sockaddr_rxrpc *srx,
  78				  int len)
  79{
  80	unsigned int tail;
  81
  82	if (len < sizeof(struct sockaddr_rxrpc))
  83		return -EINVAL;
  84
  85	if (srx->srx_family != AF_RXRPC)
  86		return -EAFNOSUPPORT;
  87
  88	if (srx->transport_type != SOCK_DGRAM)
  89		return -ESOCKTNOSUPPORT;
  90
  91	len -= offsetof(struct sockaddr_rxrpc, transport);
  92	if (srx->transport_len < sizeof(sa_family_t) ||
  93	    srx->transport_len > len)
  94		return -EINVAL;
  95
  96	switch (srx->transport.family) {
  97	case AF_INET:
  98		if (rx->family != AF_INET &&
  99		    rx->family != AF_INET6)
 100			return -EAFNOSUPPORT;
 101		if (srx->transport_len < sizeof(struct sockaddr_in))
 102			return -EINVAL;
 103		tail = offsetof(struct sockaddr_rxrpc, transport.sin.__pad);
 104		break;
 105
 106#ifdef CONFIG_AF_RXRPC_IPV6
 107	case AF_INET6:
 108		if (rx->family != AF_INET6)
 109			return -EAFNOSUPPORT;
 110		if (srx->transport_len < sizeof(struct sockaddr_in6))
 111			return -EINVAL;
 112		tail = offsetof(struct sockaddr_rxrpc, transport) +
 113			sizeof(struct sockaddr_in6);
 114		break;
 115#endif
 116
 117	default:
 118		return -EAFNOSUPPORT;
 119	}
 120
 121	if (tail < len)
 122		memset((void *)srx + tail, 0, len - tail);
 123	_debug("INET: %pISp", &srx->transport);
 124	return 0;
 125}
 126
 127/*
 128 * bind a local address to an RxRPC socket
 129 */
 130static int rxrpc_bind(struct socket *sock, struct sockaddr_unsized *saddr, int len)
 131{
 132	struct sockaddr_rxrpc *srx = (struct sockaddr_rxrpc *)saddr;
 133	struct rxrpc_local *local;
 134	struct rxrpc_sock *rx = rxrpc_sk(sock->sk);
 135	u16 service_id;
 136	int ret;
 137
 138	_enter("%p,%p,%d", rx, saddr, len);
 139
 140	ret = rxrpc_validate_address(rx, srx, len);
 141	if (ret < 0)
 142		goto error;
 143	service_id = srx->srx_service;
 144
 145	lock_sock(&rx->sk);
 146
 147	switch (rx->sk.sk_state) {
 148	case RXRPC_UNBOUND:
 149		rx->srx = *srx;
 150		local = rxrpc_lookup_local(sock_net(&rx->sk), &rx->srx);
 151		if (IS_ERR(local)) {
 152			ret = PTR_ERR(local);
 153			goto error_unlock;
 154		}
 155
 156		if (service_id) {
 157			write_lock(&local->services_lock);
 158			if (local->service)
 159				goto service_in_use;
 160			rx->local = local;
 161			local->service = rx;
 162			write_unlock(&local->services_lock);
 163
 164			rx->sk.sk_state = RXRPC_SERVER_BOUND;
 165		} else {
 166			rx->local = local;
 167			rx->sk.sk_state = RXRPC_CLIENT_BOUND;
 168		}
 169		break;
 170
 171	case RXRPC_SERVER_BOUND:
 172		ret = -EINVAL;
 173		if (service_id == 0)
 174			goto error_unlock;
 175		ret = -EADDRINUSE;
 176		if (service_id == rx->srx.srx_service)
 177			goto error_unlock;
 178		ret = -EINVAL;
 179		srx->srx_service = rx->srx.srx_service;
 180		if (memcmp(srx, &rx->srx, sizeof(*srx)) != 0)
 181			goto error_unlock;
 182		rx->second_service = service_id;
 183		rx->sk.sk_state = RXRPC_SERVER_BOUND2;
 184		break;
 185
 186	default:
 187		ret = -EINVAL;
 188		goto error_unlock;
 189	}
 190
 191	release_sock(&rx->sk);
 192	_leave(" = 0");
 193	return 0;
 194
 195service_in_use:
 196	write_unlock(&local->services_lock);
 197	rxrpc_unuse_local(local, rxrpc_local_unuse_bind);
 198	rxrpc_put_local(local, rxrpc_local_put_bind);
 199	ret = -EADDRINUSE;
 200error_unlock:
 201	release_sock(&rx->sk);
 202error:
 203	_leave(" = %d", ret);
 204	return ret;
 205}
 206
 207/*
 208 * set the number of pending calls permitted on a listening socket
 209 */
 210static int rxrpc_listen(struct socket *sock, int backlog)
 211{
 212	struct sock *sk = sock->sk;
 213	struct rxrpc_sock *rx = rxrpc_sk(sk);
 214	unsigned int max, old;
 215	int ret;
 216
 217	_enter("%p,%d", rx, backlog);
 218
 219	lock_sock(&rx->sk);
 220
 221	switch (rx->sk.sk_state) {
 222	case RXRPC_UNBOUND:
 223		ret = -EADDRNOTAVAIL;
 224		break;
 225	case RXRPC_SERVER_BOUND:
 226	case RXRPC_SERVER_BOUND2:
 227		ASSERT(rx->local != NULL);
 228		max = READ_ONCE(rxrpc_max_backlog);
 229		ret = -EINVAL;
 230		if (backlog == INT_MAX)
 231			backlog = max;
 232		else if (backlog < 0 || backlog > max)
 233			break;
 234		old = sk->sk_max_ack_backlog;
 235		sk->sk_max_ack_backlog = backlog;
 236		ret = rxrpc_service_prealloc(rx, GFP_KERNEL);
 237		if (ret == 0)
 238			rx->sk.sk_state = RXRPC_SERVER_LISTENING;
 239		else
 240			sk->sk_max_ack_backlog = old;
 241		break;
 242	case RXRPC_SERVER_LISTENING:
 243		if (backlog == 0) {
 244			rx->sk.sk_state = RXRPC_SERVER_LISTEN_DISABLED;
 245			sk->sk_max_ack_backlog = 0;
 246			rxrpc_discard_prealloc(rx);
 247			ret = 0;
 248			break;
 249		}
 250		fallthrough;
 251	default:
 252		ret = -EBUSY;
 253		break;
 254	}
 255
 256	release_sock(&rx->sk);
 257	_leave(" = %d", ret);
 258	return ret;
 259}
 260
 261/**
 262 * rxrpc_kernel_lookup_peer - Obtain remote transport endpoint for an address
 263 * @sock: The socket through which it will be accessed
 264 * @srx: The network address
 265 * @gfp: Allocation flags
 266 *
 267 * Lookup or create a remote transport endpoint record for the specified
 268 * address.
 269 *
 270 * Return: The peer record found with a reference or a negative error code if
 271 * the address is invalid or unsupported.
 272 */
 273struct rxrpc_peer *rxrpc_kernel_lookup_peer(struct socket *sock,
 274					    struct sockaddr_rxrpc *srx, gfp_t gfp)
 275{
 276	struct rxrpc_peer *peer;
 277	struct rxrpc_sock *rx = rxrpc_sk(sock->sk);
 278	int ret;
 279
 280	ret = rxrpc_validate_address(rx, srx, sizeof(*srx));
 281	if (ret < 0)
 282		return ERR_PTR(ret);
 283
 284	peer = rxrpc_lookup_peer(rx->local, srx, gfp);
 285	return peer ?: ERR_PTR(-ENOMEM);
 286}
 287EXPORT_SYMBOL(rxrpc_kernel_lookup_peer);
 288
 289/**
 290 * rxrpc_kernel_get_peer - Get a reference on a peer
 291 * @peer: The peer to get a reference on (may be NULL).
 292 *
 293 * Get a reference for a remote peer record (if not NULL).
 294 *
 295 * Return: The @peer argument.
 296 */
 297struct rxrpc_peer *rxrpc_kernel_get_peer(struct rxrpc_peer *peer)
 298{
 299	return peer ? rxrpc_get_peer(peer, rxrpc_peer_get_application) : NULL;
 300}
 301EXPORT_SYMBOL(rxrpc_kernel_get_peer);
 302
 303/**
 304 * rxrpc_kernel_put_peer - Allow a kernel app to drop a peer reference
 305 * @peer: The peer to drop a ref on
 306 *
 307 * Drop a reference on a peer record.
 308 */
 309void rxrpc_kernel_put_peer(struct rxrpc_peer *peer)
 310{
 311	rxrpc_put_peer(peer, rxrpc_peer_put_application);
 312}
 313EXPORT_SYMBOL(rxrpc_kernel_put_peer);
 314
 315/**
 316 * rxrpc_kernel_begin_call - Allow a kernel service to begin a call
 317 * @sock: The socket on which to make the call
 318 * @peer: The peer to contact
 319 * @key: The security context to use (defaults to socket setting)
 320 * @user_call_ID: The ID to use
 321 * @tx_total_len: Total length of data to transmit during the call (or -1)
 322 * @hard_timeout: The maximum lifespan of the call in sec
 323 * @gfp: The allocation constraints
 324 * @notify_rx: Where to send notifications instead of socket queue
 325 * @service_id: The ID of the service to contact
 326 * @upgrade: Request service upgrade for call
 327 * @interruptibility: The call is interruptible, or can be canceled.
 328 * @debug_id: The debug ID for tracing to be assigned to the call
 329 *
 330 * Allow a kernel service to begin a call on the nominated socket.  This just
 331 * sets up all the internal tracking structures and allocates connection and
 332 * call IDs as appropriate.
 333 *
 334 * The default socket destination address and security may be overridden by
 335 * supplying @srx and @key.
 336 *
 337 * Return: The new call or an error code.
 338 */
 339struct rxrpc_call *rxrpc_kernel_begin_call(struct socket *sock,
 340					   struct rxrpc_peer *peer,
 341					   struct key *key,
 342					   unsigned long user_call_ID,
 343					   s64 tx_total_len,
 344					   u32 hard_timeout,
 345					   gfp_t gfp,
 346					   rxrpc_notify_rx_t notify_rx,
 347					   u16 service_id,
 348					   bool upgrade,
 349					   enum rxrpc_interruptibility interruptibility,
 350					   unsigned int debug_id)
 351{
 352	struct rxrpc_conn_parameters cp;
 353	struct rxrpc_call_params p;
 354	struct rxrpc_call *call;
 355	struct rxrpc_sock *rx = rxrpc_sk(sock->sk);
 356
 357	_enter(",,%x,%lx", key_serial(key), user_call_ID);
 358
 359	if (WARN_ON_ONCE(peer->local != rx->local))
 360		return ERR_PTR(-EIO);
 361
 362	lock_sock(&rx->sk);
 363
 364	if (!key)
 365		key = rx->key;
 366	if (key && !key->payload.data[0])
 367		key = NULL; /* a no-security key */
 368
 369	memset(&p, 0, sizeof(p));
 370	p.user_call_ID		= user_call_ID;
 371	p.tx_total_len		= tx_total_len;
 372	p.interruptibility	= interruptibility;
 373	p.kernel		= true;
 374	p.timeouts.hard		= hard_timeout;
 375
 376	memset(&cp, 0, sizeof(cp));
 377	cp.local		= rx->local;
 378	cp.peer			= peer;
 379	cp.key			= key;
 380	cp.security_level	= rx->min_sec_level;
 381	cp.exclusive		= false;
 382	cp.upgrade		= upgrade;
 383	cp.service_id		= service_id;
 384	call = rxrpc_new_client_call(rx, &cp, &p, gfp, debug_id);
 385	/* The socket has been unlocked. */
 386	if (!IS_ERR(call)) {
 387		call->notify_rx = notify_rx;
 388		mutex_unlock(&call->user_mutex);
 389	}
 390
 391	_leave(" = %p", call);
 392	return call;
 393}
 394EXPORT_SYMBOL(rxrpc_kernel_begin_call);
 395
 396/*
 397 * Dummy function used to stop the notifier talking to recvmsg().
 398 */
 399static void rxrpc_dummy_notify_rx(struct sock *sk, struct rxrpc_call *rxcall,
 400				  unsigned long call_user_ID)
 401{
 402}
 403
 404/**
 405 * rxrpc_kernel_shutdown_call - Allow a kernel service to shut down a call it was using
 406 * @sock: The socket the call is on
 407 * @call: The call to end
 408 *
 409 * Allow a kernel service to shut down a call it was using.  The call must be
 410 * complete before this is called (the call should be aborted if necessary).
 411 */
 412void rxrpc_kernel_shutdown_call(struct socket *sock, struct rxrpc_call *call)
 413{
 414	_enter("%d{%d}", call->debug_id, refcount_read(&call->ref));
 415
 416	mutex_lock(&call->user_mutex);
 417	if (!test_bit(RXRPC_CALL_RELEASED, &call->flags)) {
 418		rxrpc_release_call(rxrpc_sk(sock->sk), call);
 419
 420		/* Make sure we're not going to call back into a kernel service */
 421		if (call->notify_rx) {
 422			spin_lock_irq(&call->notify_lock);
 423			call->notify_rx = rxrpc_dummy_notify_rx;
 424			spin_unlock_irq(&call->notify_lock);
 425		}
 426	}
 427	mutex_unlock(&call->user_mutex);
 428}
 429EXPORT_SYMBOL(rxrpc_kernel_shutdown_call);
 430
 431/**
 432 * rxrpc_kernel_put_call - Release a reference to a call
 433 * @sock: The socket the call is on
 434 * @call: The call to put
 435 *
 436 * Drop the application's ref on an rxrpc call.
 437 */
 438void rxrpc_kernel_put_call(struct socket *sock, struct rxrpc_call *call)
 439{
 440	rxrpc_put_call(call, rxrpc_call_put_kernel);
 441}
 442EXPORT_SYMBOL(rxrpc_kernel_put_call);
 443
 444/**
 445 * rxrpc_kernel_check_life - Check to see whether a call is still alive
 446 * @sock: The socket the call is on
 447 * @call: The call to check
 448 *
 449 * Allow a kernel service to find out whether a call is still alive - whether
 450 * it has completed successfully and all received data has been consumed.
 451 *
 452 * Return: %true if the call is still ongoing and %false if it has completed.
 453 */
 454bool rxrpc_kernel_check_life(const struct socket *sock,
 455			     const struct rxrpc_call *call)
 456{
 457	if (!rxrpc_call_is_complete(call))
 458		return true;
 459	if (call->completion != RXRPC_CALL_SUCCEEDED)
 460		return false;
 461	return !skb_queue_empty(&call->recvmsg_queue);
 462}
 463EXPORT_SYMBOL(rxrpc_kernel_check_life);
 464
 465/**
 466 * rxrpc_kernel_set_notifications - Set table of callback operations
 467 * @sock: The socket to install table upon
 468 * @app_ops: Callback operation table to set
 469 *
 470 * Allow a kernel service to set a table of event notifications on a socket.
 471 */
 472void rxrpc_kernel_set_notifications(struct socket *sock,
 473				    const struct rxrpc_kernel_ops *app_ops)
 474{
 475	struct rxrpc_sock *rx = rxrpc_sk(sock->sk);
 476
 477	rx->app_ops = app_ops;
 478}
 479EXPORT_SYMBOL(rxrpc_kernel_set_notifications);
 480
 481/*
 482 * connect an RxRPC socket
 483 * - this just targets it at a specific destination; no actual connection
 484 *   negotiation takes place
 485 */
 486static int rxrpc_connect(struct socket *sock, struct sockaddr_unsized *addr,
 487			 int addr_len, int flags)
 488{
 489	struct sockaddr_rxrpc *srx = (struct sockaddr_rxrpc *)addr;
 490	struct rxrpc_sock *rx = rxrpc_sk(sock->sk);
 491	int ret;
 492
 493	_enter("%p,%p,%d,%d", rx, addr, addr_len, flags);
 494
 495	ret = rxrpc_validate_address(rx, srx, addr_len);
 496	if (ret < 0) {
 497		_leave(" = %d [bad addr]", ret);
 498		return ret;
 499	}
 500
 501	lock_sock(&rx->sk);
 502
 503	ret = -EISCONN;
 504	if (test_bit(RXRPC_SOCK_CONNECTED, &rx->flags))
 505		goto error;
 506
 507	switch (rx->sk.sk_state) {
 508	case RXRPC_UNBOUND:
 509		rx->sk.sk_state = RXRPC_CLIENT_UNBOUND;
 510		break;
 511	case RXRPC_CLIENT_UNBOUND:
 512	case RXRPC_CLIENT_BOUND:
 513		break;
 514	default:
 515		ret = -EBUSY;
 516		goto error;
 517	}
 518
 519	rx->connect_srx = *srx;
 520	set_bit(RXRPC_SOCK_CONNECTED, &rx->flags);
 521	ret = 0;
 522
 523error:
 524	release_sock(&rx->sk);
 525	return ret;
 526}
 527
 528/*
 529 * send a message through an RxRPC socket
 530 * - in a client this does a number of things:
 531 *   - finds/sets up a connection for the security specified (if any)
 532 *   - initiates a call (ID in control data)
 533 *   - ends the request phase of a call (if MSG_MORE is not set)
 534 *   - sends a call data packet
 535 *   - may send an abort (abort code in control data)
 536 */
 537static int rxrpc_sendmsg(struct socket *sock, struct msghdr *m, size_t len)
 538{
 539	struct rxrpc_local *local;
 540	struct rxrpc_sock *rx = rxrpc_sk(sock->sk);
 541	int ret;
 542
 543	_enter(",{%d},,%zu", rx->sk.sk_state, len);
 544
 545	if (m->msg_flags & MSG_OOB)
 546		return -EOPNOTSUPP;
 547
 548	if (m->msg_name) {
 549		ret = rxrpc_validate_address(rx, m->msg_name, m->msg_namelen);
 550		if (ret < 0) {
 551			_leave(" = %d [bad addr]", ret);
 552			return ret;
 553		}
 554	}
 555
 556	lock_sock(&rx->sk);
 557
 558	switch (rx->sk.sk_state) {
 559	case RXRPC_UNBOUND:
 560	case RXRPC_CLIENT_UNBOUND:
 561		rx->srx.srx_family = AF_RXRPC;
 562		rx->srx.srx_service = 0;
 563		rx->srx.transport_type = SOCK_DGRAM;
 564		rx->srx.transport.family = rx->family;
 565		switch (rx->family) {
 566		case AF_INET:
 567			rx->srx.transport_len = sizeof(struct sockaddr_in);
 568			break;
 569#ifdef CONFIG_AF_RXRPC_IPV6
 570		case AF_INET6:
 571			rx->srx.transport_len = sizeof(struct sockaddr_in6);
 572			break;
 573#endif
 574		default:
 575			ret = -EAFNOSUPPORT;
 576			goto error_unlock;
 577		}
 578		local = rxrpc_lookup_local(sock_net(sock->sk), &rx->srx);
 579		if (IS_ERR(local)) {
 580			ret = PTR_ERR(local);
 581			goto error_unlock;
 582		}
 583
 584		rx->local = local;
 585		rx->sk.sk_state = RXRPC_CLIENT_BOUND;
 586		fallthrough;
 587
 588	case RXRPC_CLIENT_BOUND:
 589		if (!m->msg_name &&
 590		    test_bit(RXRPC_SOCK_CONNECTED, &rx->flags)) {
 591			m->msg_name = &rx->connect_srx;
 592			m->msg_namelen = sizeof(rx->connect_srx);
 593		}
 594		fallthrough;
 595	case RXRPC_SERVER_BOUND:
 596	case RXRPC_SERVER_LISTENING:
 597		if (m->msg_flags & MSG_OOB)
 598			ret = rxrpc_sendmsg_oob(rx, m, len);
 599		else
 600			ret = rxrpc_do_sendmsg(rx, m, len);
 601		/* The socket has been unlocked */
 602		goto out;
 603	default:
 604		ret = -EINVAL;
 605		goto error_unlock;
 606	}
 607
 608error_unlock:
 609	release_sock(&rx->sk);
 610out:
 611	_leave(" = %d", ret);
 612	return ret;
 613}
 614
 615int rxrpc_sock_set_min_security_level(struct sock *sk, unsigned int val)
 616{
 617	if (sk->sk_state != RXRPC_UNBOUND)
 618		return -EISCONN;
 619	if (val > RXRPC_SECURITY_MAX)
 620		return -EINVAL;
 621	lock_sock(sk);
 622	rxrpc_sk(sk)->min_sec_level = val;
 623	release_sock(sk);
 624	return 0;
 625}
 626EXPORT_SYMBOL(rxrpc_sock_set_min_security_level);
 627
 628/*
 629 * set RxRPC socket options
 630 */
 631static int rxrpc_setsockopt(struct socket *sock, int level, int optname,
 632			    sockptr_t optval, unsigned int optlen)
 633{
 634	struct rxrpc_sock *rx = rxrpc_sk(sock->sk);
 635	unsigned int min_sec_level, val;
 636	u16 service_upgrade[2];
 637	int ret;
 638
 639	_enter(",%d,%d,,%d", level, optname, optlen);
 640
 641	lock_sock(&rx->sk);
 642	ret = -EOPNOTSUPP;
 643
 644	if (level == SOL_RXRPC) {
 645		switch (optname) {
 646		case RXRPC_EXCLUSIVE_CONNECTION:
 647			ret = -EINVAL;
 648			if (optlen != 0)
 649				goto error;
 650			ret = -EISCONN;
 651			if (rx->sk.sk_state != RXRPC_UNBOUND)
 652				goto error;
 653			rx->exclusive = true;
 654			goto success;
 655
 656		case RXRPC_SECURITY_KEY:
 657			ret = -EISCONN;
 658			if (rx->sk.sk_state != RXRPC_UNBOUND)
 659				goto error;
 660			ret = rxrpc_request_key(rx, optval, optlen);
 661			goto error;
 662
 663		case RXRPC_SECURITY_KEYRING:
 664			ret = -EISCONN;
 665			if (rx->sk.sk_state != RXRPC_UNBOUND)
 666				goto error;
 667			ret = rxrpc_server_keyring(rx, optval, optlen);
 668			goto error;
 669
 670		case RXRPC_MIN_SECURITY_LEVEL:
 671			ret = -EINVAL;
 672			if (optlen != sizeof(unsigned int))
 673				goto error;
 674			ret = -EISCONN;
 675			if (rx->sk.sk_state != RXRPC_UNBOUND)
 676				goto error;
 677			ret = copy_safe_from_sockptr(&min_sec_level,
 678						     sizeof(min_sec_level),
 679						     optval, optlen);
 680			if (ret)
 681				goto error;
 682			ret = -EINVAL;
 683			if (min_sec_level > RXRPC_SECURITY_MAX)
 684				goto error;
 685			rx->min_sec_level = min_sec_level;
 686			goto success;
 687
 688		case RXRPC_UPGRADEABLE_SERVICE:
 689			ret = -EINVAL;
 690			if (optlen != sizeof(service_upgrade) ||
 691			    rx->service_upgrade.from != 0)
 692				goto error;
 693			ret = -EISCONN;
 694			if (rx->sk.sk_state != RXRPC_SERVER_BOUND2)
 695				goto error;
 696			ret = -EFAULT;
 697			if (copy_from_sockptr(service_upgrade, optval,
 698					   sizeof(service_upgrade)) != 0)
 699				goto error;
 700			ret = -EINVAL;
 701			if ((service_upgrade[0] != rx->srx.srx_service ||
 702			     service_upgrade[1] != rx->second_service) &&
 703			    (service_upgrade[0] != rx->second_service ||
 704			     service_upgrade[1] != rx->srx.srx_service))
 705				goto error;
 706			rx->service_upgrade.from = service_upgrade[0];
 707			rx->service_upgrade.to = service_upgrade[1];
 708			goto success;
 709
 710		case RXRPC_MANAGE_RESPONSE:
 711			ret = -EINVAL;
 712			if (optlen != sizeof(unsigned int))
 713				goto error;
 714			ret = -EISCONN;
 715			if (rx->sk.sk_state != RXRPC_UNBOUND)
 716				goto error;
 717			ret = copy_safe_from_sockptr(&val, sizeof(val),
 718						     optval, optlen);
 719			if (ret)
 720				goto error;
 721			ret = -EINVAL;
 722			if (val > 1)
 723				goto error;
 724			if (val)
 725				set_bit(RXRPC_SOCK_MANAGE_RESPONSE, &rx->flags);
 726			else
 727				clear_bit(RXRPC_SOCK_MANAGE_RESPONSE, &rx->flags);
 728			goto success;
 729
 730		default:
 731			break;
 732		}
 733	}
 734
 735success:
 736	ret = 0;
 737error:
 738	release_sock(&rx->sk);
 739	return ret;
 740}
 741
 742/*
 743 * Get socket options.
 744 */
 745static int rxrpc_getsockopt(struct socket *sock, int level, int optname,
 746			    char __user *optval, int __user *_optlen)
 747{
 748	int optlen;
 749
 750	if (level != SOL_RXRPC)
 751		return -EOPNOTSUPP;
 752
 753	if (get_user(optlen, _optlen))
 754		return -EFAULT;
 755
 756	switch (optname) {
 757	case RXRPC_SUPPORTED_CMSG:
 758		if (optlen < sizeof(int))
 759			return -ETOOSMALL;
 760		if (put_user(RXRPC__SUPPORTED - 1, (int __user *)optval) ||
 761		    put_user(sizeof(int), _optlen))
 762			return -EFAULT;
 763		return 0;
 764
 765	default:
 766		return -EOPNOTSUPP;
 767	}
 768}
 769
 770/*
 771 * permit an RxRPC socket to be polled
 772 */
 773static __poll_t rxrpc_poll(struct file *file, struct socket *sock,
 774			       poll_table *wait)
 775{
 776	struct sock *sk = sock->sk;
 777	struct rxrpc_sock *rx = rxrpc_sk(sk);
 778	__poll_t mask;
 779
 780	sock_poll_wait(file, sock, wait);
 781	mask = 0;
 782
 783	/* the socket is readable if there are any messages waiting on the Rx
 784	 * queue */
 785	if (!list_empty(&rx->recvmsg_q))
 786		mask |= EPOLLIN | EPOLLRDNORM;
 787
 788	/* the socket is writable if there is space to add new data to the
 789	 * socket; there is no guarantee that any particular call in progress
 790	 * on the socket may have space in the Tx ACK window */
 791	if (rxrpc_writable(sk))
 792		mask |= EPOLLOUT | EPOLLWRNORM;
 793
 794	return mask;
 795}
 796
 797/*
 798 * create an RxRPC socket
 799 */
 800static int rxrpc_create(struct net *net, struct socket *sock, int protocol,
 801			int kern)
 802{
 803	struct rxrpc_net *rxnet;
 804	struct rxrpc_sock *rx;
 805	struct sock *sk;
 806
 807	_enter("%p,%d", sock, protocol);
 808
 809	/* we support transport protocol UDP/UDP6 only */
 810	if (protocol != PF_INET &&
 811	    IS_ENABLED(CONFIG_AF_RXRPC_IPV6) && protocol != PF_INET6)
 812		return -EPROTONOSUPPORT;
 813
 814	if (sock->type != SOCK_DGRAM)
 815		return -ESOCKTNOSUPPORT;
 816
 817	sock->ops = &rxrpc_rpc_ops;
 818	sock->state = SS_UNCONNECTED;
 819
 820	sk = sk_alloc(net, PF_RXRPC, GFP_KERNEL, &rxrpc_proto, kern);
 821	if (!sk)
 822		return -ENOMEM;
 823
 824	sock_init_data(sock, sk);
 825	sock_set_flag(sk, SOCK_RCU_FREE);
 826	sk->sk_state		= RXRPC_UNBOUND;
 827	sk->sk_write_space	= rxrpc_write_space;
 828	sk->sk_max_ack_backlog	= 0;
 829	sk->sk_destruct		= rxrpc_sock_destructor;
 830
 831	rx = rxrpc_sk(sk);
 832	rx->family = protocol;
 833	rx->calls = RB_ROOT;
 834
 835	spin_lock_init(&rx->incoming_lock);
 836	skb_queue_head_init(&rx->recvmsg_oobq);
 837	rx->pending_oobq = RB_ROOT;
 838	INIT_LIST_HEAD(&rx->sock_calls);
 839	INIT_LIST_HEAD(&rx->to_be_accepted);
 840	INIT_LIST_HEAD(&rx->recvmsg_q);
 841	spin_lock_init(&rx->recvmsg_lock);
 842	rwlock_init(&rx->call_lock);
 843	memset(&rx->srx, 0, sizeof(rx->srx));
 844
 845	rxnet = rxrpc_net(sock_net(&rx->sk));
 846	timer_reduce(&rxnet->peer_keepalive_timer, jiffies + 1);
 847
 848	_leave(" = 0 [%p]", rx);
 849	return 0;
 850}
 851
 852/*
 853 * Kill all the calls on a socket and shut it down.
 854 */
 855static int rxrpc_shutdown(struct socket *sock, int flags)
 856{
 857	struct sock *sk = sock->sk;
 858	struct rxrpc_sock *rx = rxrpc_sk(sk);
 859	int ret = 0;
 860
 861	_enter("%p,%d", sk, flags);
 862
 863	if (flags != SHUT_RDWR)
 864		return -EOPNOTSUPP;
 865	if (sk->sk_state == RXRPC_CLOSE)
 866		return -ESHUTDOWN;
 867
 868	lock_sock(sk);
 869
 870	if (sk->sk_state < RXRPC_CLOSE) {
 871		spin_lock_irq(&rx->recvmsg_lock);
 872		sk->sk_state = RXRPC_CLOSE;
 873		sk->sk_shutdown = SHUTDOWN_MASK;
 874		spin_unlock_irq(&rx->recvmsg_lock);
 875	} else {
 876		ret = -ESHUTDOWN;
 877	}
 878
 879	rxrpc_discard_prealloc(rx);
 880
 881	release_sock(sk);
 882	return ret;
 883}
 884
 885/*
 886 * Purge the out-of-band queue.
 887 */
 888static void rxrpc_purge_oob_queue(struct sock *sk)
 889{
 890	struct rxrpc_sock *rx = rxrpc_sk(sk);
 891	struct sk_buff *skb;
 892
 893	while ((skb = skb_dequeue(&rx->recvmsg_oobq)))
 894		rxrpc_kernel_free_oob(skb);
 895	while (!RB_EMPTY_ROOT(&rx->pending_oobq)) {
 896		skb = rb_entry(rx->pending_oobq.rb_node, struct sk_buff, rbnode);
 897		rb_erase(&skb->rbnode, &rx->pending_oobq);
 898		rxrpc_kernel_free_oob(skb);
 899	}
 900}
 901
 902/*
 903 * RxRPC socket destructor
 904 */
 905static void rxrpc_sock_destructor(struct sock *sk)
 906{
 907	_enter("%p", sk);
 908
 909	rxrpc_purge_oob_queue(sk);
 910	rxrpc_purge_queue(&sk->sk_receive_queue);
 911
 912	WARN_ON(refcount_read(&sk->sk_wmem_alloc));
 913	WARN_ON(!sk_unhashed(sk));
 914	WARN_ON(sk->sk_socket);
 915
 916	if (!sock_flag(sk, SOCK_DEAD)) {
 917		printk("Attempt to release alive rxrpc socket: %p\n", sk);
 918		return;
 919	}
 920}
 921
 922/*
 923 * release an RxRPC socket
 924 */
 925static int rxrpc_release_sock(struct sock *sk)
 926{
 927	struct rxrpc_sock *rx = rxrpc_sk(sk);
 928
 929	_enter("%p{%d,%d}", sk, sk->sk_state, refcount_read(&sk->sk_refcnt));
 930
 931	/* declare the socket closed for business */
 932	sock_orphan(sk);
 933	sk->sk_shutdown = SHUTDOWN_MASK;
 934
 935	/* We want to kill off all connections from a service socket
 936	 * as fast as possible because we can't share these; client
 937	 * sockets, on the other hand, can share an endpoint.
 938	 */
 939	switch (sk->sk_state) {
 940	case RXRPC_SERVER_BOUND:
 941	case RXRPC_SERVER_BOUND2:
 942	case RXRPC_SERVER_LISTENING:
 943	case RXRPC_SERVER_LISTEN_DISABLED:
 944		rx->local->service_closed = true;
 945		break;
 946	}
 947
 948	spin_lock_irq(&rx->recvmsg_lock);
 949	sk->sk_state = RXRPC_CLOSE;
 950	spin_unlock_irq(&rx->recvmsg_lock);
 951
 952	if (rx->local && rx->local->service == rx) {
 953		write_lock(&rx->local->services_lock);
 954		rx->local->service = NULL;
 955		write_unlock(&rx->local->services_lock);
 956	}
 957
 958	/* try to flush out this socket */
 959	rxrpc_discard_prealloc(rx);
 960	rxrpc_release_calls_on_socket(rx);
 961	flush_workqueue(rxrpc_workqueue);
 962	rxrpc_purge_oob_queue(sk);
 963	rxrpc_purge_queue(&sk->sk_receive_queue);
 964
 965	rxrpc_unuse_local(rx->local, rxrpc_local_unuse_release_sock);
 966	rxrpc_put_local(rx->local, rxrpc_local_put_release_sock);
 967	rx->local = NULL;
 968	key_put(rx->key);
 969	rx->key = NULL;
 970	key_put(rx->securities);
 971	rx->securities = NULL;
 972	sock_put(sk);
 973
 974	_leave(" = 0");
 975	return 0;
 976}
 977
 978/*
 979 * release an RxRPC BSD socket on close() or equivalent
 980 */
 981static int rxrpc_release(struct socket *sock)
 982{
 983	struct sock *sk = sock->sk;
 984
 985	_enter("%p{%p}", sock, sk);
 986
 987	if (!sk)
 988		return 0;
 989
 990	sock->sk = NULL;
 991
 992	return rxrpc_release_sock(sk);
 993}
 994
 995/*
 996 * RxRPC network protocol
 997 */
 998static const struct proto_ops rxrpc_rpc_ops = {
 999	.family		= PF_RXRPC,
1000	.owner		= THIS_MODULE,
1001	.release	= rxrpc_release,
1002	.bind		= rxrpc_bind,
1003	.connect	= rxrpc_connect,
1004	.socketpair	= sock_no_socketpair,
1005	.accept		= sock_no_accept,
1006	.getname	= sock_no_getname,
1007	.poll		= rxrpc_poll,
1008	.ioctl		= sock_no_ioctl,
1009	.listen		= rxrpc_listen,
1010	.shutdown	= rxrpc_shutdown,
1011	.setsockopt	= rxrpc_setsockopt,
1012	.getsockopt	= rxrpc_getsockopt,
1013	.sendmsg	= rxrpc_sendmsg,
1014	.recvmsg	= rxrpc_recvmsg,
1015	.mmap		= sock_no_mmap,
1016};
1017
1018static struct proto rxrpc_proto = {
1019	.name		= "RXRPC",
1020	.owner		= THIS_MODULE,
1021	.obj_size	= sizeof(struct rxrpc_sock),
1022	.max_header	= sizeof(struct rxrpc_wire_header),
1023};
1024
1025static const struct net_proto_family rxrpc_family_ops = {
1026	.family	= PF_RXRPC,
1027	.create = rxrpc_create,
1028	.owner	= THIS_MODULE,
1029};
1030
1031/*
1032 * initialise and register the RxRPC protocol
1033 */
1034static int __init af_rxrpc_init(void)
1035{
1036	int ret = -1;
1037
1038	BUILD_BUG_ON(sizeof(struct rxrpc_skb_priv) > sizeof_field(struct sk_buff, cb));
1039
1040	ret = -ENOMEM;
1041	rxrpc_gen_version_string();
1042	rxrpc_call_jar = kmem_cache_create(
1043		"rxrpc_call_jar", sizeof(struct rxrpc_call), 0,
1044		SLAB_HWCACHE_ALIGN, NULL);
1045	if (!rxrpc_call_jar) {
1046		pr_notice("Failed to allocate call jar\n");
1047		goto error_call_jar;
1048	}
1049
1050	rxrpc_workqueue = alloc_ordered_workqueue("krxrpcd", WQ_HIGHPRI | WQ_MEM_RECLAIM);
1051	if (!rxrpc_workqueue) {
1052		pr_notice("Failed to allocate work queue\n");
1053		goto error_work_queue;
1054	}
1055
1056	ret = rxrpc_init_security();
1057	if (ret < 0) {
1058		pr_crit("Cannot initialise security\n");
1059		goto error_security;
1060	}
1061
1062	ret = register_pernet_device(&rxrpc_net_ops);
1063	if (ret)
1064		goto error_pernet;
1065
1066	ret = proto_register(&rxrpc_proto, 1);
1067	if (ret < 0) {
1068		pr_crit("Cannot register protocol\n");
1069		goto error_proto;
1070	}
1071
1072	ret = sock_register(&rxrpc_family_ops);
1073	if (ret < 0) {
1074		pr_crit("Cannot register socket family\n");
1075		goto error_sock;
1076	}
1077
1078	ret = register_key_type(&key_type_rxrpc);
1079	if (ret < 0) {
1080		pr_crit("Cannot register client key type\n");
1081		goto error_key_type;
1082	}
1083
1084	ret = register_key_type(&key_type_rxrpc_s);
1085	if (ret < 0) {
1086		pr_crit("Cannot register server key type\n");
1087		goto error_key_type_s;
1088	}
1089
1090	ret = rxrpc_sysctl_init();
1091	if (ret < 0) {
1092		pr_crit("Cannot register sysctls\n");
1093		goto error_sysctls;
1094	}
1095
1096	return 0;
1097
1098error_sysctls:
1099	unregister_key_type(&key_type_rxrpc_s);
1100error_key_type_s:
1101	unregister_key_type(&key_type_rxrpc);
1102error_key_type:
1103	sock_unregister(PF_RXRPC);
1104error_sock:
1105	proto_unregister(&rxrpc_proto);
1106error_proto:
1107	unregister_pernet_device(&rxrpc_net_ops);
1108error_pernet:
1109	rxrpc_exit_security();
1110error_security:
1111	destroy_workqueue(rxrpc_workqueue);
1112error_work_queue:
1113	kmem_cache_destroy(rxrpc_call_jar);
1114error_call_jar:
1115	return ret;
1116}
1117
1118/*
1119 * unregister the RxRPC protocol
1120 */
1121static void __exit af_rxrpc_exit(void)
1122{
1123	_enter("");
1124	rxrpc_sysctl_exit();
1125	unregister_key_type(&key_type_rxrpc_s);
1126	unregister_key_type(&key_type_rxrpc);
1127	sock_unregister(PF_RXRPC);
1128	proto_unregister(&rxrpc_proto);
1129	unregister_pernet_device(&rxrpc_net_ops);
1130	ASSERTCMP(atomic_read(&rxrpc_n_rx_skbs), ==, 0);
1131
1132	/* Make sure the local and peer records pinned by any dying connections
1133	 * are released.
1134	 */
1135	rcu_barrier();
1136
1137	destroy_workqueue(rxrpc_workqueue);
1138	rxrpc_exit_security();
1139	kmem_cache_destroy(rxrpc_call_jar);
1140	_leave("");
1141}
1142
1143module_init(af_rxrpc_init);
1144module_exit(af_rxrpc_exit);