Index: /trunk/include/iprt/mangling.h =================================================================== --- /trunk/include/iprt/mangling.h (revision 39631) +++ /trunk/include/iprt/mangling.h (revision 39632) @@ -1018,7 +1018,13 @@ # define RTRandU64Ex RT_MANGLER(RTRandU64Ex) # define RTReqPoolAlloc RT_MANGLER(RTReqPoolAlloc) +# define RTReqPoolCallEx RT_MANGLER(RTReqPoolCallEx) +# define RTReqPoolCallExV RT_MANGLER(RTReqPoolCallExV) +# define RTReqPoolCallWait RT_MANGLER(RTReqPoolCallWait) +# define RTReqPoolCallNoWait RT_MANGLER(RTReqPoolCallNoWait) +# define RTReqPoolCallVoidWait RT_MANGLER(RTReqPoolCallVoidWait) +# define RTReqPoolCallVoidNoWait RT_MANGLER(RTReqPoolCallVoidNoWait) # define RTReqPoolCreate RT_MANGLER(RTReqPoolCreate) +# define RTReqPoolGetCfgVar RT_MANGLER(RTReqPoolGetCfgVar) # define RTReqPoolGetStat RT_MANGLER(RTReqPoolGetStat) -# define RTReqPoolQueryCfgVar RT_MANGLER(RTReqPoolQueryCfgVar) # define RTReqPoolRetain RT_MANGLER(RTReqPoolRetain) # define RTReqPoolRelease RT_MANGLER(RTReqPoolRelease) @@ -1031,9 +1037,9 @@ # define RTReqQueueCreate RT_MANGLER(RTReqQueueCreate) # define RTReqQueueDestroy RT_MANGLER(RTReqQueueDestroy) -# define RTReqRelease RT_MANGLER(RTReqRelease) -# define RTReqRetain RT_MANGLER(RTReqRetain) # define RTReqQueueIsBusy RT_MANGLER(RTReqQueueIsBusy) # define RTReqQueueProcess RT_MANGLER(RTReqQueueProcess) # define RTReqSubmit RT_MANGLER(RTReqSubmit) +# define RTReqRelease RT_MANGLER(RTReqRelease) +# define RTReqRetain RT_MANGLER(RTReqRetain) # define RTReqWait RT_MANGLER(RTReqWait) # define RTReqGetStatus RT_MANGLER(RTReqGetStatus) Index: /trunk/include/iprt/req.h =================================================================== --- /trunk/include/iprt/req.h (revision 39631) +++ /trunk/include/iprt/req.h (revision 39632) @@ -87,4 +87,6 @@ /** Pointer to an RT request packet. */ typedef RTREQ *PRTREQ; +/** Nil request handle. */ +#define NIL_RTREQ ((PRTREQ)0) @@ -258,4 +260,32 @@ RTDECL(int) RTReqQueueAlloc(RTREQQUEUE hQueue, RTREQTYPE enmType, PRTREQ *phReq); + +/** + * Creates a request thread pool. + * + * The core configuration is given as parameters, finer pool tuning can be + * achieved via RTReqPoolSetCfgVar. + * + * @returns IPRT status code. + * @param cMaxThreads The maximum number of worker threads. + * UINT32_MAX is an alias for the highest + * allowed thread count. + * @param cMsMinIdle The number of milliseconds a worker + * thread needs to be idle before it is + * considered for shutdown. The value + * RT_INDEFINITE_WAIT disables automatic + * idle thread shutdown. + * @param cThreadsPushBackThreshold At which worker thread count the push + * back should kick in. + * @param cMsMaxPushBack The max number of milliseconds to push + * back a submitter. UINT32_MAX is an + * alias for the highest allowed push back. + * @param pszName The pool name. Keep it short as it is + * used for naming worker threads. + * @param phPool Where to return the pool handle. + */ +RTDECL(int) RTReqPoolCreate(uint32_t cMaxThreads, RTMSINTERVAL cMsMinIdle, + uint32_t cThreadsPushBackThreshold, uint32_t cMsMaxPushBack, + const char *pszName, PRTREQPOOL phPool); /** @@ -330,10 +360,9 @@ * Gets a config variable for a request thread pool. * - * @returns IPRT status code. + * @returns The value, UINT64_MAX on invalid parameters. * @param hPool The pool handle. * @param enmVar The variable to query. - * @param puValue Where to return the value. - */ -RTDECL(int) RTReqPoolQueryCfgVar(RTREQPOOL hPool, RTREQPOOLCFGVAR enmVar, uint64_t *puValue); + */ +RTDECL(uint64_t) RTReqPoolGetCfgVar(RTREQPOOL hPool, RTREQPOOLCFGVAR enmVar); /** @@ -396,4 +425,13 @@ RTDECL(int) RTReqPoolAlloc(RTREQPOOL hPool, RTREQTYPE enmType, PRTREQ *phReq); +RTDECL(int) RTReqPoolCallEx( RTREQPOOL hPool, RTMSINTERVAL cMillies, PRTREQ *phReq, uint32_t fFlags, PFNRT pfnFunction, unsigned cArgs, ...); +RTDECL(int) RTReqPoolCallExV(RTREQPOOL hPool, RTMSINTERVAL cMillies, PRTREQ *phReq, uint32_t fFlags, PFNRT pfnFunction, unsigned cArgs, va_list va); + +RTDECL(int) RTReqPoolCallWait(RTREQPOOL hPool, PFNRT pfnFunction, unsigned cArgs, ...); +RTDECL(int) RTReqPoolCallNoWait(RTREQPOOL hPool, PFNRT pfnFunction, unsigned cArgs, ...); + +RTDECL(int) RTReqPoolCallVoidWait(RTREQPOOL hPool, PFNRT pfnFunction, unsigned cArgs, ...); +RTDECL(int) RTReqPoolCallVoidNoWait(RTREQPOOL hPool, PFNRT pfnFunction, unsigned cArgs, ...); + /** Index: /trunk/src/VBox/Runtime/common/misc/reqpool.cpp =================================================================== --- /trunk/src/VBox/Runtime/common/misc/reqpool.cpp (revision 39631) +++ /trunk/src/VBox/Runtime/common/misc/reqpool.cpp (revision 39632) @@ -108,4 +108,6 @@ /** Magic value (RTREQPOOL_MAGIC). */ uint32_t u32Magic; + /** The request pool name. */ + char szName[12]; /** @name Config @@ -618,4 +620,94 @@ +RTDECL(int) RTReqPoolCreate(uint32_t cMaxThreads, RTMSINTERVAL cMsMinIdle, + uint32_t cThreadsPushBackThreshold, uint32_t cMsMaxPushBack, + const char *pszName, PRTREQPOOL phPool) +{ + /* + * Validate and massage the config. + */ + if (cMaxThreads == UINT32_MAX) + cMaxThreads = RTREQPOOL_MAX_THREADS; + AssertMsgReturn(cMaxThreads > 0 && cMaxThreads <= RTREQPOOL_MAX_THREADS, ("%u\n", cMaxThreads), VERR_OUT_OF_RANGE); + uint32_t const cMinThreads = cMaxThreads > 2 ? 2 : cMaxThreads - 1; + + if (cThreadsPushBackThreshold == 0) + cThreadsPushBackThreshold = cMinThreads; + else if (cThreadsPushBackThreshold == UINT32_MAX) + cThreadsPushBackThreshold = cMaxThreads; + AssertMsgReturn(cThreadsPushBackThreshold <= cMaxThreads, ("%u/%u\n", cThreadsPushBackThreshold, cMaxThreads), VERR_OUT_OF_RANGE); + + if (cMsMaxPushBack == UINT32_MAX) + cMsMaxPushBack = RTREQPOOL_PUSH_BACK_MAX_MS; + AssertMsgReturn(cMsMaxPushBack <= RTREQPOOL_PUSH_BACK_MAX_MS, ("%llu\n", cMsMaxPushBack), VERR_OUT_OF_RANGE); + uint32_t const cMsMinPushBack = cMsMaxPushBack >= 200 ? 100 : cMsMaxPushBack / 2; + + AssertPtrReturn(pszName, VERR_INVALID_POINTER); + size_t cchName = strlen(pszName); + AssertReturn(cchName > 0, VERR_INVALID_PARAMETER); + Assert(cchName <= 10); + + AssertPtrReturn(phPool, VERR_INVALID_POINTER); + + /* + * Create and initialize the pool. + */ + PRTREQPOOLINT pPool = (PRTREQPOOLINT)RTMemAlloc(sizeof(*pPool)); + if (!pPool) + return VERR_NO_MEMORY; + + pPool->u32Magic = RTREQPOOL_MAGIC; + RTStrCopy(pPool->szName, sizeof(pPool->szName), pszName); + + pPool->enmThreadType = RTTHREADTYPE_DEFAULT; + pPool->cMaxThreads = cMaxThreads; + pPool->cMinThreads = cMinThreads; + pPool->cMsMinIdle = cMsMinIdle == RT_INDEFINITE_WAIT || cMsMinIdle >= UINT32_MAX ? UINT32_MAX : cMsMinIdle; + pPool->cNsMinIdle = pPool->cMsMinIdle == UINT32_MAX ? UINT64_MAX : cMsMinIdle * RT_NS_1MS_64; + pPool->cMsIdleSleep = pPool->cMsMinIdle == UINT32_MAX ? RT_INDEFINITE_WAIT : RT_MAX(RT_MS_1SEC, pPool->cMsMinIdle); + pPool->cThreadsPushBackThreshold = cThreadsPushBackThreshold; + pPool->cMsMaxPushBack = cMsMaxPushBack; + pPool->cMsMinPushBack = cMsMinPushBack; + pPool->cMaxFreeRequests = cMaxThreads * 2; + pPool->hThreadTermEvt = NIL_RTSEMEVENTMULTI; + pPool->fDestructing = false; + pPool->cMsCurPushBack = 0; + pPool->cCurThreads = 0; + pPool->cThreadsCreated = 0; + pPool->uLastThreadCreateNanoTs = 0; + RTListInit(&pPool->WorkerThreads); + pPool->cReqProcessed = 0; + pPool->cNsTotalReqProcessing= 0; + pPool->cNsTotalReqQueued = 0; + pPool->cRefs = 1; + pPool->cIdleThreads = 0; + RTListInit(&pPool->IdleThreads); + pPool->pPendingRequests = NULL; + pPool->ppPendingRequests = &pPool->pPendingRequests; + pPool->cCurPendingRequests = 0; + pPool->cCurActiveRequests = 0; + pPool->cReqSubmitted = 0; + pPool->pFreeRequests = NULL; + pPool->cCurFreeRequests = NULL; + + int rc = RTSemEventMultiCreate(&pPool->hThreadTermEvt); + if (RT_SUCCESS(rc)) + { + rc = RTCritSectInit(&pPool->CritSect); + if (RT_SUCCESS(rc)) + { + *phPool = pPool; + return VINF_SUCCESS; + } + + RTSemEventMultiDestroy(pPool->hThreadTermEvt); + } + pPool->u32Magic = RTREQPOOL_MAGIC_DEAD; + RTMemFree(pPool); + return rc; +} + + + RTDECL(int) RTReqPoolSetCfgVar(RTREQPOOL hPool, RTREQPOOLCFGVAR enmVar, uint64_t uValue) { @@ -706,5 +798,8 @@ case RTREQPOOLCFGVAR_PUSH_BACK_MIN_MS: - AssertMsgBreakStmt(uValue <= RTREQPOOL_PUSH_BACK_MAX_MS, ("%llu\n", uValue), rc = VERR_OUT_OF_RANGE); + if (uValue == UINT32_MAX || uValue == UINT64_MAX) + uValue = RTREQPOOL_PUSH_BACK_MAX_MS; + else + AssertMsgBreakStmt(uValue <= RTREQPOOL_PUSH_BACK_MAX_MS, ("%llu\n", uValue), rc = VERR_OUT_OF_RANGE); pPool->cMsMinPushBack = (uint32_t)uValue; if (pPool->cMsMaxPushBack < pPool->cMsMinPushBack) @@ -714,5 +809,8 @@ case RTREQPOOLCFGVAR_PUSH_BACK_MAX_MS: - AssertMsgBreakStmt(uValue <= RTREQPOOL_PUSH_BACK_MAX_MS, ("%llu\n", uValue), rc = VERR_OUT_OF_RANGE); + if (uValue == UINT32_MAX || uValue == UINT64_MAX) + uValue = RTREQPOOL_PUSH_BACK_MAX_MS; + else + AssertMsgBreakStmt(uValue <= RTREQPOOL_PUSH_BACK_MAX_MS, ("%llu\n", uValue), rc = VERR_OUT_OF_RANGE); pPool->cMsMaxPushBack = (uint32_t)uValue; if (pPool->cMsMinPushBack < pPool->cMsMaxPushBack) @@ -766,56 +864,55 @@ -RTDECL(int) RTReqPoolQueryCfgVar(RTREQPOOL hPool, RTREQPOOLCFGVAR enmVar, uint64_t *puValue) +RTDECL(uint64_t) RTReqPoolGetCfgVar(RTREQPOOL hPool, RTREQPOOLCFGVAR enmVar) { PRTREQPOOLINT pPool = hPool; - AssertPtrReturn(pPool, VERR_INVALID_HANDLE); - AssertReturn(pPool->u32Magic == RTREQPOOL_MAGIC, VERR_INVALID_HANDLE); - AssertReturn(enmVar > RTREQPOOLCFGVAR_INVALID && enmVar < RTREQPOOLCFGVAR_END, VERR_INVALID_PARAMETER); + AssertPtrReturn(pPool, UINT64_MAX); + AssertReturn(pPool->u32Magic == RTREQPOOL_MAGIC, UINT64_MAX); + AssertReturn(enmVar > RTREQPOOLCFGVAR_INVALID && enmVar < RTREQPOOLCFGVAR_END, UINT64_MAX); RTCritSectEnter(&pPool->CritSect); - int rc = VINF_SUCCESS; + uint64_t u64; switch (enmVar) { case RTREQPOOLCFGVAR_THREAD_TYPE: - *puValue = pPool->enmThreadType; + u64 = pPool->enmThreadType; break; case RTREQPOOLCFGVAR_MIN_THREADS: - *puValue = pPool->cMinThreads; + u64 = pPool->cMinThreads; break; case RTREQPOOLCFGVAR_MAX_THREADS: - *puValue = pPool->cMaxThreads; + u64 = pPool->cMaxThreads; break; case RTREQPOOLCFGVAR_MS_MIN_IDLE: - *puValue = pPool->cMsMinIdle; + u64 = pPool->cMsMinIdle; break; case RTREQPOOLCFGVAR_MS_IDLE_SLEEP: - *puValue = pPool->cMsIdleSleep; + u64 = pPool->cMsIdleSleep; break; case RTREQPOOLCFGVAR_PUSH_BACK_THRESHOLD: - *puValue = pPool->cThreadsPushBackThreshold; + u64 = pPool->cThreadsPushBackThreshold; break; case RTREQPOOLCFGVAR_PUSH_BACK_MIN_MS: - *puValue = pPool->cMsMinPushBack; + u64 = pPool->cMsMinPushBack; break; case RTREQPOOLCFGVAR_PUSH_BACK_MAX_MS: - *puValue = pPool->cMsMaxPushBack; + u64 = pPool->cMsMaxPushBack; break; case RTREQPOOLCFGVAR_MAX_FREE_REQUESTS: - *puValue = pPool->cMaxFreeRequests; + u64 = pPool->cMaxFreeRequests; break; default: AssertFailed(); - rc = VERR_IPE_NOT_REACHED_DEFAULT_CASE; - *puValue = UINT64_MAX; + u64 = UINT64_MAX; break; } @@ -823,7 +920,7 @@ RTCritSectLeave(&pPool->CritSect); - return rc; -} -RT_EXPORT_SYMBOL(RTReqPoolQueryCfgVar); + return u64; +} +RT_EXPORT_SYMBOL(RTReqGetQueryCfgVar); @@ -939,5 +1036,7 @@ } - /* Finally, free the handle. */ + /* Finally, free the critical section and pool instance. */ + RTCritSectLeave(&pPool->CritSect); + RTCritSectDelete(&pPool->CritSect); RTMemFree(pPool); } @@ -992,2 +1091,121 @@ RT_EXPORT_SYMBOL(RTReqPoolAlloc); + +RTDECL(int) RTReqPoolCallEx( RTREQPOOL hPool, RTMSINTERVAL cMillies, PRTREQ *phReq, uint32_t fFlags, PFNRT pfnFunction, unsigned cArgs, ...) +{ + va_list va; + va_start(va, cArgs); + int rc = RTReqPoolCallExV(hPool, cMillies, phReq, fFlags, pfnFunction, cArgs, va); + va_end(va); + return rc; +} +RT_EXPORT_SYMBOL(RTReqPoolCallEx); + + +RTDECL(int) RTReqPoolCallExV(RTREQPOOL hPool, RTMSINTERVAL cMillies, PRTREQ *phReq, uint32_t fFlags, PFNRT pfnFunction, unsigned cArgs, va_list va) +{ + /* + * Check input. + */ + AssertPtrReturn(pfnFunction, VERR_INVALID_POINTER); + AssertMsgReturn(!((uint32_t)fFlags & ~(uint32_t)(RTREQFLAGS_NO_WAIT | RTREQFLAGS_RETURN_MASK)), ("%#x\n", (uint32_t)fFlags), VERR_INVALID_PARAMETER); + if (!(fFlags & RTREQFLAGS_NO_WAIT)) + { + AssertPtrReturn(phReq, VERR_INVALID_POINTER); + *phReq = NIL_RTREQ; + } + + PRTREQINT pReq = NULL; + AssertMsgReturn(cArgs * sizeof(uintptr_t) <= sizeof(pReq->u.Internal.aArgs), ("cArgs=%u\n", cArgs), VERR_TOO_MUCH_DATA); + + /* + * Allocate and initialize the request. + */ + int rc = RTReqPoolAlloc(hPool, RTREQTYPE_INTERNAL, &pReq); + if (RT_FAILURE(rc)) + return rc; + pReq->fFlags = fFlags; + pReq->u.Internal.pfn = pfnFunction; + pReq->u.Internal.cArgs = cArgs; + for (unsigned iArg = 0; iArg < cArgs; iArg++) + pReq->u.Internal.aArgs[iArg] = va_arg(va, uintptr_t); + + /* + * Submit the request. + */ + rc = RTReqSubmit(pReq, cMillies); + if ( rc != VINF_SUCCESS + && rc != VERR_TIMEOUT) + { + Assert(rc != VERR_INTERRUPTED); + RTReqRelease(pReq); + pReq = NULL; + } + + if (!(fFlags & RTREQFLAGS_NO_WAIT)) + { + *phReq = pReq; + LogFlow(("RTReqPoolCallExV: returns %Rrc *phReq=%p\n", rc, pReq)); + } + else + LogFlow(("RTReqPoolCallExV: returns %Rrc\n", rc)); + return rc; +} +RT_EXPORT_SYMBOL(RTReqPoolCallExV); + + +RTDECL(int) RTReqPoolCallWait(RTREQPOOL hPool, PFNRT pfnFunction, unsigned cArgs, ...) +{ + PRTREQINT pReq; + va_list va; + va_start(va, cArgs); + int rc = RTReqPoolCallExV(hPool, RT_INDEFINITE_WAIT, &pReq, RTREQFLAGS_IPRT_STATUS, + pfnFunction, cArgs, va); + va_end(va); + if (RT_SUCCESS(rc)) + rc = pReq->iStatusX; + RTReqRelease(pReq); + return rc; +} +RT_EXPORT_SYMBOL(RTReqPoolCallWait); + + +RTDECL(int) RTReqPoolCallNoWait(RTREQPOOL hPool, PFNRT pfnFunction, unsigned cArgs, ...) +{ + va_list va; + va_start(va, cArgs); + int rc = RTReqPoolCallExV(hPool, 0, NULL, RTREQFLAGS_IPRT_STATUS | RTREQFLAGS_NO_WAIT, + pfnFunction, cArgs, va); + va_end(va); + return rc; +} +RT_EXPORT_SYMBOL(RTReqPoolCallNoWait); + + +RTDECL(int) RTReqPoolCallVoidWait(RTREQPOOL hPool, PFNRT pfnFunction, unsigned cArgs, ...) +{ + PRTREQINT pReq; + va_list va; + va_start(va, cArgs); + int rc = RTReqPoolCallExV(hPool, RT_INDEFINITE_WAIT, &pReq, RTREQFLAGS_VOID, + pfnFunction, cArgs, va); + va_end(va); + if (RT_SUCCESS(rc)) + rc = pReq->iStatusX; + RTReqRelease(pReq); + return rc; +} +RT_EXPORT_SYMBOL(RTReqPoolCallVoidWait); + + +RTDECL(int) RTReqPoolCallVoidNoWait(RTREQPOOL hPool, PFNRT pfnFunction, unsigned cArgs, ...) +{ + va_list va; + va_start(va, cArgs); + int rc = RTReqPoolCallExV(hPool, 0, NULL, RTREQFLAGS_VOID | RTREQFLAGS_NO_WAIT, + pfnFunction, cArgs, va); + va_end(va); + return rc; +} +RT_EXPORT_SYMBOL(RTReqPoolCallVoidNoWait); + Index: /trunk/src/VBox/Runtime/testcase/Makefile.kmk =================================================================== --- /trunk/src/VBox/Runtime/testcase/Makefile.kmk (revision 39631) +++ /trunk/src/VBox/Runtime/testcase/Makefile.kmk (revision 39632) @@ -65,4 +65,5 @@ tstFileLock \ tstFork \ + tstRTFsQueries \ tstRTGetOpt \ tstRTGetOptArgv \ @@ -92,5 +93,5 @@ tstPrfRT \ tstRand \ - tstRTFsQueries \ + tstRTReqPool \ tstRTSemEventMulti \ tstSemMutex \ @@ -216,12 +217,17 @@ tstRTDigest_SOURCES = tstRTDigest.cpp +tstDir_TEMPLATE = VBOXR3TSTEXE tstDir_SOURCES = tstDir.cpp +tstDir-2_TEMPLATE = VBOXR3TSTEXE tstDir-2_SOURCES = tstDir-2.cpp +tstDir-3_TEMPLATE = VBOXR3TSTEXE tstDir-3_SOURCES = tstDir-3.cpp +tstRTDvm_TEMPLATE = VBOXR3TSTEXE tstRTDvm_SOURCES = tstRTDvm.cpp +tstEnv_TEMPLATE = VBOXR3TSTEXE tstEnv_SOURCES = tstEnv.cpp @@ -231,4 +237,5 @@ tstErrUnique.cpp_DEPS = $(IPRT_OUT_DIR)/errmsgdata.h +tstFile_TEMPLATE = VBOXR3TSTEXE tstFile_SOURCES = tstFile.cpp @@ -242,9 +249,15 @@ tstRTFileGetSize-1_SOURCES = tstRTFileGetSize-1.cpp +tstFileAppendWin-1_TEMPLATE = VBOXR3TSTEXE tstFileAppendWin-1_SOURCES = tstFileAppendWin-1.cpp +tstFileLock_TEMPLATE = VBOXR3TSTEXE tstFileLock_SOURCES = tstFileLock.cpp +tstFork_TEMPLATE = VBOXR3TSTEXE tstFork_SOURCES = tstFork.cpp + +tstRTFsQueries_TEMPLATE = VBOXR3TSTEXE +tstRTFsQueries_SOURCES = tstRTFsQueries.cpp tstRTGetOpt_TEMPLATE = VBOXR3TSTEXE @@ -262,4 +275,5 @@ tstRTHeapSimple_SOURCES = tstRTHeapSimple.cpp +tstIoCtl_TEMPLATE = VBOXR3TSTEXE tstIoCtl_SOURCES = tstIoCtl.cpp @@ -283,6 +297,8 @@ tstIprtMiniString_SOURCES = tstIprtMiniString.cpp +tstLdr_TEMPLATE = VBOXR3TSTEXE tstLdr_SOURCES = tstLdr.cpp +tstLdr-2_TEMPLATE = VBOXR3TSTEXE tstLdr-2_SOURCES = tstLdr-2.cpp tstLdr-2_DEFS = IN_DIS @@ -315,4 +331,5 @@ endif # VBOX_WITH_RAW_MODE +tstLdr-3_TEMPLATE = VBOXR3TSTEXE tstLdr-3_SOURCES = tstLdr-3.cpp tstLdr-3_DEFS = IN_DIS @@ -355,4 +372,5 @@ endif +tstLdr-4_TEMPLATE = VBOXR3TSTEXE tstLdr-4_SOURCES = tstLdr-4.cpp tstLdrDisasmTest.cpp tstLdr-4_DEFS = IN_DIS @@ -360,4 +378,5 @@ $(PATH_STAGE_LIB)/DisasmR3$(VBOX_SUFF_LIB) +tstLdrLoad_TEMPLATE = VBOXR3TSTEXE tstLdrLoad_SOURCES = tstLdrLoad.cpp @@ -368,6 +387,8 @@ tstRTLockValidator_SOURCES = tstRTLockValidator.cpp +tstLog_TEMPLATE = VBOXR3TSTEXE tstLog_SOURCES = tstLog.cpp +tstMemAutoPtr_TEMPLATE = VBOXR3TSTEXE tstMemAutoPtr_SOURCES = tstMemAutoPtr.cpp @@ -381,8 +402,11 @@ tstRTMemPool_SOURCES = tstRTMemPool.cpp +tstMove_TEMPLATE = VBOXR3TSTEXE tstMove_SOURCES = tstMove.cpp +tstMp-1_TEMPLATE = VBOXR3TSTEXE tstMp-1_SOURCES = tstMp-1.cpp +tstNoCrt-1_TEMPLATE = VBOXR3TSTEXE tstNoCrt-1_DEFS = RT_WITHOUT_NOCRT_WRAPPER_ALIASES tstNoCrt-1_SOURCES = \ @@ -399,4 +423,5 @@ ../common/string/strlen.asm +tstOnce_TEMPLATE = VBOXR3TSTEXE tstOnce_SOURCES = tstOnce.cpp @@ -410,9 +435,6 @@ tstRTPoll_SOURCES = tstRTPoll.cpp +tstPrfRT_TEMPLATE = VBOXR3TSTEXE tstPrfRT_SOURCES = tstPrfRT.cpp - -tstRand_SOURCES = tstRand.cpp - -tstRTFsQueries_SOURCES = tstRTFsQueries.cpp tstRTPrfIO_TEMPLATE = VBOXR3TSTEXE @@ -422,10 +444,20 @@ tstRTProcCreateEx_SOURCES = tstRTProcCreateEx.cpp +tstRTProcWait_TEMPLATE = VBOXR3TSTEXE tstRTProcWait_SOURCES = tstRTProcWait.cpp +tstRTProcIsRunningByName_TEMPLATE = VBOXR3TSTEXE tstRTProcIsRunningByName_SOURCES = tstRTProcIsRunningByName.cpp +tstRand_TEMPLATE = VBOXR3TSTEXE +tstRand_SOURCES = tstRand.cpp + +tstRTReqPool_TEMPLATE = VBOXR3TSTEXE +tstRTReqPool_SOURCES = tstRTReqPool.cpp + +tstRTS3_TEMPLATE = VBOXR3TSTEXE tstRTS3_SOURCES = tstRTS3.cpp +tstSemMutex_TEMPLATE = VBOXR3TSTEXE tstSemMutex_SOURCES = tstSemMutex.cpp @@ -436,4 +468,5 @@ tstRTSemRW_SOURCES = tstRTSemRW.cpp +tstSemPingPong_TEMPLATE = VBOXR3TSTEXE tstSemPingPong_SOURCES = tstSemPingPong.cpp @@ -456,6 +489,8 @@ tstRTStrFormat_SOURCES = tstRTStrFormat.cpp +tstStrSimplePattern_TEMPLATE = VBOXR3TSTEXE tstStrSimplePattern_SOURCES = tstStrSimplePattern.cpp +tstStrToNum_TEMPLATE = VBOXR3TSTEXE tstStrToNum_SOURCES = tstStrToNum.cpp @@ -481,6 +516,8 @@ tstRTDirCreateUniqueNumbered_SOURCES = tstRTDirCreateUniqueNumbered.cpp +tstTermCallbacks_TEMPLATE = VBOXR3TSTEXE tstTermCallbacks_SOURCES = tstTermCallbacks.cpp +tstThread-1_TEMPLATE = VBOXR3TSTEXE tstThread-1_SOURCES = tstThread-1.cpp @@ -491,14 +528,20 @@ tstRTThreadExecutionTime_SOURCES = tstRTThreadExecutionTime.cpp +tstTime_TEMPLATE = VBOXR3TSTEXE tstTime_SOURCES = tstTime.cpp +tstTime-2_TEMPLATE = VBOXR3TSTEXE tstTime-2_SOURCES = tstTime-2.cpp +tstTime-3_TEMPLATE = VBOXR3TSTEXE tstTime-3_SOURCES = tstTime-3.cpp +tstTime-4_TEMPLATE = VBOXR3TSTEXE tstTime-4_SOURCES = tstTime-4.cpp +tstTimer_TEMPLATE = VBOXR3TSTEXE tstTimer_SOURCES = tstTimer.cpp +tstTimerLR_TEMPLATE = VBOXR3TSTEXE tstTimerLR_SOURCES = tstTimerLR.cpp @@ -512,4 +555,5 @@ tstRTUuid_SOURCES = tstRTUuid.cpp +tstUtf8_TEMPLATE = VBOXR3TSTEXE tstUtf8_SOURCES = tstUtf8.cpp @@ -591,4 +635,5 @@ # +tstDarwinSched_TEMPLATE = VBOXR3TSTEXE tstDarwinSched_SOURCES = tstDarwinSched.cpp Index: /trunk/src/VBox/Runtime/testcase/tstRTDvm.cpp =================================================================== --- /trunk/src/VBox/Runtime/testcase/tstRTDvm.cpp (revision 39631) +++ /trunk/src/VBox/Runtime/testcase/tstRTDvm.cpp (revision 39632) @@ -29,11 +29,15 @@ * Header Files * *******************************************************************************/ -#include +#include + #include #include -#include #include #include + +/******************************************************************************* +* Structures and Typedefs * +*******************************************************************************/ /** * Disk structure. @@ -53,4 +57,6 @@ } TSTRTDVMDISK, *PTSTRTDVMDISK; + + static int dvmDiskRead(void *pvUser, uint64_t off, void *pvBuf, size_t cbRead) { @@ -59,6 +65,5 @@ if (pDisk->fUseImage) return RTFileReadAt(pDisk->hImage, off, pvBuf, cbRead, NULL); - else - return RTDvmVolumeRead(pDisk->hVol, off, pvBuf, cbRead); + return RTDvmVolumeRead(pDisk->hVol, off, pvBuf, cbRead); } @@ -69,6 +74,5 @@ if (pDisk->fUseImage) return RTFileWriteAt(pDisk->hImage, off, pvBuf, cbWrite, NULL); - else - return RTDvmVolumeWrite(pDisk->hVol, off, pvBuf, cbWrite); + return RTDvmVolumeWrite(pDisk->hVol, off, pvBuf, cbWrite); } @@ -78,5 +82,5 @@ int rc = VINF_SUCCESS; - memset(szPrefix, 0, sizeof(szPrefix)); + RT_ZERO(szPrefix); if (cNesting < sizeof(szPrefix) - 1) @@ -103,5 +107,5 @@ return RTTestSummaryAndDestroy(hTest); } - else if (rc == VERR_NOT_SUPPORTED) + if (rc == VERR_NOT_SUPPORTED) return VINF_SUCCESS;