VirtualBox

儲存庫 vbox 的更動 39632


忽略:
時間撮記:
2011-12-15 下午04:37:48 (13 年 以前)
作者:
vboxsync
svn:sync-xref-src-repo-rev:
75428
訊息:

Most of the reqpool code is there now. The testcase didn't turn up any bad bugs yet, so there must be some pretty bad stuff hiding in there. according to the rules...

位置:
trunk
檔案:
修改 5 筆資料

圖例:

未更動
新增
刪除

  • trunk/include/iprt/mangling.h

    r39612 r39632  
    10181018# define RTRandU64Ex                                    RT_MANGLER(RTRandU64Ex)
    10191019# define RTReqPoolAlloc                                 RT_MANGLER(RTReqPoolAlloc)
     1020# define RTReqPoolCallEx                                RT_MANGLER(RTReqPoolCallEx)
     1021# define RTReqPoolCallExV                               RT_MANGLER(RTReqPoolCallExV)
     1022# define RTReqPoolCallWait                              RT_MANGLER(RTReqPoolCallWait)
     1023# define RTReqPoolCallNoWait                            RT_MANGLER(RTReqPoolCallNoWait)
     1024# define RTReqPoolCallVoidWait                          RT_MANGLER(RTReqPoolCallVoidWait)
     1025# define RTReqPoolCallVoidNoWait                        RT_MANGLER(RTReqPoolCallVoidNoWait)
    10201026# define RTReqPoolCreate                                RT_MANGLER(RTReqPoolCreate)
     1027# define RTReqPoolGetCfgVar                             RT_MANGLER(RTReqPoolGetCfgVar)
    10211028# define RTReqPoolGetStat                               RT_MANGLER(RTReqPoolGetStat)
    1022 # define RTReqPoolQueryCfgVar                           RT_MANGLER(RTReqPoolQueryCfgVar)
    10231029# define RTReqPoolRetain                                RT_MANGLER(RTReqPoolRetain)
    10241030# define RTReqPoolRelease                               RT_MANGLER(RTReqPoolRelease)
    … …  
    10311037# define RTReqQueueCreate                               RT_MANGLER(RTReqQueueCreate)
    10321038# define RTReqQueueDestroy                              RT_MANGLER(RTReqQueueDestroy)
    1033 # define RTReqRelease                                   RT_MANGLER(RTReqRelease)
    1034 # define RTReqRetain                                    RT_MANGLER(RTReqRetain)
    10351039# define RTReqQueueIsBusy                               RT_MANGLER(RTReqQueueIsBusy)
    10361040# define RTReqQueueProcess                              RT_MANGLER(RTReqQueueProcess)
    10371041# define RTReqSubmit                                    RT_MANGLER(RTReqSubmit)
     1042# define RTReqRelease                                   RT_MANGLER(RTReqRelease)
     1043# define RTReqRetain                                    RT_MANGLER(RTReqRetain)
    10381044# define RTReqWait                                      RT_MANGLER(RTReqWait)
    10391045# define RTReqGetStatus                                 RT_MANGLER(RTReqGetStatus)

  • trunk/include/iprt/req.h

    r39620 r39632  
    8787/** Pointer to an RT request packet. */
    8888typedef RTREQ *PRTREQ;
     89/** Nil request handle. */
     90#define NIL_RTREQ           ((PRTREQ)0)
    8991
    9092
    … …  
    258260RTDECL(int) RTReqQueueAlloc(RTREQQUEUE hQueue, RTREQTYPE enmType, PRTREQ *phReq);
    259261
     262
     263/**
     264 * Creates a request thread pool.
     265 *
     266 * The core configuration is given as parameters, finer pool tuning can be
     267 * achieved via RTReqPoolSetCfgVar.
     268 *
     269 * @returns IPRT status code.
     270 * @param   cMaxThreads                 The maximum number of worker threads.
     271 *                                      UINT32_MAX is an alias for the highest
     272 *                                      allowed thread count.
     273 * @param   cMsMinIdle                  The number of milliseconds a worker
     274 *                                      thread needs to be idle before it is
     275 *                                      considered for shutdown. The value
     276 *                                      RT_INDEFINITE_WAIT disables automatic
     277 *                                      idle thread shutdown.
     278 * @param   cThreadsPushBackThreshold   At which worker thread count the push
     279 *                                      back should kick in.
     280 * @param   cMsMaxPushBack              The max number of milliseconds to push
     281 *                                      back a submitter.  UINT32_MAX is an
     282 *                                      alias for the highest allowed push back.
     283 * @param   pszName                     The pool name. Keep it short as it is
     284 *                                      used for naming worker threads.
     285 * @param   phPool                      Where to return the pool handle.
     286 */
     287RTDECL(int) RTReqPoolCreate(uint32_t cMaxThreads, RTMSINTERVAL cMsMinIdle,
     288                            uint32_t cThreadsPushBackThreshold, uint32_t cMsMaxPushBack,
     289                            const char *pszName, PRTREQPOOL phPool);
    260290
    261291/**
    … …  
    330360 * Gets a config variable for a request thread pool.
    331361 *
    332  * @returns IPRT status code.
     362 * @returns The value, UINT64_MAX on invalid parameters.
    333363 * @param   hPool           The pool handle.
    334364 * @param   enmVar          The variable to query.
    335  * @param   puValue         Where to return the value.
    336  */
    337 RTDECL(int) RTReqPoolQueryCfgVar(RTREQPOOL hPool, RTREQPOOLCFGVAR enmVar, uint64_t *puValue);
     365 */
     366RTDECL(uint64_t) RTReqPoolGetCfgVar(RTREQPOOL hPool, RTREQPOOLCFGVAR enmVar);
    338367
    339368/**
    … …  
    396425RTDECL(int) RTReqPoolAlloc(RTREQPOOL hPool, RTREQTYPE enmType, PRTREQ *phReq);
    397426
     427RTDECL(int) RTReqPoolCallEx( RTREQPOOL hPool, RTMSINTERVAL cMillies, PRTREQ *phReq, uint32_t fFlags, PFNRT pfnFunction, unsigned cArgs, ...);
     428RTDECL(int) RTReqPoolCallExV(RTREQPOOL hPool, RTMSINTERVAL cMillies, PRTREQ *phReq, uint32_t fFlags, PFNRT pfnFunction, unsigned cArgs, va_list va);
     429
     430RTDECL(int) RTReqPoolCallWait(RTREQPOOL hPool, PFNRT pfnFunction, unsigned cArgs, ...);
     431RTDECL(int) RTReqPoolCallNoWait(RTREQPOOL hPool, PFNRT pfnFunction, unsigned cArgs, ...);
     432
     433RTDECL(int) RTReqPoolCallVoidWait(RTREQPOOL hPool, PFNRT pfnFunction, unsigned cArgs, ...);
     434RTDECL(int) RTReqPoolCallVoidNoWait(RTREQPOOL hPool, PFNRT pfnFunction, unsigned cArgs, ...);
     435
    398436
    399437/**

  • trunk/src/VBox/Runtime/common/misc/reqpool.cpp

    r39621 r39632  
    108108    /** Magic value (RTREQPOOL_MAGIC). */
    109109    uint32_t                u32Magic;
     110    /** The request pool name. */
     111    char                    szName[12];
    110112
    111113    /** @name Config
    … …  
    618620
    619621
     622RTDECL(int) RTReqPoolCreate(uint32_t cMaxThreads, RTMSINTERVAL cMsMinIdle,
     623                            uint32_t cThreadsPushBackThreshold, uint32_t cMsMaxPushBack,
     624                            const char *pszName, PRTREQPOOL phPool)
     625{
     626    /*
     627     * Validate and massage the config.
     628     */
     629    if (cMaxThreads == UINT32_MAX)
     630        cMaxThreads = RTREQPOOL_MAX_THREADS;
     631    AssertMsgReturn(cMaxThreads > 0 && cMaxThreads <= RTREQPOOL_MAX_THREADS, ("%u\n", cMaxThreads), VERR_OUT_OF_RANGE);
     632    uint32_t const cMinThreads = cMaxThreads > 2 ? 2 : cMaxThreads - 1;
     633
     634    if (cThreadsPushBackThreshold == 0)
     635        cThreadsPushBackThreshold = cMinThreads;
     636    else if (cThreadsPushBackThreshold == UINT32_MAX)
     637        cThreadsPushBackThreshold = cMaxThreads;
     638    AssertMsgReturn(cThreadsPushBackThreshold <= cMaxThreads, ("%u/%u\n", cThreadsPushBackThreshold, cMaxThreads), VERR_OUT_OF_RANGE);
     639
     640    if (cMsMaxPushBack == UINT32_MAX)
     641        cMsMaxPushBack = RTREQPOOL_PUSH_BACK_MAX_MS;
     642    AssertMsgReturn(cMsMaxPushBack <= RTREQPOOL_PUSH_BACK_MAX_MS, ("%llu\n",  cMsMaxPushBack), VERR_OUT_OF_RANGE);
     643    uint32_t const cMsMinPushBack = cMsMaxPushBack >= 200 ? 100 : cMsMaxPushBack / 2;
     644
     645    AssertPtrReturn(pszName, VERR_INVALID_POINTER);
     646    size_t cchName = strlen(pszName);
     647    AssertReturn(cchName > 0, VERR_INVALID_PARAMETER);
     648    Assert(cchName <= 10);
     649
     650    AssertPtrReturn(phPool, VERR_INVALID_POINTER);
     651
     652    /*
     653     * Create and initialize the pool.
     654     */
     655    PRTREQPOOLINT pPool = (PRTREQPOOLINT)RTMemAlloc(sizeof(*pPool));
     656    if (!pPool)
     657        return VERR_NO_MEMORY;
     658
     659    pPool->u32Magic         = RTREQPOOL_MAGIC;
     660    RTStrCopy(pPool->szName, sizeof(pPool->szName), pszName);
     661
     662    pPool->enmThreadType        = RTTHREADTYPE_DEFAULT;
     663    pPool->cMaxThreads          = cMaxThreads;
     664    pPool->cMinThreads          = cMinThreads;
     665    pPool->cMsMinIdle           = cMsMinIdle == RT_INDEFINITE_WAIT || cMsMinIdle >= UINT32_MAX ? UINT32_MAX : cMsMinIdle;
     666    pPool->cNsMinIdle           = pPool->cMsMinIdle == UINT32_MAX ? UINT64_MAX         : cMsMinIdle * RT_NS_1MS_64;
     667    pPool->cMsIdleSleep         = pPool->cMsMinIdle == UINT32_MAX ? RT_INDEFINITE_WAIT : RT_MAX(RT_MS_1SEC, pPool->cMsMinIdle);
     668    pPool->cThreadsPushBackThreshold = cThreadsPushBackThreshold;
     669    pPool->cMsMaxPushBack       = cMsMaxPushBack;
     670    pPool->cMsMinPushBack       = cMsMinPushBack;
     671    pPool->cMaxFreeRequests     = cMaxThreads * 2;
     672    pPool->hThreadTermEvt       = NIL_RTSEMEVENTMULTI;
     673    pPool->fDestructing         = false;
     674    pPool->cMsCurPushBack       = 0;
     675    pPool->cCurThreads          = 0;
     676    pPool->cThreadsCreated      = 0;
     677    pPool->uLastThreadCreateNanoTs = 0;
     678    RTListInit(&pPool->WorkerThreads);
     679    pPool->cReqProcessed        = 0;
     680    pPool->cNsTotalReqProcessing= 0;
     681    pPool->cNsTotalReqQueued    = 0;
     682    pPool->cRefs                = 1;
     683    pPool->cIdleThreads         = 0;
     684    RTListInit(&pPool->IdleThreads);
     685    pPool->pPendingRequests     = NULL;
     686    pPool->ppPendingRequests    = &pPool->pPendingRequests;
     687    pPool->cCurPendingRequests  = 0;
     688    pPool->cCurActiveRequests   = 0;
     689    pPool->cReqSubmitted        = 0;
     690    pPool->pFreeRequests        = NULL;
     691    pPool->cCurFreeRequests     = NULL;
     692
     693    int rc = RTSemEventMultiCreate(&pPool->hThreadTermEvt);
     694    if (RT_SUCCESS(rc))
     695    {
     696        rc = RTCritSectInit(&pPool->CritSect);
     697        if (RT_SUCCESS(rc))
     698        {
     699            *phPool = pPool;
     700            return VINF_SUCCESS;
     701        }
     702
     703        RTSemEventMultiDestroy(pPool->hThreadTermEvt);
     704    }
     705    pPool->u32Magic = RTREQPOOL_MAGIC_DEAD;
     706    RTMemFree(pPool);
     707    return rc;
     708}
     709
     710
     711
    620712RTDECL(int) RTReqPoolSetCfgVar(RTREQPOOL hPool, RTREQPOOLCFGVAR enmVar, uint64_t uValue)
    621713{
    … …  
    706798
    707799        case RTREQPOOLCFGVAR_PUSH_BACK_MIN_MS:
    708             AssertMsgBreakStmt(uValue <= RTREQPOOL_PUSH_BACK_MAX_MS,  ("%llu\n",  uValue), rc = VERR_OUT_OF_RANGE);
     800            if (uValue == UINT32_MAX || uValue == UINT64_MAX)
     801                uValue = RTREQPOOL_PUSH_BACK_MAX_MS;
     802            else
     803                AssertMsgBreakStmt(uValue <= RTREQPOOL_PUSH_BACK_MAX_MS,  ("%llu\n",  uValue), rc = VERR_OUT_OF_RANGE);
    709804            pPool->cMsMinPushBack = (uint32_t)uValue;
    710805            if (pPool->cMsMaxPushBack < pPool->cMsMinPushBack)
    … …  
    714809
    715810        case RTREQPOOLCFGVAR_PUSH_BACK_MAX_MS:
    716             AssertMsgBreakStmt(uValue <= RTREQPOOL_PUSH_BACK_MAX_MS,  ("%llu\n",  uValue), rc = VERR_OUT_OF_RANGE);
     811            if (uValue == UINT32_MAX || uValue == UINT64_MAX)
     812                uValue = RTREQPOOL_PUSH_BACK_MAX_MS;
     813            else
     814                AssertMsgBreakStmt(uValue <= RTREQPOOL_PUSH_BACK_MAX_MS,  ("%llu\n",  uValue), rc = VERR_OUT_OF_RANGE);
    717815            pPool->cMsMaxPushBack = (uint32_t)uValue;
    718816            if (pPool->cMsMinPushBack < pPool->cMsMaxPushBack)
    … …  
    766864
    767865
    768 RTDECL(int) RTReqPoolQueryCfgVar(RTREQPOOL hPool, RTREQPOOLCFGVAR enmVar, uint64_t *puValue)
     866RTDECL(uint64_t) RTReqPoolGetCfgVar(RTREQPOOL hPool, RTREQPOOLCFGVAR enmVar)
    769867{
    770868    PRTREQPOOLINT pPool = hPool;
    771     AssertPtrReturn(pPool, VERR_INVALID_HANDLE);
    772     AssertReturn(pPool->u32Magic == RTREQPOOL_MAGIC, VERR_INVALID_HANDLE);
    773     AssertReturn(enmVar > RTREQPOOLCFGVAR_INVALID && enmVar < RTREQPOOLCFGVAR_END, VERR_INVALID_PARAMETER);
     869    AssertPtrReturn(pPool, UINT64_MAX);
     870    AssertReturn(pPool->u32Magic == RTREQPOOL_MAGIC, UINT64_MAX);
     871    AssertReturn(enmVar > RTREQPOOLCFGVAR_INVALID && enmVar < RTREQPOOLCFGVAR_END, UINT64_MAX);
    774872
    775873    RTCritSectEnter(&pPool->CritSect);
    776874
    777     int rc = VINF_SUCCESS;
     875    uint64_t u64;
    778876    switch (enmVar)
    779877    {
    780878        case RTREQPOOLCFGVAR_THREAD_TYPE:
    781             *puValue = pPool->enmThreadType;
     879            u64 = pPool->enmThreadType;
    782880            break;
    783881
    784882        case RTREQPOOLCFGVAR_MIN_THREADS:
    785             *puValue = pPool->cMinThreads;
     883            u64 = pPool->cMinThreads;
    786884            break;
    787885
    788886        case RTREQPOOLCFGVAR_MAX_THREADS:
    789             *puValue = pPool->cMaxThreads;
     887            u64 = pPool->cMaxThreads;
    790888            break;
    791889
    792890        case RTREQPOOLCFGVAR_MS_MIN_IDLE:
    793             *puValue = pPool->cMsMinIdle;
     891            u64 = pPool->cMsMinIdle;
    794892            break;
    795893
    796894        case RTREQPOOLCFGVAR_MS_IDLE_SLEEP:
    797             *puValue = pPool->cMsIdleSleep;
     895            u64 = pPool->cMsIdleSleep;
    798896            break;
    799897
    800898        case RTREQPOOLCFGVAR_PUSH_BACK_THRESHOLD:
    801             *puValue = pPool->cThreadsPushBackThreshold;
     899            u64 = pPool->cThreadsPushBackThreshold;
    802900            break;
    803901
    804902        case RTREQPOOLCFGVAR_PUSH_BACK_MIN_MS:
    805             *puValue = pPool->cMsMinPushBack;
     903            u64 = pPool->cMsMinPushBack;
    806904            break;
    807905
    808906        case RTREQPOOLCFGVAR_PUSH_BACK_MAX_MS:
    809             *puValue = pPool->cMsMaxPushBack;
     907            u64 = pPool->cMsMaxPushBack;
    810908            break;
    811909
    812910        case RTREQPOOLCFGVAR_MAX_FREE_REQUESTS:
    813             *puValue = pPool->cMaxFreeRequests;
     911            u64 = pPool->cMaxFreeRequests;
    814912            break;
    815913
    816914        default:
    817915            AssertFailed();
    818             rc = VERR_IPE_NOT_REACHED_DEFAULT_CASE;
    819             *puValue = UINT64_MAX;
     916            u64 = UINT64_MAX;
    820917            break;
    821918    }
    … …  
    823920    RTCritSectLeave(&pPool->CritSect);
    824921
    825     return rc;
    826 }
    827 RT_EXPORT_SYMBOL(RTReqPoolQueryCfgVar);
     922    return u64;
     923}
     924RT_EXPORT_SYMBOL(RTReqGetQueryCfgVar);
    828925
    829926
    … …  
    9391036        }
    9401037
    941         /* Finally, free the handle. */
     1038        /* Finally, free the critical section and pool instance. */
     1039        RTCritSectLeave(&pPool->CritSect);
     1040        RTCritSectDelete(&pPool->CritSect);
    9421041        RTMemFree(pPool);
    9431042    }
    … …  
    9921091RT_EXPORT_SYMBOL(RTReqPoolAlloc);
    9931092
     1093
     1094RTDECL(int) RTReqPoolCallEx( RTREQPOOL hPool, RTMSINTERVAL cMillies, PRTREQ *phReq, uint32_t fFlags, PFNRT pfnFunction, unsigned cArgs, ...)
     1095{
     1096    va_list va;
     1097    va_start(va, cArgs);
     1098    int rc = RTReqPoolCallExV(hPool, cMillies, phReq, fFlags, pfnFunction, cArgs, va);
     1099    va_end(va);
     1100    return rc;
     1101}
     1102RT_EXPORT_SYMBOL(RTReqPoolCallEx);
     1103
     1104
     1105RTDECL(int) RTReqPoolCallExV(RTREQPOOL hPool, RTMSINTERVAL cMillies, PRTREQ *phReq, uint32_t fFlags, PFNRT pfnFunction, unsigned cArgs, va_list va)
     1106{
     1107    /*
     1108     * Check input.
     1109     */
     1110    AssertPtrReturn(pfnFunction, VERR_INVALID_POINTER);
     1111    AssertMsgReturn(!((uint32_t)fFlags & ~(uint32_t)(RTREQFLAGS_NO_WAIT | RTREQFLAGS_RETURN_MASK)), ("%#x\n", (uint32_t)fFlags), VERR_INVALID_PARAMETER);
     1112    if (!(fFlags & RTREQFLAGS_NO_WAIT))
     1113    {
     1114        AssertPtrReturn(phReq, VERR_INVALID_POINTER);
     1115        *phReq = NIL_RTREQ;
     1116    }
     1117
     1118    PRTREQINT pReq = NULL;
     1119    AssertMsgReturn(cArgs * sizeof(uintptr_t) <= sizeof(pReq->u.Internal.aArgs), ("cArgs=%u\n", cArgs), VERR_TOO_MUCH_DATA);
     1120
     1121    /*
     1122     * Allocate and initialize the request.
     1123     */
     1124    int rc = RTReqPoolAlloc(hPool, RTREQTYPE_INTERNAL, &pReq);
     1125    if (RT_FAILURE(rc))
     1126        return rc;
     1127    pReq->fFlags           = fFlags;
     1128    pReq->u.Internal.pfn   = pfnFunction;
     1129    pReq->u.Internal.cArgs = cArgs;
     1130    for (unsigned iArg = 0; iArg < cArgs; iArg++)
     1131        pReq->u.Internal.aArgs[iArg] = va_arg(va, uintptr_t);
     1132
     1133    /*
     1134     * Submit the request.
     1135     */
     1136    rc = RTReqSubmit(pReq, cMillies);
     1137    if (   rc != VINF_SUCCESS
     1138        && rc != VERR_TIMEOUT)
     1139    {
     1140        Assert(rc != VERR_INTERRUPTED);
     1141        RTReqRelease(pReq);
     1142        pReq = NULL;
     1143    }
     1144
     1145    if (!(fFlags & RTREQFLAGS_NO_WAIT))
     1146    {
     1147        *phReq = pReq;
     1148        LogFlow(("RTReqPoolCallExV: returns %Rrc *phReq=%p\n", rc, pReq));
     1149    }
     1150    else
     1151        LogFlow(("RTReqPoolCallExV: returns %Rrc\n", rc));
     1152    return rc;
     1153}
     1154RT_EXPORT_SYMBOL(RTReqPoolCallExV);
     1155
     1156
     1157RTDECL(int) RTReqPoolCallWait(RTREQPOOL hPool, PFNRT pfnFunction, unsigned cArgs, ...)
     1158{
     1159    PRTREQINT pReq;
     1160    va_list   va;
     1161    va_start(va, cArgs);
     1162    int rc = RTReqPoolCallExV(hPool, RT_INDEFINITE_WAIT, &pReq, RTREQFLAGS_IPRT_STATUS,
     1163                              pfnFunction, cArgs, va);
     1164    va_end(va);
     1165    if (RT_SUCCESS(rc))
     1166        rc = pReq->iStatusX;
     1167    RTReqRelease(pReq);
     1168    return rc;
     1169}
     1170RT_EXPORT_SYMBOL(RTReqPoolCallWait);
     1171
     1172
     1173RTDECL(int) RTReqPoolCallNoWait(RTREQPOOL hPool, PFNRT pfnFunction, unsigned cArgs, ...)
     1174{
     1175    va_list   va;
     1176    va_start(va, cArgs);
     1177    int rc = RTReqPoolCallExV(hPool, 0, NULL, RTREQFLAGS_IPRT_STATUS | RTREQFLAGS_NO_WAIT,
     1178                              pfnFunction, cArgs, va);
     1179    va_end(va);
     1180    return rc;
     1181}
     1182RT_EXPORT_SYMBOL(RTReqPoolCallNoWait);
     1183
     1184
     1185RTDECL(int) RTReqPoolCallVoidWait(RTREQPOOL hPool, PFNRT pfnFunction, unsigned cArgs, ...)
     1186{
     1187    PRTREQINT pReq;
     1188    va_list   va;
     1189    va_start(va, cArgs);
     1190    int rc = RTReqPoolCallExV(hPool, RT_INDEFINITE_WAIT, &pReq, RTREQFLAGS_VOID,
     1191                              pfnFunction, cArgs, va);
     1192    va_end(va);
     1193    if (RT_SUCCESS(rc))
     1194        rc = pReq->iStatusX;
     1195    RTReqRelease(pReq);
     1196    return rc;
     1197}
     1198RT_EXPORT_SYMBOL(RTReqPoolCallVoidWait);
     1199
     1200
     1201RTDECL(int) RTReqPoolCallVoidNoWait(RTREQPOOL hPool, PFNRT pfnFunction, unsigned cArgs, ...)
     1202{
     1203    va_list   va;
     1204    va_start(va, cArgs);
     1205    int rc = RTReqPoolCallExV(hPool, 0, NULL, RTREQFLAGS_VOID | RTREQFLAGS_NO_WAIT,
     1206                              pfnFunction, cArgs, va);
     1207    va_end(va);
     1208    return rc;
     1209}
     1210RT_EXPORT_SYMBOL(RTReqPoolCallVoidNoWait);
     1211

  • trunk/src/VBox/Runtime/testcase/Makefile.kmk

    r39448 r39632  
    6565        tstFileLock \
    6666        tstFork \
     67        tstRTFsQueries \
    6768        tstRTGetOpt \
    6869        tstRTGetOptArgv \
    … …  
    9293        tstPrfRT \
    9394        tstRand \
    94         tstRTFsQueries \
     95        tstRTReqPool \
    9596        tstRTSemEventMulti \
    9697        tstSemMutex \
    … …  
    216217tstRTDigest_SOURCES = tstRTDigest.cpp
    217218
     219tstDir_TEMPLATE = VBOXR3TSTEXE
    218220tstDir_SOURCES = tstDir.cpp
    219221
     222tstDir-2_TEMPLATE = VBOXR3TSTEXE
    220223tstDir-2_SOURCES = tstDir-2.cpp
    221224
     225tstDir-3_TEMPLATE = VBOXR3TSTEXE
    222226tstDir-3_SOURCES = tstDir-3.cpp
    223227
     228tstRTDvm_TEMPLATE = VBOXR3TSTEXE
    224229tstRTDvm_SOURCES = tstRTDvm.cpp
    225230
     231tstEnv_TEMPLATE = VBOXR3TSTEXE
    226232tstEnv_SOURCES = tstEnv.cpp
    227233
    … …  
    231237tstErrUnique.cpp_DEPS = $(IPRT_OUT_DIR)/errmsgdata.h
    232238
     239tstFile_TEMPLATE = VBOXR3TSTEXE
    233240tstFile_SOURCES = tstFile.cpp
    234241
    … …  
    242249tstRTFileGetSize-1_SOURCES = tstRTFileGetSize-1.cpp
    243250
     251tstFileAppendWin-1_TEMPLATE = VBOXR3TSTEXE
    244252tstFileAppendWin-1_SOURCES = tstFileAppendWin-1.cpp
    245253
     254tstFileLock_TEMPLATE = VBOXR3TSTEXE
    246255tstFileLock_SOURCES = tstFileLock.cpp
    247256
     257tstFork_TEMPLATE = VBOXR3TSTEXE
    248258tstFork_SOURCES = tstFork.cpp
     259
     260tstRTFsQueries_TEMPLATE = VBOXR3TSTEXE
     261tstRTFsQueries_SOURCES = tstRTFsQueries.cpp
    249262
    250263tstRTGetOpt_TEMPLATE = VBOXR3TSTEXE
    … …  
    262275tstRTHeapSimple_SOURCES = tstRTHeapSimple.cpp
    263276
     277tstIoCtl_TEMPLATE = VBOXR3TSTEXE
    264278tstIoCtl_SOURCES = tstIoCtl.cpp
    265279
    … …  
    283297tstIprtMiniString_SOURCES = tstIprtMiniString.cpp
    284298
     299tstLdr_TEMPLATE = VBOXR3TSTEXE
    285300tstLdr_SOURCES = tstLdr.cpp
    286301
     302tstLdr-2_TEMPLATE = VBOXR3TSTEXE
    287303tstLdr-2_SOURCES = tstLdr-2.cpp
    288304tstLdr-2_DEFS = IN_DIS
    … …  
    315331endif # VBOX_WITH_RAW_MODE
    316332
     333tstLdr-3_TEMPLATE = VBOXR3TSTEXE
    317334tstLdr-3_SOURCES = tstLdr-3.cpp
    318335tstLdr-3_DEFS = IN_DIS
    … …  
    355372endif
    356373
     374tstLdr-4_TEMPLATE = VBOXR3TSTEXE
    357375tstLdr-4_SOURCES = tstLdr-4.cpp tstLdrDisasmTest.cpp
    358376tstLdr-4_DEFS = IN_DIS
    … …  
    360378        $(PATH_STAGE_LIB)/DisasmR3$(VBOX_SUFF_LIB)
    361379
     380tstLdrLoad_TEMPLATE = VBOXR3TSTEXE
    362381tstLdrLoad_SOURCES = tstLdrLoad.cpp
    363382
    … …  
    368387tstRTLockValidator_SOURCES = tstRTLockValidator.cpp
    369388
     389tstLog_TEMPLATE = VBOXR3TSTEXE
    370390tstLog_SOURCES = tstLog.cpp
    371391
     392tstMemAutoPtr_TEMPLATE = VBOXR3TSTEXE
    372393tstMemAutoPtr_SOURCES = tstMemAutoPtr.cpp
    373394
    … …  
    381402tstRTMemPool_SOURCES = tstRTMemPool.cpp
    382403
     404tstMove_TEMPLATE = VBOXR3TSTEXE
    383405tstMove_SOURCES = tstMove.cpp
    384406
     407tstMp-1_TEMPLATE = VBOXR3TSTEXE
    385408tstMp-1_SOURCES = tstMp-1.cpp
    386409
     410tstNoCrt-1_TEMPLATE = VBOXR3TSTEXE
    387411tstNoCrt-1_DEFS = RT_WITHOUT_NOCRT_WRAPPER_ALIASES
    388412tstNoCrt-1_SOURCES = \
    … …  
    399423        ../common/string/strlen.asm
    400424
     425tstOnce_TEMPLATE = VBOXR3TSTEXE
    401426tstOnce_SOURCES = tstOnce.cpp
    402427
    … …  
    410435tstRTPoll_SOURCES  = tstRTPoll.cpp
    411436
     437tstPrfRT_TEMPLATE = VBOXR3TSTEXE
    412438tstPrfRT_SOURCES = tstPrfRT.cpp
    413 
    414 tstRand_SOURCES = tstRand.cpp
    415 
    416 tstRTFsQueries_SOURCES = tstRTFsQueries.cpp
    417439
    418440tstRTPrfIO_TEMPLATE = VBOXR3TSTEXE
    … …  
    422444tstRTProcCreateEx_SOURCES = tstRTProcCreateEx.cpp
    423445
     446tstRTProcWait_TEMPLATE = VBOXR3TSTEXE
    424447tstRTProcWait_SOURCES = tstRTProcWait.cpp
    425448
     449tstRTProcIsRunningByName_TEMPLATE = VBOXR3TSTEXE
    426450tstRTProcIsRunningByName_SOURCES = tstRTProcIsRunningByName.cpp
    427451
     452tstRand_TEMPLATE = VBOXR3TSTEXE
     453tstRand_SOURCES = tstRand.cpp
     454
     455tstRTReqPool_TEMPLATE = VBOXR3TSTEXE
     456tstRTReqPool_SOURCES = tstRTReqPool.cpp
     457
     458tstRTS3_TEMPLATE = VBOXR3TSTEXE
    428459tstRTS3_SOURCES = tstRTS3.cpp
    429460
     461tstSemMutex_TEMPLATE = VBOXR3TSTEXE
    430462tstSemMutex_SOURCES = tstSemMutex.cpp
    431463
    … …  
    436468tstRTSemRW_SOURCES = tstRTSemRW.cpp
    437469
     470tstSemPingPong_TEMPLATE = VBOXR3TSTEXE
    438471tstSemPingPong_SOURCES = tstSemPingPong.cpp
    439472
    … …  
    456489tstRTStrFormat_SOURCES = tstRTStrFormat.cpp
    457490
     491tstStrSimplePattern_TEMPLATE = VBOXR3TSTEXE
    458492tstStrSimplePattern_SOURCES = tstStrSimplePattern.cpp
    459493
     494tstStrToNum_TEMPLATE = VBOXR3TSTEXE
    460495tstStrToNum_SOURCES = tstStrToNum.cpp
    461496
    … …  
    481516tstRTDirCreateUniqueNumbered_SOURCES = tstRTDirCreateUniqueNumbered.cpp
    482517
     518tstTermCallbacks_TEMPLATE = VBOXR3TSTEXE
    483519tstTermCallbacks_SOURCES = tstTermCallbacks.cpp
    484520
     521tstThread-1_TEMPLATE = VBOXR3TSTEXE
    485522tstThread-1_SOURCES = tstThread-1.cpp
    486523
    … …  
    491528tstRTThreadExecutionTime_SOURCES = tstRTThreadExecutionTime.cpp
    492529
     530tstTime_TEMPLATE = VBOXR3TSTEXE
    493531tstTime_SOURCES = tstTime.cpp
    494532
     533tstTime-2_TEMPLATE = VBOXR3TSTEXE
    495534tstTime-2_SOURCES = tstTime-2.cpp
    496535
     536tstTime-3_TEMPLATE = VBOXR3TSTEXE
    497537tstTime-3_SOURCES = tstTime-3.cpp
    498538
     539tstTime-4_TEMPLATE = VBOXR3TSTEXE
    499540tstTime-4_SOURCES = tstTime-4.cpp
    500541
     542tstTimer_TEMPLATE = VBOXR3TSTEXE
    501543tstTimer_SOURCES = tstTimer.cpp
    502544
     545tstTimerLR_TEMPLATE = VBOXR3TSTEXE
    503546tstTimerLR_SOURCES = tstTimerLR.cpp
    504547
    … …  
    512555tstRTUuid_SOURCES = tstRTUuid.cpp
    513556
     557tstUtf8_TEMPLATE = VBOXR3TSTEXE
    514558tstUtf8_SOURCES = tstUtf8.cpp
    515559
    … …  
    591635#
    592636
     637tstDarwinSched_TEMPLATE = VBOXR3TSTEXE
    593638tstDarwinSched_SOURCES = tstDarwinSched.cpp
    594639

  • trunk/src/VBox/Runtime/testcase/tstRTDvm.cpp

    r37270 r39632  
    2929*   Header Files                                                               *
    3030*******************************************************************************/
    31 #include <iprt/initterm.h>
     31#include <iprt/dvm.h>
     32
    3233#include <iprt/err.h>
    3334#include <iprt/test.h>
    34 #include <iprt/dvm.h>
    3535#include <iprt/file.h>
    3636#include <iprt/string.h>
    3737
     38
     39/*******************************************************************************
     40*   Structures and Typedefs                                                    *
     41*******************************************************************************/
    3842/**
    3943 * Disk structure.
    … …  
    5357} TSTRTDVMDISK, *PTSTRTDVMDISK;
    5458
     59
     60
    5561static int dvmDiskRead(void *pvUser, uint64_t off, void *pvBuf, size_t cbRead)
    5662{
    … …  
    5965    if (pDisk->fUseImage)
    6066        return RTFileReadAt(pDisk->hImage, off, pvBuf, cbRead, NULL);
    61     else
    62         return RTDvmVolumeRead(pDisk->hVol, off, pvBuf, cbRead);
     67    return RTDvmVolumeRead(pDisk->hVol, off, pvBuf, cbRead);
    6368}
    6469
    … …  
    6974    if (pDisk->fUseImage)
    7075        return RTFileWriteAt(pDisk->hImage, off, pvBuf, cbWrite, NULL);
    71     else
    72         return RTDvmVolumeWrite(pDisk->hVol, off, pvBuf, cbWrite);
     76    return RTDvmVolumeWrite(pDisk->hVol, off, pvBuf, cbWrite);
    7377}
    7478
    … …  
    7882    int rc = VINF_SUCCESS;
    7983
    80     memset(szPrefix, 0, sizeof(szPrefix));
     84    RT_ZERO(szPrefix);
    8185
    8286    if (cNesting < sizeof(szPrefix) - 1)
    … …  
    103107        return RTTestSummaryAndDestroy(hTest);
    104108    }
    105     else if (rc == VERR_NOT_SUPPORTED)
     109    if (rc == VERR_NOT_SUPPORTED)
    106110        return VINF_SUCCESS;
    107111
注意: 瀏覽 TracChangeset 來幫助您使用更動檢視器

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette