test/crypto-perf: move IV to crypto op private data

Usually, IV will change for each crypto operation.
Therefore, instead of pointing at the same location,
IV is copied after each crypto operation.

This will let the IV to be passed as an offset from
the beginning of the crypto operation, instead of
a pointer.

Signed-off-by: Pablo de Lara <pablo.de.lara.guarch@intel.com>
Acked-by: Declan Doherty <declan.doherty@intel.com>
Acked-by: Akhil Goyal <akhil.goyal@nxp.com>
Acked-by: Fiona Trahe <fiona.trahe@intel.com>

diff --git a/test/test/test_cryptodev_perf.c b/test/test/test_cryptodev_perf.c
index 7a90667..a959a6c 100644 (file)
--- a/test/test/test_cryptodev_perf.c
+++ b/test/test/test_cryptodev_perf.c
@@ -1,7 +1,7 @@
 /*-
  *   BSD LICENSE
  *
- *   Copyright(c) 2015-2016 Intel Corporation. All rights reserved.
+ *   Copyright(c) 2015-2017 Intel Corporation. All rights reserved.
  *
  *   Redistribution and use in source and binary forms, with or without
  *   modification, are permitted provided that the following conditions
@@ -110,7 +110,6 @@ struct symmetric_session_attrs {
 
 struct crypto_params {
        uint8_t *aad;
-       uint8_t *iv;
        uint8_t *digest;
 };
 
@@ -265,7 +264,8 @@ testsuite_setup(void)
                        RTE_CRYPTO_OP_TYPE_SYMMETRIC,
                        NUM_MBUFS, MBUF_CACHE_SIZE,
                        DEFAULT_NUM_XFORMS *
-                       sizeof(struct rte_crypto_sym_xform),
+                       sizeof(struct rte_crypto_sym_xform) +
+                       MAXIMUM_IV_LENGTH,
                        rte_socket_id());
                if (ts_params->op_mpool == NULL) {
                        RTE_LOG(ERR, USER1, "Can't create CRYPTO_OP_POOL\n");
@@ -1978,19 +1978,20 @@ test_perf_crypto_qp_vary_burst_size(uint16_t dev_num)
                                data_params[0].length);
                op->sym->auth.digest.length = DIGEST_BYTE_LENGTH_SHA256;
 
-               op->sym->auth.data.offset = CIPHER_IV_LENGTH_AES_CBC;
+               op->sym->auth.data.offset = 0;
                op->sym->auth.data.length = data_params[0].length;
 
 
-               op->sym->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(m,
-                               CIPHER_IV_LENGTH_AES_CBC);
-               op->sym->cipher.iv.phys_addr = rte_pktmbuf_mtophys(m);
+               op->sym->cipher.iv.data = rte_crypto_op_ctod_offset(op,
+                               uint8_t *, IV_OFFSET);
+               op->sym->cipher.iv.phys_addr = rte_crypto_op_ctophys_offset(op,
+                               IV_OFFSET);
                op->sym->cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC;
 
                rte_memcpy(op->sym->cipher.iv.data, aes_cbc_128_iv,
                                CIPHER_IV_LENGTH_AES_CBC);
 
-               op->sym->cipher.data.offset = CIPHER_IV_LENGTH_AES_CBC;
+               op->sym->cipher.data.offset = 0;
                op->sym->cipher.data.length = data_params[0].length;
 
                op->sym->m_src = m;
@@ -2887,23 +2888,25 @@ test_perf_set_crypto_op_aes(struct rte_crypto_op *op, struct rte_mbuf *m,
                op->sym->auth.data.length = 0;
        } else {
                op->sym->auth.digest.data = rte_pktmbuf_mtod_offset(m,
-                                uint8_t *, AES_CIPHER_IV_LENGTH + data_len);
+                                uint8_t *, data_len);
                op->sym->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(m,
-                               AES_CIPHER_IV_LENGTH + data_len);
+                               data_len);
                op->sym->auth.digest.length = digest_len;
-               op->sym->auth.data.offset = AES_CIPHER_IV_LENGTH;
+               op->sym->auth.data.offset = 0;
                op->sym->auth.data.length = data_len;
        }
 
 
        /* Cipher Parameters */
