net/ice: support flow priority for DCF switch filter

Support rte flow priority attribute for DCF switch filter.
When a packet is matched by two rules, the behavior of it
is not defined. This patch supports flow priority to create
different recipes for this situation. Only priority 0 and 1
are supported and higher value denotes higher priority.

for example:
1. flow create 0 priority 0 ingress pattern eth / vlan tci is 2 / vlan
   tci is 2 / end actions vf id 2 / end
2. flow create 0 priority 1 ingress pattern eth / vlan / vlan / ipv4 dst
   is 192.168.0.1 / end actions vf id 1 / end

These two rules can be created at the same time in DCF switch
filter and priority of rule 2 is higher. Packet hits rule 2
when two conditions of rules are satisfied.

Signed-off-by: Yuying Zhang <yuying.zhang@intel.com>
Acked-by: Qi Zhang <qi.z.zhang@intel.com>

diff --git a/doc/guides/rel_notes/release_21_05.rst b/doc/guides/rel_notes/release_21_05.rst
index bfd0e89..6a9cdc0 100644 (file)
--- a/doc/guides/rel_notes/release_21_05.rst
+++ b/doc/guides/rel_notes/release_21_05.rst
@@ -128,6 +128,7 @@ New Features
 
   * Added Intel ice support on Windows.
   * Added GTPU TEID support for DCF switch filter.
+  * Added flow priority support for DCF switch filter.
 
 * **Updated Marvell OCTEON TX2 ethdev driver.**
 

diff --git a/drivers/net/ice/ice_acl_filter.c b/drivers/net/ice/ice_acl_filter.c
index 9e06e8a..3375609 100644 (file)
--- a/drivers/net/ice/ice_acl_filter.c
+++ b/drivers/net/ice/ice_acl_filter.c
@@ -904,6 +904,7 @@ ice_acl_parse(struct ice_adapter *ad,
               uint32_t array_len,
               const struct rte_flow_item pattern[],
               const struct rte_flow_action actions[],
+              uint32_t priority __rte_unused,
               void **meta,
               struct rte_flow_error *error)
 {

diff --git a/drivers/net/ice/ice_fdir_filter.c b/drivers/net/ice/ice_fdir_filter.c
index 92e18d5..3b8ea32 100644 (file)
--- a/drivers/net/ice/ice_fdir_filter.c
+++ b/drivers/net/ice/ice_fdir_filter.c
@@ -1997,6 +1997,7 @@ ice_fdir_parse(struct ice_adapter *ad,
               uint32_t array_len,
               const struct rte_flow_item pattern[],
               const struct rte_flow_action actions[],
+              uint32_t priority __rte_unused,
               void **meta,
               struct rte_flow_error *error)
 {

diff --git a/drivers/net/ice/ice_generic_flow.c b/drivers/net/ice/ice_generic_flow.c
index 8704812..261f0b7 100644 (file)
--- a/drivers/net/ice/ice_generic_flow.c
+++ b/drivers/net/ice/ice_generic_flow.c
@@ -1774,6 +1774,7 @@ enum rte_flow_item_type pattern_eth_ipv6_pfcp[] = {
 typedef struct ice_flow_engine * (*parse_engine_t)(struct ice_adapter *ad,
                struct rte_flow *flow,
                struct ice_parser_list *parser_list,
+               uint32_t priority,
                const struct rte_flow_item pattern[],
                const struct rte_flow_action actions[],
                struct rte_flow_error *error);
@@ -1965,11 +1966,10 @@ ice_flow_valid_attr(struct ice_adapter *ad,
        } else {
                *ice_pipeline_stage =
                        ICE_FLOW_CLASSIFY_STAGE_DISTRIBUTOR_ONLY;
-               /* Not supported */
-               if (attr->priority) {
+               if (attr->priority > 1) {
                        rte_flow_error_set(error, EINVAL,
                                        RTE_FLOW_ERROR_TYPE_ATTR_PRIORITY,
-                                       attr, "Not support priority.");
+                                       attr, "Only support priority 0 and 1.");
                        return -rte_errno;
                }
        }
@@ -2240,6 +2240,7 @@ static struct ice_flow_engine *
 ice_parse_engine_create(struct ice_adapter *ad,
                struct rte_flow *flow,
                struct ice_parser_list *parser_list,
+               uint32_t priority,
                const struct rte_flow_item pattern[],
                const struct rte_flow_action actions[],
                struct rte_flow_error *error)
@@ -2255,7 +2256,7 @@ ice_parse_engine_create(struct ice_adapter *ad,
                if (parser_node->parser->parse_pattern_action(ad,
                                parser_node->parser->array,
                                parser_node->parser->array_len,
-                               pattern, actions, &meta, error) < 0)
+                               pattern, actions, priority, &meta, error) < 0)
                        continue;
 
                engine = parser_node->parser->engine;
@@ -2273,6 +2274,7 @@ static struct ice_flow_engine *
 ice_parse_engine_validate(struct ice_adapter *ad,
                struct rte_flow *flow __rte_unused,
                struct ice_parser_list *parser_list,
+               uint32_t priority,
                const struct rte_flow_item pattern[],
                const struct rte_flow_action actions[],
                struct rte_flow_error *error)
@@ -2285,7 +2287,7 @@ ice_parse_engine_validate(struct ice_adapter *ad,
                if (parser_node->parser->parse_pattern_action(ad,
                                parser_node->parser->array,
                                parser_node->parser->array_len,
-                               pattern, actions, NULL, error) < 0)
+                               pattern, actions, priority, NULL, error) < 0)
                        continue;
 
                engine = parser_node->parser->engine;
@@ -2335,7 +2337,7 @@ ice_flow_process_filter(struct rte_eth_dev *dev,
                return ret;
 
        *engine = ice_parse_engine(ad, flow, &pf->rss_parser_list,
-                       pattern, actions, error);
+                       attr->priority, pattern, actions, error);
        if (*engine != NULL)
                return 0;
 
@@ -2343,11 +2345,11 @@ ice_flow_process_filter(struct rte_eth_dev *dev,
        case ICE_FLOW_CLASSIFY_STAGE_DISTRIBUTOR_ONLY:
        case ICE_FLOW_CLASSIFY_STAGE_DISTRIBUTOR:
                *engine = ice_parse_engine(ad, flow, &pf->dist_parser_list,
-                               pattern, actions, error);
+                               attr->priority, pattern, actions, error);
                break;
        case ICE_FLOW_CLASSIFY_STAGE_PERMISSION:
                *engine = ice_parse_engine(ad, flow, &pf->perm_parser_list,
-                               pattern, actions, error);
+                               attr->priority, pattern, actions, error);
                break;
        default:
                return -EINVAL;

