]> git.proxmox.com Git - ceph.git/blame - ceph/src/spdk/dpdk/app/test-pmd/cmdline_mtr.c
projects / ceph.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
update source to Ceph Pacific 16.2.2
[ceph.git] / ceph / src / spdk / dpdk / app / test-pmd / cmdline_mtr.c
CommitLineData
11fdf7f2
TL		 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 */
20static void
21print_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
59static int
60parse_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
76static int
9f95a23c 77parse_dscp_table_entries(char *str, enum rte_color **dscp_table)
11fdf7f2
TL		 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 */
9f95a23c
TL		 87 *dscp_table = (enum rte_color *)malloc(MAX_DSCP_TABLE_ENTRIES *
88 sizeof(enum rte_color));
89 if (*dscp_table == NULL)
11fdf7f2
TL		 90 return -1;
91
92 while (1) {
93 if (strcmp(token, "G") == 0 ||
94 strcmp(token, "g") == 0)
9f95a23c 95 *dscp_table[i++] = RTE_COLOR_GREEN;
11fdf7f2
TL		 96 else if (strcmp(token, "Y") == 0 ||
97 strcmp(token, "y") == 0)
9f95a23c 98 *dscp_table[i++] = RTE_COLOR_YELLOW;
11fdf7f2
TL		 99 else if (strcmp(token, "R") == 0 ||
100 strcmp(token, "r") == 0)
9f95a23c 101 *dscp_table[i++] = RTE_COLOR_RED;
11fdf7f2 102 else {
9f95a23c 103 free(*dscp_table);
11fdf7f2
TL		 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) {
9f95a23c 111 free(*dscp_table);
11fdf7f2
TL		 112 return -1;
113 }
114 }
115 return 0;
116}
117
118static int
119parse_meter_color_str(char *c_str, uint32_t *use_prev_meter_color,
9f95a23c 120 enum rte_color **dscp_table)
11fdf7f2
TL		 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
149static int
150string_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
167static int
168parse_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)) {
9f95a23c 185 actions[RTE_COLOR_GREEN] = action;
11fdf7f2
TL		 186 g_color = 1;
187 } else if (y_color == 0 && (action_mask & 0x2)) {
9f95a23c 188 actions[RTE_COLOR_YELLOW] = action;
11fdf7f2
TL		 189 y_color = 1;
190 } else
9f95a23c 191 actions[RTE_COLOR_RED] = action;
11fdf7f2
TL		 192 }
193 return 0;
194}
195
196static int
197parse_multi_token_string(char *t_str, uint16_t *port_id,
9f95a23c 198 uint32_t *mtr_id, enum rte_color **dscp_table)
11fdf7f2
TL		 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 *** */
234struct 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
242cmdline_parse_token_string_t cmd_show_port_meter_cap_show =
243 TOKEN_STRING_INITIALIZER(
244 struct cmd_show_port_meter_cap_result, show, "show");
245cmdline_parse_token_string_t cmd_show_port_meter_cap_port =
246 TOKEN_STRING_INITIALIZER(
247 struct cmd_show_port_meter_cap_result, port, "port");
248cmdline_parse_token_string_t cmd_show_port_meter_cap_meter =
249 TOKEN_STRING_INITIALIZER(
250 struct cmd_show_port_meter_cap_result, meter, "meter");
251cmdline_parse_token_string_t cmd_show_port_meter_cap_cap =
252 TOKEN_STRING_INITIALIZER(
253 struct cmd_show_port_meter_cap_result, cap, "cap");
254cmdline_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
258static void cmd_show_port_meter_cap_parsed(void *parsed_result,
f67539c2
TL		 259 __rte_unused struct cmdline *cl,
260 __rte_unused void *data)
11fdf7f2
TL		 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
312cmdline_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 *** */
327struct 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
340cmdline_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");
343cmdline_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");
347cmdline_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");
351cmdline_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");
355cmdline_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");
359cmdline_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);
363cmdline_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);
367cmdline_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);
371cmdline_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);
375cmdline_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
380static void cmd_add_port_meter_profile_srtcm_parsed(void *parsed_result,
f67539c2
TL		 381 __rte_unused struct cmdline *cl,
382 __rte_unused void *data)
11fdf7f2
TL		 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
408cmdline_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,
9f95a23c 417 (void *)&cmd_add_port_meter_profile_srtcm_srtcm_rfc2697,
11fdf7f2
TL		 418 (void *)&cmd_add_port_meter_profile_srtcm_port_id,
419 (void *)&cmd_add_port_meter_profile_srtcm_profile_id,
11fdf7f2
TL		 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 *** */
428struct 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
442cmdline_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");
445cmdline_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");
449cmdline_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");
453cmdline_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");
457cmdline_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");
461cmdline_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);
465cmdline_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);
469cmdline_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);
473cmdline_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);
477cmdline_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);
481cmdline_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
486static void cmd_add_port_meter_profile_trtcm_parsed(void *parsed_result,
f67539c2
TL		 487 __rte_unused struct cmdline *cl,
488 __rte_unused void *data)
11fdf7f2
TL		 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
515cmdline_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,
9f95a23c 524 (void *)&cmd_add_port_meter_profile_trtcm_trtcm_rfc2698,
11fdf7f2
TL		 525 (void *)&cmd_add_port_meter_profile_trtcm_port_id,
526 (void *)&cmd_add_port_meter_profile_trtcm_profile_id,
11fdf7f2
TL		 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 *** */
536struct 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
550cmdline_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");
554cmdline_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");
558cmdline_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");
562cmdline_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");
566cmdline_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");
571cmdline_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);
575cmdline_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);
579cmdline_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);
583cmdline_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);
587cmdline_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);
591cmdline_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
596static void cmd_add_port_meter_profile_trtcm_rfc4115_parsed(
597 void *parsed_result,
f67539c2
TL		 598 __rte_unused struct cmdline *cl,
599 __rte_unused void *data)
11fdf7f2
TL		 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
627cmdline_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,
9f95a23c 636 (void *)&cmd_add_port_meter_profile_trtcm_rfc4115_trtcm_rfc4115,
11fdf7f2
TL		 637 (void *)&cmd_add_port_meter_profile_trtcm_rfc4115_port_id,
638 (void *)&cmd_add_port_meter_profile_trtcm_rfc4115_profile_id,
11fdf7f2
TL		 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 *** */
648struct 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
657cmdline_parse_token_string_t cmd_del_port_meter_profile_del =
658 TOKEN_STRING_INITIALIZER(
659 struct cmd_del_port_meter_profile_result, del, "del");
660cmdline_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");
664cmdline_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");
668cmdline_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");
672cmdline_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);
676cmdline_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
681static void cmd_del_port_meter_profile_parsed(void *parsed_result,
f67539c2
TL		 682 __rte_unused struct cmdline *cl,
683 __rte_unused void *data)
11fdf7f2
TL		 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
702cmdline_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 *** */
718struct 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
734cmdline_parse_token_string_t cmd_create_port_meter_create =
735 TOKEN_STRING_INITIALIZER(
736 struct cmd_create_port_meter_result, create, "create");
737cmdline_parse_token_string_t cmd_create_port_meter_port =
738 TOKEN_STRING_INITIALIZER(
739 struct cmd_create_port_meter_result, port, "port");
740cmdline_parse_token_string_t cmd_create_port_meter_meter =
741 TOKEN_STRING_INITIALIZER(
742 struct cmd_create_port_meter_result, meter, "meter");
743cmdline_parse_token_num_t cmd_create_port_meter_port_id =
744 TOKEN_NUM_INITIALIZER(
745 struct cmd_create_port_meter_result, port_id, UINT16);
746cmdline_parse_token_num_t cmd_create_port_meter_mtr_id =
747 TOKEN_NUM_INITIALIZER(
748 struct cmd_create_port_meter_result, mtr_id, UINT32);
749cmdline_parse_token_num_t cmd_create_port_meter_profile_id =
750 TOKEN_NUM_INITIALIZER(
751 struct cmd_create_port_meter_result, profile_id, UINT32);
752cmdline_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");
755cmdline_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");
758cmdline_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");
761cmdline_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");
764cmdline_parse_token_num_t cmd_create_port_meter_statistics_mask =
765 TOKEN_NUM_INITIALIZER(struct cmd_create_port_meter_result,
766 statistics_mask, UINT64);
767cmdline_parse_token_num_t cmd_create_port_meter_shared =
768 TOKEN_NUM_INITIALIZER(struct cmd_create_port_meter_result,
769 shared, UINT32);
770cmdline_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
774static void cmd_create_port_meter_parsed(void *parsed_result,
f67539c2
TL		 775 __rte_unused struct cmdline *cl,
776 __rte_unused void *data)
11fdf7f2
TL		 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;
9f95a23c 785 enum rte_color *dscp_table = NULL;
11fdf7f2
TL		 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 */
9f95a23c 797 ret = parse_meter_color_str(c_str, &use_prev_meter_color, &dscp_table);
11fdf7f2
TL		 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
9f95a23c 811 params.action[RTE_COLOR_GREEN] =
11fdf7f2 812 string_to_policer_action(res->g_action);
9f95a23c 813 params.action[RTE_COLOR_YELLOW] =
11fdf7f2 814 string_to_policer_action(res->y_action);
9f95a23c 815 params.action[RTE_COLOR_RED] =
11fdf7f2
TL		 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
827cmdline_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 *** */
850struct 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
858cmdline_parse_token_string_t cmd_enable_port_meter_enable =
859 TOKEN_STRING_INITIALIZER(
860 struct cmd_enable_port_meter_result, enable, "enable");
861cmdline_parse_token_string_t cmd_enable_port_meter_port =
862 TOKEN_STRING_INITIALIZER(
863 struct cmd_enable_port_meter_result, port, "port");
864cmdline_parse_token_string_t cmd_enable_port_meter_meter =
865 TOKEN_STRING_INITIALIZER(
866 struct cmd_enable_port_meter_result, meter, "meter");
867cmdline_parse_token_num_t cmd_enable_port_meter_port_id =
868 TOKEN_NUM_INITIALIZER(
869 struct cmd_enable_port_meter_result, port_id, UINT16);
870cmdline_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
874static void cmd_enable_port_meter_parsed(void *parsed_result,
f67539c2
TL		 875 __rte_unused struct cmdline *cl,
876 __rte_unused void *data)
11fdf7f2
TL		 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
896cmdline_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 *** */
911struct 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
919cmdline_parse_token_string_t cmd_disable_port_meter_disable =
920 TOKEN_STRING_INITIALIZER(
921 struct cmd_disable_port_meter_result, disable, "disable");
922cmdline_parse_token_string_t cmd_disable_port_meter_port =
923 TOKEN_STRING_INITIALIZER(
924 struct cmd_disable_port_meter_result, port, "port");
925cmdline_parse_token_string_t cmd_disable_port_meter_meter =
926 TOKEN_STRING_INITIALIZER(
927 struct cmd_disable_port_meter_result, meter, "meter");
928cmdline_parse_token_num_t cmd_disable_port_meter_port_id =
929 TOKEN_NUM_INITIALIZER(
930 struct cmd_disable_port_meter_result, port_id, UINT16);
931cmdline_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
935static void cmd_disable_port_meter_parsed(void *parsed_result,
f67539c2
TL		 936 __rte_unused struct cmdline *cl,
937 __rte_unused void *data)
11fdf7f2
TL		 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
957cmdline_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 *** */
972struct 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
980cmdline_parse_token_string_t cmd_del_port_meter_del =
981 TOKEN_STRING_INITIALIZER(
982 struct cmd_del_port_meter_result, del, "del");
983cmdline_parse_token_string_t cmd_del_port_meter_port =
984 TOKEN_STRING_INITIALIZER(
985 struct cmd_del_port_meter_result, port, "port");
986cmdline_parse_token_string_t cmd_del_port_meter_meter =
987 TOKEN_STRING_INITIALIZER(
988 struct cmd_del_port_meter_result, meter, "meter");
989cmdline_parse_token_num_t cmd_del_port_meter_port_id =
990 TOKEN_NUM_INITIALIZER(
991 struct cmd_del_port_meter_result, port_id, UINT16);
992cmdline_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
996static void cmd_del_port_meter_parsed(void *parsed_result,
f67539c2
TL		 997 __rte_unused struct cmdline *cl,
998 __rte_unused void *data)
11fdf7f2
TL		 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
1018cmdline_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 *** */
1033struct 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
1043cmdline_parse_token_string_t cmd_set_port_meter_profile_set =
1044 TOKEN_STRING_INITIALIZER(
1045 struct cmd_set_port_meter_profile_result, set, "set");
1046cmdline_parse_token_string_t cmd_set_port_meter_profile_port =
1047 TOKEN_STRING_INITIALIZER(
1048 struct cmd_set_port_meter_profile_result, port, "port");
1049cmdline_parse_token_string_t cmd_set_port_meter_profile_meter =
1050 TOKEN_STRING_INITIALIZER(
1051 struct cmd_set_port_meter_profile_result, meter, "meter");
1052cmdline_parse_token_string_t cmd_set_port_meter_profile_profile =
1053 TOKEN_STRING_INITIALIZER(
1054 struct cmd_set_port_meter_profile_result, profile, "profile");
1055cmdline_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);
1058cmdline_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);
1061cmdline_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
1065static void cmd_set_port_meter_profile_parsed(void *parsed_result,
f67539c2
TL		 1066 __rte_unused struct cmdline *cl,
1067 __rte_unused void *data)
11fdf7f2
TL		 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
1089cmdline_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 *** */
1106struct 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
1114cmdline_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");
1117cmdline_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");
1120cmdline_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");
1123cmdline_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");
1127cmdline_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
1131static void cmd_set_port_meter_dscp_table_parsed(void *parsed_result,
f67539c2
TL		 1132 __rte_unused struct cmdline *cl,
1133 __rte_unused void *data)
11fdf7f2
TL		 1134{
1135 struct cmd_set_port_meter_dscp_table_result *res = parsed_result;
1136 struct rte_mtr_error error;
9f95a23c 1137 enum rte_color *dscp_table = NULL;
11fdf7f2
TL		 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 */
9f95a23c 1144 ret = parse_multi_token_string(t_str, &port_id, &mtr_id, &dscp_table);
11fdf7f2
TL		 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))
9f95a23c 1151 goto free_table;
11fdf7f2
TL		 1152
1153 /* Update Meter DSCP Table*/
1154 ret = rte_mtr_meter_dscp_table_update(port_id, mtr_id,
1155 dscp_table, &error);
9f95a23c 1156 if (ret != 0)
11fdf7f2 1157 print_err_msg(&error);
9f95a23c
TL		 1158
1159free_table:
11fdf7f2
TL		 1160 free(dscp_table);
1161}
1162
1163cmdline_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 *** */
1178struct 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
1190cmdline_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");
1193cmdline_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");
1196cmdline_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");
1200cmdline_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");
1204cmdline_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");
1208cmdline_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);
1212cmdline_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);
1216cmdline_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);
1220cmdline_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
1225static void cmd_set_port_meter_policer_action_parsed(void *parsed_result,
f67539c2
TL		 1226 __rte_unused struct cmdline *cl,
1227 __rte_unused void *data)
11fdf7f2
TL		 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 */
9f95a23c 1248 actions = (enum rte_mtr_policer_action *)malloc(RTE_COLORS *
11fdf7f2
TL		 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
1272cmdline_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 *** */
1291struct 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
1302cmdline_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");
1305cmdline_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");
1308cmdline_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");
1311cmdline_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");
1314cmdline_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");
1317cmdline_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);
1320cmdline_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);
1323cmdline_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
1328static void cmd_set_port_meter_stats_mask_parsed(void *parsed_result,
f67539c2
TL		 1329 __rte_unused struct cmdline *cl,
1330 __rte_unused void *data)
11fdf7f2
TL		 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
1349cmdline_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 *** */
1367struct 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
1377cmdline_parse_token_string_t cmd_show_port_meter_stats_show =
1378 TOKEN_STRING_INITIALIZER(
1379 struct cmd_show_port_meter_stats_result, show, "show");
1380cmdline_parse_token_string_t cmd_show_port_meter_stats_port =
1381 TOKEN_STRING_INITIALIZER(
1382 struct cmd_show_port_meter_stats_result, port, "port");
1383cmdline_parse_token_string_t cmd_show_port_meter_stats_meter =
1384 TOKEN_STRING_INITIALIZER(
1385 struct cmd_show_port_meter_stats_result, meter, "meter");
1386cmdline_parse_token_string_t cmd_show_port_meter_stats_stats =
1387 TOKEN_STRING_INITIALIZER(
1388 struct cmd_show_port_meter_stats_result, stats, "stats");
1389cmdline_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);
1392cmdline_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);
1395cmdline_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
1399static void cmd_show_port_meter_stats_parsed(void *parsed_result,
f67539c2
TL		 1400 __rte_unused struct cmdline *cl,
1401 __rte_unused void *data)
11fdf7f2
TL		 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",
9f95a23c 1429 stats.n_pkts[RTE_COLOR_GREEN]);
11fdf7f2
TL		 1430 if (stats_mask & RTE_MTR_STATS_N_BYTES_GREEN)
1431 printf("\tBytes G: %" PRIu64 "\n",
9f95a23c 1432 stats.n_bytes[RTE_COLOR_GREEN]);
11fdf7f2
TL		 1433 if (stats_mask & RTE_MTR_STATS_N_PKTS_YELLOW)
1434 printf("\tPkts Y: %" PRIu64 "\n",
9f95a23c 1435 stats.n_pkts[RTE_COLOR_YELLOW]);
11fdf7f2
TL		 1436 if (stats_mask & RTE_MTR_STATS_N_BYTES_YELLOW)
1437 printf("\tBytes Y: %" PRIu64 "\n",
9f95a23c 1438 stats.n_bytes[RTE_COLOR_YELLOW]);
11fdf7f2
TL		 1439 if (stats_mask & RTE_MTR_STATS_N_PKTS_RED)
1440 printf("\tPkts R: %" PRIu64 "\n",
9f95a23c 1441 stats.n_pkts[RTE_COLOR_RED]);
11fdf7f2 1442 if (stats_mask & RTE_MTR_STATS_N_BYTES_RED)
9f95a23c
TL		 1443 printf("\tBytes R: %" PRIu64 "\n",
1444 stats.n_bytes[RTE_COLOR_RED]);
11fdf7f2
TL		 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
1453cmdline_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};
Ceph