RTDECL(int) RTFileAioCtxSubmit(RTFILEAIOCTX hAioCtx, PRTFILEAIOREQ pahReqs, size_t cReqs)
{
/*
* Parameter validation.
*/
int rc = VINF_SUCCESS;
PRTFILEAIOCTXINTERNAL pCtxInt = hAioCtx;
RTFILEAIOCTX_VALID_RETURN(pCtxInt);
AssertReturn(cReqs > 0, VERR_INVALID_PARAMETER);
Assert(cReqs <= INT32_MAX);
AssertPtrReturn(pahReqs, VERR_INVALID_POINTER);
size_t i;
for (i = 0; i < cReqs; i++)
{
PRTFILEAIOREQINTERNAL pReqInt = pahReqs[i];
BOOL fSucceeded;
Assert(pReqInt->cbTransfer == (DWORD)pReqInt->cbTransfer);
if (pReqInt->enmTransferDirection == TRANSFERDIRECTION_READ)
{
fSucceeded = ReadFile(pReqInt->hFile, pReqInt->pvBuf,
(DWORD)pReqInt->cbTransfer, NULL,
&pReqInt->Overlapped);
}
else if (pReqInt->enmTransferDirection == TRANSFERDIRECTION_WRITE)
{
fSucceeded = WriteFile(pReqInt->hFile, pReqInt->pvBuf,
(DWORD)pReqInt->cbTransfer, NULL,
&pReqInt->Overlapped);
}
else
{
fSucceeded = false;
AssertMsgFailed(("Invalid transfer direction\n"));
}
if (RT_UNLIKELY(!fSucceeded && GetLastError() != ERROR_IO_PENDING))
{
RTFILEAIOREQ_SET_STATE(pReqInt, COMPLETED);
rc = RTErrConvertFromWin32(GetLastError());
pReqInt->Rc = rc;
break;
}
RTFILEAIOREQ_SET_STATE(pReqInt, SUBMITTED);
}
ASMAtomicAddS32(&pCtxInt->cRequests, (int32_t)i);
return rc;
}
RTDECL(int) RTFileAioReqCancel(RTFILEAIOREQ hReq)
{
PRTFILEAIOREQINTERNAL pReqInt = hReq;
RTFILEAIOREQ_VALID_RETURN(pReqInt);
RTFILEAIOREQ_STATE_RETURN_RC(pReqInt, SUBMITTED, VERR_FILE_AIO_NOT_SUBMITTED);
LNXKAIOIOEVENT AioEvent;
int rc = rtFileAsyncIoLinuxCancel(pReqInt->AioContext, &pReqInt->AioCB, &AioEvent);
if (RT_SUCCESS(rc))
{
/*
* Decrement request count because the request will never arrive at the
* completion port.
*/
AssertMsg(VALID_PTR(pReqInt->pCtxInt),
("Invalid state. Request was canceled but wasn't submitted\n"));
ASMAtomicDecS32(&pReqInt->pCtxInt->cRequests);
pReqInt->Rc = VERR_FILE_AIO_CANCELED;
RTFILEAIOREQ_SET_STATE(pReqInt, COMPLETED);
return VINF_SUCCESS;
}
if (rc == VERR_TRY_AGAIN)
return VERR_FILE_AIO_IN_PROGRESS;
return rc;
}
/**
* Worker setting up the request.
*/
DECLINLINE(int) rtFileAioReqPrepareTransfer(RTFILEAIOREQ hReq, RTFILE hFile,
uint16_t uTransferDirection,
RTFOFF off, void *pvBuf, size_t cbTransfer,
void *pvUser)
{
/*
* Validate the input.
*/
PRTFILEAIOREQINTERNAL pReqInt = hReq;
RTFILEAIOREQ_VALID_RETURN(pReqInt);
RTFILEAIOREQ_NOT_STATE_RETURN_RC(pReqInt, SUBMITTED, VERR_FILE_AIO_IN_PROGRESS);
Assert(hFile != NIL_RTFILE);
if (uTransferDirection != LNXKAIO_IOCB_CMD_FSYNC)
{
AssertPtr(pvBuf);
Assert(off >= 0);
Assert(cbTransfer > 0);
}
/*
* Setup the control block and clear the finished flag.
*/
pReqInt->AioCB.u16IoOpCode = uTransferDirection;
pReqInt->AioCB.uFileDesc = RTFileToNative(hFile);
pReqInt->AioCB.off = off;
pReqInt->AioCB.cbTransfer = cbTransfer;
pReqInt->AioCB.pvBuf = pvBuf;
pReqInt->AioCB.pvUser = pvUser;
pReqInt->pCtxInt = NULL;
RTFILEAIOREQ_SET_STATE(pReqInt, PREPARED);
return VINF_SUCCESS;
}
/**
* Worker setting up the request.
*/
DECLINLINE(int) rtFileAioReqPrepareTransfer(RTFILEAIOREQ hReq, RTFILE hFile,
unsigned uTransferDirection,
RTFOFF off, void *pvBuf, size_t cbTransfer,
void *pvUser)
{
/*
* Validate the input.
*/
PRTFILEAIOREQINTERNAL pReqInt = hReq;
RTFILEAIOREQ_VALID_RETURN(pReqInt);
RTFILEAIOREQ_NOT_STATE_RETURN_RC(pReqInt, SUBMITTED, VERR_FILE_AIO_IN_PROGRESS);
Assert(hFile != NIL_RTFILE);
AssertPtr(pvBuf);
Assert(off >= 0);
Assert(cbTransfer > 0);
memset(&pReqInt->AioCB, 0, sizeof(struct aiocb));
pReqInt->fFlush = false;
pReqInt->AioCB.aio_lio_opcode = uTransferDirection;
pReqInt->AioCB.aio_fildes = RTFileToNative(hFile);
pReqInt->AioCB.aio_offset = off;
pReqInt->AioCB.aio_nbytes = cbTransfer;
pReqInt->AioCB.aio_buf = pvBuf;
pReqInt->pvUser = pvUser;
pReqInt->pCtxInt = NULL;
pReqInt->Rc = VERR_FILE_AIO_IN_PROGRESS;
RTFILEAIOREQ_SET_STATE(pReqInt, PREPARED);
return VINF_SUCCESS;
}
RTDECL(int) RTFileAioReqCancel(RTFILEAIOREQ hReq)
{
PRTFILEAIOREQINTERNAL pReqInt = hReq;
RTFILEAIOREQ_VALID_RETURN(pReqInt);
RTFILEAIOREQ_STATE_RETURN_RC(pReqInt, SUBMITTED, VERR_FILE_AIO_NOT_SUBMITTED);
int rcBSD = aio_cancel(pReqInt->AioCB.aio_fildes, &pReqInt->AioCB);
if (rcBSD == AIO_CANCELED)
{
/*
* Decrement request count because the request will never arrive at the
* completion port.
*/
AssertMsg(VALID_PTR(pReqInt->pCtxInt),
("Invalid state. Request was canceled but wasn't submitted\n"));
ASMAtomicDecS32(&pReqInt->pCtxInt->cRequests);
pReqInt->Rc = VERR_FILE_AIO_CANCELED;
RTFILEAIOREQ_SET_STATE(pReqInt, COMPLETED);
return VINF_SUCCESS;
}
else if (rcBSD == AIO_ALLDONE)
return VERR_FILE_AIO_COMPLETED;
else if (rcBSD == AIO_NOTCANCELED)
return VERR_FILE_AIO_IN_PROGRESS;
else
return RTErrConvertFromErrno(errno);
}
RTR3DECL(int) RTFileAioReqCreate(PRTFILEAIOREQ phReq)
{
AssertPtrReturn(phReq, VERR_INVALID_POINTER);
PRTFILEAIOREQINTERNAL pReqInt = (PRTFILEAIOREQINTERNAL)RTMemAllocZ(sizeof(RTFILEAIOREQINTERNAL));
if (RT_UNLIKELY(!pReqInt))
return VERR_NO_MEMORY;
pReqInt->pCtxInt = NULL;
pReqInt->fCompleted = false;
pReqInt->u32Magic = RTFILEAIOREQ_MAGIC;
RTFILEAIOREQ_SET_STATE(pReqInt, COMPLETED);
*phReq = (RTFILEAIOREQ)pReqInt;
return VINF_SUCCESS;
}
RTR3DECL(int) RTFileAioReqCreate(PRTFILEAIOREQ phReq)
{
AssertPtrReturn(phReq, VERR_INVALID_POINTER);
/*
* Allocate a new request and initialize it.
*/
PRTFILEAIOREQINTERNAL pReqInt = (PRTFILEAIOREQINTERNAL)RTMemAllocZ(sizeof(*pReqInt));
if (RT_UNLIKELY(!pReqInt))
return VERR_NO_MEMORY;
pReqInt->pCtxInt = NULL;
pReqInt->u32Magic = RTFILEAIOREQ_MAGIC;
RTFILEAIOREQ_SET_STATE(pReqInt, COMPLETED);
*phReq = (RTFILEAIOREQ)pReqInt;
return VINF_SUCCESS;
}
RTDECL(int) RTFileAioReqPrepareFlush(RTFILEAIOREQ hReq, RTFILE hFile, void *pvUser)
{
PRTFILEAIOREQINTERNAL pReqInt = (PRTFILEAIOREQINTERNAL)hReq;
RTFILEAIOREQ_VALID_RETURN(pReqInt);
Assert(hFile != NIL_RTFILE);
RTFILEAIOREQ_NOT_STATE_RETURN_RC(pReqInt, SUBMITTED, VERR_FILE_AIO_IN_PROGRESS);
pReqInt->fFlush = true;
pReqInt->AioCB.aio_fildes = RTFileToNative(hFile);
pReqInt->AioCB.aio_offset = 0;
pReqInt->AioCB.aio_nbytes = 0;
pReqInt->AioCB.aio_buf = NULL;
pReqInt->pvUser = pvUser;
RTFILEAIOREQ_SET_STATE(pReqInt, PREPARED);
return VINF_SUCCESS;
}
RTR3DECL(int) RTFileAioReqCreate(PRTFILEAIOREQ phReq)
{
AssertPtrReturn(phReq, VERR_INVALID_POINTER);
PRTFILEAIOREQINTERNAL pReqInt = (PRTFILEAIOREQINTERNAL)RTMemAllocZ(sizeof(RTFILEAIOREQINTERNAL));
if (RT_UNLIKELY(!pReqInt))
return VERR_NO_MEMORY;
/* Ininitialize static parts. */
pReqInt->AioCB.aio_sigevent.sigev_notify = SIGEV_KEVENT;
pReqInt->AioCB.aio_sigevent.sigev_value.sival_ptr = pReqInt;
pReqInt->pCtxInt = NULL;
pReqInt->u32Magic = RTFILEAIOREQ_MAGIC;
RTFILEAIOREQ_SET_STATE(pReqInt, COMPLETED);
*phReq = (RTFILEAIOREQ)pReqInt;
return VINF_SUCCESS;
}
RTDECL(int) RTFileAioReqCancel(RTFILEAIOREQ hReq)
{
PRTFILEAIOREQINTERNAL pReqInt = hReq;
RTFILEAIOREQ_VALID_RETURN(pReqInt);
RTFILEAIOREQ_STATE_RETURN_RC(pReqInt, SUBMITTED, VERR_FILE_AIO_NOT_SUBMITTED);
ASMAtomicXchgBool(&pReqInt->fCanceled, true);
int rcPosix = aio_cancel(pReqInt->AioCB.aio_fildes, &pReqInt->AioCB);
if (rcPosix == AIO_CANCELED)
{
PRTFILEAIOCTXINTERNAL pCtxInt = pReqInt->pCtxInt;
/*
* Notify the waiting thread that the request was canceled.
*/
AssertMsg(VALID_PTR(pCtxInt),
("Invalid state. Request was canceled but wasn't submitted\n"));
Assert(!pCtxInt->pReqToCancel);
ASMAtomicWritePtr(&pCtxInt->pReqToCancel, pReqInt);
rtFileAioCtxWakeup(pCtxInt);
/* Wait for acknowledge. */
int rc = RTSemEventWait(pCtxInt->SemEventCancel, RT_INDEFINITE_WAIT);
AssertRC(rc);
ASMAtomicWriteNullPtr(&pCtxInt->pReqToCancel);
pReqInt->Rc = VERR_FILE_AIO_CANCELED;
RTFILEAIOREQ_SET_STATE(pReqInt, COMPLETED);
return VINF_SUCCESS;
}
else if (rcPosix == AIO_ALLDONE)
return VERR_FILE_AIO_COMPLETED;
else if (rcPosix == AIO_NOTCANCELED)
return VERR_FILE_AIO_IN_PROGRESS;
else
return RTErrConvertFromErrno(errno);
}
RTDECL(int) RTFileAioCtxWait(RTFILEAIOCTX hAioCtx, size_t cMinReqs, RTMSINTERVAL cMillies,
PRTFILEAIOREQ pahReqs, size_t cReqs, uint32_t *pcReqs)
{
int rc = VINF_SUCCESS;
int cRequestsCompleted = 0;
PRTFILEAIOCTXINTERNAL pCtxInt = (PRTFILEAIOCTXINTERNAL)hAioCtx;
struct timespec Timeout;
struct timespec *pTimeout = NULL;
uint64_t StartNanoTS = 0;
LogFlowFunc(("hAioCtx=%#p cMinReqs=%zu cMillies=%u pahReqs=%#p cReqs=%zu pcbReqs=%#p\n",
hAioCtx, cMinReqs, cMillies, pahReqs, cReqs, pcReqs));
/* Check parameters. */
AssertPtrReturn(pCtxInt, VERR_INVALID_HANDLE);
AssertPtrReturn(pcReqs, VERR_INVALID_POINTER);
AssertPtrReturn(pahReqs, VERR_INVALID_POINTER);
AssertReturn(cReqs != 0, VERR_INVALID_PARAMETER);
AssertReturn(cReqs >= cMinReqs, VERR_OUT_OF_RANGE);
rtFileAioCtxDump(pCtxInt);
int32_t cRequestsWaiting = ASMAtomicReadS32(&pCtxInt->cRequests);
if ( RT_UNLIKELY(cRequestsWaiting <= 0)
&& !(pCtxInt->fFlags & RTFILEAIOCTX_FLAGS_WAIT_WITHOUT_PENDING_REQUESTS))
return VERR_FILE_AIO_NO_REQUEST;
if (RT_UNLIKELY(cMinReqs > (uint32_t)cRequestsWaiting))
return VERR_INVALID_PARAMETER;
if (cMillies != RT_INDEFINITE_WAIT)
{
Timeout.tv_sec = cMillies / 1000;
Timeout.tv_nsec = (cMillies % 1000) * 1000000;
pTimeout = &Timeout;
StartNanoTS = RTTimeNanoTS();
}
/* Wait for at least one. */
if (!cMinReqs)
cMinReqs = 1;
/* For the wakeup call. */
Assert(pCtxInt->hThreadWait == NIL_RTTHREAD);
ASMAtomicWriteHandle(&pCtxInt->hThreadWait, RTThreadSelf());
/* Update the waiting list once before we enter the loop. */
rc = rtFileAioCtxProcessEvents(pCtxInt);
while ( cMinReqs
&& RT_SUCCESS_NP(rc))
{
#ifdef RT_STRICT
if (RT_UNLIKELY(!pCtxInt->iFirstFree))
{
for (unsigned i = 0; i < pCtxInt->cReqsWaitMax; i++)
RTAssertMsg2Weak("wait[%d] = %#p\n", i, pCtxInt->apReqs[i]);
AssertMsgFailed(("No request to wait for. pReqsWaitHead=%#p pReqsWaitTail=%#p\n",
pCtxInt->pReqsWaitHead, pCtxInt->pReqsWaitTail));
}
#endif
LogFlow(("Waiting for %d requests to complete\n", pCtxInt->iFirstFree));
rtFileAioCtxDump(pCtxInt);
ASMAtomicXchgBool(&pCtxInt->fWaiting, true);
int rcPosix = aio_suspend((const struct aiocb * const *)pCtxInt->apReqs,
pCtxInt->iFirstFree, pTimeout);
ASMAtomicXchgBool(&pCtxInt->fWaiting, false);
if (rcPosix < 0)
{
LogFlow(("aio_suspend failed %d nent=%u\n", errno, pCtxInt->iFirstFree));
/* Check that this is an external wakeup event. */
if (errno == EINTR)
rc = rtFileAioCtxProcessEvents(pCtxInt);
else
rc = RTErrConvertFromErrno(errno);
}
else
{
/* Requests finished. */
unsigned iReqCurr = 0;
unsigned cDone = 0;
/* Remove completed requests from the waiting list. */
while ( (iReqCurr < pCtxInt->iFirstFree)
&& (cDone < cReqs))
{
PRTFILEAIOREQINTERNAL pReq = pCtxInt->apReqs[iReqCurr];
int rcReq = aio_error(&pReq->AioCB);
if (rcReq != EINPROGRESS)
{
/* Completed store the return code. */
if (rcReq == 0)
{
pReq->Rc = VINF_SUCCESS;
/* Call aio_return() to free resources. */
pReq->cbTransfered = aio_return(&pReq->AioCB);
}
else
{
#if defined(RT_OS_DARWIN) || defined(RT_OS_FREEBSD)
pReq->Rc = RTErrConvertFromErrno(errno);
#else
pReq->Rc = RTErrConvertFromErrno(rcReq);
#endif
}
/* Mark the request as finished. */
RTFILEAIOREQ_SET_STATE(pReq, COMPLETED);
cDone++;
/* If there are other entries waiting put the head into the now free entry. */
if (pCtxInt->pReqsWaitHead)
{
PRTFILEAIOREQINTERNAL pReqInsert = pCtxInt->pReqsWaitHead;
pCtxInt->pReqsWaitHead = pReqInsert->pNext;
if (!pCtxInt->pReqsWaitHead)
{
/* List is empty now. Clear tail too. */
pCtxInt->pReqsWaitTail = NULL;
}
pReqInsert->iWaitingList = pReq->iWaitingList;
pCtxInt->apReqs[pReqInsert->iWaitingList] = pReqInsert;
iReqCurr++;
}
else
{
/*
* Move the last entry into the current position to avoid holes
* but only if it is not the last element already.
*/
if (pReq->iWaitingList < pCtxInt->iFirstFree - 1)
{
pCtxInt->apReqs[pReq->iWaitingList] = pCtxInt->apReqs[--pCtxInt->iFirstFree];
pCtxInt->apReqs[pReq->iWaitingList]->iWaitingList = pReq->iWaitingList;
}
else
pCtxInt->iFirstFree--;
pCtxInt->apReqs[pCtxInt->iFirstFree] = NULL;
}
/* Put the request into the completed list. */
pahReqs[cRequestsCompleted++] = pReq;
pReq->iWaitingList = RTFILEAIOCTX_WAIT_ENTRY_INVALID;
}
else
iReqCurr++;
}
AssertMsg((cDone <= cReqs), ("Overflow cReqs=%u cMinReqs=%u cDone=%u\n",
cReqs, cDone));
cReqs -= cDone;
cMinReqs = RT_MAX(cMinReqs, cDone) - cDone;
ASMAtomicSubS32(&pCtxInt->cRequests, cDone);
AssertMsg(pCtxInt->cRequests >= 0, ("Finished more requests than currently active\n"));
if (!cMinReqs)
break;
if (cMillies != RT_INDEFINITE_WAIT)
{
uint64_t TimeDiff;
/* Recalculate the timeout. */
TimeDiff = RTTimeSystemNanoTS() - StartNanoTS;
Timeout.tv_sec = Timeout.tv_sec - (TimeDiff / 1000000);
Timeout.tv_nsec = Timeout.tv_nsec - (TimeDiff % 1000000);
}
/* Check for new elements. */
rc = rtFileAioCtxProcessEvents(pCtxInt);
}
}
*pcReqs = cRequestsCompleted;
Assert(pCtxInt->hThreadWait == RTThreadSelf());
ASMAtomicWriteHandle(&pCtxInt->hThreadWait, NIL_RTTHREAD);
rtFileAioCtxDump(pCtxInt);
return rc;
}
RTDECL(int) RTFileAioCtxSubmit(RTFILEAIOCTX hAioCtx, PRTFILEAIOREQ pahReqs, size_t cReqs)
{
int rc = VINF_SUCCESS;
PRTFILEAIOCTXINTERNAL pCtxInt = hAioCtx;
/* Parameter checks */
AssertPtrReturn(pCtxInt, VERR_INVALID_HANDLE);
AssertReturn(cReqs != 0, VERR_INVALID_POINTER);
AssertPtrReturn(pahReqs, VERR_INVALID_PARAMETER);
rtFileAioCtxDump(pCtxInt);
/* Check that we don't exceed the limit */
if (ASMAtomicUoReadS32(&pCtxInt->cRequests) + cReqs > pCtxInt->cMaxRequests)
return VERR_FILE_AIO_LIMIT_EXCEEDED;
PRTFILEAIOREQINTERNAL pHead = NULL;
do
{
int rcPosix = 0;
size_t cReqsSubmit = 0;
size_t i = 0;
PRTFILEAIOREQINTERNAL pReqInt;
while ( (i < cReqs)
&& (i < AIO_LISTIO_MAX))
{
pReqInt = pahReqs[i];
if (RTFILEAIOREQ_IS_NOT_VALID(pReqInt))
{
/* Undo everything and stop submitting. */
for (size_t iUndo = 0; iUndo < i; iUndo++)
{
pReqInt = pahReqs[iUndo];
RTFILEAIOREQ_SET_STATE(pReqInt, PREPARED);
pReqInt->pCtxInt = NULL;
/* Unlink from the list again. */
PRTFILEAIOREQINTERNAL pNext, pPrev;
pNext = pReqInt->pNext;
pPrev = pReqInt->pPrev;
if (pNext)
pNext->pPrev = pPrev;
if (pPrev)
pPrev->pNext = pNext;
else
pHead = pNext;
}
rc = VERR_INVALID_HANDLE;
break;
}
pReqInt->pCtxInt = pCtxInt;
if (pReqInt->fFlush)
break;
/* Link them together. */
pReqInt->pNext = pHead;
if (pHead)
pHead->pPrev = pReqInt;
pReqInt->pPrev = NULL;
pHead = pReqInt;
RTFILEAIOREQ_SET_STATE(pReqInt, SUBMITTED);
cReqsSubmit++;
i++;
}
if (cReqsSubmit)
{
rcPosix = lio_listio(LIO_NOWAIT, (struct aiocb **)pahReqs, cReqsSubmit, NULL);
if (RT_UNLIKELY(rcPosix < 0))
{
size_t cReqsSubmitted = cReqsSubmit;
if (errno == EAGAIN)
rc = VERR_FILE_AIO_INSUFFICIENT_RESSOURCES;
else
rc = RTErrConvertFromErrno(errno);
/* Check which ones were not submitted. */
for (i = 0; i < cReqsSubmit; i++)
{
pReqInt = pahReqs[i];
rcPosix = aio_error(&pReqInt->AioCB);
if ((rcPosix != EINPROGRESS) && (rcPosix != 0))
{
cReqsSubmitted--;
#if defined(RT_OS_DARWIN) || defined(RT_OS_FREEBSD)
if (errno == EINVAL)
#else
if (rcPosix == EINVAL)
#endif
{
/* Was not submitted. */
RTFILEAIOREQ_SET_STATE(pReqInt, PREPARED);
}
else
{
/* An error occurred. */
RTFILEAIOREQ_SET_STATE(pReqInt, COMPLETED);
/*
* Looks like Apple and glibc interpret the standard in different ways.
* glibc returns the error code which would be in errno but Apple returns
* -1 and sets errno to the appropriate value
*/
#if defined(RT_OS_DARWIN) || defined(RT_OS_FREEBSD)
Assert(rcPosix == -1);
pReqInt->Rc = RTErrConvertFromErrno(errno);
#elif defined(RT_OS_LINUX)
pReqInt->Rc = RTErrConvertFromErrno(rcPosix);
#endif
pReqInt->cbTransfered = 0;
}
/* Unlink from the list. */
PRTFILEAIOREQINTERNAL pNext, pPrev;
pNext = pReqInt->pNext;
pPrev = pReqInt->pPrev;
if (pNext)
pNext->pPrev = pPrev;
if (pPrev)
pPrev->pNext = pNext;
else
pHead = pNext;
pReqInt->pNext = NULL;
pReqInt->pPrev = NULL;
}
}
ASMAtomicAddS32(&pCtxInt->cRequests, cReqsSubmitted);
AssertMsg(pCtxInt->cRequests >= 0, ("Adding requests resulted in overflow\n"));
break;
}
ASMAtomicAddS32(&pCtxInt->cRequests, cReqsSubmit);
AssertMsg(pCtxInt->cRequests >= 0, ("Adding requests resulted in overflow\n"));
cReqs -= cReqsSubmit;
pahReqs += cReqsSubmit;
}
/*
* Check if we have a flush request now.
* If not we hit the AIO_LISTIO_MAX limit
* and will continue submitting requests
* above.
*/
if (cReqs && RT_SUCCESS_NP(rc))
{
pReqInt = pahReqs[0];
if (pReqInt->fFlush)
{
/*
* lio_listio does not work with flush requests so
* we have to use aio_fsync directly.
*/
rcPosix = aio_fsync(O_SYNC, &pReqInt->AioCB);
if (RT_UNLIKELY(rcPosix < 0))
{
if (errno == EAGAIN)
{
rc = VERR_FILE_AIO_INSUFFICIENT_RESSOURCES;
RTFILEAIOREQ_SET_STATE(pReqInt, PREPARED);
}
else
{
rc = RTErrConvertFromErrno(errno);
RTFILEAIOREQ_SET_STATE(pReqInt, COMPLETED);
pReqInt->Rc = rc;
}
pReqInt->cbTransfered = 0;
break;
}
/* Link them together. */
pReqInt->pNext = pHead;
if (pHead)
pHead->pPrev = pReqInt;
pReqInt->pPrev = NULL;
pHead = pReqInt;
RTFILEAIOREQ_SET_STATE(pReqInt, SUBMITTED);
ASMAtomicIncS32(&pCtxInt->cRequests);
AssertMsg(pCtxInt->cRequests >= 0, ("Adding requests resulted in overflow\n"));
cReqs--;
pahReqs++;
}
}
} while ( cReqs
&& RT_SUCCESS_NP(rc));
if (pHead)
{
/*
* Forward successfully submitted requests to the thread waiting for requests.
* We search for a free slot first and if we don't find one
* we will grab the first one and append our list to the existing entries.
*/
unsigned iSlot = 0;
while ( (iSlot < RT_ELEMENTS(pCtxInt->apReqsNewHead))
&& !ASMAtomicCmpXchgPtr(&pCtxInt->apReqsNewHead[iSlot], pHead, NULL))
iSlot++;
if (iSlot == RT_ELEMENTS(pCtxInt->apReqsNewHead))
{
/* Nothing found. */
PRTFILEAIOREQINTERNAL pOldHead = ASMAtomicXchgPtrT(&pCtxInt->apReqsNewHead[0], NULL, PRTFILEAIOREQINTERNAL);
/* Find the end of the current head and link the old list to the current. */
PRTFILEAIOREQINTERNAL pTail = pHead;
while (pTail->pNext)
pTail = pTail->pNext;
pTail->pNext = pOldHead;
ASMAtomicWritePtr(&pCtxInt->apReqsNewHead[0], pHead);
}
/* Set the internal wakeup flag and wakeup the thread if possible. */
bool fWokenUp = ASMAtomicXchgBool(&pCtxInt->fWokenUpInternal, true);
if (!fWokenUp)
rtFileAioCtxWakeup(pCtxInt);
}
rtFileAioCtxDump(pCtxInt);
return rc;
}
RTDECL(int) RTFileAioCtxWait(RTFILEAIOCTX hAioCtx, size_t cMinReqs, RTMSINTERVAL cMillies,
PRTFILEAIOREQ pahReqs, size_t cReqs, uint32_t *pcReqs)
{
int rc = VINF_SUCCESS;
int cRequestsCompleted = 0;
/*
* Validate the parameters, making sure to always set pcReqs.
*/
AssertPtrReturn(pcReqs, VERR_INVALID_POINTER);
*pcReqs = 0; /* always set */
PRTFILEAIOCTXINTERNAL pCtxInt = hAioCtx;
RTFILEAIOCTX_VALID_RETURN(pCtxInt);
AssertPtrReturn(pahReqs, VERR_INVALID_POINTER);
AssertReturn(cReqs != 0, VERR_INVALID_PARAMETER);
AssertReturn(cReqs >= cMinReqs, VERR_OUT_OF_RANGE);
if (RT_UNLIKELY(ASMAtomicReadS32(&pCtxInt->cRequests) == 0))
return VERR_FILE_AIO_NO_REQUEST;
/*
* Convert the timeout if specified.
*/
struct timespec *pTimeout = NULL;
struct timespec Timeout = {0,0};
uint64_t StartNanoTS = 0;
if (cMillies != RT_INDEFINITE_WAIT)
{
Timeout.tv_sec = cMillies / 1000;
Timeout.tv_nsec = cMillies % 1000 * 1000000;
pTimeout = &Timeout;
StartNanoTS = RTTimeNanoTS();
}
/* Wait for at least one. */
if (!cMinReqs)
cMinReqs = 1;
/* For the wakeup call. */
Assert(pCtxInt->hThreadWait == NIL_RTTHREAD);
ASMAtomicWriteHandle(&pCtxInt->hThreadWait, RTThreadSelf());
while ( cMinReqs
&& RT_SUCCESS_NP(rc))
{
struct kevent aKEvents[AIO_MAXIMUM_REQUESTS_PER_CONTEXT];
int cRequestsToWait = cMinReqs < AIO_MAXIMUM_REQUESTS_PER_CONTEXT ? cReqs : AIO_MAXIMUM_REQUESTS_PER_CONTEXT;
int rcBSD;
uint64_t StartTime;
ASMAtomicXchgBool(&pCtxInt->fWaiting, true);
rcBSD = kevent(pCtxInt->iKQueue, NULL, 0, aKEvents, cRequestsToWait, pTimeout);
ASMAtomicXchgBool(&pCtxInt->fWaiting, false);
if (RT_UNLIKELY(rcBSD < 0))
{
rc = RTErrConvertFromErrno(errno);
break;
}
uint32_t const cDone = rcBSD;
/* Process received events. */
for (uint32_t i = 0; i < cDone; i++)
{
PRTFILEAIOREQINTERNAL pReqInt = (PRTFILEAIOREQINTERNAL)aKEvents[i].udata;
AssertPtr(pReqInt);
Assert(pReqInt->u32Magic == RTFILEAIOREQ_MAGIC);
/*
* Retrieve the status code here already because the
* user may omit the RTFileAioReqGetRC() call and
* we will leak kernel resources then.
* This will result in errors during submission
* of other requests as soon as the max_aio_queue_per_proc
* limit is reached.
*/
int cbTransfered = aio_return(&pReqInt->AioCB);
if (cbTransfered < 0)
{
pReqInt->Rc = RTErrConvertFromErrno(cbTransfered);
pReqInt->cbTransfered = 0;
}
else
{
pReqInt->Rc = VINF_SUCCESS;
pReqInt->cbTransfered = cbTransfered;
}
RTFILEAIOREQ_SET_STATE(pReqInt, COMPLETED);
pahReqs[cRequestsCompleted++] = (RTFILEAIOREQ)pReqInt;
}
/*
* Done Yet? If not advance and try again.
*/
if (cDone >= cMinReqs)
break;
cMinReqs -= cDone;
cReqs -= cDone;
if (cMillies != RT_INDEFINITE_WAIT)
{
/* The API doesn't return ETIMEDOUT, so we have to fix that ourselves. */
uint64_t NanoTS = RTTimeNanoTS();
uint64_t cMilliesElapsed = (NanoTS - StartNanoTS) / 1000000;
if (cMilliesElapsed >= cMillies)
{
rc = VERR_TIMEOUT;
break;
}
/* The syscall supposedly updates it, but we're paranoid. :-) */
Timeout.tv_sec = (cMillies - (RTMSINTERVAL)cMilliesElapsed) / 1000;
Timeout.tv_nsec = (cMillies - (RTMSINTERVAL)cMilliesElapsed) % 1000 * 1000000;
}
}
/*
* Update the context state and set the return value.
*/
*pcReqs = cRequestsCompleted;
ASMAtomicSubS32(&pCtxInt->cRequests, cRequestsCompleted);
Assert(pCtxInt->hThreadWait == RTThreadSelf());
ASMAtomicWriteHandle(&pCtxInt->hThreadWait, NIL_RTTHREAD);
/*
* Clear the wakeup flag and set rc.
*/
if ( pCtxInt->fWokenUp
&& RT_SUCCESS(rc))
{
ASMAtomicXchgBool(&pCtxInt->fWokenUp, false);
rc = VERR_INTERRUPTED;
}
return rc;
}
RTDECL(int) RTFileAioCtxSubmit(RTFILEAIOCTX hAioCtx, PRTFILEAIOREQ pahReqs, size_t cReqs)
{
/*
* Parameter validation.
*/
int rc = VINF_SUCCESS;
PRTFILEAIOCTXINTERNAL pCtxInt = hAioCtx;
RTFILEAIOCTX_VALID_RETURN(pCtxInt);
AssertReturn(cReqs > 0, VERR_INVALID_PARAMETER);
AssertPtrReturn(pahReqs, VERR_INVALID_POINTER);
do
{
int rcBSD = 0;
size_t cReqsSubmit = 0;
size_t i = 0;
PRTFILEAIOREQINTERNAL pReqInt;
while ( (i < cReqs)
&& (i < AIO_LISTIO_MAX))
{
pReqInt = pahReqs[i];
if (RTFILEAIOREQ_IS_NOT_VALID(pReqInt))
{
/* Undo everything and stop submitting. */
for (size_t iUndo = 0; iUndo < i; iUndo++)
{
pReqInt = pahReqs[iUndo];
RTFILEAIOREQ_SET_STATE(pReqInt, PREPARED);
pReqInt->pCtxInt = NULL;
pReqInt->AioCB.aio_sigevent.sigev_notify_kqueue = 0;
}
rc = VERR_INVALID_HANDLE;
break;
}
pReqInt->AioCB.aio_sigevent.sigev_notify_kqueue = pCtxInt->iKQueue;
pReqInt->pCtxInt = pCtxInt;
RTFILEAIOREQ_SET_STATE(pReqInt, SUBMITTED);
if (pReqInt->fFlush)
break;
cReqsSubmit++;
i++;
}
if (cReqsSubmit)
{
rcBSD = lio_listio(LIO_NOWAIT, (struct aiocb **)pahReqs, cReqsSubmit, NULL);
if (RT_UNLIKELY(rcBSD < 0))
{
if (errno == EAGAIN)
rc = VERR_FILE_AIO_INSUFFICIENT_RESSOURCES;
else
rc = RTErrConvertFromErrno(errno);
/* Check which requests got actually submitted and which not. */
for (i = 0; i < cReqs; i++)
{
pReqInt = pahReqs[i];
rcBSD = aio_error(&pReqInt->AioCB);
if ( rcBSD == -1
&& errno == EINVAL)
{
/* Was not submitted. */
RTFILEAIOREQ_SET_STATE(pReqInt, PREPARED);
pReqInt->pCtxInt = NULL;
}
else if (rcBSD != EINPROGRESS)
{
/* The request encountered an error. */
RTFILEAIOREQ_SET_STATE(pReqInt, COMPLETED);
pReqInt->Rc = RTErrConvertFromErrno(rcBSD);
pReqInt->pCtxInt = NULL;
pReqInt->cbTransfered = 0;
}
}
break;
}
ASMAtomicAddS32(&pCtxInt->cRequests, cReqsSubmit);
cReqs -= cReqsSubmit;
pahReqs += cReqsSubmit;
}
/* Check if we have a flush request now. */
if (cReqs && RT_SUCCESS_NP(rc))
{
pReqInt = pahReqs[0];
RTFILEAIOREQ_VALID_RETURN(pReqInt);
if (pReqInt->fFlush)
{
/*
* lio_listio does not work with flush requests so
* we have to use aio_fsync directly.
*/
rcBSD = aio_fsync(O_SYNC, &pReqInt->AioCB);
if (RT_UNLIKELY(rcBSD < 0))
{
if (rcBSD == EAGAIN)
{
/* Was not submitted. */
RTFILEAIOREQ_SET_STATE(pReqInt, PREPARED);
pReqInt->pCtxInt = NULL;
return VERR_FILE_AIO_INSUFFICIENT_RESSOURCES;
}
else
{
RTFILEAIOREQ_SET_STATE(pReqInt, COMPLETED);
pReqInt->Rc = RTErrConvertFromErrno(errno);
pReqInt->cbTransfered = 0;
return pReqInt->Rc;
}
}
ASMAtomicIncS32(&pCtxInt->cRequests);
cReqs--;
pahReqs++;
}
}
} while (cReqs);
return rc;
}
RTDECL(int) RTFileAioCtxWait(RTFILEAIOCTX hAioCtx, size_t cMinReqs, RTMSINTERVAL cMillies,
PRTFILEAIOREQ pahReqs, size_t cReqs, uint32_t *pcReqs)
{
int rc = VINF_SUCCESS;
int cRequestsCompleted = 0;
/*
* Validate the parameters, making sure to always set pcReqs.
*/
AssertPtrReturn(pcReqs, VERR_INVALID_POINTER);
*pcReqs = 0; /* always set */
PRTFILEAIOCTXINTERNAL pCtxInt = hAioCtx;
RTFILEAIOCTX_VALID_RETURN(pCtxInt);
AssertPtrReturn(pahReqs, VERR_INVALID_POINTER);
AssertReturn(cReqs != 0, VERR_INVALID_PARAMETER);
AssertReturn(cReqs >= cMinReqs, VERR_OUT_OF_RANGE);
if ( RT_UNLIKELY(ASMAtomicReadS32(&pCtxInt->cRequests) == 0)
&& !(pCtxInt->fFlags & RTFILEAIOCTX_FLAGS_WAIT_WITHOUT_PENDING_REQUESTS))
return VERR_FILE_AIO_NO_REQUEST;
/*
* Convert the timeout if specified.
*/
struct timespec *pTimeout = NULL;
struct timespec Timeout = {0,0};
uint64_t StartNanoTS = 0;
if (cMillies != RT_INDEFINITE_WAIT)
{
Timeout.tv_sec = cMillies / 1000;
Timeout.tv_nsec = cMillies % 1000 * 1000000;
pTimeout = &Timeout;
StartNanoTS = RTTimeNanoTS();
}
/* Wait for at least one. */
if (!cMinReqs)
cMinReqs = 1;
while ( cMinReqs
&& RT_SUCCESS_NP(rc))
{
port_event_t aPortEvents[AIO_MAXIMUM_REQUESTS_PER_CONTEXT];
uint_t cRequests = cMinReqs;
int cRequestsToWait = RT_MIN(cReqs, AIO_MAXIMUM_REQUESTS_PER_CONTEXT);
int rcSol;
uint64_t StartTime;
rcSol = port_getn(pCtxInt->iPort, &aPortEvents[0], cRequestsToWait, &cRequests, pTimeout);
if (RT_UNLIKELY(rcSol < 0))
rc = RTErrConvertFromErrno(errno);
/* Process received events. */
for (uint_t i = 0; i < cRequests; i++)
{
if (aPortEvents[i].portev_source == PORT_SOURCE_ALERT)
{
Assert(aPortEvents[i].portev_events == AIO_CONTEXT_WAKEUP_EVENT);
rc = VERR_INTERRUPTED; /* We've got interrupted. */
/* Reset the port. */
port_alert(pCtxInt->iPort, PORT_ALERT_SET, 0, NULL);
}
else
{
PRTFILEAIOREQINTERNAL pReqInt = (PRTFILEAIOREQINTERNAL)aPortEvents[i].portev_user;
AssertPtr(pReqInt);
Assert(pReqInt->u32Magic == RTFILEAIOREQ_MAGIC);
/* A request has finished. */
pahReqs[cRequestsCompleted++] = pReqInt;
/* Mark the request as finished. */
RTFILEAIOREQ_SET_STATE(pReqInt, COMPLETED);
}
}
/*
* Done Yet? If not advance and try again.
*/
if (cRequests >= cMinReqs)
break;
cMinReqs -= cRequests;
cReqs -= cRequests;
if (cMillies != RT_INDEFINITE_WAIT)
{
uint64_t NanoTS = RTTimeNanoTS();
uint64_t cMilliesElapsed = (NanoTS - StartNanoTS) / 1000000;
/* The syscall supposedly updates it, but we're paranoid. :-) */
if (cMilliesElapsed < cMillies)
{
Timeout.tv_sec = (cMillies - (RTMSINTERVAL)cMilliesElapsed) / 1000;
Timeout.tv_nsec = (cMillies - (RTMSINTERVAL)cMilliesElapsed) % 1000 * 1000000;
}
else
{
Timeout.tv_sec = 0;
Timeout.tv_nsec = 0;
}
}
}
/*
* Update the context state and set the return value.
*/
*pcReqs = cRequestsCompleted;
ASMAtomicSubS32(&pCtxInt->cRequests, cRequestsCompleted);
return rc;
}
RTDECL(int) RTFileAioCtxSubmit(RTFILEAIOCTX hAioCtx, PRTFILEAIOREQ pahReqs, size_t cReqs)
{
int rc = VINF_SUCCESS;
/*
* Parameter validation.
*/
PRTFILEAIOCTXINTERNAL pCtxInt = hAioCtx;
RTFILEAIOCTX_VALID_RETURN(pCtxInt);
AssertReturn(cReqs > 0, VERR_INVALID_PARAMETER);
AssertPtrReturn(pahReqs, VERR_INVALID_POINTER);
uint32_t i = cReqs;
PRTFILEAIOREQINTERNAL pReqInt = NULL;
/*
* Validate requests and associate with the context.
*/
while (i-- > 0)
{
pReqInt = pahReqs[i];
if (RTFILEAIOREQ_IS_NOT_VALID(pReqInt))
{
/* Undo everything and stop submitting. */
size_t iUndo = cReqs;
while (iUndo-- > i)
{
pReqInt = pahReqs[iUndo];
RTFILEAIOREQ_SET_STATE(pReqInt, PREPARED);
pReqInt->pCtxInt = NULL;
}
return VERR_INVALID_HANDLE;
}
pReqInt->AioContext = pCtxInt->AioContext;
pReqInt->pCtxInt = pCtxInt;
RTFILEAIOREQ_SET_STATE(pReqInt, SUBMITTED);
}
do
{
/*
* We cast pahReqs to the Linux iocb structure to avoid copying the requests
* into a temporary array. This is possible because the iocb structure is
* the first element in the request structure (see PRTFILEAIOCTXINTERNAL).
*/
int cReqsSubmitted = 0;
rc = rtFileAsyncIoLinuxSubmit(pCtxInt->AioContext, cReqs,
(PLNXKAIOIOCB *)pahReqs,
&cReqsSubmitted);
if (RT_FAILURE(rc))
{
/*
* We encountered an error.
* This means that the first IoCB
* is not correctly initialized
* (invalid buffer alignment or bad file descriptor).
* Revert every request into the prepared state except
* the first one which will switch to completed.
* Another reason could be insufficient resources.
*/
i = cReqs;
while (i-- > 0)
{
/* Already validated. */
pReqInt = pahReqs[i];
pReqInt->pCtxInt = NULL;
pReqInt->AioContext = 0;
RTFILEAIOREQ_SET_STATE(pReqInt, PREPARED);
}
if (rc == VERR_TRY_AGAIN)
return VERR_FILE_AIO_INSUFFICIENT_RESSOURCES;
else
{
/* The first request failed. */
pReqInt = pahReqs[0];
RTFILEAIOREQ_SET_STATE(pReqInt, COMPLETED);
pReqInt->Rc = rc;
pReqInt->cbTransfered = 0;
return rc;
}
}
/* Advance. */
cReqs -= cReqsSubmitted;
pahReqs += cReqsSubmitted;
ASMAtomicAddS32(&pCtxInt->cRequests, cReqsSubmitted);
} while (cReqs);
return rc;
}
RTDECL(int) RTFileAioCtxWait(RTFILEAIOCTX hAioCtx, size_t cMinReqs, RTMSINTERVAL cMillies,
PRTFILEAIOREQ pahReqs, size_t cReqs, uint32_t *pcReqs)
{
/*
* Validate the parameters, making sure to always set pcReqs.
*/
AssertPtrReturn(pcReqs, VERR_INVALID_POINTER);
*pcReqs = 0; /* always set */
PRTFILEAIOCTXINTERNAL pCtxInt = hAioCtx;
RTFILEAIOCTX_VALID_RETURN(pCtxInt);
AssertPtrReturn(pahReqs, VERR_INVALID_POINTER);
AssertReturn(cReqs != 0, VERR_INVALID_PARAMETER);
AssertReturn(cReqs >= cMinReqs, VERR_OUT_OF_RANGE);
/*
* Can't wait if there are not requests around.
*/
if ( RT_UNLIKELY(ASMAtomicUoReadS32(&pCtxInt->cRequests) == 0)
&& !(pCtxInt->fFlags & RTFILEAIOCTX_FLAGS_WAIT_WITHOUT_PENDING_REQUESTS))
return VERR_FILE_AIO_NO_REQUEST;
/*
* Convert the timeout if specified.
*/
struct timespec *pTimeout = NULL;
struct timespec Timeout = {0,0};
uint64_t StartNanoTS = 0;
if (cMillies != RT_INDEFINITE_WAIT)
{
Timeout.tv_sec = cMillies / 1000;
Timeout.tv_nsec = cMillies % 1000 * 1000000;
pTimeout = &Timeout;
StartNanoTS = RTTimeNanoTS();
}
/* Wait for at least one. */
if (!cMinReqs)
cMinReqs = 1;
/* For the wakeup call. */
Assert(pCtxInt->hThreadWait == NIL_RTTHREAD);
ASMAtomicWriteHandle(&pCtxInt->hThreadWait, RTThreadSelf());
/*
* Loop until we're woken up, hit an error (incl timeout), or
* have collected the desired number of requests.
*/
int rc = VINF_SUCCESS;
int cRequestsCompleted = 0;
while (!pCtxInt->fWokenUp)
{
LNXKAIOIOEVENT aPortEvents[AIO_MAXIMUM_REQUESTS_PER_CONTEXT];
int cRequestsToWait = RT_MIN(cReqs, AIO_MAXIMUM_REQUESTS_PER_CONTEXT);
ASMAtomicXchgBool(&pCtxInt->fWaiting, true);
rc = rtFileAsyncIoLinuxGetEvents(pCtxInt->AioContext, cMinReqs, cRequestsToWait, &aPortEvents[0], pTimeout);
ASMAtomicXchgBool(&pCtxInt->fWaiting, false);
if (RT_FAILURE(rc))
break;
uint32_t const cDone = rc;
rc = VINF_SUCCESS;
/*
* Process received events / requests.
*/
for (uint32_t i = 0; i < cDone; i++)
{
/*
* The iocb is the first element in our request structure.
* So we can safely cast it directly to the handle (see above)
*/
PRTFILEAIOREQINTERNAL pReqInt = (PRTFILEAIOREQINTERNAL)aPortEvents[i].pIoCB;
AssertPtr(pReqInt);
Assert(pReqInt->u32Magic == RTFILEAIOREQ_MAGIC);
/** @todo aeichner: The rc field contains the result code
* like you can find in errno for the normal read/write ops.
* But there is a second field called rc2. I don't know the
* purpose for it yet.
*/
if (RT_UNLIKELY(aPortEvents[i].rc < 0))
pReqInt->Rc = RTErrConvertFromErrno(-aPortEvents[i].rc); /* Convert to positive value. */
else
{
pReqInt->Rc = VINF_SUCCESS;
pReqInt->cbTransfered = aPortEvents[i].rc;
}
/* Mark the request as finished. */
RTFILEAIOREQ_SET_STATE(pReqInt, COMPLETED);
pahReqs[cRequestsCompleted++] = (RTFILEAIOREQ)pReqInt;
}
/*
* Done Yet? If not advance and try again.
*/
if (cDone >= cMinReqs)
break;
cMinReqs -= cDone;
cReqs -= cDone;
if (cMillies != RT_INDEFINITE_WAIT)
{
/* The API doesn't return ETIMEDOUT, so we have to fix that ourselves. */
uint64_t NanoTS = RTTimeNanoTS();
uint64_t cMilliesElapsed = (NanoTS - StartNanoTS) / 1000000;
if (cMilliesElapsed >= cMillies)
{
rc = VERR_TIMEOUT;
break;
}
/* The syscall supposedly updates it, but we're paranoid. :-) */
Timeout.tv_sec = (cMillies - (RTMSINTERVAL)cMilliesElapsed) / 1000;
Timeout.tv_nsec = (cMillies - (RTMSINTERVAL)cMilliesElapsed) % 1000 * 1000000;
}
}
/*
* Update the context state and set the return value.
*/
*pcReqs = cRequestsCompleted;
ASMAtomicSubS32(&pCtxInt->cRequests, cRequestsCompleted);
Assert(pCtxInt->hThreadWait == RTThreadSelf());
ASMAtomicWriteHandle(&pCtxInt->hThreadWait, NIL_RTTHREAD);
/*
* Clear the wakeup flag and set rc.
*/
if ( pCtxInt->fWokenUp
&& RT_SUCCESS(rc))
{
ASMAtomicXchgBool(&pCtxInt->fWokenUp, false);
rc = VERR_INTERRUPTED;
}
return rc;
}
RTDECL(int) RTFileAioCtxWait(RTFILEAIOCTX hAioCtx, size_t cMinReqs, RTMSINTERVAL cMillies,
PRTFILEAIOREQ pahReqs, size_t cReqs, uint32_t *pcReqs)
{
/*
* Validate the parameters, making sure to always set pcReqs.
*/
AssertPtrReturn(pcReqs, VERR_INVALID_POINTER);
*pcReqs = 0; /* always set */
PRTFILEAIOCTXINTERNAL pCtxInt = hAioCtx;
RTFILEAIOCTX_VALID_RETURN(pCtxInt);
AssertPtrReturn(pahReqs, VERR_INVALID_POINTER);
AssertReturn(cReqs != 0, VERR_INVALID_PARAMETER);
AssertReturn(cReqs >= cMinReqs, VERR_OUT_OF_RANGE);
/*
* Can't wait if there are no requests around.
*/
if ( RT_UNLIKELY(ASMAtomicUoReadS32(&pCtxInt->cRequests) == 0)
&& !(pCtxInt->fFlags & RTFILEAIOCTX_FLAGS_WAIT_WITHOUT_PENDING_REQUESTS))
return VERR_FILE_AIO_NO_REQUEST;
/* Wait for at least one. */
if (!cMinReqs)
cMinReqs = 1;
/*
* Loop until we're woken up, hit an error (incl timeout), or
* have collected the desired number of requests.
*/
int rc = VINF_SUCCESS;
int cRequestsCompleted = 0;
while ( !pCtxInt->fWokenUp
&& cMinReqs > 0)
{
uint64_t StartNanoTS = 0;
DWORD dwTimeout = cMillies == RT_INDEFINITE_WAIT ? INFINITE : cMillies;
DWORD cbTransfered;
LPOVERLAPPED pOverlapped;
ULONG_PTR lCompletionKey;
BOOL fSucceeded;
if (cMillies != RT_INDEFINITE_WAIT)
StartNanoTS = RTTimeNanoTS();
ASMAtomicXchgBool(&pCtxInt->fWaiting, true);
fSucceeded = GetQueuedCompletionStatus(pCtxInt->hIoCompletionPort,
&cbTransfered,
&lCompletionKey,
&pOverlapped,
dwTimeout);
ASMAtomicXchgBool(&pCtxInt->fWaiting, false);
if ( !fSucceeded
&& !pOverlapped)
{
/* The call failed to dequeue a completion packet, includes VERR_TIMEOUT */
rc = RTErrConvertFromWin32(GetLastError());
break;
}
/* Check if we got woken up. */
if (lCompletionKey == AIO_CONTEXT_WAKEUP_EVENT)
{
Assert(fSucceeded && !pOverlapped);
break;
}
/* A request completed. */
PRTFILEAIOREQINTERNAL pReqInt = OVERLAPPED_2_RTFILEAIOREQINTERNAL(pOverlapped);
AssertPtr(pReqInt);
Assert(pReqInt->u32Magic == RTFILEAIOREQ_MAGIC);
/* Mark the request as finished. */
RTFILEAIOREQ_SET_STATE(pReqInt, COMPLETED);
pReqInt->cbTransfered = cbTransfered;
if (fSucceeded)
pReqInt->Rc = VINF_SUCCESS;
else
{
DWORD errCode = GetLastError();
pReqInt->Rc = RTErrConvertFromWin32(errCode);
if (pReqInt->Rc == VERR_UNRESOLVED_ERROR)
LogRel(("AIO/win: Request %#p returned rc=%Rrc (native %u\n)", pReqInt, pReqInt->Rc, errCode));
}
pahReqs[cRequestsCompleted++] = (RTFILEAIOREQ)pReqInt;
/* Update counter. */
cMinReqs--;
if (cMillies != RT_INDEFINITE_WAIT)
{
/* Recalculate timeout. */
uint64_t NanoTS = RTTimeNanoTS();
uint64_t cMilliesElapsed = (NanoTS - StartNanoTS) / 1000000;
if (cMilliesElapsed < cMillies)
cMillies -= cMilliesElapsed;
else
cMillies = 0;
}
}
/*
* Update the context state and set the return value.
*/
*pcReqs = cRequestsCompleted;
ASMAtomicSubS32(&pCtxInt->cRequests, cRequestsCompleted);
/*
* Clear the wakeup flag and set rc.
*/
bool fWokenUp = ASMAtomicXchgBool(&pCtxInt->fWokenUp, false);
if ( fWokenUp
&& RT_SUCCESS(rc))
rc = VERR_INTERRUPTED;
return rc;
}
RTDECL(int) RTFileAioCtxSubmit(RTFILEAIOCTX hAioCtx, PRTFILEAIOREQ pahReqs, size_t cReqs)
{
/*
* Parameter validation.
*/
int rc = VINF_SUCCESS;
PRTFILEAIOCTXINTERNAL pCtxInt = hAioCtx;
RTFILEAIOCTX_VALID_RETURN(pCtxInt);
AssertReturn(cReqs > 0, VERR_INVALID_PARAMETER);
AssertPtrReturn(pahReqs, VERR_INVALID_POINTER);
size_t i = cReqs;
do
{
int rcSol = 0;
size_t cReqsSubmit = 0;
PRTFILEAIOREQINTERNAL pReqInt;
while(i-- > 0)
{
pReqInt = pahReqs[i];
if (RTFILEAIOREQ_IS_NOT_VALID(pReqInt))
{
/* Undo everything and stop submitting. */
for (size_t iUndo = 0; iUndo < i; iUndo++)
{
pReqInt = pahReqs[iUndo];
RTFILEAIOREQ_SET_STATE(pReqInt, PREPARED);
pReqInt->pCtxInt = NULL;
}
rc = VERR_INVALID_HANDLE;
break;
}
pReqInt->PortNotifier.portnfy_port = pCtxInt->iPort;
pReqInt->pCtxInt = pCtxInt;
RTFILEAIOREQ_SET_STATE(pReqInt, SUBMITTED);
if (pReqInt->fFlush)
break;
cReqsSubmit++;
}
if (cReqsSubmit)
{
rcSol = lio_listio(LIO_NOWAIT, (struct aiocb **)pahReqs, cReqsSubmit, NULL);
if (RT_UNLIKELY(rcSol < 0))
{
if (rcSol == EAGAIN)
rc = VERR_FILE_AIO_INSUFFICIENT_RESSOURCES;
else
rc = RTErrConvertFromErrno(errno);
/* Check which requests got actually submitted and which not. */
for (i = 0; i < cReqs; i++)
{
pReqInt = pahReqs[i];
rcSol = aio_error(&pReqInt->AioCB);
if (rcSol == EINVAL)
{
/* Was not submitted. */
RTFILEAIOREQ_SET_STATE(pReqInt, PREPARED);
pReqInt->pCtxInt = NULL;
}
else if (rcSol != EINPROGRESS)
{
/* The request encountered an error. */
RTFILEAIOREQ_SET_STATE(pReqInt, COMPLETED);
}
}
break;
}
ASMAtomicAddS32(&pCtxInt->cRequests, cReqsSubmit);
cReqs -= cReqsSubmit;
pahReqs += cReqsSubmit;
}
if (cReqs)
{
pReqInt = pahReqs[0];
RTFILEAIOREQ_VALID_RETURN(pReqInt);
/*
* If there are still requests left we have a flush request.
* lio_listio does not work with this requests so
* we have to use aio_fsync directly.
*/
rcSol = aio_fsync(O_SYNC, &pReqInt->AioCB);
if (RT_UNLIKELY(rcSol < 0))
{
RTFILEAIOREQ_SET_STATE(pReqInt, COMPLETED);
rc = RTErrConvertFromErrno(errno);
break;
}
ASMAtomicIncS32(&pCtxInt->cRequests);
cReqs--;
pahReqs++;
}
} while (cReqs);
return rc;
}
