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