cryptodev: move IV parameters to session

[dpdk.git] / test / test / test_cryptodev.c

diff --git a/test/test/test_cryptodev.c b/test/test/test_cryptodev.c
index 42a7161..5bd55c7 100644 (file)
--- a/test/test/test_cryptodev.c
+++ b/test/test/test_cryptodev.c
@@ -35,6 +35,7 @@
 #include <rte_mbuf.h>
 #include <rte_malloc.h>
 #include <rte_memcpy.h>
+#include <rte_pause.h>
 
 #include <rte_crypto.h>
 #include <rte_cryptodev.h>
@@ -202,7 +203,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");
@@ -219,7 +221,7 @@ testsuite_setup(void)
                nb_devs = rte_cryptodev_count_devtype(
                                RTE_CRYPTODEV_AESNI_MB_PMD);
                if (nb_devs < 1) {
-                       ret = rte_eal_vdev_init(
+                       ret = rte_vdev_init(
                                RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD), NULL);
 
                        TEST_ASSERT(ret == 0,
@@ -239,7 +241,7 @@ testsuite_setup(void)
                nb_devs = rte_cryptodev_count_devtype(
                                RTE_CRYPTODEV_AESNI_GCM_PMD);
                if (nb_devs < 1) {
-                       TEST_ASSERT_SUCCESS(rte_eal_vdev_init(
+                       TEST_ASSERT_SUCCESS(rte_vdev_init(
                                RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD), NULL),
                                "Failed to create instance of"
                                " pmd : %s",
@@ -256,7 +258,7 @@ testsuite_setup(void)
 #endif
                nb_devs = rte_cryptodev_count_devtype(RTE_CRYPTODEV_SNOW3G_PMD);
                if (nb_devs < 1) {
-                       TEST_ASSERT_SUCCESS(rte_eal_vdev_init(
+                       TEST_ASSERT_SUCCESS(rte_vdev_init(
                                RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD), NULL),
                                "Failed to create instance of"
                                " pmd : %s",
@@ -273,7 +275,7 @@ testsuite_setup(void)
 #endif
                nb_devs = rte_cryptodev_count_devtype(RTE_CRYPTODEV_KASUMI_PMD);
                if (nb_devs < 1) {
-                       TEST_ASSERT_SUCCESS(rte_eal_vdev_init(
+                       TEST_ASSERT_SUCCESS(rte_vdev_init(
                                RTE_STR(CRYPTODEV_NAME_KASUMI_PMD), NULL),
                                "Failed to create instance of"
                                " pmd : %s",
@@ -290,7 +292,7 @@ testsuite_setup(void)
 #endif
                nb_devs = rte_cryptodev_count_devtype(RTE_CRYPTODEV_ZUC_PMD);
                if (nb_devs < 1) {
-                       TEST_ASSERT_SUCCESS(rte_eal_vdev_init(
+                       TEST_ASSERT_SUCCESS(rte_vdev_init(
                                RTE_STR(CRYPTODEV_NAME_ZUC_PMD), NULL),
                                "Failed to create instance of"
                                " pmd : %s",
@@ -308,7 +310,7 @@ testsuite_setup(void)
                nb_devs = rte_cryptodev_count_devtype(
                                RTE_CRYPTODEV_NULL_PMD);
                if (nb_devs < 1) {
-                       ret = rte_eal_vdev_init(
+                       ret = rte_vdev_init(
                                RTE_STR(CRYPTODEV_NAME_NULL_PMD), NULL);
 
                        TEST_ASSERT(ret == 0,
@@ -328,7 +330,7 @@ testsuite_setup(void)
                nb_devs = rte_cryptodev_count_devtype(
                                RTE_CRYPTODEV_OPENSSL_PMD);
                if (nb_devs < 1) {
-                       ret = rte_eal_vdev_init(
+                       ret = rte_vdev_init(
                                RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD),
                                NULL);
 
@@ -348,7 +350,7 @@ testsuite_setup(void)
                nb_devs = rte_cryptodev_count_devtype(
                                RTE_CRYPTODEV_ARMV8_PMD);
                if (nb_devs < 1) {
-                       ret = rte_eal_vdev_init(
+                       ret = rte_vdev_init(
                                RTE_STR(CRYPTODEV_NAME_ARMV8_PMD),
                                NULL);
 
@@ -369,7 +371,7 @@ testsuite_setup(void)
                nb_devs = rte_cryptodev_count_devtype(
                                RTE_CRYPTODEV_SCHEDULER_PMD);
                if (nb_devs < 1) {
-                       ret = rte_eal_vdev_init(
+                       ret = rte_vdev_init(
                                RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD),
                                NULL);
 
@@ -1269,6 +1271,8 @@ test_AES_CBC_HMAC_SHA1_encrypt_digest(void)
        ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
        ut_params->cipher_xform.cipher.key.data = aes_cbc_key;
        ut_params->cipher_xform.cipher.key.length = CIPHER_KEY_LENGTH_AES_CBC;
+       ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
+       ut_params->cipher_xform.cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC;
 
        /* Setup HMAC Parameters */
        ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
@@ -1306,19 +1310,15 @@ test_AES_CBC_HMAC_SHA1_encrypt_digest(void)
                        ut_params->ibuf, QUOTE_512_BYTES);
        sym_op->auth.digest.length = DIGEST_BYTE_LENGTH_SHA1;
 
-       sym_op->auth.data.offset = CIPHER_IV_LENGTH_AES_CBC;
+       sym_op->auth.data.offset = 0;
        sym_op->auth.data.length = QUOTE_512_BYTES;
 
-       /* Set crypto operation cipher parameters */
-       sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(ut_params->ibuf,
-                       CIPHER_IV_LENGTH_AES_CBC);
-       sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
-       sym_op->cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC;
-
-       rte_memcpy(sym_op->cipher.iv.data, aes_cbc_iv,
-                       CIPHER_IV_LENGTH_AES_CBC);
+       /* Copy IV at the end of the crypto operation */
+       rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
+                       aes_cbc_iv, CIPHER_IV_LENGTH_AES_CBC);
 
-       sym_op->cipher.data.offset = CIPHER_IV_LENGTH_AES_CBC;
+       /* Set crypto operation cipher parameters */
+       sym_op->cipher.data.offset = 0;
        sym_op->cipher.data.length = QUOTE_512_BYTES;
 
        /* Process crypto operation */
@@ -1329,8 +1329,8 @@ test_AES_CBC_HMAC_SHA1_encrypt_digest(void)
                        "crypto op processing failed");
 
        /* Validate obuf */
-       uint8_t *ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src,
-                       uint8_t *, CIPHER_IV_LENGTH_AES_CBC);
+       uint8_t *ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_src,
+                       uint8_t *);
 
        TEST_ASSERT_BUFFERS_ARE_EQUAL(ciphertext,
                        catch_22_quote_2_512_bytes_AES_CBC_ciphertext,
@@ -1405,6 +1405,8 @@ test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
        ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT;
        ut_params->cipher_xform.cipher.key.data = cipher_key;
        ut_params->cipher_xform.cipher.key.length = CIPHER_KEY_LENGTH_AES_CBC;
+       ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
+       ut_params->cipher_xform.cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC;
 
        /* Setup HMAC Parameters */
        ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
@@ -1460,19 +1462,14 @@ test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess,
                        ut_params->ibuf, QUOTE_512_BYTES);
        sym_op->auth.digest.length = DIGEST_BYTE_LENGTH_SHA512;
 
-       sym_op->auth.data.offset = CIPHER_IV_LENGTH_AES_CBC;
+       sym_op->auth.data.offset = 0;
        sym_op->auth.data.length = QUOTE_512_BYTES;
 
-       sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(
-                       ut_params->ibuf, CIPHER_IV_LENGTH_AES_CBC);
-       sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys_offset(
-                       ut_params->ibuf, 0);
-       sym_op->cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC;
+       /* Copy IV at the end of the crypto operation */
+       rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
+                       iv, CIPHER_IV_LENGTH_AES_CBC);
 
-       rte_memcpy(sym_op->cipher.iv.data, iv,
-                       CIPHER_IV_LENGTH_AES_CBC);
-
-       sym_op->cipher.data.offset = CIPHER_IV_LENGTH_AES_CBC;
+       sym_op->cipher.data.offset = 0;
        sym_op->cipher.data.length = QUOTE_512_BYTES;
 
        /* Process crypto operation */
@@ -1486,8 +1483,8 @@ test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess,
 
        /* Validate obuf */
        TEST_ASSERT_BUFFERS_ARE_EQUAL(
-                       rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) +
-                       CIPHER_IV_LENGTH_AES_CBC, catch_22_quote,
+                       rte_pktmbuf_mtod(ut_params->obuf, uint8_t *),
+                       catch_22_quote,
                        QUOTE_512_BYTES,
                        "Plaintext data not as expected");
 
@@ -1810,7 +1807,8 @@ static int
 create_wireless_algo_cipher_session(uint8_t dev_id,
                        enum rte_crypto_cipher_operation op,
                        enum rte_crypto_cipher_algorithm algo,
-                       const uint8_t *key, const uint8_t key_len)
+                       const uint8_t *key, const uint8_t key_len,
+                       uint8_t iv_len)
 {
        uint8_t cipher_key[key_len];
 
@@ -1826,6 +1824,8 @@ create_wireless_algo_cipher_session(uint8_t dev_id,
        ut_params->cipher_xform.cipher.op = op;
        ut_params->cipher_xform.cipher.key.data = cipher_key;
        ut_params->cipher_xform.cipher.key.length = key_len;
+       ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
+       ut_params->cipher_xform.cipher.iv.length = iv_len;
 
        TEST_HEXDUMP(stdout, "key:", key, key_len);
 
@@ -1838,14 +1838,12 @@ create_wireless_algo_cipher_session(uint8_t dev_id,
 }
 
 static int
-create_wireless_algo_cipher_operation(const uint8_t *iv, const unsigned iv_len,
-                       const unsigned cipher_len,
-                       const unsigned cipher_offset,
-                       enum rte_crypto_cipher_algorithm algo)
+create_wireless_algo_cipher_operation(const uint8_t *iv, uint8_t iv_len,
+                       unsigned int cipher_len,
+                       unsigned int cipher_offset)
 {
        struct crypto_testsuite_params *ts_params = &testsuite_params;
        struct crypto_unittest_params *ut_params = &unittest_params;
-       unsigned iv_pad_len = 0;
 
        /* Generate Crypto op data structure */
        ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
@@ -1862,35 +1860,20 @@ create_wireless_algo_cipher_operation(const uint8_t *iv, const unsigned iv_len,
        sym_op->m_src = ut_params->ibuf;
 
        /* iv */
-       if (algo == RTE_CRYPTO_CIPHER_KASUMI_F8)
-               iv_pad_len = RTE_ALIGN_CEIL(iv_len, 8);
-       else
-               iv_pad_len = RTE_ALIGN_CEIL(iv_len, 16);
-
-       sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(ut_params->ibuf
-                       , iv_pad_len);
-
-       TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data, "no room to prepend iv");
-
-       memset(sym_op->cipher.iv.data, 0, iv_pad_len);
-       sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
-       sym_op->cipher.iv.length = iv_pad_len;
-
-       rte_memcpy(sym_op->cipher.iv.data, iv, iv_len);
+       rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
+                       iv, iv_len);
        sym_op->cipher.data.length = cipher_len;
        sym_op->cipher.data.offset = cipher_offset;
        return 0;
 }
 
 static int
-create_wireless_algo_cipher_operation_oop(const uint8_t *iv, const uint8_t iv_len,
-                       const unsigned cipher_len,
-                       const unsigned cipher_offset,
-                       enum rte_crypto_cipher_algorithm algo)
+create_wireless_algo_cipher_operation_oop(const uint8_t *iv, uint8_t iv_len,
+                       unsigned int cipher_len,
+                       unsigned int cipher_offset)
 {
        struct crypto_testsuite_params *ts_params = &testsuite_params;
        struct crypto_unittest_params *ut_params = &unittest_params;
-       unsigned iv_pad_len = 0;
 
        /* Generate Crypto op data structure */
        ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
@@ -1908,24 +1891,8 @@ create_wireless_algo_cipher_operation_oop(const uint8_t *iv, const uint8_t iv_le
        sym_op->m_dst = ut_params->obuf;
 
        /* iv */
-       if (algo == RTE_CRYPTO_CIPHER_KASUMI_F8)
-               iv_pad_len = RTE_ALIGN_CEIL(iv_len, 8);
-       else
-               iv_pad_len = RTE_ALIGN_CEIL(iv_len, 16);
-       sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(ut_params->ibuf,
-                                       iv_pad_len);
-
-       TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data, "no room to prepend iv");
-
-       /* For OOP operation both buffers must have the same size */
-       if (ut_params->obuf)
-               rte_pktmbuf_prepend(ut_params->obuf, iv_pad_len);
-
-       memset(sym_op->cipher.iv.data, 0, iv_pad_len);
-       sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
-       sym_op->cipher.iv.length = iv_pad_len;
-
-       rte_memcpy(sym_op->cipher.iv.data, iv, iv_len);
+       rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
+                       iv, iv_len);
        sym_op->cipher.data.length = cipher_len;
        sym_op->cipher.data.offset = cipher_offset;
        return 0;
@@ -1938,7 +1905,8 @@ create_wireless_algo_cipher_auth_session(uint8_t dev_id,
                enum rte_crypto_auth_algorithm auth_algo,
                enum rte_crypto_cipher_algorithm cipher_algo,
                const uint8_t *key, const uint8_t key_len,
-               const uint8_t aad_len, const uint8_t auth_len)
+               const uint8_t aad_len, const uint8_t auth_len,
+               uint8_t iv_len)
 
 {
        uint8_t cipher_auth_key[key_len];
@@ -1967,6 +1935,8 @@ create_wireless_algo_cipher_auth_session(uint8_t dev_id,
        ut_params->cipher_xform.cipher.op = cipher_op;
        ut_params->cipher_xform.cipher.key.data = cipher_auth_key;
        ut_params->cipher_xform.cipher.key.length = key_len;
+       ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
+       ut_params->cipher_xform.cipher.iv.length = iv_len;
 
        TEST_HEXDUMP(stdout, "key:", key, key_len);
 
@@ -1993,6 +1963,7 @@ create_wireless_cipher_auth_session(uint8_t dev_id,
        const uint8_t *key = tdata->key.data;
        const uint8_t aad_len = tdata->aad.len;
        const uint8_t auth_len = tdata->digest.len;
+       uint8_t iv_len = tdata->iv.len;
 
        memcpy(cipher_auth_key, key, key_len);
 
@@ -2016,6 +1987,9 @@ create_wireless_cipher_auth_session(uint8_t dev_id,
        ut_params->cipher_xform.cipher.op = cipher_op;
        ut_params->cipher_xform.cipher.key.data = cipher_auth_key;
        ut_params->cipher_xform.cipher.key.length = key_len;
+       ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
+       ut_params->cipher_xform.cipher.iv.length = iv_len;
+
 
        TEST_HEXDUMP(stdout, "key:", key, key_len);
 
@@ -2044,7 +2018,8 @@ create_wireless_algo_auth_cipher_session(uint8_t dev_id,
                enum rte_crypto_auth_algorithm auth_algo,
                enum rte_crypto_cipher_algorithm cipher_algo,
                const uint8_t *key, const uint8_t key_len,
-               const uint8_t aad_len, const uint8_t auth_len)
+               const uint8_t aad_len, const uint8_t auth_len,
+               uint8_t iv_len)
 {
        uint8_t auth_cipher_key[key_len];
 
@@ -2069,6 +2044,8 @@ create_wireless_algo_auth_cipher_session(uint8_t dev_id,
        ut_params->cipher_xform.cipher.op = cipher_op;
        ut_params->cipher_xform.cipher.key.data = auth_cipher_key;
        ut_params->cipher_xform.cipher.key.length = key_len;
+       ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
+       ut_params->cipher_xform.cipher.iv.length = iv_len;
 
        TEST_HEXDUMP(stdout, "key:", key, key_len);
 
@@ -2164,8 +2141,7 @@ create_wireless_algo_hash_operation(const uint8_t *auth_tag,
 static int
 create_wireless_cipher_hash_operation(const struct wireless_test_data *tdata,
        enum rte_crypto_auth_operation op,
-       enum rte_crypto_auth_algorithm auth_algo,
-       enum rte_crypto_cipher_algorithm cipher_algo)
+       enum rte_crypto_auth_algorithm auth_algo)
 {
        struct crypto_testsuite_params *ts_params = &testsuite_params;
        struct crypto_unittest_params *ut_params = &unittest_params;
@@ -2180,12 +2156,10 @@ create_wireless_cipher_hash_operation(const struct wireless_test_data *tdata,
        const uint8_t *iv = tdata->iv.data;
        const uint8_t iv_len = tdata->iv.len;
        const unsigned int cipher_len = tdata->validCipherLenInBits.len;
-       const unsigned int cipher_offset =
-               tdata->validCipherOffsetLenInBits.len;
+       const unsigned int cipher_offset = 0;
        const unsigned int auth_len = tdata->validAuthLenInBits.len;
-       const unsigned int auth_offset = tdata->validAuthOffsetLenInBits.len;
+       const unsigned int auth_offset = tdata->aad.len << 3;
 
-       unsigned int iv_pad_len = 0;
        unsigned int aad_buffer_len;
 
        /* Generate Crypto op data structure */
@@ -2245,18 +2219,8 @@ create_wireless_cipher_hash_operation(const struct wireless_test_data *tdata,
        TEST_HEXDUMP(stdout, "aad:", sym_op->auth.aad.data, aad_len);
 
        /* iv */
-       if (cipher_algo == RTE_CRYPTO_CIPHER_KASUMI_F8)
-               iv_pad_len = RTE_ALIGN_CEIL(iv_len, 8);
-       else
-               iv_pad_len = RTE_ALIGN_CEIL(iv_len, 16);
-       sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(
-               ut_params->ibuf, iv_pad_len);
-
-       TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data, "no room to prepend iv");
-       memset(sym_op->cipher.iv.data, 0, iv_pad_len);
-       sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
-       sym_op->cipher.iv.length = iv_pad_len;
-       rte_memcpy(sym_op->cipher.iv.data, iv, iv_len);
+       rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
+                       iv, iv_len);
        sym_op->cipher.data.length = cipher_len;
        sym_op->cipher.data.offset = cipher_offset + auth_offset;
        sym_op->auth.data.length = auth_len;
@@ -2271,8 +2235,7 @@ create_zuc_cipher_hash_generate_operation(
 {
        return create_wireless_cipher_hash_operation(tdata,
                RTE_CRYPTO_AUTH_OP_GENERATE,
-               RTE_CRYPTO_AUTH_ZUC_EIA3,
-               RTE_CRYPTO_CIPHER_ZUC_EEA3);
+               RTE_CRYPTO_AUTH_ZUC_EIA3);
 }
 
 static int
@@ -2282,7 +2245,6 @@ create_wireless_algo_cipher_hash_operation(const uint8_t *auth_tag,
                unsigned data_pad_len,
                enum rte_crypto_auth_operation op,
                enum rte_crypto_auth_algorithm auth_algo,
-               enum rte_crypto_cipher_algorithm cipher_algo,
                const uint8_t *iv, const uint8_t iv_len,
                const unsigned cipher_len, const unsigned cipher_offset,
                const unsigned auth_len, const unsigned auth_offset)
@@ -2290,7 +2252,6 @@ create_wireless_algo_cipher_hash_operation(const uint8_t *auth_tag,
        struct crypto_testsuite_params *ts_params = &testsuite_params;
        struct crypto_unittest_params *ut_params = &unittest_params;
 
-       unsigned iv_pad_len = 0;
        unsigned aad_buffer_len;
 
        /* Generate Crypto op data structure */
@@ -2350,18 +2311,8 @@ create_wireless_algo_cipher_hash_operation(const uint8_t *auth_tag,
        TEST_HEXDUMP(stdout, "aad:", sym_op->auth.aad.data, aad_len);
 
        /* iv */
-       if (cipher_algo == RTE_CRYPTO_CIPHER_KASUMI_F8)
-               iv_pad_len = RTE_ALIGN_CEIL(iv_len, 8);
-       else
-               iv_pad_len = RTE_ALIGN_CEIL(iv_len, 16);
-       sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(
-               ut_params->ibuf, iv_pad_len);
-
-       TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data, "no room to prepend iv");
-       memset(sym_op->cipher.iv.data, 0, iv_pad_len);
-       sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
-       sym_op->cipher.iv.length = iv_pad_len;
-       rte_memcpy(sym_op->cipher.iv.data, iv, iv_len);
+       rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
+                       iv, iv_len);
        sym_op->cipher.data.length = cipher_len;
        sym_op->cipher.data.offset = cipher_offset + auth_offset;
        sym_op->auth.data.length = auth_len;
@@ -2377,13 +2328,11 @@ create_wireless_algo_auth_cipher_operation(const unsigned auth_tag_len,
                unsigned data_pad_len,
                const unsigned cipher_len, const unsigned cipher_offset,
                const unsigned auth_len, const unsigned auth_offset,
-               enum rte_crypto_auth_algorithm auth_algo,
-               enum rte_crypto_cipher_algorithm cipher_algo)
+               enum rte_crypto_auth_algorithm auth_algo)
 {
        struct crypto_testsuite_params *ts_params = &testsuite_params;
        struct crypto_unittest_params *ut_params = &unittest_params;
 
-       unsigned iv_pad_len = 0;
        unsigned aad_buffer_len = 0;
 
        /* Generate Crypto op data structure */
@@ -2442,21 +2391,8 @@ create_wireless_algo_auth_cipher_operation(const unsigned auth_tag_len,
                        sym_op->auth.aad.data, aad_len);
 
        /* iv */
-       if (cipher_algo == RTE_CRYPTO_CIPHER_KASUMI_F8)
-               iv_pad_len = RTE_ALIGN_CEIL(iv_len, 8);
-       else
-               iv_pad_len = RTE_ALIGN_CEIL(iv_len, 16);
-
-       sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(
-               ut_params->ibuf, iv_pad_len);
-       TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data, "no room to prepend iv");
-
-       memset(sym_op->cipher.iv.data, 0, iv_pad_len);
-       sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
-       sym_op->cipher.iv.length = iv_pad_len;
-
-       rte_memcpy(sym_op->cipher.iv.data, iv, iv_len);
-
+       rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
+                       iv, iv_len);
        sym_op->cipher.data.length = cipher_len;
        sym_op->cipher.data.offset = auth_offset + cipher_offset;
 
@@ -2506,7 +2442,7 @@ test_snow3g_authentication(const struct snow3g_hash_test_data *tdata)
                        plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
                        RTE_CRYPTO_AUTH_SNOW3G_UIA2,
                        tdata->validAuthLenInBits.len,
-                       tdata->validAuthOffsetLenInBits.len);
+                       (tdata->aad.len << 3));
        if (retval < 0)
                return retval;
 
@@ -2568,7 +2504,7 @@ test_snow3g_authentication_verify(const struct snow3g_hash_test_data *tdata)
                        RTE_CRYPTO_AUTH_OP_VERIFY,
                        RTE_CRYPTO_AUTH_SNOW3G_UIA2,
                        tdata->validAuthLenInBits.len,
-                       tdata->validAuthOffsetLenInBits.len);
+                       (tdata->aad.len << 3));
        if (retval < 0)
                return retval;
 
@@ -2628,7 +2564,7 @@ test_kasumi_authentication(const struct kasumi_hash_test_data *tdata)
                        plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
                        RTE_CRYPTO_AUTH_KASUMI_F9,
                        tdata->validAuthLenInBits.len,
-                       tdata->validAuthOffsetLenInBits.len);
+                       (tdata->aad.len << 3));
        if (retval < 0)
                return retval;
 
@@ -2690,7 +2626,7 @@ test_kasumi_authentication_verify(const struct kasumi_hash_test_data *tdata)
                        RTE_CRYPTO_AUTH_OP_VERIFY,
                        RTE_CRYPTO_AUTH_KASUMI_F9,
                        tdata->validAuthLenInBits.len,
-                       tdata->validAuthOffsetLenInBits.len);
+                       (tdata->aad.len << 3));
        if (retval < 0)
                return retval;
 
@@ -2864,7 +2800,8 @@ test_kasumi_encryption(const struct kasumi_test_data *tdata)
        retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
                                        RTE_CRYPTO_CIPHER_OP_ENCRYPT,
                                        RTE_CRYPTO_CIPHER_KASUMI_F8,
-                                       tdata->key.data, tdata->key.len);
+                                       tdata->key.data, tdata->key.len,
+                                       tdata->iv.len);
        if (retval < 0)
                return retval;
 
@@ -2887,8 +2824,7 @@ test_kasumi_encryption(const struct kasumi_test_data *tdata)
        /* Create KASUMI operation */
        retval = create_wireless_algo_cipher_operation(tdata->iv.data, tdata->iv.len,
                                        tdata->plaintext.len,
-                                       tdata->validCipherOffsetLenInBits.len,
-                                       RTE_CRYPTO_CIPHER_KASUMI_F8);
+                                       0);
        if (retval < 0)
                return retval;
 
@@ -2898,8 +2834,7 @@ test_kasumi_encryption(const struct kasumi_test_data *tdata)
 
        ut_params->obuf = ut_params->op->sym->m_dst;
        if (ut_params->obuf)
-               ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
-                               + tdata->iv.len;
+               ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
        else
                ciphertext = plaintext;
 
@@ -2941,7 +2876,8 @@ test_kasumi_encryption_sgl(const struct kasumi_test_data *tdata)
        retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
                                        RTE_CRYPTO_CIPHER_OP_ENCRYPT,
                                        RTE_CRYPTO_CIPHER_KASUMI_F8,
-                                       tdata->key.data, tdata->key.len);
+                                       tdata->key.data, tdata->key.len,
+                                       tdata->iv.len);
        if (retval < 0)
                return retval;
 
@@ -2961,8 +2897,7 @@ test_kasumi_encryption_sgl(const struct kasumi_test_data *tdata)
        retval = create_wireless_algo_cipher_operation(tdata->iv.data,
                                        tdata->iv.len,
                                        tdata->plaintext.len,
-                                       tdata->validCipherOffsetLenInBits.len,
-                                       RTE_CRYPTO_CIPHER_KASUMI_F8);
+                                       0);
        if (retval < 0)
                return retval;
 
@@ -2973,10 +2908,10 @@ test_kasumi_encryption_sgl(const struct kasumi_test_data *tdata)
        ut_params->obuf = ut_params->op->sym->m_dst;
 
        if (ut_params->obuf)
-               ciphertext = rte_pktmbuf_read(ut_params->obuf, tdata->iv.len,
+               ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
                                plaintext_len, buffer);
        else
-               ciphertext = rte_pktmbuf_read(ut_params->ibuf, tdata->iv.len,
+               ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
                                plaintext_len, buffer);
 
        /* Validate obuf */
@@ -3006,7 +2941,8 @@ test_kasumi_encryption_oop(const struct kasumi_test_data *tdata)
        retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
                                        RTE_CRYPTO_CIPHER_OP_ENCRYPT,
                                        RTE_CRYPTO_CIPHER_KASUMI_F8,
-                                       tdata->key.data, tdata->key.len);
+                                       tdata->key.data, tdata->key.len,
+                                       tdata->iv.len);
        if (retval < 0)
                return retval;
 
@@ -3032,8 +2968,7 @@ test_kasumi_encryption_oop(const struct kasumi_test_data *tdata)
        retval = create_wireless_algo_cipher_operation_oop(tdata->iv.data,
                                        tdata->iv.len,
                                        tdata->plaintext.len,
-                                       tdata->validCipherOffsetLenInBits.len,
-                                       RTE_CRYPTO_CIPHER_KASUMI_F8);
+                                       0);
        if (retval < 0)
                return retval;
 
@@ -3043,8 +2978,7 @@ test_kasumi_encryption_oop(const struct kasumi_test_data *tdata)
 
        ut_params->obuf = ut_params->op->sym->m_dst;
        if (ut_params->obuf)
-               ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
-                               + tdata->iv.len;
+               ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
        else
                ciphertext = plaintext;
 
@@ -3085,7 +3019,8 @@ test_kasumi_encryption_oop_sgl(const struct kasumi_test_data *tdata)
        retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
                                        RTE_CRYPTO_CIPHER_OP_ENCRYPT,
                                        RTE_CRYPTO_CIPHER_KASUMI_F8,
-                                       tdata->key.data, tdata->key.len);
+                                       tdata->key.data, tdata->key.len,
+                                       tdata->iv.len);
        if (retval < 0)
                return retval;
 
