]> git.droids-corp.org - dpdk.git/commitdiff
net/ice: fix flow API tunnel rule
authorQiming Yang <qiming.yang@intel.com>
Mon, 15 Jul 2019 09:40:52 +0000 (17:40 +0800)
committerFerruh Yigit <ferruh.yigit@intel.com>
Tue, 23 Jul 2019 12:31:35 +0000 (14:31 +0200)
If the input set is outer or inner protocol was distinguished by
checking if the item appears once or twice.

But this is not working when the user doesn't configure the outer
input set, this patch fixes the issue.

Fixes: d76116a4678f ("net/ice: add generic flow API")
Signed-off-by: Qiming Yang <qiming.yang@intel.com>
Acked-by: Qi Zhang <qi.z.zhang@intel.com>
drivers/net/ice/ice_generic_flow.c

index e6a2c4b1637b93dbdf7c4d98de23fc9dab79a21b..05a1678fc0582ebd9faedf550bb8d87749dc8868 100644 (file)
@@ -209,8 +209,7 @@ static uint64_t ice_get_flow_field(const struct rte_flow_item pattern[],
                0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
                0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
        uint64_t input_set = ICE_INSET_NONE;
-       bool outer_ip = true;
-       bool outer_l4 = true;
+       bool is_tunnel = false;
 
        for (; item->type != RTE_FLOW_ITEM_TYPE_END; item++) {
                if (item->last) {
@@ -259,27 +258,26 @@ static uint64_t ice_get_flow_field(const struct rte_flow_item pattern[],
                                return 0;
                        }
 
-                       if (outer_ip) {
+                       if (is_tunnel) {
                                if (ipv4_mask->hdr.src_addr == UINT32_MAX)
-                                       input_set |= ICE_INSET_IPV4_SRC;
+                                       input_set |= ICE_INSET_TUN_IPV4_SRC;
                                if (ipv4_mask->hdr.dst_addr == UINT32_MAX)
-                                       input_set |= ICE_INSET_IPV4_DST;
-                               if (ipv4_mask->hdr.type_of_service == UINT8_MAX)
-                                       input_set |= ICE_INSET_IPV4_TOS;
+                                       input_set |= ICE_INSET_TUN_IPV4_DST;
                                if (ipv4_mask->hdr.time_to_live == UINT8_MAX)
-                                       input_set |= ICE_INSET_IPV4_TTL;
+                                       input_set |= ICE_INSET_TUN_IPV4_TTL;
                                if (ipv4_mask->hdr.next_proto_id == UINT8_MAX)
-                                       input_set |= ICE_INSET_IPV4_PROTO;
-                               outer_ip = false;
+                                       input_set |= ICE_INSET_TUN_IPV4_PROTO;
                        } else {
                                if (ipv4_mask->hdr.src_addr == UINT32_MAX)
-                                       input_set |= ICE_INSET_TUN_IPV4_SRC;
+                                       input_set |= ICE_INSET_IPV4_SRC;
                                if (ipv4_mask->hdr.dst_addr == UINT32_MAX)
-                                       input_set |= ICE_INSET_TUN_IPV4_DST;
+                                       input_set |= ICE_INSET_IPV4_DST;
                                if (ipv4_mask->hdr.time_to_live == UINT8_MAX)
-                                       input_set |= ICE_INSET_TUN_IPV4_TTL;
+                                       input_set |= ICE_INSET_IPV4_TTL;
                                if (ipv4_mask->hdr.next_proto_id == UINT8_MAX)
-                                       input_set |= ICE_INSET_TUN_IPV4_PROTO;
+                                       input_set |= ICE_INSET_IPV4_PROTO;
+                               if (ipv4_mask->hdr.type_of_service == UINT8_MAX)
+                                       input_set |= ICE_INSET_IPV4_TOS;
                        }
                        break;
                case RTE_FLOW_ITEM_TYPE_IPV6:
@@ -302,33 +300,32 @@ static uint64_t ice_get_flow_field(const struct rte_flow_item pattern[],
                                return 0;
                        }
 
-                       if (outer_ip) {
+                       if (is_tunnel) {
                                if (!memcmp(ipv6_mask->hdr.src_addr,
                                            ipv6_addr_mask,
                                            RTE_DIM(ipv6_mask->hdr.src_addr)))
-                                       input_set |= ICE_INSET_IPV6_SRC;
+                                       input_set |= ICE_INSET_TUN_IPV6_SRC;
                                if (!memcmp(ipv6_mask->hdr.dst_addr,
                                            ipv6_addr_mask,
                                            RTE_DIM(ipv6_mask->hdr.dst_addr)))
-                                       input_set |= ICE_INSET_IPV6_DST;
+                                       input_set |= ICE_INSET_TUN_IPV6_DST;
                                if (ipv6_mask->hdr.proto == UINT8_MAX)
-                                       input_set |= ICE_INSET_IPV6_PROTO;
+                                       input_set |= ICE_INSET_TUN_IPV6_PROTO;
                                if (ipv6_mask->hdr.hop_limits == UINT8_MAX)
-                                       input_set |= ICE_INSET_IPV6_HOP_LIMIT;
-                               outer_ip = false;
+                                       input_set |= ICE_INSET_TUN_IPV6_TTL;
                        } else {
                                if (!memcmp(ipv6_mask->hdr.src_addr,
                                            ipv6_addr_mask,
                                            RTE_DIM(ipv6_mask->hdr.src_addr)))
-                                       input_set |= ICE_INSET_TUN_IPV6_SRC;
+                                       input_set |= ICE_INSET_IPV6_SRC;
                                if (!memcmp(ipv6_mask->hdr.dst_addr,
                                            ipv6_addr_mask,
                                            RTE_DIM(ipv6_mask->hdr.dst_addr)))
-                                       input_set |= ICE_INSET_TUN_IPV6_DST;
+                                       input_set |= ICE_INSET_IPV6_DST;
                                if (ipv6_mask->hdr.proto == UINT8_MAX)
-                                       input_set |= ICE_INSET_TUN_IPV6_PROTO;
+                                       input_set |= ICE_INSET_IPV6_PROTO;
                                if (ipv6_mask->hdr.hop_limits == UINT8_MAX)
-                                       input_set |= ICE_INSET_TUN_IPV6_TTL;
+                                       input_set |= ICE_INSET_IPV6_HOP_LIMIT;
                        }
 
                        break;
@@ -353,17 +350,16 @@ static uint64_t ice_get_flow_field(const struct rte_flow_item pattern[],
                                return 0;
                        }
 
-                       if (outer_l4) {
+                       if (is_tunnel) {
                                if (udp_mask->hdr.src_port == UINT16_MAX)
-                                       input_set |= ICE_INSET_SRC_PORT;
+                                       input_set |= ICE_INSET_TUN_SRC_PORT;
                                if (udp_mask->hdr.dst_port == UINT16_MAX)
-                                       input_set |= ICE_INSET_DST_PORT;
-                               outer_l4 = false;
+                                       input_set |= ICE_INSET_TUN_DST_PORT;
                        } else {
                                if (udp_mask->hdr.src_port == UINT16_MAX)
-                                       input_set |= ICE_INSET_TUN_SRC_PORT;
+                                       input_set |= ICE_INSET_SRC_PORT;
                                if (udp_mask->hdr.dst_port == UINT16_MAX)
-                                       input_set |= ICE_INSET_TUN_DST_PORT;
+                                       input_set |= ICE_INSET_DST_PORT;
                        }
 
                        break;
@@ -393,17 +389,16 @@ static uint64_t ice_get_flow_field(const struct rte_flow_item pattern[],
                                return 0;
                        }
 
-                       if (outer_l4) {
+                       if (is_tunnel) {
                                if (tcp_mask->hdr.src_port == UINT16_MAX)
-                                       input_set |= ICE_INSET_SRC_PORT;
+                                       input_set |= ICE_INSET_TUN_SRC_PORT;
                                if (tcp_mask->hdr.dst_port == UINT16_MAX)
-                                       input_set |= ICE_INSET_DST_PORT;
-                               outer_l4 = false;
+                                       input_set |= ICE_INSET_TUN_DST_PORT;
                        } else {
                                if (tcp_mask->hdr.src_port == UINT16_MAX)
-                                       input_set |= ICE_INSET_TUN_SRC_PORT;
+                                       input_set |= ICE_INSET_SRC_PORT;
                                if (tcp_mask->hdr.dst_port == UINT16_MAX)
-                                       input_set |= ICE_INSET_TUN_DST_PORT;
+                                       input_set |= ICE_INSET_DST_PORT;
                        }
 
                        break;
@@ -427,17 +422,16 @@ static uint64_t ice_get_flow_field(const struct rte_flow_item pattern[],
                                return 0;
                        }
 
-                       if (outer_l4) {
+                       if (is_tunnel) {
                                if (sctp_mask->hdr.src_port == UINT16_MAX)
-                                       input_set |= ICE_INSET_SRC_PORT;
+                                       input_set |= ICE_INSET_TUN_SRC_PORT;
                                if (sctp_mask->hdr.dst_port == UINT16_MAX)
-                                       input_set |= ICE_INSET_DST_PORT;
-                               outer_l4 = false;
+                                       input_set |= ICE_INSET_TUN_DST_PORT;
                        } else {
                                if (sctp_mask->hdr.src_port == UINT16_MAX)
-                                       input_set |= ICE_INSET_TUN_SRC_PORT;
+                                       input_set |= ICE_INSET_SRC_PORT;
                                if (sctp_mask->hdr.dst_port == UINT16_MAX)
-                                       input_set |= ICE_INSET_TUN_DST_PORT;
+                                       input_set |= ICE_INSET_DST_PORT;
                        }
 
                        break;
@@ -486,6 +480,7 @@ static uint64_t ice_get_flow_field(const struct rte_flow_item pattern[],
                                           "Invalid VXLAN item");
                                return 0;
                        }
+                       is_tunnel = 1;
 
                        break;
                case RTE_FLOW_ITEM_TYPE_NVGRE:
@@ -503,6 +498,7 @@ static uint64_t ice_get_flow_field(const struct rte_flow_item pattern[],
                                           "Invalid NVGRE item");
                                return 0;
                        }
+                       is_tunnel = 1;
 
                        break;
                default: