Changeset 82868 in vbox for trunk/src/VBox/Runtime/r0drv/darwin/memobj-r0drv-darwin.cpp

Timestamp:

Jan 27, 2020 10:25:43 AM (5 years ago)

Author:

vboxsync

Message:

IPRT/memobj-r0drv-darwin.cpp: Added support for alignments other than PAGE_SIZE in rtR0MemObjNativeAllocPhys. This allows for large page allocations. bugref:5324

File:

• trunk/src/VBox/Runtime/r0drv/darwin/memobj-r0drv-darwin.cpp (modified) (12 diffs)

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

@@ -144 +144 @@
         case RTR0MEMOBJTYPE_PHYS:
         case RTR0MEMOBJTYPE_PHYS_NC:
-            return NULL; /* pretend these have no mapping atm. */
+            if (pMem->pv)
+                return kernel_map;
+            return NULL;
 
         case RTR0MEMOBJTYPE_LOCK:
@@ -454 +456 @@
  *                          UINT64_MAX if it doesn't matter.
  * @param   enmType         The object type.
+ * @param   uAlignment      The allocation alignment (in bytes).
  */
 static int rtR0MemObjNativeAllocWorker(PPRTR0MEMOBJINTERNAL ppMem, size_t cb,
                                        bool fExecutable, bool fContiguous,
                                        mach_vm_address_t PhysMask, uint64_t MaxPhysAddr,
-                                       RTR0MEMOBJTYPE enmType)
-{
+                                       RTR0MEMOBJTYPE enmType, size_t uAlignment)
+{
+    RT_NOREF_PV(uAlignment);
+    int rc;
+
     /*
      * Try inTaskWithPhysicalMask first, but since we don't quite trust that it
@@ -469 +475 @@
      * The kIOMemoryMapperNone flag is required since 10.8.2 (IOMMU changes?).
      */
-    int rc;
     size_t cbFudged = cb;
     if (1) /** @todo Figure out why this is broken. Is it only on snow leopard? Seen allocating memory for the VM structure, last page corrupted or inaccessible. */
          cbFudged += PAGE_SIZE;
-#if 1
+
+    uint64_t uAlignmentActual = uAlignment;
+
     IOOptionBits fOptions = kIOMemoryKernelUserShared | kIODirectionInOut;
     if (fContiguous)
@@ -479 +486 @@
     if (version_major >= 12 /* 12 = 10.8.x = Mountain Kitten */)
         fOptions |= kIOMemoryMapperNone;
-    IOBufferMemoryDescriptor *pMemDesc = IOBufferMemoryDescriptor::inTaskWithPhysicalMask(kernel_task, fOptions,
-                                                                                          cbFudged, PhysMask);
-#else /* Requires 10.7 SDK, but allows alignment to be specified: */
-    uint64_t     uAlignment = PAGE_SIZE;
-    IOOptionBits fOptions   = kIODirectionInOut | kIOMemoryMapperNone;
-    if (fContiguous || MaxPhysAddr < UINT64_MAX)
-    {
-        fOptions  |= kIOMemoryPhysicallyContiguous;
-        uAlignment = 1;                 /* PhysMask isn't respected if higher. */
-    }
-
-    IOBufferMemoryDescriptor *pMemDesc = new IOBufferMemoryDescriptor;
-    if (pMemDesc && !pMemDesc->initWithPhysicalMask(kernel_task, fOptions, cbFudged, uAlignment, PhysMask))
-    {
-        pMemDesc->release();
-        pMemDesc = NULL;
-    }
+
+    /* The public initWithPhysicalMask virtual method appeared in 10.7.0, in
+       versions 10.5.0 up to 10.7.0 it was private, and 10.4.8-10.5.0 it was
+       x86 only and didn't have the alignment parameter (slot was different too). */
+    IOBufferMemoryDescriptor *pMemDesc;
+#if __MAC_OS_X_VERSION_MAX_ALLOWED >= 1070
+    if (version_major >= 11 /* 11 = 10.7.x = Lion, could probably allow 10.5.0+ here if we really wanted to. */)
+    {
+        if (fContiguous || MaxPhysAddr < UINT64_MAX)
+        {
+            fOptions |= kIOMemoryPhysicallyContiguous;
+            // cannot find any evidence of this: uAlignmentActual = 1; /* PhysMask isn't respected if higher. */
+        }
+
+        pMemDesc = new IOBufferMemoryDescriptor;
+        if (pMemDesc)
+        {
+            if (pMemDesc->initWithPhysicalMask(kernel_task, fOptions, cbFudged, uAlignmentActual, PhysMask))
+            { /* likely */ }
+            else
+            {
+                pMemDesc->release();
+                pMemDesc = NULL;
+            }
+        }
+    }
+    else
 #endif
+        pMemDesc = IOBufferMemoryDescriptor::inTaskWithPhysicalMask(kernel_task, fOptions, cbFudged, PhysMask);
     if (pMemDesc)
     {
@@ -528 +546 @@
                         pMemDesc->release();
                         if (PhysMask)
-                            LogRel(("rtR0MemObjNativeAllocWorker: off=%x Addr=%llx AddrPrev=%llx MaxPhysAddr=%llx PhysMas=%llx fContiguous=%RTbool fOptions=%#x - buggy API!\n",
-                                    off, Addr, AddrPrev, MaxPhysAddr, PhysMask, fContiguous, fOptions));
+                        {
+                            kprintf("rtR0MemObjNativeAllocWorker: off=%zx Addr=%llx AddrPrev=%llx MaxPhysAddr=%llx PhysMas=%llx fContiguous=%d fOptions=%#x - buggy API!\n",
+                                    (size_t)off, Addr, AddrPrev, MaxPhysAddr, PhysMask, fContiguous, fOptions);
+                            LogRel(("rtR0MemObjNativeAllocWorker: off=%zx Addr=%llx AddrPrev=%llx MaxPhysAddr=%llx PhysMas=%llx fContiguous=%RTbool fOptions=%#x - buggy API!\n",
+                                    (size_t)off, Addr, AddrPrev, MaxPhysAddr, PhysMask, fContiguous, fOptions));
+                        }
                         return VERR_ADDRESS_TOO_BIG;
                     }
                     AddrPrev = Addr;
+                }
+
+                /*
+                 * Check that it's aligned correctly.
+                 */
+                if ((uintptr_t)pv & (uAlignment - 1))
+                {
+                    pMemDesc->complete();
+                    pMemDesc->release();
+                    if (PhysMask)
+                    {
+                        kprintf("rtR0MemObjNativeAllocWorker: pv=%p uAlignment=%#zx (MaxPhysAddr=%llx PhysMas=%llx fContiguous=%d fOptions=%#x) - buggy API!!\n",
+                                pv, uAlignment, MaxPhysAddr, PhysMask, fContiguous, fOptions);
+                        LogRel(("rtR0MemObjNativeAllocWorker: pv=%p uAlignment=%#zx (MaxPhysAddr=%llx PhysMas=%llx fContiguous=%RTbool fOptions=%#x) - buggy API!\n",
+                                pv, uAlignment, MaxPhysAddr, PhysMask, fContiguous, fOptions));
+                    }
+                    return VERR_NOT_SUPPORTED;
                 }
 
