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

Timestamp:

Jun 28, 2023 10:31:50 AM (19 months ago)

Author:

vboxsync

Message:

Runtime/r3/memsafer-r3.cpp: Replace occurences of PAGE_SIZE/PAGE_OFFSET_MASK with RTSystemGetPageSize()/RTSystemGetPageOffsetMask() in code which is used by the linux.arm64 guest additions / validationkit, bugref:10476

File:

• trunk/src/VBox/Runtime/r3/memsafer-r3.cpp (modified) (10 diffs)

trunk/src/VBox/Runtime/r3/memsafer-r3.cpp

@@ -52 +52 @@
 #include <iprt/param.h>
 #include <iprt/string.h>
+#include <iprt/system.h>
 #ifdef IN_SUP_R3
 # include <VBox/sup.h>
@@ -270 +271 @@
 static void rtMemSaferInitializePages(PRTMEMSAFERNODE pThis, void *pvPages)
 {
-    RTRandBytes(pvPages, PAGE_SIZE + pThis->offUser);
-
-    uint8_t *pbUser = (uint8_t *)pvPages + PAGE_SIZE + pThis->offUser;
+    uint32_t const cbPage = RTSystemGetPageSize();
+    RTRandBytes(pvPages, cbPage + pThis->offUser);
+
+    uint8_t *pbUser = (uint8_t *)pvPages + cbPage + pThis->offUser;
     pThis->Core.Key = pbUser;
     RT_BZERO(pbUser, pThis->cbUser); /* paranoia */
 
-    RTRandBytes(pbUser + pThis->cbUser, (size_t)pThis->cPages * PAGE_SIZE - PAGE_SIZE - pThis->offUser - pThis->cbUser);
+    RTRandBytes(pbUser + pThis->cbUser, (size_t)pThis->cPages * cbPage - cbPage - pThis->offUser - pThis->cbUser);
 }
 
@@ -312 +314 @@
          * SUPR3PageProtect isn't supported on all hosts, we ignore that.
          */
-        rc = SUPR3PageProtect(pvPages, NIL_RTR0PTR, 0, PAGE_SIZE, RTMEM_PROT_NONE);
+        uint32_t const cbPage = RTSystemGetPageSize();
+        rc = SUPR3PageProtect(pvPages, NIL_RTR0PTR, 0, cbPage, RTMEM_PROT_NONE);
         if (RT_SUCCESS(rc))
         {
-            rc = SUPR3PageProtect(pvPages, NIL_RTR0PTR, (pThis->cPages - 1) * PAGE_SIZE, PAGE_SIZE, RTMEM_PROT_NONE);
+            rc = SUPR3PageProtect(pvPages, NIL_RTR0PTR, (pThis->cPages - 1) * cbPage, cbPage, RTMEM_PROT_NONE);
             if (RT_SUCCESS(rc))
                 return VINF_SUCCESS;
-            SUPR3PageProtect(pvPages, NIL_RTR0PTR, 0, PAGE_SIZE, RTMEM_PROT_READ | RTMEM_PROT_WRITE);
+            SUPR3PageProtect(pvPages, NIL_RTR0PTR, 0, cbPage, RTMEM_PROT_READ | RTMEM_PROT_WRITE);
         }
         else if (rc == VERR_NOT_SUPPORTED)
@@ -348 +351 @@
      * Try allocate the memory.
      */
+    uint32_t const cbPage = RTSystemGetPageSize();
     int rc = VINF_SUCCESS;
-    void *pvPages = RTMemPageAllocEx((size_t)pThis->cPages * PAGE_SIZE,
+    void *pvPages = RTMemPageAllocEx((size_t)pThis->cPages * cbPage,
                                      RTMEMPAGEALLOC_F_ADVISE_LOCKED | RTMEMPAGEALLOC_F_ADVISE_NO_DUMP | RTMEMPAGEALLOC_F_ZERO);
     if (pvPages)
@@ -358 +362 @@
          * Configure the guard pages.
          */
-        rc = RTMemProtect(pvPages, PAGE_SIZE, RTMEM_PROT_NONE);
+        rc = RTMemProtect(pvPages, cbPage, RTMEM_PROT_NONE);
         if (RT_SUCCESS(rc))
         {
-            rc = RTMemProtect((uint8_t *)pvPages + (size_t)(pThis->cPages - 1U) * PAGE_SIZE, PAGE_SIZE, RTMEM_PROT_NONE);
+            rc = RTMemProtect((uint8_t *)pvPages + (size_t)(pThis->cPages - 1U) * cbPage, cbPage, RTMEM_PROT_NONE);
             if (RT_SUCCESS(rc))
                 return VINF_SUCCESS;
-            rc = RTMemProtect(pvPages, PAGE_SIZE, RTMEM_PROT_READ | RTMEM_PROT_WRITE);
+            rc = RTMemProtect(pvPages, cbPage, RTMEM_PROT_READ | RTMEM_PROT_WRITE);
         }
 
         /* failed. */
-        RTMemPageFree(pvPages, (size_t)pThis->cPages * PAGE_SIZE);
+        RTMemPageFree(pvPages, (size_t)pThis->cPages * cbPage);
     }
     else
