vswitchd/bridge.c

   1 /* Copyright (c) 2008, 2009, 2010 Nicira Networks
   2  *
   3  * Licensed under the Apache License, Version 2.0 (the "License");
   4  * you may not use this file except in compliance with the License.
   5  * You may obtain a copy of the License at:
   6  *
   7  *     http://www.apache.org/licenses/LICENSE-2.0
   8  *
   9  * Unless required by applicable law or agreed to in writing, software
  10  * distributed under the License is distributed on an "AS IS" BASIS,
  11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12  * See the License for the specific language governing permissions and
  13  * limitations under the License.
  14  */
  15
  16 #include <config.h>
  17 #include "bridge.h"
  18 #include <assert.h>
  19 #include <errno.h>
  20 #include <arpa/inet.h>
  21 #include <ctype.h>
  22 #include <inttypes.h>
  23 #include <sys/socket.h>
  24 #include <net/if.h>
  25 #include <openflow/openflow.h>
  26 #include <signal.h>
  27 #include <stdlib.h>
  28 #include <strings.h>
  29 #include <sys/stat.h>
  30 #include <sys/socket.h>
  31 #include <sys/types.h>
  32 #include <unistd.h>
  33 #include "bitmap.h"
  34 #include "coverage.h"
  35 #include "dirs.h"
  36 #include "dynamic-string.h"
  37 #include "flow.h"
  38 #include "hash.h"
  39 #include "jsonrpc.h"
  40 #include "list.h"
  41 #include "mac-learning.h"
  42 #include "netdev.h"
  43 #include "xflow-util.h"
  44 #include "ofp-print.h"
  45 #include "ofpbuf.h"
  46 #include "ofproto/netflow.h"
  47 #include "ofproto/ofproto.h"
  48 #include "packets.h"
  49 #include "poll-loop.h"
  50 #include "port-array.h"
  51 #include "proc-net-compat.h"
  52 #include "process.h"
  53 #include "sha1.h"
  54 #include "shash.h"
  55 #include "socket-util.h"
  56 #include "stream-ssl.h"
  57 #include "svec.h"
  58 #include "timeval.h"
  59 #include "util.h"
  60 #include "unixctl.h"
  61 #include "vconn.h"
  62 #include "vswitchd/vswitch-idl.h"
  63 #include "xenserver.h"
  64 #include "xfif.h"
  65 #include "xtoxll.h"
  66 #include "sflow_api.h"
  67
  68 #define THIS_MODULE VLM_bridge
  69 #include "vlog.h"
  70
  71 struct dst {
  72     uint16_t vlan;
  73     uint16_t xf_ifidx;
  74 };
  75
  76 struct iface {
  77     /* These members are always valid. */
  78     struct port *port;          /* Containing port. */
  79     size_t port_ifidx;          /* Index within containing port. */
  80     char *name;                 /* Host network device name. */
  81     tag_type tag;               /* Tag associated with this interface. */
  82     long long delay_expires;    /* Time after which 'enabled' may change. */
  83
  84     /* These members are valid only after bridge_reconfigure() causes them to
  85      * be initialized. */
  86     int xf_ifidx;               /* Index within kernel datapath. */
  87     struct netdev *netdev;      /* Network device. */
  88     bool enabled;               /* May be chosen for flows? */
  89     const struct ovsrec_interface *cfg;
  90 };
  91
  92 #define BOND_MASK 0xff
  93 struct bond_entry {
  94     int iface_idx;              /* Index of assigned iface, or -1 if none. */
  95     uint64_t tx_bytes;          /* Count of bytes recently transmitted. */
  96     tag_type iface_tag;         /* Tag associated with iface_idx. */
  97 };
  98
  99 #define MAX_MIRRORS 32
 100 typedef uint32_t mirror_mask_t;
 101 #define MIRROR_MASK_C(X) UINT32_C(X)
 102 BUILD_ASSERT_DECL(sizeof(mirror_mask_t) * CHAR_BIT >= MAX_MIRRORS);
 103 struct mirror {
 104     struct bridge *bridge;
 105     size_t idx;
 106     char *name;
 107
 108     /* Selection criteria. */
 109     struct shash src_ports;     /* Name is port name; data is always NULL. */
 110     struct shash dst_ports;     /* Name is port name; data is always NULL. */
 111     int *vlans;
 112     size_t n_vlans;
 113
 114     /* Output. */
 115     struct port *out_port;
 116     int out_vlan;
 117 };
 118
 119 #define FLOOD_PORT ((struct port *) 1) /* The 'flood' output port. */
 120 struct port {
 121     struct bridge *bridge;
 122     size_t port_idx;
 123     int vlan;                   /* -1=trunk port, else a 12-bit VLAN ID. */
 124     unsigned long *trunks;      /* Bitmap of trunked VLANs, if 'vlan' == -1.
 125                                  * NULL if all VLANs are trunked. */
 126     const struct ovsrec_port *cfg;
 127     char *name;
 128
 129     /* An ordinary bridge port has 1 interface.
 130      * A bridge port for bonding has at least 2 interfaces. */
 131     struct iface **ifaces;
 132     size_t n_ifaces, allocated_ifaces;
 133
 134     /* Bonding info. */
 135     struct bond_entry *bond_hash; /* An array of (BOND_MASK + 1) elements. */
 136     int active_iface;           /* Ifidx on which bcasts accepted, or -1. */
 137     tag_type active_iface_tag;  /* Tag for bcast flows. */
 138     tag_type no_ifaces_tag;     /* Tag for flows when all ifaces disabled. */
 139     int updelay, downdelay;     /* Delay before iface goes up/down, in ms. */
 140     bool bond_compat_is_stale;  /* Need to call port_update_bond_compat()? */
 141     bool bond_fake_iface;       /* Fake a bond interface for legacy compat? */
 142     long bond_next_fake_iface_update; /* Next update to fake bond stats. */
 143     int bond_rebalance_interval; /* Interval between rebalances, in ms. */
 144     long long int bond_next_rebalance; /* Next rebalancing time. */
 145
 146     /* Port mirroring info. */
 147     mirror_mask_t src_mirrors;  /* Mirrors triggered when packet received. */
 148     mirror_mask_t dst_mirrors;  /* Mirrors triggered when packet sent. */
 149     bool is_mirror_output_port; /* Does port mirroring send frames here? */
 150 };
 151
 152 #define DP_MAX_PORTS 255
 153 struct bridge {
 154     struct list node;           /* Node in global list of bridges. */
 155     char *name;                 /* User-specified arbitrary name. */
 156     struct mac_learning *ml;    /* MAC learning table. */
 157     uint8_t default_ea[ETH_ADDR_LEN]; /* Default MAC. */
 158     const struct ovsrec_bridge *cfg;
 159
 160     /* OpenFlow switch processing. */
 161     struct ofproto *ofproto;    /* OpenFlow switch. */
 162
 163     /* Kernel datapath information. */
 164     struct xfif *xfif;          /* Datapath. */
 165     struct port_array ifaces;   /* Indexed by kernel datapath port number. */
 166
 167     /* Bridge ports. */
 168     struct port **ports;
 169     size_t n_ports, allocated_ports;
 170     struct shash iface_by_name; /* "struct iface"s indexed by name. */
 171     struct shash port_by_name;  /* "struct port"s indexed by name. */
 172
 173     /* Bonding. */
 174     bool has_bonded_ports;
 175
 176     /* Flow tracking. */
 177     bool flush;
 178
 179     /* Port mirroring. */
 180     struct mirror *mirrors[MAX_MIRRORS];
 181 };
 182
 183 /* List of all bridges. */
 184 static struct list all_bridges = LIST_INITIALIZER(&all_bridges);
 185
 186 /* OVSDB IDL used to obtain configuration. */
 187 static struct ovsdb_idl *idl;
 188
 189 /* Each time this timer expires, the bridge fetches statistics for every
 190  * interface and pushes them into the database. */
 191 #define IFACE_STATS_INTERVAL (5 * 1000) /* In milliseconds. */
 192 static long long int iface_stats_timer = LLONG_MIN;
 193
 194 static struct bridge *bridge_create(const struct ovsrec_bridge *br_cfg);
 195 static void bridge_destroy(struct bridge *);
 196 static struct bridge *bridge_lookup(const char *name);
 197 static unixctl_cb_func bridge_unixctl_dump_flows;
 198 static unixctl_cb_func bridge_unixctl_reconnect;
 199 static int bridge_run_one(struct bridge *);
 200 static size_t bridge_get_controllers(const struct ovsrec_open_vswitch *ovs_cfg,
 201                                      const struct bridge *br,
 202                                      struct ovsrec_controller ***controllersp);
 203 static void bridge_reconfigure_one(const struct ovsrec_open_vswitch *,
 204                                    struct bridge *);
 205 static void bridge_reconfigure_remotes(const struct ovsrec_open_vswitch *,
 206                                        struct bridge *,
 207                                        const struct sockaddr_in *managers,
 208                                        size_t n_managers);
 209 static void bridge_get_all_ifaces(const struct bridge *, struct shash *ifaces);
 210 static void bridge_fetch_dp_ifaces(struct bridge *);
 211 static void bridge_flush(struct bridge *);
 212 static void bridge_pick_local_hw_addr(struct bridge *,
 213                                       uint8_t ea[ETH_ADDR_LEN],
 214                                       struct iface **hw_addr_iface);
 215 static uint64_t bridge_pick_datapath_id(struct bridge *,
 216                                         const uint8_t bridge_ea[ETH_ADDR_LEN],
 217                                         struct iface *hw_addr_iface);
 218 static struct iface *bridge_get_local_iface(struct bridge *);
 219 static uint64_t dpid_from_hash(const void *, size_t nbytes);
 220
 221 static unixctl_cb_func bridge_unixctl_fdb_show;
 222
 223 static void bond_init(void);
 224 static void bond_run(struct bridge *);
 225 static void bond_wait(struct bridge *);
 226 static void bond_rebalance_port(struct port *);
 227 static void bond_send_learning_packets(struct port *);
 228 static void bond_enable_slave(struct iface *iface, bool enable);
 229
 230 static struct port *port_create(struct bridge *, const char *name);
 231 static void port_reconfigure(struct port *, const struct ovsrec_port *);
 232 static void port_del_ifaces(struct port *, const struct ovsrec_port *);
 233 static void port_destroy(struct port *);
 234 static struct port *port_lookup(const struct bridge *, const char *name);
 235 static struct iface *port_lookup_iface(const struct port *, const char *name);
 236 static struct port *port_from_xf_ifidx(const struct bridge *,
 237                                        uint16_t xf_ifidx);
 238 static void port_update_bond_compat(struct port *);
 239 static void port_update_vlan_compat(struct port *);
 240 static void port_update_bonding(struct port *);
 241
 242 static struct mirror *mirror_create(struct bridge *, const char *name);
 243 static void mirror_destroy(struct mirror *);
 244 static void mirror_reconfigure(struct bridge *);
 245 static void mirror_reconfigure_one(struct mirror *, struct ovsrec_mirror *);
 246 static bool vlan_is_mirrored(const struct mirror *, int vlan);
 247
 248 static struct iface *iface_create(struct port *port,
 249                                   const struct ovsrec_interface *if_cfg);
 250 static void iface_destroy(struct iface *);
 251 static struct iface *iface_lookup(const struct bridge *, const char *name);
 252 static struct iface *iface_from_xf_ifidx(const struct bridge *,
 253                                          uint16_t xf_ifidx);
 254 static bool iface_is_internal(const struct bridge *, const char *name);
 255 static void iface_set_mac(struct iface *);
 256 static void iface_update_qos(struct iface *, const struct ovsrec_qos *);
 257
 258 /* Hooks into ofproto processing. */
 259 static struct ofhooks bridge_ofhooks;
 260 \f
 261 /* Public functions. */
 262
 263 /* Initializes the bridge module, configuring it to obtain its configuration
 264  * from an OVSDB server accessed over 'remote', which should be a string in a
 265  * form acceptable to ovsdb_idl_create(). */
 266 void
 267 bridge_init(const char *remote)
 268 {
 269     /* Create connection to database. */
 270     idl = ovsdb_idl_create(remote, &ovsrec_idl_class);
 271
 272     /* Register unixctl commands. */
 273     unixctl_command_register("fdb/show", bridge_unixctl_fdb_show, NULL);
 274     unixctl_command_register("bridge/dump-flows", bridge_unixctl_dump_flows,
 275                              NULL);
 276     unixctl_command_register("bridge/reconnect", bridge_unixctl_reconnect,
 277                              NULL);
 278     bond_init();
 279 }
 280
 281 /* Performs configuration that is only necessary once at ovs-vswitchd startup,
 282  * but for which the ovs-vswitchd configuration 'cfg' is required. */
 283 static void
 284 bridge_configure_once(const struct ovsrec_open_vswitch *cfg)
 285 {
 286     static bool already_configured_once;
 287     struct svec bridge_names;
 288     struct svec xfif_names, xfif_types;
 289     size_t i;
 290
 291     /* Only do this once per ovs-vswitchd run. */
 292     if (already_configured_once) {
 293         return;
 294     }
 295     already_configured_once = true;
 296
 297     iface_stats_timer = time_msec() + IFACE_STATS_INTERVAL;
 298
 299     /* Get all the configured bridges' names from 'cfg' into 'bridge_names'. */
 300     svec_init(&bridge_names);
 301     for (i = 0; i < cfg->n_bridges; i++) {
 302         svec_add(&bridge_names, cfg->bridges[i]->name);
 303     }
 304     svec_sort(&bridge_names);
 305
 306     /* Iterate over all system xfifs and delete any of them that do not appear
 307      * in 'cfg'. */
 308     svec_init(&xfif_names);
 309     svec_init(&xfif_types);
 310     xf_enumerate_types(&xfif_types);
 311     for (i = 0; i < xfif_types.n; i++) {
 312         struct xfif *xfif;
 313         int retval;
 314         size_t j;
 315
 316         xf_enumerate_names(xfif_types.names[i], &xfif_names);
 317
 318         /* For each xfif... */
 319         for (j = 0; j < xfif_names.n; j++) {
 320             retval = xfif_open(xfif_names.names[j], xfif_types.names[i], &xfif);
 321             if (!retval) {
 322                 struct svec all_names;
 323                 size_t k;
 324
 325                 /* ...check whether any of its names is in 'bridge_names'. */
 326                 svec_init(&all_names);
 327                 xfif_get_all_names(xfif, &all_names);
 328                 for (k = 0; k < all_names.n; k++) {
 329                     if (svec_contains(&bridge_names, all_names.names[k])) {
 330                         goto found;
 331                     }
 332                 }
 333
 334                 /* No.  Delete the xfif. */
 335                 xfif_delete(xfif);
 336
 337             found:
 338                 svec_destroy(&all_names);
 339                 xfif_close(xfif);
 340             }
 341         }
 342     }
 343     svec_destroy(&bridge_names);
 344     svec_destroy(&xfif_names);
 345     svec_destroy(&xfif_types);
 346 }
 347
 348 #ifdef HAVE_OPENSSL
 349 static void
 350 bridge_configure_ssl(const struct ovsrec_ssl *ssl)
 351 {
 352     /* XXX SSL should be configurable on a per-bridge basis. */
 353     if (ssl) {
 354         stream_ssl_set_private_key_file(ssl->private_key);
 355         stream_ssl_set_certificate_file(ssl->certificate);
 356         stream_ssl_set_ca_cert_file(ssl->ca_cert, ssl->bootstrap_ca_cert);
 357     }
 358 }
 359 #endif
 360
 361 /* Attempt to create the network device 'iface_name' through the netdev
 362  * library. */
 363 static int
 364 set_up_iface(const struct ovsrec_interface *iface_cfg, struct iface *iface,
 365              bool create)
 366 {
 367     struct shash options;
 368     int error = 0;
 369     size_t i;
 370
 371     shash_init(&options);
 372     for (i = 0; i < iface_cfg->n_options; i++) {
 373         shash_add(&options, iface_cfg->key_options[i],
 374                   xstrdup(iface_cfg->value_options[i]));
 375     }
 376
 377     if (create) {
 378         struct netdev_options netdev_options;
 379
 380         memset(&netdev_options, 0, sizeof netdev_options);
 381         netdev_options.name = iface_cfg->name;
 382         if (!strcmp(iface_cfg->type, "internal")) {
 383             /* An "internal" config type maps to a netdev "system" type. */
 384             netdev_options.type = "system";
 385         } else {
 386             netdev_options.type = iface_cfg->type;
 387         }
 388         netdev_options.args = &options;
 389         netdev_options.ethertype = NETDEV_ETH_TYPE_NONE;
 390         error = netdev_open(&netdev_options, &iface->netdev);
 391
 392         if (iface->netdev) {
 393             netdev_get_carrier(iface->netdev, &iface->enabled);
 394         }
 395     } else if (iface->netdev) {
 396         const char *netdev_type = netdev_get_type(iface->netdev);
 397         const char *iface_type = iface_cfg->type && strlen(iface_cfg->type)
 398                                   ? iface_cfg->type : NULL;
 399
 400         /* An "internal" config type maps to a netdev "system" type. */
 401         if (iface_type && !strcmp(iface_type, "internal")) {
 402             iface_type = "system";
 403         }
 404
 405         if (!iface_type || !strcmp(netdev_type, iface_type)) {
 406             error = netdev_reconfigure(iface->netdev, &options);
 407         } else {
 408             VLOG_WARN("%s: attempting change device type from %s to %s",
 409                       iface_cfg->name, netdev_type, iface_type);
 410             error = EINVAL;
 411         }
 412     }
 413     shash_destroy_free_data(&options);
 414
 415     return error;
 416 }
 417
 418 static int
 419 reconfigure_iface(const struct ovsrec_interface *iface_cfg, struct iface *iface)
 420 {
 421     return set_up_iface(iface_cfg, iface, false);
 422 }
 423
 424 static bool
 425 check_iface_netdev(struct bridge *br OVS_UNUSED, struct iface *iface,
 426                    void *aux OVS_UNUSED)
 427 {
 428     if (!iface->netdev) {
 429         int error = set_up_iface(iface->cfg, iface, true);
 430         if (error) {
 431             VLOG_WARN("could not open netdev on %s, dropping: %s", iface->name,
 432                                                                strerror(error));
 433             return false;
 434         }
 435     }
 436
 437     return true;
 438 }
 439
 440 static bool
 441 check_iface_xf_ifidx(struct bridge *br, struct iface *iface,
 442                      void *aux OVS_UNUSED)
 443 {
 444     if (iface->xf_ifidx >= 0) {
 445         VLOG_DBG("%s has interface %s on port %d",
 446                  xfif_name(br->xfif),
 447                  iface->name, iface->xf_ifidx);
 448         return true;
 449     } else {
 450         VLOG_ERR("%s interface not in %s, dropping",
 451                  iface->name, xfif_name(br->xfif));
 452         return false;
 453     }
 454 }
 455
 456 static bool
 457 set_iface_properties(struct bridge *br OVS_UNUSED, struct iface *iface,
 458                      void *aux OVS_UNUSED)
 459 {
 460     /* Set policing attributes. */
 461     netdev_set_policing(iface->netdev,
 462                         iface->cfg->ingress_policing_rate,
 463                         iface->cfg->ingress_policing_burst);
 464
 465     /* Set MAC address of internal interfaces other than the local
 466      * interface. */
 467     if (iface->xf_ifidx != XFLOWP_LOCAL
 468         && iface_is_internal(br, iface->name)) {
 469         iface_set_mac(iface);
 470     }
 471
 472     return true;
 473 }
 474
 475 /* Calls 'cb' for each interfaces in 'br', passing along the 'aux' argument.
 476  * Deletes from 'br' all the interfaces for which 'cb' returns false, and then
 477  * deletes from 'br' any ports that no longer have any interfaces. */
 478 static void
 479 iterate_and_prune_ifaces(struct bridge *br,
 480                          bool (*cb)(struct bridge *, struct iface *,
 481                                     void *aux),
 482                          void *aux)
 483 {
 484     size_t i, j;
 485
 486     for (i = 0; i < br->n_ports; ) {
 487         struct port *port = br->ports[i];
 488         for (j = 0; j < port->n_ifaces; ) {
 489             struct iface *iface = port->ifaces[j];
 490             if (cb(br, iface, aux)) {
 491                 j++;
 492             } else {
 493                 iface_destroy(iface);
 494             }
 495         }
 496
 497         if (port->n_ifaces) {
 498             i++;
 499         } else  {
 500             VLOG_ERR("%s port has no interfaces, dropping", port->name);
 501             port_destroy(port);
 502         }
 503     }
 504 }
 505
 506 /* Looks at the list of managers in 'ovs_cfg' and extracts their remote IP
 507  * addresses and ports into '*managersp' and '*n_managersp'.  The caller is
 508  * responsible for freeing '*managersp' (with free()).
 509  *
 510  * You may be asking yourself "why does ovs-vswitchd care?", because
 511  * ovsdb-server is responsible for connecting to the managers, and ovs-vswitchd
 512  * should not be and in fact is not directly involved in that.  But
 513  * ovs-vswitchd needs to make sure that ovsdb-server can reach the managers, so
 514  * it has to tell in-band control where the managers are to enable that.
 515  */
 516 static void
 517 collect_managers(const struct ovsrec_open_vswitch *ovs_cfg,
 518                  struct sockaddr_in **managersp, size_t *n_managersp)
 519 {
 520     struct sockaddr_in *managers = NULL;
 521     size_t n_managers = 0;
 522
 523     if (ovs_cfg->n_managers > 0) {
 524         size_t i;
 525
 526         managers = xmalloc(ovs_cfg->n_managers * sizeof *managers);
 527         for (i = 0; i < ovs_cfg->n_managers; i++) {
 528             const char *name = ovs_cfg->managers[i];
 529             struct sockaddr_in *sin = &managers[i];
 530
 531             if ((!strncmp(name, "tcp:", 4)
 532                  && inet_parse_active(name + 4, JSONRPC_TCP_PORT, sin)) ||
 533                 (!strncmp(name, "ssl:", 4)
 534                  && inet_parse_active(name + 4, JSONRPC_SSL_PORT, sin))) {
 535                 n_managers++;
 536             }
 537         }
 538     }
 539
 540     *managersp = managers;
 541     *n_managersp = n_managers;
 542 }
 543
 544 static void
 545 bridge_reconfigure(const struct ovsrec_open_vswitch *ovs_cfg)
 546 {
 547     struct shash old_br, new_br;
 548     struct shash_node *node;
 549     struct bridge *br, *next;
 550     struct sockaddr_in *managers;
 551     size_t n_managers;
 552     size_t i;
 553     int sflow_bridge_number;
 554
 555     COVERAGE_INC(bridge_reconfigure);
 556
 557     collect_managers(ovs_cfg, &managers, &n_managers);
 558
 559     /* Collect old and new bridges. */
 560     shash_init(&old_br);
 561     shash_init(&new_br);
 562     LIST_FOR_EACH (br, struct bridge, node, &all_bridges) {
 563         shash_add(&old_br, br->name, br);
 564     }
 565     for (i = 0; i < ovs_cfg->n_bridges; i++) {
 566         const struct ovsrec_bridge *br_cfg = ovs_cfg->bridges[i];
 567         if (!shash_add_once(&new_br, br_cfg->name, br_cfg)) {
 568             VLOG_WARN("more than one bridge named %s", br_cfg->name);
 569         }
 570     }
 571
 572     /* Get rid of deleted bridges and add new bridges. */
 573     LIST_FOR_EACH_SAFE (br, next, struct bridge, node, &all_bridges) {
 574         struct ovsrec_bridge *br_cfg = shash_find_data(&new_br, br->name);
 575         if (br_cfg) {
 576             br->cfg = br_cfg;
 577         } else {
 578             bridge_destroy(br);
 579         }
 580     }
 581     SHASH_FOR_EACH (node, &new_br) {
 582         const char *br_name = node->name;
 583         const struct ovsrec_bridge *br_cfg = node->data;
 584         br = shash_find_data(&old_br, br_name);
 585         if (br) {
 586             /* If the bridge datapath type has changed, we need to tear it
 587              * down and recreate. */
 588             if (strcmp(br->cfg->datapath_type, br_cfg->datapath_type)) {
 589                 bridge_destroy(br);
 590                 bridge_create(br_cfg);
 591             }
 592         } else {
 593             bridge_create(br_cfg);
 594         }
 595     }
 596     shash_destroy(&old_br);
 597     shash_destroy(&new_br);
 598
 599 #ifdef HAVE_OPENSSL
 600     /* Configure SSL. */
 601     bridge_configure_ssl(ovs_cfg->ssl);
 602 #endif
 603
 604     /* Reconfigure all bridges. */
 605     LIST_FOR_EACH (br, struct bridge, node, &all_bridges) {
 606         bridge_reconfigure_one(ovs_cfg, br);
 607     }
 608
 609     /* Add and delete ports on all datapaths.
 610      *
 611      * The kernel will reject any attempt to add a given port to a datapath if
 612      * that port already belongs to a different datapath, so we must do all
 613      * port deletions before any port additions. */
 614     LIST_FOR_EACH (br, struct bridge, node, &all_bridges) {
 615         struct xflow_port *xfif_ports;
 616         size_t n_xfif_ports;
 617         struct shash want_ifaces;
 618
 619         xfif_port_list(br->xfif, &xfif_ports, &n_xfif_ports);
 620         bridge_get_all_ifaces(br, &want_ifaces);
 621         for (i = 0; i < n_xfif_ports; i++) {
 622             const struct xflow_port *p = &xfif_ports[i];
 623             if (!shash_find(&want_ifaces, p->devname)
 624                 && strcmp(p->devname, br->name)) {
 625                 int retval = xfif_port_del(br->xfif, p->port);
 626                 if (retval) {
 627                     VLOG_ERR("failed to remove %s interface from %s: %s",
 628                              p->devname, xfif_name(br->xfif),
 629                              strerror(retval));
 630                 }
 631             }
 632         }
 633         shash_destroy(&want_ifaces);
 634         free(xfif_ports);
 635     }
 636     LIST_FOR_EACH (br, struct bridge, node, &all_bridges) {
 637         struct xflow_port *xfif_ports;
 638         size_t n_xfif_ports;
 639         struct shash cur_ifaces, want_ifaces;
 640         struct shash_node *node;
 641
 642         /* Get the set of interfaces currently in this datapath. */
 643         xfif_port_list(br->xfif, &xfif_ports, &n_xfif_ports);
 644         shash_init(&cur_ifaces);
 645         for (i = 0; i < n_xfif_ports; i++) {
 646             const char *name = xfif_ports[i].devname;
 647             if (!shash_find(&cur_ifaces, name)) {
 648                 shash_add(&cur_ifaces, name, NULL);
 649             }
 650         }
 651         free(xfif_ports);
 652
 653         /* Get the set of interfaces we want on this datapath. */
 654         bridge_get_all_ifaces(br, &want_ifaces);
 655
 656         SHASH_FOR_EACH (node, &want_ifaces) {
 657             const char *if_name = node->name;
 658             struct iface *iface = node->data;
 659
 660             if (shash_find(&cur_ifaces, if_name)) {
 661                 /* Already exists, just reconfigure it. */
 662                 if (iface) {
 663                     reconfigure_iface(iface->cfg, iface);
 664                 }
 665             } else {
 666                 /* Need to add to datapath. */
 667                 bool internal;
 668                 int error;
 669
 670                 /* Add to datapath. */
 671                 internal = iface_is_internal(br, if_name);
 672                 error = xfif_port_add(br->xfif, if_name,
 673                                       internal ? XFLOW_PORT_INTERNAL : 0, NULL);
 674                 if (error == EFBIG) {
 675                     VLOG_ERR("ran out of valid port numbers on %s",
 676                              xfif_name(br->xfif));
 677                     break;
 678                 } else if (error) {
 679                     VLOG_ERR("failed to add %s interface to %s: %s",
 680                              if_name, xfif_name(br->xfif), strerror(error));
 681                 }
 682             }
 683         }
 684         shash_destroy(&cur_ifaces);
 685         shash_destroy(&want_ifaces);
 686     }
 687     sflow_bridge_number = 0;
 688     LIST_FOR_EACH (br, struct bridge, node, &all_bridges) {
 689         uint8_t ea[8];
 690         uint64_t dpid;
 691         struct iface *local_iface;
 692         struct iface *hw_addr_iface;
 693         char *dpid_string;
 694
 695         bridge_fetch_dp_ifaces(br);
 696
 697         iterate_and_prune_ifaces(br, check_iface_netdev, NULL);
 698         iterate_and_prune_ifaces(br, check_iface_xf_ifidx, NULL);
 699
 700         /* Pick local port hardware address, datapath ID. */
 701         bridge_pick_local_hw_addr(br, ea, &hw_addr_iface);
 702         local_iface = bridge_get_local_iface(br);
 703         if (local_iface) {
 704             int error = netdev_set_etheraddr(local_iface->netdev, ea);
 705             if (error) {
 706                 static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
 707                 VLOG_ERR_RL(&rl, "bridge %s: failed to set bridge "
 708                             "Ethernet address: %s",
 709                             br->name, strerror(error));
 710             }
 711         }
 712
 713         dpid = bridge_pick_datapath_id(br, ea, hw_addr_iface);
 714         ofproto_set_datapath_id(br->ofproto, dpid);
 715
 716         dpid_string = xasprintf("%016"PRIx64, dpid);
 717         ovsrec_bridge_set_datapath_id(br->cfg, dpid_string);
 718         free(dpid_string);
 719
 720         /* Set NetFlow configuration on this bridge. */
 721         if (br->cfg->netflow) {
 722             struct ovsrec_netflow *nf_cfg = br->cfg->netflow;
 723             struct netflow_options opts;
 724
 725             memset(&opts, 0, sizeof opts);
 726
 727             xfif_get_netflow_ids(br->xfif, &opts.engine_type, &opts.engine_id);
 728             if (nf_cfg->engine_type) {
 729                 opts.engine_type = *nf_cfg->engine_type;
 730             }
 731             if (nf_cfg->engine_id) {
 732                 opts.engine_id = *nf_cfg->engine_id;
 733             }
 734
 735             opts.active_timeout = nf_cfg->active_timeout;
 736             if (!opts.active_timeout) {
 737                 opts.active_timeout = -1;
 738             } else if (opts.active_timeout < 0) {
 739                 VLOG_WARN("bridge %s: active timeout interval set to negative "
 740                           "value, using default instead (%d seconds)", br->name,
 741                           NF_ACTIVE_TIMEOUT_DEFAULT);
 742                 opts.active_timeout = -1;
 743             }
 744
 745             opts.add_id_to_iface = nf_cfg->add_id_to_interface;
 746             if (opts.add_id_to_iface) {
 747                 if (opts.engine_id > 0x7f) {
 748                     VLOG_WARN("bridge %s: netflow port mangling may conflict "
 749                               "with another vswitch, choose an engine id less "
 750                               "than 128", br->name);
 751                 }
 752                 if (br->n_ports > 508) {
 753                     VLOG_WARN("bridge %s: netflow port mangling will conflict "
 754                               "with another port when more than 508 ports are "
 755                               "used", br->name);
 756                 }
 757             }
 758
 759             opts.collectors.n = nf_cfg->n_targets;
 760             opts.collectors.names = nf_cfg->targets;
 761             if (ofproto_set_netflow(br->ofproto, &opts)) {
 762                 VLOG_ERR("bridge %s: problem setting netflow collectors",
 763                          br->name);
 764             }
 765         } else {
 766             ofproto_set_netflow(br->ofproto, NULL);
 767         }
 768
 769         /* Set sFlow configuration on this bridge. */
 770         if (br->cfg->sflow) {
 771             const struct ovsrec_sflow *sflow_cfg = br->cfg->sflow;
 772             struct ovsrec_controller **controllers;
 773             struct ofproto_sflow_options oso;
 774             size_t n_controllers;
 775             size_t i;
 776
 777             memset(&oso, 0, sizeof oso);
 778
 779             oso.targets.n = sflow_cfg->n_targets;
 780             oso.targets.names = sflow_cfg->targets;
 781
 782             oso.sampling_rate = SFL_DEFAULT_SAMPLING_RATE;
 783             if (sflow_cfg->sampling) {
 784                 oso.sampling_rate = *sflow_cfg->sampling;
 785             }
 786
 787             oso.polling_interval = SFL_DEFAULT_POLLING_INTERVAL;
 788             if (sflow_cfg->polling) {
 789                 oso.polling_interval = *sflow_cfg->polling;
 790             }
 791
 792             oso.header_len = SFL_DEFAULT_HEADER_SIZE;
 793             if (sflow_cfg->header) {
 794                 oso.header_len = *sflow_cfg->header;
 795             }
 796
 797             oso.sub_id = sflow_bridge_number++;
 798             oso.agent_device = sflow_cfg->agent;
 799
 800             oso.control_ip = NULL;
 801             n_controllers = bridge_get_controllers(ovs_cfg, br, &controllers);
 802             for (i = 0; i < n_controllers; i++) {
 803                 if (controllers[i]->local_ip) {
 804                     oso.control_ip = controllers[i]->local_ip;
 805                     break;
 806                 }
 807             }
 808             ofproto_set_sflow(br->ofproto, &oso);
 809
 810             /* Do not destroy oso.targets because it is owned by sflow_cfg. */
 811         } else {
 812             ofproto_set_sflow(br->ofproto, NULL);
 813         }
 814
 815         /* Update the controller and related settings.  It would be more
 816          * straightforward to call this from bridge_reconfigure_one(), but we
 817          * can't do it there for two reasons.  First, and most importantly, at
 818          * that point we don't know the xf_ifidx of any interfaces that have
 819          * been added to the bridge (because we haven't actually added them to
 820          * the datapath).  Second, at that point we haven't set the datapath ID
 821          * yet; when a controller is configured, resetting the datapath ID will
 822          * immediately disconnect from the controller, so it's better to set
 823          * the datapath ID before the controller. */
 824         bridge_reconfigure_remotes(ovs_cfg, br, managers, n_managers);
 825     }
 826     LIST_FOR_EACH (br, struct bridge, node, &all_bridges) {
 827         for (i = 0; i < br->n_ports; i++) {
 828             struct port *port = br->ports[i];
 829             int j;
 830
 831             port_update_vlan_compat(port);
 832             port_update_bonding(port);
 833
 834             for (j = 0; j < port->n_ifaces; j++) {
 835                 iface_update_qos(port->ifaces[j], port->cfg->qos);
 836             }
 837         }
 838     }
 839     LIST_FOR_EACH (br, struct bridge, node, &all_bridges) {
 840         iterate_and_prune_ifaces(br, set_iface_properties, NULL);
 841     }
 842
 843     free(managers);
 844 }
 845
 846 static const char *
 847 get_ovsrec_key_value(const char *key, char **keys, char **values, size_t n)
 848 {
 849     size_t i;
 850
 851     for (i = 0; i < n; i++) {
 852         if (!strcmp(keys[i], key)) {
 853             return values[i];
 854         }
 855     }
 856     return NULL;
 857 }
 858
 859 static const char *
 860 bridge_get_other_config(const struct ovsrec_bridge *br_cfg, const char *key)
 861 {
 862     return get_ovsrec_key_value(key,
 863                                 br_cfg->key_other_config,
 864                                 br_cfg->value_other_config,
 865                                 br_cfg->n_other_config);
 866 }
 867
 868 static void
 869 bridge_pick_local_hw_addr(struct bridge *br, uint8_t ea[ETH_ADDR_LEN],
 870                           struct iface **hw_addr_iface)
 871 {
 872     const char *hwaddr;
 873     size_t i, j;
 874     int error;
 875
 876     *hw_addr_iface = NULL;
 877
 878     /* Did the user request a particular MAC? */
 879     hwaddr = bridge_get_other_config(br->cfg, "hwaddr");
 880     if (hwaddr && eth_addr_from_string(hwaddr, ea)) {
 881         if (eth_addr_is_multicast(ea)) {
 882             VLOG_ERR("bridge %s: cannot set MAC address to multicast "
 883                      "address "ETH_ADDR_FMT, br->name, ETH_ADDR_ARGS(ea));
 884         } else if (eth_addr_is_zero(ea)) {
 885             VLOG_ERR("bridge %s: cannot set MAC address to zero", br->name);
 886         } else {
 887             return;
 888         }
 889     }
 890
 891     /* Otherwise choose the minimum non-local MAC address among all of the
 892      * interfaces. */
 893     memset(ea, 0xff, sizeof ea);
 894     for (i = 0; i < br->n_ports; i++) {
 895         struct port *port = br->ports[i];
 896         uint8_t iface_ea[ETH_ADDR_LEN];
 897         struct iface *iface;
 898
 899         /* Mirror output ports don't participate. */
 900         if (port->is_mirror_output_port) {
 901             continue;
 902         }
 903
 904         /* Choose the MAC address to represent the port. */
 905         if (port->cfg->mac && eth_addr_from_string(port->cfg->mac, iface_ea)) {
 906             /* Find the interface with this Ethernet address (if any) so that
 907              * we can provide the correct devname to the caller. */
 908             iface = NULL;
 909             for (j = 0; j < port->n_ifaces; j++) {
 910                 struct iface *candidate = port->ifaces[j];
 911                 uint8_t candidate_ea[ETH_ADDR_LEN];
 912                 if (!netdev_get_etheraddr(candidate->netdev, candidate_ea)
 913                     && eth_addr_equals(iface_ea, candidate_ea)) {
 914                     iface = candidate;
 915                 }
 916             }
 917         } else {
 918             /* Choose the interface whose MAC address will represent the port.
 919              * The Linux kernel bonding code always chooses the MAC address of
 920              * the first slave added to a bond, and the Fedora networking
 921              * scripts always add slaves to a bond in alphabetical order, so
 922              * for compatibility we choose the interface with the name that is
 923              * first in alphabetical order. */
 924             iface = port->ifaces[0];
 925             for (j = 1; j < port->n_ifaces; j++) {
 926                 struct iface *candidate = port->ifaces[j];
 927                 if (strcmp(candidate->name, iface->name) < 0) {
 928                     iface = candidate;
 929                 }
 930             }
 931
 932             /* The local port doesn't count (since we're trying to choose its
 933              * MAC address anyway). */
 934             if (iface->xf_ifidx == XFLOWP_LOCAL) {
 935                 continue;
 936             }
 937
 938             /* Grab MAC. */
 939             error = netdev_get_etheraddr(iface->netdev, iface_ea);
 940             if (error) {
 941                 static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
 942                 VLOG_ERR_RL(&rl, "failed to obtain Ethernet address of %s: %s",
 943                             iface->name, strerror(error));
 944                 continue;
 945             }
 946         }
 947
 948         /* Compare against our current choice. */
 949         if (!eth_addr_is_multicast(iface_ea) &&
 950             !eth_addr_is_local(iface_ea) &&
 951             !eth_addr_is_reserved(iface_ea) &&
 952             !eth_addr_is_zero(iface_ea) &&
 953             memcmp(iface_ea, ea, ETH_ADDR_LEN) < 0)
 954         {
 955             memcpy(ea, iface_ea, ETH_ADDR_LEN);
 956             *hw_addr_iface = iface;
 957         }
 958     }
 959     if (eth_addr_is_multicast(ea)) {
 960         memcpy(ea, br->default_ea, ETH_ADDR_LEN);
 961         *hw_addr_iface = NULL;
 962         VLOG_WARN("bridge %s: using default bridge Ethernet "
 963                   "address "ETH_ADDR_FMT, br->name, ETH_ADDR_ARGS(ea));
 964     } else {
 965         VLOG_DBG("bridge %s: using bridge Ethernet address "ETH_ADDR_FMT,
 966                  br->name, ETH_ADDR_ARGS(ea));
 967     }
 968 }
 969
 970 /* Choose and returns the datapath ID for bridge 'br' given that the bridge
 971  * Ethernet address is 'bridge_ea'.  If 'bridge_ea' is the Ethernet address of
 972  * an interface on 'br', then that interface must be passed in as
 973  * 'hw_addr_iface'; if 'bridge_ea' was derived some other way, then
 974  * 'hw_addr_iface' must be passed in as a null pointer. */
 975 static uint64_t
 976 bridge_pick_datapath_id(struct bridge *br,
 977                         const uint8_t bridge_ea[ETH_ADDR_LEN],
 978                         struct iface *hw_addr_iface)
 979 {
 980     /*
 981      * The procedure for choosing a bridge MAC address will, in the most
 982      * ordinary case, also choose a unique MAC that we can use as a datapath
 983      * ID.  In some special cases, though, multiple bridges will end up with
 984      * the same MAC address.  This is OK for the bridges, but it will confuse
 985      * the OpenFlow controller, because each datapath needs a unique datapath
 986      * ID.
 987      *
 988      * Datapath IDs must be unique.  It is also very desirable that they be
 989      * stable from one run to the next, so that policy set on a datapath
 990      * "sticks".
 991      */
 992     const char *datapath_id;
 993     uint64_t dpid;
 994
 995     datapath_id = bridge_get_other_config(br->cfg, "datapath-id");
 996     if (datapath_id && dpid_from_string(datapath_id, &dpid)) {
 997         return dpid;
 998     }
 999
1000     if (hw_addr_iface) {
1001         int vlan;
1002         if (!netdev_get_vlan_vid(hw_addr_iface->netdev, &vlan)) {
1003             /*
1004              * A bridge whose MAC address is taken from a VLAN network device
1005              * (that is, a network device created with vconfig(8) or similar
1006              * tool) will have the same MAC address as a bridge on the VLAN
1007              * device's physical network device.
1008              *
1009              * Handle this case by hashing the physical network device MAC
1010              * along with the VLAN identifier.
1011              */
1012             uint8_t buf[ETH_ADDR_LEN + 2];
1013             memcpy(buf, bridge_ea, ETH_ADDR_LEN);
1014             buf[ETH_ADDR_LEN] = vlan >> 8;
1015             buf[ETH_ADDR_LEN + 1] = vlan;
1016             return dpid_from_hash(buf, sizeof buf);
1017         } else {
1018             /*
1019              * Assume that this bridge's MAC address is unique, since it
1020              * doesn't fit any of the cases we handle specially.
1021              */
1022         }
1023     } else {
1024         /*
1025          * A purely internal bridge, that is, one that has no non-virtual
1026          * network devices on it at all, is more difficult because it has no
1027          * natural unique identifier at all.
1028          *
1029          * When the host is a XenServer, we handle this case by hashing the
1030          * host's UUID with the name of the bridge.  Names of bridges are
1031          * persistent across XenServer reboots, although they can be reused if
1032          * an internal network is destroyed and then a new one is later
1033          * created, so this is fairly effective.
1034          *
1035          * When the host is not a XenServer, we punt by using a random MAC
1036          * address on each run.
1037          */
1038         const char *host_uuid = xenserver_get_host_uuid();
1039         if (host_uuid) {
1040             char *combined = xasprintf("%s,%s", host_uuid, br->name);
1041             dpid = dpid_from_hash(combined, strlen(combined));
1042             free(combined);
1043             return dpid;
1044         }
1045     }
1046
1047     return eth_addr_to_uint64(bridge_ea);
1048 }
1049
1050 static uint64_t
1051 dpid_from_hash(const void *data, size_t n)
1052 {
1053     uint8_t hash[SHA1_DIGEST_SIZE];
1054
1055     BUILD_ASSERT_DECL(sizeof hash >= ETH_ADDR_LEN);
1056     sha1_bytes(data, n, hash);
1057     eth_addr_mark_random(hash);
1058     return eth_addr_to_uint64(hash);
1059 }
1060
1061 static void
1062 iface_refresh_stats(struct iface *iface)
1063 {
1064     struct iface_stat {
1065         char *name;
1066         int offset;
1067     };
1068     static const struct iface_stat iface_stats[] = {
1069         { "rx_packets", offsetof(struct netdev_stats, rx_packets) },
1070         { "tx_packets", offsetof(struct netdev_stats, tx_packets) },
1071         { "rx_bytes", offsetof(struct netdev_stats, rx_bytes) },
1072         { "tx_bytes", offsetof(struct netdev_stats, tx_bytes) },
1073         { "rx_dropped", offsetof(struct netdev_stats, rx_dropped) },
1074         { "tx_dropped", offsetof(struct netdev_stats, tx_dropped) },
1075         { "rx_errors", offsetof(struct netdev_stats, rx_errors) },
1076         { "tx_errors", offsetof(struct netdev_stats, tx_errors) },
1077         { "rx_frame_err", offsetof(struct netdev_stats, rx_frame_errors) },
1078         { "rx_over_err", offsetof(struct netdev_stats, rx_over_errors) },
1079         { "rx_crc_err", offsetof(struct netdev_stats, rx_crc_errors) },
1080         { "collisions", offsetof(struct netdev_stats, collisions) },
1081     };
1082     enum { N_STATS = ARRAY_SIZE(iface_stats) };
1083     const struct iface_stat *s;
1084
1085     char *keys[N_STATS];
1086     int64_t values[N_STATS];
1087     int n;
1088
1089     struct netdev_stats stats;
1090
1091     /* Intentionally ignore return value, since errors will set 'stats' to
1092      * all-1s, and we will deal with that correctly below. */
1093     netdev_get_stats(iface->netdev, &stats);
1094
1095     n = 0;
1096     for (s = iface_stats; s < &iface_stats[N_STATS]; s++) {
1097         uint64_t value = *(uint64_t *) (((char *) &stats) + s->offset);
1098         if (value != UINT64_MAX) {
1099             keys[n] = s->name;
1100             values[n] = value;
1101             n++;
1102         }
1103     }
1104
1105     ovsrec_interface_set_statistics(iface->cfg, keys, values, n);
1106 }
1107
1108 void
1109 bridge_run(void)
1110 {
1111     bool datapath_destroyed;
1112     struct bridge *br;
1113
1114     /* Let each bridge do the work that it needs to do. */
1115     datapath_destroyed = false;
1116     LIST_FOR_EACH (br, struct bridge, node, &all_bridges) {
1117         int error = bridge_run_one(br);
1118         if (error) {
1119             static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
1120             VLOG_ERR_RL(&rl, "bridge %s: datapath was destroyed externally, "
1121                         "forcing reconfiguration", br->name);
1122             datapath_destroyed = true;
1123         }
1124     }
1125
1126     /* (Re)configure if necessary. */
1127     if (ovsdb_idl_run(idl) || datapath_destroyed) {
1128         const struct ovsrec_open_vswitch *cfg = ovsrec_open_vswitch_first(idl);
1129         if (cfg) {
1130             struct ovsdb_idl_txn *txn = ovsdb_idl_txn_create(idl);
1131
1132             bridge_configure_once(cfg);
1133             bridge_reconfigure(cfg);
1134
1135             ovsrec_open_vswitch_set_cur_cfg(cfg, cfg->next_cfg);
1136             ovsdb_idl_txn_commit(txn);
1137             ovsdb_idl_txn_destroy(txn); /* XXX */
1138         } else {
1139             /* We still need to reconfigure to avoid dangling pointers to
1140              * now-destroyed ovsrec structures inside bridge data. */
1141             static const struct ovsrec_open_vswitch null_cfg;
1142
1143             bridge_reconfigure(&null_cfg);
1144         }
1145     }
1146
1147     /* Refresh interface stats if necessary. */
1148     if (time_msec() >= iface_stats_timer) {
1149         struct ovsdb_idl_txn *txn;
1150
1151         txn = ovsdb_idl_txn_create(idl);
1152         LIST_FOR_EACH (br, struct bridge, node, &all_bridges) {
1153             size_t i;
1154
1155             for (i = 0; i < br->n_ports; i++) {
1156                 struct port *port = br->ports[i];
1157                 size_t j;
1158
1159                 for (j = 0; j < port->n_ifaces; j++) {
1160                     struct iface *iface = port->ifaces[j];
1161                     iface_refresh_stats(iface);
1162                 }
1163             }
1164         }
1165         ovsdb_idl_txn_commit(txn);
1166         ovsdb_idl_txn_destroy(txn); /* XXX */
1167
1168         iface_stats_timer = time_msec() + IFACE_STATS_INTERVAL;
1169     }
1170 }
1171
1172 void
1173 bridge_wait(void)
1174 {
1175     struct bridge *br;
1176
1177     LIST_FOR_EACH (br, struct bridge, node, &all_bridges) {
1178         ofproto_wait(br->ofproto);
1179         if (ofproto_has_controller(br->ofproto)) {
1180             continue;
1181         }
1182
1183         mac_learning_wait(br->ml);
1184         bond_wait(br);
1185     }
1186     ovsdb_idl_wait(idl);
1187     poll_timer_wait_until(iface_stats_timer);
1188 }
1189
1190 /* Forces 'br' to revalidate all of its flows.  This is appropriate when 'br''s
1191  * configuration changes.  */
1192 static void
1193 bridge_flush(struct bridge *br)
1194 {
1195     COVERAGE_INC(bridge_flush);
1196     br->flush = true;
1197     mac_learning_flush(br->ml);
1198 }
1199
1200 /* Returns the 'br' interface for the XFLOWP_LOCAL port, or null if 'br' has no
1201  * such interface. */
1202 static struct iface *
1203 bridge_get_local_iface(struct bridge *br)
1204 {
1205     size_t i, j;
1206
1207     for (i = 0; i < br->n_ports; i++) {
1208         struct port *port = br->ports[i];
1209         for (j = 0; j < port->n_ifaces; j++) {
1210             struct iface *iface = port->ifaces[j];
1211             if (iface->xf_ifidx == XFLOWP_LOCAL) {
1212                 return iface;
1213             }
1214         }
1215     }
1216
1217     return NULL;
1218 }
1219 \f
1220 /* Bridge unixctl user interface functions. */
1221 static void
1222 bridge_unixctl_fdb_show(struct unixctl_conn *conn,
1223                         const char *args, void *aux OVS_UNUSED)
1224 {
1225     struct ds ds = DS_EMPTY_INITIALIZER;
1226     const struct bridge *br;
1227     const struct mac_entry *e;
1228
1229     br = bridge_lookup(args);
1230     if (!br) {
1231         unixctl_command_reply(conn, 501, "no such bridge");
1232         return;
1233     }
1234
1235     ds_put_cstr(&ds, " port  VLAN  MAC                Age\n");
1236     LIST_FOR_EACH (e, struct mac_entry, lru_node, &br->ml->lrus) {
1237         if (e->port < 0 || e->port >= br->n_ports) {
1238             continue;
1239         }
1240         ds_put_format(&ds, "%5d  %4d  "ETH_ADDR_FMT"  %3d\n",
1241                       br->ports[e->port]->ifaces[0]->xf_ifidx,
1242                       e->vlan, ETH_ADDR_ARGS(e->mac), mac_entry_age(e));
1243     }
1244     unixctl_command_reply(conn, 200, ds_cstr(&ds));
1245     ds_destroy(&ds);
1246 }
1247 \f
1248 /* Bridge reconfiguration functions. */
1249 static struct bridge *
1250 bridge_create(const struct ovsrec_bridge *br_cfg)
1251 {
1252     struct bridge *br;
1253     int error;
1254
1255     assert(!bridge_lookup(br_cfg->name));
1256     br = xzalloc(sizeof *br);
1257
1258     error = xfif_create_and_open(br_cfg->name, br_cfg->datapath_type,
1259                                  &br->xfif);
1260     if (error) {
1261         free(br);
1262         return NULL;
1263     }
1264     xfif_flow_flush(br->xfif);
1265
1266     error = ofproto_create(br_cfg->name, br_cfg->datapath_type, &bridge_ofhooks,
1267                            br, &br->ofproto);
1268     if (error) {
1269         VLOG_ERR("failed to create switch %s: %s", br_cfg->name,
1270                  strerror(error));
1271         xfif_delete(br->xfif);
1272         xfif_close(br->xfif);
1273         free(br);
1274         return NULL;
1275     }
1276
1277     br->name = xstrdup(br_cfg->name);
1278     br->cfg = br_cfg;
1279     br->ml = mac_learning_create();
1280     eth_addr_nicira_random(br->default_ea);
1281
1282     port_array_init(&br->ifaces);
1283
1284     shash_init(&br->port_by_name);
1285     shash_init(&br->iface_by_name);
1286
1287     br->flush = false;
1288
1289     list_push_back(&all_bridges, &br->node);
1290
1291     VLOG_INFO("created bridge %s on %s", br->name, xfif_name(br->xfif));
1292
1293     return br;
1294 }
1295
1296 static void
1297 bridge_destroy(struct bridge *br)
1298 {
1299     if (br) {
1300         int error;
1301
1302         while (br->n_ports > 0) {
1303             port_destroy(br->ports[br->n_ports - 1]);
1304         }
1305         list_remove(&br->node);
1306         error = xfif_delete(br->xfif);
1307         if (error && error != ENOENT) {
1308             VLOG_ERR("failed to delete %s: %s",
1309                      xfif_name(br->xfif), strerror(error));
1310         }
1311         xfif_close(br->xfif);
1312         ofproto_destroy(br->ofproto);
1313         mac_learning_destroy(br->ml);
1314         port_array_destroy(&br->ifaces);
1315         shash_destroy(&br->port_by_name);
1316         shash_destroy(&br->iface_by_name);
1317         free(br->ports);
1318         free(br->name);
1319         free(br);
1320     }
1321 }
1322
1323 static struct bridge *
1324 bridge_lookup(const char *name)
1325 {
1326     struct bridge *br;
1327
1328     LIST_FOR_EACH (br, struct bridge, node, &all_bridges) {
1329         if (!strcmp(br->name, name)) {
1330             return br;
1331         }
1332     }
1333     return NULL;
1334 }
1335
1336 /* Handle requests for a listing of all flows known by the OpenFlow
1337  * stack, including those normally hidden. */
1338 static void
1339 bridge_unixctl_dump_flows(struct unixctl_conn *conn,
1340                           const char *args, void *aux OVS_UNUSED)
1341 {
1342     struct bridge *br;
1343     struct ds results;
1344
1345     br = bridge_lookup(args);
1346     if (!br) {
1347         unixctl_command_reply(conn, 501, "Unknown bridge");
1348         return;
1349     }
1350
1351     ds_init(&results);
1352     ofproto_get_all_flows(br->ofproto, &results);
1353
1354     unixctl_command_reply(conn, 200, ds_cstr(&results));
1355     ds_destroy(&results);
1356 }
1357
1358 /* "bridge/reconnect [BRIDGE]": makes BRIDGE drop all of its controller
1359  * connections and reconnect.  If BRIDGE is not specified, then all bridges
1360  * drop their controller connections and reconnect. */
1361 static void
1362 bridge_unixctl_reconnect(struct unixctl_conn *conn,
1363                          const char *args, void *aux OVS_UNUSED)
1364 {
1365     struct bridge *br;
1366     if (args[0] != '\0') {
1367         br = bridge_lookup(args);
1368         if (!br) {
1369             unixctl_command_reply(conn, 501, "Unknown bridge");
1370             return;
1371         }
1372         ofproto_reconnect_controllers(br->ofproto);
1373     } else {
1374         LIST_FOR_EACH (br, struct bridge, node, &all_bridges) {
1375             ofproto_reconnect_controllers(br->ofproto);
1376         }
1377     }
1378     unixctl_command_reply(conn, 200, NULL);
1379 }
1380
1381 static int
1382 bridge_run_one(struct bridge *br)
1383 {
1384     int error;
1385
1386     error = ofproto_run1(br->ofproto);
1387     if (error) {
1388         return error;
1389     }
1390
1391     //XXX mac_learning_run(br->ml, ofproto_get_revalidate_set(br->ofproto));
1392     bond_run(br);
1393
1394     error = ofproto_run2(br->ofproto, br->flush);
1395     br->flush = false;
1396
1397     return error;
1398 }
1399
1400 static size_t
1401 bridge_get_controllers(const struct ovsrec_open_vswitch *ovs_cfg,
1402                        const struct bridge *br,
1403                        struct ovsrec_controller ***controllersp)
1404 {
1405     struct ovsrec_controller **controllers;
1406     size_t n_controllers;
1407
1408     if (br->cfg->n_controller) {
1409         controllers = br->cfg->controller;
1410         n_controllers = br->cfg->n_controller;
1411     } else {
1412         controllers = ovs_cfg->controller;
1413         n_controllers = ovs_cfg->n_controller;
1414     }
1415
1416     if (n_controllers == 1 && !strcmp(controllers[0]->target, "none")) {
1417         controllers = NULL;
1418         n_controllers = 0;
1419     }
1420
1421     if (controllersp) {
1422         *controllersp = controllers;
1423     }
1424     return n_controllers;
1425 }
1426
1427 static void
1428 bridge_reconfigure_one(const struct ovsrec_open_vswitch *ovs_cfg,
1429                        struct bridge *br)
1430 {
1431     struct shash old_ports, new_ports;
1432     struct svec listeners, old_listeners;
1433     struct svec snoops, old_snoops;
1434     struct shash_node *node;
1435     size_t i;
1436
1437     /* Collect old ports. */
1438     shash_init(&old_ports);
1439     for (i = 0; i < br->n_ports; i++) {
1440         shash_add(&old_ports, br->ports[i]->name, br->ports[i]);
1441     }
1442
1443     /* Collect new ports. */
1444     shash_init(&new_ports);
1445     for (i = 0; i < br->cfg->n_ports; i++) {
1446         const char *name = br->cfg->ports[i]->name;
1447         if (!shash_add_once(&new_ports, name, br->cfg->ports[i])) {
1448             VLOG_WARN("bridge %s: %s specified twice as bridge port",
1449                       br->name, name);
1450         }
1451     }
1452
1453     /* If we have a controller, then we need a local port.  Complain if the
1454      * user didn't specify one.
1455      *
1456      * XXX perhaps we should synthesize a port ourselves in this case. */
1457     if (bridge_get_controllers(ovs_cfg, br, NULL)) {
1458         char local_name[IF_NAMESIZE];
1459         int error;
1460
1461         error = xfif_port_get_name(br->xfif, XFLOWP_LOCAL,
1462                                    local_name, sizeof local_name);
1463         if (!error && !shash_find(&new_ports, local_name)) {
1464             VLOG_WARN("bridge %s: controller specified but no local port "
1465                       "(port named %s) defined",
1466                       br->name, local_name);
1467         }
1468     }
1469
1470     /* Get rid of deleted ports.
1471      * Get rid of deleted interfaces on ports that still exist. */
1472     SHASH_FOR_EACH (node, &old_ports) {
1473         struct port *port = node->data;
1474         const struct ovsrec_port *port_cfg;
1475
1476         port_cfg = shash_find_data(&new_ports, node->name);
1477         if (!port_cfg) {
1478             port_destroy(port);
1479         } else {
1480             port_del_ifaces(port, port_cfg);
1481         }
1482     }
1483
1484     /* Create new ports.
1485      * Add new interfaces to existing ports.
1486      * Reconfigure existing ports. */
1487     SHASH_FOR_EACH (node, &new_ports) {
1488         struct port *port = shash_find_data(&old_ports, node->name);
1489         if (!port) {
1490             port = port_create(br, node->name);
1491         }
1492
1493         port_reconfigure(port, node->data);
1494         if (!port->n_ifaces) {
1495             VLOG_WARN("bridge %s: port %s has no interfaces, dropping",
1496                       br->name, port->name);
1497             port_destroy(port);
1498         }
1499     }
1500     shash_destroy(&old_ports);
1501     shash_destroy(&new_ports);
1502
1503     /* Delete all flows if we're switching from connected to standalone or vice
1504      * versa.  (XXX Should we delete all flows if we are switching from one
1505      * controller to another?) */
1506
1507     /* Configure OpenFlow management listener. */
1508     svec_init(&listeners);
1509     svec_add_nocopy(&listeners, xasprintf("punix:%s/%s.mgmt",
1510                                           ovs_rundir, br->name));
1511     svec_init(&old_listeners);
1512     ofproto_get_listeners(br->ofproto, &old_listeners);
1513     if (!svec_equal(&listeners, &old_listeners)) {
1514         ofproto_set_listeners(br->ofproto, &listeners);
1515     }
1516     svec_destroy(&listeners);
1517     svec_destroy(&old_listeners);
1518
1519     /* Configure OpenFlow controller connection snooping. */
1520     svec_init(&snoops);
1521     svec_add_nocopy(&snoops, xasprintf("punix:%s/%s.snoop",
1522                                        ovs_rundir, br->name));
1523     svec_init(&old_snoops);
1524     ofproto_get_snoops(br->ofproto, &old_snoops);
1525     if (!svec_equal(&snoops, &old_snoops)) {
1526         ofproto_set_snoops(br->ofproto, &snoops);
1527     }
1528     svec_destroy(&snoops);
1529     svec_destroy(&old_snoops);
1530
1531     mirror_reconfigure(br);
1532 }
1533
1534 static void
1535 bridge_reconfigure_remotes(const struct ovsrec_open_vswitch *ovs_cfg,
1536                            struct bridge *br,
1537                            const struct sockaddr_in *managers,
1538                            size_t n_managers)
1539 {
1540     struct ovsrec_controller **controllers;
1541     size_t n_controllers;
1542
1543     ofproto_set_extra_in_band_remotes(br->ofproto, managers, n_managers);
1544
1545     n_controllers = bridge_get_controllers(ovs_cfg, br, &controllers);
1546     if (ofproto_has_controller(br->ofproto) != (n_controllers != 0)) {
1547         ofproto_flush_flows(br->ofproto);
1548     }
1549
1550     if (!n_controllers) {
1551         union ofp_action action;
1552         flow_t flow;
1553
1554         /* Clear out controllers. */
1555         ofproto_set_controllers(br->ofproto, NULL, 0);
1556
1557         /* Set up a flow that matches every packet and directs them to
1558          * OFPP_NORMAL (which goes to us). */
1559         memset(&action, 0, sizeof action);
1560         action.type = htons(OFPAT_OUTPUT);
1561         action.output.len = htons(sizeof action);
1562         action.output.port = htons(OFPP_NORMAL);
1563         memset(&flow, 0, sizeof flow);
1564         flow.wildcards = OVSFW_ALL;
1565         ofproto_add_flow(br->ofproto, &flow, &action, 1, 0);
1566     } else {
1567         struct ofproto_controller *ocs;
1568         size_t i;
1569
1570         ocs = xmalloc(n_controllers * sizeof *ocs);
1571         for (i = 0; i < n_controllers; i++) {
1572             struct ovsrec_controller *c = controllers[i];
1573             struct ofproto_controller *oc = &ocs[i];
1574
1575             if (strcmp(c->target, "discover")) {
1576                 struct iface *local_iface;
1577                 struct in_addr ip;
1578
1579                 local_iface = bridge_get_local_iface(br);
1580                 if (local_iface && c->local_ip
1581                     && inet_aton(c->local_ip, &ip)) {
1582                     struct netdev *netdev = local_iface->netdev;
1583                     struct in_addr mask, gateway;
1584
1585                     if (!c->local_netmask
1586                         || !inet_aton(c->local_netmask, &mask)) {
1587                         mask.s_addr = 0;
1588                     }
1589                     if (!c->local_gateway
1590                         || !inet_aton(c->local_gateway, &gateway)) {
1591                         gateway.s_addr = 0;
1592                     }
1593
1594                     netdev_turn_flags_on(netdev, NETDEV_UP, true);
1595                     if (!mask.s_addr) {
1596                         mask.s_addr = guess_netmask(ip.s_addr);
1597                     }
1598                     if (!netdev_set_in4(netdev, ip, mask)) {
1599                         VLOG_INFO("bridge %s: configured IP address "IP_FMT", "
1600                                   "netmask "IP_FMT,
1601                                   br->name, IP_ARGS(&ip.s_addr),
1602                                   IP_ARGS(&mask.s_addr));
1603                     }
1604
1605                     if (gateway.s_addr) {
1606                         if (!netdev_add_router(netdev, gateway)) {
1607                             VLOG_INFO("bridge %s: configured gateway "IP_FMT,
1608                                       br->name, IP_ARGS(&gateway.s_addr));
1609                         }
1610                     }
1611                 }
1612             }
1613
1614             oc->target = c->target;
1615             oc->max_backoff = c->max_backoff ? *c->max_backoff / 1000 : 8;
1616             oc->probe_interval = (c->inactivity_probe
1617                                  ? *c->inactivity_probe / 1000 : 5);
1618             oc->fail = (!c->fail_mode
1619                        || !strcmp(c->fail_mode, "standalone")
1620                        || !strcmp(c->fail_mode, "open")
1621                        ? OFPROTO_FAIL_STANDALONE
1622                        : OFPROTO_FAIL_SECURE);
1623             oc->band = (!c->connection_mode
1624                        || !strcmp(c->connection_mode, "in-band")
1625                        ? OFPROTO_IN_BAND
1626                        : OFPROTO_OUT_OF_BAND);
1627             oc->accept_re = c->discover_accept_regex;
1628             oc->update_resolv_conf = c->discover_update_resolv_conf;
1629             oc->rate_limit = (c->controller_rate_limit
1630                              ? *c->controller_rate_limit : 0);
1631             oc->burst_limit = (c->controller_burst_limit
1632                               ? *c->controller_burst_limit : 0);
1633         }
1634         ofproto_set_controllers(br->ofproto, ocs, n_controllers);
1635         free(ocs);
1636     }
1637 }
1638
1639 static void
1640 bridge_get_all_ifaces(const struct bridge *br, struct shash *ifaces)
1641 {
1642     size_t i, j;
1643
1644     shash_init(ifaces);
1645     for (i = 0; i < br->n_ports; i++) {
1646         struct port *port = br->ports[i];
1647         for (j = 0; j < port->n_ifaces; j++) {
1648             struct iface *iface = port->ifaces[j];
1649             shash_add_once(ifaces, iface->name, iface);
1650         }
1651         if (port->n_ifaces > 1 && port->cfg->bond_fake_iface) {
1652             shash_add_once(ifaces, port->name, NULL);
1653         }
1654     }
1655 }
1656
1657 /* For robustness, in case the administrator moves around datapath ports behind
1658  * our back, we re-check all the datapath port numbers here.
1659  *
1660  * This function will set the 'xf_ifidx' members of interfaces that have
1661  * disappeared to -1, so only call this function from a context where those
1662  * 'struct iface's will be removed from the bridge.  Otherwise, the -1
1663  * 'xf_ifidx'es will cause trouble later when we try to send them to the
1664  * datapath, which doesn't support UINT16_MAX+1 ports. */
1665 static void
1666 bridge_fetch_dp_ifaces(struct bridge *br)
1667 {
1668     struct xflow_port *xfif_ports;
1669     size_t n_xfif_ports;
1670     size_t i, j;
1671
1672     /* Reset all interface numbers. */
1673     for (i = 0; i < br->n_ports; i++) {
1674         struct port *port = br->ports[i];
1675         for (j = 0; j < port->n_ifaces; j++) {
1676             struct iface *iface = port->ifaces[j];
1677             iface->xf_ifidx = -1;
1678         }
1679     }
1680     port_array_clear(&br->ifaces);
1681
1682     xfif_port_list(br->xfif, &xfif_ports, &n_xfif_ports);
1683     for (i = 0; i < n_xfif_ports; i++) {
1684         struct xflow_port *p = &xfif_ports[i];
1685         struct iface *iface = iface_lookup(br, p->devname);
1686         if (iface) {
1687             if (iface->xf_ifidx >= 0) {
1688                 VLOG_WARN("%s reported interface %s twice",
1689                           xfif_name(br->xfif), p->devname);
1690             } else if (iface_from_xf_ifidx(br, p->port)) {
1691                 VLOG_WARN("%s reported interface %"PRIu16" twice",
1692                           xfif_name(br->xfif), p->port);
1693             } else {
1694                 port_array_set(&br->ifaces, p->port, iface);
1695                 iface->xf_ifidx = p->port;
1696             }
1697
1698             if (iface->cfg) {
1699                 int64_t ofport = (iface->xf_ifidx >= 0
1700                                   ? xflow_port_to_ofp_port(iface->xf_ifidx)
1701                                   : -1);
1702                 ovsrec_interface_set_ofport(iface->cfg, &ofport, 1);
1703             }
1704         }
1705     }
1706     free(xfif_ports);
1707 }
1708 \f
1709 /* Bridge packet processing functions. */
1710
1711 static int
1712 bond_hash(const uint8_t mac[ETH_ADDR_LEN])
1713 {
1714     return hash_bytes(mac, ETH_ADDR_LEN, 0) & BOND_MASK;
1715 }
1716
1717 static struct bond_entry *
1718 lookup_bond_entry(const struct port *port, const uint8_t mac[ETH_ADDR_LEN])
1719 {
1720     return &port->bond_hash[bond_hash(mac)];
1721 }
1722
1723 static int
1724 bond_choose_iface(const struct port *port)
1725 {
1726     static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(5, 20);
1727     size_t i, best_down_slave = -1;
1728     long long next_delay_expiration = LLONG_MAX;
1729
1730     for (i = 0; i < port->n_ifaces; i++) {
1731         struct iface *iface = port->ifaces[i];
1732
1733         if (iface->enabled) {
1734             return i;
1735         } else if (iface->delay_expires < next_delay_expiration) {
1736             best_down_slave = i;
1737             next_delay_expiration = iface->delay_expires;
1738         }
1739     }
1740
1741     if (best_down_slave != -1) {
1742         struct iface *iface = port->ifaces[best_down_slave];
1743
1744         VLOG_INFO_RL(&rl, "interface %s: skipping remaining %lli ms updelay "
1745                      "since no other interface is up", iface->name,
1746                      iface->delay_expires - time_msec());
1747         bond_enable_slave(iface, true);
1748     }
1749
1750     return best_down_slave;
1751 }
1752
1753 static bool
1754 choose_output_iface(const struct port *port, const uint8_t *dl_src,
1755                     uint16_t *xf_ifidx, tag_type *tags)
1756 {
1757     struct iface *iface;
1758
1759     assert(port->n_ifaces);
1760     if (port->n_ifaces == 1) {
1761         iface = port->ifaces[0];
1762     } else {
1763         struct bond_entry *e = lookup_bond_entry(port, dl_src);
1764         if (e->iface_idx < 0 || e->iface_idx >= port->n_ifaces
1765             || !port->ifaces[e->iface_idx]->enabled) {
1766             /* XXX select interface properly.  The current interface selection
1767              * is only good for testing the rebalancing code. */
1768             e->iface_idx = bond_choose_iface(port);
1769             if (e->iface_idx < 0) {
1770                 *tags |= port->no_ifaces_tag;
1771                 return false;
1772             }
1773             e->iface_tag = tag_create_random();
1774             ((struct port *) port)->bond_compat_is_stale = true;
1775         }
1776         *tags |= e->iface_tag;
1777         iface = port->ifaces[e->iface_idx];
1778     }
1779     *xf_ifidx = iface->xf_ifidx;
1780     *tags |= iface->tag;        /* Currently only used for bonding. */
1781     return true;
1782 }
1783
1784 static void
1785 bond_link_status_update(struct iface *iface, bool carrier)
1786 {
1787     static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(5, 20);
1788     struct port *port = iface->port;
1789
1790     if ((carrier == iface->enabled) == (iface->delay_expires == LLONG_MAX)) {
1791         /* Nothing to do. */
1792         return;
1793     }
1794     VLOG_INFO_RL(&rl, "interface %s: carrier %s",
1795                  iface->name, carrier ? "detected" : "dropped");
1796     if (carrier == iface->enabled) {
1797         iface->delay_expires = LLONG_MAX;
1798         VLOG_INFO_RL(&rl, "interface %s: will not be %s",
1799                      iface->name, carrier ? "disabled" : "enabled");
1800     } else if (carrier && port->active_iface < 0) {
1801         bond_enable_slave(iface, true);
1802         if (port->updelay) {
1803             VLOG_INFO_RL(&rl, "interface %s: skipping %d ms updelay since no "
1804                          "other interface is up", iface->name, port->updelay);
1805         }
1806     } else {
1807         int delay = carrier ? port->updelay : port->downdelay;
1808         iface->delay_expires = time_msec() + delay;
1809         if (delay) {
1810             VLOG_INFO_RL(&rl,
1811                          "interface %s: will be %s if it stays %s for %d ms",
1812                          iface->name,
1813                          carrier ? "enabled" : "disabled",
1814                          carrier ? "up" : "down",
1815                          delay);
1816         }
1817     }
1818 }
1819
1820 static void
1821 bond_choose_active_iface(struct port *port)
1822 {
1823     static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(5, 20);
1824
1825     port->active_iface = bond_choose_iface(port);
1826     port->active_iface_tag = tag_create_random();
1827     if (port->active_iface >= 0) {
1828         VLOG_INFO_RL(&rl, "port %s: active interface is now %s",
1829                      port->name, port->ifaces[port->active_iface]->name);
1830     } else {
1831         VLOG_WARN_RL(&rl, "port %s: all ports disabled, no active interface",
1832                      port->name);
1833     }
1834 }
1835
1836 static void
1837 bond_enable_slave(struct iface *iface, bool enable)
1838 {
1839     struct port *port = iface->port;
1840     struct bridge *br = port->bridge;
1841
1842     /* This acts as a recursion check.  If the act of disabling a slave
1843      * causes a different slave to be enabled, the flag will allow us to
1844      * skip redundant work when we reenter this function.  It must be
1845      * cleared on exit to keep things safe with multiple bonds. */
1846     static bool moving_active_iface = false;
1847
1848     iface->delay_expires = LLONG_MAX;
1849     if (enable == iface->enabled) {
1850         return;
1851     }
1852
1853     iface->enabled = enable;
1854     if (!iface->enabled) {
1855         VLOG_WARN("interface %s: disabled", iface->name);
1856         ofproto_revalidate(br->ofproto, iface->tag);
1857         if (iface->port_ifidx == port->active_iface) {
1858             ofproto_revalidate(br->ofproto,
1859                                port->active_iface_tag);
1860
1861             /* Disabling a slave can lead to another slave being immediately
1862              * enabled if there will be no active slaves but one is waiting
1863              * on an updelay.  In this case we do not need to run most of the
1864              * code for the newly enabled slave since there was no period
1865              * without an active slave and it is redundant with the disabling
1866              * path. */
1867             moving_active_iface = true;
1868             bond_choose_active_iface(port);
1869         }
1870         bond_send_learning_packets(port);
1871     } else {
1872         VLOG_WARN("interface %s: enabled", iface->name);
1873         if (port->active_iface < 0 && !moving_active_iface) {
1874             ofproto_revalidate(br->ofproto, port->no_ifaces_tag);
1875             bond_choose_active_iface(port);
1876             bond_send_learning_packets(port);
1877         }
1878         iface->tag = tag_create_random();
1879     }
1880
1881     moving_active_iface = false;
1882     port->bond_compat_is_stale = true;
1883 }
1884
1885 /* Attempts to make the sum of the bond slaves' statistics appear on the fake
1886  * bond interface. */
1887 static void
1888 bond_update_fake_iface_stats(struct port *port)
1889 {
1890     struct netdev_stats bond_stats;
1891     struct netdev *bond_dev;
1892     size_t i;
1893
1894     memset(&bond_stats, 0, sizeof bond_stats);
1895
1896     for (i = 0; i < port->n_ifaces; i++) {
1897         struct netdev_stats slave_stats;
1898
1899         if (!netdev_get_stats(port->ifaces[i]->netdev, &slave_stats)) {
1900             /* XXX: We swap the stats here because they are swapped back when
1901              * reported by the internal device.  The reason for this is
1902              * internal devices normally represent packets going into the system
1903              * but when used as fake bond device they represent packets leaving
1904              * the system.  We really should do this in the internal device
1905              * itself because changing it here reverses the counts from the
1906              * perspective of the switch.  However, the internal device doesn't
1907              * know what type of device it represents so we have to do it here
1908              * for now. */
1909             bond_stats.tx_packets += slave_stats.rx_packets;
1910             bond_stats.tx_bytes += slave_stats.rx_bytes;
1911             bond_stats.rx_packets += slave_stats.tx_packets;
1912             bond_stats.rx_bytes += slave_stats.tx_bytes;
1913         }
1914     }
1915
1916     if (!netdev_open_default(port->name, &bond_dev)) {
1917         netdev_set_stats(bond_dev, &bond_stats);
1918         netdev_close(bond_dev);
1919     }
1920 }
1921
1922 static void
1923 bond_run(struct bridge *br)
1924 {
1925     size_t i, j;
1926
1927     for (i = 0; i < br->n_ports; i++) {
1928         struct port *port = br->ports[i];
1929
1930         if (port->n_ifaces >= 2) {
1931             for (j = 0; j < port->n_ifaces; j++) {
1932                 struct iface *iface = port->ifaces[j];
1933                 if (time_msec() >= iface->delay_expires) {
1934                     bond_enable_slave(iface, !iface->enabled);
1935                 }
1936             }
1937
1938             if (port->bond_fake_iface
1939                 && time_msec() >= port->bond_next_fake_iface_update) {
1940                 bond_update_fake_iface_stats(port);
1941                 port->bond_next_fake_iface_update = time_msec() + 1000;
1942             }
1943         }
1944
1945         if (port->bond_compat_is_stale) {
1946             port->bond_compat_is_stale = false;
1947             port_update_bond_compat(port);
1948         }
1949     }
1950 }
1951
1952 static void
1953 bond_wait(struct bridge *br)
1954 {
1955     size_t i, j;
1956
1957     for (i = 0; i < br->n_ports; i++) {
1958         struct port *port = br->ports[i];
1959         if (port->n_ifaces < 2) {
1960             continue;
1961         }
1962         for (j = 0; j < port->n_ifaces; j++) {
1963             struct iface *iface = port->ifaces[j];
1964             if (iface->delay_expires != LLONG_MAX) {
1965                 poll_timer_wait_until(iface->delay_expires);
1966             }
1967         }
1968         if (port->bond_fake_iface) {
1969             poll_timer_wait_until(port->bond_next_fake_iface_update);
1970         }
1971     }
1972 }
1973
1974 static bool
1975 set_dst(struct dst *p, const flow_t *flow,
1976         const struct port *in_port, const struct port *out_port,
1977         tag_type *tags)
1978 {
1979     p->vlan = (out_port->vlan >= 0 ? OFP_VLAN_NONE
1980               : in_port->vlan >= 0 ? in_port->vlan
1981               : ntohs(flow->dl_vlan));
1982     return choose_output_iface(out_port, flow->dl_src, &p->xf_ifidx, tags);
1983 }
1984
1985 static void
1986 swap_dst(struct dst *p, struct dst *q)
1987 {
1988     struct dst tmp = *p;
1989     *p = *q;
1990     *q = tmp;
1991 }
1992
1993 /* Moves all the dsts with vlan == 'vlan' to the front of the 'n_dsts' in
1994  * 'dsts'.  (This may help performance by reducing the number of VLAN changes
1995  * that we push to the datapath.  We could in fact fully sort the array by
1996  * vlan, but in most cases there are at most two different vlan tags so that's
1997  * possibly overkill.) */
1998 static void
1999 partition_dsts(struct dst *dsts, size_t n_dsts, int vlan)
2000 {
2001     struct dst *first = dsts;
2002     struct dst *last = dsts + n_dsts;
2003
2004     while (first != last) {
2005         /* Invariants:
2006          *      - All dsts < first have vlan == 'vlan'.
2007          *      - All dsts >= last have vlan != 'vlan'.
2008          *      - first < last. */
2009         while (first->vlan == vlan) {
2010             if (++first == last) {
2011                 return;
2012             }
2013         }
2014
2015         /* Same invariants, plus one additional:
2016          *      - first->vlan != vlan.
2017          */
2018         while (last[-1].vlan != vlan) {
2019             if (--last == first) {
2020                 return;
2021             }
2022         }
2023
2024         /* Same invariants, plus one additional:
2025          *      - last[-1].vlan == vlan.*/
2026         swap_dst(first++, --last);
2027     }
2028 }
2029
2030 static int
2031 mirror_mask_ffs(mirror_mask_t mask)
2032 {
2033     BUILD_ASSERT_DECL(sizeof(unsigned int) >= sizeof(mask));
2034     return ffs(mask);
2035 }
2036
2037 static bool
2038 dst_is_duplicate(const struct dst *dsts, size_t n_dsts,
2039                  const struct dst *test)
2040 {
2041     size_t i;
2042     for (i = 0; i < n_dsts; i++) {
2043         if (dsts[i].vlan == test->vlan && dsts[i].xf_ifidx == test->xf_ifidx) {
2044             return true;
2045         }
2046     }
2047     return false;
2048 }
2049
2050 static bool
2051 port_trunks_vlan(const struct port *port, uint16_t vlan)
2052 {
2053     return (port->vlan < 0
2054             && (!port->trunks || bitmap_is_set(port->trunks, vlan)));
2055 }
2056
2057 static bool
2058 port_includes_vlan(const struct port *port, uint16_t vlan)
2059 {
2060     return vlan == port->vlan || port_trunks_vlan(port, vlan);
2061 }
2062
2063 static size_t
2064 compose_dsts(const struct bridge *br, const flow_t *flow, uint16_t vlan,
2065              const struct port *in_port, const struct port *out_port,
2066              struct dst dsts[], tag_type *tags, uint16_t *nf_output_iface)
2067 {
2068     mirror_mask_t mirrors = in_port->src_mirrors;
2069     struct dst *dst = dsts;
2070     size_t i;
2071
2072     if (out_port == FLOOD_PORT) {
2073         /* XXX use XFLOW_FLOOD if no vlans or bonding. */
2074         /* XXX even better, define each VLAN as a datapath port group */
2075         for (i = 0; i < br->n_ports; i++) {
2076             struct port *port = br->ports[i];
2077             if (port != in_port && port_includes_vlan(port, vlan)
2078                 && !port->is_mirror_output_port
2079                 && set_dst(dst, flow, in_port, port, tags)) {
2080                 mirrors |= port->dst_mirrors;
2081                 dst++;
2082             }
2083         }
2084         *nf_output_iface = NF_OUT_FLOOD;
2085     } else if (out_port && set_dst(dst, flow, in_port, out_port, tags)) {
2086         *nf_output_iface = dst->xf_ifidx;
2087         mirrors |= out_port->dst_mirrors;
2088         dst++;
2089     }
2090
2091     while (mirrors) {
2092         struct mirror *m = br->mirrors[mirror_mask_ffs(mirrors) - 1];
2093         if (!m->n_vlans || vlan_is_mirrored(m, vlan)) {
2094             if (m->out_port) {
2095                 if (set_dst(dst, flow, in_port, m->out_port, tags)
2096                     && !dst_is_duplicate(dsts, dst - dsts, dst)) {
2097                     dst++;
2098                 }
2099             } else {
2100                 for (i = 0; i < br->n_ports; i++) {
2101                     struct port *port = br->ports[i];
2102                     if (port_includes_vlan(port, m->out_vlan)
2103                         && set_dst(dst, flow, in_port, port, tags))
2104                     {
2105                         int flow_vlan;
2106
2107                         if (port->vlan < 0) {
2108                             dst->vlan = m->out_vlan;
2109                         }
2110                         if (dst_is_duplicate(dsts, dst - dsts, dst)) {
2111                             continue;
2112                         }
2113
2114                         /* Use the vlan tag on the original flow instead of
2115                          * the one passed in the vlan parameter.  This ensures
2116                          * that we compare the vlan from before any implicit
2117                          * tagging tags place. This is necessary because
2118                          * dst->vlan is the final vlan, after removing implicit
2119                          * tags. */
2120                         flow_vlan = ntohs(flow->dl_vlan);
2121                         if (flow_vlan == 0) {
2122                             flow_vlan = OFP_VLAN_NONE;
2123                         }
2124                         if (port == in_port && dst->vlan == flow_vlan) {
2125                             /* Don't send out input port on same VLAN. */
2126                             continue;
2127                         }
2128                         dst++;
2129                     }
2130                 }
2131             }
2132         }
2133         mirrors &= mirrors - 1;
2134     }
2135
2136     partition_dsts(dsts, dst - dsts, ntohs(flow->dl_vlan));
2137     return dst - dsts;
2138 }
2139
2140 static void OVS_UNUSED
2141 print_dsts(const struct dst *dsts, size_t n)
2142 {
2143     for (; n--; dsts++) {
2144         printf(">p%"PRIu16, dsts->xf_ifidx);
2145         if (dsts->vlan != OFP_VLAN_NONE) {
2146             printf("v%"PRIu16, dsts->vlan);
2147         }
2148     }
2149 }
2150
2151 static void
2152 compose_actions(struct bridge *br, const flow_t *flow, uint16_t vlan,
2153                 const struct port *in_port, const struct port *out_port,
2154                 tag_type *tags, struct xflow_actions *actions,
2155                 uint16_t *nf_output_iface)
2156 {
2157     struct dst dsts[DP_MAX_PORTS * (MAX_MIRRORS + 1)];
2158     size_t n_dsts;
2159     const struct dst *p;
2160     uint16_t cur_vlan;
2161
2162     n_dsts = compose_dsts(br, flow, vlan, in_port, out_port, dsts, tags,
2163                           nf_output_iface);
2164
2165     cur_vlan = ntohs(flow->dl_vlan);
2166     for (p = dsts; p < &dsts[n_dsts]; p++) {
2167         union xflow_action *a;
2168         if (p->vlan != cur_vlan) {
2169             if (p->vlan == OFP_VLAN_NONE) {
2170                 xflow_actions_add(actions, XFLOWAT_STRIP_VLAN);
2171             } else {
2172                 a = xflow_actions_add(actions, XFLOWAT_SET_DL_TCI);
2173                 a->dl_tci.tci = htons(p->vlan & VLAN_VID_MASK);
2174                 a->dl_tci.mask = htons(VLAN_VID_MASK);
2175             }
2176             cur_vlan = p->vlan;
2177         }
2178         a = xflow_actions_add(actions, XFLOWAT_OUTPUT);
2179         a->output.port = p->xf_ifidx;
2180     }
2181 }
2182
2183 /* Returns the effective vlan of a packet, taking into account both the
2184  * 802.1Q header and implicitly tagged ports.  A value of 0 indicates that
2185  * the packet is untagged and -1 indicates it has an invalid header and
2186  * should be dropped. */
2187 static int flow_get_vlan(struct bridge *br, const flow_t *flow,
2188                          struct port *in_port, bool have_packet)
2189 {
2190     /* Note that dl_vlan of 0 and of OFP_VLAN_NONE both mean that the packet
2191      * belongs to VLAN 0, so we should treat both cases identically.  (In the
2192      * former case, the packet has an 802.1Q header that specifies VLAN 0,
2193      * presumably to allow a priority to be specified.  In the latter case, the
2194      * packet does not have any 802.1Q header.) */
2195     int vlan = ntohs(flow->dl_vlan);
2196     if (vlan == OFP_VLAN_NONE) {
2197         vlan = 0;
2198     }
2199     if (in_port->vlan >= 0) {
2200         if (vlan) {
2201             /* XXX support double tagging? */
2202             if (have_packet) {
2203                 static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
2204                 VLOG_WARN_RL(&rl, "bridge %s: dropping VLAN %"PRIu16" tagged "
2205                              "packet received on port %s configured with "
2206                              "implicit VLAN %"PRIu16,
2207                              br->name, ntohs(flow->dl_vlan),
2208                              in_port->name, in_port->vlan);
2209             }
2210             return -1;
2211         }
2212         vlan = in_port->vlan;
2213     } else {
2214         if (!port_includes_vlan(in_port, vlan)) {
2215             if (have_packet) {
2216                 static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
2217                 VLOG_WARN_RL(&rl, "bridge %s: dropping VLAN %d tagged "
2218                              "packet received on port %s not configured for "
2219                              "trunking VLAN %d",
2220                              br->name, vlan, in_port->name, vlan);
2221             }
2222             return -1;
2223         }
2224     }
2225
2226     return vlan;
2227 }
2228
2229 /* A VM broadcasts a gratuitous ARP to indicate that it has resumed after
2230  * migration.  Older Citrix-patched Linux DomU used gratuitous ARP replies to
2231  * indicate this; newer upstream kernels use gratuitous ARP requests. */
2232 static bool
2233 is_gratuitous_arp(const flow_t *flow)
2234 {
2235     return (flow->dl_type == htons(ETH_TYPE_ARP)
2236             && eth_addr_is_broadcast(flow->dl_dst)
2237             && (flow->nw_proto == ARP_OP_REPLY
2238                 || (flow->nw_proto == ARP_OP_REQUEST
2239                     && flow->nw_src == flow->nw_dst)));
2240 }
2241
2242 static void
2243 update_learning_table(struct bridge *br, const flow_t *flow, int vlan,
2244                       struct port *in_port)
2245 {
2246     enum grat_arp_lock_type lock_type;
2247     tag_type rev_tag;
2248
2249     /* We don't want to learn from gratuitous ARP packets that are reflected
2250      * back over bond slaves so we lock the learning table. */
2251     lock_type = !is_gratuitous_arp(flow) ? GRAT_ARP_LOCK_NONE :
2252                     (in_port->n_ifaces == 1) ? GRAT_ARP_LOCK_SET :
2253                                                GRAT_ARP_LOCK_CHECK;
2254
2255     rev_tag = mac_learning_learn(br->ml, flow->dl_src, vlan, in_port->port_idx,
2256                                  lock_type);
2257     if (rev_tag) {
2258         /* The log messages here could actually be useful in debugging,
2259          * so keep the rate limit relatively high. */
2260         static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(30,
2261                                                                 300);
2262         VLOG_DBG_RL(&rl, "bridge %s: learned that "ETH_ADDR_FMT" is "
2263                     "on port %s in VLAN %d",
2264                     br->name, ETH_ADDR_ARGS(flow->dl_src),
2265                     in_port->name, vlan);
2266         ofproto_revalidate(br->ofproto, rev_tag);
2267     }
2268 }
2269
2270 /* Determines whether packets in 'flow' within 'br' should be forwarded or
2271  * dropped.  Returns true if they may be forwarded, false if they should be
2272  * dropped.
2273  *
2274  * If 'have_packet' is true, it indicates that the caller is processing a
2275  * received packet.  If 'have_packet' is false, then the caller is just
2276  * revalidating an existing flow because configuration has changed.  Either
2277  * way, 'have_packet' only affects logging (there is no point in logging errors
2278  * during revalidation).
2279  *
2280  * Sets '*in_portp' to the input port.  This will be a null pointer if
2281  * flow->in_port does not designate a known input port (in which case
2282  * is_admissible() returns false).
2283  *
2284  * When returning true, sets '*vlanp' to the effective VLAN of the input
2285  * packet, as returned by flow_get_vlan().
2286  *
2287  * May also add tags to '*tags', although the current implementation only does
2288  * so in one special case.
2289  */
2290 static bool
2291 is_admissible(struct bridge *br, const flow_t *flow, bool have_packet,
2292               tag_type *tags, int *vlanp, struct port **in_portp)
2293 {
2294     struct iface *in_iface;
2295     struct port *in_port;
2296     int vlan;
2297
2298     /* Find the interface and port structure for the received packet. */
2299     in_iface = iface_from_xf_ifidx(br, flow->in_port);
2300     if (!in_iface) {
2301         /* No interface?  Something fishy... */
2302         if (have_packet) {
2303             /* Odd.  A few possible reasons here:
2304              *
2305              * - We deleted an interface but there are still a few packets
2306              *   queued up from it.
2307              *
2308              * - Someone externally added an interface (e.g. with "ovs-dpctl
2309              *   add-if") that we don't know about.
2310              *
2311              * - Packet arrived on the local port but the local port is not
2312              *   one of our bridge ports.
2313              */
2314             static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
2315
2316             VLOG_WARN_RL(&rl, "bridge %s: received packet on unknown "
2317                          "interface %"PRIu16, br->name, flow->in_port);
2318         }
2319
2320         *in_portp = NULL;
2321         return false;
2322     }
2323     *in_portp = in_port = in_iface->port;
2324     *vlanp = vlan = flow_get_vlan(br, flow, in_port, have_packet);
2325     if (vlan < 0) {
2326         return false;
2327     }
2328
2329     /* Drop frames for reserved multicast addresses. */
2330     if (eth_addr_is_reserved(flow->dl_dst)) {
2331         return false;
2332     }
2333
2334     /* Drop frames on ports reserved for mirroring. */
2335     if (in_port->is_mirror_output_port) {
2336         if (have_packet) {
2337             static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
2338             VLOG_WARN_RL(&rl, "bridge %s: dropping packet received on port "
2339                          "%s, which is reserved exclusively for mirroring",
2340                          br->name, in_port->name);
2341         }
2342         return false;
2343     }
2344
2345     /* Packets received on bonds need special attention to avoid duplicates. */
2346     if (in_port->n_ifaces > 1) {
2347         int src_idx;
2348         bool is_grat_arp_locked;
2349
2350         if (eth_addr_is_multicast(flow->dl_dst)) {
2351             *tags |= in_port->active_iface_tag;
2352             if (in_port->active_iface != in_iface->port_ifidx) {
2353                 /* Drop all multicast packets on inactive slaves. */
2354                 return false;
2355             }
2356         }
2357
2358         /* Drop all packets for which we have learned a different input
2359          * port, because we probably sent the packet on one slave and got
2360          * it back on the other.  Gratuitous ARP packets are an exception
2361          * to this rule: the host has moved to another switch.  The exception
2362          * to the exception is if we locked the learning table to avoid
2363          * reflections on bond slaves.  If this is the case, just drop the
2364          * packet now. */
2365         src_idx = mac_learning_lookup(br->ml, flow->dl_src, vlan,
2366                                       &is_grat_arp_locked);
2367         if (src_idx != -1 && src_idx != in_port->port_idx &&
2368             (!is_gratuitous_arp(flow) || is_grat_arp_locked)) {
2369                 return false;
2370         }
2371     }
2372
2373     return true;
2374 }
2375
2376 /* If the composed actions may be applied to any packet in the given 'flow',
2377  * returns true.  Otherwise, the actions should only be applied to 'packet', or
2378  * not at all, if 'packet' was NULL. */
2379 static bool
2380 process_flow(struct bridge *br, const flow_t *flow,
2381              const struct ofpbuf *packet, struct xflow_actions *actions,
2382              tag_type *tags, uint16_t *nf_output_iface)
2383 {
2384     struct port *in_port;
2385     struct port *out_port;
2386     int vlan;
2387     int out_port_idx;
2388
2389     /* Check whether we should drop packets in this flow. */
2390     if (!is_admissible(br, flow, packet != NULL, tags, &vlan, &in_port)) {
2391         out_port = NULL;
2392         goto done;
2393     }
2394
2395     /* Learn source MAC (but don't try to learn from revalidation). */
2396     if (packet) {
2397         update_learning_table(br, flow, vlan, in_port);
2398     }
2399
2400     /* Determine output port. */
2401     out_port_idx = mac_learning_lookup_tag(br->ml, flow->dl_dst, vlan, tags,
2402                                            NULL);
2403     if (out_port_idx >= 0 && out_port_idx < br->n_ports) {
2404         out_port = br->ports[out_port_idx];
2405     } else if (!packet && !eth_addr_is_multicast(flow->dl_dst)) {
2406         /* If we are revalidating but don't have a learning entry then
2407          * eject the flow.  Installing a flow that floods packets opens
2408          * up a window of time where we could learn from a packet reflected
2409          * on a bond and blackhole packets before the learning table is
2410          * updated to reflect the correct port. */
2411         return false;
2412     } else {
2413         out_port = FLOOD_PORT;
2414     }
2415
2416     /* Don't send packets out their input ports. */
2417     if (in_port == out_port) {
2418         out_port = NULL;
2419     }
2420
2421 done:
2422     if (in_port) {
2423         compose_actions(br, flow, vlan, in_port, out_port, tags, actions,
2424                         nf_output_iface);
2425     }
2426
2427     return true;
2428 }
2429
2430 /* Careful: 'opp' is in host byte order and opp->port_no is an OFP port
2431  * number. */
2432 static void
2433 bridge_port_changed_ofhook_cb(enum ofp_port_reason reason,
2434                               const struct ofp_phy_port *opp,
2435                               void *br_)
2436 {
2437     struct bridge *br = br_;
2438     struct iface *iface;
2439     struct port *port;
2440
2441     iface = iface_from_xf_ifidx(br, ofp_port_to_xflow_port(opp->port_no));
2442     if (!iface) {
2443         return;
2444     }
2445     port = iface->port;
2446
2447     if (reason == OFPPR_DELETE) {
2448         VLOG_WARN("bridge %s: interface %s deleted unexpectedly",
2449                   br->name, iface->name);
2450         iface_destroy(iface);
2451         if (!port->n_ifaces) {
2452             VLOG_WARN("bridge %s: port %s has no interfaces, dropping",
2453                       br->name, port->name);
2454             port_destroy(port);
2455         }
2456
2457         bridge_flush(br);
2458     } else {
2459         if (port->n_ifaces > 1) {
2460             bool up = !(opp->state & OFPPS_LINK_DOWN);
2461             bond_link_status_update(iface, up);
2462             port_update_bond_compat(port);
2463         }
2464     }
2465 }
2466
2467 static bool
2468 bridge_normal_ofhook_cb(const flow_t *flow, const struct ofpbuf *packet,
2469                         struct xflow_actions *actions, tag_type *tags,
2470                         uint16_t *nf_output_iface, void *br_)
2471 {
2472     struct bridge *br = br_;
2473
2474     COVERAGE_INC(bridge_process_flow);
2475     return process_flow(br, flow, packet, actions, tags, nf_output_iface);
2476 }
2477
2478 static void
2479 bridge_account_flow_ofhook_cb(const flow_t *flow,
2480                               const union xflow_action *actions,
2481                               size_t n_actions, unsigned long long int n_bytes,
2482                               void *br_)
2483 {
2484     struct bridge *br = br_;
2485     const union xflow_action *a;
2486     struct port *in_port;
2487     tag_type tags = 0;
2488     int vlan;
2489
2490     /* Feed information from the active flows back into the learning table
2491      * to ensure that table is always in sync with what is actually flowing
2492      * through the datapath. */
2493     if (is_admissible(br, flow, false, &tags, &vlan, &in_port)) {
2494         update_learning_table(br, flow, vlan, in_port);
2495     }
2496
2497     if (!br->has_bonded_ports) {
2498         return;
2499     }
2500
2501     for (a = actions; a < &actions[n_actions]; a++) {
2502         if (a->type == XFLOWAT_OUTPUT) {
2503             struct port *out_port = port_from_xf_ifidx(br, a->output.port);
2504             if (out_port && out_port->n_ifaces >= 2) {
2505                 struct bond_entry *e = lookup_bond_entry(out_port,
2506                                                          flow->dl_src);
2507                 e->tx_bytes += n_bytes;
2508             }
2509         }
2510     }
2511 }
2512
2513 static void
2514 bridge_account_checkpoint_ofhook_cb(void *br_)
2515 {
2516     struct bridge *br = br_;
2517     long long int now;
2518     size_t i;
2519
2520     if (!br->has_bonded_ports) {
2521         return;
2522     }
2523
2524     now = time_msec();
2525     for (i = 0; i < br->n_ports; i++) {
2526         struct port *port = br->ports[i];
2527         if (port->n_ifaces > 1 && now >= port->bond_next_rebalance) {
2528             port->bond_next_rebalance = now + port->bond_rebalance_interval;
2529             bond_rebalance_port(port);
2530         }
2531     }
2532 }
2533
2534 static struct ofhooks bridge_ofhooks = {
2535     bridge_port_changed_ofhook_cb,
2536     bridge_normal_ofhook_cb,
2537     bridge_account_flow_ofhook_cb,
2538     bridge_account_checkpoint_ofhook_cb,
2539 };
2540 \f
2541 /* Bonding functions. */
2542
2543 /* Statistics for a single interface on a bonded port, used for load-based
2544  * bond rebalancing.  */
2545 struct slave_balance {
2546     struct iface *iface;        /* The interface. */
2547     uint64_t tx_bytes;          /* Sum of hashes[*]->tx_bytes. */
2548
2549     /* All the "bond_entry"s that are assigned to this interface, in order of
2550      * increasing tx_bytes. */
2551     struct bond_entry **hashes;
2552     size_t n_hashes;
2553 };
2554
2555 /* Sorts pointers to pointers to bond_entries in ascending order by the
2556  * interface to which they are assigned, and within a single interface in
2557  * ascending order of bytes transmitted. */
2558 static int
2559 compare_bond_entries(const void *a_, const void *b_)
2560 {
2561     const struct bond_entry *const *ap = a_;
2562     const struct bond_entry *const *bp = b_;
2563     const struct bond_entry *a = *ap;
2564     const struct bond_entry *b = *bp;
2565     if (a->iface_idx != b->iface_idx) {
2566         return a->iface_idx > b->iface_idx ? 1 : -1;
2567     } else if (a->tx_bytes != b->tx_bytes) {
2568         return a->tx_bytes > b->tx_bytes ? 1 : -1;
2569     } else {
2570         return 0;
2571     }
2572 }
2573
2574 /* Sorts slave_balances so that enabled ports come first, and otherwise in
2575  * *descending* order by number of bytes transmitted. */
2576 static int
2577 compare_slave_balance(const void *a_, const void *b_)
2578 {
2579     const struct slave_balance *a = a_;
2580     const struct slave_balance *b = b_;
2581     if (a->iface->enabled != b->iface->enabled) {
2582         return a->iface->enabled ? -1 : 1;
2583     } else if (a->tx_bytes != b->tx_bytes) {
2584         return a->tx_bytes > b->tx_bytes ? -1 : 1;
2585     } else {
2586         return 0;
2587     }
2588 }
2589
2590 static void
2591 swap_bals(struct slave_balance *a, struct slave_balance *b)
2592 {
2593     struct slave_balance tmp = *a;
2594     *a = *b;
2595     *b = tmp;
2596 }
2597
2598 /* Restores the 'n_bals' slave_balance structures in 'bals' to sorted order
2599  * given that 'p' (and only 'p') might be in the wrong location.
2600  *
2601  * This function invalidates 'p', since it might now be in a different memory
2602  * location. */
2603 static void
2604 resort_bals(struct slave_balance *p,
2605             struct slave_balance bals[], size_t n_bals)
2606 {
2607     if (n_bals > 1) {
2608         for (; p > bals && p->tx_bytes > p[-1].tx_bytes; p--) {
2609             swap_bals(p, p - 1);
2610         }
2611         for (; p < &bals[n_bals - 1] && p->tx_bytes < p[1].tx_bytes; p++) {
2612             swap_bals(p, p + 1);
2613         }
2614     }
2615 }
2616
2617 static void
2618 log_bals(const struct slave_balance *bals, size_t n_bals, struct port *port)
2619 {
2620     if (VLOG_IS_DBG_ENABLED()) {
2621         struct ds ds = DS_EMPTY_INITIALIZER;
2622         const struct slave_balance *b;
2623
2624         for (b = bals; b < bals + n_bals; b++) {
2625             size_t i;
2626
2627             if (b > bals) {
2628                 ds_put_char(&ds, ',');
2629             }
2630             ds_put_format(&ds, " %s %"PRIu64"kB",
2631                           b->iface->name, b->tx_bytes / 1024);
2632
2633             if (!b->iface->enabled) {
2634                 ds_put_cstr(&ds, " (disabled)");
2635             }
2636             if (b->n_hashes > 0) {
2637                 ds_put_cstr(&ds, " (");
2638                 for (i = 0; i < b->n_hashes; i++) {
2639                     const struct bond_entry *e = b->hashes[i];
2640                     if (i > 0) {
2641                         ds_put_cstr(&ds, " + ");
2642                     }
2643                     ds_put_format(&ds, "h%td: %"PRIu64"kB",
2644                                   e - port->bond_hash, e->tx_bytes / 1024);
2645                 }
2646                 ds_put_cstr(&ds, ")");
2647             }
2648         }
2649         VLOG_DBG("bond %s:%s", port->name, ds_cstr(&ds));
2650         ds_destroy(&ds);
2651     }
2652 }
2653
2654 /* Shifts 'hash' from 'from' to 'to' within 'port'. */
2655 static void
2656 bond_shift_load(struct slave_balance *from, struct slave_balance *to,
2657                 int hash_idx)
2658 {
2659     struct bond_entry *hash = from->hashes[hash_idx];
2660     struct port *port = from->iface->port;
2661     uint64_t delta = hash->tx_bytes;
2662
2663     VLOG_INFO("bond %s: shift %"PRIu64"kB of load (with hash %td) "
2664               "from %s to %s (now carrying %"PRIu64"kB and "
2665               "%"PRIu64"kB load, respectively)",
2666               port->name, delta / 1024, hash - port->bond_hash,
2667               from->iface->name, to->iface->name,
2668               (from->tx_bytes - delta) / 1024,
2669               (to->tx_bytes + delta) / 1024);
2670
2671     /* Delete element from from->hashes.
2672      *
2673      * We don't bother to add the element to to->hashes because not only would
2674      * it require more work, the only purpose it would be to allow that hash to
2675      * be migrated to another slave in this rebalancing run, and there is no
2676      * point in doing that.  */
2677     if (hash_idx == 0) {
2678         from->hashes++;
2679     } else {
2680         memmove(from->hashes + hash_idx, from->hashes + hash_idx + 1,
2681                 (from->n_hashes - (hash_idx + 1)) * sizeof *from->hashes);
2682     }
2683     from->n_hashes--;
2684
2685     /* Shift load away from 'from' to 'to'. */
2686     from->tx_bytes -= delta;
2687     to->tx_bytes += delta;
2688
2689     /* Arrange for flows to be revalidated. */
2690     ofproto_revalidate(port->bridge->ofproto, hash->iface_tag);
2691     hash->iface_idx = to->iface->port_ifidx;
2692     hash->iface_tag = tag_create_random();
2693 }
2694
2695 static void
2696 bond_rebalance_port(struct port *port)
2697 {
2698     struct slave_balance bals[DP_MAX_PORTS];
2699     size_t n_bals;
2700     struct bond_entry *hashes[BOND_MASK + 1];
2701     struct slave_balance *b, *from, *to;
2702     struct bond_entry *e;
2703     size_t i;
2704
2705     /* Sets up 'bals' to describe each of the port's interfaces, sorted in
2706      * descending order of tx_bytes, so that bals[0] represents the most
2707      * heavily loaded slave and bals[n_bals - 1] represents the least heavily
2708      * loaded slave.
2709      *
2710      * The code is a bit tricky: to avoid dynamically allocating a 'hashes'
2711      * array for each slave_balance structure, we sort our local array of
2712      * hashes in order by slave, so that all of the hashes for a given slave
2713      * become contiguous in memory, and then we point each 'hashes' members of
2714      * a slave_balance structure to the start of a contiguous group. */
2715     n_bals = port->n_ifaces;
2716     for (b = bals; b < &bals[n_bals]; b++) {
2717         b->iface = port->ifaces[b - bals];
2718         b->tx_bytes = 0;
2719         b->hashes = NULL;
2720         b->n_hashes = 0;
2721     }
2722     for (i = 0; i <= BOND_MASK; i++) {
2723         hashes[i] = &port->bond_hash[i];
2724     }
2725     qsort(hashes, BOND_MASK + 1, sizeof *hashes, compare_bond_entries);
2726     for (i = 0; i <= BOND_MASK; i++) {
2727         e = hashes[i];
2728         if (e->iface_idx >= 0 && e->iface_idx < port->n_ifaces) {
2729             b = &bals[e->iface_idx];
2730             b->tx_bytes += e->tx_bytes;
2731             if (!b->hashes) {
2732                 b->hashes = &hashes[i];
2733             }
2734             b->n_hashes++;
2735         }
2736     }
2737     qsort(bals, n_bals, sizeof *bals, compare_slave_balance);
2738     log_bals(bals, n_bals, port);
2739
2740     /* Discard slaves that aren't enabled (which were sorted to the back of the
2741      * array earlier). */
2742     while (!bals[n_bals - 1].iface->enabled) {
2743         n_bals--;
2744         if (!n_bals) {
2745             return;
2746         }
2747     }
2748
2749     /* Shift load from the most-loaded slaves to the least-loaded slaves. */
2750     to = &bals[n_bals - 1];
2751     for (from = bals; from < to; ) {
2752         uint64_t overload = from->tx_bytes - to->tx_bytes;
2753         if (overload < to->tx_bytes >> 5 || overload < 100000) {
2754             /* The extra load on 'from' (and all less-loaded slaves), compared
2755              * to that of 'to' (the least-loaded slave), is less than ~3%, or
2756              * it is less than ~1Mbps.  No point in rebalancing. */
2757             break;
2758         } else if (from->n_hashes == 1) {
2759             /* 'from' only carries a single MAC hash, so we can't shift any
2760              * load away from it, even though we want to. */
2761             from++;
2762         } else {
2763             /* 'from' is carrying significantly more load than 'to', and that
2764              * load is split across at least two different hashes.  Pick a hash
2765              * to migrate to 'to' (the least-loaded slave), given that doing so
2766              * must decrease the ratio of the load on the two slaves by at
2767              * least 0.1.
2768              *
2769              * The sort order we use means that we prefer to shift away the
2770              * smallest hashes instead of the biggest ones.  There is little
2771              * reason behind this decision; we could use the opposite sort
2772              * order to shift away big hashes ahead of small ones. */
2773             size_t i;
2774             bool order_swapped;
2775
2776             for (i = 0; i < from->n_hashes; i++) {
2777                 double old_ratio, new_ratio;
2778                 uint64_t delta = from->hashes[i]->tx_bytes;
2779
2780                 if (delta == 0 || from->tx_bytes - delta == 0) {
2781                     /* Pointless move. */
2782                     continue;
2783                 }
2784
2785                 order_swapped = from->tx_bytes - delta < to->tx_bytes + delta;
2786
2787                 if (to->tx_bytes == 0) {
2788                     /* Nothing on the new slave, move it. */
2789                     break;
2790                 }
2791
2792                 old_ratio = (double)from->tx_bytes / to->tx_bytes;
2793                 new_ratio = (double)(from->tx_bytes - delta) /
2794                             (to->tx_bytes + delta);
2795
2796                 if (new_ratio == 0) {
2797                     /* Should already be covered but check to prevent division
2798                      * by zero. */
2799                     continue;
2800                 }
2801
2802                 if (new_ratio < 1) {
2803                     new_ratio = 1 / new_ratio;
2804                 }
2805
2806                 if (old_ratio - new_ratio > 0.1) {
2807                     /* Would decrease the ratio, move it. */
2808                     break;
2809                 }
2810             }
2811             if (i < from->n_hashes) {
2812                 bond_shift_load(from, to, i);
2813                 port->bond_compat_is_stale = true;
2814
2815                 /* If the result of the migration changed the relative order of
2816                  * 'from' and 'to' swap them back to maintain invariants. */
2817                 if (order_swapped) {
2818                     swap_bals(from, to);
2819                 }
2820
2821                 /* Re-sort 'bals'.  Note that this may make 'from' and 'to'
2822                  * point to different slave_balance structures.  It is only
2823                  * valid to do these two operations in a row at all because we
2824                  * know that 'from' will not move past 'to' and vice versa. */
2825                 resort_bals(from, bals, n_bals);
2826                 resort_bals(to, bals, n_bals);
2827             } else {
2828                 from++;
2829             }
2830         }
2831     }
2832
2833     /* Implement exponentially weighted moving average.  A weight of 1/2 causes
2834      * historical data to decay to <1% in 7 rebalancing runs.  */
2835     for (e = &port->bond_hash[0]; e <= &port->bond_hash[BOND_MASK]; e++) {
2836         e->tx_bytes /= 2;
2837     }
2838 }
2839
2840 static void
2841 bond_send_learning_packets(struct port *port)
2842 {
2843     struct bridge *br = port->bridge;
2844     struct mac_entry *e;
2845     struct ofpbuf packet;
2846     int error, n_packets, n_errors;
2847
2848     if (!port->n_ifaces || port->active_iface < 0) {
2849         return;
2850     }
2851
2852     ofpbuf_init(&packet, 128);
2853     error = n_packets = n_errors = 0;
2854     LIST_FOR_EACH (e, struct mac_entry, lru_node, &br->ml->lrus) {
2855         union ofp_action actions[2], *a;
2856         uint16_t xf_ifidx;
2857         tag_type tags = 0;
2858         flow_t flow;
2859         int retval;
2860
2861         if (e->port == port->port_idx
2862             || !choose_output_iface(port, e->mac, &xf_ifidx, &tags)) {
2863             continue;
2864         }
2865
2866         /* Compose actions. */
2867         memset(actions, 0, sizeof actions);
2868         a = actions;
2869         if (e->vlan) {
2870             a->vlan_vid.type = htons(OFPAT_SET_VLAN_VID);
2871             a->vlan_vid.len = htons(sizeof *a);
2872             a->vlan_vid.vlan_vid = htons(e->vlan);
2873             a++;
2874         }
2875         a->output.type = htons(OFPAT_OUTPUT);
2876         a->output.len = htons(sizeof *a);
2877         a->output.port = htons(xflow_port_to_ofp_port(xf_ifidx));
2878         a++;
2879
2880         /* Send packet. */
2881         n_packets++;
2882         compose_benign_packet(&packet, "Open vSwitch Bond Failover", 0xf177,
2883                               e->mac);
2884         flow_extract(&packet, 0, XFLOWP_NONE, &flow);
2885         retval = ofproto_send_packet(br->ofproto, &flow, actions, a - actions,
2886                                      &packet);
2887         if (retval) {
2888             error = retval;
2889             n_errors++;
2890         }
2891     }
2892     ofpbuf_uninit(&packet);
2893
2894     if (n_errors) {
2895         static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
2896         VLOG_WARN_RL(&rl, "bond %s: %d errors sending %d gratuitous learning "
2897                      "packets, last error was: %s",
2898                      port->name, n_errors, n_packets, strerror(error));
2899     } else {
2900         VLOG_DBG("bond %s: sent %d gratuitous learning packets",
2901                  port->name, n_packets);
2902     }
2903 }
2904 \f
2905 /* Bonding unixctl user interface functions. */
2906
2907 static void
2908 bond_unixctl_list(struct unixctl_conn *conn,
2909                   const char *args OVS_UNUSED, void *aux OVS_UNUSED)
2910 {
2911     struct ds ds = DS_EMPTY_INITIALIZER;
2912     const struct bridge *br;
2913
2914     ds_put_cstr(&ds, "bridge\tbond\tslaves\n");
2915
2916     LIST_FOR_EACH (br, struct bridge, node, &all_bridges) {
2917         size_t i;
2918
2919         for (i = 0; i < br->n_ports; i++) {
2920             const struct port *port = br->ports[i];
2921             if (port->n_ifaces > 1) {
2922                 size_t j;
2923
2924                 ds_put_format(&ds, "%s\t%s\t", br->name, port->name);
2925                 for (j = 0; j < port->n_ifaces; j++) {
2926                     const struct iface *iface = port->ifaces[j];
2927                     if (j) {
2928                         ds_put_cstr(&ds, ", ");
2929                     }
2930                     ds_put_cstr(&ds, iface->name);
2931                 }
2932                 ds_put_char(&ds, '\n');
2933             }
2934         }
2935     }
2936     unixctl_command_reply(conn, 200, ds_cstr(&ds));
2937     ds_destroy(&ds);
2938 }
2939
2940 static struct port *
2941 bond_find(const char *name)
2942 {
2943     const struct bridge *br;
2944
2945     LIST_FOR_EACH (br, struct bridge, node, &all_bridges) {
2946         size_t i;
2947
2948         for (i = 0; i < br->n_ports; i++) {
2949             struct port *port = br->ports[i];
2950             if (!strcmp(port->name, name) && port->n_ifaces > 1) {
2951                 return port;
2952             }
2953         }
2954     }
2955     return NULL;
2956 }
2957
2958 static void
2959 bond_unixctl_show(struct unixctl_conn *conn,
2960                   const char *args, void *aux OVS_UNUSED)
2961 {
2962     struct ds ds = DS_EMPTY_INITIALIZER;
2963     const struct port *port;
2964     size_t j;
2965
2966     port = bond_find(args);
2967     if (!port) {
2968         unixctl_command_reply(conn, 501, "no such bond");
2969         return;
2970     }
2971
2972     ds_put_format(&ds, "updelay: %d ms\n", port->updelay);
2973     ds_put_format(&ds, "downdelay: %d ms\n", port->downdelay);
2974     ds_put_format(&ds, "next rebalance: %lld ms\n",
2975                   port->bond_next_rebalance - time_msec());
2976     for (j = 0; j < port->n_ifaces; j++) {
2977         const struct iface *iface = port->ifaces[j];
2978         struct bond_entry *be;
2979
2980         /* Basic info. */
2981         ds_put_format(&ds, "slave %s: %s\n",
2982                       iface->name, iface->enabled ? "enabled" : "disabled");
2983         if (j == port->active_iface) {
2984             ds_put_cstr(&ds, "\tactive slave\n");
2985         }
2986         if (iface->delay_expires != LLONG_MAX) {
2987             ds_put_format(&ds, "\t%s expires in %lld ms\n",
2988                           iface->enabled ? "downdelay" : "updelay",
2989                           iface->delay_expires - time_msec());
2990         }
2991
2992         /* Hashes. */
2993         for (be = port->bond_hash; be <= &port->bond_hash[BOND_MASK]; be++) {
2994             int hash = be - port->bond_hash;
2995             struct mac_entry *me;
2996
2997             if (be->iface_idx != j) {
2998                 continue;
2999             }
3000
3001             ds_put_format(&ds, "\thash %d: %"PRIu64" kB load\n",
3002                           hash, be->tx_bytes / 1024);
3003
3004             /* MACs. */
3005             LIST_FOR_EACH (me, struct mac_entry, lru_node,
3006                            &port->bridge->ml->lrus) {
3007                 uint16_t xf_ifidx;
3008                 tag_type tags = 0;
3009                 if (bond_hash(me->mac) == hash
3010                     && me->port != port->port_idx
3011                     && choose_output_iface(port, me->mac, &xf_ifidx, &tags)
3012                     && xf_ifidx == iface->xf_ifidx)
3013                 {
3014                     ds_put_format(&ds, "\t\t"ETH_ADDR_FMT"\n",
3015                                   ETH_ADDR_ARGS(me->mac));
3016                 }
3017             }
3018         }
3019     }
3020     unixctl_command_reply(conn, 200, ds_cstr(&ds));
3021     ds_destroy(&ds);
3022 }
3023
3024 static void
3025 bond_unixctl_migrate(struct unixctl_conn *conn, const char *args_,
3026                      void *aux OVS_UNUSED)
3027 {
3028     char *args = (char *) args_;
3029     char *save_ptr = NULL;
3030     char *bond_s, *hash_s, *slave_s;
3031     uint8_t mac[ETH_ADDR_LEN];
3032     struct port *port;
3033     struct iface *iface;
3034     struct bond_entry *entry;
3035     int hash;
3036
3037     bond_s = strtok_r(args, " ", &save_ptr);
3038     hash_s = strtok_r(NULL, " ", &save_ptr);
3039     slave_s = strtok_r(NULL, " ", &save_ptr);
3040     if (!slave_s) {
3041         unixctl_command_reply(conn, 501,
3042                               "usage: bond/migrate BOND HASH SLAVE");
3043         return;
3044     }
3045
3046     port = bond_find(bond_s);
3047     if (!port) {
3048         unixctl_command_reply(conn, 501, "no such bond");
3049         return;
3050     }
3051
3052     if (sscanf(hash_s, ETH_ADDR_SCAN_FMT, ETH_ADDR_SCAN_ARGS(mac))
3053         == ETH_ADDR_SCAN_COUNT) {
3054         hash = bond_hash(mac);
3055     } else if (strspn(hash_s, "0123456789") == strlen(hash_s)) {
3056         hash = atoi(hash_s) & BOND_MASK;
3057     } else {
3058         unixctl_command_reply(conn, 501, "bad hash");
3059         return;
3060     }
3061
3062     iface = port_lookup_iface(port, slave_s);
3063     if (!iface) {
3064         unixctl_command_reply(conn, 501, "no such slave");
3065         return;
3066     }
3067
3068     if (!iface->enabled) {
3069         unixctl_command_reply(conn, 501, "cannot migrate to disabled slave");
3070         return;
3071     }
3072
3073     entry = &port->bond_hash[hash];
3074     ofproto_revalidate(port->bridge->ofproto, entry->iface_tag);
3075     entry->iface_idx = iface->port_ifidx;
3076     entry->iface_tag = tag_create_random();
3077     port->bond_compat_is_stale = true;
3078     unixctl_command_reply(conn, 200, "migrated");
3079 }
3080
3081 static void
3082 bond_unixctl_set_active_slave(struct unixctl_conn *conn, const char *args_,
3083                               void *aux OVS_UNUSED)
3084 {
3085     char *args = (char *) args_;
3086     char *save_ptr = NULL;
3087     char *bond_s, *slave_s;
3088     struct port *port;
3089     struct iface *iface;
3090
3091     bond_s = strtok_r(args, " ", &save_ptr);
3092     slave_s = strtok_r(NULL, " ", &save_ptr);
3093     if (!slave_s) {
3094         unixctl_command_reply(conn, 501,
3095                               "usage: bond/set-active-slave BOND SLAVE");
3096         return;
3097     }
3098
3099     port = bond_find(bond_s);
3100     if (!port) {
3101         unixctl_command_reply(conn, 501, "no such bond");
3102         return;
3103     }
3104
3105     iface = port_lookup_iface(port, slave_s);
3106     if (!iface) {
3107         unixctl_command_reply(conn, 501, "no such slave");
3108         return;
3109     }
3110
3111     if (!iface->enabled) {
3112         unixctl_command_reply(conn, 501, "cannot make disabled slave active");
3113         return;
3114     }
3115
3116     if (port->active_iface != iface->port_ifidx) {
3117         ofproto_revalidate(port->bridge->ofproto, port->active_iface_tag);
3118         port->active_iface = iface->port_ifidx;
3119         port->active_iface_tag = tag_create_random();
3120         VLOG_INFO("port %s: active interface is now %s",
3121                   port->name, iface->name);
3122         bond_send_learning_packets(port);
3123         unixctl_command_reply(conn, 200, "done");
3124     } else {
3125         unixctl_command_reply(conn, 200, "no change");
3126     }
3127 }
3128
3129 static void
3130 enable_slave(struct unixctl_conn *conn, const char *args_, bool enable)
3131 {
3132     char *args = (char *) args_;
3133     char *save_ptr = NULL;
3134     char *bond_s, *slave_s;
3135     struct port *port;
3136     struct iface *iface;
3137
3138     bond_s = strtok_r(args, " ", &save_ptr);
3139     slave_s = strtok_r(NULL, " ", &save_ptr);
3140     if (!slave_s) {
3141         unixctl_command_reply(conn, 501,
3142                               "usage: bond/enable/disable-slave BOND SLAVE");
3143         return;
3144     }
3145
3146     port = bond_find(bond_s);
3147     if (!port) {
3148         unixctl_command_reply(conn, 501, "no such bond");
3149         return;
3150     }
3151
3152     iface = port_lookup_iface(port, slave_s);
3153     if (!iface) {
3154         unixctl_command_reply(conn, 501, "no such slave");
3155         return;
3156     }
3157
3158     bond_enable_slave(iface, enable);
3159     unixctl_command_reply(conn, 501, enable ? "enabled" : "disabled");
3160 }
3161
3162 static void
3163 bond_unixctl_enable_slave(struct unixctl_conn *conn, const char *args,
3164                           void *aux OVS_UNUSED)
3165 {
3166     enable_slave(conn, args, true);
3167 }
3168
3169 static void
3170 bond_unixctl_disable_slave(struct unixctl_conn *conn, const char *args,
3171                            void *aux OVS_UNUSED)
3172 {
3173     enable_slave(conn, args, false);
3174 }
3175
3176 static void
3177 bond_unixctl_hash(struct unixctl_conn *conn, const char *args,
3178                   void *aux OVS_UNUSED)
3179 {
3180         uint8_t mac[ETH_ADDR_LEN];
3181         uint8_t hash;
3182         char *hash_cstr;
3183
3184         if (sscanf(args, ETH_ADDR_SCAN_FMT, ETH_ADDR_SCAN_ARGS(mac))
3185             == ETH_ADDR_SCAN_COUNT) {
3186                 hash = bond_hash(mac);
3187
3188                 hash_cstr = xasprintf("%u", hash);
3189                 unixctl_command_reply(conn, 200, hash_cstr);
3190                 free(hash_cstr);
3191         } else {
3192                 unixctl_command_reply(conn, 501, "invalid mac");
3193         }
3194 }
3195
3196 static void
3197 bond_init(void)
3198 {
3199     unixctl_command_register("bond/list", bond_unixctl_list, NULL);
3200     unixctl_command_register("bond/show", bond_unixctl_show, NULL);
3201     unixctl_command_register("bond/migrate", bond_unixctl_migrate, NULL);
3202     unixctl_command_register("bond/set-active-slave",
3203                              bond_unixctl_set_active_slave, NULL);
3204     unixctl_command_register("bond/enable-slave", bond_unixctl_enable_slave,
3205                              NULL);
3206     unixctl_command_register("bond/disable-slave", bond_unixctl_disable_slave,
3207                              NULL);
3208     unixctl_command_register("bond/hash", bond_unixctl_hash, NULL);
3209 }
3210 \f
3211 /* Port functions. */
3212
3213 static struct port *
3214 port_create(struct bridge *br, const char *name)
3215 {
3216     struct port *port;
3217
3218     port = xzalloc(sizeof *port);
3219     port->bridge = br;
3220     port->port_idx = br->n_ports;
3221     port->vlan = -1;
3222     port->trunks = NULL;
3223     port->name = xstrdup(name);
3224     port->active_iface = -1;
3225
3226     if (br->n_ports >= br->allocated_ports) {
3227         br->ports = x2nrealloc(br->ports, &br->allocated_ports,
3228                                sizeof *br->ports);
3229     }
3230     br->ports[br->n_ports++] = port;
3231     shash_add_assert(&br->port_by_name, port->name, port);
3232
3233     VLOG_INFO("created port %s on bridge %s", port->name, br->name);
3234     bridge_flush(br);
3235
3236     return port;
3237 }
3238
3239 static const char *
3240 get_port_other_config(const struct ovsrec_port *port, const char *key,
3241                       const char *default_value)
3242 {
3243     const char *value = get_ovsrec_key_value(key,
3244                                              port->key_other_config,
3245                                              port->value_other_config,
3246                                              port->n_other_config);
3247     return value ? value : default_value;
3248 }
3249
3250 static void
3251 port_del_ifaces(struct port *port, const struct ovsrec_port *cfg)
3252 {
3253     struct shash new_ifaces;
3254     size_t i;
3255
3256     /* Collect list of new interfaces. */
3257     shash_init(&new_ifaces);
3258     for (i = 0; i < cfg->n_interfaces; i++) {
3259         const char *name = cfg->interfaces[i]->name;
3260         shash_add_once(&new_ifaces, name, NULL);
3261     }
3262
3263     /* Get rid of deleted interfaces. */
3264     for (i = 0; i < port->n_ifaces; ) {
3265         if (!shash_find(&new_ifaces, cfg->interfaces[i]->name)) {
3266             iface_destroy(port->ifaces[i]);
3267         } else {
3268             i++;
3269         }
3270     }
3271
3272     shash_destroy(&new_ifaces);
3273 }
3274
3275 static void
3276 port_reconfigure(struct port *port, const struct ovsrec_port *cfg)
3277 {
3278     struct shash new_ifaces;
3279     long long int next_rebalance;
3280     unsigned long *trunks;
3281     int vlan;
3282     size_t i;
3283
3284     port->cfg = cfg;
3285
3286     /* Update settings. */
3287     port->updelay = cfg->bond_updelay;
3288     if (port->updelay < 0) {
3289         port->updelay = 0;
3290     }
3291     port->updelay = cfg->bond_downdelay;
3292     if (port->downdelay < 0) {
3293         port->downdelay = 0;
3294     }
3295     port->bond_rebalance_interval = atoi(
3296         get_port_other_config(cfg, "bond-rebalance-interval", "10000"));
3297     if (port->bond_rebalance_interval < 1000) {
3298         port->bond_rebalance_interval = 1000;
3299     }
3300     next_rebalance = time_msec() + port->bond_rebalance_interval;
3301     if (port->bond_next_rebalance > next_rebalance) {
3302         port->bond_next_rebalance = next_rebalance;
3303     }
3304
3305     /* Add new interfaces and update 'cfg' member of existing ones. */
3306     shash_init(&new_ifaces);
3307     for (i = 0; i < cfg->n_interfaces; i++) {
3308         const struct ovsrec_interface *if_cfg = cfg->interfaces[i];
3309         struct iface *iface;
3310
3311         if (!shash_add_once(&new_ifaces, if_cfg->name, NULL)) {
3312             VLOG_WARN("port %s: %s specified twice as port interface",
3313                       port->name, if_cfg->name);
3314             continue;
3315         }
3316
3317         iface = iface_lookup(port->bridge, if_cfg->name);
3318         if (iface) {
3319             if (iface->port != port) {
3320                 VLOG_ERR("bridge %s: %s interface is on multiple ports, "
3321                          "removing from %s",
3322                          port->bridge->name, if_cfg->name, iface->port->name);
3323                 continue;
3324             }
3325             iface->cfg = if_cfg;
3326         } else {
3327             iface_create(port, if_cfg);
3328         }
3329     }
3330     shash_destroy(&new_ifaces);
3331
3332     /* Get VLAN tag. */
3333     vlan = -1;
3334     if (cfg->tag) {
3335         if (port->n_ifaces < 2) {
3336             vlan = *cfg->tag;
3337             if (vlan >= 0 && vlan <= 4095) {
3338                 VLOG_DBG("port %s: assigning VLAN tag %d", port->name, vlan);
3339             } else {
3340                 vlan = -1;
3341             }
3342         } else {
3343             /* It's possible that bonded, VLAN-tagged ports make sense.  Maybe
3344              * they even work as-is.  But they have not been tested. */
3345             VLOG_WARN("port %s: VLAN tags not supported on bonded ports",
3346                       port->name);
3347         }
3348     }
3349     if (port->vlan != vlan) {
3350         port->vlan = vlan;
3351         bridge_flush(port->bridge);
3352     }
3353
3354     /* Get trunked VLANs. */
3355     trunks = NULL;
3356     if (vlan < 0 && cfg->n_trunks) {
3357         size_t n_errors;
3358         size_t i;
3359
3360         trunks = bitmap_allocate(4096);
3361         n_errors = 0;
3362         for (i = 0; i < cfg->n_trunks; i++) {
3363             int trunk = cfg->trunks[i];
3364             if (trunk >= 0) {
3365                 bitmap_set1(trunks, trunk);
3366             } else {
3367                 n_errors++;
3368             }
3369         }
3370         if (n_errors) {
3371             VLOG_ERR("port %s: invalid values for %zu trunk VLANs",
3372                      port->name, cfg->n_trunks);
3373         }
3374         if (n_errors == cfg->n_trunks) {
3375             VLOG_ERR("port %s: no valid trunks, trunking all VLANs",
3376                      port->name);
3377             bitmap_free(trunks);
3378             trunks = NULL;
3379         }
3380     } else if (vlan >= 0 && cfg->n_trunks) {
3381         VLOG_ERR("port %s: ignoring trunks in favor of implicit vlan",
3382                  port->name);
3383     }
3384     if (trunks == NULL
3385         ? port->trunks != NULL
3386         : port->trunks == NULL || !bitmap_equal(trunks, port->trunks, 4096)) {
3387         bridge_flush(port->bridge);
3388     }
3389     bitmap_free(port->trunks);
3390     port->trunks = trunks;
3391 }
3392
3393 static void
3394 port_destroy(struct port *port)
3395 {
3396     if (port) {
3397         struct bridge *br = port->bridge;
3398         struct port *del;
3399         int i;
3400
3401         proc_net_compat_update_vlan(port->name, NULL, 0);
3402         proc_net_compat_update_bond(port->name, NULL);
3403
3404         for (i = 0; i < MAX_MIRRORS; i++) {
3405             struct mirror *m = br->mirrors[i];
3406             if (m && m->out_port == port) {
3407                 mirror_destroy(m);
3408             }
3409         }
3410
3411         while (port->n_ifaces > 0) {
3412             iface_destroy(port->ifaces[port->n_ifaces - 1]);
3413         }
3414
3415         shash_find_and_delete_assert(&br->port_by_name, port->name);
3416
3417         del = br->ports[port->port_idx] = br->ports[--br->n_ports];
3418         del->port_idx = port->port_idx;
3419
3420         free(port->ifaces);
3421         bitmap_free(port->trunks);
3422         free(port->name);
3423         free(port);
3424         bridge_flush(br);
3425     }
3426 }
3427
3428 static struct port *
3429 port_from_xf_ifidx(const struct bridge *br, uint16_t xf_ifidx)
3430 {
3431     struct iface *iface = iface_from_xf_ifidx(br, xf_ifidx);
3432     return iface ? iface->port : NULL;
3433 }
3434
3435 static struct port *
3436 port_lookup(const struct bridge *br, const char *name)
3437 {
3438     return shash_find_data(&br->port_by_name, name);
3439 }
3440
3441 static struct iface *
3442 port_lookup_iface(const struct port *port, const char *name)
3443 {
3444     struct iface *iface = iface_lookup(port->bridge, name);
3445     return iface && iface->port == port ? iface : NULL;
3446 }
3447
3448 static void
3449 port_update_bonding(struct port *port)
3450 {
3451     if (port->n_ifaces < 2) {
3452         /* Not a bonded port. */
3453         if (port->bond_hash) {
3454             free(port->bond_hash);
3455             port->bond_hash = NULL;
3456             port->bond_compat_is_stale = true;
3457             port->bond_fake_iface = false;
3458         }
3459     } else {
3460         if (!port->bond_hash) {
3461             size_t i;
3462
3463             port->bond_hash = xcalloc(BOND_MASK + 1, sizeof *port->bond_hash);
3464             for (i = 0; i <= BOND_MASK; i++) {
3465                 struct bond_entry *e = &port->bond_hash[i];
3466                 e->iface_idx = -1;
3467                 e->tx_bytes = 0;
3468             }
3469             port->no_ifaces_tag = tag_create_random();
3470             bond_choose_active_iface(port);
3471             port->bond_next_rebalance
3472                 = time_msec() + port->bond_rebalance_interval;
3473
3474             if (port->cfg->bond_fake_iface) {
3475                 port->bond_next_fake_iface_update = time_msec();
3476             }
3477         }
3478         port->bond_compat_is_stale = true;
3479         port->bond_fake_iface = port->cfg->bond_fake_iface;
3480     }
3481 }
3482
3483 static void
3484 port_update_bond_compat(struct port *port)
3485 {
3486     struct compat_bond_hash compat_hashes[BOND_MASK + 1];
3487     struct compat_bond bond;
3488     size_t i;
3489
3490     if (port->n_ifaces < 2) {
3491         proc_net_compat_update_bond(port->name, NULL);
3492         return;
3493     }
3494
3495     bond.up = false;
3496     bond.updelay = port->updelay;
3497     bond.downdelay = port->downdelay;
3498
3499     bond.n_hashes = 0;
3500     bond.hashes = compat_hashes;
3501     if (port->bond_hash) {
3502         const struct bond_entry *e;
3503         for (e = port->bond_hash; e <= &port->bond_hash[BOND_MASK]; e++) {
3504             if (e->iface_idx >= 0 && e->iface_idx < port->n_ifaces) {
3505                 struct compat_bond_hash *cbh = &bond.hashes[bond.n_hashes++];
3506                 cbh->hash = e - port->bond_hash;
3507                 cbh->netdev_name = port->ifaces[e->iface_idx]->name;
3508             }
3509         }
3510     }
3511
3512     bond.n_slaves = port->n_ifaces;
3513     bond.slaves = xmalloc(port->n_ifaces * sizeof *bond.slaves);
3514     for (i = 0; i < port->n_ifaces; i++) {
3515         struct iface *iface = port->ifaces[i];
3516         struct compat_bond_slave *slave = &bond.slaves[i];
3517         slave->name = iface->name;
3518
3519         /* We need to make the same determination as the Linux bonding
3520          * code to determine whether a slave should be consider "up".
3521          * The Linux function bond_miimon_inspect() supports four
3522          * BOND_LINK_* states:
3523          *
3524          *    - BOND_LINK_UP: carrier detected, updelay has passed.
3525          *    - BOND_LINK_FAIL: carrier lost, downdelay in progress.
3526          *    - BOND_LINK_DOWN: carrier lost, downdelay has passed.
3527          *    - BOND_LINK_BACK: carrier detected, updelay in progress.
3528          *
3529          * The function bond_info_show_slave() only considers BOND_LINK_UP
3530          * to be "up" and anything else to be "down".
3531          */
3532         slave->up = iface->enabled && iface->delay_expires == LLONG_MAX;
3533         if (slave->up) {
3534             bond.up = true;
3535         }
3536         netdev_get_etheraddr(iface->netdev, slave->mac);
3537     }
3538
3539     if (port->bond_fake_iface) {
3540         struct netdev *bond_netdev;
3541
3542         if (!netdev_open_default(port->name, &bond_netdev)) {
3543             if (bond.up) {
3544                 netdev_turn_flags_on(bond_netdev, NETDEV_UP, true);
3545             } else {
3546                 netdev_turn_flags_off(bond_netdev, NETDEV_UP, true);
3547             }
3548             netdev_close(bond_netdev);
3549         }
3550     }
3551
3552     proc_net_compat_update_bond(port->name, &bond);
3553     free(bond.slaves);
3554 }
3555
3556 static void
3557 port_update_vlan_compat(struct port *port)
3558 {
3559     struct bridge *br = port->bridge;
3560     char *vlandev_name = NULL;
3561
3562     if (port->vlan > 0) {
3563         /* Figure out the name that the VLAN device should actually have, if it
3564          * existed.  This takes some work because the VLAN device would not
3565          * have port->name in its name; rather, it would have the trunk port's
3566          * name, and 'port' would be attached to a bridge that also had the
3567          * VLAN device one of its ports.  So we need to find a trunk port that
3568          * includes port->vlan.
3569          *
3570          * There might be more than one candidate.  This doesn't happen on
3571          * XenServer, so if it happens we just pick the first choice in
3572          * alphabetical order instead of creating multiple VLAN devices. */
3573         size_t i;
3574         for (i = 0; i < br->n_ports; i++) {
3575             struct port *p = br->ports[i];
3576             if (port_trunks_vlan(p, port->vlan)
3577                 && p->n_ifaces
3578                 && (!vlandev_name || strcmp(p->name, vlandev_name) <= 0))
3579             {
3580                 uint8_t ea[ETH_ADDR_LEN];
3581                 netdev_get_etheraddr(p->ifaces[0]->netdev, ea);
3582                 if (!eth_addr_is_multicast(ea) &&
3583                     !eth_addr_is_reserved(ea) &&
3584                     !eth_addr_is_zero(ea)) {
3585                     vlandev_name = p->name;
3586                 }
3587             }
3588         }
3589     }
3590     proc_net_compat_update_vlan(port->name, vlandev_name, port->vlan);
3591 }
3592 \f
3593 /* Interface functions. */
3594
3595 static struct iface *
3596 iface_create(struct port *port, const struct ovsrec_interface *if_cfg)
3597 {
3598     struct bridge *br = port->bridge;
3599     struct iface *iface;
3600     char *name = if_cfg->name;
3601     int error;
3602
3603     iface = xzalloc(sizeof *iface);
3604     iface->port = port;
3605     iface->port_ifidx = port->n_ifaces;
3606     iface->name = xstrdup(name);
3607     iface->xf_ifidx = -1;
3608     iface->tag = tag_create_random();
3609     iface->delay_expires = LLONG_MAX;
3610     iface->netdev = NULL;
3611     iface->cfg = if_cfg;
3612
3613     shash_add_assert(&br->iface_by_name, iface->name, iface);
3614
3615     /* Attempt to create the network interface in case it doesn't exist yet. */
3616     if (!iface_is_internal(br, iface->name)) {
3617         error = set_up_iface(if_cfg, iface, true);
3618         if (error) {
3619             VLOG_WARN("could not create iface %s: %s", iface->name,
3620                       strerror(error));
3621
3622             shash_find_and_delete_assert(&br->iface_by_name, iface->name);
3623             free(iface->name);
3624             free(iface);
3625             return NULL;
3626         }
3627     }
3628
3629     if (port->n_ifaces >= port->allocated_ifaces) {
3630         port->ifaces = x2nrealloc(port->ifaces, &port->allocated_ifaces,
3631                                   sizeof *port->ifaces);
3632     }
3633     port->ifaces[port->n_ifaces++] = iface;
3634     if (port->n_ifaces > 1) {
3635         br->has_bonded_ports = true;
3636     }
3637
3638     VLOG_DBG("attached network device %s to port %s", iface->name, port->name);
3639
3640     bridge_flush(br);
3641
3642     return iface;
3643 }
3644
3645 static void
3646 iface_destroy(struct iface *iface)
3647 {
3648     if (iface) {
3649         struct port *port = iface->port;
3650         struct bridge *br = port->bridge;
3651         bool del_active = port->active_iface == iface->port_ifidx;
3652         struct iface *del;
3653
3654         shash_find_and_delete_assert(&br->iface_by_name, iface->name);
3655
3656         if (iface->xf_ifidx >= 0) {
3657             port_array_set(&br->ifaces, iface->xf_ifidx, NULL);
3658         }
3659
3660         del = port->ifaces[iface->port_ifidx] = port->ifaces[--port->n_ifaces];
3661         del->port_ifidx = iface->port_ifidx;
3662
3663         netdev_close(iface->netdev);
3664
3665         if (del_active) {
3666             ofproto_revalidate(port->bridge->ofproto, port->active_iface_tag);
3667             bond_choose_active_iface(port);
3668             bond_send_learning_packets(port);
3669         }
3670
3671         free(iface->name);
3672         free(iface);
3673
3674         bridge_flush(port->bridge);
3675     }
3676 }
3677
3678 static struct iface *
3679 iface_lookup(const struct bridge *br, const char *name)
3680 {
3681     return shash_find_data(&br->iface_by_name, name);
3682 }
3683
3684 static struct iface *
3685 iface_from_xf_ifidx(const struct bridge *br, uint16_t xf_ifidx)
3686 {
3687     return port_array_get(&br->ifaces, xf_ifidx);
3688 }
3689
3690 /* Returns true if 'iface' is the name of an "internal" interface on bridge
3691  * 'br', that is, an interface that is entirely simulated within the datapath.
3692  * The local port (XFLOWP_LOCAL) is always an internal interface.  Other local
3693  * interfaces are created by setting "iface.<iface>.internal = true".
3694  *
3695  * In addition, we have a kluge-y feature that creates an internal port with
3696  * the name of a bonded port if "bonding.<bondname>.fake-iface = true" is set.
3697  * This feature needs to go away in the long term.  Until then, this is one
3698  * reason why this function takes a name instead of a struct iface: the fake
3699  * interfaces created this way do not have a struct iface. */
3700 static bool
3701 iface_is_internal(const struct bridge *br, const char *if_name)
3702 {
3703     struct iface *iface;
3704     struct port *port;
3705
3706     if (!strcmp(if_name, br->name)) {
3707         return true;
3708     }
3709
3710     iface = iface_lookup(br, if_name);
3711     if (iface && !strcmp(iface->cfg->type, "internal")) {
3712         return true;
3713     }
3714
3715     port = port_lookup(br, if_name);
3716     if (port && port->n_ifaces > 1 && port->cfg->bond_fake_iface) {
3717         return true;
3718     }
3719     return false;
3720 }
3721
3722 /* Set Ethernet address of 'iface', if one is specified in the configuration
3723  * file. */
3724 static void
3725 iface_set_mac(struct iface *iface)
3726 {
3727     uint8_t ea[ETH_ADDR_LEN];
3728
3729     if (iface->cfg->mac && eth_addr_from_string(iface->cfg->mac, ea)) {
3730         if (eth_addr_is_multicast(ea)) {
3731             VLOG_ERR("interface %s: cannot set MAC to multicast address",
3732                      iface->name);
3733         } else if (iface->xf_ifidx == XFLOWP_LOCAL) {
3734             VLOG_ERR("ignoring iface.%s.mac; use bridge.%s.mac instead",
3735                      iface->name, iface->name);
3736         } else {
3737             int error = netdev_set_etheraddr(iface->netdev, ea);
3738             if (error) {
3739                 VLOG_ERR("interface %s: setting MAC failed (%s)",
3740                          iface->name, strerror(error));
3741             }
3742         }
3743     }
3744 }
3745
3746 static void
3747 shash_from_ovs_idl_map(char **keys, char **values, size_t n,
3748                        struct shash *shash)
3749 {
3750     size_t i;
3751
3752     shash_init(shash);
3753     for (i = 0; i < n; i++) {
3754         shash_add(shash, keys[i], values[i]);
3755     }
3756 }
3757
3758 struct iface_delete_queues_cbdata {
3759     struct netdev *netdev;
3760     const int64_t *queue_ids;
3761     size_t n_queue_ids;
3762 };
3763
3764 static bool
3765 queue_ids_include(const int64_t *ids, size_t n, int64_t target)
3766 {
3767     size_t low = 0;
3768     size_t high = n;
3769
3770     while (low < high) {
3771         size_t mid = low + (high - low) / 2;
3772         if (target > ids[mid]) {
3773             high = mid;
3774         } else if (target < ids[mid]) {
3775             low = mid + 1;
3776         } else {
3777             return true;
3778         }
3779     }
3780     return false;
3781 }
3782
3783 static void
3784 iface_delete_queues(unsigned int queue_id,
3785                     const struct shash *details OVS_UNUSED, void *cbdata_)
3786 {
3787     struct iface_delete_queues_cbdata *cbdata = cbdata_;
3788
3789     if (!queue_ids_include(cbdata->queue_ids, cbdata->n_queue_ids, queue_id)) {
3790         netdev_delete_queue(cbdata->netdev, queue_id);
3791     }
3792 }
3793
3794 static void
3795 iface_update_qos(struct iface *iface, const struct ovsrec_qos *qos)
3796 {
3797     if (!qos || qos->type[0] == '\0') {
3798         netdev_set_qos(iface->netdev, NULL, NULL);
3799     } else {
3800         struct iface_delete_queues_cbdata cbdata;
3801         struct shash details;
3802         size_t i;
3803
3804         /* Configure top-level Qos for 'iface'. */
3805         shash_from_ovs_idl_map(qos->key_other_config, qos->value_other_config,
3806                                qos->n_other_config, &details);
3807         netdev_set_qos(iface->netdev, qos->type, &details);
3808         shash_destroy(&details);
3809
3810         /* Deconfigure queues that were deleted. */
3811         cbdata.netdev = iface->netdev;
3812         cbdata.queue_ids = qos->key_queues;
3813         cbdata.n_queue_ids = qos->n_queues;
3814         netdev_dump_queues(iface->netdev, iface_delete_queues, &cbdata);
3815
3816         /* Configure queues for 'iface'. */
3817         for (i = 0; i < qos->n_queues; i++) {
3818             const struct ovsrec_queue *queue = qos->value_queues[i];
3819             unsigned int queue_id = qos->key_queues[i];
3820
3821             shash_from_ovs_idl_map(queue->key_other_config,
3822                                    queue->value_other_config,
3823                                    queue->n_other_config, &details);
3824             netdev_set_queue(iface->netdev, queue_id, &details);
3825             shash_destroy(&details);
3826         }
3827     }
3828 }
3829 \f
3830 /* Port mirroring. */
3831
3832 static void
3833 mirror_reconfigure(struct bridge *br)
3834 {
3835     struct shash old_mirrors, new_mirrors;
3836     struct shash_node *node;
3837     unsigned long *rspan_vlans;
3838     int i;
3839
3840     /* Collect old mirrors. */
3841     shash_init(&old_mirrors);
3842     for (i = 0; i < MAX_MIRRORS; i++) {
3843         if (br->mirrors[i]) {
3844             shash_add(&old_mirrors, br->mirrors[i]->name, br->mirrors[i]);
3845         }
3846     }
3847
3848     /* Collect new mirrors. */
3849     shash_init(&new_mirrors);
3850     for (i = 0; i < br->cfg->n_mirrors; i++) {
3851         struct ovsrec_mirror *cfg = br->cfg->mirrors[i];
3852         if (!shash_add_once(&new_mirrors, cfg->name, cfg)) {
3853             VLOG_WARN("bridge %s: %s specified twice as mirror",
3854                       br->name, cfg->name);
3855         }
3856     }
3857
3858     /* Get rid of deleted mirrors and add new mirrors. */
3859     SHASH_FOR_EACH (node, &old_mirrors) {
3860         if (!shash_find(&new_mirrors, node->name)) {
3861             mirror_destroy(node->data);
3862         }
3863     }
3864     SHASH_FOR_EACH (node, &new_mirrors) {
3865         struct mirror *mirror = shash_find_data(&old_mirrors, node->name);
3866         if (!mirror) {
3867             mirror = mirror_create(br, node->name);
3868             if (!mirror) {
3869                 break;
3870             }
3871         }
3872         mirror_reconfigure_one(mirror, node->data);
3873     }
3874     shash_destroy(&old_mirrors);
3875     shash_destroy(&new_mirrors);
3876
3877     /* Update port reserved status. */
3878     for (i = 0; i < br->n_ports; i++) {
3879         br->ports[i]->is_mirror_output_port = false;
3880     }
3881     for (i = 0; i < MAX_MIRRORS; i++) {
3882         struct mirror *m = br->mirrors[i];
3883         if (m && m->out_port) {
3884             m->out_port->is_mirror_output_port = true;
3885         }
3886     }
3887
3888     /* Update flooded vlans (for RSPAN). */
3889     rspan_vlans = NULL;
3890     if (br->cfg->n_flood_vlans) {
3891         rspan_vlans = bitmap_allocate(4096);
3892
3893         for (i = 0; i < br->cfg->n_flood_vlans; i++) {
3894             int64_t vlan = br->cfg->flood_vlans[i];
3895             if (vlan >= 0 && vlan < 4096) {
3896                 bitmap_set1(rspan_vlans, vlan);
3897                 VLOG_INFO("bridge %s: disabling learning on vlan %"PRId64,
3898                           br->name, vlan);
3899             } else {
3900                 VLOG_ERR("bridge %s: invalid value %"PRId64 "for flood VLAN",
3901                          br->name, vlan);
3902             }
3903         }
3904     }
3905     if (mac_learning_set_flood_vlans(br->ml, rspan_vlans)) {
3906         bridge_flush(br);
3907     }
3908 }
3909
3910 static struct mirror *
3911 mirror_create(struct bridge *br, const char *name)
3912 {
3913     struct mirror *m;
3914     size_t i;
3915
3916     for (i = 0; ; i++) {
3917         if (i >= MAX_MIRRORS) {
3918             VLOG_WARN("bridge %s: maximum of %d port mirrors reached, "
3919                       "cannot create %s", br->name, MAX_MIRRORS, name);
3920             return NULL;
3921         }
3922         if (!br->mirrors[i]) {
3923             break;
3924         }
3925     }
3926
3927     VLOG_INFO("created port mirror %s on bridge %s", name, br->name);
3928     bridge_flush(br);
3929
3930     br->mirrors[i] = m = xzalloc(sizeof *m);
3931     m->bridge = br;
3932     m->idx = i;
3933     m->name = xstrdup(name);
3934     shash_init(&m->src_ports);
3935     shash_init(&m->dst_ports);
3936     m->vlans = NULL;
3937     m->n_vlans = 0;
3938     m->out_vlan = -1;
3939     m->out_port = NULL;
3940
3941     return m;
3942 }
3943
3944 static void
3945 mirror_destroy(struct mirror *m)
3946 {
3947     if (m) {
3948         struct bridge *br = m->bridge;
3949         size_t i;
3950
3951         for (i = 0; i < br->n_ports; i++) {
3952             br->ports[i]->src_mirrors &= ~(MIRROR_MASK_C(1) << m->idx);
3953             br->ports[i]->dst_mirrors &= ~(MIRROR_MASK_C(1) << m->idx);
3954         }
3955
3956         shash_destroy(&m->src_ports);
3957         shash_destroy(&m->dst_ports);
3958         free(m->vlans);
3959
3960         m->bridge->mirrors[m->idx] = NULL;
3961         free(m);
3962
3963         bridge_flush(br);
3964     }
3965 }
3966
3967 static void
3968 mirror_collect_ports(struct mirror *m, struct ovsrec_port **ports, int n_ports,
3969                      struct shash *names)
3970 {
3971     size_t i;
3972
3973     for (i = 0; i < n_ports; i++) {
3974         const char *name = ports[i]->name;
3975         if (port_lookup(m->bridge, name)) {
3976             shash_add_once(names, name, NULL);
3977         } else {
3978             VLOG_WARN("bridge %s: mirror %s cannot match on nonexistent "
3979                       "port %s", m->bridge->name, m->name, name);
3980         }
3981     }
3982 }
3983
3984 static size_t
3985 mirror_collect_vlans(struct mirror *m, const struct ovsrec_mirror *cfg,
3986                      int **vlans)
3987 {
3988     size_t n_vlans;
3989     size_t i;
3990
3991     *vlans = xmalloc(sizeof **vlans * cfg->n_select_vlan);
3992     n_vlans = 0;
3993     for (i = 0; i < cfg->n_select_vlan; i++) {
3994         int64_t vlan = cfg->select_vlan[i];
3995         if (vlan < 0 || vlan > 4095) {
3996             VLOG_WARN("bridge %s: mirror %s selects invalid VLAN %"PRId64,
3997                       m->bridge->name, m->name, vlan);
3998         } else {
3999             (*vlans)[n_vlans++] = vlan;
4000         }
4001     }
4002     return n_vlans;
4003 }
4004
4005 static bool
4006 vlan_is_mirrored(const struct mirror *m, int vlan)
4007 {
4008     size_t i;
4009
4010     for (i = 0; i < m->n_vlans; i++) {
4011         if (m->vlans[i] == vlan) {
4012             return true;
4013         }
4014     }
4015     return false;
4016 }
4017
4018 static bool
4019 port_trunks_any_mirrored_vlan(const struct mirror *m, const struct port *p)
4020 {
4021     size_t i;
4022
4023     for (i = 0; i < m->n_vlans; i++) {
4024         if (port_trunks_vlan(p, m->vlans[i])) {
4025             return true;
4026         }
4027     }
4028     return false;
4029 }
4030
4031 static void
4032 mirror_reconfigure_one(struct mirror *m, struct ovsrec_mirror *cfg)
4033 {
4034     struct shash src_ports, dst_ports;
4035     mirror_mask_t mirror_bit;
4036     struct port *out_port;
4037     int out_vlan;
4038     size_t n_vlans;
4039     int *vlans;
4040     size_t i;
4041
4042     /* Get output port. */
4043     if (cfg->output_port) {
4044         out_port = port_lookup(m->bridge, cfg->output_port->name);
4045         if (!out_port) {
4046             VLOG_ERR("bridge %s: mirror %s outputs to port not on bridge",
4047                      m->bridge->name, m->name);
4048             mirror_destroy(m);
4049             return;
4050         }
4051         out_vlan = -1;
4052
4053         if (cfg->output_vlan) {
4054             VLOG_ERR("bridge %s: mirror %s specifies both output port and "
4055                      "output vlan; ignoring output vlan",
4056                      m->bridge->name, m->name);
4057         }
4058     } else if (cfg->output_vlan) {
4059         out_port = NULL;
4060         out_vlan = *cfg->output_vlan;
4061     } else {
4062         VLOG_ERR("bridge %s: mirror %s does not specify output; ignoring",
4063                  m->bridge->name, m->name);
4064         mirror_destroy(m);
4065         return;
4066     }
4067
4068     shash_init(&src_ports);
4069     shash_init(&dst_ports);
4070     if (cfg->select_all) {
4071         for (i = 0; i < m->bridge->n_ports; i++) {
4072             const char *name = m->bridge->ports[i]->name;
4073             shash_add_once(&src_ports, name, NULL);
4074             shash_add_once(&dst_ports, name, NULL);
4075         }
4076         vlans = NULL;
4077         n_vlans = 0;
4078     } else {
4079         /* Get ports, and drop duplicates and ports that don't exist. */
4080         mirror_collect_ports(m, cfg->select_src_port, cfg->n_select_src_port,
4081                              &src_ports);
4082         mirror_collect_ports(m, cfg->select_dst_port, cfg->n_select_dst_port,
4083                              &dst_ports);
4084
4085         /* Get all the vlans, and drop duplicate and invalid vlans. */
4086         n_vlans = mirror_collect_vlans(m, cfg, &vlans);
4087     }
4088
4089     /* Update mirror data. */
4090     if (!shash_equal_keys(&m->src_ports, &src_ports)
4091         || !shash_equal_keys(&m->dst_ports, &dst_ports)
4092         || m->n_vlans != n_vlans
4093         || memcmp(m->vlans, vlans, sizeof *vlans * n_vlans)
4094         || m->out_port != out_port
4095         || m->out_vlan != out_vlan) {
4096         bridge_flush(m->bridge);
4097     }
4098     shash_swap(&m->src_ports, &src_ports);
4099     shash_swap(&m->dst_ports, &dst_ports);
4100     free(m->vlans);
4101     m->vlans = vlans;
4102     m->n_vlans = n_vlans;
4103     m->out_port = out_port;
4104     m->out_vlan = out_vlan;
4105
4106     /* Update ports. */
4107     mirror_bit = MIRROR_MASK_C(1) << m->idx;
4108     for (i = 0; i < m->bridge->n_ports; i++) {
4109         struct port *port = m->bridge->ports[i];
4110
4111         if (shash_find(&m->src_ports, port->name)
4112             || (m->n_vlans
4113                 && (!port->vlan
4114                     ? port_trunks_any_mirrored_vlan(m, port)
4115                     : vlan_is_mirrored(m, port->vlan)))) {
4116             port->src_mirrors |= mirror_bit;
4117         } else {
4118             port->src_mirrors &= ~mirror_bit;
4119         }
4120
4121         if (shash_find(&m->dst_ports, port->name)) {
4122             port->dst_mirrors |= mirror_bit;
4123         } else {
4124             port->dst_mirrors &= ~mirror_bit;
4125         }
4126     }
4127
4128     /* Clean up. */
4129     shash_destroy(&src_ports);
4130     shash_destroy(&dst_ports);
4131 }