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