From patchwork Mon Mar 16 20:03:43 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Mairtin o Loingsigh X-Patchwork-Id: 66736 X-Patchwork-Delegate: thomas@monjalon.net 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 AA17EA0559; Mon, 16 Mar 2020 21:03:51 +0100 (CET) Received: from [92.243.14.124] (localhost [127.0.0.1]) by dpdk.org (Postfix) with ESMTP id 891081C045; Mon, 16 Mar 2020 21:03:50 +0100 (CET) Received: from mga06.intel.com (mga06.intel.com [134.134.136.31]) by dpdk.org (Postfix) with ESMTP id A70291C037 for ; Mon, 16 Mar 2020 21:03:48 +0100 (CET) IronPort-SDR: DcNISfJiOhmcnINBC3R4L7H7FIHG7DX7gro38x9CeT9l3c8Wmzyv6WnaRpMbaP3iaswKVZ2tev KD5RFQvfLlqw== X-Amp-Result: SKIPPED(no attachment in message) X-Amp-File-Uploaded: False Received: from orsmga008.jf.intel.com ([10.7.209.65]) by orsmga104.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 16 Mar 2020 13:03:47 -0700 IronPort-SDR: IMl3eIdViHbxvlblyGA9OlP2MYxePhf1AzcsMhMe94Y+oo+WENAEPf1iXiZfGfbYW2iybORk3P VyL9hdpeS1Iw== X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.70,561,1574150400"; d="scan'208";a="238066294" Received: from irvmail001.ir.intel.com ([163.33.26.43]) by orsmga008.jf.intel.com with ESMTP; 16 Mar 2020 13:03:46 -0700 Received: from sivswdev08.ir.intel.com (sivswdev08.ir.intel.com [10.237.217.47]) by irvmail001.ir.intel.com (8.14.3/8.13.6/MailSET/Hub) with ESMTP id 02GK3jX7008041; Mon, 16 Mar 2020 20:03:45 GMT Received: from sivswdev08.ir.intel.com (localhost [127.0.0.1]) by sivswdev08.ir.intel.com with ESMTP id 02GK3jSW032509; Mon, 16 Mar 2020 20:03:45 GMT Received: (from moloings@localhost) by sivswdev08.ir.intel.com with LOCAL id 02GK3j66032505; Mon, 16 Mar 2020 20:03:45 GMT From: Mairtin o Loingsigh To: shreyansh.jain@nxp.com Cc: dev@dpdk.org, Mairtin o Loingsigh Date: Mon, 16 Mar 2020 20:03:43 +0000 Message-Id: <1584389023-32456-1-git-send-email-mairtin.oloingsigh@intel.com> X-Mailer: git-send-email 1.7.0.7 Subject: [dpdk-dev] [PATCH] test/rawdev: add Multi-function test 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" Function test for Multi-function library Signed-off-by: Mairtin o Loingsigh --- app/test/Makefile | 5 + app/test/test_cryptodev.h | 1 + app/test/test_rawdev.c | 418 ++++++++++++++++++++++++++ app/test/test_rawdev_multi_fn_test_vectors.h | 83 +++++ 4 files changed, 507 insertions(+), 0 deletions(-) create mode 100644 app/test/test_rawdev_multi_fn_test_vectors.h diff --git a/app/test/Makefile b/app/test/Makefile index 1f080d1..57e9b23 100644 --- a/app/test/Makefile +++ b/app/test/Makefile @@ -243,6 +243,7 @@ CFLAGS += -O3 CFLAGS += $(WERROR_FLAGS) LDLIBS += -lm +LDLIBS += -lrte_multi_fn ifeq ($(CONFIG_RTE_LIBRTE_PDUMP),y) LDLIBS += -lpthread @@ -286,6 +287,10 @@ ifeq ($(CONFIG_RTE_APP_TEST_RESOURCE_TAR),y) LDLIBS += -larchive endif +ifeq ($(CONFIG_RTE_LIBRTE_PMD_AESNI_MB_RAWDEV),y) +LDLIBS += -lrte_pmd_aesni_mb_rawdev +endif + include $(RTE_SDK)/mk/rte.app.mk endif diff --git a/app/test/test_cryptodev.h b/app/test/test_cryptodev.h index def304e..424184b 100644 --- a/app/test/test_cryptodev.h +++ b/app/test/test_cryptodev.h @@ -69,6 +69,7 @@ #define CRYPTODEV_NAME_OCTEONTX2_PMD crypto_octeontx2 #define CRYPTODEV_NAME_CAAM_JR_PMD crypto_caam_jr #define CRYPTODEV_NAME_NITROX_PMD crypto_nitrox_sym +#define RAWDEV_NAME_AESNI_MB_PMD rawdev_aesni_mb /** * Write (spread) data from buffer to mbuf data diff --git a/app/test/test_rawdev.c b/app/test/test_rawdev.c index 524a9d5..a1d03f9 100644 --- a/app/test/test_rawdev.c +++ b/app/test/test_rawdev.c @@ -6,10 +6,38 @@ #include #include #include +#include #include +#include #include +#include "test_rawdev_multi_fn_test_vectors.h" #include "test.h" +#include "test_cryptodev.h" + +struct raw_testsuite_params { + struct rte_mempool *mbuf_pool; + struct rte_mempool *op_mpool; + struct rte_rawdev_info info; + struct rte_multi_fn_device_info priv; + struct rte_multi_fn_dev_config conf; + struct rte_multi_fn_qp_config qp_conf; + uint8_t valid_devs[RTE_RAWDEV_MAX_DEVS]; + uint8_t valid_dev_count; +}; + +struct raw_unittest_params { + struct rte_crypto_sym_xform cipher_xform; + struct rte_crypto_sym_xform auth_xform; + struct rte_crypto_sym_xform aead_xform; + struct rte_multi_fn_err_detect_xform err_detect; + struct rte_multi_fn_session *sess; + + struct rte_crypto_op *op; + struct rte_mbuf *obuf, *ibuf; + + uint8_t *digest; +}; static int test_rawdev_selftest_impl(const char *pmd, const char *opts) @@ -45,3 +73,393 @@ } REGISTER_TEST_COMMAND(ioat_rawdev_autotest, test_rawdev_selftest_ioat); + +static struct raw_testsuite_params testsuite_raw_params = { NULL }; +static struct raw_unittest_params unittest_raw_params; + +static int +testsuite_raw_setup(void) +{ + int ret; + uint32_t i = 0, nb_devs, dev_id; + struct raw_testsuite_params *ts_params = &testsuite_raw_params; + struct rte_rawdev_info *info = &ts_params->info; + struct rte_multi_fn_device_info *priv = &ts_params->priv; + + memset(ts_params, 0, sizeof(*ts_params)); + + info->dev_private = priv; + priv->config = &ts_params->conf; + + ts_params->mbuf_pool = rte_mempool_lookup("RAWDEV_MBUFPOOL"); + if (ts_params->mbuf_pool == NULL) { + /* Not already created so create */ + ts_params->mbuf_pool = rte_pktmbuf_pool_create( + "RAWDEV_MBUFPOOL", + NUM_MBUFS, MBUF_CACHE_SIZE, 0, MBUF_SIZE, + rte_socket_id()); + if (ts_params->mbuf_pool == NULL) { + RTE_LOG(ERR, USER1, "Can't create RAWDEV_MBUFPOOL\n"); + return TEST_FAILED; + } + } + + ts_params->op_mpool = rte_pktmbuf_pool_create("RAWDEV_MULTI_FN_OP_POOL", + NUM_MBUFS, MBUF_CACHE_SIZE, 0, + sizeof(struct rte_multi_fn_op) + + MAXIMUM_IV_LENGTH, + rte_socket_id()); + + if (ts_params->op_mpool == NULL) { + RTE_LOG(ERR, USER1, "Can't create RAWDEV_MULTI_FN_OP_POOL\n"); + return TEST_FAILED; + } + + /* Find 1st aesni rawdev. */ + for (i = 0; i < RTE_RAWDEV_MAX_DEVS; i++) + if (rte_rawdevs[i].driver_name && + (strncmp(rte_rawdevs[i].driver_name, "rawdev_aesni_mb", + RTE_RAWDEV_NAME_MAX_LEN) == 0)) + break; + + if (i == RTE_RAWDEV_MAX_DEVS) + rte_exit(EXIT_FAILURE, "Cannot find any ntb device.\n"); + + nb_devs = rte_rawdev_count(); + if (nb_devs < 1) { + RTE_LOG(WARNING, USER1, "No rawdev devices found?\n"); + return TEST_SKIPPED; + } + + /* Create list of valid crypto devs */ + for (i = 0; i < nb_devs; i++) { + rte_rawdev_info_get(i, info); + if (strncmp(rte_rawdevs[i].driver_name, "rawdev_aesni_mb", + RTE_RAWDEV_NAME_MAX_LEN) == 0) + ts_params->valid_devs[ts_params->valid_dev_count++] + = i; + } + + if (ts_params->valid_dev_count < 1) + return TEST_FAILED; + + /* Set up all the qps on the first of the valid devices found */ + + dev_id = ts_params->valid_devs[0]; + + ret = rte_rawdev_info_get(dev_id, info); + if (ret) + return ret; + + return TEST_SUCCESS; +} + +static void +testsuite_raw_teardown(void) +{ + struct raw_testsuite_params *ts_params = &testsuite_raw_params; + + if (ts_params->mbuf_pool != NULL) { + RTE_LOG(DEBUG, USER1, "CRYPTO_MBUFPOOL count %u\n", + rte_mempool_avail_count(ts_params->mbuf_pool)); + rte_mempool_free(ts_params->mbuf_pool); + ts_params->mbuf_pool = NULL; + } + + if (ts_params->op_mpool != NULL) { + RTE_LOG(DEBUG, USER1, "CRYPTO_OP_POOL count %u\n", + rte_mempool_avail_count(ts_params->op_mpool)); + rte_mempool_free(ts_params->op_mpool); + ts_params->op_mpool = NULL; + } + + rte_vdev_uninit(RTE_STR(RAWDEV_NAME_AESNI_MB_PMD)); +} + +static int +ut_raw_setup(void) +{ + int ret; + struct raw_testsuite_params *ts_params = &testsuite_raw_params; + struct raw_unittest_params *ut_params = &unittest_raw_params; + + uint16_t qp_id; + + /* Clear unit test parameters before running test */ + memset(ut_params, 0, sizeof(*ut_params)); + + /* Reconfigure device to default parameters */ + ts_params->qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT; + + TEST_ASSERT_SUCCESS(rte_rawdev_configure(ts_params->valid_devs[0], + &ts_params->info), + "Failed to configure rawdev %u", + ts_params->valid_devs[0]); + + for (qp_id = 0; qp_id < ts_params->conf.nb_queues ; qp_id++) { + TEST_ASSERT_SUCCESS(rte_rawdev_queue_setup( + ts_params->valid_devs[0], qp_id, + &ts_params->qp_conf), + "Failed to setup queue pair %u on rawdev %u", + qp_id, ts_params->valid_devs[0]); + } + + ret = rte_rawdev_xstats_reset(ts_params->valid_devs[0], NULL, 0); + + TEST_ASSERT_SUCCESS(ret, "Failed to reset rawdev stats"); + + /* Start the device */ + TEST_ASSERT_SUCCESS(rte_rawdev_start(ts_params->valid_devs[0]), + "Failed to start rawdev %u", ts_params->valid_devs[0]); + + return 0; +} + +static void +ut_raw_teardown(void) +{ + struct raw_testsuite_params *ts_params = &testsuite_raw_params; + struct raw_unittest_params *ut_params = &unittest_raw_params; + + /* free crypto operation structure */ + if (ut_params->op) + rte_crypto_op_free(ut_params->op); + + /* + * free mbuf - both obuf and ibuf are usually the same, + * so check if they point at the same address is necessary, + * to avoid freeing the mbuf twice. + */ + if (ut_params->obuf) { + rte_pktmbuf_free(ut_params->obuf); + if (ut_params->ibuf == ut_params->obuf) + ut_params->ibuf = 0; + ut_params->obuf = 0; + } + if (ut_params->ibuf) { + rte_pktmbuf_free(ut_params->ibuf); + ut_params->ibuf = 0; + } + + if (ts_params->mbuf_pool != NULL) + RTE_LOG(DEBUG, USER1, "CRYPTO_MBUFPOOL count %u\n", + rte_mempool_avail_count(ts_params->mbuf_pool)); + + /* Stop the device */ + rte_rawdev_stop(ts_params->valid_devs[0]); +} + +static int +test_session_create_docsis_dl(struct docsis_test_data *d_tc) +{ + uint16_t qpid = 0, enqueued, dequeued = 0; + uint16_t output_vec_len = 16; + struct rte_multi_fn_op *ops[2]; + struct rte_multi_fn_op *results; + struct rte_multi_fn_xform xfrm1 = {0}; + struct rte_multi_fn_xform xfrm2 = {0}; + uint8_t *plaintext = NULL, *ciphertext = NULL; + struct rte_mbuf *m1, *m2; + + /* Operations */ + struct rte_crypto_sym_op *crypto_sym_op; + struct rte_multi_fn_err_detect_op *err_detect_op; + struct raw_testsuite_params *t_param = &testsuite_raw_params; + struct raw_unittest_params *u_param = &unittest_raw_params; + + int i, ret = TEST_SUCCESS; + int oop = 0; + + uint8_t key_128bit[16] = {0}; + uint64_t stats[4] = {0}; + const unsigned int stats_id[4] = {1, 2, 3, 4}; + int num_stats = 0; + + /* Docsis test params */ + uint8_t *cipher_iv = NULL; + uint8_t cipher_iv_len = 0; + unsigned int cipher_len = 0, auth_len = 0; + + uint8_t dev_id = t_param->valid_devs[0]; + + /* Copy key from test vector */ + memcpy(key_128bit, d_tc->key.data, d_tc->key.len); + + debug_hexdump(stdout, "Key:", key_128bit, d_tc->key.len); + + /* multi-operation type session creation */ + xfrm1.type = RTE_MULTI_FN_XFORM_TYPE_CRYPTO_SYM; + xfrm1.next = &xfrm2; + + xfrm1.crypto_sym.type = RTE_CRYPTO_SYM_XFORM_CIPHER; + + struct rte_crypto_cipher_xform *xfrm_cipher = &xfrm1.crypto_sym.cipher; + + xfrm_cipher->op = RTE_CRYPTO_CIPHER_OP_DECRYPT; + xfrm_cipher->algo = RTE_CRYPTO_CIPHER_AES_DOCSISBPI; + xfrm_cipher->key.data = key_128bit; + xfrm_cipher->key.length = RTE_DIM(key_128bit); + /*sizeof(key_128bit)/sizeof(key_128bit[0]);*/ + xfrm_cipher->iv.offset = sizeof(struct rte_multi_fn_op); + xfrm_cipher->iv.length = d_tc->cipher_iv.len; + + xfrm2.type = RTE_MULTI_FN_XFORM_TYPE_ERR_DETECT; + xfrm2.err_detect.algo = RTE_MULTI_FN_ERR_DETECT_CRC32_ETH; + xfrm2.err_detect.op = RTE_MULTI_FN_ERR_DETECT_OP_VERIFY; + xfrm2.next = NULL; + + m1 = rte_pktmbuf_alloc(t_param->mbuf_pool); + if (!m1) { + printf("rte_pktmbuf_alloc failed\n"); + return -1; + } + + /* clear mbuf payload */ + memset(rte_pktmbuf_mtod(m1, uint8_t *), 0, rte_pktmbuf_tailroom(m1)); + + if (oop) { + m2 = rte_pktmbuf_alloc(t_param->mbuf_pool); + rte_pktmbuf_append(m2, output_vec_len); + } + + ciphertext = (uint8_t *)rte_pktmbuf_append(m1, d_tc->ciphertext.len); + + memcpy(ciphertext, d_tc->ciphertext.data, d_tc->ciphertext.len); + + debug_hexdump(stdout, "ciphertext:", ciphertext, d_tc->ciphertext.len); + + u_param->sess = rte_multi_fn_session_create(dev_id, + &t_param->info, &xfrm1, rte_socket_id()); + + if ((u_param->sess == NULL) || + (u_param->sess->sess_private_data == NULL)) { + printf("rte_multi_fn_session_create create failed\n"); + return -1; + } + + /* Create combined DOCSIS operation */ + cipher_iv = d_tc->cipher_iv.data; + cipher_iv_len = d_tc->cipher_iv.len; + + cipher_len = d_tc->ciphertext.no_cipher == false ? + (d_tc->ciphertext.len - + d_tc->ciphertext.cipher_offset) : + 0; + auth_len = d_tc->ciphertext.no_auth == false ? (d_tc->ciphertext.len - + d_tc->ciphertext.auth_offset - + 4) : 0; + + ret = rte_mempool_get_bulk(t_param->op_mpool, (void **)ops, 2); + if (ret) { + printf("rte_mempool_get_bulk failed to alloc ops\n"); + return -1; + } + + ops[0]->next = ops[1]; + ops[0]->m_src = m1; + ops[0]->m_dst = NULL; + + uint8_t *iv_ptr = (uint8_t *)ops[0] + sizeof( + struct rte_multi_fn_op); + rte_memcpy(iv_ptr, cipher_iv, cipher_iv_len); + + debug_hexdump(stdout, "iv:", iv_ptr, cipher_iv_len); + + /* crypto decrypt op config */ + crypto_sym_op = &ops[0]->crypto_sym; + crypto_sym_op->cipher.data.offset = d_tc->ciphertext.cipher_offset; + crypto_sym_op->cipher.data.length = cipher_len; + + /* error detect op config */ + err_detect_op = &ops[1]->err_detect; + err_detect_op->data.offset = d_tc->ciphertext.auth_offset; + err_detect_op->data.length = auth_len; + + /* Attach session to op */ + ops[0]->sess = u_param->sess; + + enqueued = rte_rawdev_enqueue_buffers(dev_id, + (struct rte_rawdev_buf **) ops, 1, + (rte_rawdev_obj_t)&qpid); + + if (enqueued != 1) + printf("rte_accelerator_ops_enqueue failed\n"); + + do { + dequeued = rte_rawdev_dequeue_buffers(dev_id, + (struct rte_rawdev_buf **)&results, 1, + (rte_rawdev_obj_t)&qpid); + } while (dequeued < 1); + + /* Check results. in-place operation */ + plaintext = ciphertext; + debug_hexdump(stdout, "plaintext:", plaintext, d_tc->plaintext.len); + + /* Validate obuf */ + TEST_ASSERT_BUFFERS_ARE_EQUAL( + plaintext, + d_tc->plaintext.data, + /* Check only plaintext, CRC is checked internally */ + d_tc->plaintext.len - 4, + "DOCSIS Plaintext data not as expected"); + + TEST_ASSERT_EQUAL(results->op_status, + RTE_MULTI_FN_OP_STATUS_SUCCESS, + "crypto op processing failed"); + + num_stats = rte_rawdev_xstats_get(dev_id, stats_id, stats, 4); + for (i = 0; i < num_stats; i++) + printf("Stat num: %d = %"PRIu64"\n", i, stats[i]); + + ret = rte_multi_fn_session_destroy(dev_id, &t_param->info, + u_param->sess); + + return ret; +} + +static int +test_device_configure_docsis_decrypt(void) +{ + return test_session_create_docsis_dl(&docsis_test_case_1); +} + +static struct unit_test_suite rawdev_aesni_testsuite = { + .suite_name = "Raw Unit Test Suite", + .setup = testsuite_raw_setup, + .teardown = testsuite_raw_teardown, + .unit_test_cases = { + TEST_CASE_ST(ut_raw_setup, ut_raw_teardown, + test_device_configure_docsis_decrypt), + TEST_CASES_END() /**< NULL terminate unit test array */ + } +}; + +static int +test_rawdev_aesni(void /*argv __rte_unused, int argc __rte_unused*/) +{ + int i, ret; + + ret = rte_vdev_init(RTE_STR(RAWDEV_NAME_AESNI_MB_PMD), NULL); + if (ret) { + RTE_LOG(ERR, USER1, "aesni raw vdev init failed\n"); + return ret; + } + + /* Find 1st ntb rawdev. */ + for (i = 0; i < RTE_RAWDEV_MAX_DEVS; i++) + if (rte_rawdevs[i].driver_name && + (strncmp(rte_rawdevs[i].driver_name, "rawdev_aesni_mb", + RTE_RAWDEV_NAME_MAX_LEN) == 0) && + (rte_rawdevs[i].attached == 1)) + break; + + if (i == RTE_RAWDEV_MAX_DEVS) { + RTE_LOG(ERR, USER1, "aesni raw driver needed to run test\n"); + return TEST_SKIPPED; + } + + return unit_test_suite_runner(&rawdev_aesni_testsuite); +} + +REGISTER_TEST_COMMAND(rawdev_aesni_autotest, test_rawdev_aesni); + diff --git a/app/test/test_rawdev_multi_fn_test_vectors.h b/app/test/test_rawdev_multi_fn_test_vectors.h new file mode 100644 index 0000000..f60400d --- /dev/null +++ b/app/test/test_rawdev_multi_fn_test_vectors.h @@ -0,0 +1,83 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * + * Copyright (C) 2015-2016 Freescale Semiconductor,Inc. + * Copyright 2018-2019 NXP + */ + +#ifndef TEST_RAWDEV_MULTI_FN_TEST_VECTORS_H_ +#define TEST_RAWDEV_MULTI_FN_TEST_VECTORS_H_ + +#include + +struct docsis_test_data { + struct { + uint8_t data[16]; + unsigned int len; + } key; + + struct { + uint8_t data[16] __rte_aligned(16); + unsigned int len; + } cipher_iv; + + struct { + uint8_t data[1024]; + unsigned int len; + unsigned int cipher_offset; + unsigned int auth_offset; + bool no_cipher; + bool no_auth; + } plaintext; + + struct { + uint8_t data[1024]; + unsigned int len; + unsigned int cipher_offset; + unsigned int auth_offset; + bool no_cipher; + bool no_auth; + } ciphertext; +}; + +struct docsis_test_data docsis_test_case_1 = { + .key = { + .data = { + 0x00, 0x00, 0x00, 0x00, 0xAA, 0xBB, 0xCC, 0xDD, + 0xEE, 0xFF, 0x00, 0x11, 0x22, 0x33, 0x44, 0x55 + }, + .len = 16 + }, + .cipher_iv = { + .data = { + 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, + 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11 + }, + .len = 16 + }, + .plaintext = { + .data = { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, + 0x03, 0x04, 0x05, 0x06, 0x06, 0x05, 0x04, 0x03, + 0x02, 0x01, 0x08, 0x00, 0xFF, 0xFF, 0xFF, 0xFF + }, + .len = 24, + .cipher_offset = 18, + .auth_offset = 6, + .no_cipher = false, + .no_auth = false + }, + .ciphertext = { + .data = { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, + 0x03, 0x04, 0x05, 0x06, 0x06, 0x05, 0x04, 0x03, + 0x02, 0x01, 0x7A, 0xF0, 0x61, 0xF8, 0x63, 0x42 + }, + .len = 24, + .cipher_offset = 18, + .auth_offset = 6, + .no_cipher = false, + .no_auth = false + } +}; + +#endif /* TEST_RAWDEV_MULTI_FN_TEST_VECTORS_H_ */