@@ -3107,8 +3042,7 @@ test_kasumi_encryption_oop_sgl(const struct kasumi_test_data *tdata)
        retval = create_wireless_algo_cipher_operation_oop(tdata->iv.data,
                                        tdata->iv.len,
                                        tdata->plaintext.len,
-                                       tdata->validCipherOffsetLenInBits.len,
-                                       RTE_CRYPTO_CIPHER_KASUMI_F8);
+                                       0);
        if (retval < 0)
                return retval;
 
@@ -3118,10 +3052,10 @@ test_kasumi_encryption_oop_sgl(const struct kasumi_test_data *tdata)
 
        ut_params->obuf = ut_params->op->sym->m_dst;
        if (ut_params->obuf)
-               ciphertext = rte_pktmbuf_read(ut_params->obuf, tdata->iv.len,
+               ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
                                plaintext_pad_len, buffer);
        else
-               ciphertext = rte_pktmbuf_read(ut_params->ibuf, tdata->iv.len,
+               ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
                                plaintext_pad_len, buffer);
 
        /* Validate obuf */
@@ -3149,7 +3083,8 @@ test_kasumi_decryption_oop(const struct kasumi_test_data *tdata)
        retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
                                        RTE_CRYPTO_CIPHER_OP_DECRYPT,
                                        RTE_CRYPTO_CIPHER_KASUMI_F8,
