vswitchd/bridge.c

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