[RTE_MTR_ERROR_TYPE_STATS] = "stats",
[RTE_MTR_ERROR_TYPE_SHARED]
= "shared meter",
+ [RTE_MTR_ERROR_TYPE_METER_POLICY_ID] = "meter policy id",
+ [RTE_MTR_ERROR_TYPE_METER_POLICY] = "meter policy null",
};
const char *errstr;
error->type);
}
+void
+print_mtr_err_msg(struct rte_mtr_error *error)
+{
+ print_err_msg(error);
+}
+
static int
parse_uint(uint64_t *value, const char *str)
{
}
static int
-parse_dscp_table_entries(char *str, enum rte_mtr_color *dscp_table)
+parse_dscp_table_entries(char *str, enum rte_color **dscp_table)
{
char *token;
int i = 0;
return 0;
/* Allocate memory for dscp table */
- dscp_table = (enum rte_mtr_color *)malloc(MAX_DSCP_TABLE_ENTRIES *
- sizeof(enum rte_mtr_color));
- if (dscp_table == NULL)
+ *dscp_table = (enum rte_color *)malloc(MAX_DSCP_TABLE_ENTRIES *
+ sizeof(enum rte_color));
+ if (*dscp_table == NULL)
return -1;
while (1) {
if (strcmp(token, "G") == 0 ||
strcmp(token, "g") == 0)
- dscp_table[i++] = RTE_MTR_GREEN;
+ *dscp_table[i++] = RTE_COLOR_GREEN;
else if (strcmp(token, "Y") == 0 ||
strcmp(token, "y") == 0)
- dscp_table[i++] = RTE_MTR_YELLOW;
+ *dscp_table[i++] = RTE_COLOR_YELLOW;
else if (strcmp(token, "R") == 0 ||
strcmp(token, "r") == 0)
- dscp_table[i++] = RTE_MTR_RED;
+ *dscp_table[i++] = RTE_COLOR_RED;
else {
- free(dscp_table);
+ free(*dscp_table);
return -1;
}
if (i == MAX_DSCP_TABLE_ENTRIES)
token = strtok_r(str, PARSE_DELIMITER, &str);
if (token == NULL) {
- free(dscp_table);
+ free(*dscp_table);
return -1;
}
}
static int
parse_meter_color_str(char *c_str, uint32_t *use_prev_meter_color,
- enum rte_mtr_color *dscp_table)
+ enum rte_color **dscp_table)
{
char *token;
uint64_t previous_mtr_color = 0;
return 0;
}
-static int
-string_to_policer_action(char *s)
-{
- if ((strcmp(s, "G") == 0) || (strcmp(s, "g") == 0))
- return MTR_POLICER_ACTION_COLOR_GREEN;
-
- if ((strcmp(s, "Y") == 0) || (strcmp(s, "y") == 0))
- return MTR_POLICER_ACTION_COLOR_YELLOW;
-
- if ((strcmp(s, "R") == 0) || (strcmp(s, "r") == 0))
- return MTR_POLICER_ACTION_COLOR_RED;
-
- if ((strcmp(s, "D") == 0) || (strcmp(s, "d") == 0))
- return MTR_POLICER_ACTION_DROP;
-
- return -1;
-}
-
-static int
-parse_policer_action_string(char *p_str, uint32_t action_mask,
- enum rte_mtr_policer_action actions[])
-{
- char *token;
- int count = __builtin_popcount(action_mask);
- int g_color = 0, y_color = 0, action, i;
-
- for (i = 0; i < count; i++) {
- token = strtok_r(p_str, PARSE_DELIMITER, &p_str);
- if (token == NULL)
- return -1;
-
- action = string_to_policer_action(token);
- if (action == -1)
- return -1;
-
- if (g_color == 0 && (action_mask & 0x1)) {
- actions[RTE_MTR_GREEN] = action;
- g_color = 1;
- } else if (y_color == 0 && (action_mask & 0x2)) {
- actions[RTE_MTR_YELLOW] = action;
- y_color = 1;
- } else
- actions[RTE_MTR_RED] = action;
- }
- return 0;
-}
-
static int
parse_multi_token_string(char *t_str, uint16_t *port_id,
- uint32_t *mtr_id, enum rte_mtr_color *dscp_table)
+ uint32_t *mtr_id, enum rte_color **dscp_table)
{
char *token;
uint64_t val;
struct cmd_show_port_meter_cap_result, cap, "cap");
cmdline_parse_token_num_t cmd_show_port_meter_cap_port_id =
TOKEN_NUM_INITIALIZER(
- struct cmd_show_port_meter_cap_result, port_id, UINT16);
+ struct cmd_show_port_meter_cap_result, port_id, RTE_UINT16);
static void cmd_show_port_meter_cap_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_show_port_meter_cap_result *res = parsed_result;
struct rte_mtr_capabilities cap;
cap.color_aware_trtcm_rfc2698_supported);
printf("cap.color_aware_trtcm_rfc4115_supported %" PRId32 "\n",
cap.color_aware_trtcm_rfc4115_supported);
- printf("cap.policer_action_recolor_supported %" PRId32 "\n",
- cap.policer_action_recolor_supported);
- printf("cap.policer_action_drop_supported %" PRId32 "\n",
- cap.policer_action_drop_supported);
+ printf("cap.srtcm_rfc2697_byte_mode_supported %" PRId32 "\n",
+ cap.srtcm_rfc2697_byte_mode_supported);
+ printf("cap.srtcm_rfc2697_packet_mode_supported %" PRId32 "\n",
+ cap.srtcm_rfc2697_packet_mode_supported);
+ printf("cap.trtcm_rfc2698_byte_mode_supported %" PRId32 "\n",
+ cap.trtcm_rfc2698_byte_mode_supported);
+ printf("cap.trtcm_rfc2698_packet_mode_supported %" PRId32 "\n",
+ cap.trtcm_rfc2698_packet_mode_supported);
+ printf("cap.trtcm_rfc4115_byte_mode_supported %" PRId32 "\n",
+ cap.trtcm_rfc4115_byte_mode_supported);
+ printf("cap.trtcm_rfc4115_packet_mode_supported %" PRId32 "\n",
+ cap.trtcm_rfc4115_packet_mode_supported);
printf("cap.stats_mask %" PRIx64 "\n", cap.stats_mask);
}
cmdline_parse_inst_t cmd_show_port_meter_cap = {
.f = cmd_show_port_meter_cap_parsed,
.data = NULL,
- .help_str = "Show port meter cap",
+ .help_str = "show port meter cap <port_id>",
.tokens = {
(void *)&cmd_show_port_meter_cap_show,
(void *)&cmd_show_port_meter_cap_port,
uint64_t cir;
uint64_t cbs;
uint64_t ebs;
+ int packet_mode;
};
cmdline_parse_token_string_t cmd_add_port_meter_profile_srtcm_add =
cmdline_parse_token_num_t cmd_add_port_meter_profile_srtcm_port_id =
TOKEN_NUM_INITIALIZER(
struct cmd_add_port_meter_profile_srtcm_result,
- port_id, UINT16);
+ port_id, RTE_UINT16);
cmdline_parse_token_num_t cmd_add_port_meter_profile_srtcm_profile_id =
TOKEN_NUM_INITIALIZER(
struct cmd_add_port_meter_profile_srtcm_result,
- profile_id, UINT32);
+ profile_id, RTE_UINT32);
cmdline_parse_token_num_t cmd_add_port_meter_profile_srtcm_cir =
TOKEN_NUM_INITIALIZER(
struct cmd_add_port_meter_profile_srtcm_result,
- cir, UINT64);
+ cir, RTE_UINT64);
cmdline_parse_token_num_t cmd_add_port_meter_profile_srtcm_cbs =
TOKEN_NUM_INITIALIZER(
struct cmd_add_port_meter_profile_srtcm_result,
- cbs, UINT64);
+ cbs, RTE_UINT64);
cmdline_parse_token_num_t cmd_add_port_meter_profile_srtcm_ebs =
TOKEN_NUM_INITIALIZER(
struct cmd_add_port_meter_profile_srtcm_result,
- ebs, UINT64);
+ ebs, RTE_UINT64);
+cmdline_parse_token_num_t cmd_add_port_meter_profile_srtcm_packet_mode =
+ TOKEN_NUM_INITIALIZER(
+ struct cmd_add_port_meter_profile_srtcm_result,
+ packet_mode, RTE_UINT32);
static void cmd_add_port_meter_profile_srtcm_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_add_port_meter_profile_srtcm_result *res = parsed_result;
struct rte_mtr_meter_profile mp;
mp.srtcm_rfc2697.cir = res->cir;
mp.srtcm_rfc2697.cbs = res->cbs;
mp.srtcm_rfc2697.ebs = res->ebs;
+ mp.packet_mode = res->packet_mode;
ret = rte_mtr_meter_profile_add(port_id, profile_id, &mp, &error);
if (ret != 0) {
cmdline_parse_inst_t cmd_add_port_meter_profile_srtcm = {
.f = cmd_add_port_meter_profile_srtcm_parsed,
.data = NULL,
- .help_str = "Add port meter profile srtcm (rfc2697)",
+ .help_str = "add port meter profile srtcm_rfc2697 <port_id> <profile_id> <cir> <cbs> <ebs> <packet_mode>",
.tokens = {
(void *)&cmd_add_port_meter_profile_srtcm_add,
(void *)&cmd_add_port_meter_profile_srtcm_port,
(void *)&cmd_add_port_meter_profile_srtcm_cir,
(void *)&cmd_add_port_meter_profile_srtcm_cbs,
(void *)&cmd_add_port_meter_profile_srtcm_ebs,
+ (void *)&cmd_add_port_meter_profile_srtcm_packet_mode,
NULL,
},
};
uint64_t pir;
uint64_t cbs;
uint64_t pbs;
+ int packet_mode;
};
cmdline_parse_token_string_t cmd_add_port_meter_profile_trtcm_add =
cmdline_parse_token_num_t cmd_add_port_meter_profile_trtcm_port_id =
TOKEN_NUM_INITIALIZER(
struct cmd_add_port_meter_profile_trtcm_result,
- port_id, UINT16);
+ port_id, RTE_UINT16);
cmdline_parse_token_num_t cmd_add_port_meter_profile_trtcm_profile_id =
TOKEN_NUM_INITIALIZER(
struct cmd_add_port_meter_profile_trtcm_result,
- profile_id, UINT32);
+ profile_id, RTE_UINT32);
cmdline_parse_token_num_t cmd_add_port_meter_profile_trtcm_cir =
TOKEN_NUM_INITIALIZER(
struct cmd_add_port_meter_profile_trtcm_result,
- cir, UINT64);
+ cir, RTE_UINT64);
cmdline_parse_token_num_t cmd_add_port_meter_profile_trtcm_pir =
TOKEN_NUM_INITIALIZER(
struct cmd_add_port_meter_profile_trtcm_result,
- pir, UINT64);
+ pir, RTE_UINT64);
cmdline_parse_token_num_t cmd_add_port_meter_profile_trtcm_cbs =
TOKEN_NUM_INITIALIZER(
struct cmd_add_port_meter_profile_trtcm_result,
- cbs, UINT64);
+ cbs, RTE_UINT64);
cmdline_parse_token_num_t cmd_add_port_meter_profile_trtcm_pbs =
TOKEN_NUM_INITIALIZER(
struct cmd_add_port_meter_profile_trtcm_result,
- pbs, UINT64);
+ pbs, RTE_UINT64);
+cmdline_parse_token_num_t cmd_add_port_meter_profile_trtcm_packet_mode =
+ TOKEN_NUM_INITIALIZER(
+ struct cmd_add_port_meter_profile_trtcm_result,
+ packet_mode, RTE_UINT32);
static void cmd_add_port_meter_profile_trtcm_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_add_port_meter_profile_trtcm_result *res = parsed_result;
struct rte_mtr_meter_profile mp;
mp.trtcm_rfc2698.pir = res->pir;
mp.trtcm_rfc2698.cbs = res->cbs;
mp.trtcm_rfc2698.pbs = res->pbs;
+ mp.packet_mode = res->packet_mode;
ret = rte_mtr_meter_profile_add(port_id, profile_id, &mp, &error);
if (ret != 0) {
cmdline_parse_inst_t cmd_add_port_meter_profile_trtcm = {
.f = cmd_add_port_meter_profile_trtcm_parsed,
.data = NULL,
- .help_str = "Add port meter profile trtcm (rfc2698)",
+ .help_str = "add port meter profile trtcm_rfc2698 <port_id> <profile_id> <cir> <pir> <cbs> <pbs> <packet_mode>",
.tokens = {
(void *)&cmd_add_port_meter_profile_trtcm_add,
(void *)&cmd_add_port_meter_profile_trtcm_port,
(void *)&cmd_add_port_meter_profile_trtcm_pir,
(void *)&cmd_add_port_meter_profile_trtcm_cbs,
(void *)&cmd_add_port_meter_profile_trtcm_pbs,
+ (void *)&cmd_add_port_meter_profile_trtcm_packet_mode,
NULL,
},
};
uint64_t eir;
uint64_t cbs;
uint64_t ebs;
+ int packet_mode;
};
cmdline_parse_token_string_t cmd_add_port_meter_profile_trtcm_rfc4115_add =
cmdline_parse_token_num_t cmd_add_port_meter_profile_trtcm_rfc4115_port_id =
TOKEN_NUM_INITIALIZER(
struct cmd_add_port_meter_profile_trtcm_rfc4115_result,
- port_id, UINT16);
+ port_id, RTE_UINT16);
cmdline_parse_token_num_t cmd_add_port_meter_profile_trtcm_rfc4115_profile_id =
TOKEN_NUM_INITIALIZER(
struct cmd_add_port_meter_profile_trtcm_rfc4115_result,
- profile_id, UINT32);
+ profile_id, RTE_UINT32);
cmdline_parse_token_num_t cmd_add_port_meter_profile_trtcm_rfc4115_cir =
TOKEN_NUM_INITIALIZER(
struct cmd_add_port_meter_profile_trtcm_rfc4115_result,
- cir, UINT64);
+ cir, RTE_UINT64);
cmdline_parse_token_num_t cmd_add_port_meter_profile_trtcm_rfc4115_eir =
TOKEN_NUM_INITIALIZER(
struct cmd_add_port_meter_profile_trtcm_rfc4115_result,
- eir, UINT64);
+ eir, RTE_UINT64);
cmdline_parse_token_num_t cmd_add_port_meter_profile_trtcm_rfc4115_cbs =
TOKEN_NUM_INITIALIZER(
struct cmd_add_port_meter_profile_trtcm_rfc4115_result,
- cbs, UINT64);
+ cbs, RTE_UINT64);
cmdline_parse_token_num_t cmd_add_port_meter_profile_trtcm_rfc4115_ebs =
TOKEN_NUM_INITIALIZER(
struct cmd_add_port_meter_profile_trtcm_rfc4115_result,
- ebs, UINT64);
+ ebs, RTE_UINT64);
+cmdline_parse_token_num_t
+ cmd_add_port_meter_profile_trtcm_rfc4115_packet_mode =
+ TOKEN_NUM_INITIALIZER(
+ struct cmd_add_port_meter_profile_trtcm_rfc4115_result,
+ packet_mode, RTE_UINT32);
static void cmd_add_port_meter_profile_trtcm_rfc4115_parsed(
void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_add_port_meter_profile_trtcm_rfc4115_result *res =
parsed_result;
mp.trtcm_rfc4115.eir = res->eir;
mp.trtcm_rfc4115.cbs = res->cbs;
mp.trtcm_rfc4115.ebs = res->ebs;
+ mp.packet_mode = res->packet_mode;
ret = rte_mtr_meter_profile_add(port_id, profile_id, &mp, &error);
if (ret != 0) {
cmdline_parse_inst_t cmd_add_port_meter_profile_trtcm_rfc4115 = {
.f = cmd_add_port_meter_profile_trtcm_rfc4115_parsed,
.data = NULL,
- .help_str = "Add port meter profile trtcm (rfc4115)",
+ .help_str = "add port meter profile trtcm_rfc4115 <port_id> <profile_id> <cir> <eir> <cbs> <ebs> <packet_mode>",
.tokens = {
(void *)&cmd_add_port_meter_profile_trtcm_rfc4115_add,
(void *)&cmd_add_port_meter_profile_trtcm_rfc4115_port,
(void *)&cmd_add_port_meter_profile_trtcm_rfc4115_eir,
(void *)&cmd_add_port_meter_profile_trtcm_rfc4115_cbs,
(void *)&cmd_add_port_meter_profile_trtcm_rfc4115_ebs,
+ (void *)&cmd_add_port_meter_profile_trtcm_rfc4115_packet_mode,
NULL,
},
};
cmdline_parse_token_num_t cmd_del_port_meter_profile_port_id =
TOKEN_NUM_INITIALIZER(
struct cmd_del_port_meter_profile_result,
- port_id, UINT16);
+ port_id, RTE_UINT16);
cmdline_parse_token_num_t cmd_del_port_meter_profile_profile_id =
TOKEN_NUM_INITIALIZER(
struct cmd_del_port_meter_profile_result,
- profile_id, UINT32);
+ profile_id, RTE_UINT32);
static void cmd_del_port_meter_profile_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_del_port_meter_profile_result *res = parsed_result;
struct rte_mtr_error error;
cmdline_parse_inst_t cmd_del_port_meter_profile = {
.f = cmd_del_port_meter_profile_parsed,
.data = NULL,
- .help_str = "Delete port meter profile",
+ .help_str = "del port meter profile <port_id> <profile_id>",
.tokens = {
(void *)&cmd_del_port_meter_profile_del,
(void *)&cmd_del_port_meter_profile_port,
uint16_t port_id;
uint32_t mtr_id;
uint32_t profile_id;
+ uint32_t policy_id;
cmdline_fixed_string_t meter_enable;
cmdline_fixed_string_t g_action;
cmdline_fixed_string_t y_action;
struct cmd_create_port_meter_result, meter, "meter");
cmdline_parse_token_num_t cmd_create_port_meter_port_id =
TOKEN_NUM_INITIALIZER(
- struct cmd_create_port_meter_result, port_id, UINT16);
+ struct cmd_create_port_meter_result, port_id, RTE_UINT16);
cmdline_parse_token_num_t cmd_create_port_meter_mtr_id =
TOKEN_NUM_INITIALIZER(
- struct cmd_create_port_meter_result, mtr_id, UINT32);
+ struct cmd_create_port_meter_result, mtr_id, RTE_UINT32);
cmdline_parse_token_num_t cmd_create_port_meter_profile_id =
TOKEN_NUM_INITIALIZER(
- struct cmd_create_port_meter_result, profile_id, UINT32);
+ struct cmd_create_port_meter_result, profile_id, RTE_UINT32);
+cmdline_parse_token_num_t cmd_create_port_meter_policy_id =
+ TOKEN_NUM_INITIALIZER(
+ struct cmd_create_port_meter_result, policy_id, RTE_UINT32);
cmdline_parse_token_string_t cmd_create_port_meter_meter_enable =
TOKEN_STRING_INITIALIZER(struct cmd_create_port_meter_result,
meter_enable, "yes#no");
r_action, "R#Y#G#D#r#y#g#d");
cmdline_parse_token_num_t cmd_create_port_meter_statistics_mask =
TOKEN_NUM_INITIALIZER(struct cmd_create_port_meter_result,
- statistics_mask, UINT64);
+ statistics_mask, RTE_UINT64);
cmdline_parse_token_num_t cmd_create_port_meter_shared =
TOKEN_NUM_INITIALIZER(struct cmd_create_port_meter_result,
- shared, UINT32);
+ shared, RTE_UINT32);
cmdline_parse_token_string_t cmd_create_port_meter_input_color =
TOKEN_STRING_INITIALIZER(struct cmd_create_port_meter_result,
meter_input_color, TOKEN_STRING_MULTI);
static void cmd_create_port_meter_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_create_port_meter_result *res = parsed_result;
struct rte_mtr_error error;
uint32_t shared = res->shared;
uint32_t use_prev_meter_color = 0;
uint16_t port_id = res->port_id;
- enum rte_mtr_color *dscp_table = NULL;
+ enum rte_color *dscp_table = NULL;
char *c_str = res->meter_input_color;
int ret;
/* Meter params */
memset(¶ms, 0, sizeof(struct rte_mtr_params));
params.meter_profile_id = res->profile_id;
-
+ params.meter_policy_id = res->policy_id;
/* Parse meter input color string params */
- ret = parse_meter_color_str(c_str, &use_prev_meter_color, dscp_table);
+ ret = parse_meter_color_str(c_str, &use_prev_meter_color, &dscp_table);
if (ret) {
printf(" Meter input color params string parse error\n");
return;
params.meter_enable = 1;
else
params.meter_enable = 0;
-
- params.action[RTE_MTR_GREEN] =
- string_to_policer_action(res->g_action);
- params.action[RTE_MTR_YELLOW] =
- string_to_policer_action(res->y_action);
- params.action[RTE_MTR_RED] =
- string_to_policer_action(res->r_action);
params.stats_mask = res->statistics_mask;
ret = rte_mtr_create(port_id, mtr_id, ¶ms, shared, &error);
cmdline_parse_inst_t cmd_create_port_meter = {
.f = cmd_create_port_meter_parsed,
.data = NULL,
- .help_str = "Create port meter",
+ .help_str = "create port meter <port_id> <mtr_id> <profile_id> <meter_enable>(yes|no) "
+ "<stats_mask> <shared> <use_pre_meter_color> "
+ "[<dscp_tbl_entry0> <dscp_tbl_entry1> ...<dscp_tbl_entry63>]",
.tokens = {
(void *)&cmd_create_port_meter_create,
(void *)&cmd_create_port_meter_port,
(void *)&cmd_create_port_meter_port_id,
(void *)&cmd_create_port_meter_mtr_id,
(void *)&cmd_create_port_meter_profile_id,
+ (void *)&cmd_create_port_meter_policy_id,
(void *)&cmd_create_port_meter_meter_enable,
- (void *)&cmd_create_port_meter_g_action,
- (void *)&cmd_create_port_meter_y_action,
- (void *)&cmd_create_port_meter_r_action,
(void *)&cmd_create_port_meter_statistics_mask,
(void *)&cmd_create_port_meter_shared,
(void *)&cmd_create_port_meter_input_color,
struct cmd_enable_port_meter_result, meter, "meter");
cmdline_parse_token_num_t cmd_enable_port_meter_port_id =
TOKEN_NUM_INITIALIZER(
- struct cmd_enable_port_meter_result, port_id, UINT16);
+ struct cmd_enable_port_meter_result, port_id, RTE_UINT16);
cmdline_parse_token_num_t cmd_enable_port_meter_mtr_id =
TOKEN_NUM_INITIALIZER(
- struct cmd_enable_port_meter_result, mtr_id, UINT32);
+ struct cmd_enable_port_meter_result, mtr_id, RTE_UINT32);
static void cmd_enable_port_meter_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_enable_port_meter_result *res = parsed_result;
struct rte_mtr_error error;
cmdline_parse_inst_t cmd_enable_port_meter = {
.f = cmd_enable_port_meter_parsed,
.data = NULL,
- .help_str = "Enable port meter",
+ .help_str = "enable port meter <port_id> <mtr_id>",
.tokens = {
(void *)&cmd_enable_port_meter_enable,
(void *)&cmd_enable_port_meter_port,
struct cmd_disable_port_meter_result, meter, "meter");
cmdline_parse_token_num_t cmd_disable_port_meter_port_id =
TOKEN_NUM_INITIALIZER(
- struct cmd_disable_port_meter_result, port_id, UINT16);
+ struct cmd_disable_port_meter_result, port_id, RTE_UINT16);
cmdline_parse_token_num_t cmd_disable_port_meter_mtr_id =
TOKEN_NUM_INITIALIZER(
- struct cmd_disable_port_meter_result, mtr_id, UINT32);
+ struct cmd_disable_port_meter_result, mtr_id, RTE_UINT32);
static void cmd_disable_port_meter_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_disable_port_meter_result *res = parsed_result;
struct rte_mtr_error error;
cmdline_parse_inst_t cmd_disable_port_meter = {
.f = cmd_disable_port_meter_parsed,
.data = NULL,
- .help_str = "Disable port meter",
+ .help_str = "disable port meter <port_id> <mtr_id>",
.tokens = {
(void *)&cmd_disable_port_meter_disable,
(void *)&cmd_disable_port_meter_port,
},
};
+/* *** Delete Port Meter Policy Object *** */
+struct cmd_del_port_meter_policy_result {
+ cmdline_fixed_string_t del;
+ cmdline_fixed_string_t port;
+ cmdline_fixed_string_t meter;
+ cmdline_fixed_string_t policy;
+ uint16_t port_id;
+ uint32_t policy_id;
+};
+
+cmdline_parse_token_string_t cmd_del_port_meter_policy_del =
+ TOKEN_STRING_INITIALIZER(
+ struct cmd_del_port_meter_policy_result, del, "del");
+cmdline_parse_token_string_t cmd_del_port_meter_policy_port =
+ TOKEN_STRING_INITIALIZER(
+ struct cmd_del_port_meter_policy_result, port, "port");
+cmdline_parse_token_string_t cmd_del_port_meter_policy_meter =
+ TOKEN_STRING_INITIALIZER(
+ struct cmd_del_port_meter_policy_result, meter, "meter");
+cmdline_parse_token_string_t cmd_del_port_meter_policy_policy =
+ TOKEN_STRING_INITIALIZER(
+ struct cmd_del_port_meter_policy_result, policy, "policy");
+cmdline_parse_token_num_t cmd_del_port_meter_policy_port_id =
+ TOKEN_NUM_INITIALIZER(
+ struct cmd_del_port_meter_policy_result, port_id, RTE_UINT16);
+cmdline_parse_token_num_t cmd_del_port_meter_policy_policy_id =
+ TOKEN_NUM_INITIALIZER(
+ struct cmd_del_port_meter_policy_result, policy_id, RTE_UINT32);
+
+static void cmd_del_port_meter_policy_parsed(void *parsed_result,
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
+{
+ struct cmd_del_port_meter_policy_result *res = parsed_result;
+ struct rte_mtr_error error;
+ uint32_t policy_id = res->policy_id;
+ uint16_t port_id = res->port_id;
+ int ret;
+
+ if (port_id_is_invalid(port_id, ENABLED_WARN))
+ return;
+
+ /* Delete Meter Policy*/
+ ret = rte_mtr_meter_policy_delete(port_id, policy_id, &error);
+ if (ret != 0) {
+ print_err_msg(&error);
+ return;
+ }
+}
+
+cmdline_parse_inst_t cmd_del_port_meter_policy = {
+ .f = cmd_del_port_meter_policy_parsed,
+ .data = NULL,
+ .help_str = "Delete port meter policy",
+ .tokens = {
+ (void *)&cmd_del_port_meter_policy_del,
+ (void *)&cmd_del_port_meter_policy_port,
+ (void *)&cmd_del_port_meter_policy_meter,
+ (void *)&cmd_del_port_meter_policy_policy,
+ (void *)&cmd_del_port_meter_policy_port_id,
+ (void *)&cmd_del_port_meter_policy_policy_id,
+ NULL,
+ },
+};
+
/* *** Delete Port Meter Object *** */
struct cmd_del_port_meter_result {
cmdline_fixed_string_t del;
struct cmd_del_port_meter_result, meter, "meter");
cmdline_parse_token_num_t cmd_del_port_meter_port_id =
TOKEN_NUM_INITIALIZER(
- struct cmd_del_port_meter_result, port_id, UINT16);
+ struct cmd_del_port_meter_result, port_id, RTE_UINT16);
cmdline_parse_token_num_t cmd_del_port_meter_mtr_id =
TOKEN_NUM_INITIALIZER(
- struct cmd_del_port_meter_result, mtr_id, UINT32);
+ struct cmd_del_port_meter_result, mtr_id, RTE_UINT32);
static void cmd_del_port_meter_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_del_port_meter_result *res = parsed_result;
struct rte_mtr_error error;
cmdline_parse_inst_t cmd_del_port_meter = {
.f = cmd_del_port_meter_parsed,
.data = NULL,
- .help_str = "Delete port meter",
+ .help_str = "del port meter <port_id> <mtr_id>",
.tokens = {
(void *)&cmd_del_port_meter_del,
(void *)&cmd_del_port_meter_port,
struct cmd_set_port_meter_profile_result, profile, "profile");
cmdline_parse_token_num_t cmd_set_port_meter_profile_port_id =
TOKEN_NUM_INITIALIZER(
- struct cmd_set_port_meter_profile_result, port_id, UINT16);
+ struct cmd_set_port_meter_profile_result, port_id,
+ RTE_UINT16);
cmdline_parse_token_num_t cmd_set_port_meter_profile_mtr_id =
TOKEN_NUM_INITIALIZER(
- struct cmd_set_port_meter_profile_result, mtr_id, UINT32);
+ struct cmd_set_port_meter_profile_result, mtr_id,
+ RTE_UINT32);
cmdline_parse_token_num_t cmd_set_port_meter_profile_profile_id =
TOKEN_NUM_INITIALIZER(
- struct cmd_set_port_meter_profile_result, profile_id, UINT32);
+ struct cmd_set_port_meter_profile_result, profile_id,
+ RTE_UINT32);
static void cmd_set_port_meter_profile_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_set_port_meter_profile_result *res = parsed_result;
struct rte_mtr_error error;
cmdline_parse_inst_t cmd_set_port_meter_profile = {
.f = cmd_set_port_meter_profile_parsed,
.data = NULL,
- .help_str = "Set port meter profile",
+ .help_str = "set port meter profile <port_id> <mtr_id> <profile_id>",
.tokens = {
(void *)&cmd_set_port_meter_profile_set,
(void *)&cmd_set_port_meter_profile_port,
token_string, TOKEN_STRING_MULTI);
static void cmd_set_port_meter_dscp_table_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_set_port_meter_dscp_table_result *res = parsed_result;
struct rte_mtr_error error;
- enum rte_mtr_color *dscp_table = NULL;
+ enum rte_color *dscp_table = NULL;
char *t_str = res->token_string;
uint32_t mtr_id = 0;
uint16_t port_id;
int ret;
/* Parse string */
- ret = parse_multi_token_string(t_str, &port_id, &mtr_id, dscp_table);
+ ret = parse_multi_token_string(t_str, &port_id, &mtr_id, &dscp_table);
if (ret) {
printf(" Multi token string parse error\n");
return;
}
if (port_id_is_invalid(port_id, ENABLED_WARN))
- return;
+ goto free_table;
/* Update Meter DSCP Table*/
ret = rte_mtr_meter_dscp_table_update(port_id, mtr_id,
dscp_table, &error);
- if (ret != 0) {
+ if (ret != 0)
print_err_msg(&error);
- return;
- }
+
+free_table:
free(dscp_table);
}
cmdline_parse_inst_t cmd_set_port_meter_dscp_table = {
.f = cmd_set_port_meter_dscp_table_parsed,
.data = NULL,
- .help_str = "Update port meter dscp table",
+ .help_str = "set port meter dscp table <port_id> <mtr_id> "
+ "[<dscp_tbl_entry0> <dscp_tbl_entry1> ... <dscp_tbl_entry63>]",
.tokens = {
(void *)&cmd_set_port_meter_dscp_table_set,
(void *)&cmd_set_port_meter_dscp_table_port,
},
};
-/* *** Set Port Meter Policer Action *** */
-struct cmd_set_port_meter_policer_action_result {
- cmdline_fixed_string_t set;
- cmdline_fixed_string_t port;
- cmdline_fixed_string_t meter;
- cmdline_fixed_string_t policer;
- cmdline_fixed_string_t action;
- uint16_t port_id;
- uint32_t mtr_id;
- uint32_t action_mask;
- cmdline_multi_string_t policer_action;
-};
-
-cmdline_parse_token_string_t cmd_set_port_meter_policer_action_set =
- TOKEN_STRING_INITIALIZER(
- struct cmd_set_port_meter_policer_action_result, set, "set");
-cmdline_parse_token_string_t cmd_set_port_meter_policer_action_port =
- TOKEN_STRING_INITIALIZER(
- struct cmd_set_port_meter_policer_action_result, port, "port");
-cmdline_parse_token_string_t cmd_set_port_meter_policer_action_meter =
- TOKEN_STRING_INITIALIZER(
- struct cmd_set_port_meter_policer_action_result, meter,
- "meter");
-cmdline_parse_token_string_t cmd_set_port_meter_policer_action_policer =
- TOKEN_STRING_INITIALIZER(
- struct cmd_set_port_meter_policer_action_result, policer,
- "policer");
-cmdline_parse_token_string_t cmd_set_port_meter_policer_action_action =
- TOKEN_STRING_INITIALIZER(
- struct cmd_set_port_meter_policer_action_result, action,
- "action");
-cmdline_parse_token_num_t cmd_set_port_meter_policer_action_port_id =
- TOKEN_NUM_INITIALIZER(
- struct cmd_set_port_meter_policer_action_result, port_id,
- UINT16);
-cmdline_parse_token_num_t cmd_set_port_meter_policer_action_mtr_id =
- TOKEN_NUM_INITIALIZER(
- struct cmd_set_port_meter_policer_action_result, mtr_id,
- UINT32);
-cmdline_parse_token_num_t cmd_set_port_meter_policer_action_action_mask =
- TOKEN_NUM_INITIALIZER(
- struct cmd_set_port_meter_policer_action_result, action_mask,
- UINT32);
-cmdline_parse_token_string_t cmd_set_port_meter_policer_action_policer_action =
- TOKEN_STRING_INITIALIZER(
- struct cmd_set_port_meter_policer_action_result,
- policer_action, TOKEN_STRING_MULTI);
-
-static void cmd_set_port_meter_policer_action_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
-{
- struct cmd_set_port_meter_policer_action_result *res = parsed_result;
- enum rte_mtr_policer_action *actions;
- struct rte_mtr_error error;
- uint32_t mtr_id = res->mtr_id;
- uint32_t action_mask = res->action_mask;
- uint16_t port_id = res->port_id;
- char *p_str = res->policer_action;
- int ret;
-
- if (port_id_is_invalid(port_id, ENABLED_WARN))
- return;
-
- /* Check: action mask */
- if (action_mask == 0 || (action_mask & (~0x7UL))) {
- printf(" Policer action mask not correct (error)\n");
- return;
- }
-
- /* Allocate memory for policer actions */
- actions = (enum rte_mtr_policer_action *)malloc(RTE_MTR_COLORS *
- sizeof(enum rte_mtr_policer_action));
- if (actions == NULL) {
- printf("Memory for policer actions not allocated (error)\n");
- return;
- }
- /* Parse policer action string */
- ret = parse_policer_action_string(p_str, action_mask, actions);
- if (ret) {
- printf(" Policer action string parse error\n");
- free(actions);
- return;
- }
-
- ret = rte_mtr_policer_actions_update(port_id, mtr_id,
- action_mask, actions, &error);
- if (ret != 0) {
- print_err_msg(&error);
- return;
- }
-
- free(actions);
-}
-
-cmdline_parse_inst_t cmd_set_port_meter_policer_action = {
- .f = cmd_set_port_meter_policer_action_parsed,
- .data = NULL,
- .help_str = "Set port meter policer action",
- .tokens = {
- (void *)&cmd_set_port_meter_policer_action_set,
- (void *)&cmd_set_port_meter_policer_action_port,
- (void *)&cmd_set_port_meter_policer_action_meter,
- (void *)&cmd_set_port_meter_policer_action_policer,
- (void *)&cmd_set_port_meter_policer_action_action,
- (void *)&cmd_set_port_meter_policer_action_port_id,
- (void *)&cmd_set_port_meter_policer_action_mtr_id,
- (void *)&cmd_set_port_meter_policer_action_action_mask,
- (void *)&cmd_set_port_meter_policer_action_policer_action,
- NULL,
- },
-};
-
/* *** Set Port Meter Stats Mask *** */
struct cmd_set_port_meter_stats_mask_result {
cmdline_fixed_string_t set;
struct cmd_set_port_meter_stats_mask_result, mask, "mask");
cmdline_parse_token_num_t cmd_set_port_meter_stats_mask_port_id =
TOKEN_NUM_INITIALIZER(
- struct cmd_set_port_meter_stats_mask_result, port_id, UINT16);
+ struct cmd_set_port_meter_stats_mask_result, port_id,
+ RTE_UINT16);
cmdline_parse_token_num_t cmd_set_port_meter_stats_mask_mtr_id =
TOKEN_NUM_INITIALIZER(
- struct cmd_set_port_meter_stats_mask_result, mtr_id, UINT32);
+ struct cmd_set_port_meter_stats_mask_result, mtr_id,
+ RTE_UINT32);
cmdline_parse_token_num_t cmd_set_port_meter_stats_mask_stats_mask =
TOKEN_NUM_INITIALIZER(
struct cmd_set_port_meter_stats_mask_result, stats_mask,
- UINT64);
+ RTE_UINT64);
static void cmd_set_port_meter_stats_mask_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_set_port_meter_stats_mask_result *res = parsed_result;
struct rte_mtr_error error;
cmdline_parse_inst_t cmd_set_port_meter_stats_mask = {
.f = cmd_set_port_meter_stats_mask_parsed,
.data = NULL,
- .help_str = "Set port meter stats mask",
+ .help_str = "set port meter stats mask <port_id> <mtr_id> <stats_mask>",
.tokens = {
(void *)&cmd_set_port_meter_stats_mask_set,
(void *)&cmd_set_port_meter_stats_mask_port,
struct cmd_show_port_meter_stats_result, stats, "stats");
cmdline_parse_token_num_t cmd_show_port_meter_stats_port_id =
TOKEN_NUM_INITIALIZER(
- struct cmd_show_port_meter_stats_result, port_id, UINT16);
+ struct cmd_show_port_meter_stats_result, port_id, RTE_UINT16);
cmdline_parse_token_num_t cmd_show_port_meter_stats_mtr_id =
TOKEN_NUM_INITIALIZER(
- struct cmd_show_port_meter_stats_result, mtr_id, UINT32);
+ struct cmd_show_port_meter_stats_result, mtr_id, RTE_UINT32);
cmdline_parse_token_string_t cmd_show_port_meter_stats_clear =
TOKEN_STRING_INITIALIZER(
struct cmd_show_port_meter_stats_result, clear, "yes#no");
static void cmd_show_port_meter_stats_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_show_port_meter_stats_result *res = parsed_result;
struct rte_mtr_stats stats;
/* Display stats */
if (stats_mask & RTE_MTR_STATS_N_PKTS_GREEN)
printf("\tPkts G: %" PRIu64 "\n",
- stats.n_pkts[RTE_MTR_GREEN]);
+ stats.n_pkts[RTE_COLOR_GREEN]);
if (stats_mask & RTE_MTR_STATS_N_BYTES_GREEN)
printf("\tBytes G: %" PRIu64 "\n",
- stats.n_bytes[RTE_MTR_GREEN]);
+ stats.n_bytes[RTE_COLOR_GREEN]);
if (stats_mask & RTE_MTR_STATS_N_PKTS_YELLOW)
printf("\tPkts Y: %" PRIu64 "\n",
- stats.n_pkts[RTE_MTR_YELLOW]);
+ stats.n_pkts[RTE_COLOR_YELLOW]);
if (stats_mask & RTE_MTR_STATS_N_BYTES_YELLOW)
printf("\tBytes Y: %" PRIu64 "\n",
- stats.n_bytes[RTE_MTR_YELLOW]);
+ stats.n_bytes[RTE_COLOR_YELLOW]);
if (stats_mask & RTE_MTR_STATS_N_PKTS_RED)
printf("\tPkts R: %" PRIu64 "\n",
- stats.n_pkts[RTE_MTR_RED]);
+ stats.n_pkts[RTE_COLOR_RED]);
if (stats_mask & RTE_MTR_STATS_N_BYTES_RED)
printf("\tBytes R: %" PRIu64 "\n",
- stats.n_bytes[RTE_MTR_RED]);
+ stats.n_bytes[RTE_COLOR_RED]);
if (stats_mask & RTE_MTR_STATS_N_PKTS_DROPPED)
printf("\tPkts DROPPED: %" PRIu64 "\n",
stats.n_pkts_dropped);
cmdline_parse_inst_t cmd_show_port_meter_stats = {
.f = cmd_show_port_meter_stats_parsed,
.data = NULL,
- .help_str = "Show port meter stats",
+ .help_str = "show port meter stats <port_id> <mtr_id> <clear>(yes|no)",
.tokens = {
(void *)&cmd_show_port_meter_stats_show,
(void *)&cmd_show_port_meter_stats_port,
git.droids-corp.org / dpdk.git / blobdiff