Changeset 4155 in vbox for trunk/src/VBox/Runtime/r0drv

Timestamp:

Aug 15, 2007 7:41:26 PM (17 years ago)

Author:

vboxsync

Message:

RTR0MemGetAddressR3 & RTR0MemObjLockUser. Linux memobj impl.

Location:

trunk/src/VBox/Runtime/r0drv

Files:

• darwin/memobj-r0drv-darwin.cpp (modified) (1 diff)
• freebsd/memobj-r0drv-freebsd.c (modified) (2 diffs)
• linux/memobj-r0drv-linux.c (copied) (copied from trunk/src/VBox/Runtime/r0drv/darwin/memobj-r0drv-darwin.cpp ) (4 diffs)
• linux/the-linux-kernel.h (modified) (1 diff)
• memobj-r0drv.cpp (modified) (3 diffs)
• os2/memobj-r0drv-os2.cpp (modified) (3 diffs)

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

@@ -484 +484 @@
 
 
-int rtR0MemObjNativeLockUser(PPRTR0MEMOBJINTERNAL ppMem, void *pv, size_t cb, RTR0PROCESS R0Process)
-{
-    return rtR0MemObjNativeLock(ppMem, pv, cb, (task_t)R0Process);
+int rtR0MemObjNativeLockUser(PPRTR0MEMOBJINTERNAL ppMem, RTR3PTR R3Ptr, size_t cb, RTR0PROCESS R0Process)
+{
+    return rtR0MemObjNativeLock(ppMem, (void *)R3Ptr, cb, (task_t)R0Process);
 }
 

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

@@ -330 +330 @@
 
 
-int rtR0MemObjNativeLockUser(PPRTR0MEMOBJINTERNAL ppMem, void *pv, size_t cb, RTR0PROCESS R0Process)
+int rtR0MemObjNativeLockUser(PPRTR0MEMOBJINTERNAL ppMem, RTR3PTR R3Ptr, size_t cb, RTR0PROCESS R0Process)
 {
     int rc;
 
     /* create the object. */
-    PRTR0MEMOBJFREEBSD pMemFreeBSD = (PRTR0MEMOBJFREEBSD)rtR0MemObjNew(sizeof(*pMemFreeBSD), RTR0MEMOBJTYPE_LOCK, pv, cb);
+    PRTR0MEMOBJFREEBSD pMemFreeBSD = (PRTR0MEMOBJFREEBSD)rtR0MemObjNew(sizeof(*pMemFreeBSD), RTR0MEMOBJTYPE_LOCK, (void *)R3Ptr, cb);
     if (!pMemFreeBSD)
         return VERR_NO_MEMORY;
@@ -344 +344 @@
      */
     rc = vm_map_wire(&((struct proc *)R0Process)->p_vmspace->vm_map, /* the map */
-                     (vm_offset_t)pv,                               /* start */
-                     (vm_offset_t)pv + cb,                          /* end */
+                     (vm_offset_t)R3Ptr,                            /* start */
+                     (vm_offset_t)R3Ptr + cb,                       /* end */
                      VM_MAP_WIRE_SYSTEM | VM_MAP_WIRE_NOHOLES);     /* flags - SYSTEM? */
     if (rc == KERN_SUCCESS)

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

@@ -1 +1 @@
 /* $Id$ */
 /** @file
- * innotek Portable Runtime - Ring-0 Memory Objects, Darwin.
+ * innotek Portable Runtime - Ring-0 Memory Objects, Linux.
  */
 
@@ -20 +20 @@
 *   Header Files                                                               *
 *******************************************************************************/
-#include "the-darwin-kernel.h"
+#include "the-linux-kernel.h"
 
 #include <iprt/memobj.h>
@@ -26 +26 @@
 #include <iprt/assert.h>
 #include <iprt/log.h>
-#include <iprt/param.h>
+//#include <iprt/param.h>
 #include <iprt/string.h>
 #include <iprt/process.h>
 #include "internal/memobj.h"
-
-#define USE_VM_MAP_WIRE
 
 
@@ -40 +38 @@
  * The Darwin version of the memory object structure.
  */
-typedef struct RTR0MEMOBJDARWIN
+typedef struct RTR0MEMOBJLNX
 {
     /** 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;
+    /** Set if the allocation is contiguous.
+     * This means it has to be given back as one chunk. */
+    bool                fContiguous;
+    /** Set if we've vmap'ed thed memory into ring-0. */
+    bool                fMappedToRing0;
+    /** The pages in the apPages array. */
+    size_t              cPages;
+    /** Array of struct page pointers. (variable size) */
+    struct page        *apPages[1];
+} RTR0MEMOBJLNX, *PRTR0MEMOBJLNX;
+
+
+/**
+ * Helper that converts from a RTR0PROCESS handle to a linux task.
+ *
+ * @returns The corresponding Linux task.
+ * @param   R0Process   IPRT ring-0 process handle.
+ */
+struct task_struct *rtR0ProcessToLinuxTask(RTR0PROCESS R0Process)
+{
+    /** @todo fix rtR0ProcessToLinuxTask!! */
+    return R0Process == RTR0ProcHandleSelf() ? current : NULL;
+}
+
+
+/**
+ * Compute order. Some functions allocate 2^order pages.
+ *
+ * @returns order.
+ * @param   cPages      Number of pages.
+ */
+static int rtR0MemObjLinuxOrder(size_t cPages)
+{
+    int     iOrder;
+    size_t  cTmp;
+
+    for (iOrder = 0, cTmp = cPages; cTmp >>= 1; ++iOrder)
+        ;
+    if (cPages & ~((size_t)1 << iOrder))
+        ++iOrder;
+
+    return iOrder;
+}
+
+
+/**
+ * Converts from RTMEM_PROT_* to Linux PAGE_*.
+ *
+ * @returns Linux page protection constant.
+ * @param   fProt       The IPRT protection mask.
+ * @param   fKernel     Whether it applies to kernel or user space.
+ */
+static pgprot_t rtR0MemObjLinuxConvertProt(unsigned fProt, bool fKernel)
+{
+    switch (fProt)
+    {
+        default:
+            AssertMsgFailed(("%#x %d\n", fProt, fKernel));
+        case RTMEM_PROT_NONE:
+            return PAGE_NONE;
+
+        case RTMEM_PROT_READ:
+            return fKernel ? PAGE_KERNEL_RO         : PAGE_READONLY;
+
+        case RTMEM_PROT_WRITE:
+        case RTMEM_PROT_WRITE | RTMEM_PROT_READ:
+            return fKernel ? PAGE_KERNEL            : PAGE_SHARED;
+
+        case RTMEM_PROT_EXEC:
+        case RTMEM_PROT_EXEC | RTMEM_PROT_READ:
+#if defined(RT_ARCH_X86) || defined(RT_ARCH_AMD64)
+            if (fKernel)
+            {
+                pgprot_t fPg = MY_PAGE_KERNEL_EXEC;
+                pgprot_val(fPg) &= ~_PAGE_RW;
+                return fPg;
+            }
+            return PAGE_READONLY_EXEC;
+#else
+            return fKernel ? MY_PAGE_KERNEL_EXEC    : PAGE_READONLY_EXEC;
+#endif
+
+        case RTMEM_PROT_WRITE | RTMEM_PROT_EXEC:
+        case RTMEM_PROT_WRITE | RTMEM_PROT_EXEC | RTMEM_PROT_READ:
+            return fKernel ? MY_PAGE_KERNEL_EXEC    : PAGE_SHARED_EXEC;
+    }
+}
+
+
+/**
+ * Internal worker that allocates physical pages and creates the memory object for them.
+ *
+ * @returns IPRT status code.
+ * @param   ppMemLnx    Where to store the memory object pointer.
+ * @param   enmType     The object type.
+ * @param   cb          The number of bytes to allocate.
+ * @param   fFlagsLnx   The page allocation flags (GPFs).
+ * @param   fContiguous Whether the allocation must be contiguous.
+ */
+static int rtR0MemObjLinuxAllocPages(PRTR0MEMOBJLNX *ppMemLnx, RTR0MEMOBJTYPE enmType, size_t cb, unsigned fFlagsLnx, bool fContiguous)
+{
+    size_t          iPage;
+    size_t          cPages = cb >> PAGE_SHIFT;
+    struct page    *paPages;
+
+    /*
+     * Allocate a memory object structure that's large enough to contain
+     * the page pointer array.
+     */
+    PRTR0MEMOBJLNX  pMemLnx = (PRTR0MEMOBJLNX)rtR0MemObjNew(RT_OFFSETOF(RTR0MEMOBJLNX, apPages[cPages]), enmType, NULL, cb);
+    if (!pMemLnx)
+        return VERR_NO_MEMORY;
+    pMemLnx->cPages = cPages;
+
+    /*
+     * Allocate the pages.
+     * For small allocations we'll try contiguous first and then fall back on page by page.
+     */
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 4, 22)
+    if (    fContiguous
+        ||  cb <= PAGE_SIZE * 2)
+    {
+        paPages = alloc_pages(fFlagsLnx, rtR0MemObjLinuxOrder(cb));
+        if (paPages)
+        {
+            fContiguous = true;
+            for (iPage = 0; iPage < cPages; iPage++)
+                pMemLnx->apPages[iPage] = &paPages[iPage];
+        }
+        else if (fContiguous)
+        {
+            rtR0MemObjDelete(&pMemLnx->Core);
+            return VERR_NO_MEMORY;
+        }
+    }
+
+    if (!fContiguous)
+    {
+        for (iPage = 0; iPage < cPages; iPage++)
+        {
+            pMemLnx->apPages[iPage] = alloc_page(fFlagsLnx);
+            if (RT_UNLIKELY(!pMemLnx->apPages[iPage]))
+            {
+                while (iPage-- > 0)
+                    __free_page(pMemLnx->apPages[iPage]);
+                rtR0MemObjDelete(&pMemLnx->Core);
+                return VERR_NO_MEMORY;
+            }
+        }
+    }
+
+#else /* < 2.4.22 */
+    /** @todo figure out why we didn't allocate page-by-page on 2.4.21 and older... */
+    paPages = alloc_pages(fFlagsLnx, rtR0MemObjLinuxOrder(cb));
+    if (!paPages)
+    {
+        rtR0MemObjDelete(&pMemLnx->Core);
+        return VERR_NO_MEMORY;
+    }
+    for (iPage = 0; iPage < cPages; iPage++)
+    {
+        pMemLnx->apPages[iPage] = &paPages[iPage];
+        if (pgprot_val(MY_PAGE_KERNEL_EXEC) != pgprot_val(PAGE_KERNEL))
+            MY_CHANGE_PAGE_ATTR(pMemLnx->apPages[iPage], 1, MY_PAGE_KERNEL_EXEC);
+        if (PageHighMem(pMemLnx->apPages[iPage]))
+            BUG();
+    }
+
+    fPageByPage = false;
+#endif /* < 2.4.22 */
+    pMemLnx->fContiguous = fContiguous;
+
+    /*
+     * Reserve the pages.
+     */
+    for (iPage = 0; iPage < cPages; iPage++)
+        SetPageReserved(pMemLnx->apPages[iPage]);
+
+    *ppMemLnx = pMemLnx;
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * Frees the physical pages allocated by the rtR0MemObjLinuxAllocPages() call.
+ *
+ * This method does NOT free the object.
+ *
+ * @param   pMemLnx     The object which physical pages should be freed.
+ */
+static void rtR0MemObjLinuxFreePages(PRTR0MEMOBJLNX pMemLnx)
+{
+    size_t iPage = pMemLnx->cPages;
+    if (iPage > 0)
+    {
+        /*
+         * Restore the page flags.
+         */
+        while (iPage-- > 0)
+        {
+            ClearPageReserved(pMemLnx->apPages[iPage]);
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 4, 22)
+#else
+            if (pgprot_val(MY_PAGE_KERNEL_EXEC) != pgprot_val(PAGE_KERNEL))
+                MY_CHANGE_PAGE_ATTR(pMemLnx->apPages[iPage], 1, PAGE_KERNEL);
+#endif
+        }
+
+        /*
+         * Free the pages.
+         */
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 4, 22)
+        if (!pMemLnx->fContiguous)
+        {
+            iPage = pMemLnx->cPages;
+            while (iPage-- > 0)
+                __free_page(pMemLnx->apPages[iPage]);
+        }
+        else
+#endif
+            __free_pages(pMemLnx->apPages[0], rtR0MemObjLinuxOrder(pMemLnx->cPages));
+
+        pMemLnx->cPages = 0;
+    }
+}
+
+
+/**
+ * Maps the allocation into ring-0.
+ *
+ * This will update the RTR0MEMOBJLNX::Core.pv and RTR0MEMOBJ::fMappedToRing0 members.
+ *
+ * Contiguous mappings that isn't in 'high' memory will already be mapped into kernel
+ * space, so we'll use that mapping if possible. If execute access is required, we'll
+ * play safe and do our own mapping.
+ *
+ * @returns IPRT status code.
+ * @param   pMemLnx     The linux memory object to map.
+ * @param   fExecutable Whether execute access is required.
+ */
+static int rtR0MemObjLinuxVMap(PRTR0MEMOBJLNX pMemLnx, bool fExecutable)
+{
+    int rc = VINF_SUCCESS;
+
+    /*
+     * Choose mapping strategy.
+     */
+    bool fMustMap = fExecutable
+                 || !pMemLnx->fContiguous;
+    if (!fMustMap)
+    {
+        size_t iPage = pMemLnx->cPages;
+        while (iPage-- > 0)
+            if (PageHighMem(pMemLnx->apPages[iPage]))
+            {
+                fMustMap = true;
+                break;
+            }
+    }
+
+    Assert(!pMemLnx->Core.pv);
+    Assert(!pMemLnx->fMappedToRing0);
+
+    if (fMustMap)
+    {
+        /*
+         * Use vmap - 2.4.22 and later.
+         */
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 4, 22)
+        pgprot_t fPg;
+        pgprot_val(fPg) = _PAGE_PRESENT | _PAGE_RW;
+# ifdef _PAGE_NX
+        if (!fExecutable)
+            pgprot_val(fPg) |= _PAGE_NX;
+# endif
+
+# ifdef VM_MAP
+        pMemLnx->Core.pv = vmap(&pMemLnx->apPages[0], pMemLnx->cPages, VM_MAP, fPg);
+# else
+        pMemLnx->Core.pv = vmap(&pMemLnx->apPages[0], pMemLnx->cPages, VM_ALLOC, fPg);
+# endif
+        if (pMemLnx->Core.pv)
+            pMemLnx->fMappedToRing0 = true;
+        else
+            rc = VERR_MAP_FAILED;
+#else   /* < 2.4.22 */
+        rc = VERR_NOT_SUPPORTED;
+#endif
+    }
+    else
+    {
+        /*
+         * Use the kernel RAM mapping.
+         */
+        pMemLnx->Core.pv = phys_to_virt(page_to_phys(pMemLnx->apPages[0]));
+        Assert(pMemLnx->Core.pv);
+    }
+
+    return rc;
+}
+
+
+/**
+ * Undos what rtR0MemObjLinuxVMap() did.
+ *
+ * @param   pMemLnx     The linux memory object.
+ */
+static void rtR0MemObjLinuxVUnmap(PRTR0MEMOBJLNX pMemLnx)
+{
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 4, 22)
+    if (pMemLnx->fMappedToRing0)
+    {
+        Assert(pMemLnx->Core.pv);
+        vunmap(pMemLnx->Core.pv);
+        pMemLnx->fMappedToRing0 = false;
+    }
+#else /* < 2.4.22 */
+    Assert(!pMemLnx->fMappedToRing0);
+#endif
+    pMemLnx->Core.pv = NULL;
+}
 
 
 int rtR0MemObjNativeFree(RTR0MEMOBJ pMem)
 {
-    PRTR0MEMOBJDARWIN pMemDarwin = (PRTR0MEMOBJDARWIN)pMem;
-
-    /*
-     * Release the IOMemoryDescriptor/IOMemoryMap associated with the object.
-     */
-    if (pMemDarwin->pMemDesc)
-    {
-        if (pMemDarwin->Core.enmType == RTR0MEMOBJTYPE_LOCK)
-            pMemDarwin->pMemDesc->complete(); /* paranoia */
-        pMemDarwin->pMemDesc->release();
-        pMemDarwin->pMemDesc = NULL;
-        Assert(!pMemDarwin->pMemMap);
-    }
-    else if (pMemDarwin->pMemMap)
-    {
-        pMemDarwin->pMemMap->release();
-        pMemDarwin->pMemMap = NULL;
-    }
+    PRTR0MEMOBJLNX pMemLnx = (PRTR0MEMOBJLNX)pMem;
 
     /*
      * Release any memory that we've allocated or locked.
      */
-    switch (pMemDarwin->Core.enmType)
+    switch (pMemLnx->Core.enmType)
     {
         case RTR0MEMOBJTYPE_LOW:
         case RTR0MEMOBJTYPE_PAGE:
-            IOFreeAligned(pMemDarwin->Core.pv, pMemDarwin->Core.cb);
+        case RTR0MEMOBJTYPE_CONT:
+        case RTR0MEMOBJTYPE_PHYS:
+            rtR0MemObjLinuxVUnmap(pMemLnx);
+            rtR0MemObjLinuxFreePages(pMemLnx);
             break;
 
+        case RTR0MEMOBJTYPE_LOCK:
+            if (pMemLnx->Core.u.Lock.R0Process != NIL_RTR0PROCESS)
+            {
+                struct task_struct *pTask = rtR0ProcessToLinuxTask(pMemLnx->Core.u.Lock.R0Process);
+                size_t iPage;
+                down_read(&pTask->mm->mmap_sem);
+
+                iPage = pMemLnx->cPages;
+                while (iPage-- > 0)
+                {
+                    if (!PageReserved(pMemLnx->apPages[iPage]))
+                        SetPageDirty(pMemLnx->apPages[iPage]);
+                    page_cache_release(pMemLnx->apPages[iPage]);
+                }
+
+                up_read(&pTask->mm->mmap_sem);
+            }
+            else
+                AssertFailed(); /* not implemented for R0 */
+            break;
+
+        case RTR0MEMOBJTYPE_RES_VIRT:
+            Assert(pMemLnx->Core.pv);
+            if (pMemLnx->Core.u.ResVirt.R0Process != NIL_RTR0PROCESS)
+            {
+                struct task_struct *pTask = rtR0ProcessToLinuxTask(pMemLnx->Core.u.Lock.R0Process);
+                down_write(&pTask->mm->mmap_sem);
+                MY_DO_MUNMAP(pTask->mm, (unsigned long)pMemLnx->Core.pv, pMemLnx->Core.cb);
+                up_write(&pTask->mm->mmap_sem);
+            }
+            else
+            {
+                vunmap(pMemLnx->Core.pv);
+
+                Assert(pMemLnx->cPages == 1 && pMemLnx->apPages[0] != NULL);
+                __free_page(pMemLnx->apPages[0]);
+                pMemLnx->apPages[0] = NULL;
+                pMemLnx->cPages = 0;
+            }
+            pMemLnx->Core.pv = NULL;
+            break;
+
+        case RTR0MEMOBJTYPE_MAPPING:
+            Assert(pMemLnx->cPages == 0); Assert(pMemLnx->Core.pv);
+            if (pMemLnx->Core.u.ResVirt.R0Process != NIL_RTR0PROCESS)
+            {
+                struct task_struct *pTask = rtR0ProcessToLinuxTask(pMemLnx->Core.u.Lock.R0Process);
+                down_write(&pTask->mm->mmap_sem);
+                MY_DO_MUNMAP(pTask->mm, (unsigned long)pMemLnx->Core.pv, pMemLnx->Core.cb);
+                up_write(&pTask->mm->mmap_sem);
+            }
+            else
+                vunmap(pMemLnx->Core.pv);
+            pMemLnx->Core.pv = NULL;
+            break;
+
+        default:
+            AssertMsgFailed(("enmType=%d\n", pMemLnx->Core.enmType));
+            return VERR_INTERNAL_ERROR;
+    }
+    return VINF_SUCCESS;
+}
+
+
+int rtR0MemObjNativeAllocPage(PPRTR0MEMOBJINTERNAL ppMem, size_t cb, bool fExecutable)
+{
+    PRTR0MEMOBJLNX pMemLnx;
+    int rc;
+
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 4, 22)
+    rc = rtR0MemObjLinuxAllocPages(&pMemLnx, RTR0MEMOBJTYPE_PAGE, cb, GFP_HIGHUSER, false /* non-contiguous */);
+#else
+    rc = rtR0MemObjLinuxAllocPages(&pMemLnx, RTR0MEMOBJTYPE_PAGE, cb, GFP_USER, false /* non-contiguous */);
+#endif
+    if (RT_SUCCESS(rc))
+    {
+        rc = rtR0MemObjLinuxVMap(pMemLnx, fExecutable);
+        if (RT_SUCCESS(rc))
+        {
+            *ppMem = &pMemLnx->Core;
+            return rc;
+        }
+
+        rtR0MemObjLinuxFreePages(pMemLnx);
+        rtR0MemObjDelete(&pMemLnx->Core);
+    }
+
+    return rc;
+}
+
+
+int rtR0MemObjNativeAllocLow(PPRTR0MEMOBJINTERNAL ppMem, size_t cb, bool fExecutable)
+{
+    PRTR0MEMOBJLNX pMemLnx;
+    int rc;
+
+#ifdef RT_ARCH_AMD64
+# ifdef GFP_DMA32
+    rc = rtR0MemObjLinuxAllocPages(&pMemLnx, RTR0MEMOBJTYPE_LOW, cb, GFP_DMA32, false /* non-contiguous */);
+# else
+    rc = rtR0MemObjLinuxAllocPages(&pMemLnx, RTR0MEMOBJTYPE_LOW, cb, GFP_DMA, false /* non-contiguous */);
+# endif
+#else
+    rc = rtR0MemObjLinuxAllocPages(&pMemLnx, RTR0MEMOBJTYPE_LOW, cb, GFP_USER, false /* non-contiguous */);
+#endif
+    if (RT_SUCCESS(rc))
+    {
+        rc = rtR0MemObjLinuxVMap(pMemLnx, fExecutable);
+        if (RT_SUCCESS(rc))
+        {
+            *ppMem = &pMemLnx->Core;
+            return rc;
+        }
+
+        rtR0MemObjLinuxFreePages(pMemLnx);
+        rtR0MemObjDelete(&pMemLnx->Core);
+    }
+
+    return rc;
+}
+
+
+int rtR0MemObjNativeAllocCont(PPRTR0MEMOBJINTERNAL ppMem, size_t cb, bool fExecutable)
+{
+    PRTR0MEMOBJLNX pMemLnx;
+    int rc;
+
+#ifdef RT_ARCH_AMD64
+# ifdef GFP_DMA32
+    rc = rtR0MemObjLinuxAllocPages(&pMemLnx, RTR0MEMOBJTYPE_CONT, cb, GFP_DMA32, true /* contiguous */);
+# else
+    rc = rtR0MemObjLinuxAllocPages(&pMemLnx, RTR0MEMOBJTYPE_CONT, cb, GFP_DMA, true /* contiguous */);
+# endif
+#else
+    rc = rtR0MemObjLinuxAllocPages(&pMemLnx, RTR0MEMOBJTYPE_CONT, cb, GFP_USER, true /* contiguous */);
+#endif
+    if (RT_SUCCESS(rc))
+    {
+        rc = rtR0MemObjLinuxVMap(pMemLnx, fExecutable);
+        if (RT_SUCCESS(rc))
+        {
+#ifdef RT_STRICT
+            size_t iPage = pMemLnx->cPages;
+            while (iPage-- > 0)
+                Assert(page_to_phys(pMemLnx->apPages[iPage]) < _4G);
+#endif
+            pMemLnx->Core.u.Cont.Phys = page_to_phys(pMemLnx->apPages[0]);
+            *ppMem = &pMemLnx->Core;
+            return rc;
+        }
+
+        rtR0MemObjLinuxFreePages(pMemLnx);
+        rtR0MemObjDelete(&pMemLnx->Core);
+    }
+
+    return rc;
+}
+
+
+/**
+ * Worker for rtR0MemObjNativeAllocPhys and rtR0MemObjNativeAllocPhysNC.
+ *
+ * @returns IPRT status.
+ * @param   ppMemLnx    Where to
+ * @param   enmType     The object type.
+ * @param   cb          The size of the allocation.
+ * @param   PhysHighest See rtR0MemObjNativeAllocPhys.
+ * @param   fGfp        The Linux GFP flags to use for the allocation.
+ */
+static int rtR0MemObjLinuxAllocPhysSub(PPRTR0MEMOBJINTERNAL ppMem, RTR0MEMOBJTYPE enmType, size_t cb, RTHCPHYS PhysHighest, unsigned fGfp)
+{
+    PRTR0MEMOBJLNX pMemLnx;
+    int rc;
+
+    rc = rtR0MemObjLinuxAllocPages(&pMemLnx, enmType, cb, fGfp,
+                                   enmType == RTR0MEMOBJTYPE_PHYS /* contiguous / non-contiguous */);
+    if (RT_FAILURE(rc))
+        return rc;
+
+    /*
+     * Check the addresses if necessary. (Can be optimized a bit for PHYS.)
+     */
+    if (PhysHighest != NIL_RTHCPHYS)
+    {
+        size_t iPage = pMemLnx->cPages;
+        while (iPage-- > 0)
+            if (page_to_phys(pMemLnx->apPages[iPage]) >= PhysHighest)
+            {
+                rtR0MemObjLinuxFreePages(pMemLnx);
+                rtR0MemObjDelete(&pMemLnx->Core);
+                return VERR_NO_MEMORY;
+            }
+    }
+
+    /*
+     * Complete the object.
+     */
+    if (enmType == RTR0MEMOBJTYPE_PHYS)
+    {
+        pMemLnx->Core.u.Phys.PhysBase = page_to_phys(pMemLnx->apPages[0]);
+        pMemLnx->Core.u.Phys.fAllocated = true;
+    }
+    *ppMem = &pMemLnx->Core;
+    return rc;
+}
+
+
+int rtR0MemObjNativeAllocPhys(PPRTR0MEMOBJINTERNAL ppMem, size_t cb, RTHCPHYS PhysHighest)
+{
+    unsigned fGfp;
+    unsigned fGfp2;
+    int rc;
+
+    /*
+     * Calc the allocation flags for the first and second allocation attempt
+     * and perform the allocation(s).
+     */
+    if (PhysHighest == NIL_RTHCPHYS)
+        fGfp2 = fGfp = GFP_HIGHUSER;
+#ifdef GFP_DMA32
+    else if (PhysHighest >= _4G)
+        fGfp2 = fGfp = GFP_DMA32;
+#endif
+    else if (PhysHighest <= _1M * 16)
+        fGfp2 = fGfp = GFP_DMA;
+    else
+    {
+        fGfp = GFP_USER;
+        fGfp2 = GFP_DMA;
+    }
+    rc = rtR0MemObjLinuxAllocPhysSub(ppMem, RTR0MEMOBJTYPE_PHYS, cb, PhysHighest, fGfp);
+    if (    RT_FAILURE(rc)
+        &&  fGfp2 != fGfp)
+        rc = rtR0MemObjLinuxAllocPhysSub(ppMem, RTR0MEMOBJTYPE_PHYS, cb, PhysHighest, fGfp2);
+    return rc;
+}
+
+
+int rtR0MemObjNativeAllocPhysNC(PPRTR0MEMOBJINTERNAL ppMem, size_t cb, RTHCPHYS PhysHighest)
+{
+    unsigned fGfp;
+    unsigned fGfp2;
+    int rc;
+
+    /*
+     * Calc the allocation flags for the first and second allocation attempt
+     * and perform the allocation(s).
+     */
+    if (PhysHighest == NIL_RTHCPHYS)
+        fGfp2 = fGfp = GFP_HIGHUSER;
+#ifdef GFP_DMA32
+    else if (PhysHighest >= _4G)
+        fGfp2 = fGfp = GFP_DMA32;
+#endif
+    else if (PhysHighest <= _1M * 16)
+        fGfp2 = fGfp = GFP_DMA;
+    else
+    {
+        fGfp = GFP_USER;
+        fGfp2 = GFP_DMA;
+    }
+    rc = rtR0MemObjLinuxAllocPhysSub(ppMem, RTR0MEMOBJTYPE_PHYS_NC, cb, PhysHighest, fGfp);
+    if (    RT_FAILURE(rc)
+        &&  fGfp2 != fGfp)
+        rc = rtR0MemObjLinuxAllocPhysSub(ppMem, RTR0MEMOBJTYPE_PHYS_NC, cb, PhysHighest, fGfp2);
+    return rc;
+}
+
+
+int rtR0MemObjNativeEnterPhys(PPRTR0MEMOBJINTERNAL ppMem, RTHCPHYS Phys, size_t cb)
+{
+    /*
+     * All we need to do here is to validate that we can use
+     * ioremap on the specified address (32/64-bit dma_addr_t).
+     */
+    PRTR0MEMOBJLNX  pMemLnx;
+    dma_addr_t      PhysAddr = Phys;
+    AssertMsgReturn(PhysAddr == Phys, ("%#llx\n", (unsigned long long)Phys), VERR_ADDRESS_TOO_BIG);
+
+    pMemLnx = (PRTR0MEMOBJLNX)rtR0MemObjNew(sizeof(*pMemLnx), RTR0MEMOBJTYPE_PHYS, NULL, cb);
+    if (!pMemLnx)
+        return VERR_NO_MEMORY;
+
+    pMemLnx->Core.u.Phys.PhysBase = PhysAddr;
+    pMemLnx->Core.u.Phys.fAllocated = false;
+    Assert(!pMemLnx->cPages);
+    *ppMem = &pMemLnx->Core;
+    return VINF_SUCCESS;
+}
+
+
+int rtR0MemObjNativeLockUser(PPRTR0MEMOBJINTERNAL ppMem, RTR3PTR R3Ptr, size_t cb, RTR0PROCESS R0Process)
+{
+    const int cPages = cb >> PAGE_SHIFT;
+    struct task_struct *pTask = rtR0ProcessToLinuxTask(R0Process);
+    struct vm_area_struct **papVMAs;
+    PRTR0MEMOBJLNX pMemLnx;
+    int rc;
+
+    /*
+     * Check for valid task and size overflows.
+     */
+    if (!pTask)
+        return VERR_NOT_SUPPORTED;
+    if (((size_t)cPages << PAGE_SHIFT) != cb)
+        return VERR_OUT_OF_RANGE;
+
+    /*
+     * Allocate the memory object and a temporary buffer for the VMAs.
+     */
+    pMemLnx = (PRTR0MEMOBJLNX)rtR0MemObjNew(RT_OFFSETOF(RTR0MEMOBJLNX, apPages[cPages]), RTR0MEMOBJTYPE_LOCK, (void *)R3Ptr, cb);
+    if (!pMemLnx)
+        return VERR_NO_MEMORY;
+
+    papVMAs = (struct vm_area_struct **)RTMemAlloc(sizeof(*papVMAs) * cPages);
+    if (papVMAs)
+    {
+        down_read(&pTask->mm->mmap_sem);
+
+        /*
+         * Get user pages.
+         */
+        rc = get_user_pages(pTask,                  /* Task for fault acounting. */
+                            pTask->mm,              /* Whose pages. */
+                            R3Ptr,                  /* Where from. */
+                            cPages,                 /* How many pages. */
+                            1,                      /* Write to memory. */
+                            0,                      /* force. */
+                            &pMemLnx->apPages[0],   /* Page array. */
+                            papVMAs);               /* vmas */
+        if (rc == cPages)
+        {
+            /*
+             * Flush dcache (required?) and protect against fork.
+             */
+            /** @todo The Linux fork() protection will require more work if this API
+             * is to be used for anything but locking VM pages. */
+            while (rc-- > 0)
+            {
+                flush_dcache_page(pMemLnx->apPages[rc]);
+                papVMAs[rc]->vm_flags |= VM_DONTCOPY;
+            }
+
+            up_read(&pTask->mm->mmap_sem);
+
+            RTMemFree(papVMAs);
+
+            pMemLnx->Core.u.Lock.R0Process = R0Process;
+            pMemLnx->cPages = cPages;
+            Assert(!pMemLnx->fMappedToRing0);
+            *ppMem = &pMemLnx->Core;
+
+            return VINF_SUCCESS;
+        }
+
+        /*
+         * Failed - we need to unlock any pages that we succeeded to lock.
+         */
+        while (rc-- > 0)
+        {
+            if (!PageReserved(pMemLnx->apPages[rc]))
+                SetPageDirty(pMemLnx->apPages[rc]);
+            page_cache_release(pMemLnx->apPages[rc]);
+        }
+
+        up_read(&pTask->mm->mmap_sem);
+
+        RTMemFree(papVMAs);
+        rc = VERR_LOCK_FAILED;
+    }
+
+    rtR0MemObjDelete(&pMemLnx->Core);
+    return rc;
+}
+
+
+int rtR0MemObjNativeLockKernel(PPRTR0MEMOBJINTERNAL ppMem, void *pv, size_t cb)
+{
+    /* What is there to lock? Should/Can we fake this? */
+    return VERR_NOT_SUPPORTED;
+}
+
+
+int rtR0MemObjNativeReserveKernel(PPRTR0MEMOBJINTERNAL ppMem, void *pvFixed, size_t cb, size_t uAlignment)
+{
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 4, 22)
+    const size_t cPages = cb >> PAGE_SHIFT;
+    struct page *pDummyPage;
+    struct page **papPages;
+
+    /* check for unsupported stuff. */
+    AssertMsgReturn(pvFixed == (void *)-1, ("%p\n", pvFixed), VERR_NOT_SUPPORTED);
+    AssertMsgReturn(uAlignment <= PAGE_SIZE, ("%#x\n", uAlignment), VERR_NOT_SUPPORTED);
+
+    /*
+     * Allocate a dummy page and create a page pointer array for vmap such that
+     * the dummy page is mapped all over the reserved area.
+     */
+    pDummyPage = alloc_page(GFP_HIGHUSER);
+    if (!pDummyPage)
+        return VERR_NO_MEMORY;
+    papPages = RTMemAlloc(sizeof(*papPages) * cPages);
+    if (papPages)
+    {
+        void *pv;
+        size_t iPage = cPages;
+        while (iPage-- > 0)
+            papPages[iPage] = pDummyPage;
+# ifdef VM_MAP
+        pv = vmap(papPages, cPages, VM_MAP, PAGE_KERNEL_RO);
+# else
+        pv = vmap(papPages, cPages, VM_ALLOC, PAGE_KERNEL_RO);
+# endif
+        RTMemFree(papPages);
+        if (pv)
+        {
+            PRTR0MEMOBJLNX pMemLnx = (PRTR0MEMOBJLNX)rtR0MemObjNew(sizeof(*pMemLnx), RTR0MEMOBJTYPE_RES_VIRT, pv, cb);
+            if (pMemLnx)
+            {
+                pMemLnx->Core.u.ResVirt.R0Process = NIL_RTR0PROCESS;
+                pMemLnx->cPages = 1;
+                pMemLnx->apPages[0] = pDummyPage;
+                *ppMem = &pMemLnx->Core;
+                return VINF_SUCCESS;
+            }
+            vunmap(pv);
+        }
+    }
+    __free_page(pDummyPage);
+    return VERR_NO_MEMORY;
+
+#else   /* < 2.4.22 */
+    /*
+     * Could probably use ioremap here, but the caller is in a better position than us
+     * to select some safe physical memory.
+     */
+    return VERR_NOT_SUPPORTED;
+#endif
+}
+
+
+/**
+ * Worker for rtR0MemObjNativeReserveUser and rtR0MemObjNativerMapUser that creates
+ * an empty user space mapping.
+ *
+ * The caller takes care of acquiring the mmap_sem of the task.
+ *
+ * @returns Pointer to the mapping.
+ *          (void *)-1 on failure.
+ * @param   R3PtrFixed  (RTR3PTR)-1 if anywhere, otherwise a specific location.
+ * @param   cb          The size of the mapping.
+ * @param   uAlignment  The alignment of the mapping.
+ * @param   pTask       The Linux task to create this mapping in.
+ * @param   fProt       The RTMEM_PROT_* mask.
+ */
+static void *rtR0MemObjLinuxDoMmap(RTR3PTR R3PtrFixed, size_t cb, size_t uAlignment, struct task_struct *pTask, unsigned fProt)
+{
+    unsigned fLnxProt;
+    unsigned long ulAddr;
+
+    /*
+     * Convert from IPRT protection to mman.h PROT_ and call do_mmap.
+     */
+    fProt &= (RTMEM_PROT_NONE | RTMEM_PROT_READ | RTMEM_PROT_WRITE | RTMEM_PROT_EXEC);
+    if (fProt == RTMEM_PROT_NONE)
+        fLnxProt = PROT_NONE;
+    else
+    {
+        fLnxProt = 0;
+        if (fProt & RTMEM_PROT_READ)
+            fLnxProt |= PROT_READ;
+        if (fProt & RTMEM_PROT_WRITE)
+            fLnxProt |= PROT_WRITE;
+        if (fProt & RTMEM_PROT_EXEC)
+            fLnxProt |= PROT_EXEC;
+    }
+
+    if (R3PtrFixed != (RTR3PTR)-1)
+        ulAddr = do_mmap(NULL, R3PtrFixed, cb, fLnxProt, MAP_SHARED | MAP_ANONYMOUS | MAP_FIXED, 0);
+    else
+    {
+        ulAddr = do_mmap(NULL, 0, cb, fLnxProt, MAP_SHARED | MAP_ANONYMOUS, 0);
+        if (    !(ulAddr & ~PAGE_MASK)
+            &&  (ulAddr & (uAlignment - 1)))
+        {
+            /** @todo implement uAlignment properly... We'll probably need to make some dummy mappings to fill
+             * up alignment gaps. This is of course complicated by fragmentation (which we might have cause
+             * ourselves) and further by there begin two mmap strategies (top / bottom). */
+            /* For now, just ignore uAlignment requirements... */
+        }
+    }
+    if (ulAddr & ~PAGE_MASK) /* ~PAGE_MASK == PAGE_OFFSET_MASK */
+        return (void *)-1;
+    return (void *)ulAddr;
+}
+
+
+int rtR0MemObjNativeReserveUser(PPRTR0MEMOBJINTERNAL ppMem, RTR3PTR R3PtrFixed, size_t cb, size_t uAlignment, RTR0PROCESS R0Process)
+{
+    PRTR0MEMOBJLNX      pMemLnx;
+    void               *pv;
+    struct task_struct *pTask = rtR0ProcessToLinuxTask(R0Process);
+    if (!pTask)
+        return VERR_NOT_SUPPORTED;
+
+    /*
+     * Let rtR0MemObjLinuxDoMmap do the difficult bits.
+     */
+    down_write(&pTask->mm->mmap_sem);
+    pv = rtR0MemObjLinuxDoMmap(R3PtrFixed, cb, uAlignment, pTask, RTMEM_PROT_NONE);
+    up_write(&pTask->mm->mmap_sem);
+    if (pv == (void *)-1)
+        return VERR_NO_MEMORY;
+
+    pMemLnx = (PRTR0MEMOBJLNX)rtR0MemObjNew(sizeof(*pMemLnx), RTR0MEMOBJTYPE_RES_VIRT, pv, cb);
+    if (!pMemLnx)
+    {
+        down_write(&pTask->mm->mmap_sem);
+        MY_DO_MUNMAP(pTask->mm, (unsigned long)pv, cb);
+        up_write(&pTask->mm->mmap_sem);
+        return VERR_NO_MEMORY;
+    }
+
+    pMemLnx->Core.u.ResVirt.R0Process = R0Process;
+    *ppMem = &pMemLnx->Core;
+    return VINF_SUCCESS;
+}
+
+
+int rtR0MemObjNativeMapKernel(PPRTR0MEMOBJINTERNAL ppMem, RTR0MEMOBJ pMemToMap, void *pvFixed, size_t uAlignment, unsigned fProt)
+{
+    int rc = VERR_NO_MEMORY;
+    PRTR0MEMOBJLNX pMemLnxToMap = (PRTR0MEMOBJLNX)pMemToMap;
+    PRTR0MEMOBJLNX pMemLnx;
+
+    /* Fail if requested to do something we can't. */
+    AssertMsgReturn(pvFixed == (void *)-1, ("%p\n", pvFixed), VERR_NOT_SUPPORTED);
+    AssertMsgReturn(uAlignment <= PAGE_SIZE, ("%#x\n", uAlignment), VERR_NOT_SUPPORTED);
+
+    /*
+     * Create the IPRT memory object.
+     */
+    pMemLnx = (PRTR0MEMOBJLNX)rtR0MemObjNew(sizeof(*pMemLnx), RTR0MEMOBJTYPE_MAPPING, NULL, pMemLnxToMap->Core.cb);
+    if (pMemLnx)
+    {
+        if (pMemLnxToMap->cPages)
+        {
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 4, 22)
+            /*
+             * Use vmap - 2.4.22 and later.
+             */
+            pgprot_t fPg = rtR0MemObjLinuxConvertProt(fProt, true /* kernel */);
+# ifdef VM_MAP
+            pMemLnx->Core.pv = vmap(&pMemLnxToMap->apPages[0], pMemLnxToMap->cPages, VM_MAP, fPg);
+# else
+            pMemLnx->Core.pv = vmap(&pMemLnxToMap->apPages[0], pMemLnxToMap->cPages, VM_ALLOC, fPg);
+# endif
+            if (pMemLnx->Core.pv)
+            {
+                pMemLnx->fMappedToRing0 = true;
+                rc = VINF_SUCCESS;
+            }
+            else
+                rc = VERR_MAP_FAILED;
+
+#else   /* < 2.4.22 */
+            /*
+             * Only option here is to share mappings if possible and forget about fProt.
+             */
+            if (rtR0MemObjIsRing3(pMemToMap))
+                rc = VERR_NOT_SUPPORTED;
+            else
+            {
+                rc = VINF_SUCCESS;
+                if (!pMemLnxToMap->Core.pv)
+                    rc = rtR0MemObjLinuxVMap(pMemLnxToMap, !!(fProt & RTMEM_PROT_EXEC));
+                if (RT_SUCCESS(rc))
+                {
+                    Assert(pMemLnxToMap->Core.pv);
+                    pMemLnx->Core.pv = pMemLnxToMap->Core.pv;
+                }
+            }
+#endif
+        }
+        else
+        {
+            /*
+             * MMIO / physical memory.
+             */
+            Assert(pMemLnxToMap->Core.enmType == RTR0MEMOBJTYPE_PHYS && !pMemLnxToMap->Core.u.Phys.fAllocated);
+            pMemLnx->Core.pv = ioremap(pMemLnxToMap->Core.u.Phys.PhysBase, pMemLnxToMap->Core.cb);
+            if (pMemLnx->Core.pv)
+            {
+                /** @todo fix protection. */
+                rc = VINF_SUCCESS;
+            }
+        }
+        if (RT_SUCCESS(rc))
+        {
+            pMemLnx->Core.u.Mapping.R0Process = NIL_RTR0PROCESS;
+            *ppMem = &pMemLnx->Core;
+            return VINF_SUCCESS;
+        }
+        rtR0MemObjDelete(&pMemLnx->Core);
+    }
+
+    return rc;
+}
+
+
+int rtR0MemObjNativeMapUser(PPRTR0MEMOBJINTERNAL ppMem, RTR0MEMOBJ pMemToMap, RTR3PTR R3PtrFixed, size_t uAlignment, unsigned fProt, RTR0PROCESS R0Process)
+{
+    struct task_struct *pTask        = rtR0ProcessToLinuxTask(R0Process);
+    PRTR0MEMOBJLNX      pMemLnxToMap = (PRTR0MEMOBJLNX)pMemToMap;
+    int                 rc           = VERR_NO_MEMORY;
+    PRTR0MEMOBJLNX      pMemLnx;
+
+    /*
+     * Check for restrictions.
+     */
+    if (!pTask)
+        return VERR_NOT_SUPPORTED;
+
+    /*
+     * Create the IPRT memory object.
+     */
+    pMemLnx = (PRTR0MEMOBJLNX)rtR0MemObjNew(sizeof(*pMemLnx), RTR0MEMOBJTYPE_MAPPING, NULL, pMemLnxToMap->Core.cb);
+    if (pMemLnx)
+    {
+        /*
+         * Allocate user space mapping.
+         */
+        void *pv;
+        down_write(&pTask->mm->mmap_sem);
+        pv = rtR0MemObjLinuxDoMmap(R3PtrFixed, pMemLnxToMap->Core.cb, uAlignment, pTask, fProt);
+        if (pv != (void *)-1)
+        {
+            /*
+             * Map page by page into the mmap area.
+             * This is generic, paranoid and not very efficient.
+             */
+            pgprot_t        fPg = rtR0MemObjLinuxConvertProt(fProt, false /* user */);
+            unsigned long   ulAddrCur = (unsigned long)pv;
+            const size_t    cPages = pMemLnxToMap->Core.cb >> PAGE_SHIFT;
+            size_t          iPage;
+            rc = 0;
+            if (pMemLnxToMap->cPages)
+            {
+                for (iPage = 0; iPage < cPages; iPage++, ulAddrCur += PAGE_SIZE)
+                {
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0) || defined(HAVE_26_STYLE_REMAP_PAGE_RANGE)
+                    struct vm_area_struct *vma = find_vma(pTask->mm, ulAddrCur); /* this is probably the same for all the pages... */
+                    AssertBreak(vma, rc = VERR_INTERNAL_ERROR);
+#endif
+
+#if   LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 11)
+                    rc = remap_pfn_range(vma, ulAddrCur, page_to_pfn(pMemLnxToMap->apPages[iPage]), PAGE_SIZE, fPg);
+#elif LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0) || defined(HAVE_26_STYLE_REMAP_PAGE_RANGE)
+                    rc = remap_page_range(vma, ulAddrCur, page_to_phys(pMemLnxToMap->apPages[iPage]), PAGE_SIZE, fPg);
+#else /* 2.4 */
+                    rc = remap_page_range(ulAddrCur, page_to_phys(pMemLnxToMap->apPages[iPage]), PAGE_SIZE, fPg);
+#endif
+                    if (rc)
+                        break;
+                }
+            }
+            else
+            {
+                RTHCPHYS Phys;
+                if (pMemLnxToMap->Core.enmType == RTR0MEMOBJTYPE_PHYS)
+                    Phys = pMemLnxToMap->Core.u.Phys.PhysBase;
+                else if (pMemLnxToMap->Core.enmType == RTR0MEMOBJTYPE_CONT)
+                    Phys = pMemLnxToMap->Core.u.Cont.Phys;
+                else
+                {
+                    AssertMsgFailed(("%d\n", pMemLnxToMap->Core.enmType));
+                    Phys = NIL_RTHCPHYS;
+                }
+                if (Phys != NIL_RTHCPHYS)
+                {
+                    for (iPage = 0; iPage < cPages; iPage++, ulAddrCur += PAGE_SIZE, Phys += PAGE_SIZE)
+                    {
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0) || defined(HAVE_26_STYLE_REMAP_PAGE_RANGE)
+                        struct vm_area_struct *vma = find_vma(pTask->mm, ulAddrCur); /* this is probably the same for all the pages... */
+                        AssertBreak(vma, rc = VERR_INTERNAL_ERROR);
+#endif
+
+#if   LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 11)
+                        rc = remap_pfn_range(vma, ulAddrCur, Phys, PAGE_SIZE, fPg);
+#elif LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0) || defined(HAVE_26_STYLE_REMAP_PAGE_RANGE)
+                        rc = remap_page_range(vma, ulAddrCur, Phys, PAGE_SIZE, fPg);
+#else /* 2.4 */
+                        rc = remap_page_range(ulAddrCur, Phys, PAGE_SIZE, fPg);
+#endif
+                        if (rc)
+                            break;
+                    }
+                }
+            }
+            if (!rc)
+            {
+                up_write(&pTask->mm->mmap_sem);
+
+                pMemLnx->Core.pv = pv;
+                pMemLnx->Core.u.Mapping.R0Process = R0Process;
+                *ppMem = &pMemLnx->Core;
+                return VINF_SUCCESS;
+            }
+
+            /*
+             * Bail out.
+             */
+            MY_DO_MUNMAP(pTask->mm, (unsigned long)pv, pMemLnxToMap->Core.cb);
+            if (rc != VERR_INTERNAL_ERROR)
+                rc = VERR_NO_MEMORY;
+        }
+
+        up_write(&pTask->mm->mmap_sem);
+
+        rtR0MemObjDelete(&pMemLnx->Core);
+    }
+
+    return rc;
+}
+
+
+RTHCPHYS rtR0MemObjNativeGetPagePhysAddr(PRTR0MEMOBJINTERNAL pMem, size_t iPage)
+{
+    PRTR0MEMOBJLNX  pMemLnx = (PRTR0MEMOBJLNX)pMem;
+
+    if (pMemLnx->cPages)
+        return page_to_phys(pMemLnx->apPages[iPage]);
+
+    switch (pMemLnx->Core.enmType)
+    {
         case RTR0MEMOBJTYPE_CONT:
-            IOFreeContiguous(pMemDarwin->Core.pv, pMemDarwin->Core.cb);
-            break;
-
+            return pMemLnx->Core.u.Cont.Phys     + (iPage << PAGE_SHIFT);
+
+        case RTR0MEMOBJTYPE_PHYS:
+            return pMemLnx->Core.u.Phys.PhysBase + (iPage << PAGE_SHIFT);
+
+            /* the parent knows */
+        case RTR0MEMOBJTYPE_MAPPING:
+            return rtR0MemObjNativeGetPagePhysAddr(pMemLnx->Core.uRel.Child.pParent, iPage);
+
+            /* cPages > 0 */
+        case RTR0MEMOBJTYPE_LOW:
         case RTR0MEMOBJTYPE_LOCK:
-        {
-#ifdef USE_VM_MAP_WIRE
-            vm_map_t Map = pMemDarwin->Core.u.Lock.R0Process != NIL_RTR0PROCESS
-                         ? get_task_map((task_t)pMemDarwin->Core.u.Lock.R0Process)
-                         : kernel_map;
-            kern_return_t kr = vm_map_unwire(Map,
-                                             (vm_map_offset_t)pMemDarwin->Core.pv,
-                                             (vm_map_offset_t)pMemDarwin->Core.pv + pMemDarwin->Core.cb,
-                                             0 /* not user */);
-            AssertRC(kr == KERN_SUCCESS); /** @todo don't ignore... */
-#endif
-            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_PHYS_NC:
+        case RTR0MEMOBJTYPE_PAGE:
+        default:
+            AssertMsgFailed(("%d\n", pMemLnx->Core.enmType));
+            /* fall thru */
 
         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)
-{
-#if 1
-    /* 
-     * Allocating 128KB for the low page pool can bit a bit exhausting on the kernel,
-     * it frequnetly causes the entire box to lock up on startup.
-     *
-     * So, try allocate the memory using IOMallocAligned first and if we get any high 
-     * physical memory we'll release it and fall back on IOMAllocContiguous.
-     */
-    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)
-        {
-            /*
-             * Check if it's all below 4GB.
-             */
-            for (IOByteCount off = 0; off < cb; off += PAGE_SIZE)
-            {
-                addr64_t Addr = pMemDesc->getPhysicalSegment64(off, NULL);
-                if (Addr > (uint32_t)(_4G - PAGE_SIZE))
-                {
-                    /* Ok, we failed, fall back on contiguous allocation. */
-                    pMemDesc->release();
-                    IOFreeAligned(pv, cb);
-                    return rtR0MemObjNativeAllocCont(ppMem, cb, fExecutable);
-                }
-            }
-
-            /*
-             * Create the IPRT memory object.
-             */
-            PRTR0MEMOBJDARWIN pMemDarwin = (PRTR0MEMOBJDARWIN)rtR0MemObjNew(sizeof(*pMemDarwin), RTR0MEMOBJTYPE_LOW, 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;
-
-#else
-
-    /*
-     * IOMallocContiguous is the most suitable API.
-     */
-    return rtR0MemObjNativeAllocCont(ppMem, cb, fExecutable);
-#endif 
-}
-
-
-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 IOMallocContiguous 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;
-}
-
-
-/**
- * Internal worker for locking down pages.
- *
- * @return IPRT status code.
- *
- * @param ppMem     Where to store the memory object pointer.
- * @param pv        First page.
- * @param cb        Number of bytes.
- * @param Task      The task \a pv and \a cb refers to.
- */
-static int rtR0MemObjNativeLock(PPRTR0MEMOBJINTERNAL ppMem, void *pv, size_t cb, task_t Task)
-{
-#ifdef USE_VM_MAP_WIRE
-    vm_map_t Map = get_task_map(Task);
-    Assert(Map);
-
-    /*
-     * First try lock the memory.
-     */
-    int rc = VERR_LOCK_FAILED;
-    kern_return_t kr = vm_map_wire(get_task_map(Task),
-                                   (vm_map_offset_t)pv,
-                                   (vm_map_offset_t)pv + cb,
-                                   VM_PROT_DEFAULT,
-                                   0 /* not user */);
-    if (kr == KERN_SUCCESS)
-    {
-        /*
-         * Create the IPRT memory object.
-         */
-        PRTR0MEMOBJDARWIN pMemDarwin = (PRTR0MEMOBJDARWIN)rtR0MemObjNew(sizeof(*pMemDarwin), RTR0MEMOBJTYPE_LOCK, pv, cb);
-        if (pMemDarwin)
-        {
-            pMemDarwin->Core.u.Lock.R0Process = (RTR0PROCESS)Task;
-            *ppMem = &pMemDarwin->Core;
-            return VINF_SUCCESS;
-        }
-
-        kr = vm_map_unwire(get_task_map(Task), (vm_map_offset_t)pv, (vm_map_offset_t)pv + cb, 0 /* not user */);
-        Assert(kr == KERN_SUCCESS);
-        rc = VERR_NO_MEMORY;
-    }
-
-#else
-
-    /*
-     * Create a descriptor and try lock it (prepare).
-     */
-    int rc = VERR_MEMOBJ_INIT_FAILED;
-    IOMemoryDescriptor *pMemDesc = IOMemoryDescriptor::withAddress((vm_address_t)pv, cb, kIODirectionInOut, Task);
-    if (pMemDesc)
-    {
-        IOReturn IORet = pMemDesc->prepare(kIODirectionInOut);
-        if (IORet == kIOReturnSuccess)
-        {
-            /*
-             * Create the IPRT memory object.
-             */
-            PRTR0MEMOBJDARWIN pMemDarwin = (PRTR0MEMOBJDARWIN)rtR0MemObjNew(sizeof(*pMemDarwin), RTR0MEMOBJTYPE_LOCK, pv, cb);
-            if (pMemDarwin)
-            {
-                pMemDarwin->Core.u.Lock.R0Process = (RTR0PROCESS)Task;
-                pMemDarwin->pMemDesc = pMemDesc;
-                *ppMem = &pMemDarwin->Core;
-                return VINF_SUCCESS;
-            }
-
-            pMemDesc->complete();
-            rc = VERR_NO_MEMORY;
-        }
-        else
-            rc = VERR_LOCK_FAILED;
-        pMemDesc->release();
-    }
-#endif
-    return rc;
-}
-
-
-int rtR0MemObjNativeLockUser(PPRTR0MEMOBJINTERNAL ppMem, void *pv, size_t cb, RTR0PROCESS R0Process)
-{
-    return rtR0MemObjNativeLock(ppMem, pv, cb, (task_t)R0Process);
-}
-
-
-int rtR0MemObjNativeLockKernel(PPRTR0MEMOBJINTERNAL ppMem, void *pv, size_t cb)
-{
-    return rtR0MemObjNativeLock(ppMem, pv, cb, kernel_task);
-}
-
-
-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, RTR0PROCESS R0Process)
-{
-    return VERR_NOT_IMPLEMENTED;
-}
-
-
-int rtR0MemObjNativeMapKernel(PPRTR0MEMOBJINTERNAL ppMem, RTR0MEMOBJ pMemToMap, void *pvFixed, size_t uAlignment, unsigned fProt)
-{
-    /*
-     * Must have a memory descriptor.
-     */
-    int rc = VERR_INVALID_PARAMETER;
-    PRTR0MEMOBJDARWIN pMemToMapDarwin = (PRTR0MEMOBJDARWIN)pMemToMap;
-    if (pMemToMapDarwin->pMemDesc)
-    {
-        IOMemoryMap *pMemMap = pMemToMapDarwin->pMemDesc->map(kernel_task, kIOMapAnywhere,
-                                                              kIOMapAnywhere | kIOMapDefaultCache);
-        if (pMemMap)
-        {
-            IOVirtualAddress VirtAddr = pMemMap->getVirtualAddress();
-            void *pv = (void *)(uintptr_t)VirtAddr;
-            if ((uintptr_t)pv == VirtAddr)
-            {
-                /*
-                 * Create the IPRT memory object.
-                 */
-                PRTR0MEMOBJDARWIN pMemDarwin = (PRTR0MEMOBJDARWIN)rtR0MemObjNew(sizeof(*pMemDarwin), RTR0MEMOBJTYPE_MAPPING,
-                                                                                pv, pMemToMapDarwin->Core.cb);
-                if (pMemDarwin)
-                {
-                    pMemDarwin->Core.u.Mapping.R0Process = NIL_RTR0PROCESS;
-                    pMemDarwin->pMemMap = pMemMap;
-                    *ppMem = &pMemDarwin->Core;
-                    return VINF_SUCCESS;
-                }
-
-                rc = VERR_NO_MEMORY;
-            }
-            else
-                rc = VERR_ADDRESS_TOO_BIG;
-            pMemMap->release();
-        }
-        else
-            rc = VERR_MAP_FAILED;
-    }
-    return rc;
-}
-
-
-int rtR0MemObjNativeMapUser(PPRTR0MEMOBJINTERNAL ppMem, RTR0MEMOBJ pMemToMap, void *pvFixed, size_t uAlignment, unsigned fProt, RTR0PROCESS R0Process)
-{
-    /*
-     * Must have a memory descriptor.
-     */
-    int rc = VERR_INVALID_PARAMETER;
-    PRTR0MEMOBJDARWIN pMemToMapDarwin = (PRTR0MEMOBJDARWIN)pMemToMap;
-    if (pMemToMapDarwin->pMemDesc)
-    {
-        IOMemoryMap *pMemMap = pMemToMapDarwin->pMemDesc->map((task_t)R0Process, kIOMapAnywhere,
-                                                              kIOMapAnywhere | kIOMapDefaultCache);
-        if (pMemMap)
-        {
-            IOVirtualAddress VirtAddr = pMemMap->getVirtualAddress();
-            void *pv = (void *)(uintptr_t)VirtAddr;
-            if ((uintptr_t)pv == VirtAddr)
-            {
-                /*
-                 * Create the IPRT memory object.
-                 */
-                PRTR0MEMOBJDARWIN pMemDarwin = (PRTR0MEMOBJDARWIN)rtR0MemObjNew(sizeof(*pMemDarwin), RTR0MEMOBJTYPE_MAPPING,
-                                                                                pv, pMemToMapDarwin->Core.cb);
-                if (pMemDarwin)
-                {
-                    pMemDarwin->Core.u.Mapping.R0Process = R0Process;
-                    pMemDarwin->pMemMap = pMemMap;
-                    *ppMem = &pMemDarwin->Core;
-                    return VINF_SUCCESS;
-                }
-
-                rc = VERR_NO_MEMORY;
-            }
-            else
-                rc = VERR_ADDRESS_TOO_BIG;
-            pMemMap->release();
-        }
-        else
-            rc = VERR_MAP_FAILED;
-    }
-    return rc;
-}
-
-
-RTHCPHYS rtR0MemObjNativeGetPagePhysAddr(PRTR0MEMOBJINTERNAL pMem, unsigned iPage)
-{
-    RTHCPHYS            PhysAddr;
-    PRTR0MEMOBJDARWIN   pMemDarwin = (PRTR0MEMOBJDARWIN)pMem;
-
-#ifdef USE_VM_MAP_WIRE
-    /*
-     * Locked memory doesn't have a memory descriptor and
-     * needs to be handled differently.
-     */
-    if (pMemDarwin->Core.enmType == RTR0MEMOBJTYPE_LOCK)
-    {
-        ppnum_t PgNo;
-        if (pMemDarwin->Core.u.Lock.R0Process == NIL_RTR0PROCESS)
-            PgNo = pmap_find_phys(kernel_pmap, (uintptr_t)pMemDarwin->Core.pv + iPage * PAGE_SIZE);
-        else
-        {
-            /*
-             * From what I can tell, Apple seems to have locked up the all the
-             * available interfaces that could help us obtain the pmap_t of a task
-             * or vm_map_t.
-
-             * So, we'll have to figure out where in the vm_map_t  structure it is
-             * and read it our selves. ASSUMING that kernel_pmap is pointed to by
-             * kernel_map->pmap, we scan kernel_map to locate the structure offset.
-             * Not nice, but it will hopefully do the job in a reliable manner...
-             *
-             * (get_task_pmap, get_map_pmap or vm_map_pmap is what we really need btw.)
-             */
-            static int s_offPmap = -1;
-            if (RT_UNLIKELY(s_offPmap == -1))
-            {
-                pmap_t const *p = (pmap_t *)kernel_map;
-                pmap_t const * const pEnd = p + 64;
-                for (; p < pEnd; p++)
-                    if (*p == kernel_pmap)
-                    {
-                        s_offPmap = (uintptr_t)p - (uintptr_t)kernel_map;
-                        break;
-                    }
-                AssertReturn(s_offPmap >= 0, NIL_RTHCPHYS);
-            }
-            pmap_t Pmap = *(pmap_t *)((uintptr_t)get_task_map((task_t)pMemDarwin->Core.u.Lock.R0Process) + s_offPmap);
-            PgNo = pmap_find_phys(Pmap, (uintptr_t)pMemDarwin->Core.pv + iPage * PAGE_SIZE);
-        }
-
-        AssertReturn(PgNo, NIL_RTHCPHYS);
-        PhysAddr = (RTHCPHYS)PgNo << PAGE_SHIFT;
-        Assert((PhysAddr >> PAGE_SHIFT) == PgNo);
-    }
-    else
-#endif /* USE_VM_MAP_WIRE */
-    {
-        /*
-         * Get the memory descriptor.
-         */
-        IOMemoryDescriptor *pMemDesc = pMemDarwin->pMemDesc;
-        if (!pMemDesc)
-            pMemDesc = pMemDarwin->pMemMap->getMemoryDescriptor();
-        AssertReturn(pMemDesc, NIL_RTHCPHYS);
-
-        /*
-         * If we've got a memory descriptor, use getPhysicalSegment64().
-         */
-        addr64_t Addr = pMemDesc->getPhysicalSegment64(iPage * PAGE_SIZE, NULL);
-        AssertMsgReturn(Addr, ("iPage=%u\n", iPage), NIL_RTHCPHYS);
-        PhysAddr = Addr;
-        AssertMsgReturn(PhysAddr == Addr, ("PhysAddr=%VHp Addr=%RX64\n", PhysAddr, (uint64_t)Addr), NIL_RTHCPHYS);
-    }
-
-    return PhysAddr;
-}
-
+            return NIL_RTHCPHYS;
+    }
+}
+

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

