Changeset 4755

Timestamp:

09/13/07 10:05:08 (1 year ago)

Author:

vboxsync

Message:

Reverse allocation for Windows hosts: physical pages are allocated in the support driver and mapped into user space
VMM: Use locked memory for the MM pagepool structures.

Files:

• trunk/include/VBox/sup.h (modified) (1 diff)
• trunk/include/iprt/cdefs.h (modified) (2 diffs)
• trunk/src/VBox/HostDrivers/Support/SUPDRV.h (modified) (1 diff)
• trunk/src/VBox/HostDrivers/Support/SUPDRVIOC.h (modified) (2 diffs)
• trunk/src/VBox/HostDrivers/Support/SUPDRVShared.c (modified) (7 diffs)
• trunk/src/VBox/HostDrivers/Support/SUPLib.cpp (modified) (3 diffs)
• trunk/src/VBox/HostDrivers/Support/win/SUPDrv-win.cpp (modified) (1 diff)
• trunk/src/VBox/Runtime/r0drv/memobj-r0drv.cpp (modified) (2 diffs)
• trunk/src/VBox/VMM/MMInternal.h (modified) (1 diff)
• trunk/src/VBox/VMM/MMPagePool.cpp (modified) (4 diffs)
• trunk/src/VBox/VMM/VMMR0/VMMR0.cpp (modified) (2 diffs)

trunk/include/VBox/sup.h

@@ -560 +560 @@
-SUPR0DECL(int) SUPR0MemGetPhys(PSUPDRVSESSION pSession, RTHCUINTPTR uPtr, PSUPPAGE paPages);
-SUPR0DECL(int) SUPR0MemFree(PSUPDRVSESSION pSession, RTHCUINTPTR uPtr);
+SUPR0DECL(int) SUPR0PageAlloc(PSUPDRVSESSION pSession, uint32_t cb, PRTR3PTR ppvR3);
+SUPR0DECL(int) SUPR0PageGetPhys(PSUPDRVSESSION pSession, RTHCUINTPTR uPtr, uint32_t cPages, PSUPPAGE paPages);
+SUPR0DECL(int) SUPR0PageFree(PSUPDRVSESSION pSession, RTHCUINTPTR uPtr);
+SUPR0DECL(bool) SUPR0PageWasLockedByPageAlloc(PSUPDRVSESSION pSession, RTHCUINTPTR uPtr);
-SUPR0DECL(int) SUPR0GipMap(PSUPDRVSESSION pSession, PRTR3PTR ppGipR3, PRTHCPHYS pHCPhysGid);
-SUPR0DECL(int) SUPR0GipUnmap(PSUPDRVSESSION pSession);

trunk/include/iprt/cdefs.h

@@ -227 +227 @@
-#endif
-
+/** @def CTXTYPE
+ * Declare a type differently in GC vs R3 and R0.
+ *
+ * @param   GCType  The GC type.
+ * @param   R3Type  The R3 type.
+ * @param   R0Type  The R0 type.
+ * @remark  For pointers used only in one context use GCPTRTYPE(), HCPTRTYPE(), R3PTRTYPE() or R0PTRTYPE().
+ */
+#ifdef IN_GC
+# define CTR3R0TYPE(GCType, R3Type, R0Type)  GCType
+#else
+# define CTR3R0TYPE(GCType, R3Type, R0Type)  R3Type
+#endif
+
-/** @def GCTYPE
- * Declare a type differently in GC and HC.
@@ -253 +267 @@
- */
-#define HCPTRTYPE(HCType)       CTXTYPE(RTHCPTR, HCType, HCType)
+
+/** @def R3R0PTRTYPE
+ * Declare a pointer which is used in HC, is explicitely valid in ring 3 and 0, 
+ * but appears in structure(s) used by both HC and GC. The main purpose is to 
+ * make sure structures have the same size when built for different architectures.
+ *
+ * @param   R3R0Type  The R3R0 type.
+ */
+#define R3R0PTRTYPE(R3R0Type)       CTR3R0TYPE(RTHCPTR, R3R0Type, R3R0Type)
-
-/** @def R3PTRTYPE

trunk/src/VBox/HostDrivers/Support/SUPDRV.h

@@ -357 +357 @@
-    /** Memory block (r3 and r0 mapping). */
-    MEMREF_TYPE_MEM,
+    /** Locked memory (r3 mapping only) allocated by the support driver. */
+    MEMREF_TYPE_LOCKED_SUP,
-    /** Blow the type up to 32-bit and mark the end. */
-    MEMREG_TYPE_32BIT_HACK = 0x7fffffff

