/* SPDX-License-Identifier: BSD-3-Clause * Copyright(c) 2017 Intel Corporation */ #include #include #include #include #include #include #include "testpmd.h" #include "cmdline_mtr.h" #define PARSE_DELIMITER " \f\n\r\t\v" #define MAX_VLAN_TABLE_ENTRIES 16 #define MAX_DSCP_TABLE_ENTRIES 64 /** Display Meter Error Message */ static void print_err_msg(struct rte_mtr_error *error) { static const char *const errstrlist[] = { [RTE_MTR_ERROR_TYPE_NONE] = "no error", [RTE_MTR_ERROR_TYPE_UNSPECIFIED] = "cause unspecified", [RTE_MTR_ERROR_TYPE_METER_PROFILE_ID] = "meter profile id", [RTE_MTR_ERROR_TYPE_METER_PROFILE] = "meter profile null", [RTE_MTR_ERROR_TYPE_MTR_ID] = "meter id", [RTE_MTR_ERROR_TYPE_MTR_PARAMS] = "meter params null", [RTE_MTR_ERROR_TYPE_POLICER_ACTION_GREEN] = "policer action(green)", [RTE_MTR_ERROR_TYPE_POLICER_ACTION_YELLOW] = "policer action(yellow)", [RTE_MTR_ERROR_TYPE_POLICER_ACTION_RED] = "policer action(red)", [RTE_MTR_ERROR_TYPE_STATS_MASK] = "stats mask", [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; char buf[64]; if ((unsigned int)error->type >= RTE_DIM(errstrlist) || !errstrlist[error->type]) errstr = "unknown type"; else errstr = errstrlist[error->type]; if (error->cause) snprintf(buf, sizeof(buf), "cause: %p, ", error->cause); 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) { char *next = NULL; uint64_t n; errno = 0; /* Parse number string */ n = strtol(str, &next, 10); if (errno != 0 || str == next || *next != '\0') return -1; *value = n; return 0; } static int parse_input_color_table_entries(char *str, enum rte_color **dscp_table, enum rte_color **vlan_table) { enum rte_color *vlan, *dscp; char *token; int i = 0; token = strtok_r(str, PARSE_DELIMITER, &str); if (token == NULL) return 0; /* Allocate memory for dscp table */ dscp = (enum rte_color *)malloc(MAX_DSCP_TABLE_ENTRIES * sizeof(enum rte_color)); if (dscp == NULL) return -1; while (1) { if (strcasecmp(token, "G") == 0) dscp[i++] = RTE_COLOR_GREEN; else if (strcasecmp(token, "Y") == 0) dscp[i++] = RTE_COLOR_YELLOW; else if (strcasecmp(token, "R") == 0) dscp[i++] = RTE_COLOR_RED; else { free(dscp); return -1; } if (i == MAX_DSCP_TABLE_ENTRIES) break; token = strtok_r(str, PARSE_DELIMITER, &str); if (token == NULL) { free(dscp); return -1; } } *dscp_table = dscp; token = strtok_r(str, PARSE_DELIMITER, &str); if (token == NULL) return 0; /* Allocate memory for vlan table */ vlan = (enum rte_color *)malloc(MAX_VLAN_TABLE_ENTRIES * sizeof(enum rte_color)); if (vlan == NULL) { free(*dscp_table); return -1; } i = 0; while (1) { if (strcasecmp(token, "G") == 0) vlan[i++] = RTE_COLOR_GREEN; else if (strcasecmp(token, "Y") == 0) vlan[i++] = RTE_COLOR_YELLOW; else if (strcasecmp(token, "R") == 0) vlan[i++] = RTE_COLOR_RED; else { free(vlan); free(*dscp_table); return -1; } if (i == MAX_VLAN_TABLE_ENTRIES) break; token = strtok_r(str, PARSE_DELIMITER, &str); if (token == NULL) { free(vlan); free(*dscp_table); return -1; } } *vlan_table = vlan; return 0; } static int parse_vlan_table_entries(char *str, enum rte_color **vlan_table) { char *token; int i = 0; token = strtok_r(str, PARSE_DELIMITER, &str); if (token == NULL) return 0; /* Allocate memory for vlan table */ *vlan_table = (enum rte_color *)malloc(MAX_VLAN_TABLE_ENTRIES * sizeof(enum rte_color)); if (*vlan_table == NULL) return -1; while (1) { if (strcasecmp(token, "G") == 0) (*vlan_table)[i++] = RTE_COLOR_GREEN; else if (strcasecmp(token, "Y") == 0) (*vlan_table)[i++] = RTE_COLOR_YELLOW; else if (strcasecmp(token, "R") == 0) (*vlan_table)[i++] = RTE_COLOR_RED; else { free(*vlan_table); return -1; } if (i == MAX_VLAN_TABLE_ENTRIES) break; token = strtok_r(str, PARSE_DELIMITER, &str); if (token == NULL) { free(*vlan_table); return -1; } } return 0; } static int parse_dscp_table_entries(char *str, enum rte_color **dscp_table) { char *token; int i = 0; token = strtok_r(str, PARSE_DELIMITER, &str); if (token == NULL) return 0; /* Allocate memory for dscp table */ *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_COLOR_GREEN; else if (strcmp(token, "Y") == 0 || strcmp(token, "y") == 0) (*dscp_table)[i++] = RTE_COLOR_YELLOW; else if (strcmp(token, "R") == 0 || strcmp(token, "r") == 0) (*dscp_table)[i++] = RTE_COLOR_RED; else { free(*dscp_table); return -1; } if (i == MAX_DSCP_TABLE_ENTRIES) break; token = strtok_r(str, PARSE_DELIMITER, &str); if (token == NULL) { free(*dscp_table); return -1; } } return 0; } static int parse_default_input_color_str(char *str, uint64_t *def_inp_color) { char *token; token = strtok_r(str, PARSE_DELIMITER, &str); if (token == NULL) return 0; if (strcasecmp(token, "G") == 0) *def_inp_color = RTE_COLOR_GREEN; else if (strcasecmp(token, "Y") == 0) *def_inp_color = RTE_COLOR_YELLOW; else if (strcasecmp(token, "R") == 0) *def_inp_color = RTE_COLOR_RED; else return -1; return 0; } static int parse_meter_color_str(char *c_str, uint32_t *use_prev_meter_color, enum rte_color **vlan_table, enum rte_color **dscp_table) { char *token; uint64_t previous_mtr_color = 0; int ret; /* First token: use previous meter color */ token = strtok_r(c_str, PARSE_DELIMITER, &c_str); if (token == NULL) return -1; ret = parse_uint(&previous_mtr_color, token); if (ret != 0) return -1; /* Check if previous meter color to be used */ if (previous_mtr_color) { *use_prev_meter_color = previous_mtr_color; return 0; } ret = parse_input_color_table_entries(c_str, dscp_table, vlan_table); if (ret != 0) return -1; 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; } static int parse_multi_token_vlan_str(char *t_str, uint16_t *port_id, uint32_t *mtr_id, enum rte_color **vlan_table) { uint64_t val; char *token; 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_vlan_table_entries(t_str, vlan_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; }; static cmdline_parse_token_string_t cmd_show_port_meter_cap_show = TOKEN_STRING_INITIALIZER( struct cmd_show_port_meter_cap_result, show, "show"); static cmdline_parse_token_string_t cmd_show_port_meter_cap_port = TOKEN_STRING_INITIALIZER( struct cmd_show_port_meter_cap_result, port, "port"); static cmdline_parse_token_string_t cmd_show_port_meter_cap_meter = TOKEN_STRING_INITIALIZER( struct cmd_show_port_meter_cap_result, meter, "meter"); static cmdline_parse_token_string_t cmd_show_port_meter_cap_cap = TOKEN_STRING_INITIALIZER( struct cmd_show_port_meter_cap_result, cap, "cap"); static 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); 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.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); printf("cap.input_color_proto_mask 0x%" PRIx64 "\n", cap.input_color_proto_mask); printf("cap.separate_input_color_table_per_port %" PRId32 "\n", cap.separate_input_color_table_per_port); } 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; cmdline_fixed_string_t port; cmdline_fixed_string_t meter; cmdline_fixed_string_t profile; cmdline_fixed_string_t srtcm_rfc2697; uint16_t port_id; uint32_t profile_id; uint64_t cir; uint64_t cbs; uint64_t ebs; int packet_mode; }; static cmdline_parse_token_string_t cmd_add_port_meter_profile_srtcm_add = TOKEN_STRING_INITIALIZER( struct cmd_add_port_meter_profile_srtcm_result, add, "add"); static cmdline_parse_token_string_t cmd_add_port_meter_profile_srtcm_port = TOKEN_STRING_INITIALIZER( struct cmd_add_port_meter_profile_srtcm_result, port, "port"); static cmdline_parse_token_string_t cmd_add_port_meter_profile_srtcm_meter = TOKEN_STRING_INITIALIZER( struct cmd_add_port_meter_profile_srtcm_result, meter, "meter"); static cmdline_parse_token_string_t cmd_add_port_meter_profile_srtcm_profile = TOKEN_STRING_INITIALIZER( struct cmd_add_port_meter_profile_srtcm_result, profile, "profile"); static cmdline_parse_token_string_t cmd_add_port_meter_profile_srtcm_srtcm_rfc2697 = TOKEN_STRING_INITIALIZER( struct cmd_add_port_meter_profile_srtcm_result, srtcm_rfc2697, "srtcm_rfc2697"); static 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, RTE_UINT16); static 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, RTE_UINT32); static cmdline_parse_token_num_t cmd_add_port_meter_profile_srtcm_cir = TOKEN_NUM_INITIALIZER( struct cmd_add_port_meter_profile_srtcm_result, cir, RTE_UINT64); static cmdline_parse_token_num_t cmd_add_port_meter_profile_srtcm_cbs = TOKEN_NUM_INITIALIZER( struct cmd_add_port_meter_profile_srtcm_result, cbs, RTE_UINT64); static cmdline_parse_token_num_t cmd_add_port_meter_profile_srtcm_ebs = TOKEN_NUM_INITIALIZER( struct cmd_add_port_meter_profile_srtcm_result, ebs, RTE_UINT64); static 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, __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; struct rte_mtr_error error; uint32_t profile_id = res->profile_id; uint16_t port_id = res->port_id; int ret; if (port_id_is_invalid(port_id, ENABLED_WARN)) return; /* Private shaper profile params */ memset(&mp, 0, sizeof(struct rte_mtr_meter_profile)); mp.alg = RTE_MTR_SRTCM_RFC2697; 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) { print_err_msg(&error); return; } } 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 ", .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_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, }, }; /* *** Add Port Meter Profile trtcm_rfc2698 *** */ struct cmd_add_port_meter_profile_trtcm_result { cmdline_fixed_string_t add; cmdline_fixed_string_t port; cmdline_fixed_string_t meter; cmdline_fixed_string_t profile; cmdline_fixed_string_t trtcm_rfc2698; uint16_t port_id; uint32_t profile_id; uint64_t cir; uint64_t pir; uint64_t cbs; uint64_t pbs; int packet_mode; }; static cmdline_parse_token_string_t cmd_add_port_meter_profile_trtcm_add = TOKEN_STRING_INITIALIZER( struct cmd_add_port_meter_profile_trtcm_result, add, "add"); static cmdline_parse_token_string_t cmd_add_port_meter_profile_trtcm_port = TOKEN_STRING_INITIALIZER( struct cmd_add_port_meter_profile_trtcm_result, port, "port"); static cmdline_parse_token_string_t cmd_add_port_meter_profile_trtcm_meter = TOKEN_STRING_INITIALIZER( struct cmd_add_port_meter_profile_trtcm_result, meter, "meter"); static cmdline_parse_token_string_t cmd_add_port_meter_profile_trtcm_profile = TOKEN_STRING_INITIALIZER( struct cmd_add_port_meter_profile_trtcm_result, profile, "profile"); static cmdline_parse_token_string_t cmd_add_port_meter_profile_trtcm_trtcm_rfc2698 = TOKEN_STRING_INITIALIZER( struct cmd_add_port_meter_profile_trtcm_result, trtcm_rfc2698, "trtcm_rfc2698"); static 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, RTE_UINT16); static 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, RTE_UINT32); static cmdline_parse_token_num_t cmd_add_port_meter_profile_trtcm_cir = TOKEN_NUM_INITIALIZER( struct cmd_add_port_meter_profile_trtcm_result, cir, RTE_UINT64); static cmdline_parse_token_num_t cmd_add_port_meter_profile_trtcm_pir = TOKEN_NUM_INITIALIZER( struct cmd_add_port_meter_profile_trtcm_result, pir, RTE_UINT64); static cmdline_parse_token_num_t cmd_add_port_meter_profile_trtcm_cbs = TOKEN_NUM_INITIALIZER( struct cmd_add_port_meter_profile_trtcm_result, cbs, RTE_UINT64); static cmdline_parse_token_num_t cmd_add_port_meter_profile_trtcm_pbs = TOKEN_NUM_INITIALIZER( struct cmd_add_port_meter_profile_trtcm_result, pbs, RTE_UINT64); static 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, __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; struct rte_mtr_error error; uint32_t profile_id = res->profile_id; uint16_t port_id = res->port_id; int ret; if (port_id_is_invalid(port_id, ENABLED_WARN)) return; /* Private shaper profile params */ memset(&mp, 0, sizeof(struct rte_mtr_meter_profile)); mp.alg = RTE_MTR_TRTCM_RFC2698; mp.trtcm_rfc2698.cir = res->cir; 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) { print_err_msg(&error); return; } } 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 ", .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_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, }, }; /* *** Add Port Meter Profile trtcm_rfc4115 *** */ struct cmd_add_port_meter_profile_trtcm_rfc4115_result { cmdline_fixed_string_t add; cmdline_fixed_string_t port; cmdline_fixed_string_t meter; cmdline_fixed_string_t profile; cmdline_fixed_string_t trtcm_rfc4115; uint16_t port_id; uint32_t profile_id; uint64_t cir; uint64_t eir; uint64_t cbs; uint64_t ebs; int packet_mode; }; static cmdline_parse_token_string_t cmd_add_port_meter_profile_trtcm_rfc4115_add = TOKEN_STRING_INITIALIZER( struct cmd_add_port_meter_profile_trtcm_rfc4115_result, add, "add"); static cmdline_parse_token_string_t cmd_add_port_meter_profile_trtcm_rfc4115_port = TOKEN_STRING_INITIALIZER( struct cmd_add_port_meter_profile_trtcm_rfc4115_result, port, "port"); static cmdline_parse_token_string_t cmd_add_port_meter_profile_trtcm_rfc4115_meter = TOKEN_STRING_INITIALIZER( struct cmd_add_port_meter_profile_trtcm_rfc4115_result, meter, "meter"); static cmdline_parse_token_string_t cmd_add_port_meter_profile_trtcm_rfc4115_profile = TOKEN_STRING_INITIALIZER( struct cmd_add_port_meter_profile_trtcm_rfc4115_result, profile, "profile"); static cmdline_parse_token_string_t cmd_add_port_meter_profile_trtcm_rfc4115_trtcm_rfc4115 = TOKEN_STRING_INITIALIZER( struct cmd_add_port_meter_profile_trtcm_rfc4115_result, trtcm_rfc4115, "trtcm_rfc4115"); static 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, RTE_UINT16); static 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, RTE_UINT32); static 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, RTE_UINT64); static 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, RTE_UINT64); static 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, RTE_UINT64); static 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, RTE_UINT64); static 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, __rte_unused struct cmdline *cl, __rte_unused void *data) { struct cmd_add_port_meter_profile_trtcm_rfc4115_result *res = parsed_result; struct rte_mtr_meter_profile mp; struct rte_mtr_error error; uint32_t profile_id = res->profile_id; uint16_t port_id = res->port_id; int ret; if (port_id_is_invalid(port_id, ENABLED_WARN)) return; /* Private shaper profile params */ memset(&mp, 0, sizeof(struct rte_mtr_meter_profile)); mp.alg = RTE_MTR_TRTCM_RFC4115; mp.trtcm_rfc4115.cir = res->cir; 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) { print_err_msg(&error); return; } } 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 ", .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_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, }, }; /* *** Delete Port Meter Profile *** */ struct cmd_del_port_meter_profile_result { cmdline_fixed_string_t del; cmdline_fixed_string_t port; cmdline_fixed_string_t meter; cmdline_fixed_string_t profile; uint16_t port_id; uint32_t profile_id; }; static cmdline_parse_token_string_t cmd_del_port_meter_profile_del = TOKEN_STRING_INITIALIZER( struct cmd_del_port_meter_profile_result, del, "del"); static cmdline_parse_token_string_t cmd_del_port_meter_profile_port = TOKEN_STRING_INITIALIZER( struct cmd_del_port_meter_profile_result, port, "port"); static cmdline_parse_token_string_t cmd_del_port_meter_profile_meter = TOKEN_STRING_INITIALIZER( struct cmd_del_port_meter_profile_result, meter, "meter"); static cmdline_parse_token_string_t cmd_del_port_meter_profile_profile = TOKEN_STRING_INITIALIZER( struct cmd_del_port_meter_profile_result, profile, "profile"); static cmdline_parse_token_num_t cmd_del_port_meter_profile_port_id = TOKEN_NUM_INITIALIZER( struct cmd_del_port_meter_profile_result, port_id, RTE_UINT16); static cmdline_parse_token_num_t cmd_del_port_meter_profile_profile_id = TOKEN_NUM_INITIALIZER( struct cmd_del_port_meter_profile_result, profile_id, RTE_UINT32); static void cmd_del_port_meter_profile_parsed(void *parsed_result, __rte_unused struct cmdline *cl, __rte_unused void *data) { struct cmd_del_port_meter_profile_result *res = parsed_result; struct rte_mtr_error error; uint32_t profile_id = res->profile_id; uint16_t port_id = res->port_id; int ret; if (port_id_is_invalid(port_id, ENABLED_WARN)) return; /* Delete meter profile */ ret = rte_mtr_meter_profile_delete(port_id, profile_id, &error); if (ret != 0) { print_err_msg(&error); return; } } cmdline_parse_inst_t cmd_del_port_meter_profile = { .f = cmd_del_port_meter_profile_parsed, .data = NULL, .help_str = "del port meter profile ", .tokens = { (void *)&cmd_del_port_meter_profile_del, (void *)&cmd_del_port_meter_profile_port, (void *)&cmd_del_port_meter_profile_meter, (void *)&cmd_del_port_meter_profile_profile, (void *)&cmd_del_port_meter_profile_port_id, (void *)&cmd_del_port_meter_profile_profile_id, NULL, }, }; /* *** Create Port Meter Object *** */ struct cmd_create_port_meter_result { cmdline_fixed_string_t create; cmdline_fixed_string_t port; cmdline_fixed_string_t meter; 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; cmdline_fixed_string_t r_action; uint64_t statistics_mask; uint32_t shared; cmdline_fixed_string_t default_input_color; cmdline_multi_string_t meter_input_color; }; static cmdline_parse_token_string_t cmd_create_port_meter_create = TOKEN_STRING_INITIALIZER( struct cmd_create_port_meter_result, create, "create"); static cmdline_parse_token_string_t cmd_create_port_meter_port = TOKEN_STRING_INITIALIZER( struct cmd_create_port_meter_result, port, "port"); static cmdline_parse_token_string_t cmd_create_port_meter_meter = TOKEN_STRING_INITIALIZER( struct cmd_create_port_meter_result, meter, "meter"); static cmdline_parse_token_num_t cmd_create_port_meter_port_id = TOKEN_NUM_INITIALIZER( struct cmd_create_port_meter_result, port_id, RTE_UINT16); static cmdline_parse_token_num_t cmd_create_port_meter_mtr_id = TOKEN_NUM_INITIALIZER( struct cmd_create_port_meter_result, mtr_id, RTE_UINT32); static cmdline_parse_token_num_t cmd_create_port_meter_profile_id = TOKEN_NUM_INITIALIZER( struct cmd_create_port_meter_result, profile_id, RTE_UINT32); static cmdline_parse_token_num_t cmd_create_port_meter_policy_id = TOKEN_NUM_INITIALIZER( struct cmd_create_port_meter_result, policy_id, RTE_UINT32); static cmdline_parse_token_string_t cmd_create_port_meter_meter_enable = TOKEN_STRING_INITIALIZER(struct cmd_create_port_meter_result, meter_enable, "yes#no"); static cmdline_parse_token_num_t cmd_create_port_meter_statistics_mask = TOKEN_NUM_INITIALIZER(struct cmd_create_port_meter_result, statistics_mask, RTE_UINT64); static cmdline_parse_token_num_t cmd_create_port_meter_shared = TOKEN_NUM_INITIALIZER(struct cmd_create_port_meter_result, shared, RTE_UINT32); static cmdline_parse_token_string_t cmd_create_port_meter_default_input_color = TOKEN_STRING_INITIALIZER(struct cmd_create_port_meter_result, default_input_color, "R#Y#G#r#y#g"); static 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, __rte_unused struct cmdline *cl, __rte_unused void *data) { struct cmd_create_port_meter_result *res = parsed_result; struct rte_mtr_error error; struct rte_mtr_params params; uint32_t mtr_id = res->mtr_id; uint32_t shared = res->shared; uint32_t use_prev_meter_color = 0; uint16_t port_id = res->port_id; uint64_t def_inp_color = 0; enum rte_color *dscp_table = NULL; enum rte_color *vlan_table = NULL; char *def_color_str = res->default_input_color; char *c_str = res->meter_input_color; int ret; if (port_id_is_invalid(port_id, ENABLED_WARN)) return; /* 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 default input color string params */ ret = parse_default_input_color_str(def_color_str, &def_inp_color); if (ret) { fprintf(stderr, " Meter default input color is invalid\n"); return; } /* Parse meter input color string params */ ret = parse_meter_color_str(c_str, &use_prev_meter_color, &vlan_table, &dscp_table); if (ret) { fprintf(stderr, " Meter input color params string parse error\n"); return; } params.use_prev_mtr_color = use_prev_meter_color; params.vlan_table = vlan_table; params.dscp_table = dscp_table; params.default_input_color = def_inp_color; if (strcmp(res->meter_enable, "yes") == 0) params.meter_enable = 1; else params.meter_enable = 0; params.stats_mask = res->statistics_mask; ret = rte_mtr_create(port_id, mtr_id, ¶ms, shared, &error); if (ret != 0) { free(vlan_table); free(dscp_table); print_err_msg(&error); return; } } cmdline_parse_inst_t cmd_create_port_meter = { .f = cmd_create_port_meter_parsed, .data = NULL, .help_str = "create port meter " "(yes|no) " "(g|y|r) " "[ ...] " "[ ... ]", .tokens = { (void *)&cmd_create_port_meter_create, (void *)&cmd_create_port_meter_port, (void *)&cmd_create_port_meter_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_statistics_mask, (void *)&cmd_create_port_meter_shared, (void *)&cmd_create_port_meter_default_input_color, (void *)&cmd_create_port_meter_input_color, NULL, }, }; /* *** 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; }; static cmdline_parse_token_string_t cmd_enable_port_meter_enable = TOKEN_STRING_INITIALIZER( struct cmd_enable_port_meter_result, enable, "enable"); static cmdline_parse_token_string_t cmd_enable_port_meter_port = TOKEN_STRING_INITIALIZER( struct cmd_enable_port_meter_result, port, "port"); static cmdline_parse_token_string_t cmd_enable_port_meter_meter = TOKEN_STRING_INITIALIZER( struct cmd_enable_port_meter_result, meter, "meter"); static cmdline_parse_token_num_t cmd_enable_port_meter_port_id = TOKEN_NUM_INITIALIZER( struct cmd_enable_port_meter_result, port_id, RTE_UINT16); static 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; }; static cmdline_parse_token_string_t cmd_disable_port_meter_disable = TOKEN_STRING_INITIALIZER( struct cmd_disable_port_meter_result, disable, "disable"); static cmdline_parse_token_string_t cmd_disable_port_meter_port = TOKEN_STRING_INITIALIZER( struct cmd_disable_port_meter_result, port, "port"); static cmdline_parse_token_string_t cmd_disable_port_meter_meter = TOKEN_STRING_INITIALIZER( struct cmd_disable_port_meter_result, meter, "meter"); static cmdline_parse_token_num_t cmd_disable_port_meter_port_id = TOKEN_NUM_INITIALIZER( struct cmd_disable_port_meter_result, port_id, RTE_UINT16); static 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; }; static cmdline_parse_token_string_t cmd_del_port_meter_policy_del = TOKEN_STRING_INITIALIZER( struct cmd_del_port_meter_policy_result, del, "del"); static cmdline_parse_token_string_t cmd_del_port_meter_policy_port = TOKEN_STRING_INITIALIZER( struct cmd_del_port_meter_policy_result, port, "port"); static cmdline_parse_token_string_t cmd_del_port_meter_policy_meter = TOKEN_STRING_INITIALIZER( struct cmd_del_port_meter_policy_result, meter, "meter"); static cmdline_parse_token_string_t cmd_del_port_meter_policy_policy = TOKEN_STRING_INITIALIZER( struct cmd_del_port_meter_policy_result, policy, "policy"); static 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); static 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; cmdline_fixed_string_t port; cmdline_fixed_string_t meter; uint16_t port_id; uint32_t mtr_id; }; static cmdline_parse_token_string_t cmd_del_port_meter_del = TOKEN_STRING_INITIALIZER( struct cmd_del_port_meter_result, del, "del"); static cmdline_parse_token_string_t cmd_del_port_meter_port = TOKEN_STRING_INITIALIZER( struct cmd_del_port_meter_result, port, "port"); static cmdline_parse_token_string_t cmd_del_port_meter_meter = TOKEN_STRING_INITIALIZER( struct cmd_del_port_meter_result, meter, "meter"); static cmdline_parse_token_num_t cmd_del_port_meter_port_id = TOKEN_NUM_INITIALIZER( struct cmd_del_port_meter_result, port_id, RTE_UINT16); static cmdline_parse_token_num_t cmd_del_port_meter_mtr_id = TOKEN_NUM_INITIALIZER( struct cmd_del_port_meter_result, mtr_id, RTE_UINT32); static void cmd_del_port_meter_parsed(void *parsed_result, __rte_unused struct cmdline *cl, __rte_unused void *data) { struct cmd_del_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; /* Destroy Meter */ ret = rte_mtr_destroy(port_id, mtr_id, &error); if (ret != 0) { print_err_msg(&error); return; } } cmdline_parse_inst_t cmd_del_port_meter = { .f = cmd_del_port_meter_parsed, .data = NULL, .help_str = "del port meter ", .tokens = { (void *)&cmd_del_port_meter_del, (void *)&cmd_del_port_meter_port, (void *)&cmd_del_port_meter_meter, (void *)&cmd_del_port_meter_port_id, (void *)&cmd_del_port_meter_mtr_id, NULL, }, }; /* *** Set Port Meter Profile *** */ struct cmd_set_port_meter_profile_result { cmdline_fixed_string_t set; cmdline_fixed_string_t port; cmdline_fixed_string_t meter; cmdline_fixed_string_t profile; uint16_t port_id; uint32_t mtr_id; uint32_t profile_id; }; static cmdline_parse_token_string_t cmd_set_port_meter_profile_set = TOKEN_STRING_INITIALIZER( struct cmd_set_port_meter_profile_result, set, "set"); static cmdline_parse_token_string_t cmd_set_port_meter_profile_port = TOKEN_STRING_INITIALIZER( struct cmd_set_port_meter_profile_result, port, "port"); static cmdline_parse_token_string_t cmd_set_port_meter_profile_meter = TOKEN_STRING_INITIALIZER( struct cmd_set_port_meter_profile_result, meter, "meter"); static cmdline_parse_token_string_t cmd_set_port_meter_profile_profile = TOKEN_STRING_INITIALIZER( struct cmd_set_port_meter_profile_result, profile, "profile"); static cmdline_parse_token_num_t cmd_set_port_meter_profile_port_id = TOKEN_NUM_INITIALIZER( struct cmd_set_port_meter_profile_result, port_id, RTE_UINT16); static cmdline_parse_token_num_t cmd_set_port_meter_profile_mtr_id = TOKEN_NUM_INITIALIZER( struct cmd_set_port_meter_profile_result, mtr_id, RTE_UINT32); static cmdline_parse_token_num_t cmd_set_port_meter_profile_profile_id = TOKEN_NUM_INITIALIZER( struct cmd_set_port_meter_profile_result, profile_id, RTE_UINT32); static void cmd_set_port_meter_profile_parsed(void *parsed_result, __rte_unused struct cmdline *cl, __rte_unused void *data) { struct cmd_set_port_meter_profile_result *res = parsed_result; struct rte_mtr_error error; uint32_t mtr_id = res->mtr_id; uint32_t profile_id = res->profile_id; uint16_t port_id = res->port_id; int ret; if (port_id_is_invalid(port_id, ENABLED_WARN)) return; /* Set meter profile */ ret = rte_mtr_meter_profile_update(port_id, mtr_id, profile_id, &error); if (ret != 0) { print_err_msg(&error); return; } } cmdline_parse_inst_t cmd_set_port_meter_profile = { .f = cmd_set_port_meter_profile_parsed, .data = NULL, .help_str = "set port meter profile ", .tokens = { (void *)&cmd_set_port_meter_profile_set, (void *)&cmd_set_port_meter_profile_port, (void *)&cmd_set_port_meter_profile_meter, (void *)&cmd_set_port_meter_profile_profile, (void *)&cmd_set_port_meter_profile_port_id, (void *)&cmd_set_port_meter_profile_mtr_id, (void *)&cmd_set_port_meter_profile_profile_id, NULL, }, }; /* *** 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; }; static 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"); static 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"); static 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"); static 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"); static 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) { fprintf(stderr, " 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 = "set 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 VLAN Table *** */ struct cmd_set_port_meter_vlan_table_result { cmdline_fixed_string_t set; cmdline_fixed_string_t port; cmdline_fixed_string_t meter; cmdline_fixed_string_t vlan_table; cmdline_multi_string_t token_string; }; static cmdline_parse_token_string_t cmd_set_port_meter_vlan_table_set = TOKEN_STRING_INITIALIZER( struct cmd_set_port_meter_vlan_table_result, set, "set"); static cmdline_parse_token_string_t cmd_set_port_meter_vlan_table_port = TOKEN_STRING_INITIALIZER( struct cmd_set_port_meter_vlan_table_result, port, "port"); static cmdline_parse_token_string_t cmd_set_port_meter_vlan_table_meter = TOKEN_STRING_INITIALIZER( struct cmd_set_port_meter_vlan_table_result, meter, "meter"); static cmdline_parse_token_string_t cmd_set_port_meter_vlan_table_vlan_table = TOKEN_STRING_INITIALIZER( struct cmd_set_port_meter_vlan_table_result, vlan_table, "vlan table"); static cmdline_parse_token_string_t cmd_set_port_meter_vlan_table_token_string = TOKEN_STRING_INITIALIZER(struct cmd_set_port_meter_vlan_table_result, token_string, TOKEN_STRING_MULTI); static void cmd_set_port_meter_vlan_table_parsed(void *parsed_result, __rte_unused struct cmdline *cl, __rte_unused void *data) { struct cmd_set_port_meter_vlan_table_result *res = parsed_result; struct rte_mtr_error error; enum rte_color *vlan_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_vlan_str(t_str, &port_id, &mtr_id, &vlan_table); if (ret) { fprintf(stderr, " Multi token string parse error\n"); return; } if (port_id_is_invalid(port_id, ENABLED_WARN)) goto free_table; /* Update Meter VLAN Table*/ ret = rte_mtr_meter_vlan_table_update(port_id, mtr_id, vlan_table, &error); if (ret != 0) print_err_msg(&error); free_table: free(vlan_table); } cmdline_parse_inst_t cmd_set_port_meter_vlan_table = { .f = cmd_set_port_meter_vlan_table_parsed, .data = NULL, .help_str = "set port meter vlan table " "[ ... ]", .tokens = { (void *)&cmd_set_port_meter_vlan_table_set, (void *)&cmd_set_port_meter_vlan_table_port, (void *)&cmd_set_port_meter_vlan_table_meter, (void *)&cmd_set_port_meter_vlan_table_vlan_table, (void *)&cmd_set_port_meter_vlan_table_token_string, NULL, }, }; /* *** Set Port Meter input protocol *** */ struct cmd_set_port_meter_in_proto_result { cmdline_fixed_string_t set; cmdline_fixed_string_t port; cmdline_fixed_string_t meter; cmdline_fixed_string_t protocol; cmdline_fixed_string_t proto; uint32_t prio; uint32_t mtr_id; uint16_t port_id; }; static cmdline_parse_token_string_t cmd_set_port_meter_in_proto_set = TOKEN_STRING_INITIALIZER( struct cmd_set_port_meter_in_proto_result, set, "set"); static cmdline_parse_token_string_t cmd_set_port_meter_in_proto_port = TOKEN_STRING_INITIALIZER( struct cmd_set_port_meter_in_proto_result, port, "port"); static cmdline_parse_token_string_t cmd_set_port_meter_in_proto_meter = TOKEN_STRING_INITIALIZER( struct cmd_set_port_meter_in_proto_result, meter, "meter"); static cmdline_parse_token_string_t cmd_set_port_meter_in_proto_protocol = TOKEN_STRING_INITIALIZER( struct cmd_set_port_meter_in_proto_result, protocol, "proto"); static cmdline_parse_token_string_t cmd_set_port_meter_in_proto_proto = TOKEN_STRING_INITIALIZER( struct cmd_set_port_meter_in_proto_result, proto, "outer_vlan#inner_vlan#outer_ip#inner_ip"); static cmdline_parse_token_num_t cmd_set_port_meter_in_proto_prio = TOKEN_NUM_INITIALIZER( struct cmd_set_port_meter_in_proto_result, prio, RTE_UINT32); static cmdline_parse_token_num_t cmd_set_port_meter_in_proto_port_id = TOKEN_NUM_INITIALIZER( struct cmd_set_port_meter_in_proto_result, port_id, RTE_UINT16); static cmdline_parse_token_num_t cmd_set_port_meter_in_proto_mtr_id = TOKEN_NUM_INITIALIZER( struct cmd_set_port_meter_in_proto_result, mtr_id, RTE_UINT32); static void cmd_set_port_meter_in_proto_parsed(void *parsed_result, __rte_unused struct cmdline *cl, __rte_unused void *data) { struct cmd_set_port_meter_in_proto_result *res = parsed_result; enum rte_mtr_color_in_protocol proto; struct rte_mtr_error error; int ret; if (port_id_is_invalid(res->port_id, ENABLED_WARN)) return; if (strcmp(res->proto, "outer_vlan") == 0) proto = RTE_MTR_COLOR_IN_PROTO_OUTER_VLAN; else if (strcmp(res->proto, "inner_vlan") == 0) proto = RTE_MTR_COLOR_IN_PROTO_INNER_VLAN; else if (strcmp(res->proto, "outer_ip") == 0) proto = RTE_MTR_COLOR_IN_PROTO_OUTER_IP; else if (strcmp(res->proto, "inner_ip") == 0) proto = RTE_MTR_COLOR_IN_PROTO_INNER_IP; else { printf("Invalid protocol\n"); return; } /* Update Meter input proto and priority */ ret = rte_mtr_color_in_protocol_set(res->port_id, res->mtr_id, proto, res->prio, &error); if (ret != 0) print_err_msg(&error); } cmdline_parse_inst_t cmd_set_port_meter_in_proto = { .f = cmd_set_port_meter_in_proto_parsed, .data = NULL, .help_str = "set port meter proto " "", .tokens = { (void *)&cmd_set_port_meter_in_proto_set, (void *)&cmd_set_port_meter_in_proto_port, (void *)&cmd_set_port_meter_in_proto_meter, (void *)&cmd_set_port_meter_in_proto_protocol, (void *)&cmd_set_port_meter_in_proto_port_id, (void *)&cmd_set_port_meter_in_proto_mtr_id, (void *)&cmd_set_port_meter_in_proto_proto, (void *)&cmd_set_port_meter_in_proto_prio, NULL, }, }; /* *** Get Port Meter input protocol *** */ struct cmd_get_port_meter_in_proto_result { cmdline_fixed_string_t get; cmdline_fixed_string_t port; cmdline_fixed_string_t meter; cmdline_fixed_string_t protocol; uint32_t mtr_id; uint16_t port_id; }; static cmdline_parse_token_string_t cmd_get_port_meter_in_proto_get = TOKEN_STRING_INITIALIZER( struct cmd_get_port_meter_in_proto_result, get, "get"); static cmdline_parse_token_string_t cmd_get_port_meter_in_proto_port = TOKEN_STRING_INITIALIZER( struct cmd_get_port_meter_in_proto_result, port, "port"); static cmdline_parse_token_string_t cmd_get_port_meter_in_proto_meter = TOKEN_STRING_INITIALIZER( struct cmd_get_port_meter_in_proto_result, meter, "meter"); static cmdline_parse_token_string_t cmd_get_port_meter_in_proto_protocol = TOKEN_STRING_INITIALIZER( struct cmd_get_port_meter_in_proto_result, protocol, "proto"); static cmdline_parse_token_num_t cmd_get_port_meter_in_proto_port_id = TOKEN_NUM_INITIALIZER( struct cmd_get_port_meter_in_proto_result, port_id, RTE_UINT16); static cmdline_parse_token_num_t cmd_get_port_meter_in_proto_mtr_id = TOKEN_NUM_INITIALIZER( struct cmd_get_port_meter_in_proto_result, mtr_id, RTE_UINT32); static void cmd_get_port_meter_in_proto_parsed(void *parsed_result, __rte_unused struct cmdline *cl, __rte_unused void *data) { struct cmd_set_port_meter_in_proto_result *res = parsed_result; struct rte_mtr_error error; uint64_t proto_mask = 0; int ret; if (port_id_is_invalid(res->port_id, ENABLED_WARN)) return; /* Update Meter input proto and priority */ ret = rte_mtr_color_in_protocol_get(res->port_id, res->mtr_id, &proto_mask, &error); if (ret != 0) print_err_msg(&error); printf("Enabled protocols:\n"); if (proto_mask & RTE_MTR_COLOR_IN_PROTO_OUTER_VLAN) printf("\touter_vlan\n"); if (proto_mask & RTE_MTR_COLOR_IN_PROTO_INNER_VLAN) printf("\tinner_vlan\n"); if (proto_mask & RTE_MTR_COLOR_IN_PROTO_OUTER_IP) printf("\touter_ip\n"); if (proto_mask & RTE_MTR_COLOR_IN_PROTO_INNER_IP) printf("\tinner_ip\n"); } cmdline_parse_inst_t cmd_get_port_meter_in_proto = { .f = cmd_get_port_meter_in_proto_parsed, .data = NULL, .help_str = "get port meter proto ", .tokens = { (void *)&cmd_get_port_meter_in_proto_get, (void *)&cmd_get_port_meter_in_proto_port, (void *)&cmd_get_port_meter_in_proto_meter, (void *)&cmd_get_port_meter_in_proto_protocol, (void *)&cmd_get_port_meter_in_proto_port_id, (void *)&cmd_get_port_meter_in_proto_mtr_id, NULL, }, }; /* *** Get Port Meter input protocol priority *** */ struct cmd_get_port_meter_in_proto_prio_result { cmdline_fixed_string_t get; cmdline_fixed_string_t port; cmdline_fixed_string_t meter; cmdline_fixed_string_t protocol; cmdline_fixed_string_t proto; uint32_t mtr_id; uint16_t port_id; }; static cmdline_parse_token_string_t cmd_get_port_meter_in_proto_prio_get = TOKEN_STRING_INITIALIZER( struct cmd_get_port_meter_in_proto_prio_result, get, "get"); static cmdline_parse_token_string_t cmd_get_port_meter_in_proto_prio_port = TOKEN_STRING_INITIALIZER( struct cmd_get_port_meter_in_proto_prio_result, port, "port"); static cmdline_parse_token_string_t cmd_get_port_meter_in_proto_prio_meter = TOKEN_STRING_INITIALIZER( struct cmd_get_port_meter_in_proto_prio_result, meter, "meter"); static cmdline_parse_token_string_t cmd_get_port_meter_in_proto_prio_protocol = TOKEN_STRING_INITIALIZER( struct cmd_get_port_meter_in_proto_prio_result, protocol, "proto_prio"); static cmdline_parse_token_string_t cmd_get_port_meter_in_proto_prio_proto = TOKEN_STRING_INITIALIZER( struct cmd_get_port_meter_in_proto_prio_result, proto, "outer_vlan#inner_vlan#outer_ip#inner_ip"); static cmdline_parse_token_num_t cmd_get_port_meter_in_proto_prio_port_id = TOKEN_NUM_INITIALIZER( struct cmd_get_port_meter_in_proto_prio_result, port_id, RTE_UINT16); static cmdline_parse_token_num_t cmd_get_port_meter_in_proto_prio_mtr_id = TOKEN_NUM_INITIALIZER( struct cmd_get_port_meter_in_proto_prio_result, mtr_id, RTE_UINT32); static void cmd_get_port_meter_in_proto_prio_parsed(void *parsed_result, __rte_unused struct cmdline *cl, __rte_unused void *data) { struct cmd_get_port_meter_in_proto_prio_result *res = parsed_result; enum rte_mtr_color_in_protocol proto; struct rte_mtr_error error; uint32_t prio = 0; int ret; if (port_id_is_invalid(res->port_id, ENABLED_WARN)) return; if (strcmp(res->proto, "outer_vlan") == 0) proto = RTE_MTR_COLOR_IN_PROTO_OUTER_VLAN; else if (strcmp(res->proto, "inner_vlan") == 0) proto = RTE_MTR_COLOR_IN_PROTO_INNER_VLAN; else if (strcmp(res->proto, "outer_ip") == 0) proto = RTE_MTR_COLOR_IN_PROTO_OUTER_IP; else if (strcmp(res->proto, "inner_ip") == 0) proto = RTE_MTR_COLOR_IN_PROTO_INNER_IP; else { printf("Invalid protocol\n"); return; } /* Get Meter input proto and priority */ ret = rte_mtr_color_in_protocol_priority_get(res->port_id, res->mtr_id, proto, &prio, &error); if (ret != 0) print_err_msg(&error); } cmdline_parse_inst_t cmd_get_port_meter_in_proto_prio = { .f = cmd_get_port_meter_in_proto_prio_parsed, .data = NULL, .help_str = "get port meter proto_prio ", .tokens = { (void *)&cmd_get_port_meter_in_proto_prio_get, (void *)&cmd_get_port_meter_in_proto_prio_port, (void *)&cmd_get_port_meter_in_proto_prio_meter, (void *)&cmd_get_port_meter_in_proto_prio_protocol, (void *)&cmd_get_port_meter_in_proto_prio_port_id, (void *)&cmd_get_port_meter_in_proto_prio_mtr_id, (void *)&cmd_get_port_meter_in_proto_prio_proto, NULL, }, }; /* *** Set Port Meter Stats Mask *** */ struct cmd_set_port_meter_stats_mask_result { cmdline_fixed_string_t set; cmdline_fixed_string_t port; cmdline_fixed_string_t meter; cmdline_fixed_string_t stats; cmdline_fixed_string_t mask; uint16_t port_id; uint32_t mtr_id; uint64_t stats_mask; }; static cmdline_parse_token_string_t cmd_set_port_meter_stats_mask_set = TOKEN_STRING_INITIALIZER( struct cmd_set_port_meter_stats_mask_result, set, "set"); static cmdline_parse_token_string_t cmd_set_port_meter_stats_mask_port = TOKEN_STRING_INITIALIZER( struct cmd_set_port_meter_stats_mask_result, port, "port"); static cmdline_parse_token_string_t cmd_set_port_meter_stats_mask_meter = TOKEN_STRING_INITIALIZER( struct cmd_set_port_meter_stats_mask_result, meter, "meter"); static cmdline_parse_token_string_t cmd_set_port_meter_stats_mask_stats = TOKEN_STRING_INITIALIZER( struct cmd_set_port_meter_stats_mask_result, stats, "stats"); static cmdline_parse_token_string_t cmd_set_port_meter_stats_mask_mask = TOKEN_STRING_INITIALIZER( struct cmd_set_port_meter_stats_mask_result, mask, "mask"); static 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, RTE_UINT16); static 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, RTE_UINT32); static 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, RTE_UINT64); static void cmd_set_port_meter_stats_mask_parsed(void *parsed_result, __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; uint64_t stats_mask = res->stats_mask; 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; ret = rte_mtr_stats_update(port_id, mtr_id, stats_mask, &error); if (ret != 0) { print_err_msg(&error); return; } } 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 ", .tokens = { (void *)&cmd_set_port_meter_stats_mask_set, (void *)&cmd_set_port_meter_stats_mask_port, (void *)&cmd_set_port_meter_stats_mask_meter, (void *)&cmd_set_port_meter_stats_mask_stats, (void *)&cmd_set_port_meter_stats_mask_mask, (void *)&cmd_set_port_meter_stats_mask_port_id, (void *)&cmd_set_port_meter_stats_mask_mtr_id, (void *)&cmd_set_port_meter_stats_mask_stats_mask, NULL, }, }; /* *** Show Port Meter Stats *** */ struct cmd_show_port_meter_stats_result { cmdline_fixed_string_t show; cmdline_fixed_string_t port; cmdline_fixed_string_t meter; cmdline_fixed_string_t stats; uint16_t port_id; uint32_t mtr_id; cmdline_fixed_string_t clear; }; static cmdline_parse_token_string_t cmd_show_port_meter_stats_show = TOKEN_STRING_INITIALIZER( struct cmd_show_port_meter_stats_result, show, "show"); static cmdline_parse_token_string_t cmd_show_port_meter_stats_port = TOKEN_STRING_INITIALIZER( struct cmd_show_port_meter_stats_result, port, "port"); static cmdline_parse_token_string_t cmd_show_port_meter_stats_meter = TOKEN_STRING_INITIALIZER( struct cmd_show_port_meter_stats_result, meter, "meter"); static cmdline_parse_token_string_t cmd_show_port_meter_stats_stats = TOKEN_STRING_INITIALIZER( struct cmd_show_port_meter_stats_result, stats, "stats"); static cmdline_parse_token_num_t cmd_show_port_meter_stats_port_id = TOKEN_NUM_INITIALIZER( struct cmd_show_port_meter_stats_result, port_id, RTE_UINT16); static cmdline_parse_token_num_t cmd_show_port_meter_stats_mtr_id = TOKEN_NUM_INITIALIZER( struct cmd_show_port_meter_stats_result, mtr_id, RTE_UINT32); static 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, __rte_unused struct cmdline *cl, __rte_unused void *data) { struct cmd_show_port_meter_stats_result *res = parsed_result; struct rte_mtr_stats stats; uint64_t stats_mask = 0; struct rte_mtr_error error; uint32_t mtr_id = res->mtr_id; uint32_t clear = 0; uint16_t port_id = res->port_id; int ret; if (port_id_is_invalid(port_id, ENABLED_WARN)) return; if (strcmp(res->clear, "yes") == 0) clear = 1; memset(&stats, 0, sizeof(struct rte_mtr_stats)); ret = rte_mtr_stats_read(port_id, mtr_id, &stats, &stats_mask, clear, &error); if (ret != 0) { print_err_msg(&error); return; } /* Display stats */ if (stats_mask & RTE_MTR_STATS_N_PKTS_GREEN) printf("\tPkts G: %" PRIu64 "\n", stats.n_pkts[RTE_COLOR_GREEN]); if (stats_mask & RTE_MTR_STATS_N_BYTES_GREEN) printf("\tBytes G: %" PRIu64 "\n", stats.n_bytes[RTE_COLOR_GREEN]); if (stats_mask & RTE_MTR_STATS_N_PKTS_YELLOW) printf("\tPkts Y: %" PRIu64 "\n", stats.n_pkts[RTE_COLOR_YELLOW]); if (stats_mask & RTE_MTR_STATS_N_BYTES_YELLOW) printf("\tBytes Y: %" PRIu64 "\n", stats.n_bytes[RTE_COLOR_YELLOW]); if (stats_mask & RTE_MTR_STATS_N_PKTS_RED) printf("\tPkts R: %" PRIu64 "\n", stats.n_pkts[RTE_COLOR_RED]); if (stats_mask & RTE_MTR_STATS_N_BYTES_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); if (stats_mask & RTE_MTR_STATS_N_BYTES_DROPPED) printf("\tBytes DROPPED: %" PRIu64 "\n", stats.n_bytes_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 (yes|no)", .tokens = { (void *)&cmd_show_port_meter_stats_show, (void *)&cmd_show_port_meter_stats_port, (void *)&cmd_show_port_meter_stats_meter, (void *)&cmd_show_port_meter_stats_stats, (void *)&cmd_show_port_meter_stats_port_id, (void *)&cmd_show_port_meter_stats_mtr_id, (void *)&cmd_show_port_meter_stats_clear, NULL, }, };