1 /* SPDX-License-Identifier: BSD-3-Clause 2 * Copyright(c) 2016-2017 Intel Corporation 3 */ 4 5 #include <getopt.h> 6 #include <unistd.h> 7 8 #include <rte_cryptodev.h> 9 #include <rte_malloc.h> 10 #include <rte_ether.h> 11 12 #include "cperf_options.h" 13 14 #define AES_BLOCK_SIZE 16 15 #define DES_BLOCK_SIZE 8 16 17 struct name_id_map { 18 const char *name; 19 uint32_t id; 20 }; 21 22 static void 23 usage(char *progname) 24 { 25 printf("%s [EAL options] --\n" 26 " --silent: disable options dump\n" 27 " --ptest throughput / latency / verify / pmd-cycleount :" 28 " set test type\n" 29 " --pool_sz N: set the number of crypto ops/mbufs allocated\n" 30 " --total-ops N: set the number of total operations performed\n" 31 " --burst-sz N: set the number of packets per burst\n" 32 " --buffer-sz N: set the size of a single packet\n" 33 " --imix N: set the distribution of packet sizes\n" 34 " --segment-sz N: set the size of the segment to use\n" 35 " --desc-nb N: set number of descriptors for each crypto device\n" 36 " --devtype TYPE: set crypto device type to use\n" 37 " --optype cipher-only / auth-only / cipher-then-auth /\n" 38 " auth-then-cipher / aead : set operation type\n" 39 " --sessionless: enable session-less crypto operations\n" 40 " --out-of-place: enable out-of-place crypto operations\n" 41 " --test-file NAME: set the test vector file path\n" 42 " --test-name NAME: set specific test name section in test file\n" 43 " --cipher-algo ALGO: set cipher algorithm\n" 44 " --cipher-op encrypt / decrypt: set the cipher operation\n" 45 " --cipher-key-sz N: set the cipher key size\n" 46 " --cipher-iv-sz N: set the cipher IV size\n" 47 " --auth-algo ALGO: set auth algorithm\n" 48 " --auth-op generate / verify: set the auth operation\n" 49 " --auth-key-sz N: set the auth key size\n" 50 " --auth-iv-sz N: set the auth IV size\n" 51 " --aead-algo ALGO: set AEAD algorithm\n" 52 " --aead-op encrypt / decrypt: set the AEAD operation\n" 53 " --aead-key-sz N: set the AEAD key size\n" 54 " --aead-iv-sz N: set the AEAD IV size\n" 55 " --aead-aad-sz N: set the AEAD AAD size\n" 56 " --digest-sz N: set the digest size\n" 57 " --pmd-cyclecount-delay-ms N: set delay between enqueue\n" 58 " and dequeue in pmd-cyclecount benchmarking mode\n" 59 " --csv-friendly: enable test result output CSV friendly\n" 60 #ifdef RTE_LIBRTE_SECURITY 61 " --docsis-hdr-sz: set DOCSIS header size\n" 62 #endif 63 " -h: prints this help\n", 64 progname); 65 } 66 67 static int 68 get_str_key_id_mapping(struct name_id_map *map, unsigned int map_len, 69 const char *str_key) 70 { 71 unsigned int i; 72 73 for (i = 0; i < map_len; i++) { 74 75 if (strcmp(str_key, map[i].name) == 0) 76 return map[i].id; 77 } 78 79 return -1; 80 } 81 82 static int 83 parse_cperf_test_type(struct cperf_options *opts, const char *arg) 84 { 85 struct name_id_map cperftest_namemap[] = { 86 { 87 cperf_test_type_strs[CPERF_TEST_TYPE_THROUGHPUT], 88 CPERF_TEST_TYPE_THROUGHPUT 89 }, 90 { 91 cperf_test_type_strs[CPERF_TEST_TYPE_VERIFY], 92 CPERF_TEST_TYPE_VERIFY 93 }, 94 { 95 cperf_test_type_strs[CPERF_TEST_TYPE_LATENCY], 96 CPERF_TEST_TYPE_LATENCY 97 }, 98 { 99 cperf_test_type_strs[CPERF_TEST_TYPE_PMDCC], 100 CPERF_TEST_TYPE_PMDCC 101 } 102 }; 103 104 int id = get_str_key_id_mapping( 105 (struct name_id_map *)cperftest_namemap, 106 RTE_DIM(cperftest_namemap), arg); 107 if (id < 0) { 108 RTE_LOG(ERR, USER1, "failed to parse test type"); 109 return -1; 110 } 111 112 opts->test = (enum cperf_perf_test_type)id; 113 114 return 0; 115 } 116 117 static int 118 parse_uint32_t(uint32_t *value, const char *arg) 119 { 120 char *end = NULL; 121 unsigned long n = strtoul(arg, &end, 10); 122 123 if ((optarg[0] == '\0') || (end == NULL) || (*end != '\0')) 124 return -1; 125 126 if (n > UINT32_MAX) 127 return -ERANGE; 128 129 *value = (uint32_t) n; 130 131 return 0; 132 } 133 134 static int 135 parse_uint16_t(uint16_t *value, const char *arg) 136 { 137 uint32_t val = 0; 138 int ret = parse_uint32_t(&val, arg); 139 140 if (ret < 0) 141 return ret; 142 143 if (val > UINT16_MAX) 144 return -ERANGE; 145 146 *value = (uint16_t) val; 147 148 return 0; 149 } 150 151 static int 152 parse_range(const char *arg, uint32_t *min, uint32_t *max, uint32_t *inc) 153 { 154 char *token; 155 uint32_t number; 156 157 char *copy_arg = strdup(arg); 158 159 if (copy_arg == NULL) 160 return -1; 161 162 errno = 0; 163 token = strtok(copy_arg, ":"); 164 165 /* Parse minimum value */ 166 if (token != NULL) { 167 number = strtoul(token, NULL, 10); 168 169 if (errno == EINVAL || errno == ERANGE || 170 number == 0) 171 goto err_range; 172 173 *min = number; 174 } else 175 goto err_range; 176 177 token = strtok(NULL, ":"); 178 179 /* Parse increment value */ 180 if (token != NULL) { 181 number = strtoul(token, NULL, 10); 182 183 if (errno == EINVAL || errno == ERANGE || 184 number == 0) 185 goto err_range; 186 187 *inc = number; 188 } else 189 goto err_range; 190 191 token = strtok(NULL, ":"); 192 193 /* Parse maximum value */ 194 if (token != NULL) { 195 number = strtoul(token, NULL, 10); 196 197 if (errno == EINVAL || errno == ERANGE || 198 number == 0 || 199 number < *min) 200 goto err_range; 201 202 *max = number; 203 } else 204 goto err_range; 205 206 if (strtok(NULL, ":") != NULL) 207 goto err_range; 208 209 free(copy_arg); 210 return 0; 211 212 err_range: 213 free(copy_arg); 214 return -1; 215 } 216 217 static int 218 parse_list(const char *arg, uint32_t *list, uint32_t *min, uint32_t *max) 219 { 220 char *token; 221 uint32_t number; 222 uint8_t count = 0; 223 uint32_t temp_min; 224 uint32_t temp_max; 225 226 char *copy_arg = strdup(arg); 227 228 if (copy_arg == NULL) 229 return -1; 230 231 errno = 0; 232 token = strtok(copy_arg, ","); 233 234 /* Parse first value */ 235 if (token != NULL) { 236 number = strtoul(token, NULL, 10); 237 238 if (errno == EINVAL || errno == ERANGE || 239 number == 0) 240 goto err_list; 241 242 list[count++] = number; 243 temp_min = number; 244 temp_max = number; 245 } else 246 goto err_list; 247 248 token = strtok(NULL, ","); 249 250 while (token != NULL) { 251 if (count == MAX_LIST) { 252 RTE_LOG(WARNING, USER1, "Using only the first %u sizes\n", 253 MAX_LIST); 254 break; 255 } 256 257 number = strtoul(token, NULL, 10); 258 259 if (errno == EINVAL || errno == ERANGE || 260 number == 0) 261 goto err_list; 262 263 list[count++] = number; 264 265 if (number < temp_min) 266 temp_min = number; 267 if (number > temp_max) 268 temp_max = number; 269 270 token = strtok(NULL, ","); 271 } 272 273 if (min) 274 *min = temp_min; 275 if (max) 276 *max = temp_max; 277 278 free(copy_arg); 279 return count; 280 281 err_list: 282 free(copy_arg); 283 return -1; 284 } 285 286 static int 287 parse_total_ops(struct cperf_options *opts, const char *arg) 288 { 289 int ret = parse_uint32_t(&opts->total_ops, arg); 290 291 if (ret) 292 RTE_LOG(ERR, USER1, "failed to parse total operations count\n"); 293 294 if (opts->total_ops == 0) { 295 RTE_LOG(ERR, USER1, 296 "invalid total operations count number specified\n"); 297 return -1; 298 } 299 300 return ret; 301 } 302 303 static int 304 parse_pool_sz(struct cperf_options *opts, const char *arg) 305 { 306 int ret = parse_uint32_t(&opts->pool_sz, arg); 307 308 if (ret) 309 RTE_LOG(ERR, USER1, "failed to parse pool size"); 310 return ret; 311 } 312 313 static int 314 parse_burst_sz(struct cperf_options *opts, const char *arg) 315 { 316 int ret; 317 318 /* Try parsing the argument as a range, if it fails, parse it as a list */ 319 if (parse_range(arg, &opts->min_burst_size, &opts->max_burst_size, 320 &opts->inc_burst_size) < 0) { 321 ret = parse_list(arg, opts->burst_size_list, 322 &opts->min_burst_size, 323 &opts->max_burst_size); 324 if (ret < 0) { 325 RTE_LOG(ERR, USER1, "failed to parse burst size/s\n"); 326 return -1; 327 } 328 opts->burst_size_count = ret; 329 } 330 331 return 0; 332 } 333 334 static int 335 parse_buffer_sz(struct cperf_options *opts, const char *arg) 336 { 337 int ret; 338 339 /* Try parsing the argument as a range, if it fails, parse it as a list */ 340 if (parse_range(arg, &opts->min_buffer_size, &opts->max_buffer_size, 341 &opts->inc_buffer_size) < 0) { 342 ret = parse_list(arg, opts->buffer_size_list, 343 &opts->min_buffer_size, 344 &opts->max_buffer_size); 345 if (ret < 0) { 346 RTE_LOG(ERR, USER1, "failed to parse buffer size/s\n"); 347 return -1; 348 } 349 opts->buffer_size_count = ret; 350 } 351 352 return 0; 353 } 354 355 static int 356 parse_segment_sz(struct cperf_options *opts, const char *arg) 357 { 358 int ret = parse_uint32_t(&opts->segment_sz, arg); 359 360 if (ret) { 361 RTE_LOG(ERR, USER1, "failed to parse segment size\n"); 362 return -1; 363 } 364 365 if (opts->segment_sz == 0) { 366 RTE_LOG(ERR, USER1, "Segment size has to be bigger than 0\n"); 367 return -1; 368 } 369 370 return 0; 371 } 372 373 static int 374 parse_imix(struct cperf_options *opts, const char *arg) 375 { 376 int ret; 377 378 ret = parse_list(arg, opts->imix_distribution_list, 379 NULL, NULL); 380 if (ret < 0) { 381 RTE_LOG(ERR, USER1, "failed to parse imix distribution\n"); 382 return -1; 383 } 384 385 opts->imix_distribution_count = ret; 386 387 if (opts->imix_distribution_count <= 1) { 388 RTE_LOG(ERR, USER1, "imix distribution should have " 389 "at least two entries\n"); 390 return -1; 391 } 392 393 return 0; 394 } 395 396 static int 397 parse_desc_nb(struct cperf_options *opts, const char *arg) 398 { 399 int ret = parse_uint32_t(&opts->nb_descriptors, arg); 400 401 if (ret) { 402 RTE_LOG(ERR, USER1, "failed to parse descriptors number\n"); 403 return -1; 404 } 405 406 if (opts->nb_descriptors == 0) { 407 RTE_LOG(ERR, USER1, "invalid descriptors number specified\n"); 408 return -1; 409 } 410 411 return 0; 412 } 413 414 static int 415 parse_device_type(struct cperf_options *opts, const char *arg) 416 { 417 if (strlen(arg) > (sizeof(opts->device_type) - 1)) 418 return -1; 419 420 strncpy(opts->device_type, arg, sizeof(opts->device_type) - 1); 421 *(opts->device_type + sizeof(opts->device_type) - 1) = '\0'; 422 423 return 0; 424 } 425 426 static int 427 parse_op_type(struct cperf_options *opts, const char *arg) 428 { 429 struct name_id_map optype_namemap[] = { 430 { 431 cperf_op_type_strs[CPERF_CIPHER_ONLY], 432 CPERF_CIPHER_ONLY 433 }, 434 { 435 cperf_op_type_strs[CPERF_AUTH_ONLY], 436 CPERF_AUTH_ONLY 437 }, 438 { 439 cperf_op_type_strs[CPERF_CIPHER_THEN_AUTH], 440 CPERF_CIPHER_THEN_AUTH 441 }, 442 { 443 cperf_op_type_strs[CPERF_AUTH_THEN_CIPHER], 444 CPERF_AUTH_THEN_CIPHER 445 }, 446 { 447 cperf_op_type_strs[CPERF_AEAD], 448 CPERF_AEAD 449 }, 450 { 451 cperf_op_type_strs[CPERF_PDCP], 452 CPERF_PDCP 453 }, 454 { 455 cperf_op_type_strs[CPERF_DOCSIS], 456 CPERF_DOCSIS 457 } 458 }; 459 460 int id = get_str_key_id_mapping(optype_namemap, 461 RTE_DIM(optype_namemap), arg); 462 if (id < 0) { 463 RTE_LOG(ERR, USER1, "invalid opt type specified\n"); 464 return -1; 465 } 466 467 opts->op_type = (enum cperf_op_type)id; 468 469 return 0; 470 } 471 472 static int 473 parse_sessionless(struct cperf_options *opts, 474 const char *arg __rte_unused) 475 { 476 opts->sessionless = 1; 477 return 0; 478 } 479 480 static int 481 parse_out_of_place(struct cperf_options *opts, 482 const char *arg __rte_unused) 483 { 484 opts->out_of_place = 1; 485 return 0; 486 } 487 488 static int 489 parse_test_file(struct cperf_options *opts, 490 const char *arg) 491 { 492 opts->test_file = strdup(arg); 493 if (access(opts->test_file, F_OK) != -1) 494 return 0; 495 RTE_LOG(ERR, USER1, "Test vector file doesn't exist\n"); 496 497 return -1; 498 } 499 500 static int 501 parse_test_name(struct cperf_options *opts, 502 const char *arg) 503 { 504 char *test_name = (char *) rte_zmalloc(NULL, 505 sizeof(char) * (strlen(arg) + 3), 0); 506 snprintf(test_name, strlen(arg) + 3, "[%s]", arg); 507 opts->test_name = test_name; 508 509 return 0; 510 } 511 512 static int 513 parse_silent(struct cperf_options *opts, 514 const char *arg __rte_unused) 515 { 516 opts->silent = 1; 517 518 return 0; 519 } 520 521 static int 522 parse_cipher_algo(struct cperf_options *opts, const char *arg) 523 { 524 525 enum rte_crypto_cipher_algorithm cipher_algo; 526 527 if (rte_cryptodev_get_cipher_algo_enum(&cipher_algo, arg) < 0) { 528 RTE_LOG(ERR, USER1, "Invalid cipher algorithm specified\n"); 529 return -1; 530 } 531 532 opts->cipher_algo = cipher_algo; 533 534 return 0; 535 } 536 537 static int 538 parse_cipher_op(struct cperf_options *opts, const char *arg) 539 { 540 struct name_id_map cipher_op_namemap[] = { 541 { 542 rte_crypto_cipher_operation_strings 543 [RTE_CRYPTO_CIPHER_OP_ENCRYPT], 544 RTE_CRYPTO_CIPHER_OP_ENCRYPT }, 545 { 546 rte_crypto_cipher_operation_strings 547 [RTE_CRYPTO_CIPHER_OP_DECRYPT], 548 RTE_CRYPTO_CIPHER_OP_DECRYPT 549 } 550 }; 551 552 int id = get_str_key_id_mapping(cipher_op_namemap, 553 RTE_DIM(cipher_op_namemap), arg); 554 if (id < 0) { 555 RTE_LOG(ERR, USER1, "Invalid cipher operation specified\n"); 556 return -1; 557 } 558 559 opts->cipher_op = (enum rte_crypto_cipher_operation)id; 560 561 return 0; 562 } 563 564 static int 565 parse_cipher_key_sz(struct cperf_options *opts, const char *arg) 566 { 567 return parse_uint16_t(&opts->cipher_key_sz, arg); 568 } 569 570 static int 571 parse_cipher_iv_sz(struct cperf_options *opts, const char *arg) 572 { 573 return parse_uint16_t(&opts->cipher_iv_sz, arg); 574 } 575 576 static int 577 parse_auth_algo(struct cperf_options *opts, const char *arg) 578 { 579 enum rte_crypto_auth_algorithm auth_algo; 580 581 if (rte_cryptodev_get_auth_algo_enum(&auth_algo, arg) < 0) { 582 RTE_LOG(ERR, USER1, "Invalid authentication algorithm specified\n"); 583 return -1; 584 } 585 586 opts->auth_algo = auth_algo; 587 588 return 0; 589 } 590 591 static int 592 parse_auth_op(struct cperf_options *opts, const char *arg) 593 { 594 struct name_id_map auth_op_namemap[] = { 595 { 596 rte_crypto_auth_operation_strings 597 [RTE_CRYPTO_AUTH_OP_GENERATE], 598 RTE_CRYPTO_AUTH_OP_GENERATE }, 599 { 600 rte_crypto_auth_operation_strings 601 [RTE_CRYPTO_AUTH_OP_VERIFY], 602 RTE_CRYPTO_AUTH_OP_VERIFY 603 } 604 }; 605 606 int id = get_str_key_id_mapping(auth_op_namemap, 607 RTE_DIM(auth_op_namemap), arg); 608 if (id < 0) { 609 RTE_LOG(ERR, USER1, "invalid authentication operation specified" 610 "\n"); 611 return -1; 612 } 613 614 opts->auth_op = (enum rte_crypto_auth_operation)id; 615 616 return 0; 617 } 618 619 static int 620 parse_auth_key_sz(struct cperf_options *opts, const char *arg) 621 { 622 return parse_uint16_t(&opts->auth_key_sz, arg); 623 } 624 625 static int 626 parse_digest_sz(struct cperf_options *opts, const char *arg) 627 { 628 return parse_uint16_t(&opts->digest_sz, arg); 629 } 630 631 #ifdef RTE_LIBRTE_SECURITY 632 static int 633 parse_pdcp_sn_sz(struct cperf_options *opts, const char *arg) 634 { 635 uint32_t val = 0; 636 int ret = parse_uint32_t(&val, arg); 637 638 if (ret < 0) 639 return ret; 640 641 if (val != RTE_SECURITY_PDCP_SN_SIZE_5 && 642 val != RTE_SECURITY_PDCP_SN_SIZE_7 && 643 val != RTE_SECURITY_PDCP_SN_SIZE_12 && 644 val != RTE_SECURITY_PDCP_SN_SIZE_15 && 645 val != RTE_SECURITY_PDCP_SN_SIZE_18) { 646 printf("\nInvalid pdcp SN size: %u\n", val); 647 return -ERANGE; 648 } 649 opts->pdcp_sn_sz = val; 650 651 return 0; 652 } 653 654 const char *cperf_pdcp_domain_strs[] = { 655 [RTE_SECURITY_PDCP_MODE_CONTROL] = "control", 656 [RTE_SECURITY_PDCP_MODE_DATA] = "data" 657 }; 658 659 static int 660 parse_pdcp_domain(struct cperf_options *opts, const char *arg) 661 { 662 struct name_id_map pdcp_domain_namemap[] = { 663 { 664 cperf_pdcp_domain_strs 665 [RTE_SECURITY_PDCP_MODE_CONTROL], 666 RTE_SECURITY_PDCP_MODE_CONTROL }, 667 { 668 cperf_pdcp_domain_strs 669 [RTE_SECURITY_PDCP_MODE_DATA], 670 RTE_SECURITY_PDCP_MODE_DATA 671 } 672 }; 673 674 int id = get_str_key_id_mapping(pdcp_domain_namemap, 675 RTE_DIM(pdcp_domain_namemap), arg); 676 if (id < 0) { 677 RTE_LOG(ERR, USER1, "invalid pdcp domain specified" 678 "\n"); 679 return -1; 680 } 681 682 opts->pdcp_domain = (enum rte_security_pdcp_domain)id; 683 684 return 0; 685 } 686 687 static int 688 parse_docsis_hdr_sz(struct cperf_options *opts, const char *arg) 689 { 690 return parse_uint16_t(&opts->docsis_hdr_sz, arg); 691 } 692 #endif 693 694 static int 695 parse_auth_iv_sz(struct cperf_options *opts, const char *arg) 696 { 697 return parse_uint16_t(&opts->auth_iv_sz, arg); 698 } 699 700 static int 701 parse_aead_algo(struct cperf_options *opts, const char *arg) 702 { 703 enum rte_crypto_aead_algorithm aead_algo; 704 705 if (rte_cryptodev_get_aead_algo_enum(&aead_algo, arg) < 0) { 706 RTE_LOG(ERR, USER1, "Invalid AEAD algorithm specified\n"); 707 return -1; 708 } 709 710 opts->aead_algo = aead_algo; 711 712 return 0; 713 } 714 715 static int 716 parse_aead_op(struct cperf_options *opts, const char *arg) 717 { 718 struct name_id_map aead_op_namemap[] = { 719 { 720 rte_crypto_aead_operation_strings 721 [RTE_CRYPTO_AEAD_OP_ENCRYPT], 722 RTE_CRYPTO_AEAD_OP_ENCRYPT }, 723 { 724 rte_crypto_aead_operation_strings 725 [RTE_CRYPTO_AEAD_OP_DECRYPT], 726 RTE_CRYPTO_AEAD_OP_DECRYPT 727 } 728 }; 729 730 int id = get_str_key_id_mapping(aead_op_namemap, 731 RTE_DIM(aead_op_namemap), arg); 732 if (id < 0) { 733 RTE_LOG(ERR, USER1, "invalid AEAD operation specified" 734 "\n"); 735 return -1; 736 } 737 738 opts->aead_op = (enum rte_crypto_aead_operation)id; 739 740 return 0; 741 } 742 743 static int 744 parse_aead_key_sz(struct cperf_options *opts, const char *arg) 745 { 746 return parse_uint16_t(&opts->aead_key_sz, arg); 747 } 748 749 static int 750 parse_aead_iv_sz(struct cperf_options *opts, const char *arg) 751 { 752 return parse_uint16_t(&opts->aead_iv_sz, arg); 753 } 754 755 static int 756 parse_aead_aad_sz(struct cperf_options *opts, const char *arg) 757 { 758 return parse_uint16_t(&opts->aead_aad_sz, arg); 759 } 760 761 static int 762 parse_csv_friendly(struct cperf_options *opts, const char *arg __rte_unused) 763 { 764 opts->csv = 1; 765 opts->silent = 1; 766 return 0; 767 } 768 769 static int 770 parse_pmd_cyclecount_delay_ms(struct cperf_options *opts, 771 const char *arg) 772 { 773 int ret = parse_uint32_t(&opts->pmdcc_delay, arg); 774 775 if (ret) { 776 RTE_LOG(ERR, USER1, "failed to parse pmd-cyclecount delay\n"); 777 return -1; 778 } 779 780 return 0; 781 } 782 783 typedef int (*option_parser_t)(struct cperf_options *opts, 784 const char *arg); 785 786 struct long_opt_parser { 787 const char *lgopt_name; 788 option_parser_t parser_fn; 789 790 }; 791 792 static struct option lgopts[] = { 793 794 { CPERF_PTEST_TYPE, required_argument, 0, 0 }, 795 796 { CPERF_POOL_SIZE, required_argument, 0, 0 }, 797 { CPERF_TOTAL_OPS, required_argument, 0, 0 }, 798 { CPERF_BURST_SIZE, required_argument, 0, 0 }, 799 { CPERF_BUFFER_SIZE, required_argument, 0, 0 }, 800 { CPERF_SEGMENT_SIZE, required_argument, 0, 0 }, 801 { CPERF_DESC_NB, required_argument, 0, 0 }, 802 803 { CPERF_IMIX, required_argument, 0, 0 }, 804 { CPERF_DEVTYPE, required_argument, 0, 0 }, 805 { CPERF_OPTYPE, required_argument, 0, 0 }, 806 807 { CPERF_SILENT, no_argument, 0, 0 }, 808 { CPERF_SESSIONLESS, no_argument, 0, 0 }, 809 { CPERF_OUT_OF_PLACE, no_argument, 0, 0 }, 810 { CPERF_TEST_FILE, required_argument, 0, 0 }, 811 { CPERF_TEST_NAME, required_argument, 0, 0 }, 812 813 { CPERF_CIPHER_ALGO, required_argument, 0, 0 }, 814 { CPERF_CIPHER_OP, required_argument, 0, 0 }, 815 816 { CPERF_CIPHER_KEY_SZ, required_argument, 0, 0 }, 817 { CPERF_CIPHER_IV_SZ, required_argument, 0, 0 }, 818 819 { CPERF_AUTH_ALGO, required_argument, 0, 0 }, 820 { CPERF_AUTH_OP, required_argument, 0, 0 }, 821 822 { CPERF_AUTH_KEY_SZ, required_argument, 0, 0 }, 823 { CPERF_AUTH_IV_SZ, required_argument, 0, 0 }, 824 825 { CPERF_AEAD_ALGO, required_argument, 0, 0 }, 826 { CPERF_AEAD_OP, required_argument, 0, 0 }, 827 828 { CPERF_AEAD_KEY_SZ, required_argument, 0, 0 }, 829 { CPERF_AEAD_AAD_SZ, required_argument, 0, 0 }, 830 { CPERF_AEAD_IV_SZ, required_argument, 0, 0 }, 831 832 { CPERF_DIGEST_SZ, required_argument, 0, 0 }, 833 834 #ifdef RTE_LIBRTE_SECURITY 835 { CPERF_PDCP_SN_SZ, required_argument, 0, 0 }, 836 { CPERF_PDCP_DOMAIN, required_argument, 0, 0 }, 837 { CPERF_DOCSIS_HDR_SZ, required_argument, 0, 0 }, 838 #endif 839 { CPERF_CSV, no_argument, 0, 0}, 840 841 { CPERF_PMDCC_DELAY_MS, required_argument, 0, 0 }, 842 843 { NULL, 0, 0, 0 } 844 }; 845 846 void 847 cperf_options_default(struct cperf_options *opts) 848 { 849 opts->test = CPERF_TEST_TYPE_THROUGHPUT; 850 851 opts->pool_sz = 8192; 852 opts->total_ops = 10000000; 853 opts->nb_descriptors = 2048; 854 855 opts->buffer_size_list[0] = 64; 856 opts->buffer_size_count = 1; 857 opts->max_buffer_size = 64; 858 opts->min_buffer_size = 64; 859 opts->inc_buffer_size = 0; 860 861 opts->burst_size_list[0] = 32; 862 opts->burst_size_count = 1; 863 opts->max_burst_size = 32; 864 opts->min_burst_size = 32; 865 opts->inc_burst_size = 0; 866 867 /* 868 * Will be parsed from command line or set to 869 * maximum buffer size + digest, later 870 */ 871 opts->segment_sz = 0; 872 873 opts->imix_distribution_count = 0; 874 strncpy(opts->device_type, "crypto_aesni_mb", 875 sizeof(opts->device_type)); 876 opts->nb_qps = 1; 877 878 opts->op_type = CPERF_CIPHER_THEN_AUTH; 879 880 opts->silent = 0; 881 opts->test_file = NULL; 882 opts->test_name = NULL; 883 opts->sessionless = 0; 884 opts->out_of_place = 0; 885 opts->csv = 0; 886 887 opts->cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC; 888 opts->cipher_op = RTE_CRYPTO_CIPHER_OP_ENCRYPT; 889 opts->cipher_key_sz = 16; 890 opts->cipher_iv_sz = 16; 891 892 opts->auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC; 893 opts->auth_op = RTE_CRYPTO_AUTH_OP_GENERATE; 894 895 opts->auth_key_sz = 64; 896 opts->auth_iv_sz = 0; 897 898 opts->aead_key_sz = 0; 899 opts->aead_iv_sz = 0; 900 opts->aead_aad_sz = 0; 901 902 opts->digest_sz = 12; 903 904 opts->pmdcc_delay = 0; 905 #ifdef RTE_LIBRTE_SECURITY 906 opts->pdcp_sn_sz = 12; 907 opts->pdcp_domain = RTE_SECURITY_PDCP_MODE_CONTROL; 908 opts->docsis_hdr_sz = 17; 909 #endif 910 } 911 912 static int 913 cperf_opts_parse_long(int opt_idx, struct cperf_options *opts) 914 { 915 struct long_opt_parser parsermap[] = { 916 { CPERF_PTEST_TYPE, parse_cperf_test_type }, 917 { CPERF_SILENT, parse_silent }, 918 { CPERF_POOL_SIZE, parse_pool_sz }, 919 { CPERF_TOTAL_OPS, parse_total_ops }, 920 { CPERF_BURST_SIZE, parse_burst_sz }, 921 { CPERF_BUFFER_SIZE, parse_buffer_sz }, 922 { CPERF_SEGMENT_SIZE, parse_segment_sz }, 923 { CPERF_DESC_NB, parse_desc_nb }, 924 { CPERF_DEVTYPE, parse_device_type }, 925 { CPERF_OPTYPE, parse_op_type }, 926 { CPERF_SESSIONLESS, parse_sessionless }, 927 { CPERF_OUT_OF_PLACE, parse_out_of_place }, 928 { CPERF_IMIX, parse_imix }, 929 { CPERF_TEST_FILE, parse_test_file }, 930 { CPERF_TEST_NAME, parse_test_name }, 931 { CPERF_CIPHER_ALGO, parse_cipher_algo }, 932 { CPERF_CIPHER_OP, parse_cipher_op }, 933 { CPERF_CIPHER_KEY_SZ, parse_cipher_key_sz }, 934 { CPERF_CIPHER_IV_SZ, parse_cipher_iv_sz }, 935 { CPERF_AUTH_ALGO, parse_auth_algo }, 936 { CPERF_AUTH_OP, parse_auth_op }, 937 { CPERF_AUTH_KEY_SZ, parse_auth_key_sz }, 938 { CPERF_AUTH_IV_SZ, parse_auth_iv_sz }, 939 { CPERF_AEAD_ALGO, parse_aead_algo }, 940 { CPERF_AEAD_OP, parse_aead_op }, 941 { CPERF_AEAD_KEY_SZ, parse_aead_key_sz }, 942 { CPERF_AEAD_IV_SZ, parse_aead_iv_sz }, 943 { CPERF_AEAD_AAD_SZ, parse_aead_aad_sz }, 944 { CPERF_DIGEST_SZ, parse_digest_sz }, 945 #ifdef RTE_LIBRTE_SECURITY 946 { CPERF_PDCP_SN_SZ, parse_pdcp_sn_sz }, 947 { CPERF_PDCP_DOMAIN, parse_pdcp_domain }, 948 { CPERF_DOCSIS_HDR_SZ, parse_docsis_hdr_sz }, 949 #endif 950 { CPERF_CSV, parse_csv_friendly}, 951 { CPERF_PMDCC_DELAY_MS, parse_pmd_cyclecount_delay_ms}, 952 }; 953 unsigned int i; 954 955 for (i = 0; i < RTE_DIM(parsermap); i++) { 956 if (strncmp(lgopts[opt_idx].name, parsermap[i].lgopt_name, 957 strlen(lgopts[opt_idx].name)) == 0) 958 return parsermap[i].parser_fn(opts, optarg); 959 } 960 961 return -EINVAL; 962 } 963 964 int 965 cperf_options_parse(struct cperf_options *options, int argc, char **argv) 966 { 967 int opt, retval, opt_idx; 968 969 while ((opt = getopt_long(argc, argv, "h", lgopts, &opt_idx)) != EOF) { 970 switch (opt) { 971 case 'h': 972 usage(argv[0]); 973 rte_exit(EXIT_SUCCESS, "Displayed help\n"); 974 break; 975 /* long options */ 976 case 0: 977 retval = cperf_opts_parse_long(opt_idx, options); 978 if (retval != 0) 979 return retval; 980 981 break; 982 983 default: 984 usage(argv[0]); 985 return -EINVAL; 986 } 987 } 988 989 return 0; 990 } 991 992 static int 993 check_cipher_buffer_length(struct cperf_options *options) 994 { 995 uint32_t buffer_size, buffer_size_idx = 0; 996 997 if (options->cipher_algo == RTE_CRYPTO_CIPHER_AES_CBC || 998 options->cipher_algo == RTE_CRYPTO_CIPHER_AES_ECB) { 999 if (options->inc_buffer_size != 0) 1000 buffer_size = options->min_buffer_size; 1001 else 1002 buffer_size = options->buffer_size_list[0]; 1003 1004 while (buffer_size <= options->max_buffer_size) { 1005 if ((buffer_size % AES_BLOCK_SIZE) != 0) { 1006 RTE_LOG(ERR, USER1, "Some of the buffer sizes are " 1007 "not suitable for the algorithm selected\n"); 1008 return -EINVAL; 1009 } 1010 1011 if (options->inc_buffer_size != 0) 1012 buffer_size += options->inc_buffer_size; 1013 else { 1014 if (++buffer_size_idx == options->buffer_size_count) 1015 break; 1016 buffer_size = options->buffer_size_list[buffer_size_idx]; 1017 } 1018 1019 } 1020 } 1021 1022 if (options->cipher_algo == RTE_CRYPTO_CIPHER_DES_CBC || 1023 options->cipher_algo == RTE_CRYPTO_CIPHER_3DES_CBC || 1024 options->cipher_algo == RTE_CRYPTO_CIPHER_3DES_ECB) { 1025 if (options->inc_buffer_size != 0) 1026 buffer_size = options->min_buffer_size; 1027 else 1028 buffer_size = options->buffer_size_list[0]; 1029 1030 while (buffer_size <= options->max_buffer_size) { 1031 if ((buffer_size % DES_BLOCK_SIZE) != 0) { 1032 RTE_LOG(ERR, USER1, "Some of the buffer sizes are " 1033 "not suitable for the algorithm selected\n"); 1034 return -EINVAL; 1035 } 1036 1037 if (options->inc_buffer_size != 0) 1038 buffer_size += options->inc_buffer_size; 1039 else { 1040 if (++buffer_size_idx == options->buffer_size_count) 1041 break; 1042 buffer_size = options->buffer_size_list[buffer_size_idx]; 1043 } 1044 1045 } 1046 } 1047 1048 return 0; 1049 } 1050 1051 #ifdef RTE_LIBRTE_SECURITY 1052 static int 1053 check_docsis_buffer_length(struct cperf_options *options) 1054 { 1055 uint32_t buffer_size, buffer_size_idx = 0; 1056 1057 if (options->inc_buffer_size != 0) 1058 buffer_size = options->min_buffer_size; 1059 else 1060 buffer_size = options->buffer_size_list[0]; 1061 1062 while (buffer_size <= options->max_buffer_size) { 1063 if (buffer_size < (uint32_t)(options->docsis_hdr_sz + 1064 RTE_ETHER_HDR_LEN + RTE_ETHER_CRC_LEN)) { 1065 RTE_LOG(ERR, USER1, "Some of the buffer sizes are not " 1066 "valid for DOCSIS\n"); 1067 return -EINVAL; 1068 } 1069 1070 if (options->inc_buffer_size != 0) 1071 buffer_size += options->inc_buffer_size; 1072 else { 1073 if (++buffer_size_idx == options->buffer_size_count) 1074 break; 1075 buffer_size = 1076 options->buffer_size_list[buffer_size_idx]; 1077 } 1078 } 1079 1080 return 0; 1081 } 1082 #endif 1083 1084 int 1085 cperf_options_check(struct cperf_options *options) 1086 { 1087 if (options->op_type == CPERF_CIPHER_ONLY || 1088 options->op_type == CPERF_DOCSIS) 1089 options->digest_sz = 0; 1090 1091 if (options->out_of_place && 1092 options->segment_sz <= options->max_buffer_size) { 1093 RTE_LOG(ERR, USER1, "Out of place mode can only work " 1094 "with non segmented buffers\n"); 1095 return -EINVAL; 1096 } 1097 1098 /* 1099 * If segment size is not set, assume only one segment, 1100 * big enough to contain the largest buffer and the digest 1101 */ 1102 if (options->segment_sz == 0) 1103 options->segment_sz = options->max_buffer_size + 1104 options->digest_sz; 1105 1106 if (options->segment_sz < options->digest_sz) { 1107 RTE_LOG(ERR, USER1, 1108 "Segment size should be at least " 1109 "the size of the digest\n"); 1110 return -EINVAL; 1111 } 1112 1113 if ((options->imix_distribution_count != 0) && 1114 (options->imix_distribution_count != 1115 options->buffer_size_count)) { 1116 RTE_LOG(ERR, USER1, "IMIX distribution must have the same " 1117 "number of buffer sizes\n"); 1118 return -EINVAL; 1119 } 1120 1121 if (options->test == CPERF_TEST_TYPE_VERIFY && 1122 options->test_file == NULL) { 1123 RTE_LOG(ERR, USER1, "Define path to the file with test" 1124 " vectors.\n"); 1125 return -EINVAL; 1126 } 1127 1128 if (options->test == CPERF_TEST_TYPE_VERIFY && 1129 options->op_type != CPERF_CIPHER_ONLY && 1130 options->test_name == NULL) { 1131 RTE_LOG(ERR, USER1, "Define test name to get the correct digest" 1132 " from the test vectors.\n"); 1133 return -EINVAL; 1134 } 1135 1136 if (options->test_name != NULL && options->test_file == NULL) { 1137 RTE_LOG(ERR, USER1, "Define path to the file with test" 1138 " vectors.\n"); 1139 return -EINVAL; 1140 } 1141 1142 if (options->auth_op == RTE_CRYPTO_AUTH_OP_VERIFY && 1143 options->test_file == NULL) { 1144 RTE_LOG(ERR, USER1, "Define path to the file with test" 1145 " vectors.\n"); 1146 return -EINVAL; 1147 } 1148 1149 if (options->test == CPERF_TEST_TYPE_VERIFY && 1150 (options->inc_buffer_size != 0 || 1151 options->buffer_size_count > 1)) { 1152 RTE_LOG(ERR, USER1, "Only one buffer size is allowed when " 1153 "using the verify test.\n"); 1154 return -EINVAL; 1155 } 1156 1157 if (options->test == CPERF_TEST_TYPE_VERIFY && 1158 (options->inc_burst_size != 0 || 1159 options->burst_size_count > 1)) { 1160 RTE_LOG(ERR, USER1, "Only one burst size is allowed when " 1161 "using the verify test.\n"); 1162 return -EINVAL; 1163 } 1164 1165 if (options->test == CPERF_TEST_TYPE_PMDCC && 1166 options->pool_sz < options->nb_descriptors) { 1167 RTE_LOG(ERR, USER1, "For pmd cyclecount benchmarks, pool size " 1168 "must be equal or greater than the number of " 1169 "cryptodev descriptors.\n"); 1170 return -EINVAL; 1171 } 1172 1173 if (options->test == CPERF_TEST_TYPE_VERIFY && 1174 options->imix_distribution_count > 0) { 1175 RTE_LOG(ERR, USER1, "IMIX is not allowed when " 1176 "using the verify test.\n"); 1177 return -EINVAL; 1178 } 1179 1180 if (options->op_type == CPERF_CIPHER_THEN_AUTH) { 1181 if (options->cipher_op != RTE_CRYPTO_CIPHER_OP_ENCRYPT && 1182 options->auth_op != 1183 RTE_CRYPTO_AUTH_OP_GENERATE) { 1184 RTE_LOG(ERR, USER1, "Option cipher then auth must use" 1185 " options: encrypt and generate.\n"); 1186 return -EINVAL; 1187 } 1188 } else if (options->op_type == CPERF_AUTH_THEN_CIPHER) { 1189 if (options->cipher_op != RTE_CRYPTO_CIPHER_OP_DECRYPT && 1190 options->auth_op != 1191 RTE_CRYPTO_AUTH_OP_VERIFY) { 1192 RTE_LOG(ERR, USER1, "Option auth then cipher must use" 1193 " options: decrypt and verify.\n"); 1194 return -EINVAL; 1195 } 1196 } 1197 1198 if (options->op_type == CPERF_CIPHER_ONLY || 1199 options->op_type == CPERF_CIPHER_THEN_AUTH || 1200 options->op_type == CPERF_AUTH_THEN_CIPHER) { 1201 if (check_cipher_buffer_length(options) < 0) 1202 return -EINVAL; 1203 } 1204 1205 #ifdef RTE_LIBRTE_SECURITY 1206 if (options->op_type == CPERF_DOCSIS) { 1207 if (check_docsis_buffer_length(options) < 0) 1208 return -EINVAL; 1209 } 1210 #endif 1211 1212 return 0; 1213 } 1214 1215 void 1216 cperf_options_dump(struct cperf_options *opts) 1217 { 1218 uint8_t size_idx; 1219 1220 printf("# Crypto Performance Application Options:\n"); 1221 printf("#\n"); 1222 printf("# cperf test: %s\n", cperf_test_type_strs[opts->test]); 1223 printf("#\n"); 1224 printf("# size of crypto op / mbuf pool: %u\n", opts->pool_sz); 1225 printf("# total number of ops: %u\n", opts->total_ops); 1226 if (opts->inc_buffer_size != 0) { 1227 printf("# buffer size:\n"); 1228 printf("#\t min: %u\n", opts->min_buffer_size); 1229 printf("#\t max: %u\n", opts->max_buffer_size); 1230 printf("#\t inc: %u\n", opts->inc_buffer_size); 1231 } else { 1232 printf("# buffer sizes: "); 1233 for (size_idx = 0; size_idx < opts->buffer_size_count; size_idx++) 1234 printf("%u ", opts->buffer_size_list[size_idx]); 1235 printf("\n"); 1236 } 1237 if (opts->inc_burst_size != 0) { 1238 printf("# burst size:\n"); 1239 printf("#\t min: %u\n", opts->min_burst_size); 1240 printf("#\t max: %u\n", opts->max_burst_size); 1241 printf("#\t inc: %u\n", opts->inc_burst_size); 1242 } else { 1243 printf("# burst sizes: "); 1244 for (size_idx = 0; size_idx < opts->burst_size_count; size_idx++) 1245 printf("%u ", opts->burst_size_list[size_idx]); 1246 printf("\n"); 1247 } 1248 printf("\n# segment size: %u\n", opts->segment_sz); 1249 printf("#\n"); 1250 printf("# cryptodev type: %s\n", opts->device_type); 1251 printf("#\n"); 1252 printf("# number of queue pairs per device: %u\n", opts->nb_qps); 1253 printf("# crypto operation: %s\n", cperf_op_type_strs[opts->op_type]); 1254 printf("# sessionless: %s\n", opts->sessionless ? "yes" : "no"); 1255 printf("# out of place: %s\n", opts->out_of_place ? "yes" : "no"); 1256 if (opts->test == CPERF_TEST_TYPE_PMDCC) 1257 printf("# inter-burst delay: %u ms\n", opts->pmdcc_delay); 1258 1259 printf("#\n"); 1260 1261 if (opts->op_type == CPERF_AUTH_ONLY || 1262 opts->op_type == CPERF_CIPHER_THEN_AUTH || 1263 opts->op_type == CPERF_AUTH_THEN_CIPHER) { 1264 printf("# auth algorithm: %s\n", 1265 rte_crypto_auth_algorithm_strings[opts->auth_algo]); 1266 printf("# auth operation: %s\n", 1267 rte_crypto_auth_operation_strings[opts->auth_op]); 1268 printf("# auth key size: %u\n", opts->auth_key_sz); 1269 printf("# auth iv size: %u\n", opts->auth_iv_sz); 1270 printf("# auth digest size: %u\n", opts->digest_sz); 1271 printf("#\n"); 1272 } 1273 1274 if (opts->op_type == CPERF_CIPHER_ONLY || 1275 opts->op_type == CPERF_CIPHER_THEN_AUTH || 1276 opts->op_type == CPERF_AUTH_THEN_CIPHER) { 1277 printf("# cipher algorithm: %s\n", 1278 rte_crypto_cipher_algorithm_strings[opts->cipher_algo]); 1279 printf("# cipher operation: %s\n", 1280 rte_crypto_cipher_operation_strings[opts->cipher_op]); 1281 printf("# cipher key size: %u\n", opts->cipher_key_sz); 1282 printf("# cipher iv size: %u\n", opts->cipher_iv_sz); 1283 printf("#\n"); 1284 } 1285 1286 if (opts->op_type == CPERF_AEAD) { 1287 printf("# aead algorithm: %s\n", 1288 rte_crypto_aead_algorithm_strings[opts->aead_algo]); 1289 printf("# aead operation: %s\n", 1290 rte_crypto_aead_operation_strings[opts->aead_op]); 1291 printf("# aead key size: %u\n", opts->aead_key_sz); 1292 printf("# aead iv size: %u\n", opts->aead_iv_sz); 1293 printf("# aead digest size: %u\n", opts->digest_sz); 1294 printf("# aead aad size: %u\n", opts->aead_aad_sz); 1295 printf("#\n"); 1296 } 1297 1298 #ifdef RTE_LIBRTE_SECURITY 1299 if (opts->op_type == CPERF_DOCSIS) { 1300 printf("# docsis header size: %u\n", opts->docsis_hdr_sz); 1301 printf("#\n"); 1302 } 1303 #endif 1304 } 1305