Changeset 108724 in vbox for trunk/src

Timestamp:

Mar 24, 2025 6:53:21 PM (3 weeks ago)

Author:

vboxsync

svn:sync-xref-src-repo-rev:

168147

Message:

HostDrivers/Support: Make SUPR3 work on hosts where the page size is not known during compile time, bugref:10391

Location:

trunk/src/VBox/HostDrivers/Support

Files:

• Makefile.kmk (modified) (1 diff)
• SUPLib.cpp (modified) (15 diffs)
• SUPLibInternal.h (modified) (2 diffs)
• SUPLibLdr.cpp (modified) (8 diffs)
• linux/SUPLib-linux.cpp (modified) (7 diffs)

trunk/src/VBox/HostDrivers/Support/Makefile.kmk

@@ -49 +49 @@
 # Targets
 #
-if "$(KBUILD_TARGET).$(KBUILD_TARGET_ARCH)" != "linux.arm64" || defined(VBOX_WITH_STATIC_ARM64_PAGE_SHIFT) # @todo Required by LoadGenerator in the validationkit but uses PAGE_SIZE++
- LIBRARIES += SUPR3 SUPR3Static
-endif
+LIBRARIES += SUPR3 SUPR3Static
 if   defined(VBOX_WITH_HARDENING) \
   && !defined(VBOX_ONLY_VALIDATIONKIT)

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

@@ -75 +75 @@
 #include <iprt/path.h>
 #include <iprt/string.h>
+#include <iprt/system.h>
 #include <iprt/env.h>
 #include <iprt/rand.h>
@@ -551 +552 @@
 
         /* fake the GIP. */
