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