From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from NAM03-CO1-obe.outbound.protection.outlook.com (mail-co1nam03on0069.outbound.protection.outlook.com [104.47.40.69]) by dpdk.org (Postfix) with ESMTP id A0248343F for ; Thu, 3 May 2018 07:57:52 +0200 (CEST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=amdcloud.onmicrosoft.com; s=selector1-amd-com; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version; bh=kfLc4lTh399bYSEOfCN9170G3k6kYQuC1nyaUaMZjvo=; b=OYYT7g83w4mdLYDoBrFHUH/9Vv1m20PREv6SRgVk5JTY+UrIdfAoXGlizdKdHM8akmnXTAa8Mvk7w+xju78mUqRC7tn/0DW9FOZ/1QXYuOXTrL9lD/D9vsmoJon+9FxAcOh9Uo5m+Q4E151aQ+Y6aECbv4wo9BvGUTvlSb3XYaY= Authentication-Results: spf=none (sender IP is ) smtp.mailfrom=Ravi1.Kumar@amd.com; Received: from wallaby-smavila.amd.com (202.56.249.162) by BN6PR12MB1505.namprd12.prod.outlook.com (2603:10b6:405:11::18) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.715.18; Thu, 3 May 2018 05:57:48 +0000 From: Ravi Kumar To: dev@dpdk.org Cc: pablo.de.lara.guarch@intel.com, thomas@monjalon.net, hemant.agrawal@nxp.com Date: Thu, 3 May 2018 01:57:21 -0400 Message-Id: <1525327041-128382-2-git-send-email-Ravi1.kumar@amd.com> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1525327041-128382-1-git-send-email-Ravi1.kumar@amd.com> References: <1525327041-128382-1-git-send-email-Ravi1.kumar@amd.com> MIME-Version: 1.0 Content-Type: text/plain X-Originating-IP: [202.56.249.162] X-ClientProxiedBy: MAXPR0101CA0045.INDPRD01.PROD.OUTLOOK.COM (2603:1096:a00:d::31) To BN6PR12MB1505.namprd12.prod.outlook.com (2603:10b6:405:11::18) X-MS-PublicTrafficType: Email X-MS-Office365-Filtering-HT: Tenant X-Microsoft-Antispam: UriScan:; BCL:0; PCL:0; RULEID:(7020095)(4652020)(48565401081)(5600026)(4534165)(4627221)(201703031133081)(201702281549075)(2017052603328)(7153060)(7193020); SRVR:BN6PR12MB1505; X-Microsoft-Exchange-Diagnostics: 1; BN6PR12MB1505; 3:hD+CzDNriQa2QRE0woEf34B9yUZ+RPy8SqCAJF4qlfKkpq0H7A0RovMgXFIkYsFRljp1UFWok7FJZV5nhxsE2a6uuUq4uvFNHfp9jeucDqJZD/GCibmgJiUuML6VIEKke7imfT7PQ8AuqpOvfGopOSdS6ph42Fs2I1eN7u16/Il/SaxeIjnA6WpG5yoetJhKwyuhOUBaOwBF8evTiplZj58D8lrtoJ6TzQvtOI83Eoptj3R47Zg+SEqTMIsTOMNb; 25:sCinCsYbnAv+FF7vVtA73GrgqjxrW+8rocbdxaY83Yli3wQogIxuWD32nq7crVvRwG+XBbohZtdo7XdU2DRsYSL29yrQOfjhLSW55vado2LJsFbGM8JZBYEgege1SeUvqVDpSvxM6dgmUiSvSA55HDj0jkGmmZ2gk+t+yxtUaeq/OUQOWKRJHkxzYdiUSyJivPky1h9+FAFzbg8UTmwhSutWWUzg5XT0PNsX/9KIm2nOT2ONpLvBAkNTOfDUfYDW/qjsCSlhDiZ8XcwVP7fjY6JXZXW6v3rD5u5ShcNqq378qw4KVj+GRKcwI/KjHA82e2sooNm5J4/PPdGo2792BQ==; 31:jeHD9g0nuv615j/UNOXSkN+KTeUKOJ7SF1wEsZ3yMjXdIV8P0SpqgRE2G/BuBVNTrhMbmnN1VQcxSDiexmlKQbCDkZPRsjyvPIU7uHX9qjTDyMVytetDtO6H9JUjGZazEZ3kfRiZs8yAhUMaoi4TWjORAO3s2VbVjacXl4FCAIu3pscOw325YpZZqWUXg0bS+zTB/CQzk6Oz1M942uecwu1uyoUK8mqP4K0Cktspw6k= X-MS-TrafficTypeDiagnostic: BN6PR12MB1505: X-Microsoft-Exchange-Diagnostics: 1; BN6PR12MB1505; 20:CXWXuo1be7+QoTt2PrPeg+JNibuvtDHmDMO33BpqtnVb3XZQpYYp8J8QIteG057fThGqt+pZ1xFNNfSU0sIuG7qwkzeXLAeBFRrsy6fu3WKyLNVseu07OLhYPKUDMUi4iTsmYnSL2hVsNuViUPWC/3W643KDzxUBahazljUwFrrgoVONpWNtDvJeGPDLEx9dPhxN8BJjyP2J+gRz6nwqZdBq4Yd7WbdTkcei2SKHLTuqZ7cVF3I0YXsG1I8O/hcP48PJc6Zby8FFRF6E8EndazC71El+M71cbNzhJNvUD094bSn2zLeE/S962+hFSes/XuluVUyDhYc6KHE7L3yGmdtvKqTM8xRnrMctmuT3KaXXn65LjEF2Gx5U9GlAlNmRCXk2weu21KMfYJ5FEhSyonla+O55/Uuj+CofyUazFVynZ39ry4/ZAz2U2X515nOL+XlNZlSQ7iBIB2TNGDCuraaA/niWIpeiuK66QDqXxcIGXizg+7u2FFoRF95fRGsG; 4:YcE2LDDgAeCfXAt/JYHUMTvrEPimxxaq3zSAXpw4PjRCjIPxQ9cTR8xSKTu20Z3FYgUNNVDY7fzGBivq8QWwwt1gKy04r3qS91LJK47zt9pp19nhkhrhW0T8BWdfGSDtcOM0Vwh2vPK0R5/F2UA225rOI+D/UYIH+ast4GYx8gxMz7nul53GoSH/SE+lQv9TEUp7UMHma8OAyuNrTIYYDWrJuKKNSxEXMzzBSAJ/NwFaBmt60Mlgr+7qk0wfMEQvu85YsEFhsi13vBGSHP54Ro9wIiJX43yCy187L1EMb5CDwNoPUU7fXKD0zuV4JS7/ X-Microsoft-Antispam-PRVS: X-Exchange-Antispam-Report-Test: UriScan:(767451399110); X-Exchange-Antispam-Report-CFA-Test: BCL:0; PCL:0; RULEID:(8211001083)(6040522)(2401047)(5005006)(8121501046)(3231254)(944501410)(52105095)(3002001)(93006095)(93001095)(10201501046)(6055026)(6041310)(20161123560045)(20161123558120)(20161123564045)(20161123562045)(201703131423095)(201702281528075)(20161123555045)(201703061421075)(201703061406153)(6072148)(201708071742011); SRVR:BN6PR12MB1505; BCL:0; PCL:0; RULEID:; SRVR:BN6PR12MB1505; X-Forefront-PRVS: 066153096A X-Forefront-Antispam-Report: SFV:NSPM; SFS:(10009020)(39380400002)(346002)(39860400002)(396003)(376002)(366004)(189003)(199004)(575784001)(486006)(105586002)(106356001)(68736007)(48376002)(53416004)(50466002)(2906002)(305945005)(36756003)(51416003)(7696005)(50226002)(6486002)(2351001)(6666003)(52116002)(4326008)(53946003)(76176011)(53936002)(6916009)(8936002)(2361001)(8676002)(7736002)(3846002)(6116002)(97736004)(66066001)(26005)(5660300001)(81156014)(81166006)(47776003)(59450400001)(386003)(8656006)(956004)(86362001)(478600001)(72206003)(16586007)(11346002)(186003)(316002)(2616005)(446003)(16526019)(476003)(25786009); DIR:OUT; SFP:1101; SCL:1; SRVR:BN6PR12MB1505; H:wallaby-smavila.amd.com; FPR:; SPF:None; LANG:en; PTR:InfoNoRecords; MX:1; A:1; Received-SPF: None (protection.outlook.com: amd.com does not designate permitted sender hosts) X-Microsoft-Exchange-Diagnostics: =?us-ascii?Q?1; BN6PR12MB1505; 23:v2LVB0wG//8Nip95IwhxcGVM6EgIIeSNSLGS1W9Ip?= =?us-ascii?Q?mHhS1IlhJqxfYKPQc51B7a0fBqDk/99hYc5WdTZpkACma0uwHgULewr4Lemn?= =?us-ascii?Q?6l+wdY9XGMkHr5bYeJu++vJFvpC2NpdpB/07tjPo8aaXY0Zq0BGLgDLa9jvA?= =?us-ascii?Q?nb/gqSCbJ4TO55D4pvDnLPBrz/1ND49Rvw/O30O3iBoOY3QeXWxfdx8CHtaZ?= =?us-ascii?Q?DVWWzPvGy+21zoMyJZD68xJedXflHAEoGCpB7Ec1oQWx5GNBC9C1JKI7Ys8i?= =?us-ascii?Q?pAiH1tS+SixdgvpXmAJ7GfsIWybVtaoTxAPxlJH2M3JYSZWRmnMxA9Zx9iSk?= =?us-ascii?Q?zQfFq1Hs+yU8mqoNQySxRxH+sP9+yEHACs2Tz7XUfnPXSZWSmvkHQqhY839y?= =?us-ascii?Q?AwSr2lhbHFmNK56rUC7EOH9efxOZY3CAZSJa3/yXYVIZTK8FX6L3rYbx0CcL?= =?us-ascii?Q?vIQIWFHwQIPNY8BKV5Ri/staSq9UJ4aNvf4KaQAh5Lg2T5wWZDpsxCN2oFhy?= =?us-ascii?Q?iTBzMC5bcP1rS2Yih788EhG3CZ9KM+ypQeVmjsTbNs2X5f9Vr6wrLIGMENeA?= =?us-ascii?Q?MSQZN6dPtE3cv+cJSprRPtbIWbT8I3IB8y+kaZ/wPb4NCLbFMvUAYFYJCsBv?= =?us-ascii?Q?n3I6wqhmjg3ztqMhXaxPxB6TtRX1xrd8ZHS/vuEoBy6SeGbSmdoIsUUh6FcA?= =?us-ascii?Q?NN7as7Jyw5bbgdmgfFzn/M/LiHKYTyh6qIXGe5T78FLpED5eKQwpweVnT6Vu?= =?us-ascii?Q?p83W19YHOvoozTx3N6LkYSSLVXjU7ksZFdX1FAtBnyl8r8xwetfI/MBGAJmQ?= =?us-ascii?Q?T5V6Oqvm44QSlqgAsWULZJCBVOjrstmN00u1XL6Js6NxxCwn5lVIlkxxntM7?= =?us-ascii?Q?7myEeYfk3p216zu+q1bOZKYuSmmf1tK+l7gTXlaUwdEKVZy9MSdcA8YyVcHu?= =?us-ascii?Q?KeNDJln1BXpFf5G+yimz7oeQtDCamKjEIDGAtyhyb6SkRhGFdoKsLmI7NJy0?= =?us-ascii?Q?uGXrO37KVjeqZMwNFCLb1havFMwHLt6jOtEpPphcvd7AE7PPSaRgY7YYnUUG?= =?us-ascii?Q?VHuSL2oMvHUlwlukDQMUMX2NjfCNwUeOrv5mH6NZaVREYDQMG51LO//RQbnI?= =?us-ascii?Q?zr6x6hOK7bW6xbZaFGdknu8FImZNxo9gkRj/ND4GgkLnNHlLnhkKA1fYIcrg?= =?us-ascii?Q?nLqw7y9VLcFMtE0siRVqdKC6w9WtQ+X6LPS4oXcR1HuclXfu4pdThvEILqQs?= =?us-ascii?Q?Us7BpuBzHBlL7a/Kn1A8O1Td/VQ07jeTY9/sNhPHVC/hAQjIRi/a77VE71u1?= =?us-ascii?Q?jZycLfTYhuV3pofA49ulxzwsDmaAEaHwN1yqP3yb1ya?= X-Microsoft-Antispam-Message-Info: OULmzC4kdupl1/pA+2d5OQJskmUGbfsdykGizhHQJh0wb2DCJ+Mel8HDtvPPfKtHPEa8qNxoGOjuuUV3Ksk8NAfn0JkxguMlPKCL2IBFbSJ0r8WTIZldv1U0q6h8YJetrpa+k1sVmyb/hJDNB8V89ECkBLMayzTiSRL4S5v6sSFFdzWmmp5gvGq2rej316nO X-Microsoft-Exchange-Diagnostics: 1; BN6PR12MB1505; 6:wXXyjLzvrzzf2hAAXciEbc+dlU2iF9TWmEWdTHiXsAsKpn41zEpu3YGwByf/JVYa65moHdtyz6x30XfWmbP+GYcghJdO+2anjH6puyO2GmAB3dyLkdy319TtyWtn92aTLBhPmh1rabonEhk06N6M4M+eHB6SfeH4u/XW+2nanBGvbrqFXR8hLyvaczU0Iv3jXnGB05ltkcvyWbL67OZwkX4eQlNt4O3ZXjfn12385YbJzVx2rVdi+p9D0sFunmDeJJtPTHIvlWXDLWDYTwntR8lkshYrZxco3nGluAYUyIkMAF59FbB2SCkaaDsv8vEARkQtxMO61ZBW/HqxrrDhMZcO6JWzmqUk0JSKRPT6WDL6FC3vIiXtP2Gu63s45JAviwO4YDf0XFTTOkB0cxbw/VB+ihZjMATXKFsem6dVtkp89xzF1tDRjp41eWwNDJsMPMrXIoI4Ly47IsOwSjDiPg==; 5:K5vYY2ICf0fhDN/KTKZd+DnyS8+SrjniE2VEn0kpq21LwBYMpuykgSbMoM3ySMXFoPBQbA8irQMYUtkYcsYKG+ZsdedBaDSODpl6Rr/MRZnayQ0p3R+ls4bl7padLc/bpCMvG57PiooL45We2QpHoeRf4AWfiCiNLS1R4vzogbE=; 24:APHYyF+bTA1TH5K47794IXXKHG3xIIrbdOxe9dX9UsqPrhrWuxiVEHxxtF5+3FeK9/Xvx8agaUCRvEqu1F3NzQOcZY+CUnVDrkBVGE3GmzE= SpamDiagnosticOutput: 1:99 SpamDiagnosticMetadata: NSPM X-Microsoft-Exchange-Diagnostics: 1; BN6PR12MB1505; 7:PYb6f+mn/jz7EC+KpodVGJoqG96ID0tEsHiYB03aEvoa0nsfx1BAEr4HP0+rBMjsVwnoG0RjJ0BKOhTS7QiofZ3rxQX6nyA4RK0bEKznyO6QUMO76glwBFrqYquyCiRfCVmAmYynQaghFNbox8WkVhku+kAuCbyI+jOE7pL+hx9JXSlFdHXwUqb8nANQWSnQVuBVc/JLpSS5sHqW51EMW08KSnfSMyaYojT4mRXYACccpBMpk78EAEubbJDPljL2; 20:/5aTcuks6cnbPO7RMDvYQ/dSnEhDfWWmvGSpx8tX/WFr5eDiJ3dCXo03funJpLbIP+pUGEWFyTDxBuhkvSj5DHWmChPUKvUUOWy5DLo6IDmzT0pNi3S0jwARgIqvF/HQgHdee37xb6wPUD2/JvaTFAaI6RERdm0UoJgLrGmOlOFQNslkhU0+gsao5gXhxMy2l2ApC4oN3T8Cz/E9mZXP4bbNT27P1WXBUK1DfDaTBSQNAQLoAyWhalLZzeXpojk1 X-MS-Office365-Filtering-Correlation-Id: 8d170d6a-611c-4106-5244-08d5b0bacdb3 X-OriginatorOrg: amd.com X-MS-Exchange-CrossTenant-OriginalArrivalTime: 03 May 2018 05:57:48.6835 (UTC) X-MS-Exchange-CrossTenant-Network-Message-Id: 8d170d6a-611c-4106-5244-08d5b0bacdb3 X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: 3dd8961f-e488-4e60-8e11-a82d994e183d X-MS-Exchange-Transport-CrossTenantHeadersStamped: BN6PR12MB1505 Subject: [dpdk-dev] [PATCH 2/2] crypto/ccp: change to command line option from compile time 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: , X-List-Received-Date: Thu, 03 May 2018 05:57:53 -0000 CCP PMD supports authentication offload to either of CCP or CPU. The earlier version of patch provided this option as compile time. This patch changes this option from compile time to run time. User can pass "ccp_auth_opt=1" as an additional argument to vdev parameter to enable authentication operations on CPU. Signed-off-by: Ravi Kumar --- config/common_base | 1 - doc/guides/cryptodevs/ccp.rst | 13 +- drivers/crypto/ccp/ccp_crypto.c | 413 +++++++++++++++++------------------ drivers/crypto/ccp/ccp_crypto.h | 10 +- drivers/crypto/ccp/ccp_pmd_ops.c | 6 +- drivers/crypto/ccp/ccp_pmd_private.h | 6 +- drivers/crypto/ccp/rte_ccp_pmd.c | 226 +++++++++++++++++-- 7 files changed, 421 insertions(+), 254 deletions(-) diff --git a/config/common_base b/config/common_base index 802035b..ad24402 100644 --- a/config/common_base +++ b/config/common_base @@ -556,7 +556,6 @@ CONFIG_RTE_LIBRTE_PMD_NULL_CRYPTO=y # Compile PMD for AMD CCP crypto device # CONFIG_RTE_LIBRTE_PMD_CCP=y -CONFIG_RTE_LIBRTE_PMD_CCP_CPU_AUTH=n # # Compile PMD for Marvell Crypto device diff --git a/doc/guides/cryptodevs/ccp.rst b/doc/guides/cryptodevs/ccp.rst index 1fcd462..cdb9374 100644 --- a/doc/guides/cryptodevs/ccp.rst +++ b/doc/guides/cryptodevs/ccp.rst @@ -56,14 +56,11 @@ AEAD algorithms: Installation ------------ -To compile CCP PMD, it has to be enabled in the config/common_base file. +To compile CCP PMD, ensure that following is enabled in your DPDK configuration file. * ``CONFIG_RTE_LIBRTE_PMD_CCP=y`` -The CCP PMD also supports computing authentication over CPU with cipher offloaded -to CCP. To enable this feature, enable following in the configuration. -* ``CONFIG_RTE_LIBRTE_PMD_CCP_CPU_AUTH=y`` - -This code was verified on Ubuntu 16.04. +The CCP PMD also supports computing authentication over CPU with cipher offloaded to CCP. +To enable this feature, pass an additional argument as ccp_auth_opt=1 to --vdev parameters. Initialization -------------- @@ -98,5 +95,5 @@ To verify real traffic l2fwd-crypto example can be used with following command: Limitations ----------- -* Chained mbufs are not supported -* MD5_HMAC is supported only if ``CONFIG_RTE_LIBRTE_PMD_CCP_CPU_AUTH=y`` is enabled in configuration +* Chained mbufs are not supported. +* MD5_HMAC is supported only for CPU based authentication. diff --git a/drivers/crypto/ccp/ccp_crypto.c b/drivers/crypto/ccp/ccp_crypto.c index a0809e4..3ce0f39 100644 --- a/drivers/crypto/ccp/ccp_crypto.c +++ b/drivers/crypto/ccp/ccp_crypto.c @@ -27,11 +27,9 @@ #include "ccp_pci.h" #include "ccp_pmd_private.h" -#ifdef RTE_LIBRTE_PMD_CCP_CPU_AUTH #include #include #include -#endif /* SHA initial context values */ static uint32_t ccp_sha1_init[SHA_COMMON_DIGEST_SIZE / sizeof(uint32_t)] = { @@ -766,17 +764,19 @@ ccp_configure_session_auth(struct ccp_session *sess, else sess->auth.op = CCP_AUTH_OP_VERIFY; switch (auth_xform->algo) { -#ifdef RTE_LIBRTE_PMD_CCP_CPU_AUTH case RTE_CRYPTO_AUTH_MD5_HMAC: - sess->auth.algo = CCP_AUTH_ALGO_MD5_HMAC; - sess->auth.offset = (CCP_SB_BYTES << 1) - MD5_DIGEST_SIZE; - sess->auth.key_length = auth_xform->key.length; - sess->auth.block_size = MD5_BLOCK_SIZE; - memset(sess->auth.key, 0, sess->auth.block_size); - rte_memcpy(sess->auth.key, auth_xform->key.data, - auth_xform->key.length); + if (sess->auth_opt) { + sess->auth.algo = CCP_AUTH_ALGO_MD5_HMAC; + sess->auth.offset = ((CCP_SB_BYTES << 1) - + MD5_DIGEST_SIZE); + sess->auth.key_length = auth_xform->key.length; + sess->auth.block_size = MD5_BLOCK_SIZE; + memset(sess->auth.key, 0, sess->auth.block_size); + rte_memcpy(sess->auth.key, auth_xform->key.data, + auth_xform->key.length); + } else + return -1; /* HMAC MD5 not supported on CCP */ break; -#endif case RTE_CRYPTO_AUTH_SHA1: sess->auth.engine = CCP_ENGINE_SHA; sess->auth.algo = CCP_AUTH_ALGO_SHA1; @@ -786,33 +786,34 @@ ccp_configure_session_auth(struct ccp_session *sess, sess->auth.offset = CCP_SB_BYTES - SHA1_DIGEST_SIZE; break; case RTE_CRYPTO_AUTH_SHA1_HMAC: -#ifdef RTE_LIBRTE_PMD_CCP_CPU_AUTH - if (auth_xform->key.length > SHA1_BLOCK_SIZE) - return -1; - sess->auth.algo = CCP_AUTH_ALGO_SHA1_HMAC; - sess->auth.offset = CCP_SB_BYTES - SHA1_DIGEST_SIZE; - sess->auth.block_size = SHA1_BLOCK_SIZE; - sess->auth.key_length = auth_xform->key.length; - memset(sess->auth.key, 0, sess->auth.block_size); - rte_memcpy(sess->auth.key, auth_xform->key.data, - auth_xform->key.length); -#else - if (auth_xform->key.length > SHA1_BLOCK_SIZE) - return -1; - sess->auth.engine = CCP_ENGINE_SHA; - sess->auth.algo = CCP_AUTH_ALGO_SHA1_HMAC; - sess->auth.ut.sha_type = CCP_SHA_TYPE_1; - sess->auth.ctx_len = CCP_SB_BYTES; - sess->auth.offset = CCP_SB_BYTES - SHA1_DIGEST_SIZE; - sess->auth.block_size = SHA1_BLOCK_SIZE; - sess->auth.key_length = auth_xform->key.length; - memset(sess->auth.key, 0, sess->auth.block_size); - memset(sess->auth.pre_compute, 0, sess->auth.ctx_len << 1); - rte_memcpy(sess->auth.key, auth_xform->key.data, - auth_xform->key.length); - if (generate_partial_hash(sess)) - return -1; -#endif + if (sess->auth_opt) { + if (auth_xform->key.length > SHA1_BLOCK_SIZE) + return -1; + sess->auth.algo = CCP_AUTH_ALGO_SHA1_HMAC; + sess->auth.offset = CCP_SB_BYTES - SHA1_DIGEST_SIZE; + sess->auth.block_size = SHA1_BLOCK_SIZE; + sess->auth.key_length = auth_xform->key.length; + memset(sess->auth.key, 0, sess->auth.block_size); + rte_memcpy(sess->auth.key, auth_xform->key.data, + auth_xform->key.length); + } else { + if (auth_xform->key.length > SHA1_BLOCK_SIZE) + return -1; + sess->auth.engine = CCP_ENGINE_SHA; + sess->auth.algo = CCP_AUTH_ALGO_SHA1_HMAC; + sess->auth.ut.sha_type = CCP_SHA_TYPE_1; + sess->auth.ctx_len = CCP_SB_BYTES; + sess->auth.offset = CCP_SB_BYTES - SHA1_DIGEST_SIZE; + sess->auth.block_size = SHA1_BLOCK_SIZE; + sess->auth.key_length = auth_xform->key.length; + memset(sess->auth.key, 0, sess->auth.block_size); + memset(sess->auth.pre_compute, 0, + sess->auth.ctx_len << 1); + rte_memcpy(sess->auth.key, auth_xform->key.data, + auth_xform->key.length); + if (generate_partial_hash(sess)) + return -1; + } break; case RTE_CRYPTO_AUTH_SHA224: sess->auth.algo = CCP_AUTH_ALGO_SHA224; @@ -823,33 +824,34 @@ ccp_configure_session_auth(struct ccp_session *sess, sess->auth.offset = CCP_SB_BYTES - SHA224_DIGEST_SIZE; break; case RTE_CRYPTO_AUTH_SHA224_HMAC: -#ifdef RTE_LIBRTE_PMD_CCP_CPU_AUTH - if (auth_xform->key.length > SHA224_BLOCK_SIZE) - return -1; - sess->auth.algo = CCP_AUTH_ALGO_SHA224_HMAC; - sess->auth.offset = CCP_SB_BYTES - SHA224_DIGEST_SIZE; - sess->auth.block_size = SHA224_BLOCK_SIZE; - sess->auth.key_length = auth_xform->key.length; - memset(sess->auth.key, 0, sess->auth.block_size); - rte_memcpy(sess->auth.key, auth_xform->key.data, - auth_xform->key.length); -#else - if (auth_xform->key.length > SHA224_BLOCK_SIZE) - return -1; - sess->auth.algo = CCP_AUTH_ALGO_SHA224_HMAC; - sess->auth.engine = CCP_ENGINE_SHA; - sess->auth.ut.sha_type = CCP_SHA_TYPE_224; - sess->auth.ctx_len = CCP_SB_BYTES; - sess->auth.offset = CCP_SB_BYTES - SHA224_DIGEST_SIZE; - sess->auth.block_size = SHA224_BLOCK_SIZE; - sess->auth.key_length = auth_xform->key.length; - memset(sess->auth.key, 0, sess->auth.block_size); - memset(sess->auth.pre_compute, 0, sess->auth.ctx_len << 1); - rte_memcpy(sess->auth.key, auth_xform->key.data, - auth_xform->key.length); - if (generate_partial_hash(sess)) - return -1; -#endif + if (sess->auth_opt) { + if (auth_xform->key.length > SHA224_BLOCK_SIZE) + return -1; + sess->auth.algo = CCP_AUTH_ALGO_SHA224_HMAC; + sess->auth.offset = CCP_SB_BYTES - SHA224_DIGEST_SIZE; + sess->auth.block_size = SHA224_BLOCK_SIZE; + sess->auth.key_length = auth_xform->key.length; + memset(sess->auth.key, 0, sess->auth.block_size); + rte_memcpy(sess->auth.key, auth_xform->key.data, + auth_xform->key.length); + } else { + if (auth_xform->key.length > SHA224_BLOCK_SIZE) + return -1; + sess->auth.algo = CCP_AUTH_ALGO_SHA224_HMAC; + sess->auth.engine = CCP_ENGINE_SHA; + sess->auth.ut.sha_type = CCP_SHA_TYPE_224; + sess->auth.ctx_len = CCP_SB_BYTES; + sess->auth.offset = CCP_SB_BYTES - SHA224_DIGEST_SIZE; + sess->auth.block_size = SHA224_BLOCK_SIZE; + sess->auth.key_length = auth_xform->key.length; + memset(sess->auth.key, 0, sess->auth.block_size); + memset(sess->auth.pre_compute, 0, + sess->auth.ctx_len << 1); + rte_memcpy(sess->auth.key, auth_xform->key.data, + auth_xform->key.length); + if (generate_partial_hash(sess)) + return -1; + } break; case RTE_CRYPTO_AUTH_SHA3_224: sess->auth.algo = CCP_AUTH_ALGO_SHA3_224; @@ -884,33 +886,34 @@ ccp_configure_session_auth(struct ccp_session *sess, sess->auth.offset = CCP_SB_BYTES - SHA256_DIGEST_SIZE; break; case RTE_CRYPTO_AUTH_SHA256_HMAC: -#ifdef RTE_LIBRTE_PMD_CCP_CPU_AUTH - if (auth_xform->key.length > SHA256_BLOCK_SIZE) - return -1; - sess->auth.algo = CCP_AUTH_ALGO_SHA256_HMAC; - sess->auth.offset = CCP_SB_BYTES - SHA256_DIGEST_SIZE; - sess->auth.block_size = SHA256_BLOCK_SIZE; - sess->auth.key_length = auth_xform->key.length; - memset(sess->auth.key, 0, sess->auth.block_size); - rte_memcpy(sess->auth.key, auth_xform->key.data, - auth_xform->key.length); -#else - if (auth_xform->key.length > SHA256_BLOCK_SIZE) - return -1; - sess->auth.algo = CCP_AUTH_ALGO_SHA256_HMAC; - sess->auth.engine = CCP_ENGINE_SHA; - sess->auth.ut.sha_type = CCP_SHA_TYPE_256; - sess->auth.ctx_len = CCP_SB_BYTES; - sess->auth.offset = CCP_SB_BYTES - SHA256_DIGEST_SIZE; - sess->auth.block_size = SHA256_BLOCK_SIZE; - sess->auth.key_length = auth_xform->key.length; - memset(sess->auth.key, 0, sess->auth.block_size); - memset(sess->auth.pre_compute, 0, sess->auth.ctx_len << 1); - rte_memcpy(sess->auth.key, auth_xform->key.data, - auth_xform->key.length); - if (generate_partial_hash(sess)) - return -1; -#endif + if (sess->auth_opt) { + if (auth_xform->key.length > SHA256_BLOCK_SIZE) + return -1; + sess->auth.algo = CCP_AUTH_ALGO_SHA256_HMAC; + sess->auth.offset = CCP_SB_BYTES - SHA256_DIGEST_SIZE; + sess->auth.block_size = SHA256_BLOCK_SIZE; + sess->auth.key_length = auth_xform->key.length; + memset(sess->auth.key, 0, sess->auth.block_size); + rte_memcpy(sess->auth.key, auth_xform->key.data, + auth_xform->key.length); + } else { + if (auth_xform->key.length > SHA256_BLOCK_SIZE) + return -1; + sess->auth.algo = CCP_AUTH_ALGO_SHA256_HMAC; + sess->auth.engine = CCP_ENGINE_SHA; + sess->auth.ut.sha_type = CCP_SHA_TYPE_256; + sess->auth.ctx_len = CCP_SB_BYTES; + sess->auth.offset = CCP_SB_BYTES - SHA256_DIGEST_SIZE; + sess->auth.block_size = SHA256_BLOCK_SIZE; + sess->auth.key_length = auth_xform->key.length; + memset(sess->auth.key, 0, sess->auth.block_size); + memset(sess->auth.pre_compute, 0, + sess->auth.ctx_len << 1); + rte_memcpy(sess->auth.key, auth_xform->key.data, + auth_xform->key.length); + if (generate_partial_hash(sess)) + return -1; + } break; case RTE_CRYPTO_AUTH_SHA3_256: sess->auth.algo = CCP_AUTH_ALGO_SHA3_256; @@ -945,33 +948,36 @@ ccp_configure_session_auth(struct ccp_session *sess, sess->auth.offset = (CCP_SB_BYTES << 1) - SHA384_DIGEST_SIZE; break; case RTE_CRYPTO_AUTH_SHA384_HMAC: -#ifdef RTE_LIBRTE_PMD_CCP_CPU_AUTH - if (auth_xform->key.length > SHA384_BLOCK_SIZE) - return -1; - sess->auth.algo = CCP_AUTH_ALGO_SHA384_HMAC; - sess->auth.offset = (CCP_SB_BYTES << 1) - SHA384_DIGEST_SIZE; - sess->auth.block_size = SHA384_BLOCK_SIZE; - sess->auth.key_length = auth_xform->key.length; - memset(sess->auth.key, 0, sess->auth.block_size); - rte_memcpy(sess->auth.key, auth_xform->key.data, - auth_xform->key.length); -#else - if (auth_xform->key.length > SHA384_BLOCK_SIZE) - return -1; - sess->auth.algo = CCP_AUTH_ALGO_SHA384_HMAC; - sess->auth.engine = CCP_ENGINE_SHA; - sess->auth.ut.sha_type = CCP_SHA_TYPE_384; - sess->auth.ctx_len = CCP_SB_BYTES << 1; - sess->auth.offset = (CCP_SB_BYTES << 1) - SHA384_DIGEST_SIZE; - sess->auth.block_size = SHA384_BLOCK_SIZE; - sess->auth.key_length = auth_xform->key.length; - memset(sess->auth.key, 0, sess->auth.block_size); - memset(sess->auth.pre_compute, 0, sess->auth.ctx_len << 1); - rte_memcpy(sess->auth.key, auth_xform->key.data, - auth_xform->key.length); - if (generate_partial_hash(sess)) - return -1; -#endif + if (sess->auth_opt) { + if (auth_xform->key.length > SHA384_BLOCK_SIZE) + return -1; + sess->auth.algo = CCP_AUTH_ALGO_SHA384_HMAC; + sess->auth.offset = ((CCP_SB_BYTES << 1) - + SHA384_DIGEST_SIZE); + sess->auth.block_size = SHA384_BLOCK_SIZE; + sess->auth.key_length = auth_xform->key.length; + memset(sess->auth.key, 0, sess->auth.block_size); + rte_memcpy(sess->auth.key, auth_xform->key.data, + auth_xform->key.length); + } else { + if (auth_xform->key.length > SHA384_BLOCK_SIZE) + return -1; + sess->auth.algo = CCP_AUTH_ALGO_SHA384_HMAC; + sess->auth.engine = CCP_ENGINE_SHA; + sess->auth.ut.sha_type = CCP_SHA_TYPE_384; + sess->auth.ctx_len = CCP_SB_BYTES << 1; + sess->auth.offset = ((CCP_SB_BYTES << 1) - + SHA384_DIGEST_SIZE); + sess->auth.block_size = SHA384_BLOCK_SIZE; + sess->auth.key_length = auth_xform->key.length; + memset(sess->auth.key, 0, sess->auth.block_size); + memset(sess->auth.pre_compute, 0, + sess->auth.ctx_len << 1); + rte_memcpy(sess->auth.key, auth_xform->key.data, + auth_xform->key.length); + if (generate_partial_hash(sess)) + return -1; + } break; case RTE_CRYPTO_AUTH_SHA3_384: sess->auth.algo = CCP_AUTH_ALGO_SHA3_384; @@ -1006,33 +1012,36 @@ ccp_configure_session_auth(struct ccp_session *sess, sess->auth.offset = (CCP_SB_BYTES << 1) - SHA512_DIGEST_SIZE; break; case RTE_CRYPTO_AUTH_SHA512_HMAC: -#ifdef RTE_LIBRTE_PMD_CCP_CPU_AUTH - if (auth_xform->key.length > SHA512_BLOCK_SIZE) - return -1; - sess->auth.algo = CCP_AUTH_ALGO_SHA512_HMAC; - sess->auth.offset = (CCP_SB_BYTES << 1) - SHA512_DIGEST_SIZE; - sess->auth.block_size = SHA512_BLOCK_SIZE; - sess->auth.key_length = auth_xform->key.length; - memset(sess->auth.key, 0, sess->auth.block_size); - rte_memcpy(sess->auth.key, auth_xform->key.data, - auth_xform->key.length); -#else - if (auth_xform->key.length > SHA512_BLOCK_SIZE) - return -1; - sess->auth.algo = CCP_AUTH_ALGO_SHA512_HMAC; - sess->auth.engine = CCP_ENGINE_SHA; - sess->auth.ut.sha_type = CCP_SHA_TYPE_512; - sess->auth.ctx_len = CCP_SB_BYTES << 1; - sess->auth.offset = (CCP_SB_BYTES << 1) - SHA512_DIGEST_SIZE; - sess->auth.block_size = SHA512_BLOCK_SIZE; - sess->auth.key_length = auth_xform->key.length; - memset(sess->auth.key, 0, sess->auth.block_size); - memset(sess->auth.pre_compute, 0, sess->auth.ctx_len << 1); - rte_memcpy(sess->auth.key, auth_xform->key.data, - auth_xform->key.length); - if (generate_partial_hash(sess)) - return -1; -#endif + if (sess->auth_opt) { + if (auth_xform->key.length > SHA512_BLOCK_SIZE) + return -1; + sess->auth.algo = CCP_AUTH_ALGO_SHA512_HMAC; + sess->auth.offset = ((CCP_SB_BYTES << 1) - + SHA512_DIGEST_SIZE); + sess->auth.block_size = SHA512_BLOCK_SIZE; + sess->auth.key_length = auth_xform->key.length; + memset(sess->auth.key, 0, sess->auth.block_size); + rte_memcpy(sess->auth.key, auth_xform->key.data, + auth_xform->key.length); + } else { + if (auth_xform->key.length > SHA512_BLOCK_SIZE) + return -1; + sess->auth.algo = CCP_AUTH_ALGO_SHA512_HMAC; + sess->auth.engine = CCP_ENGINE_SHA; + sess->auth.ut.sha_type = CCP_SHA_TYPE_512; + sess->auth.ctx_len = CCP_SB_BYTES << 1; + sess->auth.offset = ((CCP_SB_BYTES << 1) - + SHA512_DIGEST_SIZE); + sess->auth.block_size = SHA512_BLOCK_SIZE; + sess->auth.key_length = auth_xform->key.length; + memset(sess->auth.key, 0, sess->auth.block_size); + memset(sess->auth.pre_compute, 0, + sess->auth.ctx_len << 1); + rte_memcpy(sess->auth.key, auth_xform->key.data, + auth_xform->key.length); + if (generate_partial_hash(sess)) + return -1; + } break; case RTE_CRYPTO_AUTH_SHA3_512: sess->auth.algo = CCP_AUTH_ALGO_SHA3_512; @@ -1157,13 +1166,15 @@ ccp_configure_session_aead(struct ccp_session *sess, int ccp_set_session_parameters(struct ccp_session *sess, - const struct rte_crypto_sym_xform *xform) + const struct rte_crypto_sym_xform *xform, + struct ccp_private *internals) { const struct rte_crypto_sym_xform *cipher_xform = NULL; const struct rte_crypto_sym_xform *auth_xform = NULL; const struct rte_crypto_sym_xform *aead_xform = NULL; int ret = 0; + sess->auth_opt = internals->auth_opt; sess->cmd_id = ccp_get_cmd_id(xform); switch (sess->cmd_id) { @@ -1259,22 +1270,16 @@ ccp_auth_slot(struct ccp_session *session) count = 3; /**< op + lsb passthrough cpy to/from*/ break; -#ifdef RTE_LIBRTE_PMD_CCP_CPU_AUTH case CCP_AUTH_ALGO_MD5_HMAC: break; -#endif case CCP_AUTH_ALGO_SHA1_HMAC: case CCP_AUTH_ALGO_SHA224_HMAC: case CCP_AUTH_ALGO_SHA256_HMAC: -#ifndef RTE_LIBRTE_PMD_CCP_CPU_AUTH - count = 6; -#endif + if (session->auth_opt == 0) + count = 6; break; case CCP_AUTH_ALGO_SHA384_HMAC: case CCP_AUTH_ALGO_SHA512_HMAC: -#ifndef RTE_LIBRTE_PMD_CCP_CPU_AUTH - count = 7; -#endif /** * 1. Load PHash1 = H(k ^ ipad); to LSB * 2. generate IHash = H(hash on meassage with PHash1 @@ -1285,6 +1290,8 @@ ccp_auth_slot(struct ccp_session *session) * as init value); * 6. Retrieve HMAC output from LSB to host memory */ + if (session->auth_opt == 0) + count = 7; break; case CCP_AUTH_ALGO_SHA3_224: case CCP_AUTH_ALGO_SHA3_256: @@ -1381,7 +1388,6 @@ ccp_compute_slot_count(struct ccp_session *session) return count; } -#ifdef RTE_LIBRTE_PMD_CCP_CPU_AUTH static uint8_t algo_select(int sessalgo, const EVP_MD **algo) @@ -1495,7 +1501,6 @@ static int cpu_crypto_auth(struct ccp_qp *qp, EVP_PKEY_free(pkey); return 0; } -#endif static void ccp_perform_passthru(struct ccp_passthru *pst, @@ -2592,26 +2597,24 @@ ccp_crypto_auth(struct rte_crypto_op *op, result = ccp_perform_sha(op, cmd_q); b_info->desccnt += 3; break; -#ifdef RTE_LIBRTE_PMD_CCP_CPU_AUTH case CCP_AUTH_ALGO_MD5_HMAC: + if (session->auth_opt == 0) + result = -1; break; -#endif case CCP_AUTH_ALGO_SHA1_HMAC: case CCP_AUTH_ALGO_SHA224_HMAC: case CCP_AUTH_ALGO_SHA256_HMAC: -#ifdef RTE_LIBRTE_PMD_CCP_CPU_AUTH - break; -#endif - result = ccp_perform_hmac(op, cmd_q); - b_info->desccnt += 6; + if (session->auth_opt == 0) { + result = ccp_perform_hmac(op, cmd_q); + b_info->desccnt += 6; + } break; case CCP_AUTH_ALGO_SHA384_HMAC: case CCP_AUTH_ALGO_SHA512_HMAC: -#ifdef RTE_LIBRTE_PMD_CCP_CPU_AUTH - break; -#endif - result = ccp_perform_hmac(op, cmd_q); - b_info->desccnt += 7; + if (session->auth_opt == 0) { + result = ccp_perform_hmac(op, cmd_q); + b_info->desccnt += 7; + } break; case CCP_AUTH_ALGO_SHA3_224: case CCP_AUTH_ALGO_SHA3_256: @@ -2682,22 +2685,20 @@ process_ops_to_enqueue(struct ccp_qp *qp, int i, result = 0; struct ccp_batch_info *b_info; struct ccp_session *session; -#ifdef RTE_LIBRTE_PMD_CCP_CPU_AUTH EVP_MD_CTX *auth_ctx = NULL; -#endif if (rte_mempool_get(qp->batch_mp, (void **)&b_info)) { CCP_LOG_ERR("batch info allocation failed"); return 0; } -#ifdef RTE_LIBRTE_PMD_CCP_CPU_AUTH + auth_ctx = EVP_MD_CTX_create(); if (unlikely(!auth_ctx)) { CCP_LOG_ERR("Unable to create auth ctx"); return 0; } b_info->auth_ctr = 0; -#endif + /* populate batch info necessary for dequeue */ b_info->op_idx = 0; b_info->lsb_buf_idx = 0; @@ -2718,12 +2719,12 @@ process_ops_to_enqueue(struct ccp_qp *qp, result = ccp_crypto_cipher(op[i], cmd_q, b_info); break; case CCP_CMD_AUTH: - result = ccp_crypto_auth(op[i], cmd_q, b_info); -#ifdef RTE_LIBRTE_PMD_CCP_CPU_AUTH - b_info->auth_ctr++; - result = cpu_crypto_auth(qp, op[i], - session, auth_ctx); -#endif + if (session->auth_opt) { + b_info->auth_ctr++; + result = cpu_crypto_auth(qp, op[i], + session, auth_ctx); + } else + result = ccp_crypto_auth(op[i], cmd_q, b_info); break; case CCP_CMD_CIPHER_HASH: result = ccp_crypto_cipher(op[i], cmd_q, b_info); @@ -2732,13 +2733,15 @@ process_ops_to_enqueue(struct ccp_qp *qp, result = ccp_crypto_auth(op[i], cmd_q, b_info); break; case CCP_CMD_HASH_CIPHER: - result = ccp_crypto_auth(op[i], cmd_q, b_info); -#ifdef RTE_LIBRTE_PMD_CCP_CPU_AUTH - result = cpu_crypto_auth(qp, op[i], - session, auth_ctx); - if (op[i]->status != RTE_CRYPTO_OP_STATUS_SUCCESS) - continue; -#endif + if (session->auth_opt) { + result = cpu_crypto_auth(qp, op[i], + session, auth_ctx); + if (op[i]->status != + RTE_CRYPTO_OP_STATUS_SUCCESS) + continue; + } else + result = ccp_crypto_auth(op[i], cmd_q, b_info); + if (result) break; result = ccp_crypto_cipher(op[i], cmd_q, b_info); @@ -2772,9 +2775,7 @@ process_ops_to_enqueue(struct ccp_qp *qp, rte_ring_enqueue(qp->processed_pkts, (void *)b_info); -#ifdef RTE_LIBRTE_PMD_CCP_CPU_AUTH EVP_MD_CTX_destroy(auth_ctx); -#endif return i; } @@ -2843,11 +2844,7 @@ static inline void ccp_auth_dq_prepare(struct rte_crypto_op *op) } static int -#ifdef RTE_LIBRTE_PMD_CCP_CPU_AUTH ccp_prepare_ops(struct ccp_qp *qp, -#else -ccp_prepare_ops(struct ccp_qp *qp __rte_unused, -#endif struct rte_crypto_op **op_d, struct ccp_batch_info *b_info, uint16_t nb_ops) @@ -2855,7 +2852,6 @@ ccp_prepare_ops(struct ccp_qp *qp __rte_unused, int i, min_ops; struct ccp_session *session; -#ifdef RTE_LIBRTE_PMD_CCP_CPU_AUTH EVP_MD_CTX *auth_ctx = NULL; auth_ctx = EVP_MD_CTX_create(); @@ -2863,7 +2859,6 @@ ccp_prepare_ops(struct ccp_qp *qp __rte_unused, CCP_LOG_ERR("Unable to create auth ctx"); return 0; } -#endif min_ops = RTE_MIN(nb_ops, b_info->opcnt); for (i = 0; i < min_ops; i++) { @@ -2876,24 +2871,21 @@ ccp_prepare_ops(struct ccp_qp *qp __rte_unused, op_d[i]->status = RTE_CRYPTO_OP_STATUS_SUCCESS; break; case CCP_CMD_AUTH: -#ifndef RTE_LIBRTE_PMD_CCP_CPU_AUTH - ccp_auth_dq_prepare(op_d[i]); -#endif + if (session->auth_opt == 0) + ccp_auth_dq_prepare(op_d[i]); break; case CCP_CMD_CIPHER_HASH: -#ifdef RTE_LIBRTE_PMD_CCP_CPU_AUTH - cpu_crypto_auth(qp, op_d[i], - session, auth_ctx); -#else - ccp_auth_dq_prepare(op_d[i]); -#endif + if (session->auth_opt) + cpu_crypto_auth(qp, op_d[i], + session, auth_ctx); + else + ccp_auth_dq_prepare(op_d[i]); break; case CCP_CMD_HASH_CIPHER: -#ifdef RTE_LIBRTE_PMD_CCP_CPU_AUTH - op_d[i]->status = RTE_CRYPTO_OP_STATUS_SUCCESS; -#else - ccp_auth_dq_prepare(op_d[i]); -#endif + if (session->auth_opt) + op_d[i]->status = RTE_CRYPTO_OP_STATUS_SUCCESS; + else + ccp_auth_dq_prepare(op_d[i]); break; case CCP_CMD_COMBINED: ccp_auth_dq_prepare(op_d[i]); @@ -2903,9 +2895,7 @@ ccp_prepare_ops(struct ccp_qp *qp __rte_unused, } } -#ifdef RTE_LIBRTE_PMD_CCP_CPU_AUTH EVP_MD_CTX_destroy(auth_ctx); -#endif b_info->opcnt -= min_ops; return min_ops; } @@ -2925,10 +2915,9 @@ process_ops_to_dequeue(struct ccp_qp *qp, } else if (rte_ring_dequeue(qp->processed_pkts, (void **)&b_info)) return 0; -#ifdef RTE_LIBRTE_PMD_CCP_CPU_AUTH + if (b_info->auth_ctr == b_info->opcnt) goto success; -#endif cur_head_offset = CCP_READ_REG(b_info->cmd_q->reg_base, CMD_Q_HEAD_LO_BASE); diff --git a/drivers/crypto/ccp/ccp_crypto.h b/drivers/crypto/ccp/ccp_crypto.h index dd89ad9..882b398 100644 --- a/drivers/crypto/ccp/ccp_crypto.h +++ b/drivers/crypto/ccp/ccp_crypto.h @@ -42,10 +42,9 @@ #define HMAC_IPAD_VALUE 0x36 #define HMAC_OPAD_VALUE 0x5c -#ifdef RTE_LIBRTE_PMD_CCP_CPU_AUTH +/* MD5 */ #define MD5_DIGEST_SIZE 16 #define MD5_BLOCK_SIZE 64 -#endif /* SHA */ #define SHA_COMMON_DIGEST_SIZE 32 @@ -235,9 +234,7 @@ enum ccp_hash_algo { CCP_AUTH_ALGO_SHA3_512_HMAC, CCP_AUTH_ALGO_AES_CMAC, CCP_AUTH_ALGO_AES_GCM, -#ifdef RTE_LIBRTE_PMD_CCP_CPU_AUTH CCP_AUTH_ALGO_MD5_HMAC, -#endif }; /** @@ -250,6 +247,7 @@ enum ccp_hash_op { /* CCP crypto private session structure */ struct ccp_session { + bool auth_opt; enum ccp_cmd_order cmd_id; /**< chain order mode */ struct { @@ -321,6 +319,7 @@ struct ccp_session { extern uint8_t ccp_cryptodev_driver_id; struct ccp_qp; +struct ccp_private; /** * Set and validate CCP crypto session parameters @@ -330,7 +329,8 @@ struct ccp_qp; * @return 0 on success otherwise -1 */ int ccp_set_session_parameters(struct ccp_session *sess, - const struct rte_crypto_sym_xform *xform); + const struct rte_crypto_sym_xform *xform, + struct ccp_private *internals); /** * Find count of slots diff --git a/drivers/crypto/ccp/ccp_pmd_ops.c b/drivers/crypto/ccp/ccp_pmd_ops.c index 3d0d875..2c7496b 100644 --- a/drivers/crypto/ccp/ccp_pmd_ops.c +++ b/drivers/crypto/ccp/ccp_pmd_ops.c @@ -13,7 +13,6 @@ #include "ccp_crypto.h" static const struct rte_cryptodev_capabilities ccp_pmd_capabilities[] = { -#ifdef RTE_LIBRTE_PMD_CCP_CPU_AUTH { /* MD5 HMAC */ .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC, {.sym = { @@ -35,7 +34,6 @@ static const struct rte_cryptodev_capabilities ccp_pmd_capabilities[] = { }, } }, } }, -#endif { /* SHA1 */ .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC, {.sym = { @@ -770,6 +768,7 @@ ccp_pmd_session_configure(struct rte_cryptodev *dev, { int ret; void *sess_private_data; + struct ccp_private *internals; if (unlikely(sess == NULL || xform == NULL)) { CCP_LOG_ERR("Invalid session struct or xform"); @@ -780,7 +779,8 @@ ccp_pmd_session_configure(struct rte_cryptodev *dev, CCP_LOG_ERR("Couldn't get object from session mempool"); return -ENOMEM; } - ret = ccp_set_session_parameters(sess_private_data, xform); + internals = (struct ccp_private *)dev->data->dev_private; + ret = ccp_set_session_parameters(sess_private_data, xform, internals); if (ret != 0) { CCP_LOG_ERR("failed configure session parameters"); diff --git a/drivers/crypto/ccp/ccp_pmd_private.h b/drivers/crypto/ccp/ccp_pmd_private.h index 560bed9..71677ee 100644 --- a/drivers/crypto/ccp/ccp_pmd_private.h +++ b/drivers/crypto/ccp/ccp_pmd_private.h @@ -42,6 +42,8 @@ struct ccp_private { unsigned int max_nb_qpairs; /**< Max number of queue pairs */ unsigned int max_nb_sessions; /**< Max number of sessions */ uint8_t crypto_num_dev; /**< Number of working crypto devices */ + bool auth_opt; /**< Authentication offload option */ + int die_num; /**< Combine CCP devices of this die */ struct ccp_device *last_dev; /**< Last working crypto device */ }; @@ -62,10 +64,8 @@ struct ccp_batch_info { phys_addr_t lsb_buf_phys; /**< LSB intermediate buf for passthru */ int lsb_buf_idx; -#ifdef RTE_LIBRTE_PMD_CCP_CPU_AUTH uint16_t auth_ctr; - /**< auth only ops batch */ -#endif + /**< auth only ops batch for CPU based auth */ } __rte_cache_aligned; /**< CCP crypto queue pair */ diff --git a/drivers/crypto/ccp/rte_ccp_pmd.c b/drivers/crypto/ccp/rte_ccp_pmd.c index d3553db..7d3870f 100644 --- a/drivers/crypto/ccp/rte_ccp_pmd.c +++ b/drivers/crypto/ccp/rte_ccp_pmd.c @@ -22,6 +22,173 @@ static unsigned int ccp_pmd_init_done; uint8_t ccp_cryptodev_driver_id; +struct ccp_pmd_init_params { + struct rte_cryptodev_pmd_init_params def_p; + bool auth_opt; + int die_num; +}; + +#define CCP_CRYPTODEV_PARAM_NAME ("name") +#define CCP_CRYPTODEV_PARAM_SOCKET_ID ("socket_id") +#define CCP_CRYPTODEV_PARAM_MAX_NB_QP ("max_nb_queue_pairs") +#define CCP_CRYPTODEV_PARAM_MAX_NB_SESS ("max_nb_sessions") +#define CCP_CRYPTODEV_PARAM_AUTH_OPT ("ccp_auth_opt") +#define CCP_CRYPTODEV_PARAM_DIE_NUM ("die_num") + +const char *ccp_pmd_valid_params[] = { + CCP_CRYPTODEV_PARAM_NAME, + CCP_CRYPTODEV_PARAM_SOCKET_ID, + CCP_CRYPTODEV_PARAM_MAX_NB_QP, + CCP_CRYPTODEV_PARAM_MAX_NB_SESS, + CCP_CRYPTODEV_PARAM_AUTH_OPT, + CCP_CRYPTODEV_PARAM_DIE_NUM, +}; + +/** ccp pmd auth option */ +enum ccp_pmd_auth_opt { + CCP_PMD_AUTH_OPT_CCP = 0, + CCP_PMD_AUTH_OPT_CPU, +}; + +/** parse integer from integer argument */ +static int +parse_integer_arg(const char *key __rte_unused, + const char *value, void *extra_args) +{ + int *i = (int *) extra_args; + + *i = atoi(value); + if (*i < 0) { + CCP_LOG_ERR("Argument has to be positive.\n"); + return -EINVAL; + } + + return 0; +} + +/** parse name argument */ +static int +parse_name_arg(const char *key __rte_unused, + const char *value, void *extra_args) +{ + struct rte_cryptodev_pmd_init_params *params = extra_args; + + if (strlen(value) >= RTE_CRYPTODEV_NAME_MAX_LEN - 1) { + CCP_LOG_ERR("Invalid name %s, should be less than " + "%u bytes.\n", value, + RTE_CRYPTODEV_NAME_MAX_LEN - 1); + return -EINVAL; + } + + strncpy(params->name, value, RTE_CRYPTODEV_NAME_MAX_LEN); + + return 0; +} + +/** parse authentication operation option */ +static int +parse_auth_opt_arg(const char *key __rte_unused, + const char *value, void *extra_args) +{ + struct ccp_pmd_init_params *params = extra_args; + int i; + + i = atoi(value); + if (i < CCP_PMD_AUTH_OPT_CCP || i > CCP_PMD_AUTH_OPT_CPU) { + CCP_LOG_ERR("Invalid ccp pmd auth option. " + "0->auth on CCP(default), " + "1->auth on CPU\n"); + return -EINVAL; + } + params->auth_opt = i; + return 0; +} + +/* Maximum 4-die platform (0-3) supported */ +#define CCP_PLATFORM_MAX_DIE_NUM 3 + +/** parse die number argument */ +static int +parse_die_num_arg(const char *key __rte_unused, + const char *value, void *extra_args) +{ + struct ccp_pmd_init_params *params = extra_args; + int *i = (int *)¶ms->die_num; + + *i = atoi(value); + if (*i < 0 || *i > CCP_PLATFORM_MAX_DIE_NUM) { + CCP_LOG_ERR("Invalid platform die number. " + "Must be in the range 0-%d\n", + CCP_PLATFORM_MAX_DIE_NUM); + return -EINVAL; + } + return 0; +} + +static int +ccp_pmd_parse_input_args(struct ccp_pmd_init_params *params, + const char *input_args) +{ + struct rte_kvargs *kvlist = NULL; + int ret = 0; + + if (params == NULL) + return -EINVAL; + + if (input_args) { + kvlist = rte_kvargs_parse(input_args, + ccp_pmd_valid_params); + if (kvlist == NULL) + return -1; + + ret = rte_kvargs_process(kvlist, + CCP_CRYPTODEV_PARAM_MAX_NB_QP, + &parse_integer_arg, + ¶ms->def_p.max_nb_queue_pairs); + if (ret < 0) + goto free_kvlist; + + ret = rte_kvargs_process(kvlist, + CCP_CRYPTODEV_PARAM_MAX_NB_SESS, + &parse_integer_arg, + ¶ms->def_p.max_nb_sessions); + if (ret < 0) + goto free_kvlist; + + ret = rte_kvargs_process(kvlist, + CCP_CRYPTODEV_PARAM_SOCKET_ID, + &parse_integer_arg, + ¶ms->def_p.socket_id); + if (ret < 0) + goto free_kvlist; + + ret = rte_kvargs_process(kvlist, + CCP_CRYPTODEV_PARAM_NAME, + &parse_name_arg, + ¶ms->def_p); + if (ret < 0) + goto free_kvlist; + + ret = rte_kvargs_process(kvlist, + CCP_CRYPTODEV_PARAM_AUTH_OPT, + &parse_auth_opt_arg, + params); + if (ret < 0) + goto free_kvlist; + + ret = rte_kvargs_process(kvlist, + CCP_CRYPTODEV_PARAM_DIE_NUM, + &parse_die_num_arg, + params); + if (ret < 0) + goto free_kvlist; + } + +free_kvlist: + rte_kvargs_free(kvlist); + return ret; +} + static struct ccp_session * get_ccp_session(struct ccp_qp *qp, struct rte_crypto_op *op) { @@ -38,6 +205,7 @@ get_ccp_session(struct ccp_qp *qp, struct rte_crypto_op *op) } else if (op->sess_type == RTE_CRYPTO_OP_SESSIONLESS) { void *_sess; void *_sess_private_data = NULL; + struct ccp_private *internals; if (rte_mempool_get(qp->sess_mp, &_sess)) return NULL; @@ -46,8 +214,9 @@ get_ccp_session(struct ccp_qp *qp, struct rte_crypto_op *op) sess = (struct ccp_session *)_sess_private_data; - if (unlikely(ccp_set_session_parameters(sess, - op->sym->xform) != 0)) { + internals = (struct ccp_private *)qp->dev->data->dev_private; + if (unlikely(ccp_set_session_parameters(sess, op->sym->xform, + internals) != 0)) { rte_mempool_put(qp->sess_mp, _sess); rte_mempool_put(qp->sess_mp, _sess_private_data); sess = NULL; @@ -154,19 +323,20 @@ cryptodev_ccp_remove(struct rte_vdev_device *dev) static int cryptodev_ccp_create(const char *name, struct rte_vdev_device *vdev, - struct rte_cryptodev_pmd_init_params *init_params) + struct ccp_pmd_init_params *init_params) { struct rte_cryptodev *dev; struct ccp_private *internals; uint8_t cryptodev_cnt = 0; - if (init_params->name[0] == '\0') - snprintf(init_params->name, sizeof(init_params->name), - "%s", name); + if (init_params->def_p.name[0] == '\0') + snprintf(init_params->def_p.name, + sizeof(init_params->def_p.name), + "%s", name); - dev = rte_cryptodev_pmd_create(init_params->name, + dev = rte_cryptodev_pmd_create(init_params->def_p.name, &vdev->device, - init_params); + &init_params->def_p); if (dev == NULL) { CCP_LOG_ERR("failed to create cryptodev vdev"); goto init_error; @@ -193,15 +363,17 @@ cryptodev_ccp_create(const char *name, internals = dev->data->dev_private; - internals->max_nb_qpairs = init_params->max_nb_queue_pairs; - internals->max_nb_sessions = init_params->max_nb_sessions; + internals->max_nb_qpairs = init_params->def_p.max_nb_queue_pairs; + internals->max_nb_sessions = init_params->def_p.max_nb_sessions; + internals->auth_opt = init_params->auth_opt; + internals->die_num = init_params->die_num; internals->crypto_num_dev = cryptodev_cnt; return 0; init_error: CCP_LOG_ERR("driver %s: %s() failed", - init_params->name, __func__); + init_params->def_p.name, __func__); cryptodev_ccp_remove(vdev); return -EFAULT; @@ -213,12 +385,17 @@ cryptodev_ccp_probe(struct rte_vdev_device *vdev) { int rc = 0; const char *name; - struct rte_cryptodev_pmd_init_params init_params = { - "", - sizeof(struct ccp_private), - rte_socket_id(), - CCP_PMD_MAX_QUEUE_PAIRS, - RTE_CRYPTODEV_PMD_DEFAULT_MAX_NB_SESSIONS + char die_num[20] = {0}; + struct ccp_pmd_init_params init_params = { + .def_p = { + "", + sizeof(struct ccp_private), + rte_socket_id(), + CCP_PMD_MAX_QUEUE_PAIRS, + RTE_CRYPTODEV_PMD_DEFAULT_MAX_NB_SESSIONS + }, + .auth_opt = CCP_PMD_AUTH_OPT_CCP, + .die_num = -1, /* by default use all CCP underneath */ }; const char *input_args; @@ -231,15 +408,20 @@ cryptodev_ccp_probe(struct rte_vdev_device *vdev) return -EINVAL; input_args = rte_vdev_device_args(vdev); - rte_cryptodev_pmd_parse_input_args(&init_params, input_args); - init_params.max_nb_queue_pairs = CCP_PMD_MAX_QUEUE_PAIRS; + ccp_pmd_parse_input_args(&init_params, input_args); + init_params.def_p.max_nb_queue_pairs = CCP_PMD_MAX_QUEUE_PAIRS; RTE_LOG(INFO, PMD, "Initialising %s on NUMA node %d\n", name, - init_params.socket_id); + init_params.def_p.socket_id); RTE_LOG(INFO, PMD, "Max number of queue pairs = %d\n", - init_params.max_nb_queue_pairs); + init_params.def_p.max_nb_queue_pairs); RTE_LOG(INFO, PMD, "Max number of sessions = %d\n", - init_params.max_nb_sessions); + init_params.def_p.max_nb_sessions); + RTE_LOG(INFO, PMD, "Authentication offload to %s\n", + ((init_params.auth_opt == 0) ? "CCP" : "CPU")); + snprintf(die_num, 20, "die_num-%d", init_params.die_num); + RTE_LOG(INFO, PMD, "Combining %s CCP devices\n", + ((init_params.die_num == -1) ? "all" : die_num)); rc = cryptodev_ccp_create(name, vdev, &init_params); if (rc) -- 2.7.4