-/* 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.
#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 "netdev.h"
#include "ofp-print.h"
#include "ofpbuf.h"
#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 "vlandev.h"
#include "vswitchd/vswitch-idl.h"
#include "xenserver.h"
#include "vlog.h"
struct hmap_node hmap_node; /* In struct bridge's "mirrors" hmap. */
struct bridge *bridge;
char *name;
+ const struct ovsrec_mirror *cfg;
};
struct port {
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_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_remotes(struct bridge *,
const struct sockaddr_in *managers,
size_t n_managers);
static uint64_t bridge_pick_datapath_id(struct bridge *,
const uint8_t bridge_ea[ETH_ADDR_LEN],
struct iface *hw_addr_iface);
+static const char *bridge_get_other_config(const struct ovsrec_bridge *,
+ const char *key);
+static const char *get_port_other_config(const struct ovsrec_port *,
+ const char *key,
+ const char *default_value);
static uint64_t dpid_from_hash(const void *, size_t nbytes);
static bool bridge_has_bond_fake_iface(const struct bridge *,
const char *name);
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,
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 const char *get_interface_other_config(const struct ovsrec_interface *,
+ const char *key,
+ const char *default_value);
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);
\f
/* Public functions. */
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);
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_remote_mpids);
+ 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);
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);
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();
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++;
}
}
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;
* 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.
*
* 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) {
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;
}
}
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);
}
free(managers);
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;
/* 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", get_port_other_config(
+ cfg, "priority-tags", ""));
+
/* Get LACP settings. */
s.lacp = port_configure_lacp(port, &lacp_settings);
if (s.lacp) {
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 = get_port_other_config(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 = get_port_other_config(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 = get_port_other_config(port->cfg, "stp-path-cost", NULL);
+ if (config_str) {
+ port_s->path_cost = strtoul(config_str, NULL, 10);
+ } else {
+ uint32_t 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 = get_port_other_config(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 = bridge_get_other_config(br->cfg, "stp-system-id");
+ 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 = bridge_get_other_config(br->cfg, "stp-priority");
+ if (config_str) {
+ br_s.priority = strtoul(config_str, NULL, 0);
+ } else {
+ br_s.priority = STP_DEFAULT_BRIDGE_PRIORITY;
+ }
+
+ config_str = bridge_get_other_config(br->cfg, "stp-hello-time");
+ if (config_str) {
+ br_s.hello_time = strtoul(config_str, NULL, 10) * 1000;
+ } else {
+ br_s.hello_time = STP_DEFAULT_HELLO_TIME;
+ }
+
+ config_str = bridge_get_other_config(br->cfg, "stp-max-age");
+ if (config_str) {
+ br_s.max_age = strtoul(config_str, NULL, 10) * 1000;
+ } else {
+ br_s.max_age = STP_DEFAULT_MAX_AGE;
+ }
+
+ config_str = bridge_get_other_config(br->cfg, "stp-forward-delay");
+ 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)
{
/* 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);
}
}
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;
}
/* 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);
}
}
}
static const char *
-get_ovsrec_key_value(const struct ovsdb_idl_row *row,
- const struct ovsdb_idl_column *column,
- const char *key)
+get_ovsrec_key_value(char **keys, char **values, size_t n, const char *key)
{
- const struct ovsdb_datum *datum;
- union ovsdb_atom atom;
- unsigned int idx;
+ size_t i;
- 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;
+ for (i = 0; i < n; i++) {
+ if (!strcmp(keys[i], key)) {
+ return values[i];
+ }
+ }
+ return NULL;
}
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);
+ return get_ovsrec_key_value(br_cfg->key_other_config,
+ br_cfg->value_other_config,
+ br_cfg->n_other_config, key);
}
/* Set Flow eviction threshold */
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 = bridge_get_other_config(br->cfg, "mac-aging-time");
+ 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;
}
}
+ /* 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. */
HMAP_FOR_EACH (port, hmap_node, &br->ports) {
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;
}
!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;
VLOG_WARN("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
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
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);
}
}
}
-/* 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;
-
- fault = ofproto_port_get_cfm_fault(iface->port->bridge->ofproto,
- iface->ofp_port);
+ int fault, error;
+ const uint64_t *rmps;
+ size_t n_rmps;
- if (fault < 0) {
- return false;
+ if (iface_is_synthetic(iface)) {
+ return;
}
- if (cfg->n_cfm_fault != 1 || cfg->cfm_fault[0] != fault) {
+ fault = ofproto_port_get_cfm_fault(iface->port->bridge->ofproto,
+ iface->ofp_port);
+ if (fault >= 0) {
bool fault_bool = fault;
ovsrec_interface_set_cfm_fault(cfg, &fault_bool, 1);
- changed = true;
+ } else {
+ ovsrec_interface_set_cfm_fault(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);
-
- if (old != new) {
- bool current = new;
- ovsrec_interface_set_lacp_current(iface->cfg, ¤t, new >= 0);
+ 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);
}
- return old != new;
}
static void
#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 = get_ovsrec_key_value(cfg->key_other_config,
+ cfg->value_other_config,
+ cfg->n_other_config,
"enable-statistics");
if (enable) {
return !strcmp(enable, "true");
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 vlan_splinters_changed;
bool database_changed;
struct bridge *br;
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,
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 (database_changed || vlan_splinters_changed) {
if (cfg) {
struct ovsdb_idl_txn *txn = ovsdb_idl_txn_create(idl);
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;
iface_refresh_status(iface);
}
}
+
+ HMAP_FOR_EACH (m, hmap_node, &br->mirrors) {
+ mirror_refresh_stats(m);
+ }
+
}
refresh_system_stats(cfg);
refresh_controller_status();
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
}
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);
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");
return;
/* 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");
return;
* 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");
return;
/* 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;
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) {
}
}
+/* 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)
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);
{
const char *value;
- value = get_ovsrec_key_value(&port->header_, &ovsrec_port_col_other_config,
- key);
+ value = get_ovsrec_key_value(port->key_other_config,
+ port->value_other_config,
+ port->n_other_config, key);
return value ? value : default_value;
}
{
const char *value;
- value = get_ovsrec_key_value(&iface->header_,
- &ovsrec_interface_col_other_config, key);
+ value = get_ovsrec_key_value(iface->key_other_config,
+ iface->value_other_config,
+ iface->n_other_config, key);
return value ? value : default_value;
}
&& !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);
}
}
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;
}
s->name = port->name;
- memcpy(s->id, port->bridge->ea, ETH_ADDR_LEN);
+
+ system_id = get_port_other_config(port->cfg, "lacp-system-id", NULL);
+ if (!system_id
+ || sscanf(system_id, ETH_ADDR_SCAN_FMT,
+ ETH_ADDR_SCAN_ARGS(s->id)) != ETH_ADDR_SCAN_COUNT) {
+ 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",
"lacp-heartbeat",
"false"), "true");
-
lacp_time = get_port_other_config(port->cfg, "lacp-time", "slow");
custom_time = atoi(lacp_time);
if (!strcmp(lacp_time, "fast")) {
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));
+ 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.4.*, change the default bond_mode to
+ * active-backup. Until then, warn that the change is imminent. */
+ VLOG_WARN_RL(&rl, "port %s: Using the default bond_mode %s. Note that"
+ " in future versions, the default bond_mode is expected"
+ " to change to active-backup", 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, "
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_);
+}
\f
/* Interface functions. */
}
}
+/* 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_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,
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 {
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);
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.",
+ "queue (queue 0). Using default configuration.",
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;
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.ccm_vlan = atoi(get_interface_other_config(iface->cfg, "cfm_ccm_vlan",
+ "0"));
if (s.interval <= 0) {
s.interval = 1000;
}
- ofproto_port_set_cfm(iface->port->bridge->ofproto, iface->ofp_port, &s);
-}
+ extended_str = get_interface_other_config(iface->cfg, "cfm_extended",
+ "false");
+ s.extended = !strcasecmp("true", extended_str);
-/* 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);
+ opstate_str = get_interface_other_config(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
if (!m) {
m = mirror_create(br, cfg);
}
- if (!mirror_configure(m, cfg)) {
+ m->cfg = cfg;
+ if (!mirror_configure(m)) {
mirror_destroy(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. */
return true;
}
+\f
+/* 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 = get_interface_other_config(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 = get_port_other_config(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);
+}
git://git.onelab.eu / sliver-openvswitch.git / blobdiff