doca_flow.h

Go to the documentation of this file.

/*
 * Copyright (c) 2021-2022 NVIDIA CORPORATION & AFFILIATES, ALL RIGHTS RESERVED.
 *
 * This software product is a proprietary product of NVIDIA CORPORATION &
 * AFFILIATES (the "Company") and all right, title, and interest in and to the
 * software product, including all associated intellectual property rights, are
 * and shall remain exclusively with the Company.
 *
 * This software product is governed by the End User License Agreement
 * provided with the software product.
 *
 */
 
#ifndef DOCA_FLOW_H_
#define DOCA_FLOW_H_
 
#include <stdio.h>
#include <stdint.h>
#include <stdbool.h>
 
#include <doca_compat.h>
#include <doca_error.h>
 
#include <doca_flow_net.h>
#include <doca_flow_crypto.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
struct doca_dev;
struct doca_dev_rep;
 
struct doca_flow_port;
 
struct doca_flow_pipe;
 
struct doca_flow_pipe_entry;
 
struct doca_flow_target;
 
struct doca_flow_parser;
 
struct doca_flow_definitions;
 
struct doca_flow_cfg;
 
struct doca_flow_port_cfg;
 
struct doca_flow_pipe_cfg;
 
enum doca_flow_shared_resource_type {
    DOCA_FLOW_SHARED_RESOURCE_METER,
    DOCA_FLOW_SHARED_RESOURCE_COUNTER,
    DOCA_FLOW_SHARED_RESOURCE_RSS,
    DOCA_FLOW_SHARED_RESOURCE_MIRROR,
    DOCA_FLOW_SHARED_RESOURCE_PSP,
    DOCA_FLOW_SHARED_RESOURCE_ENCAP,
    DOCA_FLOW_SHARED_RESOURCE_DECAP,
    DOCA_FLOW_SHARED_RESOURCE_IPSEC_SA,
};
 
enum doca_flow_flags_type {
    DOCA_FLOW_NO_WAIT = 0,
    DOCA_FLOW_WAIT_FOR_BATCH = (1 << 0),
};
 
enum doca_flow_pipe_op {
    DOCA_FLOW_PIPE_OP_CONGESTION_REACHED,
    DOCA_FLOW_PIPE_OP_RESIZED,
    DOCA_FLOW_PIPE_OP_DESTROYED,
};
 
enum doca_flow_pipe_status {
    DOCA_FLOW_PIPE_STATUS_SUCCESS = 1,
    DOCA_FLOW_PIPE_STATUS_ERROR,
};
 
enum doca_flow_entry_op {
    DOCA_FLOW_ENTRY_OP_ADD,
    DOCA_FLOW_ENTRY_OP_DEL,
    DOCA_FLOW_ENTRY_OP_UPD,
    DOCA_FLOW_ENTRY_OP_AGED,
};
 
enum doca_flow_entry_status {
    DOCA_FLOW_ENTRY_STATUS_IN_PROCESS,
    /* The operation is in progress. */
    DOCA_FLOW_ENTRY_STATUS_SUCCESS,
    /* The operation was completed successfully. */
    DOCA_FLOW_ENTRY_STATUS_ERROR,
    /* The operation failed. */
};
 
enum doca_flow_rss_hash_function {
    DOCA_FLOW_RSS_HASH_FUNCTION_TOEPLITZ,       
    DOCA_FLOW_RSS_HASH_FUNCTION_SYMMETRIC_TOEPLITZ, 
};
 
struct doca_flow_resource_rss_cfg {
    uint32_t outer_flags;
    uint32_t inner_flags;
    uint16_t *queues_array;
    int nr_queues;
    enum doca_flow_rss_hash_function rss_hash_func;
};
 
typedef void (*doca_flow_pipe_process_cb)(struct doca_flow_pipe *pipe,
                      enum doca_flow_pipe_status status,
                      enum doca_flow_pipe_op op,
                      void *user_ctx);
 
typedef void (*doca_flow_entry_process_cb)(struct doca_flow_pipe_entry *entry,
                       uint16_t pipe_queue,
                       enum doca_flow_entry_status status,
                       enum doca_flow_entry_op op,
                       void *user_ctx);
 
typedef void (*doca_flow_shared_resource_unbind_cb)(enum doca_flow_shared_resource_type,
                            uint32_t shared_resource_id,
                            void *bindable_obj);
 
enum doca_flow_pipe_type {
    DOCA_FLOW_PIPE_BASIC,
    DOCA_FLOW_PIPE_CONTROL,
    DOCA_FLOW_PIPE_LPM,
    DOCA_FLOW_PIPE_CT,
    DOCA_FLOW_PIPE_ACL,
    DOCA_FLOW_PIPE_ORDERED_LIST,
    DOCA_FLOW_PIPE_HASH,
};
 
enum doca_flow_pipe_domain {
    DOCA_FLOW_PIPE_DOMAIN_DEFAULT = 0,
    DOCA_FLOW_PIPE_DOMAIN_SECURE_INGRESS,
    DOCA_FLOW_PIPE_DOMAIN_EGRESS,
    DOCA_FLOW_PIPE_DOMAIN_SECURE_EGRESS,
};
 
#define DOCA_FLOW_META_SCRATCH_PAD_MAX 10
 
