Linux Audio

Check our new training course

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