static CpaStatus poll_instances(void)
{
unsigned int poll_loop;
CpaInstanceHandle instanceHandle = NULL;
CpaStatus internal_status = CPA_STATUS_SUCCESS,
ret_status = CPA_STATUS_SUCCESS;
if (enable_instance_for_thread)
instanceHandle = pthread_getspecific(qatInstanceForThread);
if (instanceHandle) {
ret_status = icp_sal_CyPollInstance(instanceHandle, 0);
} else {
for (poll_loop = 0; poll_loop < numInstances; poll_loop++) {
if (qatInstanceHandles[poll_loop] != NULL) {
internal_status =
icp_sal_CyPollInstance(qatInstanceHandles[poll_loop], 0);
if (CPA_STATUS_SUCCESS == internal_status) {
/* Do nothing */
} else if (CPA_STATUS_RETRY == internal_status) {
ret_status = internal_status;
} else {
WARN("WARNING icp_sal_CyPollInstance returned status %d\n", internal_status);
ret_status = internal_status;
break;
}
}
}
}
return ret_status;
}
static void *eventPoll_ns(void *ih)
{
CpaStatus status = 0;
struct epoll_event *events = NULL;
ENGINE_EPOLL_ST* epollst = NULL;
/* Buffer where events are returned */
events = OPENSSL_zalloc(sizeof(struct epoll_event) * MAX_EVENTS);
if (NULL == events) {
WARN("Error allocating events list\n");
goto end;
}
while (keep_polling) {
int n = 0;
int i = 0;
n = epoll_wait(internal_efd, events, MAX_EVENTS, qat_epoll_timeout);
for (i = 0; i < n; ++i) {
if (events[i].events & EPOLLIN) {
/* poll for 0 means process all packets on the ET ring */
epollst = (ENGINE_EPOLL_ST*)events[i].data.ptr;
status = icp_sal_CyPollInstance(qatInstanceHandles[epollst->inst_index], 0);
if (CPA_STATUS_SUCCESS == status) {
/* do nothing */
} else {
WARN("WARNING icp_sal_CyPollInstance returned status %d\n", status);
}
}
}
}
OPENSSL_free(events);
events = 0;
end:
return NULL;
}
/******************************************************************************
* function:
* void *sendPoll_ns(void *ih)
*
* @param ih [IN] - Instance handle
*
* description:
* Poll the QAT instances (nanosleep version)
* NB: Delay in this function is set by default at runtime by an engine
* specific message. If not set then the default is QAT_POLL_PERIOD_IN_NS.
*
******************************************************************************/
static void *sendPoll_ns(void *ih)
{
CpaStatus status = 0;
CpaInstanceHandle instanceHandle;
struct timespec reqTime = { 0 };
struct timespec remTime = { 0 };
unsigned int retry_count = 0; /* to prevent too much time drift */
instanceHandle = (CpaInstanceHandle) ih;
if (NULL == instanceHandle) {
WARN("WARNING sendPoll_ns - instanceHandle is NULL\n");
return NULL;
}
while (keep_polling) {
reqTime.tv_nsec = qat_poll_interval;
/* Poll for 0 means process all packets on the instance */
status = icp_sal_CyPollInstance(instanceHandle, 0);
if (likely
(CPA_STATUS_SUCCESS == status || CPA_STATUS_RETRY == status)) {
/* Do nothing */
} else {
WARN("WARNING icp_sal_CyPollInstance returned status %d\n",
status);
}
retry_count = 0;
do {
retry_count++;
nanosleep(&reqTime, &remTime);
reqTime.tv_sec = remTime.tv_sec;
reqTime.tv_nsec = remTime.tv_nsec;
if (unlikely((errno < 0) && (EINTR != errno))) {
WARN("WARNING nanosleep system call failed: errno %i\n",
errno);
break;
}
}
while ((retry_count <= QAT_CRYPTO_NUM_POLLING_RETRIES)
&& (EINTR == errno));
}
end:
return NULL;
}
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;
}
