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); }
RTDECL(int) RTStrCacheCreate(PRTSTRCACHE phStrCache, const char *pszName) { AssertCompile(sizeof(RTSTRCACHE) == sizeof(RTMEMPOOL)); AssertCompileNS(NIL_RTSTRCACHE == (RTSTRCACHE)NIL_RTMEMPOOL); AssertCompileNS(RTSTRCACHE_DEFAULT == (RTSTRCACHE)RTMEMPOOL_DEFAULT); return RTMemPoolCreate((PRTMEMPOOL)phStrCache, pszName); }
RTDECL(int) RTSpinlockCreate(PRTSPINLOCK pSpinlock, uint32_t fFlags, const char *pszName) { RT_ASSERT_PREEMPTIBLE(); AssertReturn(fFlags == RTSPINLOCK_FLAGS_INTERRUPT_SAFE || fFlags == RTSPINLOCK_FLAGS_INTERRUPT_UNSAFE, VERR_INVALID_PARAMETER); /* * Allocate. */ AssertCompile(sizeof(RTSPINLOCKINTERNAL) > sizeof(void *)); PRTSPINLOCKINTERNAL pThis = (PRTSPINLOCKINTERNAL)RTMemAlloc(sizeof(*pThis)); if (!pThis) return VERR_NO_MEMORY; /* * Initialize & return. */ pThis->u32Magic = RTSPINLOCK_MAGIC; pThis->fIntSaved = 0; pThis->fFlags = fFlags; pThis->pszName = pszName; Assert(g_pDarwinLockGroup); pThis->pSpinLock = lck_spin_alloc_init(g_pDarwinLockGroup, LCK_ATTR_NULL); if (!pThis->pSpinLock) { RTMemFree(pThis); return VERR_NO_MEMORY; } *pSpinlock = pThis; return VINF_SUCCESS; }
/** * 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; }
/** * Updates the specified segment register * */ DISDECL(int) DISWriteRegSeg(PCPUMCTXCORE pCtx, DIS_SELREG sel, RTSEL val) { AssertReturn((unsigned)sel < RT_ELEMENTS(g_aRegSegIndex), VERR_INVALID_PARAMETER); AssertCompile(sizeof(uint16_t) == sizeof(RTSEL)); DIS_WRITE_REGSEG(pCtx, sel, val); return VINF_SUCCESS; }
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; }
/** * Returns the value of the specified segment register including a pointer to the hidden register in the supplied cpu context * */ DISDECL(int) DISFetchRegSegEx(PCCPUMCTXCORE pCtx, DIS_SELREG sel, RTSEL *pVal, CPUMSELREGHID **ppSelHidReg) { AssertReturn((unsigned)sel < RT_ELEMENTS(g_aRegSegIndex), VERR_INVALID_PARAMETER); AssertCompile(sizeof(uint16_t) == sizeof(RTSEL)); *pVal = DIS_READ_REGSEG(pCtx, sel); *ppSelHidReg = (CPUMSELREGHID *)((char *)pCtx + g_aRegHidSegIndex[sel]); 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; }
HRESULT SystemProperties::getMaxGuestRAM(ULONG *maxRAM) { /* no need to lock, this is const */ AssertCompile(MM_RAM_MAX_IN_MB <= SchemaDefs::MaxGuestRAM); ULONG maxRAMSys = MM_RAM_MAX_IN_MB; ULONG maxRAMArch = maxRAMSys; *maxRAM = RT_MIN(maxRAMSys, maxRAMArch); return S_OK; }
RTDECL(PRTTIMESPEC) RTTimeLocalNow(PRTTIMESPEC pTime) { uint64_t u64; AssertCompile(sizeof(u64) == sizeof(FILETIME)); GetSystemTimeAsFileTime((LPFILETIME)&u64); uint64_t u64Local; if (!FileTimeToLocalFileTime((FILETIME const *)&u64, (LPFILETIME)&u64Local)) u64Local = u64; return RTTimeSpecSetNtTime(pTime, u64Local); }
//***************************************************************************** //***************************************************************************** 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; }