/**
* @callback_method_impl{The randu32() function implementation.}
*/
static DECLCALLBACK(int) dbgcFuncRandU32(PCDBGCFUNC pFunc, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, uint32_t cArgs,
PDBGCVAR pResult)
{
AssertReturn(cArgs == 0, VERR_DBGC_PARSE_BUG);
uint32_t u32 = RTRandU32();
DBGCVAR_INIT_NUMBER(pResult, u32);
NOREF(pFunc); NOREF(pCmdHlp); NOREF(pUVM); NOREF(paArgs);
return VINF_SUCCESS;
}
/*
* Feel free to inspect with gdb / objdump / whatever / g++ -fverbose-asm in
* a release build and compare with tstMemAutoPtrDisas1PureC.
*/
extern "C" int tstMemAutoPtrDisas1(void **ppv)
{
RTCMemAutoPtr<TSTMEMAUTOPTRSTRUCT> Handle(1);
if (!Handle)
{
Handle->a = RTRandU32();
if (Handle->a < UINT32_MAX / 2)
{
*ppv = Handle.release();
return VINF_SUCCESS;
}
}
return VERR_TRY_AGAIN;
}
/*
* For comparing to tstMemAutoPtrDisas1.
*/
extern "C" int tstMemAutoPtrDisas1PureC(void **ppv)
{
TSTMEMAUTOPTRSTRUCT *pHandle = (TSTMEMAUTOPTRSTRUCT *)RTMemRealloc(NULL, sizeof(*pHandle));
if (pHandle)
{
pHandle->a = RTRandU32();
if (pHandle->a < UINT32_MAX / 2)
{
*ppv = pHandle;
return VINF_SUCCESS;
}
RTMemFree(pHandle);
}
return VERR_TRY_AGAIN;
}
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);
}
}
}
/** Internal worker for VBoxNetUDPUnicast and VBoxNetUDPBroadcast. */
static int vboxnetudpSend(PSUPDRVSESSION pSession, INTNETIFHANDLE hIf, PINTNETBUF pBuf,
RTNETADDRIPV4 SrcIPv4Addr, PCRTMAC pSrcMacAddr, unsigned uSrcPort,
RTNETADDRIPV4 DstIPv4Addr, PCRTMAC pDstMacAddr, unsigned uDstPort,
void const *pvData, size_t cbData)
{
INTNETSEG aSegs[4];
/* the Ethernet header */
RTNETETHERHDR EtherHdr;
EtherHdr.DstMac = *pDstMacAddr;
EtherHdr.SrcMac = *pSrcMacAddr;
EtherHdr.EtherType = RT_H2BE_U16_C(RTNET_ETHERTYPE_IPV4);
aSegs[0].pv = &EtherHdr;
aSegs[0].cb = sizeof(EtherHdr);
aSegs[0].Phys = NIL_RTHCPHYS;
/* the IP header */
RTNETIPV4 IpHdr;
unsigned cbIdHdr = RT_UOFFSETOF(RTNETIPV4, ip_options);
IpHdr.ip_v = 4;
IpHdr.ip_hl = cbIdHdr >> 2;
IpHdr.ip_tos = 0;
IpHdr.ip_len = RT_H2BE_U16((uint16_t)(cbData + sizeof(RTNETUDP) + cbIdHdr));
IpHdr.ip_id = (uint16_t)RTRandU32();
IpHdr.ip_off = 0;
IpHdr.ip_ttl = 255;
IpHdr.ip_p = RTNETIPV4_PROT_UDP;
IpHdr.ip_sum = 0;
IpHdr.ip_src = SrcIPv4Addr;
IpHdr.ip_dst = DstIPv4Addr;
IpHdr.ip_sum = RTNetIPv4HdrChecksum(&IpHdr);
aSegs[1].pv = &IpHdr;
aSegs[1].cb = cbIdHdr;
aSegs[1].Phys = NIL_RTHCPHYS;
/* the UDP bit */
RTNETUDP UdpHdr;
UdpHdr.uh_sport = RT_H2BE_U16(uSrcPort);
UdpHdr.uh_dport = RT_H2BE_U16(uDstPort);
UdpHdr.uh_ulen = RT_H2BE_U16((uint16_t)(cbData + sizeof(RTNETUDP)));
#if 0
UdpHdr.uh_sum = 0; /* pretend checksumming is disabled */
#else
UdpHdr.uh_sum = RTNetIPv4UDPChecksum(&IpHdr, &UdpHdr, pvData);
#endif
aSegs[2].pv = &UdpHdr;
aSegs[2].cb = sizeof(UdpHdr);
aSegs[2].Phys = NIL_RTHCPHYS;
/* the payload */
aSegs[3].pv = (void *)pvData;
aSegs[3].cb = (uint32_t)cbData;
aSegs[3].Phys = NIL_RTHCPHYS;
/* send it */
return VBoxNetIntIfSend(pSession, hIf, pBuf, RT_ELEMENTS(aSegs), &aSegs[0], true /* fFlush */);
}
static int tstParentChild(RTTEST hTest)
{
RTTestSubF(hTest, "2 Children -> Parent");
uint32_t cBufSize = _1K;
PDMAUDIOSTREAMCFG cfg_p =
{
44100, /* Hz */
2 /* Channels */,
AUD_FMT_S16 /* Format */,
PDMAUDIOENDIANESS_LITTLE /* Endianess */
};
PDMPCMPROPS props;
int rc = drvAudioStreamCfgToProps(&cfg_p, &props);
AssertRC(rc);
PDMAUDIOMIXBUF parent;
RTTESTI_CHECK_RC_OK(audioMixBufInit(&parent, "Parent", &props, cBufSize));
PDMAUDIOSTREAMCFG cfg_c1 = /* Upmixing to parent */
{
22100, /* Hz */
2 /* Channels */,
AUD_FMT_S16 /* Format */,
PDMAUDIOENDIANESS_LITTLE /* Endianess */
};
rc = drvAudioStreamCfgToProps(&cfg_c1, &props);
AssertRC(rc);
PDMAUDIOMIXBUF child1;
RTTESTI_CHECK_RC_OK(audioMixBufInit(&child1, "Child1", &props, cBufSize));
RTTESTI_CHECK_RC_OK(audioMixBufLinkTo(&child1, &parent));
PDMAUDIOSTREAMCFG cfg_c2 = /* Downmixing to parent */
{
48000, /* Hz */
2 /* Channels */,
AUD_FMT_S16 /* Format */,
PDMAUDIOENDIANESS_LITTLE /* Endianess */
};
rc = drvAudioStreamCfgToProps(&cfg_c2, &props);
AssertRC(rc);
PDMAUDIOMIXBUF child2;
RTTESTI_CHECK_RC_OK(audioMixBufInit(&child2, "Child2", &props, cBufSize));
RTTESTI_CHECK_RC_OK(audioMixBufLinkTo(&child2, &parent));
/*
* Writing + mixing from child/children -> parent, sequential.
*/
size_t cbBuf = _1K;
char pvBuf[_1K];
int16_t samples[32] = { 0xAA, 0xBB };
uint32_t free, read , written, proc, mixed, temp;
uint32_t cChild1Free = cBufSize;
uint32_t cChild1Mixed = 0;
uint32_t cSamplesParent1 = 16;
uint32_t cSamplesChild1 = 16;
uint32_t cChild2Free = cBufSize;
uint32_t cChild2Mixed = 0;
uint32_t cSamplesParent2 = 16;
uint32_t cSamplesChild2 = 16;
uint32_t t = RTRandU32() % 64;
for (uint32_t i = 0; i < t; i++)
{
RTTestPrintf(hTest, RTTESTLVL_DEBUG, "i=%RU32\n", i);
RTTESTI_CHECK_RC_OK_BREAK(audioMixBufWriteAt(&child1, 0, &samples, sizeof(samples), &written));
RTTESTI_CHECK_MSG_BREAK(written == cSamplesChild1, ("Child1: Expected %RU32 written samples, got %RU32\n", cSamplesChild1, written));
RTTESTI_CHECK_RC_OK_BREAK(audioMixBufMixToParent(&child1, written, &mixed));
temp = audioMixBufProcessed(&parent) - audioMixBufMixed(&child2);
RTTESTI_CHECK_MSG_BREAK(audioMixBufMixed(&child1) == temp, ("Child1: Expected %RU32 mixed samples, got %RU32\n", audioMixBufMixed(&child1), temp));
RTTESTI_CHECK_RC_OK_BREAK(audioMixBufWriteAt(&child2, 0, &samples, sizeof(samples), &written));
RTTESTI_CHECK_MSG_BREAK(written == cSamplesChild2, ("Child2: Expected %RU32 written samples, got %RU32\n", cSamplesChild2, written));
RTTESTI_CHECK_RC_OK_BREAK(audioMixBufMixToParent(&child2, written, &mixed));
temp = audioMixBufProcessed(&parent) - audioMixBufMixed(&child1);
RTTESTI_CHECK_MSG_BREAK(audioMixBufMixed(&child2) == temp, ("Child2: Expected %RU32 mixed samples, got %RU32\n", audioMixBufMixed(&child2), temp));
}
RTTESTI_CHECK(audioMixBufProcessed(&parent) == audioMixBufMixed(&child1) + audioMixBufMixed(&child2));
for (;;)
{
RTTESTI_CHECK_RC_OK_BREAK(audioMixBufReadCirc(&parent, pvBuf, cbBuf, &read));
if (!read)
break;
audioMixBufFinish(&parent, read);
}
RTTESTI_CHECK(audioMixBufProcessed(&parent) == 0);
RTTESTI_CHECK(audioMixBufMixed(&child1) == 0);
RTTESTI_CHECK(audioMixBufMixed(&child2) == 0);
return RTTestSubErrorCount(hTest) ? VERR_GENERAL_FAILURE : VINF_SUCCESS;
}