Changeset 4155

Timestamp:

08/15/07 21:41:26 (1 year ago)

Author:

vboxsync

Message:

RTR0MemGetAddressR3 & RTR0MemObjLockUser. Linux memobj impl.

Files:

• trunk/include/iprt/memobj.h (modified) (3 diffs)
• trunk/src/VBox/Additions/common/VBoxGuestLib/SysHlp.cpp (modified) (10 diffs)
• trunk/src/VBox/Runtime/Makefile.kmk (modified) (1 diff)
• trunk/src/VBox/Runtime/include/internal/memobj.h (modified) (2 diffs)
• trunk/src/VBox/Runtime/r0drv/darwin/memobj-r0drv-darwin.cpp (modified) (1 diff)
• trunk/src/VBox/Runtime/r0drv/freebsd/memobj-r0drv-freebsd.c (modified) (2 diffs)
• trunk/src/VBox/Runtime/r0drv/linux/memobj-r0drv-linux.c (copied) (copied from trunk/src/VBox/Runtime/r0drv/darwin/memobj-r0drv-darwin.cpp) (4 diffs)
• trunk/src/VBox/Runtime/r0drv/linux/the-linux-kernel.h (modified) (1 diff)
• trunk/src/VBox/Runtime/r0drv/memobj-r0drv.cpp (modified) (3 diffs)
• trunk/src/VBox/Runtime/r0drv/os2/memobj-r0drv-os2.cpp (modified) (3 diffs)

trunk/include/iprt/memobj.h

@@ -48 +48 @@
-
-/**
+ * Gets the ring-3 address of a ring-0 memory object.
+ *
+ * This only applies to ring-0 memory object with ring-3 mappings of some kind, i.e.
+ * locked user memory, reserved user address space and user mappings. This API should
+ * not be used on any other objects.
+ *
+ * @returns The address of the memory object.
+ * @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.
+ */
+RTR0DECL(RTR3PTR) RTR0MemObjAddressR3(RTR0MEMOBJ MemObj);
+
+/**
- * Gets the size of a ring-0 memory object.
- *
@@ -119 +133 @@
- * @returns IPRT status code.
- * @param   pMemObj         Where to store the ring-0 memory object handle.
-pv   
+R3Ptr
- * @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.
@@ -125 +139 @@
- * @remark  RTR0MemGetAddressR3() and RTR0MemGetAddress() will return the rounded down address.
- */
-void *pv
+RTR3PTR R3Ptr
-
-/**

trunk/src/VBox/Additions/common/VBoxGuestLib/SysHlp.cpp

@@ -25 +25 @@
-#if !defined(RT_OS_WINDOWS) && !defined(RT_OS_LINUX)
-#include <iprt/memobj.h>
- 
+
-
-
@@ -31 +31 @@
-{
-    int rc = VINF_SUCCESS;
-
+
-#ifdef RT_OS_WINDOWS
-    PMDL pMdl = IoAllocateMdl (pv, u32Size, FALSE, FALSE, NULL);
@@ -47 +47 @@
-                                 KernelMode,
-                                 (fWriteAccess) ? IoModifyAccess : IoReadAccess);
-
+
-            *ppvCtx = pMdl;
-
@@ -66 +66 @@
-    /* Default to IPRT - this ASSUMES that it is USER addresses we're locking. */
-    RTR0MEMOBJ MemObj;
-
+(RTR3PTR)
-    if (RT_SUCCESS(rc))
-        *ppvCtx = MemObj;
@@ -73 +73 @@
-
-#endif
-
+
-    return rc;
-}
@@ -123 +123 @@
-#ifdef RT_OS_OS2
-__BEGIN_DECLS
- 
- 
+
+
- * client driver, exporting a g_VBoxGuestIDC symbol containing
- * the connection information obtained from the 16-bit IDC.
@@ -130 +130 @@
-extern VBOXGUESTOS2IDCCONNECT g_VBoxGuestIDC;
-__END_DECLS
- 
+
-
-
@@ -168 +168 @@
-
-#elif defined (RT_OS_OS2)
- 
+
-     * Just check whether the connection was made or not.
-     */
@@ -221 +221 @@
-                                   NULL);
-
-                     
-    
+
+
-
-    if (!NT_SUCCESS(rc))
@@ -233 +233 @@
-
-#elif defined (RT_OS_OS2)
- 
+
-        &&  pDriver->u32Session == g_VBoxGuestIDC.u32Session)
-        return g_VBoxGuestIDC.pfnServiceEP(pDriver->u32Session, u32Function, pvData, cbData, NULL);

