/*
- * Copyright (c) 2011, 2012 Nicira, Inc.
+ * Copyright (c) 2011, 2012, 2013 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 "meta-flow.h"
-#include <assert.h>
#include <errno.h>
#include <limits.h>
#include <netinet/icmp6.h>
MFP_NONE,
true,
NXM_NX_TUN_ID, "NXM_NX_TUN_ID",
- NXM_NX_TUN_ID, "NXM_NX_TUN_ID",
+ OXM_OF_TUNNEL_ID, "OXM_OF_TUNNEL_ID",
+ }, {
+ MFF_TUN_SRC, "tun_src", NULL,
+ MF_FIELD_SIZES(be32),
+ MFM_FULLY,
+ MFS_IPV4,
+ MFP_NONE,
+ 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_FULLY,
+ MFS_IPV4,
+ MFP_NONE,
+ 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_TNL_FLAGS,
+ MFP_NONE,
+ false,
+ 0, NULL,
+ 0, NULL,
+ }, {
+ MFF_TUN_TOS, "tun_tos", NULL,
+ MF_FIELD_SIZES(u8),
+ MFM_NONE,
+ MFS_DECIMAL,
+ MFP_NONE,
+ false,
+ 0, NULL,
+ 0, NULL,
+ }, {
+ MFF_TUN_TTL, "tun_ttl", NULL,
+ MF_FIELD_SIZES(u8),
+ MFM_NONE,
+ MFS_DECIMAL,
+ MFP_NONE,
+ false,
+ 0, NULL,
+ 0, NULL,
}, {
MFF_METADATA, "metadata", NULL,
MF_FIELD_SIZES(be64),
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,
+ MF_FIELD_SIZES(be32),
+ MFM_NONE,
+ MFS_HEXADECIMAL,
+ MFP_NONE,
+ false,
+ 0, NULL,
+ 0, NULL,
+ }, {
+ MFF_SKB_MARK, "skb_mark", NULL,
+ MF_FIELD_SIZES(be32),
+ MFM_NONE,
+ MFS_HEXADECIMAL,
+ MFP_NONE,
+ false,
+ 0, NULL,
+ 0, NULL,
},
#define REGISTER(IDX) \
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,
const struct mf_field *
mf_from_id(enum mf_field_id id)
{
- assert((unsigned int) id < MFF_N_IDS);
+ ovs_assert((unsigned int) id < MFF_N_IDS);
return &mf_fields[id];
}
nxm_init_add_field(const struct mf_field *mf, uint32_t header)
{
if (header) {
- assert(!mf_from_nxm_header__(header));
+ ovs_assert(!mf_from_nxm_header__(header));
add_nxm_field(header, mf);
if (mf->maskable != MFM_NONE) {
add_nxm_field(NXM_MAKE_WILD_HEADER(header), mf);
mf_is_all_wild(const struct mf_field *mf, const struct flow_wildcards *wc)
{
switch (mf->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:
return !wc->masks.tunnel.tun_id;
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_REGS:
return !wc->masks.regs[mf->id - MFF_REG0];
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);
mf_get_mask(const struct mf_field *mf, const struct flow_wildcards *wc,
union mf_value *mask)
{
- switch (mf->id) {
- case MFF_TUN_ID:
- mask->be64 = wc->masks.tunnel.tun_id;
- break;
- case MFF_METADATA:
- mask->be64 = wc->masks.metadata;
- break;
- case MFF_IN_PORT:
- mask->be16 = htons(wc->masks.in_port);
- break;
- CASE_MFF_REGS:
- mask->be32 = htonl(wc->masks.regs[mf->id - MFF_REG0]);
- break;
-
- case MFF_ETH_DST:
- memcpy(mask->mac, wc->masks.dl_dst, ETH_ADDR_LEN);
- break;
- case MFF_ETH_SRC:
- memcpy(mask->mac, wc->masks.dl_src, ETH_ADDR_LEN);
- break;
- case MFF_ETH_TYPE:
- mask->be16 = wc->masks.dl_type;
- break;
-
- case MFF_VLAN_TCI:
- mask->be16 = wc->masks.vlan_tci;
- break;
- case MFF_DL_VLAN:
- mask->be16 = wc->masks.vlan_tci & htons(VLAN_VID_MASK);
- break;
- case MFF_VLAN_VID:
- mask->be16 = wc->masks.vlan_tci & htons(VLAN_VID_MASK | VLAN_CFI);
- break;
- case MFF_DL_VLAN_PCP:
- case MFF_VLAN_PCP:
- mask->u8 = vlan_tci_to_pcp(wc->masks.vlan_tci);
- break;
-
- case MFF_IPV4_SRC:
- mask->be32 = wc->masks.nw_src;
- break;
- case MFF_IPV4_DST:
- mask->be32 = wc->masks.nw_dst;
- break;
-
- case MFF_IPV6_SRC:
- mask->ipv6 = wc->masks.ipv6_src;
- break;
- case MFF_IPV6_DST:
- mask->ipv6 = wc->masks.ipv6_dst;
- break;
- case MFF_IPV6_LABEL:
- mask->be32 = wc->masks.ipv6_label;
- break;
-
- case MFF_IP_PROTO:
- mask->u8 = wc->masks.nw_proto;
- break;
- case MFF_IP_DSCP:
- mask->u8 = wc->masks.nw_tos & IP_DSCP_MASK;
- break;
- case MFF_IP_ECN:
- mask->u8 = wc->masks.nw_tos & IP_ECN_MASK;
- break;
-
- case MFF_ND_TARGET:
- mask->ipv6 = wc->masks.nd_target;
- break;
-
- case MFF_IP_TTL:
- mask->u8 = wc->masks.nw_ttl;
- break;
- case MFF_IP_FRAG:
- mask->u8 = wc->masks.nw_frag & FLOW_NW_FRAG_MASK;
- break;
-
- case MFF_ARP_OP:
- mask->u8 = wc->masks.nw_proto;
- break;
- case MFF_ARP_SPA:
- mask->be32 = wc->masks.nw_src;
- break;
- case MFF_ARP_TPA:
- mask->be32 = wc->masks.nw_dst;
- break;
- case MFF_ARP_SHA:
- case MFF_ND_SLL:
- memcpy(mask->mac, wc->masks.arp_sha, ETH_ADDR_LEN);
- break;
- case MFF_ARP_THA:
- case MFF_ND_TLL:
- memcpy(mask->mac, wc->masks.arp_tha, ETH_ADDR_LEN);
- break;
-
- case MFF_TCP_SRC:
- case MFF_UDP_SRC:
- mask->be16 = wc->masks.tp_src;
- break;
- case MFF_TCP_DST:
- case MFF_UDP_DST:
- mask->be16 = wc->masks.tp_dst;
- break;
-
- case MFF_ICMPV4_TYPE:
- case MFF_ICMPV6_TYPE:
- mask->u8 = ntohs(wc->masks.tp_src);
- break;
- case MFF_ICMPV4_CODE:
- case MFF_ICMPV6_CODE:
- mask->u8 = ntohs(wc->masks.tp_dst);
- break;
-
- case MFF_N_IDS:
- default:
- NOT_REACHED();
- }
+ mf_get_value(mf, &wc->masks, mask);
}
/* Tests whether 'mask' is a valid wildcard bit pattern for 'mf'. Returns true
NOT_REACHED();
}
-static bool
-is_ip_any(const struct flow *flow)
-{
- return (flow->dl_type == htons(ETH_TYPE_IP) ||
- flow->dl_type == htons(ETH_TYPE_IPV6));
-}
-
static bool
is_icmpv4(const struct flow *flow)
{
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);
{
switch (mf->id) {
case MFF_TUN_ID:
+ case MFF_TUN_SRC:
+ case MFF_TUN_DST:
+ case MFF_TUN_TOS:
+ case MFF_TUN_TTL:
+ case MFF_TUN_FLAGS:
case MFF_METADATA:
case MFF_IN_PORT:
+ case MFF_SKB_PRIORITY:
+ case MFF_SKB_MARK:
CASE_MFF_REGS:
case MFF_ETH_SRC:
case MFF_ETH_DST:
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();
case MFF_TUN_ID:
value->be64 = flow->tunnel.tun_id;
break;
+ case MFF_TUN_SRC:
+ value->be32 = flow->tunnel.ip_src;
+ break;
+ case MFF_TUN_DST:
+ value->be32 = flow->tunnel.ip_dst;
+ break;
+ case MFF_TUN_FLAGS:
+ value->be16 = htons(flow->tunnel.flags);
+ break;
+ case MFF_TUN_TTL:
+ value->u8 = flow->tunnel.ip_ttl;
+ break;
+ case MFF_TUN_TOS:
+ value->u8 = flow->tunnel.ip_tos;
+ break;
+
case MFF_METADATA:
value->be64 = flow->metadata;
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);
break;
CASE_MFF_REGS:
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;
case MFF_TUN_ID:
match_set_tun_id(match, value->be64);
break;
+ case MFF_TUN_SRC:
+ match_set_tun_src(match, value->be32);
+ break;
+ case MFF_TUN_DST:
+ match_set_tun_dst(match, value->be32);
+ break;
+ case MFF_TUN_FLAGS:
+ match_set_tun_flags(match, ntohs(value->be16));
+ break;
+ case MFF_TUN_TOS:
+ match_set_tun_tos(match, value->u8);
+ break;
+ case MFF_TUN_TTL:
+ match_set_tun_ttl(match, value->u8);
+ break;
+
case MFF_METADATA:
match_set_metadata(match, value->be64);
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));
break;
CASE_MFF_REGS:
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)
case MFF_TUN_ID:
flow->tunnel.tun_id = value->be64;
break;
+ case MFF_TUN_SRC:
+ flow->tunnel.ip_src = value->be32;
+ break;
+ case MFF_TUN_DST:
+ flow->tunnel.ip_dst = value->be32;
+ break;
+ case MFF_TUN_FLAGS:
+ flow->tunnel.flags = ntohs(value->be16);
+ break;
+ case MFF_TUN_TOS:
+ flow->tunnel.ip_tos = value->u8;
+ break;
+ case MFF_TUN_TTL:
+ flow->tunnel.ip_ttl = value->u8;
+ break;
+
case MFF_METADATA:
flow->metadata = value->be64;
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);
break;
CASE_MFF_REGS:
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_TUN_ID:
match_set_tun_id_masked(match, htonll(0), htonll(0));
break;
+ case MFF_TUN_SRC:
+ match_set_tun_src_masked(match, htonl(0), htonl(0));
+ break;
+ case MFF_TUN_DST:
+ match_set_tun_dst_masked(match, htonl(0), htonl(0));
+ break;
+ case MFF_TUN_FLAGS:
+ match_set_tun_flags_masked(match, 0, 0);
+ break;
+ case MFF_TUN_TOS:
+ match_set_tun_tos_masked(match, 0, 0);
+ break;
+ case MFF_TUN_TTL:
+ match_set_tun_ttl_masked(match, 0, 0);
+ break;
+
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->flow.skb_priority = 0;
+ match->wc.masks.skb_priority = 0;
+ break;
+
+ case MFF_SKB_MARK:
+ match->flow.skb_mark = 0;
+ match->wc.masks.skb_mark = 0;
break;
CASE_MFF_REGS:
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_TUN_ID:
match_set_tun_id_masked(match, value->be64, mask->be64);
break;
+ case MFF_TUN_SRC:
+ match_set_tun_src_masked(match, value->be32, mask->be32);
+ break;
+ case MFF_TUN_DST:
+ match_set_tun_dst_masked(match, value->be32, mask->be32);
+ break;
+ case MFF_TUN_FLAGS:
+ match_set_tun_flags_masked(match, ntohs(value->be16), ntohs(mask->be16));
+ break;
+ case MFF_TUN_TTL:
+ match_set_tun_ttl_masked(match, value->u8, mask->u8);
+ break;
+ case MFF_TUN_TOS:
+ match_set_tun_tos_masked(match, value->u8, mask->u8);
+ break;
+
case MFF_METADATA:
match_set_metadata_masked(match, value->be64, mask->be64);
break;
switch (mf->id) {
case MFF_TUN_ID:
+ case MFF_TUN_SRC:
+ case MFF_TUN_DST:
+ case MFF_TUN_TOS:
+ case MFF_TUN_TTL:
+ case MFF_TUN_FLAGS:
case MFF_METADATA:
case MFF_IN_PORT:
+ case MFF_SKB_MARK:
+ case MFF_SKB_PRIORITY:
CASE_MFF_REGS:
case MFF_ETH_SRC:
case MFF_ETH_DST:
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])
{
- assert(mf->n_bytes == ETH_ADDR_LEN);
+ ovs_assert(mf->n_bytes == ETH_ADDR_LEN);
switch (sscanf(s, ETH_ADDR_SCAN_FMT"/"ETH_ADDR_SCAN_FMT,
ETH_ADDR_SCAN_ARGS(mac), ETH_ADDR_SCAN_ARGS(mask))){
{
int prefix;
- assert(mf->n_bytes == sizeof *ip);
+ ovs_assert(mf->n_bytes == sizeof *ip);
if (sscanf(s, IP_SCAN_FMT"/"IP_SCAN_FMT,
IP_SCAN_ARGS(ip), IP_SCAN_ARGS(mask)) == IP_SCAN_COUNT * 2) {
const char *name, *netmask;
int retval;
- assert(mf->n_bytes == sizeof *value);
+ ovs_assert(mf->n_bytes == sizeof *value);
name = strtok_r(str, "/", &save_ptr);
retval = name ? lookup_ipv6(name, value) : EINVAL;
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));
- 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;
- } 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 {
"\"yes\", \"first\", \"later\", \"not_first\"", s);
}
+static int
+parse_flow_tun_flags(const char *s_, const char *(*bit_to_string)(uint32_t),
+ ovs_be16 *res)
+{
+ uint32_t result = 0;
+ char *save_ptr = NULL;
+ char *name;
+ int rc = 0;
+ char *s = xstrdup(s_);
+
+ for (name = strtok_r((char *)s, " |", &save_ptr); name;
+ name = strtok_r(NULL, " |", &save_ptr)) {
+ int name_len;
+ unsigned long long int flags;
+ uint32_t bit;
+ int n0;
+
+ if (sscanf(name, "%lli%n", &flags, &n0) > 0 && n0 > 0) {
+ result |= flags;
+ continue;
+ }
+ name_len = strlen(name);
+ for (bit = 1; bit; bit <<= 1) {
+ const char *fname = bit_to_string(bit);
+ size_t len;
+
+ if (!fname) {
+ continue;
+ }
+
+ len = strlen(fname);
+ if (len != name_len) {
+ continue;
+ }
+ if (!strncmp(name, fname, len)) {
+ result |= bit;
+ break;
+ }
+ }
+
+ if (!bit) {
+ rc = -ENOENT;
+ goto out;
+ }
+ }
+
+ *res = htons(result);
+out:
+ free(s);
+ return rc;
+}
+
+static char *
+mf_from_tun_flags_string(const char *s, ovs_be16 *valuep, ovs_be16 *maskp)
+{
+ if (!parse_flow_tun_flags(s, flow_tun_flag_to_string, valuep)) {
+ *maskp = htons(UINT16_MAX);
+ return NULL;
+ }
+
+ return xasprintf("%s: unknown tunnel flags (valid flags are \"df\", "
+ "\"csum\", \"key\"", s);
+}
+
/* 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 *
mf_parse(const struct mf_field *mf, const char *s,
union mf_value *value, union mf_value *mask)
{
- if (!strcasecmp(s, "any") || !strcmp(s, "*")) {
+ if (!strcmp(s, "*")) {
memset(value, 0, mf->n_bytes);
memset(mask, 0, mf->n_bytes);
return NULL;
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);
+
+ case MFS_TNL_FLAGS:
+ ovs_assert(mf->n_bytes == sizeof(ovs_be16));
+ return mf_from_tun_flags_string(s, &value->be16, &mask->be16);
}
NOT_REACHED();
}
unsigned long long int integer;
int i;
- assert(mf->n_bytes <= 8);
+ ovs_assert(mf->n_bytes <= 8);
integer = 0;
for (i = 0; i < mf->n_bytes; i++) {
}
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) {
ds_put_cstr(s, "<error>");
}
+static void
+mf_format_tnl_flags_string(const ovs_be16 *valuep, struct ds *s)
+{
+ format_flags(s, flow_tun_flag_to_string, ntohs(*valuep), '|');
+}
+
/* 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
}
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:
+ mf_format_tnl_flags_string(&value->be16, s);
break;
default:
git://git.onelab.eu / sliver-openvswitch.git / blobdiff