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 <rte_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_udp[] = {
 223         RTE_FLOW_ITEM_TYPE_ETH,
 224         RTE_FLOW_ITEM_TYPE_IPV6,
 225         RTE_FLOW_ITEM_TYPE_UDP,
 226         RTE_FLOW_ITEM_TYPE_END,
 227 };
 228
 229 enum rte_flow_item_type iavf_pattern_eth_vlan_ipv6_udp[] = {
 230         RTE_FLOW_ITEM_TYPE_ETH,
 231         RTE_FLOW_ITEM_TYPE_VLAN,
 232         RTE_FLOW_ITEM_TYPE_IPV6,
 233         RTE_FLOW_ITEM_TYPE_UDP,
 234         RTE_FLOW_ITEM_TYPE_END,
 235 };
 236
 237 enum rte_flow_item_type iavf_pattern_eth_qinq_ipv6_udp[] = {
 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_UDP,
 243         RTE_FLOW_ITEM_TYPE_END,
 244 };
 245
 246 enum rte_flow_item_type iavf_pattern_eth_ipv6_tcp[] = {
 247         RTE_FLOW_ITEM_TYPE_ETH,
 248         RTE_FLOW_ITEM_TYPE_IPV6,
 249         RTE_FLOW_ITEM_TYPE_TCP,
 250         RTE_FLOW_ITEM_TYPE_END,
 251 };
 252
 253 enum rte_flow_item_type iavf_pattern_eth_vlan_ipv6_tcp[] = {
 254         RTE_FLOW_ITEM_TYPE_ETH,
 255         RTE_FLOW_ITEM_TYPE_VLAN,
 256         RTE_FLOW_ITEM_TYPE_IPV6,
 257         RTE_FLOW_ITEM_TYPE_TCP,
 258         RTE_FLOW_ITEM_TYPE_END,
 259 };
 260
 261 enum rte_flow_item_type iavf_pattern_eth_qinq_ipv6_tcp[] = {
 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_TCP,
 267         RTE_FLOW_ITEM_TYPE_END,
 268 };
 269
 270 enum rte_flow_item_type iavf_pattern_eth_ipv6_sctp[] = {
 271         RTE_FLOW_ITEM_TYPE_ETH,
 272         RTE_FLOW_ITEM_TYPE_IPV6,
 273         RTE_FLOW_ITEM_TYPE_SCTP,
 274         RTE_FLOW_ITEM_TYPE_END,
 275 };
 276
 277 enum rte_flow_item_type iavf_pattern_eth_vlan_ipv6_sctp[] = {
 278         RTE_FLOW_ITEM_TYPE_ETH,
 279         RTE_FLOW_ITEM_TYPE_VLAN,
 280         RTE_FLOW_ITEM_TYPE_IPV6,
 281         RTE_FLOW_ITEM_TYPE_SCTP,
 282         RTE_FLOW_ITEM_TYPE_END,
 283 };
 284
 285 enum rte_flow_item_type iavf_pattern_eth_qinq_ipv6_sctp[] = {
 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_SCTP,
 291         RTE_FLOW_ITEM_TYPE_END,
 292 };
 293
 294 enum rte_flow_item_type iavf_pattern_eth_ipv6_icmp6[] = {
 295         RTE_FLOW_ITEM_TYPE_ETH,
 296         RTE_FLOW_ITEM_TYPE_IPV6,
 297         RTE_FLOW_ITEM_TYPE_ICMP6,
 298         RTE_FLOW_ITEM_TYPE_END,
 299 };
 300
 301 enum rte_flow_item_type iavf_pattern_eth_vlan_ipv6_icmp6[] = {
 302         RTE_FLOW_ITEM_TYPE_ETH,
 303         RTE_FLOW_ITEM_TYPE_VLAN,
 304         RTE_FLOW_ITEM_TYPE_IPV6,
 305         RTE_FLOW_ITEM_TYPE_ICMP6,
 306         RTE_FLOW_ITEM_TYPE_END,
 307 };
 308
 309 enum rte_flow_item_type iavf_pattern_eth_qinq_ipv6_icmp6[] = {
 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_ICMP6,
 315         RTE_FLOW_ITEM_TYPE_END,
 316 };
 317
 318 /* IPv4 GTPC */
 319 enum rte_flow_item_type iavf_pattern_eth_ipv4_gtpc[] = {
 320         RTE_FLOW_ITEM_TYPE_ETH,
 321         RTE_FLOW_ITEM_TYPE_IPV4,
 322         RTE_FLOW_ITEM_TYPE_UDP,
 323         RTE_FLOW_ITEM_TYPE_GTPC,
 324         RTE_FLOW_ITEM_TYPE_END,
 325 };
 326
 327 /* IPV4 GTPU (EH) */
 328 enum rte_flow_item_type iavf_pattern_eth_ipv4_gtpu[] = {
 329         RTE_FLOW_ITEM_TYPE_ETH,
 330         RTE_FLOW_ITEM_TYPE_IPV4,
 331         RTE_FLOW_ITEM_TYPE_UDP,
 332         RTE_FLOW_ITEM_TYPE_GTPU,
 333         RTE_FLOW_ITEM_TYPE_END,
 334 };
 335
 336 enum rte_flow_item_type iavf_pattern_eth_ipv4_gtpu_eh[] = {
 337         RTE_FLOW_ITEM_TYPE_ETH,
 338         RTE_FLOW_ITEM_TYPE_IPV4,
 339         RTE_FLOW_ITEM_TYPE_UDP,
 340         RTE_FLOW_ITEM_TYPE_GTPU,
 341         RTE_FLOW_ITEM_TYPE_GTP_PSC,
 342         RTE_FLOW_ITEM_TYPE_END,
 343 };
 344
 345 /* IPv6 GTPC */
 346 enum rte_flow_item_type iavf_pattern_eth_ipv6_gtpc[] = {
 347         RTE_FLOW_ITEM_TYPE_ETH,
 348         RTE_FLOW_ITEM_TYPE_IPV6,
 349         RTE_FLOW_ITEM_TYPE_UDP,
 350         RTE_FLOW_ITEM_TYPE_GTPC,
 351         RTE_FLOW_ITEM_TYPE_END,
 352 };
 353
 354 /* IPV6 GTPU (EH) */
 355 enum rte_flow_item_type iavf_pattern_eth_ipv6_gtpu[] = {
 356         RTE_FLOW_ITEM_TYPE_ETH,
 357         RTE_FLOW_ITEM_TYPE_IPV6,
 358         RTE_FLOW_ITEM_TYPE_UDP,
 359         RTE_FLOW_ITEM_TYPE_GTPU,
 360         RTE_FLOW_ITEM_TYPE_END,
 361 };
 362
 363 enum rte_flow_item_type iavf_pattern_eth_ipv6_gtpu_eh[] = {
 364         RTE_FLOW_ITEM_TYPE_ETH,
 365         RTE_FLOW_ITEM_TYPE_IPV6,
 366         RTE_FLOW_ITEM_TYPE_UDP,
 367         RTE_FLOW_ITEM_TYPE_GTPU,
 368         RTE_FLOW_ITEM_TYPE_GTP_PSC,
 369         RTE_FLOW_ITEM_TYPE_END,
 370 };
 371
 372 /* IPV4 GTPU IPv4 */
 373 enum rte_flow_item_type iavf_pattern_eth_ipv4_gtpu_ipv4[] = {
 374         RTE_FLOW_ITEM_TYPE_ETH,
 375         RTE_FLOW_ITEM_TYPE_IPV4,
 376         RTE_FLOW_ITEM_TYPE_UDP,
 377         RTE_FLOW_ITEM_TYPE_GTPU,
 378         RTE_FLOW_ITEM_TYPE_IPV4,
 379         RTE_FLOW_ITEM_TYPE_END,
 380 };
 381
 382 enum rte_flow_item_type iavf_pattern_eth_ipv4_gtpu_ipv4_udp[] = {
 383         RTE_FLOW_ITEM_TYPE_ETH,
 384         RTE_FLOW_ITEM_TYPE_IPV4,
 385         RTE_FLOW_ITEM_TYPE_UDP,
 386         RTE_FLOW_ITEM_TYPE_GTPU,
 387         RTE_FLOW_ITEM_TYPE_IPV4,
 388         RTE_FLOW_ITEM_TYPE_UDP,
 389         RTE_FLOW_ITEM_TYPE_END,
 390 };
 391
 392 enum rte_flow_item_type iavf_pattern_eth_ipv4_gtpu_ipv4_tcp[] = {
 393         RTE_FLOW_ITEM_TYPE_ETH,
 394         RTE_FLOW_ITEM_TYPE_IPV4,
 395         RTE_FLOW_ITEM_TYPE_UDP,
 396         RTE_FLOW_ITEM_TYPE_GTPU,
 397         RTE_FLOW_ITEM_TYPE_IPV4,
 398         RTE_FLOW_ITEM_TYPE_TCP,
 399         RTE_FLOW_ITEM_TYPE_END,
 400 };
 401
 402 enum rte_flow_item_type iavf_pattern_eth_ipv4_gtpu_ipv4_icmp[] = {
 403         RTE_FLOW_ITEM_TYPE_ETH,
 404         RTE_FLOW_ITEM_TYPE_IPV4,
 405         RTE_FLOW_ITEM_TYPE_UDP,
 406         RTE_FLOW_ITEM_TYPE_GTPU,
 407         RTE_FLOW_ITEM_TYPE_IPV4,
 408         RTE_FLOW_ITEM_TYPE_ICMP,
 409         RTE_FLOW_ITEM_TYPE_END,
 410 };
 411
 412 /* IPV4 GTPU IPv6 */
 413 enum rte_flow_item_type iavf_pattern_eth_ipv4_gtpu_ipv6[] = {
 414         RTE_FLOW_ITEM_TYPE_ETH,
 415         RTE_FLOW_ITEM_TYPE_IPV4,
 416         RTE_FLOW_ITEM_TYPE_UDP,
 417         RTE_FLOW_ITEM_TYPE_GTPU,
 418         RTE_FLOW_ITEM_TYPE_IPV6,
 419         RTE_FLOW_ITEM_TYPE_END,
 420 };
 421
 422 enum rte_flow_item_type iavf_pattern_eth_ipv4_gtpu_ipv6_udp[] = {
 423         RTE_FLOW_ITEM_TYPE_ETH,
 424         RTE_FLOW_ITEM_TYPE_IPV4,
 425         RTE_FLOW_ITEM_TYPE_UDP,
 426         RTE_FLOW_ITEM_TYPE_GTPU,
 427         RTE_FLOW_ITEM_TYPE_IPV6,
 428         RTE_FLOW_ITEM_TYPE_UDP,
 429         RTE_FLOW_ITEM_TYPE_END,
 430 };
 431
 432 enum rte_flow_item_type iavf_pattern_eth_ipv4_gtpu_ipv6_tcp[] = {
 433         RTE_FLOW_ITEM_TYPE_ETH,
 434         RTE_FLOW_ITEM_TYPE_IPV4,
 435         RTE_FLOW_ITEM_TYPE_UDP,
 436         RTE_FLOW_ITEM_TYPE_GTPU,
 437         RTE_FLOW_ITEM_TYPE_IPV6,
 438         RTE_FLOW_ITEM_TYPE_TCP,
 439         RTE_FLOW_ITEM_TYPE_END,
 440 };
 441
 442 enum rte_flow_item_type iavf_pattern_eth_ipv4_gtpu_ipv6_icmp[] = {
 443         RTE_FLOW_ITEM_TYPE_ETH,
 444         RTE_FLOW_ITEM_TYPE_IPV4,
 445         RTE_FLOW_ITEM_TYPE_UDP,
 446         RTE_FLOW_ITEM_TYPE_GTPU,
 447         RTE_FLOW_ITEM_TYPE_IPV6,
 448         RTE_FLOW_ITEM_TYPE_ICMP,
 449         RTE_FLOW_ITEM_TYPE_END,
 450 };
 451
 452 /* IPV6 GTPU IPv4 */
 453 enum rte_flow_item_type iavf_pattern_eth_ipv6_gtpu_ipv4[] = {
 454         RTE_FLOW_ITEM_TYPE_ETH,
 455         RTE_FLOW_ITEM_TYPE_IPV6,
 456         RTE_FLOW_ITEM_TYPE_UDP,
 457         RTE_FLOW_ITEM_TYPE_GTPU,
 458         RTE_FLOW_ITEM_TYPE_IPV4,
 459         RTE_FLOW_ITEM_TYPE_END,
 460 };
 461
 462 enum rte_flow_item_type iavf_pattern_eth_ipv6_gtpu_ipv4_udp[] = {
 463         RTE_FLOW_ITEM_TYPE_ETH,
 464         RTE_FLOW_ITEM_TYPE_IPV6,
 465         RTE_FLOW_ITEM_TYPE_UDP,
 466         RTE_FLOW_ITEM_TYPE_GTPU,
 467         RTE_FLOW_ITEM_TYPE_IPV4,
 468         RTE_FLOW_ITEM_TYPE_UDP,
 469         RTE_FLOW_ITEM_TYPE_END,
 470 };
 471
 472 enum rte_flow_item_type iavf_pattern_eth_ipv6_gtpu_ipv4_tcp[] = {
 473         RTE_FLOW_ITEM_TYPE_ETH,
 474         RTE_FLOW_ITEM_TYPE_IPV6,
 475         RTE_FLOW_ITEM_TYPE_UDP,
 476         RTE_FLOW_ITEM_TYPE_GTPU,
 477         RTE_FLOW_ITEM_TYPE_IPV4,
 478         RTE_FLOW_ITEM_TYPE_TCP,
 479         RTE_FLOW_ITEM_TYPE_END,
 480 };
 481
 482 enum rte_flow_item_type iavf_pattern_eth_ipv6_gtpu_ipv4_icmp[] = {
 483         RTE_FLOW_ITEM_TYPE_ETH,
 484         RTE_FLOW_ITEM_TYPE_IPV6,
 485         RTE_FLOW_ITEM_TYPE_UDP,
 486         RTE_FLOW_ITEM_TYPE_GTPU,
 487         RTE_FLOW_ITEM_TYPE_IPV4,
 488         RTE_FLOW_ITEM_TYPE_ICMP,
 489         RTE_FLOW_ITEM_TYPE_END,
 490 };
 491
 492 /* IPV6 GTPU IPv6 */
 493 enum rte_flow_item_type iavf_pattern_eth_ipv6_gtpu_ipv6[] = {
 494         RTE_FLOW_ITEM_TYPE_ETH,
 495         RTE_FLOW_ITEM_TYPE_IPV6,
 496         RTE_FLOW_ITEM_TYPE_UDP,
 497         RTE_FLOW_ITEM_TYPE_GTPU,
 498         RTE_FLOW_ITEM_TYPE_IPV6,
 499         RTE_FLOW_ITEM_TYPE_END,
 500 };
 501
 502 enum rte_flow_item_type iavf_pattern_eth_ipv6_gtpu_ipv6_udp[] = {
 503         RTE_FLOW_ITEM_TYPE_ETH,
 504         RTE_FLOW_ITEM_TYPE_IPV6,
 505         RTE_FLOW_ITEM_TYPE_UDP,
 506         RTE_FLOW_ITEM_TYPE_GTPU,
 507         RTE_FLOW_ITEM_TYPE_IPV6,
 508         RTE_FLOW_ITEM_TYPE_UDP,
 509         RTE_FLOW_ITEM_TYPE_END,
 510 };
 511
 512 enum rte_flow_item_type iavf_pattern_eth_ipv6_gtpu_ipv6_tcp[] = {
 513         RTE_FLOW_ITEM_TYPE_ETH,
 514         RTE_FLOW_ITEM_TYPE_IPV6,
 515         RTE_FLOW_ITEM_TYPE_UDP,
 516         RTE_FLOW_ITEM_TYPE_GTPU,
 517         RTE_FLOW_ITEM_TYPE_IPV6,
 518         RTE_FLOW_ITEM_TYPE_TCP,
 519         RTE_FLOW_ITEM_TYPE_END,
 520 };
 521
 522 enum rte_flow_item_type iavf_pattern_eth_ipv6_gtpu_ipv6_icmp[] = {
 523         RTE_FLOW_ITEM_TYPE_ETH,
 524         RTE_FLOW_ITEM_TYPE_IPV6,
 525         RTE_FLOW_ITEM_TYPE_UDP,
 526         RTE_FLOW_ITEM_TYPE_GTPU,
 527         RTE_FLOW_ITEM_TYPE_IPV6,
 528         RTE_FLOW_ITEM_TYPE_ICMP,
 529         RTE_FLOW_ITEM_TYPE_END,
 530 };
 531
 532 /* IPV4 GTPU EH IPv4 */
 533 enum rte_flow_item_type iavf_pattern_eth_ipv4_gtpu_eh_ipv4[] = {
 534         RTE_FLOW_ITEM_TYPE_ETH,
 535         RTE_FLOW_ITEM_TYPE_IPV4,
 536         RTE_FLOW_ITEM_TYPE_UDP,
 537         RTE_FLOW_ITEM_TYPE_GTPU,
 538         RTE_FLOW_ITEM_TYPE_GTP_PSC,
 539         RTE_FLOW_ITEM_TYPE_IPV4,
 540         RTE_FLOW_ITEM_TYPE_END,
 541 };
 542
 543 enum rte_flow_item_type iavf_pattern_eth_ipv4_gtpu_eh_ipv4_udp[] = {
 544         RTE_FLOW_ITEM_TYPE_ETH,
 545         RTE_FLOW_ITEM_TYPE_IPV4,
 546         RTE_FLOW_ITEM_TYPE_UDP,
 547         RTE_FLOW_ITEM_TYPE_GTPU,
 548         RTE_FLOW_ITEM_TYPE_GTP_PSC,
 549         RTE_FLOW_ITEM_TYPE_IPV4,
 550         RTE_FLOW_ITEM_TYPE_UDP,
 551         RTE_FLOW_ITEM_TYPE_END,
 552 };
 553
 554 enum rte_flow_item_type iavf_pattern_eth_ipv4_gtpu_eh_ipv4_tcp[] = {
 555         RTE_FLOW_ITEM_TYPE_ETH,
 556         RTE_FLOW_ITEM_TYPE_IPV4,
 557         RTE_FLOW_ITEM_TYPE_UDP,
 558         RTE_FLOW_ITEM_TYPE_GTPU,
 559         RTE_FLOW_ITEM_TYPE_GTP_PSC,
 560         RTE_FLOW_ITEM_TYPE_IPV4,
 561         RTE_FLOW_ITEM_TYPE_TCP,
 562         RTE_FLOW_ITEM_TYPE_END,
 563 };
 564
 565 enum rte_flow_item_type iavf_pattern_eth_ipv4_gtpu_eh_ipv4_icmp[] = {
 566         RTE_FLOW_ITEM_TYPE_ETH,
 567         RTE_FLOW_ITEM_TYPE_IPV4,
 568         RTE_FLOW_ITEM_TYPE_UDP,
 569         RTE_FLOW_ITEM_TYPE_GTPU,
 570         RTE_FLOW_ITEM_TYPE_GTP_PSC,
 571         RTE_FLOW_ITEM_TYPE_IPV4,
 572         RTE_FLOW_ITEM_TYPE_ICMP,
 573         RTE_FLOW_ITEM_TYPE_END,
 574 };
 575
 576 /* IPV4 GTPU EH IPv6 */
 577 enum rte_flow_item_type iavf_pattern_eth_ipv4_gtpu_eh_ipv6[] = {
 578         RTE_FLOW_ITEM_TYPE_ETH,
 579         RTE_FLOW_ITEM_TYPE_IPV4,
 580         RTE_FLOW_ITEM_TYPE_UDP,
 581         RTE_FLOW_ITEM_TYPE_GTPU,
 582         RTE_FLOW_ITEM_TYPE_GTP_PSC,
 583         RTE_FLOW_ITEM_TYPE_IPV6,
 584         RTE_FLOW_ITEM_TYPE_END,
 585 };
 586
 587 enum rte_flow_item_type iavf_pattern_eth_ipv4_gtpu_eh_ipv6_udp[] = {
 588         RTE_FLOW_ITEM_TYPE_ETH,
 589         RTE_FLOW_ITEM_TYPE_IPV4,
 590         RTE_FLOW_ITEM_TYPE_UDP,
 591         RTE_FLOW_ITEM_TYPE_GTPU,
 592         RTE_FLOW_ITEM_TYPE_GTP_PSC,
 593         RTE_FLOW_ITEM_TYPE_IPV6,
 594         RTE_FLOW_ITEM_TYPE_UDP,
 595         RTE_FLOW_ITEM_TYPE_END,
 596 };
 597
 598 enum rte_flow_item_type iavf_pattern_eth_ipv4_gtpu_eh_ipv6_tcp[] = {
 599         RTE_FLOW_ITEM_TYPE_ETH,
 600         RTE_FLOW_ITEM_TYPE_IPV4,
 601         RTE_FLOW_ITEM_TYPE_UDP,
 602         RTE_FLOW_ITEM_TYPE_GTPU,
 603         RTE_FLOW_ITEM_TYPE_GTP_PSC,
 604         RTE_FLOW_ITEM_TYPE_IPV6,
 605         RTE_FLOW_ITEM_TYPE_TCP,
 606         RTE_FLOW_ITEM_TYPE_END,
 607 };
 608
 609 enum rte_flow_item_type iavf_pattern_eth_ipv4_gtpu_eh_ipv6_icmp[] = {
 610         RTE_FLOW_ITEM_TYPE_ETH,
 611         RTE_FLOW_ITEM_TYPE_IPV4,
 612         RTE_FLOW_ITEM_TYPE_UDP,
 613         RTE_FLOW_ITEM_TYPE_GTPU,
 614         RTE_FLOW_ITEM_TYPE_GTP_PSC,
 615         RTE_FLOW_ITEM_TYPE_IPV6,
 616         RTE_FLOW_ITEM_TYPE_ICMP,
 617         RTE_FLOW_ITEM_TYPE_END,
 618 };
 619
 620 /* IPV6 GTPU EH IPv4 */
 621 enum rte_flow_item_type iavf_pattern_eth_ipv6_gtpu_eh_ipv4[] = {
 622         RTE_FLOW_ITEM_TYPE_ETH,
 623         RTE_FLOW_ITEM_TYPE_IPV6,
 624         RTE_FLOW_ITEM_TYPE_UDP,
 625         RTE_FLOW_ITEM_TYPE_GTPU,
 626         RTE_FLOW_ITEM_TYPE_GTP_PSC,
 627         RTE_FLOW_ITEM_TYPE_IPV4,
 628         RTE_FLOW_ITEM_TYPE_END,
 629 };
 630
 631 enum rte_flow_item_type iavf_pattern_eth_ipv6_gtpu_eh_ipv4_udp[] = {
 632         RTE_FLOW_ITEM_TYPE_ETH,
 633         RTE_FLOW_ITEM_TYPE_IPV6,
 634         RTE_FLOW_ITEM_TYPE_UDP,
 635         RTE_FLOW_ITEM_TYPE_GTPU,
 636         RTE_FLOW_ITEM_TYPE_GTP_PSC,
 637         RTE_FLOW_ITEM_TYPE_IPV4,
 638         RTE_FLOW_ITEM_TYPE_UDP,
 639         RTE_FLOW_ITEM_TYPE_END,
 640 };
 641
 642 enum rte_flow_item_type iavf_pattern_eth_ipv6_gtpu_eh_ipv4_tcp[] = {
 643         RTE_FLOW_ITEM_TYPE_ETH,
 644         RTE_FLOW_ITEM_TYPE_IPV6,
 645         RTE_FLOW_ITEM_TYPE_UDP,
 646         RTE_FLOW_ITEM_TYPE_GTPU,
 647         RTE_FLOW_ITEM_TYPE_GTP_PSC,
 648         RTE_FLOW_ITEM_TYPE_IPV4,
 649         RTE_FLOW_ITEM_TYPE_TCP,
 650         RTE_FLOW_ITEM_TYPE_END,
 651 };
 652
 653 enum rte_flow_item_type iavf_pattern_eth_ipv6_gtpu_eh_ipv4_icmp[] = {
 654         RTE_FLOW_ITEM_TYPE_ETH,
 655         RTE_FLOW_ITEM_TYPE_IPV6,
 656         RTE_FLOW_ITEM_TYPE_UDP,
 657         RTE_FLOW_ITEM_TYPE_GTPU,
 658         RTE_FLOW_ITEM_TYPE_GTP_PSC,
 659         RTE_FLOW_ITEM_TYPE_IPV4,
 660         RTE_FLOW_ITEM_TYPE_ICMP,
 661         RTE_FLOW_ITEM_TYPE_END,
 662 };
 663
 664 /* IPV6 GTPU EH IPv6 */
 665 enum rte_flow_item_type iavf_pattern_eth_ipv6_gtpu_eh_ipv6[] = {
 666         RTE_FLOW_ITEM_TYPE_ETH,
 667         RTE_FLOW_ITEM_TYPE_IPV6,
 668         RTE_FLOW_ITEM_TYPE_UDP,
 669         RTE_FLOW_ITEM_TYPE_GTPU,
 670         RTE_FLOW_ITEM_TYPE_GTP_PSC,
 671         RTE_FLOW_ITEM_TYPE_IPV6,
 672         RTE_FLOW_ITEM_TYPE_END,
 673 };
 674
 675 enum rte_flow_item_type iavf_pattern_eth_ipv6_gtpu_eh_ipv6_udp[] = {
 676         RTE_FLOW_ITEM_TYPE_ETH,
 677         RTE_FLOW_ITEM_TYPE_IPV6,
 678         RTE_FLOW_ITEM_TYPE_UDP,
 679         RTE_FLOW_ITEM_TYPE_GTPU,
 680         RTE_FLOW_ITEM_TYPE_GTP_PSC,
 681         RTE_FLOW_ITEM_TYPE_IPV6,
 682         RTE_FLOW_ITEM_TYPE_UDP,
 683         RTE_FLOW_ITEM_TYPE_END,
 684 };
 685
 686 enum rte_flow_item_type iavf_pattern_eth_ipv6_gtpu_eh_ipv6_tcp[] = {
 687         RTE_FLOW_ITEM_TYPE_ETH,
 688         RTE_FLOW_ITEM_TYPE_IPV6,
 689         RTE_FLOW_ITEM_TYPE_UDP,
 690         RTE_FLOW_ITEM_TYPE_GTPU,
 691         RTE_FLOW_ITEM_TYPE_GTP_PSC,
 692         RTE_FLOW_ITEM_TYPE_IPV6,
 693         RTE_FLOW_ITEM_TYPE_TCP,
 694         RTE_FLOW_ITEM_TYPE_END,
 695 };
 696
 697 enum rte_flow_item_type iavf_pattern_eth_ipv6_gtpu_eh_ipv6_icmp[] = {
 698         RTE_FLOW_ITEM_TYPE_ETH,
 699         RTE_FLOW_ITEM_TYPE_IPV6,
 700         RTE_FLOW_ITEM_TYPE_UDP,
 701         RTE_FLOW_ITEM_TYPE_GTPU,
 702         RTE_FLOW_ITEM_TYPE_GTP_PSC,
 703         RTE_FLOW_ITEM_TYPE_IPV6,
 704         RTE_FLOW_ITEM_TYPE_ICMP,
 705         RTE_FLOW_ITEM_TYPE_END,
 706 };
 707
 708 /* ESP */
 709 enum rte_flow_item_type iavf_pattern_eth_ipv4_esp[] = {
 710         RTE_FLOW_ITEM_TYPE_ETH,
 711         RTE_FLOW_ITEM_TYPE_IPV4,
 712         RTE_FLOW_ITEM_TYPE_ESP,
 713         RTE_FLOW_ITEM_TYPE_END,
 714 };
 715
 716 enum rte_flow_item_type iavf_pattern_eth_ipv4_udp_esp[] = {
 717         RTE_FLOW_ITEM_TYPE_ETH,
 718         RTE_FLOW_ITEM_TYPE_IPV4,
 719         RTE_FLOW_ITEM_TYPE_UDP,
 720         RTE_FLOW_ITEM_TYPE_ESP,
 721         RTE_FLOW_ITEM_TYPE_END,
 722 };
 723
 724 enum rte_flow_item_type iavf_pattern_eth_ipv6_esp[] = {
 725         RTE_FLOW_ITEM_TYPE_ETH,
 726         RTE_FLOW_ITEM_TYPE_IPV6,
 727         RTE_FLOW_ITEM_TYPE_ESP,
 728         RTE_FLOW_ITEM_TYPE_END,
 729 };
 730
 731 enum rte_flow_item_type iavf_pattern_eth_ipv6_udp_esp[] = {
 732         RTE_FLOW_ITEM_TYPE_ETH,
 733         RTE_FLOW_ITEM_TYPE_IPV6,
 734         RTE_FLOW_ITEM_TYPE_UDP,
 735         RTE_FLOW_ITEM_TYPE_ESP,
 736         RTE_FLOW_ITEM_TYPE_END,
 737 };
 738
 739 /* AH */
 740 enum rte_flow_item_type iavf_pattern_eth_ipv4_ah[] = {
 741         RTE_FLOW_ITEM_TYPE_ETH,
 742         RTE_FLOW_ITEM_TYPE_IPV4,
 743         RTE_FLOW_ITEM_TYPE_AH,
 744         RTE_FLOW_ITEM_TYPE_END,
 745 };
 746
 747 enum rte_flow_item_type iavf_pattern_eth_ipv6_ah[] = {
 748         RTE_FLOW_ITEM_TYPE_ETH,
 749         RTE_FLOW_ITEM_TYPE_IPV6,
 750         RTE_FLOW_ITEM_TYPE_AH,
 751         RTE_FLOW_ITEM_TYPE_END,
 752 };
 753
 754 /* L2TPV3 */
 755 enum rte_flow_item_type iavf_pattern_eth_ipv4_l2tpv3[] = {
 756         RTE_FLOW_ITEM_TYPE_ETH,
 757         RTE_FLOW_ITEM_TYPE_IPV4,
 758         RTE_FLOW_ITEM_TYPE_L2TPV3OIP,
 759         RTE_FLOW_ITEM_TYPE_END,
 760 };
 761
 762 enum rte_flow_item_type iavf_pattern_eth_ipv6_l2tpv3[] = {
 763         RTE_FLOW_ITEM_TYPE_ETH,
 764         RTE_FLOW_ITEM_TYPE_IPV6,
 765         RTE_FLOW_ITEM_TYPE_L2TPV3OIP,
 766         RTE_FLOW_ITEM_TYPE_END,
 767 };
 768
 769 /* PFCP */
 770 enum rte_flow_item_type iavf_pattern_eth_ipv4_pfcp[] = {
 771         RTE_FLOW_ITEM_TYPE_ETH,
 772         RTE_FLOW_ITEM_TYPE_IPV4,
 773         RTE_FLOW_ITEM_TYPE_UDP,
 774         RTE_FLOW_ITEM_TYPE_PFCP,
 775         RTE_FLOW_ITEM_TYPE_END,
 776 };
 777
 778 enum rte_flow_item_type iavf_pattern_eth_ipv6_pfcp[] = {
 779         RTE_FLOW_ITEM_TYPE_ETH,
 780         RTE_FLOW_ITEM_TYPE_IPV6,
 781         RTE_FLOW_ITEM_TYPE_UDP,
 782         RTE_FLOW_ITEM_TYPE_PFCP,
 783         RTE_FLOW_ITEM_TYPE_END,
 784 };
 785
 786 /* ECPRI */
 787 enum rte_flow_item_type iavf_pattern_eth_ecpri[] = {
 788         RTE_FLOW_ITEM_TYPE_ETH,
 789         RTE_FLOW_ITEM_TYPE_ECPRI,
 790         RTE_FLOW_ITEM_TYPE_END,
 791 };
 792
 793 enum rte_flow_item_type iavf_pattern_eth_ipv4_ecpri[] = {
 794         RTE_FLOW_ITEM_TYPE_ETH,
 795         RTE_FLOW_ITEM_TYPE_IPV4,
 796         RTE_FLOW_ITEM_TYPE_UDP,
 797         RTE_FLOW_ITEM_TYPE_ECPRI,
 798         RTE_FLOW_ITEM_TYPE_END,
 799 };
 800
 801 typedef struct iavf_flow_engine * (*parse_engine_t)(struct iavf_adapter *ad,
 802                 struct rte_flow *flow,
 803                 struct iavf_parser_list *parser_list,
 804                 const struct rte_flow_item pattern[],
 805                 const struct rte_flow_action actions[],
 806                 struct rte_flow_error *error);
 807
 808 void
 809 iavf_register_flow_engine(struct iavf_flow_engine *engine)
 810 {
 811         TAILQ_INSERT_TAIL(&engine_list, engine, node);
 812 }
 813
 814 int
 815 iavf_flow_init(struct iavf_adapter *ad)
 816 {
 817         int ret;
 818         struct iavf_info *vf = IAVF_DEV_PRIVATE_TO_VF(ad);
 819         void *temp;
 820         struct iavf_flow_engine *engine;
 821
 822         TAILQ_INIT(&vf->flow_list);
 823         TAILQ_INIT(&vf->rss_parser_list);
 824         TAILQ_INIT(&vf->dist_parser_list);
 825         rte_spinlock_init(&vf->flow_ops_lock);
 826
 827         TAILQ_FOREACH_SAFE(engine, &engine_list, node, temp) {
 828                 if (engine->init == NULL) {
 829                         PMD_INIT_LOG(ERR, "Invalid engine type (%d)",
 830                                      engine->type);
 831                         return -ENOTSUP;
 832                 }
 833
 834                 ret = engine->init(ad);
 835                 if (ret && ret != -ENOTSUP) {
 836                         PMD_INIT_LOG(ERR, "Failed to initialize engine %d",
 837                                      engine->type);
 838                         return ret;
 839                 }
 840         }
 841         return 0;
 842 }
 843
 844 void
 845 iavf_flow_uninit(struct iavf_adapter *ad)
 846 {
 847         struct iavf_info *vf = IAVF_DEV_PRIVATE_TO_VF(ad);
 848         struct iavf_flow_engine *engine;
 849         struct rte_flow *p_flow;
 850         struct iavf_flow_parser_node *p_parser;
 851         void *temp;
 852
 853         TAILQ_FOREACH_SAFE(engine, &engine_list, node, temp) {
 854                 if (engine->uninit)
 855                         engine->uninit(ad);
 856         }
 857
 858         /* Remove all flows */
 859         while ((p_flow = TAILQ_FIRST(&vf->flow_list))) {
 860                 TAILQ_REMOVE(&vf->flow_list, p_flow, node);
 861                 if (p_flow->engine->free)
 862                         p_flow->engine->free(p_flow);
 863                 rte_free(p_flow);
 864         }
 865
 866         /* Cleanup parser list */
 867         while ((p_parser = TAILQ_FIRST(&vf->rss_parser_list))) {
 868                 TAILQ_REMOVE(&vf->rss_parser_list, p_parser, node);
 869                 rte_free(p_parser);
 870         }
 871
 872         while ((p_parser = TAILQ_FIRST(&vf->dist_parser_list))) {
 873                 TAILQ_REMOVE(&vf->dist_parser_list, p_parser, node);
 874                 rte_free(p_parser);
 875         }
 876 }
 877
 878 int
 879 iavf_register_parser(struct iavf_flow_parser *parser,
 880                      struct iavf_adapter *ad)
 881 {
 882         struct iavf_parser_list *list = NULL;
 883         struct iavf_flow_parser_node *parser_node;
 884         struct iavf_info *vf = IAVF_DEV_PRIVATE_TO_VF(ad);
 885
 886         parser_node = rte_zmalloc("iavf_parser", sizeof(*parser_node), 0);
 887         if (parser_node == NULL) {
 888                 PMD_DRV_LOG(ERR, "Failed to allocate memory.");
 889                 return -ENOMEM;
 890         }
 891         parser_node->parser = parser;
 892
 893         if (parser->engine->type == IAVF_FLOW_ENGINE_HASH) {
 894                 list = &vf->rss_parser_list;
 895                 TAILQ_INSERT_TAIL(list, parser_node, node);
 896         } else if (parser->engine->type == IAVF_FLOW_ENGINE_FDIR) {
 897                 list = &vf->dist_parser_list;
 898                 TAILQ_INSERT_HEAD(list, parser_node, node);
 899         } else {
 900                 return -EINVAL;
 901         }
 902
 903         return 0;
 904 }
 905
 906 void
 907 iavf_unregister_parser(struct iavf_flow_parser *parser,
 908                        struct iavf_adapter *ad)
 909 {
 910         struct iavf_parser_list *list = NULL;
 911         struct iavf_flow_parser_node *p_parser;
 912         struct iavf_info *vf = IAVF_DEV_PRIVATE_TO_VF(ad);
 913         void *temp;
 914
 915         if (parser->engine->type == IAVF_FLOW_ENGINE_HASH)
 916                 list = &vf->rss_parser_list;
 917         else if (parser->engine->type == IAVF_FLOW_ENGINE_FDIR)
 918                 list = &vf->dist_parser_list;
 919
 920         if (list == NULL)
 921                 return;
 922
 923         TAILQ_FOREACH_SAFE(p_parser, list, node, temp) {
 924                 if (p_parser->parser->engine->type == parser->engine->type) {
 925                         TAILQ_REMOVE(list, p_parser, node);
 926                         rte_free(p_parser);
 927                 }
 928         }
 929 }
 930
 931 static int
 932 iavf_flow_valid_attr(const struct rte_flow_attr *attr,
 933                      struct rte_flow_error *error)
 934 {
 935         /* Must be input direction */
 936         if (!attr->ingress) {
 937                 rte_flow_error_set(error, EINVAL,
 938                                 RTE_FLOW_ERROR_TYPE_ATTR_INGRESS,
 939                                 attr, "Only support ingress.");
 940                 return -rte_errno;
 941         }
 942
 943         /* Not supported */
 944         if (attr->egress) {
 945                 rte_flow_error_set(error, EINVAL,
 946                                 RTE_FLOW_ERROR_TYPE_ATTR_EGRESS,
 947                                 attr, "Not support egress.");
 948                 return -rte_errno;
 949         }
 950
 951         /* Not supported */
 952         if (attr->priority) {
 953                 rte_flow_error_set(error, EINVAL,
 954                                 RTE_FLOW_ERROR_TYPE_ATTR_PRIORITY,
 955                                 attr, "Not support priority.");
 956                 return -rte_errno;
 957         }
 958
 959         /* Not supported */
 960         if (attr->group) {
 961                 rte_flow_error_set(error, EINVAL,
 962                                 RTE_FLOW_ERROR_TYPE_ATTR_GROUP,
 963                                 attr, "Not support group.");
 964                 return -rte_errno;
 965         }
 966
 967         return 0;
 968 }
 969
 970 /* Find the first VOID or non-VOID item pointer */
 971 static const struct rte_flow_item *
 972 iavf_find_first_item(const struct rte_flow_item *item, bool is_void)
 973 {
 974         bool is_find;
 975
 976         while (item->type != RTE_FLOW_ITEM_TYPE_END) {
 977                 if (is_void)
 978                         is_find = item->type == RTE_FLOW_ITEM_TYPE_VOID;
 979                 else
 980                         is_find = item->type != RTE_FLOW_ITEM_TYPE_VOID;
 981                 if (is_find)
 982                         break;
 983                 item++;
 984         }
 985         return item;
 986 }
 987
 988 /* Skip all VOID items of the pattern */
 989 static void
 990 iavf_pattern_skip_void_item(struct rte_flow_item *items,
 991                         const struct rte_flow_item *pattern)
 992 {
 993         uint32_t cpy_count = 0;
 994         const struct rte_flow_item *pb = pattern, *pe = pattern;
 995
 996         for (;;) {
 997                 /* Find a non-void item first */
 998                 pb = iavf_find_first_item(pb, false);
 999                 if (pb->type == RTE_FLOW_ITEM_TYPE_END) {
1000                         pe = pb;
1001                         break;
1002                 }
1003
1004                 /* Find a void item */
1005                 pe = iavf_find_first_item(pb + 1, true);
1006
1007                 cpy_count = pe - pb;
1008                 rte_memcpy(items, pb, sizeof(struct rte_flow_item) * cpy_count);
1009
1010                 items += cpy_count;
1011
1012                 if (pe->type == RTE_FLOW_ITEM_TYPE_END)
1013                         break;
1014
1015                 pb = pe + 1;
1016         }
1017         /* Copy the END item. */
1018         rte_memcpy(items, pe, sizeof(struct rte_flow_item));
1019 }
1020
1021 /* Check if the pattern matches a supported item type array */
1022 static bool
1023 iavf_match_pattern(enum rte_flow_item_type *item_array,
1024                    const struct rte_flow_item *pattern)
1025 {
1026         const struct rte_flow_item *item = pattern;
1027
1028         while ((*item_array == item->type) &&
1029                (*item_array != RTE_FLOW_ITEM_TYPE_END)) {
1030                 item_array++;
1031                 item++;
1032         }
1033
1034         return (*item_array == RTE_FLOW_ITEM_TYPE_END &&
1035                 item->type == RTE_FLOW_ITEM_TYPE_END);
1036 }
1037
1038 struct iavf_pattern_match_item *
1039 iavf_search_pattern_match_item(const struct rte_flow_item pattern[],
1040                 struct iavf_pattern_match_item *array,
1041                 uint32_t array_len,
1042                 struct rte_flow_error *error)
1043 {
1044         uint16_t i = 0;
1045         struct iavf_pattern_match_item *pattern_match_item;
1046         /* need free by each filter */
1047         struct rte_flow_item *items; /* used for pattern without VOID items */
1048         uint32_t item_num = 0; /* non-void item number */
1049
1050         /* Get the non-void item number of pattern */
1051         while ((pattern + i)->type != RTE_FLOW_ITEM_TYPE_END) {
1052                 if ((pattern + i)->type != RTE_FLOW_ITEM_TYPE_VOID)
1053                         item_num++;
1054                 i++;
1055         }
1056         item_num++;
1057
1058         items = rte_zmalloc("iavf_pattern",
1059                             item_num * sizeof(struct rte_flow_item), 0);
1060         if (!items) {
1061                 rte_flow_error_set(error, ENOMEM, RTE_FLOW_ERROR_TYPE_ITEM_NUM,
1062                                    NULL, "No memory for PMD internal items.");
1063                 return NULL;
1064         }
1065         pattern_match_item = rte_zmalloc("iavf_pattern_match_item",
1066                                 sizeof(struct iavf_pattern_match_item), 0);
1067         if (!pattern_match_item) {
1068                 rte_flow_error_set(error, ENOMEM, RTE_FLOW_ERROR_TYPE_HANDLE,
1069                                    NULL, "Failed to allocate memory.");
1070                 return NULL;
1071         }
1072
1073         iavf_pattern_skip_void_item(items, pattern);
1074
1075         for (i = 0; i < array_len; i++)
1076                 if (iavf_match_pattern(array[i].pattern_list,
1077                                        items)) {
1078                         pattern_match_item->input_set_mask =
1079                                 array[i].input_set_mask;
1080                         pattern_match_item->pattern_list =
1081                                 array[i].pattern_list;
1082                         pattern_match_item->meta = array[i].meta;
1083                         rte_free(items);
1084                         return pattern_match_item;
1085                 }
1086         rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_ITEM,
1087                            pattern, "Unsupported pattern");
1088
1089         rte_free(items);
1090         rte_free(pattern_match_item);
1091         return NULL;
1092 }
1093
1094 static struct iavf_flow_engine *
1095 iavf_parse_engine_create(struct iavf_adapter *ad,
1096                 struct rte_flow *flow,
1097                 struct iavf_parser_list *parser_list,
1098                 const struct rte_flow_item pattern[],
1099                 const struct rte_flow_action actions[],
1100                 struct rte_flow_error *error)
1101 {
1102         struct iavf_flow_engine *engine = NULL;
1103         struct iavf_flow_parser_node *parser_node;
1104         void *temp;
1105         void *meta = NULL;
1106
1107         TAILQ_FOREACH_SAFE(parser_node, parser_list, node, temp) {
1108                 if (parser_node->parser->parse_pattern_action(ad,
1109                                 parser_node->parser->array,
1110                                 parser_node->parser->array_len,
1111                                 pattern, actions, &meta, error) < 0)
1112                         continue;
1113
1114                 engine = parser_node->parser->engine;
1115
1116                 RTE_ASSERT(engine->create != NULL);
1117                 if (!(engine->create(ad, flow, meta, error)))
1118                         return engine;
1119         }
1120         return NULL;
1121 }
1122
1123 static struct iavf_flow_engine *
1124 iavf_parse_engine_validate(struct iavf_adapter *ad,
1125                 struct rte_flow *flow,
1126                 struct iavf_parser_list *parser_list,
1127                 const struct rte_flow_item pattern[],
1128                 const struct rte_flow_action actions[],
1129                 struct rte_flow_error *error)
1130 {
1131         struct iavf_flow_engine *engine = NULL;
1132         struct iavf_flow_parser_node *parser_node;
1133         void *temp;
1134         void *meta = NULL;
1135
1136         TAILQ_FOREACH_SAFE(parser_node, parser_list, node, temp) {
1137                 if (parser_node->parser->parse_pattern_action(ad,
1138                                 parser_node->parser->array,
1139                                 parser_node->parser->array_len,
1140                                 pattern, actions, &meta,  error) < 0)
1141                         continue;
1142
1143                 engine = parser_node->parser->engine;
1144                 if (engine->validation == NULL) {
1145                         rte_flow_error_set(error, EINVAL,
1146                                 RTE_FLOW_ERROR_TYPE_HANDLE,
1147                                 NULL, "Validation not support");
1148                         continue;
1149                 }
1150
1151                 if (engine->validation(ad, flow, meta, error)) {
1152                         rte_flow_error_set(error, EINVAL,
1153                                 RTE_FLOW_ERROR_TYPE_HANDLE,
1154                                 NULL, "Validation failed");
1155                         break;
1156                 }
1157         }
1158         return engine;
1159 }
1160
1161
1162 static int
1163 iavf_flow_process_filter(struct rte_eth_dev *dev,
1164                 struct rte_flow *flow,
1165                 const struct rte_flow_attr *attr,
1166                 const struct rte_flow_item pattern[],
1167                 const struct rte_flow_action actions[],
1168                 struct iavf_flow_engine **engine,
1169                 parse_engine_t iavf_parse_engine,
1170                 struct rte_flow_error *error)
1171 {
1172         int ret = IAVF_ERR_CONFIG;
1173         struct iavf_adapter *ad =
1174                 IAVF_DEV_PRIVATE_TO_ADAPTER(dev->data->dev_private);
1175         struct iavf_info *vf = IAVF_DEV_PRIVATE_TO_VF(ad);
1176
1177         if (!pattern) {
1178                 rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_ITEM_NUM,
1179                                    NULL, "NULL pattern.");
1180                 return -rte_errno;
1181         }
1182
1183         if (!actions) {
1184                 rte_flow_error_set(error, EINVAL,
1185                                    RTE_FLOW_ERROR_TYPE_ACTION_NUM,
1186                                    NULL, "NULL action.");
1187                 return -rte_errno;
1188         }
1189
1190         if (!attr) {
1191                 rte_flow_error_set(error, EINVAL,
1192                                    RTE_FLOW_ERROR_TYPE_ATTR,
1193                                    NULL, "NULL attribute.");
1194                 return -rte_errno;
1195         }
1196
1197         ret = iavf_flow_valid_attr(attr, error);
1198         if (ret)
1199                 return ret;
1200
1201         *engine = iavf_parse_engine(ad, flow, &vf->rss_parser_list, pattern,
1202                                     actions, error);
1203         if (*engine)
1204                 return 0;
1205
1206         *engine = iavf_parse_engine(ad, flow, &vf->dist_parser_list, pattern,
1207                                     actions, error);
1208
1209         if (!*engine) {
1210                 rte_flow_error_set(error, EINVAL,
1211                                    RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
1212                                    "Failed to create parser engine.");
1213                 return -rte_errno;
1214         }
1215
1216         return 0;
1217 }
1218
1219 static int
1220 iavf_flow_validate(struct rte_eth_dev *dev,
1221                 const struct rte_flow_attr *attr,
1222                 const struct rte_flow_item pattern[],
1223                 const struct rte_flow_action actions[],
1224                 struct rte_flow_error *error)
1225 {
1226         struct iavf_flow_engine *engine;
1227
1228         return iavf_flow_process_filter(dev, NULL, attr, pattern, actions,
1229                         &engine, iavf_parse_engine_validate, error);
1230 }
1231
1232 static struct rte_flow *
1233 iavf_flow_create(struct rte_eth_dev *dev,
1234                  const struct rte_flow_attr *attr,
1235                  const struct rte_flow_item pattern[],
1236                  const struct rte_flow_action actions[],
1237                  struct rte_flow_error *error)
1238 {
1239         struct iavf_adapter *ad =
1240                 IAVF_DEV_PRIVATE_TO_ADAPTER(dev->data->dev_private);
1241         struct iavf_info *vf = IAVF_DEV_PRIVATE_TO_VF(ad);
1242         struct iavf_flow_engine *engine = NULL;
1243         struct rte_flow *flow = NULL;
1244         int ret;
1245
1246         flow = rte_zmalloc("iavf_flow", sizeof(struct rte_flow), 0);
1247         if (!flow) {
1248                 rte_flow_error_set(error, ENOMEM,
1249                                    RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
1250                                    "Failed to allocate memory");
1251                 return flow;
1252         }
1253
1254         ret = iavf_flow_process_filter(dev, flow, attr, pattern, actions,
1255                         &engine, iavf_parse_engine_create, error);
1256         if (ret < 0) {
1257                 PMD_DRV_LOG(ERR, "Failed to create flow");
1258                 rte_free(flow);
1259                 flow = NULL;
1260                 goto free_flow;
1261         }
1262
1263         flow->engine = engine;
1264         TAILQ_INSERT_TAIL(&vf->flow_list, flow, node);
1265         PMD_DRV_LOG(INFO, "Succeeded to create (%d) flow", engine->type);
1266
1267 free_flow:
1268         rte_spinlock_unlock(&vf->flow_ops_lock);
1269         return flow;
1270 }
1271
1272 static bool
1273 iavf_flow_is_valid(struct rte_flow *flow)
1274 {
1275         struct iavf_flow_engine *engine;
1276         void *temp;
1277
1278         if (flow && flow->engine) {
1279                 TAILQ_FOREACH_SAFE(engine, &engine_list, node, temp) {
1280                         if (engine == flow->engine)
1281                                 return true;
1282                 }
1283         }
1284
1285         return false;
1286 }
1287
1288 static int
1289 iavf_flow_destroy(struct rte_eth_dev *dev,
1290                   struct rte_flow *flow,
1291                   struct rte_flow_error *error)
1292 {
1293         struct iavf_adapter *ad =
1294                 IAVF_DEV_PRIVATE_TO_ADAPTER(dev->data->dev_private);
1295         struct iavf_info *vf = IAVF_DEV_PRIVATE_TO_VF(ad);
1296         int ret = 0;
1297
1298         if (!iavf_flow_is_valid(flow) || !flow->engine->destroy) {
1299                 rte_flow_error_set(error, EINVAL,
1300                                    RTE_FLOW_ERROR_TYPE_HANDLE,
1301                                    NULL, "Invalid flow destroy");
1302                 return -rte_errno;
1303         }
1304
1305         rte_spinlock_lock(&vf->flow_ops_lock);
1306
1307         ret = flow->engine->destroy(ad, flow, error);
1308
1309         if (!ret) {
1310                 TAILQ_REMOVE(&vf->flow_list, flow, node);
1311                 rte_free(flow);
1312         } else {
1313                 PMD_DRV_LOG(ERR, "Failed to destroy flow");
1314         }
1315
1316         rte_spinlock_unlock(&vf->flow_ops_lock);
1317
1318         return ret;
1319 }
1320
1321 int
1322 iavf_flow_flush(struct rte_eth_dev *dev,
1323                 struct rte_flow_error *error)
1324 {
1325         struct iavf_adapter *ad =
1326                 IAVF_DEV_PRIVATE_TO_ADAPTER(dev->data->dev_private);
1327         struct iavf_info *vf = IAVF_DEV_PRIVATE_TO_VF(ad);
1328         struct rte_flow *p_flow;
1329         void *temp;
1330         int ret = 0;
1331
1332         TAILQ_FOREACH_SAFE(p_flow, &vf->flow_list, node, temp) {
1333                 ret = iavf_flow_destroy(dev, p_flow, error);
1334                 if (ret) {
1335                         PMD_DRV_LOG(ERR, "Failed to flush flows");
1336                         return -EINVAL;
1337                 }
1338         }
1339
1340         return ret;
1341 }
1342
1343 static int
1344 iavf_flow_query(struct rte_eth_dev *dev,
1345                 struct rte_flow *flow,
1346                 const struct rte_flow_action *actions,
1347                 void *data,
1348                 struct rte_flow_error *error)
1349 {
1350         int ret = -EINVAL;
1351         struct iavf_adapter *ad =
1352                 IAVF_DEV_PRIVATE_TO_ADAPTER(dev->data->dev_private);
1353         struct rte_flow_query_count *count = data;
1354
1355         if (!iavf_flow_is_valid(flow) || !flow->engine->query_count) {
1356                 rte_flow_error_set(error, EINVAL,
1357                                    RTE_FLOW_ERROR_TYPE_HANDLE,
1358                                    NULL, "Invalid flow query");
1359                 return -rte_errno;
1360         }
1361
1362         for (; actions->type != RTE_FLOW_ACTION_TYPE_END; actions++) {
1363                 switch (actions->type) {
1364                 case RTE_FLOW_ACTION_TYPE_VOID:
1365                         break;
1366                 case RTE_FLOW_ACTION_TYPE_COUNT:
1367                         ret = flow->engine->query_count(ad, flow, count, error);
1368                         break;
1369                 default:
1370                         return rte_flow_error_set(error, ENOTSUP,
1371                                         RTE_FLOW_ERROR_TYPE_ACTION,
1372                                         actions,
1373                                         "action not supported");
1374                 }
1375         }
1376         return ret;
1377 }
1378