X-Git-Url: http://git.cascardo.eti.br/?a=blobdiff_plain;f=vswitchd%2Fbridge.c;h=25a0663f195bda963a6cee0258c1f6591d7fa8f9;hb=e8fed7d01ca6fb6c7e96faf2b831fcfa4552cb4a;hp=8ccb8da2bee67f3e7e3e424a7da533714bc4a0cb;hpb=4f6b99348189f728a734aaf3b551410ee8b07f0c;p=cascardo%2Fovs.git diff --git a/vswitchd/bridge.c b/vswitchd/bridge.c index 8ccb8da2b..25a0663f1 100644 --- a/vswitchd/bridge.c +++ b/vswitchd/bridge.c @@ -1,4 +1,4 @@ -/* Copyright (c) 2008, 2009, 2010, 2011, 2012, 2013 Nicira, Inc. +/* Copyright (c) 2008, 2009, 2010, 2011, 2012, 2013, 2014, 2015, 2016 Nicira, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -18,13 +18,16 @@ #include #include #include + #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 "dynamic-string.h" #include "hash.h" #include "hmap.h" @@ -32,15 +35,21 @@ #include "jsonrpc.h" #include "lacp.h" #include "list.h" +#include "ovs-lldp.h" #include "mac-learning.h" +#include "mcast-snooping.h" #include "meta-flow.h" #include "netdev.h" +#include "nx-match.h" #include "ofp-print.h" #include "ofp-util.h" #include "ofpbuf.h" #include "ofproto/bond.h" #include "ofproto/ofproto.h" +#include "ovs-numa.h" #include "poll-loop.h" +#include "if-notifier.h" +#include "seq.h" #include "sha1.h" #include "shash.h" #include "smap.h" @@ -55,41 +64,30 @@ #include "vlandev.h" #include "lib/vswitch-idl.h" #include "xenserver.h" -#include "vlog.h" +#include "openvswitch/vlog.h" #include "sflow_api.h" #include "vlan-bitmap.h" +#include "packets.h" VLOG_DEFINE_THIS_MODULE(bridge); COVERAGE_DEFINE(bridge_reconfigure); -/* Configuration of an uninstantiated iface. */ -struct if_cfg { - struct hmap_node hmap_node; /* Node in bridge's if_cfg_todo. */ - const struct ovsrec_interface *cfg; /* Interface record. */ - const struct ovsrec_port *parent; /* Parent port record. */ - ofp_port_t ofport; /* Requested OpenFlow port number. */ -}; - -/* OpenFlow port slated for removal from ofproto. */ -struct ofpp_garbage { - struct list list_node; /* Node in bridge's ofpp_garbage. */ - ofp_port_t ofp_port; /* Port to be deleted. */ -}; - struct iface { - /* These members are always valid. */ - struct list port_elem; /* Element in struct port's "ifaces" list. */ + /* 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. */ - - /* These members are valid only after bridge_reconfigure() causes them to - * be initialized. */ - struct hmap_node ofp_port_node; /* In struct bridge's "ifaces" hmap. */ - ofp_port_t ofp_port; /* OpenFlow port number, */ - /* OFPP_NONE if unknown. */ 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; }; @@ -111,15 +109,15 @@ struct port { /* An ordinary bridge port has 1 interface. * A bridge port for bonding has at least 2 interfaces. */ - struct list ifaces; /* List of "struct iface"s. */ + 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. */ - uint8_t ea[ETH_ADDR_LEN]; /* Bridge Ethernet Address. */ - uint8_t default_ea[ETH_ADDR_LEN]; /* Default MAC. */ + struct eth_addr ea; /* Bridge Ethernet Address. */ + struct eth_addr default_ea; /* Default MAC. */ const struct ovsrec_bridge *cfg; /* OpenFlow switch processing. */ @@ -130,19 +128,29 @@ struct bridge { struct hmap ifaces; /* "struct iface"s indexed by ofp_port. */ struct hmap iface_by_name; /* "struct iface"s indexed by name. */ - struct list ofpp_garbage; /* "struct ofpp_garbage" slated for removal. */ - struct hmap if_cfg_todo; /* "struct if_cfg"s slated for creation. - Indexed on 'cfg->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; +}; + /* All bridges, indexed by name. */ static struct hmap all_bridges = HMAP_INITIALIZER(&all_bridges); @@ -169,56 +177,93 @@ 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. */ -#define IFACE_STATS_INTERVAL (5 * 1000) /* In milliseconds. */ -static long long int iface_stats_timer = LLONG_MIN; - -/* In some datapaths, creating and destroying OpenFlow ports can be extremely - * expensive. This can cause bridge_reconfigure() to take a long time during - * which no other work can be done. To deal with this problem, we limit port - * adds and deletions to a window of OFP_PORT_ACTION_WINDOW milliseconds per - * call to bridge_reconfigure(). If there is more work to do after the limit - * is reached, 'need_reconfigure', is flagged and it's done on the next loop. - * This allows the rest of the code to catch up on important things like - * forwarding packets. */ -#define OFP_PORT_ACTION_WINDOW 10 -static bool reconfiguring = false; +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 bool ifaces_changed = false; static void add_del_bridges(const struct ovsrec_open_vswitch *); -static void bridge_update_ofprotos(void); +static void bridge_run__(void); static void bridge_create(const struct ovsrec_bridge *); -static void bridge_destroy(struct 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_add_del_ports(struct bridge *, - const unsigned long int *splinter_vlans); -static void bridge_refresh_ofp_port(struct bridge *); -static void bridge_configure_flow_miss_model(const char *opt); +static void bridge_collect_wanted_ports(struct bridge *, + const unsigned long *splinter_vlans, + 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_stp(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_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 *, - uint8_t ea[ETH_ADDR_LEN], +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 uint8_t bridge_ea[ETH_ADDR_LEN], + const struct eth_addr bridge_ea, struct iface *hw_addr_iface); -static void bridge_queue_if_cfg(struct bridge *, - const struct ovsrec_interface *, - const struct ovsrec_port *); static uint64_t dpid_from_hash(const void *, size_t nbytes); static bool bridge_has_bond_fake_iface(const struct bridge *, const char *name); @@ -247,29 +292,33 @@ static bool mirror_configure(struct mirror *); static void mirror_refresh_stats(struct mirror *); static void iface_configure_lacp(struct iface *, struct lacp_slave_settings *); -static bool iface_create(struct bridge *, struct if_cfg *, - ofp_port_t ofp_port); +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 if_cfg *if_cfg_lookup(const struct bridge *, const char *name); static struct iface *iface_from_ofp_port(const struct bridge *, ofp_port_t ofp_port); -static void iface_set_mac(struct iface *); +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); +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_status(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 *); + /* Linux VLAN device support (e.g. "eth0.10" for VLAN 10.) * * This is deprecated. It is only for compatibility with broken device drivers @@ -288,6 +337,8 @@ static void add_vlan_splinter_ports(struct bridge *, const unsigned long int *splinter_vlans, struct shash *ports); +static void discover_types(const struct ovsrec_open_vswitch *cfg); + static void bridge_init_ofproto(const struct ovsrec_open_vswitch *cfg) { @@ -330,6 +381,12 @@ bridge_init_ofproto(const struct ovsrec_open_vswitch *cfg) shash_destroy_free_data(&iface_hints); initialized = true; } + +static void +if_change_cb(void *aux OVS_UNUSED) +{ + ifaces_changed = true; +} /* Public functions. */ @@ -347,6 +404,8 @@ bridge_init(const char *remote) 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); @@ -354,14 +413,21 @@ bridge_init(const char *remote) ovsdb_idl_omit(idl, &ovsrec_open_vswitch_col_system_version); ovsdb_idl_omit_alert(idl, &ovsrec_bridge_col_datapath_id); + ovsdb_idl_omit_alert(idl, &ovsrec_bridge_col_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(idl, &ovsrec_port_col_fake_bridge); - + 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); @@ -381,6 +447,7 @@ bridge_init(const char *remote) 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); @@ -418,7 +485,12 @@ bridge_init(const char *remote) lacp_init(); bond_init(); cfm_init(); + bfd_init(); + ovs_numa_init(); stp_init(); + lldp_init(); + rstp_init(); + ifnotifier = if_notifier_create(if_change_cb, NULL); } void @@ -426,8 +498,9 @@ bridge_exit(void) { struct bridge *br, *next_br; + if_notifier_destroy(ifnotifier); HMAP_FOR_EACH_SAFE (br, next_br, node, &all_bridges) { - bridge_destroy(br); + bridge_destroy(br, false); } ovsdb_idl_destroy(idl); } @@ -441,7 +514,8 @@ bridge_exit(void) * 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 are collected.) + * (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, @@ -472,12 +546,17 @@ collect_in_band_managers(const struct ovsrec_open_vswitch *ovs_cfg, managers = xmalloc(sset_count(&targets) * sizeof *managers); SSET_FOR_EACH (target, &targets) { - struct sockaddr_in *sin = &managers[n_managers]; - - if (stream_parse_target_with_default_port(target, - OVSDB_OLD_PORT, - sin)) { - n_managers++; + 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; } } } @@ -491,113 +570,82 @@ static void bridge_reconfigure(const struct ovsrec_open_vswitch *ovs_cfg) { unsigned long int *splinter_vlans; - struct bridge *br; + struct sockaddr_in *managers; + struct bridge *br, *next; + int sflow_bridge_number; + size_t n_managers; COVERAGE_INC(bridge_reconfigure); - ovs_assert(!reconfiguring); - reconfiguring = true; + ofproto_set_flow_limit(smap_get_int(&ovs_cfg->other_config, "flow-limit", + OFPROTO_FLOW_LIMIT_DEFAULT)); + ofproto_set_max_idle(smap_get_int(&ovs_cfg->other_config, "max-idle", + OFPROTO_MAX_IDLE_DEFAULT)); + ofproto_set_cpu_mask(smap_get(&ovs_cfg->other_config, "pmd-cpu-mask")); - ofproto_set_flow_eviction_threshold( - smap_get_int(&ovs_cfg->other_config, "flow-eviction-threshold", - OFPROTO_FLOW_EVICTION_THRESHOLD_DEFAULT)); - - ofproto_set_n_handler_threads( - smap_get_int(&ovs_cfg->other_config, "n-handler-threads", 0)); - - bridge_configure_flow_miss_model(smap_get(&ovs_cfg->other_config, - "force-miss-model")); + 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' while update the "if_cfg_queue", with only very minimal - * configuration otherwise. + * 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); splinter_vlans = collect_splinter_vlans(ovs_cfg); HMAP_FOR_EACH (br, node, &all_bridges) { - bridge_add_del_ports(br, splinter_vlans); + bridge_collect_wanted_ports(br, splinter_vlans, &br->wanted_ports); + bridge_del_ports(br, &br->wanted_ports); } free(splinter_vlans); - /* Delete datapaths that are no longer configured, and create ones which - * don't exist but should. */ - bridge_update_ofprotos(); - - /* Make sure each "struct iface" has a correct ofp_port in its ofproto. */ - HMAP_FOR_EACH (br, node, &all_bridges) { - bridge_refresh_ofp_port(br); - } - - /* Clear database records for "if_cfg"s which haven't been instantiated. */ + /* 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) { - struct if_cfg *if_cfg; - - HMAP_FOR_EACH (if_cfg, hmap_node, &br->if_cfg_todo) { - iface_clear_db_record(if_cfg->cfg); + if (br->ofproto) { + bridge_delete_or_reconfigure_ports(br); } } - reconfigure_system_stats(ovs_cfg); -} - -static bool -bridge_reconfigure_ofp(void) -{ - long long int deadline; - struct bridge *br; - - deadline = time_msec() + OFP_PORT_ACTION_WINDOW; + /* Finish pushing configuration changes to the ofproto layer: + * + * - Create ofprotos that are missing. + * + * - Add ports that are missing. */ + HMAP_FOR_EACH_SAFE (br, next, node, &all_bridges) { + if (!br->ofproto) { + int error; - /* The kernel will reject any attempt to add a given port to a datapath if - * that port already belongs to a different datapath, so we must do all - * port deletions before any port additions. */ - HMAP_FOR_EACH (br, node, &all_bridges) { - struct ofpp_garbage *garbage, *next; - - LIST_FOR_EACH_SAFE (garbage, next, list_node, &br->ofpp_garbage) { - /* It's a bit dangerous to call bridge_run_fast() here as ofproto's - * internal datastructures may not be consistent. Eventually, when - * port additions and deletions are cheaper, these calls should be - * removed. */ - bridge_run_fast(); - ofproto_port_del(br->ofproto, garbage->ofp_port); - list_remove(&garbage->list_node); - free(garbage); - - if (time_msec() >= deadline) { - return false; + 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()); } - bridge_run_fast(); } } - HMAP_FOR_EACH (br, node, &all_bridges) { - struct if_cfg *if_cfg, *next; - - HMAP_FOR_EACH_SAFE (if_cfg, next, hmap_node, &br->if_cfg_todo) { - iface_create(br, if_cfg, OFPP_NONE); - if (time_msec() >= deadline) { - return false; - } - } + bridge_add_ports(br, &br->wanted_ports); + shash_destroy(&br->wanted_ports); } - return true; -} - -static bool -bridge_reconfigure_continue(const struct ovsrec_open_vswitch *ovs_cfg) -{ - struct sockaddr_in *managers; - int sflow_bridge_number; - size_t n_managers; - struct bridge *br; - bool done; - - ovs_assert(reconfiguring); - done = bridge_reconfigure_ofp(); + reconfigure_system_stats(ovs_cfg); /* Complete the configuration. */ sflow_bridge_number = 0; @@ -615,42 +663,47 @@ bridge_reconfigure_continue(const struct ovsrec_open_vswitch *ovs_cfg) 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(iface); + 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); } } 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_stp(br); + bridge_configure_spanning_tree(br); bridge_configure_tables(br); bridge_configure_dp_desc(br); - - if (smap_get(&br->cfg->other_config, "flow-eviction-threshold")) { - /* XXX: Remove this warning message eventually. */ - VLOG_WARN_ONCE("As of June 2013, flow-eviction-threshold has been" - " moved to the Open_vSwitch table. Ignoring its" - " setting in the bridge table."); - } + bridge_configure_aa(br); } free(managers); - return done; + /* 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_update_ofprotos(void) +bridge_delete_ofprotos(void) { - struct bridge *br, *next; + struct bridge *br; struct sset names; struct sset types; const char *type; @@ -672,46 +725,187 @@ bridge_update_ofprotos(void) } sset_destroy(&names); sset_destroy(&types); +} - /* Add ofprotos for bridges which don't have one yet. */ - HMAP_FOR_EACH_SAFE (br, next, node, &all_bridges) { - struct bridge *br2; - int error; +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; +} - if (br->ofproto) { - continue; - } +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, *port_next; + + /* 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); - /* Remove ports from any datapath with the same name as 'br'. If we - * don't do this, creating 'br''s ofproto will fail because a port with - * the same name as its local port already exists. */ - HMAP_FOR_EACH (br2, node, &all_bridges) { - struct ofproto_port ofproto_port; + /* 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; - if (!br2->ofproto) { + 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; + } - if (!ofproto_port_query_by_name(br2->ofproto, br->name, - &ofproto_port)) { - error = ofproto_port_del(br2->ofproto, ofproto_port.ofp_port); - if (error) { - VLOG_ERR("failed to delete port %s: %s", ofproto_port.name, - ovs_strerror(error)); - } - ofproto_port_destroy(&ofproto_port); + if (strcmp(ofproto_port.type, iface->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; + } + + /* 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; } } - error = ofproto_create(br->name, br->type, &br->ofproto); - if (error) { - VLOG_ERR("failed to create bridge %s: %s", br->name, - ovs_strerror(error)); - bridge_destroy(br); + /* 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, port_next, hmap_node, &br->ports) { + struct iface *iface, *iface_next; + + LIST_FOR_EACH_SAFE (iface, iface_next, port_elem, &port->ifaces) { + if (!sset_contains(&ofproto_ports, iface->name)) { + iface_destroy__(iface); + } + } + + if (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) { @@ -760,15 +954,16 @@ port_configure(struct port *port) s.vlan_mode = PORT_VLAN_NATIVE_UNTAGGED; } else { /* This "can't happen" because ovsdb-server should prevent it. */ - VLOG_ERR("unknown VLAN mode %s", cfg->vlan_mode); + 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) { - VLOG_ERR("port %s: ignoring trunks in favor of implicit vlan", - port->name); + VLOG_WARN("port %s: ignoring trunks in favor of implicit vlan", + port->name); } } else { s.vlan_mode = PORT_VLAN_TRUNK; @@ -810,33 +1005,17 @@ port_configure(struct port *port) free(s.lacp_slaves); } -static void -bridge_configure_flow_miss_model(const char *opt) -{ - enum ofproto_flow_miss_model model = OFPROTO_HANDLE_MISS_AUTO; - - if (opt) { - if (strcmp(opt, "with-facets")) { - model = OFPROTO_HANDLE_MISS_WITH_FACETS; - } else if (strcmp(opt, "without-facets")) { - model = OFPROTO_HANDLE_MISS_WITHOUT_FACETS; - } - } - - ofproto_set_flow_miss_model(model); -} - /* Pick local port hardware address and datapath ID for 'br'. */ static void bridge_configure_datapath_id(struct bridge *br) { - uint8_t ea[ETH_ADDR_LEN]; + 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); + 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); @@ -847,7 +1026,7 @@ bridge_configure_datapath_id(struct bridge *br) br->name, ovs_strerror(error)); } } - memcpy(br->ea, ea, ETH_ADDR_LEN); + br->ea = ea; dpid = bridge_pick_datapath_id(br, ea, hw_addr_iface); if (dpid != ofproto_get_datapath_id(br->ofproto)) { @@ -865,8 +1044,9 @@ bridge_configure_datapath_id(struct bridge *br) static uint32_t bridge_get_allowed_versions(struct bridge *br) { - if (!br->cfg->n_protocols) + if (!br->cfg->n_protocols) { return 0; + } return ofputil_versions_from_strings(br->cfg->protocols, br->cfg->n_protocols); @@ -1044,6 +1224,15 @@ bridge_configure_ipfix(struct bridge *br) if (be_cfg->cache_max_flows) { be_opts.cache_max_flows = *be_cfg->cache_max_flows; } + + 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", false); + + be_opts.enable_output_sampling = !smap_get_bool(&be_cfg->other_config, + "enable-output-sampling", false); } if (n_fe_opts > 0) { @@ -1172,11 +1361,107 @@ port_configure_stp(const struct ofproto *ofproto, struct port *port, } } +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 (!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(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; + } + + config_str = smap_get(&port->cfg->other_config, "rstp-path-cost"); + if (config_str) { + port_s->path_cost = strtoul(config_str, NULL, 10); + } else { + enum netdev_features current; + unsigned int mbps; + + netdev_get_features(iface->netdev, ¤t, NULL, NULL, NULL); + mbps = netdev_features_to_bps(current, 100 * 1000 * 1000) / 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; + } + + config_str = smap_get(&port->cfg->other_config, "rstp-admin-p2p-mac"); + if (config_str) { + port_s->admin_p2p_mac_state = strtoul(config_str, NULL, 0); + } else { + port_s->admin_p2p_mac_state = 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) +bridge_configure_stp(struct bridge *br, bool enable_stp) { - if (!br->cfg->stp_enable) { + if (!enable_stp) { ofproto_set_stp(br->ofproto, NULL); } else { struct ofproto_stp_settings br_s; @@ -1187,9 +1472,9 @@ bridge_configure_stp(struct bridge *br) config_str = smap_get(&br->cfg->other_config, "stp-system-id"); if (config_str) { - uint8_t ea[ETH_ADDR_LEN]; + struct eth_addr ea; - if (eth_addr_from_string(config_str, 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); @@ -1257,7 +1542,7 @@ bridge_configure_stp(struct bridge *br) } } - if (bitmap_scan(port_num_bitmap, 0, STP_MAX_PORTS) != STP_MAX_PORTS + 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); @@ -1267,207 +1552,204 @@ bridge_configure_stp(struct bridge *br) } } -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 && !list_is_short(&port->ifaces); -} - static void -add_del_bridges(const struct ovsrec_open_vswitch *cfg) +bridge_configure_rstp(struct bridge *br, bool enable_rstp) { - struct bridge *br, *next; - struct shash new_br; - size_t i; + 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; - /* 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]; + config_str = smap_get(&br->cfg->other_config, "rstp-address"); + if (config_str) { + struct eth_addr ea; - if (strchr(br_cfg->name, '/')) { - /* Prevent remote ovsdb-server users from accessing arbitrary - * directories, e.g. consider a bridge named "../../../etc/". */ - VLOG_WARN_RL(&rl, "ignoring bridge with invalid name \"%s\"", - br_cfg->name); - } else if (!shash_add_once(&new_br, br_cfg->name, br_cfg)) { - VLOG_WARN_RL(&rl, "bridge %s specified twice", br_cfg->name); + 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); } - } - /* Get rid of deleted bridges or those whose types have changed. - * Update 'cfg' of bridges that still exist. */ - HMAP_FOR_EACH_SAFE (br, next, 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); + config_str = smap_get(&br->cfg->other_config, "rstp-priority"); + if (config_str) { + br_s.priority = strtoul(config_str, NULL, 0); + } else { + br_s.priority = RSTP_DEFAULT_PRIORITY; } - } - /* Add new bridges. */ - for (i = 0; i < cfg->n_bridges; i++) { - const struct ovsrec_bridge *br_cfg = cfg->bridges[i]; - struct bridge *br = bridge_lookup(br_cfg->name); - if (!br) { - bridge_create(br_cfg); + config_str = smap_get(&br->cfg->other_config, "rstp-ageing-time"); + if (config_str) { + br_s.ageing_time = strtoul(config_str, NULL, 0); + } else { + br_s.ageing_time = RSTP_DEFAULT_AGEING_TIME; } - } - shash_destroy(&new_br); + config_str = smap_get(&br->cfg->other_config, + "rstp-force-protocol-version"); + if (config_str) { + br_s.force_protocol_version = strtoul(config_str, NULL, 0); + } else { + br_s.force_protocol_version = FPV_DEFAULT; + } + + config_str = smap_get(&br->cfg->other_config, "rstp-max-age"); + if (config_str) { + br_s.bridge_max_age = strtoul(config_str, NULL, 10); + } else { + br_s.bridge_max_age = RSTP_DEFAULT_BRIDGE_MAX_AGE; + } + + config_str = smap_get(&br->cfg->other_config, "rstp-forward-delay"); + if (config_str) { + br_s.bridge_forward_delay = strtoul(config_str, NULL, 10); + } else { + br_s.bridge_forward_delay = RSTP_DEFAULT_BRIDGE_FORWARD_DELAY; + } + + config_str = smap_get(&br->cfg->other_config, + "rstp-transmit-hold-count"); + if (config_str) { + br_s.transmit_hold_count = strtoul(config_str, NULL, 10); + } else { + br_s.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 -iface_set_ofp_port(struct iface *iface, ofp_port_t ofp_port) +bridge_configure_spanning_tree(struct bridge *br) { - struct bridge *br = iface->port->bridge; + bool enable_rstp = br->cfg->rstp_enable; + bool enable_stp = br->cfg->stp_enable; - ovs_assert(iface->ofp_port == OFPP_NONE && ofp_port != OFPP_NONE); - iface->ofp_port = ofp_port; - hmap_insert(&br->ifaces, &iface->ofp_port_node, - hash_ofp_port(ofp_port)); - iface_set_ofport(iface->cfg, ofp_port); + 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); } -/* 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) +static bool +bridge_has_bond_fake_iface(const struct bridge *br, const char *name) { - return netdev_set_config(netdev, &iface_cfg->options); + const struct port *port = port_lookup(br, name); + return port && port_is_bond_fake_iface(port); } -/* This function determines whether 'ofproto_port', which is attached to - * br->ofproto's datapath, is one that we want in 'br'. - * - * If it is, it returns true, after creating an iface (if necessary), - * configuring the iface's netdev according to the iface's options, and setting - * iface's ofp_port member to 'ofproto_port->ofp_port'. - * - * If, on the other hand, 'port' should be removed, it returns false. The - * caller should later detach the port from br->ofproto. */ static bool -bridge_refresh_one_ofp_port(struct bridge *br, - const struct ofproto_port *ofproto_port) +port_is_bond_fake_iface(const struct port *port) { - const char *name = ofproto_port->name; - const char *type = ofproto_port->type; - ofp_port_t ofp_port = ofproto_port->ofp_port; - - struct iface *iface = iface_lookup(br, name); - if (iface) { - /* Check that the name-to-number mapping is one-to-one. */ - if (iface->ofp_port != OFPP_NONE) { - VLOG_WARN("bridge %s: interface %s reported twice", - br->name, name); - return false; - } else if (iface_from_ofp_port(br, ofp_port)) { - VLOG_WARN("bridge %s: interface %"PRIu16" reported twice", - br->name, ofp_port); - return false; - } - - /* There's a configured interface named 'name'. */ - if (strcmp(type, iface->type) - || iface_set_netdev_config(iface->cfg, iface->netdev)) { - /* It's the wrong type, or it's the right type but can't be - * configured as the user requested, so we must destroy it. */ - return false; - } else { - /* It's the right type and configured correctly. Keep it. */ - iface_set_ofp_port(iface, ofp_port); - return true; - } - } else if (bridge_has_bond_fake_iface(br, name) - && !strcmp(type, "internal")) { - /* It's a bond fake iface. Keep it. */ - return true; - } else { - /* There's no configured interface named 'name', but there might be an - * interface of that name queued to be created. - * - * If there is, and it has the correct type, then try to configure it - * and add it. If that's successful, we'll keep it. Otherwise, we'll - * delete it and later try to re-add it. */ - struct if_cfg *if_cfg = if_cfg_lookup(br, name); - return (if_cfg - && !strcmp(type, iface_get_type(if_cfg->cfg, br->cfg)) - && iface_create(br, if_cfg, ofp_port)); - } + return port->cfg->bond_fake_iface && !list_is_short(&port->ifaces); } -/* Update bridges "if_cfg"s, "struct port"s, and "struct iface"s to be - * consistent with the ofp_ports in "br->ofproto". */ static void -bridge_refresh_ofp_port(struct bridge *br) +add_del_bridges(const struct ovsrec_open_vswitch *cfg) { - struct ofproto_port_dump dump; - struct ofproto_port ofproto_port; - struct port *port, *port_next; + struct bridge *br, *next; + struct shash_node *node; + struct shash new_br; + size_t i; - /* Clear each "struct iface"s ofp_port so we can get its correct value. */ - hmap_clear(&br->ifaces); - HMAP_FOR_EACH (port, hmap_node, &br->ports) { - struct iface *iface; + /* 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]; - LIST_FOR_EACH (iface, port_elem, &port->ifaces) { - iface->ofp_port = OFPP_NONE; + 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); } } - /* Obtain the correct "ofp_port"s from ofproto. Find any if_cfg's which - * already exist in the datapath and promote them to full fledged "struct - * iface"s. Mark ports in the datapath which don't belong as garbage. */ - OFPROTO_PORT_FOR_EACH (&ofproto_port, &dump, br->ofproto) { - if (!bridge_refresh_one_ofp_port(br, &ofproto_port)) { - struct ofpp_garbage *garbage = xmalloc(sizeof *garbage); - garbage->ofp_port = ofproto_port.ofp_port; - list_push_front(&br->ofpp_garbage, &garbage->list_node); + /* Get rid of deleted bridges or those whose types have changed. + * Update 'cfg' of bridges that still exist. */ + HMAP_FOR_EACH_SAFE (br, next, 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); } } - /* Some ifaces may not have "ofp_port"s in ofproto and therefore don't - * deserve to have "struct iface"s. Demote these to "if_cfg"s so that - * later they can be added to ofproto. */ - HMAP_FOR_EACH_SAFE (port, port_next, hmap_node, &br->ports) { - struct iface *iface, *iface_next; - - LIST_FOR_EACH_SAFE (iface, iface_next, port_elem, &port->ifaces) { - if (iface->ofp_port == OFPP_NONE) { - bridge_queue_if_cfg(br, iface->cfg, port->cfg); - iface_destroy(iface); - } - } - - if (list_is_empty(&port->ifaces)) { - port_destroy(port); + /* Add new bridges. */ + SHASH_FOR_EACH(node, &new_br) { + const struct ovsrec_bridge *br_cfg = node->data; + struct bridge *br = bridge_lookup(br_cfg->name); + if (!br) { + bridge_create(br_cfg); } } + + shash_destroy(&new_br); } -/* Opens a network device for 'if_cfg' and configures it. If '*ofp_portp' - * is OFPP_NONE, adds the network device to br->ofproto and stores the OpenFlow - * port number in '*ofp_portp'; otherwise leaves br->ofproto and '*ofp_portp' - * untouched. +/* 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 if_cfg *if_cfg, - ofp_port_t *ofp_portp, struct netdev **netdevp) + const struct ovsrec_interface *iface_cfg, + const struct ovsrec_port *port_cfg, + ofp_port_t *ofp_portp, struct netdev **netdevp, + char **errp) { - const struct ovsrec_interface *iface_cfg = if_cfg->cfg; - const struct ovsrec_port *port_cfg = if_cfg->parent; struct netdev *netdev = NULL; int error; @@ -1481,34 +1763,26 @@ iface_do_create(const struct bridge *br, error = netdev_open(iface_cfg->name, iface_get_type(iface_cfg, br->cfg), &netdev); if (error) { - VLOG_WARN("could not open network device %s (%s)", - iface_cfg->name, ovs_strerror(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); + error = iface_set_netdev_config(iface_cfg, netdev, errp); if (error) { goto error; } - if (*ofp_portp == OFPP_NONE) { - ofp_port_t ofp_port = if_cfg->ofport; - - error = ofproto_port_add(br->ofproto, netdev, &ofp_port); - if (error) { - goto error; - } - *ofp_portp = ofp_port; - - VLOG_INFO("bridge %s: added interface %s on port %d", - br->name, iface_cfg->name, *ofp_portp); - } else { - VLOG_DBG("bridge %s: interface %s is on port %d", - br->name, iface_cfg->name, *ofp_portp); + *ofp_portp = iface_pick_ofport(iface_cfg); + error = ofproto_port_add(br->ofproto, netdev, ofp_portp); + if (error) { + goto error; } - if ((port_cfg->vlan_mode && !strcmp(port_cfg->vlan_mode, "splinter")) - || iface_is_internal(iface_cfg, br->cfg)) { + VLOG_INFO("bridge %s: added interface %s on port %d", + br->name, iface_cfg->name, *ofp_portp); + + if (port_cfg->vlan_mode && !strcmp(port_cfg->vlan_mode, "splinter")) { netdev_turn_flags_on(netdev, NETDEV_UP, NULL); } @@ -1528,31 +1802,23 @@ error: * * Return true if an iface is successfully created, false otherwise. */ static bool -iface_create(struct bridge *br, struct if_cfg *if_cfg, ofp_port_t ofp_port) +iface_create(struct bridge *br, const struct ovsrec_interface *iface_cfg, + const struct ovsrec_port *port_cfg) { - const struct ovsrec_interface *iface_cfg = if_cfg->cfg; - const struct ovsrec_port *port_cfg = if_cfg->parent; - struct netdev *netdev; struct iface *iface; + ofp_port_t ofp_port; struct port *port; + char *errp = NULL; int error; - bool ok = true; - /* Do the bits that can fail up front. - * - * It's a bit dangerous to call bridge_run_fast() here as ofproto's - * internal datastructures may not be consistent. Eventually, when port - * additions and deletions are cheaper, these calls should be removed. */ - bridge_run_fast(); + /* Do the bits that can fail up front. */ ovs_assert(!iface_lookup(br, iface_cfg->name)); - error = iface_do_create(br, if_cfg, &ofp_port, &netdev); - bridge_run_fast(); + error = iface_do_create(br, iface_cfg, port_cfg, &ofp_port, &netdev, &errp); if (error) { - iface_set_ofport(iface_cfg, OFPP_NONE); - iface_clear_db_record(iface_cfg); - ok = false; - goto done; + iface_clear_db_record(iface_cfg, errp); + free(errp); + return false; } /* Get or create the port structure. */ @@ -1568,16 +1834,16 @@ iface_create(struct bridge *br, struct if_cfg *if_cfg, ofp_port_t ofp_port) hash_string(iface_cfg->name, 0)); iface->port = port; iface->name = xstrdup(iface_cfg->name); - iface->ofp_port = OFPP_NONE; + iface->ofp_port = ofp_port; iface->netdev = netdev; iface->type = iface_get_type(iface_cfg, br->cfg); iface->cfg = iface_cfg; - - iface_set_ofp_port(iface, ofp_port); + hmap_insert(&br->ifaces, &iface->ofp_port_node, + hash_ofp_port(ofp_port)); /* Populate initial status in database. */ iface_refresh_stats(iface); - iface_refresh_status(iface); + iface_refresh_netdev_status(iface); /* Add bond fake iface if necessary. */ if (port_is_bond_fake_iface(port)) { @@ -1590,8 +1856,7 @@ iface_create(struct bridge *br, struct if_cfg *if_cfg, ofp_port_t ofp_port) error = netdev_open(port->name, "internal", &netdev); if (!error) { - ofp_port_t fake_ofp_port = if_cfg->ofport; - + ofp_port_t fake_ofp_port = OFPP_NONE; ofproto_port_add(br->ofproto, netdev, &fake_ofp_port); netdev_close(netdev); } else { @@ -1604,11 +1869,7 @@ iface_create(struct bridge *br, struct if_cfg *if_cfg, ofp_port_t ofp_port) } } -done: - hmap_remove(&br->if_cfg_todo, &if_cfg->hmap_node); - free(if_cfg); - - return ok; + return true; } /* Set forward BPDU option. */ @@ -1644,32 +1905,65 @@ bridge_configure_mac_table(struct bridge *br) ofproto_set_mac_table_config(br->ofproto, idle_time, mac_table_size); } +/* Set multicast snooping table configuration for 'br'. */ static void -bridge_pick_local_hw_addr(struct bridge *br, uint8_t ea[ETH_ADDR_LEN], - struct iface **hw_addr_iface) +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 char *idle_time_str; + const char *max_entries_str; + + idle_time_str = smap_get(&br->cfg->other_config, + "mcast-snooping-aging-time"); + br_s.idle_time = (idle_time_str && atoi(idle_time_str) + ? atoi(idle_time_str) + : MCAST_ENTRY_DEFAULT_IDLE_TIME); + + max_entries_str = smap_get(&br->cfg->other_config, + "mcast-snooping-table-size"); + br_s.max_entries = (max_entries_str && atoi(max_entries_str) + ? atoi(max_entries_str) + : MCAST_DEFAULT_MAX_ENTRIES); + + br_s.flood_unreg = !smap_get_bool(&br->cfg->other_config, + "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; - const char *hwaddr; struct port *port; bool found_addr = false; int error; int i; - *hw_addr_iface = NULL; - - /* Did the user request a particular MAC? */ - hwaddr = smap_get(&br->cfg->other_config, "hwaddr"); - if (hwaddr && 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; - } - } - /* 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 @@ -1685,7 +1979,7 @@ bridge_pick_local_hw_addr(struct bridge *br, uint8_t ea[ETH_ADDR_LEN], /* Otherwise choose the minimum non-local MAC address among all of the * interfaces. */ HMAP_FOR_EACH (port, hmap_node, &br->ports) { - uint8_t iface_ea[ETH_ADDR_LEN]; + struct eth_addr iface_ea; struct iface *candidate; struct iface *iface; @@ -1696,12 +1990,13 @@ bridge_pick_local_hw_addr(struct bridge *br, uint8_t ea[ETH_ADDR_LEN], /* Choose the MAC address to represent the port. */ iface = NULL; - if (port->cfg->mac && eth_addr_from_string(port->cfg->mac, iface_ea)) { + 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) { - uint8_t candidate_ea[ETH_ADDR_LEN]; - if (!netdev_get_etheraddr(candidate->netdev, candidate_ea) + struct eth_addr candidate_ea; + if (!netdev_get_etheraddr(candidate->netdev, &candidate_ea) && eth_addr_equals(iface_ea, candidate_ea)) { iface = candidate; } @@ -1725,8 +2020,18 @@ bridge_pick_local_hw_addr(struct bridge *br, uint8_t ea[ETH_ADDR_LEN], 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); + error = netdev_get_etheraddr(iface->netdev, &iface_ea); if (error) { continue; } @@ -1737,22 +2042,46 @@ bridge_pick_local_hw_addr(struct bridge *br, uint8_t ea[ETH_ADDR_LEN], !eth_addr_is_local(iface_ea) && !eth_addr_is_reserved(iface_ea) && !eth_addr_is_zero(iface_ea) && - (!found_addr || eth_addr_compare_3way(iface_ea, ea) < 0)) + (!found_addr || eth_addr_compare_3way(iface_ea, *ea) < 0)) { - memcpy(ea, iface_ea, ETH_ADDR_LEN); + *ea = iface_ea; *hw_addr_iface = iface; found_addr = true; } } if (!found_addr) { - memcpy(ea, br->default_ea, ETH_ADDR_LEN); + *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) +{ + const char *hwaddr; + *hw_addr_iface = NULL; + + /* Did the user request a particular MAC? */ + hwaddr = smap_get(&br->cfg->other_config, "hwaddr"); + if (hwaddr && 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'. If 'bridge_ea' is the Ethernet address of * an interface on 'br', then that interface must be passed in as @@ -1760,7 +2089,7 @@ bridge_pick_local_hw_addr(struct bridge *br, uint8_t ea[ETH_ADDR_LEN], * 'hw_addr_iface' must be passed in as a null pointer. */ static uint64_t bridge_pick_datapath_id(struct bridge *br, - const uint8_t bridge_ea[ETH_ADDR_LEN], + const struct eth_addr bridge_ea, struct iface *hw_addr_iface) { /* @@ -1813,31 +2142,39 @@ bridge_pick_datapath_id(struct bridge *br, static uint64_t dpid_from_hash(const void *data, size_t n) { - uint8_t hash[SHA1_DIGEST_SIZE]; - - BUILD_ASSERT_DECL(sizeof hash >= ETH_ADDR_LEN); - sha1_bytes(data, n, hash); - eth_addr_mark_random(hash); - return eth_addr_to_uint64(hash); + union { + uint8_t bytes[SHA1_DIGEST_SIZE]; + struct eth_addr ea; + } hash; + + sha1_bytes(data, n, hash.bytes); + eth_addr_mark_random(&hash.ea); + return eth_addr_to_uint64(hash.ea); } static void -iface_refresh_status(struct iface *iface) +iface_refresh_netdev_status(struct iface *iface) { struct smap smap; enum netdev_features current; - int64_t bps; - int mtu; - int64_t mtu_64; - uint8_t mac[ETH_ADDR_LEN]; - int64_t ifindex64; - int error; + enum netdev_flags flags; + const char *link_state; + struct eth_addr mac; + int64_t bps, mtu_64, ifindex64, link_resets; + int mtu, error; 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)) { @@ -1848,6 +2185,21 @@ iface_refresh_status(struct iface *iface) 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, ¤t, NULL, NULL, NULL); bps = !error ? netdev_features_to_bps(current, 0) : 0; if (bps) { @@ -1868,11 +2220,12 @@ iface_refresh_status(struct iface *iface) ovsrec_interface_set_mtu(iface->cfg, NULL, 0); } - error = netdev_get_etheraddr(iface->netdev, mac); + error = netdev_get_etheraddr(iface->netdev, &mac); if (!error) { - char mac_string[32]; + char mac_string[ETH_ADDR_STRLEN + 1]; - sprintf(mac_string, ETH_ADDR_FMT, ETH_ADDR_ARGS(mac)); + 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); @@ -1887,16 +2240,55 @@ iface_refresh_status(struct iface *iface) ovsrec_interface_set_ifindex(iface->cfg, &ifindex64, 1); } +static void +iface_refresh_ofproto_status(struct iface *iface) +{ + int current; + + if (iface_is_synthetic(iface)) { + return; + } + + 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 ofproto_cfm_status status; + struct cfm_status status; + int error; - if (!ofproto_port_get_cfm_status(iface->port->bridge->ofproto, - iface->ofp_port, &status)) { + 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); @@ -1919,7 +2311,7 @@ iface_refresh_cfm_stats(struct iface *iface) reasons[j++] = cfm_fault_reason_to_str(reason); } } - ovsrec_interface_set_cfm_fault_status(cfg, (char **) reasons, j); + ovsrec_interface_set_cfm_fault_status(cfg, reasons, j); ovsrec_interface_set_cfm_flap_count(cfg, &cfm_flap_count, 1); @@ -1964,7 +2356,7 @@ iface_refresh_stats(struct iface *iface) enum { N_IFACE_STATS = IFACE_STATS }; #undef IFACE_STAT int64_t values[N_IFACE_STATS]; - char *keys[N_IFACE_STATS]; + const char *keys[N_IFACE_STATS]; int n; struct netdev_stats stats; @@ -1993,6 +2385,19 @@ iface_refresh_stats(struct iface *iface) #undef IFACE_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 : ""); +} + static void br_refresh_stp_status(struct bridge *br) { @@ -2063,7 +2468,7 @@ port_refresh_stp_stats(struct port *port) struct ofproto *ofproto = port->bridge->ofproto; struct iface *iface; struct ofproto_port_stp_stats stats; - char *keys[3]; + const char *keys[3]; int64_t int_values[3]; if (port_is_synthetic(port)) { @@ -2097,6 +2502,118 @@ port_refresh_stp_stats(struct port *port) 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; + const char *keys[4]; + int64_t int_values[4]; + struct smap smap; + + if (port_is_synthetic(port)) { + return; + } + + /* RSTP doesn't currently support bonds. */ + if (!list_is_singleton(&port->ifaces)) { + ovsrec_port_set_rstp_status(port->cfg, NULL); + return; + } + + iface = CONTAINER_OF(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); + ovsrec_port_set_rstp_statistics(port->cfg, NULL, NULL, 0); + 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); + + /* 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 (list_is_singleton(&port->ifaces)) { + return; + } + + if (bond_get_changed_active_slave(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) { @@ -2136,7 +2653,7 @@ run_system_stats(void) } } -static inline const char * +static const char * ofp12_controller_role_to_str(enum ofp12_controller_role role) { switch (role) { @@ -2172,20 +2689,10 @@ refresh_controller_status(void) shash_find_data(&info, cfg->target); if (cinfo) { - struct smap smap = SMAP_INITIALIZER(&smap); - const char **values = cinfo->pairs.values; - const char **keys = cinfo->pairs.keys; - size_t i; - - for (i = 0; i < cinfo->pairs.n; i++) { - smap_add(&smap, keys[i], values[i]); - } - ovsrec_controller_set_is_connected(cfg, cinfo->is_connected); ovsrec_controller_set_role(cfg, ofp12_controller_role_to_str( cinfo->role)); - ovsrec_controller_set_status(cfg, &smap); - smap_destroy(&smap); + ovsrec_controller_set_status(cfg, &cinfo->pairs); } else { ovsrec_controller_set_is_connected(cfg, false); ovsrec_controller_set_role(cfg, NULL); @@ -2196,157 +2703,186 @@ refresh_controller_status(void) ofproto_free_ofproto_controller_info(&info); } -/* "Instant" stats. - * - * Some information in the database must be kept as up-to-date as possible to - * allow controllers to respond rapidly to network outages. We call these - * statistics "instant" stats. - * - * We wish to update these statistics every INSTANT_INTERVAL_MSEC milliseconds, - * assuming that they've changed. The only means we have to determine whether - * they have changed are: - * - * - Try to commit changes to the database. If nothing changed, then - * ovsdb_idl_txn_commit() returns TXN_UNCHANGED, otherwise some other - * value. - * - * - instant_stats_run() is called late in the run loop, after anything that - * might change any of the instant stats. - * - * We use these two facts together to avoid waking the process up every - * INSTANT_INTERVAL_MSEC whether there is any change or not. - */ +/* 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; -/* Minimum interval between writing updates to the instant stats to the - * database. */ -#define INSTANT_INTERVAL_MSEC 100 + if (!cfg) { + return; + } -/* Current instant stats database transaction, NULL if there is no ongoing - * transaction. */ -static struct ovsdb_idl_txn *instant_txn; + /* 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; + } -/* Next time (in msec on monotonic clock) at which we will update the instant - * stats. */ -static long long int instant_next_txn = LLONG_MIN; + if (time_msec() >= stats_timer) { + enum ovsdb_idl_txn_status status; -/* True if the run loop has run since we last saw that the instant stats were - * unchanged, that is, this is true if we need to wake up at 'instant_next_txn' - * to refresh the instant stats. */ -static bool instant_stats_could_have_changed; + /* Rate limit the update. Do not start a new update if the + * previous one is not done. */ + if (!stats_txn) { + struct bridge *br; -static void -instant_stats_run(void) -{ - enum ovsdb_idl_txn_status status; + stats_txn = ovsdb_idl_txn_create(idl); + HMAP_FOR_EACH (br, node, &all_bridges) { + struct port *port; + struct mirror *m; - instant_stats_could_have_changed = true; + HMAP_FOR_EACH (port, hmap_node, &br->ports) { + struct iface *iface; - if (!instant_txn) { - struct bridge *br; + LIST_FOR_EACH (iface, port_elem, &port->ifaces) { + iface_refresh_stats(iface); + } + port_refresh_stp_stats(port); + } + HMAP_FOR_EACH (m, hmap_node, &br->mirrors) { + mirror_refresh_stats(m); + } + } + refresh_controller_status(); + } - if (time_msec() < instant_next_txn) { - return; + 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; } - instant_next_txn = time_msec() + INSTANT_INTERVAL_MSEC; + } +} - instant_txn = ovsdb_idl_txn_create(idl); - HMAP_FOR_EACH (br, node, &all_bridges) { - struct iface *iface; - struct port *port; +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); + } +} - br_refresh_stp_status(br); +/* Update bridge/port/interface status if necessary. */ +static void +run_status_update(void) +{ + if (!status_txn) { + uint64_t seq; - HMAP_FOR_EACH (port, hmap_node, &br->ports) { - port_refresh_stp_status(port); - } + /* 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) { + struct bridge *br; - HMAP_FOR_EACH (iface, name_node, &br->iface_by_name) { - enum netdev_flags flags; - struct smap smap; - const char *link_state; - int64_t link_resets; - int current, error; + connectivity_seqno = seq; + status_txn = ovsdb_idl_txn_create(idl); + HMAP_FOR_EACH (br, node, &all_bridges) { + struct port *port; - if (iface_is_synthetic(iface)) { - continue; - } + 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; - current = ofproto_port_is_lacp_current(br->ofproto, - iface->ofp_port); - if (current >= 0) { - bool bl = current; - ovsrec_interface_set_lacp_current(iface->cfg, &bl, 1); - } else { - ovsrec_interface_set_lacp_current(iface->cfg, NULL, 0); + 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); + } } + } + } + } - 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); - } + /* 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; - link_state = netdev_get_carrier(iface->netdev) ? "up" : "down"; - ovsrec_interface_set_link_state(iface->cfg, link_state); + status = ovsdb_idl_txn_commit(status_txn); + if (status != TXN_INCOMPLETE) { + ovsdb_idl_txn_destroy(status_txn); + status_txn = NULL; - link_resets = netdev_get_carrier_resets(iface->netdev); - ovsrec_interface_set_link_resets(iface->cfg, &link_resets, 1); + /* 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; - iface_refresh_cfm_stats(iface); + HMAP_FOR_EACH (br, node, &all_bridges) { + if (bridge_aa_need_refresh(br)) { + struct ovsdb_idl_txn *txn; - smap_init(&smap); - ofproto_port_get_bfd_status(br->ofproto, iface->ofp_port, - &smap); - ovsrec_interface_set_bfd_status(iface->cfg, &smap); - smap_destroy(&smap); + txn = ovsdb_idl_txn_create(idl); + bridge_aa_refresh_queued(br); + ovsdb_idl_txn_commit(txn); + ovsdb_idl_txn_destroy(txn); } } - } - status = ovsdb_idl_txn_commit(instant_txn); - if (status != TXN_INCOMPLETE) { - ovsdb_idl_txn_destroy(instant_txn); - instant_txn = NULL; - } - if (status == TXN_UNCHANGED) { - instant_stats_could_have_changed = false; + aa_refresh_timer = time_msec() + AA_REFRESH_INTERVAL; } } static void -instant_stats_wait(void) +status_update_wait(void) { - if (instant_txn) { - ovsdb_idl_txn_wait(instant_txn); - } else if (instant_stats_could_have_changed) { - poll_timer_wait_until(instant_next_txn); + /* 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); } } - -/* Performs periodic activity required by bridges that needs to be done with - * the least possible latency. - * - * It makes sense to call this function a couple of times per poll loop, to - * provide a significant performance boost on some benchmarks with ofprotos - * that use the ofproto-dpif implementation. */ -void -bridge_run_fast(void) + +static void +bridge_run__(void) { + struct bridge *br; struct sset types; const char *type; - struct bridge *br; + /* 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_fast(type); + 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_fast(br->ofproto); + ofproto_run(br->ofproto); } } @@ -2355,38 +2891,36 @@ bridge_run(void) { static struct ovsrec_open_vswitch null_cfg; const struct ovsrec_open_vswitch *cfg; - struct ovsdb_idl_txn *reconf_txn = NULL; - struct sset types; - const char *type; bool vlan_splinters_changed; - struct bridge *br; ovsrec_open_vswitch_init(&null_cfg); - /* (Re)configure if necessary. */ - if (!reconfiguring) { - ovsdb_idl_run(idl); + ovsdb_idl_run(idl); - if (ovsdb_idl_is_lock_contended(idl)) { - static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 1); - struct bridge *br, *next_br; + if_notifier_run(); - VLOG_ERR_RL(&rl, "another ovs-vswitchd process is running, " - "disabling this process (pid %ld) until it goes away", - (long int) getpid()); + if (ovsdb_idl_is_lock_contended(idl)) { + static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 1); + struct bridge *br, *next_br; - HMAP_FOR_EACH_SAFE (br, next_br, node, &all_bridges) { - bridge_destroy(br); - } - /* 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)) { - return; + 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, next_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); @@ -2398,24 +2932,13 @@ bridge_run(void) /* 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)); - } - - /* 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); + 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. @@ -2429,59 +2952,48 @@ bridge_run(void) stream_ssl_set_ca_cert_file(ssl->ca_cert, ssl->bootstrap_ca_cert); } - if (!reconfiguring) { - /* If VLAN splinters are in use, then we need to reconfigure if VLAN - * usage has changed. */ - vlan_splinters_changed = false; - if (vlan_splinters_enabled_anywhere) { - HMAP_FOR_EACH (br, node, &all_bridges) { - if (ofproto_has_vlan_usage_changed(br->ofproto)) { - vlan_splinters_changed = true; - break; - } - } - } + /* If VLAN splinters are in use, then we need to reconfigure if VLAN + * usage has changed. */ + vlan_splinters_changed = false; + if (vlan_splinters_enabled_anywhere) { + struct bridge *br; - if (ovsdb_idl_get_seqno(idl) != idl_seqno || vlan_splinters_changed) { - idl_seqno = ovsdb_idl_get_seqno(idl); - if (cfg) { - reconf_txn = ovsdb_idl_txn_create(idl); - bridge_reconfigure(cfg); - } else { - /* We still need to reconfigure to avoid dangling pointers to - * now-destroyed ovsrec structures inside bridge data. */ - bridge_reconfigure(&null_cfg); + HMAP_FOR_EACH (br, node, &all_bridges) { + if (ofproto_has_vlan_usage_changed(br->ofproto)) { + vlan_splinters_changed = true; + break; } } } - if (reconfiguring) { - if (!reconf_txn) { - reconf_txn = ovsdb_idl_txn_create(idl); - } + if (ovsdb_idl_get_seqno(idl) != idl_seqno || vlan_splinters_changed + || ifaces_changed) { + struct ovsdb_idl_txn *txn; - if (bridge_reconfigure_continue(cfg ? cfg : &null_cfg)) { - reconfiguring = false; + ifaces_changed = false; - if (cfg) { - ovsrec_open_vswitch_set_cur_cfg(cfg, cfg->next_cfg); - } + idl_seqno = ovsdb_idl_get_seqno(idl); + txn = ovsdb_idl_txn_create(idl); + bridge_reconfigure(cfg ? cfg : &null_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) { - initial_config_done = true; - daemonize_txn = reconf_txn; - reconf_txn = NULL; - } + if (cfg) { + ovsrec_open_vswitch_set_cur_cfg(cfg, cfg->next_cfg); + discover_types(cfg); } - } - if (reconf_txn) { - ovsdb_idl_txn_commit(reconf_txn); - ovsdb_idl_txn_destroy(reconf_txn); - reconf_txn = NULL; + /* 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) { @@ -2500,42 +3012,9 @@ bridge_run(void) } } - /* Refresh interface and mirror stats if necessary. */ - if (time_msec() >= iface_stats_timer) { - if (cfg) { - struct ovsdb_idl_txn *txn; - - 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); - iface_refresh_status(iface); - } - - port_refresh_stp_stats(port); - } - - HMAP_FOR_EACH (m, hmap_node, &br->mirrors) { - mirror_refresh_stats(m); - } - - } - refresh_controller_status(); - ovsdb_idl_txn_commit(txn); - ovsdb_idl_txn_destroy(txn); /* XXX */ - } - - iface_stats_timer = time_msec() + IFACE_STATS_INTERVAL; - } - + run_stats_update(); + run_status_update(); run_system_stats(); - instant_stats_run(); } void @@ -2549,7 +3028,8 @@ bridge_wait(void) ovsdb_idl_txn_wait(daemonize_txn); } - if (reconfiguring) { + if_notifier_wait(); + if (ifaces_changed) { poll_immediate_wake(); } @@ -2566,11 +3046,11 @@ bridge_wait(void) HMAP_FOR_EACH (br, node, &all_bridges) { ofproto_wait(br->ofproto); } - poll_timer_wait_until(iface_stats_timer); + stats_update_wait(); + status_update_wait(); } system_stats_wait(); - instant_stats_wait(); } /* Adds some memory usage statistics for bridges into 'usage', for use with @@ -2579,6 +3059,15 @@ 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); @@ -2692,28 +3181,24 @@ bridge_create(const struct ovsrec_bridge *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); + 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->if_cfg_todo); - list_init(&br->ofpp_garbage); - + hmap_init(&br->mappings); hmap_insert(&all_bridges, &br->node, hash_string(br->name, 0)); } static void -bridge_destroy(struct bridge *br) +bridge_destroy(struct bridge *br, bool del) { if (br) { struct mirror *mirror, *next_mirror; struct port *port, *next_port; - struct if_cfg *if_cfg, *next_if_cfg; - struct ofpp_garbage *garbage, *next_garbage; HMAP_FOR_EACH_SAFE (port, next_port, hmap_node, &br->ports) { port_destroy(port); @@ -2721,23 +3206,14 @@ bridge_destroy(struct bridge *br) HMAP_FOR_EACH_SAFE (mirror, next_mirror, hmap_node, &br->mirrors) { mirror_destroy(mirror); } - HMAP_FOR_EACH_SAFE (if_cfg, next_if_cfg, hmap_node, &br->if_cfg_todo) { - hmap_remove(&br->if_cfg_todo, &if_cfg->hmap_node); - free(if_cfg); - } - LIST_FOR_EACH_SAFE (garbage, next_garbage, list_node, - &br->ofpp_garbage) { - list_remove(&garbage->list_node); - free(garbage); - } hmap_remove(&all_bridges, &br->node); - ofproto_destroy(br->ofproto); + 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->if_cfg_todo); + hmap_destroy(&br->mappings); free(br->name); free(br->type); free(br); @@ -2824,44 +3300,23 @@ bridge_get_controllers(const struct bridge *br, } static void -bridge_queue_if_cfg(struct bridge *br, - const struct ovsrec_interface *cfg, - const struct ovsrec_port *parent) -{ - struct if_cfg *if_cfg = xmalloc(sizeof *if_cfg); - - if_cfg->cfg = cfg; - if_cfg->parent = parent; - if_cfg->ofport = iface_pick_ofport(cfg); - hmap_insert(&br->if_cfg_todo, &if_cfg->hmap_node, - hash_string(if_cfg->cfg->name, 0)); -} - -/* 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_add_del_ports(struct bridge *br, - const unsigned long int *splinter_vlans) +bridge_collect_wanted_ports(struct bridge *br, + const unsigned long int *splinter_vlans, + struct shash *wanted_ports) { - struct shash_node *port_node; - struct port *port, *next; - struct shash new_ports; size_t i; - ovs_assert(hmap_is_empty(&br->if_cfg_todo)); + shash_init(wanted_ports); - /* Collect new ports. */ - shash_init(&new_ports); for (i = 0; i < br->cfg->n_ports; i++) { const char *name = br->cfg->ports[i]->name; - if (!shash_add_once(&new_ports, name, br->cfg->ports[i])) { + 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(&new_ports, br->name)) { + && !shash_find(wanted_ports, br->name)) { VLOG_WARN("bridge %s: no port named %s, synthesizing one", br->name, br->name); @@ -2877,17 +3332,27 @@ bridge_add_del_ports(struct bridge *br, br->synth_local_ifacep = &br->synth_local_iface; - shash_add(&new_ports, br->name, &br->synth_local_port); + shash_add(wanted_ports, br->name, &br->synth_local_port); } if (splinter_vlans) { - add_vlan_splinter_ports(br, splinter_vlans, &new_ports); + add_vlan_splinter_ports(br, splinter_vlans, wanted_ports); } +} + +/* 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, *next; /* Get rid of deleted ports. * Get rid of deleted interfaces on ports that still exist. */ HMAP_FOR_EACH_SAFE (port, next, hmap_node, &br->ports) { - port->cfg = shash_find_data(&new_ports, port->name); + port->cfg = shash_find_data(wanted_ports, port->name); if (!port->cfg) { port_destroy(port); } else { @@ -2895,9 +3360,8 @@ bridge_add_del_ports(struct bridge *br, } } - /* Update iface->cfg and iface->type in interfaces that still exist. - * Add new interfaces to creation queue. */ - SHASH_FOR_EACH (port_node, &new_ports) { + /* Update iface->cfg and iface->type in interfaces that still exist. */ + SHASH_FOR_EACH (port_node, wanted_ports) { const struct ovsrec_port *port = port_node->data; size_t i; @@ -2915,12 +3379,10 @@ bridge_add_del_ports(struct bridge *br, " dev@openvswitch.org with concerns.", cfg->name); } else { - bridge_queue_if_cfg(br, cfg, port); + /* We will add new interfaces later. */ } } } - - shash_destroy(&new_ports); } /* Initializes 'oc' appropriately as a management service controller for @@ -2938,6 +3400,7 @@ bridge_ofproto_controller_for_mgmt(const struct bridge *br, oc->rate_limit = 0; oc->burst_limit = 0; oc->enable_async_msgs = true; + oc->dscp = 0; } /* Converts ovsrec_controller 'c' into an ofproto_controller in 'oc'. */ @@ -2978,7 +3441,7 @@ bridge_configure_local_iface_netdev(struct bridge *br, /* 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 || !inet_aton(c->local_ip, &ip)) { + if (!local_iface || !c->local_ip || !ip_parse(c->local_ip, &ip.s_addr)) { return; } @@ -2988,7 +3451,7 @@ bridge_configure_local_iface_netdev(struct bridge *br, /* Configure the IP address and netmask. */ if (!c->local_netmask - || !inet_aton(c->local_netmask, &mask) + || !ip_parse(c->local_netmask, &mask.s_addr) || !mask.s_addr) { mask.s_addr = guess_netmask(ip.s_addr); } @@ -2999,7 +3462,7 @@ bridge_configure_local_iface_netdev(struct bridge *br, /* Configure the default gateway. */ if (c->local_gateway - && inet_aton(c->local_gateway, &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, @@ -3101,18 +3564,20 @@ bridge_configure_remotes(struct bridge *br, continue; } } else { - whitelist = xasprintf("punix:%s/%s.controller", + whitelist = xasprintf("punix:%s/%s.", ovs_rundir(), br->name); - if (!equal_pathnames(c->target, whitelist, SIZE_MAX)) { + if (!equal_pathnames(c->target, whitelist, strlen(whitelist)) + || strchr(c->target + strlen(whitelist), '/')) { /* Prevent remote ovsdb-server users from accessing * arbitrary Unix domain sockets and overwriting arbitrary * local files. */ VLOG_ERR_RL(&rl, "bridge %s: Not adding Unix domain socket " "controller \"%s\" due to possibility of " "overwriting local files. Instead, specify " - "whitelisted \"%s\" or connect to " - "\"unix:%s/%s.mgmt\" (which is always " - "available without special configuration).", + "path in whitelisted format \"%s*\" or " + "connect to \"unix:%s/%s.mgmt\" (which is " + "always available without special " + "configuration).", br->name, c->target, whitelist, ovs_rundir(), br->name); free(whitelist); @@ -3166,10 +3631,12 @@ bridge_configure_tables(struct bridge *br) 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)); @@ -3181,9 +3648,10 @@ bridge_configure_tables(struct bridge *br) if (cfg->n_flow_limit && *cfg->flow_limit < UINT_MAX) { s.max_flows = *cfg->flow_limit; } - if (cfg->overflow_policy - && !strcmp(cfg->overflow_policy, "evict")) { + 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 (k = 0; k < cfg->n_groups; k++) { const char *string = cfg->groups[k]; @@ -3203,11 +3671,19 @@ bridge_configure_tables(struct bridge *br) } } } + /* Prefix lookup fields. */ s.n_prefix_fields = 0; for (k = 0; k < cfg->n_prefixes; k++) { const char *name = cfg->prefixes[k]; - const struct mf_field *mf = mf_from_name(name); + 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); @@ -3223,21 +3699,30 @@ bridge_configure_tables(struct bridge *br) "field not used: %s", br->name, name); continue; } + use_default_prefixes = false; s.prefix_fields[s.n_prefix_fields++] = mf->id; } - if (s.n_prefix_fields > 0) { - int k; - struct ds ds = DS_EMPTY_INITIALIZER; - for (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 (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 { + int k; + struct ds ds = DS_EMPTY_INITIALIZER; + for (k = 0; k < s.n_prefix_fields; k++) { + if (k) { + ds_put_char(&ds, ','); } - VLOG_INFO("bridge %s table %d: Prefix lookup with: %s.", - br->name, i, ds_cstr(&ds)); - ds_destroy(&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); @@ -3257,6 +3742,233 @@ bridge_configure_dp_desc(struct bridge *br) ofproto_set_dp_desc(br->ofproto, smap_get(&br->cfg->other_config, "dp-desc")); } + +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, *next; + 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, next, hmap_node, &br->mappings) { + union ovsdb_atom atom; + + atom.integer = m->isid; + if (ovsdb_datum_find_key(mc, &atom, OVSDB_TYPE_UUID) == UINT_MAX) { + 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) { + struct aa_mapping *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); + } +} + +static void +bridge_aa_refresh_queued(struct bridge *br) +{ + struct ovs_list *list = xmalloc(sizeof *list); + struct bridge_aa_vlan *node, *next; + + list_init(list); + ofproto_aa_vlan_get_queued(br->ofproto, list); + + LIST_FOR_EACH_SAFE (node, next, 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); + } + + list_remove(&node->list_node); + free(node->port_name); + free(node); + } + + free(list); +} + /* Port functions. */ @@ -3315,7 +4027,7 @@ port_destroy(struct port *port) } LIST_FOR_EACH_SAFE (iface, next, port_elem, &port->ifaces) { - iface_destroy(iface); + iface_destroy__(iface); } hmap_remove(&br->ports, &port->hmap_node); @@ -3381,7 +4093,7 @@ port_configure_lacp(struct port *port, struct lacp_settings *s) return NULL; } } else { - memcpy(s->id, port->bridge->ea, ETH_ADDR_LEN); + s->id = port->bridge->ea; } if (eth_addr_is_zero(s->id)) { @@ -3438,6 +4150,7 @@ 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; @@ -3488,14 +4201,19 @@ port_configure_bond(struct port *port, struct bond_settings *s) s->rebalance_interval = 1000; } - s->fake_iface = port->cfg->bond_fake_iface; - s->lacp_fallback_ab_cfg = smap_get_bool(&port->cfg->other_config, "lacp-fallback-ab", false); 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_slave_mac))) { + /* OVSDB did not store the last active interface */ + s->active_slave_mac = eth_addr_zero; + } } /* Returns true if 'port' is synthetic, that is, if we constructed it locally @@ -3537,7 +4255,7 @@ iface_get_type(const struct ovsrec_interface *iface, } static void -iface_destroy(struct iface *iface) +iface_destroy__(struct iface *iface) { if (iface) { struct port *port = iface->port; @@ -3554,13 +4272,28 @@ iface_destroy(struct iface *iface) list_remove(&iface->port_elem); hmap_remove(&br->iface_by_name, &iface->name_node); - netdev_close(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 (list_is_empty(&port->ifaces)) { + port_destroy(port); + } + } +} + static struct iface * iface_lookup(const struct bridge *br, const char *name) { @@ -3591,21 +4324,6 @@ iface_find(const char *name) return NULL; } -static struct if_cfg * -if_cfg_lookup(const struct bridge *br, const char *name) -{ - struct if_cfg *if_cfg; - - HMAP_FOR_EACH_WITH_HASH (if_cfg, hmap_node, hash_string(name, 0), - &br->if_cfg_todo) { - if (!strcmp(if_cfg->cfg->name, name)) { - return if_cfg; - } - } - - return NULL; -} - static struct iface * iface_from_ofp_port(const struct bridge *br, ofp_port_t ofp_port) { @@ -3623,21 +4341,33 @@ iface_from_ofp_port(const struct bridge *br, ofp_port_t ofp_port) /* Set Ethernet address of 'iface', if one is specified in the configuration * file. */ static void -iface_set_mac(struct iface *iface) +iface_set_mac(const struct bridge *br, const struct port *port, struct iface *iface) { - uint8_t ea[ETH_ADDR_LEN]; + 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 (!strcmp(iface->type, "internal") - && iface->cfg->mac && eth_addr_from_string(iface->cfg->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(ea)) { + } else if (eth_addr_is_multicast(*mac)) { VLOG_ERR("interface %s: cannot set MAC to multicast address", iface->name); } else { - int error = netdev_set_etheraddr(iface->netdev, ea); + int error = netdev_set_etheraddr(iface->netdev, *mac); if (error) { VLOG_ERR("interface %s: setting MAC failed (%s)", iface->name, ovs_strerror(error)); @@ -3662,9 +4392,11 @@ iface_set_ofport(const struct ovsrec_interface *if_cfg, ofp_port_t ofport) * 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) +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); @@ -3697,7 +4429,7 @@ iface_configure_qos(struct iface *iface, const struct ovsrec_qos *qos) ofpbuf_init(&queues_buf, 0); - if (!qos || qos->type[0] == '\0' || qos->n_queues < 1) { + if (!qos || qos->type[0] == '\0') { netdev_set_qos(iface->netdev, NULL, NULL); } else { const struct ovsdb_datum *queues; @@ -3760,8 +4492,8 @@ iface_configure_qos(struct iface *iface, const struct ovsrec_qos *qos) } netdev_set_policing(iface->netdev, - iface->cfg->ingress_policing_rate, - iface->cfg->ingress_policing_burst); + MIN(UINT32_MAX, iface->cfg->ingress_policing_rate), + MIN(UINT32_MAX, iface->cfg->ingress_policing_burst)); ofpbuf_uninit(&queues_buf); } @@ -3830,14 +4562,27 @@ iface_is_synthetic(const struct iface *iface) } static ofp_port_t -iface_pick_ofport(const struct ovsrec_interface *cfg) +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) { - ofp_port_t ofport = cfg->n_ofport ? u16_to_ofp(*cfg->ofport) - : OFPP_NONE; - return cfg->n_ofport_request ? u16_to_ofp(*cfg->ofport_request) - : ofport; + 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. */ @@ -4200,7 +4945,7 @@ collect_splinter_vlans(const struct ovsrec_open_vswitch *ovs_cfg) sset_destroy(&splinter_ifaces); - if (bitmap_scan(splinter_vlans, 0, 4096) >= 4096) { + if (bitmap_scan(splinter_vlans, 1, 0, 4096) >= 4096) { free(splinter_vlans); return NULL; } @@ -4303,7 +5048,7 @@ mirror_refresh_stats(struct mirror *m) { struct ofproto *ofproto = m->bridge->ofproto; uint64_t tx_packets, tx_bytes; - char *keys[2]; + const char *keys[2]; int64_t values[2]; size_t stat_cnt = 0; @@ -4325,3 +5070,31 @@ mirror_refresh_stats(struct mirror *m) 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); +}