net/rxrpc/ar-peer.c

   1 /* RxRPC remote transport 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 <linux/udp.h>
  16 #include <linux/in.h>
  17 #include <linux/in6.h>
  18 #include <linux/icmp.h>
  19 #include <linux/slab.h>
  20 #include <net/sock.h>
  21 #include <net/af_rxrpc.h>
  22 #include <net/ip.h>
  23 #include <net/route.h>
  24 #include "ar-internal.h"
  25
  26 static LIST_HEAD(rxrpc_peers);
  27 static DEFINE_RWLOCK(rxrpc_peer_lock);
  28 static DECLARE_WAIT_QUEUE_HEAD(rxrpc_peer_wq);
  29
  30 static void rxrpc_destroy_peer(struct work_struct *work);
  31
  32 /*
  33  * assess the MTU size for the network interface through which this peer is
  34  * reached
  35  */
  36 static void rxrpc_assess_MTU_size(struct rxrpc_peer *peer)
  37 {
  38         struct rtable *rt;
  39         struct flowi4 fl4;
  40
  41         peer->if_mtu = 1500;
  42
  43         rt = ip_route_output_ports(&init_net, &fl4, NULL,
  44                                    peer->srx.transport.sin.sin_addr.s_addr, 0,
  45                                    htons(7000), htons(7001),
  46                                    IPPROTO_UDP, 0, 0);
  47         if (IS_ERR(rt)) {
  48                 _leave(" [route err %ld]", PTR_ERR(rt));
  49                 return;
  50         }
  51
  52         peer->if_mtu = dst_mtu(&rt->dst);
  53         dst_release(&rt->dst);
  54
  55         _leave(" [if_mtu %u]", peer->if_mtu);
  56 }
  57
  58 /*
  59  * allocate a new peer
  60  */
  61 static struct rxrpc_peer *rxrpc_alloc_peer(struct sockaddr_rxrpc *srx,
  62                                            gfp_t gfp)
  63 {
  64         struct rxrpc_peer *peer;
  65
  66         _enter("");
  67
  68         peer = kzalloc(sizeof(struct rxrpc_peer), gfp);
  69         if (peer) {
  70                 INIT_WORK(&peer->destroyer, &rxrpc_destroy_peer);
  71                 INIT_LIST_HEAD(&peer->link);
  72                 INIT_LIST_HEAD(&peer->error_targets);
  73                 spin_lock_init(&peer->lock);
  74                 atomic_set(&peer->usage, 1);
  75                 peer->debug_id = atomic_inc_return(&rxrpc_debug_id);
  76                 memcpy(&peer->srx, srx, sizeof(*srx));
  77
  78                 rxrpc_assess_MTU_size(peer);
  79                 peer->mtu = peer->if_mtu;
  80
  81                 if (srx->transport.family == AF_INET) {
  82                         peer->hdrsize = sizeof(struct iphdr);
  83                         switch (srx->transport_type) {
  84                         case SOCK_DGRAM:
  85                                 peer->hdrsize += sizeof(struct udphdr);
  86                                 break;
  87                         default:
  88                                 BUG();
  89                                 break;
  90                         }
  91                 } else {
  92                         BUG();
  93                 }
  94
  95                 peer->hdrsize += sizeof(struct rxrpc_header);
  96                 peer->maxdata = peer->mtu - peer->hdrsize;
  97         }
  98
  99         _leave(" = %p", peer);
 100         return peer;
 101 }
 102
 103 /*
 104  * obtain a remote transport endpoint for the specified address
 105  */
 106 struct rxrpc_peer *rxrpc_get_peer(struct sockaddr_rxrpc *srx, gfp_t gfp)
 107 {
 108         struct rxrpc_peer *peer, *candidate;
 109         const char *new = "old";
 110         int usage;
 111
 112         _enter("{%d,%d,%pI4+%hu}",
 113                srx->transport_type,
 114                srx->transport_len,
 115                &srx->transport.sin.sin_addr,
 116                ntohs(srx->transport.sin.sin_port));
 117
 118         /* search the peer list first */
 119         read_lock_bh(&rxrpc_peer_lock);
 120         list_for_each_entry(peer, &rxrpc_peers, link) {
 121                 _debug("check PEER %d { u=%d t=%d l=%d }",
 122                        peer->debug_id,
 123                        atomic_read(&peer->usage),
 124                        peer->srx.transport_type,
 125                        peer->srx.transport_len);
 126
 127                 if (atomic_read(&peer->usage) > 0 &&
 128                     peer->srx.transport_type == srx->transport_type &&
 129                     peer->srx.transport_len == srx->transport_len &&
 130                     memcmp(&peer->srx.transport,
 131                            &srx->transport,
 132                            srx->transport_len) == 0)
 133                         goto found_extant_peer;
 134         }
 135         read_unlock_bh(&rxrpc_peer_lock);
 136
 137         /* not yet present - create a candidate for a new record and then
 138          * redo the search */
 139         candidate = rxrpc_alloc_peer(srx, gfp);
 140         if (!candidate) {
 141                 _leave(" = -ENOMEM");
 142                 return ERR_PTR(-ENOMEM);
 143         }
 144
 145         write_lock_bh(&rxrpc_peer_lock);
 146
 147         list_for_each_entry(peer, &rxrpc_peers, link) {
 148                 if (atomic_read(&peer->usage) > 0 &&
 149                     peer->srx.transport_type == srx->transport_type &&
 150                     peer->srx.transport_len == srx->transport_len &&
 151                     memcmp(&peer->srx.transport,
 152                            &srx->transport,
 153                            srx->transport_len) == 0)
 154                         goto found_extant_second;
 155         }
 156
 157         /* we can now add the new candidate to the list */
 158         peer = candidate;
 159         candidate = NULL;
 160
 161         list_add_tail(&peer->link, &rxrpc_peers);
 162         write_unlock_bh(&rxrpc_peer_lock);
 163         new = "new";
 164
 165 success:
 166         _net("PEER %s %d {%d,%u,%pI4+%hu}",
 167              new,
 168              peer->debug_id,
 169              peer->srx.transport_type,
 170              peer->srx.transport.family,
 171              &peer->srx.transport.sin.sin_addr,
 172              ntohs(peer->srx.transport.sin.sin_port));
 173
 174         _leave(" = %p {u=%d}", peer, atomic_read(&peer->usage));
 175         return peer;
 176
 177         /* we found the peer in the list immediately */
 178 found_extant_peer:
 179         usage = atomic_inc_return(&peer->usage);
 180         read_unlock_bh(&rxrpc_peer_lock);
 181         goto success;
 182
 183         /* we found the peer on the second time through the list */
 184 found_extant_second:
 185         usage = atomic_inc_return(&peer->usage);
 186         write_unlock_bh(&rxrpc_peer_lock);
 187         kfree(candidate);
 188         goto success;
 189 }
 190
 191 /*
 192  * find the peer associated with a packet
 193  */
 194 struct rxrpc_peer *rxrpc_find_peer(struct rxrpc_local *local,
 195                                    __be32 addr, __be16 port)
 196 {
 197         struct rxrpc_peer *peer;
 198
 199         _enter("");
 200
 201         /* search the peer list */
 202         read_lock_bh(&rxrpc_peer_lock);
 203
 204         if (local->srx.transport.family == AF_INET &&
 205             local->srx.transport_type == SOCK_DGRAM
 206             ) {
 207                 list_for_each_entry(peer, &rxrpc_peers, link) {
 208                         if (atomic_read(&peer->usage) > 0 &&
 209                             peer->srx.transport_type == SOCK_DGRAM &&
 210                             peer->srx.transport.family == AF_INET &&
 211                             peer->srx.transport.sin.sin_port == port &&
 212                             peer->srx.transport.sin.sin_addr.s_addr == addr)
 213                                 goto found_UDP_peer;
 214                 }
 215
 216                 goto new_UDP_peer;
 217         }
 218
 219         read_unlock_bh(&rxrpc_peer_lock);
 220         _leave(" = -EAFNOSUPPORT");
 221         return ERR_PTR(-EAFNOSUPPORT);
 222
 223 found_UDP_peer:
 224         _net("Rx UDP DGRAM from peer %d", peer->debug_id);
 225         atomic_inc(&peer->usage);
 226         read_unlock_bh(&rxrpc_peer_lock);
 227         _leave(" = %p", peer);
 228         return peer;
 229
 230 new_UDP_peer:
 231         _net("Rx UDP DGRAM from NEW peer %d", peer->debug_id);
 232         read_unlock_bh(&rxrpc_peer_lock);
 233         _leave(" = -EBUSY [new]");
 234         return ERR_PTR(-EBUSY);
 235 }
 236
 237 /*
 238  * release a remote transport endpoint
 239  */
 240 void rxrpc_put_peer(struct rxrpc_peer *peer)
 241 {
 242         _enter("%p{u=%d}", peer, atomic_read(&peer->usage));
 243
 244         ASSERTCMP(atomic_read(&peer->usage), >, 0);
 245
 246         if (likely(!atomic_dec_and_test(&peer->usage))) {
 247                 _leave(" [in use]");
 248                 return;
 249         }
 250
 251         rxrpc_queue_work(&peer->destroyer);
 252         _leave("");
 253 }
 254
 255 /*
 256  * destroy a remote transport endpoint
 257  */
 258 static void rxrpc_destroy_peer(struct work_struct *work)
 259 {
 260         struct rxrpc_peer *peer =
 261                 container_of(work, struct rxrpc_peer, destroyer);
 262
 263         _enter("%p{%d}", peer, atomic_read(&peer->usage));
 264
 265         write_lock_bh(&rxrpc_peer_lock);
 266         list_del(&peer->link);
 267         write_unlock_bh(&rxrpc_peer_lock);
 268
 269         _net("DESTROY PEER %d", peer->debug_id);
 270         kfree(peer);
 271
 272         if (list_empty(&rxrpc_peers))
 273                 wake_up_all(&rxrpc_peer_wq);
 274         _leave("");
 275 }
 276
 277 /*
 278  * preemptively destroy all the peer records from a transport endpoint rather
 279  * than waiting for them to time out
 280  */
 281 void __exit rxrpc_destroy_all_peers(void)
 282 {
 283         DECLARE_WAITQUEUE(myself,current);
 284
 285         _enter("");
 286
 287         /* we simply have to wait for them to go away */
 288         if (!list_empty(&rxrpc_peers)) {
 289                 set_current_state(TASK_UNINTERRUPTIBLE);
 290                 add_wait_queue(&rxrpc_peer_wq, &myself);
 291
 292                 while (!list_empty(&rxrpc_peers)) {
 293                         schedule();
 294                         set_current_state(TASK_UNINTERRUPTIBLE);
 295                 }
 296
 297                 remove_wait_queue(&rxrpc_peer_wq, &myself);
 298                 set_current_state(TASK_RUNNING);
 299         }
 300
 301         _leave("");
 302 }