#include "dynamic-string.h"
#include "ofp-errors.h"
#include "ofp-util.h"
+#include "ovs-thread.h"
#include "packets.h"
#include "random.h"
#include "shash.h"
}, {
MFF_TUN_SRC, "tun_src", NULL,
MF_FIELD_SIZES(be32),
- MFM_NONE,
+ MFM_FULLY,
MFS_IPV4,
MFP_NONE,
- false,
- 0, NULL,
- 0, NULL,
+ true,
+ NXM_NX_TUN_IPV4_SRC, "NXM_NX_TUN_IPV4_SRC",
+ NXM_NX_TUN_IPV4_SRC, "NXM_NX_TUN_IPV4_SRC",
}, {
MFF_TUN_DST, "tun_dst", NULL,
MF_FIELD_SIZES(be32),
- MFM_NONE,
+ MFM_FULLY,
MFS_IPV4,
MFP_NONE,
- false,
- 0, NULL,
- 0, NULL,
+ true,
+ NXM_NX_TUN_IPV4_DST, "NXM_NX_TUN_IPV4_DST",
+ NXM_NX_TUN_IPV4_DST, "NXM_NX_TUN_IPV4_DST",
}, {
MFF_TUN_FLAGS, "tun_flags", NULL,
MF_FIELD_SIZES(be16),
MFM_NONE,
MFS_OFP_PORT,
MFP_NONE,
- false,
+ true,
+ NXM_OF_IN_PORT, "NXM_OF_IN_PORT",
NXM_OF_IN_PORT, "NXM_OF_IN_PORT",
+ }, {
+ MFF_IN_PORT_OXM, "in_port_oxm", NULL,
+ MF_FIELD_SIZES(be32),
+ MFM_NONE,
+ MFS_OFP_PORT_OXM,
+ MFP_NONE,
+ true,
+ OXM_OF_IN_PORT, "OXM_OF_IN_PORT",
OXM_OF_IN_PORT, "OXM_OF_IN_PORT",
}, {
MFF_SKB_PRIORITY, "skb_priority", NULL,
OXM_OF_VLAN_PCP, "OXM_OF_VLAN_PCP",
},
+ /* ## ---- ## */
+ /* ## L2.5 ## */
+ /* ## ---- ## */
+ {
+ MFF_MPLS_LABEL, "mpls_label", NULL,
+ 4, 20,
+ MFM_NONE,
+ MFS_DECIMAL,
+ MFP_MPLS,
+ true,
+ OXM_OF_MPLS_LABEL, "OXM_OF_MPLS_LABEL",
+ OXM_OF_MPLS_LABEL, "OXM_OF_MPLS_LABEL",
+ }, {
+ MFF_MPLS_TC, "mpls_tc", NULL,
+ 1, 3,
+ MFM_NONE,
+ MFS_DECIMAL,
+ MFP_MPLS,
+ true,
+ OXM_OF_MPLS_TC, "OXM_OF_MPLS_TC",
+ OXM_OF_MPLS_TC, "OXM_OF_MPLS_TC",
+ }, {
+ MFF_MPLS_BOS, "mpls_bos", NULL,
+ 1, 1,
+ MFM_NONE,
+ MFS_DECIMAL,
+ MFP_MPLS,
+ false,
+ OXM_OF_MPLS_BOS, "OXM_OF_MPLS_BOS",
+ OXM_OF_MPLS_BOS, "OXM_OF_MPLS_BOS",
+ },
+
/* ## -- ## */
/* ## L3 ## */
/* ## -- ## */
MFP_IP_ANY,
true,
NXM_OF_IP_TOS, "NXM_OF_IP_TOS",
+ NXM_OF_IP_TOS, "NXM_OF_IP_TOS",
+ }, {
+ MFF_IP_DSCP_SHIFTED, "nw_tos_shifted", NULL,
+ MF_FIELD_SIZES(u8),
+ MFM_NONE,
+ MFS_DECIMAL,
+ MFP_IP_ANY,
+ true,
+ OXM_OF_IP_DSCP, "OXM_OF_IP_DSCP",
OXM_OF_IP_DSCP, "OXM_OF_IP_DSCP",
}, {
MFF_IP_ECN, "nw_ecn", NULL,
};
/* Contains 'struct nxm_field's. */
-static struct hmap all_fields = HMAP_INITIALIZER(&all_fields);
+static struct hmap all_fields;
+
+/* Maps from an mf_field's 'name' or 'extra_name' to the mf_field. */
+static struct shash mf_by_name;
/* Rate limit for parse errors. These always indicate a bug in an OpenFlow
* controller 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);
const struct mf_field *mf_from_nxm_header__(uint32_t header);
+static void nxm_init(void);
/* Returns the field with the given 'id'. */
const struct mf_field *
const struct mf_field *
mf_from_name(const char *name)
{
- static struct shash mf_by_name = SHASH_INITIALIZER(&mf_by_name);
-
- if (shash_is_empty(&mf_by_name)) {
- const struct mf_field *mf;
-
- for (mf = mf_fields; mf < &mf_fields[MFF_N_IDS]; mf++) {
- shash_add_once(&mf_by_name, mf->name, mf);
- if (mf->extra_name) {
- shash_add_once(&mf_by_name, mf->extra_name, mf);
- }
- }
- }
-
+ nxm_init();
return shash_find_data(&mf_by_name, name);
}
}
static void
-nxm_init(void)
+nxm_do_init(void)
{
const struct mf_field *mf;
+ hmap_init(&all_fields);
+ shash_init(&mf_by_name);
for (mf = mf_fields; mf < &mf_fields[MFF_N_IDS]; mf++) {
nxm_init_add_field(mf, mf->nxm_header);
if (mf->oxm_header != mf->nxm_header) {
nxm_init_add_field(mf, mf->oxm_header);
}
+
+ shash_add_once(&mf_by_name, mf->name, mf);
+ if (mf->extra_name) {
+ shash_add_once(&mf_by_name, mf->extra_name, mf);
+ }
}
}
+static void
+nxm_init(void)
+{
+ static pthread_once_t once = PTHREAD_ONCE_INIT;
+ pthread_once(&once, nxm_do_init);
+}
+
const struct mf_field *
mf_from_nxm_header(uint32_t header)
{
- if (hmap_is_empty(&all_fields)) {
- nxm_init();
- }
+ nxm_init();
return mf_from_nxm_header__(header);
}
mf_is_all_wild(const struct mf_field *mf, const struct flow_wildcards *wc)
{
switch (mf->id) {
- case MFF_TUN_ID:
case MFF_TUN_SRC:
+ return !wc->masks.tunnel.ip_src;
case MFF_TUN_DST:
+ return !wc->masks.tunnel.ip_dst;
+ case MFF_TUN_ID:
case MFF_TUN_TOS:
case MFF_TUN_TTL:
case MFF_TUN_FLAGS:
case MFF_METADATA:
return !wc->masks.metadata;
case MFF_IN_PORT:
- return !wc->masks.in_port;
+ case MFF_IN_PORT_OXM:
+ return !wc->masks.in_port.ofp_port;
case MFF_SKB_PRIORITY:
return !wc->masks.skb_priority;
case MFF_SKB_MARK:
case MFF_VLAN_PCP:
return !(wc->masks.vlan_tci & htons(VLAN_PCP_MASK));
+ case MFF_MPLS_LABEL:
+ return !(wc->masks.mpls_lse & htonl(MPLS_LABEL_MASK));
+ case MFF_MPLS_TC:
+ return !(wc->masks.mpls_lse & htonl(MPLS_TC_MASK));
+ case MFF_MPLS_BOS:
+ return !(wc->masks.mpls_lse & htonl(MPLS_BOS_MASK));
+
case MFF_IPV4_SRC:
return !wc->masks.nw_src;
case MFF_IPV4_DST:
case MFF_IP_PROTO:
return !wc->masks.nw_proto;
case MFF_IP_DSCP:
+ case MFF_IP_DSCP_SHIFTED:
return !(wc->masks.nw_tos & IP_DSCP_MASK);
case MFF_IP_ECN:
return !(wc->masks.nw_tos & IP_ECN_MASK);
return flow->dl_type == htons(ETH_TYPE_IPV6);
case MFP_VLAN_VID:
return (flow->vlan_tci & htons(VLAN_CFI)) != 0;
+ case MFP_MPLS:
+ return eth_type_mpls(flow->dl_type);
case MFP_IP_ANY:
return is_ip_any(flow);
case MFF_ND_TLL:
return true;
+ case MFF_IN_PORT_OXM: {
+ ofp_port_t port;
+ return !ofputil_port_from_ofp11(value->be32, &port);
+ }
+
case MFF_IP_DSCP:
return !(value->u8 & ~IP_DSCP_MASK);
+ case MFF_IP_DSCP_SHIFTED:
+ return !(value->u8 & (~IP_DSCP_MASK >> 2));
case MFF_IP_ECN:
return !(value->u8 & ~IP_ECN_MASK);
case MFF_IP_FRAG:
case MFF_IPV6_LABEL:
return !(value->be32 & ~htonl(IPV6_LABEL_MASK));
+ case MFF_MPLS_LABEL:
+ return !(value->be32 & ~htonl(MPLS_LABEL_MASK >> MPLS_LABEL_SHIFT));
+
+ case MFF_MPLS_TC:
+ return !(value->u8 & ~(MPLS_TC_MASK >> MPLS_TC_SHIFT));
+
+ case MFF_MPLS_BOS:
+ return !(value->u8 & ~(MPLS_BOS_MASK >> MPLS_BOS_SHIFT));
+
case MFF_N_IDS:
default:
NOT_REACHED();
break;
case MFF_IN_PORT:
- value->be16 = htons(flow->in_port);
+ value->be16 = htons(ofp_to_u16(flow->in_port.ofp_port));
+ break;
+ case MFF_IN_PORT_OXM:
+ value->be32 = ofputil_port_to_ofp11(flow->in_port.ofp_port);
break;
case MFF_SKB_PRIORITY:
value->u8 = vlan_tci_to_pcp(flow->vlan_tci);
break;
+ case MFF_MPLS_LABEL:
+ value->be32 = htonl(mpls_lse_to_label(flow->mpls_lse));
+ break;
+
+ case MFF_MPLS_TC:
+ value->u8 = mpls_lse_to_tc(flow->mpls_lse);
+ break;
+
+ case MFF_MPLS_BOS:
+ value->u8 = mpls_lse_to_bos(flow->mpls_lse);
+ break;
+
case MFF_IPV4_SRC:
value->be32 = flow->nw_src;
break;
value->u8 = flow->nw_tos & IP_DSCP_MASK;
break;
+ case MFF_IP_DSCP_SHIFTED:
+ value->u8 = flow->nw_tos >> 2;
+ break;
+
case MFF_IP_ECN:
value->u8 = flow->nw_tos & IP_ECN_MASK;
break;
break;
case MFF_IN_PORT:
- match_set_in_port(match, ntohs(value->be16));
+ match_set_in_port(match, u16_to_ofp(ntohs(value->be16)));
break;
+ case MFF_IN_PORT_OXM: {
+ ofp_port_t port;
+ ofputil_port_from_ofp11(value->be32, &port);
+ match_set_in_port(match, port);
+ break;
+ }
+
case MFF_SKB_PRIORITY:
match_set_skb_priority(match, ntohl(value->be32));
break;
match_set_dl_vlan_pcp(match, value->u8);
break;
+ case MFF_MPLS_LABEL:
+ match_set_mpls_label(match, value->be32);
+ break;
+
+ case MFF_MPLS_TC:
+ match_set_mpls_tc(match, value->u8);
+ break;
+
+ case MFF_MPLS_BOS:
+ match_set_mpls_bos(match, value->u8);
+ break;
+
case MFF_IPV4_SRC:
match_set_nw_src(match, value->be32);
break;
match_set_nw_dscp(match, value->u8);
break;
+ case MFF_IP_DSCP_SHIFTED:
+ match_set_nw_dscp(match, value->u8 << 2);
+ break;
+
case MFF_IP_ECN:
match_set_nw_ecn(match, value->u8);
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. */
+/* Sets 'flow' member field described by 'mf' to 'value'. The caller is
+ * responsible for ensuring that 'flow' meets 'mf''s prerequisites.*/
void
mf_set_flow_value(const struct mf_field *mf,
const union mf_value *value, struct flow *flow)
break;
case MFF_IN_PORT:
- flow->in_port = ntohs(value->be16);
+ flow->in_port.ofp_port = u16_to_ofp(ntohs(value->be16));
break;
+ case MFF_IN_PORT_OXM: {
+ ofp_port_t port;
+ ofputil_port_from_ofp11(value->be32, &port);
+ flow->in_port.ofp_port = port;
+ break;
+ }
+
case MFF_SKB_PRIORITY:
flow->skb_priority = ntohl(value->be32);
break;
flow_set_vlan_pcp(flow, value->u8);
break;
+ case MFF_MPLS_LABEL:
+ flow_set_mpls_label(flow, value->be32);
+ break;
+
+ case MFF_MPLS_TC:
+ flow_set_mpls_tc(flow, value->u8);
+ break;
+
+ case MFF_MPLS_BOS:
+ flow_set_mpls_bos(flow, value->u8);
+ break;
+
case MFF_IPV4_SRC:
flow->nw_src = value->be32;
break;
flow->nw_tos |= value->u8 & IP_DSCP_MASK;
break;
+ case MFF_IP_DSCP_SHIFTED:
+ flow->nw_tos &= ~IP_DSCP_MASK;
+ flow->nw_tos |= value->u8 << 2;
+ break;
+
case MFF_IP_ECN:
flow->nw_tos &= ~IP_ECN_MASK;
flow->nw_tos |= value->u8 & IP_ECN_MASK;
case MFF_METADATA:
match_set_metadata_masked(match, htonll(0), htonll(0));
+ break;
case MFF_IN_PORT:
- match->flow.in_port = 0;
- match->wc.masks.in_port = 0;
+ case MFF_IN_PORT_OXM:
+ match->flow.in_port.ofp_port = 0;
+ match->wc.masks.in_port.ofp_port = 0;
break;
case MFF_SKB_PRIORITY:
match_set_any_pcp(match);
break;
+ case MFF_MPLS_LABEL:
+ match_set_any_mpls_label(match);
+ break;
+
+ case MFF_MPLS_TC:
+ match_set_any_mpls_tc(match);
+ break;
+
+ case MFF_MPLS_BOS:
+ match_set_any_mpls_bos(match);
+ break;
+
case MFF_IPV4_SRC:
case MFF_ARP_SPA:
match_set_nw_src_masked(match, htonl(0), htonl(0));
break;
case MFF_IP_DSCP:
+ case MFF_IP_DSCP_SHIFTED:
match->wc.masks.nw_tos &= ~IP_DSCP_MASK;
match->flow.nw_tos &= ~IP_DSCP_MASK;
break;
switch (mf->id) {
case MFF_IN_PORT:
+ case MFF_IN_PORT_OXM:
case MFF_SKB_MARK:
case MFF_SKB_PRIORITY:
case MFF_ETH_TYPE:
case MFF_DL_VLAN:
case MFF_DL_VLAN_PCP:
case MFF_VLAN_PCP:
+ case MFF_MPLS_LABEL:
+ case MFF_MPLS_TC:
+ case MFF_MPLS_BOS:
case MFF_IP_PROTO:
case MFF_IP_TTL:
case MFF_IP_DSCP:
+ case MFF_IP_DSCP_SHIFTED:
case MFF_IP_ECN:
case MFF_ARP_OP:
case MFF_ICMPV4_TYPE:
case MFF_ND_TLL:
break;
+ case MFF_IN_PORT_OXM:
+ value->be32 = ofputil_port_to_ofp11(u16_to_ofp(ntohs(value->be16)));
+ break;
+
case MFF_IPV6_LABEL:
value->be32 &= ~htonl(IPV6_LABEL_MASK);
break;
value->u8 &= IP_DSCP_MASK;
break;
+ case MFF_IP_DSCP_SHIFTED:
+ value->u8 &= IP_DSCP_MASK >> 2;
+ break;
+
case MFF_IP_ECN:
value->u8 &= IP_ECN_MASK;
break;
value->u8 &= 0x07;
break;
+ case MFF_MPLS_LABEL:
+ value->be32 &= htonl(MPLS_LABEL_MASK >> MPLS_LABEL_SHIFT);
+ break;
+
+ case MFF_MPLS_TC:
+ value->u8 &= MPLS_TC_MASK >> MPLS_TC_SHIFT;
+ break;
+
+ case MFF_MPLS_BOS:
+ value->u8 &= MPLS_BOS_MASK >> MPLS_BOS_SHIFT;
+ break;
+
case MFF_N_IDS:
default:
NOT_REACHED();
uint8_t mac[ETH_ADDR_LEN],
uint8_t mask[ETH_ADDR_LEN])
{
- ovs_assert(mf->n_bytes == ETH_ADDR_LEN);
+ int n;
- switch (sscanf(s, ETH_ADDR_SCAN_FMT"/"ETH_ADDR_SCAN_FMT,
- ETH_ADDR_SCAN_ARGS(mac), ETH_ADDR_SCAN_ARGS(mask))){
- case ETH_ADDR_SCAN_COUNT * 2:
- return NULL;
+ ovs_assert(mf->n_bytes == ETH_ADDR_LEN);
- case ETH_ADDR_SCAN_COUNT:
+ n = -1;
+ if (sscanf(s, ETH_ADDR_SCAN_FMT"%n", ETH_ADDR_SCAN_ARGS(mac), &n) > 0
+ && n == strlen(s)) {
memset(mask, 0xff, ETH_ADDR_LEN);
return NULL;
+ }
- default:
- return xasprintf("%s: invalid Ethernet address", s);
+ n = -1;
+ if (sscanf(s, ETH_ADDR_SCAN_FMT"/"ETH_ADDR_SCAN_FMT"%n",
+ ETH_ADDR_SCAN_ARGS(mac), ETH_ADDR_SCAN_ARGS(mask), &n) > 0
+ && n == strlen(s)) {
+ return NULL;
}
+
+ return xasprintf("%s: invalid Ethernet address", s);
}
static char *
mf_from_ofp_port_string(const struct mf_field *mf, const char *s,
ovs_be16 *valuep, ovs_be16 *maskp)
{
- uint16_t port;
+ ofp_port_t port;
ovs_assert(mf->n_bytes == sizeof(ovs_be16));
- if (*s == '-') {
- return xasprintf("%s: negative values not supported for %s",
- s, mf->name);
- } else if (ofputil_port_from_string(s, &port)) {
- *valuep = htons(port);
+
+ if (ofputil_port_from_string(s, &port)) {
+ *valuep = htons(ofp_to_u16(port));
*maskp = htons(UINT16_MAX);
return NULL;
- } else {
- return mf_from_integer_string(mf, s,
- (uint8_t *) valuep, (uint8_t *) maskp);
}
+ return xasprintf("%s: port value out of range for %s", s, mf->name);
+}
+
+static char *
+mf_from_ofp_port_string32(const struct mf_field *mf, const char *s,
+ ovs_be32 *valuep, ovs_be32 *maskp)
+{
+ ofp_port_t port;
+
+ ovs_assert(mf->n_bytes == sizeof(ovs_be32));
+ if (ofputil_port_from_string(s, &port)) {
+ *valuep = ofputil_port_to_ofp11(port);
+ *maskp = htonl(UINT32_MAX);
+ return NULL;
+ }
+ return xasprintf("%s: port value out of range for %s", s, mf->name);
}
struct frag_handling {
case MFS_OFP_PORT:
return mf_from_ofp_port_string(mf, s, &value->be16, &mask->be16);
+ case MFS_OFP_PORT_OXM:
+ return mf_from_ofp_port_string32(mf, s, &value->be32, &mask->be32);
+
case MFS_FRAG:
return mf_from_frag_string(s, &value->u8, &mask->u8);
}
static void
-mf_format_frag_string(const uint8_t *valuep, const uint8_t *maskp,
- struct ds *s)
+mf_format_frag_string(uint8_t value, uint8_t mask, struct ds *s)
{
const struct frag_handling *h;
- uint8_t value = *valuep;
- uint8_t mask = *maskp;
- value &= mask;
mask &= FLOW_NW_FRAG_MASK;
+ value &= mask;
for (h = all_frags; h < &all_frags[ARRAY_SIZE(all_frags)]; h++) {
if (value == h->value && mask == h->mask) {
}
switch (mf->string) {
+ case MFS_OFP_PORT_OXM:
+ if (!mask) {
+ ofp_port_t port;
+ ofputil_port_from_ofp11(value->be32, &port);
+ ofputil_format_port(port, s);
+ break;
+ }
+ /* fall through */
case MFS_OFP_PORT:
if (!mask) {
- ofputil_format_port(ntohs(value->be16), s);
+ ofputil_format_port(u16_to_ofp(ntohs(value->be16)), s);
break;
}
/* fall through */
break;
case MFS_FRAG:
- mf_format_frag_string(&value->u8, &mask->u8, s);
+ mf_format_frag_string(value->u8, mask ? mask->u8 : UINT8_MAX, s);
break;
case MFS_TNL_FLAGS:
* 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 *
+char * WARN_UNUSED_RESULT
mf_parse_subfield__(struct mf_subfield *sf, const char **sp)
{
const struct mf_field *field;
return NULL;
}
-/* Parses a subfield from the beginning of 's' into 'sf'. Returns the first
- * byte in 's' following the parsed string.
- *
- * Exits with an error message if 's' has incorrect syntax.
+/* 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. */
-const char *
+char * WARN_UNUSED_RESULT
mf_parse_subfield(struct mf_subfield *sf, const char *s)
{
- char *msg = mf_parse_subfield__(sf, &s);
- if (msg) {
- ovs_fatal(0, "%s", msg);
+ char *error = mf_parse_subfield__(sf, &s);
+ if (!error && s[0]) {
+ error = xstrdup("unexpected input following field syntax");
}
- return s;
+ return error;
}
void