rte_mtr.h

Go to the documentation of this file.

/* SPDX-License-Identifier: BSD-3-Clause
 * Copyright 2017 Intel Corporation
 * Copyright 2017 NXP
 * Copyright 2017 Cavium
 */
 
#ifndef __INCLUDE_RTE_MTR_H__
#define __INCLUDE_RTE_MTR_H__
 
#include <stdint.h>
#include <rte_compat.h>
#include <rte_common.h>
#include <rte_meter.h>
#include <rte_flow.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
enum rte_mtr_stats_type {
    RTE_MTR_STATS_N_PKTS_GREEN = 1 << 0,
 
    RTE_MTR_STATS_N_PKTS_YELLOW = 1 << 1,
 
    RTE_MTR_STATS_N_PKTS_RED = 1 << 2,
 
    RTE_MTR_STATS_N_PKTS_DROPPED = 1 << 3,
 
    RTE_MTR_STATS_N_BYTES_GREEN = 1 << 4,
 
    RTE_MTR_STATS_N_BYTES_YELLOW = 1 << 5,
 
    RTE_MTR_STATS_N_BYTES_RED = 1 << 6,
 
    RTE_MTR_STATS_N_BYTES_DROPPED = 1 << 7,
};
 
struct rte_mtr_stats {
    uint64_t n_pkts[RTE_COLORS];
 
    uint64_t n_bytes[RTE_COLORS];
 
    uint64_t n_pkts_dropped;
 
    uint64_t n_bytes_dropped;
};
 
enum rte_mtr_algorithm {
    RTE_MTR_NONE = 0,
 
    RTE_MTR_SRTCM_RFC2697,
 
    RTE_MTR_TRTCM_RFC2698,
 
    RTE_MTR_TRTCM_RFC4115,
};
 
struct rte_mtr_meter_profile {
    enum rte_mtr_algorithm alg;
 
    union {
        struct {
            uint64_t cir;
 
            uint64_t cbs;
 
            uint64_t ebs;
        } srtcm_rfc2697;
 
        struct {
            uint64_t cir;
 
            uint64_t pir;
 
            uint64_t cbs;
 
            uint64_t pbs;
        } trtcm_rfc2698;
 
        struct {
            uint64_t cir;
 
            uint64_t eir;
 
            uint64_t cbs;
 
            uint64_t ebs;
        } trtcm_rfc4115;
    };
 
    int packet_mode;
};
 
struct rte_mtr_meter_policy_params {
    const struct rte_flow_action *actions[RTE_COLORS];
};
 
enum rte_mtr_color_in_protocol {
    RTE_MTR_COLOR_IN_PROTO_OUTER_VLAN = RTE_BIT64(0),
    RTE_MTR_COLOR_IN_PROTO_INNER_VLAN = RTE_BIT64(1),
    RTE_MTR_COLOR_IN_PROTO_OUTER_IP = RTE_BIT64(2),
    RTE_MTR_COLOR_IN_PROTO_INNER_IP = RTE_BIT64(3),
};
 
struct rte_mtr_params {
    uint32_t meter_profile_id;
 
    int use_prev_mtr_color;
 
    enum rte_color *dscp_table;
    enum rte_color *vlan_table;
    int meter_enable;
 
    uint64_t stats_mask;
 
    uint32_t meter_policy_id;
 
    enum rte_color default_input_color;
};
 
struct rte_mtr_capabilities {
    uint32_t n_max;
 
    uint32_t n_shared_max;
 
    int identical;
 
    int shared_identical;
 
    uint32_t shared_n_flows_per_mtr_max;
 
    uint32_t chaining_n_mtrs_per_flow_max;
 
    int chaining_use_prev_mtr_color_supported;
 
    int chaining_use_prev_mtr_color_enforced;
 
    uint32_t meter_srtcm_rfc2697_n_max;
 
    uint32_t meter_trtcm_rfc2698_n_max;
 
    uint32_t meter_trtcm_rfc4115_n_max;
 
