vswitchd/bridge.c

   1 /* Copyright (c) 2008, 2009, 2010, 2011, 2012, 2013 Nicira, Inc.
   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 <errno.h>
  19 #include <inttypes.h>
  20 #include <stdlib.h>
  21 #include "async-append.h"
  22 #include "bfd.h"
  23 #include "bitmap.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 "hmapx.h"
  32 #include "jsonrpc.h"
  33 #include "lacp.h"
  34 #include "list.h"
  35 #include "mac-learning.h"
  36 #include "meta-flow.h"
  37 #include "netdev.h"
  38 #include "ofp-print.h"
  39 #include "ofp-util.h"
  40 #include "ofpbuf.h"
  41 #include "ofproto/bond.h"
  42 #include "ofproto/ofproto.h"
  43 #include "poll-loop.h"
  44 #include "sha1.h"
  45 #include "shash.h"
  46 #include "smap.h"
  47 #include "socket-util.h"
  48 #include "stream.h"
  49 #include "stream-ssl.h"
  50 #include "sset.h"
  51 #include "system-stats.h"
  52 #include "timeval.h"
  53 #include "util.h"
  54 #include "unixctl.h"
  55 #include "vlandev.h"
  56 #include "lib/vswitch-idl.h"
  57 #include "xenserver.h"
  58 #include "vlog.h"
  59 #include "sflow_api.h"
  60 #include "vlan-bitmap.h"
  61
  62 VLOG_DEFINE_THIS_MODULE(bridge);
  63
  64 COVERAGE_DEFINE(bridge_reconfigure);
  65
  66 struct iface {
  67     /* These members are always valid.
  68      *
  69      * They are immutable: they never change between iface_create() and
  70      * iface_destroy(). */
  71     struct list port_elem;      /* Element in struct port's "ifaces" list. */
  72     struct hmap_node name_node; /* In struct bridge's "iface_by_name" hmap. */
  73     struct hmap_node ofp_port_node; /* In struct bridge's "ifaces" hmap. */
  74     struct port *port;          /* Containing port. */
  75     char *name;                 /* Host network device name. */
  76     struct netdev *netdev;      /* Network device. */
  77     ofp_port_t ofp_port;        /* OpenFlow port number. */
  78
  79     /* These members are valid only within bridge_reconfigure(). */
  80     const char *type;           /* Usually same as cfg->type. */
  81     const struct ovsrec_interface *cfg;
  82 };
  83
  84 struct mirror {
  85     struct uuid uuid;           /* UUID of this "mirror" record in database. */
  86     struct hmap_node hmap_node; /* In struct bridge's "mirrors" hmap. */
  87     struct bridge *bridge;
  88     char *name;
  89     const struct ovsrec_mirror *cfg;
  90 };
  91
  92 struct port {
  93     struct hmap_node hmap_node; /* Element in struct bridge's "ports" hmap. */
  94     struct bridge *bridge;
  95     char *name;
  96
  97     const struct ovsrec_port *cfg;
  98
  99     /* An ordinary bridge port has 1 interface.
 100      * A bridge port for bonding has at least 2 interfaces. */
 101     struct list ifaces;         /* List of "struct iface"s. */
 102 };
 103
 104 struct bridge {
 105     struct hmap_node node;      /* In 'all_bridges'. */
 106     char *name;                 /* User-specified arbitrary name. */
 107     char *type;                 /* Datapath type. */
 108     uint8_t ea[ETH_ADDR_LEN];   /* Bridge Ethernet Address. */
 109     uint8_t default_ea[ETH_ADDR_LEN]; /* Default MAC. */
 110     const struct ovsrec_bridge *cfg;
 111
 112     /* OpenFlow switch processing. */
 113     struct ofproto *ofproto;    /* OpenFlow switch. */
 114
 115     /* Bridge ports. */
 116     struct hmap ports;          /* "struct port"s indexed by name. */
 117     struct hmap ifaces;         /* "struct iface"s indexed by ofp_port. */
 118     struct hmap iface_by_name;  /* "struct iface"s indexed by name. */
 119
 120     /* Port mirroring. */
 121     struct hmap mirrors;        /* "struct mirror" indexed by UUID. */
 122
 123     /* Used during reconfiguration. */
 124     struct shash wanted_ports;
 125
 126     /* Synthetic local port if necessary. */
 127     struct ovsrec_port synth_local_port;
 128     struct ovsrec_interface synth_local_iface;
 129     struct ovsrec_interface *synth_local_ifacep;
 130 };
 131
 132 /* All bridges, indexed by name. */
 133 static struct hmap all_bridges = HMAP_INITIALIZER(&all_bridges);
 134
 135 /* OVSDB IDL used to obtain configuration. */
 136 static struct ovsdb_idl *idl;
 137
 138 /* We want to complete daemonization, fully detaching from our parent process,
 139  * only after we have completed our initial configuration, committed our state
 140  * to the database, and received confirmation back from the database server
 141  * that it applied the commit.  This allows our parent process to know that,
 142  * post-detach, ephemeral fields such as datapath-id and ofport are very likely
 143  * to have already been filled in.  (It is only "very likely" rather than
 144  * certain because there is always a slim possibility that the transaction will
 145  * fail or that some other client has added new bridges, ports, etc. while
 146  * ovs-vswitchd was configuring using an old configuration.)
 147  *
 148  * We only need to do this once for our initial configuration at startup, so
 149  * 'initial_config_done' tracks whether we've already done it.  While we are
 150  * waiting for a response to our commit, 'daemonize_txn' tracks the transaction
 151  * itself and is otherwise NULL. */
 152 static bool initial_config_done;
 153 static struct ovsdb_idl_txn *daemonize_txn;
 154
 155 /* Most recently processed IDL sequence number. */
 156 static unsigned int idl_seqno;
 157
 158 /* Each time this timer expires, the bridge fetches interface and mirror
 159  * statistics and pushes them into the database. */
 160 #define IFACE_STATS_INTERVAL (5 * 1000) /* In milliseconds. */
 161 static long long int iface_stats_timer = LLONG_MIN;
 162
 163 /* In some datapaths, creating and destroying OpenFlow ports can be extremely
 164  * expensive.  This can cause bridge_reconfigure() to take a long time during
 165  * which no other work can be done.  To deal with this problem, we limit port
 166  * adds and deletions to a window of OFP_PORT_ACTION_WINDOW milliseconds per
 167  * call to bridge_reconfigure().  If there is more work to do after the limit
 168  * is reached, 'need_reconfigure', is flagged and it's done on the next loop.
 169  * This allows the rest of the code to catch up on important things like
 170  * forwarding packets. */
 171 #define OFP_PORT_ACTION_WINDOW 10
 172
 173 static void add_del_bridges(const struct ovsrec_open_vswitch *);
 174 static void bridge_create(const struct ovsrec_bridge *);
 175 static void bridge_destroy(struct bridge *);
 176 static struct bridge *bridge_lookup(const char *name);
 177 static unixctl_cb_func bridge_unixctl_dump_flows;
 178 static unixctl_cb_func bridge_unixctl_reconnect;
 179 static size_t bridge_get_controllers(const struct bridge *br,
 180                                      struct ovsrec_controller ***controllersp);
 181 static void bridge_collect_wanted_ports(struct bridge *,
 182                                         const unsigned long *splinter_vlans,
 183                                         struct shash *wanted_ports);
 184 static void bridge_delete_ofprotos(void);
 185 static void bridge_delete_or_reconfigure_ports(struct bridge *);
 186 static void bridge_del_ports(struct bridge *,
 187                              const struct shash *wanted_ports);
 188 static void bridge_add_ports(struct bridge *,
 189                              const struct shash *wanted_ports);
 190
 191 static void bridge_configure_flow_miss_model(const char *opt);
 192 static void bridge_configure_datapath_id(struct bridge *);
 193 static void bridge_configure_netflow(struct bridge *);
 194 static void bridge_configure_forward_bpdu(struct bridge *);
 195 static void bridge_configure_mac_table(struct bridge *);
 196 static void bridge_configure_sflow(struct bridge *, int *sflow_bridge_number);
 197 static void bridge_configure_ipfix(struct bridge *);
 198 static void bridge_configure_stp(struct bridge *);
 199 static void bridge_configure_tables(struct bridge *);
 200 static void bridge_configure_dp_desc(struct bridge *);
 201 static void bridge_configure_remotes(struct bridge *,
 202                                      const struct sockaddr_in *managers,
 203                                      size_t n_managers);
 204 static void bridge_pick_local_hw_addr(struct bridge *,
 205                                       uint8_t ea[ETH_ADDR_LEN],
 206                                       struct iface **hw_addr_iface);
 207 static uint64_t bridge_pick_datapath_id(struct bridge *,
 208                                         const uint8_t bridge_ea[ETH_ADDR_LEN],
 209                                         struct iface *hw_addr_iface);
 210 static uint64_t dpid_from_hash(const void *, size_t nbytes);
 211 static bool bridge_has_bond_fake_iface(const struct bridge *,
 212                                        const char *name);
 213 static bool port_is_bond_fake_iface(const struct port *);
 214
 215 static unixctl_cb_func qos_unixctl_show;
 216
 217 static struct port *port_create(struct bridge *, const struct ovsrec_port *);
 218 static void port_del_ifaces(struct port *);
 219 static void port_destroy(struct port *);
 220 static struct port *port_lookup(const struct bridge *, const char *name);
 221 static void port_configure(struct port *);
 222 static struct lacp_settings *port_configure_lacp(struct port *,
 223                                                  struct lacp_settings *);
 224 static void port_configure_bond(struct port *, struct bond_settings *);
 225 static bool port_is_synthetic(const struct port *);
 226
 227 static void reconfigure_system_stats(const struct ovsrec_open_vswitch *);
 228 static void run_system_stats(void);
 229
 230 static void bridge_configure_mirrors(struct bridge *);
 231 static struct mirror *mirror_create(struct bridge *,
 232                                     const struct ovsrec_mirror *);
 233 static void mirror_destroy(struct mirror *);
 234 static bool mirror_configure(struct mirror *);
 235 static void mirror_refresh_stats(struct mirror *);
 236
 237 static void iface_configure_lacp(struct iface *, struct lacp_slave_settings *);
 238 static bool iface_create(struct bridge *, const struct ovsrec_interface *,
 239                          const struct ovsrec_port *);
 240 static bool iface_is_internal(const struct ovsrec_interface *iface,
 241                               const struct ovsrec_bridge *br);
 242 static const char *iface_get_type(const struct ovsrec_interface *,
 243                                   const struct ovsrec_bridge *);
 244 static void iface_destroy(struct iface *);
 245 static struct iface *iface_lookup(const struct bridge *, const char *name);
 246 static struct iface *iface_find(const char *name);
 247 static struct iface *iface_from_ofp_port(const struct bridge *,
 248                                          ofp_port_t ofp_port);
 249 static void iface_set_mac(struct iface *);
 250 static void iface_set_ofport(const struct ovsrec_interface *, ofp_port_t ofport);
 251 static void iface_clear_db_record(const struct ovsrec_interface *if_cfg);
 252 static void iface_configure_qos(struct iface *, const struct ovsrec_qos *);
 253 static void iface_configure_cfm(struct iface *);
 254 static void iface_refresh_cfm_stats(struct iface *);
 255 static void iface_refresh_stats(struct iface *);
 256 static void iface_refresh_status(struct iface *);
 257 static bool iface_is_synthetic(const struct iface *);
 258 static ofp_port_t iface_pick_ofport(const struct ovsrec_interface *);
 259
 260 /* Linux VLAN device support (e.g. "eth0.10" for VLAN 10.)
 261  *
 262  * This is deprecated.  It is only for compatibility with broken device drivers
 263  * in old versions of Linux that do not properly support VLANs when VLAN
 264  * devices are not used.  When broken device drivers are no longer in
 265  * widespread use, we will delete these interfaces. */
 266
 267 /* True if VLAN splinters are enabled on any interface, false otherwise.*/
 268 static bool vlan_splinters_enabled_anywhere;
 269
 270 static bool vlan_splinters_is_enabled(const struct ovsrec_interface *);
 271 static unsigned long int *collect_splinter_vlans(
 272     const struct ovsrec_open_vswitch *);
 273 static void configure_splinter_port(struct port *);
 274 static void add_vlan_splinter_ports(struct bridge *,
 275                                     const unsigned long int *splinter_vlans,
 276                                     struct shash *ports);
 277
 278 static void
 279 bridge_init_ofproto(const struct ovsrec_open_vswitch *cfg)
 280 {
 281     struct shash iface_hints;
 282     static bool initialized = false;
 283     int i;
 284
 285     if (initialized) {
 286         return;
 287     }
 288
 289     shash_init(&iface_hints);
 290
 291     if (cfg) {
 292         for (i = 0; i < cfg->n_bridges; i++) {
 293             const struct ovsrec_bridge *br_cfg = cfg->bridges[i];
 294             int j;
 295
 296             for (j = 0; j < br_cfg->n_ports; j++) {
 297                 struct ovsrec_port *port_cfg = br_cfg->ports[j];
 298                 int k;
 299
 300                 for (k = 0; k < port_cfg->n_interfaces; k++) {
 301                     struct ovsrec_interface *if_cfg = port_cfg->interfaces[k];
 302                     struct iface_hint *iface_hint;
 303
 304                     iface_hint = xmalloc(sizeof *iface_hint);
 305                     iface_hint->br_name = br_cfg->name;
 306                     iface_hint->br_type = br_cfg->datapath_type;
 307                     iface_hint->ofp_port = iface_pick_ofport(if_cfg);
 308
 309                     shash_add(&iface_hints, if_cfg->name, iface_hint);
 310                 }
 311             }
 312         }
 313     }
 314
 315     ofproto_init(&iface_hints);
 316
 317     shash_destroy_free_data(&iface_hints);
 318     initialized = true;
 319 }
 320 \f
 321 /* Public functions. */
 322
 323 /* Initializes the bridge module, configuring it to obtain its configuration
 324  * from an OVSDB server accessed over 'remote', which should be a string in a
 325  * form acceptable to ovsdb_idl_create(). */
 326 void
 327 bridge_init(const char *remote)
 328 {
 329     /* Create connection to database. */
 330     idl = ovsdb_idl_create(remote, &ovsrec_idl_class, true, true);
 331     idl_seqno = ovsdb_idl_get_seqno(idl);
 332     ovsdb_idl_set_lock(idl, "ovs_vswitchd");
 333     ovsdb_idl_verify_write_only(idl);
 334
 335     ovsdb_idl_omit_alert(idl, &ovsrec_open_vswitch_col_cur_cfg);
 336     ovsdb_idl_omit_alert(idl, &ovsrec_open_vswitch_col_statistics);
 337     ovsdb_idl_omit(idl, &ovsrec_open_vswitch_col_external_ids);
 338     ovsdb_idl_omit(idl, &ovsrec_open_vswitch_col_ovs_version);
 339     ovsdb_idl_omit(idl, &ovsrec_open_vswitch_col_db_version);
 340     ovsdb_idl_omit(idl, &ovsrec_open_vswitch_col_system_type);
 341     ovsdb_idl_omit(idl, &ovsrec_open_vswitch_col_system_version);
 342
 343     ovsdb_idl_omit_alert(idl, &ovsrec_bridge_col_datapath_id);
 344     ovsdb_idl_omit_alert(idl, &ovsrec_bridge_col_status);
 345     ovsdb_idl_omit(idl, &ovsrec_bridge_col_external_ids);
 346
 347     ovsdb_idl_omit_alert(idl, &ovsrec_port_col_status);
 348     ovsdb_idl_omit_alert(idl, &ovsrec_port_col_statistics);
 349     ovsdb_idl_omit(idl, &ovsrec_port_col_external_ids);
 350     ovsdb_idl_omit(idl, &ovsrec_port_col_fake_bridge);
 351
 352     ovsdb_idl_omit_alert(idl, &ovsrec_interface_col_admin_state);
 353     ovsdb_idl_omit_alert(idl, &ovsrec_interface_col_duplex);
 354     ovsdb_idl_omit_alert(idl, &ovsrec_interface_col_link_speed);
 355     ovsdb_idl_omit_alert(idl, &ovsrec_interface_col_link_state);
 356     ovsdb_idl_omit_alert(idl, &ovsrec_interface_col_link_resets);
 357     ovsdb_idl_omit_alert(idl, &ovsrec_interface_col_mac_in_use);
 358     ovsdb_idl_omit_alert(idl, &ovsrec_interface_col_ifindex);
 359     ovsdb_idl_omit_alert(idl, &ovsrec_interface_col_mtu);
 360     ovsdb_idl_omit_alert(idl, &ovsrec_interface_col_ofport);
 361     ovsdb_idl_omit_alert(idl, &ovsrec_interface_col_statistics);
 362     ovsdb_idl_omit_alert(idl, &ovsrec_interface_col_status);
 363     ovsdb_idl_omit_alert(idl, &ovsrec_interface_col_cfm_fault);
 364     ovsdb_idl_omit_alert(idl, &ovsrec_interface_col_cfm_fault_status);
 365     ovsdb_idl_omit_alert(idl, &ovsrec_interface_col_cfm_remote_mpids);
 366     ovsdb_idl_omit_alert(idl, &ovsrec_interface_col_cfm_flap_count);
 367     ovsdb_idl_omit_alert(idl, &ovsrec_interface_col_cfm_health);
 368     ovsdb_idl_omit_alert(idl, &ovsrec_interface_col_cfm_remote_opstate);
 369     ovsdb_idl_omit_alert(idl, &ovsrec_interface_col_bfd_status);
 370     ovsdb_idl_omit_alert(idl, &ovsrec_interface_col_lacp_current);
 371     ovsdb_idl_omit(idl, &ovsrec_interface_col_external_ids);
 372
 373     ovsdb_idl_omit_alert(idl, &ovsrec_controller_col_is_connected);
 374     ovsdb_idl_omit_alert(idl, &ovsrec_controller_col_role);
 375     ovsdb_idl_omit_alert(idl, &ovsrec_controller_col_status);
 376     ovsdb_idl_omit(idl, &ovsrec_controller_col_external_ids);
 377
 378     ovsdb_idl_omit(idl, &ovsrec_qos_col_external_ids);
 379
 380     ovsdb_idl_omit(idl, &ovsrec_queue_col_external_ids);
 381
 382     ovsdb_idl_omit(idl, &ovsrec_mirror_col_external_ids);
 383     ovsdb_idl_omit_alert(idl, &ovsrec_mirror_col_statistics);
 384
 385     ovsdb_idl_omit(idl, &ovsrec_netflow_col_external_ids);
 386     ovsdb_idl_omit(idl, &ovsrec_sflow_col_external_ids);
 387     ovsdb_idl_omit(idl, &ovsrec_ipfix_col_external_ids);
 388     ovsdb_idl_omit(idl, &ovsrec_flow_sample_collector_set_col_external_ids);
 389
 390     ovsdb_idl_omit(idl, &ovsrec_manager_col_external_ids);
 391     ovsdb_idl_omit(idl, &ovsrec_manager_col_inactivity_probe);
 392     ovsdb_idl_omit(idl, &ovsrec_manager_col_is_connected);
 393     ovsdb_idl_omit(idl, &ovsrec_manager_col_max_backoff);
 394     ovsdb_idl_omit(idl, &ovsrec_manager_col_status);
 395
 396     ovsdb_idl_omit(idl, &ovsrec_ssl_col_external_ids);
 397
 398     /* Register unixctl commands. */
 399     unixctl_command_register("qos/show", "interface", 1, 1,
 400                              qos_unixctl_show, NULL);
 401     unixctl_command_register("bridge/dump-flows", "bridge", 1, 1,
 402                              bridge_unixctl_dump_flows, NULL);
 403     unixctl_command_register("bridge/reconnect", "[bridge]", 0, 1,
 404                              bridge_unixctl_reconnect, NULL);
 405     lacp_init();
 406     bond_init();
 407     cfm_init();
 408     stp_init();
 409 }
 410
 411 void
 412 bridge_exit(void)
 413 {
 414     struct bridge *br, *next_br;
 415
 416     HMAP_FOR_EACH_SAFE (br, next_br, node, &all_bridges) {
 417         bridge_destroy(br);
 418     }
 419     ovsdb_idl_destroy(idl);
 420 }
 421
 422 /* Looks at the list of managers in 'ovs_cfg' and extracts their remote IP
 423  * addresses and ports into '*managersp' and '*n_managersp'.  The caller is
 424  * responsible for freeing '*managersp' (with free()).
 425  *
 426  * You may be asking yourself "why does ovs-vswitchd care?", because
 427  * ovsdb-server is responsible for connecting to the managers, and ovs-vswitchd
 428  * should not be and in fact is not directly involved in that.  But
 429  * ovs-vswitchd needs to make sure that ovsdb-server can reach the managers, so
 430  * it has to tell in-band control where the managers are to enable that.
 431  * (Thus, only managers connected in-band are collected.)
 432  */
 433 static void
 434 collect_in_band_managers(const struct ovsrec_open_vswitch *ovs_cfg,
 435                          struct sockaddr_in **managersp, size_t *n_managersp)
 436 {
 437     struct sockaddr_in *managers = NULL;
 438     size_t n_managers = 0;
 439     struct sset targets;
 440     size_t i;
 441
 442     /* Collect all of the potential targets from the "targets" columns of the
 443      * rows pointed to by "manager_options", excluding any that are
 444      * out-of-band. */
 445     sset_init(&targets);
 446     for (i = 0; i < ovs_cfg->n_manager_options; i++) {
 447         struct ovsrec_manager *m = ovs_cfg->manager_options[i];
 448
 449         if (m->connection_mode && !strcmp(m->connection_mode, "out-of-band")) {
 450             sset_find_and_delete(&targets, m->target);
 451         } else {
 452             sset_add(&targets, m->target);
 453         }
 454     }
 455
 456     /* Now extract the targets' IP addresses. */
 457     if (!sset_is_empty(&targets)) {
 458         const char *target;
 459
 460         managers = xmalloc(sset_count(&targets) * sizeof *managers);
 461         SSET_FOR_EACH (target, &targets) {
 462             struct sockaddr_in *sin = &managers[n_managers];
 463
 464             if (stream_parse_target_with_default_port(target,
 465                                                       OVSDB_OLD_PORT,
 466                                                       sin)) {
 467                 n_managers++;
 468             }
 469         }
 470     }
 471     sset_destroy(&targets);
 472
 473     *managersp = managers;
 474     *n_managersp = n_managers;
 475 }
 476
 477 static void
 478 bridge_reconfigure(const struct ovsrec_open_vswitch *ovs_cfg)
 479 {
 480     unsigned long int *splinter_vlans;
 481     struct sockaddr_in *managers;
 482     struct bridge *br, *next;
 483     int sflow_bridge_number;
 484     size_t n_managers;
 485
 486     COVERAGE_INC(bridge_reconfigure);
 487
 488     ofproto_set_flow_eviction_threshold(
 489         smap_get_int(&ovs_cfg->other_config, "flow-eviction-threshold",
 490                      OFPROTO_FLOW_EVICTION_THRESHOLD_DEFAULT));
 491
 492     ofproto_set_n_handler_threads(
 493         smap_get_int(&ovs_cfg->other_config, "n-handler-threads", 0));
 494
 495     bridge_configure_flow_miss_model(smap_get(&ovs_cfg->other_config,
 496                                               "force-miss-model"));
 497
 498     /* Destroy "struct bridge"s, "struct port"s, and "struct iface"s according
 499      * to 'ovs_cfg', with only very minimal configuration otherwise.
 500      *
 501      * This is mostly an update to bridge data structures. Nothing is pushed
 502      * down to ofproto or lower layers. */
 503     add_del_bridges(ovs_cfg);
 504     splinter_vlans = collect_splinter_vlans(ovs_cfg);
 505     HMAP_FOR_EACH (br, node, &all_bridges) {
 506         bridge_collect_wanted_ports(br, splinter_vlans, &br->wanted_ports);
 507         bridge_del_ports(br, &br->wanted_ports);
 508     }
 509     free(splinter_vlans);
 510
 511     /* Start pushing configuration changes down to the ofproto layer:
 512      *
 513      *   - Delete ofprotos that are no longer configured.
 514      *
 515      *   - Delete ports that are no longer configured.
 516      *
 517      *   - Reconfigure existing ports to their desired configurations, or
 518      *     delete them if not possible.
 519      *
 520      * We have to do all the deletions before we can do any additions, because
 521      * the ports to be added might require resources that will be freed up by
 522      * deletions (they might especially overlap in name). */
 523     bridge_delete_ofprotos();
 524     HMAP_FOR_EACH (br, node, &all_bridges) {
 525         if (br->ofproto) {
 526             bridge_delete_or_reconfigure_ports(br);
 527         }
 528     }
 529
 530     /* Finish pushing configuration changes to the ofproto layer:
 531      *
 532      *     - Create ofprotos that are missing.
 533      *
 534      *     - Add ports that are missing. */
 535     HMAP_FOR_EACH_SAFE (br, next, node, &all_bridges) {
 536         if (!br->ofproto) {
 537             int error;
 538
 539             error = ofproto_create(br->name, br->type, &br->ofproto);
 540             if (error) {
 541                 VLOG_ERR("failed to create bridge %s: %s", br->name,
 542                          ovs_strerror(error));
 543                 shash_destroy(&br->wanted_ports);
 544                 bridge_destroy(br);
 545             }
 546         }
 547     }
 548     HMAP_FOR_EACH (br, node, &all_bridges) {
 549         bridge_add_ports(br, &br->wanted_ports);
 550         shash_destroy(&br->wanted_ports);
 551     }
 552
 553     reconfigure_system_stats(ovs_cfg);
 554
 555     /* Complete the configuration. */
 556     sflow_bridge_number = 0;
 557     collect_in_band_managers(ovs_cfg, &managers, &n_managers);
 558     HMAP_FOR_EACH (br, node, &all_bridges) {
 559         struct port *port;
 560
 561         /* We need the datapath ID early to allow LACP ports to use it as the
 562          * default system ID. */
 563         bridge_configure_datapath_id(br);
 564
 565         HMAP_FOR_EACH (port, hmap_node, &br->ports) {
 566             struct iface *iface;
 567
 568             port_configure(port);
 569
 570             LIST_FOR_EACH (iface, port_elem, &port->ifaces) {
 571                 iface_configure_cfm(iface);
 572                 iface_configure_qos(iface, port->cfg->qos);
 573                 iface_set_mac(iface);
 574                 ofproto_port_set_bfd(br->ofproto, iface->ofp_port,
 575                                      &iface->cfg->bfd);
 576             }
 577         }
 578         bridge_configure_mirrors(br);
 579         bridge_configure_forward_bpdu(br);
 580         bridge_configure_mac_table(br);
 581         bridge_configure_remotes(br, managers, n_managers);
 582         bridge_configure_netflow(br);
 583         bridge_configure_sflow(br, &sflow_bridge_number);
 584         bridge_configure_ipfix(br);
 585         bridge_configure_stp(br);
 586         bridge_configure_tables(br);
 587         bridge_configure_dp_desc(br);
 588
 589         if (smap_get(&br->cfg->other_config, "flow-eviction-threshold")) {
 590             /* XXX: Remove this warning message eventually. */
 591             VLOG_WARN_ONCE("As of June 2013, flow-eviction-threshold has been"
 592                            " moved to the Open_vSwitch table.  Ignoring its"
 593                            " setting in the bridge table.");
 594         }
 595     }
 596     free(managers);
 597 }
 598
 599 /* Delete ofprotos which aren't configured or have the wrong type.  Create
 600  * ofprotos which don't exist but need to. */
 601 static void
 602 bridge_delete_ofprotos(void)
 603 {
 604     struct bridge *br;
 605     struct sset names;
 606     struct sset types;
 607     const char *type;
 608
 609     /* Delete ofprotos with no bridge or with the wrong type. */
 610     sset_init(&names);
 611     sset_init(&types);
 612     ofproto_enumerate_types(&types);
 613     SSET_FOR_EACH (type, &types) {
 614         const char *name;
 615
 616         ofproto_enumerate_names(type, &names);
 617         SSET_FOR_EACH (name, &names) {
 618             br = bridge_lookup(name);
 619             if (!br || strcmp(type, br->type)) {
 620                 ofproto_delete(name, type);
 621             }
 622         }
 623     }
 624     sset_destroy(&names);
 625     sset_destroy(&types);
 626 }
 627
 628 static ofp_port_t *
 629 add_ofp_port(ofp_port_t port, ofp_port_t *ports, size_t *n, size_t *allocated)
 630 {
 631     if (*n >= *allocated) {
 632         ports = x2nrealloc(ports, allocated, sizeof *ports);
 633     }
 634     ports[(*n)++] = port;
 635     return ports;
 636 }
 637
 638 static void
 639 bridge_delete_or_reconfigure_ports(struct bridge *br)
 640 {
 641     struct ofproto_port ofproto_port;
 642     struct ofproto_port_dump dump;
 643
 644     /* List of "ofp_port"s to delete.  We make a list instead of deleting them
 645      * right away because ofproto implementations aren't necessarily able to
 646      * iterate through a changing list of ports in an entirely robust way. */
 647     ofp_port_t *del;
 648     size_t n, allocated;
 649     size_t i;
 650
 651     del = NULL;
 652     n = allocated = 0;
 653
 654     OFPROTO_PORT_FOR_EACH (&ofproto_port, &dump, br->ofproto) {
 655         struct iface *iface;
 656
 657         iface = iface_lookup(br, ofproto_port.name);
 658         if (!iface) {
 659             /* No such iface is configured, so we should delete this
 660              * ofproto_port.
 661              *
 662              * As a corner case exception, keep the port if it's a bond fake
 663              * interface. */
 664             if (bridge_has_bond_fake_iface(br, ofproto_port.name)
 665                 && !strcmp(ofproto_port.type, "internal")) {
 666                 continue;
 667             }
 668             goto delete;
 669         }
 670
 671         if (strcmp(ofproto_port.type, iface->type)
 672             || netdev_set_config(iface->netdev, &iface->cfg->options)) {
 673             /* The interface is the wrong type or can't be configured.
 674              * Delete it. */
 675             goto delete;
 676         }
 677
 678         /* Keep it. */
 679         continue;
 680
 681     delete:
 682         iface_destroy(iface);
 683         del = add_ofp_port(ofproto_port.ofp_port, del, &n, &allocated);
 684     }
 685
 686     for (i = 0; i < n; i++) {
 687         ofproto_port_del(br->ofproto, del[i]);
 688     }
 689     free(del);
 690 }
 691
 692 static void
 693 bridge_add_ports(struct bridge *br, const struct shash *wanted_ports)
 694 {
 695     struct shash_node *port_node;
 696
 697     SHASH_FOR_EACH (port_node, wanted_ports) {
 698         const struct ovsrec_port *port_cfg = port_node->data;
 699         size_t i;
 700
 701         for (i = 0; i < port_cfg->n_interfaces; i++) {
 702             const struct ovsrec_interface *iface_cfg = port_cfg->interfaces[i];
 703             struct iface *iface = iface_lookup(br, iface_cfg->name);
 704
 705             if (!iface) {
 706                 iface_create(br, iface_cfg, port_cfg);
 707             }
 708         }
 709     }
 710 }
 711
 712 static void
 713 port_configure(struct port *port)
 714 {
 715     const struct ovsrec_port *cfg = port->cfg;
 716     struct bond_settings bond_settings;
 717     struct lacp_settings lacp_settings;
 718     struct ofproto_bundle_settings s;
 719     struct iface *iface;
 720
 721     if (cfg->vlan_mode && !strcmp(cfg->vlan_mode, "splinter")) {
 722         configure_splinter_port(port);
 723         return;
 724     }
 725
 726     /* Get name. */
 727     s.name = port->name;
 728
 729     /* Get slaves. */
 730     s.n_slaves = 0;
 731     s.slaves = xmalloc(list_size(&port->ifaces) * sizeof *s.slaves);
 732     LIST_FOR_EACH (iface, port_elem, &port->ifaces) {
 733         s.slaves[s.n_slaves++] = iface->ofp_port;
 734     }
 735
 736     /* Get VLAN tag. */
 737     s.vlan = -1;
 738     if (cfg->tag && *cfg->tag >= 0 && *cfg->tag <= 4095) {
 739         s.vlan = *cfg->tag;
 740     }
 741
 742     /* Get VLAN trunks. */
 743     s.trunks = NULL;
 744     if (cfg->n_trunks) {
 745         s.trunks = vlan_bitmap_from_array(cfg->trunks, cfg->n_trunks);
 746     }
 747
 748     /* Get VLAN mode. */
 749     if (cfg->vlan_mode) {
 750         if (!strcmp(cfg->vlan_mode, "access")) {
 751             s.vlan_mode = PORT_VLAN_ACCESS;
 752         } else if (!strcmp(cfg->vlan_mode, "trunk")) {
 753             s.vlan_mode = PORT_VLAN_TRUNK;
 754         } else if (!strcmp(cfg->vlan_mode, "native-tagged")) {
 755             s.vlan_mode = PORT_VLAN_NATIVE_TAGGED;
 756         } else if (!strcmp(cfg->vlan_mode, "native-untagged")) {
 757             s.vlan_mode = PORT_VLAN_NATIVE_UNTAGGED;
 758         } else {
 759             /* This "can't happen" because ovsdb-server should prevent it. */
 760             VLOG_ERR("unknown VLAN mode %s", cfg->vlan_mode);
 761             s.vlan_mode = PORT_VLAN_TRUNK;
 762         }
 763     } else {
 764         if (s.vlan >= 0) {
 765             s.vlan_mode = PORT_VLAN_ACCESS;
 766             if (cfg->n_trunks) {
 767                 VLOG_ERR("port %s: ignoring trunks in favor of implicit vlan",
 768                          port->name);
 769             }
 770         } else {
 771             s.vlan_mode = PORT_VLAN_TRUNK;
 772         }
 773     }
 774     s.use_priority_tags = smap_get_bool(&cfg->other_config, "priority-tags",
 775                                         false);
 776
 777     /* Get LACP settings. */
 778     s.lacp = port_configure_lacp(port, &lacp_settings);
 779     if (s.lacp) {
 780         size_t i = 0;
 781
 782         s.lacp_slaves = xmalloc(s.n_slaves * sizeof *s.lacp_slaves);
 783         LIST_FOR_EACH (iface, port_elem, &port->ifaces) {
 784             iface_configure_lacp(iface, &s.lacp_slaves[i++]);
 785         }
 786     } else {
 787         s.lacp_slaves = NULL;
 788     }
 789
 790     /* Get bond settings. */
 791     if (s.n_slaves > 1) {
 792         s.bond = &bond_settings;
 793         port_configure_bond(port, &bond_settings);
 794     } else {
 795         s.bond = NULL;
 796         LIST_FOR_EACH (iface, port_elem, &port->ifaces) {
 797             netdev_set_miimon_interval(iface->netdev, 0);
 798         }
 799     }
 800
 801     /* Register. */
 802     ofproto_bundle_register(port->bridge->ofproto, port, &s);
 803
 804     /* Clean up. */
 805     free(s.slaves);
 806     free(s.trunks);
 807     free(s.lacp_slaves);
 808 }
 809
 810 static void
 811 bridge_configure_flow_miss_model(const char *opt)
 812 {
 813     enum ofproto_flow_miss_model model = OFPROTO_HANDLE_MISS_AUTO;
 814
 815     if (opt) {
 816         if (strcmp(opt, "with-facets")) {
 817             model = OFPROTO_HANDLE_MISS_WITH_FACETS;
 818         } else if (strcmp(opt, "without-facets")) {
 819             model = OFPROTO_HANDLE_MISS_WITHOUT_FACETS;
 820         }
 821     }
 822
 823     ofproto_set_flow_miss_model(model);
 824 }
 825
 826 /* Pick local port hardware address and datapath ID for 'br'. */
 827 static void
 828 bridge_configure_datapath_id(struct bridge *br)
 829 {
 830     uint8_t ea[ETH_ADDR_LEN];
 831     uint64_t dpid;
 832     struct iface *local_iface;
 833     struct iface *hw_addr_iface;
 834     char *dpid_string;
 835
 836     bridge_pick_local_hw_addr(br, ea, &hw_addr_iface);
 837     local_iface = iface_from_ofp_port(br, OFPP_LOCAL);
 838     if (local_iface) {
 839         int error = netdev_set_etheraddr(local_iface->netdev, ea);
 840         if (error) {
 841             static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
 842             VLOG_ERR_RL(&rl, "bridge %s: failed to set bridge "
 843                         "Ethernet address: %s",
 844                         br->name, ovs_strerror(error));
 845         }
 846     }
 847     memcpy(br->ea, ea, ETH_ADDR_LEN);
 848
 849     dpid = bridge_pick_datapath_id(br, ea, hw_addr_iface);
 850     if (dpid != ofproto_get_datapath_id(br->ofproto)) {
 851         VLOG_INFO("bridge %s: using datapath ID %016"PRIx64, br->name, dpid);
 852         ofproto_set_datapath_id(br->ofproto, dpid);
 853     }
 854
 855     dpid_string = xasprintf("%016"PRIx64, dpid);
 856     ovsrec_bridge_set_datapath_id(br->cfg, dpid_string);
 857     free(dpid_string);
 858 }
 859
 860 /* Returns a bitmap of "enum ofputil_protocol"s that are allowed for use with
 861  * 'br'. */
 862 static uint32_t
 863 bridge_get_allowed_versions(struct bridge *br)
 864 {
 865     if (!br->cfg->n_protocols)
 866         return 0;
 867
 868     return ofputil_versions_from_strings(br->cfg->protocols,
 869                                          br->cfg->n_protocols);
 870 }
 871
 872 /* Set NetFlow configuration on 'br'. */
 873 static void
 874 bridge_configure_netflow(struct bridge *br)
 875 {
 876     struct ovsrec_netflow *cfg = br->cfg->netflow;
 877     struct netflow_options opts;
 878
 879     if (!cfg) {
 880         ofproto_set_netflow(br->ofproto, NULL);
 881         return;
 882     }
 883
 884     memset(&opts, 0, sizeof opts);
 885
 886     /* Get default NetFlow configuration from datapath.
 887      * Apply overrides from 'cfg'. */
 888     ofproto_get_netflow_ids(br->ofproto, &opts.engine_type, &opts.engine_id);
 889     if (cfg->engine_type) {
 890         opts.engine_type = *cfg->engine_type;
 891     }
 892     if (cfg->engine_id) {
 893         opts.engine_id = *cfg->engine_id;
 894     }
 895
 896     /* Configure active timeout interval. */
 897     opts.active_timeout = cfg->active_timeout;
 898     if (!opts.active_timeout) {
 899         opts.active_timeout = -1;
 900     } else if (opts.active_timeout < 0) {
 901         VLOG_WARN("bridge %s: active timeout interval set to negative "
 902                   "value, using default instead (%d seconds)", br->name,
 903                   NF_ACTIVE_TIMEOUT_DEFAULT);
 904         opts.active_timeout = -1;
 905     }
 906
 907     /* Add engine ID to interface number to disambiguate bridgs? */
 908     opts.add_id_to_iface = cfg->add_id_to_interface;
 909     if (opts.add_id_to_iface) {
 910         if (opts.engine_id > 0x7f) {
 911             VLOG_WARN("bridge %s: NetFlow port mangling may conflict with "
 912                       "another vswitch, choose an engine id less than 128",
 913                       br->name);
 914         }
 915         if (hmap_count(&br->ports) > 508) {
 916             VLOG_WARN("bridge %s: NetFlow port mangling will conflict with "
 917                       "another port when more than 508 ports are used",
 918                       br->name);
 919         }
 920     }
 921
 922     /* Collectors. */
 923     sset_init(&opts.collectors);
 924     sset_add_array(&opts.collectors, cfg->targets, cfg->n_targets);
 925
 926     /* Configure. */
 927     if (ofproto_set_netflow(br->ofproto, &opts)) {
 928         VLOG_ERR("bridge %s: problem setting netflow collectors", br->name);
 929     }
 930     sset_destroy(&opts.collectors);
 931 }
 932
 933 /* Set sFlow configuration on 'br'. */
 934 static void
 935 bridge_configure_sflow(struct bridge *br, int *sflow_bridge_number)
 936 {
 937     const struct ovsrec_sflow *cfg = br->cfg->sflow;
 938     struct ovsrec_controller **controllers;
 939     struct ofproto_sflow_options oso;
 940     size_t n_controllers;
 941     size_t i;
 942
 943     if (!cfg) {
 944         ofproto_set_sflow(br->ofproto, NULL);
 945         return;
 946     }
 947
 948     memset(&oso, 0, sizeof oso);
 949
 950     sset_init(&oso.targets);
 951     sset_add_array(&oso.targets, cfg->targets, cfg->n_targets);
 952
 953     oso.sampling_rate = SFL_DEFAULT_SAMPLING_RATE;
 954     if (cfg->sampling) {
 955         oso.sampling_rate = *cfg->sampling;
 956     }
 957
 958     oso.polling_interval = SFL_DEFAULT_POLLING_INTERVAL;
 959     if (cfg->polling) {
 960         oso.polling_interval = *cfg->polling;
 961     }
 962
 963     oso.header_len = SFL_DEFAULT_HEADER_SIZE;
 964     if (cfg->header) {
 965         oso.header_len = *cfg->header;
 966     }
 967
 968     oso.sub_id = (*sflow_bridge_number)++;
 969     oso.agent_device = cfg->agent;
 970
 971     oso.control_ip = NULL;
 972     n_controllers = bridge_get_controllers(br, &controllers);
 973     for (i = 0; i < n_controllers; i++) {
 974         if (controllers[i]->local_ip) {
 975             oso.control_ip = controllers[i]->local_ip;
 976             break;
 977         }
 978     }
 979     ofproto_set_sflow(br->ofproto, &oso);
 980
 981     sset_destroy(&oso.targets);
 982 }
 983
 984 /* Returns whether a IPFIX row is valid. */
 985 static bool
 986 ovsrec_ipfix_is_valid(const struct ovsrec_ipfix *ipfix)
 987 {
 988     return ipfix && ipfix->n_targets > 0;
 989 }
 990
 991 /* Returns whether a Flow_Sample_Collector_Set row is valid. */
 992 static bool
 993 ovsrec_fscs_is_valid(const struct ovsrec_flow_sample_collector_set *fscs,
 994                      const struct bridge *br)
 995 {
 996     return ovsrec_ipfix_is_valid(fscs->ipfix) && fscs->bridge == br->cfg;
 997 }
 998
 999 /* Set IPFIX configuration on 'br'. */
