X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=vswitchd%2Fbridge.c;h=e5b546bf4082faa12edd70916e33452cd9736191;hb=7e041ba51410125ec74cba2b5f0b6f1b0481baa9;hp=94668a733f9a316912bbf70205f3fa49fae06399;hpb=18812dff32ce650440b9f1eac1bb00afe08c621a;p=sliver-openvswitch.git diff --git a/vswitchd/bridge.c b/vswitchd/bridge.c index 94668a733..e5b546bf4 100644 --- a/vswitchd/bridge.c +++ b/vswitchd/bridge.c @@ -1,4 +1,4 @@ -/* Copyright (c) 2008, 2009, 2010, 2011 Nicira Networks +/* Copyright (c) 2008, 2009, 2010, 2011, 2012 Nicira Networks * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -28,9 +28,12 @@ #include "dynamic-string.h" #include "hash.h" #include "hmap.h" +#include "hmapx.h" #include "jsonrpc.h" #include "lacp.h" #include "list.h" +#include "mac-learning.h" +#include "meta-flow.h" #include "netdev.h" #include "ofp-print.h" #include "ofpbuf.h" @@ -39,13 +42,15 @@ #include "sha1.h" #include "shash.h" #include "socket-util.h" +#include "stream.h" #include "stream-ssl.h" #include "sset.h" #include "system-stats.h" #include "timeval.h" #include "util.h" #include "unixctl.h" -#include "vswitchd/vswitch-idl.h" +#include "vlandev.h" +#include "lib/vswitch-idl.h" #include "xenserver.h" #include "vlog.h" #include "sflow_api.h" @@ -70,6 +75,7 @@ struct iface { struct netdev *netdev; /* Network device. */ const char *type; /* Usually same as cfg->type. */ const struct ovsrec_interface *cfg; + bool need_refresh; /* Refresh iface after create. */ }; struct mirror { @@ -77,11 +83,12 @@ struct mirror { struct hmap_node hmap_node; /* In struct bridge's "mirrors" hmap. */ struct bridge *bridge; char *name; + const struct ovsrec_mirror *cfg; }; struct port { - struct bridge *bridge; struct hmap_node hmap_node; /* Element in struct bridge's "ports" hmap. */ + struct bridge *bridge; char *name; const struct ovsrec_port *cfg; @@ -122,6 +129,9 @@ static struct hmap all_bridges = HMAP_INITIALIZER(&all_bridges); /* OVSDB IDL used to obtain configuration. */ static struct ovsdb_idl *idl; +/* Most recently processed IDL sequence number. */ +static unsigned int idl_seqno; + /* Each time this timer expires, the bridge fetches systems and interface * statistics and pushes them into the database. */ #define STATS_INTERVAL (5 * 1000) /* In milliseconds. */ @@ -143,14 +153,19 @@ static unixctl_cb_func bridge_unixctl_dump_flows; static unixctl_cb_func bridge_unixctl_reconnect; static size_t bridge_get_controllers(const struct bridge *br, struct ovsrec_controller ***controllersp); -static void bridge_add_del_ports(struct bridge *); +static void bridge_add_del_ports(struct bridge *, + const unsigned long int *splinter_vlans); static void bridge_add_ofproto_ports(struct bridge *); static void bridge_del_ofproto_ports(struct bridge *); static void bridge_refresh_ofp_port(struct bridge *); static void bridge_configure_datapath_id(struct bridge *); static void bridge_configure_flow_eviction_threshold(struct bridge *); static void bridge_configure_netflow(struct bridge *); +static void bridge_configure_forward_bpdu(struct bridge *); +static void bridge_configure_mac_idle_time(struct bridge *); static void bridge_configure_sflow(struct bridge *, int *sflow_bridge_number); +static void bridge_configure_stp(struct bridge *); +static void bridge_configure_tables(struct bridge *); static void bridge_configure_remotes(struct bridge *, const struct sockaddr_in *managers, size_t n_managers); @@ -177,12 +192,14 @@ static struct lacp_settings *port_configure_lacp(struct port *, struct lacp_settings *); static void port_configure_bond(struct port *, struct bond_settings *, uint32_t *bond_stable_ids); +static bool port_is_synthetic(const struct port *); static void bridge_configure_mirrors(struct bridge *); static struct mirror *mirror_create(struct bridge *, const struct ovsrec_mirror *); static void mirror_destroy(struct mirror *); -static bool mirror_configure(struct mirror *, const struct ovsrec_mirror *); +static bool mirror_configure(struct mirror *); +static void mirror_refresh_stats(struct mirror *); static void iface_configure_lacp(struct iface *, struct lacp_slave_settings *); static struct iface *iface_create(struct port *port, @@ -194,18 +211,35 @@ static struct iface *iface_from_ofp_port(const struct bridge *, uint16_t ofp_port); static void iface_set_mac(struct iface *); static void iface_set_ofport(const struct ovsrec_interface *, int64_t ofport); +static void iface_clear_db_record(const struct ovsrec_interface *if_cfg); static void iface_configure_qos(struct iface *, const struct ovsrec_qos *); static void iface_configure_cfm(struct iface *); -static bool iface_refresh_cfm_stats(struct iface *); +static void iface_refresh_cfm_stats(struct iface *); static void iface_refresh_stats(struct iface *); static void iface_refresh_status(struct iface *); -static bool iface_get_carrier(const struct iface *); static bool iface_is_synthetic(const struct iface *); - static void shash_from_ovs_idl_map(char **keys, char **values, size_t n, struct shash *); static void shash_to_ovs_idl_map(struct shash *, char ***keys, char ***values, size_t *n); + +/* Linux VLAN device support (e.g. "eth0.10" for VLAN 10.) + * + * This is deprecated. It is only for compatibility with broken device drivers + * in old versions of Linux that do not properly support VLANs when VLAN + * devices are not used. When broken device drivers are no longer in + * widespread use, we will delete these interfaces. */ + +/* True if VLAN splinters are enabled on any interface, false otherwise.*/ +static bool vlan_splinters_enabled_anywhere; + +static bool vlan_splinters_is_enabled(const struct ovsrec_interface *); +static unsigned long int *collect_splinter_vlans( + const struct ovsrec_open_vswitch *); +static void configure_splinter_port(struct port *); +static void add_vlan_splinter_ports(struct bridge *, + const unsigned long int *splinter_vlans, + struct shash *ports); /* Public functions. */ @@ -217,6 +251,7 @@ bridge_init(const char *remote) { /* Create connection to database. */ idl = ovsdb_idl_create(remote, &ovsrec_idl_class, true); + idl_seqno = ovsdb_idl_get_seqno(idl); ovsdb_idl_set_lock(idl, "ovs_vswitchd"); ovsdb_idl_omit_alert(idl, &ovsrec_open_vswitch_col_cur_cfg); @@ -228,8 +263,11 @@ bridge_init(const char *remote) ovsdb_idl_omit(idl, &ovsrec_open_vswitch_col_system_version); ovsdb_idl_omit_alert(idl, &ovsrec_bridge_col_datapath_id); + ovsdb_idl_omit_alert(idl, &ovsrec_bridge_col_status); ovsdb_idl_omit(idl, &ovsrec_bridge_col_external_ids); + ovsdb_idl_omit_alert(idl, &ovsrec_port_col_status); + ovsdb_idl_omit_alert(idl, &ovsrec_port_col_statistics); ovsdb_idl_omit(idl, &ovsrec_port_col_external_ids); ovsdb_idl_omit(idl, &ovsrec_port_col_fake_bridge); @@ -237,10 +275,16 @@ bridge_init(const char *remote) ovsdb_idl_omit_alert(idl, &ovsrec_interface_col_duplex); ovsdb_idl_omit_alert(idl, &ovsrec_interface_col_link_speed); ovsdb_idl_omit_alert(idl, &ovsrec_interface_col_link_state); + ovsdb_idl_omit_alert(idl, &ovsrec_interface_col_link_resets); ovsdb_idl_omit_alert(idl, &ovsrec_interface_col_mtu); ovsdb_idl_omit_alert(idl, &ovsrec_interface_col_ofport); ovsdb_idl_omit_alert(idl, &ovsrec_interface_col_statistics); ovsdb_idl_omit_alert(idl, &ovsrec_interface_col_status); + ovsdb_idl_omit_alert(idl, &ovsrec_interface_col_cfm_fault); + ovsdb_idl_omit_alert(idl, &ovsrec_interface_col_cfm_fault_status); + ovsdb_idl_omit_alert(idl, &ovsrec_interface_col_cfm_remote_mpids); + ovsdb_idl_omit_alert(idl, &ovsrec_interface_col_cfm_health); + ovsdb_idl_omit_alert(idl, &ovsrec_interface_col_lacp_current); ovsdb_idl_omit(idl, &ovsrec_interface_col_external_ids); ovsdb_idl_omit_alert(idl, &ovsrec_controller_col_is_connected); @@ -253,6 +297,7 @@ bridge_init(const char *remote) ovsdb_idl_omit(idl, &ovsrec_queue_col_external_ids); ovsdb_idl_omit(idl, &ovsrec_mirror_col_external_ids); + ovsdb_idl_omit_alert(idl, &ovsrec_mirror_col_statistics); ovsdb_idl_omit(idl, &ovsrec_netflow_col_external_ids); @@ -267,14 +312,16 @@ bridge_init(const char *remote) ovsdb_idl_omit(idl, &ovsrec_ssl_col_external_ids); /* Register unixctl commands. */ - unixctl_command_register("qos/show", qos_unixctl_show, NULL); - unixctl_command_register("bridge/dump-flows", bridge_unixctl_dump_flows, - NULL); - unixctl_command_register("bridge/reconnect", bridge_unixctl_reconnect, - NULL); + unixctl_command_register("qos/show", "interface", 1, 1, + qos_unixctl_show, NULL); + unixctl_command_register("bridge/dump-flows", "bridge", 1, 1, + bridge_unixctl_dump_flows, NULL); + unixctl_command_register("bridge/reconnect", "[bridge]", 0, 1, + bridge_unixctl_reconnect, NULL); lacp_init(); bond_init(); cfm_init(); + stp_init(); } void @@ -330,10 +377,10 @@ collect_in_band_managers(const struct ovsrec_open_vswitch *ovs_cfg, SSET_FOR_EACH (target, &targets) { struct sockaddr_in *sin = &managers[n_managers]; - if ((!strncmp(target, "tcp:", 4) - && inet_parse_active(target + 4, JSONRPC_TCP_PORT, sin)) || - (!strncmp(target, "ssl:", 4) - && inet_parse_active(target + 4, JSONRPC_SSL_PORT, sin))) { + if (stream_parse_target_with_default_ports(target, + JSONRPC_TCP_PORT, + JSONRPC_SSL_PORT, + sin)) { n_managers++; } } @@ -347,6 +394,7 @@ collect_in_band_managers(const struct ovsrec_open_vswitch *ovs_cfg, static void bridge_reconfigure(const struct ovsrec_open_vswitch *ovs_cfg) { + unsigned long int *splinter_vlans; struct sockaddr_in *managers; struct bridge *br, *next; int sflow_bridge_number; @@ -358,12 +406,14 @@ bridge_reconfigure(const struct ovsrec_open_vswitch *ovs_cfg) * iface"s according to 'ovs_cfg', with only very minimal configuration * otherwise. * - * This is purely an update to bridge data structures. Nothing is pushed - * down to ofproto or lower layers. */ + * This is mostly an update to bridge data structures. Very little is + * pushed down to ofproto or lower layers. */ add_del_bridges(ovs_cfg); + splinter_vlans = collect_splinter_vlans(ovs_cfg); HMAP_FOR_EACH (br, node, &all_bridges) { - bridge_add_del_ports(br); + bridge_add_del_ports(br, splinter_vlans); } + free(splinter_vlans); /* Delete all datapaths and datapath ports that are no longer configured. * @@ -385,8 +435,12 @@ bridge_reconfigure(const struct ovsrec_open_vswitch *ovs_cfg) * has at least one iface, every "struct iface" has a valid ofp_port and * netdev. */ HMAP_FOR_EACH_SAFE (br, next, node, &all_bridges) { - if (!br->ofproto && !bridge_add_ofprotos(br)) { - bridge_destroy(br); + if (!br->ofproto) { + if (bridge_add_ofprotos(br)) { + bridge_del_ofproto_ports(br); + } else { + bridge_destroy(br); + } } } HMAP_FOR_EACH (br, node, &all_bridges) { @@ -400,6 +454,10 @@ bridge_reconfigure(const struct ovsrec_open_vswitch *ovs_cfg) HMAP_FOR_EACH (br, node, &all_bridges) { struct port *port; + /* We need the datapath ID early to allow LACP ports to use it as the + * default system ID. */ + bridge_configure_datapath_id(br); + HMAP_FOR_EACH (port, hmap_node, &br->ports) { struct iface *iface; @@ -412,11 +470,14 @@ bridge_reconfigure(const struct ovsrec_open_vswitch *ovs_cfg) } } bridge_configure_mirrors(br); - bridge_configure_datapath_id(br); bridge_configure_flow_eviction_threshold(br); + bridge_configure_forward_bpdu(br); + bridge_configure_mac_idle_time(br); bridge_configure_remotes(br, managers, n_managers); bridge_configure_netflow(br); bridge_configure_sflow(br, &sflow_bridge_number); + bridge_configure_stp(br); + bridge_configure_tables(br); } free(managers); @@ -472,6 +533,11 @@ port_configure(struct port *port) struct ofproto_bundle_settings s; struct iface *iface; + if (cfg->vlan_mode && !strcmp(cfg->vlan_mode, "splinter")) { + configure_splinter_port(port); + return; + } + /* Get name. */ s.name = port->name; @@ -484,29 +550,45 @@ port_configure(struct port *port) /* Get VLAN tag. */ s.vlan = -1; - if (cfg->tag) { - if (list_is_short(&port->ifaces)) { - if (*cfg->tag >= 0 && *cfg->tag <= 4095) { - s.vlan = *cfg->tag; - VLOG_DBG("port %s: assigning VLAN tag %d", port->name, s.vlan); - } - } else { - /* It's possible that bonded, VLAN-tagged ports make sense. Maybe - * they even work as-is. But they have not been tested. */ - VLOG_WARN("port %s: VLAN tags not supported on bonded ports", - port->name); - } + if (cfg->tag && *cfg->tag >= 0 && *cfg->tag <= 4095) { + s.vlan = *cfg->tag; } /* Get VLAN trunks. */ s.trunks = NULL; - if (s.vlan < 0 && cfg->n_trunks) { + if (cfg->n_trunks) { s.trunks = vlan_bitmap_from_array(cfg->trunks, cfg->n_trunks); - } else if (s.vlan >= 0 && cfg->n_trunks) { - VLOG_ERR("port %s: ignoring trunks in favor of implicit vlan", - port->name); } + /* Get VLAN mode. */ + if (cfg->vlan_mode) { + if (!strcmp(cfg->vlan_mode, "access")) { + s.vlan_mode = PORT_VLAN_ACCESS; + } else if (!strcmp(cfg->vlan_mode, "trunk")) { + s.vlan_mode = PORT_VLAN_TRUNK; + } else if (!strcmp(cfg->vlan_mode, "native-tagged")) { + s.vlan_mode = PORT_VLAN_NATIVE_TAGGED; + } else if (!strcmp(cfg->vlan_mode, "native-untagged")) { + s.vlan_mode = PORT_VLAN_NATIVE_UNTAGGED; + } else { + /* This "can't happen" because ovsdb-server should prevent it. */ + VLOG_ERR("unknown VLAN mode %s", cfg->vlan_mode); + s.vlan_mode = PORT_VLAN_TRUNK; + } + } else { + if (s.vlan >= 0) { + s.vlan_mode = PORT_VLAN_ACCESS; + if (cfg->n_trunks) { + VLOG_ERR("port %s: ignoring trunks in favor of implicit vlan", + port->name); + } + } else { + s.vlan_mode = PORT_VLAN_TRUNK; + } + } + s.use_priority_tags = !strcmp("true", ovsrec_port_get_other_config_value( + cfg, "priority-tags", "")); + /* Get LACP settings. */ s.lacp = port_configure_lacp(port, &lacp_settings); if (s.lacp) { @@ -687,6 +769,211 @@ bridge_configure_sflow(struct bridge *br, int *sflow_bridge_number) sset_destroy(&oso.targets); } +static void +port_configure_stp(const struct ofproto *ofproto, struct port *port, + struct ofproto_port_stp_settings *port_s, + int *port_num_counter, unsigned long *port_num_bitmap) +{ + const char *config_str; + struct iface *iface; + + config_str = ovsrec_port_get_other_config_value(port->cfg, "stp-enable", + NULL); + if (config_str && !strcmp(config_str, "false")) { + port_s->enable = false; + return; + } else { + port_s->enable = true; + } + + /* STP over bonds is not supported. */ + if (!list_is_singleton(&port->ifaces)) { + VLOG_ERR("port %s: cannot enable STP on bonds, disabling", + port->name); + port_s->enable = false; + return; + } + + iface = CONTAINER_OF(list_front(&port->ifaces), struct iface, port_elem); + + /* Internal ports shouldn't participate in spanning tree, so + * skip them. */ + if (!strcmp(iface->type, "internal")) { + VLOG_DBG("port %s: disable STP on internal ports", port->name); + port_s->enable = false; + return; + } + + /* STP on mirror output ports is not supported. */ + if (ofproto_is_mirror_output_bundle(ofproto, port)) { + VLOG_DBG("port %s: disable STP on mirror ports", port->name); + port_s->enable = false; + return; + } + + config_str = ovsrec_port_get_other_config_value(port->cfg, "stp-port-num", + NULL); + if (config_str) { + unsigned long int port_num = strtoul(config_str, NULL, 0); + int port_idx = port_num - 1; + + if (port_num < 1 || port_num > STP_MAX_PORTS) { + VLOG_ERR("port %s: invalid stp-port-num", port->name); + port_s->enable = false; + return; + } + + if (bitmap_is_set(port_num_bitmap, port_idx)) { + VLOG_ERR("port %s: duplicate stp-port-num %lu, disabling", + port->name, port_num); + port_s->enable = false; + return; + } + bitmap_set1(port_num_bitmap, port_idx); + port_s->port_num = port_idx; + } else { + if (*port_num_counter > STP_MAX_PORTS) { + VLOG_ERR("port %s: too many STP ports, disabling", port->name); + port_s->enable = false; + return; + } + + port_s->port_num = (*port_num_counter)++; + } + + config_str = ovsrec_port_get_other_config_value(port->cfg, "stp-path-cost", + NULL); + if (config_str) { + port_s->path_cost = strtoul(config_str, NULL, 10); + } else { + enum netdev_features current; + + if (netdev_get_features(iface->netdev, ¤t, NULL, NULL, NULL)) { + /* Couldn't get speed, so assume 100Mb/s. */ + port_s->path_cost = 19; + } else { + unsigned int mbps; + + mbps = netdev_features_to_bps(current) / 1000000; + port_s->path_cost = stp_convert_speed_to_cost(mbps); + } + } + + config_str = ovsrec_port_get_other_config_value(port->cfg, + "stp-port-priority", + NULL); + if (config_str) { + port_s->priority = strtoul(config_str, NULL, 0); + } else { + port_s->priority = STP_DEFAULT_PORT_PRIORITY; + } +} + +/* Set spanning tree configuration on 'br'. */ +static void +bridge_configure_stp(struct bridge *br) +{ + if (!br->cfg->stp_enable) { + ofproto_set_stp(br->ofproto, NULL); + } else { + struct ofproto_stp_settings br_s; + const char *config_str; + struct port *port; + int port_num_counter; + unsigned long *port_num_bitmap; + + config_str = ovsrec_bridge_get_other_config_value(br->cfg, + "stp-system-id", + NULL); + if (config_str) { + uint8_t ea[ETH_ADDR_LEN]; + + if (eth_addr_from_string(config_str, ea)) { + br_s.system_id = eth_addr_to_uint64(ea); + } else { + br_s.system_id = eth_addr_to_uint64(br->ea); + VLOG_ERR("bridge %s: invalid stp-system-id, defaulting " + "to "ETH_ADDR_FMT, br->name, ETH_ADDR_ARGS(br->ea)); + } + } else { + br_s.system_id = eth_addr_to_uint64(br->ea); + } + + config_str = ovsrec_bridge_get_other_config_value(br->cfg, + "stp-priority", + NULL); + if (config_str) { + br_s.priority = strtoul(config_str, NULL, 0); + } else { + br_s.priority = STP_DEFAULT_BRIDGE_PRIORITY; + } + + config_str = ovsrec_bridge_get_other_config_value(br->cfg, + "stp-hello-time", + NULL); + if (config_str) { + br_s.hello_time = strtoul(config_str, NULL, 10) * 1000; + } else { + br_s.hello_time = STP_DEFAULT_HELLO_TIME; + } + + config_str = ovsrec_bridge_get_other_config_value(br->cfg, + "stp-max-age", + NULL); + if (config_str) { + br_s.max_age = strtoul(config_str, NULL, 10) * 1000; + } else { + br_s.max_age = STP_DEFAULT_MAX_AGE; + } + + config_str = ovsrec_bridge_get_other_config_value(br->cfg, + "stp-forward-delay", + NULL); + if (config_str) { + br_s.fwd_delay = strtoul(config_str, NULL, 10) * 1000; + } else { + br_s.fwd_delay = STP_DEFAULT_FWD_DELAY; + } + + /* Configure STP on the bridge. */ + if (ofproto_set_stp(br->ofproto, &br_s)) { + VLOG_ERR("bridge %s: could not enable STP", br->name); + return; + } + + /* Users must either set the port number with the "stp-port-num" + * configuration on all ports or none. If manual configuration + * is not done, then we allocate them sequentially. */ + port_num_counter = 0; + port_num_bitmap = bitmap_allocate(STP_MAX_PORTS); + HMAP_FOR_EACH (port, hmap_node, &br->ports) { + struct ofproto_port_stp_settings port_s; + struct iface *iface; + + port_configure_stp(br->ofproto, port, &port_s, + &port_num_counter, port_num_bitmap); + + /* As bonds are not supported, just apply configuration to + * all interfaces. */ + LIST_FOR_EACH (iface, port_elem, &port->ifaces) { + if (ofproto_port_set_stp(br->ofproto, iface->ofp_port, + &port_s)) { + VLOG_ERR("port %s: could not enable STP", port->name); + continue; + } + } + } + + if (bitmap_scan(port_num_bitmap, 0, STP_MAX_PORTS) != STP_MAX_PORTS + && port_num_counter) { + VLOG_ERR("bridge %s: must manually configure all STP port " + "IDs or none, disabling", br->name); + ofproto_set_stp(br->ofproto, NULL); + } + bitmap_free(port_num_bitmap); + } +} + static bool bridge_has_bond_fake_iface(const struct bridge *br, const char *name) { @@ -710,9 +997,16 @@ add_del_bridges(const struct ovsrec_open_vswitch *cfg) /* Collect new bridges' names and types. */ shash_init(&new_br); for (i = 0; i < cfg->n_bridges; i++) { + static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5); const struct ovsrec_bridge *br_cfg = cfg->bridges[i]; - if (!shash_add_once(&new_br, br_cfg->name, br_cfg)) { - VLOG_WARN("bridge %s specified twice", br_cfg->name); + + if (strchr(br_cfg->name, '/')) { + /* Prevent remote ovsdb-server users from accessing arbitrary + * directories, e.g. consider a bridge named "../../../etc/". */ + VLOG_WARN_RL(&rl, "ignoring bridge with invalid name \"%s\"", + br_cfg->name); + } else if (!shash_add_once(&new_br, br_cfg->name, br_cfg)) { + VLOG_WARN_RL(&rl, "bridge %s specified twice", br_cfg->name); } } @@ -855,6 +1149,12 @@ bridge_add_ofproto_ports(struct bridge *br) VLOG_WARN("could not open network device %s (%s)", iface->name, strerror(error)); } + + if (iface->netdev + && port->cfg->vlan_mode + && !strcmp(port->cfg->vlan_mode, "splinter")) { + netdev_turn_flags_on(iface->netdev, NETDEV_UP, true); + } } else { error = 0; } @@ -894,9 +1194,10 @@ bridge_add_ofproto_ports(struct bridge *br) } /* Populate stats columns in new Interface rows. */ - if (iface->netdev && !iface->cfg->mtu) { + if (iface->netdev && iface->need_refresh) { iface_refresh_stats(iface); iface_refresh_status(iface); + iface->need_refresh = false; } /* Delete the iface if we failed. */ @@ -911,7 +1212,12 @@ bridge_add_ofproto_ports(struct bridge *br) /* We already reported a related error, don't bother * duplicating it. */ } - iface_set_ofport(iface->cfg, -1); + if (!ofproto_port_query_by_name(br->ofproto, port->name, + &ofproto_port)) { + ofproto_port_del(br->ofproto, ofproto_port.ofp_port); + ofproto_port_destroy(&ofproto_port); + } + iface_clear_db_record(iface->cfg); iface_destroy(iface); } } @@ -944,28 +1250,6 @@ bridge_add_ofproto_ports(struct bridge *br) } } -static const char * -get_ovsrec_key_value(const struct ovsdb_idl_row *row, - const struct ovsdb_idl_column *column, - const char *key) -{ - const struct ovsdb_datum *datum; - union ovsdb_atom atom; - unsigned int idx; - - datum = ovsdb_idl_get(row, column, OVSDB_TYPE_STRING, OVSDB_TYPE_STRING); - atom.string = (char *) key; - idx = ovsdb_datum_find_key(datum, &atom, OVSDB_TYPE_STRING); - return idx == UINT_MAX ? NULL : datum->values[idx].string; -} - -static const char * -bridge_get_other_config(const struct ovsrec_bridge *br_cfg, const char *key) -{ - return get_ovsrec_key_value(&br_cfg->header_, - &ovsrec_bridge_col_other_config, key); -} - /* Set Flow eviction threshold */ static void bridge_configure_flow_eviction_threshold(struct bridge *br) @@ -973,7 +1257,10 @@ bridge_configure_flow_eviction_threshold(struct bridge *br) const char *threshold_str; unsigned threshold; - threshold_str = bridge_get_other_config(br->cfg, "flow-eviction-threshold"); + threshold_str = + ovsrec_bridge_get_other_config_value(br->cfg, + "flow-eviction-threshold", + NULL); if (threshold_str) { threshold = strtoul(threshold_str, NULL, 10); } else { @@ -982,18 +1269,53 @@ bridge_configure_flow_eviction_threshold(struct bridge *br) ofproto_set_flow_eviction_threshold(br->ofproto, threshold); } +/* Set forward BPDU option. */ +static void +bridge_configure_forward_bpdu(struct bridge *br) +{ + const char *forward_bpdu_str; + bool forward_bpdu = false; + + forward_bpdu_str = ovsrec_bridge_get_other_config_value(br->cfg, + "forward-bpdu", + NULL); + if (forward_bpdu_str && !strcmp(forward_bpdu_str, "true")) { + forward_bpdu = true; + } + ofproto_set_forward_bpdu(br->ofproto, forward_bpdu); +} + +/* Set MAC aging time for 'br'. */ +static void +bridge_configure_mac_idle_time(struct bridge *br) +{ + const char *idle_time_str; + int idle_time; + + idle_time_str = ovsrec_bridge_get_other_config_value(br->cfg, + "mac-aging-time", + NULL); + idle_time = (idle_time_str && atoi(idle_time_str) + ? atoi(idle_time_str) + : MAC_ENTRY_DEFAULT_IDLE_TIME); + ofproto_set_mac_idle_time(br->ofproto, idle_time); +} + static void bridge_pick_local_hw_addr(struct bridge *br, uint8_t ea[ETH_ADDR_LEN], struct iface **hw_addr_iface) { + struct hmapx mirror_output_ports; const char *hwaddr; struct port *port; + bool found_addr = false; int error; + int i; *hw_addr_iface = NULL; /* Did the user request a particular MAC? */ - hwaddr = bridge_get_other_config(br->cfg, "hwaddr"); + hwaddr = ovsrec_bridge_get_other_config_value(br->cfg, "hwaddr", NULL); if (hwaddr && eth_addr_from_string(hwaddr, ea)) { if (eth_addr_is_multicast(ea)) { VLOG_ERR("bridge %s: cannot set MAC address to multicast " @@ -1005,16 +1327,27 @@ bridge_pick_local_hw_addr(struct bridge *br, uint8_t ea[ETH_ADDR_LEN], } } + /* Mirror output ports don't participate in picking the local hardware + * address. ofproto can't help us find out whether a given port is a + * mirror output because we haven't configured mirrors yet, so we need to + * accumulate them ourselves. */ + hmapx_init(&mirror_output_ports); + for (i = 0; i < br->cfg->n_mirrors; i++) { + struct ovsrec_mirror *m = br->cfg->mirrors[i]; + if (m->output_port) { + hmapx_add(&mirror_output_ports, m->output_port); + } + } + /* Otherwise choose the minimum non-local MAC address among all of the * interfaces. */ - memset(ea, 0xff, ETH_ADDR_LEN); HMAP_FOR_EACH (port, hmap_node, &br->ports) { uint8_t iface_ea[ETH_ADDR_LEN]; struct iface *candidate; struct iface *iface; /* Mirror output ports don't participate. */ - if (ofproto_is_mirror_output_bundle(br->ofproto, port)) { + if (hmapx_contains(&mirror_output_ports, port->cfg)) { continue; } @@ -1061,21 +1394,25 @@ bridge_pick_local_hw_addr(struct bridge *br, uint8_t ea[ETH_ADDR_LEN], !eth_addr_is_local(iface_ea) && !eth_addr_is_reserved(iface_ea) && !eth_addr_is_zero(iface_ea) && - eth_addr_compare_3way(iface_ea, ea) < 0) + (!found_addr || eth_addr_compare_3way(iface_ea, ea) < 0)) { memcpy(ea, iface_ea, ETH_ADDR_LEN); *hw_addr_iface = iface; + found_addr = true; } } - if (eth_addr_is_multicast(ea)) { - memcpy(ea, br->default_ea, ETH_ADDR_LEN); - *hw_addr_iface = NULL; - VLOG_WARN("bridge %s: using default bridge Ethernet " - "address "ETH_ADDR_FMT, br->name, ETH_ADDR_ARGS(ea)); - } else { + if (found_addr) { VLOG_DBG("bridge %s: using bridge Ethernet address "ETH_ADDR_FMT, br->name, ETH_ADDR_ARGS(ea)); + } else { + static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 10); + memcpy(ea, br->default_ea, ETH_ADDR_LEN); + *hw_addr_iface = NULL; + VLOG_WARN_RL(&rl, "bridge %s: using default bridge Ethernet " + "address "ETH_ADDR_FMT, br->name, ETH_ADDR_ARGS(ea)); } + + hmapx_destroy(&mirror_output_ports); } /* Choose and returns the datapath ID for bridge 'br' given that the bridge @@ -1103,38 +1440,16 @@ bridge_pick_datapath_id(struct bridge *br, const char *datapath_id; uint64_t dpid; - datapath_id = bridge_get_other_config(br->cfg, "datapath-id"); + datapath_id = ovsrec_bridge_get_other_config_value(br->cfg, "datapath-id", + NULL); if (datapath_id && dpid_from_string(datapath_id, &dpid)) { return dpid; } - if (hw_addr_iface) { - int vlan; - if (!netdev_get_vlan_vid(hw_addr_iface->netdev, &vlan)) { - /* - * A bridge whose MAC address is taken from a VLAN network device - * (that is, a network device created with vconfig(8) or similar - * tool) will have the same MAC address as a bridge on the VLAN - * device's physical network device. - * - * Handle this case by hashing the physical network device MAC - * along with the VLAN identifier. - */ - uint8_t buf[ETH_ADDR_LEN + 2]; - memcpy(buf, bridge_ea, ETH_ADDR_LEN); - buf[ETH_ADDR_LEN] = vlan >> 8; - buf[ETH_ADDR_LEN + 1] = vlan; - return dpid_from_hash(buf, sizeof buf); - } else { - /* - * Assume that this bridge's MAC address is unique, since it - * doesn't fit any of the cases we handle specially. - */ - } - } else { + if (!hw_addr_iface) { /* * A purely internal bridge, that is, one that has no non-virtual - * network devices on it at all, is more difficult because it has no + * network devices on it at all, is difficult because it has no * natural unique identifier at all. * * When the host is a XenServer, we handle this case by hashing the @@ -1174,8 +1489,8 @@ iface_refresh_status(struct iface *iface) { struct shash sh; + enum netdev_features current; enum netdev_flags flags; - uint32_t current; int64_t bps; int mtu; int64_t mtu_64; @@ -1187,7 +1502,7 @@ iface_refresh_status(struct iface *iface) shash_init(&sh); - if (!netdev_get_status(iface->netdev, &sh)) { + if (!netdev_get_drv_info(iface->netdev, &sh)) { size_t n; char **keys, **values; @@ -1204,7 +1519,8 @@ iface_refresh_status(struct iface *iface) error = netdev_get_flags(iface->netdev, &flags); if (!error) { - ovsrec_interface_set_admin_state(iface->cfg, flags & NETDEV_UP ? "up" : "down"); + ovsrec_interface_set_admin_state(iface->cfg, + flags & NETDEV_UP ? "up" : "down"); } else { ovsrec_interface_set_admin_state(iface->cfg, NULL); @@ -1224,11 +1540,8 @@ iface_refresh_status(struct iface *iface) ovsrec_interface_set_link_speed(iface->cfg, NULL, 0); } - ovsrec_interface_set_link_state(iface->cfg, - iface_get_carrier(iface) ? "up" : "down"); - error = netdev_get_mtu(iface->netdev, &mtu); - if (!error && mtu != INT_MAX) { + if (!error) { mtu_64 = mtu; ovsrec_interface_set_mtu(iface->cfg, &mtu_64, 1); } @@ -1237,43 +1550,59 @@ iface_refresh_status(struct iface *iface) } } -/* Writes 'iface''s CFM statistics to the database. Returns true if anything - * changed, false otherwise. */ -static bool +/* Writes 'iface''s CFM statistics to the database. */ +static void iface_refresh_cfm_stats(struct iface *iface) { const struct ovsrec_interface *cfg = iface->cfg; - bool changed = false; - int fault; + int fault, error; + const uint64_t *rmps; + size_t n_rmps; + int health; + + if (iface_is_synthetic(iface)) { + return; + } fault = ofproto_port_get_cfm_fault(iface->port->bridge->ofproto, iface->ofp_port); + if (fault >= 0) { + const char *reasons[CFM_FAULT_N_REASONS]; + bool fault_bool = fault; + size_t i, j; - if (fault < 0) { - return false; - } + j = 0; + for (i = 0; i < CFM_FAULT_N_REASONS; i++) { + int reason = 1 << i; + if (fault & reason) { + reasons[j++] = cfm_fault_reason_to_str(reason); + } + } - if (cfg->n_cfm_fault != 1 || cfg->cfm_fault[0] != fault) { - bool fault_bool = fault; ovsrec_interface_set_cfm_fault(cfg, &fault_bool, 1); - changed = true; + ovsrec_interface_set_cfm_fault_status(cfg, (char **) reasons, j); + } else { + ovsrec_interface_set_cfm_fault(cfg, NULL, 0); + ovsrec_interface_set_cfm_fault_status(cfg, NULL, 0); } - return changed; -} - -static bool -iface_refresh_lacp_stats(struct iface *iface) -{ - struct ofproto *ofproto = iface->port->bridge->ofproto; - int old = iface->cfg->lacp_current ? *iface->cfg->lacp_current : -1; - int new = ofproto_port_is_lacp_current(ofproto, iface->ofp_port); + error = ofproto_port_get_cfm_remote_mpids(iface->port->bridge->ofproto, + iface->ofp_port, &rmps, &n_rmps); + if (error >= 0) { + ovsrec_interface_set_cfm_remote_mpids(cfg, (const int64_t *)rmps, + n_rmps); + } else { + ovsrec_interface_set_cfm_remote_mpids(cfg, NULL, 0); + } - if (old != new) { - bool current = new; - ovsrec_interface_set_lacp_current(iface->cfg, ¤t, new >= 0); + health = ofproto_port_get_cfm_health(iface->port->bridge->ofproto, + iface->ofp_port); + if (health >= 0) { + int64_t cfm_health = health; + ovsrec_interface_set_cfm_health(cfg, &cfm_health, 1); + } else { + ovsrec_interface_set_cfm_health(cfg, NULL, 0); } - return old != new; } static void @@ -1316,19 +1645,113 @@ iface_refresh_stats(struct iface *iface) #undef IFACE_STAT assert(i == ARRAY_SIZE(keys)); - ovsrec_interface_set_statistics(iface->cfg, keys, values, ARRAY_SIZE(keys)); + ovsrec_interface_set_statistics(iface->cfg, keys, values, + ARRAY_SIZE(keys)); #undef IFACE_STATS } +static void +br_refresh_stp_status(struct bridge *br) +{ + struct ofproto *ofproto = br->ofproto; + struct ofproto_stp_status status; + char *keys[3], *values[3]; + size_t i; + + if (ofproto_get_stp_status(ofproto, &status)) { + return; + } + + if (!status.enabled) { + ovsrec_bridge_set_status(br->cfg, NULL, NULL, 0); + return; + } + + keys[0] = "stp_bridge_id", + values[0] = xasprintf(STP_ID_FMT, STP_ID_ARGS(status.bridge_id)); + keys[1] = "stp_designated_root", + values[1] = xasprintf(STP_ID_FMT, STP_ID_ARGS(status.designated_root)); + keys[2] = "stp_root_path_cost", + values[2] = xasprintf("%d", status.root_path_cost); + + ovsrec_bridge_set_status(br->cfg, keys, values, ARRAY_SIZE(values)); + + for (i = 0; i < ARRAY_SIZE(values); i++) { + free(values[i]); + } +} + +static void +port_refresh_stp_status(struct port *port) +{ + struct ofproto *ofproto = port->bridge->ofproto; + struct iface *iface; + struct ofproto_port_stp_status status; + char *keys[4]; + char *str_values[4]; + int64_t int_values[3]; + size_t i; + + if (port_is_synthetic(port)) { + return; + } + + /* STP doesn't currently support bonds. */ + if (!list_is_singleton(&port->ifaces)) { + ovsrec_port_set_status(port->cfg, NULL, NULL, 0); + return; + } + + iface = CONTAINER_OF(list_front(&port->ifaces), struct iface, port_elem); + + if (ofproto_port_get_stp_status(ofproto, iface->ofp_port, &status)) { + return; + } + + if (!status.enabled) { + ovsrec_port_set_status(port->cfg, NULL, NULL, 0); + ovsrec_port_set_statistics(port->cfg, NULL, NULL, 0); + return; + } + + /* Set Status column. */ + keys[0] = "stp_port_id"; + str_values[0] = xasprintf(STP_PORT_ID_FMT, status.port_id); + keys[1] = "stp_state"; + str_values[1] = xstrdup(stp_state_name(status.state)); + keys[2] = "stp_sec_in_state"; + str_values[2] = xasprintf("%u", status.sec_in_state); + keys[3] = "stp_role"; + str_values[3] = xstrdup(stp_role_name(status.role)); + + ovsrec_port_set_status(port->cfg, keys, str_values, + ARRAY_SIZE(str_values)); + + for (i = 0; i < ARRAY_SIZE(str_values); i++) { + free(str_values[i]); + } + + /* Set Statistics column. */ + keys[0] = "stp_tx_count"; + int_values[0] = status.tx_count; + keys[1] = "stp_rx_count"; + int_values[1] = status.rx_count; + keys[2] = "stp_error_count"; + int_values[2] = status.error_count; + + ovsrec_port_set_statistics(port->cfg, keys, int_values, + ARRAY_SIZE(int_values)); +} + static bool enable_system_stats(const struct ovsrec_open_vswitch *cfg) { const char *enable; /* Use other-config:enable-system-stats by preference. */ - enable = get_ovsrec_key_value(&cfg->header_, - &ovsrec_open_vswitch_col_other_config, - "enable-statistics"); + enable = ovsrec_open_vswitch_get_other_config_value(cfg, + "enable-statistics", + NULL); if (enable) { return !strcmp(enable, "true"); } @@ -1403,17 +1826,57 @@ refresh_controller_status(void) ofproto_free_ofproto_controller_info(&info); } +static void +refresh_cfm_stats(void) +{ + static struct ovsdb_idl_txn *txn = NULL; + + if (!txn) { + struct bridge *br; + + txn = ovsdb_idl_txn_create(idl); + + HMAP_FOR_EACH (br, node, &all_bridges) { + struct iface *iface; + + HMAP_FOR_EACH (iface, name_node, &br->iface_by_name) { + iface_refresh_cfm_stats(iface); + } + } + } + + if (ovsdb_idl_txn_commit(txn) != TXN_INCOMPLETE) { + ovsdb_idl_txn_destroy(txn); + txn = NULL; + } +} + +/* Performs periodic activity required by bridges that needs to be done with + * the least possible latency. + * + * It makes sense to call this function a couple of times per poll loop, to + * provide a significant performance boost on some benchmarks with ofprotos + * that use the ofproto-dpif implementation. */ +void +bridge_run_fast(void) +{ + struct bridge *br; + + HMAP_FOR_EACH (br, node, &all_bridges) { + ofproto_run_fast(br->ofproto); + } +} + void bridge_run(void) { const struct ovsrec_open_vswitch *cfg; - bool datapath_destroyed; - bool database_changed; + bool vlan_splinters_changed; struct bridge *br; /* (Re)configure if necessary. */ - database_changed = ovsdb_idl_run(idl); + ovsdb_idl_run(idl); if (ovsdb_idl_is_lock_contended(idl)) { static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 1); struct bridge *br, *next_br; @@ -1431,15 +1894,8 @@ bridge_run(void) cfg = ovsrec_open_vswitch_first(idl); /* Let each bridge do the work that it needs to do. */ - datapath_destroyed = false; HMAP_FOR_EACH (br, node, &all_bridges) { - int error = ofproto_run(br->ofproto); - if (error) { - static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5); - VLOG_ERR_RL(&rl, "bridge %s: datapath was destroyed externally, " - "forcing reconfiguration", br->name); - datapath_destroyed = true; - } + ofproto_run(br->ofproto); } /* Re-configure SSL. We do this on every trip through the main loop, @@ -1455,7 +1911,20 @@ bridge_run(void) stream_ssl_set_ca_cert_file(ssl->ca_cert, ssl->bootstrap_ca_cert); } - if (database_changed || datapath_destroyed) { + /* If VLAN splinters are in use, then we need to reconfigure if VLAN usage + * has changed. */ + vlan_splinters_changed = false; + if (vlan_splinters_enabled_anywhere) { + HMAP_FOR_EACH (br, node, &all_bridges) { + if (ofproto_has_vlan_usage_changed(br->ofproto)) { + vlan_splinters_changed = true; + break; + } + } + } + + if (ovsdb_idl_get_seqno(idl) != idl_seqno || vlan_splinters_changed) { + idl_seqno = ovsdb_idl_get_seqno(idl); if (cfg) { struct ovsdb_idl_txn *txn = ovsdb_idl_txn_create(idl); @@ -1481,6 +1950,7 @@ bridge_run(void) txn = ovsdb_idl_txn_create(idl); HMAP_FOR_EACH (br, node, &all_bridges) { struct port *port; + struct mirror *m; HMAP_FOR_EACH (port, hmap_node, &br->ports) { struct iface *iface; @@ -1490,6 +1960,11 @@ bridge_run(void) iface_refresh_status(iface); } } + + HMAP_FOR_EACH (m, hmap_node, &br->mirrors) { + mirror_refresh_stats(m); + } + } refresh_system_stats(cfg); refresh_controller_status(); @@ -1502,29 +1977,51 @@ bridge_run(void) if (time_msec() >= db_limiter) { struct ovsdb_idl_txn *txn; - bool changed = false; txn = ovsdb_idl_txn_create(idl); HMAP_FOR_EACH (br, node, &all_bridges) { + struct iface *iface; struct port *port; + br_refresh_stp_status(br); + HMAP_FOR_EACH (port, hmap_node, &br->ports) { - struct iface *iface; + port_refresh_stp_status(port); + } + + HMAP_FOR_EACH (iface, name_node, &br->iface_by_name) { + const char *link_state; + int64_t link_resets; + int current; - LIST_FOR_EACH (iface, port_elem, &port->ifaces) { - changed = iface_refresh_cfm_stats(iface) || changed; - changed = iface_refresh_lacp_stats(iface) || changed; + if (iface_is_synthetic(iface)) { + continue; } + + current = ofproto_port_is_lacp_current(br->ofproto, + iface->ofp_port); + if (current >= 0) { + bool bl = current; + ovsrec_interface_set_lacp_current(iface->cfg, &bl, 1); + } else { + ovsrec_interface_set_lacp_current(iface->cfg, NULL, 0); + } + + link_state = netdev_get_carrier(iface->netdev) ? "up" : "down"; + ovsrec_interface_set_link_state(iface->cfg, link_state); + + link_resets = netdev_get_carrier_resets(iface->netdev); + ovsrec_interface_set_link_resets(iface->cfg, &link_resets, 1); } } - if (changed) { + if (ovsdb_idl_txn_commit(txn) != TXN_UNCHANGED) { db_limiter = time_msec() + DB_LIMIT_INTERVAL; } - - ovsdb_idl_txn_commit(txn); ovsdb_idl_txn_destroy(txn); } + + refresh_cfm_stats(); } void @@ -1595,8 +2092,8 @@ qos_unixctl_show_cb(unsigned int queue_id, } static void -qos_unixctl_show(struct unixctl_conn *conn, - const char *args, void *aux OVS_UNUSED) +qos_unixctl_show(struct unixctl_conn *conn, int argc OVS_UNUSED, + const char *argv[], void *aux OVS_UNUSED) { struct ds ds = DS_EMPTY_INITIALIZER; struct shash sh = SHASH_INITIALIZER(&sh); @@ -1606,9 +2103,9 @@ qos_unixctl_show(struct unixctl_conn *conn, struct qos_unixctl_show_cbdata data; int error; - iface = iface_find(args); + iface = iface_find(argv[1]); if (!iface) { - unixctl_command_reply(conn, 501, "no such interface"); + unixctl_command_reply_error(conn, "no such interface"); return; } @@ -1628,10 +2125,10 @@ qos_unixctl_show(struct unixctl_conn *conn, if (error) { ds_put_format(&ds, "failed to dump queues: %s", strerror(error)); } - unixctl_command_reply(conn, 200, ds_cstr(&ds)); + unixctl_command_reply(conn, ds_cstr(&ds)); } else { ds_put_format(&ds, "QoS not configured on %s\n", iface->name); - unixctl_command_reply(conn, 501, ds_cstr(&ds)); + unixctl_command_reply_error(conn, ds_cstr(&ds)); } shash_destroy_free_data(&sh); @@ -1705,22 +2202,22 @@ bridge_lookup(const char *name) /* Handle requests for a listing of all flows known by the OpenFlow * stack, including those normally hidden. */ static void -bridge_unixctl_dump_flows(struct unixctl_conn *conn, - const char *args, void *aux OVS_UNUSED) +bridge_unixctl_dump_flows(struct unixctl_conn *conn, int argc OVS_UNUSED, + const char *argv[], void *aux OVS_UNUSED) { struct bridge *br; struct ds results; - br = bridge_lookup(args); + br = bridge_lookup(argv[1]); if (!br) { - unixctl_command_reply(conn, 501, "Unknown bridge"); + unixctl_command_reply_error(conn, "Unknown bridge"); return; } ds_init(&results); ofproto_get_all_flows(br->ofproto, &results); - unixctl_command_reply(conn, 200, ds_cstr(&results)); + unixctl_command_reply(conn, ds_cstr(&results)); ds_destroy(&results); } @@ -1728,14 +2225,14 @@ bridge_unixctl_dump_flows(struct unixctl_conn *conn, * connections and reconnect. If BRIDGE is not specified, then all bridges * drop their controller connections and reconnect. */ static void -bridge_unixctl_reconnect(struct unixctl_conn *conn, - const char *args, void *aux OVS_UNUSED) +bridge_unixctl_reconnect(struct unixctl_conn *conn, int argc, + const char *argv[], void *aux OVS_UNUSED) { struct bridge *br; - if (args[0] != '\0') { - br = bridge_lookup(args); + if (argc > 1) { + br = bridge_lookup(argv[1]); if (!br) { - unixctl_command_reply(conn, 501, "Unknown bridge"); + unixctl_command_reply_error(conn, "Unknown bridge"); return; } ofproto_reconnect_controllers(br->ofproto); @@ -1744,7 +2241,7 @@ bridge_unixctl_reconnect(struct unixctl_conn *conn, ofproto_reconnect_controllers(br->ofproto); } } - unixctl_command_reply(conn, 200, NULL); + unixctl_command_reply(conn, NULL); } static size_t @@ -1771,7 +2268,8 @@ bridge_get_controllers(const struct bridge *br, /* Adds and deletes "struct port"s and "struct iface"s under 'br' to match * those configured in 'br->cfg'. */ static void -bridge_add_del_ports(struct bridge *br) +bridge_add_del_ports(struct bridge *br, + const unsigned long int *splinter_vlans) { struct port *port, *next; struct shash_node *node; @@ -1804,9 +2302,12 @@ bridge_add_del_ports(struct bridge *br) shash_add(&new_ports, br->name, &br->synth_local_port); } + if (splinter_vlans) { + add_vlan_splinter_ports(br, splinter_vlans, &new_ports); + } + /* Get rid of deleted ports. - * Get rid of deleted interfaces on ports that still exist. - * Update 'cfg' of ports that still exist. */ + * Get rid of deleted interfaces on ports that still exist. */ HMAP_FOR_EACH_SAFE (port, next, hmap_node, &br->ports) { port->cfg = shash_find_data(&new_ports, port->name); if (!port->cfg) { @@ -1848,6 +2349,7 @@ bridge_ofproto_controller_for_mgmt(const struct bridge *br, oc->band = OFPROTO_OUT_OF_BAND; oc->rate_limit = 0; oc->burst_limit = 0; + oc->enable_async_msgs = true; } /* Converts ovsrec_controller 'c' into an ofproto_controller in 'oc'. */ @@ -1855,6 +2357,8 @@ static void bridge_ofproto_controller_from_ovsrec(const struct ovsrec_controller *c, struct ofproto_controller *oc) { + const char *config_str; + oc->target = c->target; oc->max_backoff = c->max_backoff ? *c->max_backoff / 1000 : 8; oc->probe_interval = c->inactivity_probe ? *c->inactivity_probe / 1000 : 5; @@ -1863,6 +2367,14 @@ bridge_ofproto_controller_from_ovsrec(const struct ovsrec_controller *c, oc->rate_limit = c->controller_rate_limit ? *c->controller_rate_limit : 0; oc->burst_limit = (c->controller_burst_limit ? *c->controller_burst_limit : 0); + oc->enable_async_msgs = (!c->enable_async_messages + || *c->enable_async_messages); + config_str = ovsrec_controller_get_other_config_value(c, "dscp", NULL); + if (config_str) { + oc->dscp = atoi(config_str); + } else { + oc->dscp = DSCP_DEFAULT; + } } /* Configures the IP stack for 'br''s local interface properly according to the @@ -1909,6 +2421,26 @@ bridge_configure_local_iface_netdev(struct bridge *br, } } +/* Returns true if 'a' and 'b' are the same except that any number of slashes + * in either string are treated as equal to any number of slashes in the other, + * e.g. "x///y" is equal to "x/y". */ +static bool +equal_pathnames(const char *a, const char *b) +{ + while (*a == *b) { + if (*a == '/') { + a += strspn(a, "/"); + b += strspn(b, "/"); + } else if (*a == '\0') { + return true; + } else { + a++; + b++; + } + } + return false; +} + static void bridge_configure_remotes(struct bridge *br, const struct sockaddr_in *managers, size_t n_managers) @@ -1927,13 +2459,17 @@ bridge_configure_remotes(struct bridge *br, size_t i; /* Check if we should disable in-band control on this bridge. */ - disable_ib_str = bridge_get_other_config(br->cfg, "disable-in-band"); + disable_ib_str = ovsrec_bridge_get_other_config_value(br->cfg, + "disable-in-band", + NULL); if (disable_ib_str && !strcmp(disable_ib_str, "true")) { disable_in_band = true; } /* Set OpenFlow queue ID for in-band control. */ - queue_id_str = bridge_get_other_config(br->cfg, "in-band-queue"); + queue_id_str = ovsrec_bridge_get_other_config_value(br->cfg, + "in-band-queue", + NULL); queue_id = queue_id_str ? strtol(queue_id_str, NULL, 10) : -1; ofproto_set_in_band_queue(br->ofproto, queue_id); @@ -1955,13 +2491,26 @@ bridge_configure_remotes(struct bridge *br, if (!strncmp(c->target, "punix:", 6) || !strncmp(c->target, "unix:", 5)) { static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5); + char *whitelist; + + whitelist = xasprintf("unix:%s/%s.controller", + ovs_rundir(), br->name); + if (!equal_pathnames(c->target, whitelist)) { + /* Prevent remote ovsdb-server users from accessing arbitrary + * Unix domain sockets and overwriting arbitrary local + * files. */ + VLOG_ERR_RL(&rl, "bridge %s: Not adding Unix domain socket " + "controller \"%s\" due to possibility for remote " + "exploit. Instead, specify whitelisted \"%s\" or " + "connect to \"unix:%s/%s.mgmt\" (which is always " + "available without special configuration).", + br->name, c->target, whitelist, + ovs_rundir(), br->name); + free(whitelist); + continue; + } - /* Prevent remote ovsdb-server users from accessing arbitrary Unix - * domain sockets and overwriting arbitrary local files. */ - VLOG_ERR_RL(&rl, "bridge %s: not adding Unix domain socket " - "controller \"%s\" due to possibility for remote " - "exploit", br->name, c->target); - continue; + free(whitelist); } bridge_configure_local_iface_netdev(br, c); @@ -1994,6 +2543,66 @@ bridge_configure_remotes(struct bridge *br, sset_destroy(&snoops); } } + +static void +bridge_configure_tables(struct bridge *br) +{ + static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5); + int n_tables; + int i, j; + + n_tables = ofproto_get_n_tables(br->ofproto); + j = 0; + for (i = 0; i < n_tables; i++) { + struct ofproto_table_settings s; + + s.name = NULL; + s.max_flows = UINT_MAX; + s.groups = NULL; + s.n_groups = 0; + + if (j < br->cfg->n_flow_tables && i == br->cfg->key_flow_tables[j]) { + struct ovsrec_flow_table *cfg = br->cfg->value_flow_tables[j++]; + + s.name = cfg->name; + if (cfg->n_flow_limit && *cfg->flow_limit < UINT_MAX) { + s.max_flows = *cfg->flow_limit; + } + if (cfg->overflow_policy + && !strcmp(cfg->overflow_policy, "evict")) { + size_t k; + + s.groups = xmalloc(cfg->n_groups * sizeof *s.groups); + for (k = 0; k < cfg->n_groups; k++) { + const char *string = cfg->groups[k]; + char *msg; + + msg = mf_parse_subfield__(&s.groups[k], &string); + if (msg) { + VLOG_WARN_RL(&rl, "bridge %s table %d: error parsing " + "'groups' (%s)", br->name, i, msg); + free(msg); + } else if (*string) { + VLOG_WARN_RL(&rl, "bridge %s table %d: 'groups' " + "element '%s' contains trailing garbage", + br->name, i, cfg->groups[k]); + } else { + s.n_groups++; + } + } + } + } + + ofproto_configure_table(br->ofproto, i, &s); + + free(s.groups); + } + for (; j < br->cfg->n_flow_tables; j++) { + VLOG_WARN_RL(&rl, "bridge %s: ignoring configuration for flow table " + "%"PRId64" not supported by this datapath", br->name, + br->cfg->key_flow_tables[j]); + } +} /* Port functions. */ @@ -2015,28 +2624,6 @@ port_create(struct bridge *br, const struct ovsrec_port *cfg) return port; } -static const char * -get_port_other_config(const struct ovsrec_port *port, const char *key, - const char *default_value) -{ - const char *value; - - value = get_ovsrec_key_value(&port->header_, &ovsrec_port_col_other_config, - key); - return value ? value : default_value; -} - -static const char * -get_interface_other_config(const struct ovsrec_interface *iface, - const char *key, const char *default_value) -{ - const char *value; - - value = get_ovsrec_key_value(&iface->header_, - &ovsrec_interface_col_other_config, key); - return value ? value : default_value; -} - /* Deletes interfaces from 'port' that are no longer configured for it. */ static void port_del_ifaces(struct port *port) @@ -2082,7 +2669,7 @@ port_add_ifaces(struct port *port) && !shash_add_once(&new_ifaces, cfg->name, cfg)) { VLOG_WARN("port %s: %s specified twice as port interface", port->name, cfg->name); - iface_set_ofport(cfg, -1); + iface_clear_db_record(cfg); } } @@ -2173,7 +2760,7 @@ enable_lacp(struct port *port, bool *activep) static struct lacp_settings * port_configure_lacp(struct port *port, struct lacp_settings *s) { - const char *lacp_time; + const char *lacp_time, *system_id; long long int custom_time; int priority; @@ -2182,21 +2769,40 @@ port_configure_lacp(struct port *port, struct lacp_settings *s) } s->name = port->name; - memcpy(s->id, port->bridge->ea, ETH_ADDR_LEN); + + system_id = ovsrec_port_get_other_config_value(port->cfg, "lacp-system-id", + NULL); + if (system_id) { + if (sscanf(system_id, ETH_ADDR_SCAN_FMT, + ETH_ADDR_SCAN_ARGS(s->id)) != ETH_ADDR_SCAN_COUNT) { + VLOG_WARN("port %s: LACP system ID (%s) must be an Ethernet" + " address.", port->name, system_id); + return NULL; + } + } else { + memcpy(s->id, port->bridge->ea, ETH_ADDR_LEN); + } + + if (eth_addr_is_zero(s->id)) { + VLOG_WARN("port %s: Invalid zero LACP system ID.", port->name); + return NULL; + } /* Prefer bondable links if unspecified. */ - priority = atoi(get_port_other_config(port->cfg, "lacp-system-priority", - "0")); + priority = atoi(ovsrec_port_get_other_config_value(port->cfg, + "lacp-system-priority", + "0")); s->priority = (priority > 0 && priority <= UINT16_MAX ? priority : UINT16_MAX - !list_is_short(&port->ifaces)); - s->heartbeat = !strcmp(get_port_other_config(port->cfg, - "lacp-heartbeat", - "false"), "true"); + s->heartbeat = !strcmp(ovsrec_port_get_other_config_value(port->cfg, + "lacp-heartbeat", + "false"), + "true"); - - lacp_time = get_port_other_config(port->cfg, "lacp-time", "slow"); + lacp_time = ovsrec_port_get_other_config_value(port->cfg, "lacp-time", + "slow"); custom_time = atoi(lacp_time); if (!strcmp(lacp_time, "fast")) { s->lacp_time = LACP_TIME_FAST; @@ -2217,11 +2823,16 @@ iface_configure_lacp(struct iface *iface, struct lacp_slave_settings *s) { int priority, portid, key; - portid = atoi(get_interface_other_config(iface->cfg, "lacp-port-id", "0")); - priority = atoi(get_interface_other_config(iface->cfg, - "lacp-port-priority", "0")); - key = atoi(get_interface_other_config(iface->cfg, "lacp-aggregation-key", - "0")); + portid = atoi(ovsrec_interface_get_other_config_value(iface->cfg, + "lacp-port-id", + "0")); + priority = + atoi(ovsrec_interface_get_other_config_value(iface->cfg, + "lacp-port-priority", + "0")); + key = atoi(ovsrec_interface_get_other_config_value(iface->cfg, + "lacp-aggregation-key", + "0")); if (portid <= 0 || portid > UINT16_MAX) { portid = iface->ofp_port; @@ -2251,12 +2862,22 @@ port_configure_bond(struct port *port, struct bond_settings *s, size_t i; s->name = port->name; - s->balance = BM_SLB; - if (port->cfg->bond_mode - && !bond_mode_from_string(&s->balance, port->cfg->bond_mode)) { - VLOG_WARN("port %s: unknown bond_mode %s, defaulting to %s", - port->name, port->cfg->bond_mode, - bond_mode_to_string(s->balance)); + s->balance = BM_AB; + if (port->cfg->bond_mode) { + if (!bond_mode_from_string(&s->balance, port->cfg->bond_mode)) { + VLOG_WARN("port %s: unknown bond_mode %s, defaulting to %s", + port->name, port->cfg->bond_mode, + bond_mode_to_string(s->balance)); + } + } else { + static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 1); + + /* XXX: Post version 1.5.*, the default bond_mode changed from SLB to + * active-backup. At some point we should remove this warning. */ + VLOG_WARN_RL(&rl, "port %s: Using the default bond_mode %s. Note that" + " in previous versions, the default bond_mode was" + " balance-slb", port->name, + bond_mode_to_string(s->balance)); } if (s->balance == BM_SLB && port->bridge->cfg->n_flood_vlans) { VLOG_WARN("port %s: SLB bonds are incompatible with flood_vlans, " @@ -2264,13 +2885,16 @@ port_configure_bond(struct port *port, struct bond_settings *s, port->name); } - miimon_interval = atoi(get_port_other_config(port->cfg, - "bond-miimon-interval", "0")); + miimon_interval = + atoi(ovsrec_port_get_other_config_value(port->cfg, + "bond-miimon-interval", "0")); if (miimon_interval <= 0) { miimon_interval = 200; } - detect_s = get_port_other_config(port->cfg, "bond-detect-mode", "carrier"); + detect_s = ovsrec_port_get_other_config_value(port->cfg, + "bond-detect-mode", + "carrier"); if (!strcmp(detect_s, "carrier")) { miimon_interval = 0; } else if (strcmp(detect_s, "miimon")) { @@ -2281,10 +2905,14 @@ port_configure_bond(struct port *port, struct bond_settings *s, s->up_delay = MAX(0, port->cfg->bond_updelay); s->down_delay = MAX(0, port->cfg->bond_downdelay); - s->basis = atoi(get_port_other_config(port->cfg, "bond-hash-basis", "0")); + s->basis = atoi(ovsrec_port_get_other_config_value(port->cfg, + "bond-hash-basis", + "0")); s->rebalance_interval = atoi( - get_port_other_config(port->cfg, "bond-rebalance-interval", "10000")); - if (s->rebalance_interval < 1000) { + ovsrec_port_get_other_config_value(port->cfg, + "bond-rebalance-interval", + "10000")); + if (s->rebalance_interval && s->rebalance_interval < 1000) { s->rebalance_interval = 1000; } @@ -2294,8 +2922,10 @@ port_configure_bond(struct port *port, struct bond_settings *s, LIST_FOR_EACH (iface, port_elem, &port->ifaces) { long long stable_id; - stable_id = atoll(get_interface_other_config(iface->cfg, - "bond-stable-id", "0")); + stable_id = + atoll(ovsrec_interface_get_other_config_value(iface->cfg, + "bond-stable-id", + "0")); if (stable_id <= 0 || stable_id >= UINT32_MAX) { stable_id = iface->ofp_port; } @@ -2304,6 +2934,14 @@ port_configure_bond(struct port *port, struct bond_settings *s, netdev_set_miimon_interval(iface->netdev, miimon_interval); } } + +/* Returns true if 'port' is synthetic, that is, if we constructed it locally + * instead of obtaining it from the database. */ +static bool +port_is_synthetic(const struct port *port) +{ + return ovsdb_idl_row_is_synthetic(&port->cfg->header_); +} /* Interface functions. */ @@ -2321,6 +2959,7 @@ iface_create(struct port *port, const struct ovsrec_interface *if_cfg) iface->tag = tag_create_random(); iface->netdev = NULL; iface->cfg = if_cfg; + iface->need_refresh = true; hmap_insert(&br->iface_by_name, &iface->name_node, hash_string(name, 0)); @@ -2435,6 +3074,30 @@ iface_set_ofport(const struct ovsrec_interface *if_cfg, int64_t ofport) } } +/* Clears all of the fields in 'if_cfg' that indicate interface status, and + * sets the "ofport" field to -1. + * + * This is appropriate when 'if_cfg''s interface cannot be created or is + * otherwise invalid. */ +static void +iface_clear_db_record(const struct ovsrec_interface *if_cfg) +{ + if (!ovsdb_idl_row_is_synthetic(&if_cfg->header_)) { + iface_set_ofport(if_cfg, -1); + ovsrec_interface_set_status(if_cfg, NULL, NULL, 0); + ovsrec_interface_set_admin_state(if_cfg, NULL); + ovsrec_interface_set_duplex(if_cfg, NULL); + ovsrec_interface_set_link_speed(if_cfg, NULL, 0); + ovsrec_interface_set_link_state(if_cfg, NULL); + ovsrec_interface_set_mtu(if_cfg, NULL, 0); + ovsrec_interface_set_cfm_fault(if_cfg, NULL, 0); + ovsrec_interface_set_cfm_fault_status(if_cfg, NULL, 0); + ovsrec_interface_set_cfm_remote_mpids(if_cfg, NULL, 0); + ovsrec_interface_set_lacp_current(if_cfg, NULL, 0); + ovsrec_interface_set_statistics(if_cfg, NULL, NULL, 0); + } +} + /* Adds the 'n' key-value pairs in 'keys' in 'values' to 'shash'. * * The value strings in '*shash' are taken directly from values[], not copied, @@ -2511,6 +3174,10 @@ iface_delete_queues(unsigned int queue_id, static void iface_configure_qos(struct iface *iface, const struct ovsrec_qos *qos) { + struct ofpbuf queues_buf; + + ofpbuf_init(&queues_buf, 0); + if (!qos || qos->type[0] == '\0' || qos->n_queues < 1) { netdev_set_qos(iface->netdev, NULL, NULL); } else { @@ -2541,6 +3208,15 @@ iface_configure_qos(struct iface *iface, const struct ovsrec_qos *qos) queue_zero = true; } + if (queue->n_dscp == 1) { + struct ofproto_port_queue *port_queue; + + port_queue = ofpbuf_put_uninit(&queues_buf, + sizeof *port_queue); + port_queue->queue = queue_id; + port_queue->dscp = queue->dscp[0]; + } + shash_from_ovs_idl_map(queue->key_other_config, queue->value_other_config, queue->n_other_config, &details); @@ -2548,54 +3224,74 @@ iface_configure_qos(struct iface *iface, const struct ovsrec_qos *qos) shash_destroy(&details); } if (!queue_zero) { - static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 1); - VLOG_WARN_RL(&rl, "interface %s: QoS configured without a default " - "queue (queue 0). Packets not directed to a " - "correctly configured queue may be dropped.", - iface->name); + shash_init(&details); + netdev_set_queue(iface->netdev, 0, &details); + shash_destroy(&details); } } + if (iface->ofp_port >= 0) { + const struct ofproto_port_queue *port_queues = queues_buf.data; + size_t n_queues = queues_buf.size / sizeof *port_queues; + + ofproto_port_set_queues(iface->port->bridge->ofproto, iface->ofp_port, + port_queues, n_queues); + } + netdev_set_policing(iface->netdev, iface->cfg->ingress_policing_rate, iface->cfg->ingress_policing_burst); + + ofpbuf_uninit(&queues_buf); } static void iface_configure_cfm(struct iface *iface) { const struct ovsrec_interface *cfg = iface->cfg; + const char *extended_str, *opstate_str; + const char *cfm_ccm_vlan; struct cfm_settings s; - uint16_t remote_mpid; - if (!cfg->n_cfm_mpid || !cfg->n_cfm_remote_mpid) { + if (!cfg->n_cfm_mpid) { ofproto_port_clear_cfm(iface->port->bridge->ofproto, iface->ofp_port); return; } s.mpid = *cfg->cfm_mpid; - remote_mpid = *cfg->cfm_remote_mpid; - s.remote_mpids = &remote_mpid; - s.n_remote_mpids = 1; - - s.interval = atoi(get_interface_other_config(iface->cfg, "cfm_interval", - "0")); + s.interval = atoi(ovsrec_interface_get_other_config_value(iface->cfg, + "cfm_interval", + "0")); + cfm_ccm_vlan = ovsrec_interface_get_other_config_value(iface->cfg, + "cfm_ccm_vlan", + "0"); + s.ccm_pcp = atoi(ovsrec_interface_get_other_config_value(iface->cfg, + "cfm_ccm_pcp", + "0")); if (s.interval <= 0) { s.interval = 1000; } - ofproto_port_set_cfm(iface->port->bridge->ofproto, iface->ofp_port, &s); -} + if (!strcasecmp("random", cfm_ccm_vlan)) { + s.ccm_vlan = CFM_RANDOM_VLAN; + } else { + s.ccm_vlan = atoi(cfm_ccm_vlan); + if (s.ccm_vlan == CFM_RANDOM_VLAN) { + s.ccm_vlan = 0; + } + } -/* Read carrier or miimon status directly from 'iface''s netdev, according to - * how 'iface''s port is configured. - * - * Returns true if 'iface' is up, false otherwise. */ -static bool -iface_get_carrier(const struct iface *iface) -{ - /* XXX */ - return netdev_get_carrier(iface->netdev); + extended_str = ovsrec_interface_get_other_config_value(iface->cfg, + "cfm_extended", + "false"); + s.extended = !strcasecmp("true", extended_str); + + opstate_str = ovsrec_interface_get_other_config_value(iface->cfg, + "cfm_opstate", + "up"); + s.opup = !strcasecmp("up", opstate_str); + + ofproto_port_set_cfm(iface->port->bridge->ofproto, iface->ofp_port, &s); } /* Returns true if 'iface' is synthetic, that is, if we constructed it locally @@ -2605,6 +3301,7 @@ iface_is_synthetic(const struct iface *iface) { return ovsdb_idl_row_is_synthetic(&iface->cfg->header_); } + /* Port mirroring. */ @@ -2647,7 +3344,8 @@ bridge_configure_mirrors(struct bridge *br) if (!m) { m = mirror_create(br, cfg); } - if (!mirror_configure(m, cfg)) { + m->cfg = cfg; + if (!mirror_configure(m)) { mirror_destroy(m); } } @@ -2713,8 +3411,9 @@ mirror_collect_ports(struct mirror *m, } static bool -mirror_configure(struct mirror *m, const struct ovsrec_mirror *cfg) +mirror_configure(struct mirror *m) { + const struct ovsrec_mirror *cfg = m->cfg; struct ofproto_mirror_settings s; /* Set name. */ @@ -2790,3 +3489,305 @@ mirror_configure(struct mirror *m, const struct ovsrec_mirror *cfg) return true; } + +/* Linux VLAN device support (e.g. "eth0.10" for VLAN 10.) + * + * This is deprecated. It is only for compatibility with broken device drivers + * in old versions of Linux that do not properly support VLANs when VLAN + * devices are not used. When broken device drivers are no longer in + * widespread use, we will delete these interfaces. */ + +static void **blocks; +static size_t n_blocks, allocated_blocks; + +/* Adds 'block' to a list of blocks that have to be freed with free() when the + * VLAN splinters are reconfigured. */ +static void +register_block(void *block) +{ + if (n_blocks >= allocated_blocks) { + blocks = x2nrealloc(blocks, &allocated_blocks, sizeof *blocks); + } + blocks[n_blocks++] = block; +} + +/* Frees all of the blocks registered with register_block(). */ +static void +free_registered_blocks(void) +{ + size_t i; + + for (i = 0; i < n_blocks; i++) { + free(blocks[i]); + } + n_blocks = 0; +} + +/* Returns true if VLAN splinters are enabled on 'iface_cfg', false + * otherwise. */ +static bool +vlan_splinters_is_enabled(const struct ovsrec_interface *iface_cfg) +{ + const char *value; + + value = ovsrec_interface_get_other_config_value(iface_cfg, + "enable-vlan-splinters", + ""); + return !strcmp(value, "true"); +} + +/* Figures out the set of VLANs that are in use for the purpose of VLAN + * splinters. + * + * If VLAN splinters are enabled on at least one interface and any VLANs are in + * use, returns a 4096-bit bitmap with a 1-bit for each in-use VLAN (bits 0 and + * 4095 will not be set). The caller is responsible for freeing the bitmap, + * with free(). + * + * If VLANs splinters are not enabled on any interface or if no VLANs are in + * use, returns NULL. + * + * Updates 'vlan_splinters_enabled_anywhere'. */ +static unsigned long int * +collect_splinter_vlans(const struct ovsrec_open_vswitch *ovs_cfg) +{ + unsigned long int *splinter_vlans; + struct sset splinter_ifaces; + const char *real_dev_name; + struct shash *real_devs; + struct shash_node *node; + struct bridge *br; + size_t i; + + /* Free space allocated for synthesized ports and interfaces, since we're + * in the process of reconstructing all of them. */ + free_registered_blocks(); + + splinter_vlans = bitmap_allocate(4096); + sset_init(&splinter_ifaces); + vlan_splinters_enabled_anywhere = false; + for (i = 0; i < ovs_cfg->n_bridges; i++) { + struct ovsrec_bridge *br_cfg = ovs_cfg->bridges[i]; + size_t j; + + for (j = 0; j < br_cfg->n_ports; j++) { + struct ovsrec_port *port_cfg = br_cfg->ports[j]; + int k; + + for (k = 0; k < port_cfg->n_interfaces; k++) { + struct ovsrec_interface *iface_cfg = port_cfg->interfaces[k]; + + if (vlan_splinters_is_enabled(iface_cfg)) { + vlan_splinters_enabled_anywhere = true; + sset_add(&splinter_ifaces, iface_cfg->name); + vlan_bitmap_from_array__(port_cfg->trunks, + port_cfg->n_trunks, + splinter_vlans); + } + } + + if (port_cfg->tag && *port_cfg->tag > 0 && *port_cfg->tag < 4095) { + bitmap_set1(splinter_vlans, *port_cfg->tag); + } + } + } + + if (!vlan_splinters_enabled_anywhere) { + free(splinter_vlans); + sset_destroy(&splinter_ifaces); + return NULL; + } + + HMAP_FOR_EACH (br, node, &all_bridges) { + if (br->ofproto) { + ofproto_get_vlan_usage(br->ofproto, splinter_vlans); + } + } + + /* Don't allow VLANs 0 or 4095 to be splintered. VLAN 0 should appear on + * the real device. VLAN 4095 is reserved and Linux doesn't allow a VLAN + * device to be created for it. */ + bitmap_set0(splinter_vlans, 0); + bitmap_set0(splinter_vlans, 4095); + + /* Delete all VLAN devices that we don't need. */ + vlandev_refresh(); + real_devs = vlandev_get_real_devs(); + SHASH_FOR_EACH (node, real_devs) { + const struct vlan_real_dev *real_dev = node->data; + const struct vlan_dev *vlan_dev; + bool real_dev_has_splinters; + + real_dev_has_splinters = sset_contains(&splinter_ifaces, + real_dev->name); + HMAP_FOR_EACH (vlan_dev, hmap_node, &real_dev->vlan_devs) { + if (!real_dev_has_splinters + || !bitmap_is_set(splinter_vlans, vlan_dev->vid)) { + struct netdev *netdev; + + if (!netdev_open(vlan_dev->name, "system", &netdev)) { + if (!netdev_get_in4(netdev, NULL, NULL) || + !netdev_get_in6(netdev, NULL)) { + vlandev_del(vlan_dev->name); + } else { + /* It has an IP address configured, so we don't own + * it. Don't delete it. */ + } + netdev_close(netdev); + } + } + + } + } + + /* Add all VLAN devices that we need. */ + SSET_FOR_EACH (real_dev_name, &splinter_ifaces) { + int vid; + + BITMAP_FOR_EACH_1 (vid, 4096, splinter_vlans) { + if (!vlandev_get_name(real_dev_name, vid)) { + vlandev_add(real_dev_name, vid); + } + } + } + + vlandev_refresh(); + + sset_destroy(&splinter_ifaces); + + if (bitmap_scan(splinter_vlans, 0, 4096) >= 4096) { + free(splinter_vlans); + return NULL; + } + return splinter_vlans; +} + +/* Pushes the configure of VLAN splinter port 'port' (e.g. eth0.9) down to + * ofproto. */ +static void +configure_splinter_port(struct port *port) +{ + struct ofproto *ofproto = port->bridge->ofproto; + uint16_t realdev_ofp_port; + const char *realdev_name; + struct iface *vlandev, *realdev; + + ofproto_bundle_unregister(port->bridge->ofproto, port); + + vlandev = CONTAINER_OF(list_front(&port->ifaces), struct iface, + port_elem); + + realdev_name = ovsrec_port_get_other_config_value(port->cfg, + "realdev", NULL); + realdev = iface_lookup(port->bridge, realdev_name); + realdev_ofp_port = realdev ? realdev->ofp_port : 0; + + ofproto_port_set_realdev(ofproto, vlandev->ofp_port, realdev_ofp_port, + *port->cfg->tag); +} + +static struct ovsrec_port * +synthesize_splinter_port(const char *real_dev_name, + const char *vlan_dev_name, int vid) +{ + struct ovsrec_interface *iface; + struct ovsrec_port *port; + + iface = xzalloc(sizeof *iface); + iface->name = xstrdup(vlan_dev_name); + iface->type = "system"; + + port = xzalloc(sizeof *port); + port->interfaces = xmemdup(&iface, sizeof iface); + port->n_interfaces = 1; + port->name = xstrdup(vlan_dev_name); + port->vlan_mode = "splinter"; + port->tag = xmalloc(sizeof *port->tag); + *port->tag = vid; + port->key_other_config = xmalloc(sizeof *port->key_other_config); + port->key_other_config[0] = "realdev"; + port->value_other_config = xmalloc(sizeof *port->value_other_config); + port->value_other_config[0] = xstrdup(real_dev_name); + port->n_other_config = 1; + + register_block(iface); + register_block(iface->name); + register_block(port); + register_block(port->interfaces); + register_block(port->name); + register_block(port->tag); + register_block(port->key_other_config); + register_block(port->value_other_config); + register_block(port->value_other_config[0]); + + return port; +} + +/* For each interface with 'br' that has VLAN splinters enabled, adds a + * corresponding ovsrec_port to 'ports' for each splinter VLAN marked with a + * 1-bit in the 'splinter_vlans' bitmap. */ +static void +add_vlan_splinter_ports(struct bridge *br, + const unsigned long int *splinter_vlans, + struct shash *ports) +{ + size_t i; + + /* We iterate through 'br->cfg->ports' instead of 'ports' here because + * we're modifying 'ports'. */ + for (i = 0; i < br->cfg->n_ports; i++) { + const char *name = br->cfg->ports[i]->name; + struct ovsrec_port *port_cfg = shash_find_data(ports, name); + size_t j; + + for (j = 0; j < port_cfg->n_interfaces; j++) { + struct ovsrec_interface *iface_cfg = port_cfg->interfaces[j]; + + if (vlan_splinters_is_enabled(iface_cfg)) { + const char *real_dev_name; + uint16_t vid; + + real_dev_name = iface_cfg->name; + BITMAP_FOR_EACH_1 (vid, 4096, splinter_vlans) { + const char *vlan_dev_name; + + vlan_dev_name = vlandev_get_name(real_dev_name, vid); + if (vlan_dev_name + && !shash_find(ports, vlan_dev_name)) { + shash_add(ports, vlan_dev_name, + synthesize_splinter_port( + real_dev_name, vlan_dev_name, vid)); + } + } + } + } + } +} + +static void +mirror_refresh_stats(struct mirror *m) +{ + struct ofproto *ofproto = m->bridge->ofproto; + uint64_t tx_packets, tx_bytes; + char *keys[2]; + int64_t values[2]; + size_t stat_cnt = 0; + + if (ofproto_mirror_get_stats(ofproto, m, &tx_packets, &tx_bytes)) { + ovsrec_mirror_set_statistics(m->cfg, NULL, NULL, 0); + return; + } + + if (tx_packets != UINT64_MAX) { + keys[stat_cnt] = "tx_packets"; + values[stat_cnt] = tx_packets; + stat_cnt++; + } + if (tx_bytes != UINT64_MAX) { + keys[stat_cnt] = "tx_bytes"; + values[stat_cnt] = tx_bytes; + stat_cnt++; + } + + ovsrec_mirror_set_statistics(m->cfg, keys, values, stat_cnt); +}