net/sfc: reserve queues for port representors

[dpdk.git] / drivers / net / ice / ice_generic_flow.c

diff --git a/drivers/net/ice/ice_generic_flow.c b/drivers/net/ice/ice_generic_flow.c
index 25d15a8..3e6ed70 100644 (file)
--- a/drivers/net/ice/ice_generic_flow.c
+++ b/drivers/net/ice/ice_generic_flow.c
@@ -212,6 +212,27 @@ enum rte_flow_item_type pattern_eth_qinq_ipv6[] = {
        RTE_FLOW_ITEM_TYPE_IPV6,
        RTE_FLOW_ITEM_TYPE_END,
 };
+enum rte_flow_item_type pattern_eth_ipv6_frag_ext[] = {
+       RTE_FLOW_ITEM_TYPE_ETH,
+       RTE_FLOW_ITEM_TYPE_IPV6,
+       RTE_FLOW_ITEM_TYPE_IPV6_FRAG_EXT,
+       RTE_FLOW_ITEM_TYPE_END,
+};
+enum rte_flow_item_type pattern_eth_vlan_ipv6_frag_ext[] = {
+       RTE_FLOW_ITEM_TYPE_ETH,
+       RTE_FLOW_ITEM_TYPE_VLAN,
+       RTE_FLOW_ITEM_TYPE_IPV6,
+       RTE_FLOW_ITEM_TYPE_IPV6_FRAG_EXT,
+       RTE_FLOW_ITEM_TYPE_END,
+};
+enum rte_flow_item_type pattern_eth_qinq_ipv6_frag_ext[] = {
+       RTE_FLOW_ITEM_TYPE_ETH,
+       RTE_FLOW_ITEM_TYPE_VLAN,
+       RTE_FLOW_ITEM_TYPE_VLAN,
+       RTE_FLOW_ITEM_TYPE_IPV6,
+       RTE_FLOW_ITEM_TYPE_IPV6_FRAG_EXT,
+       RTE_FLOW_ITEM_TYPE_END,
+};
 enum rte_flow_item_type pattern_eth_ipv6_udp[] = {
        RTE_FLOW_ITEM_TYPE_ETH,
        RTE_FLOW_ITEM_TYPE_IPV6,
@@ -1774,6 +1795,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);
@@ -1798,7 +1820,7 @@ ice_flow_init(struct ice_adapter *ad)
        TAILQ_INIT(&pf->dist_parser_list);
        rte_spinlock_init(&pf->flow_ops_lock);
 
