X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=utilities%2Fovs-vsctl.c;h=f3bb88e2c3f91d25cd62a3c68286f0976c35b0ad;hb=4d12270a618bead742d4cabc50601e86fde83f64;hp=81ef95c4caac948d803408502b3ba1a1f6f8228c;hpb=0c3dd1e1a1c34fedad24b8ff82c0b2a0d3e48904;p=openvswitch

diff --git a/utilities/ovs-vsctl.c b/utilities/ovs-vsctl.c
index 81ef95c4..f3bb88e2 100644
--- a/utilities/ovs-vsctl.c
+++ b/utilities/ovs-vsctl.c
@@ -29,6 +29,7 @@
 #include "compiler.h"
 #include "dirs.h"
 #include "dynamic-string.h"
+#include "json.h"
 #include "ovsdb-idl.h"
 #include "poll-loop.h"
 #include "svec.h"
@@ -45,6 +46,16 @@ static const char *db;
 /* --oneline: Write each command's output as a single line? */
 static bool oneline;
 
+/* --dry-run: Do not commit any changes. */
+static bool dry_run;
+
+/* --no-wait: Wait for ovs-vswitchd to reload its configuration? */
+static bool wait_for_reload = true;
+
+/* --timeout: Time to wait for a connection to 'db'. */
+static int timeout = 5;
+
+static void vsctl_fatal(const char *, ...) PRINTF_FORMAT(1, 2) NO_RETURN;
 static char *default_db(void);
 static void usage(void) NO_RETURN;
 static void parse_options(int argc, char *argv[]);
@@ -70,6 +81,10 @@ main(int argc, char *argv[])
     vlog_set_levels(VLM_reconnect, VLF_ANY_FACILITY, VLL_WARN);
     parse_options(argc, argv);
 
+    if (timeout) {
+        time_alarm(timeout);
+    }
+
     /* Log our arguments.  This is often valuable for debugging systems. */
     ds_init(&args);
     for (i = 1; i < argc; i++) {
@@ -90,10 +105,10 @@ main(int argc, char *argv[])
         }
     }
     if (!n_commands) {
-        ovs_fatal(0, "missing command name (use --help for help)");
+        vsctl_fatal("missing command name (use --help for help)");
     }
 
-    /* Now execut the commands. */
+    /* Now execute the commands. */
     idl = ovsdb_idl_create(db, &ovsrec_idl_class);
     seqno = ovsdb_idl_get_seqno(idl);
     trials = 0;
@@ -104,7 +119,7 @@ main(int argc, char *argv[])
         new_seqno = ovsdb_idl_get_seqno(idl);
         if (new_seqno != seqno) {
             if (++trials > 5) {
-                ovs_fatal(0, "too many database inconsistency failures");
+                vsctl_fatal("too many database inconsistency failures");
             }
             do_vsctl(argc - optind, argv + optind, idl);
             seqno = new_seqno;
@@ -115,6 +130,21 @@ main(int argc, char *argv[])
     }
 }
 
+static void
+vsctl_fatal(const char *format, ...)
+{
+    char *message;
+    va_list args;
+
+    va_start(args, format);
+    message = xvasprintf(format, args);
+    va_end(args);
+
+    vlog_set_levels(VLM_vsctl, VLF_CONSOLE, VLL_EMER);
+    VLOG_ERR("%s", message);
+    ovs_fatal(0, "%s", message);
+}
+
 static void
 parse_options(int argc, char *argv[])
 {
@@ -122,23 +152,28 @@ parse_options(int argc, char *argv[])
         OPT_DB = UCHAR_MAX + 1,
         OPT_ONELINE,
         OPT_NO_SYSLOG,
-        OPT_NO_WAIT
+        OPT_NO_WAIT,
+        OPT_DRY_RUN,
+        VLOG_OPTION_ENUMS
     };
     static struct option long_options[] = {
         {"db", required_argument, 0, OPT_DB},
         {"no-syslog", no_argument, 0, OPT_NO_SYSLOG},
         {"no-wait", no_argument, 0, OPT_NO_WAIT},
+        {"dry-run", no_argument, 0, OPT_DRY_RUN},
         {"oneline", no_argument, 0, OPT_ONELINE},
-        {"verbose", optional_argument, 0, 'v'},
+        {"timeout", required_argument, 0, 't'},
         {"help", no_argument, 0, 'h'},
         {"version", no_argument, 0, 'V'},
+        VLOG_LONG_OPTIONS,
         {0, 0, 0, 0},
     };
 