-                                       tdata->key.data, tdata->key.len);
+                                       tdata->key.data, tdata->key.len,
+                                       tdata->iv.len);
        if (retval < 0)
                return retval;
 
@@ -3175,8 +3110,7 @@ test_kasumi_decryption_oop(const struct kasumi_test_data *tdata)
        retval = create_wireless_algo_cipher_operation_oop(tdata->iv.data,
                                        tdata->iv.len,
                                        tdata->ciphertext.len,
-                                       tdata->validCipherOffsetLenInBits.len,
-                                       RTE_CRYPTO_CIPHER_KASUMI_F8);
+                                       0);
        if (retval < 0)
                return retval;
 
@@ -3186,8 +3120,7 @@ test_kasumi_decryption_oop(const struct kasumi_test_data *tdata)
 
        ut_params->obuf = ut_params->op->sym->m_dst;
        if (ut_params->obuf)
-               plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
-                               + tdata->iv.len;
+               plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
        else
                plaintext = ciphertext;
 
@@ -3217,7 +3150,8 @@ test_kasumi_decryption(const struct kasumi_test_data *tdata)
        retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
                                        RTE_CRYPTO_CIPHER_OP_DECRYPT,
                                        RTE_CRYPTO_CIPHER_KASUMI_F8,
