rte_mtr.h

Go to the documentation of this file.

/*-
 *   BSD LICENSE
 *
 *   Copyright 2017 Intel Corporation
 *   Copyright 2017 NXP
 *   Copyright 2017 Cavium
 *
 *   Redistribution and use in source and binary forms, with or without
 *   modification, are permitted provided that the following conditions
 *   are met:
 *
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in
 *       the documentation and/or other materials provided with the
 *       distribution.
 *     * Neither the name of Intel Corporation nor the names of its
 *       contributors may be used to endorse or promote products derived
 *       from this software without specific prior written permission.
 *
 *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef __INCLUDE_RTE_MTR_H__
#define __INCLUDE_RTE_MTR_H__

#include <stdint.h>

#include <rte_common.h>

#ifdef __cplusplus
extern "C" {
#endif

enum rte_mtr_color {
    RTE_MTR_GREEN = 0, 
    RTE_MTR_YELLOW, 
    RTE_MTR_RED, 
    RTE_MTR_COLORS 
};

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_MTR_COLORS];

    uint64_t n_bytes[RTE_MTR_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;

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

enum rte_mtr_policer_action {
    MTR_POLICER_ACTION_COLOR_GREEN = 0,

    MTR_POLICER_ACTION_COLOR_YELLOW,

    MTR_POLICER_ACTION_COLOR_RED,

    MTR_POLICER_ACTION_DROP,
};

struct rte_mtr_params {
    uint32_t meter_profile_id;

    int use_prev_mtr_color;

    enum rte_mtr_color *dscp_table;

    int meter_enable;

    enum rte_mtr_policer_action action[RTE_MTR_COLORS];

    uint64_t stats_mask;
};

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;

    int color_aware_srtcm_rfc2697_supported;

    int color_aware_trtcm_rfc2698_supported;

    int color_aware_trtcm_rfc4115_supported;

    int policer_action_recolor_supported;

    int policer_action_drop_supported;

    uint64_t stats_mask;
};

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

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

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_dscp_table_update(uint16_t port_id,
    uint32_t mtr_id,
    enum rte_mtr_color *dscp_table,
    struct rte_mtr_error *error);

int
rte_mtr_policer_actions_update(uint16_t port_id,
    uint32_t mtr_id,
    uint32_t action_mask,
    enum rte_mtr_policer_action *actions,
    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__ */