X-Git-Url: http://git.cascardo.eti.br/?a=blobdiff_plain;f=lib%2Fofp-util.c;h=a0da289d0b601a2e6e3d73b4ba685171b5f7e721;hb=0c4b9393b6a5792b888d4b580e04cc3fa64ebc12;hp=5c6120a67245962d2041dab7d9e38645d74a14aa;hpb=ecb229bebb9dd2687848dcebc10d2556ae1f2a87;p=cascardo%2Fovs.git diff --git a/lib/ofp-util.c b/lib/ofp-util.c index 5c6120a67..a0da289d0 100644 --- a/lib/ofp-util.c +++ b/lib/ofp-util.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2008, 2009, 2010, 2011, 2012, 2013, 2014 Nicira, Inc. + * Copyright (c) 2008, 2009, 2010, 2011, 2012, 2013, 2014, 2015 Nicira, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -32,16 +32,19 @@ #include "multipath.h" #include "netdev.h" #include "nx-match.h" +#include "id-pool.h" #include "ofp-actions.h" #include "ofp-errors.h" #include "ofp-msgs.h" #include "ofp-util.h" #include "ofpbuf.h" +#include "openflow/netronome-ext.h" #include "packets.h" #include "random.h" #include "unaligned.h" #include "type-props.h" -#include "vlog.h" +#include "openvswitch/vlog.h" +#include "bitmap.h" VLOG_DEFINE_THIS_MODULE(ofp_util); @@ -49,6 +52,114 @@ VLOG_DEFINE_THIS_MODULE(ofp_util); * in the peer and so there's not much point in showing a lot of them. */ static struct vlog_rate_limit bad_ofmsg_rl = VLOG_RATE_LIMIT_INIT(1, 5); +static enum ofputil_table_miss ofputil_table_miss_from_config( + ovs_be32 config_, enum ofp_version); + +struct ofp_prop_header { + ovs_be16 type; + ovs_be16 len; +}; + +struct ofp_prop_experimenter { + ovs_be16 type; /* OFP*_EXPERIMENTER. */ + ovs_be16 length; /* Length in bytes of this property. */ + ovs_be32 experimenter; /* Experimenter ID which takes the same form as + * in struct ofp_experimenter_header. */ + ovs_be32 exp_type; /* Experimenter defined. */ +}; + +/* Pulls a property, beginning with struct ofp_prop_header, from the beginning + * of 'msg'. Stores the type of the property in '*typep' and, if 'property' is + * nonnull, the entire property, including the header, in '*property'. Returns + * 0 if successful, otherwise an error code. + * + * This function pulls the property's stated size padded out to a multiple of + * 'alignment' bytes. The common case in OpenFlow is an 'alignment' of 8, so + * you can use ofputil_pull_property() for that case. */ +static enum ofperr +ofputil_pull_property__(struct ofpbuf *msg, struct ofpbuf *property, + unsigned int alignment, uint16_t *typep) +{ + struct ofp_prop_header *oph; + unsigned int padded_len; + unsigned int len; + + if (msg->size < sizeof *oph) { + return OFPERR_OFPBPC_BAD_LEN; + } + + oph = msg->data; + len = ntohs(oph->len); + padded_len = ROUND_UP(len, alignment); + if (len < sizeof *oph || padded_len > msg->size) { + return OFPERR_OFPBPC_BAD_LEN; + } + + *typep = ntohs(oph->type); + if (property) { + ofpbuf_use_const(property, msg->data, len); + } + ofpbuf_pull(msg, padded_len); + return 0; +} + +/* Pulls a property, beginning with struct ofp_prop_header, from the beginning + * of 'msg'. Stores the type of the property in '*typep' and, if 'property' is + * nonnull, the entire property, including the header, in '*property'. Returns + * 0 if successful, otherwise an error code. + * + * This function pulls the property's stated size padded out to a multiple of + * 8 bytes, which is the common case for OpenFlow properties. */ +static enum ofperr +ofputil_pull_property(struct ofpbuf *msg, struct ofpbuf *property, + uint16_t *typep) +{ + return ofputil_pull_property__(msg, property, 8, typep); +} + +static void OVS_PRINTF_FORMAT(2, 3) +log_property(bool loose, const char *message, ...) +{ + enum vlog_level level = loose ? VLL_DBG : VLL_WARN; + if (!vlog_should_drop(THIS_MODULE, level, &bad_ofmsg_rl)) { + va_list args; + + va_start(args, message); + vlog_valist(THIS_MODULE, level, message, args); + va_end(args); + } +} + +static size_t +start_property(struct ofpbuf *msg, uint16_t type) +{ + size_t start_ofs = msg->size; + struct ofp_prop_header *oph; + + oph = ofpbuf_put_uninit(msg, sizeof *oph); + oph->type = htons(type); + oph->len = htons(4); /* May be updated later by end_property(). */ + return start_ofs; +} + +static void +end_property(struct ofpbuf *msg, size_t start_ofs) +{ + struct ofp_prop_header *oph; + + oph = ofpbuf_at_assert(msg, start_ofs, sizeof *oph); + oph->len = htons(msg->size - start_ofs); + ofpbuf_padto(msg, ROUND_UP(msg->size, 8)); +} + +static void +put_bitmap_properties(struct ofpbuf *msg, uint64_t bitmap) +{ + for (; bitmap; bitmap = zero_rightmost_1bit(bitmap)) { + start_property(msg, rightmost_1bit_idx(bitmap)); + } +} + /* Given the wildcard bit count in the least-significant 6 of 'wcbits', returns * an IP netmask with a 1 in each bit that must match and a 0 in each bit that * is wildcarded. @@ -84,7 +195,7 @@ ofputil_netmask_to_wcbits(ovs_be32 netmask) void ofputil_wildcard_from_ofpfw10(uint32_t ofpfw, struct flow_wildcards *wc) { - BUILD_ASSERT_DECL(FLOW_WC_SEQ == 24); + BUILD_ASSERT_DECL(FLOW_WC_SEQ == 31); /* Initialize most of wc. */ flow_wildcards_init_catchall(wc); @@ -574,6 +685,7 @@ ofputil_match_typical_len(enum ofputil_protocol protocol) case OFPUTIL_P_OF12_OXM: case OFPUTIL_P_OF13_OXM: case OFPUTIL_P_OF14_OXM: + case OFPUTIL_P_OF15_OXM: return NXM_TYPICAL_LEN; default: @@ -615,7 +727,9 @@ ofputil_put_ofp11_match(struct ofpbuf *b, const struct match *match, case OFPUTIL_P_OF12_OXM: case OFPUTIL_P_OF13_OXM: case OFPUTIL_P_OF14_OXM: - return oxm_put_match(b, match); + case OFPUTIL_P_OF15_OXM: + return oxm_put_match(b, match, + ofputil_protocol_to_ofp_version(protocol)); } OVS_NOT_REACHED(); @@ -651,20 +765,17 @@ struct proto_abbrev { }; /* Most users really don't care about some of the differences between - * protocols. These abbreviations help with that. - * - * Until it is safe to use the OpenFlow 1.4 protocol (which currently can - * cause aborts due to unimplemented features), we omit OpenFlow 1.4 from all - * abbrevations. */ + * protocols. These abbreviations help with that. */ static const struct proto_abbrev proto_abbrevs[] = { - { OFPUTIL_P_ANY & ~OFPUTIL_P_OF14_OXM, "any" }, - { OFPUTIL_P_OF10_STD_ANY & ~OFPUTIL_P_OF14_OXM, "OpenFlow10" }, - { OFPUTIL_P_OF10_NXM_ANY & ~OFPUTIL_P_OF14_OXM, "NXM" }, - { OFPUTIL_P_ANY_OXM & ~OFPUTIL_P_OF14_OXM, "OXM" }, + { OFPUTIL_P_ANY, "any" }, + { OFPUTIL_P_OF10_STD_ANY, "OpenFlow10" }, + { OFPUTIL_P_OF10_NXM_ANY, "NXM" }, + { OFPUTIL_P_ANY_OXM, "OXM" }, }; #define N_PROTO_ABBREVS ARRAY_SIZE(proto_abbrevs) enum ofputil_protocol ofputil_flow_dump_protocols[] = { + OFPUTIL_P_OF15_OXM, OFPUTIL_P_OF14_OXM, OFPUTIL_P_OF13_OXM, OFPUTIL_P_OF12_OXM, @@ -692,6 +803,8 @@ ofputil_protocols_from_ofp_version(enum ofp_version version) return OFPUTIL_P_OF13_OXM; case OFP14_VERSION: return OFPUTIL_P_OF14_OXM; + case OFP15_VERSION: + return OFPUTIL_P_OF15_OXM; default: return 0; } @@ -727,6 +840,8 @@ ofputil_protocol_to_ofp_version(enum ofputil_protocol protocol) return OFP13_VERSION; case OFPUTIL_P_OF14_OXM: return OFP14_VERSION; + case OFPUTIL_P_OF15_OXM: + return OFP15_VERSION; } OVS_NOT_REACHED(); @@ -806,6 +921,9 @@ ofputil_protocol_set_tid(enum ofputil_protocol protocol, bool enable) case OFPUTIL_P_OF14_OXM: return OFPUTIL_P_OF14_OXM; + case OFPUTIL_P_OF15_OXM: + return OFPUTIL_P_OF15_OXM; + default: OVS_NOT_REACHED(); } @@ -849,6 +967,9 @@ ofputil_protocol_set_base(enum ofputil_protocol cur, case OFPUTIL_P_OF14_OXM: return ofputil_protocol_set_tid(OFPUTIL_P_OF14_OXM, tid); + case OFPUTIL_P_OF15_OXM: + return ofputil_protocol_set_tid(OFPUTIL_P_OF15_OXM, tid); + default: OVS_NOT_REACHED(); } @@ -888,6 +1009,9 @@ ofputil_protocol_to_string(enum ofputil_protocol protocol) case OFPUTIL_P_OF14_OXM: return "OXM-OpenFlow14"; + + case OFPUTIL_P_OF15_OXM: + return "OXM-OpenFlow15"; } /* Check abbreviations. */ @@ -1008,7 +1132,7 @@ ofputil_protocols_from_string(const char *s) return protocols; } -static int +enum ofp_version ofputil_version_from_string(const char *s) { if (!strcasecmp(s, "OpenFlow10")) { @@ -1026,6 +1150,9 @@ ofputil_version_from_string(const char *s) if (!strcasecmp(s, "OpenFlow14")) { return OFP14_VERSION; } + if (!strcasecmp(s, "OpenFlow15")) { + return OFP15_VERSION; + } return 0; } @@ -1098,6 +1225,8 @@ ofputil_version_to_string(enum ofp_version ofp_version) return "OpenFlow13"; case OFP14_VERSION: return "OpenFlow14"; + case OFP15_VERSION: + return "OpenFlow15"; default: OVS_NOT_REACHED(); } @@ -1332,6 +1461,7 @@ ofputil_encode_set_protocol(enum ofputil_protocol current, case OFPUTIL_P_OF12_OXM: case OFPUTIL_P_OF13_OXM: case OFPUTIL_P_OF14_OXM: + case OFPUTIL_P_OF15_OXM: /* There is only one variant of each OpenFlow 1.1+ protocol, and we * verified above that we're not trying to change versions. */ OVS_NOT_REACHED(); @@ -1529,6 +1659,9 @@ ofputil_decode_flow_mod(struct ofputil_flow_mod *fm, struct ofpbuf b; enum ofpraw raw; + /* Ignored for non-delete actions */ + fm->delete_reason = OFPRR_DELETE; + ofpbuf_use_const(&b, oh, ntohs(oh->length)); raw = ofpraw_pull_assert(&b); if (raw == OFPRAW_OFPT11_FLOW_MOD) { @@ -1542,12 +1675,6 @@ ofputil_decode_flow_mod(struct ofputil_flow_mod *fm, return error; } - error = ofpacts_pull_openflow_instructions(&b, b.size, oh->version, - ofpacts); - if (error) { - return error; - } - /* Translate the message. */ fm->priority = ntohs(ofm->priority); if (ofm->command == OFPFC_ADD @@ -1583,6 +1710,11 @@ ofputil_decode_flow_mod(struct ofputil_flow_mod *fm, fm->idle_timeout = ntohs(ofm->idle_timeout); fm->hard_timeout = ntohs(ofm->hard_timeout); + if (oh->version >= OFP14_VERSION && ofm->command == OFPFC_ADD) { + fm->importance = ntohs(ofm->importance); + } else { + fm->importance = 0; + } fm->buffer_id = ntohl(ofm->buffer_id); error = ofputil_port_from_ofp11(ofm->out_port, &fm->out_port); if (error) { @@ -1608,13 +1740,6 @@ ofputil_decode_flow_mod(struct ofputil_flow_mod *fm, ofputil_match_from_ofp10_match(&ofm->match, &fm->match); ofputil_normalize_match(&fm->match); - /* Now get the actions. */ - error = ofpacts_pull_openflow_actions(&b, b.size, oh->version, - ofpacts); - if (error) { - return error; - } - /* OpenFlow 1.0 says that exact-match rules have to have the * highest possible priority. */ fm->priority = (ofm->match.wildcards & htonl(OFPFW10_ALL) @@ -1628,6 +1753,7 @@ ofputil_decode_flow_mod(struct ofputil_flow_mod *fm, fm->new_cookie = ofm->cookie; fm->idle_timeout = ntohs(ofm->idle_timeout); fm->hard_timeout = ntohs(ofm->hard_timeout); + fm->importance = 0; fm->buffer_id = ntohl(ofm->buffer_id); fm->out_port = u16_to_ofp(ntohs(ofm->out_port)); fm->out_group = OFPG11_ANY; @@ -1643,11 +1769,6 @@ ofputil_decode_flow_mod(struct ofputil_flow_mod *fm, if (error) { return error; } - error = ofpacts_pull_openflow_actions(&b, b.size, oh->version, - ofpacts); - if (error) { - return error; - } /* Translate the message. */ command = ntohs(nfm->command); @@ -1660,6 +1781,7 @@ ofputil_decode_flow_mod(struct ofputil_flow_mod *fm, fm->new_cookie = nfm->cookie; fm->idle_timeout = ntohs(nfm->idle_timeout); fm->hard_timeout = ntohs(nfm->hard_timeout); + fm->importance = 0; fm->buffer_id = ntohl(nfm->buffer_id); fm->out_port = u16_to_ofp(ntohs(nfm->out_port)); fm->out_group = OFPG11_ANY; @@ -1678,6 +1800,11 @@ ofputil_decode_flow_mod(struct ofputil_flow_mod *fm, } } + error = ofpacts_pull_openflow_instructions(&b, b.size, + oh->version, ofpacts); + if (error) { + return error; + } fm->ofpacts = ofpacts->data; fm->ofpacts_len = ofpacts->size; @@ -1851,7 +1978,7 @@ ofputil_put_bands(uint16_t n_bands, const struct ofputil_meter_band *mb, /* Encode a meter stat for 'mc' and append it to 'replies'. */ void -ofputil_append_meter_config(struct list *replies, +ofputil_append_meter_config(struct ovs_list *replies, const struct ofputil_meter_config *mc) { struct ofpbuf *msg = ofpbuf_from_list(list_back(replies)); @@ -1869,7 +1996,7 @@ ofputil_append_meter_config(struct list *replies, /* Encode a meter stat for 'ms' and append it to 'replies'. */ void -ofputil_append_meter_stats(struct list *replies, +ofputil_append_meter_stats(struct ovs_list *replies, const struct ofputil_meter_stats *ms) { struct ofp13_meter_stats *reply; @@ -1917,7 +2044,7 @@ ofputil_decode_meter_config(struct ofpbuf *msg, enum ofperr err; /* Pull OpenFlow headers for the first call. */ - if (!msg->l2) { + if (!msg->header) { ofpraw_pull_assert(msg); } @@ -1928,7 +2055,7 @@ ofputil_decode_meter_config(struct ofpbuf *msg, omc = ofpbuf_try_pull(msg, sizeof *omc); if (!omc) { VLOG_WARN_RL(&bad_ofmsg_rl, - "OFPMP_METER_CONFIG reply has %"PRIuSIZE" leftover bytes at end", + "OFPMP_METER_CONFIG reply has %"PRIu32" leftover bytes at end", msg->size); return OFPERR_OFPBRC_BAD_LEN; } @@ -1993,7 +2120,7 @@ ofputil_decode_meter_stats(struct ofpbuf *msg, enum ofperr err; /* Pull OpenFlow headers for the first call. */ - if (!msg->l2) { + if (!msg->header) { ofpraw_pull_assert(msg); } @@ -2004,7 +2131,7 @@ ofputil_decode_meter_stats(struct ofpbuf *msg, oms = ofpbuf_try_pull(msg, sizeof *oms); if (!oms) { VLOG_WARN_RL(&bad_ofmsg_rl, - "OFPMP_METER reply has %"PRIuSIZE" leftover bytes at end", + "OFPMP_METER reply has %"PRIu32" leftover bytes at end", msg->size); return OFPERR_OFPBRC_BAD_LEN; } @@ -2104,7 +2231,8 @@ ofputil_encode_flow_mod(const struct ofputil_flow_mod *fm, case OFPUTIL_P_OF11_STD: case OFPUTIL_P_OF12_OXM: case OFPUTIL_P_OF13_OXM: - case OFPUTIL_P_OF14_OXM: { + case OFPUTIL_P_OF14_OXM: + case OFPUTIL_P_OF15_OXM: { struct ofp11_flow_mod *ofm; int tailroom; @@ -2118,7 +2246,7 @@ ofputil_encode_flow_mod(const struct ofputil_flow_mod *fm, || fm->command == OFPFC_ADD) { ofm->cookie = fm->new_cookie; } else { - ofm->cookie = fm->cookie; + ofm->cookie = fm->cookie & fm->cookie_mask; } ofm->cookie_mask = fm->cookie_mask; if (fm->table_id != OFPTT_ALL @@ -2137,6 +2265,11 @@ ofputil_encode_flow_mod(const struct ofputil_flow_mod *fm, ofm->out_port = ofputil_port_to_ofp11(fm->out_port); ofm->out_group = htonl(fm->out_group); ofm->flags = raw_flags; + if (version >= OFP14_VERSION && fm->command == OFPFC_ADD) { + ofm->importance = htons(fm->importance); + } else { + ofm->importance = 0; + } ofputil_put_ofp11_match(msg, &fm->match, protocol); ofpacts_put_openflow_instructions(fm->ofpacts, fm->ofpacts_len, msg, version); @@ -2175,7 +2308,7 @@ ofputil_encode_flow_mod(const struct ofputil_flow_mod *fm, nfm->command = ofputil_tid_command(fm, protocol); nfm->cookie = fm->new_cookie; match_len = nx_put_match(msg, &fm->match, fm->cookie, fm->cookie_mask); - nfm = msg->l3; + nfm = msg->msg; nfm->idle_timeout = htons(fm->idle_timeout); nfm->hard_timeout = htons(fm->hard_timeout); nfm->priority = htons(fm->priority); @@ -2395,7 +2528,7 @@ ofputil_append_queue_get_config_reply(struct ofpbuf *reply, struct ofp12_packet_queue *opq12; ovs_be32 port; - qgcr11 = reply->l3; + qgcr11 = reply->msg; port = qgcr11->port; opq12 = ofpbuf_put_zeros(reply, sizeof *opq12); @@ -2474,7 +2607,7 @@ ofputil_pull_queue_get_config_reply(struct ofpbuf *reply, queue->min_rate = UINT16_MAX; queue->max_rate = UINT16_MAX; - oh = reply->l2; + oh = reply->header; if (oh->version < OFP12_VERSION) { const struct ofp10_packet_queue *opq10; @@ -2589,7 +2722,8 @@ ofputil_encode_flow_stats_request(const struct ofputil_flow_stats_request *fsr, case OFPUTIL_P_OF11_STD: case OFPUTIL_P_OF12_OXM: case OFPUTIL_P_OF13_OXM: - case OFPUTIL_P_OF14_OXM: { + case OFPUTIL_P_OF14_OXM: + case OFPUTIL_P_OF15_OXM: { struct ofp11_flow_stats_request *ofsr; raw = (fsr->aggregate @@ -2635,7 +2769,7 @@ ofputil_encode_flow_stats_request(const struct ofputil_flow_stats_request *fsr, match_len = nx_put_match(msg, &fsr->match, fsr->cookie, fsr->cookie_mask); - nfsr = msg->l3; + nfsr = msg->msg; nfsr->out_port = htons(ofp_to_u16(fsr->out_port)); nfsr->match_len = htons(match_len); nfsr->table_id = fsr->table_id; @@ -2676,16 +2810,16 @@ ofputil_decode_flow_stats_reply(struct ofputil_flow_stats *fs, struct ofpbuf *ofpacts) { const struct ofp_header *oh; + size_t instructions_len; enum ofperr error; enum ofpraw raw; - error = (msg->l2 - ? ofpraw_decode(&raw, msg->l2) + error = (msg->header ? ofpraw_decode(&raw, msg->header) : ofpraw_pull(&raw, msg)); if (error) { return error; } - oh = msg->l2; + oh = msg->header; if (!msg->size) { return EOF; @@ -2697,7 +2831,7 @@ ofputil_decode_flow_stats_reply(struct ofputil_flow_stats *fs, ofs = ofpbuf_try_pull(msg, sizeof *ofs); if (!ofs) { - VLOG_WARN_RL(&bad_ofmsg_rl, "OFPST_FLOW reply has %"PRIuSIZE" leftover " + VLOG_WARN_RL(&bad_ofmsg_rl, "OFPST_FLOW reply has %"PRIu32" leftover " "bytes at end", msg->size); return EINVAL; } @@ -2713,13 +2847,7 @@ ofputil_decode_flow_stats_reply(struct ofputil_flow_stats *fs, VLOG_WARN_RL(&bad_ofmsg_rl, "OFPST_FLOW reply bad match"); return EINVAL; } - - if (ofpacts_pull_openflow_instructions(msg, length - sizeof *ofs - - padded_match_len, oh->version, - ofpacts)) { - VLOG_WARN_RL(&bad_ofmsg_rl, "OFPST_FLOW reply bad instructions"); - return EINVAL; - } + instructions_len = length - sizeof *ofs - padded_match_len; fs->priority = ntohs(ofs->priority); fs->table_id = ofs->table_id; @@ -2727,6 +2855,11 @@ ofputil_decode_flow_stats_reply(struct ofputil_flow_stats *fs, fs->duration_nsec = ntohl(ofs->duration_nsec); fs->idle_timeout = ntohs(ofs->idle_timeout); fs->hard_timeout = ntohs(ofs->hard_timeout); + if (oh->version >= OFP14_VERSION) { + fs->importance = ntohs(ofs->importance); + } else { + fs->importance = 0; + } if (raw == OFPRAW_OFPST13_FLOW_REPLY) { error = ofputil_decode_flow_mod_flags(ofs->flags, -1, oh->version, &fs->flags); @@ -2747,7 +2880,7 @@ ofputil_decode_flow_stats_reply(struct ofputil_flow_stats *fs, ofs = ofpbuf_try_pull(msg, sizeof *ofs); if (!ofs) { - VLOG_WARN_RL(&bad_ofmsg_rl, "OFPST_FLOW reply has %"PRIuSIZE" leftover " + VLOG_WARN_RL(&bad_ofmsg_rl, "OFPST_FLOW reply has %"PRIu32" leftover " "bytes at end", msg->size); return EINVAL; } @@ -2758,11 +2891,7 @@ ofputil_decode_flow_stats_reply(struct ofputil_flow_stats *fs, "length %"PRIuSIZE, length); return EINVAL; } - - if (ofpacts_pull_openflow_actions(msg, length - sizeof *ofs, - oh->version, ofpacts)) { - return EINVAL; - } + instructions_len = length - sizeof *ofs; fs->cookie = get_32aligned_be64(&ofs->cookie); ofputil_match_from_ofp10_match(&ofs->match, &fs->match); @@ -2772,6 +2901,7 @@ ofputil_decode_flow_stats_reply(struct ofputil_flow_stats *fs, fs->duration_nsec = ntohl(ofs->duration_nsec); fs->idle_timeout = ntohs(ofs->idle_timeout); fs->hard_timeout = ntohs(ofs->hard_timeout); + fs->importance = 0; fs->idle_age = -1; fs->hard_age = -1; fs->packet_count = ntohll(get_32aligned_be64(&ofs->packet_count)); @@ -2779,11 +2909,11 @@ ofputil_decode_flow_stats_reply(struct ofputil_flow_stats *fs, fs->flags = 0; } else if (raw == OFPRAW_NXST_FLOW_REPLY) { const struct nx_flow_stats *nfs; - size_t match_len, actions_len, length; + size_t match_len, length; nfs = ofpbuf_try_pull(msg, sizeof *nfs); if (!nfs) { - VLOG_WARN_RL(&bad_ofmsg_rl, "NXST_FLOW reply has %"PRIuSIZE" leftover " + VLOG_WARN_RL(&bad_ofmsg_rl, "NXST_FLOW reply has %"PRIu32" leftover " "bytes at end", msg->size); return EINVAL; } @@ -2798,12 +2928,7 @@ ofputil_decode_flow_stats_reply(struct ofputil_flow_stats *fs, if (nx_pull_match(msg, match_len, &fs->match, NULL, NULL)) { return EINVAL; } - - actions_len = length - sizeof *nfs - ROUND_UP(match_len, 8); - if (ofpacts_pull_openflow_actions(msg, actions_len, oh->version, - ofpacts)) { - return EINVAL; - } + instructions_len = length - sizeof *nfs - ROUND_UP(match_len, 8); fs->cookie = nfs->cookie; fs->table_id = nfs->table_id; @@ -2812,6 +2937,7 @@ ofputil_decode_flow_stats_reply(struct ofputil_flow_stats *fs, fs->priority = ntohs(nfs->priority); fs->idle_timeout = ntohs(nfs->idle_timeout); fs->hard_timeout = ntohs(nfs->hard_timeout); + fs->importance = 0; fs->idle_age = -1; fs->hard_age = -1; if (flow_age_extension) { @@ -2829,6 +2955,11 @@ ofputil_decode_flow_stats_reply(struct ofputil_flow_stats *fs, OVS_NOT_REACHED(); } + if (ofpacts_pull_openflow_instructions(msg, instructions_len, oh->version, + ofpacts)) { + VLOG_WARN_RL(&bad_ofmsg_rl, "OFPST_FLOW reply bad instructions"); + return EINVAL; + } fs->ofpacts = ofpacts->data; fs->ofpacts_len = ofpacts->size; @@ -2850,19 +2981,18 @@ unknown_to_zero(uint64_t count) * have been initialized with ofpmp_init(). */ void ofputil_append_flow_stats_reply(const struct ofputil_flow_stats *fs, - struct list *replies) + struct ovs_list *replies) { struct ofpbuf *reply = ofpbuf_from_list(list_back(replies)); size_t start_ofs = reply->size; - enum ofpraw raw; - enum ofp_version version = ((struct ofp_header *)reply->data)->version; + enum ofp_version version = ofpmp_version(replies); + enum ofpraw raw = ofpmp_decode_raw(replies); - ofpraw_decode_partial(&raw, reply->data, reply->size); if (raw == OFPRAW_OFPST11_FLOW_REPLY || raw == OFPRAW_OFPST13_FLOW_REPLY) { struct ofp11_flow_stats *ofs; ofpbuf_put_uninit(reply, sizeof *ofs); - oxm_put_match(reply, &fs->match); + oxm_put_match(reply, &fs->match, version); ofpacts_put_openflow_instructions(fs->ofpacts, fs->ofpacts_len, reply, version); @@ -2875,6 +3005,11 @@ ofputil_append_flow_stats_reply(const struct ofputil_flow_stats *fs, ofs->priority = htons(fs->priority); ofs->idle_timeout = htons(fs->idle_timeout); ofs->hard_timeout = htons(fs->hard_timeout); + if (version >= OFP14_VERSION) { + ofs->importance = htons(fs->importance); + } else { + ofs->importance = 0; + } if (raw == OFPRAW_OFPST13_FLOW_REPLY) { ofs->flags = ofputil_encode_flow_mod_flags(fs->flags, version); } else { @@ -2981,7 +3116,7 @@ ofputil_decode_aggregate_stats_reply(struct ofputil_aggregate_stats *stats, ofpbuf_use_const(&msg, reply, ntohs(reply->length)); ofpraw_pull_assert(&msg); - asr = msg.l3; + asr = msg.msg; stats->packet_count = ntohll(get_32aligned_be64(&asr->packet_count)); stats->byte_count = ntohll(get_32aligned_be64(&asr->byte_count)); stats->flow_count = ntohl(asr->flow_count); @@ -3077,12 +3212,18 @@ ofputil_encode_flow_removed(const struct ofputil_flow_removed *fr, enum ofputil_protocol protocol) { struct ofpbuf *msg; + enum ofp_flow_removed_reason reason = fr->reason; + + if (reason == OFPRR_METER_DELETE && !(protocol & OFPUTIL_P_OF14_UP)) { + reason = OFPRR_DELETE; + } switch (protocol) { case OFPUTIL_P_OF11_STD: case OFPUTIL_P_OF12_OXM: case OFPUTIL_P_OF13_OXM: - case OFPUTIL_P_OF14_OXM: { + case OFPUTIL_P_OF14_OXM: + case OFPUTIL_P_OF15_OXM: { struct ofp12_flow_removed *ofr; msg = ofpraw_alloc_xid(OFPRAW_OFPT11_FLOW_REMOVED, @@ -3092,7 +3233,7 @@ ofputil_encode_flow_removed(const struct ofputil_flow_removed *fr, ofr = ofpbuf_put_zeros(msg, sizeof *ofr); ofr->cookie = fr->cookie; ofr->priority = htons(fr->priority); - ofr->reason = fr->reason; + ofr->reason = reason; ofr->table_id = fr->table_id; ofr->duration_sec = htonl(fr->duration_sec); ofr->duration_nsec = htonl(fr->duration_nsec); @@ -3114,7 +3255,7 @@ ofputil_encode_flow_removed(const struct ofputil_flow_removed *fr, ofputil_match_to_ofp10_match(&fr->match, &ofr->match); ofr->cookie = fr->cookie; ofr->priority = htons(fr->priority); - ofr->reason = fr->reason; + ofr->reason = reason; ofr->duration_sec = htonl(fr->duration_sec); ofr->duration_nsec = htonl(fr->duration_nsec); ofr->idle_timeout = htons(fr->idle_timeout); @@ -3130,13 +3271,13 @@ ofputil_encode_flow_removed(const struct ofputil_flow_removed *fr, msg = ofpraw_alloc_xid(OFPRAW_NXT_FLOW_REMOVED, OFP10_VERSION, htonl(0), NXM_TYPICAL_LEN); - nfr = ofpbuf_put_zeros(msg, sizeof *nfr); + ofpbuf_put_zeros(msg, sizeof *nfr); match_len = nx_put_match(msg, &fr->match, 0, 0); - nfr = msg->l3; + nfr = msg->msg; nfr->cookie = fr->cookie; nfr->priority = htons(fr->priority); - nfr->reason = fr->reason; + nfr->reason = reason; nfr->table_id = fr->table_id + 1; nfr->duration_sec = htonl(fr->duration_sec); nfr->duration_nsec = htonl(fr->duration_nsec); @@ -3165,6 +3306,8 @@ ofputil_decode_packet_in_finish(struct ofputil_packet_in *pin, pin->fmd.tun_id = match->flow.tunnel.tun_id; pin->fmd.tun_src = match->flow.tunnel.ip_src; pin->fmd.tun_dst = match->flow.tunnel.ip_dst; + pin->fmd.gbp_id = match->flow.tunnel.gbp_id; + pin->fmd.gbp_flags = match->flow.tunnel.gbp_flags; pin->fmd.metadata = match->flow.metadata; memcpy(pin->fmd.regs, match->flow.regs, sizeof pin->fmd.regs); pin->fmd.pkt_mark = match->flow.pkt_mark; @@ -3290,6 +3433,12 @@ ofputil_packet_in_to_match(const struct ofputil_packet_in *pin, if (pin->fmd.tun_dst != htonl(0)) { match_set_tun_dst(match, pin->fmd.tun_dst); } + if (pin->fmd.gbp_id != htons(0)) { + match_set_tun_gbp_id(match, pin->fmd.gbp_id); + } + if (pin->fmd.gbp_flags) { + match_set_tun_gbp_flags(match, pin->fmd.gbp_flags); + } if (pin->fmd.metadata != htonll(0)) { match_set_metadata(match, pin->fmd.metadata); } @@ -3345,7 +3494,7 @@ ofputil_encode_nx_packet_in(const struct ofputil_packet_in *pin) ofpbuf_put_zeros(packet, 2); ofpbuf_put(packet, pin->packet, pin->packet_len); - npi = packet->l3; + npi = packet->msg; npi->buffer_id = htonl(pin->buffer_id); npi->total_len = htons(pin->total_len); npi->reason = pin->reason; @@ -3394,7 +3543,7 @@ ofputil_encode_ofp12_packet_in(const struct ofputil_packet_in *pin, packet_in_size = sizeof (struct ofp12_packet_in); } else { packet_in_raw = OFPRAW_OFPT13_PACKET_IN; - packet_in_version = OFP13_VERSION; + packet_in_version = ofputil_protocol_to_ofp_version(protocol); packet_in_size = sizeof (struct ofp13_packet_in); } @@ -3405,16 +3554,16 @@ ofputil_encode_ofp12_packet_in(const struct ofputil_packet_in *pin, htonl(0), (sizeof(struct flow_metadata) * 2 + 2 + pin->packet_len)); ofpbuf_put_zeros(packet, packet_in_size); - oxm_put_match(packet, &match); + oxm_put_match(packet, &match, ofputil_protocol_to_ofp_version(protocol)); ofpbuf_put_zeros(packet, 2); ofpbuf_put(packet, pin->packet, pin->packet_len); - opi = packet->l3; + opi = packet->msg; opi->pi.buffer_id = htonl(pin->buffer_id); opi->pi.total_len = htons(pin->total_len); opi->pi.reason = pin->reason; opi->pi.table_id = pin->table_id; - if (protocol == OFPUTIL_P_OF13_OXM) { + if (protocol != OFPUTIL_P_OF12_OXM) { opi->cookie = pin->cookie; } @@ -3447,6 +3596,7 @@ ofputil_encode_packet_in(const struct ofputil_packet_in *pin, case OFPUTIL_P_OF12_OXM: case OFPUTIL_P_OF13_OXM: case OFPUTIL_P_OF14_OXM: + case OFPUTIL_P_OF15_OXM: packet = ofputil_encode_ofp12_packet_in(pin, protocol); break; @@ -3472,6 +3622,12 @@ ofputil_packet_in_reason_to_string(enum ofp_packet_in_reason reason, return "action"; case OFPR_INVALID_TTL: return "invalid_ttl"; + case OFPR_ACTION_SET: + return "action_set"; + case OFPR_GROUP: + return "group"; + case OFPR_PACKET_OUT: + return "packet_out"; case OFPR_N_REASONS: default: @@ -3636,8 +3792,6 @@ static enum ofperr ofputil_decode_ofp10_phy_port(struct ofputil_phy_port *pp, const struct ofp10_phy_port *opp) { - memset(pp, 0, sizeof *pp); - pp->port_no = u16_to_ofp(ntohs(opp->port_no)); memcpy(pp->hw_addr, opp->hw_addr, OFP_ETH_ALEN); ovs_strlcpy(pp->name, opp->name, OFP_MAX_PORT_NAME_LEN); @@ -3662,8 +3816,6 @@ ofputil_decode_ofp11_port(struct ofputil_phy_port *pp, { enum ofperr error; - memset(pp, 0, sizeof *pp); - error = ofputil_port_from_ofp11(op->port_no, &pp->port_no); if (error) { return error; @@ -3685,20 +3837,84 @@ ofputil_decode_ofp11_port(struct ofputil_phy_port *pp, return 0; } -static size_t -ofputil_get_phy_port_size(enum ofp_version ofp_version) +static enum ofperr +parse_ofp14_port_ethernet_property(const struct ofpbuf *payload, + struct ofputil_phy_port *pp) { - switch (ofp_version) { - case OFP10_VERSION: - return sizeof(struct ofp10_phy_port); - case OFP11_VERSION: - case OFP12_VERSION: - case OFP13_VERSION: - case OFP14_VERSION: - return sizeof(struct ofp11_port); - default: - OVS_NOT_REACHED(); + struct ofp14_port_desc_prop_ethernet *eth = payload->data; + + if (payload->size != sizeof *eth) { + return OFPERR_OFPBPC_BAD_LEN; + } + + pp->curr = netdev_port_features_from_ofp11(eth->curr); + pp->advertised = netdev_port_features_from_ofp11(eth->advertised); + pp->supported = netdev_port_features_from_ofp11(eth->supported); + pp->peer = netdev_port_features_from_ofp11(eth->peer); + + pp->curr_speed = ntohl(eth->curr_speed); + pp->max_speed = ntohl(eth->max_speed); + + return 0; +} + +static enum ofperr +ofputil_pull_ofp14_port(struct ofputil_phy_port *pp, struct ofpbuf *msg) +{ + struct ofpbuf properties; + struct ofp14_port *op; + enum ofperr error; + size_t len; + + op = ofpbuf_try_pull(msg, sizeof *op); + if (!op) { + return OFPERR_OFPBRC_BAD_LEN; + } + + len = ntohs(op->length); + if (len < sizeof *op || len - sizeof *op > msg->size) { + return OFPERR_OFPBRC_BAD_LEN; + } + len -= sizeof *op; + ofpbuf_use_const(&properties, ofpbuf_pull(msg, len), len); + + error = ofputil_port_from_ofp11(op->port_no, &pp->port_no); + if (error) { + return error; } + memcpy(pp->hw_addr, op->hw_addr, OFP_ETH_ALEN); + ovs_strlcpy(pp->name, op->name, OFP_MAX_PORT_NAME_LEN); + + pp->config = ntohl(op->config) & OFPPC11_ALL; + pp->state = ntohl(op->state) & OFPPS11_ALL; + + while (properties.size > 0) { + struct ofpbuf payload; + enum ofperr error; + uint16_t type; + + error = ofputil_pull_property(&properties, &payload, &type); + if (error) { + return error; + } + + switch (type) { + case OFPPDPT14_ETHERNET: + error = parse_ofp14_port_ethernet_property(&payload, pp); + break; + + default: + log_property(true, "unknown port property %"PRIu16, type); + error = 0; + break; + } + + if (error) { + return error; + } + } + + return 0; } static void @@ -3742,33 +3958,56 @@ ofputil_encode_ofp11_port(const struct ofputil_phy_port *pp, op->max_speed = htonl(pp->max_speed); } +static void +ofputil_put_ofp14_port(const struct ofputil_phy_port *pp, + struct ofpbuf *b) +{ + struct ofp14_port *op; + struct ofp14_port_desc_prop_ethernet *eth; + + ofpbuf_prealloc_tailroom(b, sizeof *op + sizeof *eth); + + op = ofpbuf_put_zeros(b, sizeof *op); + op->port_no = ofputil_port_to_ofp11(pp->port_no); + op->length = htons(sizeof *op + sizeof *eth); + memcpy(op->hw_addr, pp->hw_addr, ETH_ADDR_LEN); + ovs_strlcpy(op->name, pp->name, sizeof op->name); + op->config = htonl(pp->config & OFPPC11_ALL); + op->state = htonl(pp->state & OFPPS11_ALL); + + eth = ofpbuf_put_zeros(b, sizeof *eth); + eth->type = htons(OFPPDPT14_ETHERNET); + eth->length = htons(sizeof *eth); + eth->curr = netdev_port_features_to_ofp11(pp->curr); + eth->advertised = netdev_port_features_to_ofp11(pp->advertised); + eth->supported = netdev_port_features_to_ofp11(pp->supported); + eth->peer = netdev_port_features_to_ofp11(pp->peer); + eth->curr_speed = htonl(pp->curr_speed); + eth->max_speed = htonl(pp->max_speed); +} + static void ofputil_put_phy_port(enum ofp_version ofp_version, const struct ofputil_phy_port *pp, struct ofpbuf *b) { switch (ofp_version) { case OFP10_VERSION: { - struct ofp10_phy_port *opp; - if (b->size + sizeof *opp <= UINT16_MAX) { - opp = ofpbuf_put_uninit(b, sizeof *opp); - ofputil_encode_ofp10_phy_port(pp, opp); - } + struct ofp10_phy_port *opp = ofpbuf_put_uninit(b, sizeof *opp); + ofputil_encode_ofp10_phy_port(pp, opp); break; } case OFP11_VERSION: case OFP12_VERSION: case OFP13_VERSION: { - struct ofp11_port *op; - if (b->size + sizeof *op <= UINT16_MAX) { - op = ofpbuf_put_uninit(b, sizeof *op); - ofputil_encode_ofp11_port(pp, op); - } + struct ofp11_port *op = ofpbuf_put_uninit(b, sizeof *op); + ofputil_encode_ofp11_port(pp, op); break; } case OFP14_VERSION: - OVS_NOT_REACHED(); + case OFP15_VERSION: + ofputil_put_ofp14_port(pp, b); break; default: @@ -3776,37 +4015,68 @@ ofputil_put_phy_port(enum ofp_version ofp_version, } } -void -ofputil_append_port_desc_stats_reply(enum ofp_version ofp_version, - const struct ofputil_phy_port *pp, - struct list *replies) +enum ofperr +ofputil_decode_port_desc_stats_request(const struct ofp_header *request, + ofp_port_t *port) { - switch (ofp_version) { - case OFP10_VERSION: { - struct ofp10_phy_port *opp; + struct ofpbuf b; + enum ofpraw raw; - opp = ofpmp_append(replies, sizeof *opp); - ofputil_encode_ofp10_phy_port(pp, opp); - break; + ofpbuf_use_const(&b, request, ntohs(request->length)); + raw = ofpraw_pull_assert(&b); + if (raw == OFPRAW_OFPST10_PORT_DESC_REQUEST) { + *port = OFPP_ANY; + return 0; + } else if (raw == OFPRAW_OFPST15_PORT_DESC_REQUEST) { + ovs_be32 *ofp11_port; + + ofp11_port = ofpbuf_pull(&b, sizeof *ofp11_port); + return ofputil_port_from_ofp11(*ofp11_port, port); + } else { + OVS_NOT_REACHED(); } +} + +struct ofpbuf * +ofputil_encode_port_desc_stats_request(enum ofp_version ofp_version, + ofp_port_t port) +{ + struct ofpbuf *request; + ovs_be32 ofp11_port; + switch (ofp_version) { + case OFP10_VERSION: case OFP11_VERSION: case OFP12_VERSION: - case OFP13_VERSION: { - struct ofp11_port *op; - - op = ofpmp_append(replies, sizeof *op); - ofputil_encode_ofp11_port(pp, op); + case OFP13_VERSION: + case OFP14_VERSION: + request = ofpraw_alloc(OFPRAW_OFPST10_PORT_DESC_REQUEST, + ofp_version, 0); break; - } - case OFP14_VERSION: - OVS_NOT_REACHED(); + case OFP15_VERSION: + request = ofpraw_alloc(OFPRAW_OFPST15_PORT_DESC_REQUEST, + ofp_version, 0); + ofp11_port = ofputil_port_to_ofp11(port); + ofpbuf_put(request, &ofp11_port, sizeof ofp11_port); break; default: - OVS_NOT_REACHED(); + OVS_NOT_REACHED(); } + + return request; +} + +void +ofputil_append_port_desc_stats_reply(const struct ofputil_phy_port *pp, + struct ovs_list *replies) +{ + struct ofpbuf *reply = ofpbuf_from_list(list_back(replies)); + size_t start_ofs = reply->size; + + ofputil_put_phy_port(ofpmp_version(replies), pp, reply); + ofpmp_postappend(replies, start_ofs); } /* ofputil_switch_features */ @@ -3820,56 +4090,19 @@ BUILD_ASSERT_DECL((int) OFPUTIL_C_IP_REASM == OFPC_IP_REASM); BUILD_ASSERT_DECL((int) OFPUTIL_C_QUEUE_STATS == OFPC_QUEUE_STATS); BUILD_ASSERT_DECL((int) OFPUTIL_C_ARP_MATCH_IP == OFPC_ARP_MATCH_IP); -struct ofputil_action_bit_translation { - enum ofputil_action_bitmap ofputil_bit; - int of_bit; -}; - -static const struct ofputil_action_bit_translation of10_action_bits[] = { - { OFPUTIL_A_OUTPUT, OFPAT10_OUTPUT }, - { OFPUTIL_A_SET_VLAN_VID, OFPAT10_SET_VLAN_VID }, - { OFPUTIL_A_SET_VLAN_PCP, OFPAT10_SET_VLAN_PCP }, - { OFPUTIL_A_STRIP_VLAN, OFPAT10_STRIP_VLAN }, - { OFPUTIL_A_SET_DL_SRC, OFPAT10_SET_DL_SRC }, - { OFPUTIL_A_SET_DL_DST, OFPAT10_SET_DL_DST }, - { OFPUTIL_A_SET_NW_SRC, OFPAT10_SET_NW_SRC }, - { OFPUTIL_A_SET_NW_DST, OFPAT10_SET_NW_DST }, - { OFPUTIL_A_SET_NW_TOS, OFPAT10_SET_NW_TOS }, - { OFPUTIL_A_SET_TP_SRC, OFPAT10_SET_TP_SRC }, - { OFPUTIL_A_SET_TP_DST, OFPAT10_SET_TP_DST }, - { OFPUTIL_A_ENQUEUE, OFPAT10_ENQUEUE }, - { 0, 0 }, -}; - -static enum ofputil_action_bitmap -decode_action_bits(ovs_be32 of_actions, - const struct ofputil_action_bit_translation *x) -{ - enum ofputil_action_bitmap ofputil_actions; - - ofputil_actions = 0; - for (; x->ofputil_bit; x++) { - if (of_actions & htonl(1u << x->of_bit)) { - ofputil_actions |= x->ofputil_bit; - } - } - return ofputil_actions; -} - static uint32_t ofputil_capabilities_mask(enum ofp_version ofp_version) { - /* Handle capabilities whose bit is unique for all Open Flow versions */ + /* Handle capabilities whose bit is unique for all OpenFlow versions */ switch (ofp_version) { case OFP10_VERSION: case OFP11_VERSION: return OFPC_COMMON | OFPC_ARP_MATCH_IP; case OFP12_VERSION: case OFP13_VERSION: - return OFPC_COMMON | OFPC12_PORT_BLOCKED; case OFP14_VERSION: - OVS_NOT_REACHED(); - break; + case OFP15_VERSION: + return OFPC_COMMON | OFPC12_PORT_BLOCKED; default: /* Caller needs to check osf->header.version itself */ return 0; @@ -3901,21 +4134,18 @@ ofputil_decode_switch_features(const struct ofp_header *oh, features->capabilities = ntohl(osf->capabilities) & ofputil_capabilities_mask(oh->version); - if (b->size % ofputil_get_phy_port_size(oh->version)) { - return OFPERR_OFPBRC_BAD_LEN; - } - if (raw == OFPRAW_OFPT10_FEATURES_REPLY) { if (osf->capabilities & htonl(OFPC10_STP)) { features->capabilities |= OFPUTIL_C_STP; } - features->actions = decode_action_bits(osf->actions, of10_action_bits); + features->ofpacts = ofpact_bitmap_from_openflow(osf->actions, + OFP10_VERSION); } else if (raw == OFPRAW_OFPT11_FEATURES_REPLY || raw == OFPRAW_OFPT13_FEATURES_REPLY) { if (osf->capabilities & htonl(OFPC11_GROUP_STATS)) { features->capabilities |= OFPUTIL_C_GROUP_STATS; } - features->actions = 0; + features->ofpacts = 0; if (raw == OFPRAW_OFPT13_FEATURES_REPLY) { features->auxiliary_id = osf->auxiliary_id; } @@ -3926,53 +4156,46 @@ ofputil_decode_switch_features(const struct ofp_header *oh, return 0; } -/* Returns true if the maximum number of ports are in 'oh'. */ -static bool -max_ports_in_features(const struct ofp_header *oh) -{ - size_t pp_size = ofputil_get_phy_port_size(oh->version); - return ntohs(oh->length) + pp_size > UINT16_MAX; -} - -/* Given a buffer 'b' that contains a Features Reply message, checks if - * it contains the maximum number of ports that will fit. If so, it - * returns true and removes the ports from the message. The caller - * should then send an OFPST_PORT_DESC stats request to get the ports, - * since the switch may have more ports than could be represented in the - * Features Reply. Otherwise, returns false. - */ +/* In OpenFlow 1.0, 1.1, and 1.2, an OFPT_FEATURES_REPLY message lists all the + * switch's ports, unless there are too many to fit. In OpenFlow 1.3 and + * later, an OFPT_FEATURES_REPLY does not list ports at all. + * + * Given a buffer 'b' that contains a Features Reply message, this message + * checks if it contains a complete list of the switch's ports. Returns true, + * if so. Returns false if the list is missing (OF1.3+) or incomplete + * (OF1.0/1.1/1.2), and in the latter case removes all of the ports from the + * message. + * + * When this function returns false, the caller should send an OFPST_PORT_DESC + * stats request to get the ports. */ bool -ofputil_switch_features_ports_trunc(struct ofpbuf *b) +ofputil_switch_features_has_ports(struct ofpbuf *b) { struct ofp_header *oh = b->data; + size_t phy_port_size; - if (max_ports_in_features(oh)) { - /* Remove all the ports. */ - b->size = (sizeof(struct ofp_header) - + sizeof(struct ofp_switch_features)); - ofpmsg_update_length(b); + if (oh->version >= OFP13_VERSION) { + /* OpenFlow 1.3+ never has ports in the feature reply. */ + return false; + } + phy_port_size = (oh->version == OFP10_VERSION + ? sizeof(struct ofp10_phy_port) + : sizeof(struct ofp11_port)); + if (ntohs(oh->length) + phy_port_size <= UINT16_MAX) { + /* There's room for additional ports in the feature reply. + * Assume that the list is complete. */ return true; } + /* The feature reply has no room for more ports. Probably the list is + * truncated. Drop the ports and tell the caller to retrieve them with + * OFPST_PORT_DESC. */ + b->size = sizeof *oh + sizeof(struct ofp_switch_features); + ofpmsg_update_length(b); return false; } -static ovs_be32 -encode_action_bits(enum ofputil_action_bitmap ofputil_actions, - const struct ofputil_action_bit_translation *x) -{ - uint32_t of_actions; - - of_actions = 0; - for (; x->ofputil_bit; x++) { - if (ofputil_actions & x->ofputil_bit) { - of_actions |= 1 << x->of_bit; - } - } - return htonl(of_actions); -} - /* Returns a buffer owned by the caller that encodes 'features' in the format * required by 'protocol' with the given 'xid'. The caller should append port * information to the buffer with subsequent calls to @@ -3997,6 +4220,7 @@ ofputil_encode_switch_features(const struct ofputil_switch_features *features, break; case OFP13_VERSION: case OFP14_VERSION: + case OFP15_VERSION: raw = OFPRAW_OFPT13_FEATURES_REPLY; break; default: @@ -4016,10 +4240,12 @@ ofputil_encode_switch_features(const struct ofputil_switch_features *features, if (features->capabilities & OFPUTIL_C_STP) { osf->capabilities |= htonl(OFPC10_STP); } - osf->actions = encode_action_bits(features->actions, of10_action_bits); + osf->actions = ofpact_bitmap_to_openflow(features->ofpacts, + OFP10_VERSION); break; case OFP13_VERSION: case OFP14_VERSION: + case OFP15_VERSION: osf->auxiliary_id = features->auxiliary_id; /* fall through */ case OFP11_VERSION: @@ -4045,7 +4271,14 @@ ofputil_put_switch_features_port(const struct ofputil_phy_port *pp, const struct ofp_header *oh = b->data; if (oh->version < OFP13_VERSION) { + /* Try adding a port description to the message, but drop it again if + * the buffer overflows. (This possibility for overflow is why + * OpenFlow 1.3+ moved port descriptions into a multipart message.) */ + size_t start_ofs = b->size; ofputil_put_phy_port(oh->version, pp, b); + if (b->size > UINT16_MAX) { + b->size = start_ofs; + } } } @@ -4098,10 +4331,14 @@ ofputil_encode_port_status(const struct ofputil_port_status *ps, case OFP11_VERSION: case OFP12_VERSION: case OFP13_VERSION: - case OFP14_VERSION: raw = OFPRAW_OFPT11_PORT_STATUS; break; + case OFP14_VERSION: + case OFP15_VERSION: + raw = OFPRAW_OFPT14_PORT_STATUS; + break; + default: OVS_NOT_REACHED(); } @@ -4116,16 +4353,30 @@ ofputil_encode_port_status(const struct ofputil_port_status *ps, /* ofputil_port_mod */ -/* Decodes the OpenFlow "port mod" message in '*oh' into an abstract form in - * '*pm'. Returns 0 if successful, otherwise an OFPERR_* value. */ -enum ofperr -ofputil_decode_port_mod(const struct ofp_header *oh, - struct ofputil_port_mod *pm) +static enum ofperr +parse_port_mod_ethernet_property(struct ofpbuf *property, + struct ofputil_port_mod *pm) { - enum ofpraw raw; - struct ofpbuf b; + struct ofp14_port_mod_prop_ethernet *eth = property->data; - ofpbuf_use_const(&b, oh, ntohs(oh->length)); + if (property->size != sizeof *eth) { + return OFPERR_OFPBRC_BAD_LEN; + } + + pm->advertise = netdev_port_features_from_ofp11(eth->advertise); + return 0; +} + +/* Decodes the OpenFlow "port mod" message in '*oh' into an abstract form in + * '*pm'. Returns 0 if successful, otherwise an OFPERR_* value. */ +enum ofperr +ofputil_decode_port_mod(const struct ofp_header *oh, + struct ofputil_port_mod *pm, bool loose) +{ + enum ofpraw raw; + struct ofpbuf b; + + ofpbuf_use_const(&b, oh, ntohs(oh->length)); raw = ofpraw_pull_assert(&b); if (raw == OFPRAW_OFPT10_PORT_MOD) { @@ -4149,6 +4400,52 @@ ofputil_decode_port_mod(const struct ofp_header *oh, pm->config = ntohl(opm->config) & OFPPC11_ALL; pm->mask = ntohl(opm->mask) & OFPPC11_ALL; pm->advertise = netdev_port_features_from_ofp11(opm->advertise); + } else if (raw == OFPRAW_OFPT14_PORT_MOD) { + const struct ofp14_port_mod *opm = ofpbuf_pull(&b, sizeof *opm); + enum ofperr error; + + memset(pm, 0, sizeof *pm); + + error = ofputil_port_from_ofp11(opm->port_no, &pm->port_no); + if (error) { + return error; + } + + memcpy(pm->hw_addr, opm->hw_addr, ETH_ADDR_LEN); + pm->config = ntohl(opm->config) & OFPPC11_ALL; + pm->mask = ntohl(opm->mask) & OFPPC11_ALL; + + while (b.size > 0) { + struct ofpbuf property; + enum ofperr error; + uint16_t type; + + error = ofputil_pull_property(&b, &property, &type); + if (error) { + return error; + } + + switch (type) { + case OFPPMPT14_ETHERNET: + error = parse_port_mod_ethernet_property(&property, pm); + break; + + default: + log_property(loose, "unknown port_mod property %"PRIu16, type); + if (loose) { + error = 0; + } else if (type == OFPPMPT14_EXPERIMENTER) { + error = OFPERR_OFPBPC_BAD_EXPERIMENTER; + } else { + error = OFPERR_OFPBRC_BAD_TYPE; + } + break; + } + + if (error) { + return error; + } + } } else { return OFPERR_OFPBRC_BAD_TYPE; } @@ -4196,17 +4493,488 @@ ofputil_encode_port_mod(const struct ofputil_port_mod *pm, break; } case OFP14_VERSION: - OVS_NOT_REACHED(); + case OFP15_VERSION: { + struct ofp14_port_mod_prop_ethernet *eth; + struct ofp14_port_mod *opm; + + b = ofpraw_alloc(OFPRAW_OFPT14_PORT_MOD, ofp_version, sizeof *eth); + opm = ofpbuf_put_zeros(b, sizeof *opm); + opm->port_no = ofputil_port_to_ofp11(pm->port_no); + memcpy(opm->hw_addr, pm->hw_addr, ETH_ADDR_LEN); + opm->config = htonl(pm->config & OFPPC11_ALL); + opm->mask = htonl(pm->mask & OFPPC11_ALL); + + if (pm->advertise) { + eth = ofpbuf_put_zeros(b, sizeof *eth); + eth->type = htons(OFPPMPT14_ETHERNET); + eth->length = htons(sizeof *eth); + eth->advertise = netdev_port_features_to_ofp11(pm->advertise); + } break; + } default: OVS_NOT_REACHED(); } return b; } + +/* Table features. */ + +static enum ofperr +pull_table_feature_property(struct ofpbuf *msg, struct ofpbuf *payload, + uint16_t *typep) +{ + enum ofperr error; + + error = ofputil_pull_property(msg, payload, typep); + if (payload && !error) { + ofpbuf_pull(payload, sizeof(struct ofp_prop_header)); + } + return error; +} + +static enum ofperr +parse_action_bitmap(struct ofpbuf *payload, enum ofp_version ofp_version, + uint64_t *ofpacts) +{ + uint32_t types = 0; + + while (payload->size > 0) { + uint16_t type; + enum ofperr error; + + error = ofputil_pull_property__(payload, NULL, 1, &type); + if (error) { + return error; + } + if (type < CHAR_BIT * sizeof types) { + types |= 1u << type; + } + } + + *ofpacts = ofpact_bitmap_from_openflow(htonl(types), ofp_version); + return 0; +} + +static enum ofperr +parse_instruction_ids(struct ofpbuf *payload, bool loose, uint32_t *insts) +{ + *insts = 0; + while (payload->size > 0) { + enum ovs_instruction_type inst; + enum ofperr error; + uint16_t ofpit; + + /* OF1.3 and OF1.4 aren't clear about padding in the instruction IDs. + * It seems clear that they aren't padded to 8 bytes, though, because + * both standards say that "non-experimenter instructions are 4 bytes" + * and do not mention any padding before the first instruction ID. + * (There wouldn't be any point in padding to 8 bytes if the IDs were + * aligned on an odd 4-byte boundary.) + * + * Anyway, we just assume they're all glommed together on byte + * boundaries. */ + error = ofputil_pull_property__(payload, NULL, 1, &ofpit); + if (error) { + return error; + } + + error = ovs_instruction_type_from_inst_type(&inst, ofpit); + if (!error) { + *insts |= 1u << inst; + } else if (!loose) { + return error; + } + } + return 0; +} + +static enum ofperr +parse_table_features_next_table(struct ofpbuf *payload, + unsigned long int *next_tables) +{ + size_t i; + + memset(next_tables, 0, bitmap_n_bytes(255)); + for (i = 0; i < payload->size; i++) { + uint8_t id = ((const uint8_t *) payload->data)[i]; + if (id >= 255) { + return OFPERR_OFPBPC_BAD_VALUE; + } + bitmap_set1(next_tables, id); + } + return 0; +} + +static enum ofperr +parse_oxms(struct ofpbuf *payload, bool loose, + struct mf_bitmap *exactp, struct mf_bitmap *maskedp) +{ + struct mf_bitmap exact = MF_BITMAP_INITIALIZER; + struct mf_bitmap masked = MF_BITMAP_INITIALIZER; + + while (payload->size > 0) { + const struct mf_field *field; + enum ofperr error; + bool hasmask; + + error = nx_pull_header(payload, &field, &hasmask); + if (!error) { + bitmap_set1(hasmask ? masked.bm : exact.bm, field->id); + } else if (error != OFPERR_OFPBMC_BAD_FIELD || !loose) { + return error; + } + } + if (exactp) { + *exactp = exact; + } else if (!bitmap_is_all_zeros(exact.bm, MFF_N_IDS)) { + return OFPERR_OFPBMC_BAD_MASK; + } + if (maskedp) { + *maskedp = masked; + } else if (!bitmap_is_all_zeros(masked.bm, MFF_N_IDS)) { + return OFPERR_OFPBMC_BAD_MASK; + } + return 0; +} + +/* Converts an OFPMP_TABLE_FEATURES request or reply in 'msg' into an abstract + * ofputil_table_features in 'tf'. + * + * If 'loose' is true, this function ignores properties and values that it does + * not understand, as a controller would want to do when interpreting + * capabilities provided by a switch. If 'loose' is false, this function + * treats unknown properties and values as an error, as a switch would want to + * do when interpreting a configuration request made by a controller. + * + * A single OpenFlow message can specify features for multiple tables. Calling + * this function multiple times for a single 'msg' iterates through the tables + * in the message. The caller must initially leave 'msg''s layer pointers null + * and not modify them between calls. + * + * Returns 0 if successful, EOF if no tables were left in this 'msg', otherwise + * a positive "enum ofperr" value. */ +int +ofputil_decode_table_features(struct ofpbuf *msg, + struct ofputil_table_features *tf, bool loose) +{ + const struct ofp_header *oh; + struct ofp13_table_features *otf; + struct ofpbuf properties; + unsigned int len; + + memset(tf, 0, sizeof *tf); + + if (!msg->header) { + ofpraw_pull_assert(msg); + } + oh = msg->header; + + if (!msg->size) { + return EOF; + } + + if (msg->size < sizeof *otf) { + return OFPERR_OFPBPC_BAD_LEN; + } + + otf = msg->data; + len = ntohs(otf->length); + if (len < sizeof *otf || len % 8 || len > msg->size) { + return OFPERR_OFPBPC_BAD_LEN; + } + ofpbuf_use_const(&properties, ofpbuf_pull(msg, len), len); + ofpbuf_pull(&properties, sizeof *otf); + + tf->table_id = otf->table_id; + if (tf->table_id == OFPTT_ALL) { + return OFPERR_OFPTFFC_BAD_TABLE; + } + + ovs_strlcpy(tf->name, otf->name, OFP_MAX_TABLE_NAME_LEN); + tf->metadata_match = otf->metadata_match; + tf->metadata_write = otf->metadata_write; + tf->miss_config = ofputil_table_miss_from_config(otf->config, oh->version); + tf->max_entries = ntohl(otf->max_entries); + + while (properties.size > 0) { + struct ofpbuf payload; + enum ofperr error; + uint16_t type; + + error = pull_table_feature_property(&properties, &payload, &type); + if (error) { + return error; + } + + switch ((enum ofp13_table_feature_prop_type) type) { + case OFPTFPT13_INSTRUCTIONS: + error = parse_instruction_ids(&payload, loose, + &tf->nonmiss.instructions); + break; + case OFPTFPT13_INSTRUCTIONS_MISS: + error = parse_instruction_ids(&payload, loose, + &tf->miss.instructions); + break; + + case OFPTFPT13_NEXT_TABLES: + error = parse_table_features_next_table(&payload, + tf->nonmiss.next); + break; + case OFPTFPT13_NEXT_TABLES_MISS: + error = parse_table_features_next_table(&payload, tf->miss.next); + break; + + case OFPTFPT13_WRITE_ACTIONS: + error = parse_action_bitmap(&payload, oh->version, + &tf->nonmiss.write.ofpacts); + break; + case OFPTFPT13_WRITE_ACTIONS_MISS: + error = parse_action_bitmap(&payload, oh->version, + &tf->miss.write.ofpacts); + break; + + case OFPTFPT13_APPLY_ACTIONS: + error = parse_action_bitmap(&payload, oh->version, + &tf->nonmiss.apply.ofpacts); + break; + case OFPTFPT13_APPLY_ACTIONS_MISS: + error = parse_action_bitmap(&payload, oh->version, + &tf->miss.apply.ofpacts); + break; + + case OFPTFPT13_MATCH: + error = parse_oxms(&payload, loose, &tf->match, &tf->mask); + break; + case OFPTFPT13_WILDCARDS: + error = parse_oxms(&payload, loose, &tf->wildcard, NULL); + break; + + case OFPTFPT13_WRITE_SETFIELD: + error = parse_oxms(&payload, loose, + &tf->nonmiss.write.set_fields, NULL); + break; + case OFPTFPT13_WRITE_SETFIELD_MISS: + error = parse_oxms(&payload, loose, + &tf->miss.write.set_fields, NULL); + break; + case OFPTFPT13_APPLY_SETFIELD: + error = parse_oxms(&payload, loose, + &tf->nonmiss.apply.set_fields, NULL); + break; + case OFPTFPT13_APPLY_SETFIELD_MISS: + error = parse_oxms(&payload, loose, + &tf->miss.apply.set_fields, NULL); + break; + + case OFPTFPT13_EXPERIMENTER: + case OFPTFPT13_EXPERIMENTER_MISS: + default: + log_property(loose, "unknown table features property %"PRIu16, + type); + error = loose ? 0 : OFPERR_OFPBPC_BAD_TYPE; + break; + } + if (error) { + return error; + } + } + + /* Fix inconsistencies: + * + * - Turn on 'match' bits that are set in 'mask', because maskable + * fields are matchable. + * + * - Turn on 'wildcard' bits that are set in 'mask', because a field + * that is arbitrarily maskable can be wildcarded entirely. + * + * - Turn off 'wildcard' bits that are not in 'match', because a field + * must be matchable for it to be meaningfully wildcarded. */ + bitmap_or(tf->match.bm, tf->mask.bm, MFF_N_IDS); + bitmap_or(tf->wildcard.bm, tf->mask.bm, MFF_N_IDS); + bitmap_and(tf->wildcard.bm, tf->match.bm, MFF_N_IDS); + + return 0; +} + +/* Encodes and returns a request to obtain the table features of a switch. + * The message is encoded for OpenFlow version 'ofp_version'. */ +struct ofpbuf * +ofputil_encode_table_features_request(enum ofp_version ofp_version) +{ + struct ofpbuf *request = NULL; + + switch (ofp_version) { + case OFP10_VERSION: + case OFP11_VERSION: + case OFP12_VERSION: + ovs_fatal(0, "dump-table-features needs OpenFlow 1.3 or later " + "(\'-O OpenFlow13\')"); + case OFP13_VERSION: + case OFP14_VERSION: + case OFP15_VERSION: + request = ofpraw_alloc(OFPRAW_OFPST13_TABLE_FEATURES_REQUEST, + ofp_version, 0); + break; + default: + OVS_NOT_REACHED(); + } + + return request; +} + +static void +put_fields_property(struct ofpbuf *reply, + const struct mf_bitmap *fields, + const struct mf_bitmap *masks, + enum ofp13_table_feature_prop_type property, + enum ofp_version version) +{ + size_t start_ofs; + int field; + + start_ofs = start_property(reply, property); + BITMAP_FOR_EACH_1 (field, MFF_N_IDS, fields->bm) { + nx_put_header(reply, field, version, + masks && bitmap_is_set(masks->bm, field)); + } + end_property(reply, start_ofs); +} + +static void +put_table_action_features(struct ofpbuf *reply, + const struct ofputil_table_action_features *taf, + enum ofp13_table_feature_prop_type actions_type, + enum ofp13_table_feature_prop_type set_fields_type, + int miss_offset, enum ofp_version version) +{ + size_t start_ofs; + + start_ofs = start_property(reply, actions_type + miss_offset); + put_bitmap_properties(reply, + ntohl(ofpact_bitmap_to_openflow(taf->ofpacts, + version))); + end_property(reply, start_ofs); + + put_fields_property(reply, &taf->set_fields, NULL, + set_fields_type + miss_offset, version); +} + +static void +put_table_instruction_features( + struct ofpbuf *reply, const struct ofputil_table_instruction_features *tif, + int miss_offset, enum ofp_version version) +{ + size_t start_ofs; + uint8_t table_id; + + start_ofs = start_property(reply, OFPTFPT13_INSTRUCTIONS + miss_offset); + put_bitmap_properties(reply, + ntohl(ovsinst_bitmap_to_openflow(tif->instructions, + version))); + end_property(reply, start_ofs); + + start_ofs = start_property(reply, OFPTFPT13_NEXT_TABLES + miss_offset); + BITMAP_FOR_EACH_1 (table_id, 255, tif->next) { + ofpbuf_put(reply, &table_id, 1); + } + end_property(reply, start_ofs); + + put_table_action_features(reply, &tif->write, + OFPTFPT13_WRITE_ACTIONS, + OFPTFPT13_WRITE_SETFIELD, miss_offset, version); + put_table_action_features(reply, &tif->apply, + OFPTFPT13_APPLY_ACTIONS, + OFPTFPT13_APPLY_SETFIELD, miss_offset, version); +} + +void +ofputil_append_table_features_reply(const struct ofputil_table_features *tf, + struct ovs_list *replies) +{ + struct ofpbuf *reply = ofpbuf_from_list(list_back(replies)); + enum ofp_version version = ofpmp_version(replies); + size_t start_ofs = reply->size; + struct ofp13_table_features *otf; + + otf = ofpbuf_put_zeros(reply, sizeof *otf); + otf->table_id = tf->table_id; + ovs_strlcpy(otf->name, tf->name, sizeof otf->name); + otf->metadata_match = tf->metadata_match; + otf->metadata_write = tf->metadata_write; + otf->config = ofputil_table_miss_to_config(tf->miss_config, version); + otf->max_entries = htonl(tf->max_entries); + + put_table_instruction_features(reply, &tf->nonmiss, 0, version); + put_table_instruction_features(reply, &tf->miss, 1, version); + + put_fields_property(reply, &tf->match, &tf->mask, + OFPTFPT13_MATCH, version); + put_fields_property(reply, &tf->wildcard, NULL, + OFPTFPT13_WILDCARDS, version); + + otf = ofpbuf_at_assert(reply, start_ofs, sizeof *otf); + otf->length = htons(reply->size - start_ofs); + ofpmp_postappend(replies, start_ofs); +} /* ofputil_table_mod */ +/* Given 'config', taken from an OpenFlow 'version' message that specifies + * table configuration (a table mod, table stats, or table features message), + * returns the table miss configuration that it specifies. */ +static enum ofputil_table_miss +ofputil_table_miss_from_config(ovs_be32 config_, enum ofp_version version) +{ + uint32_t config = ntohl(config_); + + if (version < OFP13_VERSION) { + switch (config & OFPTC11_TABLE_MISS_MASK) { + case OFPTC11_TABLE_MISS_CONTROLLER: + return OFPUTIL_TABLE_MISS_CONTROLLER; + + case OFPTC11_TABLE_MISS_CONTINUE: + return OFPUTIL_TABLE_MISS_CONTINUE; + + case OFPTC11_TABLE_MISS_DROP: + return OFPUTIL_TABLE_MISS_DROP; + + default: + VLOG_WARN_RL(&bad_ofmsg_rl, "bad table miss config %d", config); + return OFPUTIL_TABLE_MISS_CONTROLLER; + } + } else { + return OFPUTIL_TABLE_MISS_DEFAULT; + } +} + +/* Given a table miss configuration, returns the corresponding OpenFlow table + * configuration for use in an OpenFlow message of the given 'version'. */ +ovs_be32 +ofputil_table_miss_to_config(enum ofputil_table_miss miss, + enum ofp_version version) +{ + if (version < OFP13_VERSION) { + switch (miss) { + case OFPUTIL_TABLE_MISS_CONTROLLER: + case OFPUTIL_TABLE_MISS_DEFAULT: + return htonl(OFPTC11_TABLE_MISS_CONTROLLER); + + case OFPUTIL_TABLE_MISS_CONTINUE: + return htonl(OFPTC11_TABLE_MISS_CONTINUE); + + case OFPUTIL_TABLE_MISS_DROP: + return htonl(OFPTC11_TABLE_MISS_DROP); + + default: + OVS_NOT_REACHED(); + } + } else { + return htonl(0); + } +} + /* Decodes the OpenFlow "table mod" message in '*oh' into an abstract form in * '*pm'. Returns 0 if successful, otherwise an OFPERR_* value. */ enum ofperr @@ -4223,7 +4991,16 @@ ofputil_decode_table_mod(const struct ofp_header *oh, const struct ofp11_table_mod *otm = b.data; pm->table_id = otm->table_id; - pm->config = ntohl(otm->config); + pm->miss_config = ofputil_table_miss_from_config(otm->config, + oh->version); + } else if (raw == OFPRAW_OFPT14_TABLE_MOD) { + const struct ofp14_table_mod *otm = ofpbuf_pull(&b, sizeof *otm); + + pm->table_id = otm->table_id; + pm->miss_config = ofputil_table_miss_from_config(otm->config, + oh->version); + /* We do not understand any properties yet, so we do not bother + * parsing them. */ } else { return OFPERR_OFPBRC_BAD_TYPE; } @@ -4255,12 +5032,21 @@ ofputil_encode_table_mod(const struct ofputil_table_mod *pm, b = ofpraw_alloc(OFPRAW_OFPT11_TABLE_MOD, ofp_version, 0); otm = ofpbuf_put_zeros(b, sizeof *otm); otm->table_id = pm->table_id; - otm->config = htonl(pm->config); + otm->config = ofputil_table_miss_to_config(pm->miss_config, + ofp_version); break; } case OFP14_VERSION: - OVS_NOT_REACHED(); + case OFP15_VERSION: { + struct ofp14_table_mod *otm; + + b = ofpraw_alloc(OFPRAW_OFPT14_TABLE_MOD, ofp_version, 0); + otm = ofpbuf_put_zeros(b, sizeof *otm); + otm->table_id = pm->table_id; + otm->config = ofputil_table_miss_to_config(pm->miss_config, + ofp_version); break; + } default: OVS_NOT_REACHED(); } @@ -4285,7 +5071,7 @@ ofputil_decode_role_message(const struct ofp_header *oh, if (raw == OFPRAW_OFPT12_ROLE_REQUEST || raw == OFPRAW_OFPT12_ROLE_REPLY) { - const struct ofp12_role_request *orr = b.l3; + const struct ofp12_role_request *orr = b.msg; if (orr->role != htonl(OFPCR12_ROLE_NOCHANGE) && orr->role != htonl(OFPCR12_ROLE_EQUAL) && @@ -4306,7 +5092,7 @@ ofputil_decode_role_message(const struct ofp_header *oh, } } else if (raw == OFPRAW_NXT_ROLE_REQUEST || raw == OFPRAW_NXT_ROLE_REPLY) { - const struct nx_role_request *nrr = b.l3; + const struct nx_role_request *nrr = b.msg; BUILD_ASSERT(NX_ROLE_OTHER + 1 == OFPCR12_ROLE_EQUAL); BUILD_ASSERT(NX_ROLE_MASTER + 1 == OFPCR12_ROLE_MASTER); @@ -4365,22 +5151,31 @@ ofputil_encode_role_reply(const struct ofp_header *request, return buf; } +/* Encodes "role status" message 'status' for sending in the given + * 'protocol'. Returns the role status message, if 'protocol' supports them, + * otherwise a null pointer. */ struct ofpbuf * ofputil_encode_role_status(const struct ofputil_role_status *status, enum ofputil_protocol protocol) { - struct ofpbuf *buf; enum ofp_version version; - struct ofp14_role_status *rstatus; version = ofputil_protocol_to_ofp_version(protocol); - buf = ofpraw_alloc_xid(OFPRAW_OFPT14_ROLE_STATUS, version, htonl(0), 0); - rstatus = ofpbuf_put_zeros(buf, sizeof *rstatus); - rstatus->role = htonl(status->role); - rstatus->reason = status->reason; - rstatus->generation_id = htonll(status->generation_id); - - return buf; + if (version >= OFP14_VERSION) { + struct ofp14_role_status *rstatus; + struct ofpbuf *buf; + + buf = ofpraw_alloc_xid(OFPRAW_OFPT14_ROLE_STATUS, version, htonl(0), + 0); + rstatus = ofpbuf_put_zeros(buf, sizeof *rstatus); + rstatus->role = htonl(status->role); + rstatus->reason = status->reason; + rstatus->generation_id = htonll(status->generation_id); + + return buf; + } else { + return NULL; + } } enum ofperr @@ -4395,7 +5190,7 @@ ofputil_decode_role_status(const struct ofp_header *oh, raw = ofpraw_pull_assert(&b); ovs_assert(raw == OFPRAW_OFPT14_ROLE_STATUS); - r = b.l3; + r = b.msg; if (r->role != htonl(OFPCR12_ROLE_NOCHANGE) && r->role != htonl(OFPCR12_ROLE_EQUAL) && r->role != htonl(OFPCR12_ROLE_MASTER) && @@ -4412,171 +5207,414 @@ ofputil_decode_role_status(const struct ofp_header *oh, /* Table stats. */ +/* OpenFlow 1.0 and 1.1 don't distinguish between a field that cannot be + * matched and a field that must be wildcarded. This function returns a bitmap + * that contains both kinds of fields. */ +static struct mf_bitmap +wild_or_nonmatchable_fields(const struct ofputil_table_features *features) +{ + struct mf_bitmap wc = features->match; + bitmap_not(wc.bm, MFF_N_IDS); + bitmap_or(wc.bm, features->wildcard.bm, MFF_N_IDS); + return wc; +} + +struct ofp10_wc_map { + enum ofp10_flow_wildcards wc10; + enum mf_field_id mf; +}; + +static const struct ofp10_wc_map ofp10_wc_map[] = { + { OFPFW10_IN_PORT, MFF_IN_PORT }, + { OFPFW10_DL_VLAN, MFF_VLAN_VID }, + { OFPFW10_DL_SRC, MFF_ETH_SRC }, + { OFPFW10_DL_DST, MFF_ETH_DST}, + { OFPFW10_DL_TYPE, MFF_ETH_TYPE }, + { OFPFW10_NW_PROTO, MFF_IP_PROTO }, + { OFPFW10_TP_SRC, MFF_TCP_SRC }, + { OFPFW10_TP_DST, MFF_TCP_DST }, + { OFPFW10_NW_SRC_MASK, MFF_IPV4_SRC }, + { OFPFW10_NW_DST_MASK, MFF_IPV4_DST }, + { OFPFW10_DL_VLAN_PCP, MFF_VLAN_PCP }, + { OFPFW10_NW_TOS, MFF_IP_DSCP }, +}; + +static ovs_be32 +mf_bitmap_to_of10(const struct mf_bitmap *fields) +{ + const struct ofp10_wc_map *p; + uint32_t wc10 = 0; + + for (p = ofp10_wc_map; p < &ofp10_wc_map[ARRAY_SIZE(ofp10_wc_map)]; p++) { + if (bitmap_is_set(fields->bm, p->mf)) { + wc10 |= p->wc10; + } + } + return htonl(wc10); +} + +static struct mf_bitmap +mf_bitmap_from_of10(ovs_be32 wc10_) +{ + struct mf_bitmap fields = MF_BITMAP_INITIALIZER; + const struct ofp10_wc_map *p; + uint32_t wc10 = ntohl(wc10_); + + for (p = ofp10_wc_map; p < &ofp10_wc_map[ARRAY_SIZE(ofp10_wc_map)]; p++) { + if (wc10 & p->wc10) { + bitmap_set1(fields.bm, p->mf); + } + } + return fields; +} + static void -ofputil_put_ofp10_table_stats(const struct ofp12_table_stats *in, +ofputil_put_ofp10_table_stats(const struct ofputil_table_stats *stats, + const struct ofputil_table_features *features, struct ofpbuf *buf) { - struct wc_map { - enum ofp10_flow_wildcards wc10; - enum oxm12_ofb_match_fields mf12; - }; - - static const struct wc_map wc_map[] = { - { OFPFW10_IN_PORT, OFPXMT12_OFB_IN_PORT }, - { OFPFW10_DL_VLAN, OFPXMT12_OFB_VLAN_VID }, - { OFPFW10_DL_SRC, OFPXMT12_OFB_ETH_SRC }, - { OFPFW10_DL_DST, OFPXMT12_OFB_ETH_DST}, - { OFPFW10_DL_TYPE, OFPXMT12_OFB_ETH_TYPE }, - { OFPFW10_NW_PROTO, OFPXMT12_OFB_IP_PROTO }, - { OFPFW10_TP_SRC, OFPXMT12_OFB_TCP_SRC }, - { OFPFW10_TP_DST, OFPXMT12_OFB_TCP_DST }, - { OFPFW10_NW_SRC_MASK, OFPXMT12_OFB_IPV4_SRC }, - { OFPFW10_NW_DST_MASK, OFPXMT12_OFB_IPV4_DST }, - { OFPFW10_DL_VLAN_PCP, OFPXMT12_OFB_VLAN_PCP }, - { OFPFW10_NW_TOS, OFPXMT12_OFB_IP_DSCP }, - }; - + struct mf_bitmap wc = wild_or_nonmatchable_fields(features); struct ofp10_table_stats *out; - const struct wc_map *p; out = ofpbuf_put_zeros(buf, sizeof *out); - out->table_id = in->table_id; - ovs_strlcpy(out->name, in->name, sizeof out->name); - out->wildcards = 0; - for (p = wc_map; p < &wc_map[ARRAY_SIZE(wc_map)]; p++) { - if (in->wildcards & htonll(1ULL << p->mf12)) { - out->wildcards |= htonl(p->wc10); + out->table_id = features->table_id; + ovs_strlcpy(out->name, features->name, sizeof out->name); + out->wildcards = mf_bitmap_to_of10(&wc); + out->max_entries = htonl(features->max_entries); + out->active_count = htonl(stats->active_count); + put_32aligned_be64(&out->lookup_count, htonll(stats->lookup_count)); + put_32aligned_be64(&out->matched_count, htonll(stats->matched_count)); +} + +struct ofp11_wc_map { + enum ofp11_flow_match_fields wc11; + enum mf_field_id mf; +}; + +static const struct ofp11_wc_map ofp11_wc_map[] = { + { OFPFMF11_IN_PORT, MFF_IN_PORT }, + { OFPFMF11_DL_VLAN, MFF_VLAN_VID }, + { OFPFMF11_DL_VLAN_PCP, MFF_VLAN_PCP }, + { OFPFMF11_DL_TYPE, MFF_ETH_TYPE }, + { OFPFMF11_NW_TOS, MFF_IP_DSCP }, + { OFPFMF11_NW_PROTO, MFF_IP_PROTO }, + { OFPFMF11_TP_SRC, MFF_TCP_SRC }, + { OFPFMF11_TP_DST, MFF_TCP_DST }, + { OFPFMF11_MPLS_LABEL, MFF_MPLS_LABEL }, + { OFPFMF11_MPLS_TC, MFF_MPLS_TC }, + /* I don't know what OFPFMF11_TYPE means. */ + { OFPFMF11_DL_SRC, MFF_ETH_SRC }, + { OFPFMF11_DL_DST, MFF_ETH_DST }, + { OFPFMF11_NW_SRC, MFF_IPV4_SRC }, + { OFPFMF11_NW_DST, MFF_IPV4_DST }, + { OFPFMF11_METADATA, MFF_METADATA }, +}; + +static ovs_be32 +mf_bitmap_to_of11(const struct mf_bitmap *fields) +{ + const struct ofp11_wc_map *p; + uint32_t wc11 = 0; + + for (p = ofp11_wc_map; p < &ofp11_wc_map[ARRAY_SIZE(ofp11_wc_map)]; p++) { + if (bitmap_is_set(fields->bm, p->mf)) { + wc11 |= p->wc11; } } - out->max_entries = in->max_entries; - out->active_count = in->active_count; - put_32aligned_be64(&out->lookup_count, in->lookup_count); - put_32aligned_be64(&out->matched_count, in->matched_count); + return htonl(wc11); } -static ovs_be32 -oxm12_to_ofp11_flow_match_fields(ovs_be64 oxm12) -{ - struct map { - enum ofp11_flow_match_fields fmf11; - enum oxm12_ofb_match_fields mf12; - }; - - static const struct map map[] = { - { OFPFMF11_IN_PORT, OFPXMT12_OFB_IN_PORT }, - { OFPFMF11_DL_VLAN, OFPXMT12_OFB_VLAN_VID }, - { OFPFMF11_DL_VLAN_PCP, OFPXMT12_OFB_VLAN_PCP }, - { OFPFMF11_DL_TYPE, OFPXMT12_OFB_ETH_TYPE }, - { OFPFMF11_NW_TOS, OFPXMT12_OFB_IP_DSCP }, - { OFPFMF11_NW_PROTO, OFPXMT12_OFB_IP_PROTO }, - { OFPFMF11_TP_SRC, OFPXMT12_OFB_TCP_SRC }, - { OFPFMF11_TP_DST, OFPXMT12_OFB_TCP_DST }, - { OFPFMF11_MPLS_LABEL, OFPXMT12_OFB_MPLS_LABEL }, - { OFPFMF11_MPLS_TC, OFPXMT12_OFB_MPLS_TC }, - /* I don't know what OFPFMF11_TYPE means. */ - { OFPFMF11_DL_SRC, OFPXMT12_OFB_ETH_SRC }, - { OFPFMF11_DL_DST, OFPXMT12_OFB_ETH_DST }, - { OFPFMF11_NW_SRC, OFPXMT12_OFB_IPV4_SRC }, - { OFPFMF11_NW_DST, OFPXMT12_OFB_IPV4_DST }, - { OFPFMF11_METADATA, OFPXMT12_OFB_METADATA }, - }; - - const struct map *p; - uint32_t fmf11; - - fmf11 = 0; - for (p = map; p < &map[ARRAY_SIZE(map)]; p++) { - if (oxm12 & htonll(1ULL << p->mf12)) { - fmf11 |= p->fmf11; - } - } - return htonl(fmf11); +static struct mf_bitmap +mf_bitmap_from_of11(ovs_be32 wc11_) +{ + struct mf_bitmap fields = MF_BITMAP_INITIALIZER; + const struct ofp11_wc_map *p; + uint32_t wc11 = ntohl(wc11_); + + for (p = ofp11_wc_map; p < &ofp11_wc_map[ARRAY_SIZE(ofp11_wc_map)]; p++) { + if (wc11 & p->wc11) { + bitmap_set1(fields.bm, p->mf); + } + } + return fields; } static void -ofputil_put_ofp11_table_stats(const struct ofp12_table_stats *in, +ofputil_put_ofp11_table_stats(const struct ofputil_table_stats *stats, + const struct ofputil_table_features *features, struct ofpbuf *buf) { + struct mf_bitmap wc = wild_or_nonmatchable_fields(features); struct ofp11_table_stats *out; out = ofpbuf_put_zeros(buf, sizeof *out); - out->table_id = in->table_id; - ovs_strlcpy(out->name, in->name, sizeof out->name); - out->wildcards = oxm12_to_ofp11_flow_match_fields(in->wildcards); - out->match = oxm12_to_ofp11_flow_match_fields(in->match); - out->instructions = in->instructions; - out->write_actions = in->write_actions; - out->apply_actions = in->apply_actions; - out->config = in->config; - out->max_entries = in->max_entries; - out->active_count = in->active_count; - out->lookup_count = in->lookup_count; - out->matched_count = in->matched_count; + out->table_id = features->table_id; + ovs_strlcpy(out->name, features->name, sizeof out->name); + out->wildcards = mf_bitmap_to_of11(&wc); + out->match = mf_bitmap_to_of11(&features->match); + out->instructions = ovsinst_bitmap_to_openflow( + features->nonmiss.instructions, OFP11_VERSION); + out->write_actions = ofpact_bitmap_to_openflow( + features->nonmiss.write.ofpacts, OFP11_VERSION); + out->apply_actions = ofpact_bitmap_to_openflow( + features->nonmiss.apply.ofpacts, OFP11_VERSION); + out->config = htonl(features->miss_config); + out->max_entries = htonl(features->max_entries); + out->active_count = htonl(stats->active_count); + out->lookup_count = htonll(stats->lookup_count); + out->matched_count = htonll(stats->matched_count); } static void -ofputil_put_ofp12_table_stats(const struct ofp12_table_stats *in, +ofputil_put_ofp12_table_stats(const struct ofputil_table_stats *stats, + const struct ofputil_table_features *features, struct ofpbuf *buf) { - struct ofp12_table_stats *out = ofpbuf_put(buf, in, sizeof *in); + struct ofp12_table_stats *out; - /* Trim off OF1.3-only capabilities. */ - out->match &= htonll(OFPXMT12_MASK); - out->wildcards &= htonll(OFPXMT12_MASK); - out->write_setfields &= htonll(OFPXMT12_MASK); - out->apply_setfields &= htonll(OFPXMT12_MASK); + out = ofpbuf_put_zeros(buf, sizeof *out); + out->table_id = features->table_id; + ovs_strlcpy(out->name, features->name, sizeof out->name); + out->match = oxm_bitmap_from_mf_bitmap(&features->match, OFP12_VERSION); + out->wildcards = oxm_bitmap_from_mf_bitmap(&features->wildcard, + OFP12_VERSION); + out->write_actions = ofpact_bitmap_to_openflow( + features->nonmiss.write.ofpacts, OFP12_VERSION); + out->apply_actions = ofpact_bitmap_to_openflow( + features->nonmiss.apply.ofpacts, OFP12_VERSION); + out->write_setfields = oxm_bitmap_from_mf_bitmap( + &features->nonmiss.write.set_fields, OFP12_VERSION); + out->apply_setfields = oxm_bitmap_from_mf_bitmap( + &features->nonmiss.apply.set_fields, OFP12_VERSION); + out->metadata_match = features->metadata_match; + out->metadata_write = features->metadata_write; + out->instructions = ovsinst_bitmap_to_openflow( + features->nonmiss.instructions, OFP12_VERSION); + out->config = ofputil_table_miss_to_config(features->miss_config, + OFP12_VERSION); + out->max_entries = htonl(features->max_entries); + out->active_count = htonl(stats->active_count); + out->lookup_count = htonll(stats->lookup_count); + out->matched_count = htonll(stats->matched_count); } static void -ofputil_put_ofp13_table_stats(const struct ofp12_table_stats *in, +ofputil_put_ofp13_table_stats(const struct ofputil_table_stats *stats, struct ofpbuf *buf) { struct ofp13_table_stats *out; - /* OF 1.3 splits table features off the ofp_table_stats, - * so there is not much here. */ - - out = ofpbuf_put_uninit(buf, sizeof *out); - out->table_id = in->table_id; - out->active_count = in->active_count; - out->lookup_count = in->lookup_count; - out->matched_count = in->matched_count; + out = ofpbuf_put_zeros(buf, sizeof *out); + out->table_id = stats->table_id; + out->active_count = htonl(stats->active_count); + out->lookup_count = htonll(stats->lookup_count); + out->matched_count = htonll(stats->matched_count); } struct ofpbuf * -ofputil_encode_table_stats_reply(const struct ofp12_table_stats stats[], int n, - const struct ofp_header *request) +ofputil_encode_table_stats_reply(const struct ofp_header *request) { - struct ofpbuf *reply; - int i; + return ofpraw_alloc_stats_reply(request, 0); +} - reply = ofpraw_alloc_stats_reply(request, n * sizeof *stats); +void +ofputil_append_table_stats_reply(struct ofpbuf *reply, + const struct ofputil_table_stats *stats, + const struct ofputil_table_features *features) +{ + struct ofp_header *oh = reply->header; - for (i = 0; i < n; i++) { - switch ((enum ofp_version) request->version) { - case OFP10_VERSION: - ofputil_put_ofp10_table_stats(&stats[i], reply); - break; + ovs_assert(stats->table_id == features->table_id); - case OFP11_VERSION: - ofputil_put_ofp11_table_stats(&stats[i], reply); - break; + switch ((enum ofp_version) oh->version) { + case OFP10_VERSION: + ofputil_put_ofp10_table_stats(stats, features, reply); + break; - case OFP12_VERSION: - ofputil_put_ofp12_table_stats(&stats[i], reply); - break; + case OFP11_VERSION: + ofputil_put_ofp11_table_stats(stats, features, reply); + break; - case OFP13_VERSION: - case OFP14_VERSION: - ofputil_put_ofp13_table_stats(&stats[i], reply); - break; + case OFP12_VERSION: + ofputil_put_ofp12_table_stats(stats, features, reply); + break; - default: - OVS_NOT_REACHED(); - } + case OFP13_VERSION: + case OFP14_VERSION: + case OFP15_VERSION: + ofputil_put_ofp13_table_stats(stats, reply); + break; + + default: + OVS_NOT_REACHED(); } +} - return reply; +static int +ofputil_decode_ofp10_table_stats(struct ofpbuf *msg, + struct ofputil_table_stats *stats, + struct ofputil_table_features *features) +{ + struct ofp10_table_stats *ots; + + ots = ofpbuf_try_pull(msg, sizeof *ots); + if (!ots) { + return OFPERR_OFPBRC_BAD_LEN; + } + + features->table_id = ots->table_id; + ovs_strlcpy(features->name, ots->name, sizeof features->name); + features->max_entries = ntohl(ots->max_entries); + features->match = features->wildcard = mf_bitmap_from_of10(ots->wildcards); + + stats->table_id = ots->table_id; + stats->active_count = ntohl(ots->active_count); + stats->lookup_count = ntohll(get_32aligned_be64(&ots->lookup_count)); + stats->matched_count = ntohll(get_32aligned_be64(&ots->matched_count)); + + return 0; +} + +static int +ofputil_decode_ofp11_table_stats(struct ofpbuf *msg, + struct ofputil_table_stats *stats, + struct ofputil_table_features *features) +{ + struct ofp11_table_stats *ots; + + ots = ofpbuf_try_pull(msg, sizeof *ots); + if (!ots) { + return OFPERR_OFPBRC_BAD_LEN; + } + + features->table_id = ots->table_id; + ovs_strlcpy(features->name, ots->name, sizeof features->name); + features->max_entries = ntohl(ots->max_entries); + features->nonmiss.instructions = ovsinst_bitmap_from_openflow( + ots->instructions, OFP11_VERSION); + features->nonmiss.write.ofpacts = ofpact_bitmap_from_openflow( + ots->write_actions, OFP11_VERSION); + features->nonmiss.apply.ofpacts = ofpact_bitmap_from_openflow( + ots->write_actions, OFP11_VERSION); + features->miss = features->nonmiss; + features->miss_config = ofputil_table_miss_from_config(ots->config, + OFP11_VERSION); + features->match = mf_bitmap_from_of11(ots->match); + features->wildcard = mf_bitmap_from_of11(ots->wildcards); + bitmap_or(features->match.bm, features->wildcard.bm, MFF_N_IDS); + + stats->table_id = ots->table_id; + stats->active_count = ntohl(ots->active_count); + stats->lookup_count = ntohll(ots->lookup_count); + stats->matched_count = ntohll(ots->matched_count); + + return 0; +} + +static int +ofputil_decode_ofp12_table_stats(struct ofpbuf *msg, + struct ofputil_table_stats *stats, + struct ofputil_table_features *features) +{ + struct ofp12_table_stats *ots; + + ots = ofpbuf_try_pull(msg, sizeof *ots); + if (!ots) { + return OFPERR_OFPBRC_BAD_LEN; + } + + features->table_id = ots->table_id; + ovs_strlcpy(features->name, ots->name, sizeof features->name); + features->metadata_match = ots->metadata_match; + features->metadata_write = ots->metadata_write; + features->miss_config = ofputil_table_miss_from_config(ots->config, + OFP12_VERSION); + features->max_entries = ntohl(ots->max_entries); + + features->nonmiss.instructions = ovsinst_bitmap_from_openflow( + ots->instructions, OFP12_VERSION); + features->nonmiss.write.ofpacts = ofpact_bitmap_from_openflow( + ots->write_actions, OFP12_VERSION); + features->nonmiss.apply.ofpacts = ofpact_bitmap_from_openflow( + ots->apply_actions, OFP12_VERSION); + features->nonmiss.write.set_fields = oxm_bitmap_to_mf_bitmap( + ots->write_setfields, OFP12_VERSION); + features->nonmiss.apply.set_fields = oxm_bitmap_to_mf_bitmap( + ots->apply_setfields, OFP12_VERSION); + features->miss = features->nonmiss; + + features->match = oxm_bitmap_to_mf_bitmap(ots->match, OFP12_VERSION); + features->wildcard = oxm_bitmap_to_mf_bitmap(ots->wildcards, + OFP12_VERSION); + bitmap_or(features->match.bm, features->wildcard.bm, MFF_N_IDS); + + stats->table_id = ots->table_id; + stats->active_count = ntohl(ots->active_count); + stats->lookup_count = ntohll(ots->lookup_count); + stats->matched_count = ntohll(ots->matched_count); + + return 0; +} + +static int +ofputil_decode_ofp13_table_stats(struct ofpbuf *msg, + struct ofputil_table_stats *stats, + struct ofputil_table_features *features) +{ + struct ofp13_table_stats *ots; + + ots = ofpbuf_try_pull(msg, sizeof *ots); + if (!ots) { + return OFPERR_OFPBRC_BAD_LEN; + } + + features->table_id = ots->table_id; + + stats->table_id = ots->table_id; + stats->active_count = ntohl(ots->active_count); + stats->lookup_count = ntohll(ots->lookup_count); + stats->matched_count = ntohll(ots->matched_count); + + return 0; +} + +int +ofputil_decode_table_stats_reply(struct ofpbuf *msg, + struct ofputil_table_stats *stats, + struct ofputil_table_features *features) +{ + const struct ofp_header *oh; + + if (!msg->header) { + ofpraw_pull_assert(msg); + } + oh = msg->header; + + if (!msg->size) { + return EOF; + } + + memset(stats, 0, sizeof *stats); + memset(features, 0, sizeof *features); + + switch ((enum ofp_version) oh->version) { + case OFP10_VERSION: + return ofputil_decode_ofp10_table_stats(msg, stats, features); + + case OFP11_VERSION: + return ofputil_decode_ofp11_table_stats(msg, stats, features); + + case OFP12_VERSION: + return ofputil_decode_ofp12_table_stats(msg, stats, features); + + case OFP13_VERSION: + case OFP14_VERSION: + case OFP15_VERSION: + return ofputil_decode_ofp13_table_stats(msg, stats, features); + + default: + OVS_NOT_REACHED(); + } } /* ofputil_flow_monitor_request */ @@ -4598,8 +5636,7 @@ ofputil_decode_flow_monitor_request(struct ofputil_flow_monitor_request *rq, struct nx_flow_monitor_request *nfmr; uint16_t flags; - if (!msg->l2) { - msg->l2 = msg->data; + if (!msg->header) { ofpraw_pull_assert(msg); } @@ -4609,7 +5646,7 @@ ofputil_decode_flow_monitor_request(struct ofputil_flow_monitor_request *rq, nfmr = ofpbuf_try_pull(msg, sizeof *nfmr); if (!nfmr) { - VLOG_WARN_RL(&bad_ofmsg_rl, "NXST_FLOW_MONITOR request has %"PRIuSIZE" " + VLOG_WARN_RL(&bad_ofmsg_rl, "NXST_FLOW_MONITOR request has %"PRIu32" " "leftover bytes at end", msg->size); return OFPERR_OFPBRC_BAD_LEN; } @@ -4620,7 +5657,7 @@ ofputil_decode_flow_monitor_request(struct ofputil_flow_monitor_request *rq, | NXFMF_MODIFY | NXFMF_ACTIONS | NXFMF_OWN)) { VLOG_WARN_RL(&bad_ofmsg_rl, "NXST_FLOW_MONITOR has bad flags %#"PRIx16, flags); - return OFPERR_NXBRC_FM_BAD_FLAGS; + return OFPERR_OFPMOFC_BAD_FLAGS; } if (!is_all_zeros(nfmr->zeros, sizeof nfmr->zeros)) { @@ -4683,8 +5720,7 @@ ofputil_decode_flow_update(struct ofputil_flow_update *update, unsigned int length; struct ofp_header *oh; - if (!msg->l2) { - msg->l2 = msg->data; + if (!msg->header) { ofpraw_pull_assert(msg); } @@ -4696,7 +5732,7 @@ ofputil_decode_flow_update(struct ofputil_flow_update *update, goto bad_len; } - oh = msg->l2; + oh = msg->header; nfuh = msg->data; update->event = ntohs(nfuh->event); @@ -4763,7 +5799,7 @@ ofputil_decode_flow_update(struct ofputil_flow_update *update, } bad_len: - VLOG_WARN_RL(&bad_ofmsg_rl, "NXST_FLOW_MONITOR reply has %"PRIuSIZE" " + VLOG_WARN_RL(&bad_ofmsg_rl, "NXST_FLOW_MONITOR reply has %"PRIu32" " "leftover bytes at end", msg->size); return OFPERR_OFPBRC_BAD_LEN; } @@ -4789,7 +5825,7 @@ ofputil_encode_flow_monitor_cancel(uint32_t id) } void -ofputil_start_flow_update(struct list *replies) +ofputil_start_flow_update(struct ovs_list *replies) { struct ofpbuf *msg; @@ -4802,16 +5838,15 @@ ofputil_start_flow_update(struct list *replies) void ofputil_append_flow_update(const struct ofputil_flow_update *update, - struct list *replies) + struct ovs_list *replies) { + enum ofp_version version = ofpmp_version(replies); struct nx_flow_update_header *nfuh; struct ofpbuf *msg; size_t start_ofs; - enum ofp_version version; msg = ofpbuf_from_list(list_back(replies)); start_ofs = msg->size; - version = ((struct ofp_header *)msg->l2)->version; if (update->event == NXFME_ABBREV) { struct nx_flow_update_abbrev *nfua; @@ -4867,7 +5902,7 @@ ofputil_encode_packet_out(const struct ofputil_packet_out *po, ofpacts_put_openflow_actions(po->ofpacts, po->ofpacts_len, msg, ofp_version); - opo = msg->l3; + opo = msg->msg; opo->buffer_id = htonl(po->buffer_id); opo->in_port = htons(ofp_to_u16(po->in_port)); opo->actions_len = htons(msg->size - actions_ofs); @@ -4877,7 +5912,8 @@ ofputil_encode_packet_out(const struct ofputil_packet_out *po, case OFP11_VERSION: case OFP12_VERSION: case OFP13_VERSION: - case OFP14_VERSION:{ + case OFP14_VERSION: + case OFP15_VERSION: { struct ofp11_packet_out *opo; size_t len; @@ -4885,7 +5921,7 @@ ofputil_encode_packet_out(const struct ofputil_packet_out *po, ofpbuf_put_zeros(msg, sizeof *opo); len = ofpacts_put_openflow_actions(po->ofpacts, po->ofpacts_len, msg, ofp_version); - opo = msg->l3; + opo = msg->msg; opo->buffer_id = htonl(po->buffer_id); opo->in_port = ofputil_port_to_ofp11(po->in_port); opo->actions_len = htons(len); @@ -4935,6 +5971,7 @@ ofputil_encode_barrier_request(enum ofp_version ofp_version) enum ofpraw type; switch (ofp_version) { + case OFP15_VERSION: case OFP14_VERSION: case OFP13_VERSION: case OFP12_VERSION: @@ -5030,7 +6067,8 @@ ofputil_port_to_ofp11(ofp_port_t ofp10_port) OFPUTIL_NAMED_PORT(ALL) \ OFPUTIL_NAMED_PORT(CONTROLLER) \ OFPUTIL_NAMED_PORT(LOCAL) \ - OFPUTIL_NAMED_PORT(ANY) + OFPUTIL_NAMED_PORT(ANY) \ + OFPUTIL_NAMED_PORT(UNSET) /* For backwards compatibility, so that "none" is recognized as OFPP_ANY */ #define OFPUTIL_NAMED_PORTS_WITH_NONE \ @@ -5053,8 +6091,12 @@ ofputil_port_to_ofp11(ofp_port_t ofp10_port) bool ofputil_port_from_string(const char *s, ofp_port_t *portp) { - uint32_t port32; + unsigned int port32; /* int is at least 32 bits wide. */ + if (*s == '-') { + VLOG_WARN("Negative value %s is not a valid port number.", s); + return false; + } *portp = 0; if (str_to_uint(s, 10, &port32)) { if (port32 < ofp_to_u16(OFPP_MAX)) { @@ -5205,6 +6247,8 @@ int ofputil_pull_phy_port(enum ofp_version ofp_version, struct ofpbuf *b, struct ofputil_phy_port *pp) { + memset(pp, 0, sizeof *pp); + switch (ofp_version) { case OFP10_VERSION: { const struct ofp10_phy_port *opp = ofpbuf_try_pull(b, sizeof *opp); @@ -5217,115 +6261,13 @@ ofputil_pull_phy_port(enum ofp_version ofp_version, struct ofpbuf *b, return op ? ofputil_decode_ofp11_port(pp, op) : EOF; } case OFP14_VERSION: - OVS_NOT_REACHED(); - break; + case OFP15_VERSION: + return b->size ? ofputil_pull_ofp14_port(pp, b) : EOF; default: OVS_NOT_REACHED(); } } -/* Given a buffer 'b' that contains an array of OpenFlow ports of type - * 'ofp_version', returns the number of elements. */ -size_t ofputil_count_phy_ports(uint8_t ofp_version, struct ofpbuf *b) -{ - return b->size / ofputil_get_phy_port_size(ofp_version); -} - -/* ofp-util.def lists the mapping from names to action. */ -static const char *const names[OFPUTIL_N_ACTIONS] = { - NULL, -#define OFPAT10_ACTION(ENUM, STRUCT, NAME) NAME, -#define OFPAT11_ACTION(ENUM, STRUCT, EXTENSIBLE, NAME) NAME, -#define NXAST_ACTION(ENUM, STRUCT, EXTENSIBLE, NAME) NAME, -#include "ofp-util.def" -}; - -/* Returns the 'enum ofputil_action_code' corresponding to 'name' (e.g. if - * 'name' is "output" then the return value is OFPUTIL_OFPAT10_OUTPUT), or -1 - * if 'name' is not the name of any action. */ -int -ofputil_action_code_from_name(const char *name) -{ - const char *const *p; - - for (p = names; p < &names[ARRAY_SIZE(names)]; p++) { - if (*p && !strcasecmp(name, *p)) { - return p - names; - } - } - return -1; -} - -/* Returns name corresponding to the 'enum ofputil_action_code', - * or "Unkonwn action", if the name is not available. */ -const char * -ofputil_action_name_from_code(enum ofputil_action_code code) -{ - return code < (int)OFPUTIL_N_ACTIONS && names[code] ? names[code] - : "Unknown action"; -} - -/* Appends an action of the type specified by 'code' to 'buf' and returns the - * action. Initializes the parts of 'action' that identify it as having type - * and length 'sizeof *action' and zeros the rest. For actions that - * have variable length, the length used and cleared is that of struct - * . */ -void * -ofputil_put_action(enum ofputil_action_code code, struct ofpbuf *buf) -{ - switch (code) { - case OFPUTIL_ACTION_INVALID: - OVS_NOT_REACHED(); - -#define OFPAT10_ACTION(ENUM, STRUCT, NAME) \ - case OFPUTIL_##ENUM: return ofputil_put_##ENUM(buf); -#define OFPAT11_ACTION(ENUM, STRUCT, EXTENSIBLE, NAME) \ - case OFPUTIL_##ENUM: return ofputil_put_##ENUM(buf); -#define NXAST_ACTION(ENUM, STRUCT, EXTENSIBLE, NAME) \ - case OFPUTIL_##ENUM: return ofputil_put_##ENUM(buf); -#include "ofp-util.def" - } - OVS_NOT_REACHED(); -} - -#define OFPAT10_ACTION(ENUM, STRUCT, NAME) \ - void \ - ofputil_init_##ENUM(struct STRUCT *s) \ - { \ - memset(s, 0, sizeof *s); \ - s->type = htons(ENUM); \ - s->len = htons(sizeof *s); \ - } \ - \ - struct STRUCT * \ - ofputil_put_##ENUM(struct ofpbuf *buf) \ - { \ - struct STRUCT *s = ofpbuf_put_uninit(buf, sizeof *s); \ - ofputil_init_##ENUM(s); \ - return s; \ - } -#define OFPAT11_ACTION(ENUM, STRUCT, EXTENSIBLE, NAME) \ - OFPAT10_ACTION(ENUM, STRUCT, NAME) -#define NXAST_ACTION(ENUM, STRUCT, EXTENSIBLE, NAME) \ - void \ - ofputil_init_##ENUM(struct STRUCT *s) \ - { \ - memset(s, 0, sizeof *s); \ - s->type = htons(OFPAT10_VENDOR); \ - s->len = htons(sizeof *s); \ - s->vendor = htonl(NX_VENDOR_ID); \ - s->subtype = htons(ENUM); \ - } \ - \ - struct STRUCT * \ - ofputil_put_##ENUM(struct ofpbuf *buf) \ - { \ - struct STRUCT *s = ofpbuf_put_uninit(buf, sizeof *s); \ - ofputil_init_##ENUM(s); \ - return s; \ - } -#include "ofp-util.def" - static void ofputil_normalize_match__(struct match *match, bool may_log) { @@ -5530,7 +6472,7 @@ ofputil_parse_key_value(char **stringp, char **keyp, char **valuep) } /* Encode a dump ports request for 'port', the encoded message - * will be for Open Flow version 'ofp_version'. Returns message + * will be for OpenFlow version 'ofp_version'. Returns message * as a struct ofpbuf. Returns encoded message on success, NULL on error */ struct ofpbuf * ofputil_encode_dump_ports_request(enum ofp_version ofp_version, ofp_port_t port) @@ -5548,7 +6490,8 @@ ofputil_encode_dump_ports_request(enum ofp_version ofp_version, ofp_port_t port) case OFP11_VERSION: case OFP12_VERSION: case OFP13_VERSION: - case OFP14_VERSION:{ + case OFP14_VERSION: + case OFP15_VERSION: { struct ofp11_port_stats_request *req; request = ofpraw_alloc(OFPRAW_OFPST11_PORT_REQUEST, ofp_version, 0); req = ofpbuf_put_zeros(request, sizeof *req); @@ -5611,16 +6554,47 @@ ofputil_port_stats_to_ofp13(const struct ofputil_port_stats *ops, ps13->duration_nsec = htonl(ops->duration_nsec); } +static void +ofputil_append_ofp14_port_stats(const struct ofputil_port_stats *ops, + struct ovs_list *replies) +{ + struct ofp14_port_stats_prop_ethernet *eth; + struct ofp14_port_stats *ps14; + struct ofpbuf *reply; + + reply = ofpmp_reserve(replies, sizeof *ps14 + sizeof *eth); + + ps14 = ofpbuf_put_uninit(reply, sizeof *ps14); + ps14->length = htons(sizeof *ps14 + sizeof *eth); + memset(ps14->pad, 0, sizeof ps14->pad); + ps14->port_no = ofputil_port_to_ofp11(ops->port_no); + ps14->duration_sec = htonl(ops->duration_sec); + ps14->duration_nsec = htonl(ops->duration_nsec); + ps14->rx_packets = htonll(ops->stats.rx_packets); + ps14->tx_packets = htonll(ops->stats.tx_packets); + ps14->rx_bytes = htonll(ops->stats.rx_bytes); + ps14->tx_bytes = htonll(ops->stats.tx_bytes); + ps14->rx_dropped = htonll(ops->stats.rx_dropped); + ps14->tx_dropped = htonll(ops->stats.tx_dropped); + ps14->rx_errors = htonll(ops->stats.rx_errors); + ps14->tx_errors = htonll(ops->stats.tx_errors); + + eth = ofpbuf_put_uninit(reply, sizeof *eth); + eth->type = htons(OFPPSPT14_ETHERNET); + eth->length = htons(sizeof *eth); + memset(eth->pad, 0, sizeof eth->pad); + eth->rx_frame_err = htonll(ops->stats.rx_frame_errors); + eth->rx_over_err = htonll(ops->stats.rx_over_errors); + eth->rx_crc_err = htonll(ops->stats.rx_crc_errors); + eth->collisions = htonll(ops->stats.collisions); +} /* Encode a ports stat for 'ops' and append it to 'replies'. */ void -ofputil_append_port_stat(struct list *replies, +ofputil_append_port_stat(struct ovs_list *replies, const struct ofputil_port_stats *ops) { - struct ofpbuf *msg = ofpbuf_from_list(list_back(replies)); - struct ofp_header *oh = msg->data; - - switch ((enum ofp_version)oh->version) { + switch (ofpmp_version(replies)) { case OFP13_VERSION: { struct ofp13_port_stats *reply = ofpmp_append(replies, sizeof *reply); ofputil_port_stats_to_ofp13(ops, reply); @@ -5640,7 +6614,8 @@ ofputil_append_port_stat(struct list *replies, } case OFP14_VERSION: - OVS_NOT_REACHED(); + case OFP15_VERSION: + ofputil_append_ofp14_port_stats(ops, replies); break; default: @@ -5714,23 +6689,92 @@ ofputil_port_stats_from_ofp13(struct ofputil_port_stats *ops, return error; } -static size_t -ofputil_get_port_stats_size(enum ofp_version ofp_version) +static enum ofperr +parse_ofp14_port_stats_ethernet_property(const struct ofpbuf *payload, + struct ofputil_port_stats *ops) { - switch (ofp_version) { - case OFP10_VERSION: - return sizeof(struct ofp10_port_stats); - case OFP11_VERSION: - case OFP12_VERSION: - return sizeof(struct ofp11_port_stats); - case OFP13_VERSION: - return sizeof(struct ofp13_port_stats); - case OFP14_VERSION: - OVS_NOT_REACHED(); - return 0; - default: - OVS_NOT_REACHED(); + const struct ofp14_port_stats_prop_ethernet *eth = payload->data; + + if (payload->size != sizeof *eth) { + return OFPERR_OFPBPC_BAD_LEN; + } + + ops->stats.rx_frame_errors = ntohll(eth->rx_frame_err); + ops->stats.rx_over_errors = ntohll(eth->rx_over_err); + ops->stats.rx_crc_errors = ntohll(eth->rx_crc_err); + ops->stats.collisions = ntohll(eth->collisions); + + return 0; +} + +static enum ofperr +ofputil_pull_ofp14_port_stats(struct ofputil_port_stats *ops, + struct ofpbuf *msg) +{ + const struct ofp14_port_stats *ps14; + struct ofpbuf properties; + enum ofperr error; + size_t len; + + ps14 = ofpbuf_try_pull(msg, sizeof *ps14); + if (!ps14) { + return OFPERR_OFPBRC_BAD_LEN; + } + + len = ntohs(ps14->length); + if (len < sizeof *ps14 || len - sizeof *ps14 > msg->size) { + return OFPERR_OFPBRC_BAD_LEN; + } + len -= sizeof *ps14; + ofpbuf_use_const(&properties, ofpbuf_pull(msg, len), len); + + error = ofputil_port_from_ofp11(ps14->port_no, &ops->port_no); + if (error) { + return error; + } + + ops->duration_sec = ntohl(ps14->duration_sec); + ops->duration_nsec = ntohl(ps14->duration_nsec); + ops->stats.rx_packets = ntohll(ps14->rx_packets); + ops->stats.tx_packets = ntohll(ps14->tx_packets); + ops->stats.rx_bytes = ntohll(ps14->rx_bytes); + ops->stats.tx_bytes = ntohll(ps14->tx_bytes); + ops->stats.rx_dropped = ntohll(ps14->rx_dropped); + ops->stats.tx_dropped = ntohll(ps14->tx_dropped); + ops->stats.rx_errors = ntohll(ps14->rx_errors); + ops->stats.tx_errors = ntohll(ps14->tx_errors); + ops->stats.rx_frame_errors = UINT64_MAX; + ops->stats.rx_over_errors = UINT64_MAX; + ops->stats.rx_crc_errors = UINT64_MAX; + ops->stats.collisions = UINT64_MAX; + + while (properties.size > 0) { + struct ofpbuf payload; + enum ofperr error; + uint16_t type; + + error = ofputil_pull_property(&properties, &payload, &type); + if (error) { + return error; + } + + switch (type) { + case OFPPSPT14_ETHERNET: + error = parse_ofp14_port_stats_ethernet_property(&payload, ops); + break; + + default: + log_property(true, "unknown port stats property %"PRIu16, type); + error = 0; + break; + } + + if (error) { + return error; + } } + + return 0; } /* Returns the number of port stats elements in OFPTYPE_PORT_STATS_REPLY @@ -5738,12 +6782,16 @@ ofputil_get_port_stats_size(enum ofp_version ofp_version) size_t ofputil_count_port_stats(const struct ofp_header *oh) { + struct ofputil_port_stats ps; struct ofpbuf b; + size_t n = 0; ofpbuf_use_const(&b, oh, ntohs(oh->length)); ofpraw_pull_assert(&b); - - return b.size / ofputil_get_port_stats_size(oh->version); + while (!ofputil_decode_port_stats(&ps, &b)) { + n++; + } + return n; } /* Converts an OFPST_PORT_STATS reply in 'msg' into an abstract @@ -5762,8 +6810,7 @@ ofputil_decode_port_stats(struct ofputil_port_stats *ps, struct ofpbuf *msg) enum ofperr error; enum ofpraw raw; - error = (msg->l2 - ? ofpraw_decode(&raw, msg->l2) + error = (msg->header ? ofpraw_decode(&raw, msg->header) : ofpraw_pull(&raw, msg)); if (error) { return error; @@ -5771,6 +6818,8 @@ ofputil_decode_port_stats(struct ofputil_port_stats *ps, struct ofpbuf *msg) if (!msg->size) { return EOF; + } else if (raw == OFPRAW_OFPST14_PORT_REPLY) { + return ofputil_pull_ofp14_port_stats(ps, msg); } else if (raw == OFPRAW_OFPST13_PORT_REPLY) { const struct ofp13_port_stats *ps13; @@ -5800,7 +6849,7 @@ ofputil_decode_port_stats(struct ofputil_port_stats *ps, struct ofpbuf *msg) } bad_len: - VLOG_WARN_RL(&bad_ofmsg_rl, "OFPST_PORT reply has %"PRIuSIZE" leftover " + VLOG_WARN_RL(&bad_ofmsg_rl, "OFPST_PORT reply has %"PRIu32" leftover " "bytes at end", msg->size); return OFPERR_OFPBRC_BAD_LEN; } @@ -5813,6 +6862,8 @@ ofputil_decode_port_stats_request(const struct ofp_header *request, ofp_port_t *ofp10_port) { switch ((enum ofp_version)request->version) { + case OFP15_VERSION: + case OFP14_VERSION: case OFP13_VERSION: case OFP12_VERSION: case OFP11_VERSION: { @@ -5826,10 +6877,6 @@ ofputil_decode_port_stats_request(const struct ofp_header *request, return 0; } - case OFP14_VERSION: - OVS_NOT_REACHED(); - break; - default: OVS_NOT_REACHED(); } @@ -5837,7 +6884,7 @@ ofputil_decode_port_stats_request(const struct ofp_header *request, /* Frees all of the "struct ofputil_bucket"s in the 'buckets' list. */ void -ofputil_bucket_list_destroy(struct list *buckets) +ofputil_bucket_list_destroy(struct ovs_list *buckets) { struct ofputil_bucket *bucket, *next_bucket; @@ -5848,48 +6895,181 @@ ofputil_bucket_list_destroy(struct list *buckets) } } -/* Returns an OpenFlow group stats request for OpenFlow version 'ofp_version', - * that requests stats for group 'group_id'. (Use OFPG_ALL to request stats - * for all groups.) - * - * Group statistics include packet and byte counts for each group. */ -struct ofpbuf * -ofputil_encode_group_stats_request(enum ofp_version ofp_version, - uint32_t group_id) +/* Clones 'bucket' and its ofpacts data */ +static struct ofputil_bucket * +ofputil_bucket_clone_data(const struct ofputil_bucket *bucket) { - struct ofpbuf *request; + struct ofputil_bucket *new; - switch (ofp_version) { - case OFP10_VERSION: - ovs_fatal(0, "dump-group-stats needs OpenFlow 1.1 or later " - "(\'-O OpenFlow11\')"); - case OFP11_VERSION: - case OFP12_VERSION: - case OFP13_VERSION: - case OFP14_VERSION: { - struct ofp11_group_stats_request *req; - request = ofpraw_alloc(OFPRAW_OFPST11_GROUP_REQUEST, ofp_version, 0); - req = ofpbuf_put_zeros(request, sizeof *req); - req->group_id = htonl(group_id); - break; - } - default: + new = xmemdup(bucket, sizeof *bucket); + new->ofpacts = xmemdup(bucket->ofpacts, bucket->ofpacts_len); + + return new; +} + +/* Clones each of the buckets in the list 'src' appending them + * in turn to 'dest' which should be an initialised list. + * An exception is that if the pointer value of a bucket in 'src' + * matches 'skip' then it is not cloned or appended to 'dest'. + * This allows all of 'src' or 'all of 'src' except 'skip' to + * be cloned and appended to 'dest'. */ +void +ofputil_bucket_clone_list(struct ovs_list *dest, const struct ovs_list *src, + const struct ofputil_bucket *skip) +{ + struct ofputil_bucket *bucket; + + LIST_FOR_EACH (bucket, list_node, src) { + struct ofputil_bucket *new_bucket; + + if (bucket == skip) { + continue; + } + + new_bucket = ofputil_bucket_clone_data(bucket); + list_push_back(dest, &new_bucket->list_node); + } +} + +/* Find a bucket in the list 'buckets' whose bucket id is 'bucket_id' + * Returns the first bucket found or NULL if no buckets are found. */ +struct ofputil_bucket * +ofputil_bucket_find(const struct ovs_list *buckets, uint32_t bucket_id) +{ + struct ofputil_bucket *bucket; + + if (bucket_id > OFPG15_BUCKET_MAX) { + return NULL; + } + + LIST_FOR_EACH (bucket, list_node, buckets) { + if (bucket->bucket_id == bucket_id) { + return bucket; + } + } + + return NULL; +} + +/* Returns true if more than one bucket in the list 'buckets' + * have the same bucket id. Returns false otherwise. */ +bool +ofputil_bucket_check_duplicate_id(const struct ovs_list *buckets) +{ + struct ofputil_bucket *i, *j; + + LIST_FOR_EACH (i, list_node, buckets) { + LIST_FOR_EACH_REVERSE (j, list_node, buckets) { + if (i == j) { + break; + } + if (i->bucket_id == j->bucket_id) { + return true; + } + } + } + + return false; +} + +/* Returns the bucket at the front of the list 'buckets'. + * Undefined if 'buckets is empty. */ +struct ofputil_bucket * +ofputil_bucket_list_front(const struct ovs_list *buckets) +{ + static struct ofputil_bucket *bucket; + + ASSIGN_CONTAINER(bucket, list_front(buckets), list_node); + + return bucket; +} + +/* Returns the bucket at the back of the list 'buckets'. + * Undefined if 'buckets is empty. */ +struct ofputil_bucket * +ofputil_bucket_list_back(const struct ovs_list *buckets) +{ + static struct ofputil_bucket *bucket; + + ASSIGN_CONTAINER(bucket, list_back(buckets), list_node); + + return bucket; +} + +/* Returns an OpenFlow group stats request for OpenFlow version 'ofp_version', + * that requests stats for group 'group_id'. (Use OFPG_ALL to request stats + * for all groups.) + * + * Group statistics include packet and byte counts for each group. */ +struct ofpbuf * +ofputil_encode_group_stats_request(enum ofp_version ofp_version, + uint32_t group_id) +{ + struct ofpbuf *request; + + switch (ofp_version) { + case OFP10_VERSION: + ovs_fatal(0, "dump-group-stats needs OpenFlow 1.1 or later " + "(\'-O OpenFlow11\')"); + case OFP11_VERSION: + case OFP12_VERSION: + case OFP13_VERSION: + case OFP14_VERSION: + case OFP15_VERSION: { + struct ofp11_group_stats_request *req; + request = ofpraw_alloc(OFPRAW_OFPST11_GROUP_REQUEST, ofp_version, 0); + req = ofpbuf_put_zeros(request, sizeof *req); + req->group_id = htonl(group_id); + break; + } + default: OVS_NOT_REACHED(); } return request; } +void +ofputil_uninit_group_desc(struct ofputil_group_desc *gd) +{ + ofputil_bucket_list_destroy(&gd->buckets); + free(&gd->props.fields); +} + +/* Decodes the OpenFlow group description request in 'oh', returning the group + * whose description is requested, or OFPG_ALL if stats for all groups was + * requested. */ +uint32_t +ofputil_decode_group_desc_request(const struct ofp_header *oh) +{ + struct ofpbuf request; + enum ofpraw raw; + + ofpbuf_use_const(&request, oh, ntohs(oh->length)); + raw = ofpraw_pull_assert(&request); + if (raw == OFPRAW_OFPST11_GROUP_DESC_REQUEST) { + return OFPG_ALL; + } else if (raw == OFPRAW_OFPST15_GROUP_DESC_REQUEST) { + ovs_be32 *group_id = ofpbuf_pull(&request, sizeof *group_id); + return ntohl(*group_id); + } else { + OVS_NOT_REACHED(); + } +} + /* Returns an OpenFlow group description request for OpenFlow version - * 'ofp_version', that requests stats for group 'group_id'. (Use OFPG_ALL to - * request stats for all groups.) + * 'ofp_version', that requests stats for group 'group_id'. Use OFPG_ALL to + * request stats for all groups (OpenFlow 1.4 and earlier always request all + * groups). * * Group descriptions include the bucket and action configuration for each * group. */ struct ofpbuf * -ofputil_encode_group_desc_request(enum ofp_version ofp_version) +ofputil_encode_group_desc_request(enum ofp_version ofp_version, + uint32_t group_id) { struct ofpbuf *request; + ovs_be32 gid; switch (ofp_version) { case OFP10_VERSION: @@ -5899,7 +7079,14 @@ ofputil_encode_group_desc_request(enum ofp_version ofp_version) case OFP12_VERSION: case OFP13_VERSION: case OFP14_VERSION: - request = ofpraw_alloc(OFPRAW_OFPST11_GROUP_DESC_REQUEST, ofp_version, 0); + request = ofpraw_alloc(OFPRAW_OFPST11_GROUP_DESC_REQUEST, + ofp_version, 0); + break; + case OFP15_VERSION: + request = ofpraw_alloc(OFPRAW_OFPST15_GROUP_DESC_REQUEST, + ofp_version, 0); + gid = htonl(group_id); + ofpbuf_put(request, &gid, sizeof gid); break; default: OVS_NOT_REACHED(); @@ -5908,78 +7095,85 @@ ofputil_encode_group_desc_request(enum ofp_version ofp_version) return request; } -static void * -ofputil_group_stats_to_ofp11(const struct ofputil_group_stats *ogs, - size_t base_len, struct list *replies) +static void +ofputil_group_bucket_counters_to_ofp11(const struct ofputil_group_stats *gs, + struct ofp11_bucket_counter bucket_cnts[]) { - struct ofp11_bucket_counter *bc11; - struct ofp11_group_stats *gs11; - size_t length; int i; - length = base_len + sizeof(struct ofp11_bucket_counter) * ogs->n_buckets; - - gs11 = ofpmp_append(replies, length); - memset(gs11, 0, base_len); - gs11->length = htons(length); - gs11->group_id = htonl(ogs->group_id); - gs11->ref_count = htonl(ogs->ref_count); - gs11->packet_count = htonll(ogs->packet_count); - gs11->byte_count = htonll(ogs->byte_count); - - bc11 = (void *) (((uint8_t *) gs11) + base_len); - for (i = 0; i < ogs->n_buckets; i++) { - const struct bucket_counter *obc = &ogs->bucket_stats[i]; - - bc11[i].packet_count = htonll(obc->packet_count); - bc11[i].byte_count = htonll(obc->byte_count); + for (i = 0; i < gs->n_buckets; i++) { + bucket_cnts[i].packet_count = htonll(gs->bucket_stats[i].packet_count); + bucket_cnts[i].byte_count = htonll(gs->bucket_stats[i].byte_count); } +} - return gs11; +static void +ofputil_group_stats_to_ofp11(const struct ofputil_group_stats *gs, + struct ofp11_group_stats *gs11, size_t length, + struct ofp11_bucket_counter bucket_cnts[]) +{ + memset(gs11, 0, sizeof *gs11); + gs11->length = htons(length); + gs11->group_id = htonl(gs->group_id); + gs11->ref_count = htonl(gs->ref_count); + gs11->packet_count = htonll(gs->packet_count); + gs11->byte_count = htonll(gs->byte_count); + ofputil_group_bucket_counters_to_ofp11(gs, bucket_cnts); } static void -ofputil_append_of13_group_stats(const struct ofputil_group_stats *ogs, - struct list *replies) +ofputil_group_stats_to_ofp13(const struct ofputil_group_stats *gs, + struct ofp13_group_stats *gs13, size_t length, + struct ofp11_bucket_counter bucket_cnts[]) { - struct ofp13_group_stats *gs13; + ofputil_group_stats_to_ofp11(gs, &gs13->gs, length, bucket_cnts); + gs13->duration_sec = htonl(gs->duration_sec); + gs13->duration_nsec = htonl(gs->duration_nsec); - gs13 = ofputil_group_stats_to_ofp11(ogs, sizeof *gs13, replies); - gs13->duration_sec = htonl(ogs->duration_sec); - gs13->duration_nsec = htonl(ogs->duration_nsec); } -/* Encodes 'ogs' properly for the format of the list of group statistics +/* Encodes 'gs' properly for the format of the list of group statistics * replies already begun in 'replies' and appends it to the list. 'replies' * must have originally been initialized with ofpmp_init(). */ void -ofputil_append_group_stats(struct list *replies, - const struct ofputil_group_stats *ogs) +ofputil_append_group_stats(struct ovs_list *replies, + const struct ofputil_group_stats *gs) { - struct ofpbuf *msg = ofpbuf_from_list(list_back(replies)); - struct ofp_header *oh = msg->data; + size_t bucket_counter_size; + struct ofp11_bucket_counter *bucket_counters; + size_t length; - switch ((enum ofp_version)oh->version) { + bucket_counter_size = gs->n_buckets * sizeof(struct ofp11_bucket_counter); + + switch (ofpmp_version(replies)) { case OFP11_VERSION: - case OFP12_VERSION: - ofputil_group_stats_to_ofp11(ogs, sizeof(struct ofp11_group_stats), - replies); - break; + case OFP12_VERSION:{ + struct ofp11_group_stats *gs11; - case OFP13_VERSION: - ofputil_append_of13_group_stats(ogs, replies); - break; + length = sizeof *gs11 + bucket_counter_size; + gs11 = ofpmp_append(replies, length); + bucket_counters = (struct ofp11_bucket_counter *)(gs11 + 1); + ofputil_group_stats_to_ofp11(gs, gs11, length, bucket_counters); + break; + } + case OFP13_VERSION: case OFP14_VERSION: - OVS_NOT_REACHED(); - break; + case OFP15_VERSION: { + struct ofp13_group_stats *gs13; + + length = sizeof *gs13 + bucket_counter_size; + gs13 = ofpmp_append(replies, length); + bucket_counters = (struct ofp11_bucket_counter *)(gs13 + 1); + ofputil_group_stats_to_ofp13(gs, gs13, length, bucket_counters); + break; + } case OFP10_VERSION: default: OVS_NOT_REACHED(); } } - /* Returns an OpenFlow group features request for OpenFlow version * 'ofp_version'. */ struct ofpbuf * @@ -5995,6 +7189,7 @@ ofputil_encode_group_features_request(enum ofp_version ofp_version) case OFP12_VERSION: case OFP13_VERSION: case OFP14_VERSION: + case OFP15_VERSION: request = ofpraw_alloc(OFPRAW_OFPST12_GROUP_FEATURES_REQUEST, ofp_version, 0); break; @@ -6014,20 +7209,18 @@ ofputil_encode_group_features_reply( { struct ofp12_group_features_stats *ogf; struct ofpbuf *reply; + int i; reply = ofpraw_alloc_xid(OFPRAW_OFPST12_GROUP_FEATURES_REPLY, request->version, request->xid, 0); ogf = ofpbuf_put_zeros(reply, sizeof *ogf); ogf->types = htonl(features->types); ogf->capabilities = htonl(features->capabilities); - ogf->max_groups[0] = htonl(features->max_groups[0]); - ogf->max_groups[1] = htonl(features->max_groups[1]); - ogf->max_groups[2] = htonl(features->max_groups[2]); - ogf->max_groups[3] = htonl(features->max_groups[3]); - ogf->actions[0] = htonl(features->actions[0]); - ogf->actions[1] = htonl(features->actions[1]); - ogf->actions[2] = htonl(features->actions[2]); - ogf->actions[3] = htonl(features->actions[3]); + for (i = 0; i < OFPGT12_N_TYPES; i++) { + ogf->max_groups[i] = htonl(features->max_groups[i]); + ogf->actions[i] = ofpact_bitmap_to_openflow(features->ofpacts[i], + request->version); + } return reply; } @@ -6038,17 +7231,15 @@ ofputil_decode_group_features_reply(const struct ofp_header *oh, struct ofputil_group_features *features) { const struct ofp12_group_features_stats *ogf = ofpmsg_body(oh); + int i; features->types = ntohl(ogf->types); features->capabilities = ntohl(ogf->capabilities); - features->max_groups[0] = ntohl(ogf->max_groups[0]); - features->max_groups[1] = ntohl(ogf->max_groups[1]); - features->max_groups[2] = ntohl(ogf->max_groups[2]); - features->max_groups[3] = ntohl(ogf->max_groups[3]); - features->actions[0] = ntohl(ogf->actions[0]); - features->actions[1] = ntohl(ogf->actions[1]); - features->actions[2] = ntohl(ogf->actions[2]); - features->actions[3] = ntohl(ogf->actions[3]); + for (i = 0; i < OFPGT12_N_TYPES; i++) { + features->max_groups[i] = ntohl(ogf->max_groups[i]); + features->ofpacts[i] = ofpact_bitmap_from_openflow( + ogf->actions[i], oh->version); + } } /* Parse a group status request message into a 32 bit OpenFlow 1.1 @@ -6087,8 +7278,7 @@ ofputil_decode_group_stats_reply(struct ofpbuf *msg, size_t i; gs->bucket_stats = NULL; - error = (msg->l2 - ? ofpraw_decode(&raw, msg->l2) + error = (msg->header ? ofpraw_decode(&raw, msg->header) : ofpraw_pull(&raw, msg)); if (error) { return error; @@ -6119,7 +7309,7 @@ ofputil_decode_group_stats_reply(struct ofpbuf *msg, } if (!ogs11) { - VLOG_WARN_RL(&bad_ofmsg_rl, "%s reply has %"PRIuSIZE" leftover bytes at end", + VLOG_WARN_RL(&bad_ofmsg_rl, "%s reply has %"PRIu32" leftover bytes at end", ofpraw_get_name(raw), msg->size); return OFPERR_OFPBRC_BAD_LEN; } @@ -6138,7 +7328,7 @@ ofputil_decode_group_stats_reply(struct ofpbuf *msg, gs->n_buckets = (length - base_len) / sizeof *obc; obc = ofpbuf_try_pull(msg, gs->n_buckets * sizeof *obc); if (!obc) { - VLOG_WARN_RL(&bad_ofmsg_rl, "%s reply has %"PRIuSIZE" leftover bytes at end", + VLOG_WARN_RL(&bad_ofmsg_rl, "%s reply has %"PRIu32" leftover bytes at end", ofpraw_get_name(raw), msg->size); return OFPERR_OFPBRC_BAD_LEN; } @@ -6152,35 +7342,126 @@ ofputil_decode_group_stats_reply(struct ofpbuf *msg, return 0; } -/* Appends a group stats reply that contains the data in 'gds' to those already - * present in the list of ofpbufs in 'replies'. 'replies' should have been - * initialized with ofpmp_init(). */ -void -ofputil_append_group_desc_reply(const struct ofputil_group_desc *gds, - struct list *buckets, - struct list *replies) +static void +ofputil_put_ofp11_bucket(const struct ofputil_bucket *bucket, + struct ofpbuf *openflow, enum ofp_version ofp_version) +{ + struct ofp11_bucket *ob; + size_t start; + + start = openflow->size; + ofpbuf_put_zeros(openflow, sizeof *ob); + ofpacts_put_openflow_actions(bucket->ofpacts, bucket->ofpacts_len, + openflow, ofp_version); + ob = ofpbuf_at_assert(openflow, start, sizeof *ob); + ob->len = htons(openflow->size - start); + ob->weight = htons(bucket->weight); + ob->watch_port = ofputil_port_to_ofp11(bucket->watch_port); + ob->watch_group = htonl(bucket->watch_group); +} + +static void +ofputil_put_ofp15_group_bucket_prop_weight(ovs_be16 weight, + struct ofpbuf *openflow) +{ + size_t start_ofs; + struct ofp15_group_bucket_prop_weight *prop; + + start_ofs = start_property(openflow, OFPGBPT15_WEIGHT); + ofpbuf_put_zeros(openflow, sizeof *prop - sizeof(struct ofp_prop_header)); + prop = ofpbuf_at_assert(openflow, start_ofs, sizeof *prop); + prop->weight = weight; + end_property(openflow, start_ofs); +} + +static void +ofputil_put_ofp15_group_bucket_prop_watch(ovs_be32 watch, uint16_t type, + struct ofpbuf *openflow) +{ + size_t start_ofs; + struct ofp15_group_bucket_prop_watch *prop; + + start_ofs = start_property(openflow, type); + ofpbuf_put_zeros(openflow, sizeof *prop - sizeof(struct ofp_prop_header)); + prop = ofpbuf_at_assert(openflow, start_ofs, sizeof *prop); + prop->watch = watch; + end_property(openflow, start_ofs); +} + +static void +ofputil_put_ofp15_bucket(const struct ofputil_bucket *bucket, + uint32_t bucket_id, enum ofp11_group_type group_type, + struct ofpbuf *openflow, enum ofp_version ofp_version) +{ + struct ofp15_bucket *ob; + size_t start, actions_start, actions_len; + + start = openflow->size; + ofpbuf_put_zeros(openflow, sizeof *ob); + + actions_start = openflow->size; + ofpacts_put_openflow_actions(bucket->ofpacts, bucket->ofpacts_len, + openflow, ofp_version); + actions_len = openflow->size - actions_start; + + if (group_type == OFPGT11_SELECT) { + ofputil_put_ofp15_group_bucket_prop_weight(htons(bucket->weight), + openflow); + } + if (bucket->watch_port != OFPP_ANY) { + ovs_be32 port = ofputil_port_to_ofp11(bucket->watch_port); + ofputil_put_ofp15_group_bucket_prop_watch(port, + OFPGBPT15_WATCH_PORT, + openflow); + } + if (bucket->watch_group != OFPG_ANY) { + ovs_be32 group = htonl(bucket->watch_group); + ofputil_put_ofp15_group_bucket_prop_watch(group, + OFPGBPT15_WATCH_GROUP, + openflow); + } + + ob = ofpbuf_at_assert(openflow, start, sizeof *ob); + ob->len = htons(openflow->size - start); + ob->action_array_len = htons(actions_len); + ob->bucket_id = htonl(bucket_id); +} + +static void +ofputil_put_group_prop_ntr_selection_method(enum ofp_version ofp_version, + const struct ofputil_group_props *gp, + struct ofpbuf *openflow) +{ + struct ntr_group_prop_selection_method *prop; + size_t start; + + start = openflow->size; + ofpbuf_put_zeros(openflow, sizeof *prop); + oxm_put_field_array(openflow, &gp->fields, ofp_version); + prop = ofpbuf_at_assert(openflow, start, sizeof *prop); + prop->type = htons(OFPGPT15_EXPERIMENTER); + prop->experimenter = htonl(NTR_VENDOR_ID); + prop->exp_type = htonl(NTRT_SELECTION_METHOD); + strcpy(prop->selection_method, gp->selection_method); + prop->selection_method_param = htonll(gp->selection_method_param); + end_property(openflow, start); +} + +static void +ofputil_append_ofp11_group_desc_reply(const struct ofputil_group_desc *gds, + const struct ovs_list *buckets, + struct ovs_list *replies, + enum ofp_version version) { struct ofpbuf *reply = ofpbuf_from_list(list_back(replies)); struct ofp11_group_desc_stats *ogds; struct ofputil_bucket *bucket; size_t start_ogds; - enum ofp_version version = ((struct ofp_header *)reply->data)->version; start_ogds = reply->size; ofpbuf_put_zeros(reply, sizeof *ogds); LIST_FOR_EACH (bucket, list_node, buckets) { - struct ofp11_bucket *ob; - size_t start_ob; - - start_ob = reply->size; - ofpbuf_put_zeros(reply, sizeof *ob); - ofpacts_put_openflow_actions(bucket->ofpacts, bucket->ofpacts_len, - reply, version); - ob = ofpbuf_at_assert(reply, start_ob, sizeof *ob); - ob->len = htons(reply->size - start_ob); - ob->weight = htons(bucket->weight); - ob->watch_port = ofputil_port_to_ofp11(bucket->watch_port); - ob->watch_group = htonl(bucket->watch_group); + ofputil_put_ofp11_bucket(bucket, reply, version); } ogds = ofpbuf_at_assert(reply, start_ogds, sizeof *ogds); ogds->length = htons(reply->size - start_ogds); @@ -6190,11 +7471,74 @@ ofputil_append_group_desc_reply(const struct ofputil_group_desc *gds, ofpmp_postappend(replies, start_ogds); } +static void +ofputil_append_ofp15_group_desc_reply(const struct ofputil_group_desc *gds, + const struct ovs_list *buckets, + struct ovs_list *replies, + enum ofp_version version) +{ + struct ofpbuf *reply = ofpbuf_from_list(list_back(replies)); + struct ofp15_group_desc_stats *ogds; + struct ofputil_bucket *bucket; + size_t start_ogds, start_buckets; + + start_ogds = reply->size; + ofpbuf_put_zeros(reply, sizeof *ogds); + start_buckets = reply->size; + LIST_FOR_EACH (bucket, list_node, buckets) { + ofputil_put_ofp15_bucket(bucket, bucket->bucket_id, + gds->type, reply, version); + } + ogds = ofpbuf_at_assert(reply, start_ogds, sizeof *ogds); + ogds->length = htons(reply->size - start_ogds); + ogds->type = gds->type; + ogds->group_id = htonl(gds->group_id); + ogds->bucket_list_len = htons(reply->size - start_buckets); + + /* Add group properties */ + if (gds->props.selection_method[0]) { + ofputil_put_group_prop_ntr_selection_method(version, &gds->props, + reply); + } + + ofpmp_postappend(replies, start_ogds); +} + +/* Appends a group stats reply that contains the data in 'gds' to those already + * present in the list of ofpbufs in 'replies'. 'replies' should have been + * initialized with ofpmp_init(). */ +void +ofputil_append_group_desc_reply(const struct ofputil_group_desc *gds, + const struct ovs_list *buckets, + struct ovs_list *replies) +{ + enum ofp_version version = ofpmp_version(replies); + + switch (version) + { + case OFP11_VERSION: + case OFP12_VERSION: + case OFP13_VERSION: + case OFP14_VERSION: + ofputil_append_ofp11_group_desc_reply(gds, buckets, replies, version); + break; + + case OFP15_VERSION: + ofputil_append_ofp15_group_desc_reply(gds, buckets, replies, version); + break; + + case OFP10_VERSION: + default: + OVS_NOT_REACHED(); + } +} + static enum ofperr -ofputil_pull_buckets(struct ofpbuf *msg, size_t buckets_length, - enum ofp_version version, struct list *buckets) +ofputil_pull_ofp11_buckets(struct ofpbuf *msg, size_t buckets_length, + enum ofp_version version, struct ovs_list *buckets) { struct ofp11_bucket *ob; + uint32_t bucket_id = 0; list_init(buckets); while (buckets_length > 0) { @@ -6209,6 +7553,7 @@ ofputil_pull_buckets(struct ofpbuf *msg, size_t buckets_length, if (!ob) { VLOG_WARN_RL(&bad_ofmsg_rl, "buckets end with %"PRIuSIZE" leftover bytes", buckets_length); + return OFPERR_OFPGMFC_BAD_BUCKET; } ob_len = ntohs(ob->len); @@ -6242,57 +7587,640 @@ ofputil_pull_buckets(struct ofpbuf *msg, size_t buckets_length, return OFPERR_OFPGMFC_BAD_WATCH; } bucket->watch_group = ntohl(ob->watch_group); + bucket->bucket_id = bucket_id++; + bucket->ofpacts = ofpbuf_steal_data(&ofpacts); bucket->ofpacts_len = ofpacts.size; list_push_back(buckets, &bucket->list_node); } - return 0; + return 0; +} + +static enum ofperr +parse_ofp15_group_bucket_prop_weight(const struct ofpbuf *payload, + ovs_be16 *weight) +{ + struct ofp15_group_bucket_prop_weight *prop = payload->data; + + if (payload->size != sizeof *prop) { + log_property(false, "OpenFlow bucket weight property length " + "%u is not valid", payload->size); + return OFPERR_OFPBPC_BAD_LEN; + } + + *weight = prop->weight; + + return 0; +} + +static enum ofperr +parse_ofp15_group_bucket_prop_watch(const struct ofpbuf *payload, + ovs_be32 *watch) +{ + struct ofp15_group_bucket_prop_watch *prop = payload->data; + + if (payload->size != sizeof *prop) { + log_property(false, "OpenFlow bucket watch port or group " + "property length %u is not valid", payload->size); + return OFPERR_OFPBPC_BAD_LEN; + } + + *watch = prop->watch; + + return 0; +} + +static enum ofperr +ofputil_pull_ofp15_buckets(struct ofpbuf *msg, size_t buckets_length, + enum ofp_version version, struct ovs_list *buckets) +{ + struct ofp15_bucket *ob; + + list_init(buckets); + while (buckets_length > 0) { + struct ofputil_bucket *bucket = NULL; + struct ofpbuf ofpacts; + enum ofperr err = OFPERR_OFPGMFC_BAD_BUCKET; + struct ofpbuf properties; + size_t ob_len, actions_len, properties_len; + ovs_be32 watch_port = ofputil_port_to_ofp11(OFPP_ANY); + ovs_be32 watch_group = htonl(OFPG_ANY); + ovs_be16 weight = htons(1); + + ofpbuf_init(&ofpacts, 0); + + ob = ofpbuf_try_pull(msg, sizeof *ob); + if (!ob) { + VLOG_WARN_RL(&bad_ofmsg_rl, "buckets end with %"PRIuSIZE + " leftover bytes", buckets_length); + goto err; + } + + ob_len = ntohs(ob->len); + actions_len = ntohs(ob->action_array_len); + + if (ob_len < sizeof *ob) { + VLOG_WARN_RL(&bad_ofmsg_rl, "OpenFlow message bucket length " + "%"PRIuSIZE" is not valid", ob_len); + goto err; + } else if (ob_len > buckets_length) { + VLOG_WARN_RL(&bad_ofmsg_rl, "OpenFlow message bucket length " + "%"PRIuSIZE" exceeds remaining buckets data size %" + PRIuSIZE, ob_len, buckets_length); + goto err; + } else if (actions_len > ob_len - sizeof *ob) { + VLOG_WARN_RL(&bad_ofmsg_rl, "OpenFlow message bucket actions " + "length %"PRIuSIZE" exceeds remaining bucket " + "data size %"PRIuSIZE, actions_len, + ob_len - sizeof *ob); + goto err; + } + buckets_length -= ob_len; + + err = ofpacts_pull_openflow_actions(msg, actions_len, version, + &ofpacts); + if (err) { + goto err; + } + + properties_len = ob_len - sizeof *ob - actions_len; + ofpbuf_use_const(&properties, ofpbuf_pull(msg, properties_len), + properties_len); + + while (properties.size > 0) { + struct ofpbuf payload; + uint16_t type; + + err = ofputil_pull_property(&properties, &payload, &type); + if (err) { + goto err; + } + + switch (type) { + case OFPGBPT15_WEIGHT: + err = parse_ofp15_group_bucket_prop_weight(&payload, &weight); + break; + + case OFPGBPT15_WATCH_PORT: + err = parse_ofp15_group_bucket_prop_watch(&payload, + &watch_port); + break; + + case OFPGBPT15_WATCH_GROUP: + err = parse_ofp15_group_bucket_prop_watch(&payload, + &watch_group); + break; + + default: + log_property(false, "unknown group bucket property %"PRIu16, + type); + err = OFPERR_OFPBPC_BAD_TYPE; + break; + } + + if (err) { + goto err; + } + } + + bucket = xzalloc(sizeof *bucket); + + bucket->weight = ntohs(weight); + err = ofputil_port_from_ofp11(watch_port, &bucket->watch_port); + if (err) { + err = OFPERR_OFPGMFC_BAD_WATCH; + goto err; + } + bucket->watch_group = ntohl(watch_group); + bucket->bucket_id = ntohl(ob->bucket_id); + if (bucket->bucket_id > OFPG15_BUCKET_MAX) { + VLOG_WARN_RL(&bad_ofmsg_rl, "bucket id (%u) is out of range", + bucket->bucket_id); + err = OFPERR_OFPGMFC_BAD_BUCKET; + goto err; + } + + bucket->ofpacts = ofpbuf_steal_data(&ofpacts); + bucket->ofpacts_len = ofpacts.size; + list_push_back(buckets, &bucket->list_node); + + continue; + + err: + free(bucket); + ofpbuf_uninit(&ofpacts); + ofputil_bucket_list_destroy(buckets); + return err; + } + + if (ofputil_bucket_check_duplicate_id(buckets)) { + VLOG_WARN_RL(&bad_ofmsg_rl, "Duplicate bucket id"); + ofputil_bucket_list_destroy(buckets); + return OFPERR_OFPGMFC_BAD_BUCKET; + } + + return 0; +} + +static void +ofputil_init_group_properties(struct ofputil_group_props *gp) +{ + memset(gp, 0, sizeof *gp); +} + +static enum ofperr +parse_group_prop_ntr_selection_method(struct ofpbuf *payload, + enum ofp11_group_type group_type, + enum ofp15_group_mod_command group_cmd, + struct ofputil_group_props *gp) +{ + struct ntr_group_prop_selection_method *prop = payload->data; + size_t fields_len, method_len; + enum ofperr error; + + switch (group_type) { + case OFPGT11_SELECT: + break; + case OFPGT11_ALL: + case OFPGT11_INDIRECT: + case OFPGT11_FF: + log_property(false, "ntr selection method property is only allowed " + "for select groups"); + return OFPERR_OFPBPC_BAD_VALUE; + default: + OVS_NOT_REACHED(); + } + + switch (group_cmd) { + case OFPGC15_ADD: + case OFPGC15_MODIFY: + break; + case OFPGC15_DELETE: + case OFPGC15_INSERT_BUCKET: + case OFPGC15_REMOVE_BUCKET: + log_property(false, "ntr selection method property is only allowed " + "for add and delete group modifications"); + return OFPERR_OFPBPC_BAD_VALUE; + default: + OVS_NOT_REACHED(); + } + + if (payload->size < sizeof *prop) { + log_property(false, "ntr selection method property length " + "%u is not valid", payload->size); + return OFPERR_OFPBPC_BAD_LEN; + } + + method_len = strnlen(prop->selection_method, NTR_MAX_SELECTION_METHOD_LEN); + + if (method_len == NTR_MAX_SELECTION_METHOD_LEN) { + log_property(false, "ntr selection method is not null terminated"); + return OFPERR_OFPBPC_BAD_VALUE; + } + + if (strcmp("hash", prop->selection_method)) { + log_property(false, "ntr selection method '%s' is not supported", + prop->selection_method); + return OFPERR_OFPBPC_BAD_VALUE; + } + + strcpy(gp->selection_method, prop->selection_method); + gp->selection_method_param = ntohll(prop->selection_method_param); + + if (!method_len && gp->selection_method_param) { + log_property(false, "ntr selection method parameter is non-zero but " + "selection method is empty"); + return OFPERR_OFPBPC_BAD_VALUE; + } + + ofpbuf_pull(payload, sizeof *prop); + + fields_len = ntohs(prop->length) - sizeof *prop; + if (!method_len && fields_len) { + log_property(false, "ntr selection method parameter is zero " + "but fields are provided"); + return OFPERR_OFPBPC_BAD_VALUE; + } + + error = oxm_pull_field_array(payload->data, fields_len, + &gp->fields); + if (error) { + log_property(false, "ntr selection method fields are invalid"); + return error; + } + + return 0; +} + +static enum ofperr +parse_group_prop_ntr(struct ofpbuf *payload, uint32_t exp_type, + enum ofp11_group_type group_type, + enum ofp15_group_mod_command group_cmd, + struct ofputil_group_props *gp) +{ + enum ofperr error; + + switch (exp_type) { + case NTRT_SELECTION_METHOD: + error = parse_group_prop_ntr_selection_method(payload, group_type, + group_cmd, gp); + break; + + default: + log_property(false, "unknown group property ntr experimenter type " + "%"PRIu32, exp_type); + error = OFPERR_OFPBPC_BAD_TYPE; + break; + } + + return error; +} + +static enum ofperr +parse_ofp15_group_prop_exp(struct ofpbuf *payload, + enum ofp11_group_type group_type, + enum ofp15_group_mod_command group_cmd, + struct ofputil_group_props *gp) +{ + struct ofp_prop_experimenter *prop = payload->data; + uint16_t experimenter; + uint32_t exp_type; + enum ofperr error; + + if (payload->size < sizeof *prop) { + return OFPERR_OFPBPC_BAD_LEN; + } + + experimenter = ntohl(prop->experimenter); + exp_type = ntohl(prop->exp_type); + + switch (experimenter) { + case NTR_VENDOR_ID: + error = parse_group_prop_ntr(payload, exp_type, group_type, + group_cmd, gp); + break; + + default: + log_property(false, "unknown group property experimenter %"PRIu16, + experimenter); + error = OFPERR_OFPBPC_BAD_EXPERIMENTER; + break; + } + + return error; +} + +static enum ofperr +parse_ofp15_group_properties(struct ofpbuf *msg, + enum ofp11_group_type group_type, + enum ofp15_group_mod_command group_cmd, + struct ofputil_group_props *gp, + size_t properties_len) +{ + struct ofpbuf properties; + + ofpbuf_use_const(&properties, ofpbuf_pull(msg, properties_len), + properties_len); + + while (properties.size > 0) { + struct ofpbuf payload; + enum ofperr error; + uint16_t type; + + error = ofputil_pull_property(&properties, &payload, &type); + if (error) { + return error; + } + + switch (type) { + case OFPGPT15_EXPERIMENTER: + error = parse_ofp15_group_prop_exp(&payload, group_type, + group_cmd, gp); + break; + + default: + log_property(false, "unknown group property %"PRIu16, type); + error = OFPERR_OFPBPC_BAD_TYPE; + break; + } + + if (error) { + return error; + } + } + + return 0; +} + +static int +ofputil_decode_ofp11_group_desc_reply(struct ofputil_group_desc *gd, + struct ofpbuf *msg, + enum ofp_version version) +{ + struct ofp11_group_desc_stats *ogds; + size_t length; + + if (!msg->header) { + ofpraw_pull_assert(msg); + } + + if (!msg->size) { + return EOF; + } + + ogds = ofpbuf_try_pull(msg, sizeof *ogds); + if (!ogds) { + VLOG_WARN_RL(&bad_ofmsg_rl, "OFPST11_GROUP_DESC reply has %"PRIu32" " + "leftover bytes at end", msg->size); + return OFPERR_OFPBRC_BAD_LEN; + } + gd->type = ogds->type; + gd->group_id = ntohl(ogds->group_id); + + length = ntohs(ogds->length); + if (length < sizeof *ogds || length - sizeof *ogds > msg->size) { + VLOG_WARN_RL(&bad_ofmsg_rl, "OFPST11_GROUP_DESC reply claims invalid " + "length %"PRIuSIZE, length); + return OFPERR_OFPBRC_BAD_LEN; + } + + return ofputil_pull_ofp11_buckets(msg, length - sizeof *ogds, version, + &gd->buckets); +} + +static int +ofputil_decode_ofp15_group_desc_reply(struct ofputil_group_desc *gd, + struct ofpbuf *msg, + enum ofp_version version) +{ + struct ofp15_group_desc_stats *ogds; + uint16_t length, bucket_list_len; + int error; + + if (!msg->header) { + ofpraw_pull_assert(msg); + } + + if (!msg->size) { + return EOF; + } + + ogds = ofpbuf_try_pull(msg, sizeof *ogds); + if (!ogds) { + VLOG_WARN_RL(&bad_ofmsg_rl, "OFPST11_GROUP_DESC reply has %"PRIu32" " + "leftover bytes at end", msg->size); + return OFPERR_OFPBRC_BAD_LEN; + } + gd->type = ogds->type; + gd->group_id = ntohl(ogds->group_id); + + length = ntohs(ogds->length); + if (length < sizeof *ogds || length - sizeof *ogds > msg->size) { + VLOG_WARN_RL(&bad_ofmsg_rl, "OFPST11_GROUP_DESC reply claims invalid " + "length %u", length); + return OFPERR_OFPBRC_BAD_LEN; + } + + bucket_list_len = ntohs(ogds->bucket_list_len); + if (length < bucket_list_len + sizeof *ogds) { + VLOG_WARN_RL(&bad_ofmsg_rl, "OFPST11_GROUP_DESC reply claims invalid " + "bucket list length %u", bucket_list_len); + return OFPERR_OFPBRC_BAD_LEN; + } + error = ofputil_pull_ofp15_buckets(msg, bucket_list_len, version, + &gd->buckets); + if (error) { + return error; + } + + /* By definition group desc messages don't have a group mod command. + * However, parse_group_prop_ntr_selection_method() checks to make sure + * that the command is OFPGC15_ADD or OFPGC15_DELETE to guard + * against group mod messages with other commands supplying + * a NTR selection method group experimenter property. + * Such properties are valid for group desc replies so + * claim that the group mod command is OFPGC15_ADD to + * satisfy the check in parse_group_prop_ntr_selection_method() */ + return parse_ofp15_group_properties(msg, gd->type, OFPGC15_ADD, &gd->props, + msg->size); +} + +/* Converts a group description reply in 'msg' into an abstract + * ofputil_group_desc in 'gd'. + * + * Multiple group description replies can be packed into a single OpenFlow + * message. Calling this function multiple times for a single 'msg' iterates + * through the replies. The caller must initially leave 'msg''s layer pointers + * null and not modify them between calls. + * + * Returns 0 if successful, EOF if no replies were left in this 'msg', + * otherwise a positive errno value. */ +int +ofputil_decode_group_desc_reply(struct ofputil_group_desc *gd, + struct ofpbuf *msg, enum ofp_version version) +{ + ofputil_init_group_properties(&gd->props); + + switch (version) + { + case OFP11_VERSION: + case OFP12_VERSION: + case OFP13_VERSION: + case OFP14_VERSION: + return ofputil_decode_ofp11_group_desc_reply(gd, msg, version); + + case OFP15_VERSION: + return ofputil_decode_ofp15_group_desc_reply(gd, msg, version); + + case OFP10_VERSION: + default: + OVS_NOT_REACHED(); + } +} + +void +ofputil_uninit_group_mod(struct ofputil_group_mod *gm) +{ + ofputil_bucket_list_destroy(&gm->buckets); +} + +static struct ofpbuf * +ofputil_encode_ofp11_group_mod(enum ofp_version ofp_version, + const struct ofputil_group_mod *gm) +{ + struct ofpbuf *b; + struct ofp11_group_mod *ogm; + size_t start_ogm; + struct ofputil_bucket *bucket; + + b = ofpraw_alloc(OFPRAW_OFPT11_GROUP_MOD, ofp_version, 0); + start_ogm = b->size; + ofpbuf_put_zeros(b, sizeof *ogm); + + LIST_FOR_EACH (bucket, list_node, &gm->buckets) { + ofputil_put_ofp11_bucket(bucket, b, ofp_version); + } + ogm = ofpbuf_at_assert(b, start_ogm, sizeof *ogm); + ogm->command = htons(gm->command); + ogm->type = gm->type; + ogm->group_id = htonl(gm->group_id); + + return b; } -/* Converts a group description reply in 'msg' into an abstract - * ofputil_group_desc in 'gd'. - * - * Multiple group description replies can be packed into a single OpenFlow - * message. Calling this function multiple times for a single 'msg' iterates - * through the replies. The caller must initially leave 'msg''s layer pointers - * null and not modify them between calls. - * - * Returns 0 if successful, EOF if no replies were left in this 'msg', - * otherwise a positive errno value. */ -int -ofputil_decode_group_desc_reply(struct ofputil_group_desc *gd, - struct ofpbuf *msg, enum ofp_version version) +static struct ofpbuf * +ofputil_encode_ofp15_group_mod(enum ofp_version ofp_version, + const struct ofputil_group_mod *gm) { - struct ofp11_group_desc_stats *ogds; - size_t length; + struct ofpbuf *b; + struct ofp15_group_mod *ogm; + size_t start_ogm; + struct ofputil_bucket *bucket; + struct id_pool *bucket_ids = NULL; - if (!msg->l2) { - ofpraw_pull_assert(msg); + b = ofpraw_alloc(OFPRAW_OFPT15_GROUP_MOD, ofp_version, 0); + start_ogm = b->size; + ofpbuf_put_zeros(b, sizeof *ogm); + + LIST_FOR_EACH (bucket, list_node, &gm->buckets) { + uint32_t bucket_id; + + /* Generate a bucket id if none was supplied */ + if (bucket->bucket_id > OFPG15_BUCKET_MAX) { + if (!bucket_ids) { + const struct ofputil_bucket *bkt; + + bucket_ids = id_pool_create(0, OFPG15_BUCKET_MAX + 1); + + /* Mark all bucket_ids that are present in gm + * as used in the pool. */ + LIST_FOR_EACH_REVERSE (bkt, list_node, &gm->buckets) { + if (bkt == bucket) { + break; + } + if (bkt->bucket_id <= OFPG15_BUCKET_MAX) { + id_pool_add(bucket_ids, bkt->bucket_id); + } + } + } + + if (!id_pool_alloc_id(bucket_ids, &bucket_id)) { + OVS_NOT_REACHED(); + } + } else { + bucket_id = bucket->bucket_id; + } + + ofputil_put_ofp15_bucket(bucket, bucket_id, gm->type, b, ofp_version); } + ogm = ofpbuf_at_assert(b, start_ogm, sizeof *ogm); + ogm->command = htons(gm->command); + ogm->type = gm->type; + ogm->group_id = htonl(gm->group_id); + ogm->command_bucket_id = htonl(gm->command_bucket_id); + ogm->bucket_array_len = htons(b->size - start_ogm - sizeof *ogm); - if (!msg->size) { - return EOF; + /* Add group properties */ + if (gm->props.selection_method[0]) { + ofputil_put_group_prop_ntr_selection_method(ofp_version, &gm->props, b); } - ogds = ofpbuf_try_pull(msg, sizeof *ogds); - if (!ogds) { - VLOG_WARN_RL(&bad_ofmsg_rl, "OFPST11_GROUP_DESC reply has %"PRIuSIZE" " - "leftover bytes at end", msg->size); - return OFPERR_OFPBRC_BAD_LEN; + id_pool_destroy(bucket_ids); + return b; +} + +static void +bad_group_cmd(enum ofp15_group_mod_command cmd) { + const char *opt_version; + const char *version; + const char *cmd_str; + + switch (cmd) { + case OFPGC15_ADD: + case OFPGC15_MODIFY: + case OFPGC15_DELETE: + version = "1.1"; + opt_version = "11"; + break; + + case OFPGC15_INSERT_BUCKET: + case OFPGC15_REMOVE_BUCKET: + version = "1.5"; + opt_version = "15"; + + default: + OVS_NOT_REACHED(); } - gd->type = ogds->type; - gd->group_id = ntohl(ogds->group_id); - length = ntohs(ogds->length); - if (length < sizeof *ogds || length - sizeof *ogds > msg->size) { - VLOG_WARN_RL(&bad_ofmsg_rl, "OFPST11_GROUP_DESC reply claims invalid " - "length %"PRIuSIZE, length); - return OFPERR_OFPBRC_BAD_LEN; + switch (cmd) { + case OFPGC15_ADD: + cmd_str = "add-group"; + break; + + case OFPGC15_MODIFY: + cmd_str = "mod-group"; + break; + + case OFPGC15_DELETE: + cmd_str = "del-group"; + break; + + case OFPGC15_INSERT_BUCKET: + cmd_str = "insert-bucket"; + break; + + case OFPGC15_REMOVE_BUCKET: + cmd_str = "insert-bucket"; + break; + + default: + OVS_NOT_REACHED(); } - return ofputil_pull_buckets(msg, length - sizeof *ogds, version, - &gd->buckets); + ovs_fatal(0, "%s needs OpenFlow %s or later (\'-O OpenFlow%s\')", + cmd_str, version, opt_version); + } /* Converts abstract group mod 'gm' into a message for OpenFlow version @@ -6301,61 +8229,108 @@ struct ofpbuf * ofputil_encode_group_mod(enum ofp_version ofp_version, const struct ofputil_group_mod *gm) { - struct ofpbuf *b; - struct ofp11_group_mod *ogm; - size_t start_ogm; - size_t start_bucket; - struct ofputil_bucket *bucket; - struct ofp11_bucket *ob; switch (ofp_version) { - case OFP10_VERSION: { - if (gm->command == OFPGC11_ADD) { - ovs_fatal(0, "add-group needs OpenFlow 1.1 or later " - "(\'-O OpenFlow11\')"); - } else if (gm->command == OFPGC11_MODIFY) { - ovs_fatal(0, "mod-group needs OpenFlow 1.1 or later " - "(\'-O OpenFlow11\')"); - } else { - ovs_fatal(0, "del-groups needs OpenFlow 1.1 or later " - "(\'-O OpenFlow11\')"); - } - } + case OFP10_VERSION: + bad_group_cmd(gm->command); case OFP11_VERSION: case OFP12_VERSION: case OFP13_VERSION: case OFP14_VERSION: - b = ofpraw_alloc(OFPRAW_OFPT11_GROUP_MOD, ofp_version, 0); - start_ogm = b->size; - ofpbuf_put_zeros(b, sizeof *ogm); - - LIST_FOR_EACH (bucket, list_node, &gm->buckets) { - start_bucket = b->size; - ofpbuf_put_zeros(b, sizeof *ob); - if (bucket->ofpacts && bucket->ofpacts_len) { - ofpacts_put_openflow_actions(bucket->ofpacts, - bucket->ofpacts_len, b, - ofp_version); - } - ob = ofpbuf_at_assert(b, start_bucket, sizeof *ob); - ob->len = htons(b->size - start_bucket);; - ob->weight = htons(bucket->weight); - ob->watch_port = ofputil_port_to_ofp11(bucket->watch_port); - ob->watch_group = htonl(bucket->watch_group); + if (gm->command > OFPGC11_DELETE) { + bad_group_cmd(gm->command); } - ogm = ofpbuf_at_assert(b, start_ogm, sizeof *ogm); - ogm->command = htons(gm->command); - ogm->type = gm->type; - ogm->group_id = htonl(gm->group_id); + return ofputil_encode_ofp11_group_mod(ofp_version, gm); - break; + case OFP15_VERSION: + return ofputil_encode_ofp15_group_mod(ofp_version, gm); default: OVS_NOT_REACHED(); } +} - return b; +static enum ofperr +ofputil_pull_ofp11_group_mod(struct ofpbuf *msg, enum ofp_version ofp_version, + struct ofputil_group_mod *gm) +{ + const struct ofp11_group_mod *ogm; + enum ofperr error; + + ogm = ofpbuf_pull(msg, sizeof *ogm); + gm->command = ntohs(ogm->command); + gm->type = ogm->type; + gm->group_id = ntohl(ogm->group_id); + gm->command_bucket_id = OFPG15_BUCKET_ALL; + + error = ofputil_pull_ofp11_buckets(msg, msg->size, ofp_version, + &gm->buckets); + + /* OF1.3.5+ prescribes an error when an OFPGC_DELETE includes buckets. */ + if (!error + && ofp_version >= OFP13_VERSION + && gm->command == OFPGC11_DELETE + && !list_is_empty(&gm->buckets)) { + error = OFPERR_OFPGMFC_INVALID_GROUP; + } + + return error; +} + +static enum ofperr +ofputil_pull_ofp15_group_mod(struct ofpbuf *msg, enum ofp_version ofp_version, + struct ofputil_group_mod *gm) +{ + const struct ofp15_group_mod *ogm; + uint16_t bucket_list_len; + enum ofperr error = OFPERR_OFPGMFC_BAD_BUCKET; + + ogm = ofpbuf_pull(msg, sizeof *ogm); + gm->command = ntohs(ogm->command); + gm->type = ogm->type; + gm->group_id = ntohl(ogm->group_id); + + gm->command_bucket_id = ntohl(ogm->command_bucket_id); + switch (gm->command) { + case OFPGC15_REMOVE_BUCKET: + if (gm->command_bucket_id == OFPG15_BUCKET_ALL) { + error = 0; + } + /* Fall through */ + case OFPGC15_INSERT_BUCKET: + if (gm->command_bucket_id <= OFPG15_BUCKET_MAX || + gm->command_bucket_id == OFPG15_BUCKET_FIRST + || gm->command_bucket_id == OFPG15_BUCKET_LAST) { + error = 0; + } + break; + + case OFPGC11_ADD: + case OFPGC11_MODIFY: + case OFPGC11_DELETE: + default: + if (gm->command_bucket_id == OFPG15_BUCKET_ALL) { + error = 0; + } + break; + } + if (error) { + VLOG_WARN_RL(&bad_ofmsg_rl, + "group command bucket id (%u) is out of range", + gm->command_bucket_id); + return OFPERR_OFPGMFC_BAD_BUCKET; + } + + bucket_list_len = ntohs(ogm->bucket_array_len); + error = ofputil_pull_ofp15_buckets(msg, bucket_list_len, ofp_version, + &gm->buckets); + if (error) { + return error; + } + + return parse_ofp15_group_properties(msg, gm->type, gm->command, &gm->props, + msg->size); } /* Converts OpenFlow group mod message 'oh' into an abstract group mod in @@ -6364,7 +8339,7 @@ enum ofperr ofputil_decode_group_mod(const struct ofp_header *oh, struct ofputil_group_mod *gm) { - const struct ofp11_group_mod *ogm; + enum ofp_version ofp_version = oh->version; struct ofpbuf msg; struct ofputil_bucket *bucket; enum ofperr err; @@ -6372,16 +8347,59 @@ ofputil_decode_group_mod(const struct ofp_header *oh, ofpbuf_use_const(&msg, oh, ntohs(oh->length)); ofpraw_pull_assert(&msg); - ogm = ofpbuf_pull(&msg, sizeof *ogm); - gm->command = ntohs(ogm->command); - gm->type = ogm->type; - gm->group_id = ntohl(ogm->group_id); + ofputil_init_group_properties(&gm->props); + + switch (ofp_version) + { + case OFP11_VERSION: + case OFP12_VERSION: + case OFP13_VERSION: + case OFP14_VERSION: + err = ofputil_pull_ofp11_group_mod(&msg, ofp_version, gm); + break; + + case OFP15_VERSION: + err = ofputil_pull_ofp15_group_mod(&msg, ofp_version, gm); + break; + + case OFP10_VERSION: + default: + OVS_NOT_REACHED(); + } - err = ofputil_pull_buckets(&msg, msg.size, oh->version, &gm->buckets); if (err) { return err; } + switch (gm->type) { + case OFPGT11_INDIRECT: + if (!list_is_singleton(&gm->buckets)) { + return OFPERR_OFPGMFC_INVALID_GROUP; + } + break; + case OFPGT11_ALL: + case OFPGT11_SELECT: + case OFPGT11_FF: + break; + default: + OVS_NOT_REACHED(); + } + + switch (gm->command) { + case OFPGC11_ADD: + case OFPGC11_MODIFY: + case OFPGC11_DELETE: + case OFPGC15_INSERT_BUCKET: + break; + case OFPGC15_REMOVE_BUCKET: + if (!list_is_empty(&gm->buckets)) { + return OFPERR_OFPGMFC_BAD_BUCKET; + } + break; + default: + OVS_NOT_REACHED(); + } + LIST_FOR_EACH (bucket, list_node, &gm->buckets) { switch (gm->type) { case OFPGT11_ALL: @@ -6412,6 +8430,7 @@ ofputil_decode_queue_stats_request(const struct ofp_header *request, struct ofputil_queue_stats_request *oqsr) { switch ((enum ofp_version)request->version) { + case OFP15_VERSION: case OFP14_VERSION: case OFP13_VERSION: case OFP12_VERSION: @@ -6437,9 +8456,9 @@ ofputil_decode_queue_stats_request(const struct ofp_header *request, } } -/* Encode a queue statsrequest for 'oqsr', the encoded message - * will be fore Open Flow version 'ofp_version'. Returns message - * as a struct ofpbuf. Returns encoded message on success, NULL on error */ +/* Encode a queue stats request for 'oqsr', the encoded message + * will be for OpenFlow version 'ofp_version'. Returns message + * as a struct ofpbuf. Returns encoded message on success, NULL on error. */ struct ofpbuf * ofputil_encode_queue_stats_request(enum ofp_version ofp_version, const struct ofputil_queue_stats_request *oqsr) @@ -6450,7 +8469,8 @@ ofputil_encode_queue_stats_request(enum ofp_version ofp_version, case OFP11_VERSION: case OFP12_VERSION: case OFP13_VERSION: - case OFP14_VERSION: { + case OFP14_VERSION: + case OFP15_VERSION: { struct ofp11_queue_stats_request *req; request = ofpraw_alloc(OFPRAW_OFPST11_QUEUE_REQUEST, ofp_version, 0); req = ofpbuf_put_zeros(request, sizeof *req); @@ -6475,36 +8495,21 @@ ofputil_encode_queue_stats_request(enum ofp_version ofp_version, return request; } -static size_t -ofputil_get_queue_stats_size(enum ofp_version ofp_version) -{ - switch (ofp_version) { - case OFP10_VERSION: - return sizeof(struct ofp10_queue_stats); - case OFP11_VERSION: - case OFP12_VERSION: - return sizeof(struct ofp11_queue_stats); - case OFP13_VERSION: - return sizeof(struct ofp13_queue_stats); - case OFP14_VERSION: - OVS_NOT_REACHED(); - return 0; - default: - OVS_NOT_REACHED(); - } -} - /* Returns the number of queue stats elements in OFPTYPE_QUEUE_STATS_REPLY * message 'oh'. */ size_t ofputil_count_queue_stats(const struct ofp_header *oh) { + struct ofputil_queue_stats qs; struct ofpbuf b; + size_t n = 0; ofpbuf_use_const(&b, oh, ntohs(oh->length)); ofpraw_pull_assert(&b); - - return b.size / ofputil_get_queue_stats_size(oh->version); + while (!ofputil_decode_queue_stats(&qs, &b)) { + n++; + } + return n; } static enum ofperr @@ -6554,6 +8559,29 @@ ofputil_queue_stats_from_ofp13(struct ofputil_queue_stats *oqs, return error; } +static enum ofperr +ofputil_pull_ofp14_queue_stats(struct ofputil_queue_stats *oqs, + struct ofpbuf *msg) +{ + const struct ofp14_queue_stats *qs14; + size_t len; + + qs14 = ofpbuf_try_pull(msg, sizeof *qs14); + if (!qs14) { + return OFPERR_OFPBRC_BAD_LEN; + } + + len = ntohs(qs14->length); + if (len < sizeof *qs14 || len - sizeof *qs14 > msg->size) { + return OFPERR_OFPBRC_BAD_LEN; + } + ofpbuf_pull(msg, len - sizeof *qs14); + + /* No properties yet defined, so ignore them for now. */ + + return ofputil_queue_stats_from_ofp13(oqs, &qs14->qs); +} + /* Converts an OFPST_QUEUE_STATS reply in 'msg' into an abstract * ofputil_queue_stats in 'qs'. * @@ -6570,8 +8598,7 @@ ofputil_decode_queue_stats(struct ofputil_queue_stats *qs, struct ofpbuf *msg) enum ofperr error; enum ofpraw raw; - error = (msg->l2 - ? ofpraw_decode(&raw, msg->l2) + error = (msg->header ? ofpraw_decode(&raw, msg->header) : ofpraw_pull(&raw, msg)); if (error) { return error; @@ -6579,6 +8606,8 @@ ofputil_decode_queue_stats(struct ofputil_queue_stats *qs, struct ofpbuf *msg) if (!msg->size) { return EOF; + } else if (raw == OFPRAW_OFPST14_QUEUE_REPLY) { + return ofputil_pull_ofp14_queue_stats(qs, msg); } else if (raw == OFPRAW_OFPST13_QUEUE_REPLY) { const struct ofp13_queue_stats *qs13; @@ -6608,7 +8637,7 @@ ofputil_decode_queue_stats(struct ofputil_queue_stats *qs, struct ofpbuf *msg) } bad_len: - VLOG_WARN_RL(&bad_ofmsg_rl, "OFPST_QUEUE reply has %"PRIuSIZE" leftover " + VLOG_WARN_RL(&bad_ofmsg_rl, "OFPST_QUEUE reply has %"PRIu32" leftover " "bytes at end", msg->size); return OFPERR_OFPBRC_BAD_LEN; } @@ -6650,15 +8679,22 @@ ofputil_queue_stats_to_ofp13(const struct ofputil_queue_stats *oqs, } } +static void +ofputil_queue_stats_to_ofp14(const struct ofputil_queue_stats *oqs, + struct ofp14_queue_stats *qs14) +{ + qs14->length = htons(sizeof *qs14); + memset(qs14->pad, 0, sizeof qs14->pad); + ofputil_queue_stats_to_ofp13(oqs, &qs14->qs); +} + + /* Encode a queue stat for 'oqs' and append it to 'replies'. */ void -ofputil_append_queue_stat(struct list *replies, +ofputil_append_queue_stat(struct ovs_list *replies, const struct ofputil_queue_stats *oqs) { - struct ofpbuf *msg = ofpbuf_from_list(list_back(replies)); - struct ofp_header *oh = msg->data; - - switch ((enum ofp_version)oh->version) { + switch (ofpmp_version(replies)) { case OFP13_VERSION: { struct ofp13_queue_stats *reply = ofpmp_append(replies, sizeof *reply); ofputil_queue_stats_to_ofp13(oqs, reply); @@ -6679,10 +8715,196 @@ ofputil_append_queue_stat(struct list *replies, } case OFP14_VERSION: - OVS_NOT_REACHED(); + case OFP15_VERSION: { + struct ofp14_queue_stats *reply = ofpmp_append(replies, sizeof *reply); + ofputil_queue_stats_to_ofp14(oqs, reply); break; + } default: OVS_NOT_REACHED(); } } + +enum ofperr +ofputil_decode_bundle_ctrl(const struct ofp_header *oh, + struct ofputil_bundle_ctrl_msg *msg) +{ + struct ofpbuf b; + enum ofpraw raw; + const struct ofp14_bundle_ctrl_msg *m; + + ofpbuf_use_const(&b, oh, ntohs(oh->length)); + raw = ofpraw_pull_assert(&b); + ovs_assert(raw == OFPRAW_OFPT14_BUNDLE_CONTROL); + + m = b.msg; + msg->bundle_id = ntohl(m->bundle_id); + msg->type = ntohs(m->type); + msg->flags = ntohs(m->flags); + + return 0; +} + +struct ofpbuf * +ofputil_encode_bundle_ctrl_reply(const struct ofp_header *oh, + struct ofputil_bundle_ctrl_msg *msg) +{ + struct ofpbuf *buf; + struct ofp14_bundle_ctrl_msg *m; + + buf = ofpraw_alloc_reply(OFPRAW_OFPT14_BUNDLE_CONTROL, oh, 0); + m = ofpbuf_put_zeros(buf, sizeof *m); + + m->bundle_id = htonl(msg->bundle_id); + m->type = htons(msg->type); + m->flags = htons(msg->flags); + + return buf; +} + +/* Return true for bundlable state change requests, false for other messages. + */ +static bool +ofputil_is_bundlable(enum ofptype type) +{ + switch (type) { + /* Minimum required by OpenFlow 1.4. */ + case OFPTYPE_PORT_MOD: + case OFPTYPE_FLOW_MOD: + return true; + + /* Nice to have later. */ + case OFPTYPE_FLOW_MOD_TABLE_ID: + case OFPTYPE_GROUP_MOD: + case OFPTYPE_TABLE_MOD: + case OFPTYPE_METER_MOD: + case OFPTYPE_PACKET_OUT: + + /* Not to be bundlable. */ + case OFPTYPE_ECHO_REQUEST: + case OFPTYPE_FEATURES_REQUEST: + case OFPTYPE_GET_CONFIG_REQUEST: + case OFPTYPE_SET_CONFIG: + case OFPTYPE_BARRIER_REQUEST: + case OFPTYPE_ROLE_REQUEST: + case OFPTYPE_ECHO_REPLY: + case OFPTYPE_SET_FLOW_FORMAT: + case OFPTYPE_SET_PACKET_IN_FORMAT: + case OFPTYPE_SET_CONTROLLER_ID: + case OFPTYPE_FLOW_AGE: + case OFPTYPE_FLOW_MONITOR_CANCEL: + case OFPTYPE_SET_ASYNC_CONFIG: + case OFPTYPE_GET_ASYNC_REQUEST: + case OFPTYPE_DESC_STATS_REQUEST: + case OFPTYPE_FLOW_STATS_REQUEST: + case OFPTYPE_AGGREGATE_STATS_REQUEST: + case OFPTYPE_TABLE_STATS_REQUEST: + case OFPTYPE_TABLE_FEATURES_STATS_REQUEST: + case OFPTYPE_PORT_STATS_REQUEST: + case OFPTYPE_QUEUE_STATS_REQUEST: + case OFPTYPE_PORT_DESC_STATS_REQUEST: + case OFPTYPE_FLOW_MONITOR_STATS_REQUEST: + case OFPTYPE_METER_STATS_REQUEST: + case OFPTYPE_METER_CONFIG_STATS_REQUEST: + case OFPTYPE_METER_FEATURES_STATS_REQUEST: + case OFPTYPE_GROUP_STATS_REQUEST: + case OFPTYPE_GROUP_DESC_STATS_REQUEST: + case OFPTYPE_GROUP_FEATURES_STATS_REQUEST: + case OFPTYPE_QUEUE_GET_CONFIG_REQUEST: + case OFPTYPE_BUNDLE_CONTROL: + case OFPTYPE_BUNDLE_ADD_MESSAGE: + case OFPTYPE_HELLO: + case OFPTYPE_ERROR: + case OFPTYPE_FEATURES_REPLY: + case OFPTYPE_GET_CONFIG_REPLY: + case OFPTYPE_PACKET_IN: + case OFPTYPE_FLOW_REMOVED: + case OFPTYPE_PORT_STATUS: + case OFPTYPE_BARRIER_REPLY: + case OFPTYPE_QUEUE_GET_CONFIG_REPLY: + case OFPTYPE_DESC_STATS_REPLY: + case OFPTYPE_FLOW_STATS_REPLY: + case OFPTYPE_QUEUE_STATS_REPLY: + case OFPTYPE_PORT_STATS_REPLY: + case OFPTYPE_TABLE_STATS_REPLY: + case OFPTYPE_AGGREGATE_STATS_REPLY: + case OFPTYPE_PORT_DESC_STATS_REPLY: + case OFPTYPE_ROLE_REPLY: + case OFPTYPE_FLOW_MONITOR_PAUSED: + case OFPTYPE_FLOW_MONITOR_RESUMED: + case OFPTYPE_FLOW_MONITOR_STATS_REPLY: + case OFPTYPE_GET_ASYNC_REPLY: + case OFPTYPE_GROUP_STATS_REPLY: + case OFPTYPE_GROUP_DESC_STATS_REPLY: + case OFPTYPE_GROUP_FEATURES_STATS_REPLY: + case OFPTYPE_METER_STATS_REPLY: + case OFPTYPE_METER_CONFIG_STATS_REPLY: + case OFPTYPE_METER_FEATURES_STATS_REPLY: + case OFPTYPE_TABLE_FEATURES_STATS_REPLY: + case OFPTYPE_ROLE_STATUS: + break; + } + + return false; +} + +enum ofperr +ofputil_decode_bundle_add(const struct ofp_header *oh, + struct ofputil_bundle_add_msg *msg) +{ + const struct ofp14_bundle_ctrl_msg *m; + struct ofpbuf b; + enum ofpraw raw; + size_t inner_len; + enum ofperr error; + enum ofptype type; + + ofpbuf_use_const(&b, oh, ntohs(oh->length)); + raw = ofpraw_pull_assert(&b); + ovs_assert(raw == OFPRAW_OFPT14_BUNDLE_ADD_MESSAGE); + + m = ofpbuf_pull(&b, sizeof *m); + msg->bundle_id = ntohl(m->bundle_id); + msg->flags = ntohs(m->flags); + + msg->msg = b.data; + inner_len = ntohs(msg->msg->length); + if (inner_len < sizeof(struct ofp_header) || inner_len > b.size) { + return OFPERR_OFPBFC_MSG_BAD_LEN; + } + if (msg->msg->xid != oh->xid) { + return OFPERR_OFPBFC_MSG_BAD_XID; + } + + /* Reject unbundlable messages. */ + error = ofptype_decode(&type, msg->msg); + if (error) { + VLOG_WARN_RL(&bad_ofmsg_rl, "OFPT14_BUNDLE_ADD_MESSAGE contained " + "message is unparsable (%s)", ofperr_get_name(error)); + return OFPERR_OFPBFC_MSG_UNSUP; /* 'error' would be confusing. */ + } + + if (!ofputil_is_bundlable(type)) { + return OFPERR_OFPBFC_MSG_UNSUP; + } + + return 0; +} + +struct ofpbuf * +ofputil_encode_bundle_add(enum ofp_version ofp_version, + struct ofputil_bundle_add_msg *msg) +{ + struct ofpbuf *request; + struct ofp14_bundle_ctrl_msg *m; + + request = ofpraw_alloc(OFPRAW_OFPT14_BUNDLE_ADD_MESSAGE, ofp_version, 0); + m = ofpbuf_put_zeros(request, sizeof *m); + + m->bundle_id = htonl(msg->bundle_id); + m->flags = htons(msg->flags); + ofpbuf_put(request, msg->msg, ntohs(msg->msg->length)); + + return request; +}