net/rxrpc/peer_object.c

   1 /* RxRPC remote transport endpoint record management
   2  *
   3  * Copyright (C) 2007, 2016 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/net.h>
  16 #include <linux/skbuff.h>
  17 #include <linux/udp.h>
  18 #include <linux/in.h>
  19 #include <linux/slab.h>
  20 #include <linux/hashtable.h>
  21 #include <net/sock.h>
  22 #include <net/af_rxrpc.h>
  23 #include <net/ip.h>
  24 #include <net/route.h>
  25 #include "ar-internal.h"
  26
  27 static DEFINE_HASHTABLE(rxrpc_peer_hash, 10);
  28 static DEFINE_SPINLOCK(rxrpc_peer_hash_lock);
  29
  30 /*
  31  * Hash a peer key.
  32  */
  33 static unsigned long rxrpc_peer_hash_key(struct rxrpc_local *local,
  34                                          const struct sockaddr_rxrpc *srx)
  35 {
  36         const u16 *p;
  37         unsigned int i, size;
  38         unsigned long hash_key;
  39
  40         _enter("");
  41
  42         hash_key = (unsigned long)local / __alignof__(*local);
  43         hash_key += srx->transport_type;
  44         hash_key += srx->transport_len;
  45         hash_key += srx->transport.family;
  46
  47         switch (srx->transport.family) {
  48         case AF_INET:
  49                 hash_key += (u16 __force)srx->transport.sin.sin_port;
  50                 size = sizeof(srx->transport.sin.sin_addr);
  51                 p = (u16 *)&srx->transport.sin.sin_addr;
  52                 break;
  53         default:
  54                 WARN(1, "AF_RXRPC: Unsupported transport address family\n");
  55                 return 0;
  56         }
  57
  58         /* Step through the peer address in 16-bit portions for speed */
  59         for (i = 0; i < size; i += sizeof(*p), p++)
  60                 hash_key += *p;
  61
  62         _leave(" 0x%lx", hash_key);
  63         return hash_key;
  64 }
  65
  66 /*
  67  * Compare a peer to a key.  Return -ve, 0 or +ve to indicate less than, same
  68  * or greater than.
  69  *
  70  * Unfortunately, the primitives in linux/hashtable.h don't allow for sorted
  71  * buckets and mid-bucket insertion, so we don't make full use of this
  72  * information at this point.
  73  */
  74 static long rxrpc_peer_cmp_key(const struct rxrpc_peer *peer,
  75                                struct rxrpc_local *local,
  76                                const struct sockaddr_rxrpc *srx,
  77                                unsigned long hash_key)
  78 {
  79         long diff;
  80
  81         diff = ((peer->hash_key - hash_key) ?:
  82                 ((unsigned long)peer->local - (unsigned long)local) ?:
  83                 (peer->srx.transport_type - srx->transport_type) ?:
  84                 (peer->srx.transport_len - srx->transport_len) ?:
  85                 (peer->srx.transport.family - srx->transport.family));
  86         if (diff != 0)
  87                 return diff;
  88
  89         switch (srx->transport.family) {
  90         case AF_INET:
  91                 return ((u16 __force)peer->srx.transport.sin.sin_port -
  92                         (u16 __force)srx->transport.sin.sin_port) ?:
  93                         memcmp(&peer->srx.transport.sin.sin_addr,
  94                                &srx->transport.sin.sin_addr,
  95                                sizeof(struct in_addr));
  96         default:
  97                 BUG();
  98         }
  99 }
 100
 101 /*
 102  * Look up a remote transport endpoint for the specified address using RCU.
 103  */
 104 static struct rxrpc_peer *__rxrpc_lookup_peer_rcu(
 105         struct rxrpc_local *local,
 106         const struct sockaddr_rxrpc *srx,
 107         unsigned long hash_key)
 108 {
 109         struct rxrpc_peer *peer;
 110
 111         hash_for_each_possible_rcu(rxrpc_peer_hash, peer, hash_link, hash_key) {
 112                 if (rxrpc_peer_cmp_key(peer, local, srx, hash_key) == 0) {
 113                         if (atomic_read(&peer->usage) == 0)
 114                                 return NULL;
 115                         return peer;
 116                 }
 117         }
 118
 119         return NULL;
 120 }
 121
 122 /*
 123  * Look up a remote transport endpoint for the specified address using RCU.
 124  */
 125 struct rxrpc_peer *rxrpc_lookup_peer_rcu(struct rxrpc_local *local,
 126                                          const struct sockaddr_rxrpc *srx)
 127 {
 128         struct rxrpc_peer *peer;
 129         unsigned long hash_key = rxrpc_peer_hash_key(local, srx);
 130
 131         peer = __rxrpc_lookup_peer_rcu(local, srx, hash_key);
 132         if (peer) {
 133                 switch (srx->transport.family) {
 134                 case AF_INET:
 135                         _net("PEER %d {%d,%u,%pI4+%hu}",
 136                              peer->debug_id,
 137                              peer->srx.transport_type,
 138                              peer->srx.transport.family,
 139                              &peer->srx.transport.sin.sin_addr,
 140                              ntohs(peer->srx.transport.sin.sin_port));
 141                         break;
 142                 }
 143
 144                 _leave(" = %p {u=%d}", peer, atomic_read(&peer->usage));
 145         }
 146         return peer;
 147 }
 148
 149 /*
 150  * assess the MTU size for the network interface through which this peer is
 151  * reached
 152  */
 153 static void rxrpc_assess_MTU_size(struct rxrpc_peer *peer)
 154 {
 155         struct rtable *rt;
 156         struct flowi4 fl4;
 157
 158         peer->if_mtu = 1500;
 159
 160         rt = ip_route_output_ports(&init_net, &fl4, NULL,
 161                                    peer->srx.transport.sin.sin_addr.s_addr, 0,
 162                                    htons(7000), htons(7001),
 163                                    IPPROTO_UDP, 0, 0);
 164         if (IS_ERR(rt)) {
 165                 _leave(" [route err %ld]", PTR_ERR(rt));
 166                 return;
 167         }
 168
 169         peer->if_mtu = dst_mtu(&rt->dst);
 170         dst_release(&rt->dst);
 171
 172         _leave(" [if_mtu %u]", peer->if_mtu);
 173 }
 174
 175 /*
 176  * Allocate a peer.
 177  */
 178 struct rxrpc_peer *rxrpc_alloc_peer(struct rxrpc_local *local, gfp_t gfp)
 179 {
 180         struct rxrpc_peer *peer;
 181
 182         _enter("");
 183
 184         peer = kzalloc(sizeof(struct rxrpc_peer), gfp);
 185         if (peer) {
 186                 atomic_set(&peer->usage, 1);
 187                 peer->local = local;
 188                 INIT_HLIST_HEAD(&peer->error_targets);
 189                 INIT_WORK(&peer->error_distributor,
 190                           &rxrpc_peer_error_distributor);
 191                 spin_lock_init(&peer->lock);
 192                 peer->debug_id = atomic_inc_return(&rxrpc_debug_id);
 193         }
 194
 195         _leave(" = %p", peer);
 196         return peer;
 197 }
 198
 199 /*
 200  * Set up a new peer.
 201  */
 202 static struct rxrpc_peer *rxrpc_create_peer(struct rxrpc_local *local,
 203                                             struct sockaddr_rxrpc *srx,
 204                                             unsigned long hash_key,
 205                                             gfp_t gfp)
 206 {
 207         struct rxrpc_peer *peer;
 208
 209         _enter("");
 210
 211         peer = rxrpc_alloc_peer(local, gfp);
 212         if (peer) {
 213                 peer->hash_key = hash_key;
 214                 memcpy(&peer->srx, srx, sizeof(*srx));
 215
 216                 rxrpc_assess_MTU_size(peer);
 217                 peer->mtu = peer->if_mtu;
 218
 219                 if (srx->transport.family == AF_INET) {
 220                         peer->hdrsize = sizeof(struct iphdr);
 221                         switch (srx->transport_type) {
 222                         case SOCK_DGRAM:
 223                                 peer->hdrsize += sizeof(struct udphdr);
 224                                 break;
 225                         default:
 226                                 BUG();
 227                                 break;
 228                         }
 229                 } else {
 230                         BUG();
 231                 }
 232
 233                 peer->hdrsize += sizeof(struct rxrpc_wire_header);
 234                 peer->maxdata = peer->mtu - peer->hdrsize;
 235         }
 236
 237         _leave(" = %p", peer);
 238         return peer;
 239 }
 240
 241 /*
 242  * obtain a remote transport endpoint for the specified address
 243  */
 244 struct rxrpc_peer *rxrpc_lookup_peer(struct rxrpc_local *local,
 245                                      struct sockaddr_rxrpc *srx, gfp_t gfp)
 246 {
 247         struct rxrpc_peer *peer, *candidate;
 248         unsigned long hash_key = rxrpc_peer_hash_key(local, srx);
 249
 250         _enter("{%d,%d,%pI4+%hu}",
 251                srx->transport_type,
 252                srx->transport_len,
 253                &srx->transport.sin.sin_addr,
 254                ntohs(srx->transport.sin.sin_port));
 255
 256         /* search the peer list first */
 257         rcu_read_lock();
 258         peer = __rxrpc_lookup_peer_rcu(local, srx, hash_key);
 259         if (peer && !rxrpc_get_peer_maybe(peer))
 260                 peer = NULL;
 261         rcu_read_unlock();
 262
 263         if (!peer) {
 264                 /* The peer is not yet present in hash - create a candidate
 265                  * for a new record and then redo the search.
 266                  */
 267                 candidate = rxrpc_create_peer(local, srx, hash_key, gfp);
 268                 if (!candidate) {
 269                         _leave(" = NULL [nomem]");
 270                         return NULL;
 271                 }
 272
 273                 spin_lock(&rxrpc_peer_hash_lock);
 274
 275                 /* Need to check that we aren't racing with someone else */
 276                 peer = __rxrpc_lookup_peer_rcu(local, srx, hash_key);
 277                 if (peer && !rxrpc_get_peer_maybe(peer))
 278                         peer = NULL;
 279                 if (!peer)
 280                         hash_add_rcu(rxrpc_peer_hash,
 281                                      &candidate->hash_link, hash_key);
 282
 283                 spin_unlock(&rxrpc_peer_hash_lock);
 284
 285                 if (peer)
 286                         kfree(candidate);
 287                 else
 288                         peer = candidate;
 289         }
 290
 291         _net("PEER %d {%d,%pI4+%hu}",
 292              peer->debug_id,
 293              peer->srx.transport_type,
 294              &peer->srx.transport.sin.sin_addr,
 295              ntohs(peer->srx.transport.sin.sin_port));
 296
 297         _leave(" = %p {u=%d}", peer, atomic_read(&peer->usage));
 298         return peer;
 299 }
 300
 301 /*
 302  * Discard a ref on a remote peer record.
 303  */
 304 void __rxrpc_put_peer(struct rxrpc_peer *peer)
 305 {
 306         ASSERT(hlist_empty(&peer->error_targets));
 307
 308         spin_lock(&rxrpc_peer_hash_lock);
 309         hash_del_rcu(&peer->hash_link);
 310         spin_unlock(&rxrpc_peer_hash_lock);
 311
 312         kfree_rcu(peer, rcu);
 313 }