X-Git-Url: http://git.droids-corp.org/?a=blobdiff_plain;f=app%2Ftest-pmd%2Fcmdline_mtr.c;h=ad7ef6ad986159e2a3812644dd2b0bcae46026b7;hb=5aae2723cddba81b179162b5e7e4f6bd429eaac5;hp=ae742492d69a04dac5167955a35e6ed73cf4c420;hpb=e63b50162aa38111410a2ab2381d672d42503f6e;p=dpdk.git diff --git a/app/test-pmd/cmdline_mtr.c b/app/test-pmd/cmdline_mtr.c index ae742492d6..ad7ef6ad98 100644 --- a/app/test-pmd/cmdline_mtr.c +++ b/app/test-pmd/cmdline_mtr.c @@ -37,6 +37,8 @@ print_err_msg(struct rte_mtr_error *error) [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; @@ -51,11 +53,18 @@ print_err_msg(struct rte_mtr_error *error) if (error->cause) snprintf(buf, sizeof(buf), "cause: %p, ", error->cause); - printf("%s: %s%s (error %d)\n", errstr, error->cause ? buf : "", + fprintf(stderr, "%s: %s%s (error %d)\n", + errstr, error->cause ? buf : "", error->message ? error->message : "(no stated reason)", 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) { @@ -74,7 +83,7 @@ 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; @@ -84,36 +93,40 @@ parse_dscp_table_entries(char *str, enum rte_mtr_color *dscp_table) return 0; /* Allocate memory for dscp table */ - dscp_table = (enum rte_mtr_color *)malloc(MAX_DSCP_TABLE_ENTRIES * - sizeof(enum rte_mtr_color)); + *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) break; token = strtok_r(str, PARSE_DELIMITER, &str); - if (token == NULL) + if (token == NULL) { + free(*dscp_table); return -1; + } } return 0; } 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; @@ -143,51 +156,143 @@ parse_meter_color_str(char *c_str, uint32_t *use_prev_meter_color, } static int -string_to_policer_action(char *s) +parse_multi_token_string(char *t_str, uint16_t *port_id, + uint32_t *mtr_id, enum rte_color **dscp_table) { - if ((strcmp(s, "G") == 0) || (strcmp(s, "g") == 0)) - return MTR_POLICER_ACTION_COLOR_GREEN; + char *token; + uint64_t val; + int ret; - if ((strcmp(s, "Y") == 0) || (strcmp(s, "y") == 0)) - return MTR_POLICER_ACTION_COLOR_YELLOW; + /* First token: port id */ + token = strtok_r(t_str, PARSE_DELIMITER, &t_str); + if (token == NULL) + return -1; + + ret = parse_uint(&val, token); + if (ret != 0 || val > UINT16_MAX) + return -1; - if ((strcmp(s, "R") == 0) || (strcmp(s, "r") == 0)) - return MTR_POLICER_ACTION_COLOR_RED; + *port_id = val; - if ((strcmp(s, "D") == 0) || (strcmp(s, "d") == 0)) - return MTR_POLICER_ACTION_DROP; + /* Second token: meter id */ + token = strtok_r(t_str, PARSE_DELIMITER, &t_str); + if (token == NULL) + return 0; - return -1; + ret = parse_uint(&val, token); + if (ret != 0 || val > UINT32_MAX) + return -1; + + *mtr_id = val; + + ret = parse_dscp_table_entries(t_str, dscp_table); + if (ret != 0) + return -1; + + return 0; } -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; +/* *** Show Port Meter Capabilities *** */ +struct cmd_show_port_meter_cap_result { + cmdline_fixed_string_t show; + cmdline_fixed_string_t port; + cmdline_fixed_string_t meter; + cmdline_fixed_string_t cap; + uint16_t port_id; +}; - for (i = 0; i < count; i++) { - token = strtok_r(p_str, PARSE_DELIMITER, &p_str); - if (token == NULL) - return -1; +cmdline_parse_token_string_t cmd_show_port_meter_cap_show = + TOKEN_STRING_INITIALIZER( + struct cmd_show_port_meter_cap_result, show, "show"); +cmdline_parse_token_string_t cmd_show_port_meter_cap_port = + TOKEN_STRING_INITIALIZER( + struct cmd_show_port_meter_cap_result, port, "port"); +cmdline_parse_token_string_t cmd_show_port_meter_cap_meter = + TOKEN_STRING_INITIALIZER( + struct cmd_show_port_meter_cap_result, meter, "meter"); +cmdline_parse_token_string_t cmd_show_port_meter_cap_cap = + TOKEN_STRING_INITIALIZER( + 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, RTE_UINT16); - action = string_to_policer_action(token); - if (action == -1) - return -1; +static void cmd_show_port_meter_cap_parsed(void *parsed_result, + __rte_unused struct cmdline *cl, + __rte_unused void *data) +{ + struct cmd_show_port_meter_cap_result *res = parsed_result; + struct rte_mtr_capabilities cap; + struct rte_mtr_error error; + uint16_t port_id = res->port_id; + int ret; + + if (port_id_is_invalid(port_id, ENABLED_WARN)) + return; - 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; + memset(&cap, 0, sizeof(struct rte_mtr_capabilities)); + ret = rte_mtr_capabilities_get(port_id, &cap, &error); + if (ret) { + print_err_msg(&error); + return; } - return 0; + + printf("\n**** Port Meter Object Capabilities ****\n\n"); + printf("cap.n_max %" PRIu32 "\n", cap.n_max); + printf("cap.n_shared_max %" PRIu32 "\n", cap.n_shared_max); + printf("cap.identical %" PRId32 "\n", cap.identical); + printf("cap.shared_identical %" PRId32 "\n", + cap.shared_identical); + printf("cap.shared_n_flows_per_mtr_max %" PRIu32 "\n", + cap.shared_n_flows_per_mtr_max); + printf("cap.chaining_n_mtrs_per_flow_max %" PRIu32 "\n", + cap.chaining_n_mtrs_per_flow_max); + printf("cap.chaining_use_prev_mtr_color_supported %" PRId32 "\n", + cap.chaining_use_prev_mtr_color_supported); + printf("cap.chaining_use_prev_mtr_color_enforced %" PRId32 "\n", + cap.chaining_use_prev_mtr_color_enforced); + printf("cap.meter_srtcm_rfc2697_n_max %" PRIu32 "\n", + cap.meter_srtcm_rfc2697_n_max); + printf("cap.meter_trtcm_rfc2698_n_max %" PRIu32 "\n", + cap.meter_trtcm_rfc2698_n_max); + printf("cap.meter_trtcm_rfc4115_n_max %" PRIu32 "\n", + cap.meter_trtcm_rfc4115_n_max); + printf("cap.meter_rate_max %" PRIu64 "\n", cap.meter_rate_max); + printf("cap.color_aware_srtcm_rfc2697_supported %" PRId32 "\n", + cap.color_aware_srtcm_rfc2697_supported); + printf("cap.color_aware_trtcm_rfc2698_supported %" PRId32 "\n", + cap.color_aware_trtcm_rfc2698_supported); + printf("cap.color_aware_trtcm_rfc4115_supported %" PRId32 "\n", + cap.color_aware_trtcm_rfc4115_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 ", + .tokens = { + (void *)&cmd_show_port_meter_cap_show, + (void *)&cmd_show_port_meter_cap_port, + (void *)&cmd_show_port_meter_cap_meter, + (void *)&cmd_show_port_meter_cap_cap, + (void *)&cmd_show_port_meter_cap_port_id, + NULL, + }, +}; + /* *** Add Port Meter Profile srtcm_rfc2697 *** */ struct cmd_add_port_meter_profile_srtcm_result { cmdline_fixed_string_t add; @@ -200,6 +305,7 @@ struct cmd_add_port_meter_profile_srtcm_result { uint64_t cir; uint64_t cbs; uint64_t ebs; + int packet_mode; }; cmdline_parse_token_string_t cmd_add_port_meter_profile_srtcm_add = @@ -224,27 +330,31 @@ cmdline_parse_token_string_t cmd_add_port_meter_profile_srtcm_srtcm_rfc2697 = 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; @@ -262,6 +372,7 @@ static void cmd_add_port_meter_profile_srtcm_parsed(void *parsed_result, 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) { @@ -273,18 +384,19 @@ static void cmd_add_port_meter_profile_srtcm_parsed(void *parsed_result, 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 ", .tokens = { (void *)&cmd_add_port_meter_profile_srtcm_add, (void *)&cmd_add_port_meter_profile_srtcm_port, (void *)&cmd_add_port_meter_profile_srtcm_meter, (void *)&cmd_add_port_meter_profile_srtcm_profile, + (void *)&cmd_add_port_meter_profile_srtcm_srtcm_rfc2697, (void *)&cmd_add_port_meter_profile_srtcm_port_id, (void *)&cmd_add_port_meter_profile_srtcm_profile_id, - (void *)&cmd_add_port_meter_profile_srtcm_srtcm_rfc2697, (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, }, }; @@ -302,6 +414,7 @@ struct cmd_add_port_meter_profile_trtcm_result { uint64_t pir; uint64_t cbs; uint64_t pbs; + int packet_mode; }; cmdline_parse_token_string_t cmd_add_port_meter_profile_trtcm_add = @@ -326,31 +439,35 @@ cmdline_parse_token_string_t cmd_add_port_meter_profile_trtcm_trtcm_rfc2698 = 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; @@ -369,6 +486,7 @@ static void cmd_add_port_meter_profile_trtcm_parsed(void *parsed_result, 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) { @@ -380,19 +498,20 @@ static void cmd_add_port_meter_profile_trtcm_parsed(void *parsed_result, 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 ", .tokens = { (void *)&cmd_add_port_meter_profile_trtcm_add, (void *)&cmd_add_port_meter_profile_trtcm_port, (void *)&cmd_add_port_meter_profile_trtcm_meter, (void *)&cmd_add_port_meter_profile_trtcm_profile, + (void *)&cmd_add_port_meter_profile_trtcm_trtcm_rfc2698, (void *)&cmd_add_port_meter_profile_trtcm_port_id, (void *)&cmd_add_port_meter_profile_trtcm_profile_id, - (void *)&cmd_add_port_meter_profile_trtcm_trtcm_rfc2698, (void *)&cmd_add_port_meter_profile_trtcm_cir, (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, }, }; @@ -410,6 +529,7 @@ struct cmd_add_port_meter_profile_trtcm_rfc4115_result { 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 = @@ -436,32 +556,37 @@ cmdline_parse_token_string_t 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; @@ -481,6 +606,7 @@ static void cmd_add_port_meter_profile_trtcm_rfc4115_parsed( 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) { @@ -492,19 +618,20 @@ static void cmd_add_port_meter_profile_trtcm_rfc4115_parsed( 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 ", .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_meter, (void *)&cmd_add_port_meter_profile_trtcm_rfc4115_profile, + (void *)&cmd_add_port_meter_profile_trtcm_rfc4115_trtcm_rfc4115, (void *)&cmd_add_port_meter_profile_trtcm_rfc4115_port_id, (void *)&cmd_add_port_meter_profile_trtcm_rfc4115_profile_id, - (void *)&cmd_add_port_meter_profile_trtcm_rfc4115_trtcm_rfc4115, (void *)&cmd_add_port_meter_profile_trtcm_rfc4115_cir, (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, }, }; @@ -537,15 +664,15 @@ cmdline_parse_token_string_t cmd_del_port_meter_profile_profile = 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; @@ -567,7 +694,7 @@ static void cmd_del_port_meter_profile_parsed(void *parsed_result, 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 ", .tokens = { (void *)&cmd_del_port_meter_profile_del, (void *)&cmd_del_port_meter_profile_port, @@ -587,6 +714,7 @@ struct cmd_create_port_meter_result { 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; @@ -607,13 +735,16 @@ cmdline_parse_token_string_t cmd_create_port_meter_meter = 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"); @@ -628,17 +759,17 @@ cmdline_parse_token_string_t cmd_create_port_meter_r_action = 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; @@ -647,7 +778,7 @@ static void cmd_create_port_meter_parsed(void *parsed_result, 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; @@ -657,11 +788,12 @@ static void cmd_create_port_meter_parsed(void *parsed_result, /* 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"); + fprintf(stderr, + " Meter input color params string parse error\n"); return; } @@ -672,13 +804,6 @@ static void cmd_create_port_meter_parsed(void *parsed_result, 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); @@ -692,7 +817,9 @@ static void cmd_create_port_meter_parsed(void *parsed_result, 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 (yes|no) " + " " + "[ ...]", .tokens = { (void *)&cmd_create_port_meter_create, (void *)&cmd_create_port_meter_port, @@ -700,10 +827,8 @@ cmdline_parse_inst_t cmd_create_port_meter = { (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, @@ -711,6 +836,193 @@ cmdline_parse_inst_t cmd_create_port_meter = { }, }; +/* *** Enable Meter of MTR Object *** */ +struct cmd_enable_port_meter_result { + cmdline_fixed_string_t enable; + cmdline_fixed_string_t port; + cmdline_fixed_string_t meter; + uint16_t port_id; + uint32_t mtr_id; +}; + +cmdline_parse_token_string_t cmd_enable_port_meter_enable = + TOKEN_STRING_INITIALIZER( + struct cmd_enable_port_meter_result, enable, "enable"); +cmdline_parse_token_string_t cmd_enable_port_meter_port = + TOKEN_STRING_INITIALIZER( + struct cmd_enable_port_meter_result, port, "port"); +cmdline_parse_token_string_t cmd_enable_port_meter_meter = + TOKEN_STRING_INITIALIZER( + 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, RTE_UINT16); +cmdline_parse_token_num_t cmd_enable_port_meter_mtr_id = + TOKEN_NUM_INITIALIZER( + struct cmd_enable_port_meter_result, mtr_id, RTE_UINT32); + +static void cmd_enable_port_meter_parsed(void *parsed_result, + __rte_unused struct cmdline *cl, + __rte_unused void *data) +{ + struct cmd_enable_port_meter_result *res = parsed_result; + struct rte_mtr_error error; + uint32_t mtr_id = res->mtr_id; + uint16_t port_id = res->port_id; + + int ret; + + if (port_id_is_invalid(port_id, ENABLED_WARN)) + return; + + /* Enable Meter */ + ret = rte_mtr_meter_enable(port_id, mtr_id, &error); + if (ret != 0) { + print_err_msg(&error); + return; + } +} + +cmdline_parse_inst_t cmd_enable_port_meter = { + .f = cmd_enable_port_meter_parsed, + .data = NULL, + .help_str = "enable port meter ", + .tokens = { + (void *)&cmd_enable_port_meter_enable, + (void *)&cmd_enable_port_meter_port, + (void *)&cmd_enable_port_meter_meter, + (void *)&cmd_enable_port_meter_port_id, + (void *)&cmd_enable_port_meter_mtr_id, + NULL, + }, +}; + +/* *** Disable Meter of MTR Object *** */ +struct cmd_disable_port_meter_result { + cmdline_fixed_string_t disable; + cmdline_fixed_string_t port; + cmdline_fixed_string_t meter; + uint16_t port_id; + uint32_t mtr_id; +}; + +cmdline_parse_token_string_t cmd_disable_port_meter_disable = + TOKEN_STRING_INITIALIZER( + struct cmd_disable_port_meter_result, disable, "disable"); +cmdline_parse_token_string_t cmd_disable_port_meter_port = + TOKEN_STRING_INITIALIZER( + struct cmd_disable_port_meter_result, port, "port"); +cmdline_parse_token_string_t cmd_disable_port_meter_meter = + TOKEN_STRING_INITIALIZER( + 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, RTE_UINT16); +cmdline_parse_token_num_t cmd_disable_port_meter_mtr_id = + TOKEN_NUM_INITIALIZER( + struct cmd_disable_port_meter_result, mtr_id, RTE_UINT32); + +static void cmd_disable_port_meter_parsed(void *parsed_result, + __rte_unused struct cmdline *cl, + __rte_unused void *data) +{ + struct cmd_disable_port_meter_result *res = parsed_result; + struct rte_mtr_error error; + uint32_t mtr_id = res->mtr_id; + uint16_t port_id = res->port_id; + + int ret; + + if (port_id_is_invalid(port_id, ENABLED_WARN)) + return; + + /* Disable Meter */ + ret = rte_mtr_meter_disable(port_id, mtr_id, &error); + if (ret != 0) { + print_err_msg(&error); + return; + } +} + +cmdline_parse_inst_t cmd_disable_port_meter = { + .f = cmd_disable_port_meter_parsed, + .data = NULL, + .help_str = "disable port meter ", + .tokens = { + (void *)&cmd_disable_port_meter_disable, + (void *)&cmd_disable_port_meter_port, + (void *)&cmd_disable_port_meter_meter, + (void *)&cmd_disable_port_meter_port_id, + (void *)&cmd_disable_port_meter_mtr_id, + NULL, + }, +}; + +/* *** 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; @@ -731,14 +1043,14 @@ cmdline_parse_token_string_t cmd_del_port_meter_meter = 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; @@ -761,7 +1073,7 @@ static void cmd_del_port_meter_parsed(void *parsed_result, 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 ", .tokens = { (void *)&cmd_del_port_meter_del, (void *)&cmd_del_port_meter_port, @@ -797,17 +1109,20 @@ cmdline_parse_token_string_t cmd_set_port_meter_profile_profile = 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; @@ -832,7 +1147,7 @@ static void cmd_set_port_meter_profile_parsed(void *parsed_result, 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 ", .tokens = { (void *)&cmd_set_port_meter_profile_set, (void *)&cmd_set_port_meter_profile_port, @@ -845,115 +1160,75 @@ cmdline_parse_inst_t cmd_set_port_meter_profile = { }, }; -/* *** Set Port Meter Policer Action *** */ -struct cmd_set_port_meter_policer_action_result { +/* *** Set Port Meter DSCP Table *** */ +struct cmd_set_port_meter_dscp_table_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_fixed_string_t dscp_table; + cmdline_multi_string_t token_string; }; -cmdline_parse_token_string_t cmd_set_port_meter_policer_action_set = +cmdline_parse_token_string_t cmd_set_port_meter_dscp_table_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 = + struct cmd_set_port_meter_dscp_table_result, set, "set"); +cmdline_parse_token_string_t cmd_set_port_meter_dscp_table_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 = + struct cmd_set_port_meter_dscp_table_result, port, "port"); +cmdline_parse_token_string_t cmd_set_port_meter_dscp_table_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 = + struct cmd_set_port_meter_dscp_table_result, meter, "meter"); +cmdline_parse_token_string_t cmd_set_port_meter_dscp_table_dscp_table = 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_dscp_table_result, + dscp_table, "dscp table"); +cmdline_parse_token_string_t cmd_set_port_meter_dscp_table_token_string = + TOKEN_STRING_INITIALIZER(struct cmd_set_port_meter_dscp_table_result, + token_string, TOKEN_STRING_MULTI); + +static void cmd_set_port_meter_dscp_table_parsed(void *parsed_result, + __rte_unused struct cmdline *cl, + __rte_unused void *data) { - struct cmd_set_port_meter_policer_action_result *res = parsed_result; - enum rte_mtr_policer_action *actions; + struct cmd_set_port_meter_dscp_table_result *res = parsed_result; 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; + enum rte_color *dscp_table = NULL; + char *t_str = res->token_string; + uint32_t mtr_id = 0; + uint16_t port_id; 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); + /* Parse string */ + ret = parse_multi_token_string(t_str, &port_id, &mtr_id, &dscp_table); if (ret) { - printf(" Policer action string parse error\n"); - free(actions); + fprintf(stderr, " Multi token string parse error\n"); return; } - ret = rte_mtr_policer_actions_update(port_id, mtr_id, - action_mask, actions, &error); - if (ret != 0) { + if (port_id_is_invalid(port_id, ENABLED_WARN)) + goto free_table; + + /* Update Meter DSCP Table*/ + ret = rte_mtr_meter_dscp_table_update(port_id, mtr_id, + dscp_table, &error); + if (ret != 0) print_err_msg(&error); - return; - } - free(actions); +free_table: + free(dscp_table); } -cmdline_parse_inst_t cmd_set_port_meter_policer_action = { - .f = cmd_set_port_meter_policer_action_parsed, +cmdline_parse_inst_t cmd_set_port_meter_dscp_table = { + .f = cmd_set_port_meter_dscp_table_parsed, .data = NULL, - .help_str = "Set port meter policer action", + .help_str = "set port meter dscp table " + "[ ... ]", .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, + (void *)&cmd_set_port_meter_dscp_table_set, + (void *)&cmd_set_port_meter_dscp_table_port, + (void *)&cmd_set_port_meter_dscp_table_meter, + (void *)&cmd_set_port_meter_dscp_table_dscp_table, + (void *)&cmd_set_port_meter_dscp_table_token_string, NULL, }, }; @@ -987,18 +1262,20 @@ cmdline_parse_token_string_t cmd_set_port_meter_stats_mask_mask = 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; @@ -1020,7 +1297,7 @@ static void cmd_set_port_meter_stats_mask_parsed(void *parsed_result, 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 ", .tokens = { (void *)&cmd_set_port_meter_stats_mask_set, (void *)&cmd_set_port_meter_stats_mask_port, @@ -1059,17 +1336,17 @@ cmdline_parse_token_string_t cmd_show_port_meter_stats_stats = 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; @@ -1097,22 +1374,22 @@ static void cmd_show_port_meter_stats_parsed(void *parsed_result, /* 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 Y: %" PRIu64 "\n", - stats.n_bytes[RTE_MTR_RED]); + printf("\tBytes R: %" PRIu64 "\n", + stats.n_bytes[RTE_COLOR_RED]); if (stats_mask & RTE_MTR_STATS_N_PKTS_DROPPED) printf("\tPkts DROPPED: %" PRIu64 "\n", stats.n_pkts_dropped); @@ -1124,7 +1401,7 @@ static void cmd_show_port_meter_stats_parsed(void *parsed_result, 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 (yes|no)", .tokens = { (void *)&cmd_show_port_meter_stats_show, (void *)&cmd_show_port_meter_stats_port,