vswitchd/bridge.c

   1 /* Copyright (c) 2008, 2009 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 <net/if.h>
  24 #include <openflow/openflow.h>
  25 #include <signal.h>
  26 #include <stdlib.h>
  27 #include <strings.h>
  28 #include <sys/stat.h>
  29 #include <sys/socket.h>
  30 #include <sys/types.h>
  31 #include <unistd.h>
  32 #include "bitmap.h"
  33 #include "cfg.h"
  34 #include "coverage.h"
  35 #include "dirs.h"
  36 #include "dpif.h"
  37 #include "dynamic-string.h"
  38 #include "flow.h"
  39 #include "hash.h"
  40 #include "list.h"
  41 #include "mac-learning.h"
  42 #include "netdev.h"
  43 #include "odp-util.h"
  44 #include "ofp-print.h"
  45 #include "ofpbuf.h"
  46 #include "packets.h"
  47 #include "poll-loop.h"
  48 #include "port-array.h"
  49 #include "proc-net-compat.h"
  50 #include "process.h"
  51 #include "secchan/ofproto.h"
  52 #include "socket-util.h"
  53 #include "stp.h"
  54 #include "svec.h"
  55 #include "timeval.h"
  56 #include "util.h"
  57 #include "unixctl.h"
  58 #include "vconn.h"
  59 #include "vconn-ssl.h"
  60 #include "xenserver.h"
  61 #include "xtoxll.h"
  62
  63 #define THIS_MODULE VLM_bridge
  64 #include "vlog.h"
  65
  66 struct dst {
  67     uint16_t vlan;
  68     uint16_t dp_ifidx;
  69 };
  70
  71 extern uint64_t mgmt_id;
  72
  73 struct iface {
  74     struct port *port;          /* Containing port. */
  75     size_t port_ifidx;          /* Index within containing port. */
  76
  77     char *name;                 /* Host network device name. */
  78     int dp_ifidx;               /* Index within kernel datapath. */
  79
  80     uint8_t mac[ETH_ADDR_LEN];  /* Ethernet address (all zeros if unknowns). */
  81
  82     tag_type tag;               /* Tag associated with this interface. */
  83     bool enabled;               /* May be chosen for flows? */
  84     long long delay_expires;    /* Time after which 'enabled' may change. */
  85 };
  86
  87 #define BOND_MASK 0xff
  88 struct bond_entry {
  89     int iface_idx;              /* Index of assigned iface, or -1 if none. */
  90     uint64_t tx_bytes;          /* Count of bytes recently transmitted. */
  91     tag_type iface_tag;         /* Tag associated with iface_idx. */
  92 };
  93
  94 #define MAX_MIRRORS 32
  95 typedef uint32_t mirror_mask_t;
  96 #define MIRROR_MASK_C(X) UINT32_C(X)
  97 BUILD_ASSERT_DECL(sizeof(mirror_mask_t) * CHAR_BIT >= MAX_MIRRORS);
  98 struct mirror {
  99     struct bridge *bridge;
 100     size_t idx;
 101     char *name;
 102
 103     /* Selection criteria. */
 104     struct svec src_ports;
 105     struct svec dst_ports;
 106     int *vlans;
 107     size_t n_vlans;
 108
 109     /* Output. */
 110     struct port *out_port;
 111     int out_vlan;
 112 };
 113
 114 #define FLOOD_PORT ((struct port *) 1) /* The 'flood' output port. */
 115 struct port {
 116     struct bridge *bridge;
 117     size_t port_idx;
 118     int vlan;                   /* -1=trunk port, else a 12-bit VLAN ID. */
 119     unsigned long *trunks;      /* Bitmap of trunked VLANs, if 'vlan' == -1. */
 120     char *name;
 121
 122     /* An ordinary bridge port has 1 interface.
 123      * A bridge port for bonding has at least 2 interfaces. */
 124     struct iface **ifaces;
 125     size_t n_ifaces, allocated_ifaces;
 126
 127     /* Bonding info. */
 128     struct bond_entry *bond_hash; /* An array of (BOND_MASK + 1) elements. */
 129     int active_iface;           /* Ifidx on which bcasts accepted, or -1. */
 130     tag_type active_iface_tag;  /* Tag for bcast flows. */
 131     tag_type no_ifaces_tag;     /* Tag for flows when all ifaces disabled. */
 132     int updelay, downdelay;     /* Delay before iface goes up/down, in ms. */
 133
 134     /* Port mirroring info. */
 135     mirror_mask_t src_mirrors;  /* Mirrors triggered when packet received. */
 136     mirror_mask_t dst_mirrors;  /* Mirrors triggered when packet sent. */
 137     bool is_mirror_output_port; /* Does port mirroring send frames here? */
 138
 139     /* Spanning tree info. */
 140     enum stp_state stp_state;   /* Always STP_FORWARDING if STP not in use. */
 141     tag_type stp_state_tag;     /* Tag for STP state change. */
 142 };
 143
 144 #define DP_MAX_PORTS 255
 145 struct bridge {
 146     struct list node;           /* Node in global list of bridges. */
 147     char *name;                 /* User-specified arbitrary name. */
 148     struct mac_learning *ml;    /* MAC learning table, or null not to learn. */
 149     bool sent_config_request;   /* Successfully sent config request? */
 150     uint8_t default_ea[ETH_ADDR_LEN]; /* Default MAC. */
 151
 152     /* Support for remote controllers. */
 153     char *controller;           /* NULL if there is no remote controller;
 154                                  * "discover" to do controller discovery;
 155                                  * otherwise a vconn name. */
 156
 157     /* OpenFlow switch processing. */
 158     struct ofproto *ofproto;    /* OpenFlow switch. */
 159
 160     /* Kernel datapath information. */
 161     struct dpif dpif;           /* Kernel datapath. */
 162     struct port_array ifaces;   /* Indexed by kernel datapath port number. */
 163
 164     /* Bridge ports. */
 165     struct port **ports;
 166     size_t n_ports, allocated_ports;
 167
 168     /* Bonding. */
 169     bool has_bonded_ports;
 170     long long int bond_next_rebalance;
 171
 172     /* Flow tracking. */
 173     bool flush;
 174
 175     /* Flow statistics gathering. */
 176     time_t next_stats_request;
 177
 178     /* Port mirroring. */
 179     struct mirror *mirrors[MAX_MIRRORS];
 180
 181     /* Spanning tree. */
 182     struct stp *stp;
 183     long long int stp_last_tick;
 184 };
 185
 186 /* List of all bridges. */
 187 static struct list all_bridges = LIST_INITIALIZER(&all_bridges);
 188
 189 /* Maximum number of datapaths. */
 190 enum { DP_MAX = 256 };
 191
 192 static struct bridge *bridge_create(const char *name);
 193 static void bridge_destroy(struct bridge *);
 194 static struct bridge *bridge_lookup(const char *name);
 195 static void bridge_unixctl_dump_flows(struct unixctl_conn *, const char *);
 196 static int bridge_run_one(struct bridge *);
 197 static void bridge_reconfigure_one(struct bridge *);
 198 static void bridge_reconfigure_controller(struct bridge *);
 199 static void bridge_get_all_ifaces(const struct bridge *, struct svec *ifaces);
 200 static void bridge_fetch_dp_ifaces(struct bridge *);
 201 static void bridge_flush(struct bridge *);
 202 static void bridge_pick_local_hw_addr(struct bridge *,
 203                                       uint8_t ea[ETH_ADDR_LEN],
 204                                       const char **devname);
 205 static uint64_t bridge_pick_datapath_id(struct bridge *,
 206                                         const uint8_t bridge_ea[ETH_ADDR_LEN],
 207                                         const char *devname);
 208 static uint64_t dpid_from_hash(const void *, size_t nbytes);
 209
 210 static void bridge_unixctl_fdb_show(struct unixctl_conn *, const char *args);
 211
 212 static void bond_init(void);
 213 static void bond_run(struct bridge *);
 214 static void bond_wait(struct bridge *);
 215 static void bond_rebalance_port(struct port *);
 216 static void bond_send_learning_packets(struct port *);
 217
 218 static void port_create(struct bridge *, const char *name);
 219 static void port_reconfigure(struct port *);
 220 static void port_destroy(struct port *);
 221 static struct port *port_lookup(const struct bridge *, const char *name);
 222 static struct iface *port_lookup_iface(const struct port *, const char *name);
 223 static struct port *port_from_dp_ifidx(const struct bridge *,
 224                                        uint16_t dp_ifidx);
 225 static void port_update_bond_compat(struct port *);
 226 static void port_update_vlan_compat(struct port *);
 227
 228 static void mirror_create(struct bridge *, const char *name);
 229 static void mirror_destroy(struct mirror *);
 230 static void mirror_reconfigure(struct bridge *);
 231 static void mirror_reconfigure_one(struct mirror *);
 232 static bool vlan_is_mirrored(const struct mirror *, int vlan);
 233
 234 static void brstp_reconfigure(struct bridge *);
 235 static void brstp_adjust_timers(struct bridge *);
 236 static void brstp_run(struct bridge *);
 237 static void brstp_wait(struct bridge *);
 238
 239 static void iface_create(struct port *, const char *name);
 240 static void iface_destroy(struct iface *);
 241 static struct iface *iface_lookup(const struct bridge *, const char *name);
 242 static struct iface *iface_from_dp_ifidx(const struct bridge *,
 243                                          uint16_t dp_ifidx);
 244
 245 /* Hooks into ofproto processing. */
 246 static struct ofhooks bridge_ofhooks;
 247 \f
 248 /* Public functions. */
 249
 250 /* Adds the name of each interface used by a bridge, including local and
 251  * internal ports, to 'svec'. */
 252 void
 253 bridge_get_ifaces(struct svec *svec)
 254 {
 255     struct bridge *br, *next;
 256     size_t i, j;
 257
 258     LIST_FOR_EACH_SAFE (br, next, struct bridge, node, &all_bridges) {
 259         for (i = 0; i < br->n_ports; i++) {
 260             struct port *port = br->ports[i];
 261
 262             for (j = 0; j < port->n_ifaces; j++) {
 263                 struct iface *iface = port->ifaces[j];
 264                 if (iface->dp_ifidx < 0) {
 265                     VLOG_ERR("%s interface not in dp%u, ignoring",
 266                              iface->name, dpif_id(&br->dpif));
 267                 } else {
 268                     if (iface->dp_ifidx != ODPP_LOCAL) {
 269                         svec_add(svec, iface->name);
 270                     }
 271                 }
 272             }
 273         }
 274     }
 275 }
 276
 277 /* The caller must already have called cfg_read(). */
 278 void
 279 bridge_init(void)
 280 {
 281     int retval;
 282     int i;
 283
 284     bond_init();
 285
 286     unixctl_command_register("fdb/show", bridge_unixctl_fdb_show);
 287
 288     for (i = 0; i < DP_MAX; i++) {
 289         struct dpif dpif;
 290         char devname[16];
 291
 292         sprintf(devname, "dp%d", i);
 293         retval = dpif_open(devname, &dpif);
 294         if (!retval) {
 295             char dpif_name[IF_NAMESIZE];
 296             if (dpif_get_name(&dpif, dpif_name, sizeof dpif_name)
 297                 || !cfg_has("bridge.%s.port", dpif_name)) {
 298                 dpif_delete(&dpif);
 299             }
 300             dpif_close(&dpif);
 301         } else if (retval != ENODEV) {
 302             VLOG_ERR("failed to delete datapath dp%d: %s",
 303                      i, strerror(retval));
 304         }
 305     }
 306
 307     unixctl_command_register("bridge/dump-flows", bridge_unixctl_dump_flows);
 308
 309     bridge_reconfigure();
 310 }
 311
 312 #ifdef HAVE_OPENSSL
 313 static bool
 314 config_string_change(const char *key, char **valuep)
 315 {
 316     const char *value = cfg_get_string(0, "%s", key);
 317     if (value && (!*valuep || strcmp(value, *valuep))) {
 318         free(*valuep);
 319         *valuep = xstrdup(value);
 320         return true;
 321     } else {
 322         return false;
 323     }
 324 }
 325
 326 static void
 327 bridge_configure_ssl(void)
 328 {
 329     /* XXX SSL should be configurable on a per-bridge basis.
 330      * XXX should be possible to de-configure SSL. */
 331     static char *private_key_file;
 332     static char *certificate_file;
 333     static char *cacert_file;
 334     struct stat s;
 335
 336     if (config_string_change("ssl.private-key", &private_key_file)) {
 337         vconn_ssl_set_private_key_file(private_key_file);
 338     }
 339
 340     if (config_string_change("ssl.certificate", &certificate_file)) {
 341         vconn_ssl_set_certificate_file(certificate_file);
 342     }
 343
 344     /* We assume that even if the filename hasn't changed, if the CA cert
 345      * file has been removed, that we want to move back into
 346      * boot-strapping mode.  This opens a small security hole, because
 347      * the old certificate will still be trusted until vSwitch is
 348      * restarted.  We may want to address this in vconn's SSL library. */
 349     if (config_string_change("ssl.ca-cert", &cacert_file)
 350             || (stat(cacert_file, &s) && errno == ENOENT)) {
 351         vconn_ssl_set_ca_cert_file(cacert_file,
 352                                    cfg_get_bool(0, "ssl.bootstrap-ca-cert"));
 353     }
 354 }
 355 #endif
 356
 357 void
 358 bridge_reconfigure(void)
 359 {
 360     struct svec old_br, new_br, raw_new_br;
 361     struct bridge *br, *next;
 362     size_t i, j;
 363
 364     COVERAGE_INC(bridge_reconfigure);
 365
 366     /* Collect old bridges. */
 367     svec_init(&old_br);
 368     LIST_FOR_EACH (br, struct bridge, node, &all_bridges) {
 369         svec_add(&old_br, br->name);
 370     }
 371
 372     /* Collect new bridges. */
 373     svec_init(&raw_new_br);
 374     cfg_get_subsections(&raw_new_br, "bridge");
 375     svec_init(&new_br);
 376     for (i = 0; i < raw_new_br.n; i++) {
 377         const char *name = raw_new_br.names[i];
 378         if ((!strncmp(name, "dp", 2) && isdigit(name[2])) ||
 379             (!strncmp(name, "nl:", 3) && isdigit(name[3]))) {
 380             VLOG_ERR("%s is not a valid bridge name (bridges may not be "
 381                      "named \"dp\" or \"nl:\" followed by a digit)", name);
 382         } else {
 383             svec_add(&new_br, name);
 384         }
 385     }
 386     svec_destroy(&raw_new_br);
 387
 388     /* Get rid of deleted bridges and add new bridges. */
 389     svec_sort(&old_br);
 390     svec_sort(&new_br);
 391     assert(svec_is_unique(&old_br));
 392     assert(svec_is_unique(&new_br));
 393     LIST_FOR_EACH_SAFE (br, next, struct bridge, node, &all_bridges) {
 394         if (!svec_contains(&new_br, br->name)) {
 395             bridge_destroy(br);
 396         }
 397     }
 398     for (i = 0; i < new_br.n; i++) {
 399         const char *name = new_br.names[i];
 400         if (!svec_contains(&old_br, name)) {
 401             bridge_create(name);
 402         }
 403     }
 404     svec_destroy(&old_br);
 405     svec_destroy(&new_br);
 406
 407 #ifdef HAVE_OPENSSL
 408     /* Configure SSL. */
 409     bridge_configure_ssl();
 410 #endif
 411
 412     /* Reconfigure all bridges. */
 413     LIST_FOR_EACH (br, struct bridge, node, &all_bridges) {
 414         bridge_reconfigure_one(br);
 415     }
 416
 417     /* Add and delete ports on all datapaths.
 418      *
 419      * The kernel will reject any attempt to add a given port to a datapath if
 420      * that port already belongs to a different datapath, so we must do all
 421      * port deletions before any port additions. */
 422     LIST_FOR_EACH (br, struct bridge, node, &all_bridges) {
 423         struct odp_port *dpif_ports;
 424         size_t n_dpif_ports;
 425         struct svec want_ifaces;
 426
 427         dpif_port_list(&br->dpif, &dpif_ports, &n_dpif_ports);
 428         bridge_get_all_ifaces(br, &want_ifaces);
 429         for (i = 0; i < n_dpif_ports; i++) {
 430             const struct odp_port *p = &dpif_ports[i];
 431             if (!svec_contains(&want_ifaces, p->devname)
 432                 && strcmp(p->devname, br->name)) {
 433                 int retval = dpif_port_del(&br->dpif, p->port);
 434                 if (retval) {
 435                     VLOG_ERR("failed to remove %s interface from dp%u: %s",
 436                              p->devname, dpif_id(&br->dpif), strerror(retval));
 437                 }
 438             }
 439         }
 440         svec_destroy(&want_ifaces);
 441         free(dpif_ports);
 442     }
 443     LIST_FOR_EACH (br, struct bridge, node, &all_bridges) {
 444         struct odp_port *dpif_ports;
 445         size_t n_dpif_ports;
 446         struct svec cur_ifaces, want_ifaces, add_ifaces;
 447         int next_port_no;
 448
 449         dpif_port_list(&br->dpif, &dpif_ports, &n_dpif_ports);
 450         svec_init(&cur_ifaces);
 451         for (i = 0; i < n_dpif_ports; i++) {
 452             svec_add(&cur_ifaces, dpif_ports[i].devname);
 453         }
 454         free(dpif_ports);
 455         svec_sort_unique(&cur_ifaces);
 456         bridge_get_all_ifaces(br, &want_ifaces);
 457         svec_diff(&want_ifaces, &cur_ifaces, &add_ifaces, NULL, NULL);
 458
 459         next_port_no = 1;
 460         for (i = 0; i < add_ifaces.n; i++) {
 461             const char *if_name = add_ifaces.names[i];
 462             for (;;) {
 463                 int internal = cfg_get_bool(0, "iface.%s.internal", if_name);
 464                 int error = dpif_port_add(&br->dpif, if_name, next_port_no++,
 465                                           internal ? ODP_PORT_INTERNAL : 0);
 466                 if (error != EEXIST) {
 467                     if (next_port_no >= 256) {
 468                         VLOG_ERR("ran out of valid port numbers on dp%u",
 469                                  dpif_id(&br->dpif));
 470                         goto out;
 471                     }
 472                     if (error) {
 473                         VLOG_ERR("failed to add %s interface to dp%u: %s",
 474                                  if_name, dpif_id(&br->dpif), strerror(error));
 475                     }
 476                     break;
 477                 }
 478             }
 479         }
 480     out:
 481         svec_destroy(&cur_ifaces);
 482         svec_destroy(&want_ifaces);
 483         svec_destroy(&add_ifaces);
 484     }
 485     LIST_FOR_EACH (br, struct bridge, node, &all_bridges) {
 486         uint8_t ea[8];
 487         uint64_t dpid;
 488         struct iface *local_iface = NULL;
 489         const char *devname;
 490         uint8_t engine_type = br->dpif.minor;
 491         uint8_t engine_id = br->dpif.minor;
 492         bool add_id_to_iface = false;
 493         struct svec nf_hosts;
 494
 495         bridge_fetch_dp_ifaces(br);
 496         for (i = 0; i < br->n_ports; ) {
 497             struct port *port = br->ports[i];
 498
 499             for (j = 0; j < port->n_ifaces; ) {
 500                 struct iface *iface = port->ifaces[j];
 501                 if (iface->dp_ifidx < 0) {
 502                     VLOG_ERR("%s interface not in dp%u, dropping",
 503                              iface->name, dpif_id(&br->dpif));
 504                     iface_destroy(iface);
 505                 } else {
 506                     if (iface->dp_ifidx == ODPP_LOCAL) {
 507                         local_iface = iface;
 508                     }
 509                     VLOG_DBG("dp%u has interface %s on port %d",
 510                              dpif_id(&br->dpif), iface->name, iface->dp_ifidx);
 511                     j++;
 512                 }
 513             }
 514             if (!port->n_ifaces) {
 515                 VLOG_ERR("%s port has no interfaces, dropping", port->name);
 516                 port_destroy(port);
 517                 continue;
 518             }
 519             i++;
 520         }
 521
 522         /* Pick local port hardware address, datapath ID. */
 523         bridge_pick_local_hw_addr(br, ea, &devname);
 524         if (local_iface) {
 525             int error = netdev_nodev_set_etheraddr(local_iface->name, ea);
 526             if (error) {
 527                 static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
 528                 VLOG_ERR_RL(&rl, "bridge %s: failed to set bridge "
 529                             "Ethernet address: %s",
 530                             br->name, strerror(error));
 531             }
 532         }
 533
 534         dpid = bridge_pick_datapath_id(br, ea, devname);
 535         ofproto_set_datapath_id(br->ofproto, dpid);
 536
 537         /* Set NetFlow configuration on this bridge. */
 538         if (cfg_has("netflow.%s.engine-type", br->name)) {
 539             engine_type = cfg_get_int(0, "netflow.%s.engine-type",
 540                     br->name);
 541         }
 542         if (cfg_has("netflow.%s.engine-id", br->name)) {
 543             engine_id = cfg_get_int(0, "netflow.%s.engine-id", br->name);
 544         }
 545         if (cfg_has("netflow.%s.add-id-to-iface", br->name)) {
 546             add_id_to_iface = cfg_get_bool(0, "netflow.%s.add-id-to-iface",
 547                     br->name);
 548         }
 549         if (add_id_to_iface && engine_id > 0x7f) {
 550             VLOG_WARN("bridge %s: netflow port mangling may conflict with "
 551                     "another vswitch, choose an engine id less than 128",
 552                     br->name);
 553         }
 554         if (add_id_to_iface && br->n_ports > 0x1ff) {
 555             VLOG_WARN("bridge %s: netflow port mangling will conflict with "
 556                     "another port when 512 or more ports are used",
 557                     br->name);
 558         }
 559         svec_init(&nf_hosts);
 560         cfg_get_all_keys(&nf_hosts, "netflow.%s.host", br->name);
 561         if (ofproto_set_netflow(br->ofproto, &nf_hosts,  engine_type,
 562                     engine_id, add_id_to_iface)) {
 563             VLOG_ERR("bridge %s: problem setting netflow collectors",
 564                     br->name);
 565         }
 566
 567         /* Update the controller and related settings.  It would be more
 568          * straightforward to call this from bridge_reconfigure_one(), but we
 569          * can't do it there for two reasons.  First, and most importantly, at
 570          * that point we don't know the dp_ifidx of any interfaces that have
 571          * been added to the bridge (because we haven't actually added them to
 572          * the datapath).  Second, at that point we haven't set the datapath ID
 573          * yet; when a controller is configured, resetting the datapath ID will
 574          * immediately disconnect from the controller, so it's better to set
 575          * the datapath ID before the controller. */
 576         bridge_reconfigure_controller(br);
 577     }
 578     LIST_FOR_EACH (br, struct bridge, node, &all_bridges) {
 579         for (i = 0; i < br->n_ports; i++) {
 580             struct port *port = br->ports[i];
 581             port_update_vlan_compat(port);
 582         }
 583     }
 584     LIST_FOR_EACH (br, struct bridge, node, &all_bridges) {
 585         brstp_reconfigure(br);
 586     }
 587 }
 588
 589 static void
 590 bridge_pick_local_hw_addr(struct bridge *br, uint8_t ea[ETH_ADDR_LEN],
 591                           const char **devname)
 592 {
 593     uint64_t requested_ea;
 594     size_t i, j;
 595     int error;
 596
 597     *devname = NULL;
 598
 599     /* Did the user request a particular MAC? */
 600     requested_ea = cfg_get_mac(0, "bridge.%s.mac", br->name);
 601     if (requested_ea) {
 602         eth_addr_from_uint64(requested_ea, ea);
 603         if (eth_addr_is_multicast(ea)) {
 604             VLOG_ERR("bridge %s: cannot set MAC address to multicast "
 605                      "address "ETH_ADDR_FMT, br->name, ETH_ADDR_ARGS(ea));
 606         } else if (eth_addr_is_zero(ea)) {
 607             VLOG_ERR("bridge %s: cannot set MAC address to zero", br->name);
 608         } else {
 609             return;
 610         }
 611     }
 612
 613     /* Otherwise choose the minimum MAC address among all of the interfaces.
 614      * (Xen uses FE:FF:FF:FF:FF:FF for virtual interfaces so this will get the
 615      * MAC of the physical interface in such an environment.) */
 616     memset(ea, 0xff, sizeof ea);
 617     for (i = 0; i < br->n_ports; i++) {
 618         struct port *port = br->ports[i];
 619         uint8_t iface_ea[ETH_ADDR_LEN];
 620         uint64_t iface_ea_u64;
 621         struct iface *iface;
 622
 623         /* Mirror output ports don't participate. */
 624         if (port->is_mirror_output_port) {
 625             continue;
 626         }
 627
 628         /* Choose the MAC address to represent the port. */
 629         iface_ea_u64 = cfg_get_mac(0, "port.%s.mac", port->name);
 630         if (iface_ea_u64) {
 631             /* User specified explicitly. */
 632             eth_addr_from_uint64(iface_ea_u64, iface_ea);
 633         } else {
 634             /* Choose the interface whose MAC address will represent the port.
 635              * The Linux kernel bonding code always chooses the MAC address of
 636              * the first slave added to a bond, and the Fedora networking
 637              * scripts always add slaves to a bond in alphabetical order, so
 638              * for compatibility we choose the interface with the name that is
 639              * first in alphabetical order. */
 640             iface = port->ifaces[0];
 641             for (j = 1; j < port->n_ifaces; j++) {
 642                 struct iface *candidate = port->ifaces[j];
 643                 if (strcmp(candidate->name, iface->name) < 0) {
 644                     iface = candidate;
 645                 }
 646             }
 647
 648             /* The local port doesn't count (since we're trying to choose its
 649              * MAC address anyway).  Other internal ports don't count because
 650              * we really want a physical MAC if we can get it, and internal
 651              * ports typically have randomly generated MACs. */
 652             if (iface->dp_ifidx == ODPP_LOCAL
 653                 || cfg_get_bool(0, "iface.%s.internal", iface->name)) {
 654                 continue;
 655             }
 656
 657             /* Grab MAC. */
 658             error = netdev_nodev_get_etheraddr(iface->name, iface_ea);
 659             if (error) {
 660                 static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
 661                 VLOG_ERR_RL(&rl, "failed to obtain Ethernet address of %s: %s",
 662                             iface->name, strerror(error));
 663                 continue;
 664             }
 665         }
 666
 667         /* Compare against our current choice. */
 668         if (!eth_addr_is_multicast(iface_ea) &&
 669             !eth_addr_is_reserved(iface_ea) &&
 670             !eth_addr_is_zero(iface_ea) &&
 671             memcmp(iface_ea, ea, ETH_ADDR_LEN) < 0)
 672         {
 673             memcpy(ea, iface_ea, ETH_ADDR_LEN);
 674             *devname = iface->name;
 675         }
 676     }
 677     if (eth_addr_is_multicast(ea) || eth_addr_is_vif(ea)) {
 678         memcpy(ea, br->default_ea, ETH_ADDR_LEN);
 679         *devname = NULL;
 680         VLOG_WARN("bridge %s: using default bridge Ethernet "
 681                   "address "ETH_ADDR_FMT, br->name, ETH_ADDR_ARGS(ea));
 682     } else {
 683         VLOG_DBG("bridge %s: using bridge Ethernet address "ETH_ADDR_FMT,
 684                  br->name, ETH_ADDR_ARGS(ea));
 685     }
 686 }
 687
 688 /* Choose and returns the datapath ID for bridge 'br' given that the bridge
 689  * Ethernet address is 'bridge_ea'.  If 'bridge_ea' is the Ethernet address of
 690  * a network device, then that network device's name must be passed in as
 691  * 'devname'; if 'bridge_ea' was derived some other way, then 'devname' must be
 692  * passed in as a null pointer. */
 693 static uint64_t
 694 bridge_pick_datapath_id(struct bridge *br,
 695                         const uint8_t bridge_ea[ETH_ADDR_LEN],
 696                         const char *devname)
 697 {
 698     /*
 699      * The procedure for choosing a bridge MAC address will, in the most
 700      * ordinary case, also choose a unique MAC that we can use as a datapath
 701      * ID.  In some special cases, though, multiple bridges will end up with
 702      * the same MAC address.  This is OK for the bridges, but it will confuse
 703      * the OpenFlow controller, because each datapath needs a unique datapath
 704      * ID.
 705      *
 706      * Datapath IDs must be unique.  It is also very desirable that they be
 707      * stable from one run to the next, so that policy set on a datapath
 708      * "sticks".
 709      */
 710     uint64_t dpid;
 711
 712     dpid = cfg_get_dpid(0, "bridge.%s.datapath-id", br->name);
 713     if (dpid) {
 714         return dpid;
 715     }
 716
 717     if (devname) {
 718         int vlan;
 719         if (!netdev_get_vlan_vid(devname, &vlan)) {
 720             /*
 721              * A bridge whose MAC address is taken from a VLAN network device
 722              * (that is, a network device created with vconfig(8) or similar
 723              * tool) will have the same MAC address as a bridge on the VLAN
 724              * device's physical network device.
 725              *
 726              * Handle this case by hashing the physical network device MAC
 727              * along with the VLAN identifier.
 728              */
 729             uint8_t buf[ETH_ADDR_LEN + 2];
 730             memcpy(buf, bridge_ea, ETH_ADDR_LEN);
 731             buf[ETH_ADDR_LEN] = vlan >> 8;
 732             buf[ETH_ADDR_LEN + 1] = vlan;
 733             return dpid_from_hash(buf, sizeof buf);
 734         } else {
 735             /*
 736              * Assume that this bridge's MAC address is unique, since it
 737              * doesn't fit any of the cases we handle specially.
 738              */
 739         }
 740     } else {
 741         /*
 742          * A purely internal bridge, that is, one that has no non-virtual
 743          * network devices on it at all, is more difficult because it has no
 744          * natural unique identifier at all.
 745          *
 746          * When the host is a XenServer, we handle this case by hashing the
 747          * host's UUID with the name of the bridge.  Names of bridges are
 748          * persistent across XenServer reboots, although they can be reused if
 749          * an internal network is destroyed and then a new one is later
 750          * created, so this is fairly effective.
 751          *
 752          * When the host is not a XenServer, we punt by using a random MAC
 753          * address on each run.
 754          */
 755         const char *host_uuid = xenserver_get_host_uuid();
 756         if (host_uuid) {
 757             char *combined = xasprintf("%s,%s", host_uuid, br->name);
 758             dpid = dpid_from_hash(combined, strlen(combined));
 759             free(combined);
 760             return dpid;
 761         }
 762     }
 763
 764     return eth_addr_to_uint64(bridge_ea);
 765 }
 766
 767 static uint64_t
 768 dpid_from_hash(const void *data, size_t n)
 769 {
 770     uint8_t hash[SHA1_DIGEST_SIZE];
 771
 772     BUILD_ASSERT_DECL(sizeof hash >= ETH_ADDR_LEN);
 773     sha1_bytes(data, n, hash);
 774     eth_addr_mark_random(hash);
 775     return eth_addr_to_uint64(hash);
 776 }
 777
 778 int
 779 bridge_run(void)
 780 {
 781     struct bridge *br, *next;
 782     int retval;
 783
 784     retval = 0;
 785     LIST_FOR_EACH_SAFE (br, next, struct bridge, node, &all_bridges) {
 786         int error = bridge_run_one(br);
 787         if (error) {
 788             static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
 789             VLOG_ERR_RL(&rl, "bridge %s: datapath was destroyed externally, "
 790                         "forcing reconfiguration", br->name);
 791             if (!retval) {
 792                 retval = error;
 793             }
 794         }
 795     }
 796     return retval;
 797 }
 798
 799 void
 800 bridge_wait(void)
 801 {
 802     struct bridge *br;
 803
 804     LIST_FOR_EACH (br, struct bridge, node, &all_bridges) {
 805         ofproto_wait(br->ofproto);
 806         if (br->controller) {
 807             continue;
 808         }
 809
 810         if (br->ml) {
 811             mac_learning_wait(br->ml);
 812         }
 813         bond_wait(br);
 814         brstp_wait(br);
 815     }
 816 }
 817
 818 /* Forces 'br' to revalidate all of its flows.  This is appropriate when 'br''s
 819  * configuration changes.  */
 820 static void
 821 bridge_flush(struct bridge *br)
 822 {
 823     COVERAGE_INC(bridge_flush);
 824     br->flush = true;
 825     if (br->ml) {
 826         mac_learning_flush(br->ml);
 827     }
 828 }
 829 \f
 830 /* Bridge unixctl user interface functions. */
 831 static void
 832 bridge_unixctl_fdb_show(struct unixctl_conn *conn, const char *args)
 833 {
 834     struct ds ds = DS_EMPTY_INITIALIZER;
 835     const struct bridge *br;
 836
 837     br = bridge_lookup(args);
 838     if (!br) {
 839         unixctl_command_reply(conn, 501, "no such bridge");
 840         return;
 841     }
 842
 843     ds_put_cstr(&ds, " port  VLAN  MAC                Age\n");
 844     if (br->ml) {
 845         const struct mac_entry *e;
 846         LIST_FOR_EACH (e, struct mac_entry, lru_node, &br->ml->lrus) {
 847             if (e->port < 0 || e->port >= br->n_ports) {
 848                 continue;
 849             }
 850             ds_put_format(&ds, "%5d  %4d  "ETH_ADDR_FMT"  %3d\n",
 851                           br->ports[e->port]->ifaces[0]->dp_ifidx,
 852                           e->vlan, ETH_ADDR_ARGS(e->mac), mac_entry_age(e));
 853         }
 854     }
 855     unixctl_command_reply(conn, 200, ds_cstr(&ds));
 856     ds_destroy(&ds);
 857 }
 858 \f
 859 /* Bridge reconfiguration functions. */
 860
 861 static struct bridge *
 862 bridge_create(const char *name)
 863 {
 864     struct bridge *br;
 865     int error;
 866
 867     assert(!bridge_lookup(name));
 868     br = xcalloc(1, sizeof *br);
 869
 870     error = dpif_create(name, &br->dpif);
 871     if (error == EEXIST) {
 872         error = dpif_open(name, &br->dpif);
 873         if (error) {
 874             VLOG_ERR("datapath %s already exists but cannot be opened: %s",
 875                      name, strerror(error));
 876             free(br);
 877             return NULL;
 878         }
 879         dpif_flow_flush(&br->dpif);
 880     } else if (error) {
 881         VLOG_ERR("failed to create datapath %s: %s", name, strerror(error));
 882         free(br);
 883         return NULL;
 884     }
 885
 886     error = ofproto_create(name, &bridge_ofhooks, br, &br->ofproto);
 887     if (error) {
 888         VLOG_ERR("failed to create switch %s: %s", name, strerror(error));
 889         dpif_delete(&br->dpif);
 890         dpif_close(&br->dpif);
 891         free(br);
 892         return NULL;
 893     }
 894
 895     br->name = xstrdup(name);
 896     br->ml = mac_learning_create();
 897     br->sent_config_request = false;
 898     eth_addr_random(br->default_ea);
 899
 900     port_array_init(&br->ifaces);
 901
 902     br->flush = false;
 903     br->bond_next_rebalance = time_msec() + 10000;
 904
 905     list_push_back(&all_bridges, &br->node);
 906
 907     VLOG_INFO("created bridge %s on dp%u", br->name, dpif_id(&br->dpif));
 908
 909     return br;
 910 }
 911
 912 static void
 913 bridge_destroy(struct bridge *br)
 914 {
 915     if (br) {
 916         int error;
 917
 918         while (br->n_ports > 0) {
 919             port_destroy(br->ports[br->n_ports - 1]);
 920         }
 921         list_remove(&br->node);
 922         error = dpif_delete(&br->dpif);
 923         if (error && error != ENOENT) {
 924             VLOG_ERR("failed to delete dp%u: %s",
 925                      dpif_id(&br->dpif), strerror(error));
 926         }
 927         dpif_close(&br->dpif);
 928         ofproto_destroy(br->ofproto);
 929         free(br->controller);
 930         mac_learning_destroy(br->ml);
 931         port_array_destroy(&br->ifaces);
 932         free(br->ports);
 933         free(br->name);
 934         free(br);
 935     }
 936 }
 937
 938 static struct bridge *
 939 bridge_lookup(const char *name)
 940 {
 941     struct bridge *br;
 942
 943     LIST_FOR_EACH (br, struct bridge, node, &all_bridges) {
 944         if (!strcmp(br->name, name)) {
 945             return br;
 946         }
 947     }
 948     return NULL;
 949 }
 950
 951 bool
 952 bridge_exists(const char *name)
 953 {
 954     return bridge_lookup(name) ? true : false;
 955 }
 956
 957 uint64_t
 958 bridge_get_datapathid(const char *name)
 959 {
 960     struct bridge *br = bridge_lookup(name);
 961     return br ? ofproto_get_datapath_id(br->ofproto) : 0;
 962 }
 963
 964 /* Handle requests for a listing of all flows known by the OpenFlow
 965  * stack, including those normally hidden. */
 966 static void
 967 bridge_unixctl_dump_flows(struct unixctl_conn *conn, const char *args)
 968 {
 969     struct bridge *br;
 970     struct ds results;
 971
 972     br = bridge_lookup(args);
 973     if (!br) {
 974         unixctl_command_reply(conn, 501, "Unknown bridge");
 975         return;
 976     }
 977
 978     ds_init(&results);
 979     ofproto_get_all_flows(br->ofproto, &results);
 980
 981     unixctl_command_reply(conn, 200, ds_cstr(&results));
 982     ds_destroy(&results);
 983 }
 984
 985 static int
 986 bridge_run_one(struct bridge *br)
 987 {
 988     int error;
 989
 990     error = ofproto_run1(br->ofproto);
 991     if (error) {
 992         return error;
 993     }
 994
 995     if (br->ml) {
 996         mac_learning_run(br->ml, ofproto_get_revalidate_set(br->ofproto));
 997     }
 998     bond_run(br);
 999     brstp_run(br);
1000
1001     error = ofproto_run2(br->ofproto, br->flush);
1002     br->flush = false;
1003
1004     return error;
1005 }
1006
1007 static const char *
1008 bridge_get_controller(const struct bridge *br)
1009 {
1010     const char *controller;
1011
1012     controller = cfg_get_string(0, "bridge.%s.controller", br->name);
1013     if (!controller) {
1014         controller = cfg_get_string(0, "mgmt.controller");
1015     }
1016     return controller && controller[0] ? controller : NULL;
1017 }
1018
1019 static void
1020 bridge_reconfigure_one(struct bridge *br)
1021 {
1022     struct svec old_ports, new_ports, ifaces;
1023     struct svec listeners, old_listeners;
1024     struct svec snoops, old_snoops;
1025     size_t i, j;
1026
1027     /* Collect old ports. */
1028     svec_init(&old_ports);
1029     for (i = 0; i < br->n_ports; i++) {
1030         svec_add(&old_ports, br->ports[i]->name);
1031     }
1032     svec_sort(&old_ports);
1033     assert(svec_is_unique(&old_ports));
1034
1035     /* Collect new ports. */
1036     svec_init(&new_ports);
1037     cfg_get_all_keys(&new_ports, "bridge.%s.port", br->name);
1038     svec_sort(&new_ports);
1039     if (bridge_get_controller(br) && !svec_contains(&new_ports, br->name)) {
1040         svec_add(&new_ports, br->name);
1041         svec_sort(&new_ports);
1042     }
1043     if (!svec_is_unique(&new_ports)) {
1044         VLOG_WARN("bridge %s: %s specified twice as bridge port",
1045                   br->name, svec_get_duplicate(&new_ports));
1046         svec_unique(&new_ports);
1047     }
1048
1049     ofproto_set_mgmt_id(br->ofproto, mgmt_id);
1050
1051     /* Get rid of deleted ports and add new ports. */
1052     for (i = 0; i < br->n_ports; ) {
1053         struct port *port = br->ports[i];
1054         if (!svec_contains(&new_ports, port->name)) {
1055             port_destroy(port);
1056         } else {
1057             i++;
1058         }
1059     }
1060     for (i = 0; i < new_ports.n; i++) {
1061         const char *name = new_ports.names[i];
1062         if (!svec_contains(&old_ports, name)) {
1063             port_create(br, name);
1064         }
1065     }
1066     svec_destroy(&old_ports);
1067     svec_destroy(&new_ports);
1068
1069     /* Reconfigure all ports. */
1070     for (i = 0; i < br->n_ports; i++) {
1071         port_reconfigure(br->ports[i]);
1072     }
1073
1074     /* Check and delete duplicate interfaces. */
1075     svec_init(&ifaces);
1076     for (i = 0; i < br->n_ports; ) {
1077         struct port *port = br->ports[i];
1078         for (j = 0; j < port->n_ifaces; ) {
1079             struct iface *iface = port->ifaces[j];
1080             if (svec_contains(&ifaces, iface->name)) {
1081                 VLOG_ERR("bridge %s: %s interface is on multiple ports, "
1082                          "removing from %s",
1083                          br->name, iface->name, port->name);
1084                 iface_destroy(iface);
1085             } else {
1086                 svec_add(&ifaces, iface->name);
1087                 svec_sort(&ifaces);
1088                 j++;
1089             }
1090         }
1091         if (!port->n_ifaces) {
1092             VLOG_ERR("%s port has no interfaces, dropping", port->name);
1093             port_destroy(port);
1094         } else {
1095             i++;
1096         }
1097     }
1098     svec_destroy(&ifaces);
1099
1100     /* Delete all flows if we're switching from connected to standalone or vice
1101      * versa.  (XXX Should we delete all flows if we are switching from one
1102      * controller to another?) */
1103
1104     /* Configure OpenFlow management listeners. */
1105     svec_init(&listeners);
1106     cfg_get_all_strings(&listeners, "bridge.%s.openflow.listeners", br->name);
1107     if (!listeners.n) {
1108         svec_add_nocopy(&listeners, xasprintf("punix:%s/%s.mgmt",
1109                                               ovs_rundir, br->name));
1110     } else if (listeners.n == 1 && !strcmp(listeners.names[0], "none")) {
1111         svec_clear(&listeners);
1112     }
1113     svec_sort_unique(&listeners);
1114
1115     svec_init(&old_listeners);
1116     ofproto_get_listeners(br->ofproto, &old_listeners);
1117     svec_sort_unique(&old_listeners);
1118
1119     if (!svec_equal(&listeners, &old_listeners)) {
1120         ofproto_set_listeners(br->ofproto, &listeners);
1121     }
1122     svec_destroy(&listeners);
1123     svec_destroy(&old_listeners);
1124
1125     /* Configure OpenFlow controller connection snooping. */
1126     svec_init(&snoops);
1127     cfg_get_all_strings(&snoops, "bridge.%s.openflow.snoops", br->name);
1128     if (!snoops.n) {
1129         svec_add_nocopy(&snoops, xasprintf("punix:%s/%s.snoop",
1130                                            ovs_rundir, br->name));
1131     } else if (snoops.n == 1 && !strcmp(snoops.names[0], "none")) {
1132         svec_clear(&snoops);
1133     }
1134     svec_sort_unique(&snoops);
1135
1136     svec_init(&old_snoops);
1137     ofproto_get_snoops(br->ofproto, &old_snoops);
1138     svec_sort_unique(&old_snoops);
1139
1140     if (!svec_equal(&snoops, &old_snoops)) {
1141         ofproto_set_snoops(br->ofproto, &snoops);
1142     }
1143     svec_destroy(&snoops);
1144     svec_destroy(&old_snoops);
1145
1146     mirror_reconfigure(br);
1147 }
1148
1149 static void
1150 bridge_reconfigure_controller(struct bridge *br)
1151 {
1152     char *pfx = xasprintf("bridge.%s.controller", br->name);
1153     const char *controller;
1154
1155     controller = bridge_get_controller(br);
1156     if ((br->controller != NULL) != (controller != NULL)) {
1157         ofproto_flush_flows(br->ofproto);
1158     }
1159     free(br->controller);
1160     br->controller = controller ? xstrdup(controller) : NULL;
1161
1162     if (controller) {
1163         const char *fail_mode;
1164         int max_backoff, probe;
1165         int rate_limit, burst_limit;
1166
1167         if (!strcmp(controller, "discover")) {
1168             bool update_resolv_conf = true;
1169
1170             if (cfg_has("%s.update-resolv.conf", pfx)) {
1171                 update_resolv_conf = cfg_get_bool(0, "%s.update-resolv.conf",
1172                         pfx);
1173             }
1174             ofproto_set_discovery(br->ofproto, true,
1175                                   cfg_get_string(0, "%s.accept-regex", pfx),
1176                                   update_resolv_conf);
1177         } else {
1178             struct netdev *netdev;
1179             bool in_band;
1180             int error;
1181
1182             in_band = (!cfg_is_valid(CFG_BOOL | CFG_REQUIRED,
1183                                      "%s.in-band", pfx)
1184                        || cfg_get_bool(0, "%s.in-band", pfx));
1185             ofproto_set_discovery(br->ofproto, false, NULL, NULL);
1186             ofproto_set_in_band(br->ofproto, in_band);
1187
1188             error = netdev_open(br->name, NETDEV_ETH_TYPE_NONE, &netdev);
1189             if (!error) {
1190                 if (cfg_is_valid(CFG_IP | CFG_REQUIRED, "%s.ip", pfx)) {
1191                     struct in_addr ip, mask, gateway;
1192                     ip.s_addr = cfg_get_ip(0, "%s.ip", pfx);
1193                     mask.s_addr = cfg_get_ip(0, "%s.netmask", pfx);
1194                     gateway.s_addr = cfg_get_ip(0, "%s.gateway", pfx);
1195
1196                     netdev_turn_flags_on(netdev, NETDEV_UP, true);
1197                     if (!mask.s_addr) {
1198                         mask.s_addr = guess_netmask(ip.s_addr);
1199                     }
1200                     if (!netdev_set_in4(netdev, ip, mask)) {
1201                         VLOG_INFO("bridge %s: configured IP address "IP_FMT", "
1202                                   "netmask "IP_FMT,
1203                                   br->name, IP_ARGS(&ip.s_addr),
1204                                   IP_ARGS(&mask.s_addr));
1205                     }
1206
1207                     if (gateway.s_addr) {
1208                         if (!netdev_add_router(gateway)) {
1209                             VLOG_INFO("bridge %s: configured gateway "IP_FMT,
1210                                       br->name, IP_ARGS(&gateway.s_addr));
1211                         }
1212                     }
1213                 }
1214                 netdev_close(netdev);
1215             }
1216         }
1217
1218         fail_mode = cfg_get_string(0, "%s.fail-mode", pfx);
1219         if (!fail_mode) {
1220             fail_mode = cfg_get_string(0, "mgmt.fail-mode");
1221         }
1222         ofproto_set_failure(br->ofproto,
1223                             (!fail_mode
1224                              || !strcmp(fail_mode, "standalone")
1225                              || !strcmp(fail_mode, "open")));
1226
1227         probe = cfg_get_int(0, "%s.inactivity-probe", pfx);
1228         if (probe < 5) {
1229             probe = cfg_get_int(0, "mgmt.inactivity-probe");
1230             if (probe < 5) {
1231                 probe = 5;
1232             }
1233         }
1234         ofproto_set_probe_interval(br->ofproto, probe);
1235
1236         max_backoff = cfg_get_int(0, "%s.max-backoff", pfx);
1237         if (!max_backoff) {
1238             max_backoff = cfg_get_int(0, "mgmt.max-backoff");
1239             if (!max_backoff) {
1240                 max_backoff = 8;
1241             }
1242         }
1243         ofproto_set_max_backoff(br->ofproto, max_backoff);
1244
1245         rate_limit = cfg_get_int(0, "%s.rate-limit", pfx);
1246         if (!rate_limit) {
1247             rate_limit = cfg_get_int(0, "mgmt.rate-limit");
1248         }
1249         burst_limit = cfg_get_int(0, "%s.burst-limit", pfx);
1250         if (!burst_limit) {
1251             burst_limit = cfg_get_int(0, "mgmt.burst-limit");
1252         }
1253         ofproto_set_rate_limit(br->ofproto, rate_limit, burst_limit);
1254
1255         ofproto_set_stp(br->ofproto, cfg_get_bool(0, "%s.stp", pfx));
1256
1257         if (cfg_has("%s.commands.acl", pfx)) {
1258             struct svec command_acls;
1259             char *command_acl;
1260
1261             svec_init(&command_acls);
1262             cfg_get_all_strings(&command_acls, "%s.commands.acl", pfx);
1263             command_acl = svec_join(&command_acls, ",", "");
1264
1265             ofproto_set_remote_execution(br->ofproto, command_acl,
1266                                          cfg_get_string(0, "%s.commands.dir",
1267                                                         pfx));
1268
1269             svec_destroy(&command_acls);
1270             free(command_acl);
1271         } else {
1272             ofproto_set_remote_execution(br->ofproto, NULL, NULL);
1273         }
1274     } else {
1275         union ofp_action action;
1276         flow_t flow;
1277
1278         /* Set up a flow that matches every packet and directs them to
1279          * OFPP_NORMAL (which goes to us). */
1280         memset(&action, 0, sizeof action);
1281         action.type = htons(OFPAT_OUTPUT);
1282         action.output.len = htons(sizeof action);
1283         action.output.port = htons(OFPP_NORMAL);
1284         memset(&flow, 0, sizeof flow);
1285         ofproto_add_flow(br->ofproto, &flow, OFPFW_ALL, 0,
1286                          &action, 1, 0);
1287
1288         ofproto_set_in_band(br->ofproto, false);
1289         ofproto_set_max_backoff(br->ofproto, 1);
1290         ofproto_set_probe_interval(br->ofproto, 5);
1291         ofproto_set_failure(br->ofproto, false);
1292         ofproto_set_stp(br->ofproto, false);
1293     }
1294     free(pfx);
1295
1296     ofproto_set_controller(br->ofproto, br->controller);
1297 }
1298
1299 static void
1300 bridge_get_all_ifaces(const struct bridge *br, struct svec *ifaces)
1301 {
1302     size_t i, j;
1303
1304     svec_init(ifaces);
1305     for (i = 0; i < br->n_ports; i++) {
1306         struct port *port = br->ports[i];
1307         for (j = 0; j < port->n_ifaces; j++) {
1308             struct iface *iface = port->ifaces[j];
1309             svec_add(ifaces, iface->name);
1310         }
1311     }
1312     svec_sort(ifaces);
1313     assert(svec_is_unique(ifaces));
1314 }
1315
1316 /* For robustness, in case the administrator moves around datapath ports behind
1317  * our back, we re-check all the datapath port numbers here.
1318  *
1319  * This function will set the 'dp_ifidx' members of interfaces that have
1320  * disappeared to -1, so only call this function from a context where those
1321  * 'struct iface's will be removed from the bridge.  Otherwise, the -1
1322  * 'dp_ifidx'es will cause trouble later when we try to send them to the
1323  * datapath, which doesn't support UINT16_MAX+1 ports. */
1324 static void
1325 bridge_fetch_dp_ifaces(struct bridge *br)
1326 {
1327     struct odp_port *dpif_ports;
1328     size_t n_dpif_ports;
1329     size_t i, j;
1330
1331     /* Reset all interface numbers. */
1332     for (i = 0; i < br->n_ports; i++) {
1333         struct port *port = br->ports[i];
1334         for (j = 0; j < port->n_ifaces; j++) {
1335             struct iface *iface = port->ifaces[j];
1336             iface->dp_ifidx = -1;
1337         }
1338     }
1339     port_array_clear(&br->ifaces);
1340
1341     dpif_port_list(&br->dpif, &dpif_ports, &n_dpif_ports);
1342     for (i = 0; i < n_dpif_ports; i++) {
1343         struct odp_port *p = &dpif_ports[i];
1344         struct iface *iface = iface_lookup(br, p->devname);
1345         if (iface) {
1346             if (iface->dp_ifidx >= 0) {
1347                 VLOG_WARN("dp%u reported interface %s twice",
1348                           dpif_id(&br->dpif), p->devname);
1349             } else if (iface_from_dp_ifidx(br, p->port)) {
1350                 VLOG_WARN("dp%u reported interface %"PRIu16" twice",
1351                           dpif_id(&br->dpif), p->port);
1352             } else {
1353                 port_array_set(&br->ifaces, p->port, iface);
1354                 iface->dp_ifidx = p->port;
1355             }
1356         }
1357     }
1358     free(dpif_ports);
1359 }
1360 \f
1361 /* Bridge packet processing functions. */
1362
1363 static int
1364 bond_hash(const uint8_t mac[ETH_ADDR_LEN])
1365 {
1366     return hash_bytes(mac, ETH_ADDR_LEN, 0) & BOND_MASK;
1367 }
1368
1369 static struct bond_entry *
1370 lookup_bond_entry(const struct port *port, const uint8_t mac[ETH_ADDR_LEN])
1371 {
1372     return &port->bond_hash[bond_hash(mac)];
1373 }
1374
1375 static int
1376 bond_choose_iface(const struct port *port)
1377 {
1378     size_t i;
1379     for (i = 0; i < port->n_ifaces; i++) {
1380         if (port->ifaces[i]->enabled) {
1381             return i;
1382         }
1383     }
1384     return -1;
1385 }
1386
1387 static bool
1388 choose_output_iface(const struct port *port, const uint8_t *dl_src,
1389                     uint16_t *dp_ifidx, tag_type *tags)
1390 {
1391     struct iface *iface;
1392
1393     assert(port->n_ifaces);
1394     if (port->n_ifaces == 1) {
1395         iface = port->ifaces[0];
1396     } else {
1397         struct bond_entry *e = lookup_bond_entry(port, dl_src);
1398         if (e->iface_idx < 0 || e->iface_idx >= port->n_ifaces
1399             || !port->ifaces[e->iface_idx]->enabled) {
1400             /* XXX select interface properly.  The current interface selection
1401              * is only good for testing the rebalancing code. */
1402             e->iface_idx = bond_choose_iface(port);
1403             if (e->iface_idx < 0) {
1404                 *tags |= port->no_ifaces_tag;
1405                 return false;
1406             }
1407             e->iface_tag = tag_create_random();
1408         }
1409         *tags |= e->iface_tag;
1410         iface = port->ifaces[e->iface_idx];
1411     }
1412     *dp_ifidx = iface->dp_ifidx;
1413     *tags |= iface->tag;        /* Currently only used for bonding. */
1414     return true;
1415 }
1416
1417 static void
1418 bond_link_status_update(struct iface *iface, bool carrier)
1419 {
1420     static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(5, 20);
1421     struct port *port = iface->port;
1422
1423     if ((carrier == iface->enabled) == (iface->delay_expires == LLONG_MAX)) {
1424         /* Nothing to do. */
1425         return;
1426     }
1427     VLOG_INFO_RL(&rl, "interface %s: carrier %s",
1428                  iface->name, carrier ? "detected" : "dropped");
1429     if (carrier == iface->enabled) {
1430         iface->delay_expires = LLONG_MAX;
1431         VLOG_INFO_RL(&rl, "interface %s: will not be %s",
1432                      iface->name, carrier ? "disabled" : "enabled");
1433     } else if (carrier && port->updelay && port->active_iface < 0) {
1434         iface->delay_expires = time_msec();
1435         VLOG_INFO_RL(&rl, "interface %s: skipping %d ms updelay since no "
1436                      "other interface is up", iface->name, port->updelay);
1437     } else {
1438         int delay = carrier ? port->updelay : port->downdelay;
1439         iface->delay_expires = time_msec() + delay;
1440         if (delay) {
1441             VLOG_INFO_RL(&rl,
1442                          "interface %s: will be %s if it stays %s for %d ms",
1443                          iface->name,
1444                          carrier ? "enabled" : "disabled",
1445                          carrier ? "up" : "down",
1446                          delay);
1447         }
1448     }
1449 }
1450
1451 static void
1452 bond_choose_active_iface(struct port *port)
1453 {
1454     static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(5, 20);
1455
1456     port->active_iface = bond_choose_iface(port);
1457     port->active_iface_tag = tag_create_random();
1458     if (port->active_iface >= 0) {
1459         VLOG_INFO_RL(&rl, "port %s: active interface is now %s",
1460                      port->name, port->ifaces[port->active_iface]->name);
1461     } else {
1462         VLOG_WARN_RL(&rl, "port %s: all ports disabled, no active interface",
1463                      port->name);
1464     }
1465 }
1466
1467 static void
1468 bond_enable_slave(struct iface *iface, bool enable)
1469 {
1470     struct port *port = iface->port;
1471     struct bridge *br = port->bridge;
1472
1473     iface->delay_expires = LLONG_MAX;
1474     if (enable == iface->enabled) {
1475         return;
1476     }
1477
1478     iface->enabled = enable;
1479     if (!iface->enabled) {
1480         VLOG_WARN("interface %s: disabled", iface->name);
1481         ofproto_revalidate(br->ofproto, iface->tag);
1482         if (iface->port_ifidx == port->active_iface) {
1483             ofproto_revalidate(br->ofproto,
1484                                port->active_iface_tag);
1485             bond_choose_active_iface(port);
1486         }
1487         bond_send_learning_packets(port);
1488     } else {
1489         VLOG_WARN("interface %s: enabled", iface->name);
1490         if (port->active_iface < 0) {
1491             ofproto_revalidate(br->ofproto, port->no_ifaces_tag);
1492             bond_choose_active_iface(port);
1493             bond_send_learning_packets(port);
1494         }
1495         iface->tag = tag_create_random();
1496     }
1497 }
1498
1499 static void
1500 bond_run(struct bridge *br)
1501 {
1502     size_t i, j;
1503
1504     for (i = 0; i < br->n_ports; i++) {
1505         struct port *port = br->ports[i];
1506         if (port->n_ifaces < 2) {
1507             continue;
1508         }
1509         for (j = 0; j < port->n_ifaces; j++) {
1510             struct iface *iface = port->ifaces[j];
1511             if (time_msec() >= iface->delay_expires) {
1512                 bond_enable_slave(iface, !iface->enabled);
1513             }
1514         }
1515     }
1516 }
1517
1518 static void
1519 bond_wait(struct bridge *br)
1520 {
1521     size_t i, j;
1522
1523     for (i = 0; i < br->n_ports; i++) {
1524         struct port *port = br->ports[i];
1525         if (port->n_ifaces < 2) {
1526             continue;
1527         }
1528         for (j = 0; j < port->n_ifaces; j++) {
1529             struct iface *iface = port->ifaces[j];
1530             if (iface->delay_expires != LLONG_MAX) {
1531                 poll_timer_wait(iface->delay_expires - time_msec());
1532             }
1533         }
1534     }
1535 }
1536
1537 static bool
1538 set_dst(struct dst *p, const flow_t *flow,
1539         const struct port *in_port, const struct port *out_port,
1540         tag_type *tags)
1541 {
1542     /* STP handling.
1543      *
1544      * XXX This uses too many tags: any broadcast flow will get one tag per
1545      * destination port, and thus a broadcast on a switch of any size is likely
1546      * to have all tag bits set.  We should figure out a way to be smarter.
1547      *
1548      * This is OK when STP is disabled, because stp_state_tag is 0 then. */
1549     *tags |= out_port->stp_state_tag;
1550     if (!(out_port->stp_state & (STP_DISABLED | STP_FORWARDING))) {
1551         return false;
1552     }
1553
1554     p->vlan = (out_port->vlan >= 0 ? OFP_VLAN_NONE
1555               : in_port->vlan >= 0 ? in_port->vlan
1556               : ntohs(flow->dl_vlan));
1557     return choose_output_iface(out_port, flow->dl_src, &p->dp_ifidx, tags);
1558 }
1559
1560 static void
1561 swap_dst(struct dst *p, struct dst *q)
1562 {
1563     struct dst tmp = *p;
1564     *p = *q;
1565     *q = tmp;
1566 }
1567
1568 /* Moves all the dsts with vlan == 'vlan' to the front of the 'n_dsts' in
1569  * 'dsts'.  (This may help performance by reducing the number of VLAN changes
1570  * that we push to the datapath.  We could in fact fully sort the array by
1571  * vlan, but in most cases there are at most two different vlan tags so that's
1572  * possibly overkill.) */
1573 static void
1574 partition_dsts(struct dst *dsts, size_t n_dsts, int vlan)
1575 {
1576     struct dst *first = dsts;
1577     struct dst *last = dsts + n_dsts;
1578
1579     while (first != last) {
1580         /* Invariants:
1581          *      - All dsts < first have vlan == 'vlan'.
1582          *      - All dsts >= last have vlan != 'vlan'.
1583          *      - first < last. */
1584         while (first->vlan == vlan) {
1585             if (++first == last) {
1586                 return;
1587             }
1588         }
1589
1590         /* Same invariants, plus one additional:
1591          *      - first->vlan != vlan.
1592          */
1593         while (last[-1].vlan != vlan) {
1594             if (--last == first) {
1595                 return;
1596             }
1597         }
1598
1599         /* Same invariants, plus one additional:
1600          *      - last[-1].vlan == vlan.*/
1601         swap_dst(first++, --last);
1602     }
1603 }
1604
1605 static int
1606 mirror_mask_ffs(mirror_mask_t mask)
1607 {
1608     BUILD_ASSERT_DECL(sizeof(unsigned int) >= sizeof(mask));
1609     return ffs(mask);
1610 }
1611
1612 static bool
1613 dst_is_duplicate(const struct dst *dsts, size_t n_dsts,
1614                  const struct dst *test)
1615 {
1616     size_t i;
1617     for (i = 0; i < n_dsts; i++) {
1618         if (dsts[i].vlan == test->vlan && dsts[i].dp_ifidx == test->dp_ifidx) {
1619             return true;
1620         }
1621     }
1622     return false;
1623 }
1624
1625 static bool
1626 port_trunks_vlan(const struct port *port, uint16_t vlan)
1627 {
1628     return port->vlan < 0 && bitmap_is_set(port->trunks, vlan);
1629 }
1630
1631 static bool
1632 port_includes_vlan(const struct port *port, uint16_t vlan)
1633 {
1634     return vlan == port->vlan || port_trunks_vlan(port, vlan);
1635 }
1636
1637 static size_t
1638 compose_dsts(const struct bridge *br, const flow_t *flow, uint16_t vlan,
1639              const struct port *in_port, const struct port *out_port,
1640              struct dst dsts[], tag_type *tags)
1641 {
1642     mirror_mask_t mirrors = in_port->src_mirrors;
1643     struct dst *dst = dsts;
1644     size_t i;
1645
1646     *tags |= in_port->stp_state_tag;
1647     if (out_port == FLOOD_PORT) {
1648         /* XXX use ODP_FLOOD if no vlans or bonding. */
1649         /* XXX even better, define each VLAN as a datapath port group */
1650         for (i = 0; i < br->n_ports; i++) {
1651             struct port *port = br->ports[i];
1652             if (port != in_port && port_includes_vlan(port, vlan)
1653                 && !port->is_mirror_output_port
1654                 && set_dst(dst, flow, in_port, port, tags)) {
1655                 mirrors |= port->dst_mirrors;
1656                 dst++;
1657             }
1658         }
1659     } else if (out_port && set_dst(dst, flow, in_port, out_port, tags)) {
1660         mirrors |= out_port->dst_mirrors;
1661         dst++;
1662     }
1663
1664     while (mirrors) {
1665         struct mirror *m = br->mirrors[mirror_mask_ffs(mirrors) - 1];
1666         if (!m->n_vlans || vlan_is_mirrored(m, vlan)) {
1667             if (m->out_port) {
1668                 if (set_dst(dst, flow, in_port, m->out_port, tags)
1669                     && !dst_is_duplicate(dsts, dst - dsts, dst)) {
1670                     dst++;
1671                 }
1672             } else {
1673                 for (i = 0; i < br->n_ports; i++) {
1674                     struct port *port = br->ports[i];
1675                     if (port_includes_vlan(port, m->out_vlan)
1676                         && set_dst(dst, flow, in_port, port, tags)
1677                         && !dst_is_duplicate(dsts, dst - dsts, dst))
1678                     {
1679                         if (port->vlan < 0) {
1680                             dst->vlan = m->out_vlan;
1681                         }
1682                         if (dst->dp_ifidx == flow->in_port
1683                             && dst->vlan == vlan) {
1684                             /* Don't send out input port on same VLAN. */
1685                             continue;
1686                         }
1687                         dst++;
1688                     }
1689                 }
1690             }
1691         }
1692         mirrors &= mirrors - 1;
1693     }
1694
1695     partition_dsts(dsts, dst - dsts, ntohs(flow->dl_vlan));
1696     return dst - dsts;
1697 }
1698
1699 static void UNUSED
1700 print_dsts(const struct dst *dsts, size_t n)
1701 {
1702     for (; n--; dsts++) {
1703         printf(">p%"PRIu16, dsts->dp_ifidx);
1704         if (dsts->vlan != OFP_VLAN_NONE) {
1705             printf("v%"PRIu16, dsts->vlan);
1706         }
1707     }
1708 }
1709
1710 static void
1711 compose_actions(struct bridge *br, const flow_t *flow, uint16_t vlan,
1712                 const struct port *in_port, const struct port *out_port,
1713                 tag_type *tags, struct odp_actions *actions)
1714 {
1715     struct dst dsts[DP_MAX_PORTS * (MAX_MIRRORS + 1)];
1716     size_t n_dsts;
1717     const struct dst *p;
1718     uint16_t cur_vlan;
1719
1720     n_dsts = compose_dsts(br, flow, vlan, in_port, out_port, dsts, tags);
1721
1722     cur_vlan = ntohs(flow->dl_vlan);
1723     for (p = dsts; p < &dsts[n_dsts]; p++) {
1724         union odp_action *a;
1725         if (p->vlan != cur_vlan) {
1726             if (p->vlan == OFP_VLAN_NONE) {
1727                 odp_actions_add(actions, ODPAT_STRIP_VLAN);
1728             } else {
1729                 a = odp_actions_add(actions, ODPAT_SET_VLAN_VID);
1730                 a->vlan_vid.vlan_vid = htons(p->vlan);
1731             }
1732             cur_vlan = p->vlan;
1733         }
1734         a = odp_actions_add(actions, ODPAT_OUTPUT);
1735         a->output.port = p->dp_ifidx;
1736     }
1737 }
1738
1739 static bool
1740 is_bcast_arp_reply(const flow_t *flow, const struct ofpbuf *packet)
1741 {
1742     struct arp_eth_header *arp = (struct arp_eth_header *) packet->data;
1743     return (flow->dl_type == htons(ETH_TYPE_ARP)
1744             && eth_addr_is_broadcast(flow->dl_dst)
1745             && packet->size >= sizeof(struct arp_eth_header)
1746             && arp->ar_op == ARP_OP_REQUEST);
1747 }
1748
1749 /* If the composed actions may be applied to any packet in the given 'flow',
1750  * returns true.  Otherwise, the actions should only be applied to 'packet', or
1751  * not at all, if 'packet' was NULL. */
1752 static bool
1753 process_flow(struct bridge *br, const flow_t *flow,
1754              const struct ofpbuf *packet, struct odp_actions *actions,
1755              tag_type *tags)
1756 {
1757     struct iface *in_iface;
1758     struct port *in_port;
1759     struct port *out_port = NULL; /* By default, drop the packet/flow. */
1760     int vlan;
1761
1762     /* Find the interface and port structure for the received packet. */
1763     in_iface = iface_from_dp_ifidx(br, flow->in_port);
1764     if (!in_iface) {
1765         /* No interface?  Something fishy... */
1766         if (packet != NULL) {
1767             /* Odd.  A few possible reasons here:
1768              *
1769              * - We deleted an interface but there are still a few packets
1770              *   queued up from it.
1771              *
1772              * - Someone externally added an interface (e.g. with "ovs-dpctl
1773              *   add-if") that we don't know about.
1774              *
1775              * - Packet arrived on the local port but the local port is not
1776              *   one of our bridge ports.
1777              */
1778             static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
1779
1780             VLOG_WARN_RL(&rl, "bridge %s: received packet on unknown "
1781                          "interface %"PRIu16, br->name, flow->in_port);
1782         }
1783
1784         /* Return without adding any actions, to drop packets on this flow. */
1785         return true;
1786     }
1787     in_port = in_iface->port;
1788
1789     /* Figure out what VLAN this packet belongs to.
1790      *
1791      * Note that dl_vlan of 0 and of OFP_VLAN_NONE both mean that the packet
1792      * belongs to VLAN 0, so we should treat both cases identically.  (In the
1793      * former case, the packet has an 802.1Q header that specifies VLAN 0,
1794      * presumably to allow a priority to be specified.  In the latter case, the
1795      * packet does not have any 802.1Q header.) */
1796     vlan = ntohs(flow->dl_vlan);
1797     if (vlan == OFP_VLAN_NONE) {
1798         vlan = 0;
1799     }
1800     if (in_port->vlan >= 0) {
1801         if (vlan) {
1802             /* XXX support double tagging? */
1803             if (packet != NULL) {
1804                 static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
1805                 VLOG_WARN_RL(&rl, "bridge %s: dropping VLAN %"PRIu16" tagged "
1806                              "packet received on port %s configured with "
1807                              "implicit VLAN %"PRIu16,
1808                              br->name, ntohs(flow->dl_vlan),
1809                              in_port->name, in_port->vlan);
1810             }
1811             goto done;
1812         }
1813         vlan = in_port->vlan;
1814     } else {
1815         if (!port_includes_vlan(in_port, vlan)) {
1816             static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
1817             VLOG_WARN_RL(&rl, "bridge %s: dropping VLAN %d tagged "
1818                          "packet received on port %s not configured for "
1819                          "trunking VLAN %d",
1820                          br->name, vlan, in_port->name, vlan);
1821             goto done;
1822         }
1823     }
1824
1825     /* Drop frames for ports that STP wants entirely killed (both for
1826      * forwarding and for learning).  Later, after we do learning, we'll drop
1827      * the frames that STP wants to do learning but not forwarding on. */
1828     if (in_port->stp_state & (STP_LISTENING | STP_BLOCKING)) {
1829         goto done;
1830     }
1831
1832     /* Drop frames for reserved multicast addresses. */
1833     if (eth_addr_is_reserved(flow->dl_dst)) {
1834         goto done;
1835     }
1836
1837     /* Drop frames on ports reserved for mirroring. */
1838     if (in_port->is_mirror_output_port) {
1839         static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
1840         VLOG_WARN_RL(&rl, "bridge %s: dropping packet received on port %s, "
1841                      "which is reserved exclusively for mirroring",
1842                      br->name, in_port->name);
1843         goto done;
1844     }
1845
1846     /* Multicast (and broadcast) packets on bonds need special attention, to
1847      * avoid receiving duplicates. */
1848     if (in_port->n_ifaces > 1 && eth_addr_is_multicast(flow->dl_dst)) {
1849         *tags |= in_port->active_iface_tag;
1850         if (in_port->active_iface != in_iface->port_ifidx) {
1851             /* Drop all multicast packets on inactive slaves. */
1852             goto done;
1853         } else {
1854             /* Drop all multicast packets for which we have learned a different
1855              * input port, because we probably sent the packet on one slaves
1856              * and got it back on the active slave.  Broadcast ARP replies are
1857              * an exception to this rule: the host has moved to another
1858              * switch. */
1859             int src_idx = mac_learning_lookup(br->ml, flow->dl_src, vlan);
1860             if (src_idx != -1 && src_idx != in_port->port_idx) {
1861                 if (packet) {
1862                     if (!is_bcast_arp_reply(flow, packet)) {
1863                         goto done;
1864                     }
1865                 } else {
1866                     /* No way to know whether it's an ARP reply, because the
1867                      * flow entry doesn't include enough information and we
1868                      * don't have a packet.  Punt. */
1869                     return false;
1870                 }
1871             }
1872         }
1873     }
1874
1875     /* MAC learning. */
1876     out_port = FLOOD_PORT;
1877     if (br->ml) {
1878         int out_port_idx;
1879
1880         /* Learn source MAC (but don't try to learn from revalidation). */
1881         if (packet) {
1882             tag_type rev_tag = mac_learning_learn(br->ml, flow->dl_src,
1883                                                   vlan, in_port->port_idx);
1884             if (rev_tag) {
1885                 /* The log messages here could actually be useful in debugging,
1886                  * so keep the rate limit relatively high. */
1887                 static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(30,
1888                                                                         300);
1889                 VLOG_DBG_RL(&rl, "bridge %s: learned that "ETH_ADDR_FMT" is "
1890                             "on port %s in VLAN %d",
1891                             br->name, ETH_ADDR_ARGS(flow->dl_src),
1892                             in_port->name, vlan);
1893                 ofproto_revalidate(br->ofproto, rev_tag);
1894             }
1895         }
1896
1897         /* Determine output port. */
1898         out_port_idx = mac_learning_lookup_tag(br->ml, flow->dl_dst, vlan,
1899                                                tags);
1900         if (out_port_idx >= 0 && out_port_idx < br->n_ports) {
1901             out_port = br->ports[out_port_idx];
1902         }
1903     }
1904
1905     /* Don't send packets out their input ports.  Don't forward frames that STP
1906      * wants us to discard. */
1907     if (in_port == out_port || in_port->stp_state == STP_LEARNING) {
1908         out_port = NULL;
1909     }
1910
1911 done:
1912     compose_actions(br, flow, vlan, in_port, out_port, tags, actions);
1913
1914     /*
1915      * We send out only a single packet, instead of setting up a flow, if the
1916      * packet is an ARP directed to broadcast that arrived on a bonded
1917      * interface.  In such a situation ARP requests and replies must be handled
1918      * differently, but OpenFlow unfortunately can't distinguish them.
1919      */
1920     return (in_port->n_ifaces < 2
1921             || flow->dl_type != htons(ETH_TYPE_ARP)
1922             || !eth_addr_is_broadcast(flow->dl_dst));
1923 }
1924
1925 /* Careful: 'opp' is in host byte order and opp->port_no is an OFP port
1926  * number. */
1927 static void
1928 bridge_port_changed_ofhook_cb(enum ofp_port_reason reason,
1929                               const struct ofp_phy_port *opp,
1930                               void *br_)
1931 {
1932     struct bridge *br = br_;
1933     struct iface *iface;
1934     struct port *port;
1935
1936     iface = iface_from_dp_ifidx(br, ofp_port_to_odp_port(opp->port_no));
1937     if (!iface) {
1938         return;
1939     }
1940     port = iface->port;
1941
1942     if (reason == OFPPR_DELETE) {
1943         VLOG_WARN("bridge %s: interface %s deleted unexpectedly",
1944                   br->name, iface->name);
1945         iface_destroy(iface);
1946         if (!port->n_ifaces) {
1947             VLOG_WARN("bridge %s: port %s has no interfaces, dropping",
1948                       br->name, port->name);
1949             port_destroy(port);
1950         }
1951
1952         bridge_flush(br);
1953     } else {
1954         memcpy(iface->mac, opp->hw_addr, ETH_ADDR_LEN);
1955         if (port->n_ifaces > 1) {
1956             bool up = !(opp->state & OFPPS_LINK_DOWN);
1957             bond_link_status_update(iface, up);
1958             port_update_bond_compat(port);
1959         }
1960     }
1961 }
1962
1963 static bool
1964 bridge_normal_ofhook_cb(const flow_t *flow, const struct ofpbuf *packet,
1965                         struct odp_actions *actions, tag_type *tags, void *br_)
1966 {
1967     struct bridge *br = br_;
1968
1969 #if 0
1970     if (flow->dl_type == htons(OFP_DL_TYPE_NOT_ETH_TYPE)
1971         && eth_addr_equals(flow->dl_dst, stp_eth_addr)) {
1972         brstp_receive(br, flow, payload);
1973         return true;
1974     }
1975 #endif
1976
1977     COVERAGE_INC(bridge_process_flow);
1978     return process_flow(br, flow, packet, actions, tags);
1979 }
1980
1981 static void
1982 bridge_account_flow_ofhook_cb(const flow_t *flow,
1983                               const union odp_action *actions,
1984                               size_t n_actions, unsigned long long int n_bytes,
1985                               void *br_)
1986 {
1987     struct bridge *br = br_;
1988     const union odp_action *a;
1989
1990     if (!br->has_bonded_ports) {
1991         return;
1992     }
1993
1994     for (a = actions; a < &actions[n_actions]; a++) {
1995         if (a->type == ODPAT_OUTPUT) {
1996             struct port *port = port_from_dp_ifidx(br, a->output.port);
1997             if (port && port->n_ifaces >= 2) {
1998                 struct bond_entry *e = lookup_bond_entry(port, flow->dl_src);
1999                 e->tx_bytes += n_bytes;
2000             }
2001         }
2002     }
2003 }
2004
2005 static void
2006 bridge_account_checkpoint_ofhook_cb(void *br_)
2007 {
2008     struct bridge *br = br_;
2009     size_t i;
2010
2011     if (!br->has_bonded_ports) {
2012         return;
2013     }
2014
2015     /* The current ofproto implementation calls this callback at least once a
2016      * second, so this timer implementation is sufficient. */
2017     if (time_msec() < br->bond_next_rebalance) {
2018         return;
2019     }
2020     br->bond_next_rebalance = time_msec() + 10000;
2021
2022     for (i = 0; i < br->n_ports; i++) {
2023         struct port *port = br->ports[i];
2024         if (port->n_ifaces > 1) {
2025             bond_rebalance_port(port);
2026         }
2027     }
2028 }
2029
2030 static struct ofhooks bridge_ofhooks = {
2031     bridge_port_changed_ofhook_cb,
2032     bridge_normal_ofhook_cb,
2033     bridge_account_flow_ofhook_cb,
2034     bridge_account_checkpoint_ofhook_cb,
2035 };
2036 \f
2037 /* Bonding functions. */
2038
2039 /* Statistics for a single interface on a bonded port, used for load-based
2040  * bond rebalancing.  */
2041 struct slave_balance {
2042     struct iface *iface;        /* The interface. */
2043     uint64_t tx_bytes;          /* Sum of hashes[*]->tx_bytes. */
2044
2045     /* All the "bond_entry"s that are assigned to this interface, in order of
2046      * increasing tx_bytes. */
2047     struct bond_entry **hashes;
2048     size_t n_hashes;
2049 };
2050
2051 /* Sorts pointers to pointers to bond_entries in ascending order by the
2052  * interface to which they are assigned, and within a single interface in
2053  * ascending order of bytes transmitted. */
2054 static int
2055 compare_bond_entries(const void *a_, const void *b_)
2056 {
2057     const struct bond_entry *const *ap = a_;
2058     const struct bond_entry *const *bp = b_;
2059     const struct bond_entry *a = *ap;
2060     const struct bond_entry *b = *bp;
2061     if (a->iface_idx != b->iface_idx) {
2062         return a->iface_idx > b->iface_idx ? 1 : -1;
2063     } else if (a->tx_bytes != b->tx_bytes) {
2064         return a->tx_bytes > b->tx_bytes ? 1 : -1;
2065     } else {
2066         return 0;
2067     }
2068 }
2069
2070 /* Sorts slave_balances so that enabled ports come first, and otherwise in
2071  * *descending* order by number of bytes transmitted. */
2072 static int
2073 compare_slave_balance(const void *a_, const void *b_)
2074 {
2075     const struct slave_balance *a = a_;
2076     const struct slave_balance *b = b_;
2077     if (a->iface->enabled != b->iface->enabled) {
2078         return a->iface->enabled ? -1 : 1;
2079     } else if (a->tx_bytes != b->tx_bytes) {
2080         return a->tx_bytes > b->tx_bytes ? -1 : 1;
2081     } else {
2082         return 0;
2083     }
2084 }
2085
2086 static void
2087 swap_bals(struct slave_balance *a, struct slave_balance *b)
2088 {
2089     struct slave_balance tmp = *a;
2090     *a = *b;
2091     *b = tmp;
2092 }
2093
2094 /* Restores the 'n_bals' slave_balance structures in 'bals' to sorted order
2095  * given that 'p' (and only 'p') might be in the wrong location.
2096  *
2097  * This function invalidates 'p', since it might now be in a different memory
2098  * location. */
2099 static void
2100 resort_bals(struct slave_balance *p,
2101             struct slave_balance bals[], size_t n_bals)
2102 {
2103     if (n_bals > 1) {
2104         for (; p > bals && p->tx_bytes > p[-1].tx_bytes; p--) {
2105             swap_bals(p, p - 1);
2106         }
2107         for (; p < &bals[n_bals - 1] && p->tx_bytes < p[1].tx_bytes; p++) {
2108             swap_bals(p, p + 1);
2109         }
2110     }
2111 }
2112
2113 static void
2114 log_bals(const struct slave_balance *bals, size_t n_bals, struct port *port)
2115 {
2116     if (VLOG_IS_DBG_ENABLED()) {
2117         struct ds ds = DS_EMPTY_INITIALIZER;
2118         const struct slave_balance *b;
2119
2120         for (b = bals; b < bals + n_bals; b++) {
2121             size_t i;
2122
2123             if (b > bals) {
2124                 ds_put_char(&ds, ',');
2125             }
2126             ds_put_format(&ds, " %s %"PRIu64"kB",
2127                           b->iface->name, b->tx_bytes / 1024);
2128
2129             if (!b->iface->enabled) {
2130                 ds_put_cstr(&ds, " (disabled)");
2131             }
2132             if (b->n_hashes > 0) {
2133                 ds_put_cstr(&ds, " (");
2134                 for (i = 0; i < b->n_hashes; i++) {
2135                     const struct bond_entry *e = b->hashes[i];
2136                     if (i > 0) {
2137                         ds_put_cstr(&ds, " + ");
2138                     }
2139                     ds_put_format(&ds, "h%td: %"PRIu64"kB",
2140                                   e - port->bond_hash, e->tx_bytes / 1024);
2141                 }
2142                 ds_put_cstr(&ds, ")");
2143             }
2144         }
2145         VLOG_DBG("bond %s:%s", port->name, ds_cstr(&ds));
2146         ds_destroy(&ds);
2147     }
2148 }
2149
2150 /* Shifts 'hash' from 'from' to 'to' within 'port'. */
2151 static void
2152 bond_shift_load(struct slave_balance *from, struct slave_balance *to,
2153                 struct bond_entry *hash)
2154 {
2155     struct port *port = from->iface->port;
2156     uint64_t delta = hash->tx_bytes;
2157
2158     VLOG_INFO("bond %s: shift %"PRIu64"kB of load (with hash %td) "
2159               "from %s to %s (now carrying %"PRIu64"kB and "
2160               "%"PRIu64"kB load, respectively)",
2161               port->name, delta / 1024, hash - port->bond_hash,
2162               from->iface->name, to->iface->name,
2163               (from->tx_bytes - delta) / 1024,
2164               (to->tx_bytes + delta) / 1024);
2165
2166     /* Delete element from from->hashes.
2167      *
2168      * We don't bother to add the element to to->hashes because not only would
2169      * it require more work, the only purpose it would be to allow that hash to
2170      * be migrated to another slave in this rebalancing run, and there is no
2171      * point in doing that.  */
2172     if (from->hashes[0] == hash) {
2173         from->hashes++;
2174     } else {
2175         int i = hash - from->hashes[0];
2176         memmove(from->hashes + i, from->hashes + i + 1,
2177                 (from->n_hashes - (i + 1)) * sizeof *from->hashes);
2178     }
2179     from->n_hashes--;
2180
2181     /* Shift load away from 'from' to 'to'. */
2182     from->tx_bytes -= delta;
2183     to->tx_bytes += delta;
2184
2185     /* Arrange for flows to be revalidated. */
2186     ofproto_revalidate(port->bridge->ofproto, hash->iface_tag);
2187     hash->iface_idx = to->iface->port_ifidx;
2188     hash->iface_tag = tag_create_random();
2189 }
2190
2191 static void
2192 bond_rebalance_port(struct port *port)
2193 {
2194     struct slave_balance bals[DP_MAX_PORTS];
2195     size_t n_bals;
2196     struct bond_entry *hashes[BOND_MASK + 1];
2197     struct slave_balance *b, *from, *to;
2198     struct bond_entry *e;
2199     size_t i;
2200
2201     /* Sets up 'bals' to describe each of the port's interfaces, sorted in
2202      * descending order of tx_bytes, so that bals[0] represents the most
2203      * heavily loaded slave and bals[n_bals - 1] represents the least heavily
2204      * loaded slave.
2205      *
2206      * The code is a bit tricky: to avoid dynamically allocating a 'hashes'
2207      * array for each slave_balance structure, we sort our local array of
2208      * hashes in order by slave, so that all of the hashes for a given slave
2209      * become contiguous in memory, and then we point each 'hashes' members of
2210      * a slave_balance structure to the start of a contiguous group. */
2211     n_bals = port->n_ifaces;
2212     for (b = bals; b < &bals[n_bals]; b++) {
2213         b->iface = port->ifaces[b - bals];
2214         b->tx_bytes = 0;
2215         b->hashes = NULL;
2216         b->n_hashes = 0;
2217     }
2218     for (i = 0; i <= BOND_MASK; i++) {
2219         hashes[i] = &port->bond_hash[i];
2220     }
2221     qsort(hashes, BOND_MASK + 1, sizeof *hashes, compare_bond_entries);
2222     for (i = 0; i <= BOND_MASK; i++) {
2223         e = hashes[i];
2224         if (e->iface_idx >= 0 && e->iface_idx < port->n_ifaces) {
2225             b = &bals[e->iface_idx];
2226             b->tx_bytes += e->tx_bytes;
2227             if (!b->hashes) {
2228                 b->hashes = &hashes[i];
2229             }
2230             b->n_hashes++;
2231         }
2232     }
2233     qsort(bals, n_bals, sizeof *bals, compare_slave_balance);
2234     log_bals(bals, n_bals, port);
2235
2236     /* Discard slaves that aren't enabled (which were sorted to the back of the
2237      * array earlier). */
2238     while (!bals[n_bals - 1].iface->enabled) {
2239         n_bals--;
2240         if (!n_bals) {
2241             return;
2242         }
2243     }
2244
2245     /* Shift load from the most-loaded slaves to the least-loaded slaves. */
2246     to = &bals[n_bals - 1];
2247     for (from = bals; from < to; ) {
2248         uint64_t overload = from->tx_bytes - to->tx_bytes;
2249         if (overload < to->tx_bytes >> 5 || overload < 100000) {
2250             /* The extra load on 'from' (and all less-loaded slaves), compared
2251              * to that of 'to' (the least-loaded slave), is less than ~3%, or
2252              * it is less than ~1Mbps.  No point in rebalancing. */
2253             break;
2254         } else if (from->n_hashes == 1) {
2255             /* 'from' only carries a single MAC hash, so we can't shift any
2256              * load away from it, even though we want to. */
2257             from++;
2258         } else {
2259             /* 'from' is carrying significantly more load than 'to', and that
2260              * load is split across at least two different hashes.  Pick a hash
2261              * to migrate to 'to' (the least-loaded slave), given that doing so
2262              * must not cause 'to''s load to exceed 'from''s load.
2263              *
2264              * The sort order we use means that we prefer to shift away the
2265              * smallest hashes instead of the biggest ones.  There is little
2266              * reason behind this decision; we could use the opposite sort
2267              * order to shift away big hashes ahead of small ones. */
2268             size_t i;
2269
2270             for (i = 0; i < from->n_hashes; i++) {
2271                 uint64_t delta = from->hashes[i]->tx_bytes;
2272                 if (to->tx_bytes + delta < from->tx_bytes - delta) {
2273                     break;
2274                 }
2275             }
2276             if (i < from->n_hashes) {
2277                 bond_shift_load(from, to, from->hashes[i]);
2278
2279                 /* Re-sort 'bals'.  Note that this may make 'from' and 'to'
2280                  * point to different slave_balance structures.  It is only
2281                  * valid to do these two operations in a row at all because we
2282                  * know that 'from' will not move past 'to' and vice versa. */
2283                 resort_bals(from, bals, n_bals);
2284                 resort_bals(to, bals, n_bals);
2285             } else {
2286                 from++;
2287             }
2288         }
2289     }
2290
2291     /* Implement exponentially weighted moving average.  A weight of 1/2 causes
2292      * historical data to decay to <1% in 7 rebalancing runs.  */
2293     for (e = &port->bond_hash[0]; e <= &port->bond_hash[BOND_MASK]; e++) {
2294         e->tx_bytes /= 2;
2295     }
2296 }
2297
2298 static void
2299 bond_send_learning_packets(struct port *port)
2300 {
2301     struct bridge *br = port->bridge;
2302     struct mac_entry *e;
2303     struct ofpbuf packet;
2304     int error, n_packets, n_errors;
2305
2306     if (!port->n_ifaces || port->active_iface < 0 || !br->ml) {
2307         return;
2308     }
2309
2310     ofpbuf_init(&packet, 128);
2311     error = n_packets = n_errors = 0;
2312     LIST_FOR_EACH (e, struct mac_entry, lru_node, &br->ml->lrus) {
2313         static const char s[] = "Open vSwitch Bond Failover";
2314         union ofp_action actions[2], *a;
2315         struct eth_header *eth;
2316         struct llc_snap_header *llc_snap;
2317         uint16_t dp_ifidx;
2318         tag_type tags = 0;
2319         flow_t flow;
2320         int retval;
2321
2322         if (e->port == port->port_idx
2323             || !choose_output_iface(port, e->mac, &dp_ifidx, &tags)) {
2324             continue;
2325         }
2326
2327         /* Compose packet to send. */
2328         ofpbuf_clear(&packet);
2329         eth = ofpbuf_put_zeros(&packet, ETH_HEADER_LEN);
2330         llc_snap = ofpbuf_put_zeros(&packet, LLC_SNAP_HEADER_LEN);
2331         ofpbuf_put(&packet, s, sizeof s); /* Includes null byte. */
2332         ofpbuf_put(&packet, e->mac, ETH_ADDR_LEN);
2333
2334         memcpy(eth->eth_dst, eth_addr_broadcast, ETH_ADDR_LEN);
2335         memcpy(eth->eth_src, e->mac, ETH_ADDR_LEN);
2336         eth->eth_type = htons(packet.size - ETH_HEADER_LEN);
2337
2338         llc_snap->llc.llc_dsap = LLC_DSAP_SNAP;
2339         llc_snap->llc.llc_ssap = LLC_SSAP_SNAP;
2340         llc_snap->llc.llc_cntl = LLC_CNTL_SNAP;
2341         memcpy(llc_snap->snap.snap_org, "\x00\x23\x20", 3);
2342         llc_snap->snap.snap_type = htons(0xf177); /* Random number. */
2343
2344         /* Compose actions. */
2345         memset(actions, 0, sizeof actions);
2346         a = actions;
2347         if (e->vlan) {
2348             a->vlan_vid.type = htons(OFPAT_SET_VLAN_VID);
2349             a->vlan_vid.len = htons(sizeof *a);
2350             a->vlan_vid.vlan_vid = htons(e->vlan);
2351             a++;
2352         }
2353         a->output.type = htons(OFPAT_OUTPUT);
2354         a->output.len = htons(sizeof *a);
2355         a->output.port = htons(odp_port_to_ofp_port(dp_ifidx));
2356         a++;
2357
2358         /* Send packet. */
2359         n_packets++;
2360         flow_extract(&packet, ODPP_NONE, &flow);
2361         retval = ofproto_send_packet(br->ofproto, &flow, actions, a - actions,
2362                                      &packet);
2363         if (retval) {
2364             error = retval;
2365             n_errors++;
2366         }
2367     }
2368     ofpbuf_uninit(&packet);
2369
2370     if (n_errors) {
2371         static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
2372         VLOG_WARN_RL(&rl, "bond %s: %d errors sending %d gratuitous learning "
2373                      "packets, last error was: %s",
2374                      port->name, n_errors, n_packets, strerror(error));
2375     } else {
2376         VLOG_DBG("bond %s: sent %d gratuitous learning packets",
2377                  port->name, n_packets);
2378     }
2379 }
2380 \f
2381 /* Bonding unixctl user interface functions. */
2382
2383 static void
2384 bond_unixctl_list(struct unixctl_conn *conn, const char *args UNUSED)
2385 {
2386     struct ds ds = DS_EMPTY_INITIALIZER;
2387     const struct bridge *br;
2388
2389     ds_put_cstr(&ds, "bridge\tbond\tslaves\n");
2390
2391     LIST_FOR_EACH (br, struct bridge, node, &all_bridges) {
2392         size_t i;
2393
2394         for (i = 0; i < br->n_ports; i++) {
2395             const struct port *port = br->ports[i];
2396             if (port->n_ifaces > 1) {
2397                 size_t j;
2398
2399                 ds_put_format(&ds, "%s\t%s\t", br->name, port->name);
2400                 for (j = 0; j < port->n_ifaces; j++) {
2401                     const struct iface *iface = port->ifaces[j];
2402                     if (j) {
2403                         ds_put_cstr(&ds, ", ");
2404                     }
2405                     ds_put_cstr(&ds, iface->name);
2406                 }
2407                 ds_put_char(&ds, '\n');
2408             }
2409         }
2410     }
2411     unixctl_command_reply(conn, 200, ds_cstr(&ds));
2412     ds_destroy(&ds);
2413 }
2414
2415 static struct port *
2416 bond_find(const char *name)
2417 {
2418     const struct bridge *br;
2419
2420     LIST_FOR_EACH (br, struct bridge, node, &all_bridges) {
2421         size_t i;
2422
2423         for (i = 0; i < br->n_ports; i++) {
2424             struct port *port = br->ports[i];
2425             if (!strcmp(port->name, name) && port->n_ifaces > 1) {
2426                 return port;
2427             }
2428         }
2429     }
2430     return NULL;
2431 }
2432
2433 static void
2434 bond_unixctl_show(struct unixctl_conn *conn, const char *args)
2435 {
2436     struct ds ds = DS_EMPTY_INITIALIZER;
2437     const struct port *port;
2438     size_t j;
2439
2440     port = bond_find(args);
2441     if (!port) {
2442         unixctl_command_reply(conn, 501, "no such bond");
2443         return;
2444     }
2445
2446     ds_put_format(&ds, "updelay: %d ms\n", port->updelay);
2447     ds_put_format(&ds, "downdelay: %d ms\n", port->downdelay);
2448     ds_put_format(&ds, "next rebalance: %lld ms\n",
2449                   port->bridge->bond_next_rebalance - time_msec());
2450     for (j = 0; j < port->n_ifaces; j++) {
2451         const struct iface *iface = port->ifaces[j];
2452         struct bond_entry *be;
2453
2454         /* Basic info. */
2455         ds_put_format(&ds, "slave %s: %s\n",
2456                       iface->name, iface->enabled ? "enabled" : "disabled");
2457         if (j == port->active_iface) {
2458             ds_put_cstr(&ds, "\tactive slave\n");
2459         }
2460         if (iface->delay_expires != LLONG_MAX) {
2461             ds_put_format(&ds, "\t%s expires in %lld ms\n",
2462                           iface->enabled ? "downdelay" : "updelay",
2463                           iface->delay_expires - time_msec());
2464         }
2465
2466         /* Hashes. */
2467         for (be = port->bond_hash; be <= &port->bond_hash[BOND_MASK]; be++) {
2468             int hash = be - port->bond_hash;
2469             struct mac_entry *me;
2470
2471             if (be->iface_idx != j) {
2472                 continue;
2473             }
2474
2475             ds_put_format(&ds, "\thash %d: %lld kB load\n",
2476                           hash, be->tx_bytes / 1024);
2477
2478             /* MACs. */
2479             if (!port->bridge->ml) {
2480                 break;
2481             }
2482
2483             LIST_FOR_EACH (me, struct mac_entry, lru_node,
2484                            &port->bridge->ml->lrus) {
2485                 uint16_t dp_ifidx;
2486                 tag_type tags = 0;
2487                 if (bond_hash(me->mac) == hash
2488                     && me->port != port->port_idx
2489                     && choose_output_iface(port, me->mac, &dp_ifidx, &tags)
2490                     && dp_ifidx == iface->dp_ifidx)
2491                 {
2492                     ds_put_format(&ds, "\t\t"ETH_ADDR_FMT"\n",
2493                                   ETH_ADDR_ARGS(me->mac));
2494                 }
2495             }
2496         }
2497     }
2498     unixctl_command_reply(conn, 200, ds_cstr(&ds));
2499     ds_destroy(&ds);
2500 }
2501
2502 static void
2503 bond_unixctl_migrate(struct unixctl_conn *conn, const char *args_)
2504 {
2505     char *args = (char *) args_;
2506     char *save_ptr = NULL;
2507     char *bond_s, *hash_s, *slave_s;
2508     uint8_t mac[ETH_ADDR_LEN];
2509     struct port *port;
2510     struct iface *iface;
2511     struct bond_entry *entry;
2512     int hash;
2513
2514     bond_s = strtok_r(args, " ", &save_ptr);
2515     hash_s = strtok_r(NULL, " ", &save_ptr);
2516     slave_s = strtok_r(NULL, " ", &save_ptr);
2517     if (!slave_s) {
2518         unixctl_command_reply(conn, 501,
2519                               "usage: bond/migrate BOND HASH SLAVE");
2520         return;
2521     }
2522
2523     port = bond_find(bond_s);
2524     if (!port) {
2525         unixctl_command_reply(conn, 501, "no such bond");
2526         return;
2527     }
2528
2529     if (sscanf(hash_s, ETH_ADDR_SCAN_FMT, ETH_ADDR_SCAN_ARGS(mac))
2530         == ETH_ADDR_SCAN_COUNT) {
2531         hash = bond_hash(mac);
2532     } else if (strspn(hash_s, "0123456789") == strlen(hash_s)) {
2533         hash = atoi(hash_s) & BOND_MASK;
2534     } else {
2535         unixctl_command_reply(conn, 501, "bad hash");
2536         return;
2537     }
2538
2539     iface = port_lookup_iface(port, slave_s);
2540     if (!iface) {
2541         unixctl_command_reply(conn, 501, "no such slave");
2542         return;
2543     }
2544
2545     if (!iface->enabled) {
2546         unixctl_command_reply(conn, 501, "cannot migrate to disabled slave");
2547         return;
2548     }
2549
2550     entry = &port->bond_hash[hash];
2551     ofproto_revalidate(port->bridge->ofproto, entry->iface_tag);
2552     entry->iface_idx = iface->port_ifidx;
2553     entry->iface_tag = tag_create_random();
2554     unixctl_command_reply(conn, 200, "migrated");
2555 }
2556
2557 static void
2558 bond_unixctl_set_active_slave(struct unixctl_conn *conn, const char *args_)
2559 {
2560     char *args = (char *) args_;
2561     char *save_ptr = NULL;
2562     char *bond_s, *slave_s;
2563     struct port *port;
2564     struct iface *iface;
2565
2566     bond_s = strtok_r(args, " ", &save_ptr);
2567     slave_s = strtok_r(NULL, " ", &save_ptr);
2568     if (!slave_s) {
2569         unixctl_command_reply(conn, 501,
2570                               "usage: bond/set-active-slave BOND SLAVE");
2571         return;
2572     }
2573
2574     port = bond_find(bond_s);
2575     if (!port) {
2576         unixctl_command_reply(conn, 501, "no such bond");
2577         return;
2578     }
2579
2580     iface = port_lookup_iface(port, slave_s);
2581     if (!iface) {
2582         unixctl_command_reply(conn, 501, "no such slave");
2583         return;
2584     }
2585
2586     if (!iface->enabled) {
2587         unixctl_command_reply(conn, 501, "cannot make disabled slave active");
2588         return;
2589     }
2590
2591     if (port->active_iface != iface->port_ifidx) {
2592         ofproto_revalidate(port->bridge->ofproto, port->active_iface_tag);
2593         port->active_iface = iface->port_ifidx;
2594         port->active_iface_tag = tag_create_random();
2595         VLOG_INFO("port %s: active interface is now %s",
2596                   port->name, iface->name);
2597         bond_send_learning_packets(port);
2598         unixctl_command_reply(conn, 200, "done");
2599     } else {
2600         unixctl_command_reply(conn, 200, "no change");
2601     }
2602 }
2603
2604 static void
2605 enable_slave(struct unixctl_conn *conn, const char *args_, bool enable)
2606 {
2607     char *args = (char *) args_;
2608     char *save_ptr = NULL;
2609     char *bond_s, *slave_s;
2610     struct port *port;
2611     struct iface *iface;
2612
2613     bond_s = strtok_r(args, " ", &save_ptr);
2614     slave_s = strtok_r(NULL, " ", &save_ptr);
2615     if (!slave_s) {
2616         unixctl_command_reply(conn, 501,
2617                               "usage: bond/enable/disable-slave BOND SLAVE");
2618         return;
2619     }
2620
2621     port = bond_find(bond_s);
2622     if (!port) {
2623         unixctl_command_reply(conn, 501, "no such bond");
2624         return;
2625     }
2626
2627     iface = port_lookup_iface(port, slave_s);
2628     if (!iface) {
2629         unixctl_command_reply(conn, 501, "no such slave");
2630         return;
2631     }
2632
2633     bond_enable_slave(iface, enable);
2634     unixctl_command_reply(conn, 501, enable ? "enabled" : "disabled");
2635 }
2636
2637 static void
2638 bond_unixctl_enable_slave(struct unixctl_conn *conn, const char *args)
2639 {
2640     enable_slave(conn, args, true);
2641 }
2642
2643 static void
2644 bond_unixctl_disable_slave(struct unixctl_conn *conn, const char *args)
2645 {
2646     enable_slave(conn, args, false);
2647 }
2648
2649 static void
2650 bond_init(void)
2651 {
2652     unixctl_command_register("bond/list", bond_unixctl_list);
2653     unixctl_command_register("bond/show", bond_unixctl_show);
2654     unixctl_command_register("bond/migrate", bond_unixctl_migrate);
2655     unixctl_command_register("bond/set-active-slave",
2656                              bond_unixctl_set_active_slave);
2657     unixctl_command_register("bond/enable-slave", bond_unixctl_enable_slave);
2658     unixctl_command_register("bond/disable-slave", bond_unixctl_disable_slave);
2659 }
2660 \f
2661 /* Port functions. */
2662
2663 static void
2664 port_create(struct bridge *br, const char *name)
2665 {
2666     struct port *port;
2667
2668     port = xcalloc(1, sizeof *port);
2669     port->bridge = br;
2670     port->port_idx = br->n_ports;
2671     port->vlan = -1;
2672     port->trunks = NULL;
2673     port->name = xstrdup(name);
2674     port->active_iface = -1;
2675     port->stp_state = STP_DISABLED;
2676     port->stp_state_tag = 0;
2677
2678     if (br->n_ports >= br->allocated_ports) {
2679         br->ports = x2nrealloc(br->ports, &br->allocated_ports,
2680                                sizeof *br->ports);
2681     }
2682     br->ports[br->n_ports++] = port;
2683
2684     VLOG_INFO("created port %s on bridge %s", port->name, br->name);
2685     bridge_flush(br);
2686 }
2687
2688 static void
2689 port_reconfigure(struct port *port)
2690 {
2691     bool bonded = cfg_has_section("bonding.%s", port->name);
2692     struct svec old_ifaces, new_ifaces;
2693     unsigned long *trunks;
2694     int vlan;
2695     size_t i;
2696
2697     /* Collect old and new interfaces. */
2698     svec_init(&old_ifaces);
2699     svec_init(&new_ifaces);
2700     for (i = 0; i < port->n_ifaces; i++) {
2701         svec_add(&old_ifaces, port->ifaces[i]->name);
2702     }
2703     svec_sort(&old_ifaces);
2704     if (bonded) {
2705         cfg_get_all_keys(&new_ifaces, "bonding.%s.slave", port->name);
2706         if (!new_ifaces.n) {
2707             VLOG_ERR("port %s: no interfaces specified for bonded port",
2708                      port->name);
2709         } else if (new_ifaces.n == 1) {
2710             VLOG_WARN("port %s: only 1 interface specified for bonded port",
2711                       port->name);
2712         }
2713
2714         port->updelay = cfg_get_int(0, "bonding.%s.updelay", port->name);
2715         if (port->updelay < 0) {
2716             port->updelay = 0;
2717         }
2718         port->downdelay = cfg_get_int(0, "bonding.%s.downdelay", port->name);
2719         if (port->downdelay < 0) {
2720             port->downdelay = 0;
2721         }
2722     } else {
2723         svec_init(&new_ifaces);
2724         svec_add(&new_ifaces, port->name);
2725     }
2726
2727     /* Get rid of deleted interfaces and add new interfaces. */
2728     for (i = 0; i < port->n_ifaces; i++) {
2729         struct iface *iface = port->ifaces[i];
2730         if (!svec_contains(&new_ifaces, iface->name)) {
2731             iface_destroy(iface);
2732         } else {
2733             i++;
2734         }
2735     }
2736     for (i = 0; i < new_ifaces.n; i++) {
2737         const char *name = new_ifaces.names[i];
2738         if (!svec_contains(&old_ifaces, name)) {
2739             iface_create(port, name);
2740         }
2741     }
2742
2743     /* Get VLAN tag. */
2744     vlan = -1;
2745     if (cfg_has("vlan.%s.tag", port->name)) {
2746         if (!bonded) {
2747             vlan = cfg_get_vlan(0, "vlan.%s.tag", port->name);
2748             if (vlan >= 0 && vlan <= 4095) {
2749                 VLOG_DBG("port %s: assigning VLAN tag %d", port->name, vlan);
2750             }
2751         } else {
2752             /* It's possible that bonded, VLAN-tagged ports make sense.  Maybe
2753              * they even work as-is.  But they have not been tested. */
2754             VLOG_WARN("port %s: VLAN tags not supported on bonded ports",
2755                       port->name);
2756         }
2757     }
2758     if (port->vlan != vlan) {
2759         port->vlan = vlan;
2760         bridge_flush(port->bridge);
2761     }
2762
2763     /* Get trunked VLANs. */
2764     trunks = NULL;
2765     if (vlan < 0) {
2766         size_t n_trunks, n_errors;
2767         size_t i;
2768
2769         trunks = bitmap_allocate(4096);
2770         n_trunks = cfg_count("vlan.%s.trunks", port->name);
2771         n_errors = 0;
2772         for (i = 0; i < n_trunks; i++) {
2773             int trunk = cfg_get_vlan(i, "vlan.%s.trunks", port->name);
2774             if (trunk >= 0) {
2775                 bitmap_set1(trunks, trunk);
2776             } else {
2777                 n_errors++;
2778             }
2779         }
2780         if (n_errors) {
2781             VLOG_ERR("port %s: invalid values for %zu trunk VLANs",
2782                      port->name, n_trunks);
2783         }
2784         if (n_errors == n_trunks) {
2785             if (n_errors) {
2786                 VLOG_ERR("port %s: no valid trunks, trunking all VLANs",
2787                          port->name);
2788             }
2789             bitmap_set_multiple(trunks, 0, 4096, 1);
2790         }
2791     } else {
2792         if (cfg_has("vlan.%s.trunks", port->name)) {
2793             VLOG_ERR("ignoring vlan.%s.trunks in favor of vlan.%s.vlan",
2794                      port->name, port->name);
2795         }
2796     }
2797     if (trunks == NULL
2798         ? port->trunks != NULL
2799         : port->trunks == NULL || !bitmap_equal(trunks, port->trunks, 4096)) {
2800         bridge_flush(port->bridge);
2801     }
2802     bitmap_free(port->trunks);
2803     port->trunks = trunks;
2804
2805     svec_destroy(&old_ifaces);
2806     svec_destroy(&new_ifaces);
2807 }
2808
2809 static void
2810 port_destroy(struct port *port)
2811 {
2812     if (port) {
2813         struct bridge *br = port->bridge;
2814         struct port *del;
2815         size_t i;
2816
2817         proc_net_compat_update_vlan(port->name, NULL, 0);
2818
2819         for (i = 0; i < MAX_MIRRORS; i++) {
2820             struct mirror *m = br->mirrors[i];
2821             if (m && m->out_port == port) {
2822                 mirror_destroy(m);
2823             }
2824         }
2825
2826         while (port->n_ifaces > 0) {
2827             iface_destroy(port->ifaces[port->n_ifaces - 1]);
2828         }
2829
2830         del = br->ports[port->port_idx] = br->ports[--br->n_ports];
2831         del->port_idx = port->port_idx;
2832
2833         free(port->ifaces);
2834         bitmap_free(port->trunks);
2835         free(port->name);
2836         free(port);
2837         bridge_flush(br);
2838     }
2839 }
2840
2841 static struct port *
2842 port_from_dp_ifidx(const struct bridge *br, uint16_t dp_ifidx)
2843 {
2844     struct iface *iface = iface_from_dp_ifidx(br, dp_ifidx);
2845     return iface ? iface->port : NULL;
2846 }
2847
2848 static struct port *
2849 port_lookup(const struct bridge *br, const char *name)
2850 {
2851     size_t i;
2852
2853     for (i = 0; i < br->n_ports; i++) {
2854         struct port *port = br->ports[i];
2855         if (!strcmp(port->name, name)) {
2856             return port;
2857         }
2858     }
2859     return NULL;
2860 }
2861
2862 static struct iface *
2863 port_lookup_iface(const struct port *port, const char *name)
2864 {
2865     size_t j;
2866
2867     for (j = 0; j < port->n_ifaces; j++) {
2868         struct iface *iface = port->ifaces[j];
2869         if (!strcmp(iface->name, name)) {
2870             return iface;
2871         }
2872     }
2873     return NULL;
2874 }
2875
2876 static void
2877 port_update_bonding(struct port *port)
2878 {
2879     if (port->n_ifaces < 2) {
2880         /* Not a bonded port. */
2881         if (port->bond_hash) {
2882             free(port->bond_hash);
2883             port->bond_hash = NULL;
2884             proc_net_compat_update_bond(port->name, NULL);
2885         }
2886     } else {
2887         if (!port->bond_hash) {
2888             size_t i;
2889
2890             port->bond_hash = xcalloc(BOND_MASK + 1, sizeof *port->bond_hash);
2891             for (i = 0; i <= BOND_MASK; i++) {
2892                 struct bond_entry *e = &port->bond_hash[i];
2893                 e->iface_idx = -1;
2894                 e->tx_bytes = 0;
2895             }
2896             port->no_ifaces_tag = tag_create_random();
2897             bond_choose_active_iface(port);
2898         }
2899         port_update_bond_compat(port);
2900     }
2901 }
2902
2903 static void
2904 port_update_bond_compat(struct port *port)
2905 {
2906     struct compat_bond_hash compat_hashes[BOND_MASK + 1];
2907     struct compat_bond bond;
2908     size_t i;
2909
2910     if (port->n_ifaces < 2) {
2911         return;
2912     }
2913
2914     bond.up = false;
2915     bond.updelay = port->updelay;
2916     bond.downdelay = port->downdelay;
2917
2918     bond.n_hashes = 0;
2919     bond.hashes = compat_hashes;
2920     if (port->bond_hash) {
2921         const struct bond_entry *e;
2922         for (e = port->bond_hash; e <= &port->bond_hash[BOND_MASK]; e++) {
2923             if (e->iface_idx >= 0 && e->iface_idx < port->n_ifaces) {
2924                 struct compat_bond_hash *cbh = &bond.hashes[bond.n_hashes++];
2925                 cbh->hash = e - port->bond_hash;
2926                 cbh->netdev_name = port->ifaces[e->iface_idx]->name;
2927             }
2928         }
2929     }
2930
2931     bond.n_slaves = port->n_ifaces;
2932     bond.slaves = xmalloc(port->n_ifaces * sizeof *bond.slaves);
2933     for (i = 0; i < port->n_ifaces; i++) {
2934         struct iface *iface = port->ifaces[i];
2935         struct compat_bond_slave *slave = &bond.slaves[i];
2936         slave->name = iface->name;
2937         slave->up = ((iface->enabled && iface->delay_expires == LLONG_MAX) ||
2938                      (!iface->enabled && iface->delay_expires != LLONG_MAX));
2939         if (slave->up) {
2940             bond.up = true;
2941         }
2942         memcpy(slave->mac, iface->mac, ETH_ADDR_LEN);
2943     }
2944
2945     proc_net_compat_update_bond(port->name, &bond);
2946     free(bond.slaves);
2947 }
2948
2949 static void
2950 port_update_vlan_compat(struct port *port)
2951 {
2952     struct bridge *br = port->bridge;
2953     char *vlandev_name = NULL;
2954
2955     if (port->vlan > 0) {
2956         /* Figure out the name that the VLAN device should actually have, if it
2957          * existed.  This takes some work because the VLAN device would not
2958          * have port->name in its name; rather, it would have the trunk port's
2959          * name, and 'port' would be attached to a bridge that also had the
2960          * VLAN device one of its ports.  So we need to find a trunk port that
2961          * includes port->vlan.
2962          *
2963          * There might be more than one candidate.  This doesn't happen on
2964          * XenServer, so if it happens we just pick the first choice in
2965          * alphabetical order instead of creating multiple VLAN devices. */
2966         size_t i;
2967         for (i = 0; i < br->n_ports; i++) {
2968             struct port *p = br->ports[i];
2969             if (port_trunks_vlan(p, port->vlan)
2970                 && p->n_ifaces
2971                 && (!vlandev_name || strcmp(p->name, vlandev_name) <= 0))
2972             {
2973                 const uint8_t *ea = p->ifaces[0]->mac;
2974                 if (!eth_addr_is_multicast(ea) &&
2975                     !eth_addr_is_reserved(ea) &&
2976                     !eth_addr_is_zero(ea)) {
2977                     vlandev_name = p->name;
2978                 }
2979             }
2980         }
2981     }
2982     proc_net_compat_update_vlan(port->name, vlandev_name, port->vlan);
2983 }
2984 \f
2985 /* Interface functions. */
2986
2987 static void
2988 iface_create(struct port *port, const char *name)
2989 {
2990     struct iface *iface;
2991
2992     iface = xcalloc(1, sizeof *iface);
2993     iface->port = port;
2994     iface->port_ifidx = port->n_ifaces;
2995     iface->name = xstrdup(name);
2996     iface->dp_ifidx = -1;
2997     iface->tag = tag_create_random();
2998     iface->delay_expires = LLONG_MAX;
2999
3000     netdev_nodev_get_etheraddr(name, iface->mac);
3001     netdev_nodev_get_carrier(name, &iface->enabled);
3002
3003     if (port->n_ifaces >= port->allocated_ifaces) {
3004         port->ifaces = x2nrealloc(port->ifaces, &port->allocated_ifaces,
3005                                   sizeof *port->ifaces);
3006     }
3007     port->ifaces[port->n_ifaces++] = iface;
3008     if (port->n_ifaces > 1) {
3009         port->bridge->has_bonded_ports = true;
3010     }
3011
3012     VLOG_DBG("attached network device %s to port %s", iface->name, port->name);
3013
3014     port_update_bonding(port);
3015     bridge_flush(port->bridge);
3016 }
3017
3018 static void
3019 iface_destroy(struct iface *iface)
3020 {
3021     if (iface) {
3022         struct port *port = iface->port;
3023         struct bridge *br = port->bridge;
3024         bool del_active = port->active_iface == iface->port_ifidx;
3025         struct iface *del;
3026
3027         if (iface->dp_ifidx >= 0) {
3028             port_array_set(&br->ifaces, iface->dp_ifidx, NULL);
3029         }
3030
3031         del = port->ifaces[iface->port_ifidx] = port->ifaces[--port->n_ifaces];
3032         del->port_ifidx = iface->port_ifidx;
3033
3034         free(iface->name);
3035         free(iface);
3036
3037         if (del_active) {
3038             ofproto_revalidate(port->bridge->ofproto, port->active_iface_tag);
3039             bond_choose_active_iface(port);
3040             bond_send_learning_packets(port);
3041         }
3042
3043         port_update_bonding(port);
3044         bridge_flush(port->bridge);
3045     }
3046 }
3047
3048 static struct iface *
3049 iface_lookup(const struct bridge *br, const char *name)
3050 {
3051     size_t i, j;
3052
3053     for (i = 0; i < br->n_ports; i++) {
3054         struct port *port = br->ports[i];
3055         for (j = 0; j < port->n_ifaces; j++) {
3056             struct iface *iface = port->ifaces[j];
3057             if (!strcmp(iface->name, name)) {
3058                 return iface;
3059             }
3060         }
3061     }
3062     return NULL;
3063 }
3064
3065 static struct iface *
3066 iface_from_dp_ifidx(const struct bridge *br, uint16_t dp_ifidx)
3067 {
3068     return port_array_get(&br->ifaces, dp_ifidx);
3069 }
3070 \f
3071 /* Port mirroring. */
3072
3073 static void
3074 mirror_reconfigure(struct bridge *br)
3075 {
3076     struct svec old_mirrors, new_mirrors;
3077     size_t i;
3078
3079     /* Collect old and new mirrors. */
3080     svec_init(&old_mirrors);
3081     svec_init(&new_mirrors);
3082     cfg_get_subsections(&new_mirrors, "mirror.%s", br->name);
3083     for (i = 0; i < MAX_MIRRORS; i++) {
3084         if (br->mirrors[i]) {
3085             svec_add(&old_mirrors, br->mirrors[i]->name);
3086         }
3087     }
3088
3089     /* Get rid of deleted mirrors and add new mirrors. */
3090     svec_sort(&old_mirrors);
3091     assert(svec_is_unique(&old_mirrors));
3092     svec_sort(&new_mirrors);
3093     assert(svec_is_unique(&new_mirrors));
3094     for (i = 0; i < MAX_MIRRORS; i++) {
3095         struct mirror *m = br->mirrors[i];
3096         if (m && !svec_contains(&new_mirrors, m->name)) {
3097             mirror_destroy(m);
3098         }
3099     }
3100     for (i = 0; i < new_mirrors.n; i++) {
3101         const char *name = new_mirrors.names[i];
3102         if (!svec_contains(&old_mirrors, name)) {
3103             mirror_create(br, name);
3104         }
3105     }
3106     svec_destroy(&old_mirrors);
3107     svec_destroy(&new_mirrors);
3108
3109     /* Reconfigure all mirrors. */
3110     for (i = 0; i < MAX_MIRRORS; i++) {
3111         if (br->mirrors[i]) {
3112             mirror_reconfigure_one(br->mirrors[i]);
3113         }
3114     }
3115
3116     /* Update port reserved status. */
3117     for (i = 0; i < br->n_ports; i++) {
3118         br->ports[i]->is_mirror_output_port = false;
3119     }
3120     for (i = 0; i < MAX_MIRRORS; i++) {
3121         struct mirror *m = br->mirrors[i];
3122         if (m && m->out_port) {
3123             m->out_port->is_mirror_output_port = true;
3124         }
3125     }
3126 }
3127
3128 static void
3129 mirror_create(struct bridge *br, const char *name)
3130 {
3131     struct mirror *m;
3132     size_t i;
3133
3134     for (i = 0; ; i++) {
3135         if (i >= MAX_MIRRORS) {
3136             VLOG_WARN("bridge %s: maximum of %d port mirrors reached, "
3137                       "cannot create %s", br->name, MAX_MIRRORS, name);
3138             return;
3139         }
3140         if (!br->mirrors[i]) {
3141             break;
3142         }
3143     }
3144
3145     VLOG_INFO("created port mirror %s on bridge %s", name, br->name);
3146     bridge_flush(br);
3147
3148     br->mirrors[i] = m = xcalloc(1, sizeof *m);
3149     m->bridge = br;
3150     m->idx = i;
3151     m->name = xstrdup(name);
3152     svec_init(&m->src_ports);
3153     svec_init(&m->dst_ports);
3154     m->vlans = NULL;
3155     m->n_vlans = 0;
3156     m->out_vlan = -1;
3157     m->out_port = NULL;
3158 }
3159
3160 static void
3161 mirror_destroy(struct mirror *m)
3162 {
3163     if (m) {
3164         struct bridge *br = m->bridge;
3165         size_t i;
3166
3167         for (i = 0; i < br->n_ports; i++) {
3168             br->ports[i]->src_mirrors &= ~(MIRROR_MASK_C(1) << m->idx);
3169             br->ports[i]->dst_mirrors &= ~(MIRROR_MASK_C(1) << m->idx);
3170         }
3171
3172         svec_destroy(&m->src_ports);
3173         svec_destroy(&m->dst_ports);
3174         free(m->vlans);
3175
3176         m->bridge->mirrors[m->idx] = NULL;
3177         free(m);
3178
3179         bridge_flush(br);
3180     }
3181 }
3182
3183 static void
3184 prune_ports(struct mirror *m, struct svec *ports)
3185 {
3186     struct svec tmp;
3187     size_t i;
3188
3189     svec_sort_unique(ports);
3190
3191     svec_init(&tmp);
3192     for (i = 0; i < ports->n; i++) {
3193         const char *name = ports->names[i];
3194         if (port_lookup(m->bridge, name)) {
3195             svec_add(&tmp, name);
3196         } else {
3197             VLOG_WARN("mirror.%s.%s: cannot match on nonexistent port %s",
3198                       m->bridge->name, m->name, name);
3199         }
3200     }
3201     svec_swap(ports, &tmp);
3202     svec_destroy(&tmp);
3203 }
3204
3205 static size_t
3206 prune_vlans(struct mirror *m, struct svec *vlan_strings, int **vlans)
3207 {
3208     size_t n_vlans, i;
3209
3210     /* This isn't perfect: it won't combine "0" and "00", and the textual sort
3211      * order won't give us numeric sort order.  But that's good enough for what
3212      * we need right now. */
3213     svec_sort_unique(vlan_strings);
3214
3215     *vlans = xmalloc(sizeof *vlans * vlan_strings->n);
3216     n_vlans = 0;
3217     for (i = 0; i < vlan_strings->n; i++) {
3218         const char *name = vlan_strings->names[i];
3219         int vlan;
3220         if (!str_to_int(name, 10, &vlan) || vlan < 0 || vlan > 4095) {
3221             VLOG_WARN("mirror.%s.%s.select.vlan: ignoring invalid VLAN %s",
3222                       m->bridge->name, m->name, name);
3223         } else {
3224             (*vlans)[n_vlans++] = vlan;
3225         }
3226     }
3227     return n_vlans;
3228 }
3229
3230 static bool
3231 vlan_is_mirrored(const struct mirror *m, int vlan)
3232 {
3233     size_t i;
3234
3235     for (i = 0; i < m->n_vlans; i++) {
3236         if (m->vlans[i] == vlan) {
3237             return true;
3238         }
3239     }
3240     return false;
3241 }
3242
3243 static bool
3244 port_trunks_any_mirrored_vlan(const struct mirror *m, const struct port *p)
3245 {
3246     size_t i;
3247
3248     for (i = 0; i < m->n_vlans; i++) {
3249         if (port_trunks_vlan(p, m->vlans[i])) {
3250             return true;
3251         }
3252     }
3253     return false;
3254 }
3255
3256 static void
3257 mirror_reconfigure_one(struct mirror *m)
3258 {
3259     char *pfx = xasprintf("mirror.%s.%s", m->bridge->name, m->name);
3260     struct svec src_ports, dst_ports, ports;
3261     struct svec vlan_strings;
3262     mirror_mask_t mirror_bit;
3263     const char *out_port_name;
3264     struct port *out_port;
3265     int out_vlan;
3266     size_t n_vlans;
3267     int *vlans;
3268     size_t i;
3269     bool mirror_all_ports;
3270
3271     /* Get output port. */
3272     out_port_name = cfg_get_key(0, "mirror.%s.%s.output.port",
3273                                 m->bridge->name, m->name);
3274     if (out_port_name) {
3275         out_port = port_lookup(m->bridge, out_port_name);
3276         if (!out_port) {
3277             VLOG_ERR("%s.output.port: bridge %s does not have a port "
3278                       "named %s", pfx, m->bridge->name, out_port_name);
3279             mirror_destroy(m);
3280             free(pfx);
3281             return;
3282         }
3283         out_vlan = -1;
3284
3285         if (cfg_has("%s.output.vlan", pfx)) {
3286             VLOG_ERR("%s.output.port and %s.output.vlan both specified; "
3287                      "ignoring %s.output.vlan", pfx, pfx, pfx);
3288         }
3289     } else if (cfg_has("%s.output.vlan", pfx)) {
3290         out_port = NULL;
3291         out_vlan = cfg_get_vlan(0, "%s.output.vlan", pfx);
3292     } else {
3293         VLOG_ERR("%s: neither %s.output.port nor %s.output.vlan specified, "
3294                  "but exactly one is required; disabling port mirror %s",
3295                  pfx, pfx, pfx, pfx);
3296         mirror_destroy(m);
3297         free(pfx);
3298         return;
3299     }
3300
3301     /* Get all the ports, and drop duplicates and ports that don't exist. */
3302     svec_init(&src_ports);
3303     svec_init(&dst_ports);
3304     svec_init(&ports);
3305     cfg_get_all_keys(&src_ports, "%s.select.src-port", pfx);
3306     cfg_get_all_keys(&dst_ports, "%s.select.dst-port", pfx);
3307     cfg_get_all_keys(&ports, "%s.select.port", pfx);
3308     svec_append(&src_ports, &ports);
3309     svec_append(&dst_ports, &ports);
3310     svec_destroy(&ports);
3311     prune_ports(m, &src_ports);
3312     prune_ports(m, &dst_ports);
3313
3314     /* Get all the vlans, and drop duplicate and invalid vlans. */
3315     svec_init(&vlan_strings);
3316     cfg_get_all_keys(&vlan_strings, "%s.select.vlan", pfx);
3317     n_vlans = prune_vlans(m, &vlan_strings, &vlans);
3318     svec_destroy(&vlan_strings);
3319
3320     /* Update mirror data. */
3321     if (!svec_equal(&m->src_ports, &src_ports)
3322         || !svec_equal(&m->dst_ports, &dst_ports)
3323         || m->n_vlans != n_vlans
3324         || memcmp(m->vlans, vlans, sizeof *vlans * n_vlans)
3325         || m->out_port != out_port
3326         || m->out_vlan != out_vlan) {
3327         bridge_flush(m->bridge);
3328     }
3329     svec_swap(&m->src_ports, &src_ports);
3330     svec_swap(&m->dst_ports, &dst_ports);
3331     free(m->vlans);
3332     m->vlans = vlans;
3333     m->n_vlans = n_vlans;
3334     m->out_port = out_port;
3335     m->out_vlan = out_vlan;
3336
3337     /* If no selection criteria have been given, mirror for all ports. */
3338     mirror_all_ports = (!m->src_ports.n) && (!m->dst_ports.n) && (!m->n_vlans);
3339
3340     /* Update ports. */
3341     mirror_bit = MIRROR_MASK_C(1) << m->idx;
3342     for (i = 0; i < m->bridge->n_ports; i++) {
3343         struct port *port = m->bridge->ports[i];
3344
3345         if (mirror_all_ports
3346             || svec_contains(&m->src_ports, port->name)
3347             || (m->n_vlans
3348                 && (!port->vlan
3349                     ? port_trunks_any_mirrored_vlan(m, port)
3350                     : vlan_is_mirrored(m, port->vlan)))) {
3351             port->src_mirrors |= mirror_bit;
3352         } else {
3353             port->src_mirrors &= ~mirror_bit;
3354         }
3355
3356         if (mirror_all_ports || svec_contains(&m->dst_ports, port->name)) {
3357             port->dst_mirrors |= mirror_bit;
3358         } else {
3359             port->dst_mirrors &= ~mirror_bit;
3360         }
3361     }
3362
3363     /* Clean up. */
3364     svec_destroy(&src_ports);
3365     svec_destroy(&dst_ports);
3366     free(pfx);
3367 }
3368 \f
3369 /* Spanning tree protocol. */
3370
3371 static void brstp_update_port_state(struct port *);
3372
3373 static void
3374 brstp_send_bpdu(struct ofpbuf *pkt, int port_no, void *br_)
3375 {
3376     struct bridge *br = br_;
3377     static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
3378     struct iface *iface = iface_from_dp_ifidx(br, port_no);
3379     if (!iface) {
3380         VLOG_WARN_RL(&rl, "%s: cannot send BPDU on unknown port %d",
3381                      br->name, port_no);
3382     } else if (eth_addr_is_zero(iface->mac)) {
3383         VLOG_WARN_RL(&rl, "%s: cannot send BPDU on port %d with unknown MAC",
3384                      br->name, port_no);
3385     } else {
3386         union ofp_action action;
3387         struct eth_header *eth = pkt->l2;
3388         flow_t flow;
3389
3390         memcpy(eth->eth_src, iface->mac, ETH_ADDR_LEN);
3391
3392         memset(&action, 0, sizeof action);
3393         action.type = htons(OFPAT_OUTPUT);
3394         action.output.len = htons(sizeof action);
3395         action.output.port = htons(port_no);
3396
3397         flow_extract(pkt, ODPP_NONE, &flow);
3398         ofproto_send_packet(br->ofproto, &flow, &action, 1, pkt);
3399     }
3400     ofpbuf_delete(pkt);
3401 }
3402
3403 static void
3404 brstp_reconfigure(struct bridge *br)
3405 {
3406     size_t i;
3407
3408     if (!cfg_get_bool(0, "stp.%s.enabled", br->name)) {
3409         if (br->stp) {
3410             stp_destroy(br->stp);
3411             br->stp = NULL;
3412
3413             bridge_flush(br);
3414         }
3415     } else {
3416         uint64_t bridge_address, bridge_id;
3417         int bridge_priority;
3418
3419         bridge_address = cfg_get_mac(0, "stp.%s.address", br->name);
3420         if (!bridge_address) {
3421             if (br->stp) {
3422                 bridge_address = (stp_get_bridge_id(br->stp)
3423                                   & ((UINT64_C(1) << 48) - 1));
3424             } else {
3425                 uint8_t mac[ETH_ADDR_LEN];
3426                 eth_addr_random(mac);
3427                 bridge_address = eth_addr_to_uint64(mac);
3428             }
3429         }
3430
3431         if (cfg_is_valid(CFG_INT | CFG_REQUIRED, "stp.%s.priority",
3432                          br->name)) {
3433             bridge_priority = cfg_get_int(0, "stp.%s.priority", br->name);
3434         } else {
3435             bridge_priority = STP_DEFAULT_BRIDGE_PRIORITY;
3436         }
3437
3438         bridge_id = bridge_address | ((uint64_t) bridge_priority << 48);
3439         if (!br->stp) {
3440             br->stp = stp_create(br->name, bridge_id, brstp_send_bpdu, br);
3441             br->stp_last_tick = time_msec();
3442             bridge_flush(br);
3443         } else {
3444             if (bridge_id != stp_get_bridge_id(br->stp)) {
3445                 stp_set_bridge_id(br->stp, bridge_id);
3446                 bridge_flush(br);
3447             }
3448         }
3449
3450         for (i = 0; i < br->n_ports; i++) {
3451             struct port *p = br->ports[i];
3452             int dp_ifidx;
3453             struct stp_port *sp;
3454             int path_cost, priority;
3455             bool enable;
3456
3457             if (!p->n_ifaces) {
3458                 continue;
3459             }
3460             dp_ifidx = p->ifaces[0]->dp_ifidx;
3461             if (dp_ifidx < 0 || dp_ifidx >= STP_MAX_PORTS) {
3462                 continue;
3463             }
3464
3465             sp = stp_get_port(br->stp, dp_ifidx);
3466             enable = (!cfg_is_valid(CFG_BOOL | CFG_REQUIRED,
3467                                     "stp.%s.port.%s.enabled",
3468                                     br->name, p->name)
3469                       || cfg_get_bool(0, "stp.%s.port.%s.enabled",
3470                                       br->name, p->name));
3471             if (p->is_mirror_output_port) {
3472                 enable = false;
3473             }
3474             if (enable != (stp_port_get_state(sp) != STP_DISABLED)) {
3475                 bridge_flush(br); /* Might not be necessary. */
3476                 if (enable) {
3477                     stp_port_enable(sp);
3478                 } else {
3479                     stp_port_disable(sp);
3480                 }
3481             }
3482
3483             path_cost = cfg_get_int(0, "stp.%s.port.%s.path-cost",
3484                                     br->name, p->name);
3485             stp_port_set_path_cost(sp, path_cost ? path_cost : 19 /* XXX */);
3486
3487             priority = (cfg_is_valid(CFG_INT | CFG_REQUIRED,
3488                                      "stp.%s.port.%s.priority",
3489                                      br->name, p->name)
3490                         ? cfg_get_int(0, "stp.%s.port.%s.priority",
3491                                       br->name, p->name)
3492                         : STP_DEFAULT_PORT_PRIORITY);
3493             stp_port_set_priority(sp, priority);
3494         }
3495
3496         brstp_adjust_timers(br);
3497     }
3498     for (i = 0; i < br->n_ports; i++) {
3499         brstp_update_port_state(br->ports[i]);
3500     }
3501 }
3502
3503 static void
3504 brstp_update_port_state(struct port *p)
3505 {
3506     struct bridge *br = p->bridge;
3507     enum stp_state state;
3508
3509     /* Figure out new state. */
3510     state = STP_DISABLED;
3511     if (br->stp && p->n_ifaces > 0) {
3512         int dp_ifidx = p->ifaces[0]->dp_ifidx;
3513         if (dp_ifidx >= 0 && dp_ifidx < STP_MAX_PORTS) {
3514             state = stp_port_get_state(stp_get_port(br->stp, dp_ifidx));
3515         }
3516     }
3517
3518     /* Update state. */
3519     if (p->stp_state != state) {
3520         static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(10, 10);
3521         VLOG_INFO_RL(&rl, "port %s: STP state changed from %s to %s",
3522                      p->name, stp_state_name(p->stp_state),
3523                      stp_state_name(state));
3524         if (p->stp_state == STP_DISABLED) {
3525             bridge_flush(br);
3526         } else {
3527             ofproto_revalidate(p->bridge->ofproto, p->stp_state_tag);
3528         }
3529         p->stp_state = state;
3530         p->stp_state_tag = (p->stp_state == STP_DISABLED ? 0
3531                             : tag_create_random());
3532     }
3533 }
3534
3535 static void
3536 brstp_adjust_timers(struct bridge *br)
3537 {
3538     int hello_time = cfg_get_int(0, "stp.%s.hello-time", br->name);
3539     int max_age = cfg_get_int(0, "stp.%s.max-age", br->name);
3540     int forward_delay = cfg_get_int(0, "stp.%s.forward-delay", br->name);
3541
3542     stp_set_hello_time(br->stp, hello_time ? hello_time : 2000);
3543     stp_set_max_age(br->stp, max_age ? max_age : 20000);
3544     stp_set_forward_delay(br->stp, forward_delay ? forward_delay : 15000);
3545 }
3546
3547 static void
3548 brstp_run(struct bridge *br)
3549 {
3550     if (br->stp) {
3551         long long int now = time_msec();
3552         long long int elapsed = now - br->stp_last_tick;
3553         struct stp_port *sp;
3554
3555         if (elapsed > 0) {
3556             stp_tick(br->stp, MIN(INT_MAX, elapsed));
3557             br->stp_last_tick = now;
3558         }
3559         while (stp_get_changed_port(br->stp, &sp)) {
3560             struct port *p = port_from_dp_ifidx(br, stp_port_no(sp));
3561             if (p) {
3562                 brstp_update_port_state(p);
3563             }
3564         }
3565     }
3566 }
3567
3568 static void
3569 brstp_wait(struct bridge *br)
3570 {
3571     if (br->stp) {
3572         poll_timer_wait(1000);
3573     }
3574 }