diff mbox series

[v4,1/1] app/testpmd: support different input color method

Message ID 20220614100518.533931-1-skori@marvell.com (mailing list archive)
State Superseded, archived
Delegated to: Andrew Rybchenko
Headers
Series [v4,1/1] app/testpmd: support different input color method |

Checks

Context Check Description
ci/checkpatch warning coding style issues
ci/Intel-compilation success Compilation OK
ci/intel-Testing success Testing PASS
ci/github-robot: build success github build: passed
ci/iol-mellanox-Performance success Performance Testing PASS
ci/iol-aarch64-unit-testing success Testing PASS
ci/iol-intel-Performance success Performance Testing PASS
ci/iol-intel-Functional success Functional Testing PASS
ci/iol-aarch64-compile-testing success Testing PASS
ci/iol-x86_64-compile-testing success Testing PASS
ci/iol-x86_64-unit-testing fail Testing issues
ci/iol-abi-testing success Testing PASS

Commit Message

Sunil Kumar Kori June 14, 2022, 10:05 a.m. UTC 
  From: Sunil Kumar Kori <skori@marvell.com>

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 <skori@marvell.com>
Acked-by: Cristian Dumitrescu <cristian.dumitrescu@intel.com>
---
v3..v4:
 - Replace strcmp with strcasecmp whereever is needed.
 
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 | 552 ++++++++++++++++++++++++++++++++++++-
 app/test-pmd/cmdline_mtr.h |   4 +
 3 files changed, 554 insertions(+), 6 deletions(-)

Comments

Andrew Rybchenko June 23, 2022, 11:05 a.m. UTC | #1 
On 6/14/22 13:05, skori@marvell.com wrote:
> From: Sunil Kumar Kori <skori@marvell.com>
> 
> 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 <skori@marvell.com>
> Acked-by: Cristian Dumitrescu <cristian.dumitrescu@intel.com>
> ---
> v3..v4:
>   - Replace strcmp with strcasecmp whereever is needed.
>   
> 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 | 552 ++++++++++++++++++++++++++++++++++++-
>   app/test-pmd/cmdline_mtr.h |   4 +
>   3 files changed, 554 insertions(+), 6 deletions(-)


doc/guides/testpmd_app_ug/testpmd_funcs.rst update is missing.
Please, respin it quickly and I'll process it today.
Sunil Kumar Kori June 23, 2022, 12:54 p.m. UTC | #2 
> -----Original Message-----
> From: Andrew Rybchenko <andrew.rybchenko@oktetlabs.ru>
> Sent: Thursday, June 23, 2022 4:36 PM
> To: Sunil Kumar Kori <skori@marvell.com>; Xiaoyun Li
> <xiaoyun.li@intel.com>; Aman Singh <aman.deep.singh@intel.com>; Yuying
> Zhang <yuying.zhang@intel.com>; Cristian Dumitrescu
> <cristian.dumitrescu@intel.com>
> Cc: dev@dpdk.org
> Subject: [EXT] Re: [PATCH v4 1/1] app/testpmd: support different input color
> method
> 
> External Email
> 
> ----------------------------------------------------------------------
> On 6/14/22 13:05, skori@marvell.com wrote:
> > From: Sunil Kumar Kori <skori@marvell.com>
> >
> > 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 <skori@marvell.com>
> > Acked-by: Cristian Dumitrescu <cristian.dumitrescu@intel.com>
> > ---
> > v3..v4:
> >   - Replace strcmp with strcasecmp whereever is needed.
> >
> > 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 | 552
> ++++++++++++++++++++++++++++++++++++-
> >   app/test-pmd/cmdline_mtr.h |   4 +
> >   3 files changed, 554 insertions(+), 6 deletions(-)
> 
> 
> doc/guides/testpmd_app_ug/testpmd_funcs.rst update is missing.
> Please, respin it quickly and I'll process it today.
Ack.
diff mbox series

Patch

diff --git a/app/test-pmd/cmdline.c b/app/test-pmd/cmdline.c
index a59e6166d5..9a2ae2fee3 100644
--- a/app/test-pmd/cmdline.c
+++ b/app/test-pmd/cmdline.c
@@ -18066,6 +18066,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..3aef91c364 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,122 @@  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 (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)
+		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);
+			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 (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)
 {
@@ -124,9 +241,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 (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 **dscp_table)
+	enum rte_color **vlan_table, enum rte_color **dscp_table)
 {
 	char *token;
 	uint64_t previous_mtr_color = 0;
@@ -147,8 +285,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 +329,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 +451,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 +899,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 +933,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 +951,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 +965,18 @@  static void cmd_create_port_meter_parsed(void *parsed_result,
 	memset(&params, 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 +984,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, &params, shared, &error);
 	if (ret != 0) {
+		free(vlan_table);
 		free(dscp_table);
 		print_err_msg(&error);
 		return;
@@ -809,8 +1008,10 @@  cmdline_parse_inst_t cmd_create_port_meter = {
 	.f = cmd_create_port_meter_parsed,
 	.data = NULL,
 	.help_str = "create port meter <port_id> <mtr_id> <profile_id> <policy_id> "
-		"<meter_enable>(yes|no) <stats_mask> <shared> <use_pre_meter_color> "
-		"[<dscp_tbl_entry0> <dscp_tbl_entry1> ...<dscp_tbl_entry63>]",
+		"<meter_enable>(yes|no) <stats_mask> <shared> "
+		"<default_input_color>(g|y|r) <use_pre_meter_color> "
+		"[<dscp_tbl_entry0> <dscp_tbl_entry1> ...<dscp_tbl_entry63>] "
+		"[<vlan_tbl_entry0> <vlan_tbl_entry1> ... <vlan_tbl_entry16>]",
 	.tokens = {
 		(void *)&cmd_create_port_meter_create,
 		(void *)&cmd_create_port_meter_port,
@@ -822,6 +1023,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 +1426,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 <port_id> <mtr_id> "
+		"[<vlan_tbl_entry0> <vlan_tbl_entry1> ... <vlan_tbl_entry15>]",
+	.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 <port_id> <mtr_id> <proto> "
+		"<prio>",
+	.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 <port_id> <mtr_id>",
+	.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 <port_id> <mtr_id> <proto>",
+	.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);