hak5
/
openwrt-owl
mirror of https://github.com/hak5/openwrt-owl.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
openwrt-owl/target/linux/generic-2.4/files/crypto/ocf/ep80579/icp_sym.c

1154 lines
37 KiB
C
Raw Normal View History

add OCF 20100325 support to brcm-2.4 SVN-Revision: 21357
2010-05-04 21:00:14 +00:00
/***************************************************************************
*
* This file is provided under a dual BSD/GPLv2 license. When using or
* redistributing this file, you may do so under either license.
*
* GPL LICENSE SUMMARY
*
* Copyright(c) 2007,2008,2009 Intel Corporation. All rights reserved.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of version 2 of the GNU General Public License as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
* The full GNU General Public License is included in this distribution
* in the file called LICENSE.GPL.
*
* Contact Information:
* Intel Corporation
*
* BSD LICENSE
*
* Copyright(c) 2007,2008,2009 Intel Corporation. All rights reserved.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* * Neither the name of Intel Corporation nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*
* version: Security.L.1.0.2-229
*
***************************************************************************/
/*
* An OCF module that uses the API for Intel® QuickAssist Technology to do the
* cryptography.
*
* This driver requires the ICP Access Library that is available from Intel in
* order to operate.
*/
#include "icp_ocf.h"
/*This is the call back function for all symmetric cryptographic processes.
Its main functionality is to free driver crypto operation structure and to
call back to OCF*/
static void
icp_ocfDrvSymCallBack(void *callbackTag,
CpaStatus status,
const CpaCySymOp operationType,
void *pOpData,
CpaBufferList * pDstBuffer, CpaBoolean verifyResult);
/*This function is used to extract crypto processing information from the OCF
inputs, so as that it may be passed onto LAC*/
static int
icp_ocfDrvProcessDataSetup(struct icp_drvOpData *drvOpData,
struct cryptodesc *crp_desc);
/*This function checks whether the crp_desc argument pertains to a digest or a
cipher operation*/
static int icp_ocfDrvAlgCheck(struct cryptodesc *crp_desc);
/*This function copies all the passed in session context information and stores
it in a LAC context structure*/
static int
icp_ocfDrvAlgorithmSetup(struct cryptoini *cri,
CpaCySymSessionSetupData * lacSessCtx);
/*This function is used to free an OCF->OCF_DRV session object*/
static void icp_ocfDrvFreeOCFSession(struct icp_drvSessionData *sessionData);
/*max IOV buffs supported in a UIO structure*/
#define NUM_IOV_SUPPORTED (1)
/* Name : icp_ocfDrvSymCallBack
*
* Description : When this function returns it signifies that the LAC
* component has completed the relevant symmetric operation.
*
* Notes : The callbackTag is a pointer to an icp_drvOpData. This memory
* object was passed to LAC for the cryptographic processing and contains all
* the relevant information for cleaning up buffer handles etc. so that the
* OCF EP80579 Driver portion of this crypto operation can be fully completed.
*/
static void
icp_ocfDrvSymCallBack(void *callbackTag,
CpaStatus status,
const CpaCySymOp operationType,
void *pOpData,
CpaBufferList * pDstBuffer, CpaBoolean verifyResult)
{
struct cryptop *crp = NULL;
struct icp_drvOpData *temp_drvOpData =
(struct icp_drvOpData *)callbackTag;
uint64_t *tempBasePtr = NULL;
uint32_t tempLen = 0;
if (NULL == temp_drvOpData) {
DPRINTK("%s(): The callback from the LAC component"
" has failed due to Null userOpaque data"
"(status == %d).\n", __FUNCTION__, status);
DPRINTK("%s(): Unable to call OCF back! \n", __FUNCTION__);
return;
}
crp = temp_drvOpData->crp;
crp->crp_etype = ICP_OCF_DRV_NO_CRYPTO_PROCESS_ERROR;
if (NULL == pOpData) {
DPRINTK("%s(): The callback from the LAC component"
" has failed due to Null Symmetric Op data"
"(status == %d).\n", __FUNCTION__, status);
crp->crp_etype = ECANCELED;
crypto_done(crp);
return;
}
if (NULL == pDstBuffer) {
DPRINTK("%s(): The callback from the LAC component"
" has failed due to Null Dst Bufferlist data"
"(status == %d).\n", __FUNCTION__, status);
crp->crp_etype = ECANCELED;
crypto_done(crp);
return;
}
if (CPA_STATUS_SUCCESS == status) {
if (temp_drvOpData->bufferType == ICP_CRYPTO_F_PACKET_BUF) {
if (ICP_OCF_DRV_STATUS_SUCCESS !=
icp_ocfDrvBufferListToPacketBuff(pDstBuffer,
(icp_packet_buffer_t
**)
& (crp->crp_buf))) {
EPRINTK("%s(): BufferList to SkBuff "
"conversion error.\n", __FUNCTION__);
crp->crp_etype = EPERM;
}
} else {
icp_ocfDrvBufferListToPtrAndLen(pDstBuffer,
(void **)&tempBasePtr,
&tempLen);
crp->crp_olen = (int)tempLen;
}
} else {
DPRINTK("%s(): The callback from the LAC component has failed"
"(status == %d).\n", __FUNCTION__, status);
crp->crp_etype = ECANCELED;
}
if (temp_drvOpData->numBufferListArray >
ICP_OCF_DRV_DEFAULT_BUFFLIST_ARRAYS) {
icp_kfree(pDstBuffer->pBuffers);
}
icp_ocfDrvFreeMetaData(pDstBuffer);
ICP_CACHE_FREE(drvOpData_zone, temp_drvOpData);
/* Invoke the OCF callback function */
crypto_done(crp);
return;
}
/* Name : icp_ocfDrvNewSession
*
* Description : This function will create a new Driver<->OCF session
*
* Notes : LAC session registration happens during the first perform call.
* That is the first time we know all information about a given session.
*/
int icp_ocfDrvNewSession(icp_device_t dev, uint32_t * sid,
struct cryptoini *cri)
{
struct icp_drvSessionData *sessionData = NULL;
uint32_t delete_session = 0;
/* The SID passed in should be our driver ID. We can return the */
/* local ID (LID) which is a unique identifier which we can use */
/* to differentiate between the encrypt/decrypt LAC session handles */
if (NULL == sid) {
EPRINTK("%s(): Invalid input parameters - NULL sid.\n",
__FUNCTION__);
return EINVAL;
}
if (NULL == cri) {
EPRINTK("%s(): Invalid input parameters - NULL cryptoini.\n",
__FUNCTION__);
return EINVAL;
}
if (icp_ocfDrvDriverId != *sid) {
EPRINTK("%s(): Invalid input parameters - bad driver ID\n",
__FUNCTION__);
EPRINTK("\t sid = 0x08%p \n \t cri = 0x08%p \n", sid, cri);
return EINVAL;
}
sessionData = icp_kmem_cache_zalloc(drvSessionData_zone, ICP_M_NOWAIT);
if (NULL == sessionData) {
DPRINTK("%s():No memory for Session Data\n", __FUNCTION__);
return ENOMEM;
}
/*ENTER CRITICAL SECTION */
icp_spin_lockbh_lock(&icp_ocfDrvSymSessInfoListSpinlock);
/*put this check in the spinlock so no new sessions can be added to the
linked list when we are exiting */
if (CPA_TRUE == icp_atomic_read(&icp_ocfDrvIsExiting)) {
delete_session++;
} else if (NO_OCF_TO_DRV_MAX_SESSIONS != max_sessions) {
if (icp_atomic_read(&num_ocf_to_drv_registered_sessions) >=
(max_sessions -
icp_atomic_read(&lac_session_failed_dereg_count))) {
delete_session++;
} else {
icp_atomic_inc(&num_ocf_to_drv_registered_sessions);
/* Add to session data linked list */
ICP_LIST_ADD(sessionData, &icp_ocfDrvGlobalSymListHead,
listNode);
}
} else if (NO_OCF_TO_DRV_MAX_SESSIONS == max_sessions) {
ICP_LIST_ADD(sessionData, &icp_ocfDrvGlobalSymListHead,
listNode);
}
sessionData->inUse = ICP_SESSION_INITIALISED;
/*EXIT CRITICAL SECTION */
icp_spin_lockbh_unlock(&icp_ocfDrvSymSessInfoListSpinlock);
if (delete_session) {
DPRINTK("%s():No Session handles available\n", __FUNCTION__);
ICP_CACHE_FREE(drvSessionData_zone, sessionData);
return EPERM;
}
if (ICP_OCF_DRV_STATUS_SUCCESS !=
icp_ocfDrvAlgorithmSetup(cri, &(sessionData->lacSessCtx))) {
DPRINTK("%s():algorithm not supported\n", __FUNCTION__);
icp_ocfDrvFreeOCFSession(sessionData);
return EINVAL;
}
if (cri->cri_next) {
if (cri->cri_next->cri_next != NULL) {
DPRINTK("%s():only two chained algorithms supported\n",
__FUNCTION__);
icp_ocfDrvFreeOCFSession(sessionData);
return EPERM;
}
if (ICP_OCF_DRV_STATUS_SUCCESS !=
icp_ocfDrvAlgorithmSetup(cri->cri_next,
&(sessionData->lacSessCtx))) {
DPRINTK("%s():second algorithm not supported\n",
__FUNCTION__);
icp_ocfDrvFreeOCFSession(sessionData);
return EINVAL;
}
sessionData->lacSessCtx.symOperation =
CPA_CY_SYM_OP_ALGORITHM_CHAINING;
}
*sid = (uint32_t) sessionData;
return ICP_OCF_DRV_STATUS_SUCCESS;
}
/* Name : icp_ocfDrvAlgorithmSetup
*
* Description : This function builds the session context data from the
* information supplied through OCF. Algorithm chain order and whether the
* session is Encrypt/Decrypt can only be found out at perform time however, so
* the session is registered with LAC at that time.
*/
static int
icp_ocfDrvAlgorithmSetup(struct cryptoini *cri,
CpaCySymSessionSetupData * lacSessCtx)
{
lacSessCtx->sessionPriority = CPA_CY_PRIORITY_NORMAL;
switch (cri->cri_alg) {
case CRYPTO_NULL_CBC:
DPRINTK("%s(): NULL CBC\n", __FUNCTION__);
lacSessCtx->symOperation = CPA_CY_SYM_OP_CIPHER;
lacSessCtx->cipherSetupData.cipherAlgorithm =
CPA_CY_SYM_CIPHER_NULL;
lacSessCtx->cipherSetupData.cipherKeyLenInBytes =
cri->cri_klen / NUM_BITS_IN_BYTE;
lacSessCtx->cipherSetupData.pCipherKey = cri->cri_key;
break;
case CRYPTO_DES_CBC:
DPRINTK("%s(): DES CBC\n", __FUNCTION__);
lacSessCtx->symOperation = CPA_CY_SYM_OP_CIPHER;
lacSessCtx->cipherSetupData.cipherAlgorithm =
CPA_CY_SYM_CIPHER_DES_CBC;
lacSessCtx->cipherSetupData.cipherKeyLenInBytes =
cri->cri_klen / NUM_BITS_IN_BYTE;
lacSessCtx->cipherSetupData.pCipherKey = cri->cri_key;
break;
case CRYPTO_3DES_CBC:
DPRINTK("%s(): 3DES CBC\n", __FUNCTION__);
lacSessCtx->symOperation = CPA_CY_SYM_OP_CIPHER;
lacSessCtx->cipherSetupData.cipherAlgorithm =
CPA_CY_SYM_CIPHER_3DES_CBC;
lacSessCtx->cipherSetupData.cipherKeyLenInBytes =
cri->cri_klen / NUM_BITS_IN_BYTE;
lacSessCtx->cipherSetupData.pCipherKey = cri->cri_key;
break;
case CRYPTO_AES_CBC:
DPRINTK("%s(): AES CBC\n", __FUNCTION__);
lacSessCtx->symOperation = CPA_CY_SYM_OP_CIPHER;
lacSessCtx->cipherSetupData.cipherAlgorithm =
CPA_CY_SYM_CIPHER_AES_CBC;
lacSessCtx->cipherSetupData.cipherKeyLenInBytes =
cri->cri_klen / NUM_BITS_IN_BYTE;
lacSessCtx->cipherSetupData.pCipherKey = cri->cri_key;
break;
case CRYPTO_ARC4:
DPRINTK("%s(): ARC4\n", __FUNCTION__);
lacSessCtx->symOperation = CPA_CY_SYM_OP_CIPHER;
lacSessCtx->cipherSetupData.cipherAlgorithm =
CPA_CY_SYM_CIPHER_ARC4;
lacSessCtx->cipherSetupData.cipherKeyLenInBytes =
cri->cri_klen / NUM_BITS_IN_BYTE;
lacSessCtx->cipherSetupData.pCipherKey = cri->cri_key;
break;
case CRYPTO_SHA1:
DPRINTK("%s(): SHA1\n", __FUNCTION__);
lacSessCtx->symOperation = CPA_CY_SYM_OP_HASH;
lacSessCtx->hashSetupData.hashAlgorithm = CPA_CY_SYM_HASH_SHA1;
lacSessCtx->hashSetupData.hashMode = CPA_CY_SYM_HASH_MODE_PLAIN;
lacSessCtx->hashSetupData.digestResultLenInBytes =
(cri->cri_mlen ?
cri->cri_mlen : ICP_SHA1_DIGEST_SIZE_IN_BYTES);
break;
case CRYPTO_SHA1_HMAC:
DPRINTK("%s(): SHA1_HMAC\n", __FUNCTION__);
lacSessCtx->symOperation = CPA_CY_SYM_OP_HASH;
lacSessCtx->hashSetupData.hashAlgorithm = CPA_CY_SYM_HASH_SHA1;
lacSessCtx->hashSetupData.hashMode = CPA_CY_SYM_HASH_MODE_AUTH;
lacSessCtx->hashSetupData.digestResultLenInBytes =
(cri->cri_mlen ?
cri->cri_mlen : ICP_SHA1_DIGEST_SIZE_IN_BYTES);
lacSessCtx->hashSetupData.authModeSetupData.authKey =
cri->cri_key;
lacSessCtx->hashSetupData.authModeSetupData.authKeyLenInBytes =
cri->cri_klen / NUM_BITS_IN_BYTE;
lacSessCtx->hashSetupData.authModeSetupData.aadLenInBytes = 0;
break;
case CRYPTO_SHA2_256:
DPRINTK("%s(): SHA256\n", __FUNCTION__);
lacSessCtx->symOperation = CPA_CY_SYM_OP_HASH;
lacSessCtx->hashSetupData.hashAlgorithm =
CPA_CY_SYM_HASH_SHA256;
lacSessCtx->hashSetupData.hashMode = CPA_CY_SYM_HASH_MODE_PLAIN;
lacSessCtx->hashSetupData.digestResultLenInBytes =
(cri->cri_mlen ?
cri->cri_mlen : ICP_SHA256_DIGEST_SIZE_IN_BYTES);
break;
case CRYPTO_SHA2_256_HMAC:
DPRINTK("%s(): SHA256_HMAC\n", __FUNCTION__);
lacSessCtx->symOperation = CPA_CY_SYM_OP_HASH;
lacSessCtx->hashSetupData.hashAlgorithm =
CPA_CY_SYM_HASH_SHA256;
lacSessCtx->hashSetupData.hashMode = CPA_CY_SYM_HASH_MODE_AUTH;
lacSessCtx->hashSetupData.digestResultLenInBytes =
(cri->cri_mlen ?
cri->cri_mlen : ICP_SHA256_DIGEST_SIZE_IN_BYTES);
lacSessCtx->hashSetupData.authModeSetupData.authKey =
cri->cri_key;
lacSessCtx->hashSetupData.authModeSetupData.authKeyLenInBytes =
cri->cri_klen / NUM_BITS_IN_BYTE;
lacSessCtx->hashSetupData.authModeSetupData.aadLenInBytes = 0;
break;
case CRYPTO_SHA2_384:
DPRINTK("%s(): SHA384\n", __FUNCTION__);
lacSessCtx->symOperation = CPA_CY_SYM_OP_HASH;
lacSessCtx->hashSetupData.hashAlgorithm =
CPA_CY_SYM_HASH_SHA384;
lacSessCtx->hashSetupData.hashMode = CPA_CY_SYM_HASH_MODE_PLAIN;
lacSessCtx->hashSetupData.digestResultLenInBytes =
(cri->cri_mlen ?
cri->cri_mlen : ICP_SHA384_DIGEST_SIZE_IN_BYTES);
break;
case CRYPTO_SHA2_384_HMAC:
DPRINTK("%s(): SHA384_HMAC\n", __FUNCTION__);
lacSessCtx->symOperation = CPA_CY_SYM_OP_HASH;
lacSessCtx->hashSetupData.hashAlgorithm =
CPA_CY_SYM_HASH_SHA384;
lacSessCtx->hashSetupData.hashMode = CPA_CY_SYM_HASH_MODE_AUTH;
lacSessCtx->hashSetupData.digestResultLenInBytes =
(cri->cri_mlen ?
cri->cri_mlen : ICP_SHA384_DIGEST_SIZE_IN_BYTES);
lacSessCtx->hashSetupData.authModeSetupData.authKey =
cri->cri_key;
lacSessCtx->hashSetupData.authModeSetupData.authKeyLenInBytes =
cri->cri_klen / NUM_BITS_IN_BYTE;
lacSessCtx->hashSetupData.authModeSetupData.aadLenInBytes = 0;
break;
case CRYPTO_SHA2_512:
DPRINTK("%s(): SHA512\n", __FUNCTION__);
lacSessCtx->symOperation = CPA_CY_SYM_OP_HASH;
lacSessCtx->hashSetupData.hashAlgorithm =
CPA_CY_SYM_HASH_SHA512;
lacSessCtx->hashSetupData.hashMode = CPA_CY_SYM_HASH_MODE_PLAIN;
lacSessCtx->hashSetupData.digestResultLenInBytes =
(cri->cri_mlen ?
cri->cri_mlen : ICP_SHA512_DIGEST_SIZE_IN_BYTES);
break;
case CRYPTO_SHA2_512_HMAC:
DPRINTK("%s(): SHA512_HMAC\n", __FUNCTION__);
lacSessCtx->symOperation = CPA_CY_SYM_OP_HASH;
lacSessCtx->hashSetupData.hashAlgorithm =
CPA_CY_SYM_HASH_SHA512;
lacSessCtx->hashSetupData.hashMode = CPA_CY_SYM_HASH_MODE_AUTH;
lacSessCtx->hashSetupData.digestResultLenInBytes =
(cri->cri_mlen ?
cri->cri_mlen : ICP_SHA512_DIGEST_SIZE_IN_BYTES);
lacSessCtx->hashSetupData.authModeSetupData.authKey =
cri->cri_key;
lacSessCtx->hashSetupData.authModeSetupData.authKeyLenInBytes =
cri->cri_klen / NUM_BITS_IN_BYTE;
lacSessCtx->hashSetupData.authModeSetupData.aadLenInBytes = 0;
break;
case CRYPTO_MD5:
DPRINTK("%s(): MD5\n", __FUNCTION__);
lacSessCtx->symOperation = CPA_CY_SYM_OP_HASH;
lacSessCtx->hashSetupData.hashAlgorithm = CPA_CY_SYM_HASH_MD5;
lacSessCtx->hashSetupData.hashMode = CPA_CY_SYM_HASH_MODE_PLAIN;
lacSessCtx->hashSetupData.digestResultLenInBytes =
(cri->cri_mlen ?
cri->cri_mlen : ICP_MD5_DIGEST_SIZE_IN_BYTES);
break;
case CRYPTO_MD5_HMAC:
DPRINTK("%s(): MD5_HMAC\n", __FUNCTION__);
lacSessCtx->symOperation = CPA_CY_SYM_OP_HASH;
lacSessCtx->hashSetupData.hashAlgorithm = CPA_CY_SYM_HASH_MD5;
lacSessCtx->hashSetupData.hashMode = CPA_CY_SYM_HASH_MODE_AUTH;
lacSessCtx->hashSetupData.digestResultLenInBytes =
(cri->cri_mlen ?
cri->cri_mlen : ICP_MD5_DIGEST_SIZE_IN_BYTES);
lacSessCtx->hashSetupData.authModeSetupData.authKey =
cri->cri_key;
lacSessCtx->hashSetupData.authModeSetupData.authKeyLenInBytes =
cri->cri_klen / NUM_BITS_IN_BYTE;
lacSessCtx->hashSetupData.authModeSetupData.aadLenInBytes = 0;
break;
default:
DPRINTK("%s(): ALG Setup FAIL\n", __FUNCTION__);
return ICP_OCF_DRV_STATUS_FAIL;
}
return ICP_OCF_DRV_STATUS_SUCCESS;
}
/* Name : icp_ocfDrvFreeOCFSession
*
* Description : This function deletes all existing Session data representing
* the Cryptographic session established between OCF and this driver. This
* also includes freeing the memory allocated for the session context. The
* session object is also removed from the session linked list.
*/
static void icp_ocfDrvFreeOCFSession(struct icp_drvSessionData *sessionData)
{
sessionData->inUse = ICP_SESSION_DEREGISTERED;
/*ENTER CRITICAL SECTION */
icp_spin_lockbh_lock(&icp_ocfDrvSymSessInfoListSpinlock);
if (CPA_TRUE == icp_atomic_read(&icp_ocfDrvIsExiting)) {
/*If the Driver is exiting, allow that process to
handle any deletions */
/*EXIT CRITICAL SECTION */
icp_spin_lockbh_unlock(&icp_ocfDrvSymSessInfoListSpinlock);
return;
}
icp_atomic_dec(&num_ocf_to_drv_registered_sessions);
ICP_LIST_DEL(sessionData, listNode);
/*EXIT CRITICAL SECTION */
icp_spin_lockbh_unlock(&icp_ocfDrvSymSessInfoListSpinlock);
if (NULL != sessionData->sessHandle) {
icp_kfree(sessionData->sessHandle);
}
ICP_CACHE_FREE(drvSessionData_zone, sessionData);
}
/* Name : icp_ocfDrvFreeLACSession
*
* Description : This attempts to deregister a LAC session. If it fails, the
* deregistation retry function is called.
*/
int icp_ocfDrvFreeLACSession(icp_device_t dev, uint64_t sid)
{
CpaCySymSessionCtx sessionToDeregister = NULL;
struct icp_drvSessionData *sessionData = NULL;
CpaStatus lacStatus = CPA_STATUS_SUCCESS;
int retval = 0;
sessionData = (struct icp_drvSessionData *)CRYPTO_SESID2LID(sid);
if (NULL == sessionData) {
EPRINTK("%s(): OCF Free session called with Null Session ID.\n",
__FUNCTION__);
return EINVAL;
}
sessionToDeregister = sessionData->sessHandle;
if ((ICP_SESSION_INITIALISED != sessionData->inUse) &&
(ICP_SESSION_RUNNING != sessionData->inUse) &&
(ICP_SESSION_DEREGISTERED != sessionData->inUse)) {
DPRINTK("%s() Session not initialised.\n", __FUNCTION__);
return EINVAL;
}
if (ICP_SESSION_RUNNING == sessionData->inUse) {
lacStatus = cpaCySymRemoveSession(CPA_INSTANCE_HANDLE_SINGLE,
sessionToDeregister);
if (CPA_STATUS_RETRY == lacStatus) {
if (ICP_OCF_DRV_STATUS_SUCCESS !=
icp_ocfDrvDeregRetry(&sessionToDeregister)) {
/* the retry function increments the
dereg failed count */
DPRINTK("%s(): LAC failed to deregister the "
"session. (localSessionId= %p)\n",
__FUNCTION__, sessionToDeregister);
retval = EPERM;
}
} else if (CPA_STATUS_SUCCESS != lacStatus) {
DPRINTK("%s(): LAC failed to deregister the session. "
"localSessionId= %p, lacStatus = %d\n",
__FUNCTION__, sessionToDeregister, lacStatus);
icp_atomic_inc(&lac_session_failed_dereg_count);
retval = EPERM;
}
} else {
DPRINTK("%s() Session not registered with LAC.\n",
__FUNCTION__);
}
icp_ocfDrvFreeOCFSession(sessionData);
return retval;
}
/* Name : icp_ocfDrvAlgCheck
*
* Description : This function checks whether the cryptodesc argument pertains
* to a sym or hash function
*/
static int icp_ocfDrvAlgCheck(struct cryptodesc *crp_desc)
{
if (crp_desc->crd_alg == CRYPTO_3DES_CBC ||
crp_desc->crd_alg == CRYPTO_AES_CBC ||
crp_desc->crd_alg == CRYPTO_DES_CBC ||
crp_desc->crd_alg == CRYPTO_NULL_CBC ||
crp_desc->crd_alg == CRYPTO_ARC4) {
return ICP_OCF_DRV_ALG_CIPHER;
}
return ICP_OCF_DRV_ALG_HASH;
}
/* Name : icp_ocfDrvSymProcess
*
* Description : This function will map symmetric functionality calls from OCF
* to the LAC API. It will also allocate memory to store the session context.
*
* Notes: If it is the first perform call for a given session, then a LAC
* session is registered. After the session is registered, no checks as
* to whether session paramaters have changed (e.g. alg chain order) are
* done.
*/
int icp_ocfDrvSymProcess(icp_device_t dev, struct cryptop *crp, int hint)
{
struct icp_drvSessionData *sessionData = NULL;
struct icp_drvOpData *drvOpData = NULL;
CpaStatus lacStatus = CPA_STATUS_SUCCESS;
Cpa32U sessionCtxSizeInBytes = 0;
if (NULL == crp) {
DPRINTK("%s(): Invalid input parameters, cryptop is NULL\n",
__FUNCTION__);
return EINVAL;
}
if (NULL == crp->crp_desc) {
DPRINTK("%s(): Invalid input parameters, no crp_desc attached "
"to crp\n", __FUNCTION__);
crp->crp_etype = EINVAL;
return EINVAL;
}
if (NULL == crp->crp_buf) {
DPRINTK("%s(): Invalid input parameters, no buffer attached "
"to crp\n", __FUNCTION__);
crp->crp_etype = EINVAL;
return EINVAL;
}
if (CPA_TRUE == icp_atomic_read(&icp_ocfDrvIsExiting)) {
crp->crp_etype = EFAULT;
return EFAULT;
}
sessionData = (struct icp_drvSessionData *)
(CRYPTO_SESID2LID(crp->crp_sid));
if (NULL == sessionData) {
DPRINTK("%s(): Invalid input parameters, Null Session ID \n",
__FUNCTION__);
crp->crp_etype = EINVAL;
return EINVAL;
}
/*If we get a request against a deregisted session, cancel operation*/
if (ICP_SESSION_DEREGISTERED == sessionData->inUse) {
DPRINTK("%s(): Session ID %d was deregistered \n",
__FUNCTION__, (int)(CRYPTO_SESID2LID(crp->crp_sid)));
crp->crp_etype = EFAULT;
return EFAULT;
}
/*If none of the session states are set, then the session structure was either
not initialised properly or we are reading from a freed memory area (possible
due to OCF batch mode not removing queued requests against deregistered
sessions*/
if (ICP_SESSION_INITIALISED != sessionData->inUse &&
ICP_SESSION_RUNNING != sessionData->inUse) {
DPRINTK("%s(): Session - ID %d - not properly initialised or "
"memory freed back to the kernel \n",
__FUNCTION__, (int)(CRYPTO_SESID2LID(crp->crp_sid)));
crp->crp_etype = EINVAL;
return EINVAL;
}
/*For the below checks, remember error checking is already done in LAC.
We're not validating inputs subsequent to registration */
if (sessionData->inUse == ICP_SESSION_INITIALISED) {
DPRINTK("%s(): Initialising session\n", __FUNCTION__);
if (NULL != crp->crp_desc->crd_next) {
if (ICP_OCF_DRV_ALG_CIPHER ==
icp_ocfDrvAlgCheck(crp->crp_desc)) {
sessionData->lacSessCtx.algChainOrder =
CPA_CY_SYM_ALG_CHAIN_ORDER_CIPHER_THEN_HASH;
if (crp->crp_desc->crd_flags & CRD_F_ENCRYPT) {
sessionData->lacSessCtx.cipherSetupData.
cipherDirection =
CPA_CY_SYM_CIPHER_DIRECTION_ENCRYPT;
} else {
sessionData->lacSessCtx.cipherSetupData.
cipherDirection =
CPA_CY_SYM_CIPHER_DIRECTION_DECRYPT;
}
} else {
sessionData->lacSessCtx.algChainOrder =
CPA_CY_SYM_ALG_CHAIN_ORDER_HASH_THEN_CIPHER;
if (crp->crp_desc->crd_next->crd_flags &
CRD_F_ENCRYPT) {
sessionData->lacSessCtx.cipherSetupData.
cipherDirection =
CPA_CY_SYM_CIPHER_DIRECTION_ENCRYPT;
} else {
sessionData->lacSessCtx.cipherSetupData.
cipherDirection =
CPA_CY_SYM_CIPHER_DIRECTION_DECRYPT;
}
}
} else if (ICP_OCF_DRV_ALG_CIPHER ==
icp_ocfDrvAlgCheck(crp->crp_desc)) {
if (crp->crp_desc->crd_flags & CRD_F_ENCRYPT) {
sessionData->lacSessCtx.cipherSetupData.
cipherDirection =
CPA_CY_SYM_CIPHER_DIRECTION_ENCRYPT;
} else {
sessionData->lacSessCtx.cipherSetupData.
cipherDirection =
CPA_CY_SYM_CIPHER_DIRECTION_DECRYPT;
}
}
/*No action required for standalone Auth here */
/* Allocate memory for SymSessionCtx before the Session Registration */
lacStatus =
cpaCySymSessionCtxGetSize(CPA_INSTANCE_HANDLE_SINGLE,
&(sessionData->lacSessCtx),
&sessionCtxSizeInBytes);
if (CPA_STATUS_SUCCESS != lacStatus) {
EPRINTK("%s(): cpaCySymSessionCtxGetSize failed - %d\n",
__FUNCTION__, lacStatus);
crp->crp_etype = EINVAL;
return EINVAL;
}
sessionData->sessHandle =
icp_kmalloc(sessionCtxSizeInBytes, ICP_M_NOWAIT);
if (NULL == sessionData->sessHandle) {
EPRINTK
("%s(): Failed to get memory for SymSessionCtx\n",
__FUNCTION__);
crp->crp_etype = ENOMEM;
return ENOMEM;
}
lacStatus = cpaCySymInitSession(CPA_INSTANCE_HANDLE_SINGLE,
icp_ocfDrvSymCallBack,
&(sessionData->lacSessCtx),
sessionData->sessHandle);
if (CPA_STATUS_SUCCESS != lacStatus) {
EPRINTK("%s(): cpaCySymInitSession failed -%d \n",
__FUNCTION__, lacStatus);
crp->crp_etype = EFAULT;
return EFAULT;
}
sessionData->inUse = ICP_SESSION_RUNNING;
}
drvOpData = icp_kmem_cache_zalloc(drvOpData_zone, ICP_M_NOWAIT);
if (NULL == drvOpData) {
EPRINTK("%s():Failed to get memory for drvOpData\n",
__FUNCTION__);
crp->crp_etype = ENOMEM;
return ENOMEM;
}
drvOpData->lacOpData.pSessionCtx = sessionData->sessHandle;
drvOpData->digestSizeInBytes = sessionData->lacSessCtx.hashSetupData.
digestResultLenInBytes;
drvOpData->crp = crp;
/* Set the default buffer list array memory allocation */
drvOpData->srcBuffer.pBuffers = drvOpData->bufferListArray;
drvOpData->numBufferListArray = ICP_OCF_DRV_DEFAULT_BUFFLIST_ARRAYS;
if (ICP_OCF_DRV_STATUS_SUCCESS !=
icp_ocfDrvProcessDataSetup(drvOpData, drvOpData->crp->crp_desc)) {
crp->crp_etype = EINVAL;
goto err;
}
if (drvOpData->crp->crp_desc->crd_next != NULL) {
if (icp_ocfDrvProcessDataSetup(drvOpData, drvOpData->crp->
crp_desc->crd_next)) {
crp->crp_etype = EINVAL;
goto err;
}
}
/*
* Allocate buffer list array memory if the data fragment is more than
* the default number (ICP_OCF_DRV_DEFAULT_BUFFLIST_ARRAYS) and not
* calculated already
*/
if (crp->crp_flags & ICP_CRYPTO_F_PACKET_BUF) {
if (NULL == drvOpData->lacOpData.pDigestResult) {
drvOpData->numBufferListArray =
icp_ocfDrvGetPacketBuffFrags((icp_packet_buffer_t *)
crp->crp_buf);
}
if (ICP_OCF_DRV_DEFAULT_BUFFLIST_ARRAYS <
drvOpData->numBufferListArray) {
DPRINTK("%s() numBufferListArray more than default\n",
__FUNCTION__);
drvOpData->srcBuffer.pBuffers = NULL;
drvOpData->srcBuffer.pBuffers =
icp_kmalloc(drvOpData->numBufferListArray *
sizeof(CpaFlatBuffer), ICP_M_NOWAIT);
if (NULL == drvOpData->srcBuffer.pBuffers) {
EPRINTK("%s() Failed to get memory for "
"pBuffers\n", __FUNCTION__);
ICP_CACHE_FREE(drvOpData_zone, drvOpData);
crp->crp_etype = ENOMEM;
return ENOMEM;
}
}
}
/*
* Check the type of buffer structure we got and convert it into
* CpaBufferList format.
*/
if (crp->crp_flags & ICP_CRYPTO_F_PACKET_BUF) {
if (ICP_OCF_DRV_STATUS_SUCCESS !=
icp_ocfDrvPacketBuffToBufferList((icp_packet_buffer_t *)
crp->crp_buf,
&(drvOpData->srcBuffer))) {
EPRINTK("%s():Failed to translate from packet buffer "
"to bufferlist\n", __FUNCTION__);
crp->crp_etype = EINVAL;
goto err;
}
drvOpData->bufferType = ICP_CRYPTO_F_PACKET_BUF;
} else if (crp->crp_flags & CRYPTO_F_IOV) {
/* OCF only supports IOV of one entry. */
if (NUM_IOV_SUPPORTED ==
((struct uio *)(crp->crp_buf))->uio_iovcnt) {
icp_ocfDrvPtrAndLenToBufferList(((struct uio *)(crp->
crp_buf))->
uio_iov[0].iov_base,
((struct uio *)(crp->
crp_buf))->
uio_iov[0].iov_len,
&(drvOpData->
srcBuffer));
drvOpData->bufferType = CRYPTO_F_IOV;
} else {
DPRINTK("%s():Unable to handle IOVs with lengths of "
"greater than one!\n", __FUNCTION__);
crp->crp_etype = EINVAL;
goto err;
}
} else {
icp_ocfDrvPtrAndLenToBufferList(crp->crp_buf,
crp->crp_ilen,
&(drvOpData->srcBuffer));
drvOpData->bufferType = CRYPTO_BUF_CONTIG;
}
/* Allocate srcBuffer's private meta data */
if (ICP_OCF_DRV_STATUS_SUCCESS !=
icp_ocfDrvAllocMetaData(&(drvOpData->srcBuffer), drvOpData)) {
EPRINTK("%s() icp_ocfDrvAllocMetaData failed\n", __FUNCTION__);
memset(&(drvOpData->lacOpData), 0, sizeof(CpaCySymOpData));
crp->crp_etype = EINVAL;
goto err;
}
/* Perform "in-place" crypto operation */
lacStatus = cpaCySymPerformOp(CPA_INSTANCE_HANDLE_SINGLE,
(void *)drvOpData,
&(drvOpData->lacOpData),
&(drvOpData->srcBuffer),
&(drvOpData->srcBuffer),
&(drvOpData->verifyResult));
if (CPA_STATUS_RETRY == lacStatus) {
DPRINTK("%s(): cpaCySymPerformOp retry, lacStatus = %d\n",
__FUNCTION__, lacStatus);
memset(&(drvOpData->lacOpData), 0, sizeof(CpaCySymOpData));
crp->crp_etype = ERESTART;
goto err;
}
if (CPA_STATUS_SUCCESS != lacStatus) {
EPRINTK("%s(): cpaCySymPerformOp failed, lacStatus = %d\n",
__FUNCTION__, lacStatus);
memset(&(drvOpData->lacOpData), 0, sizeof(CpaCySymOpData));
crp->crp_etype = EINVAL;
goto err;
}
return 0; //OCF success status value
err:
if (drvOpData->numBufferListArray > ICP_OCF_DRV_DEFAULT_BUFFLIST_ARRAYS) {
icp_kfree(drvOpData->srcBuffer.pBuffers);
}
icp_ocfDrvFreeMetaData(&(drvOpData->srcBuffer));
ICP_CACHE_FREE(drvOpData_zone, drvOpData);
return crp->crp_etype;
}
/* Name : icp_ocfDrvProcessDataSetup
*
* Description : This function will setup all the cryptographic operation data
* that is required by LAC to execute the operation.
*/
static int icp_ocfDrvProcessDataSetup(struct icp_drvOpData *drvOpData,
struct cryptodesc *crp_desc)
{
CpaCyRandGenOpData randGenOpData;
CpaFlatBuffer randData;
drvOpData->lacOpData.packetType = CPA_CY_SYM_PACKET_TYPE_FULL;
/* Convert from the cryptop to the ICP LAC crypto parameters */
switch (crp_desc->crd_alg) {
case CRYPTO_NULL_CBC:
drvOpData->lacOpData.
cryptoStartSrcOffsetInBytes = crp_desc->crd_skip;
drvOpData->lacOpData.
messageLenToCipherInBytes = crp_desc->crd_len;
drvOpData->verifyResult = CPA_FALSE;
drvOpData->lacOpData.ivLenInBytes = NULL_BLOCK_LEN;
break;
case CRYPTO_DES_CBC:
drvOpData->lacOpData.
cryptoStartSrcOffsetInBytes = crp_desc->crd_skip;
drvOpData->lacOpData.
messageLenToCipherInBytes = crp_desc->crd_len;
drvOpData->verifyResult = CPA_FALSE;
drvOpData->lacOpData.ivLenInBytes = DES_BLOCK_LEN;
break;
case CRYPTO_3DES_CBC:
drvOpData->lacOpData.
cryptoStartSrcOffsetInBytes = crp_desc->crd_skip;
drvOpData->lacOpData.
messageLenToCipherInBytes = crp_desc->crd_len;
drvOpData->verifyResult = CPA_FALSE;
drvOpData->lacOpData.ivLenInBytes = DES3_BLOCK_LEN;
break;
case CRYPTO_ARC4:
drvOpData->lacOpData.
cryptoStartSrcOffsetInBytes = crp_desc->crd_skip;
drvOpData->lacOpData.
messageLenToCipherInBytes = crp_desc->crd_len;
drvOpData->verifyResult = CPA_FALSE;
drvOpData->lacOpData.ivLenInBytes = ARC4_COUNTER_LEN;
break;
case CRYPTO_AES_CBC:
drvOpData->lacOpData.
cryptoStartSrcOffsetInBytes = crp_desc->crd_skip;
drvOpData->lacOpData.
messageLenToCipherInBytes = crp_desc->crd_len;
drvOpData->verifyResult = CPA_FALSE;
drvOpData->lacOpData.ivLenInBytes = RIJNDAEL128_BLOCK_LEN;
break;
case CRYPTO_SHA1:
case CRYPTO_SHA1_HMAC:
case CRYPTO_SHA2_256:
case CRYPTO_SHA2_256_HMAC:
case CRYPTO_SHA2_384:
case CRYPTO_SHA2_384_HMAC:
case CRYPTO_SHA2_512:
case CRYPTO_SHA2_512_HMAC:
case CRYPTO_MD5:
case CRYPTO_MD5_HMAC:
drvOpData->lacOpData.
hashStartSrcOffsetInBytes = crp_desc->crd_skip;
drvOpData->lacOpData.
messageLenToHashInBytes = crp_desc->crd_len;
drvOpData->lacOpData.
pDigestResult =
icp_ocfDrvDigestPointerFind(drvOpData, crp_desc);
if (NULL == drvOpData->lacOpData.pDigestResult) {
DPRINTK("%s(): ERROR - could not calculate "
"Digest Result memory address\n", __FUNCTION__);
return ICP_OCF_DRV_STATUS_FAIL;
}
drvOpData->lacOpData.digestVerify = CPA_FALSE;
break;
default:
DPRINTK("%s(): Crypto process error - algorithm not "
"found \n", __FUNCTION__);
return ICP_OCF_DRV_STATUS_FAIL;
}
/* Figure out what the IV is supposed to be */
if ((crp_desc->crd_alg == CRYPTO_DES_CBC) ||
(crp_desc->crd_alg == CRYPTO_3DES_CBC) ||
(crp_desc->crd_alg == CRYPTO_AES_CBC)) {
/*ARC4 doesn't use an IV */
if (crp_desc->crd_flags & CRD_F_IV_EXPLICIT) {
/* Explicit IV provided to OCF */
drvOpData->lacOpData.pIv = crp_desc->crd_iv;
} else {
/* IV is not explicitly provided to OCF */
/* Point the LAC OP Data IV pointer to our allocated
storage location for this session. */
drvOpData->lacOpData.pIv = drvOpData->ivData;
if ((crp_desc->crd_flags & CRD_F_ENCRYPT) &&
((crp_desc->crd_flags & CRD_F_IV_PRESENT) == 0)) {
/* Encrypting - need to create IV */
randGenOpData.generateBits = CPA_TRUE;
randGenOpData.lenInBytes = MAX_IV_LEN_IN_BYTES;
icp_ocfDrvPtrAndLenToFlatBuffer((Cpa8U *)
drvOpData->
ivData,
MAX_IV_LEN_IN_BYTES,
&randData);
if (CPA_STATUS_SUCCESS !=
cpaCyRandGen(CPA_INSTANCE_HANDLE_SINGLE,
NULL, NULL,
&randGenOpData, &randData)) {
DPRINTK("%s(): ERROR - Failed to"
" generate"
" Initialisation Vector\n",
__FUNCTION__);
return ICP_OCF_DRV_STATUS_FAIL;
}
crypto_copyback(drvOpData->crp->
crp_flags,
drvOpData->crp->crp_buf,
crp_desc->crd_inject,
drvOpData->lacOpData.
ivLenInBytes,
(caddr_t) (drvOpData->lacOpData.
pIv));
} else {
/* Reading IV from buffer */
crypto_copydata(drvOpData->crp->
crp_flags,
drvOpData->crp->crp_buf,
crp_desc->crd_inject,
drvOpData->lacOpData.
ivLenInBytes,
(caddr_t) (drvOpData->lacOpData.
pIv));
}
}
}
return ICP_OCF_DRV_STATUS_SUCCESS;
}
/* Name : icp_ocfDrvDigestPointerFind
*
* Description : This function is used to find the memory address of where the
* digest information shall be stored in. Input buffer types are an skbuff, iov
* or flat buffer. The address is found using the buffer data start address and
* an offset.
*
* Note: In the case of a linux skbuff, the digest address may exist within
* a memory space linked to from the start buffer. These linked memory spaces
* must be traversed by the data length offset in order to find the digest start
* address. Whether there is enough space for the digest must also be checked.
*/
uint8_t *icp_ocfDrvDigestPointerFind(struct icp_drvOpData * drvOpData,
struct cryptodesc * crp_desc)
{
int offsetInBytes = crp_desc->crd_inject;
uint32_t digestSizeInBytes = drvOpData->digestSizeInBytes;
uint8_t *flat_buffer_base = NULL;
int flat_buffer_length = 0;
if (drvOpData->crp->crp_flags & ICP_CRYPTO_F_PACKET_BUF) {
return icp_ocfDrvPacketBufferDigestPointerFind(drvOpData,
offsetInBytes,
digestSizeInBytes);
} else {
/* IOV or flat buffer */
if (drvOpData->crp->crp_flags & CRYPTO_F_IOV) {
/*single IOV check has already been done */
flat_buffer_base = ((struct uio *)
(drvOpData->crp->crp_buf))->
uio_iov[0].iov_base;
flat_buffer_length = ((struct uio *)
(drvOpData->crp->crp_buf))->
uio_iov[0].iov_len;
} else {
flat_buffer_base = (uint8_t *) drvOpData->crp->crp_buf;
flat_buffer_length = drvOpData->crp->crp_ilen;
}
if (flat_buffer_length < (offsetInBytes + digestSizeInBytes)) {
DPRINTK("%s() Not enough space for Digest "
"(IOV/Flat Buffer) \n", __FUNCTION__);
return NULL;
} else {
return (uint8_t *) (flat_buffer_base + offsetInBytes);
}
}
DPRINTK("%s() Should not reach this point\n", __FUNCTION__);
return NULL;
}