#define DOCA_FLOW_META_MAX ((DOCA_FLOW_META_SCRATCH_PAD_MAX + 1) * 4)
 
#define DOCA_FLOW_MAX_ENTRY_ACTIONS_MEM_SIZE (128)
 
enum __attribute__((__packed__)) doca_flow_meter_color {
    DOCA_FLOW_METER_COLOR_RED = 0,
    DOCA_FLOW_METER_COLOR_YELLOW,
    DOCA_FLOW_METER_COLOR_GREEN,
};
 
enum doca_flow_l2_meta {
    DOCA_FLOW_L2_META_NO_VLAN = 0,
    DOCA_FLOW_L2_META_MULTI_VLAN,
    DOCA_FLOW_L2_META_SINGLE_VLAN,
    DOCA_FLOW_L2_META_CUSTOM_VLAN,
};
 
enum doca_flow_l3_meta {
    DOCA_FLOW_L3_META_NONE = 0,
    DOCA_FLOW_L3_META_IPV4,
    DOCA_FLOW_L3_META_IPV6,
};
 
enum doca_flow_l4_meta {
    DOCA_FLOW_L4_META_NONE = 0,
    DOCA_FLOW_L4_META_TCP,
    DOCA_FLOW_L4_META_UDP,
    DOCA_FLOW_L4_META_ICMP,
    DOCA_FLOW_L4_META_ESP,
};
 
enum doca_flow_crypto_syndrome {
    DOCA_FLOW_CRYPTO_SYNDROME_OK,
    DOCA_FLOW_CRYPTO_SYNDROME_ICV_FAIL,
    DOCA_FLOW_CRYPTO_SYNDROME_BAD_TRAILER,
};
 
enum doca_flow_pipe_hash_map_algorithm {
    DOCA_FLOW_PIPE_HASH_MAP_ALGORITHM_HASH = 1 << 0,
    DOCA_FLOW_PIPE_HASH_MAP_ALGORITHM_RANDOM = 1 << 1,
    DOCA_FLOW_PIPE_HASH_MAP_ALGORITHM_IDENTITY = 1 << 2,
    DOCA_FLOW_PIPE_HASH_MAP_ALGORITHM_ROUND_ROBIN = 1 << 3,
    DOCA_FLOW_PIPE_HASH_MAP_ALGORITHM_FLOODING = 1 << 4,
    DOCA_FLOW_PIPE_HASH_MAP_ALGORITHM_SELECT_ENABLED = 1 << 5,
};
 
struct doca_flow_meta {
    doca_be32_t pkt_meta;                
    doca_be32_t u32[DOCA_FLOW_META_SCRATCH_PAD_MAX]; 
    doca_be32_t mark;                
};
 
struct doca_flow_parser_meta {
    uint16_t port_id; 
    doca_be16_t random;
    uint8_t ipsec_syndrome;         
    uint8_t ipsec_ar_syndrome;      
    uint8_t psp_syndrome;           
    enum doca_flow_meter_color meter_color; 
    enum doca_flow_l2_meta outer_l2_type;   
    enum doca_flow_l3_meta outer_l3_type;   
    enum doca_flow_l4_meta outer_l4_type;   
    enum doca_flow_l2_meta inner_l2_type;   
    enum doca_flow_l3_meta inner_l3_type;   
    enum doca_flow_l4_meta inner_l4_type;   
    uint8_t outer_ip_fragmented;        
    uint8_t inner_ip_fragmented;        
    uint8_t outer_l3_ok;            
    uint8_t outer_ip4_checksum_ok;      
    uint8_t outer_l4_ok;            
    uint8_t outer_l4_checksum_ok;       
    uint8_t inner_l3_ok;            
    uint8_t inner_ip4_checksum_ok;      
    uint8_t inner_l4_ok;            
    uint8_t inner_l4_checksum_ok;       
};
 
enum doca_flow_match_tcp_flags {
    DOCA_FLOW_MATCH_TCP_FLAG_FIN = (1 << 0),
    DOCA_FLOW_MATCH_TCP_FLAG_SYN = (1 << 1),
    DOCA_FLOW_MATCH_TCP_FLAG_RST = (1 << 2),
    DOCA_FLOW_MATCH_TCP_FLAG_PSH = (1 << 3),
    DOCA_FLOW_MATCH_TCP_FLAG_ACK = (1 << 4),
    DOCA_FLOW_MATCH_TCP_FLAG_URG = (1 << 5),
    DOCA_FLOW_MATCH_TCP_FLAG_ECE = (1 << 6),
    DOCA_FLOW_MATCH_TCP_FLAG_CWR = (1 << 7),
};
 
#define DOCA_FLOW_VLAN_MAX 2
 
enum doca_flow_l2_valid_header {
    DOCA_FLOW_L2_VALID_HEADER_VLAN_0 = (1 << 0),
    DOCA_FLOW_L2_VALID_HEADER_VLAN_1 = (1 << 1),
};
 
struct doca_flow_header_format {
    struct doca_flow_header_eth eth;
    uint16_t l2_valid_headers;
    struct doca_flow_header_eth_vlan eth_vlan[DOCA_FLOW_VLAN_MAX];
    enum doca_flow_l3_type l3_type;
    union {
        struct doca_flow_header_ip4 ip4;
        struct doca_flow_header_ip6 ip6;
    };
    enum doca_flow_l4_type_ext l4_type_ext;
    union {
        struct doca_flow_header_icmp icmp;
        struct doca_flow_header_udp udp;
        struct doca_flow_header_tcp tcp;
        struct doca_flow_header_l4_port transport;
        struct doca_flow_header_roce_v2 roce_v2;
    };
};
 
