X-Git-Url: http://git.cascardo.eti.br/?a=blobdiff_plain;f=utilities%2Fovs-ofctl.c;h=0d990aa73ee18407e1ac4c86b009ba71b5f3c7c1;hb=6409e0083debb6cd1ad71e7d6bdd7fc1d7b83dd1;hp=44c52751cc50034c5393e3c0101add857e1df8fc;hpb=bdd0bd2873415838643e42a1e4c08319fe8d3b8b;p=cascardo%2Fovs.git diff --git a/utilities/ovs-ofctl.c b/utilities/ovs-ofctl.c index 44c52751c..0d990aa73 100644 --- a/utilities/ovs-ofctl.c +++ b/utilities/ovs-ofctl.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2008, 2009, 2010, 2011, 2012, 2013, 2014, 2015 Nicira, Inc. + * Copyright (c) 2008, 2009, 2010, 2011, 2012, 2013, 2014, 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. @@ -67,6 +67,12 @@ VLOG_DEFINE_THIS_MODULE(ofctl); +/* --bundle: Use OpenFlow 1.4 bundle for making the flow table change atomic. + * NOTE: Also the flow mod will use OpenFlow 1.4, so the semantics may be + * different (see the comment in parse_options() for details). + */ +static bool bundle = false; + /* --strict: Use strict matching for flow mod commands? Additionally governs * use of nx_pull_match() instead of nx_pull_match_loose() in parse-nx-match. */ @@ -105,7 +111,7 @@ struct sort_criterion { static struct sort_criterion *criteria; static size_t n_criteria, allocated_criteria; -static const struct command *get_all_commands(void); +static const struct ovs_cmdl_command *get_all_commands(void); OVS_NO_RETURN static void usage(void); static void parse_options(int argc, char *argv[]); @@ -117,11 +123,16 @@ static bool recv_flow_stats_reply(struct vconn *, ovs_be32 send_xid, int main(int argc, char *argv[]) { + struct ovs_cmdl_context ctx = { .argc = 0, }; set_program_name(argv[0]); service_start(&argc, &argv); parse_options(argc, argv); fatal_ignore_sigpipe(); - run_command(argc - optind, argv + optind, get_all_commands()); + ctx.argc = argc - optind; + ctx.argv = argv + optind; + + daemon_become_new_user(false); + ovs_cmdl_run_command(&ctx, get_all_commands()); return 0; } @@ -156,6 +167,7 @@ parse_options(int argc, char *argv[]) OPT_SORT, OPT_RSORT, OPT_UNIXCTL, + OPT_BUNDLE, DAEMON_OPTION_ENUMS, OFP_VERSION_OPTION_ENUMS, VLOG_OPTION_ENUMS @@ -173,13 +185,14 @@ parse_options(int argc, char *argv[]) {"unixctl", required_argument, NULL, OPT_UNIXCTL}, {"help", no_argument, NULL, 'h'}, {"option", no_argument, NULL, 'o'}, + {"bundle", no_argument, NULL, OPT_BUNDLE}, DAEMON_LONG_OPTIONS, OFP_VERSION_LONG_OPTIONS, VLOG_LONG_OPTIONS, STREAM_SSL_LONG_OPTIONS, {NULL, 0, NULL, 0}, }; - char *short_options = long_options_to_short_options(long_options); + char *short_options = ovs_cmdl_long_options_to_short_options(long_options); uint32_t versions; enum ofputil_protocol version_protocols; @@ -243,9 +256,13 @@ parse_options(int argc, char *argv[]) usage(); case 'o': - print_options(long_options); + ovs_cmdl_print_options(long_options); exit(EXIT_SUCCESS); + case OPT_BUNDLE: + bundle = true; + break; + case OPT_STRICT: strict = true; break; @@ -290,6 +307,15 @@ parse_options(int argc, char *argv[]) free(short_options); + /* Implicit OpenFlow 1.4 with the '--bundle' option. */ + if (bundle) { + /* Add implicit allowance for OpenFlow 1.4. */ + add_allowed_ofp_versions(ofputil_protocols_to_version_bitmap( + OFPUTIL_P_OF14_OXM)); + /* Remove all prior versions. */ + mask_allowed_ofp_versions(ofputil_protocols_to_version_bitmap( + OFPUTIL_P_OF14_UP)); + } versions = get_allowed_ofp_versions(); version_protocols = ofputil_protocols_from_version_bitmap(versions); if (!(allowed_protocols & version_protocols)) { @@ -317,10 +343,14 @@ usage(void) " 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, vacancy:low,high, novacancy\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" @@ -348,7 +378,7 @@ usage(void) " dump-group-features SWITCH print group features\n" " dump-groups SWITCH [GROUP] print group description\n" " dump-group-stats SWITCH [GROUP] print group statistics\n" - " queue-get-config SWITCH PORT print queue information for port\n" + " queue-get-config SWITCH [PORT] print queue config for PORT\n" " add-meter SWITCH METER add meter described by METER\n" " mod-meter SWITCH METER modify specific METER\n" " del-meter SWITCH METER delete METER\n" @@ -357,6 +387,9 @@ usage(void) " dump-meters SWITCH print all meter configuration\n" " meter-stats SWITCH [METER] print meter statistics\n" " meter-features SWITCH print meter features\n" + " add-tlv-map SWITCH MAP add TLV option MAPpings\n" + " del-tlv-map SWITCH [MAP] delete TLV option MAPpings\n" + " dump-tlv-map SWITCH print TLV option mappings\n" "\nFor OpenFlow switches and controllers:\n" " probe TARGET probe whether TARGET is up\n" " ping TARGET [N] latency of N-byte echos\n" @@ -493,86 +526,70 @@ open_vconn(const char *name, struct vconn **vconnp) static void send_openflow_buffer(struct vconn *vconn, struct ofpbuf *buffer) { - ofpmsg_update_length(buffer); run(vconn_send_block(vconn, buffer), "failed to send packet to switch"); } static void dump_transaction(struct vconn *vconn, struct ofpbuf *request) { - struct ofpbuf *reply; + const struct ofp_header *oh = request->data; + if (ofpmsg_is_stat_request(oh)) { + ovs_be32 send_xid = oh->xid; + enum ofpraw request_raw; + enum ofpraw reply_raw; + bool done = false; - ofpmsg_update_length(request); - run(vconn_transact(vconn, request, &reply), "talking to %s", - vconn_get_name(vconn)); - ofp_print(stdout, reply->data, reply->size, verbosity + 1); - ofpbuf_delete(reply); -} + ofpraw_decode_partial(&request_raw, request->data, request->size); + reply_raw = ofpraw_stats_request_to_reply(request_raw, oh->version); -static void -dump_trivial_transaction(const char *vconn_name, enum ofpraw raw) -{ - struct ofpbuf *request; - struct vconn *vconn; - - open_vconn(vconn_name, &vconn); - request = ofpraw_alloc(raw, vconn_get_version(vconn), 0); - dump_transaction(vconn, request); - vconn_close(vconn); -} - -static void -dump_stats_transaction(struct vconn *vconn, struct ofpbuf *request) -{ - const struct ofp_header *request_oh = request->data; - ovs_be32 send_xid = request_oh->xid; - enum ofpraw request_raw; - enum ofpraw reply_raw; - bool done = false; - - ofpraw_decode_partial(&request_raw, request->data, request->size); - reply_raw = ofpraw_stats_request_to_reply(request_raw, - request_oh->version); - - 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 ofpraw raw; - - ofp_print(stdout, reply->data, reply->size, verbosity + 1); - - ofpraw_decode(&raw, reply->data); - if (ofptype_from_ofpraw(raw) == OFPTYPE_ERROR) { - done = true; - } else if (raw == reply_raw) { - done = !ofpmp_more(reply->data); + 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 ofpraw raw; + + ofp_print(stdout, reply->data, reply->size, verbosity + 1); + + ofpraw_decode(&raw, reply->data); + if (ofptype_from_ofpraw(raw) == OFPTYPE_ERROR) { + done = true; + } else if (raw == reply_raw) { + done = !ofpmp_more(reply->data); + } else { + ovs_fatal(0, "received bad reply: %s", + ofp_to_string(reply->data, reply->size, + verbosity + 1)); + } } else { - ovs_fatal(0, "received bad reply: %s", - ofp_to_string(reply->data, reply->size, - verbosity + 1)); + VLOG_DBG("received reply with xid %08"PRIx32" " + "!= expected %08"PRIx32, recv_xid, send_xid); } - } else { - VLOG_DBG("received reply with xid %08"PRIx32" " - "!= expected %08"PRIx32, recv_xid, send_xid); + ofpbuf_delete(reply); } + } else { + struct ofpbuf *reply; + + run(vconn_transact(vconn, request, &reply), "talking to %s", + vconn_get_name(vconn)); + ofp_print(stdout, reply->data, reply->size, verbosity + 1); ofpbuf_delete(reply); } } static void -dump_trivial_stats_transaction(const char *vconn_name, enum ofpraw raw) +dump_trivial_transaction(const char *vconn_name, enum ofpraw raw) { struct ofpbuf *request; struct vconn *vconn; open_vconn(vconn_name, &vconn); request = ofpraw_alloc(raw, vconn_get_version(vconn), 0); - dump_stats_transaction(vconn, request); + dump_transaction(vconn, request); vconn_close(vconn); } @@ -584,11 +601,7 @@ dump_trivial_stats_transaction(const char *vconn_name, enum ofpraw raw) static void transact_multiple_noreply(struct vconn *vconn, struct ovs_list *requests) { - struct ofpbuf *request, *reply; - - LIST_FOR_EACH (request, list_node, requests) { - ofpmsg_update_length(request); - } + struct ofpbuf *reply; run(vconn_transact_multiple_noreply(vconn, requests, &reply), "talking to %s", vconn_get_name(vconn)); @@ -599,6 +612,20 @@ transact_multiple_noreply(struct vconn *vconn, struct ovs_list *requests) ofpbuf_delete(reply); } +static void +bundle_error_reporter(const struct ofp_header *oh) +{ + ofp_print(stderr, oh, ntohs(oh->length), verbosity + 1); + fflush(stderr); +} + +static void +bundle_transact(struct vconn *vconn, struct ovs_list *requests, uint16_t flags) +{ + run(vconn_bundle_transact(vconn, requests, flags, bundle_error_reporter), + "talking to %s", vconn_get_name(vconn)); +} + /* Sends 'request', which should be a request that only has a reply if an error * occurs, and waits for it to succeed or fail. If an error does occur, prints * it and exits with an error. @@ -615,9 +642,8 @@ transact_noreply(struct vconn *vconn, struct ofpbuf *request) } static void -fetch_switch_config(struct vconn *vconn, struct ofp_switch_config *config_) +fetch_switch_config(struct vconn *vconn, struct ofputil_switch_config *config) { - struct ofp_switch_config *config; struct ofpbuf *request; struct ofpbuf *reply; enum ofptype type; @@ -627,31 +653,26 @@ fetch_switch_config(struct vconn *vconn, struct ofp_switch_config *config_) run(vconn_transact(vconn, request, &reply), "talking to %s", vconn_get_name(vconn)); - if (ofptype_pull(&type, reply) || type != OFPTYPE_GET_CONFIG_REPLY) { + if (ofptype_decode(&type, reply->data) + || type != OFPTYPE_GET_CONFIG_REPLY) { ovs_fatal(0, "%s: bad reply to config request", vconn_get_name(vconn)); } - - config = ofpbuf_pull(reply, sizeof *config); - *config_ = *config; - + ofputil_decode_get_config_reply(reply->data, config); ofpbuf_delete(reply); } static void -set_switch_config(struct vconn *vconn, const struct ofp_switch_config *config) +set_switch_config(struct vconn *vconn, + const struct ofputil_switch_config *config) { - struct ofpbuf *request; - - request = ofpraw_alloc(OFPRAW_OFPT_SET_CONFIG, vconn_get_version(vconn), 0); - ofpbuf_put(request, config, sizeof *config); - - transact_noreply(vconn, request); + enum ofp_version version = vconn_get_version(vconn); + transact_noreply(vconn, ofputil_encode_set_config(config, version)); } static void -ofctl_show(int argc OVS_UNUSED, char *argv[]) +ofctl_show(struct ovs_cmdl_context *ctx) { - const char *vconn_name = argv[1]; + const char *vconn_name = ctx->argv[1]; enum ofp_version version; struct vconn *vconn; struct ofpbuf *request; @@ -669,178 +690,262 @@ ofctl_show(int argc OVS_UNUSED, char *argv[]) if (!has_ports) { request = ofputil_encode_port_desc_stats_request(version, OFPP_ANY); - dump_stats_transaction(vconn, request); + dump_transaction(vconn, request); } dump_trivial_transaction(vconn_name, OFPRAW_OFPT_GET_CONFIG_REQUEST); vconn_close(vconn); } static void -ofctl_dump_desc(int argc OVS_UNUSED, char *argv[]) +ofctl_dump_desc(struct ovs_cmdl_context *ctx) { - dump_trivial_stats_transaction(argv[1], OFPRAW_OFPST_DESC_REQUEST); + dump_trivial_transaction(ctx->argv[1], OFPRAW_OFPST_DESC_REQUEST); } static void -ofctl_dump_tables(int argc OVS_UNUSED, char *argv[]) +ofctl_dump_tables(struct ovs_cmdl_context *ctx) { - dump_trivial_stats_transaction(argv[1], OFPRAW_OFPST_TABLE_REQUEST); + dump_trivial_transaction(ctx->argv[1], OFPRAW_OFPST_TABLE_REQUEST); } static void -ofctl_dump_table_features(int argc OVS_UNUSED, char *argv[]) +ofctl_dump_table_features(struct ovs_cmdl_context *ctx) { struct ofpbuf *request; struct vconn *vconn; - open_vconn(argv[1], &vconn); + open_vconn(ctx->argv[1], &vconn); request = ofputil_encode_table_features_request(vconn_get_version(vconn)); + + /* The following is similar to dump_trivial_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); + dump_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 *); -/* Uses OFPT_FEATURES_REQUEST to attempt to fetch information about the port - * named 'port_name' or numbered 'port_no' into '*pp'. Returns true if - * successful, false on failure. - * - * This is only appropriate for OpenFlow 1.0, 1.1, and 1.2, which include a - * list of ports in OFPT_FEATURES_REPLY. */ static bool -fetch_port_by_features(struct vconn *vconn, - const char *port_name, ofp_port_t port_no, - struct ofputil_phy_port *pp) +str_to_ofp(const char *s, ofp_port_t *ofp_port) { - struct ofputil_switch_features features; - const struct ofp_header *oh; - struct ofpbuf *request, *reply; - enum ofperr error; - enum ofptype type; - struct ofpbuf b; - bool found = false; + bool ret; + uint32_t port_; + + ret = str_to_uint(s, 10, &port_); + *ofp_port = u16_to_ofp(port_); + return ret; +} + +struct port_iterator { + struct vconn *vconn; + + enum { PI_FEATURES, PI_PORT_DESC } variant; + struct ofpbuf *reply; + ovs_be32 send_xid; + bool more; +}; + +static void +port_iterator_fetch_port_desc(struct port_iterator *pi) +{ + pi->variant = PI_PORT_DESC; + pi->more = true; + + struct ofpbuf *rq = ofputil_encode_port_desc_stats_request( + vconn_get_version(pi->vconn), OFPP_ANY); + pi->send_xid = ((struct ofp_header *) rq->data)->xid; + send_openflow_buffer(pi->vconn, rq); +} + +static void +port_iterator_fetch_features(struct port_iterator *pi) +{ + pi->variant = PI_FEATURES; /* Fetch the switch's ofp_switch_features. */ - request = ofpraw_alloc(OFPRAW_OFPT_FEATURES_REQUEST, - vconn_get_version(vconn), 0); - run(vconn_transact(vconn, request, &reply), - "talking to %s", vconn_get_name(vconn)); + enum ofp_version version = vconn_get_version(pi->vconn); + struct ofpbuf *rq = ofpraw_alloc(OFPRAW_OFPT_FEATURES_REQUEST, version, 0); + run(vconn_transact(pi->vconn, rq, &pi->reply), + "talking to %s", vconn_get_name(pi->vconn)); - oh = reply->data; - if (ofptype_decode(&type, reply->data) + enum ofptype type; + if (ofptype_decode(&type, pi->reply->data) || type != OFPTYPE_FEATURES_REPLY) { - ovs_fatal(0, "%s: received bad features reply", vconn_get_name(vconn)); + ovs_fatal(0, "%s: received bad features reply", + vconn_get_name(pi->vconn)); } - if (!ofputil_switch_features_has_ports(reply)) { + if (!ofputil_switch_features_has_ports(pi->reply)) { /* The switch features reply does not contain a complete list of ports. * Probably, there are more ports than will fit into a single 64 kB * OpenFlow message. Use OFPST_PORT_DESC to get a complete list of * ports. */ - ofpbuf_delete(reply); - return fetch_port_by_stats(vconn, port_name, port_no, pp); + ofpbuf_delete(pi->reply); + pi->reply = NULL; + port_iterator_fetch_port_desc(pi); + return; } - error = ofputil_decode_switch_features(oh, &features, &b); + struct ofputil_switch_features features; + enum ofperr error = ofputil_pull_switch_features(pi->reply, &features); if (error) { ovs_fatal(0, "%s: failed to decode features reply (%s)", - vconn_get_name(vconn), ofperr_to_string(error)); + vconn_get_name(pi->vconn), ofperr_to_string(error)); } +} - while (!ofputil_pull_phy_port(oh->version, &b, pp)) { - if (port_no != OFPP_NONE - ? port_no == pp->port_no - : !strcmp(pp->name, port_name)) { - found = true; - break; - } +/* Initializes 'pi' to prepare for iterating through all of the ports on the + * OpenFlow switch to which 'vconn' is connected. + * + * During iteration, the client should not make other use of 'vconn', because + * that can cause other messages to be interleaved with the replies used by the + * iterator and thus some ports may be missed or a hang can occur. */ +static void +port_iterator_init(struct port_iterator *pi, struct vconn *vconn) +{ + memset(pi, 0, sizeof *pi); + pi->vconn = vconn; + if (vconn_get_version(vconn) < OFP13_VERSION) { + port_iterator_fetch_features(pi); + } else { + port_iterator_fetch_port_desc(pi); } - ofpbuf_delete(reply); - return found; } -/* Uses a OFPST_PORT_DESC request to attempt to fetch information about the - * port named 'port_name' or numbered 'port_no' into '*pp'. Returns true if - * successful, false on failure. - * - * This is most appropriate for OpenFlow 1.3 and later. Open vSwitch 1.7 and - * later also implements OFPST_PORT_DESC, as an extension, for OpenFlow 1.0, - * 1.1, and 1.2, so this can be used as a fallback in those versions when there - * are too many ports than fit in an OFPT_FEATURES_REPLY. */ +/* Obtains the next port from 'pi'. On success, initializes '*pp' with the + * port's details and returns true, otherwise (if all the ports have already + * been seen), returns false. */ static bool -fetch_port_by_stats(struct vconn *vconn, - const char *port_name, ofp_port_t port_no, - struct ofputil_phy_port *pp) +port_iterator_next(struct port_iterator *pi, struct ofputil_phy_port *pp) { - struct ofpbuf *request; - ovs_be32 send_xid; - bool done = false; - bool found = false; - - request = ofputil_encode_port_desc_stats_request(vconn_get_version(vconn), - port_no); - send_xid = ((struct ofp_header *) request->data)->xid; - - 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) { - struct ofp_header *oh = reply->data; - enum ofptype type; - struct ofpbuf b; - uint16_t flags; - - ofpbuf_use_const(&b, oh, ntohs(oh->length)); - if (ofptype_pull(&type, &b) - || type != OFPTYPE_PORT_DESC_STATS_REPLY) { + for (;;) { + if (pi->reply) { + int retval = ofputil_pull_phy_port(vconn_get_version(pi->vconn), + pi->reply, pp); + if (!retval) { + return true; + } else if (retval != EOF) { ovs_fatal(0, "received bad reply: %s", - ofp_to_string(reply->data, reply->size, + ofp_to_string(pi->reply->data, pi->reply->size, verbosity + 1)); } + } - flags = ofpmp_flags(oh); - done = !(flags & OFPSF_REPLY_MORE); - - if (found) { - /* We've already found the port, but we need to drain - * the queue of any other replies for this request. */ - continue; - } + if (pi->variant == PI_FEATURES || !pi->more) { + return false; + } - while (!ofputil_pull_phy_port(oh->version, &b, pp)) { - if (port_no != OFPP_NONE ? port_no == pp->port_no - : !strcmp(pp->name, port_name)) { - found = true; - break; - } - } - } else { - VLOG_DBG("received reply with xid %08"PRIx32" " - "!= expected %08"PRIx32, recv_xid, send_xid); + ovs_be32 recv_xid; + do { + ofpbuf_delete(pi->reply); + run(vconn_recv_block(pi->vconn, &pi->reply), + "OpenFlow receive failed"); + recv_xid = ((struct ofp_header *) pi->reply->data)->xid; + } while (pi->send_xid != recv_xid); + + struct ofp_header *oh = pi->reply->data; + enum ofptype type; + if (ofptype_pull(&type, pi->reply) + || type != OFPTYPE_PORT_DESC_STATS_REPLY) { + ovs_fatal(0, "received bad reply: %s", + ofp_to_string(pi->reply->data, pi->reply->size, + verbosity + 1)); } - ofpbuf_delete(reply); - } - return found; + pi->more = (ofpmp_flags(oh) & OFPSF_REPLY_MORE) != 0; + } } -static bool -str_to_ofp(const char *s, ofp_port_t *ofp_port) +/* Destroys iterator 'pi'. */ +static void +port_iterator_destroy(struct port_iterator *pi) { - bool ret; - uint32_t port_; + if (pi) { + while (pi->variant == PI_PORT_DESC && pi->more) { + /* Drain vconn's queue of any other replies for this request. */ + struct ofputil_phy_port pp; + port_iterator_next(pi, &pp); + } - ret = str_to_uint(s, 10, &port_); - *ofp_port = u16_to_ofp(port_); - return ret; + ofpbuf_delete(pi->reply); + } } /* Opens a connection to 'vconn_name', fetches the port structure for @@ -852,7 +957,7 @@ fetch_ofputil_phy_port(const char *vconn_name, const char *port_name, { struct vconn *vconn; ofp_port_t port_no; - bool found; + bool found = false; /* Try to interpret the argument as a port number. */ if (!str_to_ofp(port_name, &port_no)) { @@ -863,9 +968,16 @@ fetch_ofputil_phy_port(const char *vconn_name, const char *port_name, * OFPT_FEATURES_REPLY message. OpenFlow 1.3 and later versions put it * into the OFPST_PORT_DESC reply. Try it the correct way. */ open_vconn(vconn_name, &vconn); - found = (vconn_get_version(vconn) < OFP13_VERSION - ? fetch_port_by_features(vconn, port_name, port_no, pp) - : fetch_port_by_stats(vconn, port_name, port_no, pp)); + struct port_iterator pi; + for (port_iterator_init(&pi, vconn); port_iterator_next(&pi, pp); ) { + if (port_no != OFPP_NONE + ? port_no == pp->port_no + : !strcmp(pp->name, port_name)) { + found = true; + break; + } + } + port_iterator_destroy(&pi); vconn_close(vconn); if (!found) { @@ -974,7 +1086,7 @@ ofctl_dump_flows__(int argc, char *argv[], bool aggregate) struct vconn *vconn; vconn = prepare_dump_flows(argc, argv, aggregate, &request); - dump_stats_transaction(vconn, request); + dump_transaction(vconn, request); vconn_close(vconn); } @@ -1023,10 +1135,10 @@ compare_flows(const void *afs_, const void *bfs_) } static void -ofctl_dump_flows(int argc, char *argv[]) +ofctl_dump_flows(struct ovs_cmdl_context *ctx) { if (!n_criteria) { - ofctl_dump_flows__(argc, argv, false); + ofctl_dump_flows__(ctx->argc, ctx->argv, false); return; } else { struct ofputil_flow_stats *fses; @@ -1039,7 +1151,7 @@ ofctl_dump_flows(int argc, char *argv[]) struct ds s; size_t i; - vconn = prepare_dump_flows(argc, argv, false, &request); + vconn = prepare_dump_flows(ctx->argc, ctx->argv, false, &request); send_xid = ((struct ofp_header *) request->data)->xid; send_openflow_buffer(vconn, request); @@ -1084,53 +1196,76 @@ ofctl_dump_flows(int argc, char *argv[]) } static void -ofctl_dump_aggregate(int argc, char *argv[]) +ofctl_dump_aggregate(struct ovs_cmdl_context *ctx) { - ofctl_dump_flows__(argc, argv, true); + ofctl_dump_flows__(ctx->argc, ctx->argv, true); } static void -ofctl_queue_stats(int argc, char *argv[]) +ofctl_queue_stats(struct ovs_cmdl_context *ctx) { struct ofpbuf *request; struct vconn *vconn; struct ofputil_queue_stats_request oqs; - open_vconn(argv[1], &vconn); + open_vconn(ctx->argv[1], &vconn); - if (argc > 2 && argv[2][0] && strcasecmp(argv[2], "all")) { - oqs.port_no = str_to_port_no(argv[1], argv[2]); + if (ctx->argc > 2 && ctx->argv[2][0] && strcasecmp(ctx->argv[2], "all")) { + oqs.port_no = str_to_port_no(ctx->argv[1], ctx->argv[2]); } else { oqs.port_no = OFPP_ANY; } - if (argc > 3 && argv[3][0] && strcasecmp(argv[3], "all")) { - oqs.queue_id = atoi(argv[3]); + if (ctx->argc > 3 && ctx->argv[3][0] && strcasecmp(ctx->argv[3], "all")) { + oqs.queue_id = atoi(ctx->argv[3]); } else { oqs.queue_id = OFPQ_ALL; } request = ofputil_encode_queue_stats_request(vconn_get_version(vconn), &oqs); - dump_stats_transaction(vconn, request); + dump_transaction(vconn, request); vconn_close(vconn); } static void -ofctl_queue_get_config(int argc OVS_UNUSED, char *argv[]) +ofctl_queue_get_config(struct ovs_cmdl_context *ctx) { - const char *vconn_name = argv[1]; - const char *port_name = argv[2]; - enum ofputil_protocol protocol; - enum ofp_version version; - struct ofpbuf *request; + const char *vconn_name = ctx->argv[1]; + const char *port_name = ctx->argc > 2 ? ctx->argv[2] : "any"; + ofp_port_t port = str_to_port_no(vconn_name, port_name); + const char *queue_name = ctx->argc > 3 ? ctx->argv[3] : "all"; + uint32_t queue = (!strcasecmp(queue_name, "all") + ? OFPQ_ALL + : atoi(queue_name)); struct vconn *vconn; - ofp_port_t port; - - port = str_to_port_no(vconn_name, port_name); - protocol = open_vconn(vconn_name, &vconn); - version = ofputil_protocol_to_ofp_version(protocol); - request = ofputil_encode_queue_get_config_request(version, port); - dump_transaction(vconn, request); + enum ofputil_protocol protocol = open_vconn(vconn_name, &vconn); + enum ofp_version version = ofputil_protocol_to_ofp_version(protocol); + if (port == OFPP_ANY && version == OFP10_VERSION) { + /* The user requested all queues on all ports. OpenFlow 1.0 only + * supports getting queues for an individual port, so to implement the + * user's request we have to get a list of all the ports. + * + * We use a second vconn to avoid having to accumulate a list of all of + * the ports. */ + struct vconn *vconn2; + enum ofputil_protocol protocol2 = open_vconn(vconn_name, &vconn2); + enum ofp_version version2 = ofputil_protocol_to_ofp_version(protocol2); + + struct port_iterator pi; + struct ofputil_phy_port pp; + for (port_iterator_init(&pi, vconn); port_iterator_next(&pi, &pp); ) { + if (ofp_to_u16(pp.port_no) < ofp_to_u16(OFPP_MAX)) { + dump_transaction(vconn2, + ofputil_encode_queue_get_config_request( + version2, pp.port_no, queue)); + } + } + port_iterator_destroy(&pi); + vconn_close(vconn2); + } else { + dump_transaction(vconn, ofputil_encode_queue_get_config_request( + version, port, queue)); + } vconn_close(vconn); } @@ -1171,6 +1306,34 @@ open_vconn_for_flow_mod(const char *remote, struct vconn **vconnp, "formats (%s)", usable_s); } +static void +bundle_flow_mod__(const char *remote, struct ofputil_flow_mod *fms, + size_t n_fms, enum ofputil_protocol usable_protocols) +{ + enum ofputil_protocol protocol; + struct vconn *vconn; + struct ovs_list requests; + size_t i; + + list_init(&requests); + + /* Bundles need OpenFlow 1.4+. */ + usable_protocols &= OFPUTIL_P_OF14_UP; + protocol = open_vconn_for_flow_mod(remote, &vconn, usable_protocols); + + for (i = 0; i < n_fms; i++) { + struct ofputil_flow_mod *fm = &fms[i]; + struct ofpbuf *request = ofputil_encode_flow_mod(fm, protocol); + + list_push_back(&requests, &request->list_node); + free(CONST_CAST(struct ofpact *, fm->ofpacts)); + } + + bundle_transact(vconn, &requests, OFPBF_ORDERED | OFPBF_ATOMIC); + ofpbuf_list_delete(&requests); + vconn_close(vconn); +} + static void ofctl_flow_mod__(const char *remote, struct ofputil_flow_mod *fms, size_t n_fms, enum ofputil_protocol usable_protocols) @@ -1179,6 +1342,11 @@ ofctl_flow_mod__(const char *remote, struct ofputil_flow_mod *fms, struct vconn *vconn; size_t i; + if (bundle) { + bundle_flow_mod__(remote, fms, n_fms, usable_protocols); + return; + } + protocol = open_vconn_for_flow_mod(remote, &vconn, usable_protocols); for (i = 0; i < n_fms; i++) { @@ -1191,13 +1359,19 @@ ofctl_flow_mod__(const char *remote, struct ofputil_flow_mod *fms, } static void -ofctl_flow_mod_file(int argc OVS_UNUSED, char *argv[], uint16_t command) +ofctl_flow_mod_file(int argc OVS_UNUSED, char *argv[], int command) { enum ofputil_protocol usable_protocols; struct ofputil_flow_mod *fms = NULL; size_t n_fms = 0; char *error; + if (command == OFPFC_ADD) { + /* Allow the file to specify a mix of commands. If none specified at + * the beginning of any given line, then the default is OFPFC_ADD, so + * this is backwards compatible. */ + command = -2; + } error = parse_ofp_flow_mod_file(argv[2], command, &fms, &n_fms, &usable_protocols); if (error) { @@ -1227,67 +1401,80 @@ ofctl_flow_mod(int argc, char *argv[], uint16_t command) } static void -ofctl_add_flow(int argc, char *argv[]) +ofctl_add_flow(struct ovs_cmdl_context *ctx) { - ofctl_flow_mod(argc, argv, OFPFC_ADD); + ofctl_flow_mod(ctx->argc, ctx->argv, OFPFC_ADD); } static void -ofctl_add_flows(int argc, char *argv[]) +ofctl_add_flows(struct ovs_cmdl_context *ctx) { - ofctl_flow_mod_file(argc, argv, OFPFC_ADD); + ofctl_flow_mod_file(ctx->argc, ctx->argv, OFPFC_ADD); } static void -ofctl_mod_flows(int argc, char *argv[]) +ofctl_mod_flows(struct ovs_cmdl_context *ctx) { - ofctl_flow_mod(argc, argv, strict ? OFPFC_MODIFY_STRICT : OFPFC_MODIFY); + ofctl_flow_mod(ctx->argc, ctx->argv, strict ? OFPFC_MODIFY_STRICT : OFPFC_MODIFY); } static void -ofctl_del_flows(int argc, char *argv[]) +ofctl_del_flows(struct ovs_cmdl_context *ctx) { - ofctl_flow_mod(argc, argv, strict ? OFPFC_DELETE_STRICT : OFPFC_DELETE); + ofctl_flow_mod(ctx->argc, ctx->argv, strict ? OFPFC_DELETE_STRICT : OFPFC_DELETE); } -static void +static bool set_packet_in_format(struct vconn *vconn, - enum nx_packet_in_format packet_in_format) + enum nx_packet_in_format packet_in_format, + bool must_succeed) { struct ofpbuf *spif; spif = ofputil_make_set_packet_in_format(vconn_get_version(vconn), packet_in_format); - transact_noreply(vconn, spif); - VLOG_DBG("%s: using user-specified packet in format %s", - vconn_get_name(vconn), - ofputil_packet_in_format_to_string(packet_in_format)); + if (must_succeed) { + transact_noreply(vconn, spif); + } else { + struct ofpbuf *reply; + + run(vconn_transact_noreply(vconn, spif, &reply), + "talking to %s", vconn_get_name(vconn)); + if (reply) { + char *s = ofp_to_string(reply->data, reply->size, 2); + VLOG_DBG("%s: failed to set packet in format to nx_packet_in, " + "controller replied: %s.", + vconn_get_name(vconn), s); + free(s); + ofpbuf_delete(reply); + + return false; + } else { + VLOG_DBG("%s: using user-specified packet in format %s", + vconn_get_name(vconn), + ofputil_packet_in_format_to_string(packet_in_format)); + } + } + return true; } static int monitor_set_invalid_ttl_to_controller(struct vconn *vconn) { - struct ofp_switch_config config; - enum ofp_config_flags flags; + struct ofputil_switch_config config; fetch_switch_config(vconn, &config); - flags = ntohs(config.flags); - if (!(flags & OFPC_INVALID_TTL_TO_CONTROLLER)) { - /* Set the invalid ttl config. */ - flags |= OFPC_INVALID_TTL_TO_CONTROLLER; - - config.flags = htons(flags); + if (!config.invalid_ttl_to_controller) { + config.invalid_ttl_to_controller = 1; set_switch_config(vconn, &config); /* Then retrieve the configuration to see if it really took. OpenFlow - * doesn't define error reporting for bad modes, so this is all we can - * do. */ + * has ill-defined error reporting for bad flags, so this is about the + * best we can do. */ fetch_switch_config(vconn, &config); - flags = ntohs(config.flags); - if (!(flags & OFPC_INVALID_TTL_TO_CONTROLLER)) { + if (!config.invalid_ttl_to_controller) { ovs_fatal(0, "setting invalid_ttl_to_controller failed (this " - "switch probably doesn't support mode)"); - return -EOPNOTSUPP; + "switch probably doesn't support this flag)"); } } return 0; @@ -1457,7 +1644,7 @@ monitor_vconn(struct vconn *vconn, bool reply_to_echo_requests) 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"); @@ -1542,21 +1729,43 @@ monitor_vconn(struct vconn *vconn, bool reply_to_echo_requests) } static void -ofctl_monitor(int argc, char *argv[]) +ofctl_monitor(struct ovs_cmdl_context *ctx) { struct vconn *vconn; int i; enum ofputil_protocol usable_protocols; - open_vconn(argv[1], &vconn); - for (i = 2; i < argc; i++) { - const char *arg = argv[i]; + /* If the user wants the invalid_ttl_to_controller feature, limit the + * OpenFlow versions to those that support that feature. (Support in + * OpenFlow 1.0 is an Open vSwitch extension.) */ + for (i = 2; i < ctx->argc; i++) { + if (!strcmp(ctx->argv[i], "invalid_ttl")) { + uint32_t usable_versions = ((1u << OFP10_VERSION) | + (1u << OFP11_VERSION) | + (1u << OFP12_VERSION)); + 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, + usable_versions); + ovs_fatal(0, "invalid_ttl requires one of the OpenFlow " + "versions %s but none is enabled (use -O)", + ds_cstr(&versions)); + } + mask_allowed_ofp_versions(usable_versions); + break; + } + } + + open_vconn(ctx->argv[1], &vconn); + for (i = 2; i < ctx->argc; i++) { + const char *arg = ctx->argv[i]; if (isdigit((unsigned char) *arg)) { - struct ofp_switch_config config; + struct ofputil_switch_config config; fetch_switch_config(vconn, &config); - config.miss_send_len = htons(atoi(arg)); + config.miss_send_len = atoi(arg); set_switch_config(vconn, &config); } else if (!strcmp(arg, "invalid_ttl")) { monitor_set_invalid_ttl_to_controller(vconn); @@ -1573,7 +1782,7 @@ ofctl_monitor(int argc, char *argv[]) msg = ofpbuf_new(0); ofputil_append_flow_monitor_request(&fmr, msg); - dump_stats_transaction(vconn, msg); + dump_transaction(vconn, msg); fflush(stdout); } else { ovs_fatal(0, "%s: unsupported \"monitor\" argument", arg); @@ -1581,36 +1790,18 @@ ofctl_monitor(int argc, char *argv[]) } if (preferred_packet_in_format >= 0) { - set_packet_in_format(vconn, preferred_packet_in_format); + /* A particular packet-in format was requested, so we must set it. */ + set_packet_in_format(vconn, preferred_packet_in_format, true); } else { - enum ofp_version version = vconn_get_version(vconn); - - switch (version) { - case OFP10_VERSION: { - struct ofpbuf *spif, *reply; - - spif = ofputil_make_set_packet_in_format(vconn_get_version(vconn), - NXPIF_NXM); - run(vconn_transact_noreply(vconn, spif, &reply), - "talking to %s", vconn_get_name(vconn)); - if (reply) { - char *s = ofp_to_string(reply->data, reply->size, 2); - VLOG_DBG("%s: failed to set packet in format to nxm, controller" - " replied: %s. Falling back to the switch default.", - vconn_get_name(vconn), s); - free(s); - ofpbuf_delete(reply); + /* Otherwise, we always prefer NXT_PACKET_IN2. */ + if (!set_packet_in_format(vconn, NXPIF_NXT_PACKET_IN2, false)) { + /* We can't get NXT_PACKET_IN2. For OpenFlow 1.0 only, request + * NXT_PACKET_IN. (Before 2.6, Open vSwitch will accept a request + * for NXT_PACKET_IN with OF1.1+, but even after that it still + * sends packet-ins in the OpenFlow native format.) */ + if (vconn_get_version(vconn) == OFP10_VERSION) { + set_packet_in_format(vconn, NXPIF_NXT_PACKET_IN, false); } - break; - } - case OFP11_VERSION: - case OFP12_VERSION: - case OFP13_VERSION: - case OFP14_VERSION: - case OFP15_VERSION: - break; - default: - OVS_NOT_REACHED(); } } @@ -1618,53 +1809,53 @@ ofctl_monitor(int argc, char *argv[]) } static void -ofctl_snoop(int argc OVS_UNUSED, char *argv[]) +ofctl_snoop(struct ovs_cmdl_context *ctx) { struct vconn *vconn; - open_vconn__(argv[1], SNOOP, &vconn); + open_vconn__(ctx->argv[1], SNOOP, &vconn); monitor_vconn(vconn, false); } static void -ofctl_dump_ports(int argc, char *argv[]) +ofctl_dump_ports(struct ovs_cmdl_context *ctx) { struct ofpbuf *request; struct vconn *vconn; ofp_port_t port; - open_vconn(argv[1], &vconn); - port = argc > 2 ? str_to_port_no(argv[1], argv[2]) : OFPP_ANY; + open_vconn(ctx->argv[1], &vconn); + port = ctx->argc > 2 ? str_to_port_no(ctx->argv[1], ctx->argv[2]) : OFPP_ANY; request = ofputil_encode_dump_ports_request(vconn_get_version(vconn), port); - dump_stats_transaction(vconn, request); + dump_transaction(vconn, request); vconn_close(vconn); } static void -ofctl_dump_ports_desc(int argc OVS_UNUSED, char *argv[]) +ofctl_dump_ports_desc(struct ovs_cmdl_context *ctx) { struct ofpbuf *request; struct vconn *vconn; ofp_port_t port; - open_vconn(argv[1], &vconn); - port = argc > 2 ? str_to_port_no(argv[1], argv[2]) : OFPP_ANY; + open_vconn(ctx->argv[1], &vconn); + port = ctx->argc > 2 ? str_to_port_no(ctx->argv[1], ctx->argv[2]) : OFPP_ANY; request = ofputil_encode_port_desc_stats_request(vconn_get_version(vconn), port); - dump_stats_transaction(vconn, request); + dump_transaction(vconn, request); vconn_close(vconn); } static void -ofctl_probe(int argc OVS_UNUSED, char *argv[]) +ofctl_probe(struct ovs_cmdl_context *ctx) { struct ofpbuf *request; struct vconn *vconn; struct ofpbuf *reply; - open_vconn(argv[1], &vconn); + open_vconn(ctx->argv[1], &vconn); request = make_echo_request(vconn_get_version(vconn)); - run(vconn_transact(vconn, request, &reply), "talking to %s", argv[1]); + run(vconn_transact(vconn, request, &reply), "talking to %s", ctx->argv[1]); if (reply->size != sizeof(struct ofp_header)) { ovs_fatal(0, "reply does not match request"); } @@ -1673,7 +1864,7 @@ ofctl_probe(int argc OVS_UNUSED, char *argv[]) } static void -ofctl_packet_out(int argc, char *argv[]) +ofctl_packet_out(struct ovs_cmdl_context *ctx) { enum ofputil_protocol protocol; struct ofputil_packet_out po; @@ -1684,23 +1875,23 @@ ofctl_packet_out(int argc, char *argv[]) enum ofputil_protocol usable_protocols; /* XXX: Use in proto selection */ ofpbuf_init(&ofpacts, 64); - error = ofpacts_parse_actions(argv[3], &ofpacts, &usable_protocols); + error = ofpacts_parse_actions(ctx->argv[3], &ofpacts, &usable_protocols); if (error) { ovs_fatal(0, "%s", error); } po.buffer_id = UINT32_MAX; - po.in_port = str_to_port_no(argv[1], argv[2]); + po.in_port = str_to_port_no(ctx->argv[1], ctx->argv[2]); po.ofpacts = ofpacts.data; po.ofpacts_len = ofpacts.size; - protocol = open_vconn(argv[1], &vconn); - for (i = 4; i < argc; i++) { + protocol = open_vconn(ctx->argv[1], &vconn); + for (i = 4; i < ctx->argc; i++) { struct dp_packet *packet; struct ofpbuf *opo; const char *error_msg; - error_msg = eth_from_hex(argv[i], &packet); + error_msg = eth_from_hex(ctx->argv[i], &packet); if (error_msg) { ovs_fatal(0, "%s", error_msg); } @@ -1716,7 +1907,7 @@ ofctl_packet_out(int argc, char *argv[]) } static void -ofctl_mod_port(int argc OVS_UNUSED, char *argv[]) +ofctl_mod_port(struct ovs_cmdl_context *ctx) { struct ofp_config_flag { const char *name; /* The flag's name. */ @@ -1742,22 +1933,22 @@ ofctl_mod_port(int argc OVS_UNUSED, char *argv[]) const char *command; bool not; - fetch_ofputil_phy_port(argv[1], argv[2], &pp); + 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; - if (!strncasecmp(argv[3], "no-", 3)) { - command = argv[3] + 3; + if (!strncasecmp(ctx->argv[3], "no-", 3)) { + command = ctx->argv[3] + 3; not = true; - } else if (!strncasecmp(argv[3], "no", 2)) { - command = argv[3] + 2; + } else if (!strncasecmp(ctx->argv[3], "no", 2)) { + command = ctx->argv[3] + 2; not = true; } else { - command = argv[3]; + command = ctx->argv[3]; not = false; } for (flag = flags; flag < &flags[ARRAY_SIZE(flags)]; flag++) { @@ -1767,99 +1958,174 @@ ofctl_mod_port(int argc OVS_UNUSED, char *argv[]) goto found; } } - ovs_fatal(0, "unknown mod-port command '%s'", argv[3]); + ovs_fatal(0, "unknown mod-port command '%s'", ctx->argv[3]); found: - protocol = open_vconn(argv[1], &vconn); + protocol = open_vconn(ctx->argv[1], &vconn); transact_noreply(vconn, ofputil_encode_port_mod(&pm, protocol)); vconn_close(vconn); } +/* This function uses OFPMP14_TABLE_DESC request to get the current + * table configuration from switch. The function then modifies + * only that table-config property, which has been requested. */ static void -ofctl_mod_table(int argc OVS_UNUSED, char *argv[]) +fetch_table_desc(struct vconn *vconn, struct ofputil_table_mod *tm, + struct ofputil_table_desc *td) { - enum ofputil_protocol protocol, usable_protocols; + struct ofpbuf *request; + ovs_be32 send_xid; + bool done = false; + bool found = false; + + request = ofputil_encode_table_desc_request(vconn_get_version(vconn)); + send_xid = ((struct ofp_header *) request->data)->xid; + 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) { + struct ofp_header *oh = reply->data; + struct ofpbuf b = ofpbuf_const_initializer(oh, ntohs(oh->length)); + + enum ofptype type; + if (ofptype_pull(&type, &b) + || type != OFPTYPE_TABLE_DESC_REPLY) { + ovs_fatal(0, "received bad reply: %s", + ofp_to_string(reply->data, reply->size, + verbosity + 1)); + } + uint16_t flags = ofpmp_flags(oh); + done = !(flags & OFPSF_REPLY_MORE); + if (found) { + /* We've already found the table desc consisting of current + * table configuration, but we need to drain the queue of + * any other replies for this request. */ + continue; + } + while (!ofputil_decode_table_desc(&b, td, oh->version)) { + if (td->table_id == tm->table_id) { + found = true; + break; + } + } + } else { + VLOG_DBG("received reply with xid %08"PRIx32" " + "!= expected %08"PRIx32, recv_xid, send_xid); + } + ofpbuf_delete(reply); + } + if (tm->eviction != OFPUTIL_TABLE_EVICTION_DEFAULT) { + tm->vacancy = td->vacancy; + tm->table_vacancy.vacancy_down = td->table_vacancy.vacancy_down; + tm->table_vacancy.vacancy_up = td->table_vacancy.vacancy_up; + } else if (tm->vacancy != OFPUTIL_TABLE_VACANCY_DEFAULT) { + tm->eviction = td->eviction; + tm->eviction_flags = td->eviction_flags; + } +} + +static void +ofctl_mod_table(struct ovs_cmdl_context *ctx) +{ + uint32_t usable_versions; struct ofputil_table_mod tm; struct vconn *vconn; char *error; int i; - error = parse_ofp_table_mod(&tm, argv[2], 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(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; + 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, usable_versions); + ovs_fatal(0, "table_mod '%s' requires one of the OpenFlow " + "versions %s", + ctx->argv[3], ds_cstr(&versions)); + } + mask_allowed_ofp_versions(usable_versions); + enum ofputil_protocol protocol = open_vconn(ctx->argv[1], &vconn); + + /* For OpenFlow 1.4+, ovs-ofctl mod-table should not affect table-config + * properties that the user didn't ask to change, so it is necessary to + * restore the current configuration of table-config parameters using + * OFPMP14_TABLE_DESC request. */ + if ((allowed_versions & (1u << OFP14_VERSION)) || + (allowed_versions & (1u << OFP15_VERSION))) { + struct ofputil_table_desc td; + + if (tm.table_id == OFPTT_ALL) { + for (i = 0; i < OFPTT_MAX; i++) { + tm.table_id = i; + fetch_table_desc(vconn, &tm, &td); + transact_noreply(vconn, + ofputil_encode_table_mod(&tm, protocol)); } + } else { + fetch_table_desc(vconn, &tm, &td); + transact_noreply(vconn, ofputil_encode_table_mod(&tm, protocol)); } + } else { + transact_noreply(vconn, ofputil_encode_table_mod(&tm, protocol)); } - - 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); - } - - transact_noreply(vconn, ofputil_encode_table_mod(&tm, protocol)); vconn_close(vconn); } static void -ofctl_get_frags(int argc OVS_UNUSED, char *argv[]) +ofctl_get_frags(struct ovs_cmdl_context *ctx) { - struct ofp_switch_config config; + struct ofputil_switch_config config; struct vconn *vconn; - open_vconn(argv[1], &vconn); + open_vconn(ctx->argv[1], &vconn); fetch_switch_config(vconn, &config); - puts(ofputil_frag_handling_to_string(ntohs(config.flags))); + puts(ofputil_frag_handling_to_string(config.frag)); vconn_close(vconn); } static void -ofctl_set_frags(int argc OVS_UNUSED, char *argv[]) +ofctl_set_frags(struct ovs_cmdl_context *ctx) { - struct ofp_switch_config config; - enum ofp_config_flags mode; + struct ofputil_switch_config config; + enum ofputil_frag_handling frag; struct vconn *vconn; - ovs_be16 flags; - if (!ofputil_frag_handling_from_string(argv[2], &mode)) { - ovs_fatal(0, "%s: unknown fragment handling mode", argv[2]); + if (!ofputil_frag_handling_from_string(ctx->argv[2], &frag)) { + ovs_fatal(0, "%s: unknown fragment handling mode", ctx->argv[2]); } - open_vconn(argv[1], &vconn); + open_vconn(ctx->argv[1], &vconn); fetch_switch_config(vconn, &config); - flags = htons(mode) | (config.flags & htons(~OFPC_FRAG_MASK)); - if (flags != config.flags) { + if (frag != config.frag) { /* Set the configuration. */ - config.flags = flags; + config.frag = frag; set_switch_config(vconn, &config); /* Then retrieve the configuration to see if it really took. OpenFlow - * doesn't define error reporting for bad modes, so this is all we can - * do. */ + * has ill-defined error reporting for bad flags, so this is about the + * best we can do. */ fetch_switch_config(vconn, &config); - if (flags != config.flags) { + if (frag != config.frag) { ovs_fatal(0, "%s: setting fragment handling mode failed (this " "switch probably doesn't support mode \"%s\")", - argv[1], ofputil_frag_handling_to_string(mode)); + ctx->argv[1], ofputil_frag_handling_to_string(frag)); } } vconn_close(vconn); } static void -ofctl_ofp_parse(int argc OVS_UNUSED, char *argv[]) +ofctl_ofp_parse(struct ovs_cmdl_context *ctx) { - const char *filename = argv[1]; + const char *filename = ctx->argv[1]; struct ofpbuf b; FILE *file; @@ -1925,16 +2191,16 @@ is_openflow_port(ovs_be16 port_, char *ports[]) } static void -ofctl_ofp_parse_pcap(int argc OVS_UNUSED, char *argv[]) +ofctl_ofp_parse_pcap(struct ovs_cmdl_context *ctx) { struct tcp_reader *reader; FILE *file; int error; bool first; - file = ovs_pcap_open(argv[1], "rb"); + file = ovs_pcap_open(ctx->argv[1], "rb"); if (!file) { - ovs_fatal(errno, "%s: open failed", argv[1]); + ovs_fatal(errno, "%s: open failed", ctx->argv[1]); } reader = tcp_reader_open(); @@ -1948,12 +2214,12 @@ ofctl_ofp_parse_pcap(int argc OVS_UNUSED, char *argv[]) if (error) { break; } - packet->md = PKT_METADATA_INITIALIZER(ODPP_NONE); + pkt_metadata_init(&packet->md, ODPP_NONE); flow_extract(packet, &flow); if (flow.dl_type == htons(ETH_TYPE_IP) && flow.nw_proto == IPPROTO_TCP - && (is_openflow_port(flow.tp_src, argv + 2) || - is_openflow_port(flow.tp_dst, argv + 2))) { + && (is_openflow_port(flow.tp_src, ctx->argv + 2) || + is_openflow_port(flow.tp_dst, ctx->argv + 2))) { struct dp_packet *payload = tcp_reader_run(reader, &flow, packet); if (payload) { while (dp_packet_size(payload) >= sizeof(struct ofp_header)) { @@ -1995,19 +2261,19 @@ ofctl_ofp_parse_pcap(int argc OVS_UNUSED, char *argv[]) } static void -ofctl_ping(int argc, char *argv[]) +ofctl_ping(struct ovs_cmdl_context *ctx) { size_t max_payload = 65535 - sizeof(struct ofp_header); unsigned int payload; struct vconn *vconn; int i; - payload = argc > 2 ? atoi(argv[2]) : 64; + payload = ctx->argc > 2 ? atoi(ctx->argv[2]) : 64; if (payload > max_payload) { ovs_fatal(0, "payload must be between 0 and %"PRIuSIZE" bytes", max_payload); } - open_vconn(argv[1], &vconn); + open_vconn(ctx->argv[1], &vconn); for (i = 0; i < 10; i++) { struct timeval start, end; struct ofpbuf *request, *reply; @@ -2033,7 +2299,7 @@ ofctl_ping(int argc, char *argv[]) ofp_print(stdout, reply, reply->size, verbosity + 2); } printf("%"PRIu32" bytes from %s: xid=%08"PRIx32" time=%.1f ms\n", - reply->size, argv[1], ntohl(rpy_hdr->xid), + reply->size, ctx->argv[1], ntohl(rpy_hdr->xid), (1000*(double)(end.tv_sec - start.tv_sec)) + (.001*(end.tv_usec - start.tv_usec))); ofpbuf_delete(request); @@ -2043,7 +2309,7 @@ ofctl_ping(int argc, char *argv[]) } static void -ofctl_benchmark(int argc OVS_UNUSED, char *argv[]) +ofctl_benchmark(struct ovs_cmdl_context *ctx) { size_t max_payload = 65535 - sizeof(struct ofp_header); struct timeval start, end; @@ -2053,18 +2319,18 @@ ofctl_benchmark(int argc OVS_UNUSED, char *argv[]) int count; int i; - payload_size = atoi(argv[2]); + payload_size = atoi(ctx->argv[2]); if (payload_size > max_payload) { ovs_fatal(0, "payload must be between 0 and %"PRIuSIZE" bytes", max_payload); } message_size = sizeof(struct ofp_header) + payload_size; - count = atoi(argv[3]); + count = atoi(ctx->argv[3]); printf("Sending %d packets * %u bytes (with header) = %u bytes total\n", count, message_size, count * message_size); - open_vconn(argv[1], &vconn); + open_vconn(ctx->argv[1], &vconn); xgettimeofday(&start); for (i = 0; i < count; i++) { struct ofpbuf *request, *reply; @@ -2155,43 +2421,43 @@ ofctl_group_mod(int argc, char *argv[], uint16_t command) } static void -ofctl_add_group(int argc, char *argv[]) +ofctl_add_group(struct ovs_cmdl_context *ctx) { - ofctl_group_mod(argc, argv, OFPGC11_ADD); + ofctl_group_mod(ctx->argc, ctx->argv, OFPGC11_ADD); } static void -ofctl_add_groups(int argc, char *argv[]) +ofctl_add_groups(struct ovs_cmdl_context *ctx) { - ofctl_group_mod_file(argc, argv, OFPGC11_ADD); + ofctl_group_mod_file(ctx->argc, ctx->argv, OFPGC11_ADD); } static void -ofctl_mod_group(int argc, char *argv[]) +ofctl_mod_group(struct ovs_cmdl_context *ctx) { - ofctl_group_mod(argc, argv, OFPGC11_MODIFY); + ofctl_group_mod(ctx->argc, ctx->argv, OFPGC11_MODIFY); } static void -ofctl_del_groups(int argc, char *argv[]) +ofctl_del_groups(struct ovs_cmdl_context *ctx) { - ofctl_group_mod(argc, argv, OFPGC11_DELETE); + ofctl_group_mod(ctx->argc, ctx->argv, OFPGC11_DELETE); } static void -ofctl_insert_bucket(int argc, char *argv[]) +ofctl_insert_bucket(struct ovs_cmdl_context *ctx) { - ofctl_group_mod(argc, argv, OFPGC15_INSERT_BUCKET); + ofctl_group_mod(ctx->argc, ctx->argv, OFPGC15_INSERT_BUCKET); } static void -ofctl_remove_bucket(int argc, char *argv[]) +ofctl_remove_bucket(struct ovs_cmdl_context *ctx) { - ofctl_group_mod(argc, argv, OFPGC15_REMOVE_BUCKET); + ofctl_group_mod(ctx->argc, ctx->argv, OFPGC15_REMOVE_BUCKET); } static void -ofctl_dump_group_stats(int argc, char *argv[]) +ofctl_dump_group_stats(struct ovs_cmdl_context *ctx) { enum ofputil_protocol usable_protocols; struct ofputil_group_mod gm; @@ -2203,7 +2469,7 @@ ofctl_dump_group_stats(int argc, char *argv[]) memset(&gm, 0, sizeof gm); error = parse_ofp_group_mod_str(&gm, OFPGC11_DELETE, - argc > 2 ? argv[2] : "", + ctx->argc > 2 ? ctx->argv[2] : "", &usable_protocols); if (error) { ovs_fatal(0, "%s", error); @@ -2211,67 +2477,154 @@ ofctl_dump_group_stats(int argc, char *argv[]) group_id = gm.group_id; - open_vconn(argv[1], &vconn); + open_vconn(ctx->argv[1], &vconn); request = ofputil_encode_group_stats_request(vconn_get_version(vconn), group_id); if (request) { - dump_stats_transaction(vconn, request); + dump_transaction(vconn, request); } vconn_close(vconn); } static void -ofctl_dump_group_desc(int argc OVS_UNUSED, char *argv[]) +ofctl_dump_group_desc(struct ovs_cmdl_context *ctx) { struct ofpbuf *request; struct vconn *vconn; uint32_t group_id; - open_vconn(argv[1], &vconn); + open_vconn(ctx->argv[1], &vconn); - if (argc < 3 || !ofputil_group_from_string(argv[2], &group_id)) { - group_id = OFPG11_ALL; + if (ctx->argc < 3 || !ofputil_group_from_string(ctx->argv[2], &group_id)) { + group_id = OFPG_ALL; } request = ofputil_encode_group_desc_request(vconn_get_version(vconn), group_id); if (request) { - dump_stats_transaction(vconn, request); + dump_transaction(vconn, request); } vconn_close(vconn); } static void -ofctl_dump_group_features(int argc OVS_UNUSED, char *argv[]) +ofctl_dump_group_features(struct ovs_cmdl_context *ctx) { struct ofpbuf *request; struct vconn *vconn; - open_vconn(argv[1], &vconn); + open_vconn(ctx->argv[1], &vconn); request = ofputil_encode_group_features_request(vconn_get_version(vconn)); if (request) { - dump_stats_transaction(vconn, request); + dump_transaction(vconn, request); } vconn_close(vconn); } static void -ofctl_help(int argc OVS_UNUSED, char *argv[] OVS_UNUSED) +ofctl_tlv_mod(struct ovs_cmdl_context *ctx, uint16_t command) +{ + enum ofputil_protocol usable_protocols; + enum ofputil_protocol protocol; + struct ofputil_tlv_table_mod ttm; + char *error; + enum ofp_version version; + struct ofpbuf *request; + struct vconn *vconn; + + error = parse_ofp_tlv_table_mod_str(&ttm, command, ctx->argc > 2 ? + ctx->argv[2] : "", + &usable_protocols); + if (error) { + ovs_fatal(0, "%s", error); + } + + protocol = open_vconn_for_flow_mod(ctx->argv[1], &vconn, usable_protocols); + version = ofputil_protocol_to_ofp_version(protocol); + + request = ofputil_encode_tlv_table_mod(version, &ttm); + if (request) { + transact_noreply(vconn, request); + } + + vconn_close(vconn); + ofputil_uninit_tlv_table(&ttm.mappings); +} + +static void +ofctl_add_tlv_map(struct ovs_cmdl_context *ctx) +{ + ofctl_tlv_mod(ctx, NXTTMC_ADD); +} + +static void +ofctl_del_tlv_map(struct ovs_cmdl_context *ctx) +{ + ofctl_tlv_mod(ctx, ctx->argc > 2 ? NXTTMC_DELETE : NXTTMC_CLEAR); +} + +static void +ofctl_dump_tlv_map(struct ovs_cmdl_context *ctx) +{ + dump_trivial_transaction(ctx->argv[1], OFPRAW_NXT_TLV_TABLE_REQUEST); +} + +static void +ofctl_help(struct ovs_cmdl_context *ctx OVS_UNUSED) { usage(); } static void -ofctl_list_commands(int argc OVS_UNUSED, char *argv[] OVS_UNUSED) +ofctl_list_commands(struct ovs_cmdl_context *ctx OVS_UNUSED) { - print_commands(get_all_commands()); + ovs_cmdl_print_commands(get_all_commands()); } /* replace-flows and diff-flows commands. */ +struct flow_tables { + struct classifier tables[OFPTT_MAX + 1]; +}; + +#define FOR_EACH_TABLE(CLS, TABLES) \ + for ((CLS) = (TABLES)->tables; \ + (CLS) < &(TABLES)->tables[ARRAY_SIZE((TABLES)->tables)]; \ + (CLS)++) + +static void +flow_tables_init(struct flow_tables *tables) +{ + struct classifier *cls; + + FOR_EACH_TABLE (cls, tables) { + classifier_init(cls, NULL); + } +} + +static void +flow_tables_defer(struct flow_tables *tables) +{ + struct classifier *cls; + + FOR_EACH_TABLE (cls, tables) { + classifier_defer(cls); + } +} + +static void +flow_tables_publish(struct flow_tables *tables) +{ + struct classifier *cls; + + FOR_EACH_TABLE (cls, tables) { + classifier_publish(cls); + } +} + /* A flow table entry, possibly with two different versions. */ struct fte { struct cls_rule rule; /* Within a "struct classifier". */ @@ -2287,6 +2640,7 @@ struct fte_version { uint16_t flags; struct ofpact *ofpacts; size_t ofpacts_len; + uint8_t table_id; }; /* Frees 'version' and the data that it owns. */ @@ -2310,6 +2664,7 @@ fte_version_equals(const struct fte_version *a, const struct fte_version *b) && a->idle_timeout == b->idle_timeout && a->hard_timeout == b->hard_timeout && a->importance == b->importance + && a->table_id == b->table_id && ofpacts_equal(a->ofpacts, a->ofpacts_len, b->ofpacts, b->ofpacts_len)); } @@ -2326,6 +2681,9 @@ fte_version_format(const struct fte *fte, int index, struct ds *s) return; } + if (version->table_id) { + ds_put_format(s, "table=%"PRIu8" ", version->table_id); + } cls_rule_format(&fte->rule, s); if (version->cookie != htonll(0)) { ds_put_format(s, " cookie=0x%"PRIx64, ntohll(version->cookie)); @@ -2364,36 +2722,42 @@ fte_free(struct fte *fte) } } -/* Frees all of the FTEs within 'cls'. */ +/* Frees all of the FTEs within 'tables'. */ static void -fte_free_all(struct classifier *cls) +fte_free_all(struct flow_tables *tables) { - struct fte *fte; + struct classifier *cls; - classifier_defer(cls); - CLS_FOR_EACH (fte, rule, cls) { - classifier_remove(cls, &fte->rule); - ovsrcu_postpone(fte_free, fte); + FOR_EACH_TABLE (cls, tables) { + struct fte *fte; + + classifier_defer(cls); + CLS_FOR_EACH (fte, rule, cls) { + classifier_remove(cls, &fte->rule); + ovsrcu_postpone(fte_free, fte); + } + classifier_destroy(cls); } - classifier_destroy(cls); } -/* Searches 'cls' for an FTE matching 'rule', inserting a new one if +/* Searches 'tables' for an FTE matching 'rule', inserting a new one if * necessary. Sets 'version' as the version of that rule with the given * 'index', replacing any existing version, if any. * * Takes ownership of 'version'. */ static void -fte_insert(struct classifier *cls, const struct match *match, +fte_insert(struct flow_tables *tables, const struct match *match, int priority, struct fte_version *version, int index) { + struct classifier *cls = &tables->tables[version->table_id]; struct fte *old, *fte; fte = xzalloc(sizeof *fte); 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; @@ -2402,11 +2766,12 @@ fte_insert(struct classifier *cls, const struct match *match, } } -/* Reads the flows in 'filename' as flow table entries in 'cls' for the version - * with the specified 'index'. Returns the flow formats able to represent the - * flows that were read. */ +/* Reads the flows in 'filename' as flow table entries in 'tables' for the + * version with the specified 'index'. Returns the flow formats able to + * represent the flows that were read. */ static enum ofputil_protocol -read_flows_from_file(const char *filename, struct classifier *cls, int index) +read_flows_from_file(const char *filename, struct flow_tables *tables, + int index) { enum ofputil_protocol usable_protocols; int line_number; @@ -2421,7 +2786,7 @@ read_flows_from_file(const char *filename, struct classifier *cls, int index) ds_init(&s); usable_protocols = OFPUTIL_P_ANY; line_number = 0; - classifier_defer(cls); + flow_tables_defer(tables); while (!ds_get_preprocessed_line(&s, file, &line_number)) { struct fte_version *version; struct ofputil_flow_mod fm; @@ -2443,10 +2808,11 @@ read_flows_from_file(const char *filename, struct classifier *cls, int index) | OFPUTIL_FF_EMERG); version->ofpacts = fm.ofpacts; version->ofpacts_len = fm.ofpacts_len; + version->table_id = fm.table_id != OFPTT_ALL ? fm.table_id : 0; - fte_insert(cls, &fm.match, fm.priority, version, index); + fte_insert(tables, &fm.match, fm.priority, version, index); } - classifier_publish(cls); + flow_tables_publish(tables); ds_destroy(&s); if (file != stdin) { @@ -2510,12 +2876,12 @@ recv_flow_stats_reply(struct vconn *vconn, ovs_be32 send_xid, } /* Reads the OpenFlow flow table from 'vconn', which has currently active flow - * format 'protocol', and adds them as flow table entries in 'cls' for the + * format 'protocol', and adds them as flow table entries in 'tables' for the * version with the specified 'index'. */ static void read_flows_from_switch(struct vconn *vconn, enum ofputil_protocol protocol, - struct classifier *cls, int index) + struct flow_tables *tables, int index) { struct ofputil_flow_stats_request fsr; struct ofputil_flow_stats fs; @@ -2527,6 +2893,7 @@ read_flows_from_switch(struct vconn *vconn, fsr.aggregate = false; match_init_catchall(&fsr.match); fsr.out_port = OFPP_ANY; + fsr.out_group = OFPG_ANY; fsr.table_id = 0xff; fsr.cookie = fsr.cookie_mask = htonll(0); request = ofputil_encode_flow_stats_request(&fsr, protocol); @@ -2535,7 +2902,7 @@ read_flows_from_switch(struct vconn *vconn, reply = NULL; ofpbuf_init(&ofpacts, 0); - classifier_defer(cls); + flow_tables_defer(tables); while (recv_flow_stats_reply(vconn, send_xid, &reply, &fs, &ofpacts)) { struct fte_version *version; @@ -2547,10 +2914,11 @@ read_flows_from_switch(struct vconn *vconn, version->flags = 0; version->ofpacts_len = fs.ofpacts_len; version->ofpacts = xmemdup(fs.ofpacts, fs.ofpacts_len); + version->table_id = fs.table_id; - fte_insert(cls, &fs.match, fs.priority, version, index); + fte_insert(tables, &fs.match, fs.priority, version, index); } - classifier_publish(cls); + flow_tables_publish(tables); ofpbuf_uninit(&ofpacts); } @@ -2559,23 +2927,24 @@ fte_make_flow_mod(const struct fte *fte, int index, uint16_t command, enum ofputil_protocol protocol, struct ovs_list *packets) { const struct fte_version *version = fte->versions[index]; - struct ofputil_flow_mod fm; struct ofpbuf *ofm; + struct ofputil_flow_mod fm = { + .priority = fte->rule.priority, + .new_cookie = version->cookie, + .modify_cookie = true, + .table_id = version->table_id, + .command = command, + .idle_timeout = version->idle_timeout, + .hard_timeout = version->hard_timeout, + .importance = version->importance, + .buffer_id = UINT32_MAX, + .out_port = OFPP_ANY, + .out_group = OFPG_ANY, + .flags = version->flags, + .delete_reason = OFPRR_DELETE, + }; minimatch_expand(&fte->rule.match, &fm.match); - fm.priority = fte->rule.priority; - fm.cookie = htonll(0); - fm.cookie_mask = htonll(0); - fm.new_cookie = version->cookie; - fm.modify_cookie = true; - fm.table_id = 0xff; - fm.command = command; - fm.idle_timeout = version->idle_timeout; - fm.hard_timeout = version->hard_timeout; - fm.importance = version->importance; - fm.buffer_id = UINT32_MAX; - fm.out_port = OFPP_ANY; - fm.flags = version->flags; if (command == OFPFC_ADD || command == OFPFC_MODIFY || command == OFPFC_MODIFY_STRICT) { fm.ofpacts = version->ofpacts; @@ -2584,109 +2953,122 @@ fte_make_flow_mod(const struct fte *fte, int index, uint16_t command, fm.ofpacts = NULL; fm.ofpacts_len = 0; } - fm.delete_reason = OFPRR_DELETE; ofm = ofputil_encode_flow_mod(&fm, protocol); list_push_back(packets, &ofm->list_node); } static void -ofctl_replace_flows(int argc OVS_UNUSED, char *argv[]) +ofctl_replace_flows(struct ovs_cmdl_context *ctx) { enum { FILE_IDX = 0, SWITCH_IDX = 1 }; enum ofputil_protocol usable_protocols, protocol; - struct classifier cls; + struct flow_tables tables; + struct classifier *cls; struct ovs_list requests; struct vconn *vconn; struct fte *fte; - classifier_init(&cls, NULL); - usable_protocols = read_flows_from_file(argv[2], &cls, FILE_IDX); + flow_tables_init(&tables); + usable_protocols = read_flows_from_file(ctx->argv[2], &tables, FILE_IDX); - protocol = open_vconn(argv[1], &vconn); + protocol = open_vconn(ctx->argv[1], &vconn); protocol = set_protocol_for_flow_dump(vconn, protocol, usable_protocols); - read_flows_from_switch(vconn, protocol, &cls, SWITCH_IDX); + read_flows_from_switch(vconn, protocol, &tables, SWITCH_IDX); list_init(&requests); - /* Delete flows that exist on the switch but not in the file. */ - CLS_FOR_EACH (fte, rule, &cls) { - struct fte_version *file_ver = fte->versions[FILE_IDX]; - struct fte_version *sw_ver = fte->versions[SWITCH_IDX]; + FOR_EACH_TABLE (cls, &tables) { + /* Delete flows that exist on the switch but not in the file. */ + CLS_FOR_EACH (fte, rule, cls) { + struct fte_version *file_ver = fte->versions[FILE_IDX]; + struct fte_version *sw_ver = fte->versions[SWITCH_IDX]; - if (sw_ver && !file_ver) { - fte_make_flow_mod(fte, SWITCH_IDX, OFPFC_DELETE_STRICT, - protocol, &requests); + if (sw_ver && !file_ver) { + fte_make_flow_mod(fte, SWITCH_IDX, OFPFC_DELETE_STRICT, + protocol, &requests); + } } - } - /* Add flows that exist in the file but not on the switch. - * Update flows that exist in both places but differ. */ - CLS_FOR_EACH (fte, rule, &cls) { - struct fte_version *file_ver = fte->versions[FILE_IDX]; - struct fte_version *sw_ver = fte->versions[SWITCH_IDX]; + /* Add flows that exist in the file but not on the switch. + * Update flows that exist in both places but differ. */ + CLS_FOR_EACH (fte, rule, cls) { + struct fte_version *file_ver = fte->versions[FILE_IDX]; + struct fte_version *sw_ver = fte->versions[SWITCH_IDX]; - if (file_ver - && (readd || !sw_ver || !fte_version_equals(sw_ver, file_ver))) { - fte_make_flow_mod(fte, FILE_IDX, OFPFC_ADD, protocol, &requests); + if (file_ver && + (readd || !sw_ver || !fte_version_equals(sw_ver, file_ver))) { + fte_make_flow_mod(fte, FILE_IDX, OFPFC_ADD, protocol, + &requests); + } } } - transact_multiple_noreply(vconn, &requests); + if (bundle) { + bundle_transact(vconn, &requests, OFPBF_ORDERED | OFPBF_ATOMIC); + } else { + transact_multiple_noreply(vconn, &requests); + } + + ofpbuf_list_delete(&requests); vconn_close(vconn); - fte_free_all(&cls); + fte_free_all(&tables); } static void -read_flows_from_source(const char *source, struct classifier *cls, int index) +read_flows_from_source(const char *source, struct flow_tables *tables, + int index) { struct stat s; if (source[0] == '/' || source[0] == '.' || (!strchr(source, ':') && !stat(source, &s))) { - read_flows_from_file(source, cls, index); + read_flows_from_file(source, tables, index); } else { enum ofputil_protocol protocol; struct vconn *vconn; protocol = open_vconn(source, &vconn); protocol = set_protocol_for_flow_dump(vconn, protocol, OFPUTIL_P_ANY); - read_flows_from_switch(vconn, protocol, cls, index); + read_flows_from_switch(vconn, protocol, tables, index); vconn_close(vconn); } } static void -ofctl_diff_flows(int argc OVS_UNUSED, char *argv[]) +ofctl_diff_flows(struct ovs_cmdl_context *ctx) { bool differences = false; - struct classifier cls; + struct flow_tables tables; + struct classifier *cls; struct ds a_s, b_s; struct fte *fte; - classifier_init(&cls, NULL); - read_flows_from_source(argv[1], &cls, 0); - read_flows_from_source(argv[2], &cls, 1); + flow_tables_init(&tables); + read_flows_from_source(ctx->argv[1], &tables, 0); + read_flows_from_source(ctx->argv[2], &tables, 1); ds_init(&a_s); ds_init(&b_s); - CLS_FOR_EACH (fte, rule, &cls) { - struct fte_version *a = fte->versions[0]; - struct fte_version *b = fte->versions[1]; - - if (!a || !b || !fte_version_equals(a, b)) { - fte_version_format(fte, 0, &a_s); - fte_version_format(fte, 1, &b_s); - if (strcmp(ds_cstr(&a_s), ds_cstr(&b_s))) { - if (a_s.length) { - printf("-%s", ds_cstr(&a_s)); - } - if (b_s.length) { - printf("+%s", ds_cstr(&b_s)); + FOR_EACH_TABLE (cls, &tables) { + CLS_FOR_EACH (fte, rule, cls) { + struct fte_version *a = fte->versions[0]; + struct fte_version *b = fte->versions[1]; + + if (!a || !b || !fte_version_equals(a, b)) { + fte_version_format(fte, 0, &a_s); + fte_version_format(fte, 1, &b_s); + if (strcmp(ds_cstr(&a_s), ds_cstr(&b_s))) { + if (a_s.length) { + printf("-%s", ds_cstr(&a_s)); + } + if (b_s.length) { + printf("+%s", ds_cstr(&b_s)); + } + differences = true; } - differences = true; } } } @@ -2694,7 +3076,7 @@ ofctl_diff_flows(int argc OVS_UNUSED, char *argv[]) ds_destroy(&a_s); ds_destroy(&b_s); - fte_free_all(&cls); + fte_free_all(&tables); if (differences) { exit(2); @@ -2751,49 +3133,48 @@ ofctl_meter_request__(const char *bridge, const char *str, protocol = open_vconn_for_flow_mod(bridge, &vconn, usable_protocols); version = ofputil_protocol_to_ofp_version(protocol); - transact_noreply(vconn, ofputil_encode_meter_request(version, - type, + dump_transaction(vconn, ofputil_encode_meter_request(version, type, mm.meter.meter_id)); vconn_close(vconn); } static void -ofctl_add_meter(int argc OVS_UNUSED, char *argv[]) +ofctl_add_meter(struct ovs_cmdl_context *ctx) { - ofctl_meter_mod__(argv[1], argv[2], OFPMC13_ADD); + ofctl_meter_mod__(ctx->argv[1], ctx->argv[2], OFPMC13_ADD); } static void -ofctl_mod_meter(int argc OVS_UNUSED, char *argv[]) +ofctl_mod_meter(struct ovs_cmdl_context *ctx) { - ofctl_meter_mod__(argv[1], argv[2], OFPMC13_MODIFY); + ofctl_meter_mod__(ctx->argv[1], ctx->argv[2], OFPMC13_MODIFY); } static void -ofctl_del_meters(int argc, char *argv[]) +ofctl_del_meters(struct ovs_cmdl_context *ctx) { - ofctl_meter_mod__(argv[1], argc > 2 ? argv[2] : NULL, OFPMC13_DELETE); + ofctl_meter_mod__(ctx->argv[1], ctx->argc > 2 ? ctx->argv[2] : NULL, OFPMC13_DELETE); } static void -ofctl_dump_meters(int argc, char *argv[]) +ofctl_dump_meters(struct ovs_cmdl_context *ctx) { - ofctl_meter_request__(argv[1], argc > 2 ? argv[2] : NULL, + ofctl_meter_request__(ctx->argv[1], ctx->argc > 2 ? ctx->argv[2] : NULL, OFPUTIL_METER_CONFIG); } static void -ofctl_meter_stats(int argc, char *argv[]) +ofctl_meter_stats(struct ovs_cmdl_context *ctx) { - ofctl_meter_request__(argv[1], argc > 2 ? argv[2] : NULL, + ofctl_meter_request__(ctx->argv[1], ctx->argc > 2 ? ctx->argv[2] : NULL, OFPUTIL_METER_STATS); } static void -ofctl_meter_features(int argc OVS_UNUSED, char *argv[]) +ofctl_meter_features(struct ovs_cmdl_context *ctx) { - ofctl_meter_request__(argv[1], NULL, OFPUTIL_METER_FEATURES); + ofctl_meter_request__(ctx->argv[1], NULL, OFPUTIL_METER_FEATURES); } @@ -2839,13 +3220,13 @@ ofctl_parse_flows__(struct ofputil_flow_mod *fms, size_t n_fms, /* "parse-flow FLOW": parses the argument as a flow (like add-flow) and prints * it back to stdout. */ static void -ofctl_parse_flow(int argc OVS_UNUSED, char *argv[]) +ofctl_parse_flow(struct ovs_cmdl_context *ctx) { enum ofputil_protocol usable_protocols; struct ofputil_flow_mod fm; char *error; - error = parse_ofp_flow_mod_str(&fm, argv[1], OFPFC_ADD, &usable_protocols); + error = parse_ofp_flow_mod_str(&fm, ctx->argv[1], OFPFC_ADD, &usable_protocols); if (error) { ovs_fatal(0, "%s", error); } @@ -2855,14 +3236,14 @@ ofctl_parse_flow(int argc OVS_UNUSED, char *argv[]) /* "parse-flows FILENAME": reads the named file as a sequence of flows (like * add-flows) and prints each of the flows back to stdout. */ static void -ofctl_parse_flows(int argc OVS_UNUSED, char *argv[]) +ofctl_parse_flows(struct ovs_cmdl_context *ctx) { enum ofputil_protocol usable_protocols; struct ofputil_flow_mod *fms = NULL; size_t n_fms = 0; char *error; - error = parse_ofp_flow_mod_file(argv[1], OFPFC_ADD, &fms, &n_fms, + error = parse_ofp_flow_mod_file(ctx->argv[1], OFPFC_ADD, &fms, &n_fms, &usable_protocols); if (error) { ovs_fatal(0, "%s", error); @@ -2945,7 +3326,7 @@ ofctl_parse_nxm__(bool oxm, enum ofp_version version) * stdin, does some internal fussing with them, and then prints them back as * strings on stdout. */ static void -ofctl_parse_nxm(int argc OVS_UNUSED, char *argv[] OVS_UNUSED) +ofctl_parse_nxm(struct ovs_cmdl_context *ctx OVS_UNUSED) { ofctl_parse_nxm__(false, 0); } @@ -2955,11 +3336,11 @@ ofctl_parse_nxm(int argc OVS_UNUSED, char *argv[] OVS_UNUSED) * them back as strings on stdout. VERSION must specify an OpenFlow version, * e.g. "OpenFlow12". */ static void -ofctl_parse_oxm(int argc OVS_UNUSED, char *argv[]) +ofctl_parse_oxm(struct ovs_cmdl_context *ctx) { - enum ofp_version version = ofputil_version_from_string(argv[1]); + enum ofp_version version = ofputil_version_from_string(ctx->argv[1]); if (version < OFP12_VERSION) { - ovs_fatal(0, "%s: not a valid version for OXM", argv[1]); + ovs_fatal(0, "%s: not a valid version for OXM", ctx->argv[1]); } ofctl_parse_nxm__(true, version); @@ -3041,7 +3422,7 @@ ofctl_parse_actions__(const char *version_s, bool instructions) error = ofpacts_check_consistency(ofpacts.data, ofpacts.size, &flow, OFPP_MAX, table_id ? atoi(table_id) : 0, - 255, protocol); + OFPTT_MAX + 1, protocol); } if (error) { printf("bad %s %s: %s\n\n", @@ -3086,9 +3467,9 @@ ofctl_parse_actions__(const char *version_s, bool instructions) * prints them as strings on stdout, and then converts them back to hex bytes * and prints any differences from the input. */ static void -ofctl_parse_actions(int argc OVS_UNUSED, char *argv[] OVS_UNUSED) +ofctl_parse_actions(struct ovs_cmdl_context *ctx) { - ofctl_parse_actions__(argv[1], false); + ofctl_parse_actions__(ctx->argv[1], false); } /* "parse-actions VERSION": reads a series of instruction specifications for @@ -3096,9 +3477,9 @@ ofctl_parse_actions(int argc OVS_UNUSED, char *argv[] OVS_UNUSED) * ofpacts, prints them as strings on stdout, and then converts them back to * hex bytes and prints any differences from the input. */ static void -ofctl_parse_instructions(int argc OVS_UNUSED, char *argv[] OVS_UNUSED) +ofctl_parse_instructions(struct ovs_cmdl_context *ctx) { - ofctl_parse_actions__(argv[1], true); + ofctl_parse_actions__(ctx->argv[1], true); } /* "parse-ofp10-match": reads a series of ofp10_match specifications as hex @@ -3111,7 +3492,7 @@ ofctl_parse_instructions(int argc OVS_UNUSED, char *argv[] OVS_UNUSED) * them back to hex bytes. ovs-ofctl actually sets "x"s to random bits when * it does the conversion to hex, to ensure that in fact they are ignored. */ static void -ofctl_parse_ofp10_match(int argc OVS_UNUSED, char *argv[] OVS_UNUSED) +ofctl_parse_ofp10_match(struct ovs_cmdl_context *ctx OVS_UNUSED) { struct ds expout; struct ds in; @@ -3185,7 +3566,7 @@ ofctl_parse_ofp10_match(int argc OVS_UNUSED, char *argv[] OVS_UNUSED) * on stdout, and then converts them back to hex bytes and prints any * differences from the input. */ static void -ofctl_parse_ofp11_match(int argc OVS_UNUSED, char *argv[] OVS_UNUSED) +ofctl_parse_ofp11_match(struct ovs_cmdl_context *ctx OVS_UNUSED) { struct ds in; @@ -3231,13 +3612,13 @@ ofctl_parse_ofp11_match(int argc OVS_UNUSED, char *argv[] OVS_UNUSED) /* "parse-pcap PCAP": read packets from PCAP and print their flows. */ static void -ofctl_parse_pcap(int argc OVS_UNUSED, char *argv[]) +ofctl_parse_pcap(struct ovs_cmdl_context *ctx) { FILE *pcap; - pcap = ovs_pcap_open(argv[1], "rb"); + pcap = ovs_pcap_open(ctx->argv[1], "rb"); if (!pcap) { - ovs_fatal(errno, "%s: open failed", argv[1]); + ovs_fatal(errno, "%s: open failed", ctx->argv[1]); } for (;;) { @@ -3249,10 +3630,10 @@ ofctl_parse_pcap(int argc OVS_UNUSED, char *argv[]) if (error == EOF) { break; } else if (error) { - ovs_fatal(error, "%s: read failed", argv[1]); + ovs_fatal(error, "%s: read failed", ctx->argv[1]); } - packet->md = PKT_METADATA_INITIALIZER(ODPP_NONE); + pkt_metadata_init(&packet->md, ODPP_NONE); flow_extract(packet, &flow); flow_print(stdout, &flow); putchar('\n'); @@ -3263,7 +3644,7 @@ ofctl_parse_pcap(int argc OVS_UNUSED, char *argv[]) /* "check-vlan VLAN_TCI VLAN_TCI_MASK": converts the specified vlan_tci and * mask values to and from various formats and prints the results. */ static void -ofctl_check_vlan(int argc OVS_UNUSED, char *argv[]) +ofctl_check_vlan(struct ovs_cmdl_context *ctx) { struct match match; @@ -3287,8 +3668,8 @@ ofctl_check_vlan(int argc OVS_UNUSED, char *argv[]) enum ofputil_protocol usable_protocols; /* Unused for now. */ match_init_catchall(&match); - match.flow.vlan_tci = htons(strtoul(argv[1], NULL, 16)); - match.wc.masks.vlan_tci = htons(strtoul(argv[2], NULL, 16)); + match.flow.vlan_tci = htons(strtoul(ctx->argv[1], NULL, 16)); + match.wc.masks.vlan_tci = htons(strtoul(ctx->argv[2], NULL, 16)); /* Convert to and from string. */ string_s = match_to_string(&match, OFP_DEFAULT_PRIORITY); @@ -3369,14 +3750,14 @@ ofctl_check_vlan(int argc OVS_UNUSED, char *argv[]) /* "print-error ENUM": Prints the type and code of ENUM for every OpenFlow * version. */ static void -ofctl_print_error(int argc OVS_UNUSED, char *argv[]) +ofctl_print_error(struct ovs_cmdl_context *ctx) { enum ofperr error; int version; - error = ofperr_from_name(argv[1]); + error = ofperr_from_name(ctx->argv[1]); if (!error) { - ovs_fatal(0, "unknown error \"%s\"", argv[1]); + ovs_fatal(0, "unknown error \"%s\"", ctx->argv[1]); } for (version = 0; version <= UINT8_MAX; version++) { @@ -3397,19 +3778,19 @@ ofctl_print_error(int argc OVS_UNUSED, char *argv[]) /* "encode-error-reply ENUM REQUEST": Encodes an error reply to REQUEST for the * error named ENUM and prints the error reply in hex. */ static void -ofctl_encode_error_reply(int argc OVS_UNUSED, char *argv[]) +ofctl_encode_error_reply(struct ovs_cmdl_context *ctx) { const struct ofp_header *oh; struct ofpbuf request, *reply; enum ofperr error; - error = ofperr_from_name(argv[1]); + error = ofperr_from_name(ctx->argv[1]); if (!error) { - ovs_fatal(0, "unknown error \"%s\"", argv[1]); + ovs_fatal(0, "unknown error \"%s\"", ctx->argv[1]); } ofpbuf_init(&request, 0); - if (ofpbuf_put_hex(&request, argv[2], NULL)[0] != '\0') { + if (ofpbuf_put_hex(&request, ctx->argv[2], NULL)[0] != '\0') { ovs_fatal(0, "Trailing garbage in hex data"); } if (request.size < sizeof(struct ofp_header)) { @@ -3435,7 +3816,7 @@ ofctl_encode_error_reply(int argc OVS_UNUSED, char *argv[]) * Alternative usage: "ofp-print [VERBOSITY] - < HEXSTRING_FILE", where * HEXSTRING_FILE contains the HEXSTRING. */ static void -ofctl_ofp_print(int argc, char *argv[]) +ofctl_ofp_print(struct ovs_cmdl_context *ctx) { struct ofpbuf packet; char *buffer; @@ -3444,18 +3825,18 @@ ofctl_ofp_print(int argc, char *argv[]) ds_init(&line); - if (!strcmp(argv[argc-1], "-")) { + if (!strcmp(ctx->argv[ctx->argc-1], "-")) { if (ds_get_line(&line, stdin)) { VLOG_FATAL("Failed to read stdin"); } buffer = line.string; - verbosity = argc > 2 ? atoi(argv[1]) : verbosity; - } else if (argc > 2) { - buffer = argv[1]; - verbosity = atoi(argv[2]); + verbosity = ctx->argc > 2 ? atoi(ctx->argv[1]) : verbosity; + } else if (ctx->argc > 2) { + buffer = ctx->argv[1]; + verbosity = atoi(ctx->argv[2]); } else { - buffer = argv[1]; + buffer = ctx->argv[1]; } ofpbuf_init(&packet, strlen(buffer) / 2); @@ -3470,9 +3851,9 @@ ofctl_ofp_print(int argc, char *argv[]) /* "encode-hello BITMAP...": Encodes each BITMAP as an OpenFlow hello message * and dumps each message in hex. */ static void -ofctl_encode_hello(int argc OVS_UNUSED, char *argv[]) +ofctl_encode_hello(struct ovs_cmdl_context *ctx) { - uint32_t bitmap = strtol(argv[1], NULL, 0); + uint32_t bitmap = strtol(ctx->argv[1], NULL, 0); struct ofpbuf *hello; hello = ofputil_encode_hello(bitmap); @@ -3481,7 +3862,7 @@ ofctl_encode_hello(int argc OVS_UNUSED, char *argv[]) ofpbuf_delete(hello); } -static const struct command all_commands[] = { +static const struct ovs_cmdl_command all_commands[] = { { "show", "switch", 1, 1, ofctl_show }, { "monitor", "switch [misslen] [invalid_ttl] [watch:[...]]", @@ -3494,14 +3875,16 @@ static const struct command all_commands[] = { 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", 1, 2, ofctl_dump_aggregate }, { "queue-stats", "switch [port [queue]]", 1, 3, ofctl_queue_stats }, - { "queue-get-config", "switch port", - 2, 2, ofctl_queue_get_config }, + { "queue-get-config", "switch [port [queue]]", + 1, 3, ofctl_queue_get_config }, { "add-flow", "switch flow", 2, 2, ofctl_add_flow }, { "add-flows", "switch file", @@ -3574,6 +3957,12 @@ static const struct command all_commands[] = { 1, 2, ofctl_dump_group_stats }, { "dump-group-features", "switch", 1, 1, ofctl_dump_group_features }, + { "add-tlv-map", "switch map", + 2, 2, ofctl_add_tlv_map }, + { "del-tlv-map", "switch [map]", + 1, 2, ofctl_del_tlv_map }, + { "dump-tlv-map", "switch", + 1, 1, ofctl_dump_tlv_map }, { "help", NULL, 0, INT_MAX, ofctl_help }, { "list-commands", NULL, 0, INT_MAX, ofctl_list_commands }, @@ -3597,7 +3986,7 @@ static const struct command all_commands[] = { { NULL, NULL, 0, 0, NULL }, }; -static const struct command *get_all_commands(void) +static const struct ovs_cmdl_command *get_all_commands(void) { return all_commands; }