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