From: Suanming Mou <suanmingm@nvidia.com>
To: Fan Zhang <roy.fan.zhang@intel.com>, <dev@dpdk.org>
Cc: <akhil.goyal@nxp.com>, <fiona.trahe@intel.com>,
<arkadiuszx.kusztal@intel.com>, <adamx.dybkowski@intel.com>
Subject: Re: [dpdk-dev] [dpdk-dev v2 1/2] fips_validation: add SGL support
Date: Mon, 7 Sep 2020 21:32:13 +0800 [thread overview]
Message-ID: <b9593ab0-3592-3d16-150a-ecc09d204332@nvidia.com> (raw)
In-Reply-To: <20200904160945.24590-2-roy.fan.zhang@intel.com>
Hi,
On 9/5/2020 12:09 AM, Fan Zhang wrote:
> This patch adds SGL support to FIPS sample application.
> Originally the application allocates single mbuf of 64KB - 1
> bytes data room. With the change the user may reduce the
> mbuf dataroom size by using the add cmdline option. If the
> input test data is longer than the user provided data room
> size the application will automatically build chained mbufs
> for the target cryptodev PMD to test.
>
> Signed-off-by: Fan Zhang <roy.fan.zhang@intel.com>
> ---
> doc/guides/sample_app_ug/fips_validation.rst | 6 +
> examples/fips_validation/fips_validation.h | 3 +-
> examples/fips_validation/main.c | 377 +++++++++++++------
> 3 files changed, 271 insertions(+), 115 deletions(-)
>
> diff --git a/doc/guides/sample_app_ug/fips_validation.rst b/doc/guides/sample_app_ug/fips_validation.rst
> index 2953fddeb..8d3db2214 100644
> --- a/doc/guides/sample_app_ug/fips_validation.rst
> +++ b/doc/guides/sample_app_ug/fips_validation.rst
> @@ -96,6 +96,7 @@ The application requires a number of command line options:
> -- --req-file FILE_PATH/FOLDER_PATH
> --rsp-file FILE_PATH/FOLDER_PATH
> [--cryptodev DEVICE_NAME] [--cryptodev-id ID] [--path-is-folder]
> + --mbuf-dataroom DATAROOM_SIZE
>
> where,
> * req-file: The path of the request file or folder, separated by
> @@ -111,6 +112,11 @@ where,
> * path-is-folder: If presented the application expects req-file and rsp-file
> are folder paths.
>
> + * mbuf-dataroom: By default the application creates mbuf pool with maximum
> + possible data room (65535 bytes). If the user wants to test scatter-gather
> + list feature of the PMD he or she may set this value to reduce the dataroom
> + size so that the input data may be dividied into multiple chained mbufs.
> +
>
> To run the application in linux environment to test one AES FIPS test data
> file for crypto_aesni_mb PMD, issue the command:
> diff --git a/examples/fips_validation/fips_validation.h b/examples/fips_validation/fips_validation.h
> index 75fa555fa..ecf3d54dd 100644
> --- a/examples/fips_validation/fips_validation.h
> +++ b/examples/fips_validation/fips_validation.h
> @@ -12,7 +12,8 @@
> #define MAX_CASE_LINE 15
> #define MAX_LINE_CHAR 204800 /*< max number of characters per line */
> #define MAX_NB_TESTS 10240
> -#define MAX_BUF_SIZE 2048
> +#define DEF_MBUF_SEG_SIZE (UINT16_MAX - sizeof(struct rte_mbuf) - \
> + RTE_PKTMBUF_HEADROOM)
> #define MAX_STRING_SIZE 64
> #define MAX_DIGEST_SIZE 64
>
> diff --git a/examples/fips_validation/main.c b/examples/fips_validation/main.c
> index efd32a86a..fadca6e0c 100644
> --- a/examples/fips_validation/main.c
> +++ b/examples/fips_validation/main.c
> @@ -17,6 +17,7 @@
>
> #define REQ_FILE_PATH_KEYWORD "req-file"
> #define RSP_FILE_PATH_KEYWORD "rsp-file"
> +#define MBUF_DATAROOM_KEYWORD "mbuf-dataroom"
> #define FOLDER_KEYWORD "path-is-folder"
> #define CRYPTODEV_KEYWORD "cryptodev"
> #define CRYPTODEV_ID_KEYWORD "cryptodev-id"
> @@ -33,15 +34,19 @@ struct cryptodev_fips_validate_env {
> const char *req_path;
> const char *rsp_path;
> uint32_t is_path_folder;
> - uint32_t dev_id;
> + uint8_t dev_id;
> + uint8_t dev_support_sgl;
> + uint16_t mbuf_data_room;
> struct rte_mempool *mpool;
> struct rte_mempool *sess_mpool;
> struct rte_mempool *sess_priv_mpool;
> struct rte_mempool *op_pool;
> struct rte_mbuf *mbuf;
> + uint8_t *digest;
> + uint16_t digest_len;
> struct rte_crypto_op *op;
> struct rte_cryptodev_sym_session *sess;
> - uint32_t self_test;
> + uint16_t self_test;
> struct fips_dev_broken_test_config *broken_test_config;
> } env;
>
> @@ -50,8 +55,10 @@ cryptodev_fips_validate_app_int(void)
> {
> struct rte_cryptodev_config conf = {rte_socket_id(), 1, 0};
> struct rte_cryptodev_qp_conf qp_conf = {128, NULL, NULL};
> + struct rte_cryptodev_info dev_info;
Better to initialize the dev_info here?
> uint32_t sess_sz = rte_cryptodev_sym_get_private_session_size(
> env.dev_id);
> + uint32_t nb_mbufs = UINT16_MAX / env.mbuf_data_room + 1;
> int ret;
>
> if (env.self_test) {
> @@ -70,8 +77,15 @@ cryptodev_fips_validate_app_int(void)
> if (ret < 0)
> return ret;
>
> - env.mpool = rte_pktmbuf_pool_create("FIPS_MEMPOOL", 128, 0, 0,
> - UINT16_MAX, rte_socket_id());
> + rte_cryptodev_info_get(env.dev_id, &dev_info);
> + if (dev_info.feature_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)
> + env.dev_support_sgl = 1;
> + else
> + env.dev_support_sgl = 0;
> +
> + env.mpool = rte_pktmbuf_pool_create("FIPS_MEMPOOL", nb_mbufs,
> + 0, 0, sizeof(struct rte_mbuf) + RTE_PKTMBUF_HEADROOM +
> + env.mbuf_data_room, rte_socket_id());
> if (!env.mpool)
> return ret;
>
> @@ -102,10 +116,6 @@ cryptodev_fips_validate_app_int(void)
> if (!env.op_pool)
> goto error_exit;
>
> - env.mbuf = rte_pktmbuf_alloc(env.mpool);
> - if (!env.mbuf)
> - goto error_exit;
> -
> env.op = rte_crypto_op_alloc(env.op_pool, RTE_CRYPTO_OP_TYPE_SYMMETRIC);
> if (!env.op)
> goto error_exit;
> @@ -160,7 +170,7 @@ parse_cryptodev_arg(char *arg)
> return id;
> }
>
> - env.dev_id = (uint32_t)id;
> + env.dev_id = (uint8_t)id;
>
> return 0;
> }
> @@ -191,19 +201,21 @@ parse_cryptodev_id_arg(char *arg)
> static void
> cryptodev_fips_validate_usage(const char *prgname)
> {
> + uint32_t def_mbuf_seg_size = DEF_MBUF_SEG_SIZE;
> printf("%s [EAL options] --\n"
> " --%s: REQUEST-FILE-PATH\n"
> " --%s: RESPONSE-FILE-PATH\n"
> " --%s: indicating both paths are folders\n"
> + " --%s: mbuf dataroom size (default %u bytes)\n"
> " --%s: CRYPTODEV-NAME\n"
> " --%s: CRYPTODEV-ID-NAME\n"
> " --%s: self test indicator\n"
> " --%s: self broken test ID\n"
> " --%s: self broken test direction\n",
> prgname, REQ_FILE_PATH_KEYWORD, RSP_FILE_PATH_KEYWORD,
> - FOLDER_KEYWORD, CRYPTODEV_KEYWORD, CRYPTODEV_ID_KEYWORD,
> - CRYPTODEV_ST_KEYWORD, CRYPTODEV_BK_ID_KEYWORD,
> - CRYPTODEV_BK_DIR_KEY);
> + FOLDER_KEYWORD, MBUF_DATAROOM_KEYWORD, def_mbuf_seg_size,
> + CRYPTODEV_KEYWORD, CRYPTODEV_ID_KEYWORD, CRYPTODEV_ST_KEYWORD,
> + CRYPTODEV_BK_ID_KEYWORD, CRYPTODEV_BK_DIR_KEY);
> }
>
> static int
> @@ -217,6 +229,7 @@ cryptodev_fips_validate_parse_args(int argc, char **argv)
> {REQ_FILE_PATH_KEYWORD, required_argument, 0, 0},
> {RSP_FILE_PATH_KEYWORD, required_argument, 0, 0},
> {FOLDER_KEYWORD, no_argument, 0, 0},
> + {MBUF_DATAROOM_KEYWORD, required_argument, 0, 0},
> {CRYPTODEV_KEYWORD, required_argument, 0, 0},
> {CRYPTODEV_ID_KEYWORD, required_argument, 0, 0},
> {CRYPTODEV_ST_KEYWORD, no_argument, 0, 0},
> @@ -227,6 +240,14 @@ cryptodev_fips_validate_parse_args(int argc, char **argv)
>
> argvopt = argv;
>
> + env.mbuf_data_room = DEF_MBUF_SEG_SIZE;
> + if (rte_cryptodev_count())
> + env.dev_id = 0;
> + else {
> + cryptodev_fips_validate_usage(prgname);
> + return -EINVAL;
> + }
> +
> while ((opt = getopt_long(argc, argvopt, "s:",
> lgopts, &option_index)) != EOF) {
>
> @@ -305,6 +326,23 @@ cryptodev_fips_validate_parse_args(int argc, char **argv)
> cryptodev_fips_validate_usage(prgname);
> return -EINVAL;
> }
> + } else if (strcmp(lgopts[option_index].name,
> + MBUF_DATAROOM_KEYWORD) == 0) {
> + uint32_t data_room_size;
> +
> + if (parser_read_uint32(&data_room_size,
> + optarg) < 0) {
> + cryptodev_fips_validate_usage(prgname);
> + return -EINVAL;
> + }
> +
> + if (data_room_size == 0 ||
> + data_room_size > UINT16_MAX) {
> + cryptodev_fips_validate_usage(prgname);
> + return -EINVAL;
> + }
> +
> + env.mbuf_data_room = data_room_size;
> } else {
> cryptodev_fips_validate_usage(prgname);
> return -EINVAL;
> @@ -315,8 +353,7 @@ cryptodev_fips_validate_parse_args(int argc, char **argv)
> }
> }
>
> - if (env.req_path == NULL || env.rsp_path == NULL ||
> - env.dev_id == UINT32_MAX) {
> + if (env.req_path == NULL || env.rsp_path == NULL) {
> cryptodev_fips_validate_usage(prgname);
> return -EINVAL;
> }
> @@ -451,60 +488,124 @@ struct fips_test_ops {
> } test_ops;
>
> static int
> -prepare_cipher_op(void)
> +prepare_data_mbufs(struct fips_val *val)
> {
> - struct rte_crypto_sym_op *sym = env.op->sym;
> - uint8_t *iv = rte_crypto_op_ctod_offset(env.op, uint8_t *, IV_OFF);
> + struct rte_mbuf *m, *head = 0;
> + uint8_t *src = val->val;
> + uint32_t total_len = val->len;
> + uint16_t nb_seg;
> + int ret = 0;
>
> - __rte_crypto_op_reset(env.op, RTE_CRYPTO_OP_TYPE_SYMMETRIC);
> - rte_pktmbuf_reset(env.mbuf);
> -
> - sym->m_src = env.mbuf;
> - sym->cipher.data.offset = 0;
> + if (env.mbuf)
> + rte_pktmbuf_free(env.mbuf);
>
> - memcpy(iv, vec.iv.val, vec.iv.len);
> + if (total_len > RTE_MBUF_MAX_NB_SEGS) {
> + RTE_LOG(ERR, USER1, "Data len %u too big\n", total_len);
> + return -EPERM;
> + }
>
> - if (info.op == FIPS_TEST_ENC_AUTH_GEN) {
> - uint8_t *pt;
> + nb_seg = total_len / env.mbuf_data_room;
> + if (total_len % env.mbuf_data_room)
> + nb_seg++;
>
> - if (vec.pt.len > RTE_MBUF_MAX_NB_SEGS) {
> - RTE_LOG(ERR, USER1, "PT len %u\n", vec.pt.len);
> - return -EPERM;
> - }
> + m = rte_pktmbuf_alloc(env.mpool);
> + if (!m) {
> + RTE_LOG(ERR, USER1, "Error %i: Not enough mbuf\n",
> + -ENOMEM);
> + return -ENOMEM;
> + }
> + head = m;
>
> - pt = (uint8_t *)rte_pktmbuf_append(env.mbuf, vec.pt.len);
> + while (nb_seg) {
> + uint16_t len = RTE_MIN(total_len, env.mbuf_data_room);
> + uint8_t *dst = (uint8_t *)rte_pktmbuf_append(m, len);
>
> - if (!pt) {
> + if (!dst) {
> RTE_LOG(ERR, USER1, "Error %i: MBUF too small\n",
> -ENOMEM);
> - return -ENOMEM;
> + ret = -ENOMEM;
> + goto error_exit;
> }
>
> - memcpy(pt, vec.pt.val, vec.pt.len);
> - sym->cipher.data.length = vec.pt.len;
> + memcpy(dst, src, len);
>
> - } else {
> - uint8_t *ct;
> -
> - if (vec.ct.len > RTE_MBUF_MAX_NB_SEGS) {
> - RTE_LOG(ERR, USER1, "CT len %u\n", vec.ct.len);
> - return -EPERM;
> + if (head != m) {
> + ret = rte_pktmbuf_chain(head, m);
> + if (ret) {
> + rte_pktmbuf_free(m);
> + RTE_LOG(ERR, USER1, "Error %i: SGL build\n",
> + ret);
> + goto error_exit;
> + }
> }
> + total_len -= len;
>
> - ct = (uint8_t *)rte_pktmbuf_append(env.mbuf, vec.ct.len);
> + if (total_len) {
> + if (!env.dev_support_sgl) {
> + RTE_LOG(ERR, USER1, "SGL not supported\n");
> + ret = -EPERM;
> + goto error_exit;
> + }
>
> - if (!ct) {
> - RTE_LOG(ERR, USER1, "Error %i: MBUF too small\n",
> - -ENOMEM);
> - return -ENOMEM;
> - }
> + m = rte_pktmbuf_alloc(env.mpool);
> + if (!m) {
> + RTE_LOG(ERR, USER1, "Error %i: No memory\n",
> + -ENOMEM);
> + goto error_exit;
> + }
> + } else
> + break;
> +
> + src += len;
> + nb_seg--;
> + }
> +
> + if (total_len) {
> + RTE_LOG(ERR, USER1, "Error %i: Failed to store all data\n",
> + -ENOMEM);
> + goto error_exit;
> + }
> +
> + env.mbuf = head;
> +
> + return 0;
> +
> +error_exit:
> + if (head)
> + rte_pktmbuf_free(head);
> + return ret;
> +}
> +
> +static int
> +prepare_cipher_op(void)
> +{
> + struct rte_crypto_sym_op *sym = env.op->sym;
> + uint8_t *iv = rte_crypto_op_ctod_offset(env.op, uint8_t *, IV_OFF);
> + int ret;
> +
> + __rte_crypto_op_reset(env.op, RTE_CRYPTO_OP_TYPE_SYMMETRIC);
> +
> + memcpy(iv, vec.iv.val, vec.iv.len);
> +
> + if (info.op == FIPS_TEST_ENC_AUTH_GEN) {
> + ret = prepare_data_mbufs(&vec.pt);
> + if (ret < 0)
> + return ret;
> +
> + sym->cipher.data.length = vec.pt.len;
> + } else {
> + ret = prepare_data_mbufs(&vec.ct);
> + if (ret < 0)
> + return ret;
>
> - memcpy(ct, vec.ct.val, vec.ct.len);
> sym->cipher.data.length = vec.ct.len;
> }
>
> rte_crypto_op_attach_sym_session(env.op, env.sess);
>
> + sym->m_src = env.mbuf;
> + sym->cipher.data.offset = 0;
> +
> return 0;
> }
>
> @@ -512,32 +613,33 @@ static int
> prepare_auth_op(void)
> {
> struct rte_crypto_sym_op *sym = env.op->sym;
> - uint8_t *pt;
> + int ret;
>
> __rte_crypto_op_reset(env.op, RTE_CRYPTO_OP_TYPE_SYMMETRIC);
> - rte_pktmbuf_reset(env.mbuf);
>
> - sym->m_src = env.mbuf;
> - sym->auth.data.offset = 0;
> + ret = prepare_data_mbufs(&vec.pt);
> + if (ret < 0)
> + return ret;
>
> - pt = (uint8_t *)rte_pktmbuf_append(env.mbuf, vec.pt.len +
> - vec.cipher_auth.digest.len);
> + if (env.digest)
> + rte_free(env.digest);
>
> - if (!pt) {
> - RTE_LOG(ERR, USER1, "Error %i: MBUF too small\n",
> - -ENOMEM);
> + env.digest = rte_zmalloc(NULL, vec.cipher_auth.digest.len,
> + RTE_CACHE_LINE_SIZE);
> + if (!env.digest) {
> + RTE_LOG(ERR, USER1, "Not enough memory\n");
> return -ENOMEM;
> }
> + env.digest_len = vec.cipher_auth.digest.len;
>
> + sym->m_src = env.mbuf;
> + sym->auth.data.offset = 0;
> sym->auth.data.length = vec.pt.len;
> - sym->auth.digest.data = pt + vec.pt.len;
> - sym->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
> - env.mbuf, vec.pt.len);
> -
> - memcpy(pt, vec.pt.val, vec.pt.len);
> + sym->auth.digest.data = env.digest;
> + sym->auth.digest.phys_addr = rte_malloc_virt2iova(env.digest);
>
> if (info.op == FIPS_TEST_DEC_AUTH_VERIF)
> - memcpy(pt + vec.pt.len, vec.cipher_auth.digest.val,
> + memcpy(env.digest, vec.cipher_auth.digest.val,
> vec.cipher_auth.digest.len);
>
> rte_crypto_op_attach_sym_session(env.op, env.sess);
> @@ -550,65 +652,53 @@ prepare_aead_op(void)
> {
> struct rte_crypto_sym_op *sym = env.op->sym;
> uint8_t *iv = rte_crypto_op_ctod_offset(env.op, uint8_t *, IV_OFF);
> + int ret;
>
> __rte_crypto_op_reset(env.op, RTE_CRYPTO_OP_TYPE_SYMMETRIC);
> - rte_pktmbuf_reset(env.mbuf);
>
> if (info.algo == FIPS_TEST_ALGO_AES_CCM)
> - memcpy(iv + 1, vec.iv.val, vec.iv.len);
> - else
> - memcpy(iv, vec.iv.val, vec.iv.len);
> + iv++;
>
> - sym->m_src = env.mbuf;
> - sym->aead.data.offset = 0;
> - sym->aead.aad.data = vec.aead.aad.val;
> - sym->aead.aad.phys_addr = rte_malloc_virt2iova(sym->aead.aad.data);
> + if (vec.iv.val)
> + memcpy(iv, vec.iv.val, vec.iv.len);
> + else
> + /* if REQ file has iv length but not data, default as all 0 */
> + memset(iv, 0, vec.iv.len);
>
> if (info.op == FIPS_TEST_ENC_AUTH_GEN) {
> - uint8_t *pt;
> -
> - if (vec.pt.len > RTE_MBUF_MAX_NB_SEGS) {
> - RTE_LOG(ERR, USER1, "PT len %u\n", vec.pt.len);
> - return -EPERM;
> - }
> -
> - pt = (uint8_t *)rte_pktmbuf_append(env.mbuf,
> - vec.pt.len + vec.aead.digest.len);
> + ret = prepare_data_mbufs(&vec.pt);
> + if (ret < 0)
> + return ret;
>
> - if (!pt) {
> - RTE_LOG(ERR, USER1, "Error %i: MBUF too small\n",
> - -ENOMEM);
> + if (env.digest)
> + rte_free(env.digest);
> + env.digest = rte_zmalloc(NULL, vec.aead.digest.len,
> + RTE_CACHE_LINE_SIZE);
> + if (!env.digest) {
> + RTE_LOG(ERR, USER1, "Not enough memory\n");
> return -ENOMEM;
> }
> + env.digest_len = vec.cipher_auth.digest.len;
>
> - memcpy(pt, vec.pt.val, vec.pt.len);
> sym->aead.data.length = vec.pt.len;
> - sym->aead.digest.data = pt + vec.pt.len;
> - sym->aead.digest.phys_addr = rte_pktmbuf_mtophys_offset(
> - env.mbuf, vec.pt.len);
> + sym->aead.digest.data = env.digest;
> + sym->aead.digest.phys_addr = rte_malloc_virt2iova(env.digest);
> } else {
> - uint8_t *ct;
> -
> - if (vec.ct.len > RTE_MBUF_MAX_NB_SEGS) {
> - RTE_LOG(ERR, USER1, "CT len %u\n", vec.ct.len);
> - return -EPERM;
> - }
> -
> - ct = (uint8_t *)rte_pktmbuf_append(env.mbuf, vec.ct.len);
> -
> - if (!ct) {
> - RTE_LOG(ERR, USER1, "Error %i: MBUF too small\n",
> - -ENOMEM);
> - return -ENOMEM;
> - }
> + ret = prepare_data_mbufs(&vec.ct);
> + if (ret < 0)
> + return ret;
>
> - memcpy(ct, vec.ct.val, vec.ct.len);
> sym->aead.data.length = vec.ct.len;
> sym->aead.digest.data = vec.aead.digest.val;
> sym->aead.digest.phys_addr = rte_malloc_virt2iova(
> sym->aead.digest.data);
> }
>
> + sym->m_src = env.mbuf;
> + sym->aead.data.offset = 0;
> + sym->aead.aad.data = vec.aead.aad.val;
> + sym->aead.aad.phys_addr = rte_malloc_virt2iova(sym->aead.aad.data);
> +
> rte_crypto_op_attach_sym_session(env.op, env.sess);
>
> return 0;
> @@ -952,11 +1042,48 @@ prepare_xts_xform(struct rte_crypto_sym_xform *xform)
> return 0;
> }
>
> -static void
> +static int
> get_writeback_data(struct fips_val *val)
> {
> - val->val = rte_pktmbuf_mtod(env.mbuf, uint8_t *);
> - val->len = rte_pktmbuf_pkt_len(env.mbuf);
> + struct rte_mbuf *m = env.mbuf;
> + uint16_t data_len = rte_pktmbuf_pkt_len(m);
> + uint16_t total_len = data_len + env.digest_len;
> + uint8_t *src, *dst, *wb_data;
> +
> + /* in case val is reused for MCT test, try to free the buffer first */
> + if (val->val) {
> + free(val->val);
> + val->val = NULL;
> + }
> +
> + wb_data = dst = calloc(1, total_len);
> + if (!dst) {
> + RTE_LOG(ERR, USER1, "Error %i: Not enough memory\n", -ENOMEM);
> + return -ENOMEM;
> + }
> +
> + while (m && data_len) {
> + uint16_t seg_len = RTE_MIN(rte_pktmbuf_data_len(m), data_len);
> +
> + src = rte_pktmbuf_mtod(m, uint8_t *);
> + memcpy(dst, src, seg_len);
> + m = m->next;
> + data_len -= seg_len;
> + dst += seg_len;
> + }
> +
> + if (data_len) {
> + RTE_LOG(ERR, USER1, "Error -1: write back data\n");
> + return -1;
> + }
> +
> + if (env.digest)
> + memcpy(dst, env.digest, env.digest_len);
> +
> + val->val = wb_data;
> + val->len = total_len;
> +
> + return 0;
> }
>
> static int
> @@ -1015,7 +1142,7 @@ fips_run_test(void)
> static int
> fips_generic_test(void)
> {
> - struct fips_val val;
> + struct fips_val val = {NULL, 0};
> int ret;
>
> fips_test_write_one_case();
> @@ -1030,7 +1157,9 @@ fips_generic_test(void)
> return ret;
> }
>
> - get_writeback_data(&val);
> + ret = get_writeback_data(&val);
> + if (ret < 0)
> + return ret;
>
> switch (info.file_type) {
> case FIPS_TYPE_REQ:
> @@ -1051,6 +1180,7 @@ fips_generic_test(void)
> }
>
> fprintf(info.fp_wr, "\n");
> + free(val.val);
>
> return 0;
> }
> @@ -1061,7 +1191,7 @@ fips_mct_tdes_test(void)
> #define TDES_BLOCK_SIZE 8
> #define TDES_EXTERN_ITER 400
> #define TDES_INTERN_ITER 10000
> - struct fips_val val, val_key;
> + struct fips_val val = {NULL, 0}, val_key;
> uint8_t prev_out[TDES_BLOCK_SIZE] = {0};
> uint8_t prev_prev_out[TDES_BLOCK_SIZE] = {0};
> uint8_t prev_in[TDES_BLOCK_SIZE] = {0};
> @@ -1088,7 +1218,9 @@ fips_mct_tdes_test(void)
> return ret;
> }
>
> - get_writeback_data(&val);
> + ret = get_writeback_data(&val);
> + if (ret < 0)
> + return ret;
>
> if (info.op == FIPS_TEST_DEC_AUTH_VERIF)
> memcpy(prev_in, vec.ct.val, TDES_BLOCK_SIZE);
> @@ -1215,6 +1347,9 @@ fips_mct_tdes_test(void)
> }
> }
>
> + if (val.val)
> + free(val.val);
> +
> return 0;
> }
>
> @@ -1224,7 +1359,7 @@ fips_mct_aes_ecb_test(void)
> #define AES_BLOCK_SIZE 16
> #define AES_EXTERN_ITER 100
> #define AES_INTERN_ITER 1000
> - struct fips_val val, val_key;
> + struct fips_val val = {NULL, 0}, val_key;
> uint8_t prev_out[AES_BLOCK_SIZE] = {0};
> uint32_t i, j, k;
> int ret;
> @@ -1246,7 +1381,9 @@ fips_mct_aes_ecb_test(void)
> return ret;
> }
>
> - get_writeback_data(&val);
> + ret = get_writeback_data(&val);
> + if (ret < 0)
> + return ret;
>
> if (info.op == FIPS_TEST_ENC_AUTH_GEN)
> memcpy(vec.pt.val, val.val, AES_BLOCK_SIZE);
> @@ -1290,6 +1427,9 @@ fips_mct_aes_ecb_test(void)
> }
> }
>
> + if (val.val)
> + free(val.val);
> +
> return 0;
> }
> static int
> @@ -1298,7 +1438,7 @@ fips_mct_aes_test(void)
> #define AES_BLOCK_SIZE 16
> #define AES_EXTERN_ITER 100
> #define AES_INTERN_ITER 1000
> - struct fips_val val, val_key;
> + struct fips_val val = {NULL, 0}, val_key;
> uint8_t prev_out[AES_BLOCK_SIZE] = {0};
> uint8_t prev_in[AES_BLOCK_SIZE] = {0};
> uint32_t i, j, k;
> @@ -1394,6 +1534,9 @@ fips_mct_aes_test(void)
> memcpy(vec.iv.val, val.val, AES_BLOCK_SIZE);
> }
>
> + if (val.val)
> + free(val.val);
> +
> return 0;
> }
>
> @@ -1403,7 +1546,7 @@ fips_mct_sha_test(void)
> #define SHA_EXTERN_ITER 100
> #define SHA_INTERN_ITER 1000
> #define SHA_MD_BLOCK 3
> - struct fips_val val, md[SHA_MD_BLOCK];
> + struct fips_val val = {NULL, 0}, md[SHA_MD_BLOCK];
> char temp[MAX_DIGEST_SIZE*2];
> int ret;
> uint32_t i, j;
> @@ -1477,6 +1620,9 @@ fips_mct_sha_test(void)
>
> rte_free(vec.pt.val);
>
> + if (val.val)
> + free(val.val);
> +
> return 0;
> }
>
> @@ -1568,7 +1714,6 @@ fips_test_one_file(void)
> {
> int fetch_ret = 0, ret;
>
> -
> ret = init_test_ops();
> if (ret < 0) {
> RTE_LOG(ERR, USER1, "Error %i: Init test op\n", ret);
> @@ -1616,6 +1761,10 @@ fips_test_one_file(void)
>
> fips_test_clear();
>
> - return ret;
> + if (env.digest)
> + rte_free(env.digest);
> + if (env.mbuf)
> + rte_pktmbuf_free(env.mbuf);
>
> + return ret;
> }
next prev parent reply other threads:[~2020-09-07 13:32 UTC|newest]
Thread overview: 16+ messages / expand[flat|nested] mbox.gz Atom feed top
2020-08-18 12:17 [dpdk-dev] [dpdk-dev 0/2] fips_validation: add SGL and GMAC support Fan Zhang
2020-08-18 12:17 ` [dpdk-dev] [dpdk-dev 1/2] fips_validation: add SGL support Fan Zhang
2020-08-18 12:17 ` [dpdk-dev] [dpdk-dev 2/2] fips_validation: update GCM test Fan Zhang
2020-09-04 16:09 ` [dpdk-dev] [dpdk-dev v2 0/2] fips_validation: add SGL and GMAC support Fan Zhang
2020-09-04 16:09 ` [dpdk-dev] [dpdk-dev v2 1/2] fips_validation: add SGL support Fan Zhang
2020-09-07 13:32 ` Suanming Mou [this message]
2020-09-08 10:13 ` Zhang, Roy Fan
2020-09-17 9:20 ` Griffin, John
2020-09-04 16:09 ` [dpdk-dev] [dpdk-dev v2 2/2] fips_validation: update GCM test Fan Zhang
2020-09-17 9:20 ` Griffin, John
2020-10-09 18:23 ` [dpdk-dev] [dpdk-dev v2 0/2] fips_validation: add SGL and GMAC support Akhil Goyal
2020-10-09 18:47 ` Zhang, Roy Fan
2020-10-09 20:08 ` [dpdk-dev] [dpdk-dev v3 " Fan Zhang
2020-10-09 20:08 ` [dpdk-dev] [dpdk-dev v3 1/2] fips_validation: add SGL support Fan Zhang
2020-10-09 20:08 ` [dpdk-dev] [dpdk-dev v3 2/2] fips_validation: update GCM test Fan Zhang
2020-10-10 16:55 ` Akhil Goyal
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=b9593ab0-3592-3d16-150a-ecc09d204332@nvidia.com \
--to=suanmingm@nvidia.com \
--cc=adamx.dybkowski@intel.com \
--cc=akhil.goyal@nxp.com \
--cc=arkadiuszx.kusztal@intel.com \
--cc=dev@dpdk.org \
--cc=fiona.trahe@intel.com \
--cc=roy.fan.zhang@intel.com \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).