LCOV - code coverage report
Current view: top level - drivers/net/ice - ice_switch_filter.c (source / functions) Hit Total Coverage
Test: Code coverage Lines: 3 940 0.3 %
Date: 2024-01-22 15:35:40 Functions: 1 13 7.7 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 684 0.0 %

           Branch data     Line data    Source code
       1                 :            : /* SPDX-License-Identifier: BSD-3-Clause
       2                 :            :  * Copyright(c) 2019 Intel Corporation
       3                 :            :  */
       4                 :            : 
       5                 :            : #include <sys/queue.h>
       6                 :            : #include <stdio.h>
       7                 :            : #include <errno.h>
       8                 :            : #include <stdint.h>
       9                 :            : #include <string.h>
      10                 :            : #include <unistd.h>
      11                 :            : #include <stdarg.h>
      12                 :            : #include <rte_debug.h>
      13                 :            : #include <rte_ether.h>
      14                 :            : #include <ethdev_driver.h>
      15                 :            : #include <rte_log.h>
      16                 :            : #include <rte_malloc.h>
      17                 :            : #include <rte_eth_ctrl.h>
      18                 :            : #include <rte_tailq.h>
      19                 :            : #include <rte_flow_driver.h>
      20                 :            : #include <rte_flow.h>
      21                 :            : #include "base/ice_type.h"
      22                 :            : #include "base/ice_switch.h"
      23                 :            : #include "ice_logs.h"
      24                 :            : #include "ice_ethdev.h"
      25                 :            : #include "ice_generic_flow.h"
      26                 :            : #include "ice_dcf_ethdev.h"
      27                 :            : 
      28                 :            : 
      29                 :            : #define MAX_QGRP_NUM_TYPE       7
      30                 :            : #define MAX_INPUT_SET_BYTE      32
      31                 :            : #define ICE_PPP_IPV4_PROTO      0x0021
      32                 :            : #define ICE_PPP_IPV6_PROTO      0x0057
      33                 :            : #define ICE_IPV4_PROTO_NVGRE    0x002F
      34                 :            : #define ICE_SW_PRI_BASE 6
      35                 :            : 
      36                 :            : #define ICE_SW_INSET_ETHER ( \
      37                 :            :         ICE_INSET_DMAC | ICE_INSET_SMAC | ICE_INSET_ETHERTYPE)
      38                 :            : #define ICE_SW_INSET_MAC_VLAN ( \
      39                 :            :         ICE_SW_INSET_ETHER | ICE_INSET_VLAN_INNER)
      40                 :            : #define ICE_SW_INSET_MAC_QINQ  ( \
      41                 :            :         ICE_INSET_DMAC | ICE_INSET_SMAC | ICE_INSET_VLAN_INNER | \
      42                 :            :         ICE_INSET_VLAN_OUTER)
      43                 :            : #define ICE_SW_INSET_MAC_IPV4 ( \
      44                 :            :         ICE_INSET_DMAC | ICE_INSET_IPV4_DST | ICE_INSET_IPV4_SRC | \
      45                 :            :         ICE_INSET_IPV4_PROTO | ICE_INSET_IPV4_TTL | ICE_INSET_IPV4_TOS)
      46                 :            : #define ICE_SW_INSET_MAC_QINQ_IPV4 ( \
      47                 :            :         ICE_SW_INSET_MAC_QINQ | ICE_SW_INSET_MAC_IPV4)
      48                 :            : #define ICE_SW_INSET_MAC_QINQ_IPV4_TCP ( \
      49                 :            :         ICE_SW_INSET_MAC_QINQ_IPV4 | \
      50                 :            :         ICE_INSET_TCP_DST_PORT | ICE_INSET_TCP_SRC_PORT)
      51                 :            : #define ICE_SW_INSET_MAC_QINQ_IPV4_UDP ( \
      52                 :            :         ICE_SW_INSET_MAC_QINQ_IPV4 | \
      53                 :            :         ICE_INSET_UDP_DST_PORT | ICE_INSET_UDP_SRC_PORT)
      54                 :            : #define ICE_SW_INSET_MAC_IPV4_TCP ( \
      55                 :            :         ICE_INSET_DMAC | ICE_INSET_IPV4_DST | ICE_INSET_IPV4_SRC | \
      56                 :            :         ICE_INSET_IPV4_TTL | ICE_INSET_IPV4_TOS | \
      57                 :            :         ICE_INSET_TCP_DST_PORT | ICE_INSET_TCP_SRC_PORT)
      58                 :            : #define ICE_SW_INSET_MAC_IPV4_UDP ( \
      59                 :            :         ICE_INSET_DMAC | ICE_INSET_IPV4_DST | ICE_INSET_IPV4_SRC | \
      60                 :            :         ICE_INSET_IPV4_TTL | ICE_INSET_IPV4_TOS | \
      61                 :            :         ICE_INSET_UDP_DST_PORT | ICE_INSET_UDP_SRC_PORT)
      62                 :            : #define ICE_SW_INSET_MAC_IPV6 ( \
      63                 :            :         ICE_INSET_DMAC | ICE_INSET_IPV6_DST | ICE_INSET_IPV6_SRC | \
      64                 :            :         ICE_INSET_IPV6_TC | ICE_INSET_IPV6_HOP_LIMIT | \
      65                 :            :         ICE_INSET_IPV6_NEXT_HDR)
      66                 :            : #define ICE_SW_INSET_MAC_QINQ_IPV6 ( \
      67                 :            :         ICE_SW_INSET_MAC_QINQ | ICE_SW_INSET_MAC_IPV6)
      68                 :            : #define ICE_SW_INSET_MAC_QINQ_IPV6_TCP ( \
      69                 :            :         ICE_SW_INSET_MAC_QINQ_IPV6 | \
      70                 :            :         ICE_INSET_TCP_DST_PORT | ICE_INSET_TCP_SRC_PORT)
      71                 :            : #define ICE_SW_INSET_MAC_QINQ_IPV6_UDP ( \
      72                 :            :         ICE_SW_INSET_MAC_QINQ_IPV6 | \
      73                 :            :         ICE_INSET_UDP_DST_PORT | ICE_INSET_UDP_SRC_PORT)
      74                 :            : #define ICE_SW_INSET_MAC_IPV6_TCP ( \
      75                 :            :         ICE_INSET_DMAC | ICE_INSET_IPV6_DST | ICE_INSET_IPV6_SRC | \
      76                 :            :         ICE_INSET_IPV6_HOP_LIMIT | ICE_INSET_IPV6_TC | \
      77                 :            :         ICE_INSET_TCP_DST_PORT | ICE_INSET_TCP_SRC_PORT)
      78                 :            : #define ICE_SW_INSET_MAC_IPV6_UDP ( \
      79                 :            :         ICE_INSET_DMAC | ICE_INSET_IPV6_DST | ICE_INSET_IPV6_SRC | \
      80                 :            :         ICE_INSET_IPV6_HOP_LIMIT | ICE_INSET_IPV6_TC | \
      81                 :            :         ICE_INSET_UDP_DST_PORT | ICE_INSET_UDP_SRC_PORT)
      82                 :            : #define ICE_SW_INSET_DIST_NVGRE_IPV4 ( \
      83                 :            :         ICE_INSET_IPV4_SRC | ICE_INSET_IPV4_DST | ICE_INSET_DMAC | \
      84                 :            :         ICE_INSET_NVGRE_TNI)
      85                 :            : #define ICE_SW_INSET_DIST_VXLAN_IPV4 ( \
      86                 :            :         ICE_INSET_IPV4_SRC | ICE_INSET_IPV4_DST | ICE_INSET_DMAC | \
      87                 :            :         ICE_INSET_VXLAN_VNI)
      88                 :            : #define ICE_SW_INSET_DIST_NVGRE_IPV4_TCP ( \
      89                 :            :         ICE_INSET_IPV4_SRC | ICE_INSET_IPV4_DST | \
      90                 :            :         ICE_INSET_TCP_SRC_PORT | ICE_INSET_TCP_DST_PORT | \
      91                 :            :         ICE_INSET_DMAC | ICE_INSET_NVGRE_TNI)
      92                 :            : #define ICE_SW_INSET_DIST_NVGRE_IPV4_UDP ( \
      93                 :            :         ICE_INSET_IPV4_SRC | ICE_INSET_IPV4_DST | \
      94                 :            :         ICE_INSET_UDP_SRC_PORT | ICE_INSET_UDP_DST_PORT | \
      95                 :            :         ICE_INSET_DMAC | ICE_INSET_NVGRE_TNI)
      96                 :            : #define ICE_SW_INSET_DIST_VXLAN_IPV4_TCP ( \
      97                 :            :         ICE_INSET_IPV4_SRC | ICE_INSET_IPV4_DST | \
      98                 :            :         ICE_INSET_TCP_SRC_PORT | ICE_INSET_TCP_DST_PORT | \
      99                 :            :         ICE_INSET_DMAC | ICE_INSET_VXLAN_VNI)
     100                 :            : #define ICE_SW_INSET_DIST_VXLAN_IPV4_UDP ( \
     101                 :            :         ICE_INSET_IPV4_SRC | ICE_INSET_IPV4_DST | \
     102                 :            :         ICE_INSET_UDP_SRC_PORT | ICE_INSET_UDP_DST_PORT | \
     103                 :            :         ICE_INSET_DMAC | ICE_INSET_VXLAN_VNI)
     104                 :            : #define ICE_SW_INSET_PERM_TUNNEL_IPV4 ( \
     105                 :            :         ICE_INSET_IPV4_SRC | ICE_INSET_IPV4_DST | \
     106                 :            :         ICE_INSET_IPV4_PROTO | ICE_INSET_IPV4_TOS)
     107                 :            : #define ICE_SW_INSET_PERM_TUNNEL_IPV4_TCP ( \
     108                 :            :         ICE_INSET_IPV4_SRC | ICE_INSET_IPV4_DST | \
     109                 :            :         ICE_INSET_TCP_SRC_PORT | ICE_INSET_TCP_DST_PORT | \
     110                 :            :         ICE_INSET_IPV4_TOS)
     111                 :            : #define ICE_SW_INSET_PERM_TUNNEL_IPV4_UDP ( \
     112                 :            :         ICE_INSET_IPV4_SRC | ICE_INSET_IPV4_DST | \
     113                 :            :         ICE_INSET_UDP_SRC_PORT | ICE_INSET_UDP_DST_PORT | \
     114                 :            :         ICE_INSET_IPV4_TOS)
     115                 :            : #define ICE_SW_INSET_MAC_PPPOE  ( \
     116                 :            :         ICE_INSET_VLAN_OUTER | ICE_INSET_VLAN_INNER | \
     117                 :            :         ICE_INSET_DMAC | ICE_INSET_ETHERTYPE | ICE_INSET_PPPOE_SESSION)
     118                 :            : #define ICE_SW_INSET_MAC_PPPOE_PROTO  ( \
     119                 :            :         ICE_INSET_VLAN_OUTER | ICE_INSET_VLAN_INNER | \
     120                 :            :         ICE_INSET_DMAC | ICE_INSET_ETHERTYPE | ICE_INSET_PPPOE_SESSION | \
     121                 :            :         ICE_INSET_PPPOE_PROTO)
     122                 :            : #define ICE_SW_INSET_MAC_PPPOE_IPV4 ( \
     123                 :            :         ICE_SW_INSET_MAC_PPPOE | ICE_SW_INSET_MAC_IPV4)
     124                 :            : #define ICE_SW_INSET_MAC_PPPOE_IPV4_TCP ( \
     125                 :            :         ICE_SW_INSET_MAC_PPPOE | ICE_SW_INSET_MAC_IPV4_TCP)
     126                 :            : #define ICE_SW_INSET_MAC_PPPOE_IPV4_UDP ( \
     127                 :            :         ICE_SW_INSET_MAC_PPPOE | ICE_SW_INSET_MAC_IPV4_UDP)
     128                 :            : #define ICE_SW_INSET_MAC_PPPOE_IPV6 ( \
     129                 :            :         ICE_SW_INSET_MAC_PPPOE | ICE_SW_INSET_MAC_IPV6)
     130                 :            : #define ICE_SW_INSET_MAC_PPPOE_IPV6_TCP ( \
     131                 :            :         ICE_SW_INSET_MAC_PPPOE | ICE_SW_INSET_MAC_IPV6_TCP)
     132                 :            : #define ICE_SW_INSET_MAC_PPPOE_IPV6_UDP ( \
     133                 :            :         ICE_SW_INSET_MAC_PPPOE | ICE_SW_INSET_MAC_IPV6_UDP)
     134                 :            : #define ICE_SW_INSET_MAC_IPV4_ESP ( \
     135                 :            :         ICE_SW_INSET_MAC_IPV4 | ICE_INSET_ESP_SPI)
     136                 :            : #define ICE_SW_INSET_MAC_IPV6_ESP ( \
     137                 :            :         ICE_SW_INSET_MAC_IPV6 | ICE_INSET_ESP_SPI)
     138                 :            : #define ICE_SW_INSET_MAC_IPV4_AH ( \
     139                 :            :         ICE_SW_INSET_MAC_IPV4 | ICE_INSET_AH_SPI)
     140                 :            : #define ICE_SW_INSET_MAC_IPV6_AH ( \
     141                 :            :         ICE_SW_INSET_MAC_IPV6 | ICE_INSET_AH_SPI)
     142                 :            : #define ICE_SW_INSET_MAC_IPV4_L2TP ( \
     143                 :            :         ICE_SW_INSET_MAC_IPV4 | ICE_INSET_L2TPV3OIP_SESSION_ID)
     144                 :            : #define ICE_SW_INSET_MAC_IPV6_L2TP ( \
     145                 :            :         ICE_SW_INSET_MAC_IPV6 | ICE_INSET_L2TPV3OIP_SESSION_ID)
     146                 :            : #define ICE_SW_INSET_MAC_IPV4_PFCP ( \
     147                 :            :         ICE_SW_INSET_MAC_IPV4 | \
     148                 :            :         ICE_INSET_PFCP_S_FIELD | ICE_INSET_PFCP_SEID)
     149                 :            : #define ICE_SW_INSET_MAC_IPV6_PFCP ( \
     150                 :            :         ICE_SW_INSET_MAC_IPV6 | \
     151                 :            :         ICE_INSET_PFCP_S_FIELD | ICE_INSET_PFCP_SEID)
     152                 :            : #define ICE_SW_INSET_MAC_IPV4_GTPU ( \
     153                 :            :         ICE_SW_INSET_MAC_IPV4 | ICE_INSET_GTPU_TEID)
     154                 :            : #define ICE_SW_INSET_MAC_IPV6_GTPU ( \
     155                 :            :         ICE_SW_INSET_MAC_IPV6 | ICE_INSET_GTPU_TEID)
     156                 :            : #define ICE_SW_INSET_MAC_GTPU_OUTER ( \
     157                 :            :         ICE_INSET_DMAC | ICE_INSET_GTPU_TEID)
     158                 :            : #define ICE_SW_INSET_MAC_GTPU_EH_OUTER ( \
     159                 :            :         ICE_SW_INSET_MAC_GTPU_OUTER | ICE_INSET_GTPU_QFI)
     160                 :            : #define ICE_SW_INSET_GTPU_IPV4 ( \
     161                 :            :         ICE_INSET_IPV4_SRC | ICE_INSET_IPV4_DST)
     162                 :            : #define ICE_SW_INSET_GTPU_IPV6 ( \
     163                 :            :         ICE_INSET_IPV6_SRC | ICE_INSET_IPV6_DST)
     164                 :            : #define ICE_SW_INSET_GTPU_IPV4_UDP ( \
     165                 :            :         ICE_SW_INSET_GTPU_IPV4 | ICE_INSET_UDP_SRC_PORT | \
     166                 :            :         ICE_INSET_UDP_DST_PORT)
     167                 :            : #define ICE_SW_INSET_GTPU_IPV4_TCP ( \
     168                 :            :         ICE_SW_INSET_GTPU_IPV4 | ICE_INSET_TCP_SRC_PORT | \
     169                 :            :         ICE_INSET_TCP_DST_PORT)
     170                 :            : #define ICE_SW_INSET_GTPU_IPV6_UDP ( \
     171                 :            :         ICE_SW_INSET_GTPU_IPV6 | ICE_INSET_UDP_SRC_PORT | \
     172                 :            :         ICE_INSET_UDP_DST_PORT)
     173                 :            : #define ICE_SW_INSET_GTPU_IPV6_TCP ( \
     174                 :            :         ICE_SW_INSET_GTPU_IPV6 | ICE_INSET_TCP_SRC_PORT | \
     175                 :            :         ICE_INSET_TCP_DST_PORT)
     176                 :            : 
     177                 :            : struct sw_meta {
     178                 :            :         struct ice_adv_lkup_elem *list;
     179                 :            :         uint16_t lkups_num;
     180                 :            :         struct ice_adv_rule_info rule_info;
     181                 :            : };
     182                 :            : 
     183                 :            : enum ice_sw_fltr_status {
     184                 :            :         ICE_SW_FLTR_ADDED,
     185                 :            :         ICE_SW_FLTR_RMV_FAILED_ON_RIDRECT,
     186                 :            :         ICE_SW_FLTR_ADD_FAILED_ON_RIDRECT,
     187                 :            : };
     188                 :            : 
     189                 :            : struct ice_switch_filter_conf {
     190                 :            :         enum ice_sw_fltr_status fltr_status;
     191                 :            : 
     192                 :            :         struct ice_rule_query_data sw_query_data;
     193                 :            : 
     194                 :            :         /*
     195                 :            :          * The lookup elements and rule info are saved here when filter creation
     196                 :            :          * succeeds.
     197                 :            :          */
     198                 :            :         uint16_t vsi_num;
     199                 :            :         uint16_t lkups_num;
     200                 :            :         struct ice_adv_lkup_elem *lkups;
     201                 :            :         struct ice_adv_rule_info rule_info;
     202                 :            : };
     203                 :            : 
     204                 :            : static struct
     205                 :            : ice_pattern_match_item ice_switch_supported_pattern[] = {
     206                 :            :         {pattern_any,                                   ICE_INSET_NONE,                         ICE_INSET_NONE,                         ICE_INSET_NONE},
     207                 :            :         {pattern_ethertype,                             ICE_SW_INSET_ETHER,                     ICE_INSET_NONE,                         ICE_INSET_NONE},
     208                 :            :         {pattern_ethertype_vlan,                        ICE_SW_INSET_MAC_VLAN,                  ICE_INSET_NONE,                         ICE_INSET_NONE},
     209                 :            :         {pattern_ethertype_qinq,                        ICE_SW_INSET_MAC_QINQ,                  ICE_INSET_NONE,                         ICE_INSET_NONE},
     210                 :            :         {pattern_eth_arp,                               ICE_INSET_NONE,                         ICE_INSET_NONE,                         ICE_INSET_NONE},
     211                 :            :         {pattern_eth_ipv4,                              ICE_SW_INSET_MAC_IPV4,                  ICE_INSET_NONE,                         ICE_INSET_NONE},
     212                 :            :         {pattern_eth_ipv4_udp,                          ICE_SW_INSET_MAC_IPV4_UDP,              ICE_INSET_NONE,                         ICE_INSET_NONE},
     213                 :            :         {pattern_eth_ipv4_tcp,                          ICE_SW_INSET_MAC_IPV4_TCP,              ICE_INSET_NONE,                         ICE_INSET_NONE},
     214                 :            :         {pattern_eth_ipv6,                              ICE_SW_INSET_MAC_IPV6,                  ICE_INSET_NONE,                         ICE_INSET_NONE},
     215                 :            :         {pattern_eth_ipv6_udp,                          ICE_SW_INSET_MAC_IPV6_UDP,              ICE_INSET_NONE,                         ICE_INSET_NONE},
     216                 :            :         {pattern_eth_ipv6_tcp,                          ICE_SW_INSET_MAC_IPV6_TCP,              ICE_INSET_NONE,                         ICE_INSET_NONE},
     217                 :            :         {pattern_eth_ipv4_udp_vxlan_eth_ipv4,           ICE_INSET_IPV4_DST,                     ICE_SW_INSET_DIST_VXLAN_IPV4,           ICE_INSET_NONE},
     218                 :            :         {pattern_eth_ipv4_udp_vxlan_eth_ipv4_udp,       ICE_INSET_IPV4_DST,                     ICE_SW_INSET_DIST_VXLAN_IPV4_UDP,       ICE_INSET_NONE},
     219                 :            :         {pattern_eth_ipv4_udp_vxlan_eth_ipv4_tcp,       ICE_INSET_IPV4_DST,                     ICE_SW_INSET_DIST_VXLAN_IPV4_TCP,       ICE_INSET_NONE},
     220                 :            :         {pattern_eth_ipv4_nvgre_eth_ipv4,               ICE_INSET_IPV4_DST,                     ICE_SW_INSET_DIST_NVGRE_IPV4,           ICE_INSET_NONE},
     221                 :            :         {pattern_eth_ipv4_nvgre_eth_ipv4_udp,           ICE_INSET_IPV4_DST,                     ICE_SW_INSET_DIST_NVGRE_IPV4_UDP,       ICE_INSET_NONE},
     222                 :            :         {pattern_eth_ipv4_nvgre_eth_ipv4_tcp,           ICE_INSET_IPV4_DST,                     ICE_SW_INSET_DIST_NVGRE_IPV4_TCP,       ICE_INSET_NONE},
     223                 :            :         {pattern_eth_pppoes,                            ICE_SW_INSET_MAC_PPPOE,                 ICE_INSET_NONE,                         ICE_INSET_NONE},
     224                 :            :         {pattern_eth_vlan_pppoes,                       ICE_SW_INSET_MAC_PPPOE,                 ICE_INSET_NONE,                         ICE_INSET_NONE},
     225                 :            :         {pattern_eth_pppoes_proto,                      ICE_SW_INSET_MAC_PPPOE_PROTO,           ICE_INSET_NONE,                         ICE_INSET_NONE},
     226                 :            :         {pattern_eth_vlan_pppoes_proto,                 ICE_SW_INSET_MAC_PPPOE_PROTO,           ICE_INSET_NONE,                         ICE_INSET_NONE},
     227                 :            :         {pattern_eth_pppoes_ipv4,                       ICE_SW_INSET_MAC_PPPOE_IPV4,            ICE_INSET_NONE,                         ICE_INSET_NONE},
     228                 :            :         {pattern_eth_pppoes_ipv4_tcp,                   ICE_SW_INSET_MAC_PPPOE_IPV4_TCP,        ICE_INSET_NONE,                         ICE_INSET_NONE},
     229                 :            :         {pattern_eth_pppoes_ipv4_udp,                   ICE_SW_INSET_MAC_PPPOE_IPV4_UDP,        ICE_INSET_NONE,                         ICE_INSET_NONE},
     230                 :            :         {pattern_eth_pppoes_ipv6,                       ICE_SW_INSET_MAC_PPPOE_IPV6,            ICE_INSET_NONE,                         ICE_INSET_NONE},
     231                 :            :         {pattern_eth_pppoes_ipv6_tcp,                   ICE_SW_INSET_MAC_PPPOE_IPV6_TCP,        ICE_INSET_NONE,                         ICE_INSET_NONE},
     232                 :            :         {pattern_eth_pppoes_ipv6_udp,                   ICE_SW_INSET_MAC_PPPOE_IPV6_UDP,        ICE_INSET_NONE,                         ICE_INSET_NONE},
     233                 :            :         {pattern_eth_vlan_pppoes_ipv4,                  ICE_SW_INSET_MAC_PPPOE_IPV4,            ICE_INSET_NONE,                         ICE_INSET_NONE},
     234                 :            :         {pattern_eth_vlan_pppoes_ipv4_tcp,              ICE_SW_INSET_MAC_PPPOE_IPV4_TCP,        ICE_INSET_NONE,                         ICE_INSET_NONE},
     235                 :            :         {pattern_eth_vlan_pppoes_ipv4_udp,              ICE_SW_INSET_MAC_PPPOE_IPV4_UDP,        ICE_INSET_NONE,                         ICE_INSET_NONE},
     236                 :            :         {pattern_eth_vlan_pppoes_ipv6,                  ICE_SW_INSET_MAC_PPPOE_IPV6,            ICE_INSET_NONE,                         ICE_INSET_NONE},
     237                 :            :         {pattern_eth_vlan_pppoes_ipv6_tcp,              ICE_SW_INSET_MAC_PPPOE_IPV6_TCP,        ICE_INSET_NONE,                         ICE_INSET_NONE},
     238                 :            :         {pattern_eth_vlan_pppoes_ipv6_udp,              ICE_SW_INSET_MAC_PPPOE_IPV6_UDP,        ICE_INSET_NONE,                         ICE_INSET_NONE},
     239                 :            :         {pattern_eth_ipv4_esp,                          ICE_SW_INSET_MAC_IPV4_ESP,              ICE_INSET_NONE,                         ICE_INSET_NONE},
     240                 :            :         {pattern_eth_ipv4_udp_esp,                      ICE_SW_INSET_MAC_IPV4_ESP,              ICE_INSET_NONE,                         ICE_INSET_NONE},
     241                 :            :         {pattern_eth_ipv6_esp,                          ICE_SW_INSET_MAC_IPV6_ESP,              ICE_INSET_NONE,                         ICE_INSET_NONE},
     242                 :            :         {pattern_eth_ipv6_udp_esp,                      ICE_SW_INSET_MAC_IPV6_ESP,              ICE_INSET_NONE,                         ICE_INSET_NONE},
     243                 :            :         {pattern_eth_ipv4_ah,                           ICE_SW_INSET_MAC_IPV4_AH,               ICE_INSET_NONE,                         ICE_INSET_NONE},
     244                 :            :         {pattern_eth_ipv6_ah,                           ICE_SW_INSET_MAC_IPV6_AH,               ICE_INSET_NONE,                         ICE_INSET_NONE},
     245                 :            :         {pattern_eth_ipv6_udp_ah,                       ICE_INSET_NONE,                         ICE_INSET_NONE,                         ICE_INSET_NONE},
     246                 :            :         {pattern_eth_ipv4_l2tp,                         ICE_SW_INSET_MAC_IPV4_L2TP,             ICE_INSET_NONE,                         ICE_INSET_NONE},
     247                 :            :         {pattern_eth_ipv6_l2tp,                         ICE_SW_INSET_MAC_IPV6_L2TP,             ICE_INSET_NONE,                         ICE_INSET_NONE},
     248                 :            :         {pattern_eth_ipv4_pfcp,                         ICE_INSET_NONE,                         ICE_INSET_NONE,                         ICE_INSET_NONE},
     249                 :            :         {pattern_eth_ipv6_pfcp,                         ICE_INSET_NONE,                         ICE_INSET_NONE,                         ICE_INSET_NONE},
     250                 :            :         {pattern_eth_qinq_ipv4,                         ICE_SW_INSET_MAC_QINQ_IPV4,             ICE_INSET_NONE,                         ICE_INSET_NONE},
     251                 :            :         {pattern_eth_qinq_ipv4_tcp,                     ICE_SW_INSET_MAC_QINQ_IPV4_TCP,         ICE_INSET_NONE,                         ICE_INSET_NONE},
     252                 :            :         {pattern_eth_qinq_ipv4_udp,                     ICE_SW_INSET_MAC_QINQ_IPV4_UDP,         ICE_INSET_NONE,                         ICE_INSET_NONE},
     253                 :            :         {pattern_eth_qinq_ipv6,                         ICE_SW_INSET_MAC_QINQ_IPV6,             ICE_INSET_NONE,                         ICE_INSET_NONE},
     254                 :            :         {pattern_eth_qinq_ipv6_tcp,                     ICE_SW_INSET_MAC_QINQ_IPV6_TCP,         ICE_INSET_NONE,                         ICE_INSET_NONE},
     255                 :            :         {pattern_eth_qinq_ipv6_udp,                     ICE_SW_INSET_MAC_QINQ_IPV6_UDP,         ICE_INSET_NONE,                         ICE_INSET_NONE},
     256                 :            :         {pattern_eth_qinq_pppoes,                       ICE_SW_INSET_MAC_PPPOE,                 ICE_INSET_NONE,                         ICE_INSET_NONE},
     257                 :            :         {pattern_eth_qinq_pppoes_proto,                 ICE_SW_INSET_MAC_PPPOE_PROTO,           ICE_INSET_NONE,                         ICE_INSET_NONE},
     258                 :            :         {pattern_eth_qinq_pppoes_ipv4,                  ICE_SW_INSET_MAC_PPPOE_IPV4,            ICE_INSET_NONE,                         ICE_INSET_NONE},
     259                 :            :         {pattern_eth_qinq_pppoes_ipv6,                  ICE_SW_INSET_MAC_PPPOE_IPV6,            ICE_INSET_NONE,                         ICE_INSET_NONE},
     260                 :            :         {pattern_eth_ipv4_gtpu,                         ICE_SW_INSET_MAC_IPV4_GTPU,             ICE_INSET_NONE,                         ICE_INSET_NONE},
     261                 :            :         {pattern_eth_ipv6_gtpu,                         ICE_SW_INSET_MAC_IPV6_GTPU,             ICE_INSET_NONE,                         ICE_INSET_NONE},
     262                 :            :         {pattern_eth_ipv4_gtpu_ipv4,                    ICE_SW_INSET_MAC_GTPU_OUTER,            ICE_SW_INSET_GTPU_IPV4,                 ICE_INSET_NONE},
     263                 :            :         {pattern_eth_ipv4_gtpu_eh_ipv4,                 ICE_SW_INSET_MAC_GTPU_EH_OUTER,         ICE_SW_INSET_GTPU_IPV4,                 ICE_INSET_NONE},
     264                 :            :         {pattern_eth_ipv4_gtpu_ipv4_udp,                ICE_SW_INSET_MAC_GTPU_OUTER,            ICE_SW_INSET_GTPU_IPV4_UDP,             ICE_INSET_NONE},
     265                 :            :         {pattern_eth_ipv4_gtpu_eh_ipv4_udp,             ICE_SW_INSET_MAC_GTPU_EH_OUTER,         ICE_SW_INSET_GTPU_IPV4_UDP,             ICE_INSET_NONE},
     266                 :            :         {pattern_eth_ipv4_gtpu_ipv4_tcp,                ICE_SW_INSET_MAC_GTPU_OUTER,            ICE_SW_INSET_GTPU_IPV4_TCP,             ICE_INSET_NONE},
     267                 :            :         {pattern_eth_ipv4_gtpu_eh_ipv4_tcp,             ICE_SW_INSET_MAC_GTPU_EH_OUTER,         ICE_SW_INSET_GTPU_IPV4_TCP,             ICE_INSET_NONE},
     268                 :            :         {pattern_eth_ipv4_gtpu_ipv6,                    ICE_SW_INSET_MAC_GTPU_OUTER,            ICE_SW_INSET_GTPU_IPV6,                 ICE_INSET_NONE},
     269                 :            :         {pattern_eth_ipv4_gtpu_eh_ipv6,                 ICE_SW_INSET_MAC_GTPU_EH_OUTER,         ICE_SW_INSET_GTPU_IPV6,                 ICE_INSET_NONE},
     270                 :            :         {pattern_eth_ipv4_gtpu_ipv6_udp,                ICE_SW_INSET_MAC_GTPU_OUTER,            ICE_SW_INSET_GTPU_IPV6_UDP,             ICE_INSET_NONE},
     271                 :            :         {pattern_eth_ipv4_gtpu_eh_ipv6_udp,             ICE_SW_INSET_MAC_GTPU_EH_OUTER,         ICE_SW_INSET_GTPU_IPV6_UDP,             ICE_INSET_NONE},
     272                 :            :         {pattern_eth_ipv4_gtpu_ipv6_tcp,                ICE_SW_INSET_MAC_GTPU_OUTER,            ICE_SW_INSET_GTPU_IPV6_TCP,             ICE_INSET_NONE},
     273                 :            :         {pattern_eth_ipv4_gtpu_eh_ipv6_tcp,             ICE_SW_INSET_MAC_GTPU_EH_OUTER,         ICE_SW_INSET_GTPU_IPV6_TCP,             ICE_INSET_NONE},
     274                 :            :         {pattern_eth_ipv6_gtpu_ipv4,                    ICE_SW_INSET_MAC_GTPU_OUTER,            ICE_SW_INSET_GTPU_IPV4,                 ICE_INSET_NONE},
     275                 :            :         {pattern_eth_ipv6_gtpu_eh_ipv4,                 ICE_SW_INSET_MAC_GTPU_EH_OUTER,         ICE_SW_INSET_GTPU_IPV4,                 ICE_INSET_NONE},
     276                 :            :         {pattern_eth_ipv6_gtpu_ipv4_udp,                ICE_SW_INSET_MAC_GTPU_OUTER,            ICE_SW_INSET_GTPU_IPV4_UDP,             ICE_INSET_NONE},
     277                 :            :         {pattern_eth_ipv6_gtpu_eh_ipv4_udp,             ICE_SW_INSET_MAC_GTPU_EH_OUTER,         ICE_SW_INSET_GTPU_IPV4_UDP,             ICE_INSET_NONE},
     278                 :            :         {pattern_eth_ipv6_gtpu_ipv4_tcp,                ICE_SW_INSET_MAC_GTPU_OUTER,            ICE_SW_INSET_GTPU_IPV4_TCP,             ICE_INSET_NONE},
     279                 :            :         {pattern_eth_ipv6_gtpu_eh_ipv4_tcp,             ICE_SW_INSET_MAC_GTPU_EH_OUTER,         ICE_SW_INSET_GTPU_IPV4_TCP,             ICE_INSET_NONE},
     280                 :            :         {pattern_eth_ipv6_gtpu_ipv6,                    ICE_SW_INSET_MAC_GTPU_OUTER,            ICE_SW_INSET_GTPU_IPV6,                 ICE_INSET_NONE},
     281                 :            :         {pattern_eth_ipv6_gtpu_eh_ipv6,                 ICE_SW_INSET_MAC_GTPU_EH_OUTER,         ICE_SW_INSET_GTPU_IPV6,                 ICE_INSET_NONE},
     282                 :            :         {pattern_eth_ipv6_gtpu_ipv6_udp,                ICE_SW_INSET_MAC_GTPU_OUTER,            ICE_SW_INSET_GTPU_IPV6_UDP,             ICE_INSET_NONE},
     283                 :            :         {pattern_eth_ipv6_gtpu_eh_ipv6_udp,             ICE_SW_INSET_MAC_GTPU_EH_OUTER,         ICE_SW_INSET_GTPU_IPV6_UDP,             ICE_INSET_NONE},
     284                 :            :         {pattern_eth_ipv6_gtpu_ipv6_tcp,                ICE_SW_INSET_MAC_GTPU_OUTER,            ICE_SW_INSET_GTPU_IPV6_TCP,             ICE_INSET_NONE},
     285                 :            :         {pattern_eth_ipv6_gtpu_eh_ipv6_tcp,             ICE_SW_INSET_MAC_GTPU_EH_OUTER,         ICE_SW_INSET_GTPU_IPV6_TCP,             ICE_INSET_NONE},
     286                 :            : };
     287                 :            : 
     288                 :            : static int
     289                 :          0 : ice_switch_create(struct ice_adapter *ad,
     290                 :            :                 struct rte_flow *flow,
     291                 :            :                 void *meta,
     292                 :            :                 struct rte_flow_error *error)
     293                 :            : {
     294                 :            :         int ret = 0;
     295                 :            :         struct ice_pf *pf = &ad->pf;
     296                 :          0 :         struct ice_hw *hw = ICE_PF_TO_HW(pf);
     297                 :          0 :         struct ice_rule_query_data rule_added = {0};
     298                 :            :         struct ice_switch_filter_conf *filter_conf_ptr;
     299                 :          0 :         struct ice_adv_lkup_elem *list =
     300                 :            :                 ((struct sw_meta *)meta)->list;
     301                 :          0 :         uint16_t lkups_cnt =
     302                 :            :                 ((struct sw_meta *)meta)->lkups_num;
     303                 :          0 :         struct ice_adv_rule_info *rule_info =
     304                 :            :                 &((struct sw_meta *)meta)->rule_info;
     305                 :            : 
     306         [ #  # ]:          0 :         if (lkups_cnt > ICE_MAX_CHAIN_WORDS) {
     307                 :          0 :                 rte_flow_error_set(error, EINVAL,
     308                 :            :                         RTE_FLOW_ERROR_TYPE_ITEM, NULL,
     309                 :            :                         "item number too large for rule");
     310                 :          0 :                 goto error;
     311                 :            :         }
     312         [ #  # ]:          0 :         if (!list) {
     313                 :          0 :                 rte_flow_error_set(error, EINVAL,
     314                 :            :                         RTE_FLOW_ERROR_TYPE_ITEM, NULL,
     315                 :            :                         "lookup list should not be NULL");
     316                 :          0 :                 goto error;
     317                 :            :         }
     318                 :            : 
     319         [ #  # ]:          0 :         if (ice_dcf_adminq_need_retry(ad)) {
     320                 :          0 :                 rte_flow_error_set(error, EAGAIN,
     321                 :            :                         RTE_FLOW_ERROR_TYPE_ITEM, NULL,
     322                 :            :                         "DCF is not on");
     323                 :          0 :                 goto error;
     324                 :            :         }
     325                 :            : 
     326                 :          0 :         ret = ice_add_adv_rule(hw, list, lkups_cnt, rule_info, &rule_added);
     327         [ #  # ]:          0 :         if (!ret) {
     328                 :          0 :                 filter_conf_ptr = rte_zmalloc("ice_switch_filter",
     329                 :            :                         sizeof(struct ice_switch_filter_conf), 0);
     330         [ #  # ]:          0 :                 if (!filter_conf_ptr) {
     331                 :          0 :                         rte_flow_error_set(error, EINVAL,
     332                 :            :                                    RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
     333                 :            :                                    "No memory for ice_switch_filter");
     334                 :          0 :                         goto error;
     335                 :            :                 }
     336                 :            : 
     337                 :          0 :                 filter_conf_ptr->sw_query_data = rule_added;
     338                 :            : 
     339                 :          0 :                 filter_conf_ptr->vsi_num =
     340                 :          0 :                         ice_get_hw_vsi_num(hw, rule_info->sw_act.vsi_handle);
     341                 :          0 :                 filter_conf_ptr->lkups = list;
     342                 :          0 :                 filter_conf_ptr->lkups_num = lkups_cnt;
     343                 :          0 :                 filter_conf_ptr->rule_info = *rule_info;
     344                 :            : 
     345                 :          0 :                 filter_conf_ptr->fltr_status = ICE_SW_FLTR_ADDED;
     346                 :            : 
     347                 :          0 :                 flow->rule = filter_conf_ptr;
     348                 :            :         } else {
     349         [ #  # ]:          0 :                 if (ice_dcf_adminq_need_retry(ad))
     350                 :            :                         ret = -EAGAIN;
     351                 :            :                 else
     352                 :            :                         ret = -EINVAL;
     353                 :            : 
     354                 :          0 :                 rte_flow_error_set(error, -ret,
     355                 :            :                         RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
     356                 :            :                         "switch filter create flow fail");
     357                 :          0 :                 goto error;
     358                 :            :         }
     359                 :            : 
     360                 :          0 :         rte_free(meta);
     361                 :          0 :         return 0;
     362                 :            : 
     363                 :          0 : error:
     364                 :          0 :         rte_free(list);
     365                 :          0 :         rte_free(meta);
     366                 :            : 
     367                 :          0 :         return -rte_errno;
     368                 :            : }
     369                 :            : 
     370                 :            : static inline void
     371                 :          0 : ice_switch_filter_rule_free(struct rte_flow *flow)
     372                 :            : {
     373                 :          0 :         struct ice_switch_filter_conf *filter_conf_ptr =
     374                 :            :                 (struct ice_switch_filter_conf *)flow->rule;
     375                 :            : 
     376         [ #  # ]:          0 :         if (filter_conf_ptr)
     377                 :          0 :                 rte_free(filter_conf_ptr->lkups);
     378                 :            : 
     379                 :          0 :         rte_free(filter_conf_ptr);
     380                 :          0 : }
     381                 :            : 
     382                 :            : static int
     383                 :          0 : ice_switch_destroy(struct ice_adapter *ad,
     384                 :            :                 struct rte_flow *flow,
     385                 :            :                 struct rte_flow_error *error)
     386                 :            : {
     387                 :          0 :         struct ice_hw *hw = &ad->hw;
     388                 :            :         int ret;
     389                 :            :         struct ice_switch_filter_conf *filter_conf_ptr;
     390                 :            : 
     391                 :          0 :         filter_conf_ptr = (struct ice_switch_filter_conf *)
     392                 :            :                 flow->rule;
     393                 :            : 
     394         [ #  # ]:          0 :         if (!filter_conf_ptr ||
     395         [ #  # ]:          0 :             filter_conf_ptr->fltr_status == ICE_SW_FLTR_ADD_FAILED_ON_RIDRECT) {
     396                 :          0 :                 rte_flow_error_set(error, EINVAL,
     397                 :            :                         RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
     398                 :            :                         "no such flow"
     399                 :            :                         " create by switch filter");
     400                 :            : 
     401                 :          0 :                 ice_switch_filter_rule_free(flow);
     402                 :            : 
     403                 :          0 :                 return -rte_errno;
     404                 :            :         }
     405                 :            : 
     406         [ #  # ]:          0 :         if (ice_dcf_adminq_need_retry(ad)) {
     407                 :          0 :                 rte_flow_error_set(error, EAGAIN,
     408                 :            :                         RTE_FLOW_ERROR_TYPE_ITEM, NULL,
     409                 :            :                         "DCF is not on");
     410                 :          0 :                 return -rte_errno;
     411                 :            :         }
     412                 :            : 
     413                 :          0 :         ret = ice_rem_adv_rule_by_id(hw, &filter_conf_ptr->sw_query_data);
     414         [ #  # ]:          0 :         if (ret) {
     415         [ #  # ]:          0 :                 if (ice_dcf_adminq_need_retry(ad))
     416                 :            :                         ret = -EAGAIN;
     417                 :            :                 else
     418                 :            :                         ret = -EINVAL;
     419                 :            : 
     420                 :          0 :                 rte_flow_error_set(error, -ret,
     421                 :            :                         RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
     422                 :            :                         "fail to destroy switch filter rule");
     423                 :          0 :                 return -rte_errno;
     424                 :            :         }
     425                 :            : 
     426                 :          0 :         ice_switch_filter_rule_free(flow);
     427                 :          0 :         return ret;
     428                 :            : }
     429                 :            : 
     430                 :            : static bool
     431                 :          0 : ice_switch_parse_pattern(const struct rte_flow_item pattern[],
     432                 :            :                 struct rte_flow_error *error,
     433                 :            :                 struct ice_adv_lkup_elem *list,
     434                 :            :                 uint16_t *lkups_num,
     435                 :            :                 enum ice_sw_tunnel_type *tun_type,
     436                 :            :                 const struct ice_pattern_match_item *pattern_match_item)
     437                 :            : {
     438                 :            :         const struct rte_flow_item *item = pattern;
     439                 :            :         enum rte_flow_item_type item_type;
     440                 :            :         const struct rte_flow_item_eth *eth_spec, *eth_mask;
     441                 :            :         const struct rte_flow_item_ipv4 *ipv4_spec, *ipv4_mask;
     442                 :            :         const struct rte_flow_item_ipv6 *ipv6_spec, *ipv6_mask;
     443                 :            :         const struct rte_flow_item_tcp *tcp_spec, *tcp_mask;
     444                 :            :         const struct rte_flow_item_udp *udp_spec, *udp_mask;
     445                 :            :         const struct rte_flow_item_sctp *sctp_spec, *sctp_mask;
     446                 :            :         const struct rte_flow_item_nvgre *nvgre_spec, *nvgre_mask;
     447                 :            :         const struct rte_flow_item_vxlan *vxlan_spec, *vxlan_mask;
     448                 :            :         const struct rte_flow_item_vlan *vlan_spec, *vlan_mask;
     449                 :            :         const struct rte_flow_item_pppoe *pppoe_spec, *pppoe_mask;
     450                 :            :         const struct rte_flow_item_pppoe_proto_id *pppoe_proto_spec,
     451                 :            :                                 *pppoe_proto_mask;
     452                 :            :         const struct rte_flow_item_esp *esp_spec, *esp_mask;
     453                 :            :         const struct rte_flow_item_ah *ah_spec, *ah_mask;
     454                 :            :         const struct rte_flow_item_l2tpv3oip *l2tp_spec, *l2tp_mask;
     455                 :            :         const struct rte_flow_item_pfcp *pfcp_spec, *pfcp_mask;
     456                 :            :         const struct rte_flow_item_gtp *gtp_spec, *gtp_mask;
     457                 :            :         const struct rte_flow_item_gtp_psc *gtp_psc_spec, *gtp_psc_mask;
     458                 :          0 :         uint64_t outer_input_set = ICE_INSET_NONE;
     459                 :          0 :         uint64_t inner_input_set = ICE_INSET_NONE;
     460                 :            :         uint64_t *input = NULL;
     461                 :            :         uint16_t input_set_byte = 0;
     462                 :            :         bool pppoe_elem_valid = 0;
     463                 :            :         bool pppoe_patt_valid = 0;
     464                 :            :         bool pppoe_prot_valid = 0;
     465                 :            :         bool inner_vlan_valid = 0;
     466                 :            :         bool outer_vlan_valid = 0;
     467                 :            :         bool tunnel_valid = 0;
     468                 :            :         bool profile_rule = 0;
     469                 :            :         bool nvgre_valid = 0;
     470                 :            :         bool vxlan_valid = 0;
     471                 :            :         bool qinq_valid = 0;
     472                 :            :         bool ipv6_valid = 0;
     473                 :            :         bool ipv4_valid = 0;
     474                 :            :         bool udp_valid = 0;
     475                 :            :         bool tcp_valid = 0;
     476                 :            :         bool gtpu_valid = 0;
     477                 :            :         bool gtpu_psc_valid = 0;
     478                 :            :         bool inner_ipv4_valid = 0;
     479                 :            :         bool inner_ipv6_valid = 0;
     480                 :            :         bool inner_tcp_valid = 0;
     481                 :            :         bool inner_udp_valid = 0;
     482                 :            :         uint16_t j, k, t = 0;
     483                 :            : 
     484         [ #  # ]:          0 :         if (*tun_type == ICE_SW_TUN_AND_NON_TUN_QINQ ||
     485                 :            :             *tun_type == ICE_NON_TUN_QINQ)
     486                 :            :                 qinq_valid = 1;
     487                 :            : 
     488         [ #  # ]:          0 :         for (item = pattern; item->type !=
     489                 :          0 :                         RTE_FLOW_ITEM_TYPE_END; item++) {
     490         [ #  # ]:          0 :                 if (item->last) {
     491                 :          0 :                         rte_flow_error_set(error, EINVAL,
     492                 :            :                                         RTE_FLOW_ERROR_TYPE_ITEM,
     493                 :            :                                         item,
     494                 :            :                                         "Not support range");
     495                 :          0 :                         return false;
     496                 :            :                 }
     497                 :            :                 item_type = item->type;
     498                 :            : 
     499   [ #  #  #  #  :          0 :                 switch (item_type) {
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
                      # ]
     500                 :          0 :                 case RTE_FLOW_ITEM_TYPE_ANY:
     501                 :          0 :                         *tun_type = ICE_SW_TUN_AND_NON_TUN;
     502                 :          0 :                         break;
     503                 :            : 
     504                 :          0 :                 case RTE_FLOW_ITEM_TYPE_ETH:
     505                 :          0 :                         eth_spec = item->spec;
     506                 :          0 :                         eth_mask = item->mask;
     507         [ #  # ]:          0 :                         if (eth_spec && eth_mask) {
     508                 :          0 :                                 const uint8_t *a = eth_mask->hdr.src_addr.addr_bytes;
     509                 :          0 :                                 const uint8_t *b = eth_mask->hdr.dst_addr.addr_bytes;
     510         [ #  # ]:          0 :                                 if (tunnel_valid)
     511                 :            :                                         input = &inner_input_set;
     512                 :            :                                 else
     513                 :            :                                         input = &outer_input_set;
     514         [ #  # ]:          0 :                                 for (j = 0; j < RTE_ETHER_ADDR_LEN; j++) {
     515         [ #  # ]:          0 :                                         if (a[j]) {
     516                 :          0 :                                                 *input |= ICE_INSET_SMAC;
     517                 :          0 :                                                 break;
     518                 :            :                                         }
     519                 :            :                                 }
     520         [ #  # ]:          0 :                                 for (j = 0; j < RTE_ETHER_ADDR_LEN; j++) {
     521         [ #  # ]:          0 :                                         if (b[j]) {
     522                 :          0 :                                                 *input |= ICE_INSET_DMAC;
     523                 :          0 :                                                 break;
     524                 :            :                                         }
     525                 :            :                                 }
     526         [ #  # ]:          0 :                                 if (eth_mask->hdr.ether_type)
     527                 :          0 :                                         *input |= ICE_INSET_ETHERTYPE;
     528                 :          0 :                                 list[t].type = (tunnel_valid  == 0) ?
     529         [ #  # ]:          0 :                                         ICE_MAC_OFOS : ICE_MAC_IL;
     530                 :            :                                 struct ice_ether_hdr *h;
     531                 :            :                                 struct ice_ether_hdr *m;
     532                 :            :                                 uint16_t i = 0;
     533                 :            :                                 h = &list[t].h_u.eth_hdr;
     534                 :            :                                 m = &list[t].m_u.eth_hdr;
     535         [ #  # ]:          0 :                                 for (j = 0; j < RTE_ETHER_ADDR_LEN; j++) {
     536         [ #  # ]:          0 :                                         if (eth_mask->hdr.src_addr.addr_bytes[j]) {
     537                 :          0 :                                                 h->src_addr[j] =
     538                 :          0 :                                                 eth_spec->hdr.src_addr.addr_bytes[j];
     539                 :          0 :                                                 m->src_addr[j] =
     540                 :            :                                                 eth_mask->hdr.src_addr.addr_bytes[j];
     541                 :            :                                                 i = 1;
     542                 :          0 :                                                 input_set_byte++;
     543                 :            :                                         }
     544         [ #  # ]:          0 :                                         if (eth_mask->hdr.dst_addr.addr_bytes[j]) {
     545                 :          0 :                                                 h->dst_addr[j] =
     546                 :          0 :                                                 eth_spec->hdr.dst_addr.addr_bytes[j];
     547                 :          0 :                                                 m->dst_addr[j] =
     548                 :            :                                                 eth_mask->hdr.dst_addr.addr_bytes[j];
     549                 :            :                                                 i = 1;
     550                 :          0 :                                                 input_set_byte++;
     551                 :            :                                         }
     552                 :            :                                 }
     553         [ #  # ]:          0 :                                 if (i)
     554                 :          0 :                                         t++;
     555         [ #  # ]:          0 :                                 if (eth_mask->hdr.ether_type) {
     556                 :          0 :                                         list[t].type = ICE_ETYPE_OL;
     557                 :          0 :                                         list[t].h_u.ethertype.ethtype_id =
     558                 :          0 :                                                 eth_spec->hdr.ether_type;
     559                 :          0 :                                         list[t].m_u.ethertype.ethtype_id =
     560                 :            :                                                 eth_mask->hdr.ether_type;
     561                 :          0 :                                         input_set_byte += 2;
     562                 :          0 :                                         t++;
     563                 :            :                                 }
     564                 :            :                         }
     565                 :            :                         break;
     566                 :            : 
     567                 :          0 :                 case RTE_FLOW_ITEM_TYPE_IPV4:
     568                 :          0 :                         ipv4_spec = item->spec;
     569                 :          0 :                         ipv4_mask = item->mask;
     570         [ #  # ]:          0 :                         if (tunnel_valid) {
     571                 :            :                                 inner_ipv4_valid = 1;
     572                 :            :                                 input = &inner_input_set;
     573                 :            :                         } else {
     574                 :            :                                 ipv4_valid = 1;
     575                 :            :                                 input = &outer_input_set;
     576                 :            :                         }
     577                 :            : 
     578         [ #  # ]:          0 :                         if (ipv4_spec && ipv4_mask) {
     579                 :            :                                 /* Check IPv4 mask and update input set */
     580         [ #  # ]:          0 :                                 if (ipv4_mask->hdr.version_ihl ||
     581         [ #  # ]:          0 :                                         ipv4_mask->hdr.total_length ||
     582         [ #  # ]:          0 :                                         ipv4_mask->hdr.packet_id ||
     583         [ #  # ]:          0 :                                         ipv4_mask->hdr.hdr_checksum) {
     584                 :          0 :                                         rte_flow_error_set(error, EINVAL,
     585                 :            :                                                    RTE_FLOW_ERROR_TYPE_ITEM,
     586                 :            :                                                    item,
     587                 :            :                                                    "Invalid IPv4 mask.");
     588                 :          0 :                                         return false;
     589                 :            :                                 }
     590                 :            : 
     591         [ #  # ]:          0 :                                 if (ipv4_mask->hdr.src_addr)
     592                 :          0 :                                         *input |= ICE_INSET_IPV4_SRC;
     593         [ #  # ]:          0 :                                 if (ipv4_mask->hdr.dst_addr)
     594                 :          0 :                                         *input |= ICE_INSET_IPV4_DST;
     595         [ #  # ]:          0 :                                 if (ipv4_mask->hdr.time_to_live)
     596                 :          0 :                                         *input |= ICE_INSET_IPV4_TTL;
     597         [ #  # ]:          0 :                                 if (ipv4_mask->hdr.next_proto_id)
     598                 :          0 :                                         *input |= ICE_INSET_IPV4_PROTO;
     599         [ #  # ]:          0 :                                 if (ipv4_mask->hdr.type_of_service)
     600                 :          0 :                                         *input |= ICE_INSET_IPV4_TOS;
     601                 :            : 
     602                 :          0 :                                 list[t].type = (tunnel_valid  == 0) ?
     603         [ #  # ]:          0 :                                         ICE_IPV4_OFOS : ICE_IPV4_IL;
     604         [ #  # ]:          0 :                                 if (ipv4_mask->hdr.src_addr) {
     605                 :          0 :                                         list[t].h_u.ipv4_hdr.src_addr =
     606                 :          0 :                                                 ipv4_spec->hdr.src_addr;
     607                 :          0 :                                         list[t].m_u.ipv4_hdr.src_addr =
     608                 :            :                                                 ipv4_mask->hdr.src_addr;
     609                 :          0 :                                         input_set_byte += 2;
     610                 :            :                                 }
     611         [ #  # ]:          0 :                                 if (ipv4_mask->hdr.dst_addr) {
     612                 :          0 :                                         list[t].h_u.ipv4_hdr.dst_addr =
     613                 :          0 :                                                 ipv4_spec->hdr.dst_addr;
     614                 :          0 :                                         list[t].m_u.ipv4_hdr.dst_addr =
     615                 :            :                                                 ipv4_mask->hdr.dst_addr;
     616                 :          0 :                                         input_set_byte += 2;
     617                 :            :                                 }
     618         [ #  # ]:          0 :                                 if (ipv4_mask->hdr.time_to_live) {
     619                 :          0 :                                         list[t].h_u.ipv4_hdr.time_to_live =
     620                 :          0 :                                                 ipv4_spec->hdr.time_to_live;
     621                 :          0 :                                         list[t].m_u.ipv4_hdr.time_to_live =
     622                 :            :                                                 ipv4_mask->hdr.time_to_live;
     623                 :          0 :                                         input_set_byte++;
     624                 :            :                                 }
     625         [ #  # ]:          0 :                                 if (ipv4_mask->hdr.next_proto_id) {
     626                 :          0 :                                         list[t].h_u.ipv4_hdr.protocol =
     627                 :          0 :                                                 ipv4_spec->hdr.next_proto_id;
     628                 :          0 :                                         list[t].m_u.ipv4_hdr.protocol =
     629                 :            :                                                 ipv4_mask->hdr.next_proto_id;
     630                 :          0 :                                         input_set_byte++;
     631                 :            :                                 }
     632                 :          0 :                                 if ((ipv4_spec->hdr.next_proto_id &
     633         [ #  # ]:          0 :                                         ipv4_mask->hdr.next_proto_id) ==
     634                 :            :                                         ICE_IPV4_PROTO_NVGRE)
     635                 :          0 :                                         *tun_type = ICE_SW_TUN_AND_NON_TUN;
     636         [ #  # ]:          0 :                                 if (ipv4_mask->hdr.type_of_service) {
     637                 :          0 :                                         list[t].h_u.ipv4_hdr.tos =
     638                 :          0 :                                                 ipv4_spec->hdr.type_of_service;
     639                 :          0 :                                         list[t].m_u.ipv4_hdr.tos =
     640                 :            :                                                 ipv4_mask->hdr.type_of_service;
     641                 :          0 :                                         input_set_byte++;
     642                 :            :                                 }
     643                 :          0 :                                 t++;
     644                 :            :                         }
     645                 :            :                         break;
     646                 :            : 
     647                 :          0 :                 case RTE_FLOW_ITEM_TYPE_IPV6:
     648                 :          0 :                         ipv6_spec = item->spec;
     649                 :          0 :                         ipv6_mask = item->mask;
     650         [ #  # ]:          0 :                         if (tunnel_valid) {
     651                 :            :                                 inner_ipv6_valid = 1;
     652                 :            :                                 input = &inner_input_set;
     653                 :            :                         } else {
     654                 :            :                                 ipv6_valid = 1;
     655                 :            :                                 input = &outer_input_set;
     656                 :            :                         }
     657                 :            : 
     658         [ #  # ]:          0 :                         if (ipv6_spec && ipv6_mask) {
     659         [ #  # ]:          0 :                                 if (ipv6_mask->hdr.payload_len) {
     660                 :          0 :                                         rte_flow_error_set(error, EINVAL,
     661                 :            :                                            RTE_FLOW_ERROR_TYPE_ITEM,
     662                 :            :                                            item,
     663                 :            :                                            "Invalid IPv6 mask");
     664                 :          0 :                                         return false;
     665                 :            :                                 }
     666                 :            : 
     667         [ #  # ]:          0 :                                 for (j = 0; j < ICE_IPV6_ADDR_LENGTH; j++) {
     668         [ #  # ]:          0 :                                         if (ipv6_mask->hdr.src_addr[j]) {
     669                 :          0 :                                                 *input |= ICE_INSET_IPV6_SRC;
     670                 :          0 :                                                 break;
     671                 :            :                                         }
     672                 :            :                                 }
     673         [ #  # ]:          0 :                                 for (j = 0; j < ICE_IPV6_ADDR_LENGTH; j++) {
     674         [ #  # ]:          0 :                                         if (ipv6_mask->hdr.dst_addr[j]) {
     675                 :          0 :                                                 *input |= ICE_INSET_IPV6_DST;
     676                 :          0 :                                                 break;
     677                 :            :                                         }
     678                 :            :                                 }
     679         [ #  # ]:          0 :                                 if (ipv6_mask->hdr.proto)
     680                 :          0 :                                         *input |= ICE_INSET_IPV6_NEXT_HDR;
     681         [ #  # ]:          0 :                                 if (ipv6_mask->hdr.hop_limits)
     682                 :          0 :                                         *input |= ICE_INSET_IPV6_HOP_LIMIT;
     683         [ #  # ]:          0 :                                 if (ipv6_mask->hdr.vtc_flow &
     684                 :            :                                     rte_cpu_to_be_32(RTE_IPV6_HDR_TC_MASK))
     685                 :          0 :                                         *input |= ICE_INSET_IPV6_TC;
     686                 :            : 
     687                 :          0 :                                 list[t].type = (tunnel_valid  == 0) ?
     688         [ #  # ]:          0 :                                         ICE_IPV6_OFOS : ICE_IPV6_IL;
     689                 :            :                                 struct ice_ipv6_hdr *f;
     690                 :            :                                 struct ice_ipv6_hdr *s;
     691                 :            :                                 f = &list[t].h_u.ipv6_hdr;
     692                 :            :                                 s = &list[t].m_u.ipv6_hdr;
     693         [ #  # ]:          0 :                                 for (j = 0; j < ICE_IPV6_ADDR_LENGTH; j++) {
     694         [ #  # ]:          0 :                                         if (ipv6_mask->hdr.src_addr[j]) {
     695                 :          0 :                                                 f->src_addr[j] =
     696                 :          0 :                                                 ipv6_spec->hdr.src_addr[j];
     697                 :          0 :                                                 s->src_addr[j] =
     698                 :            :                                                 ipv6_mask->hdr.src_addr[j];
     699                 :          0 :                                                 input_set_byte++;
     700                 :            :                                         }
     701         [ #  # ]:          0 :                                         if (ipv6_mask->hdr.dst_addr[j]) {
     702                 :          0 :                                                 f->dst_addr[j] =
     703                 :          0 :                                                 ipv6_spec->hdr.dst_addr[j];
     704                 :          0 :                                                 s->dst_addr[j] =
     705                 :            :                                                 ipv6_mask->hdr.dst_addr[j];
     706                 :          0 :                                                 input_set_byte++;
     707                 :            :                                         }
     708                 :            :                                 }
     709         [ #  # ]:          0 :                                 if (ipv6_mask->hdr.proto) {
     710                 :          0 :                                         f->next_hdr =
     711                 :          0 :                                                 ipv6_spec->hdr.proto;
     712                 :          0 :                                         s->next_hdr =
     713                 :            :                                                 ipv6_mask->hdr.proto;
     714                 :          0 :                                         input_set_byte++;
     715                 :            :                                 }
     716         [ #  # ]:          0 :                                 if (ipv6_mask->hdr.hop_limits) {
     717                 :          0 :                                         f->hop_limit =
     718                 :          0 :                                                 ipv6_spec->hdr.hop_limits;
     719                 :          0 :                                         s->hop_limit =
     720                 :            :                                                 ipv6_mask->hdr.hop_limits;
     721                 :          0 :                                         input_set_byte++;
     722                 :            :                                 }
     723         [ #  # ]:          0 :                                 if (ipv6_mask->hdr.vtc_flow &
     724                 :            :                                                 rte_cpu_to_be_32
     725                 :            :                                                 (RTE_IPV6_HDR_TC_MASK)) {
     726                 :            :                                         struct ice_le_ver_tc_flow vtf;
     727                 :          0 :                                         vtf.u.fld.version = 0;
     728                 :          0 :                                         vtf.u.fld.flow_label = 0;
     729         [ #  # ]:          0 :                                         vtf.u.fld.tc = (rte_be_to_cpu_32
     730                 :            :                                                 (ipv6_spec->hdr.vtc_flow) &
     731                 :          0 :                                                         RTE_IPV6_HDR_TC_MASK) >>
     732                 :            :                                                         RTE_IPV6_HDR_TC_SHIFT;
     733         [ #  # ]:          0 :                                         f->be_ver_tc_flow = CPU_TO_BE32(vtf.u.val);
     734         [ #  # ]:          0 :                                         vtf.u.fld.tc = (rte_be_to_cpu_32
     735                 :            :                                                 (ipv6_mask->hdr.vtc_flow) &
     736                 :          0 :                                                         RTE_IPV6_HDR_TC_MASK) >>
     737                 :            :                                                         RTE_IPV6_HDR_TC_SHIFT;
     738         [ #  # ]:          0 :                                         s->be_ver_tc_flow = CPU_TO_BE32(vtf.u.val);
     739                 :          0 :                                         input_set_byte += 4;
     740                 :            :                                 }
     741                 :          0 :                                 t++;
     742                 :            :                         }
     743                 :            :                         break;
     744                 :            : 
     745                 :          0 :                 case RTE_FLOW_ITEM_TYPE_UDP:
     746                 :          0 :                         udp_spec = item->spec;
     747                 :          0 :                         udp_mask = item->mask;
     748         [ #  # ]:          0 :                         if (tunnel_valid) {
     749                 :            :                                 inner_udp_valid = 1;
     750                 :            :                                 input = &inner_input_set;
     751                 :            :                         } else {
     752                 :            :                                 udp_valid = 1;
     753                 :            :                                 input = &outer_input_set;
     754                 :            :                         }
     755                 :            : 
     756         [ #  # ]:          0 :                         if (udp_spec && udp_mask) {
     757                 :            :                                 /* Check UDP mask and update input set*/
     758         [ #  # ]:          0 :                                 if (udp_mask->hdr.dgram_len ||
     759         [ #  # ]:          0 :                                     udp_mask->hdr.dgram_cksum) {
     760                 :          0 :                                         rte_flow_error_set(error, EINVAL,
     761                 :            :                                                    RTE_FLOW_ERROR_TYPE_ITEM,
     762                 :            :                                                    item,
     763                 :            :                                                    "Invalid UDP mask");
     764                 :          0 :                                         return false;
     765                 :            :                                 }
     766                 :            : 
     767         [ #  # ]:          0 :                                 if (udp_mask->hdr.src_port)
     768                 :          0 :                                         *input |= ICE_INSET_UDP_SRC_PORT;
     769         [ #  # ]:          0 :                                 if (udp_mask->hdr.dst_port)
     770                 :          0 :                                         *input |= ICE_INSET_UDP_DST_PORT;
     771                 :            : 
     772   [ #  #  #  # ]:          0 :                                 if (*tun_type == ICE_SW_TUN_VXLAN &&
     773                 :            :                                                 tunnel_valid == 0)
     774                 :          0 :                                         list[t].type = ICE_UDP_OF;
     775                 :            :                                 else
     776                 :          0 :                                         list[t].type = ICE_UDP_ILOS;
     777         [ #  # ]:          0 :                                 if (udp_mask->hdr.src_port) {
     778                 :          0 :                                         list[t].h_u.l4_hdr.src_port =
     779                 :          0 :                                                 udp_spec->hdr.src_port;
     780                 :          0 :                                         list[t].m_u.l4_hdr.src_port =
     781                 :            :                                                 udp_mask->hdr.src_port;
     782                 :          0 :                                         input_set_byte += 2;
     783                 :            :                                 }
     784         [ #  # ]:          0 :                                 if (udp_mask->hdr.dst_port) {
     785                 :          0 :                                         list[t].h_u.l4_hdr.dst_port =
     786                 :          0 :                                                 udp_spec->hdr.dst_port;
     787                 :          0 :                                         list[t].m_u.l4_hdr.dst_port =
     788                 :            :                                                 udp_mask->hdr.dst_port;
     789                 :          0 :                                         input_set_byte += 2;
     790                 :            :                                 }
     791                 :          0 :                                 t++;
     792                 :            :                         }
     793                 :            :                         break;
     794                 :            : 
     795                 :          0 :                 case RTE_FLOW_ITEM_TYPE_TCP:
     796                 :          0 :                         tcp_spec = item->spec;
     797                 :          0 :                         tcp_mask = item->mask;
     798         [ #  # ]:          0 :                         if (tunnel_valid) {
     799                 :            :                                 inner_tcp_valid = 1;
     800                 :            :                                 input = &inner_input_set;
     801                 :            :                         } else {
     802                 :            :                                 tcp_valid = 1;
     803                 :            :                                 input = &outer_input_set;
     804                 :            :                         }
     805                 :            : 
     806         [ #  # ]:          0 :                         if (tcp_spec && tcp_mask) {
     807                 :            :                                 /* Check TCP mask and update input set */
     808         [ #  # ]:          0 :                                 if (tcp_mask->hdr.sent_seq ||
     809         [ #  # ]:          0 :                                         tcp_mask->hdr.recv_ack ||
     810         [ #  # ]:          0 :                                         tcp_mask->hdr.data_off ||
     811         [ #  # ]:          0 :                                         tcp_mask->hdr.tcp_flags ||
     812         [ #  # ]:          0 :                                         tcp_mask->hdr.rx_win ||
     813         [ #  # ]:          0 :                                         tcp_mask->hdr.cksum ||
     814         [ #  # ]:          0 :                                         tcp_mask->hdr.tcp_urp) {
     815                 :          0 :                                         rte_flow_error_set(error, EINVAL,
     816                 :            :                                            RTE_FLOW_ERROR_TYPE_ITEM,
     817                 :            :                                            item,
     818                 :            :                                            "Invalid TCP mask");
     819                 :          0 :                                         return false;
     820                 :            :                                 }
     821                 :            : 
     822         [ #  # ]:          0 :                                 if (tcp_mask->hdr.src_port)
     823                 :          0 :                                         *input |= ICE_INSET_TCP_SRC_PORT;
     824         [ #  # ]:          0 :                                 if (tcp_mask->hdr.dst_port)
     825                 :          0 :                                         *input |= ICE_INSET_TCP_DST_PORT;
     826                 :          0 :                                 list[t].type = ICE_TCP_IL;
     827         [ #  # ]:          0 :                                 if (tcp_mask->hdr.src_port) {
     828                 :          0 :                                         list[t].h_u.l4_hdr.src_port =
     829                 :          0 :                                                 tcp_spec->hdr.src_port;
     830                 :          0 :                                         list[t].m_u.l4_hdr.src_port =
     831                 :            :                                                 tcp_mask->hdr.src_port;
     832                 :          0 :                                         input_set_byte += 2;
     833                 :            :                                 }
     834         [ #  # ]:          0 :                                 if (tcp_mask->hdr.dst_port) {
     835                 :          0 :                                         list[t].h_u.l4_hdr.dst_port =
     836                 :          0 :                                                 tcp_spec->hdr.dst_port;
     837                 :          0 :                                         list[t].m_u.l4_hdr.dst_port =
     838                 :            :                                                 tcp_mask->hdr.dst_port;
     839                 :          0 :                                         input_set_byte += 2;
     840                 :            :                                 }
     841                 :          0 :                                 t++;
     842                 :            :                         }
     843                 :            :                         break;
     844                 :            : 
     845                 :          0 :                 case RTE_FLOW_ITEM_TYPE_SCTP:
     846                 :          0 :                         sctp_spec = item->spec;
     847                 :          0 :                         sctp_mask = item->mask;
     848         [ #  # ]:          0 :                         if (sctp_spec && sctp_mask) {
     849                 :            :                                 /* Check SCTP mask and update input set */
     850         [ #  # ]:          0 :                                 if (sctp_mask->hdr.cksum) {
     851                 :          0 :                                         rte_flow_error_set(error, EINVAL,
     852                 :            :                                            RTE_FLOW_ERROR_TYPE_ITEM,
     853                 :            :                                            item,
     854                 :            :                                            "Invalid SCTP mask");
     855                 :          0 :                                         return false;
     856                 :            :                                 }
     857         [ #  # ]:          0 :                                 if (tunnel_valid)
     858                 :            :                                         input = &inner_input_set;
     859                 :            :                                 else
     860                 :            :                                         input = &outer_input_set;
     861                 :            : 
     862         [ #  # ]:          0 :                                 if (sctp_mask->hdr.src_port)
     863                 :          0 :                                         *input |= ICE_INSET_SCTP_SRC_PORT;
     864         [ #  # ]:          0 :                                 if (sctp_mask->hdr.dst_port)
     865                 :          0 :                                         *input |= ICE_INSET_SCTP_DST_PORT;
     866                 :            : 
     867                 :          0 :                                 list[t].type = ICE_SCTP_IL;
     868         [ #  # ]:          0 :                                 if (sctp_mask->hdr.src_port) {
     869                 :          0 :                                         list[t].h_u.sctp_hdr.src_port =
     870                 :          0 :                                                 sctp_spec->hdr.src_port;
     871                 :          0 :                                         list[t].m_u.sctp_hdr.src_port =
     872                 :            :                                                 sctp_mask->hdr.src_port;
     873                 :          0 :                                         input_set_byte += 2;
     874                 :            :                                 }
     875         [ #  # ]:          0 :                                 if (sctp_mask->hdr.dst_port) {
     876                 :          0 :                                         list[t].h_u.sctp_hdr.dst_port =
     877                 :          0 :                                                 sctp_spec->hdr.dst_port;
     878                 :          0 :                                         list[t].m_u.sctp_hdr.dst_port =
     879                 :            :                                                 sctp_mask->hdr.dst_port;
     880                 :          0 :                                         input_set_byte += 2;
     881                 :            :                                 }
     882                 :          0 :                                 t++;
     883                 :            :                         }
     884                 :            :                         break;
     885                 :            : 
     886                 :          0 :                 case RTE_FLOW_ITEM_TYPE_VXLAN:
     887                 :          0 :                         vxlan_spec = item->spec;
     888                 :          0 :                         vxlan_mask = item->mask;
     889                 :            :                         /* Check if VXLAN item is used to describe protocol.
     890                 :            :                          * If yes, both spec and mask should be NULL.
     891                 :            :                          * If no, both spec and mask shouldn't be NULL.
     892                 :            :                          */
     893         [ #  # ]:          0 :                         if ((!vxlan_spec && vxlan_mask) ||
     894                 :            :                             (vxlan_spec && !vxlan_mask)) {
     895                 :          0 :                                 rte_flow_error_set(error, EINVAL,
     896                 :            :                                            RTE_FLOW_ERROR_TYPE_ITEM,
     897                 :            :                                            item,
     898                 :            :                                            "Invalid VXLAN item");
     899                 :          0 :                                 return false;
     900                 :            :                         }
     901                 :            :                         vxlan_valid = 1;
     902                 :            :                         tunnel_valid = 1;
     903                 :            :                         input = &inner_input_set;
     904         [ #  # ]:          0 :                         if (vxlan_spec && vxlan_mask) {
     905                 :          0 :                                 list[t].type = ICE_VXLAN;
     906         [ #  # ]:          0 :                                 if (vxlan_mask->hdr.vni[0] ||
     907         [ #  # ]:          0 :                                         vxlan_mask->hdr.vni[1] ||
     908         [ #  # ]:          0 :                                         vxlan_mask->hdr.vni[2]) {
     909                 :          0 :                                         list[t].h_u.tnl_hdr.vni =
     910                 :          0 :                                                 (vxlan_spec->hdr.vni[2] << 16) |
     911                 :          0 :                                                 (vxlan_spec->hdr.vni[1] << 8) |
     912                 :          0 :                                                 vxlan_spec->hdr.vni[0];
     913                 :          0 :                                         list[t].m_u.tnl_hdr.vni =
     914                 :          0 :                                                 (vxlan_mask->hdr.vni[2] << 16) |
     915                 :          0 :                                                 (vxlan_mask->hdr.vni[1] << 8) |
     916                 :          0 :                                                 vxlan_mask->hdr.vni[0];
     917                 :          0 :                                         *input |= ICE_INSET_VXLAN_VNI;
     918                 :          0 :                                         input_set_byte += 2;
     919                 :            :                                 }
     920                 :          0 :                                 t++;
     921                 :            :                         }
     922                 :            :                         break;
     923                 :            : 
     924                 :          0 :                 case RTE_FLOW_ITEM_TYPE_NVGRE:
     925                 :          0 :                         nvgre_spec = item->spec;
     926                 :          0 :                         nvgre_mask = item->mask;
     927                 :            :                         /* Check if NVGRE item is used to describe protocol.
     928                 :            :                          * If yes, both spec and mask should be NULL.
     929                 :            :                          * If no, both spec and mask shouldn't be NULL.
     930                 :            :                          */
     931         [ #  # ]:          0 :                         if ((!nvgre_spec && nvgre_mask) ||
     932                 :            :                             (nvgre_spec && !nvgre_mask)) {
     933                 :          0 :                                 rte_flow_error_set(error, EINVAL,
     934                 :            :                                            RTE_FLOW_ERROR_TYPE_ITEM,
     935                 :            :                                            item,
     936                 :            :                                            "Invalid NVGRE item");
     937                 :          0 :                                 return false;
     938                 :            :                         }
     939                 :            :                         nvgre_valid = 1;
     940                 :            :                         tunnel_valid = 1;
     941                 :            :                         input = &inner_input_set;
     942         [ #  # ]:          0 :                         if (nvgre_spec && nvgre_mask) {
     943                 :          0 :                                 list[t].type = ICE_NVGRE;
     944         [ #  # ]:          0 :                                 if (nvgre_mask->tni[0] ||
     945                 :          0 :                                         nvgre_mask->tni[1] ||
     946         [ #  # ]:          0 :                                         nvgre_mask->tni[2]) {
     947                 :          0 :                                         list[t].h_u.nvgre_hdr.tni_flow =
     948                 :          0 :                                                 (nvgre_spec->tni[2] << 16) |
     949                 :          0 :                                                 (nvgre_spec->tni[1] << 8) |
     950                 :          0 :                                                 nvgre_spec->tni[0];
     951                 :          0 :                                         list[t].m_u.nvgre_hdr.tni_flow =
     952                 :          0 :                                                 (nvgre_mask->tni[2] << 16) |
     953                 :          0 :                                                 (nvgre_mask->tni[1] << 8) |
     954                 :          0 :                                                 nvgre_mask->tni[0];
     955                 :          0 :                                         *input |= ICE_INSET_NVGRE_TNI;
     956                 :          0 :                                         input_set_byte += 2;
     957                 :            :                                 }
     958                 :          0 :                                 t++;
     959                 :            :                         }
     960                 :            :                         break;
     961                 :            : 
     962                 :          0 :                 case RTE_FLOW_ITEM_TYPE_VLAN:
     963                 :          0 :                         vlan_spec = item->spec;
     964                 :          0 :                         vlan_mask = item->mask;
     965                 :            :                         /* Check if VLAN item is used to describe protocol.
     966                 :            :                          * If yes, both spec and mask should be NULL.
     967                 :            :                          * If no, both spec and mask shouldn't be NULL.
     968                 :            :                          */
     969         [ #  # ]:          0 :                         if ((!vlan_spec && vlan_mask) ||
     970                 :            :                             (vlan_spec && !vlan_mask)) {
     971                 :          0 :                                 rte_flow_error_set(error, EINVAL,
     972                 :            :                                            RTE_FLOW_ERROR_TYPE_ITEM,
     973                 :            :                                            item,
     974                 :            :                                            "Invalid VLAN item");
     975                 :          0 :                                 return false;
     976                 :            :                         }
     977                 :            : 
     978         [ #  # ]:          0 :                         if (qinq_valid) {
     979         [ #  # ]:          0 :                                 if (!outer_vlan_valid)
     980                 :            :                                         outer_vlan_valid = 1;
     981                 :            :                                 else
     982                 :            :                                         inner_vlan_valid = 1;
     983                 :            :                         }
     984                 :            : 
     985                 :            :                         input = &outer_input_set;
     986                 :            : 
     987         [ #  # ]:          0 :                         if (vlan_spec && vlan_mask) {
     988         [ #  # ]:          0 :                                 if (qinq_valid) {
     989         [ #  # ]:          0 :                                         if (!inner_vlan_valid) {
     990                 :          0 :                                                 list[t].type = ICE_VLAN_EX;
     991                 :          0 :                                                 *input |=
     992                 :            :                                                         ICE_INSET_VLAN_OUTER;
     993                 :            :                                         } else {
     994                 :          0 :                                                 list[t].type = ICE_VLAN_IN;
     995                 :          0 :                                                 *input |=
     996                 :            :                                                         ICE_INSET_VLAN_INNER;
     997                 :            :                                         }
     998                 :            :                                 } else {
     999                 :          0 :                                         list[t].type = ICE_VLAN_OFOS;
    1000                 :          0 :                                         *input |= ICE_INSET_VLAN_INNER;
    1001                 :            :                                 }
    1002                 :            : 
    1003         [ #  # ]:          0 :                                 if (vlan_mask->hdr.vlan_tci) {
    1004                 :          0 :                                         list[t].h_u.vlan_hdr.vlan =
    1005                 :          0 :                                                 vlan_spec->hdr.vlan_tci;
    1006                 :          0 :                                         list[t].m_u.vlan_hdr.vlan =
    1007                 :            :                                                 vlan_mask->hdr.vlan_tci;
    1008                 :          0 :                                         input_set_byte += 2;
    1009                 :            :                                 }
    1010         [ #  # ]:          0 :                                 if (vlan_mask->hdr.eth_proto) {
    1011                 :          0 :                                         rte_flow_error_set(error, EINVAL,
    1012                 :            :                                                 RTE_FLOW_ERROR_TYPE_ITEM,
    1013                 :            :                                                 item,
    1014                 :            :                                                 "Invalid VLAN input set.");
    1015                 :          0 :                                         return false;
    1016                 :            :                                 }
    1017                 :          0 :                                 t++;
    1018                 :            :                         }
    1019                 :            :                         break;
    1020                 :            : 
    1021                 :          0 :                 case RTE_FLOW_ITEM_TYPE_PPPOED:
    1022                 :            :                 case RTE_FLOW_ITEM_TYPE_PPPOES:
    1023                 :          0 :                         pppoe_spec = item->spec;
    1024                 :          0 :                         pppoe_mask = item->mask;
    1025                 :            :                         /* Check if PPPoE item is used to describe protocol.
    1026                 :            :                          * If yes, both spec and mask should be NULL.
    1027                 :            :                          * If no, both spec and mask shouldn't be NULL.
    1028                 :            :                          */
    1029         [ #  # ]:          0 :                         if ((!pppoe_spec && pppoe_mask) ||
    1030                 :            :                                 (pppoe_spec && !pppoe_mask)) {
    1031                 :          0 :                                 rte_flow_error_set(error, EINVAL,
    1032                 :            :                                         RTE_FLOW_ERROR_TYPE_ITEM,
    1033                 :            :                                         item,
    1034                 :            :                                         "Invalid pppoe item");
    1035                 :          0 :                                 return false;
    1036                 :            :                         }
    1037                 :            :                         pppoe_patt_valid = 1;
    1038                 :            :                         input = &outer_input_set;
    1039         [ #  # ]:          0 :                         if (pppoe_spec && pppoe_mask) {
    1040                 :            :                                 /* Check pppoe mask and update input set */
    1041         [ #  # ]:          0 :                                 if (pppoe_mask->length ||
    1042         [ #  # ]:          0 :                                         pppoe_mask->code ||
    1043                 :            :                                         pppoe_mask->version_type) {
    1044                 :          0 :                                         rte_flow_error_set(error, EINVAL,
    1045                 :            :                                                 RTE_FLOW_ERROR_TYPE_ITEM,
    1046                 :            :                                                 item,
    1047                 :            :                                                 "Invalid pppoe mask");
    1048                 :          0 :                                         return false;
    1049                 :            :                                 }
    1050                 :          0 :                                 list[t].type = ICE_PPPOE;
    1051         [ #  # ]:          0 :                                 if (pppoe_mask->session_id) {
    1052                 :          0 :                                         list[t].h_u.pppoe_hdr.session_id =
    1053                 :          0 :                                                 pppoe_spec->session_id;
    1054                 :          0 :                                         list[t].m_u.pppoe_hdr.session_id =
    1055                 :            :                                                 pppoe_mask->session_id;
    1056                 :          0 :                                         *input |= ICE_INSET_PPPOE_SESSION;
    1057                 :          0 :                                         input_set_byte += 2;
    1058                 :            :                                 }
    1059                 :          0 :                                 t++;
    1060                 :            :                                 pppoe_elem_valid = 1;
    1061                 :            :                         }
    1062                 :            :                         break;
    1063                 :            : 
    1064                 :          0 :                 case RTE_FLOW_ITEM_TYPE_PPPOE_PROTO_ID:
    1065                 :          0 :                         pppoe_proto_spec = item->spec;
    1066                 :          0 :                         pppoe_proto_mask = item->mask;
    1067                 :            :                         /* Check if PPPoE optional proto_id item
    1068                 :            :                          * is used to describe protocol.
    1069                 :            :                          * If yes, both spec and mask should be NULL.
    1070                 :            :                          * If no, both spec and mask shouldn't be NULL.
    1071                 :            :                          */
    1072         [ #  # ]:          0 :                         if ((!pppoe_proto_spec && pppoe_proto_mask) ||
    1073                 :            :                                 (pppoe_proto_spec && !pppoe_proto_mask)) {
    1074                 :          0 :                                 rte_flow_error_set(error, EINVAL,
    1075                 :            :                                         RTE_FLOW_ERROR_TYPE_ITEM,
    1076                 :            :                                         item,
    1077                 :            :                                         "Invalid pppoe proto item");
    1078                 :          0 :                                 return false;
    1079                 :            :                         }
    1080                 :            :                         input = &outer_input_set;
    1081         [ #  # ]:          0 :                         if (pppoe_proto_spec && pppoe_proto_mask) {
    1082         [ #  # ]:          0 :                                 if (pppoe_elem_valid)
    1083                 :          0 :                                         t--;
    1084                 :          0 :                                 list[t].type = ICE_PPPOE;
    1085         [ #  # ]:          0 :                                 if (pppoe_proto_mask->proto_id) {
    1086                 :          0 :                                         list[t].h_u.pppoe_hdr.ppp_prot_id =
    1087                 :          0 :                                                 pppoe_proto_spec->proto_id;
    1088                 :          0 :                                         list[t].m_u.pppoe_hdr.ppp_prot_id =
    1089                 :            :                                                 pppoe_proto_mask->proto_id;
    1090                 :          0 :                                         *input |= ICE_INSET_PPPOE_PROTO;
    1091                 :          0 :                                         input_set_byte += 2;
    1092                 :            :                                         pppoe_prot_valid = 1;
    1093                 :            :                                 }
    1094                 :          0 :                                 if ((pppoe_proto_mask->proto_id &
    1095         [ #  # ]:          0 :                                         pppoe_proto_spec->proto_id) !=
    1096         [ #  # ]:          0 :                                             CPU_TO_BE16(ICE_PPP_IPV4_PROTO) &&
    1097                 :            :                                         (pppoe_proto_mask->proto_id &
    1098                 :            :                                         pppoe_proto_spec->proto_id) !=
    1099                 :            :                                             CPU_TO_BE16(ICE_PPP_IPV6_PROTO))
    1100                 :          0 :                                         *tun_type = ICE_SW_TUN_PPPOE_PAY;
    1101                 :            :                                 else
    1102                 :          0 :                                         *tun_type = ICE_SW_TUN_PPPOE;
    1103                 :          0 :                                 t++;
    1104                 :            :                         }
    1105                 :            : 
    1106                 :            :                         break;
    1107                 :            : 
    1108                 :          0 :                 case RTE_FLOW_ITEM_TYPE_ESP:
    1109                 :          0 :                         esp_spec = item->spec;
    1110                 :          0 :                         esp_mask = item->mask;
    1111         [ #  # ]:          0 :                         if ((esp_spec && !esp_mask) ||
    1112                 :            :                                 (!esp_spec && esp_mask)) {
    1113                 :          0 :                                 rte_flow_error_set(error, EINVAL,
    1114                 :            :                                            RTE_FLOW_ERROR_TYPE_ITEM,
    1115                 :            :                                            item,
    1116                 :            :                                            "Invalid esp item");
    1117                 :          0 :                                 return false;
    1118                 :            :                         }
    1119                 :            :                         /* Check esp mask and update input set */
    1120   [ #  #  #  # ]:          0 :                         if (esp_mask && esp_mask->hdr.seq) {
    1121                 :          0 :                                 rte_flow_error_set(error, EINVAL,
    1122                 :            :                                                 RTE_FLOW_ERROR_TYPE_ITEM,
    1123                 :            :                                                 item,
    1124                 :            :                                                 "Invalid esp mask");
    1125                 :          0 :                                 return false;
    1126                 :            :                         }
    1127                 :            :                         input = &outer_input_set;
    1128   [ #  #  #  # ]:          0 :                         if (!esp_spec && !esp_mask && !(*input)) {
    1129                 :            :                                 profile_rule = 1;
    1130         [ #  # ]:          0 :                                 if (ipv6_valid && udp_valid)
    1131                 :          0 :                                         *tun_type =
    1132                 :            :                                         ICE_SW_TUN_PROFID_IPV6_NAT_T;
    1133         [ #  # ]:          0 :                                 else if (ipv6_valid)
    1134                 :          0 :                                         *tun_type = ICE_SW_TUN_PROFID_IPV6_ESP;
    1135         [ #  # ]:          0 :                                 else if (ipv4_valid)
    1136                 :          0 :                                         goto inset_check;
    1137         [ #  # ]:          0 :                         } else if (esp_spec && esp_mask &&
    1138         [ #  # ]:          0 :                                                 esp_mask->hdr.spi){
    1139         [ #  # ]:          0 :                                 if (udp_valid)
    1140                 :          0 :                                         list[t].type = ICE_NAT_T;
    1141                 :            :                                 else
    1142                 :          0 :                                         list[t].type = ICE_ESP;
    1143                 :          0 :                                 list[t].h_u.esp_hdr.spi =
    1144                 :          0 :                                         esp_spec->hdr.spi;
    1145                 :          0 :                                 list[t].m_u.esp_hdr.spi =
    1146                 :            :                                         esp_mask->hdr.spi;
    1147                 :          0 :                                 *input |= ICE_INSET_ESP_SPI;
    1148                 :          0 :                                 input_set_byte += 4;
    1149                 :          0 :                                 t++;
    1150                 :            :                         }
    1151                 :            : 
    1152         [ #  # ]:          0 :                         if (!profile_rule) {
    1153         [ #  # ]:          0 :                                 if (ipv6_valid && udp_valid)
    1154                 :          0 :                                         *tun_type = ICE_SW_TUN_IPV6_NAT_T;
    1155         [ #  # ]:          0 :                                 else if (ipv4_valid && udp_valid)
    1156                 :          0 :                                         *tun_type = ICE_SW_TUN_IPV4_NAT_T;
    1157         [ #  # ]:          0 :                                 else if (ipv6_valid)
    1158                 :          0 :                                         *tun_type = ICE_SW_TUN_IPV6_ESP;
    1159         [ #  # ]:          0 :                                 else if (ipv4_valid)
    1160                 :          0 :                                         *tun_type = ICE_SW_TUN_IPV4_ESP;
    1161                 :            :                         }
    1162                 :            :                         break;
    1163                 :            : 
    1164                 :          0 :                 case RTE_FLOW_ITEM_TYPE_AH:
    1165                 :          0 :                         ah_spec = item->spec;
    1166                 :          0 :                         ah_mask = item->mask;
    1167         [ #  # ]:          0 :                         if ((ah_spec && !ah_mask) ||
    1168                 :            :                                 (!ah_spec && ah_mask)) {
    1169                 :          0 :                                 rte_flow_error_set(error, EINVAL,
    1170                 :            :                                            RTE_FLOW_ERROR_TYPE_ITEM,
    1171                 :            :                                            item,
    1172                 :            :                                            "Invalid ah item");
    1173                 :          0 :                                 return false;
    1174                 :            :                         }
    1175                 :            :                         /* Check ah mask and update input set */
    1176         [ #  # ]:          0 :                         if (ah_mask &&
    1177         [ #  # ]:          0 :                                 (ah_mask->next_hdr ||
    1178                 :          0 :                                 ah_mask->payload_len ||
    1179         [ #  # ]:          0 :                                 ah_mask->seq_num ||
    1180         [ #  # ]:          0 :                                 ah_mask->reserved)) {
    1181                 :          0 :                                 rte_flow_error_set(error, EINVAL,
    1182                 :            :                                                 RTE_FLOW_ERROR_TYPE_ITEM,
    1183                 :            :                                                 item,
    1184                 :            :                                                 "Invalid ah mask");
    1185                 :          0 :                                 return false;
    1186                 :            :                         }
    1187                 :            : 
    1188                 :            :                         input = &outer_input_set;
    1189   [ #  #  #  # ]:          0 :                         if (!ah_spec && !ah_mask && !(*input)) {
    1190                 :            :                                 profile_rule = 1;
    1191         [ #  # ]:          0 :                                 if (ipv6_valid && udp_valid)
    1192                 :          0 :                                         *tun_type =
    1193                 :            :                                         ICE_SW_TUN_PROFID_IPV6_NAT_T;
    1194         [ #  # ]:          0 :                                 else if (ipv6_valid)
    1195                 :          0 :                                         *tun_type = ICE_SW_TUN_PROFID_IPV6_AH;
    1196         [ #  # ]:          0 :                                 else if (ipv4_valid)
    1197                 :          0 :                                         goto inset_check;
    1198         [ #  # ]:          0 :                         } else if (ah_spec && ah_mask &&
    1199         [ #  # ]:          0 :                                                 ah_mask->spi){
    1200                 :          0 :                                 list[t].type = ICE_AH;
    1201                 :          0 :                                 list[t].h_u.ah_hdr.spi =
    1202                 :          0 :                                         ah_spec->spi;
    1203                 :          0 :                                 list[t].m_u.ah_hdr.spi =
    1204                 :            :                                         ah_mask->spi;
    1205                 :          0 :                                 *input |= ICE_INSET_AH_SPI;
    1206                 :          0 :                                 input_set_byte += 4;
    1207                 :          0 :                                 t++;
    1208                 :            :                         }
    1209                 :            : 
    1210         [ #  # ]:          0 :                         if (!profile_rule) {
    1211         [ #  # ]:          0 :                                 if (udp_valid)
    1212                 :          0 :                                         goto inset_check;
    1213         [ #  # ]:          0 :                                 else if (ipv6_valid)
    1214                 :          0 :                                         *tun_type = ICE_SW_TUN_IPV6_AH;
    1215         [ #  # ]:          0 :                                 else if (ipv4_valid)
    1216                 :          0 :                                         *tun_type = ICE_SW_TUN_IPV4_AH;
    1217                 :            :                         }
    1218                 :            :                         break;
    1219                 :            : 
    1220                 :          0 :                 case RTE_FLOW_ITEM_TYPE_L2TPV3OIP:
    1221                 :          0 :                         l2tp_spec = item->spec;
    1222                 :          0 :                         l2tp_mask = item->mask;
    1223         [ #  # ]:          0 :                         if ((l2tp_spec && !l2tp_mask) ||
    1224                 :            :                                 (!l2tp_spec && l2tp_mask)) {
    1225                 :          0 :                                 rte_flow_error_set(error, EINVAL,
    1226                 :            :                                            RTE_FLOW_ERROR_TYPE_ITEM,
    1227                 :            :                                            item,
    1228                 :            :                                            "Invalid l2tp item");
    1229                 :          0 :                                 return false;
    1230                 :            :                         }
    1231                 :            : 
    1232                 :            :                         input = &outer_input_set;
    1233   [ #  #  #  # ]:          0 :                         if (!l2tp_spec && !l2tp_mask && !(*input)) {
    1234         [ #  # ]:          0 :                                 if (ipv6_valid)
    1235                 :          0 :                                         *tun_type =
    1236                 :            :                                         ICE_SW_TUN_PROFID_MAC_IPV6_L2TPV3;
    1237         [ #  # ]:          0 :                                 else if (ipv4_valid)
    1238                 :          0 :                                         goto inset_check;
    1239         [ #  # ]:          0 :                         } else if (l2tp_spec && l2tp_mask &&
    1240         [ #  # ]:          0 :                                                 l2tp_mask->session_id){
    1241                 :          0 :                                 list[t].type = ICE_L2TPV3;
    1242                 :          0 :                                 list[t].h_u.l2tpv3_sess_hdr.session_id =
    1243                 :          0 :                                         l2tp_spec->session_id;
    1244                 :          0 :                                 list[t].m_u.l2tpv3_sess_hdr.session_id =
    1245                 :            :                                         l2tp_mask->session_id;
    1246                 :          0 :                                 *input |= ICE_INSET_L2TPV3OIP_SESSION_ID;
    1247                 :          0 :                                 input_set_byte += 4;
    1248                 :          0 :                                 t++;
    1249                 :            :                         }
    1250                 :            : 
    1251         [ #  # ]:          0 :                         if (!profile_rule) {
    1252         [ #  # ]:          0 :                                 if (ipv6_valid)
    1253                 :          0 :                                         *tun_type =
    1254                 :            :                                         ICE_SW_TUN_IPV6_L2TPV3;
    1255         [ #  # ]:          0 :                                 else if (ipv4_valid)
    1256                 :          0 :                                         *tun_type =
    1257                 :            :                                         ICE_SW_TUN_IPV4_L2TPV3;
    1258                 :            :                         }
    1259                 :            :                         break;
    1260                 :            : 
    1261                 :          0 :                 case RTE_FLOW_ITEM_TYPE_PFCP:
    1262                 :          0 :                         pfcp_spec = item->spec;
    1263                 :          0 :                         pfcp_mask = item->mask;
    1264                 :            :                         /* Check if PFCP item is used to describe protocol.
    1265                 :            :                          * If yes, both spec and mask should be NULL.
    1266                 :            :                          * If no, both spec and mask shouldn't be NULL.
    1267                 :            :                          */
    1268         [ #  # ]:          0 :                         if ((!pfcp_spec && pfcp_mask) ||
    1269                 :            :                             (pfcp_spec && !pfcp_mask)) {
    1270                 :          0 :                                 rte_flow_error_set(error, EINVAL,
    1271                 :            :                                            RTE_FLOW_ERROR_TYPE_ITEM,
    1272                 :            :                                            item,
    1273                 :            :                                            "Invalid PFCP item");
    1274                 :          0 :                                 return false;
    1275                 :            :                         }
    1276         [ #  # ]:          0 :                         if (pfcp_spec && pfcp_mask) {
    1277                 :            :                                 /* Check pfcp mask and update input set */
    1278         [ #  # ]:          0 :                                 if (pfcp_mask->msg_type ||
    1279                 :          0 :                                         pfcp_mask->msg_len ||
    1280         [ #  # ]:          0 :                                         pfcp_mask->seid) {
    1281                 :          0 :                                         rte_flow_error_set(error, EINVAL,
    1282                 :            :                                                 RTE_FLOW_ERROR_TYPE_ITEM,
    1283                 :            :                                                 item,
    1284                 :            :                                                 "Invalid pfcp mask");
    1285                 :          0 :                                         return false;
    1286                 :            :                                 }
    1287         [ #  # ]:          0 :                                 if (pfcp_mask->s_field &&
    1288   [ #  #  #  # ]:          0 :                                         pfcp_spec->s_field == 0x01 &&
    1289                 :            :                                         ipv6_valid)
    1290                 :          0 :                                         *tun_type =
    1291                 :            :                                         ICE_SW_TUN_PROFID_IPV6_PFCP_SESSION;
    1292         [ #  # ]:          0 :                                 else if (pfcp_mask->s_field &&
    1293         [ #  # ]:          0 :                                         pfcp_spec->s_field == 0x01)
    1294                 :          0 :                                         *tun_type =
    1295                 :            :                                         ICE_SW_TUN_PROFID_IPV4_PFCP_SESSION;
    1296         [ #  # ]:          0 :                                 else if (pfcp_mask->s_field &&
    1297   [ #  #  #  # ]:          0 :                                         !pfcp_spec->s_field &&
    1298                 :            :                                         ipv6_valid)
    1299                 :          0 :                                         *tun_type =
    1300                 :            :                                         ICE_SW_TUN_PROFID_IPV6_PFCP_NODE;
    1301         [ #  # ]:          0 :                                 else if (pfcp_mask->s_field &&
    1302         [ #  # ]:          0 :                                         !pfcp_spec->s_field)
    1303                 :          0 :                                         *tun_type =
    1304                 :            :                                         ICE_SW_TUN_PROFID_IPV4_PFCP_NODE;
    1305                 :            :                                 else
    1306                 :            :                                         return false;
    1307                 :            :                         }
    1308                 :            :                         break;
    1309                 :            : 
    1310                 :          0 :                 case RTE_FLOW_ITEM_TYPE_GTPU:
    1311                 :          0 :                         gtp_spec = item->spec;
    1312                 :          0 :                         gtp_mask = item->mask;
    1313         [ #  # ]:          0 :                         if (gtp_spec && !gtp_mask) {
    1314                 :          0 :                                 rte_flow_error_set(error, EINVAL,
    1315                 :            :                                         RTE_FLOW_ERROR_TYPE_ITEM,
    1316                 :            :                                         item,
    1317                 :            :                                         "Invalid GTP item");
    1318                 :          0 :                                 return false;
    1319                 :            :                         }
    1320         [ #  # ]:          0 :                         if (gtp_spec && gtp_mask) {
    1321                 :          0 :                                 if (gtp_mask->hdr.gtp_hdr_info ||
    1322         [ #  # ]:          0 :                                     gtp_mask->hdr.msg_type ||
    1323                 :            :                                     gtp_mask->hdr.plen) {
    1324                 :          0 :                                         rte_flow_error_set(error, EINVAL,
    1325                 :            :                                                 RTE_FLOW_ERROR_TYPE_ITEM,
    1326                 :            :                                                 item,
    1327                 :            :                                                 "Invalid GTP mask");
    1328                 :          0 :                                         return false;
    1329                 :            :                                 }
    1330                 :            :                                 input = &outer_input_set;
    1331         [ #  # ]:          0 :                                 if (gtp_mask->hdr.teid)
    1332                 :          0 :                                         *input |= ICE_INSET_GTPU_TEID;
    1333                 :          0 :                                 list[t].type = ICE_GTP;
    1334                 :          0 :                                 list[t].h_u.gtp_hdr.teid =
    1335                 :          0 :                                         gtp_spec->hdr.teid;
    1336                 :          0 :                                 list[t].m_u.gtp_hdr.teid =
    1337                 :            :                                         gtp_mask->hdr.teid;
    1338                 :          0 :                                 input_set_byte += 4;
    1339                 :          0 :                                 t++;
    1340                 :            :                         }
    1341                 :            :                         tunnel_valid = 1;
    1342                 :            :                         gtpu_valid = 1;
    1343                 :            :                         break;
    1344                 :            : 
    1345                 :          0 :                 case RTE_FLOW_ITEM_TYPE_GTP_PSC:
    1346                 :          0 :                         gtp_psc_spec = item->spec;
    1347                 :          0 :                         gtp_psc_mask = item->mask;
    1348         [ #  # ]:          0 :                         if (gtp_psc_spec && !gtp_psc_mask) {
    1349                 :          0 :                                 rte_flow_error_set(error, EINVAL,
    1350                 :            :                                         RTE_FLOW_ERROR_TYPE_ITEM,
    1351                 :            :                                         item,
    1352                 :            :                                         "Invalid GTPU_EH item");
    1353                 :          0 :                                 return false;
    1354                 :            :                         }
    1355         [ #  # ]:          0 :                         if (gtp_psc_spec && gtp_psc_mask) {
    1356         [ #  # ]:          0 :                                 if (gtp_psc_mask->hdr.type) {
    1357                 :          0 :                                         rte_flow_error_set(error, EINVAL,
    1358                 :            :                                                 RTE_FLOW_ERROR_TYPE_ITEM,
    1359                 :            :                                                 item,
    1360                 :            :                                                 "Invalid GTPU_EH mask");
    1361                 :          0 :                                         return false;
    1362                 :            :                                 }
    1363                 :            :                                 input = &outer_input_set;
    1364         [ #  # ]:          0 :                                 if (gtp_psc_mask->hdr.qfi)
    1365                 :          0 :                                         *input |= ICE_INSET_GTPU_QFI;
    1366                 :          0 :                                 list[t].type = ICE_GTP;
    1367                 :          0 :                                 list[t].h_u.gtp_hdr.qfi =
    1368                 :          0 :                                         gtp_psc_spec->hdr.qfi;
    1369                 :          0 :                                 list[t].m_u.gtp_hdr.qfi =
    1370                 :          0 :                                         gtp_psc_mask->hdr.qfi;
    1371                 :          0 :                                 input_set_byte += 1;
    1372                 :          0 :                                 t++;
    1373                 :            :                         }
    1374                 :            :                         gtpu_psc_valid = 1;
    1375                 :            :                         break;
    1376                 :            : 
    1377                 :            :                 case RTE_FLOW_ITEM_TYPE_VOID:
    1378                 :            :                         break;
    1379                 :            : 
    1380                 :          0 :                 default:
    1381                 :          0 :                         rte_flow_error_set(error, EINVAL,
    1382                 :            :                                    RTE_FLOW_ERROR_TYPE_ITEM, pattern,
    1383                 :            :                                    "Invalid pattern item.");
    1384                 :          0 :                         return false;
    1385                 :            :                 }
    1386                 :            :         }
    1387                 :            : 
    1388         [ #  # ]:          0 :         if (*tun_type == ICE_SW_TUN_PPPOE_PAY &&
    1389         [ #  # ]:          0 :             inner_vlan_valid && outer_vlan_valid)
    1390                 :          0 :                 *tun_type = ICE_SW_TUN_PPPOE_PAY_QINQ;
    1391         [ #  # ]:          0 :         else if (*tun_type == ICE_SW_TUN_PPPOE &&
    1392         [ #  # ]:          0 :                  inner_vlan_valid && outer_vlan_valid)
    1393                 :          0 :                 *tun_type = ICE_SW_TUN_PPPOE_QINQ;
    1394         [ #  # ]:          0 :         else if (*tun_type == ICE_NON_TUN &&
    1395         [ #  # ]:          0 :                  inner_vlan_valid && outer_vlan_valid)
    1396                 :          0 :                 *tun_type = ICE_NON_TUN_QINQ;
    1397         [ #  # ]:          0 :         else if (*tun_type == ICE_SW_TUN_AND_NON_TUN &&
    1398         [ #  # ]:          0 :                  inner_vlan_valid && outer_vlan_valid)
    1399                 :          0 :                 *tun_type = ICE_SW_TUN_AND_NON_TUN_QINQ;
    1400                 :            : 
    1401         [ #  # ]:          0 :         if (pppoe_patt_valid && !pppoe_prot_valid) {
    1402   [ #  #  #  # ]:          0 :                 if (inner_vlan_valid && outer_vlan_valid && ipv4_valid)
    1403                 :          0 :                         *tun_type = ICE_SW_TUN_PPPOE_IPV4_QINQ;
    1404   [ #  #  #  # ]:          0 :                 else if (inner_vlan_valid && outer_vlan_valid && ipv6_valid)
    1405                 :          0 :                         *tun_type = ICE_SW_TUN_PPPOE_IPV6_QINQ;
    1406         [ #  # ]:          0 :                 else if (inner_vlan_valid && outer_vlan_valid)
    1407                 :          0 :                         *tun_type = ICE_SW_TUN_PPPOE_QINQ;
    1408         [ #  # ]:          0 :                 else if (ipv6_valid && udp_valid)
    1409                 :          0 :                         *tun_type = ICE_SW_TUN_PPPOE_IPV6_UDP;
    1410         [ #  # ]:          0 :                 else if (ipv6_valid && tcp_valid)
    1411                 :          0 :                         *tun_type = ICE_SW_TUN_PPPOE_IPV6_TCP;
    1412         [ #  # ]:          0 :                 else if (ipv4_valid && udp_valid)
    1413                 :          0 :                         *tun_type = ICE_SW_TUN_PPPOE_IPV4_UDP;
    1414         [ #  # ]:          0 :                 else if (ipv4_valid && tcp_valid)
    1415                 :          0 :                         *tun_type = ICE_SW_TUN_PPPOE_IPV4_TCP;
    1416         [ #  # ]:          0 :                 else if (ipv6_valid)
    1417                 :          0 :                         *tun_type = ICE_SW_TUN_PPPOE_IPV6;
    1418         [ #  # ]:          0 :                 else if (ipv4_valid)
    1419                 :          0 :                         *tun_type = ICE_SW_TUN_PPPOE_IPV4;
    1420                 :            :                 else
    1421                 :          0 :                         *tun_type = ICE_SW_TUN_PPPOE;
    1422                 :            :         }
    1423                 :            : 
    1424         [ #  # ]:          0 :         if (gtpu_valid && gtpu_psc_valid) {
    1425   [ #  #  #  # ]:          0 :                 if (ipv4_valid && inner_ipv4_valid && inner_udp_valid)
    1426                 :          0 :                         *tun_type = ICE_SW_TUN_IPV4_GTPU_EH_IPV4_UDP;
    1427   [ #  #  #  # ]:          0 :                 else if (ipv4_valid && inner_ipv4_valid && inner_tcp_valid)
    1428                 :          0 :                         *tun_type = ICE_SW_TUN_IPV4_GTPU_EH_IPV4_TCP;
    1429         [ #  # ]:          0 :                 else if (ipv4_valid && inner_ipv4_valid)
    1430                 :          0 :                         *tun_type = ICE_SW_TUN_IPV4_GTPU_EH_IPV4;
    1431   [ #  #  #  # ]:          0 :                 else if (ipv4_valid && inner_ipv6_valid && inner_udp_valid)
    1432                 :          0 :                         *tun_type = ICE_SW_TUN_IPV4_GTPU_EH_IPV6_UDP;
    1433   [ #  #  #  # ]:          0 :                 else if (ipv4_valid && inner_ipv6_valid && inner_tcp_valid)
    1434                 :          0 :                         *tun_type = ICE_SW_TUN_IPV4_GTPU_EH_IPV6_TCP;
    1435         [ #  # ]:          0 :                 else if (ipv4_valid && inner_ipv6_valid)
    1436                 :          0 :                         *tun_type = ICE_SW_TUN_IPV4_GTPU_EH_IPV6;
    1437   [ #  #  #  # ]:          0 :                 else if (ipv6_valid && inner_ipv4_valid && inner_udp_valid)
    1438                 :          0 :                         *tun_type = ICE_SW_TUN_IPV6_GTPU_EH_IPV4_UDP;
    1439   [ #  #  #  # ]:          0 :                 else if (ipv6_valid && inner_ipv4_valid && inner_tcp_valid)
    1440                 :          0 :                         *tun_type = ICE_SW_TUN_IPV6_GTPU_EH_IPV4_TCP;
    1441         [ #  # ]:          0 :                 else if (ipv6_valid && inner_ipv4_valid)
    1442                 :          0 :                         *tun_type = ICE_SW_TUN_IPV6_GTPU_EH_IPV4;
    1443   [ #  #  #  # ]:          0 :                 else if (ipv6_valid && inner_ipv6_valid && inner_udp_valid)
    1444                 :          0 :                         *tun_type = ICE_SW_TUN_IPV6_GTPU_EH_IPV6_UDP;
    1445   [ #  #  #  # ]:          0 :                 else if (ipv6_valid && inner_ipv6_valid && inner_tcp_valid)
    1446                 :          0 :                         *tun_type = ICE_SW_TUN_IPV6_GTPU_EH_IPV6_TCP;
    1447         [ #  # ]:          0 :                 else if (ipv6_valid && inner_ipv6_valid)
    1448                 :          0 :                         *tun_type = ICE_SW_TUN_IPV6_GTPU_EH_IPV6;
    1449         [ #  # ]:          0 :                 else if (ipv4_valid)
    1450                 :          0 :                         *tun_type = ICE_SW_TUN_IPV4_GTPU_NO_PAY;
    1451         [ #  # ]:          0 :                 else if (ipv6_valid)
    1452                 :          0 :                         *tun_type = ICE_SW_TUN_IPV6_GTPU_NO_PAY;
    1453         [ #  # ]:          0 :         } else if (gtpu_valid) {
    1454   [ #  #  #  # ]:          0 :                 if (ipv4_valid && inner_ipv4_valid && inner_udp_valid)
    1455                 :          0 :                         *tun_type = ICE_SW_TUN_IPV4_GTPU_IPV4_UDP;
    1456   [ #  #  #  # ]:          0 :                 else if (ipv4_valid && inner_ipv4_valid && inner_tcp_valid)
    1457                 :          0 :                         *tun_type = ICE_SW_TUN_IPV4_GTPU_IPV4_TCP;
    1458         [ #  # ]:          0 :                 else if (ipv4_valid && inner_ipv4_valid)
    1459                 :          0 :                         *tun_type = ICE_SW_TUN_IPV4_GTPU_IPV4;
    1460   [ #  #  #  # ]:          0 :                 else if (ipv4_valid && inner_ipv6_valid && inner_udp_valid)
    1461                 :          0 :                         *tun_type = ICE_SW_TUN_IPV4_GTPU_IPV6_UDP;
    1462   [ #  #  #  # ]:          0 :                 else if (ipv4_valid && inner_ipv6_valid && inner_tcp_valid)
    1463                 :          0 :                         *tun_type = ICE_SW_TUN_IPV4_GTPU_IPV6_TCP;
    1464         [ #  # ]:          0 :                 else if (ipv4_valid && inner_ipv6_valid)
    1465                 :          0 :                         *tun_type = ICE_SW_TUN_IPV4_GTPU_IPV6;
    1466   [ #  #  #  # ]:          0 :                 else if (ipv6_valid && inner_ipv4_valid && inner_udp_valid)
    1467                 :          0 :                         *tun_type = ICE_SW_TUN_IPV6_GTPU_IPV4_UDP;
    1468   [ #  #  #  # ]:          0 :                 else if (ipv6_valid && inner_ipv4_valid && inner_tcp_valid)
    1469                 :          0 :                         *tun_type = ICE_SW_TUN_IPV6_GTPU_IPV4_TCP;
    1470         [ #  # ]:          0 :                 else if (ipv6_valid && inner_ipv4_valid)
    1471                 :          0 :                         *tun_type = ICE_SW_TUN_IPV6_GTPU_IPV4;
    1472   [ #  #  #  # ]:          0 :                 else if (ipv6_valid && inner_ipv6_valid && inner_udp_valid)
    1473                 :          0 :                         *tun_type = ICE_SW_TUN_IPV6_GTPU_IPV6_UDP;
    1474   [ #  #  #  # ]:          0 :                 else if (ipv6_valid && inner_ipv6_valid && inner_tcp_valid)
    1475                 :          0 :                         *tun_type = ICE_SW_TUN_IPV6_GTPU_IPV6_TCP;
    1476         [ #  # ]:          0 :                 else if (ipv6_valid && inner_ipv6_valid)
    1477                 :          0 :                         *tun_type = ICE_SW_TUN_IPV6_GTPU_IPV6;
    1478         [ #  # ]:          0 :                 else if (ipv4_valid)
    1479                 :          0 :                         *tun_type = ICE_SW_TUN_IPV4_GTPU_NO_PAY;
    1480         [ #  # ]:          0 :                 else if (ipv6_valid)
    1481                 :          0 :                         *tun_type = ICE_SW_TUN_IPV6_GTPU_NO_PAY;
    1482                 :            :         }
    1483                 :            : 
    1484         [ #  # ]:          0 :         if (*tun_type == ICE_SW_TUN_IPV4_GTPU_NO_PAY ||
    1485                 :            :             *tun_type == ICE_SW_TUN_IPV6_GTPU_NO_PAY) {
    1486         [ #  # ]:          0 :                 for (k = 0; k < t; k++) {
    1487         [ #  # ]:          0 :                         if (list[k].type == ICE_GTP)
    1488                 :          0 :                                 list[k].type = ICE_GTP_NO_PAY;
    1489                 :            :                 }
    1490                 :            :         }
    1491                 :            : 
    1492         [ #  # ]:          0 :         if (*tun_type == ICE_NON_TUN) {
    1493         [ #  # ]:          0 :                 if (vxlan_valid)
    1494                 :          0 :                         *tun_type = ICE_SW_TUN_VXLAN;
    1495         [ #  # ]:          0 :                 else if (nvgre_valid)
    1496                 :          0 :                         *tun_type = ICE_SW_TUN_NVGRE;
    1497         [ #  # ]:          0 :                 else if (ipv4_valid && tcp_valid)
    1498                 :          0 :                         *tun_type = ICE_SW_IPV4_TCP;
    1499         [ #  # ]:          0 :                 else if (ipv4_valid && udp_valid)
    1500                 :          0 :                         *tun_type = ICE_SW_IPV4_UDP;
    1501         [ #  # ]:          0 :                 else if (ipv6_valid && tcp_valid)
    1502                 :          0 :                         *tun_type = ICE_SW_IPV6_TCP;
    1503         [ #  # ]:          0 :                 else if (ipv6_valid && udp_valid)
    1504                 :          0 :                         *tun_type = ICE_SW_IPV6_UDP;
    1505                 :            :         }
    1506                 :            : 
    1507         [ #  # ]:          0 :         if (input_set_byte > MAX_INPUT_SET_BYTE) {
    1508                 :          0 :                 rte_flow_error_set(error, EINVAL,
    1509                 :            :                         RTE_FLOW_ERROR_TYPE_ITEM,
    1510                 :            :                         item,
    1511                 :            :                         "too much input set");
    1512                 :          0 :                 return false;
    1513                 :            :         }
    1514                 :            : 
    1515                 :          0 :         *lkups_num = t;
    1516                 :            : 
    1517                 :          0 : inset_check:
    1518   [ #  #  #  #  :          0 :         if ((!outer_input_set && !inner_input_set &&
                   #  # ]
    1519                 :          0 :             !ice_is_prof_rule(*tun_type)) || (outer_input_set &
    1520         [ #  # ]:          0 :             ~pattern_match_item->input_set_mask_o) ||
    1521         [ #  # ]:          0 :             (inner_input_set & ~pattern_match_item->input_set_mask_i))
    1522                 :          0 :                 return false;
    1523                 :            : 
    1524                 :            :         return true;
    1525                 :            : }
    1526                 :            : 
    1527                 :            : static int
    1528                 :          0 : ice_switch_parse_dcf_action(struct ice_dcf_adapter *ad,
    1529                 :            :                             const struct rte_flow_action *actions,
    1530                 :            :                             uint32_t priority,
    1531                 :            :                             struct rte_flow_error *error,
    1532                 :            :                             struct ice_adv_rule_info *rule_info)
    1533                 :            : {
    1534                 :            :         const struct rte_flow_action_ethdev *act_ethdev;
    1535                 :            :         const struct rte_flow_action *action;
    1536                 :            :         const struct rte_eth_dev *repr_dev;
    1537                 :            :         enum rte_flow_action_type action_type;
    1538                 :            :         uint16_t rule_port_id, backer_port_id;
    1539                 :            : 
    1540         [ #  # ]:          0 :         for (action = actions; action->type !=
    1541                 :          0 :                                 RTE_FLOW_ACTION_TYPE_END; action++) {
    1542                 :            :                 action_type = action->type;
    1543   [ #  #  #  # ]:          0 :                 switch (action_type) {
    1544                 :          0 :                 case RTE_FLOW_ACTION_TYPE_PORT_REPRESENTOR:
    1545                 :          0 :                         rule_info->sw_act.fltr_act = ICE_FWD_TO_VSI;
    1546                 :          0 :                         act_ethdev = action->conf;
    1547                 :            : 
    1548         [ #  # ]:          0 :                         if (!rte_eth_dev_is_valid_port(act_ethdev->port_id))
    1549                 :          0 :                                 goto invalid_port_id;
    1550                 :            : 
    1551                 :            :                         /* For traffic to original DCF port */
    1552                 :          0 :                         rule_port_id = ad->parent.pf.dev_data->port_id;
    1553                 :            : 
    1554         [ #  # ]:          0 :                         if (rule_port_id != act_ethdev->port_id)
    1555                 :          0 :                                 goto invalid_port_id;
    1556                 :            : 
    1557                 :          0 :                         rule_info->sw_act.vsi_handle = 0;
    1558                 :            : 
    1559                 :          0 :                         break;
    1560                 :            : 
    1561                 :          0 : invalid_port_id:
    1562                 :          0 :                         rte_flow_error_set(error,
    1563                 :            :                                                 EINVAL, RTE_FLOW_ERROR_TYPE_ACTION,
    1564                 :            :                                                 actions,
    1565                 :            :                                                 "Invalid port_id");
    1566                 :          0 :                         return -rte_errno;
    1567                 :            : 
    1568                 :          0 :                 case RTE_FLOW_ACTION_TYPE_REPRESENTED_PORT:
    1569                 :          0 :                         rule_info->sw_act.fltr_act = ICE_FWD_TO_VSI;
    1570                 :          0 :                         act_ethdev = action->conf;
    1571                 :            : 
    1572         [ #  # ]:          0 :                         if (!rte_eth_dev_is_valid_port(act_ethdev->port_id))
    1573                 :          0 :                                 goto invalid;
    1574                 :            : 
    1575                 :          0 :                         repr_dev = &rte_eth_devices[act_ethdev->port_id];
    1576                 :            : 
    1577         [ #  # ]:          0 :                         if (!repr_dev->data)
    1578                 :          0 :                                 goto invalid;
    1579                 :            : 
    1580                 :          0 :                         rule_port_id = ad->parent.pf.dev_data->port_id;
    1581                 :          0 :                         backer_port_id = repr_dev->data->backer_port_id;
    1582                 :            : 
    1583         [ #  # ]:          0 :                         if (backer_port_id != rule_port_id)
    1584                 :          0 :                                 goto invalid;
    1585                 :            : 
    1586                 :          0 :                         rule_info->sw_act.vsi_handle = repr_dev->data->representor_id;
    1587                 :          0 :                         break;
    1588                 :            : 
    1589                 :          0 : invalid:
    1590                 :          0 :                         rte_flow_error_set(error,
    1591                 :            :                                                 EINVAL, RTE_FLOW_ERROR_TYPE_ACTION,
    1592                 :            :                                                 actions,
    1593                 :            :                                                 "Invalid ethdev_port_id");
    1594                 :          0 :                         return -rte_errno;
    1595                 :            : 
    1596                 :          0 :                 case RTE_FLOW_ACTION_TYPE_DROP:
    1597                 :          0 :                         rule_info->sw_act.fltr_act = ICE_DROP_PACKET;
    1598                 :          0 :                         break;
    1599                 :            : 
    1600                 :          0 :                 default:
    1601                 :          0 :                         rte_flow_error_set(error,
    1602                 :            :                                            EINVAL, RTE_FLOW_ERROR_TYPE_ACTION,
    1603                 :            :                                            actions,
    1604                 :            :                                            "Invalid action type");
    1605                 :          0 :                         return -rte_errno;
    1606                 :            :                 }
    1607                 :            :         }
    1608                 :            : 
    1609                 :          0 :         rule_info->sw_act.src = rule_info->sw_act.vsi_handle;
    1610                 :          0 :         rule_info->sw_act.flag = ICE_FLTR_RX;
    1611                 :          0 :         rule_info->rx = 1;
    1612                 :            :         /* 0 denotes lowest priority of recipe and highest priority
    1613                 :            :          * of rte_flow. Change rte_flow priority into recipe priority.
    1614                 :            :          */
    1615                 :          0 :         rule_info->priority = ICE_SW_PRI_BASE - priority;
    1616                 :            : 
    1617                 :          0 :         return 0;
    1618                 :            : }
    1619                 :            : 
    1620                 :            : static int
    1621                 :          0 : ice_switch_parse_action(struct ice_pf *pf,
    1622                 :            :                 const struct rte_flow_action *actions,
    1623                 :            :                 uint32_t priority,
    1624                 :            :                 struct rte_flow_error *error,
    1625                 :            :                 struct ice_adv_rule_info *rule_info)
    1626                 :            : {
    1627                 :          0 :         struct ice_vsi *vsi = pf->main_vsi;
    1628                 :          0 :         struct rte_eth_dev_data *dev_data = pf->adapter->pf.dev_data;
    1629                 :            :         const struct rte_flow_action_queue *act_q;
    1630                 :            :         const struct rte_flow_action_rss *act_qgrop;
    1631                 :            :         uint16_t base_queue, i;
    1632                 :            :         const struct rte_flow_action *action;
    1633                 :            :         enum rte_flow_action_type action_type;
    1634                 :          0 :         uint16_t valid_qgrop_number[MAX_QGRP_NUM_TYPE] = {
    1635                 :            :                  2, 4, 8, 16, 32, 64, 128};
    1636                 :            : 
    1637                 :          0 :         base_queue = pf->base_queue + vsi->base_queue;
    1638         [ #  # ]:          0 :         for (action = actions; action->type !=
    1639                 :          0 :                         RTE_FLOW_ACTION_TYPE_END; action++) {
    1640                 :            :                 action_type = action->type;
    1641   [ #  #  #  #  :          0 :                 switch (action_type) {
                      # ]
    1642                 :          0 :                 case RTE_FLOW_ACTION_TYPE_RSS:
    1643                 :          0 :                         act_qgrop = action->conf;
    1644         [ #  # ]:          0 :                         if (act_qgrop->queue_num <= 1)
    1645                 :          0 :                                 goto error;
    1646                 :          0 :                         rule_info->sw_act.fltr_act =
    1647                 :            :                                 ICE_FWD_TO_QGRP;
    1648                 :          0 :                         rule_info->sw_act.fwd_id.q_id =
    1649                 :          0 :                                 base_queue + act_qgrop->queue[0];
    1650         [ #  # ]:          0 :                         for (i = 0; i < MAX_QGRP_NUM_TYPE; i++) {
    1651                 :          0 :                                 if (act_qgrop->queue_num ==
    1652         [ #  # ]:          0 :                                         valid_qgrop_number[i])
    1653                 :            :                                         break;
    1654                 :            :                         }
    1655         [ #  # ]:          0 :                         if (i == MAX_QGRP_NUM_TYPE)
    1656                 :          0 :                                 goto error;
    1657                 :          0 :                         if ((act_qgrop->queue[0] +
    1658                 :            :                                 act_qgrop->queue_num) >
    1659         [ #  # ]:          0 :                                 dev_data->nb_rx_queues)
    1660                 :          0 :                                 goto error1;
    1661         [ #  # ]:          0 :                         for (i = 0; i < act_qgrop->queue_num - 1; i++)
    1662                 :          0 :                                 if (act_qgrop->queue[i + 1] !=
    1663         [ #  # ]:          0 :                                         act_qgrop->queue[i] + 1)
    1664                 :          0 :                                         goto error2;
    1665                 :          0 :                         rule_info->sw_act.qgrp_size =
    1666                 :            :                                 act_qgrop->queue_num;
    1667                 :          0 :                         break;
    1668                 :          0 :                 case RTE_FLOW_ACTION_TYPE_QUEUE:
    1669                 :          0 :                         act_q = action->conf;
    1670         [ #  # ]:          0 :                         if (act_q->index >= dev_data->nb_rx_queues)
    1671                 :          0 :                                 goto error;
    1672                 :          0 :                         rule_info->sw_act.fltr_act =
    1673                 :            :                                 ICE_FWD_TO_Q;
    1674                 :          0 :                         rule_info->sw_act.fwd_id.q_id =
    1675                 :          0 :                                 base_queue + act_q->index;
    1676                 :          0 :                         break;
    1677                 :            : 
    1678                 :          0 :                 case RTE_FLOW_ACTION_TYPE_DROP:
    1679                 :          0 :                         rule_info->sw_act.fltr_act =
    1680                 :            :                                 ICE_DROP_PACKET;
    1681                 :          0 :                         break;
    1682                 :            : 
    1683                 :            :                 case RTE_FLOW_ACTION_TYPE_VOID:
    1684                 :            :                         break;
    1685                 :            : 
    1686                 :          0 :                 default:
    1687                 :          0 :                         goto error;
    1688                 :            :                 }
    1689                 :            :         }
    1690                 :            : 
    1691                 :          0 :         rule_info->sw_act.vsi_handle = vsi->idx;
    1692                 :          0 :         rule_info->rx = 1;
    1693                 :          0 :         rule_info->sw_act.src = vsi->idx;
    1694                 :            :         /* 0 denotes lowest priority of recipe and highest priority
    1695                 :            :          * of rte_flow. Change rte_flow priority into recipe priority.
    1696                 :            :          */
    1697                 :          0 :         rule_info->priority = ICE_SW_PRI_BASE - priority;
    1698                 :            : 
    1699                 :          0 :         return 0;
    1700                 :            : 
    1701                 :          0 : error:
    1702                 :          0 :         rte_flow_error_set(error,
    1703                 :            :                 EINVAL, RTE_FLOW_ERROR_TYPE_ACTION,
    1704                 :            :                 actions,
    1705                 :            :                 "Invalid action type or queue number");
    1706                 :          0 :         return -rte_errno;
    1707                 :            : 
    1708                 :            : error1:
    1709                 :          0 :         rte_flow_error_set(error,
    1710                 :            :                 EINVAL, RTE_FLOW_ERROR_TYPE_ACTION,
    1711                 :            :                 actions,
    1712                 :            :                 "Invalid queue region indexes");
    1713                 :          0 :         return -rte_errno;
    1714                 :            : 
    1715                 :            : error2:
    1716                 :          0 :         rte_flow_error_set(error,
    1717                 :            :                 EINVAL, RTE_FLOW_ERROR_TYPE_ACTION,
    1718                 :            :                 actions,
    1719                 :            :                 "Discontinuous queue region");
    1720                 :          0 :         return -rte_errno;
    1721                 :            : }
    1722                 :            : 
    1723                 :            : static int
    1724                 :          0 : ice_switch_check_action(const struct rte_flow_action *actions,
    1725                 :            :                             struct rte_flow_error *error)
    1726                 :            : {
    1727                 :            :         const struct rte_flow_action *action;
    1728                 :            :         enum rte_flow_action_type action_type;
    1729                 :            :         uint16_t actions_num = 0;
    1730                 :            : 
    1731         [ #  # ]:          0 :         for (action = actions; action->type !=
    1732                 :          0 :                                 RTE_FLOW_ACTION_TYPE_END; action++) {
    1733                 :            :                 action_type = action->type;
    1734      [ #  #  # ]:          0 :                 switch (action_type) {
    1735                 :          0 :                 case RTE_FLOW_ACTION_TYPE_RSS:
    1736                 :            :                 case RTE_FLOW_ACTION_TYPE_QUEUE:
    1737                 :            :                 case RTE_FLOW_ACTION_TYPE_DROP:
    1738                 :            :                 case RTE_FLOW_ACTION_TYPE_REPRESENTED_PORT:
    1739                 :            :                 case RTE_FLOW_ACTION_TYPE_PORT_REPRESENTOR:
    1740                 :          0 :                         actions_num++;
    1741                 :          0 :                         break;
    1742                 :          0 :                 case RTE_FLOW_ACTION_TYPE_VOID:
    1743                 :          0 :                         continue;
    1744                 :          0 :                 default:
    1745                 :          0 :                         rte_flow_error_set(error,
    1746                 :            :                                            EINVAL, RTE_FLOW_ERROR_TYPE_ACTION,
    1747                 :            :                                            actions,
    1748                 :            :                                            "Invalid action type");
    1749                 :          0 :                         return -rte_errno;
    1750                 :            :                 }
    1751                 :            :         }
    1752                 :            : 
    1753         [ #  # ]:          0 :         if (actions_num != 1) {
    1754                 :          0 :                 rte_flow_error_set(error,
    1755                 :            :                                    EINVAL, RTE_FLOW_ERROR_TYPE_ACTION,
    1756                 :            :                                    actions,
    1757                 :            :                                    "Invalid action number");
    1758                 :          0 :                 return -rte_errno;
    1759                 :            :         }
    1760                 :            : 
    1761                 :            :         return 0;
    1762                 :            : }
    1763                 :            : 
    1764                 :            : static int
    1765                 :          0 : ice_switch_parse_pattern_action(struct ice_adapter *ad,
    1766                 :            :                 struct ice_pattern_match_item *array,
    1767                 :            :                 uint32_t array_len,
    1768                 :            :                 const struct rte_flow_item pattern[],
    1769                 :            :                 const struct rte_flow_action actions[],
    1770                 :            :                 uint32_t priority,
    1771                 :            :                 void **meta,
    1772                 :            :                 struct rte_flow_error *error)
    1773                 :            : {
    1774                 :          0 :         struct ice_pf *pf = &ad->pf;
    1775                 :            :         int ret = 0;
    1776                 :            :         struct sw_meta *sw_meta_ptr = NULL;
    1777                 :            :         struct ice_adv_rule_info rule_info;
    1778                 :            :         struct ice_adv_lkup_elem *list = NULL;
    1779                 :          0 :         uint16_t lkups_num = 0;
    1780                 :            :         const struct rte_flow_item *item = pattern;
    1781                 :            :         uint16_t item_num = 0;
    1782                 :            :         uint16_t vlan_num = 0;
    1783                 :          0 :         enum ice_sw_tunnel_type tun_type =
    1784                 :            :                         ICE_NON_TUN;
    1785                 :            :         struct ice_pattern_match_item *pattern_match_item = NULL;
    1786                 :            : 
    1787         [ #  # ]:          0 :         for (; item->type != RTE_FLOW_ITEM_TYPE_END; item++) {
    1788                 :          0 :                 item_num++;
    1789         [ #  # ]:          0 :                 if (item->type == RTE_FLOW_ITEM_TYPE_ETH) {
    1790                 :            :                         const struct rte_flow_item_eth *eth_mask;
    1791         [ #  # ]:          0 :                         if (item->mask)
    1792                 :            :                                 eth_mask = item->mask;
    1793                 :            :                         else
    1794                 :          0 :                                 continue;
    1795         [ #  # ]:          0 :                         if (eth_mask->hdr.ether_type == UINT16_MAX)
    1796                 :          0 :                                 tun_type = ICE_SW_TUN_AND_NON_TUN;
    1797                 :            :                 }
    1798                 :            : 
    1799         [ #  # ]:          0 :                 if (item->type == RTE_FLOW_ITEM_TYPE_VLAN)
    1800                 :          0 :                         vlan_num++;
    1801                 :            : 
    1802                 :            :                 /* reserve one more memory slot for ETH which may
    1803                 :            :                  * consume 2 lookup items.
    1804                 :            :                  */
    1805         [ #  # ]:          0 :                 if (item->type == RTE_FLOW_ITEM_TYPE_ETH)
    1806                 :          0 :                         item_num++;
    1807                 :            :         }
    1808                 :            : 
    1809         [ #  # ]:          0 :         if (vlan_num == 2 && tun_type == ICE_SW_TUN_AND_NON_TUN)
    1810                 :          0 :                 tun_type = ICE_SW_TUN_AND_NON_TUN_QINQ;
    1811         [ #  # ]:          0 :         else if (vlan_num == 2)
    1812                 :          0 :                 tun_type = ICE_NON_TUN_QINQ;
    1813                 :            : 
    1814                 :            :         /* reserve one more memory slot for direction flag which may
    1815                 :            :          * consume 1 lookup item.
    1816                 :            :          */
    1817                 :          0 :         list = rte_zmalloc(NULL, (item_num + 1) * sizeof(*list), 0);
    1818         [ #  # ]:          0 :         if (!list) {
    1819                 :          0 :                 rte_flow_error_set(error, EINVAL,
    1820                 :            :                                    RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
    1821                 :            :                                    "No memory for PMD internal items");
    1822                 :          0 :                 return -rte_errno;
    1823                 :            :         }
    1824                 :            : 
    1825                 :            :         sw_meta_ptr =
    1826                 :          0 :                 rte_zmalloc(NULL, sizeof(*sw_meta_ptr), 0);
    1827         [ #  # ]:          0 :         if (!sw_meta_ptr) {
    1828                 :          0 :                 rte_flow_error_set(error, EINVAL,
    1829                 :            :                                    RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
    1830                 :            :                                    "No memory for sw_pattern_meta_ptr");
    1831                 :          0 :                 goto error;
    1832                 :            :         }
    1833                 :            : 
    1834                 :            :         pattern_match_item =
    1835                 :          0 :                 ice_search_pattern_match_item(ad, pattern, array, array_len,
    1836                 :            :                                               error);
    1837         [ #  # ]:          0 :         if (!pattern_match_item) {
    1838                 :          0 :                 rte_flow_error_set(error, EINVAL,
    1839                 :            :                                    RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
    1840                 :            :                                    "Invalid input pattern");
    1841                 :          0 :                 goto error;
    1842                 :            :         }
    1843                 :            : 
    1844         [ #  # ]:          0 :         if (!ice_switch_parse_pattern(pattern, error, list, &lkups_num,
    1845                 :            :                                    &tun_type, pattern_match_item)) {
    1846                 :          0 :                 rte_flow_error_set(error, EINVAL,
    1847                 :            :                                    RTE_FLOW_ERROR_TYPE_ITEM_SPEC,
    1848                 :            :                                    pattern,
    1849                 :            :                                    "Invalid input set");
    1850                 :          0 :                 goto error;
    1851                 :            :         }
    1852                 :            : 
    1853                 :            :         memset(&rule_info, 0, sizeof(rule_info));
    1854                 :          0 :         rule_info.tun_type = tun_type;
    1855                 :            : 
    1856                 :          0 :         ret = ice_switch_check_action(actions, error);
    1857         [ #  # ]:          0 :         if (ret)
    1858                 :          0 :                 goto error;
    1859                 :            : 
    1860         [ #  # ]:          0 :         if (ad->hw.dcf_enabled)
    1861                 :          0 :                 ret = ice_switch_parse_dcf_action((void *)ad, actions, priority,
    1862                 :            :                                                   error, &rule_info);
    1863                 :            :         else
    1864                 :          0 :                 ret = ice_switch_parse_action(pf, actions, priority, error,
    1865                 :            :                                               &rule_info);
    1866                 :            : 
    1867         [ #  # ]:          0 :         if (ret)
    1868                 :          0 :                 goto error;
    1869                 :            : 
    1870         [ #  # ]:          0 :         if (meta) {
    1871                 :          0 :                 *meta = sw_meta_ptr;
    1872                 :          0 :                 ((struct sw_meta *)*meta)->list = list;
    1873                 :          0 :                 ((struct sw_meta *)*meta)->lkups_num = lkups_num;
    1874                 :          0 :                 ((struct sw_meta *)*meta)->rule_info = rule_info;
    1875                 :            :         } else {
    1876                 :          0 :                 rte_free(list);
    1877                 :          0 :                 rte_free(sw_meta_ptr);
    1878                 :            :         }
    1879                 :            : 
    1880                 :          0 :         rte_free(pattern_match_item);
    1881                 :            : 
    1882                 :          0 :         return 0;
    1883                 :            : 
    1884                 :          0 : error:
    1885                 :          0 :         rte_free(list);
    1886                 :          0 :         rte_free(sw_meta_ptr);
    1887                 :          0 :         rte_free(pattern_match_item);
    1888                 :            : 
    1889                 :          0 :         return -rte_errno;
    1890                 :            : }
    1891                 :            : 
    1892                 :            : static int
    1893                 :          0 : ice_switch_query(struct ice_adapter *ad __rte_unused,
    1894                 :            :                 struct rte_flow *flow __rte_unused,
    1895                 :            :                 struct rte_flow_query_count *count __rte_unused,
    1896                 :            :                 struct rte_flow_error *error)
    1897                 :            : {
    1898                 :          0 :         rte_flow_error_set(error, EINVAL,
    1899                 :            :                 RTE_FLOW_ERROR_TYPE_HANDLE,
    1900                 :            :                 NULL,
    1901                 :            :                 "count action not supported by switch filter");
    1902                 :            : 
    1903                 :          0 :         return -rte_errno;
    1904                 :            : }
    1905                 :            : 
    1906                 :            : static int
    1907                 :          0 : ice_switch_redirect(struct ice_adapter *ad,
    1908                 :            :                     struct rte_flow *flow,
    1909                 :            :                     struct ice_flow_redirect *rd)
    1910                 :            : {
    1911                 :            :         struct ice_rule_query_data *rdata;
    1912                 :          0 :         struct ice_switch_filter_conf *filter_conf_ptr =
    1913                 :            :                 (struct ice_switch_filter_conf *)flow->rule;
    1914                 :          0 :         struct ice_rule_query_data added_rdata = { 0 };
    1915                 :            :         struct ice_adv_fltr_mgmt_list_entry *list_itr;
    1916                 :            :         struct ice_adv_lkup_elem *lkups_ref = NULL;
    1917                 :            :         struct ice_adv_lkup_elem *lkups_dp = NULL;
    1918                 :            :         struct LIST_HEAD_TYPE *list_head;
    1919                 :            :         struct ice_adv_rule_info rinfo;
    1920                 :          0 :         struct ice_hw *hw = &ad->hw;
    1921                 :            :         struct ice_switch_info *sw;
    1922                 :            :         uint16_t lkups_cnt;
    1923                 :            :         int ret;
    1924                 :            : 
    1925                 :            :         rdata = &filter_conf_ptr->sw_query_data;
    1926                 :            : 
    1927         [ #  # ]:          0 :         if (rdata->vsi_handle != rd->vsi_handle)
    1928                 :            :                 return 0;
    1929                 :            : 
    1930                 :          0 :         sw = hw->switch_info;
    1931         [ #  # ]:          0 :         if (!sw->recp_list[rdata->rid].recp_created)
    1932                 :            :                 return -EINVAL;
    1933                 :            : 
    1934         [ #  # ]:          0 :         if (rd->type != ICE_FLOW_REDIRECT_VSI)
    1935                 :            :                 return -ENOTSUP;
    1936                 :            : 
    1937   [ #  #  #  # ]:          0 :         switch (filter_conf_ptr->fltr_status) {
    1938                 :          0 :         case ICE_SW_FLTR_ADDED:
    1939                 :            :                 list_head = &sw->recp_list[rdata->rid].filt_rules;
    1940   [ #  #  #  #  :          0 :                 LIST_FOR_EACH_ENTRY(list_itr, list_head,
                   #  # ]
    1941                 :            :                                     ice_adv_fltr_mgmt_list_entry,
    1942                 :            :                                     list_entry) {
    1943                 :          0 :                         rinfo = list_itr->rule_info;
    1944         [ #  # ]:          0 :                         if ((rinfo.fltr_rule_id == rdata->rule_id &&
    1945         [ #  # ]:          0 :                             rinfo.sw_act.fltr_act == ICE_FWD_TO_VSI &&
    1946   [ #  #  #  # ]:          0 :                             rinfo.sw_act.vsi_handle == rd->vsi_handle) ||
    1947                 :          0 :                             (rinfo.fltr_rule_id == rdata->rule_id &&
    1948         [ #  # ]:          0 :                             rinfo.sw_act.fltr_act == ICE_FWD_TO_VSI_LIST)){
    1949                 :          0 :                                 lkups_cnt = list_itr->lkups_cnt;
    1950                 :            : 
    1951                 :            :                                 lkups_dp = (struct ice_adv_lkup_elem *)
    1952                 :          0 :                                         ice_memdup(hw, list_itr->lkups,
    1953                 :            :                                                    sizeof(*list_itr->lkups) *
    1954                 :            :                                                    lkups_cnt,
    1955                 :            :                                                    ICE_NONDMA_TO_NONDMA);
    1956         [ #  # ]:          0 :                                 if (!lkups_dp) {
    1957                 :          0 :                                         PMD_DRV_LOG(ERR,
    1958                 :            :                                                     "Failed to allocate memory.");
    1959                 :          0 :                                         return -EINVAL;
    1960                 :            :                                 }
    1961                 :            :                                 lkups_ref = lkups_dp;
    1962                 :            : 
    1963         [ #  # ]:          0 :                                 if (rinfo.sw_act.fltr_act ==
    1964                 :            :                                     ICE_FWD_TO_VSI_LIST) {
    1965                 :          0 :                                         rinfo.sw_act.vsi_handle =
    1966                 :          0 :                                                 rd->vsi_handle;
    1967                 :          0 :                                         rinfo.sw_act.fltr_act = ICE_FWD_TO_VSI;
    1968                 :            :                                 }
    1969                 :            :                                 break;
    1970                 :            :                         }
    1971                 :            :                 }
    1972                 :            : 
    1973         [ #  # ]:          0 :                 if (!lkups_ref)
    1974                 :            :                         return -EINVAL;
    1975                 :            : 
    1976                 :          0 :                 goto rmv_rule;
    1977                 :          0 :         case ICE_SW_FLTR_RMV_FAILED_ON_RIDRECT:
    1978                 :            :                 /* Recover VSI context */
    1979                 :          0 :                 hw->vsi_ctx[rd->vsi_handle]->vsi_num = filter_conf_ptr->vsi_num;
    1980                 :          0 :                 rinfo = filter_conf_ptr->rule_info;
    1981                 :          0 :                 lkups_cnt = filter_conf_ptr->lkups_num;
    1982                 :          0 :                 lkups_ref = filter_conf_ptr->lkups;
    1983                 :            : 
    1984         [ #  # ]:          0 :                 if (rinfo.sw_act.fltr_act == ICE_FWD_TO_VSI_LIST) {
    1985                 :          0 :                         rinfo.sw_act.vsi_handle = rd->vsi_handle;
    1986                 :          0 :                         rinfo.sw_act.fltr_act = ICE_FWD_TO_VSI;
    1987                 :            :                 }
    1988                 :            : 
    1989                 :          0 :                 goto rmv_rule;
    1990                 :          0 :         case ICE_SW_FLTR_ADD_FAILED_ON_RIDRECT:
    1991                 :          0 :                 rinfo = filter_conf_ptr->rule_info;
    1992                 :          0 :                 lkups_cnt = filter_conf_ptr->lkups_num;
    1993                 :          0 :                 lkups_ref = filter_conf_ptr->lkups;
    1994                 :            : 
    1995                 :          0 :                 goto add_rule;
    1996                 :            :         default:
    1997                 :            :                 return -EINVAL;
    1998                 :            :         }
    1999                 :            : 
    2000                 :          0 : rmv_rule:
    2001         [ #  # ]:          0 :         if (ice_dcf_adminq_need_retry(ad)) {
    2002                 :          0 :                 PMD_DRV_LOG(WARNING, "DCF is not on");
    2003                 :            :                 ret = -EAGAIN;
    2004                 :          0 :                 goto out;
    2005                 :            :         }
    2006                 :            : 
    2007                 :            :         /* Remove the old rule */
    2008                 :          0 :         ret = ice_rem_adv_rule(hw, lkups_ref, lkups_cnt, &rinfo);
    2009         [ #  # ]:          0 :         if (ret) {
    2010                 :          0 :                 PMD_DRV_LOG(ERR, "Failed to delete the old rule %d",
    2011                 :            :                             rdata->rule_id);
    2012                 :          0 :                 filter_conf_ptr->fltr_status =
    2013                 :            :                         ICE_SW_FLTR_RMV_FAILED_ON_RIDRECT;
    2014                 :            :                 ret = -EINVAL;
    2015                 :          0 :                 goto out;
    2016                 :            :         }
    2017                 :            : 
    2018                 :          0 : add_rule:
    2019         [ #  # ]:          0 :         if (ice_dcf_adminq_need_retry(ad)) {
    2020                 :          0 :                 PMD_DRV_LOG(WARNING, "DCF is not on");
    2021                 :            :                 ret = -EAGAIN;
    2022                 :          0 :                 goto out;
    2023                 :            :         }
    2024                 :            : 
    2025                 :            :         /* Update VSI context */
    2026                 :          0 :         hw->vsi_ctx[rd->vsi_handle]->vsi_num = rd->new_vsi_num;
    2027                 :            : 
    2028                 :            :         /* Replay the rule */
    2029                 :          0 :         ret = ice_add_adv_rule(hw, lkups_ref, lkups_cnt,
    2030                 :            :                                &rinfo, &added_rdata);
    2031         [ #  # ]:          0 :         if (ret) {
    2032                 :          0 :                 PMD_DRV_LOG(ERR, "Failed to replay the rule");
    2033                 :          0 :                 filter_conf_ptr->fltr_status =
    2034                 :            :                         ICE_SW_FLTR_ADD_FAILED_ON_RIDRECT;
    2035                 :            :                 ret = -EINVAL;
    2036                 :            :         } else {
    2037                 :          0 :                 filter_conf_ptr->sw_query_data = added_rdata;
    2038                 :            :                 /* Save VSI number for failure recover */
    2039                 :          0 :                 filter_conf_ptr->vsi_num = rd->new_vsi_num;
    2040                 :          0 :                 filter_conf_ptr->fltr_status = ICE_SW_FLTR_ADDED;
    2041                 :            :         }
    2042                 :            : 
    2043                 :            : out:
    2044                 :            :         if (ret == -EINVAL)
    2045         [ #  # ]:          0 :                 if (ice_dcf_adminq_need_retry(ad))
    2046                 :            :                         ret = -EAGAIN;
    2047                 :            : 
    2048                 :          0 :         ice_free(hw, lkups_dp);
    2049                 :          0 :         return ret;
    2050                 :            : }
    2051                 :            : 
    2052                 :            : static int
    2053                 :          0 : ice_switch_init(struct ice_adapter *ad __rte_unused)
    2054                 :            : {
    2055                 :          0 :         return 0;
    2056                 :            : }
    2057                 :            : 
    2058                 :            : static void
    2059                 :          0 : ice_switch_uninit(struct ice_adapter *ad __rte_unused)
    2060                 :            : {
    2061                 :          0 : }
    2062                 :            : 
    2063                 :            : static struct
    2064                 :            : ice_flow_engine ice_switch_engine = {
    2065                 :            :         .init = ice_switch_init,
    2066                 :            :         .uninit = ice_switch_uninit,
    2067                 :            :         .create = ice_switch_create,
    2068                 :            :         .destroy = ice_switch_destroy,
    2069                 :            :         .query_count = ice_switch_query,
    2070                 :            :         .redirect = ice_switch_redirect,
    2071                 :            :         .free = ice_switch_filter_rule_free,
    2072                 :            :         .type = ICE_FLOW_ENGINE_SWITCH,
    2073                 :            : };
    2074                 :            : 
    2075                 :            : struct
    2076                 :            : ice_flow_parser ice_switch_parser = {
    2077                 :            :         .engine = &ice_switch_engine,
    2078                 :            :         .array = ice_switch_supported_pattern,
    2079                 :            :         .array_len = RTE_DIM(ice_switch_supported_pattern),
    2080                 :            :         .parse_pattern_action = ice_switch_parse_pattern_action,
    2081                 :            :         .stage = ICE_FLOW_STAGE_DISTRIBUTOR,
    2082                 :            : };
    2083                 :            : 
    2084                 :        235 : RTE_INIT(ice_sw_engine_init)
    2085                 :            : {
    2086                 :            :         struct ice_flow_engine *engine = &ice_switch_engine;
    2087                 :        235 :         ice_register_flow_engine(engine);
    2088                 :        235 : }

Generated by: LCOV version 1.14