自学教程：C++ AssertReleaseRC函数代码示例

void testCreateFileSimple(RTTEST hTest){    VBOXHGCMSVCFNTABLE  svcTable;    VBOXHGCMSVCHELPERS  svcHelpers;    SHFLROOT Root;    const RTFILE hcFile = (RTFILE) 0x10000;    SHFLCREATERESULT Result;    int rc;    RTTestSub(hTest, "Create file simple");    Root = initWithWritableMapping(hTest, &svcTable, &svcHelpers,                                   "/test/mapping", "testname");    testRTFileOpenpFile = hcFile;    rc = createFile(&svcTable, Root, "/test/file", SHFL_CF_ACCESS_READ, NULL,                    &Result);    RTTEST_CHECK_RC_OK(hTest, rc);    RTTEST_CHECK_MSG(hTest,                     !strcmp(testRTFileOpenName, "/test/mapping/test/file"),                     (hTest, "pszFilename=%s/n", testRTFileOpenName));    RTTEST_CHECK_MSG(hTest, testRTFileOpenFlags == 0x181,                     (hTest, "fOpen=%llu/n", LLUIFY(testRTFileOpenFlags)));    RTTEST_CHECK_MSG(hTest, Result == SHFL_FILE_CREATED,                     (hTest, "Result=%d/n", (int) Result));    unmapAndRemoveMapping(hTest, &svcTable, Root, "testname");    AssertReleaseRC(svcTable.pfnDisconnect(NULL, 0, svcTable.pvService));    RTTestGuardedFree(hTest, svcTable.pvService);    RTTEST_CHECK_MSG(hTest, testRTFileCloseFile == hcFile,                     (hTest, "File=%llu/n", LLUIFY(testRTFileCloseFile)));}

void testFSInfoQuerySetEndOfFile(RTTEST hTest){    VBOXHGCMSVCFNTABLE  svcTable;    VBOXHGCMSVCHELPERS  svcHelpers;    SHFLROOT Root;    const RTFILE hcFile = (RTFILE) 0x10000;    const RTFOFF cbNew = 50000;    SHFLFSOBJINFO Info;    SHFLHANDLE Handle;    int rc;    RTTestSub(hTest, "Set end of file position");    Root = initWithWritableMapping(hTest, &svcTable, &svcHelpers,                                   "/test/mapping", "testname");    testRTFileOpenpFile = hcFile;    rc = createFile(&svcTable, Root, "/test/file", SHFL_CF_ACCESS_READ,                    &Handle, NULL);    RTTEST_CHECK_RC_OK(hTest, rc);    RT_ZERO(Info);    Info.cbObject = cbNew;    rc = sfInformation(&svcTable, Root, Handle, SHFL_INFO_SET | SHFL_INFO_SIZE,                       sizeof(Info), &Info);    RTTEST_CHECK_RC_OK(hTest, rc);    RTTEST_CHECK_MSG(hTest, testRTFileSetSizeFile == hcFile,                     (hTest, "File=%llu/n", LLUIFY(testRTFileSetSizeFile)));    RTTEST_CHECK_MSG(hTest, testRTFileSetSizeSize == cbNew,                     (hTest, "Size=%llu/n", LLUIFY(testRTFileSetSizeSize)));    unmapAndRemoveMapping(hTest, &svcTable, Root, "testname");    AssertReleaseRC(svcTable.pfnDisconnect(NULL, 0, svcTable.pvService));    RTTestGuardedFree(hTest, svcTable.pvService);    RTTEST_CHECK_MSG(hTest, testRTFileCloseFile == hcFile,                     (hTest, "File=%llu/n", LLUIFY(testRTFileCloseFile)));}

void testReadFileSimple(RTTEST hTest){    VBOXHGCMSVCFNTABLE  svcTable;    VBOXHGCMSVCHELPERS  svcHelpers;    SHFLROOT Root;    const RTFILE hcFile = (RTFILE) 0x10000;    SHFLHANDLE Handle;    const char *pcszReadData = "Data to read";    char acBuf[sizeof(pcszReadData) + 10];    uint32_t cbRead;    int rc;    RTTestSub(hTest, "Read file simple");    Root = initWithWritableMapping(hTest, &svcTable, &svcHelpers,                                   "/test/mapping", "testname");    testRTFileOpenpFile = hcFile;    rc = createFile(&svcTable, Root, "/test/file", SHFL_CF_ACCESS_READ,                    &Handle, NULL);    RTTEST_CHECK_RC_OK(hTest, rc);    testRTFileReadData = pcszReadData;    rc = readFile(&svcTable, Root, Handle, 0, strlen(pcszReadData) + 1,                  &cbRead, acBuf, (uint32_t)sizeof(acBuf));    RTTEST_CHECK_RC_OK(hTest, rc);    RTTEST_CHECK_MSG(hTest,                     !strncmp(acBuf, pcszReadData, sizeof(acBuf)),                     (hTest, "pvBuf=%.*s/n", sizeof(acBuf), acBuf));    RTTEST_CHECK_MSG(hTest, cbRead == strlen(pcszReadData) + 1,                     (hTest, "cbRead=%llu/n", LLUIFY(cbRead)));    unmapAndRemoveMapping(hTest, &svcTable, Root, "testname");    RTTEST_CHECK_MSG(hTest, testRTFileCloseFile == hcFile,                     (hTest, "File=%llu/n", LLUIFY(testRTFileCloseFile)));    AssertReleaseRC(svcTable.pfnDisconnect(NULL, 0, svcTable.pvService));    RTTestGuardedFree(hTest, svcTable.pvService);}