-                                       tdata->key.data, tdata->key.len);
+                                       tdata->key.data, tdata->key.len,
+                                       tdata->iv.len);
        if (retval < 0)
                return retval;
 
@@ -3241,8 +3175,7 @@ test_kasumi_decryption(const struct kasumi_test_data *tdata)
        retval = create_wireless_algo_cipher_operation(tdata->iv.data,
                                        tdata->iv.len,
                                        tdata->ciphertext.len,
-                                       tdata->validCipherOffsetLenInBits.len,
-                                       RTE_CRYPTO_CIPHER_KASUMI_F8);
+                                       0);
        if (retval < 0)
                return retval;
 
@@ -3252,8 +3185,7 @@ test_kasumi_decryption(const struct kasumi_test_data *tdata)
 
        ut_params->obuf = ut_params->op->sym->m_dst;
        if (ut_params->obuf)
-               plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
-                               + tdata->iv.len;
+               plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
        else
                plaintext = ciphertext;
 
@@ -3283,7 +3215,8 @@ test_snow3g_encryption(const struct snow3g_test_data *tdata)
        retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
                                        RTE_CRYPTO_CIPHER_OP_ENCRYPT,
                                        RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
-                                       tdata->key.data, tdata->key.len);
+                                       tdata->key.data, tdata->key.len,
+                                       tdata->iv.len);
        if (retval < 0)
                return retval;
 
@@ -3306,8 +3239,7 @@ test_snow3g_encryption(const struct snow3g_test_data *tdata)
        /* Create SNOW 3G operation */
        retval = create_wireless_algo_cipher_operation(tdata->iv.data, tdata->iv.len,
                                        tdata->validCipherLenInBits.len,
-                                       tdata->validCipherOffsetLenInBits.len,
-                                       RTE_CRYPTO_CIPHER_SNOW3G_UEA2);
+                                       0);
        if (retval < 0)
                return retval;
 
@@ -3317,8 +3249,7 @@ test_snow3g_encryption(const struct snow3g_test_data *tdata)
 
        ut_params->obuf = ut_params->op->sym->m_dst;
        if (ut_params->obuf)
-               ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
-                               + tdata->iv.len;
+               ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
        else
                ciphertext = plaintext;
 
@@ -3349,7 +3280,8 @@ test_snow3g_encryption_oop(const struct snow3g_test_data *tdata)
        retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
                                        RTE_CRYPTO_CIPHER_OP_ENCRYPT,
                                        RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
-                                       tdata->key.data, tdata->key.len);
+                                       tdata->key.data, tdata->key.len,
+                                       tdata->iv.len);
        if (retval < 0)
                return retval;
 
@@ -3380,8 +3312,7 @@ test_snow3g_encryption_oop(const struct snow3g_test_data *tdata)
        retval = create_wireless_algo_cipher_operation_oop(tdata->iv.data,
                                        tdata->iv.len,
                                        tdata->validCipherLenInBits.len,
-                                       tdata->validCipherOffsetLenInBits.len,
-                                       RTE_CRYPTO_CIPHER_SNOW3G_UEA2);
+                                       0);
        if (retval < 0)
                return retval;
 
@@ -3391,8 +3322,7 @@ test_snow3g_encryption_oop(const struct snow3g_test_data *tdata)
 
        ut_params->obuf = ut_params->op->sym->m_dst;
        if (ut_params->obuf)
-               ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
-                               + tdata->iv.len;
+               ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
        else
                ciphertext = plaintext;
 
