drivers/net/iavf/iavf_generic_flow.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2019 Intel Corporation
   3  */
   4
   5 #include <sys/queue.h>
   6 #include <stdio.h>
   7 #include <errno.h>
   8 #include <stdint.h>
   9 #include <string.h>
  10 #include <unistd.h>
  11 #include <stdarg.h>
  12
  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
  21 static struct iavf_engine_list engine_list =
  22                 TAILQ_HEAD_INITIALIZER(engine_list);
  23
  24 static int iavf_flow_validate(struct rte_eth_dev *dev,
  25                 const struct rte_flow_attr *attr,
  26                 const struct rte_flow_item pattern[],
  27                 const struct rte_flow_action actions[],
  28                 struct rte_flow_error *error);
  29 static struct rte_flow *iavf_flow_create(struct rte_eth_dev *dev,
  30                 const struct rte_flow_attr *attr,
  31                 const struct rte_flow_item pattern[],
  32                 const struct rte_flow_action actions[],
  33                 struct rte_flow_error *error);
  34 static int iavf_flow_destroy(struct rte_eth_dev *dev,
  35                 struct rte_flow *flow,
  36                 struct rte_flow_error *error);
  37 static int iavf_flow_query(struct rte_eth_dev *dev,
  38                 struct rte_flow *flow,
  39                 const struct rte_flow_action *actions,
  40                 void *data,
  41                 struct rte_flow_error *error);
  42
  43 const struct rte_flow_ops iavf_flow_ops = {
  44         .validate = iavf_flow_validate,
  45         .create = iavf_flow_create,
  46         .destroy = iavf_flow_destroy,
  47         .flush = iavf_flow_flush,
  48         .query = iavf_flow_query,
  49 };
  50
  51 /* empty */
  52 enum rte_flow_item_type iavf_pattern_empty[] = {
  53         RTE_FLOW_ITEM_TYPE_END,
  54 };
  55
  56 /* L2 */
  57 enum rte_flow_item_type iavf_pattern_ethertype[] = {
  58         RTE_FLOW_ITEM_TYPE_ETH,
  59         RTE_FLOW_ITEM_TYPE_END,
  60 };
  61
  62 enum rte_flow_item_type iavf_pattern_ethertype_vlan[] = {
  63         RTE_FLOW_ITEM_TYPE_ETH,
  64         RTE_FLOW_ITEM_TYPE_VLAN,
  65         RTE_FLOW_ITEM_TYPE_END,
  66 };
  67
  68 enum rte_flow_item_type iavf_pattern_ethertype_qinq[] = {
  69         RTE_FLOW_ITEM_TYPE_ETH,
  70         RTE_FLOW_ITEM_TYPE_VLAN,
  71         RTE_FLOW_ITEM_TYPE_VLAN,
  72         RTE_FLOW_ITEM_TYPE_END,
  73 };
  74
  75 /* ARP */
  76 enum rte_flow_item_type iavf_pattern_eth_arp[] = {
  77         RTE_FLOW_ITEM_TYPE_ETH,
  78         RTE_FLOW_ITEM_TYPE_ARP_ETH_IPV4,
  79         RTE_FLOW_ITEM_TYPE_END,
  80 };
  81
  82 /* non-tunnel IPv4 */
  83 enum rte_flow_item_type iavf_pattern_eth_ipv4[] = {
  84         RTE_FLOW_ITEM_TYPE_ETH,
  85         RTE_FLOW_ITEM_TYPE_IPV4,
  86         RTE_FLOW_ITEM_TYPE_END,
  87 };
  88
  89 enum rte_flow_item_type iavf_pattern_eth_vlan_ipv4[] = {
  90         RTE_FLOW_ITEM_TYPE_ETH,
  91         RTE_FLOW_ITEM_TYPE_VLAN,
  92         RTE_FLOW_ITEM_TYPE_IPV4,
  93         RTE_FLOW_ITEM_TYPE_END,
  94 };
  95
  96 enum rte_flow_item_type iavf_pattern_eth_qinq_ipv4[] = {
  97         RTE_FLOW_ITEM_TYPE_ETH,
  98         RTE_FLOW_ITEM_TYPE_VLAN,
  99         RTE_FLOW_ITEM_TYPE_VLAN,
 100         RTE_FLOW_ITEM_TYPE_IPV4,
 101         RTE_FLOW_ITEM_TYPE_END,
 102 };
 103
 104 enum rte_flow_item_type iavf_pattern_eth_ipv4_udp[] = {
 105         RTE_FLOW_ITEM_TYPE_ETH,
 106         RTE_FLOW_ITEM_TYPE_IPV4,
 107         RTE_FLOW_ITEM_TYPE_UDP,
 108         RTE_FLOW_ITEM_TYPE_END,
 109 };
 110
 111 enum rte_flow_item_type iavf_pattern_eth_vlan_ipv4_udp[] = {
 112         RTE_FLOW_ITEM_TYPE_ETH,
 113         RTE_FLOW_ITEM_TYPE_VLAN,
 114         RTE_FLOW_ITEM_TYPE_IPV4,
 115         RTE_FLOW_ITEM_TYPE_UDP,
 116         RTE_FLOW_ITEM_TYPE_END,
 117 };
 118
 119 enum rte_flow_item_type iavf_pattern_eth_qinq_ipv4_udp[] = {
 120         RTE_FLOW_ITEM_TYPE_ETH,
 121         RTE_FLOW_ITEM_TYPE_VLAN,
 122         RTE_FLOW_ITEM_TYPE_VLAN,
 123         RTE_FLOW_ITEM_TYPE_IPV4,
 124         RTE_FLOW_ITEM_TYPE_UDP,
 125         RTE_FLOW_ITEM_TYPE_END,
 126 };
 127
 128 enum rte_flow_item_type iavf_pattern_eth_ipv4_tcp[] = {
 129         RTE_FLOW_ITEM_TYPE_ETH,
 130         RTE_FLOW_ITEM_TYPE_IPV4,
 131         RTE_FLOW_ITEM_TYPE_TCP,
 132         RTE_FLOW_ITEM_TYPE_END,
 133 };
 134
 135 enum rte_flow_item_type iavf_pattern_eth_vlan_ipv4_tcp[] = {
 136         RTE_FLOW_ITEM_TYPE_ETH,
 137         RTE_FLOW_ITEM_TYPE_VLAN,
 138         RTE_FLOW_ITEM_TYPE_IPV4,
 139         RTE_FLOW_ITEM_TYPE_TCP,
 140         RTE_FLOW_ITEM_TYPE_END,
 141 };
 142
 143 enum rte_flow_item_type iavf_pattern_eth_qinq_ipv4_tcp[] = {
 144         RTE_FLOW_ITEM_TYPE_ETH,
 145         RTE_FLOW_ITEM_TYPE_VLAN,
 146         RTE_FLOW_ITEM_TYPE_VLAN,
 147         RTE_FLOW_ITEM_TYPE_IPV4,
 148         RTE_FLOW_ITEM_TYPE_TCP,
 149         RTE_FLOW_ITEM_TYPE_END,
 150 };
 151
 152 enum rte_flow_item_type iavf_pattern_eth_ipv4_sctp[] = {
 153         RTE_FLOW_ITEM_TYPE_ETH,
 154         RTE_FLOW_ITEM_TYPE_IPV4,
 155         RTE_FLOW_ITEM_TYPE_SCTP,
 156         RTE_FLOW_ITEM_TYPE_END,
 157 };
 158
 159 enum rte_flow_item_type iavf_pattern_eth_vlan_ipv4_sctp[] = {
 160         RTE_FLOW_ITEM_TYPE_ETH,
 161         RTE_FLOW_ITEM_TYPE_VLAN,
 162         RTE_FLOW_ITEM_TYPE_IPV4,
 163         RTE_FLOW_ITEM_TYPE_SCTP,
 164         RTE_FLOW_ITEM_TYPE_END,
 165 };
 166
 167 enum rte_flow_item_type iavf_pattern_eth_qinq_ipv4_sctp[] = {
 168         RTE_FLOW_ITEM_TYPE_ETH,
 169         RTE_FLOW_ITEM_TYPE_VLAN,
 170         RTE_FLOW_ITEM_TYPE_VLAN,
 171         RTE_FLOW_ITEM_TYPE_IPV4,
 172         RTE_FLOW_ITEM_TYPE_SCTP,
 173         RTE_FLOW_ITEM_TYPE_END,
 174 };
 175
 176 enum rte_flow_item_type iavf_pattern_eth_ipv4_icmp[] = {
 177         RTE_FLOW_ITEM_TYPE_ETH,
 178         RTE_FLOW_ITEM_TYPE_IPV4,
 179         RTE_FLOW_ITEM_TYPE_ICMP,
 180         RTE_FLOW_ITEM_TYPE_END,
 181 };
 182
 183 enum rte_flow_item_type iavf_pattern_eth_vlan_ipv4_icmp[] = {
 184         RTE_FLOW_ITEM_TYPE_ETH,
 185         RTE_FLOW_ITEM_TYPE_VLAN,
 186         RTE_FLOW_ITEM_TYPE_IPV4,
 187         RTE_FLOW_ITEM_TYPE_ICMP,
 188         RTE_FLOW_ITEM_TYPE_END,
 189 };
 190
 191 enum rte_flow_item_type iavf_pattern_eth_qinq_ipv4_icmp[] = {
 192         RTE_FLOW_ITEM_TYPE_ETH,
 193         RTE_FLOW_ITEM_TYPE_VLAN,
 194         RTE_FLOW_ITEM_TYPE_VLAN,
 195         RTE_FLOW_ITEM_TYPE_IPV4,
 196         RTE_FLOW_ITEM_TYPE_ICMP,
 197         RTE_FLOW_ITEM_TYPE_END,
 198 };
 199
 200 /* non-tunnel IPv6 */
 201 enum rte_flow_item_type iavf_pattern_eth_ipv6[] = {
 202         RTE_FLOW_ITEM_TYPE_ETH,
 203         RTE_FLOW_ITEM_TYPE_IPV6,
 204         RTE_FLOW_ITEM_TYPE_END,
 205 };
 206
 207 enum rte_flow_item_type iavf_pattern_eth_vlan_ipv6[] = {
 208         RTE_FLOW_ITEM_TYPE_ETH,
 209         RTE_FLOW_ITEM_TYPE_VLAN,
 210         RTE_FLOW_ITEM_TYPE_IPV6,
 211         RTE_FLOW_ITEM_TYPE_END,
 212 };
 213
 214 enum rte_flow_item_type iavf_pattern_eth_qinq_ipv6[] = {
 215         RTE_FLOW_ITEM_TYPE_ETH,
 216         RTE_FLOW_ITEM_TYPE_VLAN,
 217         RTE_FLOW_ITEM_TYPE_VLAN,
 218         RTE_FLOW_ITEM_TYPE_IPV6,
 219         RTE_FLOW_ITEM_TYPE_END,
 220 };
 221
 222 enum rte_flow_item_type iavf_pattern_eth_ipv6_frag_ext[] = {
 223         RTE_FLOW_ITEM_TYPE_ETH,
 224         RTE_FLOW_ITEM_TYPE_IPV6,
 225         RTE_FLOW_ITEM_TYPE_IPV6_FRAG_EXT,
 226         RTE_FLOW_ITEM_TYPE_END,
 227 };
 228
 229 enum rte_flow_item_type iavf_pattern_eth_vlan_ipv6_frag_ext[] = {
 230         RTE_FLOW_ITEM_TYPE_ETH,
 231         RTE_FLOW_ITEM_TYPE_VLAN,
 232         RTE_FLOW_ITEM_TYPE_IPV6,
 233         RTE_FLOW_ITEM_TYPE_IPV6_FRAG_EXT,
 234         RTE_FLOW_ITEM_TYPE_END,
 235 };
 236
 237 enum rte_flow_item_type iavf_pattern_eth_qinq_ipv6_frag_ext[] = {
 238         RTE_FLOW_ITEM_TYPE_ETH,
 239         RTE_FLOW_ITEM_TYPE_VLAN,
 240         RTE_FLOW_ITEM_TYPE_VLAN,
 241         RTE_FLOW_ITEM_TYPE_IPV6,
 242         RTE_FLOW_ITEM_TYPE_IPV6_FRAG_EXT,
 243         RTE_FLOW_ITEM_TYPE_END,
 244 };
 245
 246 enum rte_flow_item_type iavf_pattern_eth_ipv6_udp[] = {
 247         RTE_FLOW_ITEM_TYPE_ETH,
 248         RTE_FLOW_ITEM_TYPE_IPV6,
 249         RTE_FLOW_ITEM_TYPE_UDP,
 250         RTE_FLOW_ITEM_TYPE_END,
 251 };
 252
 253 enum rte_flow_item_type iavf_pattern_eth_vlan_ipv6_udp[] = {
 254         RTE_FLOW_ITEM_TYPE_ETH,
 255         RTE_FLOW_ITEM_TYPE_VLAN,
 256         RTE_FLOW_ITEM_TYPE_IPV6,
 257         RTE_FLOW_ITEM_TYPE_UDP,
 258         RTE_FLOW_ITEM_TYPE_END,
 259 };
 260
 261 enum rte_flow_item_type iavf_pattern_eth_qinq_ipv6_udp[] = {
 262         RTE_FLOW_ITEM_TYPE_ETH,
 263         RTE_FLOW_ITEM_TYPE_VLAN,
 264         RTE_FLOW_ITEM_TYPE_VLAN,
 265         RTE_FLOW_ITEM_TYPE_IPV6,
 266         RTE_FLOW_ITEM_TYPE_UDP,
 267         RTE_FLOW_ITEM_TYPE_END,
 268 };
 269
 270 enum rte_flow_item_type iavf_pattern_eth_ipv6_tcp[] = {
 271         RTE_FLOW_ITEM_TYPE_ETH,
 272         RTE_FLOW_ITEM_TYPE_IPV6,
 273         RTE_FLOW_ITEM_TYPE_TCP,
 274         RTE_FLOW_ITEM_TYPE_END,
 275 };
 276
 277 enum rte_flow_item_type iavf_pattern_eth_vlan_ipv6_tcp[] = {
 278         RTE_FLOW_ITEM_TYPE_ETH,
 279         RTE_FLOW_ITEM_TYPE_VLAN,
 280         RTE_FLOW_ITEM_TYPE_IPV6,
 281         RTE_FLOW_ITEM_TYPE_TCP,
 282         RTE_FLOW_ITEM_TYPE_END,
 283 };
 284
 285 enum rte_flow_item_type iavf_pattern_eth_qinq_ipv6_tcp[] = {
 286         RTE_FLOW_ITEM_TYPE_ETH,
 287         RTE_FLOW_ITEM_TYPE_VLAN,
 288         RTE_FLOW_ITEM_TYPE_VLAN,
 289         RTE_FLOW_ITEM_TYPE_IPV6,
 290         RTE_FLOW_ITEM_TYPE_TCP,
 291         RTE_FLOW_ITEM_TYPE_END,
 292 };
 293
 294 enum rte_flow_item_type iavf_pattern_eth_ipv6_sctp[] = {
 295         RTE_FLOW_ITEM_TYPE_ETH,
 296         RTE_FLOW_ITEM_TYPE_IPV6,
 297         RTE_FLOW_ITEM_TYPE_SCTP,
 298         RTE_FLOW_ITEM_TYPE_END,
 299 };
 300
 301 enum rte_flow_item_type iavf_pattern_eth_vlan_ipv6_sctp[] = {
 302         RTE_FLOW_ITEM_TYPE_ETH,
 303         RTE_FLOW_ITEM_TYPE_VLAN,
 304         RTE_FLOW_ITEM_TYPE_IPV6,
 305         RTE_FLOW_ITEM_TYPE_SCTP,
 306         RTE_FLOW_ITEM_TYPE_END,
 307 };
 308
 309 enum rte_flow_item_type iavf_pattern_eth_qinq_ipv6_sctp[] = {
 310         RTE_FLOW_ITEM_TYPE_ETH,
 311         RTE_FLOW_ITEM_TYPE_VLAN,
 312         RTE_FLOW_ITEM_TYPE_VLAN,
 313         RTE_FLOW_ITEM_TYPE_IPV6,
 314         RTE_FLOW_ITEM_TYPE_SCTP,
 315         RTE_FLOW_ITEM_TYPE_END,
 316 };
 317
 318 enum rte_flow_item_type iavf_pattern_eth_ipv6_icmp6[] = {
 319         RTE_FLOW_ITEM_TYPE_ETH,
 320         RTE_FLOW_ITEM_TYPE_IPV6,
 321         RTE_FLOW_ITEM_TYPE_ICMP6,
 322         RTE_FLOW_ITEM_TYPE_END,
 323 };
 324
 325 enum rte_flow_item_type iavf_pattern_eth_vlan_ipv6_icmp6[] = {
 326         RTE_FLOW_ITEM_TYPE_ETH,
 327         RTE_FLOW_ITEM_TYPE_VLAN,
 328         RTE_FLOW_ITEM_TYPE_IPV6,
 329         RTE_FLOW_ITEM_TYPE_ICMP6,
 330         RTE_FLOW_ITEM_TYPE_END,
 331 };
 332
 333 enum rte_flow_item_type iavf_pattern_eth_qinq_ipv6_icmp6[] = {
 334         RTE_FLOW_ITEM_TYPE_ETH,
 335         RTE_FLOW_ITEM_TYPE_VLAN,
 336         RTE_FLOW_ITEM_TYPE_VLAN,
 337         RTE_FLOW_ITEM_TYPE_IPV6,
 338         RTE_FLOW_ITEM_TYPE_ICMP6,
 339         RTE_FLOW_ITEM_TYPE_END,
 340 };
 341
 342 /* IPv4 GTPC */
 343 enum rte_flow_item_type iavf_pattern_eth_ipv4_gtpc[] = {
 344         RTE_FLOW_ITEM_TYPE_ETH,
 345         RTE_FLOW_ITEM_TYPE_IPV4,
 346         RTE_FLOW_ITEM_TYPE_UDP,
 347         RTE_FLOW_ITEM_TYPE_GTPC,
 348         RTE_FLOW_ITEM_TYPE_END,
 349 };
 350
 351 /* IPV4 GTPU (EH) */
 352 enum rte_flow_item_type iavf_pattern_eth_ipv4_gtpu[] = {
 353         RTE_FLOW_ITEM_TYPE_ETH,
 354         RTE_FLOW_ITEM_TYPE_IPV4,
 355         RTE_FLOW_ITEM_TYPE_UDP,
 356         RTE_FLOW_ITEM_TYPE_GTPU,
 357         RTE_FLOW_ITEM_TYPE_END,
 358 };
 359
 360 enum rte_flow_item_type iavf_pattern_eth_ipv4_gtpu_eh[] = {
 361         RTE_FLOW_ITEM_TYPE_ETH,
 362         RTE_FLOW_ITEM_TYPE_IPV4,
 363         RTE_FLOW_ITEM_TYPE_UDP,
 364         RTE_FLOW_ITEM_TYPE_GTPU,
 365         RTE_FLOW_ITEM_TYPE_GTP_PSC,
 366         RTE_FLOW_ITEM_TYPE_END,
 367 };
 368
 369 /* IPv6 GTPC */
 370 enum rte_flow_item_type iavf_pattern_eth_ipv6_gtpc[] = {
 371         RTE_FLOW_ITEM_TYPE_ETH,
 372         RTE_FLOW_ITEM_TYPE_IPV6,
 373         RTE_FLOW_ITEM_TYPE_UDP,
 374         RTE_FLOW_ITEM_TYPE_GTPC,
 375         RTE_FLOW_ITEM_TYPE_END,
 376 };
 377
 378 /* IPV6 GTPU (EH) */
 379 enum rte_flow_item_type iavf_pattern_eth_ipv6_gtpu[] = {
 380         RTE_FLOW_ITEM_TYPE_ETH,
 381         RTE_FLOW_ITEM_TYPE_IPV6,
 382         RTE_FLOW_ITEM_TYPE_UDP,
 383         RTE_FLOW_ITEM_TYPE_GTPU,
 384         RTE_FLOW_ITEM_TYPE_END,
 385 };
 386
 387 enum rte_flow_item_type iavf_pattern_eth_ipv6_gtpu_eh[] = {
 388         RTE_FLOW_ITEM_TYPE_ETH,
 389         RTE_FLOW_ITEM_TYPE_IPV6,
 390         RTE_FLOW_ITEM_TYPE_UDP,
 391         RTE_FLOW_ITEM_TYPE_GTPU,
 392         RTE_FLOW_ITEM_TYPE_GTP_PSC,
 393         RTE_FLOW_ITEM_TYPE_END,
 394 };
 395
 396 /* IPV4 GTPU IPv4 */
 397 enum rte_flow_item_type iavf_pattern_eth_ipv4_gtpu_ipv4[] = {
 398         RTE_FLOW_ITEM_TYPE_ETH,
 399         RTE_FLOW_ITEM_TYPE_IPV4,
 400         RTE_FLOW_ITEM_TYPE_UDP,
 401         RTE_FLOW_ITEM_TYPE_GTPU,
 402         RTE_FLOW_ITEM_TYPE_IPV4,
 403         RTE_FLOW_ITEM_TYPE_END,
 404 };
 405
 406 enum rte_flow_item_type iavf_pattern_eth_ipv4_gtpu_ipv4_udp[] = {
 407         RTE_FLOW_ITEM_TYPE_ETH,
 408         RTE_FLOW_ITEM_TYPE_IPV4,
 409         RTE_FLOW_ITEM_TYPE_UDP,
 410         RTE_FLOW_ITEM_TYPE_GTPU,
 411         RTE_FLOW_ITEM_TYPE_IPV4,
 412         RTE_FLOW_ITEM_TYPE_UDP,
 413         RTE_FLOW_ITEM_TYPE_END,
 414 };
 415
 416 enum rte_flow_item_type iavf_pattern_eth_ipv4_gtpu_ipv4_tcp[] = {
 417         RTE_FLOW_ITEM_TYPE_ETH,
 418         RTE_FLOW_ITEM_TYPE_IPV4,
 419         RTE_FLOW_ITEM_TYPE_UDP,
 420         RTE_FLOW_ITEM_TYPE_GTPU,
 421         RTE_FLOW_ITEM_TYPE_IPV4,
 422         RTE_FLOW_ITEM_TYPE_TCP,
 423         RTE_FLOW_ITEM_TYPE_END,
 424 };
 425
 426 enum rte_flow_item_type iavf_pattern_eth_ipv4_gtpu_ipv4_icmp[] = {
 427         RTE_FLOW_ITEM_TYPE_ETH,
 428         RTE_FLOW_ITEM_TYPE_IPV4,
 429         RTE_FLOW_ITEM_TYPE_UDP,
 430         RTE_FLOW_ITEM_TYPE_GTPU,
 431         RTE_FLOW_ITEM_TYPE_IPV4,
 432         RTE_FLOW_ITEM_TYPE_ICMP,
 433         RTE_FLOW_ITEM_TYPE_END,
 434 };
 435
 436 /* IPV4 GTPU IPv6 */
 437 enum rte_flow_item_type iavf_pattern_eth_ipv4_gtpu_ipv6[] = {
 438         RTE_FLOW_ITEM_TYPE_ETH,
 439         RTE_FLOW_ITEM_TYPE_IPV4,
 440         RTE_FLOW_ITEM_TYPE_UDP,
 441         RTE_FLOW_ITEM_TYPE_GTPU,
 442         RTE_FLOW_ITEM_TYPE_IPV6,
 443         RTE_FLOW_ITEM_TYPE_END,
 444 };
 445
 446 enum rte_flow_item_type iavf_pattern_eth_ipv4_gtpu_ipv6_udp[] = {
 447         RTE_FLOW_ITEM_TYPE_ETH,
 448         RTE_FLOW_ITEM_TYPE_IPV4,
 449         RTE_FLOW_ITEM_TYPE_UDP,
 450         RTE_FLOW_ITEM_TYPE_GTPU,
 451         RTE_FLOW_ITEM_TYPE_IPV6,
 452         RTE_FLOW_ITEM_TYPE_UDP,
 453         RTE_FLOW_ITEM_TYPE_END,
 454 };
 455
 456 enum rte_flow_item_type iavf_pattern_eth_ipv4_gtpu_ipv6_tcp[] = {
 457         RTE_FLOW_ITEM_TYPE_ETH,
 458         RTE_FLOW_ITEM_TYPE_IPV4,
 459         RTE_FLOW_ITEM_TYPE_UDP,
 460         RTE_FLOW_ITEM_TYPE_GTPU,
 461         RTE_FLOW_ITEM_TYPE_IPV6,
 462         RTE_FLOW_ITEM_TYPE_TCP,
 463         RTE_FLOW_ITEM_TYPE_END,
 464 };
 465
 466 enum rte_flow_item_type iavf_pattern_eth_ipv4_gtpu_ipv6_icmp[] = {
 467         RTE_FLOW_ITEM_TYPE_ETH,
 468         RTE_FLOW_ITEM_TYPE_IPV4,
 469         RTE_FLOW_ITEM_TYPE_UDP,
 470         RTE_FLOW_ITEM_TYPE_GTPU,
 471         RTE_FLOW_ITEM_TYPE_IPV6,
 472         RTE_FLOW_ITEM_TYPE_ICMP,
 473         RTE_FLOW_ITEM_TYPE_END,
 474 };
 475
 476 /* IPV6 GTPU IPv4 */
 477 enum rte_flow_item_type iavf_pattern_eth_ipv6_gtpu_ipv4[] = {
 478         RTE_FLOW_ITEM_TYPE_ETH,
 479         RTE_FLOW_ITEM_TYPE_IPV6,
 480         RTE_FLOW_ITEM_TYPE_UDP,
 481         RTE_FLOW_ITEM_TYPE_GTPU,
 482         RTE_FLOW_ITEM_TYPE_IPV4,
 483         RTE_FLOW_ITEM_TYPE_END,
 484 };
 485
 486 enum rte_flow_item_type iavf_pattern_eth_ipv6_gtpu_ipv4_udp[] = {
 487         RTE_FLOW_ITEM_TYPE_ETH,
 488         RTE_FLOW_ITEM_TYPE_IPV6,
 489         RTE_FLOW_ITEM_TYPE_UDP,
 490         RTE_FLOW_ITEM_TYPE_GTPU,
 491         RTE_FLOW_ITEM_TYPE_IPV4,
 492         RTE_FLOW_ITEM_TYPE_UDP,
 493         RTE_FLOW_ITEM_TYPE_END,
 494 };
 495
 496 enum rte_flow_item_type iavf_pattern_eth_ipv6_gtpu_ipv4_tcp[] = {
 497         RTE_FLOW_ITEM_TYPE_ETH,
 498         RTE_FLOW_ITEM_TYPE_IPV6,
 499         RTE_FLOW_ITEM_TYPE_UDP,
 500         RTE_FLOW_ITEM_TYPE_GTPU,
 501         RTE_FLOW_ITEM_TYPE_IPV4,
 502         RTE_FLOW_ITEM_TYPE_TCP,
 503         RTE_FLOW_ITEM_TYPE_END,
 504 };
 505
 506 enum rte_flow_item_type iavf_pattern_eth_ipv6_gtpu_ipv4_icmp[] = {
 507         RTE_FLOW_ITEM_TYPE_ETH,
 508         RTE_FLOW_ITEM_TYPE_IPV6,
 509         RTE_FLOW_ITEM_TYPE_UDP,
 510         RTE_FLOW_ITEM_TYPE_GTPU,
 511         RTE_FLOW_ITEM_TYPE_IPV4,
 512         RTE_FLOW_ITEM_TYPE_ICMP,
 513         RTE_FLOW_ITEM_TYPE_END,
 514 };
 515
 516 /* IPV6 GTPU IPv6 */
 517 enum rte_flow_item_type iavf_pattern_eth_ipv6_gtpu_ipv6[] = {
 518         RTE_FLOW_ITEM_TYPE_ETH,
 519         RTE_FLOW_ITEM_TYPE_IPV6,
 520         RTE_FLOW_ITEM_TYPE_UDP,
 521         RTE_FLOW_ITEM_TYPE_GTPU,
 522         RTE_FLOW_ITEM_TYPE_IPV6,
 523         RTE_FLOW_ITEM_TYPE_END,
 524 };
 525
 526 enum rte_flow_item_type iavf_pattern_eth_ipv6_gtpu_ipv6_udp[] = {
 527         RTE_FLOW_ITEM_TYPE_ETH,
 528         RTE_FLOW_ITEM_TYPE_IPV6,
 529         RTE_FLOW_ITEM_TYPE_UDP,
 530         RTE_FLOW_ITEM_TYPE_GTPU,
 531         RTE_FLOW_ITEM_TYPE_IPV6,
 532         RTE_FLOW_ITEM_TYPE_UDP,
 533         RTE_FLOW_ITEM_TYPE_END,
 534 };
 535
 536 enum rte_flow_item_type iavf_pattern_eth_ipv6_gtpu_ipv6_tcp[] = {
 537         RTE_FLOW_ITEM_TYPE_ETH,
 538         RTE_FLOW_ITEM_TYPE_IPV6,
 539         RTE_FLOW_ITEM_TYPE_UDP,
 540         RTE_FLOW_ITEM_TYPE_GTPU,
 541         RTE_FLOW_ITEM_TYPE_IPV6,
 542         RTE_FLOW_ITEM_TYPE_TCP,
 543         RTE_FLOW_ITEM_TYPE_END,
 544 };
 545
 546 enum rte_flow_item_type iavf_pattern_eth_ipv6_gtpu_ipv6_icmp[] = {
 547         RTE_FLOW_ITEM_TYPE_ETH,
 548         RTE_FLOW_ITEM_TYPE_IPV6,
 549         RTE_FLOW_ITEM_TYPE_UDP,
 550         RTE_FLOW_ITEM_TYPE_GTPU,
 551         RTE_FLOW_ITEM_TYPE_IPV6,
 552         RTE_FLOW_ITEM_TYPE_ICMP,
 553         RTE_FLOW_ITEM_TYPE_END,
 554 };
 555
 556 /* IPV4 GTPU EH IPv4 */
 557 enum rte_flow_item_type iavf_pattern_eth_ipv4_gtpu_eh_ipv4[] = {
 558         RTE_FLOW_ITEM_TYPE_ETH,
 559         RTE_FLOW_ITEM_TYPE_IPV4,
 560         RTE_FLOW_ITEM_TYPE_UDP,
 561         RTE_FLOW_ITEM_TYPE_GTPU,
 562         RTE_FLOW_ITEM_TYPE_GTP_PSC,
 563         RTE_FLOW_ITEM_TYPE_IPV4,
 564         RTE_FLOW_ITEM_TYPE_END,
 565 };
 566
 567 enum rte_flow_item_type iavf_pattern_eth_ipv4_gtpu_eh_ipv4_udp[] = {
 568         RTE_FLOW_ITEM_TYPE_ETH,
 569         RTE_FLOW_ITEM_TYPE_IPV4,
 570         RTE_FLOW_ITEM_TYPE_UDP,
 571         RTE_FLOW_ITEM_TYPE_GTPU,
 572         RTE_FLOW_ITEM_TYPE_GTP_PSC,
 573         RTE_FLOW_ITEM_TYPE_IPV4,
 574         RTE_FLOW_ITEM_TYPE_UDP,
 575         RTE_FLOW_ITEM_TYPE_END,
 576 };
 577
 578 enum rte_flow_item_type iavf_pattern_eth_ipv4_gtpu_eh_ipv4_tcp[] = {
 579         RTE_FLOW_ITEM_TYPE_ETH,
 580         RTE_FLOW_ITEM_TYPE_IPV4,
 581         RTE_FLOW_ITEM_TYPE_UDP,
 582         RTE_FLOW_ITEM_TYPE_GTPU,
 583         RTE_FLOW_ITEM_TYPE_GTP_PSC,
 584         RTE_FLOW_ITEM_TYPE_IPV4,
 585         RTE_FLOW_ITEM_TYPE_TCP,
 586         RTE_FLOW_ITEM_TYPE_END,
 587 };
 588
 589 enum rte_flow_item_type iavf_pattern_eth_ipv4_gtpu_eh_ipv4_icmp[] = {
 590         RTE_FLOW_ITEM_TYPE_ETH,
 591         RTE_FLOW_ITEM_TYPE_IPV4,
 592         RTE_FLOW_ITEM_TYPE_UDP,
 593         RTE_FLOW_ITEM_TYPE_GTPU,
 594         RTE_FLOW_ITEM_TYPE_GTP_PSC,
 595         RTE_FLOW_ITEM_TYPE_IPV4,
 596         RTE_FLOW_ITEM_TYPE_ICMP,
 597         RTE_FLOW_ITEM_TYPE_END,
 598 };
 599
 600 /* IPV4 GTPU EH IPv6 */
 601 enum rte_flow_item_type iavf_pattern_eth_ipv4_gtpu_eh_ipv6[] = {
 602         RTE_FLOW_ITEM_TYPE_ETH,
 603         RTE_FLOW_ITEM_TYPE_IPV4,
 604         RTE_FLOW_ITEM_TYPE_UDP,
 605         RTE_FLOW_ITEM_TYPE_GTPU,
 606         RTE_FLOW_ITEM_TYPE_GTP_PSC,
 607         RTE_FLOW_ITEM_TYPE_IPV6,
 608         RTE_FLOW_ITEM_TYPE_END,
 609 };
 610
 611 enum rte_flow_item_type iavf_pattern_eth_ipv4_gtpu_eh_ipv6_udp[] = {
 612         RTE_FLOW_ITEM_TYPE_ETH,
 613         RTE_FLOW_ITEM_TYPE_IPV4,
 614         RTE_FLOW_ITEM_TYPE_UDP,
 615         RTE_FLOW_ITEM_TYPE_GTPU,
 616         RTE_FLOW_ITEM_TYPE_GTP_PSC,
 617         RTE_FLOW_ITEM_TYPE_IPV6,
 618         RTE_FLOW_ITEM_TYPE_UDP,
 619         RTE_FLOW_ITEM_TYPE_END,
 620 };
 621
 622 enum rte_flow_item_type iavf_pattern_eth_ipv4_gtpu_eh_ipv6_tcp[] = {
 623         RTE_FLOW_ITEM_TYPE_ETH,
 624         RTE_FLOW_ITEM_TYPE_IPV4,
 625         RTE_FLOW_ITEM_TYPE_UDP,
 626         RTE_FLOW_ITEM_TYPE_GTPU,
 627         RTE_FLOW_ITEM_TYPE_GTP_PSC,
 628         RTE_FLOW_ITEM_TYPE_IPV6,
 629         RTE_FLOW_ITEM_TYPE_TCP,
 630         RTE_FLOW_ITEM_TYPE_END,
 631 };
 632
 633 enum rte_flow_item_type iavf_pattern_eth_ipv4_gtpu_eh_ipv6_icmp[] = {
 634         RTE_FLOW_ITEM_TYPE_ETH,
 635         RTE_FLOW_ITEM_TYPE_IPV4,
 636         RTE_FLOW_ITEM_TYPE_UDP,
 637         RTE_FLOW_ITEM_TYPE_GTPU,
 638         RTE_FLOW_ITEM_TYPE_GTP_PSC,
 639         RTE_FLOW_ITEM_TYPE_IPV6,
 640         RTE_FLOW_ITEM_TYPE_ICMP,
 641         RTE_FLOW_ITEM_TYPE_END,
 642 };
 643
 644 /* IPV6 GTPU EH IPv4 */
 645 enum rte_flow_item_type iavf_pattern_eth_ipv6_gtpu_eh_ipv4[] = {
 646         RTE_FLOW_ITEM_TYPE_ETH,
 647         RTE_FLOW_ITEM_TYPE_IPV6,
 648         RTE_FLOW_ITEM_TYPE_UDP,
 649         RTE_FLOW_ITEM_TYPE_GTPU,
 650         RTE_FLOW_ITEM_TYPE_GTP_PSC,
 651         RTE_FLOW_ITEM_TYPE_IPV4,
 652         RTE_FLOW_ITEM_TYPE_END,
 653 };
 654
 655 enum rte_flow_item_type iavf_pattern_eth_ipv6_gtpu_eh_ipv4_udp[] = {
 656         RTE_FLOW_ITEM_TYPE_ETH,
 657         RTE_FLOW_ITEM_TYPE_IPV6,
 658         RTE_FLOW_ITEM_TYPE_UDP,
 659         RTE_FLOW_ITEM_TYPE_GTPU,
 660         RTE_FLOW_ITEM_TYPE_GTP_PSC,
 661         RTE_FLOW_ITEM_TYPE_IPV4,
 662         RTE_FLOW_ITEM_TYPE_UDP,
 663         RTE_FLOW_ITEM_TYPE_END,
 664 };
 665
 666 enum rte_flow_item_type iavf_pattern_eth_ipv6_gtpu_eh_ipv4_tcp[] = {
 667         RTE_FLOW_ITEM_TYPE_ETH,
 668         RTE_FLOW_ITEM_TYPE_IPV6,
 669         RTE_FLOW_ITEM_TYPE_UDP,
 670         RTE_FLOW_ITEM_TYPE_GTPU,
 671         RTE_FLOW_ITEM_TYPE_GTP_PSC,
 672         RTE_FLOW_ITEM_TYPE_IPV4,
 673         RTE_FLOW_ITEM_TYPE_TCP,
 674         RTE_FLOW_ITEM_TYPE_END,
 675 };
 676
 677 enum rte_flow_item_type iavf_pattern_eth_ipv6_gtpu_eh_ipv4_icmp[] = {
 678         RTE_FLOW_ITEM_TYPE_ETH,
 679         RTE_FLOW_ITEM_TYPE_IPV6,
 680         RTE_FLOW_ITEM_TYPE_UDP,
 681         RTE_FLOW_ITEM_TYPE_GTPU,
 682         RTE_FLOW_ITEM_TYPE_GTP_PSC,
 683         RTE_FLOW_ITEM_TYPE_IPV4,
 684         RTE_FLOW_ITEM_TYPE_ICMP,
 685         RTE_FLOW_ITEM_TYPE_END,
 686 };
 687
 688 /* IPV6 GTPU EH IPv6 */
 689 enum rte_flow_item_type iavf_pattern_eth_ipv6_gtpu_eh_ipv6[] = {
 690         RTE_FLOW_ITEM_TYPE_ETH,
 691         RTE_FLOW_ITEM_TYPE_IPV6,
 692         RTE_FLOW_ITEM_TYPE_UDP,
 693         RTE_FLOW_ITEM_TYPE_GTPU,
 694         RTE_FLOW_ITEM_TYPE_GTP_PSC,
 695         RTE_FLOW_ITEM_TYPE_IPV6,
 696         RTE_FLOW_ITEM_TYPE_END,
 697 };
 698
 699 enum rte_flow_item_type iavf_pattern_eth_ipv6_gtpu_eh_ipv6_udp[] = {
 700         RTE_FLOW_ITEM_TYPE_ETH,
 701         RTE_FLOW_ITEM_TYPE_IPV6,
 702         RTE_FLOW_ITEM_TYPE_UDP,
 703         RTE_FLOW_ITEM_TYPE_GTPU,
 704         RTE_FLOW_ITEM_TYPE_GTP_PSC,
 705         RTE_FLOW_ITEM_TYPE_IPV6,
 706         RTE_FLOW_ITEM_TYPE_UDP,
 707         RTE_FLOW_ITEM_TYPE_END,
 708 };
 709
 710 enum rte_flow_item_type iavf_pattern_eth_ipv6_gtpu_eh_ipv6_tcp[] = {
 711         RTE_FLOW_ITEM_TYPE_ETH,
 712         RTE_FLOW_ITEM_TYPE_IPV6,
 713         RTE_FLOW_ITEM_TYPE_UDP,
 714         RTE_FLOW_ITEM_TYPE_GTPU,
 715         RTE_FLOW_ITEM_TYPE_GTP_PSC,
 716         RTE_FLOW_ITEM_TYPE_IPV6,
 717         RTE_FLOW_ITEM_TYPE_TCP,
 718         RTE_FLOW_ITEM_TYPE_END,
 719 };
 720
 721 enum rte_flow_item_type iavf_pattern_eth_ipv6_gtpu_eh_ipv6_icmp[] = {
 722         RTE_FLOW_ITEM_TYPE_ETH,
 723         RTE_FLOW_ITEM_TYPE_IPV6,
 724         RTE_FLOW_ITEM_TYPE_UDP,
 725         RTE_FLOW_ITEM_TYPE_GTPU,
 726         RTE_FLOW_ITEM_TYPE_GTP_PSC,
 727         RTE_FLOW_ITEM_TYPE_IPV6,
 728         RTE_FLOW_ITEM_TYPE_ICMP,
 729         RTE_FLOW_ITEM_TYPE_END,
 730 };
 731
 732 /* ESP */
 733 enum rte_flow_item_type iavf_pattern_eth_ipv4_esp[] = {
 734         RTE_FLOW_ITEM_TYPE_ETH,
 735         RTE_FLOW_ITEM_TYPE_IPV4,
 736         RTE_FLOW_ITEM_TYPE_ESP,
 737         RTE_FLOW_ITEM_TYPE_END,
 738 };
 739
 740 enum rte_flow_item_type iavf_pattern_eth_ipv4_udp_esp[] = {
 741         RTE_FLOW_ITEM_TYPE_ETH,
 742         RTE_FLOW_ITEM_TYPE_IPV4,
 743         RTE_FLOW_ITEM_TYPE_UDP,
 744         RTE_FLOW_ITEM_TYPE_ESP,
 745         RTE_FLOW_ITEM_TYPE_END,
 746 };
 747
 748 enum rte_flow_item_type iavf_pattern_eth_ipv6_esp[] = {
 749         RTE_FLOW_ITEM_TYPE_ETH,
 750         RTE_FLOW_ITEM_TYPE_IPV6,
 751         RTE_FLOW_ITEM_TYPE_ESP,
 752         RTE_FLOW_ITEM_TYPE_END,
 753 };
 754
 755 enum rte_flow_item_type iavf_pattern_eth_ipv6_udp_esp[] = {
 756         RTE_FLOW_ITEM_TYPE_ETH,
 757         RTE_FLOW_ITEM_TYPE_IPV6,
 758         RTE_FLOW_ITEM_TYPE_UDP,
 759         RTE_FLOW_ITEM_TYPE_ESP,
 760         RTE_FLOW_ITEM_TYPE_END,
 761 };
 762
 763 /* AH */
 764 enum rte_flow_item_type iavf_pattern_eth_ipv4_ah[] = {
 765         RTE_FLOW_ITEM_TYPE_ETH,
 766         RTE_FLOW_ITEM_TYPE_IPV4,
 767         RTE_FLOW_ITEM_TYPE_AH,
 768         RTE_FLOW_ITEM_TYPE_END,
 769 };
 770
 771 enum rte_flow_item_type iavf_pattern_eth_ipv6_ah[] = {
 772         RTE_FLOW_ITEM_TYPE_ETH,
 773         RTE_FLOW_ITEM_TYPE_IPV6,
 774         RTE_FLOW_ITEM_TYPE_AH,
 775         RTE_FLOW_ITEM_TYPE_END,
 776 };
 777
 778 /* L2TPV3 */
 779 enum rte_flow_item_type iavf_pattern_eth_ipv4_l2tpv3[] = {
 780         RTE_FLOW_ITEM_TYPE_ETH,
 781         RTE_FLOW_ITEM_TYPE_IPV4,
 782         RTE_FLOW_ITEM_TYPE_L2TPV3OIP,
 783         RTE_FLOW_ITEM_TYPE_END,
 784 };
 785
 786 enum rte_flow_item_type iavf_pattern_eth_ipv6_l2tpv3[] = {
 787         RTE_FLOW_ITEM_TYPE_ETH,
 788         RTE_FLOW_ITEM_TYPE_IPV6,
 789         RTE_FLOW_ITEM_TYPE_L2TPV3OIP,
 790         RTE_FLOW_ITEM_TYPE_END,
 791 };
 792
 793 /* PFCP */
 794 enum rte_flow_item_type iavf_pattern_eth_ipv4_pfcp[] = {
 795         RTE_FLOW_ITEM_TYPE_ETH,
 796         RTE_FLOW_ITEM_TYPE_IPV4,
 797         RTE_FLOW_ITEM_TYPE_UDP,
 798         RTE_FLOW_ITEM_TYPE_PFCP,
 799         RTE_FLOW_ITEM_TYPE_END,
 800 };
 801
 802 enum rte_flow_item_type iavf_pattern_eth_ipv6_pfcp[] = {
 803         RTE_FLOW_ITEM_TYPE_ETH,
 804         RTE_FLOW_ITEM_TYPE_IPV6,
 805         RTE_FLOW_ITEM_TYPE_UDP,
 806         RTE_FLOW_ITEM_TYPE_PFCP,
 807         RTE_FLOW_ITEM_TYPE_END,
 808 };
 809
 810 /* ECPRI */
 811 enum rte_flow_item_type iavf_pattern_eth_ecpri[] = {
 812         RTE_FLOW_ITEM_TYPE_ETH,
 813         RTE_FLOW_ITEM_TYPE_ECPRI,
 814         RTE_FLOW_ITEM_TYPE_END,
 815 };
 816
 817 enum rte_flow_item_type iavf_pattern_eth_ipv4_ecpri[] = {
 818         RTE_FLOW_ITEM_TYPE_ETH,
 819         RTE_FLOW_ITEM_TYPE_IPV4,
 820         RTE_FLOW_ITEM_TYPE_UDP,
 821         RTE_FLOW_ITEM_TYPE_ECPRI,
 822         RTE_FLOW_ITEM_TYPE_END,
 823 };
 824
 825 /* GRE */
 826 enum rte_flow_item_type iavf_pattern_eth_ipv4_gre_ipv4[] = {
 827         RTE_FLOW_ITEM_TYPE_ETH,
 828         RTE_FLOW_ITEM_TYPE_IPV4,
 829         RTE_FLOW_ITEM_TYPE_GRE,
 830         RTE_FLOW_ITEM_TYPE_IPV4,
 831         RTE_FLOW_ITEM_TYPE_END,
 832 };
 833
 834 enum rte_flow_item_type iavf_pattern_eth_ipv4_gre_ipv6[] = {
 835         RTE_FLOW_ITEM_TYPE_ETH,
 836         RTE_FLOW_ITEM_TYPE_IPV4,
 837         RTE_FLOW_ITEM_TYPE_GRE,
 838         RTE_FLOW_ITEM_TYPE_IPV6,
 839         RTE_FLOW_ITEM_TYPE_END,
 840 };
 841
 842 enum rte_flow_item_type iavf_pattern_eth_ipv6_gre_ipv4[] = {
 843         RTE_FLOW_ITEM_TYPE_ETH,
 844         RTE_FLOW_ITEM_TYPE_IPV6,
 845         RTE_FLOW_ITEM_TYPE_GRE,
 846         RTE_FLOW_ITEM_TYPE_IPV4,
 847         RTE_FLOW_ITEM_TYPE_END,
 848 };
 849
 850 enum rte_flow_item_type iavf_pattern_eth_ipv6_gre_ipv6[] = {
 851         RTE_FLOW_ITEM_TYPE_ETH,
 852         RTE_FLOW_ITEM_TYPE_IPV6,
 853         RTE_FLOW_ITEM_TYPE_GRE,
 854         RTE_FLOW_ITEM_TYPE_IPV6,
 855         RTE_FLOW_ITEM_TYPE_END,
 856 };
 857
 858 enum rte_flow_item_type iavf_pattern_eth_ipv4_gre_ipv4_tcp[] = {
 859         RTE_FLOW_ITEM_TYPE_ETH,
 860         RTE_FLOW_ITEM_TYPE_IPV4,
 861         RTE_FLOW_ITEM_TYPE_GRE,
 862         RTE_FLOW_ITEM_TYPE_IPV4,
 863         RTE_FLOW_ITEM_TYPE_TCP,
 864         RTE_FLOW_ITEM_TYPE_END,
 865 };
 866
 867 enum rte_flow_item_type iavf_pattern_eth_ipv4_gre_ipv4_udp[] = {
 868         RTE_FLOW_ITEM_TYPE_ETH,
 869         RTE_FLOW_ITEM_TYPE_IPV4,
 870         RTE_FLOW_ITEM_TYPE_GRE,
 871         RTE_FLOW_ITEM_TYPE_IPV4,
 872         RTE_FLOW_ITEM_TYPE_UDP,
 873         RTE_FLOW_ITEM_TYPE_END,
 874 };
 875
 876 enum rte_flow_item_type iavf_pattern_eth_ipv4_gre_ipv6_tcp[] = {
 877         RTE_FLOW_ITEM_TYPE_ETH,
 878         RTE_FLOW_ITEM_TYPE_IPV4,
 879         RTE_FLOW_ITEM_TYPE_GRE,
 880         RTE_FLOW_ITEM_TYPE_IPV6,
 881         RTE_FLOW_ITEM_TYPE_TCP,
 882         RTE_FLOW_ITEM_TYPE_END,
 883 };
 884
 885 enum rte_flow_item_type iavf_pattern_eth_ipv4_gre_ipv6_udp[] = {
 886         RTE_FLOW_ITEM_TYPE_ETH,
 887         RTE_FLOW_ITEM_TYPE_IPV4,
 888         RTE_FLOW_ITEM_TYPE_GRE,
 889         RTE_FLOW_ITEM_TYPE_IPV6,
 890         RTE_FLOW_ITEM_TYPE_UDP,
 891         RTE_FLOW_ITEM_TYPE_END,
 892 };
 893
 894 enum rte_flow_item_type iavf_pattern_eth_ipv6_gre_ipv4_tcp[] = {
 895         RTE_FLOW_ITEM_TYPE_ETH,
 896         RTE_FLOW_ITEM_TYPE_IPV6,
 897         RTE_FLOW_ITEM_TYPE_GRE,
 898         RTE_FLOW_ITEM_TYPE_IPV4,
 899         RTE_FLOW_ITEM_TYPE_TCP,
 900         RTE_FLOW_ITEM_TYPE_END,
 901 };
 902
 903 enum rte_flow_item_type iavf_pattern_eth_ipv6_gre_ipv4_udp[] = {
 904         RTE_FLOW_ITEM_TYPE_ETH,
 905         RTE_FLOW_ITEM_TYPE_IPV6,
 906         RTE_FLOW_ITEM_TYPE_GRE,
 907         RTE_FLOW_ITEM_TYPE_IPV4,
 908         RTE_FLOW_ITEM_TYPE_UDP,
 909         RTE_FLOW_ITEM_TYPE_END,
 910 };
 911
 912 enum rte_flow_item_type iavf_pattern_eth_ipv6_gre_ipv6_tcp[] = {
 913         RTE_FLOW_ITEM_TYPE_ETH,
 914         RTE_FLOW_ITEM_TYPE_IPV6,
 915         RTE_FLOW_ITEM_TYPE_GRE,
 916         RTE_FLOW_ITEM_TYPE_IPV6,
 917         RTE_FLOW_ITEM_TYPE_TCP,
 918         RTE_FLOW_ITEM_TYPE_END,
 919 };
 920
 921 enum rte_flow_item_type iavf_pattern_eth_ipv6_gre_ipv6_udp[] = {
 922         RTE_FLOW_ITEM_TYPE_ETH,
 923         RTE_FLOW_ITEM_TYPE_IPV6,
 924         RTE_FLOW_ITEM_TYPE_GRE,
 925         RTE_FLOW_ITEM_TYPE_IPV6,
 926         RTE_FLOW_ITEM_TYPE_UDP,
 927         RTE_FLOW_ITEM_TYPE_END,
 928 };
 929
 930 typedef struct iavf_flow_engine * (*parse_engine_t)(struct iavf_adapter *ad,
 931                 struct rte_flow *flow,
 932                 struct iavf_parser_list *parser_list,
 933                 const struct rte_flow_item pattern[],
 934                 const struct rte_flow_action actions[],
 935                 struct rte_flow_error *error);
 936
 937 void
 938 iavf_register_flow_engine(struct iavf_flow_engine *engine)
 939 {
 940         TAILQ_INSERT_TAIL(&engine_list, engine, node);
 941 }
 942
 943 int
 944 iavf_flow_init(struct iavf_adapter *ad)
 945 {
 946         int ret;
 947         struct iavf_info *vf = IAVF_DEV_PRIVATE_TO_VF(ad);
 948         void *temp;
 949         struct iavf_flow_engine *engine;
 950
 951         TAILQ_INIT(&vf->flow_list);
 952         TAILQ_INIT(&vf->rss_parser_list);
 953         TAILQ_INIT(&vf->dist_parser_list);
 954         rte_spinlock_init(&vf->flow_ops_lock);
 955
 956         TAILQ_FOREACH_SAFE(engine, &engine_list, node, temp) {
 957                 if (engine->init == NULL) {
 958                         PMD_INIT_LOG(ERR, "Invalid engine type (%d)",
 959                                      engine->type);
 960                         return -ENOTSUP;
 961                 }
 962
 963                 ret = engine->init(ad);
 964                 if (ret && ret != -ENOTSUP) {
 965                         PMD_INIT_LOG(ERR, "Failed to initialize engine %d",
 966                                      engine->type);
 967                         return ret;
 968                 }
 969         }
 970         return 0;
 971 }
 972
 973 void
 974 iavf_flow_uninit(struct iavf_adapter *ad)
 975 {
 976         struct iavf_info *vf = IAVF_DEV_PRIVATE_TO_VF(ad);
 977         struct iavf_flow_engine *engine;
 978         struct rte_flow *p_flow;
 979         struct iavf_flow_parser_node *p_parser;
 980         void *temp;
 981
 982         TAILQ_FOREACH_SAFE(engine, &engine_list, node, temp) {
 983                 if (engine->uninit)
 984                         engine->uninit(ad);
 985         }
 986
 987         /* Remove all flows */
 988         while ((p_flow = TAILQ_FIRST(&vf->flow_list))) {
 989                 TAILQ_REMOVE(&vf->flow_list, p_flow, node);
 990                 if (p_flow->engine->free)
 991                         p_flow->engine->free(p_flow);
 992                 rte_free(p_flow);
 993         }
 994
 995         /* Cleanup parser list */
 996         while ((p_parser = TAILQ_FIRST(&vf->rss_parser_list))) {
 997                 TAILQ_REMOVE(&vf->rss_parser_list, p_parser, node);
 998                 rte_free(p_parser);
 999         }
1000
1001         while ((p_parser = TAILQ_FIRST(&vf->dist_parser_list))) {
1002                 TAILQ_REMOVE(&vf->dist_parser_list, p_parser, node);
1003                 rte_free(p_parser);
1004         }
1005 }
1006
1007 int
1008 iavf_register_parser(struct iavf_flow_parser *parser,
1009                      struct iavf_adapter *ad)
1010 {
1011         struct iavf_parser_list *list = NULL;
1012         struct iavf_flow_parser_node *parser_node;
1013         struct iavf_info *vf = IAVF_DEV_PRIVATE_TO_VF(ad);
1014
1015         parser_node = rte_zmalloc("iavf_parser", sizeof(*parser_node), 0);
1016         if (parser_node == NULL) {
1017                 PMD_DRV_LOG(ERR, "Failed to allocate memory.");
1018                 return -ENOMEM;
1019         }
1020         parser_node->parser = parser;
1021
1022         if (parser->engine->type == IAVF_FLOW_ENGINE_HASH) {
1023                 list = &vf->rss_parser_list;
1024                 TAILQ_INSERT_TAIL(list, parser_node, node);
1025         } else if (parser->engine->type == IAVF_FLOW_ENGINE_FDIR) {
1026                 list = &vf->dist_parser_list;
1027                 TAILQ_INSERT_HEAD(list, parser_node, node);
1028         } else {
1029                 return -EINVAL;
1030         }
1031
1032         return 0;
1033 }
1034
1035 void
1036 iavf_unregister_parser(struct iavf_flow_parser *parser,
1037                        struct iavf_adapter *ad)
1038 {
1039         struct iavf_parser_list *list = NULL;
1040         struct iavf_flow_parser_node *p_parser;
1041         struct iavf_info *vf = IAVF_DEV_PRIVATE_TO_VF(ad);
1042         void *temp;
1043
1044         if (parser->engine->type == IAVF_FLOW_ENGINE_HASH)
1045                 list = &vf->rss_parser_list;
1046         else if (parser->engine->type == IAVF_FLOW_ENGINE_FDIR)
1047                 list = &vf->dist_parser_list;
1048
1049         if (list == NULL)
1050                 return;
1051
1052         TAILQ_FOREACH_SAFE(p_parser, list, node, temp) {
1053                 if (p_parser->parser->engine->type == parser->engine->type) {
1054                         TAILQ_REMOVE(list, p_parser, node);
1055                         rte_free(p_parser);
1056                 }
1057         }
1058 }
1059
1060 static int
1061 iavf_flow_valid_attr(const struct rte_flow_attr *attr,
1062                      struct rte_flow_error *error)
1063 {
1064         /* Must be input direction */
1065         if (!attr->ingress) {
1066                 rte_flow_error_set(error, EINVAL,
1067                                 RTE_FLOW_ERROR_TYPE_ATTR_INGRESS,
1068                                 attr, "Only support ingress.");
1069                 return -rte_errno;
1070         }
1071
1072         /* Not supported */
1073         if (attr->egress) {
1074                 rte_flow_error_set(error, EINVAL,
1075                                 RTE_FLOW_ERROR_TYPE_ATTR_EGRESS,
1076                                 attr, "Not support egress.");
1077                 return -rte_errno;
1078         }
1079
1080         /* Not supported */
1081         if (attr->priority) {
1082                 rte_flow_error_set(error, EINVAL,
1083                                 RTE_FLOW_ERROR_TYPE_ATTR_PRIORITY,
1084                                 attr, "Not support priority.");
1085                 return -rte_errno;
1086         }
1087
1088         /* Not supported */
1089         if (attr->group) {
1090                 rte_flow_error_set(error, EINVAL,
1091                                 RTE_FLOW_ERROR_TYPE_ATTR_GROUP,
1092                                 attr, "Not support group.");
1093                 return -rte_errno;
1094         }
1095
1096         return 0;
1097 }
1098
1099 /* Find the first VOID or non-VOID item pointer */
1100 static const struct rte_flow_item *
1101 iavf_find_first_item(const struct rte_flow_item *item, bool is_void)
1102 {
1103         bool is_find;
1104
1105         while (item->type != RTE_FLOW_ITEM_TYPE_END) {
1106                 if (is_void)
1107                         is_find = item->type == RTE_FLOW_ITEM_TYPE_VOID;
1108                 else
1109                         is_find = item->type != RTE_FLOW_ITEM_TYPE_VOID;
1110                 if (is_find)
1111                         break;
1112                 item++;
1113         }
1114         return item;
1115 }
1116
1117 /* Skip all VOID items of the pattern */
1118 static void
1119 iavf_pattern_skip_void_item(struct rte_flow_item *items,
1120                         const struct rte_flow_item *pattern)
1121 {
1122         uint32_t cpy_count = 0;
1123         const struct rte_flow_item *pb = pattern, *pe = pattern;
1124
1125         for (;;) {
1126                 /* Find a non-void item first */
1127                 pb = iavf_find_first_item(pb, false);
1128                 if (pb->type == RTE_FLOW_ITEM_TYPE_END) {
1129                         pe = pb;
1130                         break;
1131                 }
1132
1133                 /* Find a void item */
1134                 pe = iavf_find_first_item(pb + 1, true);
1135
1136                 cpy_count = pe - pb;
1137                 rte_memcpy(items, pb, sizeof(struct rte_flow_item) * cpy_count);
1138
1139                 items += cpy_count;
1140
1141                 if (pe->type == RTE_FLOW_ITEM_TYPE_END)
1142                         break;
1143
1144                 pb = pe + 1;
1145         }
1146         /* Copy the END item. */
1147         rte_memcpy(items, pe, sizeof(struct rte_flow_item));
1148 }
1149
1150 /* Check if the pattern matches a supported item type array */
1151 static bool
1152 iavf_match_pattern(enum rte_flow_item_type *item_array,
1153                    const struct rte_flow_item *pattern)
1154 {
1155         const struct rte_flow_item *item = pattern;
1156
1157         while ((*item_array == item->type) &&
1158                (*item_array != RTE_FLOW_ITEM_TYPE_END)) {
1159                 item_array++;
1160                 item++;
1161         }
1162
1163         return (*item_array == RTE_FLOW_ITEM_TYPE_END &&
1164                 item->type == RTE_FLOW_ITEM_TYPE_END);
1165 }
1166
1167 struct iavf_pattern_match_item *
1168 iavf_search_pattern_match_item(const struct rte_flow_item pattern[],
1169                 struct iavf_pattern_match_item *array,
1170                 uint32_t array_len,
1171                 struct rte_flow_error *error)
1172 {
1173         uint16_t i = 0;
1174         struct iavf_pattern_match_item *pattern_match_item;
1175         /* need free by each filter */
1176         struct rte_flow_item *items; /* used for pattern without VOID items */
1177         uint32_t item_num = 0; /* non-void item number */
1178
1179         /* Get the non-void item number of pattern */
1180         while ((pattern + i)->type != RTE_FLOW_ITEM_TYPE_END) {
1181                 if ((pattern + i)->type != RTE_FLOW_ITEM_TYPE_VOID)
1182                         item_num++;
1183                 i++;
1184         }
1185         item_num++;
1186
1187         items = rte_zmalloc("iavf_pattern",
1188                             item_num * sizeof(struct rte_flow_item), 0);
1189         if (!items) {
1190                 rte_flow_error_set(error, ENOMEM, RTE_FLOW_ERROR_TYPE_ITEM_NUM,
1191                                    NULL, "No memory for PMD internal items.");
1192                 return NULL;
1193         }
1194         pattern_match_item = rte_zmalloc("iavf_pattern_match_item",
1195                                 sizeof(struct iavf_pattern_match_item), 0);
1196         if (!pattern_match_item) {
1197                 rte_flow_error_set(error, ENOMEM, RTE_FLOW_ERROR_TYPE_HANDLE,
1198                                    NULL, "Failed to allocate memory.");
1199                 return NULL;
1200         }
1201
1202         iavf_pattern_skip_void_item(items, pattern);
1203
1204         for (i = 0; i < array_len; i++)
1205                 if (iavf_match_pattern(array[i].pattern_list,
1206                                        items)) {
1207                         pattern_match_item->input_set_mask =
1208                                 array[i].input_set_mask;
1209                         pattern_match_item->pattern_list =
1210                                 array[i].pattern_list;
1211                         pattern_match_item->meta = array[i].meta;
1212                         rte_free(items);
1213                         return pattern_match_item;
1214                 }
1215         rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_ITEM,
1216                            pattern, "Unsupported pattern");
1217
1218         rte_free(items);
1219         rte_free(pattern_match_item);
1220         return NULL;
1221 }
1222
1223 static struct iavf_flow_engine *
1224 iavf_parse_engine_create(struct iavf_adapter *ad,
1225                 struct rte_flow *flow,
1226                 struct iavf_parser_list *parser_list,
1227                 const struct rte_flow_item pattern[],
1228                 const struct rte_flow_action actions[],
1229                 struct rte_flow_error *error)
1230 {
1231         struct iavf_flow_engine *engine = NULL;
1232         struct iavf_flow_parser_node *parser_node;
1233         void *temp;
1234         void *meta = NULL;
1235
1236         TAILQ_FOREACH_SAFE(parser_node, parser_list, node, temp) {
1237                 if (parser_node->parser->parse_pattern_action(ad,
1238                                 parser_node->parser->array,
1239                                 parser_node->parser->array_len,
1240                                 pattern, actions, &meta, error) < 0)
1241                         continue;
1242
1243                 engine = parser_node->parser->engine;
1244
1245                 RTE_ASSERT(engine->create != NULL);
1246                 if (!(engine->create(ad, flow, meta, error)))
1247                         return engine;
1248         }
1249         return NULL;
1250 }
1251
1252 static struct iavf_flow_engine *
1253 iavf_parse_engine_validate(struct iavf_adapter *ad,
1254                 struct rte_flow *flow,
1255                 struct iavf_parser_list *parser_list,
1256                 const struct rte_flow_item pattern[],
1257                 const struct rte_flow_action actions[],
1258                 struct rte_flow_error *error)
1259 {
1260         struct iavf_flow_engine *engine = NULL;
1261         struct iavf_flow_parser_node *parser_node;
1262         void *temp;
1263         void *meta = NULL;
1264
1265         TAILQ_FOREACH_SAFE(parser_node, parser_list, node, temp) {
1266                 if (parser_node->parser->parse_pattern_action(ad,
1267                                 parser_node->parser->array,
1268                                 parser_node->parser->array_len,
1269                                 pattern, actions, &meta,  error) < 0)
1270                         continue;
1271
1272                 engine = parser_node->parser->engine;
1273                 if (engine->validation == NULL) {
1274                         rte_flow_error_set(error, EINVAL,
1275                                 RTE_FLOW_ERROR_TYPE_HANDLE,
1276                                 NULL, "Validation not support");
1277                         continue;
1278                 }
1279
1280                 if (engine->validation(ad, flow, meta, error)) {
1281                         rte_flow_error_set(error, EINVAL,
1282                                 RTE_FLOW_ERROR_TYPE_HANDLE,
1283                                 NULL, "Validation failed");
1284                         break;
1285                 }
1286         }
1287         return engine;
1288 }
1289
1290
1291 static int
1292 iavf_flow_process_filter(struct rte_eth_dev *dev,
1293                 struct rte_flow *flow,
1294                 const struct rte_flow_attr *attr,
1295                 const struct rte_flow_item pattern[],
1296                 const struct rte_flow_action actions[],
1297                 struct iavf_flow_engine **engine,
1298                 parse_engine_t iavf_parse_engine,
1299                 struct rte_flow_error *error)
1300 {
1301         int ret = IAVF_ERR_CONFIG;
1302         struct iavf_adapter *ad =
1303                 IAVF_DEV_PRIVATE_TO_ADAPTER(dev->data->dev_private);
1304         struct iavf_info *vf = IAVF_DEV_PRIVATE_TO_VF(ad);
1305
1306         if (!pattern) {
1307                 rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_ITEM_NUM,
1308                                    NULL, "NULL pattern.");
1309                 return -rte_errno;
1310         }
1311
1312         if (!actions) {
1313                 rte_flow_error_set(error, EINVAL,
1314                                    RTE_FLOW_ERROR_TYPE_ACTION_NUM,
1315                                    NULL, "NULL action.");
1316                 return -rte_errno;
1317         }
1318
1319         if (!attr) {
1320                 rte_flow_error_set(error, EINVAL,
1321                                    RTE_FLOW_ERROR_TYPE_ATTR,
1322                                    NULL, "NULL attribute.");
1323                 return -rte_errno;
1324         }
1325
1326         ret = iavf_flow_valid_attr(attr, error);
1327         if (ret)
1328                 return ret;
1329
1330         *engine = iavf_parse_engine(ad, flow, &vf->rss_parser_list, pattern,
1331                                     actions, error);
1332         if (*engine)
1333                 return 0;
1334
1335         *engine = iavf_parse_engine(ad, flow, &vf->dist_parser_list, pattern,
1336                                     actions, error);
1337
1338         if (!*engine) {
1339                 rte_flow_error_set(error, EINVAL,
1340                                    RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
1341                                    "Failed to create parser engine.");
1342                 return -rte_errno;
1343         }
1344
1345         return 0;
1346 }
1347
1348 static int
1349 iavf_flow_validate(struct rte_eth_dev *dev,
1350                 const struct rte_flow_attr *attr,
1351                 const struct rte_flow_item pattern[],
1352                 const struct rte_flow_action actions[],
1353                 struct rte_flow_error *error)
1354 {
1355         struct iavf_flow_engine *engine;
1356
1357         return iavf_flow_process_filter(dev, NULL, attr, pattern, actions,
1358                         &engine, iavf_parse_engine_validate, error);
1359 }
1360
1361 static struct rte_flow *
1362 iavf_flow_create(struct rte_eth_dev *dev,
1363                  const struct rte_flow_attr *attr,
1364                  const struct rte_flow_item pattern[],
1365                  const struct rte_flow_action actions[],
1366                  struct rte_flow_error *error)
1367 {
1368         struct iavf_adapter *ad =
1369                 IAVF_DEV_PRIVATE_TO_ADAPTER(dev->data->dev_private);
1370         struct iavf_info *vf = IAVF_DEV_PRIVATE_TO_VF(ad);
1371         struct iavf_flow_engine *engine = NULL;
1372         struct rte_flow *flow = NULL;
1373         int ret;
1374
1375         flow = rte_zmalloc("iavf_flow", sizeof(struct rte_flow), 0);
1376         if (!flow) {
1377                 rte_flow_error_set(error, ENOMEM,
1378                                    RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
1379                                    "Failed to allocate memory");
1380                 return flow;
1381         }
1382
1383         ret = iavf_flow_process_filter(dev, flow, attr, pattern, actions,
1384                         &engine, iavf_parse_engine_create, error);
1385         if (ret < 0) {
1386                 PMD_DRV_LOG(ERR, "Failed to create flow");
1387                 rte_free(flow);
1388                 flow = NULL;
1389                 goto free_flow;
1390         }
1391
1392         flow->engine = engine;
1393         TAILQ_INSERT_TAIL(&vf->flow_list, flow, node);
1394         PMD_DRV_LOG(INFO, "Succeeded to create (%d) flow", engine->type);
1395
1396 free_flow:
1397         rte_spinlock_unlock(&vf->flow_ops_lock);
1398         return flow;
1399 }
1400
1401 static bool
1402 iavf_flow_is_valid(struct rte_flow *flow)
1403 {
1404         struct iavf_flow_engine *engine;
1405         void *temp;
1406
1407         if (flow && flow->engine) {
1408                 TAILQ_FOREACH_SAFE(engine, &engine_list, node, temp) {
1409                         if (engine == flow->engine)
1410                                 return true;
1411                 }
1412         }
1413
1414         return false;
1415 }
1416
1417 static int
1418 iavf_flow_destroy(struct rte_eth_dev *dev,
1419                   struct rte_flow *flow,
1420                   struct rte_flow_error *error)
1421 {
1422         struct iavf_adapter *ad =
1423                 IAVF_DEV_PRIVATE_TO_ADAPTER(dev->data->dev_private);
1424         struct iavf_info *vf = IAVF_DEV_PRIVATE_TO_VF(ad);
1425         int ret = 0;
1426
1427         if (!iavf_flow_is_valid(flow) || !flow->engine->destroy) {
1428                 rte_flow_error_set(error, EINVAL,
1429                                    RTE_FLOW_ERROR_TYPE_HANDLE,
1430                                    NULL, "Invalid flow destroy");
1431                 return -rte_errno;
1432         }
1433
1434         rte_spinlock_lock(&vf->flow_ops_lock);
1435
1436         ret = flow->engine->destroy(ad, flow, error);
1437
1438         if (!ret) {
1439                 TAILQ_REMOVE(&vf->flow_list, flow, node);
1440                 rte_free(flow);
1441         } else {
1442                 PMD_DRV_LOG(ERR, "Failed to destroy flow");
1443         }
1444
1445         rte_spinlock_unlock(&vf->flow_ops_lock);
1446
1447         return ret;
1448 }
1449
1450 int
1451 iavf_flow_flush(struct rte_eth_dev *dev,
1452                 struct rte_flow_error *error)
1453 {
1454         struct iavf_adapter *ad =
1455                 IAVF_DEV_PRIVATE_TO_ADAPTER(dev->data->dev_private);
1456         struct iavf_info *vf = IAVF_DEV_PRIVATE_TO_VF(ad);
1457         struct rte_flow *p_flow;
1458         void *temp;
1459         int ret = 0;
1460
1461         TAILQ_FOREACH_SAFE(p_flow, &vf->flow_list, node, temp) {
1462                 ret = iavf_flow_destroy(dev, p_flow, error);
1463                 if (ret) {
1464                         PMD_DRV_LOG(ERR, "Failed to flush flows");
1465                         return -EINVAL;
1466                 }
1467         }
1468
1469         return ret;
1470 }
1471
1472 static int
1473 iavf_flow_query(struct rte_eth_dev *dev,
1474                 struct rte_flow *flow,
1475                 const struct rte_flow_action *actions,
1476                 void *data,
1477                 struct rte_flow_error *error)
1478 {
1479         int ret = -EINVAL;
1480         struct iavf_adapter *ad =
1481                 IAVF_DEV_PRIVATE_TO_ADAPTER(dev->data->dev_private);
1482         struct rte_flow_query_count *count = data;
1483
1484         if (!iavf_flow_is_valid(flow) || !flow->engine->query_count) {
1485                 rte_flow_error_set(error, EINVAL,
1486                                    RTE_FLOW_ERROR_TYPE_HANDLE,
1487                                    NULL, "Invalid flow query");
1488                 return -rte_errno;
1489         }
1490
1491         for (; actions->type != RTE_FLOW_ACTION_TYPE_END; actions++) {
1492                 switch (actions->type) {
1493                 case RTE_FLOW_ACTION_TYPE_VOID:
1494                         break;
1495                 case RTE_FLOW_ACTION_TYPE_COUNT:
1496                         ret = flow->engine->query_count(ad, flow, count, error);
1497                         break;
1498                 default:
1499                         return rte_flow_error_set(error, ENOTSUP,
1500                                         RTE_FLOW_ERROR_TYPE_ACTION,
1501                                         actions,
1502                                         "action not supported");
1503                 }
1504         }
1505         return ret;
1506 }
1507