#include "compiler.h"
#include "daemon.h"
#include "dirs.h"
-#include "dpif.h"
#include "dummy.h"
#include "leak-checker.h"
#include "list.h"
#include "poll-loop.h"
#include "rconn.h"
#include "stream-ssl.h"
-#include "svec.h"
#include "timeval.h"
#include "unixctl.h"
#include "util.h"
uint64_t datapath_id; /* Datapath ID. */
char *dp_name; /* Name of local datapath. */
char *dp_type; /* Type of local datapath. */
- struct svec ports; /* Set of ports to add to datapath (if any). */
+ struct sset ports; /* Set of ports to add to datapath (if any). */
/* Description strings. */
const char *mfr_desc; /* Manufacturer. */
struct ofproto *ofproto;
struct ofsettings s;
int error;
- struct dpif *dpif;
struct netflow_options nf_options;
+ const char *port;
bool exiting;
proctitle_init(argc, argv);
parse_options(argc, argv, &s);
signal(SIGPIPE, SIG_IGN);
- die_if_already_running();
daemonize_start();
/* Start listening for ovs-appctl requests. */
VLOG_INFO("Open vSwitch version %s", VERSION BUILDNR);
VLOG_INFO("OpenFlow protocol version 0x%02x", OFP_VERSION);
- error = dpif_create_and_open(s.dp_name, s.dp_type, &dpif);
+ error = ofproto_create(s.dp_name, s.dp_type, &ofproto);
if (error) {
- ovs_fatal(error, "could not create datapath");
+ VLOG_FATAL("could not initialize OpenFlow switch (%s)",
+ strerror(error));
}
/* Add ports to the datapath if requested by the user. */
- if (s.ports.n) {
- const char *port;
- size_t i;
+ SSET_FOR_EACH (port, &s.ports) {
+ struct netdev *netdev;
- SVEC_FOR_EACH (i, port, &s.ports) {
- struct netdev *netdev;
-
- error = netdev_open_default(port, &netdev);
- if (error) {
- ovs_fatal(error, "%s: failed to open network device", port);
- }
-
- error = dpif_port_add(dpif, netdev, NULL);
- if (error) {
- ovs_fatal(error, "failed to add %s as a port", port);
- }
+ error = netdev_open_default(port, &netdev);
+ if (error) {
+ VLOG_FATAL("%s: failed to open network device (%s)",
+ port, strerror(error));
+ }
- netdev_close(netdev);
+ error = ofproto_port_add(ofproto, netdev, NULL);
+ if (error) {
+ VLOG_FATAL("failed to add %s as a port (%s)",
+ port, strerror(error));
}
- }
- /* Start OpenFlow processing. */
- error = ofproto_create(s.dp_name, s.dp_type, NULL, NULL, &ofproto);
- if (error) {
- ovs_fatal(error, "could not initialize openflow switch");
+ netdev_close(netdev);
}
+
+ /* Configure OpenFlow switch. */
if (s.datapath_id) {
ofproto_set_datapath_id(ofproto, s.datapath_id);
}
s.serial_desc, s.dp_desc);
error = ofproto_set_snoops(ofproto, &s.snoops);
if (error) {
- ovs_fatal(error,
- "failed to configure controller snooping connections");
+ VLOG_FATAL("failed to configure controller snooping connections (%s)",
+ strerror(error));
}
memset(&nf_options, 0, sizeof nf_options);
nf_options.collectors = s.netflow;
error = ofproto_set_netflow(ofproto, &nf_options);
if (error) {
- ovs_fatal(error, "failed to configure NetFlow collectors");
+ VLOG_FATAL("failed to configure NetFlow collectors (%s)",
+ strerror(error));
}
ofproto_set_controllers(ofproto, s.controllers, s.n_controllers);
ofproto_set_fail_mode(ofproto, s.fail_mode);
while (!exiting && (s.run_forever || ofproto_is_alive(ofproto))) {
error = ofproto_run(ofproto);
if (error) {
- ovs_fatal(error, "unrecoverable datapath error");
+ VLOG_FATAL("unrecoverable datapath error (%s)", strerror(error));
}
unixctl_server_run(unixctl);
- dp_run();
netdev_run();
ofproto_wait(ofproto);
unixctl_server_wait(unixctl);
- dp_wait();
netdev_wait();
if (exiting) {
poll_immediate_wake();
poll_block();
}
- dpif_close(dpif);
+ ofproto_destroy(ofproto);
return 0;
}
\f
/* User interface. */
+/* Breaks 'ports' apart at commas and adds each resulting word to 'ports'. */
+static void
+parse_ports(const char *s_, struct sset *ports)
+{
+ char *s = xstrdup(s_);
+ char *save_ptr = NULL;
+ char *token;
+
+ for (token = strtok_r(s, ",", &save_ptr); token != NULL;
+ token = strtok_r(NULL, ",", &save_ptr)) {
+ sset_add(ports, token);
+ }
+ free(s);
+}
+
static void
parse_options(int argc, char *argv[], struct ofsettings *s)
{
DAEMON_OPTION_ENUMS
};
static struct option long_options[] = {
- {"datapath-id", required_argument, 0, OPT_DATAPATH_ID},
- {"mfr-desc", required_argument, 0, OPT_MFR_DESC},
- {"hw-desc", required_argument, 0, OPT_HW_DESC},
- {"sw-desc", required_argument, 0, OPT_SW_DESC},
- {"serial-desc", required_argument, 0, OPT_SERIAL_DESC},
- {"dp-desc", required_argument, 0, OPT_DP_DESC},
- {"config", required_argument, 0, 'F'},
- {"br-name", required_argument, 0, OPT_BR_NAME},
- {"fail", required_argument, 0, OPT_FAIL_MODE},
- {"inactivity-probe", required_argument, 0, OPT_INACTIVITY_PROBE},
- {"max-idle", required_argument, 0, OPT_MAX_IDLE},
- {"max-backoff", required_argument, 0, OPT_MAX_BACKOFF},
- {"listen", required_argument, 0, 'l'},
- {"snoop", required_argument, 0, OPT_SNOOP},
- {"rate-limit", optional_argument, 0, OPT_RATE_LIMIT},
- {"burst-limit", required_argument, 0, OPT_BURST_LIMIT},
- {"out-of-band", no_argument, 0, OPT_OUT_OF_BAND},
- {"in-band", no_argument, 0, OPT_IN_BAND},
- {"netflow", required_argument, 0, OPT_NETFLOW},
- {"ports", required_argument, 0, OPT_PORTS},
- {"unixctl", required_argument, 0, OPT_UNIXCTL},
- {"enable-dummy", no_argument, 0, OPT_ENABLE_DUMMY},
- {"verbose", optional_argument, 0, 'v'},
- {"help", no_argument, 0, 'h'},
- {"version", no_argument, 0, 'V'},
+ {"datapath-id", required_argument, NULL, OPT_DATAPATH_ID},
+ {"mfr-desc", required_argument, NULL, OPT_MFR_DESC},
+ {"hw-desc", required_argument, NULL, OPT_HW_DESC},
+ {"sw-desc", required_argument, NULL, OPT_SW_DESC},
+ {"serial-desc", required_argument, NULL, OPT_SERIAL_DESC},
+ {"dp-desc", required_argument, NULL, OPT_DP_DESC},
+ {"config", required_argument, NULL, 'F'},
+ {"br-name", required_argument, NULL, OPT_BR_NAME},
+ {"fail", required_argument, NULL, OPT_FAIL_MODE},
+ {"inactivity-probe", required_argument, NULL, OPT_INACTIVITY_PROBE},
+ {"max-idle", required_argument, NULL, OPT_MAX_IDLE},
+ {"max-backoff", required_argument, NULL, OPT_MAX_BACKOFF},
+ {"listen", required_argument, NULL, 'l'},
+ {"snoop", required_argument, NULL, OPT_SNOOP},
+ {"rate-limit", optional_argument, NULL, OPT_RATE_LIMIT},
+ {"burst-limit", required_argument, NULL, OPT_BURST_LIMIT},
+ {"out-of-band", no_argument, NULL, OPT_OUT_OF_BAND},
+ {"in-band", no_argument, NULL, OPT_IN_BAND},
+ {"netflow", required_argument, NULL, OPT_NETFLOW},
+ {"ports", required_argument, NULL, OPT_PORTS},
+ {"unixctl", required_argument, NULL, OPT_UNIXCTL},
+ {"enable-dummy", no_argument, NULL, OPT_ENABLE_DUMMY},
+ {"verbose", optional_argument, NULL, 'v'},
+ {"help", no_argument, NULL, 'h'},
+ {"version", no_argument, NULL, 'V'},
DAEMON_LONG_OPTIONS,
VLOG_LONG_OPTIONS,
LEAK_CHECKER_LONG_OPTIONS,
-#ifdef HAVE_OPENSSL
- STREAM_SSL_LONG_OPTIONS
- {"bootstrap-ca-cert", required_argument, 0, OPT_BOOTSTRAP_CA_CERT},
-#endif
- {0, 0, 0, 0},
+ STREAM_SSL_LONG_OPTIONS,
+ {"bootstrap-ca-cert", required_argument, NULL, OPT_BOOTSTRAP_CA_CERT},
+ {NULL, 0, NULL, 0},
};
char *short_options = long_options_to_short_options(long_options);
struct ofproto_controller controller_opts;
- struct svec controllers;
+ struct sset controllers;
+ const char *name;
int i;
/* Set defaults that we can figure out before parsing options. */
s->sw_desc = NULL;
s->serial_desc = NULL;
s->dp_desc = NULL;
- svec_init(&controllers);
+ sset_init(&controllers);
sset_init(&s->snoops);
s->max_idle = 0;
sset_init(&s->netflow);
- svec_init(&s->ports);
+ sset_init(&s->ports);
for (;;) {
int c;
switch (c) {
case OPT_DATAPATH_ID:
if (!dpid_from_string(optarg, &s->datapath_id)) {
- ovs_fatal(0, "argument to --datapath-id must be "
- "exactly 16 hex digits and may not be all-zero");
+ VLOG_FATAL("argument to --datapath-id must be exactly 16 hex "
+ "digits and may not be all-zero");
}
break;
|| !strcmp(optarg, "secure")) {
s->fail_mode = OFPROTO_FAIL_SECURE;
} else {
- ovs_fatal(0, "--fail argument must be \"standalone\" "
- "or \"secure\"");
+ VLOG_FATAL("--fail argument must be \"standalone\" "
+ "or \"secure\"");
}
break;
case OPT_INACTIVITY_PROBE:
controller_opts.probe_interval = atoi(optarg);
if (controller_opts.probe_interval < 5) {
- ovs_fatal(0, "--inactivity-probe argument must be at least 5");
+ VLOG_FATAL("--inactivity-probe argument must be at least 5");
}
break;
} else {
s->max_idle = atoi(optarg);
if (s->max_idle < 1 || s->max_idle > 65535) {
- ovs_fatal(0, "--max-idle argument must be between 1 and "
- "65535 or the word 'permanent'");
+ VLOG_FATAL("--max-idle argument must be between 1 and "
+ "65535 or the word 'permanent'");
}
}
break;
case OPT_MAX_BACKOFF:
controller_opts.max_backoff = atoi(optarg);
if (controller_opts.max_backoff < 1) {
- ovs_fatal(0, "--max-backoff argument must be at least 1");
+ VLOG_FATAL("--max-backoff argument must be at least 1");
} else if (controller_opts.max_backoff > 3600) {
controller_opts.max_backoff = 3600;
}
if (optarg) {
controller_opts.rate_limit = atoi(optarg);
if (controller_opts.rate_limit < 1) {
- ovs_fatal(0, "--rate-limit argument must be at least 1");
+ VLOG_FATAL("--rate-limit argument must be at least 1");
}
} else {
controller_opts.rate_limit = 1000;
case OPT_BURST_LIMIT:
controller_opts.burst_limit = atoi(optarg);
if (controller_opts.burst_limit < 1) {
- ovs_fatal(0, "--burst-limit argument must be at least 1");
+ VLOG_FATAL("--burst-limit argument must be at least 1");
}
break;
break;
case 'l':
- svec_add(&controllers, optarg);
+ sset_add(&controllers, optarg);
break;
case OPT_SNOOP:
break;
case OPT_PORTS:
- svec_split(&s->ports, optarg, ",");
+ parse_ports(optarg, &s->ports);
break;
case OPT_UNIXCTL:
LEAK_CHECKER_OPTION_HANDLERS
-#ifdef HAVE_OPENSSL
STREAM_SSL_OPTION_HANDLERS
case OPT_BOOTSTRAP_CA_CERT:
stream_ssl_set_ca_cert_file(optarg, true);
break;
-#endif
case '?':
exit(EXIT_FAILURE);
argc -= optind;
argv += optind;
if (argc < 2) {
- ovs_fatal(0, "need at least two non-option arguments; "
- "use --help for usage");
+ VLOG_FATAL("need at least two non-option arguments; "
+ "use --help for usage");
}
/* Rate limiting. */
}
/* Local vconns. */
- dp_parse_name(argv[0], &s->dp_name, &s->dp_type);
+ ofproto_parse_name(argv[0], &s->dp_name, &s->dp_type);
/* Figure out controller names. */
s->run_forever = false;
- if (!controllers.n) {
- svec_add_nocopy(&controllers, xasprintf("punix:%s/%s.mgmt",
- ovs_rundir(), s->dp_name));
+ if (sset_is_empty(&controllers)) {
+ sset_add_and_free(&controllers, xasprintf("punix:%s/%s.mgmt",
+ ovs_rundir(), s->dp_name));
}
for (i = 1; i < argc; i++) {
if (!strcmp(argv[i], "none")) {
s->run_forever = true;
} else {
- svec_add(&controllers, argv[i]);
+ sset_add(&controllers, argv[i]);
}
}
/* Set up controllers. */
- s->n_controllers = controllers.n;
+ s->n_controllers = sset_count(&controllers);
s->controllers = xmalloc(s->n_controllers * sizeof *s->controllers);
- for (i = 0; i < s->n_controllers; i++) {
+ i = 0;
+ SSET_FOR_EACH (name, &controllers) {
s->controllers[i] = controller_opts;
- s->controllers[i].target = controllers.names[i];
+ s->controllers[i].target = xstrdup(name);
+ i++;
}
+ sset_destroy(&controllers);
}
static void