Changeset 4755 in vbox for trunk/src/VBox

Timestamp:

Sep 13, 2007 8:05:08 AM (17 years 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.

Location:

trunk/src/VBox

Files:

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

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",
-             pDevObj, pIrp, pStack->Parameters.DeviceIoControl.IoControlCode,
-             pBuf, pStack->Parameters.DeviceIoControl.InputBufferLength,
+             pDevExt, pIrp, pStack->Parameters.DeviceIoControl.IoControlCode,
+             pIrp->AssociatedIrp.SystemBuffer, pStack->Parameters.DeviceIoControl.InputBufferLength,
              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();
 
-    /* do the allocation. */
+    /* do the locking. */
     return rtR0MemObjNativeLockUser(pMemObj, R3PtrAligned, cbAligned, R0Process);
 }

trunk/src/VBox/VMM/MMInternal.h

@@ -648 +648 @@
 
     /** Page pool. (HC only) */
-    HCPTRTYPE(PMMPAGEPOOL)      pPagePool;
+    R3R0PTRTYPE(PMMPAGEPOOL)    pPagePool;
     /** Page pool pages in low memory. (HC only) */
-    HCPTRTYPE(PMMPAGEPOOL)      pPagePoolLow;
+    R3R0PTRTYPE(PMMPAGEPOOL)    pPagePoolLow;
 
     /** 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));
-    if (!pVM->mm.s.pPagePool)
-        return VERR_NO_MEMORY;
+    int rc = SUPPageAlloc(RT_ALIGN_32(sizeof(*pVM->mm.s.pPagePool), PAGE_SIZE), (void **)pVM->mm.s.pPagePool);
+    if (VBOX_FAILURE(rc))
+        return 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));
-    if (!pVM->mm.s.pPagePoolLow)
-        return VERR_NO_MEMORY;
+    rc = SUPPageAlloc(RT_ALIGN_32(sizeof(*pVM->mm.s.pPagePoolLow), PAGE_SIZE), (void **)pVM->mm.s.pPagePoolLow);
+    if (VBOX_FAILURE(rc))
+        return 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 @@
         }
 
-        pVM->mm.s.pPagePool = NULL;
+        SUPPageFree(pVM->mm.s.pPagePoolLow, RT_ALIGN_32(sizeof(*pVM->mm.s.pPagePoolLow), PAGE_SIZE));
+        pVM->mm.s.pPagePoolLow = NULL;
     }
 }

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