mir/ovs
2
0
Fork 0
mirror of https://github.com/openvswitch/ovs synced 2025-08-22 09:58:01 +00:00
Code Issues Releases Wiki Activity
ovs/vswitchd/bridge.c
Adrian Moreno 6240c0b4c8 netdev: Add netdev_get_speed() to netdev API. 
Currently, the netdev's speed is being calculated by taking the link's
feature bits (using netdev_get_features()) and transforming them into
bps.

This mechanism can be both inaccurate and difficult to maintain, mainly
because we currently use the feature bits supported by OpenFlow which
would have to be extended to support all new feature bits of all netdev
implementations while keeping the OpenFlow API intact.

In order to expose the link speed accurately for all current and future
hardware, add a new netdev API call that allows the implementations to
provide the current and maximum link speeds in Mbps.

Internally, the logic to get the maximum supported speed still relies on
feature bits so it might still get out of sync in the future. However,
the maximum configurable speed is not used as much as the current speed
and these feature bits are not exposed through the netdev interface so
it should be easier to add more.

Use this new function instead of netdev_get_features() where the link
speed is needed.

As a consequence of this patch, link speeds of cards is properly
reported (internally in OVSDB) even if not supported by OpenFlow.
A test verifies this behavior using a tap device.

Also, in order to avoid using the old, this patch adds a checkpatch.py
warning if the old API is used.

Reported-at: https://bugzilla.redhat.com/show_bug.cgi?id=2137567
Acked-by: Eelco Chaudron <echaudro@redhat.com>
Signed-off-by: Adrian Moreno <amorenoz@redhat.com>
Signed-off-by: Ilya Maximets <i.maximets@ovn.org>
2023-07-17 20:03:32 +02:00