struct doca_flow_entropy_format {
    enum doca_flow_l3_type l3_type;
    union {
        struct doca_flow_header_ip4 ip4;
        struct doca_flow_header_ip6 ip6;
    };
    enum doca_flow_l4_type_ext l4_type_ext;
    struct doca_flow_header_l4_port transport;
};
 
struct doca_flow_match {
    uint32_t flags;
    struct doca_flow_meta meta;
    struct doca_flow_parser_meta parser_meta;
    struct doca_flow_header_format outer;
    struct doca_flow_tun tun;
    struct doca_flow_header_format inner;
};
 
enum doca_flow_compare_op {
    DOCA_FLOW_COMPARE_EQ,
    DOCA_FLOW_COMPARE_NE,
    DOCA_FLOW_COMPARE_LT,
    DOCA_FLOW_COMPARE_LE,
    DOCA_FLOW_COMPARE_GT,
    DOCA_FLOW_COMPARE_GE,
};
 
struct doca_flow_desc_field {
    const char *field_string;
    uint32_t bit_offset;
};
 
struct doca_flow_match_condition {
    enum doca_flow_compare_op operation;
    union {
        struct {
            struct doca_flow_desc_field a;
            struct doca_flow_desc_field b;
            uint32_t width;
        } field_op;
    };
};
 
struct doca_flow_encap_action {
    struct doca_flow_header_format outer;
    struct doca_flow_tun tun;
};
 
struct doca_flow_push_vlan_action {
    doca_be16_t eth_type;
    struct doca_flow_header_eth_vlan vlan_hdr;
};
 
enum doca_flow_push_action_type {
    DOCA_FLOW_PUSH_ACTION_VLAN,
};
 
struct doca_flow_push_action {
    enum doca_flow_push_action_type type;
    union {
        struct doca_flow_push_vlan_action vlan;
    };
};
 
struct doca_flow_nat64_action {
    enum doca_flow_l3_type original_l3_type;
};
 
enum doca_flow_resource_type {
    DOCA_FLOW_RESOURCE_TYPE_NONE,
    DOCA_FLOW_RESOURCE_TYPE_SHARED,
    DOCA_FLOW_RESOURCE_TYPE_NON_SHARED
};
 
#define DOCA_FLOW_PSP_DECRYPTION_ID UINT32_MAX
 
struct doca_flow_crypto_action {
    enum doca_flow_crypto_action_type action_type;
    enum doca_flow_crypto_resource_type resource_type;
    union {
        struct {
            bool sn_en;
        } ipsec_sa;
    };
    uint32_t crypto_id;
};
 
struct doca_flow_crypto_encap_action {
    enum doca_flow_crypto_encap_action_type action_type;
    enum doca_flow_crypto_encap_net_type net_type;
    uint16_t icv_size;
    uint16_t data_size;
    uint8_t encap_data[DOCA_FLOW_CRYPTO_HEADER_LEN_MAX];
};
 
struct doca_flow_resource_encap_cfg {
    bool is_l2;
    struct doca_flow_encap_action encap;
};
 
struct doca_flow_resource_decap_cfg {
    bool is_l2;
    struct doca_flow_header_eth eth;
    uint16_t l2_valid_headers;
    struct doca_flow_header_eth_vlan eth_vlan[DOCA_FLOW_VLAN_MAX];
};
 
struct doca_flow_actions {
    uint8_t action_idx;
    uint32_t flags;
    enum doca_flow_resource_type decap_type;
    union {
        struct doca_flow_resource_decap_cfg decap_cfg;
        uint32_t shared_decap_id;
    };
    bool pop_vlan;
    struct doca_flow_meta meta;
    struct doca_flow_parser_meta parser_meta;
    struct doca_flow_header_format outer;
    struct doca_flow_tun tun;
    enum doca_flow_resource_type encap_type;
    union {
        struct doca_flow_resource_encap_cfg encap_cfg;
        uint32_t shared_encap_id;
    };
    bool has_push;
    struct doca_flow_push_action push;
    struct doca_flow_nat64_action nat64;
    bool has_crypto_encap;
    struct doca_flow_crypto_encap_action crypto_encap;
    struct doca_flow_crypto_action crypto;
};
 
enum doca_flow_target_type {
    DOCA_FLOW_TARGET_KERNEL,
};
 
enum doca_flow_fwd_type {
    DOCA_FLOW_FWD_NONE = 0,
    DOCA_FLOW_FWD_RSS,
    DOCA_FLOW_FWD_PORT,
    DOCA_FLOW_FWD_PIPE,
    DOCA_FLOW_FWD_DROP,
    DOCA_FLOW_FWD_TARGET,
    DOCA_FLOW_FWD_ORDERED_LIST_PIPE,
    DOCA_FLOW_FWD_HASH_PIPE,
    DOCA_FLOW_FWD_CHANGEABLE = 100
};
 
