Changeset 100360 in vbox for trunk/src

Timestamp:

Jul 4, 2023 7:09:24 AM (18 months ago)

Author:

vboxsync

Message:

Additions/VBoxGuest/VBoxGuestR0LibPhysHeap: Make use of the RTR0MemObjContAlloc() API and support allocating memory above 4GiB, bugref:10457

Location:

trunk/src/VBox/Additions/common/VBoxGuest/lib

Files:

• VBoxGuestR0LibInit.cpp (modified) (2 diffs)
• VBoxGuestR0LibInternal.h (modified) (1 diff)
• VBoxGuestR0LibPhysHeap.cpp (modified) (6 diffs)
• testcase/tstVbglR0PhysHeap-1.cpp (modified) (6 diffs)

trunk/src/VBox/Additions/common/VBoxGuest/lib/VBoxGuestR0LibInit.cpp

@@ -117 +117 @@
                     g_vbgldata.pMmioReq      = PortInfo.u.Out.pMmioReq;
 
-                    rc = VbglR0PhysHeapInit(g_vbgldata.pMmioReq == NULL /*fAlloc32BitAddr*/);
+                    /*
+                     * Initialize the physical heap, only allocate memory below 4GiB if the new
+                     * MMIO interface isn't available and we are using a 32-bit OUT instruction to pass a block
+                     * physical address to the host.
+                     */
+                    rc = VbglR0PhysHeapInit(g_vbgldata.pMmioReq == NULL ? _4G - 1 : NIL_RTHCPHYS /*HCPhysMax*/);
                     if (RT_SUCCESS(rc))
                     {
@@ -208 +213 @@
         g_vbgldata.pMmioReq      = pMmioReq;
 
-        rc = VbglR0PhysHeapInit(pMmioReq == NULL /*fAlloc32BitAddr*/);
+        /*
+         * Initialize the physical heap, only allocate memory below 4GiB if the new
+         * MMIO interface isn't available and we are using a 32-bit OUT instruction to pass a block
+         * physical address to the host.
+         */
+        rc = VbglR0PhysHeapInit(g_vbgldata.pMmioReq == NULL ? _4G - 1 : NIL_RTHCPHYS /*HCPhysMax*/);
         if (RT_SUCCESS(rc))
         {

trunk/src/VBox/Additions/common/VBoxGuest/lib/VBoxGuestR0LibInternal.h

@@ -152 +152 @@
     /** Head of the chunk list. */
     VBGLPHYSHEAPCHUNK      *pChunkHead;
-    /** Flag whether all allocations should be below 4GiB to fit into
-     * a 32-bit address. */
-    bool                   fAlloc32BitAddr;
+    /** Maximum physical address allowed for allocations, inclusive. */
+    RTHCPHYS                HCPhysMax;
     /** @} */
 

trunk/src/VBox/Additions/common/VBoxGuest/lib/VBoxGuestR0LibPhysHeap.cpp

@@ -157 +157 @@
  * linker cannot eliminiate functions within objects.  Only drawback is that
  * RTR0MemObjAllocCont requires another heap allocation for the handle.
- */
-#if defined(DOXYGEN_RUNNING) || (!defined(IN_TESTCASE) && 0)
-# define VBGL_PH_USE_MEMOBJ
-#endif
+ *
+ * Update: Just enable it everywhere so we can more easily use memory above 4G.
+ */
+#define VBGL_PH_USE_MEMOBJ
 
 
@@ -233 +233 @@
     /** The allocation handle. */
     RTR0MEMOBJ          hMemObj;
-#elif ARCH_BITS == 64
+#endif
+#if ARCH_BITS == 64
     /** Pad the size up to 64 bytes. */
 # ifdef VBGL_PH_USE_MEMOBJ
@@ -532 +533 @@
     cbChunk = RT_ALIGN_32(cbChunk, VBGL_PH_CHUNKSIZE);
 
-    if (g_vbgldata.fAlloc32BitAddr)
-    {
-        /*
-         * This function allocates physical contiguous memory below 4 GB.  This 4GB
-         * limitation stems from using a 32-bit OUT instruction to pass a block
-         * physical address to the host.
-         */
 #ifdef VBGL_PH_USE_MEMOBJ
-        rc = RTR0MemObjAllocCont(&hMemObj, cbChunk, false /*fExecutable*/);
-        pChunk = (VBGLPHYSHEAPCHUNK *)(RT_SUCCESS(rc) ? RTR0MemObjAddress(hMemObj) : NULL);
+    rc = RTR0MemObjAllocCont(&hMemObj, cbChunk, g_vbgldata.HCPhysMax, false /*fExecutable*/);
+    pChunk = (VBGLPHYSHEAPCHUNK *)(RT_SUCCESS(rc) ? RTR0MemObjAddress(hMemObj) : NULL);
+    PhysAddr = RT_SUCCESS(rc) ? (RTCCPHYS)RTR0MemObjGetPagePhysAddr(hMemObj, 0 /*iPage*/) : NIL_RTCCPHYS;
 #else
-        pChunk = (VBGLPHYSHEAPCHUNK *)RTMemContAlloc(&PhysAddr, cbChunk);
-#endif
-    }
-    else
-    {
-        /** @todo Provide appropriate memory API. */
-#ifdef VBGL_PH_USE_MEMOBJ
-        rc = RTR0MemObjAllocCont(&hMemObj, cbChunk, false /*fExecutable*/);
-        pChunk = (VBGLPHYSHEAPCHUNK *)(RT_SUCCESS(rc) ? RTR0MemObjAddress(hMemObj) : NULL);
-#else
-        pChunk = (VBGLPHYSHEAPCHUNK *)RTMemContAlloc(&PhysAddr, cbChunk);
-#endif
-    }
+    pChunk = (VBGLPHYSHEAPCHUNK *)RTMemContAlloc(&PhysAddr, cbChunk);
+#endif
     if (!pChunk)
     {
@@ -567 +551 @@
                 cbChunk = RT_ALIGN_32(cbChunk, PAGE_SIZE);
 #ifdef VBGL_PH_USE_MEMOBJ
-                rc = RTR0MemObjAllocCont(&hMemObj, cbChunk, false /*fExecutable*/);
+                rc = RTR0MemObjAllocCont(&hMemObj, cbChunk, g_vbgldata.HCPhysMax, false /*fExecutable*/);
                 pChunk = (VBGLPHYSHEAPCHUNK *)(RT_SUCCESS(rc) ? RTR0MemObjAddress(hMemObj) : NULL);
+                PhysAddr = RT_SUCCESS(rc) ? (RTCCPHYS)RTR0MemObjGetPagePhysAddr(hMemObj, 0 /*iPage*/) : NIL_RTCCPHYS;
 #else
                 pChunk = (VBGLPHYSHEAPCHUNK *)RTMemContAlloc(&PhysAddr, cbChunk);
@@ -578 +563 @@
         VBGLPHYSHEAPCHUNK     *pOldHeadChunk;
         VBGLPHYSHEAPFREEBLOCK *pBlock;
-        AssertRelease(   !g_vbgldata.fAlloc32BitAddr
+        AssertRelease(   g_vbgldata.HCPhysMax == NIL_RTHCPHYS
                       || (PhysAddr < _4G && PhysAddr + cbChunk <= _4G));
 
@@ -1183 +1168 @@
 #endif /* IN_TESTCASE */
 
-DECLR0VBGL(int) VbglR0PhysHeapInit(bool fAlloc32BitAddr)
-{
-    g_vbgldata.fAlloc32BitAddr = fAlloc32BitAddr;
-    g_vbgldata.hMtxHeap        = NIL_RTSEMFASTMUTEX;
+DECLR0VBGL(int) VbglR0PhysHeapInit(RTHCPHYS HCPhysMax)
+{
+    g_vbgldata.HCPhysMax = HCPhysMax;
+    g_vbgldata.hMtxHeap  = NIL_RTSEMFASTMUTEX;
 
     /* Allocate the first chunk of the heap. */

trunk/src/VBox/Additions/common/VBoxGuest/lib/testcase/tstVbglR0PhysHeap-1.cpp

@@ -53 +53 @@
 #define IN_TESTCASE
 #define IN_RING0 /* pretend we're in ring-0 so we get access to the functions */
+#include <iprt/memobj.h>
 #include "../VBoxGuestR0LibInternal.h"
 
@@ -66 +67 @@
 
 
+typedef struct TSTMEMOBJ
+{
+    size_t cb;
+} TSTMEMOBJ;
+typedef TSTMEMOBJ *PTSTMEMOBJ;
+
+
 /*********************************************************************************************************************************
 *   Global Variables                                                                                                             *
@@ -75 +83 @@
 
 /** Drop-in replacement for RTMemContAlloc   */
-static void *tstMemContAlloc(PRTCCPHYS pPhys, size_t cb)
-{
+static int tstMemObjContAllocTag(PRTR0MEMOBJ pMemObj, size_t cb, RTHCPHYS PhysHighest, bool fExecutable, const char *pszTag)
+{
+    RT_NOREF(pszTag, PhysHighest, fExecutable);
+
     RTTESTI_CHECK(cb > 0);
 
@@ -82 +92 @@
     if (g_cChunks < TST_MAX_CHUNKS)
     {
-        void *pvRet = RTMemAlloc(cb);
-        if (pvRet)
-        {
+        PTSTMEMOBJ pMem = (PTSTMEMOBJ)RTMemAlloc(sizeof(TSTMEMOBJ) + cb);
+        if (pMem)
+        {
+            pMem->cb = cb;
+
             g_cChunks++;
             g_cbChunks += cb;
-            *pPhys = (uint32_t)(uintptr_t)pvRet ^ (UINT32_C(0xf0f0f0f0) & ~(uint32_t)PAGE_OFFSET_MASK);
-
-            /* Avoid problematic values that won't happen in real life:  */
-            if (!*pPhys)
-                *pPhys = 4U << PAGE_SHIFT;
-            if (UINT32_MAX - *pPhys < cb)
-                *pPhys -= RT_ALIGN_32(cb, PAGE_SIZE);
-
-            return pvRet;
-        }
-    }
-
-    *pPhys = NIL_RTCCPHYS;
-    return NULL;
-}
-
-
-/** Drop-in replacement for RTMemContFree   */
-static void tstMemContFree(void *pv, size_t cb)
-{
-    RTTESTI_CHECK(RT_VALID_PTR(pv));
-    RTTESTI_CHECK(cb > 0);
+            *pMemObj = (RTR0MEMOBJ)pMem;
+            return VINF_SUCCESS;
+        }
+    }
+
+    return VERR_NO_MEMORY;
+}
+
+
+/** Drop-in replacement for RTR0MemObjAddress   */
+static void *tstMemObjAddress(RTR0MEMOBJ hMemObj)
+{
+    return (void *)((PTSTMEMOBJ)hMemObj + 1);
+}
+
+
+/** Drop-in replacement for RTR0MemObjGetPagePhysAddr   */
+static RTHCPHYS tstMemObjGetPagePhysAddr(RTR0MEMOBJ hMemObj, uint32_t iPage)
+{
+    RTTESTI_CHECK(iPage == 0);
+
+    PTSTMEMOBJ pMemObj = (PTSTMEMOBJ)hMemObj;
+    uintptr_t PtrMem = (uintptr_t)(pMemObj + 1);
+    RTHCPHYS Phys = (uint32_t)(uintptr_t)PtrMem ^ (UINT32_C(0xf0f0f0f0) & ~(uint32_t)PAGE_OFFSET_MASK);
+
+    /* Avoid problematic values that won't happen in real life:  */
+    if (!Phys)
+        Phys = 4U << PAGE_SHIFT;
+    if (UINT32_MAX - Phys < pMemObj->cb)
+        Phys -= RT_ALIGN_32(pMemObj->cb, PAGE_SIZE);
+
+    return Phys;
+}
+
+
+/** Drop-in replacement for RTR0MemObjFree   */
+static void tstMemObjFree(RTR0MEMOBJ hMemObj, bool fFreeMappings)
+{
+    RT_NOREF(fFreeMappings);
+
+    PTSTMEMOBJ pMemObj = (PTSTMEMOBJ)hMemObj;
+    RTTESTI_CHECK(RT_VALID_PTR(pMemObj));
+    RTTESTI_CHECK(pMemObj->cb > 0);
     RTTESTI_CHECK(g_cChunks > 0);
-    RTMemFree(pv);
     g_cChunks--;
-    g_cbChunks -= cb;
-}
-
-
-#define RTMemContAlloc  tstMemContAlloc
-#define RTMemContFree   tstMemContFree
+    g_cbChunks -= pMemObj->cb;
+    RTMemFree(pMemObj);
+}
+
+
+#define RTR0MemObjAllocContTag      tstMemObjContAllocTag
+#define RTR0MemObjAddress           tstMemObjAddress
+#define RTR0MemObjGetPagePhysAddr   tstMemObjGetPagePhysAddr
+#define RTR0MemObjFree              tstMemObjFree
 #include "../VBoxGuestR0LibPhysHeap.cpp"
 
@@ -178 +213 @@
      */
     RTTestSub(hTest, "Basics");
-    RTTESTI_CHECK_RC(rc = VbglR0PhysHeapInit(true /*fAlloc32BitAddr*/), VINF_SUCCESS);
+    RTTESTI_CHECK_RC(rc = VbglR0PhysHeapInit(NIL_RTHCPHYS), VINF_SUCCESS);
     if (RT_FAILURE(rc))
         return RTTestSummaryAndDestroy(hTest);
@@ -288 +323 @@
      */
     RTTestSub(hTest, "Random Test");
-    RTTESTI_CHECK_RC(rc = VbglR0PhysHeapInit(true /*fAlloc32BitAddr*/), VINF_SUCCESS);
+    RTTESTI_CHECK_RC(rc = VbglR0PhysHeapInit(NIL_RTHCPHYS), VINF_SUCCESS);
     if (RT_FAILURE(rc))
         return RTTestSummaryAndDestroy(hTest);