rte_flow.h

Go to the documentation of this file.

/* SPDX-License-Identifier: BSD-3-Clause
 * Copyright 2016 6WIND S.A.
 * Copyright 2016 Mellanox Technologies, Ltd
 */
 
#ifndef RTE_FLOW_H_
#define RTE_FLOW_H_
 
#include <stddef.h>
#include <stdint.h>
 
#include <rte_compat.h>
#include <rte_common.h>
#include <rte_ether.h>
#include <rte_icmp.h>
#include <rte_ip.h>
#include <rte_sctp.h>
#include <rte_tcp.h>
#include <rte_udp.h>
#include <rte_vxlan.h>
#include <rte_esp.h>
#include <rte_higig.h>
#include <rte_ecpri.h>
#include <rte_bitops.h>
#include <rte_mbuf_dyn.h>
#include <rte_meter.h>
#include <rte_gtp.h>
#include <rte_l2tpv2.h>
#include <rte_ppp.h>
#include <rte_gre.h>
#include <rte_macsec.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
#define RTE_FLOW_LOG(level, ...) \
    rte_log(RTE_LOG_ ## level, rte_eth_dev_logtype, "" __VA_ARGS__)
 
struct rte_flow_attr {
    uint32_t group; 
    uint32_t priority; 
    uint32_t ingress:1;
    uint32_t egress:1;
    uint32_t transfer:1;
    uint32_t reserved:29; 
};
 
enum rte_flow_item_type {
    RTE_FLOW_ITEM_TYPE_END,
 
    RTE_FLOW_ITEM_TYPE_VOID,
 
    RTE_FLOW_ITEM_TYPE_INVERT,
 
    RTE_FLOW_ITEM_TYPE_ANY,
 
    RTE_FLOW_ITEM_TYPE_PORT_ID,
 
    RTE_FLOW_ITEM_TYPE_RAW,
 
    RTE_FLOW_ITEM_TYPE_ETH,
 
    RTE_FLOW_ITEM_TYPE_VLAN,
 
    RTE_FLOW_ITEM_TYPE_IPV4,
 
    RTE_FLOW_ITEM_TYPE_IPV6,
 
    RTE_FLOW_ITEM_TYPE_ICMP,
 
    RTE_FLOW_ITEM_TYPE_UDP,
 
    RTE_FLOW_ITEM_TYPE_TCP,
 
    RTE_FLOW_ITEM_TYPE_SCTP,
 
    RTE_FLOW_ITEM_TYPE_VXLAN,
 
    RTE_FLOW_ITEM_TYPE_E_TAG,
 
    RTE_FLOW_ITEM_TYPE_NVGRE,
 
    RTE_FLOW_ITEM_TYPE_MPLS,
 
    RTE_FLOW_ITEM_TYPE_GRE,
 
    RTE_FLOW_ITEM_TYPE_FUZZY,
 
    RTE_FLOW_ITEM_TYPE_GTP,
 
    RTE_FLOW_ITEM_TYPE_GTPC,
 
    RTE_FLOW_ITEM_TYPE_GTPU,
 
    RTE_FLOW_ITEM_TYPE_ESP,
 
    RTE_FLOW_ITEM_TYPE_GENEVE,
 
    RTE_FLOW_ITEM_TYPE_VXLAN_GPE,
 
    RTE_FLOW_ITEM_TYPE_ARP_ETH_IPV4,
 
    RTE_FLOW_ITEM_TYPE_IPV6_EXT,
 
    RTE_FLOW_ITEM_TYPE_ICMP6,
 
    RTE_FLOW_ITEM_TYPE_ICMP6_ND_NS,
 
    RTE_FLOW_ITEM_TYPE_ICMP6_ND_NA,
 
    RTE_FLOW_ITEM_TYPE_ICMP6_ND_OPT,
 
    RTE_FLOW_ITEM_TYPE_ICMP6_ND_OPT_SLA_ETH,
 
    RTE_FLOW_ITEM_TYPE_ICMP6_ND_OPT_TLA_ETH,
 
    RTE_FLOW_ITEM_TYPE_MARK,
 
    RTE_FLOW_ITEM_TYPE_META,
 
    RTE_FLOW_ITEM_TYPE_GRE_KEY,
 
    RTE_FLOW_ITEM_TYPE_GTP_PSC,
 
    RTE_FLOW_ITEM_TYPE_PPPOES,
 
    RTE_FLOW_ITEM_TYPE_PPPOED,
 
    RTE_FLOW_ITEM_TYPE_PPPOE_PROTO_ID,
 
    RTE_FLOW_ITEM_TYPE_NSH,
 
    RTE_FLOW_ITEM_TYPE_IGMP,
 
    RTE_FLOW_ITEM_TYPE_AH,
 
    RTE_FLOW_ITEM_TYPE_HIGIG2,
 
    RTE_FLOW_ITEM_TYPE_TAG,
 
    RTE_FLOW_ITEM_TYPE_L2TPV3OIP,
 
    RTE_FLOW_ITEM_TYPE_PFCP,
 
    RTE_FLOW_ITEM_TYPE_ECPRI,
 
    RTE_FLOW_ITEM_TYPE_IPV6_FRAG_EXT,
 
    RTE_FLOW_ITEM_TYPE_GENEVE_OPT,
 
    RTE_FLOW_ITEM_TYPE_INTEGRITY,
 
    RTE_FLOW_ITEM_TYPE_CONNTRACK,
 
    RTE_FLOW_ITEM_TYPE_PORT_REPRESENTOR,
 
    RTE_FLOW_ITEM_TYPE_REPRESENTED_PORT,
 
    RTE_FLOW_ITEM_TYPE_FLEX,
 
    RTE_FLOW_ITEM_TYPE_L2TPV2,
 
    RTE_FLOW_ITEM_TYPE_PPP,
 
    RTE_FLOW_ITEM_TYPE_GRE_OPTION,
 
    RTE_FLOW_ITEM_TYPE_MACSEC,
 
    RTE_FLOW_ITEM_TYPE_METER_COLOR,
};
 
RTE_STD_C11
struct rte_flow_item_higig2_hdr {
    struct rte_higig2_hdr hdr;
};
 
#ifndef __cplusplus
static const struct rte_flow_item_higig2_hdr rte_flow_item_higig2_hdr_mask = {
    .hdr = {
        .ppt1 = {
            .classification = 0xffff,
            .vid = 0xfff,
        },
    },
};
#endif
 
struct rte_flow_item_any {
    uint32_t num; 
};
 
#ifndef __cplusplus
static const struct rte_flow_item_any rte_flow_item_any_mask = {
    .num = 0x00000000,
};
#endif
 
struct rte_flow_item_port_id {
    uint32_t id; 
};
 
#ifndef __cplusplus
static const struct rte_flow_item_port_id rte_flow_item_port_id_mask = {
    .id = 0xffffffff,
};
#endif
 
struct rte_flow_item_raw {
    uint32_t relative:1; 
    uint32_t search:1; 
    uint32_t reserved:30; 
    int32_t offset; 
    uint16_t limit; 
    uint16_t length; 
    const uint8_t *pattern; 
};
 
#ifndef __cplusplus
static const struct rte_flow_item_raw rte_flow_item_raw_mask = {
    .relative = 1,
    .search = 1,
    .reserved = 0x3fffffff,
    .offset = 0xffffffff,
    .limit = 0xffff,
    .length = 0xffff,
    .pattern = NULL,
};
#endif
 
RTE_STD_C11
struct rte_flow_item_eth {
    union {
        struct {
            /*
             * These fields are retained for compatibility.
             * Please switch to the new header field below.
             */
            struct rte_ether_addr dst; 
            struct rte_ether_addr src; 
            rte_be16_t type; 
        };
        struct rte_ether_hdr hdr;
    };
    uint32_t has_vlan:1; 
    uint32_t reserved:31; 
};
 
#ifndef __cplusplus
static const struct rte_flow_item_eth rte_flow_item_eth_mask = {
    .hdr.dst_addr.addr_bytes = "\xff\xff\xff\xff\xff\xff",
    .hdr.src_addr.addr_bytes = "\xff\xff\xff\xff\xff\xff",
    .hdr.ether_type = RTE_BE16(0x0000),
};
#endif
 
RTE_STD_C11
struct rte_flow_item_vlan {
    union {
        struct {
            /*
             * These fields are retained for compatibility.
             * Please switch to the new header field below.
             */
            rte_be16_t tci; 
            rte_be16_t inner_type; 
        };
        struct rte_vlan_hdr hdr;
    };
    uint32_t has_more_vlan:1;
    uint32_t reserved:31; 
};
 
#ifndef __cplusplus
static const struct rte_flow_item_vlan rte_flow_item_vlan_mask = {
    .hdr.vlan_tci = RTE_BE16(0x0fff),
    .hdr.eth_proto = RTE_BE16(0x0000),
};
#endif
 
struct rte_flow_item_ipv4 {
    struct rte_ipv4_hdr hdr; 
};
 
#ifndef __cplusplus
static const struct rte_flow_item_ipv4 rte_flow_item_ipv4_mask = {
    .hdr = {
        .src_addr = RTE_BE32(0xffffffff),
        .dst_addr = RTE_BE32(0xffffffff),
    },
};
#endif
 
struct rte_flow_item_ipv6 {
    struct rte_ipv6_hdr hdr; 
    uint32_t has_hop_ext:1;
    uint32_t has_route_ext:1;
    uint32_t has_frag_ext:1;
    uint32_t has_auth_ext:1;
    uint32_t has_esp_ext:1;
    uint32_t has_dest_ext:1;
    uint32_t has_mobil_ext:1;
    uint32_t has_hip_ext:1;
    uint32_t has_shim6_ext:1;
    uint32_t reserved:23;
};
 
#ifndef __cplusplus
static const struct rte_flow_item_ipv6 rte_flow_item_ipv6_mask = {
    .hdr = {
        .src_addr =
            "\xff\xff\xff\xff\xff\xff\xff\xff"
            "\xff\xff\xff\xff\xff\xff\xff\xff",
        .dst_addr =
            "\xff\xff\xff\xff\xff\xff\xff\xff"
            "\xff\xff\xff\xff\xff\xff\xff\xff",
    },
};
#endif
 
struct rte_flow_item_icmp {
    struct rte_icmp_hdr hdr; 
};
 
#ifndef __cplusplus
static const struct rte_flow_item_icmp rte_flow_item_icmp_mask = {
    .hdr = {
        .icmp_type = 0xff,
        .icmp_code = 0xff,
    },
};
#endif
 
struct rte_flow_item_udp {
    struct rte_udp_hdr hdr; 
};
 
#ifndef __cplusplus
static const struct rte_flow_item_udp rte_flow_item_udp_mask = {
    .hdr = {
        .src_port = RTE_BE16(0xffff),
        .dst_port = RTE_BE16(0xffff),
    },
};
#endif
 
struct rte_flow_item_tcp {
    struct rte_tcp_hdr hdr; 
};
 
#ifndef __cplusplus
static const struct rte_flow_item_tcp rte_flow_item_tcp_mask = {
    .hdr = {
        .src_port = RTE_BE16(0xffff),
        .dst_port = RTE_BE16(0xffff),
    },
};
#endif
 
struct rte_flow_item_sctp {
    struct rte_sctp_hdr hdr; 
};
 
#ifndef __cplusplus
static const struct rte_flow_item_sctp rte_flow_item_sctp_mask = {
    .hdr = {
        .src_port = RTE_BE16(0xffff),
        .dst_port = RTE_BE16(0xffff),
    },
};
#endif
 
RTE_STD_C11
struct rte_flow_item_vxlan {
    union {
        struct {
            /*
             * These fields are retained for compatibility.
             * Please switch to the new header field below.
             */
            uint8_t flags; 
            uint8_t rsvd0[3]; 
            uint8_t vni[3]; 
            uint8_t rsvd1; 
        };
        struct rte_vxlan_hdr hdr;
    };
};
 
#ifndef __cplusplus
static const struct rte_flow_item_vxlan rte_flow_item_vxlan_mask = {
    .hdr.vx_vni = RTE_BE32(0xffffff00), /* (0xffffff << 8) */
};
#endif
 
struct rte_flow_item_e_tag {
    rte_be16_t epcp_edei_in_ecid_b;
    rte_be16_t rsvd_grp_ecid_b;
    uint8_t in_ecid_e; 
    uint8_t ecid_e; 
    rte_be16_t inner_type; 
};
 
#ifndef __cplusplus
static const struct rte_flow_item_e_tag rte_flow_item_e_tag_mask = {
    .rsvd_grp_ecid_b = RTE_BE16(0x3fff),
};
#endif
 
struct rte_flow_item_nvgre {
    rte_be16_t c_k_s_rsvd0_ver;
    rte_be16_t protocol; 
    uint8_t tni[3]; 
    uint8_t flow_id; 
};
 
#ifndef __cplusplus
static const struct rte_flow_item_nvgre rte_flow_item_nvgre_mask = {
    .tni = "\xff\xff\xff",
};
#endif
 
struct rte_flow_item_mpls {
    uint8_t label_tc_s[3];
    uint8_t ttl; 
};
 
#ifndef __cplusplus
static const struct rte_flow_item_mpls rte_flow_item_mpls_mask = {
    .label_tc_s = "\xff\xff\xf0",
};
#endif
 
struct rte_flow_item_gre {
    rte_be16_t c_rsvd0_ver;
    rte_be16_t protocol; 
};
 
#ifndef __cplusplus
static const struct rte_flow_item_gre rte_flow_item_gre_mask = {
    .protocol = RTE_BE16(0xffff),
};
#endif
 
struct rte_flow_item_gre_opt {
    struct rte_gre_hdr_opt_checksum_rsvd checksum_rsvd;
    struct rte_gre_hdr_opt_key key;
    struct rte_gre_hdr_opt_sequence sequence;
};
 
struct rte_flow_item_macsec {
    struct rte_macsec_hdr macsec_hdr;
};
 
struct rte_flow_item_fuzzy {
    uint32_t thresh; 
};
 
#ifndef __cplusplus
static const struct rte_flow_item_fuzzy rte_flow_item_fuzzy_mask = {
    .thresh = 0xffffffff,
};
#endif
 
struct rte_flow_item_gtp {
    uint8_t v_pt_rsv_flags;
    uint8_t msg_type; 
    rte_be16_t msg_len; 
    rte_be32_t teid; 
};
 
#ifndef __cplusplus
static const struct rte_flow_item_gtp rte_flow_item_gtp_mask = {
    .teid = RTE_BE32(0xffffffff),
};
#endif
 
struct rte_flow_item_esp {
    struct rte_esp_hdr hdr; 
};
 
#ifndef __cplusplus
static const struct rte_flow_item_esp rte_flow_item_esp_mask = {
    .hdr = {
        .spi = RTE_BE32(0xffffffff),
    },
};
#endif
 
struct rte_flow_item_geneve {
    rte_be16_t ver_opt_len_o_c_rsvd0;
    rte_be16_t protocol; 
    uint8_t vni[3]; 
    uint8_t rsvd1; 
};
 
#ifndef __cplusplus
static const struct rte_flow_item_geneve rte_flow_item_geneve_mask = {
    .vni = "\xff\xff\xff",
};
#endif
 
struct rte_flow_item_vxlan_gpe {
    uint8_t flags; 
    uint8_t rsvd0[2]; 
    uint8_t protocol; 
    uint8_t vni[3]; 
    uint8_t rsvd1; 
};
 
#ifndef __cplusplus
static const struct rte_flow_item_vxlan_gpe rte_flow_item_vxlan_gpe_mask = {
    .vni = "\xff\xff\xff",
};
#endif
 
struct rte_flow_item_arp_eth_ipv4 {
    rte_be16_t hrd; 
    rte_be16_t pro; 
    uint8_t hln; 
    uint8_t pln; 
    rte_be16_t op; 
    struct rte_ether_addr sha; 
    rte_be32_t spa; 
    struct rte_ether_addr tha; 
    rte_be32_t tpa; 
};
 
#ifndef __cplusplus
static const struct rte_flow_item_arp_eth_ipv4
rte_flow_item_arp_eth_ipv4_mask = {
    .sha.addr_bytes = "\xff\xff\xff\xff\xff\xff",
    .spa = RTE_BE32(0xffffffff),
    .tha.addr_bytes = "\xff\xff\xff\xff\xff\xff",
    .tpa = RTE_BE32(0xffffffff),
};
#endif
 
struct rte_flow_item_ipv6_ext {
    uint8_t next_hdr; 
};
 
#ifndef __cplusplus
static const
struct rte_flow_item_ipv6_ext rte_flow_item_ipv6_ext_mask = {
    .next_hdr = 0xff,
};
#endif
 
struct rte_flow_item_ipv6_frag_ext {
    struct rte_ipv6_fragment_ext hdr;
};
 
struct rte_flow_item_icmp6 {
    uint8_t type; 
    uint8_t code; 
    uint16_t checksum; 
};
 
#ifndef __cplusplus
static const struct rte_flow_item_icmp6 rte_flow_item_icmp6_mask = {
    .type = 0xff,
    .code = 0xff,
};
#endif
 
struct rte_flow_item_icmp6_nd_ns {
    uint8_t type; 
    uint8_t code; 
    rte_be16_t checksum; 
    rte_be32_t reserved; 
    uint8_t target_addr[16]; 
};
 
#ifndef __cplusplus
static const
struct rte_flow_item_icmp6_nd_ns rte_flow_item_icmp6_nd_ns_mask = {
    .target_addr =
        "\xff\xff\xff\xff\xff\xff\xff\xff"
        "\xff\xff\xff\xff\xff\xff\xff\xff",
};
#endif
 
struct rte_flow_item_icmp6_nd_na {
    uint8_t type; 
    uint8_t code; 
    rte_be16_t checksum; 
    rte_be32_t rso_reserved;
    uint8_t target_addr[16]; 
};
 
#ifndef __cplusplus
static const
struct rte_flow_item_icmp6_nd_na rte_flow_item_icmp6_nd_na_mask = {
    .target_addr =
        "\xff\xff\xff\xff\xff\xff\xff\xff"
        "\xff\xff\xff\xff\xff\xff\xff\xff",
};
#endif
 
struct rte_flow_item_icmp6_nd_opt {
    uint8_t type; 
    uint8_t length; 
};
 
#ifndef __cplusplus
static const struct rte_flow_item_icmp6_nd_opt
rte_flow_item_icmp6_nd_opt_mask = {
    .type = 0xff,
};
#endif
 
struct rte_flow_item_icmp6_nd_opt_sla_eth {
    uint8_t type; 
    uint8_t length; 
    struct rte_ether_addr sla; 
};
 
#ifndef __cplusplus
static const struct rte_flow_item_icmp6_nd_opt_sla_eth
rte_flow_item_icmp6_nd_opt_sla_eth_mask = {
    .sla.addr_bytes = "\xff\xff\xff\xff\xff\xff",
};
#endif
 
struct rte_flow_item_icmp6_nd_opt_tla_eth {
    uint8_t type; 
    uint8_t length; 
    struct rte_ether_addr tla; 
};
 
#ifndef __cplusplus
static const struct rte_flow_item_icmp6_nd_opt_tla_eth
rte_flow_item_icmp6_nd_opt_tla_eth_mask = {
    .tla.addr_bytes = "\xff\xff\xff\xff\xff\xff",
};
#endif
 
struct rte_flow_item_meta {
    uint32_t data;
};
 
#ifndef __cplusplus
static const struct rte_flow_item_meta rte_flow_item_meta_mask = {
    .data = UINT32_MAX,
};
#endif
 
struct rte_flow_item_gtp_psc {
    struct rte_gtp_psc_generic_hdr hdr; 
};
 
#ifndef __cplusplus
static const struct rte_flow_item_gtp_psc
rte_flow_item_gtp_psc_mask = {
    .hdr.qfi = 0x3f,
};
#endif
 
struct rte_flow_item_pppoe {
    uint8_t version_type;
    uint8_t code; 
    rte_be16_t session_id; 
    rte_be16_t length; 
};
 
struct rte_flow_item_pppoe_proto_id {
    rte_be16_t proto_id; 
};
 
#ifndef __cplusplus
static const struct rte_flow_item_pppoe_proto_id
rte_flow_item_pppoe_proto_id_mask = {
    .proto_id = RTE_BE16(0xffff),
};
#endif
 
struct rte_flow_item_tag {
    uint32_t data;
    uint8_t index;
};
 
#ifndef __cplusplus
static const struct rte_flow_item_tag rte_flow_item_tag_mask = {
    .data = 0xffffffff,
    .index = 0xff,
};
#endif
 
struct rte_flow_item_l2tpv3oip {
    rte_be32_t session_id; 
};
 
#ifndef __cplusplus
static const struct rte_flow_item_l2tpv3oip rte_flow_item_l2tpv3oip_mask = {
    .session_id = RTE_BE32(UINT32_MAX),
};
#endif
 
 
struct rte_flow_item_mark {
    uint32_t id; 
};
 
#ifndef __cplusplus
static const struct rte_flow_item_mark rte_flow_item_mark_mask = {
    .id = 0xffffffff,
};
#endif
 
struct rte_flow_item_nsh {
    uint32_t version:2;
    uint32_t oam_pkt:1;
    uint32_t reserved:1;
    uint32_t ttl:6;
    uint32_t length:6;
    uint32_t reserved1:4;
    uint32_t mdtype:4;
    uint32_t next_proto:8;
    uint32_t spi:24;
    uint32_t sindex:8;
};
 
#ifndef __cplusplus
static const struct rte_flow_item_nsh rte_flow_item_nsh_mask = {
    .mdtype = 0xf,
    .next_proto = 0xff,
    .spi = 0xffffff,
    .sindex = 0xff,
};
#endif
 
struct rte_flow_item_igmp {
    uint32_t type:8;
    uint32_t max_resp_time:8;
    uint32_t checksum:16;
    uint32_t group_addr;
};
 
#ifndef __cplusplus
static const struct rte_flow_item_igmp rte_flow_item_igmp_mask = {
    .group_addr = 0xffffffff,
};
#endif
 
struct rte_flow_item_ah {
    uint32_t next_hdr:8;
    uint32_t payload_len:8;
    uint32_t reserved:16;
    uint32_t spi;
    uint32_t seq_num;
};
 
#ifndef __cplusplus
static const struct rte_flow_item_ah rte_flow_item_ah_mask = {
    .spi = 0xffffffff,
};
#endif
 
struct rte_flow_item_pfcp {
    uint8_t s_field;
    uint8_t msg_type;
    rte_be16_t msg_len;
    rte_be64_t seid;
};
 
#ifndef __cplusplus
static const struct rte_flow_item_pfcp rte_flow_item_pfcp_mask = {
    .s_field = 0x01,
    .seid = RTE_BE64(UINT64_C(0xffffffffffffffff)),
};
#endif
 
struct rte_flow_item_ecpri {
    struct rte_ecpri_combined_msg_hdr hdr;
};
 
#ifndef __cplusplus
static const struct rte_flow_item_ecpri rte_flow_item_ecpri_mask = {
    .hdr = {
        .common = {
            .u32 = 0x0,
        },
    },
};
#endif
 
struct rte_flow_item_geneve_opt {
    rte_be16_t option_class;
    uint8_t option_type;
    uint8_t option_len;
    uint32_t *data;
};
 
#ifndef __cplusplus
static const struct rte_flow_item_geneve_opt
rte_flow_item_geneve_opt_mask = {
    .option_type = 0xff,
};
#endif
 
struct rte_flow_item_integrity {
    uint32_t level;
    RTE_STD_C11
    union {
        __extension__
        struct {
            uint64_t packet_ok:1;
            uint64_t l2_ok:1;
            uint64_t l3_ok:1;
            uint64_t l4_ok:1;
            uint64_t l2_crc_ok:1;
            uint64_t ipv4_csum_ok:1;
            uint64_t l4_csum_ok:1;
            uint64_t l3_len_ok:1;
            uint64_t reserved:56;
        };
        uint64_t value;
    };
};
 
#ifndef __cplusplus
static const struct rte_flow_item_integrity
rte_flow_item_integrity_mask = {
    .level = 0,
    .value = 0,
};
#endif
 
#define RTE_FLOW_CONNTRACK_PKT_STATE_VALID RTE_BIT32(0)
 
#define RTE_FLOW_CONNTRACK_PKT_STATE_CHANGED RTE_BIT32(1)
 
#define RTE_FLOW_CONNTRACK_PKT_STATE_INVALID RTE_BIT32(2)
 
#define RTE_FLOW_CONNTRACK_PKT_STATE_DISABLED RTE_BIT32(3)
 
#define RTE_FLOW_CONNTRACK_PKT_STATE_BAD RTE_BIT32(4)
 
struct rte_flow_item_conntrack {
    uint32_t flags;
};
 
#ifndef __cplusplus
static const struct rte_flow_item_conntrack rte_flow_item_conntrack_mask = {
    .flags = 0xffffffff,
};
#endif
 
struct rte_flow_item_ethdev {
    uint16_t port_id; 
};
 
#ifndef __cplusplus
static const struct rte_flow_item_ethdev rte_flow_item_ethdev_mask = {
    .port_id = 0xffff,
};
#endif
 
struct rte_flow_item_l2tpv2 {
    struct rte_l2tpv2_combined_msg_hdr hdr;
};
 
#ifndef __cplusplus
static const struct rte_flow_item_l2tpv2 rte_flow_item_l2tpv2_mask = {
    /*
     * flags and version bit mask
     * 7 6 5 4 3 2 1 0 7 6 5 4 3 2 1 0
     * T L x x S x O P x x x x V V V V
     */
    .hdr = {
        .common = {
            .flags_version = RTE_BE16(0xcb0f),
        },
    },
};
#endif
 
struct rte_flow_item_ppp {
    struct rte_ppp_hdr hdr;
};
 
#ifndef __cplusplus
static const struct rte_flow_item_ppp rte_flow_item_ppp_mask = {
    .hdr = {
        .addr = 0xff,
        .ctrl = 0xff,
        .proto_id = RTE_BE16(0xffff),
    }
};
#endif
 
struct rte_flow_item {
    enum rte_flow_item_type type; 
    const void *spec; 
    const void *last; 
    const void *mask; 
};
 
struct rte_flow_item_flex {
    struct rte_flow_item_flex_handle *handle; 
    uint32_t length; 
    const uint8_t *pattern; 
};
enum rte_flow_item_flex_field_mode {
    FIELD_MODE_DUMMY = 0,
    FIELD_MODE_FIXED,
    FIELD_MODE_OFFSET,
    FIELD_MODE_BITMASK,
};
 
enum rte_flow_item_flex_tunnel_mode {
    FLEX_TUNNEL_MODE_SINGLE = 0,
    FLEX_TUNNEL_MODE_OUTER,
    FLEX_TUNNEL_MODE_INNER,
    FLEX_TUNNEL_MODE_MULTI,
    FLEX_TUNNEL_MODE_TUNNEL,
};
 
__extension__
struct rte_flow_item_flex_field {
    enum rte_flow_item_flex_field_mode field_mode;
    uint32_t field_size; 
    int32_t field_base; 
    uint32_t offset_base; 
    uint32_t offset_mask; 
    int32_t offset_shift; 
    uint32_t field_id:16; 
    uint32_t reserved:16; 
};
 
struct rte_flow_item_flex_link {
    struct rte_flow_item item;
    uint32_t next;
};
 
struct rte_flow_item_flex_conf {
    enum rte_flow_item_flex_tunnel_mode tunnel;
    struct rte_flow_item_flex_field next_header;
    struct rte_flow_item_flex_field next_protocol;
    struct rte_flow_item_flex_field *sample_data;
    uint32_t nb_samples;
    struct rte_flow_item_flex_link *input_link;
    uint32_t nb_inputs;
    struct rte_flow_item_flex_link *output_link;
    uint32_t nb_outputs;
};
 
struct rte_flow_item_meter_color {
    enum rte_color color; 
};
 
#ifndef __cplusplus
static const struct rte_flow_item_meter_color rte_flow_item_meter_color_mask = {
    .color = RTE_COLORS,
};
#endif
 
enum rte_flow_action_type {
    RTE_FLOW_ACTION_TYPE_END,
 
    RTE_FLOW_ACTION_TYPE_VOID,
 
    RTE_FLOW_ACTION_TYPE_PASSTHRU,
 
    RTE_FLOW_ACTION_TYPE_JUMP,
 
    RTE_FLOW_ACTION_TYPE_MARK,
 
    RTE_FLOW_ACTION_TYPE_FLAG,
 
    RTE_FLOW_ACTION_TYPE_QUEUE,
 
    RTE_FLOW_ACTION_TYPE_DROP,
 
    RTE_FLOW_ACTION_TYPE_COUNT,
 
    RTE_FLOW_ACTION_TYPE_RSS,
 
    RTE_FLOW_ACTION_TYPE_PF,
 
    RTE_FLOW_ACTION_TYPE_VF,
 
    RTE_FLOW_ACTION_TYPE_PORT_ID,
 
    RTE_FLOW_ACTION_TYPE_METER,
 
    RTE_FLOW_ACTION_TYPE_SECURITY,
 
    RTE_FLOW_ACTION_TYPE_OF_DEC_NW_TTL,
 
    RTE_FLOW_ACTION_TYPE_OF_POP_VLAN,
 
    RTE_FLOW_ACTION_TYPE_OF_PUSH_VLAN,
 
    RTE_FLOW_ACTION_TYPE_OF_SET_VLAN_VID,
 
    RTE_FLOW_ACTION_TYPE_OF_SET_VLAN_PCP,
 
    RTE_FLOW_ACTION_TYPE_OF_POP_MPLS,
 
    RTE_FLOW_ACTION_TYPE_OF_PUSH_MPLS,
 
    RTE_FLOW_ACTION_TYPE_VXLAN_ENCAP,
 
    RTE_FLOW_ACTION_TYPE_VXLAN_DECAP,
 
    RTE_FLOW_ACTION_TYPE_NVGRE_ENCAP,
 
    RTE_FLOW_ACTION_TYPE_NVGRE_DECAP,
 
    RTE_FLOW_ACTION_TYPE_RAW_ENCAP,
 
    RTE_FLOW_ACTION_TYPE_RAW_DECAP,
 
    RTE_FLOW_ACTION_TYPE_SET_IPV4_SRC,
 
    RTE_FLOW_ACTION_TYPE_SET_IPV4_DST,
 
    RTE_FLOW_ACTION_TYPE_SET_IPV6_SRC,
 
    RTE_FLOW_ACTION_TYPE_SET_IPV6_DST,
 
    RTE_FLOW_ACTION_TYPE_SET_TP_SRC,
 
    RTE_FLOW_ACTION_TYPE_SET_TP_DST,
 
    RTE_FLOW_ACTION_TYPE_MAC_SWAP,
 
    RTE_FLOW_ACTION_TYPE_DEC_TTL,
 
    RTE_FLOW_ACTION_TYPE_SET_TTL,
 
    RTE_FLOW_ACTION_TYPE_SET_MAC_SRC,
 
    RTE_FLOW_ACTION_TYPE_SET_MAC_DST,
 
    RTE_FLOW_ACTION_TYPE_INC_TCP_SEQ,
 
    RTE_FLOW_ACTION_TYPE_DEC_TCP_SEQ,
 
    RTE_FLOW_ACTION_TYPE_INC_TCP_ACK,
 
    RTE_FLOW_ACTION_TYPE_DEC_TCP_ACK,
 
    RTE_FLOW_ACTION_TYPE_SET_TAG,
 
    RTE_FLOW_ACTION_TYPE_SET_META,
 
    RTE_FLOW_ACTION_TYPE_SET_IPV4_DSCP,
 
    RTE_FLOW_ACTION_TYPE_SET_IPV6_DSCP,
 
    RTE_FLOW_ACTION_TYPE_AGE,
 
    RTE_FLOW_ACTION_TYPE_SAMPLE,
 
    RTE_FLOW_ACTION_TYPE_SHARED,
 
    RTE_FLOW_ACTION_TYPE_MODIFY_FIELD,
 
    RTE_FLOW_ACTION_TYPE_INDIRECT,
 
    RTE_FLOW_ACTION_TYPE_CONNTRACK,
 
    RTE_FLOW_ACTION_TYPE_METER_COLOR,
 
    RTE_FLOW_ACTION_TYPE_PORT_REPRESENTOR,
 
    RTE_FLOW_ACTION_TYPE_REPRESENTED_PORT,
 
    RTE_FLOW_ACTION_TYPE_METER_MARK,
 
    RTE_FLOW_ACTION_TYPE_SEND_TO_KERNEL,
};
 
struct rte_flow_action_mark {
    uint32_t id; 
};
 
struct rte_flow_action_jump {
    uint32_t group;
};
 
struct rte_flow_action_queue {
    uint16_t index; 
};
 
struct rte_flow_action_age {
    uint32_t timeout:24; 
    uint32_t reserved:8; 
    void *context;
};
 
struct rte_flow_query_age {
    uint32_t reserved:6; 
    uint32_t aged:1; 
    uint32_t sec_since_last_hit_valid:1;
    uint32_t sec_since_last_hit:24; 
};
 
struct rte_flow_update_age {
    uint32_t reserved:6; 
    uint32_t timeout_valid:1; 
    uint32_t timeout:24; 
    uint32_t touch:1;
};
 
struct rte_flow_action_count {
    uint32_t id; 
};
 
struct rte_flow_query_count {
    uint32_t reset:1; 
    uint32_t hits_set:1; 
    uint32_t bytes_set:1; 
    uint32_t reserved:29; 
    uint64_t hits; 
    uint64_t bytes; 
};
 
enum rte_eth_hash_function {
    RTE_ETH_HASH_FUNCTION_DEFAULT = 0,
    RTE_ETH_HASH_FUNCTION_TOEPLITZ, 
    RTE_ETH_HASH_FUNCTION_SIMPLE_XOR, 
    RTE_ETH_HASH_FUNCTION_SYMMETRIC_TOEPLITZ,
    RTE_ETH_HASH_FUNCTION_MAX,
};
 
struct rte_flow_action_rss {
    enum rte_eth_hash_function func; 
    uint32_t level;
    uint64_t types; 
    uint32_t key_len; 
    uint32_t queue_num; 
    const uint8_t *key; 
    const uint16_t *queue; 
};
 
struct rte_flow_action_vf {
    uint32_t original:1; 
    uint32_t reserved:31; 
    uint32_t id; 
};
 
struct rte_flow_action_port_id {
    uint32_t original:1; 
    uint32_t reserved:31; 
    uint32_t id; 
};
 
struct rte_flow_action_meter {
    uint32_t mtr_id; 
};
 
struct rte_flow_action_security {
    void *security_session; 
};
 
struct rte_flow_action_of_push_vlan {
    rte_be16_t ethertype; 
};
 
struct rte_flow_action_of_set_vlan_vid {
    rte_be16_t vlan_vid; 
};
 
struct rte_flow_action_of_set_vlan_pcp {
    uint8_t vlan_pcp; 
};
 
struct rte_flow_action_of_pop_mpls {
    rte_be16_t ethertype; 
};
 
struct rte_flow_action_of_push_mpls {
    rte_be16_t ethertype; 
};
 
struct rte_flow_action_vxlan_encap {
    struct rte_flow_item *definition;
};
 
struct rte_flow_action_nvgre_encap {
    struct rte_flow_item *definition;
};
 
struct rte_flow_action_raw_encap {
    uint8_t *data; 
    uint8_t *preserve; 
    size_t size; 
};
 
struct rte_flow_action_raw_decap {
    uint8_t *data; 
    size_t size; 
};
 
struct rte_flow_action_set_ipv4 {
    rte_be32_t ipv4_addr;
};
 
struct rte_flow_action_set_ipv6 {
    uint8_t ipv6_addr[16];
};
 
struct rte_flow_action_set_tp {
    rte_be16_t port;
};
 
struct rte_flow_action_set_ttl {
    uint8_t ttl_value;
};
 
struct rte_flow_action_set_mac {
    uint8_t mac_addr[RTE_ETHER_ADDR_LEN];
};
 
struct rte_flow_action_set_tag {
    uint32_t data;
    uint32_t mask;
    uint8_t index;
};
 
struct rte_flow_action_set_meta {
    uint32_t data;
    uint32_t mask;
};
 
struct rte_flow_action_set_dscp {
    uint8_t dscp;
};
 
struct rte_flow_action_handle;
 
enum rte_flow_conntrack_state {
    RTE_FLOW_CONNTRACK_STATE_SYN_RECV,
    RTE_FLOW_CONNTRACK_STATE_ESTABLISHED,
    RTE_FLOW_CONNTRACK_STATE_FIN_WAIT,
    RTE_FLOW_CONNTRACK_STATE_CLOSE_WAIT,
    RTE_FLOW_CONNTRACK_STATE_LAST_ACK,
    RTE_FLOW_CONNTRACK_STATE_TIME_WAIT,
};
 
enum rte_flow_conntrack_tcp_last_index {
    RTE_FLOW_CONNTRACK_FLAG_NONE = 0, 
    RTE_FLOW_CONNTRACK_FLAG_SYN = RTE_BIT32(0), 
    RTE_FLOW_CONNTRACK_FLAG_SYNACK = RTE_BIT32(1), 
    RTE_FLOW_CONNTRACK_FLAG_FIN = RTE_BIT32(2), 
    RTE_FLOW_CONNTRACK_FLAG_ACK = RTE_BIT32(3), 
    RTE_FLOW_CONNTRACK_FLAG_RST = RTE_BIT32(4), 
};
 
struct rte_flow_tcp_dir_param {
    uint32_t scale:4;
    uint32_t close_initiated:1;
    uint32_t last_ack_seen:1;
    uint32_t data_unacked:1;
    uint32_t sent_end;
    uint32_t reply_end;
    uint32_t max_win;
    uint32_t max_ack;
};
 
struct rte_flow_action_conntrack {
    uint16_t peer_port;
    uint32_t is_original_dir:1;
    uint32_t enable:1;
    uint32_t live_connection:1;
    uint32_t selective_ack:1;
    uint32_t challenge_ack_passed:1;
    uint32_t last_direction:1;
    uint32_t liberal_mode:1;
    enum rte_flow_conntrack_state state;
    uint8_t max_ack_window;
    uint8_t retransmission_limit;
    struct rte_flow_tcp_dir_param original_dir;
    struct rte_flow_tcp_dir_param reply_dir;
    uint16_t last_window;
    enum rte_flow_conntrack_tcp_last_index last_index;
    uint32_t last_seq;
    uint32_t last_ack;
    uint32_t last_end;
};
 
struct rte_flow_modify_conntrack {
    struct rte_flow_action_conntrack new_ct;
    uint32_t direction:1;
    uint32_t state:1;
    uint32_t reserved:30;
};
 
struct rte_flow_action_meter_color {
    enum rte_color color; 
};
 
struct rte_flow_action_ethdev {
    uint16_t port_id; 
};
 
enum rte_flow_field_id {
    RTE_FLOW_FIELD_START = 0,   
    RTE_FLOW_FIELD_MAC_DST,     
    RTE_FLOW_FIELD_MAC_SRC,     
    RTE_FLOW_FIELD_VLAN_TYPE,   
    RTE_FLOW_FIELD_VLAN_ID,     
    RTE_FLOW_FIELD_MAC_TYPE,    
    RTE_FLOW_FIELD_IPV4_DSCP,   
    RTE_FLOW_FIELD_IPV4_TTL,    
    RTE_FLOW_FIELD_IPV4_SRC,    
    RTE_FLOW_FIELD_IPV4_DST,    
    RTE_FLOW_FIELD_IPV6_DSCP,   
    RTE_FLOW_FIELD_IPV6_HOPLIMIT,   
    RTE_FLOW_FIELD_IPV6_SRC,    
    RTE_FLOW_FIELD_IPV6_DST,    
    RTE_FLOW_FIELD_TCP_PORT_SRC,    
    RTE_FLOW_FIELD_TCP_PORT_DST,    
    RTE_FLOW_FIELD_TCP_SEQ_NUM, 
    RTE_FLOW_FIELD_TCP_ACK_NUM, 
    RTE_FLOW_FIELD_TCP_FLAGS,   
    RTE_FLOW_FIELD_UDP_PORT_SRC,    
    RTE_FLOW_FIELD_UDP_PORT_DST,    
    RTE_FLOW_FIELD_VXLAN_VNI,   
    RTE_FLOW_FIELD_GENEVE_VNI,  
    RTE_FLOW_FIELD_GTP_TEID,    
    RTE_FLOW_FIELD_TAG,     
    RTE_FLOW_FIELD_MARK,        
    RTE_FLOW_FIELD_META,        
    RTE_FLOW_FIELD_POINTER,     
    RTE_FLOW_FIELD_VALUE,       
    RTE_FLOW_FIELD_IPV4_ECN,    
    RTE_FLOW_FIELD_IPV6_ECN,    
    RTE_FLOW_FIELD_GTP_PSC_QFI, 
    RTE_FLOW_FIELD_METER_COLOR, 
};
 
struct rte_flow_action_modify_data {
    enum rte_flow_field_id field; 
    RTE_STD_C11
    union {
        struct {
            uint32_t level;
            uint32_t offset;
        };
        uint8_t value[16];
        void *pvalue;
    };
};
 
enum rte_flow_modify_op {
    RTE_FLOW_MODIFY_SET = 0, 
    RTE_FLOW_MODIFY_ADD,     
    RTE_FLOW_MODIFY_SUB,     
};
 
struct rte_flow_action_modify_field {
    enum rte_flow_modify_op operation; 
    struct rte_flow_action_modify_data dst; 
    struct rte_flow_action_modify_data src; 
    uint32_t width; 
};
 
struct rte_flow_action_meter_mark {
 
    struct rte_flow_meter_profile *profile;
    struct rte_flow_meter_policy *policy;
    int color_mode;
    enum rte_color init_color;
    int state;
};
 
struct rte_flow_update_meter_mark {
    struct rte_flow_action_meter_mark meter_mark;
    uint32_t profile_valid:1;
    uint32_t policy_valid:1;
    uint32_t color_mode_valid:1;
    uint32_t init_color_valid:1;
    uint32_t state_valid:1;
    uint32_t reserved:27;
};
 
/* Mbuf dynamic field offset for metadata. */
extern int32_t rte_flow_dynf_metadata_offs;
 
/* Mbuf dynamic field flag mask for metadata. */
extern uint64_t rte_flow_dynf_metadata_mask;
 
/* Mbuf dynamic field pointer for metadata. */
#define RTE_FLOW_DYNF_METADATA(m) \
    RTE_MBUF_DYNFIELD((m), rte_flow_dynf_metadata_offs, uint32_t *)
 
/* Mbuf dynamic flags for metadata. */
#define RTE_MBUF_DYNFLAG_RX_METADATA (rte_flow_dynf_metadata_mask)
#define RTE_MBUF_DYNFLAG_TX_METADATA (rte_flow_dynf_metadata_mask)
 
__rte_experimental
static inline uint32_t
rte_flow_dynf_metadata_get(struct rte_mbuf *m)
{
    return *RTE_FLOW_DYNF_METADATA(m);
}
 
__rte_experimental
static inline void
rte_flow_dynf_metadata_set(struct rte_mbuf *m, uint32_t v)
{
    *RTE_FLOW_DYNF_METADATA(m) = v;
}
 
struct rte_flow_action {
    enum rte_flow_action_type type; 
    const void *conf; 
};
 
struct rte_flow;
 
struct rte_flow_meter_profile;
 
struct rte_flow_meter_policy;
 
struct rte_flow_action_sample {
    uint32_t ratio; 
    const struct rte_flow_action *actions;
};
 
enum rte_flow_error_type {
    RTE_FLOW_ERROR_TYPE_NONE, 
    RTE_FLOW_ERROR_TYPE_UNSPECIFIED, 
    RTE_FLOW_ERROR_TYPE_HANDLE, 
    RTE_FLOW_ERROR_TYPE_ATTR_GROUP, 
    RTE_FLOW_ERROR_TYPE_ATTR_PRIORITY, 
    RTE_FLOW_ERROR_TYPE_ATTR_INGRESS, 
    RTE_FLOW_ERROR_TYPE_ATTR_EGRESS, 
    RTE_FLOW_ERROR_TYPE_ATTR_TRANSFER, 
    RTE_FLOW_ERROR_TYPE_ATTR, 
    RTE_FLOW_ERROR_TYPE_ITEM_NUM, 
    RTE_FLOW_ERROR_TYPE_ITEM_SPEC, 
    RTE_FLOW_ERROR_TYPE_ITEM_LAST, 
    RTE_FLOW_ERROR_TYPE_ITEM_MASK, 
    RTE_FLOW_ERROR_TYPE_ITEM, 
    RTE_FLOW_ERROR_TYPE_ACTION_NUM, 
    RTE_FLOW_ERROR_TYPE_ACTION_CONF, 
    RTE_FLOW_ERROR_TYPE_ACTION, 
    RTE_FLOW_ERROR_TYPE_STATE, 
};
 
struct rte_flow_error {
    enum rte_flow_error_type type; 
    const void *cause; 
    const char *message; 
};
 
RTE_STD_C11
struct rte_flow_conv_rule {
    union {
        const struct rte_flow_attr *attr_ro; 
        struct rte_flow_attr *attr; 
    };
    union {
        const struct rte_flow_item *pattern_ro; 
        struct rte_flow_item *pattern; 
    };
    union {
        const struct rte_flow_action *actions_ro; 
        struct rte_flow_action *actions; 
    };
};
 
enum rte_flow_conv_op {
    RTE_FLOW_CONV_OP_NONE,
 
    RTE_FLOW_CONV_OP_ATTR,
 
    RTE_FLOW_CONV_OP_ITEM,
 
    RTE_FLOW_CONV_OP_ACTION,
 
    RTE_FLOW_CONV_OP_PATTERN,
 
    RTE_FLOW_CONV_OP_ACTIONS,
 
    RTE_FLOW_CONV_OP_RULE,
 
    RTE_FLOW_CONV_OP_ITEM_NAME,
 
    RTE_FLOW_CONV_OP_ACTION_NAME,
 
    RTE_FLOW_CONV_OP_ITEM_NAME_PTR,
 
    RTE_FLOW_CONV_OP_ACTION_NAME_PTR,
};
 
__rte_experimental
int
rte_flow_dev_dump(uint16_t port_id, struct rte_flow *flow,
        FILE *file, struct rte_flow_error *error);
 
__rte_experimental
static inline int
rte_flow_dynf_metadata_avail(void)
{
    return !!rte_flow_dynf_metadata_mask;
}
 
__rte_experimental
int
rte_flow_dynf_metadata_register(void);
 
int
rte_flow_validate(uint16_t port_id,
          const struct rte_flow_attr *attr,
          const struct rte_flow_item pattern[],
          const struct rte_flow_action actions[],
          struct rte_flow_error *error);
 
struct rte_flow *
rte_flow_create(uint16_t port_id,
        const struct rte_flow_attr *attr,
        const struct rte_flow_item pattern[],
        const struct rte_flow_action actions[],
        struct rte_flow_error *error);
 
int
rte_flow_destroy(uint16_t port_id,
         struct rte_flow *flow,
         struct rte_flow_error *error);
 
int
rte_flow_flush(uint16_t port_id,
           struct rte_flow_error *error);
 
int
rte_flow_query(uint16_t port_id,
           struct rte_flow *flow,
           const struct rte_flow_action *action,
           void *data,
           struct rte_flow_error *error);
 
int
rte_flow_isolate(uint16_t port_id, int set, struct rte_flow_error *error);
 
int
rte_flow_error_set(struct rte_flow_error *error,
           int code,
           enum rte_flow_error_type type,
           const void *cause,
           const char *message);
 
struct rte_flow_desc {
    size_t size; 
    struct rte_flow_attr attr; 
    struct rte_flow_item *items; 
    struct rte_flow_action *actions; 
    uint8_t data[]; 
};
 
__rte_deprecated
size_t
rte_flow_copy(struct rte_flow_desc *fd, size_t len,
          const struct rte_flow_attr *attr,
          const struct rte_flow_item *items,
          const struct rte_flow_action *actions);
 
__rte_experimental
int
rte_flow_conv(enum rte_flow_conv_op op,
          void *dst,
          size_t size,
          const void *src,
          struct rte_flow_error *error);
 
__rte_experimental
int
rte_flow_get_aged_flows(uint16_t port_id, void **contexts,
            uint32_t nb_contexts, struct rte_flow_error *error);
 
__rte_experimental
int
rte_flow_get_q_aged_flows(uint16_t port_id, uint32_t queue_id, void **contexts,
              uint32_t nb_contexts, struct rte_flow_error *error);
 
struct rte_flow_indir_action_conf {
    uint32_t ingress:1;
    uint32_t egress:1;
    uint32_t transfer:1;
};
 
__rte_experimental
struct rte_flow_action_handle *
rte_flow_action_handle_create(uint16_t port_id,
                  const struct rte_flow_indir_action_conf *conf,
                  const struct rte_flow_action *action,
                  struct rte_flow_error *error);
 
__rte_experimental
int
rte_flow_action_handle_destroy(uint16_t port_id,
                   struct rte_flow_action_handle *handle,
                   struct rte_flow_error *error);
 
__rte_experimental
int
rte_flow_action_handle_update(uint16_t port_id,
                  struct rte_flow_action_handle *handle,
                  const void *update,
                  struct rte_flow_error *error);
 
__rte_experimental
int
rte_flow_action_handle_query(uint16_t port_id,
                 const struct rte_flow_action_handle *handle,
                 void *data, struct rte_flow_error *error);
 
/* Tunnel has a type and the key information. */
struct rte_flow_tunnel {
    enum rte_flow_item_type type;
    uint64_t tun_id; 
    RTE_STD_C11
    union {
        struct {
            rte_be32_t src_addr; 
            rte_be32_t dst_addr; 
        } ipv4;
        struct {
            uint8_t src_addr[16]; 
            uint8_t dst_addr[16]; 
        } ipv6;
    };
    rte_be16_t tp_src; 
    rte_be16_t tp_dst; 
    uint16_t   tun_flags; 
    bool       is_ipv6; 
    uint8_t    tos; 
    uint8_t    ttl; 
    uint32_t label; 
};
 
#define RTE_FLOW_RESTORE_INFO_TUNNEL RTE_BIT64(0)
 
#define RTE_FLOW_RESTORE_INFO_ENCAPSULATED RTE_BIT64(1)
 
#define RTE_FLOW_RESTORE_INFO_GROUP_ID RTE_BIT64(2)
 
struct rte_flow_restore_info {
    uint64_t flags;
    uint32_t group_id; 
    struct rte_flow_tunnel tunnel; 
};
 
__rte_experimental
int
rte_flow_tunnel_decap_set(uint16_t port_id,
              struct rte_flow_tunnel *tunnel,
              struct rte_flow_action **actions,
              uint32_t *num_of_actions,
              struct rte_flow_error *error);
 
__rte_experimental
int
rte_flow_tunnel_match(uint16_t port_id,
              struct rte_flow_tunnel *tunnel,
              struct rte_flow_item **items,
              uint32_t *num_of_items,
              struct rte_flow_error *error);
 
__rte_experimental
int
rte_flow_get_restore_info(uint16_t port_id,
              struct rte_mbuf *m,
              struct rte_flow_restore_info *info,
              struct rte_flow_error *error);
 
__rte_experimental
int
rte_flow_tunnel_action_decap_release(uint16_t port_id,
                     struct rte_flow_action *actions,
                     uint32_t num_of_actions,
                     struct rte_flow_error *error);
 
__rte_experimental
int
rte_flow_tunnel_item_release(uint16_t port_id,
                 struct rte_flow_item *items,
                 uint32_t num_of_items,
                 struct rte_flow_error *error);
 
int
rte_flow_pick_transfer_proxy(uint16_t port_id, uint16_t *proxy_port_id,
                 struct rte_flow_error *error);
 
__rte_experimental
struct rte_flow_item_flex_handle *
rte_flow_flex_item_create(uint16_t port_id,
              const struct rte_flow_item_flex_conf *conf,
              struct rte_flow_error *error);
 
__rte_experimental
int
rte_flow_flex_item_release(uint16_t port_id,
               const struct rte_flow_item_flex_handle *handle,
               struct rte_flow_error *error);
 
#define RTE_FLOW_PORT_FLAG_STRICT_QUEUE RTE_BIT32(0)
 
struct rte_flow_port_info {
    uint32_t max_nb_queues;
    uint32_t max_nb_counters;
    uint32_t max_nb_aging_objects;
    uint32_t max_nb_meters;
    uint32_t max_nb_conn_tracks;
    uint32_t supported_flags;
};
 
struct rte_flow_queue_info {
    uint32_t max_size;
};
 
__rte_experimental
int
rte_flow_info_get(uint16_t port_id,
          struct rte_flow_port_info *port_info,
          struct rte_flow_queue_info *queue_info,
          struct rte_flow_error *error);
 
struct rte_flow_port_attr {
    uint32_t nb_counters;
    uint32_t nb_aging_objects;
    uint32_t nb_meters;
    uint32_t nb_conn_tracks;
    uint32_t flags;
};
 
struct rte_flow_queue_attr {
    uint32_t size;
};
 
__rte_experimental
int
rte_flow_configure(uint16_t port_id,
           const struct rte_flow_port_attr *port_attr,
           uint16_t nb_queue,
           const struct rte_flow_queue_attr *queue_attr[],
           struct rte_flow_error *error);
 
struct rte_flow_pattern_template;
 
__extension__
struct rte_flow_pattern_template_attr {
    uint32_t relaxed_matching:1;
    uint32_t ingress:1;
    uint32_t egress:1;
    uint32_t transfer:1;
};
 
__rte_experimental
struct rte_flow_pattern_template *
rte_flow_pattern_template_create(uint16_t port_id,
        const struct rte_flow_pattern_template_attr *template_attr,
        const struct rte_flow_item pattern[],
        struct rte_flow_error *error);
 
__rte_experimental
int
rte_flow_pattern_template_destroy(uint16_t port_id,
        struct rte_flow_pattern_template *pattern_template,
        struct rte_flow_error *error);
 
struct rte_flow_actions_template;
 
__extension__
struct rte_flow_actions_template_attr {
    uint32_t ingress:1;
    uint32_t egress:1;
    uint32_t transfer:1;
};
 
__rte_experimental
struct rte_flow_actions_template *
rte_flow_actions_template_create(uint16_t port_id,
        const struct rte_flow_actions_template_attr *template_attr,
        const struct rte_flow_action actions[],
        const struct rte_flow_action masks[],
        struct rte_flow_error *error);
 
__rte_experimental
int
rte_flow_actions_template_destroy(uint16_t port_id,
        struct rte_flow_actions_template *actions_template,
        struct rte_flow_error *error);
 
struct rte_flow_template_table;
 
struct rte_flow_template_table_attr {
    struct rte_flow_attr flow_attr;
    uint32_t nb_flows;
};
 
__rte_experimental
struct rte_flow_template_table *
rte_flow_template_table_create(uint16_t port_id,
        const struct rte_flow_template_table_attr *table_attr,
        struct rte_flow_pattern_template *pattern_templates[],
        uint8_t nb_pattern_templates,
        struct rte_flow_actions_template *actions_templates[],
        uint8_t nb_actions_templates,
        struct rte_flow_error *error);
 
__rte_experimental
int
rte_flow_template_table_destroy(uint16_t port_id,
        struct rte_flow_template_table *template_table,
        struct rte_flow_error *error);
 
__extension__
struct rte_flow_op_attr {
    uint32_t postpone:1;
};
 
__rte_experimental
struct rte_flow *
rte_flow_async_create(uint16_t port_id,
              uint32_t queue_id,
              const struct rte_flow_op_attr *op_attr,
              struct rte_flow_template_table *template_table,
              const struct rte_flow_item pattern[],
              uint8_t pattern_template_index,
              const struct rte_flow_action actions[],
              uint8_t actions_template_index,
              void *user_data,
              struct rte_flow_error *error);
 
__rte_experimental
int
rte_flow_async_destroy(uint16_t port_id,
               uint32_t queue_id,
               const struct rte_flow_op_attr *op_attr,
               struct rte_flow *flow,
               void *user_data,
               struct rte_flow_error *error);
 
__rte_experimental
int
rte_flow_push(uint16_t port_id,
          uint32_t queue_id,
          struct rte_flow_error *error);
 
enum rte_flow_op_status {
    RTE_FLOW_OP_SUCCESS,
    RTE_FLOW_OP_ERROR,
};
 
__extension__
struct rte_flow_op_result {
    enum rte_flow_op_status status;
    void *user_data;
};
 
__rte_experimental
int
rte_flow_pull(uint16_t port_id,
          uint32_t queue_id,
          struct rte_flow_op_result res[],
          uint16_t n_res,
          struct rte_flow_error *error);
 
__rte_experimental
struct rte_flow_action_handle *
rte_flow_async_action_handle_create(uint16_t port_id,
        uint32_t queue_id,
        const struct rte_flow_op_attr *op_attr,
        const struct rte_flow_indir_action_conf *indir_action_conf,
        const struct rte_flow_action *action,
        void *user_data,
        struct rte_flow_error *error);
 
__rte_experimental
int
rte_flow_async_action_handle_destroy(uint16_t port_id,
        uint32_t queue_id,
        const struct rte_flow_op_attr *op_attr,
        struct rte_flow_action_handle *action_handle,
        void *user_data,
        struct rte_flow_error *error);
 
__rte_experimental
int
rte_flow_async_action_handle_update(uint16_t port_id,
        uint32_t queue_id,
        const struct rte_flow_op_attr *op_attr,
        struct rte_flow_action_handle *action_handle,
        const void *update,
        void *user_data,
        struct rte_flow_error *error);
 
__rte_experimental
int
rte_flow_async_action_handle_query(uint16_t port_id,
        uint32_t queue_id,
        const struct rte_flow_op_attr *op_attr,
        const struct rte_flow_action_handle *action_handle,
        void *data,
        void *user_data,
        struct rte_flow_error *error);
 
#ifdef __cplusplus
}
#endif
 
#endif /* RTE_FLOW_H_ */