@@ -3432,7 +3362,8 @@ test_snow3g_encryption_oop_sgl(const struct snow3g_test_data *tdata)
        retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
                                        RTE_CRYPTO_CIPHER_OP_ENCRYPT,
                                        RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
-                                       tdata->key.data, tdata->key.len);
+                                       tdata->key.data, tdata->key.len,
+                                       tdata->iv.len);
        if (retval < 0)
                return retval;
 
@@ -3457,8 +3388,7 @@ test_snow3g_encryption_oop_sgl(const struct snow3g_test_data *tdata)
        retval = create_wireless_algo_cipher_operation_oop(tdata->iv.data,
                                        tdata->iv.len,
                                        tdata->validCipherLenInBits.len,
-                                       tdata->validCipherOffsetLenInBits.len,
-                                       RTE_CRYPTO_CIPHER_SNOW3G_UEA2);
+                                       0);
        if (retval < 0)
                return retval;
 
@@ -3468,10 +3398,10 @@ test_snow3g_encryption_oop_sgl(const struct snow3g_test_data *tdata)
 
        ut_params->obuf = ut_params->op->sym->m_dst;
        if (ut_params->obuf)
-               ciphertext = rte_pktmbuf_read(ut_params->obuf, tdata->iv.len,
+               ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
                                plaintext_len, buffer);
        else
-               ciphertext = rte_pktmbuf_read(ut_params->ibuf, tdata->iv.len,
+               ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
                                plaintext_len, buffer);
 
        TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len);
@@ -3522,7 +3452,8 @@ test_snow3g_encryption_offset_oop(const struct snow3g_test_data *tdata)
        retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
                                        RTE_CRYPTO_CIPHER_OP_ENCRYPT,
                                        RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
-                                       tdata->key.data, tdata->key.len);
+                                       tdata->key.data, tdata->key.len,
+                                       tdata->iv.len);
        if (retval < 0)
                return retval;
 
@@ -3560,9 +3491,7 @@ test_snow3g_encryption_offset_oop(const struct snow3g_test_data *tdata)
        retval = create_wireless_algo_cipher_operation_oop(tdata->iv.data,
                                        tdata->iv.len,
                                        tdata->validCipherLenInBits.len,
-                                       tdata->validCipherOffsetLenInBits.len +
-                                       extra_offset,
-                                       RTE_CRYPTO_CIPHER_SNOW3G_UEA2);
+                                       extra_offset);
        if (retval < 0)
                return retval;
 
@@ -3572,8 +3501,7 @@ test_snow3g_encryption_offset_oop(const struct snow3g_test_data *tdata)
 
        ut_params->obuf = ut_params->op->sym->m_dst;
        if (ut_params->obuf)
-               ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
-                               + tdata->iv.len;
+               ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
        else
                ciphertext = plaintext;
 
@@ -3581,8 +3509,7 @@ test_snow3g_encryption_offset_oop(const struct snow3g_test_data *tdata)
        rte_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
 #endif
 
-       expected_ciphertext_shifted = rte_malloc(NULL,
-                       ceil_byte_length(plaintext_len + extra_offset), 0);
+       expected_ciphertext_shifted = rte_malloc(NULL, plaintext_len, 8);
 
        TEST_ASSERT_NOT_NULL(expected_ciphertext_shifted,
                        "failed to reserve memory for ciphertext shifted\n");
@@ -3616,7 +3543,8 @@ static int test_snow3g_decryption(const struct snow3g_test_data *tdata)
        retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
                                        RTE_CRYPTO_CIPHER_OP_DECRYPT,
                                        RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
-                                       tdata->key.data, tdata->key.len);
+                                       tdata->key.data, tdata->key.len,
+                                       tdata->iv.len);
        if (retval < 0)
                return retval;
 
@@ -3639,8 +3567,7 @@ static int test_snow3g_decryption(const struct snow3g_test_data *tdata)
        /* Create SNOW 3G operation */
        retval = create_wireless_algo_cipher_operation(tdata->iv.data, tdata->iv.len,
                                        tdata->validCipherLenInBits.len,
-                                       tdata->validCipherOffsetLenInBits.len,
-                                       RTE_CRYPTO_CIPHER_SNOW3G_UEA2);
+                                       0);
        if (retval < 0)
                return retval;
 
@@ -3649,8 +3576,7 @@ static int test_snow3g_decryption(const struct snow3g_test_data *tdata)
        TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
        ut_params->obuf = ut_params->op->sym->m_dst;
        if (ut_params->obuf)
-               plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
-                               + tdata->iv.len;
+               plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
        else
                plaintext = ciphertext;
 
@@ -3679,7 +3605,8 @@ static int test_snow3g_decryption_oop(const struct snow3g_test_data *tdata)
        retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
                                        RTE_CRYPTO_CIPHER_OP_DECRYPT,
                                        RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
-                                       tdata->key.data, tdata->key.len);
+                                       tdata->key.data, tdata->key.len,
+                                       tdata->iv.len);
        if (retval < 0)
                return retval;
 
@@ -3713,8 +3640,7 @@ static int test_snow3g_decryption_oop(const struct snow3g_test_data *tdata)
        retval = create_wireless_algo_cipher_operation_oop(tdata->iv.data,
                                        tdata->iv.len,
                                        tdata->validCipherLenInBits.len,
-                                       tdata->validCipherOffsetLenInBits.len,
-                                       RTE_CRYPTO_CIPHER_SNOW3G_UEA2);
+                                       0);
        if (retval < 0)
                return retval;
 
@@ -3723,8 +3649,7 @@ static int test_snow3g_decryption_oop(const struct snow3g_test_data *tdata)
        TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
        ut_params->obuf = ut_params->op->sym->m_dst;
        if (ut_params->obuf)
-               plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
-                               + tdata->iv.len;
+               plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
        else
                plaintext = ciphertext;
 
@@ -3801,7 +3726,7 @@ test_zuc_cipher_auth(const struct wireless_test_data *tdata)
        ut_params->obuf = ut_params->op->sym->m_src;
        if (ut_params->obuf)
                ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
-                               + tdata->iv.len + tdata->aad.len;
+                               + tdata->aad.len;
        else
                ciphertext = plaintext;
 
@@ -3814,7 +3739,7 @@ test_zuc_cipher_auth(const struct wireless_test_data *tdata)
                        "ZUC Ciphertext data not as expected");
 
        ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
-           + plaintext_pad_len + tdata->aad.len + tdata->iv.len;
+           + plaintext_pad_len + tdata->aad.len;
 
        /* Validate obuf */
        TEST_ASSERT_BUFFERS_ARE_EQUAL(
@@ -3844,7 +3769,8 @@ test_snow3g_cipher_auth(const struct snow3g_test_data *tdata)
                        RTE_CRYPTO_AUTH_SNOW3G_UIA2,
                        RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
                        tdata->key.data, tdata->key.len,
-                       tdata->aad.len, tdata->digest.len);
+                       tdata->aad.len, tdata->digest.len,
+                       tdata->iv.len);
        if (retval < 0)
                return retval;
        ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
@@ -3869,12 +3795,11 @@ test_snow3g_cipher_auth(const struct snow3g_test_data *tdata)
                        tdata->aad.len, /*tdata->plaintext.len,*/
                        plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
                        RTE_CRYPTO_AUTH_SNOW3G_UIA2,
-                       RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
                        tdata->iv.data, tdata->iv.len,
                        tdata->validCipherLenInBits.len,
-                       tdata->validCipherOffsetLenInBits.len,
+                       0,
                        tdata->validAuthLenInBits.len,
-                       tdata->validAuthOffsetLenInBits.len
+                       (tdata->aad.len << 3)
                        );
        if (retval < 0)
                return retval;
@@ -3885,7 +3810,7 @@ test_snow3g_cipher_auth(const struct snow3g_test_data *tdata)
        ut_params->obuf = ut_params->op->sym->m_src;
        if (ut_params->obuf)
                ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
-                               + tdata->iv.len + tdata->aad.len;
+                                       + tdata->aad.len;
        else
                ciphertext = plaintext;
 
@@ -3898,7 +3823,7 @@ test_snow3g_cipher_auth(const struct snow3g_test_data *tdata)
                        "SNOW 3G Ciphertext data not as expected");
 
        ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
-           + plaintext_pad_len + tdata->aad.len + tdata->iv.len;
+           + plaintext_pad_len + tdata->aad.len;
 
        /* Validate obuf */
        TEST_ASSERT_BUFFERS_ARE_EQUAL(
@@ -3927,7 +3852,8 @@ test_snow3g_auth_cipher(const struct snow3g_test_data *tdata)
                        RTE_CRYPTO_AUTH_SNOW3G_UIA2,
                        RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
                        tdata->key.data, tdata->key.len,
-                       tdata->aad.len, tdata->digest.len);
+                       tdata->aad.len, tdata->digest.len,
+                       tdata->iv.len);
        if (retval < 0)
                return retval;
 
