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 [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 62 void 63 print_mtr_err_msg(struct rte_mtr_error *error) 64 { 65 print_err_msg(error); 66 } 67 68 static int 69 parse_uint(uint64_t *value, const char *str) 70 { 71 char *next = NULL; 72 uint64_t n; 73 74 errno = 0; 75 /* Parse number string */ 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 85 static int 86 parse_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 /* Allocate memory for dscp table */ 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 127 static int 128 parse_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 /* First token: use previous meter color */ 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 /* Check if previous meter color to be used */ 145 if (previous_mtr_color) { 146 *use_prev_meter_color = previous_mtr_color; 147 return 0; 148 } 149 150 /* Parse dscp table entries */ 151 ret = parse_dscp_table_entries(c_str, dscp_table); 152 if (ret != 0) 153 return -1; 154 155 return 0; 156 } 157 158 static int 159 parse_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 /* First token: port id */ 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 /* Second token: meter id */ 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 /* *** Show Port Meter Capabilities *** */ 196 struct 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 204 cmdline_parse_token_string_t cmd_show_port_meter_cap_show = 205 TOKEN_STRING_INITIALIZER( 206 struct cmd_show_port_meter_cap_result, show, "show"); 207 cmdline_parse_token_string_t cmd_show_port_meter_cap_port = 208 TOKEN_STRING_INITIALIZER( 209 struct cmd_show_port_meter_cap_result, port, "port"); 210 cmdline_parse_token_string_t cmd_show_port_meter_cap_meter = 211 TOKEN_STRING_INITIALIZER( 212 struct cmd_show_port_meter_cap_result, meter, "meter"); 213 cmdline_parse_token_string_t cmd_show_port_meter_cap_cap = 214 TOKEN_STRING_INITIALIZER( 215 struct cmd_show_port_meter_cap_result, cap, "cap"); 216 cmdline_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 220 static 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 282 cmdline_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 /* *** Add Port Meter Profile srtcm_rfc2697 *** */ 297 struct 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 311 cmdline_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"); 314 cmdline_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"); 318 cmdline_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"); 322 cmdline_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"); 326 cmdline_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"); 330 cmdline_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); 334 cmdline_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); 338 cmdline_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); 342 cmdline_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); 346 cmdline_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); 350 cmdline_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 355 static 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 /* Private shaper profile params */ 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 384 cmdline_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 /* *** Add Port Meter Profile trtcm_rfc2698 *** */ 405 struct 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 420 cmdline_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"); 423 cmdline_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"); 427 cmdline_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"); 431 cmdline_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"); 435 cmdline_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"); 439 cmdline_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); 443 cmdline_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); 447 cmdline_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); 451 cmdline_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); 455 cmdline_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); 459 cmdline_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); 463 cmdline_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 468 static 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 /* Private shaper profile params */ 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 498 cmdline_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 /* *** Add Port Meter Profile trtcm_rfc4115 *** */ 520 struct 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 535 cmdline_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"); 539 cmdline_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"); 543 cmdline_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"); 547 cmdline_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"); 551 cmdline_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"); 556 cmdline_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); 560 cmdline_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); 564 cmdline_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); 568 cmdline_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); 572 cmdline_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); 576 cmdline_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); 580 cmdline_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 586 static 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 /* Private shaper profile params */ 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 618 cmdline_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 /* *** Delete Port Meter Profile *** */ 640 struct 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 649 cmdline_parse_token_string_t cmd_del_port_meter_profile_del = 650 TOKEN_STRING_INITIALIZER( 651 struct cmd_del_port_meter_profile_result, del, "del"); 652 cmdline_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"); 656 cmdline_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"); 660 cmdline_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"); 664 cmdline_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); 668 cmdline_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 673 static 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 /* Delete meter profile */ 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 694 cmdline_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 /* *** Create Port Meter Object *** */ 710 struct 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 727 cmdline_parse_token_string_t cmd_create_port_meter_create = 728 TOKEN_STRING_INITIALIZER( 729 struct cmd_create_port_meter_result, create, "create"); 730 cmdline_parse_token_string_t cmd_create_port_meter_port = 731 TOKEN_STRING_INITIALIZER( 732 struct cmd_create_port_meter_result, port, "port"); 733 cmdline_parse_token_string_t cmd_create_port_meter_meter = 734 TOKEN_STRING_INITIALIZER( 735 struct cmd_create_port_meter_result, meter, "meter"); 736 cmdline_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); 739 cmdline_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); 742 cmdline_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); 745 cmdline_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); 748 cmdline_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"); 751 cmdline_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"); 754 cmdline_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"); 757 cmdline_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"); 760 cmdline_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); 763 cmdline_parse_token_num_t cmd_create_port_meter_shared = 764 TOKEN_NUM_INITIALIZER(struct cmd_create_port_meter_result, 765 shared, RTE_UINT32); 766 cmdline_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 770 static 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 /* Meter params */ 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 /* Parse meter input color string params */ 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 817 cmdline_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 /* *** Enable Meter of MTR Object *** */ 840 struct 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 848 cmdline_parse_token_string_t cmd_enable_port_meter_enable = 849 TOKEN_STRING_INITIALIZER( 850 struct cmd_enable_port_meter_result, enable, "enable"); 851 cmdline_parse_token_string_t cmd_enable_port_meter_port = 852 TOKEN_STRING_INITIALIZER( 853 struct cmd_enable_port_meter_result, port, "port"); 854 cmdline_parse_token_string_t cmd_enable_port_meter_meter = 855 TOKEN_STRING_INITIALIZER( 856 struct cmd_enable_port_meter_result, meter, "meter"); 857 cmdline_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); 860 cmdline_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 864 static 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 /* Enable Meter */ 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 886 cmdline_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 /* *** Disable Meter of MTR Object *** */ 901 struct 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 909 cmdline_parse_token_string_t cmd_disable_port_meter_disable = 910 TOKEN_STRING_INITIALIZER( 911 struct cmd_disable_port_meter_result, disable, "disable"); 912 cmdline_parse_token_string_t cmd_disable_port_meter_port = 913 TOKEN_STRING_INITIALIZER( 914 struct cmd_disable_port_meter_result, port, "port"); 915 cmdline_parse_token_string_t cmd_disable_port_meter_meter = 916 TOKEN_STRING_INITIALIZER( 917 struct cmd_disable_port_meter_result, meter, "meter"); 918 cmdline_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); 921 cmdline_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 925 static 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 /* Disable Meter */ 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 947 cmdline_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 /* *** Delete Port Meter Policy Object *** */ 962 struct 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 971 cmdline_parse_token_string_t cmd_del_port_meter_policy_del = 972 TOKEN_STRING_INITIALIZER( 973 struct cmd_del_port_meter_policy_result, del, "del"); 974 cmdline_parse_token_string_t cmd_del_port_meter_policy_port = 975 TOKEN_STRING_INITIALIZER( 976 struct cmd_del_port_meter_policy_result, port, "port"); 977 cmdline_parse_token_string_t cmd_del_port_meter_policy_meter = 978 TOKEN_STRING_INITIALIZER( 979 struct cmd_del_port_meter_policy_result, meter, "meter"); 980 cmdline_parse_token_string_t cmd_del_port_meter_policy_policy = 981 TOKEN_STRING_INITIALIZER( 982 struct cmd_del_port_meter_policy_result, policy, "policy"); 983 cmdline_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); 986 cmdline_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 990 static 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 /* Delete Meter Policy*/ 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 1011 cmdline_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 /* *** Delete Port Meter Object *** */ 1027 struct 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 1035 cmdline_parse_token_string_t cmd_del_port_meter_del = 1036 TOKEN_STRING_INITIALIZER( 1037 struct cmd_del_port_meter_result, del, "del"); 1038 cmdline_parse_token_string_t cmd_del_port_meter_port = 1039 TOKEN_STRING_INITIALIZER( 1040 struct cmd_del_port_meter_result, port, "port"); 1041 cmdline_parse_token_string_t cmd_del_port_meter_meter = 1042 TOKEN_STRING_INITIALIZER( 1043 struct cmd_del_port_meter_result, meter, "meter"); 1044 cmdline_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); 1047 cmdline_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 1051 static 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 /* Destroy Meter */ 1066 ret = rte_mtr_destroy(port_id, mtr_id, &error); 1067 if (ret != 0) { 1068 print_err_msg(&error); 1069 return; 1070 } 1071 } 1072 1073 cmdline_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 /* *** Set Port Meter Profile *** */ 1088 struct 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 1098 cmdline_parse_token_string_t cmd_set_port_meter_profile_set = 1099 TOKEN_STRING_INITIALIZER( 1100 struct cmd_set_port_meter_profile_result, set, "set"); 1101 cmdline_parse_token_string_t cmd_set_port_meter_profile_port = 1102 TOKEN_STRING_INITIALIZER( 1103 struct cmd_set_port_meter_profile_result, port, "port"); 1104 cmdline_parse_token_string_t cmd_set_port_meter_profile_meter = 1105 TOKEN_STRING_INITIALIZER( 1106 struct cmd_set_port_meter_profile_result, meter, "meter"); 1107 cmdline_parse_token_string_t cmd_set_port_meter_profile_profile = 1108 TOKEN_STRING_INITIALIZER( 1109 struct cmd_set_port_meter_profile_result, profile, "profile"); 1110 cmdline_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); 1114 cmdline_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); 1118 cmdline_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 1123 static 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 /* Set meter profile */ 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 1147 cmdline_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 /* *** Set Port Meter DSCP Table *** */ 1164 struct 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 1172 cmdline_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"); 1175 cmdline_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"); 1178 cmdline_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"); 1181 cmdline_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"); 1185 cmdline_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 1189 static 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 /* Parse string */ 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 /* Update Meter DSCP Table*/ 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 1217 free_table: 1218 free(dscp_table); 1219 } 1220 1221 cmdline_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 /* *** Set Port Meter Stats Mask *** */ 1237 struct 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 1248 cmdline_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"); 1251 cmdline_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"); 1254 cmdline_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"); 1257 cmdline_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"); 1260 cmdline_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"); 1263 cmdline_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); 1267 cmdline_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); 1271 cmdline_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 1276 static 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 1297 cmdline_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 /* *** Show Port Meter Stats *** */ 1315 struct 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 1325 cmdline_parse_token_string_t cmd_show_port_meter_stats_show = 1326 TOKEN_STRING_INITIALIZER( 1327 struct cmd_show_port_meter_stats_result, show, "show"); 1328 cmdline_parse_token_string_t cmd_show_port_meter_stats_port = 1329 TOKEN_STRING_INITIALIZER( 1330 struct cmd_show_port_meter_stats_result, port, "port"); 1331 cmdline_parse_token_string_t cmd_show_port_meter_stats_meter = 1332 TOKEN_STRING_INITIALIZER( 1333 struct cmd_show_port_meter_stats_result, meter, "meter"); 1334 cmdline_parse_token_string_t cmd_show_port_meter_stats_stats = 1335 TOKEN_STRING_INITIALIZER( 1336 struct cmd_show_port_meter_stats_result, stats, "stats"); 1337 cmdline_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); 1340 cmdline_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); 1343 cmdline_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 1347 static 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 /* Display stats */ 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 1401 cmdline_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