int qat_setup_async_event_notification(int notificationNo) { /* We will ignore notificationNo for the moment */ ASYNC_JOB *job; ASYNC_WAIT_CTX *waitctx; OSSL_ASYNC_FD efd; void *custom = NULL; int ret = 0; if ((job = ASYNC_get_current_job()) == NULL) return ret; if ((waitctx = ASYNC_get_wait_ctx(job)) == NULL) return ret; if (ASYNC_WAIT_CTX_get_fd(waitctx, engine_qat_id, &efd, &custom)) { ret = 1; } else { efd = eventfd(0, 0); if (efd == -1) { WARN("Failed to get eventfd = %d\n", errno); return ret; } if ((ret = ASYNC_WAIT_CTX_set_wait_fd(waitctx, engine_qat_id, efd, custom, qat_fd_cleanup)) == 0) { qat_fd_cleanup(waitctx, engine_qat_id, efd, NULL); } } return ret; }
static int afalg_setup_async_event_notification(afalg_aio *aio) { ASYNC_JOB *job; ASYNC_WAIT_CTX *waitctx; void *custom = NULL; int ret; if ((job = ASYNC_get_current_job()) != NULL) { /* Async mode */ waitctx = ASYNC_get_wait_ctx(job); if (waitctx == NULL) { ALG_WARN("%s(%d): ASYNC_get_wait_ctx error", __FILE__, __LINE__); return 0; } /* Get waitfd from ASYNC_WAIT_CTX if it is already set */ ret = ASYNC_WAIT_CTX_get_fd(waitctx, engine_afalg_id, &aio->efd, &custom); if (ret == 0) { /* * waitfd is not set in ASYNC_WAIT_CTX, create a new one * and set it. efd will be signaled when AIO operation completes */ aio->efd = eventfd(0); if (aio->efd == -1) { ALG_PERR("%s(%d): Failed to get eventfd : ", __FILE__, __LINE__); AFALGerr(AFALG_F_AFALG_SETUP_ASYNC_EVENT_NOTIFICATION, AFALG_R_EVENTFD_FAILED); return 0; } ret = ASYNC_WAIT_CTX_set_wait_fd(waitctx, engine_afalg_id, aio->efd, custom, afalg_waitfd_cleanup); if (ret == 0) { ALG_WARN("%s(%d): Failed to set wait fd", __FILE__, __LINE__); close(aio->efd); return 0; } /* make fd non-blocking in async mode */ if (fcntl(aio->efd, F_SETFL, O_NONBLOCK) != 0) { ALG_WARN("%s(%d): Failed to set event fd as NONBLOCKING", __FILE__, __LINE__); } } aio->mode = MODE_ASYNC; } else { /* Sync mode */ aio->efd = eventfd(0); if (aio->efd == -1) { ALG_PERR("%s(%d): Failed to get eventfd : ", __FILE__, __LINE__); AFALGerr(AFALG_F_AFALG_SETUP_ASYNC_EVENT_NOTIFICATION, AFALG_R_EVENTFD_FAILED); return 0; } aio->mode = MODE_SYNC; } return 1; }
static void dummy_pause_job(void) { ASYNC_JOB *job; ASYNC_WAIT_CTX *waitctx; OSSL_ASYNC_FD pipefds[2] = {0, 0}; OSSL_ASYNC_FD *writefd; #if defined(ASYNC_WIN) DWORD numwritten, numread; char buf = DUMMY_CHAR; #elif defined(ASYNC_POSIX) char buf = DUMMY_CHAR; #endif if ((job = ASYNC_get_current_job()) == NULL) return; waitctx = ASYNC_get_wait_ctx(job); if (ASYNC_WAIT_CTX_get_fd(waitctx, engine_dasync_id, &pipefds[0], (void **)&writefd)) { pipefds[1] = *writefd; } else { writefd = OPENSSL_malloc(sizeof(*writefd)); if (writefd == NULL) return; #if defined(ASYNC_WIN) if (CreatePipe(&pipefds[0], &pipefds[1], NULL, 256) == 0) { OPENSSL_free(writefd); return; } #elif defined(ASYNC_POSIX) if (pipe(pipefds) != 0) { OPENSSL_free(writefd); return; } #endif *writefd = pipefds[1]; if(!ASYNC_WAIT_CTX_set_wait_fd(waitctx, engine_dasync_id, pipefds[0], writefd, wait_cleanup)) { wait_cleanup(waitctx, engine_dasync_id, pipefds[0], writefd); return; } } /* * In the Dummy async engine we are cheating. We signal that the job * is complete by waking it before the call to ASYNC_pause_job(). A real * async engine would only wake when the job was actually complete */ #if defined(ASYNC_WIN) WriteFile(pipefds[1], &buf, 1, &numwritten, NULL); #elif defined(ASYNC_POSIX) if (write(pipefds[1], &buf, 1) < 0) return; #endif /* Ignore errors - we carry on anyway */ ASYNC_pause_job(); /* Clear the wake signal */ #if defined(ASYNC_WIN) ReadFile(pipefds[0], &buf, 1, &numread, NULL); #elif defined(ASYNC_POSIX) if (read(pipefds[0], &buf, 1) < 0) return; #endif }