#include <arpa/inet.h>
#include <ctype.h>
#include <inttypes.h>
+#include <sys/socket.h>
#include <net/if.h>
#include <openflow/openflow.h>
#include <signal.h>
#include "dynamic-string.h"
#include "flow.h"
#include "hash.h"
+#include "jsonrpc.h"
#include "list.h"
#include "mac-learning.h"
#include "netdev.h"
struct bridge *bridge;
size_t port_idx;
int vlan; /* -1=trunk port, else a 12-bit VLAN ID. */
- unsigned long *trunks; /* Bitmap of trunked VLANs, if 'vlan' == -1. */
+ unsigned long *trunks; /* Bitmap of trunked VLANs, if 'vlan' == -1.
+ * NULL if all VLANs are trunked. */
char *name;
/* An ordinary bridge port has 1 interface.
int updelay, downdelay; /* Delay before iface goes up/down, in ms. */
bool bond_compat_is_stale; /* Need to call port_update_bond_compat()? */
bool bond_fake_iface; /* Fake a bond interface for legacy compat? */
+ long bond_next_fake_iface_update; /* Next update to fake bond stats. */
int bond_rebalance_interval; /* Interval between rebalances, in ms. */
long long int bond_next_rebalance; /* Next rebalancing time. */
bool sent_config_request; /* Successfully sent config request? */
uint8_t default_ea[ETH_ADDR_LEN]; /* Default MAC. */
- /* Support for remote controllers. */
- char *controller; /* NULL if there is no remote controller;
- * "discover" to do controller discovery;
- * otherwise a vconn name. */
-
/* OpenFlow switch processing. */
struct ofproto *ofproto; /* OpenFlow switch. */
/* Bridge ports. */
struct port **ports;
size_t n_ports, allocated_ports;
+ struct shash iface_by_name; /* "struct iface"s indexed by name. */
+ struct shash port_by_name; /* "struct port"s indexed by name. */
/* Bonding. */
bool has_bonded_ports;
static struct bridge *bridge_lookup(const char *name);
static unixctl_cb_func bridge_unixctl_dump_flows;
static int bridge_run_one(struct bridge *);
-static const struct ovsrec_controller *bridge_get_controller(
- const struct ovsrec_open_vswitch *ovs_cfg,
- const struct bridge *br);
+static size_t bridge_get_controllers(const struct ovsrec_open_vswitch *ovs_cfg,
+ const struct bridge *br,
+ struct ovsrec_controller ***controllersp);
static void bridge_reconfigure_one(const struct ovsrec_open_vswitch *,
struct bridge *);
-static void bridge_reconfigure_controller(const struct ovsrec_open_vswitch *,
- struct bridge *);
+static void bridge_reconfigure_remotes(const struct ovsrec_open_vswitch *,
+ struct bridge *,
+ const struct sockaddr_in *managers,
+ size_t n_managers);
static void bridge_get_all_ifaces(const struct bridge *, struct shash *ifaces);
static void bridge_fetch_dp_ifaces(struct bridge *);
static void bridge_flush(struct bridge *);
static struct port *port_create(struct bridge *, const char *name);
static void port_reconfigure(struct port *, const struct ovsrec_port *);
+static void port_del_ifaces(struct port *, const struct ovsrec_port *);
static void port_destroy(struct port *);
static struct port *port_lookup(const struct bridge *, const char *name);
static struct iface *port_lookup_iface(const struct port *, const char *name);
}
netdev_options.args = &options;
netdev_options.ethertype = NETDEV_ETH_TYPE_NONE;
- netdev_options.may_create = true;
- if (iface_is_internal(iface->port->bridge, iface_cfg->name)) {
- netdev_options.may_open = true;
- }
error = netdev_open(&netdev_options, &iface->netdev);
}
}
+/* Looks at the list of managers in 'ovs_cfg' and extracts their remote IP
+ * addresses and ports into '*managersp' and '*n_managersp'. The caller is
+ * responsible for freeing '*managersp' (with free()).
+ *
+ * You may be asking yourself "why does ovs-vswitchd care?", because
+ * ovsdb-server is responsible for connecting to the managers, and ovs-vswitchd
+ * should not be and in fact is not directly involved in that. But
+ * ovs-vswitchd needs to make sure that ovsdb-server can reach the managers, so
+ * it has to tell in-band control where the managers are to enable that.
+ */
+static void
+collect_managers(const struct ovsrec_open_vswitch *ovs_cfg,
+ struct sockaddr_in **managersp, size_t *n_managersp)
+{
+ struct sockaddr_in *managers = NULL;
+ size_t n_managers = 0;
+
+ if (ovs_cfg->n_managers > 0) {
+ size_t i;
+
+ managers = xmalloc(ovs_cfg->n_managers * sizeof *managers);
+ for (i = 0; i < ovs_cfg->n_managers; i++) {
+ const char *name = ovs_cfg->managers[i];
+ struct sockaddr_in *sin = &managers[i];
+
+ if ((!strncmp(name, "tcp:", 4)
+ && inet_parse_active(name + 4, JSONRPC_TCP_PORT, sin)) ||
+ (!strncmp(name, "ssl:", 4)
+ && inet_parse_active(name + 4, JSONRPC_SSL_PORT, sin))) {
+ n_managers++;
+ }
+ }
+ }
+
+ *managersp = managers;
+ *n_managersp = n_managers;
+}
+
void
bridge_reconfigure(const struct ovsrec_open_vswitch *ovs_cfg)
{
struct shash old_br, new_br;
struct shash_node *node;
struct bridge *br, *next;
+ struct sockaddr_in *managers;
+ size_t n_managers;
size_t i;
int sflow_bridge_number;
txn = ovsdb_idl_txn_create(ovs_cfg->header_.table->idl);
+ collect_managers(ovs_cfg, &managers, &n_managers);
+
/* Collect old and new bridges. */
shash_init(&old_br);
shash_init(&new_br);
/* Set sFlow configuration on this bridge. */
if (br->cfg->sflow) {
const struct ovsrec_sflow *sflow_cfg = br->cfg->sflow;
- const struct ovsrec_controller *ctrl;
+ struct ovsrec_controller **controllers;
struct ofproto_sflow_options oso;
+ size_t n_controllers;
+ size_t i;
memset(&oso, 0, sizeof oso);
oso.sub_id = sflow_bridge_number++;
oso.agent_device = sflow_cfg->agent;
- ctrl = bridge_get_controller(ovs_cfg, br);
- oso.control_ip = ctrl ? ctrl->local_ip : NULL;
+ oso.control_ip = NULL;
+ n_controllers = bridge_get_controllers(ovs_cfg, br, &controllers);
+ for (i = 0; i < n_controllers; i++) {
+ if (controllers[i]->local_ip) {
+ oso.control_ip = controllers[i]->local_ip;
+ break;
+ }
+ }
ofproto_set_sflow(br->ofproto, &oso);
- svec_destroy(&oso.targets);
+ /* Do not destroy oso.targets because it is owned by sflow_cfg. */
} else {
ofproto_set_sflow(br->ofproto, NULL);
}
* yet; when a controller is configured, resetting the datapath ID will
* immediately disconnect from the controller, so it's better to set
* the datapath ID before the controller. */
- bridge_reconfigure_controller(ovs_cfg, br);
+ bridge_reconfigure_remotes(ovs_cfg, br, managers, n_managers);
}
LIST_FOR_EACH (br, struct bridge, node, &all_bridges) {
for (i = 0; i < br->n_ports; i++) {
ovsdb_idl_txn_commit(txn);
ovsdb_idl_txn_destroy(txn); /* XXX */
+
+ free(managers);
}
static const char *
LIST_FOR_EACH (br, struct bridge, node, &all_bridges) {
ofproto_wait(br->ofproto);
- if (br->controller) {
+ if (ofproto_has_controller(br->ofproto)) {
continue;
}
port_array_init(&br->ifaces);
+ shash_init(&br->port_by_name);
+ shash_init(&br->iface_by_name);
+
br->flush = false;
list_push_back(&all_bridges, &br->node);
}
dpif_close(br->dpif);
ofproto_destroy(br->ofproto);
- free(br->controller);
mac_learning_destroy(br->ml);
port_array_destroy(&br->ifaces);
+ shash_destroy(&br->port_by_name);
+ shash_destroy(&br->iface_by_name);
free(br->ports);
free(br->name);
free(br);
return error;
}
-static const struct ovsrec_controller *
-bridge_get_controller(const struct ovsrec_open_vswitch *ovs_cfg,
- const struct bridge *br)
+static size_t
+bridge_get_controllers(const struct ovsrec_open_vswitch *ovs_cfg,
+ const struct bridge *br,
+ struct ovsrec_controller ***controllersp)
{
- const struct ovsrec_controller *controller;
-
- controller = (br->cfg->controller ? br->cfg->controller
- : ovs_cfg->controller ? ovs_cfg->controller
- : NULL);
+ struct ovsrec_controller **controllers;
+ size_t n_controllers;
- if (controller && !strcmp(controller->target, "none")) {
- return NULL;
+ if (br->cfg->n_controller) {
+ controllers = br->cfg->controller;
+ n_controllers = br->cfg->n_controller;
+ } else {
+ controllers = ovs_cfg->controller;
+ n_controllers = ovs_cfg->n_controller;
}
- return controller;
-}
+ if (n_controllers == 1 && !strcmp(controllers[0]->target, "none")) {
+ controllers = NULL;
+ n_controllers = 0;
+ }
-static bool
-check_duplicate_ifaces(struct bridge *br, struct iface *iface, void *ifaces_)
-{
- struct svec *ifaces = ifaces_;
- if (!svec_contains(ifaces, iface->name)) {
- svec_add(ifaces, iface->name);
- svec_sort(ifaces);
- return true;
- } else {
- VLOG_ERR("bridge %s: %s interface is on multiple ports, "
- "removing from %s",
- br->name, iface->name, iface->port->name);
- return false;
+ if (controllersp) {
+ *controllersp = controllers;
}
+ return n_controllers;
}
static void
struct bridge *br)
{
struct shash old_ports, new_ports;
- struct svec ifaces;
struct svec listeners, old_listeners;
struct svec snoops, old_snoops;
struct shash_node *node;
* user didn't specify one.
*
* XXX perhaps we should synthesize a port ourselves in this case. */
- if (bridge_get_controller(ovs_cfg, br)) {
+ if (bridge_get_controllers(ovs_cfg, br, NULL)) {
char local_name[IF_NAMESIZE];
int error;
}
}
- /* Get rid of deleted ports and add new ports. */
+ /* Get rid of deleted ports.
+ * Get rid of deleted interfaces on ports that still exist. */
SHASH_FOR_EACH (node, &old_ports) {
- if (!shash_find(&new_ports, node->name)) {
- port_destroy(node->data);
+ struct port *port = node->data;
+ const struct ovsrec_port *port_cfg;
+
+ port_cfg = shash_find_data(&new_ports, node->name);
+ if (!port_cfg) {
+ port_destroy(port);
+ } else {
+ port_del_ifaces(port, port_cfg);
}
}
+
+ /* Create new ports.
+ * Add new interfaces to existing ports.
+ * Reconfigure existing ports. */
SHASH_FOR_EACH (node, &new_ports) {
struct port *port = shash_find_data(&old_ports, node->name);
if (!port) {
port = port_create(br, node->name);
}
+
port_reconfigure(port, node->data);
+ if (!port->n_ifaces) {
+ VLOG_WARN("bridge %s: port %s has no interfaces, dropping",
+ br->name, port->name);
+ port_destroy(port);
+ }
}
shash_destroy(&old_ports);
shash_destroy(&new_ports);
- /* Check and delete duplicate interfaces. */
- svec_init(&ifaces);
- iterate_and_prune_ifaces(br, check_duplicate_ifaces, &ifaces);
- svec_destroy(&ifaces);
-
/* Delete all flows if we're switching from connected to standalone or vice
* versa. (XXX Should we delete all flows if we are switching from one
* controller to another?) */
}
static void
-bridge_reconfigure_controller(const struct ovsrec_open_vswitch *ovs_cfg,
- struct bridge *br)
+bridge_reconfigure_remotes(const struct ovsrec_open_vswitch *ovs_cfg,
+ struct bridge *br,
+ const struct sockaddr_in *managers,
+ size_t n_managers)
{
- const struct ovsrec_controller *c;
+ struct ovsrec_controller **controllers;
+ size_t n_controllers;
+
+ ofproto_set_extra_in_band_remotes(br->ofproto, managers, n_managers);
- c = bridge_get_controller(ovs_cfg, br);
- if ((br->controller != NULL) != (c != NULL)) {
+ n_controllers = bridge_get_controllers(ovs_cfg, br, &controllers);
+ if (ofproto_has_controller(br->ofproto) != (n_controllers != 0)) {
ofproto_flush_flows(br->ofproto);
}
- free(br->controller);
- br->controller = c ? xstrdup(c->target) : NULL;
-
- if (c) {
- int max_backoff, probe;
- int rate_limit, burst_limit;
- if (!strcmp(c->target, "discover")) {
- ofproto_set_discovery(br->ofproto, true,
- c->discover_accept_regex,
- c->discover_update_resolv_conf);
- } else {
- struct iface *local_iface;
- struct in_addr ip;
- bool in_band;
-
- in_band = (!c->connection_mode
- || !strcmp(c->connection_mode, "out-of-band"));
- ofproto_set_discovery(br->ofproto, false, NULL, NULL);
- ofproto_set_in_band(br->ofproto, in_band);
-
- local_iface = bridge_get_local_iface(br);
- if (local_iface && c->local_ip && inet_aton(c->local_ip, &ip)) {
- struct netdev *netdev = local_iface->netdev;
- struct in_addr mask, gateway;
-
- if (!c->local_netmask || !inet_aton(c->local_netmask, &mask)) {
- mask.s_addr = 0;
- }
- if (!c->local_gateway
- || !inet_aton(c->local_gateway, &gateway)) {
- gateway.s_addr = 0;
- }
-
- netdev_turn_flags_on(netdev, NETDEV_UP, true);
- if (!mask.s_addr) {
- mask.s_addr = guess_netmask(ip.s_addr);
- }
- if (!netdev_set_in4(netdev, ip, mask)) {
- VLOG_INFO("bridge %s: configured IP address "IP_FMT", "
- "netmask "IP_FMT,
- br->name, IP_ARGS(&ip.s_addr),
- IP_ARGS(&mask.s_addr));
- }
-
- if (gateway.s_addr) {
- if (!netdev_add_router(netdev, gateway)) {
- VLOG_INFO("bridge %s: configured gateway "IP_FMT,
- br->name, IP_ARGS(&gateway.s_addr));
- }
- }
- }
- }
-
- ofproto_set_failure(br->ofproto,
- (!c->fail_mode
- || !strcmp(c->fail_mode, "standalone")
- || !strcmp(c->fail_mode, "open")));
-
- probe = c->inactivity_probe ? *c->inactivity_probe / 1000 : 5;
- ofproto_set_probe_interval(br->ofproto, probe);
-
- max_backoff = c->max_backoff ? *c->max_backoff / 1000 : 8;
- ofproto_set_max_backoff(br->ofproto, max_backoff);
-
- rate_limit = c->controller_rate_limit ? *c->controller_rate_limit : 0;
- burst_limit = c->controller_burst_limit ? *c->controller_burst_limit : 0;
- ofproto_set_rate_limit(br->ofproto, rate_limit, burst_limit);
- } else {
+ if (!n_controllers) {
union ofp_action action;
flow_t flow;
+ /* Clear out controllers. */
+ ofproto_set_controllers(br->ofproto, NULL, 0);
+
/* Set up a flow that matches every packet and directs them to
* OFPP_NORMAL (which goes to us). */
memset(&action, 0, sizeof action);
action.output.port = htons(OFPP_NORMAL);
memset(&flow, 0, sizeof flow);
ofproto_add_flow(br->ofproto, &flow, OVSFW_ALL, 0, &action, 1, 0);
+ } else {
+ struct ofproto_controller *ocs;
+ size_t i;
- ofproto_set_in_band(br->ofproto, false);
- ofproto_set_max_backoff(br->ofproto, 1);
- ofproto_set_probe_interval(br->ofproto, 5);
- ofproto_set_failure(br->ofproto, false);
- }
+ ocs = xmalloc(n_controllers * sizeof *ocs);
+ for (i = 0; i < n_controllers; i++) {
+ struct ovsrec_controller *c = controllers[i];
+ struct ofproto_controller *oc = &ocs[i];
+
+ if (strcmp(c->target, "discover")) {
+ struct iface *local_iface;
+ struct in_addr ip;
+
+ local_iface = bridge_get_local_iface(br);
+ if (local_iface && c->local_ip
+ && inet_aton(c->local_ip, &ip)) {
+ struct netdev *netdev = local_iface->netdev;
+ struct in_addr mask, gateway;
+
+ if (!c->local_netmask
+ || !inet_aton(c->local_netmask, &mask)) {
+ mask.s_addr = 0;
+ }
+ if (!c->local_gateway
+ || !inet_aton(c->local_gateway, &gateway)) {
+ gateway.s_addr = 0;
+ }
+
+ netdev_turn_flags_on(netdev, NETDEV_UP, true);
+ if (!mask.s_addr) {
+ mask.s_addr = guess_netmask(ip.s_addr);
+ }
+ if (!netdev_set_in4(netdev, ip, mask)) {
+ VLOG_INFO("bridge %s: configured IP address "IP_FMT", "
+ "netmask "IP_FMT,
+ br->name, IP_ARGS(&ip.s_addr),
+ IP_ARGS(&mask.s_addr));
+ }
+
+ if (gateway.s_addr) {
+ if (!netdev_add_router(netdev, gateway)) {
+ VLOG_INFO("bridge %s: configured gateway "IP_FMT,
+ br->name, IP_ARGS(&gateway.s_addr));
+ }
+ }
+ }
+ }
- ofproto_set_controller(br->ofproto, br->controller);
+ 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);
+ oc->fail = (!c->fail_mode
+ || !strcmp(c->fail_mode, "standalone")
+ || !strcmp(c->fail_mode, "open")
+ ? OFPROTO_FAIL_STANDALONE
+ : OFPROTO_FAIL_SECURE);
+ oc->band = (!c->connection_mode
+ || !strcmp(c->connection_mode, "in-band")
+ ? OFPROTO_IN_BAND
+ : OFPROTO_OUT_OF_BAND);
+ oc->accept_re = c->discover_accept_regex;
+ oc->update_resolv_conf = c->discover_update_resolv_conf;
+ oc->rate_limit = (c->controller_rate_limit
+ ? *c->controller_rate_limit : 0);
+ oc->burst_limit = (c->controller_burst_limit
+ ? *c->controller_burst_limit : 0);
+ }
+ ofproto_set_controllers(br->ofproto, ocs, n_controllers);
+ free(ocs);
+ }
}
static void
port->bond_compat_is_stale = true;
}
+/* Attempts to make the sum of the bond slaves' statistics appear on the fake
+ * bond interface. */
+static void
+bond_update_fake_iface_stats(struct port *port)
+{
+ struct netdev_stats bond_stats;
+ struct netdev *bond_dev;
+ size_t i;
+
+ memset(&bond_stats, 0, sizeof bond_stats);
+
+ for (i = 0; i < port->n_ifaces; i++) {
+ struct netdev_stats slave_stats;
+
+ if (!netdev_get_stats(port->ifaces[i]->netdev, &slave_stats)) {
+ bond_stats.rx_packets += slave_stats.rx_packets;
+ bond_stats.rx_bytes += slave_stats.rx_bytes;
+ bond_stats.tx_packets += slave_stats.tx_packets;
+ bond_stats.tx_bytes += slave_stats.tx_bytes;
+ }
+ }
+
+ if (!netdev_open_default(port->name, &bond_dev)) {
+ netdev_set_stats(bond_dev, &bond_stats);
+ netdev_close(bond_dev);
+ }
+}
+
static void
bond_run(struct bridge *br)
{
bond_enable_slave(iface, !iface->enabled);
}
}
+
+ if (port->bond_fake_iface
+ && time_msec() >= port->bond_next_fake_iface_update) {
+ bond_update_fake_iface_stats(port);
+ port->bond_next_fake_iface_update = time_msec() + 1000;
+ }
}
if (port->bond_compat_is_stale) {
for (j = 0; j < port->n_ifaces; j++) {
struct iface *iface = port->ifaces[j];
if (iface->delay_expires != LLONG_MAX) {
- poll_timer_wait(iface->delay_expires - time_msec());
+ poll_timer_wait_until(iface->delay_expires);
}
}
+ if (port->bond_fake_iface) {
+ poll_timer_wait_until(port->bond_next_fake_iface_update);
+ }
}
}
static bool
port_trunks_vlan(const struct port *port, uint16_t vlan)
{
- return port->vlan < 0 && bitmap_is_set(port->trunks, vlan);
+ return (port->vlan < 0
+ && (!port->trunks || bitmap_is_set(port->trunks, vlan)));
}
static bool
}
}
+/* A VM broadcasts a gratuitous ARP to indicate that it has resumed after
+ * migration. Older Citrix-patched Linux DomU used gratuitous ARP replies to
+ * indicate this; newer upstream kernels use gratuitous ARP requests. */
static bool
-is_bcast_arp_reply(const flow_t *flow)
+is_gratuitous_arp(const flow_t *flow)
{
return (flow->dl_type == htons(ETH_TYPE_ARP)
- && flow->nw_proto == ARP_OP_REPLY
- && eth_addr_is_broadcast(flow->dl_dst));
+ && eth_addr_is_broadcast(flow->dl_dst)
+ && (flow->nw_proto == ARP_OP_REPLY
+ || (flow->nw_proto == ARP_OP_REQUEST
+ && flow->nw_src == flow->nw_dst)));
}
/* Determines whether packets in 'flow' within 'br' should be forwarded or
/* Drop all packets for which we have learned a different input
* port, because we probably sent the packet on one slave and got
- * it back on the other. Broadcast ARP replies are an exception
+ * it back on the other. Gratuitous ARP packets are an exception
* to this rule: the host has moved to another switch. */
src_idx = mac_learning_lookup(br->ml, flow->dl_src, vlan);
if (src_idx != -1 && src_idx != in_port->port_idx &&
- !is_bcast_arp_reply(flow)) {
+ !is_gratuitous_arp(flow)) {
return false;
}
}
sizeof *br->ports);
}
br->ports[br->n_ports++] = port;
+ shash_add_assert(&br->port_by_name, port->name, port);
VLOG_INFO("created port %s on bridge %s", port->name, br->name);
bridge_flush(br);
return value ? value : default_value;
}
+static void
+port_del_ifaces(struct port *port, const struct ovsrec_port *cfg)
+{
+ struct shash new_ifaces;
+ size_t i;
+
+ /* Collect list of new interfaces. */
+ shash_init(&new_ifaces);
+ for (i = 0; i < cfg->n_interfaces; i++) {
+ const char *name = cfg->interfaces[i]->name;
+ shash_add_once(&new_ifaces, name, NULL);
+ }
+
+ /* Get rid of deleted interfaces. */
+ for (i = 0; i < port->n_ifaces; ) {
+ if (!shash_find(&new_ifaces, cfg->interfaces[i]->name)) {
+ iface_destroy(port->ifaces[i]);
+ } else {
+ i++;
+ }
+ }
+
+ shash_destroy(&new_ifaces);
+}
+
static void
port_reconfigure(struct port *port, const struct ovsrec_port *cfg)
{
- struct shash old_ifaces, new_ifaces;
+ struct shash new_ifaces;
long long int next_rebalance;
- struct shash_node *node;
unsigned long *trunks;
int vlan;
size_t i;
port->cfg = cfg;
- /* Collect old and new interfaces. */
- shash_init(&old_ifaces);
- shash_init(&new_ifaces);
- for (i = 0; i < port->n_ifaces; i++) {
- shash_add(&old_ifaces, port->ifaces[i]->name, port->ifaces[i]);
- }
- for (i = 0; i < cfg->n_interfaces; i++) {
- const char *name = cfg->interfaces[i]->name;
- if (!shash_add_once(&new_ifaces, name, cfg->interfaces[i])) {
- VLOG_WARN("port %s: %s specified twice as port interface",
- port->name, name);
- }
- }
+ /* Update settings. */
port->updelay = cfg->bond_updelay;
if (port->updelay < 0) {
port->updelay = 0;
port->bond_next_rebalance = next_rebalance;
}
- /* Get rid of deleted interfaces and add new interfaces. */
- SHASH_FOR_EACH (node, &old_ifaces) {
- if (!shash_find(&new_ifaces, node->name)) {
- iface_destroy(node->data);
- }
- }
- SHASH_FOR_EACH (node, &new_ifaces) {
- const struct ovsrec_interface *if_cfg = node->data;
+ /* Add new interfaces and update 'cfg' member of existing ones. */
+ shash_init(&new_ifaces);
+ for (i = 0; i < cfg->n_interfaces; i++) {
+ const struct ovsrec_interface *if_cfg = cfg->interfaces[i];
struct iface *iface;
- iface = shash_find_data(&old_ifaces, if_cfg->name);
- if (!iface) {
- iface_create(port, if_cfg);
- } else {
+ if (!shash_add_once(&new_ifaces, if_cfg->name, NULL)) {
+ VLOG_WARN("port %s: %s specified twice as port interface",
+ port->name, if_cfg->name);
+ continue;
+ }
+
+ iface = iface_lookup(port->bridge, if_cfg->name);
+ if (iface) {
+ if (iface->port != port) {
+ VLOG_ERR("bridge %s: %s interface is on multiple ports, "
+ "removing from %s",
+ port->bridge->name, if_cfg->name, iface->port->name);
+ continue;
+ }
iface->cfg = if_cfg;
+ } else {
+ iface_create(port, if_cfg);
}
}
+ shash_destroy(&new_ifaces);
/* Get VLAN tag. */
vlan = -1;
/* Get trunked VLANs. */
trunks = NULL;
- if (vlan < 0) {
+ if (vlan < 0 && cfg->n_trunks) {
size_t n_errors;
size_t i;
port->name, cfg->n_trunks);
}
if (n_errors == cfg->n_trunks) {
- if (n_errors) {
- VLOG_ERR("port %s: no valid trunks, trunking all VLANs",
- port->name);
- }
- bitmap_set_multiple(trunks, 0, 4096, 1);
- }
- } else {
- if (cfg->n_trunks) {
- VLOG_ERR("port %s: ignoring trunks in favor of implicit vlan",
+ VLOG_ERR("port %s: no valid trunks, trunking all VLANs",
port->name);
+ bitmap_free(trunks);
+ trunks = NULL;
}
+ } else if (vlan >= 0 && cfg->n_trunks) {
+ VLOG_ERR("port %s: ignoring trunks in favor of implicit vlan",
+ port->name);
}
if (trunks == NULL
? port->trunks != NULL
}
bitmap_free(port->trunks);
port->trunks = trunks;
-
- shash_destroy(&old_ifaces);
- shash_destroy(&new_ifaces);
}
static void
iface_destroy(port->ifaces[port->n_ifaces - 1]);
}
+ shash_find_and_delete_assert(&br->port_by_name, port->name);
+
del = br->ports[port->port_idx] = br->ports[--br->n_ports];
del->port_idx = port->port_idx;
static struct port *
port_lookup(const struct bridge *br, const char *name)
{
- size_t i;
-
- for (i = 0; i < br->n_ports; i++) {
- struct port *port = br->ports[i];
- if (!strcmp(port->name, name)) {
- return port;
- }
- }
- return NULL;
+ return shash_find_data(&br->port_by_name, name);
}
static struct iface *
port_lookup_iface(const struct port *port, const char *name)
{
- size_t j;
-
- for (j = 0; j < port->n_ifaces; j++) {
- struct iface *iface = port->ifaces[j];
- if (!strcmp(iface->name, name)) {
- return iface;
- }
- }
- return NULL;
+ struct iface *iface = iface_lookup(port->bridge, name);
+ return iface && iface->port == port ? iface : NULL;
}
static void
bond_choose_active_iface(port);
port->bond_next_rebalance
= time_msec() + port->bond_rebalance_interval;
+
+ if (port->cfg->bond_fake_iface) {
+ port->bond_next_fake_iface_update = time_msec();
+ }
}
port->bond_compat_is_stale = true;
port->bond_fake_iface = port->cfg->bond_fake_iface;
static struct iface *
iface_create(struct port *port, const struct ovsrec_interface *if_cfg)
{
+ struct bridge *br = port->bridge;
struct iface *iface;
char *name = if_cfg->name;
int error;
iface->netdev = NULL;
iface->cfg = if_cfg;
+ shash_add_assert(&br->iface_by_name, iface->name, iface);
+
+ /* Attempt to create the network interface in case it doesn't exist yet. */
+ if (!iface_is_internal(br, iface->name)) {
+ error = set_up_iface(if_cfg, iface, true);
+ if (error) {
+ VLOG_WARN("could not create iface %s: %s", iface->name,
+ strerror(error));
+
+ shash_find_and_delete_assert(&br->iface_by_name, iface->name);
+ free(iface->name);
+ free(iface);
+ return NULL;
+ }
+ }
+
if (port->n_ifaces >= port->allocated_ifaces) {
port->ifaces = x2nrealloc(port->ifaces, &port->allocated_ifaces,
sizeof *port->ifaces);
}
port->ifaces[port->n_ifaces++] = iface;
if (port->n_ifaces > 1) {
- port->bridge->has_bonded_ports = true;
- }
-
- /* Attempt to create the network interface in case it
- * doesn't exist yet. */
- if (!iface_is_internal(port->bridge, iface->name)) {
- error = set_up_iface(if_cfg, iface, true);
- if (error) {
- VLOG_WARN("could not create iface %s: %s", iface->name,
- strerror(error));
- }
+ br->has_bonded_ports = true;
}
VLOG_DBG("attached network device %s to port %s", iface->name, port->name);
- bridge_flush(port->bridge);
+ bridge_flush(br);
return iface;
}
bool del_active = port->active_iface == iface->port_ifidx;
struct iface *del;
+ shash_find_and_delete_assert(&br->iface_by_name, iface->name);
+
if (iface->dp_ifidx >= 0) {
port_array_set(&br->ifaces, iface->dp_ifidx, NULL);
}
static struct iface *
iface_lookup(const struct bridge *br, const char *name)
{
- size_t i, j;
-
- for (i = 0; i < br->n_ports; i++) {
- struct port *port = br->ports[i];
- for (j = 0; j < port->n_ifaces; j++) {
- struct iface *iface = port->ifaces[j];
- if (!strcmp(iface->name, name)) {
- return iface;
- }
- }
- }
- return NULL;
+ return shash_find_data(&br->iface_by_name, name);
}
static struct iface *
static bool
iface_is_internal(const struct bridge *br, const char *if_name)
{
- /* XXX wastes time */
struct iface *iface;
struct port *port;
git://git.onelab.eu / sliver-openvswitch.git / blobdiff