+
     for (;;) {
         int c;
 
-        c = getopt_long(argc, argv, "+v::hV", long_options, NULL);
+        c = getopt_long(argc, argv, "+v::hVt:", long_options, NULL);
         if (c == -1) {
             break;
         }
@@ -157,7 +192,11 @@ parse_options(int argc, char *argv[])
             break;
 
         case OPT_NO_WAIT:
-            /* XXX not yet implemented */
+            wait_for_reload = false;
+            break;
+
+        case OPT_DRY_RUN:
+            dry_run = true;
             break;
 
         case 'h':
@@ -167,10 +206,16 @@ parse_options(int argc, char *argv[])
             OVS_PRINT_VERSION(0, 0);
             exit(EXIT_SUCCESS);
 
-        case 'v':
-            vlog_set_verbosity(optarg);
+        case 't':
+            timeout = strtoul(optarg, NULL, 10);
+            if (timeout < 0) {
+                ovs_fatal(0, "value %s on -t or --timeout is invalid",
+                          optarg);
+            }
             break;
 
+        VLOG_OPTION_HANDLERS
+
         case '?':
             exit(EXIT_FAILURE);
 
@@ -249,6 +294,28 @@ usage(void)
            "  iface-get-external-id IFACE"
            "  list key-value pairs on IFACE\n"
         );