@@ -3954,11 +3880,10 @@ test_snow3g_auth_cipher(const struct snow3g_test_data *tdata)
                tdata->aad.data, tdata->aad.len,
                plaintext_pad_len,
                tdata->validCipherLenInBits.len,
-               tdata->validCipherOffsetLenInBits.len,
+               0,
                tdata->validAuthLenInBits.len,
-               tdata->validAuthOffsetLenInBits.len,
-               RTE_CRYPTO_AUTH_SNOW3G_UIA2,
-               RTE_CRYPTO_CIPHER_SNOW3G_UEA2
+               (tdata->aad.len << 3),
+               RTE_CRYPTO_AUTH_SNOW3G_UIA2
        );
 
        if (retval < 0)
@@ -3970,12 +3895,12 @@ test_snow3g_auth_cipher(const struct snow3g_test_data *tdata)
        ut_params->obuf = ut_params->op->sym->m_src;
        if (ut_params->obuf)
                ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
-                               + tdata->aad.len + tdata->iv.len;
+                               + tdata->aad.len;
        else
                ciphertext = plaintext;
 
        ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
-                       + plaintext_pad_len + tdata->aad.len + tdata->iv.len;
+                       + plaintext_pad_len + tdata->aad.len;
        TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len);
 
        /* Validate obuf */
@@ -4014,7 +3939,8 @@ test_kasumi_auth_cipher(const struct kasumi_test_data *tdata)
                        RTE_CRYPTO_AUTH_KASUMI_F9,
                        RTE_CRYPTO_CIPHER_KASUMI_F8,
                        tdata->key.data, tdata->key.len,
-                       tdata->aad.len, tdata->digest.len);
+                       tdata->aad.len, tdata->digest.len,
+                       tdata->iv.len);
        if (retval < 0)
                return retval;
        ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
@@ -4039,11 +3965,10 @@ test_kasumi_auth_cipher(const struct kasumi_test_data *tdata)
                                tdata->aad.data, tdata->aad.len,
                                plaintext_pad_len,
                                tdata->validCipherLenInBits.len,
-                               tdata->validCipherOffsetLenInBits.len,
+                               0,
                                tdata->validAuthLenInBits.len,
-                               tdata->validAuthOffsetLenInBits.len,
-                               RTE_CRYPTO_AUTH_KASUMI_F9,
-                               RTE_CRYPTO_CIPHER_KASUMI_F8
+                               (tdata->aad.len << 3),
+                               RTE_CRYPTO_AUTH_KASUMI_F9
                                );
 
        if (retval < 0)
@@ -4055,7 +3980,7 @@ test_kasumi_auth_cipher(const struct kasumi_test_data *tdata)
        ut_params->obuf = ut_params->op->sym->m_src;
        if (ut_params->obuf)
                ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
-                               + tdata->iv.len + tdata->aad.len;
+                               + tdata->aad.len;
        else
                ciphertext = plaintext;
 
@@ -4066,7 +3991,7 @@ test_kasumi_auth_cipher(const struct kasumi_test_data *tdata)
                        tdata->validCipherLenInBits.len,
                        "KASUMI Ciphertext data not as expected");
        ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
-           + plaintext_pad_len + tdata->aad.len + tdata->iv.len;
+           + plaintext_pad_len + tdata->aad.len;
 
        /* Validate obuf */
        TEST_ASSERT_BUFFERS_ARE_EQUAL(
@@ -4097,7 +4022,8 @@ test_kasumi_cipher_auth(const struct kasumi_test_data *tdata)
                        RTE_CRYPTO_AUTH_KASUMI_F9,
                        RTE_CRYPTO_CIPHER_KASUMI_F8,
                        tdata->key.data, tdata->key.len,
-                       tdata->aad.len, tdata->digest.len);
+                       tdata->aad.len, tdata->digest.len,
+                       tdata->iv.len);
        if (retval < 0)
                return retval;
 
@@ -4123,12 +4049,11 @@ test_kasumi_cipher_auth(const struct kasumi_test_data *tdata)
                                tdata->aad.len,
                                plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
                                RTE_CRYPTO_AUTH_KASUMI_F9,
-                               RTE_CRYPTO_CIPHER_KASUMI_F8,
                                tdata->iv.data, tdata->iv.len,
                                tdata->validCipherLenInBits.len,
-                               tdata->validCipherOffsetLenInBits.len,
+                               0,
                                tdata->validAuthLenInBits.len,
-                               tdata->validAuthOffsetLenInBits.len
+                               (tdata->aad.len << 3)
                                );
        if (retval < 0)
                return retval;
@@ -4139,12 +4064,12 @@ test_kasumi_cipher_auth(const struct kasumi_test_data *tdata)
        ut_params->obuf = ut_params->op->sym->m_src;
        if (ut_params->obuf)
                ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
-                               + tdata->aad.len + tdata->iv.len;
+                               + tdata->aad.len;
        else
                ciphertext = plaintext;
 
        ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
-                       + plaintext_pad_len + tdata->aad.len + tdata->iv.len;
+                       + plaintext_pad_len + tdata->aad.len;
 
        /* Validate obuf */
        TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
@@ -4187,7 +4112,8 @@ test_zuc_encryption(const struct wireless_test_data *tdata)
        retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
                                        RTE_CRYPTO_CIPHER_OP_ENCRYPT,
                                        RTE_CRYPTO_CIPHER_ZUC_EEA3,
-                                       tdata->key.data, tdata->key.len);
+                                       tdata->key.data, tdata->key.len,
+                                       tdata->iv.len);
        if (retval < 0)
                return retval;
 
@@ -4210,8 +4136,7 @@ test_zuc_encryption(const struct wireless_test_data *tdata)
        /* Create ZUC operation */
        retval = create_wireless_algo_cipher_operation(tdata->iv.data, tdata->iv.len,
                                        tdata->plaintext.len,
-                                       tdata->validCipherOffsetLenInBits.len,
-                                       RTE_CRYPTO_CIPHER_ZUC_EEA3);
+                                       0);
        if (retval < 0)
                return retval;
 
@@ -4221,8 +4146,7 @@ test_zuc_encryption(const struct wireless_test_data *tdata)
 
        ut_params->obuf = ut_params->op->sym->m_dst;
        if (ut_params->obuf)
-               ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
-                               + tdata->iv.len;
+               ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
        else
                ciphertext = plaintext;
 
@@ -4284,7 +4208,8 @@ test_zuc_encryption_sgl(const struct wireless_test_data *tdata)
        retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
                        RTE_CRYPTO_CIPHER_OP_ENCRYPT,
                        RTE_CRYPTO_CIPHER_ZUC_EEA3,
-                       tdata->key.data, tdata->key.len);
+                       tdata->key.data, tdata->key.len,
+                       tdata->iv.len);
        if (retval < 0)
                return retval;
 
@@ -4295,8 +4220,7 @@ test_zuc_encryption_sgl(const struct wireless_test_data *tdata)
        /* Create ZUC operation */
        retval = create_wireless_algo_cipher_operation(tdata->iv.data,
                        tdata->iv.len, tdata->plaintext.len,
-                       tdata->validCipherOffsetLenInBits.len,
-                       RTE_CRYPTO_CIPHER_ZUC_EEA3);
+                       0);
        if (retval < 0)
                return retval;
 
@@ -4307,10 +4231,10 @@ test_zuc_encryption_sgl(const struct wireless_test_data *tdata)
        ut_params->obuf = ut_params->op->sym->m_dst;
        if (ut_params->obuf)
                ciphertext = rte_pktmbuf_read(ut_params->obuf,
-                       tdata->iv.len, plaintext_len, ciphertext_buffer);
+                       0, plaintext_len, ciphertext_buffer);
        else
                ciphertext = rte_pktmbuf_read(ut_params->ibuf,
-                       tdata->iv.len, plaintext_len, ciphertext_buffer);
+                       0, plaintext_len, ciphertext_buffer);
 
        /* Validate obuf */
        TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len);
@@ -4375,7 +4299,7 @@ test_zuc_authentication(const struct wireless_test_data *tdata)
                        plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
                        RTE_CRYPTO_AUTH_ZUC_EIA3,
                        tdata->validAuthLenInBits.len,
-                       tdata->validAuthOffsetLenInBits.len);
+                       (tdata->aad.len << 3));
        if (retval < 0)
                return retval;
 