    uint64_t meter_rate_max;
 
    uint64_t meter_policy_n_max;
 
    int color_aware_srtcm_rfc2697_supported;
 
    int color_aware_trtcm_rfc2698_supported;
 
    int color_aware_trtcm_rfc4115_supported;
 
    int srtcm_rfc2697_byte_mode_supported;
 
    int srtcm_rfc2697_packet_mode_supported;
 
    int trtcm_rfc2698_byte_mode_supported;
 
    int trtcm_rfc2698_packet_mode_supported;
 
    int trtcm_rfc4115_byte_mode_supported;
 
    int trtcm_rfc4115_packet_mode_supported;
 
    uint64_t stats_mask;
 
    uint64_t input_color_proto_mask;
 
    int separate_input_color_table_per_port;
};
 
enum rte_mtr_error_type {
    RTE_MTR_ERROR_TYPE_NONE, 
    RTE_MTR_ERROR_TYPE_UNSPECIFIED, 
    RTE_MTR_ERROR_TYPE_METER_PROFILE_ID,
    RTE_MTR_ERROR_TYPE_METER_PROFILE,
    RTE_MTR_ERROR_TYPE_METER_PROFILE_PACKET_MODE,
    RTE_MTR_ERROR_TYPE_MTR_ID,
    RTE_MTR_ERROR_TYPE_MTR_PARAMS,
    RTE_MTR_ERROR_TYPE_POLICER_ACTION_GREEN,
    RTE_MTR_ERROR_TYPE_POLICER_ACTION_YELLOW,
    RTE_MTR_ERROR_TYPE_POLICER_ACTION_RED,
    RTE_MTR_ERROR_TYPE_STATS_MASK,
    RTE_MTR_ERROR_TYPE_STATS,
    RTE_MTR_ERROR_TYPE_SHARED,
    RTE_MTR_ERROR_TYPE_METER_POLICY_ID,
    RTE_MTR_ERROR_TYPE_METER_POLICY,
};
 
struct rte_mtr_error {
    enum rte_mtr_error_type type; 
    const void *cause; 
    const char *message; 
};
 
int
rte_mtr_capabilities_get(uint16_t port_id,
    struct rte_mtr_capabilities *cap,
    struct rte_mtr_error *error);
 
int
rte_mtr_meter_profile_add(uint16_t port_id,
    uint32_t meter_profile_id,
    struct rte_mtr_meter_profile *profile,
    struct rte_mtr_error *error);
 
int
rte_mtr_meter_profile_delete(uint16_t port_id,
    uint32_t meter_profile_id,
    struct rte_mtr_error *error);
 
struct rte_flow_meter_profile *
rte_mtr_meter_profile_get(uint16_t port_id,
    uint32_t meter_profile_id,
    struct rte_mtr_error *error);
 
int
rte_mtr_meter_policy_validate(uint16_t port_id,
    struct rte_mtr_meter_policy_params *policy,
    struct rte_mtr_error *error);
 
int
rte_mtr_meter_policy_add(uint16_t port_id,
    uint32_t policy_id,
    struct rte_mtr_meter_policy_params *policy,
    struct rte_mtr_error *error);
 
struct rte_flow_meter_policy *
rte_mtr_meter_policy_get(uint16_t port_id,
    uint32_t policy_id,
    struct rte_mtr_error *error);
 
#define rte_mtr_policy_pass_color(policy) \
struct rte_mtr_meter_policy_params policy = \
{ \
    .actions[RTE_COLOR_GREEN] = (struct rte_flow_action[]) { \
        { \
            .type = RTE_FLOW_ACTION_TYPE_METER_COLOR, \
            .conf = &(struct rte_flow_action_meter_color) { \
                .color = RTE_COLOR_GREEN, \
            }, \
        }, \
        { \
            .type = RTE_FLOW_ACTION_TYPE_END, \
        }, \
    }, \
    .actions[RTE_COLOR_YELLOW] = (struct rte_flow_action[]) { \
        { \
            .type = RTE_FLOW_ACTION_TYPE_METER_COLOR, \
            .conf = &(struct rte_flow_action_meter_color) { \
                .color = RTE_COLOR_YELLOW, \
            }, \
        }, \
        { \
        .type = RTE_FLOW_ACTION_TYPE_END, \
        }, \
    }, \
    .actions[RTE_COLOR_RED] = (struct rte_flow_action[]) { \
        { \
            .type = RTE_FLOW_ACTION_TYPE_METER_COLOR, \
            .conf = &(struct rte_flow_action_meter_color) { \
                .color = RTE_COLOR_RED, \
            }, \
        }, \
        { \
            .type = RTE_FLOW_ACTION_TYPE_END, \
        }, \
    }, \
}
 
#define rte_mtr_policy_drop_red(policy) \
struct rte_mtr_meter_policy_params policy = \
{ \
    .actions[RTE_COLOR_GREEN] = NULL, \
    .actions[RTE_COLOR_YELLOW] = NULL, \
    .actions[RTE_COLOR_RED] = (struct rte_flow_action[]) { \
        { \
            .type = RTE_FLOW_ACTION_TYPE_DROP, \
        }, \
        { \
            .type = RTE_FLOW_ACTION_TYPE_END, \
        }, \
    }, \
}
 
int
rte_mtr_meter_policy_delete(uint16_t port_id,
    uint32_t policy_id,
    struct rte_mtr_error *error);
 
int
rte_mtr_create(uint16_t port_id,
    uint32_t mtr_id,
    struct rte_mtr_params *params,
    int shared,
    struct rte_mtr_error *error);
 
int
rte_mtr_destroy(uint16_t port_id,
    uint32_t mtr_id,
    struct rte_mtr_error *error);
 
int
rte_mtr_meter_disable(uint16_t port_id,
    uint32_t mtr_id,
    struct rte_mtr_error *error);
 
int
rte_mtr_meter_enable(uint16_t port_id,
    uint32_t mtr_id,
    struct rte_mtr_error *error);
 
int
rte_mtr_meter_profile_update(uint16_t port_id,
    uint32_t mtr_id,
    uint32_t meter_profile_id,
    struct rte_mtr_error *error);
 
int
rte_mtr_meter_policy_update(uint16_t port_id,
    uint32_t mtr_id,
    uint32_t meter_policy_id,
    struct rte_mtr_error *error);
 
int
rte_mtr_meter_dscp_table_update(uint16_t port_id,
    uint32_t mtr_id, enum rte_mtr_color_in_protocol proto,
    enum rte_color *dscp_table,
    struct rte_mtr_error *error);
 
int
rte_mtr_meter_vlan_table_update(uint16_t port_id, uint32_t mtr_id,
                enum rte_mtr_color_in_protocol proto,
                enum rte_color *vlan_table,
                struct rte_mtr_error *error);
 
int
rte_mtr_color_in_protocol_set(uint16_t port_id, uint32_t mtr_id,
    enum rte_mtr_color_in_protocol proto, uint32_t priority,
    struct rte_mtr_error *error);
 
int
rte_mtr_color_in_protocol_get(uint16_t port_id, uint32_t mtr_id,
    uint64_t *proto_mask,
    struct rte_mtr_error *error);
 
int
rte_mtr_color_in_protocol_priority_get(uint16_t port_id, uint32_t mtr_id,
    enum rte_mtr_color_in_protocol proto, uint32_t *priority,
    struct rte_mtr_error *error);
 
int
rte_mtr_stats_update(uint16_t port_id,
    uint32_t mtr_id,
    uint64_t stats_mask,
    struct rte_mtr_error *error);
 
int
rte_mtr_stats_read(uint16_t port_id,
    uint32_t mtr_id,
    struct rte_mtr_stats *stats,
    uint64_t *stats_mask,
    int clear,
    struct rte_mtr_error *error);
 
#ifdef __cplusplus
}
#endif
 
#endif /* __INCLUDE_RTE_MTR_H__ */