@@ -627 +666 @@
 
     int rc = rtR0MemObjNativeAllocWorker(ppMem, cb, fExecutable, false /* fContiguous */,
-                                         0 /* PhysMask */, UINT64_MAX, RTR0MEMOBJTYPE_PAGE);
+                                         0 /* PhysMask */, UINT64_MAX, RTR0MEMOBJTYPE_PAGE, PAGE_SIZE);
 
     IPRT_DARWIN_RESTORE_EFL_AC();
@@ -646 +685 @@
      */
     int rc = rtR0MemObjNativeAllocWorker(ppMem, cb, fExecutable, false /* fContiguous */,
-                                         ~(uint32_t)PAGE_OFFSET_MASK, _4G - PAGE_SIZE, RTR0MEMOBJTYPE_LOW);
+                                         ~(uint32_t)PAGE_OFFSET_MASK, _4G - PAGE_SIZE, RTR0MEMOBJTYPE_LOW, PAGE_SIZE);
     if (rc == VERR_ADDRESS_TOO_BIG)
         rc = rtR0MemObjNativeAllocWorker(ppMem, cb, fExecutable, false /* fContiguous */,
-                                         0 /* PhysMask */, _4G - PAGE_SIZE, RTR0MEMOBJTYPE_LOW);
+                                         0 /* PhysMask */, _4G - PAGE_SIZE, RTR0MEMOBJTYPE_LOW, PAGE_SIZE);
 
     IPRT_DARWIN_RESTORE_EFL_AC();