@@ -146 +146 @@
 
 /*
- * This sucks soooo badly! Why don't they export __PAGE_KERNEL_EXEC so PAGE_KERNEL_EXEC would be usable?
- */
-#if defined(PAGE_KERNEL_EXEC) && defined(CONFIG_X86_PAE)
-# define MY_PAGE_KERNEL_EXEC __pgprot(cpu_has_pge ? _PAGE_KERNEL_EXEC | _PAGE_GLOBAL : _PAGE_KERNEL_EXEC)
+ * This sucks soooo badly on x86! Why don't they export __PAGE_KERNEL_EXEC so PAGE_KERNEL_EXEC would be usable?
+ */
+#if defined(RT_ARCH_AMD64)
+# define MY_PAGE_KERNEL_EXEC    PAGE_KERNEL_EXEC
+#elif defined(PAGE_KERNEL_EXEC) && defined(CONFIG_X86_PAE)
+# define MY_PAGE_KERNEL_EXEC    __pgprot(cpu_has_pge ? _PAGE_KERNEL_EXEC | _PAGE_GLOBAL : _PAGE_KERNEL_EXEC)
 #else
-# define MY_PAGE_KERNEL_EXEC PAGE_KERNEL
+# define MY_PAGE_KERNEL_EXEC    PAGE_KERNEL
 #endif
 

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