trunk/src/VBox/HostDrivers/Support/SUPDRVIOC.h

@@ -134 +134 @@
-/** Set the VM handle for doing fast call ioctl calls. */
-#define SUP_IOCTL_SET_VM_FOR_FAST   SUP_CTL_CODE(20)
+/** Allocate memory and map into the user process. */
+#define SUP_IOCTL_PAGE_ALLOC        SUP_CTL_CODE(21)
+/** Free memory allocated with SUP_IOCTL_PAGE_ALLOC. */
+#define SUP_IOCTL_PAGE_FREE         SUP_CTL_CODE(22)
-
-/** Fast path IOCtl: VMMR0_DO_RAW_RUN */
@@ -598 +602 @@
-} SUPSETVMFORFAST_IN, *PSUPSETVMFORFAST_IN;
-
+typedef struct SUPALLOCPAGE_IN
+{
+    /** Cookie. */
+    uint32_t        u32Cookie;
+    /** Session cookie. */
+    uint32_t        u32SessionCookie;
+    /** Number of pages to allocate */
+    uint32_t        cPages;
+} SUPALLOCPAGE_IN, *PSUPALLOCPAGE_IN;
+
+typedef struct SUPALLOCPAGE_OUT
+{
+    /** Cookie. */
+    uint32_t            u32Cookie;
+    /** Returned ring-3 address */
+    R3PTRTYPE(void *)   pvR3;
+} SUPALLOCPAGE_OUT, *PSUPALLOCPAGE_OUT;
+
+typedef struct SUPFREEPAGE_IN
+{
+    /** Cookie. */
+    uint32_t            u32Cookie;
+    /** Session cookie. */
+    uint32_t        u32SessionCookie;
+    /** Address of memory range to free */
+    R3PTRTYPE(void *)   pvR3;
+} SUPFREEPAGE_IN, *PSUPFREEPAGE_IN;
+
-#pragma pack()                          /* paranoia */
-

trunk/src/VBox/HostDrivers/Support/SUPDRVShared.c

