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

Timestamp:

Aug 18, 2007 11:42:23 PM (17 years ago)

Author:

vboxsync

Message:

RTR0MemObj for NT (untested).

Location:

trunk/src/VBox/Runtime

Files:

• Makefile.kmk (modified) (2 diffs)
• r0drv/nt/memobj-r0drv-nt.cpp (modified) (26 diffs)
• r0drv/nt/the-nt-kernel.h (modified) (1 diff)

trunk/src/VBox/Runtime/Makefile.kmk

@@ -768 +768 @@
         generic/RTAssertDoBreakpoint-generic.cpp \
         nt/RTErrConvertFromNtStatus.cpp \
+        r0drv/memobj-r0drv.cpp \
         r0drv/nt/alloc-r0drv-nt.cpp \
         r0drv/nt/initterm-r0drv-nt.cpp \
+        r0drv/nt/memobj-r0drv-nt.cpp \
         r0drv/nt/process-r0drv-nt.cpp \
         r0drv/nt/RTLogWriteDebugger-r0drv-nt.cpp \
@@ -776 +778 @@
         r0drv/nt/thread-r0drv-nt.cpp \
         string/strncmp.cpp
-
-#RuntimeR0Drv_SOURCES.win += \
-#       r0drv/memobj-r0drv.cpp \
-#       r0drv/nt/memobj-r0drv-nt.cpp
 
 RuntimeR0Drv_SOURCES.win.amd64 = \

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

@@ -62 +62 @@
 #endif
     /** The number of PMDLs (memory descriptor lists) in the array. */
-    unsigned            cMdls;
+    uint32_t            cMdls;
     /** Array of MDL pointers. (variable size) */
     PMDL                apMdls[1];