@@ -168 +168 @@
  *
  * @returns The address of the memory object.
- * @returns NULL if the handle is invalid or if it's not an object with a ring-3 mapping.
+ * @returns NIL_RTR3PTR if the handle is invalid or if it's not an object with a ring-3 mapping.
  *          Strict builds will assert in both cases.
  * @param   MemObj  The ring-0 memory object handle.
@@ -437 +437 @@
  * @returns IPRT status code.
  * @param   pMemObj         Where to store the ring-0 memory object handle.
- * @param   pv              User virtual address. This is rounded down to a page boundrary.
+ * @param   R3Ptr           User virtual address. This is rounded down to a page boundrary.
  * @param   cb              Number of bytes to lock. This is rounded up to nearest page boundrary.
  * @param   R0Process       The process to lock pages in. NIL_R0PROCESS is an alias for the current one.
@@ -443 +443 @@
  * @remark  RTR0MemGetAddressR3() and RTR0MemGetAddress() will return the rounded down address.
  */
-RTR0DECL(int) RTR0MemObjLockUser(PRTR0MEMOBJ pMemObj, void *pv, size_t cb, RTR0PROCESS R0Process)
-{
-    /* sanity checks. */
-    AssertPtrReturn(pMemObj, VERR_INVALID_POINTER);
-    *pMemObj = NIL_RTR0MEMOBJ;
-    AssertReturn(cb > 0, VERR_INVALID_PARAMETER);
-    const size_t cbAligned = RT_ALIGN_Z(cb + ((uintptr_t)pv & PAGE_OFFSET_MASK), PAGE_SIZE);
-    AssertReturn(cb <= cbAligned, VERR_INVALID_PARAMETER);
-    void * const pvAligned = (void *)((uintptr_t)pv & ~(uintptr_t)PAGE_OFFSET_MASK);
+RTR0DECL(int) RTR0MemObjLockUser(PRTR0MEMOBJ pMemObj, RTR3PTR R3Ptr, size_t cb, RTR0PROCESS R0Process)
+{
+    /* sanity checks. */
+    AssertPtrReturn(pMemObj, VERR_INVALID_POINTER);
+    *pMemObj = NIL_RTR0MEMOBJ;
+    AssertReturn(cb > 0, VERR_INVALID_PARAMETER);
+    const size_t cbAligned = RT_ALIGN_Z(cb + (R3Ptr & PAGE_OFFSET_MASK), PAGE_SIZE);
+    AssertReturn(cb <= cbAligned, VERR_INVALID_PARAMETER);
+    RTR3PTR const R3PtrAligned = (R3Ptr & ~(RTR3PTR)PAGE_OFFSET_MASK);
     if (R0Process == NIL_RTR0PROCESS)
         R0Process = RTR0ProcHandleSelf();
 
     /* do the allocation. */
-    return rtR0MemObjNativeLockUser(pMemObj, pvAligned, cbAligned, R0Process);
+    return rtR0MemObjNativeLockUser(pMemObj, R3PtrAligned, cbAligned, R0Process);
 }
 

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

@@ -242 +242 @@
 
 
-int rtR0MemObjNativeLockUser(PPRTR0MEMOBJINTERNAL ppMem, void *pv, size_t cb, RTR0PROCESS R0Process)
+int rtR0MemObjNativeLockUser(PPRTR0MEMOBJINTERNAL ppMem, RTR3PTR R3Ptr, size_t cb, RTR0PROCESS R0Process)
 {
     AssertMsgReturn(R0Process == RTR0ProcHandleSelf(), ("%p != %p\n", R0Process, RTR0ProcHandleSelf()), VERR_NOT_SUPPORTED);
@@ -248 +248 @@
     /* create the object. */
     const ULONG cPages = cb >> PAGE_SHIFT;
-    PRTR0MEMOBJOS2 pMemOs2 = (PRTR0MEMOBJOS2)rtR0MemObjNew(RT_OFFSETOF(RTR0MEMOBJOS2, aPages[cPages]), RTR0MEMOBJTYPE_LOCK, pv, cb);
+    PRTR0MEMOBJOS2 pMemOs2 = (PRTR0MEMOBJOS2)rtR0MemObjNew(RT_OFFSETOF(RTR0MEMOBJOS2, aPages[cPages]), RTR0MEMOBJTYPE_LOCK, (void *)R3Ptr, cb);
     if (!pMemOs2)
         return VERR_NO_MEMORY;
@@ -254 +254 @@
     /* lock it. */
     ULONG cPagesRet = cPages;
-    int rc = KernVMLock(VMDHL_LONG | VMDHL_WRITE, pv, cb, &pMemOs2->Lock, &pMemOs2->aPages[0], &cPagesRet);
+    int rc = KernVMLock(VMDHL_LONG | VMDHL_WRITE, (void *)R3Ptr, cb, &pMemOs2->Lock, &pMemOs2->aPages[0], &cPagesRet);
     if (!rc)
     {
         rtR0MemObjFixPageList(&pMemOs2->aPages[0], cPages, cPagesRet);
         Assert(cb == pMemOs2->Core.cb);
-        Assert(pv == pMemOs2->Core.pv);
+        Assert(R3Ptr == (RTR3PTR)pMemOs2->Core.pv);
         pMemOs2->Core.u.Lock.R0Process = R0Process;
         *ppMem = &pMemOs2->Core;