5238 lines
171 KiB
C
Raw Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/* Copyright (c) 2008, 2009, 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017 Nicira, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at:
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <config.h>
#include "bridge.h"
#include <errno.h>
#include <inttypes.h>
#include <stdlib.h>
#include "async-append.h"
#include "bfd.h"
#include "bitmap.h"
#include "cfm.h"
#include "connectivity.h"
#include "coverage.h"
#include "daemon.h"
#include "dirs.h"
#include "dpif.h"
#include "dpdk.h"
#include "hash.h"
#include "openvswitch/hmap.h"
#include "hmapx.h"
#include "if-notifier.h"
#include "jsonrpc.h"
#include "lacp.h"
#include "mac-learning.h"
#include "mcast-snooping.h"
#include "netdev.h"
#include "netdev-offload.h"
#include "nx-match.h"
#include "odp-execute.h"
#include "ofproto/bond.h"
#include "ofproto/ofproto.h"
#include "openvswitch/dynamic-string.h"
#include "openvswitch/list.h"
#include "openvswitch/meta-flow.h"
#include "openvswitch/ofp-print.h"
#include "openvswitch/ofpbuf.h"
#include "openvswitch/vconn.h"
#include "openvswitch/vlog.h"
#include "ovs-lldp.h"
#include "ovs-numa.h"
#include "packets.h"
#include "openvswitch/poll-loop.h"
#include "seq.h"
#include "sflow_api.h"
#include "sha1.h"
#include "openvswitch/shash.h"
#include "smap.h"
#include "socket-util.h"
#include "stream.h"
#include "stream-ssl.h"
#include "sset.h"
#include "system-stats.h"
#include "timeval.h"
#include "tnl-ports.h"
#include "userspace-tso.h"
#include "util.h"
#include "unixctl.h"
#include "lib/vswitch-idl.h"
#include "vlan-bitmap.h"
VLOG_DEFINE_THIS_MODULE(bridge);
COVERAGE_DEFINE(bridge_reconfigure);
struct iface {
/* These members are always valid.
*
* They are immutable: they never change between iface_create() and
* iface_destroy(). */
struct ovs_list port_elem; /* Element in struct port's "ifaces" list. */
struct hmap_node name_node; /* In struct bridge's "iface_by_name" hmap. */
struct hmap_node ofp_port_node; /* In struct bridge's "ifaces" hmap. */
struct port *port; /* Containing port. */
char *name; /* Host network device name. */
struct netdev *netdev; /* Network device. */
ofp_port_t ofp_port; /* OpenFlow port number. */
uint64_t change_seq;
/* These members are valid only within bridge_reconfigure(). */
const char *type; /* Usually same as cfg->type. */
const struct ovsrec_interface *cfg;
};
struct mirror {
struct uuid uuid; /* UUID of this "mirror" record in database. */
struct hmap_node hmap_node; /* In struct bridge's "mirrors" hmap. */
struct bridge *bridge;
char *name;
const struct ovsrec_mirror *cfg;
};
struct port {
struct hmap_node hmap_node; /* Element in struct bridge's "ports" hmap. */
struct bridge *bridge;
char *name;
const struct ovsrec_port *cfg;
/* An ordinary bridge port has 1 interface.
* A bridge port for bonding has at least 2 interfaces. */
struct ovs_list ifaces; /* List of "struct iface"s. */
};
struct bridge {
struct hmap_node node; /* In 'all_bridges'. */
char *name; /* User-specified arbitrary name. */
char *type; /* Datapath type. */
struct eth_addr ea; /* Bridge Ethernet Address. */
struct eth_addr default_ea; /* Default MAC. */
const struct ovsrec_bridge *cfg;
/* OpenFlow switch processing. */
struct ofproto *ofproto; /* OpenFlow switch. */
/* Bridge ports. */
struct hmap ports; /* "struct port"s indexed by name. */
struct hmap ifaces; /* "struct iface"s indexed by ofp_port. */
struct hmap iface_by_name; /* "struct iface"s indexed by name. */
/* Port mirroring. */
struct hmap mirrors; /* "struct mirror" indexed by UUID. */
/* Auto Attach */
struct hmap mappings; /* "struct" indexed by UUID */
/* Used during reconfiguration. */
struct shash wanted_ports;
/* Synthetic local port if necessary. */
struct ovsrec_port synth_local_port;
struct ovsrec_interface synth_local_iface;
struct ovsrec_interface *synth_local_ifacep;
};
struct aa_mapping {
struct hmap_node hmap_node; /* In struct bridge's "mappings" hmap. */
struct bridge *bridge;
uint32_t isid;
uint16_t vlan;
char *br_name;
};
/* Internal representation of conntrack zone configuration table in OVSDB. */
struct ct_zone {
uint16_t zone_id;
struct simap tp; /* A map from timeout policy attribute to
* timeout value. */
struct hmap_node node; /* Node in 'struct datapath' 'ct_zones'
* hmap. */
unsigned int last_used; /* The last idl_seqno that this 'ct_zone' used
* in OVSDB. This number is used for garbage
* collection. */
};
/* Internal representation of datapath configuration table in OVSDB. */
struct datapath {
char *type; /* Datapath type. */
struct hmap ct_zones; /* Map of 'struct ct_zone' elements, indexed
* by 'zone'. */
struct hmap_node node; /* Node in 'all_datapaths' hmap. */
struct smap caps; /* Capabilities. */
unsigned int last_used; /* The last idl_seqno that this 'datapath'
* used in OVSDB. This number is used for
* garbage collection. */
};
/* All bridges, indexed by name. */
static struct hmap all_bridges = HMAP_INITIALIZER(&all_bridges);
/* All datapath configuartions, indexed by type. */
static struct hmap all_datapaths = HMAP_INITIALIZER(&all_datapaths);
/* OVSDB IDL used to obtain configuration. */
static struct ovsdb_idl *idl;
/* We want to complete daemonization, fully detaching from our parent process,
* only after we have completed our initial configuration, committed our state
* to the database, and received confirmation back from the database server
* that it applied the commit. This allows our parent process to know that,
* post-detach, ephemeral fields such as datapath-id and ofport are very likely
* to have already been filled in. (It is only "very likely" rather than
* certain because there is always a slim possibility that the transaction will
* fail or that some other client has added new bridges, ports, etc. while
* ovs-vswitchd was configuring using an old configuration.)
*
* We only need to do this once for our initial configuration at startup, so
* 'initial_config_done' tracks whether we've already done it. While we are
* waiting for a response to our commit, 'daemonize_txn' tracks the transaction
* itself and is otherwise NULL. */
static bool initial_config_done;
static struct ovsdb_idl_txn *daemonize_txn;
/* Most recently processed IDL sequence number. */
static unsigned int idl_seqno;
/* Track changes to port connectivity. */
static uint64_t connectivity_seqno = LLONG_MIN;
/* Status update to database.
*
* Some information in the database must be kept as up-to-date as possible to
* allow controllers to respond rapidly to network outages. Those status are
* updated via the 'status_txn'.
*
* We use the global connectivity sequence number to detect the status change.
* Also, to prevent the status update from sending too much to the database,
* we check the return status of each update transaction and do not start new
* update if the previous transaction status is 'TXN_INCOMPLETE'.
*
* 'statux_txn' is NULL if there is no ongoing status update.
*
* If the previous database transaction was failed (is not 'TXN_SUCCESS',
* 'TXN_UNCHANGED' or 'TXN_INCOMPLETE'), 'status_txn_try_again' is set to true,
* which will cause the main thread wake up soon and retry the status update.
*/
static struct ovsdb_idl_txn *status_txn;
static bool status_txn_try_again;
/* When the status update transaction returns 'TXN_INCOMPLETE', should register a
* timeout in 'STATUS_CHECK_AGAIN_MSEC' to check again. */
#define STATUS_CHECK_AGAIN_MSEC 100
/* Statistics update to database. */
static struct ovsdb_idl_txn *stats_txn;
/* Each time this timer expires, the bridge fetches interface and mirror
* statistics and pushes them into the database. */
static int stats_timer_interval;
static long long int stats_timer = LLONG_MIN;
/* Each time this timer expires, the bridge fetches the list of port/VLAN
* membership that has been modified by the AA.
*/
#define AA_REFRESH_INTERVAL (1000) /* In milliseconds. */
static long long int aa_refresh_timer = LLONG_MIN;
/* Whenever system interfaces are added, removed or change state, the bridge
* will be reconfigured.
*/
static struct if_notifier *ifnotifier;
static struct seq *ifaces_changed;
static uint64_t last_ifaces_changed;
/* Default/min/max packet-in queue sizes towards the controllers. */
#define BRIDGE_CONTROLLER_PACKET_QUEUE_DEFAULT_SIZE 100
#define BRIDGE_CONTROLLER_PACKET_QUEUE_MIN_SIZE 1
#define BRIDGE_CONTROLLER_PACKET_QUEUE_MAX_SIZE 512
static void add_del_bridges(const struct ovsrec_open_vswitch *);
static void bridge_run__(void);
static void bridge_create(const struct ovsrec_bridge *);
static void bridge_destroy(struct bridge *, bool del);
static struct bridge *bridge_lookup(const char *name);
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_collect_wanted_ports(struct bridge *,
struct shash *wanted_ports);
static void bridge_delete_ofprotos(void);
static void bridge_delete_or_reconfigure_ports(struct bridge *);
static void bridge_del_ports(struct bridge *,
const struct shash *wanted_ports);
static void bridge_add_ports(struct bridge *,
const struct shash *wanted_ports);
static void bridge_configure_datapath_id(struct bridge *);
static void bridge_configure_netflow(struct bridge *);
static void bridge_configure_forward_bpdu(struct bridge *);
static void bridge_configure_mac_table(struct bridge *);
static void bridge_configure_mcast_snooping(struct bridge *);
static void bridge_configure_sflow(struct bridge *, int *sflow_bridge_number);
static void bridge_configure_ipfix(struct bridge *);
static void bridge_configure_spanning_tree(struct bridge *);
static void bridge_configure_tables(struct bridge *);
static void bridge_configure_dp_desc(struct bridge *);
static void bridge_configure_serial_desc(struct bridge *);
static void bridge_configure_aa(struct bridge *);
static void bridge_aa_refresh_queued(struct bridge *);
static bool bridge_aa_need_refresh(struct bridge *);
static void bridge_configure_remotes(struct bridge *,
const struct sockaddr_in *managers,
size_t n_managers);
static void bridge_pick_local_hw_addr(struct bridge *, struct eth_addr *ea,
struct iface **hw_addr_iface);
static uint64_t bridge_pick_datapath_id(struct bridge *,
const struct eth_addr bridge_ea);
static bool bridge_has_bond_fake_iface(const struct bridge *,
const char *name);
static bool port_is_bond_fake_iface(const struct port *);
static void datapath_destroy(struct datapath *dp);
static unixctl_cb_func qos_unixctl_show_types;
static unixctl_cb_func qos_unixctl_show;
static struct port *port_create(struct bridge *, const struct ovsrec_port *);
static void port_del_ifaces(struct port *);
static void port_destroy(struct port *);
static struct port *port_lookup(const struct bridge *, const char *name);
static void port_configure(struct port *);
static struct lacp_settings *port_configure_lacp(struct port *,
struct lacp_settings *);
static void port_configure_bond(struct port *, struct bond_settings *);
static bool port_is_synthetic(const struct port *);
static void reconfigure_system_stats(const struct ovsrec_open_vswitch *);
static void run_system_stats(void);
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 *);
static void mirror_refresh_stats(struct mirror *);
static void iface_configure_lacp(struct iface *,
struct lacp_member_settings *);
static bool iface_create(struct bridge *, const struct ovsrec_interface *,
const struct ovsrec_port *);
static bool iface_is_internal(const struct ovsrec_interface *iface,
const struct ovsrec_bridge *br);
static const char *iface_get_type(const struct ovsrec_interface *,
const struct ovsrec_bridge *);
static void iface_destroy(struct iface *);
static void iface_destroy__(struct iface *);
static struct iface *iface_lookup(const struct bridge *, const char *name);
static struct iface *iface_find(const char *name);
static struct iface *iface_from_ofp_port(const struct bridge *,
ofp_port_t ofp_port);
static void iface_set_mac(const struct bridge *, const struct port *, struct iface *);
static void iface_set_ofport(const struct ovsrec_interface *, ofp_port_t ofport);
static void iface_clear_db_record(const struct ovsrec_interface *if_cfg, char *errp);
static void iface_configure_qos(struct iface *, const struct ovsrec_qos *);
static void iface_configure_cfm(struct iface *);
static void iface_refresh_cfm_stats(struct iface *);
static void iface_refresh_stats(struct iface *);
static void iface_refresh_netdev_status(struct iface *);
static void iface_refresh_ofproto_status(struct iface *);
static bool iface_is_synthetic(const struct iface *);
static ofp_port_t iface_get_requested_ofp_port(
const struct ovsrec_interface *);
static ofp_port_t iface_pick_ofport(const struct ovsrec_interface *);
static void discover_types(const struct ovsrec_open_vswitch *cfg);
static void
bridge_init_ofproto(const struct ovsrec_open_vswitch *cfg)
{
struct shash iface_hints;
static bool initialized = false;
int i;
if (initialized) {
return;
}
shash_init(&iface_hints);
if (cfg) {
for (i = 0; i < cfg->n_bridges; i++) {
const struct ovsrec_bridge *br_cfg = cfg->bridges[i];
int 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 *if_cfg = port_cfg->interfaces[k];
struct iface_hint *iface_hint;
iface_hint = xmalloc(sizeof *iface_hint);
iface_hint->br_name = br_cfg->name;
iface_hint->br_type = br_cfg->datapath_type;
iface_hint->ofp_port = iface_pick_ofport(if_cfg);
shash_add(&iface_hints, if_cfg->name, iface_hint);
}
}
}
}
ofproto_init(&iface_hints);
shash_destroy_free_data(&iface_hints);
initialized = true;
}
static void
if_change_cb(void *aux OVS_UNUSED)
{
seq_change(ifaces_changed);
}
static bool
if_notifier_changed(struct if_notifier *notifier OVS_UNUSED)
{
uint64_t new_seq;
bool changed = false;
new_seq = seq_read(ifaces_changed);
if (new_seq != last_ifaces_changed) {
changed = true;
last_ifaces_changed = new_seq;
}
seq_wait(ifaces_changed, last_ifaces_changed);
return changed;
}
/* Public functions. */
/* Initializes the bridge module, configuring it to obtain its configuration
* from an OVSDB server accessed over 'remote', which should be a string in a
* form acceptable to ovsdb_idl_create(). */
void
bridge_init(const char *remote)
{
/* Create connection to database. */
idl = ovsdb_idl_create(remote, &ovsrec_idl_class, true, true);
idl_seqno = ovsdb_idl_get_seqno(idl);
ovsdb_idl_set_lock(idl, "ovs_vswitchd");
ovsdb_idl_verify_write_only(idl);
ovsdb_idl_omit_alert(idl, &ovsrec_open_vswitch_col_cur_cfg);
ovsdb_idl_omit_alert(idl, &ovsrec_open_vswitch_col_statistics);
ovsdb_idl_omit_alert(idl, &ovsrec_open_vswitch_col_datapath_types);
ovsdb_idl_omit_alert(idl, &ovsrec_open_vswitch_col_iface_types);
ovsdb_idl_omit(idl, &ovsrec_open_vswitch_col_external_ids);
ovsdb_idl_omit(idl, &ovsrec_open_vswitch_col_ovs_version);
ovsdb_idl_omit(idl, &ovsrec_open_vswitch_col_db_version);
ovsdb_idl_omit(idl, &ovsrec_open_vswitch_col_system_type);
ovsdb_idl_omit(idl, &ovsrec_open_vswitch_col_system_version);
ovsdb_idl_omit_alert(idl, &ovsrec_open_vswitch_col_dpdk_version);
ovsdb_idl_omit_alert(idl, &ovsrec_open_vswitch_col_dpdk_initialized);
ovsdb_idl_omit_alert(idl, &ovsrec_bridge_col_datapath_id);
ovsdb_idl_omit_alert(idl, &ovsrec_bridge_col_datapath_version);
ovsdb_idl_omit_alert(idl, &ovsrec_bridge_col_status);
ovsdb_idl_omit_alert(idl, &ovsrec_bridge_col_rstp_status);
ovsdb_idl_omit_alert(idl, &ovsrec_bridge_col_stp_enable);
ovsdb_idl_omit_alert(idl, &ovsrec_bridge_col_rstp_enable);
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_rstp_status);
ovsdb_idl_omit_alert(idl, &ovsrec_port_col_rstp_statistics);
ovsdb_idl_omit_alert(idl, &ovsrec_port_col_statistics);
ovsdb_idl_omit_alert(idl, &ovsrec_port_col_bond_active_slave);
ovsdb_idl_omit(idl, &ovsrec_port_col_external_ids);
ovsdb_idl_omit_alert(idl, &ovsrec_port_col_trunks);
ovsdb_idl_omit_alert(idl, &ovsrec_port_col_vlan_mode);
ovsdb_idl_omit_alert(idl, &ovsrec_interface_col_admin_state);
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_mac_in_use);
ovsdb_idl_omit_alert(idl, &ovsrec_interface_col_ifindex);
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_flap_count);
ovsdb_idl_omit_alert(idl, &ovsrec_interface_col_cfm_health);
ovsdb_idl_omit_alert(idl, &ovsrec_interface_col_cfm_remote_opstate);
ovsdb_idl_omit_alert(idl, &ovsrec_interface_col_bfd_status);
ovsdb_idl_omit_alert(idl, &ovsrec_interface_col_lacp_current);
ovsdb_idl_omit_alert(idl, &ovsrec_interface_col_error);
ovsdb_idl_omit(idl, &ovsrec_interface_col_external_ids);
ovsdb_idl_omit_alert(idl, &ovsrec_controller_col_is_connected);
ovsdb_idl_omit_alert(idl, &ovsrec_controller_col_role);
ovsdb_idl_omit_alert(idl, &ovsrec_controller_col_status);
ovsdb_idl_omit(idl, &ovsrec_controller_col_external_ids);
ovsdb_idl_omit(idl, &ovsrec_qos_col_external_ids);
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_sflow_col_external_ids);
ovsdb_idl_omit(idl, &ovsrec_ipfix_col_external_ids);
ovsdb_idl_omit(idl, &ovsrec_flow_sample_collector_set_col_external_ids);
ovsdb_idl_omit(idl, &ovsrec_manager_col_external_ids);
ovsdb_idl_omit(idl, &ovsrec_manager_col_inactivity_probe);
ovsdb_idl_omit(idl, &ovsrec_manager_col_is_connected);
ovsdb_idl_omit(idl, &ovsrec_manager_col_max_backoff);
ovsdb_idl_omit(idl, &ovsrec_manager_col_status);
ovsdb_idl_omit(idl, &ovsrec_ssl_col_external_ids);
/* Register unixctl commands. */
unixctl_command_register("qos/show-types", "interface", 1, 1,
qos_unixctl_show_types, NULL);
unixctl_command_register("qos/show", "interface", 1, 1,
qos_unixctl_show, NULL);
unixctl_command_register("bridge/dump-flows", "[--offload-stats] bridge",
1, 2, bridge_unixctl_dump_flows, NULL);
unixctl_command_register("bridge/reconnect", "[bridge]", 0, 1,
bridge_unixctl_reconnect, NULL);
lacp_init();
bond_init();
cfm_init();
bfd_init();
ovs_numa_init();
stp_init();
lldp_init();
rstp_init();
odp_execute_init();
ifaces_changed = seq_create();
last_ifaces_changed = seq_read(ifaces_changed);
ifnotifier = if_notifier_create(if_change_cb, NULL);
if_notifier_manual_set_cb(if_change_cb);
}
void
bridge_exit(bool delete_datapath)
{
if_notifier_manual_set_cb(NULL);
if_notifier_destroy(ifnotifier);
seq_destroy(ifaces_changed);
struct datapath *dp;
HMAP_FOR_EACH_SAFE (dp, node, &all_datapaths) {
datapath_destroy(dp);
}
struct bridge *br;
HMAP_FOR_EACH_SAFE (br, node, &all_bridges) {
bridge_destroy(br, delete_datapath);
}
ovsdb_idl_destroy(idl);
}
/* 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.
* (Thus, only managers connected in-band and with non-loopback addresses
* are collected.)
*/
static void
collect_in_band_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;
struct sset targets;
size_t i;
/* Collect all of the potential targets from the "targets" columns of the
* rows pointed to by "manager_options", excluding any that are
* out-of-band. */
sset_init(&targets);
for (i = 0; i < ovs_cfg->n_manager_options; i++) {
struct ovsrec_manager *m = ovs_cfg->manager_options[i];
if (m->connection_mode && !strcmp(m->connection_mode, "out-of-band")) {
sset_find_and_delete(&targets, m->target);
} else {
sset_add(&targets, m->target);
}
}
/* Now extract the targets' IP addresses. */
if (!sset_is_empty(&targets)) {
const char *target;
managers = xmalloc(sset_count(&targets) * sizeof *managers);
SSET_FOR_EACH (target, &targets) {
union {
struct sockaddr_storage ss;
struct sockaddr_in in;
} sa;
/* Ignore loopback. */
if (stream_parse_target_with_default_port(target, OVSDB_PORT,
&sa.ss)
&& sa.ss.ss_family == AF_INET
&& sa.in.sin_addr.s_addr != htonl(INADDR_LOOPBACK)) {
managers[n_managers++] = sa.in;
}
}
}
sset_destroy(&targets);
*managersp = managers;
*n_managersp = n_managers;
}
static void
config_ofproto_types(const struct smap *other_config)
{
struct sset types;
const char *type;
/* Pass custom configuration to datapath types. */
sset_init(&types);
ofproto_enumerate_types(&types);
SSET_FOR_EACH (type, &types) {
ofproto_type_set_config(type, other_config);
}
sset_destroy(&types);
}
static void
get_timeout_policy_from_ovsrec(struct simap *tp,
const struct ovsrec_ct_timeout_policy *tp_cfg)
{
if (tp_cfg) {
for (size_t i = 0; i < tp_cfg->n_timeouts; i++) {
simap_put(tp, tp_cfg->key_timeouts[i], tp_cfg->value_timeouts[i]);
}
}
}
static struct ct_zone *
ct_zone_lookup(struct hmap *ct_zones, uint16_t zone_id)
{
struct ct_zone *ct_zone;
HMAP_FOR_EACH_WITH_HASH (ct_zone, node, hash_int(zone_id, 0), ct_zones) {
if (ct_zone->zone_id == zone_id) {
return ct_zone;
}
}
return NULL;
}
static struct ct_zone *
ct_zone_alloc(uint16_t zone_id, struct ovsrec_ct_timeout_policy *tp_cfg)
{
struct ct_zone *ct_zone = xzalloc(sizeof *ct_zone);
ct_zone->zone_id = zone_id;
simap_init(&ct_zone->tp);
get_timeout_policy_from_ovsrec(&ct_zone->tp, tp_cfg);
return ct_zone;
}
static void
ct_zone_remove_and_destroy(struct datapath *dp, struct ct_zone *ct_zone)
{
hmap_remove(&dp->ct_zones, &ct_zone->node);
simap_destroy(&ct_zone->tp);
free(ct_zone);
}
/* Replace 'old_tp' by 'new_tp' (destroyed 'new_tp'). Returns true if 'old_tp'
* and 'new_tp' contains different data, false if they are the same. */
static bool
update_timeout_policy(struct simap *old_tp, struct simap *new_tp)
{
bool changed = !simap_equal(old_tp, new_tp);
if (changed) {
simap_swap(old_tp, new_tp);
}
simap_destroy(new_tp);
return changed;
}
static struct datapath *
datapath_lookup(const char *type)
{
struct datapath *dp;
HMAP_FOR_EACH_WITH_HASH (dp, node, hash_string(type, 0), &all_datapaths) {
if (!strcmp(dp->type, type)) {
return dp;
}
}
return NULL;
}
static struct datapath *
datapath_create(const char *type)
{
struct datapath *dp = xzalloc(sizeof *dp);
dp->type = xstrdup(type);
hmap_init(&dp->ct_zones);
hmap_insert(&all_datapaths, &dp->node, hash_string(type, 0));
smap_init(&dp->caps);
return dp;
}
static void
datapath_destroy(struct datapath *dp)
{
if (dp) {
struct ct_zone *ct_zone;
HMAP_FOR_EACH_SAFE (ct_zone, node, &dp->ct_zones) {
ofproto_ct_del_zone_timeout_policy(dp->type, ct_zone->zone_id);
ct_zone_remove_and_destroy(dp, ct_zone);
}
hmap_remove(&all_datapaths, &dp->node);
hmap_destroy(&dp->ct_zones);
free(dp->type);
smap_destroy(&dp->caps);
free(dp);
}
}
static void
ct_zones_reconfigure(struct datapath *dp, struct ovsrec_datapath *dp_cfg)
{
struct ct_zone *ct_zone;
/* Add new 'ct_zone's or update existing 'ct_zone's based on the database
* state. */
for (size_t i = 0; i < dp_cfg->n_ct_zones; i++) {
uint16_t zone_id = dp_cfg->key_ct_zones[i];
struct ovsrec_ct_zone *zone_cfg = dp_cfg->value_ct_zones[i];
struct ovsrec_ct_timeout_policy *tp_cfg = zone_cfg->timeout_policy;
ct_zone = ct_zone_lookup(&dp->ct_zones, zone_id);
if (ct_zone) {
struct simap new_tp = SIMAP_INITIALIZER(&new_tp);
get_timeout_policy_from_ovsrec(&new_tp, tp_cfg);
if (update_timeout_policy(&ct_zone->tp, &new_tp)) {
ofproto_ct_set_zone_timeout_policy(dp->type, ct_zone->zone_id,
&ct_zone->tp);
}
} else {
ct_zone = ct_zone_alloc(zone_id, tp_cfg);
hmap_insert(&dp->ct_zones, &ct_zone->node, hash_int(zone_id, 0));
ofproto_ct_set_zone_timeout_policy(dp->type, ct_zone->zone_id,
&ct_zone->tp);
}
ct_zone->last_used = idl_seqno;
}
/* Purge 'ct_zone's no longer found in the database. */
HMAP_FOR_EACH_SAFE (ct_zone, node, &dp->ct_zones) {
if (ct_zone->last_used != idl_seqno) {
ofproto_ct_del_zone_timeout_policy(dp->type, ct_zone->zone_id);
ct_zone_remove_and_destroy(dp, ct_zone);
}
}
}
static void
dp_capability_reconfigure(struct datapath *dp,
struct ovsrec_datapath *dp_cfg)
{
struct smap_node *node;
struct smap cap;
smap_init(&cap);
ofproto_get_datapath_cap(dp->type, &cap);
SMAP_FOR_EACH (node, &cap) {
ovsrec_datapath_update_capabilities_setkey(dp_cfg, node->key,
node->value);
}
smap_destroy(&cap);
}
static void
datapath_reconfigure(const struct ovsrec_open_vswitch *cfg)
{
struct datapath *dp;
/* Add new 'datapath's or update existing ones. */
for (size_t i = 0; i < cfg->n_datapaths; i++) {
struct ovsrec_datapath *dp_cfg = cfg->value_datapaths[i];
char *dp_name = cfg->key_datapaths[i];
dp = datapath_lookup(dp_name);
if (!dp) {
dp = datapath_create(dp_name);
dp_capability_reconfigure(dp, dp_cfg);
}
dp->last_used = idl_seqno;
ct_zones_reconfigure(dp, dp_cfg);
}
/* Purge deleted 'datapath's. */
HMAP_FOR_EACH_SAFE (dp, node, &all_datapaths) {
if (dp->last_used != idl_seqno) {
datapath_destroy(dp);
}
}
}
static void
bridge_reconfigure(const struct ovsrec_open_vswitch *ovs_cfg)
{
struct sockaddr_in *managers;
struct bridge *br;
int sflow_bridge_number;
size_t n_managers;
COVERAGE_INC(bridge_reconfigure);
ofproto_set_flow_limit(smap_get_uint(&ovs_cfg->other_config, "flow-limit",
OFPROTO_FLOW_LIMIT_DEFAULT));
ofproto_set_max_idle(smap_get_uint(&ovs_cfg->other_config, "max-idle",
OFPROTO_MAX_IDLE_DEFAULT));
ofproto_set_max_revalidator(smap_get_uint(&ovs_cfg->other_config,
"max-revalidator",
OFPROTO_MAX_REVALIDATOR_DEFAULT));
ofproto_set_min_revalidate_pps(
smap_get_uint(&ovs_cfg->other_config, "min-revalidate-pps",
OFPROTO_MIN_REVALIDATE_PPS_DEFAULT));
ofproto_set_offloaded_stats_delay(
smap_get_uint(&ovs_cfg->other_config, "offloaded-stats-delay",
OFPROTO_OFFLOADED_STATS_DELAY));
ofproto_set_vlan_limit(smap_get_int(&ovs_cfg->other_config, "vlan-limit",
LEGACY_MAX_VLAN_HEADERS));
ofproto_set_bundle_idle_timeout(smap_get_uint(&ovs_cfg->other_config,
"bundle-idle-timeout", 0));
ofproto_set_threads(
smap_get_int(&ovs_cfg->other_config, "n-handler-threads", 0),
smap_get_int(&ovs_cfg->other_config, "n-revalidator-threads", 0));
/* Destroy "struct bridge"s, "struct port"s, and "struct iface"s according
* to 'ovs_cfg', with only very minimal configuration otherwise.
*
* This is mostly an update to bridge data structures. Nothing is pushed
* down to ofproto or lower layers. */
add_del_bridges(ovs_cfg);
HMAP_FOR_EACH (br, node, &all_bridges) {
bridge_collect_wanted_ports(br, &br->wanted_ports);
bridge_del_ports(br, &br->wanted_ports);
}
/* Start pushing configuration changes down to the ofproto layer:
*
* - Delete ofprotos that are no longer configured.
*
* - Delete ports that are no longer configured.
*
* - Reconfigure existing ports to their desired configurations, or
* delete them if not possible.
*
* We have to do all the deletions before we can do any additions, because
* the ports to be added might require resources that will be freed up by
* deletions (they might especially overlap in name). */
bridge_delete_ofprotos();
HMAP_FOR_EACH (br, node, &all_bridges) {
if (br->ofproto) {
bridge_delete_or_reconfigure_ports(br);
}
}
/* Finish pushing configuration changes to the ofproto layer:
*
* - Create ofprotos that are missing.
*
* - Add ports that are missing. */
HMAP_FOR_EACH_SAFE (br, node, &all_bridges) {
if (!br->ofproto) {
int error;
error = ofproto_create(br->name, br->type, &br->ofproto);
if (error) {
VLOG_ERR("failed to create bridge %s: %s", br->name,
ovs_strerror(error));
shash_destroy(&br->wanted_ports);
bridge_destroy(br, true);
} else {
/* Trigger storing datapath version. */
seq_change(connectivity_seq_get());
}
}
}
config_ofproto_types(&ovs_cfg->other_config);
HMAP_FOR_EACH (br, node, &all_bridges) {
bridge_add_ports(br, &br->wanted_ports);
shash_destroy(&br->wanted_ports);
}
reconfigure_system_stats(ovs_cfg);
datapath_reconfigure(ovs_cfg);
/* Complete the configuration. */
sflow_bridge_number = 0;
collect_in_band_managers(ovs_cfg, &managers, &n_managers);
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;
port_configure(port);
LIST_FOR_EACH (iface, port_elem, &port->ifaces) {
iface_set_ofport(iface->cfg, iface->ofp_port);
/* Clear eventual previous errors */
ovsrec_interface_set_error(iface->cfg, NULL);
iface_configure_cfm(iface);
iface_configure_qos(iface, port->cfg->qos);
iface_set_mac(br, port, iface);
ofproto_port_set_bfd(br->ofproto, iface->ofp_port,
&iface->cfg->bfd);
ofproto_port_set_lldp(br->ofproto, iface->ofp_port,
&iface->cfg->lldp);
ofproto_port_set_config(br->ofproto, iface->ofp_port,
&iface->cfg->other_config);
}
}
bridge_configure_mirrors(br);
bridge_configure_forward_bpdu(br);
bridge_configure_mac_table(br);
bridge_configure_mcast_snooping(br);
bridge_configure_remotes(br, managers, n_managers);
bridge_configure_netflow(br);
bridge_configure_sflow(br, &sflow_bridge_number);
bridge_configure_ipfix(br);
bridge_configure_spanning_tree(br);
bridge_configure_tables(br);
bridge_configure_dp_desc(br);
bridge_configure_serial_desc(br);
bridge_configure_aa(br);
}
free(managers);
/* The ofproto-dpif provider does some final reconfiguration in its
* ->type_run() function. We have to call it before notifying the database
* client that reconfiguration is complete, otherwise there is a very
* narrow race window in which e.g. ofproto/trace will not recognize the
* new configuration (sometimes this causes unit test failures). */
bridge_run__();
}
/* Delete ofprotos which aren't configured or have the wrong type. Create
* ofprotos which don't exist but need to. */
static void
bridge_delete_ofprotos(void)
{
struct bridge *br;
struct sset names;
struct sset types;
const char *type;
/* Delete ofprotos with no bridge or with the wrong type. */
sset_init(&names);
sset_init(&types);
ofproto_enumerate_types(&types);
SSET_FOR_EACH (type, &types) {
const char *name;
ofproto_enumerate_names(type, &names);
SSET_FOR_EACH (name, &names) {
br = bridge_lookup(name);
if (!br || strcmp(type, br->type)) {
ofproto_delete(name, type);
}
}
}
sset_destroy(&names);
sset_destroy(&types);
}
static ofp_port_t *
add_ofp_port(ofp_port_t port, ofp_port_t *ports, size_t *n, size_t *allocated)
{
if (*n >= *allocated) {
ports = x2nrealloc(ports, allocated, sizeof *ports);
}
ports[(*n)++] = port;
return ports;
}
/* Configures the MTU of 'netdev' based on the "mtu_request" column
* in 'iface_cfg'. */
static int
iface_set_netdev_mtu(const struct ovsrec_interface *iface_cfg,
struct netdev *netdev)
{
if (iface_cfg->n_mtu_request == 1) {
/* The user explicitly asked for this MTU. */
netdev_mtu_user_config(netdev, true);
/* Try to set the MTU to the requested value. */
return netdev_set_mtu(netdev, *iface_cfg->mtu_request);
}
/* The user didn't explicitly asked for any MTU. */
netdev_mtu_user_config(netdev, false);
return 0;
}
static void
bridge_delete_or_reconfigure_ports(struct bridge *br)
{
struct ofproto_port ofproto_port;
struct ofproto_port_dump dump;
struct sset ofproto_ports;
struct port *port;
/* List of "ofp_port"s to delete. We make a list instead of deleting them
* right away because ofproto implementations aren't necessarily able to
* iterate through a changing list of ports in an entirely robust way. */
ofp_port_t *del;
size_t n, allocated;
size_t i;
del = NULL;
n = allocated = 0;
sset_init(&ofproto_ports);
/* Main task: Iterate over the ports in 'br->ofproto' and remove the ports
* that are not configured in the database. (This commonly happens when
* ports have been deleted, e.g. with "ovs-vsctl del-port".)
*
* Side tasks: Reconfigure the ports that are still in 'br'. Delete ports
* that have the wrong OpenFlow port number (and arrange to add them back
* with the correct OpenFlow port number). */
OFPROTO_PORT_FOR_EACH (&ofproto_port, &dump, br->ofproto) {
ofp_port_t requested_ofp_port;
struct iface *iface;
sset_add(&ofproto_ports, ofproto_port.name);
iface = iface_lookup(br, ofproto_port.name);
if (!iface) {
/* No such iface is configured, so we should delete this
* ofproto_port.
*
* As a corner case exception, keep the port if it's a bond fake
* interface. */
if (bridge_has_bond_fake_iface(br, ofproto_port.name)
&& !strcmp(ofproto_port.type, "internal")) {
continue;
}
goto delete;
}
const char *netdev_type = ofproto_port_open_type(br->ofproto,
iface->type);
if (strcmp(ofproto_port.type, netdev_type)
|| netdev_set_config(iface->netdev, &iface->cfg->options, NULL)) {
/* The interface is the wrong type or can't be configured.
* Delete it. */
goto delete;
}
iface_set_netdev_mtu(iface->cfg, iface->netdev);
/* If the requested OpenFlow port for 'iface' changed, and it's not
* already the correct port, then we might want to temporarily delete
* this interface, so we can add it back again with the new OpenFlow
* port number. */
requested_ofp_port = iface_get_requested_ofp_port(iface->cfg);
if (iface->ofp_port != OFPP_LOCAL &&
requested_ofp_port != OFPP_NONE &&
requested_ofp_port != iface->ofp_port) {
ofp_port_t victim_request;
struct iface *victim;
/* Check for an existing OpenFlow port currently occupying
* 'iface''s requested port number. If there isn't one, then
* delete this port. Otherwise we need to consider further. */
victim = iface_from_ofp_port(br, requested_ofp_port);
if (!victim) {
goto delete;
}
/* 'victim' is a port currently using 'iface''s requested port
* number. Unless 'victim' specifically requested that port
* number, too, then we can delete both 'iface' and 'victim'
* temporarily. (We'll add both of them back again later with new
* OpenFlow port numbers.)
*
* If 'victim' did request port number 'requested_ofp_port', just
* like 'iface', then that's a configuration inconsistency that we
* can't resolve. We might as well let it keep its current port
* number. */
victim_request = iface_get_requested_ofp_port(victim->cfg);
if (victim_request != requested_ofp_port) {
del = add_ofp_port(victim->ofp_port, del, &n, &allocated);
iface_destroy(victim);
goto delete;
}
}
/* Keep it. */
continue;
delete:
iface_destroy(iface);
del = add_ofp_port(ofproto_port.ofp_port, del, &n, &allocated);
}
for (i = 0; i < n; i++) {
ofproto_port_del(br->ofproto, del[i]);
}
free(del);
/* Iterate over this module's idea of interfaces in 'br'. Remove any ports
* that we didn't see when we iterated through the datapath, i.e. ports
* that disappeared underneath use. This is an unusual situation, but it
* can happen in some cases:
*
* - An admin runs a command like "ovs-dpctl del-port" (which is a bad
* idea but could happen).
*
* - The port represented a device that disappeared, e.g. a tuntap
* device destroyed via "tunctl -d", a physical Ethernet device
* whose module was just unloaded via "rmmod", or a virtual NIC for a
* VM whose VM was just terminated. */
HMAP_FOR_EACH_SAFE (port, hmap_node, &br->ports) {
struct iface *iface;
LIST_FOR_EACH_SAFE (iface, port_elem, &port->ifaces) {
if (!sset_contains(&ofproto_ports, iface->name)) {
iface_destroy__(iface);
}
}
if (ovs_list_is_empty(&port->ifaces)) {
port_destroy(port);
}
}
sset_destroy(&ofproto_ports);
}
static void
bridge_add_ports__(struct bridge *br, const struct shash *wanted_ports,
bool with_requested_port)
{
struct shash_node *port_node;
SHASH_FOR_EACH (port_node, wanted_ports) {
const struct ovsrec_port *port_cfg = port_node->data;
size_t i;
for (i = 0; i < port_cfg->n_interfaces; i++) {
const struct ovsrec_interface *iface_cfg = port_cfg->interfaces[i];
ofp_port_t requested_ofp_port;
requested_ofp_port = iface_get_requested_ofp_port(iface_cfg);
if ((requested_ofp_port != OFPP_NONE) == with_requested_port) {
struct iface *iface = iface_lookup(br, iface_cfg->name);
if (!iface) {
iface_create(br, iface_cfg, port_cfg);
}
}
}
}
}
static void
bridge_add_ports(struct bridge *br, const struct shash *wanted_ports)
{
/* First add interfaces that request a particular port number. */
bridge_add_ports__(br, wanted_ports, true);
/* Then add interfaces that want automatic port number assignment.
* We add these afterward to avoid accidentally taking a specifically
* requested port number. */
bridge_add_ports__(br, wanted_ports, false);
}
static void
port_configure(struct port *port)
{
const struct ovsrec_port *cfg = port->cfg;
struct bond_settings bond_settings;
struct lacp_settings lacp_settings;
struct ofproto_bundle_settings s;
struct iface *iface;
/* Get name. */
s.name = port->name;
/* Get members. */
s.n_members = 0;
s.members = xmalloc(ovs_list_size(&port->ifaces) * sizeof *s.members);
LIST_FOR_EACH (iface, port_elem, &port->ifaces) {
s.members[s.n_members++] = iface->ofp_port;
}
/* Get VLAN tag. */
s.vlan = -1;
if (cfg->tag && *cfg->tag >= 0 && *cfg->tag <= 4095) {
s.vlan = *cfg->tag;
}
/* Get VLAN trunks. */
s.trunks = NULL;
if (cfg->n_trunks) {
s.trunks = vlan_bitmap_from_array(cfg->trunks, cfg->n_trunks);
}
s.cvlans = NULL;
if (cfg->n_cvlans) {
s.cvlans = vlan_bitmap_from_array(cfg->cvlans, cfg->n_cvlans);
}
/* 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 if (!strcmp(cfg->vlan_mode, "dot1q-tunnel")) {
s.vlan_mode = PORT_VLAN_DOT1Q_TUNNEL;
} else {
/* This "can't happen" because ovsdb-server should prevent it. */
VLOG_WARN("port %s: unknown VLAN mode %s, falling "
"back to trunk mode", port->name, cfg->vlan_mode);
s.vlan_mode = PORT_VLAN_TRUNK;
}
} else {
if (s.vlan >= 0) {
s.vlan_mode = PORT_VLAN_ACCESS;
if (cfg->n_trunks || cfg->n_cvlans) {
VLOG_WARN("port %s: ignoring trunks in favor of implicit vlan",
port->name);
}
} else {
s.vlan_mode = PORT_VLAN_TRUNK;
}
}
const char *qe = smap_get_def(&cfg->other_config, "qinq-ethtype", "");
s.qinq_ethtype = (!strcmp(qe, "802.1q")
? ETH_TYPE_VLAN_8021Q
: ETH_TYPE_VLAN_8021AD);
const char *pt = smap_get_def(&cfg->other_config, "priority-tags", "");
if (!strcmp(pt, "if-nonzero") || !strcmp(pt, "true")) {
s.use_priority_tags = PORT_PRIORITY_TAGS_IF_NONZERO;
} else if (!strcmp(pt, "always")) {
s.use_priority_tags = PORT_PRIORITY_TAGS_ALWAYS;
} else {
s.use_priority_tags = PORT_PRIORITY_TAGS_NEVER;
}
/* Get LACP settings. */
s.lacp = port_configure_lacp(port, &lacp_settings);
if (s.lacp) {
size_t i = 0;
s.lacp_members = xmalloc(s.n_members * sizeof *s.lacp_members);
LIST_FOR_EACH (iface, port_elem, &port->ifaces) {
iface_configure_lacp(iface, &s.lacp_members[i++]);
}
} else {
s.lacp_members = NULL;
}
/* Get bond settings. */
if (s.n_members > 1) {
s.bond = &bond_settings;
port_configure_bond(port, &bond_settings);
} else {
s.bond = NULL;
LIST_FOR_EACH (iface, port_elem, &port->ifaces) {
netdev_set_miimon_interval(iface->netdev, 0);
}
}
/* Protected port mode */
s.protected = cfg->protected_;
/* Register. */
ofproto_bundle_register(port->bridge->ofproto, port, &s);
/* Clean up. */
free(s.cvlans);
free(s.members);
free(s.trunks);
free(s.lacp_members);
}
/* Pick local port hardware address and datapath ID for 'br'. */
static void
bridge_configure_datapath_id(struct bridge *br)
{
struct eth_addr ea;
uint64_t dpid;
struct iface *local_iface;
struct iface *hw_addr_iface;
char *dpid_string;
bridge_pick_local_hw_addr(br, &ea, &hw_addr_iface);
local_iface = iface_from_ofp_port(br, OFPP_LOCAL);
if (local_iface) {
int error = netdev_set_etheraddr(local_iface->netdev, ea);
if (error) {
static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
VLOG_ERR_RL(&rl, "bridge %s: failed to set bridge "
"Ethernet address: %s",
br->name, ovs_strerror(error));
}
}
br->ea = ea;
dpid = bridge_pick_datapath_id(br, ea);
if (dpid != ofproto_get_datapath_id(br->ofproto)) {
VLOG_INFO("bridge %s: using datapath ID %016"PRIx64, br->name, dpid);
ofproto_set_datapath_id(br->ofproto, dpid);
}
dpid_string = xasprintf("%016"PRIx64, dpid);
ovsrec_bridge_set_datapath_id(br->cfg, dpid_string);
free(dpid_string);
}
/* Returns a bitmap of "enum ofputil_protocol"s that are allowed for use with
* 'br'. */
static uint32_t
bridge_get_allowed_versions(struct bridge *br)
{
if (!br->cfg->n_protocols) {
return 0;
}
return ofputil_versions_from_strings(br->cfg->protocols,
br->cfg->n_protocols);
}
static int
bridge_get_controller_queue_size(struct bridge *br,
struct ovsrec_controller *c)
{
if (c && c->controller_queue_size) {
return *c->controller_queue_size;
}
int queue_size = smap_get_int(&br->cfg->other_config,
"controller-queue-size",
BRIDGE_CONTROLLER_PACKET_QUEUE_DEFAULT_SIZE);
if (queue_size < BRIDGE_CONTROLLER_PACKET_QUEUE_MIN_SIZE ||
queue_size > BRIDGE_CONTROLLER_PACKET_QUEUE_MAX_SIZE) {
return BRIDGE_CONTROLLER_PACKET_QUEUE_DEFAULT_SIZE;
}
return queue_size;
}
/* Set NetFlow configuration on 'br'. */
static void
bridge_configure_netflow(struct bridge *br)
{
struct ovsrec_netflow *cfg = br->cfg->netflow;
struct netflow_options opts;
if (!cfg) {
ofproto_set_netflow(br->ofproto, NULL);
return;
}
memset(&opts, 0, sizeof opts);
/* Get default NetFlow configuration from datapath.
* Apply overrides from 'cfg'. */
ofproto_get_netflow_ids(br->ofproto, &opts.engine_type, &opts.engine_id);
if (cfg->engine_type) {
opts.engine_type = *cfg->engine_type;
}
if (cfg->engine_id) {
opts.engine_id = *cfg->engine_id;
}
/* Configure active timeout interval. */
opts.active_timeout = cfg->active_timeout;
if (!opts.active_timeout) {
opts.active_timeout = -1;
} else if (opts.active_timeout < 0) {
VLOG_WARN("bridge %s: active timeout interval set to negative "
"value, using default instead (%d seconds)", br->name,
NF_ACTIVE_TIMEOUT_DEFAULT);
opts.active_timeout = -1;
}
/* Add engine ID to interface number to disambiguate bridgs? */
opts.add_id_to_iface = cfg->add_id_to_interface;
if (opts.add_id_to_iface) {
if (opts.engine_id > 0x7f) {
VLOG_WARN("bridge %s: NetFlow port mangling may conflict with "
"another vswitch, choose an engine id less than 128",
br->name);
}
if (hmap_count(&br->ports) > 508) {
VLOG_WARN("bridge %s: NetFlow port mangling will conflict with "
"another port when more than 508 ports are used",
br->name);
}
}
/* Collectors. */
sset_init(&opts.collectors);
sset_add_array(&opts.collectors, cfg->targets, cfg->n_targets);
/* Configure. */
if (ofproto_set_netflow(br->ofproto, &opts)) {
VLOG_ERR("bridge %s: problem setting netflow collectors", br->name);
}
sset_destroy(&opts.collectors);
}
/* Set sFlow configuration on 'br'. */
static void
bridge_configure_sflow(struct bridge *br, int *sflow_bridge_number)
{
const struct ovsrec_sflow *cfg = br->cfg->sflow;
struct ovsrec_controller **controllers;
struct ofproto_sflow_options oso;
size_t n_controllers;
size_t i;
if (!cfg) {
ofproto_set_sflow(br->ofproto, NULL);
return;
}
memset(&oso, 0, sizeof oso);
sset_init(&oso.targets);
sset_add_array(&oso.targets, cfg->targets, cfg->n_targets);
oso.sampling_rate = SFL_DEFAULT_SAMPLING_RATE;
if (cfg->sampling) {
oso.sampling_rate = *cfg->sampling;
}
oso.polling_interval = SFL_DEFAULT_POLLING_INTERVAL;
if (cfg->polling) {
oso.polling_interval = *cfg->polling;
}
oso.header_len = SFL_DEFAULT_HEADER_SIZE;
if (cfg->header) {
oso.header_len = *cfg->header;
}
oso.sub_id = (*sflow_bridge_number)++;
oso.agent_device = cfg->agent;
oso.control_ip = NULL;
n_controllers = bridge_get_controllers(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);
sset_destroy(&oso.targets);
}
/* Returns whether a IPFIX row is valid. */
static bool
ovsrec_ipfix_is_valid(const struct ovsrec_ipfix *ipfix)
{
return ipfix && ipfix->n_targets > 0;
}
/* Returns whether a Flow_Sample_Collector_Set row is valid. */
static bool
ovsrec_fscs_is_valid(const struct ovsrec_flow_sample_collector_set *fscs,
const struct bridge *br)
{
return ovsrec_ipfix_is_valid(fscs->ipfix) && fscs->bridge == br->cfg;
}
/* Set IPFIX configuration on 'br'. */
static void
bridge_configure_ipfix(struct bridge *br)
{
const struct ovsrec_ipfix *be_cfg = br->cfg->ipfix;
bool valid_be_cfg = ovsrec_ipfix_is_valid(be_cfg);
const struct ovsrec_flow_sample_collector_set *fe_cfg;
struct ofproto_ipfix_bridge_exporter_options be_opts;
struct ofproto_ipfix_flow_exporter_options *fe_opts = NULL;
size_t n_fe_opts = 0;
const char *virtual_obs_id;
OVSREC_FLOW_SAMPLE_COLLECTOR_SET_FOR_EACH(fe_cfg, idl) {
if (ovsrec_fscs_is_valid(fe_cfg, br)) {
n_fe_opts++;
}
}
if (!valid_be_cfg && n_fe_opts == 0) {
ofproto_set_ipfix(br->ofproto, NULL, NULL, 0);
return;
}
if (valid_be_cfg) {
memset(&be_opts, 0, sizeof be_opts);
sset_init(&be_opts.targets);
sset_add_array(&be_opts.targets, be_cfg->targets, be_cfg->n_targets);
if (be_cfg->sampling) {
be_opts.sampling_rate = *be_cfg->sampling;
} else {
be_opts.sampling_rate = SFL_DEFAULT_SAMPLING_RATE;
}
if (be_cfg->obs_domain_id) {
be_opts.obs_domain_id = *be_cfg->obs_domain_id;
}
if (be_cfg->obs_point_id) {
be_opts.obs_point_id = *be_cfg->obs_point_id;
}
if (be_cfg->cache_active_timeout) {
be_opts.cache_active_timeout = *be_cfg->cache_active_timeout;
}
if (be_cfg->cache_max_flows) {
be_opts.cache_max_flows = *be_cfg->cache_max_flows;
}
if (be_cfg->stats_interval) {
be_opts.stats_interval = *be_cfg->stats_interval;
} else {
be_opts.stats_interval = OFPROTO_IPFIX_DEFAULT_TEMPLATE_INTERVAL;
}
if (be_cfg->template_interval) {
be_opts.template_interval = *be_cfg->template_interval;
} else {
be_opts.template_interval =
OFPROTO_IPFIX_DEFAULT_TEMPLATE_INTERVAL;
}
be_opts.enable_tunnel_sampling = smap_get_bool(&be_cfg->other_config,
"enable-tunnel-sampling", true);
be_opts.enable_input_sampling = smap_get_bool(&be_cfg->other_config,
"enable-input-sampling", true);
be_opts.enable_output_sampling = smap_get_bool(&be_cfg->other_config,
"enable-output-sampling", true);
virtual_obs_id = smap_get(&be_cfg->other_config, "virtual_obs_id");
be_opts.virtual_obs_id = nullable_xstrdup(virtual_obs_id);
}
if (n_fe_opts > 0) {
struct ofproto_ipfix_flow_exporter_options *opts;
fe_opts = xcalloc(n_fe_opts, sizeof *fe_opts);
opts = fe_opts;
OVSREC_FLOW_SAMPLE_COLLECTOR_SET_FOR_EACH(fe_cfg, idl) {
if (ovsrec_fscs_is_valid(fe_cfg, br)) {
opts->collector_set_id = fe_cfg->id;
sset_init(&opts->targets);
sset_add_array(&opts->targets, fe_cfg->ipfix->targets,
fe_cfg->ipfix->n_targets);
opts->cache_active_timeout = fe_cfg->ipfix->cache_active_timeout
? *fe_cfg->ipfix->cache_active_timeout : 0;
opts->cache_max_flows = fe_cfg->ipfix->cache_max_flows
? *fe_cfg->ipfix->cache_max_flows : 0;
opts->stats_interval = fe_cfg->ipfix->stats_interval
? *fe_cfg->ipfix->stats_interval
: OFPROTO_IPFIX_DEFAULT_TEMPLATE_INTERVAL;
opts->template_interval = fe_cfg->ipfix->template_interval
? *fe_cfg->ipfix->template_interval
: OFPROTO_IPFIX_DEFAULT_TEMPLATE_INTERVAL;
opts->enable_tunnel_sampling = smap_get_bool(
&fe_cfg->ipfix->other_config,
"enable-tunnel-sampling", true);
virtual_obs_id = smap_get(&fe_cfg->ipfix->other_config,
"virtual_obs_id");
opts->virtual_obs_id = nullable_xstrdup(virtual_obs_id);
opts++;
}
}
}
ofproto_set_ipfix(br->ofproto, valid_be_cfg ? &be_opts : NULL, fe_opts,
n_fe_opts);
if (valid_be_cfg) {
sset_destroy(&be_opts.targets);
free(be_opts.virtual_obs_id);
}
if (n_fe_opts > 0) {
struct ofproto_ipfix_flow_exporter_options *opts = fe_opts;
size_t i;
for (i = 0; i < n_fe_opts; i++) {
sset_destroy(&opts->targets);
free(opts->virtual_obs_id);
opts++;
}
free(fe_opts);
}
}
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;
if (!smap_get_bool(&port->cfg->other_config, "stp-enable", true)) {
port_s->enable = false;
return;
} else {
port_s->enable = true;
}
/* STP over bonds is not supported. */
if (!ovs_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(ovs_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 = smap_get(&port->cfg->other_config, "stp-port-num");
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 = smap_get(&port->cfg->other_config, "stp-path-cost");
if (config_str) {
port_s->path_cost = strtoul(config_str, NULL, 10);
} else {
uint32_t mbps;
netdev_get_speed(iface->netdev, &mbps, NULL);
if (!mbps) {
mbps = NETDEV_DEFAULT_BPS / 1000000;
}
port_s->path_cost = stp_convert_speed_to_cost(mbps);
}
config_str = smap_get(&port->cfg->other_config, "stp-port-priority");
if (config_str) {
port_s->priority = strtoul(config_str, NULL, 0);
} else {
port_s->priority = STP_DEFAULT_PORT_PRIORITY;
}
}
static void
port_configure_rstp(const struct ofproto *ofproto, struct port *port,
struct ofproto_port_rstp_settings *port_s, int *port_num_counter)
{
const char *config_str;
struct iface *iface;
if (!smap_get_bool(&port->cfg->other_config, "rstp-enable", true)) {
port_s->enable = false;
return;
} else {
port_s->enable = true;
}
/* RSTP over bonds is not supported. */
if (!ovs_list_is_singleton(&port->ifaces)) {
VLOG_ERR("port %s: cannot enable RSTP on bonds, disabling",
port->name);
port_s->enable = false;
return;
}
iface = CONTAINER_OF(ovs_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 RSTP on internal ports", port->name);
port_s->enable = false;
return;
}
/* RSTP on mirror output ports is not supported. */
if (ofproto_is_mirror_output_bundle(ofproto, port)) {
VLOG_DBG("port %s: disable RSTP on mirror ports", port->name);
port_s->enable = false;
return;
}
config_str = smap_get(&port->cfg->other_config, "rstp-port-num");
if (config_str) {
unsigned long int port_num = strtoul(config_str, NULL, 0);
if (port_num < 1 || port_num > RSTP_MAX_PORTS) {
VLOG_ERR("port %s: invalid rstp-port-num", port->name);
port_s->enable = false;
return;
}
port_s->port_num = port_num;
} else {
if (*port_num_counter >= RSTP_MAX_PORTS) {
VLOG_ERR("port %s: too many RSTP ports, disabling", port->name);
port_s->enable = false;
return;
}
/* If rstp-port-num is not specified, use 0.
* rstp_port_set_port_number() will look for the first free one. */
port_s->port_num = 0;
}
/* Increment the port num counter, because we only support
* RSTP_MAX_PORTS rstp ports. */
(*port_num_counter)++;
config_str = smap_get(&port->cfg->other_config, "rstp-path-cost");
if (config_str) {
port_s->path_cost = strtoul(config_str, NULL, 10);
} else {
uint32_t mbps;
netdev_get_speed(iface->netdev, &mbps, NULL);
if (!mbps) {
mbps = NETDEV_DEFAULT_BPS / 1000000;
}
port_s->path_cost = rstp_convert_speed_to_cost(mbps);
}
config_str = smap_get(&port->cfg->other_config, "rstp-port-priority");
if (config_str) {
port_s->priority = strtoul(config_str, NULL, 0);
} else {
port_s->priority = RSTP_DEFAULT_PORT_PRIORITY;
}
port_s->admin_p2p_mac_state = smap_get_ullong(
&port->cfg->other_config, "rstp-admin-p2p-mac",
RSTP_ADMIN_P2P_MAC_FORCE_TRUE);
port_s->admin_port_state = smap_get_bool(&port->cfg->other_config,
"rstp-admin-port-state", true);
port_s->admin_edge_port = smap_get_bool(&port->cfg->other_config,
"rstp-port-admin-edge", false);
port_s->auto_edge = smap_get_bool(&port->cfg->other_config,
"rstp-port-auto-edge", true);
port_s->mcheck = smap_get_bool(&port->cfg->other_config,
"rstp-port-mcheck", false);
}
/* Set spanning tree configuration on 'br'. */
static void
bridge_configure_stp(struct bridge *br, bool enable_stp)
{
if (!enable_stp) {
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 = smap_get(&br->cfg->other_config, "stp-system-id");
if (config_str) {
struct eth_addr ea;
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);
}
br_s.priority = smap_get_ullong(&br->cfg->other_config, "stp-priority",
STP_DEFAULT_BRIDGE_PRIORITY);
br_s.hello_time = smap_get_ullong(&br->cfg->other_config,
"stp-hello-time",
STP_DEFAULT_HELLO_TIME);
br_s.max_age = smap_get_ullong(&br->cfg->other_config, "stp-max-age",
STP_DEFAULT_MAX_AGE / 1000) * 1000;
br_s.fwd_delay = smap_get_ullong(&br->cfg->other_config,
"stp-forward-delay",
STP_DEFAULT_FWD_DELAY / 1000) * 1000;
/* 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, 1, 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 void
bridge_configure_rstp(struct bridge *br, bool enable_rstp)
{
if (!enable_rstp) {
ofproto_set_rstp(br->ofproto, NULL);
} else {
struct ofproto_rstp_settings br_s;
const char *config_str;
struct port *port;
int port_num_counter;
config_str = smap_get(&br->cfg->other_config, "rstp-address");
if (config_str) {
struct eth_addr ea;
if (eth_addr_from_string(config_str, &ea)) {
br_s.address = eth_addr_to_uint64(ea);
}
else {
br_s.address = eth_addr_to_uint64(br->ea);
VLOG_ERR("bridge %s: invalid rstp-address, defaulting "
"to "ETH_ADDR_FMT, br->name, ETH_ADDR_ARGS(br->ea));
}
}
else {
br_s.address = eth_addr_to_uint64(br->ea);
}
const struct smap *oc = &br->cfg->other_config;
br_s.priority = smap_get_ullong(oc, "rstp-priority",
RSTP_DEFAULT_PRIORITY);
br_s.ageing_time = smap_get_ullong(oc, "rstp-ageing-time",
RSTP_DEFAULT_AGEING_TIME);
br_s.force_protocol_version = smap_get_ullong(
oc, "rstp-force-protocol-version", FPV_DEFAULT);
br_s.bridge_max_age = smap_get_ullong(oc, "rstp-max-age",
RSTP_DEFAULT_BRIDGE_MAX_AGE);
br_s.bridge_forward_delay = smap_get_ullong(
oc, "rstp-forward-delay", RSTP_DEFAULT_BRIDGE_FORWARD_DELAY);
br_s.transmit_hold_count = smap_get_ullong(
oc, "rstp-transmit-hold-count", RSTP_DEFAULT_TRANSMIT_HOLD_COUNT);
/* Configure RSTP on the bridge. */
if (ofproto_set_rstp(br->ofproto, &br_s)) {
VLOG_ERR("bridge %s: could not enable RSTP", br->name);
return;
}
port_num_counter = 0;
HMAP_FOR_EACH (port, hmap_node, &br->ports) {
struct ofproto_port_rstp_settings port_s;
struct iface *iface;
port_configure_rstp(br->ofproto, port, &port_s,
&port_num_counter);
/* As bonds are not supported, just apply configuration to
* all interfaces. */
LIST_FOR_EACH (iface, port_elem, &port->ifaces) {
if (ofproto_port_set_rstp(br->ofproto, iface->ofp_port,
&port_s)) {
VLOG_ERR("port %s: could not enable RSTP", port->name);
continue;
}
}
}
}
}
static void
bridge_configure_spanning_tree(struct bridge *br)
{
bool enable_rstp = br->cfg->rstp_enable;
bool enable_stp = br->cfg->stp_enable;
if (enable_rstp && enable_stp) {
VLOG_WARN("%s: RSTP and STP are mutually exclusive but both are "
"configured; enabling RSTP", br->name);
enable_stp = false;
}
bridge_configure_stp(br, enable_stp);
bridge_configure_rstp(br, enable_rstp);
}
static bool
bridge_has_bond_fake_iface(const struct bridge *br, const char *name)
{
const struct port *port = port_lookup(br, name);
return port && port_is_bond_fake_iface(port);
}
static bool
port_is_bond_fake_iface(const struct port *port)
{
return port->cfg->bond_fake_iface && !ovs_list_is_short(&port->ifaces);
}
static void
add_del_bridges(const struct ovsrec_open_vswitch *cfg)
{
struct bridge *br;
struct shash_node *node;
struct shash new_br;
size_t i;
/* 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 (strchr(br_cfg->name, '/') || strchr(br_cfg->name, '\\')) {
/* Prevent remote ovsdb-server users from accessing arbitrary
* directories, e.g. consider a bridge named "../../../etc/".
*
* Prohibiting "\" is only necessary on Windows but it's no great
* loss elsewhere. */
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);
}
}
/* Get rid of deleted bridges or those whose types have changed.
* Update 'cfg' of bridges that still exist. */
HMAP_FOR_EACH_SAFE (br, node, &all_bridges) {
br->cfg = shash_find_data(&new_br, br->name);
if (!br->cfg || strcmp(br->type, ofproto_normalize_type(
br->cfg->datapath_type))) {
bridge_destroy(br, true);
}
}
/* Add new bridges. */
SHASH_FOR_EACH(node, &new_br) {
const struct ovsrec_bridge *br_cfg = node->data;
if (!bridge_lookup(br_cfg->name)) {
bridge_create(br_cfg);
}
}
shash_destroy(&new_br);
}
/* Configures 'netdev' based on the "options" column in 'iface_cfg'.
* Returns 0 if successful, otherwise a positive errno value. */
static int
iface_set_netdev_config(const struct ovsrec_interface *iface_cfg,
struct netdev *netdev, char **errp)
{
return netdev_set_config(netdev, &iface_cfg->options, errp);
}
/* Opens a network device for 'if_cfg' and configures it. Adds the network
* device to br->ofproto and stores the OpenFlow port number in '*ofp_portp'.
*
* If successful, returns 0 and stores the network device in '*netdevp'. On
* failure, returns a positive errno value and stores NULL in '*netdevp'. */
static int
iface_do_create(const struct bridge *br,
const struct ovsrec_interface *iface_cfg,
ofp_port_t *ofp_portp, struct netdev **netdevp,
char **errp)
{
struct netdev *netdev = NULL;
int error;
const char *type;
if (netdev_is_reserved_name(iface_cfg->name)) {
VLOG_WARN("could not create interface %s, name is reserved",
iface_cfg->name);
error = EINVAL;
goto error;
}
type = ofproto_port_open_type(br->ofproto,
iface_get_type(iface_cfg, br->cfg));
error = netdev_open(iface_cfg->name, type, &netdev);
if (error) {
VLOG_WARN_BUF(errp, "could not open network device %s (%s)",
iface_cfg->name, ovs_strerror(error));
goto error;
}
error = iface_set_netdev_config(iface_cfg, netdev, errp);
if (error) {
goto error;
}
iface_set_netdev_mtu(iface_cfg, netdev);
*ofp_portp = iface_pick_ofport(iface_cfg);
error = ofproto_port_add(br->ofproto, netdev, ofp_portp);
if (error) {
static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
*errp = xasprintf("could not add network device %s to ofproto (%s)",
iface_cfg->name, ovs_strerror(error));
if (!VLOG_DROP_WARN(&rl)) {
VLOG_WARN("%s", *errp);
}
goto error;
}
VLOG_INFO("bridge %s: added interface %s on port %d",
br->name, iface_cfg->name, *ofp_portp);
*netdevp = netdev;
return 0;
error:
*netdevp = NULL;
netdev_close(netdev);
return error;
}
/* Creates a new iface on 'br' based on 'if_cfg'. The new iface has OpenFlow
* port number 'ofp_port'. If ofp_port is OFPP_NONE, an OpenFlow port is
* automatically allocated for the iface. Takes ownership of and
* deallocates 'if_cfg'.
*
* Return true if an iface is successfully created, false otherwise. */
static bool
iface_create(struct bridge *br, const struct ovsrec_interface *iface_cfg,
const struct ovsrec_port *port_cfg)
{
struct netdev *netdev;
struct iface *iface;
ofp_port_t ofp_port;
struct port *port;
char *errp = NULL;
int error;
/* Do the bits that can fail up front. */
ovs_assert(!iface_lookup(br, iface_cfg->name));
error = iface_do_create(br, iface_cfg, &ofp_port, &netdev, &errp);
if (error) {
iface_clear_db_record(iface_cfg, errp);
free(errp);
return false;
}
/* Get or create the port structure. */
port = port_lookup(br, port_cfg->name);
if (!port) {
port = port_create(br, port_cfg);
}
/* Create the iface structure. */
iface = xzalloc(sizeof *iface);
ovs_list_push_back(&port->ifaces, &iface->port_elem);
hmap_insert(&br->iface_by_name, &iface->name_node,
hash_string(iface_cfg->name, 0));
iface->port = port;
iface->name = xstrdup(iface_cfg->name);
iface->ofp_port = ofp_port;
iface->netdev = netdev;
iface->type = iface_get_type(iface_cfg, br->cfg);
iface->cfg = iface_cfg;
hmap_insert(&br->ifaces, &iface->ofp_port_node,
hash_ofp_port(ofp_port));
/* Populate initial status in database. */
iface_refresh_stats(iface);
iface_refresh_netdev_status(iface);
/* Add bond fake iface if necessary. */
if (port_is_bond_fake_iface(port)) {
struct ofproto_port ofproto_port;
if (ofproto_port_query_by_name(br->ofproto, port->name,
&ofproto_port)) {
error = netdev_open(port->name, "internal", &netdev);
if (!error) {
ofp_port_t fake_ofp_port = OFPP_NONE;
ofproto_port_add(br->ofproto, netdev, &fake_ofp_port);
netdev_close(netdev);
} else {
VLOG_WARN("could not open network device %s (%s)",
port->name, ovs_strerror(error));
}
} else {
/* Already exists, nothing to do. */
ofproto_port_destroy(&ofproto_port);
}
}
return true;
}
/* Set forward BPDU option. */
static void
bridge_configure_forward_bpdu(struct bridge *br)
{
ofproto_set_forward_bpdu(br->ofproto,
smap_get_bool(&br->cfg->other_config,
"forward-bpdu",
false));
}
/* Set MAC learning table configuration for 'br'. */
static void
bridge_configure_mac_table(struct bridge *br)
{
const struct smap *oc = &br->cfg->other_config;
int idle_time = smap_get_int(oc, "mac-aging-time", 0);
if (!idle_time) {
idle_time = MAC_ENTRY_DEFAULT_IDLE_TIME;
}
int mac_table_size = smap_get_int(oc, "mac-table-size", 0);
if (!mac_table_size) {
mac_table_size = MAC_DEFAULT_MAX;
}
ofproto_set_mac_table_config(br->ofproto, idle_time, mac_table_size);
}
/* Set multicast snooping table configuration for 'br'. */
static void
bridge_configure_mcast_snooping(struct bridge *br)
{
if (!br->cfg->mcast_snooping_enable) {
ofproto_set_mcast_snooping(br->ofproto, NULL);
} else {
struct port *port;
struct ofproto_mcast_snooping_settings br_s;
const struct smap *oc = &br->cfg->other_config;
int idle_time = smap_get_int(oc, "mcast-snooping-aging-time", 0);
br_s.idle_time = idle_time ? idle_time : MCAST_ENTRY_DEFAULT_IDLE_TIME;
int max_entries = smap_get_int(oc, "mcast-snooping-table-size", 0);
br_s.max_entries = (max_entries
? max_entries
: MCAST_DEFAULT_MAX_ENTRIES);
br_s.flood_unreg = !smap_get_bool(
oc, "mcast-snooping-disable-flood-unregistered", false);
/* Configure multicast snooping on the bridge */
if (ofproto_set_mcast_snooping(br->ofproto, &br_s)) {
VLOG_ERR("bridge %s: could not enable multicast snooping",
br->name);
return;
}
HMAP_FOR_EACH (port, hmap_node, &br->ports) {
struct ofproto_mcast_snooping_port_settings port_s;
port_s.flood = smap_get_bool(&port->cfg->other_config,
"mcast-snooping-flood", false);
port_s.flood_reports = smap_get_bool(&port->cfg->other_config,
"mcast-snooping-flood-reports", false);
if (ofproto_port_set_mcast_snooping(br->ofproto, port, &port_s)) {
VLOG_ERR("port %s: could not configure mcast snooping",
port->name);
}
}
}
}
static void
find_local_hw_addr(const struct bridge *br, struct eth_addr *ea,
const struct port *fake_br, struct iface **hw_addr_iface)
{
struct hmapx mirror_output_ports;
struct port *port;
bool found_addr = false;
int error;
int i;
/* 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 eth_addr iface_ea;
struct iface *candidate;
struct iface *iface;
/* Mirror output ports don't participate. */
if (hmapx_contains(&mirror_output_ports, port->cfg)) {
continue;
}
/* Choose the MAC address to represent the port. */
iface = NULL;
if (port->cfg->mac && eth_addr_from_string(port->cfg->mac,
&iface_ea)) {
/* Find the interface with this Ethernet address (if any) so that
* we can provide the correct devname to the caller. */
LIST_FOR_EACH (candidate, port_elem, &port->ifaces) {
struct eth_addr candidate_ea;
if (!netdev_get_etheraddr(candidate->netdev, &candidate_ea)
&& eth_addr_equals(iface_ea, candidate_ea)) {
iface = candidate;
}
}
} else {
/* Choose the interface whose MAC address will represent the port.
* The Linux kernel bonding code always chooses the MAC address of
* the first member added to a bond, and the Fedora networking
* scripts always add members to a bond in alphabetical order, so
* for compatibility we choose the interface with the name that is
* first in alphabetical order. */
LIST_FOR_EACH (candidate, port_elem, &port->ifaces) {
if (!iface || strcmp(candidate->name, iface->name) < 0) {
iface = candidate;
}
}
/* A port always has at least one interface. */
ovs_assert(iface != NULL);
/* The local port doesn't count (since we're trying to choose its
* MAC address anyway). */
if (iface->ofp_port == OFPP_LOCAL) {
continue;
}
/* For fake bridges we only choose from ports with the same tag */
if (fake_br && fake_br->cfg && fake_br->cfg->tag) {
if (!port->cfg->tag) {
continue;
}
if (*port->cfg->tag != *fake_br->cfg->tag) {
continue;
}
}
/* Grab MAC. */
error = netdev_get_etheraddr(iface->netdev, &iface_ea);
if (error) {
continue;
}
}
/* Compare against our current choice. */
if (!eth_addr_is_multicast(iface_ea) &&
!eth_addr_is_local(iface_ea) &&
!eth_addr_is_reserved(iface_ea) &&
!eth_addr_is_zero(iface_ea) &&
(!found_addr || eth_addr_compare_3way(iface_ea, *ea) < 0))
{
*ea = iface_ea;
*hw_addr_iface = iface;
found_addr = true;
}
}
if (!found_addr) {
*ea = br->default_ea;
*hw_addr_iface = NULL;
}
hmapx_destroy(&mirror_output_ports);
}
static void
bridge_pick_local_hw_addr(struct bridge *br, struct eth_addr *ea,
struct iface **hw_addr_iface)
{
*hw_addr_iface = NULL;
/* Did the user request a particular MAC? */
const char *hwaddr = smap_get_def(&br->cfg->other_config, "hwaddr", "");
if (eth_addr_from_string(hwaddr, ea)) {
if (eth_addr_is_multicast(*ea)) {
VLOG_ERR("bridge %s: cannot set MAC address to multicast "
"address "ETH_ADDR_FMT, br->name, ETH_ADDR_ARGS(*ea));
} else if (eth_addr_is_zero(*ea)) {
VLOG_ERR("bridge %s: cannot set MAC address to zero", br->name);
} else {
return;
}
}
/* Find a local hw address */
find_local_hw_addr(br, ea, NULL, hw_addr_iface);
}
/* Choose and returns the datapath ID for bridge 'br' given that the bridge
* Ethernet address is 'bridge_ea'. */
static uint64_t
bridge_pick_datapath_id(struct bridge *br,
const struct eth_addr bridge_ea)
{
/*
* The procedure for choosing a bridge MAC address will, in the most
* ordinary case, also choose a unique MAC that we can use as a datapath
* ID. In some special cases, though, multiple bridges will end up with
* the same MAC address. This is OK for the bridges, but it will confuse
* the OpenFlow controller, because each datapath needs a unique datapath
* ID.
*
* Datapath IDs must be unique. It is also very desirable that they be
* stable from one run to the next, so that policy set on a datapath
* "sticks".
*/
const char *datapath_id;
uint64_t dpid;
datapath_id = smap_get_def(&br->cfg->other_config, "datapath-id", "");
if (dpid_from_string(datapath_id, &dpid)) {
return dpid;
}
return eth_addr_to_uint64(bridge_ea);
}
static void
iface_refresh_netdev_status(struct iface *iface)
{
struct smap smap;
enum netdev_features current;
enum netdev_flags flags;
const char *link_state;
struct eth_addr mac;
int64_t bps, mtu_64, ifindex64, link_resets;
int mtu, error;
uint32_t mbps;
if (iface_is_synthetic(iface)) {
return;
}
if (iface->change_seq == netdev_get_change_seq(iface->netdev)
&& !status_txn_try_again) {
return;
}
iface->change_seq = netdev_get_change_seq(iface->netdev);
smap_init(&smap);
if (!netdev_get_status(iface->netdev, &smap)) {
ovsrec_interface_set_status(iface->cfg, &smap);
} else {
ovsrec_interface_set_status(iface->cfg, NULL);
}
smap_destroy(&smap);
error = netdev_get_flags(iface->netdev, &flags);
if (!error) {
const char *state = flags & NETDEV_UP ? "up" : "down";
ovsrec_interface_set_admin_state(iface->cfg, state);
} else {
ovsrec_interface_set_admin_state(iface->cfg, NULL);
}
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);
error = netdev_get_features(iface->netdev, &current, NULL, NULL, NULL);
if (!error) {
ovsrec_interface_set_duplex(iface->cfg,
netdev_features_is_full_duplex(current)
? "full" : "half");
} else {
ovsrec_interface_set_duplex(iface->cfg, NULL);
}
netdev_get_speed(iface->netdev, &mbps, NULL);
if (mbps) {
bps = mbps * 1000000ULL;
ovsrec_interface_set_link_speed(iface->cfg, &bps, 1);
} else {
ovsrec_interface_set_link_speed(iface->cfg, NULL, 0);
}
error = netdev_get_mtu(iface->netdev, &mtu);
if (!error) {
mtu_64 = mtu;
ovsrec_interface_set_mtu(iface->cfg, &mtu_64, 1);
} else {
ovsrec_interface_set_mtu(iface->cfg, NULL, 0);
}
error = netdev_get_etheraddr(iface->netdev, &mac);
if (!error) {
char mac_string[ETH_ADDR_STRLEN + 1];
snprintf(mac_string, sizeof mac_string,
ETH_ADDR_FMT, ETH_ADDR_ARGS(mac));
ovsrec_interface_set_mac_in_use(iface->cfg, mac_string);
} else {
ovsrec_interface_set_mac_in_use(iface->cfg, NULL);
}
/* The netdev may return a negative number (such as -EOPNOTSUPP)
* if there is no valid ifindex number. */
ifindex64 = netdev_get_ifindex(iface->netdev);
if (ifindex64 < 0) {
ifindex64 = 0;
}
ovsrec_interface_set_ifindex(iface->cfg, &ifindex64, 1);
}
static void
iface_refresh_ofproto_status(struct iface *iface)
{
int current;
int error;
char *errp = NULL;
if (iface_is_synthetic(iface)) {
return;
}
error = ofproto_vport_get_status(iface->port->bridge->ofproto,
iface->ofp_port, &errp);
if (error && error != EOPNOTSUPP) {
/* Need to verify to avoid race with transaction from
* 'bridge_reconfigure' that clears errors explicitly. */
ovsrec_interface_verify_error(iface->cfg);
ovsrec_interface_set_error(iface->cfg,
errp ? errp : ovs_strerror(error));
free(errp);
}
current = ofproto_port_is_lacp_current(iface->port->bridge->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);
}
if (ofproto_port_cfm_status_changed(iface->port->bridge->ofproto,
iface->ofp_port)
|| status_txn_try_again) {
iface_refresh_cfm_stats(iface);
}
if (ofproto_port_bfd_status_changed(iface->port->bridge->ofproto,
iface->ofp_port)
|| status_txn_try_again) {
struct smap smap;
smap_init(&smap);
ofproto_port_get_bfd_status(iface->port->bridge->ofproto,
iface->ofp_port, &smap);
ovsrec_interface_set_bfd_status(iface->cfg, &smap);
smap_destroy(&smap);
}
}
/* Writes 'iface''s CFM statistics to the database. 'iface' must not be
* synthetic. */
static void
iface_refresh_cfm_stats(struct iface *iface)
{
const struct ovsrec_interface *cfg = iface->cfg;
struct cfm_status status;
int error;
error = ofproto_port_get_cfm_status(iface->port->bridge->ofproto,
iface->ofp_port, &status);
if (error > 0) {
ovsrec_interface_set_cfm_fault(cfg, NULL, 0);
ovsrec_interface_set_cfm_fault_status(cfg, NULL, 0);
ovsrec_interface_set_cfm_remote_opstate(cfg, NULL);
ovsrec_interface_set_cfm_flap_count(cfg, NULL, 0);
ovsrec_interface_set_cfm_health(cfg, NULL, 0);
ovsrec_interface_set_cfm_remote_mpids(cfg, NULL, 0);
} else {
const char *reasons[CFM_FAULT_N_REASONS];
int64_t cfm_health = status.health;
int64_t cfm_flap_count = status.flap_count;
bool faulted = status.faults != 0;
size_t i, j;
ovsrec_interface_set_cfm_fault(cfg, &faulted, 1);
j = 0;
for (i = 0; i < CFM_FAULT_N_REASONS; i++) {
int reason = 1 << i;
if (status.faults & reason) {
reasons[j++] = cfm_fault_reason_to_str(reason);
}
}
ovsrec_interface_set_cfm_fault_status(cfg, reasons, j);
ovsrec_interface_set_cfm_flap_count(cfg, &cfm_flap_count, 1);
if (status.remote_opstate >= 0) {
const char *remote_opstate = status.remote_opstate ? "up" : "down";
ovsrec_interface_set_cfm_remote_opstate(cfg, remote_opstate);
} else {
ovsrec_interface_set_cfm_remote_opstate(cfg, NULL);
}
ovsrec_interface_set_cfm_remote_mpids(cfg,
(const int64_t *)status.rmps,
status.n_rmps);
if (cfm_health >= 0) {
ovsrec_interface_set_cfm_health(cfg, &cfm_health, 1);
} else {
ovsrec_interface_set_cfm_health(cfg, NULL, 0);
}
free(status.rmps);
}
}
static void
iface_refresh_stats(struct iface *iface)
{
struct netdev_custom_stats custom_stats;
struct netdev_stats stats;
int n;
uint32_t i, counters_size;
#define IFACE_STATS \
IFACE_STAT(rx_packets, "rx_packets") \
IFACE_STAT(tx_packets, "tx_packets") \
IFACE_STAT(rx_bytes, "rx_bytes") \
IFACE_STAT(tx_bytes, "tx_bytes") \
IFACE_STAT(rx_dropped, "rx_dropped") \
IFACE_STAT(tx_dropped, "tx_dropped") \
IFACE_STAT(rx_errors, "rx_errors") \
IFACE_STAT(tx_errors, "tx_errors") \
IFACE_STAT(rx_frame_errors, "rx_frame_err") \
IFACE_STAT(rx_over_errors, "rx_over_err") \
IFACE_STAT(rx_crc_errors, "rx_crc_err") \
IFACE_STAT(rx_missed_errors, "rx_missed_errors") \
IFACE_STAT(collisions, "collisions") \
IFACE_STAT(rx_1_to_64_packets, "rx_1_to_64_packets") \
IFACE_STAT(rx_65_to_127_packets, "rx_65_to_127_packets") \
IFACE_STAT(rx_128_to_255_packets, "rx_128_to_255_packets") \
IFACE_STAT(rx_256_to_511_packets, "rx_256_to_511_packets") \
IFACE_STAT(rx_512_to_1023_packets, "rx_512_to_1023_packets") \
IFACE_STAT(rx_1024_to_1522_packets, "rx_1024_to_1522_packets") \
IFACE_STAT(rx_1523_to_max_packets, "rx_1523_to_max_packets") \
IFACE_STAT(tx_1_to_64_packets, "tx_1_to_64_packets") \
IFACE_STAT(tx_65_to_127_packets, "tx_65_to_127_packets") \
IFACE_STAT(tx_128_to_255_packets, "tx_128_to_255_packets") \
IFACE_STAT(tx_256_to_511_packets, "tx_256_to_511_packets") \
IFACE_STAT(tx_512_to_1023_packets, "tx_512_to_1023_packets") \
IFACE_STAT(tx_1024_to_1522_packets, "tx_1024_to_1522_packets") \
IFACE_STAT(tx_1523_to_max_packets, "tx_1523_to_max_packets") \
IFACE_STAT(multicast, "rx_multicast_packets") \
IFACE_STAT(tx_multicast_packets, "tx_multicast_packets") \
IFACE_STAT(rx_broadcast_packets, "rx_broadcast_packets") \
IFACE_STAT(tx_broadcast_packets, "tx_broadcast_packets") \
IFACE_STAT(rx_undersized_errors, "rx_undersized_errors") \
IFACE_STAT(rx_oversize_errors, "rx_oversize_errors") \
IFACE_STAT(rx_fragmented_errors, "rx_fragmented_errors") \
IFACE_STAT(rx_jabber_errors, "rx_jabber_errors") \
IFACE_STAT(upcall_packets, "upcall_packets") \
IFACE_STAT(upcall_errors, "upcall_errors")
#define IFACE_STAT(MEMBER, NAME) + 1
enum { N_IFACE_STATS = IFACE_STATS };
#undef IFACE_STAT
if (iface_is_synthetic(iface)) {
return;
}
netdev_get_custom_stats(iface->netdev, &custom_stats);
counters_size = custom_stats.size + N_IFACE_STATS;
int64_t *values = xmalloc(counters_size * sizeof(int64_t));
const char **keys = xmalloc(counters_size * sizeof(char *));
/* Intentionally ignore return value, since errors will set 'stats' to
* all-1s, and we will deal with that correctly below. */
netdev_get_stats(iface->netdev, &stats);
/* Copy statistics into keys[] and values[]. */
n = 0;
#define IFACE_STAT(MEMBER, NAME) \
if (stats.MEMBER != UINT64_MAX) { \
keys[n] = NAME; \
values[n] = stats.MEMBER; \
n++; \
}
IFACE_STATS;
#undef IFACE_STAT
/* Copy custom statistics into keys[] and values[]. */
if (custom_stats.size && custom_stats.counters) {
for (i = 0 ; i < custom_stats.size ; i++) {
values[n] = custom_stats.counters[i].value;
keys[n] = custom_stats.counters[i].name;
n++;
}
}
ovs_assert(n <= counters_size);
ovsrec_interface_set_statistics(iface->cfg, keys, values, n);
#undef IFACE_STATS
free(values);
free(keys);
netdev_free_custom_stats_counters(&custom_stats);
}
static void
br_refresh_datapath_info(struct bridge *br)
{
const char *version;
version = (br->ofproto && br->ofproto->ofproto_class->get_datapath_version
? br->ofproto->ofproto_class->get_datapath_version(br->ofproto)
: NULL);
ovsrec_bridge_set_datapath_version(br->cfg,
version ? version : "<unknown>");
}
static void
br_refresh_stp_status(struct bridge *br)
{
struct smap smap = SMAP_INITIALIZER(&smap);
struct ofproto *ofproto = br->ofproto;
struct ofproto_stp_status status;
if (ofproto_get_stp_status(ofproto, &status)) {
return;
}
if (!status.enabled) {
ovsrec_bridge_set_status(br->cfg, NULL);
return;
}
smap_add_format(&smap, "stp_bridge_id", STP_ID_FMT,
STP_ID_ARGS(status.bridge_id));
smap_add_format(&smap, "stp_designated_root", STP_ID_FMT,
STP_ID_ARGS(status.designated_root));
smap_add_format(&smap, "stp_root_path_cost", "%d", status.root_path_cost);
ovsrec_bridge_set_status(br->cfg, &smap);
smap_destroy(&smap);
}
static void
port_refresh_stp_status(struct port *port)
{
struct ofproto *ofproto = port->bridge->ofproto;
struct iface *iface;
struct ofproto_port_stp_status status;
struct smap smap;
if (port_is_synthetic(port)) {
return;
}
/* STP doesn't currently support bonds. */
if (!ovs_list_is_singleton(&port->ifaces)) {
ovsrec_port_set_status(port->cfg, NULL);
return;
}
iface = CONTAINER_OF(ovs_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);
return;
}
/* Set Status column. */
smap_init(&smap);
smap_add_format(&smap, "stp_port_id", "%d", status.port_id);
smap_add(&smap, "stp_state", stp_state_name(status.state));
smap_add_format(&smap, "stp_sec_in_state", "%u", status.sec_in_state);
smap_add(&smap, "stp_role", stp_role_name(status.role));
ovsrec_port_set_status(port->cfg, &smap);
smap_destroy(&smap);
}
static void
port_refresh_stp_stats(struct port *port)
{
struct ofproto *ofproto = port->bridge->ofproto;
struct iface *iface;
struct ofproto_port_stp_stats stats;
const char *keys[3];
int64_t int_values[3];
if (port_is_synthetic(port)) {
return;
}
/* STP doesn't currently support bonds. */
if (!ovs_list_is_singleton(&port->ifaces)) {
return;
}
iface = CONTAINER_OF(ovs_list_front(&port->ifaces), struct iface, port_elem);
if (ofproto_port_get_stp_stats(ofproto, iface->ofp_port, &stats)) {
return;
}
if (!stats.enabled) {
ovsrec_port_set_statistics(port->cfg, NULL, NULL, 0);
return;
}
/* Set Statistics column. */
keys[0] = "stp_tx_count";
int_values[0] = stats.tx_count;
keys[1] = "stp_rx_count";
int_values[1] = stats.rx_count;
keys[2] = "stp_error_count";
int_values[2] = stats.error_count;
ovsrec_port_set_statistics(port->cfg, keys, int_values,
ARRAY_SIZE(int_values));
}
static void
br_refresh_rstp_status(struct bridge *br)
{
struct smap smap = SMAP_INITIALIZER(&smap);
struct ofproto *ofproto = br->ofproto;
struct ofproto_rstp_status status;
if (ofproto_get_rstp_status(ofproto, &status)) {
return;
}
if (!status.enabled) {
ovsrec_bridge_set_rstp_status(br->cfg, NULL);
return;
}
smap_add_format(&smap, "rstp_bridge_id", RSTP_ID_FMT,
RSTP_ID_ARGS(status.bridge_id));
smap_add_format(&smap, "rstp_root_path_cost", "%"PRIu32,
status.root_path_cost);
smap_add_format(&smap, "rstp_root_id", RSTP_ID_FMT,
RSTP_ID_ARGS(status.root_id));
smap_add_format(&smap, "rstp_designated_id", RSTP_ID_FMT,
RSTP_ID_ARGS(status.designated_id));
smap_add_format(&smap, "rstp_designated_port_id", RSTP_PORT_ID_FMT,
status.designated_port_id);
smap_add_format(&smap, "rstp_bridge_port_id", RSTP_PORT_ID_FMT,
status.bridge_port_id);
ovsrec_bridge_set_rstp_status(br->cfg, &smap);
smap_destroy(&smap);
}
static void
port_refresh_rstp_status(struct port *port)
{
struct ofproto *ofproto = port->bridge->ofproto;
struct iface *iface;
struct ofproto_port_rstp_status status;
struct smap smap;
if (port_is_synthetic(port)) {
return;
}
/* RSTP doesn't currently support bonds. */
if (!ovs_list_is_singleton(&port->ifaces)) {
ovsrec_port_set_rstp_status(port->cfg, NULL);
return;
}
iface = CONTAINER_OF(ovs_list_front(&port->ifaces), struct iface, port_elem);
if (ofproto_port_get_rstp_status(ofproto, iface->ofp_port, &status)) {
return;
}
if (!status.enabled) {
ovsrec_port_set_rstp_status(port->cfg, NULL);
return;
}
/* Set Status column. */
smap_init(&smap);
smap_add_format(&smap, "rstp_port_id", RSTP_PORT_ID_FMT,
status.port_id);
smap_add_format(&smap, "rstp_port_role", "%s",
rstp_port_role_name(status.role));
smap_add_format(&smap, "rstp_port_state", "%s",
rstp_state_name(status.state));
smap_add_format(&smap, "rstp_designated_bridge_id", RSTP_ID_FMT,
RSTP_ID_ARGS(status.designated_bridge_id));
smap_add_format(&smap, "rstp_designated_port_id", RSTP_PORT_ID_FMT,
status.designated_port_id);
smap_add_format(&smap, "rstp_designated_path_cost", "%"PRIu32,
status.designated_path_cost);
ovsrec_port_set_rstp_status(port->cfg, &smap);
smap_destroy(&smap);
}
static void
port_refresh_rstp_stats(struct port *port)
{
struct ofproto *ofproto = port->bridge->ofproto;
struct iface *iface;
struct ofproto_port_rstp_status status;
const char *keys[4];
int64_t int_values[4];
if (port_is_synthetic(port)) {
return;
}
/* RSTP doesn't currently support bonds. */
if (!ovs_list_is_singleton(&port->ifaces)) {
ovsrec_port_set_rstp_statistics(port->cfg, NULL, NULL, 0);
return;
}
iface = CONTAINER_OF(ovs_list_front(&port->ifaces), struct iface, port_elem);
if (ofproto_port_get_rstp_status(ofproto, iface->ofp_port, &status)) {
return;
}
if (!status.enabled) {
ovsrec_port_set_rstp_statistics(port->cfg, NULL, NULL, 0);
return;
}
/* Set Statistics column. */
keys[0] = "rstp_tx_count";
int_values[0] = status.tx_count;
keys[1] = "rstp_rx_count";
int_values[1] = status.rx_count;
keys[2] = "rstp_uptime";
int_values[2] = status.uptime;
keys[3] = "rstp_error_count";
int_values[3] = status.error_count;
ovsrec_port_set_rstp_statistics(port->cfg, keys, int_values,
ARRAY_SIZE(int_values));
}
static void
port_refresh_bond_status(struct port *port, bool force_update)
{
struct eth_addr mac;
/* Return if port is not a bond */
if (ovs_list_is_singleton(&port->ifaces)) {
return;
}
if (bond_get_changed_active_member(port->name, &mac, force_update)) {
struct ds mac_s;
ds_init(&mac_s);
ds_put_format(&mac_s, ETH_ADDR_FMT, ETH_ADDR_ARGS(mac));
ovsrec_port_set_bond_active_slave(port->cfg, ds_cstr(&mac_s));
ds_destroy(&mac_s);
}
}
static bool
enable_system_stats(const struct ovsrec_open_vswitch *cfg)
{
return smap_get_bool(&cfg->other_config, "enable-statistics", false);
}
static void
reconfigure_system_stats(const struct ovsrec_open_vswitch *cfg)
{
bool enable = enable_system_stats(cfg);
system_stats_enable(enable);
if (!enable) {
ovsrec_open_vswitch_set_statistics(cfg, NULL);
}
}
static void
run_system_stats(void)
{
const struct ovsrec_open_vswitch *cfg = ovsrec_open_vswitch_first(idl);
struct smap *stats;
stats = system_stats_run();
if (stats && cfg) {
struct ovsdb_idl_txn *txn;
struct ovsdb_datum datum;
txn = ovsdb_idl_txn_create(idl);
ovsdb_datum_from_smap(&datum, stats);
smap_destroy(stats);
ovsdb_idl_txn_write(&cfg->header_, &ovsrec_open_vswitch_col_statistics,
&datum);
ovsdb_idl_txn_commit(txn);
ovsdb_idl_txn_destroy(txn);
free(stats);
}
}
static const char *
ofp12_controller_role_to_str(enum ofp12_controller_role role)
{
switch (role) {
case OFPCR12_ROLE_EQUAL:
return "other";
case OFPCR12_ROLE_PRIMARY:
return "master";
case OFPCR12_ROLE_SECONDARY:
return "slave";
case OFPCR12_ROLE_NOCHANGE:
default:
return NULL;
}
}
static void
refresh_controller_status(void)
{
struct bridge *br;
/* Accumulate status for controllers on all bridges. */
HMAP_FOR_EACH (br, node, &all_bridges) {
struct shash info = SHASH_INITIALIZER(&info);
ofproto_get_ofproto_controller_info(br->ofproto, &info);
/* Update each controller of the bridge in the database with
* current status. */
struct ovsrec_controller **controllers;
size_t n_controllers = bridge_get_controllers(br, &controllers);
size_t i;
for (i = 0; i < n_controllers; i++) {
struct ovsrec_controller *cfg = controllers[i];
struct ofproto_controller_info *cinfo =
shash_find_data(&info, cfg->target);
/* cinfo is NULL when 'cfg->target' is a passive connection. */
if (cinfo) {
ovsrec_controller_set_is_connected(cfg, cinfo->is_connected);
const char *role = ofp12_controller_role_to_str(cinfo->role);
ovsrec_controller_set_role(cfg, role);
ovsrec_controller_set_status(cfg, &cinfo->pairs);
} else {
ovsrec_controller_set_is_connected(cfg, false);
ovsrec_controller_set_role(cfg, NULL);
ovsrec_controller_set_status(cfg, NULL);
}
}
ofproto_free_ofproto_controller_info(&info);
}
}
/* Update interface and mirror statistics if necessary. */
static void
run_stats_update(void)
{
const struct ovsrec_open_vswitch *cfg = ovsrec_open_vswitch_first(idl);
int stats_interval;
if (!cfg) {
return;
}
/* Statistics update interval should always be greater than or equal to
* 5000 ms. */
stats_interval = MAX(smap_get_int(&cfg->other_config,
"stats-update-interval",
5000), 5000);
if (stats_timer_interval != stats_interval) {
stats_timer_interval = stats_interval;
stats_timer = LLONG_MIN;
}
if (time_msec() >= stats_timer) {
enum ovsdb_idl_txn_status status;
/* Rate limit the update. Do not start a new update if the
* previous one is not done. */
if (!stats_txn) {
struct bridge *br;
stats_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;
LIST_FOR_EACH (iface, port_elem, &port->ifaces) {
iface_refresh_stats(iface);
}
port_refresh_stp_stats(port);
port_refresh_rstp_stats(port);
}
HMAP_FOR_EACH (m, hmap_node, &br->mirrors) {
mirror_refresh_stats(m);
}
}
refresh_controller_status();
}
status = ovsdb_idl_txn_commit(stats_txn);
if (status != TXN_INCOMPLETE) {
stats_timer = time_msec() + stats_timer_interval;
ovsdb_idl_txn_destroy(stats_txn);
stats_txn = NULL;
}
}
}
static void
stats_update_wait(void)
{
/* If the 'stats_txn' is non-null (transaction incomplete), waits for the
* transaction to complete. Otherwise, waits for the 'stats_timer'. */
if (stats_txn) {
ovsdb_idl_txn_wait(stats_txn);
} else {
poll_timer_wait_until(stats_timer);
}
}
/* Update bridge/port/interface status if necessary. */
static void
run_status_update(void)
{
if (!status_txn) {
uint64_t seq;
/* Rate limit the update. Do not start a new update if the
* previous one is not done. */
seq = seq_read(connectivity_seq_get());
if (seq != connectivity_seqno || status_txn_try_again) {
const struct ovsrec_open_vswitch *cfg =
ovsrec_open_vswitch_first(idl);
struct bridge *br;
connectivity_seqno = seq;
status_txn = ovsdb_idl_txn_create(idl);
dpdk_status(cfg);
HMAP_FOR_EACH (br, node, &all_bridges) {
struct port *port;
br_refresh_stp_status(br);
br_refresh_rstp_status(br);
br_refresh_datapath_info(br);
HMAP_FOR_EACH (port, hmap_node, &br->ports) {
struct iface *iface;
port_refresh_stp_status(port);
port_refresh_rstp_status(port);
port_refresh_bond_status(port, status_txn_try_again);
LIST_FOR_EACH (iface, port_elem, &port->ifaces) {
iface_refresh_netdev_status(iface);
iface_refresh_ofproto_status(iface);
}
}
}
}
}
/* Commit the transaction and get the status. If the transaction finishes,
* then destroy the transaction. Otherwise, keep it so that we can check
* progress the next time that this function is called. */
if (status_txn) {
enum ovsdb_idl_txn_status status;
status = ovsdb_idl_txn_commit(status_txn);
if (status != TXN_INCOMPLETE) {
ovsdb_idl_txn_destroy(status_txn);
status_txn = NULL;
/* Sets the 'status_txn_try_again' if the transaction fails. */
if (status == TXN_SUCCESS || status == TXN_UNCHANGED) {
status_txn_try_again = false;
} else {
status_txn_try_again = true;
}
}
}
/* Refresh AA port status if necessary. */
if (time_msec() >= aa_refresh_timer) {
struct bridge *br;
HMAP_FOR_EACH (br, node, &all_bridges) {
if (bridge_aa_need_refresh(br)) {
struct ovsdb_idl_txn *txn;
txn = ovsdb_idl_txn_create(idl);
bridge_aa_refresh_queued(br);
ovsdb_idl_txn_commit(txn);
ovsdb_idl_txn_destroy(txn);
}
}
aa_refresh_timer = time_msec() + AA_REFRESH_INTERVAL;
}
}
static void
status_update_wait(void)
{
/* If the 'status_txn' is non-null (transaction incomplete), waits for the
* transaction to complete. If the status update to database needs to be
* run again (transaction fails), registers a timeout in
* 'STATUS_CHECK_AGAIN_MSEC'. Otherwise, waits on the global connectivity
* sequence number. */
if (status_txn) {
ovsdb_idl_txn_wait(status_txn);
} else if (status_txn_try_again) {
poll_timer_wait_until(time_msec() + STATUS_CHECK_AGAIN_MSEC);
} else {
seq_wait(connectivity_seq_get(), connectivity_seqno);
}
}
static void
bridge_run__(void)
{
struct bridge *br;
struct sset types;
const char *type;
/* Let each datapath type do the work that it needs to do. */
sset_init(&types);
ofproto_enumerate_types(&types);
SSET_FOR_EACH (type, &types) {
ofproto_type_run(type);
}
sset_destroy(&types);
/* Let each bridge do the work that it needs to do. */
HMAP_FOR_EACH (br, node, &all_bridges) {
ofproto_run(br->ofproto);
}
}
void
bridge_run(void)
{
static struct ovsrec_open_vswitch null_cfg;
const struct ovsrec_open_vswitch *cfg;
ovsrec_open_vswitch_init(&null_cfg);
ovsdb_idl_run(idl);
if_notifier_run();
if (ovsdb_idl_is_lock_contended(idl)) {
static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 1);
struct bridge *br;
VLOG_ERR_RL(&rl, "another ovs-vswitchd process is running, "
"disabling this process (pid %ld) until it goes away",
(long int) getpid());
HMAP_FOR_EACH_SAFE (br, node, &all_bridges) {
bridge_destroy(br, false);
}
/* Since we will not be running system_stats_run() in this process
* with the current situation of multiple ovs-vswitchd daemons,
* disable system stats collection. */
system_stats_enable(false);
return;
} else if (!ovsdb_idl_has_lock(idl)
|| !ovsdb_idl_has_ever_connected(idl)) {
/* Returns if not holding the lock or not done retrieving db
* contents. */
return;
}
cfg = ovsrec_open_vswitch_first(idl);
if (cfg) {
netdev_set_flow_api_enabled(&cfg->other_config);
dpdk_init(&cfg->other_config);
userspace_tso_init(&cfg->other_config);
}
/* Initialize the ofproto library. This only needs to run once, but
* it must be done after the configuration is set. If the
* initialization has already occurred, bridge_init_ofproto()
* returns immediately. */
bridge_init_ofproto(cfg);
/* Once the value of flow-restore-wait is false, we no longer should
* check its value from the database. */
if (cfg && ofproto_get_flow_restore_wait()) {
ofproto_set_flow_restore_wait(smap_get_bool(&cfg->other_config,
"flow-restore-wait", false));
}
bridge_run__();
/* Re-configure SSL. We do this on every trip through the main loop,
* instead of just when the database changes, because the contents of the
* key and certificate files can change without the database changing.
*
* We do this before bridge_reconfigure() because that function might
* initiate SSL connections and thus requires SSL to be configured. */
if (cfg && cfg->ssl) {
const struct ovsrec_ssl *ssl = cfg->ssl;
stream_ssl_set_key_and_cert(ssl->private_key, ssl->certificate);
stream_ssl_set_ca_cert_file(ssl->ca_cert, ssl->bootstrap_ca_cert);
}
if (ovsdb_idl_get_seqno(idl) != idl_seqno ||
if_notifier_changed(ifnotifier)) {
struct ovsdb_idl_txn *txn;
idl_seqno = ovsdb_idl_get_seqno(idl);
txn = ovsdb_idl_txn_create(idl);
bridge_reconfigure(cfg ? cfg : &null_cfg);
if (cfg) {
ovsrec_open_vswitch_set_cur_cfg(cfg, cfg->next_cfg);
discover_types(cfg);
}
/* If we are completing our initial configuration for this run
* of ovs-vswitchd, then keep the transaction around to monitor
* it for completion. */
if (initial_config_done) {
/* Always sets the 'status_txn_try_again' to check again,
* in case that this transaction fails. */
status_txn_try_again = true;
ovsdb_idl_txn_commit(txn);
ovsdb_idl_txn_destroy(txn);
} else {
initial_config_done = true;
daemonize_txn = txn;
}
}
if (daemonize_txn) {
enum ovsdb_idl_txn_status status = ovsdb_idl_txn_commit(daemonize_txn);
if (status != TXN_INCOMPLETE) {
ovsdb_idl_txn_destroy(daemonize_txn);
daemonize_txn = NULL;
/* ovs-vswitchd has completed initialization, so allow the
* process that forked us to exit successfully. */
daemonize_complete();
vlog_enable_async();
VLOG_INFO_ONCE("%s (Open vSwitch) %s", program_name, VERSION);
}
}
run_stats_update();
run_status_update();
run_system_stats();
}
void
bridge_wait(void)
{
struct sset types;
const char *type;
ovsdb_idl_wait(idl);
if (daemonize_txn) {
ovsdb_idl_txn_wait(daemonize_txn);
}
if_notifier_wait();
sset_init(&types);
ofproto_enumerate_types(&types);
SSET_FOR_EACH (type, &types) {
ofproto_type_wait(type);
}
sset_destroy(&types);
if (!hmap_is_empty(&all_bridges)) {
struct bridge *br;
HMAP_FOR_EACH (br, node, &all_bridges) {
ofproto_wait(br->ofproto);
}
stats_update_wait();
status_update_wait();
}
system_stats_wait();
}
/* Adds some memory usage statistics for bridges into 'usage', for use with
* memory_report(). */
void
bridge_get_memory_usage(struct simap *usage)
{
struct bridge *br;
struct sset types;
const char *type;
sset_init(&types);
ofproto_enumerate_types(&types);
SSET_FOR_EACH (type, &types) {
ofproto_type_get_memory_usage(type, usage);
}
sset_destroy(&types);
HMAP_FOR_EACH (br, node, &all_bridges) {
ofproto_get_memory_usage(br->ofproto, usage);
}
ovsdb_idl_get_memory_usage(idl, usage);
}
/* QoS unixctl user interface functions. */
struct qos_unixctl_show_cbdata {
struct ds *ds;
struct iface *iface;
};
static void
qos_unixctl_show_queue(unsigned int queue_id,
const struct smap *details,
struct iface *iface,
struct ds *ds)
{
struct netdev_queue_stats stats;
struct smap_node *node;
int error;
ds_put_cstr(ds, "\n");
if (queue_id) {
ds_put_format(ds, "Queue %u:\n", queue_id);
} else {
ds_put_cstr(ds, "Default:\n");
}
SMAP_FOR_EACH (node, details) {
ds_put_format(ds, " %s: %s\n", node->key, node->value);
}
error = netdev_get_queue_stats(iface->netdev, queue_id, &stats);
if (!error) {
if (stats.tx_packets != UINT64_MAX) {
ds_put_format(ds, " tx_packets: %"PRIu64"\n", stats.tx_packets);
}
if (stats.tx_bytes != UINT64_MAX) {
ds_put_format(ds, " tx_bytes: %"PRIu64"\n", stats.tx_bytes);
}
if (stats.tx_errors != UINT64_MAX) {
ds_put_format(ds, " tx_errors: %"PRIu64"\n", stats.tx_errors);
}
} else {
ds_put_format(ds, " Failed to get statistics for queue %u: %s",
queue_id, ovs_strerror(error));
}
}
static void
qos_unixctl_show_types(struct unixctl_conn *conn, int argc OVS_UNUSED,
const char *argv[], void *aux OVS_UNUSED)
{
struct ds ds = DS_EMPTY_INITIALIZER;
struct sset types = SSET_INITIALIZER(&types);
struct iface *iface;
const char * types_name;
int error;
iface = iface_find(argv[1]);
if (!iface) {
unixctl_command_reply_error(conn, "no such interface");
return;
}
error = netdev_get_qos_types(iface->netdev, &types);
if (!error) {
if (!sset_is_empty(&types)) {
SSET_FOR_EACH (types_name, &types) {
ds_put_format(&ds, "QoS type: %s\n", types_name);
}
unixctl_command_reply(conn, ds_cstr(&ds));
} else {
ds_put_format(&ds, "No QoS types supported for interface: %s\n",
iface->name);
unixctl_command_reply(conn, ds_cstr(&ds));
}
} else {
ds_put_format(&ds, "%s: failed to retrieve supported QoS types (%s)",
iface->name, ovs_strerror(error));
unixctl_command_reply_error(conn, ds_cstr(&ds));
}
sset_destroy(&types);
ds_destroy(&ds);
}
static void
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 smap smap = SMAP_INITIALIZER(&smap);
struct iface *iface;
const char *type;
struct smap_node *node;
int error;
iface = iface_find(argv[1]);
if (!iface) {
unixctl_command_reply_error(conn, "no such interface");
return;
}
error = netdev_get_qos(iface->netdev, &type, &smap);
if (!error) {
if (*type != '\0') {
struct netdev_queue_dump dump;
struct smap details;
unsigned int queue_id;
ds_put_format(&ds, "QoS: %s %s\n", iface->name, type);
SMAP_FOR_EACH (node, &smap) {
ds_put_format(&ds, "%s: %s\n", node->key, node->value);
}
smap_init(&details);
NETDEV_QUEUE_FOR_EACH (&queue_id, &details, &dump, iface->netdev) {
qos_unixctl_show_queue(queue_id, &details, iface, &ds);
}
smap_destroy(&details);
unixctl_command_reply(conn, ds_cstr(&ds));
} else {
ds_put_format(&ds, "QoS not configured on %s\n", iface->name);
unixctl_command_reply(conn, ds_cstr(&ds));
}
} else {
ds_put_format(&ds, "%s: failed to retrieve QOS configuration (%s)\n",
iface->name, ovs_strerror(error));
unixctl_command_reply_error(conn, ds_cstr(&ds));
}
smap_destroy(&smap);
ds_destroy(&ds);
}
/* Bridge reconfiguration functions. */
static void
bridge_create(const struct ovsrec_bridge *br_cfg)
{
struct bridge *br;
ovs_assert(!bridge_lookup(br_cfg->name));
br = xzalloc(sizeof *br);
br->name = xstrdup(br_cfg->name);
br->type = xstrdup(ofproto_normalize_type(br_cfg->datapath_type));
br->cfg = br_cfg;
/* Derive the default Ethernet address from the bridge's UUID. This should
* be unique and it will be stable between ovs-vswitchd runs. */
memcpy(&br->default_ea, &br_cfg->header_.uuid, ETH_ADDR_LEN);
eth_addr_mark_random(&br->default_ea);
hmap_init(&br->ports);
hmap_init(&br->ifaces);
hmap_init(&br->iface_by_name);
hmap_init(&br->mirrors);
hmap_init(&br->mappings);
hmap_insert(&all_bridges, &br->node, hash_string(br->name, 0));
}
static void
bridge_destroy(struct bridge *br, bool del)
{
if (br) {
struct mirror *mirror;
struct port *port;
HMAP_FOR_EACH_SAFE (port, hmap_node, &br->ports) {
port_destroy(port);
}
HMAP_FOR_EACH_SAFE (mirror, hmap_node, &br->mirrors) {
mirror_destroy(mirror);
}
hmap_remove(&all_bridges, &br->node);
ofproto_destroy(br->ofproto, del);
hmap_destroy(&br->ifaces);
hmap_destroy(&br->ports);
hmap_destroy(&br->iface_by_name);
hmap_destroy(&br->mirrors);
hmap_destroy(&br->mappings);
free(br->name);
free(br->type);
free(br);
}
}
static struct bridge *
bridge_lookup(const char *name)
{
struct bridge *br;
HMAP_FOR_EACH_WITH_HASH (br, node, hash_string(name, 0), &all_bridges) {
if (!strcmp(br->name, name)) {
return br;
}
}
return NULL;
}
/* 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, int argc,
const char *argv[], void *aux OVS_UNUSED)
{
struct bridge *br;
struct ds results;
br = bridge_lookup(argv[argc - 1]);
if (!br) {
unixctl_command_reply_error(conn, "Unknown bridge");
return;
}
bool offload_stats = false;
for (int i = 1; i < argc - 1; i++) {
if (!strcmp(argv[i], "--offload-stats")) {
offload_stats = true;
}
}
ds_init(&results);
ofproto_get_all_flows(br->ofproto, &results, offload_stats);
unixctl_command_reply(conn, ds_cstr(&results));
ds_destroy(&results);
}
/* "bridge/reconnect [BRIDGE]": makes BRIDGE drop all of its controller
* 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, int argc,
const char *argv[], void *aux OVS_UNUSED)
{
struct bridge *br;
if (argc > 1) {
br = bridge_lookup(argv[1]);
if (!br) {
unixctl_command_reply_error(conn, "Unknown bridge");
return;
}
ofproto_reconnect_controllers(br->ofproto);
} else {
HMAP_FOR_EACH (br, node, &all_bridges) {
ofproto_reconnect_controllers(br->ofproto);
}
}
unixctl_command_reply(conn, NULL);
}
static size_t
bridge_get_controllers(const struct bridge *br,
struct ovsrec_controller ***controllersp)
{
struct ovsrec_controller **controllers;
size_t n_controllers;
controllers = br->cfg->controller;
n_controllers = br->cfg->n_controller;
if (n_controllers == 1 && !strcmp(controllers[0]->target, "none")) {
controllers = NULL;
n_controllers = 0;
}
if (controllersp) {
*controllersp = controllers;
}
return n_controllers;
}
static void
bridge_collect_wanted_ports(struct bridge *br,
struct shash *wanted_ports)
{
size_t i;
shash_init(wanted_ports);
for (i = 0; i < br->cfg->n_ports; i++) {
const char *name = br->cfg->ports[i]->name;
if (!shash_add_once(wanted_ports, name, br->cfg->ports[i])) {
VLOG_WARN("bridge %s: %s specified twice as bridge port",
br->name, name);
}
}
if (bridge_get_controllers(br, NULL)
&& !shash_find(wanted_ports, br->name)) {
VLOG_WARN("bridge %s: no port named %s, synthesizing one",
br->name, br->name);
ovsrec_interface_init(&br->synth_local_iface);
ovsrec_port_init(&br->synth_local_port);
br->synth_local_port.interfaces = &br->synth_local_ifacep;
br->synth_local_port.n_interfaces = 1;
br->synth_local_port.name = br->name;
br->synth_local_iface.name = br->name;
br->synth_local_iface.type = "internal";
br->synth_local_ifacep = &br->synth_local_iface;
shash_add(wanted_ports, br->name, &br->synth_local_port);
}
}
/* Deletes "struct port"s and "struct iface"s under 'br' which aren't
* consistent with 'br->cfg'. Updates 'br->if_cfg_queue' with interfaces which
* 'br' needs to complete its configuration. */
static void
bridge_del_ports(struct bridge *br, const struct shash *wanted_ports)
{
struct shash_node *port_node;
struct port *port;
/* Get rid of deleted ports.
* Get rid of deleted interfaces on ports that still exist. */
HMAP_FOR_EACH_SAFE (port, hmap_node, &br->ports) {
port->cfg = shash_find_data(wanted_ports, port->name);
if (!port->cfg) {
port_destroy(port);
} else {
port_del_ifaces(port);
}
}
/* Update iface->cfg and iface->type in interfaces that still exist. */
SHASH_FOR_EACH (port_node, wanted_ports) {
const struct ovsrec_port *port_rec = port_node->data;
size_t i;
for (i = 0; i < port_rec->n_interfaces; i++) {
const struct ovsrec_interface *cfg = port_rec->interfaces[i];
struct iface *iface = iface_lookup(br, cfg->name);
const char *type = iface_get_type(cfg, br->cfg);
if (iface) {
iface->cfg = cfg;
iface->type = type;
} else {
/* We will add new interfaces later. */
}
}
}
}
/* Configures the IP stack for 'br''s local interface properly according to the
* configuration in 'c'. */
static void
bridge_configure_local_iface_netdev(struct bridge *br,
struct ovsrec_controller *c)
{
struct netdev *netdev;
struct in_addr mask, gateway;
struct iface *local_iface;
struct in_addr ip;
/* If there's no local interface or no IP address, give up. */
local_iface = iface_from_ofp_port(br, OFPP_LOCAL);
if (!local_iface || !c->local_ip || !ip_parse(c->local_ip, &ip.s_addr)) {
return;
}
/* Bring up the local interface. */
netdev = local_iface->netdev;
netdev_turn_flags_on(netdev, NETDEV_UP, NULL);
/* Configure the IP address and netmask. */
if (!c->local_netmask
|| !ip_parse(c->local_netmask, &mask.s_addr)
|| !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));
}
/* Configure the default gateway. */
if (c->local_gateway
&& ip_parse(c->local_gateway, &gateway.s_addr)
&& gateway.s_addr) {
if (!netdev_add_router(netdev, gateway)) {
VLOG_INFO("bridge %s: configured gateway "IP_FMT,
br->name, IP_ARGS(gateway.s_addr));
}
}
}
/* 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".
*
* Also, if 'b_stoplen' bytes from 'b' are found to be equal to corresponding
* bytes from 'a', the function considers this success. Specify 'b_stoplen' as
* SIZE_MAX to compare all of 'a' to all of 'b' rather than just a prefix of
* 'b' against a prefix of 'a'.
*/
static bool
equal_pathnames(const char *a, const char *b, size_t b_stoplen)
{
const char *b_start = b;
for (;;) {
if (b - b_start >= b_stoplen) {
return true;
} else if (*a != *b) {
return false;
} else if (*a == '/') {
a += strspn(a, "/");
b += strspn(b, "/");
} else if (*a == '\0') {
return true;
} else {
a++;
b++;
}
}
}
static enum ofconn_type
get_controller_ofconn_type(const char *target, const char *type)
{
return (type
? (!strcmp(type, "primary") ? OFCONN_PRIMARY : OFCONN_SERVICE)
: (!vconn_verify_name(target) ? OFCONN_PRIMARY : OFCONN_SERVICE));
}
static void
bridge_configure_remotes(struct bridge *br,
const struct sockaddr_in *managers, size_t n_managers)
{
bool disable_in_band;
struct ovsrec_controller **controllers;
size_t n_controllers;
enum ofproto_fail_mode fail_mode;
/* Check if we should disable in-band control on this bridge. */
disable_in_band = smap_get_bool(&br->cfg->other_config, "disable-in-band",
false);
/* Set OpenFlow queue ID for in-band control. */
ofproto_set_in_band_queue(br->ofproto,
smap_get_int(&br->cfg->other_config,
"in-band-queue", -1));
if (disable_in_band) {
ofproto_set_extra_in_band_remotes(br->ofproto, NULL, 0);
} else {
ofproto_set_extra_in_band_remotes(br->ofproto, managers, n_managers);
}
n_controllers = (ofproto_get_flow_restore_wait() ? 0
: bridge_get_controllers(br, &controllers));
/* The set of controllers to pass down to ofproto. */
struct shash ocs = SHASH_INITIALIZER(&ocs);
/* Add managment controller. */
struct ofproto_controller *oc = xmalloc(sizeof *oc);
*oc = (struct ofproto_controller) {
.type = OFCONN_SERVICE,
.probe_interval = 60,
.band = OFPROTO_OUT_OF_BAND,
.enable_async_msgs = true,
.allowed_versions = bridge_get_allowed_versions(br),
.max_pktq_size = bridge_get_controller_queue_size(br, NULL),
};
shash_add_nocopy(
&ocs, xasprintf("punix:%s/%s.mgmt", ovs_rundir(), br->name), oc);
for (size_t i = 0; i < n_controllers; i++) {
struct ovsrec_controller *c = controllers[i];
if (daemon_should_self_confine()
&& (!strncmp(c->target, "punix:", 6)
|| !strncmp(c->target, "unix:", 5))) {
static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
char *allowed;
if (!strncmp(c->target, "unix:", 5)) {
/* Connect to a listening socket */
allowed = xasprintf("unix:%s/", ovs_rundir());
if (strchr(c->target, '/') &&
!equal_pathnames(c->target, allowed, strlen(allowed))) {
/* Absolute path specified, but not in ovs_rundir */
VLOG_ERR_RL(&rl, "bridge %s: Not connecting to socket "
"controller \"%s\" due to possibility for "
"remote exploit. Instead, specify socket "
"in permitted directory \"%s\" or connect to "
"\"unix:%s/%s.mgmt\" (which is always "
"available without special configuration).",
br->name, c->target, allowed,
ovs_rundir(), br->name);
free(allowed);
continue;
}
} else {
allowed = xasprintf("punix:%s/%s.",
ovs_rundir(), br->name);
if (!equal_pathnames(c->target, allowed, strlen(allowed))
|| strchr(c->target + strlen(allowed), '/')) {
/* 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 of "
"overwriting local files. Instead, specify "
"path in permitted format \"%s*\" or "
"connect to \"unix:%s/%s.mgmt\" (which is "
"always available without special "
"configuration).",
br->name, c->target, allowed,
ovs_rundir(), br->name);
free(allowed);
continue;
}
}
free(allowed);
}
bridge_configure_local_iface_netdev(br, c);
int dscp = smap_get_int(&c->other_config, "dscp", DSCP_DEFAULT);
if (dscp < 0 || dscp > 63) {
dscp = DSCP_DEFAULT;
}
oc = xmalloc(sizeof *oc);
*oc = (struct ofproto_controller) {
.type = get_controller_ofconn_type(c->target, c->type),
.max_backoff = c->max_backoff ? *c->max_backoff / 1000 : 8,
.probe_interval = (!c->inactivity_probe ? 5
: !*c->inactivity_probe ? 0
: *c->inactivity_probe < 1000 ? 1
: *c->inactivity_probe / 1000),
.band = ((!c->connection_mode
|| !strcmp(c->connection_mode, "in-band"))
&& !disable_in_band
? OFPROTO_IN_BAND : OFPROTO_OUT_OF_BAND),
.enable_async_msgs = (!c->enable_async_messages
|| *c->enable_async_messages),
.allowed_versions = bridge_get_allowed_versions(br),
.max_pktq_size = bridge_get_controller_queue_size(br, c),
.rate_limit = (c->controller_rate_limit
? *c->controller_rate_limit : 0),
.burst_limit = (c->controller_burst_limit
? *c->controller_burst_limit : 0),
.dscp = dscp,
};
shash_add(&ocs, c->target, oc);
}
ofproto_set_controllers(br->ofproto, &ocs);
shash_destroy_free_data(&ocs);
/* Set the fail-mode. */
fail_mode = !br->cfg->fail_mode
|| !strcmp(br->cfg->fail_mode, "standalone")
? OFPROTO_FAIL_STANDALONE
: OFPROTO_FAIL_SECURE;
ofproto_set_fail_mode(br->ofproto, fail_mode);
/* Configure OpenFlow controller connection snooping. */
if (!ofproto_has_snoops(br->ofproto)) {
struct sset snoops;
sset_init(&snoops);
sset_add_and_free(&snoops, xasprintf("punix:%s/%s.snoop",
ovs_rundir(), br->name));
ofproto_set_snoops(br->ofproto, &snoops);
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;
bool use_default_prefixes = true;
s.name = NULL;
s.max_flows = UINT_MAX;
s.groups = NULL;
s.enable_eviction = false;
s.n_groups = 0;
s.n_prefix_fields = 0;
memset(s.prefix_fields, ~0, sizeof(s.prefix_fields));
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;
}
s.enable_eviction = (cfg->overflow_policy
&& !strcmp(cfg->overflow_policy, "evict"));
if (cfg->n_groups) {
s.groups = xmalloc(cfg->n_groups * sizeof *s.groups);
for (int 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++;
}
}
}
/* Prefix lookup fields. */
s.n_prefix_fields = 0;
for (int k = 0; k < cfg->n_prefixes; k++) {
const char *name = cfg->prefixes[k];
const struct mf_field *mf;
if (strcmp(name, "none") == 0) {
use_default_prefixes = false;
s.n_prefix_fields = 0;
break;
}
mf = mf_from_name(name);
if (!mf) {
VLOG_WARN("bridge %s: 'prefixes' with unknown field: %s",
br->name, name);
continue;
}
if (mf->flow_be32ofs < 0 || mf->n_bits % 32) {
VLOG_WARN("bridge %s: 'prefixes' with incompatible field: "
"%s", br->name, name);
continue;
}
if (s.n_prefix_fields >= ARRAY_SIZE(s.prefix_fields)) {
VLOG_WARN("bridge %s: 'prefixes' with too many fields, "
"field not used: %s", br->name, name);
continue;
}
use_default_prefixes = false;
s.prefix_fields[s.n_prefix_fields++] = mf->id;
}
}
if (use_default_prefixes) {
/* Use default values. */
s.n_prefix_fields = ARRAY_SIZE(default_prefix_fields);
memcpy(s.prefix_fields, default_prefix_fields,
sizeof default_prefix_fields);
} else {
struct ds ds = DS_EMPTY_INITIALIZER;
for (int k = 0; k < s.n_prefix_fields; k++) {
if (k) {
ds_put_char(&ds, ',');
}
ds_put_cstr(&ds, mf_from_id(s.prefix_fields[k])->name);
}
if (s.n_prefix_fields == 0) {
ds_put_cstr(&ds, "none");
}
VLOG_INFO("bridge %s table %d: Prefix lookup with: %s.",
br->name, i, ds_cstr(&ds));
ds_destroy(&ds);
}
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]);
}
}
static void
bridge_configure_dp_desc(struct bridge *br)
{
ofproto_set_dp_desc(br->ofproto,
smap_get(&br->cfg->other_config, "dp-desc"));
}
static void
bridge_configure_serial_desc(struct bridge *br)
{
ofproto_set_serial_desc(br->ofproto,
smap_get(&br->cfg->other_config, "dp-sn"));
}
static struct aa_mapping *
bridge_aa_mapping_find(struct bridge *br, const int64_t isid)
{
struct aa_mapping *m;
HMAP_FOR_EACH_IN_BUCKET (m,
hmap_node,
hash_bytes(&isid, sizeof isid, 0),
&br->mappings) {
if (isid == m->isid) {
return m;
}
}
return NULL;
}
static struct aa_mapping *
bridge_aa_mapping_create(struct bridge *br,
const int64_t isid,
const int64_t vlan)
{
struct aa_mapping *m;
m = xzalloc(sizeof *m);
m->bridge = br;
m->isid = isid;
m->vlan = vlan;
m->br_name = xstrdup(br->name);
hmap_insert(&br->mappings,
&m->hmap_node,
hash_bytes(&isid, sizeof isid, 0));
return m;
}
static void
bridge_aa_mapping_destroy(struct aa_mapping *m)
{
if (m) {
struct bridge *br = m->bridge;
if (br->ofproto) {
ofproto_aa_mapping_unregister(br->ofproto, m);
}
hmap_remove(&br->mappings, &m->hmap_node);
if (m->br_name) {
free(m->br_name);
}
free(m);
}
}
static bool
bridge_aa_mapping_configure(struct aa_mapping *m)
{
struct aa_mapping_settings s;
s.isid = m->isid;
s.vlan = m->vlan;
/* Configure. */
ofproto_aa_mapping_register(m->bridge->ofproto, m, &s);
return true;
}
static void
bridge_configure_aa(struct bridge *br)
{
const struct ovsdb_datum *mc;
struct ovsrec_autoattach *auto_attach = br->cfg->auto_attach;
struct aa_settings aa_s;
struct aa_mapping *m;
size_t i;
if (!auto_attach) {
ofproto_set_aa(br->ofproto, NULL, NULL);
return;
}
memset(&aa_s, 0, sizeof aa_s);
aa_s.system_description = auto_attach->system_description;
aa_s.system_name = auto_attach->system_name;
ofproto_set_aa(br->ofproto, NULL, &aa_s);
mc = ovsrec_autoattach_get_mappings(auto_attach,
OVSDB_TYPE_INTEGER,
OVSDB_TYPE_INTEGER);
HMAP_FOR_EACH_SAFE (m, hmap_node, &br->mappings) {
union ovsdb_atom atom;
atom.integer = m->isid;
if (!ovsdb_datum_find_key(mc, &atom, OVSDB_TYPE_INTEGER, NULL)) {
VLOG_INFO("Deleting isid=%"PRIu32", vlan=%"PRIu16,
m->isid, m->vlan);
bridge_aa_mapping_destroy(m);
}
}
/* Add new mappings and reconfigure existing ones. */
for (i = 0; i < auto_attach->n_mappings; ++i) {
m = bridge_aa_mapping_find(br, auto_attach->key_mappings[i]);
if (!m) {
VLOG_INFO("Adding isid=%"PRId64", vlan=%"PRId64,
auto_attach->key_mappings[i],
auto_attach->value_mappings[i]);
m = bridge_aa_mapping_create(br,
auto_attach->key_mappings[i],
auto_attach->value_mappings[i]);
if (!bridge_aa_mapping_configure(m)) {
bridge_aa_mapping_destroy(m);
}
}
}
}
static bool
bridge_aa_need_refresh(struct bridge *br)
{
return ofproto_aa_vlan_get_queue_size(br->ofproto) > 0;
}
static void
bridge_aa_update_trunks(struct port *port, struct bridge_aa_vlan *m)
{
int64_t *trunks = NULL;
unsigned int i = 0;
bool found = false, reconfigure = false;
for (i = 0; i < port->cfg->n_trunks; i++) {
if (port->cfg->trunks[i] == m->vlan) {
found = true;
break;
}
}
switch (m->oper) {
case BRIDGE_AA_VLAN_OPER_ADD:
if (!found) {
trunks = xmalloc(sizeof *trunks * (port->cfg->n_trunks + 1));
for (i = 0; i < port->cfg->n_trunks; i++) {
trunks[i] = port->cfg->trunks[i];
}
trunks[i++] = m->vlan;
reconfigure = true;
}
break;
case BRIDGE_AA_VLAN_OPER_REMOVE:
if (found) {
unsigned int j = 0;
trunks = xmalloc(sizeof *trunks * (port->cfg->n_trunks - 1));
for (i = 0; i < port->cfg->n_trunks; i++) {
if (port->cfg->trunks[i] != m->vlan) {
trunks[j++] = port->cfg->trunks[i];
}
}
i = j;
reconfigure = true;
}
break;
case BRIDGE_AA_VLAN_OPER_UNDEF:
default:
VLOG_WARN("unrecognized operation %u", m->oper);
break;
}
if (reconfigure) {
/* VLAN switching under trunk mode cause the trunk port to switch all
* VLANs, see ovs-vswitchd.conf.db
*/
if (i == 0) {
static char *vlan_mode_access = "access";
ovsrec_port_set_vlan_mode(port->cfg, vlan_mode_access);
}
if (i == 1) {
static char *vlan_mode_trunk = "trunk";
ovsrec_port_set_vlan_mode(port->cfg, vlan_mode_trunk);
}
ovsrec_port_set_trunks(port->cfg, trunks, i);
/* Force reconfigure of the port. */
port_configure(port);
}
free(trunks);
}
static void
bridge_aa_refresh_queued(struct bridge *br)
{
struct ovs_list *list = xmalloc(sizeof *list);
struct bridge_aa_vlan *node;
ovs_list_init(list);
ofproto_aa_vlan_get_queued(br->ofproto, list);
LIST_FOR_EACH_SAFE (node, list_node, list) {
struct port *port;
VLOG_INFO("ifname=%s, vlan=%u, oper=%u", node->port_name, node->vlan,
node->oper);
port = port_lookup(br, node->port_name);
if (port) {
bridge_aa_update_trunks(port, node);
}
ovs_list_remove(&node->list_node);
free(node->port_name);
free(node);
}
free(list);
}
/* Port functions. */
static struct port *
port_create(struct bridge *br, const struct ovsrec_port *cfg)
{
struct port *port;
port = xzalloc(sizeof *port);
port->bridge = br;
port->name = xstrdup(cfg->name);
port->cfg = cfg;
ovs_list_init(&port->ifaces);
hmap_insert(&br->ports, &port->hmap_node, hash_string(port->name, 0));
return port;
}
/* Deletes interfaces from 'port' that are no longer configured for it. */
static void
port_del_ifaces(struct port *port)
{
struct iface *iface;
struct sset new_ifaces;
size_t i;
/* Collect list of new interfaces. */
sset_init(&new_ifaces);
for (i = 0; i < port->cfg->n_interfaces; i++) {
sset_add(&new_ifaces, port->cfg->interfaces[i]->name);
}
/* Get rid of deleted interfaces. */
LIST_FOR_EACH_SAFE (iface, port_elem, &port->ifaces) {
if (!sset_contains(&new_ifaces, iface->name)) {
iface_destroy(iface);
}
}
sset_destroy(&new_ifaces);
}
static void
port_destroy(struct port *port)
{
if (port) {
struct bridge *br = port->bridge;
struct iface *iface;
if (br->ofproto) {
ofproto_bundle_unregister(br->ofproto, port);
}
LIST_FOR_EACH_SAFE (iface, port_elem, &port->ifaces) {
iface_destroy__(iface);
}
hmap_remove(&br->ports, &port->hmap_node);
free(port->name);
free(port);
}
}
static struct port *
port_lookup(const struct bridge *br, const char *name)
{
struct port *port;
HMAP_FOR_EACH_WITH_HASH (port, hmap_node, hash_string(name, 0),
&br->ports) {
if (!strcmp(port->name, name)) {
return port;
}
}
return NULL;
}
static bool
enable_lacp(struct port *port, bool *activep)
{
if (!port->cfg->lacp) {
/* XXX when LACP implementation has been sufficiently tested, enable by
* default and make active on bonded ports. */
return false;
} else if (!strcmp(port->cfg->lacp, "off")) {
return false;
} else if (!strcmp(port->cfg->lacp, "active")) {
*activep = true;
return true;
} else if (!strcmp(port->cfg->lacp, "passive")) {
*activep = false;
return true;
} else {
VLOG_WARN("port %s: unknown LACP mode %s",
port->name, port->cfg->lacp);
return false;
}
}
static struct lacp_settings *
port_configure_lacp(struct port *port, struct lacp_settings *s)
{
const char *lacp_time, *system_id;
int priority;
if (!enable_lacp(port, &s->active)) {
return NULL;
}
s->name = port->name;
system_id = smap_get(&port->cfg->other_config, "lacp-system-id");
if (system_id) {
if (!ovs_scan(system_id, ETH_ADDR_SCAN_FMT,
ETH_ADDR_SCAN_ARGS(s->id))) {
VLOG_WARN("port %s: LACP system ID (%s) must be an Ethernet"
" address.", port->name, system_id);
return NULL;
}
} else {
s->id = port->bridge->ea;
}
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 = smap_get_int(&port->cfg->other_config, "lacp-system-priority",
0);
s->priority = (priority > 0 && priority <= UINT16_MAX
? priority
: UINT16_MAX - !ovs_list_is_short(&port->ifaces));
lacp_time = smap_get_def(&port->cfg->other_config, "lacp-time", "");
s->fast = !strcasecmp(lacp_time, "fast");
s->fallback_ab_cfg = smap_get_bool(&port->cfg->other_config,
"lacp-fallback-ab", false);
return s;
}
static void
iface_configure_lacp(struct iface *iface, struct lacp_member_settings *s)
{
int priority, portid, key;
portid = smap_get_int(&iface->cfg->other_config, "lacp-port-id", 0);
priority = smap_get_int(&iface->cfg->other_config, "lacp-port-priority",
0);
key = smap_get_int(&iface->cfg->other_config, "lacp-aggregation-key", 0);
if (portid <= 0 || portid > UINT16_MAX) {
portid = ofp_to_u16(iface->ofp_port);
}
if (priority <= 0 || priority > UINT16_MAX) {
priority = UINT16_MAX;
}
if (key < 0 || key > UINT16_MAX) {
key = 0;
}
s->name = iface->name;
s->id = portid;
s->priority = priority;
s->key = key;
}
static void
port_configure_bond(struct port *port, struct bond_settings *s)
{
const char *detect_s;
struct iface *iface;
const char *mac_s;
int miimon_interval;
s->name = port->name;
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, "
"please use another bond type or disable flood_vlans",
port->name);
}
miimon_interval = smap_get_int(&port->cfg->other_config,
"bond-miimon-interval", 0);
if (miimon_interval <= 0) {
miimon_interval = 200;
}
detect_s = smap_get(&port->cfg->other_config, "bond-detect-mode");
if (!detect_s || !strcmp(detect_s, "carrier")) {
miimon_interval = 0;
} else if (strcmp(detect_s, "miimon")) {
VLOG_WARN("port %s: unsupported bond-detect-mode %s, "
"defaulting to carrier", port->name, detect_s);
miimon_interval = 0;
}
s->up_delay = MAX(0, port->cfg->bond_updelay);
s->down_delay = MAX(0, port->cfg->bond_downdelay);
s->basis = smap_get_int(&port->cfg->other_config, "bond-hash-basis", 0);
s->rebalance_interval = smap_get_int(&port->cfg->other_config,
"bond-rebalance-interval", 10000);
if (s->rebalance_interval && s->rebalance_interval < 1000) {
s->rebalance_interval = 1000;
}
s->lacp_fallback_ab_cfg = smap_get_bool(&port->cfg->other_config,
"lacp-fallback-ab", false);
s->primary = NULL;
if (s->balance == BM_AB || s->lacp_fallback_ab_cfg) {
s->primary = smap_get(&port->cfg->other_config, "bond-primary");
}
LIST_FOR_EACH (iface, port_elem, &port->ifaces) {
netdev_set_miimon_interval(iface->netdev, miimon_interval);
}
mac_s = port->cfg->bond_active_slave;
if (!mac_s || !ovs_scan(mac_s, ETH_ADDR_SCAN_FMT,
ETH_ADDR_SCAN_ARGS(s->active_member_mac))) {
/* OVSDB did not store the last active interface */
s->active_member_mac = eth_addr_zero;
}
/* lb_output action is disabled by default. */
s->use_lb_output_action = (s->balance == BM_TCP)
&& smap_get_bool(&port->cfg->other_config,
"lb-output-action", false);
/* all_members_active is disabled by default. */
s->all_members_active = smap_get_bool(&port->cfg->other_config,
"all-members-active", false);
}
/* 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. */
static bool
iface_is_internal(const struct ovsrec_interface *iface,
const struct ovsrec_bridge *br)
{
/* The local port and "internal" ports are always "internal". */
return !strcmp(iface->type, "internal") || !strcmp(iface->name, br->name);
}
/* Returns the correct network device type for interface 'iface' in bridge
* 'br'. */
static const char *
iface_get_type(const struct ovsrec_interface *iface,
const struct ovsrec_bridge *br)
{
const char *type;
/* The local port always has type "internal". Other ports take
* their type from the database and default to "system" if none is
* specified. */
if (iface_is_internal(iface, br)) {
type = "internal";
} else {
type = iface->type[0] ? iface->type : "system";
}
return type;
}
static void
iface_destroy__(struct iface *iface)
{
if (iface) {
struct port *port = iface->port;
struct bridge *br = port->bridge;
VLOG_INFO("bridge %s: deleted interface %s on port %d",
br->name, iface->name, iface->ofp_port);
if (br->ofproto && iface->ofp_port != OFPP_NONE) {
ofproto_port_unregister(br->ofproto, iface->ofp_port);
}
if (iface->ofp_port != OFPP_NONE) {
hmap_remove(&br->ifaces, &iface->ofp_port_node);
}
ovs_list_remove(&iface->port_elem);
hmap_remove(&br->iface_by_name, &iface->name_node);
tnl_port_map_delete_ipdev(netdev_get_name(iface->netdev));
/* The user is changing configuration here, so netdev_remove needs to be
* used as opposed to netdev_close */
netdev_remove(iface->netdev);
free(iface->name);
free(iface);
}
}
static void
iface_destroy(struct iface *iface)
{
if (iface) {
struct port *port = iface->port;
iface_destroy__(iface);
if (ovs_list_is_empty(&port->ifaces)) {
port_destroy(port);
}
}
}
static struct iface *
iface_lookup(const struct bridge *br, const char *name)
{
struct iface *iface;
HMAP_FOR_EACH_WITH_HASH (iface, name_node, hash_string(name, 0),
&br->iface_by_name) {
if (!strcmp(iface->name, name)) {
return iface;
}
}
return NULL;
}
static struct iface *
iface_find(const char *name)
{
const struct bridge *br;
HMAP_FOR_EACH (br, node, &all_bridges) {
struct iface *iface = iface_lookup(br, name);
if (iface) {
return iface;
}
}
return NULL;
}
static struct iface *
iface_from_ofp_port(const struct bridge *br, ofp_port_t ofp_port)
{
struct iface *iface;
HMAP_FOR_EACH_IN_BUCKET (iface, ofp_port_node, hash_ofp_port(ofp_port),
&br->ifaces) {
if (iface->ofp_port == ofp_port) {
return iface;
}
}
return NULL;
}
/* Set Ethernet address of 'iface', if one is specified in the configuration
* file. */
static void
iface_set_mac(const struct bridge *br, const struct port *port, struct iface *iface)
{
struct eth_addr ea, *mac = NULL;
struct iface *hw_addr_iface;
if (strcmp(iface->type, "internal")) {
return;
}
if (iface->cfg->mac && eth_addr_from_string(iface->cfg->mac, &ea)) {
mac = &ea;
} else if (port->cfg->fake_bridge) {
/* Fake bridge and no MAC set in the configuration. Pick a local one. */
find_local_hw_addr(br, &ea, port, &hw_addr_iface);
mac = &ea;
}
if (mac) {
if (iface->ofp_port == OFPP_LOCAL) {
VLOG_ERR("interface %s: ignoring mac in Interface record "
"(use Bridge record to set local port's mac)",
iface->name);
} else if (eth_addr_is_multicast(*mac)) {
VLOG_ERR("interface %s: cannot set MAC to multicast address",
iface->name);
} else if (eth_addr_is_zero(*mac)) {
VLOG_ERR("interface %s: cannot set MAC to all zero address",
iface->name);
} else {
int error = netdev_set_etheraddr(iface->netdev, *mac);
if (error) {
VLOG_ERR("interface %s: setting MAC failed (%s)",
iface->name, ovs_strerror(error));
}
}
}
}
/* Sets the ofport column of 'if_cfg' to 'ofport'. */
static void
iface_set_ofport(const struct ovsrec_interface *if_cfg, ofp_port_t ofport)
{
if (if_cfg && !ovsdb_idl_row_is_synthetic(&if_cfg->header_)) {
int64_t port = ofport == OFPP_NONE ? -1 : ofp_to_u16(ofport);
ovsrec_interface_set_ofport(if_cfg, &port, 1);
}
}
/* 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, char *errp)
{
if (!ovsdb_idl_row_is_synthetic(&if_cfg->header_)) {
iface_set_ofport(if_cfg, OFPP_NONE);
ovsrec_interface_set_error(if_cfg, errp);
ovsrec_interface_set_status(if_cfg, NULL);
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_mac_in_use(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);
ovsrec_interface_set_ifindex(if_cfg, NULL, 0);
}
}
static bool
queue_ids_include(const struct ovsdb_datum *queues, int64_t target)
{
union ovsdb_atom atom;
atom.integer = target;
return ovsdb_datum_find_key(queues, &atom, OVSDB_TYPE_INTEGER, NULL);
}
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') {
netdev_set_qos(iface->netdev, NULL, NULL);
} else {
const struct ovsdb_datum *queues;
struct netdev_queue_dump dump;
unsigned int queue_id;
struct smap details;
bool queue_zero;
size_t i;
/* Configure top-level Qos for 'iface'. */
netdev_set_qos(iface->netdev, qos->type, &qos->other_config);
/* Deconfigure queues that were deleted. */
queues = ovsrec_qos_get_queues(qos, OVSDB_TYPE_INTEGER,
OVSDB_TYPE_UUID);
smap_init(&details);
NETDEV_QUEUE_FOR_EACH (&queue_id, &details, &dump, iface->netdev) {
if (!queue_ids_include(queues, queue_id)) {
netdev_delete_queue(iface->netdev, queue_id);
}
}
smap_destroy(&details);
/* Configure queues for 'iface'. */
queue_zero = false;
for (i = 0; i < qos->n_queues; i++) {
const struct ovsrec_queue *queue = qos->value_queues[i];
queue_id = qos->key_queues[i];
if (queue_id == 0) {
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];
}
netdev_set_queue(iface->netdev, queue_id, &queue->other_config);
}
if (!queue_zero) {
smap_init(&details);
netdev_set_queue(iface->netdev, 0, &details);
smap_destroy(&details);
}
}
if (iface->ofp_port != OFPP_NONE) {
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,
MIN(UINT32_MAX, iface->cfg->ingress_policing_rate),
MIN(UINT32_MAX, iface->cfg->ingress_policing_burst),
MIN(UINT32_MAX, iface->cfg->ingress_policing_kpkts_rate),
MIN(UINT32_MAX, iface->cfg->ingress_policing_kpkts_burst));
ofpbuf_uninit(&queues_buf);
}
static void
iface_configure_cfm(struct iface *iface)
{
const struct ovsrec_interface *cfg = iface->cfg;
const char *opstate_str;
const char *cfm_ccm_vlan;
struct cfm_settings s;
struct smap netdev_args;
if (!cfg->n_cfm_mpid) {
ofproto_port_clear_cfm(iface->port->bridge->ofproto, iface->ofp_port);
return;
}
s.check_tnl_key = false;
smap_init(&netdev_args);
if (!netdev_get_config(iface->netdev, &netdev_args)) {
const char *key = smap_get(&netdev_args, "key");
const char *in_key = smap_get(&netdev_args, "in_key");
s.check_tnl_key = (key && !strcmp(key, "flow"))
|| (in_key && !strcmp(in_key, "flow"));
}
smap_destroy(&netdev_args);
s.mpid = *cfg->cfm_mpid;
s.interval = smap_get_int(&iface->cfg->other_config, "cfm_interval", 0);
cfm_ccm_vlan = smap_get(&iface->cfg->other_config, "cfm_ccm_vlan");
s.ccm_pcp = smap_get_int(&iface->cfg->other_config, "cfm_ccm_pcp", 0);
if (s.interval <= 0) {
s.interval = 1000;
}
if (!cfm_ccm_vlan) {
s.ccm_vlan = 0;
} else 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;
}
}
s.extended = smap_get_bool(&iface->cfg->other_config, "cfm_extended",
false);
s.demand = smap_get_bool(&iface->cfg->other_config, "cfm_demand", false);
opstate_str = smap_get(&iface->cfg->other_config, "cfm_opstate");
s.opup = !opstate_str || !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
* instead of obtaining it from the database. */
static bool
iface_is_synthetic(const struct iface *iface)
{
return ovsdb_idl_row_is_synthetic(&iface->cfg->header_);
}
static ofp_port_t
iface_validate_ofport__(size_t n, int64_t *ofport)
{
return (n && *ofport >= 1 && *ofport < ofp_to_u16(OFPP_MAX)
? u16_to_ofp(*ofport)
: OFPP_NONE);
}
static ofp_port_t
iface_get_requested_ofp_port(const struct ovsrec_interface *cfg)
{
return iface_validate_ofport__(cfg->n_ofport_request, cfg->ofport_request);
}
static ofp_port_t
iface_pick_ofport(const struct ovsrec_interface *cfg)
{
ofp_port_t requested_ofport = iface_get_requested_ofp_port(cfg);
return (requested_ofport != OFPP_NONE
? requested_ofport
: iface_validate_ofport__(cfg->n_ofport, cfg->ofport));
}
/* Port mirroring. */
static struct mirror *
mirror_find_by_uuid(struct bridge *br, const struct uuid *uuid)
{
struct mirror *m;
HMAP_FOR_EACH_IN_BUCKET (m, hmap_node, uuid_hash(uuid), &br->mirrors) {
if (uuid_equals(uuid, &m->uuid)) {
return m;
}
}
return NULL;
}
static void
bridge_configure_mirrors(struct bridge *br)
{
const struct ovsdb_datum *mc;
unsigned long *flood_vlans;
struct mirror *m;
size_t i;
/* Get rid of deleted mirrors. */
mc = ovsrec_bridge_get_mirrors(br->cfg, OVSDB_TYPE_UUID);
HMAP_FOR_EACH_SAFE (m, hmap_node, &br->mirrors) {
union ovsdb_atom atom;
atom.uuid = m->uuid;
if (!ovsdb_datum_find_key(mc, &atom, OVSDB_TYPE_UUID, NULL)) {
mirror_destroy(m);
}
}
/* Add new mirrors and reconfigure existing ones. */
for (i = 0; i < br->cfg->n_mirrors; i++) {
const struct ovsrec_mirror *cfg = br->cfg->mirrors[i];
m = mirror_find_by_uuid(br, &cfg->header_.uuid);
if (!m) {
m = mirror_create(br, cfg);
}
m->cfg = cfg;
if (!mirror_configure(m)) {
mirror_destroy(m);
}
}
/* Update flooded vlans (for RSPAN). */
flood_vlans = vlan_bitmap_from_array(br->cfg->flood_vlans,
br->cfg->n_flood_vlans);
ofproto_set_flood_vlans(br->ofproto, flood_vlans);
bitmap_free(flood_vlans);
}
static struct mirror *
mirror_create(struct bridge *br, const struct ovsrec_mirror *cfg)
{
struct mirror *m;
m = xzalloc(sizeof *m);
m->uuid = cfg->header_.uuid;
hmap_insert(&br->mirrors, &m->hmap_node, uuid_hash(&m->uuid));
m->bridge = br;
m->name = xstrdup(cfg->name);
return m;
}
static void
mirror_destroy(struct mirror *m)
{
if (m) {
struct bridge *br = m->bridge;
if (br->ofproto) {
ofproto_mirror_unregister(br->ofproto, m);
}
hmap_remove(&br->mirrors, &m->hmap_node);
free(m->name);
free(m);
}
}
static void
mirror_collect_ports(struct mirror *m,
struct ovsrec_port **in_ports, int n_in_ports,
void ***out_portsp, size_t *n_out_portsp)
{
void **out_ports = xmalloc(n_in_ports * sizeof *out_ports);
size_t n_out_ports = 0;
size_t i;
for (i = 0; i < n_in_ports; i++) {
const char *name = in_ports[i]->name;
struct port *port = port_lookup(m->bridge, name);
if (port) {
out_ports[n_out_ports++] = port;
} else {
VLOG_WARN("bridge %s: mirror %s cannot match on nonexistent "
"port %s", m->bridge->name, m->name, name);
}
}
*out_portsp = out_ports;
*n_out_portsp = n_out_ports;
}
static bool
mirror_configure(struct mirror *m)
{
const struct ovsrec_mirror *cfg = m->cfg;
struct ofproto_mirror_settings s;
/* Set name. */
if (strcmp(cfg->name, m->name)) {
free(m->name);
m->name = xstrdup(cfg->name);
}
s.name = m->name;
/* Get output port or VLAN. */
if (cfg->output_port) {
s.out_bundle = port_lookup(m->bridge, cfg->output_port->name);
if (!s.out_bundle) {
VLOG_ERR("bridge %s: mirror %s outputs to port not on bridge",
m->bridge->name, m->name);
return false;
}
s.out_vlan = UINT16_MAX;
if (cfg->output_vlan) {
VLOG_ERR("bridge %s: mirror %s specifies both output port and "
"output vlan; ignoring output vlan",
m->bridge->name, m->name);
}
} else if (cfg->output_vlan) {
/* The database should prevent invalid VLAN values. */
s.out_bundle = NULL;
s.out_vlan = *cfg->output_vlan;
} else {
VLOG_ERR("bridge %s: mirror %s does not specify output; ignoring",
m->bridge->name, m->name);
return false;
}
if (cfg->snaplen) {
s.snaplen = *cfg->snaplen;
} else {
s.snaplen = 0;
}
/* Get port selection. */
if (cfg->select_all) {
size_t n_ports = hmap_count(&m->bridge->ports);
void **ports = xmalloc(n_ports * sizeof *ports);
struct port *port;
size_t i;
i = 0;
HMAP_FOR_EACH (port, hmap_node, &m->bridge->ports) {
ports[i++] = port;
}
s.srcs = ports;
s.n_srcs = n_ports;
s.dsts = ports;
s.n_dsts = n_ports;
} else {
/* Get ports, dropping ports that don't exist.
* The IDL ensures that there are no duplicates. */
mirror_collect_ports(m, cfg->select_src_port, cfg->n_select_src_port,
&s.srcs, &s.n_srcs);
mirror_collect_ports(m, cfg->select_dst_port, cfg->n_select_dst_port,
&s.dsts, &s.n_dsts);
}
/* Get VLAN selection. */
s.src_vlans = vlan_bitmap_from_array(cfg->select_vlan, cfg->n_select_vlan);
/* Configure. */
ofproto_mirror_register(m->bridge->ofproto, m, &s);
/* Clean up. */
if (s.srcs != s.dsts) {
free(s.dsts);
}
free(s.srcs);
free(s.src_vlans);
return true;
}
static void
mirror_refresh_stats(struct mirror *m)
{
struct ofproto *ofproto = m->bridge->ofproto;
uint64_t tx_packets, tx_bytes;
const 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);
}
/*
* Add registered netdev and dpif types to ovsdb to allow external
* applications to query the capabilities of the Open vSwitch instance
* running on the node.
*/
static void
discover_types(const struct ovsrec_open_vswitch *cfg)
{
struct sset types;
/* Datapath types. */
sset_init(&types);
dp_enumerate_types(&types);
const char **datapath_types = sset_array(&types);
ovsrec_open_vswitch_set_datapath_types(cfg, datapath_types,
sset_count(&types));
free(datapath_types);
sset_destroy(&types);
/* Port types. */
sset_init(&types);
netdev_enumerate_types(&types);
const char **iface_types = sset_array(&types);
ovsrec_open_vswitch_set_iface_types(cfg, iface_types, sset_count(&types));
free(iface_types);
sset_destroy(&types);
}
Reference in New Issue View Git Blame Copy Permalink