drivers/net/iavf/iavf_fdir.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2020 Intel Corporation
   3  */
   4
   5 #include <sys/queue.h>
   6 #include <stdio.h>
   7 #include <errno.h>
   8 #include <stdint.h>
   9 #include <string.h>
  10 #include <unistd.h>
  11 #include <stdarg.h>
  12
  13 #include <rte_ether.h>
  14 #include <ethdev_driver.h>
  15 #include <rte_malloc.h>
  16 #include <rte_tailq.h>
  17
  18 #include "iavf.h"
  19 #include "iavf_generic_flow.h"
  20 #include "virtchnl.h"
  21 #include "iavf_rxtx.h"
  22
  23 #define IAVF_FDIR_MAX_QREGION_SIZE 128
  24
  25 #define IAVF_FDIR_IPV6_TC_OFFSET 20
  26 #define IAVF_IPV6_TC_MASK  (0xFF << IAVF_FDIR_IPV6_TC_OFFSET)
  27
  28 #define IAVF_GTPU_EH_DWLINK 0
  29 #define IAVF_GTPU_EH_UPLINK 1
  30
  31 #define IAVF_FDIR_INSET_ETH (\
  32         IAVF_INSET_ETHERTYPE)
  33
  34 #define IAVF_FDIR_INSET_ETH_IPV4 (\
  35         IAVF_INSET_IPV4_SRC | IAVF_INSET_IPV4_DST | \
  36         IAVF_INSET_IPV4_PROTO | IAVF_INSET_IPV4_TOS | \
  37         IAVF_INSET_IPV4_TTL)
  38
  39 #define IAVF_FDIR_INSET_ETH_IPV4_UDP (\
  40         IAVF_INSET_IPV4_SRC | IAVF_INSET_IPV4_DST | \
  41         IAVF_INSET_IPV4_TOS | IAVF_INSET_IPV4_TTL | \
  42         IAVF_INSET_UDP_SRC_PORT | IAVF_INSET_UDP_DST_PORT)
  43
  44 #define IAVF_FDIR_INSET_ETH_IPV4_TCP (\
  45         IAVF_INSET_IPV4_SRC | IAVF_INSET_IPV4_DST | \
  46         IAVF_INSET_IPV4_TOS | IAVF_INSET_IPV4_TTL | \
  47         IAVF_INSET_TCP_SRC_PORT | IAVF_INSET_TCP_DST_PORT)
  48
  49 #define IAVF_FDIR_INSET_ETH_IPV4_SCTP (\
  50         IAVF_INSET_IPV4_SRC | IAVF_INSET_IPV4_DST | \
  51         IAVF_INSET_IPV4_TOS | IAVF_INSET_IPV4_TTL | \
  52         IAVF_INSET_SCTP_SRC_PORT | IAVF_INSET_SCTP_DST_PORT)
  53
  54 #define IAVF_FDIR_INSET_ETH_IPV6 (\
  55         IAVF_INSET_IPV6_SRC | IAVF_INSET_IPV6_DST | \
  56         IAVF_INSET_IPV6_NEXT_HDR | IAVF_INSET_IPV6_TC | \
  57         IAVF_INSET_IPV6_HOP_LIMIT)
  58
  59 #define IAVF_FDIR_INSET_ETH_IPV6_UDP (\
  60         IAVF_INSET_IPV6_SRC | IAVF_INSET_IPV6_DST | \
  61         IAVF_INSET_IPV6_TC | IAVF_INSET_IPV6_HOP_LIMIT | \
  62         IAVF_INSET_UDP_SRC_PORT | IAVF_INSET_UDP_DST_PORT)
  63
  64 #define IAVF_FDIR_INSET_ETH_IPV6_TCP (\
  65         IAVF_INSET_IPV6_SRC | IAVF_INSET_IPV6_DST | \
  66         IAVF_INSET_IPV6_TC | IAVF_INSET_IPV6_HOP_LIMIT | \
  67         IAVF_INSET_TCP_SRC_PORT | IAVF_INSET_TCP_DST_PORT)
  68
  69 #define IAVF_FDIR_INSET_ETH_IPV6_SCTP (\
  70         IAVF_INSET_IPV6_SRC | IAVF_INSET_IPV6_DST | \
  71         IAVF_INSET_IPV6_TC | IAVF_INSET_IPV6_HOP_LIMIT | \
  72         IAVF_INSET_SCTP_SRC_PORT | IAVF_INSET_SCTP_DST_PORT)
  73
  74 #define IAVF_FDIR_INSET_IPV4_GTPU (\
  75         IAVF_INSET_IPV4_SRC | IAVF_INSET_IPV4_DST | \
  76         IAVF_INSET_GTPU_TEID)
  77
  78 #define IAVF_FDIR_INSET_GTPU_IPV4 (\
  79         IAVF_INSET_TUN_IPV4_SRC | IAVF_INSET_TUN_IPV4_DST | \
  80         IAVF_INSET_TUN_IPV4_PROTO | IAVF_INSET_TUN_IPV4_TOS | \
  81         IAVF_INSET_TUN_IPV4_TTL)
  82
  83 #define IAVF_FDIR_INSET_GTPU_IPV4_UDP (\
  84         IAVF_FDIR_INSET_GTPU_IPV4 | \
  85         IAVF_INSET_TUN_UDP_SRC_PORT | IAVF_INSET_TUN_UDP_DST_PORT)
  86
  87 #define IAVF_FDIR_INSET_GTPU_IPV4_TCP (\
  88         IAVF_FDIR_INSET_GTPU_IPV4 | \
  89         IAVF_INSET_TUN_TCP_SRC_PORT | IAVF_INSET_TUN_TCP_DST_PORT)
  90
  91 #define IAVF_FDIR_INSET_IPV4_GTPU_EH (\
  92         IAVF_INSET_IPV4_SRC | IAVF_INSET_IPV4_DST | \
  93         IAVF_INSET_GTPU_TEID | IAVF_INSET_GTPU_QFI)
  94
  95 #define IAVF_FDIR_INSET_IPV6_GTPU (\
  96         IAVF_INSET_IPV6_SRC | IAVF_INSET_IPV6_DST | \
  97         IAVF_INSET_GTPU_TEID)
  98
  99 #define IAVF_FDIR_INSET_GTPU_IPV6 (\
 100         IAVF_INSET_TUN_IPV6_SRC | IAVF_INSET_TUN_IPV6_DST | \
 101         IAVF_INSET_TUN_IPV6_NEXT_HDR | IAVF_INSET_TUN_IPV6_TC | \
 102         IAVF_INSET_TUN_IPV6_HOP_LIMIT)
 103
 104 #define IAVF_FDIR_INSET_GTPU_IPV6_UDP (\
 105         IAVF_FDIR_INSET_GTPU_IPV6 | \
 106         IAVF_INSET_TUN_UDP_SRC_PORT | IAVF_INSET_TUN_UDP_DST_PORT)
 107
 108 #define IAVF_FDIR_INSET_GTPU_IPV6_TCP (\
 109         IAVF_FDIR_INSET_GTPU_IPV6 | \
 110         IAVF_INSET_TUN_TCP_SRC_PORT | IAVF_INSET_TUN_TCP_DST_PORT)
 111
 112 #define IAVF_FDIR_INSET_IPV6_GTPU_EH (\
 113         IAVF_INSET_IPV6_SRC | IAVF_INSET_IPV6_DST | \
 114         IAVF_INSET_GTPU_TEID | IAVF_INSET_GTPU_QFI)
 115
 116 #define IAVF_FDIR_INSET_L2TPV3OIP (\
 117         IAVF_L2TPV3OIP_SESSION_ID)
 118
 119 #define IAVF_FDIR_INSET_ESP (\
 120         IAVF_INSET_ESP_SPI)
 121
 122 #define IAVF_FDIR_INSET_AH (\
 123         IAVF_INSET_AH_SPI)
 124
 125 #define IAVF_FDIR_INSET_IPV4_NATT_ESP (\
 126         IAVF_INSET_IPV4_SRC | IAVF_INSET_IPV4_DST | \
 127         IAVF_INSET_ESP_SPI)
 128
 129 #define IAVF_FDIR_INSET_IPV6_NATT_ESP (\
 130         IAVF_INSET_IPV6_SRC | IAVF_INSET_IPV6_DST | \
 131         IAVF_INSET_ESP_SPI)
 132
 133 #define IAVF_FDIR_INSET_PFCP (\
 134         IAVF_INSET_PFCP_S_FIELD)
 135
 136 #define IAVF_FDIR_INSET_ECPRI (\
 137         IAVF_INSET_ECPRI)
 138
 139 static struct iavf_pattern_match_item iavf_fdir_pattern[] = {
 140         {iavf_pattern_ethertype,                 IAVF_FDIR_INSET_ETH,           IAVF_INSET_NONE},
 141         {iavf_pattern_eth_ipv4,                  IAVF_FDIR_INSET_ETH_IPV4,      IAVF_INSET_NONE},
 142         {iavf_pattern_eth_ipv4_udp,              IAVF_FDIR_INSET_ETH_IPV4_UDP,  IAVF_INSET_NONE},
 143         {iavf_pattern_eth_ipv4_tcp,              IAVF_FDIR_INSET_ETH_IPV4_TCP,  IAVF_INSET_NONE},
 144         {iavf_pattern_eth_ipv4_sctp,             IAVF_FDIR_INSET_ETH_IPV4_SCTP, IAVF_INSET_NONE},
 145         {iavf_pattern_eth_ipv6,                  IAVF_FDIR_INSET_ETH_IPV6,      IAVF_INSET_NONE},
 146         {iavf_pattern_eth_ipv6_udp,              IAVF_FDIR_INSET_ETH_IPV6_UDP,  IAVF_INSET_NONE},
 147         {iavf_pattern_eth_ipv6_tcp,              IAVF_FDIR_INSET_ETH_IPV6_TCP,  IAVF_INSET_NONE},
 148         {iavf_pattern_eth_ipv6_sctp,             IAVF_FDIR_INSET_ETH_IPV6_SCTP, IAVF_INSET_NONE},
 149         {iavf_pattern_eth_ipv4_gtpu,             IAVF_FDIR_INSET_IPV4_GTPU,     IAVF_INSET_NONE},
 150         {iavf_pattern_eth_ipv4_gtpu_ipv4,        IAVF_FDIR_INSET_GTPU_IPV4,     IAVF_INSET_NONE},
 151         {iavf_pattern_eth_ipv4_gtpu_ipv4_udp,    IAVF_FDIR_INSET_GTPU_IPV4_UDP, IAVF_INSET_NONE},
 152         {iavf_pattern_eth_ipv4_gtpu_ipv4_tcp,    IAVF_FDIR_INSET_GTPU_IPV4_TCP, IAVF_INSET_NONE},
 153         {iavf_pattern_eth_ipv4_gtpu_ipv6,        IAVF_FDIR_INSET_GTPU_IPV6,     IAVF_INSET_NONE},
 154         {iavf_pattern_eth_ipv4_gtpu_ipv6_udp,    IAVF_FDIR_INSET_GTPU_IPV6_UDP, IAVF_INSET_NONE},
 155         {iavf_pattern_eth_ipv4_gtpu_ipv6_tcp,    IAVF_FDIR_INSET_GTPU_IPV6_TCP, IAVF_INSET_NONE},
 156         {iavf_pattern_eth_ipv4_gtpu_eh,          IAVF_FDIR_INSET_IPV4_GTPU_EH,  IAVF_INSET_NONE},
 157         {iavf_pattern_eth_ipv4_gtpu_eh_ipv4,     IAVF_FDIR_INSET_GTPU_IPV4,     IAVF_INSET_NONE},
 158         {iavf_pattern_eth_ipv4_gtpu_eh_ipv4_udp, IAVF_FDIR_INSET_GTPU_IPV4_UDP, IAVF_INSET_NONE},
 159         {iavf_pattern_eth_ipv4_gtpu_eh_ipv4_tcp, IAVF_FDIR_INSET_GTPU_IPV4_TCP, IAVF_INSET_NONE},
 160         {iavf_pattern_eth_ipv4_gtpu_eh_ipv6,     IAVF_FDIR_INSET_GTPU_IPV6,     IAVF_INSET_NONE},
 161         {iavf_pattern_eth_ipv4_gtpu_eh_ipv6_udp, IAVF_FDIR_INSET_GTPU_IPV6_UDP, IAVF_INSET_NONE},
 162         {iavf_pattern_eth_ipv4_gtpu_eh_ipv6_tcp, IAVF_FDIR_INSET_GTPU_IPV6_TCP, IAVF_INSET_NONE},
 163         {iavf_pattern_eth_ipv6_gtpu,             IAVF_FDIR_INSET_IPV6_GTPU,     IAVF_INSET_NONE},
 164         {iavf_pattern_eth_ipv6_gtpu_eh,          IAVF_FDIR_INSET_IPV6_GTPU_EH,  IAVF_INSET_NONE},
 165         {iavf_pattern_eth_ipv4_l2tpv3,           IAVF_FDIR_INSET_L2TPV3OIP,     IAVF_INSET_NONE},
 166         {iavf_pattern_eth_ipv6_l2tpv3,           IAVF_FDIR_INSET_L2TPV3OIP,     IAVF_INSET_NONE},
 167         {iavf_pattern_eth_ipv4_esp,              IAVF_FDIR_INSET_ESP,           IAVF_INSET_NONE},
 168         {iavf_pattern_eth_ipv6_esp,              IAVF_FDIR_INSET_ESP,           IAVF_INSET_NONE},
 169         {iavf_pattern_eth_ipv4_ah,               IAVF_FDIR_INSET_AH,            IAVF_INSET_NONE},
 170         {iavf_pattern_eth_ipv6_ah,               IAVF_FDIR_INSET_AH,            IAVF_INSET_NONE},
 171         {iavf_pattern_eth_ipv4_udp_esp,          IAVF_FDIR_INSET_IPV4_NATT_ESP, IAVF_INSET_NONE},
 172         {iavf_pattern_eth_ipv6_udp_esp,          IAVF_FDIR_INSET_IPV6_NATT_ESP, IAVF_INSET_NONE},
 173         {iavf_pattern_eth_ipv4_pfcp,             IAVF_FDIR_INSET_PFCP,          IAVF_INSET_NONE},
 174         {iavf_pattern_eth_ipv6_pfcp,             IAVF_FDIR_INSET_PFCP,          IAVF_INSET_NONE},
 175         {iavf_pattern_eth_ecpri,                 IAVF_FDIR_INSET_ECPRI,         IAVF_INSET_NONE},
 176         {iavf_pattern_eth_ipv4_ecpri,            IAVF_FDIR_INSET_ECPRI,         IAVF_INSET_NONE},
 177 };
 178
 179 static struct iavf_flow_parser iavf_fdir_parser;
 180
 181 static int
 182 iavf_fdir_init(struct iavf_adapter *ad)
 183 {
 184         struct iavf_info *vf = IAVF_DEV_PRIVATE_TO_VF(ad);
 185         struct iavf_flow_parser *parser;
 186
 187         if (!vf->vf_res)
 188                 return -EINVAL;
 189
 190         if (vf->vf_res->vf_cap_flags & VIRTCHNL_VF_OFFLOAD_FDIR_PF)
 191                 parser = &iavf_fdir_parser;
 192         else
 193                 return -ENOTSUP;
 194
 195         return iavf_register_parser(parser, ad);
 196 }
 197
 198 static void
 199 iavf_fdir_uninit(struct iavf_adapter *ad)
 200 {
 201         iavf_unregister_parser(&iavf_fdir_parser, ad);
 202 }
 203
 204 static int
 205 iavf_fdir_create(struct iavf_adapter *ad,
 206                 struct rte_flow *flow,
 207                 void *meta,
 208                 struct rte_flow_error *error)
 209 {
 210         struct iavf_fdir_conf *filter = meta;
 211         struct iavf_fdir_conf *rule;
 212         int ret;
 213
 214         rule = rte_zmalloc("fdir_entry", sizeof(*rule), 0);
 215         if (!rule) {
 216                 rte_flow_error_set(error, ENOMEM,
 217                                 RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
 218                                 "Failed to allocate memory for fdir rule");
 219                 return -rte_errno;
 220         }
 221
 222         ret = iavf_fdir_add(ad, filter);
 223         if (ret) {
 224                 rte_flow_error_set(error, -ret,
 225                                 RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
 226                                 "Failed to add filter rule.");
 227                 goto free_entry;
 228         }
 229
 230         if (filter->mark_flag == 1)
 231                 iavf_fdir_rx_proc_enable(ad, 1);
 232
 233         rte_memcpy(rule, filter, sizeof(*rule));
 234         flow->rule = rule;
 235
 236         return 0;
 237
 238 free_entry:
 239         rte_free(rule);
 240         return -rte_errno;
 241 }
 242
 243 static int
 244 iavf_fdir_destroy(struct iavf_adapter *ad,
 245                 struct rte_flow *flow,
 246                 struct rte_flow_error *error)
 247 {
 248         struct iavf_fdir_conf *filter;
 249         int ret;
 250
 251         filter = (struct iavf_fdir_conf *)flow->rule;
 252
 253         ret = iavf_fdir_del(ad, filter);
 254         if (ret) {
 255                 rte_flow_error_set(error, -ret,
 256                                 RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
 257                                 "Failed to delete filter rule.");
 258                 return -rte_errno;
 259         }
 260
 261         if (filter->mark_flag == 1)
 262                 iavf_fdir_rx_proc_enable(ad, 0);
 263
 264         flow->rule = NULL;
 265         rte_free(filter);
 266
 267         return 0;
 268 }
 269
 270 static int
 271 iavf_fdir_validation(struct iavf_adapter *ad,
 272                 __rte_unused struct rte_flow *flow,
 273                 void *meta,
 274                 struct rte_flow_error *error)
 275 {
 276         struct iavf_fdir_conf *filter = meta;
 277         int ret;
 278
 279         ret = iavf_fdir_check(ad, filter);
 280         if (ret) {
 281                 rte_flow_error_set(error, -ret,
 282                                 RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
 283                                 "Failed to validate filter rule.");
 284                 return -rte_errno;
 285         }
 286
 287         return 0;
 288 };
 289
 290 static struct iavf_flow_engine iavf_fdir_engine = {
 291         .init = iavf_fdir_init,
 292         .uninit = iavf_fdir_uninit,
 293         .create = iavf_fdir_create,
 294         .destroy = iavf_fdir_destroy,
 295         .validation = iavf_fdir_validation,
 296         .type = IAVF_FLOW_ENGINE_FDIR,
 297 };
 298
 299 static int
 300 iavf_fdir_parse_action_qregion(struct iavf_adapter *ad,
 301                         struct rte_flow_error *error,
 302                         const struct rte_flow_action *act,
 303                         struct virtchnl_filter_action *filter_action)
 304 {
 305         struct iavf_info *vf = IAVF_DEV_PRIVATE_TO_VF(ad);
 306         const struct rte_flow_action_rss *rss = act->conf;
 307         uint32_t i;
 308
 309         if (act->type != RTE_FLOW_ACTION_TYPE_RSS) {
 310                 rte_flow_error_set(error, EINVAL,
 311                                 RTE_FLOW_ERROR_TYPE_ACTION, act,
 312                                 "Invalid action.");
 313                 return -rte_errno;
 314         }
 315
 316         if (rss->queue_num <= 1) {
 317                 rte_flow_error_set(error, EINVAL,
 318                                 RTE_FLOW_ERROR_TYPE_ACTION, act,
 319                                 "Queue region size can't be 0 or 1.");
 320                 return -rte_errno;
 321         }
 322
 323         /* check if queue index for queue region is continuous */
 324         for (i = 0; i < rss->queue_num - 1; i++) {
 325                 if (rss->queue[i + 1] != rss->queue[i] + 1) {
 326                         rte_flow_error_set(error, EINVAL,
 327                                         RTE_FLOW_ERROR_TYPE_ACTION, act,
 328                                         "Discontinuous queue region");
 329                         return -rte_errno;
 330                 }
 331         }
 332
 333         if (rss->queue[rss->queue_num - 1] >= ad->eth_dev->data->nb_rx_queues) {
 334                 rte_flow_error_set(error, EINVAL,
 335                                 RTE_FLOW_ERROR_TYPE_ACTION, act,
 336                                 "Invalid queue region indexes.");
 337                 return -rte_errno;
 338         }
 339
 340         if (!(rte_is_power_of_2(rss->queue_num) &&
 341                 rss->queue_num <= IAVF_FDIR_MAX_QREGION_SIZE)) {
 342                 rte_flow_error_set(error, EINVAL,
 343                                 RTE_FLOW_ERROR_TYPE_ACTION, act,
 344                                 "The region size should be any of the following values:"
 345                                 "1, 2, 4, 8, 16, 32, 64, 128 as long as the total number "
 346                                 "of queues do not exceed the VSI allocation.");
 347                 return -rte_errno;
 348         }
 349
 350         if (rss->queue_num > vf->max_rss_qregion) {
 351                 rte_flow_error_set(error, EINVAL,
 352                                 RTE_FLOW_ERROR_TYPE_ACTION, act,
 353                                 "The region size cannot be large than the supported max RSS queue region");
 354                 return -rte_errno;
 355         }
 356
 357         filter_action->act_conf.queue.index = rss->queue[0];
 358         filter_action->act_conf.queue.region = rte_fls_u32(rss->queue_num) - 1;
 359
 360         return 0;
 361 }
 362
 363 static int
 364 iavf_fdir_parse_action(struct iavf_adapter *ad,
 365                         const struct rte_flow_action actions[],
 366                         struct rte_flow_error *error,
 367                         struct iavf_fdir_conf *filter)
 368 {
 369         const struct rte_flow_action_queue *act_q;
 370         const struct rte_flow_action_mark *mark_spec = NULL;
 371         uint32_t dest_num = 0;
 372         uint32_t mark_num = 0;
 373         int ret;
 374
 375         int number = 0;
 376         struct virtchnl_filter_action *filter_action;
 377
 378         for (; actions->type != RTE_FLOW_ACTION_TYPE_END; actions++) {
 379                 switch (actions->type) {
 380                 case RTE_FLOW_ACTION_TYPE_VOID:
 381                         break;
 382
 383                 case RTE_FLOW_ACTION_TYPE_PASSTHRU:
 384                         dest_num++;
 385
 386                         filter_action = &filter->add_fltr.rule_cfg.action_set.actions[number];
 387
 388                         filter_action->type = VIRTCHNL_ACTION_PASSTHRU;
 389
 390                         filter->add_fltr.rule_cfg.action_set.count = ++number;
 391                         break;
 392
 393                 case RTE_FLOW_ACTION_TYPE_DROP:
 394                         dest_num++;
 395
 396                         filter_action = &filter->add_fltr.rule_cfg.action_set.actions[number];
 397
 398                         filter_action->type = VIRTCHNL_ACTION_DROP;
 399
 400                         filter->add_fltr.rule_cfg.action_set.count = ++number;
 401                         break;
 402
 403                 case RTE_FLOW_ACTION_TYPE_QUEUE:
 404                         dest_num++;
 405
 406                         act_q = actions->conf;
 407                         filter_action = &filter->add_fltr.rule_cfg.action_set.actions[number];
 408
 409                         filter_action->type = VIRTCHNL_ACTION_QUEUE;
 410                         filter_action->act_conf.queue.index = act_q->index;
 411
 412                         if (filter_action->act_conf.queue.index >=
 413                                 ad->eth_dev->data->nb_rx_queues) {
 414                                 rte_flow_error_set(error, EINVAL,
 415                                         RTE_FLOW_ERROR_TYPE_ACTION,
 416                                         actions, "Invalid queue for FDIR.");
 417                                 return -rte_errno;
 418                         }
 419
 420                         filter->add_fltr.rule_cfg.action_set.count = ++number;
 421                         break;
 422
 423                 case RTE_FLOW_ACTION_TYPE_RSS:
 424                         dest_num++;
 425
 426                         filter_action = &filter->add_fltr.rule_cfg.action_set.actions[number];
 427
 428                         filter_action->type = VIRTCHNL_ACTION_Q_REGION;
 429
 430                         ret = iavf_fdir_parse_action_qregion(ad,
 431                                                 error, actions, filter_action);
 432                         if (ret)
 433                                 return ret;
 434
 435                         filter->add_fltr.rule_cfg.action_set.count = ++number;
 436                         break;
 437
 438                 case RTE_FLOW_ACTION_TYPE_MARK:
 439                         mark_num++;
 440
 441                         filter->mark_flag = 1;
 442                         mark_spec = actions->conf;
 443                         filter_action = &filter->add_fltr.rule_cfg.action_set.actions[number];
 444
 445                         filter_action->type = VIRTCHNL_ACTION_MARK;
 446                         filter_action->act_conf.mark_id = mark_spec->id;
 447
 448                         filter->add_fltr.rule_cfg.action_set.count = ++number;
 449                         break;
 450
 451                 default:
 452                         rte_flow_error_set(error, EINVAL,
 453                                         RTE_FLOW_ERROR_TYPE_ACTION, actions,
 454                                         "Invalid action.");
 455                         return -rte_errno;
 456                 }
 457         }
 458
 459         if (number > VIRTCHNL_MAX_NUM_ACTIONS) {
 460                 rte_flow_error_set(error, EINVAL,
 461                         RTE_FLOW_ERROR_TYPE_ACTION, actions,
 462                         "Action numbers exceed the maximum value");
 463                 return -rte_errno;
 464         }
 465
 466         if (dest_num >= 2) {
 467                 rte_flow_error_set(error, EINVAL,
 468                         RTE_FLOW_ERROR_TYPE_ACTION, actions,
 469                         "Unsupported action combination");
 470                 return -rte_errno;
 471         }
 472
 473         if (mark_num >= 2) {
 474                 rte_flow_error_set(error, EINVAL,
 475                         RTE_FLOW_ERROR_TYPE_ACTION, actions,
 476                         "Too many mark actions");
 477                 return -rte_errno;
 478         }
 479
 480         if (dest_num + mark_num == 0) {
 481                 rte_flow_error_set(error, EINVAL,
 482                         RTE_FLOW_ERROR_TYPE_ACTION, actions,
 483                         "Empty action");
 484                 return -rte_errno;
 485         }
 486
 487         /* Mark only is equal to mark + passthru. */
 488         if (dest_num == 0) {
 489                 filter_action = &filter->add_fltr.rule_cfg.action_set.actions[number];
 490                 filter_action->type = VIRTCHNL_ACTION_PASSTHRU;
 491                 filter->add_fltr.rule_cfg.action_set.count = ++number;
 492         }
 493
 494         return 0;
 495 }
 496
 497 static bool
 498 iavf_fdir_refine_input_set(const uint64_t input_set,
 499                            const uint64_t input_set_mask,
 500                            struct iavf_fdir_conf *filter)
 501 {
 502         struct virtchnl_proto_hdr *hdr, *hdr_last;
 503         struct rte_flow_item_ipv4 ipv4_spec;
 504         struct rte_flow_item_ipv6 ipv6_spec;
 505         int last_layer;
 506         uint8_t proto_id;
 507
 508         if (input_set & ~input_set_mask)
 509                 return false;
 510         else if (input_set)
 511                 return true;
 512
 513         last_layer = filter->add_fltr.rule_cfg.proto_hdrs.count - 1;
 514         /* Last layer of TCP/UDP pattern isn't less than 2. */
 515         if (last_layer < 2)
 516                 return false;
 517         hdr_last = &filter->add_fltr.rule_cfg.proto_hdrs.proto_hdr[last_layer];
 518         if (hdr_last->type == VIRTCHNL_PROTO_HDR_TCP)
 519                 proto_id = 6;
 520         else if (hdr_last->type == VIRTCHNL_PROTO_HDR_UDP)
 521                 proto_id = 17;
 522         else
 523                 return false;
 524
 525         hdr = &filter->add_fltr.rule_cfg.proto_hdrs.proto_hdr[last_layer - 1];
 526         switch (hdr->type) {
 527         case VIRTCHNL_PROTO_HDR_IPV4:
 528                 VIRTCHNL_ADD_PROTO_HDR_FIELD_BIT(hdr, IPV4, PROT);
 529                 memset(&ipv4_spec, 0, sizeof(ipv4_spec));
 530                 ipv4_spec.hdr.next_proto_id = proto_id;
 531                 rte_memcpy(hdr->buffer, &ipv4_spec.hdr,
 532                            sizeof(ipv4_spec.hdr));
 533                 return true;
 534         case VIRTCHNL_PROTO_HDR_IPV6:
 535                 VIRTCHNL_ADD_PROTO_HDR_FIELD_BIT(hdr, IPV6, PROT);
 536                 memset(&ipv6_spec, 0, sizeof(ipv6_spec));
 537                 ipv6_spec.hdr.proto = proto_id;
 538                 rte_memcpy(hdr->buffer, &ipv6_spec.hdr,
 539                            sizeof(ipv6_spec.hdr));
 540                 return true;
 541         default:
 542                 return false;
 543         }
 544 }
 545
 546 static int
 547 iavf_fdir_parse_pattern(__rte_unused struct iavf_adapter *ad,
 548                         const struct rte_flow_item pattern[],
 549                         const uint64_t input_set_mask,
 550                         struct rte_flow_error *error,
 551                         struct iavf_fdir_conf *filter)
 552 {
 553         const struct rte_flow_item *item = pattern;
 554         enum rte_flow_item_type item_type;
 555         enum rte_flow_item_type l3 = RTE_FLOW_ITEM_TYPE_END;
 556         const struct rte_flow_item_eth *eth_spec, *eth_mask;
 557         const struct rte_flow_item_ipv4 *ipv4_spec, *ipv4_mask;
 558         const struct rte_flow_item_ipv6 *ipv6_spec, *ipv6_mask;
 559         const struct rte_flow_item_udp *udp_spec, *udp_mask;
 560         const struct rte_flow_item_tcp *tcp_spec, *tcp_mask;
 561         const struct rte_flow_item_sctp *sctp_spec, *sctp_mask;
 562         const struct rte_flow_item_gtp *gtp_spec, *gtp_mask;
 563         const struct rte_flow_item_gtp_psc *gtp_psc_spec, *gtp_psc_mask;
 564         const struct rte_flow_item_l2tpv3oip *l2tpv3oip_spec, *l2tpv3oip_mask;
 565         const struct rte_flow_item_esp *esp_spec, *esp_mask;
 566         const struct rte_flow_item_ah *ah_spec, *ah_mask;
 567         const struct rte_flow_item_pfcp *pfcp_spec, *pfcp_mask;
 568         const struct rte_flow_item_ecpri *ecpri_spec, *ecpri_mask;
 569         struct rte_ecpri_common_hdr ecpri_common;
 570         uint64_t input_set = IAVF_INSET_NONE;
 571
 572         enum rte_flow_item_type next_type;
 573         uint16_t ether_type;
 574
 575         u8 tun_inner = 0;
 576         int layer = 0;
 577         struct virtchnl_proto_hdr *hdr;
 578
 579         uint8_t  ipv6_addr_mask[16] = {
 580                 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
 581                 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
 582         };
 583
 584         for (item = pattern; item->type != RTE_FLOW_ITEM_TYPE_END; item++) {
 585                 if (item->last) {
 586                         rte_flow_error_set(error, EINVAL,
 587                                         RTE_FLOW_ERROR_TYPE_ITEM, item,
 588                                         "Not support range");
 589                 }
 590
 591                 item_type = item->type;
 592
 593                 switch (item_type) {
 594                 case RTE_FLOW_ITEM_TYPE_ETH:
 595                         eth_spec = item->spec;
 596                         eth_mask = item->mask;
 597                         next_type = (item + 1)->type;
 598
 599                         hdr = &filter->add_fltr.rule_cfg.proto_hdrs.proto_hdr[layer];
 600
 601                         VIRTCHNL_SET_PROTO_HDR_TYPE(hdr, ETH);
 602
 603                         if (next_type == RTE_FLOW_ITEM_TYPE_END &&
 604                                 (!eth_spec || !eth_mask)) {
 605                                 rte_flow_error_set(error, EINVAL,
 606                                                 RTE_FLOW_ERROR_TYPE_ITEM,
 607                                                 item, "NULL eth spec/mask.");
 608                                 return -rte_errno;
 609                         }
 610
 611                         if (eth_spec && eth_mask) {
 612                                 if (!rte_is_zero_ether_addr(&eth_mask->src) ||
 613                                     !rte_is_zero_ether_addr(&eth_mask->dst)) {
 614                                         rte_flow_error_set(error, EINVAL,
 615                                                 RTE_FLOW_ERROR_TYPE_ITEM, item,
 616                                                 "Invalid MAC_addr mask.");
 617                                         return -rte_errno;
 618                                 }
 619                         }
 620
 621                         if (eth_spec && eth_mask && eth_mask->type) {
 622                                 if (eth_mask->type != RTE_BE16(0xffff)) {
 623                                         rte_flow_error_set(error, EINVAL,
 624                                                 RTE_FLOW_ERROR_TYPE_ITEM,
 625                                                 item, "Invalid type mask.");
 626                                         return -rte_errno;
 627                                 }
 628
 629                                 ether_type = rte_be_to_cpu_16(eth_spec->type);
 630                                 if (ether_type == RTE_ETHER_TYPE_IPV4 ||
 631                                         ether_type == RTE_ETHER_TYPE_IPV6) {
 632                                         rte_flow_error_set(error, EINVAL,
 633                                                 RTE_FLOW_ERROR_TYPE_ITEM,
 634                                                 item,
 635                                                 "Unsupported ether_type.");
 636                                         return -rte_errno;
 637                                 }
 638
 639                                 input_set |= IAVF_INSET_ETHERTYPE;
 640                                 VIRTCHNL_ADD_PROTO_HDR_FIELD_BIT(hdr, ETH, ETHERTYPE);
 641
 642                                 rte_memcpy(hdr->buffer,
 643                                         eth_spec, sizeof(struct rte_ether_hdr));
 644                         }
 645
 646                         filter->add_fltr.rule_cfg.proto_hdrs.count = ++layer;
 647                         break;
 648
 649                 case RTE_FLOW_ITEM_TYPE_IPV4:
 650                         l3 = RTE_FLOW_ITEM_TYPE_IPV4;
 651                         ipv4_spec = item->spec;
 652                         ipv4_mask = item->mask;
 653
 654                         hdr = &filter->add_fltr.rule_cfg.proto_hdrs.proto_hdr[layer];
 655
 656                         VIRTCHNL_SET_PROTO_HDR_TYPE(hdr, IPV4);
 657
 658                         if (ipv4_spec && ipv4_mask) {
 659                                 if (ipv4_mask->hdr.version_ihl ||
 660                                         ipv4_mask->hdr.total_length ||
 661                                         ipv4_mask->hdr.packet_id ||
 662                                         ipv4_mask->hdr.fragment_offset ||
 663                                         ipv4_mask->hdr.hdr_checksum) {
 664                                         rte_flow_error_set(error, EINVAL,
 665                                                 RTE_FLOW_ERROR_TYPE_ITEM,
 666                                                 item, "Invalid IPv4 mask.");
 667                                         return -rte_errno;
 668                                 }
 669
 670                                 if (ipv4_mask->hdr.type_of_service ==
 671                                                                 UINT8_MAX) {
 672                                         input_set |= IAVF_INSET_IPV4_TOS;
 673                                         VIRTCHNL_ADD_PROTO_HDR_FIELD_BIT(hdr, IPV4, DSCP);
 674                                 }
 675                                 if (ipv4_mask->hdr.next_proto_id == UINT8_MAX) {
 676                                         input_set |= IAVF_INSET_IPV4_PROTO;
 677                                         VIRTCHNL_ADD_PROTO_HDR_FIELD_BIT(hdr, IPV4, PROT);
 678                                 }
 679                                 if (ipv4_mask->hdr.time_to_live == UINT8_MAX) {
 680                                         input_set |= IAVF_INSET_IPV4_TTL;
 681                                         VIRTCHNL_ADD_PROTO_HDR_FIELD_BIT(hdr, IPV4, TTL);
 682                                 }
 683                                 if (ipv4_mask->hdr.src_addr == UINT32_MAX) {
 684                                         input_set |= IAVF_INSET_IPV4_SRC;
 685                                         VIRTCHNL_ADD_PROTO_HDR_FIELD_BIT(hdr, IPV4, SRC);
 686                                 }
 687                                 if (ipv4_mask->hdr.dst_addr == UINT32_MAX) {
 688                                         input_set |= IAVF_INSET_IPV4_DST;
 689                                         VIRTCHNL_ADD_PROTO_HDR_FIELD_BIT(hdr, IPV4, DST);
 690                                 }
 691
 692                                 if (tun_inner) {
 693                                         input_set &= ~IAVF_PROT_IPV4_OUTER;
 694                                         input_set |= IAVF_PROT_IPV4_INNER;
 695                                 }
 696
 697                                 rte_memcpy(hdr->buffer,
 698                                         &ipv4_spec->hdr,
 699                                         sizeof(ipv4_spec->hdr));
 700                         }
 701
 702                         filter->add_fltr.rule_cfg.proto_hdrs.count = ++layer;
 703                         break;
 704
 705                 case RTE_FLOW_ITEM_TYPE_IPV6:
 706                         l3 = RTE_FLOW_ITEM_TYPE_IPV6;
 707                         ipv6_spec = item->spec;
 708                         ipv6_mask = item->mask;
 709
 710                         hdr = &filter->add_fltr.rule_cfg.proto_hdrs.proto_hdr[layer];
 711
 712                         VIRTCHNL_SET_PROTO_HDR_TYPE(hdr, IPV6);
 713
 714                         if (ipv6_spec && ipv6_mask) {
 715                                 if (ipv6_mask->hdr.payload_len) {
 716                                         rte_flow_error_set(error, EINVAL,
 717                                                 RTE_FLOW_ERROR_TYPE_ITEM,
 718                                                 item, "Invalid IPv6 mask");
 719                                         return -rte_errno;
 720                                 }
 721
 722                                 if ((ipv6_mask->hdr.vtc_flow &
 723                                         rte_cpu_to_be_32(IAVF_IPV6_TC_MASK))
 724                                         == rte_cpu_to_be_32(IAVF_IPV6_TC_MASK)) {
 725                                         input_set |= IAVF_INSET_IPV6_TC;
 726                                         VIRTCHNL_ADD_PROTO_HDR_FIELD_BIT(hdr, IPV6, TC);
 727                                 }
 728                                 if (ipv6_mask->hdr.proto == UINT8_MAX) {
 729                                         input_set |= IAVF_INSET_IPV6_NEXT_HDR;
 730                                         VIRTCHNL_ADD_PROTO_HDR_FIELD_BIT(hdr, IPV6, PROT);
 731                                 }
 732                                 if (ipv6_mask->hdr.hop_limits == UINT8_MAX) {
 733                                         input_set |= IAVF_INSET_IPV6_HOP_LIMIT;
 734                                         VIRTCHNL_ADD_PROTO_HDR_FIELD_BIT(hdr, IPV6, HOP_LIMIT);
 735                                 }
 736                                 if (!memcmp(ipv6_mask->hdr.src_addr,
 737                                         ipv6_addr_mask,
 738                                         RTE_DIM(ipv6_mask->hdr.src_addr))) {
 739                                         input_set |= IAVF_INSET_IPV6_SRC;
 740                                         VIRTCHNL_ADD_PROTO_HDR_FIELD_BIT(hdr, IPV6, SRC);
 741                                 }
 742                                 if (!memcmp(ipv6_mask->hdr.dst_addr,
 743                                         ipv6_addr_mask,
 744                                         RTE_DIM(ipv6_mask->hdr.dst_addr))) {
 745                                         input_set |= IAVF_INSET_IPV6_DST;
 746                                         VIRTCHNL_ADD_PROTO_HDR_FIELD_BIT(hdr, IPV6, DST);
 747                                 }
 748
 749                                 if (tun_inner) {
 750                                         input_set &= ~IAVF_PROT_IPV6_OUTER;
 751                                         input_set |= IAVF_PROT_IPV6_INNER;
 752                                 }
 753
 754                                 rte_memcpy(hdr->buffer,
 755                                         &ipv6_spec->hdr,
 756                                         sizeof(ipv6_spec->hdr));
 757                         }
 758
 759                         filter->add_fltr.rule_cfg.proto_hdrs.count = ++layer;
 760                         break;
 761
 762                 case RTE_FLOW_ITEM_TYPE_UDP:
 763                         udp_spec = item->spec;
 764                         udp_mask = item->mask;
 765
 766                         hdr = &filter->add_fltr.rule_cfg.proto_hdrs.proto_hdr[layer];
 767
 768                         VIRTCHNL_SET_PROTO_HDR_TYPE(hdr, UDP);
 769
 770                         if (udp_spec && udp_mask) {
 771                                 if (udp_mask->hdr.dgram_len ||
 772                                         udp_mask->hdr.dgram_cksum) {
 773                                         rte_flow_error_set(error, EINVAL,
 774                                                 RTE_FLOW_ERROR_TYPE_ITEM, item,
 775                                                 "Invalid UDP mask");
 776                                         return -rte_errno;
 777                                 }
 778
 779                                 if (udp_mask->hdr.src_port == UINT16_MAX) {
 780                                         input_set |= IAVF_INSET_UDP_SRC_PORT;
 781                                         VIRTCHNL_ADD_PROTO_HDR_FIELD_BIT(hdr, UDP, SRC_PORT);
 782                                 }
 783                                 if (udp_mask->hdr.dst_port == UINT16_MAX) {
 784                                         input_set |= IAVF_INSET_UDP_DST_PORT;
 785                                         VIRTCHNL_ADD_PROTO_HDR_FIELD_BIT(hdr, UDP, DST_PORT);
 786                                 }
 787
 788                                 if (tun_inner) {
 789                                         input_set &= ~IAVF_PROT_UDP_OUTER;
 790                                         input_set |= IAVF_PROT_UDP_INNER;
 791                                 }
 792
 793                                 if (l3 == RTE_FLOW_ITEM_TYPE_IPV4)
 794                                         rte_memcpy(hdr->buffer,
 795                                                 &udp_spec->hdr,
 796                                                 sizeof(udp_spec->hdr));
 797                                 else if (l3 == RTE_FLOW_ITEM_TYPE_IPV6)
 798                                         rte_memcpy(hdr->buffer,
 799                                                 &udp_spec->hdr,
 800                                                 sizeof(udp_spec->hdr));
 801                         }
 802
 803                         filter->add_fltr.rule_cfg.proto_hdrs.count = ++layer;
 804                         break;
 805
 806                 case RTE_FLOW_ITEM_TYPE_TCP:
 807                         tcp_spec = item->spec;
 808                         tcp_mask = item->mask;
 809
 810                         hdr = &filter->add_fltr.rule_cfg.proto_hdrs.proto_hdr[layer];
 811
 812                         VIRTCHNL_SET_PROTO_HDR_TYPE(hdr, TCP);
 813
 814                         if (tcp_spec && tcp_mask) {
 815                                 if (tcp_mask->hdr.sent_seq ||
 816                                         tcp_mask->hdr.recv_ack ||
 817                                         tcp_mask->hdr.data_off ||
 818                                         tcp_mask->hdr.tcp_flags ||
 819                                         tcp_mask->hdr.rx_win ||
 820                                         tcp_mask->hdr.cksum ||
 821                                         tcp_mask->hdr.tcp_urp) {
 822                                         rte_flow_error_set(error, EINVAL,
 823                                                 RTE_FLOW_ERROR_TYPE_ITEM, item,
 824                                                 "Invalid TCP mask");
 825                                         return -rte_errno;
 826                                 }
 827
 828                                 if (tcp_mask->hdr.src_port == UINT16_MAX) {
 829                                         input_set |= IAVF_INSET_TCP_SRC_PORT;
 830                                         VIRTCHNL_ADD_PROTO_HDR_FIELD_BIT(hdr, TCP, SRC_PORT);
 831                                 }
 832                                 if (tcp_mask->hdr.dst_port == UINT16_MAX) {
 833                                         input_set |= IAVF_INSET_TCP_DST_PORT;
 834                                         VIRTCHNL_ADD_PROTO_HDR_FIELD_BIT(hdr, TCP, DST_PORT);
 835                                 }
 836
 837                                 if (tun_inner) {
 838                                         input_set &= ~IAVF_PROT_TCP_OUTER;
 839                                         input_set |= IAVF_PROT_TCP_INNER;
 840                                 }
 841
 842                                 if (l3 == RTE_FLOW_ITEM_TYPE_IPV4)
 843                                         rte_memcpy(hdr->buffer,
 844                                                 &tcp_spec->hdr,
 845                                                 sizeof(tcp_spec->hdr));
 846                                 else if (l3 == RTE_FLOW_ITEM_TYPE_IPV6)
 847                                         rte_memcpy(hdr->buffer,
 848                                                 &tcp_spec->hdr,
 849                                                 sizeof(tcp_spec->hdr));
 850                         }
 851
 852                         filter->add_fltr.rule_cfg.proto_hdrs.count = ++layer;
 853                         break;
 854
 855                 case RTE_FLOW_ITEM_TYPE_SCTP:
 856                         sctp_spec = item->spec;
 857                         sctp_mask = item->mask;
 858
 859                         hdr = &filter->add_fltr.rule_cfg.proto_hdrs.proto_hdr[layer];
 860
 861                         VIRTCHNL_SET_PROTO_HDR_TYPE(hdr, SCTP);
 862
 863                         if (sctp_spec && sctp_mask) {
 864                                 if (sctp_mask->hdr.cksum) {
 865                                         rte_flow_error_set(error, EINVAL,
 866                                                 RTE_FLOW_ERROR_TYPE_ITEM, item,
 867                                                 "Invalid UDP mask");
 868                                         return -rte_errno;
 869                                 }
 870
 871                                 if (sctp_mask->hdr.src_port == UINT16_MAX) {
 872                                         input_set |= IAVF_INSET_SCTP_SRC_PORT;
 873                                         VIRTCHNL_ADD_PROTO_HDR_FIELD_BIT(hdr, SCTP, SRC_PORT);
 874                                 }
 875                                 if (sctp_mask->hdr.dst_port == UINT16_MAX) {
 876                                         input_set |= IAVF_INSET_SCTP_DST_PORT;
 877                                         VIRTCHNL_ADD_PROTO_HDR_FIELD_BIT(hdr, SCTP, DST_PORT);
 878                                 }
 879
 880                                 if (l3 == RTE_FLOW_ITEM_TYPE_IPV4)
 881                                         rte_memcpy(hdr->buffer,
 882                                                 &sctp_spec->hdr,
 883                                                 sizeof(sctp_spec->hdr));
 884                                 else if (l3 == RTE_FLOW_ITEM_TYPE_IPV6)
 885                                         rte_memcpy(hdr->buffer,
 886                                                 &sctp_spec->hdr,
 887                                                 sizeof(sctp_spec->hdr));
 888                         }
 889
 890                         filter->add_fltr.rule_cfg.proto_hdrs.count = ++layer;
 891                         break;
 892
 893                 case RTE_FLOW_ITEM_TYPE_GTPU:
 894                         gtp_spec = item->spec;
 895                         gtp_mask = item->mask;
 896
 897                         hdr = &filter->add_fltr.rule_cfg.proto_hdrs.proto_hdr[layer];
 898
 899                         VIRTCHNL_SET_PROTO_HDR_TYPE(hdr, GTPU_IP);
 900
 901                         if (gtp_spec && gtp_mask) {
 902                                 if (gtp_mask->v_pt_rsv_flags ||
 903                                         gtp_mask->msg_type ||
 904                                         gtp_mask->msg_len) {
 905                                         rte_flow_error_set(error, EINVAL,
 906                                                 RTE_FLOW_ERROR_TYPE_ITEM,
 907                                                 item, "Invalid GTP mask");
 908                                         return -rte_errno;
 909                                 }
 910
 911                                 if (gtp_mask->teid == UINT32_MAX) {
 912                                         input_set |= IAVF_INSET_GTPU_TEID;
 913                                         VIRTCHNL_ADD_PROTO_HDR_FIELD_BIT(hdr, GTPU_IP, TEID);
 914                                 }
 915
 916                                 rte_memcpy(hdr->buffer,
 917                                         gtp_spec, sizeof(*gtp_spec));
 918                         }
 919
 920                         tun_inner = 1;
 921
 922                         filter->add_fltr.rule_cfg.proto_hdrs.count = ++layer;
 923                         break;
 924
 925                 case RTE_FLOW_ITEM_TYPE_GTP_PSC:
 926                         gtp_psc_spec = item->spec;
 927                         gtp_psc_mask = item->mask;
 928
 929                         hdr = &filter->add_fltr.rule_cfg.proto_hdrs.proto_hdr[layer];
 930
 931                         if (!gtp_psc_spec)
 932                                 VIRTCHNL_SET_PROTO_HDR_TYPE(hdr, GTPU_EH);
 933                         else if ((gtp_psc_mask->qfi) && !(gtp_psc_mask->pdu_type))
 934                                 VIRTCHNL_SET_PROTO_HDR_TYPE(hdr, GTPU_EH);
 935                         else if (gtp_psc_spec->pdu_type == IAVF_GTPU_EH_UPLINK)
 936                                 VIRTCHNL_SET_PROTO_HDR_TYPE(hdr, GTPU_EH_PDU_UP);
 937                         else if (gtp_psc_spec->pdu_type == IAVF_GTPU_EH_DWLINK)
 938                                 VIRTCHNL_SET_PROTO_HDR_TYPE(hdr, GTPU_EH_PDU_DWN);
 939
 940                         if (gtp_psc_spec && gtp_psc_mask) {
 941                                 if (gtp_psc_mask->qfi == UINT8_MAX) {
 942                                         input_set |= IAVF_INSET_GTPU_QFI;
 943                                         VIRTCHNL_ADD_PROTO_HDR_FIELD_BIT(hdr, GTPU_EH, QFI);
 944                                 }
 945
 946                                 rte_memcpy(hdr->buffer, gtp_psc_spec,
 947                                         sizeof(*gtp_psc_spec));
 948                         }
 949
 950                         filter->add_fltr.rule_cfg.proto_hdrs.count = ++layer;
 951                         break;
 952
 953                 case RTE_FLOW_ITEM_TYPE_L2TPV3OIP:
 954                         l2tpv3oip_spec = item->spec;
 955                         l2tpv3oip_mask = item->mask;
 956
 957                         hdr = &filter->add_fltr.rule_cfg.proto_hdrs.proto_hdr[layer];
 958
 959                         VIRTCHNL_SET_PROTO_HDR_TYPE(hdr, L2TPV3);
 960
 961                         if (l2tpv3oip_spec && l2tpv3oip_mask) {
 962                                 if (l2tpv3oip_mask->session_id == UINT32_MAX) {
 963                                         input_set |= IAVF_L2TPV3OIP_SESSION_ID;
 964                                         VIRTCHNL_ADD_PROTO_HDR_FIELD_BIT(hdr, L2TPV3, SESS_ID);
 965                                 }
 966
 967                                 rte_memcpy(hdr->buffer, l2tpv3oip_spec,
 968                                         sizeof(*l2tpv3oip_spec));
 969                         }
 970
 971                         filter->add_fltr.rule_cfg.proto_hdrs.count = ++layer;
 972                         break;
 973
 974                 case RTE_FLOW_ITEM_TYPE_ESP:
 975                         esp_spec = item->spec;
 976                         esp_mask = item->mask;
 977
 978                         hdr = &filter->add_fltr.rule_cfg.proto_hdrs.proto_hdr[layer];
 979
 980                         VIRTCHNL_SET_PROTO_HDR_TYPE(hdr, ESP);
 981
 982                         if (esp_spec && esp_mask) {
 983                                 if (esp_mask->hdr.spi == UINT32_MAX) {
 984                                         input_set |= IAVF_INSET_ESP_SPI;
 985                                         VIRTCHNL_ADD_PROTO_HDR_FIELD_BIT(hdr, ESP, SPI);
 986                                 }
 987
 988                                 rte_memcpy(hdr->buffer, &esp_spec->hdr,
 989                                         sizeof(esp_spec->hdr));
 990                         }
 991
 992                         filter->add_fltr.rule_cfg.proto_hdrs.count = ++layer;
 993                         break;
 994
 995                 case RTE_FLOW_ITEM_TYPE_AH:
 996                         ah_spec = item->spec;
 997                         ah_mask = item->mask;
 998
 999                         hdr = &filter->add_fltr.rule_cfg.proto_hdrs.proto_hdr[layer];
1000
1001                         VIRTCHNL_SET_PROTO_HDR_TYPE(hdr, AH);
1002
1003                         if (ah_spec && ah_mask) {
1004                                 if (ah_mask->spi == UINT32_MAX) {
1005                                         input_set |= IAVF_INSET_AH_SPI;
1006                                         VIRTCHNL_ADD_PROTO_HDR_FIELD_BIT(hdr, AH, SPI);
1007                                 }
1008
1009                                 rte_memcpy(hdr->buffer, ah_spec,
1010                                         sizeof(*ah_spec));
1011                         }
1012
1013                         filter->add_fltr.rule_cfg.proto_hdrs.count = ++layer;
1014                         break;
1015
1016                 case RTE_FLOW_ITEM_TYPE_PFCP:
1017                         pfcp_spec = item->spec;
1018                         pfcp_mask = item->mask;
1019
1020                         hdr = &filter->add_fltr.rule_cfg.proto_hdrs.proto_hdr[layer];
1021
1022                         VIRTCHNL_SET_PROTO_HDR_TYPE(hdr, PFCP);
1023
1024                         if (pfcp_spec && pfcp_mask) {
1025                                 if (pfcp_mask->s_field == UINT8_MAX) {
1026                                         input_set |= IAVF_INSET_PFCP_S_FIELD;
1027                                         VIRTCHNL_ADD_PROTO_HDR_FIELD_BIT(hdr, PFCP, S_FIELD);
1028                                 }
1029
1030                                 rte_memcpy(hdr->buffer, pfcp_spec,
1031                                         sizeof(*pfcp_spec));
1032                         }
1033
1034                         filter->add_fltr.rule_cfg.proto_hdrs.count = ++layer;
1035                         break;
1036
1037                 case RTE_FLOW_ITEM_TYPE_ECPRI:
1038                         ecpri_spec = item->spec;
1039                         ecpri_mask = item->mask;
1040
1041                         ecpri_common.u32 = rte_be_to_cpu_32(ecpri_spec->hdr.common.u32);
1042
1043                         hdr = &filter->add_fltr.rule_cfg.proto_hdrs.proto_hdr[layer];
1044
1045                         VIRTCHNL_SET_PROTO_HDR_TYPE(hdr, ECPRI);
1046
1047                         if (ecpri_spec && ecpri_mask) {
1048                                 if (ecpri_common.type == RTE_ECPRI_MSG_TYPE_IQ_DATA &&
1049                                                 ecpri_mask->hdr.type0.pc_id == UINT16_MAX) {
1050                                         input_set |= IAVF_ECPRI_PC_RTC_ID;
1051                                         VIRTCHNL_ADD_PROTO_HDR_FIELD_BIT(hdr, ECPRI,
1052                                                                          PC_RTC_ID);
1053                                 }
1054
1055                                 rte_memcpy(hdr->buffer, ecpri_spec,
1056                                         sizeof(*ecpri_spec));
1057                         }
1058
1059                         filter->add_fltr.rule_cfg.proto_hdrs.count = ++layer;
1060                         break;
1061
1062                 case RTE_FLOW_ITEM_TYPE_VOID:
1063                         break;
1064
1065                 default:
1066                         rte_flow_error_set(error, EINVAL,
1067                                         RTE_FLOW_ERROR_TYPE_ITEM, item,
1068                                         "Invalid pattern item.");
1069                         return -rte_errno;
1070                 }
1071         }
1072
1073         if (layer > VIRTCHNL_MAX_NUM_PROTO_HDRS) {
1074                 rte_flow_error_set(error, EINVAL,
1075                         RTE_FLOW_ERROR_TYPE_ITEM, item,
1076                         "Protocol header layers exceed the maximum value");
1077                 return -rte_errno;
1078         }
1079
1080         if (!iavf_fdir_refine_input_set(input_set, input_set_mask, filter)) {
1081                 rte_flow_error_set(error, EINVAL,
1082                                    RTE_FLOW_ERROR_TYPE_ITEM_SPEC, pattern,
1083                                    "Invalid input set");
1084                 return -rte_errno;
1085         }
1086
1087         filter->input_set = input_set;
1088
1089         return 0;
1090 }
1091
1092 static int
1093 iavf_fdir_parse(struct iavf_adapter *ad,
1094                 struct iavf_pattern_match_item *array,
1095                 uint32_t array_len,
1096                 const struct rte_flow_item pattern[],
1097                 const struct rte_flow_action actions[],
1098                 void **meta,
1099                 struct rte_flow_error *error)
1100 {
1101         struct iavf_info *vf = IAVF_DEV_PRIVATE_TO_VF(ad);
1102         struct iavf_fdir_conf *filter = &vf->fdir.conf;
1103         struct iavf_pattern_match_item *item = NULL;
1104         int ret;
1105
1106         memset(filter, 0, sizeof(*filter));
1107
1108         item = iavf_search_pattern_match_item(pattern, array, array_len, error);
1109         if (!item)
1110                 return -rte_errno;
1111
1112         ret = iavf_fdir_parse_pattern(ad, pattern, item->input_set_mask,
1113                                       error, filter);
1114         if (ret)
1115                 goto error;
1116
1117         ret = iavf_fdir_parse_action(ad, actions, error, filter);
1118         if (ret)
1119                 goto error;
1120
1121         if (meta)
1122                 *meta = filter;
1123
1124 error:
1125         rte_free(item);
1126         return ret;
1127 }
1128
1129 static struct iavf_flow_parser iavf_fdir_parser = {
1130         .engine = &iavf_fdir_engine,
1131         .array = iavf_fdir_pattern,
1132         .array_len = RTE_DIM(iavf_fdir_pattern),
1133         .parse_pattern_action = iavf_fdir_parse,
1134         .stage = IAVF_FLOW_STAGE_DISTRIBUTOR,
1135 };
1136
1137 RTE_INIT(iavf_fdir_engine_register)
1138 {
1139         iavf_register_flow_engine(&iavf_fdir_engine);
1140 }