static void pdmNsBwGroupXmitPending(PPDMNSBWGROUP pBwGroup)
{
/*
* We don't need to hold the bandwidth group lock to iterate over the list
* of filters since the filters are removed while the shaper lock is being
* held.
*/
AssertPtr(pBwGroup);
AssertPtr(pBwGroup->pShaper);
Assert(RTCritSectIsOwner(&pBwGroup->pShaper->cs));
//int rc = RTCritSectEnter(&pBwGroup->cs); AssertRC(rc);
/* Check if the group is disabled. */
if (pBwGroup->cbTransferPerSecMax == 0)
return;
PPDMNSFILTER pFilter = pBwGroup->pFiltersHead;
while (pFilter)
{
bool fChoked = ASMAtomicXchgBool(&pFilter->fChoked, false);
Log3((LOG_FN_FMT ": pFilter=%#p fChoked=%RTbool\n", __PRETTY_FUNCTION__, pFilter, fChoked));
if (fChoked && pFilter->pIDrvNet)
{
LogFlowFunc(("Calling pfnXmitPending for pFilter=%#p\n", pFilter));
pFilter->pIDrvNet->pfnXmitPending(pFilter->pIDrvNet);
}
pFilter = pFilter->pNext;
}
//rc = RTCritSectLeave(&pBwGroup->cs); AssertRC(rc);
}
int vboxscsiWriteString(PPDMDEVINS pDevIns, PVBOXSCSI pVBoxSCSI, uint8_t iRegister,
RTGCPTR *pGCPtrSrc, PRTGCUINTREG pcTransfer, unsigned cb)
{
RTGCPTR GCSrc = *pGCPtrSrc;
uint32_t cbTransfer = *pcTransfer * cb;
/* Write string only valid for data in/out register. */
AssertMsg(iRegister == 1, ("Hey only register 1 can be written to with string\n"));
/* Accesses without a valid buffer will be ignored. */
if (!pVBoxSCSI->pBuf)
return VINF_SUCCESS;
Assert(cbTransfer == pVBoxSCSI->cbBuf);
if (cbTransfer > pVBoxSCSI->cbBuf)
cbTransfer = pVBoxSCSI->cbBuf; /* Ignore excess data (not supposed to happen). */
int rc = PDMDevHlpPhysReadGCVirt(pDevIns, pVBoxSCSI->pBuf, GCSrc, cbTransfer);
AssertRC(rc);
*pGCPtrSrc = (RTGCPTR)((RTGCUINTPTR)GCSrc + cbTransfer);
*pcTransfer = 0;
ASMAtomicXchgBool(&pVBoxSCSI->fBusy, true);
return VERR_MORE_DATA;
}
static int pdmacFileAioMgrWaitForBlockingEvent(PPDMACEPFILEMGR pAioMgr, PDMACEPFILEAIOMGRBLOCKINGEVENT enmEvent)
{
ASMAtomicWriteU32((volatile uint32_t *)&pAioMgr->enmBlockingEvent, enmEvent);
Assert(!pAioMgr->fBlockingEventPending);
ASMAtomicXchgBool(&pAioMgr->fBlockingEventPending, true);
/* Wakeup the async I/O manager */
pdmacFileAioMgrWakeup(pAioMgr);
/* Wait for completion. */
int rc = RTSemEventWait(pAioMgr->EventSemBlock, RT_INDEFINITE_WAIT);
AssertRC(rc);
ASMAtomicXchgBool(&pAioMgr->fBlockingEventPending, false);
ASMAtomicWriteU32((volatile uint32_t *)&pAioMgr->enmBlockingEvent, PDMACEPFILEAIOMGRBLOCKINGEVENT_INVALID);
return rc;
}
int VDIoBackendMemDestroy(PVDIOBACKENDMEM pIoBackend)
{
ASMAtomicXchgBool(&pIoBackend->fRunning, false);
vdIoBackendMemThreadPoke(pIoBackend);
RTThreadWait(pIoBackend->hThreadIo, RT_INDEFINITE_WAIT, NULL);
RTSemEventDestroy(pIoBackend->EventSem);
RTCircBufDestroy(pIoBackend->pRequestRing);
RTMemFree(pIoBackend);
return VINF_SUCCESS;
}
static void pdmacFileAioMgrWakeup(PPDMACEPFILEMGR pAioMgr)
{
bool fWokenUp = ASMAtomicXchgBool(&pAioMgr->fWokenUp, true);
if (!fWokenUp)
{
bool fWaitingEventSem = ASMAtomicReadBool(&pAioMgr->fWaitingEventSem);
if (fWaitingEventSem)
{
int rc = RTSemEventSignal(pAioMgr->EventSem);
AssertRC(rc);
}
}
}
RTDECL(int) RTFileAioCtxWakeup(RTFILEAIOCTX hAioCtx)
{
PRTFILEAIOCTXINTERNAL pCtxInt = hAioCtx;
RTFILEAIOCTX_VALID_RETURN(pCtxInt);
/** @todo r=bird: Define the protocol for how to resume work after calling
* this function. */
bool fWokenUp = ASMAtomicXchgBool(&pCtxInt->fWokenUp, true);
if (!fWokenUp)
rtFileAioCtxWakeup(pCtxInt);
return VINF_SUCCESS;
}
/**
* Send thread loop - pushes data down thru the driver chain.
*
* @returns 0 on success.
* @param ThreadSelf Thread handle to this thread.
* @param pvUser User argument.
*/
static DECLCALLBACK(int) drvCharSendLoop(RTTHREAD ThreadSelf, void *pvUser)
{
PDRVCHAR pThis = (PDRVCHAR)pvUser;
int rc = VINF_SUCCESS;
while (!pThis->fShutdown)
{
RTMSINTERVAL cMillies = (rc == VERR_TIMEOUT) ? 50 : RT_INDEFINITE_WAIT;
rc = RTSemEventWait(pThis->SendSem, cMillies);
if ( RT_FAILURE(rc)
&& rc != VERR_TIMEOUT)
break;
/*
* Write the character to the attached stream (if present).
*/
if ( pThis->fShutdown
|| !pThis->pDrvStream)
break;
size_t cbProcessed = 1;
uint8_t ch = pThis->u8SendByte;
rc = pThis->pDrvStream->pfnWrite(pThis->pDrvStream, &ch, &cbProcessed);
if (RT_SUCCESS(rc))
{
ASMAtomicXchgBool(&pThis->fSending, false);
Assert(cbProcessed == 1);
}
else if (rc == VERR_TIMEOUT)
{
/* Normal case, just means that the stream didn't accept a new
* character before the timeout elapsed. Just retry. */
/* do not change the rc status here, otherwise the (rc == VERR_TIMEOUT) branch
* in the wait above will never get executed */
/* rc = VINF_SUCCESS; */
}
else
{
LogRel(("Write failed with %Rrc; skipping\n", rc));
break;
}
}
return VINF_SUCCESS;
}
int GuestCtrlEvent::Cancel(void)
{
int rc = VINF_SUCCESS;
if (!ASMAtomicReadBool(&fCompleted))
{
if (!ASMAtomicReadBool(&fCanceled))
{
ASMAtomicXchgBool(&fCanceled, true);
LogFlowThisFunc(("Cancelling event ...\n"));
rc = hEventSem != NIL_RTSEMEVENT
? RTSemEventSignal(hEventSem) : VINF_SUCCESS;
}
}
return rc;
}
/** @copydoc PDMICHARCONNECTOR::pfnWrite */
static DECLCALLBACK(int) drvCharWrite(PPDMICHARCONNECTOR pInterface, const void *pvBuf, size_t cbWrite)
{
PDRVCHAR pThis = PDMICHAR_2_DRVCHAR(pInterface);
const char *pbBuffer = (const char *)pvBuf;
LogFlow(("%s: pvBuf=%#p cbWrite=%d\n", __FUNCTION__, pvBuf, cbWrite));
for (uint32_t i = 0; i < cbWrite; i++)
{
if (ASMAtomicXchgBool(&pThis->fSending, true))
return VERR_BUFFER_OVERFLOW;
pThis->u8SendByte = pbBuffer[i];
RTSemEventSignal(pThis->SendSem);
STAM_COUNTER_INC(&pThis->StatBytesWritten);
}
return VINF_SUCCESS;
}
/**
* The service thread.
*
* @returns Whatever the worker function returns.
* @param ThreadSelf My thread handle.
* @param pvUser The service index.
*/
static DECLCALLBACK(int) vboxServiceThread(RTTHREAD ThreadSelf, void *pvUser)
{
const unsigned i = (uintptr_t)pvUser;
#ifndef RT_OS_WINDOWS
/*
* Block all signals for this thread. Only the main thread will handle signals.
*/
sigset_t signalMask;
sigfillset(&signalMask);
pthread_sigmask(SIG_BLOCK, &signalMask, NULL);
#endif
int rc = g_aServices[i].pDesc->pfnWorker(&g_aServices[i].fShutdown);
ASMAtomicXchgBool(&g_aServices[i].fShutdown, true);
RTThreadUserSignal(ThreadSelf);
return rc;
}
RTDECL(int) RTFileAioCtxWakeup(RTFILEAIOCTX hAioCtx)
{
PRTFILEAIOCTXINTERNAL pCtxInt = hAioCtx;
RTFILEAIOCTX_VALID_RETURN(pCtxInt);
/** @todo r=bird: Define the protocol for how to resume work after calling
* this function. */
bool fWokenUp = ASMAtomicXchgBool(&pCtxInt->fWokenUp, true);
/*
* Read the thread handle before the status flag.
* If we read the handle after the flag we might
* end up with an invalid handle because the thread
* waiting in RTFileAioCtxWakeup() might get scheduled
* before we read the flag and returns.
* We can ensure that the handle is valid if fWaiting is true
* when reading the handle before the status flag.
*/
RTTHREAD hThread;
ASMAtomicReadHandle(&pCtxInt->hThreadWait, &hThread);
bool fWaiting = ASMAtomicReadBool(&pCtxInt->fWaiting);
if ( !fWokenUp
&& fWaiting)
{
/*
* If a thread waits the handle must be valid.
* It is possible that the thread returns from
* rtFileAsyncIoLinuxGetEvents() before the signal
* is send.
* This is no problem because we already set fWokenUp
* to true which will let the thread return VERR_INTERRUPTED
* and the next call to RTFileAioCtxWait() will not
* return VERR_INTERRUPTED because signals are not saved
* and will simply vanish if the destination thread can't
* receive it.
*/
Assert(hThread != NIL_RTTHREAD);
RTThreadPoke(hThread);
}
return VINF_SUCCESS;
}
int USBProxyServiceDarwin::wait(RTMSINTERVAL aMillies)
{
#ifndef VBOX_WITH_NEW_USB_CODE_ON_DARWIN
if ( mFakeAsync
&& ASMAtomicXchgBool(&mFakeAsync, false))
return VINF_SUCCESS;
#endif
SInt32 rc = CFRunLoopRunInMode(CFSTR(VBOX_IOKIT_MODE_STRING),
mWaitABitNextTime && aMillies >= 1000
? 1.0 /* seconds */
: aMillies >= 5000 /* Temporary measure to poll for status changes (MSD). */
? 5.0 /* seconds */
: aMillies / 1000.0,
true);
mWaitABitNextTime = rc != kCFRunLoopRunTimedOut;
return VINF_SUCCESS;
}
/**
*
* @see iff_detached_func in the darwin kpi.
*/
static void vboxNetFltDarwinIffDetached(void *pvThis, ifnet_t pIfNet)
{
PVBOXNETFLTINS pThis = (PVBOXNETFLTINS)pvThis;
uint64_t NanoTS = RTTimeSystemNanoTS();
LogFlow(("vboxNetFltDarwinIffDetached: pThis=%p NanoTS=%RU64 (%d)\n",
pThis, NanoTS, VALID_PTR(pIfNet) ? VBOX_GET_PCOUNT(pIfNet) : -1));
Assert(!pThis->fDisconnectedFromHost);
Assert(!pThis->fRediscoveryPending);
/*
* If we've put it into promiscuous mode, undo that now. If we don't
* the if_pcount will go all wrong when it's replugged.
*/
if (ASMAtomicXchgBool(&pThis->u.s.fSetPromiscuous, false))
ifnet_set_promiscuous(pIfNet, 0);
/*
* We carefully take the spinlock and increase the interface reference
* behind it in order to avoid problematic races with the detached callback.
*/
RTSpinlockAcquire(pThis->hSpinlock);
pIfNet = ASMAtomicUoReadPtrT(&pThis->u.s.pIfNet, ifnet_t);
int cPromisc = VALID_PTR(pIfNet) ? VBOX_GET_PCOUNT(pIfNet) : - 1;
ASMAtomicUoWriteNullPtr(&pThis->u.s.pIfNet);
ASMAtomicUoWriteNullPtr(&pThis->u.s.pIfFilter);
ASMAtomicWriteBool(&pThis->u.s.fNeedSetPromiscuous, false);
pThis->u.s.fSetPromiscuous = false;
ASMAtomicUoWriteU64(&pThis->NanoTSLastRediscovery, NanoTS);
ASMAtomicUoWriteBool(&pThis->fRediscoveryPending, false);
ASMAtomicWriteBool(&pThis->fDisconnectedFromHost, true);
RTSpinlockReleaseNoInts(pThis->hSpinlock);
if (pIfNet)
ifnet_release(pIfNet);
LogRel(("VBoxNetFlt: was detached from '%s' (%d)\n", pThis->szName, cPromisc));
}
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) RTFileAioCtxWakeup(RTFILEAIOCTX hAioCtx)
{
int rc = VINF_SUCCESS;
PRTFILEAIOCTXINTERNAL pCtxInt = hAioCtx;
RTFILEAIOCTX_VALID_RETURN(pCtxInt);
bool fWokenUp = ASMAtomicXchgBool(&pCtxInt->fWokenUp, true);
bool fWaiting = ASMAtomicReadBool(&pCtxInt->fWaiting);
if ( !fWokenUp
&& fWaiting)
{
BOOL fSucceeded = PostQueuedCompletionStatus(pCtxInt->hIoCompletionPort,
0, AIO_CONTEXT_WAKEUP_EVENT,
NULL);
if (!fSucceeded)
rc = RTErrConvertFromWin32(GetLastError());
}
return rc;
}
/**
* Notifies the device that a request finished and the incoming data
* is ready at the incoming data port.
*/
int vboxscsiRequestFinished(PVBOXSCSI pVBoxSCSI, PPDMSCSIREQUEST pScsiRequest)
{
LogFlowFunc(("pVBoxSCSI=%#p pScsiRequest=%#p\n", pVBoxSCSI, pScsiRequest));
RTMemFree(pScsiRequest->paScatterGatherHead);
RTMemFree(pScsiRequest->pbSenseBuffer);
if (pVBoxSCSI->uTxDir == VBOXSCSI_TXDIR_TO_DEVICE)
{
if (pVBoxSCSI->pBuf)
RTMemFree(pVBoxSCSI->pBuf);
pVBoxSCSI->pBuf = NULL;
pVBoxSCSI->cbBuf = 0;
pVBoxSCSI->cbCDB = 0;
pVBoxSCSI->iCDB = 0;
pVBoxSCSI->iBuf = 0;
pVBoxSCSI->uTargetDevice = 0;
pVBoxSCSI->enmState = VBOXSCSISTATE_NO_COMMAND;
memset(pVBoxSCSI->aCDB, 0, sizeof(pVBoxSCSI->aCDB));
}
ASMAtomicXchgBool(&pVBoxSCSI->fBusy, false);
return VINF_SUCCESS;
}
RTDECL(bool) RTAssertSetQuiet(bool fQuiet)
{
return ASMAtomicXchgBool(&g_fQuiet, fQuiet);
}
DECLCALLBACK(int) VBoxClipboardWorker(void *pInstance, bool volatile *pfShutdown)
{
AssertPtr(pInstance);
LogFlowFunc(("pInstance=%p\n", pInstance));
/*
* Tell the control thread that it can continue
* spawning services.
*/
RTThreadUserSignal(RTThreadSelf());
PVBOXCLIPBOARDCONTEXT pCtx = (PVBOXCLIPBOARDCONTEXT)pInstance;
AssertPtr(pCtx);
int rc;
/* The thread waits for incoming messages from the host. */
for (;;)
{
uint32_t u32Msg;
uint32_t u32Formats;
rc = VbglR3ClipboardGetHostMsg(pCtx->u32ClientID, &u32Msg, &u32Formats);
if (RT_FAILURE(rc))
{
if (rc == VERR_INTERRUPTED)
break;
LogFlowFunc(("Error getting host message, rc=%Rrc\n", rc));
if (*pfShutdown)
break;
/* Wait a bit before retrying. */
RTThreadSleep(1000);
continue;
}
else
{
LogFlowFunc(("u32Msg=%RU32, u32Formats=0x%x\n", u32Msg, u32Formats));
switch (u32Msg)
{
/** @todo r=andy: Use a \#define for WM_USER (+1). */
case VBOX_SHARED_CLIPBOARD_HOST_MSG_FORMATS:
{
/* The host has announced available clipboard formats.
* Forward the information to the window, so it can later
* respond to WM_RENDERFORMAT message. */
::PostMessage(pCtx->hwnd, WM_USER, 0, u32Formats);
} break;
case VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA:
{
/* The host needs data in the specified format. */
::PostMessage(pCtx->hwnd, WM_USER + 1, 0, u32Formats);
} break;
case VBOX_SHARED_CLIPBOARD_HOST_MSG_QUIT:
{
/* The host is terminating. */
LogRel(("Clipboard: Terminating ...\n"));
ASMAtomicXchgBool(pfShutdown, true);
} break;
default:
{
LogFlowFunc(("Unsupported message from host, message=%RU32\n", u32Msg));
/* Wait a bit before retrying. */
RTThreadSleep(1000);
} break;
}
}
if (*pfShutdown)
break;
}
LogFlowFuncLeaveRC(rc);
return rc;
}
static int Test1(unsigned cThreads, unsigned cSeconds, bool fYield, bool fQuiet)
{
int rc;
unsigned i;
uint64_t g_au64[32];
RTTHREAD aThreads[RT_ELEMENTS(g_au64)];
AssertRelease(cThreads <= RT_ELEMENTS(g_au64));
/*
* Init globals.
*/
g_fYield = fYield;
g_fQuiet = fQuiet;
g_fTerminate = false;
rc = RTSemMutexCreate(&g_hMutex);
if (RT_FAILURE(rc))
return PrintError("RTSemMutexCreate failed (rc=%Rrc)\n", rc);
/*
* Create the threads and let them block on the mutex.
*/
rc = RTSemMutexRequest(g_hMutex, RT_INDEFINITE_WAIT);
if (RT_FAILURE(rc))
return PrintError("RTSemMutexRequest failed (rc=%Rrc)\n", rc);
for (i = 0; i < cThreads; i++)
{
g_au64[i] = 0;
rc = RTThreadCreate(&aThreads[i], ThreadTest1, &g_au64[i], 0, RTTHREADTYPE_DEFAULT, RTTHREADFLAGS_WAITABLE, "test");
if (RT_FAILURE(rc))
return PrintError("RTThreadCreate failed for thread %u (rc=%Rrc)\n", i, rc);
}
if (!fQuiet)
RTPrintf("tstSemMutex: %zu Threads created. Racing them for %u seconds (%s) ...\n",
cThreads, cSeconds, g_fYield ? "yielding" : "no yielding");
uint64_t u64StartTS = RTTimeNanoTS();
rc = RTSemMutexRelease(g_hMutex);
if (RT_FAILURE(rc))
PrintError("RTSemMutexRelease failed (rc=%Rrc)\n", rc);
RTThreadSleep(cSeconds * 1000);
ASMAtomicXchgBool(&g_fTerminate, true);
uint64_t ElapsedNS = RTTimeNanoTS() - u64StartTS;
for (i = 0; i < cThreads; i++)
{
rc = RTThreadWait(aThreads[i], 5000, NULL);
if (RT_FAILURE(rc))
PrintError("RTThreadWait failed for thread %u (rc=%Rrc)\n", i, rc);
}
rc = RTSemMutexDestroy(g_hMutex);
if (RT_FAILURE(rc))
PrintError("RTSemMutexDestroy failed - %Rrc\n", rc);
g_hMutex = NIL_RTSEMMUTEX;
if (g_cErrors)
RTThreadSleep(100);
/*
* Collect and display the results.
*/
uint64_t Total = g_au64[0];
for (i = 1; i < cThreads; i++)
Total += g_au64[i];
uint64_t Normal = Total / cThreads;
uint64_t MaxDeviation = 0;
for (i = 0; i < cThreads; i++)
{
uint64_t Delta = RT_ABS((int64_t)(g_au64[i] - Normal));
if (Delta > Normal / 2)
RTPrintf("tstSemMutex: Warning! Thread %d deviates by more than 50%% - %llu (it) vs. %llu (avg)\n",
i, g_au64[i], Normal);
if (Delta > MaxDeviation)
MaxDeviation = Delta;
}
RTPrintf("tstSemMutex: Threads: %u Total: %llu Per Sec: %llu Avg: %llu ns Max dev: %llu%%\n",
cThreads,
Total,
Total / cSeconds,
ElapsedNS / Total,
MaxDeviation * 100 / Normal
);
return 0;
}
HRESULT Shutdown()
{
HRESULT rc = S_OK;
#if !defined(VBOX_WITH_XPCOM)
/* EventQueue::uninit reference counting fun. */
RTTHREAD hSelf = RTThreadSelf();
if ( hSelf == gCOMMainThread
&& hSelf != NIL_RTTHREAD)
{
if (-- gCOMMainInitCount == 0)
{
EventQueue::uninit();
ASMAtomicWriteHandle(&gCOMMainThread, NIL_RTTHREAD);
}
}
CoUninitialize();
#else /* !defined (VBOX_WITH_XPCOM) */
nsCOMPtr<nsIEventQueue> eventQ;
rc = NS_GetMainEventQ(getter_AddRefs(eventQ));
if (NS_SUCCEEDED(rc) || rc == NS_ERROR_NOT_AVAILABLE)
{
/* NS_ERROR_NOT_AVAILABLE seems to mean that
* nsIEventQueue::StopAcceptingEvents() has been called (see
* nsEventQueueService.cpp). We hope that this error code always means
* just that in this case and assume that we're on the main thread
* (it's a kind of unexpected behavior if a non-main thread ever calls
* StopAcceptingEvents() on the main event queue). */
PRBool isOnMainThread = PR_FALSE;
if (NS_SUCCEEDED(rc))
{
rc = eventQ->IsOnCurrentThread(&isOnMainThread);
eventQ = nsnull; /* early release before shutdown */
}
else
{
isOnMainThread = PR_TRUE;
rc = NS_OK;
}
if (NS_SUCCEEDED(rc) && isOnMainThread)
{
/* only the main thread needs to uninitialize XPCOM and only if
* init counter drops to zero */
if (--gXPCOMInitCount == 0)
{
EventQueue::uninit();
rc = NS_ShutdownXPCOM(nsnull);
/* This is a thread initialized XPCOM and set gIsXPCOMInitialized to
* true. Reset it back to false. */
bool wasInited = ASMAtomicXchgBool(&gIsXPCOMInitialized, false);
Assert(wasInited == true);
NOREF(wasInited);
# if defined (XPCOM_GLUE)
XPCOMGlueShutdown();
# endif
}
}
}
#endif /* !defined(VBOX_WITH_XPCOM) */
AssertComRC(rc);
return rc;
}
/**
* Start this service.
*/
bool org_virtualbox_VBoxVFS::start(IOService *pProvider)
{
int rc;
if (!IOService::start(pProvider))
return false;
/* Low level initialization should be performed only once */
if (!ASMAtomicCmpXchgBool(&g_fInstantiated, true, false))
{
IOService::stop(pProvider);
return false;
}
/* Wait for VBoxGuest to be started */
coreService = waitForCoreService();
if (coreService)
{
rc = vboxInit();
if (RT_SUCCESS(rc))
{
/* Connect to the host service. */
rc = vboxConnect(&g_vboxSFClient);
if (RT_SUCCESS(rc))
{
PINFO("VBox client connected");
rc = vboxCallSetUtf8(&g_vboxSFClient);
if (RT_SUCCESS(rc))
{
rc = VBoxVFSRegisterFilesystem();
if (RT_SUCCESS(rc))
{
registerService();
PINFO("Successfully started I/O kit class instance");
return true;
}
PERROR("Unable to register VBoxVFS filesystem");
}
else
{
PERROR("vboxCallSetUtf8 failed: rc=%d", rc);
}
vboxDisconnect(&g_vboxSFClient);
}
else
{
PERROR("Failed to get connection to host: rc=%d", rc);
}
vboxUninit();
}
else
{
PERROR("Failed to initialize low level library");
}
coreService->release();
}
else
{
PERROR("VBoxGuest KEXT not started");
}
ASMAtomicXchgBool(&g_fInstantiated, false);
IOService::stop(pProvider);
return false;
}
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) 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)
{
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;
}
/**
* Internal worker processing events and inserting new requests into the waiting list.
*/
static int rtFileAioCtxProcessEvents(PRTFILEAIOCTXINTERNAL pCtxInt)
{
int rc = VINF_SUCCESS;
/* Process new requests first. */
bool fWokenUp = ASMAtomicXchgBool(&pCtxInt->fWokenUpInternal, false);
if (fWokenUp)
{
for (unsigned iSlot = 0; iSlot < RT_ELEMENTS(pCtxInt->apReqsNewHead); iSlot++)
{
PRTFILEAIOREQINTERNAL pReqHead = ASMAtomicXchgPtrT(&pCtxInt->apReqsNewHead[iSlot], NULL, PRTFILEAIOREQINTERNAL);
while ( (pCtxInt->iFirstFree < pCtxInt->cReqsWaitMax)
&& pReqHead)
{
RTFIELAIOREQ_ASSERT_STATE(pReqHead, SUBMITTED);
pCtxInt->apReqs[pCtxInt->iFirstFree] = pReqHead;
pReqHead->iWaitingList = pCtxInt->iFirstFree;
pReqHead = pReqHead->pNext;
/* Clear pointer to next and previous element just for safety. */
pCtxInt->apReqs[pCtxInt->iFirstFree]->pNext = NULL;
pCtxInt->apReqs[pCtxInt->iFirstFree]->pPrev = NULL;
pCtxInt->iFirstFree++;
Assert( (pCtxInt->iFirstFree <= pCtxInt->cMaxRequests)
&& (pCtxInt->iFirstFree <= pCtxInt->cReqsWaitMax));
}
/* Append the rest to the wait list. */
if (pReqHead)
{
RTFIELAIOREQ_ASSERT_STATE(pReqHead, SUBMITTED);
if (!pCtxInt->pReqsWaitHead)
{
Assert(!pCtxInt->pReqsWaitTail);
pCtxInt->pReqsWaitHead = pReqHead;
pReqHead->pPrev = NULL;
}
else
{
AssertPtr(pCtxInt->pReqsWaitTail);
pCtxInt->pReqsWaitTail->pNext = pReqHead;
pReqHead->pPrev = pCtxInt->pReqsWaitTail;
}
/* Update tail. */
while (pReqHead->pNext)
{
RTFIELAIOREQ_ASSERT_STATE(pReqHead->pNext, SUBMITTED);
pReqHead = pReqHead->pNext;
}
pCtxInt->pReqsWaitTail = pReqHead;
pCtxInt->pReqsWaitTail->pNext = NULL;
}
}
/* Check if a request needs to be canceled. */
PRTFILEAIOREQINTERNAL pReqToCancel = ASMAtomicReadPtrT(&pCtxInt->pReqToCancel, PRTFILEAIOREQINTERNAL);
if (pReqToCancel)
{
/* The request can be in the array waiting for completion or still in the list because it is full. */
if (pReqToCancel->iWaitingList != RTFILEAIOCTX_WAIT_ENTRY_INVALID)
{
/* Put it out of the waiting list. */
pCtxInt->apReqs[pReqToCancel->iWaitingList] = pCtxInt->apReqs[--pCtxInt->iFirstFree];
pCtxInt->apReqs[pReqToCancel->iWaitingList]->iWaitingList = pReqToCancel->iWaitingList;
}
else
{
/* Unlink from the waiting list. */
PRTFILEAIOREQINTERNAL pPrev = pReqToCancel->pPrev;
PRTFILEAIOREQINTERNAL pNext = pReqToCancel->pNext;
if (pNext)
pNext->pPrev = pPrev;
else
{
/* We canceled the tail. */
pCtxInt->pReqsWaitTail = pPrev;
}
if (pPrev)
pPrev->pNext = pNext;
else
{
/* We canceled the head. */
pCtxInt->pReqsWaitHead = pNext;
}
}
ASMAtomicDecS32(&pCtxInt->cRequests);
AssertMsg(pCtxInt->cRequests >= 0, ("Canceled request not which is not in this context\n"));
RTSemEventSignal(pCtxInt->SemEventCancel);
}
}
else
{
if (ASMAtomicXchgBool(&pCtxInt->fWokenUp, false))
rc = VERR_INTERRUPTED;
}
return rc;
}
void pdmacFileEpTaskCompleted(PPDMACTASKFILE pTask, void *pvUser, int rc)
{
PPDMASYNCCOMPLETIONTASKFILE pTaskFile = (PPDMASYNCCOMPLETIONTASKFILE)pvUser;
LogFlowFunc(("pTask=%#p pvUser=%#p rc=%Rrc\n", pTask, pvUser, rc));
if (pTask->enmTransferType == PDMACTASKFILETRANSFER_FLUSH)
pdmR3AsyncCompletionCompleteTask(&pTaskFile->Core, rc, true);
else
{
Assert((uint32_t)pTask->DataSeg.cbSeg == pTask->DataSeg.cbSeg && (int32_t)pTask->DataSeg.cbSeg >= 0);
uint32_t uOld = ASMAtomicSubS32(&pTaskFile->cbTransferLeft, (int32_t)pTask->DataSeg.cbSeg);
/* The first error will be returned. */
if (RT_FAILURE(rc))
ASMAtomicCmpXchgS32(&pTaskFile->rc, rc, VINF_SUCCESS);
#ifdef VBOX_WITH_DEBUGGER
else
{
PPDMASYNCCOMPLETIONENDPOINTFILE pEpFile = (PPDMASYNCCOMPLETIONENDPOINTFILE)pTaskFile->Core.pEndpoint;
/* Overwrite with injected error code. */
if (pTask->enmTransferType == PDMACTASKFILETRANSFER_READ)
rc = ASMAtomicXchgS32(&pEpFile->rcReqRead, VINF_SUCCESS);
else
rc = ASMAtomicXchgS32(&pEpFile->rcReqWrite, VINF_SUCCESS);
if (RT_FAILURE(rc))
ASMAtomicCmpXchgS32(&pTaskFile->rc, rc, VINF_SUCCESS);
}
#endif
if (!(uOld - pTask->DataSeg.cbSeg)
&& !ASMAtomicXchgBool(&pTaskFile->fCompleted, true))
{
#ifdef PDM_ASYNC_COMPLETION_FILE_WITH_DELAY
PPDMASYNCCOMPLETIONENDPOINTFILE pEpFile = (PPDMASYNCCOMPLETIONENDPOINTFILE)pTaskFile->Core.pEndpoint;
PPDMASYNCCOMPLETIONEPCLASSFILE pEpClassFile = (PPDMASYNCCOMPLETIONEPCLASSFILE)pEpFile->Core.pEpClass;
/* Check if we should delay completion of the request. */
if ( ASMAtomicReadU32(&pEpFile->msDelay) > 0
&& ASMAtomicReadU32(&pEpFile->cReqsDelay) > 0)
{
uint64_t tsDelay = pEpFile->msDelay;
if (pEpFile->msJitter)
tsDelay = (RTRandU32() % 100) > 50 ? pEpFile->msDelay + (RTRandU32() % pEpFile->msJitter)
: pEpFile->msDelay - (RTRandU32() % pEpFile->msJitter);
ASMAtomicDecU32(&pEpFile->cReqsDelay);
/* Arm the delay. */
pTaskFile->tsDelayEnd = RTTimeProgramMilliTS() + tsDelay;
/* Append to the list. */
PPDMASYNCCOMPLETIONTASKFILE pHead = NULL;
do
{
pHead = ASMAtomicReadPtrT(&pEpFile->pDelayedHead, PPDMASYNCCOMPLETIONTASKFILE);
pTaskFile->pDelayedNext = pHead;
} while (!ASMAtomicCmpXchgPtr(&pEpFile->pDelayedHead, pTaskFile, pHead));
if (tsDelay < pEpClassFile->cMilliesNext)
{
ASMAtomicWriteU64(&pEpClassFile->cMilliesNext, tsDelay);
TMTimerSetMillies(pEpClassFile->pTimer, tsDelay);
}
LogRel(("AIOMgr: Delaying request %#p for %u ms\n", pTaskFile, tsDelay));
}
else
#endif
pdmR3AsyncCompletionCompleteTask(&pTaskFile->Core, pTaskFile->rc, true);
}
}
}
/**
* Writes to a register.
*
* @returns VBox status code.
* VERR_MORE_DATA if a command is ready to be sent to the SCSI driver.
* @param pVBoxSCSI Pointer to the SCSI state.
* @param iRegister Index of the register to write to.
* @param uVal Value to write.
*/
int vboxscsiWriteRegister(PVBOXSCSI pVBoxSCSI, uint8_t iRegister, uint8_t uVal)
{
int rc = VINF_SUCCESS;
switch (iRegister)
{
case 0:
{
if (pVBoxSCSI->enmState == VBOXSCSISTATE_NO_COMMAND)
{
pVBoxSCSI->enmState = VBOXSCSISTATE_READ_TXDIR;
pVBoxSCSI->uTargetDevice = uVal;
}
else if (pVBoxSCSI->enmState == VBOXSCSISTATE_READ_TXDIR)
{
if (uVal != VBOXSCSI_TXDIR_FROM_DEVICE && uVal != VBOXSCSI_TXDIR_TO_DEVICE)
vboxscsiReset(pVBoxSCSI);
else
{
pVBoxSCSI->enmState = VBOXSCSISTATE_READ_CDB_SIZE;
pVBoxSCSI->uTxDir = uVal;
}
}
else if (pVBoxSCSI->enmState == VBOXSCSISTATE_READ_CDB_SIZE)
{
if (uVal > VBOXSCSI_CDB_SIZE_MAX)
vboxscsiReset(pVBoxSCSI);
else
{
pVBoxSCSI->enmState = VBOXSCSISTATE_READ_BUFFER_SIZE_LOW;
pVBoxSCSI->cbCDB = uVal;
}
}
else if (pVBoxSCSI->enmState == VBOXSCSISTATE_READ_BUFFER_SIZE_LOW)
{
pVBoxSCSI->enmState = VBOXSCSISTATE_READ_BUFFER_SIZE_HIGH;
pVBoxSCSI->cbBuf = uVal;
}
else if (pVBoxSCSI->enmState == VBOXSCSISTATE_READ_BUFFER_SIZE_HIGH)
{
pVBoxSCSI->enmState = VBOXSCSISTATE_READ_COMMAND;
pVBoxSCSI->cbBuf |= (((uint16_t)uVal) << 8);
}
else if (pVBoxSCSI->enmState == VBOXSCSISTATE_READ_COMMAND)
{
pVBoxSCSI->aCDB[pVBoxSCSI->iCDB] = uVal;
pVBoxSCSI->iCDB++;
/* Check if we have all necessary command data. */
if (pVBoxSCSI->iCDB == pVBoxSCSI->cbCDB)
{
Log(("%s: Command ready for processing\n", __FUNCTION__));
pVBoxSCSI->enmState = VBOXSCSISTATE_COMMAND_READY;
if (pVBoxSCSI->uTxDir == VBOXSCSI_TXDIR_TO_DEVICE)
{
/* This is a write allocate buffer. */
pVBoxSCSI->pBuf = (uint8_t *)RTMemAllocZ(pVBoxSCSI->cbBuf);
if (!pVBoxSCSI->pBuf)
return VERR_NO_MEMORY;
}
else
{
/* This is a read from the device. */
ASMAtomicXchgBool(&pVBoxSCSI->fBusy, true);
rc = VERR_MORE_DATA; /** @todo Better return value to indicate ready command? */
}
}
}
else
AssertMsgFailed(("Invalid state %d\n", pVBoxSCSI->enmState));
break;
}
case 1:
{
if ( pVBoxSCSI->enmState != VBOXSCSISTATE_COMMAND_READY
|| pVBoxSCSI->uTxDir != VBOXSCSI_TXDIR_TO_DEVICE)
{
/* Reset the state */
vboxscsiReset(pVBoxSCSI);
}
else
{
pVBoxSCSI->pBuf[pVBoxSCSI->iBuf++] = uVal;
if (pVBoxSCSI->iBuf == pVBoxSCSI->cbBuf)
{
rc = VERR_MORE_DATA;
ASMAtomicXchgBool(&pVBoxSCSI->fBusy, true);
}
}
break;
}
case 2:
{
pVBoxSCSI->regIdentify = uVal;
break;
}
case 3:
{
/* Reset */
vboxscsiReset(pVBoxSCSI);
break;
}
default:
AssertMsgFailed(("Invalid register to write to %u\n", iRegister));
}
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;
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) 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(bool) RTAssertSetMayPanic(bool fMayPanic)
{
return ASMAtomicXchgBool(&g_fMayPanic, fMayPanic);
}