@@ -85 +85 @@
-    { "SUPR0MemGetPhys",                        (void *)SUPR0MemGetPhys },
-    { "SUPR0MemFree",                           (void *)SUPR0MemFree },
+#ifdef USE_NEW_OS_INTERFACE_FOR_MM
+    { "SUPR0PageAlloc",                         (void *)SUPR0PageAlloc },
+    { "SUPR0PageGetPhys",                       (void *)SUPR0PageGetPhys },
+    { "SUPR0PageFree",                          (void *)SUPR0PageFree },
+#endif
-    { "SUPR0Printf",                            (void *)SUPR0Printf },
-    { "RTMemAlloc",                             (void *)RTMemAlloc },
@@ -462 +467 @@
-            {
-                int rc;
+                dprintf2(("eType=%d pvR0=%p pvR3=%p cb=%d\n", pBundle->aMem[i].eType,
+                          RTR0MemObjAddress(pBundle->aMem[i].MapObj), RTR0MemObjAddressR3(pBundle->aMem[i].MapObjR3), RTR0MemObjSize(pBundle->aMem[i].MemObj)));
-                if (pBundle->aMem[i].MapObjR3 != NIL_RTR0MEMOBJ)
-                {
@@ -1381 +1388 @@
-        }
-
+#ifdef USE_NEW_OS_INTERFACE_FOR_MM
+        case SUP_IOCTL_PAGE_ALLOC:
+        {
+            int               rc;
+            PSUPALLOCPAGE_IN  pIn  = (PSUPALLOCPAGE_IN)pvIn;
+            PSUPALLOCPAGE_OUT pOut = (PSUPALLOCPAGE_OUT)pvOut;
+
+            /*
+             * Validate.
+             */
+            if (    cbIn != sizeof(*pIn)
+                ||  cbOut < sizeof(*pOut))
+            {
+                dprintf(("SUP_IOCTL_PAGE_ALLOC: Invalid input/output sizes. cbIn=%ld expected %ld. cbOut=%ld expected %ld.\n",
+                         (long)cbIn, (long)sizeof(*pIn), (long)cbOut, (long)sizeof(*pOut)));
+                return SUPDRV_ERR_INVALID_PARAM;
+            }
+            if (    pIn->u32Cookie != pDevExt->u32Cookie
+                ||  pIn->u32SessionCookie != pSession->u32Cookie 
+                ||  pOut->u32Cookie != pDevExt->u32Cookie)
+            {
+                dprintf(("SUP_IOCTL_PAGE_ALLOC: Cookie mismatch {%#x,%#x} != {%#x,%#x}!\n",
+                         pIn->u32Cookie,  pDevExt->u32Cookie, pIn->u32SessionCookie, pSession->u32Cookie));
+                return SUPDRV_ERR_INVALID_MAGIC;
+            }
+            /*
+             * Execute.
+             */
+            *pcbReturned = sizeof(*pOut);
+            rc = SUPR0PageAlloc(pSession, pIn->cPages, &pOut->pvR3);
+            if (rc)
+                *pcbReturned = 0;
+            return rc;
+        }
+
+        case SUP_IOCTL_PAGE_FREE:
+        {
+            PSUPFREEPAGE_IN pIn = (PSUPFREEPAGE_IN)pvIn;
+
+            /*
+             * Validate.
+             */
+            if (    cbIn != sizeof(*pIn)
+                ||  cbOut != 0)
+            {
+                dprintf(("SUP_IOCTL_PAGE_FREE: Invalid input/output sizes. cbIn=%ld expected %ld. cbOut=%ld expected %ld.\n",
+                         (long)cbIn, (long)sizeof(*pIn), (long)cbOut, (long)0));
+                return SUPDRV_ERR_INVALID_PARAM;
+            }
+            if (    pIn->u32Cookie != pDevExt->u32Cookie
+                ||  pIn->u32SessionCookie != pSession->u32Cookie)
+            {
+                dprintf(("SUP_IOCTL_PAGE_FREE: Cookie mismatch {%#x,%#x} != {%#x,%#x}!\n",
+                         pIn->u32Cookie, pDevExt->u32Cookie, pIn->u32SessionCookie, pSession->u32Cookie));
+                return SUPDRV_ERR_INVALID_MAGIC;
+            }
+            /*
+             * Execute.
+             */
+            return SUPR0PageFree(pSession, (RTHCUINTPTR)pIn->pvR3);
+        }
+#endif /* USE_NEW_OS_INTERFACE_FOR_MM */
-
-        default:
@@ -1770 +1839 @@
-
-#ifdef USE_NEW_OS_INTERFACE_FOR_MM
+    /* First check if we allocated it using SUPPageAlloc; if so then we don't need to lock it again */
+    rc = SUPR0PageGetPhys(pSession, pvR3, cPages, paPages);
+    if (RT_SUCCESS(rc))
+        return rc;
+
-    /*
-     * Let IPRT do the job.
@@ -1836 +1910 @@
-{
-    dprintf(("SUPR0UnlockMem: pSession=%p pvR3=%p\n", pSession, (void *)pvR3));
+
+    /* SUPR0PageFree will unlock SUPR0PageAlloc allocations; ignore this call */
+    if (SUPR0PageWasLockedByPageAlloc(pSession, pvR3))
+    {
+        dprintf(("Page will be unlocked in SUPR0PageFree -> ignore\n"));
+        return 0;
+    }
+
-    return supdrvMemRelease(pSession, (RTHCUINTPTR)pvR3, MEMREF_TYPE_LOCKED);
-}
@@ -2055 +2137 @@
-    return supdrvMemRelease(pSession, uPtr, MEMREF_TYPE_LOW);
-}
+
-
-
@@ -2237 +2320 @@
-
-
+#ifdef USE_NEW_OS_INTERFACE_FOR_MM
+/**
+ * Allocates a chunk of memory with only a R3 mappings.
+ * The memory is fixed and it's possible to query the physical addresses using SUPR0MemGetPhys().
+ *
+ * @returns 0 on success.
+ * @returns SUPDRV_ERR_* on failure.
+ * @param   pSession    The session to associated the allocation with.
+ * @param   cb          Number of bytes to allocate.
+ * @param   ppvR3       Where to store the address of the Ring-3 mapping.
+ */
+SUPR0DECL(int) SUPR0PageAlloc(PSUPDRVSESSION pSession, uint32_t cb, PRTR3PTR ppvR3)
+{
+    int             rc;
+    SUPDRVMEMREF    Mem = {0};
+    dprintf(("SUPR0PageAlloc: pSession=%p cb=%d ppvR3=%p\n", pSession, cb, ppvR3));
+
+    /*
+     * Validate input.
+     */
+    if (!pSession || !ppvR3)
+    {
+        dprintf(("Null pointer. All of these should be set: pSession=%p ppvR3=%p\n",
+                 pSession, ppvR3));
+        return SUPDRV_ERR_INVALID_PARAM;
+
+    }
+    if (cb < 1 || cb >= 4096)
+    {
+        dprintf(("Illegal request cb=%u; must be greater than 0 and smaller than 16MB.\n", cb));
+        return SUPDRV_ERR_INVALID_PARAM;
+    }
+
+    /*
+     * Let IPRT do the work.
+     */
+    rc = RTR0MemObjAllocPhysNC(&Mem.MemObj, cb * PAGE_SIZE, NIL_RTHCPHYS);
+    if (RT_SUCCESS(rc))
+    {
+        int rc2;
+        rc = RTR0MemObjMapUser(&Mem.MapObjR3, Mem.MemObj, (RTR3PTR)-1, 0,
+                               RTMEM_PROT_EXEC | RTMEM_PROT_WRITE | RTMEM_PROT_READ, RTR0ProcHandleSelf());
+        if (RT_SUCCESS(rc))
+        {
+            Mem.eType = MEMREF_TYPE_LOCKED_SUP;
+            rc = supdrvMemAdd(&Mem, pSession);
+            if (!rc)
+            {
+                *ppvR3 = RTR0MemObjAddressR3(Mem.MapObjR3);
+                return 0;
+            }
+            rc2 = RTR0MemObjFree(Mem.MapObjR3, false);
+            AssertRC(rc2);
+        }
+
+        rc2 = RTR0MemObjFree(Mem.MemObj, false);
+        AssertRC(rc2);
+    }
+    return rc;
+}
+
+/**
+ * Check if the pages were locked by SUPR0PageAlloc
+ *
+ * @returns boolean
+ * @param   pSession        The session to which the memory was allocated.
+ * @param   uPtr            The Ring-3 address returned by SUPR0PageAlloc().
+ */
+SUPR0DECL(bool) SUPR0PageWasLockedByPageAlloc(PSUPDRVSESSION pSession, RTHCUINTPTR uPtr)
+{
+    PSUPDRVBUNDLE pBundle;
+    RTSPINLOCKTMP SpinlockTmp = RTSPINLOCKTMP_INITIALIZER;
+    dprintf(("SUPR0PageIsLockedByPageAlloc: pSession=%p uPtr=%p\n", pSession, (void *)uPtr));
+
+    /*
+     * Validate input.
+     */
+    if (!pSession)
+    {
+        dprintf(("pSession must not be NULL!"));
+        return false;
+    }
+    if (!uPtr)
+    {
+        dprintf(("Illegal address uPtr=%p\n", (void *)uPtr));
+        return false;
+    }
+
+    /*
+     * Search for the address.
+     */
+    RTSpinlockAcquire(pSession->Spinlock, &SpinlockTmp);
+    for (pBundle = &pSession->Bundle; pBundle; pBundle = pBundle->pNext)
+    {
+        if (pBundle->cUsed > 0)
+        {
+            unsigned i;
+            for (i = 0; i < sizeof(pBundle->aMem) / sizeof(pBundle->aMem[0]); i++)
+            {
+                if (    pBundle->aMem[i].eType == MEMREF_TYPE_LOCKED_SUP
+                    &&  pBundle->aMem[i].MemObj != NIL_RTR0MEMOBJ
+                    &&  (   (RTHCUINTPTR)RTR0MemObjAddress(pBundle->aMem[i].MemObj) == uPtr
+                         || (   pBundle->aMem[i].MapObjR3 != NIL_RTR0MEMOBJ
+                             && RTR0MemObjAddressR3(pBundle->aMem[i].MapObjR3) == uPtr)
+                        )
+                   )
+                {
+                    RTSpinlockRelease(pSession->Spinlock, &SpinlockTmp);
+                    return true;
+                }
+            }
+        }
+    }
+    RTSpinlockRelease(pSession->Spinlock, &SpinlockTmp);
+    return false;
+}
+
+/**
+ * Get the physical addresses of memory allocated using SUPR0PageAlloc().
+ *
+ * @returns 0 on success.
+ * @returns SUPDRV_ERR_* on failure.
+ * @param   pSession        The session to which the memory was allocated.
+ * @param   uPtr            The Ring-3 address returned by SUPR0PageAlloc().
+ * @param   cPages          Number of pages in paPages
+ * @param   paPages         Where to store the physical addresses.
+ */
+SUPR0DECL(int) SUPR0PageGetPhys(PSUPDRVSESSION pSession, RTHCUINTPTR uPtr, uint32_t cPages, PSUPPAGE paPages)
+{
+    PSUPDRVBUNDLE pBundle;
+    RTSPINLOCKTMP SpinlockTmp = RTSPINLOCKTMP_INITIALIZER;
+    dprintf(("SUPR0PageGetPhys: pSession=%p uPtr=%p paPages=%p\n", pSession, (void *)uPtr, paPages));
+
+    /*
+     * Validate input.
+     */
+    if (!pSession)
+    {
+        dprintf(("pSession must not be NULL!"));
+        return SUPDRV_ERR_INVALID_PARAM;
+    }
+    if (!uPtr || !paPages)
+    {
+        dprintf(("Illegal address uPtr=%p or/and paPages=%p\n", (void *)uPtr, paPages));
+        return SUPDRV_ERR_INVALID_PARAM;
+    }
+
+    /*
+     * Search for the address.
+     */
+    RTSpinlockAcquire(pSession->Spinlock, &SpinlockTmp);
+    for (pBundle = &pSession->Bundle; pBundle; pBundle = pBundle->pNext)
+    {
+        if (pBundle->cUsed > 0)
+        {
+            unsigned i;
+            for (i = 0; i < sizeof(pBundle->aMem) / sizeof(pBundle->aMem[0]); i++)
+            {
+                if (    pBundle->aMem[i].eType == MEMREF_TYPE_LOCKED_SUP
+                    &&  pBundle->aMem[i].MemObj != NIL_RTR0MEMOBJ
+                    &&  (   (RTHCUINTPTR)RTR0MemObjAddress(pBundle->aMem[i].MemObj) == uPtr
+                         || (   pBundle->aMem[i].MapObjR3 != NIL_RTR0MEMOBJ
+                             && RTR0MemObjAddressR3(pBundle->aMem[i].MapObjR3) == uPtr)
+                        )
+                   )
+                {
+                    unsigned iPage;
+                    cPages = RT_MIN(RTR0MemObjSize(pBundle->aMem[i].MemObj) >> PAGE_SHIFT, cPages);
+                    for (iPage = 0; iPage < cPages; iPage++)
+                    {
+                        paPages[iPage].Phys = RTR0MemObjGetPagePhysAddr(pBundle->aMem[i].MemObj, iPage);
+                        paPages[iPage].uReserved = 0;
+                    }
+                    RTSpinlockRelease(pSession->Spinlock, &SpinlockTmp);
+                    return 0;
+                }
+            }
+        }
+    }
+    RTSpinlockRelease(pSession->Spinlock, &SpinlockTmp);
+    dprintf(("Failed to find %p!!!\n", (void *)uPtr));
+    return SUPDRV_ERR_INVALID_PARAM;
+}
+
+
+/**
+ * Free memory allocated by SUPR0PageAlloc().
+ *
+ * @returns 0 on success.
+ * @returns SUPDRV_ERR_* on failure.
+ * @param   pSession        The session owning the allocation.
+ * @param   uPtr            The Ring-3 address returned by SUPR0PageAlloc().
+ */
+SUPR0DECL(int) SUPR0PageFree(PSUPDRVSESSION pSession, RTHCUINTPTR uPtr)
+{
+    dprintf(("SUPR0PageFree: pSession=%p uPtr=%p\n", pSession, (void *)uPtr));
+    return supdrvMemRelease(pSession, uPtr, MEMREF_TYPE_LOCKED_SUP);
+}
+#endif /* USE_NEW_OS_INTERFACE_FOR_MM */
+
+
-/**
- * Maps the GIP into userspace and/or get the physical address of the GIP.

trunk/src/VBox/HostDrivers/Support/SUPLib.cpp

@@ -725 +725 @@
-}
-
-
-SUPR3DECL(int) SUPPageAlloc(size_t cPages, void **ppvPages)
-{
@@ -741 +740 @@
-    *ppvPages = NULL;
-
+#ifdef RT_OS_WINDOWS
+    SUPALLOCPAGE_IN  In;
+    SUPALLOCPAGE_OUT Out;
+
+    In.u32Cookie        = g_u32Cookie;
+    In.u32SessionCookie = g_u32SessionCookie;
+    In.cPages           = cPages;
+    Out.u32Cookie       = g_u32Cookie;
+    int rc = suplibOsIOCtl(SUP_IOCTL_PAGE_ALLOC, &In, sizeof(In), &Out, sizeof(Out));
+    if (VBOX_SUCCESS(rc))
+        *ppvPages = Out.pvR3;
+
+    return rc;
+#else
-    /*
-     * Call OS specific worker.
-     */
-    return suplibOsPageAlloc(cPages, ppvPages);
+#endif
-}
-
@@ -757 +771 @@
-        return VINF_SUCCESS;
-
+#ifdef RT_OS_WINDOWS
+    SUPFREEPAGE_IN  In;
+
+    In.u32Cookie        = g_u32Cookie;
+    In.u32SessionCookie = g_u32SessionCookie;
+    In.pvR3             = pvPages;
+    return suplibOsIOCtl(SUP_IOCTL_PAGE_FREE, &In, sizeof(In), NULL, 0);
+#else
-    /*
-     * Call OS specific worker.
-     */
-    return suplibOsPageFree(pvPages, cPages);
+#endif
-}
-

trunk/src/VBox/HostDrivers/Support/win/SUPDrv-win.cpp

@@ -320 +320 @@
-    int         rc = 0;
-    dprintf2(("VBoxSupDrvDeviceControlSlow(%p,%p): ioctl=%#x pBuf=%p cbIn=%#x cbOut=%#x pSession=%p\n",
-Obj
-Buf
+Ext
+Irp->AssociatedIrp.SystemBuffer
-             pStack->Parameters.DeviceIoControl.OutputBufferLength, pSession));
-

trunk/src/VBox/Runtime/r0drv/memobj-r0drv.cpp

@@ -187 +187 @@
-                         && pMem->u.Mapping.R0Process != NIL_RTR0PROCESS)
-                    ||  (   pMem->enmType == RTR0MEMOBJTYPE_LOCK
+                         && pMem->u.Lock.R0Process != NIL_RTR0PROCESS)
+                    ||  (   pMem->enmType == RTR0MEMOBJTYPE_PHYS_NC
-                         && pMem->u.Lock.R0Process != NIL_RTR0PROCESS)
-                    ||  (   pMem->enmType == RTR0MEMOBJTYPE_RES_VIRT
@@ -467 +469 @@
-        R0Process = RTR0ProcHandleSelf();
-
-allocation
+locking
-    return rtR0MemObjNativeLockUser(pMemObj, R3PtrAligned, cbAligned, R0Process);
-}

