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 1011DA0560; Fri, 3 Jun 2022 15:06:38 +0200 (CEST) Received: from [217.70.189.124] (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id B75F74069D; Fri, 3 Jun 2022 15:06:37 +0200 (CEST) Received: from mx0b-0016f401.pphosted.com (mx0a-0016f401.pphosted.com [67.231.148.174]) by mails.dpdk.org (Postfix) with ESMTP id 669D340694 for ; Fri, 3 Jun 2022 15:06:36 +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 2533q2T1004366; Fri, 3 Jun 2022 06:06:35 -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=to1BTKl7xPmKIOBatWKdm2P34oge6kbhanRaZKLiywQ=; b=PWuZ+IacASnlrb7ZRWAk7BXUWjJD+ZU0WXIhOyojiLQJCUrLo4hHgB50oenMy6slrcVC YwCOz9BBHhkRU/I9exw8CZzr+xdItPR6bmyW3GGVljYORZaueCWqVR4wJ9ds68Pp0m0t Abvdvft3LZt19L+VyCepE9Krr2iNt3nRGuP1Zt36tUDe+cpYm7snUSaaFyFEOAMzQfbw ZHoT+akedSkYQ6nQKV+I/UzN3O4ezxWr2NiCsksTuf+ZkqcIM0RdeUWEKBXwcImq0a5Q KBqiXsGhq4T5DgiLGSkpoumgMdc9+bIgUYLq+yNZ/zlzzm9vyuTBZ3SONpk/G6OfyFaU AQ== Received: from dc5-exch01.marvell.com ([199.233.59.181]) by mx0a-0016f401.pphosted.com (PPS) with ESMTPS id 3geupud77v-2 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-SHA384 bits=256 verify=NOT); Fri, 03 Jun 2022 06:06:35 -0700 Received: from DC5-EXCH02.marvell.com (10.69.176.39) by DC5-EXCH01.marvell.com (10.69.176.38) with Microsoft SMTP Server (TLS) id 15.0.1497.2; Fri, 3 Jun 2022 06:06:33 -0700 Received: from maili.marvell.com (10.69.176.80) by DC5-EXCH02.marvell.com (10.69.176.39) with Microsoft SMTP Server id 15.0.1497.18 via Frontend Transport; Fri, 3 Jun 2022 06:06:33 -0700 Received: from localhost.localdomain (unknown [10.28.34.25]) by maili.marvell.com (Postfix) with ESMTP id A4BE13F7097; Fri, 3 Jun 2022 06:06:30 -0700 (PDT) From: To: Xiaoyun Li , Aman Singh , Yuying Zhang , Cristian Dumitrescu CC: , Sunil Kumar Kori Subject: [PATCH v3 1/1] app/testpmd: support different input color method Date: Fri, 3 Jun 2022 18:36:27 +0530 Message-ID: <20220603130627.149785-1-skori@marvell.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20220525143716.996398-1-skori@marvell.com> References: <20220525143716.996398-1-skori@marvell.com> MIME-Version: 1.0 Content-Transfer-Encoding: 8bit Content-Type: text/plain X-Proofpoint-GUID: fHoVFTbrcxbtmM6UnaQtz4SLxNyOnro6 X-Proofpoint-ORIG-GUID: fHoVFTbrcxbtmM6UnaQtz4SLxNyOnro6 X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.205,Aquarius:18.0.874,Hydra:6.0.517,FMLib:17.11.64.514 definitions=2022-06-03_04,2022-06-03_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 Depends-on: patch-22751 ("ethdev: mtr: support protocol based input color selection") Signed-off-by: Sunil Kumar Kori Acked-by: Cristian Dumitrescu --- v2..v3: - Rebased to branch ToT dpdk-next-net/main - Fix static keyword for newly added token parsing symbols 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 | 555 ++++++++++++++++++++++++++++++++++++- app/test-pmd/cmdline_mtr.h | 4 + 3 files changed, 557 insertions(+), 6 deletions(-) diff --git a/app/test-pmd/cmdline.c b/app/test-pmd/cmdline.c index fdd0cada3b..5276b4221c 100644 --- a/app/test-pmd/cmdline.c +++ b/app/test-pmd/cmdline.c @@ -17994,6 +17994,10 @@ static cmdline_parse_ctx_t builtin_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 57050ec9af..e81e678e45 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; }; @@ -754,6 +936,9 @@ static cmdline_parse_token_num_t cmd_create_port_meter_statistics_mask = 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); @@ -769,7 +954,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; @@ -780,8 +968,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"); @@ -789,16 +987,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; @@ -809,8 +1011,10 @@ cmdline_parse_inst_t cmd_create_port_meter = { .f = cmd_create_port_meter_parsed, .data = NULL, .help_str = "create port meter " - "(yes|no) " - "[ ...]", + "(yes|no) " + "(g|y|r) " + "[ ...] " + "[ ... ]", .tokens = { (void *)&cmd_create_port_meter_create, (void *)&cmd_create_port_meter_port, @@ -822,6 +1026,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, }, @@ -1224,6 +1429,344 @@ 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; +}; + +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; 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