/******************************************************************************
* function:
* qat_engine_init(ENGINE *e)
*
* @param e [IN] - OpenSSL engine pointer
*
* description:
* Qat engine init function, associated with Crypto memory setup
* and cpaStartInstance setups.
******************************************************************************/
static int qat_engine_init(ENGINE *e)
{
int instNum, err, checkLimitStatus;
CpaStatus status = CPA_STATUS_SUCCESS;
CpaBoolean limitDevAccess = CPA_FALSE;
pthread_mutex_lock(&qat_engine_mutex);
if(engine_inited) {
pthread_mutex_unlock(&qat_engine_mutex);
return 1;
}
DEBUG("[%s] ---- Engine Initing\n\n", __func__);
CRYPTO_INIT_QAT_LOG();
if ((err = pthread_key_create(&qatInstanceForThread, NULL)) != 0) {
fprintf(stderr, "pthread_key_create: %s\n", strerror(err));
pthread_mutex_unlock(&qat_engine_mutex);
return 0;
}
checkLimitStatus =
checkLimitDevAccessValue((int *)&limitDevAccess,
ICPConfigSectionName_libcrypto);
if (!checkLimitStatus) {
WARN("Assuming LimitDevAccess = 0\n");
}
/* Initialise the QAT hardware */
if (CPA_STATUS_SUCCESS !=
icp_sal_userStartMultiProcess(ICPConfigSectionName_libcrypto,
limitDevAccess)) {
WARN("icp_sal_userStart failed\n");
pthread_mutex_unlock(&qat_engine_mutex);
return 0;
}
/* Get the number of available instances */
status = cpaCyGetNumInstances(&numInstances);
if (CPA_STATUS_SUCCESS != status) {
WARN("cpaCyGetNumInstances failed, status=%d\n", status);
pthread_mutex_unlock(&qat_engine_mutex);
qat_engine_finish(e);
return 0;
}
if (!numInstances) {
WARN("No crypto instances found\n");
pthread_mutex_unlock(&qat_engine_mutex);
qat_engine_finish(e);
return 0;
}
DEBUG("%s: %d Cy instances got\n", __func__, numInstances);
/* Allocate memory for the instance handle array */
qatInstanceHandles =
(CpaInstanceHandle *) OPENSSL_zalloc(((int)numInstances) *
sizeof(CpaInstanceHandle));
if (NULL == qatInstanceHandles) {
WARN("OPENSSL_zalloc() failed for instance handles.\n");
pthread_mutex_unlock(&qat_engine_mutex);
qat_engine_finish(e);
return 0;
}
/* Get the Cy instances */
status = cpaCyGetInstances(numInstances, qatInstanceHandles);
if (CPA_STATUS_SUCCESS != status) {
WARN("cpaCyGetInstances failed, status=%d\n", status);
pthread_mutex_unlock(&qat_engine_mutex);
qat_engine_finish(e);
return 0;
}
if (0 == enable_external_polling) {
if (qat_is_event_driven()) {
CpaStatus status;
int flags;
int engine_fd;
icp_polling_threads =
(pthread_t *) OPENSSL_zalloc(sizeof(pthread_t));
/* Add the file descriptor to an epoll event list */
internal_efd = epoll_create1(0);
if (-1 == internal_efd) {
WARN("Error creating epoll fd\n");
pthread_mutex_unlock(&qat_engine_mutex);
qat_engine_finish(e);
return 0;
}
for (instNum = 0; instNum < numInstances; instNum++) {
/* Get the file descriptor for the instance */
status =
icp_sal_CyGetFileDescriptor(qatInstanceHandles[instNum],
&engine_fd);
if (CPA_STATUS_FAIL == status) {
WARN("Error getting file descriptor for instance\n");
pthread_mutex_unlock(&qat_engine_mutex);
qat_engine_finish(e);
return 0;
}
/* Make the file descriptor non-blocking */
eng_poll_st[instNum].eng_fd = engine_fd;
eng_poll_st[instNum].inst_index = instNum;
flags = fcntl(engine_fd, F_GETFL, 0);
fcntl(engine_fd, F_SETFL, flags | O_NONBLOCK);
eng_epoll_events[instNum].data.ptr = &eng_poll_st[instNum];
eng_epoll_events[instNum].events = EPOLLIN | EPOLLET;
if (-1 ==
epoll_ctl(internal_efd, EPOLL_CTL_ADD, engine_fd,
&eng_epoll_events[instNum])) {
WARN("Error adding fd to epoll\n");
pthread_mutex_unlock(&qat_engine_mutex);
qat_engine_finish(e);
return 0;
}
}
} else {
icp_polling_threads =
(pthread_t *) OPENSSL_zalloc(((int)numInstances) *
sizeof(pthread_t));
}
if (NULL == icp_polling_threads) {
WARN("OPENSSL_malloc() failed for icp_polling_threads.\n");
pthread_mutex_unlock(&qat_engine_mutex);
qat_engine_finish(e);
return 0;
}
}
/* Set translation function and start each instance */
for (instNum = 0; instNum < numInstances; instNum++) {
/* Set the address translation function */
status = cpaCySetAddressTranslation(qatInstanceHandles[instNum],
virtualToPhysical);
if (CPA_STATUS_SUCCESS != status) {
WARN("cpaCySetAddressTranslation failed, status=%d\n", status);
pthread_mutex_unlock(&qat_engine_mutex);
qat_engine_finish(e);
return 0;
}
/* Start the instances */
status = cpaCyStartInstance(qatInstanceHandles[instNum]);
if (CPA_STATUS_SUCCESS != status) {
WARN("cpaCyStartInstance failed, status=%d\n", status);
pthread_mutex_unlock(&qat_engine_mutex);
qat_engine_finish(e);
return 0;
}
if (0 == enable_external_polling && !qat_is_event_driven()) {
/* Create the polling threads */
if (qat_create_thread(&icp_polling_threads[instNum], NULL,
sendPoll_ns, qatInstanceHandles[instNum])) {
WARN("Polling thread create failed\n");
instance_started[instNum] = 1;
pthread_mutex_unlock(&qat_engine_mutex);
qat_engine_finish(e);
return 0;
}
if (qat_adjust_thread_affinity(icp_polling_threads[instNum]) == 0) {
instance_started[instNum] = 1;
pthread_mutex_unlock(&qat_engine_mutex);
qat_engine_finish(e);
return 0;
}
}
instance_started[instNum] = 1;
}
if (0 == enable_external_polling && qat_is_event_driven()) {
if (qat_create_thread(&icp_polling_threads[0], NULL, eventPoll_ns, NULL)) {
WARN("Epoll thread create failed\n");
pthread_mutex_unlock(&qat_engine_mutex);
qat_engine_finish(e);
return 0;
}
if (qat_adjust_thread_affinity(icp_polling_threads[0]) == 0) {
pthread_mutex_unlock(&qat_engine_mutex);
qat_engine_finish(e);
return 0;
}
}
/* Reset currInst */
currInst = 0;
engine_inited = 1;
pthread_mutex_unlock(&qat_engine_mutex);
return 1;
}
static int
qat_engine_ctrl(ENGINE *e, int cmd, long i, void *p, void (*f) (void))
{
unsigned int retVal = 1;
CpaStatus status = CPA_STATUS_SUCCESS;
int flags = 0;
int fd = 0;
switch (cmd) {
case QAT_CMD_POLL:
BREAK_IF(!engine_inited, "POLL failed as engine is not initialized\n");
BREAK_IF(qat_instance_handles == NULL, "POLL failed as no instances are available\n");
BREAK_IF(!enable_external_polling, "POLL failed as external polling is not enabled\n");
BREAK_IF(p == NULL, "POLL failed as the input parameter was NULL\n");
*(int *)p = (int)poll_instances();
break;
case QAT_CMD_ENABLE_EXTERNAL_POLLING:
BREAK_IF(engine_inited, \
"ENABLE_EXTERNAL_POLLING failed as the engine is already initialized\n");
DEBUG("Enabled external polling\n");
enable_external_polling = 1;
enable_inline_polling = 0;
break;
case QAT_CMD_ENABLE_INLINE_POLLING:
BREAK_IF(engine_inited, \
"ENABLE_INLINE_POLLING failed as the engine is already initialized\n");
DEBUG("Enabled inline polling\n");
enable_inline_polling = 1;
enable_external_polling = 0;
break;
case QAT_CMD_GET_EXTERNAL_POLLING_FD:
BREAK_IF(!enable_event_driven_polling || !enable_external_polling, \
"GET_EXTERNAL_POLLING_FD failed as this engine message is only supported \
when running in Event Driven Mode with External Polling enabled\n");
BREAK_IF(!engine_inited, \
"GET_EXTERNAL_POLLING_FD failed as the engine is not initialized\n");
BREAK_IF(qat_instance_handles == NULL, \
"GET_EXTERNAL_POLLING_FD failed as no instances are available\n");
BREAK_IF(p == NULL, "GET_EXTERNAL_POLLING_FD failed as the input parameter was NULL\n");
BREAK_IF(i >= qat_num_instances, \
"GET_EXTERNAL_POLLING_FD failed as the instance does not exist\n");
/* Get the file descriptor for the instance */
status = icp_sal_CyGetFileDescriptor(qat_instance_handles[i], &fd);
BREAK_IF(CPA_STATUS_FAIL == status, \
"GET_EXTERNAL_POLLING_FD failed as there was an error retrieving the fd\n");
/* Make the file descriptor non-blocking */
flags = fcntl(fd, F_GETFL, 0);
fcntl(fd, F_SETFL, flags | O_NONBLOCK);
DEBUG("External polling FD for instance[%ld] = %d\n", i, fd);
*(int *)p = fd;
break;
case QAT_CMD_ENABLE_EVENT_DRIVEN_POLLING_MODE:
DEBUG("Enabled event driven polling mode\n");
BREAK_IF(engine_inited, \
"ENABLE_EVENT_DRIVEN_POLLING_MODE failed as the engine is already initialized\n");
enable_event_driven_polling = 1;
break;
case QAT_CMD_DISABLE_EVENT_DRIVEN_POLLING_MODE:
DEBUG("Disabled event driven polling mode\n");
BREAK_IF(engine_inited, \
"DISABLE_EVENT_DRIVEN_POLLING_MODE failed as the engine is already initialized\n");
enable_event_driven_polling = 0;
break;
case QAT_CMD_SET_INSTANCE_FOR_THREAD:
BREAK_IF(!engine_inited, \
"SET_INSTANCE_FOR_THREAD failed as the engine is not initialized\n");
BREAK_IF(qat_instance_handles == NULL, \
"SET_INSTANCE_FOR_THREAD failed as no instances are available\n");
DEBUG("Set instance for thread = %ld\n", i);
qat_set_instance_for_thread(i);
break;
case QAT_CMD_GET_NUM_OP_RETRIES:
BREAK_IF(p == NULL, "GET_NUM_OP_RETRIES failed as the input parameter was NULL\n");
BREAK_IF(!engine_inited, "GET_NUM_OP_RETRIES failed as the engine is not initialized\n");
*(int *)p = qatPerformOpRetries;
break;
case QAT_CMD_SET_MAX_RETRY_COUNT:
BREAK_IF(i < -1 || i > 100000,
"The Message retry count value is out of range, using default value\n");
DEBUG("Set max retry counter = %ld\n", i);
qat_max_retry_count = (int)i;
break;
case QAT_CMD_SET_INTERNAL_POLL_INTERVAL:
BREAK_IF(i < 1 || i > 1000000,
"The polling interval value is out of range, using default value\n");
DEBUG("Set internal poll interval = %ld ns\n", i);
qat_poll_interval = (useconds_t) i;
break;
case QAT_CMD_SET_EPOLL_TIMEOUT:
BREAK_IF(i < 1 || i > 10000,
"The epoll timeout value is out of range, using default value\n")
DEBUG("Set epoll_wait timeout = %ld ms\n", i);
qat_epoll_timeout = (int) i;
break;
case QAT_CMD_GET_NUM_CRYPTO_INSTANCES:
BREAK_IF(p == NULL, \
"GET_NUM_CRYPTO_INSTANCES failed as the input parameter was NULL\n");
BREAK_IF(!engine_inited, \
"GET_NUM_CRYPTO_INSTANCES failed as the engine is not initialized\n");
BREAK_IF(qat_instance_handles == NULL, \
"GET_NUM_CRYPTO_INSTANCES failed as no instances are available\n");
DEBUG("Get number of crypto instances = %d\n", qat_num_instances);
*(int *)p = qat_num_instances;
break;
case QAT_CMD_SET_CRYPTO_SMALL_PACKET_OFFLOAD_THRESHOLD:
#ifndef OPENSSL_ENABLE_QAT_SMALL_PACKET_CIPHER_OFFLOADS
if(p) {
char *token;
char str_p[1024];
char *itr = str_p;
strncpy(str_p, (const char *)p, 1024);
while((token = strsep(&itr, ","))) {
char *name_token = strsep(&token,":");
char *value_token = strsep(&token,":");
if(name_token && value_token) {
retVal = qat_pkt_threshold_table_set_threshold(
name_token, atoi(value_token));
} else {
WARN("Invalid name_token or value_token\n");
retVal = 0;
}
}
} else {
WARN("Invalid p parameter\n");
retVal = 0;
}
#else
WARN("QAT_CMD_SET_CRYPTO_SMALL_PACKET_OFFLOAD_THRESHOLD is not supported\n");
retVal = 0;
#endif
break;
default:
WARN("CTRL command not implemented\n");
retVal = 0;
break;
}
if(!retVal) {
QATerr(QAT_F_QAT_ENGINE_CTRL, QAT_R_ENGINE_CTRL_CMD_FAILURE);
}
return retVal;
}
static int
qat_engine_ctrl(ENGINE *e, int cmd, long i, void *p, void (*f) (void))
{
unsigned int retVal = 1;
CpaStatus status = CPA_STATUS_SUCCESS;
int flags = 0;
int fd = 0;
switch (cmd) {
case QAT_CMD_POLL:
if (qatInstanceHandles == NULL) {
/*
* It is possible to call this ctrl function while the engine is
* in a state where there are no instances available. This
* happens for example immediately when the engine is waiting
* for get_next_inst() to be called.
*
* To avoid this condition we call get_next_inst()
*/
get_next_inst();
BREAK_IF(qatInstanceHandles == NULL, "POLL failed as no instances are available\n");
}
BREAK_IF(!engine_inited, "POLL failed as engine is not initialized\n");
BREAK_IF(!enable_external_polling, "POLL failed as external polling is not enabled\n");
BREAK_IF(p == NULL, "POLL failed as the input parameter was NULL\n");
*(int *)p = (int)poll_instances();
break;
case QAT_CMD_ENABLE_EXTERNAL_POLLING:
BREAK_IF(engine_inited, \
"ENABLE_EXTERNAL_POLLING failed as the engine is already initialized\n");
DEBUG("[%s] Enabled external polling\n", __func__);
enable_external_polling = 1;
break;
case QAT_CMD_GET_EXTERNAL_POLLING_FD:
BREAK_IF(!enable_event_driven_polling || !enable_external_polling, \
"GET_EXTERNAL_POLLING_FD failed as this engine message is only supported \
when running in Event Driven Mode with External Polling enabled\n");
if (qatInstanceHandles == NULL) {
get_next_inst();
BREAK_IF(qatInstanceHandles == NULL, \
"GET_EXTERNAL_POLLING_FD failed as no instances are available\n");
}
BREAK_IF(!engine_inited, \
"GET_EXTERNAL_POLLING_FD failed as the engine is not initialized\n");
BREAK_IF(p == NULL, "GET_EXTERNAL_POLLING_FD failed as the input parameter was NULL\n");
BREAK_IF(i >= numInstances, \
"GET_EXTERNAL_POLLING_FD failed as the instance does not exist\n");
/* Get the file descriptor for the instance */
status = icp_sal_CyGetFileDescriptor(qatInstanceHandles[i], &fd);
BREAK_IF(CPA_STATUS_FAIL == status, \
"GET_EXTERNAL_POLLING_FD failed as there was an error retrieving the fd\n");
/* Make the file descriptor non-blocking */
flags = fcntl(fd, F_GETFL, 0);
fcntl(fd, F_SETFL, flags | O_NONBLOCK);
DEBUG("[%s] External polling FD for instance[%d] = %d\n", __func__, i, fd);
*(int *)p = fd;
break;
case QAT_CMD_ENABLE_EVENT_DRIVEN_POLLING_MODE:
DEBUG("[%s] Enabled event driven polling mode\n", __func__);
BREAK_IF(engine_inited, \
"ENABLE_EVENT_DRIVEN_POLLING_MODE failed as the engine is already initialized\n");
enable_event_driven_polling = 1;
break;
case QAT_CMD_DISABLE_EVENT_DRIVEN_POLLING_MODE:
DEBUG("[%s] Disabled event driven polling mode\n", __func__);
BREAK_IF(engine_inited, \
"DISABLE_EVENT_DRIVEN_POLLING_MODE failed as the engine is already initialized\n");
enable_event_driven_polling = 0;
break;
case QAT_CMD_SET_INSTANCE_FOR_THREAD:
if (qatInstanceHandles == NULL) {
get_next_inst();
BREAK_IF(qatInstanceHandles == NULL, \
"SET_INSTANCE_FOR_THREAD failed as no instances are available\n");
}
BREAK_IF(!engine_inited, \
"SET_INSTANCE_FOR_THREAD failed as the engine is not initialized\n");
DEBUG("[%s] Set instance for thread = %d\n", __func__, i);
qat_set_instance_for_thread(i);
break;
case QAT_CMD_GET_NUM_OP_RETRIES:
BREAK_IF(p == NULL, "GET_NUM_OP_RETRIES failed as the input parameter was NULL\n");
BREAK_IF(!engine_inited, "GET_NUM_OP_RETRIES failed as the engine is not initialized\n");
*(int *)p = qatPerformOpRetries;
break;
case QAT_CMD_SET_MAX_RETRY_COUNT:
BREAK_IF(i < -1 || i > 100000,
"The Message retry count value is out of range, using default value\n");
DEBUG("[%s] Set max retry counter = %d\n", __func__, i);
qat_max_retry_count = (int)i;
break;
case QAT_CMD_SET_INTERNAL_POLL_INTERVAL:
BREAK_IF(i < 1 || i > 1000000,
"The polling interval value is out of range, using default value\n");
DEBUG("[%s] Set internal poll interval = %d ns\n", __func__, i);
qat_poll_interval = (useconds_t) i;
break;
case QAT_CMD_SET_EPOLL_TIMEOUT:
BREAK_IF(i < 1 || i > 10000,
"The epoll timeout value is out of range, using default value\n")
DEBUG("[%s] Set epoll_wait timeout = %d ms\n", __func__, i);
qat_epoll_timeout = (int) i;
break;
case QAT_CMD_GET_NUM_CRYPTO_INSTANCES:
BREAK_IF(p == NULL, \
"GET_NUM_CRYPTO_INSTANCES failed as the input parameter was NULL\n");
if (qatInstanceHandles == NULL) {
get_next_inst();
BREAK_IF(qatInstanceHandles == NULL, \
"GET_NUM_CRYPTO_INSTANCES failed as no instances are available\n");
}
BREAK_IF(!engine_inited, \
"GET_NUM_CRYPTO_INSTANCES failed as the engine is not initialized\n");
DEBUG("[%s] Get number of crypto instances = %d\n", __func__, numInstances);
*(int *)p = numInstances;
break;
case QAT_CMD_SET_CRYPTO_SMALL_PACKET_OFFLOAD_THRESHOLD:
#ifndef OPENSSL_ENABLE_QAT_SMALL_PACKET_CIPHER_OFFLOADS
if(p) {
char *token;
while((token = strsep((char **)&p, ","))) {
char *name_token = strsep(&token,":");
char *value_token = strsep(&token,":");
if(name_token && value_token) {
retVal = setQatSmallPacketThreshold(name_token, atoi(value_token));
} else {
WARN("Invalid parameter!\n");
retVal = 0;
}
}
} else {
WARN("Invalid parameter!\n");
retVal = 0;
}
#else
WARN("QAT_CMD_SET_CRYPTO_SMALL_PACKET_OFFLOAD_THRESHOLD is not supported\n");
retVal = 0;
#endif
break;
default:
WARN("CTRL command not implemented\n");
retVal = 0;
break;
}
return retVal;
}
int qat_engine_init(ENGINE *e)
{
int instNum, err;
CpaStatus status = CPA_STATUS_SUCCESS;
CpaBoolean limitDevAccess = CPA_FALSE;
int ret_pthread_sigmask;
pthread_mutex_lock(&qat_engine_mutex);
if(engine_inited) {
pthread_mutex_unlock(&qat_engine_mutex);
return 1;
}
DEBUG("QAT Engine initialization:\n");
DEBUG("- External polling: %s\n", enable_external_polling ? "ON": "OFF");
DEBUG("- Inline polling: %s\n", enable_inline_polling ? "ON": "OFF");
DEBUG("- Internal poll interval: %dns\n", qat_poll_interval);
DEBUG("- Epoll timeout: %dms\n", qat_epoll_timeout);
DEBUG("- Event driven polling mode: %s\n", enable_event_driven_polling ? "ON": "OFF");
DEBUG("- Instance for thread: %s\n", enable_instance_for_thread ? "ON": "OFF");
DEBUG("- Max retry count: %d\n", qat_max_retry_count);
CRYPTO_INIT_QAT_LOG();
polling_thread = pthread_self();
if ((err = pthread_key_create(&qatInstanceForThread, NULL)) != 0) {
WARN("pthread_key_create failed: %s\n", strerror(err));
QATerr(QAT_F_QAT_ENGINE_INIT, QAT_R_PTHREAD_CREATE_FAILURE);
pthread_mutex_unlock(&qat_engine_mutex);
return 0;
}
#ifndef OPENSSL_ENABLE_QAT_UPSTREAM_DRIVER
/* limitDevAccess is passed as an input to icp_sal_userStartMultiProcess().
* However, in upstream driver the value is ignored and read directly from
* the configuration file -> No need to parse the file here.
*/
if (!checkLimitDevAccessValue((int *)&limitDevAccess,
ICPConfigSectionName_libcrypto)) {
WARN("Could not load driver config file. Assuming LimitDevAccess = 0\n");
}
#endif
/* Initialise the QAT hardware */
if (CPA_STATUS_SUCCESS !=
icp_sal_userStartMultiProcess(ICPConfigSectionName_libcrypto,
limitDevAccess)) {
WARN("icp_sal_userStart failed\n");
QATerr(QAT_F_QAT_ENGINE_INIT, QAT_R_ICP_SAL_USERSTART_FAIL);
pthread_mutex_unlock(&qat_engine_mutex);
return 0;
}
/* Get the number of available instances */
status = cpaCyGetNumInstances(&qat_num_instances);
if (CPA_STATUS_SUCCESS != status) {
WARN("cpaCyGetNumInstances failed, status=%d\n", status);
QATerr(QAT_F_QAT_ENGINE_INIT, QAT_R_GET_NUM_INSTANCE_FAILURE);
pthread_mutex_unlock(&qat_engine_mutex);
qat_engine_finish(e);
return 0;
}
if (!qat_num_instances) {
WARN("No crypto instances found\n");
QATerr(QAT_F_QAT_ENGINE_INIT, QAT_R_INSTANCE_UNAVAILABLE);
pthread_mutex_unlock(&qat_engine_mutex);
qat_engine_finish(e);
return 0;
}
DEBUG("Found %d Cy instances\n", qat_num_instances);
/* Allocate memory for the instance handle array */
qat_instance_handles =
(CpaInstanceHandle *) OPENSSL_zalloc(((int)qat_num_instances) *
sizeof(CpaInstanceHandle));
if (NULL == qat_instance_handles) {
WARN("OPENSSL_zalloc() failed for instance handles.\n");
QATerr(QAT_F_QAT_ENGINE_INIT, QAT_R_INSTANCE_HANDLE_MALLOC_FAILURE);
pthread_mutex_unlock(&qat_engine_mutex);
qat_engine_finish(e);
return 0;
}
/* Get the Cy instances */
status = cpaCyGetInstances(qat_num_instances, qat_instance_handles);
if (CPA_STATUS_SUCCESS != status) {
WARN("cpaCyGetInstances failed, status=%d\n", status);
QATerr(QAT_F_QAT_ENGINE_INIT, QAT_R_GET_INSTANCE_FAILURE);
pthread_mutex_unlock(&qat_engine_mutex);
qat_engine_finish(e);
return 0;
}
if (!enable_external_polling && !enable_inline_polling) {
if (qat_is_event_driven()) {
CpaStatus status;
int flags;
int engine_fd;
/* Add the file descriptor to an epoll event list */
internal_efd = epoll_create1(0);
if (-1 == internal_efd) {
WARN("Error creating epoll fd\n");
QATerr(QAT_F_QAT_ENGINE_INIT, QAT_R_EPOLL_CREATE_FAILURE);
pthread_mutex_unlock(&qat_engine_mutex);
qat_engine_finish(e);
return 0;
}
for (instNum = 0; instNum < qat_num_instances; instNum++) {
/* Get the file descriptor for the instance */
status =
icp_sal_CyGetFileDescriptor(qat_instance_handles[instNum],
&engine_fd);
if (CPA_STATUS_FAIL == status) {
WARN("Error getting file descriptor for instance\n");
QATerr(QAT_F_QAT_ENGINE_INIT, QAT_R_GET_FILE_DESCRIPTOR_FAILURE);
pthread_mutex_unlock(&qat_engine_mutex);
qat_engine_finish(e);
return 0;
}
/* Make the file descriptor non-blocking */
eng_poll_st[instNum].eng_fd = engine_fd;
eng_poll_st[instNum].inst_index = instNum;
flags = fcntl(engine_fd, F_GETFL, 0);
fcntl(engine_fd, F_SETFL, flags | O_NONBLOCK);
eng_epoll_events[instNum].data.ptr = &eng_poll_st[instNum];
eng_epoll_events[instNum].events = EPOLLIN | EPOLLET;
if (-1 ==
epoll_ctl(internal_efd, EPOLL_CTL_ADD, engine_fd,
&eng_epoll_events[instNum])) {
WARN("Error adding fd to epoll\n");
QATerr(QAT_F_QAT_ENGINE_INIT, QAT_R_EPOLL_CTL_FAILURE);
pthread_mutex_unlock(&qat_engine_mutex);
qat_engine_finish(e);
return 0;
}
}
}
}
/* Set translation function and start each instance */
for (instNum = 0; instNum < qat_num_instances; instNum++) {
/* Set the address translation function */
status = cpaCySetAddressTranslation(qat_instance_handles[instNum],
virtualToPhysical);
if (CPA_STATUS_SUCCESS != status) {
WARN("cpaCySetAddressTranslation failed, status=%d\n", status);
QATerr(QAT_F_QAT_ENGINE_INIT, QAT_R_SET_ADDRESS_TRANSLATION_FAILURE);
pthread_mutex_unlock(&qat_engine_mutex);
qat_engine_finish(e);
return 0;
}
/* Start the instances */
status = cpaCyStartInstance(qat_instance_handles[instNum]);
if (CPA_STATUS_SUCCESS != status) {
WARN("cpaCyStartInstance failed, status=%d\n", status);
QATerr(QAT_F_QAT_ENGINE_INIT, QAT_R_START_INSTANCE_FAILURE);
pthread_mutex_unlock(&qat_engine_mutex);
qat_engine_finish(e);
return 0;
}
instance_started[instNum] = 1;
}
if (!enable_external_polling && !enable_inline_polling) {
if (!qat_is_event_driven()) {
sigemptyset(&set);
sigaddset(&set, SIGUSR1);
ret_pthread_sigmask = pthread_sigmask(SIG_BLOCK, &set, NULL);
if (ret_pthread_sigmask != 0) {
WARN("pthread_sigmask error\n");
QATerr(QAT_F_QAT_ENGINE_INIT, QAT_R_POLLING_THREAD_SIGMASK_FAILURE);
pthread_mutex_unlock(&qat_engine_mutex);
qat_engine_finish(e);
return 0;
}
}
if (qat_create_thread(&polling_thread, NULL,
qat_is_event_driven() ? event_poll_func : timer_poll_func, NULL)) {
WARN("Creation of polling thread failed\n");
QATerr(QAT_F_QAT_ENGINE_INIT, QAT_R_POLLING_THREAD_CREATE_FAILURE);
polling_thread = pthread_self();
pthread_mutex_unlock(&qat_engine_mutex);
qat_engine_finish(e);
return 0;
}
if (qat_adjust_thread_affinity(polling_thread) == 0) {
WARN("Setting polling thread affinity failed\n");
QATerr(QAT_F_QAT_ENGINE_INIT, QAT_R_SET_POLLING_THREAD_AFFINITY_FAILURE);
pthread_mutex_unlock(&qat_engine_mutex);
qat_engine_finish(e);
return 0;
}
if (!qat_is_event_driven()) {
while (!cleared_to_start)
sleep(1);
}
}
/* Reset curr_inst */
curr_inst = 0;
engine_inited = 1;
pthread_mutex_unlock(&qat_engine_mutex);
return 1;
}
