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

VBOXUSBTOOL_DECL(NTSTATUS) VBoxUsbToolGetStringDescriptor(PDEVICE_OBJECT pDevObj, char *pszResult, ULONG cbResult,                                                          int iIndex, int LangId, ULONG dwTimeoutMs){    char aBuf[MAXIMUM_USB_STRING_LENGTH];    AssertCompile(sizeof (aBuf) <= UINT8_MAX);    UCHAR cbBuf = (UCHAR)sizeof (aBuf);    PUSB_STRING_DESCRIPTOR pDr = (PUSB_STRING_DESCRIPTOR)&aBuf;    Assert(pszResult);    *pszResult = 0;    memset(pDr, 0, cbBuf);    pDr->bLength = cbBuf;    pDr->bDescriptorType = USB_STRING_DESCRIPTOR_TYPE;    NTSTATUS Status = VBoxUsbToolGetDescriptor(pDevObj, pDr, cbBuf, USB_STRING_DESCRIPTOR_TYPE, iIndex, LangId, dwTimeoutMs);    if (NT_SUCCESS(Status))    {        if (pDr->bLength >= sizeof (USB_STRING_DESCRIPTOR))        {            int rc = RTUtf16ToUtf8Ex(pDr->bString, (pDr->bLength - RT_OFFSETOF(USB_STRING_DESCRIPTOR, bString)) / sizeof(RTUTF16),                                     &pszResult, cbResult, NULL /*pcch*/);            if (RT_SUCCESS(rc))            {                USBLibPurgeEncoding(pszResult);                Status = STATUS_SUCCESS;            }            else                Status = STATUS_UNSUCCESSFUL;        }        else            Status = STATUS_INVALID_PARAMETER;    }    return Status;}

/** * Wrapper around RTNtPathExpand8dot3Path that allocates a buffer instead of * working on the input buffer. * * @returns IPRT status code, see RTNtPathExpand8dot3Path(). * @param   pUniStrSrc  The path to fix up. MaximumLength is the max buffer *                      length. * @param   fPathOnly   Whether to only process the path and leave the filename *                      as passed in. * @param   pUniStrDst  Output string.  On success, the caller must use *                      RTUtf16Free to free what the Buffer member points to. *                      This is all zeros and NULL on failure. */RTDECL(int) RTNtPathExpand8dot3PathA(PCUNICODE_STRING pUniStrSrc, bool fPathOnly, PUNICODE_STRING pUniStrDst){    /* Guess a reasonable size for the final version. */    size_t const cbShort = pUniStrSrc->Length;    size_t       cbLong  = RT_MIN(_64K - 1, cbShort * 8);    if (cbLong < RTPATH_MAX)        cbLong = RTPATH_MAX * 2;    AssertCompile(RTPATH_MAX * 2 < _64K);    pUniStrDst->Buffer = (WCHAR *)RTUtf16Alloc(cbLong);    if (pUniStrDst->Buffer != NULL)    {        /* Copy over the short name and fix it up. */        pUniStrDst->MaximumLength = (uint16_t)cbLong;        pUniStrDst->Length        = (uint16_t)cbShort;        memcpy(pUniStrDst->Buffer, pUniStrSrc->Buffer, cbShort);        pUniStrDst->Buffer[cbShort / sizeof(WCHAR)] = '/0';        int rc = RTNtPathExpand8dot3Path(pUniStrDst, fPathOnly);        if (RT_SUCCESS(rc))            return rc;        /* We failed, bail. */        RTUtf16Free(pUniStrDst->Buffer);        pUniStrDst->Buffer    = NULL;    }    pUniStrDst->Length        = 0;    pUniStrDst->MaximumLength = 0;    return VERR_NO_UTF16_MEMORY;}

