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