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 /**
1574  * RTE_FLOW_ACTION_TYPE_MARK
1575  *
1576  * Attaches an integer value to packets and sets PKT_RX_FDIR and
1577  * PKT_RX_FDIR_ID mbuf flags.
1578  *
1579  * This value is arbitrary and application-defined. Maximum allowed value
1580  * depends on the underlying implementation. It is returned in the
1581  * hash.fdir.hi mbuf field.
1582  */
1583 struct rte_flow_action_mark {
1584         uint32_t id; /**< Integer value to return with packets. */
1585 };
1586
1587 /**
1588  * @warning
1589  * @b EXPERIMENTAL: this structure may change without prior notice
1590  *
1591  * RTE_FLOW_ACTION_TYPE_JUMP
1592  *
1593  * Redirects packets to a group on the current device.
1594  *
1595  * In a hierarchy of groups, which can be used to represent physical or logical
1596  * flow tables on the device, this action allows the action to be a redirect to
1597  * a group on that device.
1598  */
1599 struct rte_flow_action_jump {
1600         uint32_t group;
1601 };
1602
1603 /**
1604  * RTE_FLOW_ACTION_TYPE_QUEUE
1605  *
1606  * Assign packets to a given queue index.
1607  */
1608 struct rte_flow_action_queue {
1609         uint16_t index; /**< Queue index to use. */
1610 };
1611
1612
1613 /**
1614  * @warning
1615  * @b EXPERIMENTAL: this structure may change without prior notice
1616  *
1617  * RTE_FLOW_ACTION_TYPE_COUNT
1618  *
1619  * Adds a counter action to a matched flow.
1620  *
1621  * If more than one count action is specified in a single flow rule, then each
1622  * action must specify a unique id.
1623  *
1624  * Counters can be retrieved and reset through ``rte_flow_query()``, see
1625  * ``struct rte_flow_query_count``.
1626  *
1627  * The shared flag indicates whether the counter is unique to the flow rule the
1628  * action is specified with, or whether it is a shared counter.
1629  *
1630  * For a count action with the shared flag set, then then a global device
1631  * namespace is assumed for the counter id, so that any matched flow rules using
1632  * a count action with the same counter id on the same port will contribute to
1633  * that counter.
1634  *
1635  * For ports within the same switch domain then the counter id namespace extends
1636  * to all ports within that switch domain.
1637  */
1638 struct rte_flow_action_count {
1639         uint32_t shared:1; /**< Share counter ID with other flow rules. */
1640         uint32_t reserved:31; /**< Reserved, must be zero. */
1641         uint32_t id; /**< Counter ID. */
1642 };
1643
1644 /**
1645  * RTE_FLOW_ACTION_TYPE_COUNT (query)
1646  *
1647  * Query structure to retrieve and reset flow rule counters.
1648  */
1649 struct rte_flow_query_count {
1650         uint32_t reset:1; /**< Reset counters after query [in]. */
1651         uint32_t hits_set:1; /**< hits field is set [out]. */
1652         uint32_t bytes_set:1; /**< bytes field is set [out]. */
1653         uint32_t reserved:29; /**< Reserved, must be zero [in, out]. */
1654         uint64_t hits; /**< Number of hits for this rule [out]. */
1655         uint64_t bytes; /**< Number of bytes through this rule [out]. */
1656 };
1657
1658 /**
1659  * RTE_FLOW_ACTION_TYPE_RSS
1660  *
1661  * Similar to QUEUE, except RSS is additionally performed on packets to
1662  * spread them among several queues according to the provided parameters.
1663  *
1664  * Unlike global RSS settings used by other DPDK APIs, unsetting the
1665  * @p types field does not disable RSS in a flow rule. Doing so instead
1666  * requests safe unspecified "best-effort" settings from the underlying PMD,
1667  * which depending on the flow rule, may result in anything ranging from
1668  * empty (single queue) to all-inclusive RSS.
1669  *
1670  * Note: RSS hash result is stored in the hash.rss mbuf field which overlaps
1671  * hash.fdir.lo. Since the MARK action sets the hash.fdir.hi field only,
1672  * both can be requested simultaneously.
1673  */
1674 struct rte_flow_action_rss {
1675         enum rte_eth_hash_function func; /**< RSS hash function to apply. */
1676         /**
1677          * Packet encapsulation level RSS hash @p types apply to.
1678          *
1679          * - @p 0 requests the default behavior. Depending on the packet
1680          *   type, it can mean outermost, innermost, anything in between or
1681          *   even no RSS.
1682          *
1683          *   It basically stands for the innermost encapsulation level RSS
1684          *   can be performed on according to PMD and device capabilities.
1685          *
1686          * - @p 1 requests RSS to be performed on the outermost packet
1687          *   encapsulation level.
1688          *
1689          * - @p 2 and subsequent values request RSS to be performed on the
1690          *   specified inner packet encapsulation level, from outermost to
1691          *   innermost (lower to higher values).
1692          *
1693          * Values other than @p 0 are not necessarily supported.
1694          *
1695          * Requesting a specific RSS level on unrecognized traffic results
1696          * in undefined behavior. For predictable results, it is recommended
1697          * to make the flow rule pattern match packet headers up to the
1698          * requested encapsulation level so that only matching traffic goes
1699          * through.
1700          */
1701         uint32_t level;
1702         uint64_t types; /**< Specific RSS hash types (see ETH_RSS_*). */
1703         uint32_t key_len; /**< Hash key length in bytes. */
1704         uint32_t queue_num; /**< Number of entries in @p queue. */
1705         const uint8_t *key; /**< Hash key. */
1706         const uint16_t *queue; /**< Queue indices to use. */
1707 };
1708
1709 /**
1710  * RTE_FLOW_ACTION_TYPE_VF
1711  *
1712  * Directs matching traffic to a given virtual function of the current
1713  * device.
1714  *
1715  * Packets matched by a VF pattern item can be redirected to their original
1716  * VF ID instead of the specified one. This parameter may not be available
1717  * and is not guaranteed to work properly if the VF part is matched by a
1718  * prior flow rule or if packets are not addressed to a VF in the first
1719  * place.
1720  */
1721 struct rte_flow_action_vf {
1722         uint32_t original:1; /**< Use original VF ID if possible. */
1723         uint32_t reserved:31; /**< Reserved, must be zero. */
1724         uint32_t id; /**< VF ID. */
1725 };
1726
1727 /**
1728  * RTE_FLOW_ACTION_TYPE_PHY_PORT
1729  *
1730  * Directs packets to a given physical port index of the underlying
1731  * device.
1732  *
1733  * @see RTE_FLOW_ITEM_TYPE_PHY_PORT
1734  */
1735 struct rte_flow_action_phy_port {
1736         uint32_t original:1; /**< Use original port index if possible. */
1737         uint32_t reserved:31; /**< Reserved, must be zero. */
1738         uint32_t index; /**< Physical port index. */
1739 };
1740
1741 /**
1742  * RTE_FLOW_ACTION_TYPE_PORT_ID
1743  *
1744  * Directs matching traffic to a given DPDK port ID.
1745  *
1746  * @see RTE_FLOW_ITEM_TYPE_PORT_ID
1747  */
1748 struct rte_flow_action_port_id {
1749         uint32_t original:1; /**< Use original DPDK port ID if possible. */
1750         uint32_t reserved:31; /**< Reserved, must be zero. */
1751         uint32_t id; /**< DPDK port ID. */
1752 };
1753
1754 /**
1755  * RTE_FLOW_ACTION_TYPE_METER
1756  *
1757  * Traffic metering and policing (MTR).
1758  *
1759  * Packets matched by items of this type can be either dropped or passed to the
1760  * next item with their color set by the MTR object.
1761  */
1762 struct rte_flow_action_meter {
1763         uint32_t mtr_id; /**< MTR object ID created with rte_mtr_create(). */
1764 };
1765
1766 /**
1767  * RTE_FLOW_ACTION_TYPE_SECURITY
1768  *
1769  * Perform the security action on flows matched by the pattern items
1770  * according to the configuration of the security session.
1771  *
1772  * This action modifies the payload of matched flows. For INLINE_CRYPTO, the
1773  * security protocol headers and IV are fully provided by the application as
1774  * specified in the flow pattern. The payload of matching packets is
1775  * encrypted on egress, and decrypted and authenticated on ingress.
1776  * For INLINE_PROTOCOL, the security protocol is fully offloaded to HW,
1777  * providing full encapsulation and decapsulation of packets in security
1778  * protocols. The flow pattern specifies both the outer security header fields
1779  * and the inner packet fields. The security session specified in the action
1780  * must match the pattern parameters.
1781  *
1782  * The security session specified in the action must be created on the same
1783  * port as the flow action that is being specified.
1784  *
1785  * The ingress/egress flow attribute should match that specified in the
1786  * security session if the security session supports the definition of the
1787  * direction.
1788  *
1789  * Multiple flows can be configured to use the same security session.
1790  */
1791 struct rte_flow_action_security {
1792         void *security_session; /**< Pointer to security session structure. */
1793 };
1794
1795 /**
1796  * RTE_FLOW_ACTION_TYPE_OF_SET_MPLS_TTL
1797  *
1798  * Implements OFPAT_SET_MPLS_TTL ("MPLS TTL") as defined by the OpenFlow
1799  * Switch Specification.
1800  */
1801 struct rte_flow_action_of_set_mpls_ttl {
1802         uint8_t mpls_ttl; /**< MPLS TTL. */
1803 };
1804
1805 /**
1806  * RTE_FLOW_ACTION_TYPE_OF_SET_NW_TTL
1807  *
1808  * Implements OFPAT_SET_NW_TTL ("IP TTL") as defined by the OpenFlow Switch
1809  * Specification.
1810  */
1811 struct rte_flow_action_of_set_nw_ttl {
1812         uint8_t nw_ttl; /**< IP TTL. */
1813 };
1814
1815 /**
1816  * RTE_FLOW_ACTION_TYPE_OF_PUSH_VLAN
1817  *
1818  * Implements OFPAT_PUSH_VLAN ("push a new VLAN tag") as defined by the
1819  * OpenFlow Switch Specification.
1820  */
1821 struct rte_flow_action_of_push_vlan {
1822         rte_be16_t ethertype; /**< EtherType. */
1823 };
1824
1825 /**
1826  * RTE_FLOW_ACTION_TYPE_OF_SET_VLAN_VID
1827  *
1828  * Implements OFPAT_SET_VLAN_VID ("set the 802.1q VLAN id") as defined by
1829  * the OpenFlow Switch Specification.
1830  */
1831 struct rte_flow_action_of_set_vlan_vid {
1832         rte_be16_t vlan_vid; /**< VLAN id. */
1833 };
1834
1835 /**
1836  * RTE_FLOW_ACTION_TYPE_OF_SET_VLAN_PCP
1837  *
1838  * Implements OFPAT_SET_LAN_PCP ("set the 802.1q priority") as defined by
1839  * the OpenFlow Switch Specification.
1840  */
1841 struct rte_flow_action_of_set_vlan_pcp {
1842         uint8_t vlan_pcp; /**< VLAN priority. */
1843 };
1844
1845 /**
1846  * RTE_FLOW_ACTION_TYPE_OF_POP_MPLS
1847  *
1848  * Implements OFPAT_POP_MPLS ("pop the outer MPLS tag") as defined by the
1849  * OpenFlow Switch Specification.
1850  */
1851 struct rte_flow_action_of_pop_mpls {
1852         rte_be16_t ethertype; /**< EtherType. */
1853 };
1854
1855 /**
1856  * RTE_FLOW_ACTION_TYPE_OF_PUSH_MPLS
1857  *
1858  * Implements OFPAT_PUSH_MPLS ("push a new MPLS tag") as defined by the
1859  * OpenFlow Switch Specification.
1860  */
1861 struct rte_flow_action_of_push_mpls {
1862         rte_be16_t ethertype; /**< EtherType. */
1863 };
1864
1865 /**
1866  * @warning
1867  * @b EXPERIMENTAL: this structure may change without prior notice
1868  *
1869  * RTE_FLOW_ACTION_TYPE_VXLAN_ENCAP
1870  *
1871  * VXLAN tunnel end-point encapsulation data definition
1872  *
1873  * The tunnel definition is provided through the flow item pattern, the
1874  * provided pattern must conform to RFC7348 for the tunnel specified. The flow
1875  * definition must be provided in order from the RTE_FLOW_ITEM_TYPE_ETH
1876  * definition up the end item which is specified by RTE_FLOW_ITEM_TYPE_END.
1877  *
1878  * The mask field allows user to specify which fields in the flow item
1879  * definitions can be ignored and which have valid data and can be used
1880  * verbatim.
1881  *
1882  * Note: the last field is not used in the definition of a tunnel and can be
1883  * ignored.
1884  *
1885  * Valid flow definition for RTE_FLOW_ACTION_TYPE_VXLAN_ENCAP include:
1886  *
1887  * - ETH / IPV4 / UDP / VXLAN / END
1888  * - ETH / IPV6 / UDP / VXLAN / END
1889  * - ETH / VLAN / IPV4 / UDP / VXLAN / END
1890  *
1891  */
1892 struct rte_flow_action_vxlan_encap {
1893         /**
1894          * Encapsulating vxlan tunnel definition
1895          * (terminated by the END pattern item).
1896          */
1897         struct rte_flow_item *definition;
1898 };
1899
1900 /**
1901  * @warning
1902  * @b EXPERIMENTAL: this structure may change without prior notice
1903  *
1904  * RTE_FLOW_ACTION_TYPE_NVGRE_ENCAP
1905  *
1906  * NVGRE tunnel end-point encapsulation data definition
1907  *
1908  * The tunnel definition is provided through the flow item pattern  the
1909  * provided pattern must conform with RFC7637. The flow definition must be
1910  * provided in order from the RTE_FLOW_ITEM_TYPE_ETH definition up the end item
1911  * which is specified by RTE_FLOW_ITEM_TYPE_END.
1912  *
1913  * The mask field allows user to specify which fields in the flow item
1914  * definitions can be ignored and which have valid data and can be used
1915  * verbatim.
1916  *
1917  * Note: the last field is not used in the definition of a tunnel and can be
1918  * ignored.
1919  *
1920  * Valid flow definition for RTE_FLOW_ACTION_TYPE_NVGRE_ENCAP include:
1921  *
1922  * - ETH / IPV4 / NVGRE / END
1923  * - ETH / VLAN / IPV6 / NVGRE / END
1924  *
1925  */
1926 struct rte_flow_action_nvgre_encap {
1927         /**
1928          * Encapsulating vxlan tunnel definition
1929          * (terminated by the END pattern item).
1930          */
1931         struct rte_flow_item *definition;
1932 };
1933
1934 /**
1935  * @warning
1936  * @b EXPERIMENTAL: this structure may change without prior notice
1937  *
1938  * RTE_FLOW_ACTION_TYPE_SET_IPV4_SRC
1939  * RTE_FLOW_ACTION_TYPE_SET_IPV4_DST
1940  *
1941  * Allows modification of IPv4 source (RTE_FLOW_ACTION_TYPE_SET_IPV4_SRC)
1942  * and destination address (RTE_FLOW_ACTION_TYPE_SET_IPV4_DST) in the
1943  * specified outermost IPv4 header.
1944  */
1945 struct rte_flow_action_set_ipv4 {
1946         rte_be32_t ipv4_addr;
1947 };
1948
1949 /**
1950  * @warning
1951  * @b EXPERIMENTAL: this structure may change without prior notice
1952  *
1953  * RTE_FLOW_ACTION_TYPE_SET_IPV6_SRC
1954  * RTE_FLOW_ACTION_TYPE_SET_IPV6_DST
1955  *
1956  * Allows modification of IPv6 source (RTE_FLOW_ACTION_TYPE_SET_IPV6_SRC)
1957  * and destination address (RTE_FLOW_ACTION_TYPE_SET_IPV6_DST) in the
1958  * specified outermost IPv6 header.
1959  */
1960 struct rte_flow_action_set_ipv6 {
1961         uint8_t ipv6_addr[16];
1962 };
1963
1964 /**
1965  * @warning
1966  * @b EXPERIMENTAL: this structure may change without prior notice
1967  *
1968  * RTE_FLOW_ACTION_TYPE_SET_TP_SRC
1969  * RTE_FLOW_ACTION_TYPE_SET_TP_DST
1970  *
1971  * Allows modification of source (RTE_FLOW_ACTION_TYPE_SET_TP_SRC)
1972  * and destination (RTE_FLOW_ACTION_TYPE_SET_TP_DST) port numbers
1973  * in the specified outermost TCP/UDP header.
1974  */
1975 struct rte_flow_action_set_tp {
1976         rte_be16_t port;
1977 };
1978
1979 /*
1980  * Definition of a single action.
1981  *
1982  * A list of actions is terminated by a END action.
1983  *
1984  * For simple actions without a configuration structure, conf remains NULL.
1985  */
1986 struct rte_flow_action {
1987         enum rte_flow_action_type type; /**< Action type. */
1988         const void *conf; /**< Pointer to action configuration structure. */
1989 };
1990
1991 /**
1992  * Opaque type returned after successfully creating a flow.
1993  *
1994  * This handle can be used to manage and query the related flow (e.g. to
1995  * destroy it or retrieve counters).
1996  */
1997 struct rte_flow;
1998
1999 /**
2000  * Verbose error types.
2001  *
2002  * Most of them provide the type of the object referenced by struct
2003  * rte_flow_error.cause.
2004  */
2005 enum rte_flow_error_type {
2006         RTE_FLOW_ERROR_TYPE_NONE, /**< No error. */
2007         RTE_FLOW_ERROR_TYPE_UNSPECIFIED, /**< Cause unspecified. */
2008         RTE_FLOW_ERROR_TYPE_HANDLE, /**< Flow rule (handle). */
2009         RTE_FLOW_ERROR_TYPE_ATTR_GROUP, /**< Group field. */
2010         RTE_FLOW_ERROR_TYPE_ATTR_PRIORITY, /**< Priority field. */
2011         RTE_FLOW_ERROR_TYPE_ATTR_INGRESS, /**< Ingress field. */
2012         RTE_FLOW_ERROR_TYPE_ATTR_EGRESS, /**< Egress field. */
2013         RTE_FLOW_ERROR_TYPE_ATTR_TRANSFER, /**< Transfer field. */
2014         RTE_FLOW_ERROR_TYPE_ATTR, /**< Attributes structure. */
2015         RTE_FLOW_ERROR_TYPE_ITEM_NUM, /**< Pattern length. */
2016         RTE_FLOW_ERROR_TYPE_ITEM_SPEC, /**< Item specification. */
2017         RTE_FLOW_ERROR_TYPE_ITEM_LAST, /**< Item specification range. */
2018         RTE_FLOW_ERROR_TYPE_ITEM_MASK, /**< Item specification mask. */
2019         RTE_FLOW_ERROR_TYPE_ITEM, /**< Specific pattern item. */
2020         RTE_FLOW_ERROR_TYPE_ACTION_NUM, /**< Number of actions. */
2021         RTE_FLOW_ERROR_TYPE_ACTION_CONF, /**< Action configuration. */
2022         RTE_FLOW_ERROR_TYPE_ACTION, /**< Specific action. */
2023 };
2024
2025 /**
2026  * Verbose error structure definition.
2027  *
2028  * This object is normally allocated by applications and set by PMDs, the
2029  * message points to a constant string which does not need to be freed by
2030  * the application, however its pointer can be considered valid only as long
2031  * as its associated DPDK port remains configured. Closing the underlying
2032  * device or unloading the PMD invalidates it.
2033  *
2034  * Both cause and message may be NULL regardless of the error type.
2035  */
2036 struct rte_flow_error {
2037         enum rte_flow_error_type type; /**< Cause field and error types. */
2038         const void *cause; /**< Object responsible for the error. */
2039         const char *message; /**< Human-readable error message. */
2040 };
2041
2042 /**
2043  * Complete flow rule description.
2044  *
2045  * This object type is used when converting a flow rule description.
2046  *
2047  * @see RTE_FLOW_CONV_OP_RULE
2048  * @see rte_flow_conv()
2049  */
2050 RTE_STD_C11
2051 struct rte_flow_conv_rule {
2052         union {
2053                 const struct rte_flow_attr *attr_ro; /**< RO attributes. */
2054                 struct rte_flow_attr *attr; /**< Attributes. */
2055         };
2056         union {
2057                 const struct rte_flow_item *pattern_ro; /**< RO pattern. */
2058                 struct rte_flow_item *pattern; /**< Pattern items. */
2059         };
2060         union {
2061                 const struct rte_flow_action *actions_ro; /**< RO actions. */
2062                 struct rte_flow_action *actions; /**< List of actions. */
2063         };
2064 };
2065
2066 /**
2067  * Conversion operations for flow API objects.
2068  *
2069  * @see rte_flow_conv()
2070  */
2071 enum rte_flow_conv_op {
2072         /**
2073          * No operation to perform.
2074          *
2075          * rte_flow_conv() simply returns 0.
2076          */
2077         RTE_FLOW_CONV_OP_NONE,
2078
2079         /**
2080          * Convert attributes structure.
2081          *
2082          * This is a basic copy of an attributes structure.
2083          *
2084          * - @p src type:
2085          *   @code const struct rte_flow_attr * @endcode
2086          * - @p dst type:
2087          *   @code struct rte_flow_attr * @endcode
2088          */
2089         RTE_FLOW_CONV_OP_ATTR,
2090
2091         /**
2092          * Convert a single item.
2093          *
2094          * Duplicates @p spec, @p last and @p mask but not outside objects.
2095          *
2096          * - @p src type:
2097          *   @code const struct rte_flow_item * @endcode
2098          * - @p dst type:
2099          *   @code struct rte_flow_item * @endcode
2100          */
2101         RTE_FLOW_CONV_OP_ITEM,
2102
2103         /**
2104          * Convert a single action.
2105          *
2106          * Duplicates @p conf but not outside objects.
2107          *
2108          * - @p src type:
2109          *   @code const struct rte_flow_action * @endcode
2110          * - @p dst type:
2111          *   @code struct rte_flow_action * @endcode
2112          */
2113         RTE_FLOW_CONV_OP_ACTION,
2114
2115         /**
2116          * Convert an entire pattern.
2117          *
2118          * Duplicates all pattern items at once with the same constraints as
2119          * RTE_FLOW_CONV_OP_ITEM.
2120          *
2121          * - @p src type:
2122          *   @code const struct rte_flow_item * @endcode
2123          * - @p dst type:
2124          *   @code struct rte_flow_item * @endcode
2125          */
2126         RTE_FLOW_CONV_OP_PATTERN,
2127
2128         /**
2129          * Convert a list of actions.
2130          *
2131          * Duplicates the entire list of actions at once with the same
2132          * constraints as RTE_FLOW_CONV_OP_ACTION.
2133          *
2134          * - @p src type:
2135          *   @code const struct rte_flow_action * @endcode
2136          * - @p dst type:
2137          *   @code struct rte_flow_action * @endcode
2138          */
2139         RTE_FLOW_CONV_OP_ACTIONS,
2140
2141         /**
2142          * Convert a complete flow rule description.
2143          *
2144          * Comprises attributes, pattern and actions together at once with
2145          * the usual constraints.
2146          *
2147          * - @p src type:
2148          *   @code const struct rte_flow_conv_rule * @endcode
2149          * - @p dst type:
2150          *   @code struct rte_flow_conv_rule * @endcode
2151          */
2152         RTE_FLOW_CONV_OP_RULE,
2153
2154         /**
2155          * Convert item type to its name string.
2156          *
2157          * Writes a NUL-terminated string to @p dst. Like snprintf(), the
2158          * returned value excludes the terminator which is always written
2159          * nonetheless.
2160          *
2161          * - @p src type:
2162          *   @code (const void *)enum rte_flow_item_type @endcode
2163          * - @p dst type:
2164          *   @code char * @endcode
2165          **/
2166         RTE_FLOW_CONV_OP_ITEM_NAME,
2167
2168         /**
2169          * Convert action type to its name string.
2170          *
2171          * Writes a NUL-terminated string to @p dst. Like snprintf(), the
2172          * returned value excludes the terminator which is always written
2173          * nonetheless.
2174          *
2175          * - @p src type:
2176          *   @code (const void *)enum rte_flow_action_type @endcode
2177          * - @p dst type:
2178          *   @code char * @endcode
2179          **/
2180         RTE_FLOW_CONV_OP_ACTION_NAME,
2181
2182         /**
2183          * Convert item type to pointer to item name.
2184          *
2185          * Retrieves item name pointer from its type. The string itself is
2186          * not copied; instead, a unique pointer to an internal static
2187          * constant storage is written to @p dst.
2188          *
2189          * - @p src type:
2190          *   @code (const void *)enum rte_flow_item_type @endcode
2191          * - @p dst type:
2192          *   @code const char ** @endcode
2193          */
2194         RTE_FLOW_CONV_OP_ITEM_NAME_PTR,
2195
2196         /**
2197          * Convert action type to pointer to action name.
2198          *
2199          * Retrieves action name pointer from its type. The string itself is
2200          * not copied; instead, a unique pointer to an internal static
2201          * constant storage is written to @p dst.
2202          *
2203          * - @p src type:
2204          *   @code (const void *)enum rte_flow_action_type @endcode
2205          * - @p dst type:
2206          *   @code const char ** @endcode
2207          */
2208         RTE_FLOW_CONV_OP_ACTION_NAME_PTR,
2209 };
2210
2211 /**
2212  * Check whether a flow rule can be created on a given port.
2213  *
2214  * The flow rule is validated for correctness and whether it could be accepted
2215  * by the device given sufficient resources. The rule is checked against the
2216  * current device mode and queue configuration. The flow rule may also
2217  * optionally be validated against existing flow rules and device resources.
2218  * This function has no effect on the target device.
2219  *
2220  * The returned value is guaranteed to remain valid only as long as no
2221  * successful calls to rte_flow_create() or rte_flow_destroy() are made in
2222  * the meantime and no device parameter affecting flow rules in any way are
2223  * modified, due to possible collisions or resource limitations (although in
2224  * such cases EINVAL should not be returned).
2225  *
2226  * @param port_id
2227  *   Port identifier of Ethernet device.
2228  * @param[in] attr
2229  *   Flow rule attributes.
2230  * @param[in] pattern
2231  *   Pattern specification (list terminated by the END pattern item).
2232  * @param[in] actions
2233  *   Associated actions (list terminated by the END action).
2234  * @param[out] error
2235  *   Perform verbose error reporting if not NULL. PMDs initialize this
2236  *   structure in case of error only.
2237  *
2238  * @return
2239  *   0 if flow rule is valid and can be created. A negative errno value
2240  *   otherwise (rte_errno is also set), the following errors are defined:
2241  *
2242  *   -ENOSYS: underlying device does not support this functionality.
2243  *
2244  *   -EIO: underlying device is removed.
2245  *
2246  *   -EINVAL: unknown or invalid rule specification.
2247  *
2248  *   -ENOTSUP: valid but unsupported rule specification (e.g. partial
2249  *   bit-masks are unsupported).
2250  *
2251  *   -EEXIST: collision with an existing rule. Only returned if device
2252  *   supports flow rule collision checking and there was a flow rule
2253  *   collision. Not receiving this return code is no guarantee that creating
2254  *   the rule will not fail due to a collision.
2255  *
2256  *   -ENOMEM: not enough memory to execute the function, or if the device
2257  *   supports resource validation, resource limitation on the device.
2258  *
2259  *   -EBUSY: action cannot be performed due to busy device resources, may
2260  *   succeed if the affected queues or even the entire port are in a stopped
2261  *   state (see rte_eth_dev_rx_queue_stop() and rte_eth_dev_stop()).
2262  */
2263 int
2264 rte_flow_validate(uint16_t port_id,
2265                   const struct rte_flow_attr *attr,
2266                   const struct rte_flow_item pattern[],
2267                   const struct rte_flow_action actions[],
2268                   struct rte_flow_error *error);
2269
2270 /**
2271  * Create a flow rule on a given port.
2272  *
2273  * @param port_id
2274  *   Port identifier of Ethernet device.
2275  * @param[in] attr
2276  *   Flow rule attributes.
2277  * @param[in] pattern
2278  *   Pattern specification (list terminated by the END pattern item).
2279  * @param[in] actions
2280  *   Associated actions (list terminated by the END action).
2281  * @param[out] error
2282  *   Perform verbose error reporting if not NULL. PMDs initialize this
2283  *   structure in case of error only.
2284  *
2285  * @return
2286  *   A valid handle in case of success, NULL otherwise and rte_errno is set
2287  *   to the positive version of one of the error codes defined for
2288  *   rte_flow_validate().
2289  */
2290 struct rte_flow *
2291 rte_flow_create(uint16_t port_id,
2292                 const struct rte_flow_attr *attr,
2293                 const struct rte_flow_item pattern[],
2294                 const struct rte_flow_action actions[],
2295                 struct rte_flow_error *error);
2296
2297 /**
2298  * Destroy a flow rule on a given port.
2299  *
2300  * Failure to destroy a flow rule handle may occur when other flow rules
2301  * depend on it, and destroying it would result in an inconsistent state.
2302  *
2303  * This function is only guaranteed to succeed if handles are destroyed in
2304  * reverse order of their creation.
2305  *
2306  * @param port_id
2307  *   Port identifier of Ethernet device.
2308  * @param flow
2309  *   Flow rule handle to destroy.
2310  * @param[out] error
2311  *   Perform verbose error reporting if not NULL. PMDs initialize this
2312  *   structure in case of error only.
2313  *
2314  * @return
2315  *   0 on success, a negative errno value otherwise and rte_errno is set.
2316  */
2317 int
2318 rte_flow_destroy(uint16_t port_id,
2319                  struct rte_flow *flow,
2320                  struct rte_flow_error *error);
2321
2322 /**
2323  * Destroy all flow rules associated with a port.
2324  *
2325  * In the unlikely event of failure, handles are still considered destroyed
2326  * and no longer valid but the port must be assumed to be in an inconsistent
2327  * state.
2328  *
2329  * @param port_id
2330  *   Port identifier of Ethernet device.
2331  * @param[out] error
2332  *   Perform verbose error reporting if not NULL. PMDs initialize this
2333  *   structure in case of error only.
2334  *
2335  * @return
2336  *   0 on success, a negative errno value otherwise and rte_errno is set.
2337  */
2338 int
2339 rte_flow_flush(uint16_t port_id,
2340                struct rte_flow_error *error);
2341
2342 /**
2343  * Query an existing flow rule.
2344  *
2345  * This function allows retrieving flow-specific data such as counters.
2346  * Data is gathered by special actions which must be present in the flow
2347  * rule definition.
2348  *
2349  * \see RTE_FLOW_ACTION_TYPE_COUNT
2350  *
2351  * @param port_id
2352  *   Port identifier of Ethernet device.
2353  * @param flow
2354  *   Flow rule handle to query.
2355  * @param action
2356  *   Action definition as defined in original flow rule.
2357  * @param[in, out] data
2358  *   Pointer to storage for the associated query data type.
2359  * @param[out] error
2360  *   Perform verbose error reporting if not NULL. PMDs initialize this
2361  *   structure in case of error only.
2362  *
2363  * @return
2364  *   0 on success, a negative errno value otherwise and rte_errno is set.
2365  */
2366 int
2367 rte_flow_query(uint16_t port_id,
2368                struct rte_flow *flow,
2369                const struct rte_flow_action *action,
2370                void *data,
2371                struct rte_flow_error *error);
2372
2373 /**
2374  * Restrict ingress traffic to the defined flow rules.
2375  *
2376  * Isolated mode guarantees that all ingress traffic comes from defined flow
2377  * rules only (current and future).
2378  *
2379  * Besides making ingress more deterministic, it allows PMDs to safely reuse
2380  * resources otherwise assigned to handle the remaining traffic, such as
2381  * global RSS configuration settings, VLAN filters, MAC address entries,
2382  * legacy filter API rules and so on in order to expand the set of possible
2383  * flow rule types.
2384  *
2385  * Calling this function as soon as possible after device initialization,
2386  * ideally before the first call to rte_eth_dev_configure(), is recommended
2387  * to avoid possible failures due to conflicting settings.
2388  *
2389  * Once effective, leaving isolated mode may not be possible depending on
2390  * PMD implementation.
2391  *
2392  * Additionally, the following functionality has no effect on the underlying
2393  * port and may return errors such as ENOTSUP ("not supported"):
2394  *
2395  * - Toggling promiscuous mode.
2396  * - Toggling allmulticast mode.
2397  * - Configuring MAC addresses.
2398  * - Configuring multicast addresses.
2399  * - Configuring VLAN filters.
2400  * - Configuring Rx filters through the legacy API (e.g. FDIR).
2401  * - Configuring global RSS settings.
2402  *
2403  * @param port_id
2404  *   Port identifier of Ethernet device.
2405  * @param set
2406  *   Nonzero to enter isolated mode, attempt to leave it otherwise.
2407  * @param[out] error
2408  *   Perform verbose error reporting if not NULL. PMDs initialize this
2409  *   structure in case of error only.
2410  *
2411  * @return
2412  *   0 on success, a negative errno value otherwise and rte_errno is set.
2413  */
2414 int
2415 rte_flow_isolate(uint16_t port_id, int set, struct rte_flow_error *error);
2416
2417 /**
2418  * Initialize flow error structure.
2419  *
2420  * @param[out] error
2421  *   Pointer to flow error structure (may be NULL).
2422  * @param code
2423  *   Related error code (rte_errno).
2424  * @param type
2425  *   Cause field and error types.
2426  * @param cause
2427  *   Object responsible for the error.
2428  * @param message
2429  *   Human-readable error message.
2430  *
2431  * @return
2432  *   Negative error code (errno value) and rte_errno is set.
2433  */
2434 int
2435 rte_flow_error_set(struct rte_flow_error *error,
2436                    int code,
2437                    enum rte_flow_error_type type,
2438                    const void *cause,
2439                    const char *message);
2440
2441 /**
2442  * @deprecated
2443  * @see rte_flow_copy()
2444  */
2445 struct rte_flow_desc {
2446         size_t size; /**< Allocated space including data[]. */
2447         struct rte_flow_attr attr; /**< Attributes. */
2448         struct rte_flow_item *items; /**< Items. */
2449         struct rte_flow_action *actions; /**< Actions. */
2450         uint8_t data[]; /**< Storage for items/actions. */
2451 };
2452
2453 /**
2454  * @deprecated
2455  * Copy an rte_flow rule description.
2456  *
2457  * This interface is kept for compatibility with older applications but is
2458  * implemented as a wrapper to rte_flow_conv(). It is deprecated due to its
2459  * lack of flexibility and reliance on a type unusable with C++ programs
2460  * (struct rte_flow_desc).
2461  *
2462  * @param[in] fd
2463  *   Flow rule description.
2464  * @param[in] len
2465  *   Total size of allocated data for the flow description.
2466  * @param[in] attr
2467  *   Flow rule attributes.
2468  * @param[in] items
2469  *   Pattern specification (list terminated by the END pattern item).
2470  * @param[in] actions
2471  *   Associated actions (list terminated by the END action).
2472  *
2473  * @return
2474  *   If len is greater or equal to the size of the flow, the total size of the
2475  *   flow description and its data.
2476  *   If len is lower than the size of the flow, the number of bytes that would
2477  *   have been written to desc had it been sufficient. Nothing is written.
2478  */
2479 __rte_deprecated
2480 size_t
2481 rte_flow_copy(struct rte_flow_desc *fd, size_t len,
2482               const struct rte_flow_attr *attr,
2483               const struct rte_flow_item *items,
2484               const struct rte_flow_action *actions);
2485
2486 /**
2487  * Flow object conversion helper.
2488  *
2489  * This function performs conversion of various flow API objects to a
2490  * pre-allocated destination buffer. See enum rte_flow_conv_op for possible
2491  * operations and details about each of them.
2492  *
2493  * Since destination buffer must be large enough, it works in a manner
2494  * reminiscent of snprintf():
2495  *
2496  * - If @p size is 0, @p dst may be a NULL pointer, otherwise @p dst must be
2497  *   non-NULL.
2498  * - If positive, the returned value represents the number of bytes needed
2499  *   to store the conversion of @p src to @p dst according to @p op
2500  *   regardless of the @p size parameter.
2501  * - Since no more than @p size bytes can be written to @p dst, output is
2502  *   truncated and may be inconsistent when the returned value is larger
2503  *   than that.
2504  * - In case of conversion error, a negative error code is returned and
2505  *   @p dst contents are unspecified.
2506  *
2507  * @param op
2508  *   Operation to perform, related to the object type of @p dst.
2509  * @param[out] dst
2510  *   Destination buffer address. Must be suitably aligned by the caller.
2511  * @param size
2512  *   Destination buffer size in bytes.
2513  * @param[in] src
2514  *   Source object to copy. Depending on @p op, its type may differ from
2515  *   that of @p dst.
2516  * @param[out] error
2517  *   Perform verbose error reporting if not NULL. Initialized in case of
2518  *   error only.
2519  *
2520  * @return
2521  *   The number of bytes required to convert @p src to @p dst on success, a
2522  *   negative errno value otherwise and rte_errno is set.
2523  *
2524  * @see rte_flow_conv_op
2525  */
2526 __rte_experimental
2527 int
2528 rte_flow_conv(enum rte_flow_conv_op op,
2529               void *dst,
2530               size_t size,
2531               const void *src,
2532               struct rte_flow_error *error);
2533
2534 #ifdef __cplusplus
2535 }
2536 #endif
2537
2538 #endif /* RTE_FLOW_H_ */