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_arp.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>
#include <rte_ib.h>

#include "rte_ethdev.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; 
};

struct rte_flow_group_attr {
    uint32_t ingress:1;
    uint32_t egress:1;
    uint32_t transfer:1;
};

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_FLOW_ITEM_TYPE_IPV6_ROUTING_EXT,

    RTE_FLOW_ITEM_TYPE_ICMP6_ECHO_REQUEST,

    RTE_FLOW_ITEM_TYPE_ICMP6_ECHO_REPLY,

     RTE_FLOW_ITEM_TYPE_QUOTA,

    RTE_FLOW_ITEM_TYPE_AGGR_AFFINITY,

     RTE_FLOW_ITEM_TYPE_TX_QUEUE,

    RTE_FLOW_ITEM_TYPE_IB_BTH,

    RTE_FLOW_ITEM_TYPE_PTYPE,
};

enum rte_flow_quota_state {
    RTE_FLOW_QUOTA_STATE_PASS, 
    RTE_FLOW_QUOTA_STATE_BLOCK 
};

struct rte_flow_item_quota {
    enum rte_flow_quota_state state;
};

#ifndef __cplusplus
static const struct rte_flow_item_quota rte_flow_item_quota_mask = {
    .state = (enum rte_flow_quota_state)0xff
};
#endif

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 = RTE_BE16(UINT16_MAX),
            .vid = RTE_BE16(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

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

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_ipv6_routing_ext {
    struct rte_ipv6_routing_ext hdr;
};

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

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.vni = "\xff\xff\xff",
};
#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 {
    union {
        struct {
            /*
             * These are old fields kept for compatibility.
             * Please prefer hdr field below.
             */
            uint8_t v_pt_rsv_flags;
            uint8_t msg_type; 
            rte_be16_t msg_len; 
            rte_be32_t teid; 
        };
        struct rte_gtp_hdr hdr; 
    };
};

#ifndef __cplusplus
static const struct rte_flow_item_gtp rte_flow_item_gtp_mask = {
    .hdr.teid = RTE_BE32(UINT32_MAX),
};
#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 {
    union {
        struct {
            /*
             * These are old fields kept for compatibility.
             * Please prefer hdr field below.
             */
            uint8_t flags; 
            uint8_t rsvd0[2]; 
            uint8_t protocol; 
            uint8_t vni[3]; 
            uint8_t rsvd1; 
        };
        struct rte_vxlan_gpe_hdr hdr;
    };
};

#ifndef __cplusplus
static const struct rte_flow_item_vxlan_gpe rte_flow_item_vxlan_gpe_mask = {
    .hdr.vni = "\xff\xff\xff",
};
#endif

struct rte_flow_item_arp_eth_ipv4 {
    union {
        struct {
            /*
             * These are old fields kept for compatibility.
             * Please prefer hdr field below.
             */
            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; 
        };
        struct rte_arp_hdr hdr; 
    };
};

#ifndef __cplusplus
static const struct rte_flow_item_arp_eth_ipv4
rte_flow_item_arp_eth_ipv4_mask = {
    .hdr.arp_data.arp_sha.addr_bytes = "\xff\xff\xff\xff\xff\xff",
    .hdr.arp_data.arp_sip = RTE_BE32(UINT32_MAX),
    .hdr.arp_data.arp_tha.addr_bytes = "\xff\xff\xff\xff\xff\xff",
    .hdr.arp_data.arp_tip = RTE_BE32(UINT32_MAX),
};
#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_echo {
    struct rte_icmp_echo_hdr hdr;
};

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;
    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_ib_bth {
    struct rte_ib_bth hdr; 
};

#ifndef __cplusplus
static const struct rte_flow_item_ib_bth rte_flow_item_ib_bth_mask = {
    .hdr = {
        .opcode = 0xff,
        .dst_qp = "\xff\xff\xff",
    },
};
#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

struct rte_flow_item_aggr_affinity {
    uint8_t affinity;
};

#ifndef __cplusplus
static const struct rte_flow_item_aggr_affinity
rte_flow_item_aggr_affinity_mask = {
    .affinity = 0xff,
};
#endif

struct rte_flow_item_tx_queue {
    uint16_t tx_queue;
};

#ifndef __cplusplus
static const struct rte_flow_item_tx_queue rte_flow_item_tx_queue_mask = {
    .tx_queue = 0xffff,
};
#endif