diff --git a/drivers/net/ice/ice_generic_flow.h b/drivers/net/ice/ice_generic_flow.h
index 9f422e5..a4d0b66 100644 (file)
--- a/drivers/net/ice/ice_generic_flow.h
+++ b/drivers/net/ice/ice_generic_flow.h
@@ -515,6 +515,7 @@ typedef int (*parse_pattern_action_t)(struct ice_adapter *ad,
                uint32_t array_len,
                const struct rte_flow_item pattern[],
                const struct rte_flow_action actions[],
+               uint32_t priority,
                void **meta,
                struct rte_flow_error *error);
 

diff --git a/drivers/net/ice/ice_hash.c b/drivers/net/ice/ice_hash.c
index e56cdf9..f2b1719 100644 (file)
--- a/drivers/net/ice/ice_hash.c
+++ b/drivers/net/ice/ice_hash.c
@@ -102,6 +102,7 @@ ice_hash_parse_pattern_action(struct ice_adapter *ad,
                        uint32_t array_len,
                        const struct rte_flow_item pattern[],
                        const struct rte_flow_action actions[],
+                       uint32_t priority,
                        void **meta,
                        struct rte_flow_error *error);
 
@@ -985,6 +986,7 @@ ice_hash_parse_pattern_action(__rte_unused struct ice_adapter *ad,
                        uint32_t array_len,
                        const struct rte_flow_item pattern[],
                        const struct rte_flow_action actions[],
+                       uint32_t priority __rte_unused,
                        void **meta,
                        struct rte_flow_error *error)
 {

diff --git a/drivers/net/ice/ice_switch_filter.c b/drivers/net/ice/ice_switch_filter.c
index 7560fc4..0493e4d 100644 (file)
--- a/drivers/net/ice/ice_switch_filter.c
+++ b/drivers/net/ice/ice_switch_filter.c
@@ -1621,6 +1621,7 @@ out:
 static int
 ice_switch_parse_dcf_action(struct ice_dcf_adapter *ad,
                            const struct rte_flow_action *actions,
+                           uint32_t priority,
                            struct rte_flow_error *error,
                            struct ice_adv_rule_info *rule_info)
 {
@@ -1668,7 +1669,7 @@ ice_switch_parse_dcf_action(struct ice_dcf_adapter *ad,
        rule_info->sw_act.src = rule_info->sw_act.vsi_handle;
        rule_info->sw_act.flag = ICE_FLTR_RX;
        rule_info->rx = 1;
-       rule_info->priority = 5;
+       rule_info->priority = priority + 5;
 
        return 0;
 }
@@ -1676,6 +1677,7 @@ ice_switch_parse_dcf_action(struct ice_dcf_adapter *ad,
 static int
 ice_switch_parse_action(struct ice_pf *pf,
                const struct rte_flow_action *actions,
+               uint32_t priority,
                struct rte_flow_error *error,
                struct ice_adv_rule_info *rule_info)
 {
@@ -1746,7 +1748,7 @@ ice_switch_parse_action(struct ice_pf *pf,
        rule_info->sw_act.vsi_handle = vsi->idx;
        rule_info->rx = 1;
        rule_info->sw_act.src = vsi->idx;
-       rule_info->priority = 5;
+       rule_info->priority = priority + 5;
 
        return 0;
 
@@ -1818,6 +1820,7 @@ ice_switch_parse_pattern_action(struct ice_adapter *ad,
                uint32_t array_len,
                const struct rte_flow_item pattern[],
                const struct rte_flow_action actions[],
+               uint32_t priority,
                void **meta,
                struct rte_flow_error *error)
 {
@@ -1908,10 +1911,11 @@ ice_switch_parse_pattern_action(struct ice_adapter *ad,
                goto error;
 
        if (ad->hw.dcf_enabled)
-               ret = ice_switch_parse_dcf_action((void *)ad, actions, error,
-                                                 &rule_info);
+               ret = ice_switch_parse_dcf_action((void *)ad, actions, priority,
+                                                 error, &rule_info);
        else
-               ret = ice_switch_parse_action(pf, actions, error, &rule_info);
+               ret = ice_switch_parse_action(pf, actions, priority, error,
+                                             &rule_info);
 
        if (ret)
                goto error;