@@ -662 +701 @@
     int rc = rtR0MemObjNativeAllocWorker(ppMem, cb, fExecutable, true /* fContiguous */,
                                          ~(uint32_t)PAGE_OFFSET_MASK, _4G - PAGE_SIZE,
-                                         RTR0MEMOBJTYPE_CONT);
+                                         RTR0MEMOBJTYPE_CONT, PAGE_SIZE);
 
     /*
@@ -671 +710 @@
         rc = rtR0MemObjNativeAllocWorker(ppMem, cb + PAGE_SIZE, fExecutable, true /* fContiguous */,
                                          ~(uint32_t)PAGE_OFFSET_MASK, _4G - PAGE_SIZE,
-                                         RTR0MEMOBJTYPE_CONT);
+                                         RTR0MEMOBJTYPE_CONT, PAGE_SIZE);
     IPRT_DARWIN_RESTORE_EFL_AC();
     return rc;
@@ -679 +718 @@
 DECLHIDDEN(int) rtR0MemObjNativeAllocPhys(PPRTR0MEMOBJINTERNAL ppMem, size_t cb, RTHCPHYS PhysHighest, size_t uAlignment)
 {
-    /** @todo alignment */
     if (uAlignment != PAGE_SIZE)
-        return VERR_NOT_SUPPORTED;
+    {
+        /* See rtR0MemObjNativeAllocWorker: */
+        if (version_major < 9 /* 9 = 10.5.x = Snow Leopard */)
+            return VERR_NOT_SUPPORTED;
+    }
 
     IPRT_DARWIN_SAVE_EFL_AC();
@@ -690 +732 @@
     int rc;
     if (PhysHighest == NIL_RTHCPHYS)
-        rc = rtR0MemObjNativeAllocWorker(ppMem, cb, true /* fExecutable */, true /* fContiguous */,
-                                         0 /* PhysMask*/, UINT64_MAX, RTR0MEMOBJTYPE_PHYS);
+        rc = rtR0MemObjNativeAllocWorker(ppMem, cb, false /* fExecutable */, true /* fContiguous */,
+                                         uAlignment <= PAGE_SIZE ? 0 : ~(mach_vm_address_t)(uAlignment - 1) /* PhysMask*/,
+                                         UINT64_MAX, RTR0MEMOBJTYPE_PHYS, uAlignment);
     else
     {
@@ -699 +742 @@
             PhysMask >>= 1;
         AssertReturn(PhysMask + 1 <= cb, VERR_INVALID_PARAMETER);
-        PhysMask &= ~(mach_vm_address_t)PAGE_OFFSET_MASK;
-
-        rc = rtR0MemObjNativeAllocWorker(ppMem, cb, true /* fExecutable */, true /* fContiguous */,
-                                         PhysMask, PhysHighest, RTR0MEMOBJTYPE_PHYS);
+        PhysMask &= ~(mach_vm_address_t)(uAlignment - 1);
+
+        rc = rtR0MemObjNativeAllocWorker(ppMem, cb, false /* fExecutable */, true /* fContiguous */,
+                                         PhysMask, PhysHighest, RTR0MEMOBJTYPE_PHYS, uAlignment);
     }