#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"
true,
NXM_NX_TUN_ID, "NXM_NX_TUN_ID",
OXM_OF_TUNNEL_ID, "OXM_OF_TUNNEL_ID",
+ OFPUTIL_P_NXM_OXM_ANY,
+ OFPUTIL_P_NXM_OXM_ANY,
}, {
MFF_TUN_SRC, "tun_src", NULL,
MF_FIELD_SIZES(be32),
true,
NXM_NX_TUN_IPV4_SRC, "NXM_NX_TUN_IPV4_SRC",
NXM_NX_TUN_IPV4_SRC, "NXM_NX_TUN_IPV4_SRC",
+ OFPUTIL_P_NXM_OXM_ANY,
+ OFPUTIL_P_NXM_OXM_ANY,
}, {
MFF_TUN_DST, "tun_dst", NULL,
MF_FIELD_SIZES(be32),
true,
NXM_NX_TUN_IPV4_DST, "NXM_NX_TUN_IPV4_DST",
NXM_NX_TUN_IPV4_DST, "NXM_NX_TUN_IPV4_DST",
+ OFPUTIL_P_NXM_OXM_ANY,
+ OFPUTIL_P_NXM_OXM_ANY,
}, {
MFF_TUN_FLAGS, "tun_flags", NULL,
MF_FIELD_SIZES(be16),
false,
0, NULL,
0, NULL,
+ OFPUTIL_P_NONE,
+ OFPUTIL_P_NONE,
}, {
MFF_TUN_TOS, "tun_tos", NULL,
MF_FIELD_SIZES(u8),
false,
0, NULL,
0, NULL,
+ OFPUTIL_P_NONE,
+ OFPUTIL_P_NONE,
}, {
MFF_TUN_TTL, "tun_ttl", NULL,
MF_FIELD_SIZES(u8),
false,
0, NULL,
0, NULL,
+ OFPUTIL_P_NONE,
+ OFPUTIL_P_NONE,
}, {
MFF_METADATA, "metadata", NULL,
MF_FIELD_SIZES(be64),
true,
OXM_OF_METADATA, "OXM_OF_METADATA",
OXM_OF_METADATA, "OXM_OF_METADATA",
+ OFPUTIL_P_NXM_OF11_UP,
+ OFPUTIL_P_NXM_OF11_UP,
}, {
MFF_IN_PORT, "in_port", NULL,
MF_FIELD_SIZES(be16),
MFP_NONE,
true,
NXM_OF_IN_PORT, "NXM_OF_IN_PORT",
+ NXM_OF_IN_PORT, "NXM_OF_IN_PORT",
+ OFPUTIL_P_ANY, /* OF11+ via mapping to 32 bits. */
+ OFPUTIL_P_NONE,
+ }, {
+ 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",
+ OFPUTIL_P_OF11_UP,
+ OFPUTIL_P_NONE,
}, {
MFF_SKB_PRIORITY, "skb_priority", NULL,
MF_FIELD_SIZES(be32),
false,
0, NULL,
0, NULL,
+ OFPUTIL_P_NONE,
+ OFPUTIL_P_NONE,
}, {
- MFF_SKB_MARK, "skb_mark", NULL,
+ MFF_PKT_MARK, "pkt_mark", NULL,
MF_FIELD_SIZES(be32),
- MFM_NONE,
+ MFM_FULLY,
MFS_HEXADECIMAL,
MFP_NONE,
- false,
- 0, NULL,
- 0, NULL,
+ true,
+ NXM_NX_PKT_MARK, "NXM_NX_PKT_MARK",
+ NXM_NX_PKT_MARK, "NXM_NX_PKT_MARK",
+ OFPUTIL_P_NXM_OXM_ANY,
+ OFPUTIL_P_NXM_OXM_ANY,
},
#define REGISTER(IDX) \
true, \
NXM_NX_REG(IDX), "NXM_NX_REG" #IDX, \
NXM_NX_REG(IDX), "NXM_NX_REG" #IDX, \
+ OFPUTIL_P_NXM_OXM_ANY, \
+ OFPUTIL_P_NXM_OXM_ANY, \
}
#if FLOW_N_REGS > 0
REGISTER(0),
true,
NXM_OF_ETH_SRC, "NXM_OF_ETH_SRC",
OXM_OF_ETH_SRC, "OXM_OF_ETH_SRC",
+ OFPUTIL_P_ANY,
+ OFPUTIL_P_NXM_OF11_UP, /* Bitwise masking only with NXM and OF11+! */
}, {
MFF_ETH_DST, "eth_dst", "dl_dst",
MF_FIELD_SIZES(mac),
true,
NXM_OF_ETH_DST, "NXM_OF_ETH_DST",
OXM_OF_ETH_DST, "OXM_OF_ETH_DST",
+ OFPUTIL_P_ANY,
+ OFPUTIL_P_NXM_OF11_UP, /* Bitwise masking only with NXM and OF11+! */
}, {
MFF_ETH_TYPE, "eth_type", "dl_type",
MF_FIELD_SIZES(be16),
false,
NXM_OF_ETH_TYPE, "NXM_OF_ETH_TYPE",
OXM_OF_ETH_TYPE, "OXM_OF_ETH_TYPE",
+ OFPUTIL_P_ANY,
+ OFPUTIL_P_NONE,
},
{
true,
NXM_OF_VLAN_TCI, "NXM_OF_VLAN_TCI",
NXM_OF_VLAN_TCI, "NXM_OF_VLAN_TCI",
+ OFPUTIL_P_ANY,
+ OFPUTIL_P_NXM_OXM_ANY,
}, {
MFF_DL_VLAN, "dl_vlan", NULL,
sizeof(ovs_be16), 12,
true,
0, NULL,
0, NULL,
+ OFPUTIL_P_ANY,
+ OFPUTIL_P_NXM_OXM_ANY,
}, {
MFF_VLAN_VID, "vlan_vid", NULL,
sizeof(ovs_be16), 12,
true,
OXM_OF_VLAN_VID, "OXM_OF_VLAN_VID",
OXM_OF_VLAN_VID, "OXM_OF_VLAN_VID",
+ OFPUTIL_P_ANY,
+ OFPUTIL_P_NXM_OXM_ANY,
}, {
MFF_DL_VLAN_PCP, "dl_vlan_pcp", NULL,
1, 3,
true,
0, NULL,
0, NULL,
+ OFPUTIL_P_ANY, /* Will be mapped to NXM and OXM. */
+ OFPUTIL_P_NONE,
}, {
MFF_VLAN_PCP, "vlan_pcp", NULL,
1, 3,
true,
OXM_OF_VLAN_PCP, "OXM_OF_VLAN_PCP",
OXM_OF_VLAN_PCP, "OXM_OF_VLAN_PCP",
+ OFPUTIL_P_ANY, /* Will be mapped to OF10 and NXM. */
+ OFPUTIL_P_NONE,
},
/* ## ---- ## */
true,
OXM_OF_MPLS_LABEL, "OXM_OF_MPLS_LABEL",
OXM_OF_MPLS_LABEL, "OXM_OF_MPLS_LABEL",
+ OFPUTIL_P_NXM_OF11_UP,
+ OFPUTIL_P_NONE,
}, {
MFF_MPLS_TC, "mpls_tc", NULL,
1, 3,
true,
OXM_OF_MPLS_TC, "OXM_OF_MPLS_TC",
OXM_OF_MPLS_TC, "OXM_OF_MPLS_TC",
+ OFPUTIL_P_NXM_OF11_UP,
+ OFPUTIL_P_NONE,
}, {
MFF_MPLS_BOS, "mpls_bos", NULL,
1, 1,
false,
OXM_OF_MPLS_BOS, "OXM_OF_MPLS_BOS",
OXM_OF_MPLS_BOS, "OXM_OF_MPLS_BOS",
+ OFPUTIL_P_NXM_OXM_ANY,
+ OFPUTIL_P_NONE,
},
/* ## -- ## */
true,
NXM_OF_IP_SRC, "NXM_OF_IP_SRC",
OXM_OF_IPV4_SRC, "OXM_OF_IPV4_SRC",
+ OFPUTIL_P_ANY,
+ OFPUTIL_P_NXM_OF11_UP,
}, {
MFF_IPV4_DST, "ip_dst", "nw_dst",
MF_FIELD_SIZES(be32),
true,
NXM_OF_IP_DST, "NXM_OF_IP_DST",
OXM_OF_IPV4_DST, "OXM_OF_IPV4_DST",
+ OFPUTIL_P_ANY,
+ OFPUTIL_P_NXM_OF11_UP,
},
{
true,
NXM_NX_IPV6_SRC, "NXM_NX_IPV6_SRC",
OXM_OF_IPV6_SRC, "OXM_OF_IPV6_SRC",
+ OFPUTIL_P_NXM_OXM_ANY,
+ OFPUTIL_P_NXM_OXM_ANY,
}, {
MFF_IPV6_DST, "ipv6_dst", NULL,
MF_FIELD_SIZES(ipv6),
true,
NXM_NX_IPV6_DST, "NXM_NX_IPV6_DST",
OXM_OF_IPV6_DST, "OXM_OF_IPV6_DST",
+ OFPUTIL_P_NXM_OXM_ANY,
+ OFPUTIL_P_NXM_OXM_ANY,
},
{
MFF_IPV6_LABEL, "ipv6_label", NULL,
false,
NXM_NX_IPV6_LABEL, "NXM_NX_IPV6_LABEL",
OXM_OF_IPV6_FLABEL, "OXM_OF_IPV6_FLABEL",
+ OFPUTIL_P_NXM_OXM_ANY,
+ OFPUTIL_P_NXM_OXM_ANY,
},
{
false,
NXM_OF_IP_PROTO, "NXM_OF_IP_PROTO",
OXM_OF_IP_PROTO, "OXM_OF_IP_PROTO",
+ OFPUTIL_P_ANY,
+ OFPUTIL_P_NONE,
}, {
MFF_IP_DSCP, "nw_tos", NULL,
MF_FIELD_SIZES(u8),
true,
NXM_OF_IP_TOS, "NXM_OF_IP_TOS",
NXM_OF_IP_TOS, "NXM_OF_IP_TOS",
+ OFPUTIL_P_ANY, /* Will be shifted for OXM. */
+ OFPUTIL_P_NONE,
}, {
MFF_IP_DSCP_SHIFTED, "nw_tos_shifted", NULL,
MF_FIELD_SIZES(u8),
true,
OXM_OF_IP_DSCP, "OXM_OF_IP_DSCP",
OXM_OF_IP_DSCP, "OXM_OF_IP_DSCP",
+ OFPUTIL_P_ANY, /* Will be shifted for non-OXM. */
+ OFPUTIL_P_NONE,
}, {
MFF_IP_ECN, "nw_ecn", NULL,
1, 2,
true,
NXM_NX_IP_ECN, "NXM_NX_IP_ECN",
OXM_OF_IP_ECN, "OXM_OF_IP_ECN",
+ OFPUTIL_P_NXM_OXM_ANY,
+ OFPUTIL_P_NONE,
}, {
MFF_IP_TTL, "nw_ttl", NULL,
MF_FIELD_SIZES(u8),
true,
NXM_NX_IP_TTL, "NXM_NX_IP_TTL",
NXM_NX_IP_TTL, "NXM_NX_IP_TTL",
+ OFPUTIL_P_NXM_OXM_ANY,
+ OFPUTIL_P_NONE,
}, {
MFF_IP_FRAG, "ip_frag", NULL,
1, 2,
false,
NXM_NX_IP_FRAG, "NXM_NX_IP_FRAG",
NXM_NX_IP_FRAG, "NXM_NX_IP_FRAG",
+ OFPUTIL_P_NXM_OXM_ANY,
+ OFPUTIL_P_NXM_OXM_ANY,
},
{
false,
NXM_OF_ARP_OP, "NXM_OF_ARP_OP",
OXM_OF_ARP_OP, "OXM_OF_ARP_OP",
+ OFPUTIL_P_ANY,
+ OFPUTIL_P_NONE,
}, {
MFF_ARP_SPA, "arp_spa", NULL,
MF_FIELD_SIZES(be32),
false,
NXM_OF_ARP_SPA, "NXM_OF_ARP_SPA",
OXM_OF_ARP_SPA, "OXM_OF_ARP_SPA",
+ OFPUTIL_P_ANY,
+ OFPUTIL_P_NXM_OF11_UP,
}, {
MFF_ARP_TPA, "arp_tpa", NULL,
MF_FIELD_SIZES(be32),
false,
NXM_OF_ARP_TPA, "NXM_OF_ARP_TPA",
OXM_OF_ARP_TPA, "OXM_OF_ARP_TPA",
+ OFPUTIL_P_ANY,
+ OFPUTIL_P_NXM_OF11_UP,
}, {
MFF_ARP_SHA, "arp_sha", NULL,
MF_FIELD_SIZES(mac),
false,
NXM_NX_ARP_SHA, "NXM_NX_ARP_SHA",
OXM_OF_ARP_SHA, "OXM_OF_ARP_SHA",
+ OFPUTIL_P_NXM_OXM_ANY,
+ OFPUTIL_P_NXM_OXM_ANY,
}, {
MFF_ARP_THA, "arp_tha", NULL,
MF_FIELD_SIZES(mac),
false,
NXM_NX_ARP_THA, "NXM_NX_ARP_THA",
OXM_OF_ARP_THA, "OXM_OF_ARP_THA",
+ OFPUTIL_P_NXM_OXM_ANY,
+ OFPUTIL_P_NXM_OXM_ANY,
},
/* ## -- ## */
true,
NXM_OF_TCP_SRC, "NXM_OF_TCP_SRC",
OXM_OF_TCP_SRC, "OXM_OF_TCP_SRC",
+ OFPUTIL_P_ANY,
+ OFPUTIL_P_NXM_OXM_ANY,
}, {
MFF_TCP_DST, "tcp_dst", "tp_dst",
MF_FIELD_SIZES(be16),
true,
NXM_OF_TCP_DST, "NXM_OF_TCP_DST",
OXM_OF_TCP_DST, "OXM_OF_TCP_DST",
+ OFPUTIL_P_ANY,
+ OFPUTIL_P_NXM_OXM_ANY,
},
{
true,
NXM_OF_UDP_SRC, "NXM_OF_UDP_SRC",
OXM_OF_UDP_SRC, "OXM_OF_UDP_SRC",
+ OFPUTIL_P_ANY,
+ OFPUTIL_P_NXM_OXM_ANY,
}, {
MFF_UDP_DST, "udp_dst", NULL,
MF_FIELD_SIZES(be16),
true,
NXM_OF_UDP_DST, "NXM_OF_UDP_DST",
OXM_OF_UDP_DST, "OXM_OF_UDP_DST",
+ OFPUTIL_P_ANY,
+ OFPUTIL_P_NXM_OXM_ANY,
+ },
+
+ {
+ MFF_SCTP_SRC, "sctp_src", NULL,
+ MF_FIELD_SIZES(be16),
+ MFM_FULLY,
+ MFS_DECIMAL,
+ MFP_SCTP,
+ true,
+ OXM_OF_SCTP_SRC, "OXM_OF_SCTP_SRC",
+ OXM_OF_SCTP_SRC, "OXM_OF_SCTP_SRC",
+ OFPUTIL_P_NXM_OF11_UP,
+ OFPUTIL_P_NXM_OXM_ANY,
+ }, {
+ MFF_SCTP_DST, "sctp_dst", NULL,
+ MF_FIELD_SIZES(be16),
+ MFM_FULLY,
+ MFS_DECIMAL,
+ MFP_SCTP,
+ true,
+ OXM_OF_SCTP_DST, "OXM_OF_SCTP_DST",
+ OXM_OF_SCTP_DST, "OXM_OF_SCTP_DST",
+ OFPUTIL_P_NXM_OF11_UP,
+ OFPUTIL_P_NXM_OXM_ANY,
},
{
false,
NXM_OF_ICMP_TYPE, "NXM_OF_ICMP_TYPE",
OXM_OF_ICMPV4_TYPE, "OXM_OF_ICMPV4_TYPE",
+ OFPUTIL_P_ANY,
+ OFPUTIL_P_NONE,
}, {
MFF_ICMPV4_CODE, "icmp_code", NULL,
MF_FIELD_SIZES(u8),
false,
NXM_OF_ICMP_CODE, "NXM_OF_ICMP_CODE",
OXM_OF_ICMPV4_CODE, "OXM_OF_ICMPV4_CODE",
+ OFPUTIL_P_ANY,
+ OFPUTIL_P_NONE,
},
{
false,
NXM_NX_ICMPV6_TYPE, "NXM_NX_ICMPV6_TYPE",
OXM_OF_ICMPV6_TYPE, "OXM_OF_ICMPV6_TYPE",
+ OFPUTIL_P_NXM_OXM_ANY,
+ OFPUTIL_P_NONE,
}, {
MFF_ICMPV6_CODE, "icmpv6_code", NULL,
MF_FIELD_SIZES(u8),
false,
NXM_NX_ICMPV6_CODE, "NXM_NX_ICMPV6_CODE",
OXM_OF_ICMPV6_CODE, "OXM_OF_ICMPV6_CODE",
+ OFPUTIL_P_NXM_OXM_ANY,
+ OFPUTIL_P_NONE,
},
/* ## ---- ## */
false,
NXM_NX_ND_TARGET, "NXM_NX_ND_TARGET",
OXM_OF_IPV6_ND_TARGET, "OXM_OF_IPV6_ND_TARGET",
+ OFPUTIL_P_NXM_OXM_ANY,
+ OFPUTIL_P_NXM_OXM_ANY,
}, {
MFF_ND_SLL, "nd_sll", NULL,
MF_FIELD_SIZES(mac),
false,
NXM_NX_ND_SLL, "NXM_NX_ND_SLL",
OXM_OF_IPV6_ND_SLL, "OXM_OF_IPV6_ND_SLL",
+ OFPUTIL_P_NXM_OXM_ANY,
+ OFPUTIL_P_NXM_OXM_ANY,
}, {
MFF_ND_TLL, "nd_tll", NULL,
MF_FIELD_SIZES(mac),
false,
NXM_NX_ND_TLL, "NXM_NX_ND_TLL",
OXM_OF_IPV6_ND_TLL, "OXM_OF_IPV6_ND_TLL",
+ OFPUTIL_P_NXM_OXM_ANY,
+ OFPUTIL_P_NXM_OXM_ANY,
}
};
};
/* 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);
}
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:
- return !wc->masks.skb_mark;
+ case MFF_PKT_MARK:
+ return !wc->masks.pkt_mark;
CASE_MFF_REGS:
return !wc->masks.regs[mf->id - MFF_REG0];
case MFF_TCP_SRC:
case MFF_UDP_SRC:
+ case MFF_SCTP_SRC:
case MFF_ICMPV4_TYPE:
case MFF_ICMPV6_TYPE:
return !wc->masks.tp_src;
case MFF_TCP_DST:
case MFF_UDP_DST:
+ case MFF_SCTP_DST:
case MFF_ICMPV4_CODE:
case MFF_ICMPV6_CODE:
return !wc->masks.tp_dst;
return is_ip_any(flow) && flow->nw_proto == IPPROTO_TCP;
case MFP_UDP:
return is_ip_any(flow) && flow->nw_proto == IPPROTO_UDP;
+ case MFP_SCTP:
+ return is_ip_any(flow) && flow->nw_proto == IPPROTO_SCTP;
case MFP_ICMPV4:
return is_icmpv4(flow);
case MFP_ICMPV6:
case MFF_METADATA:
case MFF_IN_PORT:
case MFF_SKB_PRIORITY:
- case MFF_SKB_MARK:
+ case MFF_PKT_MARK:
CASE_MFF_REGS:
case MFF_ETH_SRC:
case MFF_ETH_DST:
case MFF_TCP_DST:
case MFF_UDP_SRC:
case MFF_UDP_DST:
+ case MFF_SCTP_SRC:
+ case MFF_SCTP_DST:
case MFF_ICMPV4_TYPE:
case MFF_ICMPV4_CODE:
case MFF_ICMPV6_TYPE:
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:
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->be32 = htonl(flow->skb_priority);
break;
- case MFF_SKB_MARK:
- value->be32 = htonl(flow->skb_mark);
+ case MFF_PKT_MARK:
+ value->be32 = htonl(flow->pkt_mark);
break;
CASE_MFF_REGS:
case MFF_TCP_SRC:
case MFF_UDP_SRC:
+ case MFF_SCTP_SRC:
value->be16 = flow->tp_src;
break;
case MFF_TCP_DST:
case MFF_UDP_DST:
+ case MFF_SCTP_DST:
value->be16 = flow->tp_dst;
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;
- case MFF_SKB_MARK:
- match_set_skb_mark(match, ntohl(value->be32));
+ case MFF_PKT_MARK:
+ match_set_pkt_mark(match, ntohl(value->be32));
break;
CASE_MFF_REGS:
case MFF_TCP_SRC:
case MFF_UDP_SRC:
+ case MFF_SCTP_SRC:
match_set_tp_src(match, value->be16);
break;
case MFF_TCP_DST:
case MFF_UDP_DST:
+ case MFF_SCTP_DST:
match_set_tp_dst(match, value->be16);
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;
- case MFF_SKB_MARK:
- flow->skb_mark = ntohl(value->be32);
+ case MFF_PKT_MARK:
+ flow->pkt_mark = ntohl(value->be32);
break;
CASE_MFF_REGS:
case MFF_TCP_SRC:
case MFF_UDP_SRC:
+ case MFF_SCTP_SRC:
flow->tp_src = value->be16;
break;
case MFF_TCP_DST:
case MFF_UDP_DST:
+ case MFF_SCTP_DST:
flow->tp_dst = value->be16;
break;
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->wc.masks.skb_priority = 0;
break;
- case MFF_SKB_MARK:
- match->flow.skb_mark = 0;
- match->wc.masks.skb_mark = 0;
+ case MFF_PKT_MARK:
+ match->flow.pkt_mark = 0;
+ match->wc.masks.pkt_mark = 0;
break;
CASE_MFF_REGS:
case MFF_TCP_SRC:
case MFF_UDP_SRC:
+ case MFF_SCTP_SRC:
case MFF_ICMPV4_TYPE:
case MFF_ICMPV6_TYPE:
match->wc.masks.tp_src = htons(0);
case MFF_TCP_DST:
case MFF_UDP_DST:
+ case MFF_SCTP_DST:
case MFF_ICMPV4_CODE:
case MFF_ICMPV6_CODE:
match->wc.masks.tp_dst = htons(0);
*
* '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. */
-void
+enum ofputil_protocol
mf_set(const struct mf_field *mf,
const union mf_value *value, const union mf_value *mask,
struct match *match)
{
if (!mask || is_all_ones((const uint8_t *) mask, mf->n_bytes)) {
mf_set_value(mf, value, match);
- return;
+ return mf->usable_protocols;
} else if (is_all_zeros((const uint8_t *) mask, mf->n_bytes)) {
mf_set_wild(mf, match);
- return;
+ return OFPUTIL_P_ANY;
}
switch (mf->id) {
case MFF_IN_PORT:
- case MFF_SKB_MARK:
+ case MFF_IN_PORT_OXM:
case MFF_SKB_PRIORITY:
case MFF_ETH_TYPE:
case MFF_DL_VLAN:
ntohl(value->be32), ntohl(mask->be32));
break;
+ case MFF_PKT_MARK:
+ match_set_pkt_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_IPV4_SRC:
match_set_nw_src_masked(match, value->be32, mask->be32);
- break;
+ goto cidr_check;
case MFF_IPV4_DST:
match_set_nw_dst_masked(match, value->be32, mask->be32);
- break;
+ goto cidr_check;
case MFF_IPV6_SRC:
match_set_ipv6_src_masked(match, &value->ipv6, &mask->ipv6);
case MFF_ARP_SPA:
match_set_nw_src_masked(match, value->be32, mask->be32);
- break;
+ goto cidr_check;
case MFF_ARP_TPA:
match_set_nw_dst_masked(match, value->be32, mask->be32);
- break;
+ goto cidr_check;
case MFF_TCP_SRC:
case MFF_UDP_SRC:
+ case MFF_SCTP_SRC:
match_set_tp_src_masked(match, value->be16, mask->be16);
break;
case MFF_TCP_DST:
case MFF_UDP_DST:
+ case MFF_SCTP_DST:
match_set_tp_dst_masked(match, value->be16, mask->be16);
break;
default:
NOT_REACHED();
}
+
+ return mf->usable_protocols_bitwise;
+
+cidr_check:
+ return ip_is_cidr(mask->be32) ? mf->usable_protocols :
+ mf->usable_protocols_bitwise;
}
static enum ofperr
{
if (!sf->field) {
VLOG_WARN_RL(&rl, "unknown %s field", type);
+ return OFPERR_OFPBAC_BAD_SET_TYPE;
} else if (!sf->n_bits) {
VLOG_WARN_RL(&rl, "zero bit %s field %s", type, sf->field->name);
+ return OFPERR_OFPBAC_BAD_SET_LEN;
} else if (sf->ofs >= sf->field->n_bits) {
VLOG_WARN_RL(&rl, "bit offset %d exceeds %d-bit width of %s field %s",
sf->ofs, sf->field->n_bits, type, sf->field->name);
+ return OFPERR_OFPBAC_BAD_SET_LEN;
} else if (sf->ofs + sf->n_bits > sf->field->n_bits) {
VLOG_WARN_RL(&rl, "bit offset %d and width %d exceeds %d-bit width "
"of %s field %s", sf->ofs, sf->n_bits,
sf->field->n_bits, type, sf->field->name);
+ return OFPERR_OFPBAC_BAD_SET_LEN;
} else if (flow && !mf_are_prereqs_ok(sf->field, flow)) {
VLOG_WARN_RL(&rl, "%s field %s lacks correct prerequisites",
type, sf->field->name);
+ return OFPERR_OFPBAC_MATCH_INCONSISTENT;
} else {
return 0;
}
-
- return OFPERR_OFPBAC_BAD_ARGUMENT;
}
/* Checks whether 'sf' is valid for reading a subfield out of 'flow'. Returns
if (!error && !sf->field->writable) {
VLOG_WARN_RL(&rl, "destination field %s is not writable",
sf->field->name);
- return OFPERR_OFPBAC_BAD_ARGUMENT;
+ return OFPERR_OFPBAC_BAD_SET_ARGUMENT;
}
return error;
}
case MFF_TUN_FLAGS:
case MFF_METADATA:
case MFF_IN_PORT:
- case MFF_SKB_MARK:
+ case MFF_PKT_MARK:
case MFF_SKB_PRIORITY:
CASE_MFF_REGS:
case MFF_ETH_SRC:
case MFF_TCP_DST:
case MFF_UDP_SRC:
case MFF_UDP_DST:
+ case MFF_SCTP_SRC:
+ case MFF_SCTP_DST:
case MFF_ICMPV4_TYPE:
case MFF_ICMPV4_CODE:
case MFF_ICMPV6_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;
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 (ofputil_port_from_string(s, &port)) {
- *valuep = htons(port);
+ *valuep = htons(ofp_to_u16(port));
*maskp = htons(UINT16_MAX);
return NULL;
}
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 {
const char *name;
uint8_t mask;
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);
}
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 */
* 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
git://git.onelab.eu / sliver-openvswitch.git / blobdiff