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