From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mails.dpdk.org (mails.dpdk.org [217.70.189.124]) by inbox.dpdk.org (Postfix) with ESMTP id 6B443A04FF; Tue, 24 May 2022 09:36:04 +0200 (CEST) Received: from [217.70.189.124] (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id 28CE54014F; Tue, 24 May 2022 09:36:04 +0200 (CEST) Received: from mx0b-0016f401.pphosted.com (mx0a-0016f401.pphosted.com [67.231.148.174]) by mails.dpdk.org (Postfix) with ESMTP id 7E4E3400D6 for ; Tue, 24 May 2022 09:36:02 +0200 (CEST) Received: from pps.filterd (m0045849.ppops.net [127.0.0.1]) by mx0a-0016f401.pphosted.com (8.17.1.5/8.17.1.5) with ESMTP id 24NNBB7v022471; Tue, 24 May 2022 00:36:01 -0700 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=marvell.com; h=from : to : cc : subject : date : message-id : in-reply-to : references : mime-version : content-transfer-encoding : content-type; s=pfpt0220; bh=qTgyCEMcuiFFqvq3I1RgzRuVUaRVOuu7Wq3uWorZyQg=; b=WD6qC1v1JmXSUu/CglapAX2pX5LPzzwDR6gO9guir4AdJzmiwUnwl/FHJryWKBcl0YRh pbshZfsfURnJgp0e9LBn6sb0aGEFlavRQPqpiijzpNHgnZbcse4hQPSu9nDwVON+kocL 8ECHEK67LB3y/95ZOGLx3Kc8VxPMe0k1c2rWCi6aLguEiN0tzzSTpQ7xKliXfzLOd4t1 6Lqjb8LzlIJSOslqOKThE6vTad0j69x9IL6a6U3S5RD28bcYoblY47lEToNPIi8b/8Ej 6DCcQwon5oq55nv9jc0m2uCK6BQP6SBYxc6dz99XUAazveBNZDVGRYOVDKcD+feTDv8Y kQ== Received: from dc5-exch02.marvell.com ([199.233.59.182]) by mx0a-0016f401.pphosted.com (PPS) with ESMTPS id 3g8kqjhg0v-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-SHA384 bits=256 verify=NOT); Tue, 24 May 2022 00:36:01 -0700 Received: from DC5-EXCH01.marvell.com (10.69.176.38) by DC5-EXCH02.marvell.com (10.69.176.39) with Microsoft SMTP Server (TLS) id 15.0.1497.18; Tue, 24 May 2022 00:35:59 -0700 Received: from maili.marvell.com (10.69.176.80) by DC5-EXCH01.marvell.com (10.69.176.38) with Microsoft SMTP Server id 15.0.1497.2 via Frontend Transport; Tue, 24 May 2022 00:35:59 -0700 Received: from localhost.localdomain (unknown [10.28.34.25]) by maili.marvell.com (Postfix) with ESMTP id 7FB7F679AA; Tue, 24 May 2022 00:35:57 -0700 (PDT) From: To: Xiaoyun Li , Aman Singh , Yuying Zhang , Cristian Dumitrescu CC: , Sunil Kumar Kori Subject: [PATCH v2 1/1] app/testpmd: support different input color method Date: Tue, 24 May 2022 13:05:54 +0530 Message-ID: <20220524073554.824162-1-skori@marvell.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20220301090056.1042866-3-skori@marvell.com> References: <20220301090056.1042866-3-skori@marvell.com> MIME-Version: 1.0 Content-Transfer-Encoding: 8bit Content-Type: text/plain X-Proofpoint-ORIG-GUID: P4jsZ16O7LzrM8_l61jdEoolKh90FP50 X-Proofpoint-GUID: P4jsZ16O7LzrM8_l61jdEoolKh90FP50 X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.205,Aquarius:18.0.874,Hydra:6.0.486,FMLib:17.11.64.514 definitions=2022-05-24_05,2022-05-23_01,2022-02-23_01 X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org From: Sunil Kumar Kori To enable input coloring, based on VLAN or DSCP, patch adds command line interface to configure the following: - configuring input coloring using VLAN or DSCP while creating meter i.e. during rte_mtr_create() - Update VLAN input coloring table at runtime. - configures protocol priorities. - retrieve protocol and priority information Signed-off-by: Sunil Kumar Kori --- v1..v2: - Rebased to branch dpdk-next-net - add CLIs for input coloring mechanism app/test-pmd/cmdline.c | 4 + app/test-pmd/cmdline_mtr.c | 558 ++++++++++++++++++++++++++++++++++++- app/test-pmd/cmdline_mtr.h | 4 + 3 files changed, 559 insertions(+), 7 deletions(-) diff --git a/app/test-pmd/cmdline.c b/app/test-pmd/cmdline.c index 1e5b294ab3..03647b2543 100644 --- a/app/test-pmd/cmdline.c +++ b/app/test-pmd/cmdline.c @@ -17972,6 +17972,10 @@ cmdline_parse_ctx_t main_ctx[] = { (cmdline_parse_inst_t *)&cmd_del_port_meter_policy, (cmdline_parse_inst_t *)&cmd_set_port_meter_profile, (cmdline_parse_inst_t *)&cmd_set_port_meter_dscp_table, + (cmdline_parse_inst_t *)&cmd_set_port_meter_vlan_table, + (cmdline_parse_inst_t *)&cmd_set_port_meter_in_proto, + (cmdline_parse_inst_t *)&cmd_get_port_meter_in_proto, + (cmdline_parse_inst_t *)&cmd_get_port_meter_in_proto_prio, (cmdline_parse_inst_t *)&cmd_set_port_meter_stats_mask, (cmdline_parse_inst_t *)&cmd_show_port_meter_stats, (cmdline_parse_inst_t *)&cmd_mcast_addr, diff --git a/app/test-pmd/cmdline_mtr.c b/app/test-pmd/cmdline_mtr.c index ad7ef6ad98..28ec92ad50 100644 --- a/app/test-pmd/cmdline_mtr.c +++ b/app/test-pmd/cmdline_mtr.c @@ -14,6 +14,7 @@ #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 */ @@ -82,6 +83,125 @@ parse_uint(uint64_t *value, const char *str) 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 (strcmp(token, "G") == 0 || strcmp(token, "g") == 0) + dscp[i++] = RTE_COLOR_GREEN; + else if (strcmp(token, "Y") == 0 || strcmp(token, "y") == 0) + dscp[i++] = RTE_COLOR_YELLOW; + else if (strcmp(token, "R") == 0 || strcmp(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) + return -1; + + i = 0; + while (1) { + if (strcmp(token, "G") == 0 || strcmp(token, "g") == 0) + vlan[i++] = RTE_COLOR_GREEN; + else if (strcmp(token, "Y") == 0 || strcmp(token, "y") == 0) + vlan[i++] = RTE_COLOR_YELLOW; + else if (strcmp(token, "R") == 0 || strcmp(token, "r") == 0) + vlan[i++] = RTE_COLOR_RED; + else { + free(vlan); + return -1; + } + if (i == MAX_VLAN_TABLE_ENTRIES) + break; + + token = strtok_r(str, PARSE_DELIMITER, &str); + if (token == NULL) { + free(vlan); + 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 (strcmp(token, "G") == 0 || + strcmp(token, "g") == 0) + (*vlan_table)[i++] = RTE_COLOR_GREEN; + else if (strcmp(token, "Y") == 0 || + strcmp(token, "y") == 0) + (*vlan_table)[i++] = RTE_COLOR_YELLOW; + else if (strcmp(token, "R") == 0 || + strcmp(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) { @@ -124,9 +244,30 @@ parse_dscp_table_entries(char *str, enum rte_color **dscp_table) 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 ((strcmp(token, "G") == 0) || (strcmp(token, "g") == 0)) + *def_inp_color = RTE_COLOR_GREEN; + else if ((strcmp(token, "Y") == 0) || (strcmp(token, "y") == 0)) + *def_inp_color = RTE_COLOR_YELLOW; + else if ((strcmp(token, "R") == 0) || (strcmp(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 **dscp_table) + enum rte_color **vlan_table, enum rte_color **dscp_table) { char *token; uint64_t previous_mtr_color = 0; @@ -147,8 +288,7 @@ parse_meter_color_str(char *c_str, uint32_t *use_prev_meter_color, return 0; } - /* Parse dscp table entries */ - ret = parse_dscp_table_entries(c_str, dscp_table); + ret = parse_input_color_table_entries(c_str, dscp_table, vlan_table); if (ret != 0) return -1; @@ -192,6 +332,43 @@ parse_multi_token_string(char *t_str, uint16_t *port_id, 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; @@ -277,6 +454,10 @@ static void cmd_show_port_meter_cap_parsed(void *parsed_result, 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 = { @@ -721,6 +902,7 @@ struct cmd_create_port_meter_result { 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; }; @@ -763,6 +945,9 @@ cmdline_parse_token_num_t cmd_create_port_meter_statistics_mask = cmdline_parse_token_num_t cmd_create_port_meter_shared = TOKEN_NUM_INITIALIZER(struct cmd_create_port_meter_result, shared, RTE_UINT32); +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"); 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); @@ -778,7 +963,10 @@ 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; + 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; @@ -789,8 +977,18 @@ static void cmd_create_port_meter_parsed(void *parsed_result, 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, &dscp_table); + 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"); @@ -798,16 +996,20 @@ static void cmd_create_port_meter_parsed(void *parsed_result, } 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; @@ -817,9 +1019,11 @@ 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 (yes|no) " - " " - "[ ...]", + .help_str = "create port meter " + "(yes|no) " + "(g|y|r) " + "[ ... ]" + "[ ... ]", .tokens = { (void *)&cmd_create_port_meter_create, (void *)&cmd_create_port_meter_port, @@ -831,6 +1035,7 @@ cmdline_parse_inst_t cmd_create_port_meter = { (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, }, @@ -1233,6 +1438,345 @@ cmdline_parse_inst_t cmd_set_port_meter_dscp_table = { }, }; +/* *** 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; +}; + +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"); +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"); +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"); +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"); +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; +}; + +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"); + +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"); + +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"); + +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"); + +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"); + +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); + +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); + +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 = 0; + 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; +}; + +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"); + +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"); + +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"); + +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"); + +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); + +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; +}; + +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"); + +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"); + +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"); + +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"); + +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"); + +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); + +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; diff --git a/app/test-pmd/cmdline_mtr.h b/app/test-pmd/cmdline_mtr.h index 2415fc16c3..23eaa5bc03 100644 --- a/app/test-pmd/cmdline_mtr.h +++ b/app/test-pmd/cmdline_mtr.h @@ -19,6 +19,10 @@ extern cmdline_parse_inst_t cmd_del_port_meter; extern cmdline_parse_inst_t cmd_del_port_meter_policy; extern cmdline_parse_inst_t cmd_set_port_meter_profile; extern cmdline_parse_inst_t cmd_set_port_meter_dscp_table; +extern cmdline_parse_inst_t cmd_set_port_meter_vlan_table; +extern cmdline_parse_inst_t cmd_set_port_meter_in_proto; +extern cmdline_parse_inst_t cmd_get_port_meter_in_proto; +extern cmdline_parse_inst_t cmd_get_port_meter_in_proto_prio; extern cmdline_parse_inst_t cmd_set_port_meter_stats_mask; extern cmdline_parse_inst_t cmd_show_port_meter_stats; void print_mtr_err_msg(struct rte_mtr_error *error); -- 2.25.1