trunk/src/VBox/VMM/MMInternal.h

@@ -648 +648 @@
-
-    /** Page pool. (HC only) */
-HCPTRTYPE(PMMPAGEPOOL)  
+R3R0PTRTYPE(PMMPAGEPOOL)
-    /** Page pool pages in low memory. (HC only) */
-HCPTRTYPE(PMMPAGEPOOL)  
+R3R0PTRTYPE(PMMPAGEPOOL)
-
-    /** Pointer to the dummy page.

trunk/src/VBox/VMM/MMPagePool.cpp

@@ -61 +61 @@
-     * Allocate the pool structures.
-     */
-pVM->mm.s.pPagePool = (PMMPAGEPOOL)MMR3HeapAllocZ(pVM, MM_TAG_MM_PAGE, sizeof(MMPAGEPOOL)
-!pVM->mm.s.pPagePool
-VERR_NO_MEMORY
+int rc = SUPPageAlloc(RT_ALIGN_32(sizeof(*pVM->mm.s.pPagePool), PAGE_SIZE), (void **)pVM->mm.s.pPagePool
+VBOX_FAILURE(rc)
+rc
-    pVM->mm.s.pPagePool->pVM = pVM;
-    STAM_REG(pVM, &pVM->mm.s.pPagePool->cPages,         STAMTYPE_U32,     "/MM/Page/Def/cPages",        STAMUNIT_PAGES, "Number of pages in the default pool.");
@@ -74 +74 @@
-    STAM_REG(pVM, &pVM->mm.s.pPagePool->cErrors,        STAMTYPE_COUNTER, "/MM/Page/Def/cErrors",       STAMUNIT_ERRORS,"Number of errors for the default pool.");
-
-pVM->mm.s.pPagePoolLow = (PMMPAGEPOOL)MMR3HeapAllocZ(pVM, MM_TAG_MM_PAGE, sizeof(MMPAGEPOOL)
-!pVM->mm.s.pPagePoolLow
-VERR_NO_MEMORY
+rc = SUPPageAlloc(RT_ALIGN_32(sizeof(*pVM->mm.s.pPagePoolLow), PAGE_SIZE), (void **)pVM->mm.s.pPagePoolLow
+VBOX_FAILURE(rc)
+rc
-    pVM->mm.s.pPagePoolLow->pVM = pVM;
-    pVM->mm.s.pPagePoolLow->fLow = true;
@@ -121 +121 @@
-        }
-
+        SUPPageFree(pVM->mm.s.pPagePool, RT_ALIGN_32(sizeof(*pVM->mm.s.pPagePool), PAGE_SIZE));
-        pVM->mm.s.pPagePool = NULL;
-    }
@@ -141 +142 @@
-        }
-
-
+
+
-    }
-}

trunk/src/VBox/VMM/VMMR0/VMMR0.cpp

@@ -509 +509 @@
-        {
-            int rc;
+            RTCCUINTREG fFlags;
-
-            STAM_COUNTER_INC(&pVM->vmm.s.StatRunGC);
+            fFlags = ASMIntDisableFlags();
-            rc = HWACCMR0Enable(pVM);
-            if (VBOX_SUCCESS(rc))
@@ -525 +527 @@
-            }
-            pVM->vmm.s.iLastGCRc = rc;
+            ASMSetFlags(fFlags);
-
-#ifdef VBOX_WITH_STATISTICS