Changeset 100356 in vbox for trunk/src/VBox/Runtime

Timestamp:

Jul 4, 2023 6:41:38 AM (17 months ago)

Author:

vboxsync

Message:

Runtime/RTR0MemObj*: Add PhysHighest parameter to RTR0MemObjAllocCont to indicate the maximum allowed physical address for an allocation, bugref:10457 [revert due to build failures]

Location:

trunk/src/VBox/Runtime

Files:

• include/internal/memobj.h (modified) (1 diff)
• r0drv/darwin/memobj-r0drv-darwin.cpp (modified) (4 diffs)
• r0drv/freebsd/memobj-r0drv-freebsd.c (modified) (2 diffs)
• r0drv/haiku/memobj-r0drv-haiku.c (modified) (1 diff)
• r0drv/linux/memobj-r0drv-linux.c (modified) (3 diffs)
• r0drv/memobj-r0drv.cpp (modified) (2 diffs)
• r0drv/netbsd/memobj-r0drv-netbsd.c (modified) (1 diff)
• r0drv/nt/memobj-r0drv-nt.cpp (modified) (2 diffs)
• r0drv/os2/memobj-r0drv-os2.cpp (modified) (4 diffs)
• r0drv/solaris/memobj-r0drv-solaris.c (modified) (1 diff)

trunk/src/VBox/Runtime/include/internal/memobj.h

@@ -361 +361 @@
  * @param   ppMem           Where to store the ring-0 memory object handle.
  * @param   cb              Number of bytes to allocate, page aligned.
- * @param   PhysHighest     The highest permitable address (inclusive).
- *                          Pass NIL_RTHCPHYS if any address is acceptable.
  * @param   fExecutable     Flag indicating whether it should be permitted to executed code in the memory object.
  * @param   pszTag          Allocation tag used for statistics and such.
  */
