/*
- * Copyright (c) 2010, 2011, 2012, 2013, 2014 Nicira, Inc.
+ * Copyright (c) 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017 Nicira, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
#include <netinet/icmp6.h>
#include "classifier.h"
-#include "dynamic-string.h"
-#include "hmap.h"
-#include "meta-flow.h"
-#include "ofp-actions.h"
-#include "ofp-errors.h"
-#include "ofp-util.h"
-#include "ofpbuf.h"
+#include "colors.h"
+#include "openvswitch/hmap.h"
#include "openflow/nicira-ext.h"
+#include "openvswitch/dynamic-string.h"
+#include "openvswitch/meta-flow.h"
+#include "openvswitch/ofp-actions.h"
+#include "openvswitch/ofp-errors.h"
+#include "openvswitch/ofp-util.h"
+#include "openvswitch/ofpbuf.h"
+#include "openvswitch/vlog.h"
#include "packets.h"
-#include "shash.h"
+#include "openvswitch/shash.h"
+#include "tun-metadata.h"
#include "unaligned.h"
#include "util.h"
-#include "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.
OFPXMC12_EXPERIMENTER = 0xffff, /* Experimenter class */
};
-/* Functions for extracting fields from OXM/NXM headers. */
-static int nxm_vendor(uint32_t header) { return header >> 16; }
-static int nxm_field(uint32_t header) { return (header >> 9) & 0x7f; }
-static bool nxm_hasmask(uint32_t header) { return (header & 0x100) != 0; }
-static int nxm_length(uint32_t header) { return header & 0xff; }
+/* 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; }
-/* Returns true if 'header' is a legacy NXM header, false if it is an OXM
- * header.*/
static bool
-is_nxm_header(uint32_t header)
+is_experimenter_oxm(uint64_t header)
{
- return nxm_vendor(header) <= 1;
+ return nxm_class(header) == OFPXMC12_EXPERIMENTER;
}
-#define NXM_HEADER(VENDOR, FIELD, HASMASK, LENGTH) \
- (((VENDOR) << 16) | ((FIELD) << 9) | ((HASMASK) << 8) | (LENGTH))
+/* 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);
+}
-#define NXM_HEADER_FMT "%d:%d:%d:%d"
-#define NXM_HEADER_ARGS(HEADER) \
- nxm_vendor(HEADER), nxm_field(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 uint32_t
-nxm_make_exact_header(uint32_t header)
+static uint64_t
+nxm_make_exact_header(uint64_t header)
{
- return NXM_HEADER(nxm_vendor(header), nxm_field(header), 0,
- nxm_length(header) / 2);
+ 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 uint32_t
-nxm_make_wild_header(uint32_t header)
+static uint64_t
+nxm_make_wild_header(uint64_t header)
{
- return NXM_HEADER(nxm_vendor(header), nxm_field(header), 1,
- nxm_length(header) * 2);
+ 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.
* 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 (0x0001, 30, 0, 8)
+#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 {
- uint32_t header;
+ 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(uint32_t header);
+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);
-static const struct nxm_field *oxm_field_by_mf_id(enum mf_field_id);
+static const struct nxm_field *nxm_field_by_mf_id(enum mf_field_id,
+ enum ofp_version);
-static void nx_put_header__(struct ofpbuf *, uint32_t header, bool masked);
+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 const struct nxm_field *
mf_parse_subfield_name(const char *name, int name_len, bool *wild);
-static const struct nxm_field *
-nxm_field_from_mf_field(enum mf_field_id id, enum ofp_version version)
-{
- const struct nxm_field *oxm = oxm_field_by_mf_id(id);
- const struct nxm_field *nxm = nxm_field_by_mf_id(id);
- return oxm && (version >= oxm->version || !nxm) ? oxm : nxm;
-}
-
/* 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. */
-uint32_t
+static uint64_t
mf_oxm_header(enum mf_field_id id, enum ofp_version version)
{
- const struct nxm_field *f = nxm_field_from_mf_field(id, 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;
+}
+
+/* Returns the 32-bit OXM or NXM header to use for field 'mff'. If 'mff' is
+ * a mapped variable length mf_field, update the header with the configured
+ * length of 'mff'. Returns 0 if 'mff' cannot be expressed with a 32-bit NXM
+ * or OXM header.*/
+uint32_t
+nxm_header_from_mff(const struct mf_field *mff)
+{
+ uint64_t oxm = mf_oxm_header(mff->id, 0);
+
+ if (mff->mapped) {
+ oxm = nxm_no_len(oxm) | ((uint64_t) mff->n_bytes << 32);
+ }
+
+ return is_experimenter_oxm(oxm) ? 0 : oxm >> 32;
+}
+
+static const struct mf_field *
+mf_from_oxm_header(uint64_t header, const struct vl_mff_map *vl_mff_map)
+{
+ const struct nxm_field *f = nxm_field_by_header(header);
+
+ if (f) {
+ const struct mf_field *mff = mf_from_id(f->id);
+ const struct mf_field *vl_mff = mf_get_vl_mff(mff, vl_mff_map);
+ return vl_mff ? vl_mff : mff;
+ } else {
+ return 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)
+mf_from_nxm_header(uint32_t header, const struct vl_mff_map *vl_mff_map)
{
- const struct nxm_field *f = nxm_field_by_header(header);
- return f ? mf_from_id(f->id) : NULL;
+ return mf_from_oxm_header((uint64_t) header << 32, vl_mff_map);
}
/* Returns the width of the data for a field with the given 'header', in
* bytes. */
static int
-nxm_field_bytes(uint32_t header)
+nxm_field_bytes(uint64_t header)
{
- unsigned int length = nxm_length(header);
+ unsigned int length = nxm_payload_len(header);
return nxm_hasmask(header) ? length / 2 : length;
}
-
-/* Returns the earliest version of OpenFlow that standardized an OXM header for
- * field 'id', or UINT8_MAX if no version of OpenFlow does. */
-static enum ofp_version
-mf_oxm_version(enum mf_field_id id)
-{
- const struct nxm_field *oxm = oxm_field_by_mf_id(id);
- return oxm ? oxm->version : UINT8_MAX;
-}
- \f
+\f
/* nx_pull_match() and helpers. */
/* 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(uint32_t header, const uint8_t *value, const uint8_t *mask)
+is_mask_consistent(uint64_t header, const uint8_t *value, const uint8_t *mask)
{
unsigned int width = nxm_field_bytes(header);
unsigned int i;
}
static bool
-is_cookie_pseudoheader(uint32_t header)
+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, uint32_t *header,
+nx_pull_header__(struct ofpbuf *b, bool allow_cookie,
+ const struct vl_mff_map *vl_mff_map, uint64_t *header,
const struct mf_field **field)
{
- if (ofpbuf_size(b) < 4) {
- VLOG_DBG_RL(&rl, "encountered partial (%"PRIu32"-byte) OXM entry",
- ofpbuf_size(b));
- goto error;
+ 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));
}
- *header = ntohl(get_unaligned_be32(ofpbuf_pull(b, 4)));
- if (nxm_length(*header) == 0) {
- VLOG_WARN_RL(&rl, "OXM header "NXM_HEADER_FMT" has zero length",
- NXM_HEADER_ARGS(*header));
+ 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_nxm_header(*header);
+ *field = mf_from_oxm_header(*header, vl_mff_map);
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;
+ } else if (mf_vl_mff_invalid(*field, vl_mff_map)) {
+ return OFPERR_NXFMFC_INVALID_TLV_FIELD;
}
}
return 0;
+bad_len:
+ VLOG_DBG_RL(&rl, "encountered partial (%"PRIu32"-byte) OXM entry",
+ b->size);
error:
*header = 0;
- *field = NULL;
+ 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, uint32_t *header,
- const struct mf_field **field,
+nx_pull_entry__(struct ofpbuf *b, bool allow_cookie,
+ const struct vl_mff_map *vl_mff_map, 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;
const uint8_t *payload;
int width;
- header_error = nx_pull_header__(b, allow_cookie, header, field);
+ header_error = nx_pull_header__(b, allow_cookie, vl_mff_map, header,
+ &field);
if (header_error && header_error != OFPERR_OFPBMC_BAD_FIELD) {
return header_error;
}
- payload_len = nxm_length(*header);
+ 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, ofpbuf_size(b));
+ NXM_HEADER_ARGS(*header), payload_len, b->size);
return OFPERR_OFPBMC_BAD_LEN;
}
return OFPERR_OFPBMC_BAD_WILDCARDS;
}
- memcpy(value, payload, MIN(width, sizeof *value));
+ copy_entry_value(field, value, payload, width);
+
if (mask) {
if (nxm_hasmask(*header)) {
- memcpy(mask, payload + width, MIN(width, sizeof *mask));
+ copy_entry_value(field, mask, payload + width, width);
} else {
- memset(mask, 0xff, MIN(width, sizeof *mask));
+ memset(mask, 0xff, sizeof *mask);
}
} else if (nxm_hasmask(*header)) {
VLOG_DBG_RL(&rl, "OXM header "NXM_HEADER_FMT" includes mask but "
return OFPERR_OFPBMC_BAD_MASK;
}
- return header_error;
+ if (field_) {
+ *field_ = field;
+ return header_error;
+ }
+
+ return 0;
}
/* Attempts to pull an NXM or OXM header, value, and mask (if present) from the
* 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)
+nx_pull_entry(struct ofpbuf *b, const struct vl_mff_map *vl_mff_map,
+ const struct mf_field **field, union mf_value *value,
+ union mf_value *mask)
{
- uint32_t header;
+ uint64_t header;
- return nx_pull_entry__(b, false, &header, field, value, mask);
+ return nx_pull_entry__(b, false, vl_mff_map, &header, field, value, mask);
}
/* Attempts to pull an NXM or OXM header from the beginning of 'b'. If
* errors (with OFPERR_OFPBMC_BAD_MASK).
*/
enum ofperr
-nx_pull_header(struct ofpbuf *b, const struct mf_field **field, bool *masked)
+nx_pull_header(struct ofpbuf *b, const struct vl_mff_map *vl_mff_map,
+ const struct mf_field **field, bool *masked)
{
enum ofperr error;
- uint32_t header;
+ uint64_t header;
- error = nx_pull_header__(b, false, &header, field);
+ error = nx_pull_header__(b, false, vl_mff_map, &header, field);
if (masked) {
*masked = !error && nxm_hasmask(header);
} else if (!error && nxm_hasmask(header)) {
union mf_value *value, union mf_value *mask)
{
enum ofperr error;
- uint32_t header;
+ uint64_t header;
- error = nx_pull_entry__(b, allow_cookie, &header, field, value, mask);
+ error = nx_pull_entry__(b, allow_cookie, NULL, &header, field, value,
+ mask);
if (error) {
return error;
}
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)
+ struct match *match, ovs_be64 *cookie, ovs_be64 *cookie_mask,
+ const struct tun_table *tun_table)
{
- struct ofpbuf b;
-
ovs_assert((cookie != NULL) == (cookie_mask != NULL));
match_init_catchall(match);
+ match->flow.tunnel.metadata.tab = tun_table;
if (cookie) {
*cookie = *cookie_mask = htonll(0);
}
- ofpbuf_use_const(&b, p, match_len);
- while (ofpbuf_size(&b)) {
- const uint8_t *pos = ofpbuf_data(&b);
+ 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;
*cookie = value.be64;
*cookie_mask = mask.be64;
}
- } else if (!mf_are_prereqs_ok(field, &match->flow)) {
+ } else if (!mf_are_prereqs_ok(field, &match->flow, NULL)) {
error = OFPERR_OFPBMC_BAD_PREREQ;
} else if (!mf_is_all_wild(field, &match->wc)) {
error = OFPERR_OFPBMC_DUP_FIELD;
} else {
- mf_set(field, &value, &mask, match);
+ 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) {
}
}
+ match->flow.tunnel.metadata.tab = NULL;
return 0;
}
static enum ofperr
nx_pull_match__(struct ofpbuf *b, unsigned int match_len, bool strict,
struct match *match,
- ovs_be64 *cookie, ovs_be64 *cookie_mask)
+ ovs_be64 *cookie, ovs_be64 *cookie_mask,
+ const struct tun_table *tun_table)
{
uint8_t *p = NULL;
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 %"PRIu32")", match_len, ofpbuf_size(b));
+ "length %"PRIu32")", match_len, b->size);
return OFPERR_OFPBMC_BAD_LEN;
}
}
- return nx_pull_raw(p, match_len, strict, match, cookie, cookie_mask);
+ return nx_pull_raw(p, match_len, strict, match, cookie, cookie_mask,
+ tun_table);
}
/* Parses the nx_match formatted match description in 'b' with length
* Returns 0 if successful, otherwise an OpenFlow error code. */
enum ofperr
nx_pull_match(struct ofpbuf *b, unsigned int match_len, struct match *match,
- ovs_be64 *cookie, ovs_be64 *cookie_mask)
+ ovs_be64 *cookie, ovs_be64 *cookie_mask,
+ const struct tun_table *tun_table)
{
- return nx_pull_match__(b, match_len, true, match, cookie, cookie_mask);
+ return nx_pull_match__(b, match_len, true, match, cookie, cookie_mask,
+ tun_table);
}
/* Behaves the same as nx_pull_match(), but skips over unknown NXM headers,
enum ofperr
nx_pull_match_loose(struct ofpbuf *b, unsigned int match_len,
struct match *match,
- ovs_be64 *cookie, ovs_be64 *cookie_mask)
+ ovs_be64 *cookie, ovs_be64 *cookie_mask,
+ const struct tun_table *tun_table)
{
- return nx_pull_match__(b, match_len, false, match, cookie, cookie_mask);
+ return nx_pull_match__(b, match_len, false, match, cookie, cookie_mask,
+ tun_table);
}
static enum ofperr
-oxm_pull_match__(struct ofpbuf *b, bool strict, struct match *match)
+oxm_pull_match__(struct ofpbuf *b, bool strict,
+ const struct tun_table *tun_table, struct match *match)
{
- struct ofp11_match_header *omh = ofpbuf_data(b);
+ struct ofp11_match_header *omh = b->data;
uint8_t *p;
uint16_t match_len;
- if (ofpbuf_size(b) < sizeof *omh) {
+ if (b->size < sizeof *omh) {
return OFPERR_OFPBMC_BAD_LEN;
}
if (!p) {
VLOG_DBG_RL(&rl, "oxm length %u, rounded up to a "
"multiple of 8, is longer than space in message (max "
- "length %"PRIu32")", match_len, ofpbuf_size(b));
+ "length %"PRIu32")", match_len, b->size);
return OFPERR_OFPBMC_BAD_LEN;
}
return nx_pull_raw(p + sizeof *omh, match_len - sizeof *omh,
- strict, match, NULL, NULL);
+ strict, match, NULL, NULL, tun_table);
}
/* Parses the oxm formatted match description preceded by a struct
*
* Returns 0 if successful, otherwise an OpenFlow error code. */
enum ofperr
-oxm_pull_match(struct ofpbuf *b, struct match *match)
+oxm_pull_match(struct ofpbuf *b, const struct tun_table *tun_table,
+ struct match *match)
{
- return oxm_pull_match__(b, true, match);
+ return oxm_pull_match__(b, true, tun_table, match);
}
/* Behaves the same as oxm_pull_match() with one exception. Skips over unknown
* OXM headers instead of failing with an error when they are encountered. */
enum ofperr
-oxm_pull_match_loose(struct ofpbuf *b, struct match *match)
+oxm_pull_match_loose(struct ofpbuf *b, const struct tun_table *tun_table,
+ struct match *match)
+{
+ return oxm_pull_match__(b, false, tun_table, match);
+}
+
+/* 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,
+ const struct tun_table *tun_table, struct match *match)
+{
+ return nx_pull_raw(oxm, oxm_len, true, match, NULL, NULL, tun_table);
+}
+
+/* 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)
{
- return oxm_pull_match__(b, false, match);
+ 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;
+
+ error = nx_pull_entry__(&b, false, NULL, &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);
+ }
+
+ if (error) {
+ const uint8_t *start = fields_data;
+
+ VLOG_DBG_RL(&rl, "error parsing OXM at offset %"PRIdPTR" "
+ "within field array (%s)", pos - start,
+ ofperr_to_string(error));
+ return error;
+ }
+ }
+
+ return 0;
}
\f
/* nx_put_match() and helpers.
* '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_unmasked(struct ofpbuf *b, enum mf_field_id field,
- enum ofp_version version, const void *value, size_t n_bytes)
+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)
{
- nx_put_header(b, field, version, false);
+ 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
{
if (!is_all_zeros(mask, n_bytes)) {
bool masked = !is_all_ones(mask, n_bytes);
- nx_put_header(b, field, version, masked);
- ofpbuf_put(b, value, n_bytes);
- if (masked) {
- ofpbuf_put(b, mask, n_bytes);
- }
+ nxm_put__(b, field, version, value, masked ? mask : NULL, n_bytes);
}
}
nxm_put_8(struct ofpbuf *b, enum mf_field_id field, enum ofp_version version,
uint8_t value)
{
- nxm_put_unmasked(b, field, version, &value, sizeof value);
+ nxm_put__(b, field, version, &value, NULL, sizeof value);
}
static void
nxm_put_16(struct ofpbuf *b, enum mf_field_id field, enum ofp_version version,
ovs_be16 value)
{
- nxm_put_unmasked(b, field, version, &value, sizeof value);
+ nxm_put__(b, field, version, &value, NULL, sizeof value);
}
static void
nxm_put_32(struct ofpbuf *b, enum mf_field_id field, enum ofp_version version,
ovs_be32 value)
{
- nxm_put_unmasked(b, field, version, &value, sizeof value);
+ nxm_put__(b, field, version, &value, NULL, sizeof value);
}
static void
nxm_put(b, field, version, &value, &mask, sizeof value);
}
+static void
+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(b, field, version, &value, &mask, sizeof(value));
+}
+
static void
nxm_put_eth_masked(struct ofpbuf *b,
enum mf_field_id field, enum ofp_version version,
- const uint8_t value[ETH_ADDR_LEN],
- const uint8_t mask[ETH_ADDR_LEN])
+ const struct eth_addr value, const struct eth_addr mask)
{
- nxm_put(b, field, version, value, mask, ETH_ADDR_LEN);
+ nxm_put(b, field, version, value.ea, mask.ea, ETH_ADDR_LEN);
}
static void
flow->nw_tos & IP_ECN_MASK);
}
- if (!oxm && match->wc.masks.nw_ttl) {
+ if (match->wc.masks.nw_ttl) {
nxm_put_8(b, MFF_IP_TTL, oxm, flow->nw_ttl);
}
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)) {
+ } else if (is_icmpv4(flow, NULL)) {
if (match->wc.masks.tp_src) {
nxm_put_8(b, MFF_ICMPV4_TYPE, oxm,
ntohs(flow->tp_src));
nxm_put_8(b, MFF_ICMPV4_CODE, oxm,
ntohs(flow->tp_dst));
}
- } else if (is_icmpv6(flow)) {
+ } else if (is_icmpv6(flow, NULL)) {
if (match->wc.masks.tp_src) {
nxm_put_8(b, MFF_ICMPV6_TYPE, oxm,
ntohs(flow->tp_src));
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)) {
+ if (is_nd(flow, NULL)) {
nxm_put_ipv6(b, MFF_ND_TARGET, oxm,
&flow->nd_target, &match->wc.masks.nd_target);
if (flow->tp_src == htons(ND_NEIGHBOR_SOLICIT)) {
ovs_be64 cookie, ovs_be64 cookie_mask)
{
const struct flow *flow = &match->flow;
- const size_t start_len = ofpbuf_size(b);
+ const size_t start_len = b->size;
int match_len;
int i;
- BUILD_ASSERT_DECL(FLOW_WC_SEQ == 27);
+ BUILD_ASSERT_DECL(FLOW_WC_SEQ == 36);
/* Metadata. */
if (match->wc.masks.dp_hash) {
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) {
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, MFF_ETH_SRC, 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. */
if (oxm < OFP15_VERSION) {
}
}
- /* Mark. */
+ /* 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, MFF_METADATA, oxm,
flow->metadata, match->wc.masks.metadata);
}
}
- match_len = ofpbuf_size(b) - start_len;
+ match_len = b->size - start_len;
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
+ * 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
{
int match_len;
struct ofp11_match_header *omh;
- size_t start_len = ofpbuf_size(b);
+ size_t start_len = b->size;
ovs_be64 cookie = htonll(0), cookie_mask = htonll(0);
ofpbuf_put_uninit(b, sizeof *omh);
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;
+ size_t i, offset = 0;
+
+ BITMAP_FOR_EACH_1 (i, MFF_N_IDS, fa->used.bm) {
+ const struct mf_field *mf = mf_from_id(i);
+ union mf_value value;
+
+ memcpy(&value, fa->values + offset, mf->n_bytes);
+ nx_format_mask_tlv(ds, i, &value);
+ offset += mf->n_bytes;
+ }
+
+ 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;
+
+ /* 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);
+
+ size_t i, offset = 0;
+
+ BITMAP_FOR_EACH_1 (i, MFF_N_IDS, fa->used.bm) {
+ const struct mf_field *mf = mf_from_id(i);
+ union mf_value value;
+
+ memcpy(&value, fa->values + offset, mf->n_bytes);
+
+ int len = mf_field_len(mf, &value, NULL, NULL);
+ nxm_put__(b, i, version, &value + mf->n_bytes - len, NULL, len);
+ offset += mf->n_bytes;
+ }
+
+ return b->size - start_len;
+}
+
static void
-nx_put_header__(struct ofpbuf *b, uint32_t header, bool masked)
+nx_put_header__(struct ofpbuf *b, uint64_t header, bool masked)
{
- uint32_t masked_header = masked ? nxm_make_wild_header(header) : header;
- ovs_be32 network_header = htonl(masked_header);
+ uint64_t masked_header = masked ? nxm_make_wild_header(header) : header;
+ ovs_be64 network_header = htonll(masked_header);
- ofpbuf_put(b, &network_header, sizeof network_header);
+ ofpbuf_put(b, &network_header, nxm_header_len(header));
}
void
nx_put_header__(b, mf_oxm_header(field, version), masked);
}
+void nx_put_mff_header(struct ofpbuf *b, const struct mf_field *mff,
+ enum ofp_version version, bool masked)
+{
+ if (mff->mapped) {
+ nx_put_header_len(b, mff->id, version, masked, mff->n_bytes);
+ } else {
+ nx_put_header(b, mff->id, 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)
+nx_put_entry(struct ofpbuf *b, const struct mf_field *mff,
+ enum ofp_version version, const union mf_value *value,
+ const union mf_value *mask)
{
- int n_bytes = mf_from_id(field)->n_bytes;
- bool masked = mask && !is_all_ones(mask, n_bytes);
+ bool masked;
+ int len, offset;
- nx_put_header(b, field, version, masked);
- ofpbuf_put(b, value, n_bytes);
+ len = mf_field_len(mff, value, mask, &masked);
+ offset = mff->n_bytes - len;
+
+ nx_put_header_len(b, mff->id, version, masked, len);
+ ofpbuf_put(b, &value->u8 + offset, len);
if (masked) {
- ofpbuf_put(b, mask, n_bytes);
+ ofpbuf_put(b, &mask->u8 + offset, len);
}
}
\f
/* 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)
{
- struct ofpbuf b;
- struct ds s;
-
if (!match_len) {
return xstrdup("<any>");
}
- ofpbuf_use_const(&b, p, match_len);
- ds_init(&s);
- while (ofpbuf_size(&b)) {
+ 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;
- uint32_t header;
+ uint64_t header;
int value_len;
- error = nx_pull_entry__(&b, true, &header, NULL, &value, &mask);
+ error = nx_pull_entry__(&b, true, NULL, &header, NULL, &value, &mask);
if (error) {
break;
}
ds_put_char(&s, ')');
}
- if (ofpbuf_size(&b)) {
+ if (b.size) {
if (s.length) {
ds_put_cstr(&s, ", ");
}
- ds_put_format(&s, "<%u invalid bytes>", ofpbuf_size(&b));
+ ds_put_format(&s, "<%u invalid bytes>", b.size);
}
return ds_steal_cstr(&s);
char *
oxm_match_to_string(const struct ofpbuf *p, unsigned int match_len)
{
- const struct ofp11_match_header *omh = ofpbuf_data(p);
+ const struct ofp11_match_header *omh = p->data;
uint16_t match_len_;
struct ds s;
}
static void
-format_nxm_field_name(struct ds *s, uint32_t header)
+format_nxm_field_name(struct ds *s, uint64_t header)
{
const struct nxm_field *f = nxm_field_by_header(header);
if (f) {
} 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));
}
}
return strlen(b) == a_len && !memcmp(a, b, a_len);
}
-static uint32_t
+static uint64_t
parse_nxm_field_name(const char *name, int name_len)
{
const struct nxm_field *f;
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;
}
}
nx_match_from_string_raw(const char *s, struct ofpbuf *b)
{
const char *full_s = s;
- const size_t start_len = ofpbuf_size(b);
+ const size_t start_len = b->size;
if (!strcmp(s, "<any>")) {
- /* Ensure that 'ofpbuf_data(b)' isn't actually null. */
+ /* Ensure that 'b->data' isn't actually null. */
ofpbuf_prealloc_tailroom(b, 1);
return 0;
}
for (s += strspn(s, ", "); *s; s += strspn(s, ", ")) {
const char *name;
- uint32_t header;
+ uint64_t header;
+ ovs_be64 nw_header;
int name_len;
size_t n;
s += name_len + 1;
- nx_put_header__(b, header, false);
+ b->header = 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, NULL);
+
+ 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);
+ }
}
+ nw_header = htonll(header);
+ memcpy(b->header, &nw_header, nxm_header_len(header));
+
if (nxm_hasmask(header)) {
s += strspn(s, " ");
if (*s != '/') {
s++;
}
- return ofpbuf_size(b) - start_len;
+ return b->size - start_len;
}
int
{
int match_len;
struct ofp11_match_header *omh;
- size_t start_len = ofpbuf_size(b);
+ size_t start_len = b->size;
ofpbuf_put_uninit(b, sizeof *omh);
match_len = nx_match_from_string_raw(s, b) + sizeof *omh;
*
* Returns NULL if successful, otherwise a malloc()'d string describing the
* error. The caller is responsible for freeing the returned string. */
-char * WARN_UNUSED_RESULT
+char * OVS_WARN_UNUSED_RESULT
nxm_parse_reg_move(struct ofpact_reg_move *move, const char *s)
{
const char *full_s = s;
void
nxm_format_reg_move(const struct ofpact_reg_move *move, struct ds *s)
{
- ds_put_format(s, "move:");
+ ds_put_format(s, "%smove:%s", colors.special, colors.end);
mf_format_subfield(&move->src, s);
- ds_put_cstr(s, "->");
+ ds_put_format(s, "%s->%s", colors.special, colors.end);
mf_format_subfield(&move->dst, s);
}
return error;
}
- return mf_check_dst(&move->dst, NULL);
+ return mf_check_dst(&move->dst, flow);
}
\f
/* nxm_execute_reg_move(). */
-void
-nxm_execute_reg_move(const struct ofpact_reg_move *move,
- struct flow *flow, struct flow_wildcards *wc)
-{
- union mf_value src_value;
- union mf_value dst_value;
-
- mf_mask_field_and_prereqs(move->dst.field, &wc->masks);
- mf_mask_field_and_prereqs(move->src.field, &wc->masks);
-
- 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);
-}
-
void
nxm_reg_load(const struct mf_subfield *dst, uint64_t src_data,
struct flow *flow, struct flow_wildcards *wc)
*
* Returns NULL if successful, otherwise a malloc()'d string describing the
* error. The caller is responsible for freeing the returned string. */
-char * WARN_UNUSED_RESULT
+char * OVS_WARN_UNUSED_RESULT
nxm_parse_stack_action(struct ofpact_stack *stack_action, const char *s)
{
char *error;
void
nxm_format_stack_push(const struct ofpact_stack *push, struct ds *s)
{
- ds_put_cstr(s, "push:");
+ ds_put_format(s, "%spush:%s", colors.param, colors.end);
mf_format_subfield(&push->subfield, s);
}
void
nxm_format_stack_pop(const struct ofpact_stack *pop, struct ds *s)
{
- ds_put_cstr(s, "pop:");
+ ds_put_format(s, "%spop:%s", colors.param, colors.end);
mf_format_subfield(&pop->subfield, s);
}
return mf_check_dst(&pop->subfield, flow);
}
-/* nxm_execute_stack_push(), nxm_execute_stack_pop(). */
-static void
-nx_stack_push(struct ofpbuf *stack, union mf_subvalue *v)
+/* nxm_execute_stack_push(), nxm_execute_stack_pop().
+ *
+ * A stack is an ofpbuf with 'data' pointing to the bottom of the stack and
+ * 'size' indexing the top of the stack. Each value of some byte length is
+ * stored to the stack immediately followed by the length of the value as an
+ * unsigned byte. This way a POP operation can first read the length byte, and
+ * then the appropriate number of bytes from the stack. This also means that
+ * it is only possible to traverse the stack from top to bottom. It is
+ * possible, however, to push values also to the bottom of the stack, which is
+ * useful when a stack has been serialized to a wire format in reverse order
+ * (topmost value first).
+ */
+
+/* Push value 'v' of length 'bytes' to the top of 'stack'. */
+void
+nx_stack_push(struct ofpbuf *stack, const void *v, uint8_t bytes)
{
- ofpbuf_put(stack, v, sizeof *v);
+ ofpbuf_put(stack, v, bytes);
+ ofpbuf_put(stack, &bytes, sizeof bytes);
}
-static union mf_subvalue *
-nx_stack_pop(struct ofpbuf *stack)
+/* Push value 'v' of length 'bytes' to the bottom of 'stack'. */
+void
+nx_stack_push_bottom(struct ofpbuf *stack, const void *v, uint8_t bytes)
{
- union mf_subvalue *v = NULL;
-
- if (ofpbuf_size(stack)) {
+ ofpbuf_push(stack, &bytes, sizeof bytes);
+ ofpbuf_push(stack, v, bytes);
+}
- ofpbuf_set_size(stack, ofpbuf_size(stack) - sizeof *v);
- v = (union mf_subvalue *) ofpbuf_tail(stack);
+/* Pop the topmost value from 'stack', returning a pointer to the value in the
+ * stack and the length of the value in '*bytes'. In case of underflow a NULL
+ * is returned and length is returned as zero via '*bytes'. */
+void *
+nx_stack_pop(struct ofpbuf *stack, uint8_t *bytes)
+{
+ if (!stack->size) {
+ *bytes = 0;
+ return NULL;
}
- return v;
+ stack->size -= sizeof *bytes;
+ memcpy(bytes, ofpbuf_tail(stack), sizeof *bytes);
+
+ ovs_assert(stack->size >= *bytes);
+ stack->size -= *bytes;
+ return ofpbuf_tail(stack);
}
void
const struct flow *flow, struct flow_wildcards *wc,
struct ofpbuf *stack)
{
- 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);
+ mf_write_subfield_flow(&push->subfield,
+ (union mf_subvalue *)&exact_match_mask,
+ &wc->masks);
mf_read_subfield(&push->subfield, flow, &dst_value);
- nx_stack_push(stack, &dst_value);
+ uint8_t bytes = DIV_ROUND_UP(push->subfield.n_bits, 8);
+ nx_stack_push(stack, &dst_value.u8[sizeof dst_value - bytes], bytes);
}
-void
+bool
nxm_execute_stack_pop(const struct ofpact_stack *pop,
struct flow *flow, struct flow_wildcards *wc,
struct ofpbuf *stack)
{
- union mf_subvalue *src_value;
+ uint8_t src_bytes;
+ const void *src = nx_stack_pop(stack, &src_bytes);
+ if (src) {
+ union mf_subvalue src_value;
+ uint8_t dst_bytes = DIV_ROUND_UP(pop->subfield.n_bits, 8);
- 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 (src_bytes < dst_bytes) {
+ memset(&src_value.u8[sizeof src_value - dst_bytes], 0,
+ dst_bytes - src_bytes);
}
+ memcpy(&src_value.u8[sizeof src_value - src_bytes], src, src_bytes);
+ mf_write_subfield_flow(&pop->subfield,
+ (union mf_subvalue *)&exact_match_mask,
+ &wc->masks);
+ mf_write_subfield_flow(&pop->subfield, &src_value, flow);
+ return true;
+ } else {
+ /* Attempted to pop from an empty stack. */
+ return false;
}
}
\f
if (!sf->field) {
ds_put_cstr(s, "<unknown>");
} else {
- const struct nxm_field *f = nxm_field_from_mf_field(sf->field->id, 0);
+ const struct nxm_field *f = nxm_field_by_mf_id(sf->field->id, 0);
ds_put_cstr(s, f ? f->name : sf->field->name);
}
* 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 * WARN_UNUSED_RESULT
+char * OVS_WARN_UNUSED_RESULT
mf_parse_subfield__(struct mf_subfield *sf, const char **sp)
{
- const struct mf_field *field;
+ const struct mf_field *field = NULL;
const struct nxm_field *f;
const char *name;
int start, end;
s = *sp;
name = s;
- name_len = strcspn(s, "[");
- if (s[name_len] != '[') {
- return xasprintf("%s: missing [ looking for field name", *sp);
- }
+ name_len = strcspn(s, "[-");
f = mf_parse_subfield_name(name, name_len, &wild);
- if (!f) {
+ field = f ? mf_from_id(f->id) : mf_from_name_len(name, name_len);
+ if (!field) {
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 [<bit>] or "
- "[<start>..<end>]", *sp);
+ /* Assume full field. */
+ start = 0;
+ end = field->n_bits - 1;
+ if (*s == '[') {
+ if (!strncmp(s, "[]", 2)) {
+ /* Nothing to do. */
+ } else if (ovs_scan(s, "[%d..%d]", &start, &end)) {
+ /* Nothing to do. */
+ } else if (ovs_scan(s, "[%d]", &start)) {
+ end = start;
+ } else {
+ return xasprintf("%s: syntax error expecting [] or [<bit>] or "
+ "[<start>..<end>]", *sp);
+ }
+ s = strchr(s, ']') + 1;
}
- s = strchr(s, ']') + 1;
if (start > end) {
return xasprintf("%s: starting bit %d is after ending bit %d",
* 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 * WARN_UNUSED_RESULT
+char * OVS_WARN_UNUSED_RESULT
mf_parse_subfield(struct mf_subfield *sf, const char *s)
{
char *error = mf_parse_subfield__(sf, &s);
int i;
BITMAP_FOR_EACH_1 (i, MFF_N_IDS, fields->bm) {
- uint32_t oxm = mf_oxm_header(i, version);
- uint32_t vendor = nxm_vendor(oxm);
+ uint64_t oxm = mf_oxm_header(i, version);
+ uint32_t class = nxm_class(oxm);
int field = nxm_field(oxm);
- if (vendor == OFPXMC12_OPENFLOW_BASIC && field < 64) {
+ if (class == OFPXMC12_OPENFLOW_BASIC && field < 64) {
oxm_bitmap |= UINT64_C(1) << field;
}
}
struct mf_bitmap fields = MF_BITMAP_INITIALIZER;
for (enum mf_field_id id = 0; id < MFF_N_IDS; id++) {
- if (version >= mf_oxm_version(id)) {
- uint32_t oxm = mf_oxm_header(id, version);
- uint32_t vendor = nxm_vendor(oxm);
+ 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 (vendor == OFPXMC12_OPENFLOW_BASIC
+ if (class == OFPXMC12_OPENFLOW_BASIC
&& field < 64
&& oxm_bitmap & htonll(UINT64_C(1) << field)) {
bitmap_set1(fields.bm, id);
}
\f
struct nxm_field_index {
- struct hmap_node header_node;
- struct hmap_node name_node;
- struct nxm_field nf;
+ 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;
};
#include "nx-match.inc"
static struct hmap nxm_header_map;
static struct hmap nxm_name_map;
-static struct nxm_field *nxm_fields[MFF_N_IDS];
-static struct nxm_field *oxm_fields[MFF_N_IDS];
+static struct ovs_list nxm_mf_map[MFF_N_IDS];
static void
nxm_init(void)
if (ovsthread_once_start(&once)) {
hmap_init(&nxm_header_map);
hmap_init(&nxm_name_map);
+ for (int i = 0; i < MFF_N_IDS; i++) {
+ ovs_list_init(&nxm_mf_map[i]);
+ }
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_int(nfi->nf.header, 0));
+ hash_uint64(nxm_no_len(nfi->nf.header)));
hmap_insert(&nxm_name_map, &nfi->name_node,
hash_string(nfi->nf.name, 0));
- if (is_nxm_header(nfi->nf.header)) {
- nxm_fields[nfi->nf.id] = &nfi->nf;
- } else {
- oxm_fields[nfi->nf.id] = &nfi->nf;
- }
+ ovs_list_push_back(&nxm_mf_map[nfi->nf.id], &nfi->mf_node);
}
ovsthread_once_done(&once);
}
}
static const struct nxm_field *
-nxm_field_by_header(uint32_t header)
+nxm_field_by_header(uint64_t header)
{
const struct nxm_field_index *nfi;
+ uint64_t header_no_len;
nxm_init();
if (nxm_hasmask(header)) {
header = nxm_make_exact_header(header);
}
- HMAP_FOR_EACH_IN_BUCKET (nfi, header_node, hash_int(header, 0),
+ 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 == nfi->nf.header) {
- return &nfi->nf;
+ 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;
}
static const struct nxm_field *
-nxm_field_by_mf_id(enum mf_field_id id)
+nxm_field_by_mf_id(enum mf_field_id id, enum ofp_version version)
{
- nxm_init();
- return nxm_fields[id];
-}
+ const struct nxm_field_index *nfi;
+ const struct nxm_field *f;
-static const struct nxm_field *
-oxm_field_by_mf_id(enum mf_field_id id)
-{
nxm_init();
- return oxm_fields[id];
-}
+ f = NULL;
+ LIST_FOR_EACH (nfi, mf_node, &nxm_mf_map[id]) {
+ if (!f || version >= nfi->nf.version) {
+ f = &nfi->nf;
+ }
+ }
+ return f;
+}
projects / mirror_ovs.git / blobdiff