-        g_pSUPGlobalInfoPage = (PSUPGLOBALINFOPAGE)RTMemPageAllocZ(PAGE_SIZE);
+        g_pSUPGlobalInfoPage = (PSUPGLOBALINFOPAGE)RTMemPageAllocZ(SUP_PAGE_SIZE);
         if (g_pSUPGlobalInfoPage)
         {
             g_pSUPGlobalInfoPageR0 = g_pSUPGlobalInfoPage;
-            g_HCPhysSUPGlobalInfoPage = NIL_RTHCPHYS & ~(RTHCPHYS)PAGE_OFFSET_MASK;
+            g_HCPhysSUPGlobalInfoPage = NIL_RTHCPHYS & ~(RTHCPHYS)SUP_PAGE_OFFSET_MASK;
             /* the page is supposed to be invalid, so don't set the magic. */
             return VINF_SUCCESS;
@@ -1002 +1003 @@
 SUPR3DECL(int) supR3PageLock(void *pvStart, size_t cPages, PSUPPAGE paPages)
 {
+    uint32_t  const cbPage = SUP_PAGE_SIZE;
+
     /*
      * Validate.
      */
     AssertPtr(pvStart);
-    AssertMsg(RT_ALIGN_P(pvStart, PAGE_SIZE) == pvStart, ("pvStart (%p) must be page aligned\n", pvStart));
+    AssertMsg(RT_ALIGN_P(pvStart, cbPage) == pvStart, ("pvStart (%p) must be page aligned\n", pvStart));
     AssertPtr(paPages);
 
@@ -1012 +1015 @@
     if (RT_UNLIKELY(g_uSupFakeMode))
     {
-        RTHCPHYS    Phys = (uintptr_t)pvStart + PAGE_SIZE * 1024;
+        RTHCPHYS    Phys = (uintptr_t)pvStart + cbPage * 1024;
         size_t      iPage = cPages;
         while (iPage-- > 0)
-            paPages[iPage].Phys = Phys + (iPage << PAGE_SHIFT);
+            paPages[iPage].Phys = Phys + (iPage << SUP_PAGE_SHIFT);
         return VINF_SUCCESS;
     }
@@ -1068 +1071 @@
      */
     AssertPtr(pvStart);
-    AssertMsg(RT_ALIGN_P(pvStart, PAGE_SIZE) == pvStart, ("pvStart (%p) must be page aligned\n", pvStart));
+    AssertMsg(RT_ALIGN_P(pvStart, SUP_PAGE_SIZE) == pvStart, ("pvStart (%p) must be page aligned\n", pvStart));
 
     /* fake */
@@ -1117 +1120 @@
 
 
+#ifdef VBOX_WITH_R0_MODULES
 /**
  * Fallback for SUPR3PageAllocEx on systems where RTR0MemObjPhysAllocNC isn't
@@ -1135 +1139 @@
     return rc;
 }
+#endif /* VBOX_WITH_R0_MODULES */
 
 
@@ -1148 +1153 @@
         *pR0Ptr = NIL_RTR0PTR;
     AssertPtrNullReturn(paPages, VERR_INVALID_POINTER);
-    AssertMsgReturn(cPages > 0 && cPages <= VBOX_MAX_ALLOC_PAGE_COUNT, ("cPages=%zu\n", cPages), VERR_PAGE_COUNT_OUT_OF_RANGE);
+    AssertMsgReturn(cPages > 0 && cPages <= VBOX_MAX_ALLOC_SIZE / SUP_PAGE_SIZE, ("cPages=%zu\n", cPages), VERR_PAGE_COUNT_OUT_OF_RANGE);
     AssertReturn(!fFlags, VERR_INVALID_FLAGS);
 
@@ -1157 +1162 @@
     {
         int rc = SUPR3PageAlloc(cPages, 0 /*fFlags*/, ppvPages);
-        Assert(RT_FAILURE(rc) || ASMMemIsZero(*ppvPages, cPages << PAGE_SHIFT));
+        Assert(RT_FAILURE(rc) || ASMMemIsZero(*ppvPages, cPages << SUP_PAGE_SHIFT));
         if (pR0Ptr)
             *pR0Ptr = NIL_RTR0PTR;
@@ -1176 +1181 @@
         return VERR_WRONG_ORDER;
 
+#ifdef VBOX_WITH_R0_MODULES
     /*
      * Use fallback for non-R0 mapping?
@@ -1240 +1246 @@
         rc = VERR_NO_TMP_MEMORY;
     return rc;
-
-}
-
-
+#else
+    AssertFailedReturn(VERR_NOT_SUPPORTED);
+#endif /* VBOX_WITH_R0_MODULES */
+}
+
+
+#ifdef VBOX_WITH_R0_MODULES
 SUPR3DECL(int) SUPR3PageMapKernel(void *pvR3, uint32_t off, uint32_t cb, uint32_t fFlags, PRTR0PTR pR0Ptr)
 {
@@ -1282 +1291 @@
     return rc;
 }
+#endif
 
 
@@ -1290 +1300 @@
      */
     AssertPtrReturn(pvR3, VERR_INVALID_POINTER);
-    Assert(!(off & PAGE_OFFSET_MASK));
-    Assert(!(cb & PAGE_OFFSET_MASK) && cb);
+    Assert(!(off & SUP_PAGE_OFFSET_MASK));
+    Assert(!(cb & SUP_PAGE_OFFSET_MASK) && cb);
     AssertReturn(!(fProt & ~(RTMEM_PROT_NONE | RTMEM_PROT_READ | RTMEM_PROT_WRITE | RTMEM_PROT_EXEC)), VERR_INVALID_PARAMETER);
 
@@ -1476 +1486 @@
     if (RT_UNLIKELY(g_uSupFakeMode))
     {
-        *ppvPages = RTMemPageAllocZ((size_t)cPages * PAGE_SIZE);
+        *ppvPages = RTMemPageAllocZ((size_t)cPages * SUP_PAGE_SIZE);
         if (!*ppvPages)
             return VERR_NO_LOW_MEMORY;
 
         /* fake physical addresses. */
-        RTHCPHYS    Phys = (uintptr_t)*ppvPages + PAGE_SIZE * 1024;
+        RTHCPHYS    Phys = (uintptr_t)*ppvPages + SUP_PAGE_SIZE * 1024;
         size_t      iPage = cPages;
         while (iPage-- > 0)
-            paPages[iPage].Phys = Phys + (iPage << PAGE_SHIFT);
+            paPages[iPage].Phys = Phys + (iPage << SUP_PAGE_SHIFT);
         return VINF_SUCCESS;
     }
@@ -1544 +1554 @@
     if (RT_UNLIKELY(g_uSupFakeMode))
     {
-        RTMemPageFree(pv, cPages * PAGE_SIZE);
+        RTMemPageFree(pv, cPages * SUP_PAGE_SIZE);
         return VINF_SUCCESS;
     }

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

@@ -44 +44 @@
 #include <VBox/types.h>
 #include <iprt/stdarg.h>
+#if defined(RT_OS_LINUX) && defined(RT_ARCH_ARM64)
+# include <iprt/system.h>
+#endif
 
 
@@ -83 +86 @@
 # undef  SUP_HARDENED_SUID
 #endif
+
+/** @def SUP_PAGE_SIZE
+ * Page size of the host, can evaluate to a function call on certain hosts where
+ * the page size is not known during compile time.
+ */
+#if defined(RT_OS_LINUX) && defined(RT_ARCH_ARM64)
+# define SUP_PAGE_SIZE RTSystemGetPageSize()
+#else
+# define SUP_PAGE_SIZE HOST_PAGE_SIZE
+#endif
+
+/** @def SUP_PAGE_SHIFT
+ * Page shift of the host, can evaluate to a function call on certain hosts where
+ * the page size is not known during compile time.
+ */
+#if defined(RT_OS_LINUX) && defined(RT_ARCH_ARM64)
+# define SUP_PAGE_SHIFT RTSystemGetPageShift()
+#else
+# define SUP_PAGE_SHIFT HOST_PAGE_SHIFT
+#endif
+
+/** @def SUP_PAGE_OFFSET_MASK
+ * Page shift of the host, can evaluate to a function call on certain hosts where
+ * the page size is not known during compile time.
+ */
+#if defined(RT_OS_LINUX) && defined(RT_ARCH_ARM64)
+# define SUP_PAGE_OFFSET_MASK RTSystemGetPageOffsetMask()
+#else
+# define SUP_PAGE_OFFSET_MASK HOST_PAGE_OFFSET_MASK
+#endif
+
 
 #ifdef IN_SUP_HARDENED_R3

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

@@ -413 +413 @@
      * a little more complicated...
      */
+    uint32_t  const cbPage      = SUP_PAGE_SIZE;
+    uint32_t  const cPageShift  = SUP_PAGE_SHIFT;
+    uintptr_t const offPageMask = SUP_PAGE_OFFSET_MASK;
     if (pArgs->uStartRva < pArgs->uEndRva)
     {
-        if (((pArgs->uEndRva - 1) >> PAGE_SHIFT) != (uRvaSeg >> PAGE_SHIFT))
+        if (((pArgs->uEndRva - 1) >> cPageShift) != (uRvaSeg >> cPageShift))
         {
             /* No common page, so make the new segment start on a page boundrary. */
-            cbMapped += uRvaSeg & PAGE_OFFSET_MASK;
-            uRvaSeg &= ~(uint32_t)PAGE_OFFSET_MASK;
+            cbMapped += uRvaSeg & offPageMask;
+            uRvaSeg &= ~(uint32_t)offPageMask;
             Assert(pArgs->uEndRva <= uRvaSeg);
             Log2(("supLoadModuleCompileSegmentsCB: -> new, no common\n"));
@@ -427 +430 @@
             /* The current segment includes the memory protections of the
                previous, so include the common page in it: */
-            uint32_t const cbCommon = PAGE_SIZE - (uRvaSeg & PAGE_OFFSET_MASK);
+            uint32_t const cbCommon = cbPage - (uRvaSeg & offPageMask);
             if (cbCommon >= cbMapped)
             {
@@ -444 +447 @@
             /* The new segment includes the memory protections of the
                previous, so include the common page in it: */
-            cbMapped += uRvaSeg & PAGE_OFFSET_MASK;
-            uRvaSeg &= ~(uint32_t)PAGE_OFFSET_MASK;
+            cbMapped += uRvaSeg & offPageMask;
+            uRvaSeg &= ~(uint32_t)offPageMask;
             if (uRvaSeg == pArgs->uStartRva)
             {
@@ -453 +456 @@
                 return VINF_SUCCESS; /* Current segment was smaller than a page. */
             }
-            Log2(("supLoadModuleCompileSegmentsCB: -> new, %#x common into new\n", (uint32_t)(pSeg->RVA & PAGE_OFFSET_MASK)));
+            Log2(("supLoadModuleCompileSegmentsCB: -> new, %#x common into new\n", (uint32_t)(pSeg->RVA & offPageMask)));
         }
         else
@@ -459 +462 @@
             /* Create a new segment for the common page with the combined protection. */
             Log2(("supLoadModuleCompileSegmentsCB: -> it's complicated...\n"));
-            pArgs->uEndRva &= ~(uint32_t)PAGE_OFFSET_MASK;
+            pArgs->uEndRva &= ~(uint32_t)offPageMask;
             if (pArgs->uEndRva > pArgs->uStartRva)
             {
@@ -477 +480 @@
             pArgs->fProt |= fProt;
 
-            uint32_t const cbCommon = PAGE_SIZE - (uRvaSeg & PAGE_OFFSET_MASK);
+            uint32_t const cbCommon = cbPage - (uRvaSeg & offPageMask);
             if (cbCommon >= cbMapped)
             {
@@ -485 +488 @@
             cbMapped -= cbCommon;
             uRvaSeg  += cbCommon;
-            Assert(uRvaSeg - pArgs->uStartRva == PAGE_SIZE);
+            Assert(uRvaSeg - pArgs->uStartRva == cbPage);
         }
 
@@ -507 +510 @@
 
     /* Start the new segment. */
-    Assert(!(uRvaSeg & PAGE_OFFSET_MASK));
+    Assert(!(uRvaSeg & offPageMask));
     pArgs->fProt     = fProt;
     pArgs->uStartRva = uRvaSeg;

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

@@ -64 +64 @@
 #include <VBox/types.h>
 #include <iprt/string.h>
-#include <iprt/system.h>
 #include <VBox/err.h>
 #include <VBox/param.h>
@@ -100 +99 @@
      * Check if madvise works.
      */
-    void *pv = mmap(NULL, PAGE_SIZE, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+    uint32_t const cbPage = SUP_PAGE_SIZE;
+    void *pv = mmap(NULL, cbPage, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
     if (pv == MAP_FAILED)
         return VERR_NO_MEMORY;
-    pThis->fSysMadviseWorks = (0 == madvise(pv, PAGE_SIZE, MADV_DONTFORK));
-    munmap(pv, PAGE_SIZE);
+    pThis->fSysMadviseWorks = (0 == madvise(pv, cbPage, MADV_DONTFORK));
+    munmap(pv, cbPage);
 
     /*
@@ -256 +256 @@
 #endif
 
-    size_t cbMmap = cPages << PAGE_SHIFT;
+    uint32_t const cbPage = SUP_PAGE_SIZE;
+    uint32_t const cPageShift = SUP_PAGE_SHIFT;
+
+    size_t cbMmap = cPages << cPageShift;
     if (   !pThis->fSysMadviseWorks
         && (fFlags & (SUP_PAGE_ALLOC_F_FOR_LOCKING | SUP_PAGE_ALLOC_F_LARGE_PAGES)) == SUP_PAGE_ALLOC_F_FOR_LOCKING)
-        cbMmap += PAGE_SIZE * 2;
+        cbMmap += cbPage * 2;
 
     uint8_t *pbPages = (uint8_t *)mmap(NULL, cbMmap, PROT_READ | PROT_WRITE, fMmap, -1, 0);
@@ -268 +271 @@
         fMmap &= ~MAP_HUGETLB;
         if (!pThis->fSysMadviseWorks && (fFlags & SUP_PAGE_ALLOC_F_FOR_LOCKING))
-            cbMmap = (cPages + 2) << PAGE_SHIFT;
+            cbMmap = (cPages + 2) << cPageShift;
         pbPages = (uint8_t *)mmap(NULL, cbMmap, PROT_READ | PROT_WRITE, fMmap, -1, 0);
     }
@@ -313 +316 @@
              * area struct of the very same size as the mmap area.
              */
-            mprotect(pbPages,                      PAGE_SIZE, PROT_NONE);
-            mprotect(pbPages + cbMmap - PAGE_SIZE, PAGE_SIZE, PROT_NONE);
-            pbPages += PAGE_SHIFT;
+            mprotect(pbPages,                   cbPage, PROT_NONE);
+            mprotect(pbPages + cbMmap - cbPage, cbPage, PROT_NONE);
+            pbPages += cPageShift;
         }
 
@@ -322 +325 @@
          * so I qualified it with SUP_PAGE_ALLOC_F_FOR_LOCKING (unused) for now... */
         if (fFlags & SUP_PAGE_ALLOC_F_FOR_LOCKING)
-            memset(pbPages, 0, cPages << PAGE_SHIFT);
+            memset(pbPages, 0, cPages << cPageShift);
 
         *ppvPages = pbPages;
@@ -334 +337 @@
 {
     NOREF(pThis);
-    munmap(pvPages, cPages << PAGE_SHIFT);
+    munmap(pvPages, cPages << SUP_PAGE_SHIFT);
     return VINF_SUCCESS;
 }