enum doca_rss_type {
    DOCA_FLOW_RSS_IPV4 = (1 << 0),
    DOCA_FLOW_RSS_IPV6 = (1 << 1),
    DOCA_FLOW_RSS_UDP = (1 << 2),
    DOCA_FLOW_RSS_TCP = (1 << 3),
    DOCA_FLOW_RSS_ESP = (1 << 4),
};
 
struct doca_flow_fwd {
    enum doca_flow_fwd_type type;
    union {
        struct {
            enum doca_flow_resource_type rss_type;
            union {
                struct doca_flow_resource_rss_cfg rss;
                uint32_t shared_rss_id;
            };
        };
        struct {
            uint16_t port_id;
        };
        struct {
            struct doca_flow_pipe *next_pipe;
        };
        struct {
            struct doca_flow_pipe *pipe;
            uint32_t idx;
        } ordered_list_pipe;
        struct {
            struct doca_flow_target *target;
        };
        struct {
            struct doca_flow_pipe *pipe;
            enum doca_flow_pipe_hash_map_algorithm algorithm;
        } hash_pipe;
    };
};
 
enum doca_flow_meter_algorithm_type {
    DOCA_FLOW_METER_ALGORITHM_TYPE_RFC2697,
    DOCA_FLOW_METER_ALGORITHM_TYPE_RFC2698,
    DOCA_FLOW_METER_ALGORITHM_TYPE_RFC4115,
};
 
enum doca_flow_meter_limit_type {
    DOCA_FLOW_METER_LIMIT_TYPE_BYTES = 0,
    DOCA_FLOW_METER_LIMIT_TYPE_PACKETS,
};
 
enum doca_flow_meter_color_mode {
    DOCA_FLOW_METER_COLOR_MODE_BLIND = 0,
    DOCA_FLOW_METER_COLOR_MODE_AWARE,
};
 
struct doca_flow_resource_meter_cfg {
    enum doca_flow_meter_limit_type limit_type;
    enum doca_flow_meter_color_mode color_mode;
    enum doca_flow_meter_algorithm_type alg;
    uint64_t cir;
    uint64_t cbs;
    union {
        struct {
            uint64_t ebs;
        } rfc2697;
        struct {
            uint64_t pir;
            uint64_t pbs;
        } rfc2698;
        struct {
            uint64_t eir;
            uint64_t ebs;
        } rfc4115;
    };
};
 
struct doca_flow_resource_psp_cfg {
    struct doca_flow_crypto_key_cfg key_cfg;
};
 
struct doca_flow_resource_ipsec_sa_cfg {
    struct doca_flow_crypto_key_cfg key_cfg;
    uint32_t salt;
    uint64_t implicit_iv;
    enum doca_flow_crypto_icv_len icv_len;
    enum doca_flow_crypto_sn_offload_type sn_offload_type;
    enum doca_flow_crypto_replay_win_size win_size;
    bool esn_en;
    uint64_t sn_initial;
    uint32_t lifetime_threshold;
};
 
struct doca_flow_mirror_target {
    bool has_encap;
    struct doca_flow_encap_action encap;
    struct doca_flow_fwd fwd;
};
 
struct doca_flow_resource_mirror_cfg {
    int nr_targets;
    struct doca_flow_mirror_target *target;
    struct doca_flow_fwd fwd;
};
 
struct doca_flow_shared_resource_cfg {
    union {
        struct doca_flow_resource_meter_cfg meter_cfg;
        struct doca_flow_resource_rss_cfg rss_cfg;
        struct doca_flow_resource_psp_cfg psp_cfg;
        struct doca_flow_resource_mirror_cfg mirror_cfg;
        struct doca_flow_resource_encap_cfg encap_cfg;
        struct doca_flow_resource_decap_cfg decap_cfg;
        struct doca_flow_resource_ipsec_sa_cfg ipsec_sa_cfg;
    };
};
 
struct doca_flow_monitor {
    enum doca_flow_resource_type meter_type;
    union {
        struct {
            enum doca_flow_meter_limit_type limit_type;
            uint64_t cir;
            uint64_t cbs;
        } non_shared_meter;
        struct {
            uint32_t shared_meter_id;
            enum doca_flow_meter_color meter_init_color;
        } shared_meter;
    };
 
    enum doca_flow_resource_type counter_type;
    union {
        struct {
            uint32_t shared_counter_id;
        } shared_counter;
    };
 
    uint32_t shared_mirror_id;
    uint32_t aging_sec;
};
 
enum doca_flow_action_type {
    DOCA_FLOW_ACTION_AUTO = 0,
    /* Derived from pipe actions. */
    DOCA_FLOW_ACTION_ADD,
    /* Add field value from pipe actions or flow entry. */
    DOCA_FLOW_ACTION_COPY,
    /* Copy field to another field. */
};
 
struct doca_flow_action_desc {
    enum doca_flow_action_type type; 
    union {
        struct {
            struct doca_flow_desc_field src; /* Source info to copy from. */
            struct doca_flow_desc_field dst; /* Or destination info to copy to. */
            uint32_t width;          /* Bit width to copy */
        } field_op;
    };
};
 
struct doca_flow_action_descs {
    uint8_t nb_action_desc;
    struct doca_flow_action_desc *desc_array;
};
 
enum doca_flow_ordered_list_element_type {
    DOCA_FLOW_ORDERED_LIST_ELEMENT_ACTIONS,
    DOCA_FLOW_ORDERED_LIST_ELEMENT_MONITOR,
};
 