-DECLHIDDEN(int) rtR0MemObjNativeAllocCont(PPRTR0MEMOBJINTERNAL ppMem, size_t cb, RTHCPHYS PhysHighest,
-                                          bool fExecutable, const char *pszTag);
+DECLHIDDEN(int) rtR0MemObjNativeAllocCont(PPRTR0MEMOBJINTERNAL ppMem, size_t cb, bool fExecutable, const char *pszTag);
 
 /**

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

@@ -885 +885 @@
 
 
-/**
- * Translates the PhysHighest address into a mask.
- */
-static mach_vm_address_t rtR0MemObjDarwinCalcPhysMask(RTHCPHYS PhysHighest, size_t uAlignment)
-{
-    if (PhysHighest == NIL_RTHCPHYS)
-        return uAlignment <= PAGE_SIZE ? 0 : ~(mach_vm_address_t)(uAlignment - 1);
-
-    mach_vm_address_t PhysMask = ~(mach_vm_address_t)0;
-    while (PhysMask > (PhysHighest | PAGE_OFFSET_MASK))
-        PhysMask >>= 1;
-    PhysMask &= ~(mach_vm_address_t)(uAlignment - 1);
-
-    return PhysMask;
-}
-
-
-DECLHIDDEN(int) rtR0MemObjNativeAllocCont(PPRTR0MEMOBJINTERNAL ppMem, size_t cb, RTHCPHYS PhysHighest,
-                                          bool fExecutable, const char *pszTag)
-{
-    mach_vm_address_t const PhysMask = rtR0MemObjDarwinCalcPhysMask(PhysHighest, PAGE_SIZE);
+DECLHIDDEN(int) rtR0MemObjNativeAllocCont(PPRTR0MEMOBJINTERNAL ppMem, size_t cb, bool fExecutable, const char *pszTag)
+{
     IPRT_DARWIN_SAVE_EFL_AC();
 
-    int rc = rtR0MemObjNativeAllocWorker(ppMem, cb, fExecutable, true /* fContiguous */, PhysMask, PhysHighest,
+    int rc = rtR0MemObjNativeAllocWorker(ppMem, cb, fExecutable, true /* fContiguous */,
+                                         ~(uint32_t)PAGE_OFFSET_MASK, _4G - PAGE_SIZE,
                                          RTR0MEMOBJTYPE_CONT, PAGE_SIZE, pszTag, false /*fOnKernelThread*/);
 
@@ -916 +898 @@
      */
     if (RT_FAILURE(rc) && cb <= PAGE_SIZE)
-        rc = rtR0MemObjNativeAllocWorker(ppMem, cb + PAGE_SIZE, fExecutable, true /* fContiguous */, PhysMask, PhysHighest,
+        rc = rtR0MemObjNativeAllocWorker(ppMem, cb + PAGE_SIZE, fExecutable, true /* fContiguous */,
+                                         ~(uint32_t)PAGE_OFFSET_MASK, _4G - PAGE_SIZE,
                                          RTR0MEMOBJTYPE_CONT, PAGE_SIZE, pszTag, false /*fOnKernelThread*/);
     IPRT_DARWIN_RESTORE_EFL_AC();
@@ -932 +915 @@
             return VERR_NOT_SUPPORTED;
     }
-    mach_vm_address_t const PhysMask = rtR0MemObjDarwinCalcPhysMask(PhysHighest, uAlignment);
 
     IPRT_DARWIN_SAVE_EFL_AC();
@@ -941 +923 @@
     int rc;
     if (PhysHighest == NIL_RTHCPHYS)
-        rc = rtR0MemObjNativeAllocWorker(ppMem, cb, false /* fExecutable */, true /* fContiguous */, PhysMask, UINT64_MAX,
-                                         RTR0MEMOBJTYPE_PHYS, uAlignment, pszTag, false /*fOnKernelThread*/);
+        rc = rtR0MemObjNativeAllocWorker(ppMem, cb, false /* fExecutable */, true /* fContiguous */,
+                                         uAlignment <= PAGE_SIZE ? 0 : ~(mach_vm_address_t)(uAlignment - 1) /* PhysMask*/,
+                                         UINT64_MAX, RTR0MEMOBJTYPE_PHYS, uAlignment, pszTag, false /*fOnKernelThread*/);
     else
     {
+        mach_vm_address_t PhysMask = 0;
+        PhysMask = ~(mach_vm_address_t)0;
+        while (PhysMask > (PhysHighest | PAGE_OFFSET_MASK))
+            PhysMask >>= 1;
         AssertReturn(PhysMask + 1 <= cb, VERR_INVALID_PARAMETER);
-        rc = rtR0MemObjNativeAllocWorker(ppMem, cb, false /* fExecutable */, true /* fContiguous */, PhysMask, PhysHighest,
+        PhysMask &= ~(mach_vm_address_t)(uAlignment - 1);
+
+        rc = rtR0MemObjNativeAllocWorker(ppMem, cb, false /* fExecutable */, true /* fContiguous */,
+                                         PhysMask, PhysHighest,
                                          RTR0MEMOBJTYPE_PHYS, uAlignment, pszTag, false /*fOnKernelThread*/);
     }

trunk/src/VBox/Runtime/r0drv/freebsd/memobj-r0drv-freebsd.c

@@ -410 +410 @@
 
 
-DECLHIDDEN(int) rtR0MemObjNativeAllocCont(PPRTR0MEMOBJINTERNAL ppMem, size_t cb, RTHCPHYS PhysHigest,
-                                          bool fExecutable, const char *pszTag)
+DECLHIDDEN(int) rtR0MemObjNativeAllocCont(PPRTR0MEMOBJINTERNAL ppMem, size_t cb, bool fExecutable, const char *pszTag)
 {
     PRTR0MEMOBJFREEBSD pMemFreeBSD = (PRTR0MEMOBJFREEBSD)rtR0MemObjNew(sizeof(*pMemFreeBSD), RTR0MEMOBJTYPE_CONT,
@@ -417 +416 @@
     if (pMemFreeBSD)
     {
-        int rc = rtR0MemObjFreeBSDAllocHelper(pMemFreeBSD, fExecutable, PhysHigest, true /*fContiguous*/, VERR_NO_CONT_MEMORY);
+        int rc = rtR0MemObjFreeBSDAllocHelper(pMemFreeBSD, fExecutable, _4G - 1, true /*fContiguous*/, VERR_NO_CONT_MEMORY);
         if (RT_SUCCESS(rc))
         {

trunk/src/VBox/Runtime/r0drv/haiku/memobj-r0drv-haiku.c

@@ -277 +277 @@
 
 
-int rtR0MemObjNativeAllocCont(PPRTR0MEMOBJINTERNAL ppMem, size_t cb, RTHCPHYS PhysHighest, bool fExecutable, const char *pszTag)
-{
-    return rtR0MemObjNativeAllocArea(ppMem, cb, fExecutable, RTR0MEMOBJTYPE_CONT, PhysHighest, 0 /* uAlignment */, pszTag);
+int rtR0MemObjNativeAllocCont(PPRTR0MEMOBJINTERNAL ppMem, size_t cb, bool fExecutable, const char *pszTag)
+{
+    return rtR0MemObjNativeAllocArea(ppMem, cb, fExecutable, RTR0MEMOBJTYPE_CONT, 0 /* PhysHighest */, 0 /* uAlignment */, pszTag);
 }
 

trunk/src/VBox/Runtime/r0drv/linux/memobj-r0drv-linux.c

@@ -149 +149 @@
 /** Pointer to the linux memory object. */
 typedef RTR0MEMOBJLNX *PRTR0MEMOBJLNX;
-
-
-/*********************************************************************************************************************************
-*   Global Variables                                                                                                             *
-*********************************************************************************************************************************/
-/*
- * Linux allows only a coarse selection of zones for
- * allocations matching a particular maximum physical address.
- *
- * Sorted from high to low physical address!
- */
-static const struct
-{
-    RTHCPHYS    PhysHighest;
-    gfp_t       fGfp;
-} g_aZones[] =
-{
-    { NIL_RTHCPHYS,      GFP_KERNEL },
-#if (defined(RT_ARCH_AMD64) || defined(CONFIG_X86_PAE)) && defined(GFP_DMA32)
-    { _4G - 1,           GFP_DMA32  }, /* ZONE_DMA32: 0-4GB */
-#elif defined(RT_ARCH_ARM32) || defined(RT_ARCH_ARM64)
-    { _4G - 1,           GFP_DMA    }, /* ZONE_DMA: 0-4GB */
-#endif
-#if defined(RT_ARCH_AMD64)
-    { _16M - 1,          GFP_DMA    }, /* ZONE_DMA: 0-16MB */
-#elif defined(RT_ARCH_X86)
-    { 896 * _1M - 1,     GFP_USER   }, /* ZONE_NORMAL (32-bit hosts): 0-896MB */
-#endif
-};
 
 
@@ -1001 +972 @@
 
 
-DECLHIDDEN(int) rtR0MemObjNativeAllocCont(PPRTR0MEMOBJINTERNAL ppMem, size_t cb, RTHCPHYS PhysHighest,
-                                          bool fExecutable, const char *pszTag)
+DECLHIDDEN(int) rtR0MemObjNativeAllocCont(PPRTR0MEMOBJINTERNAL ppMem, size_t cb, bool fExecutable, const char *pszTag)
 {
     IPRT_LINUX_SAVE_EFL_AC();
     PRTR0MEMOBJLNX pMemLnx;
     int rc;
-    uint32_t idxZone;
-
-    /*
-     * The last zone must be able to satisfy the PhysHighest requirement or there
-     * will be no zone at all.
-     */
-    if (g_aZones[RT_ELEMENTS(g_aZones) - 1].PhysHighest > PhysHighest)
-    {
-        IPRT_LINUX_RESTORE_EFL_AC();
-        AssertMsgFailedReturn(("No zone can satisfy PhysHighest=%RHp!\n", PhysHighest),
-                              VERR_NO_CONT_MEMORY);
-    }
-
-    /* Find the first zone matching our PhysHighest requirement. */
-    idxZone = 0;
-    for (;;)
-    {
-        if (g_aZones[idxZone].PhysHighest <= PhysHighest)
-            break; /* We found a zone satisfying the requirement. */
-        idxZone++;
-    }
-
-    /* Now try to allocate pages from all the left zones until one succeeds. */
-    for (;;)
-    {
-        rc = rtR0MemObjLinuxAllocPages(&pMemLnx, RTR0MEMOBJTYPE_CONT, cb, PAGE_SIZE, g_aZones[idxZone].fGfp,
+
+#if (defined(RT_ARCH_AMD64) || defined(RT_ARCH_ARM64) || defined(CONFIG_X86_PAE)) && defined(GFP_DMA32)
+    /* ZONE_DMA32: 0-4GB */
+    rc = rtR0MemObjLinuxAllocPages(&pMemLnx, RTR0MEMOBJTYPE_CONT, cb, PAGE_SIZE, GFP_DMA32,
+                                   true /* contiguous */, fExecutable, VERR_NO_CONT_MEMORY, pszTag);
+    if (RT_FAILURE(rc))
+#endif
+#if defined(RT_ARCH_AMD64) || defined(RT_ARCH_ARM64)
+        /* ZONE_DMA: 0-16MB */
+        rc = rtR0MemObjLinuxAllocPages(&pMemLnx, RTR0MEMOBJTYPE_CONT, cb, PAGE_SIZE, GFP_DMA,
                                        true /* contiguous */, fExecutable, VERR_NO_CONT_MEMORY, pszTag);
-        idxZone++;
-        if (RT_SUCCESS(rc) || idxZone == RT_ELEMENTS(g_aZones))
-            break;
-    }
+#else
+        /* ZONE_NORMAL (32-bit hosts): 0-896MB */
+        rc = rtR0MemObjLinuxAllocPages(&pMemLnx, RTR0MEMOBJTYPE_CONT, cb, PAGE_SIZE, GFP_USER,
+                                       true /* contiguous */, fExecutable, VERR_NO_CONT_MEMORY, pszTag);
+#endif
     if (RT_SUCCESS(rc))
     {
@@ -1043 +998 @@
         if (RT_SUCCESS(rc))
         {
-#if defined(RT_STRICT)
+#if defined(RT_STRICT) && (defined(RT_ARCH_AMD64) || defined(CONFIG_HIGHMEM64G))
             size_t iPage = pMemLnx->cPages;
             while (iPage-- > 0)
-                Assert(page_to_phys(pMemLnx->apPages[iPage]) < PhysHighest);
+                Assert(page_to_phys(pMemLnx->apPages[iPage]) < _4G);
 #endif
             pMemLnx->Core.u.Cont.Phys = page_to_phys(pMemLnx->apPages[0]);

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

@@ -474 +474 @@
 
 
-RTR0DECL(int) RTR0MemObjAllocContTag(PRTR0MEMOBJ pMemObj, size_t cb, RTHCPHYS PhysHighest, bool fExecutable, const char *pszTag)
+RTR0DECL(int) RTR0MemObjAllocContTag(PRTR0MEMOBJ pMemObj, size_t cb, bool fExecutable, const char *pszTag)
 {
     /* sanity checks. */
@@ -482 +482 @@
     AssertReturn(cb > 0, VERR_INVALID_PARAMETER);
     AssertReturn(cb <= cbAligned, VERR_INVALID_PARAMETER);
-    AssertReturn(PhysHighest >= cb, VERR_INVALID_PARAMETER);
     RT_ASSERT_PREEMPTIBLE();
 
     /* do the allocation. */
-    return rtR0MemObjNativeAllocCont(pMemObj, cbAligned, PhysHighest, fExecutable, pszTag);
+    return rtR0MemObjNativeAllocCont(pMemObj, cbAligned, fExecutable, pszTag);
 }
 RT_EXPORT_SYMBOL(RTR0MemObjAllocContTag);

trunk/src/VBox/Runtime/r0drv/netbsd/memobj-r0drv-netbsd.c

@@ -288 +288 @@
 
 
-DECLHIDDEN(int) rtR0MemObjNativeAllocCont(PPRTR0MEMOBJINTERNAL ppMem, size_t cb, RTHCPHYS PhysHighest,
-                                          bool fExecutable, const char *pszTag)
+DECLHIDDEN(int) rtR0MemObjNativeAllocCont(PPRTR0MEMOBJINTERNAL ppMem, size_t cb, bool fExecutable, const char *pszTag)
 {
     PRTR0MEMOBJNETBSD pMemNetBSD = (PRTR0MEMOBJNETBSD)rtR0MemObjNew(sizeof(*pMemNetBSD), RTR0MEMOBJTYPE_CONT, NULL, cb, pszTag);
     if (pMemNetBSD)
     {
-        int rc = rtR0MemObjNetBSDAllocHelper(pMemNetBSD, cb, fExecutable, PhysHighest, true /*fContiguous*/);
+        int rc = rtR0MemObjNetBSDAllocHelper(pMemNetBSD, cb, fExecutable, _4G - 1, true /*fContiguous*/);
         if (RT_SUCCESS(rc))
         {

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

@@ -565 +565 @@
      * Fall back on contiguous memory...
      */
-    return rtR0MemObjNativeAllocCont(ppMem, cb, _4G - 1, fExecutable, pszTag);
+    return rtR0MemObjNativeAllocCont(ppMem, cb, fExecutable, pszTag);
 }
 
@@ -636 +636 @@
 
 
-DECLHIDDEN(int) rtR0MemObjNativeAllocCont(PPRTR0MEMOBJINTERNAL ppMem, size_t cb, RTHCPHYS PhysHighest,
-                                          bool fExecutable, const char *pszTag)
-{
-    return rtR0MemObjNativeAllocContEx(ppMem, cb, fExecutable, PhysHighest, PAGE_SIZE /* alignment */, pszTag);
+DECLHIDDEN(int) rtR0MemObjNativeAllocCont(PPRTR0MEMOBJINTERNAL ppMem, size_t cb, bool fExecutable, const char *pszTag)
+{
+    return rtR0MemObjNativeAllocContEx(ppMem, cb, fExecutable, _4G-1, PAGE_SIZE /* alignment */, pszTag);
 }
 

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

@@ -218 +218 @@
 
 
-DECLHIDDEN(int) rtR0MemObjNativeAllocCont(PPRTR0MEMOBJINTERNAL ppMem, size_t cb, RTHCPHYS PhysHighest,
-                                          bool fExecutable, const char *pszTag)
+DECLHIDDEN(int) rtR0MemObjNativeAllocCont(PPRTR0MEMOBJINTERNAL ppMem, size_t cb, bool fExecutable, const char *pszTag)
 {
     NOREF(fExecutable);
-    AssertMsgReturn(PhysHighest >= _16M - 1, ("PhysHigest=%RHp\n", PhysHighest), VERR_NOT_SUPPORTED);
 
     /* create the object. */
@@ -231 +229 @@
         /* do the allocation. */
         ULONG ulPhys = ~0UL;
-        int rc = KernVMAlloc(cb, VMDHA_FIXED | VMDHA_CONTIG | (PhysHighest < _4G - 1 ? VMDHA_16M : 0),
-                             &pMemOs2->Core.pv, (PPVOID)&ulPhys, NULL);
+        int rc = KernVMAlloc(cb, VMDHA_FIXED | VMDHA_CONTIG, &pMemOs2->Core.pv, (PPVOID)&ulPhys, NULL);
         if (!rc)
         {
@@ -251 +248 @@
                                           const char *pszTag)
 {
-    AssertMsgReturn(PhysHighest >= _16M - 1, ("PhysHigest=%RHp\n", PhysHighest), VERR_NOT_SUPPORTED);
+    AssertMsgReturn(PhysHighest >= 16 *_1M, ("PhysHigest=%RHp\n", PhysHighest), VERR_NOT_SUPPORTED);
 
     /** @todo alignment  */
@@ -264 +261 @@
         /* do the allocation. */
         ULONG ulPhys = ~0UL;
-        int rc = KernVMAlloc(cb, VMDHA_FIXED | VMDHA_CONTIG | (PhysHighest < _4G - 1 ? VMDHA_16M : 0),
+        int rc = KernVMAlloc(cb, VMDHA_FIXED | VMDHA_CONTIG | (PhysHighest < _4G ? VMDHA_16M : 0),
                              &pMemOs2->Core.pv, (PPVOID)&ulPhys, NULL);
         if (!rc)

trunk/src/VBox/Runtime/r0drv/solaris/memobj-r0drv-solaris.c

@@ -727 +727 @@
 
 
-DECLHIDDEN(int) rtR0MemObjNativeAllocCont(PPRTR0MEMOBJINTERNAL ppMem, size_t cb, RTHCPHYS PhysHighest,
-                                          bool fExecutable, const char *pszTag)
+DECLHIDDEN(int) rtR0MemObjNativeAllocCont(PPRTR0MEMOBJINTERNAL ppMem, size_t cb, bool fExecutable, const char *pszTag)
 {
     AssertReturn(!fExecutable, VERR_NOT_SUPPORTED);
-    return rtR0MemObjNativeAllocPhys(ppMem, cb, PhysHigest, PAGE_SIZE /* alignment */, pszTag);
+    return rtR0MemObjNativeAllocPhys(ppMem, cb, _4G - 1, PAGE_SIZE /* alignment */, pszTag);
 }