LXR linux/net/rxrpc/ar-local.c

   1/* AF_RXRPC local endpoint management
   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#include <linux/module.h>
  13#include <linux/net.h>
  14#include <linux/skbuff.h>
  15#include <net/sock.h>
  16#include <net/af_rxrpc.h>
  17#include "ar-internal.h"
  18
  19static LIST_HEAD(rxrpc_locals);
  20DEFINE_RWLOCK(rxrpc_local_lock);
  21static DECLARE_RWSEM(rxrpc_local_sem);
  22static DECLARE_WAIT_QUEUE_HEAD(rxrpc_local_wq);
  23
  24static void rxrpc_destroy_local(struct work_struct *work);
  25
  26/*
  27 * allocate a new local
  28 */
  29static
  30struct rxrpc_local *rxrpc_alloc_local(struct sockaddr_rxrpc *srx)
  31{
  32        struct rxrpc_local *local;
  33
  34        local = kzalloc(sizeof(struct rxrpc_local), GFP_KERNEL);
  35        if (local) {
  36                INIT_WORK(&local->destroyer, &rxrpc_destroy_local);
  37                INIT_WORK(&local->acceptor, &rxrpc_accept_incoming_calls);
  38                INIT_WORK(&local->rejecter, &rxrpc_reject_packets);
  39                INIT_LIST_HEAD(&local->services);
  40                INIT_LIST_HEAD(&local->link);
  41                init_rwsem(&local->defrag_sem);
  42                skb_queue_head_init(&local->accept_queue);
  43                skb_queue_head_init(&local->reject_queue);
  44                spin_lock_init(&local->lock);
  45                rwlock_init(&local->services_lock);
  46                atomic_set(&local->usage, 1);
  47                local->debug_id = atomic_inc_return(&rxrpc_debug_id);
  48                memcpy(&local->srx, srx, sizeof(*srx));
  49        }
  50
  51        _leave(" = %p", local);
  52        return local;
  53}
  54
  55/*
  56 * create the local socket
  57 * - must be called with rxrpc_local_sem writelocked
  58 */
  59static int rxrpc_create_local(struct rxrpc_local *local)
  60{
  61        struct sock *sock;
  62        int ret, opt;
  63
  64        _enter("%p{%d}", local, local->srx.transport_type);
  65
  66        /* create a socket to represent the local endpoint */
  67        ret = sock_create_kern(PF_INET, local->srx.transport_type, IPPROTO_UDP,
  68                               &local->socket);
  69        if (ret < 0) {
  70                _leave(" = %d [socket]", ret);
  71                return ret;
  72        }
  73
  74        /* if a local address was supplied then bind it */
  75        if (local->srx.transport_len > sizeof(sa_family_t)) {
  76                _debug("bind");
  77                ret = kernel_bind(local->socket,
  78                                  (struct sockaddr *) &local->srx.transport,
  79                                  local->srx.transport_len);
  80                if (ret < 0) {
  81                        _debug("bind failed");
  82                        goto error;
  83                }
  84        }
  85
  86        /* we want to receive ICMP errors */
  87        opt = 1;
  88        ret = kernel_setsockopt(local->socket, SOL_IP, IP_RECVERR,
  89                                (char *) &opt, sizeof(opt));
  90        if (ret < 0) {
  91                _debug("setsockopt failed");
  92                goto error;
  93        }
  94
  95        /* we want to set the don't fragment bit */
  96        opt = IP_PMTUDISC_DO;
  97        ret = kernel_setsockopt(local->socket, SOL_IP, IP_MTU_DISCOVER,
  98                                (char *) &opt, sizeof(opt));
  99        if (ret < 0) {
 100                _debug("setsockopt failed");
 101                goto error;
 102        }
 103
 104        write_lock_bh(&rxrpc_local_lock);
 105        list_add(&local->link, &rxrpc_locals);
 106        write_unlock_bh(&rxrpc_local_lock);
 107
 108        /* set the socket up */
 109        sock = local->socket->sk;
 110        sock->sk_user_data      = local;
 111        sock->sk_data_ready     = rxrpc_data_ready;
 112        sock->sk_error_report   = rxrpc_UDP_error_report;
 113        _leave(" = 0");
 114        return 0;
 115
 116error:
 117        kernel_sock_shutdown(local->socket, SHUT_RDWR);
 118        local->socket->sk->sk_user_data = NULL;
 119        sock_release(local->socket);
 120        local->socket = NULL;
 121
 122        _leave(" = %d", ret);
 123        return ret;
 124}
 125
 126/*
 127 * create a new local endpoint using the specified UDP address
 128 */
 129struct rxrpc_local *rxrpc_lookup_local(struct sockaddr_rxrpc *srx)
 130{
 131        struct rxrpc_local *local;
 132        int ret;
 133
 134        _enter("{%d,%u,%pI4+%hu}",
 135               srx->transport_type,
 136               srx->transport.family,
 137               &srx->transport.sin.sin_addr,
 138               ntohs(srx->transport.sin.sin_port));
 139
 140        down_write(&rxrpc_local_sem);
 141
 142        /* see if we have a suitable local local endpoint already */
 143        read_lock_bh(&rxrpc_local_lock);
 144
 145        list_for_each_entry(local, &rxrpc_locals, link) {
 146                _debug("CMP {%d,%u,%pI4+%hu}",
 147                       local->srx.transport_type,
 148                       local->srx.transport.family,
 149                       &local->srx.transport.sin.sin_addr,
 150                       ntohs(local->srx.transport.sin.sin_port));
 151
 152                if (local->srx.transport_type != srx->transport_type ||
 153                    local->srx.transport.family != srx->transport.family)
 154                        continue;
 155
 156                switch (srx->transport.family) {
 157                case AF_INET:
 158                        if (local->srx.transport.sin.sin_port !=
 159                            srx->transport.sin.sin_port)
 160                                continue;
 161                        if (memcmp(&local->srx.transport.sin.sin_addr,
 162                                   &srx->transport.sin.sin_addr,
 163                                   sizeof(struct in_addr)) != 0)
 164                                continue;
 165                        goto found_local;
 166
 167                default:
 168                        BUG();
 169                }
 170        }
 171
 172        read_unlock_bh(&rxrpc_local_lock);
 173
 174        /* we didn't find one, so we need to create one */
 175        local = rxrpc_alloc_local(srx);
 176        if (!local) {
 177                up_write(&rxrpc_local_sem);
 178                return ERR_PTR(-ENOMEM);
 179        }
 180
 181        ret = rxrpc_create_local(local);
 182        if (ret < 0) {
 183                up_write(&rxrpc_local_sem);
 184                kfree(local);
 185                _leave(" = %d", ret);
 186                return ERR_PTR(ret);
 187        }
 188
 189        up_write(&rxrpc_local_sem);
 190
 191        _net("LOCAL new %d {%d,%u,%pI4+%hu}",
 192             local->debug_id,
 193             local->srx.transport_type,
 194             local->srx.transport.family,
 195             &local->srx.transport.sin.sin_addr,
 196             ntohs(local->srx.transport.sin.sin_port));
 197
 198        _leave(" = %p [new]", local);
 199        return local;
 200
 201found_local:
 202        rxrpc_get_local(local);
 203        read_unlock_bh(&rxrpc_local_lock);
 204        up_write(&rxrpc_local_sem);
 205
 206        _net("LOCAL old %d {%d,%u,%pI4+%hu}",
 207             local->debug_id,
 208             local->srx.transport_type,
 209             local->srx.transport.family,
 210             &local->srx.transport.sin.sin_addr,
 211             ntohs(local->srx.transport.sin.sin_port));
 212
 213        _leave(" = %p [reuse]", local);
 214        return local;
 215}
 216
 217/*
 218 * release a local endpoint
 219 */
 220void rxrpc_put_local(struct rxrpc_local *local)
 221{
 222        _enter("%p{u=%d}", local, atomic_read(&local->usage));
 223
 224        ASSERTCMP(atomic_read(&local->usage), >, 0);
 225
 226        /* to prevent a race, the decrement and the dequeue must be effectively
 227         * atomic */
 228        write_lock_bh(&rxrpc_local_lock);
 229        if (unlikely(atomic_dec_and_test(&local->usage))) {
 230                _debug("destroy local");
 231                rxrpc_queue_work(&local->destroyer);
 232        }
 233        write_unlock_bh(&rxrpc_local_lock);
 234        _leave("");
 235}
 236
 237/*
 238 * destroy a local endpoint
 239 */
 240static void rxrpc_destroy_local(struct work_struct *work)
 241{
 242        struct rxrpc_local *local =
 243                container_of(work, struct rxrpc_local, destroyer);
 244
 245        _enter("%p{%d}", local, atomic_read(&local->usage));
 246
 247        down_write(&rxrpc_local_sem);
 248
 249        write_lock_bh(&rxrpc_local_lock);
 250        if (atomic_read(&local->usage) > 0) {
 251                write_unlock_bh(&rxrpc_local_lock);
 252                up_read(&rxrpc_local_sem);
 253                _leave(" [resurrected]");
 254                return;
 255        }
 256
 257        list_del(&local->link);
 258        local->socket->sk->sk_user_data = NULL;
 259        write_unlock_bh(&rxrpc_local_lock);
 260
 261        downgrade_write(&rxrpc_local_sem);
 262
 263        ASSERT(list_empty(&local->services));
 264        ASSERT(!work_pending(&local->acceptor));
 265        ASSERT(!work_pending(&local->rejecter));
 266
 267        /* finish cleaning up the local descriptor */
 268        rxrpc_purge_queue(&local->accept_queue);
 269        rxrpc_purge_queue(&local->reject_queue);
 270        kernel_sock_shutdown(local->socket, SHUT_RDWR);
 271        sock_release(local->socket);
 272
 273        up_read(&rxrpc_local_sem);
 274
 275        _net("DESTROY LOCAL %d", local->debug_id);
 276        kfree(local);
 277
 278        if (list_empty(&rxrpc_locals))
 279                wake_up_all(&rxrpc_local_wq);
 280
 281        _leave("");
 282}
 283
 284/*
 285 * preemptively destroy all local local endpoint rather than waiting for
 286 * them to be destroyed
 287 */
 288void __exit rxrpc_destroy_all_locals(void)
 289{
 290        DECLARE_WAITQUEUE(myself,current);
 291
 292        _enter("");
 293
 294        /* we simply have to wait for them to go away */
 295        if (!list_empty(&rxrpc_locals)) {
 296                set_current_state(TASK_UNINTERRUPTIBLE);
 297                add_wait_queue(&rxrpc_local_wq, &myself);
 298
 299                while (!list_empty(&rxrpc_locals)) {
 300                        schedule();
 301                        set_current_state(TASK_UNINTERRUPTIBLE);
 302                }
 303
 304                remove_wait_queue(&rxrpc_local_wq, &myself);
 305                set_current_state(TASK_RUNNING);
 306        }
 307
 308        _leave("");
 309}
 310