+    printf("\nController commands:\n"
+           "  get-controller [BRIDGE]     "
+           "print the controller for BRIDGE\n"
+           "  del-controller [BRIDGE]     "
+           "delete the controller for BRIDGE\n"
+           "  set-controller [BRIDGE] TARGET  "
+           "set the controller for BRIDGE to TARGET\n"
+           "  get-fail-mode [BRIDGE]     "
+           "print the fail-mode for BRIDGE\n"
+           "  del-fail-mode [BRIDGE]     "
+           "delete the fail-mode for BRIDGE\n"
+           "  set-fail-mode [BRIDGE] MODE  "
+           "set the fail-mode for BRIDGE to MODE\n"
+        );
+    printf("\nSSL commands:\n"
+           "  get-ssl              "
+           "print the SSL configuration\n"
+           "  del-ssl              "
+           "delete the SSL configuration\n"
+           "  set-ssl PRIV-KEY CERT CA-CERT  "
+           "set the SSL configuration\n"
+        );
     printf("\nOptions:\n"
            "  --db=DATABASE               "
            "connect to DATABASE\n"
@@ -287,6 +354,7 @@ struct vsctl_context {
 struct vsctl_bridge {
     struct ovsrec_bridge *br_cfg;
     char *name;
+    struct ovsrec_controller *ctrl;
     struct vsctl_bridge *parent;
     int vlan;
 };
@@ -305,6 +373,7 @@ struct vsctl_info {
     struct shash bridges;
     struct shash ports;
     struct shash ifaces;
+    struct ovsrec_controller *ctrl;
 };
 
 static struct ovsdb_idl_txn *
@@ -323,6 +392,7 @@ add_bridge(struct vsctl_info *b,
     br->name = xstrdup(name);
     br->parent = parent;
     br->vlan = vlan;
+    br->ctrl = parent ? parent->br_cfg->controller : br_cfg->controller;
     shash_add(&b->bridges, br->name, br);
     return br;
 }
@@ -386,6 +456,8 @@ get_info(const struct ovsrec_open_vswitch *ovs, struct vsctl_info *info)
     shash_init(&info->ports);
     shash_init(&info->ifaces);
 
+    info->ctrl = ovs->controller;
+
     shash_init(&bridges);
     shash_init(&ports);
     for (i = 0; i < ovs->n_bridges; i++) {
@@ -488,19 +560,20 @@ check_conflicts(struct vsctl_info *info, const char *name,
     struct vsctl_port *port;
 
     if (shash_find(&info->bridges, name)) {
-        ovs_fatal(0, "%s because a bridge named %s already exists", msg, name);
+        vsctl_fatal("%s because a bridge named %s already exists",
+                    msg, name);
     }
 
     port = shash_find_data(&info->ports, name);
     if (port) {
-        ovs_fatal(0, "%s because a port named %s already exists on bridge %s",
-                  msg, name, port->bridge->name);
+        vsctl_fatal("%s because a port named %s already exists on "
+                    "bridge %s", msg, name, port->bridge->name);
     }
 
     iface = shash_find_data(&info->ifaces, name);
     if (iface) {
-        ovs_fatal(0, "%s because an interface named %s already exists "
-                  "on bridge %s", msg, name, iface->port->bridge->name);
+        vsctl_fatal("%s because an interface named %s already exists "
+                    "on bridge %s", msg, name, iface->port->bridge->name);
     }
 
     free(msg);
@@ -511,7 +584,17 @@ find_bridge(struct vsctl_info *info, const char *name, bool must_exist)
 {
     struct vsctl_bridge *br = shash_find_data(&info->bridges, name);
     if (must_exist && !br) {
-        ovs_fatal(0, "no bridge named %s", name);
+        vsctl_fatal("no bridge named %s", name);
+    }
+    return br;
+}
+
+static struct vsctl_bridge *
+find_real_bridge(struct vsctl_info *info, const char *name, bool must_exist)
+{
+    struct vsctl_bridge *br = find_bridge(info, name, must_exist);
+    if (br && br->parent) {
+        vsctl_fatal("%s is a fake bridge", name);
     }
     return br;
 }
@@ -524,7 +607,7 @@ find_port(struct vsctl_info *info, const char *name, bool must_exist)
         port = NULL;
     }
     if (must_exist && !port) {
-        ovs_fatal(0, "no port named %s", name);
+        vsctl_fatal("no port named %s", name);
     }
     return port;
 }
@@ -537,7 +620,7 @@ find_iface(struct vsctl_info *info, const char *name, bool must_exist)
         iface = NULL;
     }
     if (must_exist && !iface) {
-        ovs_fatal(0, "no interface named %s", name);
+        vsctl_fatal("no interface named %s", name);
     }
     return iface;
 }
@@ -606,6 +689,11 @@ ovs_delete_bridge(const struct ovsrec_open_vswitch *ovs,
     free(bridges);
 }
 
