lib/tnl-neigh-cache.c

   1 /*
   2  * Copyright (c) 2014, 2015, 2016 Nicira, Inc.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at:
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <config.h>
  18
  19 #include "tnl-neigh-cache.h"
  20
  21 #include <inttypes.h>
  22 #include <sys/types.h>
  23 #include <netinet/in.h>
  24 #include <netinet/icmp6.h>
  25 #include <stdlib.h>
  26
  27 #include "bitmap.h"
  28 #include "cmap.h"
  29 #include "coverage.h"
  30 #include "dpif-netdev.h"
  31 #include "openvswitch/dynamic-string.h"
  32 #include "errno.h"
  33 #include "flow.h"
  34 #include "netdev.h"
  35 #include "ovs-thread.h"
  36 #include "packets.h"
  37 #include "openvswitch/poll-loop.h"
  38 #include "seq.h"
  39 #include "socket-util.h"
  40 #include "timeval.h"
  41 #include "unaligned.h"
  42 #include "unixctl.h"
  43 #include "util.h"
  44 #include "openvswitch/vlog.h"
  45
  46
  47 /* In seconds */
  48 #define NEIGH_ENTRY_DEFAULT_IDLE_TIME  (15 * 60)
  49
  50 struct tnl_neigh_entry {
  51     struct cmap_node cmap_node;
  52     struct in6_addr ip;
  53     struct eth_addr mac;
  54     time_t expires;             /* Expiration time. */
  55     char br_name[IFNAMSIZ];
  56 };
  57
  58 static struct cmap table = CMAP_INITIALIZER;
  59 static struct ovs_mutex mutex = OVS_MUTEX_INITIALIZER;
  60
  61 static uint32_t
  62 tnl_neigh_hash(const struct in6_addr *ip)
  63 {
  64     return hash_bytes(ip->s6_addr, 16, 0);
  65 }
  66
  67 static struct tnl_neigh_entry *
  68 tnl_neigh_lookup__(const char br_name[IFNAMSIZ], const struct in6_addr *dst)
  69 {
  70     struct tnl_neigh_entry *neigh;
  71     uint32_t hash;
  72
  73     hash = tnl_neigh_hash(dst);
  74     CMAP_FOR_EACH_WITH_HASH (neigh, cmap_node, hash, &table) {
  75         if (ipv6_addr_equals(&neigh->ip, dst) && !strcmp(neigh->br_name, br_name)) {
  76             if (neigh->expires <= time_now()) {
  77                 return NULL;
  78             }
  79
  80             neigh->expires = time_now() + NEIGH_ENTRY_DEFAULT_IDLE_TIME;
  81             return neigh;
  82         }
  83     }
  84     return NULL;
  85 }
  86
  87 int
  88 tnl_neigh_lookup(const char br_name[IFNAMSIZ], const struct in6_addr *dst,
  89                  struct eth_addr *mac)
  90 {
  91     struct tnl_neigh_entry *neigh;
  92     int res = ENOENT;
  93
  94     neigh = tnl_neigh_lookup__(br_name, dst);
  95     if (neigh) {
  96         *mac = neigh->mac;
  97         res = 0;
  98     }
  99     return res;
 100 }
 101
 102 static void
 103 neigh_entry_free(struct tnl_neigh_entry *neigh)
 104 {
 105     free(neigh);
 106 }
 107
 108 static void
 109 tnl_neigh_delete(struct tnl_neigh_entry *neigh)
 110 {
 111     uint32_t hash = tnl_neigh_hash(&neigh->ip);
 112     cmap_remove(&table, &neigh->cmap_node, hash);
 113     ovsrcu_postpone(neigh_entry_free, neigh);
 114 }
 115
 116 static void
 117 tnl_neigh_set__(const char name[IFNAMSIZ], const struct in6_addr *dst,
 118                 const struct eth_addr mac)
 119 {
 120     ovs_mutex_lock(&mutex);
 121     struct tnl_neigh_entry *neigh = tnl_neigh_lookup__(name, dst);
 122     if (neigh) {
 123         if (eth_addr_equals(neigh->mac, mac)) {
 124             neigh->expires = time_now() + NEIGH_ENTRY_DEFAULT_IDLE_TIME;
 125             ovs_mutex_unlock(&mutex);
 126             return;
 127         }
 128         tnl_neigh_delete(neigh);
 129     }
 130     seq_change(tnl_conf_seq);
 131
 132     neigh = xmalloc(sizeof *neigh);
 133
 134     neigh->ip = *dst;
 135     neigh->mac = mac;
 136     neigh->expires = time_now() + NEIGH_ENTRY_DEFAULT_IDLE_TIME;
 137     ovs_strlcpy(neigh->br_name, name, sizeof neigh->br_name);
 138     cmap_insert(&table, &neigh->cmap_node, tnl_neigh_hash(&neigh->ip));
 139     ovs_mutex_unlock(&mutex);
 140 }
 141
 142 static void
 143 tnl_arp_set(const char name[IFNAMSIZ], ovs_be32 dst,
 144             const struct eth_addr mac)
 145 {
 146     struct in6_addr dst6 = in6_addr_mapped_ipv4(dst);
 147     tnl_neigh_set__(name, &dst6, mac);
 148 }
 149
 150 static int
 151 tnl_arp_snoop(const struct flow *flow, struct flow_wildcards *wc,
 152               const char name[IFNAMSIZ])
 153 {
 154     /* Snoop normal ARP replies and gratuitous ARP requests/replies only */
 155     if (!is_arp(flow)
 156         || (!is_garp(flow, wc) &&
 157             FLOW_WC_GET_AND_MASK_WC(flow, wc, nw_proto) != ARP_OP_REPLY)
 158         || eth_addr_is_zero(FLOW_WC_GET_AND_MASK_WC(flow, wc, arp_sha))) {
 159         return EINVAL;
 160     }
 161
 162     tnl_arp_set(name, FLOW_WC_GET_AND_MASK_WC(flow, wc, nw_src), flow->arp_sha);
 163     return 0;
 164 }
 165
 166 static int
 167 tnl_nd_snoop(const struct flow *flow, struct flow_wildcards *wc,
 168              const char name[IFNAMSIZ])
 169 {
 170     if (!is_nd(flow, wc) || flow->tp_src != htons(ND_NEIGHBOR_ADVERT)) {
 171         return EINVAL;
 172     }
 173     /* - RFC4861 says Neighbor Advertisements sent in response to unicast Neighbor
 174      *   Solicitations SHOULD include the Target link-layer address. However, Linux
 175      *   doesn't. So, the response to Solicitations sent by OVS will include the
 176      *   TLL address and other Advertisements not including it can be ignored.
 177      * - OVS flow extract can set this field to zero in case of packet parsing errors.
 178      *   For details refer miniflow_extract()*/
 179     if (eth_addr_is_zero(FLOW_WC_GET_AND_MASK_WC(flow, wc, arp_tha))) {
 180         return EINVAL;
 181     }
 182
 183     memset(&wc->masks.ipv6_src, 0xff, sizeof wc->masks.ipv6_src);
 184     memset(&wc->masks.ipv6_dst, 0xff, sizeof wc->masks.ipv6_dst);
 185     memset(&wc->masks.nd_target, 0xff, sizeof wc->masks.nd_target);
 186
 187     tnl_neigh_set__(name, &flow->nd_target, flow->arp_tha);
 188     return 0;
 189 }
 190
 191 int
 192 tnl_neigh_snoop(const struct flow *flow, struct flow_wildcards *wc,
 193                 const char name[IFNAMSIZ])
 194 {
 195     int res;
 196     res = tnl_arp_snoop(flow, wc, name);
 197     if (res != EINVAL) {
 198         return res;
 199     }
 200     return tnl_nd_snoop(flow, wc, name);
 201 }
 202
 203 void
 204 tnl_neigh_cache_run(void)
 205 {
 206     struct tnl_neigh_entry *neigh;
 207     bool changed = false;
 208
 209     ovs_mutex_lock(&mutex);
 210     CMAP_FOR_EACH(neigh, cmap_node, &table) {
 211         if (neigh->expires <= time_now()) {
 212             tnl_neigh_delete(neigh);
 213             changed = true;
 214         }
 215     }
 216     ovs_mutex_unlock(&mutex);
 217
 218     if (changed) {
 219         seq_change(tnl_conf_seq);
 220     }
 221 }
 222
 223 void
 224 tnl_neigh_flush(const char br_name[IFNAMSIZ])
 225 {
 226     struct tnl_neigh_entry *neigh;
 227     bool changed = false;
 228
 229     ovs_mutex_lock(&mutex);
 230     CMAP_FOR_EACH (neigh, cmap_node, &table) {
 231         if (!strcmp(neigh->br_name, br_name)) {
 232             tnl_neigh_delete(neigh);
 233             changed = true;
 234         }
 235     }
 236     ovs_mutex_unlock(&mutex);
 237
 238     if (changed) {
 239         seq_change(tnl_conf_seq);
 240     }
 241 }
 242
 243 static void
 244 tnl_neigh_cache_flush(struct unixctl_conn *conn, int argc OVS_UNUSED,
 245                     const char *argv[] OVS_UNUSED, void *aux OVS_UNUSED)
 246 {
 247     struct tnl_neigh_entry *neigh;
 248     bool changed = false;
 249
 250     ovs_mutex_lock(&mutex);
 251     CMAP_FOR_EACH(neigh, cmap_node, &table) {
 252         tnl_neigh_delete(neigh);
 253         changed = true;
 254     }
 255     ovs_mutex_unlock(&mutex);
 256     if (changed) {
 257         seq_change(tnl_conf_seq);
 258     }
 259     unixctl_command_reply(conn, "OK");
 260 }
 261
 262 static int
 263 lookup_any(const char *host_name, struct in6_addr *address)
 264 {
 265     if (addr_is_ipv6(host_name)) {
 266         return lookup_ipv6(host_name, address);
 267     } else {
 268         int r;
 269         struct in_addr ip;
 270         r = lookup_ip(host_name, &ip);
 271         if (r == 0) {
 272             in6_addr_set_mapped_ipv4(address, ip.s_addr);
 273         }
 274         return r;
 275     }
 276     return ENOENT;
 277 }
 278
 279 static void
 280 tnl_neigh_cache_add(struct unixctl_conn *conn, int argc OVS_UNUSED,
 281                     const char *argv[], void *aux OVS_UNUSED)
 282 {
 283     const char *br_name = argv[1];
 284     struct eth_addr mac;
 285     struct in6_addr ip6;
 286
 287     if (lookup_any(argv[2], &ip6) != 0) {
 288         unixctl_command_reply_error(conn, "bad IP address");
 289         return;
 290     }
 291
 292     if (!eth_addr_from_string(argv[3], &mac)) {
 293         unixctl_command_reply_error(conn, "bad MAC address");
 294         return;
 295     }
 296
 297     tnl_neigh_set__(br_name, &ip6, mac);
 298     unixctl_command_reply(conn, "OK");
 299 }
 300
 301 static void
 302 tnl_neigh_cache_show(struct unixctl_conn *conn, int argc OVS_UNUSED,
 303                      const char *argv[] OVS_UNUSED, void *aux OVS_UNUSED)
 304 {
 305     struct ds ds = DS_EMPTY_INITIALIZER;
 306     struct tnl_neigh_entry *neigh;
 307
 308     ds_put_cstr(&ds, "IP                                            MAC                 Bridge\n");
 309     ds_put_cstr(&ds, "==========================================================================\n");
 310     ovs_mutex_lock(&mutex);
 311     CMAP_FOR_EACH(neigh, cmap_node, &table) {
 312         int start_len, need_ws;
 313
 314         start_len = ds.length;
 315         ipv6_format_mapped(&neigh->ip, &ds);
 316
 317         need_ws = INET6_ADDRSTRLEN - (ds.length - start_len);
 318         ds_put_char_multiple(&ds, ' ', need_ws);
 319
 320         ds_put_format(&ds, ETH_ADDR_FMT"   %s",
 321                       ETH_ADDR_ARGS(neigh->mac), neigh->br_name);
 322         if (neigh->expires <= time_now()) {
 323             ds_put_format(&ds, " STALE");
 324         }
 325         ds_put_char(&ds, '\n');
 326
 327     }
 328     ovs_mutex_unlock(&mutex);
 329     unixctl_command_reply(conn, ds_cstr(&ds));
 330     ds_destroy(&ds);
 331 }
 332
 333 void
 334 tnl_neigh_cache_init(void)
 335 {
 336     unixctl_command_register("tnl/arp/show", "", 0, 0, tnl_neigh_cache_show, NULL);
 337     unixctl_command_register("tnl/arp/set", "BRIDGE IP MAC", 3, 3, tnl_neigh_cache_add, NULL);
 338     unixctl_command_register("tnl/arp/flush", "", 0, 0, tnl_neigh_cache_flush, NULL);
 339     unixctl_command_register("tnl/neigh/show", "", 0, 0, tnl_neigh_cache_show, NULL);
 340     unixctl_command_register("tnl/neigh/set", "BRIDGE IP MAC", 3, 3, tnl_neigh_cache_add, NULL);
 341     unixctl_command_register("tnl/neigh/flush", "", 0, 0, tnl_neigh_cache_flush, NULL);
 342 }