X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=lib%2Fofp-util.c;h=4e28b511425126a46dbc3160d7a5d67d62713769;hb=6c0386119d614d5e26ca08cc3d8e527806b87ef9;hp=ffdccda43ef1f0d5f7de19dbbe0fc6641137ae34;hpb=0e553d9c1063be047824c6f1afce9ffc6db6c671;p=sliver-openvswitch.git diff --git a/lib/ofp-util.c b/lib/ofp-util.c index ffdccda43..4e28b5114 100644 --- a/lib/ofp-util.c +++ b/lib/ofp-util.c @@ -30,6 +30,7 @@ #include "learn.h" #include "multipath.h" #include "meta-flow.h" +#include "netdev.h" #include "nx-match.h" #include "ofp-errors.h" #include "ofp-util.h" @@ -404,6 +405,10 @@ ofputil_decode_vendor(const struct ofp_header *oh, size_t length, { OFPUTIL_NXT_SET_ASYNC_CONFIG, OFP10_VERSION, NXT_SET_ASYNC_CONFIG, "NXT_SET_ASYNC_CONFIG", sizeof(struct nx_async_config), 0 }, + + { OFPUTIL_NXT_SET_CONTROLLER_ID, OFP10_VERSION, + NXT_SET_CONTROLLER_ID, "NXT_SET_CONTROLLER_ID", + sizeof(struct nx_controller_id), 0 }, }; static const struct ofputil_msg_category nxt_category = { @@ -720,31 +725,31 @@ ofputil_decode_msg_type__(const struct ofp_header *oh, size_t length, sizeof(struct ofp_port_status), 0 }, { OFPUTIL_OFPT_PACKET_OUT, OFP10_VERSION, - OFPT_PACKET_OUT, "OFPT_PACKET_OUT", + OFPT10_PACKET_OUT, "OFPT_PACKET_OUT", sizeof(struct ofp_packet_out), 1 }, { OFPUTIL_OFPT_FLOW_MOD, OFP10_VERSION, - OFPT_FLOW_MOD, "OFPT_FLOW_MOD", + OFPT10_FLOW_MOD, "OFPT_FLOW_MOD", sizeof(struct ofp_flow_mod), 1 }, { OFPUTIL_OFPT_PORT_MOD, OFP10_VERSION, - OFPT_PORT_MOD, "OFPT_PORT_MOD", + OFPT10_PORT_MOD, "OFPT_PORT_MOD", sizeof(struct ofp_port_mod), 0 }, { 0, OFP10_VERSION, - OFPT_STATS_REQUEST, "OFPT_STATS_REQUEST", + OFPT10_STATS_REQUEST, "OFPT_STATS_REQUEST", sizeof(struct ofp_stats_msg), 1 }, { 0, OFP10_VERSION, - OFPT_STATS_REPLY, "OFPT_STATS_REPLY", + OFPT10_STATS_REPLY, "OFPT_STATS_REPLY", sizeof(struct ofp_stats_msg), 1 }, { OFPUTIL_OFPT_BARRIER_REQUEST, OFP10_VERSION, - OFPT_BARRIER_REQUEST, "OFPT_BARRIER_REQUEST", + OFPT10_BARRIER_REQUEST, "OFPT_BARRIER_REQUEST", sizeof(struct ofp_header), 0 }, { OFPUTIL_OFPT_BARRIER_REPLY, OFP10_VERSION, - OFPT_BARRIER_REPLY, "OFPT_BARRIER_REPLY", + OFPT10_BARRIER_REPLY, "OFPT_BARRIER_REPLY", sizeof(struct ofp_header), 0 }, { 0, 0, @@ -763,16 +768,19 @@ ofputil_decode_msg_type__(const struct ofp_header *oh, size_t length, error = ofputil_lookup_openflow_message(&ofpt_category, oh->version, oh->type, typep); if (!error) { - switch (oh->type) { - case OFPT_VENDOR: + switch ((oh->version << 8) | oh->type) { + case (OFP10_VERSION << 8) | OFPT_VENDOR: + case (OFP11_VERSION << 8) | OFPT_VENDOR: error = ofputil_decode_vendor(oh, length, typep); break; - case OFPT_STATS_REQUEST: + case (OFP10_VERSION << 8) | OFPT10_STATS_REQUEST: + case (OFP11_VERSION << 8) | OFPT11_STATS_REQUEST: error = ofputil_decode_ofpst_request(oh, length, typep); break; - case OFPT_STATS_REPLY: + case (OFP10_VERSION << 8) | OFPT10_STATS_REPLY: + case (OFP11_VERSION << 8) | OFPT11_STATS_REPLY: error = ofputil_decode_ofpst_reply(oh, length, typep); default: @@ -834,39 +842,248 @@ ofputil_msg_type_code(const struct ofputil_msg_type *type) return type->code; } -/* Flow formats. */ +/* Protocols. */ + +struct proto_abbrev { + enum ofputil_protocol protocol; + const char *name; +}; + +/* Most users really don't care about some of the differences between + * protocols. These abbreviations help with that. */ +static const struct proto_abbrev proto_abbrevs[] = { + { OFPUTIL_P_ANY, "any" }, + { OFPUTIL_P_OF10_ANY, "OpenFlow10" }, + { OFPUTIL_P_NXM_ANY, "NXM" }, +}; +#define N_PROTO_ABBREVS ARRAY_SIZE(proto_abbrevs) + +enum ofputil_protocol ofputil_flow_dump_protocols[] = { + OFPUTIL_P_NXM, + OFPUTIL_P_OF10, +}; +size_t ofputil_n_flow_dump_protocols = ARRAY_SIZE(ofputil_flow_dump_protocols); +/* Returns the ofputil_protocol that is initially in effect on an OpenFlow + * connection that has negotiated the given 'version'. 'version' should + * normally be an 8-bit OpenFlow version identifier (e.g. 0x01 for OpenFlow + * 1.0, 0x02 for OpenFlow 1.1). Returns 0 if 'version' is not supported or + * outside the valid range. */ +enum ofputil_protocol +ofputil_protocol_from_ofp_version(int version) +{ + switch (version) { + case OFP10_VERSION: return OFPUTIL_P_OF10; + default: return 0; + } +} + +/* Returns true if 'protocol' is a single OFPUTIL_P_* value, false + * otherwise. */ bool -ofputil_flow_format_is_valid(enum nx_flow_format flow_format) +ofputil_protocol_is_valid(enum ofputil_protocol protocol) { - switch (flow_format) { - case NXFF_OPENFLOW10: - case NXFF_NXM: - return true; + return protocol & OFPUTIL_P_ANY && is_pow2(protocol); +} + +/* Returns the equivalent of 'protocol' with the Nicira flow_mod_table_id + * extension turned on or off if 'enable' is true or false, respectively. + * + * This extension is only useful for protocols whose "standard" version does + * not allow specific tables to be modified. In particular, this is true of + * OpenFlow 1.0. In later versions of OpenFlow, a flow_mod request always + * specifies a table ID and so there is no need for such an extension. When + * 'protocol' is such a protocol that doesn't need a flow_mod_table_id + * extension, this function just returns its 'protocol' argument unchanged + * regardless of the value of 'enable'. */ +enum ofputil_protocol +ofputil_protocol_set_tid(enum ofputil_protocol protocol, bool enable) +{ + switch (protocol) { + case OFPUTIL_P_OF10: + case OFPUTIL_P_OF10_TID: + return enable ? OFPUTIL_P_OF10_TID : OFPUTIL_P_OF10; + + case OFPUTIL_P_NXM: + case OFPUTIL_P_NXM_TID: + return enable ? OFPUTIL_P_NXM_TID : OFPUTIL_P_NXM; + + default: + NOT_REACHED(); } +} - return false; +/* Returns the "base" version of 'protocol'. That is, if 'protocol' includes + * some extension to a standard protocol version, the return value is the + * standard version of that protocol without any extension. If 'protocol' is a + * standard protocol version, returns 'protocol' unchanged. */ +enum ofputil_protocol +ofputil_protocol_to_base(enum ofputil_protocol protocol) +{ + return ofputil_protocol_set_tid(protocol, false); } -const char * -ofputil_flow_format_to_string(enum nx_flow_format flow_format) +/* Returns 'new_base' with any extensions taken from 'cur'. */ +enum ofputil_protocol +ofputil_protocol_set_base(enum ofputil_protocol cur, + enum ofputil_protocol new_base) { - switch (flow_format) { - case NXFF_OPENFLOW10: - return "openflow10"; - case NXFF_NXM: - return "nxm"; + bool tid = (cur & OFPUTIL_P_TID) != 0; + + switch (new_base) { + case OFPUTIL_P_OF10: + case OFPUTIL_P_OF10_TID: + return ofputil_protocol_set_tid(OFPUTIL_P_OF10, tid); + + case OFPUTIL_P_NXM: + case OFPUTIL_P_NXM_TID: + return ofputil_protocol_set_tid(OFPUTIL_P_NXM, tid); + default: NOT_REACHED(); } } -int -ofputil_flow_format_from_string(const char *s) +/* Returns a string form of 'protocol', if a simple form exists (that is, if + * 'protocol' is either a single protocol or it is a combination of protocols + * that have a single abbreviation). Otherwise, returns NULL. */ +const char * +ofputil_protocol_to_string(enum ofputil_protocol protocol) { - return (!strcmp(s, "openflow10") ? NXFF_OPENFLOW10 - : !strcmp(s, "nxm") ? NXFF_NXM - : -1); + const struct proto_abbrev *p; + + /* Use a "switch" statement for single-bit names so that we get a compiler + * warning if we forget any. */ + switch (protocol) { + case OFPUTIL_P_NXM: + return "NXM-table_id"; + + case OFPUTIL_P_NXM_TID: + return "NXM+table_id"; + + case OFPUTIL_P_OF10: + return "OpenFlow10-table_id"; + + case OFPUTIL_P_OF10_TID: + return "OpenFlow10+table_id"; + } + + /* Check abbreviations. */ + for (p = proto_abbrevs; p < &proto_abbrevs[N_PROTO_ABBREVS]; p++) { + if (protocol == p->protocol) { + return p->name; + } + } + + return NULL; +} + +/* Returns a string that represents 'protocols'. The return value might be a + * comma-separated list if 'protocols' doesn't have a simple name. The return + * value is "none" if 'protocols' is 0. + * + * The caller must free the returned string (with free()). */ +char * +ofputil_protocols_to_string(enum ofputil_protocol protocols) +{ + struct ds s; + + assert(!(protocols & ~OFPUTIL_P_ANY)); + if (protocols == 0) { + return xstrdup("none"); + } + + ds_init(&s); + while (protocols) { + const struct proto_abbrev *p; + int i; + + if (s.length) { + ds_put_char(&s, ','); + } + + for (p = proto_abbrevs; p < &proto_abbrevs[N_PROTO_ABBREVS]; p++) { + if ((protocols & p->protocol) == p->protocol) { + ds_put_cstr(&s, p->name); + protocols &= ~p->protocol; + goto match; + } + } + + for (i = 0; i < CHAR_BIT * sizeof(enum ofputil_protocol); i++) { + enum ofputil_protocol bit = 1u << i; + + if (protocols & bit) { + ds_put_cstr(&s, ofputil_protocol_to_string(bit)); + protocols &= ~bit; + goto match; + } + } + NOT_REACHED(); + + match: ; + } + return ds_steal_cstr(&s); +} + +static enum ofputil_protocol +ofputil_protocol_from_string__(const char *s, size_t n) +{ + const struct proto_abbrev *p; + int i; + + for (i = 0; i < CHAR_BIT * sizeof(enum ofputil_protocol); i++) { + enum ofputil_protocol bit = 1u << i; + const char *name = ofputil_protocol_to_string(bit); + + if (name && n == strlen(name) && !strncasecmp(s, name, n)) { + return bit; + } + } + + for (p = proto_abbrevs; p < &proto_abbrevs[N_PROTO_ABBREVS]; p++) { + if (n == strlen(p->name) && !strncasecmp(s, p->name, n)) { + return p->protocol; + } + } + + return 0; +} + +/* Returns the nonempty set of protocols represented by 's', which can be a + * single protocol name or abbreviation or a comma-separated list of them. + * + * Aborts the program with an error message if 's' is invalid. */ +enum ofputil_protocol +ofputil_protocols_from_string(const char *s) +{ + const char *orig_s = s; + enum ofputil_protocol protocols; + + protocols = 0; + while (*s) { + enum ofputil_protocol p; + size_t n; + + n = strcspn(s, ","); + if (n == 0) { + s++; + continue; + } + + p = ofputil_protocol_from_string__(s, n); + if (!p) { + ovs_fatal(0, "%.*s: unknown flow protocol", (int) n, s); + } + protocols |= p; + + s += n; + } + + if (!protocols) { + ovs_fatal(0, "%s: no flow protocol specified", orig_s); + } + return protocols; } bool @@ -915,12 +1132,12 @@ regs_fully_wildcarded(const struct flow_wildcards *wc) return true; } -/* Returns the minimum nx_flow_format to use for sending 'rule' to a switch - * (e.g. to add or remove a flow). Only NXM can handle tunnel IDs, registers, - * or fixing the Ethernet multicast bit. Otherwise, it's better to use - * NXFF_OPENFLOW10 for backward compatibility. */ -enum nx_flow_format -ofputil_min_flow_format(const struct cls_rule *rule) +/* Returns a bit-mask of ofputil_protocols that can be used for sending 'rule' + * to a switch (e.g. to add or remove a flow). Only NXM can handle tunnel IDs, + * registers, or fixing the Ethernet multicast bit. Otherwise, it's better to + * use OpenFlow 1.0 protocol for backward compatibility. */ +enum ofputil_protocol +ofputil_usable_protocols(const struct cls_rule *rule) { const struct flow_wildcards *wc = &rule->wc; @@ -928,74 +1145,161 @@ ofputil_min_flow_format(const struct cls_rule *rule) /* Only NXM supports separately wildcards the Ethernet multicast bit. */ if (!(wc->wildcards & FWW_DL_DST) != !(wc->wildcards & FWW_ETH_MCAST)) { - return NXFF_NXM; + return OFPUTIL_P_NXM_ANY; } /* Only NXM supports matching ARP hardware addresses. */ if (!(wc->wildcards & FWW_ARP_SHA) || !(wc->wildcards & FWW_ARP_THA)) { - return NXFF_NXM; + return OFPUTIL_P_NXM_ANY; } /* Only NXM supports matching IPv6 traffic. */ if (!(wc->wildcards & FWW_DL_TYPE) && (rule->flow.dl_type == htons(ETH_TYPE_IPV6))) { - return NXFF_NXM; + return OFPUTIL_P_NXM_ANY; } /* Only NXM supports matching registers. */ if (!regs_fully_wildcarded(wc)) { - return NXFF_NXM; + return OFPUTIL_P_NXM_ANY; } /* Only NXM supports matching tun_id. */ if (wc->tun_id_mask != htonll(0)) { - return NXFF_NXM; + return OFPUTIL_P_NXM_ANY; } /* Only NXM supports matching fragments. */ if (wc->nw_frag_mask) { - return NXFF_NXM; + return OFPUTIL_P_NXM_ANY; } /* Only NXM supports matching IPv6 flow label. */ if (!(wc->wildcards & FWW_IPV6_LABEL)) { - return NXFF_NXM; + return OFPUTIL_P_NXM_ANY; } /* Only NXM supports matching IP ECN bits. */ if (!(wc->wildcards & FWW_NW_ECN)) { - return NXFF_NXM; + return OFPUTIL_P_NXM_ANY; } /* Only NXM supports matching IP TTL/hop limit. */ if (!(wc->wildcards & FWW_NW_TTL)) { - return NXFF_NXM; + return OFPUTIL_P_NXM_ANY; } /* Only NXM supports bitwise matching on transport port. */ if ((wc->tp_src_mask && wc->tp_src_mask != htons(UINT16_MAX)) || (wc->tp_dst_mask && wc->tp_dst_mask != htons(UINT16_MAX))) { - return NXFF_NXM; + return OFPUTIL_P_NXM_ANY; } /* Other formats can express this rule. */ - return NXFF_OPENFLOW10; + return OFPUTIL_P_ANY; } -/* Returns an OpenFlow message that can be used to set the flow format to - * 'flow_format'. */ +/* Returns an OpenFlow message that, sent on an OpenFlow connection whose + * protocol is 'current', at least partly transitions the protocol to 'want'. + * Stores in '*next' the protocol that will be in effect on the OpenFlow + * connection if the switch processes the returned message correctly. (If + * '*next != want' then the caller will have to iterate.) + * + * If 'current == want', returns NULL and stores 'current' in '*next'. */ struct ofpbuf * -ofputil_make_set_flow_format(enum nx_flow_format flow_format) +ofputil_encode_set_protocol(enum ofputil_protocol current, + enum ofputil_protocol want, + enum ofputil_protocol *next) +{ + enum ofputil_protocol cur_base, want_base; + bool cur_tid, want_tid; + + cur_base = ofputil_protocol_to_base(current); + want_base = ofputil_protocol_to_base(want); + if (cur_base != want_base) { + *next = ofputil_protocol_set_base(current, want_base); + + switch (want_base) { + case OFPUTIL_P_NXM: + return ofputil_encode_nx_set_flow_format(NXFF_NXM); + + case OFPUTIL_P_OF10: + return ofputil_encode_nx_set_flow_format(NXFF_OPENFLOW10); + + case OFPUTIL_P_OF10_TID: + case OFPUTIL_P_NXM_TID: + NOT_REACHED(); + } + } + + cur_tid = (current & OFPUTIL_P_TID) != 0; + want_tid = (want & OFPUTIL_P_TID) != 0; + if (cur_tid != want_tid) { + *next = ofputil_protocol_set_tid(current, want_tid); + return ofputil_make_flow_mod_table_id(want_tid); + } + + assert(current == want); + + *next = current; + return NULL; +} + +/* Returns an NXT_SET_FLOW_FORMAT message that can be used to set the flow + * format to 'nxff'. */ +struct ofpbuf * +ofputil_encode_nx_set_flow_format(enum nx_flow_format nxff) { struct nx_set_flow_format *sff; struct ofpbuf *msg; + assert(ofputil_nx_flow_format_is_valid(nxff)); + sff = make_nxmsg(sizeof *sff, NXT_SET_FLOW_FORMAT, &msg); - sff->format = htonl(flow_format); + sff->format = htonl(nxff); return msg; } +/* Returns the base protocol if 'flow_format' is a valid NXFF_* value, false + * otherwise. */ +enum ofputil_protocol +ofputil_nx_flow_format_to_protocol(enum nx_flow_format flow_format) +{ + switch (flow_format) { + case NXFF_OPENFLOW10: + return OFPUTIL_P_OF10; + + case NXFF_NXM: + return OFPUTIL_P_NXM; + + default: + return 0; + } +} + +/* Returns true if 'flow_format' is a valid NXFF_* value, false otherwise. */ +bool +ofputil_nx_flow_format_is_valid(enum nx_flow_format flow_format) +{ + return ofputil_nx_flow_format_to_protocol(flow_format) != 0; +} + +/* Returns a string version of 'flow_format', which must be a valid NXFF_* + * value. */ +const char * +ofputil_nx_flow_format_to_string(enum nx_flow_format flow_format) +{ + switch (flow_format) { + case NXFF_OPENFLOW10: + return "openflow10"; + case NXFF_NXM: + return "nxm"; + default: + NOT_REACHED(); + } +} + struct ofpbuf * ofputil_make_set_packet_in_format(enum nx_packet_in_format packet_in_format) { @@ -1025,13 +1329,11 @@ ofputil_make_flow_mod_table_id(bool flow_mod_table_id) * flow_mod in 'fm'. Returns 0 if successful, otherwise an OpenFlow error * code. * - * 'flow_mod_table_id' should be true if the NXT_FLOW_MOD_TABLE_ID extension is - * enabled, false otherwise. - * * Does not validate the flow_mod actions. */ enum ofperr ofputil_decode_flow_mod(struct ofputil_flow_mod *fm, - const struct ofp_header *oh, bool flow_mod_table_id) + const struct ofp_header *oh, + enum ofputil_protocol protocol) { const struct ofputil_msg_type *type; uint16_t command; @@ -1064,7 +1366,7 @@ ofputil_decode_flow_mod(struct ofputil_flow_mod *fm, /* Translate the rule. */ ofputil_cls_rule_from_match(&ofm->match, priority, &fm->cr); - ofputil_normalize_rule(&fm->cr, NXFF_OPENFLOW10); + ofputil_normalize_rule(&fm->cr); /* Translate the message. */ fm->cookie = ofm->cookie; @@ -1114,7 +1416,7 @@ ofputil_decode_flow_mod(struct ofputil_flow_mod *fm, NOT_REACHED(); } - if (flow_mod_table_id) { + if (protocol & OFPUTIL_P_TID) { fm->command = command & 0xff; fm->table_id = command >> 8; } else { @@ -1126,28 +1428,30 @@ ofputil_decode_flow_mod(struct ofputil_flow_mod *fm, } /* Converts 'fm' into an OFPT_FLOW_MOD or NXT_FLOW_MOD message according to - * 'flow_format' and returns the message. + * 'protocol' and returns the message. * * 'flow_mod_table_id' should be true if the NXT_FLOW_MOD_TABLE_ID extension is * enabled, false otherwise. */ struct ofpbuf * ofputil_encode_flow_mod(const struct ofputil_flow_mod *fm, - enum nx_flow_format flow_format, - bool flow_mod_table_id) + enum ofputil_protocol protocol) { size_t actions_len = fm->n_actions * sizeof *fm->actions; + struct ofp_flow_mod *ofm; + struct nx_flow_mod *nfm; struct ofpbuf *msg; uint16_t command; + int match_len; - command = (flow_mod_table_id + command = (protocol & OFPUTIL_P_TID ? (fm->command & 0xff) | (fm->table_id << 8) : fm->command); - if (flow_format == NXFF_OPENFLOW10) { - struct ofp_flow_mod *ofm; - + switch (protocol) { + case OFPUTIL_P_OF10: + case OFPUTIL_P_OF10_TID: msg = ofpbuf_new(sizeof *ofm + actions_len); - ofm = put_openflow(sizeof *ofm, OFPT_FLOW_MOD, msg); + ofm = put_openflow(sizeof *ofm, OFPT10_FLOW_MOD, msg); ofputil_cls_rule_to_match(&fm->cr, &ofm->match); ofm->cookie = fm->cookie; ofm->command = htons(command); @@ -1157,10 +1461,10 @@ ofputil_encode_flow_mod(const struct ofputil_flow_mod *fm, ofm->buffer_id = htonl(fm->buffer_id); ofm->out_port = htons(fm->out_port); ofm->flags = htons(fm->flags); - } else if (flow_format == NXFF_NXM) { - struct nx_flow_mod *nfm; - int match_len; + break; + case OFPUTIL_P_NXM: + case OFPUTIL_P_NXM_TID: msg = ofpbuf_new(sizeof *nfm + NXM_TYPICAL_LEN + actions_len); put_nxmsg(sizeof *nfm, NXT_FLOW_MOD, msg); nfm = msg->data; @@ -1180,7 +1484,9 @@ ofputil_encode_flow_mod(const struct ofputil_flow_mod *fm, nfm->out_port = htons(fm->out_port); nfm->flags = htons(fm->flags); nfm->match_len = htons(match_len); - } else { + break; + + default: NOT_REACHED(); } @@ -1189,6 +1495,35 @@ ofputil_encode_flow_mod(const struct ofputil_flow_mod *fm, return msg; } +/* Returns a bitmask with a 1-bit for each protocol that could be used to + * send all of the 'n_fm's flow table modification requests in 'fms', and a + * 0-bit for each protocol that is inadequate. + * + * (The return value will have at least one 1-bit.) */ +enum ofputil_protocol +ofputil_flow_mod_usable_protocols(const struct ofputil_flow_mod *fms, + size_t n_fms) +{ + enum ofputil_protocol usable_protocols; + size_t i; + + usable_protocols = OFPUTIL_P_ANY; + for (i = 0; i < n_fms; i++) { + const struct ofputil_flow_mod *fm = &fms[i]; + + usable_protocols &= ofputil_usable_protocols(&fm->cr); + if (fm->table_id != 0xff) { + usable_protocols &= OFPUTIL_P_TID; + } + if (fm->command != OFPFC_ADD && fm->cookie_mask != htonll(0)) { + usable_protocols &= OFPUTIL_P_NXM_ANY; + } + } + assert(usable_protocols); + + return usable_protocols; +} + static enum ofperr ofputil_decode_ofpst_flow_request(struct ofputil_flow_stats_request *fsr, const struct ofp_header *oh, @@ -1270,14 +1605,16 @@ ofputil_decode_flow_stats_request(struct ofputil_flow_stats_request *fsr, /* Converts abstract flow_stats_request 'fsr' into an OFPST_FLOW, * OFPST_AGGREGATE, NXST_FLOW, or NXST_AGGREGATE request 'oh' according to - * 'flow_format', and returns the message. */ + * 'protocol', and returns the message. */ struct ofpbuf * ofputil_encode_flow_stats_request(const struct ofputil_flow_stats_request *fsr, - enum nx_flow_format flow_format) + enum ofputil_protocol protocol) { struct ofpbuf *msg; - if (flow_format == NXFF_OPENFLOW10) { + switch (protocol) { + case OFPUTIL_P_OF10: + case OFPUTIL_P_OF10_TID: { struct ofp_flow_stats_request *ofsr; int type; @@ -1286,7 +1623,11 @@ ofputil_encode_flow_stats_request(const struct ofputil_flow_stats_request *fsr, ofputil_cls_rule_to_match(&fsr->match, &ofsr->match); ofsr->table_id = fsr->table_id; ofsr->out_port = htons(fsr->out_port); - } else if (flow_format == NXFF_NXM) { + break; + } + + case OFPUTIL_P_NXM: + case OFPUTIL_P_NXM_TID: { struct nx_flow_stats_request *nfsr; int match_len; int subtype; @@ -1300,13 +1641,33 @@ ofputil_encode_flow_stats_request(const struct ofputil_flow_stats_request *fsr, nfsr->out_port = htons(fsr->out_port); nfsr->match_len = htons(match_len); nfsr->table_id = fsr->table_id; - } else { + break; + } + + default: NOT_REACHED(); } return msg; } +/* Returns a bitmask with a 1-bit for each protocol that could be used to + * accurately encode 'fsr', and a 0-bit for each protocol that is inadequate. + * + * (The return value will have at least one 1-bit.) */ +enum ofputil_protocol +ofputil_flow_stats_request_usable_protocols( + const struct ofputil_flow_stats_request *fsr) +{ + enum ofputil_protocol usable_protocols; + + usable_protocols = ofputil_usable_protocols(&fsr->match); + if (fsr->cookie_mask != htonll(0)) { + usable_protocols &= OFPUTIL_P_NXM_ANY; + } + return usable_protocols; +} + /* Converts an OFPST_FLOW or NXST_FLOW reply in 'msg' into an abstract * ofputil_flow_stats in 'fs'. * @@ -1512,7 +1873,7 @@ ofputil_append_flow_stats_reply(const struct ofputil_flow_stats *fs, } /* Converts abstract ofputil_aggregate_stats 'stats' into an OFPST_AGGREGATE or - * NXST_AGGREGATE reply according to 'flow_format', and returns the message. */ + * NXST_AGGREGATE reply according to 'protocol', and returns the message. */ struct ofpbuf * ofputil_encode_aggregate_stats_reply( const struct ofputil_aggregate_stats *stats, @@ -1601,15 +1962,17 @@ ofputil_decode_flow_removed(struct ofputil_flow_removed *fr, } /* Converts abstract ofputil_flow_removed 'fr' into an OFPT_FLOW_REMOVED or - * NXT_FLOW_REMOVED message 'oh' according to 'flow_format', and returns the + * NXT_FLOW_REMOVED message 'oh' according to 'protocol', and returns the * message. */ struct ofpbuf * ofputil_encode_flow_removed(const struct ofputil_flow_removed *fr, - enum nx_flow_format flow_format) + enum ofputil_protocol protocol) { struct ofpbuf *msg; - if (flow_format == NXFF_OPENFLOW10) { + switch (protocol) { + case OFPUTIL_P_OF10: + case OFPUTIL_P_OF10_TID: { struct ofp_flow_removed *ofr; ofr = make_openflow_xid(sizeof *ofr, OFPT_FLOW_REMOVED, htonl(0), @@ -1623,7 +1986,11 @@ ofputil_encode_flow_removed(const struct ofputil_flow_removed *fr, ofr->idle_timeout = htons(fr->idle_timeout); ofr->packet_count = htonll(unknown_to_zero(fr->packet_count)); ofr->byte_count = htonll(unknown_to_zero(fr->byte_count)); - } else if (flow_format == NXFF_NXM) { + break; + } + + case OFPUTIL_P_NXM: + case OFPUTIL_P_NXM_TID: { struct nx_flow_removed *nfr; int match_len; @@ -1640,7 +2007,10 @@ ofputil_encode_flow_removed(const struct ofputil_flow_removed *fr, nfr->match_len = htons(match_len); nfr->packet_count = htonll(fr->packet_count); nfr->byte_count = htonll(fr->byte_count); - } else { + break; + } + + default: NOT_REACHED(); } @@ -1728,7 +2098,7 @@ ofputil_encode_packet_in(const struct ofputil_packet_in *pin, packet = ofpbuf_new(send_len + header_len); opi = ofpbuf_put_zeros(packet, header_len); - opi->header.version = OFP_VERSION; + opi->header.version = OFP10_VERSION; opi->header.type = OFPT_PACKET_IN; opi->total_len = htons(pin->total_len); opi->in_port = htons(pin->fmd.in_port); @@ -1765,7 +2135,7 @@ ofputil_encode_packet_in(const struct ofputil_packet_in *pin, ofpbuf_put(packet, pin->packet, send_len); npi = packet->data; - npi->nxh.header.version = OFP_VERSION; + npi->nxh.header.version = OFP10_VERSION; npi->nxh.header.type = OFPT_VENDOR; npi->nxh.vendor = htonl(NX_VENDOR_ID); npi->nxh.subtype = htonl(NXT_PACKET_IN); @@ -1784,6 +2154,41 @@ ofputil_encode_packet_in(const struct ofputil_packet_in *pin, return packet; } +const char * +ofputil_packet_in_reason_to_string(enum ofp_packet_in_reason reason) +{ + static char s[INT_STRLEN(int) + 1]; + + switch (reason) { + case OFPR_NO_MATCH: + return "no_match"; + case OFPR_ACTION: + return "action"; + case OFPR_INVALID_TTL: + return "invalid_ttl"; + + case OFPR_N_REASONS: + default: + sprintf(s, "%d", (int) reason); + return s; + } +} + +bool +ofputil_packet_in_reason_from_string(const char *s, + enum ofp_packet_in_reason *reason) +{ + int i; + + for (i = 0; i < OFPR_N_REASONS; i++) { + if (!strcasecmp(s, ofputil_packet_in_reason_to_string(i))) { + *reason = i; + return true; + } + } + return false; +} + enum ofperr ofputil_decode_packet_out(struct ofputil_packet_out *po, const struct ofp_packet_out *opo) @@ -1819,6 +2224,37 @@ ofputil_decode_packet_out(struct ofputil_packet_out *po, return 0; } + +/* ofputil_phy_port */ + +/* NETDEV_F_* to and from OFPPF_* and OFPPF10_*. */ +BUILD_ASSERT_DECL((int) NETDEV_F_10MB_HD == OFPPF_10MB_HD); /* bit 0 */ +BUILD_ASSERT_DECL((int) NETDEV_F_10MB_FD == OFPPF_10MB_FD); /* bit 1 */ +BUILD_ASSERT_DECL((int) NETDEV_F_100MB_HD == OFPPF_100MB_HD); /* bit 2 */ +BUILD_ASSERT_DECL((int) NETDEV_F_100MB_FD == OFPPF_100MB_FD); /* bit 3 */ +BUILD_ASSERT_DECL((int) NETDEV_F_1GB_HD == OFPPF_1GB_HD); /* bit 4 */ +BUILD_ASSERT_DECL((int) NETDEV_F_1GB_FD == OFPPF_1GB_FD); /* bit 5 */ +BUILD_ASSERT_DECL((int) NETDEV_F_10GB_FD == OFPPF_10GB_FD); /* bit 6 */ + +/* NETDEV_F_ bits 11...15 are OFPPF10_ bits 7...11: */ +BUILD_ASSERT_DECL((int) NETDEV_F_COPPER == (OFPPF_COPPER << 4)); +BUILD_ASSERT_DECL((int) NETDEV_F_FIBER == (OFPPF_FIBER << 4)); +BUILD_ASSERT_DECL((int) NETDEV_F_AUTONEG == (OFPPF_AUTONEG << 4)); +BUILD_ASSERT_DECL((int) NETDEV_F_PAUSE == (OFPPF_PAUSE << 4)); +BUILD_ASSERT_DECL((int) NETDEV_F_PAUSE_ASYM == (OFPPF_PAUSE_ASYM << 4)); + +enum netdev_features +ofputil_netdev_port_features_from_ofp10(ovs_be32 ofp10_) +{ + uint32_t ofp10 = ntohl(ofp10_); + return (ofp10 & 0x7f) | ((ofp10 & 0xf80) << 4); +} + +ovs_be32 +ofputil_netdev_port_features_to_ofp10(enum netdev_features features) +{ + return htonl((features & 0x7f) | ((features & 0xf800) >> 4)); +} struct ofpbuf * ofputil_encode_packet_out(const struct ofputil_packet_out *po) @@ -1835,7 +2271,7 @@ ofputil_encode_packet_out(const struct ofputil_packet_out *po) } msg = ofpbuf_new(size); - opo = put_openflow(sizeof *opo, OFPT_PACKET_OUT, msg); + opo = put_openflow(sizeof *opo, OFPT10_PACKET_OUT, msg); opo->buffer_id = htonl(po->buffer_id); opo->in_port = htons(po->in_port); opo->actions_len = htons(actions_len); @@ -1951,7 +2387,7 @@ put_openflow_xid(size_t openflow_len, uint8_t type, ovs_be32 xid, assert(openflow_len <= UINT16_MAX); oh = ofpbuf_put_uninit(buffer, openflow_len); - oh->version = OFP_VERSION; + oh->version = OFP10_VERSION; oh->type = type; oh->length = htons(openflow_len); oh->xid = xid; @@ -2026,7 +2462,7 @@ ofputil_make_stats_request(size_t openflow_len, uint16_t ofpst_type, struct ofpbuf *msg; msg = *bufferp = ofpbuf_new(openflow_len); - put_stats__(alloc_xid(), OFPT_STATS_REQUEST, + put_stats__(alloc_xid(), OFPT10_STATS_REQUEST, htons(ofpst_type), htonl(nxst_subtype), msg); ofpbuf_padto(msg, openflow_len); @@ -2036,9 +2472,9 @@ ofputil_make_stats_request(size_t openflow_len, uint16_t ofpst_type, static void put_stats_reply__(const struct ofp_stats_msg *request, struct ofpbuf *msg) { - assert(request->header.type == OFPT_STATS_REQUEST || - request->header.type == OFPT_STATS_REPLY); - put_stats__(request->header.xid, OFPT_STATS_REPLY, request->type, + assert(request->header.type == OFPT10_STATS_REQUEST || + request->header.type == OFPT10_STATS_REPLY); + put_stats__(request->header.xid, OFPT10_STATS_REPLY, request->type, (request->type != htons(OFPST_VENDOR) ? htonl(0) : ((const struct nicira_stats_msg *) request)->subtype), @@ -2120,7 +2556,7 @@ ofputil_append_stats_reply(size_t len, struct list *replies) const void * ofputil_stats_body(const struct ofp_header *oh) { - assert(oh->type == OFPT_STATS_REQUEST || oh->type == OFPT_STATS_REPLY); + assert(oh->type == OFPT10_STATS_REQUEST || oh->type == OFPT10_STATS_REPLY); return (const struct ofp_stats_msg *) oh + 1; } @@ -2128,7 +2564,7 @@ ofputil_stats_body(const struct ofp_header *oh) size_t ofputil_stats_body_len(const struct ofp_header *oh) { - assert(oh->type == OFPT_STATS_REQUEST || oh->type == OFPT_STATS_REPLY); + assert(oh->type == OFPT10_STATS_REQUEST || oh->type == OFPT10_STATS_REPLY); return ntohs(oh->length) - sizeof(struct ofp_stats_msg); } @@ -2136,7 +2572,7 @@ ofputil_stats_body_len(const struct ofp_header *oh) const void * ofputil_nxstats_body(const struct ofp_header *oh) { - assert(oh->type == OFPT_STATS_REQUEST || oh->type == OFPT_STATS_REPLY); + assert(oh->type == OFPT10_STATS_REQUEST || oh->type == OFPT10_STATS_REPLY); return ((const struct nicira_stats_msg *) oh) + 1; } @@ -2144,7 +2580,7 @@ ofputil_nxstats_body(const struct ofp_header *oh) size_t ofputil_nxstats_body_len(const struct ofp_header *oh) { - assert(oh->type == OFPT_STATS_REQUEST || oh->type == OFPT_STATS_REPLY); + assert(oh->type == OFPT10_STATS_REQUEST || oh->type == OFPT10_STATS_REPLY); return ntohs(oh->length) - sizeof(struct nicira_stats_msg); } @@ -2156,8 +2592,8 @@ make_flow_mod(uint16_t command, const struct cls_rule *rule, size_t size = sizeof *ofm + actions_len; struct ofpbuf *out = ofpbuf_new(size); ofm = ofpbuf_put_zeros(out, sizeof *ofm); - ofm->header.version = OFP_VERSION; - ofm->header.type = OFPT_FLOW_MOD; + ofm->header.version = OFP10_VERSION; + ofm->header.type = OFPT10_FLOW_MOD; ofm->header.length = htons(size); ofm->cookie = 0; ofm->priority = htons(MIN(rule->priority, UINT16_MAX)); @@ -2233,7 +2669,7 @@ make_echo_request(void) struct ofp_header *rq; struct ofpbuf *out = ofpbuf_new(sizeof *rq); rq = ofpbuf_put_uninit(out, sizeof *rq); - rq->version = OFP_VERSION; + rq->version = OFP10_VERSION; rq->type = OFPT_ECHO_REQUEST; rq->length = htons(sizeof *rq); rq->xid = htonl(0); @@ -2257,7 +2693,7 @@ ofputil_encode_barrier_request(void) { struct ofpbuf *msg; - make_openflow(sizeof(struct ofp_header), OFPT_BARRIER_REQUEST, &msg); + make_openflow(sizeof(struct ofp_header), OFPT10_BARRIER_REQUEST, &msg); return msg; } @@ -2291,6 +2727,44 @@ ofputil_frag_handling_from_string(const char *s, enum ofp_config_flags *flags) return true; } +/* Converts the OpenFlow 1.1+ port number 'ofp11_port' into an OpenFlow 1.0 + * port number and stores the latter in '*ofp10_port', for the purpose of + * decoding OpenFlow 1.1+ protocol messages. Returns 0 if successful, + * otherwise an OFPERR_* number. + * + * See the definition of OFP11_MAX for an explanation of the mapping. */ +enum ofperr +ofputil_port_from_ofp11(ovs_be32 ofp11_port, uint16_t *ofp10_port) +{ + uint32_t ofp11_port_h = ntohl(ofp11_port); + + if (ofp11_port_h < OFPP_MAX) { + *ofp10_port = ofp11_port_h; + return 0; + } else if (ofp11_port_h >= OFPP11_MAX) { + *ofp10_port = ofp11_port_h - OFPP11_OFFSET; + return 0; + } else { + VLOG_WARN_RL(&bad_ofmsg_rl, "port %"PRIu32" is outside the supported " + "range 0 through %d or 0x%"PRIx32" through 0x%"PRIx32, + ofp11_port_h, OFPP_MAX - 1, + (uint32_t) OFPP11_MAX, UINT32_MAX); + return OFPERR_OFPBAC_BAD_OUT_PORT; + } +} + +/* Returns the OpenFlow 1.1+ port number equivalent to the OpenFlow 1.0 port + * number 'ofp10_port', for encoding OpenFlow 1.1+ protocol messages. + * + * See the definition of OFP11_MAX for an explanation of the mapping. */ +ovs_be32 +ofputil_port_to_ofp11(uint16_t ofp10_port) +{ + return htonl(ofp10_port < OFPP_MAX + ? ofp10_port + : ofp10_port + OFPP11_OFFSET); +} + /* Checks that 'port' is a valid output port for the OFPAT_OUTPUT action, given * that the switch will never have more than 'max_ports' ports. Returns 0 if * 'port' is valid, otherwise an OpenFlow return code. */ @@ -2492,6 +2966,12 @@ validate_actions(const union ofp_action *actions, size_t n_actions, error = learn_check((const struct nx_action_learn *) a, flow); break; + case OFPUTIL_NXAST_CONTROLLER: + if (((const struct nx_action_controller *) a)->zero) { + error = OFPERR_NXBAC_MUST_BE_ZERO; + } + break; + case OFPUTIL_OFPAT_STRIP_VLAN: case OFPUTIL_OFPAT_SET_NW_SRC: case OFPUTIL_OFPAT_SET_NW_DST: @@ -2748,12 +3228,9 @@ action_outputs_to_port(const union ofp_action *action, ovs_be16 port) * example, Open vSwitch does not understand SCTP, an L4 protocol, so the * L4 fields tp_src and tp_dst must be wildcarded if 'rule' specifies an * SCTP flow. - * - * 'flow_format' specifies the format of the flow as received or as intended to - * be sent. This is important for IPv6 and ARP, for which NXM supports more - * detailed matching. */ + */ void -ofputil_normalize_rule(struct cls_rule *rule, enum nx_flow_format flow_format) +ofputil_normalize_rule(struct cls_rule *rule) { enum { MAY_NW_ADDR = 1 << 0, /* nw_src, nw_dst */ @@ -2776,8 +3253,7 @@ ofputil_normalize_rule(struct cls_rule *rule, enum nx_flow_format flow_format) rule->flow.nw_proto == IPPROTO_ICMP) { may_match |= MAY_TP_ADDR; } - } else if (rule->flow.dl_type == htons(ETH_TYPE_IPV6) - && flow_format == NXFF_NXM) { + } else if (rule->flow.dl_type == htons(ETH_TYPE_IPV6)) { may_match = MAY_NW_PROTO | MAY_IPVx | MAY_IPV6; if (rule->flow.nw_proto == IPPROTO_TCP || rule->flow.nw_proto == IPPROTO_UDP) { @@ -2791,10 +3267,7 @@ ofputil_normalize_rule(struct cls_rule *rule, enum nx_flow_format flow_format) } } } else if (rule->flow.dl_type == htons(ETH_TYPE_ARP)) { - may_match = MAY_NW_PROTO | MAY_NW_ADDR; - if (flow_format == NXFF_NXM) { - may_match |= MAY_ARP_SHA | MAY_ARP_THA; - } + may_match = MAY_NW_PROTO | MAY_NW_ADDR | MAY_ARP_SHA | MAY_ARP_THA; } else { may_match = 0; }