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