struct rte_flow_item_ptype {
    uint32_t packet_type; 
};

#ifndef __cplusplus
static const struct rte_flow_item_ptype rte_flow_item_ptype_mask = {
    .packet_type = 0xffffffff,
};
#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,

     RTE_FLOW_ACTION_TYPE_QUOTA,

    RTE_FLOW_ACTION_TYPE_SKIP_CMAN,

    RTE_FLOW_ACTION_TYPE_IPV6_EXT_PUSH,

    RTE_FLOW_ACTION_TYPE_IPV6_EXT_REMOVE,

    RTE_FLOW_ACTION_TYPE_INDIRECT_LIST,

    RTE_FLOW_ACTION_TYPE_PROG,
};

enum rte_flow_quota_mode {
    RTE_FLOW_QUOTA_MODE_PACKET = 1, 
    RTE_FLOW_QUOTA_MODE_L2 = 2, 
    RTE_FLOW_QUOTA_MODE_L3 = 3, 
};

struct rte_flow_action_quota {
    enum rte_flow_quota_mode mode; 
    int64_t quota;                 
};

struct rte_flow_query_quota {
    int64_t quota; 
};

enum rte_flow_update_quota_op {
    RTE_FLOW_UPDATE_QUOTA_SET, 
    RTE_FLOW_UPDATE_QUOTA_ADD, 
};

struct rte_flow_update_quota {
    enum rte_flow_update_quota_op op; 
    int64_t quota;                    
};

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; 
};

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_ipv6_ext_push {
    uint8_t *data; 
    size_t size; 
    uint8_t type; 
};

struct rte_flow_action_ipv6_ext_remove {
    uint8_t type; 
};

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, 
    RTE_FLOW_FIELD_IPV6_PROTO,  
    RTE_FLOW_FIELD_FLEX_ITEM,   
    RTE_FLOW_FIELD_HASH_RESULT, 
    RTE_FLOW_FIELD_GENEVE_OPT_TYPE, 
    RTE_FLOW_FIELD_GENEVE_OPT_CLASS,
    RTE_FLOW_FIELD_GENEVE_OPT_DATA, 
    RTE_FLOW_FIELD_MPLS,        
    RTE_FLOW_FIELD_TCP_DATA_OFFSET, 
    RTE_FLOW_FIELD_IPV4_IHL,    
    RTE_FLOW_FIELD_IPV4_TOTAL_LEN,  
    RTE_FLOW_FIELD_IPV6_PAYLOAD_LEN 
};

