From patchwork Fri Sep 23 02:40:19 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Zhangfei Gao X-Patchwork-Id: 608575 Delivered-To: patch@linaro.org Received: by 2002:a17:522:c983:b0:460:3032:e3c4 with SMTP id kr3csp37543pvb; Thu, 22 Sep 2022 19:40:45 -0700 (PDT) X-Google-Smtp-Source: AMsMyM7/MDTSkGBg8CUKw6UdjR3XK1G18lDCWFdyP7xQWYtMiBHsuBP2iX6qoRRo1VnMtWfIgCsa X-Received: by 2002:a05:6000:10cd:b0:22a:f324:d2f7 with SMTP id b13-20020a05600010cd00b0022af324d2f7mr3890525wrx.710.1663900845415; Thu, 22 Sep 2022 19:40:45 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1663900845; cv=none; d=google.com; s=arc-20160816; b=FZFBzN1tyi95y88JhzYisbrA+QmJewRJDlV8LCgw2wZA/1ZWFRAYsQHtNopF+cacVm R/8ulNDE6/yZO9a7+wohfvAjXMOPo11hBefD0yJM0Qa3l18DTqEEp8DOOkggMsGmWMUa W6zVEIsXkuS0CSfOCF5dyBw0yOv56PsLv2W/qnWayNLFcK2kLLJ7FlYdN4QhzDCoctwG IT0+PaR8AGrqvim5+CKTDdjtXEnsqnnFSqSTuXTP19za7CQpqdMYJUUmrZLMOXaZxuXD 3N2EHC1F03l9bJkLRUdVAZ92llnCB5hZv5YUlcKweJgNwBsMcDnlPpMC9pochDIY//bJ CF+A== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=errors-to:list-subscribe:list-help:list-post:list-archive :list-unsubscribe:list-id:precedence:content-transfer-encoding :mime-version:references:in-reply-to:message-id:date:subject:cc:to :from:dkim-signature; bh=BGcdQOc1bnJ2ZCqvNh3r1sScWnwCKajO19G5gE2o2RA=; b=WSJaiB1AIZBpQrHaHvtDBCXpSExf7K7mXyr7a8pJtcUj7kD89Pjegne85z8heSww1/ bbysa/Q7qsqk4RctZJ4EEr+Q/L+y/PH9uK/hl4tQ7pfvHVhJG2S7B6De8Lyx++PmuBZ5 2zYzSzdLVvspdt7Vn5CsWrv1uTEXvJCMiIO4cv90yltu+WVW77j5bFrLaFAOGSDzWo5u mXV58hdFxUPYIDLOFPhHW/2nDLG4JACaSyHtC+ZIwKlB4KrSiSQMF+XRLYmq8/5YqvYz L4ec0Y2O2O98gsIAFWLGzbMIO9F5B7fLaWE0+1jqA5LQ6wD0UsIXoTbPMLg1hJqVMUvp UsKA== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=rBWosu23; spf=pass (google.com: domain of dev-bounces@dpdk.org designates 217.70.189.124 as permitted sender) smtp.mailfrom=dev-bounces@dpdk.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org Return-Path: Received: from mails.dpdk.org (mails.dpdk.org. [217.70.189.124]) by mx.google.com with ESMTP id m4-20020a056000024400b0022af5c6543esi4204006wrz.802.2022.09.22.19.40.45; Thu, 22 Sep 2022 19:40:45 -0700 (PDT) Received-SPF: pass (google.com: domain of dev-bounces@dpdk.org designates 217.70.189.124 as permitted sender) client-ip=217.70.189.124; Authentication-Results: mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=rBWosu23; spf=pass (google.com: domain of dev-bounces@dpdk.org designates 217.70.189.124 as permitted sender) smtp.mailfrom=dev-bounces@dpdk.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org Received: from [217.70.189.124] (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id 2352541145; Fri, 23 Sep 2022 04:40:45 +0200 (CEST) Received: from mail-pl1-f180.google.com (mail-pl1-f180.google.com [209.85.214.180]) by mails.dpdk.org (Postfix) with ESMTP id CF52041144 for ; Fri, 23 Sep 2022 04:40:43 +0200 (CEST) Received: by mail-pl1-f180.google.com with SMTP id w10so9660849pll.11 for ; Thu, 22 Sep 2022 19:40:43 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date; bh=BGcdQOc1bnJ2ZCqvNh3r1sScWnwCKajO19G5gE2o2RA=; b=rBWosu23giaYfXpcQ6KaxQBMsrycfqoKcRsro/VX1McFe4GPU5TrqBSBRo6dcget8m +Uuzyl3sxl43q58egqUpvALyQGuaiHUWsiwmS4X7i7n7nGcrYHf6fhmdDkLkj+p93u81 6RxbzTqlC0vS6H2F2oK8cmQsTwFTyL4r4lSVn3mm4lekGULx4mIqq0GSUkDhEh4WMEI2 LXjYxbMxGGfrXmWHkmPZAXw7kK0CHM7XNGA184ONuO0DZG98IO82TqbmJfq4680uHqVV LPKoKPos+CW0JMWUxEzN1ZogyLreuCmgHvMVPsGfLTHcGiWkVu7mVWxj42D5crWneN7B DKJg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date; bh=BGcdQOc1bnJ2ZCqvNh3r1sScWnwCKajO19G5gE2o2RA=; b=5EHAy+piUglnPVirqXvTRYdqF2M1hmcWRhfUDsjBJ7MqxoTxmsuCNm26J403MwObyV AqnafwQMuYp0m+f598J5rfUKheWrEaDixXHFiO3yp1JBRwZHF6G0mwFlHtKIYoSTWoPR RyO+h3zcd0VKS+6TvYuLl8Ld/eyT0ozC4ku6TRZ1tkgPkrJ0IAx0H83+6NLlKuj8edWC jXW1QUZFjlPcQJ4NxlsI5f8c0GBUG7oelF6ysg/B+UHiHKiDtlmsyAsTxxXL7OUW+lW8 utjue4wdKxtZ53FtYLQSTNxJ6SuZO4haL2V9I5yTtAdoIA6dXXTRCy7lvJhyKKq8QqP+ e68A== X-Gm-Message-State: ACrzQf21uI4gxZLD/VIieGFwKgIGvMJAm+Mj2Jn6NREyxtE8axziI6xX WLg6rVjhwtA4qKDvVJqe84T7Ug== X-Received: by 2002:a17:902:d2c8:b0:178:6f5b:f905 with SMTP id n8-20020a170902d2c800b001786f5bf905mr6181567plc.2.1663900843087; Thu, 22 Sep 2022 19:40:43 -0700 (PDT) Received: from localhost.localdomain ([199.101.192.56]) by smtp.gmail.com with ESMTPSA id t5-20020a625f05000000b0053e8940c4absm5075011pfb.209.2022.09.22.19.40.37 (version=TLS1_2 cipher=ECDHE-ECDSA-AES128-GCM-SHA256 bits=128/128); Thu, 22 Sep 2022 19:40:42 -0700 (PDT) From: Zhangfei Gao To: Akhil Goyal , Declan Doherty , Fan Zhang , Ashish Gupta , Ray Kinsella Cc: dev@dpdk.org, acc@openeuler.org, Zhangfei Gao Subject: [PATCH v2 1/5] test/crypto: add cryptodev_uadk_autotest Date: Fri, 23 Sep 2022 10:40:19 +0800 Message-Id: <20220923024023.15849-2-zhangfei.gao@linaro.org> X-Mailer: git-send-email 2.36.1 In-Reply-To: <20220923024023.15849-1-zhangfei.gao@linaro.org> References: <20220923024023.15849-1-zhangfei.gao@linaro.org> MIME-Version: 1.0 X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org Example: sudo dpdk-test --vdev=crypto_uadk --log-level=6 RTE>>cryptodev_uadk_autotest RTE>>quit Signed-off-by: Zhangfei Gao --- app/test/test_cryptodev.c | 7 +++++++ app/test/test_cryptodev.h | 1 + 2 files changed, 8 insertions(+) diff --git a/app/test/test_cryptodev.c b/app/test/test_cryptodev.c index 6ee4480399..7541cffd36 100644 --- a/app/test/test_cryptodev.c +++ b/app/test/test_cryptodev.c @@ -16580,6 +16580,12 @@ test_cryptodev_qat(void) return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD)); } +static int +test_cryptodev_uadk(void) +{ + return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_UADK_PMD)); +} + static int test_cryptodev_virtio(void) { @@ -16923,6 +16929,7 @@ REGISTER_TEST_COMMAND(cryptodev_sw_mvsam_autotest, test_cryptodev_mrvl); REGISTER_TEST_COMMAND(cryptodev_dpaa2_sec_autotest, test_cryptodev_dpaa2_sec); REGISTER_TEST_COMMAND(cryptodev_dpaa_sec_autotest, test_cryptodev_dpaa_sec); REGISTER_TEST_COMMAND(cryptodev_ccp_autotest, test_cryptodev_ccp); +REGISTER_TEST_COMMAND(cryptodev_uadk_autotest, test_cryptodev_uadk); REGISTER_TEST_COMMAND(cryptodev_virtio_autotest, test_cryptodev_virtio); REGISTER_TEST_COMMAND(cryptodev_octeontx_autotest, test_cryptodev_octeontx); REGISTER_TEST_COMMAND(cryptodev_caam_jr_autotest, test_cryptodev_caam_jr); diff --git a/app/test/test_cryptodev.h b/app/test/test_cryptodev.h index 29a7d4db2b..abd795f54a 100644 --- a/app/test/test_cryptodev.h +++ b/app/test/test_cryptodev.h @@ -74,6 +74,7 @@ #define CRYPTODEV_NAME_CN9K_PMD crypto_cn9k #define CRYPTODEV_NAME_CN10K_PMD crypto_cn10k #define CRYPTODEV_NAME_MLX5_PMD crypto_mlx5 +#define CRYPTODEV_NAME_UADK_PMD crypto_uadk enum cryptodev_api_test_type { From patchwork Fri Sep 23 02:40:20 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Zhangfei Gao X-Patchwork-Id: 608576 Delivered-To: patch@linaro.org Received: by 2002:a17:522:c983:b0:460:3032:e3c4 with SMTP id kr3csp37583pvb; Thu, 22 Sep 2022 19:40:53 -0700 (PDT) X-Google-Smtp-Source: AMsMyM6ilGPfYacLYHo0o2z+KR0KTZbUGv4ai/rBWVld+v3rNQfhiOrKZ/E0BLu9k9lnWrugk7Kt X-Received: by 2002:a1c:c90c:0:b0:3b4:adc7:9766 with SMTP id f12-20020a1cc90c000000b003b4adc79766mr4389031wmb.66.1663900853220; Thu, 22 Sep 2022 19:40:53 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1663900853; cv=none; d=google.com; s=arc-20160816; b=ZtYoyJAIG39VDsbdUEHlk9LiG7RqbM2LsI7Kvh4bHRDAJ78ebTFDAJq0kWa+EaJqyu RBBEp73ONS+PXB0ancpTMLs5I4yzcycbTNXoIHkfX+yaVx4efDm51HzQbxMtNufPySnu Nzq9W4VF70ndZJ7SZ1WT8RiEHOd6sG7gOmmrdFoNriBGw54e815kh80i5m6991LdWQcT 8O6a4c4l/IRvK48LRD/QrX1xJn8+PObpD+1CFL0pZeFvJlC3Ewns4/bM85j29xowKIDi 84d+CLPE3Ewl9DXrPMFlVfEDh7kxfwLTuv1lqYipBzpS4UWA0ZDn3dkFuSXVS4EVJG8M 5yOQ== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=errors-to:list-subscribe:list-help:list-post:list-archive :list-unsubscribe:list-id:precedence:content-transfer-encoding :mime-version:references:in-reply-to:message-id:date:subject:cc:to :from:dkim-signature; bh=ik2kHCNGY+d3MkYwacJqHXZXs2w9YouQd/MNPSmRYJ8=; b=L8FrRaZZr60EwEhvTPKlzhdRjph6v9ZgjHdCqQwU4DpvsW+Z44+XcmzEXF1RG43QCO QkjWxC0D7eK2bw0NyMl7cYtwgZ24f3V1sIUR30dJtUUq1HEzq7Bhqv3rKrTx9EEBsDLN YOmG2GlQxD9Fbb/f1OVbkF2+2VTAcaCXwpApwgnwMJsPIS3+r3GspmlSRpEg/nikF0+8 Yp2ZMJLMloydSlM6Mar7F2iWBT9Rtjwbdu5codBoYIVTihronbC+EBHrD9M5Hm2s0xt6 DY5dp6tiEJghmWffd4tb7OKa0Vs2FzV2EApTihqqJ5Bcuvi5uLIQ/kASckGFONQffjuA SaWg== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=TGoY0hkE; spf=pass (google.com: domain of dev-bounces@dpdk.org designates 217.70.189.124 as permitted sender) smtp.mailfrom=dev-bounces@dpdk.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org Return-Path: Received: from mails.dpdk.org (mails.dpdk.org. [217.70.189.124]) by mx.google.com with ESMTP id e10-20020a5d6d0a000000b0022af6080a6bsi5514844wrq.939.2022.09.22.19.40.53; Thu, 22 Sep 2022 19:40:53 -0700 (PDT) Received-SPF: pass (google.com: domain of dev-bounces@dpdk.org designates 217.70.189.124 as permitted sender) client-ip=217.70.189.124; Authentication-Results: mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=TGoY0hkE; spf=pass (google.com: domain of dev-bounces@dpdk.org designates 217.70.189.124 as permitted sender) smtp.mailfrom=dev-bounces@dpdk.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org Received: from [217.70.189.124] (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id E41F6427F0; Fri, 23 Sep 2022 04:40:52 +0200 (CEST) Received: from mail-pf1-f173.google.com (mail-pf1-f173.google.com [209.85.210.173]) by mails.dpdk.org (Postfix) with ESMTP id B5488427F0 for ; Fri, 23 Sep 2022 04:40:50 +0200 (CEST) Received: by mail-pf1-f173.google.com with SMTP id y136so11114023pfb.3 for ; Thu, 22 Sep 2022 19:40:50 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date; bh=ik2kHCNGY+d3MkYwacJqHXZXs2w9YouQd/MNPSmRYJ8=; b=TGoY0hkEbmadBN2GJPfmJnhY09hxaw/oEbEC71XP8NYWYJlYJylJ/ntSyoq45ZTBeg A8YXH/dQeae9pwkrQLcCZtErXXaTiaKQ7YqwLMFBvlI4AWKs7C7h9VgBnhsGpdKgt7gm XFOZ/L7LAdMfk4qMkCzBFiYf0USqgSlN7IllVxsg+vF9nOh8wWDtkgnwzDlF9ddWCN+M 8N72w3WyHGdnaMn3ItslfJcWIkUZgPR4H/Mi6Q08dh4dZvXMUhbVXoDKlxbkLH8uCCmg w6jsLZM4o7AT9M7I6tnz/c/5HyeAR73JZ+OjXyseCG/8sv8sShUfq9j1JtbXaTZm4Alq vFBA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date; bh=ik2kHCNGY+d3MkYwacJqHXZXs2w9YouQd/MNPSmRYJ8=; b=w6j8itcyQKy8vvfPGDj1JDipA8O1y2+wTbExkYjc82eD2J/GcHdEiSAqxQpu1krDdO kK08EWGiOhepnKWjMDv+S3MjkbjFQxVlOzAWCHUZtMfimr6C0I6sU/AsIBj4h6u6/uM/ HKLMLjWaexvrSQqcEcCnXk51BwfJrqRRsLKy1m+M+5NOBWq1V7qzX32aP9HoOGxXh2lq bH70StE6lQAU7ZnOXqXYgpkJ20pCFjOGyWyEPYaOxfDqMjixky/9fssku3EcVFknrTvE DlHhJY0uNYwLBZMRkiJvHLKsp96lowdqGijIsIxqJZGLV3KTp68KI8Uns5Upwy+Gb98S nKrQ== X-Gm-Message-State: ACrzQf0XEE+olFanw2bdMUkVlTqDZJl/rvytwjLD0UiOHtBexyQUPgKi /irqkSgvDEuvbwLr54F7OW/AOA== X-Received: by 2002:a63:fe54:0:b0:42b:d11d:1490 with SMTP id x20-20020a63fe54000000b0042bd11d1490mr5810308pgj.51.1663900849880; Thu, 22 Sep 2022 19:40:49 -0700 (PDT) Received: from localhost.localdomain ([199.101.192.56]) by smtp.gmail.com with ESMTPSA id t5-20020a625f05000000b0053e8940c4absm5075011pfb.209.2022.09.22.19.40.43 (version=TLS1_2 cipher=ECDHE-ECDSA-AES128-GCM-SHA256 bits=128/128); Thu, 22 Sep 2022 19:40:49 -0700 (PDT) From: Zhangfei Gao To: Akhil Goyal , Declan Doherty , Fan Zhang , Ashish Gupta , Ray Kinsella Cc: dev@dpdk.org, acc@openeuler.org, Zhangfei Gao Subject: [PATCH v2 2/5] crypto/uadk: introduce uadk crypto driver Date: Fri, 23 Sep 2022 10:40:20 +0800 Message-Id: <20220923024023.15849-3-zhangfei.gao@linaro.org> X-Mailer: git-send-email 2.36.1 In-Reply-To: <20220923024023.15849-1-zhangfei.gao@linaro.org> References: <20220923024023.15849-1-zhangfei.gao@linaro.org> MIME-Version: 1.0 X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org Introduce a new crypto PMD for hardware accelerators based on UADK [1]. UADK is a framework for user applications to access hardware accelerators. UADK relies on IOMMU SVA (Shared Virtual Address) feature, which share the same page table between IOMMU and MMU. Thereby user application can directly use virtual address for device dma, which enhances the performance as well as easy usability. This patch adds the basic framework. [1] https://github.com/Linaro/uadk Test: sudo dpdk-test --vdev=crypto_uadk (--log-level=6) RTE>>cryptodev_uadk_autotest RTE>>quit Signed-off-by: Zhangfei Gao --- drivers/crypto/meson.build | 1 + drivers/crypto/uadk/meson.build | 36 +++ drivers/crypto/uadk/uadk_crypto_pmd.c | 450 ++++++++++++++++++++++++++ drivers/crypto/uadk/version.map | 3 + 4 files changed, 490 insertions(+) create mode 100644 drivers/crypto/uadk/meson.build create mode 100644 drivers/crypto/uadk/uadk_crypto_pmd.c create mode 100644 drivers/crypto/uadk/version.map diff --git a/drivers/crypto/meson.build b/drivers/crypto/meson.build index 147b8cf633..ee5377deff 100644 --- a/drivers/crypto/meson.build +++ b/drivers/crypto/meson.build @@ -18,6 +18,7 @@ drivers = [ 'octeontx', 'openssl', 'scheduler', + 'uadk', 'virtio', ] diff --git a/drivers/crypto/uadk/meson.build b/drivers/crypto/uadk/meson.build new file mode 100644 index 0000000000..a67c6c7ca5 --- /dev/null +++ b/drivers/crypto/uadk/meson.build @@ -0,0 +1,36 @@ +# SPDX-License-Identifier: BSD-3-Clause +# Copyright 2022-2023 Huawei Technologies Co.,Ltd. All rights reserved. +# Copyright 2022-2023 Linaro ltd. + +if not is_linux + build = false + reason = 'only supported on Linux' + subdir_done() +endif + +if arch_subdir != 'arm' or not dpdk_conf.get('RTE_ARCH_64') + build = false + reason = 'only supported on aarch64' + subdir_done() +endif + +sources = files( + 'uadk_crypto_pmd.c', +) + +deps += 'bus_vdev' +dep = cc.find_library('libwd_crypto', dirs: ['/usr/local/lib'], required: false) +if not dep.found() + build = false + reason = 'missing dependency, "libwd_crypto"' +else + ext_deps += dep +endif + +dep = cc.find_library('libwd', dirs: ['/usr/local/lib'], required: false) +if not dep.found() + build = false + reason = 'missing dependency, "libwd"' +else + ext_deps += dep +endif diff --git a/drivers/crypto/uadk/uadk_crypto_pmd.c b/drivers/crypto/uadk/uadk_crypto_pmd.c new file mode 100644 index 0000000000..aad42524d6 --- /dev/null +++ b/drivers/crypto/uadk/uadk_crypto_pmd.c @@ -0,0 +1,450 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright 2022-2023 Huawei Technologies Co.,Ltd. All rights reserved. + * Copyright 2022-2023 Linaro ltd. + */ + +#include +#include +#include +#include +#include +#include + +/* Maximum length for digest (SHA-512 needs 64 bytes) */ +#define DIGEST_LENGTH_MAX 64 + +struct uadk_qp { + struct rte_ring *processed_pkts; + /* Ring for placing process packets */ + struct rte_cryptodev_stats qp_stats; + /* Queue pair statistics */ + uint16_t id; + /* Queue Pair Identifier */ + char name[RTE_CRYPTODEV_NAME_MAX_LEN]; + /* Unique Queue Pair Name */ + uint8_t temp_digest[DIGEST_LENGTH_MAX]; + /* Buffer used to store the digest generated + * by the driver when verifying a digest provided + * by the user (using authentication verify operation) + */ +} __rte_cache_aligned; + +enum uadk_chain_order { + UADK_CHAIN_NOT_SUPPORTED +}; + +struct uadk_crypto_session { + enum uadk_chain_order chain_order; +} __rte_cache_aligned; + +enum uadk_crypto_version { + UADK_CRYPTO_V2, + UADK_CRYPTO_V3, +}; + +struct uadk_crypto_priv { + enum uadk_crypto_version version; +} __rte_cache_aligned; + +static uint8_t uadk_cryptodev_driver_id; + +RTE_LOG_REGISTER_DEFAULT(uadk_crypto_logtype, INFO); + +#define UADK_LOG(level, fmt, ...) \ + rte_log(RTE_LOG_ ## level, uadk_crypto_logtype, \ + "%s() line %u: " fmt "\n", __func__, __LINE__, \ + ## __VA_ARGS__) + +static const struct rte_cryptodev_capabilities uadk_crypto_v2_capabilities[] = { + /* End of symmetric capabilities */ + RTE_CRYPTODEV_END_OF_CAPABILITIES_LIST() +}; + +/* Configure device */ +static int +uadk_crypto_pmd_config(struct rte_cryptodev *dev __rte_unused, + struct rte_cryptodev_config *config __rte_unused) +{ + return 0; +} + +/* Start device */ +static int +uadk_crypto_pmd_start(struct rte_cryptodev *dev __rte_unused) +{ + return 0; +} + +/* Stop device */ +static void +uadk_crypto_pmd_stop(struct rte_cryptodev *dev __rte_unused) +{ +} + +/* Close device */ +static int +uadk_crypto_pmd_close(struct rte_cryptodev *dev __rte_unused) +{ + return 0; +} + +/* Get device statistics */ +static void +uadk_crypto_pmd_stats_get(struct rte_cryptodev *dev, + struct rte_cryptodev_stats *stats) +{ + int qp_id; + + for (qp_id = 0; qp_id < dev->data->nb_queue_pairs; qp_id++) { + struct uadk_qp *qp = dev->data->queue_pairs[qp_id]; + + stats->enqueued_count += qp->qp_stats.enqueued_count; + stats->dequeued_count += qp->qp_stats.dequeued_count; + stats->enqueue_err_count += qp->qp_stats.enqueue_err_count; + stats->dequeue_err_count += qp->qp_stats.dequeue_err_count; + } +} + +/* Reset device statistics */ +static void +uadk_crypto_pmd_stats_reset(struct rte_cryptodev *dev __rte_unused) +{ + int qp_id; + + for (qp_id = 0; qp_id < dev->data->nb_queue_pairs; qp_id++) { + struct uadk_qp *qp = dev->data->queue_pairs[qp_id]; + + memset(&qp->qp_stats, 0, sizeof(qp->qp_stats)); + } +} + +/* Get device info */ +static void +uadk_crypto_pmd_info_get(struct rte_cryptodev *dev, + struct rte_cryptodev_info *dev_info) +{ + struct uadk_crypto_priv *priv = dev->data->dev_private; + + if (dev_info != NULL) { + dev_info->driver_id = dev->driver_id; + dev_info->driver_name = dev->device->driver->name; + dev_info->max_nb_queue_pairs = 128; + /* No limit of number of sessions */ + dev_info->sym.max_nb_sessions = 0; + dev_info->feature_flags = dev->feature_flags; + + if (priv->version == UADK_CRYPTO_V2) + dev_info->capabilities = uadk_crypto_v2_capabilities; + } +} + +/* Release queue pair */ +static int +uadk_crypto_pmd_qp_release(struct rte_cryptodev *dev, uint16_t qp_id) +{ + struct uadk_qp *qp = dev->data->queue_pairs[qp_id]; + + if (qp) { + rte_ring_free(qp->processed_pkts); + rte_free(qp); + dev->data->queue_pairs[qp_id] = NULL; + } + + return 0; +} + +/* set a unique name for the queue pair based on its name, dev_id and qp_id */ +static int +uadk_pmd_qp_set_unique_name(struct rte_cryptodev *dev, + struct uadk_qp *qp) +{ + unsigned int n = snprintf(qp->name, sizeof(qp->name), + "uadk_crypto_pmd_%u_qp_%u", + dev->data->dev_id, qp->id); + + if (n >= sizeof(qp->name)) + return -EINVAL; + + return 0; +} + +/* Create a ring to place process packets on */ +static struct rte_ring * +uadk_pmd_qp_create_processed_pkts_ring(struct uadk_qp *qp, + unsigned int ring_size, int socket_id) +{ + struct rte_ring *r = qp->processed_pkts; + + if (r) { + if (rte_ring_get_size(r) >= ring_size) { + UADK_LOG(INFO, "Reusing existing ring %s for processed packets", + qp->name); + return r; + } + + UADK_LOG(ERR, "Unable to reuse existing ring %s for processed packets", + qp->name); + return NULL; + } + + return rte_ring_create(qp->name, ring_size, socket_id, + RING_F_EXACT_SZ); +} + +static int +uadk_crypto_pmd_qp_setup(struct rte_cryptodev *dev, uint16_t qp_id, + const struct rte_cryptodev_qp_conf *qp_conf, + int socket_id) +{ + struct uadk_qp *qp; + + /* Free memory prior to re-allocation if needed. */ + if (dev->data->queue_pairs[qp_id] != NULL) + uadk_crypto_pmd_qp_release(dev, qp_id); + + /* Allocate the queue pair data structure. */ + qp = rte_zmalloc_socket("uadk PMD Queue Pair", sizeof(*qp), + RTE_CACHE_LINE_SIZE, socket_id); + if (qp == NULL) + return (-ENOMEM); + + qp->id = qp_id; + dev->data->queue_pairs[qp_id] = qp; + + if (uadk_pmd_qp_set_unique_name(dev, qp)) + goto qp_setup_cleanup; + + qp->processed_pkts = uadk_pmd_qp_create_processed_pkts_ring(qp, + qp_conf->nb_descriptors, socket_id); + if (qp->processed_pkts == NULL) + goto qp_setup_cleanup; + + memset(&qp->qp_stats, 0, sizeof(qp->qp_stats)); + + return 0; + +qp_setup_cleanup: + if (qp) { + rte_free(qp); + qp = NULL; + } + return -EINVAL; +} + +static unsigned int +uadk_crypto_sym_session_get_size(struct rte_cryptodev *dev __rte_unused) +{ + return sizeof(struct uadk_crypto_session); +} + +static enum uadk_chain_order +uadk_get_chain_order(const struct rte_crypto_sym_xform *xform __rte_unused) +{ + enum uadk_chain_order res = UADK_CHAIN_NOT_SUPPORTED; + + return res; +} + +static int +uadk_crypto_sym_session_configure(struct rte_cryptodev *dev, + struct rte_crypto_sym_xform *xform, + struct rte_cryptodev_sym_session *session, + struct rte_mempool *mp) +{ + struct uadk_crypto_session *sess; + int ret; + + ret = rte_mempool_get(mp, (void *)&sess); + if (ret != 0) { + UADK_LOG(ERR, "Failed to get session %p private data from mempool", + sess); + return -ENOMEM; + } + + sess->chain_order = uadk_get_chain_order(xform); + switch (sess->chain_order) { + default: + ret = -ENOTSUP; + goto err; + } + + set_sym_session_private_data(session, dev->driver_id, sess); + + return 0; +err: + rte_mempool_put(mp, sess); + return ret; +} + +static void +uadk_crypto_sym_session_clear(struct rte_cryptodev *dev, + struct rte_cryptodev_sym_session *sess) +{ + struct uadk_crypto_session *priv_sess = + get_sym_session_private_data(sess, dev->driver_id); + + if (unlikely(priv_sess == NULL)) { + UADK_LOG(ERR, "Failed to get session %p private data.", priv_sess); + return; + } + + set_sym_session_private_data(sess, dev->driver_id, NULL); + rte_mempool_put(rte_mempool_from_obj(priv_sess), priv_sess); +} + +static struct rte_cryptodev_ops uadk_crypto_pmd_ops = { + .dev_configure = uadk_crypto_pmd_config, + .dev_start = uadk_crypto_pmd_start, + .dev_stop = uadk_crypto_pmd_stop, + .dev_close = uadk_crypto_pmd_close, + .stats_get = uadk_crypto_pmd_stats_get, + .stats_reset = uadk_crypto_pmd_stats_reset, + .dev_infos_get = uadk_crypto_pmd_info_get, + .queue_pair_setup = uadk_crypto_pmd_qp_setup, + .queue_pair_release = uadk_crypto_pmd_qp_release, + .sym_session_get_size = uadk_crypto_sym_session_get_size, + .sym_session_configure = uadk_crypto_sym_session_configure, + .sym_session_clear = uadk_crypto_sym_session_clear, +}; + +static uint16_t +uadk_crypto_enqueue_burst(void *queue_pair, struct rte_crypto_op **ops, + uint16_t nb_ops) +{ + struct uadk_qp *qp = queue_pair; + struct uadk_crypto_session *sess = NULL; + struct rte_crypto_op *op; + uint16_t enqd = 0; + int i, ret; + + for (i = 0; i < nb_ops; i++) { + op = ops[i]; + op->status = RTE_CRYPTO_OP_STATUS_NOT_PROCESSED; + + if (op->sess_type == RTE_CRYPTO_OP_WITH_SESSION) { + if (likely(op->sym->session != NULL)) + sess = (struct uadk_crypto_session *) + get_sym_session_private_data( + op->sym->session, + uadk_cryptodev_driver_id); + } + + switch (sess->chain_order) { + default: + op->status = RTE_CRYPTO_OP_STATUS_ERROR; + break; + } + + if (op->status == RTE_CRYPTO_OP_STATUS_NOT_PROCESSED) + op->status = RTE_CRYPTO_OP_STATUS_SUCCESS; + + if (op->status != RTE_CRYPTO_OP_STATUS_ERROR) { + ret = rte_ring_enqueue(qp->processed_pkts, (void *)op); + if (ret < 0) + goto enqueue_err; + qp->qp_stats.enqueued_count++; + enqd++; + } else { + /* increment count if failed to enqueue op */ + qp->qp_stats.enqueue_err_count++; + } + } + + return enqd; + +enqueue_err: + qp->qp_stats.enqueue_err_count++; + return enqd; +} + +static uint16_t +uadk_crypto_dequeue_burst(void *queue_pair, struct rte_crypto_op **ops, + uint16_t nb_ops) +{ + struct uadk_qp *qp = queue_pair; + unsigned int nb_dequeued; + + nb_dequeued = rte_ring_dequeue_burst(qp->processed_pkts, + (void **)ops, nb_ops, NULL); + qp->qp_stats.dequeued_count += nb_dequeued; + + return nb_dequeued; +} + +static int +uadk_cryptodev_probe(struct rte_vdev_device *vdev) +{ + struct rte_cryptodev_pmd_init_params init_params = { + .name = "", + .private_data_size = sizeof(struct uadk_crypto_priv), + .max_nb_queue_pairs = + RTE_CRYPTODEV_PMD_DEFAULT_MAX_NB_QUEUE_PAIRS, + }; + enum uadk_crypto_version version = UADK_CRYPTO_V2; + struct uadk_crypto_priv *priv; + struct rte_cryptodev *dev; + struct uacce_dev *udev; + const char *name; + + udev = wd_get_accel_dev("cipher"); + if (!udev) + return -ENODEV; + + if (!strcmp(udev->api, "hisi_qm_v2")) + version = UADK_CRYPTO_V2; + + free(udev); + + name = rte_vdev_device_name(vdev); + if (name == NULL) + return -EINVAL; + + dev = rte_cryptodev_pmd_create(name, &vdev->device, &init_params); + if (dev == NULL) { + UADK_LOG(ERR, "driver %s: create failed", init_params.name); + return -ENODEV; + } + + dev->dev_ops = &uadk_crypto_pmd_ops; + dev->driver_id = uadk_cryptodev_driver_id; + dev->dequeue_burst = uadk_crypto_dequeue_burst; + dev->enqueue_burst = uadk_crypto_enqueue_burst; + dev->feature_flags = RTE_CRYPTODEV_FF_HW_ACCELERATED | + RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO | + RTE_CRYPTODEV_FF_SYM_SESSIONLESS; + priv = dev->data->dev_private; + priv->version = version; + + rte_cryptodev_pmd_probing_finish(dev); + + return 0; +} + +static int +uadk_cryptodev_remove(struct rte_vdev_device *vdev) +{ + struct rte_cryptodev *cryptodev; + const char *name; + + name = rte_vdev_device_name(vdev); + if (name == NULL) + return -EINVAL; + + cryptodev = rte_cryptodev_pmd_get_named_dev(name); + if (cryptodev == NULL) + return -ENODEV; + + return rte_cryptodev_pmd_destroy(cryptodev); +} + +static struct rte_vdev_driver uadk_crypto_pmd = { + .probe = uadk_cryptodev_probe, + .remove = uadk_cryptodev_remove, +}; + +static struct cryptodev_driver uadk_crypto_drv; + +#define UADK_CRYPTO_DRIVER_NAME crypto_uadk +RTE_PMD_REGISTER_VDEV(UADK_CRYPTO_DRIVER_NAME, uadk_crypto_pmd); +RTE_PMD_REGISTER_CRYPTO_DRIVER(uadk_crypto_drv, uadk_crypto_pmd.driver, + uadk_cryptodev_driver_id); diff --git a/drivers/crypto/uadk/version.map b/drivers/crypto/uadk/version.map new file mode 100644 index 0000000000..c2e0723b4c --- /dev/null +++ b/drivers/crypto/uadk/version.map @@ -0,0 +1,3 @@ +DPDK_22 { + local: *; +}; From patchwork Fri Sep 23 02:40:21 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Zhangfei Gao X-Patchwork-Id: 608577 Delivered-To: patch@linaro.org Received: by 2002:a17:522:c983:b0:460:3032:e3c4 with SMTP id kr3csp37632pvb; Thu, 22 Sep 2022 19:41:01 -0700 (PDT) X-Google-Smtp-Source: AMsMyM5rD3bNgonYJ3H6bgnOg+i1zcaaFgeG6scpbROL8oPc071Aq5MhLMeCH0OP0082POj1xA/S X-Received: by 2002:a5d:5a0d:0:b0:228:da3f:738 with SMTP id bq13-20020a5d5a0d000000b00228da3f0738mr3723441wrb.526.1663900861596; Thu, 22 Sep 2022 19:41:01 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1663900861; cv=none; d=google.com; s=arc-20160816; b=PZn6IUq/97qVrtdTx9oMqdIKpP5MGymXiKTNE+LZESdfKzKXGxXlRFeiT7tXJASQBH mddIIvvZvcNKiQusI73nPuvd4GwL5MQj4o7jLwGaqXi8xZl1m/8V65z3eotHpQr6966S CL6NKdCTSozmPbP6kaEb3rGcoKHcFb8dSI0czx5YNnte4F0hUaIAygyslHo2UHUz3N9u pPdPcsxvC0BIrXGtfe1TUvl/oP2S6qFD3F5fZ/aGf4nQT5W4PExXJ5XA6GnC+VATL1Bo AYbs9zWrvyV3tgyAqmiDFQI7Nay6R8OAtf1vjKJHn6o5Uk1m7UwCAWNS4TQ4tgAt0fsx H0Kg== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=errors-to:list-subscribe:list-help:list-post:list-archive :list-unsubscribe:list-id:precedence:content-transfer-encoding :mime-version:references:in-reply-to:message-id:date:subject:cc:to :from:dkim-signature; bh=47GX/bSxDO5Dj/HGxysTpVv0eGr5z+i20Q/9QaKJEcE=; b=okkaVD7RRGhL18CYDcCUHtMB97Pu2rQNJt7iamcurVapl3s0Qan91/Dv2zW3wY9VdD HxgZ35G2GpRzZAt+8QuMgUOS9bynZMQRQy3aS0KnBdXd+gypRnLdz23QhBMPXAZJPFz6 4/paFxaV81tUGBzQP2ejFqANBwnHZR7wp8Hzfuz+bfcLD8/CLx4KsLaMGhQALmP+y+vr wD8TZH/C87kHdMPO6dMdsa+zdYx3pktS48eo0/7bsX8LQ/qWZuOxLQhgrXT2yvDB4h80 D+NLdC2TQ8SCw5v4JtOotO3ti/XxDOB9KWF7gOwnkuMO5qdfqvx5M9vonfMyE4+DfHPj 4DAQ== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=A9kKS2Hq; spf=pass (google.com: domain of dev-bounces@dpdk.org designates 217.70.189.124 as permitted sender) smtp.mailfrom=dev-bounces@dpdk.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org Return-Path: Received: from mails.dpdk.org (mails.dpdk.org. [217.70.189.124]) by mx.google.com with ESMTP id h14-20020a05600016ce00b002216dd6a282si5743624wrf.70.2022.09.22.19.41.01; Thu, 22 Sep 2022 19:41:01 -0700 (PDT) Received-SPF: pass (google.com: domain of dev-bounces@dpdk.org designates 217.70.189.124 as permitted sender) client-ip=217.70.189.124; Authentication-Results: mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=A9kKS2Hq; spf=pass (google.com: domain of dev-bounces@dpdk.org designates 217.70.189.124 as permitted sender) smtp.mailfrom=dev-bounces@dpdk.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org Received: from [217.70.189.124] (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id 604F042B6E; Fri, 23 Sep 2022 04:41:00 +0200 (CEST) Received: from mail-pl1-f174.google.com (mail-pl1-f174.google.com [209.85.214.174]) by mails.dpdk.org (Postfix) with ESMTP id 908B142836 for ; Fri, 23 Sep 2022 04:40:59 +0200 (CEST) Received: by mail-pl1-f174.google.com with SMTP id t3so10554531ply.2 for ; Thu, 22 Sep 2022 19:40:59 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date; bh=47GX/bSxDO5Dj/HGxysTpVv0eGr5z+i20Q/9QaKJEcE=; b=A9kKS2HqfIDmaRO515rRGWd/gOldU0SxiQoBPFAxEuJ/uVvSFYaGYA1ugvgNKGtyYX Bkr6C6Onm8vvVcUWKlFKxFGjHKxIl64zEeJ/jTXlXVaL8651wB+JhPGxrKt4zlpYPUHO tNoqeo3Pq5PwFf5nveN8t3Hb6WLlSqXwh9Y6hYdSKPiLoHd+4E//AuyvAWZ97A1kl7fu WrzIPVxuJxgLvqGY5/VQFolnU40zZuc96vbU48GBF/z/1Eij8lWYCmzf56JEHkU1bRFu neh1YxTxraQqo68T1b2TWHDPqBzlHt7JJpEvf2VYMnZsuHUVdifQRorCyXq0ZaZ5bBZi xnJw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date; bh=47GX/bSxDO5Dj/HGxysTpVv0eGr5z+i20Q/9QaKJEcE=; b=gsvjbXoZ2HpDCvq49JDCn7GbPQZy5IfwYGhIIJJqt3TfxxMUmzJkqYIevqb3qVisQG Yy2xshr3jHTyNP1IIxJ4kBp8bbwWjj8/fHgLP9ehuckSsLmFGJoTldBqYu2sDsE3xHi1 6rZKGhXDklQ3RqsLkQ/jALuiFSKdPTKnUCdB7ZXvk3J5jlwBZr/k3XrZSB96/RFP3RPh oMVNUtKe4iH5wPX3MJJfWZVxYNAgcp0wkrwq++64Se7ot3hsdNiYJMmfKJaPJkiQsgFR PxHbTT1IKhWybkGIf0hijsaOHwYAv8+zx7H8iOPAHcuwo0sGU8F/nSmZlshAoAYU/FTx C7PA== X-Gm-Message-State: ACrzQf2kur8IaJeOcSf0sJk+tyWKSRbmYvUCt/OGRL1lnWJhCo5RZaey xXEjOAv+YaB1RKLrw5+R3FbskReCf0X9GLP4 X-Received: by 2002:a17:90b:1bc3:b0:203:84d:59b1 with SMTP id oa3-20020a17090b1bc300b00203084d59b1mr18889570pjb.37.1663900858915; Thu, 22 Sep 2022 19:40:58 -0700 (PDT) Received: from localhost.localdomain ([199.101.192.56]) by smtp.gmail.com with ESMTPSA id t5-20020a625f05000000b0053e8940c4absm5075011pfb.209.2022.09.22.19.40.50 (version=TLS1_2 cipher=ECDHE-ECDSA-AES128-GCM-SHA256 bits=128/128); Thu, 22 Sep 2022 19:40:58 -0700 (PDT) From: Zhangfei Gao To: Akhil Goyal , Declan Doherty , Fan Zhang , Ashish Gupta , Ray Kinsella Cc: dev@dpdk.org, acc@openeuler.org, Zhangfei Gao Subject: [PATCH v2 3/5] crypto/uadk: support cipher algorithms Date: Fri, 23 Sep 2022 10:40:21 +0800 Message-Id: <20220923024023.15849-4-zhangfei.gao@linaro.org> X-Mailer: git-send-email 2.36.1 In-Reply-To: <20220923024023.15849-1-zhangfei.gao@linaro.org> References: <20220923024023.15849-1-zhangfei.gao@linaro.org> MIME-Version: 1.0 X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org Cipher algorithms: * ``RTE_CRYPTO_CIPHER_AES_ECB`` * ``RTE_CRYPTO_CIPHER_AES_CBC`` * ``RTE_CRYPTO_CIPHER_AES_XTS`` * ``RTE_CRYPTO_CIPHER_DES_CBC`` Signed-off-by: Zhangfei Gao --- drivers/crypto/uadk/uadk_crypto_pmd.c | 254 +++++++++++++++++++++++++- 1 file changed, 252 insertions(+), 2 deletions(-) diff --git a/drivers/crypto/uadk/uadk_crypto_pmd.c b/drivers/crypto/uadk/uadk_crypto_pmd.c index aad42524d6..592d747a5d 100644 --- a/drivers/crypto/uadk/uadk_crypto_pmd.c +++ b/drivers/crypto/uadk/uadk_crypto_pmd.c @@ -30,11 +30,26 @@ struct uadk_qp { } __rte_cache_aligned; enum uadk_chain_order { + UADK_CHAIN_ONLY_CIPHER, UADK_CHAIN_NOT_SUPPORTED }; struct uadk_crypto_session { + handle_t handle_cipher; enum uadk_chain_order chain_order; + + /* IV parameters */ + struct { + uint16_t length; + uint16_t offset; + } iv; + + /* Cipher Parameters */ + struct { + enum rte_crypto_cipher_operation direction; + /* cipher operation direction */ + struct wd_cipher_req req; + } cipher; } __rte_cache_aligned; enum uadk_crypto_version { @@ -43,6 +58,7 @@ enum uadk_crypto_version { }; struct uadk_crypto_priv { + bool env_cipher_init; enum uadk_crypto_version version; } __rte_cache_aligned; @@ -56,6 +72,86 @@ RTE_LOG_REGISTER_DEFAULT(uadk_crypto_logtype, INFO); ## __VA_ARGS__) static const struct rte_cryptodev_capabilities uadk_crypto_v2_capabilities[] = { + { /* AES ECB */ + .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC, + {.sym = { + .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER, + {.cipher = { + .algo = RTE_CRYPTO_CIPHER_AES_ECB, + .block_size = 16, + .key_size = { + .min = 16, + .max = 32, + .increment = 8 + }, + .iv_size = { + .min = 0, + .max = 0, + .increment = 0 + } + }, } + }, } + }, + { /* AES CBC */ + .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC, + {.sym = { + .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER, + {.cipher = { + .algo = RTE_CRYPTO_CIPHER_AES_CBC, + .block_size = 16, + .key_size = { + .min = 16, + .max = 32, + .increment = 8 + }, + .iv_size = { + .min = 16, + .max = 16, + .increment = 0 + } + }, } + }, } + }, + { /* AES XTS */ + .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC, + {.sym = { + .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER, + {.cipher = { + .algo = RTE_CRYPTO_CIPHER_AES_XTS, + .block_size = 1, + .key_size = { + .min = 32, + .max = 64, + .increment = 32 + }, + .iv_size = { + .min = 0, + .max = 0, + .increment = 0 + } + }, } + }, } + }, + { /* DES CBC */ + .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC, + {.sym = { + .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER, + {.cipher = { + .algo = RTE_CRYPTO_CIPHER_DES_CBC, + .block_size = 8, + .key_size = { + .min = 8, + .max = 8, + .increment = 0 + }, + .iv_size = { + .min = 8, + .max = 8, + .increment = 0 + } + }, } + }, } + }, /* End of symmetric capabilities */ RTE_CRYPTODEV_END_OF_CAPABILITIES_LIST() }; @@ -83,8 +179,15 @@ uadk_crypto_pmd_stop(struct rte_cryptodev *dev __rte_unused) /* Close device */ static int -uadk_crypto_pmd_close(struct rte_cryptodev *dev __rte_unused) +uadk_crypto_pmd_close(struct rte_cryptodev *dev) { + struct uadk_crypto_priv *priv = dev->data->dev_private; + + if (priv->env_cipher_init) { + wd_cipher_env_uninit(); + priv->env_cipher_init = false; + } + return 0; } @@ -238,19 +341,107 @@ uadk_crypto_sym_session_get_size(struct rte_cryptodev *dev __rte_unused) } static enum uadk_chain_order -uadk_get_chain_order(const struct rte_crypto_sym_xform *xform __rte_unused) +uadk_get_chain_order(const struct rte_crypto_sym_xform *xform) { enum uadk_chain_order res = UADK_CHAIN_NOT_SUPPORTED; + if (xform != NULL) { + if (xform->type == RTE_CRYPTO_SYM_XFORM_CIPHER) { + if (xform->next == NULL) + res = UADK_CHAIN_ONLY_CIPHER; + } + } + return res; } +static int +uadk_set_session_cipher_parameters(struct rte_cryptodev *dev, + struct uadk_crypto_session *sess, + struct rte_crypto_sym_xform *xform) +{ + struct uadk_crypto_priv *priv = dev->data->dev_private; + struct rte_crypto_cipher_xform *cipher = &xform->cipher; + struct wd_cipher_sess_setup setup = {0}; + struct sched_params params = {0}; + int ret; + + if (!priv->env_cipher_init) { + ret = wd_cipher_env_init(NULL); + if (ret < 0) + return -EINVAL; + priv->env_cipher_init = true; + } + + sess->cipher.direction = cipher->op; + sess->iv.offset = cipher->iv.offset; + sess->iv.length = cipher->iv.length; + + switch (cipher->algo) { + /* Cover supported cipher algorithms */ + case RTE_CRYPTO_CIPHER_AES_CTR: + setup.alg = WD_CIPHER_AES; + setup.mode = WD_CIPHER_CTR; + sess->cipher.req.out_bytes = 64; + break; + case RTE_CRYPTO_CIPHER_AES_ECB: + setup.alg = WD_CIPHER_AES; + setup.mode = WD_CIPHER_ECB; + sess->cipher.req.out_bytes = 16; + break; + case RTE_CRYPTO_CIPHER_AES_CBC: + setup.alg = WD_CIPHER_AES; + setup.mode = WD_CIPHER_CBC; + if (cipher->key.length == 16) + sess->cipher.req.out_bytes = 16; + else + sess->cipher.req.out_bytes = 64; + break; + case RTE_CRYPTO_CIPHER_AES_XTS: + setup.alg = WD_CIPHER_AES; + setup.mode = WD_CIPHER_XTS; + if (cipher->key.length == 16) + sess->cipher.req.out_bytes = 32; + else + sess->cipher.req.out_bytes = 512; + break; + default: + ret = -ENOTSUP; + goto env_uninit; + } + + params.numa_id = -1; /* choose nearby numa node */ + setup.sched_param = ¶ms; + sess->handle_cipher = wd_cipher_alloc_sess(&setup); + if (!sess->handle_cipher) { + UADK_LOG(ERR, "uadk failed to alloc session!\n"); + ret = -EINVAL; + goto env_uninit; + } + + ret = wd_cipher_set_key(sess->handle_cipher, cipher->key.data, cipher->key.length); + if (ret) { + wd_cipher_free_sess(sess->handle_cipher); + UADK_LOG(ERR, "uadk failed to set key!\n"); + ret = -EINVAL; + goto env_uninit; + } + + return 0; + +env_uninit: + wd_cipher_env_uninit(); + priv->env_cipher_init = false; + return ret; +} + static int uadk_crypto_sym_session_configure(struct rte_cryptodev *dev, struct rte_crypto_sym_xform *xform, struct rte_cryptodev_sym_session *session, struct rte_mempool *mp) { + struct rte_crypto_sym_xform *cipher_xform = NULL; struct uadk_crypto_session *sess; int ret; @@ -263,11 +454,23 @@ uadk_crypto_sym_session_configure(struct rte_cryptodev *dev, sess->chain_order = uadk_get_chain_order(xform); switch (sess->chain_order) { + case UADK_CHAIN_ONLY_CIPHER: + cipher_xform = xform; + break; default: ret = -ENOTSUP; goto err; } + if (cipher_xform) { + ret = uadk_set_session_cipher_parameters(dev, sess, cipher_xform); + if (ret != 0) { + UADK_LOG(ERR, + "Invalid/unsupported cipher parameters"); + goto err; + } + } + set_sym_session_private_data(session, dev->driver_id, sess); return 0; @@ -288,6 +491,11 @@ uadk_crypto_sym_session_clear(struct rte_cryptodev *dev, return; } + if (priv_sess->handle_cipher) { + wd_cipher_free_sess(priv_sess->handle_cipher); + priv_sess->handle_cipher = 0; + } + set_sym_session_private_data(sess, dev->driver_id, NULL); rte_mempool_put(rte_mempool_from_obj(priv_sess), priv_sess); } @@ -307,12 +515,49 @@ static struct rte_cryptodev_ops uadk_crypto_pmd_ops = { .sym_session_clear = uadk_crypto_sym_session_clear, }; +static void +uadk_process_cipher_op(struct rte_crypto_op *op, + struct uadk_crypto_session *sess, + struct rte_mbuf *msrc, struct rte_mbuf *mdst) +{ + uint32_t off = op->sym->cipher.data.offset; + int ret; + + if (!sess) { + op->status = RTE_COMP_OP_STATUS_INVALID_ARGS; + return; + } + + sess->cipher.req.src = rte_pktmbuf_mtod_offset(msrc, uint8_t *, off); + sess->cipher.req.in_bytes = op->sym->cipher.data.length; + sess->cipher.req.dst = rte_pktmbuf_mtod_offset(mdst, uint8_t *, off); + sess->cipher.req.out_buf_bytes = sess->cipher.req.in_bytes; + sess->cipher.req.iv_bytes = sess->iv.length; + sess->cipher.req.iv = rte_crypto_op_ctod_offset(op, uint8_t *, + sess->iv.offset); + if (sess->cipher.direction == RTE_CRYPTO_CIPHER_OP_ENCRYPT) + sess->cipher.req.op_type = WD_CIPHER_ENCRYPTION; + else + sess->cipher.req.op_type = WD_CIPHER_DECRYPTION; + + do { + ret = wd_do_cipher_sync(sess->handle_cipher, &sess->cipher.req); + } while (ret == -WD_EBUSY); + + if (sess->cipher.req.out_buf_bytes > sess->cipher.req.in_bytes) + op->status = RTE_COMP_OP_STATUS_OUT_OF_SPACE_TERMINATED; + + if (ret) + op->status = RTE_COMP_OP_STATUS_ERROR; +} + static uint16_t uadk_crypto_enqueue_burst(void *queue_pair, struct rte_crypto_op **ops, uint16_t nb_ops) { struct uadk_qp *qp = queue_pair; struct uadk_crypto_session *sess = NULL; + struct rte_mbuf *msrc, *mdst; struct rte_crypto_op *op; uint16_t enqd = 0; int i, ret; @@ -320,6 +565,8 @@ uadk_crypto_enqueue_burst(void *queue_pair, struct rte_crypto_op **ops, for (i = 0; i < nb_ops; i++) { op = ops[i]; op->status = RTE_CRYPTO_OP_STATUS_NOT_PROCESSED; + msrc = op->sym->m_src; + mdst = op->sym->m_dst ? op->sym->m_dst : op->sym->m_src; if (op->sess_type == RTE_CRYPTO_OP_WITH_SESSION) { if (likely(op->sym->session != NULL)) @@ -330,6 +577,9 @@ uadk_crypto_enqueue_burst(void *queue_pair, struct rte_crypto_op **ops, } switch (sess->chain_order) { + case UADK_CHAIN_ONLY_CIPHER: + uadk_process_cipher_op(op, sess, msrc, mdst); + break; default: op->status = RTE_CRYPTO_OP_STATUS_ERROR; break; From patchwork Fri Sep 23 02:40:22 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Zhangfei Gao X-Patchwork-Id: 608578 Delivered-To: patch@linaro.org Received: by 2002:a17:522:c983:b0:460:3032:e3c4 with SMTP id kr3csp37669pvb; Thu, 22 Sep 2022 19:41:07 -0700 (PDT) X-Google-Smtp-Source: AMsMyM6JZ1a16qXxzMU5Ki9jZ2FDSj8xs5ErphooyrWQSO9+SF5zWMIsp/nu7ovWbG4AFwICP/9V X-Received: by 2002:a05:600c:6d2:b0:3b4:8361:6154 with SMTP id b18-20020a05600c06d200b003b483616154mr4433561wmn.89.1663900867328; Thu, 22 Sep 2022 19:41:07 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1663900867; cv=none; d=google.com; s=arc-20160816; b=cR2fDhJtrUf3Wh2CwMlTc6Xn/FZ5HDea0du2z9E42u8c0OePI8uqbw074CwmsSDENl QMom+iZ+AGJ4oVzhWEsznDFJGqBVFMkblO3dgTT+8ivmGlLUS9sxKt1NovwYHSvhZj/q Ew9F/mkxO5DrrC1q+ZV2/71sPeZK1EwbtpW16QwBFCHvd9tp03fDkjrALN5KwnW6kHkh iPz0qVJaj4Ggc8GTUGXKgUpfe8yWEVlTPSkhvv4JRsApKVTFfu+DZh+TiioqcZv6AAOj jeR94s1+m8qx6X4PD/3Oly/UZ6vKcCpvE3qWPhCt+UoOjkFCp8t/NfpjDv3GoikLjjxl Q7ng== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=errors-to:list-subscribe:list-help:list-post:list-archive :list-unsubscribe:list-id:precedence:content-transfer-encoding :mime-version:references:in-reply-to:message-id:date:subject:cc:to :from:dkim-signature; bh=IMMUkw0maZIUUtP63ReBUxU6MoVpVfTMOiuh3+PXCqg=; b=SMKzGnq5xHiF9OedcIYZcIMk+u3LEyJq45GruyFjDx5AcpJ8uYLoAhsINZPIprEKyA XswkPZg05f6FDfJrX+giMHie9iKi7x4mAtkLKWd0rmzm45+/EyZpCEVsDTuagt2Qepeo K/JbY5e8teL7K/1S71q7dsj0g5JXSkxn9Lqpb11pJTtcR6yRj0AxcAiYljE4RmPQEC8U NSTbclfLZ7tRFzlyQoKQZnVjS+/bXjnea9CDAem2Y8wyUITqaxX7TAYn8O4nYvlChfSI WV0D7pI7nGTeJ3gaOUTPBDocOnRBxoy/dXsd8I/Gkdq3paCFqT4RudVyKP3Y9+PS983t UX2Q== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=DZjFK8EY; spf=pass (google.com: domain of dev-bounces@dpdk.org designates 217.70.189.124 as permitted sender) smtp.mailfrom=dev-bounces@dpdk.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org Return-Path: Received: from mails.dpdk.org (mails.dpdk.org. [217.70.189.124]) by mx.google.com with ESMTP id g5-20020a7bc4c5000000b003a31820194csi705996wmk.3.2022.09.22.19.41.07; Thu, 22 Sep 2022 19:41:07 -0700 (PDT) Received-SPF: pass (google.com: domain of dev-bounces@dpdk.org designates 217.70.189.124 as permitted sender) client-ip=217.70.189.124; Authentication-Results: mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=DZjFK8EY; spf=pass (google.com: domain of dev-bounces@dpdk.org designates 217.70.189.124 as permitted sender) smtp.mailfrom=dev-bounces@dpdk.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org Received: from [217.70.189.124] (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id 864AA42802; Fri, 23 Sep 2022 04:41:06 +0200 (CEST) Received: from mail-pj1-f54.google.com (mail-pj1-f54.google.com [209.85.216.54]) by mails.dpdk.org (Postfix) with ESMTP id 384D64003C for ; Fri, 23 Sep 2022 04:41:05 +0200 (CEST) Received: by mail-pj1-f54.google.com with SMTP id fs14so11601011pjb.5 for ; Thu, 22 Sep 2022 19:41:05 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date; bh=IMMUkw0maZIUUtP63ReBUxU6MoVpVfTMOiuh3+PXCqg=; b=DZjFK8EYxjzQDCf1MtSLlLNG4ixn9nCEgU1uHrag0+tCj0nbO9xTQw8H9eLG/JiuLy KgRUoVYsioXG1E/eSJMPjpO9CWfkzCtcLbcbgJcYO/Vt2Uh+Qq79353Ab+qfY/9rSAyc OuIbL/QHI7vmUo9A/bj0ktyp5K6BPuYGvnBaKluLFxwBwmWZV903trxeS672XgqGwsrg U9vzLKQMRwJxGWYD7FJwQYSwYo87IU+2E+uDIx/mXWrEftkhgi1+dPP2SYtenGafkDsh aPViUZ9YVcQWRDxsy1EDPxS8IKLMqNNmxN5kZ+D8n4kH5WTh5PBT2GqdTsf/saFvqrCM Ay1g== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date; bh=IMMUkw0maZIUUtP63ReBUxU6MoVpVfTMOiuh3+PXCqg=; b=tXxgZvHf3CjvKF+0sTFDkqrG89sO7xRH8LPyRZixU53Dgy0HJ1EeR8JsxGuYoUhn9J ioI2IxN5F05VfFqlOHvjhTK9mb0sPFMgYFd9HMbi6PWkZnPk7LB/OpvaWS/ywHccnrl3 i23UYZ+wxcZYYInSkXvNvRxaJWOPbkCKCrBgbLjWFa+6RTjTyCBhxXM6b8O/YxU4zMx6 WUUkIq3rvT/uYbU9bXjUKeo4SVIA2Op2VFFFHHyeeAcj7b0mC9syxigN/mjkyQmsLCuR CTGY4KskhYu73t/lXl1WWenCPJTo5y2hHo/de+9dN34Ei3THKeCmXJ4Dd4B+W00WnY6s fLug== X-Gm-Message-State: ACrzQf1jiYSCVIQ525zyHUY9I8jdodwVZXtEOd3Zmy4epCYIP/Rve3U+ v2Os7Aw5FhjUiAtLm+zmHIx57hnYhMuyj7BD X-Received: by 2002:a17:903:1104:b0:178:8756:6e4d with SMTP id n4-20020a170903110400b0017887566e4dmr6512959plh.114.1663900864425; Thu, 22 Sep 2022 19:41:04 -0700 (PDT) Received: from localhost.localdomain ([199.101.192.56]) by smtp.gmail.com with ESMTPSA id t5-20020a625f05000000b0053e8940c4absm5075011pfb.209.2022.09.22.19.40.59 (version=TLS1_2 cipher=ECDHE-ECDSA-AES128-GCM-SHA256 bits=128/128); Thu, 22 Sep 2022 19:41:04 -0700 (PDT) From: Zhangfei Gao To: Akhil Goyal , Declan Doherty , Fan Zhang , Ashish Gupta , Ray Kinsella Cc: dev@dpdk.org, acc@openeuler.org, Zhangfei Gao Subject: [PATCH v2 4/5] crypto/uadk: support auth algorithms Date: Fri, 23 Sep 2022 10:40:22 +0800 Message-Id: <20220923024023.15849-5-zhangfei.gao@linaro.org> X-Mailer: git-send-email 2.36.1 In-Reply-To: <20220923024023.15849-1-zhangfei.gao@linaro.org> References: <20220923024023.15849-1-zhangfei.gao@linaro.org> MIME-Version: 1.0 X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org Hash algorithms: * ``RTE_CRYPTO_AUTH_MD5`` * ``RTE_CRYPTO_AUTH_MD5_HMAC`` * ``RTE_CRYPTO_AUTH_SHA1`` * ``RTE_CRYPTO_AUTH_SHA1_HMAC`` * ``RTE_CRYPTO_AUTH_SHA224`` * ``RTE_CRYPTO_AUTH_SHA224_HMAC`` * ``RTE_CRYPTO_AUTH_SHA256`` * ``RTE_CRYPTO_AUTH_SHA256_HMAC`` * ``RTE_CRYPTO_AUTH_SHA384`` * ``RTE_CRYPTO_AUTH_SHA384_HMAC`` * ``RTE_CRYPTO_AUTH_SHA512`` * ``RTE_CRYPTO_AUTH_SHA512_HMAC`` Signed-off-by: Zhangfei Gao --- drivers/crypto/uadk/uadk_crypto_pmd.c | 461 ++++++++++++++++++++++++++ 1 file changed, 461 insertions(+) diff --git a/drivers/crypto/uadk/uadk_crypto_pmd.c b/drivers/crypto/uadk/uadk_crypto_pmd.c index 592d747a5d..740d567b99 100644 --- a/drivers/crypto/uadk/uadk_crypto_pmd.c +++ b/drivers/crypto/uadk/uadk_crypto_pmd.c @@ -31,11 +31,15 @@ struct uadk_qp { enum uadk_chain_order { UADK_CHAIN_ONLY_CIPHER, + UADK_CHAIN_ONLY_AUTH, + UADK_CHAIN_CIPHER_AUTH, + UADK_CHAIN_AUTH_CIPHER, UADK_CHAIN_NOT_SUPPORTED }; struct uadk_crypto_session { handle_t handle_cipher; + handle_t handle_digest; enum uadk_chain_order chain_order; /* IV parameters */ @@ -50,6 +54,15 @@ struct uadk_crypto_session { /* cipher operation direction */ struct wd_cipher_req req; } cipher; + + /* Authentication Parameters */ + struct { + struct wd_digest_req req; + enum rte_crypto_auth_operation operation; + /* auth operation generate or verify */ + uint16_t digest_length; + /* digest length */ + } auth; } __rte_cache_aligned; enum uadk_crypto_version { @@ -59,6 +72,7 @@ enum uadk_crypto_version { struct uadk_crypto_priv { bool env_cipher_init; + bool env_auth_init; enum uadk_crypto_version version; } __rte_cache_aligned; @@ -72,6 +86,252 @@ RTE_LOG_REGISTER_DEFAULT(uadk_crypto_logtype, INFO); ## __VA_ARGS__) static const struct rte_cryptodev_capabilities uadk_crypto_v2_capabilities[] = { + { /* MD5 HMAC */ + .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC, + {.sym = { + .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH, + {.auth = { + .algo = RTE_CRYPTO_AUTH_MD5_HMAC, + .block_size = 64, + .key_size = { + .min = 0, + .max = 0, + .increment = 0 + }, + .digest_size = { + .min = 16, + .max = 16, + .increment = 0 + }, + .iv_size = { 0 } + }, } + }, } + }, + { /* MD5 */ + .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC, + {.sym = { + .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH, + {.auth = { + .algo = RTE_CRYPTO_AUTH_MD5, + .block_size = 64, + .key_size = { + .min = 0, + .max = 0, + .increment = 0 + }, + .digest_size = { + .min = 16, + .max = 16, + .increment = 0 + }, + }, } + }, } + }, + { /* SHA1 HMAC */ + .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC, + {.sym = { + .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH, + {.auth = { + .algo = RTE_CRYPTO_AUTH_SHA1_HMAC, + .block_size = 64, + .key_size = { + .min = 0, + .max = 0, + .increment = 0 + }, + .digest_size = { + .min = 20, + .max = 20, + .increment = 0 + }, + .iv_size = { 0 } + }, } + }, } + }, + { /* SHA1 */ + .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC, + {.sym = { + .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH, + {.auth = { + .algo = RTE_CRYPTO_AUTH_SHA1, + .block_size = 64, + .key_size = { + .min = 0, + .max = 0, + .increment = 0 + }, + .digest_size = { + .min = 20, + .max = 20, + .increment = 0 + }, + }, } + }, } + }, + { /* SHA224 HMAC */ + .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC, + {.sym = { + .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH, + {.auth = { + .algo = RTE_CRYPTO_AUTH_SHA224_HMAC, + .block_size = 64, + .key_size = { + .min = 0, + .max = 0, + .increment = 0 + }, + .digest_size = { + .min = 28, + .max = 28, + .increment = 0 + }, + .iv_size = { 0 } + }, } + }, } + }, + { /* SHA224 */ + .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC, + {.sym = { + .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH, + {.auth = { + .algo = RTE_CRYPTO_AUTH_SHA224, + .block_size = 64, + .key_size = { + .min = 0, + .max = 0, + .increment = 0 + }, + .digest_size = { + .min = 28, + .max = 28, + .increment = 0 + }, + }, } + }, } + }, + { /* SHA256 HMAC */ + .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC, + {.sym = { + .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH, + {.auth = { + .algo = RTE_CRYPTO_AUTH_SHA256_HMAC, + .block_size = 64, + .key_size = { + .min = 0, + .max = 0, + .increment = 0 + }, + .digest_size = { + .min = 32, + .max = 32, + .increment = 0 + }, + .iv_size = { 0 } + }, } + }, } + }, + { /* SHA256 */ + .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC, + {.sym = { + .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH, + {.auth = { + .algo = RTE_CRYPTO_AUTH_SHA256, + .block_size = 64, + .key_size = { + .min = 0, + .max = 0, + .increment = 0 + }, + .digest_size = { + .min = 32, + .max = 32, + .increment = 0 + }, + }, } + }, } + }, + { /* SHA384 HMAC */ + .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC, + {.sym = { + .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH, + {.auth = { + .algo = RTE_CRYPTO_AUTH_SHA384_HMAC, + .block_size = 128, + .key_size = { + .min = 0, + .max = 0, + .increment = 0 + }, + .digest_size = { + .min = 48, + .max = 48, + .increment = 0 + }, + .iv_size = { 0 } + }, } + }, } + }, + { /* SHA384 */ + .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC, + {.sym = { + .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH, + {.auth = { + .algo = RTE_CRYPTO_AUTH_SHA384, + .block_size = 64, + .key_size = { + .min = 0, + .max = 0, + .increment = 0 + }, + .digest_size = { + .min = 48, + .max = 48, + .increment = 0 + }, + }, } + }, } + }, + { /* SHA512 HMAC */ + .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC, + {.sym = { + .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH, + {.auth = { + .algo = RTE_CRYPTO_AUTH_SHA512_HMAC, + .block_size = 128, + .key_size = { + .min = 0, + .max = 0, + .increment = 0 + }, + .digest_size = { + .min = 64, + .max = 64, + .increment = 0 + }, + .iv_size = { 0 } + }, } + }, } + }, + { /* SHA512 */ + .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC, + {.sym = { + .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH, + {.auth = { + .algo = RTE_CRYPTO_AUTH_SHA512, + .block_size = 128, + .key_size = { + .min = 0, + .max = 0, + .increment = 0 + }, + .digest_size = { + .min = 64, + .max = 64, + .increment = 0 + }, + }, } + }, } + }, { /* AES ECB */ .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC, {.sym = { @@ -188,6 +448,11 @@ uadk_crypto_pmd_close(struct rte_cryptodev *dev) priv->env_cipher_init = false; } + if (priv->env_auth_init) { + wd_digest_env_uninit(); + priv->env_auth_init = false; + } + return 0; } @@ -346,9 +611,19 @@ uadk_get_chain_order(const struct rte_crypto_sym_xform *xform) enum uadk_chain_order res = UADK_CHAIN_NOT_SUPPORTED; if (xform != NULL) { + if (xform->type == RTE_CRYPTO_SYM_XFORM_AUTH) { + if (xform->next == NULL) + res = UADK_CHAIN_ONLY_AUTH; + else if (xform->next->type == + RTE_CRYPTO_SYM_XFORM_CIPHER) + res = UADK_CHAIN_AUTH_CIPHER; + } + if (xform->type == RTE_CRYPTO_SYM_XFORM_CIPHER) { if (xform->next == NULL) res = UADK_CHAIN_ONLY_CIPHER; + else if (xform->next->type == RTE_CRYPTO_SYM_XFORM_AUTH) + res = UADK_CHAIN_CIPHER_AUTH; } } @@ -435,6 +710,112 @@ uadk_set_session_cipher_parameters(struct rte_cryptodev *dev, return ret; } +/* Set session auth parameters */ +static int +uadk_set_session_auth_parameters(struct rte_cryptodev *dev, + struct uadk_crypto_session *sess, + struct rte_crypto_sym_xform *xform) +{ + struct uadk_crypto_priv *priv = dev->data->dev_private; + struct wd_digest_sess_setup setup = {0}; + struct sched_params params = {0}; + int ret; + + if (!priv->env_auth_init) { + ret = wd_digest_env_init(NULL); + if (ret < 0) + return -EINVAL; + priv->env_auth_init = true; + } + + sess->auth.operation = xform->auth.op; + sess->auth.digest_length = xform->auth.digest_length; + + switch (xform->auth.algo) { + case RTE_CRYPTO_AUTH_MD5: + case RTE_CRYPTO_AUTH_MD5_HMAC: + setup.mode = (xform->auth.algo == RTE_CRYPTO_AUTH_MD5) ? + WD_DIGEST_NORMAL : WD_DIGEST_HMAC; + setup.alg = WD_DIGEST_MD5; + sess->auth.req.out_buf_bytes = 16; + sess->auth.req.out_bytes = 16; + break; + case RTE_CRYPTO_AUTH_SHA1: + case RTE_CRYPTO_AUTH_SHA1_HMAC: + setup.mode = (xform->auth.algo == RTE_CRYPTO_AUTH_SHA1) ? + WD_DIGEST_NORMAL : WD_DIGEST_HMAC; + setup.alg = WD_DIGEST_SHA1; + sess->auth.req.out_buf_bytes = 20; + sess->auth.req.out_bytes = 20; + break; + case RTE_CRYPTO_AUTH_SHA224: + case RTE_CRYPTO_AUTH_SHA224_HMAC: + setup.mode = (xform->auth.algo == RTE_CRYPTO_AUTH_SHA224) ? + WD_DIGEST_NORMAL : WD_DIGEST_HMAC; + setup.alg = WD_DIGEST_SHA224; + sess->auth.req.out_buf_bytes = 28; + sess->auth.req.out_bytes = 28; + break; + case RTE_CRYPTO_AUTH_SHA256: + case RTE_CRYPTO_AUTH_SHA256_HMAC: + setup.mode = (xform->auth.algo == RTE_CRYPTO_AUTH_SHA256) ? + WD_DIGEST_NORMAL : WD_DIGEST_HMAC; + setup.alg = WD_DIGEST_SHA256; + sess->auth.req.out_buf_bytes = 32; + sess->auth.req.out_bytes = 32; + break; + case RTE_CRYPTO_AUTH_SHA384: + case RTE_CRYPTO_AUTH_SHA384_HMAC: + setup.mode = (xform->auth.algo == RTE_CRYPTO_AUTH_SHA384) ? + WD_DIGEST_NORMAL : WD_DIGEST_HMAC; + setup.alg = WD_DIGEST_SHA384; + sess->auth.req.out_buf_bytes = 48; + sess->auth.req.out_bytes = 48; + break; + case RTE_CRYPTO_AUTH_SHA512: + case RTE_CRYPTO_AUTH_SHA512_HMAC: + setup.mode = (xform->auth.algo == RTE_CRYPTO_AUTH_SHA512) ? + WD_DIGEST_NORMAL : WD_DIGEST_HMAC; + setup.alg = WD_DIGEST_SHA512; + sess->auth.req.out_buf_bytes = 64; + sess->auth.req.out_bytes = 64; + break; + default: + ret = -ENOTSUP; + goto env_uninit; + } + + params.numa_id = -1; /* choose nearby numa node */ + setup.sched_param = ¶ms; + sess->handle_digest = wd_digest_alloc_sess(&setup); + if (!sess->handle_digest) { + UADK_LOG(ERR, "uadk failed to alloc session!\n"); + ret = -EINVAL; + goto env_uninit; + } + + /* if mode is HMAC, should set key */ + if (setup.mode == WD_DIGEST_HMAC) { + ret = wd_digest_set_key(sess->handle_digest, + xform->auth.key.data, + xform->auth.key.length); + if (ret) { + UADK_LOG(ERR, "uadk failed to alloc session!\n"); + wd_digest_free_sess(sess->handle_digest); + sess->handle_digest = 0; + ret = -EINVAL; + goto env_uninit; + } + } + + return 0; + +env_uninit: + wd_digest_env_uninit(); + priv->env_auth_init = false; + return ret; +} + static int uadk_crypto_sym_session_configure(struct rte_cryptodev *dev, struct rte_crypto_sym_xform *xform, @@ -442,6 +823,7 @@ uadk_crypto_sym_session_configure(struct rte_cryptodev *dev, struct rte_mempool *mp) { struct rte_crypto_sym_xform *cipher_xform = NULL; + struct rte_crypto_sym_xform *auth_xform = NULL; struct uadk_crypto_session *sess; int ret; @@ -457,6 +839,17 @@ uadk_crypto_sym_session_configure(struct rte_cryptodev *dev, case UADK_CHAIN_ONLY_CIPHER: cipher_xform = xform; break; + case UADK_CHAIN_ONLY_AUTH: + auth_xform = xform; + break; + case UADK_CHAIN_CIPHER_AUTH: + cipher_xform = xform; + auth_xform = xform->next; + break; + case UADK_CHAIN_AUTH_CIPHER: + auth_xform = xform; + cipher_xform = xform->next; + break; default: ret = -ENOTSUP; goto err; @@ -471,6 +864,15 @@ uadk_crypto_sym_session_configure(struct rte_cryptodev *dev, } } + if (auth_xform) { + ret = uadk_set_session_auth_parameters(dev, sess, auth_xform); + if (ret != 0) { + UADK_LOG(ERR, + "Invalid/unsupported auth parameters"); + goto err; + } + } + set_sym_session_private_data(session, dev->driver_id, sess); return 0; @@ -496,6 +898,11 @@ uadk_crypto_sym_session_clear(struct rte_cryptodev *dev, priv_sess->handle_cipher = 0; } + if (priv_sess->handle_digest) { + wd_digest_free_sess(priv_sess->handle_digest); + priv_sess->handle_digest = 0; + } + set_sym_session_private_data(sess, dev->driver_id, NULL); rte_mempool_put(rte_mempool_from_obj(priv_sess), priv_sess); } @@ -551,6 +958,49 @@ uadk_process_cipher_op(struct rte_crypto_op *op, op->status = RTE_COMP_OP_STATUS_ERROR; } +static void +uadk_process_auth_op(struct uadk_qp *qp, struct rte_crypto_op *op, + struct uadk_crypto_session *sess, + struct rte_mbuf *msrc, struct rte_mbuf *mdst) +{ + uint32_t srclen = op->sym->auth.data.length; + uint32_t off = op->sym->auth.data.offset; + uint8_t *dst = qp->temp_digest; + int ret; + + if (!sess) { + op->status = RTE_COMP_OP_STATUS_INVALID_ARGS; + return; + } + + sess->auth.req.in = rte_pktmbuf_mtod_offset(msrc, uint8_t *, off); + sess->auth.req.in_bytes = srclen; + sess->auth.req.out = dst; + + do { + ret = wd_do_digest_sync(sess->handle_digest, &sess->auth.req); + } while (ret == -WD_EBUSY); + + if (sess->auth.operation == RTE_CRYPTO_AUTH_OP_VERIFY) { + if (memcmp(dst, op->sym->auth.digest.data, + sess->auth.digest_length) != 0) { + op->status = RTE_CRYPTO_OP_STATUS_AUTH_FAILED; + } + } else { + uint8_t *auth_dst; + + auth_dst = op->sym->auth.digest.data; + if (auth_dst == NULL) + auth_dst = rte_pktmbuf_mtod_offset(mdst, uint8_t *, + op->sym->auth.data.offset + + op->sym->auth.data.length); + memcpy(auth_dst, dst, sess->auth.digest_length); + } + + if (ret) + op->status = RTE_COMP_OP_STATUS_ERROR; +} + static uint16_t uadk_crypto_enqueue_burst(void *queue_pair, struct rte_crypto_op **ops, uint16_t nb_ops) @@ -580,6 +1030,17 @@ uadk_crypto_enqueue_burst(void *queue_pair, struct rte_crypto_op **ops, case UADK_CHAIN_ONLY_CIPHER: uadk_process_cipher_op(op, sess, msrc, mdst); break; + case UADK_CHAIN_ONLY_AUTH: + uadk_process_auth_op(qp, op, sess, msrc, mdst); + break; + case UADK_CHAIN_CIPHER_AUTH: + uadk_process_cipher_op(op, sess, msrc, mdst); + uadk_process_auth_op(qp, op, sess, mdst, mdst); + break; + case UADK_CHAIN_AUTH_CIPHER: + uadk_process_auth_op(qp, op, sess, msrc, mdst); + uadk_process_cipher_op(op, sess, msrc, mdst); + break; default: op->status = RTE_CRYPTO_OP_STATUS_ERROR; break; From patchwork Fri Sep 23 02:40:23 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Zhangfei Gao X-Patchwork-Id: 608579 Delivered-To: patch@linaro.org Received: by 2002:a17:522:c983:b0:460:3032:e3c4 with SMTP id kr3csp37715pvb; Thu, 22 Sep 2022 19:41:17 -0700 (PDT) X-Google-Smtp-Source: AMsMyM4Sa/uCRfQH4HBgC0dj1wYJJuWqSlM12MbcWzEILxjxFgMVFadNCjQAyKtPK4BORimR+EjC X-Received: by 2002:a05:600c:282:b0:3b4:76c8:da3c with SMTP id 2-20020a05600c028200b003b476c8da3cmr4457119wmk.153.1663900877352; Thu, 22 Sep 2022 19:41:17 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1663900877; cv=none; d=google.com; s=arc-20160816; b=xjimOtI0AljGrv8SomR/D+i09BZCEY8Ai5ZeLlX15cnuI1zU2epuB6KSRmHaMKTSNj jQjATuq4q1/aNn/1IpRwJGgvjKUONzrJLK5iiiPKNi2RKvK1Z0ir3ACqkpsKBU1r+P2k Mldaeep8KdLJCF1Eigd22NHN0kI/BvX8hjuimaeUZOkYpLQDY0awApr0Adj5zyTXXuTX sG+h14rT66huFG2YiF2I6ovyZC/NrXLwzBgL6TIdhmuVsNI1JIqtBzsSnRRLjKNjdGxn hAiS9XRNa1nZdhghs0SAhoEKqPmC1issztwDpkSlOCe85N19hXIM2RvoFcphuRREEJ7E qcRA== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=errors-to:list-subscribe:list-help:list-post:list-archive :list-unsubscribe:list-id:precedence:content-transfer-encoding :mime-version:references:in-reply-to:message-id:date:subject:cc:to :from:dkim-signature; bh=na9S0XUANIdkKUlVww4MNFwq9DfE+aDS+tu0zk16z6w=; b=lEL5DLkNEDzvff1ZPOD6PSlPI5GIgiXcKBS3KS296OPcOTc8Z39PqPqtZ7nc2/Zwwy GN+zEoQWkLzvYKx/afgn3wAkOwI558P1OHJSdvK4cM8tOybyGQqUPtgOfliQKBt+hqV8 wjLzvpbvUw490QMez0jdZfxXzsgLfMfCKy2lyM8RnuHXu+TAUUMbWq7O2BAWijm13KMC YnDNHxLfJJHm5bDAW6Z2ho+95DdkRP9riqXNh4YNvswAYKmPZGNhgMwdnOfbe4w+eAM5 zn9SC0Tj04oU/70onDz+WcYZiQQ3EM3IjpTCYrxzJ7MeRIdU7sIxnvvIJbr8QPO93kE9 nx9g== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=ubhj7FlG; spf=pass (google.com: domain of dev-bounces@dpdk.org designates 217.70.189.124 as permitted sender) smtp.mailfrom=dev-bounces@dpdk.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org Return-Path: Received: from mails.dpdk.org (mails.dpdk.org. [217.70.189.124]) by mx.google.com with ESMTP id co9-20020a0560000a0900b0022a09bbf14dsi4978995wrb.154.2022.09.22.19.41.17; Thu, 22 Sep 2022 19:41:17 -0700 (PDT) Received-SPF: pass (google.com: domain of dev-bounces@dpdk.org designates 217.70.189.124 as permitted sender) client-ip=217.70.189.124; Authentication-Results: mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=ubhj7FlG; spf=pass (google.com: domain of dev-bounces@dpdk.org designates 217.70.189.124 as permitted sender) smtp.mailfrom=dev-bounces@dpdk.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org Received: from [217.70.189.124] (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id 16BF542905; Fri, 23 Sep 2022 04:41:13 +0200 (CEST) Received: from mail-pf1-f179.google.com (mail-pf1-f179.google.com [209.85.210.179]) by mails.dpdk.org (Postfix) with ESMTP id 89F1942B75 for ; Fri, 23 Sep 2022 04:41:10 +0200 (CEST) Received: by mail-pf1-f179.google.com with SMTP id e5so11117046pfl.2 for ; Thu, 22 Sep 2022 19:41:10 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date; bh=na9S0XUANIdkKUlVww4MNFwq9DfE+aDS+tu0zk16z6w=; b=ubhj7FlGbCo4EEEmqqKbTX0nn6iGTxfdQuSlGVQwt6efDloh3Wdxwy9S2sRN1fZ7wu U0EMDW9IgAiFUGnn0hWEet8tMklEO777Aidl7uPJvE3F/TXtScGZtSH6+vqk55Y8TCrm MbdGsBjCXlVvGc722FxY1V3uXJxy0aotNLoqVkFUzoYtSX2PxaNmJ4H3pk1RiEIqa2a2 uP2/mX8irT1R1P5xsvb7ymbveAw6/fYCdopidiGnhWAE+8oAuMiWG4rCCmQgcAvJzkHc lmTcZrpXY/DTkJUaLOo9qd9vFVsqzpAMODB73bhJaJLH01s/iIIjenog5TjKPnatO88Q 5y4Q== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date; bh=na9S0XUANIdkKUlVww4MNFwq9DfE+aDS+tu0zk16z6w=; b=FpJraarfrnoSfwinImI/EMkFdESj2g50j41qJS0iutWMEjKIz2g1YTmvxvS/AMhc25 jy/sF0JQyNzE+82PDStTibZoZc1XUtztMrThO3yejUyI1/SJ5jC9A4RweUHjELu1DHAJ ubTEQyMbaZq+LR+zEWBwhc/6JG3LZFRQF2GDmdKOXskuHyb/oXslqrNqHrGoXzRu0+U3 n3VGEUZEJ0q0wj07x091UDAmEuMN5AZS9RzDEWWOonp7NZ1fZGUQoToS6c5hh1n9YPys WZSoJsPcmTTjf9etCx1fXUmQHSJXfk0lCpghEs5aAvqzTAyK0AGrRKwoHz3F6J4JiWNz 9XAg== X-Gm-Message-State: ACrzQf2C/nVxU7L8MLE+RF1bZ1LrHTNxvV7ZHcXsSUh3oPKTXsPLUnX5 q1VAZXh7nTJk9AwvtJqH/D3e4g== X-Received: by 2002:a63:b957:0:b0:434:c30d:84b0 with SMTP id v23-20020a63b957000000b00434c30d84b0mr5771420pgo.293.1663900869796; Thu, 22 Sep 2022 19:41:09 -0700 (PDT) Received: from localhost.localdomain ([199.101.192.56]) by smtp.gmail.com with ESMTPSA id t5-20020a625f05000000b0053e8940c4absm5075011pfb.209.2022.09.22.19.41.04 (version=TLS1_2 cipher=ECDHE-ECDSA-AES128-GCM-SHA256 bits=128/128); Thu, 22 Sep 2022 19:41:09 -0700 (PDT) From: Zhangfei Gao To: Akhil Goyal , Declan Doherty , Fan Zhang , Ashish Gupta , Ray Kinsella Cc: dev@dpdk.org, acc@openeuler.org, Zhangfei Gao Subject: [PATCH v2 5/5] doc: Update doc for UADK crypto PMD Date: Fri, 23 Sep 2022 10:40:23 +0800 Message-Id: <20220923024023.15849-6-zhangfei.gao@linaro.org> X-Mailer: git-send-email 2.36.1 In-Reply-To: <20220923024023.15849-1-zhangfei.gao@linaro.org> References: <20220923024023.15849-1-zhangfei.gao@linaro.org> MIME-Version: 1.0 X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org Update doc for the new UADK crypto PMD, which relies on UADK library [1]. UADK is a framework for user applications to access hardware accelerators. UADK relies on IOMMU SVA (Shared Virtual Address) feature, which share the same page table between IOMMU and MMU. [1] https://github.com/Linaro/uadk Signed-off-by: Zhangfei Gao --- MAINTAINERS | 6 ++ doc/guides/cryptodevs/features/uadk.ini | 54 +++++++++++++++++ doc/guides/cryptodevs/index.rst | 1 + doc/guides/cryptodevs/uadk.rst | 77 +++++++++++++++++++++++++ 4 files changed, 138 insertions(+) create mode 100644 doc/guides/cryptodevs/features/uadk.ini create mode 100644 doc/guides/cryptodevs/uadk.rst diff --git a/MAINTAINERS b/MAINTAINERS index 32ffdd1a61..f485cec2ed 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -1061,6 +1061,12 @@ M: Fan Zhang F: drivers/crypto/scheduler/ F: doc/guides/cryptodevs/scheduler.rst +HiSilicon UADK crypto +M: Zhangfei Gao +F: drivers/crypto/uadk/ +F: doc/guides/cryptodevs/uadk.rst +F: doc/guides/cryptodevs/features/uadk.ini + Intel QuickAssist M: Fan Zhang F: drivers/crypto/qat/ diff --git a/doc/guides/cryptodevs/features/uadk.ini b/doc/guides/cryptodevs/features/uadk.ini new file mode 100644 index 0000000000..1418959bd4 --- /dev/null +++ b/doc/guides/cryptodevs/features/uadk.ini @@ -0,0 +1,54 @@ +; +; Supported features of the 'uadk' crypto driver. +; +; Refer to default.ini for the full list of available PMD features. +; +[Features] +Symmetric crypto = Y +HW Accelerated = Y + +; +; Supported crypto algorithms of the 'uadk' crypto driver. +; +[Cipher] +AES CBC (128) = Y +AES CBC (192) = Y +AES CBC (256) = Y +AES ECB (128) = Y +AES ECB (192) = Y +AES ECB (256) = Y +AES XTS (128) = Y +AES XTS (256) = Y +DES CBC = Y +; +; Supported authentication algorithms of the 'uadk' crypto driver. +; +[Auth] +MD5 = Y +MD5 HMAC = Y +SHA1 = Y +SHA1 HMAC = Y +SHA224 = Y +SHA224 HMAC = Y +SHA256 = Y +SHA256 HMAC = Y +SHA384 = Y +SHA384 HMAC = Y +SHA512 = Y +SHA512 HMAC = Y + +; +; Supported AEAD algorithms of the 'uadk' crypto driver. +; +[AEAD] + +; +; Supported Asymmetric algorithms of the 'uadk' crypto driver. +; +[Asymmetric] + +; +; Supported Operating systems of the 'uadk' crypto driver. +; +[OS] +Linux = Y diff --git a/doc/guides/cryptodevs/index.rst b/doc/guides/cryptodevs/index.rst index 39cca6dbde..cb4ce227e9 100644 --- a/doc/guides/cryptodevs/index.rst +++ b/doc/guides/cryptodevs/index.rst @@ -30,5 +30,6 @@ Crypto Device Drivers scheduler snow3g qat + uadk virtio zuc diff --git a/doc/guides/cryptodevs/uadk.rst b/doc/guides/cryptodevs/uadk.rst new file mode 100644 index 0000000000..15633be010 --- /dev/null +++ b/doc/guides/cryptodevs/uadk.rst @@ -0,0 +1,77 @@ +.. SPDX-License-Identifier: BSD-3-Clause + Copyright 2022-2023 Huawei Technologies Co.,Ltd. All rights reserved. + Copyright 2022-2023 Linaro ltd. + +UADK Crypto Poll Mode Driver +======================================================= + +UADK crypto PMD provides poll mode driver +All cryptographic operations are using UADK crypto API. +Hardware accelerators using UADK are supposed to be supported. + + +Features +-------- + +UADK crypto PMD has support for: + +Cipher algorithms: + +* ``RTE_CRYPTO_CIPHER_AES_ECB`` +* ``RTE_CRYPTO_CIPHER_AES_CBC`` +* ``RTE_CRYPTO_CIPHER_AES_XTS`` +* ``RTE_CRYPTO_CIPHER_DES_CBC`` + +Hash algorithms: + +* ``RTE_CRYPTO_AUTH_MD5`` +* ``RTE_CRYPTO_AUTH_MD5_HMAC`` +* ``RTE_CRYPTO_AUTH_SHA1`` +* ``RTE_CRYPTO_AUTH_SHA1_HMAC`` +* ``RTE_CRYPTO_AUTH_SHA224`` +* ``RTE_CRYPTO_AUTH_SHA224_HMAC`` +* ``RTE_CRYPTO_AUTH_SHA256`` +* ``RTE_CRYPTO_AUTH_SHA256_HMAC`` +* ``RTE_CRYPTO_AUTH_SHA384`` +* ``RTE_CRYPTO_AUTH_SHA384_HMAC`` +* ``RTE_CRYPTO_AUTH_SHA512`` +* ``RTE_CRYPTO_AUTH_SHA512_HMAC`` + +Test steps +----------- + + .. code-block:: console + + 1. Build + cd dpdk + mkdir build + meson build (--reconfigure) + cd build + ninja + sudo ninja install + + 2. Prepare + echo 1024 > /sys/devices/system/node/node0/hugepages/hugepages-2048kB/nr_hugepages + echo 1024 > /sys/devices/system/node/node1/hugepages/hugepages-2048kB/nr_hugepages + echo 1024 > /sys/devices/system/node/node2/hugepages/hugepages-2048kB/nr_hugepages + echo 1024 > /sys/devices/system/node/node3/hugepages/hugepages-2048kB/nr_hugepages + mkdir -p /mnt/huge_2mb + mount -t hugetlbfs none /mnt/huge_2mb -o pagesize=2MB + + 2 Test with crypto_uadk + sudo dpdk-test --vdev=crypto_uadk (--log-level=6) + RTE>>cryptodev_uadk_autotest + RTE>>quit + +Dependency +------------ + +UADK crypto PMD relies on UADK library [1] + +UADK is a framework for user applications to access hardware accelerators. +UADK relies on IOMMU SVA (Shared Virtual Address) feature, which share +the same page table between IOMMU and MMU. +As a result, user application can directly use virtual address for device dma, +which enhances the performance as well as easy usability. + +[1] https://github.com/Linaro/uadk