return !wc->masks.tunnel.gbp_id;
case MFF_TUN_GBP_FLAGS:
return !wc->masks.tunnel.gbp_flags;
- CASE_MFF_TUN_METADATA: {
- union mf_value value;
-
- tun_metadata_read(&wc->masks.tunnel, mf, &value);
- return is_all_zeros(&value.tun_metadata, mf->n_bytes);
- }
+ CASE_MFF_TUN_METADATA:
+ return !ULLONG_GET(wc->masks.tunnel.metadata.present.map,
+ mf->id - MFF_TUN_METADATA0);
case MFF_METADATA:
return !wc->masks.metadata;
case MFF_IN_PORT:
return !wc->masks.skb_priority;
case MFF_PKT_MARK:
return !wc->masks.pkt_mark;
+ case MFF_CT_STATE:
+ return !wc->masks.ct_state;
+ case MFF_CT_ZONE:
+ return !wc->masks.ct_zone;
+ case MFF_CT_MARK:
+ return !wc->masks.ct_mark;
CASE_MFF_REGS:
return !wc->masks.regs[mf->id - MFF_REG0];
CASE_MFF_XREGS:
case MFF_IN_PORT:
case MFF_SKB_PRIORITY:
case MFF_PKT_MARK:
+ case MFF_CT_ZONE:
+ case MFF_CT_MARK:
CASE_MFF_REGS:
CASE_MFF_XREGS:
case MFF_ETH_SRC:
case MFF_TUN_FLAGS:
return !(value->be16 & ~htons(FLOW_TNL_PUB_F_MASK));
+ case MFF_CT_STATE:
+ return !(value->be32 & ~htonl(CS_SUPPORTED_MASK));
+
case MFF_N_IDS:
default:
OVS_NOT_REACHED();
value->be32 = htonl(flow->pkt_mark);
break;
+ case MFF_CT_STATE:
+ value->be32 = htonl(flow->ct_state);
+ break;
+
+ case MFF_CT_ZONE:
+ value->be16 = htons(flow->ct_zone);
+ break;
+
+ case MFF_CT_MARK:
+ value->be32 = htonl(flow->ct_mark);
+ break;
+
CASE_MFF_REGS:
value->be32 = htonl(flow->regs[mf->id - MFF_REG0]);
break;
/* Makes 'match' match field 'mf' exactly, with the value matched taken from
* 'value'. The caller is responsible for ensuring that 'match' meets 'mf''s
- * prerequisites. */
+ * prerequisites.
+ *
+ * If non-NULL, 'err_str' returns a malloc'ed string describing any errors
+ * with the request or NULL if there is no error. The caller is reponsible
+ * for freeing the string. */
void
mf_set_value(const struct mf_field *mf,
- const union mf_value *value, struct match *match)
+ const union mf_value *value, struct match *match, char **err_str)
{
+ if (err_str) {
+ *err_str = NULL;
+ }
+
switch (mf->id) {
case MFF_DP_HASH:
match_set_dp_hash(match, ntohl(value->be32));
match_set_tun_ttl(match, value->u8);
break;
CASE_MFF_TUN_METADATA:
- tun_metadata_set_match(mf, value, NULL, match);
+ tun_metadata_set_match(mf, value, NULL, match, err_str);
break;
case MFF_METADATA:
match_set_pkt_mark(match, ntohl(value->be32));
break;
+ case MFF_CT_STATE:
+ match_set_ct_state(match, ntohl(value->be32));
+ break;
+
+ case MFF_CT_ZONE:
+ match_set_ct_zone(match, ntohs(value->be16));
+ break;
+
+ case MFF_CT_MARK:
+ match_set_ct_mark(match, ntohl(value->be32));
+ break;
+
CASE_MFF_REGS:
match_set_reg(match, mf->id - MFF_REG0, ntohl(value->be32));
break;
/* Returns the effective length of the field. For fixed length fields,
* this is just the defined length. For variable length fields, it is
* the minimum size encoding that retains the same meaning (i.e.
- * discarding leading zeros). */
+ * discarding leading zeros).
+ *
+ * 'is_masked' returns (if non-NULL) whether the original contained
+ * a mask. Otherwise, a mask that is the same length as the value
+ * might be misinterpreted as an exact match. */
int
mf_field_len(const struct mf_field *mf, const union mf_value *value,
- const union mf_value *mask)
+ const union mf_value *mask, bool *is_masked_)
{
int len, mask_len;
+ bool is_masked = mask && !is_all_ones(mask, mf->n_bytes);
len = field_len(mf, value);
- if (mask && !is_all_ones(mask, mf->n_bytes)) {
+ if (is_masked) {
mask_len = field_len(mf, mask);
len = MAX(len, mask_len);
}
+ if (is_masked_) {
+ *is_masked_ = is_masked;
+ }
+
return len;
}
flow->pkt_mark = ntohl(value->be32);
break;
+ case MFF_CT_STATE:
+ flow->ct_state = ntohl(value->be32);
+ break;
+
+ case MFF_CT_ZONE:
+ flow->ct_zone = ntohs(value->be16);
+ break;
+
+ case MFF_CT_MARK:
+ flow->ct_mark = ntohl(value->be32);
+ break;
+
CASE_MFF_REGS:
flow->regs[mf->id - MFF_REG0] = ntohl(value->be32);
break;
mf_set_flow_value(field, &tmp, flow);
}
-/* Returns true if 'mf' has a zero value in 'flow', false if it is nonzero.
+bool
+mf_is_tun_metadata(const struct mf_field *mf)
+{
+ return mf->id >= MFF_TUN_METADATA0 &&
+ mf->id < MFF_TUN_METADATA0 + TUN_METADATA_NUM_OPTS;
+}
+
+/* Returns true if 'mf' has previously been set in 'flow', false if
+ * it contains a non-default value.
*
* The caller is responsible for ensuring that 'flow' meets 'mf''s
* prerequisites. */
bool
-mf_is_zero(const struct mf_field *mf, const struct flow *flow)
+mf_is_set(const struct mf_field *mf, const struct flow *flow)
{
- union mf_value value;
+ if (!mf_is_tun_metadata(mf)) {
+ union mf_value value;
- mf_get_value(mf, flow, &value);
- return is_all_zeros(&value, mf->n_bytes);
+ mf_get_value(mf, flow, &value);
+ return !is_all_zeros(&value, mf->n_bytes);
+ } else {
+ return ULLONG_GET(flow->tunnel.metadata.present.map,
+ mf->id - MFF_TUN_METADATA0);
+ }
}
/* Makes 'match' wildcard field 'mf'.
*
* The caller is responsible for ensuring that 'match' meets 'mf''s
- * prerequisites. */
+ * prerequisites.
+ *
+ * If non-NULL, 'err_str' returns a malloc'ed string describing any errors
+ * with the request or NULL if there is no error. The caller is reponsible
+ * for freeing the string. */
void
-mf_set_wild(const struct mf_field *mf, struct match *match)
+mf_set_wild(const struct mf_field *mf, struct match *match, char **err_str)
{
+ if (err_str) {
+ *err_str = NULL;
+ }
+
switch (mf->id) {
case MFF_DP_HASH:
match->flow.dp_hash = 0;
match_set_tun_ttl_masked(match, 0, 0);
break;
CASE_MFF_TUN_METADATA:
- tun_metadata_set_match(mf, NULL, NULL, match);
+ tun_metadata_set_match(mf, NULL, NULL, match, err_str);
break;
case MFF_METADATA:
match->wc.masks.pkt_mark = 0;
break;
+ case MFF_CT_STATE:
+ match->flow.ct_state = 0;
+ match->wc.masks.ct_state = 0;
+ break;
+
+ case MFF_CT_ZONE:
+ match->flow.ct_zone = 0;
+ match->wc.masks.ct_zone = 0;
+ break;
+
+ case MFF_CT_MARK:
+ match->flow.ct_mark = 0;
+ match->wc.masks.ct_mark = 0;
+ break;
+
CASE_MFF_REGS:
match_set_reg_masked(match, mf->id - MFF_REG0, 0, 0);
break;
* call is equivalent to mf_set_wild(mf, match).
*
* 'mask' must be a valid mask for 'mf' (see mf_is_mask_valid()). The caller
- * is responsible for ensuring that 'match' meets 'mf''s prerequisites. */
-enum ofputil_protocol
+ * is responsible for ensuring that 'match' meets 'mf''s prerequisites.
+ *
+ * If non-NULL, 'err_str' returns a malloc'ed string describing any errors
+ * with the request or NULL if there is no error. The caller is reponsible
+ * for freeing the string.
+ *
+ * Return a set of enum ofputil_protocol bits (as an uint32_t to avoid circular
+ * dependency on enum ofputil_protocol definition) indicating which OpenFlow
+ * protocol versions can support this functionality. */
+uint32_t
mf_set(const struct mf_field *mf,
const union mf_value *value, const union mf_value *mask,
- struct match *match)
+ struct match *match, char **err_str)
{
if (!mask || is_all_ones(mask, mf->n_bytes)) {
- mf_set_value(mf, value, match);
+ mf_set_value(mf, value, match, err_str);
return mf->usable_protocols_exact;
- } else if (is_all_zeros(mask, mf->n_bytes)) {
- mf_set_wild(mf, match);
+ } else if (is_all_zeros(mask, mf->n_bytes) && !mf_is_tun_metadata(mf)) {
+ /* Tunnel metadata matches on the existence of the field itself, so
+ * it still needs to be encoded even if the value is wildcarded. */
+ mf_set_wild(mf, match, err_str);
return OFPUTIL_P_ANY;
}
+ if (err_str) {
+ *err_str = NULL;
+ }
+
switch (mf->id) {
+ case MFF_CT_ZONE:
case MFF_RECIRC_ID:
case MFF_CONJ_ID:
case MFF_IN_PORT:
match_set_tun_tos_masked(match, value->u8, mask->u8);
break;
CASE_MFF_TUN_METADATA:
- tun_metadata_set_match(mf, value, mask, match);
+ tun_metadata_set_match(mf, value, mask, match, err_str);
break;
case MFF_METADATA:
ntohl(mask->be32));
break;
+ case MFF_CT_STATE:
+ match_set_ct_state_masked(match, ntohl(value->be32), ntohl(mask->be32));
+ break;
+
+ case MFF_CT_MARK:
+ match_set_ct_mark_masked(match, ntohl(value->be32), ntohl(mask->be32));
+ break;
+
case MFF_ETH_DST:
match_set_dl_dst_masked(match, value->mac, mask->mac);
break;
case MFF_IPV6_LABEL:
if ((mask->be32 & htonl(IPV6_LABEL_MASK)) == htonl(IPV6_LABEL_MASK)) {
- mf_set_value(mf, value, match);
+ mf_set_value(mf, value, match, err_str);
} else {
match_set_ipv6_label_masked(match, value->be32, mask->be32);
}
htons(FLOW_TNL_PUB_F_MASK), maskp);
}
+static char *
+mf_from_ct_state_string(const char *s, ovs_be32 *flagsp, ovs_be32 *maskp)
+{
+ int err;
+ char *err_str;
+ uint32_t flags, mask;
+
+ err = parse_flags(s, ct_state_to_string, '\0', "ct_state", &err_str,
+ &flags, CS_SUPPORTED_MASK, maskp ? &mask : NULL);
+ if (err < 0) {
+ return err_str;
+ }
+
+ *flagsp = htonl(flags);
+ if (maskp) {
+ *maskp = htonl(mask);
+ }
+
+ return NULL;
+}
+
/* Parses 's', a string value for field 'mf', into 'value' and 'mask'. Returns
* NULL if successful, otherwise a malloc()'d string describing the error. */
char *
(uint8_t *) value, (uint8_t *) mask);
break;
+ case MFS_CT_STATE:
+ ovs_assert(mf->n_bytes == sizeof(ovs_be32));
+ error = mf_from_ct_state_string(s, &value->be32, &mask->be32);
+ break;
+
case MFS_ETHERNET:
error = mf_from_ethernet_string(mf, s, &value->mac, &mask->mac);
break;
TCP_FLAGS(mask), TCP_FLAGS(OVS_BE16_MAX));
}
+static void
+mf_format_ct_state_string(ovs_be32 value, ovs_be32 mask, struct ds *s)
+{
+ format_flags_masked(s, NULL, ct_state_to_string, ntohl(value),
+ ntohl(mask), UINT16_MAX);
+}
+
/* Appends to 's' a string representation of field 'mf' whose value is in
* 'value' and 'mask'. 'mask' may be NULL to indicate an exact match. */
void
mf_format_integer_string(mf, (uint8_t *) value, (uint8_t *) mask, s);
break;
+ case MFS_CT_STATE:
+ mf_format_ct_state_string(value->be32,
+ mask ? mask->be32 : OVS_BE32_MAX, s);
+ break;
+
case MFS_ETHERNET:
eth_format_masked(value->mac, mask ? &mask->mac : NULL, s);
break;
mf_get(field, match, &value, &mask);
bitwise_copy(x, sizeof *x, 0, &value, field->n_bytes, sf->ofs, sf->n_bits);
bitwise_one ( &mask, field->n_bytes, sf->ofs, sf->n_bits);
- mf_set(field, &value, &mask, match);
+ mf_set(field, &value, &mask, match, NULL);
}
/* 'v' and 'm' correspond to values of 'field'. This function copies them into
mf_get(field, match, &value, &mask);
bitwise_copy(v, sizeof *v, 0, &value, field->n_bytes, 0, field->n_bits);
bitwise_copy(m, sizeof *m, 0, &mask, field->n_bytes, 0, field->n_bits);
- mf_set(field, &value, &mask, match);
+ mf_set(field, &value, &mask, match, NULL);
}
/* Initializes 'x' to the value of 'sf' within 'flow'. 'sf' must be valid for