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