X-Git-Url: http://git.droids-corp.org/?a=blobdiff_plain;f=app%2Ftest-pmd%2Fcmdline_mtr.c;h=ee16244de79df93c74683e9dec1f7cea7a70a7bb;hb=b253a6bbf144c8e6505dd76fe0051967eddc6903;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..ee16244de7 100644 --- a/app/test-pmd/cmdline_mtr.c +++ b/app/test-pmd/cmdline_mtr.c @@ -74,7 +74,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 +84,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; @@ -178,16 +182,147 @@ parse_policer_action_string(char *p_str, uint32_t action_mask, return -1; if (g_color == 0 && (action_mask & 0x1)) { - actions[RTE_MTR_GREEN] = action; + actions[RTE_COLOR_GREEN] = action; g_color = 1; } else if (y_color == 0 && (action_mask & 0x2)) { - actions[RTE_MTR_YELLOW] = action; + actions[RTE_COLOR_YELLOW] = action; y_color = 1; } else - actions[RTE_MTR_RED] = action; + actions[RTE_COLOR_RED] = action; } return 0; } + +static int +parse_multi_token_string(char *t_str, uint16_t *port_id, + uint32_t *mtr_id, enum rte_color **dscp_table) +{ + char *token; + uint64_t val; + int ret; + + /* 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; + + *port_id = val; + + /* Second token: meter id */ + token = strtok_r(t_str, PARSE_DELIMITER, &t_str); + if (token == NULL) + return 0; + + 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; +} + +/* *** 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; +}; + +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, UINT16); + +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; + + memset(&cap, 0, sizeof(struct rte_mtr_capabilities)); + ret = rte_mtr_capabilities_get(port_id, &cap, &error); + if (ret) { + print_err_msg(&error); + return; + } + + 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.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.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; @@ -243,8 +378,8 @@ cmdline_parse_token_num_t cmd_add_port_meter_profile_srtcm_ebs = ebs, UINT64); 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; @@ -279,9 +414,9 @@ cmdline_parse_inst_t cmd_add_port_meter_profile_srtcm = { (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, @@ -349,8 +484,8 @@ cmdline_parse_token_num_t cmd_add_port_meter_profile_trtcm_pbs = pbs, UINT64); 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; @@ -386,9 +521,9 @@ cmdline_parse_inst_t cmd_add_port_meter_profile_trtcm = { (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, @@ -460,8 +595,8 @@ cmdline_parse_token_num_t cmd_add_port_meter_profile_trtcm_rfc4115_ebs = 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; @@ -498,9 +633,9 @@ cmdline_parse_inst_t cmd_add_port_meter_profile_trtcm_rfc4115 = { (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, @@ -544,8 +679,8 @@ cmdline_parse_token_num_t cmd_del_port_meter_profile_profile_id = profile_id, 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; @@ -637,8 +772,8 @@ cmdline_parse_token_string_t cmd_create_port_meter_input_color = 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 +782,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; @@ -659,7 +794,7 @@ static void cmd_create_port_meter_parsed(void *parsed_result, params.meter_profile_id = res->profile_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; @@ -673,11 +808,11 @@ static void cmd_create_port_meter_parsed(void *parsed_result, else params.meter_enable = 0; - params.action[RTE_MTR_GREEN] = + params.action[RTE_COLOR_GREEN] = string_to_policer_action(res->g_action); - params.action[RTE_MTR_YELLOW] = + params.action[RTE_COLOR_YELLOW] = string_to_policer_action(res->y_action); - params.action[RTE_MTR_RED] = + params.action[RTE_COLOR_RED] = string_to_policer_action(res->r_action); params.stats_mask = res->statistics_mask; @@ -711,6 +846,128 @@ 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, UINT16); +cmdline_parse_token_num_t cmd_enable_port_meter_mtr_id = + TOKEN_NUM_INITIALIZER( + struct cmd_enable_port_meter_result, mtr_id, 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, UINT16); +cmdline_parse_token_num_t cmd_disable_port_meter_mtr_id = + TOKEN_NUM_INITIALIZER( + struct cmd_disable_port_meter_result, mtr_id, 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 Object *** */ struct cmd_del_port_meter_result { cmdline_fixed_string_t del; @@ -737,8 +994,8 @@ cmdline_parse_token_num_t cmd_del_port_meter_mtr_id = struct cmd_del_port_meter_result, mtr_id, 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; @@ -806,8 +1063,8 @@ cmdline_parse_token_num_t cmd_set_port_meter_profile_profile_id = struct cmd_set_port_meter_profile_result, profile_id, 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; @@ -845,6 +1102,78 @@ cmdline_parse_inst_t cmd_set_port_meter_profile = { }, }; +/* *** 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 dscp_table; + cmdline_multi_string_t token_string; +}; + +cmdline_parse_token_string_t cmd_set_port_meter_dscp_table_set = + TOKEN_STRING_INITIALIZER( + 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_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_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_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_dscp_table_result *res = parsed_result; + struct rte_mtr_error error; + 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); + if (ret) { + printf(" Multi token string parse error\n"); + return; + } + + 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); + +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", + .tokens = { + (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, + }, +}; + /* *** Set Port Meter Policer Action *** */ struct cmd_set_port_meter_policer_action_result { cmdline_fixed_string_t set; @@ -894,8 +1223,8 @@ cmdline_parse_token_string_t cmd_set_port_meter_policer_action_policer_action = 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) + __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; @@ -916,7 +1245,7 @@ static void cmd_set_port_meter_policer_action_parsed(void *parsed_result, } /* Allocate memory for policer actions */ - actions = (enum rte_mtr_policer_action *)malloc(RTE_MTR_COLORS * + actions = (enum rte_mtr_policer_action *)malloc(RTE_COLORS * sizeof(enum rte_mtr_policer_action)); if (actions == NULL) { printf("Memory for policer actions not allocated (error)\n"); @@ -933,6 +1262,7 @@ static void cmd_set_port_meter_policer_action_parsed(void *parsed_result, ret = rte_mtr_policer_actions_update(port_id, mtr_id, action_mask, actions, &error); if (ret != 0) { + free(actions); print_err_msg(&error); return; } @@ -997,8 +1327,8 @@ cmdline_parse_token_num_t cmd_set_port_meter_stats_mask_stats_mask = 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; @@ -1068,8 +1398,8 @@ cmdline_parse_token_string_t cmd_show_port_meter_stats_clear = 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 +1427,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);