1000 static void
1001 bridge_configure_ipfix(struct bridge *br)
1002 {
1003     const struct ovsrec_ipfix *be_cfg = br->cfg->ipfix;
1004     bool valid_be_cfg = ovsrec_ipfix_is_valid(be_cfg);
1005     const struct ovsrec_flow_sample_collector_set *fe_cfg;
1006     struct ofproto_ipfix_bridge_exporter_options be_opts;
1007     struct ofproto_ipfix_flow_exporter_options *fe_opts = NULL;
1008     size_t n_fe_opts = 0;
1009
1010     OVSREC_FLOW_SAMPLE_COLLECTOR_SET_FOR_EACH(fe_cfg, idl) {
1011         if (ovsrec_fscs_is_valid(fe_cfg, br)) {
1012             n_fe_opts++;
1013         }
1014     }
1015
1016     if (!valid_be_cfg && n_fe_opts == 0) {
1017         ofproto_set_ipfix(br->ofproto, NULL, NULL, 0);
1018         return;
1019     }
1020
1021     if (valid_be_cfg) {
1022         memset(&be_opts, 0, sizeof be_opts);
1023
1024         sset_init(&be_opts.targets);
1025         sset_add_array(&be_opts.targets, be_cfg->targets, be_cfg->n_targets);
1026
1027         if (be_cfg->sampling) {
1028             be_opts.sampling_rate = *be_cfg->sampling;
1029         } else {
1030             be_opts.sampling_rate = SFL_DEFAULT_SAMPLING_RATE;
1031         }
1032         if (be_cfg->obs_domain_id) {
1033             be_opts.obs_domain_id = *be_cfg->obs_domain_id;
1034         }
1035         if (be_cfg->obs_point_id) {
1036             be_opts.obs_point_id = *be_cfg->obs_point_id;
1037         }
1038         if (be_cfg->cache_active_timeout) {
1039             be_opts.cache_active_timeout = *be_cfg->cache_active_timeout;
1040         }
1041         if (be_cfg->cache_max_flows) {
1042             be_opts.cache_max_flows = *be_cfg->cache_max_flows;
1043         }
1044     }
1045
1046     if (n_fe_opts > 0) {
1047         struct ofproto_ipfix_flow_exporter_options *opts;
1048         fe_opts = xcalloc(n_fe_opts, sizeof *fe_opts);
1049         opts = fe_opts;
1050         OVSREC_FLOW_SAMPLE_COLLECTOR_SET_FOR_EACH(fe_cfg, idl) {
1051             if (ovsrec_fscs_is_valid(fe_cfg, br)) {
1052                 opts->collector_set_id = fe_cfg->id;
1053                 sset_init(&opts->targets);
1054                 sset_add_array(&opts->targets, fe_cfg->ipfix->targets,
1055                                fe_cfg->ipfix->n_targets);
1056                 opts->cache_active_timeout = fe_cfg->ipfix->cache_active_timeout
1057                     ? *fe_cfg->ipfix->cache_active_timeout : 0;
1058                 opts->cache_max_flows = fe_cfg->ipfix->cache_max_flows
1059                     ? *fe_cfg->ipfix->cache_max_flows : 0;
1060                 opts++;
1061             }
1062         }
1063     }
1064
1065     ofproto_set_ipfix(br->ofproto, valid_be_cfg ? &be_opts : NULL, fe_opts,
1066                       n_fe_opts);
1067
1068     if (valid_be_cfg) {
1069         sset_destroy(&be_opts.targets);
1070     }
1071
1072     if (n_fe_opts > 0) {
1073         struct ofproto_ipfix_flow_exporter_options *opts = fe_opts;
1074         size_t i;
1075         for (i = 0; i < n_fe_opts; i++) {
1076             sset_destroy(&opts->targets);
1077             opts++;
1078         }
1079         free(fe_opts);
1080     }
1081 }
1082
1083 static void
1084 port_configure_stp(const struct ofproto *ofproto, struct port *port,
1085                    struct ofproto_port_stp_settings *port_s,
1086                    int *port_num_counter, unsigned long *port_num_bitmap)
1087 {
1088     const char *config_str;
1089     struct iface *iface;
1090
1091     if (!smap_get_bool(&port->cfg->other_config, "stp-enable", true)) {
1092         port_s->enable = false;
1093         return;
1094     } else {
1095         port_s->enable = true;
1096     }
1097
1098     /* STP over bonds is not supported. */
1099     if (!list_is_singleton(&port->ifaces)) {
1100         VLOG_ERR("port %s: cannot enable STP on bonds, disabling",
1101                  port->name);
1102         port_s->enable = false;
1103         return;
1104     }
1105
1106     iface = CONTAINER_OF(list_front(&port->ifaces), struct iface, port_elem);
1107
1108     /* Internal ports shouldn't participate in spanning tree, so
1109      * skip them. */
1110     if (!strcmp(iface->type, "internal")) {
1111         VLOG_DBG("port %s: disable STP on internal ports", port->name);
1112         port_s->enable = false;
1113         return;
1114     }
1115
1116     /* STP on mirror output ports is not supported. */
1117     if (ofproto_is_mirror_output_bundle(ofproto, port)) {
1118         VLOG_DBG("port %s: disable STP on mirror ports", port->name);
1119         port_s->enable = false;
1120         return;
1121     }
1122
1123     config_str = smap_get(&port->cfg->other_config, "stp-port-num");
1124     if (config_str) {
1125         unsigned long int port_num = strtoul(config_str, NULL, 0);
1126         int port_idx = port_num - 1;
1127
1128         if (port_num < 1 || port_num > STP_MAX_PORTS) {
1129             VLOG_ERR("port %s: invalid stp-port-num", port->name);
1130             port_s->enable = false;
1131             return;
1132         }
1133
1134         if (bitmap_is_set(port_num_bitmap, port_idx)) {
1135             VLOG_ERR("port %s: duplicate stp-port-num %lu, disabling",
1136                     port->name, port_num);
1137             port_s->enable = false;
1138             return;
1139         }
1140         bitmap_set1(port_num_bitmap, port_idx);
1141         port_s->port_num = port_idx;
1142     } else {
1143         if (*port_num_counter >= STP_MAX_PORTS) {
1144             VLOG_ERR("port %s: too many STP ports, disabling", port->name);
1145             port_s->enable = false;
1146             return;
1147         }
1148
1149         port_s->port_num = (*port_num_counter)++;
1150     }
1151
1152     config_str = smap_get(&port->cfg->other_config, "stp-path-cost");
1153     if (config_str) {
1154         port_s->path_cost = strtoul(config_str, NULL, 10);
1155     } else {
1156         enum netdev_features current;
1157         unsigned int mbps;
1158
1159         netdev_get_features(iface->netdev, &current, NULL, NULL, NULL);
1160         mbps = netdev_features_to_bps(current, 100 * 1000 * 1000) / 1000000;
1161         port_s->path_cost = stp_convert_speed_to_cost(mbps);
1162     }
1163
1164     config_str = smap_get(&port->cfg->other_config, "stp-port-priority");
1165     if (config_str) {
1166         port_s->priority = strtoul(config_str, NULL, 0);
1167     } else {
1168         port_s->priority = STP_DEFAULT_PORT_PRIORITY;
1169     }
1170 }
1171
1172 /* Set spanning tree configuration on 'br'. */
1173 static void
1174 bridge_configure_stp(struct bridge *br)
1175 {
1176     if (!br->cfg->stp_enable) {
1177         ofproto_set_stp(br->ofproto, NULL);
1178     } else {
1179         struct ofproto_stp_settings br_s;
1180         const char *config_str;
1181         struct port *port;
1182         int port_num_counter;
1183         unsigned long *port_num_bitmap;
1184
1185         config_str = smap_get(&br->cfg->other_config, "stp-system-id");
1186         if (config_str) {
1187             uint8_t ea[ETH_ADDR_LEN];
1188
1189             if (eth_addr_from_string(config_str, ea)) {
1190                 br_s.system_id = eth_addr_to_uint64(ea);
1191             } else {
1192                 br_s.system_id = eth_addr_to_uint64(br->ea);
1193                 VLOG_ERR("bridge %s: invalid stp-system-id, defaulting "
1194                          "to "ETH_ADDR_FMT, br->name, ETH_ADDR_ARGS(br->ea));
1195             }
1196         } else {
1197             br_s.system_id = eth_addr_to_uint64(br->ea);
1198         }
1199
1200         config_str = smap_get(&br->cfg->other_config, "stp-priority");
1201         if (config_str) {
1202             br_s.priority = strtoul(config_str, NULL, 0);
1203         } else {
1204             br_s.priority = STP_DEFAULT_BRIDGE_PRIORITY;
1205         }
1206
1207         config_str = smap_get(&br->cfg->other_config, "stp-hello-time");
1208         if (config_str) {
1209             br_s.hello_time = strtoul(config_str, NULL, 10) * 1000;
1210         } else {
1211             br_s.hello_time = STP_DEFAULT_HELLO_TIME;
1212         }
1213
1214         config_str = smap_get(&br->cfg->other_config, "stp-max-age");
1215         if (config_str) {
1216             br_s.max_age = strtoul(config_str, NULL, 10) * 1000;
1217         } else {
1218             br_s.max_age = STP_DEFAULT_MAX_AGE;
1219         }
1220
1221         config_str = smap_get(&br->cfg->other_config, "stp-forward-delay");
1222         if (config_str) {
1223             br_s.fwd_delay = strtoul(config_str, NULL, 10) * 1000;
1224         } else {
1225             br_s.fwd_delay = STP_DEFAULT_FWD_DELAY;
1226         }
1227
1228         /* Configure STP on the bridge. */
1229         if (ofproto_set_stp(br->ofproto, &br_s)) {
1230             VLOG_ERR("bridge %s: could not enable STP", br->name);
1231             return;
1232         }
1233
1234         /* Users must either set the port number with the "stp-port-num"
1235          * configuration on all ports or none.  If manual configuration
1236          * is not done, then we allocate them sequentially. */
1237         port_num_counter = 0;
1238         port_num_bitmap = bitmap_allocate(STP_MAX_PORTS);
1239         HMAP_FOR_EACH (port, hmap_node, &br->ports) {
1240             struct ofproto_port_stp_settings port_s;
1241             struct iface *iface;
1242
1243             port_configure_stp(br->ofproto, port, &port_s,
1244                                &port_num_counter, port_num_bitmap);
1245
1246             /* As bonds are not supported, just apply configuration to
1247              * all interfaces. */
1248             LIST_FOR_EACH (iface, port_elem, &port->ifaces) {
1249                 if (ofproto_port_set_stp(br->ofproto, iface->ofp_port,
1250                                          &port_s)) {
1251                     VLOG_ERR("port %s: could not enable STP", port->name);
1252                     continue;
1253                 }
1254             }
1255         }
1256
1257         if (bitmap_scan(port_num_bitmap, 0, STP_MAX_PORTS) != STP_MAX_PORTS
1258                     && port_num_counter) {
1259             VLOG_ERR("bridge %s: must manually configure all STP port "
1260                      "IDs or none, disabling", br->name);
1261             ofproto_set_stp(br->ofproto, NULL);
1262         }
1263         bitmap_free(port_num_bitmap);
1264     }
1265 }
1266
1267 static bool
1268 bridge_has_bond_fake_iface(const struct bridge *br, const char *name)
1269 {
1270     const struct port *port = port_lookup(br, name);
1271     return port && port_is_bond_fake_iface(port);
1272 }
1273
1274 static bool
1275 port_is_bond_fake_iface(const struct port *port)
1276 {
1277     return port->cfg->bond_fake_iface && !list_is_short(&port->ifaces);
1278 }
1279
1280 static void
1281 add_del_bridges(const struct ovsrec_open_vswitch *cfg)
1282 {
1283     struct bridge *br, *next;
1284     struct shash new_br;
1285     size_t i;
1286
1287     /* Collect new bridges' names and types. */
1288     shash_init(&new_br);
1289     for (i = 0; i < cfg->n_bridges; i++) {
1290         static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
1291         const struct ovsrec_bridge *br_cfg = cfg->bridges[i];
1292
1293         if (strchr(br_cfg->name, '/')) {
1294             /* Prevent remote ovsdb-server users from accessing arbitrary
1295              * directories, e.g. consider a bridge named "../../../etc/". */
1296             VLOG_WARN_RL(&rl, "ignoring bridge with invalid name \"%s\"",
1297                          br_cfg->name);
1298         } else if (!shash_add_once(&new_br, br_cfg->name, br_cfg)) {
1299             VLOG_WARN_RL(&rl, "bridge %s specified twice", br_cfg->name);
1300         }
1301     }
1302
1303     /* Get rid of deleted bridges or those whose types have changed.
1304      * Update 'cfg' of bridges that still exist. */
1305     HMAP_FOR_EACH_SAFE (br, next, node, &all_bridges) {
1306         br->cfg = shash_find_data(&new_br, br->name);
1307         if (!br->cfg || strcmp(br->type, ofproto_normalize_type(
1308                                    br->cfg->datapath_type))) {
1309             bridge_destroy(br);
1310         }
1311     }
1312
1313     /* Add new bridges. */
1314     for (i = 0; i < cfg->n_bridges; i++) {
1315         const struct ovsrec_bridge *br_cfg = cfg->bridges[i];
1316         struct bridge *br = bridge_lookup(br_cfg->name);
1317         if (!br) {
1318             bridge_create(br_cfg);
1319         }
1320     }
1321
1322     shash_destroy(&new_br);
1323 }
1324
1325 /* Configures 'netdev' based on the "options" column in 'iface_cfg'.
1326  * Returns 0 if successful, otherwise a positive errno value. */
1327 static int
1328 iface_set_netdev_config(const struct ovsrec_interface *iface_cfg,
1329                         struct netdev *netdev)
1330 {
1331     return netdev_set_config(netdev, &iface_cfg->options);
1332 }
1333
1334 /* Opens a network device for 'if_cfg' and configures it.  If '*ofp_portp'
1335  * is OFPP_NONE, adds the network device to br->ofproto and stores the OpenFlow
1336  * port number in '*ofp_portp'; otherwise leaves br->ofproto and '*ofp_portp'
1337  * untouched.
1338  *
1339  * If successful, returns 0 and stores the network device in '*netdevp'.  On
1340  * failure, returns a positive errno value and stores NULL in '*netdevp'. */
1341 static int
1342 iface_do_create(const struct bridge *br,
1343                 const struct ovsrec_interface *iface_cfg,
1344                 const struct ovsrec_port *port_cfg,
1345                 ofp_port_t *ofp_portp, struct netdev **netdevp)
1346 {
1347     struct netdev *netdev = NULL;
1348     int error;
1349
1350     if (netdev_is_reserved_name(iface_cfg->name)) {
1351         VLOG_WARN("could not create interface %s, name is reserved",
1352                   iface_cfg->name);
1353         error = EINVAL;
1354         goto error;
1355     }
1356
1357     error = netdev_open(iface_cfg->name,
1358                         iface_get_type(iface_cfg, br->cfg), &netdev);
1359     if (error) {
1360         VLOG_WARN("could not open network device %s (%s)",
1361                   iface_cfg->name, ovs_strerror(error));
1362         goto error;
1363     }
1364
1365     error = iface_set_netdev_config(iface_cfg, netdev);
1366     if (error) {
1367         goto error;
1368     }
1369
1370     *ofp_portp = iface_pick_ofport(iface_cfg);
1371     error = ofproto_port_add(br->ofproto, netdev, ofp_portp);
1372     if (error) {
1373         goto error;
1374     }
1375
1376     VLOG_INFO("bridge %s: added interface %s on port %d",
1377               br->name, iface_cfg->name, *ofp_portp);
1378
1379     if ((port_cfg->vlan_mode && !strcmp(port_cfg->vlan_mode, "splinter"))
1380         || iface_is_internal(iface_cfg, br->cfg)) {
1381         netdev_turn_flags_on(netdev, NETDEV_UP, NULL);
1382     }
1383
1384     *netdevp = netdev;
1385     return 0;
1386
1387 error:
1388     *netdevp = NULL;
1389     netdev_close(netdev);
1390     return error;
1391 }
1392
1393 /* Creates a new iface on 'br' based on 'if_cfg'.  The new iface has OpenFlow
1394  * port number 'ofp_port'.  If ofp_port is OFPP_NONE, an OpenFlow port is
1395  * automatically allocated for the iface.  Takes ownership of and
1396  * deallocates 'if_cfg'.
1397  *
1398  * Return true if an iface is successfully created, false otherwise. */
1399 static bool
1400 iface_create(struct bridge *br, const struct ovsrec_interface *iface_cfg,
1401              const struct ovsrec_port *port_cfg)
1402 {
1403     struct netdev *netdev;
1404     struct iface *iface;
1405     ofp_port_t ofp_port;
1406     struct port *port;
1407     int error;
1408
1409     /* Do the bits that can fail up front.
1410      *
1411      * It's a bit dangerous to call bridge_run_fast() here as ofproto's
1412      * internal datastructures may not be consistent.  Eventually, when port
1413      * additions and deletions are cheaper, these calls should be removed. */
1414     bridge_run_fast();
1415     ovs_assert(!iface_lookup(br, iface_cfg->name));
1416     error = iface_do_create(br, iface_cfg, port_cfg, &ofp_port, &netdev);
1417     bridge_run_fast();
1418     if (error) {
1419         iface_set_ofport(iface_cfg, OFPP_NONE);
1420         iface_clear_db_record(iface_cfg);
1421         return false;
1422     }
1423
1424     /* Get or create the port structure. */
1425     port = port_lookup(br, port_cfg->name);
1426     if (!port) {
1427         port = port_create(br, port_cfg);
1428     }
1429
1430     /* Create the iface structure. */
1431     iface = xzalloc(sizeof *iface);
1432     list_push_back(&port->ifaces, &iface->port_elem);
1433     hmap_insert(&br->iface_by_name, &iface->name_node,
1434                 hash_string(iface_cfg->name, 0));
1435     iface->port = port;
1436     iface->name = xstrdup(iface_cfg->name);
1437     iface->ofp_port = ofp_port;
1438     iface->netdev = netdev;
1439     iface->type = iface_get_type(iface_cfg, br->cfg);
1440     iface->cfg = iface_cfg;
1441     hmap_insert(&br->ifaces, &iface->ofp_port_node,
1442                 hash_ofp_port(ofp_port));
1443
1444     iface_set_ofport(iface->cfg, ofp_port);
1445
1446     /* Populate initial status in database. */
1447     iface_refresh_stats(iface);
1448     iface_refresh_status(iface);
1449
1450     /* Add bond fake iface if necessary. */
1451     if (port_is_bond_fake_iface(port)) {
1452         struct ofproto_port ofproto_port;
1453
1454         if (ofproto_port_query_by_name(br->ofproto, port->name,
1455                                        &ofproto_port)) {
1456             struct netdev *netdev;
1457             int error;
1458
1459             error = netdev_open(port->name, "internal", &netdev);
1460             if (!error) {
1461                 ofp_port_t fake_ofp_port = iface_pick_ofport(iface_cfg);
1462                 ofproto_port_add(br->ofproto, netdev, &fake_ofp_port);
1463                 netdev_close(netdev);
1464             } else {
1465                 VLOG_WARN("could not open network device %s (%s)",
1466                           port->name, ovs_strerror(error));
1467             }
1468         } else {
1469             /* Already exists, nothing to do. */
1470             ofproto_port_destroy(&ofproto_port);
1471         }
1472     }
1473
1474     return true;
1475 }
1476
1477 /* Set forward BPDU option. */
1478 static void
1479 bridge_configure_forward_bpdu(struct bridge *br)
1480 {
1481     ofproto_set_forward_bpdu(br->ofproto,
1482                              smap_get_bool(&br->cfg->other_config,
1483                                            "forward-bpdu",
1484                                            false));
1485 }
1486
1487 /* Set MAC learning table configuration for 'br'. */
1488 static void
1489 bridge_configure_mac_table(struct bridge *br)
1490 {
1491     const char *idle_time_str;
1492     int idle_time;
1493
1494     const char *mac_table_size_str;
1495     int mac_table_size;
1496
1497     idle_time_str = smap_get(&br->cfg->other_config, "mac-aging-time");
1498     idle_time = (idle_time_str && atoi(idle_time_str)
1499                  ? atoi(idle_time_str)
1500                  : MAC_ENTRY_DEFAULT_IDLE_TIME);
1501
1502     mac_table_size_str = smap_get(&br->cfg->other_config, "mac-table-size");
1503     mac_table_size = (mac_table_size_str && atoi(mac_table_size_str)
1504                       ? atoi(mac_table_size_str)
1505                       : MAC_DEFAULT_MAX);
1506
1507     ofproto_set_mac_table_config(br->ofproto, idle_time, mac_table_size);
1508 }
1509
1510 static void
1511 bridge_pick_local_hw_addr(struct bridge *br, uint8_t ea[ETH_ADDR_LEN],
1512                           struct iface **hw_addr_iface)
1513 {
1514     struct hmapx mirror_output_ports;
1515     const char *hwaddr;
1516     struct port *port;
1517     bool found_addr = false;
1518     int error;
1519     int i;
1520
1521     *hw_addr_iface = NULL;
1522
1523     /* Did the user request a particular MAC? */
1524     hwaddr = smap_get(&br->cfg->other_config, "hwaddr");
1525     if (hwaddr && eth_addr_from_string(hwaddr, ea)) {
1526         if (eth_addr_is_multicast(ea)) {
1527             VLOG_ERR("bridge %s: cannot set MAC address to multicast "
1528                      "address "ETH_ADDR_FMT, br->name, ETH_ADDR_ARGS(ea));
1529         } else if (eth_addr_is_zero(ea)) {
1530             VLOG_ERR("bridge %s: cannot set MAC address to zero", br->name);
1531         } else {
1532             return;
1533         }
1534     }
1535
1536     /* Mirror output ports don't participate in picking the local hardware
1537      * address.  ofproto can't help us find out whether a given port is a
1538      * mirror output because we haven't configured mirrors yet, so we need to
1539      * accumulate them ourselves. */
1540     hmapx_init(&mirror_output_ports);
1541     for (i = 0; i < br->cfg->n_mirrors; i++) {
1542         struct ovsrec_mirror *m = br->cfg->mirrors[i];
1543         if (m->output_port) {
1544             hmapx_add(&mirror_output_ports, m->output_port);
1545         }
1546     }
1547
1548     /* Otherwise choose the minimum non-local MAC address among all of the
1549      * interfaces. */
1550     HMAP_FOR_EACH (port, hmap_node, &br->ports) {
1551         uint8_t iface_ea[ETH_ADDR_LEN];
1552         struct iface *candidate;
1553         struct iface *iface;
1554
1555         /* Mirror output ports don't participate. */
1556         if (hmapx_contains(&mirror_output_ports, port->cfg)) {
1557             continue;
1558         }
1559
1560         /* Choose the MAC address to represent the port. */
1561         iface = NULL;
1562         if (port->cfg->mac && eth_addr_from_string(port->cfg->mac, iface_ea)) {
1563             /* Find the interface with this Ethernet address (if any) so that
1564              * we can provide the correct devname to the caller. */
1565             LIST_FOR_EACH (candidate, port_elem, &port->ifaces) {
1566                 uint8_t candidate_ea[ETH_ADDR_LEN];
1567                 if (!netdev_get_etheraddr(candidate->netdev, candidate_ea)
1568                     && eth_addr_equals(iface_ea, candidate_ea)) {
1569                     iface = candidate;
1570                 }
1571             }
1572         } else {
1573             /* Choose the interface whose MAC address will represent the port.
1574              * The Linux kernel bonding code always chooses the MAC address of
1575              * the first slave added to a bond, and the Fedora networking
1576              * scripts always add slaves to a bond in alphabetical order, so
1577              * for compatibility we choose the interface with the name that is
1578              * first in alphabetical order. */
1579             LIST_FOR_EACH (candidate, port_elem, &port->ifaces) {
1580                 if (!iface || strcmp(candidate->name, iface->name) < 0) {
1581                     iface = candidate;
1582                 }
1583             }
1584
1585             /* The local port doesn't count (since we're trying to choose its
1586              * MAC address anyway). */
1587             if (iface->ofp_port == OFPP_LOCAL) {
1588                 continue;
1589             }
1590
1591             /* Grab MAC. */
1592             error = netdev_get_etheraddr(iface->netdev, iface_ea);
1593             if (error) {
1594                 continue;
1595             }
1596         }
1597
1598         /* Compare against our current choice. */
1599         if (!eth_addr_is_multicast(iface_ea) &&
1600             !eth_addr_is_local(iface_ea) &&
1601             !eth_addr_is_reserved(iface_ea) &&
1602             !eth_addr_is_zero(iface_ea) &&
1603             (!found_addr || eth_addr_compare_3way(iface_ea, ea) < 0))
1604         {
1605             memcpy(ea, iface_ea, ETH_ADDR_LEN);
1606             *hw_addr_iface = iface;
1607             found_addr = true;
1608         }
1609     }
1610
1611     if (!found_addr) {
1612         memcpy(ea, br->default_ea, ETH_ADDR_LEN);
1613         *hw_addr_iface = NULL;
1614     }
1615
1616     hmapx_destroy(&mirror_output_ports);
1617 }
1618
1619 /* Choose and returns the datapath ID for bridge 'br' given that the bridge
1620  * Ethernet address is 'bridge_ea'.  If 'bridge_ea' is the Ethernet address of
1621  * an interface on 'br', then that interface must be passed in as
1622  * 'hw_addr_iface'; if 'bridge_ea' was derived some other way, then
1623  * 'hw_addr_iface' must be passed in as a null pointer. */
1624 static uint64_t
1625 bridge_pick_datapath_id(struct bridge *br,
1626                         const uint8_t bridge_ea[ETH_ADDR_LEN],
1627                         struct iface *hw_addr_iface)
1628 {
1629     /*
1630      * The procedure for choosing a bridge MAC address will, in the most
1631      * ordinary case, also choose a unique MAC that we can use as a datapath
1632      * ID.  In some special cases, though, multiple bridges will end up with
1633      * the same MAC address.  This is OK for the bridges, but it will confuse
1634      * the OpenFlow controller, because each datapath needs a unique datapath
1635      * ID.
1636      *
1637      * Datapath IDs must be unique.  It is also very desirable that they be
1638      * stable from one run to the next, so that policy set on a datapath
1639      * "sticks".
1640      */
1641     const char *datapath_id;
1642     uint64_t dpid;
1643
1644     datapath_id = smap_get(&br->cfg->other_config, "datapath-id");
1645     if (datapath_id && dpid_from_string(datapath_id, &dpid)) {
1646         return dpid;
1647     }
1648
1649     if (!hw_addr_iface) {
1650         /*
1651          * A purely internal bridge, that is, one that has no non-virtual
1652          * network devices on it at all, is difficult because it has no
1653          * natural unique identifier at all.
1654          *
1655          * When the host is a XenServer, we handle this case by hashing the
1656          * host's UUID with the name of the bridge.  Names of bridges are
1657          * persistent across XenServer reboots, although they can be reused if
1658          * an internal network is destroyed and then a new one is later
1659          * created, so this is fairly effective.
1660          *
1661          * When the host is not a XenServer, we punt by using a random MAC
1662          * address on each run.
1663          */
1664         const char *host_uuid = xenserver_get_host_uuid();
1665         if (host_uuid) {
1666             char *combined = xasprintf("%s,%s", host_uuid, br->name);
1667             dpid = dpid_from_hash(combined, strlen(combined));
1668             free(combined);
1669             return dpid;
1670         }
1671     }
1672
1673     return eth_addr_to_uint64(bridge_ea);
1674 }
1675
1676 static uint64_t
1677 dpid_from_hash(const void *data, size_t n)
1678 {
1679     uint8_t hash[SHA1_DIGEST_SIZE];
1680
1681     BUILD_ASSERT_DECL(sizeof hash >= ETH_ADDR_LEN);
1682     sha1_bytes(data, n, hash);
1683     eth_addr_mark_random(hash);
1684     return eth_addr_to_uint64(hash);
1685 }
1686
1687 static void
1688 iface_refresh_status(struct iface *iface)
1689 {
1690     struct smap smap;
1691
1692     enum netdev_features current;
1693     int64_t bps;
1694     int mtu;
1695     int64_t mtu_64;
1696     uint8_t mac[ETH_ADDR_LEN];
1697     int64_t ifindex64;
1698     int error;
1699
1700     if (iface_is_synthetic(iface)) {
1701         return;
1702     }
1703
1704     smap_init(&smap);
1705
1706     if (!netdev_get_status(iface->netdev, &smap)) {
1707         ovsrec_interface_set_status(iface->cfg, &smap);
1708     } else {
1709         ovsrec_interface_set_status(iface->cfg, NULL);
1710     }
1711
1712     smap_destroy(&smap);
1713
1714     error = netdev_get_features(iface->netdev, &current, NULL, NULL, NULL);
1715     bps = !error ? netdev_features_to_bps(current, 0) : 0;
1716     if (bps) {
1717         ovsrec_interface_set_duplex(iface->cfg,
1718                                     netdev_features_is_full_duplex(current)
1719                                     ? "full" : "half");
1720         ovsrec_interface_set_link_speed(iface->cfg, &bps, 1);
1721     } else {
1722         ovsrec_interface_set_duplex(iface->cfg, NULL);
1723         ovsrec_interface_set_link_speed(iface->cfg, NULL, 0);
1724     }
1725
1726     error = netdev_get_mtu(iface->netdev, &mtu);
1727     if (!error) {
1728         mtu_64 = mtu;
1729         ovsrec_interface_set_mtu(iface->cfg, &mtu_64, 1);
1730     } else {
1731         ovsrec_interface_set_mtu(iface->cfg, NULL, 0);
1732     }
1733
1734     error = netdev_get_etheraddr(iface->netdev, mac);
1735     if (!error) {
1736         char mac_string[32];
1737
1738         sprintf(mac_string, ETH_ADDR_FMT, ETH_ADDR_ARGS(mac));
1739         ovsrec_interface_set_mac_in_use(iface->cfg, mac_string);
1740     } else {
1741         ovsrec_interface_set_mac_in_use(iface->cfg, NULL);
1742     }
1743
1744     /* The netdev may return a negative number (such as -EOPNOTSUPP)
1745      * if there is no valid ifindex number. */
1746     ifindex64 = netdev_get_ifindex(iface->netdev);
1747     if (ifindex64 < 0) {
1748         ifindex64 = 0;
1749     }
1750     ovsrec_interface_set_ifindex(iface->cfg, &ifindex64, 1);
1751 }
1752
1753 /* Writes 'iface''s CFM statistics to the database. 'iface' must not be
1754  * synthetic. */
1755 static void
1756 iface_refresh_cfm_stats(struct iface *iface)
1757 {
1758     const struct ovsrec_interface *cfg = iface->cfg;
1759     struct ofproto_cfm_status status;
1760
1761     if (!ofproto_port_get_cfm_status(iface->port->bridge->ofproto,
1762                                     iface->ofp_port, &status)) {
1763         ovsrec_interface_set_cfm_fault(cfg, NULL, 0);
1764         ovsrec_interface_set_cfm_fault_status(cfg, NULL, 0);
1765         ovsrec_interface_set_cfm_remote_opstate(cfg, NULL);
1766         ovsrec_interface_set_cfm_flap_count(cfg, NULL, 0);
1767         ovsrec_interface_set_cfm_health(cfg, NULL, 0);
1768         ovsrec_interface_set_cfm_remote_mpids(cfg, NULL, 0);
1769     } else {
1770         const char *reasons[CFM_FAULT_N_REASONS];
1771         int64_t cfm_health = status.health;
1772         int64_t cfm_flap_count = status.flap_count;
1773         bool faulted = status.faults != 0;
1774         size_t i, j;
1775
1776         ovsrec_interface_set_cfm_fault(cfg, &faulted, 1);
1777
1778         j = 0;
1779         for (i = 0; i < CFM_FAULT_N_REASONS; i++) {
1780             int reason = 1 << i;
1781             if (status.faults & reason) {
1782                 reasons[j++] = cfm_fault_reason_to_str(reason);
1783             }
1784         }
1785         ovsrec_interface_set_cfm_fault_status(cfg, (char **) reasons, j);
1786
1787         ovsrec_interface_set_cfm_flap_count(cfg, &cfm_flap_count, 1);
1788
1789         if (status.remote_opstate >= 0) {
1790             const char *remote_opstate = status.remote_opstate ? "up" : "down";
1791             ovsrec_interface_set_cfm_remote_opstate(cfg, remote_opstate);
1792         } else {
1793             ovsrec_interface_set_cfm_remote_opstate(cfg, NULL);
1794         }
1795
1796         ovsrec_interface_set_cfm_remote_mpids(cfg,
1797                                               (const int64_t *)status.rmps,
1798                                               status.n_rmps);
1799         if (cfm_health >= 0) {
1800             ovsrec_interface_set_cfm_health(cfg, &cfm_health, 1);
1801         } else {
1802             ovsrec_interface_set_cfm_health(cfg, NULL, 0);
1803         }
1804
1805         free(status.rmps);
1806     }
1807 }
1808
1809 static void
1810 iface_refresh_stats(struct iface *iface)
1811 {
1812 #define IFACE_STATS                             \
1813     IFACE_STAT(rx_packets,      "rx_packets")   \
1814     IFACE_STAT(tx_packets,      "tx_packets")   \
1815     IFACE_STAT(rx_bytes,        "rx_bytes")     \
1816     IFACE_STAT(tx_bytes,        "tx_bytes")     \
1817     IFACE_STAT(rx_dropped,      "rx_dropped")   \
1818     IFACE_STAT(tx_dropped,      "tx_dropped")   \
1819     IFACE_STAT(rx_errors,       "rx_errors")    \
1820     IFACE_STAT(tx_errors,       "tx_errors")    \
1821     IFACE_STAT(rx_frame_errors, "rx_frame_err") \
1822     IFACE_STAT(rx_over_errors,  "rx_over_err")  \
1823     IFACE_STAT(rx_crc_errors,   "rx_crc_err")   \
1824     IFACE_STAT(collisions,      "collisions")
1825
1826 #define IFACE_STAT(MEMBER, NAME) + 1
1827     enum { N_IFACE_STATS = IFACE_STATS };
1828 #undef IFACE_STAT
1829     int64_t values[N_IFACE_STATS];
1830     char *keys[N_IFACE_STATS];
1831     int n;
1832
1833     struct netdev_stats stats;
1834
1835     if (iface_is_synthetic(iface)) {
1836         return;
1837     }
1838
1839     /* Intentionally ignore return value, since errors will set 'stats' to
1840      * all-1s, and we will deal with that correctly below. */
1841     netdev_get_stats(iface->netdev, &stats);
1842
1843     /* Copy statistics into keys[] and values[]. */
1844     n = 0;
1845 #define IFACE_STAT(MEMBER, NAME)                \
1846     if (stats.MEMBER != UINT64_MAX) {           \
1847         keys[n] = NAME;                         \
1848         values[n] = stats.MEMBER;               \
1849         n++;                                    \
1850     }
1851     IFACE_STATS;
1852 #undef IFACE_STAT
1853     ovs_assert(n <= N_IFACE_STATS);
1854
1855     ovsrec_interface_set_statistics(iface->cfg, keys, values, n);
1856 #undef IFACE_STATS
1857 }
1858
1859 static void
1860 br_refresh_stp_status(struct bridge *br)
1861 {
1862     struct smap smap = SMAP_INITIALIZER(&smap);
1863     struct ofproto *ofproto = br->ofproto;
1864     struct ofproto_stp_status status;
1865
1866     if (ofproto_get_stp_status(ofproto, &status)) {
1867         return;
1868     }
1869
1870     if (!status.enabled) {
1871         ovsrec_bridge_set_status(br->cfg, NULL);
1872         return;
1873     }
1874
1875     smap_add_format(&smap, "stp_bridge_id", STP_ID_FMT,
1876                     STP_ID_ARGS(status.bridge_id));
1877     smap_add_format(&smap, "stp_designated_root", STP_ID_FMT,
1878                     STP_ID_ARGS(status.designated_root));
1879     smap_add_format(&smap, "stp_root_path_cost", "%d", status.root_path_cost);
1880
1881     ovsrec_bridge_set_status(br->cfg, &smap);
1882     smap_destroy(&smap);
1883 }
1884
1885 static void
1886 port_refresh_stp_status(struct port *port)
1887 {
1888     struct ofproto *ofproto = port->bridge->ofproto;
1889     struct iface *iface;
1890     struct ofproto_port_stp_status status;
1891     struct smap smap;
1892
1893     if (port_is_synthetic(port)) {
1894         return;
1895     }
1896
1897     /* STP doesn't currently support bonds. */
1898     if (!list_is_singleton(&port->ifaces)) {
1899         ovsrec_port_set_status(port->cfg, NULL);
1900         return;
1901     }
1902
1903     iface = CONTAINER_OF(list_front(&port->ifaces), struct iface, port_elem);
1904     if (ofproto_port_get_stp_status(ofproto, iface->ofp_port, &status)) {
1905         return;
1906     }
1907
1908     if (!status.enabled) {
1909         ovsrec_port_set_status(port->cfg, NULL);
1910         return;
1911     }
1912
1913     /* Set Status column. */
1914     smap_init(&smap);
1915     smap_add_format(&smap, "stp_port_id", STP_PORT_ID_FMT, status.port_id);
1916     smap_add(&smap, "stp_state", stp_state_name(status.state));
1917     smap_add_format(&smap, "stp_sec_in_state", "%u", status.sec_in_state);
1918     smap_add(&smap, "stp_role", stp_role_name(status.role));
1919     ovsrec_port_set_status(port->cfg, &smap);
1920     smap_destroy(&smap);
1921 }
1922
1923 static void
1924 port_refresh_stp_stats(struct port *port)
1925 {
1926     struct ofproto *ofproto = port->bridge->ofproto;
1927     struct iface *iface;
1928     struct ofproto_port_stp_stats stats;
1929     char *keys[3];
1930     int64_t int_values[3];
1931
1932     if (port_is_synthetic(port)) {
1933         return;
1934     }
1935
1936     /* STP doesn't currently support bonds. */
1937     if (!list_is_singleton(&port->ifaces)) {
1938         return;
1939     }
1940
1941     iface = CONTAINER_OF(list_front(&port->ifaces), struct iface, port_elem);
1942     if (ofproto_port_get_stp_stats(ofproto, iface->ofp_port, &stats)) {
1943         return;
1944     }
1945
1946     if (!stats.enabled) {
1947         ovsrec_port_set_statistics(port->cfg, NULL, NULL, 0);
1948         return;
1949     }
1950
1951     /* Set Statistics column. */
1952     keys[0] = "stp_tx_count";
1953     int_values[0] = stats.tx_count;
1954     keys[1] = "stp_rx_count";
1955     int_values[1] = stats.rx_count;
1956     keys[2] = "stp_error_count";
1957     int_values[2] = stats.error_count;
1958
1959     ovsrec_port_set_statistics(port->cfg, keys, int_values,
1960                                ARRAY_SIZE(int_values));
1961 }
1962
1963 static bool
1964 enable_system_stats(const struct ovsrec_open_vswitch *cfg)
1965 {
1966     return smap_get_bool(&cfg->other_config, "enable-statistics", false);
1967 }
1968
1969 static void
1970 reconfigure_system_stats(const struct ovsrec_open_vswitch *cfg)
1971 {
1972     bool enable = enable_system_stats(cfg);
1973
1974     system_stats_enable(enable);
1975     if (!enable) {
1976         ovsrec_open_vswitch_set_statistics(cfg, NULL);
1977     }
1978 }
1979
1980 static void
1981 run_system_stats(void)
1982 {
1983     const struct ovsrec_open_vswitch *cfg = ovsrec_open_vswitch_first(idl);
1984     struct smap *stats;
1985
1986     stats = system_stats_run();
1987     if (stats && cfg) {
1988         struct ovsdb_idl_txn *txn;
1989         struct ovsdb_datum datum;
1990
1991         txn = ovsdb_idl_txn_create(idl);
1992         ovsdb_datum_from_smap(&datum, stats);
1993         ovsdb_idl_txn_write(&cfg->header_, &ovsrec_open_vswitch_col_statistics,
1994                             &datum);
1995         ovsdb_idl_txn_commit(txn);
1996         ovsdb_idl_txn_destroy(txn);
1997
1998         free(stats);
1999     }
2000 }
2001
2002 static inline const char *
2003 ofp12_controller_role_to_str(enum ofp12_controller_role role)
2004 {
2005     switch (role) {
2006     case OFPCR12_ROLE_EQUAL:
2007         return "other";
2008     case OFPCR12_ROLE_MASTER:
2009         return "master";
2010     case OFPCR12_ROLE_SLAVE:
2011         return "slave";
2012     case OFPCR12_ROLE_NOCHANGE:
2013     default:
2014         return "*** INVALID ROLE ***";
2015     }
2016 }
2017
2018 static void
2019 refresh_controller_status(void)
2020 {
2021     struct bridge *br;
2022     struct shash info;
2023     const struct ovsrec_controller *cfg;
2024
2025     shash_init(&info);
2026
2027     /* Accumulate status for controllers on all bridges. */
2028     HMAP_FOR_EACH (br, node, &all_bridges) {
2029         ofproto_get_ofproto_controller_info(br->ofproto, &info);
2030     }
2031
2032     /* Update each controller in the database with current status. */
2033     OVSREC_CONTROLLER_FOR_EACH(cfg, idl) {
2034         struct ofproto_controller_info *cinfo =
2035             shash_find_data(&info, cfg->target);
2036
2037         if (cinfo) {
2038             struct smap smap = SMAP_INITIALIZER(&smap);
2039             const char **values = cinfo->pairs.values;
2040             const char **keys = cinfo->pairs.keys;
2041             size_t i;
2042
2043             for (i = 0; i < cinfo->pairs.n; i++) {
2044                 smap_add(&smap, keys[i], values[i]);
2045             }
2046
2047             ovsrec_controller_set_is_connected(cfg, cinfo->is_connected);
2048             ovsrec_controller_set_role(cfg, ofp12_controller_role_to_str(
2049                                            cinfo->role));
2050             ovsrec_controller_set_status(cfg, &smap);
2051             smap_destroy(&smap);
2052         } else {
2053             ovsrec_controller_set_is_connected(cfg, false);
2054             ovsrec_controller_set_role(cfg, NULL);
2055             ovsrec_controller_set_status(cfg, NULL);
2056         }
2057     }
2058
2059     ofproto_free_ofproto_controller_info(&info);
2060 }
2061 \f
2062 /* "Instant" stats.
2063  *
2064  * Some information in the database must be kept as up-to-date as possible to
2065  * allow controllers to respond rapidly to network outages.  We call these
2066  * statistics "instant" stats.
2067  *
2068  * We wish to update these statistics every INSTANT_INTERVAL_MSEC milliseconds,
2069  * assuming that they've changed.  The only means we have to determine whether
2070  * they have changed are:
2071  *
2072  *   - Try to commit changes to the database.  If nothing changed, then
2073  *     ovsdb_idl_txn_commit() returns TXN_UNCHANGED, otherwise some other
2074  *     value.
2075  *
2076  *   - instant_stats_run() is called late in the run loop, after anything that
2077  *     might change any of the instant stats.
2078  *
2079  * We use these two facts together to avoid waking the process up every
2080  * INSTANT_INTERVAL_MSEC whether there is any change or not.
2081  */
2082
2083 /* Minimum interval between writing updates to the instant stats to the
2084  * database. */
2085 #define INSTANT_INTERVAL_MSEC 100
2086
2087 /* Current instant stats database transaction, NULL if there is no ongoing
2088  * transaction. */
2089 static struct ovsdb_idl_txn *instant_txn;
2090
2091 /* Next time (in msec on monotonic clock) at which we will update the instant
2092  * stats.  */
2093 static long long int instant_next_txn = LLONG_MIN;
2094
2095 /* True if the run loop has run since we last saw that the instant stats were
2096  * unchanged, that is, this is true if we need to wake up at 'instant_next_txn'
2097  * to refresh the instant stats. */
2098 static bool instant_stats_could_have_changed;
2099
2100 static void
2101 instant_stats_run(void)
2102 {
2103     enum ovsdb_idl_txn_status status;
2104
2105     instant_stats_could_have_changed = true;
2106
2107     if (!instant_txn) {
2108         struct bridge *br;
2109
2110         if (time_msec() < instant_next_txn) {
2111             return;
2112         }
2113         instant_next_txn = time_msec() + INSTANT_INTERVAL_MSEC;
2114
2115         instant_txn = ovsdb_idl_txn_create(idl);
2116         HMAP_FOR_EACH (br, node, &all_bridges) {
2117             struct iface *iface;
2118             struct port *port;
2119
2120             br_refresh_stp_status(br);
2121
2122             HMAP_FOR_EACH (port, hmap_node, &br->ports) {
2123                 port_refresh_stp_status(port);
2124             }
2125
2126             HMAP_FOR_EACH (iface, name_node, &br->iface_by_name) {
2127                 enum netdev_flags flags;
2128                 struct smap smap;
2129                 const char *link_state;
2130                 int64_t link_resets;
2131                 int current, error;
2132
2133                 if (iface_is_synthetic(iface)) {
2134                     continue;
2135                 }
2136
2137                 current = ofproto_port_is_lacp_current(br->ofproto,
2138                                                        iface->ofp_port);
2139                 if (current >= 0) {
2140                     bool bl = current;
2141                     ovsrec_interface_set_lacp_current(iface->cfg, &bl, 1);
2142                 } else {
2143                     ovsrec_interface_set_lacp_current(iface->cfg, NULL, 0);
2144                 }
2145
2146                 error = netdev_get_flags(iface->netdev, &flags);
2147                 if (!error) {
2148                     const char *state = flags & NETDEV_UP ? "up" : "down";
2149                     ovsrec_interface_set_admin_state(iface->cfg, state);
2150                 } else {
2151                     ovsrec_interface_set_admin_state(iface->cfg, NULL);
2152                 }
2153
2154                 link_state = netdev_get_carrier(iface->netdev) ? "up" : "down";
2155                 ovsrec_interface_set_link_state(iface->cfg, link_state);
2156
2157                 link_resets = netdev_get_carrier_resets(iface->netdev);
2158                 ovsrec_interface_set_link_resets(iface->cfg, &link_resets, 1);
2159
2160                 iface_refresh_cfm_stats(iface);
2161
2162                 smap_init(&smap);
2163                 ofproto_port_get_bfd_status(br->ofproto, iface->ofp_port,
2164                                             &smap);
2165                 ovsrec_interface_set_bfd_status(iface->cfg, &smap);
2166                 smap_destroy(&smap);
2167             }
2168         }
2169     }
2170
2171     status = ovsdb_idl_txn_commit(instant_txn);
2172     if (status != TXN_INCOMPLETE) {
2173         ovsdb_idl_txn_destroy(instant_txn);
2174         instant_txn = NULL;
2175     }
2176     if (status == TXN_UNCHANGED) {
2177         instant_stats_could_have_changed = false;
2178     }
2179 }
2180
2181 static void
2182 instant_stats_wait(void)
2183 {
2184     if (instant_txn) {
2185         ovsdb_idl_txn_wait(instant_txn);
2186     } else if (instant_stats_could_have_changed) {
2187         poll_timer_wait_until(instant_next_txn);
2188     }
2189 }
2190 \f
2191 /* Performs periodic activity required by bridges that needs to be done with
2192  * the least possible latency.
2193  *
2194  * It makes sense to call this function a couple of times per poll loop, to
2195  * provide a significant performance boost on some benchmarks with ofprotos
2196  * that use the ofproto-dpif implementation. */
2197 void
2198 bridge_run_fast(void)
2199 {
2200     struct sset types;
2201     const char *type;
2202     struct bridge *br;
2203
2204     sset_init(&types);
2205     ofproto_enumerate_types(&types);
2206     SSET_FOR_EACH (type, &types) {
2207         ofproto_type_run_fast(type);
2208     }
2209     sset_destroy(&types);
2210
2211     HMAP_FOR_EACH (br, node, &all_bridges) {
2212         ofproto_run_fast(br->ofproto);
2213     }
2214 }
2215
2216 void
2217 bridge_run(void)
2218 {
2219     static struct ovsrec_open_vswitch null_cfg;
2220     const struct ovsrec_open_vswitch *cfg;
2221     struct sset types;
2222     const char *type;
2223
2224     bool vlan_splinters_changed;
2225     struct bridge *br;
2226
2227     ovsrec_open_vswitch_init(&null_cfg);
2228
2229     ovsdb_idl_run(idl);
2230
2231     if (ovsdb_idl_is_lock_contended(idl)) {
2232         static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 1);
2233         struct bridge *br, *next_br;
2234
2235         VLOG_ERR_RL(&rl, "another ovs-vswitchd process is running, "
2236                     "disabling this process (pid %ld) until it goes away",
2237                     (long int) getpid());
2238
2239         HMAP_FOR_EACH_SAFE (br, next_br, node, &all_bridges) {
2240             bridge_destroy(br);
2241         }
2242         /* Since we will not be running system_stats_run() in this process
2243          * with the current situation of multiple ovs-vswitchd daemons,
2244          * disable system stats collection. */
2245         system_stats_enable(false);
2246         return;
2247     } else if (!ovsdb_idl_has_lock(idl)) {
2248         return;
2249     }
2250     cfg = ovsrec_open_vswitch_first(idl);
2251
2252     /* Initialize the ofproto library.  This only needs to run once, but
2253      * it must be done after the configuration is set.  If the
2254      * initialization has already occurred, bridge_init_ofproto()
2255      * returns immediately. */
2256     bridge_init_ofproto(cfg);
2257
2258     /* Once the value of flow-restore-wait is false, we no longer should
2259      * check its value from the database. */
2260     if (cfg && ofproto_get_flow_restore_wait()) {
2261         ofproto_set_flow_restore_wait(smap_get_bool(&cfg->other_config,
2262                                         "flow-restore-wait", false));
2263     }
2264
2265     /* Let each datapath type do the work that it needs to do. */
2266     sset_init(&types);
2267     ofproto_enumerate_types(&types);
2268     SSET_FOR_EACH (type, &types) {
2269         ofproto_type_run(type);
2270     }
2271     sset_destroy(&types);
2272
2273     /* Let each bridge do the work that it needs to do. */
2274     HMAP_FOR_EACH (br, node, &all_bridges) {
2275         ofproto_run(br->ofproto);
2276     }
2277
2278     /* Re-configure SSL.  We do this on every trip through the main loop,
2279      * instead of just when the database changes, because the contents of the
2280      * key and certificate files can change without the database changing.
2281      *
2282      * We do this before bridge_reconfigure() because that function might
2283      * initiate SSL connections and thus requires SSL to be configured. */
2284     if (cfg && cfg->ssl) {
2285         const struct ovsrec_ssl *ssl = cfg->ssl;
2286
2287         stream_ssl_set_key_and_cert(ssl->private_key, ssl->certificate);
2288         stream_ssl_set_ca_cert_file(ssl->ca_cert, ssl->bootstrap_ca_cert);
2289     }
2290
2291     /* If VLAN splinters are in use, then we need to reconfigure if VLAN
2292      * usage has changed. */
2293     vlan_splinters_changed = false;
2294     if (vlan_splinters_enabled_anywhere) {
2295         HMAP_FOR_EACH (br, node, &all_bridges) {
2296             if (ofproto_has_vlan_usage_changed(br->ofproto)) {
2297                 vlan_splinters_changed = true;
2298                 break;
2299             }
2300         }
2301     }
2302
2303     if (ovsdb_idl_get_seqno(idl) != idl_seqno || vlan_splinters_changed) {
2304         struct ovsdb_idl_txn *txn;
2305
2306         idl_seqno = ovsdb_idl_get_seqno(idl);
2307         txn = ovsdb_idl_txn_create(idl);
2308         bridge_reconfigure(cfg ? cfg : &null_cfg);
2309
2310         if (cfg) {
2311             ovsrec_open_vswitch_set_cur_cfg(cfg, cfg->next_cfg);
2312         }
2313
2314         /* If we are completing our initial configuration for this run
2315          * of ovs-vswitchd, then keep the transaction around to monitor
2316          * it for completion. */
2317         if (initial_config_done) {
2318             ovsdb_idl_txn_commit(txn);
2319             ovsdb_idl_txn_destroy(txn);
2320         } else {
2321             initial_config_done = true;
2322             daemonize_txn = txn;
2323         }
2324     }
2325
2326     if (daemonize_txn) {
2327         enum ovsdb_idl_txn_status status = ovsdb_idl_txn_commit(daemonize_txn);
2328         if (status != TXN_INCOMPLETE) {
2329             ovsdb_idl_txn_destroy(daemonize_txn);
2330             daemonize_txn = NULL;
2331
2332             /* ovs-vswitchd has completed initialization, so allow the
2333              * process that forked us to exit successfully. */
2334             daemonize_complete();
2335
2336             vlog_enable_async();
2337
2338             VLOG_INFO_ONCE("%s (Open vSwitch) %s", program_name, VERSION);
2339         }
2340     }
2341
2342     /* Refresh interface and mirror stats if necessary. */
2343     if (time_msec() >= iface_stats_timer) {
2344         if (cfg) {
2345             struct ovsdb_idl_txn *txn;
2346
2347             txn = ovsdb_idl_txn_create(idl);
2348             HMAP_FOR_EACH (br, node, &all_bridges) {
2349                 struct port *port;
2350                 struct mirror *m;
2351
2352                 HMAP_FOR_EACH (port, hmap_node, &br->ports) {
2353                     struct iface *iface;
2354
2355                     LIST_FOR_EACH (iface, port_elem, &port->ifaces) {
2356                         iface_refresh_stats(iface);
2357                         iface_refresh_status(iface);
2358                     }
2359
2360                     port_refresh_stp_stats(port);
2361                 }
2362
2363                 HMAP_FOR_EACH (m, hmap_node, &br->mirrors) {
2364                     mirror_refresh_stats(m);
2365                 }
2366
2367             }
2368             refresh_controller_status();
2369             ovsdb_idl_txn_commit(txn);
2370             ovsdb_idl_txn_destroy(txn); /* XXX */
2371         }
2372
2373         iface_stats_timer = time_msec() + IFACE_STATS_INTERVAL;
2374     }
2375
2376     run_system_stats();
2377     instant_stats_run();
2378 }
2379
2380 void
2381 bridge_wait(void)
2382 {
2383     struct sset types;
2384     const char *type;
2385
2386     ovsdb_idl_wait(idl);
2387     if (daemonize_txn) {
2388         ovsdb_idl_txn_wait(daemonize_txn);
2389     }
2390
2391     sset_init(&types);
2392     ofproto_enumerate_types(&types);
2393     SSET_FOR_EACH (type, &types) {
2394         ofproto_type_wait(type);
2395     }
2396     sset_destroy(&types);
2397
2398     if (!hmap_is_empty(&all_bridges)) {
2399         struct bridge *br;
2400
2401         HMAP_FOR_EACH (br, node, &all_bridges) {
2402             ofproto_wait(br->ofproto);
2403         }
2404         poll_timer_wait_until(iface_stats_timer);
2405     }
2406
2407     system_stats_wait();
2408     instant_stats_wait();
2409 }
2410
2411 /* Adds some memory usage statistics for bridges into 'usage', for use with
2412  * memory_report(). */
2413 void
2414 bridge_get_memory_usage(struct simap *usage)
2415 {
2416     struct bridge *br;
2417
2418     HMAP_FOR_EACH (br, node, &all_bridges) {
2419         ofproto_get_memory_usage(br->ofproto, usage);
2420     }
2421 }
2422 \f
2423 /* QoS unixctl user interface functions. */
2424
2425 struct qos_unixctl_show_cbdata {
2426     struct ds *ds;
2427     struct iface *iface;
2428 };
2429
2430 static void
2431 qos_unixctl_show_queue(unsigned int queue_id,
2432                        const struct smap *details,
2433                        struct iface *iface,
2434                        struct ds *ds)
2435 {
2436     struct netdev_queue_stats stats;
2437     struct smap_node *node;
2438     int error;
2439
2440     ds_put_cstr(ds, "\n");
2441     if (queue_id) {
2442         ds_put_format(ds, "Queue %u:\n", queue_id);
2443     } else {
2444         ds_put_cstr(ds, "Default:\n");
2445     }
2446
2447     SMAP_FOR_EACH (node, details) {
2448         ds_put_format(ds, "\t%s: %s\n", node->key, node->value);
2449     }
2450
2451     error = netdev_get_queue_stats(iface->netdev, queue_id, &stats);
2452     if (!error) {
2453         if (stats.tx_packets != UINT64_MAX) {
2454             ds_put_format(ds, "\ttx_packets: %"PRIu64"\n", stats.tx_packets);
2455         }
2456
2457         if (stats.tx_bytes != UINT64_MAX) {
2458             ds_put_format(ds, "\ttx_bytes: %"PRIu64"\n", stats.tx_bytes);
2459         }
2460
2461         if (stats.tx_errors != UINT64_MAX) {
2462             ds_put_format(ds, "\ttx_errors: %"PRIu64"\n", stats.tx_errors);
2463         }
2464     } else {
2465         ds_put_format(ds, "\tFailed to get statistics for queue %u: %s",
2466                       queue_id, ovs_strerror(error));
2467     }
2468 }
2469
2470 static void
2471 qos_unixctl_show(struct unixctl_conn *conn, int argc OVS_UNUSED,
2472                  const char *argv[], void *aux OVS_UNUSED)
2473 {
2474     struct ds ds = DS_EMPTY_INITIALIZER;
2475     struct smap smap = SMAP_INITIALIZER(&smap);
2476     struct iface *iface;
2477     const char *type;
2478     struct smap_node *node;
2479
2480     iface = iface_find(argv[1]);
2481     if (!iface) {
2482         unixctl_command_reply_error(conn, "no such interface");
2483         return;
2484     }
2485
2486     netdev_get_qos(iface->netdev, &type, &smap);
2487
2488     if (*type != '\0') {
2489         struct netdev_queue_dump dump;
2490         struct smap details;
2491         unsigned int queue_id;
2492
2493         ds_put_format(&ds, "QoS: %s %s\n", iface->name, type);
2494
2495         SMAP_FOR_EACH (node, &smap) {
2496             ds_put_format(&ds, "%s: %s\n", node->key, node->value);
2497         }
2498
2499         smap_init(&details);
2500         NETDEV_QUEUE_FOR_EACH (&queue_id, &details, &dump, iface->netdev) {
2501             qos_unixctl_show_queue(queue_id, &details, iface, &ds);
2502         }
2503         smap_destroy(&details);
2504
2505         unixctl_command_reply(conn, ds_cstr(&ds));
2506     } else {
2507         ds_put_format(&ds, "QoS not configured on %s\n", iface->name);
2508         unixctl_command_reply_error(conn, ds_cstr(&ds));
2509     }
2510
2511     smap_destroy(&smap);
2512     ds_destroy(&ds);
2513 }
2514 \f
2515 /* Bridge reconfiguration functions. */
2516 static void
2517 bridge_create(const struct ovsrec_bridge *br_cfg)
2518 {
2519     struct bridge *br;
2520
2521     ovs_assert(!bridge_lookup(br_cfg->name));
2522     br = xzalloc(sizeof *br);
2523
2524     br->name = xstrdup(br_cfg->name);
2525     br->type = xstrdup(ofproto_normalize_type(br_cfg->datapath_type));
2526     br->cfg = br_cfg;
2527
2528     /* Derive the default Ethernet address from the bridge's UUID.  This should
2529      * be unique and it will be stable between ovs-vswitchd runs.  */
2530     memcpy(br->default_ea, &br_cfg->header_.uuid, ETH_ADDR_LEN);
2531     eth_addr_mark_random(br->default_ea);
2532
2533     hmap_init(&br->ports);
2534     hmap_init(&br->ifaces);
2535     hmap_init(&br->iface_by_name);
2536     hmap_init(&br->mirrors);
2537
2538     hmap_insert(&all_bridges, &br->node, hash_string(br->name, 0));
2539 }
2540
2541 static void
2542 bridge_destroy(struct bridge *br)
2543 {
2544     if (br) {
2545         struct mirror *mirror, *next_mirror;
2546         struct port *port, *next_port;
2547
2548         HMAP_FOR_EACH_SAFE (port, next_port, hmap_node, &br->ports) {
2549             port_destroy(port);
2550         }
2551         HMAP_FOR_EACH_SAFE (mirror, next_mirror, hmap_node, &br->mirrors) {
2552             mirror_destroy(mirror);
2553         }
2554
2555         hmap_remove(&all_bridges, &br->node);
2556         ofproto_destroy(br->ofproto);
2557         hmap_destroy(&br->ifaces);
2558         hmap_destroy(&br->ports);
2559         hmap_destroy(&br->iface_by_name);
2560         hmap_destroy(&br->mirrors);
2561         free(br->name);
2562         free(br->type);
2563         free(br);
2564     }
2565 }
2566
2567 static struct bridge *
2568 bridge_lookup(const char *name)
2569 {
2570     struct bridge *br;
2571
2572     HMAP_FOR_EACH_WITH_HASH (br, node, hash_string(name, 0), &all_bridges) {
2573         if (!strcmp(br->name, name)) {
2574             return br;
2575         }
2576     }
2577     return NULL;
2578 }
2579
2580 /* Handle requests for a listing of all flows known by the OpenFlow
2581  * stack, including those normally hidden. */
2582 static void
2583 bridge_unixctl_dump_flows(struct unixctl_conn *conn, int argc OVS_UNUSED,
2584                           const char *argv[], void *aux OVS_UNUSED)
2585 {
2586     struct bridge *br;
2587     struct ds results;
2588
2589     br = bridge_lookup(argv[1]);
2590     if (!br) {
2591         unixctl_command_reply_error(conn, "Unknown bridge");
2592         return;
2593     }
2594
2595     ds_init(&results);
2596     ofproto_get_all_flows(br->ofproto, &results);
2597
2598     unixctl_command_reply(conn, ds_cstr(&results));
2599     ds_destroy(&results);
2600 }
2601
2602 /* "bridge/reconnect [BRIDGE]": makes BRIDGE drop all of its controller
2603  * connections and reconnect.  If BRIDGE is not specified, then all bridges
2604  * drop their controller connections and reconnect. */
2605 static void
2606 bridge_unixctl_reconnect(struct unixctl_conn *conn, int argc,
2607                          const char *argv[], void *aux OVS_UNUSED)
2608 {
2609     struct bridge *br;
2610     if (argc > 1) {
2611         br = bridge_lookup(argv[1]);
2612         if (!br) {
2613             unixctl_command_reply_error(conn,  "Unknown bridge");
2614             return;
2615         }
2616         ofproto_reconnect_controllers(br->ofproto);
2617     } else {
2618         HMAP_FOR_EACH (br, node, &all_bridges) {
2619             ofproto_reconnect_controllers(br->ofproto);
2620         }
2621     }
2622     unixctl_command_reply(conn, NULL);
2623 }
2624
2625 static size_t
2626 bridge_get_controllers(const struct bridge *br,
2627                        struct ovsrec_controller ***controllersp)
2628 {
2629     struct ovsrec_controller **controllers;
2630     size_t n_controllers;
2631
2632     controllers = br->cfg->controller;
2633     n_controllers = br->cfg->n_controller;
2634
2635     if (n_controllers == 1 && !strcmp(controllers[0]->target, "none")) {
2636         controllers = NULL;
2637         n_controllers = 0;
2638     }
2639
2640     if (controllersp) {
2641         *controllersp = controllers;
2642     }
2643     return n_controllers;
2644 }
2645
2646 static void
2647 bridge_collect_wanted_ports(struct bridge *br,
2648                             const unsigned long int *splinter_vlans,
2649                             struct shash *wanted_ports)
2650 {
2651     size_t i;
2652
2653     shash_init(wanted_ports);
2654
2655     for (i = 0; i < br->cfg->n_ports; i++) {
2656         const char *name = br->cfg->ports[i]->name;
2657         if (!shash_add_once(wanted_ports, name, br->cfg->ports[i])) {
2658             VLOG_WARN("bridge %s: %s specified twice as bridge port",
2659                       br->name, name);
2660         }
2661     }
2662     if (bridge_get_controllers(br, NULL)
2663         && !shash_find(wanted_ports, br->name)) {
2664         VLOG_WARN("bridge %s: no port named %s, synthesizing one",
2665                   br->name, br->name);
2666
2667         ovsrec_interface_init(&br->synth_local_iface);
2668         ovsrec_port_init(&br->synth_local_port);
2669
2670         br->synth_local_port.interfaces = &br->synth_local_ifacep;
2671         br->synth_local_port.n_interfaces = 1;
2672         br->synth_local_port.name = br->name;
2673
2674         br->synth_local_iface.name = br->name;
2675         br->synth_local_iface.type = "internal";
2676
2677         br->synth_local_ifacep = &br->synth_local_iface;
2678
2679         shash_add(wanted_ports, br->name, &br->synth_local_port);
2680     }
2681
2682     if (splinter_vlans) {
2683         add_vlan_splinter_ports(br, splinter_vlans, wanted_ports);
2684     }
2685 }
2686
2687 /* Deletes "struct port"s and "struct iface"s under 'br' which aren't
2688  * consistent with 'br->cfg'.  Updates 'br->if_cfg_queue' with interfaces which
2689  * 'br' needs to complete its configuration. */
2690 static void
2691 bridge_del_ports(struct bridge *br, const struct shash *wanted_ports)
2692 {
2693     struct shash_node *port_node;
2694     struct port *port, *next;
2695
2696     /* Get rid of deleted ports.
2697      * Get rid of deleted interfaces on ports that still exist. */
2698     HMAP_FOR_EACH_SAFE (port, next, hmap_node, &br->ports) {
2699         port->cfg = shash_find_data(wanted_ports, port->name);
2700         if (!port->cfg) {
2701             port_destroy(port);
2702         } else {
2703             port_del_ifaces(port);
2704         }
2705     }
2706
2707     /* Update iface->cfg and iface->type in interfaces that still exist. */
2708     SHASH_FOR_EACH (port_node, wanted_ports) {
2709         const struct ovsrec_port *port = port_node->data;
2710         size_t i;
2711
2712         for (i = 0; i < port->n_interfaces; i++) {
2713             const struct ovsrec_interface *cfg = port->interfaces[i];
2714             struct iface *iface = iface_lookup(br, cfg->name);
2715             const char *type = iface_get_type(cfg, br->cfg);
2716
2717             if (iface) {
2718                 iface->cfg = cfg;
2719                 iface->type = type;
2720             } else if (!strcmp(type, "null")) {
2721                 VLOG_WARN_ONCE("%s: The null interface type is deprecated and"
2722                                " may be removed in February 2013. Please email"
2723                                " dev@openvswitch.org with concerns.",
2724                                cfg->name);
2725             } else {
2726                 /* We will add new interfaces later. */
2727             }
2728         }
2729     }
2730 }
2731
2732 /* Initializes 'oc' appropriately as a management service controller for
2733  * 'br'.
2734  *
2735  * The caller must free oc->target when it is no longer needed. */
2736 static void
2737 bridge_ofproto_controller_for_mgmt(const struct bridge *br,
2738                                    struct ofproto_controller *oc)
2739 {
2740     oc->target = xasprintf("punix:%s/%s.mgmt", ovs_rundir(), br->name);
2741     oc->max_backoff = 0;
2742     oc->probe_interval = 60;
2743     oc->band = OFPROTO_OUT_OF_BAND;
2744     oc->rate_limit = 0;
2745     oc->burst_limit = 0;
2746     oc->enable_async_msgs = true;
2747 }
2748
2749 /* Converts ovsrec_controller 'c' into an ofproto_controller in 'oc'.  */
2750 static void
2751 bridge_ofproto_controller_from_ovsrec(const struct ovsrec_controller *c,
2752                                       struct ofproto_controller *oc)
2753 {
2754     int dscp;
2755
2756     oc->target = c->target;
2757     oc->max_backoff = c->max_backoff ? *c->max_backoff / 1000 : 8;
2758     oc->probe_interval = c->inactivity_probe ? *c->inactivity_probe / 1000 : 5;
2759     oc->band = (!c->connection_mode || !strcmp(c->connection_mode, "in-band")
2760                 ? OFPROTO_IN_BAND : OFPROTO_OUT_OF_BAND);
2761     oc->rate_limit = c->controller_rate_limit ? *c->controller_rate_limit : 0;
2762     oc->burst_limit = (c->controller_burst_limit
2763                        ? *c->controller_burst_limit : 0);
2764     oc->enable_async_msgs = (!c->enable_async_messages
2765                              || *c->enable_async_messages);
2766     dscp = smap_get_int(&c->other_config, "dscp", DSCP_DEFAULT);
2767     if (dscp < 0 || dscp > 63) {
2768         dscp = DSCP_DEFAULT;
2769     }
2770     oc->dscp = dscp;
2771 }
2772
2773 /* Configures the IP stack for 'br''s local interface properly according to the
2774  * configuration in 'c'.  */
2775 static void
2776 bridge_configure_local_iface_netdev(struct bridge *br,
2777                                     struct ovsrec_controller *c)
2778 {
2779     struct netdev *netdev;
2780     struct in_addr mask, gateway;
2781
2782     struct iface *local_iface;
2783     struct in_addr ip;
2784
2785     /* If there's no local interface or no IP address, give up. */
2786     local_iface = iface_from_ofp_port(br, OFPP_LOCAL);
2787     if (!local_iface || !c->local_ip || !inet_aton(c->local_ip, &ip)) {
2788         return;
2789     }
2790
2791     /* Bring up the local interface. */
2792     netdev = local_iface->netdev;
2793     netdev_turn_flags_on(netdev, NETDEV_UP, NULL);
2794
2795     /* Configure the IP address and netmask. */
2796     if (!c->local_netmask
2797         || !inet_aton(c->local_netmask, &mask)
2798         || !mask.s_addr) {
2799         mask.s_addr = guess_netmask(ip.s_addr);
2800     }
2801     if (!netdev_set_in4(netdev, ip, mask)) {
2802         VLOG_INFO("bridge %s: configured IP address "IP_FMT", netmask "IP_FMT,
2803                   br->name, IP_ARGS(ip.s_addr), IP_ARGS(mask.s_addr));
2804     }
2805
2806     /* Configure the default gateway. */
2807     if (c->local_gateway
2808         && inet_aton(c->local_gateway, &gateway)
2809         && gateway.s_addr) {
2810         if (!netdev_add_router(netdev, gateway)) {
2811             VLOG_INFO("bridge %s: configured gateway "IP_FMT,
2812                       br->name, IP_ARGS(gateway.s_addr));
2813         }
2814     }
2815 }
2816
2817 /* Returns true if 'a' and 'b' are the same except that any number of slashes
2818  * in either string are treated as equal to any number of slashes in the other,
2819  * e.g. "x///y" is equal to "x/y".
2820  *
2821  * Also, if 'b_stoplen' bytes from 'b' are found to be equal to corresponding
2822  * bytes from 'a', the function considers this success.  Specify 'b_stoplen' as
2823  * SIZE_MAX to compare all of 'a' to all of 'b' rather than just a prefix of
2824  * 'b' against a prefix of 'a'.
2825  */
2826 static bool
2827 equal_pathnames(const char *a, const char *b, size_t b_stoplen)
2828 {
2829     const char *b_start = b;
2830     for (;;) {
2831         if (b - b_start >= b_stoplen) {
2832             return true;
2833         } else if (*a != *b) {
2834             return false;
2835         } else if (*a == '/') {
2836             a += strspn(a, "/");
2837             b += strspn(b, "/");
2838         } else if (*a == '\0') {
2839             return true;
2840         } else {
2841             a++;
2842             b++;
2843         }
2844     }
2845 }
2846
2847 static void
2848 bridge_configure_remotes(struct bridge *br,
2849                          const struct sockaddr_in *managers, size_t n_managers)
2850 {
2851     bool disable_in_band;
2852
2853     struct ovsrec_controller **controllers;
2854     size_t n_controllers;
2855
2856     enum ofproto_fail_mode fail_mode;
2857
2858     struct ofproto_controller *ocs;
2859     size_t n_ocs;
2860     size_t i;
2861
2862     /* Check if we should disable in-band control on this bridge. */
2863     disable_in_band = smap_get_bool(&br->cfg->other_config, "disable-in-band",
2864                                     false);
2865
2866     /* Set OpenFlow queue ID for in-band control. */
2867     ofproto_set_in_band_queue(br->ofproto,
2868                               smap_get_int(&br->cfg->other_config,
2869                                            "in-band-queue", -1));
2870
2871     if (disable_in_band) {
2872         ofproto_set_extra_in_band_remotes(br->ofproto, NULL, 0);
2873     } else {
2874         ofproto_set_extra_in_band_remotes(br->ofproto, managers, n_managers);
2875     }
2876
2877     n_controllers = bridge_get_controllers(br, &controllers);
2878
2879     ocs = xmalloc((n_controllers + 1) * sizeof *ocs);
2880     n_ocs = 0;
2881
2882     bridge_ofproto_controller_for_mgmt(br, &ocs[n_ocs++]);
2883     for (i = 0; i < n_controllers; i++) {
2884         struct ovsrec_controller *c = controllers[i];
2885
2886         if (!strncmp(c->target, "punix:", 6)
2887             || !strncmp(c->target, "unix:", 5)) {
2888             static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
2889             char *whitelist;
2890
2891             if (!strncmp(c->target, "unix:", 5)) {
2892                 /* Connect to a listening socket */
2893                 whitelist = xasprintf("unix:%s/", ovs_rundir());
2894                 if (strchr(c->target, '/') &&
2895                    !equal_pathnames(c->target, whitelist,
2896                      strlen(whitelist))) {
2897                     /* Absolute path specified, but not in ovs_rundir */
2898                     VLOG_ERR_RL(&rl, "bridge %s: Not connecting to socket "
2899                                   "controller \"%s\" due to possibility for "
2900                                   "remote exploit.  Instead, specify socket "
2901                                   "in whitelisted \"%s\" or connect to "
2902                                   "\"unix:%s/%s.mgmt\" (which is always "
2903                                   "available without special configuration).",
2904                                   br->name, c->target, whitelist,
2905                                   ovs_rundir(), br->name);
2906                     free(whitelist);
2907                     continue;
2908                 }
2909             } else {
2910                whitelist = xasprintf("punix:%s/%s.controller",
2911                                      ovs_rundir(), br->name);
2912                if (!equal_pathnames(c->target, whitelist, SIZE_MAX)) {
2913                    /* Prevent remote ovsdb-server users from accessing
2914                     * arbitrary Unix domain sockets and overwriting arbitrary
2915                     * local files. */
2916                    VLOG_ERR_RL(&rl, "bridge %s: Not adding Unix domain socket "
2917                                   "controller \"%s\" due to possibility of "
2918                                   "overwriting local files. Instead, specify "
2919                                   "whitelisted \"%s\" or connect to "
2920                                   "\"unix:%s/%s.mgmt\" (which is always "
2921                                   "available without special configuration).",
2922                                   br->name, c->target, whitelist,
2923                                   ovs_rundir(), br->name);
2924                    free(whitelist);
2925                    continue;
2926                }
2927             }
2928
2929             free(whitelist);
2930         }
2931
2932         bridge_configure_local_iface_netdev(br, c);
2933         bridge_ofproto_controller_from_ovsrec(c, &ocs[n_ocs]);
2934         if (disable_in_band) {
2935             ocs[n_ocs].band = OFPROTO_OUT_OF_BAND;
2936         }
2937         n_ocs++;
2938     }
2939
2940     ofproto_set_controllers(br->ofproto, ocs, n_ocs,
2941                             bridge_get_allowed_versions(br));
2942     free(ocs[0].target); /* From bridge_ofproto_controller_for_mgmt(). */
2943     free(ocs);
2944
2945     /* Set the fail-mode. */
2946     fail_mode = !br->cfg->fail_mode
2947                 || !strcmp(br->cfg->fail_mode, "standalone")
2948                     ? OFPROTO_FAIL_STANDALONE
2949                     : OFPROTO_FAIL_SECURE;
2950     ofproto_set_fail_mode(br->ofproto, fail_mode);
2951
2952     /* Configure OpenFlow controller connection snooping. */
2953     if (!ofproto_has_snoops(br->ofproto)) {
2954         struct sset snoops;
2955
2956         sset_init(&snoops);
2957         sset_add_and_free(&snoops, xasprintf("punix:%s/%s.snoop",
2958                                              ovs_rundir(), br->name));
2959         ofproto_set_snoops(br->ofproto, &snoops);
2960         sset_destroy(&snoops);
2961     }
2962 }
2963
2964 static void
2965 bridge_configure_tables(struct bridge *br)
2966 {
2967     static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
2968     int n_tables;
2969     int i, j, k;
2970
2971     n_tables = ofproto_get_n_tables(br->ofproto);
2972     j = 0;
2973     for (i = 0; i < n_tables; i++) {
2974         struct ofproto_table_settings s;
2975
2976         s.name = NULL;
2977         s.max_flows = UINT_MAX;
2978         s.groups = NULL;
2979         s.n_groups = 0;
2980         s.n_prefix_fields = 0;
2981         memset(s.prefix_fields, ~0, sizeof(s.prefix_fields));
2982
2983         if (j < br->cfg->n_flow_tables && i == br->cfg->key_flow_tables[j]) {
2984             struct ovsrec_flow_table *cfg = br->cfg->value_flow_tables[j++];
2985
2986             s.name = cfg->name;
2987             if (cfg->n_flow_limit && *cfg->flow_limit < UINT_MAX) {
2988                 s.max_flows = *cfg->flow_limit;
2989             }
2990             if (cfg->overflow_policy
2991                 && !strcmp(cfg->overflow_policy, "evict")) {
2992
2993                 s.groups = xmalloc(cfg->n_groups * sizeof *s.groups);
2994                 for (k = 0; k < cfg->n_groups; k++) {
2995                     const char *string = cfg->groups[k];
2996                     char *msg;
2997
2998                     msg = mf_parse_subfield__(&s.groups[k], &string);
2999                     if (msg) {
3000                         VLOG_WARN_RL(&rl, "bridge %s table %d: error parsing "
3001                                      "'groups' (%s)", br->name, i, msg);
3002                         free(msg);
3003                     } else if (*string) {
3004                         VLOG_WARN_RL(&rl, "bridge %s table %d: 'groups' "
3005                                      "element '%s' contains trailing garbage",
3006                                      br->name, i, cfg->groups[k]);
3007                     } else {
3008                         s.n_groups++;
3009                     }
3010                 }
3011             }
3012             /* Prefix lookup fields. */
3013             s.n_prefix_fields = 0;
3014             for (k = 0; k < cfg->n_prefixes; k++) {
3015                 const char *name = cfg->prefixes[k];
3016                 const struct mf_field *mf = mf_from_name(name);
3017                 if (!mf) {
3018                     VLOG_WARN("bridge %s: 'prefixes' with unknown field: %s",
3019                               br->name, name);
3020                     continue;
3021                 }
3022                 if (mf->flow_be32ofs < 0 || mf->n_bits % 32) {
3023                     VLOG_WARN("bridge %s: 'prefixes' with incompatible field: "
3024                               "%s", br->name, name);
3025                     continue;
3026                 }
3027                 if (s.n_prefix_fields >= ARRAY_SIZE(s.prefix_fields)) {
3028                     VLOG_WARN("bridge %s: 'prefixes' with too many fields, "
3029                               "field not used: %s", br->name, name);
3030                     continue;
3031                 }
3032                 s.prefix_fields[s.n_prefix_fields++] = mf->id;
3033             }
3034             if (s.n_prefix_fields > 0) {
3035                 int k;
3036                 struct ds ds = DS_EMPTY_INITIALIZER;
3037                 for (k = 0; k < s.n_prefix_fields; k++) {
3038                     if (k) {
3039                         ds_put_char(&ds, ',');
3040                     }
3041                     ds_put_cstr(&ds, mf_from_id(s.prefix_fields[k])->name);
3042                 }
3043                 VLOG_INFO("bridge %s table %d: Prefix lookup with: %s.",
3044                           br->name, i, ds_cstr(&ds));
3045                 ds_destroy(&ds);
3046             }
3047         }
3048
3049         ofproto_configure_table(br->ofproto, i, &s);
3050
3051         free(s.groups);
3052     }
3053     for (; j < br->cfg->n_flow_tables; j++) {
3054         VLOG_WARN_RL(&rl, "bridge %s: ignoring configuration for flow table "
3055                      "%"PRId64" not supported by this datapath", br->name,
3056                      br->cfg->key_flow_tables[j]);
3057     }
3058 }
3059
3060 static void
3061 bridge_configure_dp_desc(struct bridge *br)
3062 {
3063     ofproto_set_dp_desc(br->ofproto,
3064                         smap_get(&br->cfg->other_config, "dp-desc"));
3065 }
3066 \f
3067 /* Port functions. */
3068
3069 static void iface_destroy__(struct iface *);
3070
3071 static struct port *
3072 port_create(struct bridge *br, const struct ovsrec_port *cfg)
3073 {
3074     struct port *port;
3075
3076     port = xzalloc(sizeof *port);
3077     port->bridge = br;
3078     port->name = xstrdup(cfg->name);
3079     port->cfg = cfg;
3080     list_init(&port->ifaces);
3081
3082     hmap_insert(&br->ports, &port->hmap_node, hash_string(port->name, 0));
3083     return port;
3084 }
3085
3086 /* Deletes interfaces from 'port' that are no longer configured for it. */
3087 static void
3088 port_del_ifaces(struct port *port)
3089 {
3090     struct iface *iface, *next;
3091     struct sset new_ifaces;
3092     size_t i;
3093
3094     /* Collect list of new interfaces. */
3095     sset_init(&new_ifaces);
3096     for (i = 0; i < port->cfg->n_interfaces; i++) {
3097         const char *name = port->cfg->interfaces[i]->name;
3098         const char *type = port->cfg->interfaces[i]->type;
3099         if (strcmp(type, "null")) {
3100             sset_add(&new_ifaces, name);
3101         }
3102     }
3103
3104     /* Get rid of deleted interfaces. */
3105     LIST_FOR_EACH_SAFE (iface, next, port_elem, &port->ifaces) {
3106         if (!sset_contains(&new_ifaces, iface->name)) {
3107             iface_destroy(iface);
3108         }
3109     }
3110
3111     sset_destroy(&new_ifaces);
3112 }
3113
3114 static void
3115 port_destroy(struct port *port)
3116 {
3117     if (port) {
3118         struct bridge *br = port->bridge;
3119         struct iface *iface, *next;
3120
3121         if (br->ofproto) {
3122             ofproto_bundle_unregister(br->ofproto, port);
3123         }
3124
3125         LIST_FOR_EACH_SAFE (iface, next, port_elem, &port->ifaces) {
3126             iface_destroy__(iface);
3127         }
3128
3129         hmap_remove(&br->ports, &port->hmap_node);
3130         free(port->name);
3131         free(port);
3132     }
3133 }
3134
3135 static struct port *
3136 port_lookup(const struct bridge *br, const char *name)
3137 {
3138     struct port *port;
3139
3140     HMAP_FOR_EACH_WITH_HASH (port, hmap_node, hash_string(name, 0),
3141                              &br->ports) {
3142         if (!strcmp(port->name, name)) {
3143             return port;
3144         }
3145     }
3146     return NULL;
3147 }
3148
3149 static bool
3150 enable_lacp(struct port *port, bool *activep)
3151 {
3152     if (!port->cfg->lacp) {
3153         /* XXX when LACP implementation has been sufficiently tested, enable by
3154          * default and make active on bonded ports. */
3155         return false;
3156     } else if (!strcmp(port->cfg->lacp, "off")) {
3157         return false;
3158     } else if (!strcmp(port->cfg->lacp, "active")) {
3159         *activep = true;
3160         return true;
3161     } else if (!strcmp(port->cfg->lacp, "passive")) {
3162         *activep = false;
3163         return true;
3164     } else {
3165         VLOG_WARN("port %s: unknown LACP mode %s",
3166                   port->name, port->cfg->lacp);
3167         return false;
3168     }
3169 }
3170
3171 static struct lacp_settings *
3172 port_configure_lacp(struct port *port, struct lacp_settings *s)
3173 {
3174     const char *lacp_time, *system_id;
3175     int priority;
3176
3177     if (!enable_lacp(port, &s->active)) {
3178         return NULL;
3179     }
3180
3181     s->name = port->name;
3182
3183     system_id = smap_get(&port->cfg->other_config, "lacp-system-id");
3184     if (system_id) {
3185         if (!ovs_scan(system_id, ETH_ADDR_SCAN_FMT,
3186                       ETH_ADDR_SCAN_ARGS(s->id))) {
3187             VLOG_WARN("port %s: LACP system ID (%s) must be an Ethernet"
3188                       " address.", port->name, system_id);
3189             return NULL;
3190         }
3191     } else {
3192         memcpy(s->id, port->bridge->ea, ETH_ADDR_LEN);
3193     }
3194
3195     if (eth_addr_is_zero(s->id)) {
3196         VLOG_WARN("port %s: Invalid zero LACP system ID.", port->name);
3197         return NULL;
3198     }
3199
3200     /* Prefer bondable links if unspecified. */
3201     priority = smap_get_int(&port->cfg->other_config, "lacp-system-priority",
3202                             0);
3203     s->priority = (priority > 0 && priority <= UINT16_MAX
3204                    ? priority
3205                    : UINT16_MAX - !list_is_short(&port->ifaces));
3206
3207     lacp_time = smap_get(&port->cfg->other_config, "lacp-time");
3208     s->fast = lacp_time && !strcasecmp(lacp_time, "fast");
3209
3210     s->fallback_ab_cfg = smap_get_bool(&port->cfg->other_config,
3211                                        "lacp-fallback-ab", false);
3212
3213     return s;
3214 }
3215
3216 static void
3217 iface_configure_lacp(struct iface *iface, struct lacp_slave_settings *s)
3218 {
3219     int priority, portid, key;
3220
3221     portid = smap_get_int(&iface->cfg->other_config, "lacp-port-id", 0);
3222     priority = smap_get_int(&iface->cfg->other_config, "lacp-port-priority",
3223                             0);
3224     key = smap_get_int(&iface->cfg->other_config, "lacp-aggregation-key", 0);
3225
3226     if (portid <= 0 || portid > UINT16_MAX) {
3227         portid = ofp_to_u16(iface->ofp_port);
3228     }
3229
3230     if (priority <= 0 || priority > UINT16_MAX) {
3231         priority = UINT16_MAX;
3232     }
3233
3234     if (key < 0 || key > UINT16_MAX) {
3235         key = 0;
3236     }
3237
3238     s->name = iface->name;
3239     s->id = portid;
3240     s->priority = priority;
3241     s->key = key;
3242 }
3243
3244 static void
3245 port_configure_bond(struct port *port, struct bond_settings *s)
3246 {
3247     const char *detect_s;
3248     struct iface *iface;
3249     int miimon_interval;
3250
3251     s->name = port->name;
3252     s->balance = BM_AB;
3253     if (port->cfg->bond_mode) {
3254         if (!bond_mode_from_string(&s->balance, port->cfg->bond_mode)) {
3255             VLOG_WARN("port %s: unknown bond_mode %s, defaulting to %s",
3256                       port->name, port->cfg->bond_mode,
3257                       bond_mode_to_string(s->balance));
3258         }
3259     } else {
3260         static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 1);
3261
3262         /* XXX: Post version 1.5.*, the default bond_mode changed from SLB to
3263          * active-backup. At some point we should remove this warning. */
3264         VLOG_WARN_RL(&rl, "port %s: Using the default bond_mode %s. Note that"
3265                      " in previous versions, the default bond_mode was"
3266                      " balance-slb", port->name,
3267                      bond_mode_to_string(s->balance));
3268     }
3269     if (s->balance == BM_SLB && port->bridge->cfg->n_flood_vlans) {
3270         VLOG_WARN("port %s: SLB bonds are incompatible with flood_vlans, "
3271                   "please use another bond type or disable flood_vlans",
3272                   port->name);
3273     }
3274
3275     miimon_interval = smap_get_int(&port->cfg->other_config,
3276                                    "bond-miimon-interval", 0);
3277     if (miimon_interval <= 0) {
3278         miimon_interval = 200;
3279     }
3280
3281     detect_s = smap_get(&port->cfg->other_config, "bond-detect-mode");
3282     if (!detect_s || !strcmp(detect_s, "carrier")) {
3283         miimon_interval = 0;
3284     } else if (strcmp(detect_s, "miimon")) {
3285         VLOG_WARN("port %s: unsupported bond-detect-mode %s, "
3286                   "defaulting to carrier", port->name, detect_s);
3287         miimon_interval = 0;
3288     }
3289
3290     s->up_delay = MAX(0, port->cfg->bond_updelay);
3291     s->down_delay = MAX(0, port->cfg->bond_downdelay);
3292     s->basis = smap_get_int(&port->cfg->other_config, "bond-hash-basis", 0);
3293     s->rebalance_interval = smap_get_int(&port->cfg->other_config,
3294                                            "bond-rebalance-interval", 10000);
3295     if (s->rebalance_interval && s->rebalance_interval < 1000) {
3296         s->rebalance_interval = 1000;
3297     }
3298
3299     s->fake_iface = port->cfg->bond_fake_iface;
3300
3301     s->lacp_fallback_ab_cfg = smap_get_bool(&port->cfg->other_config,
3302                                        "lacp-fallback-ab", false);
3303
3304     LIST_FOR_EACH (iface, port_elem, &port->ifaces) {
3305         netdev_set_miimon_interval(iface->netdev, miimon_interval);
3306     }
3307 }
3308
3309 /* Returns true if 'port' is synthetic, that is, if we constructed it locally
3310  * instead of obtaining it from the database. */
3311 static bool
3312 port_is_synthetic(const struct port *port)
3313 {
3314     return ovsdb_idl_row_is_synthetic(&port->cfg->header_);
3315 }
3316 \f
3317 /* Interface functions. */
3318
3319 static bool
3320 iface_is_internal(const struct ovsrec_interface *iface,
3321                   const struct ovsrec_bridge *br)
3322 {
3323     /* The local port and "internal" ports are always "internal". */
3324     return !strcmp(iface->type, "internal") || !strcmp(iface->name, br->name);
3325 }
3326
3327 /* Returns the correct network device type for interface 'iface' in bridge
3328  * 'br'. */
3329 static const char *
3330 iface_get_type(const struct ovsrec_interface *iface,
3331                const struct ovsrec_bridge *br)
3332 {
3333     const char *type;
3334
3335     /* The local port always has type "internal".  Other ports take
3336      * their type from the database and default to "system" if none is
3337      * specified. */
3338     if (iface_is_internal(iface, br)) {
3339         type = "internal";
3340     } else {
3341         type = iface->type[0] ? iface->type : "system";
3342     }
3343
3344     return ofproto_port_open_type(br->datapath_type, type);
3345 }
3346
3347 static void
3348 iface_destroy__(struct iface *iface)
3349 {
3350     if (iface) {
3351         struct port *port = iface->port;
3352         struct bridge *br = port->bridge;
3353
3354         if (br->ofproto && iface->ofp_port != OFPP_NONE) {
3355             ofproto_port_unregister(br->ofproto, iface->ofp_port);
3356         }
3357
3358         if (iface->ofp_port != OFPP_NONE) {
3359             hmap_remove(&br->ifaces, &iface->ofp_port_node);
3360         }
3361
3362         list_remove(&iface->port_elem);
3363         hmap_remove(&br->iface_by_name, &iface->name_node);
3364
3365         netdev_close(iface->netdev);
3366
3367         free(iface->name);
3368         free(iface);
3369     }
3370 }
3371
3372 static void
3373 iface_destroy(struct iface *iface)
3374 {
3375     if (iface) {
3376         struct port *port = iface->port;
3377
3378         iface_destroy__(iface);
3379         if (list_is_empty(&port->ifaces)) {
3380             port_destroy(port);
3381         }
3382     }
3383 }
3384
3385 static struct iface *
3386 iface_lookup(const struct bridge *br, const char *name)
3387 {
3388     struct iface *iface;
3389
3390     HMAP_FOR_EACH_WITH_HASH (iface, name_node, hash_string(name, 0),
3391                              &br->iface_by_name) {
3392         if (!strcmp(iface->name, name)) {
3393             return iface;
3394         }
3395     }
3396
3397     return NULL;
3398 }
3399
3400 static struct iface *
3401 iface_find(const char *name)
3402 {
3403     const struct bridge *br;
3404
3405     HMAP_FOR_EACH (br, node, &all_bridges) {
3406         struct iface *iface = iface_lookup(br, name);
3407
3408         if (iface) {
3409             return iface;
3410         }
3411     }
3412     return NULL;
3413 }
3414
3415 static struct iface *
3416 iface_from_ofp_port(const struct bridge *br, ofp_port_t ofp_port)
3417 {
3418     struct iface *iface;
3419
3420     HMAP_FOR_EACH_IN_BUCKET (iface, ofp_port_node, hash_ofp_port(ofp_port),
3421                              &br->ifaces) {
3422         if (iface->ofp_port == ofp_port) {
3423             return iface;
3424         }
3425     }
3426     return NULL;
3427 }
3428
3429 /* Set Ethernet address of 'iface', if one is specified in the configuration
3430  * file. */
3431 static void
3432 iface_set_mac(struct iface *iface)
3433 {
3434     uint8_t ea[ETH_ADDR_LEN];
3435
3436     if (!strcmp(iface->type, "internal")
3437         && iface->cfg->mac && eth_addr_from_string(iface->cfg->mac, ea)) {
3438         if (iface->ofp_port == OFPP_LOCAL) {
3439             VLOG_ERR("interface %s: ignoring mac in Interface record "
3440                      "(use Bridge record to set local port's mac)",
3441                      iface->name);
3442         } else if (eth_addr_is_multicast(ea)) {
3443             VLOG_ERR("interface %s: cannot set MAC to multicast address",
3444                      iface->name);
3445         } else {
3446             int error = netdev_set_etheraddr(iface->netdev, ea);
3447             if (error) {
3448                 VLOG_ERR("interface %s: setting MAC failed (%s)",
3449                          iface->name, ovs_strerror(error));
3450             }
3451         }
3452     }
3453 }
3454
3455 /* Sets the ofport column of 'if_cfg' to 'ofport'. */
3456 static void
3457 iface_set_ofport(const struct ovsrec_interface *if_cfg, ofp_port_t ofport)
3458 {
3459     if (if_cfg && !ovsdb_idl_row_is_synthetic(&if_cfg->header_)) {
3460         int64_t port = ofport == OFPP_NONE ? -1 : ofp_to_u16(ofport);
3461         ovsrec_interface_set_ofport(if_cfg, &port, 1);
3462     }
3463 }
3464
3465 /* Clears all of the fields in 'if_cfg' that indicate interface status, and
3466  * sets the "ofport" field to -1.
3467  *
3468  * This is appropriate when 'if_cfg''s interface cannot be created or is
3469  * otherwise invalid. */
3470 static void
3471 iface_clear_db_record(const struct ovsrec_interface *if_cfg)
3472 {
3473     if (!ovsdb_idl_row_is_synthetic(&if_cfg->header_)) {
3474         ovsrec_interface_set_status(if_cfg, NULL);
3475         ovsrec_interface_set_admin_state(if_cfg, NULL);
3476         ovsrec_interface_set_duplex(if_cfg, NULL);
3477         ovsrec_interface_set_link_speed(if_cfg, NULL, 0);
3478         ovsrec_interface_set_link_state(if_cfg, NULL);
3479         ovsrec_interface_set_mac_in_use(if_cfg, NULL);
3480         ovsrec_interface_set_mtu(if_cfg, NULL, 0);
3481         ovsrec_interface_set_cfm_fault(if_cfg, NULL, 0);
3482         ovsrec_interface_set_cfm_fault_status(if_cfg, NULL, 0);
3483         ovsrec_interface_set_cfm_remote_mpids(if_cfg, NULL, 0);
3484         ovsrec_interface_set_lacp_current(if_cfg, NULL, 0);
3485         ovsrec_interface_set_statistics(if_cfg, NULL, NULL, 0);
3486         ovsrec_interface_set_ifindex(if_cfg, NULL, 0);
3487     }
3488 }
3489
3490 static bool
3491 queue_ids_include(const struct ovsdb_datum *queues, int64_t target)
3492 {
3493     union ovsdb_atom atom;
3494
3495     atom.integer = target;
3496     return ovsdb_datum_find_key(queues, &atom, OVSDB_TYPE_INTEGER) != UINT_MAX;
3497 }
3498
3499 static void
3500 iface_configure_qos(struct iface *iface, const struct ovsrec_qos *qos)
3501 {
3502     struct ofpbuf queues_buf;
3503
3504     ofpbuf_init(&queues_buf, 0);
3505
3506     if (!qos || qos->type[0] == '\0' || qos->n_queues < 1) {
3507         netdev_set_qos(iface->netdev, NULL, NULL);
3508     } else {
3509         const struct ovsdb_datum *queues;
3510         struct netdev_queue_dump dump;
3511         unsigned int queue_id;
3512         struct smap details;
3513         bool queue_zero;
3514         size_t i;
3515
3516         /* Configure top-level Qos for 'iface'. */
3517         netdev_set_qos(iface->netdev, qos->type, &qos->other_config);
3518
3519         /* Deconfigure queues that were deleted. */
3520         queues = ovsrec_qos_get_queues(qos, OVSDB_TYPE_INTEGER,
3521                                        OVSDB_TYPE_UUID);
3522         smap_init(&details);
3523         NETDEV_QUEUE_FOR_EACH (&queue_id, &details, &dump, iface->netdev) {
3524             if (!queue_ids_include(queues, queue_id)) {
3525                 netdev_delete_queue(iface->netdev, queue_id);
3526             }
3527         }
3528         smap_destroy(&details);
3529
3530         /* Configure queues for 'iface'. */
3531         queue_zero = false;
3532         for (i = 0; i < qos->n_queues; i++) {
3533             const struct ovsrec_queue *queue = qos->value_queues[i];
3534             unsigned int queue_id = qos->key_queues[i];
3535
3536             if (queue_id == 0) {
3537                 queue_zero = true;
3538             }
3539
3540             if (queue->n_dscp == 1) {
3541                 struct ofproto_port_queue *port_queue;
3542
3543                 port_queue = ofpbuf_put_uninit(&queues_buf,
3544                                                sizeof *port_queue);
3545                 port_queue->queue = queue_id;
3546                 port_queue->dscp = queue->dscp[0];
3547             }
3548
3549             netdev_set_queue(iface->netdev, queue_id, &queue->other_config);
3550         }
3551         if (!queue_zero) {
3552             struct smap details;
3553
3554             smap_init(&details);
3555             netdev_set_queue(iface->netdev, 0, &details);
3556             smap_destroy(&details);
3557         }
3558     }
3559
3560     if (iface->ofp_port != OFPP_NONE) {
3561         const struct ofproto_port_queue *port_queues = queues_buf.data;
3562         size_t n_queues = queues_buf.size / sizeof *port_queues;
3563
3564         ofproto_port_set_queues(iface->port->bridge->ofproto, iface->ofp_port,
3565                                 port_queues, n_queues);
3566     }
3567
3568     netdev_set_policing(iface->netdev,
3569                         iface->cfg->ingress_policing_rate,
3570                         iface->cfg->ingress_policing_burst);
3571
3572     ofpbuf_uninit(&queues_buf);
3573 }
3574
3575 static void
3576 iface_configure_cfm(struct iface *iface)
3577 {
3578     const struct ovsrec_interface *cfg = iface->cfg;
3579     const char *opstate_str;
3580     const char *cfm_ccm_vlan;
3581     struct cfm_settings s;
3582     struct smap netdev_args;
3583
3584     if (!cfg->n_cfm_mpid) {
3585         ofproto_port_clear_cfm(iface->port->bridge->ofproto, iface->ofp_port);
3586         return;
3587     }
3588
3589     s.check_tnl_key = false;
3590     smap_init(&netdev_args);
3591     if (!netdev_get_config(iface->netdev, &netdev_args)) {
3592         const char *key = smap_get(&netdev_args, "key");
3593         const char *in_key = smap_get(&netdev_args, "in_key");
3594
3595         s.check_tnl_key = (key && !strcmp(key, "flow"))
3596                            || (in_key && !strcmp(in_key, "flow"));
3597     }
3598     smap_destroy(&netdev_args);
3599
3600     s.mpid = *cfg->cfm_mpid;
3601     s.interval = smap_get_int(&iface->cfg->other_config, "cfm_interval", 0);
3602     cfm_ccm_vlan = smap_get(&iface->cfg->other_config, "cfm_ccm_vlan");
3603     s.ccm_pcp = smap_get_int(&iface->cfg->other_config, "cfm_ccm_pcp", 0);
3604
3605     if (s.interval <= 0) {
3606         s.interval = 1000;
3607     }
3608
3609     if (!cfm_ccm_vlan) {
3610         s.ccm_vlan = 0;
3611     } else if (!strcasecmp("random", cfm_ccm_vlan)) {
3612         s.ccm_vlan = CFM_RANDOM_VLAN;
3613     } else {
3614         s.ccm_vlan = atoi(cfm_ccm_vlan);
3615         if (s.ccm_vlan == CFM_RANDOM_VLAN) {
3616             s.ccm_vlan = 0;
3617         }
3618     }
3619
3620     s.extended = smap_get_bool(&iface->cfg->other_config, "cfm_extended",
3621                                false);
3622     s.demand = smap_get_bool(&iface->cfg->other_config, "cfm_demand", false);
3623
3624     opstate_str = smap_get(&iface->cfg->other_config, "cfm_opstate");
3625     s.opup = !opstate_str || !strcasecmp("up", opstate_str);
3626
3627     ofproto_port_set_cfm(iface->port->bridge->ofproto, iface->ofp_port, &s);
3628 }
3629
3630 /* Returns true if 'iface' is synthetic, that is, if we constructed it locally
3631  * instead of obtaining it from the database. */
3632 static bool
3633 iface_is_synthetic(const struct iface *iface)
3634 {
3635     return ovsdb_idl_row_is_synthetic(&iface->cfg->header_);
3636 }
3637
3638 static ofp_port_t
3639 iface_pick_ofport(const struct ovsrec_interface *cfg)
3640 {
3641     ofp_port_t ofport = cfg->n_ofport ? u16_to_ofp(*cfg->ofport)
3642                                       : OFPP_NONE;
3643     return cfg->n_ofport_request ? u16_to_ofp(*cfg->ofport_request)
3644                                  : ofport;
3645 }
3646
3647 \f
3648 /* Port mirroring. */
3649
3650 static struct mirror *
3651 mirror_find_by_uuid(struct bridge *br, const struct uuid *uuid)
3652 {
3653     struct mirror *m;
3654
3655     HMAP_FOR_EACH_IN_BUCKET (m, hmap_node, uuid_hash(uuid), &br->mirrors) {
3656         if (uuid_equals(uuid, &m->uuid)) {
3657             return m;
3658         }
3659     }
3660     return NULL;
3661 }
3662
3663 static void
3664 bridge_configure_mirrors(struct bridge *br)
3665 {
3666     const struct ovsdb_datum *mc;
3667     unsigned long *flood_vlans;
3668     struct mirror *m, *next;
3669     size_t i;
3670
3671     /* Get rid of deleted mirrors. */
3672     mc = ovsrec_bridge_get_mirrors(br->cfg, OVSDB_TYPE_UUID);
3673     HMAP_FOR_EACH_SAFE (m, next, hmap_node, &br->mirrors) {
3674         union ovsdb_atom atom;
3675
3676         atom.uuid = m->uuid;
3677         if (ovsdb_datum_find_key(mc, &atom, OVSDB_TYPE_UUID) == UINT_MAX) {
3678             mirror_destroy(m);
3679         }
3680     }
3681
3682     /* Add new mirrors and reconfigure existing ones. */
3683     for (i = 0; i < br->cfg->n_mirrors; i++) {
3684         const struct ovsrec_mirror *cfg = br->cfg->mirrors[i];
3685         struct mirror *m = mirror_find_by_uuid(br, &cfg->header_.uuid);
3686         if (!m) {
3687             m = mirror_create(br, cfg);
3688         }
3689         m->cfg = cfg;
3690         if (!mirror_configure(m)) {
3691             mirror_destroy(m);
3692         }
3693     }
3694
3695     /* Update flooded vlans (for RSPAN). */
3696     flood_vlans = vlan_bitmap_from_array(br->cfg->flood_vlans,
3697                                          br->cfg->n_flood_vlans);
3698     ofproto_set_flood_vlans(br->ofproto, flood_vlans);
3699     bitmap_free(flood_vlans);
3700 }
3701
3702 static struct mirror *
3703 mirror_create(struct bridge *br, const struct ovsrec_mirror *cfg)
3704 {
3705     struct mirror *m;
3706
3707     m = xzalloc(sizeof *m);
3708     m->uuid = cfg->header_.uuid;
3709     hmap_insert(&br->mirrors, &m->hmap_node, uuid_hash(&m->uuid));
3710     m->bridge = br;
3711     m->name = xstrdup(cfg->name);
3712
3713     return m;
3714 }
3715
3716 static void
3717 mirror_destroy(struct mirror *m)
3718 {
3719     if (m) {
3720         struct bridge *br = m->bridge;
3721
3722         if (br->ofproto) {
3723             ofproto_mirror_unregister(br->ofproto, m);
3724         }
3725
3726         hmap_remove(&br->mirrors, &m->hmap_node);
3727         free(m->name);
3728         free(m);
3729     }
3730 }
3731
3732 static void
3733 mirror_collect_ports(struct mirror *m,
3734                      struct ovsrec_port **in_ports, int n_in_ports,
3735                      void ***out_portsp, size_t *n_out_portsp)
3736 {
3737     void **out_ports = xmalloc(n_in_ports * sizeof *out_ports);
3738     size_t n_out_ports = 0;
3739     size_t i;
3740
3741     for (i = 0; i < n_in_ports; i++) {
3742         const char *name = in_ports[i]->name;
3743         struct port *port = port_lookup(m->bridge, name);
3744         if (port) {
3745             out_ports[n_out_ports++] = port;
3746         } else {
3747             VLOG_WARN("bridge %s: mirror %s cannot match on nonexistent "
3748                       "port %s", m->bridge->name, m->name, name);
3749         }
3750     }
3751     *out_portsp = out_ports;
3752     *n_out_portsp = n_out_ports;
3753 }
3754
3755 static bool
3756 mirror_configure(struct mirror *m)
3757 {
3758     const struct ovsrec_mirror *cfg = m->cfg;
3759     struct ofproto_mirror_settings s;
3760
3761     /* Set name. */
3762     if (strcmp(cfg->name, m->name)) {
3763         free(m->name);
3764         m->name = xstrdup(cfg->name);
3765     }
3766     s.name = m->name;
3767
3768     /* Get output port or VLAN. */
3769     if (cfg->output_port) {
3770         s.out_bundle = port_lookup(m->bridge, cfg->output_port->name);
3771         if (!s.out_bundle) {
3772             VLOG_ERR("bridge %s: mirror %s outputs to port not on bridge",
3773                      m->bridge->name, m->name);
3774             return false;
3775         }
3776         s.out_vlan = UINT16_MAX;
3777
3778         if (cfg->output_vlan) {
3779             VLOG_ERR("bridge %s: mirror %s specifies both output port and "
3780                      "output vlan; ignoring output vlan",
3781                      m->bridge->name, m->name);
3782         }
3783     } else if (cfg->output_vlan) {
3784         /* The database should prevent invalid VLAN values. */
3785         s.out_bundle = NULL;
3786         s.out_vlan = *cfg->output_vlan;
3787     } else {
3788         VLOG_ERR("bridge %s: mirror %s does not specify output; ignoring",
3789                  m->bridge->name, m->name);
3790         return false;
3791     }
3792
3793     /* Get port selection. */
3794     if (cfg->select_all) {
3795         size_t n_ports = hmap_count(&m->bridge->ports);
3796         void **ports = xmalloc(n_ports * sizeof *ports);
3797         struct port *port;
3798         size_t i;
3799
3800         i = 0;
3801         HMAP_FOR_EACH (port, hmap_node, &m->bridge->ports) {
3802             ports[i++] = port;
3803         }
3804
3805         s.srcs = ports;
3806         s.n_srcs = n_ports;
3807
3808         s.dsts = ports;
3809         s.n_dsts = n_ports;
3810     } else {
3811         /* Get ports, dropping ports that don't exist.
3812          * The IDL ensures that there are no duplicates. */
3813         mirror_collect_ports(m, cfg->select_src_port, cfg->n_select_src_port,
3814                              &s.srcs, &s.n_srcs);
3815         mirror_collect_ports(m, cfg->select_dst_port, cfg->n_select_dst_port,
3816                              &s.dsts, &s.n_dsts);
3817     }
3818
3819     /* Get VLAN selection. */
3820     s.src_vlans = vlan_bitmap_from_array(cfg->select_vlan, cfg->n_select_vlan);
3821
3822     /* Configure. */
3823     ofproto_mirror_register(m->bridge->ofproto, m, &s);
3824
3825     /* Clean up. */
3826     if (s.srcs != s.dsts) {
3827         free(s.dsts);
3828     }
3829     free(s.srcs);
3830     free(s.src_vlans);
3831
3832     return true;
3833 }
3834 \f
3835 /* Linux VLAN device support (e.g. "eth0.10" for VLAN 10.)
3836  *
3837  * This is deprecated.  It is only for compatibility with broken device drivers
3838  * in old versions of Linux that do not properly support VLANs when VLAN
3839  * devices are not used.  When broken device drivers are no longer in
3840  * widespread use, we will delete these interfaces. */
3841
3842 static struct ovsrec_port **recs;
3843 static size_t n_recs, allocated_recs;
3844
3845 /* Adds 'rec' to a list of recs that have to be destroyed when the VLAN
3846  * splinters are reconfigured. */
3847 static void
3848 register_rec(struct ovsrec_port *rec)
3849 {
3850     if (n_recs >= allocated_recs) {
3851         recs = x2nrealloc(recs, &allocated_recs, sizeof *recs);
3852     }
3853     recs[n_recs++] = rec;
3854 }
3855
3856 /* Frees all of the ports registered with register_reg(). */
3857 static void
3858 free_registered_recs(void)
3859 {
3860     size_t i;
3861
3862     for (i = 0; i < n_recs; i++) {
3863         struct ovsrec_port *port = recs[i];
3864         size_t j;
3865
3866         for (j = 0; j < port->n_interfaces; j++) {
3867             struct ovsrec_interface *iface = port->interfaces[j];
3868             free(iface->name);
3869             free(iface);
3870         }
3871
3872         smap_destroy(&port->other_config);
3873         free(port->interfaces);
3874         free(port->name);
3875         free(port->tag);
3876         free(port);
3877     }
3878     n_recs = 0;
3879 }
3880
3881 /* Returns true if VLAN splinters are enabled on 'iface_cfg', false
3882  * otherwise. */
3883 static bool
3884 vlan_splinters_is_enabled(const struct ovsrec_interface *iface_cfg)
3885 {
3886     return smap_get_bool(&iface_cfg->other_config, "enable-vlan-splinters",
3887                          false);
3888 }
3889
3890 /* Figures out the set of VLANs that are in use for the purpose of VLAN
3891  * splinters.
3892  *
3893  * If VLAN splinters are enabled on at least one interface and any VLANs are in
3894  * use, returns a 4096-bit bitmap with a 1-bit for each in-use VLAN (bits 0 and
3895  * 4095 will not be set).  The caller is responsible for freeing the bitmap,
3896  * with free().
3897  *
3898  * If VLANs splinters are not enabled on any interface or if no VLANs are in
3899  * use, returns NULL.
3900  *
3901  * Updates 'vlan_splinters_enabled_anywhere'. */
3902 static unsigned long int *
3903 collect_splinter_vlans(const struct ovsrec_open_vswitch *ovs_cfg)
3904 {
3905     unsigned long int *splinter_vlans;
3906     struct sset splinter_ifaces;
3907     const char *real_dev_name;
3908     struct shash *real_devs;
3909     struct shash_node *node;
3910     struct bridge *br;
3911     size_t i;
3912
3913     /* Free space allocated for synthesized ports and interfaces, since we're
3914      * in the process of reconstructing all of them. */
3915     free_registered_recs();
3916
3917     splinter_vlans = bitmap_allocate(4096);
3918     sset_init(&splinter_ifaces);
3919     vlan_splinters_enabled_anywhere = false;
3920     for (i = 0; i < ovs_cfg->n_bridges; i++) {
3921         struct ovsrec_bridge *br_cfg = ovs_cfg->bridges[i];
3922         size_t j;
3923
3924         for (j = 0; j < br_cfg->n_ports; j++) {
3925             struct ovsrec_port *port_cfg = br_cfg->ports[j];
3926             int k;
3927
3928             for (k = 0; k < port_cfg->n_interfaces; k++) {
3929                 struct ovsrec_interface *iface_cfg = port_cfg->interfaces[k];
3930
3931                 if (vlan_splinters_is_enabled(iface_cfg)) {
3932                     vlan_splinters_enabled_anywhere = true;
3933                     sset_add(&splinter_ifaces, iface_cfg->name);
3934                     vlan_bitmap_from_array__(port_cfg->trunks,
3935                                              port_cfg->n_trunks,
3936                                              splinter_vlans);
3937                 }
3938             }
3939
3940             if (port_cfg->tag && *port_cfg->tag > 0 && *port_cfg->tag < 4095) {
3941                 bitmap_set1(splinter_vlans, *port_cfg->tag);
3942             }
3943         }
3944     }
3945
3946     if (!vlan_splinters_enabled_anywhere) {
3947         free(splinter_vlans);
3948         sset_destroy(&splinter_ifaces);
3949         return NULL;
3950     }
3951
3952     HMAP_FOR_EACH (br, node, &all_bridges) {
3953         if (br->ofproto) {
3954             ofproto_get_vlan_usage(br->ofproto, splinter_vlans);
3955         }
3956     }
3957
3958     /* Don't allow VLANs 0 or 4095 to be splintered.  VLAN 0 should appear on
3959      * the real device.  VLAN 4095 is reserved and Linux doesn't allow a VLAN
3960      * device to be created for it. */
3961     bitmap_set0(splinter_vlans, 0);
3962     bitmap_set0(splinter_vlans, 4095);
3963
3964     /* Delete all VLAN devices that we don't need. */
3965     vlandev_refresh();
3966     real_devs = vlandev_get_real_devs();
3967     SHASH_FOR_EACH (node, real_devs) {
3968         const struct vlan_real_dev *real_dev = node->data;
3969         const struct vlan_dev *vlan_dev;
3970         bool real_dev_has_splinters;
3971
3972         real_dev_has_splinters = sset_contains(&splinter_ifaces,
3973                                                real_dev->name);
3974         HMAP_FOR_EACH (vlan_dev, hmap_node, &real_dev->vlan_devs) {
3975             if (!real_dev_has_splinters
3976                 || !bitmap_is_set(splinter_vlans, vlan_dev->vid)) {
3977                 struct netdev *netdev;
3978
3979                 if (!netdev_open(vlan_dev->name, "system", &netdev)) {
3980                     if (!netdev_get_in4(netdev, NULL, NULL) ||
3981                         !netdev_get_in6(netdev, NULL)) {
3982                         /* It has an IP address configured, so we don't own
3983                          * it.  Don't delete it. */
3984                     } else {
3985                         vlandev_del(vlan_dev->name);
3986                     }
3987                     netdev_close(netdev);
3988                 }
3989             }
3990
3991         }
3992     }
3993
3994     /* Add all VLAN devices that we need. */
3995     SSET_FOR_EACH (real_dev_name, &splinter_ifaces) {
3996         int vid;
3997
3998         BITMAP_FOR_EACH_1 (vid, 4096, splinter_vlans) {
3999             if (!vlandev_get_name(real_dev_name, vid)) {
4000                 vlandev_add(real_dev_name, vid);
4001             }
4002         }
4003     }
4004
4005     vlandev_refresh();
4006
4007     sset_destroy(&splinter_ifaces);
4008
4009     if (bitmap_scan(splinter_vlans, 0, 4096) >= 4096) {
4010         free(splinter_vlans);
4011         return NULL;
4012     }
4013     return splinter_vlans;
4014 }
4015
4016 /* Pushes the configure of VLAN splinter port 'port' (e.g. eth0.9) down to
4017  * ofproto.  */
4018 static void
4019 configure_splinter_port(struct port *port)
4020 {
4021     struct ofproto *ofproto = port->bridge->ofproto;
4022     ofp_port_t realdev_ofp_port;
4023     const char *realdev_name;
4024     struct iface *vlandev, *realdev;
4025
4026     ofproto_bundle_unregister(port->bridge->ofproto, port);
4027
4028     vlandev = CONTAINER_OF(list_front(&port->ifaces), struct iface,
4029                            port_elem);
4030
4031     realdev_name = smap_get(&port->cfg->other_config, "realdev");
4032     realdev = iface_lookup(port->bridge, realdev_name);
4033     realdev_ofp_port = realdev ? realdev->ofp_port : 0;
4034
4035     ofproto_port_set_realdev(ofproto, vlandev->ofp_port, realdev_ofp_port,
4036                              *port->cfg->tag);
4037 }
4038
4039 static struct ovsrec_port *
4040 synthesize_splinter_port(const char *real_dev_name,
4041                          const char *vlan_dev_name, int vid)
4042 {
4043     struct ovsrec_interface *iface;
4044     struct ovsrec_port *port;
4045
4046     iface = xmalloc(sizeof *iface);
4047     ovsrec_interface_init(iface);
4048     iface->name = xstrdup(vlan_dev_name);
4049     iface->type = "system";
4050
4051     port = xmalloc(sizeof *port);
4052     ovsrec_port_init(port);
4053     port->interfaces = xmemdup(&iface, sizeof iface);
4054     port->n_interfaces = 1;
4055     port->name = xstrdup(vlan_dev_name);
4056     port->vlan_mode = "splinter";
4057     port->tag = xmalloc(sizeof *port->tag);
4058     *port->tag = vid;
4059
4060     smap_add(&port->other_config, "realdev", real_dev_name);
4061
4062     register_rec(port);
4063     return port;
4064 }
4065
4066 /* For each interface with 'br' that has VLAN splinters enabled, adds a
4067  * corresponding ovsrec_port to 'ports' for each splinter VLAN marked with a
4068  * 1-bit in the 'splinter_vlans' bitmap. */
4069 static void
4070 add_vlan_splinter_ports(struct bridge *br,
4071                         const unsigned long int *splinter_vlans,
4072                         struct shash *ports)
4073 {
4074     size_t i;
4075
4076     /* We iterate through 'br->cfg->ports' instead of 'ports' here because
4077      * we're modifying 'ports'. */
4078     for (i = 0; i < br->cfg->n_ports; i++) {
4079         const char *name = br->cfg->ports[i]->name;
4080         struct ovsrec_port *port_cfg = shash_find_data(ports, name);
4081         size_t j;
4082
4083         for (j = 0; j < port_cfg->n_interfaces; j++) {
4084             struct ovsrec_interface *iface_cfg = port_cfg->interfaces[j];
4085
4086             if (vlan_splinters_is_enabled(iface_cfg)) {
4087                 const char *real_dev_name;
4088                 uint16_t vid;
4089
4090                 real_dev_name = iface_cfg->name;
4091                 BITMAP_FOR_EACH_1 (vid, 4096, splinter_vlans) {
4092                     const char *vlan_dev_name;
4093
4094                     vlan_dev_name = vlandev_get_name(real_dev_name, vid);
4095                     if (vlan_dev_name
4096                         && !shash_find(ports, vlan_dev_name)) {
4097                         shash_add(ports, vlan_dev_name,
4098                                   synthesize_splinter_port(
4099                                       real_dev_name, vlan_dev_name, vid));
4100                     }
4101                 }
4102             }
4103         }
4104     }
4105 }
4106
4107 static void
4108 mirror_refresh_stats(struct mirror *m)
4109 {
4110     struct ofproto *ofproto = m->bridge->ofproto;
4111     uint64_t tx_packets, tx_bytes;
4112     char *keys[2];
4113     int64_t values[2];
4114     size_t stat_cnt = 0;
4115
4116     if (ofproto_mirror_get_stats(ofproto, m, &tx_packets, &tx_bytes)) {
4117         ovsrec_mirror_set_statistics(m->cfg, NULL, NULL, 0);
4118         return;
4119     }
4120
4121     if (tx_packets != UINT64_MAX) {
4122         keys[stat_cnt] = "tx_packets";
4123         values[stat_cnt] = tx_packets;
4124         stat_cnt++;
4125     }
4126     if (tx_bytes != UINT64_MAX) {
4127         keys[stat_cnt] = "tx_bytes";
4128         values[stat_cnt] = tx_bytes;
4129         stat_cnt++;
4130     }
4131
4132     ovsrec_mirror_set_statistics(m->cfg, keys, values, stat_cnt);
4133 }