/*
- * Copyright (c) 2010, 2011 Nicira Networks.
+ * Copyright (c) 2010, 2011, 2012 Nicira Networks.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
#include "classifier.h"
#include "dynamic-string.h"
#include "meta-flow.h"
+#include "ofp-errors.h"
#include "ofp-util.h"
#include "ofpbuf.h"
#include "openflow/nicira-ext.h"
* 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);
-enum {
- NXM_INVALID = OFP_MKERR_NICIRA(OFPET_BAD_REQUEST, NXBRC_NXM_INVALID),
- NXM_BAD_TYPE = OFP_MKERR_NICIRA(OFPET_BAD_REQUEST, NXBRC_NXM_BAD_TYPE),
- NXM_BAD_VALUE = OFP_MKERR_NICIRA(OFPET_BAD_REQUEST, NXBRC_NXM_BAD_VALUE),
- NXM_BAD_MASK = OFP_MKERR_NICIRA(OFPET_BAD_REQUEST, NXBRC_NXM_BAD_MASK),
- NXM_BAD_PREREQ = OFP_MKERR_NICIRA(OFPET_BAD_REQUEST, NXBRC_NXM_BAD_PREREQ),
- NXM_DUP_TYPE = OFP_MKERR_NICIRA(OFPET_BAD_REQUEST, NXBRC_NXM_DUP_TYPE),
- BAD_ARGUMENT = OFP_MKERR(OFPET_BAD_ACTION, OFPBAC_BAD_ARGUMENT)
-};
-
/* Returns the width of the data for a field with the given 'header', in
* bytes. */
int
return header;
}
-int
-nx_pull_match(struct ofpbuf *b, unsigned int match_len, uint16_t priority,
- struct cls_rule *rule)
+static enum ofperr
+nx_pull_match__(struct ofpbuf *b, unsigned int match_len, bool strict,
+ uint16_t priority, struct cls_rule *rule,
+ ovs_be64 *cookie, ovs_be64 *cookie_mask)
{
uint32_t header;
uint8_t *p;
+ assert((cookie != NULL) == (cookie_mask != NULL));
+
p = ofpbuf_try_pull(b, ROUND_UP(match_len, 8));
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);
- return ofp_mkerr(OFPET_BAD_REQUEST, OFPBRC_BAD_LEN);
+ return OFPERR_OFPBRC_BAD_LEN;
}
cls_rule_init_catchall(rule, priority);
- while ((header = nx_entry_ok(p, match_len)) != 0) {
- unsigned length = NXM_LENGTH(header);
+ if (cookie) {
+ *cookie = *cookie_mask = htonll(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;
- int error;
+ enum ofperr error;
mf = mf_from_nxm_header(header);
if (!mf) {
- error = NXM_BAD_TYPE;
+ if (strict) {
+ error = OFPERR_NXBRC_NXM_BAD_TYPE;
+ } else {
+ continue;
+ }
} else if (!mf_are_prereqs_ok(mf, &rule->flow)) {
- error = NXM_BAD_PREREQ;
+ error = OFPERR_NXBRC_NXM_BAD_PREREQ;
} else if (!mf_is_all_wild(mf, &rule->wc)) {
- error = NXM_DUP_TYPE;
+ error = OFPERR_NXBRC_NXM_DUP_TYPE;
} else {
unsigned int width = mf->n_bytes;
union mf_value value;
memcpy(&value, p + 4, width);
if (!mf_is_value_valid(mf, &value)) {
- error = NXM_BAD_VALUE;
+ error = OFPERR_NXBRC_NXM_BAD_VALUE;
} else if (!NXM_HASMASK(header)) {
error = 0;
mf_set_value(mf, &value, rule);
memcpy(&mask, p + 4 + width, width);
if (!mf_is_mask_valid(mf, &mask)) {
- error = NXM_BAD_MASK;
+ error = OFPERR_NXBRC_NXM_BAD_MASK;
} else {
error = 0;
mf_set(mf, &value, &mask, rule);
}
}
+ /* 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_NXBRC_NXM_DUP_TYPE;
+ } 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;
+ }
+ }
+
if (error) {
- char *msg = ofputil_error_to_string(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),
- msg);
- free(msg);
-
+ ofperr_to_string(error));
return error;
}
-
- p += 4 + length;
- match_len -= 4 + length;
}
- return match_len ? NXM_INVALID : 0;
+ return match_len ? OFPERR_NXBRC_NXM_INVALID : 0;
+}
+
+/* Parses the nx_match formatted match description in 'b' with length
+ * 'match_len'. The results are stored in 'rule', which is initialized with
+ * 'priority'. If 'cookie' and 'cookie_mask' contain valid pointers, then the
+ * cookie and mask will be stored in them if a "NXM_NX_COOKIE*" match is
+ * defined. Otherwise, 0 is stored in both.
+ *
+ * Fails with an error when encountering unknown NXM headers.
+ *
+ * Returns 0 if successful, otherwise an OpenFlow error code. */
+enum ofperr
+nx_pull_match(struct ofpbuf *b, unsigned int match_len,
+ uint16_t priority, struct cls_rule *rule,
+ ovs_be64 *cookie, ovs_be64 *cookie_mask)
+{
+ return nx_pull_match__(b, match_len, true, priority, rule, cookie,
+ cookie_mask);
+}
+
+/* Behaves the same as nx_pull_match() with one exception. Skips over unknown
+ * NXM headers instead of failing with an error when they are encountered. */
+enum ofperr
+nx_pull_match_loose(struct ofpbuf *b, unsigned int match_len,
+ uint16_t priority, struct cls_rule *rule,
+ ovs_be64 *cookie, ovs_be64 *cookie_mask)
+{
+ return nx_pull_match__(b, match_len, false, priority, rule, cookie,
+ cookie_mask);
}
\f
/* nx_put_match() and helpers.
/* Appends to 'b' the nx_match format that expresses 'cr' (except for
* 'cr->priority', because priority is not part of nx_match), plus enough
- * zero bytes to pad the nx_match out to a multiple of 8.
+ * zero bytes to pad the nx_match out to a multiple of 8. For Flow Mod
+ * and Flow Stats Requests messages, a 'cookie' and 'cookie_mask' may be
+ * supplied. Otherwise, 'cookie_mask' should be zero.
*
* This function can cause 'b''s data to be reallocated.
*
* If 'cr' is a catch-all rule that matches every packet, then this function
* appends nothing to 'b' and returns 0. */
int
-nx_put_match(struct ofpbuf *b, const struct cls_rule *cr)
+nx_put_match(struct ofpbuf *b, const struct cls_rule *cr,
+ ovs_be64 cookie, ovs_be64 cookie_mask)
{
const flow_wildcards_t wc = cr->wc.wildcards;
const struct flow *flow = &cr->flow;
htonl(flow->regs[i]), htonl(cr->wc.reg_masks[i]));
}
+ /* Cookie. */
+ nxm_put_64m(b, NXM_NX_COOKIE, cookie, cookie_mask);
+
match_len = b->size - start_len;
ofpbuf_put_zeros(b, ROUND_UP(match_len, 8) - match_len);
return match_len;
if (NXM_HASMASK(header)) {
ds_put_cstr(s, "_W");
}
+ } else if (header == NXM_NX_COOKIE) {
+ ds_put_cstr(s, "NXM_NX_COOKIE");
+ } 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));
}
if (wild) {
name_len -= 2;
}
+
for (i = 0; i < MFF_N_IDS; i++) {
const struct mf_field *mf = mf_from_id(i);
}
}
+ 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;
+ }
+ }
+
/* Check whether it's a 32-bit field header value as hex.
* (This isn't ordinarily useful except for testing error behavior.) */
if (name_len == 8) {
/* Given a flow, checks that the source field represented by 'src_header'
* in the range ['ofs', 'ofs' + 'n_bits') is valid. */
-int
+enum ofperr
nxm_src_check(ovs_be32 src_header_, unsigned int ofs, unsigned int n_bits,
const struct flow *flow)
{
return 0;
}
- return BAD_ARGUMENT;
+ return OFPERR_OFPBAC_BAD_ARGUMENT;
}
/* Given a flow, checks that the destination field represented by 'dst_header'
* in the range ['ofs', 'ofs' + 'n_bits') is valid. */
-int
+enum ofperr
nxm_dst_check(ovs_be32 dst_header_, unsigned int ofs, unsigned int n_bits,
const struct flow *flow)
{
return 0;
}
- return BAD_ARGUMENT;
+ return OFPERR_OFPBAC_BAD_ARGUMENT;
}
-int
+enum ofperr
nxm_check_reg_load(const struct nx_action_reg_load *action,
const struct flow *flow)
{
unsigned int ofs = nxm_decode_ofs(action->ofs_nbits);
unsigned int n_bits = nxm_decode_n_bits(action->ofs_nbits);
- int error;
+ enum ofperr error;
error = nxm_dst_check(action->dst, ofs, n_bits, flow);
if (error) {
/* Reject 'action' if a bit numbered 'n_bits' or higher is set to 1 in
* action->value. */
if (n_bits < 64 && ntohll(action->value) >> n_bits) {
- return BAD_ARGUMENT;
+ return OFPERR_OFPBAC_BAD_ARGUMENT;
}
return 0;
git://git.onelab.eu / sliver-openvswitch.git / blobdiff