+static void
+cmd_init(struct vsctl_context *ctx UNUSED)
+{
+}
+
 static void
 cmd_add_br(struct vsctl_context *ctx)
 {
@@ -634,7 +722,8 @@ cmd_add_br(struct vsctl_context *ctx)
 
         ovs_insert_bridge(ctx->ovs, br);
     } else if (ctx->argc == 3) {
-        ovs_fatal(0, "'%s' comamnd takes exactly 1 or 3 arguments", ctx->argv[0]);
+        vsctl_fatal("'%s' command takes exactly 1 or 3 arguments",
+                    ctx->argv[0]);
     } else if (ctx->argc == 4) {
         const char *parent_name = ctx->argv[2];
         int vlan = atoi(ctx->argv[3]);
@@ -645,15 +734,15 @@ cmd_add_br(struct vsctl_context *ctx)
         int64_t tag = vlan;
 
         if (vlan < 1 || vlan > 4095) {
-            ovs_fatal(0, "%s: vlan must be between 1 and 4095", ctx->argv[0]);
+            vsctl_fatal("%s: vlan must be between 1 and 4095", ctx->argv[0]);
         }
 
         parent = find_bridge(&info, parent_name, false);
         if (parent && parent->vlan) {
-            ovs_fatal(0, "cannot create brdige with fake bridge as parent");
+            vsctl_fatal("cannot create bridge with fake bridge as parent");
         }
         if (!parent) {
-            ovs_fatal(0, "parent bridge %s does not exist", parent_name);
+            vsctl_fatal("parent bridge %s does not exist", parent_name);
         }
         br = parent->br_cfg;
 
@@ -912,7 +1001,7 @@ cmd_list_ports(struct vsctl_context *ctx)
 
 static void
 add_port(const struct ovsrec_open_vswitch *ovs,
-         const char *br_name, const char *port_name,
+         const char *br_name, const char *port_name, bool fake_iface,
          char *iface_names[], int n_ifaces)
 {
     struct vsctl_info info;
@@ -936,6 +1025,7 @@ add_port(const struct ovsrec_open_vswitch *ovs,
     port = ovsrec_port_insert(txn_from_openvswitch(ovs));
     ovsrec_port_set_name(port, port_name);
     ovsrec_port_set_interfaces(port, ifaces, n_ifaces);
+    ovsrec_port_set_bond_fake_iface(port, fake_iface);
     free(ifaces);
 
     if (bridge->vlan) {
@@ -952,13 +1042,16 @@ add_port(const struct ovsrec_open_vswitch *ovs,
 static void
 cmd_add_port(struct vsctl_context *ctx)
 {
-    add_port(ctx->ovs, ctx->argv[1], ctx->argv[2], &ctx->argv[2], 1);
+    add_port(ctx->ovs, ctx->argv[1], ctx->argv[2], false, &ctx->argv[2], 1);
 }
 
 static void
 cmd_add_bond(struct vsctl_context *ctx)
 {
-    add_port(ctx->ovs, ctx->argv[1], ctx->argv[2], &ctx->argv[3], ctx->argc - 3);
+    bool fake_iface = shash_find(&ctx->options, "--fake-iface");
+
+    add_port(ctx->ovs, ctx->argv[1], ctx->argv[2], fake_iface,
+             &ctx->argv[3], ctx->argc - 3);
 }
 
 static void
@@ -981,12 +1074,12 @@ cmd_del_port(struct vsctl_context *ctx)
             if (port->bridge == bridge) {
                 del_port(&info, port);
             } else if (port->bridge->parent == bridge) {
-                ovs_fatal(0, "bridge %s does not have a port %s (although its "
-                          "parent bridge %s does)",
-                          ctx->argv[1], ctx->argv[2], bridge->parent->name);
+                vsctl_fatal("bridge %s does not have a port %s (although its "
+                            "parent bridge %s does)",
+                            ctx->argv[1], ctx->argv[2], bridge->parent->name);
             } else {
-                ovs_fatal(0, "bridge %s does not have a port %s",
-                          ctx->argv[1], ctx->argv[2]);
+                vsctl_fatal("bridge %s does not have a port %s",
+                            ctx->argv[1], ctx->argv[2]);
             }
         }
     }
@@ -1143,6 +1236,222 @@ cmd_iface_get_external_id(struct vsctl_context *ctx)
                     "",  ctx->argc >= 3 ? ctx->argv[2] : NULL, &ctx->output);
     free_info(&info);
 }
+
+static void
+cmd_get_controller(struct vsctl_context *ctx)
+{
+    struct vsctl_info info;
+
+    get_info(ctx->ovs, &info);
+
+    if (ctx->argc == 1) {
+        /* Return the controller from the "Open_vSwitch" table */
+        if (info.ctrl) {
+            ds_put_format(&ctx->output, "%s\n", info.ctrl->target);
+        }
+    } else {
+        /* Return the controller for a particular bridge. */
+        struct vsctl_bridge *br = find_bridge(&info, ctx->argv[1], true);
+
+        /* If no controller is explicitly defined for the requested
+         * bridge, fallback to the "Open_vSwitch" table's controller. */
+        if (br->ctrl) {
+            ds_put_format(&ctx->output, "%s\n", br->ctrl->target);
+        } else if (info.ctrl) {
+            ds_put_format(&ctx->output, "%s\n", info.ctrl->target);
+        }
+    }
+
+    free_info(&info);
+}
+
+static void
+cmd_del_controller(struct vsctl_context *ctx)
+{
+    struct vsctl_info info;
+
+    get_info(ctx->ovs, &info);
+
+    if (ctx->argc == 1) {
+        if (info.ctrl) {
+            ovsrec_controller_delete(info.ctrl);
+            ovsrec_open_vswitch_set_controller(ctx->ovs, NULL);
+        }
+    } else {
+        struct vsctl_bridge *br = find_real_bridge(&info, ctx->argv[1], true);
+
+        if (br->ctrl) {
+            ovsrec_controller_delete(br->ctrl);
+            ovsrec_bridge_set_controller(br->br_cfg, NULL);
+        }
+    }
+
+    free_info(&info);
+}
+
+static void
+cmd_set_controller(struct vsctl_context *ctx)
+{
+    struct vsctl_info info;
+    struct ovsrec_controller *ctrl;
+
+    get_info(ctx->ovs, &info);
+
+    if (ctx->argc == 2) {
+        /* Set the controller in the "Open_vSwitch" table. */
+        if (info.ctrl) {
+            ovsrec_controller_delete(info.ctrl);
+        }
+        ctrl = ovsrec_controller_insert(txn_from_openvswitch(ctx->ovs));
+        ovsrec_controller_set_target(ctrl, ctx->argv[1]);
+        ovsrec_open_vswitch_set_controller(ctx->ovs, ctrl);
+    } else {
+        /* Set the controller for a particular bridge. */
+        struct vsctl_bridge *br = find_real_bridge(&info, ctx->argv[1], true);
+
+        if (br->ctrl) {
+            ovsrec_controller_delete(br->ctrl);
+        }
+        ctrl = ovsrec_controller_insert(txn_from_openvswitch(ctx->ovs));
+        ovsrec_controller_set_target(ctrl, ctx->argv[2]);
+        ovsrec_bridge_set_controller(br->br_cfg, ctrl);
+    }
+
+    free_info(&info);
+}
+
+static void
+cmd_get_fail_mode(struct vsctl_context *ctx)
+{
+    struct vsctl_info info;
+    const char *fail_mode = NULL;
+
+    get_info(ctx->ovs, &info);
+
+    if (ctx->argc == 1) {
+        /* Return the fail-mode from the "Open_vSwitch" table */
+        if (info.ctrl && info.ctrl->fail_mode) {
+            fail_mode = info.ctrl->fail_mode;
+        }
+    } else {
+        /* Return the fail-mode for a particular bridge. */
+        struct vsctl_bridge *br = find_bridge(&info, ctx->argv[1], true);
+
+        /* If no controller or fail-mode is explicitly defined for the 
+         * requested bridge, fallback to the "Open_vSwitch" table's 
+         * setting. */
+        if (br->ctrl && br->ctrl->fail_mode) {
+            fail_mode = br->ctrl->fail_mode;
+        } else if (info.ctrl && info.ctrl->fail_mode) {
+            fail_mode = info.ctrl->fail_mode;
+        }
+    }
+
+    if (fail_mode && strlen(fail_mode)) {
+        ds_put_format(&ctx->output, "%s\n", fail_mode);
+    }
+
+    free_info(&info);
+}
+
+static void
+cmd_del_fail_mode(struct vsctl_context *ctx)
+{
+    struct vsctl_info info;
+
+    get_info(ctx->ovs, &info);
+
+    if (ctx->argc == 1) {
+        if (info.ctrl && info.ctrl->fail_mode) {
+            ovsrec_controller_set_fail_mode(info.ctrl, NULL);
+        }
+    } else {
+        struct vsctl_bridge *br = find_real_bridge(&info, ctx->argv[1], true);
+
+        if (br->ctrl && br->ctrl->fail_mode) {
+            ovsrec_controller_set_fail_mode(br->ctrl, NULL);
+        }
+    }
+
+    free_info(&info);
+}
+
+static void
+cmd_set_fail_mode(struct vsctl_context *ctx)
+{
+    struct vsctl_info info;
+    const char *fail_mode;
+
+    get_info(ctx->ovs, &info);
+
+    fail_mode = (ctx->argc == 2) ? ctx->argv[1] : ctx->argv[2];
+
+    if (strcmp(fail_mode, "standalone") && strcmp(fail_mode, "secure")) {
+        vsctl_fatal("fail-mode must be \"standalone\" or \"secure\"");
+    }
+
+    if (ctx->argc == 2) {
+        /* Set the fail-mode in the "Open_vSwitch" table. */
+        if (!info.ctrl) {
+            vsctl_fatal("no controller declared");
+        }
+        ovsrec_controller_set_fail_mode(info.ctrl, fail_mode);
+    } else {
+        struct vsctl_bridge *br = find_real_bridge(&info, ctx->argv[1], true);
+
+        if (!br->ctrl) {
+            vsctl_fatal("no controller declared for %s", br->name);
+        }
+        ovsrec_controller_set_fail_mode(br->ctrl, fail_mode);
+    }
+
+    free_info(&info);
+}
+
+static void
+cmd_get_ssl(struct vsctl_context *ctx)
+{
+    struct ovsrec_ssl *ssl = ctx->ovs->ssl;
+
+    if (ssl) {
+        ds_put_format(&ctx->output, "Private key: %s\n", ssl->private_key);
+        ds_put_format(&ctx->output, "Certificate: %s\n", ssl->certificate);
+        ds_put_format(&ctx->output, "CA Certificate: %s\n", ssl->ca_cert);
+        ds_put_format(&ctx->output, "Bootstrap: %s\n",
+                ssl->bootstrap_ca_cert ? "true" : "false");
+    }
+}
+
+static void
+cmd_del_ssl(struct vsctl_context *ctx)
+{
+    struct ovsrec_ssl *ssl = ctx->ovs->ssl;
+
+    if (ssl) {
+        ovsrec_ssl_delete(ssl);
+        ovsrec_open_vswitch_set_ssl(ctx->ovs, NULL);
+    }
+}
+
+static void
+cmd_set_ssl(struct vsctl_context *ctx)
+{
+    bool bootstrap = shash_find(&ctx->options, "--bootstrap");
+    struct ovsrec_ssl *ssl = ctx->ovs->ssl;
+
+    if (ssl) {
+        ovsrec_ssl_delete(ssl);
+    }
+    ssl = ovsrec_ssl_insert(txn_from_openvswitch(ctx->ovs));
+
+    ovsrec_ssl_set_private_key(ssl, ctx->argv[1]);
+    ovsrec_ssl_set_certificate(ssl, ctx->argv[2]);
+    ovsrec_ssl_set_ca_cert(ssl, ctx->argv[3]);
+
+    ovsrec_ssl_set_bootstrap_ca_cert(ssl, bootstrap);
+
+    ovsrec_open_vswitch_set_ssl(ctx->ovs, ssl);
+}
 
 typedef void vsctl_handler_func(struct vsctl_context *);
 
@@ -1158,25 +1467,57 @@ static void run_vsctl_command(int argc, char *argv[],
                               const struct ovsrec_open_vswitch *ovs,
                               struct ds *output);
 
+static struct json *
+where_uuid_equals(const struct uuid *uuid)
+{
+    return
+        json_array_create_1(
+            json_array_create_3(
+                json_string_create("_uuid"),
+                json_string_create("=="),
+                json_array_create_2(
+                    json_string_create("uuid"),
+                    json_string_create_nocopy(
+                        xasprintf(UUID_FMT, UUID_ARGS(uuid))))));
+}
+
 static void
 do_vsctl(int argc, char *argv[], struct ovsdb_idl *idl)
 {
     struct ovsdb_idl_txn *txn;
     const struct ovsrec_open_vswitch *ovs;
     enum ovsdb_idl_txn_status status;
-    struct ds *output;
+    struct ds comment, *output;
+    int64_t next_cfg;
     int n_output;
     int i, start;
 
+    txn = ovsdb_idl_txn_create(idl);
+    if (dry_run) {
+        ovsdb_idl_txn_set_dry_run(txn);
+    }
+
+    ds_init(&comment);
+    ds_put_cstr(&comment, "ovs-vsctl:");
+    for (i = 0; i < argc; i++) {
+        ds_put_format(&comment, " %s", argv[i]);
+    }
+    ovsdb_idl_txn_add_comment(txn, ds_cstr(&comment));
+    ds_destroy(&comment);
+
     ovs = ovsrec_open_vswitch_first(idl);
     if (!ovs) {
-        /* XXX it would be more user-friendly to create a record ourselves
-         * (while verifying that the table is empty before doing so). */
-        ovs_fatal(0, "%s: database does not contain any Open vSwitch "
-                  "configuration", db);
+        /* XXX add verification that table is empty */
+        ovs = ovsrec_open_vswitch_insert(txn);
+    }
+
+    if (wait_for_reload) {
+        struct json *where = where_uuid_equals(&ovs->header_.uuid);
+        ovsdb_idl_txn_increment(txn, "Open_vSwitch", "next_cfg",
+                                where);
+        json_destroy(where);
     }
 
-    txn = ovsdb_idl_txn_create(idl);
     output = xmalloc(argc * sizeof *output);
     n_output = 0;
     for (start = i = 0; i <= argc; i++) {
@@ -1196,6 +1537,9 @@ do_vsctl(int argc, char *argv[], struct ovsdb_idl *idl)
         ovsdb_idl_txn_wait(txn);
         poll_block();
     }
+    if (wait_for_reload && status == TXN_SUCCESS) {
+        next_cfg = ovsdb_idl_txn_get_increment_new_value(txn);
+    }
     ovsdb_idl_txn_destroy(txn);
 
     switch (status) {
@@ -1204,8 +1548,9 @@ do_vsctl(int argc, char *argv[], struct ovsdb_idl *idl)
 
     case TXN_ABORTED:
         /* Should not happen--we never call ovsdb_idl_txn_abort(). */
-        ovs_fatal(0, "transaction aborted");
+        vsctl_fatal("transaction aborted");
 
+    case TXN_UNCHANGED:
     case TXN_SUCCESS:
         break;
 
@@ -1216,7 +1561,7 @@ do_vsctl(int argc, char *argv[], struct ovsdb_idl *idl)
         return;
 
     case TXN_ERROR:
-        ovs_fatal(0, "transaction error");
+        vsctl_fatal("transaction error");
 
     default:
         NOT_REACHED();
@@ -1248,6 +1593,23 @@ do_vsctl(int argc, char *argv[], struct ovsdb_idl *idl)
             fputs(ds_cstr(ds), stdout);
         }
     }
+
+    if (wait_for_reload && status != TXN_UNCHANGED) {
+        for (;;) {
+            const struct ovsrec_open_vswitch *ovs;
+
+            ovsdb_idl_run(idl);
+            OVSREC_OPEN_VSWITCH_FOR_EACH (ovs, idl) {
+                if (ovs->cur_cfg >= next_cfg) {
+                    goto done;
+                }
+            }
+            ovsdb_idl_wait(idl);
+            poll_block();
+        }
+    done: ;
+    }
+
     exit(EXIT_SUCCESS);
 }
 
