vswitchd/bridge.c

   1 /* Copyright (c) 2008, 2009, 2010, 2011 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 <inttypes.h>
  21 #include <stdlib.h>
  22 #include "bitmap.h"
  23 #include "bond.h"
  24 #include "cfm.h"
  25 #include "coverage.h"
  26 #include "daemon.h"
  27 #include "dirs.h"
  28 #include "dynamic-string.h"
  29 #include "hash.h"
  30 #include "hmap.h"
  31 #include "jsonrpc.h"
  32 #include "lacp.h"
  33 #include "list.h"
  34 #include "netdev.h"
  35 #include "ofp-print.h"
  36 #include "ofpbuf.h"
  37 #include "ofproto/ofproto.h"
  38 #include "poll-loop.h"
  39 #include "sha1.h"
  40 #include "shash.h"
  41 #include "socket-util.h"
  42 #include "stream-ssl.h"
  43 #include "sset.h"
  44 #include "system-stats.h"
  45 #include "timeval.h"
  46 #include "util.h"
  47 #include "unixctl.h"
  48 #include "vswitchd/vswitch-idl.h"
  49 #include "xenserver.h"
  50 #include "vlog.h"
  51 #include "sflow_api.h"
  52 #include "vlan-bitmap.h"
  53
  54 VLOG_DEFINE_THIS_MODULE(bridge);
  55
  56 COVERAGE_DEFINE(bridge_reconfigure);
  57
  58 struct iface {
  59     /* These members are always valid. */
  60     struct list port_elem;      /* Element in struct port's "ifaces" list. */
  61     struct hmap_node name_node; /* In struct bridge's "iface_by_name" hmap. */
  62     struct port *port;          /* Containing port. */
  63     char *name;                 /* Host network device name. */
  64     tag_type tag;               /* Tag associated with this interface. */
  65
  66     /* These members are valid only after bridge_reconfigure() causes them to
  67      * be initialized. */
  68     struct hmap_node ofp_port_node; /* In struct bridge's "ifaces" hmap. */
  69     int ofp_port;               /* OpenFlow port number, -1 if unknown. */
  70     struct netdev *netdev;      /* Network device. */
  71     const char *type;           /* Usually same as cfg->type. */
  72     const struct ovsrec_interface *cfg;
  73 };
  74
  75 struct mirror {
  76     struct uuid uuid;           /* UUID of this "mirror" record in database. */
  77     struct hmap_node hmap_node; /* In struct bridge's "mirrors" hmap. */
  78     struct bridge *bridge;
  79     char *name;
  80 };
  81
  82 struct port {
  83     struct bridge *bridge;
  84     struct hmap_node hmap_node; /* Element in struct bridge's "ports" hmap. */
  85     char *name;
  86
  87     const struct ovsrec_port *cfg;
  88
  89     /* An ordinary bridge port has 1 interface.
  90      * A bridge port for bonding has at least 2 interfaces. */
  91     struct list ifaces;         /* List of "struct iface"s. */
  92 };
  93
  94 struct bridge {
  95     struct hmap_node node;      /* In 'all_bridges'. */
  96     char *name;                 /* User-specified arbitrary name. */
  97     char *type;                 /* Datapath type. */
  98     uint8_t ea[ETH_ADDR_LEN];   /* Bridge Ethernet Address. */
  99     uint8_t default_ea[ETH_ADDR_LEN]; /* Default MAC. */
 100     const struct ovsrec_bridge *cfg;
 101
 102     /* OpenFlow switch processing. */
 103     struct ofproto *ofproto;    /* OpenFlow switch. */
 104
 105     /* Bridge ports. */
 106     struct hmap ports;          /* "struct port"s indexed by name. */
 107     struct hmap ifaces;         /* "struct iface"s indexed by ofp_port. */
 108     struct hmap iface_by_name;  /* "struct iface"s indexed by name. */
 109
 110     /* Port mirroring. */
 111     struct hmap mirrors;        /* "struct mirror" indexed by UUID. */
 112
 113     /* Synthetic local port if necessary. */
 114     struct ovsrec_port synth_local_port;
 115     struct ovsrec_interface synth_local_iface;
 116     struct ovsrec_interface *synth_local_ifacep;
 117 };
 118
 119 /* All bridges, indexed by name. */
 120 static struct hmap all_bridges = HMAP_INITIALIZER(&all_bridges);
 121
 122 /* OVSDB IDL used to obtain configuration. */
 123 static struct ovsdb_idl *idl;
 124
 125 /* Each time this timer expires, the bridge fetches systems and interface
 126  * statistics and pushes them into the database. */
 127 #define STATS_INTERVAL (5 * 1000) /* In milliseconds. */
 128 static long long int stats_timer = LLONG_MIN;
 129
 130 /* Stores the time after which rate limited statistics may be written to the
 131  * database.  Only updated when changes to the database require rate limiting.
 132  */
 133 #define DB_LIMIT_INTERVAL (1 * 1000) /* In milliseconds. */
 134 static long long int db_limiter = LLONG_MIN;
 135
 136 static void add_del_bridges(const struct ovsrec_open_vswitch *);
 137 static void bridge_del_ofprotos(void);
 138 static bool bridge_add_ofprotos(struct bridge *);
 139 static void bridge_create(const struct ovsrec_bridge *);
 140 static void bridge_destroy(struct bridge *);
 141 static struct bridge *bridge_lookup(const char *name);
 142 static unixctl_cb_func bridge_unixctl_dump_flows;
 143 static unixctl_cb_func bridge_unixctl_reconnect;
 144 static size_t bridge_get_controllers(const struct bridge *br,
 145                                      struct ovsrec_controller ***controllersp);
 146 static void bridge_add_del_ports(struct bridge *);
 147 static void bridge_add_ofproto_ports(struct bridge *);
 148 static void bridge_del_ofproto_ports(struct bridge *);
 149 static void bridge_refresh_ofp_port(struct bridge *);
 150 static void bridge_configure_datapath_id(struct bridge *);
 151 static void bridge_configure_flow_eviction_threshold(struct bridge *);
 152 static void bridge_configure_netflow(struct bridge *);
 153 static void bridge_configure_sflow(struct bridge *, int *sflow_bridge_number);
 154 static void bridge_configure_remotes(struct bridge *,
 155                                      const struct sockaddr_in *managers,
 156                                      size_t n_managers);
 157 static void bridge_pick_local_hw_addr(struct bridge *,
 158                                       uint8_t ea[ETH_ADDR_LEN],
 159                                       struct iface **hw_addr_iface);
 160 static uint64_t bridge_pick_datapath_id(struct bridge *,
 161                                         const uint8_t bridge_ea[ETH_ADDR_LEN],
 162                                         struct iface *hw_addr_iface);
 163 static uint64_t dpid_from_hash(const void *, size_t nbytes);
 164 static bool bridge_has_bond_fake_iface(const struct bridge *,
 165                                        const char *name);
 166 static bool port_is_bond_fake_iface(const struct port *);
 167
 168 static unixctl_cb_func qos_unixctl_show;
 169
 170 static struct port *port_create(struct bridge *, const struct ovsrec_port *);
 171 static void port_add_ifaces(struct port *);
 172 static void port_del_ifaces(struct port *);
 173 static void port_destroy(struct port *);
 174 static struct port *port_lookup(const struct bridge *, const char *name);
 175 static void port_configure(struct port *);
 176 static struct lacp_settings *port_configure_lacp(struct port *,
 177                                                  struct lacp_settings *);
 178 static void port_configure_bond(struct port *, struct bond_settings *,
 179                                 uint32_t *bond_stable_ids);
 180
 181 static void bridge_configure_mirrors(struct bridge *);
 182 static struct mirror *mirror_create(struct bridge *,
 183                                     const struct ovsrec_mirror *);
 184 static void mirror_destroy(struct mirror *);
 185 static bool mirror_configure(struct mirror *, const struct ovsrec_mirror *);
 186
 187 static void iface_configure_lacp(struct iface *, struct lacp_slave_settings *);
 188 static struct iface *iface_create(struct port *port,
 189                                   const struct ovsrec_interface *if_cfg);
 190 static void iface_destroy(struct iface *);
 191 static struct iface *iface_lookup(const struct bridge *, const char *name);
 192 static struct iface *iface_find(const char *name);
 193 static struct iface *iface_from_ofp_port(const struct bridge *,
 194                                          uint16_t ofp_port);
 195 static void iface_set_mac(struct iface *);
 196 static void iface_set_ofport(const struct ovsrec_interface *, int64_t ofport);
 197 static void iface_configure_qos(struct iface *, const struct ovsrec_qos *);
 198 static void iface_configure_cfm(struct iface *);
 199 static bool iface_refresh_cfm_stats(struct iface *);
 200 static void iface_refresh_stats(struct iface *);
 201 static void iface_refresh_status(struct iface *);
 202 static bool iface_get_carrier(const struct iface *);
 203 static bool iface_is_synthetic(const struct iface *);
 204
 205 static void shash_from_ovs_idl_map(char **keys, char **values, size_t n,
 206                                    struct shash *);
 207 static void shash_to_ovs_idl_map(struct shash *,
 208                                  char ***keys, char ***values, size_t *n);
 209 \f
 210 /* Public functions. */
 211
 212 /* Initializes the bridge module, configuring it to obtain its configuration
 213  * from an OVSDB server accessed over 'remote', which should be a string in a
 214  * form acceptable to ovsdb_idl_create(). */
 215 void
 216 bridge_init(const char *remote)
 217 {
 218     /* Create connection to database. */
 219     idl = ovsdb_idl_create(remote, &ovsrec_idl_class, true);
 220     ovsdb_idl_set_lock(idl, "ovs_vswitchd");
 221
 222     ovsdb_idl_omit_alert(idl, &ovsrec_open_vswitch_col_cur_cfg);
 223     ovsdb_idl_omit_alert(idl, &ovsrec_open_vswitch_col_statistics);
 224     ovsdb_idl_omit(idl, &ovsrec_open_vswitch_col_external_ids);
 225     ovsdb_idl_omit(idl, &ovsrec_open_vswitch_col_ovs_version);
 226     ovsdb_idl_omit(idl, &ovsrec_open_vswitch_col_db_version);
 227     ovsdb_idl_omit(idl, &ovsrec_open_vswitch_col_system_type);
 228     ovsdb_idl_omit(idl, &ovsrec_open_vswitch_col_system_version);
 229
 230     ovsdb_idl_omit_alert(idl, &ovsrec_bridge_col_datapath_id);
 231     ovsdb_idl_omit(idl, &ovsrec_bridge_col_external_ids);
 232
 233     ovsdb_idl_omit(idl, &ovsrec_port_col_external_ids);
 234     ovsdb_idl_omit(idl, &ovsrec_port_col_fake_bridge);
 235
 236     ovsdb_idl_omit_alert(idl, &ovsrec_interface_col_admin_state);
 237     ovsdb_idl_omit_alert(idl, &ovsrec_interface_col_duplex);
 238     ovsdb_idl_omit_alert(idl, &ovsrec_interface_col_link_speed);
 239     ovsdb_idl_omit_alert(idl, &ovsrec_interface_col_link_state);
 240     ovsdb_idl_omit_alert(idl, &ovsrec_interface_col_mtu);
 241     ovsdb_idl_omit_alert(idl, &ovsrec_interface_col_ofport);
 242     ovsdb_idl_omit_alert(idl, &ovsrec_interface_col_statistics);
 243     ovsdb_idl_omit_alert(idl, &ovsrec_interface_col_status);
 244     ovsdb_idl_omit(idl, &ovsrec_interface_col_external_ids);
 245
 246     ovsdb_idl_omit_alert(idl, &ovsrec_controller_col_is_connected);
 247     ovsdb_idl_omit_alert(idl, &ovsrec_controller_col_role);
 248     ovsdb_idl_omit_alert(idl, &ovsrec_controller_col_status);
 249     ovsdb_idl_omit(idl, &ovsrec_controller_col_external_ids);
 250
 251     ovsdb_idl_omit(idl, &ovsrec_qos_col_external_ids);
 252
 253     ovsdb_idl_omit(idl, &ovsrec_queue_col_external_ids);
 254
 255     ovsdb_idl_omit(idl, &ovsrec_mirror_col_external_ids);
 256
 257     ovsdb_idl_omit(idl, &ovsrec_netflow_col_external_ids);
 258
 259     ovsdb_idl_omit(idl, &ovsrec_sflow_col_external_ids);
 260
 261     ovsdb_idl_omit(idl, &ovsrec_manager_col_external_ids);
 262     ovsdb_idl_omit(idl, &ovsrec_manager_col_inactivity_probe);
 263     ovsdb_idl_omit(idl, &ovsrec_manager_col_is_connected);
 264     ovsdb_idl_omit(idl, &ovsrec_manager_col_max_backoff);
 265     ovsdb_idl_omit(idl, &ovsrec_manager_col_status);
 266
 267     ovsdb_idl_omit(idl, &ovsrec_ssl_col_external_ids);
 268
 269     /* Register unixctl commands. */
 270     unixctl_command_register("qos/show", qos_unixctl_show, NULL);
 271     unixctl_command_register("bridge/dump-flows", bridge_unixctl_dump_flows,
 272                              NULL);
 273     unixctl_command_register("bridge/reconnect", bridge_unixctl_reconnect,
 274                              NULL);
 275     lacp_init();
 276     bond_init();
 277     cfm_init();
 278 }
 279
 280 void
 281 bridge_exit(void)
 282 {
 283     struct bridge *br, *next_br;
 284
 285     HMAP_FOR_EACH_SAFE (br, next_br, node, &all_bridges) {
 286         bridge_destroy(br);
 287     }
 288     ovsdb_idl_destroy(idl);
 289 }
 290
 291 /* Looks at the list of managers in 'ovs_cfg' and extracts their remote IP
 292  * addresses and ports into '*managersp' and '*n_managersp'.  The caller is
 293  * responsible for freeing '*managersp' (with free()).
 294  *
 295  * You may be asking yourself "why does ovs-vswitchd care?", because
 296  * ovsdb-server is responsible for connecting to the managers, and ovs-vswitchd
 297  * should not be and in fact is not directly involved in that.  But
 298  * ovs-vswitchd needs to make sure that ovsdb-server can reach the managers, so
 299  * it has to tell in-band control where the managers are to enable that.
 300  * (Thus, only managers connected in-band are collected.)
 301  */
 302 static void
 303 collect_in_band_managers(const struct ovsrec_open_vswitch *ovs_cfg,
 304                          struct sockaddr_in **managersp, size_t *n_managersp)
 305 {
 306     struct sockaddr_in *managers = NULL;
 307     size_t n_managers = 0;
 308     struct sset targets;
 309     size_t i;
 310
 311     /* Collect all of the potential targets from the "targets" columns of the
 312      * rows pointed to by "manager_options", excluding any that are
 313      * out-of-band. */
 314     sset_init(&targets);
 315     for (i = 0; i < ovs_cfg->n_manager_options; i++) {
 316         struct ovsrec_manager *m = ovs_cfg->manager_options[i];
 317
 318         if (m->connection_mode && !strcmp(m->connection_mode, "out-of-band")) {
 319             sset_find_and_delete(&targets, m->target);
 320         } else {
 321             sset_add(&targets, m->target);
 322         }
 323     }
 324
 325     /* Now extract the targets' IP addresses. */
 326     if (!sset_is_empty(&targets)) {
 327         const char *target;
 328
 329         managers = xmalloc(sset_count(&targets) * sizeof *managers);
 330         SSET_FOR_EACH (target, &targets) {
 331             struct sockaddr_in *sin = &managers[n_managers];
 332
 333             if ((!strncmp(target, "tcp:", 4)
 334                  && inet_parse_active(target + 4, JSONRPC_TCP_PORT, sin)) ||
 335                 (!strncmp(target, "ssl:", 4)
 336                  && inet_parse_active(target + 4, JSONRPC_SSL_PORT, sin))) {
 337                 n_managers++;
 338             }
 339         }
 340     }
 341     sset_destroy(&targets);
 342
 343     *managersp = managers;
 344     *n_managersp = n_managers;
 345 }
 346
 347 static void
 348 bridge_reconfigure(const struct ovsrec_open_vswitch *ovs_cfg)
 349 {
 350     struct sockaddr_in *managers;
 351     struct bridge *br, *next;
 352     int sflow_bridge_number;
 353     size_t n_managers;
 354
 355     COVERAGE_INC(bridge_reconfigure);
 356
 357     /* Create and destroy "struct bridge"s, "struct port"s, and "struct
 358      * iface"s according to 'ovs_cfg', with only very minimal configuration
 359      * otherwise.
 360      *
 361      * This is purely an update to bridge data structures.  Nothing is pushed
 362      * down to ofproto or lower layers. */
 363     add_del_bridges(ovs_cfg);
 364     HMAP_FOR_EACH (br, node, &all_bridges) {
 365         bridge_add_del_ports(br);
 366     }
 367
 368     /* Delete all datapaths and datapath ports that are no longer configured.
 369      *
 370      * The kernel will reject any attempt to add a given port to a datapath if
 371      * that port already belongs to a different datapath, so we must do all
 372      * port deletions before any port additions.  A datapath always has a
 373      * "local port" so we must delete not-configured datapaths too. */
 374     bridge_del_ofprotos();
 375     HMAP_FOR_EACH (br, node, &all_bridges) {
 376         if (br->ofproto) {
 377             bridge_del_ofproto_ports(br);
 378         }
 379     }
 380
 381     /* Create datapaths and datapath ports that are missing.
 382      *
 383      * After this is done, we have our final set of bridges, ports, and
 384      * interfaces.  Every "struct bridge" has an ofproto, every "struct port"
 385      * has at least one iface, every "struct iface" has a valid ofp_port and
 386      * netdev. */
 387     HMAP_FOR_EACH_SAFE (br, next, node, &all_bridges) {
 388         if (!br->ofproto && !bridge_add_ofprotos(br)) {
 389             bridge_destroy(br);
 390         }
 391     }
 392     HMAP_FOR_EACH (br, node, &all_bridges) {
 393         bridge_refresh_ofp_port(br);
 394         bridge_add_ofproto_ports(br);
 395     }
 396
 397     /* Complete the configuration. */
 398     sflow_bridge_number = 0;
 399     collect_in_band_managers(ovs_cfg, &managers, &n_managers);
 400     HMAP_FOR_EACH (br, node, &all_bridges) {
 401         struct port *port;
 402
 403         HMAP_FOR_EACH (port, hmap_node, &br->ports) {
 404             struct iface *iface;
 405
 406             port_configure(port);
 407
 408             LIST_FOR_EACH (iface, port_elem, &port->ifaces) {
 409                 iface_configure_cfm(iface);
 410                 iface_configure_qos(iface, port->cfg->qos);
 411                 iface_set_mac(iface);
 412             }
 413         }
 414         bridge_configure_mirrors(br);
 415         bridge_configure_datapath_id(br);
 416         bridge_configure_flow_eviction_threshold(br);
 417         bridge_configure_remotes(br, managers, n_managers);
 418         bridge_configure_netflow(br);
 419         bridge_configure_sflow(br, &sflow_bridge_number);
 420     }
 421     free(managers);
 422
 423     /* ovs-vswitchd has completed initialization, so allow the process that
 424      * forked us to exit successfully. */
 425     daemonize_complete();
 426 }
 427
 428 /* Iterate over all ofprotos and delete any of them that do not have a
 429  * configured bridge or that are the wrong type. */
 430 static void
 431 bridge_del_ofprotos(void)
 432 {
 433     struct sset names;
 434     struct sset types;
 435     const char *type;
 436
 437     sset_init(&names);
 438     sset_init(&types);
 439     ofproto_enumerate_types(&types);
 440     SSET_FOR_EACH (type, &types) {
 441         const char *name;
 442
 443         ofproto_enumerate_names(type, &names);
 444         SSET_FOR_EACH (name, &names) {
 445             struct bridge *br = bridge_lookup(name);
 446             if (!br || strcmp(type, br->type)) {
 447                 ofproto_delete(name, type);
 448             }
 449         }
 450     }
 451     sset_destroy(&names);
 452     sset_destroy(&types);
 453 }
 454
 455 static bool
 456 bridge_add_ofprotos(struct bridge *br)
 457 {
 458     int error = ofproto_create(br->name, br->type, &br->ofproto);
 459     if (error) {
 460         VLOG_ERR("failed to create bridge %s: %s", br->name, strerror(error));
 461         return false;
 462     }
 463     return true;
 464 }
 465
 466 static void
 467 port_configure(struct port *port)
 468 {
 469     const struct ovsrec_port *cfg = port->cfg;
 470     struct bond_settings bond_settings;
 471     struct lacp_settings lacp_settings;
 472     struct ofproto_bundle_settings s;
 473     struct iface *iface;
 474
 475     /* Get name. */
 476     s.name = port->name;
 477
 478     /* Get slaves. */
 479     s.n_slaves = 0;
 480     s.slaves = xmalloc(list_size(&port->ifaces) * sizeof *s.slaves);
 481     LIST_FOR_EACH (iface, port_elem, &port->ifaces) {
 482         s.slaves[s.n_slaves++] = iface->ofp_port;
 483     }
 484
 485     /* Get VLAN tag. */
 486     s.vlan = -1;
 487     if (cfg->tag) {
 488         if (list_is_short(&port->ifaces)) {
 489             if (*cfg->tag >= 0 && *cfg->tag <= 4095) {
 490                 s.vlan = *cfg->tag;
 491                 VLOG_DBG("port %s: assigning VLAN tag %d", port->name, s.vlan);
 492             }
 493         } else {
 494             /* It's possible that bonded, VLAN-tagged ports make sense.  Maybe
 495              * they even work as-is.  But they have not been tested. */
 496             VLOG_WARN("port %s: VLAN tags not supported on bonded ports",
 497                       port->name);
 498         }
 499     }
 500
 501     /* Get VLAN trunks. */
 502     s.trunks = NULL;
 503     if (s.vlan < 0 && cfg->n_trunks) {
 504         s.trunks = vlan_bitmap_from_array(cfg->trunks, cfg->n_trunks);
 505     } else if (s.vlan >= 0 && cfg->n_trunks) {
 506         VLOG_ERR("port %s: ignoring trunks in favor of implicit vlan",
 507                  port->name);
 508     }
 509
 510     /* Get LACP settings. */
 511     s.lacp = port_configure_lacp(port, &lacp_settings);
 512     if (s.lacp) {
 513         size_t i = 0;
 514
 515         s.lacp_slaves = xmalloc(s.n_slaves * sizeof *s.lacp_slaves);
 516         LIST_FOR_EACH (iface, port_elem, &port->ifaces) {
 517             iface_configure_lacp(iface, &s.lacp_slaves[i++]);
 518         }
 519     } else {
 520         s.lacp_slaves = NULL;
 521     }
 522
 523     /* Get bond settings. */
 524     if (s.n_slaves > 1) {
 525         s.bond = &bond_settings;
 526         s.bond_stable_ids = xmalloc(s.n_slaves * sizeof *s.bond_stable_ids);
 527         port_configure_bond(port, &bond_settings, s.bond_stable_ids);
 528     } else {
 529         s.bond = NULL;
 530         s.bond_stable_ids = NULL;
 531
 532         LIST_FOR_EACH (iface, port_elem, &port->ifaces) {
 533             netdev_set_miimon_interval(iface->netdev, 0);
 534         }
 535     }
 536
 537     /* Register. */
 538     ofproto_bundle_register(port->bridge->ofproto, port, &s);
 539
 540     /* Clean up. */
 541     free(s.slaves);
 542     free(s.trunks);
 543     free(s.lacp_slaves);
 544     free(s.bond_stable_ids);
 545 }
 546
 547 /* Pick local port hardware address and datapath ID for 'br'. */
 548 static void
 549 bridge_configure_datapath_id(struct bridge *br)
 550 {
 551     uint8_t ea[ETH_ADDR_LEN];
 552     uint64_t dpid;
 553     struct iface *local_iface;
 554     struct iface *hw_addr_iface;
 555     char *dpid_string;
 556
 557     bridge_pick_local_hw_addr(br, ea, &hw_addr_iface);
 558     local_iface = iface_from_ofp_port(br, OFPP_LOCAL);
 559     if (local_iface) {
 560         int error = netdev_set_etheraddr(local_iface->netdev, ea);
 561         if (error) {
 562             static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
 563             VLOG_ERR_RL(&rl, "bridge %s: failed to set bridge "
 564                         "Ethernet address: %s",
 565                         br->name, strerror(error));
 566         }
 567     }
 568     memcpy(br->ea, ea, ETH_ADDR_LEN);
 569
 570     dpid = bridge_pick_datapath_id(br, ea, hw_addr_iface);
 571     ofproto_set_datapath_id(br->ofproto, dpid);
 572
 573     dpid_string = xasprintf("%016"PRIx64, dpid);
 574     ovsrec_bridge_set_datapath_id(br->cfg, dpid_string);
 575     free(dpid_string);
 576 }
 577
 578 /* Set NetFlow configuration on 'br'. */
 579 static void
 580 bridge_configure_netflow(struct bridge *br)
 581 {
 582     struct ovsrec_netflow *cfg = br->cfg->netflow;
 583     struct netflow_options opts;
 584
 585     if (!cfg) {
 586         ofproto_set_netflow(br->ofproto, NULL);
 587         return;
 588     }
 589
 590     memset(&opts, 0, sizeof opts);
 591
 592     /* Get default NetFlow configuration from datapath.
 593      * Apply overrides from 'cfg'. */
 594     ofproto_get_netflow_ids(br->ofproto, &opts.engine_type, &opts.engine_id);
 595     if (cfg->engine_type) {
 596         opts.engine_type = *cfg->engine_type;
 597     }
 598     if (cfg->engine_id) {
 599         opts.engine_id = *cfg->engine_id;
 600     }
 601
 602     /* Configure active timeout interval. */
 603     opts.active_timeout = cfg->active_timeout;
 604     if (!opts.active_timeout) {
 605         opts.active_timeout = -1;
 606     } else if (opts.active_timeout < 0) {
 607         VLOG_WARN("bridge %s: active timeout interval set to negative "
 608                   "value, using default instead (%d seconds)", br->name,
 609                   NF_ACTIVE_TIMEOUT_DEFAULT);
 610         opts.active_timeout = -1;
 611     }
 612
 613     /* Add engine ID to interface number to disambiguate bridgs? */
 614     opts.add_id_to_iface = cfg->add_id_to_interface;
 615     if (opts.add_id_to_iface) {
 616         if (opts.engine_id > 0x7f) {
 617             VLOG_WARN("bridge %s: NetFlow port mangling may conflict with "
 618                       "another vswitch, choose an engine id less than 128",
 619                       br->name);
 620         }
 621         if (hmap_count(&br->ports) > 508) {
 622             VLOG_WARN("bridge %s: NetFlow port mangling will conflict with "
 623                       "another port when more than 508 ports are used",
 624                       br->name);
 625         }
 626     }
 627
 628     /* Collectors. */
 629     sset_init(&opts.collectors);
 630     sset_add_array(&opts.collectors, cfg->targets, cfg->n_targets);
 631
 632     /* Configure. */
 633     if (ofproto_set_netflow(br->ofproto, &opts)) {
 634         VLOG_ERR("bridge %s: problem setting netflow collectors", br->name);
 635     }
 636     sset_destroy(&opts.collectors);
 637 }
 638
 639 /* Set sFlow configuration on 'br'. */
 640 static void
 641 bridge_configure_sflow(struct bridge *br, int *sflow_bridge_number)
 642 {
 643     const struct ovsrec_sflow *cfg = br->cfg->sflow;
 644     struct ovsrec_controller **controllers;
 645     struct ofproto_sflow_options oso;
 646     size_t n_controllers;
 647     size_t i;
 648
 649     if (!cfg) {
 650         ofproto_set_sflow(br->ofproto, NULL);
 651         return;
 652     }
 653
 654     memset(&oso, 0, sizeof oso);
 655
 656     sset_init(&oso.targets);
 657     sset_add_array(&oso.targets, cfg->targets, cfg->n_targets);
 658
 659     oso.sampling_rate = SFL_DEFAULT_SAMPLING_RATE;
 660     if (cfg->sampling) {
 661         oso.sampling_rate = *cfg->sampling;
 662     }
 663
 664     oso.polling_interval = SFL_DEFAULT_POLLING_INTERVAL;
 665     if (cfg->polling) {
 666         oso.polling_interval = *cfg->polling;
 667     }
 668
 669     oso.header_len = SFL_DEFAULT_HEADER_SIZE;
 670     if (cfg->header) {
 671         oso.header_len = *cfg->header;
 672     }
 673
 674     oso.sub_id = (*sflow_bridge_number)++;
 675     oso.agent_device = cfg->agent;
 676
 677     oso.control_ip = NULL;
 678     n_controllers = bridge_get_controllers(br, &controllers);
 679     for (i = 0; i < n_controllers; i++) {
 680         if (controllers[i]->local_ip) {
 681             oso.control_ip = controllers[i]->local_ip;
 682             break;
 683         }
 684     }
 685     ofproto_set_sflow(br->ofproto, &oso);
 686
 687     sset_destroy(&oso.targets);
 688 }
 689
 690 static bool
 691 bridge_has_bond_fake_iface(const struct bridge *br, const char *name)
 692 {
 693     const struct port *port = port_lookup(br, name);
 694     return port && port_is_bond_fake_iface(port);
 695 }
 696
 697 static bool
 698 port_is_bond_fake_iface(const struct port *port)
 699 {
 700     return port->cfg->bond_fake_iface && !list_is_short(&port->ifaces);
 701 }
 702
 703 static void
 704 add_del_bridges(const struct ovsrec_open_vswitch *cfg)
 705 {
 706     struct bridge *br, *next;
 707     struct shash new_br;
 708     size_t i;
 709
 710     /* Collect new bridges' names and types. */
 711     shash_init(&new_br);
 712     for (i = 0; i < cfg->n_bridges; i++) {
 713         const struct ovsrec_bridge *br_cfg = cfg->bridges[i];
 714         if (!shash_add_once(&new_br, br_cfg->name, br_cfg)) {
 715             VLOG_WARN("bridge %s specified twice", br_cfg->name);
 716         }
 717     }
 718
 719     /* Get rid of deleted bridges or those whose types have changed.
 720      * Update 'cfg' of bridges that still exist. */
 721     HMAP_FOR_EACH_SAFE (br, next, node, &all_bridges) {
 722         br->cfg = shash_find_data(&new_br, br->name);
 723         if (!br->cfg || strcmp(br->type, ofproto_normalize_type(
 724                                    br->cfg->datapath_type))) {
 725             bridge_destroy(br);
 726         }
 727     }
 728
 729     /* Add new bridges. */
 730     for (i = 0; i < cfg->n_bridges; i++) {
 731         const struct ovsrec_bridge *br_cfg = cfg->bridges[i];
 732         struct bridge *br = bridge_lookup(br_cfg->name);
 733         if (!br) {
 734             bridge_create(br_cfg);
 735         }
 736     }
 737
 738     shash_destroy(&new_br);
 739 }
 740
 741 /* Delete each ofproto port on 'br' that doesn't have a corresponding "struct
 742  * iface".
 743  *
 744  * The kernel will reject any attempt to add a given port to a datapath if that
 745  * port already belongs to a different datapath, so we must do all port
 746  * deletions before any port additions. */
 747 static void
 748 bridge_del_ofproto_ports(struct bridge *br)
 749 {
 750     struct ofproto_port_dump dump;
 751     struct ofproto_port ofproto_port;
 752
 753     OFPROTO_PORT_FOR_EACH (&ofproto_port, &dump, br->ofproto) {
 754         const char *name = ofproto_port.name;
 755         struct iface *iface;
 756         const char *type;
 757         int error;
 758
 759         /* Ignore the local port.  We can't change it anyhow. */
 760         if (!strcmp(name, br->name)) {
 761             continue;
 762         }
 763
 764         /* Get the type that 'ofproto_port' should have (ordinarily the
 765          * type of its corresponding iface) or NULL if it should be
 766          * deleted. */
 767         iface = iface_lookup(br, name);
 768         type = (iface ? iface->type
 769                 : bridge_has_bond_fake_iface(br, name) ? "internal"
 770                 : NULL);
 771
 772         /* If it's the wrong type then delete the ofproto port. */
 773         if (type
 774             && !strcmp(ofproto_port.type, type)
 775             && (!iface || !iface->netdev
 776                 || !strcmp(netdev_get_type(iface->netdev), type))) {
 777             continue;
 778         }
 779         error = ofproto_port_del(br->ofproto, ofproto_port.ofp_port);
 780         if (error) {
 781             VLOG_WARN("bridge %s: failed to remove %s interface (%s)",
 782                       br->name, name, strerror(error));
 783         }
 784         if (iface) {
 785             netdev_close(iface->netdev);
 786             iface->netdev = NULL;
 787         }
 788     }
 789 }
 790
 791 static void
 792 iface_set_ofp_port(struct iface *iface, int ofp_port)
 793 {
 794     struct bridge *br = iface->port->bridge;
 795
 796     assert(iface->ofp_port < 0 && ofp_port >= 0);
 797     iface->ofp_port = ofp_port;
 798     hmap_insert(&br->ifaces, &iface->ofp_port_node, hash_int(ofp_port, 0));
 799     iface_set_ofport(iface->cfg, ofp_port);
 800 }
 801
 802 static void
 803 bridge_refresh_ofp_port(struct bridge *br)
 804 {
 805     struct ofproto_port_dump dump;
 806     struct ofproto_port ofproto_port;
 807     struct port *port;
 808
 809     /* Clear all the "ofp_port"es. */
 810     hmap_clear(&br->ifaces);
 811     HMAP_FOR_EACH (port, hmap_node, &br->ports) {
 812         struct iface *iface;
 813
 814         LIST_FOR_EACH (iface, port_elem, &port->ifaces) {
 815             iface->ofp_port = -1;
 816         }
 817     }
 818
 819     /* Obtain the correct "ofp_port"s from ofproto. */
 820     OFPROTO_PORT_FOR_EACH (&ofproto_port, &dump, br->ofproto) {
 821         struct iface *iface = iface_lookup(br, ofproto_port.name);
 822         if (iface) {
 823             if (iface->ofp_port >= 0) {
 824                 VLOG_WARN("bridge %s: interface %s reported twice",
 825                           br->name, ofproto_port.name);
 826             } else if (iface_from_ofp_port(br, ofproto_port.ofp_port)) {
 827                 VLOG_WARN("bridge %s: interface %"PRIu16" reported twice",
 828                           br->name, ofproto_port.ofp_port);
 829             } else {
 830                 iface_set_ofp_port(iface, ofproto_port.ofp_port);
 831             }
 832         }
 833     }
 834 }
 835
 836 /* Add an ofproto port for any "struct iface" that doesn't have one.
 837  * Delete any "struct iface" for which this fails.
 838  * Delete any "struct port" that thereby ends up with no ifaces. */
 839 static void
 840 bridge_add_ofproto_ports(struct bridge *br)
 841 {
 842     struct port *port, *next_port;
 843
 844     HMAP_FOR_EACH_SAFE (port, next_port, hmap_node, &br->ports) {
 845         struct iface *iface, *next_iface;
 846         struct ofproto_port ofproto_port;
 847
 848         LIST_FOR_EACH_SAFE (iface, next_iface, port_elem, &port->ifaces) {
 849             int error;
 850
 851             /* Open the netdev. */
 852             if (!iface->netdev) {
 853                 struct netdev_options options;
 854                 options.name = iface->name;
 855                 options.type = iface->type;
 856                 error = netdev_open(&options, &iface->netdev);
 857                 if (error) {
 858                     VLOG_WARN("could not open network device %s (%s)",
 859                               iface->name, strerror(error));
 860                 }
 861             } else {
 862                 error = 0;
 863             }
 864
 865             /* Configure the netdev. */
 866             if (iface->netdev) {
 867                 struct shash args;
 868
 869                 shash_init(&args);
 870                 shash_from_ovs_idl_map(iface->cfg->key_options,
 871                                        iface->cfg->value_options,
 872                                        iface->cfg->n_options, &args);
 873                 error = netdev_set_config(iface->netdev, &args);
 874                 shash_destroy(&args);
 875
 876                 if (error) {
 877                     VLOG_WARN("could not configure network device %s (%s)",
 878                               iface->name, strerror(error));
 879                     netdev_close(iface->netdev);
 880                     iface->netdev = NULL;
 881                 }
 882             }
 883
 884             /* Add the port, if necessary. */
 885             if (iface->netdev && iface->ofp_port < 0) {
 886                 uint16_t ofp_port;
 887                 int error;
 888
 889                 error = ofproto_port_add(br->ofproto, iface->netdev,
 890                                          &ofp_port);
 891                 if (!error) {
 892                     iface_set_ofp_port(iface, ofp_port);
 893                 } else {
 894                     netdev_close(iface->netdev);
 895                     iface->netdev = NULL;
 896                 }
 897             }
 898
 899             /* Populate stats columns in new Interface rows. */
 900             if (iface->netdev && !iface->cfg->mtu) {
 901                 iface_refresh_stats(iface);
 902                 iface_refresh_status(iface);
 903             }
 904
 905             /* Delete the iface if we failed. */
 906             if (iface->netdev && iface->ofp_port >= 0) {
 907                 VLOG_DBG("bridge %s: interface %s is on port %d",
 908                          br->name, iface->name, iface->ofp_port);
 909             } else {
 910                 if (iface->netdev) {
 911                     VLOG_ERR("bridge %s: missing %s interface, dropping",
 912                              br->name, iface->name);
 913                 } else {
 914                     /* We already reported a related error, don't bother
 915                      * duplicating it. */
 916                 }
 917                 iface_set_ofport(iface->cfg, -1);
 918                 iface_destroy(iface);
 919             }
 920         }
 921         if (list_is_empty(&port->ifaces)) {
 922             VLOG_WARN("%s port has no interfaces, dropping", port->name);
 923             port_destroy(port);
 924             continue;
 925         }
 926
 927         /* Add bond fake iface if necessary. */
 928         if (port_is_bond_fake_iface(port)) {
 929             if (ofproto_port_query_by_name(br->ofproto, port->name,
 930                                            &ofproto_port)) {
 931                 struct netdev_options options;
 932                 struct netdev *netdev;
 933                 int error;
 934
 935                 options.name = port->name;
 936                 options.type = "internal";
 937                 error = netdev_open(&options, &netdev);
 938                 if (!error) {
 939                     ofproto_port_add(br->ofproto, netdev, NULL);
 940                     netdev_close(netdev);
 941                 } else {
 942                     VLOG_WARN("could not open network device %s (%s)",
 943                               port->name, strerror(error));
 944                 }
 945             } else {
 946                 /* Already exists, nothing to do. */
 947                 ofproto_port_destroy(&ofproto_port);
 948             }
 949         }
 950     }
 951 }
 952
 953 static const char *
 954 get_ovsrec_key_value(const struct ovsdb_idl_row *row,
 955                      const struct ovsdb_idl_column *column,
 956                      const char *key)
 957 {
 958     const struct ovsdb_datum *datum;
 959     union ovsdb_atom atom;
 960     unsigned int idx;
 961
 962     datum = ovsdb_idl_get(row, column, OVSDB_TYPE_STRING, OVSDB_TYPE_STRING);
 963     atom.string = (char *) key;
 964     idx = ovsdb_datum_find_key(datum, &atom, OVSDB_TYPE_STRING);
 965     return idx == UINT_MAX ? NULL : datum->values[idx].string;
 966 }
 967
 968 static const char *
 969 bridge_get_other_config(const struct ovsrec_bridge *br_cfg, const char *key)
 970 {
 971     return get_ovsrec_key_value(&br_cfg->header_,
 972                                 &ovsrec_bridge_col_other_config, key);
 973 }
 974
 975 /* Set Flow eviction threshold */
 976 static void
 977 bridge_configure_flow_eviction_threshold(struct bridge *br)
 978 {
 979     const char *threshold_str;
 980     unsigned threshold;
 981
 982     threshold_str = bridge_get_other_config(br->cfg, "flow-eviction-threshold");
 983     if (threshold_str) {
 984         threshold = strtoul(threshold_str, NULL, 10);
 985     } else {
 986         threshold = OFPROTO_FLOW_EVICTON_THRESHOLD_DEFAULT;
 987     }
 988     ofproto_set_flow_eviction_threshold(br->ofproto, threshold);
 989 }
 990
 991 static void
 992 bridge_pick_local_hw_addr(struct bridge *br, uint8_t ea[ETH_ADDR_LEN],
 993                           struct iface **hw_addr_iface)
 994 {
 995     const char *hwaddr;
 996     struct port *port;
 997     int error;
 998
 999     *hw_addr_iface = NULL;
1000
1001     /* Did the user request a particular MAC? */
1002     hwaddr = bridge_get_other_config(br->cfg, "hwaddr");
1003     if (hwaddr && eth_addr_from_string(hwaddr, ea)) {
1004         if (eth_addr_is_multicast(ea)) {
1005             VLOG_ERR("bridge %s: cannot set MAC address to multicast "
1006                      "address "ETH_ADDR_FMT, br->name, ETH_ADDR_ARGS(ea));
1007         } else if (eth_addr_is_zero(ea)) {
1008             VLOG_ERR("bridge %s: cannot set MAC address to zero", br->name);
1009         } else {
1010             return;
1011         }
1012     }
1013
1014     /* Otherwise choose the minimum non-local MAC address among all of the
1015      * interfaces. */
1016     memset(ea, 0xff, ETH_ADDR_LEN);
1017     HMAP_FOR_EACH (port, hmap_node, &br->ports) {
1018         uint8_t iface_ea[ETH_ADDR_LEN];
1019         struct iface *candidate;
1020         struct iface *iface;
1021
1022         /* Mirror output ports don't participate. */
1023         if (ofproto_is_mirror_output_bundle(br->ofproto, port)) {
1024             continue;
1025         }
1026
1027         /* Choose the MAC address to represent the port. */
1028         iface = NULL;
1029         if (port->cfg->mac && eth_addr_from_string(port->cfg->mac, iface_ea)) {
1030             /* Find the interface with this Ethernet address (if any) so that
1031              * we can provide the correct devname to the caller. */
1032             LIST_FOR_EACH (candidate, port_elem, &port->ifaces) {
1033                 uint8_t candidate_ea[ETH_ADDR_LEN];
1034                 if (!netdev_get_etheraddr(candidate->netdev, candidate_ea)
1035                     && eth_addr_equals(iface_ea, candidate_ea)) {
1036                     iface = candidate;
1037                 }
1038             }
1039         } else {
1040             /* Choose the interface whose MAC address will represent the port.
1041              * The Linux kernel bonding code always chooses the MAC address of
1042              * the first slave added to a bond, and the Fedora networking
1043              * scripts always add slaves to a bond in alphabetical order, so
1044              * for compatibility we choose the interface with the name that is
1045              * first in alphabetical order. */
1046             LIST_FOR_EACH (candidate, port_elem, &port->ifaces) {
1047                 if (!iface || strcmp(candidate->name, iface->name) < 0) {
1048                     iface = candidate;
1049                 }
1050             }
1051
1052             /* The local port doesn't count (since we're trying to choose its
1053              * MAC address anyway). */
1054             if (iface->ofp_port == OFPP_LOCAL) {
1055                 continue;
1056             }
1057
1058             /* Grab MAC. */
1059             error = netdev_get_etheraddr(iface->netdev, iface_ea);
1060             if (error) {
1061                 continue;
1062             }
1063         }
1064
1065         /* Compare against our current choice. */
1066         if (!eth_addr_is_multicast(iface_ea) &&
1067             !eth_addr_is_local(iface_ea) &&
1068             !eth_addr_is_reserved(iface_ea) &&
1069             !eth_addr_is_zero(iface_ea) &&
1070             eth_addr_compare_3way(iface_ea, ea) < 0)
1071         {
1072             memcpy(ea, iface_ea, ETH_ADDR_LEN);
1073             *hw_addr_iface = iface;
1074         }
1075     }
1076     if (eth_addr_is_multicast(ea)) {
1077         memcpy(ea, br->default_ea, ETH_ADDR_LEN);
1078         *hw_addr_iface = NULL;
1079         VLOG_WARN("bridge %s: using default bridge Ethernet "
1080                   "address "ETH_ADDR_FMT, br->name, ETH_ADDR_ARGS(ea));
1081     } else {
1082         VLOG_DBG("bridge %s: using bridge Ethernet address "ETH_ADDR_FMT,
1083                  br->name, ETH_ADDR_ARGS(ea));
1084     }
1085 }
1086
1087 /* Choose and returns the datapath ID for bridge 'br' given that the bridge
1088  * Ethernet address is 'bridge_ea'.  If 'bridge_ea' is the Ethernet address of
1089  * an interface on 'br', then that interface must be passed in as
1090  * 'hw_addr_iface'; if 'bridge_ea' was derived some other way, then
1091  * 'hw_addr_iface' must be passed in as a null pointer. */
1092 static uint64_t
1093 bridge_pick_datapath_id(struct bridge *br,
1094                         const uint8_t bridge_ea[ETH_ADDR_LEN],
1095                         struct iface *hw_addr_iface)
1096 {
1097     /*
1098      * The procedure for choosing a bridge MAC address will, in the most
1099      * ordinary case, also choose a unique MAC that we can use as a datapath
1100      * ID.  In some special cases, though, multiple bridges will end up with
1101      * the same MAC address.  This is OK for the bridges, but it will confuse
1102      * the OpenFlow controller, because each datapath needs a unique datapath
1103      * ID.
1104      *
1105      * Datapath IDs must be unique.  It is also very desirable that they be
1106      * stable from one run to the next, so that policy set on a datapath
1107      * "sticks".
1108      */
1109     const char *datapath_id;
1110     uint64_t dpid;
1111
1112     datapath_id = bridge_get_other_config(br->cfg, "datapath-id");
1113     if (datapath_id && dpid_from_string(datapath_id, &dpid)) {
1114         return dpid;
1115     }
1116
1117     if (hw_addr_iface) {
1118         int vlan;
1119         if (!netdev_get_vlan_vid(hw_addr_iface->netdev, &vlan)) {
1120             /*
1121              * A bridge whose MAC address is taken from a VLAN network device
1122              * (that is, a network device created with vconfig(8) or similar
1123              * tool) will have the same MAC address as a bridge on the VLAN
1124              * device's physical network device.
1125              *
1126              * Handle this case by hashing the physical network device MAC
1127              * along with the VLAN identifier.
1128              */
1129             uint8_t buf[ETH_ADDR_LEN + 2];
1130             memcpy(buf, bridge_ea, ETH_ADDR_LEN);
1131             buf[ETH_ADDR_LEN] = vlan >> 8;
1132             buf[ETH_ADDR_LEN + 1] = vlan;
1133             return dpid_from_hash(buf, sizeof buf);
1134         } else {
1135             /*
1136              * Assume that this bridge's MAC address is unique, since it
1137              * doesn't fit any of the cases we handle specially.
1138              */
1139         }
1140     } else {
1141         /*
1142          * A purely internal bridge, that is, one that has no non-virtual
1143          * network devices on it at all, is more difficult because it has no
1144          * natural unique identifier at all.
1145          *
1146          * When the host is a XenServer, we handle this case by hashing the
1147          * host's UUID with the name of the bridge.  Names of bridges are
1148          * persistent across XenServer reboots, although they can be reused if
1149          * an internal network is destroyed and then a new one is later
1150          * created, so this is fairly effective.
1151          *
1152          * When the host is not a XenServer, we punt by using a random MAC
1153          * address on each run.
1154          */
1155         const char *host_uuid = xenserver_get_host_uuid();
1156         if (host_uuid) {
1157             char *combined = xasprintf("%s,%s", host_uuid, br->name);
1158             dpid = dpid_from_hash(combined, strlen(combined));
1159             free(combined);
1160             return dpid;
1161         }
1162     }
1163
1164     return eth_addr_to_uint64(bridge_ea);
1165 }
1166
1167 static uint64_t
1168 dpid_from_hash(const void *data, size_t n)
1169 {
1170     uint8_t hash[SHA1_DIGEST_SIZE];
1171
1172     BUILD_ASSERT_DECL(sizeof hash >= ETH_ADDR_LEN);
1173     sha1_bytes(data, n, hash);
1174     eth_addr_mark_random(hash);
1175     return eth_addr_to_uint64(hash);
1176 }
1177
1178 static void
1179 iface_refresh_status(struct iface *iface)
1180 {
1181     struct shash sh;
1182
1183     enum netdev_flags flags;
1184     uint32_t current;
1185     int64_t bps;
1186     int mtu;
1187     int64_t mtu_64;
1188     int error;
1189
1190     if (iface_is_synthetic(iface)) {
1191         return;
1192     }
1193
1194     shash_init(&sh);
1195
1196     if (!netdev_get_status(iface->netdev, &sh)) {
1197         size_t n;
1198         char **keys, **values;
1199
1200         shash_to_ovs_idl_map(&sh, &keys, &values, &n);
1201         ovsrec_interface_set_status(iface->cfg, keys, values, n);
1202
1203         free(keys);
1204         free(values);
1205     } else {
1206         ovsrec_interface_set_status(iface->cfg, NULL, NULL, 0);
1207     }
1208
1209     shash_destroy_free_data(&sh);
1210
1211     error = netdev_get_flags(iface->netdev, &flags);
1212     if (!error) {
1213         ovsrec_interface_set_admin_state(iface->cfg, flags & NETDEV_UP ? "up" : "down");
1214     }
1215     else {
1216         ovsrec_interface_set_admin_state(iface->cfg, NULL);
1217     }
1218
1219     error = netdev_get_features(iface->netdev, &current, NULL, NULL, NULL);
1220     if (!error) {
1221         ovsrec_interface_set_duplex(iface->cfg,
1222                                     netdev_features_is_full_duplex(current)
1223                                     ? "full" : "half");
1224         /* warning: uint64_t -> int64_t conversion */
1225         bps = netdev_features_to_bps(current);
1226         ovsrec_interface_set_link_speed(iface->cfg, &bps, 1);
1227     }
1228     else {
1229         ovsrec_interface_set_duplex(iface->cfg, NULL);
1230         ovsrec_interface_set_link_speed(iface->cfg, NULL, 0);
1231     }
1232
1233     ovsrec_interface_set_link_state(iface->cfg,
1234                                     iface_get_carrier(iface) ? "up" : "down");
1235
1236     error = netdev_get_mtu(iface->netdev, &mtu);
1237     if (!error && mtu != INT_MAX) {
1238         mtu_64 = mtu;
1239         ovsrec_interface_set_mtu(iface->cfg, &mtu_64, 1);
1240     }
1241     else {
1242         ovsrec_interface_set_mtu(iface->cfg, NULL, 0);
1243     }
1244 }
1245
1246 /* Writes 'iface''s CFM statistics to the database.  Returns true if anything
1247  * changed, false otherwise. */
1248 static bool
1249 iface_refresh_cfm_stats(struct iface *iface)
1250 {
1251     const struct ovsrec_interface *cfg = iface->cfg;
1252     bool changed = false;
1253     int fault;
1254
1255     fault = ofproto_port_get_cfm_fault(iface->port->bridge->ofproto,
1256                                        iface->ofp_port);
1257
1258     if (fault < 0) {
1259         return false;
1260     }
1261
1262     if (cfg->n_cfm_fault != 1 || cfg->cfm_fault[0] != fault) {
1263         bool fault_bool = fault;
1264         ovsrec_interface_set_cfm_fault(cfg, &fault_bool, 1);
1265         changed = true;
1266     }
1267
1268     return changed;
1269 }
1270
1271 static bool
1272 iface_refresh_lacp_stats(struct iface *iface)
1273 {
1274     struct ofproto *ofproto = iface->port->bridge->ofproto;
1275     int old = iface->cfg->lacp_current ? *iface->cfg->lacp_current : -1;
1276     int new = ofproto_port_is_lacp_current(ofproto, iface->ofp_port);
1277
1278     if (old != new) {
1279         bool current = new;
1280         ovsrec_interface_set_lacp_current(iface->cfg, &current, new >= 0);
1281     }
1282     return old != new;
1283 }
1284
1285 static void
1286 iface_refresh_stats(struct iface *iface)
1287 {
1288 #define IFACE_STATS                             \
1289     IFACE_STAT(rx_packets,      "rx_packets")   \
1290     IFACE_STAT(tx_packets,      "tx_packets")   \
1291     IFACE_STAT(rx_bytes,        "rx_bytes")     \
1292     IFACE_STAT(tx_bytes,        "tx_bytes")     \
1293     IFACE_STAT(rx_dropped,      "rx_dropped")   \
1294     IFACE_STAT(tx_dropped,      "tx_dropped")   \
1295     IFACE_STAT(rx_errors,       "rx_errors")    \
1296     IFACE_STAT(tx_errors,       "tx_errors")    \
1297     IFACE_STAT(rx_frame_errors, "rx_frame_err") \
1298     IFACE_STAT(rx_over_errors,  "rx_over_err")  \
1299     IFACE_STAT(rx_crc_errors,   "rx_crc_err")   \
1300     IFACE_STAT(collisions,      "collisions")
1301
1302 #define IFACE_STAT(MEMBER, NAME) NAME,
1303     static char *keys[] = { IFACE_STATS };
1304 #undef IFACE_STAT
1305     int64_t values[ARRAY_SIZE(keys)];
1306     int i;
1307
1308     struct netdev_stats stats;
1309
1310     if (iface_is_synthetic(iface)) {
1311         return;
1312     }
1313
1314     /* Intentionally ignore return value, since errors will set 'stats' to
1315      * all-1s, and we will deal with that correctly below. */
1316     netdev_get_stats(iface->netdev, &stats);
1317
1318     /* Copy statistics into values[] array. */
1319     i = 0;
1320 #define IFACE_STAT(MEMBER, NAME) values[i++] = stats.MEMBER;
1321     IFACE_STATS;
1322 #undef IFACE_STAT
1323     assert(i == ARRAY_SIZE(keys));
1324
1325     ovsrec_interface_set_statistics(iface->cfg, keys, values, ARRAY_SIZE(keys));
1326 #undef IFACE_STATS
1327 }
1328
1329 static bool
1330 enable_system_stats(const struct ovsrec_open_vswitch *cfg)
1331 {
1332     const char *enable;
1333
1334     /* Use other-config:enable-system-stats by preference. */
1335     enable = get_ovsrec_key_value(&cfg->header_,
1336                                   &ovsrec_open_vswitch_col_other_config,
1337                                   "enable-statistics");
1338     if (enable) {
1339         return !strcmp(enable, "true");
1340     }
1341
1342     /* Disable by default. */
1343     return false;
1344 }
1345
1346 static void
1347 refresh_system_stats(const struct ovsrec_open_vswitch *cfg)
1348 {
1349     struct ovsdb_datum datum;
1350     struct shash stats;
1351
1352     shash_init(&stats);
1353     if (enable_system_stats(cfg)) {
1354         get_system_stats(&stats);
1355     }
1356
1357     ovsdb_datum_from_shash(&datum, &stats);
1358     ovsdb_idl_txn_write(&cfg->header_, &ovsrec_open_vswitch_col_statistics,
1359                         &datum);
1360 }
1361
1362 static inline const char *
1363 nx_role_to_str(enum nx_role role)
1364 {
1365     switch (role) {
1366     case NX_ROLE_OTHER:
1367         return "other";
1368     case NX_ROLE_MASTER:
1369         return "master";
1370     case NX_ROLE_SLAVE:
1371         return "slave";
1372     default:
1373         return "*** INVALID ROLE ***";
1374     }
1375 }
1376
1377 static void
1378 refresh_controller_status(void)
1379 {
1380     struct bridge *br;
1381     struct shash info;
1382     const struct ovsrec_controller *cfg;
1383
1384     shash_init(&info);
1385
1386     /* Accumulate status for controllers on all bridges. */
1387     HMAP_FOR_EACH (br, node, &all_bridges) {
1388         ofproto_get_ofproto_controller_info(br->ofproto, &info);
1389     }
1390
1391     /* Update each controller in the database with current status. */
1392     OVSREC_CONTROLLER_FOR_EACH(cfg, idl) {
1393         struct ofproto_controller_info *cinfo =
1394             shash_find_data(&info, cfg->target);
1395
1396         if (cinfo) {
1397             ovsrec_controller_set_is_connected(cfg, cinfo->is_connected);
1398             ovsrec_controller_set_role(cfg, nx_role_to_str(cinfo->role));
1399             ovsrec_controller_set_status(cfg, (char **) cinfo->pairs.keys,
1400                                          (char **) cinfo->pairs.values,
1401                                          cinfo->pairs.n);
1402         } else {
1403             ovsrec_controller_set_is_connected(cfg, false);
1404             ovsrec_controller_set_role(cfg, NULL);
1405             ovsrec_controller_set_status(cfg, NULL, NULL, 0);
1406         }
1407     }
1408
1409     ofproto_free_ofproto_controller_info(&info);
1410 }
1411
1412 void
1413 bridge_run(void)
1414 {
1415     const struct ovsrec_open_vswitch *cfg;
1416
1417     bool datapath_destroyed;
1418     bool database_changed;
1419     struct bridge *br;
1420
1421     /* (Re)configure if necessary. */
1422     database_changed = ovsdb_idl_run(idl);
1423     if (ovsdb_idl_is_lock_contended(idl)) {
1424         static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 1);
1425         struct bridge *br, *next_br;
1426
1427         VLOG_ERR_RL(&rl, "another ovs-vswitchd process is running, "
1428                     "disabling this process until it goes away");
1429
1430         HMAP_FOR_EACH_SAFE (br, next_br, node, &all_bridges) {
1431             bridge_destroy(br);
1432         }
1433         return;
1434     } else if (!ovsdb_idl_has_lock(idl)) {
1435         return;
1436     }
1437     cfg = ovsrec_open_vswitch_first(idl);
1438
1439     /* Let each bridge do the work that it needs to do. */
1440     datapath_destroyed = false;
1441     HMAP_FOR_EACH (br, node, &all_bridges) {
1442         int error = ofproto_run(br->ofproto);
1443         if (error) {
1444             static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
1445             VLOG_ERR_RL(&rl, "bridge %s: datapath was destroyed externally, "
1446                         "forcing reconfiguration", br->name);
1447             datapath_destroyed = true;
1448         }
1449     }
1450
1451     /* Re-configure SSL.  We do this on every trip through the main loop,
1452      * instead of just when the database changes, because the contents of the
1453      * key and certificate files can change without the database changing.
1454      *
1455      * We do this before bridge_reconfigure() because that function might
1456      * initiate SSL connections and thus requires SSL to be configured. */
1457     if (cfg && cfg->ssl) {
1458         const struct ovsrec_ssl *ssl = cfg->ssl;
1459
1460         stream_ssl_set_key_and_cert(ssl->private_key, ssl->certificate);
1461         stream_ssl_set_ca_cert_file(ssl->ca_cert, ssl->bootstrap_ca_cert);
1462     }
1463
1464     if (database_changed || datapath_destroyed) {
1465         if (cfg) {
1466             struct ovsdb_idl_txn *txn = ovsdb_idl_txn_create(idl);
1467
1468             bridge_reconfigure(cfg);
1469
1470             ovsrec_open_vswitch_set_cur_cfg(cfg, cfg->next_cfg);
1471             ovsdb_idl_txn_commit(txn);
1472             ovsdb_idl_txn_destroy(txn); /* XXX */
1473         } else {
1474             /* We still need to reconfigure to avoid dangling pointers to
1475              * now-destroyed ovsrec structures inside bridge data. */
1476             static const struct ovsrec_open_vswitch null_cfg;
1477
1478             bridge_reconfigure(&null_cfg);
1479         }
1480     }
1481
1482     /* Refresh system and interface stats if necessary. */
1483     if (time_msec() >= stats_timer) {
1484         if (cfg) {
1485             struct ovsdb_idl_txn *txn;
1486
1487             txn = ovsdb_idl_txn_create(idl);
1488             HMAP_FOR_EACH (br, node, &all_bridges) {
1489                 struct port *port;
1490
1491                 HMAP_FOR_EACH (port, hmap_node, &br->ports) {
1492                     struct iface *iface;
1493
1494                     LIST_FOR_EACH (iface, port_elem, &port->ifaces) {
1495                         iface_refresh_stats(iface);
1496                         iface_refresh_status(iface);
1497                     }
1498                 }
1499             }
1500             refresh_system_stats(cfg);
1501             refresh_controller_status();
1502             ovsdb_idl_txn_commit(txn);
1503             ovsdb_idl_txn_destroy(txn); /* XXX */
1504         }
1505
1506         stats_timer = time_msec() + STATS_INTERVAL;
1507     }
1508
1509     if (time_msec() >= db_limiter) {
1510         struct ovsdb_idl_txn *txn;
1511         bool changed = false;
1512
1513         txn = ovsdb_idl_txn_create(idl);
1514         HMAP_FOR_EACH (br, node, &all_bridges) {
1515             struct port *port;
1516
1517             HMAP_FOR_EACH (port, hmap_node, &br->ports) {
1518                 struct iface *iface;
1519
1520                 LIST_FOR_EACH (iface, port_elem, &port->ifaces) {
1521                     changed = iface_refresh_cfm_stats(iface) || changed;
1522                     changed = iface_refresh_lacp_stats(iface) || changed;
1523                 }
1524             }
1525         }
1526
1527         if (changed) {
1528             db_limiter = time_msec() + DB_LIMIT_INTERVAL;
1529         }
1530
1531         ovsdb_idl_txn_commit(txn);
1532         ovsdb_idl_txn_destroy(txn);
1533     }
1534 }
1535
1536 void
1537 bridge_wait(void)
1538 {
1539     ovsdb_idl_wait(idl);
1540     if (!hmap_is_empty(&all_bridges)) {
1541         struct bridge *br;
1542
1543         HMAP_FOR_EACH (br, node, &all_bridges) {
1544             ofproto_wait(br->ofproto);
1545         }
1546         poll_timer_wait_until(stats_timer);
1547
1548         if (db_limiter > time_msec()) {
1549             poll_timer_wait_until(db_limiter);
1550         }
1551     }
1552 }
1553 \f
1554 /* QoS unixctl user interface functions. */
1555
1556 struct qos_unixctl_show_cbdata {
1557     struct ds *ds;
1558     struct iface *iface;
1559 };
1560
1561 static void
1562 qos_unixctl_show_cb(unsigned int queue_id,
1563                     const struct shash *details,
1564                     void *aux)
1565 {
1566     struct qos_unixctl_show_cbdata *data = aux;
1567     struct ds *ds = data->ds;
1568     struct iface *iface = data->iface;
1569     struct netdev_queue_stats stats;
1570     struct shash_node *node;
1571     int error;
1572
1573     ds_put_cstr(ds, "\n");
1574     if (queue_id) {
1575         ds_put_format(ds, "Queue %u:\n", queue_id);
1576     } else {
1577         ds_put_cstr(ds, "Default:\n");
1578     }
1579
1580     SHASH_FOR_EACH (node, details) {
1581         ds_put_format(ds, "\t%s: %s\n", node->name, (char *)node->data);
1582     }
1583
1584     error = netdev_get_queue_stats(iface->netdev, queue_id, &stats);
1585     if (!error) {
1586         if (stats.tx_packets != UINT64_MAX) {
1587             ds_put_format(ds, "\ttx_packets: %"PRIu64"\n", stats.tx_packets);
1588         }
1589
1590         if (stats.tx_bytes != UINT64_MAX) {
1591             ds_put_format(ds, "\ttx_bytes: %"PRIu64"\n", stats.tx_bytes);
1592         }
1593
1594         if (stats.tx_errors != UINT64_MAX) {
1595             ds_put_format(ds, "\ttx_errors: %"PRIu64"\n", stats.tx_errors);
1596         }
1597     } else {
1598         ds_put_format(ds, "\tFailed to get statistics for queue %u: %s",
1599                       queue_id, strerror(error));
1600     }
1601 }
1602
1603 static void
1604 qos_unixctl_show(struct unixctl_conn *conn,
1605                  const char *args, void *aux OVS_UNUSED)
1606 {
1607     struct ds ds = DS_EMPTY_INITIALIZER;
1608     struct shash sh = SHASH_INITIALIZER(&sh);
1609     struct iface *iface;
1610     const char *type;
1611     struct shash_node *node;
1612     struct qos_unixctl_show_cbdata data;
1613     int error;
1614
1615     iface = iface_find(args);
1616     if (!iface) {
1617         unixctl_command_reply(conn, 501, "no such interface");
1618         return;
1619     }
1620
1621     netdev_get_qos(iface->netdev, &type, &sh);
1622
1623     if (*type != '\0') {
1624         ds_put_format(&ds, "QoS: %s %s\n", iface->name, type);
1625
1626         SHASH_FOR_EACH (node, &sh) {
1627             ds_put_format(&ds, "%s: %s\n", node->name, (char *)node->data);
1628         }
1629
1630         data.ds = &ds;
1631         data.iface = iface;
1632         error = netdev_dump_queues(iface->netdev, qos_unixctl_show_cb, &data);
1633
1634         if (error) {
1635             ds_put_format(&ds, "failed to dump queues: %s", strerror(error));
1636         }
1637         unixctl_command_reply(conn, 200, ds_cstr(&ds));
1638     } else {
1639         ds_put_format(&ds, "QoS not configured on %s\n", iface->name);
1640         unixctl_command_reply(conn, 501, ds_cstr(&ds));
1641     }
1642
1643     shash_destroy_free_data(&sh);
1644     ds_destroy(&ds);
1645 }
1646 \f
1647 /* Bridge reconfiguration functions. */
1648 static void
1649 bridge_create(const struct ovsrec_bridge *br_cfg)
1650 {
1651     struct bridge *br;
1652
1653     assert(!bridge_lookup(br_cfg->name));
1654     br = xzalloc(sizeof *br);
1655
1656     br->name = xstrdup(br_cfg->name);
1657     br->type = xstrdup(ofproto_normalize_type(br_cfg->datapath_type));
1658     br->cfg = br_cfg;
1659
1660     /* Derive the default Ethernet address from the bridge's UUID.  This should
1661      * be unique and it will be stable between ovs-vswitchd runs.  */
1662     memcpy(br->default_ea, &br_cfg->header_.uuid, ETH_ADDR_LEN);
1663     eth_addr_mark_random(br->default_ea);
1664
1665     hmap_init(&br->ports);
1666     hmap_init(&br->ifaces);
1667     hmap_init(&br->iface_by_name);
1668     hmap_init(&br->mirrors);
1669
1670     hmap_insert(&all_bridges, &br->node, hash_string(br->name, 0));
1671 }
1672
1673 static void
1674 bridge_destroy(struct bridge *br)
1675 {
1676     if (br) {
1677         struct mirror *mirror, *next_mirror;
1678         struct port *port, *next_port;
1679
1680         HMAP_FOR_EACH_SAFE (port, next_port, hmap_node, &br->ports) {
1681             port_destroy(port);
1682         }
1683         HMAP_FOR_EACH_SAFE (mirror, next_mirror, hmap_node, &br->mirrors) {
1684             mirror_destroy(mirror);
1685         }
1686         hmap_remove(&all_bridges, &br->node);
1687         ofproto_destroy(br->ofproto);
1688         hmap_destroy(&br->ifaces);
1689         hmap_destroy(&br->ports);
1690         hmap_destroy(&br->iface_by_name);
1691         hmap_destroy(&br->mirrors);
1692         free(br->name);
1693         free(br->type);
1694         free(br);
1695     }
1696 }
1697
1698 static struct bridge *
1699 bridge_lookup(const char *name)
1700 {
1701     struct bridge *br;
1702
1703     HMAP_FOR_EACH_WITH_HASH (br, node, hash_string(name, 0), &all_bridges) {
1704         if (!strcmp(br->name, name)) {
1705             return br;
1706         }
1707     }
1708     return NULL;
1709 }
1710
1711 /* Handle requests for a listing of all flows known by the OpenFlow
1712  * stack, including those normally hidden. */
1713 static void
1714 bridge_unixctl_dump_flows(struct unixctl_conn *conn,
1715                           const char *args, void *aux OVS_UNUSED)
1716 {
1717     struct bridge *br;
1718     struct ds results;
1719
1720     br = bridge_lookup(args);
1721     if (!br) {
1722         unixctl_command_reply(conn, 501, "Unknown bridge");
1723         return;
1724     }
1725
1726     ds_init(&results);
1727     ofproto_get_all_flows(br->ofproto, &results);
1728
1729     unixctl_command_reply(conn, 200, ds_cstr(&results));
1730     ds_destroy(&results);
1731 }
1732
1733 /* "bridge/reconnect [BRIDGE]": makes BRIDGE drop all of its controller
1734  * connections and reconnect.  If BRIDGE is not specified, then all bridges
1735  * drop their controller connections and reconnect. */
1736 static void
1737 bridge_unixctl_reconnect(struct unixctl_conn *conn,
1738                          const char *args, void *aux OVS_UNUSED)
1739 {
1740     struct bridge *br;
1741     if (args[0] != '\0') {
1742         br = bridge_lookup(args);
1743         if (!br) {
1744             unixctl_command_reply(conn, 501, "Unknown bridge");
1745             return;
1746         }
1747         ofproto_reconnect_controllers(br->ofproto);
1748     } else {
1749         HMAP_FOR_EACH (br, node, &all_bridges) {
1750             ofproto_reconnect_controllers(br->ofproto);
1751         }
1752     }
1753     unixctl_command_reply(conn, 200, NULL);
1754 }
1755
1756 static size_t
1757 bridge_get_controllers(const struct bridge *br,
1758                        struct ovsrec_controller ***controllersp)
1759 {
1760     struct ovsrec_controller **controllers;
1761     size_t n_controllers;
1762
1763     controllers = br->cfg->controller;
1764     n_controllers = br->cfg->n_controller;
1765
1766     if (n_controllers == 1 && !strcmp(controllers[0]->target, "none")) {
1767         controllers = NULL;
1768         n_controllers = 0;
1769     }
1770
1771     if (controllersp) {
1772         *controllersp = controllers;
1773     }
1774     return n_controllers;
1775 }
1776
1777 /* Adds and deletes "struct port"s and "struct iface"s under 'br' to match
1778  * those configured in 'br->cfg'. */
1779 static void
1780 bridge_add_del_ports(struct bridge *br)
1781 {
1782     struct port *port, *next;
1783     struct shash_node *node;
1784     struct shash new_ports;
1785     size_t i;
1786
1787     /* Collect new ports. */
1788     shash_init(&new_ports);
1789     for (i = 0; i < br->cfg->n_ports; i++) {
1790         const char *name = br->cfg->ports[i]->name;
1791         if (!shash_add_once(&new_ports, name, br->cfg->ports[i])) {
1792             VLOG_WARN("bridge %s: %s specified twice as bridge port",
1793                       br->name, name);
1794         }
1795     }
1796     if (bridge_get_controllers(br, NULL)
1797         && !shash_find(&new_ports, br->name)) {
1798         VLOG_WARN("bridge %s: no port named %s, synthesizing one",
1799                   br->name, br->name);
1800
1801         br->synth_local_port.interfaces = &br->synth_local_ifacep;
1802         br->synth_local_port.n_interfaces = 1;
1803         br->synth_local_port.name = br->name;
1804
1805         br->synth_local_iface.name = br->name;
1806         br->synth_local_iface.type = "internal";
1807
1808         br->synth_local_ifacep = &br->synth_local_iface;
1809
1810         shash_add(&new_ports, br->name, &br->synth_local_port);
1811     }
1812
1813     /* Get rid of deleted ports.
1814      * Get rid of deleted interfaces on ports that still exist.
1815      * Update 'cfg' of ports that still exist. */
1816     HMAP_FOR_EACH_SAFE (port, next, hmap_node, &br->ports) {
1817         port->cfg = shash_find_data(&new_ports, port->name);
1818         if (!port->cfg) {
1819             port_destroy(port);
1820         } else {
1821             port_del_ifaces(port);
1822         }
1823     }
1824
1825     /* Create new ports.
1826      * Add new interfaces to existing ports. */
1827     SHASH_FOR_EACH (node, &new_ports) {
1828         struct port *port = port_lookup(br, node->name);
1829         if (!port) {
1830             struct ovsrec_port *cfg = node->data;
1831             port = port_create(br, cfg);
1832         }
1833         port_add_ifaces(port);
1834         if (list_is_empty(&port->ifaces)) {
1835             VLOG_WARN("bridge %s: port %s has no interfaces, dropping",
1836                       br->name, port->name);
1837             port_destroy(port);
1838         }
1839     }
1840     shash_destroy(&new_ports);
1841 }
1842
1843 /* Initializes 'oc' appropriately as a management service controller for
1844  * 'br'.
1845  *
1846  * The caller must free oc->target when it is no longer needed. */
1847 static void
1848 bridge_ofproto_controller_for_mgmt(const struct bridge *br,
1849                                    struct ofproto_controller *oc)
1850 {
1851     oc->target = xasprintf("punix:%s/%s.mgmt", ovs_rundir(), br->name);
1852     oc->max_backoff = 0;
1853     oc->probe_interval = 60;
1854     oc->band = OFPROTO_OUT_OF_BAND;
1855     oc->rate_limit = 0;
1856     oc->burst_limit = 0;
1857 }
1858
1859 /* Converts ovsrec_controller 'c' into an ofproto_controller in 'oc'.  */
1860 static void
1861 bridge_ofproto_controller_from_ovsrec(const struct ovsrec_controller *c,
1862                                       struct ofproto_controller *oc)
1863 {
1864     oc->target = c->target;
1865     oc->max_backoff = c->max_backoff ? *c->max_backoff / 1000 : 8;
1866     oc->probe_interval = c->inactivity_probe ? *c->inactivity_probe / 1000 : 5;
1867     oc->band = (!c->connection_mode || !strcmp(c->connection_mode, "in-band")
1868                 ? OFPROTO_IN_BAND : OFPROTO_OUT_OF_BAND);
1869     oc->rate_limit = c->controller_rate_limit ? *c->controller_rate_limit : 0;
1870     oc->burst_limit = (c->controller_burst_limit
1871                        ? *c->controller_burst_limit : 0);
1872 }
1873
1874 /* Configures the IP stack for 'br''s local interface properly according to the
1875  * configuration in 'c'.  */
1876 static void
1877 bridge_configure_local_iface_netdev(struct bridge *br,
1878                                     struct ovsrec_controller *c)
1879 {
1880     struct netdev *netdev;
1881     struct in_addr mask, gateway;
1882
1883     struct iface *local_iface;
1884     struct in_addr ip;
1885
1886     /* If there's no local interface or no IP address, give up. */
1887     local_iface = iface_from_ofp_port(br, OFPP_LOCAL);
1888     if (!local_iface || !c->local_ip || !inet_aton(c->local_ip, &ip)) {
1889         return;
1890     }
1891
1892     /* Bring up the local interface. */
1893     netdev = local_iface->netdev;
1894     netdev_turn_flags_on(netdev, NETDEV_UP, true);
1895
1896     /* Configure the IP address and netmask. */
1897     if (!c->local_netmask
1898         || !inet_aton(c->local_netmask, &mask)
1899         || !mask.s_addr) {
1900         mask.s_addr = guess_netmask(ip.s_addr);
1901     }
1902     if (!netdev_set_in4(netdev, ip, mask)) {
1903         VLOG_INFO("bridge %s: configured IP address "IP_FMT", netmask "IP_FMT,
1904                   br->name, IP_ARGS(&ip.s_addr), IP_ARGS(&mask.s_addr));
1905     }
1906
1907     /* Configure the default gateway. */
1908     if (c->local_gateway
1909         && inet_aton(c->local_gateway, &gateway)
1910         && gateway.s_addr) {
1911         if (!netdev_add_router(netdev, gateway)) {
1912             VLOG_INFO("bridge %s: configured gateway "IP_FMT,
1913                       br->name, IP_ARGS(&gateway.s_addr));
1914         }
1915     }
1916 }
1917
1918 static void
1919 bridge_configure_remotes(struct bridge *br,
1920                          const struct sockaddr_in *managers, size_t n_managers)
1921 {
1922     const char *disable_ib_str, *queue_id_str;
1923     bool disable_in_band = false;
1924     int queue_id;
1925
1926     struct ovsrec_controller **controllers;
1927     size_t n_controllers;
1928
1929     enum ofproto_fail_mode fail_mode;
1930
1931     struct ofproto_controller *ocs;
1932     size_t n_ocs;
1933     size_t i;
1934
1935     /* Check if we should disable in-band control on this bridge. */
1936     disable_ib_str = bridge_get_other_config(br->cfg, "disable-in-band");
1937     if (disable_ib_str && !strcmp(disable_ib_str, "true")) {
1938         disable_in_band = true;
1939     }
1940
1941     /* Set OpenFlow queue ID for in-band control. */
1942     queue_id_str = bridge_get_other_config(br->cfg, "in-band-queue");
1943     queue_id = queue_id_str ? strtol(queue_id_str, NULL, 10) : -1;
1944     ofproto_set_in_band_queue(br->ofproto, queue_id);
1945
1946     if (disable_in_band) {
1947         ofproto_set_extra_in_band_remotes(br->ofproto, NULL, 0);
1948     } else {
1949         ofproto_set_extra_in_band_remotes(br->ofproto, managers, n_managers);
1950     }
1951
1952     n_controllers = bridge_get_controllers(br, &controllers);
1953
1954     ocs = xmalloc((n_controllers + 1) * sizeof *ocs);
1955     n_ocs = 0;
1956
1957     bridge_ofproto_controller_for_mgmt(br, &ocs[n_ocs++]);
1958     for (i = 0; i < n_controllers; i++) {
1959         struct ovsrec_controller *c = controllers[i];
1960
1961         if (!strncmp(c->target, "punix:", 6)
1962             || !strncmp(c->target, "unix:", 5)) {
1963             static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
1964
1965             /* Prevent remote ovsdb-server users from accessing arbitrary Unix
1966              * domain sockets and overwriting arbitrary local files. */
1967             VLOG_ERR_RL(&rl, "bridge %s: not adding Unix domain socket "
1968                         "controller \"%s\" due to possibility for remote "
1969                         "exploit", br->name, c->target);
1970             continue;
1971         }
1972
1973         bridge_configure_local_iface_netdev(br, c);
1974         bridge_ofproto_controller_from_ovsrec(c, &ocs[n_ocs]);
1975         if (disable_in_band) {
1976             ocs[n_ocs].band = OFPROTO_OUT_OF_BAND;
1977         }
1978         n_ocs++;
1979     }
1980
1981     ofproto_set_controllers(br->ofproto, ocs, n_ocs);
1982     free(ocs[0].target); /* From bridge_ofproto_controller_for_mgmt(). */
1983     free(ocs);
1984
1985     /* Set the fail-mode. */
1986     fail_mode = !br->cfg->fail_mode
1987                 || !strcmp(br->cfg->fail_mode, "standalone")
1988                     ? OFPROTO_FAIL_STANDALONE
1989                     : OFPROTO_FAIL_SECURE;
1990     ofproto_set_fail_mode(br->ofproto, fail_mode);
1991
1992     /* Configure OpenFlow controller connection snooping. */
1993     if (!ofproto_has_snoops(br->ofproto)) {
1994         struct sset snoops;
1995
1996         sset_init(&snoops);
1997         sset_add_and_free(&snoops, xasprintf("punix:%s/%s.snoop",
1998                                              ovs_rundir(), br->name));
1999         ofproto_set_snoops(br->ofproto, &snoops);
2000         sset_destroy(&snoops);
2001     }
2002 }
2003 \f
2004 /* Port functions. */
2005
2006 static struct port *
2007 port_create(struct bridge *br, const struct ovsrec_port *cfg)
2008 {
2009     struct port *port;
2010
2011     port = xzalloc(sizeof *port);
2012     port->bridge = br;
2013     port->name = xstrdup(cfg->name);
2014     port->cfg = cfg;
2015     list_init(&port->ifaces);
2016
2017     hmap_insert(&br->ports, &port->hmap_node, hash_string(port->name, 0));
2018
2019     VLOG_INFO("created port %s on bridge %s", port->name, br->name);
2020
2021     return port;
2022 }
2023
2024 static const char *
2025 get_port_other_config(const struct ovsrec_port *port, const char *key,
2026                       const char *default_value)
2027 {
2028     const char *value;
2029
2030     value = get_ovsrec_key_value(&port->header_, &ovsrec_port_col_other_config,
2031                                  key);
2032     return value ? value : default_value;
2033 }
2034
2035 static const char *
2036 get_interface_other_config(const struct ovsrec_interface *iface,
2037                            const char *key, const char *default_value)
2038 {
2039     const char *value;
2040
2041     value = get_ovsrec_key_value(&iface->header_,
2042                                  &ovsrec_interface_col_other_config, key);
2043     return value ? value : default_value;
2044 }
2045
2046 /* Deletes interfaces from 'port' that are no longer configured for it. */
2047 static void
2048 port_del_ifaces(struct port *port)
2049 {
2050     struct iface *iface, *next;
2051     struct sset new_ifaces;
2052     size_t i;
2053
2054     /* Collect list of new interfaces. */
2055     sset_init(&new_ifaces);
2056     for (i = 0; i < port->cfg->n_interfaces; i++) {
2057         const char *name = port->cfg->interfaces[i]->name;
2058         const char *type = port->cfg->interfaces[i]->name;
2059         if (strcmp(type, "null")) {
2060             sset_add(&new_ifaces, name);
2061         }
2062     }
2063
2064     /* Get rid of deleted interfaces. */
2065     LIST_FOR_EACH_SAFE (iface, next, port_elem, &port->ifaces) {
2066         if (!sset_contains(&new_ifaces, iface->name)) {
2067             iface_destroy(iface);
2068         }
2069     }
2070
2071     sset_destroy(&new_ifaces);
2072 }
2073
2074 /* Adds new interfaces to 'port' and updates 'type' and 'cfg' members of
2075  * existing ones. */
2076 static void
2077 port_add_ifaces(struct port *port)
2078 {
2079     struct shash new_ifaces;
2080     struct shash_node *node;
2081     size_t i;
2082
2083     /* Collect new ifaces. */
2084     shash_init(&new_ifaces);
2085     for (i = 0; i < port->cfg->n_interfaces; i++) {
2086         const struct ovsrec_interface *cfg = port->cfg->interfaces[i];
2087         if (strcmp(cfg->type, "null")
2088             && !shash_add_once(&new_ifaces, cfg->name, cfg)) {
2089             VLOG_WARN("port %s: %s specified twice as port interface",
2090                       port->name, cfg->name);
2091             iface_set_ofport(cfg, -1);
2092         }
2093     }
2094
2095     /* Create new interfaces.
2096      * Update interface types and 'cfg' members. */
2097     SHASH_FOR_EACH (node, &new_ifaces) {
2098         const struct ovsrec_interface *cfg = node->data;
2099         const char *iface_name = node->name;
2100         struct iface *iface;
2101
2102         iface = iface_lookup(port->bridge, iface_name);
2103         if (!iface) {
2104             iface = iface_create(port, cfg);
2105         } else {
2106             iface->cfg = cfg;
2107         }
2108
2109         /* Determine interface type.  The local port always has type
2110          * "internal".  Other ports take their type from the database and
2111          * default to "system" if none is specified. */
2112         iface->type = (!strcmp(iface_name, port->bridge->name) ? "internal"
2113                        : cfg->type[0] ? cfg->type
2114                        : "system");
2115     }
2116     shash_destroy(&new_ifaces);
2117 }
2118
2119 static void
2120 port_destroy(struct port *port)
2121 {
2122     if (port) {
2123         struct bridge *br = port->bridge;
2124         struct iface *iface, *next;
2125
2126         if (br->ofproto) {
2127             ofproto_bundle_unregister(br->ofproto, port);
2128         }
2129
2130         LIST_FOR_EACH_SAFE (iface, next, port_elem, &port->ifaces) {
2131             iface_destroy(iface);
2132         }
2133
2134         hmap_remove(&br->ports, &port->hmap_node);
2135
2136         VLOG_INFO("destroyed port %s on bridge %s", port->name, br->name);
2137
2138         free(port->name);
2139         free(port);
2140     }
2141 }
2142
2143 static struct port *
2144 port_lookup(const struct bridge *br, const char *name)
2145 {
2146     struct port *port;
2147
2148     HMAP_FOR_EACH_WITH_HASH (port, hmap_node, hash_string(name, 0),
2149                              &br->ports) {
2150         if (!strcmp(port->name, name)) {
2151             return port;
2152         }
2153     }
2154     return NULL;
2155 }
2156
2157 static bool
2158 enable_lacp(struct port *port, bool *activep)
2159 {
2160     if (!port->cfg->lacp) {
2161         /* XXX when LACP implementation has been sufficiently tested, enable by
2162          * default and make active on bonded ports. */
2163         return false;
2164     } else if (!strcmp(port->cfg->lacp, "off")) {
2165         return false;
2166     } else if (!strcmp(port->cfg->lacp, "active")) {
2167         *activep = true;
2168         return true;
2169     } else if (!strcmp(port->cfg->lacp, "passive")) {
2170         *activep = false;
2171         return true;
2172     } else {
2173         VLOG_WARN("port %s: unknown LACP mode %s",
2174                   port->name, port->cfg->lacp);
2175         return false;
2176     }
2177 }
2178
2179 static struct lacp_settings *
2180 port_configure_lacp(struct port *port, struct lacp_settings *s)
2181 {
2182     const char *lacp_time;
2183     long long int custom_time;
2184     int priority;
2185
2186     if (!enable_lacp(port, &s->active)) {
2187         return NULL;
2188     }
2189
2190     s->name = port->name;
2191     memcpy(s->id, port->bridge->ea, ETH_ADDR_LEN);
2192
2193     /* Prefer bondable links if unspecified. */
2194     priority = atoi(get_port_other_config(port->cfg, "lacp-system-priority",
2195                                           "0"));
2196     s->priority = (priority > 0 && priority <= UINT16_MAX
2197                    ? priority
2198                    : UINT16_MAX - !list_is_short(&port->ifaces));
2199
2200     s->heartbeat = !strcmp(get_port_other_config(port->cfg,
2201                                                  "lacp-heartbeat",
2202                                                  "false"), "true");
2203
2204
2205     lacp_time = get_port_other_config(port->cfg, "lacp-time", "slow");
2206     custom_time = atoi(lacp_time);
2207     if (!strcmp(lacp_time, "fast")) {
2208         s->lacp_time = LACP_TIME_FAST;
2209     } else if (!strcmp(lacp_time, "slow")) {
2210         s->lacp_time = LACP_TIME_SLOW;
2211     } else if (custom_time > 0) {
2212         s->lacp_time = LACP_TIME_CUSTOM;
2213         s->custom_time = custom_time;
2214     } else {
2215         s->lacp_time = LACP_TIME_SLOW;
2216     }
2217
2218     return s;
2219 }
2220
2221 static void
2222 iface_configure_lacp(struct iface *iface, struct lacp_slave_settings *s)
2223 {
2224     int priority, portid, key;
2225
2226     portid = atoi(get_interface_other_config(iface->cfg, "lacp-port-id", "0"));
2227     priority = atoi(get_interface_other_config(iface->cfg,
2228                                                "lacp-port-priority", "0"));
2229     key = atoi(get_interface_other_config(iface->cfg, "lacp-aggregation-key",
2230                                           "0"));
2231
2232     if (portid <= 0 || portid > UINT16_MAX) {
2233         portid = iface->ofp_port;
2234     }
2235
2236     if (priority <= 0 || priority > UINT16_MAX) {
2237         priority = UINT16_MAX;
2238     }
2239
2240     if (key < 0 || key > UINT16_MAX) {
2241         key = 0;
2242     }
2243
2244     s->name = iface->name;
2245     s->id = portid;
2246     s->priority = priority;
2247     s->key = key;
2248 }
2249
2250 static void
2251 port_configure_bond(struct port *port, struct bond_settings *s,
2252                     uint32_t *bond_stable_ids)
2253 {
2254     const char *detect_s;
2255     struct iface *iface;
2256     int miimon_interval;
2257     size_t i;
2258
2259     s->name = port->name;
2260     s->balance = BM_SLB;
2261     if (port->cfg->bond_mode
2262         && !bond_mode_from_string(&s->balance, port->cfg->bond_mode)) {
2263         VLOG_WARN("port %s: unknown bond_mode %s, defaulting to %s",
2264                   port->name, port->cfg->bond_mode,
2265                   bond_mode_to_string(s->balance));
2266     }
2267     if (s->balance == BM_SLB && port->bridge->cfg->n_flood_vlans) {
2268         VLOG_WARN("port %s: SLB bonds are incompatible with flood_vlans, "
2269                   "please use another bond type or disable flood_vlans",
2270                   port->name);
2271     }
2272
2273     miimon_interval = atoi(get_port_other_config(port->cfg,
2274                                                  "bond-miimon-interval", "0"));
2275     if (miimon_interval <= 0) {
2276         miimon_interval = 200;
2277     }
2278
2279     detect_s = get_port_other_config(port->cfg, "bond-detect-mode", "carrier");
2280     if (!strcmp(detect_s, "carrier")) {
2281         miimon_interval = 0;
2282     } else if (strcmp(detect_s, "miimon")) {
2283         VLOG_WARN("port %s: unsupported bond-detect-mode %s, "
2284                   "defaulting to carrier", port->name, detect_s);
2285         miimon_interval = 0;
2286     }
2287
2288     s->up_delay = MAX(0, port->cfg->bond_updelay);
2289     s->down_delay = MAX(0, port->cfg->bond_downdelay);
2290     s->basis = atoi(get_port_other_config(port->cfg, "bond-hash-basis", "0"));
2291     s->rebalance_interval = atoi(
2292         get_port_other_config(port->cfg, "bond-rebalance-interval", "10000"));
2293     if (s->rebalance_interval < 1000) {
2294         s->rebalance_interval = 1000;
2295     }
2296
2297     s->fake_iface = port->cfg->bond_fake_iface;
2298
2299     i = 0;
2300     LIST_FOR_EACH (iface, port_elem, &port->ifaces) {
2301         long long stable_id;
2302
2303         stable_id = atoll(get_interface_other_config(iface->cfg,
2304                                                      "bond-stable-id", "0"));
2305         if (stable_id <= 0 || stable_id >= UINT32_MAX) {
2306             stable_id = iface->ofp_port;
2307         }
2308         bond_stable_ids[i++] = stable_id;
2309
2310         netdev_set_miimon_interval(iface->netdev, miimon_interval);
2311     }
2312 }
2313 \f
2314 /* Interface functions. */
2315
2316 static struct iface *
2317 iface_create(struct port *port, const struct ovsrec_interface *if_cfg)
2318 {
2319     struct bridge *br = port->bridge;
2320     struct iface *iface;
2321     char *name = if_cfg->name;
2322
2323     iface = xzalloc(sizeof *iface);
2324     iface->port = port;
2325     iface->name = xstrdup(name);
2326     iface->ofp_port = -1;
2327     iface->tag = tag_create_random();
2328     iface->netdev = NULL;
2329     iface->cfg = if_cfg;
2330
2331     hmap_insert(&br->iface_by_name, &iface->name_node, hash_string(name, 0));
2332
2333     list_push_back(&port->ifaces, &iface->port_elem);
2334
2335     VLOG_DBG("attached network device %s to port %s", iface->name, port->name);
2336
2337     return iface;
2338 }
2339
2340 static void
2341 iface_destroy(struct iface *iface)
2342 {
2343     if (iface) {
2344         struct port *port = iface->port;
2345         struct bridge *br = port->bridge;
2346
2347         if (br->ofproto && iface->ofp_port >= 0) {
2348             ofproto_port_unregister(br->ofproto, iface->ofp_port);
2349         }
2350
2351         if (iface->ofp_port >= 0) {
2352             hmap_remove(&br->ifaces, &iface->ofp_port_node);
2353         }
2354
2355         list_remove(&iface->port_elem);
2356         hmap_remove(&br->iface_by_name, &iface->name_node);
2357
2358         netdev_close(iface->netdev);
2359
2360         free(iface->name);
2361         free(iface);
2362     }
2363 }
2364
2365 static struct iface *
2366 iface_lookup(const struct bridge *br, const char *name)
2367 {
2368     struct iface *iface;
2369
2370     HMAP_FOR_EACH_WITH_HASH (iface, name_node, hash_string(name, 0),
2371                              &br->iface_by_name) {
2372         if (!strcmp(iface->name, name)) {
2373             return iface;
2374         }
2375     }
2376
2377     return NULL;
2378 }
2379
2380 static struct iface *
2381 iface_find(const char *name)
2382 {
2383     const struct bridge *br;
2384
2385     HMAP_FOR_EACH (br, node, &all_bridges) {
2386         struct iface *iface = iface_lookup(br, name);
2387
2388         if (iface) {
2389             return iface;
2390         }
2391     }
2392     return NULL;
2393 }
2394
2395 static struct iface *
2396 iface_from_ofp_port(const struct bridge *br, uint16_t ofp_port)
2397 {
2398     struct iface *iface;
2399
2400     HMAP_FOR_EACH_IN_BUCKET (iface, ofp_port_node,
2401                              hash_int(ofp_port, 0), &br->ifaces) {
2402         if (iface->ofp_port == ofp_port) {
2403             return iface;
2404         }
2405     }
2406     return NULL;
2407 }
2408
2409 /* Set Ethernet address of 'iface', if one is specified in the configuration
2410  * file. */
2411 static void
2412 iface_set_mac(struct iface *iface)
2413 {
2414     uint8_t ea[ETH_ADDR_LEN];
2415
2416     if (!strcmp(iface->type, "internal")
2417         && iface->cfg->mac && eth_addr_from_string(iface->cfg->mac, ea)) {
2418         if (iface->ofp_port == OFPP_LOCAL) {
2419             VLOG_ERR("interface %s: ignoring mac in Interface record "
2420                      "(use Bridge record to set local port's mac)",
2421                      iface->name);
2422         } else if (eth_addr_is_multicast(ea)) {
2423             VLOG_ERR("interface %s: cannot set MAC to multicast address",
2424                      iface->name);
2425         } else {
2426             int error = netdev_set_etheraddr(iface->netdev, ea);
2427             if (error) {
2428                 VLOG_ERR("interface %s: setting MAC failed (%s)",
2429                          iface->name, strerror(error));
2430             }
2431         }
2432     }
2433 }
2434
2435 /* Sets the ofport column of 'if_cfg' to 'ofport'. */
2436 static void
2437 iface_set_ofport(const struct ovsrec_interface *if_cfg, int64_t ofport)
2438 {
2439     if (if_cfg && !ovsdb_idl_row_is_synthetic(&if_cfg->header_)) {
2440         ovsrec_interface_set_ofport(if_cfg, &ofport, 1);
2441     }
2442 }
2443
2444 /* Adds the 'n' key-value pairs in 'keys' in 'values' to 'shash'.
2445  *
2446  * The value strings in '*shash' are taken directly from values[], not copied,
2447  * so the caller should not modify or free them. */
2448 static void
2449 shash_from_ovs_idl_map(char **keys, char **values, size_t n,
2450                        struct shash *shash)
2451 {
2452     size_t i;
2453
2454     shash_init(shash);
2455     for (i = 0; i < n; i++) {
2456         shash_add(shash, keys[i], values[i]);
2457     }
2458 }
2459
2460 /* Creates 'keys' and 'values' arrays from 'shash'.
2461  *
2462  * Sets 'keys' and 'values' to heap allocated arrays representing the key-value
2463  * pairs in 'shash'.  The caller takes ownership of 'keys' and 'values'.  They
2464  * are populated with with strings taken directly from 'shash' and thus have
2465  * the same ownership of the key-value pairs in shash.
2466  */
2467 static void
2468 shash_to_ovs_idl_map(struct shash *shash,
2469                      char ***keys, char ***values, size_t *n)
2470 {
2471     size_t i, count;
2472     char **k, **v;
2473     struct shash_node *sn;
2474
2475     count = shash_count(shash);
2476
2477     k = xmalloc(count * sizeof *k);
2478     v = xmalloc(count * sizeof *v);
2479
2480     i = 0;
2481     SHASH_FOR_EACH(sn, shash) {
2482         k[i] = sn->name;
2483         v[i] = sn->data;
2484         i++;
2485     }
2486
2487     *n      = count;
2488     *keys   = k;
2489     *values = v;
2490 }
2491
2492 struct iface_delete_queues_cbdata {
2493     struct netdev *netdev;
2494     const struct ovsdb_datum *queues;
2495 };
2496
2497 static bool
2498 queue_ids_include(const struct ovsdb_datum *queues, int64_t target)
2499 {
2500     union ovsdb_atom atom;
2501
2502     atom.integer = target;
2503     return ovsdb_datum_find_key(queues, &atom, OVSDB_TYPE_INTEGER) != UINT_MAX;
2504 }
2505
2506 static void
2507 iface_delete_queues(unsigned int queue_id,
2508                     const struct shash *details OVS_UNUSED, void *cbdata_)
2509 {
2510     struct iface_delete_queues_cbdata *cbdata = cbdata_;
2511
2512     if (!queue_ids_include(cbdata->queues, queue_id)) {
2513         netdev_delete_queue(cbdata->netdev, queue_id);
2514     }
2515 }
2516
2517 static void
2518 iface_configure_qos(struct iface *iface, const struct ovsrec_qos *qos)
2519 {
2520     if (!qos || qos->type[0] == '\0' || qos->n_queues < 1) {
2521         netdev_set_qos(iface->netdev, NULL, NULL);
2522     } else {
2523         struct iface_delete_queues_cbdata cbdata;
2524         struct shash details;
2525         bool queue_zero;
2526         size_t i;
2527
2528         /* Configure top-level Qos for 'iface'. */
2529         shash_from_ovs_idl_map(qos->key_other_config, qos->value_other_config,
2530                                qos->n_other_config, &details);
2531         netdev_set_qos(iface->netdev, qos->type, &details);
2532         shash_destroy(&details);
2533
2534         /* Deconfigure queues that were deleted. */
2535         cbdata.netdev = iface->netdev;
2536         cbdata.queues = ovsrec_qos_get_queues(qos, OVSDB_TYPE_INTEGER,
2537                                               OVSDB_TYPE_UUID);
2538         netdev_dump_queues(iface->netdev, iface_delete_queues, &cbdata);
2539
2540         /* Configure queues for 'iface'. */
2541         queue_zero = false;
2542         for (i = 0; i < qos->n_queues; i++) {
2543             const struct ovsrec_queue *queue = qos->value_queues[i];
2544             unsigned int queue_id = qos->key_queues[i];
2545
2546             if (queue_id == 0) {
2547                 queue_zero = true;
2548             }
2549
2550             shash_from_ovs_idl_map(queue->key_other_config,
2551                                    queue->value_other_config,
2552                                    queue->n_other_config, &details);
2553             netdev_set_queue(iface->netdev, queue_id, &details);
2554             shash_destroy(&details);
2555         }
2556         if (!queue_zero) {
2557             static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 1);
2558             VLOG_WARN_RL(&rl, "interface %s: QoS configured without a default "
2559                          "queue (queue 0).  Packets not directed to a "
2560                          "correctly configured queue may be dropped.",
2561                          iface->name);
2562         }
2563     }
2564
2565     netdev_set_policing(iface->netdev,
2566                         iface->cfg->ingress_policing_rate,
2567                         iface->cfg->ingress_policing_burst);
2568 }
2569
2570 static void
2571 iface_configure_cfm(struct iface *iface)
2572 {
2573     const struct ovsrec_interface *cfg = iface->cfg;
2574     struct cfm_settings s;
2575     uint16_t remote_mpid;
2576
2577     if (!cfg->n_cfm_mpid || !cfg->n_cfm_remote_mpid) {
2578         ofproto_port_clear_cfm(iface->port->bridge->ofproto, iface->ofp_port);
2579         return;
2580     }
2581
2582     s.mpid = *cfg->cfm_mpid;
2583     remote_mpid = *cfg->cfm_remote_mpid;
2584     s.remote_mpids = &remote_mpid;
2585     s.n_remote_mpids = 1;
2586
2587     s.interval = atoi(get_interface_other_config(iface->cfg, "cfm_interval",
2588                                                  "0"));
2589     if (s.interval <= 0) {
2590         s.interval = 1000;
2591     }
2592
2593     ofproto_port_set_cfm(iface->port->bridge->ofproto, iface->ofp_port, &s);
2594 }
2595
2596 /* Read carrier or miimon status directly from 'iface''s netdev, according to
2597  * how 'iface''s port is configured.
2598  *
2599  * Returns true if 'iface' is up, false otherwise. */
2600 static bool
2601 iface_get_carrier(const struct iface *iface)
2602 {
2603     /* XXX */
2604     return netdev_get_carrier(iface->netdev);
2605 }
2606
2607 /* Returns true if 'iface' is synthetic, that is, if we constructed it locally
2608  * instead of obtaining it from the database. */
2609 static bool
2610 iface_is_synthetic(const struct iface *iface)
2611 {
2612     return ovsdb_idl_row_is_synthetic(&iface->cfg->header_);
2613 }
2614 \f
2615 /* Port mirroring. */
2616
2617 static struct mirror *
2618 mirror_find_by_uuid(struct bridge *br, const struct uuid *uuid)
2619 {
2620     struct mirror *m;
2621
2622     HMAP_FOR_EACH_IN_BUCKET (m, hmap_node, uuid_hash(uuid), &br->mirrors) {
2623         if (uuid_equals(uuid, &m->uuid)) {
2624             return m;
2625         }
2626     }
2627     return NULL;
2628 }
2629
2630 static void
2631 bridge_configure_mirrors(struct bridge *br)
2632 {
2633     const struct ovsdb_datum *mc;
2634     unsigned long *flood_vlans;
2635     struct mirror *m, *next;
2636     size_t i;
2637
2638     /* Get rid of deleted mirrors. */
2639     mc = ovsrec_bridge_get_mirrors(br->cfg, OVSDB_TYPE_UUID);
2640     HMAP_FOR_EACH_SAFE (m, next, hmap_node, &br->mirrors) {
2641         union ovsdb_atom atom;
2642
2643         atom.uuid = m->uuid;
2644         if (ovsdb_datum_find_key(mc, &atom, OVSDB_TYPE_UUID) == UINT_MAX) {
2645             mirror_destroy(m);
2646         }
2647     }
2648
2649     /* Add new mirrors and reconfigure existing ones. */
2650     for (i = 0; i < br->cfg->n_mirrors; i++) {
2651         const struct ovsrec_mirror *cfg = br->cfg->mirrors[i];
2652         struct mirror *m = mirror_find_by_uuid(br, &cfg->header_.uuid);
2653         if (!m) {
2654             m = mirror_create(br, cfg);
2655         }
2656         if (!mirror_configure(m, cfg)) {
2657             mirror_destroy(m);
2658         }
2659     }
2660
2661     /* Update flooded vlans (for RSPAN). */
2662     flood_vlans = vlan_bitmap_from_array(br->cfg->flood_vlans,
2663                                          br->cfg->n_flood_vlans);
2664     ofproto_set_flood_vlans(br->ofproto, flood_vlans);
2665     bitmap_free(flood_vlans);
2666 }
2667
2668 static struct mirror *
2669 mirror_create(struct bridge *br, const struct ovsrec_mirror *cfg)
2670 {
2671     struct mirror *m;
2672
2673     m = xzalloc(sizeof *m);
2674     m->uuid = cfg->header_.uuid;
2675     hmap_insert(&br->mirrors, &m->hmap_node, uuid_hash(&m->uuid));
2676     m->bridge = br;
2677     m->name = xstrdup(cfg->name);
2678
2679     return m;
2680 }
2681
2682 static void
2683 mirror_destroy(struct mirror *m)
2684 {
2685     if (m) {
2686         struct bridge *br = m->bridge;
2687
2688         if (br->ofproto) {
2689             ofproto_mirror_unregister(br->ofproto, m);
2690         }
2691
2692         hmap_remove(&br->mirrors, &m->hmap_node);
2693         free(m->name);
2694         free(m);
2695     }
2696 }
2697
2698 static void
2699 mirror_collect_ports(struct mirror *m,
2700                      struct ovsrec_port **in_ports, int n_in_ports,
2701                      void ***out_portsp, size_t *n_out_portsp)
2702 {
2703     void **out_ports = xmalloc(n_in_ports * sizeof *out_ports);
2704     size_t n_out_ports = 0;
2705     size_t i;
2706
2707     for (i = 0; i < n_in_ports; i++) {
2708         const char *name = in_ports[i]->name;
2709         struct port *port = port_lookup(m->bridge, name);
2710         if (port) {
2711             out_ports[n_out_ports++] = port;
2712         } else {
2713             VLOG_WARN("bridge %s: mirror %s cannot match on nonexistent "
2714                       "port %s", m->bridge->name, m->name, name);
2715         }
2716     }
2717     *out_portsp = out_ports;
2718     *n_out_portsp = n_out_ports;
2719 }
2720
2721 static bool
2722 mirror_configure(struct mirror *m, const struct ovsrec_mirror *cfg)
2723 {
2724     struct ofproto_mirror_settings s;
2725
2726     /* Set name. */
2727     if (strcmp(cfg->name, m->name)) {
2728         free(m->name);
2729         m->name = xstrdup(cfg->name);
2730     }
2731     s.name = m->name;
2732
2733     /* Get output port or VLAN. */
2734     if (cfg->output_port) {
2735         s.out_bundle = port_lookup(m->bridge, cfg->output_port->name);
2736         if (!s.out_bundle) {
2737             VLOG_ERR("bridge %s: mirror %s outputs to port not on bridge",
2738                      m->bridge->name, m->name);
2739             return false;
2740         }
2741         s.out_vlan = UINT16_MAX;
2742
2743         if (cfg->output_vlan) {
2744             VLOG_ERR("bridge %s: mirror %s specifies both output port and "
2745                      "output vlan; ignoring output vlan",
2746                      m->bridge->name, m->name);
2747         }
2748     } else if (cfg->output_vlan) {
2749         /* The database should prevent invalid VLAN values. */
2750         s.out_bundle = NULL;
2751         s.out_vlan = *cfg->output_vlan;
2752     } else {
2753         VLOG_ERR("bridge %s: mirror %s does not specify output; ignoring",
2754                  m->bridge->name, m->name);
2755         return false;
2756     }
2757
2758     /* Get port selection. */
2759     if (cfg->select_all) {
2760         size_t n_ports = hmap_count(&m->bridge->ports);
2761         void **ports = xmalloc(n_ports * sizeof *ports);
2762         struct port *port;
2763         size_t i;
2764
2765         i = 0;
2766         HMAP_FOR_EACH (port, hmap_node, &m->bridge->ports) {
2767             ports[i++] = port;
2768         }
2769
2770         s.srcs = ports;
2771         s.n_srcs = n_ports;
2772
2773         s.dsts = ports;
2774         s.n_dsts = n_ports;
2775     } else {
2776         /* Get ports, dropping ports that don't exist.
2777          * The IDL ensures that there are no duplicates. */
2778         mirror_collect_ports(m, cfg->select_src_port, cfg->n_select_src_port,
2779                              &s.srcs, &s.n_srcs);
2780         mirror_collect_ports(m, cfg->select_dst_port, cfg->n_select_dst_port,
2781                              &s.dsts, &s.n_dsts);
2782     }
2783
2784     /* Get VLAN selection. */
2785     s.src_vlans = vlan_bitmap_from_array(cfg->select_vlan, cfg->n_select_vlan);
2786
2787     /* Configure. */
2788     ofproto_mirror_register(m->bridge->ofproto, m, &s);
2789
2790     /* Clean up. */
2791     if (s.srcs != s.dsts) {
2792         free(s.dsts);
2793     }
2794     free(s.srcs);
2795     free(s.src_vlans);
2796
2797     return true;
2798 }