RTDECL(int)  RTSemEventMultiCreateEx(PRTSEMEVENTMULTI phEventMultiSem, uint32_t fFlags, RTLOCKVALCLASS hClass,                                     const char *pszNameFmt, ...){    AssertReturn(!(fFlags & ~RTSEMEVENTMULTI_FLAGS_NO_LOCK_VAL), VERR_INVALID_PARAMETER);    AssertCompile(sizeof(RTSEMEVENTMULTIINTERNAL) > sizeof(void *));    AssertPtrReturn(phEventMultiSem, VERR_INVALID_POINTER);    RT_ASSERT_PREEMPTIBLE();    PRTSEMEVENTMULTIINTERNAL pThis = (PRTSEMEVENTMULTIINTERNAL)RTMemAlloc(sizeof(*pThis));    if (pThis)    {        pThis->u32Magic             = RTSEMEVENTMULTI_MAGIC;        pThis->fStateAndGen         = RTSEMEVENTMULTIDARWIN_STATE_GEN_INIT;        pThis->cRefs                = 1;        pThis->fHaveBlockedThreads  = false;        Assert(g_pDarwinLockGroup);        pThis->pSpinlock = lck_spin_alloc_init(g_pDarwinLockGroup, LCK_ATTR_NULL);        if (pThis->pSpinlock)        {            *phEventMultiSem = pThis;            return VINF_SUCCESS;        }        pThis->u32Magic = 0;        RTMemFree(pThis);    }    return VERR_NO_MEMORY;}

RTDECL(PRTTIMESPEC) RTTimeNow(PRTTIMESPEC pTime){    uint64_t u64;    AssertCompile(sizeof(u64) == sizeof(FILETIME));    GetSystemTimeAsFileTime((LPFILETIME)&u64);    return RTTimeSpecSetNtTime(pTime, u64);}

/** * Processes all available input. * * @returns IPRT status code. * * @param   pThis           The gzip I/O stream instance data. * @param   fBlocking       Whether to block or not. */static int rtZipGzip_CompressIt(PRTZIPGZIPSTREAM pThis, bool fBlocking){    /*     * Processes all the intput currently lined up for us.     */    while (pThis->Zlib.avail_in > 0)    {        /* Make sure there is some space in the output buffer before calling           deflate() so we don't waste time filling up the corners. */        static const size_t s_cbFlushThreshold = 4096;        AssertCompile(sizeof(pThis->abBuffer) >= s_cbFlushThreshold * 4);        if (pThis->Zlib.avail_out < s_cbFlushThreshold)        {            int rc = rtZipGzip_WriteOutputBuffer(pThis, fBlocking);            if (rc != VINF_SUCCESS)                return rc;            Assert(pThis->Zlib.avail_out >= s_cbFlushThreshold);        }        int rcZlib = deflate(&pThis->Zlib, Z_NO_FLUSH);        if (rcZlib != Z_OK)            return rtZipGzipConvertErrFromZlib(pThis, rcZlib);    }    return VINF_SUCCESS;}

RTDECL(int) RTSemMutexCreateEx(PRTSEMMUTEX phMutexSem, uint32_t fFlags,                               RTLOCKVALCLASS hClass, uint32_t uSubClass, const char *pszNameFmt, ...){    AssertReturn(!(fFlags & ~RTSEMMUTEX_FLAGS_NO_LOCK_VAL), VERR_INVALID_PARAMETER);    RT_ASSERT_PREEMPTIBLE();    AssertCompile(sizeof(RTSEMMUTEXINTERNAL) > sizeof(void *));    PRTSEMMUTEXINTERNAL pThis = (PRTSEMMUTEXINTERNAL)RTMemAlloc(sizeof(*pThis));    if (pThis)    {        pThis->u32Magic     = RTSEMMUTEX_MAGIC;        pThis->cWaiters     = 0;        pThis->cRefs        = 1;        pThis->cRecursions  = 0;        pThis->hNativeOwner = NIL_RTNATIVETHREAD;        Assert(g_pDarwinLockGroup);        pThis->pSpinlock = lck_spin_alloc_init(g_pDarwinLockGroup, LCK_ATTR_NULL);        if (pThis->pSpinlock)        {            *phMutexSem = pThis;            return VINF_SUCCESS;        }        RTMemFree(pThis);    }    return VERR_NO_MEMORY;}

