/******************************************************************************
* function:
* CpaStatus myPerformOp(const CpaInstanceHandle instanceHandle,
* void * pCallbackTag,
* const CpaCySymOpData *pOpData,
* const CpaBufferList *pSrcBuffer,
* CpaBufferList *pDstBuffer,
* CpaBoolean *pVerifyResult)
*
* @param ih [IN] - Instance handle
* @param instanceHandle [IN] - Instance handle
* @param pCallbackTag [IN] - Pointer to op_done struct
* @param pOpData [IN] - Operation parameters
* @param pSrcBuffer [IN] - Source buffer list
* @param pDstBuffer [OUT] - Destination buffer list
* @param pVerifyResult [OUT] - Whether hash verified or not
*
* description:
* Wrapper around cpaCySymPerformOp which handles retries for us.
*
******************************************************************************/
CpaStatus myPerformOp(const CpaInstanceHandle instanceHandle,
void *pCallbackTag,
const CpaCySymOpData * pOpData,
const CpaBufferList * pSrcBuffer,
CpaBufferList * pDstBuffer, CpaBoolean * pVerifyResult)
{
CpaStatus status;
struct op_done *opDone = (struct op_done *)pCallbackTag;
unsigned int uiRetry = 0;
do {
status = cpaCySymPerformOp(instanceHandle,
pCallbackTag,
pOpData,
pSrcBuffer, pDstBuffer, pVerifyResult);
if (status == CPA_STATUS_RETRY) {
if (opDone->job) {
if ((qat_wake_job(opDone->job, 0) == 0) ||
(qat_pause_job(opDone->job, 0) == 0)) {
status = CPA_STATUS_FAIL;
break;
}
} else {
qatPerformOpRetries++;
if (uiRetry >= qat_max_retry_count
&& qat_max_retry_count != QAT_INFINITE_MAX_NUM_RETRIES) {
break;
}
uiRetry++;
usleep(qat_poll_interval +
(uiRetry % QAT_RETRY_BACKOFF_MODULO_DIVISOR));
}
}
}
while (status == CPA_STATUS_RETRY);
return status;
}
int
qat_rsa_encrypt(CpaCyRsaEncryptOpData * enc_op_data,
CpaFlatBuffer * output_buf)
{
/* Used for RSA Encrypt and RSA Verify */
struct op_done op_done;
CpaStatus sts = CPA_STATUS_FAIL;
int qatPerformOpRetries = 0;
CpaInstanceHandle instance_handle = NULL;
int job_ret = 0;
int pthread_kill_ret;
int iMsgRetry = getQatMsgRetryCount();
useconds_t ulPollInterval = getQatPollInterval();
DEBUG("- Started\n");
if (qat_use_signals()) {
qat_atomic_inc(num_requests_in_flight);
pthread_kill_ret = pthread_kill(timer_poll_func_thread, SIGUSR1);
if (pthread_kill_ret != 0) {
WARN("pthread_kill error\n");
QATerr(QAT_F_QAT_RSA_ENCRYPT, ERR_R_INTERNAL_ERROR);
qat_atomic_dec(num_requests_in_flight);
return 0;
}
}
qat_init_op_done(&op_done);
if (op_done.job != NULL) {
if (qat_setup_async_event_notification(0) == 0) {
WARN("Failed to setup async event notification\n");
QATerr(QAT_F_QAT_RSA_ENCRYPT, ERR_R_INTERNAL_ERROR);
qat_cleanup_op_done(&op_done);
qat_atomic_dec_if_polling(num_requests_in_flight);
return 0;
}
}
/*
* cpaCyRsaEncrypt() is the function called for RSA verify in the API.
* For that particular case the enc_op_data [IN] contains both the
* public key value and the signature value. The output_buf [OUT]
* stores the message as the output once the request is fully completed.
* The sts return value contains 0 (CPA_STATUS_SUCCESS) if the request
* was successfully submitted.
*/
CRYPTO_QAT_LOG("RSA - %s\n", __func__);
do {
if (NULL == (instance_handle = get_next_inst())) {
WARN("Failed to get an instance\n");
QATerr(QAT_F_QAT_RSA_ENCRYPT, ERR_R_INTERNAL_ERROR);
if (op_done.job != NULL) {
qat_clear_async_event_notification();
}
qat_cleanup_op_done(&op_done);
qat_atomic_dec_if_polling(num_requests_in_flight);
return 0;
}
DUMP_RSA_ENCRYPT(instance_handle, &op_done, enc_op_data, output_buf);
sts = cpaCyRsaEncrypt(instance_handle, qat_rsaCallbackFn, &op_done,
enc_op_data, output_buf);
if (sts == CPA_STATUS_RETRY) {
if (op_done.job == NULL) {
usleep(ulPollInterval +
(qatPerformOpRetries % QAT_RETRY_BACKOFF_MODULO_DIVISOR));
qatPerformOpRetries++;
if (iMsgRetry != QAT_INFINITE_MAX_NUM_RETRIES) {
if (qatPerformOpRetries >= iMsgRetry) {
WARN("No. of retries exceeded max retry : %d\n", iMsgRetry);
break;
}
}
} else {
if ((qat_wake_job(op_done.job, 0) == 0) ||
(qat_pause_job(op_done.job, 0) == 0)) {
WARN("qat_wake_job or qat_pause_job failed\n");
break;
}
}
}
}
while (sts == CPA_STATUS_RETRY);
if (sts != CPA_STATUS_SUCCESS) {
WARN("Failed to submit request to qat - status = %d\n", sts);
QATerr(QAT_F_QAT_RSA_ENCRYPT, ERR_R_INTERNAL_ERROR);
if (op_done.job != NULL) {
qat_clear_async_event_notification();
}
qat_cleanup_op_done(&op_done);
qat_atomic_dec_if_polling(num_requests_in_flight);
return 0;
}
do {
if(op_done.job != NULL) {
/* If we get a failure on qat_pause_job then we will
not flag an error here and quit because we have
an asynchronous request in flight.
We don't want to start cleaning up data
structures that are still being used. If
qat_pause_job fails we will just yield and
loop around and try again until the request
completes and we can continue. */
if ((job_ret = qat_pause_job(op_done.job, 0)) == 0)
pthread_yield();
} else {
if(getEnableInlinePolling()) {
icp_sal_CyPollInstance(instance_handle, 0);
} else {
pthread_yield();
}
}
} while (!op_done.flag ||
QAT_CHK_JOB_RESUMED_UNEXPECTEDLY(job_ret));
DUMP_RSA_ENCRYPT_OUTPUT(output_buf);
qat_cleanup_op_done(&op_done);
qat_atomic_dec_if_polling(num_requests_in_flight);
if (op_done.verifyResult != CPA_TRUE) {
WARN("Verification of result failed\n");
QATerr(QAT_F_QAT_RSA_ENCRYPT, ERR_R_INTERNAL_ERROR);
return 0;
}
return 1;
}
int
qat_rsa_decrypt(CpaCyRsaDecryptOpData * dec_op_data, int rsa_len,
CpaFlatBuffer * output_buf)
{
/* Used for RSA Decrypt and RSA Sign */
struct op_done op_done;
CpaStatus sts = CPA_STATUS_FAIL;
CpaInstanceHandle instance_handle = NULL;
int job_ret = 0;
int sync_mode_ret = 0;
int pthread_kill_ret;
DEBUG("- Started\n");
if (qat_use_signals()) {
qat_atomic_inc(num_requests_in_flight);
pthread_kill_ret = pthread_kill(timer_poll_func_thread, SIGUSR1);
if (pthread_kill_ret != 0) {
WARN("pthread_kill error\n");
QATerr(QAT_F_QAT_RSA_DECRYPT, ERR_R_INTERNAL_ERROR);
qat_atomic_dec(num_requests_in_flight);
return 0;
}
}
qat_init_op_done(&op_done);
if (op_done.job != NULL) {
if (qat_setup_async_event_notification(0) == 0) {
WARN("Failed to setup async event notifications\n");
QATerr(QAT_F_QAT_RSA_DECRYPT, ERR_R_INTERNAL_ERROR);
qat_cleanup_op_done(&op_done);
qat_atomic_dec_if_polling(num_requests_in_flight);
return 0;
}
} else {
/*
* Sync mode
*/
qat_cleanup_op_done(&op_done);
sync_mode_ret = qat_rsa_decrypt_CRT(dec_op_data, rsa_len, output_buf);
qat_atomic_dec_if_polling(num_requests_in_flight);
return sync_mode_ret;
}
/*
* cpaCyRsaDecrypt() is the function called for RSA Sign in the API.
* For that particular case the dec_op_data [IN] contains both the
* private key value and the message (hash) value. The output_buf [OUT]
* stores the signature as the output once the request is fully completed.
* The sts return value contains 0 (CPA_STATUS_SUCCESS) if the request
* was successfully submitted.
*/
CRYPTO_QAT_LOG("- RSA\n");
do {
if (NULL == (instance_handle = get_next_inst())) {
WARN("Failed to get an instance\n");
QATerr(QAT_F_QAT_RSA_DECRYPT, ERR_R_INTERNAL_ERROR);
qat_clear_async_event_notification();
qat_cleanup_op_done(&op_done);
qat_atomic_dec_if_polling(num_requests_in_flight);
return 0;
}
DUMP_RSA_DECRYPT(instance_handle, &op_done, dec_op_data, output_buf);
sts = cpaCyRsaDecrypt(instance_handle, qat_rsaCallbackFn, &op_done,
dec_op_data, output_buf);
if (sts == CPA_STATUS_RETRY) {
if ((qat_wake_job(op_done.job, 0) == 0) ||
(qat_pause_job(op_done.job, 0) == 0)) {
WARN("qat_wake_job or qat_pause_job failed\n");
break;
}
}
}
while (sts == CPA_STATUS_RETRY);
if (sts != CPA_STATUS_SUCCESS) {
WARN("Failed to submit request to qat - status = %d\n", sts);
QATerr(QAT_F_QAT_RSA_DECRYPT, ERR_R_INTERNAL_ERROR);
qat_clear_async_event_notification();
qat_cleanup_op_done(&op_done);
qat_atomic_dec_if_polling(num_requests_in_flight);
return 0;
}
do {
/* If we get a failure on qat_pause_job then we will
not flag an error here and quit because we have
an asynchronous request in flight.
We don't want to start cleaning up data
structures that are still being used. If
qat_pause_job fails we will just yield and
loop around and try again until the request
completes and we can continue. */
if ((job_ret = qat_pause_job(op_done.job, 0)) == 0)
pthread_yield();
}
while (!op_done.flag ||
QAT_CHK_JOB_RESUMED_UNEXPECTEDLY(job_ret));
DUMP_RSA_DECRYPT_OUTPUT(output_buf);
qat_cleanup_op_done(&op_done);
qat_atomic_dec_if_polling(num_requests_in_flight);
if (op_done.verifyResult != CPA_TRUE) {
WARN("Verification of result failed\n");
QATerr(QAT_F_QAT_RSA_DECRYPT, ERR_R_INTERNAL_ERROR);
return 0;
}
DEBUG("- Finished\n");
return 1;
}
