It looks correct to me. Ben, would you please consider committing it?
Acked-by: Andy Zhou <[email protected]>
git am reported a white space error: patch:28: trailing whitespace.
if (is_mask && ntohs(src_flow->dl_type) < 1536 &&
warning: 1 line adds whitespace errors.
I'd like to further improving the patch in the following area:
1. Modify test-odp.c to make use of this new function.
2. It seems exception handler can be further simplified, but I don't have
any specific suggestion at the moment.
3. Consider Simon's feed back in using ETH_TYPE_MIN in place of the hard
coded 1536.
Thanks,
Andy
On Thu, Aug 15, 2013 at 11:28 PM, <[email protected]> wrote:
> From: gyang <gyang@gyang-virtual-machine.(none)>
>
> With megaflow support, there is API to convert mask to nlattr key based
> format. This change introduces API to do the reverse conversion. We
> leverage the existing odp_flow_key_to_flow() API to resue the code.
>
> Signed-off-by: Guolin Yang <[email protected]>
> ---
> lib/odp-util.c | 295
> +++++++++++++++++++++++++++++++++++++++++---------------
> lib/odp-util.h | 2 +
> 2 files changed, 221 insertions(+), 76 deletions(-)
>
> diff --git a/lib/odp-util.c b/lib/odp-util.c
> index a09042e..e9bb548 100644
> --- a/lib/odp-util.c
> +++ b/lib/odp-util.c
> @@ -2680,20 +2680,34 @@ check_expectations(uint64_t present_attrs, int
> out_of_range_attr,
> static bool
> parse_ethertype(const struct nlattr *attrs[OVS_KEY_ATTR_MAX + 1],
> uint64_t present_attrs, uint64_t *expected_attrs,
> - struct flow *flow)
> + struct flow *flow, struct flow *src_flow)
> {
> static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
> + bool is_mask = flow != src_flow;
>
> if (present_attrs & (UINT64_C(1) << OVS_KEY_ATTR_ETHERTYPE)) {
> flow->dl_type = nl_attr_get_be16(attrs[OVS_KEY_ATTR_ETHERTYPE]);
> - if (ntohs(flow->dl_type) < 1536) {
> + if (!is_mask && ntohs(flow->dl_type) < 1536) {
> VLOG_ERR_RL(&rl, "invalid Ethertype %"PRIu16" in flow key",
> ntohs(flow->dl_type));
> return false;
> }
> + if (is_mask && ntohs(src_flow->dl_type) < 1536 &&
> + flow->dl_type != 0xffff) {
> + return false;
> + }
> *expected_attrs |= UINT64_C(1) << OVS_KEY_ATTR_ETHERTYPE;
> } else {
> - flow->dl_type = htons(FLOW_DL_TYPE_NONE);
> + if (!is_mask) {
> + flow->dl_type = htons(FLOW_DL_TYPE_NONE);
> + } else if (ntohs(src_flow->dl_type) < 1536) {
> + /*
> + * see comments odp_flow_key_from_flow__
> + */
> + VLOG_ERR_RL(&rl, "Alway expect mask for non ethernet II "
> + "frame");
> + return false;
> + }
> }
> return true;
> }
> @@ -2702,20 +2716,43 @@ static enum odp_key_fitness
> parse_l2_5_onward(const struct nlattr *attrs[OVS_KEY_ATTR_MAX + 1],
> uint64_t present_attrs, int out_of_range_attr,
> uint64_t expected_attrs, struct flow *flow,
> - const struct nlattr *key, size_t key_len)
> + const struct nlattr *key, size_t key_len,
> + struct flow *src_flow)
> {
> static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
> -
> - if (eth_type_mpls(flow->dl_type)) {
> - expected_attrs |= (UINT64_C(1) << OVS_KEY_ATTR_MPLS);
> -
> - if (!(present_attrs & (UINT64_C(1) << OVS_KEY_ATTR_MPLS))) {
> - return ODP_FIT_TOO_LITTLE;
> + bool is_mask = src_flow != flow;
> + const uint8_t *checkStart = NULL;
> + size_t checkLen = 0;
> + enum ovs_key_attr expected_bit = 0xff;
> +
> + if (eth_type_mpls(src_flow->dl_type)) {
> + if (!is_mask) {
> + expected_attrs |= (UINT64_C(1) << OVS_KEY_ATTR_MPLS);
> +
> + if (!(present_attrs & (UINT64_C(1) << OVS_KEY_ATTR_MPLS))) {
> + return ODP_FIT_TOO_LITTLE;
> + }
> + flow->mpls_lse = nl_attr_get_be32(attrs[OVS_KEY_ATTR_MPLS]);
> + flow->mpls_depth++;
> + } else if (present_attrs & (UINT64_C(1) << OVS_KEY_ATTR_MPLS)) {
> + flow->mpls_lse = nl_attr_get_be32(attrs[OVS_KEY_ATTR_MPLS]);
> +
> + if (flow->mpls_lse != 0 && flow->dl_type != 0xffff) {
> + return ODP_FIT_ERROR;
> + }
> + expected_attrs |= (UINT64_C(1) << OVS_KEY_ATTR_MPLS);
> + if (flow->mpls_lse) {
> + /*
> + * do we need to set the following? XXX
> + */
> + flow->mpls_depth = 0xffff;
> + }
> + }
> + goto done;
> + } else if (src_flow->dl_type == htons(ETH_TYPE_IP)) {
> + if (!is_mask) {
> + expected_attrs |= UINT64_C(1) << OVS_KEY_ATTR_IPV4;
> }
> - flow->mpls_lse = nl_attr_get_be32(attrs[OVS_KEY_ATTR_MPLS]);
> - flow->mpls_depth++;
> - } else if (flow->dl_type == htons(ETH_TYPE_IP)) {
> - expected_attrs |= UINT64_C(1) << OVS_KEY_ATTR_IPV4;
> if (present_attrs & (UINT64_C(1) << OVS_KEY_ATTR_IPV4)) {
> const struct ovs_key_ipv4 *ipv4_key;
>
> @@ -2725,12 +2762,19 @@ parse_l2_5_onward(const struct nlattr
> *attrs[OVS_KEY_ATTR_MAX + 1],
> flow->nw_proto = ipv4_key->ipv4_proto;
> flow->nw_tos = ipv4_key->ipv4_tos;
> flow->nw_ttl = ipv4_key->ipv4_ttl;
> - if (!odp_to_ovs_frag(ipv4_key->ipv4_frag, flow)) {
> + if (is_mask) {
> + flow->nw_frag = ipv4_key->ipv4_frag;
> + checkStart = (const uint8_t *)ipv4_key;
> + checkLen = sizeof (struct ovs_key_ipv4);
> + expected_bit = OVS_KEY_ATTR_IPV4;
> + } else if (!odp_to_ovs_frag(ipv4_key->ipv4_frag, flow)) {
> return ODP_FIT_ERROR;
> }
> }
> - } else if (flow->dl_type == htons(ETH_TYPE_IPV6)) {
> - expected_attrs |= UINT64_C(1) << OVS_KEY_ATTR_IPV6;
> + } else if (src_flow->dl_type == htons(ETH_TYPE_IPV6)) {
> + if (!is_mask) {
> + expected_attrs |= UINT64_C(1) << OVS_KEY_ATTR_IPV6;
> + }
> if (present_attrs & (UINT64_C(1) << OVS_KEY_ATTR_IPV6)) {
> const struct ovs_key_ipv6 *ipv6_key;
>
> @@ -2741,20 +2785,27 @@ parse_l2_5_onward(const struct nlattr
> *attrs[OVS_KEY_ATTR_MAX + 1],
> flow->nw_proto = ipv6_key->ipv6_proto;
> flow->nw_tos = ipv6_key->ipv6_tclass;
> flow->nw_ttl = ipv6_key->ipv6_hlimit;
> - if (!odp_to_ovs_frag(ipv6_key->ipv6_frag, flow)) {
> + if (is_mask) {
> + flow->nw_frag = ipv6_key->ipv6_frag;
> + checkStart = (const uint8_t *)ipv6_key;
> + checkLen = sizeof (struct ovs_key_ipv6);
> + expected_bit = OVS_KEY_ATTR_IPV6;
> + } else if (!odp_to_ovs_frag(ipv6_key->ipv6_frag, flow)) {
> return ODP_FIT_ERROR;
> }
> }
> - } else if (flow->dl_type == htons(ETH_TYPE_ARP) ||
> - flow->dl_type == htons(ETH_TYPE_RARP)) {
> - expected_attrs |= UINT64_C(1) << OVS_KEY_ATTR_ARP;
> + } else if (src_flow->dl_type == htons(ETH_TYPE_ARP) ||
> + src_flow->dl_type == htons(ETH_TYPE_RARP)) {
> + if (!is_mask) {
> + expected_attrs |= UINT64_C(1) << OVS_KEY_ATTR_ARP;
> + }
> if (present_attrs & (UINT64_C(1) << OVS_KEY_ATTR_ARP)) {
> const struct ovs_key_arp *arp_key;
>
> arp_key = nl_attr_get(attrs[OVS_KEY_ATTR_ARP]);
> flow->nw_src = arp_key->arp_sip;
> flow->nw_dst = arp_key->arp_tip;
> - if (arp_key->arp_op & htons(0xff00)) {
> + if (!is_mask && (arp_key->arp_op & htons(0xff00))) {
> VLOG_ERR_RL(&rl, "unsupported ARP opcode %"PRIu16" in
> flow "
> "key", ntohs(arp_key->arp_op));
> return ODP_FIT_ERROR;
> @@ -2762,58 +2813,87 @@ parse_l2_5_onward(const struct nlattr
> *attrs[OVS_KEY_ATTR_MAX + 1],
> flow->nw_proto = ntohs(arp_key->arp_op);
> memcpy(flow->arp_sha, arp_key->arp_sha, ETH_ADDR_LEN);
> memcpy(flow->arp_tha, arp_key->arp_tha, ETH_ADDR_LEN);
> +
> + if (is_mask) {
> + checkStart = (const uint8_t *)arp_key;
> + checkLen = sizeof (struct ovs_key_arp);
> + expected_bit = OVS_KEY_ATTR_ARP;
> + }
> + }
> + } else {
> + goto done;
> + }
> + if (is_mask) {
> + if (!is_all_zeros(checkStart, checkLen) && flow->dl_type !=
> 0xffff) {
> + return ODP_FIT_ERROR;
> + } else {
> + expected_attrs |= UINT64_C(1) << expected_bit;
> }
> }
>
> - if (flow->nw_proto == IPPROTO_TCP
> - && (flow->dl_type == htons(ETH_TYPE_IP) ||
> - flow->dl_type == htons(ETH_TYPE_IPV6))
> - && !(flow->nw_frag & FLOW_NW_FRAG_LATER)) {
> - expected_attrs |= UINT64_C(1) << OVS_KEY_ATTR_TCP;
> + expected_bit = 0xff; /* initialize to invalid bitsa*/
> + if (src_flow->nw_proto == IPPROTO_TCP
> + && (src_flow->dl_type == htons(ETH_TYPE_IP) ||
> + src_flow->dl_type == htons(ETH_TYPE_IPV6))
> + && !(src_flow->nw_frag & FLOW_NW_FRAG_LATER)) {
> + if (!is_mask) {
> + expected_attrs |= UINT64_C(1) << OVS_KEY_ATTR_TCP;
> + }
> if (present_attrs & (UINT64_C(1) << OVS_KEY_ATTR_TCP)) {
> const struct ovs_key_tcp *tcp_key;
>
> tcp_key = nl_attr_get(attrs[OVS_KEY_ATTR_TCP]);
> flow->tp_src = tcp_key->tcp_src;
> flow->tp_dst = tcp_key->tcp_dst;
> + expected_bit = OVS_KEY_ATTR_TCP;
> + }
> + } else if (src_flow->nw_proto == IPPROTO_UDP
> + && (src_flow->dl_type == htons(ETH_TYPE_IP) ||
> + src_flow->dl_type == htons(ETH_TYPE_IPV6))
> + && !(src_flow->nw_frag & FLOW_NW_FRAG_LATER)) {
> + if (!is_mask) {
> + expected_attrs |= UINT64_C(1) << OVS_KEY_ATTR_UDP;
> }
> - } else if (flow->nw_proto == IPPROTO_UDP
> - && (flow->dl_type == htons(ETH_TYPE_IP) ||
> - flow->dl_type == htons(ETH_TYPE_IPV6))
> - && !(flow->nw_frag & FLOW_NW_FRAG_LATER)) {
> - expected_attrs |= UINT64_C(1) << OVS_KEY_ATTR_UDP;
> if (present_attrs & (UINT64_C(1) << OVS_KEY_ATTR_UDP)) {
> const struct ovs_key_udp *udp_key;
>
> udp_key = nl_attr_get(attrs[OVS_KEY_ATTR_UDP]);
> flow->tp_src = udp_key->udp_src;
> flow->tp_dst = udp_key->udp_dst;
> + expected_bit = OVS_KEY_ATTR_UDP;
> + }
> + } else if (src_flow->nw_proto == IPPROTO_ICMP
> + && src_flow->dl_type == htons(ETH_TYPE_IP)
> + && !(src_flow->nw_frag & FLOW_NW_FRAG_LATER)) {
> + if (!is_mask) {
> + expected_attrs |= UINT64_C(1) << OVS_KEY_ATTR_ICMP;
> }
> - } else if (flow->nw_proto == IPPROTO_ICMP
> - && flow->dl_type == htons(ETH_TYPE_IP)
> - && !(flow->nw_frag & FLOW_NW_FRAG_LATER)) {
> - expected_attrs |= UINT64_C(1) << OVS_KEY_ATTR_ICMP;
> if (present_attrs & (UINT64_C(1) << OVS_KEY_ATTR_ICMP)) {
> const struct ovs_key_icmp *icmp_key;
>
> icmp_key = nl_attr_get(attrs[OVS_KEY_ATTR_ICMP]);
> flow->tp_src = htons(icmp_key->icmp_type);
> flow->tp_dst = htons(icmp_key->icmp_code);
> + expected_bit = OVS_KEY_ATTR_ICMP;
> + }
> + } else if (src_flow->nw_proto == IPPROTO_ICMPV6
> + && src_flow->dl_type == htons(ETH_TYPE_IPV6)
> + && !(src_flow->nw_frag & FLOW_NW_FRAG_LATER)) {
> + if (!is_mask) {
> + expected_attrs |= UINT64_C(1) << OVS_KEY_ATTR_ICMPV6;
> }
> - } else if (flow->nw_proto == IPPROTO_ICMPV6
> - && flow->dl_type == htons(ETH_TYPE_IPV6)
> - && !(flow->nw_frag & FLOW_NW_FRAG_LATER)) {
> - expected_attrs |= UINT64_C(1) << OVS_KEY_ATTR_ICMPV6;
> if (present_attrs & (UINT64_C(1) << OVS_KEY_ATTR_ICMPV6)) {
> const struct ovs_key_icmpv6 *icmpv6_key;
>
> icmpv6_key = nl_attr_get(attrs[OVS_KEY_ATTR_ICMPV6]);
> flow->tp_src = htons(icmpv6_key->icmpv6_type);
> flow->tp_dst = htons(icmpv6_key->icmpv6_code);
> -
> - if (flow->tp_src == htons(ND_NEIGHBOR_SOLICIT) ||
> - flow->tp_src == htons(ND_NEIGHBOR_ADVERT)) {
> - expected_attrs |= UINT64_C(1) << OVS_KEY_ATTR_ND;
> + expected_bit = OVS_KEY_ATTR_ICMPV6;
> + if (src_flow->tp_src == htons(ND_NEIGHBOR_SOLICIT) ||
> + src_flow->tp_src == htons(ND_NEIGHBOR_ADVERT)) {
> + if (!is_mask) {
> + expected_attrs |= UINT64_C(1) << OVS_KEY_ATTR_ND;
> + }
> if (present_attrs & (UINT64_C(1) << OVS_KEY_ATTR_ND)) {
> const struct ovs_key_nd *nd_key;
>
> @@ -2822,11 +2902,28 @@ parse_l2_5_onward(const struct nlattr
> *attrs[OVS_KEY_ATTR_MAX + 1],
> sizeof flow->nd_target);
> memcpy(flow->arp_sha, nd_key->nd_sll, ETH_ADDR_LEN);
> memcpy(flow->arp_tha, nd_key->nd_tll, ETH_ADDR_LEN);
> + if (is_mask) {
> + if (!is_all_zeros((const uint8_t *)nd_key,
> + sizeof (struct ovs_key_nd)) &&
> + flow->tp_src != 0xffff) {
> + return ODP_FIT_ERROR;
> + } else {
> + expected_attrs |= UINT64_C(1) <<
> OVS_KEY_ATTR_ND;
> + }
> + }
> }
> }
> }
> }
> + if (is_mask && expected_bit != 0xff) {
> + if ((flow->tp_src || flow->tp_dst) && flow->nw_proto != 0xff) {
> + return ODP_FIT_ERROR;
> + } else {
> + expected_attrs |= UINT64_C(1) << expected_bit;
> + }
> + }
>
> +done:
> return check_expectations(present_attrs, out_of_range_attr,
> expected_attrs,
> key, key_len);
> }
> @@ -2836,9 +2933,11 @@ static enum odp_key_fitness
> parse_8021q_onward(const struct nlattr *attrs[OVS_KEY_ATTR_MAX + 1],
> uint64_t present_attrs, int out_of_range_attr,
> uint64_t expected_attrs, struct flow *flow,
> - const struct nlattr *key, size_t key_len)
> + const struct nlattr *key, size_t key_len,
> + struct flow *src_flow)
> {
> static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
> + bool is_mask = src_flow != flow;
>
> const struct nlattr *encap
> = (present_attrs & (UINT64_C(1) << OVS_KEY_ATTR_ENCAP)
> @@ -2848,33 +2947,47 @@ parse_8021q_onward(const struct nlattr
> *attrs[OVS_KEY_ATTR_MAX + 1],
> ovs_be16 tci;
>
> /* Calculate fitness of outer attributes. */
> - expected_attrs |= ((UINT64_C(1) << OVS_KEY_ATTR_VLAN) |
> - (UINT64_C(1) << OVS_KEY_ATTR_ENCAP));
> + if (!is_mask) {
> + expected_attrs |= ((UINT64_C(1) << OVS_KEY_ATTR_VLAN) |
> + (UINT64_C(1) << OVS_KEY_ATTR_ENCAP));
> + } else {
> + if (present_attrs & (UINT64_C(1) << OVS_KEY_ATTR_VLAN)) {
> + expected_attrs |= (UINT64_C(1) << OVS_KEY_ATTR_VLAN);
> + }
> + if (present_attrs & (UINT64_C(1) << OVS_KEY_ATTR_ENCAP)) {
> + expected_attrs |= (UINT64_C(1) << OVS_KEY_ATTR_ENCAP);
> + }
> + }
> fitness = check_expectations(present_attrs, out_of_range_attr,
> expected_attrs, key, key_len);
>
> /* Get the VLAN TCI value. */
> - if (!(present_attrs & (UINT64_C(1) << OVS_KEY_ATTR_VLAN))) {
> + if (!is_mask && !(present_attrs & (UINT64_C(1) <<
> OVS_KEY_ATTR_VLAN))) {
> return ODP_FIT_TOO_LITTLE;
> - }
> - tci = nl_attr_get_be16(attrs[OVS_KEY_ATTR_VLAN]);
> - if (tci == htons(0)) {
> - /* Corner case for a truncated 802.1Q header. */
> - if (fitness == ODP_FIT_PERFECT && nl_attr_get_size(encap)) {
> - return ODP_FIT_TOO_MUCH;
> - }
> + } else {
> + tci = nl_attr_get_be16(attrs[OVS_KEY_ATTR_VLAN]);
> + if (!is_mask) {
> + if (tci == htons(0)) {
> + /* Corner case for a truncated 802.1Q header. */
> + if (fitness == ODP_FIT_PERFECT && nl_attr_get_size(encap))
> {
> + return ODP_FIT_TOO_MUCH;
> + }
> + return fitness;
> + } else if (!(tci & htons(VLAN_CFI))) {
> + VLOG_ERR_RL(&rl, "OVS_KEY_ATTR_VLAN 0x%04"PRIx16" is
> nonzero "
> + "but CFI bit is not set", ntohs(tci));
> + return ODP_FIT_ERROR;
> + }
> + }
> + /* Set vlan_tci.
> + * Remove the TPID from dl_type since it's not the real
> Ethertype. */
> + flow->dl_type = htons(0);
> + flow->vlan_tci = tci;
> + }
> +
> + if (is_mask && !(present_attrs & (UINT64_C(1) <<
> OVS_KEY_ATTR_ENCAP))) {
> return fitness;
> - } else if (!(tci & htons(VLAN_CFI))) {
> - VLOG_ERR_RL(&rl, "OVS_KEY_ATTR_VLAN 0x%04"PRIx16" is nonzero "
> - "but CFI bit is not set", ntohs(tci));
> - return ODP_FIT_ERROR;
> }
> -
> - /* Set vlan_tci.
> - * Remove the TPID from dl_type since it's not the real Ethertype. */
> - flow->vlan_tci = tci;
> - flow->dl_type = htons(0);
> -
> /* Now parse the encapsulated attributes. */
> if (!parse_flow_nlattrs(nl_attr_get(encap), nl_attr_get_size(encap),
> attrs, &present_attrs, &out_of_range_attr)) {
> @@ -2882,11 +2995,12 @@ parse_8021q_onward(const struct nlattr
> *attrs[OVS_KEY_ATTR_MAX + 1],
> }
> expected_attrs = 0;
>
> - if (!parse_ethertype(attrs, present_attrs, &expected_attrs, flow)) {
> + if (!parse_ethertype(attrs, present_attrs, &expected_attrs, flow,
> src_flow)) {
> return ODP_FIT_ERROR;
> }
> encap_fitness = parse_l2_5_onward(attrs, present_attrs,
> out_of_range_attr,
> - expected_attrs, flow, key, key_len);
> + expected_attrs, flow, key, key_len,
> + src_flow);
>
> /* The overall fitness is the worse of the outer and inner
> attributes. */
> return MAX(fitness, encap_fitness);
> @@ -2907,14 +3021,15 @@ parse_8021q_onward(const struct nlattr
> *attrs[OVS_KEY_ATTR_MAX + 1],
> * protocol in OVS_KEY_ATTR_IPV4 or OVS_KEY_ATTR_IPV6 is IPPROTO_TCP then
> we
> * know that a OVS_KEY_ATTR_TCP attribute must appear and that otherwise
> it
> * must be absent. */
> -enum odp_key_fitness
> -odp_flow_key_to_flow(const struct nlattr *key, size_t key_len,
> - struct flow *flow)
> +static enum odp_key_fitness
> +odp_flow_key_to_flow__(const struct nlattr *key, size_t key_len,
> + struct flow *flow, struct flow *src_flow)
> {
> const struct nlattr *attrs[OVS_KEY_ATTR_MAX + 1];
> uint64_t expected_attrs;
> uint64_t present_attrs;
> int out_of_range_attr;
> + bool is_mask = src_flow != flow;
>
> memset(flow, 0, sizeof *flow);
>
> @@ -2951,7 +3066,7 @@ odp_flow_key_to_flow(const struct nlattr *key,
> size_t key_len,
> flow->in_port.odp_port
> = nl_attr_get_odp_port(attrs[OVS_KEY_ATTR_IN_PORT]);
> expected_attrs |= UINT64_C(1) << OVS_KEY_ATTR_IN_PORT;
> - } else {
> + } else if (!is_mask) {
> flow->in_port.odp_port = ODPP_NONE;
> }
>
> @@ -2962,20 +3077,48 @@ odp_flow_key_to_flow(const struct nlattr *key,
> size_t key_len,
> eth_key = nl_attr_get(attrs[OVS_KEY_ATTR_ETHERNET]);
> memcpy(flow->dl_src, eth_key->eth_src, ETH_ADDR_LEN);
> memcpy(flow->dl_dst, eth_key->eth_dst, ETH_ADDR_LEN);
> + if (is_mask) {
> + expected_attrs |= UINT64_C(1) << OVS_KEY_ATTR_ETHERNET;
> + }
> + }
> + if (!is_mask) {
> + expected_attrs |= UINT64_C(1) << OVS_KEY_ATTR_ETHERNET;
> }
> - expected_attrs |= UINT64_C(1) << OVS_KEY_ATTR_ETHERNET;
>
> /* Get Ethertype or 802.1Q TPID or FLOW_DL_TYPE_NONE. */
> - if (!parse_ethertype(attrs, present_attrs, &expected_attrs, flow)) {
> + if (!parse_ethertype(attrs, present_attrs, &expected_attrs, flow,
> + src_flow)) {
> return ODP_FIT_ERROR;
> }
>
> - if (flow->dl_type == htons(ETH_TYPE_VLAN)) {
> + if ((is_mask && (src_flow->vlan_tci & htons(VLAN_CFI))) ||
> + (!is_mask && src_flow->dl_type == htons(ETH_TYPE_VLAN))) {
> return parse_8021q_onward(attrs, present_attrs, out_of_range_attr,
> - expected_attrs, flow, key, key_len);
> + expected_attrs, flow, key, key_len,
> src_flow);
> + }
> + if (is_mask) {
> + flow->vlan_tci = 0xffff;
> + if (present_attrs & (UINT64_C(1) << OVS_KEY_ATTR_VLAN)) {
> + flow->vlan_tci = nl_attr_get_be16(attrs[OVS_KEY_ATTR_VLAN]);
> + expected_attrs |= (UINT64_C(1) << OVS_KEY_ATTR_VLAN);
> + }
> }
> return parse_l2_5_onward(attrs, present_attrs, out_of_range_attr,
> - expected_attrs, flow, key, key_len);
> + expected_attrs, flow, key, key_len,
> src_flow);
> +}
> +
> +enum odp_key_fitness
> +odp_flow_key_to_flow(const struct nlattr *key, size_t key_len,
> + struct flow *flow)
> +{
> + return odp_flow_key_to_flow__(key, key_len, flow, flow);
> +}
> +
> +enum odp_key_fitness
> +odp_flow_key_to_mask(const struct nlattr *key, size_t key_len,
> + struct flow *mask, struct flow *flow)
> +{
> + return odp_flow_key_to_flow__(key, key_len, mask, flow);
> }
>
> /* Returns 'fitness' as a string, for use in debug messages. */
> diff --git a/lib/odp-util.h b/lib/odp-util.h
> index 0c40f38..cc18dca 100644
> --- a/lib/odp-util.h
> +++ b/lib/odp-util.h
> @@ -122,6 +122,8 @@ enum odp_key_fitness {
> };
> enum odp_key_fitness odp_flow_key_to_flow(const struct nlattr *, size_t,
> struct flow *);
> +enum odp_key_fitness odp_flow_key_to_mask(const struct nlattr *key,
> size_t len,
> + struct flow *mask, struct flow
> *flow);
> const char *odp_key_fitness_to_string(enum odp_key_fitness);
>
> void commit_odp_tunnel_action(const struct flow *, struct flow *base,
> --
> 1.7.9.5
>
> _______________________________________________
> dev mailing list
> [email protected]
> http://openvswitch.org/mailman/listinfo/dev
>
_______________________________________________
dev mailing list
[email protected]
http://openvswitch.org/mailman/listinfo/dev
