X-Git-Url: http://git.cascardo.eti.br/?a=blobdiff_plain;f=lib%2Fnx-match.c;h=4999b1ac95d7672967928524f950a42b28f40e5e;hb=8f79bb4d3999d993424e9578342b4130d10a556c;hp=05f1ce99fc6e5a77c6a7c192aa83eb4e8ab5ff5b;hpb=2f2eb46c3f83de7e825ea4549fa90843b9066888;p=cascardo%2Fovs.git diff --git a/lib/nx-match.c b/lib/nx-match.c index 05f1ce99f..4999b1ac9 100644 --- a/lib/nx-match.c +++ b/lib/nx-match.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2010, 2011, 2012 Nicira, Inc. + * Copyright (c) 2010, 2011, 2012, 2013, 2014, 2015, 2016 Nicira, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -22,6 +22,7 @@ #include "classifier.h" #include "dynamic-string.h" +#include "hmap.h" #include "meta-flow.h" #include "ofp-actions.h" #include "ofp-errors.h" @@ -29,163 +30,505 @@ #include "ofpbuf.h" #include "openflow/nicira-ext.h" #include "packets.h" +#include "shash.h" +#include "tun-metadata.h" #include "unaligned.h" #include "util.h" -#include "vlog.h" +#include "openvswitch/vlog.h" VLOG_DEFINE_THIS_MODULE(nx_match); +/* OXM headers. + * + * + * Standard OXM/NXM + * ================ + * + * The header is 32 bits long. It looks like this: + * + * |31 16 15 9| 8 7 0 + * +----------------------------------+---------------+--+------------------+ + * | oxm_class | oxm_field |hm| oxm_length | + * +----------------------------------+---------------+--+------------------+ + * + * where hm stands for oxm_hasmask. It is followed by oxm_length bytes of + * payload. When oxm_hasmask is 0, the payload is the value of the field + * identified by the header; when oxm_hasmask is 1, the payload is a value for + * the field followed by a mask of equal length. + * + * Internally, we represent a standard OXM header as a 64-bit integer with the + * above information in the most-significant bits. + * + * + * Experimenter OXM + * ================ + * + * The header is 64 bits long. It looks like the diagram above except that a + * 32-bit experimenter ID, which we call oxm_vendor and which identifies a + * vendor, is inserted just before the payload. Experimenter OXMs are + * identified by an all-1-bits oxm_class (OFPXMC12_EXPERIMENTER). The + * oxm_length value *includes* the experimenter ID, so that the real payload is + * only oxm_length - 4 bytes long. + * + * Internally, we represent an experimenter OXM header as a 64-bit integer with + * the standard header in the upper 32 bits and the experimenter ID in the + * lower 32 bits. (It would be more convenient to swap the positions of the + * two 32-bit words, but this would be more error-prone because experimenter + * OXMs are very rarely used, so accidentally passing one through a 32-bit type + * somewhere in the OVS code would be hard to find.) + */ + +/* + * OXM Class IDs. + * The high order bit differentiate reserved classes from member classes. + * Classes 0x0000 to 0x7FFF are member classes, allocated by ONF. + * Classes 0x8000 to 0xFFFE are reserved classes, reserved for standardisation. + */ +enum ofp12_oxm_class { + OFPXMC12_NXM_0 = 0x0000, /* Backward compatibility with NXM */ + OFPXMC12_NXM_1 = 0x0001, /* Backward compatibility with NXM */ + OFPXMC12_OPENFLOW_BASIC = 0x8000, /* Basic class for OpenFlow */ + OFPXMC15_PACKET_REGS = 0x8001, /* Packet registers (pipeline fields). */ + OFPXMC12_EXPERIMENTER = 0xffff, /* Experimenter class */ +}; + +/* Functions for extracting raw field values from OXM/NXM headers. */ +static uint32_t nxm_vendor(uint64_t header) { return header; } +static int nxm_class(uint64_t header) { return header >> 48; } +static int nxm_field(uint64_t header) { return (header >> 41) & 0x7f; } +static bool nxm_hasmask(uint64_t header) { return (header >> 40) & 1; } +static int nxm_length(uint64_t header) { return (header >> 32) & 0xff; } +static uint64_t nxm_no_len(uint64_t header) { return header & 0xffffff80ffffffffULL; } + +static bool +is_experimenter_oxm(uint64_t header) +{ + return nxm_class(header) == OFPXMC12_EXPERIMENTER; +} + +/* The OXM header "length" field is somewhat tricky: + * + * - For a standard OXM header, the length is the number of bytes of the + * payload, and the payload consists of just the value (and mask, if + * present). + * + * - For an experimenter OXM header, the length is the number of bytes in + * the payload plus 4 (the length of the experimenter ID). That is, the + * experimenter ID is included in oxm_length. + * + * This function returns the length of the experimenter ID field in 'header'. + * That is, for an experimenter OXM (when an experimenter ID is present), it + * returns 4, and for a standard OXM (when no experimenter ID is present), it + * returns 0. */ +static int +nxm_experimenter_len(uint64_t header) +{ + return is_experimenter_oxm(header) ? 4 : 0; +} + +/* Returns the number of bytes that follow the header for an NXM/OXM entry + * with the given 'header'. */ +static int +nxm_payload_len(uint64_t header) +{ + return nxm_length(header) - nxm_experimenter_len(header); +} + +/* Returns the number of bytes in the header for an NXM/OXM entry with the + * given 'header'. */ +static int +nxm_header_len(uint64_t header) +{ + return 4 + nxm_experimenter_len(header); +} + +#define NXM_HEADER(VENDOR, CLASS, FIELD, HASMASK, LENGTH) \ + (((uint64_t) (CLASS) << 48) | \ + ((uint64_t) (FIELD) << 41) | \ + ((uint64_t) (HASMASK) << 40) | \ + ((uint64_t) (LENGTH) << 32) | \ + (VENDOR)) + +#define NXM_HEADER_FMT "%#"PRIx32":%d:%d:%d:%d" +#define NXM_HEADER_ARGS(HEADER) \ + nxm_vendor(HEADER), nxm_class(HEADER), nxm_field(HEADER), \ + nxm_hasmask(HEADER), nxm_length(HEADER) + +/* Functions for turning the "hasmask" bit on or off. (This also requires + * adjusting the length.) */ +static uint64_t +nxm_make_exact_header(uint64_t header) +{ + int new_len = nxm_payload_len(header) / 2 + nxm_experimenter_len(header); + return NXM_HEADER(nxm_vendor(header), nxm_class(header), + nxm_field(header), 0, new_len); +} +static uint64_t +nxm_make_wild_header(uint64_t header) +{ + int new_len = nxm_payload_len(header) * 2 + nxm_experimenter_len(header); + return NXM_HEADER(nxm_vendor(header), nxm_class(header), + nxm_field(header), 1, new_len); +} + +/* Flow cookie. + * + * This may be used to gain the OpenFlow 1.1-like ability to restrict + * certain NXM-based Flow Mod and Flow Stats Request messages to flows + * with specific cookies. See the "nx_flow_mod" and "nx_flow_stats_request" + * structure definitions for more details. This match is otherwise not + * allowed. */ +#define NXM_NX_COOKIE NXM_HEADER (0, 0x0001, 30, 0, 8) +#define NXM_NX_COOKIE_W nxm_make_wild_header(NXM_NX_COOKIE) + +struct nxm_field { + uint64_t header; + enum ofp_version version; + const char *name; /* e.g. "NXM_OF_IN_PORT". */ + + enum mf_field_id id; +}; + +static const struct nxm_field *nxm_field_by_header(uint64_t header); +static const struct nxm_field *nxm_field_by_name(const char *name, size_t len); +static const struct nxm_field *nxm_field_by_mf_id(enum mf_field_id, + enum ofp_version); + +static void nx_put_header__(struct ofpbuf *, uint64_t header, bool masked); +static void nx_put_header_len(struct ofpbuf *, enum mf_field_id field, + enum ofp_version version, bool masked, + size_t n_bytes); + /* Rate limit for nx_match parse errors. These always indicate a bug in the * peer and so there's not much point in showing a lot of them. */ static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5); -/* Returns the width of the data for a field with the given 'header', in - * bytes. */ -int -nxm_field_bytes(uint32_t header) +static const struct nxm_field * +mf_parse_subfield_name(const char *name, int name_len, bool *wild); + +/* Returns the preferred OXM header to use for field 'id' in OpenFlow version + * 'version'. Specify 0 for 'version' if an NXM legacy header should be + * preferred over any standardized OXM header. Returns 0 if field 'id' cannot + * be expressed in NXM or OXM. */ +static uint64_t +mf_oxm_header(enum mf_field_id id, enum ofp_version version) +{ + const struct nxm_field *f = nxm_field_by_mf_id(id, version); + return f ? f->header : 0; +} + +/* Returns the 32-bit OXM or NXM header to use for field 'id', preferring an + * NXM legacy header over any standardized OXM header. Returns 0 if field 'id' + * cannot be expressed with a 32-bit NXM or OXM header. + * + * Whenever possible, use nx_pull_header() instead of this function, because + * this function cannot support 64-bit experimenter OXM headers. */ +uint32_t +mf_nxm_header(enum mf_field_id id) +{ + uint64_t oxm = mf_oxm_header(id, 0); + return is_experimenter_oxm(oxm) ? 0 : oxm >> 32; +} + +static const struct mf_field * +mf_from_oxm_header(uint64_t header) +{ + const struct nxm_field *f = nxm_field_by_header(header); + return f ? mf_from_id(f->id) : NULL; +} + +/* Returns the "struct mf_field" that corresponds to NXM or OXM header + * 'header', or NULL if 'header' doesn't correspond to any known field. */ +const struct mf_field * +mf_from_nxm_header(uint32_t header) { - unsigned int length = NXM_LENGTH(header); - return NXM_HASMASK(header) ? length / 2 : length; + return mf_from_oxm_header((uint64_t) header << 32); } /* Returns the width of the data for a field with the given 'header', in - * bits. */ -int -nxm_field_bits(uint32_t header) + * bytes. */ +static int +nxm_field_bytes(uint64_t header) { - return nxm_field_bytes(header) * 8; + unsigned int length = nxm_payload_len(header); + return nxm_hasmask(header) ? length / 2 : length; } /* nx_pull_match() and helpers. */ -static uint32_t -nx_entry_ok(const void *p, unsigned int match_len) +/* Given NXM/OXM value 'value' and mask 'mask' associated with 'header', checks + * for any 1-bit in the value where there is a 0-bit in the mask. Returns 0 if + * none, otherwise an error code. */ +static bool +is_mask_consistent(uint64_t header, const uint8_t *value, const uint8_t *mask) +{ + unsigned int width = nxm_field_bytes(header); + unsigned int i; + + for (i = 0; i < width; i++) { + if (value[i] & ~mask[i]) { + if (!VLOG_DROP_WARN(&rl)) { + VLOG_WARN_RL(&rl, "Rejecting NXM/OXM entry "NXM_HEADER_FMT " " + "with 1-bits in value for bits wildcarded by the " + "mask.", NXM_HEADER_ARGS(header)); + } + return false; + } + } + return true; +} + +static bool +is_cookie_pseudoheader(uint64_t header) +{ + return header == NXM_NX_COOKIE || header == NXM_NX_COOKIE_W; +} + +static enum ofperr +nx_pull_header__(struct ofpbuf *b, bool allow_cookie, uint64_t *header, + const struct mf_field **field) +{ + if (b->size < 4) { + goto bad_len; + } + + *header = ((uint64_t) ntohl(get_unaligned_be32(b->data))) << 32; + if (is_experimenter_oxm(*header)) { + if (b->size < 8) { + goto bad_len; + } + *header = ntohll(get_unaligned_be64(b->data)); + } + if (nxm_length(*header) < nxm_experimenter_len(*header)) { + VLOG_WARN_RL(&rl, "OXM header "NXM_HEADER_FMT" has invalid length %d " + "(minimum is %d)", + NXM_HEADER_ARGS(*header), nxm_length(*header), + nxm_header_len(*header)); + goto error; + } + ofpbuf_pull(b, nxm_header_len(*header)); + + if (field) { + *field = mf_from_oxm_header(*header); + if (!*field && !(allow_cookie && is_cookie_pseudoheader(*header))) { + VLOG_DBG_RL(&rl, "OXM header "NXM_HEADER_FMT" is unknown", + NXM_HEADER_ARGS(*header)); + return OFPERR_OFPBMC_BAD_FIELD; + } + } + + return 0; + +bad_len: + VLOG_DBG_RL(&rl, "encountered partial (%"PRIu32"-byte) OXM entry", + b->size); +error: + *header = 0; + if (field) { + *field = NULL; + } + return OFPERR_OFPBMC_BAD_LEN; +} + +static void +copy_entry_value(const struct mf_field *field, union mf_value *value, + const uint8_t *payload, int width) +{ + int copy_len; + void *copy_dst; + + copy_dst = value; + copy_len = MIN(width, field ? field->n_bytes : sizeof *value); + + if (field && field->variable_len) { + memset(value, 0, field->n_bytes); + copy_dst = &value->u8 + field->n_bytes - copy_len; + } + + memcpy(copy_dst, payload, copy_len); +} + +static enum ofperr +nx_pull_entry__(struct ofpbuf *b, bool allow_cookie, uint64_t *header, + const struct mf_field **field_, + union mf_value *value, union mf_value *mask) { + const struct mf_field *field; + enum ofperr header_error; unsigned int payload_len; - ovs_be32 header_be; - uint32_t header; + const uint8_t *payload; + int width; + + header_error = nx_pull_header__(b, allow_cookie, header, &field); + if (header_error && header_error != OFPERR_OFPBMC_BAD_FIELD) { + return header_error; + } + + payload_len = nxm_payload_len(*header); + payload = ofpbuf_try_pull(b, payload_len); + if (!payload) { + VLOG_DBG_RL(&rl, "OXM header "NXM_HEADER_FMT" calls for %u-byte " + "payload but only %"PRIu32" bytes follow OXM header", + NXM_HEADER_ARGS(*header), payload_len, b->size); + return OFPERR_OFPBMC_BAD_LEN; + } + + width = nxm_field_bytes(*header); + if (nxm_hasmask(*header) + && !is_mask_consistent(*header, payload, payload + width)) { + return OFPERR_OFPBMC_BAD_WILDCARDS; + } - if (match_len < 4) { - if (match_len) { - VLOG_DBG_RL(&rl, "nx_match ends with partial (%u-byte) nxm_header", - match_len); + copy_entry_value(field, value, payload, width); + + if (mask) { + if (nxm_hasmask(*header)) { + copy_entry_value(field, mask, payload + width, width); + } else { + memset(mask, 0xff, sizeof *mask); } - return 0; + } else if (nxm_hasmask(*header)) { + VLOG_DBG_RL(&rl, "OXM header "NXM_HEADER_FMT" includes mask but " + "masked OXMs are not allowed here", + NXM_HEADER_ARGS(*header)); + return OFPERR_OFPBMC_BAD_MASK; } - memcpy(&header_be, p, 4); - header = ntohl(header_be); - payload_len = NXM_LENGTH(header); - if (!payload_len) { - VLOG_DBG_RL(&rl, "nxm_entry %08"PRIx32" has invalid payload " - "length 0", header); - return 0; + if (field_) { + *field_ = field; + return header_error; } - if (match_len < payload_len + 4) { - VLOG_DBG_RL(&rl, "%"PRIu32"-byte nxm_entry but only " - "%u bytes left in nx_match", payload_len + 4, match_len); - return 0; + + return 0; +} + +/* Attempts to pull an NXM or OXM header, value, and mask (if present) from the + * beginning of 'b'. If successful, stores a pointer to the "struct mf_field" + * corresponding to the pulled header in '*field', the value into '*value', + * and the mask into '*mask', and returns 0. On error, returns an OpenFlow + * error; in this case, some bytes might have been pulled off 'b' anyhow, and + * the output parameters might have been modified. + * + * If a NULL 'mask' is supplied, masked OXM or NXM entries are treated as + * errors (with OFPERR_OFPBMC_BAD_MASK). + */ +enum ofperr +nx_pull_entry(struct ofpbuf *b, const struct mf_field **field, + union mf_value *value, union mf_value *mask) +{ + uint64_t header; + + return nx_pull_entry__(b, false, &header, field, value, mask); +} + +/* Attempts to pull an NXM or OXM header from the beginning of 'b'. If + * successful, stores a pointer to the "struct mf_field" corresponding to the + * pulled header in '*field', stores the header's hasmask bit in '*masked' + * (true if hasmask=1, false if hasmask=0), and returns 0. On error, returns + * an OpenFlow error; in this case, some bytes might have been pulled off 'b' + * anyhow, and the output parameters might have been modified. + * + * If NULL 'masked' is supplied, masked OXM or NXM headers are treated as + * errors (with OFPERR_OFPBMC_BAD_MASK). + */ +enum ofperr +nx_pull_header(struct ofpbuf *b, const struct mf_field **field, bool *masked) +{ + enum ofperr error; + uint64_t header; + + error = nx_pull_header__(b, false, &header, field); + if (masked) { + *masked = !error && nxm_hasmask(header); + } else if (!error && nxm_hasmask(header)) { + error = OFPERR_OFPBMC_BAD_MASK; } + return error; +} + +static enum ofperr +nx_pull_match_entry(struct ofpbuf *b, bool allow_cookie, + const struct mf_field **field, + union mf_value *value, union mf_value *mask) +{ + enum ofperr error; + uint64_t header; - return header; + error = nx_pull_entry__(b, allow_cookie, &header, field, value, mask); + if (error) { + return error; + } + if (field && *field) { + if (!mf_is_mask_valid(*field, mask)) { + VLOG_DBG_RL(&rl, "bad mask for field %s", (*field)->name); + return OFPERR_OFPBMC_BAD_MASK; + } + if (!mf_is_value_valid(*field, value)) { + VLOG_DBG_RL(&rl, "bad value for field %s", (*field)->name); + return OFPERR_OFPBMC_BAD_VALUE; + } + } + return 0; } static enum ofperr nx_pull_raw(const uint8_t *p, unsigned int match_len, bool strict, struct match *match, ovs_be64 *cookie, ovs_be64 *cookie_mask) { - uint32_t header; - - assert((cookie != NULL) == (cookie_mask != NULL)); + ovs_assert((cookie != NULL) == (cookie_mask != NULL)); match_init_catchall(match); if (cookie) { *cookie = *cookie_mask = htonll(0); } - if (!match_len) { - return 0; - } - for (; - (header = nx_entry_ok(p, match_len)) != 0; - p += 4 + NXM_LENGTH(header), match_len -= 4 + NXM_LENGTH(header)) { - const struct mf_field *mf; + struct ofpbuf b = ofpbuf_const_initializer(p, match_len); + while (b.size) { + const uint8_t *pos = b.data; + const struct mf_field *field; + union mf_value value; + union mf_value mask; enum ofperr error; - mf = mf_from_nxm_header(header); - if (!mf) { - if (strict) { + error = nx_pull_match_entry(&b, cookie != NULL, &field, &value, &mask); + if (error) { + if (error == OFPERR_OFPBMC_BAD_FIELD && !strict) { + continue; + } + } else if (!field) { + if (!cookie) { error = OFPERR_OFPBMC_BAD_FIELD; + } else if (*cookie_mask) { + error = OFPERR_OFPBMC_DUP_FIELD; } else { - continue; + *cookie = value.be64; + *cookie_mask = mask.be64; } - } else if (!mf_are_prereqs_ok(mf, &match->flow)) { + } else if (!mf_are_prereqs_ok(field, &match->flow)) { error = OFPERR_OFPBMC_BAD_PREREQ; - } else if (!mf_is_all_wild(mf, &match->wc)) { + } else if (!mf_is_all_wild(field, &match->wc)) { error = OFPERR_OFPBMC_DUP_FIELD; - } else if (header != OXM_OF_IN_PORT) { - unsigned int width = mf->n_bytes; - union mf_value value; - - memcpy(&value, p + 4, width); - if (!mf_is_value_valid(mf, &value)) { - error = OFPERR_OFPBMC_BAD_VALUE; - } else if (!NXM_HASMASK(header)) { - error = 0; - mf_set_value(mf, &value, match); - } else { - union mf_value mask; - - memcpy(&mask, p + 4 + width, width); - if (!mf_is_mask_valid(mf, &mask)) { - error = OFPERR_OFPBMC_BAD_MASK; - } else { - error = 0; - mf_set(mf, &value, &mask, match); - } - } } else { - /* Special case for 32bit ports when using OXM, - * ports are 16 bits wide otherwise. */ - ovs_be32 port_of11; - uint16_t port; - - memcpy(&port_of11, p + 4, sizeof port_of11); - error = ofputil_port_from_ofp11(port_of11, &port); - if (!error) { - match_set_in_port(match, port); - } - } - - /* Check if the match is for a cookie rather than a classifier rule. */ - if ((header == NXM_NX_COOKIE || header == NXM_NX_COOKIE_W) && cookie) { - if (*cookie_mask) { - error = OFPERR_OFPBMC_DUP_FIELD; - } else { - unsigned int width = sizeof *cookie; - - memcpy(cookie, p + 4, width); - if (NXM_HASMASK(header)) { - memcpy(cookie_mask, p + 4 + width, width); - } else { - *cookie_mask = htonll(UINT64_MAX); - } - error = 0; + char *err_str; + + mf_set(field, &value, &mask, match, &err_str); + if (err_str) { + VLOG_DBG_RL(&rl, "error parsing OXM at offset %"PRIdPTR" " + "within match (%s)", pos - p, err_str); + free(err_str); + return OFPERR_OFPBMC_BAD_VALUE; } } if (error) { - VLOG_DBG_RL(&rl, "bad nxm_entry %#08"PRIx32" (vendor=%"PRIu32", " - "field=%"PRIu32", hasmask=%"PRIu32", len=%"PRIu32"), " - "(%s)", header, - NXM_VENDOR(header), NXM_FIELD(header), - NXM_HASMASK(header), NXM_LENGTH(header), - ofperr_to_string(error)); + VLOG_DBG_RL(&rl, "error parsing OXM at offset %"PRIdPTR" " + "within match (%s)", pos - + p, ofperr_to_string(error)); return error; } } - return match_len ? OFPERR_OFPBMC_BAD_LEN : 0; + return 0; } static enum ofperr @@ -200,7 +543,7 @@ nx_pull_match__(struct ofpbuf *b, unsigned int match_len, bool strict, if (!p) { VLOG_DBG_RL(&rl, "nx_match length %u, rounded up to a " "multiple of 8, is longer than space in message (max " - "length %zu)", match_len, b->size); + "length %"PRIu32")", match_len, b->size); return OFPERR_OFPBMC_BAD_LEN; } } @@ -257,7 +600,7 @@ oxm_pull_match__(struct ofpbuf *b, bool strict, struct match *match) if (!p) { VLOG_DBG_RL(&rl, "oxm length %u, rounded up to a " "multiple of 8, is longer than space in message (max " - "length %zu)", match_len, b->size); + "length %"PRIu32")", match_len, b->size); return OFPERR_OFPBMC_BAD_LEN; } @@ -265,8 +608,8 @@ oxm_pull_match__(struct ofpbuf *b, bool strict, struct match *match) strict, match, NULL, NULL); } -/* Parses the oxm formatted match description preceeded by a struct ofp11_match - * in 'b' with length 'match_len'. Stores the result in 'match'. +/* Parses the oxm formatted match description preceded by a struct + * ofp11_match_header in 'b'. Stores the result in 'match'. * * Fails with an error when encountering unknown OXM headers. * @@ -278,251 +621,275 @@ oxm_pull_match(struct ofpbuf *b, struct match *match) } /* Behaves the same as oxm_pull_match() with one exception. Skips over unknown - * PXM headers instead of failing with an error when they are encountered. */ + * OXM headers instead of failing with an error when they are encountered. */ enum ofperr oxm_pull_match_loose(struct ofpbuf *b, struct match *match) { return oxm_pull_match__(b, false, match); } - -/* nx_put_match() and helpers. - * - * 'put' functions whose names end in 'w' add a wildcarded field. - * 'put' functions whose names end in 'm' add a field that might be wildcarded. - * Other 'put' functions add exact-match fields. - */ -static void -nxm_put_header(struct ofpbuf *b, uint32_t header) +/* Parses the OXM match description in the 'oxm_len' bytes in 'oxm'. Stores + * the result in 'match'. + * + * Fails with an error when encountering unknown OXM headers. + * + * Returns 0 if successful, otherwise an OpenFlow error code. */ +enum ofperr +oxm_decode_match(const void *oxm, size_t oxm_len, struct match *match) { - ovs_be32 n_header = htonl(header); - ofpbuf_put(b, &n_header, sizeof n_header); + return nx_pull_raw(oxm, oxm_len, true, match, NULL, NULL); } -static void -nxm_put_8(struct ofpbuf *b, uint32_t header, uint8_t value) +/* Verify an array of OXM TLVs treating value of each TLV as a mask, + * disallowing masks in each TLV and ignoring pre-requisites. */ +enum ofperr +oxm_pull_field_array(const void *fields_data, size_t fields_len, + struct field_array *fa) { - nxm_put_header(b, header); - ofpbuf_put(b, &value, sizeof value); -} + struct ofpbuf b = ofpbuf_const_initializer(fields_data, fields_len); + while (b.size) { + const uint8_t *pos = b.data; + const struct mf_field *field; + union mf_value value; + enum ofperr error; + uint64_t header; -static void -nxm_put_8m(struct ofpbuf *b, uint32_t header, uint8_t value, uint8_t mask) -{ - switch (mask) { - case 0: - break; + error = nx_pull_entry__(&b, false, &header, &field, &value, NULL); + if (error) { + VLOG_DBG_RL(&rl, "error pulling field array field"); + return error; + } else if (!field) { + VLOG_DBG_RL(&rl, "unknown field array field"); + error = OFPERR_OFPBMC_BAD_FIELD; + } else if (bitmap_is_set(fa->used.bm, field->id)) { + VLOG_DBG_RL(&rl, "duplicate field array field '%s'", field->name); + error = OFPERR_OFPBMC_DUP_FIELD; + } else if (!mf_is_mask_valid(field, &value)) { + VLOG_DBG_RL(&rl, "bad mask in field array field '%s'", field->name); + return OFPERR_OFPBMC_BAD_MASK; + } else { + field_array_set(field->id, &value, fa); + } - case UINT8_MAX: - nxm_put_8(b, header, value); - break; + if (error) { + const uint8_t *start = fields_data; - default: - nxm_put_header(b, NXM_MAKE_WILD_HEADER(header)); - ofpbuf_put(b, &value, sizeof value); - ofpbuf_put(b, &mask, sizeof mask); + VLOG_DBG_RL(&rl, "error parsing OXM at offset %"PRIdPTR" " + "within field array (%s)", pos - start, + ofperr_to_string(error)); + return error; + } } -} -static void -nxm_put_16(struct ofpbuf *b, uint32_t header, ovs_be16 value) + return 0; +} + +/* nx_put_match() and helpers. + * + * 'put' functions whose names end in 'w' add a wildcarded field. + * 'put' functions whose names end in 'm' add a field that might be wildcarded. + * Other 'put' functions add exact-match fields. + */ +void +nxm_put__(struct ofpbuf *b, enum mf_field_id field, enum ofp_version version, + const void *value, const void *mask, size_t n_bytes) { - nxm_put_header(b, header); - ofpbuf_put(b, &value, sizeof value); + nx_put_header_len(b, field, version, !!mask, n_bytes); + ofpbuf_put(b, value, n_bytes); + if (mask) { + ofpbuf_put(b, mask, n_bytes); + } + } static void -nxm_put_16w(struct ofpbuf *b, uint32_t header, ovs_be16 value, ovs_be16 mask) +nxm_put(struct ofpbuf *b, enum mf_field_id field, enum ofp_version version, + const void *value, const void *mask, size_t n_bytes) { - nxm_put_header(b, header); - ofpbuf_put(b, &value, sizeof value); - ofpbuf_put(b, &mask, sizeof mask); + if (!is_all_zeros(mask, n_bytes)) { + bool masked = !is_all_ones(mask, n_bytes); + nxm_put__(b, field, version, value, masked ? mask : NULL, n_bytes); + } } static void -nxm_put_16m(struct ofpbuf *b, uint32_t header, ovs_be16 value, ovs_be16 mask) +nxm_put_8m(struct ofpbuf *b, enum mf_field_id field, enum ofp_version version, + uint8_t value, uint8_t mask) { - switch (mask) { - case 0: - break; - - case CONSTANT_HTONS(UINT16_MAX): - nxm_put_16(b, header, value); - break; - - default: - nxm_put_16w(b, NXM_MAKE_WILD_HEADER(header), value, mask); - break; - } + nxm_put(b, field, version, &value, &mask, sizeof value); } static void -nxm_put_32(struct ofpbuf *b, uint32_t header, ovs_be32 value) +nxm_put_8(struct ofpbuf *b, enum mf_field_id field, enum ofp_version version, + uint8_t value) { - nxm_put_header(b, header); - ofpbuf_put(b, &value, sizeof value); + nxm_put__(b, field, version, &value, NULL, sizeof value); } static void -nxm_put_32w(struct ofpbuf *b, uint32_t header, ovs_be32 value, ovs_be32 mask) +nxm_put_16m(struct ofpbuf *b, enum mf_field_id field, enum ofp_version version, + ovs_be16 value, ovs_be16 mask) { - nxm_put_header(b, header); - ofpbuf_put(b, &value, sizeof value); - ofpbuf_put(b, &mask, sizeof mask); + nxm_put(b, field, version, &value, &mask, sizeof value); } static void -nxm_put_32m(struct ofpbuf *b, uint32_t header, ovs_be32 value, ovs_be32 mask) +nxm_put_16(struct ofpbuf *b, enum mf_field_id field, enum ofp_version version, + ovs_be16 value) { - switch (mask) { - case 0: - break; - - case CONSTANT_HTONL(UINT32_MAX): - nxm_put_32(b, header, value); - break; - - default: - nxm_put_32w(b, NXM_MAKE_WILD_HEADER(header), value, mask); - break; - } + nxm_put__(b, field, version, &value, NULL, sizeof value); } static void -nxm_put_64(struct ofpbuf *b, uint32_t header, ovs_be64 value) +nxm_put_32m(struct ofpbuf *b, enum mf_field_id field, enum ofp_version version, + ovs_be32 value, ovs_be32 mask) { - nxm_put_header(b, header); - ofpbuf_put(b, &value, sizeof value); + nxm_put(b, field, version, &value, &mask, sizeof value); } static void -nxm_put_64w(struct ofpbuf *b, uint32_t header, ovs_be64 value, ovs_be64 mask) +nxm_put_32(struct ofpbuf *b, enum mf_field_id field, enum ofp_version version, + ovs_be32 value) { - nxm_put_header(b, header); - ofpbuf_put(b, &value, sizeof value); - ofpbuf_put(b, &mask, sizeof mask); + nxm_put__(b, field, version, &value, NULL, sizeof value); } static void -nxm_put_64m(struct ofpbuf *b, uint32_t header, ovs_be64 value, ovs_be64 mask) +nxm_put_64m(struct ofpbuf *b, enum mf_field_id field, enum ofp_version version, + ovs_be64 value, ovs_be64 mask) { - switch (mask) { - case 0: - break; - - case CONSTANT_HTONLL(UINT64_MAX): - nxm_put_64(b, header, value); - break; - - default: - nxm_put_64w(b, NXM_MAKE_WILD_HEADER(header), value, mask); - break; - } + nxm_put(b, field, version, &value, &mask, sizeof value); } static void -nxm_put_eth(struct ofpbuf *b, uint32_t header, - const uint8_t value[ETH_ADDR_LEN]) +nxm_put_128m(struct ofpbuf *b, + enum mf_field_id field, enum ofp_version version, + const ovs_be128 value, const ovs_be128 mask) { - nxm_put_header(b, header); - ofpbuf_put(b, value, ETH_ADDR_LEN); + nxm_put(b, field, version, &value, &mask, sizeof(value)); } static void -nxm_put_eth_masked(struct ofpbuf *b, uint32_t header, - const uint8_t value[ETH_ADDR_LEN], - const uint8_t mask[ETH_ADDR_LEN]) +nxm_put_eth_masked(struct ofpbuf *b, + enum mf_field_id field, enum ofp_version version, + const struct eth_addr value, const struct eth_addr mask) { - if (!eth_addr_is_zero(mask)) { - if (eth_mask_is_exact(mask)) { - nxm_put_eth(b, header, value); - } else { - nxm_put_header(b, NXM_MAKE_WILD_HEADER(header)); - ofpbuf_put(b, value, ETH_ADDR_LEN); - ofpbuf_put(b, mask, ETH_ADDR_LEN); - } - } + nxm_put(b, field, version, value.ea, mask.ea, ETH_ADDR_LEN); } static void -nxm_put_ipv6(struct ofpbuf *b, uint32_t header, +nxm_put_ipv6(struct ofpbuf *b, + enum mf_field_id field, enum ofp_version version, const struct in6_addr *value, const struct in6_addr *mask) { - if (ipv6_mask_is_any(mask)) { - return; - } else if (ipv6_mask_is_exact(mask)) { - nxm_put_header(b, header); - ofpbuf_put(b, value, sizeof *value); - } else { - nxm_put_header(b, NXM_MAKE_WILD_HEADER(header)); - ofpbuf_put(b, value, sizeof *value); - ofpbuf_put(b, mask, sizeof *mask); - } + nxm_put(b, field, version, value->s6_addr, mask->s6_addr, + sizeof value->s6_addr); } static void -nxm_put_frag(struct ofpbuf *b, const struct match *match) +nxm_put_frag(struct ofpbuf *b, const struct match *match, + enum ofp_version version) { - uint8_t nw_frag = match->flow.nw_frag; - uint8_t nw_frag_mask = match->wc.masks.nw_frag; - - switch (nw_frag_mask) { - case 0: - break; + uint8_t nw_frag = match->flow.nw_frag & FLOW_NW_FRAG_MASK; + uint8_t nw_frag_mask = match->wc.masks.nw_frag & FLOW_NW_FRAG_MASK; - case FLOW_NW_FRAG_MASK: - nxm_put_8(b, NXM_NX_IP_FRAG, nw_frag); - break; - - default: - nxm_put_8m(b, NXM_NX_IP_FRAG, nw_frag, - nw_frag_mask & FLOW_NW_FRAG_MASK); - break; - } + nxm_put_8m(b, MFF_IP_FRAG, version, nw_frag, + nw_frag_mask == FLOW_NW_FRAG_MASK ? UINT8_MAX : nw_frag_mask); } +/* Appends to 'b' a set of OXM or NXM matches for the IPv4 or IPv6 fields in + * 'match'. */ static void -nxm_put_ip(struct ofpbuf *b, const struct match *match, - uint8_t icmp_proto, uint32_t icmp_type, uint32_t icmp_code, - bool oxm) +nxm_put_ip(struct ofpbuf *b, const struct match *match, enum ofp_version oxm) { const struct flow *flow = &match->flow; - nxm_put_frag(b, match); + if (flow->dl_type == htons(ETH_TYPE_IP)) { + nxm_put_32m(b, MFF_IPV4_SRC, oxm, + flow->nw_src, match->wc.masks.nw_src); + nxm_put_32m(b, MFF_IPV4_DST, oxm, + flow->nw_dst, match->wc.masks.nw_dst); + } else { + nxm_put_ipv6(b, MFF_IPV6_SRC, oxm, + &flow->ipv6_src, &match->wc.masks.ipv6_src); + nxm_put_ipv6(b, MFF_IPV6_DST, oxm, + &flow->ipv6_dst, &match->wc.masks.ipv6_dst); + } + + nxm_put_frag(b, match, oxm); if (match->wc.masks.nw_tos & IP_DSCP_MASK) { - nxm_put_8(b, oxm ? OXM_OF_IP_DSCP : NXM_OF_IP_TOS, - flow->nw_tos & IP_DSCP_MASK); + if (oxm) { + nxm_put_8(b, MFF_IP_DSCP_SHIFTED, oxm, + flow->nw_tos >> 2); + } else { + nxm_put_8(b, MFF_IP_DSCP, oxm, + flow->nw_tos & IP_DSCP_MASK); + } } if (match->wc.masks.nw_tos & IP_ECN_MASK) { - nxm_put_8(b, oxm ? OXM_OF_IP_ECN : NXM_NX_IP_ECN, + nxm_put_8(b, MFF_IP_ECN, oxm, flow->nw_tos & IP_ECN_MASK); } - if (!oxm && match->wc.masks.nw_ttl) { - nxm_put_8(b, NXM_NX_IP_TTL, flow->nw_ttl); + if (match->wc.masks.nw_ttl) { + nxm_put_8(b, MFF_IP_TTL, oxm, flow->nw_ttl); } + nxm_put_32m(b, MFF_IPV6_LABEL, oxm, + flow->ipv6_label, match->wc.masks.ipv6_label); + if (match->wc.masks.nw_proto) { - nxm_put_8(b, oxm ? OXM_OF_IP_PROTO : NXM_OF_IP_PROTO, flow->nw_proto); + nxm_put_8(b, MFF_IP_PROTO, oxm, flow->nw_proto); if (flow->nw_proto == IPPROTO_TCP) { - nxm_put_16m(b, oxm ? OXM_OF_TCP_SRC : NXM_OF_TCP_SRC, + nxm_put_16m(b, MFF_TCP_SRC, oxm, flow->tp_src, match->wc.masks.tp_src); - nxm_put_16m(b, oxm ? OXM_OF_TCP_DST : NXM_OF_TCP_DST, + nxm_put_16m(b, MFF_TCP_DST, oxm, flow->tp_dst, match->wc.masks.tp_dst); + nxm_put_16m(b, MFF_TCP_FLAGS, oxm, + flow->tcp_flags, match->wc.masks.tcp_flags); } else if (flow->nw_proto == IPPROTO_UDP) { - nxm_put_16m(b, oxm ? OXM_OF_UDP_SRC : NXM_OF_UDP_SRC, + nxm_put_16m(b, MFF_UDP_SRC, oxm, flow->tp_src, match->wc.masks.tp_src); - nxm_put_16m(b, oxm ? OXM_OF_UDP_DST : NXM_OF_UDP_DST, + nxm_put_16m(b, MFF_UDP_DST, oxm, flow->tp_dst, match->wc.masks.tp_dst); - } else if (flow->nw_proto == icmp_proto) { + } else if (flow->nw_proto == IPPROTO_SCTP) { + nxm_put_16m(b, MFF_SCTP_SRC, oxm, flow->tp_src, + match->wc.masks.tp_src); + nxm_put_16m(b, MFF_SCTP_DST, oxm, flow->tp_dst, + match->wc.masks.tp_dst); + } else if (is_icmpv4(flow)) { + if (match->wc.masks.tp_src) { + nxm_put_8(b, MFF_ICMPV4_TYPE, oxm, + ntohs(flow->tp_src)); + } + if (match->wc.masks.tp_dst) { + nxm_put_8(b, MFF_ICMPV4_CODE, oxm, + ntohs(flow->tp_dst)); + } + } else if (is_icmpv6(flow)) { if (match->wc.masks.tp_src) { - nxm_put_8(b, icmp_type, ntohs(flow->tp_src)); + nxm_put_8(b, MFF_ICMPV6_TYPE, oxm, + ntohs(flow->tp_src)); } if (match->wc.masks.tp_dst) { - nxm_put_8(b, icmp_code, ntohs(flow->tp_dst)); + nxm_put_8(b, MFF_ICMPV6_CODE, oxm, + ntohs(flow->tp_dst)); + } + if (flow->tp_src == htons(ND_NEIGHBOR_SOLICIT) || + flow->tp_src == htons(ND_NEIGHBOR_ADVERT)) { + nxm_put_ipv6(b, MFF_ND_TARGET, oxm, + &flow->nd_target, &match->wc.masks.nd_target); + if (flow->tp_src == htons(ND_NEIGHBOR_SOLICIT)) { + nxm_put_eth_masked(b, MFF_ND_SLL, oxm, + flow->arp_sha, match->wc.masks.arp_sha); + } + if (flow->tp_src == htons(ND_NEIGHBOR_ADVERT)) { + nxm_put_eth_masked(b, MFF_ND_TLL, oxm, + flow->arp_tha, match->wc.masks.arp_tha); + } } } } @@ -532,6 +899,9 @@ nxm_put_ip(struct ofpbuf *b, const struct match *match, * Flow Stats Requests messages, a 'cookie' and 'cookie_mask' may be supplied. * Otherwise, 'cookie_mask' should be zero. * + * Specify 'oxm' as 0 to express the match in NXM format; otherwise, specify + * 'oxm' as the OpenFlow version number for the OXM format to use. + * * This function can cause 'b''s data to be reallocated. * * Returns the number of bytes appended to 'b', excluding padding. @@ -539,7 +909,7 @@ nxm_put_ip(struct ofpbuf *b, const struct match *match, * If 'match' is a catch-all rule that matches every packet, then this function * appends nothing to 'b' and returns 0. */ static int -nx_put_raw(struct ofpbuf *b, bool oxm, const struct match *match, +nx_put_raw(struct ofpbuf *b, enum ofp_version oxm, const struct match *match, ovs_be64 cookie, ovs_be64 cookie_mask) { const struct flow *flow = &match->flow; @@ -547,24 +917,43 @@ nx_put_raw(struct ofpbuf *b, bool oxm, const struct match *match, int match_len; int i; - BUILD_ASSERT_DECL(FLOW_WC_SEQ == 18); + BUILD_ASSERT_DECL(FLOW_WC_SEQ == 35); /* Metadata. */ - if (match->wc.masks.in_port) { - uint16_t in_port = flow->in_port; + if (match->wc.masks.dp_hash) { + nxm_put_32m(b, MFF_DP_HASH, oxm, + htonl(flow->dp_hash), htonl(match->wc.masks.dp_hash)); + } + + if (match->wc.masks.recirc_id) { + nxm_put_32(b, MFF_RECIRC_ID, oxm, htonl(flow->recirc_id)); + } + + if (match->wc.masks.conj_id) { + nxm_put_32(b, MFF_CONJ_ID, oxm, htonl(flow->conj_id)); + } + + if (match->wc.masks.in_port.ofp_port) { + ofp_port_t in_port = flow->in_port.ofp_port; if (oxm) { - nxm_put_32(b, OXM_OF_IN_PORT, ofputil_port_to_ofp11(in_port)); + nxm_put_32(b, MFF_IN_PORT_OXM, oxm, + ofputil_port_to_ofp11(in_port)); } else { - nxm_put_16(b, NXM_OF_IN_PORT, htons(in_port)); + nxm_put_16(b, MFF_IN_PORT, oxm, + htons(ofp_to_u16(in_port))); } } + if (match->wc.masks.actset_output) { + nxm_put_32(b, MFF_ACTSET_OUTPUT, oxm, + ofputil_port_to_ofp11(flow->actset_output)); + } /* Ethernet. */ - nxm_put_eth_masked(b, oxm ? OXM_OF_ETH_SRC : NXM_OF_ETH_SRC, + nxm_put_eth_masked(b, MFF_ETH_SRC, oxm, flow->dl_src, match->wc.masks.dl_src); - nxm_put_eth_masked(b, oxm ? OXM_OF_ETH_DST : NXM_OF_ETH_DST, + nxm_put_eth_masked(b, MFF_ETH_DST, oxm, flow->dl_dst, match->wc.masks.dl_dst); - nxm_put_16m(b, oxm ? OXM_OF_ETH_TYPE : NXM_OF_ETH_TYPE, + nxm_put_16m(b, MFF_ETH_TYPE, oxm, ofputil_dl_type_to_openflow(flow->dl_type), match->wc.masks.dl_type); @@ -575,89 +964,123 @@ nx_put_raw(struct ofpbuf *b, bool oxm, const struct match *match, ovs_be16 mask = match->wc.masks.vlan_tci & VID_CFI_MASK; if (mask == htons(VLAN_VID_MASK | VLAN_CFI)) { - nxm_put_16(b, OXM_OF_VLAN_VID, vid); + nxm_put_16(b, MFF_VLAN_VID, oxm, vid); } else if (mask) { - nxm_put_16m(b, OXM_OF_VLAN_VID, vid, mask); + nxm_put_16m(b, MFF_VLAN_VID, oxm, vid, mask); } if (vid && vlan_tci_to_pcp(match->wc.masks.vlan_tci)) { - nxm_put_8(b, OXM_OF_VLAN_PCP, vlan_tci_to_pcp(flow->vlan_tci)); + nxm_put_8(b, MFF_VLAN_PCP, oxm, + vlan_tci_to_pcp(flow->vlan_tci)); } } else { - nxm_put_16m(b, NXM_OF_VLAN_TCI, flow->vlan_tci, + nxm_put_16m(b, MFF_VLAN_TCI, oxm, flow->vlan_tci, match->wc.masks.vlan_tci); } - /* L3. */ - if (flow->dl_type == htons(ETH_TYPE_IP)) { - /* IP. */ - nxm_put_32m(b, oxm ? OXM_OF_IPV4_SRC : NXM_OF_IP_SRC, - flow->nw_src, match->wc.masks.nw_src); - nxm_put_32m(b, oxm ? OXM_OF_IPV4_DST : NXM_OF_IP_DST, - flow->nw_dst, match->wc.masks.nw_dst); - nxm_put_ip(b, match, IPPROTO_ICMP, - oxm ? OXM_OF_ICMPV4_TYPE : NXM_OF_ICMP_TYPE, - oxm ? OXM_OF_ICMPV4_CODE : NXM_OF_ICMP_CODE, oxm); - } else if (flow->dl_type == htons(ETH_TYPE_IPV6)) { - /* IPv6. */ - nxm_put_ipv6(b, oxm ? OXM_OF_IPV6_SRC : NXM_NX_IPV6_SRC, - &flow->ipv6_src, &match->wc.masks.ipv6_src); - nxm_put_ipv6(b, oxm ? OXM_OF_IPV6_DST : NXM_NX_IPV6_DST, - &flow->ipv6_dst, &match->wc.masks.ipv6_dst); - nxm_put_ip(b, match, IPPROTO_ICMPV6, - oxm ? OXM_OF_ICMPV6_TYPE : NXM_NX_ICMPV6_TYPE, - oxm ? OXM_OF_ICMPV6_CODE : NXM_NX_ICMPV6_CODE, oxm); - - nxm_put_32m(b, oxm ? OXM_OF_IPV6_FLABEL : NXM_NX_IPV6_LABEL, - flow->ipv6_label, match->wc.masks.ipv6_label); - - if (flow->nw_proto == IPPROTO_ICMPV6 - && (flow->tp_src == htons(ND_NEIGHBOR_SOLICIT) || - flow->tp_src == htons(ND_NEIGHBOR_ADVERT))) { - nxm_put_ipv6(b, oxm ? OXM_OF_IPV6_ND_TARGET : NXM_NX_ND_TARGET, - &flow->nd_target, &match->wc.masks.nd_target); - if (flow->tp_src == htons(ND_NEIGHBOR_SOLICIT)) { - nxm_put_eth_masked(b, oxm ? OXM_OF_IPV6_ND_SLL : NXM_NX_ND_SLL, - flow->arp_sha, match->wc.masks.arp_sha); - } - if (flow->tp_src == htons(ND_NEIGHBOR_ADVERT)) { - nxm_put_eth_masked(b, oxm ? OXM_OF_IPV6_ND_TLL : NXM_NX_ND_TLL, - flow->arp_tha, match->wc.masks.arp_tha); - } + /* MPLS. */ + if (eth_type_mpls(flow->dl_type)) { + if (match->wc.masks.mpls_lse[0] & htonl(MPLS_TC_MASK)) { + nxm_put_8(b, MFF_MPLS_TC, oxm, + mpls_lse_to_tc(flow->mpls_lse[0])); + } + + if (match->wc.masks.mpls_lse[0] & htonl(MPLS_BOS_MASK)) { + nxm_put_8(b, MFF_MPLS_BOS, oxm, + mpls_lse_to_bos(flow->mpls_lse[0])); + } + + if (match->wc.masks.mpls_lse[0] & htonl(MPLS_LABEL_MASK)) { + nxm_put_32(b, MFF_MPLS_LABEL, oxm, + htonl(mpls_lse_to_label(flow->mpls_lse[0]))); } + } + + /* L3. */ + if (is_ip_any(flow)) { + nxm_put_ip(b, match, oxm); } else if (flow->dl_type == htons(ETH_TYPE_ARP) || flow->dl_type == htons(ETH_TYPE_RARP)) { /* ARP. */ if (match->wc.masks.nw_proto) { - nxm_put_16(b, oxm ? OXM_OF_ARP_OP : NXM_OF_ARP_OP, + nxm_put_16(b, MFF_ARP_OP, oxm, htons(flow->nw_proto)); } - nxm_put_32m(b, oxm ? OXM_OF_ARP_SPA : NXM_OF_ARP_SPA, + nxm_put_32m(b, MFF_ARP_SPA, oxm, flow->nw_src, match->wc.masks.nw_src); - nxm_put_32m(b, oxm ? OXM_OF_ARP_TPA : NXM_OF_ARP_TPA, + nxm_put_32m(b, MFF_ARP_TPA, oxm, flow->nw_dst, match->wc.masks.nw_dst); - nxm_put_eth_masked(b, oxm ? OXM_OF_ARP_SHA : NXM_NX_ARP_SHA, + nxm_put_eth_masked(b, MFF_ARP_SHA, oxm, flow->arp_sha, match->wc.masks.arp_sha); - nxm_put_eth_masked(b, oxm ? OXM_OF_ARP_THA : NXM_NX_ARP_THA, + nxm_put_eth_masked(b, MFF_ARP_THA, oxm, flow->arp_tha, match->wc.masks.arp_tha); } /* Tunnel ID. */ - nxm_put_64m(b, oxm ? OXM_OF_TUNNEL_ID : NXM_NX_TUN_ID, - flow->tunnel.tun_id, match->wc.masks.tunnel.tun_id); + nxm_put_64m(b, MFF_TUN_ID, oxm, + flow->tunnel.tun_id, match->wc.masks.tunnel.tun_id); + + /* Other tunnel metadata. */ + nxm_put_16m(b, MFF_TUN_FLAGS, oxm, + htons(flow->tunnel.flags), htons(match->wc.masks.tunnel.flags)); + nxm_put_32m(b, MFF_TUN_SRC, oxm, + flow->tunnel.ip_src, match->wc.masks.tunnel.ip_src); + nxm_put_32m(b, MFF_TUN_DST, oxm, + flow->tunnel.ip_dst, match->wc.masks.tunnel.ip_dst); + nxm_put_ipv6(b, MFF_TUN_IPV6_SRC, oxm, + &flow->tunnel.ipv6_src, &match->wc.masks.tunnel.ipv6_src); + nxm_put_ipv6(b, MFF_TUN_IPV6_DST, oxm, + &flow->tunnel.ipv6_dst, &match->wc.masks.tunnel.ipv6_dst); + nxm_put_16m(b, MFF_TUN_GBP_ID, oxm, + flow->tunnel.gbp_id, match->wc.masks.tunnel.gbp_id); + nxm_put_8m(b, MFF_TUN_GBP_FLAGS, oxm, + flow->tunnel.gbp_flags, match->wc.masks.tunnel.gbp_flags); + tun_metadata_to_nx_match(b, oxm, match); /* Registers. */ - for (i = 0; i < FLOW_N_REGS; i++) { - nxm_put_32m(b, NXM_NX_REG(i), - htonl(flow->regs[i]), htonl(match->wc.masks.regs[i])); + if (oxm < OFP15_VERSION) { + for (i = 0; i < FLOW_N_REGS; i++) { + nxm_put_32m(b, MFF_REG0 + i, oxm, + htonl(flow->regs[i]), htonl(match->wc.masks.regs[i])); + } + } else { + for (i = 0; i < FLOW_N_XREGS; i++) { + nxm_put_64m(b, MFF_XREG0 + i, oxm, + htonll(flow_get_xreg(flow, i)), + htonll(flow_get_xreg(&match->wc.masks, i))); + } } + /* Packet mark. */ + nxm_put_32m(b, MFF_PKT_MARK, oxm, htonl(flow->pkt_mark), + htonl(match->wc.masks.pkt_mark)); + + /* Connection tracking. */ + nxm_put_32m(b, MFF_CT_STATE, oxm, htonl(flow->ct_state), + htonl(match->wc.masks.ct_state)); + nxm_put_16m(b, MFF_CT_ZONE, oxm, htons(flow->ct_zone), + htons(match->wc.masks.ct_zone)); + nxm_put_32m(b, MFF_CT_MARK, oxm, htonl(flow->ct_mark), + htonl(match->wc.masks.ct_mark)); + nxm_put_128m(b, MFF_CT_LABEL, oxm, hton128(flow->ct_label), + hton128(match->wc.masks.ct_label)); + /* OpenFlow 1.1+ Metadata. */ - nxm_put_64m(b, OXM_OF_METADATA, flow->metadata, match->wc.masks.metadata); + nxm_put_64m(b, MFF_METADATA, oxm, + flow->metadata, match->wc.masks.metadata); /* Cookie. */ - nxm_put_64m(b, NXM_NX_COOKIE, cookie, cookie_mask); + if (cookie_mask) { + bool masked = cookie_mask != OVS_BE64_MAX; + + cookie &= cookie_mask; + nx_put_header__(b, NXM_NX_COOKIE, masked); + ofpbuf_put(b, &cookie, sizeof cookie); + if (masked) { + ofpbuf_put(b, &cookie_mask, sizeof cookie_mask); + } + } match_len = b->size - start_len; return match_len; @@ -677,23 +1100,26 @@ int nx_put_match(struct ofpbuf *b, const struct match *match, ovs_be64 cookie, ovs_be64 cookie_mask) { - int match_len = nx_put_raw(b, false, match, cookie, cookie_mask); + int match_len = nx_put_raw(b, 0, match, cookie, cookie_mask); - ofpbuf_put_zeros(b, ROUND_UP(match_len, 8) - match_len); + ofpbuf_put_zeros(b, PAD_SIZE(match_len, 8)); return match_len; } - -/* Appends to 'b' an struct ofp11_match_header followed by the oxm format that - * expresses 'cr', plus enough zero bytes to pad the data appended out to a +/* Appends to 'b' an struct ofp11_match_header followed by the OXM format that + * expresses 'match', plus enough zero bytes to pad the data appended out to a * multiple of 8. * + * OXM differs slightly among versions of OpenFlow. Specify the OpenFlow + * version in use as 'version'. + * * This function can cause 'b''s data to be reallocated. * * Returns the number of bytes appended to 'b', excluding the padding. Never * returns zero. */ int -oxm_put_match(struct ofpbuf *b, const struct match *match) +oxm_put_match(struct ofpbuf *b, const struct match *match, + enum ofp_version version) { int match_len; struct ofp11_match_header *omh; @@ -701,37 +1127,184 @@ oxm_put_match(struct ofpbuf *b, const struct match *match) ovs_be64 cookie = htonll(0), cookie_mask = htonll(0); ofpbuf_put_uninit(b, sizeof *omh); - match_len = nx_put_raw(b, true, match, cookie, cookie_mask) + sizeof *omh; - ofpbuf_put_zeros(b, ROUND_UP(match_len, 8) - match_len); + match_len = (nx_put_raw(b, version, match, cookie, cookie_mask) + + sizeof *omh); + ofpbuf_put_zeros(b, PAD_SIZE(match_len, 8)); - omh = (struct ofp11_match_header *)((char *)b->data + start_len); + omh = ofpbuf_at(b, start_len, sizeof *omh); omh->type = htons(OFPMT_OXM); omh->length = htons(match_len); return match_len; } + +/* Appends to 'b' the OXM formats that expresses 'match', without header or + * padding. + * + * OXM differs slightly among versions of OpenFlow. Specify the OpenFlow + * version in use as 'version'. + * + * This function can cause 'b''s data to be reallocated. */ +void +oxm_put_raw(struct ofpbuf *b, const struct match *match, + enum ofp_version version) +{ + nx_put_raw(b, version, match, 0, 0); +} + +/* Appends to 'b' the nx_match format that expresses the tlv corresponding + * to 'id'. If mask is not all-ones then it is also formated as the value + * of the tlv. */ +static void +nx_format_mask_tlv(struct ds *ds, enum mf_field_id id, + const union mf_value *mask) +{ + const struct mf_field *mf = mf_from_id(id); + + ds_put_format(ds, "%s", mf->name); + + if (!is_all_ones(mask, mf->n_bytes)) { + ds_put_char(ds, '='); + mf_format(mf, mask, NULL, ds); + } + + ds_put_char(ds, ','); +} + +/* Appends a string representation of 'fa_' to 'ds'. + * The TLVS value of 'fa_' is treated as a mask and + * only the name of fields is formated if it is all ones. */ +void +oxm_format_field_array(struct ds *ds, const struct field_array *fa) +{ + size_t start_len = ds->length; + int i; + + for (i = 0; i < MFF_N_IDS; i++) { + if (bitmap_is_set(fa->used.bm, i)) { + nx_format_mask_tlv(ds, i, &fa->value[i]); + } + } + + if (ds->length > start_len) { + ds_chomp(ds, ','); + } +} + +/* Appends to 'b' a series of OXM TLVs corresponding to the series + * of enum mf_field_id and value tuples in 'fa_'. + * + * OXM differs slightly among versions of OpenFlow. Specify the OpenFlow + * version in use as 'version'. + * + * This function can cause 'b''s data to be reallocated. + * + * Returns the number of bytes appended to 'b'. May return zero. */ +int +oxm_put_field_array(struct ofpbuf *b, const struct field_array *fa, + enum ofp_version version) +{ + size_t start_len = b->size; + int i; + + /* Field arrays are only used with the group selection method + * property and group properties are only available in OpenFlow 1.5+. + * So the following assertion should never fail. + * + * If support for older OpenFlow versions is desired then some care + * will need to be taken of different TLVs that handle the same + * flow fields. In particular: + * - VLAN_TCI, VLAN_VID and MFF_VLAN_PCP + * - IP_DSCP_MASK and DSCP_SHIFTED + * - REGS and XREGS + */ + ovs_assert(version >= OFP15_VERSION); + + for (i = 0; i < MFF_N_IDS; i++) { + if (bitmap_is_set(fa->used.bm, i)) { + int len = mf_field_len(mf_from_id(i), &fa->value[i], NULL, NULL); + nxm_put__(b, i, version, + &fa->value[i].u8 + mf_from_id(i)->n_bytes - len, NULL, + len); + } + } + + return b->size - start_len; +} + +static void +nx_put_header__(struct ofpbuf *b, uint64_t header, bool masked) +{ + uint64_t masked_header = masked ? nxm_make_wild_header(header) : header; + ovs_be64 network_header = htonll(masked_header); + + ofpbuf_put(b, &network_header, nxm_header_len(header)); +} + +void +nx_put_header(struct ofpbuf *b, enum mf_field_id field, + enum ofp_version version, bool masked) +{ + nx_put_header__(b, mf_oxm_header(field, version), masked); +} + +static void +nx_put_header_len(struct ofpbuf *b, enum mf_field_id field, + enum ofp_version version, bool masked, size_t n_bytes) +{ + uint64_t header = mf_oxm_header(field, version); + + header = NXM_HEADER(nxm_vendor(header), nxm_class(header), + nxm_field(header), false, + nxm_experimenter_len(header) + n_bytes); + + nx_put_header__(b, header, masked); +} + +void +nx_put_entry(struct ofpbuf *b, + enum mf_field_id field, enum ofp_version version, + const union mf_value *value, const union mf_value *mask) +{ + const struct mf_field *mf = mf_from_id(field); + bool masked; + int len, offset; + + len = mf_field_len(mf, value, mask, &masked); + offset = mf->n_bytes - len; + + nx_put_header_len(b, field, version, masked, len); + ofpbuf_put(b, &value->u8 + offset, len); + if (masked) { + ofpbuf_put(b, &mask->u8 + offset, len); + } +} /* nx_match_to_string() and helpers. */ -static void format_nxm_field_name(struct ds *, uint32_t header); +static void format_nxm_field_name(struct ds *, uint64_t header); char * nx_match_to_string(const uint8_t *p, unsigned int match_len) { - uint32_t header; - struct ds s; - if (!match_len) { return xstrdup(""); } - ds_init(&s); - while ((header = nx_entry_ok(p, match_len)) != 0) { - unsigned int length = NXM_LENGTH(header); - unsigned int value_len = nxm_field_bytes(header); - const uint8_t *value = p + 4; - const uint8_t *mask = value + value_len; - unsigned int i; + struct ofpbuf b = ofpbuf_const_initializer(p, match_len); + struct ds s = DS_EMPTY_INITIALIZER; + while (b.size) { + union mf_value value; + union mf_value mask; + enum ofperr error; + uint64_t header; + int value_len; + + error = nx_pull_entry__(&b, true, &header, NULL, &value, &mask); + if (error) { + break; + } + value_len = MIN(sizeof value, nxm_field_bytes(header)); if (s.length) { ds_put_cstr(&s, ", "); @@ -740,36 +1313,33 @@ nx_match_to_string(const uint8_t *p, unsigned int match_len) format_nxm_field_name(&s, header); ds_put_char(&s, '('); - for (i = 0; i < value_len; i++) { - ds_put_format(&s, "%02x", value[i]); + for (int i = 0; i < value_len; i++) { + ds_put_format(&s, "%02x", ((const uint8_t *) &value)[i]); } - if (NXM_HASMASK(header)) { + if (nxm_hasmask(header)) { ds_put_char(&s, '/'); - for (i = 0; i < value_len; i++) { - ds_put_format(&s, "%02x", mask[i]); + for (int i = 0; i < value_len; i++) { + ds_put_format(&s, "%02x", ((const uint8_t *) &mask)[i]); } } ds_put_char(&s, ')'); - - p += 4 + length; - match_len -= 4 + length; } - if (match_len) { + if (b.size) { if (s.length) { ds_put_cstr(&s, ", "); } - ds_put_format(&s, "<%u invalid bytes>", match_len); + ds_put_format(&s, "<%u invalid bytes>", b.size); } return ds_steal_cstr(&s); } char * -oxm_match_to_string(const uint8_t *p, unsigned int match_len) +oxm_match_to_string(const struct ofpbuf *p, unsigned int match_len) { - const struct ofp11_match_header *omh = (struct ofp11_match_header *)p; + const struct ofp11_match_header *omh = p->data; uint16_t match_len_; struct ds s; @@ -797,19 +1367,27 @@ oxm_match_to_string(const uint8_t *p, unsigned int match_len) goto err; } - return nx_match_to_string(p + sizeof *omh, match_len - sizeof *omh); + return nx_match_to_string(ofpbuf_at(p, sizeof *omh, 0), + match_len - sizeof *omh); err: return ds_steal_cstr(&s); } +void +nx_format_field_name(enum mf_field_id id, enum ofp_version version, + struct ds *s) +{ + format_nxm_field_name(s, mf_oxm_header(id, version)); +} + static void -format_nxm_field_name(struct ds *s, uint32_t header) +format_nxm_field_name(struct ds *s, uint64_t header) { - const struct mf_field *mf = mf_from_nxm_header(header); - if (mf) { - ds_put_cstr(s, IS_OXM_HEADER(header) ? mf->oxm_name : mf->nxm_name); - if (NXM_HASMASK(header)) { + const struct nxm_field *f = nxm_field_by_header(header); + if (f) { + ds_put_cstr(s, f->name); + if (nxm_hasmask(header)) { ds_put_cstr(s, "_W"); } } else if (header == NXM_NX_COOKIE) { @@ -817,59 +1395,53 @@ format_nxm_field_name(struct ds *s, uint32_t header) } else if (header == NXM_NX_COOKIE_W) { ds_put_cstr(s, "NXM_NX_COOKIE_W"); } else { - ds_put_format(s, "%d:%d", NXM_VENDOR(header), NXM_FIELD(header)); + ds_put_format(s, "%d:%d", nxm_class(header), nxm_field(header)); } } -static uint32_t +static bool +streq_len(const char *a, size_t a_len, const char *b) +{ + return strlen(b) == a_len && !memcmp(a, b, a_len); +} + +static uint64_t parse_nxm_field_name(const char *name, int name_len) { + const struct nxm_field *f; bool wild; - int i; - - /* Check whether it's a field name. */ - wild = name_len > 2 && !memcmp(&name[name_len - 2], "_W", 2); - if (wild) { - name_len -= 2; - } - - for (i = 0; i < MFF_N_IDS; i++) { - const struct mf_field *mf = mf_from_id(i); - uint32_t header; - - if (mf->nxm_name && - !strncmp(mf->nxm_name, name, name_len) && - mf->nxm_name[name_len] == '\0') { - header = mf->nxm_header; - } else if (mf->oxm_name && - !strncmp(mf->oxm_name, name, name_len) && - mf->oxm_name[name_len] == '\0') { - header = mf->oxm_header; - } else { - continue; - } + f = mf_parse_subfield_name(name, name_len, &wild); + if (f) { if (!wild) { - return header; - } else if (mf->maskable != MFM_NONE) { - return NXM_MAKE_WILD_HEADER(header); + return f->header; + } else if (mf_from_id(f->id)->maskable != MFM_NONE) { + return nxm_make_wild_header(f->header); } } - if (!strncmp("NXM_NX_COOKIE", name, name_len) && - (name_len == strlen("NXM_NX_COOKIE"))) { - if (!wild) { - return NXM_NX_COOKIE; - } else { - return NXM_NX_COOKIE_W; - } + if (streq_len(name, name_len, "NXM_NX_COOKIE")) { + return NXM_NX_COOKIE; + } else if (streq_len(name, name_len, "NXM_NX_COOKIE_W")) { + return NXM_NX_COOKIE_W; } - /* Check whether it's a 32-bit field header value as hex. + /* Check whether it's a field header value as hex. * (This isn't ordinarily useful except for testing error behavior.) */ if (name_len == 8) { - uint32_t header = hexits_value(name, name_len, NULL); - if (header != UINT_MAX) { + uint64_t header; + bool ok; + + header = hexits_value(name, name_len, &ok) << 32; + if (ok) { + return header; + } + } else if (name_len == 16) { + uint64_t header; + bool ok; + + header = hexits_value(name, name_len, &ok); + if (ok && is_experimenter_oxm(header)) { return header; } } @@ -893,7 +1465,9 @@ nx_match_from_string_raw(const char *s, struct ofpbuf *b) for (s += strspn(s, ", "); *s; s += strspn(s, ", ")) { const char *name; - uint32_t header; + uint64_t header; + ovs_be64 nw_header; + ovs_be64 *header_ptr; int name_len; size_t n; @@ -910,12 +1484,32 @@ nx_match_from_string_raw(const char *s, struct ofpbuf *b) s += name_len + 1; - nxm_put_header(b, header); + header_ptr = ofpbuf_put_uninit(b, nxm_header_len(header)); s = ofpbuf_put_hex(b, s, &n); if (n != nxm_field_bytes(header)) { - ovs_fatal(0, "%.2s: hex digits expected", s); + const struct mf_field *field = mf_from_oxm_header(header); + + if (field && field->variable_len) { + if (n <= field->n_bytes) { + int len = (nxm_hasmask(header) ? n * 2 : n) + + nxm_experimenter_len(header); + + header = NXM_HEADER(nxm_vendor(header), nxm_class(header), + nxm_field(header), + nxm_hasmask(header) ? 1 : 0, len); + } else { + ovs_fatal(0, "expected to read at most %d bytes but got " + "%"PRIuSIZE, field->n_bytes, n); + } + } else { + ovs_fatal(0, "expected to read %d bytes but got %"PRIuSIZE, + nxm_field_bytes(header), n); + } } - if (NXM_HASMASK(header)) { + nw_header = htonll(header); + memcpy(header_ptr, &nw_header, nxm_header_len(header)); + + if (nxm_hasmask(header)) { s += strspn(s, " "); if (*s != '/') { ovs_fatal(0, "%s: missing / in masked field %.*s", @@ -942,7 +1536,7 @@ int nx_match_from_string(const char *s, struct ofpbuf *b) { int match_len = nx_match_from_string_raw(s, b); - ofpbuf_put_zeros(b, ROUND_UP(match_len, 8) - match_len); + ofpbuf_put_zeros(b, PAD_SIZE(match_len, 8)); return match_len; } @@ -955,321 +1549,535 @@ oxm_match_from_string(const char *s, struct ofpbuf *b) ofpbuf_put_uninit(b, sizeof *omh); match_len = nx_match_from_string_raw(s, b) + sizeof *omh; - ofpbuf_put_zeros(b, ROUND_UP(match_len, 8) - match_len); + ofpbuf_put_zeros(b, PAD_SIZE(match_len, 8)); - omh = (struct ofp11_match_header *)((char *)b->data + start_len); + omh = ofpbuf_at(b, start_len, sizeof *omh); omh->type = htons(OFPMT_OXM); omh->length = htons(match_len); return match_len; } -void +/* Parses 's' as a "move" action, in the form described in ovs-ofctl(8), into + * '*move'. + * + * Returns NULL if successful, otherwise a malloc()'d string describing the + * error. The caller is responsible for freeing the returned string. */ +char * OVS_WARN_UNUSED_RESULT nxm_parse_reg_move(struct ofpact_reg_move *move, const char *s) { const char *full_s = s; + char *error; - s = mf_parse_subfield(&move->src, s); + error = mf_parse_subfield__(&move->src, &s); + if (error) { + return error; + } if (strncmp(s, "->", 2)) { - ovs_fatal(0, "%s: missing `->' following source", full_s); + return xasprintf("%s: missing `->' following source", full_s); } s += 2; - s = mf_parse_subfield(&move->dst, s); - if (*s != '\0') { - ovs_fatal(0, "%s: trailing garbage following destination", full_s); + error = mf_parse_subfield(&move->dst, s); + if (error) { + return error; } if (move->src.n_bits != move->dst.n_bits) { - ovs_fatal(0, "%s: source field is %d bits wide but destination is " - "%d bits wide", full_s, - move->src.n_bits, move->dst.n_bits); + return xasprintf("%s: source field is %d bits wide but destination is " + "%d bits wide", full_s, + move->src.n_bits, move->dst.n_bits); } + return NULL; } + +/* nxm_format_reg_move(). */ void -nxm_parse_reg_load(struct ofpact_reg_load *load, const char *s) +nxm_format_reg_move(const struct ofpact_reg_move *move, struct ds *s) { - const char *full_s = s; - uint64_t value = strtoull(s, (char **) &s, 0); + ds_put_format(s, "move:"); + mf_format_subfield(&move->src, s); + ds_put_cstr(s, "->"); + mf_format_subfield(&move->dst, s); +} - if (strncmp(s, "->", 2)) { - ovs_fatal(0, "%s: missing `->' following value", full_s); - } - s += 2; - s = mf_parse_subfield(&load->dst, s); - if (*s != '\0') { - ovs_fatal(0, "%s: trailing garbage following destination", full_s); - } + +enum ofperr +nxm_reg_move_check(const struct ofpact_reg_move *move, const struct flow *flow) +{ + enum ofperr error; - if (load->dst.n_bits < 64 && (value >> load->dst.n_bits) != 0) { - ovs_fatal(0, "%s: value %"PRIu64" does not fit into %d bits", - full_s, value, load->dst.n_bits); + error = mf_check_src(&move->src, flow); + if (error) { + return error; } - load->subvalue.be64[0] = htonll(0); - load->subvalue.be64[1] = htonll(value); + return mf_check_dst(&move->dst, flow); } -/* nxm_format_reg_move(), nxm_format_reg_load(). */ +/* nxm_execute_reg_move(). */ void -nxm_format_reg_move(const struct ofpact_reg_move *move, struct ds *s) +nxm_execute_reg_move(const struct ofpact_reg_move *move, + struct flow *flow, struct flow_wildcards *wc) { - ds_put_format(s, "move:"); - mf_format_subfield(&move->src, s); - ds_put_cstr(s, "->"); - mf_format_subfield(&move->dst, s); + union mf_value src_value; + union mf_value dst_value; + + mf_mask_field_and_prereqs(move->dst.field, wc); + mf_mask_field_and_prereqs(move->src.field, wc); + + /* A flow may wildcard nw_frag. Do nothing if setting a transport + * header field on a packet that does not have them. */ + if (mf_are_prereqs_ok(move->dst.field, flow) + && mf_are_prereqs_ok(move->src.field, flow)) { + + mf_get_value(move->dst.field, flow, &dst_value); + mf_get_value(move->src.field, flow, &src_value); + bitwise_copy(&src_value, move->src.field->n_bytes, move->src.ofs, + &dst_value, move->dst.field->n_bytes, move->dst.ofs, + move->src.n_bits); + mf_set_flow_value(move->dst.field, &dst_value, flow); + } } -static void -set_field_format(const struct ofpact_reg_load *load, struct ds *s) +void +nxm_reg_load(const struct mf_subfield *dst, uint64_t src_data, + struct flow *flow, struct flow_wildcards *wc) { - const struct mf_field *mf = load->dst.field; - union mf_value value; + union mf_subvalue src_subvalue; + union mf_subvalue mask_value; + ovs_be64 src_data_be = htonll(src_data); - assert(load->ofpact.compat == OFPUTIL_OFPAT12_SET_FIELD); - ds_put_format(s, "set_field:"); - memset(&value, 0, sizeof value); - bitwise_copy(&load->subvalue, sizeof load->subvalue, 0, - &value, mf->n_bytes, 0, load->dst.n_bits); - mf_format(mf, &value, NULL, s); - ds_put_format(s, "->%s", mf->name); + memset(&mask_value, 0xff, sizeof mask_value); + mf_write_subfield_flow(dst, &mask_value, &wc->masks); + + bitwise_copy(&src_data_be, sizeof src_data_be, 0, + &src_subvalue, sizeof src_subvalue, 0, + sizeof src_data_be * 8); + mf_write_subfield_flow(dst, &src_subvalue, flow); } + +/* nxm_parse_stack_action, works for both push() and pop(). */ -static void -load_format(const struct ofpact_reg_load *load, struct ds *s) +/* Parses 's' as a "push" or "pop" action, in the form described in + * ovs-ofctl(8), into '*stack_action'. + * + * Returns NULL if successful, otherwise a malloc()'d string describing the + * error. The caller is responsible for freeing the returned string. */ +char * OVS_WARN_UNUSED_RESULT +nxm_parse_stack_action(struct ofpact_stack *stack_action, const char *s) { - ds_put_cstr(s, "load:"); - mf_format_subvalue(&load->subvalue, s); - ds_put_cstr(s, "->"); - mf_format_subfield(&load->dst, s); + char *error; + + error = mf_parse_subfield__(&stack_action->subfield, &s); + if (error) { + return error; + } + + if (*s != '\0') { + return xasprintf("%s: trailing garbage following push or pop", s); + } + + return NULL; } void -nxm_format_reg_load(const struct ofpact_reg_load *load, struct ds *s) +nxm_format_stack_push(const struct ofpact_stack *push, struct ds *s) { - if (load->ofpact.compat == OFPUTIL_OFPAT12_SET_FIELD) { - set_field_format(load, s); - } else { - load_format(load, s); - } + ds_put_cstr(s, "push:"); + mf_format_subfield(&push->subfield, s); } - + +void +nxm_format_stack_pop(const struct ofpact_stack *pop, struct ds *s) +{ + ds_put_cstr(s, "pop:"); + mf_format_subfield(&pop->subfield, s); +} + enum ofperr -nxm_reg_move_from_openflow(const struct nx_action_reg_move *narm, - struct ofpbuf *ofpacts) +nxm_stack_push_check(const struct ofpact_stack *push, + const struct flow *flow) { - struct ofpact_reg_move *move; + return mf_check_src(&push->subfield, flow); +} - move = ofpact_put_REG_MOVE(ofpacts); - move->src.field = mf_from_nxm_header(ntohl(narm->src)); - move->src.ofs = ntohs(narm->src_ofs); - move->src.n_bits = ntohs(narm->n_bits); - move->dst.field = mf_from_nxm_header(ntohl(narm->dst)); - move->dst.ofs = ntohs(narm->dst_ofs); - move->dst.n_bits = ntohs(narm->n_bits); +enum ofperr +nxm_stack_pop_check(const struct ofpact_stack *pop, + const struct flow *flow) +{ + return mf_check_dst(&pop->subfield, flow); +} - return nxm_reg_move_check(move, NULL); +/* nxm_execute_stack_push(), nxm_execute_stack_pop(). */ +static void +nx_stack_push(struct ofpbuf *stack, union mf_subvalue *v) +{ + ofpbuf_put(stack, v, sizeof *v); } -enum ofperr -nxm_reg_load_from_openflow(const struct nx_action_reg_load *narl, - struct ofpbuf *ofpacts) +static union mf_subvalue * +nx_stack_pop(struct ofpbuf *stack) { - struct ofpact_reg_load *load; + union mf_subvalue *v = NULL; - load = ofpact_put_REG_LOAD(ofpacts); - load->dst.field = mf_from_nxm_header(ntohl(narl->dst)); - load->dst.ofs = nxm_decode_ofs(narl->ofs_nbits); - load->dst.n_bits = nxm_decode_n_bits(narl->ofs_nbits); - load->subvalue.be64[1] = narl->value; + if (stack->size) { - /* Reject 'narl' if a bit numbered 'n_bits' or higher is set to 1 in - * narl->value. */ - if (load->dst.n_bits < 64 && - ntohll(narl->value) >> load->dst.n_bits) { - return OFPERR_OFPBAC_BAD_ARGUMENT; + stack->size -= sizeof *v; + v = (union mf_subvalue *) ofpbuf_tail(stack); } - return nxm_reg_load_check(load, NULL); + return v; } -enum ofperr -nxm_reg_load_from_openflow12_set_field( - const struct ofp12_action_set_field * oasf, struct ofpbuf *ofpacts) +void +nxm_execute_stack_push(const struct ofpact_stack *push, + const struct flow *flow, struct flow_wildcards *wc, + struct ofpbuf *stack) { - uint16_t oasf_len = ntohs(oasf->len); - uint32_t oxm_header = ntohl(oasf->dst); - uint8_t oxm_length = NXM_LENGTH(oxm_header); - struct ofpact_reg_load *load; - const struct mf_field *mf; + union mf_subvalue mask_value; + union mf_subvalue dst_value; + + memset(&mask_value, 0xff, sizeof mask_value); + mf_write_subfield_flow(&push->subfield, &mask_value, &wc->masks); - /* ofp12_action_set_field is padded to 64 bits by zero */ - if (oasf_len != ROUND_UP(sizeof(*oasf) + oxm_length, 8)) { - return OFPERR_OFPBAC_BAD_ARGUMENT; + mf_read_subfield(&push->subfield, flow, &dst_value); + nx_stack_push(stack, &dst_value); +} + +void +nxm_execute_stack_pop(const struct ofpact_stack *pop, + struct flow *flow, struct flow_wildcards *wc, + struct ofpbuf *stack) +{ + union mf_subvalue *src_value; + + src_value = nx_stack_pop(stack); + + /* Only pop if stack is not empty. Otherwise, give warning. */ + if (src_value) { + union mf_subvalue mask_value; + + memset(&mask_value, 0xff, sizeof mask_value); + mf_write_subfield_flow(&pop->subfield, &mask_value, &wc->masks); + mf_write_subfield_flow(&pop->subfield, src_value, flow); + } else { + if (!VLOG_DROP_WARN(&rl)) { + char *flow_str = flow_to_string(flow); + VLOG_WARN_RL(&rl, "Failed to pop from an empty stack. On flow\n" + " %s", flow_str); + free(flow_str); + } } - if (!is_all_zeros((const uint8_t *)(oasf) + sizeof *oasf + oxm_length, - oasf_len - oxm_length - sizeof *oasf)) { - return OFPERR_OFPBAC_BAD_ARGUMENT; +} + +/* Formats 'sf' into 's' in a format normally acceptable to + * mf_parse_subfield(). (It won't be acceptable if sf->field is NULL or if + * sf->field has no NXM name.) */ +void +mf_format_subfield(const struct mf_subfield *sf, struct ds *s) +{ + if (!sf->field) { + ds_put_cstr(s, ""); + } else { + const struct nxm_field *f = nxm_field_by_mf_id(sf->field->id, 0); + ds_put_cstr(s, f ? f->name : sf->field->name); } - if (NXM_HASMASK(oxm_header)) { - return OFPERR_OFPBAC_BAD_ARGUMENT; + if (sf->field && sf->ofs == 0 && sf->n_bits == sf->field->n_bits) { + ds_put_cstr(s, "[]"); + } else if (sf->n_bits == 1) { + ds_put_format(s, "[%d]", sf->ofs); + } else { + ds_put_format(s, "[%d..%d]", sf->ofs, sf->ofs + sf->n_bits - 1); } - mf = mf_from_nxm_header(oxm_header); - if (!mf) { - return OFPERR_OFPBAC_BAD_ARGUMENT; +} + +static const struct nxm_field * +mf_parse_subfield_name(const char *name, int name_len, bool *wild) +{ + *wild = name_len > 2 && !memcmp(&name[name_len - 2], "_W", 2); + if (*wild) { + name_len -= 2; } - load = ofpact_put_REG_LOAD(ofpacts); - ofpact_set_field_init(load, mf, oasf + 1); - return nxm_reg_load_check(load, NULL); + return nxm_field_by_name(name, name_len); } - -enum ofperr -nxm_reg_move_check(const struct ofpact_reg_move *move, const struct flow *flow) + +/* Parses a subfield from the beginning of '*sp' into 'sf'. If successful, + * returns NULL and advances '*sp' to the first byte following the parsed + * string. On failure, returns a malloc()'d error message, does not modify + * '*sp', and does not properly initialize 'sf'. + * + * The syntax parsed from '*sp' takes the form "header[start..end]" where + * 'header' is the name of an NXM field and 'start' and 'end' are (inclusive) + * bit indexes. "..end" may be omitted to indicate a single bit. "start..end" + * may both be omitted (the [] are still required) to indicate an entire + * field. */ +char * OVS_WARN_UNUSED_RESULT +mf_parse_subfield__(struct mf_subfield *sf, const char **sp) { - enum ofperr error; + const struct mf_field *field; + const struct nxm_field *f; + const char *name; + int start, end; + const char *s; + int name_len; + bool wild; - error = mf_check_src(&move->src, flow); - if (error) { - return error; + s = *sp; + name = s; + name_len = strcspn(s, "["); + if (s[name_len] != '[') { + return xasprintf("%s: missing [ looking for field name", *sp); } - return mf_check_dst(&move->dst, NULL); + f = mf_parse_subfield_name(name, name_len, &wild); + if (!f) { + return xasprintf("%s: unknown field `%.*s'", *sp, name_len, s); + } + field = mf_from_id(f->id); + + s += name_len; + if (ovs_scan(s, "[%d..%d]", &start, &end)) { + /* Nothing to do. */ + } else if (ovs_scan(s, "[%d]", &start)) { + end = start; + } else if (!strncmp(s, "[]", 2)) { + start = 0; + end = field->n_bits - 1; + } else { + return xasprintf("%s: syntax error expecting [] or [] or " + "[..]", *sp); + } + s = strchr(s, ']') + 1; + + if (start > end) { + return xasprintf("%s: starting bit %d is after ending bit %d", + *sp, start, end); + } else if (start >= field->n_bits) { + return xasprintf("%s: starting bit %d is not valid because field is " + "only %d bits wide", *sp, start, field->n_bits); + } else if (end >= field->n_bits){ + return xasprintf("%s: ending bit %d is not valid because field is " + "only %d bits wide", *sp, end, field->n_bits); + } + + sf->field = field; + sf->ofs = start; + sf->n_bits = end - start + 1; + + *sp = s; + return NULL; } -enum ofperr -nxm_reg_load_check(const struct ofpact_reg_load *load, const struct flow *flow) +/* Parses a subfield from the entirety of 's' into 'sf'. Returns NULL if + * successful, otherwise a malloc()'d string describing the error. The caller + * is responsible for freeing the returned string. + * + * The syntax parsed from 's' takes the form "header[start..end]" where + * 'header' is the name of an NXM field and 'start' and 'end' are (inclusive) + * bit indexes. "..end" may be omitted to indicate a single bit. "start..end" + * may both be omitted (the [] are still required) to indicate an entire + * field. */ +char * OVS_WARN_UNUSED_RESULT +mf_parse_subfield(struct mf_subfield *sf, const char *s) { - return mf_check_dst(&load->dst, flow); + char *error = mf_parse_subfield__(sf, &s); + if (!error && s[0]) { + error = xstrdup("unexpected input following field syntax"); + } + return error; } -void -nxm_reg_move_to_nxast(const struct ofpact_reg_move *move, - struct ofpbuf *openflow) +/* Returns an bitmap in which each bit corresponds to the like-numbered field + * in the OFPXMC12_OPENFLOW_BASIC OXM class, in which the bit values are taken + * from the 'fields' bitmap. Only fields defined in OpenFlow 'version' are + * considered. + * + * This is useful for encoding OpenFlow 1.2 table stats messages. */ +ovs_be64 +oxm_bitmap_from_mf_bitmap(const struct mf_bitmap *fields, + enum ofp_version version) { - struct nx_action_reg_move *narm; + uint64_t oxm_bitmap = 0; + int i; + + BITMAP_FOR_EACH_1 (i, MFF_N_IDS, fields->bm) { + uint64_t oxm = mf_oxm_header(i, version); + uint32_t class = nxm_class(oxm); + int field = nxm_field(oxm); - narm = ofputil_put_NXAST_REG_MOVE(openflow); - narm->n_bits = htons(move->dst.n_bits); - narm->src_ofs = htons(move->src.ofs); - narm->dst_ofs = htons(move->dst.ofs); - narm->src = htonl(move->src.field->nxm_header); - narm->dst = htonl(move->dst.field->nxm_header); + if (class == OFPXMC12_OPENFLOW_BASIC && field < 64) { + oxm_bitmap |= UINT64_C(1) << field; + } + } + return htonll(oxm_bitmap); } -static void -reg_load_to_nxast(const struct ofpact_reg_load *load, struct ofpbuf *openflow) +/* Opposite conversion from oxm_bitmap_from_mf_bitmap(). + * + * This is useful for decoding OpenFlow 1.2 table stats messages. */ +struct mf_bitmap +oxm_bitmap_to_mf_bitmap(ovs_be64 oxm_bitmap, enum ofp_version version) { - struct nx_action_reg_load *narl; - - narl = ofputil_put_NXAST_REG_LOAD(openflow); - narl->ofs_nbits = nxm_encode_ofs_nbits(load->dst.ofs, load->dst.n_bits); - narl->dst = htonl(load->dst.field->nxm_header); - narl->value = load->subvalue.be64[1]; + struct mf_bitmap fields = MF_BITMAP_INITIALIZER; + + for (enum mf_field_id id = 0; id < MFF_N_IDS; id++) { + uint64_t oxm = mf_oxm_header(id, version); + if (oxm && version >= nxm_field_by_header(oxm)->version) { + uint32_t class = nxm_class(oxm); + int field = nxm_field(oxm); + + if (class == OFPXMC12_OPENFLOW_BASIC + && field < 64 + && oxm_bitmap & htonll(UINT64_C(1) << field)) { + bitmap_set1(fields.bm, id); + } + } + } + return fields; } -static void -set_field_to_ofast(const struct ofpact_reg_load *load, - struct ofpbuf *openflow) +/* Returns a bitmap of fields that can be encoded in OXM and that can be + * modified with a "set_field" action. */ +struct mf_bitmap +oxm_writable_fields(void) { - const struct mf_field *mf = load->dst.field; - struct ofp12_action_set_field *oasf; - uint16_t padded_value_len; + struct mf_bitmap b = MF_BITMAP_INITIALIZER; + int i; - oasf = ofputil_put_OFPAT12_SET_FIELD(openflow); - oasf->dst = htonl(mf->oxm_header); + for (i = 0; i < MFF_N_IDS; i++) { + if (mf_oxm_header(i, 0) && mf_from_id(i)->writable) { + bitmap_set1(b.bm, i); + } + } + return b; +} - /* Set field is the only action of variable length (so far), - * so handling the variable length portion is open-coded here */ - padded_value_len = ROUND_UP(mf->n_bytes, 8); - ofpbuf_put_uninit(openflow, padded_value_len); - oasf->len = htons(ntohs(oasf->len) + padded_value_len); - memset(oasf + 1, 0, padded_value_len); +/* Returns a bitmap of fields that can be encoded in OXM and that can be + * matched in a flow table. */ +struct mf_bitmap +oxm_matchable_fields(void) +{ + struct mf_bitmap b = MF_BITMAP_INITIALIZER; + int i; - bitwise_copy(&load->subvalue, sizeof load->subvalue, load->dst.ofs, - oasf + 1, mf->n_bytes, load->dst.ofs, load->dst.n_bits); - return; + for (i = 0; i < MFF_N_IDS; i++) { + if (mf_oxm_header(i, 0)) { + bitmap_set1(b.bm, i); + } + } + return b; } -void -nxm_reg_load_to_nxast(const struct ofpact_reg_load *load, - struct ofpbuf *openflow) +/* Returns a bitmap of fields that can be encoded in OXM and that can be + * matched in a flow table with an arbitrary bitmask. */ +struct mf_bitmap +oxm_maskable_fields(void) { + struct mf_bitmap b = MF_BITMAP_INITIALIZER; + int i; - if (load->ofpact.compat == OFPUTIL_OFPAT12_SET_FIELD) { - struct ofp_header *oh = (struct ofp_header *)openflow->l2; + for (i = 0; i < MFF_N_IDS; i++) { + if (mf_oxm_header(i, 0) && mf_from_id(i)->maskable == MFM_FULLY) { + bitmap_set1(b.bm, i); + } + } + return b; +} + +struct nxm_field_index { + struct hmap_node header_node; /* In nxm_header_map. */ + struct hmap_node name_node; /* In nxm_name_map. */ + struct ovs_list mf_node; /* In mf_mf_map[nf.id]. */ + const struct nxm_field nf; +}; - switch(oh->version) { - case OFP13_VERSION: - case OFP12_VERSION: - set_field_to_ofast(load, openflow); - break; +#include "nx-match.inc" - case OFP11_VERSION: - case OFP10_VERSION: - if (load->dst.n_bits < 64) { - reg_load_to_nxast(load, openflow); - } else { - /* Split into 64bit chunks */ - int chunk, ofs; - for (ofs = 0; ofs < load->dst.n_bits; ofs += chunk) { - struct ofpact_reg_load subload = *load; - - chunk = MIN(load->dst.n_bits - ofs, 64); - - subload.dst.field = load->dst.field; - subload.dst.ofs = load->dst.ofs + ofs; - subload.dst.n_bits = chunk; - bitwise_copy(&load->subvalue, sizeof load->subvalue, ofs, - &subload.subvalue, sizeof subload.subvalue, 0, - chunk); - reg_load_to_nxast(&subload, openflow); - } - } - break; +static struct hmap nxm_header_map; +static struct hmap nxm_name_map; +static struct ovs_list nxm_mf_map[MFF_N_IDS]; - default: - NOT_REACHED(); +static void +nxm_init(void) +{ + static struct ovsthread_once once = OVSTHREAD_ONCE_INITIALIZER; + if (ovsthread_once_start(&once)) { + hmap_init(&nxm_header_map); + hmap_init(&nxm_name_map); + for (int i = 0; i < MFF_N_IDS; i++) { + list_init(&nxm_mf_map[i]); } - } else { - reg_load_to_nxast(load, openflow); + for (struct nxm_field_index *nfi = all_nxm_fields; + nfi < &all_nxm_fields[ARRAY_SIZE(all_nxm_fields)]; nfi++) { + hmap_insert(&nxm_header_map, &nfi->header_node, + hash_uint64(nxm_no_len(nfi->nf.header))); + hmap_insert(&nxm_name_map, &nfi->name_node, + hash_string(nfi->nf.name, 0)); + list_push_back(&nxm_mf_map[nfi->nf.id], &nfi->mf_node); + } + ovsthread_once_done(&once); } } - -/* nxm_execute_reg_move(), nxm_execute_reg_load(). */ -void -nxm_execute_reg_move(const struct ofpact_reg_move *move, - struct flow *flow) +static const struct nxm_field * +nxm_field_by_header(uint64_t header) { - union mf_value src_value; - union mf_value dst_value; + const struct nxm_field_index *nfi; + uint64_t header_no_len; - mf_get_value(move->dst.field, flow, &dst_value); - mf_get_value(move->src.field, flow, &src_value); - bitwise_copy(&src_value, move->src.field->n_bytes, move->src.ofs, - &dst_value, move->dst.field->n_bytes, move->dst.ofs, - move->src.n_bits); - mf_set_flow_value(move->dst.field, &dst_value, flow); + nxm_init(); + if (nxm_hasmask(header)) { + header = nxm_make_exact_header(header); + } + + header_no_len = nxm_no_len(header); + + HMAP_FOR_EACH_IN_BUCKET (nfi, header_node, hash_uint64(header_no_len), + &nxm_header_map) { + if (header_no_len == nxm_no_len(nfi->nf.header)) { + if (nxm_length(header) == nxm_length(nfi->nf.header) || + mf_from_id(nfi->nf.id)->variable_len) { + return &nfi->nf; + } else { + return NULL; + } + } + } + return NULL; } -void -nxm_execute_reg_load(const struct ofpact_reg_load *load, struct flow *flow) +static const struct nxm_field * +nxm_field_by_name(const char *name, size_t len) { - mf_write_subfield_flow(&load->dst, &load->subvalue, flow); + const struct nxm_field_index *nfi; + + nxm_init(); + HMAP_FOR_EACH_WITH_HASH (nfi, name_node, hash_bytes(name, len, 0), + &nxm_name_map) { + if (strlen(nfi->nf.name) == len && !memcmp(nfi->nf.name, name, len)) { + return &nfi->nf; + } + } + return NULL; } -void -nxm_reg_load(const struct mf_subfield *dst, uint64_t src_data, - struct flow *flow) +static const struct nxm_field * +nxm_field_by_mf_id(enum mf_field_id id, enum ofp_version version) { - union mf_subvalue src_subvalue; - ovs_be64 src_data_be = htonll(src_data); + const struct nxm_field_index *nfi; + const struct nxm_field *f; - bitwise_copy(&src_data_be, sizeof src_data_be, 0, - &src_subvalue, sizeof src_subvalue, 0, - sizeof src_data_be * 8); - mf_write_subfield_flow(dst, &src_subvalue, flow); + nxm_init(); + + f = NULL; + LIST_FOR_EACH (nfi, mf_node, &nxm_mf_map[id]) { + if (!f || version >= nfi->nf.version) { + f = &nfi->nf; + } + } + return f; }