-/* Copyright (c) 2015 Nicira, Inc.
+/* Copyright (c) 2015, 2016 Nicira, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
#include <stdlib.h>
#include <string.h>
+#include "binding.h"
+#include "chassis.h"
#include "command-line.h"
#include "compiler.h"
#include "daemon.h"
#include "dirs.h"
+#include "openvswitch/dynamic-string.h"
+#include "encaps.h"
+#include "fatal-signal.h"
+#include "openvswitch/hmap.h"
+#include "lflow.h"
+#include "lib/vswitch-idl.h"
+#include "lport.h"
+#include "ofctrl.h"
#include "openvswitch/vconn.h"
#include "openvswitch/vlog.h"
+#include "ovn/lib/actions.h"
#include "ovn/lib/ovn-sb-idl.h"
+#include "ovn/lib/ovn-util.h"
+#include "patch.h"
+#include "physical.h"
+#include "pinctrl.h"
#include "poll-loop.h"
-#include "fatal-signal.h"
-#include "lib/vswitch-idl.h"
+#include "lib/bitmap.h"
+#include "lib/hash.h"
#include "smap.h"
-#include "stream.h"
+#include "sset.h"
#include "stream-ssl.h"
+#include "stream.h"
#include "unixctl.h"
#include "util.h"
-#include "ofctrl.h"
-#include "binding.h"
-#include "chassis.h"
-#include "encaps.h"
-#include "physical.h"
-#include "lflow.h"
-
VLOG_DEFINE_THIS_MODULE(main);
static unixctl_cb_func ovn_controller_exit;
+static unixctl_cb_func ct_zone_list;
#define DEFAULT_BRIDGE_NAME "br-int"
+#define DEFAULT_PROBE_INTERVAL_MSEC 5000
+static void update_probe_interval(struct controller_ctx *);
static void parse_options(int argc, char *argv[]);
OVS_NO_RETURN static void usage(void);
static char *ovs_remote;
-static const struct ovsrec_bridge *
-get_bridge(struct ovsdb_idl *ovs_idl, const char *br_name)
+struct local_datapath *
+get_local_datapath(const struct hmap *local_datapaths, uint32_t tunnel_key)
{
- const struct ovsrec_bridge *br;
- OVSREC_BRIDGE_FOR_EACH (br, ovs_idl) {
- if (!strcmp(br->name, br_name)) {
- return br;
- }
- }
- return NULL;
+ struct hmap_node *node = hmap_first_with_hash(local_datapaths, tunnel_key);
+ return (node
+ ? CONTAINER_OF(node, struct local_datapath, hmap_node)
+ : NULL);
}
-static const struct ovsrec_bridge *
-get_br_int(struct ovsdb_idl *ovs_idl)
+struct patched_datapath *
+get_patched_datapath(const struct hmap *patched_datapaths, uint32_t tunnel_key)
{
- const struct ovsrec_open_vswitch *cfg = ovsrec_open_vswitch_first(ovs_idl);
- if (!cfg) {
- return NULL;
- }
+ struct hmap_node *node = hmap_first_with_hash(patched_datapaths,
+ tunnel_key);
+ return (node
+ ? CONTAINER_OF(node, struct patched_datapath, hmap_node)
+ : NULL);
+}
- const char *br_int_name = smap_get(&cfg->external_ids, "ovn-bridge");
- if (!br_int_name) {
- br_int_name = DEFAULT_BRIDGE_NAME;
- }
+const struct sbrec_chassis *
+get_chassis(struct ovsdb_idl *ovnsb_idl, const char *chassis_id)
+{
+ const struct sbrec_chassis *chassis_rec;
- const struct ovsrec_bridge *br;
- br = get_bridge(ovs_idl, br_int_name);
- if (br) {
- return br;
+ SBREC_CHASSIS_FOR_EACH(chassis_rec, ovnsb_idl) {
+ if (!strcmp(chassis_rec->name, chassis_id)) {
+ break;
+ }
}
- static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 1);
- VLOG_WARN_RL(&rl, "%s: integration bridge does not exist", br_int_name);
- return NULL;
+ return chassis_rec;
}
-static const char *
-get_chassis_id(const struct ovsdb_idl *ovs_idl)
+uint32_t
+get_tunnel_type(const char *name)
{
- const struct ovsrec_open_vswitch *cfg = ovsrec_open_vswitch_first(ovs_idl);
- return cfg ? smap_get(&cfg->external_ids, "system-id") : NULL;
-}
+ if (!strcmp(name, "geneve")) {
+ return GENEVE;
+ } else if (!strcmp(name, "stt")) {
+ return STT;
+ } else if (!strcmp(name, "vxlan")) {
+ return VXLAN;
+ }
-static char *
-patch_port_name(const struct ovsrec_bridge *b1, const struct ovsrec_bridge *b2)
-{
- return xasprintf("patch-%s-to-%s", b1->name, b2->name);
+ return 0;
}
-/*
- * Return true if the port is a patch port from b1 to b2
- */
-static bool
-match_patch_port(const struct ovsrec_port *port,
- const struct ovsrec_bridge *b1,
- const struct ovsrec_bridge *b2)
+const struct ovsrec_bridge *
+get_bridge(struct ovsdb_idl *ovs_idl, const char *br_name)
{
- struct ovsrec_interface *iface;
- size_t i;
- char *peer_port_name;
- bool res = false;
-
- peer_port_name = patch_port_name(b2, b1);
-
- for (i = 0; i < port->n_interfaces; i++) {
- iface = port->interfaces[i];
- if (strcmp(iface->type, "patch")) {
- continue;
- }
- const char *peer;
- peer = smap_get(&iface->options, "peer");
- if (peer && !strcmp(peer, peer_port_name)) {
- res = true;
- break;
+ const struct ovsrec_bridge *br;
+ OVSREC_BRIDGE_FOR_EACH (br, ovs_idl) {
+ if (!strcmp(br->name, br_name)) {
+ return br;
}
}
-
- free(peer_port_name);
-
- return res;
+ return NULL;
}
-static void
-create_patch_port(struct controller_ctx *ctx,
- const char *network,
- const struct ovsrec_bridge *b1,
- const struct ovsrec_bridge *b2)
+static const struct ovsrec_bridge *
+create_br_int(struct controller_ctx *ctx,
+ const struct ovsrec_open_vswitch *cfg,
+ const char *bridge_name)
{
if (!ctx->ovs_idl_txn) {
- return;
+ return NULL;
}
- char *port_name = patch_port_name(b1, b2);
- char *peer_port_name = patch_port_name(b2, b1);
-
ovsdb_idl_txn_add_comment(ctx->ovs_idl_txn,
- "ovn-controller: creating patch port '%s' from '%s' to '%s'",
- port_name, b1->name, b2->name);
+ "ovn-controller: creating integration bridge '%s'", bridge_name);
struct ovsrec_interface *iface;
iface = ovsrec_interface_insert(ctx->ovs_idl_txn);
- ovsrec_interface_set_name(iface, port_name);
- ovsrec_interface_set_type(iface, "patch");
- struct smap options = SMAP_INITIALIZER(&options);
- smap_add(&options, "peer", peer_port_name);
- ovsrec_interface_set_options(iface, &options);
- smap_destroy(&options);
+ ovsrec_interface_set_name(iface, bridge_name);
+ ovsrec_interface_set_type(iface, "internal");
struct ovsrec_port *port;
port = ovsrec_port_insert(ctx->ovs_idl_txn);
- ovsrec_port_set_name(port, port_name);
+ ovsrec_port_set_name(port, bridge_name);
ovsrec_port_set_interfaces(port, &iface, 1);
- struct smap ext_ids = SMAP_INITIALIZER(&ext_ids);
- smap_add(&ext_ids, "ovn-patch-port", network);
- ovsrec_port_set_external_ids(port, &ext_ids);
- smap_destroy(&ext_ids);
-
- struct ovsrec_port **ports;
- ports = xmalloc(sizeof *ports * (b1->n_ports + 1));
- memcpy(ports, b1->ports, sizeof *ports * b1->n_ports);
- ports[b1->n_ports] = port;
- ovsrec_bridge_verify_ports(b1);
- ovsrec_bridge_set_ports(b1, ports, b1->n_ports + 1);
-
- free(ports);
- free(port_name);
- free(peer_port_name);
-}
-
-static void
-create_patch_ports(struct controller_ctx *ctx,
- const char *network,
- struct shash *existing_ports,
- const struct ovsrec_bridge *b1,
- const struct ovsrec_bridge *b2)
-{
- size_t i;
- for (i = 0; i < b1->n_ports; i++) {
- if (match_patch_port(b1->ports[i], b1, b2)) {
- /* Patch port already exists on b1 */
- shash_find_and_delete(existing_ports, b1->ports[i]->name);
- break;
- }
- }
- if (i == b1->n_ports) {
- create_patch_port(ctx, network, b1, b2);
- }
+ struct ovsrec_bridge *bridge;
+ bridge = ovsrec_bridge_insert(ctx->ovs_idl_txn);
+ ovsrec_bridge_set_name(bridge, bridge_name);
+ ovsrec_bridge_set_fail_mode(bridge, "secure");
+ const struct smap oc = SMAP_CONST1(&oc, "disable-in-band", "true");
+ ovsrec_bridge_set_other_config(bridge, &oc);
+ ovsrec_bridge_set_ports(bridge, &port, 1);
+
+ struct ovsrec_bridge **bridges;
+ size_t bytes = sizeof *bridges * cfg->n_bridges;
+ bridges = xmalloc(bytes + sizeof *bridges);
+ memcpy(bridges, cfg->bridges, bytes);
+ bridges[cfg->n_bridges] = bridge;
+ ovsrec_open_vswitch_verify_bridges(cfg);
+ ovsrec_open_vswitch_set_bridges(cfg, bridges, cfg->n_bridges + 1);
+
+ return bridge;
}
-static void
-init_existing_ports(struct controller_ctx *ctx,
- struct shash *existing_ports)
+static const struct ovsrec_bridge *
+get_br_int(struct controller_ctx *ctx)
{
- const struct ovsrec_port *port;
-
- OVSREC_PORT_FOR_EACH (port, ctx->ovs_idl) {
- if (smap_get(&port->external_ids, "ovn-patch-port")) {
- shash_add(existing_ports, port->name, port);
- }
+ const struct ovsrec_open_vswitch *cfg;
+ cfg = ovsrec_open_vswitch_first(ctx->ovs_idl);
+ if (!cfg) {
+ return NULL;
}
-}
-static void
-remove_port(struct controller_ctx *ctx,
- const struct ovsrec_port *port)
-{
- const struct ovsrec_bridge *bridge;
-
- /* We know the port we want to delete, but we have to find the bridge its on
- * to do so. Note this only runs on a config change that should be pretty
- * rare. */
- OVSREC_BRIDGE_FOR_EACH (bridge, ctx->ovs_idl) {
- size_t i;
- for (i = 0; i < bridge->n_ports; i++) {
- if (bridge->ports[i] != port) {
- continue;
- }
- struct ovsrec_port **new_ports;
- new_ports = xmemdup(bridge->ports,
- sizeof *new_ports * (bridge->n_ports - 1));
- if (i != bridge->n_ports - 1) {
- /* Removed port was not last */
- new_ports[i] = bridge->ports[bridge->n_ports - 1];
- }
- ovsrec_bridge_verify_ports(bridge);
- ovsrec_bridge_set_ports(bridge, new_ports, bridge->n_ports - 1);
- free(new_ports);
- ovsrec_port_delete(port);
- return;
- }
+ const char *br_int_name = smap_get(&cfg->external_ids, "ovn-bridge");
+ if (!br_int_name) {
+ br_int_name = DEFAULT_BRIDGE_NAME;
}
-}
-
-static void
-parse_bridge_mappings(struct controller_ctx *ctx,
- const struct ovsrec_bridge *br_int,
- const char *mappings_cfg)
-{
- struct shash existing_ports = SHASH_INITIALIZER(&existing_ports);
- init_existing_ports(ctx, &existing_ports);
-
- char *cur, *next, *start;
- next = start = xstrdup(mappings_cfg);
- while ((cur = strsep(&next, ",")) && *cur) {
- char *network, *bridge = cur;
- const struct ovsrec_bridge *ovs_bridge;
-
- network = strsep(&bridge, ":");
- if (!bridge || !*network || !*bridge) {
- VLOG_ERR("Invalid ovn-bridge-mappings configuration: '%s'",
- mappings_cfg);
- break;
- }
-
- ovs_bridge = get_bridge(ctx->ovs_idl, bridge);
- if (!ovs_bridge) {
- VLOG_WARN("Bridge '%s' not found for network '%s'",
- bridge, network);
- continue;
- }
- create_patch_ports(ctx, network, &existing_ports, br_int, ovs_bridge);
- create_patch_ports(ctx, network, &existing_ports, ovs_bridge, br_int);
- }
- free(start);
-
- /* Any ports left in existing_ports are related to configuration that has
- * been removed, so we should delete the ports now. */
- struct shash_node *port_node, *port_next_node;
- SHASH_FOR_EACH_SAFE (port_node, port_next_node, &existing_ports) {
- struct ovsrec_port *port = port_node->data;
- shash_delete(&existing_ports, port_node);
- remove_port(ctx, port);
+ const struct ovsrec_bridge *br;
+ br = get_bridge(ctx->ovs_idl, br_int_name);
+ if (!br) {
+ return create_br_int(ctx, cfg, br_int_name);
}
- shash_destroy(&existing_ports);
+ return br;
}
-static void
-init_bridge_mappings(struct controller_ctx *ctx,
- const struct ovsrec_bridge *br_int)
+static const char *
+get_chassis_id(const struct ovsdb_idl *ovs_idl)
{
- const char *mappings_cfg = "";
- const struct ovsrec_open_vswitch *cfg;
+ const struct ovsrec_open_vswitch *cfg = ovsrec_open_vswitch_first(ovs_idl);
+ const char *chassis_id = cfg ? smap_get(&cfg->external_ids, "system-id") : NULL;
- cfg = ovsrec_open_vswitch_first(ctx->ovs_idl);
- if (cfg) {
- mappings_cfg = smap_get(&cfg->external_ids, "ovn-bridge-mappings");
- if (!mappings_cfg) {
- mappings_cfg = "";
- }
+ if (!chassis_id) {
+ static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(5, 1);
+ VLOG_WARN_RL(&rl, "'system-id' in Open_vSwitch database is missing.");
}
- parse_bridge_mappings(ctx, br_int, mappings_cfg);
+
+ return chassis_id;
}
/* Retrieves the OVN Southbound remote location from the
}
}
+static void
+update_ct_zones(struct sset *lports, struct hmap *patched_datapaths,
+ struct simap *ct_zones, unsigned long *ct_zone_bitmap)
+{
+ struct simap_node *ct_zone, *ct_zone_next;
+ int scan_start = 1;
+ struct patched_datapath *pd;
+ const char *user;
+ struct sset all_users = SSET_INITIALIZER(&all_users);
+
+ SSET_FOR_EACH(user, lports) {
+ sset_add(&all_users, user);
+ }
+
+ /* Local patched datapath (gateway routers) need zones assigned. */
+ HMAP_FOR_EACH(pd, hmap_node, patched_datapaths) {
+ if (!pd->local) {
+ continue;
+ }
+
+ char *dnat = alloc_nat_zone_key(pd->key, "dnat");
+ char *snat = alloc_nat_zone_key(pd->key, "snat");
+ sset_add(&all_users, dnat);
+ sset_add(&all_users, snat);
+ free(dnat);
+ free(snat);
+ }
+
+ /* Delete zones that do not exist in above sset. */
+ SIMAP_FOR_EACH_SAFE(ct_zone, ct_zone_next, ct_zones) {
+ if (!sset_contains(&all_users, ct_zone->name)) {
+ bitmap_set0(ct_zone_bitmap, ct_zone->data);
+ simap_delete(ct_zones, ct_zone);
+ }
+ }
+
+ /* xxx This is wasteful to assign a zone to each port--even if no
+ * xxx security policy is applied. */
+
+ /* Assign a unique zone id for each logical port and two zones
+ * to a gateway router. */
+ SSET_FOR_EACH(user, &all_users) {
+ size_t zone;
+
+ if (simap_contains(ct_zones, user)) {
+ continue;
+ }
+
+ /* We assume that there are 64K zones and that we own them all. */
+ zone = bitmap_scan(ct_zone_bitmap, 0, scan_start, MAX_CT_ZONES + 1);
+ if (zone == MAX_CT_ZONES + 1) {
+ static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 1);
+ VLOG_WARN_RL(&rl, "exhausted all ct zones");
+ return;
+ }
+ scan_start = zone + 1;
+
+ bitmap_set1(ct_zone_bitmap, zone);
+ simap_put(ct_zones, user, zone);
+
+ /* xxx We should erase any old entries for this
+ * xxx zone, but we need a generic interface to the conntrack
+ * xxx table. */
+ }
+
+ sset_destroy(&all_users);
+}
+
+static int64_t
+get_nb_cfg(struct ovsdb_idl *idl)
+{
+ const struct sbrec_sb_global *sb = sbrec_sb_global_first(idl);
+ return sb ? sb->nb_cfg : 0;
+}
+
+/* Contains "struct local_datapath" nodes whose hash values are the
+ * tunnel_key of datapaths with at least one local port binding. */
+static struct hmap local_datapaths = HMAP_INITIALIZER(&local_datapaths);
+static struct hmap patched_datapaths = HMAP_INITIALIZER(&patched_datapaths);
+
+static struct lport_index lports;
+static struct mcgroup_index mcgroups;
+
int
main(int argc, char *argv[])
{
parse_options(argc, argv);
fatal_ignore_sigpipe();
- daemonize_start();
+ daemonize_start(false);
retval = unixctl_server_create(NULL, &unixctl);
if (retval) {
}
unixctl_command_register("exit", "", 0, 0, ovn_controller_exit, &exiting);
+ /* Initialize group ids for loadbalancing. */
+ struct group_table group_table;
+ group_table.group_ids = bitmap_allocate(MAX_OVN_GROUPS);
+ bitmap_set1(group_table.group_ids, 0); /* Group id 0 is invalid. */
+ hmap_init(&group_table.desired_groups);
+ hmap_init(&group_table.existing_groups);
+
daemonize_complete();
ovsrec_init();
sbrec_init();
ofctrl_init();
+ pinctrl_init();
lflow_init();
+ lport_index_init(&lports);
+ mcgroup_index_init(&mcgroups);
+
/* Connect to OVS OVSDB instance. We do not monitor all tables by
* default, so modules must register their interest explicitly. */
struct ovsdb_idl_loop ovs_idl_loop = OVSDB_IDL_LOOP_INITIALIZER(
ovsdb_idl_add_table(ovs_idl_loop.idl, &ovsrec_table_open_vswitch);
ovsdb_idl_add_column(ovs_idl_loop.idl,
&ovsrec_open_vswitch_col_external_ids);
+ ovsdb_idl_add_column(ovs_idl_loop.idl, &ovsrec_open_vswitch_col_bridges);
ovsdb_idl_add_table(ovs_idl_loop.idl, &ovsrec_table_interface);
ovsdb_idl_add_column(ovs_idl_loop.idl, &ovsrec_interface_col_name);
ovsdb_idl_add_column(ovs_idl_loop.idl, &ovsrec_interface_col_type);
ovsdb_idl_add_column(ovs_idl_loop.idl, &ovsrec_port_col_external_ids);
ovsdb_idl_add_table(ovs_idl_loop.idl, &ovsrec_table_bridge);
ovsdb_idl_add_column(ovs_idl_loop.idl, &ovsrec_bridge_col_ports);
+ ovsdb_idl_add_column(ovs_idl_loop.idl, &ovsrec_bridge_col_name);
+ ovsdb_idl_add_column(ovs_idl_loop.idl, &ovsrec_bridge_col_fail_mode);
+ ovsdb_idl_add_column(ovs_idl_loop.idl, &ovsrec_bridge_col_other_config);
chassis_register_ovs_idl(ovs_idl_loop.idl);
encaps_register_ovs_idl(ovs_idl_loop.idl);
binding_register_ovs_idl(ovs_idl_loop.idl);
char *ovnsb_remote = get_ovnsb_remote(ovs_idl_loop.idl);
struct ovsdb_idl_loop ovnsb_idl_loop = OVSDB_IDL_LOOP_INITIALIZER(
ovsdb_idl_create(ovnsb_remote, &sbrec_idl_class, true, true));
+ ovsdb_idl_omit_alert(ovnsb_idl_loop.idl, &sbrec_chassis_col_nb_cfg);
+
+ /* Track the southbound idl. */
+ ovsdb_idl_track_add_all(ovnsb_idl_loop.idl);
+
ovsdb_idl_get_initial_snapshot(ovnsb_idl_loop.idl);
+ /* Initialize connection tracking zones. */
+ struct simap ct_zones = SIMAP_INITIALIZER(&ct_zones);
+ unsigned long ct_zone_bitmap[BITMAP_N_LONGS(MAX_CT_ZONES)];
+ memset(ct_zone_bitmap, 0, sizeof ct_zone_bitmap);
+ bitmap_set1(ct_zone_bitmap, 0); /* Zone 0 is reserved. */
+ unixctl_command_register("ct-zone-list", "", 0, 0,
+ ct_zone_list, &ct_zones);
+
/* Main loop. */
exiting = false;
while (!exiting) {
+ /* Check OVN SB database. */
+ char *new_ovnsb_remote = get_ovnsb_remote(ovs_idl_loop.idl);
+ if (strcmp(ovnsb_remote, new_ovnsb_remote)) {
+ free(ovnsb_remote);
+ ovnsb_remote = new_ovnsb_remote;
+ ovsdb_idl_set_remote(ovnsb_idl_loop.idl, ovnsb_remote, true);
+ binding_reset_processing();
+ lport_index_clear(&lports);
+ mcgroup_index_clear(&mcgroups);
+ } else {
+ free(new_ovnsb_remote);
+ }
+
struct controller_ctx ctx = {
.ovs_idl = ovs_idl_loop.idl,
.ovs_idl_txn = ovsdb_idl_loop_run(&ovs_idl_loop),
.ovnsb_idl_txn = ovsdb_idl_loop_run(&ovnsb_idl_loop),
};
- const struct ovsrec_bridge *br_int = get_br_int(ctx.ovs_idl);
- const char *chassis_id = get_chassis_id(ctx.ovs_idl);
+ update_probe_interval(&ctx);
- /* Map bridges to local nets from ovn-bridge-mappings */
- if (br_int) {
- init_bridge_mappings(&ctx, br_int);
- }
+ struct sset all_lports = SSET_INITIALIZER(&all_lports);
+
+ const struct ovsrec_bridge *br_int = get_br_int(&ctx);
+ const char *chassis_id = get_chassis_id(ctx.ovs_idl);
+ const struct sbrec_chassis *chassis = NULL;
if (chassis_id) {
- chassis_run(&ctx, chassis_id);
+ chassis = chassis_run(&ctx, chassis_id);
encaps_run(&ctx, br_int, chassis_id);
- binding_run(&ctx, br_int, chassis_id);
+ binding_run(&ctx, br_int, chassis_id, &local_datapaths);
}
- if (br_int) {
+ if (br_int && chassis_id) {
+ patch_run(&ctx, br_int, chassis_id, &local_datapaths,
+ &patched_datapaths);
+
+ lport_index_fill(&lports, ctx.ovnsb_idl);
+ mcgroup_index_fill(&mcgroups, ctx.ovnsb_idl);
+
enum mf_field_id mff_ovn_geneve = ofctrl_run(br_int);
- struct hmap flow_table = HMAP_INITIALIZER(&flow_table);
- lflow_run(&ctx, &flow_table);
- if (chassis_id) {
- physical_run(&ctx, mff_ovn_geneve,
- br_int, chassis_id, &flow_table);
+ pinctrl_run(&ctx, &lports, br_int, chassis_id, &local_datapaths);
+ update_ct_zones(&all_lports, &patched_datapaths, &ct_zones,
+ ct_zone_bitmap);
+
+ lflow_run(&ctx, &lports, &mcgroups, &local_datapaths,
+ &patched_datapaths, &group_table, &ct_zones);
+
+ physical_run(&ctx, mff_ovn_geneve,
+ br_int, chassis_id, &ct_zones,
+ &local_datapaths, &patched_datapaths);
+
+ ofctrl_put(&group_table, get_nb_cfg(ctx.ovnsb_idl));
+ if (ctx.ovnsb_idl_txn) {
+ int64_t cur_cfg = ofctrl_get_cur_cfg();
+ if (cur_cfg && cur_cfg != chassis->nb_cfg) {
+ sbrec_chassis_set_nb_cfg(chassis, cur_cfg);
+ }
}
- ofctrl_put(&flow_table);
- hmap_destroy(&flow_table);
}
+ sset_destroy(&all_lports);
+
unixctl_server_run(unixctl);
unixctl_server_wait(unixctl);
poll_immediate_wake();
}
- ovsdb_idl_loop_commit_and_wait(&ovnsb_idl_loop);
- ovsdb_idl_loop_commit_and_wait(&ovs_idl_loop);
-
if (br_int) {
ofctrl_wait();
+ pinctrl_wait(&ctx);
}
+ ovsdb_idl_loop_commit_and_wait(&ovnsb_idl_loop);
+ ovsdb_idl_loop_commit_and_wait(&ovs_idl_loop);
+ ovsdb_idl_track_clear(ovnsb_idl_loop.idl);
poll_block();
if (should_service_stop()) {
exiting = true;
.ovnsb_idl_txn = ovsdb_idl_loop_run(&ovnsb_idl_loop),
};
- const struct ovsrec_bridge *br_int = get_br_int(ctx.ovs_idl);
+ const struct ovsrec_bridge *br_int = get_br_int(&ctx);
const char *chassis_id = get_chassis_id(ctx.ovs_idl);
/* Run all of the cleanup functions, even if one of them returns false.
unixctl_server_destroy(unixctl);
lflow_destroy();
ofctrl_destroy();
+ pinctrl_destroy();
+
+ simap_destroy(&ct_zones);
+
+ bitmap_free(group_table.group_ids);
+ hmap_destroy(&group_table.desired_groups);
+
+ struct group_info *installed, *next_group;
+ HMAP_FOR_EACH_SAFE(installed, next_group, hmap_node,
+ &group_table.existing_groups) {
+ hmap_remove(&group_table.existing_groups, &installed->hmap_node);
+ ds_destroy(&installed->group);
+ free(installed);
+ }
+ hmap_destroy(&group_table.existing_groups);
ovsdb_idl_loop_destroy(&ovs_idl_loop);
ovsdb_idl_loop_destroy(&ovnsb_idl_loop);
unixctl_command_reply(conn, NULL);
}
+
+static void
+ct_zone_list(struct unixctl_conn *conn, int argc OVS_UNUSED,
+ const char *argv[] OVS_UNUSED, void *ct_zones_)
+{
+ struct simap *ct_zones = ct_zones_;
+ struct ds ds = DS_EMPTY_INITIALIZER;
+ struct simap_node *zone;
+
+ SIMAP_FOR_EACH(zone, ct_zones) {
+ ds_put_format(&ds, "%s %d\n", zone->name, zone->data);
+ }
+
+ unixctl_command_reply(conn, ds_cstr(&ds));
+ ds_destroy(&ds);
+}
+
+/* Get the desired SB probe timer from the OVS database and configure it into
+ * the SB database. */
+static void
+update_probe_interval(struct controller_ctx *ctx)
+{
+ const struct ovsrec_open_vswitch *cfg
+ = ovsrec_open_vswitch_first(ctx->ovs_idl);
+ int interval = (cfg
+ ? smap_get_int(&cfg->external_ids,
+ "ovn-remote-probe-interval",
+ DEFAULT_PROBE_INTERVAL_MSEC)
+ : DEFAULT_PROBE_INTERVAL_MSEC);
+ ovsdb_idl_set_probe_interval(ctx->ovnsb_idl, interval);
+}