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