@@ -1255,6 +1617,9 @@ static vsctl_handler_func *
 get_vsctl_handler(int argc, char *argv[], struct vsctl_context *ctx)
 {
     static const struct vsctl_command all_commands[] = {
+        /* Open vSwitch commands. */
+        {"init", 0, 0, cmd_init, ""},
+
         /* Bridge commands. */
         {"add-br", 1, 3, cmd_add_br, ""},
         {"del-br", 1, 1, cmd_del_br, "--if-exists"},
@@ -1268,7 +1633,7 @@ get_vsctl_handler(int argc, char *argv[], struct vsctl_context *ctx)
         /* Port commands. */
         {"list-ports", 1, 1, cmd_list_ports, ""},
         {"add-port", 2, 2, cmd_add_port, ""},
-        {"add-bond", 4, INT_MAX, cmd_add_bond, ""},
+        {"add-bond", 4, INT_MAX, cmd_add_bond, "--fake-iface"},
         {"del-port", 1, 2, cmd_del_port, "--if-exists"},
         {"port-to-br", 1, 1, cmd_port_to_br, ""},
         {"port-set-external-id", 2, 3, cmd_port_set_external_id, ""},
@@ -1279,6 +1644,19 @@ get_vsctl_handler(int argc, char *argv[], struct vsctl_context *ctx)
         {"iface-to-br", 1, 1, cmd_iface_to_br, ""},
         {"iface-set-external-id", 2, 3, cmd_iface_set_external_id, ""},
         {"iface-get-external-id", 1, 2, cmd_iface_get_external_id, ""},
+
+        /* Controller commands. */
+        {"get-controller", 0, 1, cmd_get_controller, ""},
+        {"del-controller", 0, 1, cmd_del_controller, ""},
+        {"set-controller", 1, 2, cmd_set_controller, ""},
+        {"get-fail-mode", 0, 1, cmd_get_fail_mode, ""},
+        {"del-fail-mode", 0, 1, cmd_del_fail_mode, ""},
+        {"set-fail-mode", 1, 2, cmd_set_fail_mode, ""},
+
+        /* SSL commands. */
+        {"get-ssl", 0, 0, cmd_get_ssl, ""},
+        {"del-ssl", 0, 0, cmd_del_ssl, ""},
+        {"set-ssl", 3, 3, cmd_set_ssl, "--bootstrap"},
     };
 
     const struct vsctl_command *p;
@@ -1290,11 +1668,11 @@ get_vsctl_handler(int argc, char *argv[], struct vsctl_context *ctx)
             break;
         }
         if (!shash_add_once(&ctx->options, argv[i], NULL)) {
-            ovs_fatal(0, "'%s' option specified multiple times", argv[i]);
+            vsctl_fatal("'%s' option specified multiple times", argv[i]);
         }
     }
     if (i == argc) {
-        ovs_fatal(0, "missing command name");
+        vsctl_fatal("missing command name");
     }
 
     for (p = all_commands; p < &all_commands[ARRAY_SIZE(all_commands)]; p++) {
@@ -1306,18 +1684,18 @@ get_vsctl_handler(int argc, char *argv[], struct vsctl_context *ctx)
                 const char *s = strstr(p->options, node->name);
                 int end = s ? s[strlen(node->name)] : EOF;
                 if (end != ',' && end != ' ' && end != '\0') {
-                    ovs_fatal(0, "'%s' command has no '%s' option",
-                              argv[i], node->name);
+                    vsctl_fatal("'%s' command has no '%s' option",
+                                argv[i], node->name);
                 }
             }
 
             n_arg = argc - i - 1;
             if (n_arg < p->min_args) {
-                ovs_fatal(0, "'%s' command requires at least %d arguments",
-                          p->name, p->min_args);
+                vsctl_fatal("'%s' command requires at least %d arguments",
+                            p->name, p->min_args);
             } else if (n_arg > p->max_args) {
-                ovs_fatal(0, "'%s' command takes at most %d arguments",
-                          p->name, p->max_args);
+                vsctl_fatal("'%s' command takes at most %d arguments",
+                            p->name, p->max_args);
             } else {
                 ctx->argc = n_arg + 1;
                 ctx->argv = &argv[i];
@@ -1326,7 +1704,7 @@ get_vsctl_handler(int argc, char *argv[], struct vsctl_context *ctx)
         }
     }
 
-    ovs_fatal(0, "unknown command '%s'; use --help for help", argv[0]);
+    vsctl_fatal("unknown command '%s'; use --help for help", argv[i]);
 }
 
 static void