X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=utilities%2Fovs-openflowd.c;h=bb77d589658de070a0bf25b6be1e0a02e2ce75e5;hb=f22716dcca299b863dd72eb193fb1283c5f686da;hp=70430c0356f86d52b112f983f1e8369fa646d634;hpb=79c9f2ee7883b52860c76c3730725f5731402874;p=openvswitch

diff --git a/utilities/ovs-openflowd.c b/utilities/ovs-openflowd.c
index 70430c03..bb77d589 100644
--- a/utilities/ovs-openflowd.c
+++ b/utilities/ovs-openflowd.c
@@ -44,14 +44,15 @@
 #include "unixctl.h"
 #include "util.h"
 #include "vconn.h"
-
 #include "vlog.h"
-#define THIS_MODULE VLM_openflowd
+
+VLOG_DEFINE_THIS_MODULE(openflowd)
 
 /* Settings that may be configured by the user. */
 struct ofsettings {
     /* Controller configuration. */
-    struct ofproto_controller controller;
+    struct ofproto_controller *controllers;
+    size_t n_controllers;
 
     /* Datapath. */
     uint64_t datapath_id;       /* Datapath ID. */
@@ -95,8 +96,6 @@ main(int argc, char *argv[])
 
     proctitle_init(argc, argv);
     set_program_name(argv[0]);
-    time_init();
-    vlog_init();
     parse_options(argc, argv, &s);
     signal(SIGPIPE, SIG_IGN);
 
@@ -121,14 +120,8 @@ main(int argc, char *argv[])
     if (s.ports.n) {
         const char *port;
         size_t i;
-        struct netdev *netdev;
 
         SVEC_FOR_EACH (i, port, &s.ports) {
-            error = netdev_open_default(port, &netdev);
-            if (error) {
-                ovs_fatal(error, "failed to open %s as a device", port);
-            }
-
             error = dpif_port_add(dpif, port, 0, NULL);
             if (error) {
                 ovs_fatal(error, "failed to add %s as a port", port);
@@ -171,7 +164,7 @@ main(int argc, char *argv[])
     if (error) {
         ovs_fatal(error, "failed to configure STP");
     }
-    ofproto_set_controller(ofproto, &s.controller);
+    ofproto_set_controllers(ofproto, s.controllers, s.n_controllers);
 
     daemonize_complete();
 
@@ -266,16 +259,18 @@ parse_options(int argc, char *argv[], struct ofsettings *s)
         {0, 0, 0, 0},
     };
     char *short_options = long_options_to_short_options(long_options);
+    struct ofproto_controller controller_opts;
 
     /* Set defaults that we can figure out before parsing options. */
-    s->controller.max_backoff = 8;
-    s->controller.probe_interval = 5;
-    s->controller.fail = OFPROTO_FAIL_STANDALONE;
-    s->controller.band = OFPROTO_IN_BAND;
-    s->controller.accept_re = NULL;
-    s->controller.update_resolv_conf = true;
-    s->controller.rate_limit = 0;
-    s->controller.burst_limit = 0;
+    controller_opts.target = NULL;
+    controller_opts.max_backoff = 8;
+    controller_opts.probe_interval = 5;
+    controller_opts.fail = OFPROTO_FAIL_STANDALONE;
+    controller_opts.band = OFPROTO_IN_BAND;
+    controller_opts.accept_re = NULL;
+    controller_opts.update_resolv_conf = true;
+    controller_opts.rate_limit = 0;
+    controller_opts.burst_limit = 0;
     s->datapath_id = 0;
     s->mfr_desc = NULL;
     s->hw_desc = NULL;
@@ -325,26 +320,28 @@ parse_options(int argc, char *argv[], struct ofsettings *s)
             break;
 
         case OPT_ACCEPT_VCONN:
-            s->controller.accept_re = optarg;
+            controller_opts.accept_re = optarg;
             break;
 
         case OPT_NO_RESOLV_CONF:
-            s->controller.update_resolv_conf = false;
+            controller_opts.update_resolv_conf = false;
             break;
 
         case OPT_FAIL_MODE:
-            if (!strcmp(optarg, "open")) {
-                s->controller.fail = OFPROTO_FAIL_STANDALONE;
-            } else if (!strcmp(optarg, "closed")) {
-                s->controller.fail = OFPROTO_FAIL_SECURE;
+            if (!strcmp(optarg, "open") || !strcmp(optarg, "standalone")) {
+                controller_opts.fail = OFPROTO_FAIL_STANDALONE;
+            } else if (!strcmp(optarg, "closed")
+                       || !strcmp(optarg, "secure")) {
+                controller_opts.fail = OFPROTO_FAIL_SECURE;
             } else {
-                ovs_fatal(0, "--fail argument must be \"open\" or \"closed\"");
+                ovs_fatal(0, "--fail argument must be \"standalone\" "
+                          "or \"secure\"");
             }
             break;
 
         case OPT_INACTIVITY_PROBE:
-            s->controller.probe_interval = atoi(optarg);
-            if (s->controller.probe_interval < 5) {
+            controller_opts.probe_interval = atoi(optarg);
+            if (controller_opts.probe_interval < 5) {
                 ovs_fatal(0, "--inactivity-probe argument must be at least 5");
             }
             break;
@@ -362,28 +359,28 @@ parse_options(int argc, char *argv[], struct ofsettings *s)
             break;
 
         case OPT_MAX_BACKOFF:
-            s->controller.max_backoff = atoi(optarg);
-            if (s->controller.max_backoff < 1) {
+            controller_opts.max_backoff = atoi(optarg);
+            if (controller_opts.max_backoff < 1) {
                 ovs_fatal(0, "--max-backoff argument must be at least 1");
-            } else if (s->controller.max_backoff > 3600) {
-                s->controller.max_backoff = 3600;
+            } else if (controller_opts.max_backoff > 3600) {
+                controller_opts.max_backoff = 3600;
             }
             break;
 
         case OPT_RATE_LIMIT:
             if (optarg) {
-                s->controller.rate_limit = atoi(optarg);
-                if (s->controller.rate_limit < 1) {
+                controller_opts.rate_limit = atoi(optarg);
+                if (controller_opts.rate_limit < 1) {
                     ovs_fatal(0, "--rate-limit argument must be at least 1");
                 }
             } else {
-                s->controller.rate_limit = 1000;
+                controller_opts.rate_limit = 1000;
             }
             break;
 
         case OPT_BURST_LIMIT:
-            s->controller.burst_limit = atoi(optarg);
-            if (s->controller.burst_limit < 1) {
+            controller_opts.burst_limit = atoi(optarg);
+            if (controller_opts.burst_limit < 1) {
                 ovs_fatal(0, "--burst-limit argument must be at least 1");
             }
             break;
@@ -397,11 +394,11 @@ parse_options(int argc, char *argv[], struct ofsettings *s)
             break;
 
         case OPT_OUT_OF_BAND:
-            s->controller.band = OFPROTO_OUT_OF_BAND;
+            controller_opts.band = OFPROTO_OUT_OF_BAND;
             break;
 
         case OPT_IN_BAND:
-            s->controller.band = OFPROTO_IN_BAND;
+            controller_opts.band = OFPROTO_IN_BAND;
             break;
 
         case OPT_NETFLOW:
@@ -457,25 +454,46 @@ parse_options(int argc, char *argv[], struct ofsettings *s)
                   "use --help for usage");
     }
 
-    /* Local and remote vconns. */
-    dp_parse_name(argv[0], &s->dp_name, &s->dp_type);
-
-    s->controller.target = argc > 1 ? argv[1] : "discover";
-    if (!strcmp(s->controller.target, "discover")
-        && s->controller.band == OFPROTO_OUT_OF_BAND) {
-        ovs_fatal(0, "Cannot perform discovery with out-of-band control");
-    }
-
     /* Set accept_controller_regex. */
-    if (!s->controller.accept_re) {
-        s->controller.accept_re
+    if (!controller_opts.accept_re) {
+        controller_opts.accept_re
             = stream_ssl_is_configured() ? "^ssl:.*" : "^tcp:.*";
     }
 
     /* Rate limiting. */
-    if (s->controller.rate_limit && s->controller.rate_limit < 100) {
+    if (controller_opts.rate_limit && controller_opts.rate_limit < 100) {
         VLOG_WARN("Rate limit set to unusually low value %d",
-                  s->controller.rate_limit);
+                  controller_opts.rate_limit);
+    }
+
+    /* Local vconns. */
+    dp_parse_name(argv[0], &s->dp_name, &s->dp_type);
+
+    /* Controllers. */
+    s->n_controllers = argc > 1 ? argc - 1 : 1;
+    s->controllers = xmalloc(s->n_controllers * sizeof *s->controllers);
+    if (argc > 1) {
+        size_t i;
+
+        for (i = 0; i < s->n_controllers; i++) {
+            s->controllers[i] = controller_opts;
+            s->controllers[i].target = argv[i + 1];
+        }
+    } else {
+        s->controllers[0] = controller_opts;
+        s->controllers[0].target = "discover";
+    }
+
+    /* Sanity check. */
+    if (controller_opts.band == OFPROTO_OUT_OF_BAND) {
+        size_t i;
+
+        for (i = 0; i < s->n_controllers; i++) {
+            if (!strcmp(s->controllers[i].target, "discover")) {
+                ovs_fatal(0, "Cannot perform discovery with out-of-band "
+                          "control");
+            }
+        }
     }
 }
 
@@ -483,10 +501,10 @@ static void
 usage(void)
 {
     printf("%s: an OpenFlow switch implementation.\n"
-           "usage: %s [OPTIONS] DATAPATH [CONTROLLER]\n"
+           "usage: %s [OPTIONS] DATAPATH [CONTROLLER...]\n"
            "DATAPATH is a local datapath (e.g. \"dp0\").\n"
-           "CONTROLLER is an active OpenFlow connection method; if it is\n"
-           "omitted, then ovs-openflowd performs controller discovery.\n",
+           "Each CONTROLLER is an active OpenFlow connection method.  If\n"
+           "none is given, ovs-openflowd performs controller discovery.\n",
            program_name, program_name);
     vconn_usage(true, true, true);
     printf("\nOpenFlow options:\n"