struct doca_flow_ordered_list_element {
    enum doca_flow_ordered_list_element_type type;
    union {
        struct {
            struct doca_flow_actions *actions;
            /* DOCA Flow actions array. */
            struct doca_flow_actions *actions_mask;
            /* DOCA Flow actions masks array. */
            struct doca_flow_action_descs *action_descs;
            /* DOCA Flow actions descriptor array. */
        };
        struct doca_flow_monitor *monitor;
        /* DOCA Flow monitor array. */
    };
};
 
struct doca_flow_ordered_list {
    uint32_t idx;
    uint32_t size;
    struct doca_flow_ordered_list_element *elements;
};
 
enum doca_flow_direction_info {
    DOCA_FLOW_DIRECTION_BIDIRECTIONAL = 0,
    DOCA_FLOW_DIRECTION_NETWORK_TO_HOST,
    DOCA_FLOW_DIRECTION_HOST_TO_NETWORK,
};
 
struct doca_flow_resource_query {
    union {
        struct {
            uint64_t total_bytes;
            uint64_t total_pkts;
        } counter;
        struct {
            uint64_t current_sn;
        } ipsec_sa;
    };
};
 
enum doca_flow_parser_geneve_opt_mode {
    DOCA_FLOW_PARSER_GENEVE_OPT_MODE_IGNORE,
    DOCA_FLOW_PARSER_GENEVE_OPT_MODE_FIXED,
    DOCA_FLOW_PARSER_GENEVE_OPT_MODE_MATCHABLE,
};
 
struct doca_flow_parser_geneve_opt_cfg {
    enum doca_flow_parser_geneve_opt_mode match_on_class_mode;
    doca_be16_t option_class;
    uint8_t option_type;
    uint8_t option_len;
    doca_be32_t data_mask[DOCA_FLOW_GENEVE_DATA_OPTION_LEN_MAX];
};
 
enum doca_flow_port_operation_state {
    DOCA_FLOW_PORT_OPERATION_STATE_ACTIVE,
    DOCA_FLOW_PORT_OPERATION_STATE_ACTIVE_READY_TO_SWAP,
    DOCA_FLOW_PORT_OPERATION_STATE_STANDBY,
    DOCA_FLOW_PORT_OPERATION_STATE_UNCONNECTED,
};
 
DOCA_EXPERIMENTAL
doca_error_t doca_flow_init(struct doca_flow_cfg *cfg);
 
DOCA_STABLE
void doca_flow_destroy(void);
 
DOCA_EXPERIMENTAL
doca_error_t doca_flow_port_start(const struct doca_flow_port_cfg *cfg, struct doca_flow_port **port);
 
DOCA_STABLE
doca_error_t doca_flow_port_stop(struct doca_flow_port *port);
 
DOCA_EXPERIMENTAL
doca_error_t doca_flow_port_pair(struct doca_flow_port *port, struct doca_flow_port *pair_port);
 
DOCA_STABLE
uint8_t *doca_flow_port_priv_data(struct doca_flow_port *port);
 
DOCA_EXPERIMENTAL
doca_error_t doca_flow_port_operation_state_modify(struct doca_flow_port *port,
                           enum doca_flow_port_operation_state state);
 
DOCA_EXPERIMENTAL
doca_error_t doca_flow_shared_resource_set_cfg(enum doca_flow_shared_resource_type type,
                           uint32_t id,
                           struct doca_flow_shared_resource_cfg *cfg);
 
DOCA_STABLE
doca_error_t doca_flow_shared_resources_bind(enum doca_flow_shared_resource_type type,
                         uint32_t *res_array,
                         uint32_t res_array_len,
                         void *bindable_obj);
 
DOCA_EXPERIMENTAL
doca_error_t doca_flow_shared_resources_query(enum doca_flow_shared_resource_type type,
                          uint32_t *res_array,
                          struct doca_flow_resource_query *query_results_array,
                          uint32_t array_len);
 
DOCA_EXPERIMENTAL
doca_error_t doca_flow_pipe_create(const struct doca_flow_pipe_cfg *cfg,
                   const struct doca_flow_fwd *fwd,
                   const struct doca_flow_fwd *fwd_miss,
                   struct doca_flow_pipe **pipe);
 
typedef doca_error_t (*doca_flow_pipe_resize_nr_entries_changed_cb)(void *pipe_user_ctx, uint32_t nr_entries);
 
typedef doca_error_t (*doca_flow_pipe_resize_entry_relocate_cb)(void *pipe_user_ctx,
                                uint16_t pipe_queue,
                                void *entry_user_ctx,
                                void **new_entry_user_ctx);
 
DOCA_STABLE
doca_error_t doca_flow_pipe_resize(struct doca_flow_pipe *pipe,
                   uint8_t new_congestion_level,
                   doca_flow_pipe_resize_nr_entries_changed_cb nr_entries_changed_cb,
                   doca_flow_pipe_resize_entry_relocate_cb entry_relocation_cb);
 
DOCA_EXPERIMENTAL
doca_error_t doca_flow_pipe_add_entry(uint16_t pipe_queue,
                      struct doca_flow_pipe *pipe,
                      const struct doca_flow_match *match,
                      const struct doca_flow_actions *actions,
                      const struct doca_flow_monitor *monitor,
                      const struct doca_flow_fwd *fwd,
                      uint32_t flags,
                      void *usr_ctx,
                      struct doca_flow_pipe_entry **entry);
 