-       op->sym->cipher.iv.data = rte_pktmbuf_mtod(m, uint8_t *);
-       op->sym->cipher.iv.phys_addr = rte_pktmbuf_mtophys(m);
+       op->sym->cipher.iv.data = rte_crypto_op_ctod_offset(op,
+                       uint8_t *, IV_OFFSET);
+       op->sym->cipher.iv.phys_addr = rte_crypto_op_ctophys_offset(op,
+                       IV_OFFSET);
        op->sym->cipher.iv.length = AES_CIPHER_IV_LENGTH;
 
        rte_memcpy(op->sym->cipher.iv.data, aes_iv, AES_CIPHER_IV_LENGTH);
 
-       op->sym->cipher.data.offset = AES_CIPHER_IV_LENGTH;
+       op->sym->cipher.data.offset = 0;
        op->sym->cipher.data.length = data_len;
 
        op->sym->m_src = m;
@@ -2931,8 +2934,12 @@ test_perf_set_crypto_op_aes_gcm(struct rte_crypto_op *op, struct rte_mbuf *m,
        op->sym->auth.aad.length = AES_GCM_AAD_LENGTH;
 
        /* Cipher Parameters */
-       op->sym->cipher.iv.data = aes_iv;
+       op->sym->cipher.iv.data = rte_crypto_op_ctod_offset(op,
+                       uint8_t *, IV_OFFSET);
+       op->sym->cipher.iv.phys_addr = rte_crypto_op_ctophys_offset(op,
+                       IV_OFFSET);
        op->sym->cipher.iv.length = AES_CIPHER_IV_LENGTH;
+       rte_memcpy(op->sym->cipher.iv.data, aes_iv, AES_CIPHER_IV_LENGTH);
 
        /* Data lengths/offsets Parameters */
        op->sym->auth.data.offset = 0;
@@ -2951,22 +2958,31 @@ test_perf_set_crypto_op_snow3g(struct rte_crypto_op *op, struct rte_mbuf *m,
                struct rte_cryptodev_sym_session *sess, unsigned data_len,
                unsigned digest_len)
 {
+       uint8_t *iv_ptr = rte_crypto_op_ctod_offset(op,
+                       uint8_t *, IV_OFFSET);
+
        if (rte_crypto_op_attach_sym_session(op, sess) != 0) {
                rte_crypto_op_free(op);
                return NULL;
        }
 
+       rte_memcpy(iv_ptr, snow3g_iv, SNOW3G_CIPHER_IV_LENGTH);
+
        /* Authentication Parameters */
        op->sym->auth.digest.data = (uint8_t *)m->buf_addr +
                                                (m->data_off + data_len);
        op->sym->auth.digest.phys_addr =
                                rte_pktmbuf_mtophys_offset(m, data_len);
        op->sym->auth.digest.length = digest_len;
-       op->sym->auth.aad.data = snow3g_iv;
+       op->sym->auth.aad.data = iv_ptr;
+       op->sym->auth.aad.phys_addr = rte_crypto_op_ctophys_offset(op,
+                       IV_OFFSET);
        op->sym->auth.aad.length = SNOW3G_CIPHER_IV_LENGTH;
 
        /* Cipher Parameters */
-       op->sym->cipher.iv.data = snow3g_iv;
+       op->sym->cipher.iv.data = iv_ptr;
+       op->sym->cipher.iv.phys_addr = rte_crypto_op_ctophys_offset(op,
+                       IV_OFFSET);
        op->sym->cipher.iv.length = SNOW3G_CIPHER_IV_LENGTH;
 
        /* Data lengths/offsets Parameters */
@@ -2993,12 +3009,14 @@ test_perf_set_crypto_op_snow3g_cipher(struct rte_crypto_op *op,
        }
 
        /* Cipher Parameters */
-       op->sym->cipher.iv.data = rte_pktmbuf_mtod(m, uint8_t *);
+       op->sym->cipher.iv.data = rte_crypto_op_ctod_offset(op,
+                       uint8_t *, IV_OFFSET);
+       op->sym->cipher.iv.phys_addr = rte_crypto_op_ctophys_offset(op,
+                       IV_OFFSET);
        op->sym->cipher.iv.length = SNOW3G_CIPHER_IV_LENGTH;
        rte_memcpy(op->sym->cipher.iv.data, snow3g_iv, SNOW3G_CIPHER_IV_LENGTH);
-       op->sym->cipher.iv.phys_addr = rte_pktmbuf_mtophys(m);
 
-       op->sym->cipher.data.offset = SNOW3G_CIPHER_IV_LENGTH;
+       op->sym->cipher.data.offset = 0;
        op->sym->cipher.data.length = data_len << 3;
 
        op->sym->m_src = m;
@@ -3028,14 +3046,16 @@ test_perf_set_crypto_op_snow3g_hash(struct rte_crypto_op *op,
                                rte_pktmbuf_mtophys_offset(m, data_len +
                                        SNOW3G_CIPHER_IV_LENGTH);
        op->sym->auth.digest.length = digest_len;
-       op->sym->auth.aad.data = rte_pktmbuf_mtod(m, uint8_t *);
+       op->sym->auth.aad.data = rte_crypto_op_ctod_offset(op,
+                       uint8_t *, IV_OFFSET);
+       op->sym->auth.aad.phys_addr = rte_crypto_op_ctophys_offset(op,
+                       IV_OFFSET);
        op->sym->auth.aad.length = SNOW3G_CIPHER_IV_LENGTH;
        rte_memcpy(op->sym->auth.aad.data, snow3g_iv,
                        SNOW3G_CIPHER_IV_LENGTH);
-       op->sym->auth.aad.phys_addr = rte_pktmbuf_mtophys(m);
 
        /* Data lengths/offsets Parameters */
-       op->sym->auth.data.offset = SNOW3G_CIPHER_IV_LENGTH;
+       op->sym->auth.data.offset = 0;
        op->sym->auth.data.length = data_len << 3;
 
        op->sym->m_src = m;
@@ -3062,8 +3082,13 @@ test_perf_set_crypto_op_3des(struct rte_crypto_op *op, struct rte_mbuf *m,
        op->sym->auth.digest.length = digest_len;
 
        /* Cipher Parameters */
-       op->sym->cipher.iv.data = triple_des_iv;
+       op->sym->cipher.iv.data = rte_crypto_op_ctod_offset(op,
+                       uint8_t *, IV_OFFSET);
+       op->sym->cipher.iv.phys_addr = rte_crypto_op_ctophys_offset(op,
+                       IV_OFFSET);
        op->sym->cipher.iv.length = TRIPLE_DES_CIPHER_IV_LENGTH;
+       rte_memcpy(op->sym->cipher.iv.data, triple_des_iv,
+                       TRIPLE_DES_CIPHER_IV_LENGTH);
 
        /* Data lengths/offsets Parameters */
        op->sym->auth.data.offset = 0;
@@ -3129,10 +3154,9 @@ test_perf_aes_sha(uint8_t dev_id, uint16_t queue_id,
                        return -1;
                }
 
-               /* Make room for Digest and IV in mbuf */
+               /* Make room for Digest in mbuf */
                if (pparams->chain != CIPHER_ONLY)
                        rte_pktmbuf_append(mbufs[i], digest_length);
-               rte_pktmbuf_prepend(mbufs[i], AES_CIPHER_IV_LENGTH);
        }
 
 
@@ -3253,12 +3277,12 @@ test_perf_snow3g(uint8_t dev_id, uint16_t queue_id,
        /* Generate a burst of crypto operations */
        for (i = 0; i < (pparams->burst_size * NUM_MBUF_SETS); i++) {
                /*
-                * Buffer size + iv/aad len is allocated, for perf tests they
+                * Buffer size is allocated, for perf tests they
                 * are equal + digest len.
                 */
                mbufs[i] = test_perf_create_pktmbuf(
                                ts_params->mbuf_mp,
-                               pparams->buf_size + SNOW3G_CIPHER_IV_LENGTH +
+                               pparams->buf_size  +
                                digest_length);
 
                if (mbufs[i] == NULL) {
@@ -4164,28 +4188,25 @@ perf_gcm_set_crypto_op(struct rte_crypto_op *op, struct rte_mbuf *m,
                return NULL;
        }
 
-       uint16_t iv_pad_len = ALIGN_POW2_ROUNDUP(params->symmetric_op->iv_len,
-                                                16);
-
        op->sym->auth.digest.data = m_hlp->digest;
        op->sym->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
                                          m,
                                          params->symmetric_op->aad_len +
-                                         iv_pad_len +
                                          params->symmetric_op->p_len);
 
        op->sym->auth.digest.length = params->symmetric_op->t_len;
 
        op->sym->auth.aad.data = m_hlp->aad;
        op->sym->auth.aad.length = params->symmetric_op->aad_len;
-       op->sym->auth.aad.phys_addr = rte_pktmbuf_mtophys_offset(
-                                         m,
-                                         iv_pad_len);
+       op->sym->auth.aad.phys_addr = rte_pktmbuf_mtophys(m);
 
        rte_memcpy(op->sym->auth.aad.data, params->symmetric_op->aad_data,
                       params->symmetric_op->aad_len);
 
-       op->sym->cipher.iv.data = m_hlp->iv;
+       op->sym->cipher.iv.data = rte_crypto_op_ctod_offset(op,
+                       uint8_t *, IV_OFFSET);
+       op->sym->cipher.iv.phys_addr = rte_crypto_op_ctophys_offset(op,
+                       IV_OFFSET);
        rte_memcpy(op->sym->cipher.iv.data, params->symmetric_op->iv_data,
                       params->symmetric_op->iv_len);
        if (params->symmetric_op->iv_len == 12)
@@ -4194,11 +4215,11 @@ perf_gcm_set_crypto_op(struct rte_crypto_op *op, struct rte_mbuf *m,
        op->sym->cipher.iv.length = params->symmetric_op->iv_len;
 
        op->sym->auth.data.offset =
-                       iv_pad_len + params->symmetric_op->aad_len;
+                       params->symmetric_op->aad_len;
        op->sym->auth.data.length = params->symmetric_op->p_len;
 
        op->sym->cipher.data.offset =
-                       iv_pad_len + params->symmetric_op->aad_len;
+                       params->symmetric_op->aad_len;
        op->sym->cipher.data.length = params->symmetric_op->p_len;
 
        op->sym->m_src = m;
@@ -4212,8 +4233,6 @@ test_perf_create_pktmbuf_fill(struct rte_mempool *mpool,
                unsigned buf_sz, struct crypto_params *m_hlp)
 {
        struct rte_mbuf *m = rte_pktmbuf_alloc(mpool);
-       uint16_t iv_pad_len =
-                       ALIGN_POW2_ROUNDUP(params->symmetric_op->iv_len, 16);
        uint16_t aad_len = params->symmetric_op->aad_len;
        uint16_t digest_size = params->symmetric_op->t_len;
        char *p;
@@ -4225,13 +4244,6 @@ test_perf_create_pktmbuf_fill(struct rte_mempool *mpool,
        }
        m_hlp->aad = (uint8_t *)p;
 
-       p = rte_pktmbuf_append(m, iv_pad_len);
-       if (p == NULL) {
-               rte_pktmbuf_free(m);
-               return NULL;
-       }
-       m_hlp->iv = (uint8_t *)p;
-
        p = rte_pktmbuf_append(m, buf_sz);
        if (p == NULL) {
                rte_pktmbuf_free(m);
@@ -4350,22 +4362,20 @@ perf_AES_GCM(uint8_t dev_id, uint16_t queue_id,
 
                for (m = 0; m < burst_dequeued; m++) {
                        if (test_ops) {
-                               uint16_t iv_pad_len = ALIGN_POW2_ROUNDUP
-                                       (pparams->symmetric_op->iv_len, 16);
                                uint8_t *pkt = rte_pktmbuf_mtod(
                                        proc_ops[m]->sym->m_src,
                                        uint8_t *);
 
                                TEST_ASSERT_BUFFERS_ARE_EQUAL(
                                        pparams->symmetric_op->c_data,
-                                       pkt + iv_pad_len +
+                                       pkt +
                                        pparams->symmetric_op->aad_len,
                                        pparams->symmetric_op->c_len,
                                        "GCM Ciphertext data not as expected");
 
                                TEST_ASSERT_BUFFERS_ARE_EQUAL(
                                        pparams->symmetric_op->t_data,
-                                       pkt + iv_pad_len +
+                                       pkt +
                                        pparams->symmetric_op->aad_len +
                                        pparams->symmetric_op->c_len,
                                        pparams->symmetric_op->t_len,