1 /* SPDX-License-Identifier: BSD-3-Clause 2 * Copyright(c) 2016-2017 Intel Corporation 3 */ 4 5 #include <rte_cryptodev.h> 6 7 #include "cperf_ops.h" 8 #include "cperf_test_vectors.h" 9 10 static int 11 cperf_set_ops_null_cipher(struct rte_crypto_op **ops, 12 uint32_t src_buf_offset, uint32_t dst_buf_offset, 13 uint16_t nb_ops, struct rte_cryptodev_sym_session *sess, 14 const struct cperf_options *options, 15 const struct cperf_test_vector *test_vector __rte_unused, 16 uint16_t iv_offset __rte_unused, uint32_t *imix_idx) 17 { 18 uint16_t i; 19 20 for (i = 0; i < nb_ops; i++) { 21 struct rte_crypto_sym_op *sym_op = ops[i]->sym; 22 23 ops[i]->status = RTE_CRYPTO_OP_STATUS_NOT_PROCESSED; 24 rte_crypto_op_attach_sym_session(ops[i], sess); 25 26 sym_op->m_src = (struct rte_mbuf *)((uint8_t *)ops[i] + 27 src_buf_offset); 28 29 /* Set dest mbuf to NULL if out-of-place (dst_buf_offset = 0) */ 30 if (dst_buf_offset == 0) 31 sym_op->m_dst = NULL; 32 else 33 sym_op->m_dst = (struct rte_mbuf *)((uint8_t *)ops[i] + 34 dst_buf_offset); 35 36 /* cipher parameters */ 37 if (options->imix_distribution_count) { 38 sym_op->cipher.data.length = 39 options->imix_buffer_sizes[*imix_idx]; 40 *imix_idx = (*imix_idx + 1) % options->pool_sz; 41 } else 42 sym_op->cipher.data.length = options->test_buffer_size; 43 sym_op->cipher.data.offset = 0; 44 } 45 46 return 0; 47 } 48 49 static int 50 cperf_set_ops_null_auth(struct rte_crypto_op **ops, 51 uint32_t src_buf_offset, uint32_t dst_buf_offset, 52 uint16_t nb_ops, struct rte_cryptodev_sym_session *sess, 53 const struct cperf_options *options, 54 const struct cperf_test_vector *test_vector __rte_unused, 55 uint16_t iv_offset __rte_unused, uint32_t *imix_idx) 56 { 57 uint16_t i; 58 59 for (i = 0; i < nb_ops; i++) { 60 struct rte_crypto_sym_op *sym_op = ops[i]->sym; 61 62 ops[i]->status = RTE_CRYPTO_OP_STATUS_NOT_PROCESSED; 63 rte_crypto_op_attach_sym_session(ops[i], sess); 64 65 sym_op->m_src = (struct rte_mbuf *)((uint8_t *)ops[i] + 66 src_buf_offset); 67 68 /* Set dest mbuf to NULL if out-of-place (dst_buf_offset = 0) */ 69 if (dst_buf_offset == 0) 70 sym_op->m_dst = NULL; 71 else 72 sym_op->m_dst = (struct rte_mbuf *)((uint8_t *)ops[i] + 73 dst_buf_offset); 74 75 /* auth parameters */ 76 if (options->imix_distribution_count) { 77 sym_op->auth.data.length = 78 options->imix_buffer_sizes[*imix_idx]; 79 *imix_idx = (*imix_idx + 1) % options->pool_sz; 80 } else 81 sym_op->auth.data.length = options->test_buffer_size; 82 sym_op->auth.data.offset = 0; 83 } 84 85 return 0; 86 } 87 88 static int 89 cperf_set_ops_cipher(struct rte_crypto_op **ops, 90 uint32_t src_buf_offset, uint32_t dst_buf_offset, 91 uint16_t nb_ops, struct rte_cryptodev_sym_session *sess, 92 const struct cperf_options *options, 93 const struct cperf_test_vector *test_vector, 94 uint16_t iv_offset, uint32_t *imix_idx) 95 { 96 uint16_t i; 97 98 for (i = 0; i < nb_ops; i++) { 99 struct rte_crypto_sym_op *sym_op = ops[i]->sym; 100 101 ops[i]->status = RTE_CRYPTO_OP_STATUS_NOT_PROCESSED; 102 rte_crypto_op_attach_sym_session(ops[i], sess); 103 104 sym_op->m_src = (struct rte_mbuf *)((uint8_t *)ops[i] + 105 src_buf_offset); 106 107 /* Set dest mbuf to NULL if out-of-place (dst_buf_offset = 0) */ 108 if (dst_buf_offset == 0) 109 sym_op->m_dst = NULL; 110 else 111 sym_op->m_dst = (struct rte_mbuf *)((uint8_t *)ops[i] + 112 dst_buf_offset); 113 114 /* cipher parameters */ 115 if (options->imix_distribution_count) { 116 sym_op->cipher.data.length = 117 options->imix_buffer_sizes[*imix_idx]; 118 *imix_idx = (*imix_idx + 1) % options->pool_sz; 119 } else 120 sym_op->cipher.data.length = options->test_buffer_size; 121 122 if (options->cipher_algo == RTE_CRYPTO_CIPHER_SNOW3G_UEA2 || 123 options->cipher_algo == RTE_CRYPTO_CIPHER_KASUMI_F8 || 124 options->cipher_algo == RTE_CRYPTO_CIPHER_ZUC_EEA3) 125 sym_op->cipher.data.length <<= 3; 126 127 sym_op->cipher.data.offset = 0; 128 } 129 130 if (options->test == CPERF_TEST_TYPE_VERIFY) { 131 for (i = 0; i < nb_ops; i++) { 132 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ops[i], 133 uint8_t *, iv_offset); 134 135 memcpy(iv_ptr, test_vector->cipher_iv.data, 136 test_vector->cipher_iv.length); 137 138 } 139 } 140 141 return 0; 142 } 143 144 static int 145 cperf_set_ops_auth(struct rte_crypto_op **ops, 146 uint32_t src_buf_offset, uint32_t dst_buf_offset, 147 uint16_t nb_ops, struct rte_cryptodev_sym_session *sess, 148 const struct cperf_options *options, 149 const struct cperf_test_vector *test_vector, 150 uint16_t iv_offset, uint32_t *imix_idx) 151 { 152 uint16_t i; 153 154 for (i = 0; i < nb_ops; i++) { 155 struct rte_crypto_sym_op *sym_op = ops[i]->sym; 156 157 ops[i]->status = RTE_CRYPTO_OP_STATUS_NOT_PROCESSED; 158 rte_crypto_op_attach_sym_session(ops[i], sess); 159 160 sym_op->m_src = (struct rte_mbuf *)((uint8_t *)ops[i] + 161 src_buf_offset); 162 163 /* Set dest mbuf to NULL if out-of-place (dst_buf_offset = 0) */ 164 if (dst_buf_offset == 0) 165 sym_op->m_dst = NULL; 166 else 167 sym_op->m_dst = (struct rte_mbuf *)((uint8_t *)ops[i] + 168 dst_buf_offset); 169 170 if (test_vector->auth_iv.length) { 171 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ops[i], 172 uint8_t *, 173 iv_offset); 174 memcpy(iv_ptr, test_vector->auth_iv.data, 175 test_vector->auth_iv.length); 176 } 177 178 /* authentication parameters */ 179 if (options->auth_op == RTE_CRYPTO_AUTH_OP_VERIFY) { 180 sym_op->auth.digest.data = test_vector->digest.data; 181 sym_op->auth.digest.phys_addr = 182 test_vector->digest.phys_addr; 183 } else { 184 185 uint32_t offset = options->test_buffer_size; 186 struct rte_mbuf *buf, *tbuf; 187 188 if (options->out_of_place) { 189 buf = sym_op->m_dst; 190 } else { 191 tbuf = sym_op->m_src; 192 while ((tbuf->next != NULL) && 193 (offset >= tbuf->data_len)) { 194 offset -= tbuf->data_len; 195 tbuf = tbuf->next; 196 } 197 /* 198 * If there is not enough room in segment, 199 * place the digest in the next segment 200 */ 201 if ((tbuf->data_len - offset) < options->digest_sz) { 202 tbuf = tbuf->next; 203 offset = 0; 204 } 205 buf = tbuf; 206 } 207 208 sym_op->auth.digest.data = rte_pktmbuf_mtod_offset(buf, 209 uint8_t *, offset); 210 sym_op->auth.digest.phys_addr = 211 rte_pktmbuf_iova_offset(buf, offset); 212 213 } 214 215 if (options->imix_distribution_count) { 216 sym_op->auth.data.length = 217 options->imix_buffer_sizes[*imix_idx]; 218 *imix_idx = (*imix_idx + 1) % options->pool_sz; 219 } else 220 sym_op->auth.data.length = options->test_buffer_size; 221 222 if (options->auth_algo == RTE_CRYPTO_AUTH_SNOW3G_UIA2 || 223 options->auth_algo == RTE_CRYPTO_AUTH_KASUMI_F9 || 224 options->auth_algo == RTE_CRYPTO_AUTH_ZUC_EIA3) 225 sym_op->auth.data.length <<= 3; 226 227 sym_op->auth.data.offset = 0; 228 } 229 230 if (options->test == CPERF_TEST_TYPE_VERIFY) { 231 if (test_vector->auth_iv.length) { 232 for (i = 0; i < nb_ops; i++) { 233 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ops[i], 234 uint8_t *, iv_offset); 235 236 memcpy(iv_ptr, test_vector->auth_iv.data, 237 test_vector->auth_iv.length); 238 } 239 } 240 } 241 return 0; 242 } 243 244 static int 245 cperf_set_ops_cipher_auth(struct rte_crypto_op **ops, 246 uint32_t src_buf_offset, uint32_t dst_buf_offset, 247 uint16_t nb_ops, struct rte_cryptodev_sym_session *sess, 248 const struct cperf_options *options, 249 const struct cperf_test_vector *test_vector, 250 uint16_t iv_offset, uint32_t *imix_idx) 251 { 252 uint16_t i; 253 254 for (i = 0; i < nb_ops; i++) { 255 struct rte_crypto_sym_op *sym_op = ops[i]->sym; 256 257 ops[i]->status = RTE_CRYPTO_OP_STATUS_NOT_PROCESSED; 258 rte_crypto_op_attach_sym_session(ops[i], sess); 259 260 sym_op->m_src = (struct rte_mbuf *)((uint8_t *)ops[i] + 261 src_buf_offset); 262 263 /* Set dest mbuf to NULL if out-of-place (dst_buf_offset = 0) */ 264 if (dst_buf_offset == 0) 265 sym_op->m_dst = NULL; 266 else 267 sym_op->m_dst = (struct rte_mbuf *)((uint8_t *)ops[i] + 268 dst_buf_offset); 269 270 /* cipher parameters */ 271 if (options->imix_distribution_count) { 272 sym_op->cipher.data.length = 273 options->imix_buffer_sizes[*imix_idx]; 274 *imix_idx = (*imix_idx + 1) % options->pool_sz; 275 } else 276 sym_op->cipher.data.length = options->test_buffer_size; 277 278 if (options->cipher_algo == RTE_CRYPTO_CIPHER_SNOW3G_UEA2 || 279 options->cipher_algo == RTE_CRYPTO_CIPHER_KASUMI_F8 || 280 options->cipher_algo == RTE_CRYPTO_CIPHER_ZUC_EEA3) 281 sym_op->cipher.data.length <<= 3; 282 283 sym_op->cipher.data.offset = 0; 284 285 /* authentication parameters */ 286 if (options->auth_op == RTE_CRYPTO_AUTH_OP_VERIFY) { 287 sym_op->auth.digest.data = test_vector->digest.data; 288 sym_op->auth.digest.phys_addr = 289 test_vector->digest.phys_addr; 290 } else { 291 292 uint32_t offset = options->test_buffer_size; 293 struct rte_mbuf *buf, *tbuf; 294 295 if (options->out_of_place) { 296 buf = sym_op->m_dst; 297 } else { 298 tbuf = sym_op->m_src; 299 while ((tbuf->next != NULL) && 300 (offset >= tbuf->data_len)) { 301 offset -= tbuf->data_len; 302 tbuf = tbuf->next; 303 } 304 /* 305 * If there is not enough room in segment, 306 * place the digest in the next segment 307 */ 308 if ((tbuf->data_len - offset) < options->digest_sz) { 309 tbuf = tbuf->next; 310 offset = 0; 311 } 312 buf = tbuf; 313 } 314 315 sym_op->auth.digest.data = rte_pktmbuf_mtod_offset(buf, 316 uint8_t *, offset); 317 sym_op->auth.digest.phys_addr = 318 rte_pktmbuf_iova_offset(buf, offset); 319 } 320 321 if (options->imix_distribution_count) { 322 sym_op->auth.data.length = 323 options->imix_buffer_sizes[*imix_idx]; 324 *imix_idx = (*imix_idx + 1) % options->pool_sz; 325 } else 326 sym_op->auth.data.length = options->test_buffer_size; 327 328 if (options->auth_algo == RTE_CRYPTO_AUTH_SNOW3G_UIA2 || 329 options->auth_algo == RTE_CRYPTO_AUTH_KASUMI_F9 || 330 options->auth_algo == RTE_CRYPTO_AUTH_ZUC_EIA3) 331 sym_op->auth.data.length <<= 3; 332 333 sym_op->auth.data.offset = 0; 334 } 335 336 if (options->test == CPERF_TEST_TYPE_VERIFY) { 337 for (i = 0; i < nb_ops; i++) { 338 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ops[i], 339 uint8_t *, iv_offset); 340 341 memcpy(iv_ptr, test_vector->cipher_iv.data, 342 test_vector->cipher_iv.length); 343 if (test_vector->auth_iv.length) { 344 /* 345 * Copy IV after the crypto operation and 346 * the cipher IV 347 */ 348 iv_ptr += test_vector->cipher_iv.length; 349 memcpy(iv_ptr, test_vector->auth_iv.data, 350 test_vector->auth_iv.length); 351 } 352 } 353 354 } 355 356 return 0; 357 } 358 359 static int 360 cperf_set_ops_aead(struct rte_crypto_op **ops, 361 uint32_t src_buf_offset, uint32_t dst_buf_offset, 362 uint16_t nb_ops, struct rte_cryptodev_sym_session *sess, 363 const struct cperf_options *options, 364 const struct cperf_test_vector *test_vector, 365 uint16_t iv_offset, uint32_t *imix_idx) 366 { 367 uint16_t i; 368 /* AAD is placed after the IV */ 369 uint16_t aad_offset = iv_offset + 370 RTE_ALIGN_CEIL(test_vector->aead_iv.length, 16); 371 372 for (i = 0; i < nb_ops; i++) { 373 struct rte_crypto_sym_op *sym_op = ops[i]->sym; 374 375 ops[i]->status = RTE_CRYPTO_OP_STATUS_NOT_PROCESSED; 376 rte_crypto_op_attach_sym_session(ops[i], sess); 377 378 sym_op->m_src = (struct rte_mbuf *)((uint8_t *)ops[i] + 379 src_buf_offset); 380 381 /* Set dest mbuf to NULL if out-of-place (dst_buf_offset = 0) */ 382 if (dst_buf_offset == 0) 383 sym_op->m_dst = NULL; 384 else 385 sym_op->m_dst = (struct rte_mbuf *)((uint8_t *)ops[i] + 386 dst_buf_offset); 387 388 /* AEAD parameters */ 389 if (options->imix_distribution_count) { 390 sym_op->aead.data.length = 391 options->imix_buffer_sizes[*imix_idx]; 392 *imix_idx = (*imix_idx + 1) % options->pool_sz; 393 } else 394 sym_op->aead.data.length = options->test_buffer_size; 395 sym_op->aead.data.offset = 0; 396 397 sym_op->aead.aad.data = rte_crypto_op_ctod_offset(ops[i], 398 uint8_t *, aad_offset); 399 sym_op->aead.aad.phys_addr = rte_crypto_op_ctophys_offset(ops[i], 400 aad_offset); 401 402 if (options->aead_op == RTE_CRYPTO_AEAD_OP_DECRYPT) { 403 sym_op->aead.digest.data = test_vector->digest.data; 404 sym_op->aead.digest.phys_addr = 405 test_vector->digest.phys_addr; 406 } else { 407 408 uint32_t offset = sym_op->aead.data.length + 409 sym_op->aead.data.offset; 410 struct rte_mbuf *buf, *tbuf; 411 412 if (options->out_of_place) { 413 buf = sym_op->m_dst; 414 } else { 415 tbuf = sym_op->m_src; 416 while ((tbuf->next != NULL) && 417 (offset >= tbuf->data_len)) { 418 offset -= tbuf->data_len; 419 tbuf = tbuf->next; 420 } 421 /* 422 * If there is not enough room in segment, 423 * place the digest in the next segment 424 */ 425 if ((tbuf->data_len - offset) < options->digest_sz) { 426 tbuf = tbuf->next; 427 offset = 0; 428 } 429 buf = tbuf; 430 } 431 432 sym_op->aead.digest.data = rte_pktmbuf_mtod_offset(buf, 433 uint8_t *, offset); 434 sym_op->aead.digest.phys_addr = 435 rte_pktmbuf_iova_offset(buf, offset); 436 } 437 } 438 439 if (options->test == CPERF_TEST_TYPE_VERIFY) { 440 for (i = 0; i < nb_ops; i++) { 441 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ops[i], 442 uint8_t *, iv_offset); 443 444 /* 445 * If doing AES-CCM, nonce is copied one byte 446 * after the start of IV field, and AAD is copied 447 * 18 bytes after the start of the AAD field. 448 */ 449 if (options->aead_algo == RTE_CRYPTO_AEAD_AES_CCM) { 450 memcpy(iv_ptr + 1, test_vector->aead_iv.data, 451 test_vector->aead_iv.length); 452 453 memcpy(ops[i]->sym->aead.aad.data + 18, 454 test_vector->aad.data, 455 test_vector->aad.length); 456 } else { 457 memcpy(iv_ptr, test_vector->aead_iv.data, 458 test_vector->aead_iv.length); 459 460 memcpy(ops[i]->sym->aead.aad.data, 461 test_vector->aad.data, 462 test_vector->aad.length); 463 } 464 } 465 } 466 467 return 0; 468 } 469 470 static struct rte_cryptodev_sym_session * 471 cperf_create_session(struct rte_mempool *sess_mp, 472 struct rte_mempool *priv_mp, 473 uint8_t dev_id, 474 const struct cperf_options *options, 475 const struct cperf_test_vector *test_vector, 476 uint16_t iv_offset) 477 { 478 struct rte_crypto_sym_xform cipher_xform; 479 struct rte_crypto_sym_xform auth_xform; 480 struct rte_crypto_sym_xform aead_xform; 481 struct rte_cryptodev_sym_session *sess = NULL; 482 483 sess = rte_cryptodev_sym_session_create(sess_mp); 484 /* 485 * cipher only 486 */ 487 if (options->op_type == CPERF_CIPHER_ONLY) { 488 cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER; 489 cipher_xform.next = NULL; 490 cipher_xform.cipher.algo = options->cipher_algo; 491 cipher_xform.cipher.op = options->cipher_op; 492 cipher_xform.cipher.iv.offset = iv_offset; 493 494 /* cipher different than null */ 495 if (options->cipher_algo != RTE_CRYPTO_CIPHER_NULL) { 496 cipher_xform.cipher.key.data = 497 test_vector->cipher_key.data; 498 cipher_xform.cipher.key.length = 499 test_vector->cipher_key.length; 500 cipher_xform.cipher.iv.length = 501 test_vector->cipher_iv.length; 502 } else { 503 cipher_xform.cipher.key.data = NULL; 504 cipher_xform.cipher.key.length = 0; 505 cipher_xform.cipher.iv.length = 0; 506 } 507 /* create crypto session */ 508 rte_cryptodev_sym_session_init(dev_id, sess, &cipher_xform, 509 priv_mp); 510 /* 511 * auth only 512 */ 513 } else if (options->op_type == CPERF_AUTH_ONLY) { 514 auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH; 515 auth_xform.next = NULL; 516 auth_xform.auth.algo = options->auth_algo; 517 auth_xform.auth.op = options->auth_op; 518 auth_xform.auth.iv.offset = iv_offset; 519 520 /* auth different than null */ 521 if (options->auth_algo != RTE_CRYPTO_AUTH_NULL) { 522 auth_xform.auth.digest_length = 523 options->digest_sz; 524 auth_xform.auth.key.length = 525 test_vector->auth_key.length; 526 auth_xform.auth.key.data = test_vector->auth_key.data; 527 auth_xform.auth.iv.length = 528 test_vector->auth_iv.length; 529 } else { 530 auth_xform.auth.digest_length = 0; 531 auth_xform.auth.key.length = 0; 532 auth_xform.auth.key.data = NULL; 533 auth_xform.auth.iv.length = 0; 534 } 535 /* create crypto session */ 536 rte_cryptodev_sym_session_init(dev_id, sess, &auth_xform, 537 priv_mp); 538 /* 539 * cipher and auth 540 */ 541 } else if (options->op_type == CPERF_CIPHER_THEN_AUTH 542 || options->op_type == CPERF_AUTH_THEN_CIPHER) { 543 /* 544 * cipher 545 */ 546 cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER; 547 cipher_xform.next = NULL; 548 cipher_xform.cipher.algo = options->cipher_algo; 549 cipher_xform.cipher.op = options->cipher_op; 550 cipher_xform.cipher.iv.offset = iv_offset; 551 552 /* cipher different than null */ 553 if (options->cipher_algo != RTE_CRYPTO_CIPHER_NULL) { 554 cipher_xform.cipher.key.data = 555 test_vector->cipher_key.data; 556 cipher_xform.cipher.key.length = 557 test_vector->cipher_key.length; 558 cipher_xform.cipher.iv.length = 559 test_vector->cipher_iv.length; 560 } else { 561 cipher_xform.cipher.key.data = NULL; 562 cipher_xform.cipher.key.length = 0; 563 cipher_xform.cipher.iv.length = 0; 564 } 565 566 /* 567 * auth 568 */ 569 auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH; 570 auth_xform.next = NULL; 571 auth_xform.auth.algo = options->auth_algo; 572 auth_xform.auth.op = options->auth_op; 573 auth_xform.auth.iv.offset = iv_offset + 574 cipher_xform.cipher.iv.length; 575 576 /* auth different than null */ 577 if (options->auth_algo != RTE_CRYPTO_AUTH_NULL) { 578 auth_xform.auth.digest_length = options->digest_sz; 579 auth_xform.auth.iv.length = test_vector->auth_iv.length; 580 auth_xform.auth.key.length = 581 test_vector->auth_key.length; 582 auth_xform.auth.key.data = 583 test_vector->auth_key.data; 584 } else { 585 auth_xform.auth.digest_length = 0; 586 auth_xform.auth.key.length = 0; 587 auth_xform.auth.key.data = NULL; 588 auth_xform.auth.iv.length = 0; 589 } 590 591 /* cipher then auth */ 592 if (options->op_type == CPERF_CIPHER_THEN_AUTH) { 593 cipher_xform.next = &auth_xform; 594 /* create crypto session */ 595 rte_cryptodev_sym_session_init(dev_id, 596 sess, &cipher_xform, priv_mp); 597 } else { /* auth then cipher */ 598 auth_xform.next = &cipher_xform; 599 /* create crypto session */ 600 rte_cryptodev_sym_session_init(dev_id, 601 sess, &auth_xform, priv_mp); 602 } 603 } else { /* options->op_type == CPERF_AEAD */ 604 aead_xform.type = RTE_CRYPTO_SYM_XFORM_AEAD; 605 aead_xform.next = NULL; 606 aead_xform.aead.algo = options->aead_algo; 607 aead_xform.aead.op = options->aead_op; 608 aead_xform.aead.iv.offset = iv_offset; 609 610 aead_xform.aead.key.data = 611 test_vector->aead_key.data; 612 aead_xform.aead.key.length = 613 test_vector->aead_key.length; 614 aead_xform.aead.iv.length = test_vector->aead_iv.length; 615 616 aead_xform.aead.digest_length = options->digest_sz; 617 aead_xform.aead.aad_length = 618 options->aead_aad_sz; 619 620 /* Create crypto session */ 621 rte_cryptodev_sym_session_init(dev_id, 622 sess, &aead_xform, priv_mp); 623 } 624 625 return sess; 626 } 627 628 int 629 cperf_get_op_functions(const struct cperf_options *options, 630 struct cperf_op_fns *op_fns) 631 { 632 memset(op_fns, 0, sizeof(struct cperf_op_fns)); 633 634 op_fns->sess_create = cperf_create_session; 635 636 if (options->op_type == CPERF_AEAD) { 637 op_fns->populate_ops = cperf_set_ops_aead; 638 return 0; 639 } 640 641 if (options->op_type == CPERF_AUTH_THEN_CIPHER 642 || options->op_type == CPERF_CIPHER_THEN_AUTH) { 643 op_fns->populate_ops = cperf_set_ops_cipher_auth; 644 return 0; 645 } 646 if (options->op_type == CPERF_AUTH_ONLY) { 647 if (options->auth_algo == RTE_CRYPTO_AUTH_NULL) 648 op_fns->populate_ops = cperf_set_ops_null_auth; 649 else 650 op_fns->populate_ops = cperf_set_ops_auth; 651 return 0; 652 } 653 if (options->op_type == CPERF_CIPHER_ONLY) { 654 if (options->cipher_algo == RTE_CRYPTO_CIPHER_NULL) 655 op_fns->populate_ops = cperf_set_ops_null_cipher; 656 else 657 op_fns->populate_ops = cperf_set_ops_cipher; 658 return 0; 659 } 660 661 return -1; 662 } 663