fatal_ignore_sigpipe();
ctx.argc = argc - optind;
ctx.argv = argv + optind;
+
+ daemon_become_new_user(false);
ovs_cmdl_run_command(&ctx, get_all_commands());
return 0;
}
" dump-desc SWITCH print switch description\n"
" dump-tables SWITCH print table stats\n"
" dump-table-features SWITCH print table features\n"
+ " dump-table-desc SWITCH print table description (OF1.4+)\n"
" mod-port SWITCH IFACE ACT modify port behavior\n"
" mod-table SWITCH MOD modify flow table behavior\n"
+ " OF1.1/1.2 MOD: controller, continue, drop\n"
+ " OF1.4+ MOD: evict, noevict\n"
" get-frags SWITCH print fragment handling behavior\n"
" set-frags SWITCH FRAG_MODE set fragment handling behavior\n"
+ " FRAG_MODE: normal, drop, reassemble, nx-match\n"
" dump-ports SWITCH [PORT] print port statistics\n"
" dump-ports-desc SWITCH [PORT] print port descriptions\n"
" dump-flows SWITCH print all flow entries\n"
open_vconn(ctx->argv[1], &vconn);
request = ofputil_encode_table_features_request(vconn_get_version(vconn));
+
+ /* The following is similar to dump_trivial_stats_transaction(), but it
+ * maintains the previous 'ofputil_table_features' from one stats reply
+ * message to the next, which allows duplication to be eliminated in the
+ * output across messages. Otherwise the output is much larger and harder
+ * to read, because only 17 or so ofputil_table_features elements fit in a
+ * single 64 kB OpenFlow message and therefore you get a ton of repetition
+ * (every 17th element is printed in full instead of abbreviated). */
+
+ const struct ofp_header *request_oh = request->data;
+ ovs_be32 send_xid = request_oh->xid;
+ bool done = false;
+
+ struct ofputil_table_features prev;
+ int n = 0;
+
+ send_openflow_buffer(vconn, request);
+ while (!done) {
+ ovs_be32 recv_xid;
+ struct ofpbuf *reply;
+
+ run(vconn_recv_block(vconn, &reply), "OpenFlow packet receive failed");
+ recv_xid = ((struct ofp_header *) reply->data)->xid;
+ if (send_xid == recv_xid) {
+ enum ofptype type;
+ enum ofperr error;
+ error = ofptype_decode(&type, reply->data);
+ if (error) {
+ ovs_fatal(0, "decode error: %s", ofperr_get_name(error));
+ } else if (type == OFPTYPE_ERROR) {
+ ofp_print(stdout, reply->data, reply->size, verbosity + 1);
+ done = true;
+ } else if (type == OFPTYPE_TABLE_FEATURES_STATS_REPLY) {
+ done = !ofpmp_more(reply->data);
+ for (;;) {
+ struct ofputil_table_features tf;
+ int retval;
+
+ retval = ofputil_decode_table_features(reply, &tf, true);
+ if (retval) {
+ if (retval != EOF) {
+ ovs_fatal(0, "decode error: %s",
+ ofperr_get_name(retval));
+ }
+ break;
+ }
+
+ struct ds s = DS_EMPTY_INITIALIZER;
+ ofp_print_table_features(&s, &tf, n ? &prev : NULL,
+ NULL, NULL);
+ puts(ds_cstr(&s));
+ ds_destroy(&s);
+
+ prev = tf;
+ n++;
+ }
+ } else {
+ ovs_fatal(0, "received bad reply: %s",
+ ofp_to_string(reply->data, reply->size,
+ verbosity + 1));
+ }
+ } else {
+ VLOG_DBG("received reply with xid %08"PRIx32" "
+ "!= expected %08"PRIx32, recv_xid, send_xid);
+ }
+ ofpbuf_delete(reply);
+ }
+
+ vconn_close(vconn);
+}
+
+static void
+ofctl_dump_table_desc(struct ovs_cmdl_context *ctx)
+{
+ struct ofpbuf *request;
+ struct vconn *vconn;
+
+ open_vconn(ctx->argv[1], &vconn);
+ request = ofputil_encode_table_desc_request(vconn_get_version(vconn));
if (request) {
dump_stats_transaction(vconn, request);
}
vconn_close(vconn);
}
+
static bool fetch_port_by_stats(struct vconn *,
const char *port_name, ofp_port_t port_no,
struct ofputil_phy_port *);
int error;
daemon_save_fd(STDERR_FILENO);
- daemonize_start();
+ daemonize_start(false);
error = unixctl_server_create(unixctl_path, &server);
if (error) {
ovs_fatal(error, "failed to create unixctl server");
fetch_ofputil_phy_port(ctx->argv[1], ctx->argv[2], &pp);
pm.port_no = pp.port_no;
- memcpy(pm.hw_addr, pp.hw_addr, ETH_ADDR_LEN);
+ pm.hw_addr = pp.hw_addr;
pm.config = 0;
pm.mask = 0;
pm.advertise = 0;
static void
ofctl_mod_table(struct ovs_cmdl_context *ctx)
{
- enum ofputil_protocol protocol, usable_protocols;
+ uint32_t usable_versions;
struct ofputil_table_mod tm;
struct vconn *vconn;
char *error;
- int i;
- error = parse_ofp_table_mod(&tm, ctx->argv[2], ctx->argv[3], &usable_protocols);
+ error = parse_ofp_table_mod(&tm, ctx->argv[2], ctx->argv[3],
+ &usable_versions);
if (error) {
ovs_fatal(0, "%s", error);
}
- protocol = open_vconn(ctx->argv[1], &vconn);
- if (!(protocol & usable_protocols)) {
- for (i = 0; i < sizeof(enum ofputil_protocol) * CHAR_BIT; i++) {
- enum ofputil_protocol f = 1 << i;
- if (f != protocol
- && f & usable_protocols
- && try_set_protocol(vconn, f, &protocol)) {
- protocol = f;
- break;
- }
- }
- }
-
- if (!(protocol & usable_protocols)) {
- char *usable_s = ofputil_protocols_to_string(usable_protocols);
- ovs_fatal(0, "Switch does not support table mod message(%s)", usable_s);
+ uint32_t allowed_versions = get_allowed_ofp_versions();
+ if (!(allowed_versions & usable_versions)) {
+ struct ds versions = DS_EMPTY_INITIALIZER;
+ ofputil_format_version_bitmap_names(&versions, allowed_versions);
+ ovs_fatal(0, "table_mod '%s' requires one of the OpenFlow "
+ "versions %s but none is enabled (use -O)",
+ ctx->argv[3], ds_cstr(&versions));
}
+ mask_allowed_ofp_versions(usable_versions);
+ enum ofputil_protocol protocol = open_vconn(ctx->argv[1], &vconn);
transact_noreply(vconn, ofputil_encode_table_mod(&tm, protocol));
vconn_close(vconn);
}
struct fte *old, *fte;
fte = xzalloc(sizeof *fte);
- cls_rule_init(&fte->rule, match, priority, CLS_MIN_VERSION);
+ cls_rule_init(&fte->rule, match, priority);
fte->versions[index] = version;
- old = fte_from_cls_rule(classifier_replace(cls, &fte->rule, NULL, 0));
+ old = fte_from_cls_rule(classifier_replace(cls, &fte->rule,
+ CLS_MIN_VERSION, NULL, 0));
if (old) {
fte->versions[!index] = old->versions[!index];
old->versions[!index] = NULL;
1, 1, ofctl_dump_tables },
{ "dump-table-features", "switch",
1, 1, ofctl_dump_table_features },
+ { "dump-table-desc", "switch",
+ 1, 1, ofctl_dump_table_desc },
{ "dump-flows", "switch",
1, 2, ofctl_dump_flows },
{ "dump-aggregate", "switch",