lib/librte_ethdev/rte_flow.h

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright 2016 6WIND S.A.
   3  * Copyright 2016 Mellanox Technologies, Ltd
   4  */
   5
   6 #ifndef RTE_FLOW_H_
   7 #define RTE_FLOW_H_
   8
   9 /**
  10  * @file
  11  * RTE generic flow API
  12  *
  13  * This interface provides the ability to program packet matching and
  14  * associated actions in hardware through flow rules.
  15  */
  16
  17 #include <stddef.h>
  18 #include <stdint.h>
  19
  20 #include <rte_arp.h>
  21 #include <rte_common.h>
  22 #include <rte_ether.h>
  23 #include <rte_eth_ctrl.h>
  24 #include <rte_icmp.h>
  25 #include <rte_ip.h>
  26 #include <rte_sctp.h>
  27 #include <rte_tcp.h>
  28 #include <rte_udp.h>
  29 #include <rte_byteorder.h>
  30 #include <rte_esp.h>
  31
  32 #ifdef __cplusplus
  33 extern "C" {
  34 #endif
  35
  36 /**
  37  * Flow rule attributes.
  38  *
  39  * Priorities are set on a per rule based within groups.
  40  *
  41  * Lower values denote higher priority, the highest priority for a flow rule
  42  * is 0, so that a flow that matches for than one rule, the rule with the
  43  * lowest priority value will always be matched.
  44  *
  45  * Although optional, applications are encouraged to group similar rules as
  46  * much as possible to fully take advantage of hardware capabilities
  47  * (e.g. optimized matching) and work around limitations (e.g. a single
  48  * pattern type possibly allowed in a given group). Applications should be
  49  * aware that groups are not linked by default, and that they must be
  50  * explicitly linked by the application using the JUMP action.
  51  *
  52  * Priority levels are arbitrary and up to the application, they
  53  * do not need to be contiguous nor start from 0, however the maximum number
  54  * varies between devices and may be affected by existing flow rules.
  55  *
  56  * If a packet is matched by several rules of a given group for a given
  57  * priority level, the outcome is undefined. It can take any path, may be
  58  * duplicated or even cause unrecoverable errors.
  59  *
  60  * Note that support for more than a single group and priority level is not
  61  * guaranteed.
  62  *
  63  * Flow rules can apply to inbound and/or outbound traffic (ingress/egress).
  64  *
  65  * Several pattern items and actions are valid and can be used in both
  66  * directions. Those valid for only one direction are described as such.
  67  *
  68  * At least one direction must be specified.
  69  *
  70  * Specifying both directions at once for a given rule is not recommended
  71  * but may be valid in a few cases (e.g. shared counter).
  72  */
  73 struct rte_flow_attr {
  74         uint32_t group; /**< Priority group. */
  75         uint32_t priority; /**< Rule priority level within group. */
  76         uint32_t ingress:1; /**< Rule applies to ingress traffic. */
  77         uint32_t egress:1; /**< Rule applies to egress traffic. */
  78         /**
  79          * Instead of simply matching the properties of traffic as it would
  80          * appear on a given DPDK port ID, enabling this attribute transfers
  81          * a flow rule to the lowest possible level of any device endpoints
  82          * found in the pattern.
  83          *
  84          * When supported, this effectively enables an application to
  85          * re-route traffic not necessarily intended for it (e.g. coming
  86          * from or addressed to different physical ports, VFs or
  87          * applications) at the device level.
  88          *
  89          * It complements the behavior of some pattern items such as
  90          * RTE_FLOW_ITEM_TYPE_PHY_PORT and is meaningless without them.
  91          *
  92          * When transferring flow rules, ingress and egress attributes keep
  93          * their original meaning, as if processing traffic emitted or
  94          * received by the application.
  95          */
  96         uint32_t transfer:1;
  97         uint32_t reserved:29; /**< Reserved, must be zero. */
  98 };
  99
 100 /**
 101  * Matching pattern item types.
 102  *
 103  * Pattern items fall in two categories:
 104  *
 105  * - Matching protocol headers and packet data, usually associated with a
 106  *   specification structure. These must be stacked in the same order as the
 107  *   protocol layers to match inside packets, starting from the lowest.
 108  *
 109  * - Matching meta-data or affecting pattern processing, often without a
 110  *   specification structure. Since they do not match packet contents, their
 111  *   position in the list is usually not relevant.
 112  *
 113  * See the description of individual types for more information. Those
 114  * marked with [META] fall into the second category.
 115  */
 116 enum rte_flow_item_type {
 117         /**
 118          * [META]
 119          *
 120          * End marker for item lists. Prevents further processing of items,
 121          * thereby ending the pattern.
 122          *
 123          * No associated specification structure.
 124          */
 125         RTE_FLOW_ITEM_TYPE_END,
 126
 127         /**
 128          * [META]
 129          *
 130          * Used as a placeholder for convenience. It is ignored and simply
 131          * discarded by PMDs.
 132          *
 133          * No associated specification structure.
 134          */
 135         RTE_FLOW_ITEM_TYPE_VOID,
 136
 137         /**
 138          * [META]
 139          *
 140          * Inverted matching, i.e. process packets that do not match the
 141          * pattern.
 142          *
 143          * No associated specification structure.
 144          */
 145         RTE_FLOW_ITEM_TYPE_INVERT,
 146
 147         /**
 148          * Matches any protocol in place of the current layer, a single ANY
 149          * may also stand for several protocol layers.
 150          *
 151          * See struct rte_flow_item_any.
 152          */
 153         RTE_FLOW_ITEM_TYPE_ANY,
 154
 155         /**
 156          * [META]
 157          *
 158          * Matches traffic originating from (ingress) or going to (egress)
 159          * the physical function of the current device.
 160          *
 161          * No associated specification structure.
 162          */
 163         RTE_FLOW_ITEM_TYPE_PF,
 164
 165         /**
 166          * [META]
 167          *
 168          * Matches traffic originating from (ingress) or going to (egress) a
 169          * given virtual function of the current device.
 170          *
 171          * See struct rte_flow_item_vf.
 172          */
 173         RTE_FLOW_ITEM_TYPE_VF,
 174
 175         /**
 176          * [META]
 177          *
 178          * Matches traffic originating from (ingress) or going to (egress) a
 179          * physical port of the underlying device.
 180          *
 181          * See struct rte_flow_item_phy_port.
 182          */
 183         RTE_FLOW_ITEM_TYPE_PHY_PORT,
 184
 185         /**
 186          * [META]
 187          *
 188          * Matches traffic originating from (ingress) or going to (egress) a
 189          * given DPDK port ID.
 190          *
 191          * See struct rte_flow_item_port_id.
 192          */
 193         RTE_FLOW_ITEM_TYPE_PORT_ID,
 194
 195         /**
 196          * Matches a byte string of a given length at a given offset.
 197          *
 198          * See struct rte_flow_item_raw.
 199          */
 200         RTE_FLOW_ITEM_TYPE_RAW,
 201
 202         /**
 203          * Matches an Ethernet header.
 204          *
 205          * See struct rte_flow_item_eth.
 206          */
 207         RTE_FLOW_ITEM_TYPE_ETH,
 208
 209         /**
 210          * Matches an 802.1Q/ad VLAN tag.
 211          *
 212          * See struct rte_flow_item_vlan.
 213          */
 214         RTE_FLOW_ITEM_TYPE_VLAN,
 215
 216         /**
 217          * Matches an IPv4 header.
 218          *
 219          * See struct rte_flow_item_ipv4.
 220          */
 221         RTE_FLOW_ITEM_TYPE_IPV4,
 222
 223         /**
 224          * Matches an IPv6 header.
 225          *
 226          * See struct rte_flow_item_ipv6.
 227          */
 228         RTE_FLOW_ITEM_TYPE_IPV6,
 229
 230         /**
 231          * Matches an ICMP header.
 232          *
 233          * See struct rte_flow_item_icmp.
 234          */
 235         RTE_FLOW_ITEM_TYPE_ICMP,
 236
 237         /**
 238          * Matches a UDP header.
 239          *
 240          * See struct rte_flow_item_udp.
 241          */
 242         RTE_FLOW_ITEM_TYPE_UDP,
 243
 244         /**
 245          * Matches a TCP header.
 246          *
 247          * See struct rte_flow_item_tcp.
 248          */
 249         RTE_FLOW_ITEM_TYPE_TCP,
 250
 251         /**
 252          * Matches a SCTP header.
 253          *
 254          * See struct rte_flow_item_sctp.
 255          */
 256         RTE_FLOW_ITEM_TYPE_SCTP,
 257
 258         /**
 259          * Matches a VXLAN header.
 260          *
 261          * See struct rte_flow_item_vxlan.
 262          */
 263         RTE_FLOW_ITEM_TYPE_VXLAN,
 264
 265         /**
 266          * Matches a E_TAG header.
 267          *
 268          * See struct rte_flow_item_e_tag.
 269          */
 270         RTE_FLOW_ITEM_TYPE_E_TAG,
 271
 272         /**
 273          * Matches a NVGRE header.
 274          *
 275          * See struct rte_flow_item_nvgre.
 276          */
 277         RTE_FLOW_ITEM_TYPE_NVGRE,
 278
 279         /**
 280          * Matches a MPLS header.
 281          *
 282          * See struct rte_flow_item_mpls.
 283          */
 284         RTE_FLOW_ITEM_TYPE_MPLS,
 285
 286         /**
 287          * Matches a GRE header.
 288          *
 289          * See struct rte_flow_item_gre.
 290          */
 291         RTE_FLOW_ITEM_TYPE_GRE,
 292
 293         /**
 294          * [META]
 295          *
 296          * Fuzzy pattern match, expect faster than default.
 297          *
 298          * This is for device that support fuzzy matching option.
 299          * Usually a fuzzy matching is fast but the cost is accuracy.
 300          *
 301          * See struct rte_flow_item_fuzzy.
 302          */
 303         RTE_FLOW_ITEM_TYPE_FUZZY,
 304
 305         /**
 306          * Matches a GTP header.
 307          *
 308          * Configure flow for GTP packets.
 309          *
 310          * See struct rte_flow_item_gtp.
 311          */
 312         RTE_FLOW_ITEM_TYPE_GTP,
 313
 314         /**
 315          * Matches a GTP header.
 316          *
 317          * Configure flow for GTP-C packets.
 318          *
 319          * See struct rte_flow_item_gtp.
 320          */
 321         RTE_FLOW_ITEM_TYPE_GTPC,
 322
 323         /**
 324          * Matches a GTP header.
 325          *
 326          * Configure flow for GTP-U packets.
 327          *
 328          * See struct rte_flow_item_gtp.
 329          */
 330         RTE_FLOW_ITEM_TYPE_GTPU,
 331
 332         /**
 333          * Matches a ESP header.
 334          *
 335          * See struct rte_flow_item_esp.
 336          */
 337         RTE_FLOW_ITEM_TYPE_ESP,
 338
 339         /**
 340          * Matches a GENEVE header.
 341          *
 342          * See struct rte_flow_item_geneve.
 343          */
 344         RTE_FLOW_ITEM_TYPE_GENEVE,
 345
 346         /**
 347          * Matches a VXLAN-GPE header.
 348          *
 349          * See struct rte_flow_item_vxlan_gpe.
 350          */
 351         RTE_FLOW_ITEM_TYPE_VXLAN_GPE,
 352
 353         /**
 354          * Matches an ARP header for Ethernet/IPv4.
 355          *
 356          * See struct rte_flow_item_arp_eth_ipv4.
 357          */
 358         RTE_FLOW_ITEM_TYPE_ARP_ETH_IPV4,
 359
 360         /**
 361          * Matches the presence of any IPv6 extension header.
 362          *
 363          * See struct rte_flow_item_ipv6_ext.
 364          */
 365         RTE_FLOW_ITEM_TYPE_IPV6_EXT,
 366
 367         /**
 368          * Matches any ICMPv6 header.
 369          *
 370          * See struct rte_flow_item_icmp6.
 371          */
 372         RTE_FLOW_ITEM_TYPE_ICMP6,
 373
 374         /**
 375          * Matches an ICMPv6 neighbor discovery solicitation.
 376          *
 377          * See struct rte_flow_item_icmp6_nd_ns.
 378          */
 379         RTE_FLOW_ITEM_TYPE_ICMP6_ND_NS,
 380
 381         /**
 382          * Matches an ICMPv6 neighbor discovery advertisement.
 383          *
 384          * See struct rte_flow_item_icmp6_nd_na.
 385          */
 386         RTE_FLOW_ITEM_TYPE_ICMP6_ND_NA,
 387
 388         /**
 389          * Matches the presence of any ICMPv6 neighbor discovery option.
 390          *
 391          * See struct rte_flow_item_icmp6_nd_opt.
 392          */
 393         RTE_FLOW_ITEM_TYPE_ICMP6_ND_OPT,
 394
 395         /**
 396          * Matches an ICMPv6 neighbor discovery source Ethernet link-layer
 397          * address option.
 398          *
 399          * See struct rte_flow_item_icmp6_nd_opt_sla_eth.
 400          */
 401         RTE_FLOW_ITEM_TYPE_ICMP6_ND_OPT_SLA_ETH,
 402
 403         /**
 404          * Matches an ICMPv6 neighbor discovery target Ethernet link-layer
 405          * address option.
 406          *
 407          * See struct rte_flow_item_icmp6_nd_opt_tla_eth.
 408          */
 409         RTE_FLOW_ITEM_TYPE_ICMP6_ND_OPT_TLA_ETH,
 410
 411         /**
 412          * Matches specified mark field.
 413          *
 414          * See struct rte_flow_item_mark.
 415          */
 416         RTE_FLOW_ITEM_TYPE_MARK,
 417 };
 418
 419 /**
 420  * RTE_FLOW_ITEM_TYPE_ANY
 421  *
 422  * Matches any protocol in place of the current layer, a single ANY may also
 423  * stand for several protocol layers.
 424  *
 425  * This is usually specified as the first pattern item when looking for a
 426  * protocol anywhere in a packet.
 427  *
 428  * A zeroed mask stands for any number of layers.
 429  */
 430 struct rte_flow_item_any {
 431         uint32_t num; /**< Number of layers covered. */
 432 };
 433
 434 /** Default mask for RTE_FLOW_ITEM_TYPE_ANY. */
 435 #ifndef __cplusplus
 436 static const struct rte_flow_item_any rte_flow_item_any_mask = {
 437         .num = 0x00000000,
 438 };
 439 #endif
 440
 441 /**
 442  * RTE_FLOW_ITEM_TYPE_VF
 443  *
 444  * Matches traffic originating from (ingress) or going to (egress) a given
 445  * virtual function of the current device.
 446  *
 447  * If supported, should work even if the virtual function is not managed by
 448  * the application and thus not associated with a DPDK port ID.
 449  *
 450  * Note this pattern item does not match VF representors traffic which, as
 451  * separate entities, should be addressed through their own DPDK port IDs.
 452  *
 453  * - Can be specified multiple times to match traffic addressed to several
 454  *   VF IDs.
 455  * - Can be combined with a PF item to match both PF and VF traffic.
 456  *
 457  * A zeroed mask can be used to match any VF ID.
 458  */
 459 struct rte_flow_item_vf {
 460         uint32_t id; /**< VF ID. */
 461 };
 462
 463 /** Default mask for RTE_FLOW_ITEM_TYPE_VF. */
 464 #ifndef __cplusplus
 465 static const struct rte_flow_item_vf rte_flow_item_vf_mask = {
 466         .id = 0x00000000,
 467 };
 468 #endif
 469
 470 /**
 471  * RTE_FLOW_ITEM_TYPE_PHY_PORT
 472  *
 473  * Matches traffic originating from (ingress) or going to (egress) a
 474  * physical port of the underlying device.
 475  *
 476  * The first PHY_PORT item overrides the physical port normally associated
 477  * with the specified DPDK input port (port_id). This item can be provided
 478  * several times to match additional physical ports.
 479  *
 480  * Note that physical ports are not necessarily tied to DPDK input ports
 481  * (port_id) when those are not under DPDK control. Possible values are
 482  * specific to each device, they are not necessarily indexed from zero and
 483  * may not be contiguous.
 484  *
 485  * As a device property, the list of allowed values as well as the value
 486  * associated with a port_id should be retrieved by other means.
 487  *
 488  * A zeroed mask can be used to match any port index.
 489  */
 490 struct rte_flow_item_phy_port {
 491         uint32_t index; /**< Physical port index. */
 492 };
 493
 494 /** Default mask for RTE_FLOW_ITEM_TYPE_PHY_PORT. */
 495 #ifndef __cplusplus
 496 static const struct rte_flow_item_phy_port rte_flow_item_phy_port_mask = {
 497         .index = 0x00000000,
 498 };
 499 #endif
 500
 501 /**
 502  * RTE_FLOW_ITEM_TYPE_PORT_ID
 503  *
 504  * Matches traffic originating from (ingress) or going to (egress) a given
 505  * DPDK port ID.
 506  *
 507  * Normally only supported if the port ID in question is known by the
 508  * underlying PMD and related to the device the flow rule is created
 509  * against.
 510  *
 511  * This must not be confused with @p PHY_PORT which refers to the physical
 512  * port of a device, whereas @p PORT_ID refers to a struct rte_eth_dev
 513  * object on the application side (also known as "port representor"
 514  * depending on the kind of underlying device).
 515  */
 516 struct rte_flow_item_port_id {
 517         uint32_t id; /**< DPDK port ID. */
 518 };
 519
 520 /** Default mask for RTE_FLOW_ITEM_TYPE_PORT_ID. */
 521 #ifndef __cplusplus
 522 static const struct rte_flow_item_port_id rte_flow_item_port_id_mask = {
 523         .id = 0xffffffff,
 524 };
 525 #endif
 526
 527 /**
 528  * RTE_FLOW_ITEM_TYPE_RAW
 529  *
 530  * Matches a byte string of a given length at a given offset.
 531  *
 532  * Offset is either absolute (using the start of the packet) or relative to
 533  * the end of the previous matched item in the stack, in which case negative
 534  * values are allowed.
 535  *
 536  * If search is enabled, offset is used as the starting point. The search
 537  * area can be delimited by setting limit to a nonzero value, which is the
 538  * maximum number of bytes after offset where the pattern may start.
 539  *
 540  * Matching a zero-length pattern is allowed, doing so resets the relative
 541  * offset for subsequent items.
 542  *
 543  * This type does not support ranges (struct rte_flow_item.last).
 544  */
 545 struct rte_flow_item_raw {
 546         uint32_t relative:1; /**< Look for pattern after the previous item. */
 547         uint32_t search:1; /**< Search pattern from offset (see also limit). */
 548         uint32_t reserved:30; /**< Reserved, must be set to zero. */
 549         int32_t offset; /**< Absolute or relative offset for pattern. */
 550         uint16_t limit; /**< Search area limit for start of pattern. */
 551         uint16_t length; /**< Pattern length. */
 552         const uint8_t *pattern; /**< Byte string to look for. */
 553 };
 554
 555 /** Default mask for RTE_FLOW_ITEM_TYPE_RAW. */
 556 #ifndef __cplusplus
 557 static const struct rte_flow_item_raw rte_flow_item_raw_mask = {
 558         .relative = 1,
 559         .search = 1,
 560         .reserved = 0x3fffffff,
 561         .offset = 0xffffffff,
 562         .limit = 0xffff,
 563         .length = 0xffff,
 564         .pattern = NULL,
 565 };
 566 #endif
 567
 568 /**
 569  * RTE_FLOW_ITEM_TYPE_ETH
 570  *
 571  * Matches an Ethernet header.
 572  *
 573  * The @p type field either stands for "EtherType" or "TPID" when followed
 574  * by so-called layer 2.5 pattern items such as RTE_FLOW_ITEM_TYPE_VLAN. In
 575  * the latter case, @p type refers to that of the outer header, with the
 576  * inner EtherType/TPID provided by the subsequent pattern item. This is the
 577  * same order as on the wire.
 578  */
 579 struct rte_flow_item_eth {
 580         struct ether_addr dst; /**< Destination MAC. */
 581         struct ether_addr src; /**< Source MAC. */
 582         rte_be16_t type; /**< EtherType or TPID. */
 583 };
 584
 585 /** Default mask for RTE_FLOW_ITEM_TYPE_ETH. */
 586 #ifndef __cplusplus
 587 static const struct rte_flow_item_eth rte_flow_item_eth_mask = {
 588         .dst.addr_bytes = "\xff\xff\xff\xff\xff\xff",
 589         .src.addr_bytes = "\xff\xff\xff\xff\xff\xff",
 590         .type = RTE_BE16(0x0000),
 591 };
 592 #endif
 593
 594 /**
 595  * RTE_FLOW_ITEM_TYPE_VLAN
 596  *
 597  * Matches an 802.1Q/ad VLAN tag.
 598  *
 599  * The corresponding standard outer EtherType (TPID) values are
 600  * ETHER_TYPE_VLAN or ETHER_TYPE_QINQ. It can be overridden by the preceding
 601  * pattern item.
 602  */
 603 struct rte_flow_item_vlan {
 604         rte_be16_t tci; /**< Tag control information. */
 605         rte_be16_t inner_type; /**< Inner EtherType or TPID. */
 606 };
 607
 608 /** Default mask for RTE_FLOW_ITEM_TYPE_VLAN. */
 609 #ifndef __cplusplus
 610 static const struct rte_flow_item_vlan rte_flow_item_vlan_mask = {
 611         .tci = RTE_BE16(0x0fff),
 612         .inner_type = RTE_BE16(0x0000),
 613 };
 614 #endif
 615
 616 /**
 617  * RTE_FLOW_ITEM_TYPE_IPV4
 618  *
 619  * Matches an IPv4 header.
 620  *
 621  * Note: IPv4 options are handled by dedicated pattern items.
 622  */
 623 struct rte_flow_item_ipv4 {
 624         struct ipv4_hdr hdr; /**< IPv4 header definition. */
 625 };
 626
 627 /** Default mask for RTE_FLOW_ITEM_TYPE_IPV4. */
 628 #ifndef __cplusplus
 629 static const struct rte_flow_item_ipv4 rte_flow_item_ipv4_mask = {
 630         .hdr = {
 631                 .src_addr = RTE_BE32(0xffffffff),
 632                 .dst_addr = RTE_BE32(0xffffffff),
 633         },
 634 };
 635 #endif
 636
 637 /**
 638  * RTE_FLOW_ITEM_TYPE_IPV6.
 639  *
 640  * Matches an IPv6 header.
 641  *
 642  * Note: IPv6 options are handled by dedicated pattern items, see
 643  * RTE_FLOW_ITEM_TYPE_IPV6_EXT.
 644  */
 645 struct rte_flow_item_ipv6 {
 646         struct ipv6_hdr hdr; /**< IPv6 header definition. */
 647 };
 648
 649 /** Default mask for RTE_FLOW_ITEM_TYPE_IPV6. */
 650 #ifndef __cplusplus
 651 static const struct rte_flow_item_ipv6 rte_flow_item_ipv6_mask = {
 652         .hdr = {
 653                 .src_addr =
 654                         "\xff\xff\xff\xff\xff\xff\xff\xff"
 655                         "\xff\xff\xff\xff\xff\xff\xff\xff",
 656                 .dst_addr =
 657                         "\xff\xff\xff\xff\xff\xff\xff\xff"
 658                         "\xff\xff\xff\xff\xff\xff\xff\xff",
 659         },
 660 };
 661 #endif
 662
 663 /**
 664  * RTE_FLOW_ITEM_TYPE_ICMP.
 665  *
 666  * Matches an ICMP header.
 667  */
 668 struct rte_flow_item_icmp {
 669         struct icmp_hdr hdr; /**< ICMP header definition. */
 670 };
 671
 672 /** Default mask for RTE_FLOW_ITEM_TYPE_ICMP. */
 673 #ifndef __cplusplus
 674 static const struct rte_flow_item_icmp rte_flow_item_icmp_mask = {
 675         .hdr = {
 676                 .icmp_type = 0xff,
 677                 .icmp_code = 0xff,
 678         },
 679 };
 680 #endif
 681
 682 /**
 683  * RTE_FLOW_ITEM_TYPE_UDP.
 684  *
 685  * Matches a UDP header.
 686  */
 687 struct rte_flow_item_udp {
 688         struct udp_hdr hdr; /**< UDP header definition. */
 689 };
 690
 691 /** Default mask for RTE_FLOW_ITEM_TYPE_UDP. */
 692 #ifndef __cplusplus
 693 static const struct rte_flow_item_udp rte_flow_item_udp_mask = {
 694         .hdr = {
 695                 .src_port = RTE_BE16(0xffff),
 696                 .dst_port = RTE_BE16(0xffff),
 697         },
 698 };
 699 #endif
 700
 701 /**
 702  * RTE_FLOW_ITEM_TYPE_TCP.
 703  *
 704  * Matches a TCP header.
 705  */
 706 struct rte_flow_item_tcp {
 707         struct tcp_hdr hdr; /**< TCP header definition. */
 708 };
 709
 710 /** Default mask for RTE_FLOW_ITEM_TYPE_TCP. */
 711 #ifndef __cplusplus
 712 static const struct rte_flow_item_tcp rte_flow_item_tcp_mask = {
 713         .hdr = {
 714                 .src_port = RTE_BE16(0xffff),
 715                 .dst_port = RTE_BE16(0xffff),
 716         },
 717 };
 718 #endif
 719
 720 /**
 721  * RTE_FLOW_ITEM_TYPE_SCTP.
 722  *
 723  * Matches a SCTP header.
 724  */
 725 struct rte_flow_item_sctp {
 726         struct sctp_hdr hdr; /**< SCTP header definition. */
 727 };
 728
 729 /** Default mask for RTE_FLOW_ITEM_TYPE_SCTP. */
 730 #ifndef __cplusplus
 731 static const struct rte_flow_item_sctp rte_flow_item_sctp_mask = {
 732         .hdr = {
 733                 .src_port = RTE_BE16(0xffff),
 734                 .dst_port = RTE_BE16(0xffff),
 735         },
 736 };
 737 #endif
 738
 739 /**
 740  * RTE_FLOW_ITEM_TYPE_VXLAN.
 741  *
 742  * Matches a VXLAN header (RFC 7348).
 743  */
 744 struct rte_flow_item_vxlan {
 745         uint8_t flags; /**< Normally 0x08 (I flag). */
 746         uint8_t rsvd0[3]; /**< Reserved, normally 0x000000. */
 747         uint8_t vni[3]; /**< VXLAN identifier. */
 748         uint8_t rsvd1; /**< Reserved, normally 0x00. */
 749 };
 750
 751 /** Default mask for RTE_FLOW_ITEM_TYPE_VXLAN. */
 752 #ifndef __cplusplus
 753 static const struct rte_flow_item_vxlan rte_flow_item_vxlan_mask = {
 754         .vni = "\xff\xff\xff",
 755 };
 756 #endif
 757
 758 /**
 759  * RTE_FLOW_ITEM_TYPE_E_TAG.
 760  *
 761  * Matches a E-tag header.
 762  *
 763  * The corresponding standard outer EtherType (TPID) value is
 764  * ETHER_TYPE_ETAG. It can be overridden by the preceding pattern item.
 765  */
 766 struct rte_flow_item_e_tag {
 767         /**
 768          * E-Tag control information (E-TCI).
 769          * E-PCP (3b), E-DEI (1b), ingress E-CID base (12b).
 770          */
 771         rte_be16_t epcp_edei_in_ecid_b;
 772         /** Reserved (2b), GRP (2b), E-CID base (12b). */
 773         rte_be16_t rsvd_grp_ecid_b;
 774         uint8_t in_ecid_e; /**< Ingress E-CID ext. */
 775         uint8_t ecid_e; /**< E-CID ext. */
 776         rte_be16_t inner_type; /**< Inner EtherType or TPID. */
 777 };
 778
 779 /** Default mask for RTE_FLOW_ITEM_TYPE_E_TAG. */
 780 #ifndef __cplusplus
 781 static const struct rte_flow_item_e_tag rte_flow_item_e_tag_mask = {
 782         .rsvd_grp_ecid_b = RTE_BE16(0x3fff),
 783 };
 784 #endif
 785
 786 /**
 787  * RTE_FLOW_ITEM_TYPE_NVGRE.
 788  *
 789  * Matches a NVGRE header.
 790  */
 791 struct rte_flow_item_nvgre {
 792         /**
 793          * Checksum (1b), undefined (1b), key bit (1b), sequence number (1b),
 794          * reserved 0 (9b), version (3b).
 795          *
 796          * c_k_s_rsvd0_ver must have value 0x2000 according to RFC 7637.
 797          */
 798         rte_be16_t c_k_s_rsvd0_ver;
 799         rte_be16_t protocol; /**< Protocol type (0x6558). */
 800         uint8_t tni[3]; /**< Virtual subnet ID. */
 801         uint8_t flow_id; /**< Flow ID. */
 802 };
 803
 804 /** Default mask for RTE_FLOW_ITEM_TYPE_NVGRE. */
 805 #ifndef __cplusplus
 806 static const struct rte_flow_item_nvgre rte_flow_item_nvgre_mask = {
 807         .tni = "\xff\xff\xff",
 808 };
 809 #endif
 810
 811 /**
 812  * RTE_FLOW_ITEM_TYPE_MPLS.
 813  *
 814  * Matches a MPLS header.
 815  */
 816 struct rte_flow_item_mpls {
 817         /**
 818          * Label (20b), TC (3b), Bottom of Stack (1b).
 819          */
 820         uint8_t label_tc_s[3];
 821         uint8_t ttl; /** Time-to-Live. */
 822 };
 823
 824 /** Default mask for RTE_FLOW_ITEM_TYPE_MPLS. */
 825 #ifndef __cplusplus
 826 static const struct rte_flow_item_mpls rte_flow_item_mpls_mask = {
 827         .label_tc_s = "\xff\xff\xf0",
 828 };
 829 #endif
 830
 831 /**
 832  * RTE_FLOW_ITEM_TYPE_GRE.
 833  *
 834  * Matches a GRE header.
 835  */
 836 struct rte_flow_item_gre {
 837         /**
 838          * Checksum (1b), reserved 0 (12b), version (3b).
 839          * Refer to RFC 2784.
 840          */
 841         rte_be16_t c_rsvd0_ver;
 842         rte_be16_t protocol; /**< Protocol type. */
 843 };
 844
 845 /** Default mask for RTE_FLOW_ITEM_TYPE_GRE. */
 846 #ifndef __cplusplus
 847 static const struct rte_flow_item_gre rte_flow_item_gre_mask = {
 848         .protocol = RTE_BE16(0xffff),
 849 };
 850 #endif
 851
 852 /**
 853  * RTE_FLOW_ITEM_TYPE_FUZZY
 854  *
 855  * Fuzzy pattern match, expect faster than default.
 856  *
 857  * This is for device that support fuzzy match option.
 858  * Usually a fuzzy match is fast but the cost is accuracy.
 859  * i.e. Signature Match only match pattern's hash value, but it is
 860  * possible two different patterns have the same hash value.
 861  *
 862  * Matching accuracy level can be configure by threshold.
 863  * Driver can divide the range of threshold and map to different
 864  * accuracy levels that device support.
 865  *
 866  * Threshold 0 means perfect match (no fuzziness), while threshold
 867  * 0xffffffff means fuzziest match.
 868  */
 869 struct rte_flow_item_fuzzy {
 870         uint32_t thresh; /**< Accuracy threshold. */
 871 };
 872
 873 /** Default mask for RTE_FLOW_ITEM_TYPE_FUZZY. */
 874 #ifndef __cplusplus
 875 static const struct rte_flow_item_fuzzy rte_flow_item_fuzzy_mask = {
 876         .thresh = 0xffffffff,
 877 };
 878 #endif
 879
 880 /**
 881  * RTE_FLOW_ITEM_TYPE_GTP.
 882  *
 883  * Matches a GTPv1 header.
 884  */
 885 struct rte_flow_item_gtp {
 886         /**
 887          * Version (3b), protocol type (1b), reserved (1b),
 888          * Extension header flag (1b),
 889          * Sequence number flag (1b),
 890          * N-PDU number flag (1b).
 891          */
 892         uint8_t v_pt_rsv_flags;
 893         uint8_t msg_type; /**< Message type. */
 894         rte_be16_t msg_len; /**< Message length. */
 895         rte_be32_t teid; /**< Tunnel endpoint identifier. */
 896 };
 897
 898 /** Default mask for RTE_FLOW_ITEM_TYPE_GTP. */
 899 #ifndef __cplusplus
 900 static const struct rte_flow_item_gtp rte_flow_item_gtp_mask = {
 901         .teid = RTE_BE32(0xffffffff),
 902 };
 903 #endif
 904
 905 /**
 906  * RTE_FLOW_ITEM_TYPE_ESP
 907  *
 908  * Matches an ESP header.
 909  */
 910 struct rte_flow_item_esp {
 911         struct esp_hdr hdr; /**< ESP header definition. */
 912 };
 913
 914 /** Default mask for RTE_FLOW_ITEM_TYPE_ESP. */
 915 #ifndef __cplusplus
 916 static const struct rte_flow_item_esp rte_flow_item_esp_mask = {
 917         .hdr = {
 918                 .spi = 0xffffffff,
 919         },
 920 };
 921 #endif
 922
 923 /**
 924  * RTE_FLOW_ITEM_TYPE_GENEVE.
 925  *
 926  * Matches a GENEVE header.
 927  */
 928 struct rte_flow_item_geneve {
 929         /**
 930          * Version (2b), length of the options fields (6b), OAM packet (1b),
 931          * critical options present (1b), reserved 0 (6b).
 932          */
 933         rte_be16_t ver_opt_len_o_c_rsvd0;
 934         rte_be16_t protocol; /**< Protocol type. */
 935         uint8_t vni[3]; /**< Virtual Network Identifier. */
 936         uint8_t rsvd1; /**< Reserved, normally 0x00. */
 937 };
 938
 939 /** Default mask for RTE_FLOW_ITEM_TYPE_GENEVE. */
 940 #ifndef __cplusplus
 941 static const struct rte_flow_item_geneve rte_flow_item_geneve_mask = {
 942         .vni = "\xff\xff\xff",
 943 };
 944 #endif
 945
 946 /**
 947  * RTE_FLOW_ITEM_TYPE_VXLAN_GPE (draft-ietf-nvo3-vxlan-gpe-05).
 948  *
 949  * Matches a VXLAN-GPE header.
 950  */
 951 struct rte_flow_item_vxlan_gpe {
 952         uint8_t flags; /**< Normally 0x0c (I and P flags). */
 953         uint8_t rsvd0[2]; /**< Reserved, normally 0x0000. */
 954         uint8_t protocol; /**< Protocol type. */
 955         uint8_t vni[3]; /**< VXLAN identifier. */
 956         uint8_t rsvd1; /**< Reserved, normally 0x00. */
 957 };
 958
 959 /** Default mask for RTE_FLOW_ITEM_TYPE_VXLAN_GPE. */
 960 #ifndef __cplusplus
 961 static const struct rte_flow_item_vxlan_gpe rte_flow_item_vxlan_gpe_mask = {
 962         .vni = "\xff\xff\xff",
 963 };
 964 #endif
 965
 966 /**
 967  * RTE_FLOW_ITEM_TYPE_ARP_ETH_IPV4
 968  *
 969  * Matches an ARP header for Ethernet/IPv4.
 970  */
 971 struct rte_flow_item_arp_eth_ipv4 {
 972         rte_be16_t hrd; /**< Hardware type, normally 1. */
 973         rte_be16_t pro; /**< Protocol type, normally 0x0800. */
 974         uint8_t hln; /**< Hardware address length, normally 6. */
 975         uint8_t pln; /**< Protocol address length, normally 4. */
 976         rte_be16_t op; /**< Opcode (1 for request, 2 for reply). */
 977         struct ether_addr sha; /**< Sender hardware address. */
 978         rte_be32_t spa; /**< Sender IPv4 address. */
 979         struct ether_addr tha; /**< Target hardware address. */
 980         rte_be32_t tpa; /**< Target IPv4 address. */
 981 };
 982
 983 /** Default mask for RTE_FLOW_ITEM_TYPE_ARP_ETH_IPV4. */
 984 #ifndef __cplusplus
 985 static const struct rte_flow_item_arp_eth_ipv4
 986 rte_flow_item_arp_eth_ipv4_mask = {
 987         .sha.addr_bytes = "\xff\xff\xff\xff\xff\xff",
 988         .spa = RTE_BE32(0xffffffff),
 989         .tha.addr_bytes = "\xff\xff\xff\xff\xff\xff",
 990         .tpa = RTE_BE32(0xffffffff),
 991 };
 992 #endif
 993
 994 /**
 995  * RTE_FLOW_ITEM_TYPE_IPV6_EXT
 996  *
 997  * Matches the presence of any IPv6 extension header.
 998  *
 999  * Normally preceded by any of:
1000  *
1001  * - RTE_FLOW_ITEM_TYPE_IPV6
1002  * - RTE_FLOW_ITEM_TYPE_IPV6_EXT
1003  */
1004 struct rte_flow_item_ipv6_ext {
1005         uint8_t next_hdr; /**< Next header. */
1006 };
1007
1008 /** Default mask for RTE_FLOW_ITEM_TYPE_IPV6_EXT. */
1009 #ifndef __cplusplus
1010 static const
1011 struct rte_flow_item_ipv6_ext rte_flow_item_ipv6_ext_mask = {
1012         .next_hdr = 0xff,
1013 };
1014 #endif
1015
1016 /**
1017  * RTE_FLOW_ITEM_TYPE_ICMP6
1018  *
1019  * Matches any ICMPv6 header.
1020  */
1021 struct rte_flow_item_icmp6 {
1022         uint8_t type; /**< ICMPv6 type. */
1023         uint8_t code; /**< ICMPv6 code. */
1024         uint16_t checksum; /**< ICMPv6 checksum. */
1025 };
1026
1027 /** Default mask for RTE_FLOW_ITEM_TYPE_ICMP6. */
1028 #ifndef __cplusplus
1029 static const struct rte_flow_item_icmp6 rte_flow_item_icmp6_mask = {
1030         .type = 0xff,
1031         .code = 0xff,
1032 };
1033 #endif
1034
1035 /**
1036  * RTE_FLOW_ITEM_TYPE_ICMP6_ND_NS
1037  *
1038  * Matches an ICMPv6 neighbor discovery solicitation.
1039  */
1040 struct rte_flow_item_icmp6_nd_ns {
1041         uint8_t type; /**< ICMPv6 type, normally 135. */
1042         uint8_t code; /**< ICMPv6 code, normally 0. */
1043         rte_be16_t checksum; /**< ICMPv6 checksum. */
1044         rte_be32_t reserved; /**< Reserved, normally 0. */
1045         uint8_t target_addr[16]; /**< Target address. */
1046 };
1047
1048 /** Default mask for RTE_FLOW_ITEM_TYPE_ICMP6_ND_NS. */
1049 #ifndef __cplusplus
1050 static const
1051 struct rte_flow_item_icmp6_nd_ns rte_flow_item_icmp6_nd_ns_mask = {
1052         .target_addr =
1053                 "\xff\xff\xff\xff\xff\xff\xff\xff"
1054                 "\xff\xff\xff\xff\xff\xff\xff\xff",
1055 };
1056 #endif
1057
1058 /**
1059  * RTE_FLOW_ITEM_TYPE_ICMP6_ND_NA
1060  *
1061  * Matches an ICMPv6 neighbor discovery advertisement.
1062  */
1063 struct rte_flow_item_icmp6_nd_na {
1064         uint8_t type; /**< ICMPv6 type, normally 136. */
1065         uint8_t code; /**< ICMPv6 code, normally 0. */
1066         rte_be16_t checksum; /**< ICMPv6 checksum. */
1067         /**
1068          * Route flag (1b), solicited flag (1b), override flag (1b),
1069          * reserved (29b).
1070          */
1071         rte_be32_t rso_reserved;
1072         uint8_t target_addr[16]; /**< Target address. */
1073 };
1074
1075 /** Default mask for RTE_FLOW_ITEM_TYPE_ICMP6_ND_NA. */
1076 #ifndef __cplusplus
1077 static const
1078 struct rte_flow_item_icmp6_nd_na rte_flow_item_icmp6_nd_na_mask = {
1079         .target_addr =
1080                 "\xff\xff\xff\xff\xff\xff\xff\xff"
1081                 "\xff\xff\xff\xff\xff\xff\xff\xff",
1082 };
1083 #endif
1084
1085 /**
1086  * RTE_FLOW_ITEM_TYPE_ICMP6_ND_OPT
1087  *
1088  * Matches the presence of any ICMPv6 neighbor discovery option.
1089  *
1090  * Normally preceded by any of:
1091  *
1092  * - RTE_FLOW_ITEM_TYPE_ICMP6_ND_NA
1093  * - RTE_FLOW_ITEM_TYPE_ICMP6_ND_NS
1094  * - RTE_FLOW_ITEM_TYPE_ICMP6_ND_OPT
1095  */
1096 struct rte_flow_item_icmp6_nd_opt {
1097         uint8_t type; /**< ND option type. */
1098         uint8_t length; /**< ND option length. */
1099 };
1100
1101 /** Default mask for RTE_FLOW_ITEM_TYPE_ICMP6_ND_OPT. */
1102 #ifndef __cplusplus
1103 static const struct rte_flow_item_icmp6_nd_opt
1104 rte_flow_item_icmp6_nd_opt_mask = {
1105         .type = 0xff,
1106 };
1107 #endif
1108
1109 /**
1110  * RTE_FLOW_ITEM_TYPE_ICMP6_ND_OPT_SLA_ETH
1111  *
1112  * Matches an ICMPv6 neighbor discovery source Ethernet link-layer address
1113  * option.
1114  *
1115  * Normally preceded by any of:
1116  *
1117  * - RTE_FLOW_ITEM_TYPE_ICMP6_ND_NA
1118  * - RTE_FLOW_ITEM_TYPE_ICMP6_ND_OPT
1119  */
1120 struct rte_flow_item_icmp6_nd_opt_sla_eth {
1121         uint8_t type; /**< ND option type, normally 1. */
1122         uint8_t length; /**< ND option length, normally 1. */
1123         struct ether_addr sla; /**< Source Ethernet LLA. */
1124 };
1125
1126 /** Default mask for RTE_FLOW_ITEM_TYPE_ICMP6_ND_OPT_SLA_ETH. */
1127 #ifndef __cplusplus
1128 static const struct rte_flow_item_icmp6_nd_opt_sla_eth
1129 rte_flow_item_icmp6_nd_opt_sla_eth_mask = {
1130         .sla.addr_bytes = "\xff\xff\xff\xff\xff\xff",
1131 };
1132 #endif
1133
1134 /**
1135  * RTE_FLOW_ITEM_TYPE_ICMP6_ND_OPT_TLA_ETH
1136  *
1137  * Matches an ICMPv6 neighbor discovery target Ethernet link-layer address
1138  * option.
1139  *
1140  * Normally preceded by any of:
1141  *
1142  * - RTE_FLOW_ITEM_TYPE_ICMP6_ND_NS
1143  * - RTE_FLOW_ITEM_TYPE_ICMP6_ND_OPT
1144  */
1145 struct rte_flow_item_icmp6_nd_opt_tla_eth {
1146         uint8_t type; /**< ND option type, normally 2. */
1147         uint8_t length; /**< ND option length, normally 1. */
1148         struct ether_addr tla; /**< Target Ethernet LLA. */
1149 };
1150
1151 /** Default mask for RTE_FLOW_ITEM_TYPE_ICMP6_ND_OPT_TLA_ETH. */
1152 #ifndef __cplusplus
1153 static const struct rte_flow_item_icmp6_nd_opt_tla_eth
1154 rte_flow_item_icmp6_nd_opt_tla_eth_mask = {
1155         .tla.addr_bytes = "\xff\xff\xff\xff\xff\xff",
1156 };
1157 #endif
1158
1159 /**
1160  * @warning
1161  * @b EXPERIMENTAL: this structure may change without prior notice
1162  *
1163  * RTE_FLOW_ITEM_TYPE_MARK
1164  *
1165  * Matches an arbitrary integer value which was set using the ``MARK`` action
1166  * in a previously matched rule.
1167  *
1168  * This item can only be specified once as a match criteria as the ``MARK``
1169  * action can only be specified once in a flow action.
1170  *
1171  * This value is arbitrary and application-defined. Maximum allowed value
1172  * depends on the underlying implementation.
1173  *
1174  * Depending on the underlying implementation the MARK item may be supported on
1175  * the physical device, with virtual groups in the PMD or not at all.
1176  */
1177 struct rte_flow_item_mark {
1178         uint32_t id; /**< Integer value to match against. */
1179 };
1180
1181 /**
1182  * Matching pattern item definition.
1183  *
1184  * A pattern is formed by stacking items starting from the lowest protocol
1185  * layer to match. This stacking restriction does not apply to meta items
1186  * which can be placed anywhere in the stack without affecting the meaning
1187  * of the resulting pattern.
1188  *
1189  * Patterns are terminated by END items.
1190  *
1191  * The spec field should be a valid pointer to a structure of the related
1192  * item type. It may remain unspecified (NULL) in many cases to request
1193  * broad (nonspecific) matching. In such cases, last and mask must also be
1194  * set to NULL.
1195  *
1196  * Optionally, last can point to a structure of the same type to define an
1197  * inclusive range. This is mostly supported by integer and address fields,
1198  * may cause errors otherwise. Fields that do not support ranges must be set
1199  * to 0 or to the same value as the corresponding fields in spec.
1200  *
1201  * Only the fields defined to nonzero values in the default masks (see
1202  * rte_flow_item_{name}_mask constants) are considered relevant by
1203  * default. This can be overridden by providing a mask structure of the
1204  * same type with applicable bits set to one. It can also be used to
1205  * partially filter out specific fields (e.g. as an alternate mean to match
1206  * ranges of IP addresses).
1207  *
1208  * Mask is a simple bit-mask applied before interpreting the contents of
1209  * spec and last, which may yield unexpected results if not used
1210  * carefully. For example, if for an IPv4 address field, spec provides
1211  * 10.1.2.3, last provides 10.3.4.5 and mask provides 255.255.0.0, the
1212  * effective range becomes 10.1.0.0 to 10.3.255.255.
1213  */
1214 struct rte_flow_item {
1215         enum rte_flow_item_type type; /**< Item type. */
1216         const void *spec; /**< Pointer to item specification structure. */
1217         const void *last; /**< Defines an inclusive range (spec to last). */
1218         const void *mask; /**< Bit-mask applied to spec and last. */
1219 };
1220
1221 /**
1222  * Action types.
1223  *
1224  * Each possible action is represented by a type. Some have associated
1225  * configuration structures. Several actions combined in a list can be
1226  * assigned to a flow rule and are performed in order.
1227  *
1228  * They fall in three categories:
1229  *
1230  * - Actions that modify the fate of matching traffic, for instance by
1231  *   dropping or assigning it a specific destination.
1232  *
1233  * - Actions that modify matching traffic contents or its properties. This
1234  *   includes adding/removing encapsulation, encryption, compression and
1235  *   marks.
1236  *
1237  * - Actions related to the flow rule itself, such as updating counters or
1238  *   making it non-terminating.
1239  *
1240  * Flow rules being terminating by default, not specifying any action of the
1241  * fate kind results in undefined behavior. This applies to both ingress and
1242  * egress.
1243  *
1244  * PASSTHRU, when supported, makes a flow rule non-terminating.
1245  */
1246 enum rte_flow_action_type {
1247         /**
1248          * End marker for action lists. Prevents further processing of
1249          * actions, thereby ending the list.
1250          *
1251          * No associated configuration structure.
1252          */
1253         RTE_FLOW_ACTION_TYPE_END,
1254
1255         /**
1256          * Used as a placeholder for convenience. It is ignored and simply
1257          * discarded by PMDs.
1258          *
1259          * No associated configuration structure.
1260          */
1261         RTE_FLOW_ACTION_TYPE_VOID,
1262
1263         /**
1264          * Leaves traffic up for additional processing by subsequent flow
1265          * rules; makes a flow rule non-terminating.
1266          *
1267          * No associated configuration structure.
1268          */
1269         RTE_FLOW_ACTION_TYPE_PASSTHRU,
1270
1271         /**
1272          * RTE_FLOW_ACTION_TYPE_JUMP
1273          *
1274          * Redirects packets to a group on the current device.
1275          *
1276          * See struct rte_flow_action_jump.
1277          */
1278         RTE_FLOW_ACTION_TYPE_JUMP,
1279
1280         /**
1281          * Attaches an integer value to packets and sets PKT_RX_FDIR and
1282          * PKT_RX_FDIR_ID mbuf flags.
1283          *
1284          * See struct rte_flow_action_mark.
1285          */
1286         RTE_FLOW_ACTION_TYPE_MARK,
1287
1288         /**
1289          * Flags packets. Similar to MARK without a specific value; only
1290          * sets the PKT_RX_FDIR mbuf flag.
1291          *
1292          * No associated configuration structure.
1293          */
1294         RTE_FLOW_ACTION_TYPE_FLAG,
1295
1296         /**
1297          * Assigns packets to a given queue index.
1298          *
1299          * See struct rte_flow_action_queue.
1300          */
1301         RTE_FLOW_ACTION_TYPE_QUEUE,
1302
1303         /**
1304          * Drops packets.
1305          *
1306          * PASSTHRU overrides this action if both are specified.
1307          *
1308          * No associated configuration structure.
1309          */
1310         RTE_FLOW_ACTION_TYPE_DROP,
1311
1312         /**
1313          * Enables counters for this flow rule.
1314          *
1315          * These counters can be retrieved and reset through rte_flow_query(),
1316          * see struct rte_flow_query_count.
1317          *
1318          * See struct rte_flow_action_count.
1319          */
1320         RTE_FLOW_ACTION_TYPE_COUNT,
1321
1322         /**
1323          * Similar to QUEUE, except RSS is additionally performed on packets
1324          * to spread them among several queues according to the provided
1325          * parameters.
1326          *
1327          * See struct rte_flow_action_rss.
1328          */
1329         RTE_FLOW_ACTION_TYPE_RSS,
1330
1331         /**
1332          * Directs matching traffic to the physical function (PF) of the
1333          * current device.
1334          *
1335          * No associated configuration structure.
1336          */
1337         RTE_FLOW_ACTION_TYPE_PF,
1338
1339         /**
1340          * Directs matching traffic to a given virtual function of the
1341          * current device.
1342          *
1343          * See struct rte_flow_action_vf.
1344          */
1345         RTE_FLOW_ACTION_TYPE_VF,
1346
1347         /**
1348          * Directs packets to a given physical port index of the underlying
1349          * device.
1350          *
1351          * See struct rte_flow_action_phy_port.
1352          */
1353         RTE_FLOW_ACTION_TYPE_PHY_PORT,
1354
1355         /**
1356          * Directs matching traffic to a given DPDK port ID.
1357          *
1358          * See struct rte_flow_action_port_id.
1359          */
1360         RTE_FLOW_ACTION_TYPE_PORT_ID,
1361
1362         /**
1363          * Traffic metering and policing (MTR).
1364          *
1365          * See struct rte_flow_action_meter.
1366          * See file rte_mtr.h for MTR object configuration.
1367          */
1368         RTE_FLOW_ACTION_TYPE_METER,
1369
1370         /**
1371          * Redirects packets to security engine of current device for security
1372          * processing as specified by security session.
1373          *
1374          * See struct rte_flow_action_security.
1375          */
1376         RTE_FLOW_ACTION_TYPE_SECURITY,
1377
1378         /**
1379          * Implements OFPAT_SET_MPLS_TTL ("MPLS TTL") as defined by the
1380          * OpenFlow Switch Specification.
1381          *
1382          * See struct rte_flow_action_of_set_mpls_ttl.
1383          */
1384         RTE_FLOW_ACTION_TYPE_OF_SET_MPLS_TTL,
1385
1386         /**
1387          * Implements OFPAT_DEC_MPLS_TTL ("decrement MPLS TTL") as defined
1388          * by the OpenFlow Switch Specification.
1389          *
1390          * No associated configuration structure.
1391          */
1392         RTE_FLOW_ACTION_TYPE_OF_DEC_MPLS_TTL,
1393
1394         /**
1395          * Implements OFPAT_SET_NW_TTL ("IP TTL") as defined by the OpenFlow
1396          * Switch Specification.
1397          *
1398          * See struct rte_flow_action_of_set_nw_ttl.
1399          */
1400         RTE_FLOW_ACTION_TYPE_OF_SET_NW_TTL,
1401
1402         /**
1403          * Implements OFPAT_DEC_NW_TTL ("decrement IP TTL") as defined by
1404          * the OpenFlow Switch Specification.
1405          *
1406          * No associated configuration structure.
1407          */
1408         RTE_FLOW_ACTION_TYPE_OF_DEC_NW_TTL,
1409
1410         /**
1411          * Implements OFPAT_COPY_TTL_OUT ("copy TTL "outwards" -- from
1412          * next-to-outermost to outermost") as defined by the OpenFlow
1413          * Switch Specification.
1414          *
1415          * No associated configuration structure.
1416          */
1417         RTE_FLOW_ACTION_TYPE_OF_COPY_TTL_OUT,
1418
1419         /**
1420          * Implements OFPAT_COPY_TTL_IN ("copy TTL "inwards" -- from
1421          * outermost to next-to-outermost") as defined by the OpenFlow
1422          * Switch Specification.
1423          *
1424          * No associated configuration structure.
1425          */
1426         RTE_FLOW_ACTION_TYPE_OF_COPY_TTL_IN,
1427
1428         /**
1429          * Implements OFPAT_POP_VLAN ("pop the outer VLAN tag") as defined
1430          * by the OpenFlow Switch Specification.
1431          *
1432          * No associated configuration structure.
1433          */
1434         RTE_FLOW_ACTION_TYPE_OF_POP_VLAN,
1435
1436         /**
1437          * Implements OFPAT_PUSH_VLAN ("push a new VLAN tag") as defined by
1438          * the OpenFlow Switch Specification.
1439          *
1440          * See struct rte_flow_action_of_push_vlan.
1441          */
1442         RTE_FLOW_ACTION_TYPE_OF_PUSH_VLAN,
1443
1444         /**
1445          * Implements OFPAT_SET_VLAN_VID ("set the 802.1q VLAN id") as
1446          * defined by the OpenFlow Switch Specification.
1447          *
1448          * See struct rte_flow_action_of_set_vlan_vid.
1449          */
1450         RTE_FLOW_ACTION_TYPE_OF_SET_VLAN_VID,
1451
1452         /**
1453          * Implements OFPAT_SET_LAN_PCP ("set the 802.1q priority") as
1454          * defined by the OpenFlow Switch Specification.
1455          *
1456          * See struct rte_flow_action_of_set_vlan_pcp.
1457          */
1458         RTE_FLOW_ACTION_TYPE_OF_SET_VLAN_PCP,
1459
1460         /**
1461          * Implements OFPAT_POP_MPLS ("pop the outer MPLS tag") as defined
1462          * by the OpenFlow Switch Specification.
1463          *
1464          * See struct rte_flow_action_of_pop_mpls.
1465          */
1466         RTE_FLOW_ACTION_TYPE_OF_POP_MPLS,
1467
1468         /**
1469          * Implements OFPAT_PUSH_MPLS ("push a new MPLS tag") as defined by
1470          * the OpenFlow Switch Specification.
1471          *
1472          * See struct rte_flow_action_of_push_mpls.
1473          */
1474         RTE_FLOW_ACTION_TYPE_OF_PUSH_MPLS,
1475
1476         /**
1477          * Encapsulate flow in VXLAN tunnel as defined in
1478          * rte_flow_action_vxlan_encap action structure.
1479          *
1480          * See struct rte_flow_action_vxlan_encap.
1481          */
1482         RTE_FLOW_ACTION_TYPE_VXLAN_ENCAP,
1483
1484         /**
1485          * Decapsulate outer most VXLAN tunnel from matched flow.
1486          *
1487          * If flow pattern does not define a valid VXLAN tunnel (as specified by
1488          * RFC7348) then the PMD should return a RTE_FLOW_ERROR_TYPE_ACTION
1489          * error.
1490          */
1491         RTE_FLOW_ACTION_TYPE_VXLAN_DECAP,
1492
1493         /**
1494          * Encapsulate flow in NVGRE tunnel defined in the
1495          * rte_flow_action_nvgre_encap action structure.
1496          *
1497          * See struct rte_flow_action_nvgre_encap.
1498          */
1499         RTE_FLOW_ACTION_TYPE_NVGRE_ENCAP,
1500
1501         /**
1502          * Decapsulate outer most NVGRE tunnel from matched flow.
1503          *
1504          * If flow pattern does not define a valid NVGRE tunnel (as specified by
1505          * RFC7637) then the PMD should return a RTE_FLOW_ERROR_TYPE_ACTION
1506          * error.
1507          */
1508         RTE_FLOW_ACTION_TYPE_NVGRE_DECAP,
1509
1510         /**
1511          * Modify IPv4 source address in the outermost IPv4 header.
1512          *
1513          * If flow pattern does not define a valid RTE_FLOW_ITEM_TYPE_IPV4,
1514          * then the PMD should return a RTE_FLOW_ERROR_TYPE_ACTION error.
1515          *
1516          * See struct rte_flow_action_set_ipv4.
1517          */
1518         RTE_FLOW_ACTION_TYPE_SET_IPV4_SRC,
1519
1520         /**
1521          * Modify IPv4 destination address in the outermost IPv4 header.
1522          *
1523          * If flow pattern does not define a valid RTE_FLOW_ITEM_TYPE_IPV4,
1524          * then the PMD should return a RTE_FLOW_ERROR_TYPE_ACTION error.
1525          *
1526          * See struct rte_flow_action_set_ipv4.
1527          */
1528         RTE_FLOW_ACTION_TYPE_SET_IPV4_DST,
1529
1530         /**
1531          * Modify IPv6 source address in the outermost IPv6 header.
1532          *
1533          * If flow pattern does not define a valid RTE_FLOW_ITEM_TYPE_IPV6,
1534          * then the PMD should return a RTE_FLOW_ERROR_TYPE_ACTION error.
1535          *
1536          * See struct rte_flow_action_set_ipv6.
1537          */
1538         RTE_FLOW_ACTION_TYPE_SET_IPV6_SRC,
1539
1540         /**
1541          * Modify IPv6 destination address in the outermost IPv6 header.
1542          *
1543          * If flow pattern does not define a valid RTE_FLOW_ITEM_TYPE_IPV6,
1544          * then the PMD should return a RTE_FLOW_ERROR_TYPE_ACTION error.
1545          *
1546          * See struct rte_flow_action_set_ipv6.
1547          */
1548         RTE_FLOW_ACTION_TYPE_SET_IPV6_DST,
1549
1550         /**
1551          * Modify source port number in the outermost TCP/UDP header.
1552          *
1553          * If flow pattern does not define a valid RTE_FLOW_ITEM_TYPE_TCP
1554          * or RTE_FLOW_ITEM_TYPE_UDP, then the PMD should return a
1555          * RTE_FLOW_ERROR_TYPE_ACTION error.
1556          *
1557          * See struct rte_flow_action_set_tp.
1558          */
1559         RTE_FLOW_ACTION_TYPE_SET_TP_SRC,
1560
1561         /**
1562          * Modify destination port number in the outermost TCP/UDP header.
1563          *
1564          * If flow pattern does not define a valid RTE_FLOW_ITEM_TYPE_TCP
1565          * or RTE_FLOW_ITEM_TYPE_UDP, then the PMD should return a
1566          * RTE_FLOW_ERROR_TYPE_ACTION error.
1567          *
1568          * See struct rte_flow_action_set_tp.
1569          */
1570         RTE_FLOW_ACTION_TYPE_SET_TP_DST,
1571
1572         /**
1573          * Swap the source and destination MAC addresses in the outermost
1574          * Ethernet header.
1575          *
1576          * If flow pattern does not define a valid RTE_FLOW_ITEM_TYPE_ETH,
1577          * then the PMD should return a RTE_FLOW_ERROR_TYPE_ACTION error.
1578          *
1579          * No associated configuration structure.
1580          */
1581         RTE_FLOW_ACTION_TYPE_MAC_SWAP,
1582
1583         /**
1584          * Decrease TTL value directly
1585          *
1586          * No associated configuration structure.
1587          */
1588         RTE_FLOW_ACTION_TYPE_DEC_TTL,
1589
1590         /**
1591          * Set TTL value
1592          *
1593          * See struct rte_flow_action_set_ttl
1594          */
1595         RTE_FLOW_ACTION_TYPE_SET_TTL,
1596 };
1597
1598 /**
1599  * RTE_FLOW_ACTION_TYPE_MARK
1600  *
1601  * Attaches an integer value to packets and sets PKT_RX_FDIR and
1602  * PKT_RX_FDIR_ID mbuf flags.
1603  *
1604  * This value is arbitrary and application-defined. Maximum allowed value
1605  * depends on the underlying implementation. It is returned in the
1606  * hash.fdir.hi mbuf field.
1607  */
1608 struct rte_flow_action_mark {
1609         uint32_t id; /**< Integer value to return with packets. */
1610 };
1611
1612 /**
1613  * @warning
1614  * @b EXPERIMENTAL: this structure may change without prior notice
1615  *
1616  * RTE_FLOW_ACTION_TYPE_JUMP
1617  *
1618  * Redirects packets to a group on the current device.
1619  *
1620  * In a hierarchy of groups, which can be used to represent physical or logical
1621  * flow tables on the device, this action allows the action to be a redirect to
1622  * a group on that device.
1623  */
1624 struct rte_flow_action_jump {
1625         uint32_t group;
1626 };
1627
1628 /**
1629  * RTE_FLOW_ACTION_TYPE_QUEUE
1630  *
1631  * Assign packets to a given queue index.
1632  */
1633 struct rte_flow_action_queue {
1634         uint16_t index; /**< Queue index to use. */
1635 };
1636
1637
1638 /**
1639  * @warning
1640  * @b EXPERIMENTAL: this structure may change without prior notice
1641  *
1642  * RTE_FLOW_ACTION_TYPE_COUNT
1643  *
1644  * Adds a counter action to a matched flow.
1645  *
1646  * If more than one count action is specified in a single flow rule, then each
1647  * action must specify a unique id.
1648  *
1649  * Counters can be retrieved and reset through ``rte_flow_query()``, see
1650  * ``struct rte_flow_query_count``.
1651  *
1652  * The shared flag indicates whether the counter is unique to the flow rule the
1653  * action is specified with, or whether it is a shared counter.
1654  *
1655  * For a count action with the shared flag set, then then a global device
1656  * namespace is assumed for the counter id, so that any matched flow rules using
1657  * a count action with the same counter id on the same port will contribute to
1658  * that counter.
1659  *
1660  * For ports within the same switch domain then the counter id namespace extends
1661  * to all ports within that switch domain.
1662  */
1663 struct rte_flow_action_count {
1664         uint32_t shared:1; /**< Share counter ID with other flow rules. */
1665         uint32_t reserved:31; /**< Reserved, must be zero. */
1666         uint32_t id; /**< Counter ID. */
1667 };
1668
1669 /**
1670  * RTE_FLOW_ACTION_TYPE_COUNT (query)
1671  *
1672  * Query structure to retrieve and reset flow rule counters.
1673  */
1674 struct rte_flow_query_count {
1675         uint32_t reset:1; /**< Reset counters after query [in]. */
1676         uint32_t hits_set:1; /**< hits field is set [out]. */
1677         uint32_t bytes_set:1; /**< bytes field is set [out]. */
1678         uint32_t reserved:29; /**< Reserved, must be zero [in, out]. */
1679         uint64_t hits; /**< Number of hits for this rule [out]. */
1680         uint64_t bytes; /**< Number of bytes through this rule [out]. */
1681 };
1682
1683 /**
1684  * RTE_FLOW_ACTION_TYPE_RSS
1685  *
1686  * Similar to QUEUE, except RSS is additionally performed on packets to
1687  * spread them among several queues according to the provided parameters.
1688  *
1689  * Unlike global RSS settings used by other DPDK APIs, unsetting the
1690  * @p types field does not disable RSS in a flow rule. Doing so instead
1691  * requests safe unspecified "best-effort" settings from the underlying PMD,
1692  * which depending on the flow rule, may result in anything ranging from
1693  * empty (single queue) to all-inclusive RSS.
1694  *
1695  * Note: RSS hash result is stored in the hash.rss mbuf field which overlaps
1696  * hash.fdir.lo. Since the MARK action sets the hash.fdir.hi field only,
1697  * both can be requested simultaneously.
1698  */
1699 struct rte_flow_action_rss {
1700         enum rte_eth_hash_function func; /**< RSS hash function to apply. */
1701         /**
1702          * Packet encapsulation level RSS hash @p types apply to.
1703          *
1704          * - @p 0 requests the default behavior. Depending on the packet
1705          *   type, it can mean outermost, innermost, anything in between or
1706          *   even no RSS.
1707          *
1708          *   It basically stands for the innermost encapsulation level RSS
1709          *   can be performed on according to PMD and device capabilities.
1710          *
1711          * - @p 1 requests RSS to be performed on the outermost packet
1712          *   encapsulation level.
1713          *
1714          * - @p 2 and subsequent values request RSS to be performed on the
1715          *   specified inner packet encapsulation level, from outermost to
1716          *   innermost (lower to higher values).
1717          *
1718          * Values other than @p 0 are not necessarily supported.
1719          *
1720          * Requesting a specific RSS level on unrecognized traffic results
1721          * in undefined behavior. For predictable results, it is recommended
1722          * to make the flow rule pattern match packet headers up to the
1723          * requested encapsulation level so that only matching traffic goes
1724          * through.
1725          */
1726         uint32_t level;
1727         uint64_t types; /**< Specific RSS hash types (see ETH_RSS_*). */
1728         uint32_t key_len; /**< Hash key length in bytes. */
1729         uint32_t queue_num; /**< Number of entries in @p queue. */
1730         const uint8_t *key; /**< Hash key. */
1731         const uint16_t *queue; /**< Queue indices to use. */
1732 };
1733
1734 /**
1735  * RTE_FLOW_ACTION_TYPE_VF
1736  *
1737  * Directs matching traffic to a given virtual function of the current
1738  * device.
1739  *
1740  * Packets matched by a VF pattern item can be redirected to their original
1741  * VF ID instead of the specified one. This parameter may not be available
1742  * and is not guaranteed to work properly if the VF part is matched by a
1743  * prior flow rule or if packets are not addressed to a VF in the first
1744  * place.
1745  */
1746 struct rte_flow_action_vf {
1747         uint32_t original:1; /**< Use original VF ID if possible. */
1748         uint32_t reserved:31; /**< Reserved, must be zero. */
1749         uint32_t id; /**< VF ID. */
1750 };
1751
1752 /**
1753  * RTE_FLOW_ACTION_TYPE_PHY_PORT
1754  *
1755  * Directs packets to a given physical port index of the underlying
1756  * device.
1757  *
1758  * @see RTE_FLOW_ITEM_TYPE_PHY_PORT
1759  */
1760 struct rte_flow_action_phy_port {
1761         uint32_t original:1; /**< Use original port index if possible. */
1762         uint32_t reserved:31; /**< Reserved, must be zero. */
1763         uint32_t index; /**< Physical port index. */
1764 };
1765
1766 /**
1767  * RTE_FLOW_ACTION_TYPE_PORT_ID
1768  *
1769  * Directs matching traffic to a given DPDK port ID.
1770  *
1771  * @see RTE_FLOW_ITEM_TYPE_PORT_ID
1772  */
1773 struct rte_flow_action_port_id {
1774         uint32_t original:1; /**< Use original DPDK port ID if possible. */
1775         uint32_t reserved:31; /**< Reserved, must be zero. */
1776         uint32_t id; /**< DPDK port ID. */
1777 };
1778
1779 /**
1780  * RTE_FLOW_ACTION_TYPE_METER
1781  *
1782  * Traffic metering and policing (MTR).
1783  *
1784  * Packets matched by items of this type can be either dropped or passed to the
1785  * next item with their color set by the MTR object.
1786  */
1787 struct rte_flow_action_meter {
1788         uint32_t mtr_id; /**< MTR object ID created with rte_mtr_create(). */
1789 };
1790
1791 /**
1792  * RTE_FLOW_ACTION_TYPE_SECURITY
1793  *
1794  * Perform the security action on flows matched by the pattern items
1795  * according to the configuration of the security session.
1796  *
1797  * This action modifies the payload of matched flows. For INLINE_CRYPTO, the
1798  * security protocol headers and IV are fully provided by the application as
1799  * specified in the flow pattern. The payload of matching packets is
1800  * encrypted on egress, and decrypted and authenticated on ingress.
1801  * For INLINE_PROTOCOL, the security protocol is fully offloaded to HW,
1802  * providing full encapsulation and decapsulation of packets in security
1803  * protocols. The flow pattern specifies both the outer security header fields
1804  * and the inner packet fields. The security session specified in the action
1805  * must match the pattern parameters.
1806  *
1807  * The security session specified in the action must be created on the same
1808  * port as the flow action that is being specified.
1809  *
1810  * The ingress/egress flow attribute should match that specified in the
1811  * security session if the security session supports the definition of the
1812  * direction.
1813  *
1814  * Multiple flows can be configured to use the same security session.
1815  */
1816 struct rte_flow_action_security {
1817         void *security_session; /**< Pointer to security session structure. */
1818 };
1819
1820 /**
1821  * RTE_FLOW_ACTION_TYPE_OF_SET_MPLS_TTL
1822  *
1823  * Implements OFPAT_SET_MPLS_TTL ("MPLS TTL") as defined by the OpenFlow
1824  * Switch Specification.
1825  */
1826 struct rte_flow_action_of_set_mpls_ttl {
1827         uint8_t mpls_ttl; /**< MPLS TTL. */
1828 };
1829
1830 /**
1831  * RTE_FLOW_ACTION_TYPE_OF_SET_NW_TTL
1832  *
1833  * Implements OFPAT_SET_NW_TTL ("IP TTL") as defined by the OpenFlow Switch
1834  * Specification.
1835  */
1836 struct rte_flow_action_of_set_nw_ttl {
1837         uint8_t nw_ttl; /**< IP TTL. */
1838 };
1839
1840 /**
1841  * RTE_FLOW_ACTION_TYPE_OF_PUSH_VLAN
1842  *
1843  * Implements OFPAT_PUSH_VLAN ("push a new VLAN tag") as defined by the
1844  * OpenFlow Switch Specification.
1845  */
1846 struct rte_flow_action_of_push_vlan {
1847         rte_be16_t ethertype; /**< EtherType. */
1848 };
1849
1850 /**
1851  * RTE_FLOW_ACTION_TYPE_OF_SET_VLAN_VID
1852  *
1853  * Implements OFPAT_SET_VLAN_VID ("set the 802.1q VLAN id") as defined by
1854  * the OpenFlow Switch Specification.
1855  */
1856 struct rte_flow_action_of_set_vlan_vid {
1857         rte_be16_t vlan_vid; /**< VLAN id. */
1858 };
1859
1860 /**
1861  * RTE_FLOW_ACTION_TYPE_OF_SET_VLAN_PCP
1862  *
1863  * Implements OFPAT_SET_LAN_PCP ("set the 802.1q priority") as defined by
1864  * the OpenFlow Switch Specification.
1865  */
1866 struct rte_flow_action_of_set_vlan_pcp {
1867         uint8_t vlan_pcp; /**< VLAN priority. */
1868 };
1869
1870 /**
1871  * RTE_FLOW_ACTION_TYPE_OF_POP_MPLS
1872  *
1873  * Implements OFPAT_POP_MPLS ("pop the outer MPLS tag") as defined by the
1874  * OpenFlow Switch Specification.
1875  */
1876 struct rte_flow_action_of_pop_mpls {
1877         rte_be16_t ethertype; /**< EtherType. */
1878 };
1879
1880 /**
1881  * RTE_FLOW_ACTION_TYPE_OF_PUSH_MPLS
1882  *
1883  * Implements OFPAT_PUSH_MPLS ("push a new MPLS tag") as defined by the
1884  * OpenFlow Switch Specification.
1885  */
1886 struct rte_flow_action_of_push_mpls {
1887         rte_be16_t ethertype; /**< EtherType. */
1888 };
1889
1890 /**
1891  * @warning
1892  * @b EXPERIMENTAL: this structure may change without prior notice
1893  *
1894  * RTE_FLOW_ACTION_TYPE_VXLAN_ENCAP
1895  *
1896  * VXLAN tunnel end-point encapsulation data definition
1897  *
1898  * The tunnel definition is provided through the flow item pattern, the
1899  * provided pattern must conform to RFC7348 for the tunnel specified. The flow
1900  * definition must be provided in order from the RTE_FLOW_ITEM_TYPE_ETH
1901  * definition up the end item which is specified by RTE_FLOW_ITEM_TYPE_END.
1902  *
1903  * The mask field allows user to specify which fields in the flow item
1904  * definitions can be ignored and which have valid data and can be used
1905  * verbatim.
1906  *
1907  * Note: the last field is not used in the definition of a tunnel and can be
1908  * ignored.
1909  *
1910  * Valid flow definition for RTE_FLOW_ACTION_TYPE_VXLAN_ENCAP include:
1911  *
1912  * - ETH / IPV4 / UDP / VXLAN / END
1913  * - ETH / IPV6 / UDP / VXLAN / END
1914  * - ETH / VLAN / IPV4 / UDP / VXLAN / END
1915  *
1916  */
1917 struct rte_flow_action_vxlan_encap {
1918         /**
1919          * Encapsulating vxlan tunnel definition
1920          * (terminated by the END pattern item).
1921          */
1922         struct rte_flow_item *definition;
1923 };
1924
1925 /**
1926  * @warning
1927  * @b EXPERIMENTAL: this structure may change without prior notice
1928  *
1929  * RTE_FLOW_ACTION_TYPE_NVGRE_ENCAP
1930  *
1931  * NVGRE tunnel end-point encapsulation data definition
1932  *
1933  * The tunnel definition is provided through the flow item pattern  the
1934  * provided pattern must conform with RFC7637. The flow definition must be
1935  * provided in order from the RTE_FLOW_ITEM_TYPE_ETH definition up the end item
1936  * which is specified by RTE_FLOW_ITEM_TYPE_END.
1937  *
1938  * The mask field allows user to specify which fields in the flow item
1939  * definitions can be ignored and which have valid data and can be used
1940  * verbatim.
1941  *
1942  * Note: the last field is not used in the definition of a tunnel and can be
1943  * ignored.
1944  *
1945  * Valid flow definition for RTE_FLOW_ACTION_TYPE_NVGRE_ENCAP include:
1946  *
1947  * - ETH / IPV4 / NVGRE / END
1948  * - ETH / VLAN / IPV6 / NVGRE / END
1949  *
1950  */
1951 struct rte_flow_action_nvgre_encap {
1952         /**
1953          * Encapsulating vxlan tunnel definition
1954          * (terminated by the END pattern item).
1955          */
1956         struct rte_flow_item *definition;
1957 };
1958
1959 /**
1960  * @warning
1961  * @b EXPERIMENTAL: this structure may change without prior notice
1962  *
1963  * RTE_FLOW_ACTION_TYPE_SET_IPV4_SRC
1964  * RTE_FLOW_ACTION_TYPE_SET_IPV4_DST
1965  *
1966  * Allows modification of IPv4 source (RTE_FLOW_ACTION_TYPE_SET_IPV4_SRC)
1967  * and destination address (RTE_FLOW_ACTION_TYPE_SET_IPV4_DST) in the
1968  * specified outermost IPv4 header.
1969  */
1970 struct rte_flow_action_set_ipv4 {
1971         rte_be32_t ipv4_addr;
1972 };
1973
1974 /**
1975  * @warning
1976  * @b EXPERIMENTAL: this structure may change without prior notice
1977  *
1978  * RTE_FLOW_ACTION_TYPE_SET_IPV6_SRC
1979  * RTE_FLOW_ACTION_TYPE_SET_IPV6_DST
1980  *
1981  * Allows modification of IPv6 source (RTE_FLOW_ACTION_TYPE_SET_IPV6_SRC)
1982  * and destination address (RTE_FLOW_ACTION_TYPE_SET_IPV6_DST) in the
1983  * specified outermost IPv6 header.
1984  */
1985 struct rte_flow_action_set_ipv6 {
1986         uint8_t ipv6_addr[16];
1987 };
1988
1989 /**
1990  * @warning
1991  * @b EXPERIMENTAL: this structure may change without prior notice
1992  *
1993  * RTE_FLOW_ACTION_TYPE_SET_TP_SRC
1994  * RTE_FLOW_ACTION_TYPE_SET_TP_DST
1995  *
1996  * Allows modification of source (RTE_FLOW_ACTION_TYPE_SET_TP_SRC)
1997  * and destination (RTE_FLOW_ACTION_TYPE_SET_TP_DST) port numbers
1998  * in the specified outermost TCP/UDP header.
1999  */
2000 struct rte_flow_action_set_tp {
2001         rte_be16_t port;
2002 };
2003
2004 /**
2005  * RTE_FLOW_ACTION_TYPE_SET_TTL
2006  *
2007  * Set the TTL value directly for IPv4 or IPv6
2008  */
2009 struct rte_flow_action_set_ttl {
2010         uint8_t ttl_value;
2011 };
2012
2013 /*
2014  * Definition of a single action.
2015  *
2016  * A list of actions is terminated by a END action.
2017  *
2018  * For simple actions without a configuration structure, conf remains NULL.
2019  */
2020 struct rte_flow_action {
2021         enum rte_flow_action_type type; /**< Action type. */
2022         const void *conf; /**< Pointer to action configuration structure. */
2023 };
2024
2025 /**
2026  * Opaque type returned after successfully creating a flow.
2027  *
2028  * This handle can be used to manage and query the related flow (e.g. to
2029  * destroy it or retrieve counters).
2030  */
2031 struct rte_flow;
2032
2033 /**
2034  * Verbose error types.
2035  *
2036  * Most of them provide the type of the object referenced by struct
2037  * rte_flow_error.cause.
2038  */
2039 enum rte_flow_error_type {
2040         RTE_FLOW_ERROR_TYPE_NONE, /**< No error. */
2041         RTE_FLOW_ERROR_TYPE_UNSPECIFIED, /**< Cause unspecified. */
2042         RTE_FLOW_ERROR_TYPE_HANDLE, /**< Flow rule (handle). */
2043         RTE_FLOW_ERROR_TYPE_ATTR_GROUP, /**< Group field. */
2044         RTE_FLOW_ERROR_TYPE_ATTR_PRIORITY, /**< Priority field. */
2045         RTE_FLOW_ERROR_TYPE_ATTR_INGRESS, /**< Ingress field. */
2046         RTE_FLOW_ERROR_TYPE_ATTR_EGRESS, /**< Egress field. */
2047         RTE_FLOW_ERROR_TYPE_ATTR_TRANSFER, /**< Transfer field. */
2048         RTE_FLOW_ERROR_TYPE_ATTR, /**< Attributes structure. */
2049         RTE_FLOW_ERROR_TYPE_ITEM_NUM, /**< Pattern length. */
2050         RTE_FLOW_ERROR_TYPE_ITEM_SPEC, /**< Item specification. */
2051         RTE_FLOW_ERROR_TYPE_ITEM_LAST, /**< Item specification range. */
2052         RTE_FLOW_ERROR_TYPE_ITEM_MASK, /**< Item specification mask. */
2053         RTE_FLOW_ERROR_TYPE_ITEM, /**< Specific pattern item. */
2054         RTE_FLOW_ERROR_TYPE_ACTION_NUM, /**< Number of actions. */
2055         RTE_FLOW_ERROR_TYPE_ACTION_CONF, /**< Action configuration. */
2056         RTE_FLOW_ERROR_TYPE_ACTION, /**< Specific action. */
2057 };
2058
2059 /**
2060  * Verbose error structure definition.
2061  *
2062  * This object is normally allocated by applications and set by PMDs, the
2063  * message points to a constant string which does not need to be freed by
2064  * the application, however its pointer can be considered valid only as long
2065  * as its associated DPDK port remains configured. Closing the underlying
2066  * device or unloading the PMD invalidates it.
2067  *
2068  * Both cause and message may be NULL regardless of the error type.
2069  */
2070 struct rte_flow_error {
2071         enum rte_flow_error_type type; /**< Cause field and error types. */
2072         const void *cause; /**< Object responsible for the error. */
2073         const char *message; /**< Human-readable error message. */
2074 };
2075
2076 /**
2077  * Complete flow rule description.
2078  *
2079  * This object type is used when converting a flow rule description.
2080  *
2081  * @see RTE_FLOW_CONV_OP_RULE
2082  * @see rte_flow_conv()
2083  */
2084 RTE_STD_C11
2085 struct rte_flow_conv_rule {
2086         union {
2087                 const struct rte_flow_attr *attr_ro; /**< RO attributes. */
2088                 struct rte_flow_attr *attr; /**< Attributes. */
2089         };
2090         union {
2091                 const struct rte_flow_item *pattern_ro; /**< RO pattern. */
2092                 struct rte_flow_item *pattern; /**< Pattern items. */
2093         };
2094         union {
2095                 const struct rte_flow_action *actions_ro; /**< RO actions. */
2096                 struct rte_flow_action *actions; /**< List of actions. */
2097         };
2098 };
2099
2100 /**
2101  * Conversion operations for flow API objects.
2102  *
2103  * @see rte_flow_conv()
2104  */
2105 enum rte_flow_conv_op {
2106         /**
2107          * No operation to perform.
2108          *
2109          * rte_flow_conv() simply returns 0.
2110          */
2111         RTE_FLOW_CONV_OP_NONE,
2112
2113         /**
2114          * Convert attributes structure.
2115          *
2116          * This is a basic copy of an attributes structure.
2117          *
2118          * - @p src type:
2119          *   @code const struct rte_flow_attr * @endcode
2120          * - @p dst type:
2121          *   @code struct rte_flow_attr * @endcode
2122          */
2123         RTE_FLOW_CONV_OP_ATTR,
2124
2125         /**
2126          * Convert a single item.
2127          *
2128          * Duplicates @p spec, @p last and @p mask but not outside objects.
2129          *
2130          * - @p src type:
2131          *   @code const struct rte_flow_item * @endcode
2132          * - @p dst type:
2133          *   @code struct rte_flow_item * @endcode
2134          */
2135         RTE_FLOW_CONV_OP_ITEM,
2136
2137         /**
2138          * Convert a single action.
2139          *
2140          * Duplicates @p conf but not outside objects.
2141          *
2142          * - @p src type:
2143          *   @code const struct rte_flow_action * @endcode
2144          * - @p dst type:
2145          *   @code struct rte_flow_action * @endcode
2146          */
2147         RTE_FLOW_CONV_OP_ACTION,
2148
2149         /**
2150          * Convert an entire pattern.
2151          *
2152          * Duplicates all pattern items at once with the same constraints as
2153          * RTE_FLOW_CONV_OP_ITEM.
2154          *
2155          * - @p src type:
2156          *   @code const struct rte_flow_item * @endcode
2157          * - @p dst type:
2158          *   @code struct rte_flow_item * @endcode
2159          */
2160         RTE_FLOW_CONV_OP_PATTERN,
2161
2162         /**
2163          * Convert a list of actions.
2164          *
2165          * Duplicates the entire list of actions at once with the same
2166          * constraints as RTE_FLOW_CONV_OP_ACTION.
2167          *
2168          * - @p src type:
2169          *   @code const struct rte_flow_action * @endcode
2170          * - @p dst type:
2171          *   @code struct rte_flow_action * @endcode
2172          */
2173         RTE_FLOW_CONV_OP_ACTIONS,
2174
2175         /**
2176          * Convert a complete flow rule description.
2177          *
2178          * Comprises attributes, pattern and actions together at once with
2179          * the usual constraints.
2180          *
2181          * - @p src type:
2182          *   @code const struct rte_flow_conv_rule * @endcode
2183          * - @p dst type:
2184          *   @code struct rte_flow_conv_rule * @endcode
2185          */
2186         RTE_FLOW_CONV_OP_RULE,
2187
2188         /**
2189          * Convert item type to its name string.
2190          *
2191          * Writes a NUL-terminated string to @p dst. Like snprintf(), the
2192          * returned value excludes the terminator which is always written
2193          * nonetheless.
2194          *
2195          * - @p src type:
2196          *   @code (const void *)enum rte_flow_item_type @endcode
2197          * - @p dst type:
2198          *   @code char * @endcode
2199          **/
2200         RTE_FLOW_CONV_OP_ITEM_NAME,
2201
2202         /**
2203          * Convert action type to its name string.
2204          *
2205          * Writes a NUL-terminated string to @p dst. Like snprintf(), the
2206          * returned value excludes the terminator which is always written
2207          * nonetheless.
2208          *
2209          * - @p src type:
2210          *   @code (const void *)enum rte_flow_action_type @endcode
2211          * - @p dst type:
2212          *   @code char * @endcode
2213          **/
2214         RTE_FLOW_CONV_OP_ACTION_NAME,
2215
2216         /**
2217          * Convert item type to pointer to item name.
2218          *
2219          * Retrieves item name pointer from its type. The string itself is
2220          * not copied; instead, a unique pointer to an internal static
2221          * constant storage is written to @p dst.
2222          *
2223          * - @p src type:
2224          *   @code (const void *)enum rte_flow_item_type @endcode
2225          * - @p dst type:
2226          *   @code const char ** @endcode
2227          */
2228         RTE_FLOW_CONV_OP_ITEM_NAME_PTR,
2229
2230         /**
2231          * Convert action type to pointer to action name.
2232          *
2233          * Retrieves action name pointer from its type. The string itself is
2234          * not copied; instead, a unique pointer to an internal static
2235          * constant storage is written to @p dst.
2236          *
2237          * - @p src type:
2238          *   @code (const void *)enum rte_flow_action_type @endcode
2239          * - @p dst type:
2240          *   @code const char ** @endcode
2241          */
2242         RTE_FLOW_CONV_OP_ACTION_NAME_PTR,
2243 };
2244
2245 /**
2246  * Check whether a flow rule can be created on a given port.
2247  *
2248  * The flow rule is validated for correctness and whether it could be accepted
2249  * by the device given sufficient resources. The rule is checked against the
2250  * current device mode and queue configuration. The flow rule may also
2251  * optionally be validated against existing flow rules and device resources.
2252  * This function has no effect on the target device.
2253  *
2254  * The returned value is guaranteed to remain valid only as long as no
2255  * successful calls to rte_flow_create() or rte_flow_destroy() are made in
2256  * the meantime and no device parameter affecting flow rules in any way are
2257  * modified, due to possible collisions or resource limitations (although in
2258  * such cases EINVAL should not be returned).
2259  *
2260  * @param port_id
2261  *   Port identifier of Ethernet device.
2262  * @param[in] attr
2263  *   Flow rule attributes.
2264  * @param[in] pattern
2265  *   Pattern specification (list terminated by the END pattern item).
2266  * @param[in] actions
2267  *   Associated actions (list terminated by the END action).
2268  * @param[out] error
2269  *   Perform verbose error reporting if not NULL. PMDs initialize this
2270  *   structure in case of error only.
2271  *
2272  * @return
2273  *   0 if flow rule is valid and can be created. A negative errno value
2274  *   otherwise (rte_errno is also set), the following errors are defined:
2275  *
2276  *   -ENOSYS: underlying device does not support this functionality.
2277  *
2278  *   -EIO: underlying device is removed.
2279  *
2280  *   -EINVAL: unknown or invalid rule specification.
2281  *
2282  *   -ENOTSUP: valid but unsupported rule specification (e.g. partial
2283  *   bit-masks are unsupported).
2284  *
2285  *   -EEXIST: collision with an existing rule. Only returned if device
2286  *   supports flow rule collision checking and there was a flow rule
2287  *   collision. Not receiving this return code is no guarantee that creating
2288  *   the rule will not fail due to a collision.
2289  *
2290  *   -ENOMEM: not enough memory to execute the function, or if the device
2291  *   supports resource validation, resource limitation on the device.
2292  *
2293  *   -EBUSY: action cannot be performed due to busy device resources, may
2294  *   succeed if the affected queues or even the entire port are in a stopped
2295  *   state (see rte_eth_dev_rx_queue_stop() and rte_eth_dev_stop()).
2296  */
2297 int
2298 rte_flow_validate(uint16_t port_id,
2299                   const struct rte_flow_attr *attr,
2300                   const struct rte_flow_item pattern[],
2301                   const struct rte_flow_action actions[],
2302                   struct rte_flow_error *error);
2303
2304 /**
2305  * Create a flow rule on a given port.
2306  *
2307  * @param port_id
2308  *   Port identifier of Ethernet device.
2309  * @param[in] attr
2310  *   Flow rule attributes.
2311  * @param[in] pattern
2312  *   Pattern specification (list terminated by the END pattern item).
2313  * @param[in] actions
2314  *   Associated actions (list terminated by the END action).
2315  * @param[out] error
2316  *   Perform verbose error reporting if not NULL. PMDs initialize this
2317  *   structure in case of error only.
2318  *
2319  * @return
2320  *   A valid handle in case of success, NULL otherwise and rte_errno is set
2321  *   to the positive version of one of the error codes defined for
2322  *   rte_flow_validate().
2323  */
2324 struct rte_flow *
2325 rte_flow_create(uint16_t port_id,
2326                 const struct rte_flow_attr *attr,
2327                 const struct rte_flow_item pattern[],
2328                 const struct rte_flow_action actions[],
2329                 struct rte_flow_error *error);
2330
2331 /**
2332  * Destroy a flow rule on a given port.
2333  *
2334  * Failure to destroy a flow rule handle may occur when other flow rules
2335  * depend on it, and destroying it would result in an inconsistent state.
2336  *
2337  * This function is only guaranteed to succeed if handles are destroyed in
2338  * reverse order of their creation.
2339  *
2340  * @param port_id
2341  *   Port identifier of Ethernet device.
2342  * @param flow
2343  *   Flow rule handle to destroy.
2344  * @param[out] error
2345  *   Perform verbose error reporting if not NULL. PMDs initialize this
2346  *   structure in case of error only.
2347  *
2348  * @return
2349  *   0 on success, a negative errno value otherwise and rte_errno is set.
2350  */
2351 int
2352 rte_flow_destroy(uint16_t port_id,
2353                  struct rte_flow *flow,
2354                  struct rte_flow_error *error);
2355
2356 /**
2357  * Destroy all flow rules associated with a port.
2358  *
2359  * In the unlikely event of failure, handles are still considered destroyed
2360  * and no longer valid but the port must be assumed to be in an inconsistent
2361  * state.
2362  *
2363  * @param port_id
2364  *   Port identifier of Ethernet device.
2365  * @param[out] error
2366  *   Perform verbose error reporting if not NULL. PMDs initialize this
2367  *   structure in case of error only.
2368  *
2369  * @return
2370  *   0 on success, a negative errno value otherwise and rte_errno is set.
2371  */
2372 int
2373 rte_flow_flush(uint16_t port_id,
2374                struct rte_flow_error *error);
2375
2376 /**
2377  * Query an existing flow rule.
2378  *
2379  * This function allows retrieving flow-specific data such as counters.
2380  * Data is gathered by special actions which must be present in the flow
2381  * rule definition.
2382  *
2383  * \see RTE_FLOW_ACTION_TYPE_COUNT
2384  *
2385  * @param port_id
2386  *   Port identifier of Ethernet device.
2387  * @param flow
2388  *   Flow rule handle to query.
2389  * @param action
2390  *   Action definition as defined in original flow rule.
2391  * @param[in, out] data
2392  *   Pointer to storage for the associated query data type.
2393  * @param[out] error
2394  *   Perform verbose error reporting if not NULL. PMDs initialize this
2395  *   structure in case of error only.
2396  *
2397  * @return
2398  *   0 on success, a negative errno value otherwise and rte_errno is set.
2399  */
2400 int
2401 rte_flow_query(uint16_t port_id,
2402                struct rte_flow *flow,
2403                const struct rte_flow_action *action,
2404                void *data,
2405                struct rte_flow_error *error);
2406
2407 /**
2408  * Restrict ingress traffic to the defined flow rules.
2409  *
2410  * Isolated mode guarantees that all ingress traffic comes from defined flow
2411  * rules only (current and future).
2412  *
2413  * Besides making ingress more deterministic, it allows PMDs to safely reuse
2414  * resources otherwise assigned to handle the remaining traffic, such as
2415  * global RSS configuration settings, VLAN filters, MAC address entries,
2416  * legacy filter API rules and so on in order to expand the set of possible
2417  * flow rule types.
2418  *
2419  * Calling this function as soon as possible after device initialization,
2420  * ideally before the first call to rte_eth_dev_configure(), is recommended
2421  * to avoid possible failures due to conflicting settings.
2422  *
2423  * Once effective, leaving isolated mode may not be possible depending on
2424  * PMD implementation.
2425  *
2426  * Additionally, the following functionality has no effect on the underlying
2427  * port and may return errors such as ENOTSUP ("not supported"):
2428  *
2429  * - Toggling promiscuous mode.
2430  * - Toggling allmulticast mode.
2431  * - Configuring MAC addresses.
2432  * - Configuring multicast addresses.
2433  * - Configuring VLAN filters.
2434  * - Configuring Rx filters through the legacy API (e.g. FDIR).
2435  * - Configuring global RSS settings.
2436  *
2437  * @param port_id
2438  *   Port identifier of Ethernet device.
2439  * @param set
2440  *   Nonzero to enter isolated mode, attempt to leave it otherwise.
2441  * @param[out] error
2442  *   Perform verbose error reporting if not NULL. PMDs initialize this
2443  *   structure in case of error only.
2444  *
2445  * @return
2446  *   0 on success, a negative errno value otherwise and rte_errno is set.
2447  */
2448 int
2449 rte_flow_isolate(uint16_t port_id, int set, struct rte_flow_error *error);
2450
2451 /**
2452  * Initialize flow error structure.
2453  *
2454  * @param[out] error
2455  *   Pointer to flow error structure (may be NULL).
2456  * @param code
2457  *   Related error code (rte_errno).
2458  * @param type
2459  *   Cause field and error types.
2460  * @param cause
2461  *   Object responsible for the error.
2462  * @param message
2463  *   Human-readable error message.
2464  *
2465  * @return
2466  *   Negative error code (errno value) and rte_errno is set.
2467  */
2468 int
2469 rte_flow_error_set(struct rte_flow_error *error,
2470                    int code,
2471                    enum rte_flow_error_type type,
2472                    const void *cause,
2473                    const char *message);
2474
2475 /**
2476  * @deprecated
2477  * @see rte_flow_copy()
2478  */
2479 struct rte_flow_desc {
2480         size_t size; /**< Allocated space including data[]. */
2481         struct rte_flow_attr attr; /**< Attributes. */
2482         struct rte_flow_item *items; /**< Items. */
2483         struct rte_flow_action *actions; /**< Actions. */
2484         uint8_t data[]; /**< Storage for items/actions. */
2485 };
2486
2487 /**
2488  * @deprecated
2489  * Copy an rte_flow rule description.
2490  *
2491  * This interface is kept for compatibility with older applications but is
2492  * implemented as a wrapper to rte_flow_conv(). It is deprecated due to its
2493  * lack of flexibility and reliance on a type unusable with C++ programs
2494  * (struct rte_flow_desc).
2495  *
2496  * @param[in] fd
2497  *   Flow rule description.
2498  * @param[in] len
2499  *   Total size of allocated data for the flow description.
2500  * @param[in] attr
2501  *   Flow rule attributes.
2502  * @param[in] items
2503  *   Pattern specification (list terminated by the END pattern item).
2504  * @param[in] actions
2505  *   Associated actions (list terminated by the END action).
2506  *
2507  * @return
2508  *   If len is greater or equal to the size of the flow, the total size of the
2509  *   flow description and its data.
2510  *   If len is lower than the size of the flow, the number of bytes that would
2511  *   have been written to desc had it been sufficient. Nothing is written.
2512  */
2513 __rte_deprecated
2514 size_t
2515 rte_flow_copy(struct rte_flow_desc *fd, size_t len,
2516               const struct rte_flow_attr *attr,
2517               const struct rte_flow_item *items,
2518               const struct rte_flow_action *actions);
2519
2520 /**
2521  * Flow object conversion helper.
2522  *
2523  * This function performs conversion of various flow API objects to a
2524  * pre-allocated destination buffer. See enum rte_flow_conv_op for possible
2525  * operations and details about each of them.
2526  *
2527  * Since destination buffer must be large enough, it works in a manner
2528  * reminiscent of snprintf():
2529  *
2530  * - If @p size is 0, @p dst may be a NULL pointer, otherwise @p dst must be
2531  *   non-NULL.
2532  * - If positive, the returned value represents the number of bytes needed
2533  *   to store the conversion of @p src to @p dst according to @p op
2534  *   regardless of the @p size parameter.
2535  * - Since no more than @p size bytes can be written to @p dst, output is
2536  *   truncated and may be inconsistent when the returned value is larger
2537  *   than that.
2538  * - In case of conversion error, a negative error code is returned and
2539  *   @p dst contents are unspecified.
2540  *
2541  * @param op
2542  *   Operation to perform, related to the object type of @p dst.
2543  * @param[out] dst
2544  *   Destination buffer address. Must be suitably aligned by the caller.
2545  * @param size
2546  *   Destination buffer size in bytes.
2547  * @param[in] src
2548  *   Source object to copy. Depending on @p op, its type may differ from
2549  *   that of @p dst.
2550  * @param[out] error
2551  *   Perform verbose error reporting if not NULL. Initialized in case of
2552  *   error only.
2553  *
2554  * @return
2555  *   The number of bytes required to convert @p src to @p dst on success, a
2556  *   negative errno value otherwise and rte_errno is set.
2557  *
2558  * @see rte_flow_conv_op
2559  */
2560 __rte_experimental
2561 int
2562 rte_flow_conv(enum rte_flow_conv_op op,
2563               void *dst,
2564               size_t size,
2565               const void *src,
2566               struct rte_flow_error *error);
2567
2568 #ifdef __cplusplus
2569 }
2570 #endif
2571
2572 #endif /* RTE_FLOW_H_ */