DOCA_EXPERIMENTAL
doca_error_t doca_flow_pipe_update_entry(uint16_t pipe_queue,
                     struct doca_flow_pipe *pipe,
                     const struct doca_flow_actions *actions,
                     const struct doca_flow_monitor *monitor,
                     const struct doca_flow_fwd *fwd,
                     const enum doca_flow_flags_type flags,
                     struct doca_flow_pipe_entry *entry);
 
DOCA_EXPERIMENTAL
doca_error_t doca_flow_pipe_control_add_entry(uint16_t pipe_queue,
                          uint32_t priority,
                          struct doca_flow_pipe *pipe,
                          const struct doca_flow_match *match,
                          const struct doca_flow_match *match_mask,
                          const struct doca_flow_match_condition *condition,
                          const struct doca_flow_actions *actions,
                          const struct doca_flow_actions *actions_mask,
                          const struct doca_flow_action_descs *action_descs,
                          const struct doca_flow_monitor *monitor,
                          const struct doca_flow_fwd *fwd,
                          void *usr_ctx,
                          struct doca_flow_pipe_entry **entry);
 
DOCA_EXPERIMENTAL
doca_error_t doca_flow_pipe_lpm_add_entry(uint16_t pipe_queue,
                      struct doca_flow_pipe *pipe,
                      const struct doca_flow_match *match,
                      const struct doca_flow_match *match_mask,
                      const struct doca_flow_actions *actions,
                      const struct doca_flow_monitor *monitor,
                      const struct doca_flow_fwd *fwd,
                      const enum doca_flow_flags_type flag,
                      void *usr_ctx,
                      struct doca_flow_pipe_entry **entry);
 
DOCA_EXPERIMENTAL
doca_error_t doca_flow_pipe_lpm_update_entry(uint16_t pipe_queue,
                         struct doca_flow_pipe *pipe,
                         const struct doca_flow_actions *actions,
                         const struct doca_flow_monitor *monitor,
                         const struct doca_flow_fwd *fwd,
                         const enum doca_flow_flags_type flags,
                         struct doca_flow_pipe_entry *entry);
 
DOCA_EXPERIMENTAL
doca_error_t doca_flow_pipe_ordered_list_add_entry(uint16_t pipe_queue,
                           struct doca_flow_pipe *pipe,
                           uint32_t idx,
                           const struct doca_flow_ordered_list *ordered_list,
                           const struct doca_flow_fwd *fwd,
                           enum doca_flow_flags_type flags,
                           void *user_ctx,
                           struct doca_flow_pipe_entry **entry);
DOCA_EXPERIMENTAL
doca_error_t doca_flow_pipe_acl_add_entry(uint16_t pipe_queue,
                      struct doca_flow_pipe *pipe,
                      const struct doca_flow_match *match,
                      const struct doca_flow_match *match_mask,
                      const uint32_t priority,
                      const struct doca_flow_fwd *fwd,
                      const enum doca_flow_flags_type flag,
                      void *usr_ctx,
                      struct doca_flow_pipe_entry **entry);
 
DOCA_EXPERIMENTAL
doca_error_t doca_flow_pipe_hash_add_entry(uint16_t pipe_queue,
                       struct doca_flow_pipe *pipe,
                       uint32_t entry_index,
                       const struct doca_flow_actions *actions,
                       const struct doca_flow_monitor *monitor,
                       const struct doca_flow_fwd *fwd,
                       const enum doca_flow_flags_type flags,
                       void *usr_ctx,
                       struct doca_flow_pipe_entry **entry);
 
DOCA_STABLE
doca_error_t doca_flow_pipe_remove_entry(uint16_t pipe_queue, uint32_t flags, struct doca_flow_pipe_entry *entry);
 
DOCA_EXPERIMENTAL
doca_error_t doca_flow_pipe_calc_hash(struct doca_flow_pipe *pipe, const struct doca_flow_match *match, uint32_t *hash);
 
DOCA_EXPERIMENTAL
doca_error_t doca_flow_port_calc_entropy(struct doca_flow_port *port,
                     struct doca_flow_entropy_format *header,
                     uint16_t *entropy);
 
DOCA_STABLE
void doca_flow_pipe_destroy(struct doca_flow_pipe *pipe);
 
DOCA_STABLE
void doca_flow_port_pipes_flush(struct doca_flow_port *port);
 
DOCA_EXPERIMENTAL
void doca_flow_port_pipes_dump(struct doca_flow_port *port, FILE *f);
 
DOCA_EXPERIMENTAL
void doca_flow_pipe_dump(struct doca_flow_pipe *pipe, FILE *f);
 
DOCA_EXPERIMENTAL
doca_error_t doca_flow_resource_query_entry(struct doca_flow_pipe_entry *entry,
                        struct doca_flow_resource_query *query_stats);
 
DOCA_EXPERIMENTAL
doca_error_t doca_flow_resource_query_pipe_miss(struct doca_flow_pipe *pipe,
                        struct doca_flow_resource_query *query_stats);
 
DOCA_EXPERIMENTAL
doca_error_t doca_flow_pipe_update_miss(struct doca_flow_pipe *pipe, const struct doca_flow_fwd *fwd_miss);
 
