VirtualBox

Changeset 71075 in vbox for trunk/src/VBox/VMM/VMMR3


Ignore:
Timestamp:
Feb 20, 2018 9:10:45 PM (7 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
120939
Message:

VMM,SUPDrv: More NEM/win experimentation. bugref:9044

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/VMM/VMMR3/NEMR3Native-win.cpp

    r71044 r71075  
    55 * Log group 2: Exit logging.
    66 * Log group 3: Log context on exit.
     7 * Log group 5: Ring-3 memory management
     8 * Log group 6: Ring-0 memory management
    79 * Log group 12: API intercepts.
    810 */
    … …  
    2628#define LOG_GROUP LOG_GROUP_NEM
    2729#include <iprt/nt/nt-and-windows.h>
     30#include <iprt/nt/hyperv.h>
    2831#include <WinHvPlatform.h>
    2932
    … …  
    7376#define NEM_WIN_IS_RELEVANT_TO_A20(a_GCPhys)    \
    7477    ( ((RTGCPHYS)((a_GCPhys) - _1M) < (RTGCPHYS)_64K) || ((RTGCPHYS)(a_GCPhys) < (RTGCPHYS)_64K) )
     78
     79
     80#define NEM_WIN_USE_HYPERCALLS
    7581
    7682
    … …  
    147153/** @} */
    148154
     155/** @name APIs imported from Vid.dll
     156 * @{ */
     157static BOOL (WINAPI *g_pfnVidGetHvPartitionId)(HANDLE hPartition, HV_PARTITION_ID *pidPartition);
     158/** @} */
     159
    149160
    150161/**
    … …  
    176187    NEM_WIN_IMPORT(0, false, WHvGetVirtualProcessorRegisters),
    177188    NEM_WIN_IMPORT(0, false, WHvSetVirtualProcessorRegisters),
     189    NEM_WIN_IMPORT(1, false, VidGetHvPartitionId),
    178190#undef NEM_WIN_IMPORT
    179191};
    … …  
    752764        {
    753765            /*
    754              * Create and initialize a partition.
     766             * Check out our ring-0 capabilities.
    755767             */
    756             rc = nemR3WinInitCreatePartition(pVM, pErrInfo);
     768            rc = SUPR3CallVMMR0Ex(pVM->pVMR0, 0 /*idCpu*/, VMMR0_DO_NEM_INIT_VM, 0, NULL);
    757769            if (RT_SUCCESS(rc))
    758770            {
    759                 VM_SET_MAIN_EXECUTION_ENGINE(pVM, VM_EXEC_ENGINE_NATIVE_API);
    760                 Log(("NEM: Marked active!\n"));
     771                /*
     772                 * Create and initialize a partition.
     773                 */
     774                rc = nemR3WinInitCreatePartition(pVM, pErrInfo);
     775                if (RT_SUCCESS(rc))
     776                {
     777                    VM_SET_MAIN_EXECUTION_ENGINE(pVM, VM_EXEC_ENGINE_NATIVE_API);
     778                    Log(("NEM: Marked active!\n"));
     779                }
    761780            }
    762781        }
    … …  
    862881        return VMSetError(pVM, VERR_NEM_VM_CREATE_FAILED, RT_SRC_POS,
    863882                          "Failed to get device handle for partition %p: %Rhrc", hPartition, hrc);
    864     /** @todo Do a Vid query that uses the handle to check that we've got a
    865      *  working value.  */
     883
     884    HV_PARTITION_ID idHvPartition = HV_PARTITION_ID_INVALID;
     885    if (!g_pfnVidGetHvPartitionId(hPartitionDevice, &idHvPartition))
     886        return VMSetError(pVM, VERR_NEM_VM_CREATE_FAILED, RT_SRC_POS,
     887                          "Failed to get device handle and/or partition ID for %p (hPartitionDevice=%p, Last=%#x/%u)",
     888                          hPartition, hPartitionDevice, RTNtCurrentTeb()->LastStatusValue, RTNtCurrentTeb()->LastErrorValue);
    866889    pVM->nem.s.hPartitionDevice = hPartitionDevice;
     890    pVM->nem.s.idHvPartition    = idHvPartition;
    867891
    868892    /*
    … …  
    890914    pVM->nem.s.fCreatedEmts = true;
    891915
    892     LogRel(("NEM: Successfully set up partition (device handle %p)\n", hPartitionDevice));
     916    LogRel(("NEM: Successfully set up partition (device handle %p, partition ID %#llx)\n", hPartitionDevice, idHvPartition));
    893917    return VINF_SUCCESS;
    894918}
    … …  
    15881612        if (pPendingInt->fInterruptionPending)
    15891613        {
    1590             Log6(("PendingInterruption: type=%u vector=%#x errcd=%RTbool/%#x unk0=%u unk1=%u\n",
     1614            Log7(("PendingInterruption: type=%u vector=%#x errcd=%RTbool/%#x unk0=%u unk1=%u\n",
    15911615                  pPendingInt->enmInterruptionType, pPendingInt->InterruptionVector, pPendingInt->fDeliverErrCd,
    15921616                  pPendingInt->uErrCd, pPendingInt->fUnknown0, pPendingInt->fUnknown1));
    … …  
    18161840}
    18171841
     1842
    18181843static DECLCALLBACK(int) nemR3WinUnmapOnePageCallback(PVM pVM, RTGCPHYS GCPhys, uint8_t *pu2NemState, void *pvUser)
    18191844{
    18201845    RT_NOREF_PV(pvUser);
     1846#ifdef NEM_WIN_USE_HYPERCALLS
     1847    PVMCPU pVCpu = VMMGetCpu(pVM);
     1848    pVCpu->nem.s.Hypercall.UnmapPages.GCPhys = GCPhys;
     1849    pVCpu->nem.s.Hypercall.UnmapPages.cPages = 1;
     1850    int rc = SUPR3CallVMMR0Ex(pVM->pVMR0, pVCpu->idCpu, VMMR0_DO_NEM_UNMAP_PAGES, 0, NULL);
     1851    AssertRC(rc);
     1852    if (RT_SUCCESS(rc))
     1853#else
    18211854    HRESULT hrc = WHvUnmapGpaRange(pVM->nem.s.hPartition, GCPhys, X86_PAGE_SIZE);
    18221855    if (SUCCEEDED(hrc))
     1856#endif
     1857    {
     1858        Log5(("NEM GPA unmap all: %RGp (cMappedPages=%u)\n", GCPhys, pVM->nem.s.cMappedPages - 1));
    18231859        *pu2NemState = NEM_WIN_PAGE_STATE_UNMAPPED;
     1860    }
    18241861    else
    18251862    {
     1863#ifdef NEM_WIN_USE_HYPERCALLS
     1864        LogRel(("nemR3WinUnmapOnePageCallback: GCPhys=%RGp rc=%Rrc\n", GCPhys, rc));
     1865#else
    18261866        LogRel(("nemR3WinUnmapOnePageCallback: GCPhys=%RGp %s hrc=%Rhrc (%#x) Last=%#x/%u (cMappedPages=%u)\n",
    18271867                GCPhys, g_apszPageStates[*pu2NemState], hrc, hrc, RTNtCurrentTeb()->LastStatusValue,
    18281868                RTNtCurrentTeb()->LastErrorValue, pVM->nem.s.cMappedPages));
     1869#endif
    18291870        *pu2NemState = NEM_WIN_PAGE_STATE_NOT_SET;
    18301871    }
    … …  
    19471988     * If this fails, which it does every so often, just unmap everything for now.
    19481989     */
     1990#ifdef NEM_WIN_USE_HYPERCALLS
     1991    pVCpu->nem.s.Hypercall.UnmapPages.GCPhys = GCPhys;
     1992    pVCpu->nem.s.Hypercall.UnmapPages.cPages = 1;
     1993    int rc = SUPR3CallVMMR0Ex(pVM->pVMR0, pVCpu->idCpu, VMMR0_DO_NEM_UNMAP_PAGES, 0, NULL);
     1994    AssertRC(rc);
     1995    if (RT_SUCCESS(rc))
     1996#else
    19491997    /** @todo figure out whether we mess up the state or if it's WHv.   */
    19501998    HRESULT hrc = WHvUnmapGpaRange(pVM->nem.s.hPartition, GCPhys, X86_PAGE_SIZE);
    19511999    if (SUCCEEDED(hrc))
     2000#endif
    19522001    {
    19532002        pState->fDidSomething = true;
    19542003        pState->fCanResume    = true;
    19552004        pInfo->u2NemState = NEM_WIN_PAGE_STATE_UNMAPPED;
    1956         Log5(("nemR3WinHandleMemoryAccessPageCheckerCallback: %RGp => unmapped[%s]\n", GCPhys, g_apszPageStates[u2State]));
     2005        uint32_t cMappedPages = ASMAtomicDecU32(&pVM->nem.s.cMappedPages); NOREF(cMappedPages);
     2006        Log5(("NEM GPA unmapped/exit: %RGp (was %s, cMappedPages=%u)\n", GCPhys, g_apszPageStates[u2State], cMappedPages));
    19572007        return VINF_SUCCESS;
    19582008    }
     2009#ifdef NEM_WIN_USE_HYPERCALLS
     2010    LogRel(("nemR3WinHandleMemoryAccessPageCheckerCallback/unmap: GCPhysDst=%RGp rc=%Rrc\n", GCPhys, rc));
     2011    return rc;
     2012#else
    19592013    LogRel(("nemR3WinHandleMemoryAccessPageCheckerCallback/unmap: GCPhysDst=%RGp %s hrc=%Rhrc (%#x) Last=%#x/%u (cMappedPages=%u)\n",
    19602014            GCPhys, g_apszPageStates[u2State], hrc, hrc, RTNtCurrentTeb()->LastStatusValue, RTNtCurrentTeb()->LastErrorValue,
    … …  
    19682022    pInfo->u2NemState = NEM_WIN_PAGE_STATE_UNMAPPED;
    19692023    return VINF_SUCCESS;
     2024#endif
    19702025}
    19712026
    … …  
    21832238    const bool   fSingleStepping = false; /** @todo get this from somewhere. */
    21842239    VBOXSTRICTRC rcStrict = VINF_SUCCESS;
    2185     for (;;)
     2240    for (unsigned iLoop = 0;;iLoop++)
    21862241    {
    21872242        /*
    … …  
    23272382        }
    23282383
     2384#ifdef NEM_WIN_USE_HYPERCALLS
    23292385        /* Hack alert! */
    23302386        uint32_t const cMappedPages = pVM->nem.s.cMappedPages;
    … …  
    23362392            Log(("nemR3NativeRunGC: Unmapped all; cMappedPages=%u -> %u\n", cMappedPages, pVM->nem.s.cMappedPages));
    23372393        }
     2394#endif
    23382395
    23392396        /* If any FF is pending, return to the EM loops.  That's okay for the
    … …  
    25042561                                                            PPGMPHYSNEMPAGEINFO pInfo, void *pvUser)
    25052562{
    2506     Assert(pVCpu == NULL);
    2507 
    25082563    /* We'll just unmap the memory. */
    25092564    if (pInfo->u2NemState > NEM_WIN_PAGE_STATE_UNMAPPED)
    25102565    {
     2566#ifdef NEM_WIN_USE_HYPERCALLS
     2567        pVCpu->nem.s.Hypercall.UnmapPages.GCPhys = GCPhys;
     2568        pVCpu->nem.s.Hypercall.UnmapPages.cPages = 1;
     2569        int rc = SUPR3CallVMMR0Ex(pVM->pVMR0, pVCpu->idCpu, VMMR0_DO_NEM_UNMAP_PAGES, 0, NULL);
     2570        AssertRC(rc);
     2571        if (RT_SUCCESS(rc))
     2572#else
    25112573        HRESULT hrc = WHvUnmapGpaRange(pVM->nem.s.hPartition, GCPhys, X86_PAGE_SIZE);
    25122574        if (SUCCEEDED(hrc))
     2575#endif
     2576        {
     2577            uint32_t cMappedPages = ASMAtomicDecU32(&pVM->nem.s.cMappedPages); NOREF(cMappedPages);
     2578            Log5(("NEM GPA unmapped/A20: %RGp (was %s, cMappedPages=%u)\n", GCPhys, g_apszPageStates[pInfo->u2NemState], cMappedPages));
    25132579            pInfo->u2NemState = NEM_WIN_PAGE_STATE_UNMAPPED;
     2580        }
    25142581        else
    25152582        {
     2583#ifdef NEM_WIN_USE_HYPERCALLS
     2584            LogRel(("nemR3WinUnsetForA20CheckerCallback/unmap: GCPhys=%RGp rc=%Rrc\n", GCPhys, rc));
     2585            return rc;
     2586#else
    25162587            LogRel(("nemR3WinUnsetForA20CheckerCallback/unmap: GCPhys=%RGp hrc=%Rhrc (%#x) Last=%#x/%u\n",
    25172588                    GCPhys, hrc, hrc, RTNtCurrentTeb()->LastStatusValue, RTNtCurrentTeb()->LastErrorValue));
    25182589            return VERR_INTERNAL_ERROR_2;
     2590#endif
    25192591        }
    25202592    }
    … …  
    25292601 * @returns The PGMPhysNemQueryPageInfo result.
    25302602 * @param   pVM             The cross context VM structure.
    2531  * @param   pVCpu           The cross context virtual CPU structure.  Optional.
     2603 * @param   pVCpu           The cross context virtual CPU structure.
    25322604 * @param   GCPhys          The page to unmap.
    25332605 */
    2534 static int nemR3WinUnmapPageForA20Gate(PVM pVM, RTGCPHYS GCPhys)
     2606static int nemR3WinUnmapPageForA20Gate(PVM pVM, PVMCPU pVCpu, RTGCPHYS GCPhys)
    25352607{
    25362608    PGMPHYSNEMPAGEINFO Info;
    2537     return PGMPhysNemPageInfoChecker(pVM, NULL /*pVCpu*/, GCPhys, false /*fMakeWritable*/, &Info,
     2609    return PGMPhysNemPageInfoChecker(pVM, pVCpu, GCPhys, false /*fMakeWritable*/, &Info,
    25382610                                     nemR3WinUnsetForA20CheckerCallback, NULL);
    25392611}
    … …  
    25582630        pVM->nem.s.fA20Enabled = fEnabled;
    25592631        for (RTGCPHYS GCPhys = _1M; GCPhys < _1M + _64K; GCPhys += X86_PAGE_SIZE)
    2560             nemR3WinUnmapPageForA20Gate(pVM, GCPhys);
     2632            nemR3WinUnmapPageForA20Gate(pVM, pVCpu, GCPhys);
    25612633    }
    25622634}
    … …  
    26192691        if (u2OldState > NEM_WIN_PAGE_STATE_UNMAPPED)
    26202692        {
     2693#ifdef NEM_WIN_USE_HYPERCALLS
     2694            PVMCPU pVCpu = VMMGetCpu(pVM);
     2695            pVCpu->nem.s.Hypercall.UnmapPages.GCPhys = GCPhysDst;
     2696            pVCpu->nem.s.Hypercall.UnmapPages.cPages = 1;
     2697            int rc = SUPR3CallVMMR0Ex(pVM->pVMR0, pVCpu->idCpu, VMMR0_DO_NEM_UNMAP_PAGES, 0, NULL);
     2698            AssertRC(rc);
     2699            if (RT_SUCCESS(rc))
     2700            {
     2701                *pu2State = NEM_WIN_PAGE_STATE_UNMAPPED;
     2702                uint32_t cMappedPages = ASMAtomicDecU32(&pVM->nem.s.cMappedPages); NOREF(cMappedPages);
     2703                if (u2NewState == NEM_WIN_PAGE_STATE_UNMAPPED)
     2704                {
     2705                    Log5(("NEM GPA unmapped/set: %RGp (was %s, cMappedPages=%u)\n",
     2706                          GCPhysDst, g_apszPageStates[u2OldState], cMappedPages));
     2707                    return VINF_SUCCESS;
     2708                }
     2709            }
     2710            else
     2711            {
     2712                LogRel(("nemR3NativeSetPhysPage/unmap: GCPhysDst=%RGp rc=%Rrc\n", GCPhysDst, rc));
     2713                return rc;
     2714            }
     2715#else
    26212716            HRESULT hrc = WHvUnmapGpaRange(pVM->nem.s.hPartition, GCPhysDst, X86_PAGE_SIZE);
    26222717            if (SUCCEEDED(hrc))
    … …  
    26262721                if (u2NewState == NEM_WIN_PAGE_STATE_UNMAPPED)
    26272722                {
    2628                     Log5(("nemR3NativeSetPhysPage: %RGp => unmapped (total %u)\n", GCPhysDst, cMappedPages));
     2723                    Log5(("NEM GPA unmapped/set: %RGp (was %s, cMappedPages=%u)\n",
     2724                          GCPhysDst, g_apszPageStates[u2OldState], cMappedPages));
    26292725                    return VINF_SUCCESS;
    26302726                }
    … …  
    26362732                return VERR_NEM_INIT_FAILED;
    26372733            }
     2734#endif
    26382735        }
    26392736    }
    … …  
    26442741    if (fPageProt & NEM_PAGE_PROT_WRITE)
    26452742    {
     2743#ifdef NEM_WIN_USE_HYPERCALLS
     2744        RT_NOREF_PV(GCPhysSrc);
     2745        PVMCPU pVCpu = VMMGetCpu(pVM);
     2746        pVCpu->nem.s.Hypercall.MapPages.GCPhysSrc = GCPhysSrc;
     2747        pVCpu->nem.s.Hypercall.MapPages.GCPhysDst = GCPhysDst;
     2748        pVCpu->nem.s.Hypercall.MapPages.cPages    = 1;
     2749        pVCpu->nem.s.Hypercall.MapPages.fFlags    = HV_MAP_GPA_READABLE   | HV_MAP_GPA_WRITABLE
     2750                                                  | HV_MAP_GPA_EXECUTABLE | HV_MAP_GPA_EXECUTABLE_AGAIN;
     2751        int rc = SUPR3CallVMMR0Ex(pVM->pVMR0, pVCpu->idCpu, VMMR0_DO_NEM_MAP_PAGES, 0, NULL);
     2752        AssertRC(rc);
     2753        if (RT_SUCCESS(rc))
     2754        {
     2755            *pu2State = NEM_WIN_PAGE_STATE_WRITABLE;
     2756            uint32_t cMappedPages = ASMAtomicIncU32(&pVM->nem.s.cMappedPages); NOREF(cMappedPages);
     2757            Log5(("NEM GPA mapped/set: %RGp %s (was %s, cMappedPages=%u)\n",
     2758                  GCPhysDst, g_apszPageStates[u2NewState], g_apszPageStates[u2OldState], cMappedPages));
     2759            return VINF_SUCCESS;
     2760        }
     2761        LogRel(("nemR3NativeSetPhysPage/writable: GCPhysDst=%RGp rc=%Rrc\n", GCPhysDst, rc));
     2762        return rc;
     2763#else
    26462764        void *pvPage;
    26472765        int rc = nemR3NativeGCPhys2R3PtrWriteable(pVM, GCPhysSrc, &pvPage);
    … …  
    26542772                *pu2State = NEM_WIN_PAGE_STATE_WRITABLE;
    26552773                uint32_t cMappedPages = ASMAtomicIncU32(&pVM->nem.s.cMappedPages); NOREF(cMappedPages);
    2656                 Log5(("nemR3NativeSetPhysPage: %RGp => writable (total %u)\n", GCPhysDst, cMappedPages));
     2774                Log5(("NEM GPA mapped/set: %RGp %s (was %s, cMappedPages=%u)\n",
     2775                      GCPhysDst, g_apszPageStates[u2NewState], g_apszPageStates[u2OldState], cMappedPages));
    26572776                return VINF_SUCCESS;
    26582777            }
    … …  
    26632782        LogRel(("nemR3NativeSetPhysPage/writable: GCPhysSrc=%RGp rc=%Rrc\n", GCPhysSrc, rc));
    26642783        return rc;
     2784#endif
    26652785    }
    26662786
    26672787    if (fPageProt & NEM_PAGE_PROT_READ)
    26682788    {
     2789#ifdef NEM_WIN_USE_HYPERCALLS
     2790        PVMCPU pVCpu = VMMGetCpu(pVM);
     2791        pVCpu->nem.s.Hypercall.MapPages.GCPhysSrc = GCPhysSrc;
     2792        pVCpu->nem.s.Hypercall.MapPages.GCPhysDst = GCPhysDst;
     2793        pVCpu->nem.s.Hypercall.MapPages.cPages    = 1;
     2794        pVCpu->nem.s.Hypercall.MapPages.fFlags    = HV_MAP_GPA_READABLE | HV_MAP_GPA_EXECUTABLE | HV_MAP_GPA_EXECUTABLE_AGAIN;
     2795        int rc = SUPR3CallVMMR0Ex(pVM->pVMR0, pVCpu->idCpu, VMMR0_DO_NEM_MAP_PAGES, 0, NULL);
     2796        AssertRC(rc);
     2797        if (RT_SUCCESS(rc))
     2798        {
     2799            *pu2State = NEM_WIN_PAGE_STATE_READABLE;
     2800            uint32_t cMappedPages = ASMAtomicIncU32(&pVM->nem.s.cMappedPages); NOREF(cMappedPages);
     2801            Log5(("NEM GPA mapped/set: %RGp %s (was %s, cMappedPages=%u)\n",
     2802                  GCPhysDst, g_apszPageStates[u2NewState], g_apszPageStates[u2OldState], cMappedPages));
     2803            return VINF_SUCCESS;
     2804        }
     2805        LogRel(("nemR3NativeSetPhysPage/readonly: GCPhysDst=%RGp rc=%Rrc\n", GCPhysDst, rc));
     2806        return rc;
     2807#else
    26692808        const void *pvPage;
    26702809        int rc = nemR3NativeGCPhys2R3PtrReadOnly(pVM, GCPhysSrc, &pvPage);
    … …  
    26772816                *pu2State = NEM_WIN_PAGE_STATE_READABLE;
    26782817                uint32_t cMappedPages = ASMAtomicIncU32(&pVM->nem.s.cMappedPages); NOREF(cMappedPages);
    2679                 Log5(("nemR3NativeSetPhysPage: %RGp => read+exec (total %u)\n", GCPhysDst, cMappedPages));
     2818                Log5(("NEM GPA mapped/set: %RGp %s (was %s, cMappedPages=%u)\n",
     2819                      GCPhysDst, g_apszPageStates[u2NewState], g_apszPageStates[u2OldState], cMappedPages));
    26802820                return VINF_SUCCESS;
    26812821            }
    … …  
    26862826        LogRel(("nemR3NativeSetPhysPage/readonly: GCPhysSrc=%RGp rc=%Rrc\n", GCPhysSrc, rc));
    26872827        return rc;
     2828#endif
    26882829    }
    26892830
    … …  
    27032844    }
    27042845
    2705     HRESULT hrc = WHvUnmapGpaRange(pVM->nem.s.hPartition, GCPhysDst, X86_PAGE_SIZE);
     2846#ifdef NEM_WIN_USE_HYPERCALLS
     2847    PVMCPU pVCpu = VMMGetCpu(pVM);
     2848    pVCpu->nem.s.Hypercall.UnmapPages.GCPhys = GCPhysDst & ~(RTGCPHYS)X86_PAGE_OFFSET_MASK;
     2849    pVCpu->nem.s.Hypercall.UnmapPages.cPages = 1;
     2850    int rc = SUPR3CallVMMR0Ex(pVM->pVMR0, pVCpu->idCpu, VMMR0_DO_NEM_UNMAP_PAGES, 0, NULL);
     2851    AssertRC(rc);
     2852    if (RT_SUCCESS(rc))
     2853    {
     2854        uint32_t cMappedPages = ASMAtomicDecU32(&pVM->nem.s.cMappedPages); NOREF(cMappedPages);
     2855        Log5(("NEM GPA unmapped/just: %RGp (was %s, cMappedPages=%u)\n", GCPhysDst, g_apszPageStates[*pu2State], cMappedPages));
     2856        *pu2State = NEM_WIN_PAGE_STATE_UNMAPPED;
     2857        return VINF_SUCCESS;
     2858    }
     2859    LogRel(("nemR3NativeSetPhysPage/unmap: GCPhysDst=%RGp rc=%Rrc\n", GCPhysDst, rc));
     2860    return rc;
     2861#else
     2862    HRESULT hrc = WHvUnmapGpaRange(pVM->nem.s.hPartition, GCPhysDst & ~(RTGCPHYS)X86_PAGE_OFFSET_MASK, X86_PAGE_SIZE);
    27062863    if (SUCCEEDED(hrc))
    27072864    {
    … …  
    27142871            GCPhysDst, hrc, hrc, RTNtCurrentTeb()->LastStatusValue, RTNtCurrentTeb()->LastErrorValue));
    27152872    return VERR_INTERNAL_ERROR_3;
     2873#endif
    27162874}
    27172875
    … …  
    27322890    {
    27332891        /* To keep effort at a minimum, we unmap the HMA page alias and resync it lazily when needed. */
    2734         rc = nemR3WinUnmapPageForA20Gate(pVM, GCPhys | RT_BIT_32(20));
     2892        rc = nemR3WinUnmapPageForA20Gate(pVM, pVCpu, GCPhys | RT_BIT_32(20));
    27352893        if (!NEM_WIN_IS_SUBJECT_TO_A20(GCPhys) && RT_SUCCESS(rc))
    27362894            rc = nemR3NativeSetPhysPage(pVM, GCPhys, GCPhys, fPageProt, pu2State, true /*fBackingChanged*/);
    … …  
    27652923    {
    27662924        /* To keep effort at a minimum, we unmap the HMA page alias and resync it lazily when needed. */
    2767         nemR3WinUnmapPageForA20Gate(pVM, GCPhys | RT_BIT_32(20));
     2925        nemR3WinUnmapPageForA20Gate(pVM, pVCpu, GCPhys | RT_BIT_32(20));
    27682926        if (!NEM_WIN_IS_SUBJECT_TO_A20(GCPhys))
    27692927            nemR3NativeSetPhysPage(pVM, GCPhys, GCPhys, fPageProt, pu2State, false /*fBackingChanged*/);
    … …  
    27952953    {
    27962954        /* To keep effort at a minimum, we unmap the HMA page alias and resync it lazily when needed. */
    2797         nemR3WinUnmapPageForA20Gate(pVM, GCPhys | RT_BIT_32(20));
     2955        nemR3WinUnmapPageForA20Gate(pVM, pVCpu, GCPhys | RT_BIT_32(20));
    27982956        if (!NEM_WIN_IS_SUBJECT_TO_A20(GCPhys))
    27992957            nemR3NativeSetPhysPage(pVM, GCPhys, GCPhys, fPageProt, pu2State, true /*fBackingChanged*/);
Note: See TracChangeset for help on using the changeset viewer.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette