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