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_malloc.h> 37 38 #include "cperf_options.h" 39 40 struct name_id_map { 41 const char *name; 42 uint32_t id; 43 }; 44 45 static int 46 get_str_key_id_mapping(struct name_id_map *map, unsigned int map_len, 47 const char *str_key) 48 { 49 unsigned int i; 50 51 for (i = 0; i < map_len; i++) { 52 53 if (strcmp(str_key, map[i].name) == 0) 54 return map[i].id; 55 } 56 57 return -1; 58 } 59 60 static int 61 parse_cperf_test_type(struct cperf_options *opts, const char *arg) 62 { 63 struct name_id_map cperftest_namemap[] = { 64 { 65 cperf_test_type_strs[CPERF_TEST_TYPE_THROUGHPUT], 66 CPERF_TEST_TYPE_THROUGHPUT 67 }, 68 { 69 cperf_test_type_strs[CPERF_TEST_TYPE_CYCLECOUNT], 70 CPERF_TEST_TYPE_CYCLECOUNT 71 }, 72 { 73 cperf_test_type_strs[CPERF_TEST_TYPE_LATENCY], 74 CPERF_TEST_TYPE_LATENCY 75 } 76 }; 77 78 int id = get_str_key_id_mapping( 79 (struct name_id_map *)cperftest_namemap, 80 RTE_DIM(cperftest_namemap), arg); 81 if (id < 0) { 82 RTE_LOG(ERR, USER1, "failed to parse test type"); 83 return -1; 84 } 85 86 opts->test = (enum cperf_perf_test_type)id; 87 88 return 0; 89 } 90 91 static int 92 parse_uint32_t(uint32_t *value, const char *arg) 93 { 94 char *end = NULL; 95 unsigned long n = strtoul(arg, &end, 10); 96 97 if ((optarg[0] == '\0') || (end == NULL) || (*end != '\0')) 98 return -1; 99 100 if (n > UINT32_MAX) 101 return -ERANGE; 102 103 *value = (uint32_t) n; 104 105 return 0; 106 } 107 108 static int 109 parse_uint16_t(uint16_t *value, const char *arg) 110 { 111 uint32_t val = 0; 112 int ret = parse_uint32_t(&val, arg); 113 114 if (ret < 0) 115 return ret; 116 117 if (val > UINT16_MAX) 118 return -ERANGE; 119 120 *value = (uint16_t) val; 121 122 return 0; 123 } 124 125 static int 126 parse_total_ops(struct cperf_options *opts, const char *arg) 127 { 128 int ret = parse_uint32_t(&opts->total_ops, arg); 129 130 if (ret) 131 RTE_LOG(ERR, USER1, "failed to parse total operations count\n"); 132 133 if (opts->total_ops == 0) { 134 RTE_LOG(ERR, USER1, 135 "invalid total operations count number specified\n"); 136 return -1; 137 } 138 139 return ret; 140 } 141 142 static int 143 parse_pool_sz(struct cperf_options *opts, const char *arg) 144 { 145 int ret = parse_uint32_t(&opts->pool_sz, arg); 146 147 if (ret) 148 RTE_LOG(ERR, USER1, "failed to parse pool size"); 149 return ret; 150 } 151 152 static int 153 parse_burst_sz(struct cperf_options *opts, const char *arg) 154 { 155 int ret = parse_uint32_t(&opts->burst_sz, arg); 156 157 if (ret) 158 RTE_LOG(ERR, USER1, "failed to parse burst size"); 159 return ret; 160 } 161 162 static int 163 parse_buffer_sz(struct cperf_options *opts, const char *arg) 164 { 165 uint32_t i, valid_buf_sz[] = { 166 32, 64, 128, 256, 384, 512, 768, 1024, 1280, 1536, 1792, 167 2048 168 }; 169 170 if (parse_uint32_t(&opts->buffer_sz, arg)) { 171 RTE_LOG(ERR, USER1, "failed to parse buffer size"); 172 return -1; 173 } 174 175 for (i = 0; i < RTE_DIM(valid_buf_sz); i++) 176 if (valid_buf_sz[i] == opts->buffer_sz) 177 return 0; 178 179 RTE_LOG(ERR, USER1, "invalid buffer size specified"); 180 return -1; 181 } 182 183 static int 184 parse_segments_nb(struct cperf_options *opts, const char *arg) 185 { 186 int ret = parse_uint32_t(&opts->segments_nb, arg); 187 188 if (ret) { 189 RTE_LOG(ERR, USER1, "failed to parse segments number\n"); 190 return -1; 191 } 192 193 if ((opts->segments_nb == 0) || (opts->segments_nb > 255)) { 194 RTE_LOG(ERR, USER1, "invalid segments number specified\n"); 195 return -1; 196 } 197 198 return 0; 199 } 200 201 static int 202 parse_device_type(struct cperf_options *opts, const char *arg) 203 { 204 if (strlen(arg) > (sizeof(opts->device_type) - 1)) 205 return -1; 206 207 strncpy(opts->device_type, arg, sizeof(opts->device_type) - 1); 208 *(opts->device_type + sizeof(opts->device_type) - 1) = '\0'; 209 210 return 0; 211 } 212 213 static int 214 parse_op_type(struct cperf_options *opts, const char *arg) 215 { 216 struct name_id_map optype_namemap[] = { 217 { 218 cperf_op_type_strs[CPERF_CIPHER_ONLY], 219 CPERF_CIPHER_ONLY 220 }, 221 { 222 cperf_op_type_strs[CPERF_AUTH_ONLY], 223 CPERF_AUTH_ONLY 224 }, 225 { 226 cperf_op_type_strs[CPERF_CIPHER_THEN_AUTH], 227 CPERF_CIPHER_THEN_AUTH 228 }, 229 { 230 cperf_op_type_strs[CPERF_AUTH_THEN_CIPHER], 231 CPERF_AUTH_THEN_CIPHER 232 }, 233 { 234 cperf_op_type_strs[CPERF_AEAD], 235 CPERF_AEAD 236 } 237 }; 238 239 int id = get_str_key_id_mapping(optype_namemap, 240 RTE_DIM(optype_namemap), arg); 241 if (id < 0) { 242 RTE_LOG(ERR, USER1, "invalid opt type specified\n"); 243 return -1; 244 } 245 246 opts->op_type = (enum cperf_op_type)id; 247 248 return 0; 249 } 250 251 static int 252 parse_sessionless(struct cperf_options *opts, 253 const char *arg __rte_unused) 254 { 255 opts->sessionless = 1; 256 return 0; 257 } 258 259 static int 260 parse_out_of_place(struct cperf_options *opts, 261 const char *arg __rte_unused) 262 { 263 opts->out_of_place = 1; 264 return 0; 265 } 266 267 static int 268 parse_verify(struct cperf_options *opts, 269 const char *arg __rte_unused) 270 { 271 opts->verify = 1; 272 273 return 0; 274 } 275 276 static int 277 parse_test_file(struct cperf_options *opts, 278 const char *arg) 279 { 280 opts->test_file = strdup(arg); 281 if (access(opts->test_file, F_OK) != -1) 282 return 0; 283 RTE_LOG(ERR, USER1, "Test vector file doesn't exist\n"); 284 285 return -1; 286 } 287 288 static int 289 parse_test_name(struct cperf_options *opts, 290 const char *arg) 291 { 292 char *test_name = (char *) rte_zmalloc(NULL, 293 sizeof(char) * (strlen(arg) + 3), 0); 294 snprintf(test_name, strlen(arg) + 3, "[%s]", arg); 295 opts->test_name = test_name; 296 297 return 0; 298 } 299 300 static int 301 parse_silent(struct cperf_options *opts, 302 const char *arg __rte_unused) 303 { 304 opts->silent = 1; 305 306 return 0; 307 } 308 309 static int 310 parse_cipher_algo(struct cperf_options *opts, const char *arg) 311 { 312 struct name_id_map cipher_algo_namemap[] = { 313 { 314 rte_crypto_cipher_algorithm_strings 315 [RTE_CRYPTO_CIPHER_3DES_CBC], 316 RTE_CRYPTO_CIPHER_3DES_CBC 317 }, 318 { 319 rte_crypto_cipher_algorithm_strings 320 [RTE_CRYPTO_CIPHER_3DES_ECB], 321 RTE_CRYPTO_CIPHER_3DES_ECB 322 }, 323 { 324 rte_crypto_cipher_algorithm_strings 325 [RTE_CRYPTO_CIPHER_3DES_CTR], 326 RTE_CRYPTO_CIPHER_3DES_CTR 327 }, 328 { 329 rte_crypto_cipher_algorithm_strings 330 [RTE_CRYPTO_CIPHER_AES_CBC], 331 RTE_CRYPTO_CIPHER_AES_CBC 332 }, 333 { 334 rte_crypto_cipher_algorithm_strings 335 [RTE_CRYPTO_CIPHER_AES_CCM], 336 RTE_CRYPTO_CIPHER_AES_CCM 337 }, 338 { 339 rte_crypto_cipher_algorithm_strings 340 [RTE_CRYPTO_CIPHER_AES_CTR], 341 RTE_CRYPTO_CIPHER_AES_CTR 342 }, 343 { 344 rte_crypto_cipher_algorithm_strings 345 [RTE_CRYPTO_CIPHER_AES_ECB], 346 RTE_CRYPTO_CIPHER_AES_ECB 347 }, 348 { 349 rte_crypto_cipher_algorithm_strings 350 [RTE_CRYPTO_CIPHER_AES_GCM], 351 RTE_CRYPTO_CIPHER_AES_GCM 352 }, 353 { 354 rte_crypto_cipher_algorithm_strings 355 [RTE_CRYPTO_CIPHER_AES_F8], 356 RTE_CRYPTO_CIPHER_AES_F8 357 }, 358 { 359 rte_crypto_cipher_algorithm_strings 360 [RTE_CRYPTO_CIPHER_AES_XTS], 361 RTE_CRYPTO_CIPHER_AES_XTS 362 }, 363 { 364 rte_crypto_cipher_algorithm_strings 365 [RTE_CRYPTO_CIPHER_ARC4], 366 RTE_CRYPTO_CIPHER_ARC4 367 }, 368 { 369 rte_crypto_cipher_algorithm_strings 370 [RTE_CRYPTO_CIPHER_NULL], 371 RTE_CRYPTO_CIPHER_NULL 372 }, 373 { 374 rte_crypto_cipher_algorithm_strings 375 [RTE_CRYPTO_CIPHER_KASUMI_F8], 376 RTE_CRYPTO_CIPHER_KASUMI_F8 377 }, 378 { 379 rte_crypto_cipher_algorithm_strings 380 [RTE_CRYPTO_CIPHER_SNOW3G_UEA2], 381 RTE_CRYPTO_CIPHER_SNOW3G_UEA2 382 }, 383 { 384 rte_crypto_cipher_algorithm_strings 385 [RTE_CRYPTO_CIPHER_ZUC_EEA3], 386 RTE_CRYPTO_CIPHER_ZUC_EEA3 387 }, 388 }; 389 390 391 int id = get_str_key_id_mapping(cipher_algo_namemap, 392 RTE_DIM(cipher_algo_namemap), arg); 393 if (id < 0) { 394 RTE_LOG(ERR, USER1, "Invalid cipher algorithm specified\n"); 395 return -1; 396 } 397 398 opts->cipher_algo = (enum rte_crypto_cipher_algorithm)id; 399 400 return 0; 401 } 402 403 static int 404 parse_cipher_op(struct cperf_options *opts, const char *arg) 405 { 406 struct name_id_map cipher_op_namemap[] = { 407 { 408 rte_crypto_cipher_operation_strings 409 [RTE_CRYPTO_CIPHER_OP_ENCRYPT], 410 RTE_CRYPTO_CIPHER_OP_ENCRYPT }, 411 { 412 rte_crypto_cipher_operation_strings 413 [RTE_CRYPTO_CIPHER_OP_DECRYPT], 414 RTE_CRYPTO_CIPHER_OP_DECRYPT 415 } 416 }; 417 418 int id = get_str_key_id_mapping(cipher_op_namemap, 419 RTE_DIM(cipher_op_namemap), arg); 420 if (id < 0) { 421 RTE_LOG(ERR, USER1, "Invalid cipher operation specified\n"); 422 return -1; 423 } 424 425 opts->cipher_op = (enum rte_crypto_cipher_operation)id; 426 427 return 0; 428 } 429 430 static int 431 parse_cipher_key_sz(struct cperf_options *opts, const char *arg) 432 { 433 return parse_uint16_t(&opts->cipher_key_sz, arg); 434 } 435 436 static int 437 parse_cipher_iv_sz(struct cperf_options *opts, const char *arg) 438 { 439 return parse_uint16_t(&opts->cipher_iv_sz, arg); 440 } 441 442 static int 443 parse_auth_algo(struct cperf_options *opts, const char *arg) { 444 struct name_id_map cipher_auth_namemap[] = { 445 { 446 rte_crypto_auth_algorithm_strings 447 [RTE_CRYPTO_AUTH_AES_CBC_MAC], 448 RTE_CRYPTO_AUTH_AES_CBC_MAC 449 }, 450 { 451 rte_crypto_auth_algorithm_strings 452 [RTE_CRYPTO_AUTH_AES_CCM], 453 RTE_CRYPTO_AUTH_AES_CCM 454 }, 455 { 456 rte_crypto_auth_algorithm_strings 457 [RTE_CRYPTO_AUTH_AES_CMAC], 458 RTE_CRYPTO_AUTH_AES_CMAC 459 }, 460 { 461 rte_crypto_auth_algorithm_strings 462 [RTE_CRYPTO_AUTH_AES_GCM], 463 RTE_CRYPTO_AUTH_AES_GCM 464 }, 465 { 466 rte_crypto_auth_algorithm_strings 467 [RTE_CRYPTO_AUTH_AES_GMAC], 468 RTE_CRYPTO_AUTH_AES_GMAC 469 }, 470 { 471 rte_crypto_auth_algorithm_strings 472 [RTE_CRYPTO_AUTH_AES_XCBC_MAC], 473 RTE_CRYPTO_AUTH_AES_XCBC_MAC 474 }, 475 { 476 rte_crypto_auth_algorithm_strings 477 [RTE_CRYPTO_AUTH_MD5], 478 RTE_CRYPTO_AUTH_MD5 479 }, 480 { 481 rte_crypto_auth_algorithm_strings 482 [RTE_CRYPTO_AUTH_MD5_HMAC], 483 RTE_CRYPTO_AUTH_MD5_HMAC 484 }, 485 { 486 rte_crypto_auth_algorithm_strings 487 [RTE_CRYPTO_AUTH_SHA1], 488 RTE_CRYPTO_AUTH_SHA1 489 }, 490 { 491 rte_crypto_auth_algorithm_strings 492 [RTE_CRYPTO_AUTH_SHA1_HMAC], 493 RTE_CRYPTO_AUTH_SHA1_HMAC 494 }, 495 { 496 rte_crypto_auth_algorithm_strings 497 [RTE_CRYPTO_AUTH_SHA224], 498 RTE_CRYPTO_AUTH_SHA224 499 }, 500 { 501 rte_crypto_auth_algorithm_strings 502 [RTE_CRYPTO_AUTH_SHA224_HMAC], 503 RTE_CRYPTO_AUTH_SHA224_HMAC 504 }, 505 { 506 rte_crypto_auth_algorithm_strings 507 [RTE_CRYPTO_AUTH_SHA256], 508 RTE_CRYPTO_AUTH_SHA256 509 }, 510 { 511 rte_crypto_auth_algorithm_strings 512 [RTE_CRYPTO_AUTH_SHA256_HMAC], 513 RTE_CRYPTO_AUTH_SHA256_HMAC 514 }, 515 { 516 rte_crypto_auth_algorithm_strings 517 [RTE_CRYPTO_AUTH_SHA384], 518 RTE_CRYPTO_AUTH_SHA384 519 }, 520 { 521 rte_crypto_auth_algorithm_strings 522 [RTE_CRYPTO_AUTH_SHA384_HMAC], 523 RTE_CRYPTO_AUTH_SHA384_HMAC 524 }, 525 { 526 rte_crypto_auth_algorithm_strings 527 [RTE_CRYPTO_AUTH_SHA512], 528 RTE_CRYPTO_AUTH_SHA512 529 }, 530 { 531 rte_crypto_auth_algorithm_strings 532 [RTE_CRYPTO_AUTH_SHA512_HMAC], 533 RTE_CRYPTO_AUTH_SHA512_HMAC 534 }, 535 { 536 rte_crypto_auth_algorithm_strings 537 [RTE_CRYPTO_AUTH_KASUMI_F9], 538 RTE_CRYPTO_AUTH_KASUMI_F9 539 }, 540 { 541 rte_crypto_auth_algorithm_strings 542 [RTE_CRYPTO_AUTH_SNOW3G_UIA2], 543 RTE_CRYPTO_AUTH_SNOW3G_UIA2 544 }, 545 { 546 rte_crypto_auth_algorithm_strings 547 [RTE_CRYPTO_AUTH_ZUC_EIA3], 548 RTE_CRYPTO_AUTH_ZUC_EIA3 549 }, 550 }; 551 552 553 int id = get_str_key_id_mapping(cipher_auth_namemap, 554 RTE_DIM(cipher_auth_namemap), arg); 555 if (id < 0) { 556 RTE_LOG(ERR, USER1, "invalid authentication algorithm specified" 557 "\n"); 558 return -1; 559 } 560 561 opts->auth_algo = (enum rte_crypto_auth_algorithm)id; 562 563 return 0; 564 } 565 566 static int 567 parse_auth_op(struct cperf_options *opts, const char *arg) 568 { 569 struct name_id_map auth_op_namemap[] = { 570 { 571 rte_crypto_auth_operation_strings 572 [RTE_CRYPTO_AUTH_OP_GENERATE], 573 RTE_CRYPTO_AUTH_OP_GENERATE }, 574 { 575 rte_crypto_auth_operation_strings 576 [RTE_CRYPTO_AUTH_OP_VERIFY], 577 RTE_CRYPTO_AUTH_OP_VERIFY 578 } 579 }; 580 581 int id = get_str_key_id_mapping(auth_op_namemap, 582 RTE_DIM(auth_op_namemap), arg); 583 if (id < 0) { 584 RTE_LOG(ERR, USER1, "invalid authentication operation specified" 585 "\n"); 586 return -1; 587 } 588 589 opts->auth_op = (enum rte_crypto_auth_operation)id; 590 591 return 0; 592 } 593 594 static int 595 parse_auth_key_sz(struct cperf_options *opts, const char *arg) 596 { 597 return parse_uint16_t(&opts->auth_key_sz, arg); 598 } 599 600 static int 601 parse_auth_digest_sz(struct cperf_options *opts, const char *arg) 602 { 603 return parse_uint16_t(&opts->auth_digest_sz, arg); 604 } 605 606 static int 607 parse_auth_aad_sz(struct cperf_options *opts, const char *arg) 608 { 609 return parse_uint16_t(&opts->auth_aad_sz, arg); 610 } 611 612 static int 613 parse_csv_friendly(struct cperf_options *opts, const char *arg __rte_unused) 614 { 615 opts->csv = 1; 616 opts->silent = 1; 617 return 0; 618 } 619 620 typedef int (*option_parser_t)(struct cperf_options *opts, 621 const char *arg); 622 623 struct long_opt_parser { 624 const char *lgopt_name; 625 option_parser_t parser_fn; 626 627 }; 628 629 static struct option lgopts[] = { 630 631 { CPERF_PTEST_TYPE, required_argument, 0, 0 }, 632 633 { CPERF_POOL_SIZE, required_argument, 0, 0 }, 634 { CPERF_TOTAL_OPS, required_argument, 0, 0 }, 635 { CPERF_BURST_SIZE, required_argument, 0, 0 }, 636 { CPERF_BUFFER_SIZE, required_argument, 0, 0 }, 637 { CPERF_SEGMENTS_NB, required_argument, 0, 0 }, 638 639 { CPERF_DEVTYPE, required_argument, 0, 0 }, 640 { CPERF_OPTYPE, required_argument, 0, 0 }, 641 642 { CPERF_SILENT, no_argument, 0, 0 }, 643 { CPERF_SESSIONLESS, no_argument, 0, 0 }, 644 { CPERF_OUT_OF_PLACE, no_argument, 0, 0 }, 645 { CPERF_VERIFY, no_argument, 0, 0 }, 646 { CPERF_TEST_FILE, required_argument, 0, 0 }, 647 { CPERF_TEST_NAME, required_argument, 0, 0 }, 648 649 { CPERF_CIPHER_ALGO, required_argument, 0, 0 }, 650 { CPERF_CIPHER_OP, required_argument, 0, 0 }, 651 652 { CPERF_CIPHER_KEY_SZ, required_argument, 0, 0 }, 653 { CPERF_CIPHER_IV_SZ, required_argument, 0, 0 }, 654 655 { CPERF_AUTH_ALGO, required_argument, 0, 0 }, 656 { CPERF_AUTH_OP, required_argument, 0, 0 }, 657 658 { CPERF_AUTH_KEY_SZ, required_argument, 0, 0 }, 659 { CPERF_AUTH_DIGEST_SZ, required_argument, 0, 0 }, 660 { CPERF_AUTH_AAD_SZ, required_argument, 0, 0 }, 661 { CPERF_CSV, no_argument, 0, 0}, 662 663 { NULL, 0, 0, 0 } 664 }; 665 666 void 667 cperf_options_default(struct cperf_options *opts) 668 { 669 opts->test = CPERF_TEST_TYPE_THROUGHPUT; 670 671 opts->pool_sz = 8192; 672 opts->total_ops = 10000000; 673 opts->burst_sz = 32; 674 opts->buffer_sz = 64; 675 opts->segments_nb = 1; 676 677 strncpy(opts->device_type, "crypto_aesni_mb", 678 sizeof(opts->device_type)); 679 680 opts->op_type = CPERF_CIPHER_THEN_AUTH; 681 682 opts->silent = 0; 683 opts->verify = 0; 684 opts->test_file = NULL; 685 opts->test_name = NULL; 686 opts->sessionless = 0; 687 opts->out_of_place = 0; 688 opts->csv = 0; 689 690 opts->cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC; 691 opts->cipher_op = RTE_CRYPTO_CIPHER_OP_ENCRYPT; 692 opts->cipher_key_sz = 16; 693 opts->cipher_iv_sz = 16; 694 695 opts->auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC; 696 opts->auth_op = RTE_CRYPTO_AUTH_OP_GENERATE; 697 698 opts->auth_key_sz = 64; 699 opts->auth_digest_sz = 12; 700 opts->auth_aad_sz = 0; 701 } 702 703 static int 704 cperf_opts_parse_long(int opt_idx, struct cperf_options *opts) 705 { 706 struct long_opt_parser parsermap[] = { 707 { CPERF_PTEST_TYPE, parse_cperf_test_type }, 708 { CPERF_SILENT, parse_silent }, 709 { CPERF_POOL_SIZE, parse_pool_sz }, 710 { CPERF_TOTAL_OPS, parse_total_ops }, 711 { CPERF_BURST_SIZE, parse_burst_sz }, 712 { CPERF_BUFFER_SIZE, parse_buffer_sz }, 713 { CPERF_SEGMENTS_NB, parse_segments_nb }, 714 { CPERF_DEVTYPE, parse_device_type }, 715 { CPERF_OPTYPE, parse_op_type }, 716 { CPERF_SESSIONLESS, parse_sessionless }, 717 { CPERF_OUT_OF_PLACE, parse_out_of_place }, 718 { CPERF_VERIFY, parse_verify }, 719 { CPERF_TEST_FILE, parse_test_file }, 720 { CPERF_TEST_NAME, parse_test_name }, 721 { CPERF_CIPHER_ALGO, parse_cipher_algo }, 722 { CPERF_CIPHER_OP, parse_cipher_op }, 723 { CPERF_CIPHER_KEY_SZ, parse_cipher_key_sz }, 724 { CPERF_CIPHER_IV_SZ, parse_cipher_iv_sz }, 725 { CPERF_AUTH_ALGO, parse_auth_algo }, 726 { CPERF_AUTH_OP, parse_auth_op }, 727 { CPERF_AUTH_KEY_SZ, parse_auth_key_sz }, 728 { CPERF_AUTH_DIGEST_SZ, parse_auth_digest_sz }, 729 { CPERF_AUTH_AAD_SZ, parse_auth_aad_sz }, 730 { CPERF_CSV, parse_csv_friendly}, 731 }; 732 unsigned int i; 733 734 for (i = 0; i < RTE_DIM(parsermap); i++) { 735 if (strncmp(lgopts[opt_idx].name, parsermap[i].lgopt_name, 736 strlen(lgopts[opt_idx].name)) == 0) 737 return parsermap[i].parser_fn(opts, optarg); 738 } 739 740 return -EINVAL; 741 } 742 743 int 744 cperf_options_parse(struct cperf_options *options, int argc, char **argv) 745 { 746 int opt, retval, opt_idx; 747 748 while ((opt = getopt_long(argc, argv, "", lgopts, &opt_idx)) != EOF) { 749 switch (opt) { 750 /* long options */ 751 case 0: 752 753 retval = cperf_opts_parse_long(opt_idx, options); 754 if (retval != 0) 755 return retval; 756 757 break; 758 759 default: 760 return -EINVAL; 761 } 762 } 763 764 return 0; 765 } 766 767 int 768 cperf_options_check(struct cperf_options *options) 769 { 770 if (options->segments_nb > options->buffer_sz) { 771 RTE_LOG(ERR, USER1, 772 "Segments number greater than buffer size.\n"); 773 return -EINVAL; 774 } 775 776 if (options->verify && options->test_file == NULL) { 777 RTE_LOG(ERR, USER1, "Define path to the file with test" 778 " vectors.\n"); 779 return -EINVAL; 780 } 781 782 if (options->test_name != NULL && options->test_file == NULL) { 783 RTE_LOG(ERR, USER1, "Define path to the file with test" 784 " vectors.\n"); 785 return -EINVAL; 786 } 787 788 if (options->auth_op == RTE_CRYPTO_AUTH_OP_VERIFY && 789 options->test_file == NULL) { 790 RTE_LOG(ERR, USER1, "Define path to the file with test" 791 " vectors.\n"); 792 return -EINVAL; 793 } 794 795 if (options->verify && 796 options->total_ops > options->pool_sz) { 797 RTE_LOG(ERR, USER1, "Total number of ops must be less than or" 798 " equal to the pool size.\n"); 799 return -EINVAL; 800 } 801 802 if (options->op_type == CPERF_CIPHER_THEN_AUTH) { 803 if (options->cipher_op != RTE_CRYPTO_CIPHER_OP_ENCRYPT && 804 options->auth_op != 805 RTE_CRYPTO_AUTH_OP_GENERATE) { 806 RTE_LOG(ERR, USER1, "Option cipher then auth must use" 807 " options: encrypt and generate.\n"); 808 return -EINVAL; 809 } 810 } else if (options->op_type == CPERF_AUTH_THEN_CIPHER) { 811 if (options->cipher_op != RTE_CRYPTO_CIPHER_OP_DECRYPT && 812 options->auth_op != 813 RTE_CRYPTO_AUTH_OP_VERIFY) { 814 RTE_LOG(ERR, USER1, "Option auth then cipher must use" 815 " options: decrypt and verify.\n"); 816 return -EINVAL; 817 } 818 } else if (options->op_type == CPERF_AEAD) { 819 if (!(options->cipher_op == RTE_CRYPTO_CIPHER_OP_ENCRYPT && 820 options->auth_op == 821 RTE_CRYPTO_AUTH_OP_GENERATE) && 822 !(options->cipher_op == 823 RTE_CRYPTO_CIPHER_OP_DECRYPT && 824 options->auth_op == 825 RTE_CRYPTO_AUTH_OP_VERIFY)) { 826 RTE_LOG(ERR, USER1, "Use together options: encrypt and" 827 " generate or decrypt and verify.\n"); 828 return -EINVAL; 829 } 830 } 831 832 return 0; 833 } 834 835 void 836 cperf_options_dump(struct cperf_options *opts) 837 { 838 printf("# Crypto Performance Application Options:\n"); 839 printf("#\n"); 840 printf("# cperf test: %s\n", cperf_test_type_strs[opts->test]); 841 printf("#\n"); 842 printf("# size of crypto op / mbuf pool: %u\n", opts->pool_sz); 843 printf("# total number of ops: %u\n", opts->total_ops); 844 printf("# burst size: %u\n", opts->burst_sz); 845 printf("# buffer size: %u\n", opts->buffer_sz); 846 printf("# segments per buffer: %u\n", opts->segments_nb); 847 printf("#\n"); 848 printf("# cryptodev type: %s\n", opts->device_type); 849 printf("#\n"); 850 printf("# crypto operation: %s\n", cperf_op_type_strs[opts->op_type]); 851 printf("# verify operation: %s\n", opts->verify ? "yes" : "no"); 852 printf("# sessionless: %s\n", opts->sessionless ? "yes" : "no"); 853 printf("# out of place: %s\n", opts->out_of_place ? "yes" : "no"); 854 855 printf("#\n"); 856 857 if (opts->op_type == CPERF_AUTH_ONLY || 858 opts->op_type == CPERF_CIPHER_THEN_AUTH || 859 opts->op_type == CPERF_AUTH_THEN_CIPHER || 860 opts->op_type == CPERF_AEAD) { 861 printf("# auth algorithm: %s\n", 862 rte_crypto_auth_algorithm_strings[opts->auth_algo]); 863 printf("# auth operation: %s\n", 864 rte_crypto_auth_operation_strings[opts->auth_op]); 865 printf("# auth key size: %u\n", opts->auth_key_sz); 866 printf("# auth digest size: %u\n", opts->auth_digest_sz); 867 printf("# auth aad size: %u\n", opts->auth_aad_sz); 868 printf("#\n"); 869 } 870 871 if (opts->op_type == CPERF_CIPHER_ONLY || 872 opts->op_type == CPERF_CIPHER_THEN_AUTH || 873 opts->op_type == CPERF_AUTH_THEN_CIPHER || 874 opts->op_type == CPERF_AEAD) { 875 printf("# cipher algorithm: %s\n", 876 rte_crypto_cipher_algorithm_strings[opts->cipher_algo]); 877 printf("# cipher operation: %s\n", 878 rte_crypto_cipher_operation_strings[opts->cipher_op]); 879 printf("# cipher key size: %u\n", opts->cipher_key_sz); 880 printf("# cipher iv size: %u\n", opts->cipher_iv_sz); 881 printf("#\n"); 882 } 883 } 884