From patchwork Tue Sep 22 10:34:29 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "De Lara Guarch, Pablo" X-Patchwork-Id: 78395 X-Patchwork-Delegate: gakhil@marvell.com Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from dpdk.org (dpdk.org [92.243.14.124]) by inbox.dpdk.org (Postfix) with ESMTP id AF96AA04B5; Tue, 22 Sep 2020 12:34:38 +0200 (CEST) Received: from [92.243.14.124] (localhost [127.0.0.1]) by dpdk.org (Postfix) with ESMTP id 7E6FC1DBB0; Tue, 22 Sep 2020 12:34:38 +0200 (CEST) Received: from mga17.intel.com (mga17.intel.com [192.55.52.151]) by dpdk.org (Postfix) with ESMTP id 09EC01DB90 for ; Tue, 22 Sep 2020 12:34:36 +0200 (CEST) IronPort-SDR: Chlv4gRKTR+IwRQwVlJdXC96vPbIvWQ6ge9VDUmJRlqn16yAX6h9xIkQDCzKuNQUgYAmEbf2HX 3GEMLaDXyVyg== X-IronPort-AV: E=McAfee;i="6000,8403,9751"; a="140580856" X-IronPort-AV: E=Sophos;i="5.77,290,1596524400"; d="scan'208";a="140580856" X-Amp-Result: SKIPPED(no attachment in message) X-Amp-File-Uploaded: False Received: from fmsmga002.fm.intel.com ([10.253.24.26]) by fmsmga107.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 22 Sep 2020 03:34:36 -0700 IronPort-SDR: goBdayarzdOI2L76ySId4R3J3khBvRvKXzSPonbgCF990UUYb1eNUOp5NdRmvuNZXwQDK5w4CW j+AYDyABcfTw== X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.77,290,1596524400"; d="scan'208";a="341971553" Received: from silpixa00400637.ir.intel.com ([10.237.213.160]) by fmsmga002.fm.intel.com with ESMTP; 22 Sep 2020 03:34:35 -0700 From: Pablo de Lara To: declan.doherty@intel.com Cc: dev@dpdk.org, Pablo de Lara Date: Tue, 22 Sep 2020 10:34:29 +0000 Message-Id: <20200922103430.128456-1-pablo.de.lara.guarch@intel.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20200922100111.128316-1-pablo.de.lara.guarch@intel.com> References: <20200922100111.128316-1-pablo.de.lara.guarch@intel.com> MIME-Version: 1.0 Subject: [dpdk-dev] [PATCH v3 1/2] crypto/aesni_gcm: support SGL on AES-GMAC X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org Sender: "dev" Add Scatter-gather list support for AES-GMAC. Signed-off-by: Pablo de Lara --- Changes: - v2/v3: no change --- doc/guides/cryptodevs/aesni_gcm.rst | 2 - doc/guides/rel_notes/release_20_11.rst | 4 ++ drivers/crypto/aesni_gcm/aesni_gcm_ops.h | 27 ++++++++ drivers/crypto/aesni_gcm/aesni_gcm_pmd.c | 88 +++++++++++++++++++++++- 4 files changed, 118 insertions(+), 3 deletions(-) diff --git a/doc/guides/cryptodevs/aesni_gcm.rst b/doc/guides/cryptodevs/aesni_gcm.rst index 74e0de63a..0e146486e 100644 --- a/doc/guides/cryptodevs/aesni_gcm.rst +++ b/doc/guides/cryptodevs/aesni_gcm.rst @@ -31,8 +31,6 @@ Limitations ----------- * In out-of-place operations, chained destination mbufs are not supported. -* Chained mbufs are only supported by RTE_CRYPTO_AEAD_AES_GCM algorithm, - not RTE_CRYPTO_AUTH_AES_GMAC. * Cipher only is not supported. diff --git a/doc/guides/rel_notes/release_20_11.rst b/doc/guides/rel_notes/release_20_11.rst index df227a177..98fd4ae0f 100644 --- a/doc/guides/rel_notes/release_20_11.rst +++ b/doc/guides/rel_notes/release_20_11.rst @@ -55,6 +55,10 @@ New Features Also, make sure to start the actual text at the margin. ======================================================= +* **Updated the AESNI GCM crypto PMD.** + + * Added SGL support AES-GMAC. + Removed Items ------------- diff --git a/drivers/crypto/aesni_gcm/aesni_gcm_ops.h b/drivers/crypto/aesni_gcm/aesni_gcm_ops.h index 74acac09c..8a0d074b6 100644 --- a/drivers/crypto/aesni_gcm/aesni_gcm_ops.h +++ b/drivers/crypto/aesni_gcm/aesni_gcm_ops.h @@ -53,6 +53,23 @@ typedef void (*aesni_gcm_finalize_t)(const struct gcm_key_data *gcm_key_data, uint8_t *auth_tag, uint64_t auth_tag_len); +#if IMB_VERSION(0, 54, 0) < IMB_VERSION_NUM +typedef void (*aesni_gmac_init_t)(const struct gcm_key_data *gcm_key_data, + struct gcm_context_data *gcm_ctx_data, + const uint8_t *iv, + const uint64_t iv_len); + +typedef void (*aesni_gmac_update_t)(const struct gcm_key_data *gcm_key_data, + struct gcm_context_data *gcm_ctx_data, + const uint8_t *in, + const uint64_t plaintext_len); + +typedef void (*aesni_gmac_finalize_t)(const struct gcm_key_data *gcm_key_data, + struct gcm_context_data *gcm_ctx_data, + uint8_t *auth_tag, + const uint64_t auth_tag_len); +#endif + /** GCM library function pointer table */ struct aesni_gcm_ops { aesni_gcm_t enc; /**< GCM encode function pointer */ @@ -63,6 +80,11 @@ struct aesni_gcm_ops { aesni_gcm_update_t update_dec; aesni_gcm_finalize_t finalize_enc; aesni_gcm_finalize_t finalize_dec; +#if IMB_VERSION(0, 54, 0) < IMB_VERSION_NUM + aesni_gmac_init_t gmac_init; + aesni_gmac_update_t gmac_update; + aesni_gmac_finalize_t gmac_finalize; +#endif }; /** GCM per-session operation handlers */ @@ -72,6 +94,11 @@ struct aesni_gcm_session_ops { aesni_gcm_init_t init; aesni_gcm_update_t update; aesni_gcm_finalize_t finalize; +#if IMB_VERSION(0, 54, 0) < IMB_VERSION_NUM + aesni_gmac_init_t gmac_init; + aesni_gmac_update_t gmac_update; + aesni_gmac_finalize_t gmac_finalize; +#endif }; #endif /* _AESNI_GCM_OPS_H_ */ diff --git a/drivers/crypto/aesni_gcm/aesni_gcm_pmd.c b/drivers/crypto/aesni_gcm/aesni_gcm_pmd.c index 1d2a0ce00..aea599ebf 100644 --- a/drivers/crypto/aesni_gcm/aesni_gcm_pmd.c +++ b/drivers/crypto/aesni_gcm/aesni_gcm_pmd.c @@ -350,6 +350,76 @@ process_gcm_crypto_op(struct aesni_gcm_qp *qp, struct rte_crypto_op *op, &qp->gdata_ctx, tag, session->gen_digest_length); +#if IMB_VERSION(0, 54, 0) < IMB_VERSION_NUM + } else if (session->op == AESNI_GMAC_OP_GENERATE) { + qp->ops[session->key].gmac_init(&session->gdata_key, + &qp->gdata_ctx, + iv_ptr, + session->iv.length); + + qp->ops[session->key].gmac_update(&session->gdata_key, + &qp->gdata_ctx, src, + (uint64_t)part_len); + total_len = data_length - part_len; + + while (total_len) { + m_src = m_src->next; + + RTE_ASSERT(m_src != NULL); + + src = rte_pktmbuf_mtod(m_src, uint8_t *); + part_len = (m_src->data_len < total_len) ? + m_src->data_len : total_len; + + qp->ops[session->key].gmac_update(&session->gdata_key, + &qp->gdata_ctx, src, + (uint64_t)part_len); + total_len -= part_len; + } + + if (session->req_digest_length != session->gen_digest_length) + tag = qp->temp_digest; + else + tag = sym_op->auth.digest.data; + + qp->ops[session->key].gmac_finalize(&session->gdata_key, + &qp->gdata_ctx, + tag, + session->gen_digest_length); + } else { /* AESNI_GMAC_OP_VERIFY */ + qp->ops[session->key].gmac_init(&session->gdata_key, + &qp->gdata_ctx, + iv_ptr, + session->iv.length); + + qp->ops[session->key].gmac_update(&session->gdata_key, + &qp->gdata_ctx, src, + (uint64_t)part_len); + total_len = data_length - part_len; + + while (total_len) { + m_src = m_src->next; + + RTE_ASSERT(m_src != NULL); + + src = rte_pktmbuf_mtod(m_src, uint8_t *); + part_len = (m_src->data_len < total_len) ? + m_src->data_len : total_len; + + qp->ops[session->key].gmac_update(&session->gdata_key, + &qp->gdata_ctx, src, + (uint64_t)part_len); + total_len -= part_len; + } + + tag = qp->temp_digest; + + qp->ops[session->key].gmac_finalize(&session->gdata_key, + &qp->gdata_ctx, + tag, + session->gen_digest_length); + } +#else } else if (session->op == AESNI_GMAC_OP_GENERATE) { qp->ops[session->key].init(&session->gdata_key, &qp->gdata_ctx, @@ -381,6 +451,7 @@ process_gcm_crypto_op(struct aesni_gcm_qp *qp, struct rte_crypto_op *op, tag, session->gen_digest_length); } +#endif return 0; } @@ -769,7 +840,7 @@ aesni_gcm_create(const char *name, init_mb_mgr_avx2(mb_mgr); break; case RTE_AESNI_GCM_AVX512: - dev->feature_flags |= RTE_CRYPTODEV_FF_CPU_AVX2; + dev->feature_flags |= RTE_CRYPTODEV_FF_CPU_AVX512; init_mb_mgr_avx512(mb_mgr); break; default: @@ -791,6 +862,11 @@ aesni_gcm_create(const char *name, internals->ops[GCM_KEY_128].update_dec = mb_mgr->gcm128_dec_update; internals->ops[GCM_KEY_128].finalize_enc = mb_mgr->gcm128_enc_finalize; internals->ops[GCM_KEY_128].finalize_dec = mb_mgr->gcm128_dec_finalize; +#if IMB_VERSION(0, 54, 0) < IMB_VERSION_NUM + internals->ops[GCM_KEY_128].gmac_init = mb_mgr->gmac128_init; + internals->ops[GCM_KEY_128].gmac_update = mb_mgr->gmac128_update; + internals->ops[GCM_KEY_128].gmac_finalize = mb_mgr->gmac128_finalize; +#endif internals->ops[GCM_KEY_192].enc = mb_mgr->gcm192_enc; internals->ops[GCM_KEY_192].dec = mb_mgr->gcm192_dec; @@ -800,6 +876,11 @@ aesni_gcm_create(const char *name, internals->ops[GCM_KEY_192].update_dec = mb_mgr->gcm192_dec_update; internals->ops[GCM_KEY_192].finalize_enc = mb_mgr->gcm192_enc_finalize; internals->ops[GCM_KEY_192].finalize_dec = mb_mgr->gcm192_dec_finalize; +#if IMB_VERSION(0, 54, 0) < IMB_VERSION_NUM + internals->ops[GCM_KEY_192].gmac_init = mb_mgr->gmac192_init; + internals->ops[GCM_KEY_192].gmac_update = mb_mgr->gmac192_update; + internals->ops[GCM_KEY_192].gmac_finalize = mb_mgr->gmac192_finalize; +#endif internals->ops[GCM_KEY_256].enc = mb_mgr->gcm256_enc; internals->ops[GCM_KEY_256].dec = mb_mgr->gcm256_dec; @@ -809,6 +890,11 @@ aesni_gcm_create(const char *name, internals->ops[GCM_KEY_256].update_dec = mb_mgr->gcm256_dec_update; internals->ops[GCM_KEY_256].finalize_enc = mb_mgr->gcm256_enc_finalize; internals->ops[GCM_KEY_256].finalize_dec = mb_mgr->gcm256_dec_finalize; +#if IMB_VERSION(0, 54, 0) < IMB_VERSION_NUM + internals->ops[GCM_KEY_256].gmac_init = mb_mgr->gmac256_init; + internals->ops[GCM_KEY_256].gmac_update = mb_mgr->gmac256_update; + internals->ops[GCM_KEY_256].gmac_finalize = mb_mgr->gmac256_finalize; +#endif internals->max_nb_queue_pairs = init_params->max_nb_queue_pairs; From patchwork Tue Sep 22 10:34:30 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "De Lara Guarch, Pablo" X-Patchwork-Id: 78396 X-Patchwork-Delegate: gakhil@marvell.com Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from dpdk.org (dpdk.org [92.243.14.124]) by inbox.dpdk.org (Postfix) with ESMTP id 2A05DA04B5; Tue, 22 Sep 2020 12:34:47 +0200 (CEST) Received: from [92.243.14.124] (localhost [127.0.0.1]) by dpdk.org (Postfix) with ESMTP id B89AC1DC41; Tue, 22 Sep 2020 12:34:42 +0200 (CEST) Received: from mga17.intel.com (mga17.intel.com [192.55.52.151]) by dpdk.org (Postfix) with ESMTP id 8016F1DC54 for ; Tue, 22 Sep 2020 12:34:41 +0200 (CEST) IronPort-SDR: M0iPyOmplzCBMvyocZIJ4rX7banTBj+rXwzu7C3ZxRVcNSrraX6nosU/lGQyNrZI7/u+AyQT+g //s+RRzQ/0kA== X-IronPort-AV: E=McAfee;i="6000,8403,9751"; a="140580857" X-IronPort-AV: E=Sophos;i="5.77,290,1596524400"; d="scan'208";a="140580857" X-Amp-Result: SKIPPED(no attachment in message) X-Amp-File-Uploaded: False Received: from fmsmga002.fm.intel.com ([10.253.24.26]) by fmsmga107.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 22 Sep 2020 03:34:41 -0700 IronPort-SDR: YSEbhEtlo/ZBQ+MHT5MR8CBEV0kbFmJ5nG4+TK0teW23rdUKRGlIv/DDpRkjy1UAJ4717/FN98 PibejpOcZCyw== X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.77,290,1596524400"; d="scan'208";a="341971587" Received: from silpixa00400637.ir.intel.com ([10.237.213.160]) by fmsmga002.fm.intel.com with ESMTP; 22 Sep 2020 03:34:39 -0700 From: Pablo de Lara To: declan.doherty@intel.com Cc: dev@dpdk.org, Pablo de Lara Date: Tue, 22 Sep 2020 10:34:30 +0000 Message-Id: <20200922103430.128456-2-pablo.de.lara.guarch@intel.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20200922103430.128456-1-pablo.de.lara.guarch@intel.com> References: <20200922100111.128316-1-pablo.de.lara.guarch@intel.com> <20200922103430.128456-1-pablo.de.lara.guarch@intel.com> MIME-Version: 1.0 Subject: [dpdk-dev] [PATCH v3 2/2] test/crypto: add GMAC SGL tests X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org Sender: "dev" Add Scatter-Gather List tests for AES-GMAC. Signed-off-by: Pablo de Lara --- Changes: v3: - Fixed checkpatch issues v2: - Modified segment size to make reduce maximum number of segments needed --- app/test/test_cryptodev.c | 216 ++++++++++++++++++++++++++++++++++++++ app/test/test_cryptodev.h | 4 +- 2 files changed, 218 insertions(+), 2 deletions(-) diff --git a/app/test/test_cryptodev.c b/app/test/test_cryptodev.c index 70bf6fe2c..5d009e096 100644 --- a/app/test/test_cryptodev.c +++ b/app/test/test_cryptodev.c @@ -9995,6 +9995,53 @@ create_gmac_operation(enum rte_crypto_auth_operation op, return 0; } +static int +create_gmac_operation_sgl(enum rte_crypto_auth_operation op, + const struct gmac_test_data *tdata, + void *digest_mem, uint64_t digest_phys) +{ + struct crypto_testsuite_params *ts_params = &testsuite_params; + struct crypto_unittest_params *ut_params = &unittest_params; + struct rte_crypto_sym_op *sym_op; + + /* Generate Crypto op data structure */ + ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, + RTE_CRYPTO_OP_TYPE_SYMMETRIC); + TEST_ASSERT_NOT_NULL(ut_params->op, + "Failed to allocate symmetric crypto operation struct"); + + sym_op = ut_params->op->sym; + + sym_op->auth.digest.data = digest_mem; + TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data, + "no room to append digest"); + + sym_op->auth.digest.phys_addr = digest_phys; + + if (op == RTE_CRYPTO_AUTH_OP_VERIFY) { + rte_memcpy(sym_op->auth.digest.data, tdata->gmac_tag.data, + tdata->gmac_tag.len); + debug_hexdump(stdout, "digest:", + sym_op->auth.digest.data, + tdata->gmac_tag.len); + } + + uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op, + uint8_t *, IV_OFFSET); + + rte_memcpy(iv_ptr, tdata->iv.data, tdata->iv.len); + + debug_hexdump(stdout, "iv:", iv_ptr, tdata->iv.len); + + sym_op->cipher.data.length = 0; + sym_op->cipher.data.offset = 0; + + sym_op->auth.data.offset = 0; + sym_op->auth.data.length = tdata->plaintext.len; + + return 0; +} + static int create_gmac_session(uint8_t dev_id, const struct gmac_test_data *tdata, enum rte_crypto_auth_operation auth_op) @@ -10251,6 +10298,166 @@ test_AES_GMAC_authentication_verify_test_case_4(void) return test_AES_GMAC_authentication_verify(&gmac_test_case_4); } +static int +test_AES_GMAC_authentication_SGL(const struct gmac_test_data *tdata, + uint32_t fragsz) +{ + struct crypto_testsuite_params *ts_params = &testsuite_params; + struct crypto_unittest_params *ut_params = &unittest_params; + struct rte_cryptodev_info dev_info; + uint64_t feature_flags; + unsigned int trn_data = 0; + void *digest_mem = NULL; + uint32_t segs = 1; + unsigned int to_trn = 0; + struct rte_mbuf *buf = NULL; + uint8_t *auth_tag, *plaintext; + int retval; + + TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0, + "No GMAC length in the source data"); + + /* Verify the capabilities */ + struct rte_cryptodev_sym_capability_idx cap_idx; + cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH; + cap_idx.algo.auth = RTE_CRYPTO_AUTH_AES_GMAC; + if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], + &cap_idx) == NULL) + return -ENOTSUP; + + /* Check for any input SGL support */ + rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); + feature_flags = dev_info.feature_flags; + + if ((!(feature_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) && + (!(feature_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_LB_OUT)) && + (!(feature_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT))) + return -ENOTSUP; + + if (fragsz > tdata->plaintext.len) + fragsz = tdata->plaintext.len; + + uint16_t plaintext_len = fragsz; + + retval = create_gmac_session(ts_params->valid_devs[0], + tdata, RTE_CRYPTO_AUTH_OP_GENERATE); + + if (retval < 0) + return retval; + + ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); + TEST_ASSERT_NOT_NULL(ut_params->ibuf, + "Failed to allocate input buffer in mempool"); + + memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, + rte_pktmbuf_tailroom(ut_params->ibuf)); + + plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, + plaintext_len); + TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext"); + + memcpy(plaintext, tdata->plaintext.data, plaintext_len); + + trn_data += plaintext_len; + + buf = ut_params->ibuf; + + /* + * Loop until no more fragments + */ + + while (trn_data < tdata->plaintext.len) { + ++segs; + to_trn = (tdata->plaintext.len - trn_data < fragsz) ? + (tdata->plaintext.len - trn_data) : fragsz; + + buf->next = rte_pktmbuf_alloc(ts_params->mbuf_pool); + buf = buf->next; + + memset(rte_pktmbuf_mtod(buf, uint8_t *), 0, + rte_pktmbuf_tailroom(buf)); + + plaintext = (uint8_t *)rte_pktmbuf_append(buf, + to_trn); + + memcpy(plaintext, tdata->plaintext.data + trn_data, + to_trn); + trn_data += to_trn; + if (trn_data == tdata->plaintext.len) + digest_mem = (uint8_t *)rte_pktmbuf_append(buf, + tdata->gmac_tag.len); + } + ut_params->ibuf->nb_segs = segs; + + /* + * Place digest at the end of the last buffer + */ + uint64_t digest_phys = rte_pktmbuf_iova(buf) + to_trn; + + if (!digest_mem) { + digest_mem = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, + + tdata->gmac_tag.len); + digest_phys = rte_pktmbuf_iova_offset(ut_params->ibuf, + tdata->plaintext.len); + } + + retval = create_gmac_operation_sgl(RTE_CRYPTO_AUTH_OP_GENERATE, + tdata, digest_mem, digest_phys); + + if (retval < 0) + return retval; + + rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); + + ut_params->op->sym->m_src = ut_params->ibuf; + + if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) + return -ENOTSUP; + + TEST_ASSERT_NOT_NULL( + process_crypto_request(ts_params->valid_devs[0], + ut_params->op), "failed to process sym crypto op"); + + TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, + "crypto op processing failed"); + + auth_tag = digest_mem; + debug_hexdump(stdout, "auth tag:", auth_tag, tdata->gmac_tag.len); + TEST_ASSERT_BUFFERS_ARE_EQUAL( + auth_tag, + tdata->gmac_tag.data, + tdata->gmac_tag.len, + "GMAC Generated auth tag not as expected"); + + return 0; +} + +/* Segment size not multiple of block size (16B) */ +static int +test_AES_GMAC_authentication_SGL_40B(void) +{ + return test_AES_GMAC_authentication_SGL(&gmac_test_case_1, 40); +} + +static int +test_AES_GMAC_authentication_SGL_80B(void) +{ + return test_AES_GMAC_authentication_SGL(&gmac_test_case_1, 80); +} + +static int +test_AES_GMAC_authentication_SGL_4096B(void) +{ + return test_AES_GMAC_authentication_SGL(&gmac_test_case_4, 4096); +} + +/* Segment size not multiple of block size (16B) */ +static int +test_AES_GMAC_authentication_SGL_4097B(void) +{ + return test_AES_GMAC_authentication_SGL(&gmac_test_case_4, 4097); +} + struct test_crypto_vector { enum rte_crypto_cipher_algorithm crypto_algo; unsigned int cipher_offset; @@ -12164,6 +12371,15 @@ static struct unit_test_suite cryptodev_testsuite = { test_AES_GMAC_authentication_test_case_4), TEST_CASE_ST(ut_setup, ut_teardown, test_AES_GMAC_authentication_verify_test_case_4), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GMAC_authentication_SGL_40B), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GMAC_authentication_SGL_80B), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GMAC_authentication_SGL_4096B), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GMAC_authentication_SGL_4097B), + /** Chacha20-Poly1305 */ TEST_CASE_ST(ut_setup, ut_teardown, test_chacha20_poly1305_encrypt_test_case_rfc8439), diff --git a/app/test/test_cryptodev.h b/app/test/test_cryptodev.h index 41542e055..57003733b 100644 --- a/app/test/test_cryptodev.h +++ b/app/test/test_cryptodev.h @@ -17,9 +17,9 @@ #define DEFAULT_NUM_QPS_PER_QAT_DEVICE (2) #define DEFAULT_BURST_SIZE (64) #define DEFAULT_NUM_XFORMS (2) -#define NUM_MBUFS (8191) +#define NUM_MBUFS (4095) #define MBUF_CACHE_SIZE (256) -#define MBUF_DATAPAYLOAD_SIZE (2048 + DIGEST_BYTE_LENGTH_SHA512) +#define MBUF_DATAPAYLOAD_SIZE (4096 + DIGEST_BYTE_LENGTH_SHA512) #define MBUF_SIZE (sizeof(struct rte_mbuf) + \ RTE_PKTMBUF_HEADROOM + MBUF_DATAPAYLOAD_SIZE)