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