X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=vswitchd%2Fbridge.c;h=dbce59a32d50177a6cc6f58d8b2fdc96ea498351;hb=12eb035b810ff9d537d6ff9f1eb8ad5564c1f644;hp=6a25b9590bac104cb1bc695d691713f7e024aea6;hpb=80740385d2700b1a03d28a02338d02509fd0b697;p=sliver-openvswitch.git diff --git a/vswitchd/bridge.c b/vswitchd/bridge.c index 6a25b9590..1145e98db 100644 --- a/vswitchd/bridge.c +++ b/vswitchd/bridge.c @@ -1,4 +1,4 @@ -/* Copyright (c) 2008, 2009, 2010, 2011 Nicira Networks +/* Copyright (c) 2008, 2009, 2010, 2011, 2012, 2013, 2014 Nicira, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,37 +15,47 @@ #include #include "bridge.h" -#include #include #include #include +#include "async-append.h" +#include "bfd.h" #include "bitmap.h" -#include "bond.h" #include "cfm.h" +#include "connectivity.h" #include "coverage.h" #include "daemon.h" #include "dirs.h" #include "dynamic-string.h" #include "hash.h" #include "hmap.h" +#include "hmapx.h" #include "jsonrpc.h" #include "lacp.h" #include "list.h" +#include "mac-learning.h" +#include "meta-flow.h" #include "netdev.h" #include "ofp-print.h" +#include "ofp-util.h" #include "ofpbuf.h" +#include "ofproto/bond.h" #include "ofproto/ofproto.h" #include "poll-loop.h" +#include "seq.h" #include "sha1.h" #include "shash.h" +#include "smap.h" #include "socket-util.h" +#include "stream.h" #include "stream-ssl.h" #include "sset.h" #include "system-stats.h" #include "timeval.h" #include "util.h" #include "unixctl.h" -#include "vswitchd/vswitch-idl.h" +#include "vlandev.h" +#include "lib/vswitch-idl.h" #include "xenserver.h" #include "vlog.h" #include "sflow_api.h" @@ -56,18 +66,20 @@ VLOG_DEFINE_THIS_MODULE(bridge); COVERAGE_DEFINE(bridge_reconfigure); struct iface { - /* These members are always valid. */ + /* These members are always valid. + * + * They are immutable: they never change between iface_create() and + * iface_destroy(). */ struct 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. */ - tag_type tag; /* Tag associated with this interface. */ - - /* 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. */ - int ofp_port; /* OpenFlow port number, -1 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; }; @@ -77,11 +89,12 @@ struct mirror { struct hmap_node hmap_node; /* In struct bridge's "mirrors" hmap. */ struct bridge *bridge; char *name; + const struct ovsrec_mirror *cfg; }; struct port { - struct bridge *bridge; struct hmap_node hmap_node; /* Element in struct bridge's "ports" hmap. */ + struct bridge *bridge; char *name; const struct ovsrec_port *cfg; @@ -110,6 +123,9 @@ struct bridge { /* Port mirroring. */ struct hmap mirrors; /* "struct mirror" 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; @@ -122,20 +138,70 @@ static struct hmap all_bridges = HMAP_INITIALIZER(&all_bridges); /* OVSDB IDL used to obtain configuration. */ static struct ovsdb_idl *idl; -/* Each time this timer expires, the bridge fetches systems and interface +/* We want to complete daemonization, fully detaching from our parent process, + * only after we have completed our initial configuration, committed our state + * to the database, and received confirmation back from the database server + * that it applied the commit. This allows our parent process to know that, + * post-detach, ephemeral fields such as datapath-id and ofport are very likely + * to have already been filled in. (It is only "very likely" rather than + * certain because there is always a slim possibility that the transaction will + * fail or that some other client has added new bridges, ports, etc. while + * ovs-vswitchd was configuring using an old configuration.) + * + * We only need to do this once for our initial configuration at startup, so + * 'initial_config_done' tracks whether we've already done it. While we are + * waiting for a response to our commit, 'daemonize_txn' tracks the transaction + * itself and is otherwise NULL. */ +static bool initial_config_done; +static struct ovsdb_idl_txn *daemonize_txn; + +/* Most recently processed IDL sequence number. */ +static unsigned int idl_seqno; + +/* Track changes to port connectivity. */ +static uint64_t connectivity_seqno = LLONG_MIN; + +/* Status update to database. + * + * Some information in the database must be kept as up-to-date as possible to + * allow controllers to respond rapidly to network outages. Those status are + * updated via the 'status_txn'. + * + * We use the global connectivity sequence number to detect the status change. + * Also, to prevent the status update from sending too much to the database, + * we check the return status of each update transaction and do not start new + * update if the previous transaction status is 'TXN_INCOMPLETE'. + * + * 'statux_txn' is NULL if there is no ongoing status update. + */ +static struct ovsdb_idl_txn *status_txn; + +/* 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 + +/* Each time this timer expires, the bridge fetches interface and mirror * statistics and pushes them into the database. */ -#define STATS_INTERVAL (5 * 1000) /* In milliseconds. */ +static int stats_timer_interval; static long long int stats_timer = LLONG_MIN; -/* Stores the time after which rate limited statistics may be written to the - * database. Only updated when changes to the database require rate limiting. - */ -#define DB_LIMIT_INTERVAL (1 * 1000) /* In milliseconds. */ -static long long int db_limiter = LLONG_MIN; +/* Set to true to allow experimental use of OpenFlow 1.4. + * This is false initially because OpenFlow 1.4 is not yet safe to use: it can + * abort due to unimplemented features. */ +static bool allow_of14; + +/* 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 void add_del_bridges(const struct ovsrec_open_vswitch *); -static void bridge_del_ofprotos(void); -static bool bridge_add_ofprotos(struct bridge *); +static void bridge_run__(void); static void bridge_create(const struct ovsrec_bridge *); static void bridge_destroy(struct bridge *); static struct bridge *bridge_lookup(const char *name); @@ -143,16 +209,25 @@ static unixctl_cb_func bridge_unixctl_dump_flows; static unixctl_cb_func bridge_unixctl_reconnect; static size_t bridge_get_controllers(const struct bridge *br, struct ovsrec_controller ***controllersp); -static void bridge_add_del_ports(struct bridge *); -static void bridge_add_ofproto_ports(struct bridge *); -static void bridge_del_ofproto_ports(struct bridge *); -static void bridge_refresh_ofp_port(struct bridge *); +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_flow_eviction_threshold(struct bridge *); static void bridge_configure_netflow(struct bridge *); static void bridge_configure_forward_bpdu(struct bridge *); +static void bridge_configure_mac_table(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_tables(struct bridge *); +static void bridge_configure_dp_desc(struct bridge *); static void bridge_configure_remotes(struct bridge *, const struct sockaddr_in *managers, size_t n_managers); @@ -162,11 +237,6 @@ static void bridge_pick_local_hw_addr(struct bridge *, static uint64_t bridge_pick_datapath_id(struct bridge *, const uint8_t bridge_ea[ETH_ADDR_LEN], struct iface *hw_addr_iface); -static const char *bridge_get_other_config(const struct ovsrec_bridge *, - const char *key); -static const char *get_port_other_config(const struct ovsrec_port *, - const char *key, - const char *default_value); static uint64_t dpid_from_hash(const void *, size_t nbytes); static bool bridge_has_bond_fake_iface(const struct bridge *, const char *name); @@ -175,45 +245,112 @@ static bool port_is_bond_fake_iface(const struct port *); static unixctl_cb_func qos_unixctl_show; static struct port *port_create(struct bridge *, const struct ovsrec_port *); -static void port_add_ifaces(struct port *); static void port_del_ifaces(struct port *); static void port_destroy(struct port *); static struct port *port_lookup(const struct bridge *, const char *name); static void port_configure(struct port *); static struct lacp_settings *port_configure_lacp(struct port *, struct lacp_settings *); -static void port_configure_bond(struct port *, struct bond_settings *, - uint32_t *bond_stable_ids); +static void port_configure_bond(struct port *, struct bond_settings *); static bool port_is_synthetic(const struct port *); +static void reconfigure_system_stats(const struct ovsrec_open_vswitch *); +static void run_system_stats(void); + static void bridge_configure_mirrors(struct bridge *); static struct mirror *mirror_create(struct bridge *, const struct ovsrec_mirror *); static void mirror_destroy(struct mirror *); -static bool mirror_configure(struct mirror *, const struct ovsrec_mirror *); +static bool mirror_configure(struct mirror *); +static void mirror_refresh_stats(struct mirror *); static void iface_configure_lacp(struct iface *, struct lacp_slave_settings *); -static struct iface *iface_create(struct port *port, - const struct ovsrec_interface *if_cfg); +static bool iface_create(struct bridge *, const struct ovsrec_interface *, + const struct ovsrec_port *); +static bool iface_is_internal(const struct ovsrec_interface *iface, + const struct ovsrec_bridge *br); +static const char *iface_get_type(const struct ovsrec_interface *, + const struct ovsrec_bridge *); static void iface_destroy(struct iface *); +static void iface_destroy__(struct iface *); static struct iface *iface_lookup(const struct bridge *, const char *name); static struct iface *iface_find(const char *name); static struct iface *iface_from_ofp_port(const struct bridge *, - uint16_t ofp_port); -static void iface_set_mac(struct iface *); -static void iface_set_ofport(const struct ovsrec_interface *, int64_t ofport); + ofp_port_t ofp_port); +static void iface_set_mac(const struct bridge *, const struct port *, struct iface *); +static void iface_set_ofport(const struct ovsrec_interface *, ofp_port_t ofport); static void iface_clear_db_record(const struct ovsrec_interface *if_cfg); 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 + * in old versions of Linux that do not properly support VLANs when VLAN + * devices are not used. When broken device drivers are no longer in + * widespread use, we will delete these interfaces. */ + +/* True if VLAN splinters are enabled on any interface, false otherwise.*/ +static bool vlan_splinters_enabled_anywhere; + +static bool vlan_splinters_is_enabled(const struct ovsrec_interface *); +static unsigned long int *collect_splinter_vlans( + const struct ovsrec_open_vswitch *); +static void configure_splinter_port(struct port *); +static void add_vlan_splinter_ports(struct bridge *, + const unsigned long int *splinter_vlans, + struct shash *ports); + +static void +bridge_init_ofproto(const struct ovsrec_open_vswitch *cfg) +{ + struct shash iface_hints; + static bool initialized = false; + int i; + + if (initialized) { + return; + } + + shash_init(&iface_hints); + + if (cfg) { + for (i = 0; i < cfg->n_bridges; i++) { + const struct ovsrec_bridge *br_cfg = cfg->bridges[i]; + int j; -static void shash_from_ovs_idl_map(char **keys, char **values, size_t n, - struct shash *); -static void shash_to_ovs_idl_map(struct shash *, - char ***keys, char ***values, size_t *n); + for (j = 0; j < br_cfg->n_ports; j++) { + struct ovsrec_port *port_cfg = br_cfg->ports[j]; + int k; + + for (k = 0; k < port_cfg->n_interfaces; k++) { + struct ovsrec_interface *if_cfg = port_cfg->interfaces[k]; + struct iface_hint *iface_hint; + + iface_hint = xmalloc(sizeof *iface_hint); + iface_hint->br_name = br_cfg->name; + iface_hint->br_type = br_cfg->datapath_type; + iface_hint->ofp_port = iface_pick_ofport(if_cfg); + + shash_add(&iface_hints, if_cfg->name, iface_hint); + } + } + } + } + + ofproto_init(&iface_hints); + + shash_destroy_free_data(&iface_hints); + initialized = true; +} /* Public functions. */ @@ -224,8 +361,10 @@ void bridge_init(const char *remote) { /* Create connection to database. */ - idl = ovsdb_idl_create(remote, &ovsrec_idl_class, true); + idl = ovsdb_idl_create(remote, &ovsrec_idl_class, true, true); + idl_seqno = ovsdb_idl_get_seqno(idl); ovsdb_idl_set_lock(idl, "ovs_vswitchd"); + ovsdb_idl_verify_write_only(idl); ovsdb_idl_omit_alert(idl, &ovsrec_open_vswitch_col_cur_cfg); ovsdb_idl_omit_alert(idl, &ovsrec_open_vswitch_col_statistics); @@ -242,19 +381,25 @@ bridge_init(const char *remote) ovsdb_idl_omit_alert(idl, &ovsrec_port_col_status); ovsdb_idl_omit_alert(idl, &ovsrec_port_col_statistics); ovsdb_idl_omit(idl, &ovsrec_port_col_external_ids); - ovsdb_idl_omit(idl, &ovsrec_port_col_fake_bridge); ovsdb_idl_omit_alert(idl, &ovsrec_interface_col_admin_state); ovsdb_idl_omit_alert(idl, &ovsrec_interface_col_duplex); ovsdb_idl_omit_alert(idl, &ovsrec_interface_col_link_speed); ovsdb_idl_omit_alert(idl, &ovsrec_interface_col_link_state); ovsdb_idl_omit_alert(idl, &ovsrec_interface_col_link_resets); + ovsdb_idl_omit_alert(idl, &ovsrec_interface_col_mac_in_use); + ovsdb_idl_omit_alert(idl, &ovsrec_interface_col_ifindex); ovsdb_idl_omit_alert(idl, &ovsrec_interface_col_mtu); ovsdb_idl_omit_alert(idl, &ovsrec_interface_col_ofport); ovsdb_idl_omit_alert(idl, &ovsrec_interface_col_statistics); ovsdb_idl_omit_alert(idl, &ovsrec_interface_col_status); ovsdb_idl_omit_alert(idl, &ovsrec_interface_col_cfm_fault); + ovsdb_idl_omit_alert(idl, &ovsrec_interface_col_cfm_fault_status); ovsdb_idl_omit_alert(idl, &ovsrec_interface_col_cfm_remote_mpids); + ovsdb_idl_omit_alert(idl, &ovsrec_interface_col_cfm_flap_count); + ovsdb_idl_omit_alert(idl, &ovsrec_interface_col_cfm_health); + ovsdb_idl_omit_alert(idl, &ovsrec_interface_col_cfm_remote_opstate); + ovsdb_idl_omit_alert(idl, &ovsrec_interface_col_bfd_status); ovsdb_idl_omit_alert(idl, &ovsrec_interface_col_lacp_current); ovsdb_idl_omit(idl, &ovsrec_interface_col_external_ids); @@ -268,10 +413,12 @@ bridge_init(const char *remote) ovsdb_idl_omit(idl, &ovsrec_queue_col_external_ids); ovsdb_idl_omit(idl, &ovsrec_mirror_col_external_ids); + ovsdb_idl_omit_alert(idl, &ovsrec_mirror_col_statistics); ovsdb_idl_omit(idl, &ovsrec_netflow_col_external_ids); - ovsdb_idl_omit(idl, &ovsrec_sflow_col_external_ids); + ovsdb_idl_omit(idl, &ovsrec_ipfix_col_external_ids); + ovsdb_idl_omit(idl, &ovsrec_flow_sample_collector_set_col_external_ids); ovsdb_idl_omit(idl, &ovsrec_manager_col_external_ids); ovsdb_idl_omit(idl, &ovsrec_manager_col_inactivity_probe); @@ -282,14 +429,16 @@ bridge_init(const char *remote) ovsdb_idl_omit(idl, &ovsrec_ssl_col_external_ids); /* Register unixctl commands. */ - unixctl_command_register("qos/show", "interface", qos_unixctl_show, NULL); - unixctl_command_register("bridge/dump-flows", "bridge", + unixctl_command_register("qos/show", "interface", 1, 1, + qos_unixctl_show, NULL); + unixctl_command_register("bridge/dump-flows", "bridge", 1, 1, bridge_unixctl_dump_flows, NULL); - unixctl_command_register("bridge/reconnect", "[bridge]", + unixctl_command_register("bridge/reconnect", "[bridge]", 0, 1, bridge_unixctl_reconnect, NULL); lacp_init(); bond_init(); cfm_init(); + stp_init(); } void @@ -303,6 +452,14 @@ bridge_exit(void) ovsdb_idl_destroy(idl); } +/* Enables use of OpenFlow 1.4. This is off by default because OpenFlow 1.4 is + * not yet safe to use: it can abort due to unimplemented features. */ +void +bridge_enable_of14(void) +{ + allow_of14 = true; +} + /* Looks at the list of managers in 'ovs_cfg' and extracts their remote IP * addresses and ports into '*managersp' and '*n_managersp'. The caller is * responsible for freeing '*managersp' (with free()). @@ -343,13 +500,12 @@ 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]; + struct sockaddr_storage ss; - if ((!strncmp(target, "tcp:", 4) - && inet_parse_active(target + 4, JSONRPC_TCP_PORT, sin)) || - (!strncmp(target, "ssl:", 4) - && inet_parse_active(target + 4, JSONRPC_SSL_PORT, sin))) { - n_managers++; + if (stream_parse_target_with_default_port(target, OVSDB_OLD_PORT, + &ss) + && ss.ss_family == AF_INET) { + managers[n_managers++] = *(struct sockaddr_in *) &ss; } } } @@ -362,6 +518,7 @@ collect_in_band_managers(const struct ovsrec_open_vswitch *ovs_cfg, static void bridge_reconfigure(const struct ovsrec_open_vswitch *ovs_cfg) { + unsigned long int *splinter_vlans; struct sockaddr_in *managers; struct bridge *br, *next; int sflow_bridge_number; @@ -369,88 +526,128 @@ bridge_reconfigure(const struct ovsrec_open_vswitch *ovs_cfg) COVERAGE_INC(bridge_reconfigure); - /* Create and destroy "struct bridge"s, "struct port"s, and "struct - * iface"s according to 'ovs_cfg', with only very minimal configuration - * otherwise. + 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_threads( + smap_get_int(&ovs_cfg->other_config, "n-handler-threads", 0), + smap_get_int(&ovs_cfg->other_config, "n-revalidator-threads", 0)); + + /* Destroy "struct bridge"s, "struct port"s, and "struct iface"s according + * to 'ovs_cfg', with only very minimal configuration otherwise. * - * This is purely an update to bridge data structures. Nothing is pushed + * 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); + bridge_collect_wanted_ports(br, splinter_vlans, &br->wanted_ports); + bridge_del_ports(br, &br->wanted_ports); } + free(splinter_vlans); - /* Delete all datapaths and datapath ports that are no longer configured. + /* 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. * - * 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. A datapath always has a - * "local port" so we must delete not-configured datapaths too. */ - bridge_del_ofprotos(); + * We have to do all the deletions before we can do any additions, because + * the ports to be added might require resources that will be freed up by + * deletions (they might especially overlap in name). */ + bridge_delete_ofprotos(); HMAP_FOR_EACH (br, node, &all_bridges) { if (br->ofproto) { - bridge_del_ofproto_ports(br); + bridge_delete_or_reconfigure_ports(br); } } - /* Create datapaths and datapath ports that are missing. + /* Finish pushing configuration changes to the ofproto layer: * - * After this is done, we have our final set of bridges, ports, and - * interfaces. Every "struct bridge" has an ofproto, every "struct port" - * has at least one iface, every "struct iface" has a valid ofp_port and - * netdev. */ + * - Create ofprotos that are missing. + * + * - Add ports that are missing. */ HMAP_FOR_EACH_SAFE (br, next, node, &all_bridges) { - if (!br->ofproto && !bridge_add_ofprotos(br)) { - bridge_destroy(br); + if (!br->ofproto) { + int error; + + error = ofproto_create(br->name, br->type, &br->ofproto); + if (error) { + VLOG_ERR("failed to create bridge %s: %s", br->name, + ovs_strerror(error)); + shash_destroy(&br->wanted_ports); + bridge_destroy(br); + } } } HMAP_FOR_EACH (br, node, &all_bridges) { - bridge_refresh_ofp_port(br); - bridge_add_ofproto_ports(br); + bridge_add_ports(br, &br->wanted_ports); + shash_destroy(&br->wanted_ports); } + reconfigure_system_stats(ovs_cfg); + /* Complete the configuration. */ sflow_bridge_number = 0; collect_in_band_managers(ovs_cfg, &managers, &n_managers); HMAP_FOR_EACH (br, node, &all_bridges) { struct port *port; + /* We need the datapath ID early to allow LACP ports to use it as the + * default system ID. */ + bridge_configure_datapath_id(br); + HMAP_FOR_EACH (port, hmap_node, &br->ports) { struct iface *iface; port_configure(port); LIST_FOR_EACH (iface, port_elem, &port->ifaces) { + iface_set_ofport(iface->cfg, iface->ofp_port); 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); } } bridge_configure_mirrors(br); - bridge_configure_datapath_id(br); - bridge_configure_flow_eviction_threshold(br); bridge_configure_forward_bpdu(br); + bridge_configure_mac_table(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_tables(br); + bridge_configure_dp_desc(br); } free(managers); - /* ovs-vswitchd has completed initialization, so allow the process that - * forked us to exit successfully. */ - daemonize_complete(); + /* 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__(); } -/* Iterate over all ofprotos and delete any of them that do not have a - * configured bridge or that are the wrong type. */ +/* Delete ofprotos which aren't configured or have the wrong type. Create + * ofprotos which don't exist but need to. */ static void -bridge_del_ofprotos(void) +bridge_delete_ofprotos(void) { + struct bridge *br; struct sset names; struct sset types; const char *type; + /* Delete ofprotos with no bridge or with the wrong type. */ sset_init(&names); sset_init(&types); ofproto_enumerate_types(&types); @@ -459,7 +656,7 @@ bridge_del_ofprotos(void) ofproto_enumerate_names(type, &names); SSET_FOR_EACH (name, &names) { - struct bridge *br = bridge_lookup(name); + br = bridge_lookup(name); if (!br || strcmp(type, br->type)) { ofproto_delete(name, type); } @@ -469,15 +666,183 @@ bridge_del_ofprotos(void) sset_destroy(&types); } -static bool -bridge_add_ofprotos(struct bridge *br) +static ofp_port_t * +add_ofp_port(ofp_port_t port, ofp_port_t *ports, size_t *n, size_t *allocated) { - int error = ofproto_create(br->name, br->type, &br->ofproto); - if (error) { - VLOG_ERR("failed to create bridge %s: %s", br->name, strerror(error)); - return false; + if (*n >= *allocated) { + ports = x2nrealloc(ports, allocated, sizeof *ports); } - return true; + ports[(*n)++] = port; + return ports; +} + +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); + + /* Main task: Iterate over the ports in 'br->ofproto' and remove the ports + * that are not configured in the database. (This commonly happens when + * ports have been deleted, e.g. with "ovs-vsctl del-port".) + * + * Side tasks: Reconfigure the ports that are still in 'br'. Delete ports + * that have the wrong OpenFlow port number (and arrange to add them back + * with the correct OpenFlow port number). */ + OFPROTO_PORT_FOR_EACH (&ofproto_port, &dump, br->ofproto) { + ofp_port_t requested_ofp_port; + struct iface *iface; + + sset_add(&ofproto_ports, ofproto_port.name); + + iface = iface_lookup(br, ofproto_port.name); + if (!iface) { + /* No such iface is configured, so we should delete this + * ofproto_port. + * + * As a corner case exception, keep the port if it's a bond fake + * interface. */ + if (bridge_has_bond_fake_iface(br, ofproto_port.name) + && !strcmp(ofproto_port.type, "internal")) { + continue; + } + goto delete; + } + + if (strcmp(ofproto_port.type, iface->type) + || netdev_set_config(iface->netdev, &iface->cfg->options)) { + /* 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; + } + } + + /* 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 @@ -489,6 +854,11 @@ port_configure(struct port *port) struct ofproto_bundle_settings s; struct iface *iface; + if (cfg->vlan_mode && !strcmp(cfg->vlan_mode, "splinter")) { + configure_splinter_port(port); + return; + } + /* Get name. */ s.name = port->name; @@ -501,17 +871,8 @@ port_configure(struct port *port) /* Get VLAN tag. */ s.vlan = -1; - if (cfg->tag) { - if (list_is_short(&port->ifaces)) { - if (*cfg->tag >= 0 && *cfg->tag <= 4095) { - s.vlan = *cfg->tag; - } - } else { - /* It's possible that bonded, VLAN-tagged ports make sense. Maybe - * they even work as-is. But they have not been tested. */ - VLOG_WARN("port %s: VLAN tags not supported on bonded ports", - port->name); - } + if (cfg->tag && *cfg->tag >= 0 && *cfg->tag <= 4095) { + s.vlan = *cfg->tag; } /* Get VLAN trunks. */ @@ -532,20 +893,23 @@ 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; } } + s.use_priority_tags = smap_get_bool(&cfg->other_config, "priority-tags", + false); /* Get LACP settings. */ s.lacp = port_configure_lacp(port, &lacp_settings); @@ -563,12 +927,9 @@ port_configure(struct port *port) /* Get bond settings. */ if (s.n_slaves > 1) { s.bond = &bond_settings; - s.bond_stable_ids = xmalloc(s.n_slaves * sizeof *s.bond_stable_ids); - port_configure_bond(port, &bond_settings, s.bond_stable_ids); + port_configure_bond(port, &bond_settings); } else { s.bond = NULL; - s.bond_stable_ids = NULL; - LIST_FOR_EACH (iface, port_elem, &port->ifaces) { netdev_set_miimon_interval(iface->netdev, 0); } @@ -581,7 +942,6 @@ port_configure(struct port *port) free(s.slaves); free(s.trunks); free(s.lacp_slaves); - free(s.bond_stable_ids); } /* Pick local port hardware address and datapath ID for 'br'. */ @@ -602,19 +962,40 @@ bridge_configure_datapath_id(struct bridge *br) static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5); VLOG_ERR_RL(&rl, "bridge %s: failed to set bridge " "Ethernet address: %s", - br->name, strerror(error)); + br->name, ovs_strerror(error)); } } memcpy(br->ea, ea, ETH_ADDR_LEN); dpid = bridge_pick_datapath_id(br, ea, hw_addr_iface); - ofproto_set_datapath_id(br->ofproto, dpid); + if (dpid != ofproto_get_datapath_id(br->ofproto)) { + VLOG_INFO("bridge %s: using datapath ID %016"PRIx64, br->name, dpid); + ofproto_set_datapath_id(br->ofproto, dpid); + } dpid_string = xasprintf("%016"PRIx64, dpid); ovsrec_bridge_set_datapath_id(br->cfg, dpid_string); free(dpid_string); } +/* Returns a bitmap of "enum ofputil_protocol"s that are allowed for use with + * 'br'. */ +static uint32_t +bridge_get_allowed_versions(struct bridge *br) +{ + uint32_t allowed_versions; + + if (!br->cfg->n_protocols) + return 0; + + allowed_versions = ofputil_versions_from_strings(br->cfg->protocols, + br->cfg->n_protocols); + if (!allow_of14) { + allowed_versions &= ~(1u << OFP14_VERSION); + } + return allowed_versions; +} + /* Set NetFlow configuration on 'br'. */ static void bridge_configure_netflow(struct bridge *br) @@ -727,6 +1108,105 @@ bridge_configure_sflow(struct bridge *br, int *sflow_bridge_number) sset_destroy(&oso.targets); } +/* Returns whether a IPFIX row is valid. */ +static bool +ovsrec_ipfix_is_valid(const struct ovsrec_ipfix *ipfix) +{ + return ipfix && ipfix->n_targets > 0; +} + +/* Returns whether a Flow_Sample_Collector_Set row is valid. */ +static bool +ovsrec_fscs_is_valid(const struct ovsrec_flow_sample_collector_set *fscs, + const struct bridge *br) +{ + return ovsrec_ipfix_is_valid(fscs->ipfix) && fscs->bridge == br->cfg; +} + +/* Set IPFIX configuration on 'br'. */ +static void +bridge_configure_ipfix(struct bridge *br) +{ + const struct ovsrec_ipfix *be_cfg = br->cfg->ipfix; + bool valid_be_cfg = ovsrec_ipfix_is_valid(be_cfg); + const struct ovsrec_flow_sample_collector_set *fe_cfg; + struct ofproto_ipfix_bridge_exporter_options be_opts; + struct ofproto_ipfix_flow_exporter_options *fe_opts = NULL; + size_t n_fe_opts = 0; + + OVSREC_FLOW_SAMPLE_COLLECTOR_SET_FOR_EACH(fe_cfg, idl) { + if (ovsrec_fscs_is_valid(fe_cfg, br)) { + n_fe_opts++; + } + } + + if (!valid_be_cfg && n_fe_opts == 0) { + ofproto_set_ipfix(br->ofproto, NULL, NULL, 0); + return; + } + + if (valid_be_cfg) { + memset(&be_opts, 0, sizeof be_opts); + + sset_init(&be_opts.targets); + sset_add_array(&be_opts.targets, be_cfg->targets, be_cfg->n_targets); + + if (be_cfg->sampling) { + be_opts.sampling_rate = *be_cfg->sampling; + } else { + be_opts.sampling_rate = SFL_DEFAULT_SAMPLING_RATE; + } + if (be_cfg->obs_domain_id) { + be_opts.obs_domain_id = *be_cfg->obs_domain_id; + } + if (be_cfg->obs_point_id) { + be_opts.obs_point_id = *be_cfg->obs_point_id; + } + if (be_cfg->cache_active_timeout) { + be_opts.cache_active_timeout = *be_cfg->cache_active_timeout; + } + if (be_cfg->cache_max_flows) { + be_opts.cache_max_flows = *be_cfg->cache_max_flows; + } + } + + if (n_fe_opts > 0) { + struct ofproto_ipfix_flow_exporter_options *opts; + fe_opts = xcalloc(n_fe_opts, sizeof *fe_opts); + opts = fe_opts; + OVSREC_FLOW_SAMPLE_COLLECTOR_SET_FOR_EACH(fe_cfg, idl) { + if (ovsrec_fscs_is_valid(fe_cfg, br)) { + opts->collector_set_id = fe_cfg->id; + sset_init(&opts->targets); + sset_add_array(&opts->targets, fe_cfg->ipfix->targets, + fe_cfg->ipfix->n_targets); + opts->cache_active_timeout = fe_cfg->ipfix->cache_active_timeout + ? *fe_cfg->ipfix->cache_active_timeout : 0; + opts->cache_max_flows = fe_cfg->ipfix->cache_max_flows + ? *fe_cfg->ipfix->cache_max_flows : 0; + opts++; + } + } + } + + ofproto_set_ipfix(br->ofproto, valid_be_cfg ? &be_opts : NULL, fe_opts, + n_fe_opts); + + if (valid_be_cfg) { + sset_destroy(&be_opts.targets); + } + + if (n_fe_opts > 0) { + struct ofproto_ipfix_flow_exporter_options *opts = fe_opts; + size_t i; + for (i = 0; i < n_fe_opts; i++) { + sset_destroy(&opts->targets); + opts++; + } + free(fe_opts); + } +} + static void port_configure_stp(const struct ofproto *ofproto, struct port *port, struct ofproto_port_stp_settings *port_s, @@ -735,8 +1215,7 @@ port_configure_stp(const struct ofproto *ofproto, struct port *port, const char *config_str; struct iface *iface; - config_str = get_port_other_config(port->cfg, "stp-enable", NULL); - if (config_str && !strcmp(config_str, "false")) { + if (!smap_get_bool(&port->cfg->other_config, "stp-enable", true)) { port_s->enable = false; return; } else { @@ -768,7 +1247,7 @@ port_configure_stp(const struct ofproto *ofproto, struct port *port, return; } - config_str = get_port_other_config(port->cfg, "stp-port-num", NULL); + config_str = smap_get(&port->cfg->other_config, "stp-port-num"); if (config_str) { unsigned long int port_num = strtoul(config_str, NULL, 0); int port_idx = port_num - 1; @@ -788,7 +1267,7 @@ port_configure_stp(const struct ofproto *ofproto, struct port *port, bitmap_set1(port_num_bitmap, port_idx); port_s->port_num = port_idx; } else { - if (*port_num_counter > STP_MAX_PORTS) { + if (*port_num_counter >= STP_MAX_PORTS) { VLOG_ERR("port %s: too many STP ports, disabling", port->name); port_s->enable = false; return; @@ -797,24 +1276,19 @@ port_configure_stp(const struct ofproto *ofproto, struct port *port, port_s->port_num = (*port_num_counter)++; } - config_str = get_port_other_config(port->cfg, "stp-path-cost", NULL); + config_str = smap_get(&port->cfg->other_config, "stp-path-cost"); if (config_str) { port_s->path_cost = strtoul(config_str, NULL, 10); } else { - uint32_t current; - - if (netdev_get_features(iface->netdev, ¤t, NULL, NULL, NULL)) { - /* Couldn't get speed, so assume 100Mb/s. */ - port_s->path_cost = 19; - } else { - unsigned int mbps; + enum netdev_features current; + unsigned int mbps; - mbps = netdev_features_to_bps(current) / 1000000; - port_s->path_cost = stp_convert_speed_to_cost(mbps); - } + netdev_get_features(iface->netdev, ¤t, NULL, NULL, NULL); + mbps = netdev_features_to_bps(current, 100 * 1000 * 1000) / 1000000; + port_s->path_cost = stp_convert_speed_to_cost(mbps); } - config_str = get_port_other_config(port->cfg, "stp-port-priority", NULL); + config_str = smap_get(&port->cfg->other_config, "stp-port-priority"); if (config_str) { port_s->priority = strtoul(config_str, NULL, 0); } else { @@ -835,7 +1309,7 @@ bridge_configure_stp(struct bridge *br) int port_num_counter; unsigned long *port_num_bitmap; - config_str = bridge_get_other_config(br->cfg, "stp-system-id"); + config_str = smap_get(&br->cfg->other_config, "stp-system-id"); if (config_str) { uint8_t ea[ETH_ADDR_LEN]; @@ -850,28 +1324,28 @@ bridge_configure_stp(struct bridge *br) br_s.system_id = eth_addr_to_uint64(br->ea); } - config_str = bridge_get_other_config(br->cfg, "stp-priority"); + config_str = smap_get(&br->cfg->other_config, "stp-priority"); if (config_str) { br_s.priority = strtoul(config_str, NULL, 0); } else { br_s.priority = STP_DEFAULT_BRIDGE_PRIORITY; } - config_str = bridge_get_other_config(br->cfg, "stp-hello-time"); + config_str = smap_get(&br->cfg->other_config, "stp-hello-time"); if (config_str) { br_s.hello_time = strtoul(config_str, NULL, 10) * 1000; } else { br_s.hello_time = STP_DEFAULT_HELLO_TIME; } - config_str = bridge_get_other_config(br->cfg, "stp-max-age"); + config_str = smap_get(&br->cfg->other_config, "stp-max-age"); if (config_str) { br_s.max_age = strtoul(config_str, NULL, 10) * 1000; } else { br_s.max_age = STP_DEFAULT_MAX_AGE; } - config_str = bridge_get_other_config(br->cfg, "stp-forward-delay"); + config_str = smap_get(&br->cfg->other_config, "stp-forward-delay"); if (config_str) { br_s.fwd_delay = strtoul(config_str, NULL, 10) * 1000; } else { @@ -907,7 +1381,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); @@ -975,285 +1449,198 @@ add_del_bridges(const struct ovsrec_open_vswitch *cfg) shash_destroy(&new_br); } -/* Delete each ofproto port on 'br' that doesn't have a corresponding "struct - * iface". +/* 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) +{ + return netdev_set_config(netdev, &iface_cfg->options); +} + +/* 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'. * - * 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. */ -static void -bridge_del_ofproto_ports(struct bridge *br) + * If successful, returns 0 and stores the network device in '*netdevp'. On + * failure, returns a positive errno value and stores NULL in '*netdevp'. */ +static int +iface_do_create(const struct bridge *br, + const struct ovsrec_interface *iface_cfg, + const struct ovsrec_port *port_cfg, + ofp_port_t *ofp_portp, struct netdev **netdevp) { - struct ofproto_port_dump dump; - struct ofproto_port ofproto_port; + struct netdev *netdev = NULL; + int error; - OFPROTO_PORT_FOR_EACH (&ofproto_port, &dump, br->ofproto) { - const char *name = ofproto_port.name; - struct iface *iface; - const char *type; - int error; + if (netdev_is_reserved_name(iface_cfg->name)) { + VLOG_WARN("could not create interface %s, name is reserved", + iface_cfg->name); + error = EINVAL; + goto error; + } - /* Ignore the local port. We can't change it anyhow. */ - if (!strcmp(name, br->name)) { - continue; - } + 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)); + goto error; + } - /* Get the type that 'ofproto_port' should have (ordinarily the - * type of its corresponding iface) or NULL if it should be - * deleted. */ - iface = iface_lookup(br, name); - type = (iface ? iface->type - : bridge_has_bond_fake_iface(br, name) ? "internal" - : NULL); + error = iface_set_netdev_config(iface_cfg, netdev); + if (error) { + goto error; + } - /* If it's the wrong type then delete the ofproto port. */ - if (type - && !strcmp(ofproto_port.type, type) - && (!iface || !iface->netdev - || !strcmp(netdev_get_type(iface->netdev), type))) { - continue; - } - error = ofproto_port_del(br->ofproto, ofproto_port.ofp_port); - if (error) { - VLOG_WARN("bridge %s: failed to remove %s interface (%s)", - br->name, name, strerror(error)); - } - if (iface) { - netdev_close(iface->netdev); - iface->netdev = NULL; - } + *ofp_portp = iface_pick_ofport(iface_cfg); + error = ofproto_port_add(br->ofproto, netdev, ofp_portp); + if (error) { + goto error; } -} -static void -iface_set_ofp_port(struct iface *iface, int ofp_port) -{ - struct bridge *br = iface->port->bridge; + VLOG_INFO("bridge %s: added interface %s on port %d", + br->name, iface_cfg->name, *ofp_portp); - assert(iface->ofp_port < 0 && ofp_port >= 0); - iface->ofp_port = ofp_port; - hmap_insert(&br->ifaces, &iface->ofp_port_node, hash_int(ofp_port, 0)); - iface_set_ofport(iface->cfg, ofp_port); + if (port_cfg->vlan_mode && !strcmp(port_cfg->vlan_mode, "splinter")) { + netdev_turn_flags_on(netdev, NETDEV_UP, NULL); + } + + *netdevp = netdev; + return 0; + +error: + *netdevp = NULL; + netdev_close(netdev); + return error; } -static void -bridge_refresh_ofp_port(struct bridge *br) +/* Creates a new iface on 'br' based on 'if_cfg'. The new iface has OpenFlow + * port number 'ofp_port'. If ofp_port is OFPP_NONE, an OpenFlow port is + * automatically allocated for the iface. Takes ownership of and + * deallocates 'if_cfg'. + * + * Return true if an iface is successfully created, false otherwise. */ +static bool +iface_create(struct bridge *br, const struct ovsrec_interface *iface_cfg, + const struct ovsrec_port *port_cfg) { - struct ofproto_port_dump dump; - struct ofproto_port ofproto_port; + struct netdev *netdev; + struct iface *iface; + ofp_port_t ofp_port; struct port *port; + int error; - /* Clear all the "ofp_port"es. */ - hmap_clear(&br->ifaces); - HMAP_FOR_EACH (port, hmap_node, &br->ports) { - struct iface *iface; + /* Do the bits that can fail up front. */ + ovs_assert(!iface_lookup(br, iface_cfg->name)); + error = iface_do_create(br, iface_cfg, port_cfg, &ofp_port, &netdev); + if (error) { + iface_clear_db_record(iface_cfg); + return false; + } - LIST_FOR_EACH (iface, port_elem, &port->ifaces) { - iface->ofp_port = -1; - } + /* Get or create the port structure. */ + port = port_lookup(br, port_cfg->name); + if (!port) { + port = port_create(br, port_cfg); } - /* Obtain the correct "ofp_port"s from ofproto. */ - OFPROTO_PORT_FOR_EACH (&ofproto_port, &dump, br->ofproto) { - struct iface *iface = iface_lookup(br, ofproto_port.name); - if (iface) { - if (iface->ofp_port >= 0) { - VLOG_WARN("bridge %s: interface %s reported twice", - br->name, ofproto_port.name); - } else if (iface_from_ofp_port(br, ofproto_port.ofp_port)) { - VLOG_WARN("bridge %s: interface %"PRIu16" reported twice", - br->name, ofproto_port.ofp_port); + /* Create the iface structure. */ + iface = xzalloc(sizeof *iface); + list_push_back(&port->ifaces, &iface->port_elem); + hmap_insert(&br->iface_by_name, &iface->name_node, + hash_string(iface_cfg->name, 0)); + iface->port = port; + iface->name = xstrdup(iface_cfg->name); + iface->ofp_port = ofp_port; + iface->netdev = netdev; + iface->type = iface_get_type(iface_cfg, br->cfg); + iface->cfg = iface_cfg; + hmap_insert(&br->ifaces, &iface->ofp_port_node, + hash_ofp_port(ofp_port)); + + /* Populate initial status in database. */ + iface_refresh_stats(iface); + iface_refresh_netdev_status(iface); + + /* Add bond fake iface if necessary. */ + if (port_is_bond_fake_iface(port)) { + struct ofproto_port ofproto_port; + + if (ofproto_port_query_by_name(br->ofproto, port->name, + &ofproto_port)) { + struct netdev *netdev; + int error; + + error = netdev_open(port->name, "internal", &netdev); + if (!error) { + ofp_port_t fake_ofp_port = OFPP_NONE; + ofproto_port_add(br->ofproto, netdev, &fake_ofp_port); + netdev_close(netdev); } else { - iface_set_ofp_port(iface, ofproto_port.ofp_port); + VLOG_WARN("could not open network device %s (%s)", + port->name, ovs_strerror(error)); } + } else { + /* Already exists, nothing to do. */ + ofproto_port_destroy(&ofproto_port); } } + + return true; } -/* Add an ofproto port for any "struct iface" that doesn't have one. - * Delete any "struct iface" for which this fails. - * Delete any "struct port" that thereby ends up with no ifaces. */ +/* Set forward BPDU option. */ static void -bridge_add_ofproto_ports(struct bridge *br) +bridge_configure_forward_bpdu(struct bridge *br) { - struct port *port, *next_port; + ofproto_set_forward_bpdu(br->ofproto, + smap_get_bool(&br->cfg->other_config, + "forward-bpdu", + false)); +} - HMAP_FOR_EACH_SAFE (port, next_port, hmap_node, &br->ports) { - struct iface *iface, *next_iface; - struct ofproto_port ofproto_port; +/* Set MAC learning table configuration for 'br'. */ +static void +bridge_configure_mac_table(struct bridge *br) +{ + const char *idle_time_str; + int idle_time; - LIST_FOR_EACH_SAFE (iface, next_iface, port_elem, &port->ifaces) { - int error; + const char *mac_table_size_str; + int mac_table_size; - /* Open the netdev. */ - if (!iface->netdev) { - error = netdev_open(iface->name, iface->type, &iface->netdev); - if (error) { - VLOG_WARN("could not open network device %s (%s)", - iface->name, strerror(error)); - } - } else { - error = 0; - } + idle_time_str = smap_get(&br->cfg->other_config, "mac-aging-time"); + idle_time = (idle_time_str && atoi(idle_time_str) + ? atoi(idle_time_str) + : MAC_ENTRY_DEFAULT_IDLE_TIME); - /* Configure the netdev. */ - if (iface->netdev) { - struct shash args; - - shash_init(&args); - shash_from_ovs_idl_map(iface->cfg->key_options, - iface->cfg->value_options, - iface->cfg->n_options, &args); - error = netdev_set_config(iface->netdev, &args); - shash_destroy(&args); - - if (error) { - VLOG_WARN("could not configure network device %s (%s)", - iface->name, strerror(error)); - netdev_close(iface->netdev); - iface->netdev = NULL; - } - } + mac_table_size_str = smap_get(&br->cfg->other_config, "mac-table-size"); + mac_table_size = (mac_table_size_str && atoi(mac_table_size_str) + ? atoi(mac_table_size_str) + : MAC_DEFAULT_MAX); - /* Add the port, if necessary. */ - if (iface->netdev && iface->ofp_port < 0) { - uint16_t ofp_port; - int error; - - error = ofproto_port_add(br->ofproto, iface->netdev, - &ofp_port); - if (!error) { - iface_set_ofp_port(iface, ofp_port); - } else { - netdev_close(iface->netdev); - iface->netdev = NULL; - } - } - - /* Populate stats columns in new Interface rows. */ - if (iface->netdev && !iface->cfg->mtu) { - iface_refresh_stats(iface); - iface_refresh_status(iface); - } - - /* Delete the iface if we failed. */ - if (iface->netdev && iface->ofp_port >= 0) { - VLOG_DBG("bridge %s: interface %s is on port %d", - br->name, iface->name, iface->ofp_port); - } else { - if (iface->netdev) { - VLOG_ERR("bridge %s: missing %s interface, dropping", - br->name, iface->name); - } else { - /* We already reported a related error, don't bother - * duplicating it. */ - } - iface_clear_db_record(iface->cfg); - iface_destroy(iface); - } - } - if (list_is_empty(&port->ifaces)) { - VLOG_WARN("%s port has no interfaces, dropping", port->name); - port_destroy(port); - continue; - } - - /* Add bond fake iface if necessary. */ - if (port_is_bond_fake_iface(port)) { - if (ofproto_port_query_by_name(br->ofproto, port->name, - &ofproto_port)) { - struct netdev *netdev; - int error; - - error = netdev_open(port->name, "internal", &netdev); - if (!error) { - ofproto_port_add(br->ofproto, netdev, NULL); - netdev_close(netdev); - } else { - VLOG_WARN("could not open network device %s (%s)", - port->name, strerror(error)); - } - } else { - /* Already exists, nothing to do. */ - ofproto_port_destroy(&ofproto_port); - } - } - } -} - -static const char * -get_ovsrec_key_value(const struct ovsdb_idl_row *row, - const struct ovsdb_idl_column *column, - const char *key) -{ - const struct ovsdb_datum *datum; - union ovsdb_atom atom; - unsigned int idx; - - datum = ovsdb_idl_get(row, column, OVSDB_TYPE_STRING, OVSDB_TYPE_STRING); - atom.string = (char *) key; - idx = ovsdb_datum_find_key(datum, &atom, OVSDB_TYPE_STRING); - return idx == UINT_MAX ? NULL : datum->values[idx].string; -} - -static const char * -bridge_get_other_config(const struct ovsrec_bridge *br_cfg, const char *key) -{ - return get_ovsrec_key_value(&br_cfg->header_, - &ovsrec_bridge_col_other_config, key); -} - -/* Set Flow eviction threshold */ -static void -bridge_configure_flow_eviction_threshold(struct bridge *br) -{ - const char *threshold_str; - unsigned threshold; - - threshold_str = bridge_get_other_config(br->cfg, "flow-eviction-threshold"); - if (threshold_str) { - threshold = strtoul(threshold_str, NULL, 10); - } else { - threshold = OFPROTO_FLOW_EVICTON_THRESHOLD_DEFAULT; - } - ofproto_set_flow_eviction_threshold(br->ofproto, threshold); -} - -/* Set forward BPDU option. */ -static void -bridge_configure_forward_bpdu(struct bridge *br) -{ - const char *forward_bpdu_str; - bool forward_bpdu = false; - - forward_bpdu_str = bridge_get_other_config(br->cfg, "forward-bpdu"); - if (forward_bpdu_str && !strcmp(forward_bpdu_str, "true")) { - forward_bpdu = true; - } - ofproto_set_forward_bpdu(br->ofproto, forward_bpdu); + ofproto_set_mac_table_config(br->ofproto, idle_time, mac_table_size); } static void -bridge_pick_local_hw_addr(struct bridge *br, uint8_t ea[ETH_ADDR_LEN], - struct iface **hw_addr_iface) +find_local_hw_addr(const struct bridge *br, uint8_t ea[ETH_ADDR_LEN], + const struct port *fake_br, struct iface **hw_addr_iface) { - const char *hwaddr; + struct hmapx mirror_output_ports; struct port *port; bool found_addr = false; int error; + int i; - *hw_addr_iface = NULL; - - /* Did the user request a particular MAC? */ - hwaddr = bridge_get_other_config(br->cfg, "hwaddr"); - 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 + * accumulate them ourselves. */ + hmapx_init(&mirror_output_ports); + for (i = 0; i < br->cfg->n_mirrors; i++) { + struct ovsrec_mirror *m = br->cfg->mirrors[i]; + if (m->output_port) { + hmapx_add(&mirror_output_ports, m->output_port); } } @@ -1265,7 +1652,7 @@ bridge_pick_local_hw_addr(struct bridge *br, uint8_t ea[ETH_ADDR_LEN], struct iface *iface; /* Mirror output ports don't participate. */ - if (ofproto_is_mirror_output_bundle(br->ofproto, port)) { + if (hmapx_contains(&mirror_output_ports, port->cfg)) { continue; } @@ -1300,6 +1687,16 @@ 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); if (error) { @@ -1319,15 +1716,37 @@ bridge_pick_local_hw_addr(struct bridge *br, uint8_t ea[ETH_ADDR_LEN], found_addr = true; } } - if (found_addr) { - VLOG_DBG("bridge %s: using bridge Ethernet address "ETH_ADDR_FMT, - br->name, ETH_ADDR_ARGS(ea)); - } else { + + if (!found_addr) { memcpy(ea, br->default_ea, ETH_ADDR_LEN); *hw_addr_iface = NULL; - VLOG_WARN("bridge %s: using default bridge Ethernet " - "address "ETH_ADDR_FMT, br->name, ETH_ADDR_ARGS(ea)); } + + hmapx_destroy(&mirror_output_ports); +} + +static void +bridge_pick_local_hw_addr(struct bridge *br, uint8_t ea[ETH_ADDR_LEN], + 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 @@ -1355,38 +1774,15 @@ bridge_pick_datapath_id(struct bridge *br, const char *datapath_id; uint64_t dpid; - datapath_id = bridge_get_other_config(br->cfg, "datapath-id"); + datapath_id = smap_get(&br->cfg->other_config, "datapath-id"); if (datapath_id && dpid_from_string(datapath_id, &dpid)) { return dpid; } - if (hw_addr_iface) { - int vlan; - if (!netdev_get_vlan_vid(hw_addr_iface->netdev, &vlan)) { - /* - * A bridge whose MAC address is taken from a VLAN network device - * (that is, a network device created with vconfig(8) or similar - * tool) will have the same MAC address as a bridge on the VLAN - * device's physical network device. - * - * Handle this case by hashing the physical network device MAC - * along with the VLAN identifier. - */ - uint8_t buf[ETH_ADDR_LEN + 2]; - memcpy(buf, bridge_ea, ETH_ADDR_LEN); - buf[ETH_ADDR_LEN] = vlan >> 8; - buf[ETH_ADDR_LEN + 1] = vlan; - return dpid_from_hash(buf, sizeof buf); - } else { - /* - * Assume that this bridge's MAC address is unique, since it - * doesn't fit any of the cases we handle specially. - */ - } - } else { + if (!hw_addr_iface) { /* * A purely internal bridge, that is, one that has no non-virtual - * network devices on it at all, is more difficult because it has no + * network devices on it at all, is difficult because it has no * natural unique identifier at all. * * When the host is a XenServer, we handle this case by hashing the @@ -1422,56 +1818,60 @@ dpid_from_hash(const void *data, size_t n) } static void -iface_refresh_status(struct iface *iface) +iface_refresh_netdev_status(struct iface *iface) { - struct shash sh; + struct smap smap; + enum netdev_features current; enum netdev_flags flags; - uint32_t current; - int64_t bps; - int mtu; - int64_t mtu_64; - int error; + const char *link_state; + uint8_t mac[ETH_ADDR_LEN]; + int64_t bps, mtu_64, ifindex64, link_resets; + int mtu, error; if (iface_is_synthetic(iface)) { return; } - shash_init(&sh); + if (iface->change_seq == netdev_get_change_seq(iface->netdev)) { + return; + } - if (!netdev_get_status(iface->netdev, &sh)) { - size_t n; - char **keys, **values; + iface->change_seq = netdev_get_change_seq(iface->netdev); - shash_to_ovs_idl_map(&sh, &keys, &values, &n); - ovsrec_interface_set_status(iface->cfg, keys, values, n); + smap_init(&smap); - free(keys); - free(values); + if (!netdev_get_status(iface->netdev, &smap)) { + ovsrec_interface_set_status(iface->cfg, &smap); } else { - ovsrec_interface_set_status(iface->cfg, NULL, NULL, 0); + ovsrec_interface_set_status(iface->cfg, NULL); } - shash_destroy_free_data(&sh); + smap_destroy(&smap); error = netdev_get_flags(iface->netdev, &flags); if (!error) { - ovsrec_interface_set_admin_state(iface->cfg, flags & NETDEV_UP ? "up" : "down"); - } - else { + 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); - if (!error) { + bps = !error ? netdev_features_to_bps(current, 0) : 0; + if (bps) { ovsrec_interface_set_duplex(iface->cfg, netdev_features_is_full_duplex(current) ? "full" : "half"); - /* warning: uint64_t -> int64_t conversion */ - bps = netdev_features_to_bps(current); ovsrec_interface_set_link_speed(iface->cfg, &bps, 1); - } - else { + } else { ovsrec_interface_set_duplex(iface->cfg, NULL); ovsrec_interface_set_link_speed(iface->cfg, NULL, 0); } @@ -1480,41 +1880,116 @@ iface_refresh_status(struct iface *iface) if (!error) { mtu_64 = mtu; ovsrec_interface_set_mtu(iface->cfg, &mtu_64, 1); - } - else { + } else { ovsrec_interface_set_mtu(iface->cfg, NULL, 0); } + + error = netdev_get_etheraddr(iface->netdev, mac); + if (!error) { + char mac_string[32]; + + sprintf(mac_string, ETH_ADDR_FMT, ETH_ADDR_ARGS(mac)); + ovsrec_interface_set_mac_in_use(iface->cfg, mac_string); + } else { + ovsrec_interface_set_mac_in_use(iface->cfg, NULL); + } + + /* The netdev may return a negative number (such as -EOPNOTSUPP) + * if there is no valid ifindex number. */ + ifindex64 = netdev_get_ifindex(iface->netdev); + if (ifindex64 < 0) { + ifindex64 = 0; + } + ovsrec_interface_set_ifindex(iface->cfg, &ifindex64, 1); } -/* Writes 'iface''s CFM statistics to the database. */ static void -iface_refresh_cfm_stats(struct iface *iface) +iface_refresh_ofproto_status(struct iface *iface) { - const struct ovsrec_interface *cfg = iface->cfg; - int fault, error; - const uint64_t *rmps; - size_t n_rmps; + struct smap smap; + int current, error; if (iface_is_synthetic(iface)) { return; } - fault = ofproto_port_get_cfm_fault(iface->port->bridge->ofproto, - iface->ofp_port); - if (fault >= 0) { - bool fault_bool = fault; - ovsrec_interface_set_cfm_fault(cfg, &fault_bool, 1); + 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_cfm_fault(cfg, NULL, 0); + ovsrec_interface_set_lacp_current(iface->cfg, NULL, 0); } - error = ofproto_port_get_cfm_remote_mpids(iface->port->bridge->ofproto, - iface->ofp_port, &rmps, &n_rmps); + iface_refresh_cfm_stats(iface); + + smap_init(&smap); + error = ofproto_port_get_bfd_status(iface->port->bridge->ofproto, + iface->ofp_port, &smap); if (error >= 0) { - ovsrec_interface_set_cfm_remote_mpids(cfg, (const int64_t *)rmps, - n_rmps); - } else { + 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; + int error; + + error = ofproto_port_get_cfm_status(iface->port->bridge->ofproto, + iface->ofp_port, &status); + if (error < 0) { + /* Do nothing if there is no status change since last update. */ + } else if (error > 0) { + ovsrec_interface_set_cfm_fault(cfg, NULL, 0); + ovsrec_interface_set_cfm_fault_status(cfg, NULL, 0); + ovsrec_interface_set_cfm_remote_opstate(cfg, NULL); + ovsrec_interface_set_cfm_flap_count(cfg, NULL, 0); + ovsrec_interface_set_cfm_health(cfg, NULL, 0); ovsrec_interface_set_cfm_remote_mpids(cfg, NULL, 0); + } else { + const char *reasons[CFM_FAULT_N_REASONS]; + int64_t cfm_health = status.health; + int64_t cfm_flap_count = status.flap_count; + bool faulted = status.faults != 0; + size_t i, j; + + ovsrec_interface_set_cfm_fault(cfg, &faulted, 1); + + j = 0; + for (i = 0; i < CFM_FAULT_N_REASONS; i++) { + int reason = 1 << i; + if (status.faults & reason) { + reasons[j++] = cfm_fault_reason_to_str(reason); + } + } + ovsrec_interface_set_cfm_fault_status(cfg, (char **) reasons, j); + + ovsrec_interface_set_cfm_flap_count(cfg, &cfm_flap_count, 1); + + if (status.remote_opstate >= 0) { + const char *remote_opstate = status.remote_opstate ? "up" : "down"; + ovsrec_interface_set_cfm_remote_opstate(cfg, remote_opstate); + } else { + ovsrec_interface_set_cfm_remote_opstate(cfg, NULL); + } + + ovsrec_interface_set_cfm_remote_mpids(cfg, + (const int64_t *)status.rmps, + status.n_rmps); + if (cfm_health >= 0) { + ovsrec_interface_set_cfm_health(cfg, &cfm_health, 1); + } else { + ovsrec_interface_set_cfm_health(cfg, NULL, 0); + } + + free(status.rmps); } } @@ -1535,11 +2010,12 @@ iface_refresh_stats(struct iface *iface) IFACE_STAT(rx_crc_errors, "rx_crc_err") \ IFACE_STAT(collisions, "collisions") -#define IFACE_STAT(MEMBER, NAME) NAME, - static char *keys[] = { IFACE_STATS }; +#define IFACE_STAT(MEMBER, NAME) + 1 + enum { N_IFACE_STATS = IFACE_STATS }; #undef IFACE_STAT - int64_t values[ARRAY_SIZE(keys)]; - int i; + int64_t values[N_IFACE_STATS]; + char *keys[N_IFACE_STATS]; + int n; struct netdev_stats stats; @@ -1551,46 +2027,46 @@ iface_refresh_stats(struct iface *iface) * all-1s, and we will deal with that correctly below. */ netdev_get_stats(iface->netdev, &stats); - /* Copy statistics into values[] array. */ - i = 0; -#define IFACE_STAT(MEMBER, NAME) values[i++] = stats.MEMBER; + /* Copy statistics into keys[] and values[]. */ + n = 0; +#define IFACE_STAT(MEMBER, NAME) \ + if (stats.MEMBER != UINT64_MAX) { \ + keys[n] = NAME; \ + values[n] = stats.MEMBER; \ + n++; \ + } IFACE_STATS; #undef IFACE_STAT - assert(i == ARRAY_SIZE(keys)); + ovs_assert(n <= N_IFACE_STATS); - ovsrec_interface_set_statistics(iface->cfg, keys, values, ARRAY_SIZE(keys)); + ovsrec_interface_set_statistics(iface->cfg, keys, values, n); #undef IFACE_STATS } static void br_refresh_stp_status(struct bridge *br) { + struct smap smap = SMAP_INITIALIZER(&smap); struct ofproto *ofproto = br->ofproto; struct ofproto_stp_status status; - char *keys[3], *values[3]; - size_t i; if (ofproto_get_stp_status(ofproto, &status)) { return; } if (!status.enabled) { - ovsrec_bridge_set_status(br->cfg, NULL, NULL, 0); + ovsrec_bridge_set_status(br->cfg, NULL); return; } - keys[0] = "stp_bridge_id", - values[0] = xasprintf(STP_ID_FMT, STP_ID_ARGS(status.bridge_id)); - keys[1] = "stp_designated_root", - values[1] = xasprintf(STP_ID_FMT, STP_ID_ARGS(status.designated_root)); - keys[2] = "stp_root_path_cost", - values[2] = xasprintf("%d", status.root_path_cost); + smap_add_format(&smap, "stp_bridge_id", STP_ID_FMT, + STP_ID_ARGS(status.bridge_id)); + smap_add_format(&smap, "stp_designated_root", STP_ID_FMT, + STP_ID_ARGS(status.designated_root)); + smap_add_format(&smap, "stp_root_path_cost", "%d", status.root_path_cost); - ovsrec_bridge_set_status(br->cfg, keys, values, ARRAY_SIZE(values)); - - for (i = 0; i < ARRAY_SIZE(values); i++) { - free(values[i]); - } + ovsrec_bridge_set_status(br->cfg, &smap); + smap_destroy(&smap); } static void @@ -1599,10 +2075,7 @@ port_refresh_stp_status(struct port *port) struct ofproto *ofproto = port->bridge->ofproto; struct iface *iface; struct ofproto_port_stp_status status; - char *keys[4]; - char *str_values[4]; - int64_t int_values[3]; - size_t i; + struct smap smap; if (port_is_synthetic(port)) { return; @@ -1610,46 +2083,65 @@ port_refresh_stp_status(struct port *port) /* STP doesn't currently support bonds. */ if (!list_is_singleton(&port->ifaces)) { - ovsrec_port_set_status(port->cfg, NULL, NULL, 0); + ovsrec_port_set_status(port->cfg, NULL); return; } iface = CONTAINER_OF(list_front(&port->ifaces), struct iface, port_elem); - if (ofproto_port_get_stp_status(ofproto, iface->ofp_port, &status)) { return; } if (!status.enabled) { - ovsrec_port_set_status(port->cfg, NULL, NULL, 0); - ovsrec_port_set_statistics(port->cfg, NULL, NULL, 0); + ovsrec_port_set_status(port->cfg, NULL); return; } /* Set Status column. */ - keys[0] = "stp_port_id"; - str_values[0] = xasprintf(STP_PORT_ID_FMT, status.port_id); - keys[1] = "stp_state"; - str_values[1] = xstrdup(stp_state_name(status.state)); - keys[2] = "stp_sec_in_state"; - str_values[2] = xasprintf("%u", status.sec_in_state); - keys[3] = "stp_role"; - str_values[3] = xstrdup(stp_role_name(status.role)); + smap_init(&smap); + smap_add_format(&smap, "stp_port_id", STP_PORT_ID_FMT, status.port_id); + smap_add(&smap, "stp_state", stp_state_name(status.state)); + smap_add_format(&smap, "stp_sec_in_state", "%u", status.sec_in_state); + smap_add(&smap, "stp_role", stp_role_name(status.role)); + ovsrec_port_set_status(port->cfg, &smap); + smap_destroy(&smap); +} + +static void +port_refresh_stp_stats(struct port *port) +{ + struct ofproto *ofproto = port->bridge->ofproto; + struct iface *iface; + struct ofproto_port_stp_stats stats; + char *keys[3]; + int64_t int_values[3]; - ovsrec_port_set_status(port->cfg, keys, str_values, - ARRAY_SIZE(str_values)); + if (port_is_synthetic(port)) { + return; + } + + /* STP doesn't currently support bonds. */ + if (!list_is_singleton(&port->ifaces)) { + return; + } + + iface = CONTAINER_OF(list_front(&port->ifaces), struct iface, port_elem); + if (ofproto_port_get_stp_stats(ofproto, iface->ofp_port, &stats)) { + return; + } - for (i = 0; i < ARRAY_SIZE(str_values); i++) { - free(str_values[i]); + if (!stats.enabled) { + ovsrec_port_set_statistics(port->cfg, NULL, NULL, 0); + return; } /* Set Statistics column. */ keys[0] = "stp_tx_count"; - int_values[0] = status.tx_count; + int_values[0] = stats.tx_count; keys[1] = "stp_rx_count"; - int_values[1] = status.rx_count; + int_values[1] = stats.rx_count; keys[2] = "stp_error_count"; - int_values[2] = status.error_count; + int_values[2] = stats.error_count; ovsrec_port_set_statistics(port->cfg, keys, int_values, ARRAY_SIZE(int_values)); @@ -1658,46 +2150,53 @@ port_refresh_stp_status(struct port *port) static bool enable_system_stats(const struct ovsrec_open_vswitch *cfg) { - const char *enable; + return smap_get_bool(&cfg->other_config, "enable-statistics", false); +} - /* Use other-config:enable-system-stats by preference. */ - enable = get_ovsrec_key_value(&cfg->header_, - &ovsrec_open_vswitch_col_other_config, - "enable-statistics"); - if (enable) { - return !strcmp(enable, "true"); - } +static void +reconfigure_system_stats(const struct ovsrec_open_vswitch *cfg) +{ + bool enable = enable_system_stats(cfg); - /* Disable by default. */ - return false; + system_stats_enable(enable); + if (!enable) { + ovsrec_open_vswitch_set_statistics(cfg, NULL); + } } static void -refresh_system_stats(const struct ovsrec_open_vswitch *cfg) +run_system_stats(void) { - struct ovsdb_datum datum; - struct shash stats; + const struct ovsrec_open_vswitch *cfg = ovsrec_open_vswitch_first(idl); + struct smap *stats; - shash_init(&stats); - if (enable_system_stats(cfg)) { - get_system_stats(&stats); - } + stats = system_stats_run(); + if (stats && cfg) { + struct ovsdb_idl_txn *txn; + struct ovsdb_datum datum; - ovsdb_datum_from_shash(&datum, &stats); - ovsdb_idl_txn_write(&cfg->header_, &ovsrec_open_vswitch_col_statistics, - &datum); + txn = ovsdb_idl_txn_create(idl); + ovsdb_datum_from_smap(&datum, stats); + ovsdb_idl_txn_write(&cfg->header_, &ovsrec_open_vswitch_col_statistics, + &datum); + ovsdb_idl_txn_commit(txn); + ovsdb_idl_txn_destroy(txn); + + free(stats); + } } -static inline const char * -nx_role_to_str(enum nx_role role) +static const char * +ofp12_controller_role_to_str(enum ofp12_controller_role role) { switch (role) { - case NX_ROLE_OTHER: + case OFPCR12_ROLE_EQUAL: return "other"; - case NX_ROLE_MASTER: + case OFPCR12_ROLE_MASTER: return "master"; - case NX_ROLE_SLAVE: + case OFPCR12_ROLE_SLAVE: return "slave"; + case OFPCR12_ROLE_NOCHANGE: default: return "*** INVALID ROLE ***"; } @@ -1723,85 +2222,101 @@ 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, nx_role_to_str(cinfo->role)); - ovsrec_controller_set_status(cfg, (char **) cinfo->pairs.keys, - (char **) cinfo->pairs.values, - cinfo->pairs.n); + ovsrec_controller_set_role(cfg, ofp12_controller_role_to_str( + cinfo->role)); + ovsrec_controller_set_status(cfg, &smap); + smap_destroy(&smap); } else { ovsrec_controller_set_is_connected(cfg, false); ovsrec_controller_set_role(cfg, NULL); - ovsrec_controller_set_status(cfg, NULL, NULL, 0); + ovsrec_controller_set_status(cfg, NULL); } } ofproto_free_ofproto_controller_info(&info); } - + static void -refresh_cfm_stats(void) +bridge_run__(void) { - static struct ovsdb_idl_txn *txn = NULL; - - if (!txn) { - struct bridge *br; - - txn = ovsdb_idl_txn_create(idl); - - HMAP_FOR_EACH (br, node, &all_bridges) { - struct iface *iface; + struct bridge *br; + struct sset types; + const char *type; - HMAP_FOR_EACH (iface, name_node, &br->iface_by_name) { - iface_refresh_cfm_stats(iface); - } - } + /* 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); - if (ovsdb_idl_txn_commit(txn) != TXN_INCOMPLETE) { - ovsdb_idl_txn_destroy(txn); - txn = NULL; + /* Let each bridge do the work that it needs to do. */ + HMAP_FOR_EACH (br, node, &all_bridges) { + ofproto_run(br->ofproto); } } void bridge_run(void) { + static struct ovsrec_open_vswitch null_cfg; const struct ovsrec_open_vswitch *cfg; - bool datapath_destroyed; - bool database_changed; + bool vlan_splinters_changed; struct bridge *br; + int stats_interval; + + ovsrec_open_vswitch_init(&null_cfg); + + ovsdb_idl_run(idl); - /* (Re)configure if necessary. */ - database_changed = 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; VLOG_ERR_RL(&rl, "another ovs-vswitchd process is running, " - "disabling this process until it goes away"); + "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); } + /* 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; } cfg = ovsrec_open_vswitch_first(idl); - /* Let each bridge do the work that it needs to do. */ - datapath_destroyed = false; - HMAP_FOR_EACH (br, node, &all_bridges) { - int error = ofproto_run(br->ofproto); - if (error) { - static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5); - VLOG_ERR_RL(&rl, "bridge %s: datapath was destroyed externally, " - "forcing reconfiguration", br->name); - datapath_destroyed = true; - } + /* Initialize the ofproto library. This only needs to run once, but + * it must be done after the configuration is set. If the + * initialization has already occurred, bridge_init_ofproto() + * returns immediately. */ + bridge_init_ofproto(cfg); + + /* Once the value of flow-restore-wait is false, we no longer should + * check its value from the database. */ + if (cfg && ofproto_get_flow_restore_wait()) { + ofproto_set_flow_restore_wait(smap_get_bool(&cfg->other_config, + "flow-restore-wait", false)); } + bridge_run__(); + /* Re-configure SSL. We do this on every trip through the main loop, * instead of just when the database changes, because the contents of the * key and certificate files can change without the database changing. @@ -1815,25 +2330,67 @@ bridge_run(void) stream_ssl_set_ca_cert_file(ssl->ca_cert, ssl->bootstrap_ca_cert); } - if (database_changed || datapath_destroyed) { - if (cfg) { - struct ovsdb_idl_txn *txn = ovsdb_idl_txn_create(idl); + /* 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; + } + } + } - bridge_reconfigure(cfg); + if (ovsdb_idl_get_seqno(idl) != idl_seqno || vlan_splinters_changed) { + struct ovsdb_idl_txn *txn; + + idl_seqno = ovsdb_idl_get_seqno(idl); + txn = ovsdb_idl_txn_create(idl); + bridge_reconfigure(cfg ? cfg : &null_cfg); + if (cfg) { ovsrec_open_vswitch_set_cur_cfg(cfg, cfg->next_cfg); + } + + /* 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) { ovsdb_idl_txn_commit(txn); - ovsdb_idl_txn_destroy(txn); /* XXX */ + ovsdb_idl_txn_destroy(txn); } else { - /* We still need to reconfigure to avoid dangling pointers to - * now-destroyed ovsrec structures inside bridge data. */ - static const struct ovsrec_open_vswitch null_cfg; + initial_config_done = true; + daemonize_txn = txn; + } + } - bridge_reconfigure(&null_cfg); + if (daemonize_txn) { + enum ovsdb_idl_txn_status status = ovsdb_idl_txn_commit(daemonize_txn); + if (status != TXN_INCOMPLETE) { + ovsdb_idl_txn_destroy(daemonize_txn); + daemonize_txn = NULL; + + /* ovs-vswitchd has completed initialization, so allow the + * process that forked us to exit successfully. */ + daemonize_complete(); + + vlog_enable_async(); + + VLOG_INFO_ONCE("%s (Open vSwitch) %s", program_name, VERSION); } } - /* Refresh system and interface stats if necessary. */ + /* 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; + } + + /* Refresh interface and mirror stats if necessary. */ if (time_msec() >= stats_timer) { if (cfg) { struct ovsdb_idl_txn *txn; @@ -1841,89 +2398,130 @@ bridge_run(void) txn = ovsdb_idl_txn_create(idl); HMAP_FOR_EACH (br, node, &all_bridges) { struct port *port; + struct mirror *m; HMAP_FOR_EACH (port, hmap_node, &br->ports) { struct iface *iface; 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_system_stats(cfg); refresh_controller_status(); ovsdb_idl_txn_commit(txn); ovsdb_idl_txn_destroy(txn); /* XXX */ } - stats_timer = time_msec() + STATS_INTERVAL; + stats_timer = time_msec() + stats_timer_interval; } - if (time_msec() >= db_limiter) { - struct ovsdb_idl_txn *txn; - - txn = ovsdb_idl_txn_create(idl); - HMAP_FOR_EACH (br, node, &all_bridges) { - struct iface *iface; - struct port *port; - - br_refresh_stp_status(br); - - HMAP_FOR_EACH (port, hmap_node, &br->ports) { - port_refresh_stp_status(port); - } + if (!status_txn) { + uint64_t seq; - HMAP_FOR_EACH (iface, name_node, &br->iface_by_name) { - const char *link_state; - int64_t link_resets; - int current; + /* Check the need to update status. */ + seq = seq_read(connectivity_seq_get()); + if (seq != connectivity_seqno) { + 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); + 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); + LIST_FOR_EACH (iface, port_elem, &port->ifaces) { + iface_refresh_netdev_status(iface); + iface_refresh_ofproto_status(iface); + } } - - link_state = netdev_get_carrier(iface->netdev) ? "up" : "down"; - ovsrec_interface_set_link_state(iface->cfg, link_state); - - link_resets = netdev_get_carrier_resets(iface->netdev); - ovsrec_interface_set_link_resets(iface->cfg, &link_resets, 1); } } + } + + if (status_txn) { + enum ovsdb_idl_txn_status status; - if (ovsdb_idl_txn_commit(txn) != TXN_UNCHANGED) { - db_limiter = time_msec() + DB_LIMIT_INTERVAL; + status = ovsdb_idl_txn_commit(status_txn); + /* Do not destroy "status_txn" if the transaction is + * "TXN_INCOMPLETE". */ + if (status != TXN_INCOMPLETE) { + ovsdb_idl_txn_destroy(status_txn); + status_txn = NULL; } - ovsdb_idl_txn_destroy(txn); } - refresh_cfm_stats(); + run_system_stats(); } void bridge_wait(void) { + struct sset types; + const char *type; + ovsdb_idl_wait(idl); + if (daemonize_txn) { + ovsdb_idl_txn_wait(daemonize_txn); + } + + sset_init(&types); + ofproto_enumerate_types(&types); + SSET_FOR_EACH (type, &types) { + ofproto_type_wait(type); + } + sset_destroy(&types); + if (!hmap_is_empty(&all_bridges)) { struct bridge *br; HMAP_FOR_EACH (br, node, &all_bridges) { ofproto_wait(br->ofproto); } + poll_timer_wait_until(stats_timer); + } - if (db_limiter > time_msec()) { - poll_timer_wait_until(db_limiter); - } + /* If the status database transaction is 'TXN_INCOMPLETE' in this run, + * register a timeout in 'STATUS_CHECK_AGAIN_MSEC'. Else, wait on the + * global connectivity sequence number. Note, this also helps batch + * multiple status changes into one transaction. */ + if (status_txn) { + poll_timer_wait_until(time_msec() + STATUS_CHECK_AGAIN_MSEC); + } else { + seq_wait(connectivity_seq_get(), connectivity_seqno); + } + + system_stats_wait(); +} + +/* Adds some memory usage statistics for bridges into 'usage', for use with + * memory_report(). */ +void +bridge_get_memory_usage(struct simap *usage) +{ + struct bridge *br; + struct sset types; + const char *type; + + sset_init(&types); + ofproto_enumerate_types(&types); + SSET_FOR_EACH (type, &types) { + ofproto_type_get_memory_usage(type, usage); + } + sset_destroy(&types); + + HMAP_FOR_EACH (br, node, &all_bridges) { + ofproto_get_memory_usage(br->ofproto, usage); } } @@ -1935,15 +2533,13 @@ struct qos_unixctl_show_cbdata { }; static void -qos_unixctl_show_cb(unsigned int queue_id, - const struct shash *details, - void *aux) +qos_unixctl_show_queue(unsigned int queue_id, + const struct smap *details, + struct iface *iface, + struct ds *ds) { - struct qos_unixctl_show_cbdata *data = aux; - struct ds *ds = data->ds; - struct iface *iface = data->iface; struct netdev_queue_stats stats; - struct shash_node *node; + struct smap_node *node; int error; ds_put_cstr(ds, "\n"); @@ -1953,8 +2549,8 @@ qos_unixctl_show_cb(unsigned int queue_id, ds_put_cstr(ds, "Default:\n"); } - SHASH_FOR_EACH (node, details) { - ds_put_format(ds, "\t%s: %s\n", node->name, (char *)node->data); + SMAP_FOR_EACH (node, details) { + ds_put_format(ds, "\t%s: %s\n", node->key, node->value); } error = netdev_get_queue_stats(iface->netdev, queue_id, &stats); @@ -1972,51 +2568,52 @@ qos_unixctl_show_cb(unsigned int queue_id, } } else { ds_put_format(ds, "\tFailed to get statistics for queue %u: %s", - queue_id, strerror(error)); + queue_id, ovs_strerror(error)); } } static void -qos_unixctl_show(struct unixctl_conn *conn, - const char *args, void *aux OVS_UNUSED) +qos_unixctl_show(struct unixctl_conn *conn, int argc OVS_UNUSED, + const char *argv[], void *aux OVS_UNUSED) { struct ds ds = DS_EMPTY_INITIALIZER; - struct shash sh = SHASH_INITIALIZER(&sh); + struct smap smap = SMAP_INITIALIZER(&smap); struct iface *iface; const char *type; - struct shash_node *node; - struct qos_unixctl_show_cbdata data; - int error; + struct smap_node *node; - iface = iface_find(args); + iface = iface_find(argv[1]); if (!iface) { - unixctl_command_reply(conn, 501, "no such interface"); + unixctl_command_reply_error(conn, "no such interface"); return; } - netdev_get_qos(iface->netdev, &type, &sh); + netdev_get_qos(iface->netdev, &type, &smap); if (*type != '\0') { + struct netdev_queue_dump dump; + struct smap details; + unsigned int queue_id; + ds_put_format(&ds, "QoS: %s %s\n", iface->name, type); - SHASH_FOR_EACH (node, &sh) { - ds_put_format(&ds, "%s: %s\n", node->name, (char *)node->data); + SMAP_FOR_EACH (node, &smap) { + ds_put_format(&ds, "%s: %s\n", node->key, node->value); } - data.ds = &ds; - data.iface = iface; - error = netdev_dump_queues(iface->netdev, qos_unixctl_show_cb, &data); - - if (error) { - ds_put_format(&ds, "failed to dump queues: %s", strerror(error)); + smap_init(&details); + NETDEV_QUEUE_FOR_EACH (&queue_id, &details, &dump, iface->netdev) { + qos_unixctl_show_queue(queue_id, &details, iface, &ds); } - unixctl_command_reply(conn, 200, ds_cstr(&ds)); + smap_destroy(&details); + + unixctl_command_reply(conn, ds_cstr(&ds)); } else { ds_put_format(&ds, "QoS not configured on %s\n", iface->name); - unixctl_command_reply(conn, 501, ds_cstr(&ds)); + unixctl_command_reply_error(conn, ds_cstr(&ds)); } - shash_destroy_free_data(&sh); + smap_destroy(&smap); ds_destroy(&ds); } @@ -2026,7 +2623,7 @@ bridge_create(const struct ovsrec_bridge *br_cfg) { struct bridge *br; - assert(!bridge_lookup(br_cfg->name)); + ovs_assert(!bridge_lookup(br_cfg->name)); br = xzalloc(sizeof *br); br->name = xstrdup(br_cfg->name); @@ -2059,6 +2656,7 @@ bridge_destroy(struct bridge *br) HMAP_FOR_EACH_SAFE (mirror, next_mirror, hmap_node, &br->mirrors) { mirror_destroy(mirror); } + hmap_remove(&all_bridges, &br->node); ofproto_destroy(br->ofproto); hmap_destroy(&br->ifaces); @@ -2087,22 +2685,22 @@ bridge_lookup(const char *name) /* Handle requests for a listing of all flows known by the OpenFlow * stack, including those normally hidden. */ static void -bridge_unixctl_dump_flows(struct unixctl_conn *conn, - const char *args, void *aux OVS_UNUSED) +bridge_unixctl_dump_flows(struct unixctl_conn *conn, int argc OVS_UNUSED, + const char *argv[], void *aux OVS_UNUSED) { struct bridge *br; struct ds results; - br = bridge_lookup(args); + br = bridge_lookup(argv[1]); if (!br) { - unixctl_command_reply(conn, 501, "Unknown bridge"); + unixctl_command_reply_error(conn, "Unknown bridge"); return; } ds_init(&results); ofproto_get_all_flows(br->ofproto, &results); - unixctl_command_reply(conn, 200, ds_cstr(&results)); + unixctl_command_reply(conn, ds_cstr(&results)); ds_destroy(&results); } @@ -2110,14 +2708,14 @@ bridge_unixctl_dump_flows(struct unixctl_conn *conn, * connections and reconnect. If BRIDGE is not specified, then all bridges * drop their controller connections and reconnect. */ static void -bridge_unixctl_reconnect(struct unixctl_conn *conn, - const char *args, void *aux OVS_UNUSED) +bridge_unixctl_reconnect(struct unixctl_conn *conn, int argc, + const char *argv[], void *aux OVS_UNUSED) { struct bridge *br; - if (args[0] != '\0') { - br = bridge_lookup(args); + if (argc > 1) { + br = bridge_lookup(argv[1]); if (!br) { - unixctl_command_reply(conn, 501, "Unknown bridge"); + unixctl_command_reply_error(conn, "Unknown bridge"); return; } ofproto_reconnect_controllers(br->ofproto); @@ -2126,7 +2724,7 @@ bridge_unixctl_reconnect(struct unixctl_conn *conn, ofproto_reconnect_controllers(br->ofproto); } } - unixctl_command_reply(conn, 200, NULL); + unixctl_command_reply(conn, NULL); } static size_t @@ -2150,30 +2748,30 @@ bridge_get_controllers(const struct bridge *br, return n_controllers; } -/* Adds and deletes "struct port"s and "struct iface"s under 'br' to match - * those configured in 'br->cfg'. */ static void -bridge_add_del_ports(struct bridge *br) +bridge_collect_wanted_ports(struct bridge *br, + const unsigned long int *splinter_vlans, + struct shash *wanted_ports) { - struct port *port, *next; - struct shash_node *node; - struct shash new_ports; size_t i; - /* Collect new ports. */ - shash_init(&new_ports); + shash_init(wanted_ports); + for (i = 0; i < br->cfg->n_ports; i++) { const char *name = br->cfg->ports[i]->name; - if (!shash_add_once(&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); + ovsrec_interface_init(&br->synth_local_iface); + ovsrec_port_init(&br->synth_local_port); + br->synth_local_port.interfaces = &br->synth_local_ifacep; br->synth_local_port.n_interfaces = 1; br->synth_local_port.name = br->name; @@ -2183,14 +2781,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, 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. - * Update 'cfg' of ports that still exist. */ + * Get rid of deleted interfaces on ports that still exist. */ HMAP_FOR_EACH_SAFE (port, next, hmap_node, &br->ports) { - port->cfg = shash_find_data(&new_ports, port->name); + port->cfg = shash_find_data(wanted_ports, port->name); if (!port->cfg) { port_destroy(port); } else { @@ -2198,22 +2809,29 @@ bridge_add_del_ports(struct bridge *br) } } - /* Create new ports. - * Add new interfaces to existing ports. */ - SHASH_FOR_EACH (node, &new_ports) { - struct port *port = port_lookup(br, node->name); - if (!port) { - struct ovsrec_port *cfg = node->data; - port = port_create(br, cfg); - } - port_add_ifaces(port); - if (list_is_empty(&port->ifaces)) { - VLOG_WARN("bridge %s: port %s has no interfaces, dropping", - br->name, port->name); - port_destroy(port); + /* 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; + + for (i = 0; i < port->n_interfaces; i++) { + const struct ovsrec_interface *cfg = port->interfaces[i]; + struct iface *iface = iface_lookup(br, cfg->name); + const char *type = iface_get_type(cfg, br->cfg); + + if (iface) { + iface->cfg = cfg; + iface->type = type; + } else if (!strcmp(type, "null")) { + VLOG_WARN_ONCE("%s: The null interface type is deprecated and" + " may be removed in February 2013. Please email" + " dev@openvswitch.org with concerns.", + cfg->name); + } else { + /* We will add new interfaces later. */ + } } } - shash_destroy(&new_ports); } /* Initializes 'oc' appropriately as a management service controller for @@ -2230,6 +2848,7 @@ bridge_ofproto_controller_for_mgmt(const struct bridge *br, oc->band = OFPROTO_OUT_OF_BAND; oc->rate_limit = 0; oc->burst_limit = 0; + oc->enable_async_msgs = true; } /* Converts ovsrec_controller 'c' into an ofproto_controller in 'oc'. */ @@ -2237,6 +2856,8 @@ static void bridge_ofproto_controller_from_ovsrec(const struct ovsrec_controller *c, struct ofproto_controller *oc) { + int dscp; + oc->target = c->target; oc->max_backoff = c->max_backoff ? *c->max_backoff / 1000 : 8; oc->probe_interval = c->inactivity_probe ? *c->inactivity_probe / 1000 : 5; @@ -2245,6 +2866,13 @@ bridge_ofproto_controller_from_ovsrec(const struct ovsrec_controller *c, oc->rate_limit = c->controller_rate_limit ? *c->controller_rate_limit : 0; oc->burst_limit = (c->controller_burst_limit ? *c->controller_burst_limit : 0); + oc->enable_async_msgs = (!c->enable_async_messages + || *c->enable_async_messages); + dscp = smap_get_int(&c->other_config, "dscp", DSCP_DEFAULT); + if (dscp < 0 || dscp > 63) { + dscp = DSCP_DEFAULT; + } + oc->dscp = dscp; } /* Configures the IP stack for 'br''s local interface properly according to the @@ -2261,44 +2889,56 @@ 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 + || !inet_pton(AF_INET, c->local_ip, &ip)) { return; } /* Bring up the local interface. */ netdev = local_iface->netdev; - netdev_turn_flags_on(netdev, NETDEV_UP, true); + netdev_turn_flags_on(netdev, NETDEV_UP, NULL); /* Configure the IP address and netmask. */ if (!c->local_netmask - || !inet_aton(c->local_netmask, &mask) + || !inet_pton(AF_INET, c->local_netmask, &mask) || !mask.s_addr) { mask.s_addr = guess_netmask(ip.s_addr); } if (!netdev_set_in4(netdev, ip, mask)) { VLOG_INFO("bridge %s: configured IP address "IP_FMT", netmask "IP_FMT, - br->name, IP_ARGS(&ip.s_addr), IP_ARGS(&mask.s_addr)); + br->name, IP_ARGS(ip.s_addr), IP_ARGS(mask.s_addr)); } /* Configure the default gateway. */ if (c->local_gateway - && inet_aton(c->local_gateway, &gateway) + && inet_pton(AF_INET, c->local_gateway, &gateway) && gateway.s_addr) { if (!netdev_add_router(netdev, gateway)) { VLOG_INFO("bridge %s: configured gateway "IP_FMT, - br->name, IP_ARGS(&gateway.s_addr)); + br->name, IP_ARGS(gateway.s_addr)); } } } /* Returns true if 'a' and 'b' are the same except that any number of slashes * in either string are treated as equal to any number of slashes in the other, - * e.g. "x///y" is equal to "x/y". */ + * e.g. "x///y" is equal to "x/y". + * + * Also, if 'b_stoplen' bytes from 'b' are found to be equal to corresponding + * bytes from 'a', the function considers this success. Specify 'b_stoplen' as + * SIZE_MAX to compare all of 'a' to all of 'b' rather than just a prefix of + * 'b' against a prefix of 'a'. + */ static bool -equal_pathnames(const char *a, const char *b) +equal_pathnames(const char *a, const char *b, size_t b_stoplen) { - while (*a == *b) { - if (*a == '/') { + const char *b_start = b; + for (;;) { + if (b - b_start >= b_stoplen) { + return true; + } else if (*a != *b) { + return false; + } else if (*a == '/') { a += strspn(a, "/"); b += strspn(b, "/"); } else if (*a == '\0') { @@ -2308,16 +2948,13 @@ equal_pathnames(const char *a, const char *b) b++; } } - return false; } static void bridge_configure_remotes(struct bridge *br, const struct sockaddr_in *managers, size_t n_managers) { - const char *disable_ib_str, *queue_id_str; - bool disable_in_band = false; - int queue_id; + bool disable_in_band; struct ovsrec_controller **controllers; size_t n_controllers; @@ -2329,15 +2966,13 @@ bridge_configure_remotes(struct bridge *br, size_t i; /* Check if we should disable in-band control on this bridge. */ - disable_ib_str = bridge_get_other_config(br->cfg, "disable-in-band"); - if (disable_ib_str && !strcmp(disable_ib_str, "true")) { - disable_in_band = true; - } + disable_in_band = smap_get_bool(&br->cfg->other_config, "disable-in-band", + false); /* Set OpenFlow queue ID for in-band control. */ - queue_id_str = bridge_get_other_config(br->cfg, "in-band-queue"); - queue_id = queue_id_str ? strtol(queue_id_str, NULL, 10) : -1; - ofproto_set_in_band_queue(br->ofproto, queue_id); + ofproto_set_in_band_queue(br->ofproto, + smap_get_int(&br->cfg->other_config, + "in-band-queue", -1)); if (disable_in_band) { ofproto_set_extra_in_band_remotes(br->ofproto, NULL, 0); @@ -2359,21 +2994,42 @@ bridge_configure_remotes(struct bridge *br, static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5); char *whitelist; - whitelist = xasprintf("unix:%s/%s.controller", + if (!strncmp(c->target, "unix:", 5)) { + /* Connect to a listening socket */ + whitelist = xasprintf("unix:%s/", ovs_rundir()); + if (strchr(c->target, '/') && + !equal_pathnames(c->target, whitelist, + strlen(whitelist))) { + /* Absolute path specified, but not in ovs_rundir */ + VLOG_ERR_RL(&rl, "bridge %s: Not connecting to socket " + "controller \"%s\" due to possibility for " + "remote exploit. Instead, specify socket " + "in whitelisted \"%s\" or connect to " + "\"unix:%s/%s.mgmt\" (which is always " + "available without special configuration).", + br->name, c->target, whitelist, ovs_rundir(), br->name); - if (!equal_pathnames(c->target, whitelist)) { - /* Prevent remote ovsdb-server users from accessing arbitrary - * Unix domain sockets and overwriting arbitrary local - * files. */ - VLOG_ERR_RL(&rl, "bridge %s: Not adding Unix domain socket " - "controller \"%s\" due to possibility for remote " - "exploit. Instead, specify whitelisted \"%s\" or " - "connect to \"unix:%s/%s.mgmt\" (which is always " - "available without special configuration).", - br->name, c->target, whitelist, - ovs_rundir(), br->name); - free(whitelist); - continue; + free(whitelist); + continue; + } + } else { + whitelist = xasprintf("punix:%s/%s.controller", + ovs_rundir(), br->name); + if (!equal_pathnames(c->target, whitelist, SIZE_MAX)) { + /* 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).", + br->name, c->target, whitelist, + ovs_rundir(), br->name); + free(whitelist); + continue; + } } free(whitelist); @@ -2387,7 +3043,8 @@ bridge_configure_remotes(struct bridge *br, n_ocs++; } - ofproto_set_controllers(br->ofproto, ocs, n_ocs); + ofproto_set_controllers(br->ofproto, ocs, n_ocs, + bridge_get_allowed_versions(br)); free(ocs[0].target); /* From bridge_ofproto_controller_for_mgmt(). */ free(ocs); @@ -2402,13 +3059,116 @@ bridge_configure_remotes(struct bridge *br, if (!ofproto_has_snoops(br->ofproto)) { struct sset snoops; - sset_init(&snoops); - sset_add_and_free(&snoops, xasprintf("punix:%s/%s.snoop", - ovs_rundir(), br->name)); - ofproto_set_snoops(br->ofproto, &snoops); - sset_destroy(&snoops); + sset_init(&snoops); + sset_add_and_free(&snoops, xasprintf("punix:%s/%s.snoop", + ovs_rundir(), br->name)); + ofproto_set_snoops(br->ofproto, &snoops); + sset_destroy(&snoops); + } +} + +static void +bridge_configure_tables(struct bridge *br) +{ + static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5); + int n_tables; + int i, j, k; + + n_tables = ofproto_get_n_tables(br->ofproto); + j = 0; + for (i = 0; i < n_tables; i++) { + struct ofproto_table_settings s; + + s.name = NULL; + s.max_flows = UINT_MAX; + s.groups = NULL; + s.n_groups = 0; + s.n_prefix_fields = 0; + memset(s.prefix_fields, ~0, sizeof(s.prefix_fields)); + + if (j < br->cfg->n_flow_tables && i == br->cfg->key_flow_tables[j]) { + struct ovsrec_flow_table *cfg = br->cfg->value_flow_tables[j++]; + + s.name = cfg->name; + if (cfg->n_flow_limit && *cfg->flow_limit < UINT_MAX) { + s.max_flows = *cfg->flow_limit; + } + if (cfg->overflow_policy + && !strcmp(cfg->overflow_policy, "evict")) { + + s.groups = xmalloc(cfg->n_groups * sizeof *s.groups); + for (k = 0; k < cfg->n_groups; k++) { + const char *string = cfg->groups[k]; + char *msg; + + msg = mf_parse_subfield__(&s.groups[k], &string); + if (msg) { + VLOG_WARN_RL(&rl, "bridge %s table %d: error parsing " + "'groups' (%s)", br->name, i, msg); + free(msg); + } else if (*string) { + VLOG_WARN_RL(&rl, "bridge %s table %d: 'groups' " + "element '%s' contains trailing garbage", + br->name, i, cfg->groups[k]); + } else { + s.n_groups++; + } + } + } + /* 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); + if (!mf) { + VLOG_WARN("bridge %s: 'prefixes' with unknown field: %s", + br->name, name); + continue; + } + if (mf->flow_be32ofs < 0 || mf->n_bits % 32) { + VLOG_WARN("bridge %s: 'prefixes' with incompatible field: " + "%s", br->name, name); + continue; + } + if (s.n_prefix_fields >= ARRAY_SIZE(s.prefix_fields)) { + VLOG_WARN("bridge %s: 'prefixes' with too many fields, " + "field not used: %s", br->name, name); + continue; + } + 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); + } + VLOG_INFO("bridge %s table %d: Prefix lookup with: %s.", + br->name, i, ds_cstr(&ds)); + ds_destroy(&ds); + } + } + + ofproto_configure_table(br->ofproto, i, &s); + + free(s.groups); + } + for (; j < br->cfg->n_flow_tables; j++) { + VLOG_WARN_RL(&rl, "bridge %s: ignoring configuration for flow table " + "%"PRId64" not supported by this datapath", br->name, + br->cfg->key_flow_tables[j]); } } + +static void +bridge_configure_dp_desc(struct bridge *br) +{ + ofproto_set_dp_desc(br->ofproto, + smap_get(&br->cfg->other_config, "dp-desc")); +} /* Port functions. */ @@ -2424,34 +3184,9 @@ port_create(struct bridge *br, const struct ovsrec_port *cfg) list_init(&port->ifaces); hmap_insert(&br->ports, &port->hmap_node, hash_string(port->name, 0)); - - VLOG_INFO("created port %s on bridge %s", port->name, br->name); - return port; } -static const char * -get_port_other_config(const struct ovsrec_port *port, const char *key, - const char *default_value) -{ - const char *value; - - value = get_ovsrec_key_value(&port->header_, &ovsrec_port_col_other_config, - key); - return value ? value : default_value; -} - -static const char * -get_interface_other_config(const struct ovsrec_interface *iface, - const char *key, const char *default_value) -{ - const char *value; - - value = get_ovsrec_key_value(&iface->header_, - &ovsrec_interface_col_other_config, key); - return value ? value : default_value; -} - /* Deletes interfaces from 'port' that are no longer configured for it. */ static void port_del_ifaces(struct port *port) @@ -2464,7 +3199,7 @@ port_del_ifaces(struct port *port) sset_init(&new_ifaces); for (i = 0; i < port->cfg->n_interfaces; i++) { const char *name = port->cfg->interfaces[i]->name; - const char *type = port->cfg->interfaces[i]->name; + const char *type = port->cfg->interfaces[i]->type; if (strcmp(type, "null")) { sset_add(&new_ifaces, name); } @@ -2480,51 +3215,6 @@ port_del_ifaces(struct port *port) sset_destroy(&new_ifaces); } -/* Adds new interfaces to 'port' and updates 'type' and 'cfg' members of - * existing ones. */ -static void -port_add_ifaces(struct port *port) -{ - struct shash new_ifaces; - struct shash_node *node; - size_t i; - - /* Collect new ifaces. */ - shash_init(&new_ifaces); - for (i = 0; i < port->cfg->n_interfaces; i++) { - const struct ovsrec_interface *cfg = port->cfg->interfaces[i]; - if (strcmp(cfg->type, "null") - && !shash_add_once(&new_ifaces, cfg->name, cfg)) { - VLOG_WARN("port %s: %s specified twice as port interface", - port->name, cfg->name); - iface_clear_db_record(cfg); - } - } - - /* Create new interfaces. - * Update interface types and 'cfg' members. */ - SHASH_FOR_EACH (node, &new_ifaces) { - const struct ovsrec_interface *cfg = node->data; - const char *iface_name = node->name; - struct iface *iface; - - iface = iface_lookup(port->bridge, iface_name); - if (!iface) { - iface = iface_create(port, cfg); - } else { - iface->cfg = cfg; - } - - /* Determine interface type. The local port always has type - * "internal". Other ports take their type from the database and - * default to "system" if none is specified. */ - iface->type = (!strcmp(iface_name, port->bridge->name) ? "internal" - : cfg->type[0] ? cfg->type - : "system"); - } - shash_destroy(&new_ifaces); -} - static void port_destroy(struct port *port) { @@ -2537,13 +3227,10 @@ 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); - - VLOG_INFO("destroyed port %s on bridge %s", port->name, br->name); - free(port->name); free(port); } @@ -2588,8 +3275,7 @@ enable_lacp(struct port *port, bool *activep) static struct lacp_settings * port_configure_lacp(struct port *port, struct lacp_settings *s) { - const char *lacp_time; - long long int custom_time; + const char *lacp_time, *system_id; int priority; if (!enable_lacp(port, &s->active)) { @@ -2597,32 +3283,36 @@ port_configure_lacp(struct port *port, struct lacp_settings *s) } s->name = port->name; - memcpy(s->id, port->bridge->ea, ETH_ADDR_LEN); + + system_id = smap_get(&port->cfg->other_config, "lacp-system-id"); + if (system_id) { + if (!ovs_scan(system_id, ETH_ADDR_SCAN_FMT, + ETH_ADDR_SCAN_ARGS(s->id))) { + VLOG_WARN("port %s: LACP system ID (%s) must be an Ethernet" + " address.", port->name, system_id); + return NULL; + } + } else { + memcpy(s->id, port->bridge->ea, ETH_ADDR_LEN); + } + + if (eth_addr_is_zero(s->id)) { + VLOG_WARN("port %s: Invalid zero LACP system ID.", port->name); + return NULL; + } /* Prefer bondable links if unspecified. */ - priority = atoi(get_port_other_config(port->cfg, "lacp-system-priority", - "0")); + priority = smap_get_int(&port->cfg->other_config, "lacp-system-priority", + 0); s->priority = (priority > 0 && priority <= UINT16_MAX ? priority : UINT16_MAX - !list_is_short(&port->ifaces)); - s->heartbeat = !strcmp(get_port_other_config(port->cfg, - "lacp-heartbeat", - "false"), "true"); + lacp_time = smap_get(&port->cfg->other_config, "lacp-time"); + s->fast = lacp_time && !strcasecmp(lacp_time, "fast"); - - lacp_time = get_port_other_config(port->cfg, "lacp-time", "slow"); - custom_time = atoi(lacp_time); - if (!strcmp(lacp_time, "fast")) { - s->lacp_time = LACP_TIME_FAST; - } else if (!strcmp(lacp_time, "slow")) { - s->lacp_time = LACP_TIME_SLOW; - } else if (custom_time > 0) { - s->lacp_time = LACP_TIME_CUSTOM; - s->custom_time = custom_time; - } else { - s->lacp_time = LACP_TIME_SLOW; - } + s->fallback_ab_cfg = smap_get_bool(&port->cfg->other_config, + "lacp-fallback-ab", false); return s; } @@ -2632,14 +3322,13 @@ iface_configure_lacp(struct iface *iface, struct lacp_slave_settings *s) { int priority, portid, key; - portid = atoi(get_interface_other_config(iface->cfg, "lacp-port-id", "0")); - priority = atoi(get_interface_other_config(iface->cfg, - "lacp-port-priority", "0")); - key = atoi(get_interface_other_config(iface->cfg, "lacp-aggregation-key", - "0")); + portid = smap_get_int(&iface->cfg->other_config, "lacp-port-id", 0); + priority = smap_get_int(&iface->cfg->other_config, "lacp-port-priority", + 0); + key = smap_get_int(&iface->cfg->other_config, "lacp-aggregation-key", 0); if (portid <= 0 || portid > UINT16_MAX) { - portid = iface->ofp_port; + portid = ofp_to_u16(iface->ofp_port); } if (priority <= 0 || priority > UINT16_MAX) { @@ -2657,21 +3346,29 @@ iface_configure_lacp(struct iface *iface, struct lacp_slave_settings *s) } static void -port_configure_bond(struct port *port, struct bond_settings *s, - uint32_t *bond_stable_ids) +port_configure_bond(struct port *port, struct bond_settings *s) { const char *detect_s; struct iface *iface; int miimon_interval; - size_t i; s->name = port->name; - s->balance = BM_SLB; - if (port->cfg->bond_mode - && !bond_mode_from_string(&s->balance, port->cfg->bond_mode)) { - VLOG_WARN("port %s: unknown bond_mode %s, defaulting to %s", - port->name, port->cfg->bond_mode, - bond_mode_to_string(s->balance)); + s->balance = BM_AB; + if (port->cfg->bond_mode) { + if (!bond_mode_from_string(&s->balance, port->cfg->bond_mode)) { + VLOG_WARN("port %s: unknown bond_mode %s, defaulting to %s", + port->name, port->cfg->bond_mode, + bond_mode_to_string(s->balance)); + } + } else { + static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 1); + + /* XXX: Post version 1.5.*, the default bond_mode changed from SLB to + * active-backup. At some point we should remove this warning. */ + VLOG_WARN_RL(&rl, "port %s: Using the default bond_mode %s. Note that" + " in previous versions, the default bond_mode was" + " balance-slb", port->name, + bond_mode_to_string(s->balance)); } if (s->balance == BM_SLB && port->bridge->cfg->n_flood_vlans) { VLOG_WARN("port %s: SLB bonds are incompatible with flood_vlans, " @@ -2679,14 +3376,14 @@ port_configure_bond(struct port *port, struct bond_settings *s, port->name); } - miimon_interval = atoi(get_port_other_config(port->cfg, - "bond-miimon-interval", "0")); + miimon_interval = smap_get_int(&port->cfg->other_config, + "bond-miimon-interval", 0); if (miimon_interval <= 0) { miimon_interval = 200; } - detect_s = get_port_other_config(port->cfg, "bond-detect-mode", "carrier"); - if (!strcmp(detect_s, "carrier")) { + detect_s = smap_get(&port->cfg->other_config, "bond-detect-mode"); + if (!detect_s || !strcmp(detect_s, "carrier")) { miimon_interval = 0; } else if (strcmp(detect_s, "miimon")) { VLOG_WARN("port %s: unsupported bond-detect-mode %s, " @@ -2696,26 +3393,19 @@ port_configure_bond(struct port *port, struct bond_settings *s, s->up_delay = MAX(0, port->cfg->bond_updelay); s->down_delay = MAX(0, port->cfg->bond_downdelay); - s->basis = atoi(get_port_other_config(port->cfg, "bond-hash-basis", "0")); - s->rebalance_interval = atoi( - get_port_other_config(port->cfg, "bond-rebalance-interval", "10000")); - if (s->rebalance_interval < 1000) { + s->basis = smap_get_int(&port->cfg->other_config, "bond-hash-basis", 0); + s->rebalance_interval = smap_get_int(&port->cfg->other_config, + "bond-rebalance-interval", 10000); + if (s->rebalance_interval && s->rebalance_interval < 1000) { s->rebalance_interval = 1000; } s->fake_iface = port->cfg->bond_fake_iface; - i = 0; - LIST_FOR_EACH (iface, port_elem, &port->ifaces) { - long long stable_id; - - stable_id = atoll(get_interface_other_config(iface->cfg, - "bond-stable-id", "0")); - if (stable_id <= 0 || stable_id >= UINT32_MAX) { - stable_id = iface->ofp_port; - } - bond_stable_ids[i++] = stable_id; + 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); } } @@ -2730,42 +3420,46 @@ port_is_synthetic(const struct port *port) /* Interface functions. */ -static struct iface * -iface_create(struct port *port, const struct ovsrec_interface *if_cfg) +static bool +iface_is_internal(const struct ovsrec_interface *iface, + const struct ovsrec_bridge *br) { - struct bridge *br = port->bridge; - struct iface *iface; - char *name = if_cfg->name; - - iface = xzalloc(sizeof *iface); - iface->port = port; - iface->name = xstrdup(name); - iface->ofp_port = -1; - iface->tag = tag_create_random(); - iface->netdev = NULL; - iface->cfg = if_cfg; - - hmap_insert(&br->iface_by_name, &iface->name_node, hash_string(name, 0)); + /* The local port and "internal" ports are always "internal". */ + return !strcmp(iface->type, "internal") || !strcmp(iface->name, br->name); +} - list_push_back(&port->ifaces, &iface->port_elem); +/* Returns the correct network device type for interface 'iface' in bridge + * 'br'. */ +static const char * +iface_get_type(const struct ovsrec_interface *iface, + const struct ovsrec_bridge *br) +{ + const char *type; - VLOG_DBG("attached network device %s to port %s", iface->name, port->name); + /* The local port always has type "internal". Other ports take + * their type from the database and default to "system" if none is + * specified. */ + if (iface_is_internal(iface, br)) { + type = "internal"; + } else { + type = iface->type[0] ? iface->type : "system"; + } - return iface; + return ofproto_port_open_type(br->datapath_type, type); } static void -iface_destroy(struct iface *iface) +iface_destroy__(struct iface *iface) { if (iface) { struct port *port = iface->port; struct bridge *br = port->bridge; - if (br->ofproto && iface->ofp_port >= 0) { + if (br->ofproto && iface->ofp_port != OFPP_NONE) { ofproto_port_unregister(br->ofproto, iface->ofp_port); } - if (iface->ofp_port >= 0) { + if (iface->ofp_port != OFPP_NONE) { hmap_remove(&br->ifaces, &iface->ofp_port_node); } @@ -2779,6 +3473,19 @@ iface_destroy(struct iface *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) { @@ -2810,12 +3517,12 @@ iface_find(const char *name) } static struct iface * -iface_from_ofp_port(const struct bridge *br, uint16_t ofp_port) +iface_from_ofp_port(const struct bridge *br, ofp_port_t ofp_port) { struct iface *iface; - HMAP_FOR_EACH_IN_BUCKET (iface, ofp_port_node, - hash_int(ofp_port, 0), &br->ifaces) { + HMAP_FOR_EACH_IN_BUCKET (iface, ofp_port_node, hash_ofp_port(ofp_port), + &br->ifaces) { if (iface->ofp_port == ofp_port) { return iface; } @@ -2826,24 +3533,36 @@ iface_from_ofp_port(const struct bridge *br, uint16_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]; + uint8_t ea[ETH_ADDR_LEN], *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, strerror(error)); + iface->name, ovs_strerror(error)); } } } @@ -2851,10 +3570,11 @@ iface_set_mac(struct iface *iface) /* Sets the ofport column of 'if_cfg' to 'ofport'. */ static void -iface_set_ofport(const struct ovsrec_interface *if_cfg, int64_t ofport) +iface_set_ofport(const struct ovsrec_interface *if_cfg, ofp_port_t ofport) { if (if_cfg && !ovsdb_idl_row_is_synthetic(&if_cfg->header_)) { - ovsrec_interface_set_ofport(if_cfg, &ofport, 1); + int64_t port = ofport == OFPP_NONE ? -1 : ofp_to_u16(ofport); + ovsrec_interface_set_ofport(if_cfg, &port, 1); } } @@ -2867,73 +3587,23 @@ static void iface_clear_db_record(const struct ovsrec_interface *if_cfg) { if (!ovsdb_idl_row_is_synthetic(&if_cfg->header_)) { - iface_set_ofport(if_cfg, -1); - ovsrec_interface_set_status(if_cfg, NULL, NULL, 0); + iface_set_ofport(if_cfg, OFPP_NONE); + ovsrec_interface_set_status(if_cfg, NULL); ovsrec_interface_set_admin_state(if_cfg, NULL); ovsrec_interface_set_duplex(if_cfg, NULL); ovsrec_interface_set_link_speed(if_cfg, NULL, 0); ovsrec_interface_set_link_state(if_cfg, NULL); + ovsrec_interface_set_mac_in_use(if_cfg, NULL); ovsrec_interface_set_mtu(if_cfg, NULL, 0); ovsrec_interface_set_cfm_fault(if_cfg, NULL, 0); + ovsrec_interface_set_cfm_fault_status(if_cfg, NULL, 0); ovsrec_interface_set_cfm_remote_mpids(if_cfg, NULL, 0); ovsrec_interface_set_lacp_current(if_cfg, NULL, 0); ovsrec_interface_set_statistics(if_cfg, NULL, NULL, 0); + ovsrec_interface_set_ifindex(if_cfg, NULL, 0); } } -/* Adds the 'n' key-value pairs in 'keys' in 'values' to 'shash'. - * - * The value strings in '*shash' are taken directly from values[], not copied, - * so the caller should not modify or free them. */ -static void -shash_from_ovs_idl_map(char **keys, char **values, size_t n, - struct shash *shash) -{ - size_t i; - - shash_init(shash); - for (i = 0; i < n; i++) { - shash_add(shash, keys[i], values[i]); - } -} - -/* Creates 'keys' and 'values' arrays from 'shash'. - * - * Sets 'keys' and 'values' to heap allocated arrays representing the key-value - * pairs in 'shash'. The caller takes ownership of 'keys' and 'values'. They - * are populated with with strings taken directly from 'shash' and thus have - * the same ownership of the key-value pairs in shash. - */ -static void -shash_to_ovs_idl_map(struct shash *shash, - char ***keys, char ***values, size_t *n) -{ - size_t i, count; - char **k, **v; - struct shash_node *sn; - - count = shash_count(shash); - - k = xmalloc(count * sizeof *k); - v = xmalloc(count * sizeof *v); - - i = 0; - SHASH_FOR_EACH(sn, shash) { - k[i] = sn->name; - v[i] = sn->data; - i++; - } - - *n = count; - *keys = k; - *values = v; -} - -struct iface_delete_queues_cbdata { - struct netdev *netdev; - const struct ovsdb_datum *queues; -}; - static bool queue_ids_include(const struct ovsdb_datum *queues, int64_t target) { @@ -2944,38 +3614,35 @@ queue_ids_include(const struct ovsdb_datum *queues, int64_t target) } static void -iface_delete_queues(unsigned int queue_id, - const struct shash *details OVS_UNUSED, void *cbdata_) +iface_configure_qos(struct iface *iface, const struct ovsrec_qos *qos) { - struct iface_delete_queues_cbdata *cbdata = cbdata_; + struct ofpbuf queues_buf; - if (!queue_ids_include(cbdata->queues, queue_id)) { - netdev_delete_queue(cbdata->netdev, queue_id); - } -} + ofpbuf_init(&queues_buf, 0); -static void -iface_configure_qos(struct iface *iface, const struct ovsrec_qos *qos) -{ if (!qos || qos->type[0] == '\0' || qos->n_queues < 1) { netdev_set_qos(iface->netdev, NULL, NULL); } else { - struct iface_delete_queues_cbdata cbdata; - struct shash details; + const struct ovsdb_datum *queues; + struct netdev_queue_dump dump; + unsigned int queue_id; + struct smap details; bool queue_zero; size_t i; /* Configure top-level Qos for 'iface'. */ - shash_from_ovs_idl_map(qos->key_other_config, qos->value_other_config, - qos->n_other_config, &details); - netdev_set_qos(iface->netdev, qos->type, &details); - shash_destroy(&details); + netdev_set_qos(iface->netdev, qos->type, &qos->other_config); /* Deconfigure queues that were deleted. */ - cbdata.netdev = iface->netdev; - cbdata.queues = ovsrec_qos_get_queues(qos, OVSDB_TYPE_INTEGER, - OVSDB_TYPE_UUID); - netdev_dump_queues(iface->netdev, iface_delete_queues, &cbdata); + queues = ovsrec_qos_get_queues(qos, OVSDB_TYPE_INTEGER, + OVSDB_TYPE_UUID); + smap_init(&details); + NETDEV_QUEUE_FOR_EACH (&queue_id, &details, &dump, iface->netdev) { + if (!queue_ids_include(queues, queue_id)) { + netdev_delete_queue(iface->netdev, queue_id); + } + } + smap_destroy(&details); /* Configure queues for 'iface'. */ queue_zero = false; @@ -2987,53 +3654,92 @@ iface_configure_qos(struct iface *iface, const struct ovsrec_qos *qos) queue_zero = true; } - shash_from_ovs_idl_map(queue->key_other_config, - queue->value_other_config, - queue->n_other_config, &details); - netdev_set_queue(iface->netdev, queue_id, &details); - shash_destroy(&details); + if (queue->n_dscp == 1) { + struct ofproto_port_queue *port_queue; + + port_queue = ofpbuf_put_uninit(&queues_buf, + sizeof *port_queue); + port_queue->queue = queue_id; + port_queue->dscp = queue->dscp[0]; + } + + netdev_set_queue(iface->netdev, queue_id, &queue->other_config); } if (!queue_zero) { - static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 1); - VLOG_WARN_RL(&rl, "interface %s: QoS configured without a default " - "queue (queue 0). Packets not directed to a " - "correctly configured queue may be dropped.", - iface->name); + struct smap details; + + smap_init(&details); + netdev_set_queue(iface->netdev, 0, &details); + smap_destroy(&details); } } + if (iface->ofp_port != OFPP_NONE) { + const struct ofproto_port_queue *port_queues = ofpbuf_data(&queues_buf); + size_t n_queues = ofpbuf_size(&queues_buf) / sizeof *port_queues; + + ofproto_port_set_queues(iface->port->bridge->ofproto, iface->ofp_port, + port_queues, n_queues); + } + netdev_set_policing(iface->netdev, iface->cfg->ingress_policing_rate, iface->cfg->ingress_policing_burst); + + ofpbuf_uninit(&queues_buf); } static void iface_configure_cfm(struct iface *iface) { const struct ovsrec_interface *cfg = iface->cfg; - const char *extended_str, *opstate_str; + const char *opstate_str; + const char *cfm_ccm_vlan; struct cfm_settings s; + struct smap netdev_args; if (!cfg->n_cfm_mpid) { ofproto_port_clear_cfm(iface->port->bridge->ofproto, iface->ofp_port); return; } + s.check_tnl_key = false; + smap_init(&netdev_args); + if (!netdev_get_config(iface->netdev, &netdev_args)) { + const char *key = smap_get(&netdev_args, "key"); + const char *in_key = smap_get(&netdev_args, "in_key"); + + s.check_tnl_key = (key && !strcmp(key, "flow")) + || (in_key && !strcmp(in_key, "flow")); + } + smap_destroy(&netdev_args); + s.mpid = *cfg->cfm_mpid; - s.interval = atoi(get_interface_other_config(iface->cfg, "cfm_interval", - "0")); - s.ccm_vlan = atoi(get_interface_other_config(iface->cfg, "cfm_ccm_vlan", - "0")); + s.interval = smap_get_int(&iface->cfg->other_config, "cfm_interval", 0); + cfm_ccm_vlan = smap_get(&iface->cfg->other_config, "cfm_ccm_vlan"); + s.ccm_pcp = smap_get_int(&iface->cfg->other_config, "cfm_ccm_pcp", 0); + if (s.interval <= 0) { s.interval = 1000; } - extended_str = get_interface_other_config(iface->cfg, "cfm_extended", - "false"); - s.extended = !strcasecmp("true", extended_str); + if (!cfm_ccm_vlan) { + s.ccm_vlan = 0; + } else if (!strcasecmp("random", cfm_ccm_vlan)) { + s.ccm_vlan = CFM_RANDOM_VLAN; + } else { + s.ccm_vlan = atoi(cfm_ccm_vlan); + if (s.ccm_vlan == CFM_RANDOM_VLAN) { + s.ccm_vlan = 0; + } + } + + s.extended = smap_get_bool(&iface->cfg->other_config, "cfm_extended", + false); + s.demand = smap_get_bool(&iface->cfg->other_config, "cfm_demand", false); - opstate_str = get_interface_other_config(iface->cfg, "cfm_opstate", "up"); - s.opup = !strcasecmp("up", opstate_str); + opstate_str = smap_get(&iface->cfg->other_config, "cfm_opstate"); + s.opup = !opstate_str || !strcasecmp("up", opstate_str); ofproto_port_set_cfm(iface->port->bridge->ofproto, iface->ofp_port, &s); } @@ -3045,6 +3751,29 @@ iface_is_synthetic(const struct iface *iface) { return ovsdb_idl_row_is_synthetic(&iface->cfg->header_); } + +static ofp_port_t +iface_validate_ofport__(size_t n, int64_t *ofport) +{ + return (n && *ofport >= 1 && *ofport < ofp_to_u16(OFPP_MAX) + ? u16_to_ofp(*ofport) + : OFPP_NONE); +} + +static ofp_port_t +iface_get_requested_ofp_port(const struct ovsrec_interface *cfg) +{ + return iface_validate_ofport__(cfg->n_ofport_request, cfg->ofport_request); +} + +static ofp_port_t +iface_pick_ofport(const struct ovsrec_interface *cfg) +{ + ofp_port_t requested_ofport = iface_get_requested_ofp_port(cfg); + return (requested_ofport != OFPP_NONE + ? requested_ofport + : iface_validate_ofport__(cfg->n_ofport, cfg->ofport)); +} /* Port mirroring. */ @@ -3087,7 +3816,8 @@ bridge_configure_mirrors(struct bridge *br) if (!m) { m = mirror_create(br, cfg); } - if (!mirror_configure(m, cfg)) { + m->cfg = cfg; + if (!mirror_configure(m)) { mirror_destroy(m); } } @@ -3153,8 +3883,9 @@ mirror_collect_ports(struct mirror *m, } static bool -mirror_configure(struct mirror *m, const struct ovsrec_mirror *cfg) +mirror_configure(struct mirror *m) { + const struct ovsrec_mirror *cfg = m->cfg; struct ofproto_mirror_settings s; /* Set name. */ @@ -3230,3 +3961,303 @@ mirror_configure(struct mirror *m, const struct ovsrec_mirror *cfg) return true; } + +/* Linux VLAN device support (e.g. "eth0.10" for VLAN 10.) + * + * This is deprecated. It is only for compatibility with broken device drivers + * in old versions of Linux that do not properly support VLANs when VLAN + * devices are not used. When broken device drivers are no longer in + * widespread use, we will delete these interfaces. */ + +static struct ovsrec_port **recs; +static size_t n_recs, allocated_recs; + +/* Adds 'rec' to a list of recs that have to be destroyed when the VLAN + * splinters are reconfigured. */ +static void +register_rec(struct ovsrec_port *rec) +{ + if (n_recs >= allocated_recs) { + recs = x2nrealloc(recs, &allocated_recs, sizeof *recs); + } + recs[n_recs++] = rec; +} + +/* Frees all of the ports registered with register_reg(). */ +static void +free_registered_recs(void) +{ + size_t i; + + for (i = 0; i < n_recs; i++) { + struct ovsrec_port *port = recs[i]; + size_t j; + + for (j = 0; j < port->n_interfaces; j++) { + struct ovsrec_interface *iface = port->interfaces[j]; + free(iface->name); + free(iface); + } + + smap_destroy(&port->other_config); + free(port->interfaces); + free(port->name); + free(port->tag); + free(port); + } + n_recs = 0; +} + +/* Returns true if VLAN splinters are enabled on 'iface_cfg', false + * otherwise. */ +static bool +vlan_splinters_is_enabled(const struct ovsrec_interface *iface_cfg) +{ + return smap_get_bool(&iface_cfg->other_config, "enable-vlan-splinters", + false); +} + +/* Figures out the set of VLANs that are in use for the purpose of VLAN + * splinters. + * + * If VLAN splinters are enabled on at least one interface and any VLANs are in + * use, returns a 4096-bit bitmap with a 1-bit for each in-use VLAN (bits 0 and + * 4095 will not be set). The caller is responsible for freeing the bitmap, + * with free(). + * + * If VLANs splinters are not enabled on any interface or if no VLANs are in + * use, returns NULL. + * + * Updates 'vlan_splinters_enabled_anywhere'. */ +static unsigned long int * +collect_splinter_vlans(const struct ovsrec_open_vswitch *ovs_cfg) +{ + unsigned long int *splinter_vlans; + struct sset splinter_ifaces; + const char *real_dev_name; + struct shash *real_devs; + struct shash_node *node; + struct bridge *br; + size_t i; + + /* Free space allocated for synthesized ports and interfaces, since we're + * in the process of reconstructing all of them. */ + free_registered_recs(); + + splinter_vlans = bitmap_allocate(4096); + sset_init(&splinter_ifaces); + vlan_splinters_enabled_anywhere = false; + for (i = 0; i < ovs_cfg->n_bridges; i++) { + struct ovsrec_bridge *br_cfg = ovs_cfg->bridges[i]; + size_t j; + + for (j = 0; j < br_cfg->n_ports; j++) { + struct ovsrec_port *port_cfg = br_cfg->ports[j]; + int k; + + for (k = 0; k < port_cfg->n_interfaces; k++) { + struct ovsrec_interface *iface_cfg = port_cfg->interfaces[k]; + + if (vlan_splinters_is_enabled(iface_cfg)) { + vlan_splinters_enabled_anywhere = true; + sset_add(&splinter_ifaces, iface_cfg->name); + vlan_bitmap_from_array__(port_cfg->trunks, + port_cfg->n_trunks, + splinter_vlans); + } + } + + if (port_cfg->tag && *port_cfg->tag > 0 && *port_cfg->tag < 4095) { + bitmap_set1(splinter_vlans, *port_cfg->tag); + } + } + } + + if (!vlan_splinters_enabled_anywhere) { + free(splinter_vlans); + sset_destroy(&splinter_ifaces); + return NULL; + } + + HMAP_FOR_EACH (br, node, &all_bridges) { + if (br->ofproto) { + ofproto_get_vlan_usage(br->ofproto, splinter_vlans); + } + } + + /* Don't allow VLANs 0 or 4095 to be splintered. VLAN 0 should appear on + * the real device. VLAN 4095 is reserved and Linux doesn't allow a VLAN + * device to be created for it. */ + bitmap_set0(splinter_vlans, 0); + bitmap_set0(splinter_vlans, 4095); + + /* Delete all VLAN devices that we don't need. */ + vlandev_refresh(); + real_devs = vlandev_get_real_devs(); + SHASH_FOR_EACH (node, real_devs) { + const struct vlan_real_dev *real_dev = node->data; + const struct vlan_dev *vlan_dev; + bool real_dev_has_splinters; + + real_dev_has_splinters = sset_contains(&splinter_ifaces, + real_dev->name); + HMAP_FOR_EACH (vlan_dev, hmap_node, &real_dev->vlan_devs) { + if (!real_dev_has_splinters + || !bitmap_is_set(splinter_vlans, vlan_dev->vid)) { + struct netdev *netdev; + + if (!netdev_open(vlan_dev->name, "system", &netdev)) { + if (!netdev_get_in4(netdev, NULL, NULL) || + !netdev_get_in6(netdev, NULL)) { + /* It has an IP address configured, so we don't own + * it. Don't delete it. */ + } else { + vlandev_del(vlan_dev->name); + } + netdev_close(netdev); + } + } + + } + } + + /* Add all VLAN devices that we need. */ + SSET_FOR_EACH (real_dev_name, &splinter_ifaces) { + int vid; + + BITMAP_FOR_EACH_1 (vid, 4096, splinter_vlans) { + if (!vlandev_get_name(real_dev_name, vid)) { + vlandev_add(real_dev_name, vid); + } + } + } + + vlandev_refresh(); + + sset_destroy(&splinter_ifaces); + + if (bitmap_scan(splinter_vlans, 1, 0, 4096) >= 4096) { + free(splinter_vlans); + return NULL; + } + return splinter_vlans; +} + +/* Pushes the configure of VLAN splinter port 'port' (e.g. eth0.9) down to + * ofproto. */ +static void +configure_splinter_port(struct port *port) +{ + struct ofproto *ofproto = port->bridge->ofproto; + ofp_port_t realdev_ofp_port; + const char *realdev_name; + struct iface *vlandev, *realdev; + + ofproto_bundle_unregister(port->bridge->ofproto, port); + + vlandev = CONTAINER_OF(list_front(&port->ifaces), struct iface, + port_elem); + + realdev_name = smap_get(&port->cfg->other_config, "realdev"); + realdev = iface_lookup(port->bridge, realdev_name); + realdev_ofp_port = realdev ? realdev->ofp_port : 0; + + ofproto_port_set_realdev(ofproto, vlandev->ofp_port, realdev_ofp_port, + *port->cfg->tag); +} + +static struct ovsrec_port * +synthesize_splinter_port(const char *real_dev_name, + const char *vlan_dev_name, int vid) +{ + struct ovsrec_interface *iface; + struct ovsrec_port *port; + + iface = xmalloc(sizeof *iface); + ovsrec_interface_init(iface); + iface->name = xstrdup(vlan_dev_name); + iface->type = "system"; + + port = xmalloc(sizeof *port); + ovsrec_port_init(port); + port->interfaces = xmemdup(&iface, sizeof iface); + port->n_interfaces = 1; + port->name = xstrdup(vlan_dev_name); + port->vlan_mode = "splinter"; + port->tag = xmalloc(sizeof *port->tag); + *port->tag = vid; + + smap_add(&port->other_config, "realdev", real_dev_name); + + register_rec(port); + return port; +} + +/* For each interface with 'br' that has VLAN splinters enabled, adds a + * corresponding ovsrec_port to 'ports' for each splinter VLAN marked with a + * 1-bit in the 'splinter_vlans' bitmap. */ +static void +add_vlan_splinter_ports(struct bridge *br, + const unsigned long int *splinter_vlans, + struct shash *ports) +{ + size_t i; + + /* We iterate through 'br->cfg->ports' instead of 'ports' here because + * we're modifying 'ports'. */ + for (i = 0; i < br->cfg->n_ports; i++) { + const char *name = br->cfg->ports[i]->name; + struct ovsrec_port *port_cfg = shash_find_data(ports, name); + size_t j; + + for (j = 0; j < port_cfg->n_interfaces; j++) { + struct ovsrec_interface *iface_cfg = port_cfg->interfaces[j]; + + if (vlan_splinters_is_enabled(iface_cfg)) { + const char *real_dev_name; + uint16_t vid; + + real_dev_name = iface_cfg->name; + BITMAP_FOR_EACH_1 (vid, 4096, splinter_vlans) { + const char *vlan_dev_name; + + vlan_dev_name = vlandev_get_name(real_dev_name, vid); + if (vlan_dev_name + && !shash_find(ports, vlan_dev_name)) { + shash_add(ports, vlan_dev_name, + synthesize_splinter_port( + real_dev_name, vlan_dev_name, vid)); + } + } + } + } + } +} + +static void +mirror_refresh_stats(struct mirror *m) +{ + struct ofproto *ofproto = m->bridge->ofproto; + uint64_t tx_packets, tx_bytes; + char *keys[2]; + int64_t values[2]; + size_t stat_cnt = 0; + + if (ofproto_mirror_get_stats(ofproto, m, &tx_packets, &tx_bytes)) { + ovsrec_mirror_set_statistics(m->cfg, NULL, NULL, 0); + return; + } + + if (tx_packets != UINT64_MAX) { + keys[stat_cnt] = "tx_packets"; + values[stat_cnt] = tx_packets; + stat_cnt++; + } + if (tx_bytes != UINT64_MAX) { + keys[stat_cnt] = "tx_bytes"; + values[stat_cnt] = tx_bytes; + stat_cnt++; + } + + ovsrec_mirror_set_statistics(m->cfg, keys, values, stat_cnt); +}