trunk/src/VBox/Runtime/Makefile.kmk

@@ -755 +755 @@
-        generic/RTAssertDoBreakpoint-generic.cpp \
-        alloc/heapsimple.cpp \
+        r0drv/memobj-r0drv.cpp \
-        r0drv/linux/alloc-r0drv-linux.c \
-        r0drv/linux/initterm-r0drv-linux.c \
+        r0drv/linux/memobj-r0drv-linux.c \
-        r0drv/linux/process-r0drv-linux.c \
-        r0drv/linux/RTLogWriteDebugger-r0drv-linux.c \

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

@@ -218 +218 @@
-
-/**
+ * Checks if RTR0MEMOBJ::pv is a ring-3 pointer or not.
+ *
+ * @returns true if it's a object with a ring-3 address, otherwise false.
+ * @param   MemObj  The ring-0 memory object handle.
+ */
+DECLINLINE(bool) rtR0MemObjIsRing3(PRTR0MEMOBJINTERNAL pMem)
+{
+    switch (pMem->enmType)
+    {
+        case RTR0MEMOBJTYPE_RES_VIRT:
+            return pMem->u.ResVirt.R0Process != NIL_RTR0PROCESS;
+        case RTR0MEMOBJTYPE_LOCK:
+            return pMem->u.Lock.R0Process    != NIL_RTR0PROCESS;
+        case RTR0MEMOBJTYPE_MAPPING:
+            return pMem->u.Mapping.R0Process != NIL_RTR0PROCESS;
+        default:
+            return false;
+    }
+}
+
+
+/**
- * Frees the memory object (but not the handle).
- * Any OS specific handle resources will be freed by this call.
@@ -267 +289 @@
- * @returns IPRT status code.
- * @param   ppMem           Where to store the ring-0 memory object handle.
-pv   
+R3Ptr
- * @param   cb              Number of bytes to lock, page aligned.
- * @param   R0Process       The process to lock pages in.
- */
-void *pv
+RTR3PTR R3Ptr
-
-/**

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

@@ -484 +484 @@
-
-
-void *pv
-
-pv
+RTR3PTR R3Ptr
+
+(void *)R3Ptr
-}
-

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

@@ -330 +330 @@
-
-
-void *pv
+RTR3PTR R3Ptr
-{
-    int rc;
-
-    /* create the object. */
-pv
+(void *)R3Ptr
-    if (!pMemFreeBSD)
-        return VERR_NO_MEMORY;
@@ -344 +344 @@
-     */
-    rc = vm_map_wire(&((struct proc *)R0Process)->p_vmspace->vm_map, /* the map */
-pv,   
-pv + cb,   
+R3Ptr,
+R3Ptr + cb,
-                     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
-Darwin
+Linux
- */
-
@@ -20 +20 @@
-*   Header Files                                                               *
-*******************************************************************************/
-darwin
+linux
-
-#include <iprt/memobj.h>
@@ -26 +26 @@
-#include <iprt/assert.h>
-#include <iprt/log.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.
- */
-DARWIN
+LNX
-{
-    /** The core structure. */
-    RTR0MEMOBJINTERNAL  Core;
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-
-int rtR0MemObjNativeFree(RTR0MEMOBJ pMem)
-{
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
-
-    /*
-     * Release any memory that we've allocated or locked.
-     */
-Darwin
+Lnx
-    {
-        case RTR0MEMOBJTYPE_LOW:
-        case RTR0MEMOBJTYPE_PAGE:
-
+
+
+
+
-            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
+&n