app/test-crypto-perf/cperf_ops.c

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