Code Review / deb_dpdk.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | review | tree
raw | inline | side by side
New upstream version 18.08
[deb_dpdk.git] / test / test / test_cryptodev_blockcipher.c
diff --git a/test/test/test_cryptodev_blockcipher.c b/test/test/test_cryptodev_blockcipher.c
index ed06618..f2701f8 100644 (file)
--- a/test/test/test_cryptodev_blockcipher.c
+++ b/test/test/test_cryptodev_blockcipher.c
@@ -54,6 +54,8 @@ test_blockcipher_one_case(const struct blockcipher_test_case *t,
 
        int openssl_pmd = rte_cryptodev_driver_id_get(
                        RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD));
+       int ccp_pmd = rte_cryptodev_driver_id_get(
+                       RTE_STR(CRYPTODEV_NAME_CCP_PMD));
        int scheduler_pmd = rte_cryptodev_driver_id_get(
                        RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD));
        int armv8_pmd = rte_cryptodev_driver_id_get(
@@ -67,18 +69,34 @@ test_blockcipher_one_case(const struct blockcipher_test_case *t,
        int dpaa_sec_pmd = rte_cryptodev_driver_id_get(
                        RTE_STR(CRYPTODEV_NAME_DPAA_SEC_PMD));
        int mrvl_pmd = rte_cryptodev_driver_id_get(
-                       RTE_STR(CRYPTODEV_NAME_MRVL_PMD));
+                       RTE_STR(CRYPTODEV_NAME_MVSAM_PMD));
+       int virtio_pmd = rte_cryptodev_driver_id_get(
+                       RTE_STR(CRYPTODEV_NAME_VIRTIO_PMD));
 
        int nb_segs = 1;
 
+       rte_cryptodev_info_get(dev_id, &dev_info);
+
        if (t->feature_mask & BLOCKCIPHER_TEST_FEATURE_SG) {
-               rte_cryptodev_info_get(dev_id, &dev_info);
-               if (!(dev_info.feature_flags &
-                               RTE_CRYPTODEV_FF_MBUF_SCATTER_GATHER)) {
-                       printf("Device doesn't support scatter-gather. "
+               uint64_t feat_flags = dev_info.feature_flags;
+               uint64_t oop_flag = RTE_CRYPTODEV_FF_OOP_SGL_IN_LB_OUT;
+
+               if (t->feature_mask && BLOCKCIPHER_TEST_FEATURE_OOP) {
+                       if (!(feat_flags & oop_flag)) {
+                               printf("Device doesn't support out-of-place "
+                                       "scatter-gather in input mbuf. "
+                                       "Test Skipped.\n");
+                               return 0;
+                       }
+               } else {
+                       if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
+                               printf("Device doesn't support in-place "
+                                       "scatter-gather mbufs. "
                                        "Test Skipped.\n");
-                       return 0;
+                               return 0;
+                       }
                }
+
                nb_segs = 3;
        }
 
@@ -94,7 +112,9 @@ test_blockcipher_one_case(const struct blockcipher_test_case *t,
                        driver_id == qat_pmd ||
                        driver_id == openssl_pmd ||
                        driver_id == armv8_pmd ||
-                       driver_id == mrvl_pmd) { /* Fall through */
+                       driver_id == mrvl_pmd ||
+                       driver_id == ccp_pmd ||
+                       driver_id == virtio_pmd) { /* Fall through */
                digest_len = tdata->digest.len;
        } else if (driver_id == aesni_mb_pmd ||
                        driver_id == scheduler_pmd) {
@@ -432,11 +452,34 @@ test_blockcipher_one_case(const struct blockcipher_test_case *t,
                uint8_t value;
                uint32_t head_unchanged_len, changed_len = 0;
                uint32_t i;
+               uint32_t hdroom_used = 0, tlroom_used = 0;
+               uint32_t hdroom = 0;
 
                mbuf = sym_op->m_src;
+               /*
+                * Crypto PMDs specify the headroom & tailroom it would use
+                * when processing the crypto operation. PMD is free to modify
+                * this space, and so the verification check should skip that
+                * block.
+                */
+               hdroom_used = dev_info.min_mbuf_headroom_req;
+               tlroom_used = dev_info.min_mbuf_tailroom_req;
+
+               /* Get headroom */
+               hdroom = rte_pktmbuf_headroom(mbuf);
+
                head_unchanged_len = mbuf->buf_len;
 
                for (i = 0; i < mbuf->buf_len; i++) {
+
+                       /* Skip headroom used by PMD */
+                       if (i == hdroom - hdroom_used)
+                               i += hdroom_used;
+
+                       /* Skip tailroom used by PMD */
+                       if (i == (hdroom + mbuf->data_len))
+                               i += tlroom_used;
+
                        value = *((uint8_t *)(mbuf->buf_addr)+i);
                        if (value != tmp_src_buf[i]) {
                                snprintf(test_msg, BLOCKCIPHER_TEST_MSG_LEN,
@@ -449,14 +492,13 @@ test_blockcipher_one_case(const struct blockcipher_test_case *t,
 
                mbuf = sym_op->m_dst;
                if (t->op_mask & BLOCKCIPHER_TEST_OP_AUTH) {
-                       head_unchanged_len = rte_pktmbuf_headroom(mbuf) +
-                                               sym_op->auth.data.offset;
+                       head_unchanged_len = hdroom + sym_op->auth.data.offset;
                        changed_len = sym_op->auth.data.length;
                        if (t->op_mask & BLOCKCIPHER_TEST_OP_AUTH_GEN)
                                changed_len += digest_len;
                } else {
                        /* cipher-only */
-                       head_unchanged_len = rte_pktmbuf_headroom(mbuf) +
+                       head_unchanged_len = hdroom +
                                        sym_op->cipher.data.offset;
                        changed_len = sym_op->cipher.data.length;
                }
@@ -480,15 +522,30 @@ test_blockcipher_one_case(const struct blockcipher_test_case *t,
                uint8_t value;
                uint32_t head_unchanged_len = 0, changed_len = 0;
                uint32_t i;
+               uint32_t hdroom_used = 0, tlroom_used = 0;
+               uint32_t hdroom = 0;
+
+               /*
+                * Crypto PMDs specify the headroom & tailroom it would use
+                * when processing the crypto operation. PMD is free to modify
+                * this space, and so the verification check should skip that
+                * block.
+                */
+               hdroom_used = dev_info.min_mbuf_headroom_req;
+               tlroom_used = dev_info.min_mbuf_tailroom_req;
 
                mbuf = sym_op->m_src;
+
+               /* Get headroom */
+               hdroom = rte_pktmbuf_headroom(mbuf);
+
                if (t->op_mask & BLOCKCIPHER_TEST_OP_CIPHER) {
-                       head_unchanged_len = rte_pktmbuf_headroom(mbuf) +
+                       head_unchanged_len = hdroom +
                                        sym_op->cipher.data.offset;
                        changed_len = sym_op->cipher.data.length;
                } else {
                        /* auth-only */
-                       head_unchanged_len = rte_pktmbuf_headroom(mbuf) +
+                       head_unchanged_len = hdroom +
                                        sym_op->auth.data.offset +
                                        sym_op->auth.data.length;
                        changed_len = 0;
@@ -498,8 +555,18 @@ test_blockcipher_one_case(const struct blockcipher_test_case *t,
                        changed_len += digest_len;
 
                for (i = 0; i < mbuf->buf_len; i++) {
+
+                       /* Skip headroom used by PMD */
+                       if (i == hdroom - hdroom_used)
+                               i += hdroom_used;
+
                        if (i == head_unchanged_len)
                                i += changed_len;
+
+                       /* Skip tailroom used by PMD */
+                       if (i == (hdroom + mbuf->data_len))
+                               i += tlroom_used;
+
                        value = *((uint8_t *)(mbuf->buf_addr)+i);
                        if (value != tmp_src_buf[i]) {
                                snprintf(test_msg, BLOCKCIPHER_TEST_MSG_LEN,
@@ -555,6 +622,8 @@ test_blockcipher_all_tests(struct rte_mempool *mbuf_pool,
 
        int openssl_pmd = rte_cryptodev_driver_id_get(
                        RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD));
+       int ccp_pmd = rte_cryptodev_driver_id_get(
+                       RTE_STR(CRYPTODEV_NAME_CCP_PMD));
        int dpaa2_sec_pmd = rte_cryptodev_driver_id_get(
                        RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD));
        int dpaa_sec_pmd = rte_cryptodev_driver_id_get(
@@ -568,7 +637,9 @@ test_blockcipher_all_tests(struct rte_mempool *mbuf_pool,
        int qat_pmd = rte_cryptodev_driver_id_get(
                        RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD));
        int mrvl_pmd = rte_cryptodev_driver_id_get(
-                       RTE_STR(CRYPTODEV_NAME_MRVL_PMD));
+                       RTE_STR(CRYPTODEV_NAME_MVSAM_PMD));
+       int virtio_pmd = rte_cryptodev_driver_id_get(
+                       RTE_STR(CRYPTODEV_NAME_VIRTIO_PMD));
 
        switch (test_type) {
        case BLKCIPHER_AES_CHAIN_TYPE:
@@ -627,10 +698,14 @@ test_blockcipher_all_tests(struct rte_mempool *mbuf_pool,
                target_pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_SCHEDULER;
        else if (driver_id == dpaa2_sec_pmd)
                target_pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC;
+       else if (driver_id == ccp_pmd)
+               target_pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_CCP;
        else if (driver_id == dpaa_sec_pmd)
                target_pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC;
        else if (driver_id == mrvl_pmd)
-               target_pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_MRVL;
+               target_pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_MVSAM;
+       else if (driver_id == virtio_pmd)
+               target_pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_VIRTIO;
        else
                TEST_ASSERT(0, "Unrecognized cryptodev type");
 
ARCHIVED- 2020-02-20 at the request of the project