@@ -387 +391 @@
     *ppvNew = NULL;
     AssertReturn(cb, VERR_INVALID_PARAMETER);
-    AssertReturn(cb <= 32U*_1M - PAGE_SIZE * 3U, VERR_ALLOCATION_TOO_BIG); /* Max 32 MB minus padding and guard pages. */
+    uint32_t const cbPage = RTSystemGetPageSize();
+    AssertReturn(cb <= 32U*_1M - cbPage * 3U, VERR_ALLOCATION_TOO_BIG); /* Max 32 MB minus padding and guard pages. */
     AssertReturn(!(fFlags & ~RTMEMSAFER_F_VALID_MASK), VERR_INVALID_FLAGS);
 
@@ -406 +411 @@
              */
             pThis->cbUser  = cb;
-            pThis->offUser = (RTRandU32Ex(0, 128) * RTMEMSAFER_ALIGN) & PAGE_OFFSET_MASK;
+            pThis->offUser = (RTRandU32Ex(0, 128) * RTMEMSAFER_ALIGN) & RTSystemGetPageOffsetMask();
 
             size_t cbNeeded = pThis->offUser + pThis->cbUser;
-            cbNeeded = RT_ALIGN_Z(cbNeeded, PAGE_SIZE);
-
-            pThis->cPages = (uint32_t)(cbNeeded / PAGE_SIZE) + 2; /* +2 for guard pages */
+            cbNeeded = RT_ALIGN_Z(cbNeeded, cbPage);
+
+            pThis->cPages = (uint32_t)(cbNeeded / cbPage) + 2; /* +2 for guard pages */
 
             /*
@@ -465 +470 @@
          * Free the pages.
          */
-        uint8_t *pbPages = (uint8_t *)pv - pThis->offUser - PAGE_SIZE;
-        size_t   cbPages = (size_t)pThis->cPages * PAGE_SIZE;
+        uint32_t const cbPage = RTSystemGetPageSize();
+        uint8_t *pbPages = (uint8_t *)pv - pThis->offUser - cbPage;
+        size_t   cbPages = (size_t)pThis->cPages * cbPage;
         switch (pThis->enmAllocator)
         {
 #ifdef IN_SUP_R3
             case RTMEMSAFERALLOCATOR_SUPR3:
-                SUPR3PageProtect(pbPages, NIL_RTR0PTR, 0, PAGE_SIZE, RTMEM_PROT_READ | RTMEM_PROT_WRITE);
-                SUPR3PageProtect(pbPages, NIL_RTR0PTR, (uint32_t)(cbPages - PAGE_SIZE), PAGE_SIZE, RTMEM_PROT_READ | RTMEM_PROT_WRITE);
+                SUPR3PageProtect(pbPages, NIL_RTR0PTR, 0, cbPage, RTMEM_PROT_READ | RTMEM_PROT_WRITE);
+                SUPR3PageProtect(pbPages, NIL_RTR0PTR, (uint32_t)(cbPages - cbPage), cbPage, RTMEM_PROT_READ | RTMEM_PROT_WRITE);
                 SUPR3PageFreeEx(pbPages, pThis->cPages);
                 break;
 #endif
             case RTMEMSAFERALLOCATOR_RTMEMPAGE:
-                RTMemProtect(pbPages, PAGE_SIZE, RTMEM_PROT_READ | RTMEM_PROT_WRITE);
-                RTMemProtect(pbPages + cbPages - PAGE_SIZE, PAGE_SIZE, RTMEM_PROT_READ | RTMEM_PROT_WRITE);
+                RTMemProtect(pbPages, cbPage, RTMEM_PROT_READ | RTMEM_PROT_WRITE);
+                RTMemProtect(pbPages + cbPages - cbPage, cbPage, RTMEM_PROT_READ | RTMEM_PROT_WRITE);
                 RTMemPageFree(pbPages, cbPages);
                 break;
@@ -552 +558 @@
                  * Is the enough room for us to grow?
                  */
-                size_t cbMax = (size_t)(pThis->cPages - 2) * PAGE_SIZE;
+                size_t cbMax = (size_t)(pThis->cPages - 2) * RTSystemGetPageSize();
                 if (cbNew <= cbMax)
                 {
@@ -595 +601 @@
                         rtMemSaferNodeInsert(pThis);
                     }
-                    Assert(((uintptr_t)*ppvNew & PAGE_OFFSET_MASK) == pThis->offUser);
+                    Assert(((uintptr_t)*ppvNew & RTSystemGetPageOffsetMask()) == pThis->offUser);
                     pThis->cbUser = cbNew;
                     rc = VINF_SUCCESS;