DOCA_STABLE
int doca_flow_aging_handle(struct doca_flow_port *port, uint16_t queue, uint64_t quota, uint64_t max_entries);
 
DOCA_STABLE
doca_error_t doca_flow_entries_process(struct doca_flow_port *port,
                       uint16_t pipe_queue,
                       uint64_t timeout,
                       uint32_t max_processed_entries);
 
DOCA_STABLE
enum doca_flow_entry_status doca_flow_pipe_entry_get_status(struct doca_flow_pipe_entry *entry);
 
DOCA_STABLE
struct doca_flow_port *doca_flow_port_switch_get(const struct doca_flow_port *port);
 
DOCA_EXPERIMENTAL
doca_error_t doca_flow_mpls_label_encode(uint32_t label,
                     uint8_t traffic_class,
                     uint8_t ttl,
                     bool bottom_of_stack,
                     struct doca_flow_header_mpls *mpls);
 
DOCA_EXPERIMENTAL
doca_error_t doca_flow_mpls_label_decode(const struct doca_flow_header_mpls *mpls,
                     uint32_t *label,
                     uint8_t *traffic_class,
                     uint8_t *ttl,
                     bool *bottom_of_stack);
 
DOCA_EXPERIMENTAL
doca_error_t doca_flow_parser_geneve_opt_create(const struct doca_flow_port *port,
                        const struct doca_flow_parser_geneve_opt_cfg tlv_list[],
                        uint8_t nb_options,
                        struct doca_flow_parser **parser);
 
DOCA_EXPERIMENTAL
doca_error_t doca_flow_parser_geneve_opt_destroy(struct doca_flow_parser *parser);
 
DOCA_EXPERIMENTAL
doca_error_t doca_flow_get_target(enum doca_flow_target_type type, struct doca_flow_target **target);
 
DOCA_STABLE
doca_error_t doca_flow_cfg_create(struct doca_flow_cfg **cfg);
 
DOCA_STABLE
doca_error_t doca_flow_cfg_destroy(struct doca_flow_cfg *cfg);
 
DOCA_STABLE
doca_error_t doca_flow_cfg_set_pipe_queues(struct doca_flow_cfg *cfg, uint16_t pipe_queues);
 
DOCA_STABLE
doca_error_t doca_flow_cfg_set_nr_counters(struct doca_flow_cfg *cfg, uint32_t nr_counters);
 
DOCA_STABLE
doca_error_t doca_flow_cfg_set_nr_meters(struct doca_flow_cfg *cfg, uint32_t nr_meters);
 
DOCA_STABLE
doca_error_t doca_flow_cfg_set_nr_acl_collisions(struct doca_flow_cfg *cfg, uint8_t nr_acl_collisions);
 
DOCA_STABLE
doca_error_t doca_flow_cfg_set_mode_args(struct doca_flow_cfg *cfg, const char *mode_args);
 
DOCA_STABLE
doca_error_t doca_flow_cfg_set_nr_shared_resource(struct doca_flow_cfg *cfg,
                          uint32_t nr_shared_resource,
                          enum doca_flow_shared_resource_type type);
 
DOCA_STABLE
doca_error_t doca_flow_cfg_set_queue_depth(struct doca_flow_cfg *cfg, uint32_t queue_depth);
 
DOCA_STABLE
doca_error_t doca_flow_cfg_set_cb_pipe_process(struct doca_flow_cfg *cfg, doca_flow_pipe_process_cb cb);
 
DOCA_STABLE
doca_error_t doca_flow_cfg_set_cb_entry_process(struct doca_flow_cfg *cfg, doca_flow_entry_process_cb cb);
 
DOCA_STABLE
doca_error_t doca_flow_cfg_set_cb_shared_resource_unbind(struct doca_flow_cfg *cfg,
                             doca_flow_shared_resource_unbind_cb cb);
 
DOCA_STABLE
doca_error_t doca_flow_cfg_set_rss_key(struct doca_flow_cfg *cfg, const uint8_t *rss_key, uint32_t rss_key_len);
 
DOCA_EXPERIMENTAL
doca_error_t doca_flow_cfg_set_default_rss(struct doca_flow_cfg *cfg, const struct doca_flow_resource_rss_cfg *rss);
 
DOCA_EXPERIMENTAL
doca_error_t doca_flow_cfg_set_definitions(struct doca_flow_cfg *cfg, const struct doca_flow_definitions *defs);
 
DOCA_STABLE
doca_error_t doca_flow_port_cfg_create(struct doca_flow_port_cfg **cfg);
 
DOCA_STABLE
doca_error_t doca_flow_port_cfg_destroy(struct doca_flow_port_cfg *cfg);
 
DOCA_STABLE
doca_error_t doca_flow_port_cfg_set_devargs(struct doca_flow_port_cfg *cfg, const char *devargs);
 
DOCA_STABLE
doca_error_t doca_flow_port_cfg_set_priv_data_size(struct doca_flow_port_cfg *cfg, uint16_t priv_data_size);
 
DOCA_EXPERIMENTAL
doca_error_t doca_flow_port_cfg_set_dev(struct doca_flow_port_cfg *cfg, struct doca_dev *dev);
 
DOCA_EXPERIMENTAL
doca_error_t doca_flow_port_cfg_set_dev_rep(struct doca_flow_port_cfg *cfg, struct doca_dev_rep *dev);
 
