lib/tnl-ports.c

   1 /*
   2  * Copyright (c) 2014, 2015 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-ports.h"
  20
  21 #include <stddef.h>
  22 #include <stdint.h>
  23 #include <string.h>
  24
  25 #include "classifier.h"
  26 #include "openvswitch/dynamic-string.h"
  27 #include "hash.h"
  28 #include "openvswitch/list.h"
  29 #include "netdev.h"
  30 #include "openvswitch/ofpbuf.h"
  31 #include "ovs-thread.h"
  32 #include "odp-util.h"
  33 #include "ovs-thread.h"
  34 #include "unixctl.h"
  35 #include "util.h"
  36
  37 static struct ovs_mutex mutex = OVS_MUTEX_INITIALIZER;
  38 static struct classifier cls;   /* Tunnel ports. */
  39
  40 struct ip_device {
  41     struct netdev *dev;
  42     struct eth_addr mac;
  43     struct in6_addr *addr;
  44     int n_addr;
  45     uint64_t change_seq;
  46     struct ovs_list node;
  47     char dev_name[IFNAMSIZ];
  48 };
  49
  50 static struct ovs_list addr_list;
  51
  52 struct tnl_port {
  53     odp_port_t port;
  54     ovs_be16 tp_port;
  55     uint8_t nw_proto;
  56     char dev_name[IFNAMSIZ];
  57     struct ovs_list node;
  58 };
  59
  60 static struct ovs_list port_list;
  61
  62 struct tnl_port_in {
  63     struct cls_rule cr;
  64     odp_port_t portno;
  65     struct ovs_refcount ref_cnt;
  66     char dev_name[IFNAMSIZ];
  67 };
  68
  69 static struct tnl_port_in *
  70 tnl_port_cast(const struct cls_rule *cr)
  71 {
  72     BUILD_ASSERT_DECL(offsetof(struct tnl_port_in, cr) == 0);
  73
  74     return CONTAINER_OF(cr, struct tnl_port_in, cr);
  75 }
  76
  77 static void
  78 tnl_port_free(struct tnl_port_in *p)
  79 {
  80     cls_rule_destroy(&p->cr);
  81     free(p);
  82 }
  83
  84 static void
  85 tnl_port_init_flow(struct flow *flow, struct eth_addr mac,
  86                    struct in6_addr *addr, uint8_t nw_proto, ovs_be16 tp_port)
  87 {
  88     memset(flow, 0, sizeof *flow);
  89
  90     flow->dl_dst = mac;
  91     if (IN6_IS_ADDR_V4MAPPED(addr)) {
  92         flow->dl_type = htons(ETH_TYPE_IP);
  93         flow->nw_dst = in6_addr_get_mapped_ipv4(addr);
  94     } else {
  95         flow->dl_type = htons(ETH_TYPE_IPV6);
  96         flow->ipv6_dst = *addr;
  97     }
  98
  99     flow->nw_proto = nw_proto;
 100     flow->tp_dst = tp_port;
 101 }
 102
 103 static void
 104 map_insert(odp_port_t port, struct eth_addr mac, struct in6_addr *addr,
 105            uint8_t nw_proto, ovs_be16 tp_port, const char dev_name[])
 106 {
 107     const struct cls_rule *cr;
 108     struct tnl_port_in *p;
 109     struct match match;
 110
 111     memset(&match, 0, sizeof match);
 112     tnl_port_init_flow(&match.flow, mac, addr, nw_proto, tp_port);
 113
 114     do {
 115         cr = classifier_lookup(&cls, CLS_MAX_VERSION, &match.flow, NULL);
 116         p = tnl_port_cast(cr);
 117         /* Try again if the rule was released before we get the reference. */
 118     } while (p && !ovs_refcount_try_ref_rcu(&p->ref_cnt));
 119
 120     if (!p) {
 121         p = xzalloc(sizeof *p);
 122         p->portno = port;
 123
 124         match.wc.masks.dl_type = OVS_BE16_MAX;
 125         match.wc.masks.nw_proto = 0xff;
 126          /* XXX: No fragments support. */
 127         match.wc.masks.nw_frag = FLOW_NW_FRAG_MASK;
 128
 129         /* 'tp_port' is zero for GRE tunnels. In this case it
 130          * doesn't make sense to match on UDP port numbers. */
 131         if (tp_port) {
 132             match.wc.masks.tp_dst = OVS_BE16_MAX;
 133         }
 134         if (IN6_IS_ADDR_V4MAPPED(addr)) {
 135             match.wc.masks.nw_dst = OVS_BE32_MAX;
 136         } else {
 137             match.wc.masks.ipv6_dst = in6addr_exact;
 138         }
 139         match.wc.masks.vlan_tci = OVS_BE16_MAX;
 140         memset(&match.wc.masks.dl_dst, 0xff, sizeof (struct eth_addr));
 141
 142         cls_rule_init(&p->cr, &match, 0); /* Priority == 0. */
 143         ovs_refcount_init(&p->ref_cnt);
 144         ovs_strlcpy(p->dev_name, dev_name, sizeof p->dev_name);
 145
 146         classifier_insert(&cls, &p->cr, CLS_MIN_VERSION, NULL, 0);
 147     }
 148 }
 149
 150 static void
 151 map_insert_ipdev__(struct ip_device *ip_dev, char dev_name[],
 152                    odp_port_t port, uint8_t nw_proto, ovs_be16 tp_port)
 153 {
 154     if (ip_dev->n_addr) {
 155         int i;
 156
 157         for (i = 0; i < ip_dev->n_addr; i++) {
 158             map_insert(port, ip_dev->mac, &ip_dev->addr[i],
 159                        nw_proto, tp_port, dev_name);
 160         }
 161     }
 162 }
 163
 164 static uint8_t
 165 tnl_type_to_nw_proto(const char type[])
 166 {
 167     if (!strcmp(type, "geneve")) {
 168         return IPPROTO_UDP;
 169     }
 170     if (!strcmp(type, "stt")) {
 171         return IPPROTO_TCP;
 172     }
 173     if (!strcmp(type, "gre")) {
 174         return IPPROTO_GRE;
 175     }
 176     if (!strcmp(type, "vxlan")) {
 177         return IPPROTO_UDP;
 178     }
 179     return 0;
 180 }
 181
 182 void
 183 tnl_port_map_insert(odp_port_t port, ovs_be16 tp_port,
 184                     const char dev_name[], const char type[])
 185 {
 186     struct tnl_port *p;
 187     struct ip_device *ip_dev;
 188     uint8_t nw_proto;
 189
 190     nw_proto = tnl_type_to_nw_proto(type);
 191     if (!nw_proto) {
 192         return;
 193     }
 194
 195     ovs_mutex_lock(&mutex);
 196     LIST_FOR_EACH(p, node, &port_list) {
 197         if (tp_port == p->tp_port && p->nw_proto == nw_proto) {
 198              goto out;
 199         }
 200     }
 201
 202     p = xzalloc(sizeof *p);
 203     p->port = port;
 204     p->tp_port = tp_port;
 205     p->nw_proto = nw_proto;
 206     ovs_strlcpy(p->dev_name, dev_name, sizeof p->dev_name);
 207     ovs_list_insert(&port_list, &p->node);
 208
 209     LIST_FOR_EACH(ip_dev, node, &addr_list) {
 210         map_insert_ipdev__(ip_dev, p->dev_name, p->port, p->nw_proto, p->tp_port);
 211     }
 212
 213 out:
 214     ovs_mutex_unlock(&mutex);
 215 }
 216
 217 static void
 218 tnl_port_unref(const struct cls_rule *cr)
 219 {
 220     struct tnl_port_in *p = tnl_port_cast(cr);
 221
 222     if (cr && ovs_refcount_unref_relaxed(&p->ref_cnt) == 1) {
 223         if (classifier_remove(&cls, cr)) {
 224             ovsrcu_postpone(tnl_port_free, p);
 225         }
 226     }
 227 }
 228
 229 static void
 230 map_delete(struct eth_addr mac, struct in6_addr *addr,
 231            ovs_be16 tp_port, uint8_t nw_proto)
 232 {
 233     const struct cls_rule *cr;
 234     struct flow flow;
 235
 236     tnl_port_init_flow(&flow, mac, addr, nw_proto, tp_port);
 237
 238     cr = classifier_lookup(&cls, CLS_MAX_VERSION, &flow, NULL);
 239     tnl_port_unref(cr);
 240 }
 241
 242 static void
 243 ipdev_map_delete(struct ip_device *ip_dev, ovs_be16 tp_port, uint8_t nw_proto)
 244 {
 245     if (ip_dev->n_addr) {
 246         int i;
 247
 248         for (i = 0; i < ip_dev->n_addr; i++) {
 249             map_delete(ip_dev->mac, &ip_dev->addr[i], tp_port, nw_proto);
 250         }
 251     }
 252 }
 253
 254 void
 255 tnl_port_map_delete(ovs_be16 tp_port, const char type[])
 256 {
 257     struct tnl_port *p, *next;
 258     struct ip_device *ip_dev;
 259     bool found = false;
 260     uint8_t nw_proto;
 261
 262     nw_proto = tnl_type_to_nw_proto(type);
 263
 264     ovs_mutex_lock(&mutex);
 265     LIST_FOR_EACH_SAFE(p, next, node, &port_list) {
 266         if (p->tp_port == tp_port && p->nw_proto == nw_proto) {
 267             ovs_list_remove(&p->node);
 268             found = true;
 269             break;
 270         }
 271     }
 272
 273     if (!found) {
 274         goto out;
 275     }
 276     LIST_FOR_EACH(ip_dev, node, &addr_list) {
 277         ipdev_map_delete(ip_dev, p->tp_port, p->nw_proto);
 278     }
 279
 280     free(p);
 281 out:
 282     ovs_mutex_unlock(&mutex);
 283 }
 284
 285 /* 'flow' is non-const to allow for temporary modifications during the lookup.
 286  * Any changes are restored before returning. */
 287 odp_port_t
 288 tnl_port_map_lookup(struct flow *flow, struct flow_wildcards *wc)
 289 {
 290     const struct cls_rule *cr = classifier_lookup(&cls, CLS_MAX_VERSION, flow,
 291                                                   wc);
 292
 293     return (cr) ? tnl_port_cast(cr)->portno : ODPP_NONE;
 294 }
 295
 296 static void
 297 tnl_port_show_v(struct ds *ds)
 298 {
 299     const struct tnl_port_in *p;
 300
 301     CLS_FOR_EACH(p, cr, &cls) {
 302         struct odputil_keybuf keybuf;
 303         struct odputil_keybuf maskbuf;
 304         struct flow flow;
 305         const struct nlattr *key, *mask;
 306         size_t key_len, mask_len;
 307         struct flow_wildcards wc;
 308         struct ofpbuf buf;
 309         struct odp_flow_key_parms odp_parms = {
 310             .flow = &flow,
 311             .mask = &wc.masks,
 312         };
 313
 314         ds_put_format(ds, "%s (%"PRIu32") : ", p->dev_name, p->portno);
 315         minimask_expand(p->cr.match.mask, &wc);
 316         miniflow_expand(p->cr.match.flow, &flow);
 317
 318         /* Key. */
 319         odp_parms.odp_in_port = flow.in_port.odp_port;
 320         odp_parms.support.recirc = true;
 321         ofpbuf_use_stack(&buf, &keybuf, sizeof keybuf);
 322         odp_flow_key_from_flow(&odp_parms, &buf);
 323         key = buf.data;
 324         key_len = buf.size;
 325
 326         /* mask*/
 327         odp_parms.odp_in_port = wc.masks.in_port.odp_port;
 328         odp_parms.support.recirc = false;
 329         ofpbuf_use_stack(&buf, &maskbuf, sizeof maskbuf);
 330         odp_flow_key_from_mask(&odp_parms, &buf);
 331         mask = buf.data;
 332         mask_len = buf.size;
 333
 334         /* build string. */
 335         odp_flow_format(key, key_len, mask, mask_len, NULL, ds, false);
 336         ds_put_format(ds, "\n");
 337     }
 338 }
 339
 340 static void
 341 tnl_port_show(struct unixctl_conn *conn, int argc OVS_UNUSED,
 342                const char *argv[] OVS_UNUSED, void *aux OVS_UNUSED)
 343 {
 344     struct ds ds = DS_EMPTY_INITIALIZER;
 345     struct tnl_port *p;
 346
 347     ds_put_format(&ds, "Listening ports:\n");
 348     ovs_mutex_lock(&mutex);
 349     if (argc > 1) {
 350         if (!strcasecmp(argv[1], "-v")) {
 351             tnl_port_show_v(&ds);
 352             goto out;
 353         }
 354     }
 355
 356     LIST_FOR_EACH(p, node, &port_list) {
 357         ds_put_format(&ds, "%s (%"PRIu32")\n", p->dev_name, p->port);
 358     }
 359
 360 out:
 361     ovs_mutex_unlock(&mutex);
 362     unixctl_command_reply(conn, ds_cstr(&ds));
 363     ds_destroy(&ds);
 364 }
 365
 366 static void
 367 map_insert_ipdev(struct ip_device *ip_dev)
 368 {
 369     struct tnl_port *p;
 370
 371     LIST_FOR_EACH(p, node, &port_list) {
 372         map_insert_ipdev__(ip_dev, p->dev_name, p->port, p->nw_proto, p->tp_port);
 373     }
 374 }
 375
 376 static void
 377 insert_ipdev__(struct netdev *dev,
 378                struct in6_addr *addr, int n_addr)
 379 {
 380     struct ip_device *ip_dev;
 381     enum netdev_flags flags;
 382     int error;
 383
 384     error = netdev_get_flags(dev, &flags);
 385     if (error || (flags & NETDEV_LOOPBACK)) {
 386         goto err;
 387     }
 388
 389     ip_dev = xzalloc(sizeof *ip_dev);
 390     ip_dev->dev = netdev_ref(dev);
 391     ip_dev->change_seq = netdev_get_change_seq(dev);
 392     error = netdev_get_etheraddr(ip_dev->dev, &ip_dev->mac);
 393     if (error) {
 394         goto err_free_ipdev;
 395     }
 396     ip_dev->addr = addr;
 397     ip_dev->n_addr = n_addr;
 398     ovs_strlcpy(ip_dev->dev_name, netdev_get_name(dev), sizeof ip_dev->dev_name);
 399     ovs_list_insert(&addr_list, &ip_dev->node);
 400     map_insert_ipdev(ip_dev);
 401     return;
 402
 403 err_free_ipdev:
 404     netdev_close(ip_dev->dev);
 405     free(ip_dev);
 406 err:
 407     free(addr);
 408 }
 409
 410 static void
 411 insert_ipdev(const char dev_name[])
 412 {
 413     struct in6_addr *addr, *mask;
 414     struct netdev *dev;
 415     int error, n_in6;
 416
 417     error = netdev_open(dev_name, NULL, &dev);
 418     if (error) {
 419         return;
 420     }
 421
 422     error = netdev_get_addr_list(dev, &addr, &mask, &n_in6);
 423     if (error) {
 424         netdev_close(dev);
 425         return;
 426     }
 427     free(mask);
 428     insert_ipdev__(dev, addr, n_in6);
 429     netdev_close(dev);
 430 }
 431
 432 static void
 433 delete_ipdev(struct ip_device *ip_dev)
 434 {
 435     struct tnl_port *p;
 436
 437     LIST_FOR_EACH(p, node, &port_list) {
 438         ipdev_map_delete(ip_dev, p->tp_port, p->nw_proto);
 439     }
 440
 441     ovs_list_remove(&ip_dev->node);
 442     netdev_close(ip_dev->dev);
 443     free(ip_dev->addr);
 444     free(ip_dev);
 445 }
 446
 447 void
 448 tnl_port_map_insert_ipdev(const char dev_name[])
 449 {
 450     struct ip_device *ip_dev, *next;
 451
 452     ovs_mutex_lock(&mutex);
 453
 454     LIST_FOR_EACH_SAFE(ip_dev, next, node, &addr_list) {
 455         if (!strcmp(netdev_get_name(ip_dev->dev), dev_name)) {
 456             if (ip_dev->change_seq == netdev_get_change_seq(ip_dev->dev)) {
 457                 goto out;
 458             }
 459             /* Address changed. */
 460             delete_ipdev(ip_dev);
 461         }
 462     }
 463     insert_ipdev(dev_name);
 464
 465 out:
 466     ovs_mutex_unlock(&mutex);
 467 }
 468
 469 void
 470 tnl_port_map_delete_ipdev(const char dev_name[])
 471 {
 472     struct ip_device *ip_dev, *next;
 473
 474     ovs_mutex_lock(&mutex);
 475     LIST_FOR_EACH_SAFE(ip_dev, next, node, &addr_list) {
 476         if (!strcmp(netdev_get_name(ip_dev->dev), dev_name)) {
 477             delete_ipdev(ip_dev);
 478         }
 479     }
 480     ovs_mutex_unlock(&mutex);
 481 }
 482
 483 void
 484 tnl_port_map_run(void)
 485 {
 486     struct ip_device *ip_dev, *next;
 487
 488     ovs_mutex_lock(&mutex);
 489     LIST_FOR_EACH_SAFE(ip_dev, next, node, &addr_list) {
 490         char dev_name[IFNAMSIZ];
 491
 492         if (ip_dev->change_seq == netdev_get_change_seq(ip_dev->dev)) {
 493             continue;
 494         }
 495
 496         /* Address changed. */
 497         ovs_strlcpy(dev_name, ip_dev->dev_name, sizeof dev_name);
 498         delete_ipdev(ip_dev);
 499         insert_ipdev(dev_name);
 500     }
 501     ovs_mutex_unlock(&mutex);
 502 }
 503
 504 void
 505 tnl_port_map_init(void)
 506 {
 507     classifier_init(&cls, flow_segment_u64s);
 508     ovs_list_init(&addr_list);
 509     ovs_list_init(&port_list);
 510     unixctl_command_register("tnl/ports/show", "-v", 0, 1, tnl_port_show, NULL);
 511 }