net: add MPLS header structure
[dpdk.git] / app / test-pmd / cmdline_mtr.c
1 /* SPDX-License-Identifier: BSD-3-Clause
2  * Copyright(c) 2017 Intel Corporation
3  */
4
5 #include <cmdline_parse.h>
6 #include <cmdline_parse_num.h>
7 #include <cmdline_parse_string.h>
8
9 #include <rte_ethdev.h>
10 #include <rte_flow.h>
11 #include <rte_mtr.h>
12
13 #include "testpmd.h"
14 #include "cmdline_mtr.h"
15
16 #define PARSE_DELIMITER                         " \f\n\r\t\v"
17 #define MAX_DSCP_TABLE_ENTRIES          64
18
19 /** Display Meter Error Message */
20 static void
21 print_err_msg(struct rte_mtr_error *error)
22 {
23         static const char *const errstrlist[] = {
24                 [RTE_MTR_ERROR_TYPE_NONE] = "no error",
25                 [RTE_MTR_ERROR_TYPE_UNSPECIFIED] = "cause unspecified",
26                 [RTE_MTR_ERROR_TYPE_METER_PROFILE_ID] = "meter profile id",
27                 [RTE_MTR_ERROR_TYPE_METER_PROFILE] = "meter profile null",
28                 [RTE_MTR_ERROR_TYPE_MTR_ID] = "meter id",
29                 [RTE_MTR_ERROR_TYPE_MTR_PARAMS] = "meter params null",
30                 [RTE_MTR_ERROR_TYPE_POLICER_ACTION_GREEN]
31                         = "policer action(green)",
32                 [RTE_MTR_ERROR_TYPE_POLICER_ACTION_YELLOW]
33                         = "policer action(yellow)",
34                 [RTE_MTR_ERROR_TYPE_POLICER_ACTION_RED]
35                         = "policer action(red)",
36                 [RTE_MTR_ERROR_TYPE_STATS_MASK] = "stats mask",
37                 [RTE_MTR_ERROR_TYPE_STATS] = "stats",
38                 [RTE_MTR_ERROR_TYPE_SHARED]
39                         = "shared meter",
40         };
41
42         const char *errstr;
43         char buf[64];
44
45         if ((unsigned int)error->type >= RTE_DIM(errstrlist) ||
46                 !errstrlist[error->type])
47                 errstr = "unknown type";
48         else
49                 errstr = errstrlist[error->type];
50
51         if (error->cause)
52                 snprintf(buf, sizeof(buf), "cause: %p, ", error->cause);
53
54         printf("%s: %s%s (error %d)\n", errstr, error->cause ? buf : "",
55                 error->message ? error->message : "(no stated reason)",
56                 error->type);
57 }
58
59 static int
60 parse_uint(uint64_t *value, const char *str)
61 {
62         char *next = NULL;
63         uint64_t n;
64
65         errno = 0;
66         /* Parse number string */
67         n = strtol(str, &next, 10);
68         if (errno != 0 || str == next || *next != '\0')
69                 return -1;
70
71         *value = n;
72
73         return 0;
74 }
75
76 static int
77 parse_dscp_table_entries(char *str, enum rte_mtr_color *dscp_table)
78 {
79         char *token;
80         int i = 0;
81
82         token = strtok_r(str, PARSE_DELIMITER, &str);
83         if (token == NULL)
84                 return 0;
85
86         /* Allocate memory for dscp table */
87         dscp_table = (enum rte_mtr_color *)malloc(MAX_DSCP_TABLE_ENTRIES *
88                 sizeof(enum rte_mtr_color));
89         if (dscp_table == NULL)
90                 return -1;
91
92         while (1) {
93                 if (strcmp(token, "G") == 0 ||
94                         strcmp(token, "g") == 0)
95                         dscp_table[i++] = RTE_MTR_GREEN;
96                 else if (strcmp(token, "Y") == 0 ||
97                         strcmp(token, "y") == 0)
98                         dscp_table[i++] = RTE_MTR_YELLOW;
99                 else if (strcmp(token, "R") == 0 ||
100                         strcmp(token, "r") == 0)
101                         dscp_table[i++] = RTE_MTR_RED;
102                 else {
103                         free(dscp_table);
104                         return -1;
105                 }
106                 if (i == MAX_DSCP_TABLE_ENTRIES)
107                         break;
108
109                 token = strtok_r(str, PARSE_DELIMITER, &str);
110                 if (token == NULL) {
111                         free(dscp_table);
112                         return -1;
113                 }
114         }
115         return 0;
116 }
117
118 static int
119 parse_meter_color_str(char *c_str, uint32_t *use_prev_meter_color,
120         enum rte_mtr_color *dscp_table)
121 {
122         char *token;
123         uint64_t previous_mtr_color = 0;
124         int ret;
125
126         /* First token: use previous meter color */
127         token = strtok_r(c_str, PARSE_DELIMITER, &c_str);
128         if (token ==  NULL)
129                 return -1;
130
131         ret = parse_uint(&previous_mtr_color, token);
132         if (ret != 0)
133                 return -1;
134
135         /* Check if previous meter color to be used */
136         if (previous_mtr_color) {
137                 *use_prev_meter_color = previous_mtr_color;
138                 return 0;
139         }
140
141         /* Parse dscp table entries */
142         ret = parse_dscp_table_entries(c_str, dscp_table);
143         if (ret != 0)
144                 return -1;
145
146         return 0;
147 }
148
149 static int
150 string_to_policer_action(char *s)
151 {
152         if ((strcmp(s, "G") == 0) || (strcmp(s, "g") == 0))
153                 return MTR_POLICER_ACTION_COLOR_GREEN;
154
155         if ((strcmp(s, "Y") == 0) || (strcmp(s, "y") == 0))
156                 return MTR_POLICER_ACTION_COLOR_YELLOW;
157
158         if ((strcmp(s, "R") == 0) || (strcmp(s, "r") == 0))
159                 return MTR_POLICER_ACTION_COLOR_RED;
160
161         if ((strcmp(s, "D") == 0) || (strcmp(s, "d") == 0))
162                 return MTR_POLICER_ACTION_DROP;
163
164         return -1;
165 }
166
167 static int
168 parse_policer_action_string(char *p_str, uint32_t action_mask,
169         enum rte_mtr_policer_action actions[])
170 {
171         char *token;
172         int count = __builtin_popcount(action_mask);
173         int g_color = 0, y_color = 0, action, i;
174
175         for (i = 0; i < count; i++) {
176                 token = strtok_r(p_str, PARSE_DELIMITER, &p_str);
177                 if (token ==  NULL)
178                         return -1;
179
180                 action = string_to_policer_action(token);
181                 if (action == -1)
182                         return -1;
183
184                 if (g_color == 0 && (action_mask & 0x1)) {
185                         actions[RTE_MTR_GREEN] = action;
186                         g_color = 1;
187                 } else if (y_color == 0 && (action_mask & 0x2)) {
188                         actions[RTE_MTR_YELLOW] = action;
189                         y_color = 1;
190                 } else
191                         actions[RTE_MTR_RED] = action;
192         }
193         return 0;
194 }
195
196 static int
197 parse_multi_token_string(char *t_str, uint16_t *port_id,
198         uint32_t *mtr_id, enum rte_mtr_color *dscp_table)
199 {
200         char *token;
201         uint64_t val;
202         int ret;
203
204         /* First token: port id */
205         token = strtok_r(t_str, PARSE_DELIMITER, &t_str);
206         if (token ==  NULL)
207                 return -1;
208
209         ret = parse_uint(&val, token);
210         if (ret != 0 || val > UINT16_MAX)
211                 return -1;
212
213         *port_id = val;
214
215         /* Second token: meter id */
216         token = strtok_r(t_str, PARSE_DELIMITER, &t_str);
217         if (token == NULL)
218                 return 0;
219
220         ret = parse_uint(&val, token);
221         if (ret != 0 || val > UINT32_MAX)
222                 return -1;
223
224         *mtr_id = val;
225
226         ret = parse_dscp_table_entries(t_str, dscp_table);
227         if (ret != 0)
228                 return -1;
229
230         return 0;
231 }
232
233 /* *** Show Port Meter Capabilities *** */
234 struct cmd_show_port_meter_cap_result {
235         cmdline_fixed_string_t show;
236         cmdline_fixed_string_t port;
237         cmdline_fixed_string_t meter;
238         cmdline_fixed_string_t cap;
239         uint16_t port_id;
240 };
241
242 cmdline_parse_token_string_t cmd_show_port_meter_cap_show =
243         TOKEN_STRING_INITIALIZER(
244                 struct cmd_show_port_meter_cap_result, show, "show");
245 cmdline_parse_token_string_t cmd_show_port_meter_cap_port =
246         TOKEN_STRING_INITIALIZER(
247                 struct cmd_show_port_meter_cap_result, port, "port");
248 cmdline_parse_token_string_t cmd_show_port_meter_cap_meter =
249         TOKEN_STRING_INITIALIZER(
250                 struct cmd_show_port_meter_cap_result, meter, "meter");
251 cmdline_parse_token_string_t cmd_show_port_meter_cap_cap =
252         TOKEN_STRING_INITIALIZER(
253                 struct cmd_show_port_meter_cap_result, cap, "cap");
254 cmdline_parse_token_num_t cmd_show_port_meter_cap_port_id =
255         TOKEN_NUM_INITIALIZER(
256                 struct cmd_show_port_meter_cap_result, port_id, UINT16);
257
258 static void cmd_show_port_meter_cap_parsed(void *parsed_result,
259         __attribute__((unused)) struct cmdline *cl,
260         __attribute__((unused)) void *data)
261 {
262         struct cmd_show_port_meter_cap_result *res = parsed_result;
263         struct rte_mtr_capabilities cap;
264         struct rte_mtr_error error;
265         uint16_t port_id = res->port_id;
266         int ret;
267
268         if (port_id_is_invalid(port_id, ENABLED_WARN))
269                 return;
270
271         memset(&cap, 0, sizeof(struct rte_mtr_capabilities));
272         ret = rte_mtr_capabilities_get(port_id, &cap, &error);
273         if (ret) {
274                 print_err_msg(&error);
275                 return;
276         }
277
278         printf("\n****   Port Meter Object Capabilities ****\n\n");
279         printf("cap.n_max %" PRIu32 "\n", cap.n_max);
280         printf("cap.n_shared_max %" PRIu32 "\n", cap.n_shared_max);
281         printf("cap.identical %" PRId32 "\n", cap.identical);
282         printf("cap.shared_identical %" PRId32 "\n",
283                 cap.shared_identical);
284         printf("cap.shared_n_flows_per_mtr_max %" PRIu32 "\n",
285                 cap.shared_n_flows_per_mtr_max);
286         printf("cap.chaining_n_mtrs_per_flow_max %" PRIu32 "\n",
287                 cap.chaining_n_mtrs_per_flow_max);
288         printf("cap.chaining_use_prev_mtr_color_supported %" PRId32 "\n",
289                 cap.chaining_use_prev_mtr_color_supported);
290         printf("cap.chaining_use_prev_mtr_color_enforced %" PRId32 "\n",
291                 cap.chaining_use_prev_mtr_color_enforced);
292         printf("cap.meter_srtcm_rfc2697_n_max %" PRIu32 "\n",
293                 cap.meter_srtcm_rfc2697_n_max);
294         printf("cap.meter_trtcm_rfc2698_n_max %" PRIu32 "\n",
295                 cap.meter_trtcm_rfc2698_n_max);
296         printf("cap.meter_trtcm_rfc4115_n_max %" PRIu32 "\n",
297                 cap.meter_trtcm_rfc4115_n_max);
298         printf("cap.meter_rate_max %" PRIu64 "\n", cap.meter_rate_max);
299         printf("cap.color_aware_srtcm_rfc2697_supported %" PRId32 "\n",
300                 cap.color_aware_srtcm_rfc2697_supported);
301         printf("cap.color_aware_trtcm_rfc2698_supported %" PRId32 "\n",
302                 cap.color_aware_trtcm_rfc2698_supported);
303         printf("cap.color_aware_trtcm_rfc4115_supported %" PRId32 "\n",
304                 cap.color_aware_trtcm_rfc4115_supported);
305         printf("cap.policer_action_recolor_supported %" PRId32 "\n",
306                 cap.policer_action_recolor_supported);
307         printf("cap.policer_action_drop_supported %" PRId32 "\n",
308                 cap.policer_action_drop_supported);
309         printf("cap.stats_mask %" PRIx64 "\n", cap.stats_mask);
310 }
311
312 cmdline_parse_inst_t cmd_show_port_meter_cap = {
313         .f = cmd_show_port_meter_cap_parsed,
314         .data = NULL,
315         .help_str = "Show port meter cap",
316         .tokens = {
317                 (void *)&cmd_show_port_meter_cap_show,
318                 (void *)&cmd_show_port_meter_cap_port,
319                 (void *)&cmd_show_port_meter_cap_meter,
320                 (void *)&cmd_show_port_meter_cap_cap,
321                 (void *)&cmd_show_port_meter_cap_port_id,
322                 NULL,
323         },
324 };
325
326 /* *** Add Port Meter Profile srtcm_rfc2697 *** */
327 struct cmd_add_port_meter_profile_srtcm_result {
328         cmdline_fixed_string_t add;
329         cmdline_fixed_string_t port;
330         cmdline_fixed_string_t meter;
331         cmdline_fixed_string_t profile;
332         cmdline_fixed_string_t srtcm_rfc2697;
333         uint16_t port_id;
334         uint32_t profile_id;
335         uint64_t cir;
336         uint64_t cbs;
337         uint64_t ebs;
338 };
339
340 cmdline_parse_token_string_t cmd_add_port_meter_profile_srtcm_add =
341         TOKEN_STRING_INITIALIZER(
342                 struct cmd_add_port_meter_profile_srtcm_result, add, "add");
343 cmdline_parse_token_string_t cmd_add_port_meter_profile_srtcm_port =
344         TOKEN_STRING_INITIALIZER(
345                 struct cmd_add_port_meter_profile_srtcm_result,
346                         port, "port");
347 cmdline_parse_token_string_t cmd_add_port_meter_profile_srtcm_meter =
348         TOKEN_STRING_INITIALIZER(
349                 struct cmd_add_port_meter_profile_srtcm_result,
350                         meter, "meter");
351 cmdline_parse_token_string_t cmd_add_port_meter_profile_srtcm_profile =
352         TOKEN_STRING_INITIALIZER(
353                 struct cmd_add_port_meter_profile_srtcm_result,
354                         profile, "profile");
355 cmdline_parse_token_string_t cmd_add_port_meter_profile_srtcm_srtcm_rfc2697 =
356         TOKEN_STRING_INITIALIZER(
357                 struct cmd_add_port_meter_profile_srtcm_result,
358                         srtcm_rfc2697, "srtcm_rfc2697");
359 cmdline_parse_token_num_t cmd_add_port_meter_profile_srtcm_port_id =
360         TOKEN_NUM_INITIALIZER(
361                 struct cmd_add_port_meter_profile_srtcm_result,
362                         port_id, UINT16);
363 cmdline_parse_token_num_t cmd_add_port_meter_profile_srtcm_profile_id =
364         TOKEN_NUM_INITIALIZER(
365                 struct cmd_add_port_meter_profile_srtcm_result,
366                         profile_id, UINT32);
367 cmdline_parse_token_num_t cmd_add_port_meter_profile_srtcm_cir =
368         TOKEN_NUM_INITIALIZER(
369                 struct cmd_add_port_meter_profile_srtcm_result,
370                         cir, UINT64);
371 cmdline_parse_token_num_t cmd_add_port_meter_profile_srtcm_cbs =
372         TOKEN_NUM_INITIALIZER(
373                 struct cmd_add_port_meter_profile_srtcm_result,
374                         cbs, UINT64);
375 cmdline_parse_token_num_t cmd_add_port_meter_profile_srtcm_ebs =
376         TOKEN_NUM_INITIALIZER(
377                 struct cmd_add_port_meter_profile_srtcm_result,
378                         ebs, UINT64);
379
380 static void cmd_add_port_meter_profile_srtcm_parsed(void *parsed_result,
381         __attribute__((unused)) struct cmdline *cl,
382         __attribute__((unused)) void *data)
383 {
384         struct cmd_add_port_meter_profile_srtcm_result *res = parsed_result;
385         struct rte_mtr_meter_profile mp;
386         struct rte_mtr_error error;
387         uint32_t profile_id = res->profile_id;
388         uint16_t port_id = res->port_id;
389         int ret;
390
391         if (port_id_is_invalid(port_id, ENABLED_WARN))
392                 return;
393
394         /* Private shaper profile params */
395         memset(&mp, 0, sizeof(struct rte_mtr_meter_profile));
396         mp.alg = RTE_MTR_SRTCM_RFC2697;
397         mp.srtcm_rfc2697.cir = res->cir;
398         mp.srtcm_rfc2697.cbs = res->cbs;
399         mp.srtcm_rfc2697.ebs = res->ebs;
400
401         ret = rte_mtr_meter_profile_add(port_id, profile_id, &mp, &error);
402         if (ret != 0) {
403                 print_err_msg(&error);
404                 return;
405         }
406 }
407
408 cmdline_parse_inst_t cmd_add_port_meter_profile_srtcm = {
409         .f = cmd_add_port_meter_profile_srtcm_parsed,
410         .data = NULL,
411         .help_str = "Add port meter profile srtcm (rfc2697)",
412         .tokens = {
413                 (void *)&cmd_add_port_meter_profile_srtcm_add,
414                 (void *)&cmd_add_port_meter_profile_srtcm_port,
415                 (void *)&cmd_add_port_meter_profile_srtcm_meter,
416                 (void *)&cmd_add_port_meter_profile_srtcm_profile,
417                 (void *)&cmd_add_port_meter_profile_srtcm_srtcm_rfc2697,
418                 (void *)&cmd_add_port_meter_profile_srtcm_port_id,
419                 (void *)&cmd_add_port_meter_profile_srtcm_profile_id,
420                 (void *)&cmd_add_port_meter_profile_srtcm_cir,
421                 (void *)&cmd_add_port_meter_profile_srtcm_cbs,
422                 (void *)&cmd_add_port_meter_profile_srtcm_ebs,
423                 NULL,
424         },
425 };
426
427 /* *** Add Port Meter Profile trtcm_rfc2698 *** */
428 struct cmd_add_port_meter_profile_trtcm_result {
429         cmdline_fixed_string_t add;
430         cmdline_fixed_string_t port;
431         cmdline_fixed_string_t meter;
432         cmdline_fixed_string_t profile;
433         cmdline_fixed_string_t trtcm_rfc2698;
434         uint16_t port_id;
435         uint32_t profile_id;
436         uint64_t cir;
437         uint64_t pir;
438         uint64_t cbs;
439         uint64_t pbs;
440 };
441
442 cmdline_parse_token_string_t cmd_add_port_meter_profile_trtcm_add =
443         TOKEN_STRING_INITIALIZER(
444                 struct cmd_add_port_meter_profile_trtcm_result, add, "add");
445 cmdline_parse_token_string_t cmd_add_port_meter_profile_trtcm_port =
446         TOKEN_STRING_INITIALIZER(
447                 struct cmd_add_port_meter_profile_trtcm_result,
448                         port, "port");
449 cmdline_parse_token_string_t cmd_add_port_meter_profile_trtcm_meter =
450         TOKEN_STRING_INITIALIZER(
451                 struct cmd_add_port_meter_profile_trtcm_result,
452                         meter, "meter");
453 cmdline_parse_token_string_t cmd_add_port_meter_profile_trtcm_profile =
454         TOKEN_STRING_INITIALIZER(
455                 struct cmd_add_port_meter_profile_trtcm_result,
456                         profile, "profile");
457 cmdline_parse_token_string_t cmd_add_port_meter_profile_trtcm_trtcm_rfc2698 =
458         TOKEN_STRING_INITIALIZER(
459                 struct cmd_add_port_meter_profile_trtcm_result,
460                         trtcm_rfc2698, "trtcm_rfc2698");
461 cmdline_parse_token_num_t cmd_add_port_meter_profile_trtcm_port_id =
462         TOKEN_NUM_INITIALIZER(
463                 struct cmd_add_port_meter_profile_trtcm_result,
464                         port_id, UINT16);
465 cmdline_parse_token_num_t cmd_add_port_meter_profile_trtcm_profile_id =
466         TOKEN_NUM_INITIALIZER(
467                 struct cmd_add_port_meter_profile_trtcm_result,
468                         profile_id, UINT32);
469 cmdline_parse_token_num_t cmd_add_port_meter_profile_trtcm_cir =
470         TOKEN_NUM_INITIALIZER(
471                 struct cmd_add_port_meter_profile_trtcm_result,
472                         cir, UINT64);
473 cmdline_parse_token_num_t cmd_add_port_meter_profile_trtcm_pir =
474         TOKEN_NUM_INITIALIZER(
475                 struct cmd_add_port_meter_profile_trtcm_result,
476                         pir, UINT64);
477 cmdline_parse_token_num_t cmd_add_port_meter_profile_trtcm_cbs =
478         TOKEN_NUM_INITIALIZER(
479                 struct cmd_add_port_meter_profile_trtcm_result,
480                         cbs, UINT64);
481 cmdline_parse_token_num_t cmd_add_port_meter_profile_trtcm_pbs =
482         TOKEN_NUM_INITIALIZER(
483                 struct cmd_add_port_meter_profile_trtcm_result,
484                         pbs, UINT64);
485
486 static void cmd_add_port_meter_profile_trtcm_parsed(void *parsed_result,
487         __attribute__((unused)) struct cmdline *cl,
488         __attribute__((unused)) void *data)
489 {
490         struct cmd_add_port_meter_profile_trtcm_result *res = parsed_result;
491         struct rte_mtr_meter_profile mp;
492         struct rte_mtr_error error;
493         uint32_t profile_id = res->profile_id;
494         uint16_t port_id = res->port_id;
495         int ret;
496
497         if (port_id_is_invalid(port_id, ENABLED_WARN))
498                 return;
499
500         /* Private shaper profile params */
501         memset(&mp, 0, sizeof(struct rte_mtr_meter_profile));
502         mp.alg = RTE_MTR_TRTCM_RFC2698;
503         mp.trtcm_rfc2698.cir = res->cir;
504         mp.trtcm_rfc2698.pir = res->pir;
505         mp.trtcm_rfc2698.cbs = res->cbs;
506         mp.trtcm_rfc2698.pbs = res->pbs;
507
508         ret = rte_mtr_meter_profile_add(port_id, profile_id, &mp, &error);
509         if (ret != 0) {
510                 print_err_msg(&error);
511                 return;
512         }
513 }
514
515 cmdline_parse_inst_t cmd_add_port_meter_profile_trtcm = {
516         .f = cmd_add_port_meter_profile_trtcm_parsed,
517         .data = NULL,
518         .help_str = "Add port meter profile trtcm (rfc2698)",
519         .tokens = {
520                 (void *)&cmd_add_port_meter_profile_trtcm_add,
521                 (void *)&cmd_add_port_meter_profile_trtcm_port,
522                 (void *)&cmd_add_port_meter_profile_trtcm_meter,
523                 (void *)&cmd_add_port_meter_profile_trtcm_profile,
524                 (void *)&cmd_add_port_meter_profile_trtcm_trtcm_rfc2698,
525                 (void *)&cmd_add_port_meter_profile_trtcm_port_id,
526                 (void *)&cmd_add_port_meter_profile_trtcm_profile_id,
527                 (void *)&cmd_add_port_meter_profile_trtcm_cir,
528                 (void *)&cmd_add_port_meter_profile_trtcm_pir,
529                 (void *)&cmd_add_port_meter_profile_trtcm_cbs,
530                 (void *)&cmd_add_port_meter_profile_trtcm_pbs,
531                 NULL,
532         },
533 };
534
535 /* *** Add Port Meter Profile trtcm_rfc4115 *** */
536 struct cmd_add_port_meter_profile_trtcm_rfc4115_result {
537         cmdline_fixed_string_t add;
538         cmdline_fixed_string_t port;
539         cmdline_fixed_string_t meter;
540         cmdline_fixed_string_t profile;
541         cmdline_fixed_string_t trtcm_rfc4115;
542         uint16_t port_id;
543         uint32_t profile_id;
544         uint64_t cir;
545         uint64_t eir;
546         uint64_t cbs;
547         uint64_t ebs;
548 };
549
550 cmdline_parse_token_string_t cmd_add_port_meter_profile_trtcm_rfc4115_add =
551         TOKEN_STRING_INITIALIZER(
552                 struct cmd_add_port_meter_profile_trtcm_rfc4115_result, add,
553                 "add");
554 cmdline_parse_token_string_t cmd_add_port_meter_profile_trtcm_rfc4115_port =
555         TOKEN_STRING_INITIALIZER(
556                 struct cmd_add_port_meter_profile_trtcm_rfc4115_result,
557                         port, "port");
558 cmdline_parse_token_string_t cmd_add_port_meter_profile_trtcm_rfc4115_meter =
559         TOKEN_STRING_INITIALIZER(
560                 struct cmd_add_port_meter_profile_trtcm_rfc4115_result,
561                         meter, "meter");
562 cmdline_parse_token_string_t cmd_add_port_meter_profile_trtcm_rfc4115_profile =
563         TOKEN_STRING_INITIALIZER(
564                 struct cmd_add_port_meter_profile_trtcm_rfc4115_result,
565                         profile, "profile");
566 cmdline_parse_token_string_t
567         cmd_add_port_meter_profile_trtcm_rfc4115_trtcm_rfc4115 =
568         TOKEN_STRING_INITIALIZER(
569                 struct cmd_add_port_meter_profile_trtcm_rfc4115_result,
570                         trtcm_rfc4115, "trtcm_rfc4115");
571 cmdline_parse_token_num_t cmd_add_port_meter_profile_trtcm_rfc4115_port_id =
572         TOKEN_NUM_INITIALIZER(
573                 struct cmd_add_port_meter_profile_trtcm_rfc4115_result,
574                         port_id, UINT16);
575 cmdline_parse_token_num_t cmd_add_port_meter_profile_trtcm_rfc4115_profile_id =
576         TOKEN_NUM_INITIALIZER(
577                 struct cmd_add_port_meter_profile_trtcm_rfc4115_result,
578                         profile_id, UINT32);
579 cmdline_parse_token_num_t cmd_add_port_meter_profile_trtcm_rfc4115_cir =
580         TOKEN_NUM_INITIALIZER(
581                 struct cmd_add_port_meter_profile_trtcm_rfc4115_result,
582                         cir, UINT64);
583 cmdline_parse_token_num_t cmd_add_port_meter_profile_trtcm_rfc4115_eir =
584         TOKEN_NUM_INITIALIZER(
585                 struct cmd_add_port_meter_profile_trtcm_rfc4115_result,
586                         eir, UINT64);
587 cmdline_parse_token_num_t cmd_add_port_meter_profile_trtcm_rfc4115_cbs =
588         TOKEN_NUM_INITIALIZER(
589                 struct cmd_add_port_meter_profile_trtcm_rfc4115_result,
590                         cbs, UINT64);
591 cmdline_parse_token_num_t cmd_add_port_meter_profile_trtcm_rfc4115_ebs =
592         TOKEN_NUM_INITIALIZER(
593                 struct cmd_add_port_meter_profile_trtcm_rfc4115_result,
594                         ebs, UINT64);
595
596 static void cmd_add_port_meter_profile_trtcm_rfc4115_parsed(
597         void *parsed_result,
598         __attribute__((unused)) struct cmdline *cl,
599         __attribute__((unused)) void *data)
600 {
601         struct cmd_add_port_meter_profile_trtcm_rfc4115_result *res =
602                 parsed_result;
603         struct rte_mtr_meter_profile mp;
604         struct rte_mtr_error error;
605         uint32_t profile_id = res->profile_id;
606         uint16_t port_id = res->port_id;
607         int ret;
608
609         if (port_id_is_invalid(port_id, ENABLED_WARN))
610                 return;
611
612         /* Private shaper profile params */
613         memset(&mp, 0, sizeof(struct rte_mtr_meter_profile));
614         mp.alg = RTE_MTR_TRTCM_RFC4115;
615         mp.trtcm_rfc4115.cir = res->cir;
616         mp.trtcm_rfc4115.eir = res->eir;
617         mp.trtcm_rfc4115.cbs = res->cbs;
618         mp.trtcm_rfc4115.ebs = res->ebs;
619
620         ret = rte_mtr_meter_profile_add(port_id, profile_id, &mp, &error);
621         if (ret != 0) {
622                 print_err_msg(&error);
623                 return;
624         }
625 }
626
627 cmdline_parse_inst_t cmd_add_port_meter_profile_trtcm_rfc4115 = {
628         .f = cmd_add_port_meter_profile_trtcm_rfc4115_parsed,
629         .data = NULL,
630         .help_str = "Add port meter profile trtcm (rfc4115)",
631         .tokens = {
632                 (void *)&cmd_add_port_meter_profile_trtcm_rfc4115_add,
633                 (void *)&cmd_add_port_meter_profile_trtcm_rfc4115_port,
634                 (void *)&cmd_add_port_meter_profile_trtcm_rfc4115_meter,
635                 (void *)&cmd_add_port_meter_profile_trtcm_rfc4115_profile,
636                 (void *)&cmd_add_port_meter_profile_trtcm_rfc4115_trtcm_rfc4115,
637                 (void *)&cmd_add_port_meter_profile_trtcm_rfc4115_port_id,
638                 (void *)&cmd_add_port_meter_profile_trtcm_rfc4115_profile_id,
639                 (void *)&cmd_add_port_meter_profile_trtcm_rfc4115_cir,
640                 (void *)&cmd_add_port_meter_profile_trtcm_rfc4115_eir,
641                 (void *)&cmd_add_port_meter_profile_trtcm_rfc4115_cbs,
642                 (void *)&cmd_add_port_meter_profile_trtcm_rfc4115_ebs,
643                 NULL,
644         },
645 };
646
647 /* *** Delete Port Meter Profile *** */
648 struct cmd_del_port_meter_profile_result {
649         cmdline_fixed_string_t del;
650         cmdline_fixed_string_t port;
651         cmdline_fixed_string_t meter;
652         cmdline_fixed_string_t profile;
653         uint16_t port_id;
654         uint32_t profile_id;
655 };
656
657 cmdline_parse_token_string_t cmd_del_port_meter_profile_del =
658         TOKEN_STRING_INITIALIZER(
659                 struct cmd_del_port_meter_profile_result, del, "del");
660 cmdline_parse_token_string_t cmd_del_port_meter_profile_port =
661         TOKEN_STRING_INITIALIZER(
662                 struct cmd_del_port_meter_profile_result,
663                         port, "port");
664 cmdline_parse_token_string_t cmd_del_port_meter_profile_meter =
665         TOKEN_STRING_INITIALIZER(
666                 struct cmd_del_port_meter_profile_result,
667                         meter, "meter");
668 cmdline_parse_token_string_t cmd_del_port_meter_profile_profile =
669         TOKEN_STRING_INITIALIZER(
670                 struct cmd_del_port_meter_profile_result,
671                         profile, "profile");
672 cmdline_parse_token_num_t cmd_del_port_meter_profile_port_id =
673         TOKEN_NUM_INITIALIZER(
674                 struct cmd_del_port_meter_profile_result,
675                         port_id, UINT16);
676 cmdline_parse_token_num_t cmd_del_port_meter_profile_profile_id =
677         TOKEN_NUM_INITIALIZER(
678                 struct cmd_del_port_meter_profile_result,
679                         profile_id, UINT32);
680
681 static void cmd_del_port_meter_profile_parsed(void *parsed_result,
682         __attribute__((unused)) struct cmdline *cl,
683         __attribute__((unused)) void *data)
684 {
685         struct cmd_del_port_meter_profile_result *res = parsed_result;
686         struct rte_mtr_error error;
687         uint32_t profile_id = res->profile_id;
688         uint16_t port_id = res->port_id;
689         int ret;
690
691         if (port_id_is_invalid(port_id, ENABLED_WARN))
692                 return;
693
694         /* Delete meter profile */
695         ret = rte_mtr_meter_profile_delete(port_id, profile_id, &error);
696         if (ret != 0) {
697                 print_err_msg(&error);
698                 return;
699         }
700 }
701
702 cmdline_parse_inst_t cmd_del_port_meter_profile = {
703         .f = cmd_del_port_meter_profile_parsed,
704         .data = NULL,
705         .help_str = "Delete port meter profile",
706         .tokens = {
707                 (void *)&cmd_del_port_meter_profile_del,
708                 (void *)&cmd_del_port_meter_profile_port,
709                 (void *)&cmd_del_port_meter_profile_meter,
710                 (void *)&cmd_del_port_meter_profile_profile,
711                 (void *)&cmd_del_port_meter_profile_port_id,
712                 (void *)&cmd_del_port_meter_profile_profile_id,
713                 NULL,
714         },
715 };
716
717 /* *** Create Port Meter Object *** */
718 struct cmd_create_port_meter_result {
719         cmdline_fixed_string_t create;
720         cmdline_fixed_string_t port;
721         cmdline_fixed_string_t meter;
722         uint16_t port_id;
723         uint32_t mtr_id;
724         uint32_t profile_id;
725         cmdline_fixed_string_t meter_enable;
726         cmdline_fixed_string_t g_action;
727         cmdline_fixed_string_t y_action;
728         cmdline_fixed_string_t r_action;
729         uint64_t statistics_mask;
730         uint32_t shared;
731         cmdline_multi_string_t meter_input_color;
732 };
733
734 cmdline_parse_token_string_t cmd_create_port_meter_create =
735         TOKEN_STRING_INITIALIZER(
736                 struct cmd_create_port_meter_result, create, "create");
737 cmdline_parse_token_string_t cmd_create_port_meter_port =
738         TOKEN_STRING_INITIALIZER(
739                 struct cmd_create_port_meter_result, port, "port");
740 cmdline_parse_token_string_t cmd_create_port_meter_meter =
741         TOKEN_STRING_INITIALIZER(
742                 struct cmd_create_port_meter_result, meter, "meter");
743 cmdline_parse_token_num_t cmd_create_port_meter_port_id =
744         TOKEN_NUM_INITIALIZER(
745                 struct cmd_create_port_meter_result, port_id, UINT16);
746 cmdline_parse_token_num_t cmd_create_port_meter_mtr_id =
747         TOKEN_NUM_INITIALIZER(
748                 struct cmd_create_port_meter_result, mtr_id, UINT32);
749 cmdline_parse_token_num_t cmd_create_port_meter_profile_id =
750         TOKEN_NUM_INITIALIZER(
751                 struct cmd_create_port_meter_result, profile_id, UINT32);
752 cmdline_parse_token_string_t cmd_create_port_meter_meter_enable =
753         TOKEN_STRING_INITIALIZER(struct cmd_create_port_meter_result,
754                 meter_enable, "yes#no");
755 cmdline_parse_token_string_t cmd_create_port_meter_g_action =
756         TOKEN_STRING_INITIALIZER(struct cmd_create_port_meter_result,
757                 g_action, "R#Y#G#D#r#y#g#d");
758 cmdline_parse_token_string_t cmd_create_port_meter_y_action =
759         TOKEN_STRING_INITIALIZER(struct cmd_create_port_meter_result,
760                 y_action, "R#Y#G#D#r#y#g#d");
761 cmdline_parse_token_string_t cmd_create_port_meter_r_action =
762         TOKEN_STRING_INITIALIZER(struct cmd_create_port_meter_result,
763                 r_action, "R#Y#G#D#r#y#g#d");
764 cmdline_parse_token_num_t cmd_create_port_meter_statistics_mask =
765         TOKEN_NUM_INITIALIZER(struct cmd_create_port_meter_result,
766                 statistics_mask, UINT64);
767 cmdline_parse_token_num_t cmd_create_port_meter_shared =
768         TOKEN_NUM_INITIALIZER(struct cmd_create_port_meter_result,
769                 shared, UINT32);
770 cmdline_parse_token_string_t cmd_create_port_meter_input_color =
771         TOKEN_STRING_INITIALIZER(struct cmd_create_port_meter_result,
772                 meter_input_color, TOKEN_STRING_MULTI);
773
774 static void cmd_create_port_meter_parsed(void *parsed_result,
775         __attribute__((unused)) struct cmdline *cl,
776         __attribute__((unused)) void *data)
777 {
778         struct cmd_create_port_meter_result *res = parsed_result;
779         struct rte_mtr_error error;
780         struct rte_mtr_params params;
781         uint32_t mtr_id = res->mtr_id;
782         uint32_t shared = res->shared;
783         uint32_t use_prev_meter_color = 0;
784         uint16_t port_id = res->port_id;
785         enum rte_mtr_color *dscp_table = NULL;
786         char *c_str = res->meter_input_color;
787         int ret;
788
789         if (port_id_is_invalid(port_id, ENABLED_WARN))
790                 return;
791
792         /* Meter params */
793         memset(&params, 0, sizeof(struct rte_mtr_params));
794         params.meter_profile_id = res->profile_id;
795
796         /* Parse meter input color string params */
797         ret = parse_meter_color_str(c_str, &use_prev_meter_color, dscp_table);
798         if (ret) {
799                 printf(" Meter input color params string parse error\n");
800                 return;
801         }
802
803         params.use_prev_mtr_color = use_prev_meter_color;
804         params.dscp_table = dscp_table;
805
806         if (strcmp(res->meter_enable, "yes") == 0)
807                 params.meter_enable = 1;
808         else
809                 params.meter_enable = 0;
810
811         params.action[RTE_MTR_GREEN] =
812                 string_to_policer_action(res->g_action);
813         params.action[RTE_MTR_YELLOW] =
814                 string_to_policer_action(res->y_action);
815         params.action[RTE_MTR_RED] =
816                 string_to_policer_action(res->r_action);
817         params.stats_mask = res->statistics_mask;
818
819         ret = rte_mtr_create(port_id, mtr_id, &params, shared, &error);
820         if (ret != 0) {
821                 free(dscp_table);
822                 print_err_msg(&error);
823                 return;
824         }
825 }
826
827 cmdline_parse_inst_t cmd_create_port_meter = {
828         .f = cmd_create_port_meter_parsed,
829         .data = NULL,
830         .help_str = "Create port meter",
831         .tokens = {
832                 (void *)&cmd_create_port_meter_create,
833                 (void *)&cmd_create_port_meter_port,
834                 (void *)&cmd_create_port_meter_meter,
835                 (void *)&cmd_create_port_meter_port_id,
836                 (void *)&cmd_create_port_meter_mtr_id,
837                 (void *)&cmd_create_port_meter_profile_id,
838                 (void *)&cmd_create_port_meter_meter_enable,
839                 (void *)&cmd_create_port_meter_g_action,
840                 (void *)&cmd_create_port_meter_y_action,
841                 (void *)&cmd_create_port_meter_r_action,
842                 (void *)&cmd_create_port_meter_statistics_mask,
843                 (void *)&cmd_create_port_meter_shared,
844                 (void *)&cmd_create_port_meter_input_color,
845                 NULL,
846         },
847 };
848
849 /* *** Enable Meter of MTR Object  *** */
850 struct cmd_enable_port_meter_result {
851         cmdline_fixed_string_t enable;
852         cmdline_fixed_string_t port;
853         cmdline_fixed_string_t meter;
854         uint16_t port_id;
855         uint32_t mtr_id;
856 };
857
858 cmdline_parse_token_string_t cmd_enable_port_meter_enable =
859         TOKEN_STRING_INITIALIZER(
860                 struct cmd_enable_port_meter_result, enable, "enable");
861 cmdline_parse_token_string_t cmd_enable_port_meter_port =
862         TOKEN_STRING_INITIALIZER(
863                 struct cmd_enable_port_meter_result, port, "port");
864 cmdline_parse_token_string_t cmd_enable_port_meter_meter =
865         TOKEN_STRING_INITIALIZER(
866                 struct cmd_enable_port_meter_result, meter, "meter");
867 cmdline_parse_token_num_t cmd_enable_port_meter_port_id =
868         TOKEN_NUM_INITIALIZER(
869                 struct cmd_enable_port_meter_result, port_id, UINT16);
870 cmdline_parse_token_num_t cmd_enable_port_meter_mtr_id =
871         TOKEN_NUM_INITIALIZER(
872                 struct cmd_enable_port_meter_result, mtr_id, UINT32);
873
874 static void cmd_enable_port_meter_parsed(void *parsed_result,
875         __attribute__((unused)) struct cmdline *cl,
876         __attribute__((unused)) void *data)
877 {
878         struct cmd_enable_port_meter_result *res = parsed_result;
879         struct rte_mtr_error error;
880         uint32_t mtr_id = res->mtr_id;
881         uint16_t port_id = res->port_id;
882
883         int ret;
884
885         if (port_id_is_invalid(port_id, ENABLED_WARN))
886                 return;
887
888         /* Enable Meter */
889         ret = rte_mtr_meter_enable(port_id, mtr_id, &error);
890         if (ret != 0) {
891                 print_err_msg(&error);
892                 return;
893         }
894 }
895
896 cmdline_parse_inst_t cmd_enable_port_meter = {
897         .f = cmd_enable_port_meter_parsed,
898         .data = NULL,
899         .help_str = "Enable port meter",
900         .tokens = {
901                 (void *)&cmd_enable_port_meter_enable,
902                 (void *)&cmd_enable_port_meter_port,
903                 (void *)&cmd_enable_port_meter_meter,
904                 (void *)&cmd_enable_port_meter_port_id,
905                 (void *)&cmd_enable_port_meter_mtr_id,
906                 NULL,
907         },
908 };
909
910 /* *** Disable Meter of MTR Object  *** */
911 struct cmd_disable_port_meter_result {
912         cmdline_fixed_string_t disable;
913         cmdline_fixed_string_t port;
914         cmdline_fixed_string_t meter;
915         uint16_t port_id;
916         uint32_t mtr_id;
917 };
918
919 cmdline_parse_token_string_t cmd_disable_port_meter_disable =
920         TOKEN_STRING_INITIALIZER(
921                 struct cmd_disable_port_meter_result, disable, "disable");
922 cmdline_parse_token_string_t cmd_disable_port_meter_port =
923         TOKEN_STRING_INITIALIZER(
924                 struct cmd_disable_port_meter_result, port, "port");
925 cmdline_parse_token_string_t cmd_disable_port_meter_meter =
926         TOKEN_STRING_INITIALIZER(
927                 struct cmd_disable_port_meter_result, meter, "meter");
928 cmdline_parse_token_num_t cmd_disable_port_meter_port_id =
929         TOKEN_NUM_INITIALIZER(
930                 struct cmd_disable_port_meter_result, port_id, UINT16);
931 cmdline_parse_token_num_t cmd_disable_port_meter_mtr_id =
932         TOKEN_NUM_INITIALIZER(
933                 struct cmd_disable_port_meter_result, mtr_id, UINT32);
934
935 static void cmd_disable_port_meter_parsed(void *parsed_result,
936         __attribute__((unused)) struct cmdline *cl,
937         __attribute__((unused)) void *data)
938 {
939         struct cmd_disable_port_meter_result *res = parsed_result;
940         struct rte_mtr_error error;
941         uint32_t mtr_id = res->mtr_id;
942         uint16_t port_id = res->port_id;
943
944         int ret;
945
946         if (port_id_is_invalid(port_id, ENABLED_WARN))
947                 return;
948
949         /* Disable Meter */
950         ret = rte_mtr_meter_disable(port_id, mtr_id, &error);
951         if (ret != 0) {
952                 print_err_msg(&error);
953                 return;
954         }
955 }
956
957 cmdline_parse_inst_t cmd_disable_port_meter = {
958         .f = cmd_disable_port_meter_parsed,
959         .data = NULL,
960         .help_str = "Disable port meter",
961         .tokens = {
962                 (void *)&cmd_disable_port_meter_disable,
963                 (void *)&cmd_disable_port_meter_port,
964                 (void *)&cmd_disable_port_meter_meter,
965                 (void *)&cmd_disable_port_meter_port_id,
966                 (void *)&cmd_disable_port_meter_mtr_id,
967                 NULL,
968         },
969 };
970
971 /* *** Delete Port Meter Object *** */
972 struct cmd_del_port_meter_result {
973         cmdline_fixed_string_t del;
974         cmdline_fixed_string_t port;
975         cmdline_fixed_string_t meter;
976         uint16_t port_id;
977         uint32_t mtr_id;
978 };
979
980 cmdline_parse_token_string_t cmd_del_port_meter_del =
981         TOKEN_STRING_INITIALIZER(
982                 struct cmd_del_port_meter_result, del, "del");
983 cmdline_parse_token_string_t cmd_del_port_meter_port =
984         TOKEN_STRING_INITIALIZER(
985                 struct cmd_del_port_meter_result, port, "port");
986 cmdline_parse_token_string_t cmd_del_port_meter_meter =
987         TOKEN_STRING_INITIALIZER(
988                 struct cmd_del_port_meter_result, meter, "meter");
989 cmdline_parse_token_num_t cmd_del_port_meter_port_id =
990         TOKEN_NUM_INITIALIZER(
991                 struct cmd_del_port_meter_result, port_id, UINT16);
992 cmdline_parse_token_num_t cmd_del_port_meter_mtr_id =
993         TOKEN_NUM_INITIALIZER(
994                 struct cmd_del_port_meter_result, mtr_id, UINT32);
995
996 static void cmd_del_port_meter_parsed(void *parsed_result,
997         __attribute__((unused)) struct cmdline *cl,
998         __attribute__((unused)) void *data)
999 {
1000         struct cmd_del_port_meter_result *res = parsed_result;
1001         struct rte_mtr_error error;
1002         uint32_t mtr_id = res->mtr_id;
1003         uint16_t port_id = res->port_id;
1004
1005         int ret;
1006
1007         if (port_id_is_invalid(port_id, ENABLED_WARN))
1008                 return;
1009
1010         /* Destroy Meter */
1011         ret = rte_mtr_destroy(port_id, mtr_id, &error);
1012         if (ret != 0) {
1013                 print_err_msg(&error);
1014                 return;
1015         }
1016 }
1017
1018 cmdline_parse_inst_t cmd_del_port_meter = {
1019         .f = cmd_del_port_meter_parsed,
1020         .data = NULL,
1021         .help_str = "Delete port meter",
1022         .tokens = {
1023                 (void *)&cmd_del_port_meter_del,
1024                 (void *)&cmd_del_port_meter_port,
1025                 (void *)&cmd_del_port_meter_meter,
1026                 (void *)&cmd_del_port_meter_port_id,
1027                 (void *)&cmd_del_port_meter_mtr_id,
1028                 NULL,
1029         },
1030 };
1031
1032 /* *** Set Port Meter Profile *** */
1033 struct cmd_set_port_meter_profile_result {
1034         cmdline_fixed_string_t set;
1035         cmdline_fixed_string_t port;
1036         cmdline_fixed_string_t meter;
1037         cmdline_fixed_string_t profile;
1038         uint16_t port_id;
1039         uint32_t mtr_id;
1040         uint32_t profile_id;
1041 };
1042
1043 cmdline_parse_token_string_t cmd_set_port_meter_profile_set =
1044         TOKEN_STRING_INITIALIZER(
1045                 struct cmd_set_port_meter_profile_result, set, "set");
1046 cmdline_parse_token_string_t cmd_set_port_meter_profile_port =
1047         TOKEN_STRING_INITIALIZER(
1048                 struct cmd_set_port_meter_profile_result, port, "port");
1049 cmdline_parse_token_string_t cmd_set_port_meter_profile_meter =
1050         TOKEN_STRING_INITIALIZER(
1051                 struct cmd_set_port_meter_profile_result, meter, "meter");
1052 cmdline_parse_token_string_t cmd_set_port_meter_profile_profile =
1053         TOKEN_STRING_INITIALIZER(
1054                 struct cmd_set_port_meter_profile_result, profile, "profile");
1055 cmdline_parse_token_num_t cmd_set_port_meter_profile_port_id =
1056         TOKEN_NUM_INITIALIZER(
1057                 struct cmd_set_port_meter_profile_result, port_id, UINT16);
1058 cmdline_parse_token_num_t cmd_set_port_meter_profile_mtr_id =
1059         TOKEN_NUM_INITIALIZER(
1060                 struct cmd_set_port_meter_profile_result, mtr_id, UINT32);
1061 cmdline_parse_token_num_t cmd_set_port_meter_profile_profile_id =
1062         TOKEN_NUM_INITIALIZER(
1063                 struct cmd_set_port_meter_profile_result, profile_id, UINT32);
1064
1065 static void cmd_set_port_meter_profile_parsed(void *parsed_result,
1066         __attribute__((unused)) struct cmdline *cl,
1067         __attribute__((unused)) void *data)
1068 {
1069         struct cmd_set_port_meter_profile_result *res = parsed_result;
1070         struct rte_mtr_error error;
1071         uint32_t mtr_id = res->mtr_id;
1072         uint32_t profile_id = res->profile_id;
1073         uint16_t port_id = res->port_id;
1074
1075         int ret;
1076
1077         if (port_id_is_invalid(port_id, ENABLED_WARN))
1078                 return;
1079
1080         /* Set meter profile */
1081         ret = rte_mtr_meter_profile_update(port_id, mtr_id,
1082                 profile_id, &error);
1083         if (ret != 0) {
1084                 print_err_msg(&error);
1085                 return;
1086         }
1087 }
1088
1089 cmdline_parse_inst_t cmd_set_port_meter_profile = {
1090         .f = cmd_set_port_meter_profile_parsed,
1091         .data = NULL,
1092         .help_str = "Set port meter profile",
1093         .tokens = {
1094                 (void *)&cmd_set_port_meter_profile_set,
1095                 (void *)&cmd_set_port_meter_profile_port,
1096                 (void *)&cmd_set_port_meter_profile_meter,
1097                 (void *)&cmd_set_port_meter_profile_profile,
1098                 (void *)&cmd_set_port_meter_profile_port_id,
1099                 (void *)&cmd_set_port_meter_profile_mtr_id,
1100                 (void *)&cmd_set_port_meter_profile_profile_id,
1101                 NULL,
1102         },
1103 };
1104
1105 /* *** Set Port Meter DSCP Table *** */
1106 struct cmd_set_port_meter_dscp_table_result {
1107         cmdline_fixed_string_t set;
1108         cmdline_fixed_string_t port;
1109         cmdline_fixed_string_t meter;
1110         cmdline_fixed_string_t dscp_table;
1111         cmdline_multi_string_t token_string;
1112 };
1113
1114 cmdline_parse_token_string_t cmd_set_port_meter_dscp_table_set =
1115         TOKEN_STRING_INITIALIZER(
1116                 struct cmd_set_port_meter_dscp_table_result, set, "set");
1117 cmdline_parse_token_string_t cmd_set_port_meter_dscp_table_port =
1118         TOKEN_STRING_INITIALIZER(
1119                 struct cmd_set_port_meter_dscp_table_result, port, "port");
1120 cmdline_parse_token_string_t cmd_set_port_meter_dscp_table_meter =
1121         TOKEN_STRING_INITIALIZER(
1122                 struct cmd_set_port_meter_dscp_table_result, meter, "meter");
1123 cmdline_parse_token_string_t cmd_set_port_meter_dscp_table_dscp_table =
1124         TOKEN_STRING_INITIALIZER(
1125                 struct cmd_set_port_meter_dscp_table_result,
1126                 dscp_table, "dscp table");
1127 cmdline_parse_token_string_t cmd_set_port_meter_dscp_table_token_string =
1128         TOKEN_STRING_INITIALIZER(struct cmd_set_port_meter_dscp_table_result,
1129                 token_string, TOKEN_STRING_MULTI);
1130
1131 static void cmd_set_port_meter_dscp_table_parsed(void *parsed_result,
1132         __attribute__((unused)) struct cmdline *cl,
1133         __attribute__((unused)) void *data)
1134 {
1135         struct cmd_set_port_meter_dscp_table_result *res = parsed_result;
1136         struct rte_mtr_error error;
1137         enum rte_mtr_color *dscp_table = NULL;
1138         char *t_str = res->token_string;
1139         uint32_t mtr_id = 0;
1140         uint16_t port_id;
1141         int ret;
1142
1143         /* Parse string */
1144         ret = parse_multi_token_string(t_str, &port_id, &mtr_id, dscp_table);
1145         if (ret) {
1146                 printf(" Multi token string parse error\n");
1147                 return;
1148         }
1149
1150         if (port_id_is_invalid(port_id, ENABLED_WARN))
1151                 return;
1152
1153         /* Update Meter DSCP Table*/
1154         ret = rte_mtr_meter_dscp_table_update(port_id, mtr_id,
1155                 dscp_table, &error);
1156         if (ret != 0) {
1157                 print_err_msg(&error);
1158                 return;
1159         }
1160         free(dscp_table);
1161 }
1162
1163 cmdline_parse_inst_t cmd_set_port_meter_dscp_table = {
1164         .f = cmd_set_port_meter_dscp_table_parsed,
1165         .data = NULL,
1166         .help_str = "Update port meter dscp table",
1167         .tokens = {
1168                 (void *)&cmd_set_port_meter_dscp_table_set,
1169                 (void *)&cmd_set_port_meter_dscp_table_port,
1170                 (void *)&cmd_set_port_meter_dscp_table_meter,
1171                 (void *)&cmd_set_port_meter_dscp_table_dscp_table,
1172                 (void *)&cmd_set_port_meter_dscp_table_token_string,
1173                 NULL,
1174         },
1175 };
1176
1177 /* *** Set Port Meter Policer Action *** */
1178 struct cmd_set_port_meter_policer_action_result {
1179         cmdline_fixed_string_t set;
1180         cmdline_fixed_string_t port;
1181         cmdline_fixed_string_t meter;
1182         cmdline_fixed_string_t policer;
1183         cmdline_fixed_string_t action;
1184         uint16_t port_id;
1185         uint32_t mtr_id;
1186         uint32_t action_mask;
1187         cmdline_multi_string_t policer_action;
1188 };
1189
1190 cmdline_parse_token_string_t cmd_set_port_meter_policer_action_set =
1191         TOKEN_STRING_INITIALIZER(
1192                 struct cmd_set_port_meter_policer_action_result, set, "set");
1193 cmdline_parse_token_string_t cmd_set_port_meter_policer_action_port =
1194         TOKEN_STRING_INITIALIZER(
1195                 struct cmd_set_port_meter_policer_action_result, port, "port");
1196 cmdline_parse_token_string_t cmd_set_port_meter_policer_action_meter =
1197         TOKEN_STRING_INITIALIZER(
1198                 struct cmd_set_port_meter_policer_action_result, meter,
1199                 "meter");
1200 cmdline_parse_token_string_t cmd_set_port_meter_policer_action_policer =
1201         TOKEN_STRING_INITIALIZER(
1202                 struct cmd_set_port_meter_policer_action_result, policer,
1203                 "policer");
1204 cmdline_parse_token_string_t cmd_set_port_meter_policer_action_action =
1205         TOKEN_STRING_INITIALIZER(
1206                 struct cmd_set_port_meter_policer_action_result, action,
1207                 "action");
1208 cmdline_parse_token_num_t cmd_set_port_meter_policer_action_port_id =
1209         TOKEN_NUM_INITIALIZER(
1210                 struct cmd_set_port_meter_policer_action_result, port_id,
1211                 UINT16);
1212 cmdline_parse_token_num_t cmd_set_port_meter_policer_action_mtr_id =
1213         TOKEN_NUM_INITIALIZER(
1214                 struct cmd_set_port_meter_policer_action_result, mtr_id,
1215                 UINT32);
1216 cmdline_parse_token_num_t cmd_set_port_meter_policer_action_action_mask =
1217         TOKEN_NUM_INITIALIZER(
1218                 struct cmd_set_port_meter_policer_action_result, action_mask,
1219                 UINT32);
1220 cmdline_parse_token_string_t cmd_set_port_meter_policer_action_policer_action =
1221         TOKEN_STRING_INITIALIZER(
1222                 struct cmd_set_port_meter_policer_action_result,
1223                 policer_action, TOKEN_STRING_MULTI);
1224
1225 static void cmd_set_port_meter_policer_action_parsed(void *parsed_result,
1226         __attribute__((unused)) struct cmdline *cl,
1227         __attribute__((unused)) void *data)
1228 {
1229         struct cmd_set_port_meter_policer_action_result *res = parsed_result;
1230         enum rte_mtr_policer_action *actions;
1231         struct rte_mtr_error error;
1232         uint32_t mtr_id = res->mtr_id;
1233         uint32_t action_mask = res->action_mask;
1234         uint16_t port_id = res->port_id;
1235         char *p_str = res->policer_action;
1236         int ret;
1237
1238         if (port_id_is_invalid(port_id, ENABLED_WARN))
1239                 return;
1240
1241         /* Check: action mask */
1242         if (action_mask == 0 || (action_mask & (~0x7UL))) {
1243                 printf(" Policer action mask not correct (error)\n");
1244                 return;
1245         }
1246
1247         /* Allocate memory for policer actions */
1248         actions = (enum rte_mtr_policer_action *)malloc(RTE_MTR_COLORS *
1249                 sizeof(enum rte_mtr_policer_action));
1250         if (actions == NULL) {
1251                 printf("Memory for policer actions not allocated (error)\n");
1252                 return;
1253         }
1254         /* Parse policer action string */
1255         ret = parse_policer_action_string(p_str, action_mask, actions);
1256         if (ret) {
1257                 printf(" Policer action string parse error\n");
1258                 free(actions);
1259                 return;
1260         }
1261
1262         ret = rte_mtr_policer_actions_update(port_id, mtr_id,
1263                 action_mask, actions, &error);
1264         if (ret != 0) {
1265                 print_err_msg(&error);
1266                 return;
1267         }
1268
1269         free(actions);
1270 }
1271
1272 cmdline_parse_inst_t cmd_set_port_meter_policer_action = {
1273         .f = cmd_set_port_meter_policer_action_parsed,
1274         .data = NULL,
1275         .help_str = "Set port meter policer action",
1276         .tokens = {
1277                 (void *)&cmd_set_port_meter_policer_action_set,
1278                 (void *)&cmd_set_port_meter_policer_action_port,
1279                 (void *)&cmd_set_port_meter_policer_action_meter,
1280                 (void *)&cmd_set_port_meter_policer_action_policer,
1281                 (void *)&cmd_set_port_meter_policer_action_action,
1282                 (void *)&cmd_set_port_meter_policer_action_port_id,
1283                 (void *)&cmd_set_port_meter_policer_action_mtr_id,
1284                 (void *)&cmd_set_port_meter_policer_action_action_mask,
1285                 (void *)&cmd_set_port_meter_policer_action_policer_action,
1286                 NULL,
1287         },
1288 };
1289
1290 /* *** Set Port Meter Stats Mask *** */
1291 struct cmd_set_port_meter_stats_mask_result {
1292         cmdline_fixed_string_t set;
1293         cmdline_fixed_string_t port;
1294         cmdline_fixed_string_t meter;
1295         cmdline_fixed_string_t stats;
1296         cmdline_fixed_string_t mask;
1297         uint16_t port_id;
1298         uint32_t mtr_id;
1299         uint64_t stats_mask;
1300 };
1301
1302 cmdline_parse_token_string_t cmd_set_port_meter_stats_mask_set =
1303         TOKEN_STRING_INITIALIZER(
1304                 struct cmd_set_port_meter_stats_mask_result, set, "set");
1305 cmdline_parse_token_string_t cmd_set_port_meter_stats_mask_port =
1306         TOKEN_STRING_INITIALIZER(
1307                 struct cmd_set_port_meter_stats_mask_result, port, "port");
1308 cmdline_parse_token_string_t cmd_set_port_meter_stats_mask_meter =
1309         TOKEN_STRING_INITIALIZER(
1310                 struct cmd_set_port_meter_stats_mask_result, meter, "meter");
1311 cmdline_parse_token_string_t cmd_set_port_meter_stats_mask_stats =
1312         TOKEN_STRING_INITIALIZER(
1313                 struct cmd_set_port_meter_stats_mask_result, stats, "stats");
1314 cmdline_parse_token_string_t cmd_set_port_meter_stats_mask_mask =
1315         TOKEN_STRING_INITIALIZER(
1316                 struct cmd_set_port_meter_stats_mask_result, mask, "mask");
1317 cmdline_parse_token_num_t cmd_set_port_meter_stats_mask_port_id =
1318         TOKEN_NUM_INITIALIZER(
1319                 struct cmd_set_port_meter_stats_mask_result, port_id, UINT16);
1320 cmdline_parse_token_num_t cmd_set_port_meter_stats_mask_mtr_id =
1321         TOKEN_NUM_INITIALIZER(
1322                 struct cmd_set_port_meter_stats_mask_result, mtr_id, UINT32);
1323 cmdline_parse_token_num_t cmd_set_port_meter_stats_mask_stats_mask =
1324         TOKEN_NUM_INITIALIZER(
1325                 struct cmd_set_port_meter_stats_mask_result, stats_mask,
1326                 UINT64);
1327
1328 static void cmd_set_port_meter_stats_mask_parsed(void *parsed_result,
1329         __attribute__((unused)) struct cmdline *cl,
1330         __attribute__((unused)) void *data)
1331 {
1332         struct cmd_set_port_meter_stats_mask_result *res = parsed_result;
1333         struct rte_mtr_error error;
1334         uint64_t stats_mask = res->stats_mask;
1335         uint32_t mtr_id = res->mtr_id;
1336         uint16_t port_id = res->port_id;
1337         int ret;
1338
1339         if (port_id_is_invalid(port_id, ENABLED_WARN))
1340                 return;
1341
1342         ret = rte_mtr_stats_update(port_id, mtr_id, stats_mask, &error);
1343         if (ret != 0) {
1344                 print_err_msg(&error);
1345                 return;
1346         }
1347 }
1348
1349 cmdline_parse_inst_t cmd_set_port_meter_stats_mask = {
1350         .f = cmd_set_port_meter_stats_mask_parsed,
1351         .data = NULL,
1352         .help_str = "Set port meter stats mask",
1353         .tokens = {
1354                 (void *)&cmd_set_port_meter_stats_mask_set,
1355                 (void *)&cmd_set_port_meter_stats_mask_port,
1356                 (void *)&cmd_set_port_meter_stats_mask_meter,
1357                 (void *)&cmd_set_port_meter_stats_mask_stats,
1358                 (void *)&cmd_set_port_meter_stats_mask_mask,
1359                 (void *)&cmd_set_port_meter_stats_mask_port_id,
1360                 (void *)&cmd_set_port_meter_stats_mask_mtr_id,
1361                 (void *)&cmd_set_port_meter_stats_mask_stats_mask,
1362                 NULL,
1363         },
1364 };
1365
1366 /* *** Show Port Meter Stats *** */
1367 struct cmd_show_port_meter_stats_result {
1368         cmdline_fixed_string_t show;
1369         cmdline_fixed_string_t port;
1370         cmdline_fixed_string_t meter;
1371         cmdline_fixed_string_t stats;
1372         uint16_t port_id;
1373         uint32_t mtr_id;
1374         cmdline_fixed_string_t clear;
1375 };
1376
1377 cmdline_parse_token_string_t cmd_show_port_meter_stats_show =
1378         TOKEN_STRING_INITIALIZER(
1379                 struct cmd_show_port_meter_stats_result, show, "show");
1380 cmdline_parse_token_string_t cmd_show_port_meter_stats_port =
1381         TOKEN_STRING_INITIALIZER(
1382                 struct cmd_show_port_meter_stats_result, port, "port");
1383 cmdline_parse_token_string_t cmd_show_port_meter_stats_meter =
1384         TOKEN_STRING_INITIALIZER(
1385                 struct cmd_show_port_meter_stats_result, meter, "meter");
1386 cmdline_parse_token_string_t cmd_show_port_meter_stats_stats =
1387         TOKEN_STRING_INITIALIZER(
1388                 struct cmd_show_port_meter_stats_result, stats, "stats");
1389 cmdline_parse_token_num_t cmd_show_port_meter_stats_port_id =
1390         TOKEN_NUM_INITIALIZER(
1391                 struct cmd_show_port_meter_stats_result, port_id, UINT16);
1392 cmdline_parse_token_num_t cmd_show_port_meter_stats_mtr_id =
1393         TOKEN_NUM_INITIALIZER(
1394                 struct cmd_show_port_meter_stats_result, mtr_id, UINT32);
1395 cmdline_parse_token_string_t cmd_show_port_meter_stats_clear =
1396         TOKEN_STRING_INITIALIZER(
1397                 struct cmd_show_port_meter_stats_result, clear, "yes#no");
1398
1399 static void cmd_show_port_meter_stats_parsed(void *parsed_result,
1400         __attribute__((unused)) struct cmdline *cl,
1401         __attribute__((unused)) void *data)
1402 {
1403         struct cmd_show_port_meter_stats_result *res = parsed_result;
1404         struct rte_mtr_stats stats;
1405         uint64_t stats_mask = 0;
1406         struct rte_mtr_error error;
1407         uint32_t mtr_id = res->mtr_id;
1408         uint32_t clear = 0;
1409         uint16_t port_id = res->port_id;
1410         int ret;
1411
1412         if (port_id_is_invalid(port_id, ENABLED_WARN))
1413                 return;
1414
1415         if (strcmp(res->clear, "yes") == 0)
1416                 clear = 1;
1417
1418         memset(&stats, 0, sizeof(struct rte_mtr_stats));
1419         ret = rte_mtr_stats_read(port_id, mtr_id, &stats,
1420                 &stats_mask, clear, &error);
1421         if (ret != 0) {
1422                 print_err_msg(&error);
1423                 return;
1424         }
1425
1426         /* Display stats */
1427         if (stats_mask & RTE_MTR_STATS_N_PKTS_GREEN)
1428                 printf("\tPkts G: %" PRIu64 "\n",
1429                         stats.n_pkts[RTE_MTR_GREEN]);
1430         if (stats_mask & RTE_MTR_STATS_N_BYTES_GREEN)
1431                 printf("\tBytes G: %" PRIu64 "\n",
1432                         stats.n_bytes[RTE_MTR_GREEN]);
1433         if (stats_mask & RTE_MTR_STATS_N_PKTS_YELLOW)
1434                 printf("\tPkts Y: %" PRIu64 "\n",
1435                         stats.n_pkts[RTE_MTR_YELLOW]);
1436         if (stats_mask & RTE_MTR_STATS_N_BYTES_YELLOW)
1437                 printf("\tBytes Y: %" PRIu64 "\n",
1438                         stats.n_bytes[RTE_MTR_YELLOW]);
1439         if (stats_mask & RTE_MTR_STATS_N_PKTS_RED)
1440                 printf("\tPkts R: %" PRIu64 "\n",
1441                         stats.n_pkts[RTE_MTR_RED]);
1442         if (stats_mask & RTE_MTR_STATS_N_BYTES_RED)
1443                 printf("\tBytes Y: %" PRIu64 "\n",
1444                         stats.n_bytes[RTE_MTR_RED]);
1445         if (stats_mask & RTE_MTR_STATS_N_PKTS_DROPPED)
1446                 printf("\tPkts DROPPED: %" PRIu64 "\n",
1447                         stats.n_pkts_dropped);
1448         if (stats_mask & RTE_MTR_STATS_N_BYTES_DROPPED)
1449                 printf("\tBytes DROPPED: %" PRIu64 "\n",
1450                         stats.n_bytes_dropped);
1451 }
1452
1453 cmdline_parse_inst_t cmd_show_port_meter_stats = {
1454         .f = cmd_show_port_meter_stats_parsed,
1455         .data = NULL,
1456         .help_str = "Show port meter stats",
1457         .tokens = {
1458                 (void *)&cmd_show_port_meter_stats_show,
1459                 (void *)&cmd_show_port_meter_stats_port,
1460                 (void *)&cmd_show_port_meter_stats_meter,
1461                 (void *)&cmd_show_port_meter_stats_stats,
1462                 (void *)&cmd_show_port_meter_stats_port_id,
1463                 (void *)&cmd_show_port_meter_stats_mtr_id,
1464                 (void *)&cmd_show_port_meter_stats_clear,
1465                 NULL,
1466         },
1467 };