/** * Returns the value of the specified segment register * */DISDECL(int) DISFetchRegSeg(PCCPUMCTXCORE pCtx, DIS_SELREG sel, RTSEL *pVal){    AssertReturn((unsigned)sel < RT_ELEMENTS(g_aRegSegIndex), VERR_INVALID_PARAMETER);    AssertCompile(sizeof(uint16_t) == sizeof(RTSEL));    *pVal = DIS_READ_REGSEG(pCtx, sel);    return VINF_SUCCESS;}

RTDECL(void) RTCrRc4(PRTCRRC4KEY pKey, size_t cbData, void const *pvDataIn, void *pvDataOut){    AssertCompile(sizeof(RC4_INT) == 4 ? sizeof(pKey->au64Padding) == sizeof(pKey->Ossl) : sizeof(pKey->au64Padding) >= sizeof(pKey->Ossl));    Assert((int)cbData == (ssize_t)cbData);    AssertPtr(pKey);    RC4(&pKey->Ossl, (int)cbData, (const unsigned char *)pvDataIn, (unsigned char *)pvDataOut);}

/** * Helper for getting the core ID for a given CPU/strand/hyperthread. * * @returns The core ID. * @param   idCpu       The CPU ID instance. */static inline uint64_t rtMpSolarisGetCoreId(RTCPUID idCpu){    kstat_named_t *pStat = (kstat_named_t *)kstat_data_lookup(g_papCpuInfo[idCpu], (char *)"core_id");    Assert(pStat->data_type == KSTAT_DATA_LONG);    Assert(pStat->value.l >= 0);    AssertCompile(sizeof(uint64_t) >= sizeof(long));    /* Paranoia. */    return (uint64_t)pStat->value.l;}

bool VBoxLikesVideoMode(uint32_t display, uint32_t width, uint32_t height, uint32_t bpp){    bool bRC = FALSE;    VMMDevVideoModeSupportedRequest2 *req2 = NULL;    int rc = VbglGRAlloc((VMMDevRequestHeader**)&req2, sizeof(VMMDevVideoModeSupportedRequest2), VMMDevReq_VideoModeSupported2);    if (RT_FAILURE(rc))    {        LOG(("ERROR allocating request, rc = %#xrc", rc));        /* Most likely the VBoxGuest driver is not loaded.         * To get at least the video working, report the mode as supported.         */        bRC = TRUE;    }    else    {        req2->display = display;        req2->width  = width;        req2->height = height;        req2->bpp    = bpp;        rc = VbglGRPerform(&req2->header);        if (RT_SUCCESS(rc))        {            bRC = req2->fSupported;        }        else        {            /* Retry using old interface. */            AssertCompile(sizeof(VMMDevVideoModeSupportedRequest2) >= sizeof(VMMDevVideoModeSupportedRequest));            VMMDevVideoModeSupportedRequest *req = (VMMDevVideoModeSupportedRequest *)req2;            req->header.size        = sizeof(VMMDevVideoModeSupportedRequest);            req->header.version     = VMMDEV_REQUEST_HEADER_VERSION;            req->header.requestType = VMMDevReq_VideoModeSupported;            req->header.rc          = VERR_GENERAL_FAILURE;            req->header.reserved1   = 0;            req->header.reserved2   = 0;            req->width  = width;            req->height = height;            req->bpp    = bpp;            rc = VbglGRPerform(&req->header);            if (RT_SUCCESS(rc))            {                bRC = req->fSupported;            }            else            {                WARN(("ERROR querying video mode supported status from VMMDev. rc = %#xrc", rc));            }        }        VbglGRFree(&req2->header);    }    LOG(("width: %d, height: %d, bpp: %d -> %s", width, height, bpp, (bRC == 1) ? "OK" : "FALSE"));    return bRC;}

