LCOV - code coverage report
Current view: top level - drivers/net/tap - tap_flow.c (source / functions) Hit Total Coverage
Test: Code coverage Lines: 0 604 0.0 %
Date: 2024-04-01 19:00:53 Functions: 0 25 0.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 439 0.0 %

           Branch data     Line data    Source code
       1                 :            : /* SPDX-License-Identifier: BSD-3-Clause
       2                 :            :  * Copyright 2017 6WIND S.A.
       3                 :            :  * Copyright 2017 Mellanox Technologies, Ltd
       4                 :            :  */
       5                 :            : 
       6                 :            : #include <errno.h>
       7                 :            : #include <string.h>
       8                 :            : #include <unistd.h>
       9                 :            : #include <sys/queue.h>
      10                 :            : #include <sys/resource.h>
      11                 :            : 
      12                 :            : #include <rte_byteorder.h>
      13                 :            : #include <rte_jhash.h>
      14                 :            : #include <rte_random.h>
      15                 :            : #include <rte_malloc.h>
      16                 :            : #include <rte_eth_tap.h>
      17                 :            : #include <tap_flow.h>
      18                 :            : #include <tap_autoconf.h>
      19                 :            : #include <tap_tcmsgs.h>
      20                 :            : #include <tap_rss.h>
      21                 :            : 
      22                 :            : #ifndef HAVE_TC_FLOWER
      23                 :            : /*
      24                 :            :  * For kernels < 4.2, this enum is not defined. Runtime checks will be made to
      25                 :            :  * avoid sending TC messages the kernel cannot understand.
      26                 :            :  */
      27                 :            : enum {
      28                 :            :         TCA_FLOWER_UNSPEC,
      29                 :            :         TCA_FLOWER_CLASSID,
      30                 :            :         TCA_FLOWER_INDEV,
      31                 :            :         TCA_FLOWER_ACT,
      32                 :            :         TCA_FLOWER_KEY_ETH_DST,         /* ETH_ALEN */
      33                 :            :         TCA_FLOWER_KEY_ETH_DST_MASK,    /* ETH_ALEN */
      34                 :            :         TCA_FLOWER_KEY_ETH_SRC,         /* ETH_ALEN */
      35                 :            :         TCA_FLOWER_KEY_ETH_SRC_MASK,    /* ETH_ALEN */
      36                 :            :         TCA_FLOWER_KEY_ETH_TYPE,        /* be16 */
      37                 :            :         TCA_FLOWER_KEY_IP_PROTO,        /* u8 */
      38                 :            :         TCA_FLOWER_KEY_IPV4_SRC,        /* be32 */
      39                 :            :         TCA_FLOWER_KEY_IPV4_SRC_MASK,   /* be32 */
      40                 :            :         TCA_FLOWER_KEY_IPV4_DST,        /* be32 */
      41                 :            :         TCA_FLOWER_KEY_IPV4_DST_MASK,   /* be32 */
      42                 :            :         TCA_FLOWER_KEY_IPV6_SRC,        /* struct in6_addr */
      43                 :            :         TCA_FLOWER_KEY_IPV6_SRC_MASK,   /* struct in6_addr */
      44                 :            :         TCA_FLOWER_KEY_IPV6_DST,        /* struct in6_addr */
      45                 :            :         TCA_FLOWER_KEY_IPV6_DST_MASK,   /* struct in6_addr */
      46                 :            :         TCA_FLOWER_KEY_TCP_SRC,         /* be16 */
      47                 :            :         TCA_FLOWER_KEY_TCP_DST,         /* be16 */
      48                 :            :         TCA_FLOWER_KEY_UDP_SRC,         /* be16 */
      49                 :            :         TCA_FLOWER_KEY_UDP_DST,         /* be16 */
      50                 :            : };
      51                 :            : #endif
      52                 :            : #ifndef HAVE_TC_VLAN_ID
      53                 :            : enum {
      54                 :            :         /* TCA_FLOWER_FLAGS, */
      55                 :            :         TCA_FLOWER_KEY_VLAN_ID = TCA_FLOWER_KEY_UDP_DST + 2, /* be16 */
      56                 :            :         TCA_FLOWER_KEY_VLAN_PRIO,       /* u8   */
      57                 :            :         TCA_FLOWER_KEY_VLAN_ETH_TYPE,   /* be16 */
      58                 :            : };
      59                 :            : #endif
      60                 :            : /*
      61                 :            :  * For kernels < 4.2 BPF related enums may not be defined.
      62                 :            :  * Runtime checks will be carried out to gracefully report on TC messages that
      63                 :            :  * are rejected by the kernel. Rejection reasons may be due to:
      64                 :            :  * 1. enum is not defined
      65                 :            :  * 2. enum is defined but kernel is not configured to support BPF system calls,
      66                 :            :  *    BPF classifications or BPF actions.
      67                 :            :  */
      68                 :            : #ifndef HAVE_TC_BPF
      69                 :            : enum {
      70                 :            :         TCA_BPF_UNSPEC,
      71                 :            :         TCA_BPF_ACT,
      72                 :            :         TCA_BPF_POLICE,
      73                 :            :         TCA_BPF_CLASSID,
      74                 :            :         TCA_BPF_OPS_LEN,
      75                 :            :         TCA_BPF_OPS,
      76                 :            : };
      77                 :            : #endif
      78                 :            : #ifndef HAVE_TC_BPF_FD
      79                 :            : enum {
      80                 :            :         TCA_BPF_FD = TCA_BPF_OPS + 1,
      81                 :            :         TCA_BPF_NAME,
      82                 :            : };
      83                 :            : #endif
      84                 :            : #ifndef HAVE_TC_ACT_BPF
      85                 :            : #define tc_gen \
      86                 :            :         __u32                 index; \
      87                 :            :         __u32                 capab; \
      88                 :            :         int                   action; \
      89                 :            :         int                   refcnt; \
      90                 :            :         int                   bindcnt
      91                 :            : 
      92                 :            : struct tc_act_bpf {
      93                 :            :         tc_gen;
      94                 :            : };
      95                 :            : 
      96                 :            : enum {
      97                 :            :         TCA_ACT_BPF_UNSPEC,
      98                 :            :         TCA_ACT_BPF_TM,
      99                 :            :         TCA_ACT_BPF_PARMS,
     100                 :            :         TCA_ACT_BPF_OPS_LEN,
     101                 :            :         TCA_ACT_BPF_OPS,
     102                 :            : };
     103                 :            : 
     104                 :            : #endif
     105                 :            : #ifndef HAVE_TC_ACT_BPF_FD
     106                 :            : enum {
     107                 :            :         TCA_ACT_BPF_FD = TCA_ACT_BPF_OPS + 1,
     108                 :            :         TCA_ACT_BPF_NAME,
     109                 :            : };
     110                 :            : #endif
     111                 :            : 
     112                 :            : /* RSS key management */
     113                 :            : enum bpf_rss_key_e {
     114                 :            :         KEY_CMD_GET = 1,
     115                 :            :         KEY_CMD_RELEASE,
     116                 :            :         KEY_CMD_INIT,
     117                 :            :         KEY_CMD_DEINIT,
     118                 :            : };
     119                 :            : 
     120                 :            : enum key_status_e {
     121                 :            :         KEY_STAT_UNSPEC,
     122                 :            :         KEY_STAT_USED,
     123                 :            :         KEY_STAT_AVAILABLE,
     124                 :            : };
     125                 :            : 
     126                 :            : #define ISOLATE_HANDLE 1
     127                 :            : #define REMOTE_PROMISCUOUS_HANDLE 2
     128                 :            : 
     129                 :            : struct rte_flow {
     130                 :            :         LIST_ENTRY(rte_flow) next; /* Pointer to the next rte_flow structure */
     131                 :            :         struct rte_flow *remote_flow; /* associated remote flow */
     132                 :            :         int bpf_fd[SEC_MAX]; /* list of bfs fds per ELF section */
     133                 :            :         uint32_t key_idx; /* RSS rule key index into BPF map */
     134                 :            :         struct nlmsg msg;
     135                 :            : };
     136                 :            : 
     137                 :            : struct convert_data {
     138                 :            :         uint16_t eth_type;
     139                 :            :         uint16_t ip_proto;
     140                 :            :         uint8_t vlan;
     141                 :            :         struct rte_flow *flow;
     142                 :            : };
     143                 :            : 
     144                 :            : struct remote_rule {
     145                 :            :         struct rte_flow_attr attr;
     146                 :            :         struct rte_flow_item items[2];
     147                 :            :         struct rte_flow_action actions[2];
     148                 :            :         int mirred;
     149                 :            : };
     150                 :            : 
     151                 :            : struct action_data {
     152                 :            :         char id[16];
     153                 :            : 
     154                 :            :         union {
     155                 :            :                 struct tc_gact gact;
     156                 :            :                 struct tc_mirred mirred;
     157                 :            :                 struct skbedit {
     158                 :            :                         struct tc_skbedit skbedit;
     159                 :            :                         uint16_t queue;
     160                 :            :                 } skbedit;
     161                 :            :                 struct bpf {
     162                 :            :                         struct tc_act_bpf bpf;
     163                 :            :                         int bpf_fd;
     164                 :            :                         const char *annotation;
     165                 :            :                 } bpf;
     166                 :            :         };
     167                 :            : };
     168                 :            : 
     169                 :            : static int tap_flow_create_eth(const struct rte_flow_item *item, void *data);
     170                 :            : static int tap_flow_create_vlan(const struct rte_flow_item *item, void *data);
     171                 :            : static int tap_flow_create_ipv4(const struct rte_flow_item *item, void *data);
     172                 :            : static int tap_flow_create_ipv6(const struct rte_flow_item *item, void *data);
     173                 :            : static int tap_flow_create_udp(const struct rte_flow_item *item, void *data);
     174                 :            : static int tap_flow_create_tcp(const struct rte_flow_item *item, void *data);
     175                 :            : static int
     176                 :            : tap_flow_validate(struct rte_eth_dev *dev,
     177                 :            :                   const struct rte_flow_attr *attr,
     178                 :            :                   const struct rte_flow_item items[],
     179                 :            :                   const struct rte_flow_action actions[],
     180                 :            :                   struct rte_flow_error *error);
     181                 :            : 
     182                 :            : static struct rte_flow *
     183                 :            : tap_flow_create(struct rte_eth_dev *dev,
     184                 :            :                 const struct rte_flow_attr *attr,
     185                 :            :                 const struct rte_flow_item items[],
     186                 :            :                 const struct rte_flow_action actions[],
     187                 :            :                 struct rte_flow_error *error);
     188                 :            : 
     189                 :            : static void
     190                 :            : tap_flow_free(struct pmd_internals *pmd,
     191                 :            :         struct rte_flow *flow);
     192                 :            : 
     193                 :            : static int
     194                 :            : tap_flow_destroy(struct rte_eth_dev *dev,
     195                 :            :                  struct rte_flow *flow,
     196                 :            :                  struct rte_flow_error *error);
     197                 :            : 
     198                 :            : static int
     199                 :            : tap_flow_isolate(struct rte_eth_dev *dev,
     200                 :            :                  int set,
     201                 :            :                  struct rte_flow_error *error);
     202                 :            : 
     203                 :            : static int bpf_rss_key(enum bpf_rss_key_e cmd, __u32 *key_idx);
     204                 :            : static int rss_enable(struct pmd_internals *pmd,
     205                 :            :                         const struct rte_flow_attr *attr,
     206                 :            :                         struct rte_flow_error *error);
     207                 :            : static int rss_add_actions(struct rte_flow *flow, struct pmd_internals *pmd,
     208                 :            :                         const struct rte_flow_action_rss *rss,
     209                 :            :                         struct rte_flow_error *error);
     210                 :            : 
     211                 :            : static const struct rte_flow_ops tap_flow_ops = {
     212                 :            :         .validate = tap_flow_validate,
     213                 :            :         .create = tap_flow_create,
     214                 :            :         .destroy = tap_flow_destroy,
     215                 :            :         .flush = tap_flow_flush,
     216                 :            :         .isolate = tap_flow_isolate,
     217                 :            : };
     218                 :            : 
     219                 :            : /* Static initializer for items. */
     220                 :            : #define ITEMS(...) \
     221                 :            :         (const enum rte_flow_item_type []){ \
     222                 :            :                 __VA_ARGS__, RTE_FLOW_ITEM_TYPE_END, \
     223                 :            :         }
     224                 :            : 
     225                 :            : /* Structure to generate a simple graph of layers supported by the NIC. */
     226                 :            : struct tap_flow_items {
     227                 :            :         /* Bit-mask corresponding to what is supported for this item. */
     228                 :            :         const void *mask;
     229                 :            :         const unsigned int mask_sz; /* Bit-mask size in bytes. */
     230                 :            :         /*
     231                 :            :          * Bit-mask corresponding to the default mask, if none is provided
     232                 :            :          * along with the item.
     233                 :            :          */
     234                 :            :         const void *default_mask;
     235                 :            :         /**
     236                 :            :          * Conversion function from rte_flow to netlink attributes.
     237                 :            :          *
     238                 :            :          * @param item
     239                 :            :          *   rte_flow item to convert.
     240                 :            :          * @param data
     241                 :            :          *   Internal structure to store the conversion.
     242                 :            :          *
     243                 :            :          * @return
     244                 :            :          *   0 on success, negative value otherwise.
     245                 :            :          */
     246                 :            :         int (*convert)(const struct rte_flow_item *item, void *data);
     247                 :            :         /** List of possible following items.  */
     248                 :            :         const enum rte_flow_item_type *const items;
     249                 :            : };
     250                 :            : 
     251                 :            : /* Graph of supported items and associated actions. */
     252                 :            : static const struct tap_flow_items tap_flow_items[] = {
     253                 :            :         [RTE_FLOW_ITEM_TYPE_END] = {
     254                 :            :                 .items = ITEMS(RTE_FLOW_ITEM_TYPE_ETH),
     255                 :            :         },
     256                 :            :         [RTE_FLOW_ITEM_TYPE_ETH] = {
     257                 :            :                 .items = ITEMS(
     258                 :            :                         RTE_FLOW_ITEM_TYPE_VLAN,
     259                 :            :                         RTE_FLOW_ITEM_TYPE_IPV4,
     260                 :            :                         RTE_FLOW_ITEM_TYPE_IPV6),
     261                 :            :                 .mask = &(const struct rte_flow_item_eth){
     262                 :            :                         .hdr.dst_addr.addr_bytes = "\xff\xff\xff\xff\xff\xff",
     263                 :            :                         .hdr.src_addr.addr_bytes = "\xff\xff\xff\xff\xff\xff",
     264                 :            :                         .hdr.ether_type = -1,
     265                 :            :                 },
     266                 :            :                 .mask_sz = sizeof(struct rte_flow_item_eth),
     267                 :            :                 .default_mask = &rte_flow_item_eth_mask,
     268                 :            :                 .convert = tap_flow_create_eth,
     269                 :            :         },
     270                 :            :         [RTE_FLOW_ITEM_TYPE_VLAN] = {
     271                 :            :                 .items = ITEMS(RTE_FLOW_ITEM_TYPE_IPV4,
     272                 :            :                                RTE_FLOW_ITEM_TYPE_IPV6),
     273                 :            :                 .mask = &(const struct rte_flow_item_vlan){
     274                 :            :                         /* DEI matching is not supported */
     275                 :            : #if RTE_BYTE_ORDER == RTE_LITTLE_ENDIAN
     276                 :            :                         .hdr.vlan_tci = 0xffef,
     277                 :            : #else
     278                 :            :                         .hdr.vlan_tci = 0xefff,
     279                 :            : #endif
     280                 :            :                         .hdr.eth_proto = -1,
     281                 :            :                 },
     282                 :            :                 .mask_sz = sizeof(struct rte_flow_item_vlan),
     283                 :            :                 .default_mask = &rte_flow_item_vlan_mask,
     284                 :            :                 .convert = tap_flow_create_vlan,
     285                 :            :         },
     286                 :            :         [RTE_FLOW_ITEM_TYPE_IPV4] = {
     287                 :            :                 .items = ITEMS(RTE_FLOW_ITEM_TYPE_UDP,
     288                 :            :                                RTE_FLOW_ITEM_TYPE_TCP),
     289                 :            :                 .mask = &(const struct rte_flow_item_ipv4){
     290                 :            :                         .hdr = {
     291                 :            :                                 .src_addr = -1,
     292                 :            :                                 .dst_addr = -1,
     293                 :            :                                 .next_proto_id = -1,
     294                 :            :                         },
     295                 :            :                 },
     296                 :            :                 .mask_sz = sizeof(struct rte_flow_item_ipv4),
     297                 :            :                 .default_mask = &rte_flow_item_ipv4_mask,
     298                 :            :                 .convert = tap_flow_create_ipv4,
     299                 :            :         },
     300                 :            :         [RTE_FLOW_ITEM_TYPE_IPV6] = {
     301                 :            :                 .items = ITEMS(RTE_FLOW_ITEM_TYPE_UDP,
     302                 :            :                                RTE_FLOW_ITEM_TYPE_TCP),
     303                 :            :                 .mask = &(const struct rte_flow_item_ipv6){
     304                 :            :                         .hdr = {
     305                 :            :                                 .src_addr = {
     306                 :            :                                         "\xff\xff\xff\xff\xff\xff\xff\xff"
     307                 :            :                                         "\xff\xff\xff\xff\xff\xff\xff\xff",
     308                 :            :                                 },
     309                 :            :                                 .dst_addr = {
     310                 :            :                                         "\xff\xff\xff\xff\xff\xff\xff\xff"
     311                 :            :                                         "\xff\xff\xff\xff\xff\xff\xff\xff",
     312                 :            :                                 },
     313                 :            :                                 .proto = -1,
     314                 :            :                         },
     315                 :            :                 },
     316                 :            :                 .mask_sz = sizeof(struct rte_flow_item_ipv6),
     317                 :            :                 .default_mask = &rte_flow_item_ipv6_mask,
     318                 :            :                 .convert = tap_flow_create_ipv6,
     319                 :            :         },
     320                 :            :         [RTE_FLOW_ITEM_TYPE_UDP] = {
     321                 :            :                 .mask = &(const struct rte_flow_item_udp){
     322                 :            :                         .hdr = {
     323                 :            :                                 .src_port = -1,
     324                 :            :                                 .dst_port = -1,
     325                 :            :                         },
     326                 :            :                 },
     327                 :            :                 .mask_sz = sizeof(struct rte_flow_item_udp),
     328                 :            :                 .default_mask = &rte_flow_item_udp_mask,
     329                 :            :                 .convert = tap_flow_create_udp,
     330                 :            :         },
     331                 :            :         [RTE_FLOW_ITEM_TYPE_TCP] = {
     332                 :            :                 .mask = &(const struct rte_flow_item_tcp){
     333                 :            :                         .hdr = {
     334                 :            :                                 .src_port = -1,
     335                 :            :                                 .dst_port = -1,
     336                 :            :                         },
     337                 :            :                 },
     338                 :            :                 .mask_sz = sizeof(struct rte_flow_item_tcp),
     339                 :            :                 .default_mask = &rte_flow_item_tcp_mask,
     340                 :            :                 .convert = tap_flow_create_tcp,
     341                 :            :         },
     342                 :            : };
     343                 :            : 
     344                 :            : /*
     345                 :            :  *                TC rules, by growing priority
     346                 :            :  *
     347                 :            :  *        Remote netdevice                  Tap netdevice
     348                 :            :  * +-------------+-------------+  +-------------+-------------+
     349                 :            :  * |   Ingress   |   Egress    |  |   Ingress   |   Egress    |
     350                 :            :  * |-------------|-------------|  |-------------|-------------|
     351                 :            :  * |             |  \       /  |  |             |  REMOTE TX  | prio 1
     352                 :            :  * |             |   \     /   |  |             |   \     /   | prio 2
     353                 :            :  * |  EXPLICIT   |    \   /    |  |  EXPLICIT   |    \   /    |   .
     354                 :            :  * |             |     \ /     |  |             |     \ /     |   .
     355                 :            :  * |    RULES    |      X      |  |    RULES    |      X      |   .
     356                 :            :  * |      .      |     / \     |  |      .      |     / \     |   .
     357                 :            :  * |      .      |    /   \    |  |      .      |    /   \    |   .
     358                 :            :  * |      .      |   /     \   |  |      .      |   /     \   |   .
     359                 :            :  * |      .      |  /       \  |  |      .      |  /       \  |   .
     360                 :            :  *
     361                 :            :  *      ....           ....           ....           ....
     362                 :            :  *
     363                 :            :  * |      .      |  \       /  |  |      .      |  \       /  |   .
     364                 :            :  * |      .      |   \     /   |  |      .      |   \     /   |   .
     365                 :            :  * |             |    \   /    |  |             |    \   /    |
     366                 :            :  * |  LOCAL_MAC  |     \ /     |  |    \   /    |     \ /     | last prio - 5
     367                 :            :  * |   PROMISC   |      X      |  |     \ /     |      X      | last prio - 4
     368                 :            :  * |   ALLMULTI  |     / \     |  |      X      |     / \     | last prio - 3
     369                 :            :  * |  BROADCAST  |    /   \    |  |     / \     |    /   \    | last prio - 2
     370                 :            :  * | BROADCASTV6 |   /     \   |  |    /   \    |   /     \   | last prio - 1
     371                 :            :  * |     xx      |  /       \  |  |   ISOLATE   |  /       \  | last prio
     372                 :            :  * +-------------+-------------+  +-------------+-------------+
     373                 :            :  *
     374                 :            :  * The implicit flow rules are stored in a list in with mandatorily the last two
     375                 :            :  * being the ISOLATE and REMOTE_TX rules. e.g.:
     376                 :            :  *
     377                 :            :  * LOCAL_MAC -> BROADCAST -> BROADCASTV6 -> REMOTE_TX -> ISOLATE -> NULL
     378                 :            :  *
     379                 :            :  * That enables tap_flow_isolate() to remove implicit rules by popping the list
     380                 :            :  * head and remove it as long as it applies on the remote netdevice. The
     381                 :            :  * implicit rule for TX redirection is not removed, as isolate concerns only
     382                 :            :  * incoming traffic.
     383                 :            :  */
     384                 :            : 
     385                 :            : static struct remote_rule implicit_rte_flows[TAP_REMOTE_MAX_IDX] = {
     386                 :            :         [TAP_REMOTE_LOCAL_MAC] = {
     387                 :            :                 .attr = {
     388                 :            :                         .group = MAX_GROUP,
     389                 :            :                         .priority = PRIORITY_MASK - TAP_REMOTE_LOCAL_MAC,
     390                 :            :                         .ingress = 1,
     391                 :            :                 },
     392                 :            :                 .items[0] = {
     393                 :            :                         .type = RTE_FLOW_ITEM_TYPE_ETH,
     394                 :            :                         .mask =  &(const struct rte_flow_item_eth){
     395                 :            :                                 .hdr.dst_addr.addr_bytes = "\xff\xff\xff\xff\xff\xff",
     396                 :            :                         },
     397                 :            :                 },
     398                 :            :                 .items[1] = {
     399                 :            :                         .type = RTE_FLOW_ITEM_TYPE_END,
     400                 :            :                 },
     401                 :            :                 .mirred = TCA_EGRESS_REDIR,
     402                 :            :         },
     403                 :            :         [TAP_REMOTE_BROADCAST] = {
     404                 :            :                 .attr = {
     405                 :            :                         .group = MAX_GROUP,
     406                 :            :                         .priority = PRIORITY_MASK - TAP_REMOTE_BROADCAST,
     407                 :            :                         .ingress = 1,
     408                 :            :                 },
     409                 :            :                 .items[0] = {
     410                 :            :                         .type = RTE_FLOW_ITEM_TYPE_ETH,
     411                 :            :                         .mask =  &(const struct rte_flow_item_eth){
     412                 :            :                                 .hdr.dst_addr.addr_bytes = "\xff\xff\xff\xff\xff\xff",
     413                 :            :                         },
     414                 :            :                         .spec = &(const struct rte_flow_item_eth){
     415                 :            :                                 .hdr.dst_addr.addr_bytes = "\xff\xff\xff\xff\xff\xff",
     416                 :            :                         },
     417                 :            :                 },
     418                 :            :                 .items[1] = {
     419                 :            :                         .type = RTE_FLOW_ITEM_TYPE_END,
     420                 :            :                 },
     421                 :            :                 .mirred = TCA_EGRESS_MIRROR,
     422                 :            :         },
     423                 :            :         [TAP_REMOTE_BROADCASTV6] = {
     424                 :            :                 .attr = {
     425                 :            :                         .group = MAX_GROUP,
     426                 :            :                         .priority = PRIORITY_MASK - TAP_REMOTE_BROADCASTV6,
     427                 :            :                         .ingress = 1,
     428                 :            :                 },
     429                 :            :                 .items[0] = {
     430                 :            :                         .type = RTE_FLOW_ITEM_TYPE_ETH,
     431                 :            :                         .mask =  &(const struct rte_flow_item_eth){
     432                 :            :                                 .hdr.dst_addr.addr_bytes = "\x33\x33\x00\x00\x00\x00",
     433                 :            :                         },
     434                 :            :                         .spec = &(const struct rte_flow_item_eth){
     435                 :            :                                 .hdr.dst_addr.addr_bytes = "\x33\x33\x00\x00\x00\x00",
     436                 :            :                         },
     437                 :            :                 },
     438                 :            :                 .items[1] = {
     439                 :            :                         .type = RTE_FLOW_ITEM_TYPE_END,
     440                 :            :                 },
     441                 :            :                 .mirred = TCA_EGRESS_MIRROR,
     442                 :            :         },
     443                 :            :         [TAP_REMOTE_PROMISC] = {
     444                 :            :                 .attr = {
     445                 :            :                         .group = MAX_GROUP,
     446                 :            :                         .priority = PRIORITY_MASK - TAP_REMOTE_PROMISC,
     447                 :            :                         .ingress = 1,
     448                 :            :                 },
     449                 :            :                 .items[0] = {
     450                 :            :                         .type = RTE_FLOW_ITEM_TYPE_VOID,
     451                 :            :                 },
     452                 :            :                 .items[1] = {
     453                 :            :                         .type = RTE_FLOW_ITEM_TYPE_END,
     454                 :            :                 },
     455                 :            :                 .mirred = TCA_EGRESS_MIRROR,
     456                 :            :         },
     457                 :            :         [TAP_REMOTE_ALLMULTI] = {
     458                 :            :                 .attr = {
     459                 :            :                         .group = MAX_GROUP,
     460                 :            :                         .priority = PRIORITY_MASK - TAP_REMOTE_ALLMULTI,
     461                 :            :                         .ingress = 1,
     462                 :            :                 },
     463                 :            :                 .items[0] = {
     464                 :            :                         .type = RTE_FLOW_ITEM_TYPE_ETH,
     465                 :            :                         .mask =  &(const struct rte_flow_item_eth){
     466                 :            :                                 .hdr.dst_addr.addr_bytes = "\x01\x00\x00\x00\x00\x00",
     467                 :            :                         },
     468                 :            :                         .spec = &(const struct rte_flow_item_eth){
     469                 :            :                                 .hdr.dst_addr.addr_bytes = "\x01\x00\x00\x00\x00\x00",
     470                 :            :                         },
     471                 :            :                 },
     472                 :            :                 .items[1] = {
     473                 :            :                         .type = RTE_FLOW_ITEM_TYPE_END,
     474                 :            :                 },
     475                 :            :                 .mirred = TCA_EGRESS_MIRROR,
     476                 :            :         },
     477                 :            :         [TAP_REMOTE_TX] = {
     478                 :            :                 .attr = {
     479                 :            :                         .group = 0,
     480                 :            :                         .priority = TAP_REMOTE_TX,
     481                 :            :                         .egress = 1,
     482                 :            :                 },
     483                 :            :                 .items[0] = {
     484                 :            :                         .type = RTE_FLOW_ITEM_TYPE_VOID,
     485                 :            :                 },
     486                 :            :                 .items[1] = {
     487                 :            :                         .type = RTE_FLOW_ITEM_TYPE_END,
     488                 :            :                 },
     489                 :            :                 .mirred = TCA_EGRESS_MIRROR,
     490                 :            :         },
     491                 :            :         [TAP_ISOLATE] = {
     492                 :            :                 .attr = {
     493                 :            :                         .group = MAX_GROUP,
     494                 :            :                         .priority = PRIORITY_MASK - TAP_ISOLATE,
     495                 :            :                         .ingress = 1,
     496                 :            :                 },
     497                 :            :                 .items[0] = {
     498                 :            :                         .type = RTE_FLOW_ITEM_TYPE_VOID,
     499                 :            :                 },
     500                 :            :                 .items[1] = {
     501                 :            :                         .type = RTE_FLOW_ITEM_TYPE_END,
     502                 :            :                 },
     503                 :            :         },
     504                 :            : };
     505                 :            : 
     506                 :            : /**
     507                 :            :  * Make as much checks as possible on an Ethernet item, and if a flow is
     508                 :            :  * provided, fill it appropriately with Ethernet info.
     509                 :            :  *
     510                 :            :  * @param[in] item
     511                 :            :  *   Item specification.
     512                 :            :  * @param[in, out] data
     513                 :            :  *   Additional data structure to tell next layers we've been here.
     514                 :            :  *
     515                 :            :  * @return
     516                 :            :  *   0 if checks are alright, -1 otherwise.
     517                 :            :  */
     518                 :            : static int
     519                 :          0 : tap_flow_create_eth(const struct rte_flow_item *item, void *data)
     520                 :            : {
     521                 :            :         struct convert_data *info = (struct convert_data *)data;
     522                 :          0 :         const struct rte_flow_item_eth *spec = item->spec;
     523                 :          0 :         const struct rte_flow_item_eth *mask = item->mask;
     524                 :          0 :         struct rte_flow *flow = info->flow;
     525                 :            :         struct nlmsg *msg;
     526                 :            : 
     527                 :            :         /* use default mask if none provided */
     528         [ #  # ]:          0 :         if (!mask)
     529                 :            :                 mask = tap_flow_items[RTE_FLOW_ITEM_TYPE_ETH].default_mask;
     530                 :            :         /* TC does not support eth_type masking. Only accept if exact match. */
     531         [ #  # ]:          0 :         if (mask->hdr.ether_type && mask->hdr.ether_type != 0xffff)
     532                 :            :                 return -1;
     533         [ #  # ]:          0 :         if (!spec)
     534                 :            :                 return 0;
     535                 :            :         /* store eth_type for consistency if ipv4/6 pattern item comes next */
     536         [ #  # ]:          0 :         if (spec->hdr.ether_type & mask->hdr.ether_type)
     537                 :          0 :                 info->eth_type = spec->hdr.ether_type;
     538         [ #  # ]:          0 :         if (!flow)
     539                 :            :                 return 0;
     540                 :            :         msg = &flow->msg;
     541         [ #  # ]:          0 :         if (!rte_is_zero_ether_addr(&mask->hdr.dst_addr)) {
     542                 :          0 :                 tap_nlattr_add(&msg->nh, TCA_FLOWER_KEY_ETH_DST,
     543                 :            :                         RTE_ETHER_ADDR_LEN,
     544                 :          0 :                            &spec->hdr.dst_addr.addr_bytes);
     545                 :          0 :                 tap_nlattr_add(&msg->nh,
     546                 :            :                            TCA_FLOWER_KEY_ETH_DST_MASK, RTE_ETHER_ADDR_LEN,
     547                 :          0 :                            &mask->hdr.dst_addr.addr_bytes);
     548                 :            :         }
     549         [ #  # ]:          0 :         if (!rte_is_zero_ether_addr(&mask->hdr.src_addr)) {
     550                 :          0 :                 tap_nlattr_add(&msg->nh, TCA_FLOWER_KEY_ETH_SRC,
     551                 :            :                         RTE_ETHER_ADDR_LEN,
     552                 :          0 :                         &spec->hdr.src_addr.addr_bytes);
     553                 :          0 :                 tap_nlattr_add(&msg->nh,
     554                 :            :                            TCA_FLOWER_KEY_ETH_SRC_MASK, RTE_ETHER_ADDR_LEN,
     555                 :          0 :                            &mask->hdr.src_addr.addr_bytes);
     556                 :            :         }
     557                 :            :         return 0;
     558                 :            : }
     559                 :            : 
     560                 :            : /**
     561                 :            :  * Make as much checks as possible on a VLAN item, and if a flow is provided,
     562                 :            :  * fill it appropriately with VLAN info.
     563                 :            :  *
     564                 :            :  * @param[in] item
     565                 :            :  *   Item specification.
     566                 :            :  * @param[in, out] data
     567                 :            :  *   Additional data structure to tell next layers we've been here.
     568                 :            :  *
     569                 :            :  * @return
     570                 :            :  *   0 if checks are alright, -1 otherwise.
     571                 :            :  */
     572                 :            : static int
     573                 :          0 : tap_flow_create_vlan(const struct rte_flow_item *item, void *data)
     574                 :            : {
     575                 :            :         struct convert_data *info = (struct convert_data *)data;
     576                 :          0 :         const struct rte_flow_item_vlan *spec = item->spec;
     577                 :          0 :         const struct rte_flow_item_vlan *mask = item->mask;
     578                 :          0 :         struct rte_flow *flow = info->flow;
     579                 :            :         struct nlmsg *msg;
     580                 :            : 
     581                 :            :         /* use default mask if none provided */
     582         [ #  # ]:          0 :         if (!mask)
     583                 :            :                 mask = tap_flow_items[RTE_FLOW_ITEM_TYPE_VLAN].default_mask;
     584                 :            :         /* Outer TPID cannot be matched. */
     585         [ #  # ]:          0 :         if (info->eth_type)
     586                 :            :                 return -1;
     587                 :            :         /* Double-tagging not supported. */
     588         [ #  # ]:          0 :         if (info->vlan)
     589                 :            :                 return -1;
     590                 :          0 :         info->vlan = 1;
     591         [ #  # ]:          0 :         if (mask->hdr.eth_proto) {
     592                 :            :                 /* TC does not support partial eth_type masking */
     593         [ #  # ]:          0 :                 if (mask->hdr.eth_proto != RTE_BE16(0xffff))
     594                 :            :                         return -1;
     595                 :          0 :                 info->eth_type = spec->hdr.eth_proto;
     596                 :            :         }
     597         [ #  # ]:          0 :         if (!flow)
     598                 :            :                 return 0;
     599                 :            :         msg = &flow->msg;
     600                 :          0 :         msg->t.tcm_info = TC_H_MAKE(msg->t.tcm_info, htons(ETH_P_8021Q));
     601                 :            : #define VLAN_PRIO(tci) ((tci) >> 13)
     602                 :            : #define VLAN_ID(tci) ((tci) & 0xfff)
     603         [ #  # ]:          0 :         if (!spec)
     604                 :            :                 return 0;
     605         [ #  # ]:          0 :         if (spec->hdr.vlan_tci) {
     606         [ #  # ]:          0 :                 uint16_t tci = ntohs(spec->hdr.vlan_tci) & mask->hdr.vlan_tci;
     607                 :          0 :                 uint16_t prio = VLAN_PRIO(tci);
     608                 :          0 :                 uint8_t vid = VLAN_ID(tci);
     609                 :            : 
     610         [ #  # ]:          0 :                 if (prio)
     611                 :          0 :                         tap_nlattr_add8(&msg->nh,
     612                 :            :                                         TCA_FLOWER_KEY_VLAN_PRIO, prio);
     613         [ #  # ]:          0 :                 if (vid)
     614                 :          0 :                         tap_nlattr_add16(&msg->nh,
     615                 :            :                                          TCA_FLOWER_KEY_VLAN_ID, vid);
     616                 :            :         }
     617                 :            :         return 0;
     618                 :            : }
     619                 :            : 
     620                 :            : /**
     621                 :            :  * Make as much checks as possible on an IPv4 item, and if a flow is provided,
     622                 :            :  * fill it appropriately with IPv4 info.
     623                 :            :  *
     624                 :            :  * @param[in] item
     625                 :            :  *   Item specification.
     626                 :            :  * @param[in, out] data
     627                 :            :  *   Additional data structure to tell next layers we've been here.
     628                 :            :  *
     629                 :            :  * @return
     630                 :            :  *   0 if checks are alright, -1 otherwise.
     631                 :            :  */
     632                 :            : static int
     633                 :          0 : tap_flow_create_ipv4(const struct rte_flow_item *item, void *data)
     634                 :            : {
     635                 :            :         struct convert_data *info = (struct convert_data *)data;
     636                 :          0 :         const struct rte_flow_item_ipv4 *spec = item->spec;
     637                 :          0 :         const struct rte_flow_item_ipv4 *mask = item->mask;
     638                 :          0 :         struct rte_flow *flow = info->flow;
     639                 :            :         struct nlmsg *msg;
     640                 :            : 
     641                 :            :         /* use default mask if none provided */
     642         [ #  # ]:          0 :         if (!mask)
     643                 :            :                 mask = tap_flow_items[RTE_FLOW_ITEM_TYPE_IPV4].default_mask;
     644                 :            :         /* check that previous eth type is compatible with ipv4 */
     645   [ #  #  #  # ]:          0 :         if (info->eth_type && info->eth_type != htons(ETH_P_IP))
     646                 :            :                 return -1;
     647                 :            :         /* store ip_proto for consistency if udp/tcp pattern item comes next */
     648         [ #  # ]:          0 :         if (spec)
     649                 :          0 :                 info->ip_proto = spec->hdr.next_proto_id;
     650         [ #  # ]:          0 :         if (!flow)
     651                 :            :                 return 0;
     652                 :            :         msg = &flow->msg;
     653         [ #  # ]:          0 :         if (!info->eth_type)
     654                 :          0 :                 info->eth_type = htons(ETH_P_IP);
     655         [ #  # ]:          0 :         if (!spec)
     656                 :            :                 return 0;
     657         [ #  # ]:          0 :         if (mask->hdr.dst_addr) {
     658                 :          0 :                 tap_nlattr_add32(&msg->nh, TCA_FLOWER_KEY_IPV4_DST,
     659                 :          0 :                              spec->hdr.dst_addr);
     660                 :          0 :                 tap_nlattr_add32(&msg->nh, TCA_FLOWER_KEY_IPV4_DST_MASK,
     661                 :          0 :                              mask->hdr.dst_addr);
     662                 :            :         }
     663         [ #  # ]:          0 :         if (mask->hdr.src_addr) {
     664                 :          0 :                 tap_nlattr_add32(&msg->nh, TCA_FLOWER_KEY_IPV4_SRC,
     665                 :          0 :                              spec->hdr.src_addr);
     666                 :          0 :                 tap_nlattr_add32(&msg->nh, TCA_FLOWER_KEY_IPV4_SRC_MASK,
     667                 :          0 :                              mask->hdr.src_addr);
     668                 :            :         }
     669         [ #  # ]:          0 :         if (spec->hdr.next_proto_id)
     670                 :          0 :                 tap_nlattr_add8(&msg->nh, TCA_FLOWER_KEY_IP_PROTO,
     671                 :            :                             spec->hdr.next_proto_id);
     672                 :            :         return 0;
     673                 :            : }
     674                 :            : 
     675                 :            : /**
     676                 :            :  * Make as much checks as possible on an IPv6 item, and if a flow is provided,
     677                 :            :  * fill it appropriately with IPv6 info.
     678                 :            :  *
     679                 :            :  * @param[in] item
     680                 :            :  *   Item specification.
     681                 :            :  * @param[in, out] data
     682                 :            :  *   Additional data structure to tell next layers we've been here.
     683                 :            :  *
     684                 :            :  * @return
     685                 :            :  *   0 if checks are alright, -1 otherwise.
     686                 :            :  */
     687                 :            : static int
     688                 :          0 : tap_flow_create_ipv6(const struct rte_flow_item *item, void *data)
     689                 :            : {
     690                 :            :         struct convert_data *info = (struct convert_data *)data;
     691                 :          0 :         const struct rte_flow_item_ipv6 *spec = item->spec;
     692                 :          0 :         const struct rte_flow_item_ipv6 *mask = item->mask;
     693                 :          0 :         struct rte_flow *flow = info->flow;
     694                 :          0 :         uint8_t empty_addr[16] = { 0 };
     695                 :            :         struct nlmsg *msg;
     696                 :            : 
     697                 :            :         /* use default mask if none provided */
     698         [ #  # ]:          0 :         if (!mask)
     699                 :            :                 mask = tap_flow_items[RTE_FLOW_ITEM_TYPE_IPV6].default_mask;
     700                 :            :         /* check that previous eth type is compatible with ipv6 */
     701   [ #  #  #  # ]:          0 :         if (info->eth_type && info->eth_type != htons(ETH_P_IPV6))
     702                 :            :                 return -1;
     703                 :            :         /* store ip_proto for consistency if udp/tcp pattern item comes next */
     704         [ #  # ]:          0 :         if (spec)
     705                 :          0 :                 info->ip_proto = spec->hdr.proto;
     706         [ #  # ]:          0 :         if (!flow)
     707                 :            :                 return 0;
     708                 :            :         msg = &flow->msg;
     709         [ #  # ]:          0 :         if (!info->eth_type)
     710                 :          0 :                 info->eth_type = htons(ETH_P_IPV6);
     711         [ #  # ]:          0 :         if (!spec)
     712                 :            :                 return 0;
     713         [ #  # ]:          0 :         if (memcmp(mask->hdr.dst_addr, empty_addr, 16)) {
     714                 :          0 :                 tap_nlattr_add(&msg->nh, TCA_FLOWER_KEY_IPV6_DST,
     715                 :          0 :                            sizeof(spec->hdr.dst_addr), &spec->hdr.dst_addr);
     716                 :          0 :                 tap_nlattr_add(&msg->nh, TCA_FLOWER_KEY_IPV6_DST_MASK,
     717                 :            :                            sizeof(mask->hdr.dst_addr), &mask->hdr.dst_addr);
     718                 :            :         }
     719         [ #  # ]:          0 :         if (memcmp(mask->hdr.src_addr, empty_addr, 16)) {
     720                 :          0 :                 tap_nlattr_add(&msg->nh, TCA_FLOWER_KEY_IPV6_SRC,
     721                 :          0 :                            sizeof(spec->hdr.src_addr), &spec->hdr.src_addr);
     722                 :          0 :                 tap_nlattr_add(&msg->nh, TCA_FLOWER_KEY_IPV6_SRC_MASK,
     723                 :            :                            sizeof(mask->hdr.src_addr), &mask->hdr.src_addr);
     724                 :            :         }
     725         [ #  # ]:          0 :         if (spec->hdr.proto)
     726                 :          0 :                 tap_nlattr_add8(&msg->nh,
     727                 :            :                                 TCA_FLOWER_KEY_IP_PROTO, spec->hdr.proto);
     728                 :            :         return 0;
     729                 :            : }
     730                 :            : 
     731                 :            : /**
     732                 :            :  * Make as much checks as possible on a UDP item, and if a flow is provided,
     733                 :            :  * fill it appropriately with UDP info.
     734                 :            :  *
     735                 :            :  * @param[in] item
     736                 :            :  *   Item specification.
     737                 :            :  * @param[in, out] data
     738                 :            :  *   Additional data structure to tell next layers we've been here.
     739                 :            :  *
     740                 :            :  * @return
     741                 :            :  *   0 if checks are alright, -1 otherwise.
     742                 :            :  */
     743                 :            : static int
     744                 :          0 : tap_flow_create_udp(const struct rte_flow_item *item, void *data)
     745                 :            : {
     746                 :            :         struct convert_data *info = (struct convert_data *)data;
     747                 :          0 :         const struct rte_flow_item_udp *spec = item->spec;
     748                 :          0 :         const struct rte_flow_item_udp *mask = item->mask;
     749                 :          0 :         struct rte_flow *flow = info->flow;
     750                 :            :         struct nlmsg *msg;
     751                 :            : 
     752                 :            :         /* use default mask if none provided */
     753         [ #  # ]:          0 :         if (!mask)
     754                 :            :                 mask = tap_flow_items[RTE_FLOW_ITEM_TYPE_UDP].default_mask;
     755                 :            :         /* check that previous ip_proto is compatible with udp */
     756         [ #  # ]:          0 :         if (info->ip_proto && info->ip_proto != IPPROTO_UDP)
     757                 :            :                 return -1;
     758                 :            :         /* TC does not support UDP port masking. Only accept if exact match. */
     759         [ #  # ]:          0 :         if ((mask->hdr.src_port && mask->hdr.src_port != 0xffff) ||
     760         [ #  # ]:          0 :             (mask->hdr.dst_port && mask->hdr.dst_port != 0xffff))
     761                 :            :                 return -1;
     762         [ #  # ]:          0 :         if (!flow)
     763                 :            :                 return 0;
     764                 :            :         msg = &flow->msg;
     765                 :          0 :         tap_nlattr_add8(&msg->nh, TCA_FLOWER_KEY_IP_PROTO, IPPROTO_UDP);
     766         [ #  # ]:          0 :         if (!spec)
     767                 :            :                 return 0;
     768         [ #  # ]:          0 :         if (mask->hdr.dst_port)
     769                 :          0 :                 tap_nlattr_add16(&msg->nh, TCA_FLOWER_KEY_UDP_DST,
     770                 :          0 :                              spec->hdr.dst_port);
     771         [ #  # ]:          0 :         if (mask->hdr.src_port)
     772                 :          0 :                 tap_nlattr_add16(&msg->nh, TCA_FLOWER_KEY_UDP_SRC,
     773                 :          0 :                              spec->hdr.src_port);
     774                 :            :         return 0;
     775                 :            : }
     776                 :            : 
     777                 :            : /**
     778                 :            :  * Make as much checks as possible on a TCP item, and if a flow is provided,
     779                 :            :  * fill it appropriately with TCP info.
     780                 :            :  *
     781                 :            :  * @param[in] item
     782                 :            :  *   Item specification.
     783                 :            :  * @param[in, out] data
     784                 :            :  *   Additional data structure to tell next layers we've been here.
     785                 :            :  *
     786                 :            :  * @return
     787                 :            :  *   0 if checks are alright, -1 otherwise.
     788                 :            :  */
     789                 :            : static int
     790                 :          0 : tap_flow_create_tcp(const struct rte_flow_item *item, void *data)
     791                 :            : {
     792                 :            :         struct convert_data *info = (struct convert_data *)data;
     793                 :          0 :         const struct rte_flow_item_tcp *spec = item->spec;
     794                 :          0 :         const struct rte_flow_item_tcp *mask = item->mask;
     795                 :          0 :         struct rte_flow *flow = info->flow;
     796                 :            :         struct nlmsg *msg;
     797                 :            : 
     798                 :            :         /* use default mask if none provided */
     799         [ #  # ]:          0 :         if (!mask)
     800                 :            :                 mask = tap_flow_items[RTE_FLOW_ITEM_TYPE_TCP].default_mask;
     801                 :            :         /* check that previous ip_proto is compatible with tcp */
     802         [ #  # ]:          0 :         if (info->ip_proto && info->ip_proto != IPPROTO_TCP)
     803                 :            :                 return -1;
     804                 :            :         /* TC does not support TCP port masking. Only accept if exact match. */
     805         [ #  # ]:          0 :         if ((mask->hdr.src_port && mask->hdr.src_port != 0xffff) ||
     806         [ #  # ]:          0 :             (mask->hdr.dst_port && mask->hdr.dst_port != 0xffff))
     807                 :            :                 return -1;
     808         [ #  # ]:          0 :         if (!flow)
     809                 :            :                 return 0;
     810                 :            :         msg = &flow->msg;
     811                 :          0 :         tap_nlattr_add8(&msg->nh, TCA_FLOWER_KEY_IP_PROTO, IPPROTO_TCP);
     812         [ #  # ]:          0 :         if (!spec)
     813                 :            :                 return 0;
     814         [ #  # ]:          0 :         if (mask->hdr.dst_port)
     815                 :          0 :                 tap_nlattr_add16(&msg->nh, TCA_FLOWER_KEY_TCP_DST,
     816                 :          0 :                              spec->hdr.dst_port);
     817         [ #  # ]:          0 :         if (mask->hdr.src_port)
     818                 :          0 :                 tap_nlattr_add16(&msg->nh, TCA_FLOWER_KEY_TCP_SRC,
     819                 :          0 :                              spec->hdr.src_port);
     820                 :            :         return 0;
     821                 :            : }
     822                 :            : 
     823                 :            : /**
     824                 :            :  * Check support for a given item.
     825                 :            :  *
     826                 :            :  * @param[in] item
     827                 :            :  *   Item specification.
     828                 :            :  * @param size
     829                 :            :  *   Bit-Mask size in bytes.
     830                 :            :  * @param[in] supported_mask
     831                 :            :  *   Bit-mask covering supported fields to compare with spec, last and mask in
     832                 :            :  *   \item.
     833                 :            :  * @param[in] default_mask
     834                 :            :  *   Bit-mask default mask if none is provided in \item.
     835                 :            :  *
     836                 :            :  * @return
     837                 :            :  *   0 on success.
     838                 :            :  */
     839                 :            : static int
     840                 :          0 : tap_flow_item_validate(const struct rte_flow_item *item,
     841                 :            :                        unsigned int size,
     842                 :            :                        const uint8_t *supported_mask,
     843                 :            :                        const uint8_t *default_mask)
     844                 :            : {
     845                 :            :         int ret = 0;
     846                 :            : 
     847                 :            :         /* An empty layer is allowed, as long as all fields are NULL */
     848   [ #  #  #  #  :          0 :         if (!item->spec && (item->mask || item->last))
                   #  # ]
     849                 :            :                 return -1;
     850                 :            :         /* Is the item spec compatible with what the NIC supports? */
     851   [ #  #  #  # ]:          0 :         if (item->spec && !item->mask) {
     852                 :            :                 unsigned int i;
     853                 :            :                 const uint8_t *spec = item->spec;
     854                 :            : 
     855         [ #  # ]:          0 :                 for (i = 0; i < size; ++i)
     856         [ #  # ]:          0 :                         if ((spec[i] | supported_mask[i]) != supported_mask[i])
     857                 :            :                                 return -1;
     858                 :            :                 /* Is the default mask compatible with what the NIC supports? */
     859         [ #  # ]:          0 :                 for (i = 0; i < size; i++)
     860         [ #  # ]:          0 :                         if ((default_mask[i] | supported_mask[i]) !=
     861                 :            :                             supported_mask[i])
     862                 :            :                                 return -1;
     863                 :            :         }
     864                 :            :         /* Is the item last compatible with what the NIC supports? */
     865   [ #  #  #  # ]:          0 :         if (item->last && !item->mask) {
     866                 :            :                 unsigned int i;
     867                 :            :                 const uint8_t *spec = item->last;
     868                 :            : 
     869         [ #  # ]:          0 :                 for (i = 0; i < size; ++i)
     870         [ #  # ]:          0 :                         if ((spec[i] | supported_mask[i]) != supported_mask[i])
     871                 :            :                                 return -1;
     872                 :            :         }
     873                 :            :         /* Is the item mask compatible with what the NIC supports? */
     874         [ #  # ]:          0 :         if (item->mask) {
     875                 :            :                 unsigned int i;
     876                 :            :                 const uint8_t *spec = item->mask;
     877                 :            : 
     878         [ #  # ]:          0 :                 for (i = 0; i < size; ++i)
     879         [ #  # ]:          0 :                         if ((spec[i] | supported_mask[i]) != supported_mask[i])
     880                 :            :                                 return -1;
     881                 :            :         }
     882                 :            :         /**
     883                 :            :          * Once masked, Are item spec and item last equal?
     884                 :            :          * TC does not support range so anything else is invalid.
     885                 :            :          */
     886   [ #  #  #  # ]:          0 :         if (item->spec && item->last) {
     887                 :          0 :                 uint8_t spec[size];
     888                 :          0 :                 uint8_t last[size];
     889                 :            :                 const uint8_t *apply = default_mask;
     890                 :            :                 unsigned int i;
     891                 :            : 
     892         [ #  # ]:          0 :                 if (item->mask)
     893                 :            :                         apply = item->mask;
     894         [ #  # ]:          0 :                 for (i = 0; i < size; ++i) {
     895                 :          0 :                         spec[i] = ((const uint8_t *)item->spec)[i] & apply[i];
     896                 :          0 :                         last[i] = ((const uint8_t *)item->last)[i] & apply[i];
     897                 :            :                 }
     898                 :          0 :                 ret = memcmp(spec, last, size);
     899                 :            :         }
     900                 :            :         return ret;
     901                 :            : }
     902                 :            : 
     903                 :            : /**
     904                 :            :  * Configure the kernel with a TC action and its configured parameters
     905                 :            :  * Handled actions: "gact", "mirred", "skbedit", "bpf"
     906                 :            :  *
     907                 :            :  * @param[in] flow
     908                 :            :  *   Pointer to rte flow containing the netlink message
     909                 :            :  *
     910                 :            :  * @param[in, out] act_index
     911                 :            :  *   Pointer to action sequence number in the TC command
     912                 :            :  *
     913                 :            :  * @param[in] adata
     914                 :            :  *  Pointer to struct holding the action parameters
     915                 :            :  *
     916                 :            :  * @return
     917                 :            :  *   -1 on failure, 0 on success
     918                 :            :  */
     919                 :            : static int
     920                 :          0 : add_action(struct rte_flow *flow, size_t *act_index, struct action_data *adata)
     921                 :            : {
     922                 :          0 :         struct nlmsg *msg = &flow->msg;
     923                 :            : 
     924         [ #  # ]:          0 :         if (tap_nlattr_nested_start(msg, (*act_index)++) < 0)
     925                 :            :                 return -1;
     926                 :            : 
     927                 :          0 :         tap_nlattr_add(&msg->nh, TCA_ACT_KIND,
     928                 :          0 :                                 strlen(adata->id) + 1, adata->id);
     929         [ #  # ]:          0 :         if (tap_nlattr_nested_start(msg, TCA_ACT_OPTIONS) < 0)
     930                 :            :                 return -1;
     931         [ #  # ]:          0 :         if (strcmp("gact", adata->id) == 0) {
     932                 :          0 :                 tap_nlattr_add(&msg->nh, TCA_GACT_PARMS, sizeof(adata->gact),
     933                 :          0 :                            &adata->gact);
     934         [ #  # ]:          0 :         } else if (strcmp("mirred", adata->id) == 0) {
     935         [ #  # ]:          0 :                 if (adata->mirred.eaction == TCA_EGRESS_MIRROR)
     936                 :          0 :                         adata->mirred.action = TC_ACT_PIPE;
     937                 :            :                 else /* REDIRECT */
     938                 :          0 :                         adata->mirred.action = TC_ACT_STOLEN;
     939                 :          0 :                 tap_nlattr_add(&msg->nh, TCA_MIRRED_PARMS,
     940                 :            :                            sizeof(adata->mirred),
     941                 :          0 :                            &adata->mirred);
     942         [ #  # ]:          0 :         } else if (strcmp("skbedit", adata->id) == 0) {
     943                 :          0 :                 tap_nlattr_add(&msg->nh, TCA_SKBEDIT_PARMS,
     944                 :            :                            sizeof(adata->skbedit.skbedit),
     945                 :          0 :                            &adata->skbedit.skbedit);
     946                 :          0 :                 tap_nlattr_add16(&msg->nh, TCA_SKBEDIT_QUEUE_MAPPING,
     947                 :          0 :                              adata->skbedit.queue);
     948         [ #  # ]:          0 :         } else if (strcmp("bpf", adata->id) == 0) {
     949                 :          0 :                 tap_nlattr_add32(&msg->nh, TCA_ACT_BPF_FD, adata->bpf.bpf_fd);
     950                 :          0 :                 tap_nlattr_add(&msg->nh, TCA_ACT_BPF_NAME,
     951                 :          0 :                            strlen(adata->bpf.annotation) + 1,
     952                 :          0 :                            adata->bpf.annotation);
     953                 :          0 :                 tap_nlattr_add(&msg->nh, TCA_ACT_BPF_PARMS,
     954                 :            :                            sizeof(adata->bpf.bpf),
     955                 :          0 :                            &adata->bpf.bpf);
     956                 :            :         } else {
     957                 :            :                 return -1;
     958                 :            :         }
     959                 :          0 :         tap_nlattr_nested_finish(msg); /* nested TCA_ACT_OPTIONS */
     960                 :          0 :         tap_nlattr_nested_finish(msg); /* nested act_index */
     961                 :          0 :         return 0;
     962                 :            : }
     963                 :            : 
     964                 :            : /**
     965                 :            :  * Helper function to send a series of TC actions to the kernel
     966                 :            :  *
     967                 :            :  * @param[in] flow
     968                 :            :  *   Pointer to rte flow containing the netlink message
     969                 :            :  *
     970                 :            :  * @param[in] nb_actions
     971                 :            :  *   Number of actions in an array of action structs
     972                 :            :  *
     973                 :            :  * @param[in] data
     974                 :            :  *   Pointer to an array of action structs
     975                 :            :  *
     976                 :            :  * @param[in] classifier_actions
     977                 :            :  *   The classifier on behave of which the actions are configured
     978                 :            :  *
     979                 :            :  * @return
     980                 :            :  *   -1 on failure, 0 on success
     981                 :            :  */
     982                 :            : static int
     983                 :          0 : add_actions(struct rte_flow *flow, int nb_actions, struct action_data *data,
     984                 :            :             int classifier_action)
     985                 :            : {
     986                 :          0 :         struct nlmsg *msg = &flow->msg;
     987                 :          0 :         size_t act_index = 1;
     988                 :            :         int i;
     989                 :            : 
     990         [ #  # ]:          0 :         if (tap_nlattr_nested_start(msg, classifier_action) < 0)
     991                 :            :                 return -1;
     992         [ #  # ]:          0 :         for (i = 0; i < nb_actions; i++)
     993         [ #  # ]:          0 :                 if (add_action(flow, &act_index, data + i) < 0)
     994                 :            :                         return -1;
     995                 :          0 :         tap_nlattr_nested_finish(msg); /* nested TCA_FLOWER_ACT */
     996                 :          0 :         return 0;
     997                 :            : }
     998                 :            : 
     999                 :            : /**
    1000                 :            :  * Validate a flow supported by TC.
    1001                 :            :  * If flow param is not NULL, then also fill the netlink message inside.
    1002                 :            :  *
    1003                 :            :  * @param pmd
    1004                 :            :  *   Pointer to private structure.
    1005                 :            :  * @param[in] attr
    1006                 :            :  *   Flow rule attributes.
    1007                 :            :  * @param[in] pattern
    1008                 :            :  *   Pattern specification (list terminated by the END pattern item).
    1009                 :            :  * @param[in] actions
    1010                 :            :  *   Associated actions (list terminated by the END action).
    1011                 :            :  * @param[out] error
    1012                 :            :  *   Perform verbose error reporting if not NULL.
    1013                 :            :  * @param[in, out] flow
    1014                 :            :  *   Flow structure to update.
    1015                 :            :  * @param[in] mirred
    1016                 :            :  *   If set to TCA_EGRESS_REDIR, provided actions will be replaced with a
    1017                 :            :  *   redirection to the tap netdevice, and the TC rule will be configured
    1018                 :            :  *   on the remote netdevice in pmd.
    1019                 :            :  *   If set to TCA_EGRESS_MIRROR, provided actions will be replaced with a
    1020                 :            :  *   mirroring to the tap netdevice, and the TC rule will be configured
    1021                 :            :  *   on the remote netdevice in pmd. Matching packets will thus be duplicated.
    1022                 :            :  *   If set to 0, the standard behavior is to be used: set correct actions for
    1023                 :            :  *   the TC rule, and apply it on the tap netdevice.
    1024                 :            :  *
    1025                 :            :  * @return
    1026                 :            :  *   0 on success, a negative errno value otherwise and rte_errno is set.
    1027                 :            :  */
    1028                 :            : static int
    1029                 :          0 : priv_flow_process(struct pmd_internals *pmd,
    1030                 :            :                   const struct rte_flow_attr *attr,
    1031                 :            :                   const struct rte_flow_item items[],
    1032                 :            :                   const struct rte_flow_action actions[],
    1033                 :            :                   struct rte_flow_error *error,
    1034                 :            :                   struct rte_flow *flow,
    1035                 :            :                   int mirred)
    1036                 :            : {
    1037                 :            :         const struct tap_flow_items *cur_item = tap_flow_items;
    1038                 :          0 :         struct convert_data data = {
    1039                 :            :                 .eth_type = 0,
    1040                 :            :                 .ip_proto = 0,
    1041                 :            :                 .flow = flow,
    1042                 :            :         };
    1043                 :            :         int action = 0; /* Only one action authorized for now */
    1044                 :            : 
    1045         [ #  # ]:          0 :         if (attr->transfer) {
    1046                 :          0 :                 rte_flow_error_set(
    1047                 :            :                         error, ENOTSUP, RTE_FLOW_ERROR_TYPE_ATTR_TRANSFER,
    1048                 :            :                         NULL, "transfer is not supported");
    1049                 :          0 :                 return -rte_errno;
    1050                 :            :         }
    1051         [ #  # ]:          0 :         if (attr->group > MAX_GROUP) {
    1052                 :          0 :                 rte_flow_error_set(
    1053                 :            :                         error, EINVAL, RTE_FLOW_ERROR_TYPE_ATTR_GROUP,
    1054                 :            :                         NULL, "group value too big: cannot exceed 15");
    1055                 :          0 :                 return -rte_errno;
    1056                 :            :         }
    1057         [ #  # ]:          0 :         if (attr->priority > MAX_PRIORITY) {
    1058                 :          0 :                 rte_flow_error_set(
    1059                 :            :                         error, EINVAL, RTE_FLOW_ERROR_TYPE_ATTR_PRIORITY,
    1060                 :            :                         NULL, "priority value too big");
    1061                 :          0 :                 return -rte_errno;
    1062         [ #  # ]:          0 :         } else if (flow) {
    1063                 :          0 :                 uint16_t group = attr->group << GROUP_SHIFT;
    1064                 :          0 :                 uint16_t prio = group | (attr->priority +
    1065                 :          0 :                                 RSS_PRIORITY_OFFSET + PRIORITY_OFFSET);
    1066                 :          0 :                 flow->msg.t.tcm_info = TC_H_MAKE(prio << 16,
    1067                 :            :                                                  flow->msg.t.tcm_info);
    1068                 :            :         }
    1069         [ #  # ]:          0 :         if (flow) {
    1070         [ #  # ]:          0 :                 if (mirred) {
    1071                 :            :                         /*
    1072                 :            :                          * If attr->ingress, the rule applies on remote ingress
    1073                 :            :                          * to match incoming packets
    1074                 :            :                          * If attr->egress, the rule applies on tap ingress (as
    1075                 :            :                          * seen from the kernel) to deal with packets going out
    1076                 :            :                          * from the DPDK app.
    1077                 :            :                          */
    1078                 :          0 :                         flow->msg.t.tcm_parent = TC_H_MAKE(TC_H_INGRESS, 0);
    1079                 :            :                 } else {
    1080                 :            :                         /* Standard rule on tap egress (kernel standpoint). */
    1081                 :          0 :                         flow->msg.t.tcm_parent =
    1082                 :            :                                 TC_H_MAKE(MULTIQ_MAJOR_HANDLE, 0);
    1083                 :            :                 }
    1084                 :            :                 /* use flower filter type */
    1085                 :          0 :                 tap_nlattr_add(&flow->msg.nh, TCA_KIND, sizeof("flower"), "flower");
    1086         [ #  # ]:          0 :                 if (tap_nlattr_nested_start(&flow->msg, TCA_OPTIONS) < 0) {
    1087                 :          0 :                         rte_flow_error_set(error, ENOMEM, RTE_FLOW_ERROR_TYPE_ACTION,
    1088                 :            :                                            actions, "could not allocated netlink msg");
    1089                 :          0 :                         goto exit_return_error;
    1090                 :            :                 }
    1091                 :            :         }
    1092         [ #  # ]:          0 :         for (; items->type != RTE_FLOW_ITEM_TYPE_END; ++items) {
    1093                 :            :                 const struct tap_flow_items *token = NULL;
    1094                 :            :                 unsigned int i;
    1095                 :            :                 int err = 0;
    1096                 :            : 
    1097         [ #  # ]:          0 :                 if (items->type == RTE_FLOW_ITEM_TYPE_VOID)
    1098                 :          0 :                         continue;
    1099                 :            :                 for (i = 0;
    1100         [ #  # ]:          0 :                      cur_item->items &&
    1101         [ #  # ]:          0 :                      cur_item->items[i] != RTE_FLOW_ITEM_TYPE_END;
    1102                 :          0 :                      ++i) {
    1103         [ #  # ]:          0 :                         if (cur_item->items[i] == items->type) {
    1104                 :          0 :                                 token = &tap_flow_items[items->type];
    1105                 :          0 :                                 break;
    1106                 :            :                         }
    1107                 :            :                 }
    1108         [ #  # ]:          0 :                 if (!token)
    1109                 :          0 :                         goto exit_item_not_supported;
    1110                 :            :                 cur_item = token;
    1111                 :          0 :                 err = tap_flow_item_validate(
    1112                 :          0 :                         items, cur_item->mask_sz,
    1113                 :          0 :                         (const uint8_t *)cur_item->mask,
    1114                 :          0 :                         (const uint8_t *)cur_item->default_mask);
    1115         [ #  # ]:          0 :                 if (err)
    1116                 :          0 :                         goto exit_item_not_supported;
    1117   [ #  #  #  # ]:          0 :                 if (flow && cur_item->convert) {
    1118                 :          0 :                         err = cur_item->convert(items, &data);
    1119         [ #  # ]:          0 :                         if (err)
    1120                 :          0 :                                 goto exit_item_not_supported;
    1121                 :            :                 }
    1122                 :            :         }
    1123         [ #  # ]:          0 :         if (flow) {
    1124         [ #  # ]:          0 :                 if (data.vlan) {
    1125                 :          0 :                         tap_nlattr_add16(&flow->msg.nh, TCA_FLOWER_KEY_ETH_TYPE,
    1126                 :            :                                      htons(ETH_P_8021Q));
    1127                 :          0 :                         tap_nlattr_add16(&flow->msg.nh,
    1128                 :            :                                      TCA_FLOWER_KEY_VLAN_ETH_TYPE,
    1129         [ #  # ]:          0 :                                      data.eth_type ?
    1130                 :            :                                      data.eth_type : htons(ETH_P_ALL));
    1131         [ #  # ]:          0 :                 } else if (data.eth_type) {
    1132                 :          0 :                         tap_nlattr_add16(&flow->msg.nh, TCA_FLOWER_KEY_ETH_TYPE,
    1133                 :            :                                      data.eth_type);
    1134                 :            :                 }
    1135                 :            :         }
    1136         [ #  # ]:          0 :         if (mirred && flow) {
    1137                 :          0 :                 struct action_data adata = {
    1138                 :            :                         .id = "mirred",
    1139                 :            :                         .mirred = {
    1140                 :            :                                 .eaction = mirred,
    1141                 :            :                         },
    1142                 :            :                 };
    1143                 :            : 
    1144                 :            :                 /*
    1145                 :            :                  * If attr->egress && mirred, then this is a special
    1146                 :            :                  * case where the rule must be applied on the tap, to
    1147                 :            :                  * redirect packets coming from the DPDK App, out
    1148                 :            :                  * through the remote netdevice.
    1149                 :            :                  */
    1150         [ #  # ]:          0 :                 adata.mirred.ifindex = attr->ingress ? pmd->if_index :
    1151                 :          0 :                         pmd->remote_if_index;
    1152         [ #  # ]:          0 :                 if (mirred == TCA_EGRESS_MIRROR)
    1153                 :          0 :                         adata.mirred.action = TC_ACT_PIPE;
    1154                 :            :                 else
    1155                 :          0 :                         adata.mirred.action = TC_ACT_STOLEN;
    1156         [ #  # ]:          0 :                 if (add_actions(flow, 1, &adata, TCA_FLOWER_ACT) < 0)
    1157                 :          0 :                         goto exit_action_not_supported;
    1158                 :            :                 else
    1159                 :          0 :                         goto end;
    1160                 :            :         }
    1161                 :          0 : actions:
    1162         [ #  # ]:          0 :         for (; actions->type != RTE_FLOW_ACTION_TYPE_END; ++actions) {
    1163                 :            :                 int err = 0;
    1164                 :            : 
    1165                 :          0 :                 if (actions->type == RTE_FLOW_ACTION_TYPE_VOID) {
    1166                 :          0 :                         continue;
    1167                 :            :                 } else if (actions->type == RTE_FLOW_ACTION_TYPE_DROP) {
    1168         [ #  # ]:          0 :                         if (action)
    1169                 :          0 :                                 goto exit_action_not_supported;
    1170                 :            :                         action = 1;
    1171         [ #  # ]:          0 :                         if (flow) {
    1172                 :          0 :                                 struct action_data adata = {
    1173                 :            :                                         .id = "gact",
    1174                 :            :                                         .gact = {
    1175                 :            :                                                 .action = TC_ACT_SHOT,
    1176                 :            :                                         },
    1177                 :            :                                 };
    1178                 :            : 
    1179                 :          0 :                                 err = add_actions(flow, 1, &adata,
    1180                 :            :                                                   TCA_FLOWER_ACT);
    1181                 :            :                         }
    1182                 :            :                 } else if (actions->type == RTE_FLOW_ACTION_TYPE_PASSTHRU) {
    1183         [ #  # ]:          0 :                         if (action)
    1184                 :          0 :                                 goto exit_action_not_supported;
    1185                 :            :                         action = 1;
    1186         [ #  # ]:          0 :                         if (flow) {
    1187                 :          0 :                                 struct action_data adata = {
    1188                 :            :                                         .id = "gact",
    1189                 :            :                                         .gact = {
    1190                 :            :                                                 /* continue */
    1191                 :            :                                                 .action = TC_ACT_UNSPEC,
    1192                 :            :                                         },
    1193                 :            :                                 };
    1194                 :            : 
    1195                 :          0 :                                 err = add_actions(flow, 1, &adata,
    1196                 :            :                                                   TCA_FLOWER_ACT);
    1197                 :            :                         }
    1198                 :            :                 } else if (actions->type == RTE_FLOW_ACTION_TYPE_QUEUE) {
    1199                 :          0 :                         const struct rte_flow_action_queue *queue =
    1200                 :            :                                 (const struct rte_flow_action_queue *)
    1201                 :            :                                 actions->conf;
    1202                 :            : 
    1203         [ #  # ]:          0 :                         if (action)
    1204                 :          0 :                                 goto exit_action_not_supported;
    1205                 :            :                         action = 1;
    1206         [ #  # ]:          0 :                         if (queue->index >= pmd->dev->data->nb_rx_queues) {
    1207                 :          0 :                                 rte_flow_error_set(error, ERANGE,
    1208                 :            :                                                    RTE_FLOW_ERROR_TYPE_ACTION, actions,
    1209                 :            :                                                    "queue index out of range");
    1210                 :          0 :                                 goto exit_return_error;
    1211                 :            :                         }
    1212         [ #  # ]:          0 :                         if (flow) {
    1213                 :          0 :                                 struct action_data adata = {
    1214                 :            :                                         .id = "skbedit",
    1215                 :            :                                         .skbedit = {
    1216                 :            :                                                 .skbedit = {
    1217                 :            :                                                         .action = TC_ACT_PIPE,
    1218                 :            :                                                 },
    1219                 :            :                                                 .queue = queue->index,
    1220                 :            :                                         },
    1221                 :            :                                 };
    1222                 :            : 
    1223                 :          0 :                                 err = add_actions(flow, 1, &adata,
    1224                 :            :                                         TCA_FLOWER_ACT);
    1225                 :            :                         }
    1226                 :            :                 } else if (actions->type == RTE_FLOW_ACTION_TYPE_RSS) {
    1227                 :          0 :                         const struct rte_flow_action_rss *rss =
    1228                 :            :                                 (const struct rte_flow_action_rss *)
    1229                 :            :                                 actions->conf;
    1230                 :            : 
    1231         [ #  # ]:          0 :                         if (action++)
    1232                 :          0 :                                 goto exit_action_not_supported;
    1233                 :            : 
    1234         [ #  # ]:          0 :                         if (!pmd->rss_enabled) {
    1235                 :          0 :                                 err = rss_enable(pmd, attr, error);
    1236         [ #  # ]:          0 :                                 if (err)
    1237                 :          0 :                                         goto exit_return_error;
    1238                 :            :                         }
    1239         [ #  # ]:          0 :                         if (flow)
    1240                 :          0 :                                 err = rss_add_actions(flow, pmd, rss, error);
    1241                 :            :                 } else {
    1242                 :          0 :                         goto exit_action_not_supported;
    1243                 :            :                 }
    1244         [ #  # ]:          0 :                 if (err)
    1245                 :          0 :                         goto exit_return_error;
    1246                 :            :         }
    1247                 :            :         /* When fate is unknown, drop traffic. */
    1248         [ #  # ]:          0 :         if (!action) {
    1249                 :            :                 static const struct rte_flow_action drop[] = {
    1250                 :            :                         { .type = RTE_FLOW_ACTION_TYPE_DROP, },
    1251                 :            :                         { .type = RTE_FLOW_ACTION_TYPE_END, },
    1252                 :            :                 };
    1253                 :            : 
    1254                 :            :                 actions = drop;
    1255                 :          0 :                 goto actions;
    1256                 :            :         }
    1257                 :          0 : end:
    1258         [ #  # ]:          0 :         if (flow)
    1259                 :          0 :                 tap_nlattr_nested_finish(&flow->msg); /* nested TCA_OPTIONS */
    1260                 :            :         return 0;
    1261                 :          0 : exit_item_not_supported:
    1262                 :          0 :         rte_flow_error_set(error, ENOTSUP, RTE_FLOW_ERROR_TYPE_ITEM,
    1263                 :            :                            items, "item not supported");
    1264                 :          0 :         return -rte_errno;
    1265                 :          0 : exit_action_not_supported:
    1266                 :          0 :         rte_flow_error_set(error, ENOTSUP, RTE_FLOW_ERROR_TYPE_ACTION,
    1267                 :            :                            actions, "action not supported");
    1268                 :          0 : exit_return_error:
    1269                 :          0 :         return -rte_errno;
    1270                 :            : }
    1271                 :            : 
    1272                 :            : 
    1273                 :            : 
    1274                 :            : /**
    1275                 :            :  * Validate a flow.
    1276                 :            :  *
    1277                 :            :  * @see rte_flow_validate()
    1278                 :            :  * @see rte_flow_ops
    1279                 :            :  */
    1280                 :            : static int
    1281                 :          0 : tap_flow_validate(struct rte_eth_dev *dev,
    1282                 :            :                   const struct rte_flow_attr *attr,
    1283                 :            :                   const struct rte_flow_item items[],
    1284                 :            :                   const struct rte_flow_action actions[],
    1285                 :            :                   struct rte_flow_error *error)
    1286                 :            : {
    1287                 :          0 :         struct pmd_internals *pmd = dev->data->dev_private;
    1288                 :            : 
    1289                 :          0 :         return priv_flow_process(pmd, attr, items, actions, error, NULL, 0);
    1290                 :            : }
    1291                 :            : 
    1292                 :            : /**
    1293                 :            :  * Set a unique handle in a flow.
    1294                 :            :  *
    1295                 :            :  * The kernel supports TC rules with equal priority, as long as they use the
    1296                 :            :  * same matching fields (e.g.: dst mac and ipv4) with different values (and
    1297                 :            :  * full mask to ensure no collision is possible).
    1298                 :            :  * In those rules, the handle (uint32_t) is the part that would identify
    1299                 :            :  * specifically each rule.
    1300                 :            :  *
    1301                 :            :  * Use jhash of the flow pointer to make a unique handle.
    1302                 :            :  *
    1303                 :            :  * @param[in, out] flow
    1304                 :            :  *   The flow that needs its handle set.
    1305                 :            :  */
    1306                 :            : static void
    1307                 :          0 : tap_flow_set_handle(struct rte_flow *flow)
    1308                 :            : {
    1309                 :            :         union {
    1310                 :            :                 struct rte_flow *flow;
    1311                 :            :                 uint32_t words[sizeof(flow) / sizeof(uint32_t)];
    1312                 :          0 :         } tmp = {
    1313                 :            :                 .flow = flow,
    1314                 :            :         };
    1315                 :            :         uint32_t handle;
    1316                 :            :         static uint64_t hash_seed;
    1317                 :            : 
    1318         [ #  # ]:          0 :         if (hash_seed == 0)
    1319                 :          0 :                 hash_seed = rte_rand();
    1320                 :            : 
    1321                 :          0 :         handle = rte_jhash_32b(tmp.words, sizeof(flow) / sizeof(uint32_t), hash_seed);
    1322                 :            : 
    1323                 :            :         /* must be at least 1 to avoid letting the kernel choose one for us */
    1324                 :            :         if (!handle)
    1325                 :            :                 handle = 1;
    1326                 :          0 :         flow->msg.t.tcm_handle = handle;
    1327                 :          0 : }
    1328                 :            : 
    1329                 :            : /**
    1330                 :            :  * Free the flow opened file descriptors and allocated memory
    1331                 :            :  *
    1332                 :            :  * @param[in] flow
    1333                 :            :  *   Pointer to the flow to free
    1334                 :            :  *
    1335                 :            :  */
    1336                 :            : static void
    1337                 :          0 : tap_flow_free(struct pmd_internals *pmd, struct rte_flow *flow)
    1338                 :            : {
    1339                 :            :         int i;
    1340                 :            : 
    1341         [ #  # ]:          0 :         if (!flow)
    1342                 :            :                 return;
    1343                 :            : 
    1344         [ #  # ]:          0 :         if (pmd->rss_enabled) {
    1345                 :            :                 /* Close flow BPF file descriptors */
    1346         [ #  # ]:          0 :                 for (i = 0; i < SEC_MAX; i++)
    1347         [ #  # ]:          0 :                         if (flow->bpf_fd[i] != 0) {
    1348                 :          0 :                                 close(flow->bpf_fd[i]);
    1349                 :          0 :                                 flow->bpf_fd[i] = 0;
    1350                 :            :                         }
    1351                 :            : 
    1352                 :            :                 /* Release the map key for this RSS rule */
    1353                 :            :                 bpf_rss_key(KEY_CMD_RELEASE, &flow->key_idx);
    1354                 :          0 :                 flow->key_idx = 0;
    1355                 :            :         }
    1356                 :            : 
    1357                 :            :         /* Free flow allocated memory */
    1358                 :          0 :         rte_free(flow);
    1359                 :            : }
    1360                 :            : 
    1361                 :            : /**
    1362                 :            :  * Create a flow.
    1363                 :            :  *
    1364                 :            :  * @see rte_flow_create()
    1365                 :            :  * @see rte_flow_ops
    1366                 :            :  */
    1367                 :            : static struct rte_flow *
    1368                 :          0 : tap_flow_create(struct rte_eth_dev *dev,
    1369                 :            :                 const struct rte_flow_attr *attr,
    1370                 :            :                 const struct rte_flow_item items[],
    1371                 :            :                 const struct rte_flow_action actions[],
    1372                 :            :                 struct rte_flow_error *error)
    1373                 :            : {
    1374                 :          0 :         struct pmd_internals *pmd = dev->data->dev_private;
    1375                 :            :         struct rte_flow *remote_flow = NULL;
    1376                 :            :         struct rte_flow *flow = NULL;
    1377                 :            :         struct nlmsg *msg = NULL;
    1378                 :            :         int err;
    1379                 :            : 
    1380         [ #  # ]:          0 :         if (!pmd->if_index) {
    1381                 :          0 :                 rte_flow_error_set(error, ENOTSUP, RTE_FLOW_ERROR_TYPE_HANDLE,
    1382                 :            :                                    NULL,
    1383                 :            :                                    "can't create rule, ifindex not found");
    1384                 :          0 :                 goto fail;
    1385                 :            :         }
    1386                 :            :         /*
    1387                 :            :          * No rules configured through standard rte_flow should be set on the
    1388                 :            :          * priorities used by implicit rules.
    1389                 :            :          */
    1390         [ #  # ]:          0 :         if ((attr->group == MAX_GROUP) &&
    1391         [ #  # ]:          0 :             attr->priority > (MAX_PRIORITY - TAP_REMOTE_MAX_IDX)) {
    1392                 :          0 :                 rte_flow_error_set(
    1393                 :            :                         error, ENOTSUP, RTE_FLOW_ERROR_TYPE_ATTR_PRIORITY,
    1394                 :            :                         NULL, "priority value too big");
    1395                 :          0 :                 goto fail;
    1396                 :            :         }
    1397                 :          0 :         flow = rte_zmalloc(__func__, sizeof(struct rte_flow), 0);
    1398         [ #  # ]:          0 :         if (!flow) {
    1399                 :          0 :                 rte_flow_error_set(error, ENOMEM, RTE_FLOW_ERROR_TYPE_HANDLE,
    1400                 :            :                                    NULL, "cannot allocate memory for rte_flow");
    1401                 :          0 :                 goto fail;
    1402                 :            :         }
    1403                 :          0 :         msg = &flow->msg;
    1404                 :          0 :         tc_init_msg(msg, pmd->if_index, RTM_NEWTFILTER,
    1405                 :            :                     NLM_F_REQUEST | NLM_F_ACK | NLM_F_EXCL | NLM_F_CREATE);
    1406                 :          0 :         msg->t.tcm_info = TC_H_MAKE(0, htons(ETH_P_ALL));
    1407                 :          0 :         tap_flow_set_handle(flow);
    1408         [ #  # ]:          0 :         if (priv_flow_process(pmd, attr, items, actions, error, flow, 0))
    1409                 :          0 :                 goto fail;
    1410                 :          0 :         err = tap_nl_send(pmd->nlsk_fd, &msg->nh);
    1411         [ #  # ]:          0 :         if (err < 0) {
    1412                 :          0 :                 rte_flow_error_set(error, ENOTSUP, RTE_FLOW_ERROR_TYPE_HANDLE,
    1413                 :            :                                    NULL, "couldn't send request to kernel");
    1414                 :          0 :                 goto fail;
    1415                 :            :         }
    1416                 :          0 :         err = tap_nl_recv_ack(pmd->nlsk_fd);
    1417         [ #  # ]:          0 :         if (err < 0) {
    1418                 :          0 :                 TAP_LOG(ERR,
    1419                 :            :                         "Kernel refused TC filter rule creation (%d): %s",
    1420                 :            :                         errno, strerror(errno));
    1421                 :          0 :                 rte_flow_error_set(error, EEXIST, RTE_FLOW_ERROR_TYPE_HANDLE,
    1422                 :            :                                    NULL,
    1423                 :            :                                    "overlapping rules or Kernel too old for flower support");
    1424                 :          0 :                 goto fail;
    1425                 :            :         }
    1426         [ #  # ]:          0 :         LIST_INSERT_HEAD(&pmd->flows, flow, next);
    1427                 :            :         /**
    1428                 :            :          * If a remote device is configured, a TC rule with identical items for
    1429                 :            :          * matching must be set on that device, with a single action: redirect
    1430                 :            :          * to the local pmd->if_index.
    1431                 :            :          */
    1432         [ #  # ]:          0 :         if (pmd->remote_if_index) {
    1433                 :          0 :                 remote_flow = rte_zmalloc(__func__, sizeof(struct rte_flow), 0);
    1434         [ #  # ]:          0 :                 if (!remote_flow) {
    1435                 :          0 :                         rte_flow_error_set(
    1436                 :            :                                 error, ENOMEM, RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
    1437                 :            :                                 "cannot allocate memory for rte_flow");
    1438                 :          0 :                         goto fail;
    1439                 :            :                 }
    1440                 :          0 :                 msg = &remote_flow->msg;
    1441                 :            :                 /* set the rule if_index for the remote netdevice */
    1442                 :          0 :                 tc_init_msg(
    1443                 :          0 :                         msg, pmd->remote_if_index, RTM_NEWTFILTER,
    1444                 :            :                         NLM_F_REQUEST | NLM_F_ACK | NLM_F_EXCL | NLM_F_CREATE);
    1445                 :          0 :                 msg->t.tcm_info = TC_H_MAKE(0, htons(ETH_P_ALL));
    1446                 :          0 :                 tap_flow_set_handle(remote_flow);
    1447         [ #  # ]:          0 :                 if (priv_flow_process(pmd, attr, items, NULL,
    1448                 :            :                                       error, remote_flow, TCA_EGRESS_REDIR)) {
    1449                 :          0 :                         rte_flow_error_set(
    1450                 :            :                                 error, ENOMEM, RTE_FLOW_ERROR_TYPE_HANDLE,
    1451                 :            :                                 NULL, "rte flow rule validation failed");
    1452                 :          0 :                         goto fail;
    1453                 :            :                 }
    1454                 :          0 :                 err = tap_nl_send(pmd->nlsk_fd, &msg->nh);
    1455         [ #  # ]:          0 :                 if (err < 0) {
    1456                 :          0 :                         rte_flow_error_set(
    1457                 :            :                                 error, ENOMEM, RTE_FLOW_ERROR_TYPE_HANDLE,
    1458                 :            :                                 NULL, "Failure sending nl request");
    1459                 :          0 :                         goto fail;
    1460                 :            :                 }
    1461                 :          0 :                 err = tap_nl_recv_ack(pmd->nlsk_fd);
    1462         [ #  # ]:          0 :                 if (err < 0) {
    1463                 :          0 :                         TAP_LOG(ERR,
    1464                 :            :                                 "Kernel refused TC filter rule creation (%d): %s",
    1465                 :            :                                 errno, strerror(errno));
    1466                 :          0 :                         rte_flow_error_set(
    1467                 :            :                                 error, ENOMEM, RTE_FLOW_ERROR_TYPE_HANDLE,
    1468                 :            :                                 NULL,
    1469                 :            :                                 "overlapping rules or Kernel too old for flower support");
    1470                 :          0 :                         goto fail;
    1471                 :            :                 }
    1472                 :          0 :                 flow->remote_flow = remote_flow;
    1473                 :            :         }
    1474                 :            :         return flow;
    1475                 :          0 : fail:
    1476                 :          0 :         rte_free(remote_flow);
    1477         [ #  # ]:          0 :         if (flow)
    1478                 :          0 :                 tap_flow_free(pmd, flow);
    1479                 :            :         return NULL;
    1480                 :            : }
    1481                 :            : 
    1482                 :            : /**
    1483                 :            :  * Destroy a flow using pointer to pmd_internal.
    1484                 :            :  *
    1485                 :            :  * @param[in, out] pmd
    1486                 :            :  *   Pointer to private structure.
    1487                 :            :  * @param[in] flow
    1488                 :            :  *   Pointer to the flow to destroy.
    1489                 :            :  * @param[in, out] error
    1490                 :            :  *   Pointer to the flow error handler
    1491                 :            :  *
    1492                 :            :  * @return 0 if the flow could be destroyed, -1 otherwise.
    1493                 :            :  */
    1494                 :            : static int
    1495                 :          0 : tap_flow_destroy_pmd(struct pmd_internals *pmd,
    1496                 :            :                      struct rte_flow *flow,
    1497                 :            :                      struct rte_flow_error *error)
    1498                 :            : {
    1499                 :          0 :         struct rte_flow *remote_flow = flow->remote_flow;
    1500                 :            :         int ret = 0;
    1501                 :            : 
    1502         [ #  # ]:          0 :         LIST_REMOVE(flow, next);
    1503                 :          0 :         flow->msg.nh.nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK;
    1504                 :          0 :         flow->msg.nh.nlmsg_type = RTM_DELTFILTER;
    1505                 :            : 
    1506                 :          0 :         ret = tap_nl_send(pmd->nlsk_fd, &flow->msg.nh);
    1507         [ #  # ]:          0 :         if (ret < 0) {
    1508                 :          0 :                 rte_flow_error_set(error, ENOTSUP, RTE_FLOW_ERROR_TYPE_HANDLE,
    1509                 :            :                                    NULL, "couldn't send request to kernel");
    1510                 :          0 :                 goto end;
    1511                 :            :         }
    1512                 :          0 :         ret = tap_nl_recv_ack(pmd->nlsk_fd);
    1513                 :            :         /* If errno is ENOENT, the rule is already no longer in the kernel. */
    1514   [ #  #  #  # ]:          0 :         if (ret < 0 && errno == ENOENT)
    1515                 :            :                 ret = 0;
    1516         [ #  # ]:          0 :         if (ret < 0) {
    1517                 :          0 :                 TAP_LOG(ERR,
    1518                 :            :                         "Kernel refused TC filter rule deletion (%d): %s",
    1519                 :            :                         errno, strerror(errno));
    1520                 :          0 :                 rte_flow_error_set(
    1521                 :            :                         error, ENOTSUP, RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
    1522                 :            :                         "couldn't receive kernel ack to our request");
    1523                 :          0 :                 goto end;
    1524                 :            :         }
    1525                 :            : 
    1526         [ #  # ]:          0 :         if (remote_flow) {
    1527                 :          0 :                 remote_flow->msg.nh.nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK;
    1528                 :          0 :                 remote_flow->msg.nh.nlmsg_type = RTM_DELTFILTER;
    1529                 :            : 
    1530                 :          0 :                 ret = tap_nl_send(pmd->nlsk_fd, &remote_flow->msg.nh);
    1531         [ #  # ]:          0 :                 if (ret < 0) {
    1532                 :          0 :                         rte_flow_error_set(
    1533                 :            :                                 error, ENOMEM, RTE_FLOW_ERROR_TYPE_HANDLE,
    1534                 :            :                                 NULL, "Failure sending nl request");
    1535                 :          0 :                         goto end;
    1536                 :            :                 }
    1537                 :          0 :                 ret = tap_nl_recv_ack(pmd->nlsk_fd);
    1538   [ #  #  #  # ]:          0 :                 if (ret < 0 && errno == ENOENT)
    1539                 :            :                         ret = 0;
    1540         [ #  # ]:          0 :                 if (ret < 0) {
    1541                 :          0 :                         TAP_LOG(ERR,
    1542                 :            :                                 "Kernel refused TC filter rule deletion (%d): %s",
    1543                 :            :                                 errno, strerror(errno));
    1544                 :          0 :                         rte_flow_error_set(
    1545                 :            :                                 error, ENOMEM, RTE_FLOW_ERROR_TYPE_HANDLE,
    1546                 :            :                                 NULL, "Failure trying to receive nl ack");
    1547                 :          0 :                         goto end;
    1548                 :            :                 }
    1549                 :            :         }
    1550                 :          0 : end:
    1551                 :          0 :         rte_free(remote_flow);
    1552                 :          0 :         tap_flow_free(pmd, flow);
    1553                 :          0 :         return ret;
    1554                 :            : }
    1555                 :            : 
    1556                 :            : /**
    1557                 :            :  * Destroy a flow.
    1558                 :            :  *
    1559                 :            :  * @see rte_flow_destroy()
    1560                 :            :  * @see rte_flow_ops
    1561                 :            :  */
    1562                 :            : static int
    1563                 :          0 : tap_flow_destroy(struct rte_eth_dev *dev,
    1564                 :            :                  struct rte_flow *flow,
    1565                 :            :                  struct rte_flow_error *error)
    1566                 :            : {
    1567                 :          0 :         struct pmd_internals *pmd = dev->data->dev_private;
    1568                 :            : 
    1569                 :          0 :         return tap_flow_destroy_pmd(pmd, flow, error);
    1570                 :            : }
    1571                 :            : 
    1572                 :            : /**
    1573                 :            :  * Enable/disable flow isolation.
    1574                 :            :  *
    1575                 :            :  * @see rte_flow_isolate()
    1576                 :            :  * @see rte_flow_ops
    1577                 :            :  */
    1578                 :            : static int
    1579                 :          0 : tap_flow_isolate(struct rte_eth_dev *dev,
    1580                 :            :                  int set,
    1581                 :            :                  struct rte_flow_error *error __rte_unused)
    1582                 :            : {
    1583                 :          0 :         struct pmd_internals *pmd = dev->data->dev_private;
    1584                 :          0 :         struct pmd_process_private *process_private = dev->process_private;
    1585                 :            : 
    1586                 :            :         /* normalize 'set' variable to contain 0 or 1 values */
    1587         [ #  # ]:          0 :         if (set)
    1588                 :            :                 set = 1;
    1589                 :            :         /* if already in the right isolation mode - nothing to do */
    1590         [ #  # ]:          0 :         if ((set ^ pmd->flow_isolate) == 0)
    1591                 :            :                 return 0;
    1592                 :            :         /* mark the isolation mode for tap_flow_implicit_create() */
    1593                 :          0 :         pmd->flow_isolate = set;
    1594                 :            :         /*
    1595                 :            :          * If netdevice is there, setup appropriate flow rules immediately.
    1596                 :            :          * Otherwise it will be set when bringing up the netdevice (tun_alloc).
    1597                 :            :          */
    1598         [ #  # ]:          0 :         if (!process_private->rxq_fds[0])
    1599                 :            :                 return 0;
    1600         [ #  # ]:          0 :         if (set) {
    1601                 :            :                 struct rte_flow *remote_flow;
    1602                 :            : 
    1603                 :            :                 while (1) {
    1604                 :          0 :                         remote_flow = LIST_FIRST(&pmd->implicit_flows);
    1605         [ #  # ]:          0 :                         if (!remote_flow)
    1606                 :            :                                 break;
    1607                 :            :                         /*
    1608                 :            :                          * Remove all implicit rules on the remote.
    1609                 :            :                          * Keep the local rule to redirect packets on TX.
    1610                 :            :                          * Keep also the last implicit local rule: ISOLATE.
    1611                 :            :                          */
    1612         [ #  # ]:          0 :                         if (remote_flow->msg.t.tcm_ifindex == pmd->if_index)
    1613                 :            :                                 break;
    1614         [ #  # ]:          0 :                         if (tap_flow_destroy_pmd(pmd, remote_flow, NULL) < 0)
    1615                 :          0 :                                 goto error;
    1616                 :            :                 }
    1617                 :            :                 /* Switch the TC rule according to pmd->flow_isolate */
    1618         [ #  # ]:          0 :                 if (tap_flow_implicit_create(pmd, TAP_ISOLATE) == -1)
    1619                 :          0 :                         goto error;
    1620                 :            :         } else {
    1621                 :            :                 /* Switch the TC rule according to pmd->flow_isolate */
    1622         [ #  # ]:          0 :                 if (tap_flow_implicit_create(pmd, TAP_ISOLATE) == -1)
    1623                 :          0 :                         goto error;
    1624         [ #  # ]:          0 :                 if (!pmd->remote_if_index)
    1625                 :            :                         return 0;
    1626         [ #  # ]:          0 :                 if (tap_flow_implicit_create(pmd, TAP_REMOTE_TX) < 0)
    1627                 :          0 :                         goto error;
    1628         [ #  # ]:          0 :                 if (tap_flow_implicit_create(pmd, TAP_REMOTE_LOCAL_MAC) < 0)
    1629                 :          0 :                         goto error;
    1630         [ #  # ]:          0 :                 if (tap_flow_implicit_create(pmd, TAP_REMOTE_BROADCAST) < 0)
    1631                 :          0 :                         goto error;
    1632         [ #  # ]:          0 :                 if (tap_flow_implicit_create(pmd, TAP_REMOTE_BROADCASTV6) < 0)
    1633                 :          0 :                         goto error;
    1634   [ #  #  #  # ]:          0 :                 if (dev->data->promiscuous &&
    1635                 :          0 :                     tap_flow_implicit_create(pmd, TAP_REMOTE_PROMISC) < 0)
    1636                 :          0 :                         goto error;
    1637   [ #  #  #  # ]:          0 :                 if (dev->data->all_multicast &&
    1638                 :          0 :                     tap_flow_implicit_create(pmd, TAP_REMOTE_ALLMULTI) < 0)
    1639                 :          0 :                         goto error;
    1640                 :            :         }
    1641                 :            :         return 0;
    1642                 :          0 : error:
    1643                 :          0 :         pmd->flow_isolate = 0;
    1644                 :          0 :         return rte_flow_error_set(
    1645                 :            :                 error, ENOTSUP, RTE_FLOW_ERROR_TYPE_UNSPECIFIED, NULL,
    1646                 :            :                 "TC rule creation failed");
    1647                 :            : }
    1648                 :            : 
    1649                 :            : /**
    1650                 :            :  * Destroy all flows.
    1651                 :            :  *
    1652                 :            :  * @see rte_flow_flush()
    1653                 :            :  * @see rte_flow_ops
    1654                 :            :  */
    1655                 :            : int
    1656                 :          0 : tap_flow_flush(struct rte_eth_dev *dev, struct rte_flow_error *error)
    1657                 :            : {
    1658                 :          0 :         struct pmd_internals *pmd = dev->data->dev_private;
    1659                 :            :         struct rte_flow *flow;
    1660                 :            : 
    1661         [ #  # ]:          0 :         while (!LIST_EMPTY(&pmd->flows)) {
    1662                 :            :                 flow = LIST_FIRST(&pmd->flows);
    1663         [ #  # ]:          0 :                 if (tap_flow_destroy(dev, flow, error) < 0)
    1664                 :            :                         return -1;
    1665                 :            :         }
    1666                 :            :         return 0;
    1667                 :            : }
    1668                 :            : 
    1669                 :            : /**
    1670                 :            :  * Add an implicit flow rule on the remote device to make sure traffic gets to
    1671                 :            :  * the tap netdevice from there.
    1672                 :            :  *
    1673                 :            :  * @param pmd
    1674                 :            :  *   Pointer to private structure.
    1675                 :            :  * @param[in] idx
    1676                 :            :  *   The idx in the implicit_rte_flows array specifying which rule to apply.
    1677                 :            :  *
    1678                 :            :  * @return -1 if the rule couldn't be applied, 0 otherwise.
    1679                 :            :  */
    1680                 :          0 : int tap_flow_implicit_create(struct pmd_internals *pmd,
    1681                 :            :                              enum implicit_rule_index idx)
    1682                 :            : {
    1683                 :            :         uint16_t flags = NLM_F_REQUEST | NLM_F_ACK | NLM_F_EXCL | NLM_F_CREATE;
    1684                 :          0 :         struct rte_flow_action *actions = implicit_rte_flows[idx].actions;
    1685                 :          0 :         struct rte_flow_action isolate_actions[2] = {
    1686                 :            :                 [1] = {
    1687                 :            :                         .type = RTE_FLOW_ACTION_TYPE_END,
    1688                 :            :                 },
    1689                 :            :         };
    1690                 :          0 :         struct rte_flow_item *items = implicit_rte_flows[idx].items;
    1691                 :          0 :         struct rte_flow_attr *attr = &implicit_rte_flows[idx].attr;
    1692                 :          0 :         struct rte_flow_item_eth eth_local = { .hdr.ether_type = 0 };
    1693                 :          0 :         unsigned int if_index = pmd->remote_if_index;
    1694                 :            :         struct rte_flow *remote_flow = NULL;
    1695                 :            :         struct nlmsg *msg = NULL;
    1696                 :            :         int err = 0;
    1697                 :          0 :         struct rte_flow_item items_local[2] = {
    1698                 :            :                 [0] = {
    1699                 :          0 :                         .type = items[0].type,
    1700                 :            :                         .spec = &eth_local,
    1701                 :          0 :                         .mask = items[0].mask,
    1702                 :            :                 },
    1703                 :            :                 [1] = {
    1704                 :          0 :                         .type = items[1].type,
    1705                 :            :                 }
    1706                 :            :         };
    1707                 :            : 
    1708                 :          0 :         remote_flow = rte_zmalloc(__func__, sizeof(struct rte_flow), 0);
    1709         [ #  # ]:          0 :         if (!remote_flow) {
    1710                 :          0 :                 TAP_LOG(ERR, "Cannot allocate memory for rte_flow");
    1711                 :          0 :                 goto fail;
    1712                 :            :         }
    1713                 :          0 :         msg = &remote_flow->msg;
    1714         [ #  # ]:          0 :         if (idx == TAP_REMOTE_TX) {
    1715                 :          0 :                 if_index = pmd->if_index;
    1716         [ #  # ]:          0 :         } else if (idx == TAP_ISOLATE) {
    1717                 :          0 :                 if_index = pmd->if_index;
    1718                 :            :                 /* Don't be exclusive for this rule, it can be changed later. */
    1719                 :            :                 flags = NLM_F_REQUEST | NLM_F_ACK | NLM_F_CREATE;
    1720                 :          0 :                 isolate_actions[0].type = pmd->flow_isolate ?
    1721         [ #  # ]:          0 :                         RTE_FLOW_ACTION_TYPE_DROP :
    1722                 :            :                         RTE_FLOW_ACTION_TYPE_PASSTHRU;
    1723                 :            :                 actions = isolate_actions;
    1724         [ #  # ]:          0 :         } else if (idx == TAP_REMOTE_LOCAL_MAC) {
    1725                 :            :                 /*
    1726                 :            :                  * eth addr couldn't be set in implicit_rte_flows[] as it is not
    1727                 :            :                  * known at compile time.
    1728                 :            :                  */
    1729                 :          0 :                 memcpy(&eth_local.hdr.dst_addr, &pmd->eth_addr, sizeof(pmd->eth_addr));
    1730                 :            :                 items = items_local;
    1731                 :            :         }
    1732                 :          0 :         tc_init_msg(msg, if_index, RTM_NEWTFILTER, flags);
    1733                 :          0 :         msg->t.tcm_info = TC_H_MAKE(0, htons(ETH_P_ALL));
    1734                 :            :         /*
    1735                 :            :          * The ISOLATE rule is always present and must have a static handle, as
    1736                 :            :          * the action is changed whether the feature is enabled (DROP) or
    1737                 :            :          * disabled (PASSTHRU).
    1738                 :            :          * There is just one REMOTE_PROMISCUOUS rule in all cases. It should
    1739                 :            :          * have a static handle such that adding it twice will fail with EEXIST
    1740                 :            :          * with any kernel version. Remark: old kernels may falsely accept the
    1741                 :            :          * same REMOTE_PROMISCUOUS rules if they had different handles.
    1742                 :            :          */
    1743         [ #  # ]:          0 :         if (idx == TAP_ISOLATE)
    1744                 :          0 :                 remote_flow->msg.t.tcm_handle = ISOLATE_HANDLE;
    1745         [ #  # ]:          0 :         else if (idx == TAP_REMOTE_PROMISC)
    1746                 :          0 :                 remote_flow->msg.t.tcm_handle = REMOTE_PROMISCUOUS_HANDLE;
    1747                 :            :         else
    1748                 :          0 :                 tap_flow_set_handle(remote_flow);
    1749         [ #  # ]:          0 :         if (priv_flow_process(pmd, attr, items, actions, NULL,
    1750                 :            :                               remote_flow, implicit_rte_flows[idx].mirred)) {
    1751                 :          0 :                 TAP_LOG(ERR, "rte flow rule validation failed");
    1752                 :          0 :                 goto fail;
    1753                 :            :         }
    1754                 :          0 :         err = tap_nl_send(pmd->nlsk_fd, &msg->nh);
    1755         [ #  # ]:          0 :         if (err < 0) {
    1756                 :          0 :                 TAP_LOG(ERR, "Failure sending nl request");
    1757                 :          0 :                 goto fail;
    1758                 :            :         }
    1759                 :          0 :         err = tap_nl_recv_ack(pmd->nlsk_fd);
    1760         [ #  # ]:          0 :         if (err < 0) {
    1761                 :            :                 /* Silently ignore re-entering existing rule */
    1762         [ #  # ]:          0 :                 if (errno == EEXIST)
    1763                 :          0 :                         goto success;
    1764                 :          0 :                 TAP_LOG(ERR,
    1765                 :            :                         "Kernel refused TC filter rule creation (%d): %s",
    1766                 :            :                         errno, strerror(errno));
    1767                 :          0 :                 goto fail;
    1768                 :            :         }
    1769         [ #  # ]:          0 :         LIST_INSERT_HEAD(&pmd->implicit_flows, remote_flow, next);
    1770                 :            : success:
    1771                 :            :         return 0;
    1772                 :          0 : fail:
    1773                 :          0 :         rte_free(remote_flow);
    1774                 :          0 :         return -1;
    1775                 :            : }
    1776                 :            : 
    1777                 :            : /**
    1778                 :            :  * Remove specific implicit flow rule on the remote device.
    1779                 :            :  *
    1780                 :            :  * @param[in, out] pmd
    1781                 :            :  *   Pointer to private structure.
    1782                 :            :  * @param[in] idx
    1783                 :            :  *   The idx in the implicit_rte_flows array specifying which rule to remove.
    1784                 :            :  *
    1785                 :            :  * @return -1 if one of the implicit rules couldn't be created, 0 otherwise.
    1786                 :            :  */
    1787                 :          0 : int tap_flow_implicit_destroy(struct pmd_internals *pmd,
    1788                 :            :                               enum implicit_rule_index idx)
    1789                 :            : {
    1790                 :            :         struct rte_flow *remote_flow;
    1791                 :            :         int cur_prio = -1;
    1792                 :          0 :         int idx_prio = implicit_rte_flows[idx].attr.priority + PRIORITY_OFFSET;
    1793                 :            : 
    1794                 :          0 :         for (remote_flow = LIST_FIRST(&pmd->implicit_flows);
    1795         [ #  # ]:          0 :              remote_flow;
    1796                 :          0 :              remote_flow = LIST_NEXT(remote_flow, next)) {
    1797                 :          0 :                 cur_prio = (remote_flow->msg.t.tcm_info >> 16) & PRIORITY_MASK;
    1798         [ #  # ]:          0 :                 if (cur_prio != idx_prio)
    1799                 :            :                         continue;
    1800                 :          0 :                 return tap_flow_destroy_pmd(pmd, remote_flow, NULL);
    1801                 :            :         }
    1802                 :            :         return 0;
    1803                 :            : }
    1804                 :            : 
    1805                 :            : /**
    1806                 :            :  * Destroy all implicit flows.
    1807                 :            :  *
    1808                 :            :  * @see rte_flow_flush()
    1809                 :            :  */
    1810                 :            : int
    1811                 :          0 : tap_flow_implicit_flush(struct pmd_internals *pmd, struct rte_flow_error *error)
    1812                 :            : {
    1813                 :            :         struct rte_flow *remote_flow;
    1814                 :            : 
    1815         [ #  # ]:          0 :         while (!LIST_EMPTY(&pmd->implicit_flows)) {
    1816                 :            :                 remote_flow = LIST_FIRST(&pmd->implicit_flows);
    1817         [ #  # ]:          0 :                 if (tap_flow_destroy_pmd(pmd, remote_flow, error) < 0)
    1818                 :            :                         return -1;
    1819                 :            :         }
    1820                 :            :         return 0;
    1821                 :            : }
    1822                 :            : 
    1823                 :            : #define MAX_RSS_KEYS 256
    1824                 :            : #define KEY_IDX_OFFSET (3 * MAX_RSS_KEYS)
    1825                 :            : #define SEC_NAME_CLS_Q "cls_q"
    1826                 :            : 
    1827                 :            : static const char *sec_name[SEC_MAX] = {
    1828                 :            :         [SEC_L3_L4] = "l3_l4",
    1829                 :            : };
    1830                 :            : 
    1831                 :            : /**
    1832                 :            :  * Enable RSS on tap: create TC rules for queuing.
    1833                 :            :  *
    1834                 :            :  * @param[in, out] pmd
    1835                 :            :  *   Pointer to private structure.
    1836                 :            :  *
    1837                 :            :  * @param[in] attr
    1838                 :            :  *   Pointer to rte_flow to get flow group
    1839                 :            :  *
    1840                 :            :  * @param[out] error
    1841                 :            :  *   Pointer to error reporting if not NULL.
    1842                 :            :  *
    1843                 :            :  * @return 0 on success, negative value on failure.
    1844                 :            :  */
    1845                 :          0 : static int rss_enable(struct pmd_internals *pmd,
    1846                 :            :                         const struct rte_flow_attr *attr,
    1847                 :            :                         struct rte_flow_error *error)
    1848                 :            : {
    1849                 :            :         struct rte_flow *rss_flow = NULL;
    1850                 :            :         struct nlmsg *msg = NULL;
    1851                 :            :         /* 4096 is the maximum number of instructions for a BPF program */
    1852                 :            :         char annotation[64];
    1853                 :            :         int i;
    1854                 :            :         int err = 0;
    1855                 :            : 
    1856                 :            :         /* unlimit locked memory */
    1857                 :          0 :         struct rlimit memlock_limit = {
    1858                 :            :                 .rlim_cur = RLIM_INFINITY,
    1859                 :            :                 .rlim_max = RLIM_INFINITY,
    1860                 :            :         };
    1861                 :          0 :         setrlimit(RLIMIT_MEMLOCK, &memlock_limit);
    1862                 :            : 
    1863                 :            :          /* Get a new map key for a new RSS rule */
    1864                 :            :         err = bpf_rss_key(KEY_CMD_INIT, NULL);
    1865                 :            :         if (err < 0) {
    1866                 :            :                 rte_flow_error_set(
    1867                 :            :                         error, EINVAL, RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
    1868                 :            :                         "Failed to initialize BPF RSS keys");
    1869                 :            : 
    1870                 :            :                 return -1;
    1871                 :            :         }
    1872                 :            : 
    1873                 :            :         /*
    1874                 :            :          *  Create BPF RSS MAP
    1875                 :            :          */
    1876                 :          0 :         pmd->map_fd = tap_flow_bpf_rss_map_create(sizeof(__u32), /* key size */
    1877                 :            :                                 sizeof(struct rss_key),
    1878                 :            :                                 MAX_RSS_KEYS);
    1879         [ #  # ]:          0 :         if (pmd->map_fd < 0) {
    1880                 :          0 :                 TAP_LOG(ERR,
    1881                 :            :                         "Failed to create BPF map (%d): %s",
    1882                 :            :                                 errno, strerror(errno));
    1883                 :          0 :                 rte_flow_error_set(
    1884                 :            :                         error, ENOTSUP, RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
    1885                 :            :                         "Kernel too old or not configured "
    1886                 :            :                         "to support BPF maps");
    1887                 :            : 
    1888                 :          0 :                 return -ENOTSUP;
    1889                 :            :         }
    1890                 :            : 
    1891                 :            :         /*
    1892                 :            :          * Add a rule per queue to match reclassified packets and direct them to
    1893                 :            :          * the correct queue.
    1894                 :            :          */
    1895         [ #  # ]:          0 :         for (i = 0; i < pmd->dev->data->nb_rx_queues; i++) {
    1896                 :          0 :                 pmd->bpf_fd[i] = tap_flow_bpf_cls_q(i);
    1897         [ #  # ]:          0 :                 if (pmd->bpf_fd[i] < 0) {
    1898                 :          0 :                         TAP_LOG(ERR,
    1899                 :            :                                 "Failed to load BPF section %s for queue %d",
    1900                 :            :                                 SEC_NAME_CLS_Q, i);
    1901                 :          0 :                         rte_flow_error_set(
    1902                 :            :                                 error, ENOTSUP, RTE_FLOW_ERROR_TYPE_HANDLE,
    1903                 :            :                                 NULL,
    1904                 :            :                                 "Kernel too old or not configured "
    1905                 :            :                                 "to support BPF programs loading");
    1906                 :            : 
    1907                 :          0 :                         return -ENOTSUP;
    1908                 :            :                 }
    1909                 :            : 
    1910                 :          0 :                 rss_flow = rte_zmalloc(__func__, sizeof(struct rte_flow), 0);
    1911         [ #  # ]:          0 :                 if (!rss_flow) {
    1912                 :          0 :                         TAP_LOG(ERR,
    1913                 :            :                                 "Cannot allocate memory for rte_flow");
    1914                 :          0 :                         return -1;
    1915                 :            :                 }
    1916                 :          0 :                 msg = &rss_flow->msg;
    1917                 :          0 :                 tc_init_msg(msg, pmd->if_index, RTM_NEWTFILTER, NLM_F_REQUEST |
    1918                 :            :                             NLM_F_ACK | NLM_F_EXCL | NLM_F_CREATE);
    1919                 :          0 :                 msg->t.tcm_info = TC_H_MAKE(0, htons(ETH_P_ALL));
    1920                 :          0 :                 tap_flow_set_handle(rss_flow);
    1921                 :          0 :                 uint16_t group = attr->group << GROUP_SHIFT;
    1922                 :          0 :                 uint16_t prio = group | (i + PRIORITY_OFFSET);
    1923                 :          0 :                 msg->t.tcm_info = TC_H_MAKE(prio << 16, msg->t.tcm_info);
    1924                 :          0 :                 msg->t.tcm_parent = TC_H_MAKE(MULTIQ_MAJOR_HANDLE, 0);
    1925                 :            : 
    1926                 :          0 :                 tap_nlattr_add(&msg->nh, TCA_KIND, sizeof("bpf"), "bpf");
    1927         [ #  # ]:          0 :                 if (tap_nlattr_nested_start(msg, TCA_OPTIONS) < 0)
    1928                 :            :                         return -1;
    1929                 :          0 :                 tap_nlattr_add32(&msg->nh, TCA_BPF_FD, pmd->bpf_fd[i]);
    1930                 :            :                 snprintf(annotation, sizeof(annotation), "[%s%d]",
    1931                 :            :                         SEC_NAME_CLS_Q, i);
    1932                 :          0 :                 tap_nlattr_add(&msg->nh, TCA_BPF_NAME, strlen(annotation) + 1,
    1933                 :            :                            annotation);
    1934                 :            :                 /* Actions */
    1935                 :            :                 {
    1936                 :          0 :                         struct action_data adata = {
    1937                 :            :                                 .id = "skbedit",
    1938                 :            :                                 .skbedit = {
    1939                 :            :                                         .skbedit = {
    1940                 :            :                                                 .action = TC_ACT_PIPE,
    1941                 :            :                                         },
    1942                 :            :                                         .queue = i,
    1943                 :            :                                 },
    1944                 :            :                         };
    1945         [ #  # ]:          0 :                         if (add_actions(rss_flow, 1, &adata, TCA_BPF_ACT) < 0)
    1946                 :          0 :                                 return -1;
    1947                 :            :                 }
    1948                 :          0 :                 tap_nlattr_nested_finish(msg); /* nested TCA_OPTIONS */
    1949                 :            : 
    1950                 :            :                 /* Netlink message is now ready to be sent */
    1951         [ #  # ]:          0 :                 if (tap_nl_send(pmd->nlsk_fd, &msg->nh) < 0)
    1952                 :            :                         return -1;
    1953                 :          0 :                 err = tap_nl_recv_ack(pmd->nlsk_fd);
    1954         [ #  # ]:          0 :                 if (err < 0) {
    1955                 :          0 :                         TAP_LOG(ERR,
    1956                 :            :                                 "Kernel refused TC filter rule creation (%d): %s",
    1957                 :            :                                 errno, strerror(errno));
    1958                 :          0 :                         return err;
    1959                 :            :                 }
    1960         [ #  # ]:          0 :                 LIST_INSERT_HEAD(&pmd->rss_flows, rss_flow, next);
    1961                 :            :         }
    1962                 :            : 
    1963                 :          0 :         pmd->rss_enabled = 1;
    1964                 :          0 :         return err;
    1965                 :            : }
    1966                 :            : 
    1967                 :            : /**
    1968                 :            :  * Manage bpf RSS keys repository with operations: init, get, release
    1969                 :            :  *
    1970                 :            :  * @param[in] cmd
    1971                 :            :  *   Command on RSS keys: init, get, release
    1972                 :            :  *
    1973                 :            :  * @param[in, out] key_idx
    1974                 :            :  *   Pointer to RSS Key index (out for get command, in for release command)
    1975                 :            :  *
    1976                 :            :  * @return -1 if couldn't get, release or init the RSS keys, 0 otherwise.
    1977                 :            :  */
    1978                 :          0 : static int bpf_rss_key(enum bpf_rss_key_e cmd, __u32 *key_idx)
    1979                 :            : {
    1980                 :            :         __u32 i;
    1981                 :            :         int err = 0;
    1982                 :            :         static __u32 num_used_keys;
    1983                 :            :         static __u32 rss_keys[MAX_RSS_KEYS] = {KEY_STAT_UNSPEC};
    1984                 :            :         static __u32 rss_keys_initialized;
    1985                 :            :         __u32 key;
    1986                 :            : 
    1987   [ #  #  #  #  :          0 :         switch (cmd) {
                      # ]
    1988                 :          0 :         case KEY_CMD_GET:
    1989         [ #  # ]:          0 :                 if (!rss_keys_initialized) {
    1990                 :            :                         err = -1;
    1991                 :            :                         break;
    1992                 :            :                 }
    1993                 :            : 
    1994         [ #  # ]:          0 :                 if (num_used_keys == RTE_DIM(rss_keys)) {
    1995                 :            :                         err = -1;
    1996                 :            :                         break;
    1997                 :            :                 }
    1998                 :            : 
    1999                 :          0 :                 *key_idx = num_used_keys % RTE_DIM(rss_keys);
    2000         [ #  # ]:          0 :                 while (rss_keys[*key_idx] == KEY_STAT_USED)
    2001                 :          0 :                         *key_idx = (*key_idx + 1) % RTE_DIM(rss_keys);
    2002                 :            : 
    2003                 :          0 :                 rss_keys[*key_idx] = KEY_STAT_USED;
    2004                 :            : 
    2005                 :            :                 /*
    2006                 :            :                  * Add an offset to key_idx in order to handle a case of
    2007                 :            :                  * RSS and non RSS flows mixture.
    2008                 :            :                  * If a non RSS flow is destroyed it has an eBPF map
    2009                 :            :                  * index 0 (initialized on flow creation) and might
    2010                 :            :                  * unintentionally remove RSS entry 0 from eBPF map.
    2011                 :            :                  * To avoid this issue, add an offset to the real index
    2012                 :            :                  * during a KEY_CMD_GET operation and subtract this offset
    2013                 :            :                  * during a KEY_CMD_RELEASE operation in order to restore
    2014                 :            :                  * the real index.
    2015                 :            :                  */
    2016                 :          0 :                 *key_idx += KEY_IDX_OFFSET;
    2017                 :          0 :                 num_used_keys++;
    2018                 :          0 :         break;
    2019                 :            : 
    2020                 :          0 :         case KEY_CMD_RELEASE:
    2021   [ #  #  #  # ]:          0 :                 if (!rss_keys_initialized)
    2022                 :            :                         break;
    2023                 :            : 
    2024                 :            :                 /*
    2025                 :            :                  * Subtract offset to restore real key index
    2026                 :            :                  * If a non RSS flow is falsely trying to release map
    2027                 :            :                  * entry 0 - the offset subtraction will calculate the real
    2028                 :            :                  * map index as an out-of-range value and the release operation
    2029                 :            :                  * will be silently ignored.
    2030                 :            :                  */
    2031                 :          0 :                 key = *key_idx - KEY_IDX_OFFSET;
    2032   [ #  #  #  # ]:          0 :                 if (key >= RTE_DIM(rss_keys))
    2033                 :            :                         break;
    2034                 :            : 
    2035   [ #  #  #  # ]:          0 :                 if (rss_keys[key] == KEY_STAT_USED) {
    2036                 :          0 :                         rss_keys[key] = KEY_STAT_AVAILABLE;
    2037                 :          0 :                         num_used_keys--;
    2038                 :            :                 }
    2039                 :            :         break;
    2040                 :            : 
    2041                 :            :         case KEY_CMD_INIT:
    2042   [ #  #  #  # ]:          0 :                 for (i = 0; i < RTE_DIM(rss_keys); i++)
    2043                 :          0 :                         rss_keys[i] = KEY_STAT_AVAILABLE;
    2044                 :            : 
    2045                 :          0 :                 rss_keys_initialized = 1;
    2046                 :          0 :                 num_used_keys = 0;
    2047                 :          0 :         break;
    2048                 :            : 
    2049                 :            :         case KEY_CMD_DEINIT:
    2050         [ #  # ]:          0 :                 for (i = 0; i < RTE_DIM(rss_keys); i++)
    2051                 :          0 :                         rss_keys[i] = KEY_STAT_UNSPEC;
    2052                 :            : 
    2053                 :          0 :                 rss_keys_initialized = 0;
    2054                 :          0 :                 num_used_keys = 0;
    2055                 :          0 :         break;
    2056                 :            : 
    2057                 :            :         default:
    2058                 :            :                 break;
    2059                 :            :         }
    2060                 :            : 
    2061                 :          0 :         return err;
    2062                 :            : }
    2063                 :            : 
    2064                 :            : /**
    2065                 :            :  * Add RSS hash calculations and queue selection
    2066                 :            :  *
    2067                 :            :  * @param[in, out] pmd
    2068                 :            :  *   Pointer to internal structure. Used to set/get RSS map fd
    2069                 :            :  *
    2070                 :            :  * @param[in] rss
    2071                 :            :  *   Pointer to RSS flow actions
    2072                 :            :  *
    2073                 :            :  * @param[out] error
    2074                 :            :  *   Pointer to error reporting if not NULL.
    2075                 :            :  *
    2076                 :            :  * @return 0 on success, negative value on failure
    2077                 :            :  */
    2078                 :          0 : static int rss_add_actions(struct rte_flow *flow, struct pmd_internals *pmd,
    2079                 :            :                            const struct rte_flow_action_rss *rss,
    2080                 :            :                            struct rte_flow_error *error)
    2081                 :            : {
    2082                 :            :         /* 4096 is the maximum number of instructions for a BPF program */
    2083                 :            :         unsigned int i;
    2084                 :            :         int err;
    2085                 :          0 :         struct rss_key rss_entry = { .hash_fields = 0,
    2086                 :            :                                      .key_size = 0 };
    2087                 :            : 
    2088                 :            :         /* Check supported RSS features */
    2089         [ #  # ]:          0 :         if (rss->func != RTE_ETH_HASH_FUNCTION_DEFAULT)
    2090                 :          0 :                 return rte_flow_error_set
    2091                 :            :                         (error, ENOTSUP, RTE_FLOW_ERROR_TYPE_UNSPECIFIED, NULL,
    2092                 :            :                          "non-default RSS hash functions are not supported");
    2093         [ #  # ]:          0 :         if (rss->level)
    2094                 :          0 :                 return rte_flow_error_set
    2095                 :            :                         (error, ENOTSUP, RTE_FLOW_ERROR_TYPE_UNSPECIFIED, NULL,
    2096                 :            :                          "a nonzero RSS encapsulation level is not supported");
    2097                 :            : 
    2098                 :            :         /* Get a new map key for a new RSS rule */
    2099                 :          0 :         err = bpf_rss_key(KEY_CMD_GET, &flow->key_idx);
    2100         [ #  # ]:          0 :         if (err < 0) {
    2101                 :          0 :                 rte_flow_error_set(
    2102                 :            :                         error, EINVAL, RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
    2103                 :            :                         "Failed to get BPF RSS key");
    2104                 :            : 
    2105                 :          0 :                 return -1;
    2106                 :            :         }
    2107                 :            : 
    2108                 :            :         /* Update RSS map entry with queues */
    2109                 :          0 :         rss_entry.nb_queues = rss->queue_num;
    2110         [ #  # ]:          0 :         for (i = 0; i < rss->queue_num; i++)
    2111                 :          0 :                 rss_entry.queues[i] = rss->queue[i];
    2112                 :          0 :         rss_entry.hash_fields =
    2113                 :            :                 (1 << HASH_FIELD_IPV4_L3_L4) | (1 << HASH_FIELD_IPV6_L3_L4);
    2114                 :            : 
    2115                 :            :         /* Add this RSS entry to map */
    2116                 :          0 :         err = tap_flow_bpf_update_rss_elem(pmd->map_fd,
    2117                 :            :                                 &flow->key_idx, &rss_entry);
    2118                 :            : 
    2119         [ #  # ]:          0 :         if (err) {
    2120                 :          0 :                 TAP_LOG(ERR,
    2121                 :            :                         "Failed to update BPF map entry #%u (%d): %s",
    2122                 :            :                         flow->key_idx, errno, strerror(errno));
    2123                 :          0 :                 rte_flow_error_set(
    2124                 :            :                         error, ENOTSUP, RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
    2125                 :            :                         "Kernel too old or not configured "
    2126                 :            :                         "to support BPF maps updates");
    2127                 :            : 
    2128                 :          0 :                 return -ENOTSUP;
    2129                 :            :         }
    2130                 :            : 
    2131                 :            : 
    2132                 :            :         /*
    2133                 :            :          * Load bpf rules to calculate hash for this key_idx
    2134                 :            :          */
    2135                 :            : 
    2136                 :          0 :         flow->bpf_fd[SEC_L3_L4] =
    2137                 :          0 :                 tap_flow_bpf_calc_l3_l4_hash(flow->key_idx, pmd->map_fd);
    2138         [ #  # ]:          0 :         if (flow->bpf_fd[SEC_L3_L4] < 0) {
    2139                 :          0 :                 TAP_LOG(ERR,
    2140                 :            :                         "Failed to load BPF section %s (%d): %s",
    2141                 :            :                                 sec_name[SEC_L3_L4], errno, strerror(errno));
    2142                 :          0 :                 rte_flow_error_set(
    2143                 :            :                         error, ENOTSUP, RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
    2144                 :            :                         "Kernel too old or not configured "
    2145                 :            :                         "to support BPF program loading");
    2146                 :            : 
    2147                 :          0 :                 return -ENOTSUP;
    2148                 :            :         }
    2149                 :            : 
    2150                 :            :         /* Actions */
    2151                 :            :         {
    2152                 :          0 :                 struct action_data adata[] = {
    2153                 :            :                         {
    2154                 :            :                                 .id = "bpf",
    2155                 :            :                                 .bpf = {
    2156                 :            :                                         .bpf_fd = flow->bpf_fd[SEC_L3_L4],
    2157                 :          0 :                                         .annotation = sec_name[SEC_L3_L4],
    2158                 :            :                                         .bpf = {
    2159                 :            :                                                 .action = TC_ACT_PIPE,
    2160                 :            :                                         },
    2161                 :            :                                 },
    2162                 :            :                         },
    2163                 :            :                 };
    2164                 :            : 
    2165         [ #  # ]:          0 :                 if (add_actions(flow, RTE_DIM(adata), adata,
    2166                 :            :                         TCA_FLOWER_ACT) < 0)
    2167                 :          0 :                         return -1;
    2168                 :            :         }
    2169                 :            : 
    2170                 :          0 :         return 0;
    2171                 :            : }
    2172                 :            : 
    2173                 :            : /**
    2174                 :            :  * Get rte_flow operations.
    2175                 :            :  *
    2176                 :            :  * @param dev
    2177                 :            :  *   Pointer to Ethernet device structure.
    2178                 :            :  * @param ops
    2179                 :            :  *   Pointer to operation-specific structure.
    2180                 :            :  *
    2181                 :            :  * @return
    2182                 :            :  *   0 on success, negative errno value on failure.
    2183                 :            :  */
    2184                 :            : int
    2185                 :          0 : tap_dev_flow_ops_get(struct rte_eth_dev *dev __rte_unused,
    2186                 :            :                      const struct rte_flow_ops **ops)
    2187                 :            : {
    2188                 :          0 :         *ops = &tap_flow_ops;
    2189                 :          0 :         return 0;
    2190                 :            : }

Generated by: LCOV version 1.14