DOCA_EXPERIMENTAL
doca_error_t doca_flow_port_cfg_set_port_id(struct doca_flow_port_cfg *cfg, uint16_t port_id);
 
DOCA_EXPERIMENTAL
doca_error_t doca_flow_port_cfg_set_rss_cfg(struct doca_flow_port_cfg *cfg,
                        const struct doca_flow_resource_rss_cfg *rss_cfg);
 
DOCA_STABLE
doca_error_t doca_flow_port_cfg_set_ipsec_sn_offload_disable(struct doca_flow_port_cfg *cfg);
 
DOCA_EXPERIMENTAL
doca_error_t doca_flow_port_cfg_set_operation_state(struct doca_flow_port_cfg *cfg,
                            enum doca_flow_port_operation_state state);
 
DOCA_EXPERIMENTAL
doca_error_t doca_flow_port_cfg_set_actions_mem_size(struct doca_flow_port_cfg *cfg, uint32_t size);
 
DOCA_EXPERIMENTAL
doca_error_t doca_flow_port_cfg_set_service_threads_core(struct doca_flow_port_cfg *cfg, uint32_t core);
 
DOCA_EXPERIMENTAL
doca_error_t doca_flow_port_cfg_set_service_threads_cycle(struct doca_flow_port_cfg *cfg, uint32_t cycle_ms);
 
DOCA_STABLE
doca_error_t doca_flow_pipe_cfg_create(struct doca_flow_pipe_cfg **cfg, struct doca_flow_port *port);
 
DOCA_STABLE
doca_error_t doca_flow_pipe_cfg_destroy(struct doca_flow_pipe_cfg *cfg);
 
DOCA_EXPERIMENTAL
doca_error_t doca_flow_pipe_cfg_set_match(struct doca_flow_pipe_cfg *cfg,
                      const struct doca_flow_match *match,
                      const struct doca_flow_match *match_mask);
 
DOCA_EXPERIMENTAL
doca_error_t doca_flow_pipe_cfg_set_actions(struct doca_flow_pipe_cfg *cfg,
                        struct doca_flow_actions *const *actions,
                        struct doca_flow_actions *const *actions_masks,
                        struct doca_flow_action_descs *const *action_descs,
                        size_t nr_actions);
 
DOCA_EXPERIMENTAL
doca_error_t doca_flow_pipe_cfg_set_monitor(struct doca_flow_pipe_cfg *cfg, const struct doca_flow_monitor *monitor);
 
DOCA_EXPERIMENTAL
doca_error_t doca_flow_pipe_cfg_set_ordered_lists(struct doca_flow_pipe_cfg *cfg,
                          struct doca_flow_ordered_list *const *ordered_lists,
                          size_t nr_ordered_lists);
 
DOCA_STABLE
doca_error_t doca_flow_pipe_cfg_set_name(struct doca_flow_pipe_cfg *cfg, const char *name);
 
DOCA_EXPERIMENTAL
doca_error_t doca_flow_pipe_cfg_set_label(struct doca_flow_pipe_cfg *cfg, const char *label);
 
DOCA_STABLE
doca_error_t doca_flow_pipe_cfg_set_type(struct doca_flow_pipe_cfg *cfg, enum doca_flow_pipe_type type);
 
DOCA_STABLE
doca_error_t doca_flow_pipe_cfg_set_domain(struct doca_flow_pipe_cfg *cfg, enum doca_flow_pipe_domain domain);
 
DOCA_STABLE
doca_error_t doca_flow_pipe_cfg_set_is_root(struct doca_flow_pipe_cfg *cfg, bool is_root);
 
DOCA_STABLE
doca_error_t doca_flow_pipe_cfg_set_nr_entries(struct doca_flow_pipe_cfg *cfg, uint32_t nr_entries);
 
DOCA_STABLE
doca_error_t doca_flow_pipe_cfg_set_is_resizable(struct doca_flow_pipe_cfg *cfg, bool is_resizable);
 
DOCA_EXPERIMENTAL
doca_error_t doca_flow_pipe_cfg_set_excluded_queue(struct doca_flow_pipe_cfg *cfg, uint16_t pipe_queue);
 
DOCA_EXPERIMENTAL
doca_error_t doca_flow_pipe_cfg_set_dir_info(struct doca_flow_pipe_cfg *cfg, enum doca_flow_direction_info dir_info);
 
DOCA_EXPERIMENTAL
doca_error_t doca_flow_pipe_cfg_set_miss_counter(struct doca_flow_pipe_cfg *cfg, bool miss_counter);
 
DOCA_STABLE
doca_error_t doca_flow_pipe_cfg_set_congestion_level_threshold(struct doca_flow_pipe_cfg *cfg,
                                   uint8_t congestion_level_threshold);
 
DOCA_STABLE
doca_error_t doca_flow_pipe_cfg_set_user_ctx(struct doca_flow_pipe_cfg *cfg, void *user_ctx);
 
DOCA_EXPERIMENTAL
doca_error_t doca_flow_pipe_cfg_set_hash_map_algorithm(struct doca_flow_pipe_cfg *cfg, uint32_t algorithm_flags);
 
#ifdef __cplusplus
} /* extern "C" */
#endif
 
#endif /* DOCA_FLOW_H_ */