struct rte_flow_action_modify_data {
    enum rte_flow_field_id field; 
    union {
        struct {
            union {
                struct {
                    uint8_t level;
                    union {
                        uint8_t tag_index;
                        struct {
                            uint8_t type;
                            rte_be16_t class_id;
                        };
                    };
                };
                struct rte_flow_item_flex_handle *flex_handle;
            };
            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;
    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 state_valid:1;
    uint32_t reserved:28;
};

struct rte_flow_indirect_update_flow_meter_mark {
    enum rte_color init_color;
};

struct rte_flow_action_prog_argument {
    const char *name;
    uint32_t size;
    const uint8_t *value;
};

struct rte_flow_action_prog {
    const char *name;
    uint32_t args_num;
    const struct rte_flow_action_prog_argument *args;
};

/* 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; 
};

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);

__rte_experimental
int
rte_flow_actions_update(uint16_t port_id,
            struct rte_flow *flow,
            const struct rte_flow_action actions[],
            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; 
    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
uint64_t
rte_flow_restore_info_dynflag(void);

__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)

#define RTE_FLOW_PORT_FLAG_SHARE_INDIRECT RTE_BIT32(1)

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 max_nb_quotas;
    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;
    uint16_t host_port_id;
    uint32_t nb_quotas;
    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;

#define RTE_FLOW_TABLE_SPECIALIZE_TRANSFER_WIRE_ORIG RTE_BIT32(0)

#define RTE_FLOW_TABLE_SPECIALIZE_TRANSFER_VPORT_ORIG RTE_BIT32(1)

enum rte_flow_table_insertion_type {
    RTE_FLOW_TABLE_INSERTION_TYPE_PATTERN,
    RTE_FLOW_TABLE_INSERTION_TYPE_INDEX,
};

enum rte_flow_table_hash_func {
    RTE_FLOW_TABLE_HASH_FUNC_DEFAULT,
    RTE_FLOW_TABLE_HASH_FUNC_LINEAR,
    RTE_FLOW_TABLE_HASH_FUNC_CRC32,
    RTE_FLOW_TABLE_HASH_FUNC_CRC16,
};

struct rte_flow_template_table_attr {
    struct rte_flow_attr flow_attr;
    uint32_t nb_flows;
    uint32_t specialize;
    enum rte_flow_table_insertion_type insertion_type;
    enum rte_flow_table_hash_func hash_func;
};

__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);

__rte_experimental
int
rte_flow_group_set_miss_actions(uint16_t port_id,
                uint32_t group_id,
                const struct rte_flow_group_attr *attr,
                const struct rte_flow_action actions[],
                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
struct rte_flow *
rte_flow_async_create_by_index(uint16_t port_id,
                   uint32_t queue_id,
                   const struct rte_flow_op_attr *op_attr,
                   struct rte_flow_template_table *template_table,
                   uint32_t rule_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_async_actions_update(uint16_t port_id,
                  uint32_t queue_id,
                  const struct rte_flow_op_attr *op_attr,
                  struct rte_flow *flow,
                  const struct rte_flow_action actions[],
                  uint8_t actions_template_index,
                  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);

enum rte_flow_query_update_mode {
    RTE_FLOW_QU_QUERY_FIRST = 1,  
    RTE_FLOW_QU_UPDATE_FIRST,     
};

__rte_experimental
int
rte_flow_action_handle_query_update(uint16_t port_id,
                    struct rte_flow_action_handle *handle,
                    const void *update, void *query,
                    enum rte_flow_query_update_mode mode,
                    struct rte_flow_error *error);

__rte_experimental
int
rte_flow_async_action_handle_query_update(uint16_t port_id, uint32_t queue_id,
                      const struct rte_flow_op_attr *attr,
                      struct rte_flow_action_handle *handle,
                      const void *update, void *query,
                      enum rte_flow_query_update_mode mode,
                      void *user_data,
                      struct rte_flow_error *error);

struct rte_flow_action_list_handle;

struct rte_flow_action_indirect_list {
    struct rte_flow_action_list_handle *handle;
    const void **conf;
};

__rte_experimental
struct rte_flow_action_list_handle *
rte_flow_action_list_handle_create(uint16_t port_id,
                   const
                   struct rte_flow_indir_action_conf *conf,
                   const struct rte_flow_action *actions,
                   struct rte_flow_error *error);

__rte_experimental
struct rte_flow_action_list_handle *
rte_flow_async_action_list_handle_create(uint16_t port_id, uint32_t queue_id,
                     const struct rte_flow_op_attr *attr,
                     const struct rte_flow_indir_action_conf *conf,
                     const struct rte_flow_action *actions,
                     void *user_data,
                     struct rte_flow_error *error);

__rte_experimental
int
rte_flow_action_list_handle_destroy(uint16_t port_id,
                    struct rte_flow_action_list_handle *handle,
                    struct rte_flow_error *error);

__rte_experimental
int
rte_flow_async_action_list_handle_destroy
        (uint16_t port_id, uint32_t queue_id,
         const struct rte_flow_op_attr *op_attr,
         struct rte_flow_action_list_handle *handle,
         void *user_data, struct rte_flow_error *error);

__rte_experimental
int
rte_flow_action_list_handle_query_update(uint16_t port_id,
                     const struct rte_flow_action_list_handle *handle,
                     const void **update, void **query,
                     enum rte_flow_query_update_mode mode,
                     struct rte_flow_error *error);

__rte_experimental
int
rte_flow_async_action_list_handle_query_update(uint16_t port_id, uint32_t queue_id,
                      const struct rte_flow_op_attr *attr,
                      const struct rte_flow_action_list_handle *handle,
                      const void **update, void **query,
                      enum rte_flow_query_update_mode mode,
                      void *user_data,
                      struct rte_flow_error *error);

__rte_experimental
int
rte_flow_calc_table_hash(uint16_t port_id, const struct rte_flow_template_table *table,
             const struct rte_flow_item pattern[], uint8_t pattern_template_index,
             uint32_t *hash, struct rte_flow_error *error);

#ifdef __cplusplus
}
#endif

#endif /* RTE_FLOW_H_ */