Changeset 217

Timestamp:

01/21/07 22:41:29 (2 years ago)

Author:

vboxsync

Message:

hacking darwin memory objects.

Files:

• trunk/include/iprt/err.h (modified) (1 diff)
• trunk/src/VBox/Runtime/include/internal/memobj.h (modified) (1 diff)
• trunk/src/VBox/Runtime/r0drv/alloc-r0drv.cpp (modified) (1 diff)
• trunk/src/VBox/Runtime/r0drv/darwin/memobj-r0drv-darwin.cpp (modified) (5 diffs)
• trunk/src/VBox/Runtime/r0drv/darwin/the-darwin-kernel.h (modified) (1 diff)
• trunk/src/VBox/Runtime/r0drv/memobj-r0drv.cpp (modified) (5 diffs)

trunk/include/iprt/err.h

@@ -188 +188 @@
-/** The operation was cancelled by the user. */
-#define VERR_CANCELLED                      (-70)
-
+
+
+
+
+
+
+
+
+
+
+
-/** @} */
-

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

@@ -186 +186 @@
-    } u;
-
-
-} RTR0MEMOBJINTERNAL;
-

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

@@ -157 +157 @@
-RTDECL(void) RTMemFree(void *pv)
-{
-
+
+
+
+
-    if (pHdr->u32Magic == RTMEMHDR_MAGIC)
-    {

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

@@ -35 +35 @@
-
-
+/*******************************************************************************
+*   Structures and Typedefs                                                    *
+*******************************************************************************/
+/**
+ * The Darwin version of the memory object structure.
+ */
+typedef struct RTR0MEMOBJDARWIN
+{
+    /** The core structure. */
+    RTR0MEMOBJINTERNAL  Core;
+    /** Pointer to the memory descriptor created for allocated and locked memory. */
+    IOMemoryDescriptor *pMemDesc;
+    /** Pointer to the memory mapping object for mapped memory. */
+    IOMemoryMap        *pMemMap;
+} RTR0MEMOBJDARWIN, *PRTR0MEMOBJDARWIN;
+
-
-int rtR0MemObjNativeFree(RTR0MEMOBJ pMem)
-{
+    PRTR0MEMOBJDARWIN pMemDarwin = (PRTR0MEMOBJDARWIN)pMem;
+
+    /*
+     * Release the IOMemoryDescriptor/IOMemoryMap associated with the object.
+     */
+    if (pMemDarwin->pMemDesc)
+    {
+        pMemDarwin->pMemDesc->release();
+        pMemDarwin->pMemDesc = NULL;
+        Assert(!pMemDarwin->pMemMap);
+    }
+    else if (pMemDarwin->pMemMap)
+    {
+        pMemDarwin->pMemMap->release();
+        pMemDarwin->pMemMap = NULL;
+    }
+
+    /*
+     * Release any memory that we've allocated or locked.
+     */
+    switch (pMemDarwin->Core.enmType)
+    {
+        case RTR0MEMOBJTYPE_PAGE:
+            IOFreeAligned(pMemDarwin->Core.pv, pMemDarwin->Core.cb);
+            break;
+
+        /*case RTR0MEMOBJTYPE_LOW: => RTR0MEMOBJTYPE_CONT
+            break;*/
+
+        case RTR0MEMOBJTYPE_CONT:
+            IOFreeContiguous(pMemDarwin->Core.pv, pMemDarwin->Core.cb);
+            break;
+
+        case RTR0MEMOBJTYPE_LOCK:
+            AssertMsgFailed(("RTR0MEMOBJTYPE_LOCK\n"));
+            return VERR_INTERNAL_ERROR;
+            break;
+
+        case RTR0MEMOBJTYPE_PHYS:
+            /*if (pMemDarwin->Core.u.Phys.fAllocated)
+                IOFreePhysical(pMemDarwin->Core.u.Phys.PhysBase, pMemDarwin->Core.cb);*/
+            Assert(!pMemDarwin->Core.u.Phys.fAllocated);
+            break;
+
+        case RTR0MEMOBJTYPE_RES_VIRT:
+            AssertMsgFailed(("RTR0MEMOBJTYPE_RES_VIRT\n"));
+            return VERR_INTERNAL_ERROR;
+            break;
+
+        case RTR0MEMOBJTYPE_MAPPING:
+            /* nothing to do here. */
+            break;
+
+        default:
+            AssertMsgFailed(("enmType=%d\n", pMemDarwin->Core.enmType));
+            return VERR_INTERNAL_ERROR;
+    }
+
+    return VINF_SUCCESS;
+}
+
+
+int rtR0MemObjNativeAllocPage(PPRTR0MEMOBJINTERNAL ppMem, size_t cb, bool fExecutable)
+{
+    /*
+     * Try allocate the memory and create it's IOMemoryDescriptor first.
+     */
+    int rc = VERR_NO_PAGE_MEMORY;
+    AssertCompile(sizeof(IOPhysicalAddress) == 4);
+    void *pv = IOMallocAligned(cb, PAGE_SIZE);
+    if (pv)
+    {
+        IOMemoryDescriptor *pMemDesc = IOMemoryDescriptor::withAddress((vm_address_t)pv, cb, kIODirectionInOut, kernel_task);
+        if (pMemDesc)
+        {
+            /*
+             * Create the IPRT memory object.
+             */
+            PRTR0MEMOBJDARWIN pMemDarwin = (PRTR0MEMOBJDARWIN)rtR0MemObjNew(sizeof(*pMemDarwin), RTR0MEMOBJTYPE_PAGE, pv, cb);
+            if (pMemDarwin)
+            {
+                pMemDarwin->pMemDesc = pMemDesc;
+                *ppMem = &pMemDarwin->Core;
+                return VINF_SUCCESS;
+            }
+
+            rc = VERR_NO_MEMORY;
+            pMemDesc->release();
+        }
+        else
+            rc = VERR_MEMOBJ_INIT_FAILED;
+        IOFreeAligned(pv, cb);
+    }
+    return rc;
+}
+
+
+int rtR0MemObjNativeAllocLow(PPRTR0MEMOBJINTERNAL ppMem, size_t cb, bool fExecutable)
+{
+    /*
+     * IOMallocContiguous is the most suitable API.
+     */
+    return rtR0MemObjNativeAllocCont(ppMem, cb, fExecutable);
+}
+
+
+int rtR0MemObjNativeAllocCont(PPRTR0MEMOBJINTERNAL ppMem, size_t cb, bool fExecutable)
+{
+    /*
+     * Try allocate the memory and create it's IOMemoryDescriptor first.
+     */
+    int rc = VERR_NO_CONT_MEMORY;
+    AssertCompile(sizeof(IOPhysicalAddress) == 4);
+    void *pv = IOMallocContiguous(cb, PAGE_SIZE, NULL);
+    if (pv)
+    {
+        IOMemoryDescriptor *pMemDesc = IOMemoryDescriptor::withAddress((vm_address_t)pv, cb, kIODirectionInOut, kernel_task);
+        if (pMemDesc)
+        {
+            /* a bit of useful paranoia. */
+            addr64_t PhysAddr = pMemDesc->getPhysicalSegment64(0, NULL);
+            Assert(PhysAddr == pMemDesc->getPhysicalAddress());
+            if (    PhysAddr > 0
+                &&  PhysAddr <= _4G
+                &&  PhysAddr + cb <= _4G)
+            {
+                /*
+                 * Create the IPRT memory object.
+                 */
+                PRTR0MEMOBJDARWIN pMemDarwin = (PRTR0MEMOBJDARWIN)rtR0MemObjNew(sizeof(*pMemDarwin), RTR0MEMOBJTYPE_CONT, pv, cb);
+                if (pMemDarwin)
+                {
+                    pMemDarwin->Core.u.Cont.Phys = PhysAddr;
+                    pMemDarwin->pMemDesc = pMemDesc;
+                    *ppMem = &pMemDarwin->Core;
+                    return VINF_SUCCESS;
+                }
+
+                rc = VERR_NO_MEMORY;
+            }
+            else
+            {
+                AssertMsgFailed(("PhysAddr=%llx\n", (unsigned long long)PhysAddr));
+                rc = VERR_INTERNAL_ERROR;
+            }
+            pMemDesc->release();
+        }
+        else
+            rc = VERR_MEMOBJ_INIT_FAILED;
+        IOFreeContiguous(pv, cb);
+    }
+    return rc;
+}
+
+
+int rtR0MemObjNativeAllocPhys(PPRTR0MEMOBJINTERNAL ppMem, size_t cb, RTHCPHYS PhysHighest)
+{
+#if 0 /* turned out IOMallocPhysical isn't exported yet. sigh. */
+    /*
+     * Try allocate the memory and create it's IOMemoryDescriptor first.
+     * Note that IOMallocPhysical is not working correctly (it's ignoring the mask).
+     */
+
+    /* first calc the mask (in the hope that it'll be used) */
+    IOPhysicalAddress PhysMask = ~(IOPhysicalAddress)PAGE_OFFSET_MASK;
+    if (PhysHighest != NIL_RTHCPHYS)
+    {
+        PhysMask = ~(IOPhysicalAddress)0;
+        while (PhysMask > PhysHighest)
+            PhysMask >>= 1;
+        AssertReturn(PhysMask + 1 < cb, VERR_INVALID_PARAMETER);
+        PhysMask &= ~(IOPhysicalAddress)PAGE_OFFSET_MASK;
+    }
+
+    /* try allocate physical memory. */
+    int rc = VERR_NO_PHYS_MEMORY;
+    mach_vm_address_t PhysAddr64 = IOMallocPhysical(cb, PhysMask);
+    if (PhysAddr64)
+    {
+        IOPhysicalAddress PhysAddr = PhysAddr64;
+        if (    PhysAddr == PhysAddr64
+            &&  PhysAddr < PhysHighest
+            &&  PhysAddr + cb <= PhysHighest)
+        {
+            /* create a descriptor. */
+            IOMemoryDescriptor *pMemDesc = IOMemoryDescriptor::withPhysicalAddress(PhysAddr, cb, kIODirectionInOut);
+            if (pMemDesc)
+            {
+                Assert(PhysAddr == pMemDesc->getPhysicalAddress());
+
+                /*
+                 * Create the IPRT memory object.
+                 */
+                PRTR0MEMOBJDARWIN pMemDarwin = (PRTR0MEMOBJDARWIN)rtR0MemObjNew(sizeof(*pMemDarwin), RTR0MEMOBJTYPE_PHYS, NULL, cb);
+                if (pMemDarwin)
+                {
+                    pMemDarwin->Core.u.Phys.PhysBase = PhysAddr;
+                    pMemDarwin->Core.u.Phys.fAllocated = true;
+                    pMemDarwin->pMemDesc = pMemDesc;
+                    *ppMem = &pMemDarwin->Core;
+                    return VINF_SUCCESS;
+                }
+
+                rc = VERR_NO_MEMORY;
+                pMemDesc->release();
+            }
+            else
+                rc = VERR_MEMOBJ_INIT_FAILED;
+        }
+        else
+        {
+            AssertMsgFailed(("PhysAddr=%#llx PhysAddr64=%#llx PhysHigest=%#llx\n", (unsigned long long)PhysAddr,
+                             (unsigned long long)PhysAddr64, (unsigned long long)PhysHighest));
+            rc = VERR_INTERNAL_ERROR;
+        }
+
+        IOFreePhysical(PhysAddr64, cb);
+    }
+
+    /*
+     * Just in case IOMallocContigus doesn't work right, we can try fall back
+     * on a contiguous allcation.
+     */
+    if (rc == VERR_INTERNAL_ERROR || rc == VERR_NO_PHYS_MEMORY)
+    {
+        int rc2 = rtR0MemObjNativeAllocCont(ppMem, cb, false);
+        if (RT_SUCCESS(rc2))
+            rc = rc2;
+    }
+
+    return rc;
+
+#else
+
+    return rtR0MemObjNativeAllocCont(ppMem, cb, false);
+#endif
+}
+
+
+int rtR0MemObjNativeEnterPhys(PPRTR0MEMOBJINTERNAL ppMem, RTHCPHYS Phys, size_t cb)
+{
+    /*
+     * Validate the address range and create a descriptor for it.
+     */
+    int rc = VERR_ADDRESS_TOO_BIG;
+    IOPhysicalAddress PhysAddr = Phys;
+    if (PhysAddr == Phys)
+    {
+        IOMemoryDescriptor *pMemDesc = IOMemoryDescriptor::withPhysicalAddress(PhysAddr, cb, kIODirectionInOut);
+        if (pMemDesc)
+        {
+            Assert(PhysAddr == pMemDesc->getPhysicalAddress());
+
+            /*
+             * Create the IPRT memory object.
+             */
+            PRTR0MEMOBJDARWIN pMemDarwin = (PRTR0MEMOBJDARWIN)rtR0MemObjNew(sizeof(*pMemDarwin), RTR0MEMOBJTYPE_PHYS, NULL, cb);
+            if (pMemDarwin)
+            {
+                pMemDarwin->Core.u.Phys.PhysBase = PhysAddr;
+                pMemDarwin->Core.u.Phys.fAllocated = false;
+                pMemDarwin->pMemDesc = pMemDesc;
+                *ppMem = &pMemDarwin->Core;
+                return VINF_SUCCESS;
+            }
+
+            rc = VERR_NO_MEMORY;
+            pMemDesc->release();
+        }
+    }
+    else
+        AssertMsgFailed(("%#llx\n", (unsigned long long)Phys));
+    return rc;
+}
+
+
+int rtR0MemObjNativeLockUser(PPRTR0MEMOBJINTERNAL ppMem, void *pv, size_t cb)
+{
-    return VERR_NOT_IMPLEMENTED;
-}
-
-
-AllocPage(PPRTR0MEMOBJINTERNAL ppMem, size_t cb, bool fExecutable
+LockKernel(PPRTR0MEMOBJINTERNAL ppMem, void *pv, size_t cb
-{
-    return VERR_NOT_IMPLEMENTED;
@@ -48 +342 @@
-
-
-AllocLow(PPRTR0MEMOBJINTERNAL ppMem, size_t cb, bool fExecutable
+ReserveKernel(PPRTR0MEMOBJINTERNAL ppMem, void *pvFixed, size_t cb, size_t uAlignment
-{
-    return VERR_NOT_IMPLEMENTED;
@@ -54 +348 @@
-
-
-AllocCont(PPRTR0MEMOBJINTERNAL ppMem, size_t cb, bool fExecutable
+ReserveUser(PPRTR0MEMOBJINTERNAL ppMem, void *pvFixed, size_t cb, size_t uAlignment
-{
-    return VERR_NOT_IMPLEMENTED;
@@ -60 +354 @@
-
-
-int rtR0MemObjNativeLockUser(PPRTR0MEMOBJINTERNAL ppMem, void *pv, size_t cb)
-{
-    return VERR_NOT_IMPLEMENTED;
-}
-
-
-int rtR0MemObjNativeLockKernel(PPRTR0MEMOBJINTERNAL ppMem, void *pv, size_t cb)
-{
-    return VERR_NOT_IMPLEMENTED;
-}
-
-
-int rtR0MemObjNativeAllocPhys(PPRTR0MEMOBJINTERNAL ppMem, size_t cb, RTHCPHYS PhysHighest)
-{
-    return VERR_NOT_IMPLEMENTED;
-}
-
-
-int rtR0MemObjNativeEnterPhys(PPRTR0MEMOBJINTERNAL ppMem, RTHCPHYS Phys, size_t cb)
-{
-    return VERR_NOT_IMPLEMENTED;
-}
-
-
-int rtR0MemObjNativeReserveKernel(PPRTR0MEMOBJINTERNAL ppMem, void *pvFixed, size_t cb, size_t uAlignment)
-{
-    return VERR_NOT_IMPLEMENTED;
-}
-
-
-int rtR0MemObjNativeReserveUser(PPRTR0MEMOBJINTERNAL ppMem, void *pvFixed, size_t cb, size_t uAlignment)
-{
-    return VERR_NOT_IMPLEMENTED;
-}
-
-
-int rtR0MemObjNativeMapKernel(PPRTR0MEMOBJINTERNAL ppMem, RTR0MEMOBJ pMemToMap, void *pvFixed, size_t uAlignment, unsigned fProt)
-{
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-}
-
@@ -104 +399 @@
-int rtR0MemObjNativeMapUser(PPRTR0MEMOBJINTERNAL ppMem, RTR0MEMOBJ pMemToMap, void *pvFixed, size_t uAlignment, unsigned fProt)
-{
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

trunk/src/VBox/Runtime/r0drv/darwin/the-darwin-kernel.h

@@ -60 +60 @@
-#include <IOKit/IOTypes.h>
-#include <IOKit/IOLib.h>
+#include <IOKit/IOMemoryDescriptor.h>
+#include <IOKit/IOMapper.h>
-
-

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

@@ -92 +92 @@
-            return VERR_NO_MEMORY;
-        pParent->uRel.Parent.papMappings = (PPRTR0MEMOBJINTERNAL)pv;
+        pParent->uRel.Parent.cMappingsAllocated = i + 32;
-        Assert(i == pParent->uRel.Parent.cMappings);
-    }
@@ -97 +98 @@
-    /* do the linking. */
-    pParent->uRel.Parent.papMappings[i] = pChild;
+    pParent->uRel.Parent.cMappings++;
-    pChild->uRel.Child.pParent = pParent;
-
@@ -188 +190 @@
-    }
-
-
+
+
+
+
+
+
+
+
+
+
+
-    return rtR0MemObjNativeGetPagePhysAddr(pMem, iPage);
-}
@@ -263 +275 @@
-            AssertFatal(pParent->enmType > RTR0MEMOBJTYPE_INVALID && pParent->enmType < RTR0MEMOBJTYPE_END);
-            AssertFatal(!rtR0MemObjIsMapping(pParent));
+            AssertFatal(pParent->uRel.Parent.cMappings > 0);
+            AssertPtr(pParent->uRel.Parent.papMappings);
-
-            /* locate and remove from the array of mappings. */
@@ -436 +450 @@
-    const size_t cbAligned = RT_ALIGN_Z(cb, PAGE_SIZE);
-    AssertReturn(cb <= cbAligned, VERR_INVALID_PARAMETER);
+    AssertReturn(PhysHighest >= cb, VERR_INVALID_PARAMETER);
-
-    /* do the allocation. */