-       TAILQ_FOREACH_SAFE(engine, &engine_list, node, temp) {
+       RTE_TAILQ_FOREACH_SAFE(engine, &engine_list, node, temp) {
                if (engine->init == NULL) {
                        PMD_INIT_LOG(ERR, "Invalid engine type (%d)",
                                        engine->type);
@@ -1824,7 +1846,7 @@ ice_flow_uninit(struct ice_adapter *ad)
        struct ice_flow_parser_node *p_parser;
        void *temp;
 
-       TAILQ_FOREACH_SAFE(engine, &engine_list, node, temp) {
+       RTE_TAILQ_FOREACH_SAFE(engine, &engine_list, node, temp) {
                if (engine->uninit)
                        engine->uninit(ad);
        }
@@ -1901,9 +1923,9 @@ ice_register_parser(struct ice_flow_parser *parser,
        } else {
                if (parser->engine->type == ICE_FLOW_ENGINE_SWITCH ||
                                parser->engine->type == ICE_FLOW_ENGINE_HASH)
-                       TAILQ_INSERT_TAIL(list, parser_node, node);
-               else if (parser->engine->type == ICE_FLOW_ENGINE_FDIR)
                        TAILQ_INSERT_HEAD(list, parser_node, node);
+               else if (parser->engine->type == ICE_FLOW_ENGINE_FDIR)
+                       TAILQ_INSERT_TAIL(list, parser_node, node);
                else if (parser->engine->type == ICE_FLOW_ENGINE_ACL)
                        TAILQ_INSERT_HEAD(list, parser_node, node);
                else
@@ -1924,7 +1946,7 @@ ice_unregister_parser(struct ice_flow_parser *parser,
        if (list == NULL)
                return;
 
-       TAILQ_FOREACH_SAFE(p_parser, list, node, temp) {
+       RTE_TAILQ_FOREACH_SAFE(p_parser, list, node, temp) {
                if (p_parser->parser->engine->type == parser->engine->type) {
                        TAILQ_REMOVE(list, p_parser, node);
                        rte_free(p_parser);
@@ -1965,11 +1987,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;
                }
        }
@@ -2087,6 +2108,7 @@ static struct ice_ptype_match ice_ptype_map[] = {
        {pattern_eth_ipv6_udp,                          ICE_PTYPE_IPV6_UDP_PAY},
        {pattern_eth_ipv6_tcp,                          ICE_PTYPE_IPV6_TCP_PAY},
        {pattern_eth_ipv6_sctp,                         ICE_PTYPE_IPV6_SCTP_PAY},
+       {pattern_eth_ipv6_frag_ext,                     ICE_PTYPE_IPV6FRAG_PAY},
        {pattern_eth_ipv6_gtpu,                         ICE_MAC_IPV6_GTPU},
        {pattern_eth_ipv6_gtpu_eh,                      ICE_MAC_IPV6_GTPU},
        {pattern_eth_ipv6_gtpu_ipv4,                    ICE_MAC_IPV6_GTPU_IPV4_PAY},
@@ -2112,11 +2134,15 @@ static struct ice_ptype_match ice_ptype_map[] = {
        {pattern_eth_arp,                               ICE_PTYPE_MAC_PAY},
        {pattern_eth_vlan_ipv4,                         ICE_PTYPE_IPV4_PAY},
        {pattern_eth_qinq_ipv4,                         ICE_PTYPE_IPV4_PAY},
+       {pattern_eth_qinq_ipv4_udp,                     ICE_PTYPE_IPV4_UDP_PAY},
+       {pattern_eth_qinq_ipv4_tcp,                     ICE_PTYPE_IPV4_TCP_PAY},
        {pattern_eth_vlan_ipv4_udp,                     ICE_PTYPE_IPV4_UDP_PAY},
        {pattern_eth_vlan_ipv4_tcp,                     ICE_PTYPE_IPV4_TCP_PAY},
        {pattern_eth_vlan_ipv4_sctp,                    ICE_PTYPE_IPV4_SCTP_PAY},
        {pattern_eth_vlan_ipv6,                         ICE_PTYPE_IPV6_PAY},
        {pattern_eth_qinq_ipv6,                         ICE_PTYPE_IPV6_PAY},
+       {pattern_eth_qinq_ipv6_udp,                     ICE_PTYPE_IPV6_UDP_PAY},
+       {pattern_eth_qinq_ipv6_tcp,                     ICE_PTYPE_IPV6_TCP_PAY},
        {pattern_eth_vlan_ipv6_udp,                     ICE_PTYPE_IPV6_UDP_PAY},
        {pattern_eth_vlan_ipv6_tcp,                     ICE_PTYPE_IPV6_TCP_PAY},
        {pattern_eth_vlan_ipv6_sctp,                    ICE_PTYPE_IPV6_SCTP_PAY},
@@ -2216,8 +2242,10 @@ ice_search_pattern_match_item(struct ice_adapter *ad,
        for (i = 0; i < array_len; i++) {
                if (ice_match_pattern(array[i].pattern_list,
                                      items)) {
-                       pattern_match_item->input_set_mask =
-                               array[i].input_set_mask;
+                       pattern_match_item->input_set_mask_o =
+                               array[i].input_set_mask_o;
+                       pattern_match_item->input_set_mask_i =
+                               array[i].input_set_mask_i;
                        pattern_match_item->pattern_list =
                                array[i].pattern_list;
                        pattern_match_item->meta = array[i].meta;
@@ -2238,6 +2266,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)
@@ -2247,13 +2276,13 @@ ice_parse_engine_create(struct ice_adapter *ad,
        void *meta = NULL;
        void *temp;
 
-       TAILQ_FOREACH_SAFE(parser_node, parser_list, node, temp) {
+       RTE_TAILQ_FOREACH_SAFE(parser_node, parser_list, node, temp) {
                int ret;
 
                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;
@@ -2271,6 +2300,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)
@@ -2279,11 +2309,11 @@ ice_parse_engine_validate(struct ice_adapter *ad,
        struct ice_flow_parser_node *parser_node;
        void *temp;
 
-       TAILQ_FOREACH_SAFE(parser_node, parser_list, node, temp) {
+       RTE_TAILQ_FOREACH_SAFE(parser_node, parser_list, node, temp) {
                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;
@@ -2333,7 +2363,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;
 
@@ -2341,11 +2371,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;
@@ -2451,7 +2481,7 @@ ice_flow_flush(struct rte_eth_dev *dev,
        void *temp;
        int ret = 0;
 
-       TAILQ_FOREACH_SAFE(p_flow, &pf->flow_list, node, temp) {
+       RTE_TAILQ_FOREACH_SAFE(p_flow, &pf->flow_list, node, temp) {
                ret = ice_flow_destroy(dev, p_flow, error);
                if (ret) {
                        PMD_DRV_LOG(ERR, "Failed to flush flows");
@@ -2492,15 +2522,16 @@ ice_flow_query(struct rte_eth_dev *dev,
                        ret = flow->engine->query_count(ad, flow, count, error);
                        break;
                default:
-                       return rte_flow_error_set(error, ENOTSUP,
+                       ret = rte_flow_error_set(error, ENOTSUP,
                                        RTE_FLOW_ERROR_TYPE_ACTION,
                                        actions,
                                        "action not supported");
+                       goto out;
                }
        }
 
+out:
        rte_spinlock_unlock(&pf->flow_ops_lock);
-
        return ret;
 }
 
@@ -2515,7 +2546,7 @@ ice_flow_redirect(struct ice_adapter *ad,
 
        rte_spinlock_lock(&pf->flow_ops_lock);
 
-       TAILQ_FOREACH_SAFE(p_flow, &pf->flow_list, node, temp) {
+       RTE_TAILQ_FOREACH_SAFE(p_flow, &pf->flow_list, node, temp) {
                if (!p_flow->engine->redirect)
                        continue;
                ret = p_flow->engine->redirect(ad, p_flow, rd);