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

   1/* RxRPC point-to-point transport session 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 <linux/slab.h>
  16#include <net/sock.h>
  17#include <net/af_rxrpc.h>
  18#include "ar-internal.h"
  19
  20/*
  21 * Time after last use at which transport record is cleaned up.
  22 */
  23unsigned rxrpc_transport_expiry = 3600 * 24;
  24
  25static void rxrpc_transport_reaper(struct work_struct *work);
  26
  27static LIST_HEAD(rxrpc_transports);
  28static DEFINE_RWLOCK(rxrpc_transport_lock);
  29static DECLARE_DELAYED_WORK(rxrpc_transport_reap, rxrpc_transport_reaper);
  30
  31/*
  32 * allocate a new transport session manager
  33 */
  34static struct rxrpc_transport *rxrpc_alloc_transport(struct rxrpc_local *local,
  35                                                     struct rxrpc_peer *peer,
  36                                                     gfp_t gfp)
  37{
  38        struct rxrpc_transport *trans;
  39
  40        _enter("");
  41
  42        trans = kzalloc(sizeof(struct rxrpc_transport), gfp);
  43        if (trans) {
  44                trans->local = local;
  45                trans->peer = peer;
  46                INIT_LIST_HEAD(&trans->link);
  47                trans->bundles = RB_ROOT;
  48                trans->client_conns = RB_ROOT;
  49                trans->server_conns = RB_ROOT;
  50                skb_queue_head_init(&trans->error_queue);
  51                spin_lock_init(&trans->client_lock);
  52                rwlock_init(&trans->conn_lock);
  53                atomic_set(&trans->usage, 1);
  54                trans->debug_id = atomic_inc_return(&rxrpc_debug_id);
  55
  56                if (peer->srx.transport.family == AF_INET) {
  57                        switch (peer->srx.transport_type) {
  58                        case SOCK_DGRAM:
  59                                INIT_WORK(&trans->error_handler,
  60                                          rxrpc_UDP_error_handler);
  61                                break;
  62                        default:
  63                                BUG();
  64                                break;
  65                        }
  66                } else {
  67                        BUG();
  68                }
  69        }
  70
  71        _leave(" = %p", trans);
  72        return trans;
  73}
  74
  75/*
  76 * obtain a transport session for the nominated endpoints
  77 */
  78struct rxrpc_transport *rxrpc_get_transport(struct rxrpc_local *local,
  79                                            struct rxrpc_peer *peer,
  80                                            gfp_t gfp)
  81{
  82        struct rxrpc_transport *trans, *candidate;
  83        const char *new = "old";
  84        int usage;
  85
  86        _enter("{%pI4+%hu},{%pI4+%hu},",
  87               &local->srx.transport.sin.sin_addr,
  88               ntohs(local->srx.transport.sin.sin_port),
  89               &peer->srx.transport.sin.sin_addr,
  90               ntohs(peer->srx.transport.sin.sin_port));
  91
  92        /* search the transport list first */
  93        read_lock_bh(&rxrpc_transport_lock);
  94        list_for_each_entry(trans, &rxrpc_transports, link) {
  95                if (trans->local == local && trans->peer == peer)
  96                        goto found_extant_transport;
  97        }
  98        read_unlock_bh(&rxrpc_transport_lock);
  99
 100        /* not yet present - create a candidate for a new record and then
 101         * redo the search */
 102        candidate = rxrpc_alloc_transport(local, peer, gfp);
 103        if (!candidate) {
 104                _leave(" = -ENOMEM");
 105                return ERR_PTR(-ENOMEM);
 106        }
 107
 108        write_lock_bh(&rxrpc_transport_lock);
 109
 110        list_for_each_entry(trans, &rxrpc_transports, link) {
 111                if (trans->local == local && trans->peer == peer)
 112                        goto found_extant_second;
 113        }
 114
 115        /* we can now add the new candidate to the list */
 116        trans = candidate;
 117        candidate = NULL;
 118        usage = atomic_read(&trans->usage);
 119
 120        rxrpc_get_local(trans->local);
 121        atomic_inc(&trans->peer->usage);
 122        list_add_tail(&trans->link, &rxrpc_transports);
 123        write_unlock_bh(&rxrpc_transport_lock);
 124        new = "new";
 125
 126success:
 127        _net("TRANSPORT %s %d local %d -> peer %d",
 128             new,
 129             trans->debug_id,
 130             trans->local->debug_id,
 131             trans->peer->debug_id);
 132
 133        _leave(" = %p {u=%d}", trans, usage);
 134        return trans;
 135
 136        /* we found the transport in the list immediately */
 137found_extant_transport:
 138        usage = atomic_inc_return(&trans->usage);
 139        read_unlock_bh(&rxrpc_transport_lock);
 140        goto success;
 141
 142        /* we found the transport on the second time through the list */
 143found_extant_second:
 144        usage = atomic_inc_return(&trans->usage);
 145        write_unlock_bh(&rxrpc_transport_lock);
 146        kfree(candidate);
 147        goto success;
 148}
 149
 150/*
 151 * find the transport connecting two endpoints
 152 */
 153struct rxrpc_transport *rxrpc_find_transport(struct rxrpc_local *local,
 154                                             struct rxrpc_peer *peer)
 155{
 156        struct rxrpc_transport *trans;
 157
 158        _enter("{%pI4+%hu},{%pI4+%hu},",
 159               &local->srx.transport.sin.sin_addr,
 160               ntohs(local->srx.transport.sin.sin_port),
 161               &peer->srx.transport.sin.sin_addr,
 162               ntohs(peer->srx.transport.sin.sin_port));
 163
 164        /* search the transport list */
 165        read_lock_bh(&rxrpc_transport_lock);
 166
 167        list_for_each_entry(trans, &rxrpc_transports, link) {
 168                if (trans->local == local && trans->peer == peer)
 169                        goto found_extant_transport;
 170        }
 171
 172        read_unlock_bh(&rxrpc_transport_lock);
 173        _leave(" = NULL");
 174        return NULL;
 175
 176found_extant_transport:
 177        atomic_inc(&trans->usage);
 178        read_unlock_bh(&rxrpc_transport_lock);
 179        _leave(" = %p", trans);
 180        return trans;
 181}
 182
 183/*
 184 * release a transport session
 185 */
 186void rxrpc_put_transport(struct rxrpc_transport *trans)
 187{
 188        _enter("%p{u=%d}", trans, atomic_read(&trans->usage));
 189
 190        ASSERTCMP(atomic_read(&trans->usage), >, 0);
 191
 192        trans->put_time = ktime_get_seconds();
 193        if (unlikely(atomic_dec_and_test(&trans->usage))) {
 194                _debug("zombie");
 195                /* let the reaper determine the timeout to avoid a race with
 196                 * overextending the timeout if the reaper is running at the
 197                 * same time */
 198                rxrpc_queue_delayed_work(&rxrpc_transport_reap, 0);
 199        }
 200        _leave("");
 201}
 202
 203/*
 204 * clean up a transport session
 205 */
 206static void rxrpc_cleanup_transport(struct rxrpc_transport *trans)
 207{
 208        _net("DESTROY TRANS %d", trans->debug_id);
 209
 210        rxrpc_purge_queue(&trans->error_queue);
 211
 212        rxrpc_put_local(trans->local);
 213        rxrpc_put_peer(trans->peer);
 214        kfree(trans);
 215}
 216
 217/*
 218 * reap dead transports that have passed their expiry date
 219 */
 220static void rxrpc_transport_reaper(struct work_struct *work)
 221{
 222        struct rxrpc_transport *trans, *_p;
 223        unsigned long now, earliest, reap_time;
 224
 225        LIST_HEAD(graveyard);
 226
 227        _enter("");
 228
 229        now = ktime_get_seconds();
 230        earliest = ULONG_MAX;
 231
 232        /* extract all the transports that have been dead too long */
 233        write_lock_bh(&rxrpc_transport_lock);
 234        list_for_each_entry_safe(trans, _p, &rxrpc_transports, link) {
 235                _debug("reap TRANS %d { u=%d t=%ld }",
 236                       trans->debug_id, atomic_read(&trans->usage),
 237                       (long) now - (long) trans->put_time);
 238
 239                if (likely(atomic_read(&trans->usage) > 0))
 240                        continue;
 241
 242                reap_time = trans->put_time + rxrpc_transport_expiry;
 243                if (reap_time <= now)
 244                        list_move_tail(&trans->link, &graveyard);
 245                else if (reap_time < earliest)
 246                        earliest = reap_time;
 247        }
 248        write_unlock_bh(&rxrpc_transport_lock);
 249
 250        if (earliest != ULONG_MAX) {
 251                _debug("reschedule reaper %ld", (long) earliest - now);
 252                ASSERTCMP(earliest, >, now);
 253                rxrpc_queue_delayed_work(&rxrpc_transport_reap,
 254                                         (earliest - now) * HZ);
 255        }
 256
 257        /* then destroy all those pulled out */
 258        while (!list_empty(&graveyard)) {
 259                trans = list_entry(graveyard.next, struct rxrpc_transport,
 260                                   link);
 261                list_del_init(&trans->link);
 262
 263                ASSERTCMP(atomic_read(&trans->usage), ==, 0);
 264                rxrpc_cleanup_transport(trans);
 265        }
 266
 267        _leave("");
 268}
 269
 270/*
 271 * preemptively destroy all the transport session records rather than waiting
 272 * for them to time out
 273 */
 274void __exit rxrpc_destroy_all_transports(void)
 275{
 276        _enter("");
 277
 278        rxrpc_transport_expiry = 0;
 279        cancel_delayed_work(&rxrpc_transport_reap);
 280        rxrpc_queue_delayed_work(&rxrpc_transport_reap, 0);
 281
 282        _leave("");
 283}
 284