@@ -78 +78 @@
     {
         case RTR0MEMOBJTYPE_LOW:
-#ifdef IPRT_TARGET_NT4
+#ifndef IPRT_TARGET_NT4
             if (pMemNt->fAllocatedPagesForMdl)
             {
@@ -91 +91 @@
             }
 #endif
-            /* fall thru */
+            AssertFailed();
+            break;
+
         case RTR0MEMOBJTYPE_PAGE:
             Assert(pMemNt->Core.pv);
@@ -116 +118 @@
         case RTR0MEMOBJTYPE_PHYS:
         case RTR0MEMOBJTYPE_PHYS_NC:
-#ifdef IPRT_TARGET_NT4
+#ifndef IPRT_TARGET_NT4
             if (pMemNt->fAllocatedPagesForMdl)
             {
@@ -122 +124 @@
                 pMemNt->apMdls[0] = NULL;
                 pMemNt->cMdls = 0;
+                break;
             }
 #endif
+            AssertFailed();
             break;
 
         case RTR0MEMOBJTYPE_LOCK:
-            for (unsigned i = 0; i < pMemNt->cMdls; i++)
-            {
-                MmUnlockPages(pMemNt->apMdl[i]);
-                IoFreeMdl(pMemNt->apMdl[i]);
-                pMemNt->apMdl[i] = NULL;
+            for (uint32_t i = 0; i < pMemNt->cMdls; i++)
+            {
+                MmUnlockPages(pMemNt->apMdls[i]);
+                IoFreeMdl(pMemNt->apMdls[i]);
+                pMemNt->apMdls[i] = NULL;
             }
             break;
 
         case RTR0MEMOBJTYPE_RES_VIRT:
-            if (pMemNt->Core.u.ResVirt.R0Process == NIL_RTR0PROCESS)
-            {
-                MmMapIoSpace
+/*            if (pMemNt->Core.u.ResVirt.R0Process == NIL_RTR0PROCESS)
+            {
             }
             else
             {
-            }
+            }*/
             AssertMsgFailed(("RTR0MEMOBJTYPE_RES_VIRT\n"));
             return VERR_INTERNAL_ERROR;
@@ -149 +152 @@
         case RTR0MEMOBJTYPE_MAPPING:
         {
-            Assert(pMemNt->Core.pv && pMemNt->cMdls == 1 && pMemNt->apMdls[0]);
+            Assert(pMemNt->Core.pv);
             PRTR0MEMOBJNT pMemNtParent = (PRTR0MEMOBJNT)pMemNt->Core.uRel.Child.pParent;
             Assert(pMemNtParent);
-            Assert(pMemNtParent->cMdls == 1 && pMemNtParent->apMdls[0]);
-            MmUnmapLockedPages(pMemNt->Core.pv, pMemNtParent->apMdls);
+            if (pMemNtParent->cMdls)
+            {
+                Assert(pMemNt->cMdls == 1 && pMemNt->apMdls[0]);
+                Assert(pMemNtParent->cMdls == 1 && pMemNtParent->apMdls[0]);
+                Assert(     pMemNt->Core.u.Mapping.R0Process == NIL_RTR0PROCESS
+                       ||   pMemNt->Core.u.Mapping.R0Process == RTR0ProcHandleSelf());
+                MmUnmapLockedPages(pMemNt->Core.pv, pMemNtParent->apMdls[0]);
+            }
+            else
+            {
+                Assert(     pMemNtParent->Core.enmType == RTR0MEMOBJTYPE_PHYS
+                       &&   !pMemNtParent->Core.u.Phys.fAllocated);
+                MmUnmapIoSpace(pMemNt->Core.pv, pMemNt->Core.cb);
+            }
             pMemNt->Core.pv = NULL;
             break;
@@ -169 +184 @@
 int rtR0MemObjNativeAllocPage(PPRTR0MEMOBJINTERNAL ppMem, size_t cb, bool fExecutable)
 {
+    AssertMsgReturn(cb > _1G, ("%#x\n", cb), VERR_OUT_OF_RANGE); /* for safe size_t -> ULONG */
+
     /*
      * Try allocate the memory and create an MDL for them so
@@ -178 +195 @@
     if (pv)
     {
-        PMDL pMdl = IoAllocateMdl(pv, cb, FALSE, FALSE, NULL);
+        PMDL pMdl = IoAllocateMdl(pv, (ULONG)cb, FALSE, FALSE, NULL);
         if (pMdl)
         {
             MmBuildMdlForNonPagedPool(pMdl);
-            /** @todo if (fExecutable) */
+#ifdef RT_ARCH_AMD64
+            MmProtectMdlSystemAddress(pMdl, PAGE_EXECUTE_READWRITE);
+#endif
 
             /*
@@ -207 +226 @@
 int rtR0MemObjNativeAllocLow(PPRTR0MEMOBJINTERNAL ppMem, size_t cb, bool fExecutable)
 {
+    AssertMsgReturn(cb <= _1G, ("%#x\n", cb), VERR_OUT_OF_RANGE); /* for safe size_t -> ULONG */
+
     /*
      * Try see if we get lucky first...
@@ -234 +255 @@
      */
     PHYSICAL_ADDRESS Zero;
+    Zero.QuadPart = 0;
     PHYSICAL_ADDRESS HighAddr;
-    Zero.QuadPart = 0;
-    High.QuadPart = _4G - 1;
+    HighAddr.QuadPart = _4G - 1;
     PMDL pMdl = MmAllocatePagesForMdl(Zero, HighAddr, Zero, cb);
     if (pMdl)
@@ -289 +310 @@
 static int rtR0MemObjNativeAllocContEx(PPRTR0MEMOBJINTERNAL ppMem, size_t cb, bool fExecutable, RTHCPHYS PhysHighest)
 {
+    AssertMsgReturn(cb <= _1G, ("%#x\n", cb), VERR_OUT_OF_RANGE); /* for safe size_t -> ULONG */
+
     /*
      * Allocate the memory and create an MDL for it.
@@ -298 +321 @@
         return VERR_NO_MEMORY;
 
-    PMDL pMdl = IoAllocateMdl(pv, cb, FALSE, FALSE, NULL);
+    PMDL pMdl = IoAllocateMdl(pv, (ULONG)cb, FALSE, FALSE, NULL);
     if (pMdl)
     {
         MmBuildMdlForNonPagedPool(pMdl);
-        /** @todo fExecutable */
+#ifdef RT_ARCH_AMD64
+        MmProtectMdlSystemAddress(pMdl, PAGE_EXECUTE_READWRITE);
+#endif
 
         PRTR0MEMOBJNT pMemNt = (PRTR0MEMOBJNT)rtR0MemObjNew(sizeof(*pMemNt), RTR0MEMOBJTYPE_CONT, pv, cb);
@@ -333 +358 @@
      * Try and see if we're lucky and get a contiguous chunk from MmAllocatePagesForMdl.
      *
-     * If the allocation is big, the chances are *probably* not very good. The current
-     * max limit is kind of random.
+     * This is preferable to using MmAllocateContiguousMemory because there are
+     * a few situations where the memory shouldn't be mapped, like for instance
+     * VT-x control memory. Since these are rather small allocations (one or
+     * two pages) MmAllocatePagesForMdl will probably be able to satisfy the
+     * request.
+     *
+     * If the allocation is big, the chances are *probably* not very good. The
+     * current limit is kind of random...
      */
     if (cb < _128K)
     {
         PHYSICAL_ADDRESS Zero;
+        Zero.QuadPart = 0;
         PHYSICAL_ADDRESS HighAddr;
-        Zero.QuadPart = 0;
-        High.QuadPart = _4G - 1;
+        HighAddr.QuadPart = PhysHighest == NIL_RTHCPHYS ? MAXLONGLONG : PhysHighest;
         PMDL pMdl = MmAllocatePagesForMdl(Zero, HighAddr, Zero, cb);
         if (pMdl)
@@ -349 +380 @@
                 PPFN_NUMBER paPfns = MmGetMdlPfnArray(pMdl);
                 PFN_NUMBER Pfn = paPfns[0] + 1;
-                const size_t cPages = cb >> PAGE_SIZE;
+                const size_t cPages = cb >> PAGE_SHIFT;
                 size_t iPage;
                 for (iPage = 1; iPage < cPages; iPage++, Pfn++)
@@ -372 +403 @@
         }
     }
-#endif
+#endif /* !IPRT_TARGET_NT4 */
 
     return rtR0MemObjNativeAllocContEx(ppMem, cb, false, PhysHighest);
@@ -382 +413 @@
 #ifndef IPRT_TARGET_NT4
     PHYSICAL_ADDRESS Zero;
+    Zero.QuadPart = 0;
     PHYSICAL_ADDRESS HighAddr;
-    Zero.QuadPart = 0;
-    High.QuadPart = _4G - 1;
+    HighAddr.QuadPart = PhysHighest == NIL_RTHCPHYS ? MAXLONGLONG : PhysHighest;
     PMDL pMdl = MmAllocatePagesForMdl(Zero, HighAddr, Zero, cb);
     if (pMdl)
@@ -390 +421 @@
         if (MmGetMdlByteCount(pMdl) >= cb)
         {
-            PRTR0MEMOBJNT pMemNt = (PRTR0MEMOBJNT)rtR0MemObjNew(sizeof(*pMemNt), RTR0MEMOBJTYPE_CONT, pv, cb);
+            PRTR0MEMOBJNT pMemNt = (PRTR0MEMOBJNT)rtR0MemObjNew(sizeof(*pMemNt), RTR0MEMOBJTYPE_PHYS_NC, NULL, cb);
             if (pMemNt)
             {
@@ -424 +455 @@
     if (pMemNt)
     {
-        pMemNt->Core.u.Phys.PhysBase = PhysAddr;
+        pMemNt->Core.u.Phys.PhysBase = Phys;
         pMemNt->Core.u.Phys.fAllocated = false;
-        pMemNt->pMemDesc = pMemDesc;
         *ppMem = &pMemNt->Core;
         return VINF_SUCCESS;
@@ -449 +479 @@
      * Calc the number of MDLs we need and allocate the memory object structure.
      */
-    unsigned cMdls = pMem->cb / MAX_LOCK_MEM_SIZE;
-    if ((pMem->cb % MAX_LOCK_MEM_SIZE) > 0)
+    size_t cMdls = cb / MAX_LOCK_MEM_SIZE;
+    if (cb % MAX_LOCK_MEM_SIZE)
         cMdls++;
+    if (cMdls >= UINT32_MAX)
+        return VERR_OUT_OF_RANGE;
     PRTR0MEMOBJNT pMemNt = (PRTR0MEMOBJNT)rtR0MemObjNew(RT_OFFSETOF(RTR0MEMOBJNT, apMdls[cMdls]),
-                                                        RTR0MEMOBJTYPE_LOCK, (void *)R3Ptr, cb);
+                                                        RTR0MEMOBJTYPE_LOCK, pv, cb);
     if (!pMemNt)
         return VERR_NO_MEMORY;
@@ -462 +494 @@
     int         rc = VINF_SUCCESS;
     size_t      cbTotal = 0;
-    uint8_t    *pb = pv;
-    unsigned    iMdl;
+    uint8_t    *pb = (uint8_t *)pv;
+    uint32_t    iMdl;
     for (iMdl = 0; iMdl < cMdls; iMdl++)
     {
@@ -473 +505 @@
             cbCur = MAX_LOCK_MEM_SIZE;
         AssertMsg(cbCur, ("cbCur: 0!\n"));
-        PMDL pMdl = IoAllocateMdl(pb, cbCur, FALSE, FALSE, NULL);
+        PMDL pMdl = IoAllocateMdl(pb, (ULONG)cbCur, FALSE, FALSE, NULL);
         if (!pMdl)
         {
@@ -513 +545 @@
     while (iMdl-- > 0)
     {
-        MmUnlockPages(pMemNt->apMdl[iMdl]);
-        IoFreeMdl(pMemNt->apMdl[iMdl]);
-        pMemNt->apMdl[iMdl] = NULL;
-    }
-    rtR0MemObjDelete(pMemNt);
-    return SUPDRV_ERR_LOCK_FAILED;
+        MmUnlockPages(pMemNt->apMdls[iMdl]);
+        IoFreeMdl(pMemNt->apMdls[iMdl]);
+        pMemNt->apMdls[iMdl] = NULL;
+    }
+    rtR0MemObjDelete(&pMemNt->Core);
+    return VERR_LOCK_FAILED;
 }
 
@@ -525 +557 @@
 {
     AssertMsgReturn(R0Process == RTR0ProcHandleSelf(), ("%p != %p\n", R0Process, RTR0ProcHandleSelf()), VERR_NOT_SUPPORTED);
-    /* ( Can use MmProbeAndLockProcessPages if we need to mess with other processes later.) */
+    /* (Can use MmProbeAndLockProcessPages if we need to mess with other processes later.) */
     return rtR0MemObjNtLock(ppMem, (void *)R3Ptr, cb, R0Process);
 }
@@ -532 +564 @@
 int rtR0MemObjNativeLockKernel(PPRTR0MEMOBJINTERNAL ppMem, void *pv, size_t cb)
 {
-    return rtR0MemObjNtLock(ppMem, (void *)R3Ptr, cb, NIL_RTR0PROCESS);
+    return rtR0MemObjNtLock(ppMem, pv, cb, NIL_RTR0PROCESS);
 }
 
@@ -547 +579 @@
 }
 
-
-int rtR0MemObjNativeMapKernel(PPRTR0MEMOBJINTERNAL ppMem, RTR0MEMOBJ pMemToMap, void *pvFixed, size_t uAlignment, unsigned fProt)
-{
-    /*
-     * Must have a memory descriptor.
-     */
-    int rc = VERR_INVALID_PARAMETER;
-    PRTR0MEMOBJNT pMemToMapDarwin = (PRTR0MEMOBJNT)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.
-                 */
-                PRTR0MEMOBJNT pMemNt = (PRTR0MEMOBJNT)rtR0MemObjNew(sizeof(*pMemNt), RTR0MEMOBJTYPE_MAPPING,
-                                                                                pv, pMemToMapDarwin->Core.cb);
+/**
+ * Internal worker for rtR0MemObjNativeMapKernel and rtR0MemObjNativeMapUser.
+ *
+ * @returns IPRT status code.
+ * @param   ppMem       Where to store the memory object for the mapping.
+ * @param   pMemToMap   The memory object to map.
+ * @param   pvFixed     Where to map it. (void *)-1 if anywhere is fine.
+ * @param   uAlignment  The alignment requirement for the mapping.
+ * @param   fProt       The desired page protection for the mapping.
+ * @param   R0Process   If NIL_RTR0PROCESS map into system (kernel) memory.
+ *                      If not nil, it's the current process.
+ */
+static int rtR0MemObjNtMap(PPRTR0MEMOBJINTERNAL ppMem, RTR0MEMOBJ pMemToMap, void *pvFixed, size_t uAlignment,
+                           unsigned fProt, RTR0PROCESS R0Process)
+{
+    int rc = VERR_MAP_FAILED;
+
+    /*
+     * There are two basic cases here, either we've got an MDL and can
+     * map it using MmMapLockedPages, or we've got a contiguous physical
+     * range (MMIO most likely) and can use MmMapIoSpace.
+     */
+    PRTR0MEMOBJNT pMemNtToMap = (PRTR0MEMOBJNT)pMemToMap;
+    if (pMemNtToMap->cMdls)
+    {
+        /* don't attempt map locked regions with more than one mdl. */
+        if (pMemNtToMap->cMdls != 1)
+            return VERR_NOT_SUPPORTED;
+
+        /* we can't map anything to the first page, sorry. */
+        if (pvFixed == 0)
+            return VERR_NOT_SUPPORTED;
+
+        /* only one system mapping for now - no time to figure out MDL restrictions right now. */
+        if (    pMemNtToMap->Core.uRel.Parent.cMappings
+            &&  R0Process == NIL_RTR0PROCESS)
+            return VERR_NOT_SUPPORTED;
+
+        __try
+        {
+            /** @todo uAlignment */
+            /** @todo How to set the protection on the pages? */
+            void *pv = MmMapLockedPagesSpecifyCache(pMemNtToMap->apMdls[0],
+                                                    R0Process == NIL_RTR0PROCESS ? KernelMode : UserMode,
+                                                    MmCached,
+                                                    pvFixed == (void *)-1 ? pvFixed : NULL,
+                                                    FALSE /* no bug check on failure */,
+                                                    NormalPagePriority);
+            if (pv)
+            {
+                NOREF(fProt);
+
+                PRTR0MEMOBJNT pMemNt = (PRTR0MEMOBJNT)rtR0MemObjNew(sizeof(*pMemNt), RTR0MEMOBJTYPE_MAPPING, pv,
+                                                                    pMemNtToMap->Core.cb);
                 if (pMemNt)
                 {
-                    pMemNt->Core.u.Mapping.R0Process = NIL_RTR0PROCESS;
-                    pMemNt->pMemMap = pMemMap;
+                    pMemNt->Core.u.Mapping.R0Process = R0Process;
                     *ppMem = &pMemNt->Core;
                     return VINF_SUCCESS;
@@ -579 +641 @@
 
                 rc = VERR_NO_MEMORY;
-            }
-            else
-                rc = VERR_ADDRESS_TOO_BIG;
-            pMemMap->release();
-        }
-        else
+                MmUnmapLockedPages(pv, pMemNtToMap->apMdls[0]);
+            }
+        }
+        __except(EXCEPTION_EXECUTE_HANDLER)
+        {
+            /* nothing */
             rc = VERR_MAP_FAILED;
-    }
+        }
+    }
+    else
+    {
+        AssertReturn(   pMemNtToMap->Core.enmType == RTR0MEMOBJTYPE_PHYS
+                     && !pMemNtToMap->Core.u.Phys.fAllocated, VERR_INTERNAL_ERROR);
+
+        /* cannot map phys mem to user space (yet). */
+        if (R0Process != NIL_RTR0PROCESS)
+            return VERR_NOT_SUPPORTED;
+
+        /** @todo uAlignment */
+        /** @todo How to set the protection on the pages? */
+        PHYSICAL_ADDRESS Phys;
+        Phys.QuadPart = pMemNtToMap->Core.u.Phys.PhysBase;
+        void *pv = MmMapIoSpace(Phys, pMemNtToMap->Core.cb, MmCached); /** @todo add cache type to fProt. */
+        if (pv)
+        {
+            PRTR0MEMOBJNT pMemNt = (PRTR0MEMOBJNT)rtR0MemObjNew(sizeof(*pMemNt), RTR0MEMOBJTYPE_MAPPING, pv,
+                                                                pMemNtToMap->Core.cb);
+            if (pMemNt)
+            {
+                pMemNt->Core.u.Mapping.R0Process = R0Process;
+                *ppMem = &pMemNt->Core;
+                return VINF_SUCCESS;
+            }
+
+            rc = VERR_NO_MEMORY;
+            MmUnmapIoSpace(pv, pMemNtToMap->Core.cb);
+        }
+    }
+
+    NOREF(uAlignment); NOREF(fProt);
     return rc;
 }
 
 
+int rtR0MemObjNativeMapKernel(PPRTR0MEMOBJINTERNAL ppMem, RTR0MEMOBJ pMemToMap, void *pvFixed, size_t uAlignment, unsigned fProt)
+{
+    return rtR0MemObjNtMap(ppMem, pMemToMap, pvFixed, uAlignment, fProt, NIL_RTR0PROCESS);
+}
+
+
 int rtR0MemObjNativeMapUser(PPRTR0MEMOBJINTERNAL ppMem, RTR0MEMOBJ pMemToMap, RTR3PTR R3PtrFixed, size_t uAlignment, unsigned fProt, RTR0PROCESS R0Process)
 {
-    /*
-     * Must have a memory descriptor.
-     */
-    int rc = VERR_INVALID_PARAMETER;
-    PRTR0MEMOBJNT pMemToMapDarwin = (PRTR0MEMOBJNT)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.
-                 */
-                PRTR0MEMOBJNT pMemNt = (PRTR0MEMOBJNT)rtR0MemObjNew(sizeof(*pMemNt), RTR0MEMOBJTYPE_MAPPING,
-                                                                                pv, pMemToMapDarwin->Core.cb);
-                if (pMemNt)
-                {
-                    pMemNt->Core.u.Mapping.R0Process = R0Process;
-                    pMemNt->pMemMap = pMemMap;
-                    *ppMem = &pMemNt->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;
-    PRTR0MEMOBJNT   pMemNt = (PRTR0MEMOBJNT)pMem;
-
-#ifdef USE_VM_MAP_WIRE
-    /*
-     * Locked memory doesn't have a memory descriptor and
-     * needs to be handled differently.
-     */
-    if (pMemNt->Core.enmType == RTR0MEMOBJTYPE_LOCK)
-    {
-        ppnum_t PgNo;
-        if (pMemNt->Core.u.Lock.R0Process == NIL_RTR0PROCESS)
-            PgNo = pmap_find_phys(kernel_pmap, (uintptr_t)pMemNt->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)pMemNt->Core.u.Lock.R0Process) + s_offPmap);
-            PgNo = pmap_find_phys(Pmap, (uintptr_t)pMemNt->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 = pMemNt->pMemDesc;
-        if (!pMemDesc)
-            pMemDesc = pMemNt->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;
-}
-
+    AssertReturn(R0Process == RTR0ProcHandleSelf(), VERR_NOT_SUPPORTED);
+    return rtR0MemObjNtMap(ppMem, pMemToMap, (void *)R3PtrFixed, uAlignment, fProt, R0Process);
+}
+
+
+RTHCPHYS rtR0MemObjNativeGetPagePhysAddr(PRTR0MEMOBJINTERNAL pMem, size_t iPage)
+{
+    PRTR0MEMOBJNT pMemNt = (PRTR0MEMOBJNT)pMem;
+
+    if (pMemNt->cMdls)
+    {
+        if (pMemNt->cMdls == 1)
+        {
+            PPFN_NUMBER paPfns = MmGetMdlPfnArray(pMemNt->apMdls[0]);
+            return (RTHCPHYS)paPfns[iPage] << PAGE_SHIFT;
+        }
+
+        size_t iMdl = iPage / (MAX_LOCK_MEM_SIZE >> PAGE_SHIFT);
+        size_t iMdlPfn = iPage % (MAX_LOCK_MEM_SIZE >> PAGE_SHIFT);
+        PPFN_NUMBER paPfns = MmGetMdlPfnArray(pMemNt->apMdls[iMdl]);
+        return (RTHCPHYS)paPfns[iMdlPfn] << PAGE_SHIFT;
+    }
+
+    switch (pMemNt->Core.enmType)
+    {
+        case RTR0MEMOBJTYPE_MAPPING:
+            return rtR0MemObjNativeGetPagePhysAddr(pMemNt->Core.uRel.Child.pParent, iPage);
+
+        case RTR0MEMOBJTYPE_PHYS:
+            return pMemNt->Core.u.Phys.PhysBase + (iPage << PAGE_SHIFT);
+
+        case RTR0MEMOBJTYPE_PAGE:
+        case RTR0MEMOBJTYPE_PHYS_NC:
+        case RTR0MEMOBJTYPE_LOW:
+        case RTR0MEMOBJTYPE_CONT:
+        case RTR0MEMOBJTYPE_LOCK:
+        default:
+            AssertMsgFailed(("%d\n", pMemNt->Core.enmType));
+        case RTR0MEMOBJTYPE_RES_VIRT:
+            return NIL_RTHCPHYS;
+    }
+}
+

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

@@ -45 +45 @@
 #endif
 
+#include <iprt/param.h>
 #ifndef PAGE_OFFSET_MASK
 # define PAGE_OFFSET_MASK (PAGE_SIZE - 1)