/* Event rate throttling timer to emulate the auxiliary device sampling rate. */static DECLCALLBACK(void) ps2mThrottleTimer(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser){    PPS2M       pThis = (PS2M *)pvUser; NOREF(pDevIns);    uint32_t    uHaveEvents;    /* Grab the lock to avoid races with PutEvent(). */    int rc = PDMCritSectEnter(pThis->pCritSectR3, VERR_SEM_BUSY);    AssertReleaseRC(rc);#if 0    /* If the input queue is not empty, restart the timer. */#else    /* If more movement is accumulated, report it and restart the timer. */    uHaveEvents = pThis->iAccumX | pThis->iAccumY | pThis->iAccumZ | pThis->fAccumB;    LogFlowFunc(("Have%s events/n", uHaveEvents ? "" : " no"));    if (uHaveEvents)#endif    {        ps2mReportAccumulatedEvents(pThis);        TMTimerSetMillies(pThis->CTX_SUFF(pThrottleTimer), pThis->uThrottleDelay);    }    else        pThis->fThrottleActive = false;    PDMCritSectLeave(pThis->pCritSectR3);}

void testWriteFileSimple(RTTEST hTest){    VBOXHGCMSVCFNTABLE  svcTable;    VBOXHGCMSVCHELPERS  svcHelpers;    SHFLROOT Root;    const RTFILE hcFile = (RTFILE) 0x10000;    SHFLHANDLE Handle;    const char *pcszWrittenData = "Data to write";    uint32_t cbToWrite = (uint32_t)strlen(pcszWrittenData) + 1;    uint32_t cbWritten;    int rc;    RTTestSub(hTest, "Write file simple");    Root = initWithWritableMapping(hTest, &svcTable, &svcHelpers,                                   "/test/mapping", "testname");    testRTFileOpenpFile = hcFile;    rc = createFile(&svcTable, Root, "/test/file", SHFL_CF_ACCESS_READ,                    &Handle, NULL);    RTTEST_CHECK_RC_OK(hTest, rc);    rc = writeFile(&svcTable, Root, Handle, 0, cbToWrite, &cbWritten,                   pcszWrittenData, cbToWrite);    RTTEST_CHECK_RC_OK(hTest, rc);    RTTEST_CHECK_MSG(hTest,                     !strcmp(testRTFileWriteData, pcszWrittenData),                     (hTest, "pvBuf=%s/n", testRTFileWriteData));    RTTEST_CHECK_MSG(hTest, cbWritten == cbToWrite,                     (hTest, "cbWritten=%llu/n", LLUIFY(cbWritten)));    unmapAndRemoveMapping(hTest, &svcTable, Root, "testname");    RTTEST_CHECK_MSG(hTest, testRTFileCloseFile == hcFile,                     (hTest, "File=%llu/n", LLUIFY(testRTFileCloseFile)));    AssertReleaseRC(svcTable.pfnDisconnect(NULL, 0, svcTable.pvService));    RTTestGuardedFree(hTest, svcTable.pvService);}

void testFlushFileSimple(RTTEST hTest){    VBOXHGCMSVCFNTABLE  svcTable;    VBOXHGCMSVCHELPERS  svcHelpers;    SHFLROOT Root;    const RTFILE hcFile = (RTFILE) 0x10000;    SHFLHANDLE Handle;    int rc;    RTTestSub(hTest, "Flush file simple");    Root = initWithWritableMapping(hTest, &svcTable, &svcHelpers,                                   "/test/mapping", "testname");    testRTFileOpenpFile = hcFile;    rc = createFile(&svcTable, Root, "/test/file", SHFL_CF_ACCESS_READ,                    &Handle, NULL);    RTTEST_CHECK_RC_OK(hTest, rc);    rc = flushFile(&svcTable, Root, Handle);    RTTEST_CHECK_RC_OK(hTest, rc);    RTTEST_CHECK_MSG(hTest, testRTFileFlushFile == hcFile,                     (hTest, "File=%llu/n", LLUIFY(testRTFileFlushFile)));    unmapAndRemoveMapping(hTest, &svcTable, Root, "testname");    AssertReleaseRC(svcTable.pfnDisconnect(NULL, 0, svcTable.pvService));    RTTestGuardedFree(hTest, svcTable.pvService);    RTTEST_CHECK_MSG(hTest, testRTFileCloseFile == hcFile,                     (hTest, "File=%llu/n", LLUIFY(testRTFileCloseFile)));}

/* Event rate throttling timer to emulate the auxiliary device sampling rate. */static DECLCALLBACK(void) ps2mThrottleTimer(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser){    RT_NOREF2(pDevIns, pTimer);    PPS2M       pThis = (PS2M *)pvUser;    uint32_t    uHaveEvents;    /* Grab the lock to avoid races with PutEvent(). */    int rc = PDMCritSectEnter(pThis->pCritSectR3, VERR_SEM_BUSY);    AssertReleaseRC(rc);#if 0    /* If the input queue is not empty, restart the timer. */#else    /* If more movement is accumulated, report it and restart the timer. */    uHaveEvents = pThis->iAccumX | pThis->iAccumY | pThis->iAccumZ | (pThis->fCurrB != pThis->fReportedB);    LogFlowFunc(("Have%s events/n", uHaveEvents ? "" : " no"));    if (uHaveEvents)#endif    {        /* Report accumulated data, poke the KBC, and start the timer. */        ps2mReportAccumulatedEvents(pThis, (GeneriQ *)&pThis->evtQ, true);        KBCUpdateInterrupts(pThis->pParent);        TMTimerSetMillies(pThis->CTX_SUFF(pThrottleTimer), pThis->uThrottleDelay);    }    else        pThis->fThrottleActive = false;    PDMCritSectLeave(pThis->pCritSectR3);}

void testDirListEmpty(RTTEST hTest){    VBOXHGCMSVCFNTABLE  svcTable;    VBOXHGCMSVCHELPERS  svcHelpers;    SHFLROOT Root;    PRTDIR pcDir = (PRTDIR)0x10000;    SHFLHANDLE Handle;    SHFLDIRINFO DirInfo;    uint32_t cFiles;    int rc;    RTTestSub(hTest, "List empty directory");    Root = initWithWritableMapping(hTest, &svcTable, &svcHelpers,                                   "/test/mapping", "testname");    testRTDirOpenpDir = pcDir;    rc = createFile(&svcTable, Root, "test/dir",                    SHFL_CF_DIRECTORY | SHFL_CF_ACCESS_READ, &Handle, NULL);    RTTEST_CHECK_RC_OK(hTest, rc);    rc = listDir(&svcTable, Root, Handle, 0, sizeof (SHFLDIRINFO), NULL,                 &DirInfo, sizeof(DirInfo), 0, &cFiles);    RTTEST_CHECK_RC(hTest, rc, VERR_NO_MORE_FILES);    RTTEST_CHECK_MSG(hTest, testRTDirReadExDir == pcDir,                     (hTest, "Dir=%llu/n", LLUIFY(testRTDirReadExDir)));    RTTEST_CHECK_MSG(hTest, cFiles == 0,                     (hTest, "cFiles=%llu/n", LLUIFY(cFiles)));    unmapAndRemoveMapping(hTest, &svcTable, Root, "testname");    AssertReleaseRC(svcTable.pfnDisconnect(NULL, 0, svcTable.pvService));    RTTestGuardedFree(hTest, svcTable.pvService);    RTTEST_CHECK_MSG(hTest,                     testRTDirClosepDir == pcDir,                     (hTest, "pDir=%llu/n", LLUIFY(testRTDirClosepDir)));}

DECLINLINE(void) rtThreadLockRD(void){    if (g_ThreadRWSem == NIL_RTSEMRW)        rtThreadInit();    int rc = RTSemRWRequestRead(g_ThreadRWSem, RT_INDEFINITE_WAIT);    AssertReleaseRC(rc);}

void testCreateDirSimple(RTTEST hTest){    VBOXHGCMSVCFNTABLE  svcTable;    VBOXHGCMSVCHELPERS  svcHelpers;    SHFLROOT Root;    PRTDIR pcDir = (PRTDIR)0x10000;    SHFLCREATERESULT Result;    int rc;    RTTestSub(hTest, "Create directory simple");    Root = initWithWritableMapping(hTest, &svcTable, &svcHelpers,                                   "/test/mapping", "testname");    testRTDirOpenpDir = pcDir;    rc = createFile(&svcTable, Root, "test/dir",                    SHFL_CF_DIRECTORY | SHFL_CF_ACCESS_READ, NULL, &Result);    RTTEST_CHECK_RC_OK(hTest, rc);    RTTEST_CHECK_MSG(hTest,                     !strcmp(testRTDirCreatePath, "/test/mapping/test/dir"),                     (hTest, "pszPath=%s/n", testRTDirCreatePath));    RTTEST_CHECK_MSG(hTest,                     !strcmp(testRTDirOpenName, "/test/mapping/test/dir"),                     (hTest, "pszFilename=%s/n", testRTDirOpenName));    RTTEST_CHECK_MSG(hTest, Result == SHFL_FILE_CREATED,                     (hTest, "Result=%d/n", (int) Result));    unmapAndRemoveMapping(hTest, &svcTable, Root, "testname");    AssertReleaseRC(svcTable.pfnDisconnect(NULL, 0, svcTable.pvService));    RTTestGuardedFree(hTest, svcTable.pvService);    RTTEST_CHECK_MSG(hTest,                     testRTDirClosepDir == pcDir,                     (hTest, "pDir=%llu/n", LLUIFY(testRTDirClosepDir)));}

/** @todo Mappings should be automatically removed by unloading the service, *        but unloading is currently a no-op! */static void unmapAndRemoveMapping(RTTEST hTest, VBOXHGCMSVCFNTABLE *psvcTable,                                  SHFLROOT root, const char *pcszFolderName){    VBOXHGCMSVCPARM aParms[RT_MAX(SHFL_CPARMS_UNMAP_FOLDER,                                  SHFL_CPARMS_REMOVE_MAPPING)];    VBOXHGCMCALLHANDLE_TYPEDEF callHandle = { VINF_SUCCESS };    struct TESTSHFLSTRING FolderName;    int rc;    aParms[0].setUInt32(root);    psvcTable->pfnCall(psvcTable->pvService, &callHandle, 0,                       psvcTable->pvService, SHFL_FN_UNMAP_FOLDER,                       SHFL_CPARMS_UNMAP_FOLDER, aParms);    AssertReleaseRC(callHandle.rc);    fillTestShflString(&FolderName, pcszFolderName);    aParms[0].setPointer(&FolderName,   RT_UOFFSETOF(SHFLSTRING, String)                                      + FolderName.string.u16Size);    rc = psvcTable->pfnHostCall(psvcTable->pvService, SHFL_FN_REMOVE_MAPPING,                                SHFL_CPARMS_REMOVE_MAPPING, aParms);    AssertReleaseRC(rc);}

/** @interface_method_impl{PDMPCIRAWHLPR3,pfnGetR0Helpers} */static DECLCALLBACK(PCPDMPCIRAWHLPR0) pdmR3PciRawHlp_GetR0Helpers(PPDMDEVINS pDevIns){    PDMDEV_ASSERT_DEVINS(pDevIns);    VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);    PCPDMHPETHLPR0 pR0Helpers = NIL_RTR0PTR;    int rc = PDMR3LdrGetSymbolR0(pDevIns->Internal.s.pVMR3, NULL, "g_pdmR0PciRawHlp", &pR0Helpers);    AssertReleaseRC(rc);    AssertRelease(pR0Helpers);    LogFlow(("pdmR3PciRawHlp_GetR0Helpers: caller='%s'/%d: returns %RHv/n",             pDevIns->pReg->szName, pDevIns->iInstance, pR0Helpers));    return pR0Helpers;}

/** @interface_method_impl{PDMIOAPICHLPR3,pfnGetR0Helpers} */static DECLCALLBACK(PCPDMIOAPICHLPR0) pdmR3IoApicHlp_GetR0Helpers(PPDMDEVINS pDevIns){    PDMDEV_ASSERT_DEVINS(pDevIns);    PVM pVM = pDevIns->Internal.s.pVMR3;    VM_ASSERT_EMT(pVM);    PCPDMIOAPICHLPR0 pR0Helpers = 0;    int rc = PDMR3LdrGetSymbolR0(pVM, NULL, "g_pdmR0IoApicHlp", &pR0Helpers);    AssertReleaseRC(rc);    AssertRelease(pR0Helpers);    LogFlow(("pdmR3IoApicHlp_GetR0Helpers: caller='%s'/%d: returns %RHv/n",             pDevIns->pReg->szName, pDevIns->iInstance, pR0Helpers));    return pR0Helpers;}

static SHFLROOT initWithWritableMapping(RTTEST hTest,                                        VBOXHGCMSVCFNTABLE *psvcTable,                                        VBOXHGCMSVCHELPERS *psvcHelpers,                                        const char *pcszFolderName,                                        const char *pcszMapping){    VBOXHGCMSVCPARM aParms[RT_MAX(SHFL_CPARMS_ADD_MAPPING,                                  SHFL_CPARMS_MAP_FOLDER)];    struct TESTSHFLSTRING FolderName;    struct TESTSHFLSTRING Mapping;    VBOXHGCMCALLHANDLE_TYPEDEF callHandle = { VINF_SUCCESS };    int rc;    initTable(psvcTable, psvcHelpers);    AssertReleaseRC(VBoxHGCMSvcLoad(psvcTable));    AssertRelease(  psvcTable->pvService                  = RTTestGuardedAllocTail(hTest, psvcTable->cbClient));    RT_BZERO(psvcTable->pvService, psvcTable->cbClient);    fillTestShflString(&FolderName, pcszFolderName);    fillTestShflString(&Mapping, pcszMapping);    aParms[0].setPointer(&FolderName,   RT_UOFFSETOF(SHFLSTRING, String)                                      + FolderName.string.u16Size);    aParms[1].setPointer(&Mapping,   RT_UOFFSETOF(SHFLSTRING, String)                                   + Mapping.string.u16Size);    aParms[2].setUInt32(1);    rc = psvcTable->pfnHostCall(psvcTable->pvService, SHFL_FN_ADD_MAPPING,                                SHFL_CPARMS_ADD_MAPPING, aParms);    AssertReleaseRC(rc);    aParms[0].setPointer(&Mapping,   RT_UOFFSETOF(SHFLSTRING, String)                                   + Mapping.string.u16Size);    aParms[1].setUInt32(0);  /* root */    aParms[2].setUInt32('/');  /* delimiter */    aParms[3].setUInt32(1);  /* case sensitive */    psvcTable->pfnCall(psvcTable->pvService, &callHandle, 0,                       psvcTable->pvService, SHFL_FN_MAP_FOLDER,                       SHFL_CPARMS_MAP_FOLDER, aParms);    AssertReleaseRC(callHandle.rc);    return aParms[1].u.uint32;}

void testLockFileSimple(RTTEST hTest){    VBOXHGCMSVCFNTABLE  svcTable;    VBOXHGCMSVCHELPERS  svcHelpers;    SHFLROOT Root;    const RTFILE hcFile = (RTFILE) 0x10000;    const int64_t offLock = 50000;    const uint64_t cbLock = 4000;    SHFLHANDLE Handle;    int rc;    RTTestSub(hTest, "Simple file lock and unlock");    Root = initWithWritableMapping(hTest, &svcTable, &svcHelpers,                                   "/test/mapping", "testname");    testRTFileOpenpFile = hcFile;    rc = createFile(&svcTable, Root, "/test/file", SHFL_CF_ACCESS_READ,                    &Handle, NULL);    RTTEST_CHECK_RC_OK(hTest, rc);    rc = lockFile(&svcTable, Root, Handle, offLock, cbLock, SHFL_LOCK_SHARED);    RTTEST_CHECK_RC_OK(hTest, rc);#ifdef RT_OS_WINDOWS  /* Locking is a no-op elsewhere. */    RTTEST_CHECK_MSG(hTest, testRTFileLockFile == hcFile,                     (hTest, "File=%llu/n", LLUIFY(testRTFileLockFile)));    RTTEST_CHECK_MSG(hTest, testRTFileLockfLock == 0,                     (hTest, "fLock=%u/n", testRTFileLockfLock));    RTTEST_CHECK_MSG(hTest, testRTFileLockOffset == offLock,                     (hTest, "Offs=%llu/n", (long long) testRTFileLockOffset));    RTTEST_CHECK_MSG(hTest, testRTFileLockSize == cbLock,                     (hTest, "Size=%llu/n", LLUIFY(testRTFileLockSize)));#endif    rc = lockFile(&svcTable, Root, Handle, offLock, cbLock, SHFL_LOCK_CANCEL);    RTTEST_CHECK_RC_OK(hTest, rc);#ifdef RT_OS_WINDOWS    RTTEST_CHECK_MSG(hTest, testRTFileUnlockFile == hcFile,                     (hTest, "File=%llu/n", LLUIFY(testRTFileUnlockFile)));    RTTEST_CHECK_MSG(hTest, testRTFileUnlockOffset == offLock,                     (hTest, "Offs=%llu/n",                      (long long) testRTFileUnlockOffset));    RTTEST_CHECK_MSG(hTest, testRTFileUnlockSize == cbLock,                     (hTest, "Size=%llu/n", LLUIFY(testRTFileUnlockSize)));#endif    unmapAndRemoveMapping(hTest, &svcTable, Root, "testname");    AssertReleaseRC(svcTable.pfnDisconnect(NULL, 0, svcTable.pvService));    RTTestGuardedFree(hTest, svcTable.pvService);    RTTEST_CHECK_MSG(hTest, testRTFileCloseFile == hcFile,                     (hTest, "File=%llu/n", LLUIFY(testRTFileCloseFile)));}

void testFSInfoQuerySetFileATime(RTTEST hTest){    VBOXHGCMSVCFNTABLE  svcTable;    VBOXHGCMSVCHELPERS  svcHelpers;    SHFLROOT Root;    const RTFILE hcFile = (RTFILE) 0x10000;    const int64_t ccAtimeNano = 100000;    SHFLFSOBJINFO Info;    SHFLHANDLE Handle;    int rc;    RTTestSub(hTest, "Query and set file atime");    Root = initWithWritableMapping(hTest, &svcTable, &svcHelpers,                                   "/test/mapping", "testname");    testRTFileOpenpFile = hcFile;    rc = createFile(&svcTable, Root, "/test/file", SHFL_CF_ACCESS_READ,                    &Handle, NULL);    RTTEST_CHECK_RC_OK(hTest, rc);    RT_ZERO(Info);    RTTimeSpecSetNano(&testRTFileQueryInfoATime, ccAtimeNano);    rc = sfInformation(&svcTable, Root, Handle, SHFL_INFO_FILE, sizeof(Info),                       &Info);    RTTEST_CHECK_RC_OK(hTest, rc);    RTTEST_CHECK_MSG(hTest, testRTFileQueryInfoFile == hcFile,                     (hTest, "File=%llu/n", LLUIFY(testRTFileQueryInfoFile)));    RTTEST_CHECK_MSG(hTest, RTTimeSpecGetNano(&Info.AccessTime) == ccAtimeNano,                     (hTest, "ATime=%llu/n",                      LLUIFY(RTTimeSpecGetNano(&Info.AccessTime))));    RT_ZERO(Info);    RTTimeSpecSetNano(&Info.AccessTime, ccAtimeNano);    rc = sfInformation(&svcTable, Root, Handle, SHFL_INFO_SET | SHFL_INFO_FILE,                       sizeof(Info), &Info);    RTTEST_CHECK_RC_OK(hTest, rc);    RTTEST_CHECK_MSG(hTest,    RTTimeSpecGetNano(&testRTFileSetTimesATime)                            == ccAtimeNano,                     (hTest, "ATime=%llu/n",                      LLUIFY(RTTimeSpecGetNano(&testRTFileSetTimesATime))));    unmapAndRemoveMapping(hTest, &svcTable, Root, "testname");    AssertReleaseRC(svcTable.pfnDisconnect(NULL, 0, svcTable.pvService));    RTTestGuardedFree(hTest, svcTable.pvService);    RTTEST_CHECK_MSG(hTest, testRTFileCloseFile == hcFile,                     (hTest, "File=%llu/n", LLUIFY(testRTFileCloseFile)));}

/** * Create a new thread. * * @returns iprt status code. * @param   pThread     Where to store the thread handle to the new thread. (optional) * @param   pfnThread   The thread function. * @param   pvUser      User argument. * @param   cbStack     The size of the stack for the new thread. *                      Use 0 for the default stack size. * @param   enmType     The thread type. Used for deciding scheduling attributes *                      of the thread. * @param   fFlags      Flags of the RTTHREADFLAGS type (ORed together). * @param   pszName     Thread name. */RTDECL(int) RTThreadCreate(PRTTHREAD pThread, PFNRTTHREAD pfnThread, void *pvUser, size_t cbStack,                           RTTHREADTYPE enmType, unsigned fFlags, const char *pszName){    int             rc;    PRTTHREADINT    pThreadInt;    LogFlow(("RTThreadCreate: pThread=%p pfnThread=%p pvUser=%p cbStack=%#x enmType=%d fFlags=%#x pszName=%p:{%s}/n",             pThread, pfnThread, pvUser, cbStack, enmType, fFlags, pszName, pszName));    /*     * Validate input.     */    if (!VALID_PTR(pThread) && pThread)    {        Assert(VALID_PTR(pThread));        return VERR_INVALID_PARAMETER;    }    if (!VALID_PTR(pfnThread))    {        Assert(VALID_PTR(pfnThread));        return VERR_INVALID_PARAMETER;    }    if (!pszName || !*pszName || strlen(pszName) >= RTTHREAD_NAME_LEN)    {        AssertMsgFailed(("pszName=%s (max len is %d because of logging)/n", pszName, RTTHREAD_NAME_LEN - 1));        return VERR_INVALID_PARAMETER;    }    if (fFlags & ~RTTHREADFLAGS_MASK)    {        AssertMsgFailed(("fFlags=%#x/n", fFlags));        return VERR_INVALID_PARAMETER;    }    /*     * Allocate thread argument.     */    pThreadInt = rtThreadAlloc(enmType, fFlags, 0, pszName);    if (pThreadInt)    {        RTNATIVETHREAD NativeThread;        pThreadInt->pfnThread = pfnThread;        pThreadInt->pvUser    = pvUser;        pThreadInt->cbStack   = cbStack;        rc = rtThreadNativeCreate(pThreadInt, &NativeThread);        if (RT_SUCCESS(rc))        {            rtThreadInsert(pThreadInt, NativeThread);            rtThreadRelease(pThreadInt);            Log(("RTThreadCreate: Created thread %p (%p) %s/n", pThreadInt, NativeThread, pszName));            if (pThread)                *pThread = pThreadInt;            return VINF_SUCCESS;        }        pThreadInt->cRefs = 1;        rtThreadRelease(pThreadInt);    }    else        rc = VERR_NO_TMP_MEMORY;    LogFlow(("RTThreadCreate: Failed to create thread, rc=%Rrc/n", rc));    AssertReleaseRC(rc);    return rc;}

//.........这里部分代码省略.........    /*     * Open the files.     */    RTFILE FileRawMem = NIL_RTFILE;    if (pszRawMem)    {        rc = RTFileOpen(&FileRawMem, pszRawMem, RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_WRITE);        if (RT_FAILURE(rc))        {            RTPrintf("tstAnimate: error: Failed to open '%s': %Rrc/n", pszRawMem, rc);            return 1;        }    }    RTFILE FileScript = NIL_RTFILE;    if (pszScript)    {        rc = RTFileOpen(&FileScript, pszScript, RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_WRITE);        if (RT_FAILURE(rc))        {            RTPrintf("tstAnimate: error: Failed to open '%s': %Rrc/n", pszScript, rc);            return 1;        }    }    /*     * Figure the memsize if not specified.     */    if (cbMem == ~0ULL)    {        if (FileRawMem != NIL_RTFILE)        {            rc = RTFileGetSize(FileRawMem, &cbMem);            AssertReleaseRC(rc);            cbMem -= offRawMem;            cbMem &= ~(PAGE_SIZE - 1);        }        else        {            RTPrintf("tstAnimate: error: too lazy to figure out the memsize in a saved state./n");            return 1;        }    }    RTPrintf("tstAnimate: info: cbMem=0x%llx bytes/n", cbMem);    /*     * Open a release log.     */    static const char * const s_apszGroups[] = VBOX_LOGGROUP_NAMES;    PRTLOGGER pRelLogger;    rc = RTLogCreate(&pRelLogger, RTLOGFLAGS_PREFIX_TIME_PROG, "all", "VBOX_RELEASE_LOG",                     RT_ELEMENTS(s_apszGroups), s_apszGroups, RTLOGDEST_FILE, "./tstAnimate.log");    if (RT_SUCCESS(rc))        RTLogRelSetDefaultInstance(pRelLogger);    else        RTPrintf("tstAnimate: rtLogCreateEx failed - %Rrc/n", rc);    /*     * Create empty VM.     */    PVM pVM;    rc = VMR3Create(1, NULL, NULL, NULL, cfgmR3CreateDefault, &cbMem, &pVM);    if (RT_SUCCESS(rc))    {        /*         * Load memory.

/* execute the switch. */VMMR3DECL(int) VMMDoTest(PVM pVM){#if 1    PVMCPU pVCpu = &pVM->aCpus[0];#ifdef NO_SUPCALLR0VMM    RTPrintf("NO_SUPCALLR0VMM/n");    return VINF_SUCCESS;#endif    /*     * Setup stack for calling VMMGCEntry().     */    RTRCPTR RCPtrEP;    int rc = PDMR3LdrGetSymbolRC(pVM, VMMGC_MAIN_MODULE_NAME, "VMMGCEntry", &RCPtrEP);    if (RT_SUCCESS(rc))    {        RTPrintf("VMM: VMMGCEntry=%RRv/n", RCPtrEP);        /*         * Test various crashes which we must be able to recover from.         */        vmmR3DoTrapTest(pVM, 0x3, 0, VINF_EM_DBG_HYPER_ASSERTION,  0xf0f0f0f0, "vmmGCTestTrap3_FaultEIP", "int3");        vmmR3DoTrapTest(pVM, 0x3, 1, VINF_EM_DBG_HYPER_ASSERTION,  0xf0f0f0f0, "vmmGCTestTrap3_FaultEIP", "int3 WP");#if defined(DEBUG_bird) /* guess most people would like to skip these since they write to com1. */        vmmR3DoTrapTest(pVM, 0x8, 0, VERR_TRPM_PANIC,       0x00000000, "vmmGCTestTrap8_FaultEIP", "#DF [#PG]");        SELMR3Relocate(pVM); /* this resets the busy flag of the Trap 08 TSS */        bool f;        rc = CFGMR3QueryBool(CFGMR3GetRoot(pVM), "DoubleFault", &f);#if !defined(DEBUG_bird)        if (RT_SUCCESS(rc) && f)#endif        {            /* see triple fault warnings in SELM and VMMGC.cpp. */            vmmR3DoTrapTest(pVM, 0x8, 1, VERR_TRPM_PANIC,       0x00000000, "vmmGCTestTrap8_FaultEIP", "#DF [#PG] WP");            SELMR3Relocate(pVM); /* this resets the busy flag of the Trap 08 TSS */        }#endif        vmmR3DoTrapTest(pVM, 0xd, 0, VERR_TRPM_DONT_PANIC,  0xf0f0f0f0, "vmmGCTestTrap0d_FaultEIP", "ltr #GP");        ///@todo find a better /#GP case, on intel ltr will /#PF (busy update?) and not /#GP.        //vmmR3DoTrapTest(pVM, 0xd, 1, VERR_TRPM_DONT_PANIC,  0xf0f0f0f0, "vmmGCTestTrap0d_FaultEIP", "ltr #GP WP");        vmmR3DoTrapTest(pVM, 0xe, 0, VERR_TRPM_DONT_PANIC,  0x00000000, "vmmGCTestTrap0e_FaultEIP", "#PF (NULL)");        vmmR3DoTrapTest(pVM, 0xe, 1, VERR_TRPM_DONT_PANIC,  0x00000000, "vmmGCTestTrap0e_FaultEIP", "#PF (NULL) WP");        vmmR3DoTrapTest(pVM, 0xe, 2, VINF_SUCCESS,          0x00000000, NULL,                       "#PF w/Tmp Handler");        /* This test is no longer relevant as fs and gs are loaded with NULL           selectors and we will always return to HC if a #GP occurs while           returning to guest code.        vmmR3DoTrapTest(pVM, 0xe, 4, VINF_SUCCESS,          0x00000000, NULL,                       "#PF w/Tmp Handler and bad fs");        */        /*         * Set a debug register and perform a context switch.         */        rc = vmmR3DoGCTest(pVM, VMMGC_DO_TESTCASE_NOP, 0);        if (rc != VINF_SUCCESS)        {            RTPrintf("VMM: Nop test failed, rc=%Rrc not VINF_SUCCESS/n", rc);            return rc;        }        /* a harmless breakpoint */        RTPrintf("VMM: testing hardware bp at 0x10000 (not hit)/n");        DBGFADDRESS Addr;        DBGFR3AddrFromFlat(pVM, &Addr, 0x10000);        RTUINT iBp0;        rc = DBGFR3BpSetReg(pVM, &Addr, 0,  ~(uint64_t)0, X86_DR7_RW_EO, 1, &iBp0);        AssertReleaseRC(rc);        rc = vmmR3DoGCTest(pVM, VMMGC_DO_TESTCASE_NOP, 0);        if (rc != VINF_SUCCESS)        {            RTPrintf("VMM: DR0=0x10000 test failed with rc=%Rrc!/n", rc);            return rc;        }        /* a bad one at VMMGCEntry */        RTPrintf("VMM: testing hardware bp at VMMGCEntry (hit)/n");        DBGFR3AddrFromFlat(pVM, &Addr, RCPtrEP);        RTUINT iBp1;        rc = DBGFR3BpSetReg(pVM, &Addr, 0,  ~(uint64_t)0, X86_DR7_RW_EO, 1, &iBp1);        AssertReleaseRC(rc);        rc = vmmR3DoGCTest(pVM, VMMGC_DO_TESTCASE_NOP, 0);        if (rc != VINF_EM_DBG_HYPER_BREAKPOINT)        {            RTPrintf("VMM: DR1=VMMGCEntry test failed with rc=%Rrc! expected VINF_EM_RAW_BREAKPOINT_HYPER/n", rc);            return rc;        }        /* resume the breakpoint */        RTPrintf("VMM: resuming hyper after breakpoint/n");        CPUMSetHyperEFlags(pVCpu, CPUMGetHyperEFlags(pVCpu) | X86_EFL_RF);        rc = VMMR3ResumeHyper(pVM, pVCpu);        if (rc != VINF_SUCCESS)        {            RTPrintf("VMM: failed to resume on hyper breakpoint, rc=%Rrc = KNOWN BUG/n", rc); /** @todo fix VMMR3ResumeHyper */            return rc;        }//.........这里部分代码省略.........