/** * Opens the IOKit service, instantiating org_virtualbox_SupDrvClient. * * @returns VBox status code. */static int suplibDarwinOpenService(PSUPLIBDATA pThis){    /*     * Open the IOKit client first - The first step is finding the service.     */    mach_port_t MasterPort;    kern_return_t kr = IOMasterPort(MACH_PORT_NULL, &MasterPort);    if (kr != kIOReturnSuccess)    {        LogRel(("IOMasterPort -> %d/n", kr));        return VERR_GENERAL_FAILURE;    }    CFDictionaryRef ClassToMatch = IOServiceMatching(IOCLASS_NAME);    if (!ClassToMatch)    {        LogRel(("IOServiceMatching(/"%s/") failed./n", IOCLASS_NAME));        return VERR_GENERAL_FAILURE;    }    /* Create an io_iterator_t for all instances of our drivers class that exist in the IORegistry. */    io_iterator_t Iterator;    kr = IOServiceGetMatchingServices(MasterPort, ClassToMatch, &Iterator);    if (kr != kIOReturnSuccess)    {        LogRel(("IOServiceGetMatchingServices returned %d/n", kr));        return VERR_GENERAL_FAILURE;    }    /* Get the first item in the iterator and release it. */    io_service_t ServiceObject = IOIteratorNext(Iterator);    IOObjectRelease(Iterator);    if (!ServiceObject)    {        LogRel(("SUP: Couldn't find any matches. The kernel module is probably not loaded./n"));        return VERR_VM_DRIVER_NOT_INSTALLED;    }    /*     * Open the service.     *     * This will cause the user client class in SUPDrv-darwin.cpp to be     * instantiated and create a session for this process.     */    io_connect_t Connection = NULL;    kr = IOServiceOpen(ServiceObject, mach_task_self(), SUP_DARWIN_IOSERVICE_COOKIE, &Connection);    IOObjectRelease(ServiceObject);    if (kr != kIOReturnSuccess)    {        LogRel(("SUP: IOServiceOpen returned %d. Driver open failed./n", kr));        pThis->uConnection = 0;        return VERR_VM_DRIVER_OPEN_ERROR;    }    AssertCompile(sizeof(pThis->uConnection) >= sizeof(Connection));    pThis->uConnection = Connection;    return VINF_SUCCESS;}

HRESULT SystemProperties::getMinGuestRAM(ULONG *minRAM){    /* no need to lock, this is const */    AssertCompile(MM_RAM_MIN_IN_MB >= SchemaDefs::MinGuestRAM);    *minRAM = MM_RAM_MIN_IN_MB;    return S_OK;}

//*****************************************************************************//*****************************************************************************DISDECL(DISSELREG) DISDetectSegReg(PCDISSTATE pDis, PCDISOPPARAM pParam){    if (pDis->fPrefix & DISPREFIX_SEG)        /* Use specified SEG: prefix. */        return (DISSELREG)pDis->idxSegPrefix;    /* Guess segment register by parameter type. */    if (pParam->fUse & (DISUSE_REG_GEN32|DISUSE_REG_GEN64|DISUSE_REG_GEN16))    {        AssertCompile(DISGREG_ESP == DISGREG_RSP);        AssertCompile(DISGREG_EBP == DISGREG_RBP);        AssertCompile(DISGREG_ESP == DISGREG_SP);        AssertCompile(DISGREG_EBP == DISGREG_BP);        if (pParam->Base.idxGenReg == DISGREG_ESP || pParam->Base.idxGenReg == DISGREG_EBP)            return DISSELREG_SS;    }    /* Default is use DS: for data access. */    return DISSELREG_DS;}

/** * Native thread main function. * * @param   pvThreadInt     The thread structure. */static void rtThreadNativeMain(void *pvThreadInt){    PRTTHREADINT pThreadInt = (PRTTHREADINT)pvThreadInt;    AssertCompile(sizeof(kt_did_t) == sizeof(pThreadInt->tid));    uint64_t *pu64ThrId = SOL_THREAD_ID_PTR;    pThreadInt->tid = *pu64ThrId;    rtThreadMain(pThreadInt, RTThreadNativeSelf(), &pThreadInt->szName[0]);    thread_exit();}

/** * @callback_method_impl{PFNVMMEMTRENDEZVOUS, *      Worker for gimR3KvmEnableWallClock} */static DECLCALLBACK(VBOXSTRICTRC) gimR3KvmEnableWallClockCallback(PVM pVM, PVMCPU pVCpu, void *pvData){    Assert(pvData);    PKVMWALLCLOCKINFO pWallClockInfo  = (PKVMWALLCLOCKINFO)pvData;    RTGCPHYS          GCPhysWallClock = pWallClockInfo->GCPhysWallClock;    /*     * Read the wall-clock version (sequence) from the guest.     */    uint32_t uVersion;    Assert(PGMPhysIsGCPhysNormal(pVM, GCPhysWallClock));    int rc = PGMPhysSimpleReadGCPhys(pVM, &uVersion, GCPhysWallClock, sizeof(uVersion));    if (RT_FAILURE(rc))    {        LogRel(("GIM: KVM: Failed to read wall-clock struct. version at %#RGp. rc=%Rrc/n", GCPhysWallClock, rc));        return rc;    }    /*     * Ensure the version is incrementally even.     */    if (!(uVersion & 1))        ++uVersion;    ++uVersion;    /*     * Update wall-clock guest struct. with UTC information.     */    RTTIMESPEC TimeSpec;    int32_t    iSec;    int32_t    iNano;    TMR3UtcNow(pVM, &TimeSpec);    RTTimeSpecGetSecondsAndNano(&TimeSpec, &iSec, &iNano);    GIMKVMWALLCLOCK WallClock;    RT_ZERO(WallClock);    AssertCompile(sizeof(uVersion) == sizeof(WallClock.u32Version));    WallClock.u32Version = uVersion;    WallClock.u32Sec     = iSec;    WallClock.u32Nano    = iNano;    /*     * Write out the wall-clock struct. to guest memory.     */    Assert(!(WallClock.u32Version & 1));    rc = PGMPhysSimpleWriteGCPhys(pVM, GCPhysWallClock, &WallClock, sizeof(GIMKVMWALLCLOCK));    if (RT_SUCCESS(rc))    {        LogRel(("GIM: KVM: Enabled wall-clock struct. at %#RGp - u32Sec=%u u32Nano=%u uVersion=%#RU32/n", GCPhysWallClock,                WallClock.u32Sec, WallClock.u32Nano, WallClock.u32Version));    }    else        LogRel(("GIM: KVM: Failed to write wall-clock struct. at %#RGp. rc=%Rrc/n", GCPhysWallClock, rc));    return rc;}

/** * Read guest memory. * * @returns VBox status code. * * @param   pVM             Pointer to the shared VM structure. * @param   idCpu           The ID of the source CPU context (for the address). * @param   pAddress        Where to start reading. * @param   pvBuf           Where to store the data we've read. * @param   cbRead          The number of bytes to read. */VMMR3DECL(int) DBGFR3MemRead(PVM pVM, VMCPUID idCpu, PCDBGFADDRESS pAddress, void *pvBuf, size_t cbRead){    VM_ASSERT_VALID_EXT_RETURN(pVM, VERR_INVALID_VM_HANDLE);    AssertReturn(idCpu < pVM->cCpus, VERR_INVALID_CPU_ID);    if ((pAddress->fFlags & DBGFADDRESS_FLAGS_TYPE_MASK) == DBGFADDRESS_FLAGS_RING0)    {        AssertCompile(sizeof(RTHCUINTPTR) <= sizeof(pAddress->FlatPtr));        return VMMR3ReadR0Stack(pVM, idCpu, (RTHCUINTPTR)pAddress->FlatPtr, pvBuf, cbRead);    }    return VMR3ReqPriorityCallWait(pVM, idCpu, (PFNRT)dbgfR3MemRead, 5, pVM, idCpu, pAddress, pvBuf, cbRead);}

/** * Initializes a PDM critical section for internal use. * * The PDM critical sections are derived from the IPRT critical sections, but * works in GC as well. * * @returns VBox status code. * @param   pVM             Pointer to the VM. * @param   pDevIns         Device instance. * @param   pCritSect       Pointer to the critical section. * @param   RT_SRC_POS_DECL Use RT_SRC_POS. * @param   pszNameFmt      Format string for naming the critical section.  For *                          statistics and lock validation. * @param   ...             Arguments for the format string. * @thread  EMT(0) */VMMR3DECL(int) PDMR3CritSectInit(PVM pVM, PPDMCRITSECT pCritSect, RT_SRC_POS_DECL, const char *pszNameFmt, ...){#if HC_ARCH_BITS == 64 && GC_ARCH_BITS == 32    AssertCompile(sizeof(pCritSect->padding) >= sizeof(pCritSect->s));#endif    Assert(RT_ALIGN_P(pCritSect, sizeof(uintptr_t)) == pCritSect);    va_list va;    va_start(va, pszNameFmt);    int rc = pdmR3CritSectInitOne(pVM, &pCritSect->s, pCritSect, RT_SRC_POS_ARGS, pszNameFmt, va);    va_end(va);    return rc;}

/** Helper to convert HGSMI channel index to the channel structure pointer. * * @returns Pointer to the channel data. * @param pChannelInfo The channel pool. * @param u8Channel    The channel index. */HGSMICHANNEL *HGSMIChannelFindById(HGSMICHANNELINFO *pChannelInfo,                                   uint8_t u8Channel){    AssertCompile(RT_ELEMENTS(pChannelInfo->Channels) >= 0x100);    HGSMICHANNEL *pChannel = &pChannelInfo->Channels[u8Channel];    if (pChannel->u8Flags & HGSMI_CH_F_REGISTERED)    {        return pChannel;    }    return NULL;}

/** * Check if the instruction is patched as a duplicated function * * @returns patch record * @param   pVM         Pointer to the VM. * @param   pInstrGC    Guest context point to the instruction * */PPATMPATCHREC patmQueryFunctionPatch(PVM pVM, RTRCPTR pInstrGC){    PPATMPATCHREC pRec;    AssertCompile(sizeof(AVLOU32KEY) == sizeof(pInstrGC));    pRec = (PPATMPATCHREC)RTAvloU32Get(&CTXSUFF(pVM->patm.s.PatchLookupTree)->PatchTree, (AVLOU32KEY)pInstrGC);    if (    pRec        && (pRec->patch.uState == PATCH_ENABLED)        && (pRec->patch.flags & (PATMFL_DUPLICATE_FUNCTION|PATMFL_CALLABLE_AS_FUNCTION))       )        return pRec;    return 0;}

STDMETHODIMP SystemProperties::COMGETTER(MinGuestRAM)(ULONG *minRAM){    CheckComArgOutPointerValid(minRAM);    AutoCaller autoCaller(this);    if (FAILED(autoCaller.rc())) return autoCaller.rc();    /* no need to lock, this is const */    AssertCompile(MM_RAM_MIN_IN_MB >= SchemaDefs::MinGuestRAM);    *minRAM = MM_RAM_MIN_IN_MB;    return S_OK;}

RTR3DECL(int) RTFileFromNative(PRTFILE pFile, RTHCINTPTR uNative){    HANDLE h = (HANDLE)uNative;    AssertCompile(sizeof(h) == sizeof(uNative));    if (h == INVALID_HANDLE_VALUE)    {        AssertMsgFailed(("%p/n", uNative));        *pFile = NIL_RTFILE;        return VERR_INVALID_HANDLE;    }    *pFile = (RTFILE)h;    return VINF_SUCCESS;}

/** * Lookup a host context ring-0 address. * * @returns Pointer to the corresponding lookup record. * @returns NULL on failure. * @param   pVM     The cross context VM structure. * @param   R0Ptr   The host context ring-0 address to lookup. * @param   poff    Where to store the offset into the HMA memory chunk. */DECLINLINE(PMMLOOKUPHYPER) mmHyperLookupR0(PVM pVM, RTR0PTR R0Ptr, uint32_t *poff){    AssertCompile(sizeof(RTR0PTR) == sizeof(RTR3PTR));    /** @todo cache last lookup, this stuff ain't cheap! */    PMMLOOKUPHYPER  pLookup = (PMMLOOKUPHYPER)((uint8_t *)pVM->mm.s.CTX_SUFF(pHyperHeap) + pVM->mm.s.offLookupHyper);    for (;;)    {        switch (pLookup->enmType)        {            case MMLOOKUPHYPERTYPE_LOCKED:            {                const RTR0UINTPTR off = (RTR0UINTPTR)R0Ptr - (RTR0UINTPTR)pLookup->u.Locked.pvR0;                if (off < pLookup->cb && pLookup->u.Locked.pvR0)                {                    *poff = off;                    return pLookup;                }                break;            }            case MMLOOKUPHYPERTYPE_HCPHYS:            {                const RTR0UINTPTR off = (RTR0UINTPTR)R0Ptr - (RTR0UINTPTR)pLookup->u.HCPhys.pvR0;                if (off < pLookup->cb && pLookup->u.HCPhys.pvR0)                {                    *poff = off;                    return pLookup;                }                break;            }            case MMLOOKUPHYPERTYPE_GCPHYS:  /* (for now we'll not allow these kind of conversions) */            case MMLOOKUPHYPERTYPE_MMIO2:            case MMLOOKUPHYPERTYPE_DYNAMIC:                break;            default:                AssertMsgFailed(("enmType=%d/n", pLookup->enmType));                break;        }        /* next */        if (pLookup->offNext ==  (int32_t)NIL_OFFSET)            break;        pLookup = (PMMLOOKUPHYPER)((uint8_t *)pLookup + pLookup->offNext);    }    AssertMsgFailed(("R0Ptr=%RHv is not inside the hypervisor memory area!/n", R0Ptr));    return NULL;}

STDMETHODIMP Session::GetPID(ULONG *aPid){    AssertReturn(aPid, E_POINTER);    AutoCaller autoCaller(this);    AssertComRCReturn(autoCaller.rc(), autoCaller.rc());    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);    *aPid = (ULONG)RTProcSelf();    AssertCompile(sizeof(*aPid) == sizeof(RTPROCESS));    return S_OK;}

/** * Calculates the number of host CPU ticks till the next virtual sync deadline. * * @note    To save work, this function will not bother calculating the accurate *          tick count for deadlines that are more than a second ahead. * * @returns The number of host cpu ticks to the next deadline.  Max one second. * @param   cNsToDeadline       The number of nano seconds to the next virtual *                              sync deadline. */DECLINLINE(uint64_t) tmCpuCalcTicksToDeadline(uint64_t cNsToDeadline){    AssertCompile(TMCLOCK_FREQ_VIRTUAL <= _4G);    if (RT_UNLIKELY(cNsToDeadline >= TMCLOCK_FREQ_VIRTUAL))        return SUPGetCpuHzFromGIP(g_pSUPGlobalInfoPage);    uint64_t cTicks = ASMMultU64ByU32DivByU32(SUPGetCpuHzFromGIP(g_pSUPGlobalInfoPage),                                              cNsToDeadline,                                              TMCLOCK_FREQ_VIRTUAL);    if (cTicks > 4000)        cTicks -= 4000; /* fudge to account for overhead */    else        cTicks >>= 1;    return cTicks;}