@@ -4817,6 +4741,7 @@ static int
 create_gcm_session(uint8_t dev_id, enum rte_crypto_cipher_operation op,
                const uint8_t *key, const uint8_t key_len,
                const uint8_t aad_len, const uint8_t auth_len,
+               uint8_t iv_len,
                enum rte_crypto_auth_operation auth_op)
 {
        uint8_t cipher_key[key_len];
@@ -4834,6 +4759,8 @@ create_gcm_session(uint8_t dev_id, enum rte_crypto_cipher_operation op,
        ut_params->cipher_xform.cipher.op = op;
        ut_params->cipher_xform.cipher.key.data = cipher_key;
        ut_params->cipher_xform.cipher.key.length = key_len;
+       ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
+       ut_params->cipher_xform.cipher.iv.length = iv_len;
 
        TEST_HEXDUMP(stdout, "key:", key, key_len);
 
@@ -4870,6 +4797,7 @@ create_gcm_xforms(struct rte_crypto_op *op,
                enum rte_crypto_cipher_operation cipher_op,
                uint8_t *key, const uint8_t key_len,
                const uint8_t aad_len, const uint8_t auth_len,
+               uint8_t iv_len,
                enum rte_crypto_auth_operation auth_op)
 {
        TEST_ASSERT_NOT_NULL(rte_crypto_op_sym_xforms_alloc(op, 2),
@@ -4883,6 +4811,8 @@ create_gcm_xforms(struct rte_crypto_op *op,
        sym_op->xform->cipher.op = cipher_op;
        sym_op->xform->cipher.key.data = key;
        sym_op->xform->cipher.key.length = key_len;
+       sym_op->xform->cipher.iv.offset = IV_OFFSET;
+       sym_op->xform->cipher.iv.length = iv_len;
 
        TEST_HEXDUMP(stdout, "key:", key, key_len);
 
@@ -4907,7 +4837,7 @@ create_gcm_operation(enum rte_crypto_cipher_operation op,
        struct crypto_unittest_params *ut_params = &unittest_params;
 
        uint8_t *plaintext, *ciphertext;
-       unsigned int iv_pad_len, aad_pad_len, plaintext_pad_len;
+       unsigned int aad_pad_len, plaintext_pad_len;
 
        /* Generate Crypto op data structure */
        ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
@@ -4931,19 +4861,13 @@ create_gcm_operation(enum rte_crypto_cipher_operation op,
        TEST_HEXDUMP(stdout, "aad:", sym_op->auth.aad.data,
                sym_op->auth.aad.length);
 
-       /* Prepend iv */
-       iv_pad_len = RTE_ALIGN_CEIL(tdata->iv.len, 16);
-       sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(
-                       ut_params->ibuf, iv_pad_len);
-       TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data, "no room to prepend iv");
+       /* Append IV at the end of the crypto operation*/
+       uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
+                       uint8_t *, IV_OFFSET);
 
-       memset(sym_op->cipher.iv.data, 0, iv_pad_len);
-       sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
-       sym_op->cipher.iv.length = tdata->iv.len;
-
-       rte_memcpy(sym_op->cipher.iv.data, tdata->iv.data, tdata->iv.len);
-       TEST_HEXDUMP(stdout, "iv:", sym_op->cipher.iv.data,
-               sym_op->cipher.iv.length);
+       rte_memcpy(iv_ptr, tdata->iv.data, tdata->iv.len);
+       TEST_HEXDUMP(stdout, "iv:", iv_ptr,
+               tdata->iv.len);
 
        /* Append plaintext/ciphertext */
        if (op == RTE_CRYPTO_CIPHER_OP_ENCRYPT) {
@@ -4959,12 +4883,11 @@ create_gcm_operation(enum rte_crypto_cipher_operation op,
                if (ut_params->obuf) {
                        ciphertext = (uint8_t *)rte_pktmbuf_append(
                                        ut_params->obuf,
-                                       plaintext_pad_len + aad_pad_len +
-                                       iv_pad_len);
+                                       plaintext_pad_len + aad_pad_len);
                        TEST_ASSERT_NOT_NULL(ciphertext,
                                        "no room to append ciphertext");
 
-                       memset(ciphertext + aad_pad_len + iv_pad_len, 0,
+                       memset(ciphertext + aad_pad_len, 0,
                                        tdata->ciphertext.len);
                }
        } else {
@@ -4982,12 +4905,11 @@ create_gcm_operation(enum rte_crypto_cipher_operation op,
                if (ut_params->obuf) {
                        plaintext = (uint8_t *)rte_pktmbuf_append(
                                        ut_params->obuf,
-                                       plaintext_pad_len + aad_pad_len +
-                                       iv_pad_len);
+                                       plaintext_pad_len + aad_pad_len);
                        TEST_ASSERT_NOT_NULL(plaintext,
                                        "no room to append plaintext");
 
-                       memset(plaintext + aad_pad_len + iv_pad_len, 0,
+                       memset(plaintext + aad_pad_len, 0,
                                        tdata->plaintext.len);
                }
        }
@@ -5005,7 +4927,7 @@ create_gcm_operation(enum rte_crypto_cipher_operation op,
                                ut_params->obuf ? ut_params->obuf :
                                                ut_params->ibuf,
                                                plaintext_pad_len +
-                                               aad_pad_len + iv_pad_len);
+                                               aad_pad_len);
                sym_op->auth.digest.length = tdata->auth_tag.len;
        } else {
                sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
@@ -5014,7 +4936,7 @@ create_gcm_operation(enum rte_crypto_cipher_operation op,
                                "no room to append digest");
                sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
                                ut_params->ibuf,
-                               plaintext_pad_len + aad_pad_len + iv_pad_len);
+                               plaintext_pad_len + aad_pad_len);
                sym_op->auth.digest.length = tdata->auth_tag.len;
 
                rte_memcpy(sym_op->auth.digest.data, tdata->auth_tag.data,
@@ -5025,10 +4947,10 @@ create_gcm_operation(enum rte_crypto_cipher_operation op,
        }
 
        sym_op->cipher.data.length = tdata->plaintext.len;
-       sym_op->cipher.data.offset = aad_pad_len + iv_pad_len;
+       sym_op->cipher.data.offset = aad_pad_len;
 
        sym_op->auth.data.length = tdata->plaintext.len;
-       sym_op->auth.data.offset = aad_pad_len + iv_pad_len;
+       sym_op->auth.data.offset = aad_pad_len;
 
        return 0;
 }
@@ -5049,6 +4971,7 @@ test_mb_AES_GCM_authenticated_encryption(const struct gcm_test_data *tdata)
                        RTE_CRYPTO_CIPHER_OP_ENCRYPT,
                        tdata->key.data, tdata->key.len,
                        tdata->aad.len, tdata->auth_tag.len,
+                       tdata->iv.len,
                        RTE_CRYPTO_AUTH_OP_GENERATE);
        if (retval < 0)
                return retval;
@@ -5226,6 +5149,7 @@ test_mb_AES_GCM_authenticated_decryption(const struct gcm_test_data *tdata)
                        RTE_CRYPTO_CIPHER_OP_DECRYPT,
                        tdata->key.data, tdata->key.len,
                        tdata->aad.len, tdata->auth_tag.len,
+                       tdata->iv.len,
                        RTE_CRYPTO_AUTH_OP_VERIFY);
        if (retval < 0)
                return retval;
@@ -5392,6 +5316,7 @@ test_AES_GCM_authenticated_encryption_oop(const struct gcm_test_data *tdata)
                        RTE_CRYPTO_CIPHER_OP_ENCRYPT,
                        tdata->key.data, tdata->key.len,
                        tdata->aad.len, tdata->auth_tag.len,
+                       tdata->iv.len,
                        RTE_CRYPTO_AUTH_OP_GENERATE);
        if (retval < 0)
                return retval;
@@ -5468,6 +5393,7 @@ test_AES_GCM_authenticated_decryption_oop(const struct gcm_test_data *tdata)
                        RTE_CRYPTO_CIPHER_OP_DECRYPT,
                        tdata->key.data, tdata->key.len,
                        tdata->aad.len, tdata->auth_tag.len,
+                       tdata->iv.len,
                        RTE_CRYPTO_AUTH_OP_VERIFY);
        if (retval < 0)
                return retval;
@@ -5551,14 +5477,15 @@ test_AES_GCM_authenticated_encryption_sessionless(
                        RTE_CRYPTO_CIPHER_OP_ENCRYPT,
                        key, tdata->key.len,
                        tdata->aad.len, tdata->auth_tag.len,
+                       tdata->iv.len,
                        RTE_CRYPTO_AUTH_OP_GENERATE);
        if (retval < 0)
                return retval;
 
        ut_params->op->sym->m_src = ut_params->ibuf;
 
