linux/net/rxrpc/af_rxrpc.c
<<
>>
Prefs
   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, S_IWUSR | S_IRUGO);
  36MODULE_PARM_DESC(debug, "RxRPC debugging mask");
  37
  38static struct proto rxrpc_proto;
  39static const struct proto_ops rxrpc_rpc_ops;
  40
  41/* local epoch for detecting local-end reset */
  42u32 rxrpc_epoch;
  43
  44/* current debugging ID */
  45atomic_t rxrpc_debug_id;
  46
  47/* count of skbs currently in use */
  48atomic_t rxrpc_n_tx_skbs, rxrpc_n_rx_skbs;
  49
  50struct workqueue_struct *rxrpc_workqueue;
  51
  52static void rxrpc_sock_destructor(struct sock *);
  53
  54/*
  55 * see if an RxRPC socket is currently writable
  56 */
  57static inline int rxrpc_writable(struct sock *sk)
  58{
  59        return atomic_read(&sk->sk_wmem_alloc) < (size_t) sk->sk_sndbuf;
  60}
  61
  62/*
  63 * wait for write bufferage to become available
  64 */
  65static void rxrpc_write_space(struct sock *sk)
  66{
  67        _enter("%p", sk);
  68        rcu_read_lock();
  69        if (rxrpc_writable(sk)) {
  70                struct socket_wq *wq = rcu_dereference(sk->sk_wq);
  71
  72                if (skwq_has_sleeper(wq))
  73                        wake_up_interruptible(&wq->wait);
  74                sk_wake_async(sk, SOCK_WAKE_SPACE, POLL_OUT);
  75        }
  76        rcu_read_unlock();
  77}
  78
  79/*
  80 * validate an RxRPC address
  81 */
  82static int rxrpc_validate_address(struct rxrpc_sock *rx,
  83                                  struct sockaddr_rxrpc *srx,
  84                                  int len)
  85{
  86        unsigned int tail;
  87
  88        if (len < sizeof(struct sockaddr_rxrpc))
  89                return -EINVAL;
  90
  91        if (srx->srx_family != AF_RXRPC)
  92                return -EAFNOSUPPORT;
  93
  94        if (srx->transport_type != SOCK_DGRAM)
  95                return -ESOCKTNOSUPPORT;
  96
  97        len -= offsetof(struct sockaddr_rxrpc, transport);
  98        if (srx->transport_len < sizeof(sa_family_t) ||
  99            srx->transport_len > len)
 100                return -EINVAL;
 101
 102        if (srx->transport.family != rx->family)
 103                return -EAFNOSUPPORT;
 104
 105        switch (srx->transport.family) {
 106        case AF_INET:
 107                if (srx->transport_len < sizeof(struct sockaddr_in))
 108                        return -EINVAL;
 109                tail = offsetof(struct sockaddr_rxrpc, transport.sin.__pad);
 110                break;
 111
 112#ifdef CONFIG_AF_RXRPC_IPV6
 113        case AF_INET6:
 114                if (srx->transport_len < sizeof(struct sockaddr_in6))
 115                        return -EINVAL;
 116                tail = offsetof(struct sockaddr_rxrpc, transport) +
 117                        sizeof(struct sockaddr_in6);
 118                break;
 119#endif
 120
 121        default:
 122                return -EAFNOSUPPORT;
 123        }
 124
 125        if (tail < len)
 126                memset((void *)srx + tail, 0, len - tail);
 127        _debug("INET: %pISp", &srx->transport);
 128        return 0;
 129}
 130
 131/*
 132 * bind a local address to an RxRPC socket
 133 */
 134static int rxrpc_bind(struct socket *sock, struct sockaddr *saddr, int len)
 135{
 136        struct sockaddr_rxrpc *srx = (struct sockaddr_rxrpc *)saddr;
 137        struct sock *sk = sock->sk;
 138        struct rxrpc_local *local;
 139        struct rxrpc_sock *rx = rxrpc_sk(sk);
 140        u16 service_id = srx->srx_service;
 141        int ret;
 142
 143        _enter("%p,%p,%d", rx, saddr, len);
 144
 145        ret = rxrpc_validate_address(rx, srx, len);
 146        if (ret < 0)
 147                goto error;
 148
 149        lock_sock(&rx->sk);
 150
 151        if (rx->sk.sk_state != RXRPC_UNBOUND) {
 152                ret = -EINVAL;
 153                goto error_unlock;
 154        }
 155
 156        memcpy(&rx->srx, srx, sizeof(rx->srx));
 157
 158        local = rxrpc_lookup_local(&rx->srx);
 159        if (IS_ERR(local)) {
 160                ret = PTR_ERR(local);
 161                goto error_unlock;
 162        }
 163
 164        if (service_id) {
 165                write_lock(&local->services_lock);
 166                if (rcu_access_pointer(local->service))
 167                        goto service_in_use;
 168                rx->local = local;
 169                rcu_assign_pointer(local->service, rx);
 170                write_unlock(&local->services_lock);
 171
 172                rx->sk.sk_state = RXRPC_SERVER_BOUND;
 173        } else {
 174                rx->local = local;
 175                rx->sk.sk_state = RXRPC_CLIENT_BOUND;
 176        }
 177
 178        release_sock(&rx->sk);
 179        _leave(" = 0");
 180        return 0;
 181
 182service_in_use:
 183        write_unlock(&local->services_lock);
 184        rxrpc_put_local(local);
 185        ret = -EADDRINUSE;
 186error_unlock:
 187        release_sock(&rx->sk);
 188error:
 189        _leave(" = %d", ret);
 190        return ret;
 191}
 192
 193/*
 194 * set the number of pending calls permitted on a listening socket
 195 */
 196static int rxrpc_listen(struct socket *sock, int backlog)
 197{
 198        struct sock *sk = sock->sk;
 199        struct rxrpc_sock *rx = rxrpc_sk(sk);
 200        unsigned int max, old;
 201        int ret;
 202
 203        _enter("%p,%d", rx, backlog);
 204
 205        lock_sock(&rx->sk);
 206
 207        switch (rx->sk.sk_state) {
 208        case RXRPC_UNBOUND:
 209                ret = -EADDRNOTAVAIL;
 210                break;
 211        case RXRPC_SERVER_BOUND:
 212                ASSERT(rx->local != NULL);
 213                max = READ_ONCE(rxrpc_max_backlog);
 214                ret = -EINVAL;
 215                if (backlog == INT_MAX)
 216                        backlog = max;
 217                else if (backlog < 0 || backlog > max)
 218                        break;
 219                old = sk->sk_max_ack_backlog;
 220                sk->sk_max_ack_backlog = backlog;
 221                ret = rxrpc_service_prealloc(rx, GFP_KERNEL);
 222                if (ret == 0)
 223                        rx->sk.sk_state = RXRPC_SERVER_LISTENING;
 224                else
 225                        sk->sk_max_ack_backlog = old;
 226                break;
 227        default:
 228                ret = -EBUSY;
 229                break;
 230        }
 231
 232        release_sock(&rx->sk);
 233        _leave(" = %d", ret);
 234        return ret;
 235}
 236
 237/**
 238 * rxrpc_kernel_begin_call - Allow a kernel service to begin a call
 239 * @sock: The socket on which to make the call
 240 * @srx: The address of the peer to contact
 241 * @key: The security context to use (defaults to socket setting)
 242 * @user_call_ID: The ID to use
 243 * @gfp: The allocation constraints
 244 * @notify_rx: Where to send notifications instead of socket queue
 245 *
 246 * Allow a kernel service to begin a call on the nominated socket.  This just
 247 * sets up all the internal tracking structures and allocates connection and
 248 * call IDs as appropriate.  The call to be used is returned.
 249 *
 250 * The default socket destination address and security may be overridden by
 251 * supplying @srx and @key.
 252 */
 253struct rxrpc_call *rxrpc_kernel_begin_call(struct socket *sock,
 254                                           struct sockaddr_rxrpc *srx,
 255                                           struct key *key,
 256                                           unsigned long user_call_ID,
 257                                           gfp_t gfp,
 258                                           rxrpc_notify_rx_t notify_rx)
 259{
 260        struct rxrpc_conn_parameters cp;
 261        struct rxrpc_call *call;
 262        struct rxrpc_sock *rx = rxrpc_sk(sock->sk);
 263        int ret;
 264
 265        _enter(",,%x,%lx", key_serial(key), user_call_ID);
 266
 267        ret = rxrpc_validate_address(rx, srx, sizeof(*srx));
 268        if (ret < 0)
 269                return ERR_PTR(ret);
 270
 271        lock_sock(&rx->sk);
 272
 273        if (!key)
 274                key = rx->key;
 275        if (key && !key->payload.data[0])
 276                key = NULL; /* a no-security key */
 277
 278        memset(&cp, 0, sizeof(cp));
 279        cp.local                = rx->local;
 280        cp.key                  = key;
 281        cp.security_level       = 0;
 282        cp.exclusive            = false;
 283        cp.service_id           = srx->srx_service;
 284        call = rxrpc_new_client_call(rx, &cp, srx, user_call_ID, gfp);
 285        if (!IS_ERR(call))
 286                call->notify_rx = notify_rx;
 287
 288        release_sock(&rx->sk);
 289        _leave(" = %p", call);
 290        return call;
 291}
 292EXPORT_SYMBOL(rxrpc_kernel_begin_call);
 293
 294/**
 295 * rxrpc_kernel_end_call - Allow a kernel service to end a call it was using
 296 * @sock: The socket the call is on
 297 * @call: The call to end
 298 *
 299 * Allow a kernel service to end a call it was using.  The call must be
 300 * complete before this is called (the call should be aborted if necessary).
 301 */
 302void rxrpc_kernel_end_call(struct socket *sock, struct rxrpc_call *call)
 303{
 304        _enter("%d{%d}", call->debug_id, atomic_read(&call->usage));
 305        rxrpc_release_call(rxrpc_sk(sock->sk), call);
 306        rxrpc_put_call(call, rxrpc_call_put_kernel);
 307}
 308EXPORT_SYMBOL(rxrpc_kernel_end_call);
 309
 310/**
 311 * rxrpc_kernel_new_call_notification - Get notifications of new calls
 312 * @sock: The socket to intercept received messages on
 313 * @notify_new_call: Function to be called when new calls appear
 314 * @discard_new_call: Function to discard preallocated calls
 315 *
 316 * Allow a kernel service to be given notifications about new calls.
 317 */
 318void rxrpc_kernel_new_call_notification(
 319        struct socket *sock,
 320        rxrpc_notify_new_call_t notify_new_call,
 321        rxrpc_discard_new_call_t discard_new_call)
 322{
 323        struct rxrpc_sock *rx = rxrpc_sk(sock->sk);
 324
 325        rx->notify_new_call = notify_new_call;
 326        rx->discard_new_call = discard_new_call;
 327}
 328EXPORT_SYMBOL(rxrpc_kernel_new_call_notification);
 329
 330/*
 331 * connect an RxRPC socket
 332 * - this just targets it at a specific destination; no actual connection
 333 *   negotiation takes place
 334 */
 335static int rxrpc_connect(struct socket *sock, struct sockaddr *addr,
 336                         int addr_len, int flags)
 337{
 338        struct sockaddr_rxrpc *srx = (struct sockaddr_rxrpc *)addr;
 339        struct rxrpc_sock *rx = rxrpc_sk(sock->sk);
 340        int ret;
 341
 342        _enter("%p,%p,%d,%d", rx, addr, addr_len, flags);
 343
 344        ret = rxrpc_validate_address(rx, srx, addr_len);
 345        if (ret < 0) {
 346                _leave(" = %d [bad addr]", ret);
 347                return ret;
 348        }
 349
 350        lock_sock(&rx->sk);
 351
 352        ret = -EISCONN;
 353        if (test_bit(RXRPC_SOCK_CONNECTED, &rx->flags))
 354                goto error;
 355
 356        switch (rx->sk.sk_state) {
 357        case RXRPC_UNBOUND:
 358                rx->sk.sk_state = RXRPC_CLIENT_UNBOUND;
 359        case RXRPC_CLIENT_UNBOUND:
 360        case RXRPC_CLIENT_BOUND:
 361                break;
 362        default:
 363                ret = -EBUSY;
 364                goto error;
 365        }
 366
 367        rx->connect_srx = *srx;
 368        set_bit(RXRPC_SOCK_CONNECTED, &rx->flags);
 369        ret = 0;
 370
 371error:
 372        release_sock(&rx->sk);
 373        return ret;
 374}
 375
 376/*
 377 * send a message through an RxRPC socket
 378 * - in a client this does a number of things:
 379 *   - finds/sets up a connection for the security specified (if any)
 380 *   - initiates a call (ID in control data)
 381 *   - ends the request phase of a call (if MSG_MORE is not set)
 382 *   - sends a call data packet
 383 *   - may send an abort (abort code in control data)
 384 */
 385static int rxrpc_sendmsg(struct socket *sock, struct msghdr *m, size_t len)
 386{
 387        struct rxrpc_local *local;
 388        struct rxrpc_sock *rx = rxrpc_sk(sock->sk);
 389        int ret;
 390
 391        _enter(",{%d},,%zu", rx->sk.sk_state, len);
 392
 393        if (m->msg_flags & MSG_OOB)
 394                return -EOPNOTSUPP;
 395
 396        if (m->msg_name) {
 397                ret = rxrpc_validate_address(rx, m->msg_name, m->msg_namelen);
 398                if (ret < 0) {
 399                        _leave(" = %d [bad addr]", ret);
 400                        return ret;
 401                }
 402        }
 403
 404        lock_sock(&rx->sk);
 405
 406        switch (rx->sk.sk_state) {
 407        case RXRPC_UNBOUND:
 408                rx->srx.srx_family = AF_RXRPC;
 409                rx->srx.srx_service = 0;
 410                rx->srx.transport_type = SOCK_DGRAM;
 411                rx->srx.transport.family = rx->family;
 412                switch (rx->family) {
 413                case AF_INET:
 414                        rx->srx.transport_len = sizeof(struct sockaddr_in);
 415                        break;
 416#ifdef CONFIG_AF_RXRPC_IPV6
 417                case AF_INET6:
 418                        rx->srx.transport_len = sizeof(struct sockaddr_in6);
 419                        break;
 420#endif
 421                default:
 422                        ret = -EAFNOSUPPORT;
 423                        goto error_unlock;
 424                }
 425                local = rxrpc_lookup_local(&rx->srx);
 426                if (IS_ERR(local)) {
 427                        ret = PTR_ERR(local);
 428                        goto error_unlock;
 429                }
 430
 431                rx->local = local;
 432                rx->sk.sk_state = RXRPC_CLIENT_UNBOUND;
 433                /* Fall through */
 434
 435        case RXRPC_CLIENT_UNBOUND:
 436        case RXRPC_CLIENT_BOUND:
 437                if (!m->msg_name &&
 438                    test_bit(RXRPC_SOCK_CONNECTED, &rx->flags)) {
 439                        m->msg_name = &rx->connect_srx;
 440                        m->msg_namelen = sizeof(rx->connect_srx);
 441                }
 442        case RXRPC_SERVER_BOUND:
 443        case RXRPC_SERVER_LISTENING:
 444                ret = rxrpc_do_sendmsg(rx, m, len);
 445                break;
 446        default:
 447                ret = -EINVAL;
 448                break;
 449        }
 450
 451error_unlock:
 452        release_sock(&rx->sk);
 453        _leave(" = %d", ret);
 454        return ret;
 455}
 456
 457/*
 458 * set RxRPC socket options
 459 */
 460static int rxrpc_setsockopt(struct socket *sock, int level, int optname,
 461                            char __user *optval, unsigned int optlen)
 462{
 463        struct rxrpc_sock *rx = rxrpc_sk(sock->sk);
 464        unsigned int min_sec_level;
 465        int ret;
 466
 467        _enter(",%d,%d,,%d", level, optname, optlen);
 468
 469        lock_sock(&rx->sk);
 470        ret = -EOPNOTSUPP;
 471
 472        if (level == SOL_RXRPC) {
 473                switch (optname) {
 474                case RXRPC_EXCLUSIVE_CONNECTION:
 475                        ret = -EINVAL;
 476                        if (optlen != 0)
 477                                goto error;
 478                        ret = -EISCONN;
 479                        if (rx->sk.sk_state != RXRPC_UNBOUND)
 480                                goto error;
 481                        rx->exclusive = true;
 482                        goto success;
 483
 484                case RXRPC_SECURITY_KEY:
 485                        ret = -EINVAL;
 486                        if (rx->key)
 487                                goto error;
 488                        ret = -EISCONN;
 489                        if (rx->sk.sk_state != RXRPC_UNBOUND)
 490                                goto error;
 491                        ret = rxrpc_request_key(rx, optval, optlen);
 492                        goto error;
 493
 494                case RXRPC_SECURITY_KEYRING:
 495                        ret = -EINVAL;
 496                        if (rx->key)
 497                                goto error;
 498                        ret = -EISCONN;
 499                        if (rx->sk.sk_state != RXRPC_UNBOUND)
 500                                goto error;
 501                        ret = rxrpc_server_keyring(rx, optval, optlen);
 502                        goto error;
 503
 504                case RXRPC_MIN_SECURITY_LEVEL:
 505                        ret = -EINVAL;
 506                        if (optlen != sizeof(unsigned int))
 507                                goto error;
 508                        ret = -EISCONN;
 509                        if (rx->sk.sk_state != RXRPC_UNBOUND)
 510                                goto error;
 511                        ret = get_user(min_sec_level,
 512                                       (unsigned int __user *) optval);
 513                        if (ret < 0)
 514                                goto error;
 515                        ret = -EINVAL;
 516                        if (min_sec_level > RXRPC_SECURITY_MAX)
 517                                goto error;
 518                        rx->min_sec_level = min_sec_level;
 519                        goto success;
 520
 521                default:
 522                        break;
 523                }
 524        }
 525
 526success:
 527        ret = 0;
 528error:
 529        release_sock(&rx->sk);
 530        return ret;
 531}
 532
 533/*
 534 * permit an RxRPC socket to be polled
 535 */
 536static unsigned int rxrpc_poll(struct file *file, struct socket *sock,
 537                               poll_table *wait)
 538{
 539        struct sock *sk = sock->sk;
 540        struct rxrpc_sock *rx = rxrpc_sk(sk);
 541        unsigned int mask;
 542
 543        sock_poll_wait(file, sk_sleep(sk), wait);
 544        mask = 0;
 545
 546        /* the socket is readable if there are any messages waiting on the Rx
 547         * queue */
 548        if (!list_empty(&rx->recvmsg_q))
 549                mask |= POLLIN | POLLRDNORM;
 550
 551        /* the socket is writable if there is space to add new data to the
 552         * socket; there is no guarantee that any particular call in progress
 553         * on the socket may have space in the Tx ACK window */
 554        if (rxrpc_writable(sk))
 555                mask |= POLLOUT | POLLWRNORM;
 556
 557        return mask;
 558}
 559
 560/*
 561 * create an RxRPC socket
 562 */
 563static int rxrpc_create(struct net *net, struct socket *sock, int protocol,
 564                        int kern)
 565{
 566        struct rxrpc_sock *rx;
 567        struct sock *sk;
 568
 569        _enter("%p,%d", sock, protocol);
 570
 571        if (!net_eq(net, &init_net))
 572                return -EAFNOSUPPORT;
 573
 574        /* we support transport protocol UDP/UDP6 only */
 575        if (protocol != PF_INET &&
 576            IS_ENABLED(CONFIG_AF_RXRPC_IPV6) && protocol != PF_INET6)
 577                return -EPROTONOSUPPORT;
 578
 579        if (sock->type != SOCK_DGRAM)
 580                return -ESOCKTNOSUPPORT;
 581
 582        sock->ops = &rxrpc_rpc_ops;
 583        sock->state = SS_UNCONNECTED;
 584
 585        sk = sk_alloc(net, PF_RXRPC, GFP_KERNEL, &rxrpc_proto, kern);
 586        if (!sk)
 587                return -ENOMEM;
 588
 589        sock_init_data(sock, sk);
 590        sock_set_flag(sk, SOCK_RCU_FREE);
 591        sk->sk_state            = RXRPC_UNBOUND;
 592        sk->sk_write_space      = rxrpc_write_space;
 593        sk->sk_max_ack_backlog  = 0;
 594        sk->sk_destruct         = rxrpc_sock_destructor;
 595
 596        rx = rxrpc_sk(sk);
 597        rx->family = protocol;
 598        rx->calls = RB_ROOT;
 599
 600        spin_lock_init(&rx->incoming_lock);
 601        INIT_LIST_HEAD(&rx->sock_calls);
 602        INIT_LIST_HEAD(&rx->to_be_accepted);
 603        INIT_LIST_HEAD(&rx->recvmsg_q);
 604        rwlock_init(&rx->recvmsg_lock);
 605        rwlock_init(&rx->call_lock);
 606        memset(&rx->srx, 0, sizeof(rx->srx));
 607
 608        _leave(" = 0 [%p]", rx);
 609        return 0;
 610}
 611
 612/*
 613 * Kill all the calls on a socket and shut it down.
 614 */
 615static int rxrpc_shutdown(struct socket *sock, int flags)
 616{
 617        struct sock *sk = sock->sk;
 618        struct rxrpc_sock *rx = rxrpc_sk(sk);
 619        int ret = 0;
 620
 621        _enter("%p,%d", sk, flags);
 622
 623        if (flags != SHUT_RDWR)
 624                return -EOPNOTSUPP;
 625        if (sk->sk_state == RXRPC_CLOSE)
 626                return -ESHUTDOWN;
 627
 628        lock_sock(sk);
 629
 630        spin_lock_bh(&sk->sk_receive_queue.lock);
 631        if (sk->sk_state < RXRPC_CLOSE) {
 632                sk->sk_state = RXRPC_CLOSE;
 633                sk->sk_shutdown = SHUTDOWN_MASK;
 634        } else {
 635                ret = -ESHUTDOWN;
 636        }
 637        spin_unlock_bh(&sk->sk_receive_queue.lock);
 638
 639        rxrpc_discard_prealloc(rx);
 640
 641        release_sock(sk);
 642        return ret;
 643}
 644
 645/*
 646 * RxRPC socket destructor
 647 */
 648static void rxrpc_sock_destructor(struct sock *sk)
 649{
 650        _enter("%p", sk);
 651
 652        rxrpc_purge_queue(&sk->sk_receive_queue);
 653
 654        WARN_ON(atomic_read(&sk->sk_wmem_alloc));
 655        WARN_ON(!sk_unhashed(sk));
 656        WARN_ON(sk->sk_socket);
 657
 658        if (!sock_flag(sk, SOCK_DEAD)) {
 659                printk("Attempt to release alive rxrpc socket: %p\n", sk);
 660                return;
 661        }
 662}
 663
 664/*
 665 * release an RxRPC socket
 666 */
 667static int rxrpc_release_sock(struct sock *sk)
 668{
 669        struct rxrpc_sock *rx = rxrpc_sk(sk);
 670
 671        _enter("%p{%d,%d}", sk, sk->sk_state, atomic_read(&sk->sk_refcnt));
 672
 673        /* declare the socket closed for business */
 674        sock_orphan(sk);
 675        sk->sk_shutdown = SHUTDOWN_MASK;
 676
 677        spin_lock_bh(&sk->sk_receive_queue.lock);
 678        sk->sk_state = RXRPC_CLOSE;
 679        spin_unlock_bh(&sk->sk_receive_queue.lock);
 680
 681        if (rx->local && rcu_access_pointer(rx->local->service) == rx) {
 682                write_lock(&rx->local->services_lock);
 683                rcu_assign_pointer(rx->local->service, NULL);
 684                write_unlock(&rx->local->services_lock);
 685        }
 686
 687        /* try to flush out this socket */
 688        rxrpc_discard_prealloc(rx);
 689        rxrpc_release_calls_on_socket(rx);
 690        flush_workqueue(rxrpc_workqueue);
 691        rxrpc_purge_queue(&sk->sk_receive_queue);
 692
 693        rxrpc_put_local(rx->local);
 694        rx->local = NULL;
 695        key_put(rx->key);
 696        rx->key = NULL;
 697        key_put(rx->securities);
 698        rx->securities = NULL;
 699        sock_put(sk);
 700
 701        _leave(" = 0");
 702        return 0;
 703}
 704
 705/*
 706 * release an RxRPC BSD socket on close() or equivalent
 707 */
 708static int rxrpc_release(struct socket *sock)
 709{
 710        struct sock *sk = sock->sk;
 711
 712        _enter("%p{%p}", sock, sk);
 713
 714        if (!sk)
 715                return 0;
 716
 717        sock->sk = NULL;
 718
 719        return rxrpc_release_sock(sk);
 720}
 721
 722/*
 723 * RxRPC network protocol
 724 */
 725static const struct proto_ops rxrpc_rpc_ops = {
 726        .family         = PF_RXRPC,
 727        .owner          = THIS_MODULE,
 728        .release        = rxrpc_release,
 729        .bind           = rxrpc_bind,
 730        .connect        = rxrpc_connect,
 731        .socketpair     = sock_no_socketpair,
 732        .accept         = sock_no_accept,
 733        .getname        = sock_no_getname,
 734        .poll           = rxrpc_poll,
 735        .ioctl          = sock_no_ioctl,
 736        .listen         = rxrpc_listen,
 737        .shutdown       = rxrpc_shutdown,
 738        .setsockopt     = rxrpc_setsockopt,
 739        .getsockopt     = sock_no_getsockopt,
 740        .sendmsg        = rxrpc_sendmsg,
 741        .recvmsg        = rxrpc_recvmsg,
 742        .mmap           = sock_no_mmap,
 743        .sendpage       = sock_no_sendpage,
 744};
 745
 746static struct proto rxrpc_proto = {
 747        .name           = "RXRPC",
 748        .owner          = THIS_MODULE,
 749        .obj_size       = sizeof(struct rxrpc_sock),
 750        .max_header     = sizeof(struct rxrpc_wire_header),
 751};
 752
 753static const struct net_proto_family rxrpc_family_ops = {
 754        .family = PF_RXRPC,
 755        .create = rxrpc_create,
 756        .owner  = THIS_MODULE,
 757};
 758
 759/*
 760 * initialise and register the RxRPC protocol
 761 */
 762static int __init af_rxrpc_init(void)
 763{
 764        int ret = -1;
 765        unsigned int tmp;
 766
 767        BUILD_BUG_ON(sizeof(struct rxrpc_skb_priv) > FIELD_SIZEOF(struct sk_buff, cb));
 768
 769        get_random_bytes(&rxrpc_epoch, sizeof(rxrpc_epoch));
 770        rxrpc_epoch |= RXRPC_RANDOM_EPOCH;
 771        get_random_bytes(&tmp, sizeof(tmp));
 772        tmp &= 0x3fffffff;
 773        if (tmp == 0)
 774                tmp = 1;
 775        idr_set_cursor(&rxrpc_client_conn_ids, tmp);
 776
 777        ret = -ENOMEM;
 778        rxrpc_call_jar = kmem_cache_create(
 779                "rxrpc_call_jar", sizeof(struct rxrpc_call), 0,
 780                SLAB_HWCACHE_ALIGN, NULL);
 781        if (!rxrpc_call_jar) {
 782                pr_notice("Failed to allocate call jar\n");
 783                goto error_call_jar;
 784        }
 785
 786        rxrpc_workqueue = alloc_workqueue("krxrpcd", 0, 1);
 787        if (!rxrpc_workqueue) {
 788                pr_notice("Failed to allocate work queue\n");
 789                goto error_work_queue;
 790        }
 791
 792        ret = rxrpc_init_security();
 793        if (ret < 0) {
 794                pr_crit("Cannot initialise security\n");
 795                goto error_security;
 796        }
 797
 798        ret = proto_register(&rxrpc_proto, 1);
 799        if (ret < 0) {
 800                pr_crit("Cannot register protocol\n");
 801                goto error_proto;
 802        }
 803
 804        ret = sock_register(&rxrpc_family_ops);
 805        if (ret < 0) {
 806                pr_crit("Cannot register socket family\n");
 807                goto error_sock;
 808        }
 809
 810        ret = register_key_type(&key_type_rxrpc);
 811        if (ret < 0) {
 812                pr_crit("Cannot register client key type\n");
 813                goto error_key_type;
 814        }
 815
 816        ret = register_key_type(&key_type_rxrpc_s);
 817        if (ret < 0) {
 818                pr_crit("Cannot register server key type\n");
 819                goto error_key_type_s;
 820        }
 821
 822        ret = rxrpc_sysctl_init();
 823        if (ret < 0) {
 824                pr_crit("Cannot register sysctls\n");
 825                goto error_sysctls;
 826        }
 827
 828#ifdef CONFIG_PROC_FS
 829        proc_create("rxrpc_calls", 0, init_net.proc_net, &rxrpc_call_seq_fops);
 830        proc_create("rxrpc_conns", 0, init_net.proc_net,
 831                    &rxrpc_connection_seq_fops);
 832#endif
 833        return 0;
 834
 835error_sysctls:
 836        unregister_key_type(&key_type_rxrpc_s);
 837error_key_type_s:
 838        unregister_key_type(&key_type_rxrpc);
 839error_key_type:
 840        sock_unregister(PF_RXRPC);
 841error_sock:
 842        proto_unregister(&rxrpc_proto);
 843error_proto:
 844        rxrpc_exit_security();
 845error_security:
 846        destroy_workqueue(rxrpc_workqueue);
 847error_work_queue:
 848        kmem_cache_destroy(rxrpc_call_jar);
 849error_call_jar:
 850        return ret;
 851}
 852
 853/*
 854 * unregister the RxRPC protocol
 855 */
 856static void __exit af_rxrpc_exit(void)
 857{
 858        _enter("");
 859        rxrpc_sysctl_exit();
 860        unregister_key_type(&key_type_rxrpc_s);
 861        unregister_key_type(&key_type_rxrpc);
 862        sock_unregister(PF_RXRPC);
 863        proto_unregister(&rxrpc_proto);
 864        rxrpc_destroy_all_calls();
 865        rxrpc_destroy_all_connections();
 866        ASSERTCMP(atomic_read(&rxrpc_n_tx_skbs), ==, 0);
 867        ASSERTCMP(atomic_read(&rxrpc_n_rx_skbs), ==, 0);
 868        rxrpc_destroy_all_locals();
 869
 870        remove_proc_entry("rxrpc_conns", init_net.proc_net);
 871        remove_proc_entry("rxrpc_calls", init_net.proc_net);
 872        destroy_workqueue(rxrpc_workqueue);
 873        rxrpc_exit_security();
 874        kmem_cache_destroy(rxrpc_call_jar);
 875        _leave("");
 876}
 877
 878module_init(af_rxrpc_init);
 879module_exit(af_rxrpc_exit);
 880