VirtualBox

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


Ignore:
Timestamp:
Feb 14, 2018 10:46:51 PM (7 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
120883
Message:

NEM: More code. bugref:9044

Location:
trunk/src/VBox/VMM/VMMR3
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/VMM/VMMR3/EM.cpp

    r70984 r71020  
    4444#include <VBox/vmm/trpm.h>
    4545#include <VBox/vmm/iem.h>
     46#include <VBox/vmm/nem.h>
    4647#include <VBox/vmm/iom.h>
    4748#include <VBox/vmm/dbgf.h>
    … …  
    14001401
    14011402    X86EFLAGS EFlags = pCtx->eflags;
    1402     /** @todo NEM: scheduling.   */
    14031403    if (!VM_IS_RAW_MODE_ENABLED(pVM))
    14041404    {
    1405         /*
    1406          * Hardware accelerated raw-mode:
    1407          */
    1408         if (   EMIsHwVirtExecutionEnabled(pVM)
    1409             && HMR3CanExecuteGuest(pVM, pCtx))
    1410             return EMSTATE_HM;
    1411 
    1412         /*
    1413          * Note! Raw mode and hw accelerated mode are incompatible. The latter
    1414          *       turns off monitoring features essential for raw mode!
    1415          */
    1416         return EMSTATE_IEM_THEN_REM;
     1405        if (EMIsHwVirtExecutionEnabled(pVM))
     1406        {
     1407            if (VM_IS_HM_ENABLED(pVM))
     1408            {
     1409                if (HMR3CanExecuteGuest(pVM, pCtx))
     1410                    return EMSTATE_HM;
     1411            }
     1412            else if (NEMR3CanExecuteGuest(pVM, pVCpu, pCtx))
     1413                return EMSTATE_NEM;
     1414
     1415            /*
     1416             * Note! Raw mode and hw accelerated mode are incompatible. The latter
     1417             *       turns off monitoring features essential for raw mode!
     1418             */
     1419            return EMSTATE_IEM_THEN_REM;
     1420        }
    14171421    }
    14181422

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

    r70979 r71020  
    3737
    3838#include <VBox/vmm/nem.h>
     39#include <VBox/vmm/apic.h>
    3940#include "NEMInternal.h"
    4041#include <VBox/vmm/vm.h>
    … …  
    162163                                               pvInput, cbInput, pvOutput, cbOutput);
    163164    if (!hEvt && !pfnApcCallback && !pvApcCtx)
    164         LogRel(("VID!NtDeviceIoControlFile: hFile=%#zx pIos=%p->{s:%#x, i:%#zx} uFunction=%#x Input=%p LB %#x Output=%p LB %#x) -> %#x; Caller=%p\n",
    165                 hFile, pIos, pIos->Status, pIos->Information, uFunction, pvInput, cbInput, pvOutput, cbOutput, rcNt, ASMReturnAddress()));
     165        Log6(("VID!NtDeviceIoControlFile: hFile=%#zx pIos=%p->{s:%#x, i:%#zx} uFunction=%#x Input=%p LB %#x Output=%p LB %#x) -> %#x; Caller=%p\n",
     166              hFile, pIos, pIos->Status, pIos->Information, uFunction, pvInput, cbInput, pvOutput, cbOutput, rcNt, ASMReturnAddress()));
    166167    else
    167         LogRel(("VID!NtDeviceIoControlFile: hFile=%#zx hEvt=%#zx Apc=%p/%p pIos=%p->{s:%#x, i:%#zx} uFunction=%#x Input=%p LB %#x Output=%p LB %#x) -> %#x; Caller=%p\n",
    168                 hFile, hEvt, pfnApcCallback, pvApcCtx, pIos, pIos->Status, pIos->Information, uFunction,
    169                 pvInput, cbInput, pvOutput, cbOutput, rcNt, ASMReturnAddress()));
     168        Log6(("VID!NtDeviceIoControlFile: hFile=%#zx hEvt=%#zx Apc=%p/%p pIos=%p->{s:%#x, i:%#zx} uFunction=%#x Input=%p LB %#x Output=%p LB %#x) -> %#x; Caller=%p\n",
     169              hFile, hEvt, pfnApcCallback, pvApcCtx, pIos, pIos->Status, pIos->Information, uFunction,
     170              pvInput, cbInput, pvOutput, cbOutput, rcNt, ASMReturnAddress()));
    170171    return rcNt;
    171172}
    … …  
    869870
    870871
     872static int nemR3WinCopyOutState(PVM pVM, PVMCPU pVCpu, PCPUMCTX pCtx)
     873{
     874    WHV_REGISTER_NAME  aenmNames[128];
     875    WHV_REGISTER_VALUE aValues[128];
     876
     877    /* GPRs */
     878    aenmNames[0]      = WHvX64RegisterRax;
     879    aValues[0].Reg64  = pCtx->rax;
     880    aenmNames[1]      = WHvX64RegisterRcx;
     881    aValues[1].Reg64  = pCtx->rcx;
     882    aenmNames[2]      = WHvX64RegisterRdx;
     883    aValues[2].Reg64  = pCtx->rdx;
     884    aenmNames[3]      = WHvX64RegisterRbx;
     885    aValues[3].Reg64  = pCtx->rbx;
     886    aenmNames[4]      = WHvX64RegisterRsp;
     887    aValues[4].Reg64  = pCtx->rsp;
     888    aenmNames[5]      = WHvX64RegisterRbp;
     889    aValues[5].Reg64  = pCtx->rbp;
     890    aenmNames[6]      = WHvX64RegisterRsi;
     891    aValues[6].Reg64  = pCtx->rsi;
     892    aenmNames[7]      = WHvX64RegisterRdi;
     893    aValues[7].Reg64  = pCtx->rdi;
     894    aenmNames[8]      = WHvX64RegisterR8;
     895    aValues[8].Reg64  = pCtx->r8;
     896    aenmNames[9]      = WHvX64RegisterR9;
     897    aValues[9].Reg64  = pCtx->r9;
     898    aenmNames[10]     = WHvX64RegisterR10;
     899    aValues[10].Reg64 = pCtx->r10;
     900    aenmNames[11]     = WHvX64RegisterR11;
     901    aValues[11].Reg64 = pCtx->r11;
     902    aenmNames[12]     = WHvX64RegisterR12;
     903    aValues[12].Reg64 = pCtx->r12;
     904    aenmNames[13]     = WHvX64RegisterR13;
     905    aValues[13].Reg64 = pCtx->r13;
     906    aenmNames[14]     = WHvX64RegisterR14;
     907    aValues[14].Reg64 = pCtx->r14;
     908    aenmNames[15]     = WHvX64RegisterR15;
     909    aValues[15].Reg64 = pCtx->r15;
     910
     911    /* RIP & Flags */
     912    aenmNames[16]     = WHvX64RegisterRip;
     913    aValues[16].Reg64 = pCtx->rip;
     914    aenmNames[17]     = WHvX64RegisterRflags;
     915    aValues[17].Reg64 = pCtx->rflags.u;
     916
     917    /* Segments */
     918#define COPY_OUT_SEG(a_idx, a_enmName, a_SReg) \
     919        do { \
     920            aenmNames[a_idx]                  = a_enmName; \
     921            aValues[a_idx].Segment.Base       = (a_SReg).u64Base; \
     922            aValues[a_idx].Segment.Limit      = (a_SReg).u32Limit; \
     923            aValues[a_idx].Segment.Selector   = (a_SReg).Sel; \
     924            aValues[a_idx].Segment.Attributes = (a_SReg).Attr.u; \
     925        } while (0)
     926    COPY_OUT_SEG(18, WHvX64RegisterEs,   pCtx->es);
     927    COPY_OUT_SEG(19, WHvX64RegisterCs,   pCtx->cs);
     928    COPY_OUT_SEG(20, WHvX64RegisterSs,   pCtx->ss);
     929    COPY_OUT_SEG(21, WHvX64RegisterDs,   pCtx->ds);
     930    COPY_OUT_SEG(22, WHvX64RegisterFs,   pCtx->fs);
     931    COPY_OUT_SEG(23, WHvX64RegisterGs,   pCtx->gs);
     932    COPY_OUT_SEG(24, WHvX64RegisterLdtr, pCtx->ldtr);
     933    COPY_OUT_SEG(25, WHvX64RegisterTr,   pCtx->tr);
     934
     935    uintptr_t iReg = 26;
     936    /* Descriptor tables. */
     937    aenmNames[iReg] = WHvX64RegisterIdtr;
     938    aValues[iReg].Table.Limit = pCtx->idtr.cbIdt;
     939    aValues[iReg].Table.Base  = pCtx->idtr.pIdt;
     940    iReg++;
     941    aenmNames[iReg] = WHvX64RegisterGdtr;
     942    aValues[iReg].Table.Limit = pCtx->gdtr.cbGdt;
     943    aValues[iReg].Table.Base  = pCtx->gdtr.pGdt;
     944    iReg++;
     945
     946    /* Control registers. */
     947    aenmNames[iReg]     = WHvX64RegisterCr0;
     948    aValues[iReg].Reg64 = pCtx->cr0;
     949    iReg++;
     950    aenmNames[iReg]     = WHvX64RegisterCr2;
     951    aValues[iReg].Reg64 = pCtx->cr2;
     952    iReg++;
     953    aenmNames[iReg]     = WHvX64RegisterCr3;
     954    aValues[iReg].Reg64 = pCtx->cr3;
     955    iReg++;
     956    aenmNames[iReg]     = WHvX64RegisterCr4;
     957    aValues[iReg].Reg64 = pCtx->cr4;
     958    iReg++;
     959    aenmNames[iReg]     = WHvX64RegisterCr8;
     960    aValues[iReg].Reg64 = CPUMGetGuestCR8(pVCpu);
     961    iReg++;
     962
     963    /* Debug registers. */
     964/** @todo fixme */
     965    aenmNames[iReg]     = WHvX64RegisterDr0;
     966    aValues[iReg].Reg64 = CPUMGetHyperDR0(pVCpu);
     967    iReg++;
     968    aenmNames[iReg]     = WHvX64RegisterDr1;
     969    aValues[iReg].Reg64 = CPUMGetHyperDR1(pVCpu);
     970    iReg++;
     971    aenmNames[iReg]     = WHvX64RegisterDr2;
     972    aValues[iReg].Reg64 = CPUMGetHyperDR2(pVCpu);
     973    iReg++;
     974    aenmNames[iReg]     = WHvX64RegisterDr3;
     975    aValues[iReg].Reg64 = CPUMGetHyperDR3(pVCpu);
     976    iReg++;
     977    aenmNames[iReg]     = WHvX64RegisterDr6;
     978    aValues[iReg].Reg64 = CPUMGetHyperDR6(pVCpu);
     979    iReg++;
     980    aenmNames[iReg]     = WHvX64RegisterDr7;
     981    aValues[iReg].Reg64 = CPUMGetHyperDR7(pVCpu);
     982    iReg++;
     983
     984    /* Vector state. */
     985    aenmNames[iReg]     = WHvX64RegisterXmm0;
     986    aValues[iReg].Reg128.Low64  = pCtx->pXStateR3->x87.aXMM[0].uXmm.s.Lo;
     987    aValues[iReg].Reg128.High64 = pCtx->pXStateR3->x87.aXMM[0].uXmm.s.Hi;
     988    iReg++;
     989    aenmNames[iReg]     = WHvX64RegisterXmm1;
     990    aValues[iReg].Reg128.Low64  = pCtx->pXStateR3->x87.aXMM[1].uXmm.s.Lo;
     991    aValues[iReg].Reg128.High64 = pCtx->pXStateR3->x87.aXMM[1].uXmm.s.Hi;
     992    iReg++;
     993    aenmNames[iReg]     = WHvX64RegisterXmm2;
     994    aValues[iReg].Reg128.Low64  = pCtx->pXStateR3->x87.aXMM[2].uXmm.s.Lo;
     995    aValues[iReg].Reg128.High64 = pCtx->pXStateR3->x87.aXMM[2].uXmm.s.Hi;
     996    iReg++;
     997    aenmNames[iReg]     = WHvX64RegisterXmm3;
     998    aValues[iReg].Reg128.Low64  = pCtx->pXStateR3->x87.aXMM[3].uXmm.s.Lo;
     999    aValues[iReg].Reg128.High64 = pCtx->pXStateR3->x87.aXMM[3].uXmm.s.Hi;
     1000    iReg++;
     1001    aenmNames[iReg]     = WHvX64RegisterXmm4;
     1002    aValues[iReg].Reg128.Low64  = pCtx->pXStateR3->x87.aXMM[4].uXmm.s.Lo;
     1003    aValues[iReg].Reg128.High64 = pCtx->pXStateR3->x87.aXMM[4].uXmm.s.Hi;
     1004    iReg++;
     1005    aenmNames[iReg]     = WHvX64RegisterXmm5;
     1006    aValues[iReg].Reg128.Low64  = pCtx->pXStateR3->x87.aXMM[5].uXmm.s.Lo;
     1007    aValues[iReg].Reg128.High64 = pCtx->pXStateR3->x87.aXMM[5].uXmm.s.Hi;
     1008    iReg++;
     1009    aenmNames[iReg]     = WHvX64RegisterXmm6;
     1010    aValues[iReg].Reg128.Low64  = pCtx->pXStateR3->x87.aXMM[6].uXmm.s.Lo;
     1011    aValues[iReg].Reg128.High64 = pCtx->pXStateR3->x87.aXMM[6].uXmm.s.Hi;
     1012    iReg++;
     1013    aenmNames[iReg]     = WHvX64RegisterXmm7;
     1014    aValues[iReg].Reg128.Low64  = pCtx->pXStateR3->x87.aXMM[7].uXmm.s.Lo;
     1015    aValues[iReg].Reg128.High64 = pCtx->pXStateR3->x87.aXMM[7].uXmm.s.Hi;
     1016    iReg++;
     1017    aenmNames[iReg]     = WHvX64RegisterXmm8;
     1018    aValues[iReg].Reg128.Low64  = pCtx->pXStateR3->x87.aXMM[8].uXmm.s.Lo;
     1019    aValues[iReg].Reg128.High64 = pCtx->pXStateR3->x87.aXMM[8].uXmm.s.Hi;
     1020    iReg++;
     1021    aenmNames[iReg]     = WHvX64RegisterXmm9;
     1022    aValues[iReg].Reg128.Low64  = pCtx->pXStateR3->x87.aXMM[9].uXmm.s.Lo;
     1023    aValues[iReg].Reg128.High64 = pCtx->pXStateR3->x87.aXMM[9].uXmm.s.Hi;
     1024    iReg++;
     1025    aenmNames[iReg]     = WHvX64RegisterXmm10;
     1026    aValues[iReg].Reg128.Low64  = pCtx->pXStateR3->x87.aXMM[10].uXmm.s.Lo;
     1027    aValues[iReg].Reg128.High64 = pCtx->pXStateR3->x87.aXMM[10].uXmm.s.Hi;
     1028    iReg++;
     1029    aenmNames[iReg]     = WHvX64RegisterXmm11;
     1030    aValues[iReg].Reg128.Low64  = pCtx->pXStateR3->x87.aXMM[11].uXmm.s.Lo;
     1031    aValues[iReg].Reg128.High64 = pCtx->pXStateR3->x87.aXMM[11].uXmm.s.Hi;
     1032    iReg++;
     1033    aenmNames[iReg]     = WHvX64RegisterXmm12;
     1034    aValues[iReg].Reg128.Low64  = pCtx->pXStateR3->x87.aXMM[12].uXmm.s.Lo;
     1035    aValues[iReg].Reg128.High64 = pCtx->pXStateR3->x87.aXMM[12].uXmm.s.Hi;
     1036    iReg++;
     1037    aenmNames[iReg]     = WHvX64RegisterXmm13;
     1038    aValues[iReg].Reg128.Low64  = pCtx->pXStateR3->x87.aXMM[13].uXmm.s.Lo;
     1039    aValues[iReg].Reg128.High64 = pCtx->pXStateR3->x87.aXMM[13].uXmm.s.Hi;
     1040    iReg++;
     1041    aenmNames[iReg]     = WHvX64RegisterXmm14;
     1042    aValues[iReg].Reg128.Low64  = pCtx->pXStateR3->x87.aXMM[14].uXmm.s.Lo;
     1043    aValues[iReg].Reg128.High64 = pCtx->pXStateR3->x87.aXMM[14].uXmm.s.Hi;
     1044    iReg++;
     1045    aenmNames[iReg]     = WHvX64RegisterXmm15;
     1046    aValues[iReg].Reg128.Low64  = pCtx->pXStateR3->x87.aXMM[15].uXmm.s.Lo;
     1047    aValues[iReg].Reg128.High64 = pCtx->pXStateR3->x87.aXMM[15].uXmm.s.Hi;
     1048    iReg++;
     1049
     1050    /* Floating point state. */
     1051    aenmNames[iReg]     = WHvX64RegisterFpMmx0;
     1052    aValues[iReg].Fp.AsUINT128.Low64  = pCtx->pXStateR3->x87.aRegs[0].au64[0];
     1053    aValues[iReg].Fp.AsUINT128.High64 = pCtx->pXStateR3->x87.aRegs[0].au64[1];
     1054    iReg++;
     1055    aenmNames[iReg]     = WHvX64RegisterFpMmx1;
     1056    aValues[iReg].Fp.AsUINT128.Low64  = pCtx->pXStateR3->x87.aRegs[1].au64[0];
     1057    aValues[iReg].Fp.AsUINT128.High64 = pCtx->pXStateR3->x87.aRegs[1].au64[1];
     1058    iReg++;
     1059    aenmNames[iReg]     = WHvX64RegisterFpMmx2;
     1060    aValues[iReg].Fp.AsUINT128.Low64  = pCtx->pXStateR3->x87.aRegs[2].au64[0];
     1061    aValues[iReg].Fp.AsUINT128.High64 = pCtx->pXStateR3->x87.aRegs[2].au64[1];
     1062    iReg++;
     1063    aenmNames[iReg]     = WHvX64RegisterFpMmx3;
     1064    aValues[iReg].Fp.AsUINT128.Low64  = pCtx->pXStateR3->x87.aRegs[3].au64[0];
     1065    aValues[iReg].Fp.AsUINT128.High64 = pCtx->pXStateR3->x87.aRegs[3].au64[1];
     1066    iReg++;
     1067    aenmNames[iReg]     = WHvX64RegisterFpMmx4;
     1068    aValues[iReg].Fp.AsUINT128.Low64  = pCtx->pXStateR3->x87.aRegs[4].au64[0];
     1069    aValues[iReg].Fp.AsUINT128.High64 = pCtx->pXStateR3->x87.aRegs[4].au64[1];
     1070    iReg++;
     1071    aenmNames[iReg]     = WHvX64RegisterFpMmx5;
     1072    aValues[iReg].Fp.AsUINT128.Low64  = pCtx->pXStateR3->x87.aRegs[5].au64[0];
     1073    aValues[iReg].Fp.AsUINT128.High64 = pCtx->pXStateR3->x87.aRegs[5].au64[1];
     1074    iReg++;
     1075    aenmNames[iReg]     = WHvX64RegisterFpMmx6;
     1076    aValues[iReg].Fp.AsUINT128.Low64  = pCtx->pXStateR3->x87.aRegs[6].au64[0];
     1077    aValues[iReg].Fp.AsUINT128.High64 = pCtx->pXStateR3->x87.aRegs[6].au64[1];
     1078    iReg++;
     1079    aenmNames[iReg]     = WHvX64RegisterFpMmx7;
     1080    aValues[iReg].Fp.AsUINT128.Low64  = pCtx->pXStateR3->x87.aRegs[7].au64[0];
     1081    aValues[iReg].Fp.AsUINT128.High64 = pCtx->pXStateR3->x87.aRegs[7].au64[1];
     1082    iReg++;
     1083
     1084    aenmNames[iReg]     = WHvX64RegisterFpControlStatus;
     1085    aValues[iReg].FpControlStatus.FpControl = pCtx->pXStateR3->x87.FCW;
     1086    aValues[iReg].FpControlStatus.FpStatus  = pCtx->pXStateR3->x87.FSW;
     1087    aValues[iReg].FpControlStatus.FpTag     = pCtx->pXStateR3->x87.FTW;
     1088    aValues[iReg].FpControlStatus.Reserved  = pCtx->pXStateR3->x87.FTW >> 8;
     1089    aValues[iReg].FpControlStatus.LastFpOp  = pCtx->pXStateR3->x87.FOP;
     1090    aValues[iReg].FpControlStatus.LastFpRip = (pCtx->pXStateR3->x87.FPUIP)
     1091                                            | ((uint64_t)pCtx->pXStateR3->x87.CS << 32)
     1092                                            | ((uint64_t)pCtx->pXStateR3->x87.Rsrvd1 << 48);
     1093    iReg++;
     1094
     1095    aenmNames[iReg]     = WHvX64RegisterXmmControlStatus;
     1096    aValues[iReg].XmmControlStatus.LastFpRdp            = (pCtx->pXStateR3->x87.FPUDP)
     1097                                                        | ((uint64_t)pCtx->pXStateR3->x87.DS << 32)
     1098                                                        | ((uint64_t)pCtx->pXStateR3->x87.Rsrvd2 << 48);
     1099    aValues[iReg].XmmControlStatus.XmmStatusControl     = pCtx->pXStateR3->x87.MXCSR;
     1100    aValues[iReg].XmmControlStatus.XmmStatusControlMask = pCtx->pXStateR3->x87.MXCSR_MASK; /* ??? (Isn't this an output field?) */
     1101    iReg++;
     1102
     1103    /* MSRs */
     1104    // WHvX64RegisterTsc - don't touch
     1105    aenmNames[iReg]     = WHvX64RegisterEfer;
     1106    aValues[iReg].Reg64 = pCtx->msrEFER;
     1107    iReg++;
     1108    aenmNames[iReg]     = WHvX64RegisterKernelGsBase;
     1109    aValues[iReg].Reg64 = pCtx->msrKERNELGSBASE;
     1110    iReg++;
     1111    aenmNames[iReg]     = WHvX64RegisterApicBase;
     1112    aValues[iReg].Reg64 = APICGetBaseMsrNoCheck(pVCpu);
     1113    iReg++;
     1114    aenmNames[iReg]     = WHvX64RegisterPat;
     1115    aValues[iReg].Reg64 = pCtx->msrPAT;
     1116    iReg++;
     1117    /// @todo WHvX64RegisterSysenterCs
     1118    /// @todo WHvX64RegisterSysenterEip
     1119    /// @todo WHvX64RegisterSysenterEsp
     1120    aenmNames[iReg]     = WHvX64RegisterStar;
     1121    aValues[iReg].Reg64 = pCtx->msrSTAR;
     1122    iReg++;
     1123    aenmNames[iReg]     = WHvX64RegisterLstar;
     1124    aValues[iReg].Reg64 = pCtx->msrLSTAR;
     1125    iReg++;
     1126    aenmNames[iReg]     = WHvX64RegisterCstar;
     1127    aValues[iReg].Reg64 = pCtx->msrCSTAR;
     1128    iReg++;
     1129    aenmNames[iReg]     = WHvX64RegisterSfmask;
     1130    aValues[iReg].Reg64 = pCtx->msrSFMASK;
     1131    iReg++;
     1132
     1133    /* event injection */
     1134    /// @todo WHvRegisterPendingInterruption
     1135    /// @todo WHvRegisterInterruptState
     1136    /// @todo WHvRegisterPendingEvent0
     1137    /// @todo WHvRegisterPendingEvent1
     1138
     1139    /*
     1140     * Set the registers.
     1141     */
     1142    Assert(iReg < RT_ELEMENTS(aValues));
     1143    Assert(iReg < RT_ELEMENTS(aenmNames));
     1144#ifdef NEM_WIN_INTERCEPT_NT_IO_CTLS
     1145    Log6(("Calling WHvSetVirtualProcessorRegisters(%p, %u, %p, %u, %p)\n",
     1146          pVM->nem.s.hPartition, pVCpu->idCpu, aenmNames, iReg, aValues));
     1147#endif
     1148    HRESULT hrc = WHvSetVirtualProcessorRegisters(pVM->nem.s.hPartition, pVCpu->idCpu, aenmNames, iReg, aValues);
     1149    if (SUCCEEDED(hrc))
     1150        return VINF_SUCCESS;
     1151    AssertLogRelMsgFailed(("WHvSetVirtualProcessorRegisters(%p, %u,,%u,) -> %Rhrc (Last=%#x/%u)\n",
     1152                           pVM->nem.s.hPartition, pVCpu->idCpu, iReg,
     1153                           hrc, RTNtCurrentTeb()->LastStatusValue, RTNtCurrentTeb()->LastErrorValue));
     1154    return VERR_INTERNAL_ERROR;
     1155}
     1156
     1157
     1158#ifdef LOG_ENABLED
     1159/**
     1160 * Log the full details of an exit reason.
     1161 *
     1162 * @param   pExitReason     The exit reason to log.
     1163 */
     1164static void nemR3WinLogExitReason(WHV_RUN_VP_EXIT_CONTEXT const *pExitReason)
     1165{
     1166    bool fExitCtx = false;
     1167    bool fExitInstr = false;
     1168    switch (pExitReason->ExitReason)
     1169    {
     1170        case WHvRunVpExitReasonMemoryAccess:
     1171            Log2(("Exit: Memory access GCPhys=%RGp GCVirt=%RGv %s %s %s\n",
     1172                  pExitReason->MemoryAccess.Gpa, pExitReason->MemoryAccess.Gva,
     1173                  pExitReason->MemoryAccess.AccessInfo.AccessType == WHvMemoryAccessRead ? "read"
     1174                  : pExitReason->MemoryAccess.AccessInfo.AccessType == WHvMemoryAccessWrite ? "write"
     1175                  : pExitReason->MemoryAccess.AccessInfo.AccessType == WHvMemoryAccessExecute ? "exec" : "!invalid access!",
     1176                  pExitReason->MemoryAccess.AccessInfo.GpaUnmapped ? "unmapped" : "mapped",
     1177                  pExitReason->MemoryAccess.AccessInfo.GvaValid    ? "" : "invalid-gc-virt"));
     1178            AssertMsg(!(pExitReason->MemoryAccess.AccessInfo.AsUINT32 & ~UINT32_C(0xf)),
     1179                      ("MemoryAccess.AccessInfo=%#x\n", pExitReason->MemoryAccess.AccessInfo.AsUINT32));
     1180            fExitCtx = fExitInstr = true;
     1181            break;
     1182
     1183        case WHvRunVpExitReasonX64IoPortAccess:
     1184            Log2(("Exit: Memory access IoPort=%#x LB %u %s%s%s rax=%#RX64 rcx=%#RX64 rsi=%#RX64 rdi=%#RX64\n",
     1185                  pExitReason->IoPortAccess.PortNumber,
     1186                  pExitReason->IoPortAccess.AccessInfo.AccessSize,
     1187                  pExitReason->IoPortAccess.AccessInfo.IsWrite ? "out" : "in",
     1188                  pExitReason->IoPortAccess.AccessInfo.StringOp ? " string" : "",
     1189                  pExitReason->IoPortAccess.AccessInfo.RepPrefix ? " rep" : "",
     1190                  pExitReason->IoPortAccess.Rax,
     1191                  pExitReason->IoPortAccess.Rcx,
     1192                  pExitReason->IoPortAccess.Rsi,
     1193                  pExitReason->IoPortAccess.Rdi));
     1194            Log2(("Exit: ds=%#x:{%#RX64 LB %#RX32, %#x}  es=%#x:{%#RX64 LB %#RX32, %#x}\n",
     1195                  pExitReason->IoPortAccess.Ds.Selector,
     1196                  pExitReason->IoPortAccess.Ds.Base,
     1197                  pExitReason->IoPortAccess.Ds.Limit,
     1198                  pExitReason->IoPortAccess.Ds.Attributes,
     1199                  pExitReason->IoPortAccess.Es.Selector,
     1200                  pExitReason->IoPortAccess.Es.Base,
     1201                  pExitReason->IoPortAccess.Es.Limit,
     1202                  pExitReason->IoPortAccess.Es.Attributes ));
     1203
     1204            AssertMsg(   pExitReason->IoPortAccess.AccessInfo.AccessSize == 1
     1205                      || pExitReason->IoPortAccess.AccessInfo.AccessSize == 2
     1206                      || pExitReason->IoPortAccess.AccessInfo.AccessSize == 4,
     1207                      ("IoPortAccess.AccessInfo.AccessSize=%d\n", pExitReason->IoPortAccess.AccessInfo.AccessSize));
     1208            AssertMsg(!(pExitReason->IoPortAccess.AccessInfo.AsUINT32 & ~UINT32_C(0x3f)),
     1209                      ("IoPortAccess.AccessInfo=%#x\n", pExitReason->IoPortAccess.AccessInfo.AsUINT32));
     1210            fExitCtx = fExitInstr = true;
     1211            break;
     1212
     1213# if 0
     1214        case WHvRunVpExitReasonUnrecoverableException:
     1215        case WHvRunVpExitReasonInvalidVpRegisterValue:
     1216        case WHvRunVpExitReasonUnsupportedFeature:
     1217        case WHvRunVpExitReasonX64InterruptWindow:
     1218        case WHvRunVpExitReasonX64Halt:
     1219        case WHvRunVpExitReasonX64MsrAccess:
     1220        case WHvRunVpExitReasonX64Cpuid:
     1221        case WHvRunVpExitReasonException:
     1222        case WHvRunVpExitReasonCanceled:
     1223        case WHvRunVpExitReasonAlerted:
     1224            WHV_X64_MSR_ACCESS_CONTEXT MsrAccess;
     1225            WHV_X64_CPUID_ACCESS_CONTEXT CpuidAccess;
     1226            WHV_VP_EXCEPTION_CONTEXT VpException;
     1227            WHV_X64_INTERRUPTION_DELIVERABLE_CONTEXT InterruptWindow;
     1228            WHV_UNRECOVERABLE_EXCEPTION_CONTEXT UnrecoverableException;
     1229            WHV_X64_UNSUPPORTED_FEATURE_CONTEXT UnsupportedFeature;
     1230            WHV_RUN_VP_CANCELED_CONTEXT CancelReason;
     1231#endif
     1232
     1233        case WHvRunVpExitReasonNone:
     1234            Log2(("Exit: No reason\n"));
     1235            AssertFailed();
     1236            break;
     1237
     1238        default:
     1239            Log(("Exit: %#x\n", pExitReason->ExitReason));
     1240            break;
     1241    }
     1242
     1243    /*
     1244     * Context and maybe instruction details.
     1245     */
     1246    if (fExitCtx)
     1247    {
     1248        const WHV_VP_EXIT_CONTEXT *pVpCtx = &pExitReason->IoPortAccess.VpContext;
     1249        Log2(("Exit: CS:RIP=%04x:%08RX64 RFLAGS=%06RX64 cbInstr=%u CS={%RX64 L %#RX32, %#x}\n",
     1250              pVpCtx->Cs.Selector,
     1251              pVpCtx->Rip,
     1252              pVpCtx->Rflags,
     1253              pVpCtx->InstructionLength,
     1254              pVpCtx->Cs.Base, pVpCtx->Cs.Limit, pVpCtx->Cs.Attributes));
     1255        Log2(("Exit: cpl=%d CR0.PE=%d CR0.AM=%d EFER.LMA=%d DebugActive=%d InterruptionPending=%d InterruptShadow=%d\n",
     1256              pVpCtx->ExecutionState.Cpl,
     1257              pVpCtx->ExecutionState.Cr0Pe,
     1258              pVpCtx->ExecutionState.Cr0Am,
     1259              pVpCtx->ExecutionState.EferLma,
     1260              pVpCtx->ExecutionState.DebugActive,
     1261              pVpCtx->ExecutionState.InterruptionPending,
     1262              pVpCtx->ExecutionState.InterruptShadow));
     1263        AssertMsg(!(pVpCtx->ExecutionState.AsUINT16 & ~UINT16_C(0x107f)),
     1264                  ("ExecutionState.AsUINT16=%#x\n", pVpCtx->ExecutionState.AsUINT16));
     1265
     1266        /** @todo Someone please explain why the InstructionBytes fields are 16 bytes
     1267         * long, when 15 would've been sufficent and saved 3-7 bytes of alignment
     1268         * padding?  Intel max length is 15, so is this sSome ARM stuff?  Aren't ARM
     1269         * instructions max 32-bit wide?  Confused. */
     1270        if (fExitInstr && pExitReason->IoPortAccess.InstructionByteCount > 0)
     1271            Log2(("Exit: Instruction %.*Rhxs\n",
     1272                  pExitReason->IoPortAccess.InstructionByteCount, pExitReason->IoPortAccess.InstructionBytes));
     1273    }
     1274}
     1275#endif /* LOG_ENABLED */
     1276
    8711277VBOXSTRICTRC nemR3NativeRunGC(PVM pVM, PVMCPU pVCpu)
    8721278{
    873     NOREF(pVM); NOREF(pVCpu);
    874     return VERR_INTERNAL_ERROR_2;
     1279    /*
     1280     * Just some simple experiment here that runs a couple of instructions.
     1281     */
     1282    PCPUMCTX pCtx = CPUMQueryGuestCtxPtr(pVCpu);
     1283    int rc = nemR3WinCopyOutState(pVM, pVCpu, pCtx);
     1284    if (RT_SUCCESS(rc))
     1285    {
     1286        WHV_RUN_VP_EXIT_CONTEXT ExitReason;
     1287        RT_ZERO(ExitReason);
     1288        HRESULT hrc = WHvRunVirtualProcessor(pVM->nem.s.hPartition, pVCpu->idCpu, &ExitReason, sizeof(ExitReason));
     1289        Log2(("WHvRunVirtualProcessor -> %#x; exit code %#x (%d)\n", hrc, ExitReason.ExitReason));
     1290        if (LogIs2Enabled())
     1291            nemR3WinLogExitReason(&ExitReason);
     1292
     1293        rc = VERR_NOT_IMPLEMENTED;
     1294    }
     1295    return rc;
    8751296}
    8761297
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