-       TEST_ASSERT_EQUAL(ut_params->op->sym->sess_type,
-                       RTE_CRYPTO_SYM_OP_SESSIONLESS,
+       TEST_ASSERT_EQUAL(ut_params->op->sess_type,
+                       RTE_CRYPTO_OP_SESSIONLESS,
                        "crypto op session type not sessionless");
 
        /* Process crypto operation */
@@ -5631,14 +5558,15 @@ test_AES_GCM_authenticated_decryption_sessionless(
                        RTE_CRYPTO_CIPHER_OP_DECRYPT,
                        key, tdata->key.len,
                        tdata->aad.len, tdata->auth_tag.len,
+                       tdata->iv.len,
                        RTE_CRYPTO_AUTH_OP_VERIFY);
        if (retval < 0)
                return retval;
 
        ut_params->op->sym->m_src = ut_params->ibuf;
 
-       TEST_ASSERT_EQUAL(ut_params->op->sym->sess_type,
-                       RTE_CRYPTO_SYM_OP_SESSIONLESS,
+       TEST_ASSERT_EQUAL(ut_params->op->sess_type,
+                       RTE_CRYPTO_OP_SESSIONLESS,
                        "crypto op session type not sessionless");
 
        /* Process crypto operation */
@@ -6466,10 +6394,8 @@ create_gmac_operation(enum rte_crypto_auth_operation op,
        struct crypto_unittest_params *ut_params = &unittest_params;
        struct rte_crypto_sym_op *sym_op;
 
-       unsigned iv_pad_len;
        unsigned aad_pad_len;
 
-       iv_pad_len = RTE_ALIGN_CEIL(tdata->iv.len, 16);
        aad_pad_len = RTE_ALIGN_CEIL(tdata->aad.len, 16);
 
        /*
@@ -6514,17 +6440,12 @@ create_gmac_operation(enum rte_crypto_auth_operation op,
                                sym_op->auth.digest.length);
        }
 
-       sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(
-                       ut_params->ibuf, iv_pad_len);
-       TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data, "no room to prepend iv");
-
-       memset(sym_op->cipher.iv.data, 0, iv_pad_len);
-       sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
-       sym_op->cipher.iv.length = tdata->iv.len;
+       uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
+                       uint8_t *, IV_OFFSET);
 
-       rte_memcpy(sym_op->cipher.iv.data, tdata->iv.data, tdata->iv.len);
+       rte_memcpy(iv_ptr, tdata->iv.data, tdata->iv.len);
 
-       TEST_HEXDUMP(stdout, "iv:", sym_op->cipher.iv.data, iv_pad_len);
+       TEST_HEXDUMP(stdout, "iv:", iv_ptr, tdata->iv.len);
 
        sym_op->cipher.data.length = 0;
        sym_op->cipher.data.offset = 0;
@@ -6553,6 +6474,8 @@ static int create_gmac_session(uint8_t dev_id,
        ut_params->cipher_xform.cipher.op = op;
        ut_params->cipher_xform.cipher.key.data = cipher_key;
        ut_params->cipher_xform.cipher.key.length = tdata->key.len;
+       ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
+       ut_params->cipher_xform.cipher.iv.length = tdata->iv.len;
 
        ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
        ut_params->auth_xform.next = NULL;
@@ -6951,6 +6874,8 @@ create_auth_cipher_session(struct crypto_unittest_params *ut_params,
        ut_params->cipher_xform.cipher.op = cipher_op;
        ut_params->cipher_xform.cipher.key.data = cipher_key;
        ut_params->cipher_xform.cipher.key.length = reference->cipher_key.len;
+       ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
+       ut_params->cipher_xform.cipher.iv.length = reference->iv.len;
 
        /* Create Crypto session*/
        ut_params->sess = rte_cryptodev_sym_session_create(dev_id,
@@ -7062,14 +6987,8 @@ create_auth_GMAC_operation(struct crypto_testsuite_params *ts_params,
                        sym_op->auth.digest.data,
                        sym_op->auth.digest.length);
 
-       sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(
-               ut_params->ibuf, reference->iv.len);
-       TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data, "no room to prepend iv");
-
-       sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
-       sym_op->cipher.iv.length = reference->iv.len;
-
-       memcpy(sym_op->cipher.iv.data, reference->iv.data, reference->iv.len);
+       rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
+                       reference->iv.data, reference->iv.len);
 
        sym_op->cipher.data.length = 0;
        sym_op->cipher.data.offset = 0;
@@ -7122,20 +7041,14 @@ create_cipher_auth_operation(struct crypto_testsuite_params *ts_params,
                        sym_op->auth.digest.data,
                        sym_op->auth.digest.length);
 
-       sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(
-               ut_params->ibuf, reference->iv.len);
-       TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data, "no room to prepend iv");
-
-       sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
-       sym_op->cipher.iv.length = reference->iv.len;
-
-       memcpy(sym_op->cipher.iv.data, reference->iv.data, reference->iv.len);
+       rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
+                       reference->iv.data, reference->iv.len);
 
        sym_op->cipher.data.length = reference->ciphertext.len;
-       sym_op->cipher.data.offset = reference->iv.len;
+       sym_op->cipher.data.offset = 0;
 
        sym_op->auth.data.length = reference->ciphertext.len;
-       sym_op->auth.data.offset = reference->iv.len;
+       sym_op->auth.data.offset = 0;
 
        return 0;
 }
@@ -7349,8 +7262,6 @@ create_gcm_operation_SGL(enum rte_crypto_cipher_operation op,
        const unsigned int iv_len = tdata->iv.len;
        const unsigned int aad_len = tdata->aad.len;
 
-       unsigned int iv_pad_len = 0;
-
        /* Generate Crypto op data structure */
        ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
                        RTE_CRYPTO_OP_TYPE_SYMMETRIC);
@@ -7375,19 +7286,10 @@ create_gcm_operation_SGL(enum rte_crypto_cipher_operation op,
                                sym_op->auth.digest.length);
        }
 
-       iv_pad_len = RTE_ALIGN_CEIL(iv_len, 16);
-
-       sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(
-                       ut_params->ibuf, iv_pad_len);
-
-       TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data,
-                       "no room to prepend iv");
-
-       memset(sym_op->cipher.iv.data, 0, iv_pad_len);
-       sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
-       sym_op->cipher.iv.length = iv_len;
+       uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
+                       uint8_t *, IV_OFFSET);
 
-       rte_memcpy(sym_op->cipher.iv.data, tdata->iv.data, iv_pad_len);
+       rte_memcpy(iv_ptr, tdata->iv.data, iv_len);
 
        sym_op->auth.aad.data = (uint8_t *)rte_pktmbuf_prepend(
                        ut_params->ibuf, aad_len);
@@ -7400,14 +7302,14 @@ create_gcm_operation_SGL(enum rte_crypto_cipher_operation op,
        memset(sym_op->auth.aad.data, 0, aad_len);
        rte_memcpy(sym_op->auth.aad.data, tdata->aad.data, aad_len);
 
-       TEST_HEXDUMP(stdout, "iv:", sym_op->cipher.iv.data, iv_pad_len);
+       TEST_HEXDUMP(stdout, "iv:", iv_ptr, iv_len);
        TEST_HEXDUMP(stdout, "aad:",
                        sym_op->auth.aad.data, aad_len);
 
        sym_op->cipher.data.length = tdata->plaintext.len;
-       sym_op->cipher.data.offset = aad_len + iv_pad_len;
+       sym_op->cipher.data.offset = aad_len;
 
-       sym_op->auth.data.offset = aad_len + iv_pad_len;
+       sym_op->auth.data.offset = aad_len;
        sym_op->auth.data.length = tdata->plaintext.len;
 
        return 0;
@@ -7441,8 +7343,7 @@ test_AES_GCM_authenticated_encryption_SGL(const struct gcm_test_data *tdata,
        int ecx = 0;
        void *digest_mem = NULL;
 
-       uint32_t prepend_len = ALIGN_POW2_ROUNDUP(tdata->iv.len, 16)
-                       + tdata->aad.len;
+       uint32_t prepend_len = tdata->aad.len;
 
        if (tdata->plaintext.len % fragsz != 0) {
                if (tdata->plaintext.len / fragsz + 1 > SGL_MAX_NO)
@@ -7467,6 +7368,7 @@ test_AES_GCM_authenticated_encryption_SGL(const struct gcm_test_data *tdata,
                        RTE_CRYPTO_CIPHER_OP_ENCRYPT,
                        tdata->key.data, tdata->key.len,
                        tdata->aad.len, tdata->auth_tag.len,
+                       tdata->iv.len,
                        RTE_CRYPTO_AUTH_OP_GENERATE);
        if (retval < 0)
                return retval;
@@ -7825,7 +7727,7 @@ test_scheduler_attach_slave_op(void)
                        snprintf(vdev_name, sizeof(vdev_name), "%s_%u",
                                        RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD),
                                        i);
-                       ret = rte_eal_vdev_init(vdev_name, NULL);
+                       ret = rte_vdev_init(vdev_name, NULL);
 
                        TEST_ASSERT(ret == 0,
                                "Failed to create instance %u of"