VirtualBox

source: vbox/trunk/src/VBox/VMM/VMMAll/NEMAllNativeTemplate-win.cpp.h@ 93725

Last change on this file since 93725 was 93465, checked in by vboxsync, 3 years ago

VMM/NEMAllNativeTemplate-win.cpp.h: Fix returning the TSC_AUX MSR in NEMHCQueryCpuTick()
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 141.8 KB
Line 
1/* $Id: NEMAllNativeTemplate-win.cpp.h 93465 2022-01-27 19:04:30Z vboxsync $ */
2/** @file
3 * NEM - Native execution manager, Windows code template ring-0/3.
4 */
5
6/*
7 * Copyright (C) 2018-2022 Oracle Corporation
8 *
9 * This file is part of VirtualBox Open Source Edition (OSE), as
10 * available from http://www.virtualbox.org. This file is free software;
11 * you can redistribute it and/or modify it under the terms of the GNU
12 * General Public License (GPL) as published by the Free Software
13 * Foundation, in version 2 as it comes in the "COPYING" file of the
14 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16 */
17
18#ifndef IN_RING3
19# error "This is ring-3 only now"
20#endif
21
22
23/*********************************************************************************************************************************
24* Defined Constants And Macros *
25*********************************************************************************************************************************/
26/** Copy back a segment from hyper-V. */
27#define NEM_WIN_COPY_BACK_SEG(a_Dst, a_Src) \
28 do { \
29 (a_Dst).u64Base = (a_Src).Base; \
30 (a_Dst).u32Limit = (a_Src).Limit; \
31 (a_Dst).ValidSel = (a_Dst).Sel = (a_Src).Selector; \
32 (a_Dst).Attr.u = (a_Src).Attributes; \
33 (a_Dst).fFlags = CPUMSELREG_FLAGS_VALID; \
34 } while (0)
35
36/** @def NEMWIN_ASSERT_MSG_REG_VAL
37 * Asserts the correctness of a register value in a message/context.
38 */
39#if 0
40# define NEMWIN_NEED_GET_REGISTER
41# define NEMWIN_ASSERT_MSG_REG_VAL(a_pVCpu, a_enmReg, a_Expr, a_Msg) \
42 do { \
43 WHV_REGISTER_VALUE TmpVal; \
44 nemR3WinGetRegister(a_pVCpu, a_enmReg, &TmpVal); \
45 AssertMsg(a_Expr, a_Msg); \
46 } while (0)
47#else
48# define NEMWIN_ASSERT_MSG_REG_VAL(a_pVCpu, a_enmReg, a_Expr, a_Msg) do { } while (0)
49#endif
50
51/** @def NEMWIN_ASSERT_MSG_REG_VAL
52 * Asserts the correctness of a 64-bit register value in a message/context.
53 */
54#define NEMWIN_ASSERT_MSG_REG_VAL64(a_pVCpu, a_enmReg, a_u64Val) \
55 NEMWIN_ASSERT_MSG_REG_VAL(a_pVCpu, a_enmReg, (a_u64Val) == TmpVal.Reg64, \
56 (#a_u64Val "=%#RX64, expected %#RX64\n", (a_u64Val), TmpVal.Reg64))
57/** @def NEMWIN_ASSERT_MSG_REG_VAL
58 * Asserts the correctness of a segment register value in a message/context.
59 */
60#define NEMWIN_ASSERT_MSG_REG_SEG(a_pVCpu, a_enmReg, a_SReg) \
61 NEMWIN_ASSERT_MSG_REG_VAL(a_pVCpu, a_enmReg, \
62 (a_SReg).Base == TmpVal.Segment.Base \
63 && (a_SReg).Limit == TmpVal.Segment.Limit \
64 && (a_SReg).Selector == TmpVal.Segment.Selector \
65 && (a_SReg).Attributes == TmpVal.Segment.Attributes, \
66 ( #a_SReg "=%#RX16 {%#RX64 LB %#RX32,%#RX16} expected %#RX16 {%#RX64 LB %#RX32,%#RX16}\n", \
67 (a_SReg).Selector, (a_SReg).Base, (a_SReg).Limit, (a_SReg).Attributes, \
68 TmpVal.Segment.Selector, TmpVal.Segment.Base, TmpVal.Segment.Limit, TmpVal.Segment.Attributes))
69
70
71#ifndef NTDDI_WIN10_19H1
72# define NTDDI_WIN10_19H1 0x0a000007
73#endif
74
75/** WHvRegisterPendingEvent0 was renamed to WHvRegisterPendingEvent between
76 * SDK 17134 and 18362. */
77#if WDK_NTDDI_VERSION < NTDDI_WIN10_19H1
78# define WHvRegisterPendingEvent WHvRegisterPendingEvent0
79#endif
80
81
82/*********************************************************************************************************************************
83* Global Variables *
84*********************************************************************************************************************************/
85/** NEM_WIN_PAGE_STATE_XXX names. */
86NEM_TMPL_STATIC const char * const g_apszPageStates[4] = { "not-set", "unmapped", "readable", "writable" };
87
88/** HV_INTERCEPT_ACCESS_TYPE names. */
89static const char * const g_apszHvInterceptAccessTypes[4] = { "read", "write", "exec", "!undefined!" };
90
91
92/*********************************************************************************************************************************
93* Internal Functions *
94*********************************************************************************************************************************/
95NEM_TMPL_STATIC int nemHCNativeSetPhysPage(PVMCC pVM, PVMCPUCC pVCpu, RTGCPHYS GCPhysSrc, RTGCPHYS GCPhysDst,
96 uint32_t fPageProt, uint8_t *pu2State, bool fBackingChanged);
97
98
99
100NEM_TMPL_STATIC int nemHCWinCopyStateToHyperV(PVMCC pVM, PVMCPUCC pVCpu)
101{
102 /*
103 * The following is very similar to what nemR0WinExportState() does.
104 */
105 WHV_REGISTER_NAME aenmNames[128];
106 WHV_REGISTER_VALUE aValues[128];
107
108 uint64_t const fWhat = ~pVCpu->cpum.GstCtx.fExtrn & (CPUMCTX_EXTRN_ALL | CPUMCTX_EXTRN_NEM_WIN_MASK);
109 if ( !fWhat
110 && pVCpu->nem.s.fCurrentInterruptWindows == pVCpu->nem.s.fDesiredInterruptWindows)
111 return VINF_SUCCESS;
112 uintptr_t iReg = 0;
113
114#define ADD_REG64(a_enmName, a_uValue) do { \
115 aenmNames[iReg] = (a_enmName); \
116 aValues[iReg].Reg128.High64 = 0; \
117 aValues[iReg].Reg64 = (a_uValue); \
118 iReg++; \
119 } while (0)
120#define ADD_REG128(a_enmName, a_uValueLo, a_uValueHi) do { \
121 aenmNames[iReg] = (a_enmName); \
122 aValues[iReg].Reg128.Low64 = (a_uValueLo); \
123 aValues[iReg].Reg128.High64 = (a_uValueHi); \
124 iReg++; \
125 } while (0)
126
127 /* GPRs */
128 if (fWhat & CPUMCTX_EXTRN_GPRS_MASK)
129 {
130 if (fWhat & CPUMCTX_EXTRN_RAX)
131 ADD_REG64(WHvX64RegisterRax, pVCpu->cpum.GstCtx.rax);
132 if (fWhat & CPUMCTX_EXTRN_RCX)
133 ADD_REG64(WHvX64RegisterRcx, pVCpu->cpum.GstCtx.rcx);
134 if (fWhat & CPUMCTX_EXTRN_RDX)
135 ADD_REG64(WHvX64RegisterRdx, pVCpu->cpum.GstCtx.rdx);
136 if (fWhat & CPUMCTX_EXTRN_RBX)
137 ADD_REG64(WHvX64RegisterRbx, pVCpu->cpum.GstCtx.rbx);
138 if (fWhat & CPUMCTX_EXTRN_RSP)
139 ADD_REG64(WHvX64RegisterRsp, pVCpu->cpum.GstCtx.rsp);
140 if (fWhat & CPUMCTX_EXTRN_RBP)
141 ADD_REG64(WHvX64RegisterRbp, pVCpu->cpum.GstCtx.rbp);
142 if (fWhat & CPUMCTX_EXTRN_RSI)
143 ADD_REG64(WHvX64RegisterRsi, pVCpu->cpum.GstCtx.rsi);
144 if (fWhat & CPUMCTX_EXTRN_RDI)
145 ADD_REG64(WHvX64RegisterRdi, pVCpu->cpum.GstCtx.rdi);
146 if (fWhat & CPUMCTX_EXTRN_R8_R15)
147 {
148 ADD_REG64(WHvX64RegisterR8, pVCpu->cpum.GstCtx.r8);
149 ADD_REG64(WHvX64RegisterR9, pVCpu->cpum.GstCtx.r9);
150 ADD_REG64(WHvX64RegisterR10, pVCpu->cpum.GstCtx.r10);
151 ADD_REG64(WHvX64RegisterR11, pVCpu->cpum.GstCtx.r11);
152 ADD_REG64(WHvX64RegisterR12, pVCpu->cpum.GstCtx.r12);
153 ADD_REG64(WHvX64RegisterR13, pVCpu->cpum.GstCtx.r13);
154 ADD_REG64(WHvX64RegisterR14, pVCpu->cpum.GstCtx.r14);
155 ADD_REG64(WHvX64RegisterR15, pVCpu->cpum.GstCtx.r15);
156 }
157 }
158
159 /* RIP & Flags */
160 if (fWhat & CPUMCTX_EXTRN_RIP)
161 ADD_REG64(WHvX64RegisterRip, pVCpu->cpum.GstCtx.rip);
162 if (fWhat & CPUMCTX_EXTRN_RFLAGS)
163 ADD_REG64(WHvX64RegisterRflags, pVCpu->cpum.GstCtx.rflags.u);
164
165 /* Segments */
166#define ADD_SEG(a_enmName, a_SReg) \
167 do { \
168 aenmNames[iReg] = a_enmName; \
169 aValues[iReg].Segment.Base = (a_SReg).u64Base; \
170 aValues[iReg].Segment.Limit = (a_SReg).u32Limit; \
171 aValues[iReg].Segment.Selector = (a_SReg).Sel; \
172 aValues[iReg].Segment.Attributes = (a_SReg).Attr.u; \
173 iReg++; \
174 } while (0)
175 if (fWhat & CPUMCTX_EXTRN_SREG_MASK)
176 {
177 if (fWhat & CPUMCTX_EXTRN_ES)
178 ADD_SEG(WHvX64RegisterEs, pVCpu->cpum.GstCtx.es);
179 if (fWhat & CPUMCTX_EXTRN_CS)
180 ADD_SEG(WHvX64RegisterCs, pVCpu->cpum.GstCtx.cs);
181 if (fWhat & CPUMCTX_EXTRN_SS)
182 ADD_SEG(WHvX64RegisterSs, pVCpu->cpum.GstCtx.ss);
183 if (fWhat & CPUMCTX_EXTRN_DS)
184 ADD_SEG(WHvX64RegisterDs, pVCpu->cpum.GstCtx.ds);
185 if (fWhat & CPUMCTX_EXTRN_FS)
186 ADD_SEG(WHvX64RegisterFs, pVCpu->cpum.GstCtx.fs);
187 if (fWhat & CPUMCTX_EXTRN_GS)
188 ADD_SEG(WHvX64RegisterGs, pVCpu->cpum.GstCtx.gs);
189 }
190
191 /* Descriptor tables & task segment. */
192 if (fWhat & CPUMCTX_EXTRN_TABLE_MASK)
193 {
194 if (fWhat & CPUMCTX_EXTRN_LDTR)
195 ADD_SEG(WHvX64RegisterLdtr, pVCpu->cpum.GstCtx.ldtr);
196 if (fWhat & CPUMCTX_EXTRN_TR)
197 ADD_SEG(WHvX64RegisterTr, pVCpu->cpum.GstCtx.tr);
198 if (fWhat & CPUMCTX_EXTRN_IDTR)
199 {
200 aenmNames[iReg] = WHvX64RegisterIdtr;
201 aValues[iReg].Table.Limit = pVCpu->cpum.GstCtx.idtr.cbIdt;
202 aValues[iReg].Table.Base = pVCpu->cpum.GstCtx.idtr.pIdt;
203 iReg++;
204 }
205 if (fWhat & CPUMCTX_EXTRN_GDTR)
206 {
207 aenmNames[iReg] = WHvX64RegisterGdtr;
208 aValues[iReg].Table.Limit = pVCpu->cpum.GstCtx.gdtr.cbGdt;
209 aValues[iReg].Table.Base = pVCpu->cpum.GstCtx.gdtr.pGdt;
210 iReg++;
211 }
212 }
213
214 /* Control registers. */
215 if (fWhat & CPUMCTX_EXTRN_CR_MASK)
216 {
217 if (fWhat & CPUMCTX_EXTRN_CR0)
218 ADD_REG64(WHvX64RegisterCr0, pVCpu->cpum.GstCtx.cr0);
219 if (fWhat & CPUMCTX_EXTRN_CR2)
220 ADD_REG64(WHvX64RegisterCr2, pVCpu->cpum.GstCtx.cr2);
221 if (fWhat & CPUMCTX_EXTRN_CR3)
222 ADD_REG64(WHvX64RegisterCr3, pVCpu->cpum.GstCtx.cr3);
223 if (fWhat & CPUMCTX_EXTRN_CR4)
224 ADD_REG64(WHvX64RegisterCr4, pVCpu->cpum.GstCtx.cr4);
225 }
226 if (fWhat & CPUMCTX_EXTRN_APIC_TPR)
227 ADD_REG64(WHvX64RegisterCr8, CPUMGetGuestCR8(pVCpu));
228
229 /* Debug registers. */
230/** @todo fixme. Figure out what the hyper-v version of KVM_SET_GUEST_DEBUG would be. */
231 if (fWhat & CPUMCTX_EXTRN_DR0_DR3)
232 {
233 ADD_REG64(WHvX64RegisterDr0, pVCpu->cpum.GstCtx.dr[0]); // CPUMGetHyperDR0(pVCpu));
234 ADD_REG64(WHvX64RegisterDr1, pVCpu->cpum.GstCtx.dr[1]); // CPUMGetHyperDR1(pVCpu));
235 ADD_REG64(WHvX64RegisterDr2, pVCpu->cpum.GstCtx.dr[2]); // CPUMGetHyperDR2(pVCpu));
236 ADD_REG64(WHvX64RegisterDr3, pVCpu->cpum.GstCtx.dr[3]); // CPUMGetHyperDR3(pVCpu));
237 }
238 if (fWhat & CPUMCTX_EXTRN_DR6)
239 ADD_REG64(WHvX64RegisterDr6, pVCpu->cpum.GstCtx.dr[6]); // CPUMGetHyperDR6(pVCpu));
240 if (fWhat & CPUMCTX_EXTRN_DR7)
241 ADD_REG64(WHvX64RegisterDr7, pVCpu->cpum.GstCtx.dr[7]); // CPUMGetHyperDR7(pVCpu));
242
243 /* Floating point state. */
244 if (fWhat & CPUMCTX_EXTRN_X87)
245 {
246 ADD_REG128(WHvX64RegisterFpMmx0, pVCpu->cpum.GstCtx.XState.x87.aRegs[0].au64[0], pVCpu->cpum.GstCtx.XState.x87.aRegs[0].au64[1]);
247 ADD_REG128(WHvX64RegisterFpMmx1, pVCpu->cpum.GstCtx.XState.x87.aRegs[1].au64[0], pVCpu->cpum.GstCtx.XState.x87.aRegs[1].au64[1]);
248 ADD_REG128(WHvX64RegisterFpMmx2, pVCpu->cpum.GstCtx.XState.x87.aRegs[2].au64[0], pVCpu->cpum.GstCtx.XState.x87.aRegs[2].au64[1]);
249 ADD_REG128(WHvX64RegisterFpMmx3, pVCpu->cpum.GstCtx.XState.x87.aRegs[3].au64[0], pVCpu->cpum.GstCtx.XState.x87.aRegs[3].au64[1]);
250 ADD_REG128(WHvX64RegisterFpMmx4, pVCpu->cpum.GstCtx.XState.x87.aRegs[4].au64[0], pVCpu->cpum.GstCtx.XState.x87.aRegs[4].au64[1]);
251 ADD_REG128(WHvX64RegisterFpMmx5, pVCpu->cpum.GstCtx.XState.x87.aRegs[5].au64[0], pVCpu->cpum.GstCtx.XState.x87.aRegs[5].au64[1]);
252 ADD_REG128(WHvX64RegisterFpMmx6, pVCpu->cpum.GstCtx.XState.x87.aRegs[6].au64[0], pVCpu->cpum.GstCtx.XState.x87.aRegs[6].au64[1]);
253 ADD_REG128(WHvX64RegisterFpMmx7, pVCpu->cpum.GstCtx.XState.x87.aRegs[7].au64[0], pVCpu->cpum.GstCtx.XState.x87.aRegs[7].au64[1]);
254
255 aenmNames[iReg] = WHvX64RegisterFpControlStatus;
256 aValues[iReg].FpControlStatus.FpControl = pVCpu->cpum.GstCtx.XState.x87.FCW;
257 aValues[iReg].FpControlStatus.FpStatus = pVCpu->cpum.GstCtx.XState.x87.FSW;
258 aValues[iReg].FpControlStatus.FpTag = pVCpu->cpum.GstCtx.XState.x87.FTW;
259 aValues[iReg].FpControlStatus.Reserved = pVCpu->cpum.GstCtx.XState.x87.FTW >> 8;
260 aValues[iReg].FpControlStatus.LastFpOp = pVCpu->cpum.GstCtx.XState.x87.FOP;
261 aValues[iReg].FpControlStatus.LastFpRip = (pVCpu->cpum.GstCtx.XState.x87.FPUIP)
262 | ((uint64_t)pVCpu->cpum.GstCtx.XState.x87.CS << 32)
263 | ((uint64_t)pVCpu->cpum.GstCtx.XState.x87.Rsrvd1 << 48);
264 iReg++;
265
266 aenmNames[iReg] = WHvX64RegisterXmmControlStatus;
267 aValues[iReg].XmmControlStatus.LastFpRdp = (pVCpu->cpum.GstCtx.XState.x87.FPUDP)
268 | ((uint64_t)pVCpu->cpum.GstCtx.XState.x87.DS << 32)
269 | ((uint64_t)pVCpu->cpum.GstCtx.XState.x87.Rsrvd2 << 48);
270 aValues[iReg].XmmControlStatus.XmmStatusControl = pVCpu->cpum.GstCtx.XState.x87.MXCSR;
271 aValues[iReg].XmmControlStatus.XmmStatusControlMask = pVCpu->cpum.GstCtx.XState.x87.MXCSR_MASK; /** @todo ??? (Isn't this an output field?) */
272 iReg++;
273 }
274
275 /* Vector state. */
276 if (fWhat & CPUMCTX_EXTRN_SSE_AVX)
277 {
278 ADD_REG128(WHvX64RegisterXmm0, pVCpu->cpum.GstCtx.XState.x87.aXMM[ 0].uXmm.s.Lo, pVCpu->cpum.GstCtx.XState.x87.aXMM[ 0].uXmm.s.Hi);
279 ADD_REG128(WHvX64RegisterXmm1, pVCpu->cpum.GstCtx.XState.x87.aXMM[ 1].uXmm.s.Lo, pVCpu->cpum.GstCtx.XState.x87.aXMM[ 1].uXmm.s.Hi);
280 ADD_REG128(WHvX64RegisterXmm2, pVCpu->cpum.GstCtx.XState.x87.aXMM[ 2].uXmm.s.Lo, pVCpu->cpum.GstCtx.XState.x87.aXMM[ 2].uXmm.s.Hi);
281 ADD_REG128(WHvX64RegisterXmm3, pVCpu->cpum.GstCtx.XState.x87.aXMM[ 3].uXmm.s.Lo, pVCpu->cpum.GstCtx.XState.x87.aXMM[ 3].uXmm.s.Hi);
282 ADD_REG128(WHvX64RegisterXmm4, pVCpu->cpum.GstCtx.XState.x87.aXMM[ 4].uXmm.s.Lo, pVCpu->cpum.GstCtx.XState.x87.aXMM[ 4].uXmm.s.Hi);
283 ADD_REG128(WHvX64RegisterXmm5, pVCpu->cpum.GstCtx.XState.x87.aXMM[ 5].uXmm.s.Lo, pVCpu->cpum.GstCtx.XState.x87.aXMM[ 5].uXmm.s.Hi);
284 ADD_REG128(WHvX64RegisterXmm6, pVCpu->cpum.GstCtx.XState.x87.aXMM[ 6].uXmm.s.Lo, pVCpu->cpum.GstCtx.XState.x87.aXMM[ 6].uXmm.s.Hi);
285 ADD_REG128(WHvX64RegisterXmm7, pVCpu->cpum.GstCtx.XState.x87.aXMM[ 7].uXmm.s.Lo, pVCpu->cpum.GstCtx.XState.x87.aXMM[ 7].uXmm.s.Hi);
286 ADD_REG128(WHvX64RegisterXmm8, pVCpu->cpum.GstCtx.XState.x87.aXMM[ 8].uXmm.s.Lo, pVCpu->cpum.GstCtx.XState.x87.aXMM[ 8].uXmm.s.Hi);
287 ADD_REG128(WHvX64RegisterXmm9, pVCpu->cpum.GstCtx.XState.x87.aXMM[ 9].uXmm.s.Lo, pVCpu->cpum.GstCtx.XState.x87.aXMM[ 9].uXmm.s.Hi);
288 ADD_REG128(WHvX64RegisterXmm10, pVCpu->cpum.GstCtx.XState.x87.aXMM[10].uXmm.s.Lo, pVCpu->cpum.GstCtx.XState.x87.aXMM[10].uXmm.s.Hi);
289 ADD_REG128(WHvX64RegisterXmm11, pVCpu->cpum.GstCtx.XState.x87.aXMM[11].uXmm.s.Lo, pVCpu->cpum.GstCtx.XState.x87.aXMM[11].uXmm.s.Hi);
290 ADD_REG128(WHvX64RegisterXmm12, pVCpu->cpum.GstCtx.XState.x87.aXMM[12].uXmm.s.Lo, pVCpu->cpum.GstCtx.XState.x87.aXMM[12].uXmm.s.Hi);
291 ADD_REG128(WHvX64RegisterXmm13, pVCpu->cpum.GstCtx.XState.x87.aXMM[13].uXmm.s.Lo, pVCpu->cpum.GstCtx.XState.x87.aXMM[13].uXmm.s.Hi);
292 ADD_REG128(WHvX64RegisterXmm14, pVCpu->cpum.GstCtx.XState.x87.aXMM[14].uXmm.s.Lo, pVCpu->cpum.GstCtx.XState.x87.aXMM[14].uXmm.s.Hi);
293 ADD_REG128(WHvX64RegisterXmm15, pVCpu->cpum.GstCtx.XState.x87.aXMM[15].uXmm.s.Lo, pVCpu->cpum.GstCtx.XState.x87.aXMM[15].uXmm.s.Hi);
294 }
295
296 /* MSRs */
297 // WHvX64RegisterTsc - don't touch
298 if (fWhat & CPUMCTX_EXTRN_EFER)
299 ADD_REG64(WHvX64RegisterEfer, pVCpu->cpum.GstCtx.msrEFER);
300 if (fWhat & CPUMCTX_EXTRN_KERNEL_GS_BASE)
301 ADD_REG64(WHvX64RegisterKernelGsBase, pVCpu->cpum.GstCtx.msrKERNELGSBASE);
302 if (fWhat & CPUMCTX_EXTRN_SYSENTER_MSRS)
303 {
304 ADD_REG64(WHvX64RegisterSysenterCs, pVCpu->cpum.GstCtx.SysEnter.cs);
305 ADD_REG64(WHvX64RegisterSysenterEip, pVCpu->cpum.GstCtx.SysEnter.eip);
306 ADD_REG64(WHvX64RegisterSysenterEsp, pVCpu->cpum.GstCtx.SysEnter.esp);
307 }
308 if (fWhat & CPUMCTX_EXTRN_SYSCALL_MSRS)
309 {
310 ADD_REG64(WHvX64RegisterStar, pVCpu->cpum.GstCtx.msrSTAR);
311 ADD_REG64(WHvX64RegisterLstar, pVCpu->cpum.GstCtx.msrLSTAR);
312 ADD_REG64(WHvX64RegisterCstar, pVCpu->cpum.GstCtx.msrCSTAR);
313 ADD_REG64(WHvX64RegisterSfmask, pVCpu->cpum.GstCtx.msrSFMASK);
314 }
315 if (fWhat & (CPUMCTX_EXTRN_TSC_AUX | CPUMCTX_EXTRN_OTHER_MSRS))
316 {
317 PCPUMCTXMSRS const pCtxMsrs = CPUMQueryGuestCtxMsrsPtr(pVCpu);
318 if (fWhat & CPUMCTX_EXTRN_TSC_AUX)
319 ADD_REG64(WHvX64RegisterTscAux, pCtxMsrs->msr.TscAux);
320 if (fWhat & CPUMCTX_EXTRN_OTHER_MSRS)
321 {
322 ADD_REG64(WHvX64RegisterApicBase, APICGetBaseMsrNoCheck(pVCpu));
323 ADD_REG64(WHvX64RegisterPat, pVCpu->cpum.GstCtx.msrPAT);
324#if 0 /** @todo check if WHvX64RegisterMsrMtrrCap works here... */
325 ADD_REG64(WHvX64RegisterMsrMtrrCap, CPUMGetGuestIa32MtrrCap(pVCpu));
326#endif
327 ADD_REG64(WHvX64RegisterMsrMtrrDefType, pCtxMsrs->msr.MtrrDefType);
328 ADD_REG64(WHvX64RegisterMsrMtrrFix64k00000, pCtxMsrs->msr.MtrrFix64K_00000);
329 ADD_REG64(WHvX64RegisterMsrMtrrFix16k80000, pCtxMsrs->msr.MtrrFix16K_80000);
330 ADD_REG64(WHvX64RegisterMsrMtrrFix16kA0000, pCtxMsrs->msr.MtrrFix16K_A0000);
331 ADD_REG64(WHvX64RegisterMsrMtrrFix4kC0000, pCtxMsrs->msr.MtrrFix4K_C0000);
332 ADD_REG64(WHvX64RegisterMsrMtrrFix4kC8000, pCtxMsrs->msr.MtrrFix4K_C8000);
333 ADD_REG64(WHvX64RegisterMsrMtrrFix4kD0000, pCtxMsrs->msr.MtrrFix4K_D0000);
334 ADD_REG64(WHvX64RegisterMsrMtrrFix4kD8000, pCtxMsrs->msr.MtrrFix4K_D8000);
335 ADD_REG64(WHvX64RegisterMsrMtrrFix4kE0000, pCtxMsrs->msr.MtrrFix4K_E0000);
336 ADD_REG64(WHvX64RegisterMsrMtrrFix4kE8000, pCtxMsrs->msr.MtrrFix4K_E8000);
337 ADD_REG64(WHvX64RegisterMsrMtrrFix4kF0000, pCtxMsrs->msr.MtrrFix4K_F0000);
338 ADD_REG64(WHvX64RegisterMsrMtrrFix4kF8000, pCtxMsrs->msr.MtrrFix4K_F8000);
339#if 0 /** @todo these registers aren't available? Might explain something.. .*/
340 const CPUMCPUVENDOR enmCpuVendor = CPUMGetHostCpuVendor(pVM);
341 if (enmCpuVendor != CPUMCPUVENDOR_AMD)
342 {
343 ADD_REG64(HvX64RegisterIa32MiscEnable, pCtxMsrs->msr.MiscEnable);
344 ADD_REG64(HvX64RegisterIa32FeatureControl, CPUMGetGuestIa32FeatureControl(pVCpu));
345 }
346#endif
347 }
348 }
349
350 /* event injection (clear it). */
351 if (fWhat & CPUMCTX_EXTRN_NEM_WIN_EVENT_INJECT)
352 ADD_REG64(WHvRegisterPendingInterruption, 0);
353
354 /* Interruptibility state. This can get a little complicated since we get
355 half of the state via HV_X64_VP_EXECUTION_STATE. */
356 if ( (fWhat & (CPUMCTX_EXTRN_INHIBIT_INT | CPUMCTX_EXTRN_INHIBIT_NMI))
357 == (CPUMCTX_EXTRN_INHIBIT_INT | CPUMCTX_EXTRN_INHIBIT_NMI) )
358 {
359 ADD_REG64(WHvRegisterInterruptState, 0);
360 if ( VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS)
361 && EMGetInhibitInterruptsPC(pVCpu) == pVCpu->cpum.GstCtx.rip)
362 aValues[iReg - 1].InterruptState.InterruptShadow = 1;
363 if (VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_BLOCK_NMIS))
364 aValues[iReg - 1].InterruptState.NmiMasked = 1;
365 }
366 else if (fWhat & CPUMCTX_EXTRN_INHIBIT_INT)
367 {
368 if ( pVCpu->nem.s.fLastInterruptShadow
369 || ( VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS)
370 && EMGetInhibitInterruptsPC(pVCpu) == pVCpu->cpum.GstCtx.rip))
371 {
372 ADD_REG64(WHvRegisterInterruptState, 0);
373 if ( VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS)
374 && EMGetInhibitInterruptsPC(pVCpu) == pVCpu->cpum.GstCtx.rip)
375 aValues[iReg - 1].InterruptState.InterruptShadow = 1;
376 /** @todo Retrieve NMI state, currently assuming it's zero. (yes this may happen on I/O) */
377 //if (VMCPU_FF_IS_ANY_SET(pVCpu, VMCPU_FF_BLOCK_NMIS))
378 // aValues[iReg - 1].InterruptState.NmiMasked = 1;
379 }
380 }
381 else
382 Assert(!(fWhat & CPUMCTX_EXTRN_INHIBIT_NMI));
383
384 /* Interrupt windows. Always set if active as Hyper-V seems to be forgetful. */
385 uint8_t const fDesiredIntWin = pVCpu->nem.s.fDesiredInterruptWindows;
386 if ( fDesiredIntWin
387 || pVCpu->nem.s.fCurrentInterruptWindows != fDesiredIntWin)
388 {
389 pVCpu->nem.s.fCurrentInterruptWindows = pVCpu->nem.s.fDesiredInterruptWindows;
390 Log8(("Setting WHvX64RegisterDeliverabilityNotifications, fDesiredIntWin=%X\n", fDesiredIntWin));
391 ADD_REG64(WHvX64RegisterDeliverabilityNotifications, fDesiredIntWin);
392 Assert(aValues[iReg - 1].DeliverabilityNotifications.NmiNotification == RT_BOOL(fDesiredIntWin & NEM_WIN_INTW_F_NMI));
393 Assert(aValues[iReg - 1].DeliverabilityNotifications.InterruptNotification == RT_BOOL(fDesiredIntWin & NEM_WIN_INTW_F_REGULAR));
394 Assert(aValues[iReg - 1].DeliverabilityNotifications.InterruptPriority == (unsigned)((fDesiredIntWin & NEM_WIN_INTW_F_PRIO_MASK) >> NEM_WIN_INTW_F_PRIO_SHIFT));
395 }
396
397 /// @todo WHvRegisterPendingEvent
398
399#undef ADD_REG64
400#undef ADD_REG128
401#undef ADD_SEG
402
403 /*
404 * Set the registers.
405 */
406 Assert(iReg < RT_ELEMENTS(aValues));
407 Assert(iReg < RT_ELEMENTS(aenmNames));
408#ifdef NEM_WIN_INTERCEPT_NT_IO_CTLS
409 Log12(("Calling WHvSetVirtualProcessorRegisters(%p, %u, %p, %u, %p)\n",
410 pVM->nem.s.hPartition, pVCpu->idCpu, aenmNames, iReg, aValues));
411#endif
412 HRESULT hrc = WHvSetVirtualProcessorRegisters(pVM->nem.s.hPartition, pVCpu->idCpu, aenmNames, iReg, aValues);
413 if (SUCCEEDED(hrc))
414 {
415 pVCpu->cpum.GstCtx.fExtrn |= CPUMCTX_EXTRN_ALL | CPUMCTX_EXTRN_NEM_WIN_MASK | CPUMCTX_EXTRN_KEEPER_NEM;
416 return VINF_SUCCESS;
417 }
418 AssertLogRelMsgFailed(("WHvSetVirtualProcessorRegisters(%p, %u,,%u,) -> %Rhrc (Last=%#x/%u)\n",
419 pVM->nem.s.hPartition, pVCpu->idCpu, iReg,
420 hrc, RTNtLastStatusValue(), RTNtLastErrorValue()));
421 return VERR_INTERNAL_ERROR;
422}
423
424
425NEM_TMPL_STATIC int nemHCWinCopyStateFromHyperV(PVMCC pVM, PVMCPUCC pVCpu, uint64_t fWhat)
426{
427 WHV_REGISTER_NAME aenmNames[128];
428
429 fWhat &= pVCpu->cpum.GstCtx.fExtrn;
430 uintptr_t iReg = 0;
431
432 /* GPRs */
433 if (fWhat & CPUMCTX_EXTRN_GPRS_MASK)
434 {
435 if (fWhat & CPUMCTX_EXTRN_RAX)
436 aenmNames[iReg++] = WHvX64RegisterRax;
437 if (fWhat & CPUMCTX_EXTRN_RCX)
438 aenmNames[iReg++] = WHvX64RegisterRcx;
439 if (fWhat & CPUMCTX_EXTRN_RDX)
440 aenmNames[iReg++] = WHvX64RegisterRdx;
441 if (fWhat & CPUMCTX_EXTRN_RBX)
442 aenmNames[iReg++] = WHvX64RegisterRbx;
443 if (fWhat & CPUMCTX_EXTRN_RSP)
444 aenmNames[iReg++] = WHvX64RegisterRsp;
445 if (fWhat & CPUMCTX_EXTRN_RBP)
446 aenmNames[iReg++] = WHvX64RegisterRbp;
447 if (fWhat & CPUMCTX_EXTRN_RSI)
448 aenmNames[iReg++] = WHvX64RegisterRsi;
449 if (fWhat & CPUMCTX_EXTRN_RDI)
450 aenmNames[iReg++] = WHvX64RegisterRdi;
451 if (fWhat & CPUMCTX_EXTRN_R8_R15)
452 {
453 aenmNames[iReg++] = WHvX64RegisterR8;
454 aenmNames[iReg++] = WHvX64RegisterR9;
455 aenmNames[iReg++] = WHvX64RegisterR10;
456 aenmNames[iReg++] = WHvX64RegisterR11;
457 aenmNames[iReg++] = WHvX64RegisterR12;
458 aenmNames[iReg++] = WHvX64RegisterR13;
459 aenmNames[iReg++] = WHvX64RegisterR14;
460 aenmNames[iReg++] = WHvX64RegisterR15;
461 }
462 }
463
464 /* RIP & Flags */
465 if (fWhat & CPUMCTX_EXTRN_RIP)
466 aenmNames[iReg++] = WHvX64RegisterRip;
467 if (fWhat & CPUMCTX_EXTRN_RFLAGS)
468 aenmNames[iReg++] = WHvX64RegisterRflags;
469
470 /* Segments */
471 if (fWhat & CPUMCTX_EXTRN_SREG_MASK)
472 {
473 if (fWhat & CPUMCTX_EXTRN_ES)
474 aenmNames[iReg++] = WHvX64RegisterEs;
475 if (fWhat & CPUMCTX_EXTRN_CS)
476 aenmNames[iReg++] = WHvX64RegisterCs;
477 if (fWhat & CPUMCTX_EXTRN_SS)
478 aenmNames[iReg++] = WHvX64RegisterSs;
479 if (fWhat & CPUMCTX_EXTRN_DS)
480 aenmNames[iReg++] = WHvX64RegisterDs;
481 if (fWhat & CPUMCTX_EXTRN_FS)
482 aenmNames[iReg++] = WHvX64RegisterFs;
483 if (fWhat & CPUMCTX_EXTRN_GS)
484 aenmNames[iReg++] = WHvX64RegisterGs;
485 }
486
487 /* Descriptor tables. */
488 if (fWhat & CPUMCTX_EXTRN_TABLE_MASK)
489 {
490 if (fWhat & CPUMCTX_EXTRN_LDTR)
491 aenmNames[iReg++] = WHvX64RegisterLdtr;
492 if (fWhat & CPUMCTX_EXTRN_TR)
493 aenmNames[iReg++] = WHvX64RegisterTr;
494 if (fWhat & CPUMCTX_EXTRN_IDTR)
495 aenmNames[iReg++] = WHvX64RegisterIdtr;
496 if (fWhat & CPUMCTX_EXTRN_GDTR)
497 aenmNames[iReg++] = WHvX64RegisterGdtr;
498 }
499
500 /* Control registers. */
501 if (fWhat & CPUMCTX_EXTRN_CR_MASK)
502 {
503 if (fWhat & CPUMCTX_EXTRN_CR0)
504 aenmNames[iReg++] = WHvX64RegisterCr0;
505 if (fWhat & CPUMCTX_EXTRN_CR2)
506 aenmNames[iReg++] = WHvX64RegisterCr2;
507 if (fWhat & CPUMCTX_EXTRN_CR3)
508 aenmNames[iReg++] = WHvX64RegisterCr3;
509 if (fWhat & CPUMCTX_EXTRN_CR4)
510 aenmNames[iReg++] = WHvX64RegisterCr4;
511 }
512 if (fWhat & CPUMCTX_EXTRN_APIC_TPR)
513 aenmNames[iReg++] = WHvX64RegisterCr8;
514
515 /* Debug registers. */
516 if (fWhat & CPUMCTX_EXTRN_DR7)
517 aenmNames[iReg++] = WHvX64RegisterDr7;
518 if (fWhat & CPUMCTX_EXTRN_DR0_DR3)
519 {
520 if (!(fWhat & CPUMCTX_EXTRN_DR7) && (pVCpu->cpum.GstCtx.fExtrn & CPUMCTX_EXTRN_DR7))
521 {
522 fWhat |= CPUMCTX_EXTRN_DR7;
523 aenmNames[iReg++] = WHvX64RegisterDr7;
524 }
525 aenmNames[iReg++] = WHvX64RegisterDr0;
526 aenmNames[iReg++] = WHvX64RegisterDr1;
527 aenmNames[iReg++] = WHvX64RegisterDr2;
528 aenmNames[iReg++] = WHvX64RegisterDr3;
529 }
530 if (fWhat & CPUMCTX_EXTRN_DR6)
531 aenmNames[iReg++] = WHvX64RegisterDr6;
532
533 /* Floating point state. */
534 if (fWhat & CPUMCTX_EXTRN_X87)
535 {
536 aenmNames[iReg++] = WHvX64RegisterFpMmx0;
537 aenmNames[iReg++] = WHvX64RegisterFpMmx1;
538 aenmNames[iReg++] = WHvX64RegisterFpMmx2;
539 aenmNames[iReg++] = WHvX64RegisterFpMmx3;
540 aenmNames[iReg++] = WHvX64RegisterFpMmx4;
541 aenmNames[iReg++] = WHvX64RegisterFpMmx5;
542 aenmNames[iReg++] = WHvX64RegisterFpMmx6;
543 aenmNames[iReg++] = WHvX64RegisterFpMmx7;
544 aenmNames[iReg++] = WHvX64RegisterFpControlStatus;
545 }
546 if (fWhat & (CPUMCTX_EXTRN_X87 | CPUMCTX_EXTRN_SSE_AVX))
547 aenmNames[iReg++] = WHvX64RegisterXmmControlStatus;
548
549 /* Vector state. */
550 if (fWhat & CPUMCTX_EXTRN_SSE_AVX)
551 {
552 aenmNames[iReg++] = WHvX64RegisterXmm0;
553 aenmNames[iReg++] = WHvX64RegisterXmm1;
554 aenmNames[iReg++] = WHvX64RegisterXmm2;
555 aenmNames[iReg++] = WHvX64RegisterXmm3;
556 aenmNames[iReg++] = WHvX64RegisterXmm4;
557 aenmNames[iReg++] = WHvX64RegisterXmm5;
558 aenmNames[iReg++] = WHvX64RegisterXmm6;
559 aenmNames[iReg++] = WHvX64RegisterXmm7;
560 aenmNames[iReg++] = WHvX64RegisterXmm8;
561 aenmNames[iReg++] = WHvX64RegisterXmm9;
562 aenmNames[iReg++] = WHvX64RegisterXmm10;
563 aenmNames[iReg++] = WHvX64RegisterXmm11;
564 aenmNames[iReg++] = WHvX64RegisterXmm12;
565 aenmNames[iReg++] = WHvX64RegisterXmm13;
566 aenmNames[iReg++] = WHvX64RegisterXmm14;
567 aenmNames[iReg++] = WHvX64RegisterXmm15;
568 }
569
570 /* MSRs */
571 // WHvX64RegisterTsc - don't touch
572 if (fWhat & CPUMCTX_EXTRN_EFER)
573 aenmNames[iReg++] = WHvX64RegisterEfer;
574 if (fWhat & CPUMCTX_EXTRN_KERNEL_GS_BASE)
575 aenmNames[iReg++] = WHvX64RegisterKernelGsBase;
576 if (fWhat & CPUMCTX_EXTRN_SYSENTER_MSRS)
577 {
578 aenmNames[iReg++] = WHvX64RegisterSysenterCs;
579 aenmNames[iReg++] = WHvX64RegisterSysenterEip;
580 aenmNames[iReg++] = WHvX64RegisterSysenterEsp;
581 }
582 if (fWhat & CPUMCTX_EXTRN_SYSCALL_MSRS)
583 {
584 aenmNames[iReg++] = WHvX64RegisterStar;
585 aenmNames[iReg++] = WHvX64RegisterLstar;
586 aenmNames[iReg++] = WHvX64RegisterCstar;
587 aenmNames[iReg++] = WHvX64RegisterSfmask;
588 }
589
590//#ifdef LOG_ENABLED
591// const CPUMCPUVENDOR enmCpuVendor = CPUMGetHostCpuVendor(pVM);
592//#endif
593 if (fWhat & CPUMCTX_EXTRN_TSC_AUX)
594 aenmNames[iReg++] = WHvX64RegisterTscAux;
595 if (fWhat & CPUMCTX_EXTRN_OTHER_MSRS)
596 {
597 aenmNames[iReg++] = WHvX64RegisterApicBase; /// @todo APIC BASE
598 aenmNames[iReg++] = WHvX64RegisterPat;
599#if 0 /*def LOG_ENABLED*/ /** @todo Check if WHvX64RegisterMsrMtrrCap works... */
600 aenmNames[iReg++] = WHvX64RegisterMsrMtrrCap;
601#endif
602 aenmNames[iReg++] = WHvX64RegisterMsrMtrrDefType;
603 aenmNames[iReg++] = WHvX64RegisterMsrMtrrFix64k00000;
604 aenmNames[iReg++] = WHvX64RegisterMsrMtrrFix16k80000;
605 aenmNames[iReg++] = WHvX64RegisterMsrMtrrFix16kA0000;
606 aenmNames[iReg++] = WHvX64RegisterMsrMtrrFix4kC0000;
607 aenmNames[iReg++] = WHvX64RegisterMsrMtrrFix4kC8000;
608 aenmNames[iReg++] = WHvX64RegisterMsrMtrrFix4kD0000;
609 aenmNames[iReg++] = WHvX64RegisterMsrMtrrFix4kD8000;
610 aenmNames[iReg++] = WHvX64RegisterMsrMtrrFix4kE0000;
611 aenmNames[iReg++] = WHvX64RegisterMsrMtrrFix4kE8000;
612 aenmNames[iReg++] = WHvX64RegisterMsrMtrrFix4kF0000;
613 aenmNames[iReg++] = WHvX64RegisterMsrMtrrFix4kF8000;
614 /** @todo look for HvX64RegisterIa32MiscEnable and HvX64RegisterIa32FeatureControl? */
615//#ifdef LOG_ENABLED
616// if (enmCpuVendor != CPUMCPUVENDOR_AMD)
617// aenmNames[iReg++] = HvX64RegisterIa32FeatureControl;
618//#endif
619 }
620
621 /* Interruptibility. */
622 if (fWhat & (CPUMCTX_EXTRN_INHIBIT_INT | CPUMCTX_EXTRN_INHIBIT_NMI))
623 {
624 aenmNames[iReg++] = WHvRegisterInterruptState;
625 aenmNames[iReg++] = WHvX64RegisterRip;
626 }
627
628 /* event injection */
629 aenmNames[iReg++] = WHvRegisterPendingInterruption;
630 aenmNames[iReg++] = WHvRegisterPendingEvent;
631
632 size_t const cRegs = iReg;
633 Assert(cRegs < RT_ELEMENTS(aenmNames));
634
635 /*
636 * Get the registers.
637 */
638 WHV_REGISTER_VALUE aValues[128];
639 RT_ZERO(aValues);
640 Assert(RT_ELEMENTS(aValues) >= cRegs);
641 Assert(RT_ELEMENTS(aenmNames) >= cRegs);
642#ifdef NEM_WIN_INTERCEPT_NT_IO_CTLS
643 Log12(("Calling WHvGetVirtualProcessorRegisters(%p, %u, %p, %u, %p)\n",
644 pVM->nem.s.hPartition, pVCpu->idCpu, aenmNames, cRegs, aValues));
645#endif
646 HRESULT hrc = WHvGetVirtualProcessorRegisters(pVM->nem.s.hPartition, pVCpu->idCpu, aenmNames, (uint32_t)cRegs, aValues);
647 AssertLogRelMsgReturn(SUCCEEDED(hrc),
648 ("WHvGetVirtualProcessorRegisters(%p, %u,,%u,) -> %Rhrc (Last=%#x/%u)\n",
649 pVM->nem.s.hPartition, pVCpu->idCpu, cRegs, hrc, RTNtLastStatusValue(), RTNtLastErrorValue())
650 , VERR_NEM_GET_REGISTERS_FAILED);
651
652 iReg = 0;
653#define GET_REG64(a_DstVar, a_enmName) do { \
654 Assert(aenmNames[iReg] == (a_enmName)); \
655 (a_DstVar) = aValues[iReg].Reg64; \
656 iReg++; \
657 } while (0)
658#define GET_REG64_LOG7(a_DstVar, a_enmName, a_szLogName) do { \
659 Assert(aenmNames[iReg] == (a_enmName)); \
660 if ((a_DstVar) != aValues[iReg].Reg64) \
661 Log7(("NEM/%u: " a_szLogName " changed %RX64 -> %RX64\n", pVCpu->idCpu, (a_DstVar), aValues[iReg].Reg64)); \
662 (a_DstVar) = aValues[iReg].Reg64; \
663 iReg++; \
664 } while (0)
665#define GET_REG128(a_DstVarLo, a_DstVarHi, a_enmName) do { \
666 Assert(aenmNames[iReg] == a_enmName); \
667 (a_DstVarLo) = aValues[iReg].Reg128.Low64; \
668 (a_DstVarHi) = aValues[iReg].Reg128.High64; \
669 iReg++; \
670 } while (0)
671#define GET_SEG(a_SReg, a_enmName) do { \
672 Assert(aenmNames[iReg] == (a_enmName)); \
673 NEM_WIN_COPY_BACK_SEG(a_SReg, aValues[iReg].Segment); \
674 iReg++; \
675 } while (0)
676
677 /* GPRs */
678 if (fWhat & CPUMCTX_EXTRN_GPRS_MASK)
679 {
680 if (fWhat & CPUMCTX_EXTRN_RAX)
681 GET_REG64(pVCpu->cpum.GstCtx.rax, WHvX64RegisterRax);
682 if (fWhat & CPUMCTX_EXTRN_RCX)
683 GET_REG64(pVCpu->cpum.GstCtx.rcx, WHvX64RegisterRcx);
684 if (fWhat & CPUMCTX_EXTRN_RDX)
685 GET_REG64(pVCpu->cpum.GstCtx.rdx, WHvX64RegisterRdx);
686 if (fWhat & CPUMCTX_EXTRN_RBX)
687 GET_REG64(pVCpu->cpum.GstCtx.rbx, WHvX64RegisterRbx);
688 if (fWhat & CPUMCTX_EXTRN_RSP)
689 GET_REG64(pVCpu->cpum.GstCtx.rsp, WHvX64RegisterRsp);
690 if (fWhat & CPUMCTX_EXTRN_RBP)
691 GET_REG64(pVCpu->cpum.GstCtx.rbp, WHvX64RegisterRbp);
692 if (fWhat & CPUMCTX_EXTRN_RSI)
693 GET_REG64(pVCpu->cpum.GstCtx.rsi, WHvX64RegisterRsi);
694 if (fWhat & CPUMCTX_EXTRN_RDI)
695 GET_REG64(pVCpu->cpum.GstCtx.rdi, WHvX64RegisterRdi);
696 if (fWhat & CPUMCTX_EXTRN_R8_R15)
697 {
698 GET_REG64(pVCpu->cpum.GstCtx.r8, WHvX64RegisterR8);
699 GET_REG64(pVCpu->cpum.GstCtx.r9, WHvX64RegisterR9);
700 GET_REG64(pVCpu->cpum.GstCtx.r10, WHvX64RegisterR10);
701 GET_REG64(pVCpu->cpum.GstCtx.r11, WHvX64RegisterR11);
702 GET_REG64(pVCpu->cpum.GstCtx.r12, WHvX64RegisterR12);
703 GET_REG64(pVCpu->cpum.GstCtx.r13, WHvX64RegisterR13);
704 GET_REG64(pVCpu->cpum.GstCtx.r14, WHvX64RegisterR14);
705 GET_REG64(pVCpu->cpum.GstCtx.r15, WHvX64RegisterR15);
706 }
707 }
708
709 /* RIP & Flags */
710 if (fWhat & CPUMCTX_EXTRN_RIP)
711 GET_REG64(pVCpu->cpum.GstCtx.rip, WHvX64RegisterRip);
712 if (fWhat & CPUMCTX_EXTRN_RFLAGS)
713 GET_REG64(pVCpu->cpum.GstCtx.rflags.u, WHvX64RegisterRflags);
714
715 /* Segments */
716 if (fWhat & CPUMCTX_EXTRN_SREG_MASK)
717 {
718 if (fWhat & CPUMCTX_EXTRN_ES)
719 GET_SEG(pVCpu->cpum.GstCtx.es, WHvX64RegisterEs);
720 if (fWhat & CPUMCTX_EXTRN_CS)
721 GET_SEG(pVCpu->cpum.GstCtx.cs, WHvX64RegisterCs);
722 if (fWhat & CPUMCTX_EXTRN_SS)
723 GET_SEG(pVCpu->cpum.GstCtx.ss, WHvX64RegisterSs);
724 if (fWhat & CPUMCTX_EXTRN_DS)
725 GET_SEG(pVCpu->cpum.GstCtx.ds, WHvX64RegisterDs);
726 if (fWhat & CPUMCTX_EXTRN_FS)
727 GET_SEG(pVCpu->cpum.GstCtx.fs, WHvX64RegisterFs);
728 if (fWhat & CPUMCTX_EXTRN_GS)
729 GET_SEG(pVCpu->cpum.GstCtx.gs, WHvX64RegisterGs);
730 }
731
732 /* Descriptor tables and the task segment. */
733 if (fWhat & CPUMCTX_EXTRN_TABLE_MASK)
734 {
735 if (fWhat & CPUMCTX_EXTRN_LDTR)
736 GET_SEG(pVCpu->cpum.GstCtx.ldtr, WHvX64RegisterLdtr);
737
738 if (fWhat & CPUMCTX_EXTRN_TR)
739 {
740 /* AMD-V likes loading TR with in AVAIL state, whereas intel insists on BUSY. So,
741 avoid to trigger sanity assertions around the code, always fix this. */
742 GET_SEG(pVCpu->cpum.GstCtx.tr, WHvX64RegisterTr);
743 switch (pVCpu->cpum.GstCtx.tr.Attr.n.u4Type)
744 {
745 case X86_SEL_TYPE_SYS_386_TSS_BUSY:
746 case X86_SEL_TYPE_SYS_286_TSS_BUSY:
747 break;
748 case X86_SEL_TYPE_SYS_386_TSS_AVAIL:
749 pVCpu->cpum.GstCtx.tr.Attr.n.u4Type = X86_SEL_TYPE_SYS_386_TSS_BUSY;
750 break;
751 case X86_SEL_TYPE_SYS_286_TSS_AVAIL:
752 pVCpu->cpum.GstCtx.tr.Attr.n.u4Type = X86_SEL_TYPE_SYS_286_TSS_BUSY;
753 break;
754 }
755 }
756 if (fWhat & CPUMCTX_EXTRN_IDTR)
757 {
758 Assert(aenmNames[iReg] == WHvX64RegisterIdtr);
759 pVCpu->cpum.GstCtx.idtr.cbIdt = aValues[iReg].Table.Limit;
760 pVCpu->cpum.GstCtx.idtr.pIdt = aValues[iReg].Table.Base;
761 iReg++;
762 }
763 if (fWhat & CPUMCTX_EXTRN_GDTR)
764 {
765 Assert(aenmNames[iReg] == WHvX64RegisterGdtr);
766 pVCpu->cpum.GstCtx.gdtr.cbGdt = aValues[iReg].Table.Limit;
767 pVCpu->cpum.GstCtx.gdtr.pGdt = aValues[iReg].Table.Base;
768 iReg++;
769 }
770 }
771
772 /* Control registers. */
773 bool fMaybeChangedMode = false;
774 bool fUpdateCr3 = false;
775 if (fWhat & CPUMCTX_EXTRN_CR_MASK)
776 {
777 if (fWhat & CPUMCTX_EXTRN_CR0)
778 {
779 Assert(aenmNames[iReg] == WHvX64RegisterCr0);
780 if (pVCpu->cpum.GstCtx.cr0 != aValues[iReg].Reg64)
781 {
782 CPUMSetGuestCR0(pVCpu, aValues[iReg].Reg64);
783 fMaybeChangedMode = true;
784 }
785 iReg++;
786 }
787 if (fWhat & CPUMCTX_EXTRN_CR2)
788 GET_REG64(pVCpu->cpum.GstCtx.cr2, WHvX64RegisterCr2);
789 if (fWhat & CPUMCTX_EXTRN_CR3)
790 {
791 if (pVCpu->cpum.GstCtx.cr3 != aValues[iReg].Reg64)
792 {
793 CPUMSetGuestCR3(pVCpu, aValues[iReg].Reg64);
794 fUpdateCr3 = true;
795 }
796 iReg++;
797 }
798 if (fWhat & CPUMCTX_EXTRN_CR4)
799 {
800 if (pVCpu->cpum.GstCtx.cr4 != aValues[iReg].Reg64)
801 {
802 CPUMSetGuestCR4(pVCpu, aValues[iReg].Reg64);
803 fMaybeChangedMode = true;
804 }
805 iReg++;
806 }
807 }
808 if (fWhat & CPUMCTX_EXTRN_APIC_TPR)
809 {
810 Assert(aenmNames[iReg] == WHvX64RegisterCr8);
811 APICSetTpr(pVCpu, (uint8_t)aValues[iReg].Reg64 << 4);
812 iReg++;
813 }
814
815 /* Debug registers. */
816 if (fWhat & CPUMCTX_EXTRN_DR7)
817 {
818 Assert(aenmNames[iReg] == WHvX64RegisterDr7);
819 if (pVCpu->cpum.GstCtx.dr[7] != aValues[iReg].Reg64)
820 CPUMSetGuestDR7(pVCpu, aValues[iReg].Reg64);
821 pVCpu->cpum.GstCtx.fExtrn &= ~CPUMCTX_EXTRN_DR7; /* Hack alert! Avoids asserting when processing CPUMCTX_EXTRN_DR0_DR3. */
822 iReg++;
823 }
824 if (fWhat & CPUMCTX_EXTRN_DR0_DR3)
825 {
826 Assert(aenmNames[iReg] == WHvX64RegisterDr0);
827 Assert(aenmNames[iReg+3] == WHvX64RegisterDr3);
828 if (pVCpu->cpum.GstCtx.dr[0] != aValues[iReg].Reg64)
829 CPUMSetGuestDR0(pVCpu, aValues[iReg].Reg64);
830 iReg++;
831 if (pVCpu->cpum.GstCtx.dr[1] != aValues[iReg].Reg64)
832 CPUMSetGuestDR1(pVCpu, aValues[iReg].Reg64);
833 iReg++;
834 if (pVCpu->cpum.GstCtx.dr[2] != aValues[iReg].Reg64)
835 CPUMSetGuestDR2(pVCpu, aValues[iReg].Reg64);
836 iReg++;
837 if (pVCpu->cpum.GstCtx.dr[3] != aValues[iReg].Reg64)
838 CPUMSetGuestDR3(pVCpu, aValues[iReg].Reg64);
839 iReg++;
840 }
841 if (fWhat & CPUMCTX_EXTRN_DR6)
842 {
843 Assert(aenmNames[iReg] == WHvX64RegisterDr6);
844 if (pVCpu->cpum.GstCtx.dr[6] != aValues[iReg].Reg64)
845 CPUMSetGuestDR6(pVCpu, aValues[iReg].Reg64);
846 iReg++;
847 }
848
849 /* Floating point state. */
850 if (fWhat & CPUMCTX_EXTRN_X87)
851 {
852 GET_REG128(pVCpu->cpum.GstCtx.XState.x87.aRegs[0].au64[0], pVCpu->cpum.GstCtx.XState.x87.aRegs[0].au64[1], WHvX64RegisterFpMmx0);
853 GET_REG128(pVCpu->cpum.GstCtx.XState.x87.aRegs[1].au64[0], pVCpu->cpum.GstCtx.XState.x87.aRegs[1].au64[1], WHvX64RegisterFpMmx1);
854 GET_REG128(pVCpu->cpum.GstCtx.XState.x87.aRegs[2].au64[0], pVCpu->cpum.GstCtx.XState.x87.aRegs[2].au64[1], WHvX64RegisterFpMmx2);
855 GET_REG128(pVCpu->cpum.GstCtx.XState.x87.aRegs[3].au64[0], pVCpu->cpum.GstCtx.XState.x87.aRegs[3].au64[1], WHvX64RegisterFpMmx3);
856 GET_REG128(pVCpu->cpum.GstCtx.XState.x87.aRegs[4].au64[0], pVCpu->cpum.GstCtx.XState.x87.aRegs[4].au64[1], WHvX64RegisterFpMmx4);
857 GET_REG128(pVCpu->cpum.GstCtx.XState.x87.aRegs[5].au64[0], pVCpu->cpum.GstCtx.XState.x87.aRegs[5].au64[1], WHvX64RegisterFpMmx5);
858 GET_REG128(pVCpu->cpum.GstCtx.XState.x87.aRegs[6].au64[0], pVCpu->cpum.GstCtx.XState.x87.aRegs[6].au64[1], WHvX64RegisterFpMmx6);
859 GET_REG128(pVCpu->cpum.GstCtx.XState.x87.aRegs[7].au64[0], pVCpu->cpum.GstCtx.XState.x87.aRegs[7].au64[1], WHvX64RegisterFpMmx7);
860
861 Assert(aenmNames[iReg] == WHvX64RegisterFpControlStatus);
862 pVCpu->cpum.GstCtx.XState.x87.FCW = aValues[iReg].FpControlStatus.FpControl;
863 pVCpu->cpum.GstCtx.XState.x87.FSW = aValues[iReg].FpControlStatus.FpStatus;
864 pVCpu->cpum.GstCtx.XState.x87.FTW = aValues[iReg].FpControlStatus.FpTag
865 /*| (aValues[iReg].FpControlStatus.Reserved << 8)*/;
866 pVCpu->cpum.GstCtx.XState.x87.FOP = aValues[iReg].FpControlStatus.LastFpOp;
867 pVCpu->cpum.GstCtx.XState.x87.FPUIP = (uint32_t)aValues[iReg].FpControlStatus.LastFpRip;
868 pVCpu->cpum.GstCtx.XState.x87.CS = (uint16_t)(aValues[iReg].FpControlStatus.LastFpRip >> 32);
869 pVCpu->cpum.GstCtx.XState.x87.Rsrvd1 = (uint16_t)(aValues[iReg].FpControlStatus.LastFpRip >> 48);
870 iReg++;
871 }
872
873 if (fWhat & (CPUMCTX_EXTRN_X87 | CPUMCTX_EXTRN_SSE_AVX))
874 {
875 Assert(aenmNames[iReg] == WHvX64RegisterXmmControlStatus);
876 if (fWhat & CPUMCTX_EXTRN_X87)
877 {
878 pVCpu->cpum.GstCtx.XState.x87.FPUDP = (uint32_t)aValues[iReg].XmmControlStatus.LastFpRdp;
879 pVCpu->cpum.GstCtx.XState.x87.DS = (uint16_t)(aValues[iReg].XmmControlStatus.LastFpRdp >> 32);
880 pVCpu->cpum.GstCtx.XState.x87.Rsrvd2 = (uint16_t)(aValues[iReg].XmmControlStatus.LastFpRdp >> 48);
881 }
882 pVCpu->cpum.GstCtx.XState.x87.MXCSR = aValues[iReg].XmmControlStatus.XmmStatusControl;
883 pVCpu->cpum.GstCtx.XState.x87.MXCSR_MASK = aValues[iReg].XmmControlStatus.XmmStatusControlMask; /** @todo ??? (Isn't this an output field?) */
884 iReg++;
885 }
886
887 /* Vector state. */
888 if (fWhat & CPUMCTX_EXTRN_SSE_AVX)
889 {
890 GET_REG128(pVCpu->cpum.GstCtx.XState.x87.aXMM[ 0].uXmm.s.Lo, pVCpu->cpum.GstCtx.XState.x87.aXMM[ 0].uXmm.s.Hi, WHvX64RegisterXmm0);
891 GET_REG128(pVCpu->cpum.GstCtx.XState.x87.aXMM[ 1].uXmm.s.Lo, pVCpu->cpum.GstCtx.XState.x87.aXMM[ 1].uXmm.s.Hi, WHvX64RegisterXmm1);
892 GET_REG128(pVCpu->cpum.GstCtx.XState.x87.aXMM[ 2].uXmm.s.Lo, pVCpu->cpum.GstCtx.XState.x87.aXMM[ 2].uXmm.s.Hi, WHvX64RegisterXmm2);
893 GET_REG128(pVCpu->cpum.GstCtx.XState.x87.aXMM[ 3].uXmm.s.Lo, pVCpu->cpum.GstCtx.XState.x87.aXMM[ 3].uXmm.s.Hi, WHvX64RegisterXmm3);
894 GET_REG128(pVCpu->cpum.GstCtx.XState.x87.aXMM[ 4].uXmm.s.Lo, pVCpu->cpum.GstCtx.XState.x87.aXMM[ 4].uXmm.s.Hi, WHvX64RegisterXmm4);
895 GET_REG128(pVCpu->cpum.GstCtx.XState.x87.aXMM[ 5].uXmm.s.Lo, pVCpu->cpum.GstCtx.XState.x87.aXMM[ 5].uXmm.s.Hi, WHvX64RegisterXmm5);
896 GET_REG128(pVCpu->cpum.GstCtx.XState.x87.aXMM[ 6].uXmm.s.Lo, pVCpu->cpum.GstCtx.XState.x87.aXMM[ 6].uXmm.s.Hi, WHvX64RegisterXmm6);
897 GET_REG128(pVCpu->cpum.GstCtx.XState.x87.aXMM[ 7].uXmm.s.Lo, pVCpu->cpum.GstCtx.XState.x87.aXMM[ 7].uXmm.s.Hi, WHvX64RegisterXmm7);
898 GET_REG128(pVCpu->cpum.GstCtx.XState.x87.aXMM[ 8].uXmm.s.Lo, pVCpu->cpum.GstCtx.XState.x87.aXMM[ 8].uXmm.s.Hi, WHvX64RegisterXmm8);
899 GET_REG128(pVCpu->cpum.GstCtx.XState.x87.aXMM[ 9].uXmm.s.Lo, pVCpu->cpum.GstCtx.XState.x87.aXMM[ 9].uXmm.s.Hi, WHvX64RegisterXmm9);
900 GET_REG128(pVCpu->cpum.GstCtx.XState.x87.aXMM[10].uXmm.s.Lo, pVCpu->cpum.GstCtx.XState.x87.aXMM[10].uXmm.s.Hi, WHvX64RegisterXmm10);
901 GET_REG128(pVCpu->cpum.GstCtx.XState.x87.aXMM[11].uXmm.s.Lo, pVCpu->cpum.GstCtx.XState.x87.aXMM[11].uXmm.s.Hi, WHvX64RegisterXmm11);
902 GET_REG128(pVCpu->cpum.GstCtx.XState.x87.aXMM[12].uXmm.s.Lo, pVCpu->cpum.GstCtx.XState.x87.aXMM[12].uXmm.s.Hi, WHvX64RegisterXmm12);
903 GET_REG128(pVCpu->cpum.GstCtx.XState.x87.aXMM[13].uXmm.s.Lo, pVCpu->cpum.GstCtx.XState.x87.aXMM[13].uXmm.s.Hi, WHvX64RegisterXmm13);
904 GET_REG128(pVCpu->cpum.GstCtx.XState.x87.aXMM[14].uXmm.s.Lo, pVCpu->cpum.GstCtx.XState.x87.aXMM[14].uXmm.s.Hi, WHvX64RegisterXmm14);
905 GET_REG128(pVCpu->cpum.GstCtx.XState.x87.aXMM[15].uXmm.s.Lo, pVCpu->cpum.GstCtx.XState.x87.aXMM[15].uXmm.s.Hi, WHvX64RegisterXmm15);
906 }
907
908 /* MSRs */
909 // WHvX64RegisterTsc - don't touch
910 if (fWhat & CPUMCTX_EXTRN_EFER)
911 {
912 Assert(aenmNames[iReg] == WHvX64RegisterEfer);
913 if (aValues[iReg].Reg64 != pVCpu->cpum.GstCtx.msrEFER)
914 {
915 Log7(("NEM/%u: MSR EFER changed %RX64 -> %RX64\n", pVCpu->idCpu, pVCpu->cpum.GstCtx.msrEFER, aValues[iReg].Reg64));
916 if ((aValues[iReg].Reg64 ^ pVCpu->cpum.GstCtx.msrEFER) & MSR_K6_EFER_NXE)
917 PGMNotifyNxeChanged(pVCpu, RT_BOOL(aValues[iReg].Reg64 & MSR_K6_EFER_NXE));
918 pVCpu->cpum.GstCtx.msrEFER = aValues[iReg].Reg64;
919 fMaybeChangedMode = true;
920 }
921 iReg++;
922 }
923 if (fWhat & CPUMCTX_EXTRN_KERNEL_GS_BASE)
924 GET_REG64_LOG7(pVCpu->cpum.GstCtx.msrKERNELGSBASE, WHvX64RegisterKernelGsBase, "MSR KERNEL_GS_BASE");
925 if (fWhat & CPUMCTX_EXTRN_SYSENTER_MSRS)
926 {
927 GET_REG64_LOG7(pVCpu->cpum.GstCtx.SysEnter.cs, WHvX64RegisterSysenterCs, "MSR SYSENTER.CS");
928 GET_REG64_LOG7(pVCpu->cpum.GstCtx.SysEnter.eip, WHvX64RegisterSysenterEip, "MSR SYSENTER.EIP");
929 GET_REG64_LOG7(pVCpu->cpum.GstCtx.SysEnter.esp, WHvX64RegisterSysenterEsp, "MSR SYSENTER.ESP");
930 }
931 if (fWhat & CPUMCTX_EXTRN_SYSCALL_MSRS)
932 {
933 GET_REG64_LOG7(pVCpu->cpum.GstCtx.msrSTAR, WHvX64RegisterStar, "MSR STAR");
934 GET_REG64_LOG7(pVCpu->cpum.GstCtx.msrLSTAR, WHvX64RegisterLstar, "MSR LSTAR");
935 GET_REG64_LOG7(pVCpu->cpum.GstCtx.msrCSTAR, WHvX64RegisterCstar, "MSR CSTAR");
936 GET_REG64_LOG7(pVCpu->cpum.GstCtx.msrSFMASK, WHvX64RegisterSfmask, "MSR SFMASK");
937 }
938 if (fWhat & (CPUMCTX_EXTRN_TSC_AUX | CPUMCTX_EXTRN_OTHER_MSRS))
939 {
940 PCPUMCTXMSRS const pCtxMsrs = CPUMQueryGuestCtxMsrsPtr(pVCpu);
941 if (fWhat & CPUMCTX_EXTRN_TSC_AUX)
942 GET_REG64_LOG7(pCtxMsrs->msr.TscAux, WHvX64RegisterTscAux, "MSR TSC_AUX");
943 if (fWhat & CPUMCTX_EXTRN_OTHER_MSRS)
944 {
945 Assert(aenmNames[iReg] == WHvX64RegisterApicBase);
946 const uint64_t uOldBase = APICGetBaseMsrNoCheck(pVCpu);
947 if (aValues[iReg].Reg64 != uOldBase)
948 {
949 Log7(("NEM/%u: MSR APICBase changed %RX64 -> %RX64 (%RX64)\n",
950 pVCpu->idCpu, uOldBase, aValues[iReg].Reg64, aValues[iReg].Reg64 ^ uOldBase));
951 int rc2 = APICSetBaseMsr(pVCpu, aValues[iReg].Reg64);
952 AssertLogRelMsg(rc2 == VINF_SUCCESS, ("%Rrc %RX64\n", rc2, aValues[iReg].Reg64));
953 }
954 iReg++;
955
956 GET_REG64_LOG7(pVCpu->cpum.GstCtx.msrPAT, WHvX64RegisterPat, "MSR PAT");
957#if 0 /*def LOG_ENABLED*/ /** @todo something's wrong with HvX64RegisterMtrrCap? (AMD) */
958 GET_REG64_LOG7(pVCpu->cpum.GstCtx.msrPAT, WHvX64RegisterMsrMtrrCap);
959#endif
960 GET_REG64_LOG7(pCtxMsrs->msr.MtrrDefType, WHvX64RegisterMsrMtrrDefType, "MSR MTRR_DEF_TYPE");
961 GET_REG64_LOG7(pCtxMsrs->msr.MtrrFix64K_00000, WHvX64RegisterMsrMtrrFix64k00000, "MSR MTRR_FIX_64K_00000");
962 GET_REG64_LOG7(pCtxMsrs->msr.MtrrFix16K_80000, WHvX64RegisterMsrMtrrFix16k80000, "MSR MTRR_FIX_16K_80000");
963 GET_REG64_LOG7(pCtxMsrs->msr.MtrrFix16K_A0000, WHvX64RegisterMsrMtrrFix16kA0000, "MSR MTRR_FIX_16K_A0000");
964 GET_REG64_LOG7(pCtxMsrs->msr.MtrrFix4K_C0000, WHvX64RegisterMsrMtrrFix4kC0000, "MSR MTRR_FIX_4K_C0000");
965 GET_REG64_LOG7(pCtxMsrs->msr.MtrrFix4K_C8000, WHvX64RegisterMsrMtrrFix4kC8000, "MSR MTRR_FIX_4K_C8000");
966 GET_REG64_LOG7(pCtxMsrs->msr.MtrrFix4K_D0000, WHvX64RegisterMsrMtrrFix4kD0000, "MSR MTRR_FIX_4K_D0000");
967 GET_REG64_LOG7(pCtxMsrs->msr.MtrrFix4K_D8000, WHvX64RegisterMsrMtrrFix4kD8000, "MSR MTRR_FIX_4K_D8000");
968 GET_REG64_LOG7(pCtxMsrs->msr.MtrrFix4K_E0000, WHvX64RegisterMsrMtrrFix4kE0000, "MSR MTRR_FIX_4K_E0000");
969 GET_REG64_LOG7(pCtxMsrs->msr.MtrrFix4K_E8000, WHvX64RegisterMsrMtrrFix4kE8000, "MSR MTRR_FIX_4K_E8000");
970 GET_REG64_LOG7(pCtxMsrs->msr.MtrrFix4K_F0000, WHvX64RegisterMsrMtrrFix4kF0000, "MSR MTRR_FIX_4K_F0000");
971 GET_REG64_LOG7(pCtxMsrs->msr.MtrrFix4K_F8000, WHvX64RegisterMsrMtrrFix4kF8000, "MSR MTRR_FIX_4K_F8000");
972 /** @todo look for HvX64RegisterIa32MiscEnable and HvX64RegisterIa32FeatureControl? */
973 }
974 }
975
976 /* Interruptibility. */
977 if (fWhat & (CPUMCTX_EXTRN_INHIBIT_INT | CPUMCTX_EXTRN_INHIBIT_NMI))
978 {
979 Assert(aenmNames[iReg] == WHvRegisterInterruptState);
980 Assert(aenmNames[iReg + 1] == WHvX64RegisterRip);
981
982 if (!(pVCpu->cpum.GstCtx.fExtrn & CPUMCTX_EXTRN_INHIBIT_INT))
983 {
984 pVCpu->nem.s.fLastInterruptShadow = aValues[iReg].InterruptState.InterruptShadow;
985 if (aValues[iReg].InterruptState.InterruptShadow)
986 EMSetInhibitInterruptsPC(pVCpu, aValues[iReg + 1].Reg64);
987 else
988 VMCPU_FF_CLEAR(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS);
989 }
990
991 if (!(pVCpu->cpum.GstCtx.fExtrn & CPUMCTX_EXTRN_INHIBIT_NMI))
992 {
993 if (aValues[iReg].InterruptState.NmiMasked)
994 VMCPU_FF_SET(pVCpu, VMCPU_FF_BLOCK_NMIS);
995 else
996 VMCPU_FF_CLEAR(pVCpu, VMCPU_FF_BLOCK_NMIS);
997 }
998
999 fWhat |= CPUMCTX_EXTRN_INHIBIT_INT | CPUMCTX_EXTRN_INHIBIT_NMI;
1000 iReg += 2;
1001 }
1002
1003 /* Event injection. */
1004 /// @todo WHvRegisterPendingInterruption
1005 Assert(aenmNames[iReg] == WHvRegisterPendingInterruption);
1006 if (aValues[iReg].PendingInterruption.InterruptionPending)
1007 {
1008 Log7(("PendingInterruption: type=%u vector=%#x errcd=%RTbool/%#x instr-len=%u nested=%u\n",
1009 aValues[iReg].PendingInterruption.InterruptionType, aValues[iReg].PendingInterruption.InterruptionVector,
1010 aValues[iReg].PendingInterruption.DeliverErrorCode, aValues[iReg].PendingInterruption.ErrorCode,
1011 aValues[iReg].PendingInterruption.InstructionLength, aValues[iReg].PendingInterruption.NestedEvent));
1012 AssertMsg((aValues[iReg].PendingInterruption.AsUINT64 & UINT64_C(0xfc00)) == 0,
1013 ("%#RX64\n", aValues[iReg].PendingInterruption.AsUINT64));
1014 }
1015
1016 /// @todo WHvRegisterPendingEvent
1017
1018 /* Almost done, just update extrn flags and maybe change PGM mode. */
1019 pVCpu->cpum.GstCtx.fExtrn &= ~fWhat;
1020 if (!(pVCpu->cpum.GstCtx.fExtrn & (CPUMCTX_EXTRN_ALL | (CPUMCTX_EXTRN_NEM_WIN_MASK & ~CPUMCTX_EXTRN_NEM_WIN_EVENT_INJECT))))
1021 pVCpu->cpum.GstCtx.fExtrn = 0;
1022
1023 /* Typical. */
1024 if (!fMaybeChangedMode && !fUpdateCr3)
1025 return VINF_SUCCESS;
1026
1027 /*
1028 * Slow.
1029 */
1030 if (fMaybeChangedMode)
1031 {
1032 int rc = PGMChangeMode(pVCpu, pVCpu->cpum.GstCtx.cr0, pVCpu->cpum.GstCtx.cr4, pVCpu->cpum.GstCtx.msrEFER,
1033 false /* fForce */);
1034 AssertMsgReturn(rc == VINF_SUCCESS, ("rc=%Rrc\n", rc), RT_FAILURE_NP(rc) ? rc : VERR_NEM_IPE_1);
1035 }
1036
1037 if (fUpdateCr3)
1038 {
1039 int rc = PGMUpdateCR3(pVCpu, pVCpu->cpum.GstCtx.cr3);
1040 if (rc == VINF_SUCCESS)
1041 { /* likely */ }
1042 else
1043 AssertMsgFailedReturn(("rc=%Rrc\n", rc), RT_FAILURE_NP(rc) ? rc : VERR_NEM_IPE_2);
1044 }
1045
1046 return VINF_SUCCESS;
1047}
1048
1049
1050/**
1051 * Interface for importing state on demand (used by IEM).
1052 *
1053 * @returns VBox status code.
1054 * @param pVCpu The cross context CPU structure.
1055 * @param fWhat What to import, CPUMCTX_EXTRN_XXX.
1056 */
1057VMM_INT_DECL(int) NEMImportStateOnDemand(PVMCPUCC pVCpu, uint64_t fWhat)
1058{
1059 STAM_REL_COUNTER_INC(&pVCpu->nem.s.StatImportOnDemand);
1060 return nemHCWinCopyStateFromHyperV(pVCpu->pVMR3, pVCpu, fWhat);
1061}
1062
1063
1064/**
1065 * Query the CPU tick counter and optionally the TSC_AUX MSR value.
1066 *
1067 * @returns VBox status code.
1068 * @param pVCpu The cross context CPU structure.
1069 * @param pcTicks Where to return the CPU tick count.
1070 * @param puAux Where to return the TSC_AUX register value.
1071 */
1072VMM_INT_DECL(int) NEMHCQueryCpuTick(PVMCPUCC pVCpu, uint64_t *pcTicks, uint32_t *puAux)
1073{
1074 STAM_REL_COUNTER_INC(&pVCpu->nem.s.StatQueryCpuTick);
1075
1076 PVMCC pVM = pVCpu->CTX_SUFF(pVM);
1077 VMCPU_ASSERT_EMT_RETURN(pVCpu, VERR_VM_THREAD_NOT_EMT);
1078 AssertReturn(VM_IS_NEM_ENABLED(pVM), VERR_NEM_IPE_9);
1079
1080 /* Call the offical API. */
1081 WHV_REGISTER_NAME aenmNames[2] = { WHvX64RegisterTsc, WHvX64RegisterTscAux };
1082 WHV_REGISTER_VALUE aValues[2] = { { {0, 0} }, { {0, 0} } };
1083 Assert(RT_ELEMENTS(aenmNames) == RT_ELEMENTS(aValues));
1084 HRESULT hrc = WHvGetVirtualProcessorRegisters(pVM->nem.s.hPartition, pVCpu->idCpu, aenmNames, 2, aValues);
1085 AssertLogRelMsgReturn(SUCCEEDED(hrc),
1086 ("WHvGetVirtualProcessorRegisters(%p, %u,{tsc,tsc_aux},2,) -> %Rhrc (Last=%#x/%u)\n",
1087 pVM->nem.s.hPartition, pVCpu->idCpu, hrc, RTNtLastStatusValue(), RTNtLastErrorValue())
1088 , VERR_NEM_GET_REGISTERS_FAILED);
1089 *pcTicks = aValues[0].Reg64;
1090 if (puAux)
1091 *puAux = pVCpu->cpum.GstCtx.fExtrn & CPUMCTX_EXTRN_TSC_AUX ? aValues[1].Reg64 : CPUMGetGuestTscAux(pVCpu);
1092 return VINF_SUCCESS;
1093}
1094
1095
1096/**
1097 * Resumes CPU clock (TSC) on all virtual CPUs.
1098 *
1099 * This is called by TM when the VM is started, restored, resumed or similar.
1100 *
1101 * @returns VBox status code.
1102 * @param pVM The cross context VM structure.
1103 * @param pVCpu The cross context CPU structure of the calling EMT.
1104 * @param uPausedTscValue The TSC value at the time of pausing.
1105 */
1106VMM_INT_DECL(int) NEMHCResumeCpuTickOnAll(PVMCC pVM, PVMCPUCC pVCpu, uint64_t uPausedTscValue)
1107{
1108 VMCPU_ASSERT_EMT_RETURN(pVCpu, VERR_VM_THREAD_NOT_EMT);
1109 AssertReturn(VM_IS_NEM_ENABLED(pVM), VERR_NEM_IPE_9);
1110
1111 /*
1112 * Call the offical API to do the job.
1113 */
1114 if (pVM->cCpus > 1)
1115 RTThreadYield(); /* Try decrease the chance that we get rescheduled in the middle. */
1116
1117 /* Start with the first CPU. */
1118 WHV_REGISTER_NAME enmName = WHvX64RegisterTsc;
1119 WHV_REGISTER_VALUE Value = { {0, 0} };
1120 Value.Reg64 = uPausedTscValue;
1121 uint64_t const uFirstTsc = ASMReadTSC();
1122 HRESULT hrc = WHvSetVirtualProcessorRegisters(pVM->nem.s.hPartition, 0 /*iCpu*/, &enmName, 1, &Value);
1123 AssertLogRelMsgReturn(SUCCEEDED(hrc),
1124 ("WHvSetVirtualProcessorRegisters(%p, 0,{tsc},2,%#RX64) -> %Rhrc (Last=%#x/%u)\n",
1125 pVM->nem.s.hPartition, uPausedTscValue, hrc, RTNtLastStatusValue(), RTNtLastErrorValue())
1126 , VERR_NEM_SET_TSC);
1127
1128 /* Do the other CPUs, adjusting for elapsed TSC and keeping finger crossed
1129 that we don't introduce too much drift here. */
1130 for (VMCPUID iCpu = 1; iCpu < pVM->cCpus; iCpu++)
1131 {
1132 Assert(enmName == WHvX64RegisterTsc);
1133 const uint64_t offDelta = (ASMReadTSC() - uFirstTsc);
1134 Value.Reg64 = uPausedTscValue + offDelta;
1135 hrc = WHvSetVirtualProcessorRegisters(pVM->nem.s.hPartition, iCpu, &enmName, 1, &Value);
1136 AssertLogRelMsgReturn(SUCCEEDED(hrc),
1137 ("WHvSetVirtualProcessorRegisters(%p, 0,{tsc},2,%#RX64 + %#RX64) -> %Rhrc (Last=%#x/%u)\n",
1138 pVM->nem.s.hPartition, iCpu, uPausedTscValue, offDelta, hrc, RTNtLastStatusValue(), RTNtLastErrorValue())
1139 , VERR_NEM_SET_TSC);
1140 }
1141
1142 return VINF_SUCCESS;
1143}
1144
1145#ifdef LOG_ENABLED
1146
1147/**
1148 * Get the virtual processor running status.
1149 */
1150DECLINLINE(VID_PROCESSOR_STATUS) nemHCWinCpuGetRunningStatus(PVMCPUCC pVCpu)
1151{
1152 RTERRVARS Saved;
1153 RTErrVarsSave(&Saved);
1154
1155 /*
1156 * This API is disabled in release builds, it seems. On build 17101 it requires
1157 * the following patch to be enabled (windbg): eb vid+12180 0f 84 98 00 00 00
1158 */
1159 VID_PROCESSOR_STATUS enmCpuStatus = VidProcessorStatusUndefined;
1160 NTSTATUS rcNt = g_pfnVidGetVirtualProcessorRunningStatus(pVCpu->pVMR3->nem.s.hPartitionDevice, pVCpu->idCpu, &enmCpuStatus);
1161 AssertRC(rcNt);
1162
1163 RTErrVarsRestore(&Saved);
1164 return enmCpuStatus;
1165}
1166
1167
1168/**
1169 * Logs the current CPU state.
1170 */
1171NEM_TMPL_STATIC void nemHCWinLogState(PVMCC pVM, PVMCPUCC pVCpu)
1172{
1173 if (LogIs3Enabled())
1174 {
1175# if 0 // def IN_RING3 - causes lazy state import assertions all over CPUM.
1176 char szRegs[4096];
1177 DBGFR3RegPrintf(pVM->pUVM, pVCpu->idCpu, &szRegs[0], sizeof(szRegs),
1178 "rax=%016VR{rax} rbx=%016VR{rbx} rcx=%016VR{rcx} rdx=%016VR{rdx}\n"
1179 "rsi=%016VR{rsi} rdi=%016VR{rdi} r8 =%016VR{r8} r9 =%016VR{r9}\n"
1180 "r10=%016VR{r10} r11=%016VR{r11} r12=%016VR{r12} r13=%016VR{r13}\n"
1181 "r14=%016VR{r14} r15=%016VR{r15} %VRF{rflags}\n"
1182 "rip=%016VR{rip} rsp=%016VR{rsp} rbp=%016VR{rbp}\n"
1183 "cs={%04VR{cs} base=%016VR{cs_base} limit=%08VR{cs_lim} flags=%04VR{cs_attr}} cr0=%016VR{cr0}\n"
1184 "ds={%04VR{ds} base=%016VR{ds_base} limit=%08VR{ds_lim} flags=%04VR{ds_attr}} cr2=%016VR{cr2}\n"
1185 "es={%04VR{es} base=%016VR{es_base} limit=%08VR{es_lim} flags=%04VR{es_attr}} cr3=%016VR{cr3}\n"
1186 "fs={%04VR{fs} base=%016VR{fs_base} limit=%08VR{fs_lim} flags=%04VR{fs_attr}} cr4=%016VR{cr4}\n"
1187 "gs={%04VR{gs} base=%016VR{gs_base} limit=%08VR{gs_lim} flags=%04VR{gs_attr}} cr8=%016VR{cr8}\n"
1188 "ss={%04VR{ss} base=%016VR{ss_base} limit=%08VR{ss_lim} flags=%04VR{ss_attr}}\n"
1189 "dr0=%016VR{dr0} dr1=%016VR{dr1} dr2=%016VR{dr2} dr3=%016VR{dr3}\n"
1190 "dr6=%016VR{dr6} dr7=%016VR{dr7}\n"
1191 "gdtr=%016VR{gdtr_base}:%04VR{gdtr_lim} idtr=%016VR{idtr_base}:%04VR{idtr_lim} rflags=%08VR{rflags}\n"
1192 "ldtr={%04VR{ldtr} base=%016VR{ldtr_base} limit=%08VR{ldtr_lim} flags=%08VR{ldtr_attr}}\n"
1193 "tr ={%04VR{tr} base=%016VR{tr_base} limit=%08VR{tr_lim} flags=%08VR{tr_attr}}\n"
1194 " sysenter={cs=%04VR{sysenter_cs} eip=%08VR{sysenter_eip} esp=%08VR{sysenter_esp}}\n"
1195 " efer=%016VR{efer}\n"
1196 " pat=%016VR{pat}\n"
1197 " sf_mask=%016VR{sf_mask}\n"
1198 "krnl_gs_base=%016VR{krnl_gs_base}\n"
1199 " lstar=%016VR{lstar}\n"
1200 " star=%016VR{star} cstar=%016VR{cstar}\n"
1201 "fcw=%04VR{fcw} fsw=%04VR{fsw} ftw=%04VR{ftw} mxcsr=%04VR{mxcsr} mxcsr_mask=%04VR{mxcsr_mask}\n"
1202 );
1203
1204 char szInstr[256];
1205 DBGFR3DisasInstrEx(pVM->pUVM, pVCpu->idCpu, 0, 0,
1206 DBGF_DISAS_FLAGS_CURRENT_GUEST | DBGF_DISAS_FLAGS_DEFAULT_MODE,
1207 szInstr, sizeof(szInstr), NULL);
1208 Log3(("%s%s\n", szRegs, szInstr));
1209# else
1210 /** @todo stat logging in ring-0 */
1211 RT_NOREF(pVM, pVCpu);
1212# endif
1213 }
1214}
1215
1216#endif /* LOG_ENABLED */
1217
1218/**
1219 * Translates the execution stat bitfield into a short log string, WinHv version.
1220 *
1221 * @returns Read-only log string.
1222 * @param pExitCtx The exit context which state to summarize.
1223 */
1224static const char *nemR3WinExecStateToLogStr(WHV_VP_EXIT_CONTEXT const *pExitCtx)
1225{
1226 unsigned u = (unsigned)pExitCtx->ExecutionState.InterruptionPending
1227 | ((unsigned)pExitCtx->ExecutionState.DebugActive << 1)
1228 | ((unsigned)pExitCtx->ExecutionState.InterruptShadow << 2);
1229#define SWITCH_IT(a_szPrefix) \
1230 do \
1231 switch (u)\
1232 { \
1233 case 0x00: return a_szPrefix ""; \
1234 case 0x01: return a_szPrefix ",Pnd"; \
1235 case 0x02: return a_szPrefix ",Dbg"; \
1236 case 0x03: return a_szPrefix ",Pnd,Dbg"; \
1237 case 0x04: return a_szPrefix ",Shw"; \
1238 case 0x05: return a_szPrefix ",Pnd,Shw"; \
1239 case 0x06: return a_szPrefix ",Shw,Dbg"; \
1240 case 0x07: return a_szPrefix ",Pnd,Shw,Dbg"; \
1241 default: AssertFailedReturn("WTF?"); \
1242 } \
1243 while (0)
1244 if (pExitCtx->ExecutionState.EferLma)
1245 SWITCH_IT("LM");
1246 else if (pExitCtx->ExecutionState.Cr0Pe)
1247 SWITCH_IT("PM");
1248 else
1249 SWITCH_IT("RM");
1250#undef SWITCH_IT
1251}
1252
1253
1254/**
1255 * Advances the guest RIP and clear EFLAGS.RF, WinHv version.
1256 *
1257 * This may clear VMCPU_FF_INHIBIT_INTERRUPTS.
1258 *
1259 * @param pVCpu The cross context virtual CPU structure.
1260 * @param pExitCtx The exit context.
1261 * @param cbMinInstr The minimum instruction length, or 1 if not unknown.
1262 */
1263DECLINLINE(void) nemR3WinAdvanceGuestRipAndClearRF(PVMCPUCC pVCpu, WHV_VP_EXIT_CONTEXT const *pExitCtx, uint8_t cbMinInstr)
1264{
1265 Assert(!(pVCpu->cpum.GstCtx.fExtrn & (CPUMCTX_EXTRN_RIP | CPUMCTX_EXTRN_RFLAGS)));
1266
1267 /* Advance the RIP. */
1268 Assert(pExitCtx->InstructionLength >= cbMinInstr); RT_NOREF_PV(cbMinInstr);
1269 pVCpu->cpum.GstCtx.rip += pExitCtx->InstructionLength;
1270 pVCpu->cpum.GstCtx.rflags.Bits.u1RF = 0;
1271
1272 /* Update interrupt inhibition. */
1273 if (!VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS))
1274 { /* likely */ }
1275 else if (pVCpu->cpum.GstCtx.rip != EMGetInhibitInterruptsPC(pVCpu))
1276 VMCPU_FF_CLEAR(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS);
1277}
1278
1279
1280/**
1281 * State to pass between nemHCWinHandleMemoryAccess / nemR3WinWHvHandleMemoryAccess
1282 * and nemHCWinHandleMemoryAccessPageCheckerCallback.
1283 */
1284typedef struct NEMHCWINHMACPCCSTATE
1285{
1286 /** Input: Write access. */
1287 bool fWriteAccess;
1288 /** Output: Set if we did something. */
1289 bool fDidSomething;
1290 /** Output: Set it we should resume. */
1291 bool fCanResume;
1292} NEMHCWINHMACPCCSTATE;
1293
1294/**
1295 * @callback_method_impl{FNPGMPHYSNEMCHECKPAGE,
1296 * Worker for nemR3WinHandleMemoryAccess; pvUser points to a
1297 * NEMHCWINHMACPCCSTATE structure. }
1298 */
1299NEM_TMPL_STATIC DECLCALLBACK(int)
1300nemHCWinHandleMemoryAccessPageCheckerCallback(PVMCC pVM, PVMCPUCC pVCpu, RTGCPHYS GCPhys, PPGMPHYSNEMPAGEINFO pInfo, void *pvUser)
1301{
1302 NEMHCWINHMACPCCSTATE *pState = (NEMHCWINHMACPCCSTATE *)pvUser;
1303 pState->fDidSomething = false;
1304 pState->fCanResume = false;
1305
1306 /* If A20 is disabled, we may need to make another query on the masked
1307 page to get the correct protection information. */
1308 uint8_t u2State = pInfo->u2NemState;
1309 RTGCPHYS GCPhysSrc;
1310#ifdef NEM_WIN_WITH_A20
1311 if ( pVM->nem.s.fA20Enabled
1312 || !NEM_WIN_IS_SUBJECT_TO_A20(GCPhys))
1313#endif
1314 GCPhysSrc = GCPhys;
1315#ifdef NEM_WIN_WITH_A20
1316 else
1317 {
1318 GCPhysSrc = GCPhys & ~(RTGCPHYS)RT_BIT_32(20);
1319 PGMPHYSNEMPAGEINFO Info2;
1320 int rc = PGMPhysNemPageInfoChecker(pVM, pVCpu, GCPhysSrc, pState->fWriteAccess, &Info2, NULL, NULL);
1321 AssertRCReturn(rc, rc);
1322
1323 *pInfo = Info2;
1324 pInfo->u2NemState = u2State;
1325 }
1326#endif
1327
1328 /*
1329 * Consolidate current page state with actual page protection and access type.
1330 * We don't really consider downgrades here, as they shouldn't happen.
1331 */
1332 /** @todo Someone at microsoft please explain:
1333 * I'm not sure WTF was going on, but I ended up in a loop if I remapped a
1334 * readonly page as writable (unmap, then map again). Specifically, this was an
1335 * issue with the big VRAM mapping at 0xe0000000 when booing DSL 4.4.1. So, in
1336 * a hope to work around that we no longer pre-map anything, just unmap stuff
1337 * and do it lazily here. And here we will first unmap, restart, and then remap
1338 * with new protection or backing.
1339 */
1340 int rc;
1341 switch (u2State)
1342 {
1343 case NEM_WIN_PAGE_STATE_UNMAPPED:
1344 case NEM_WIN_PAGE_STATE_NOT_SET:
1345 if (pInfo->fNemProt == NEM_PAGE_PROT_NONE)
1346 {
1347 Log4(("nemHCWinHandleMemoryAccessPageCheckerCallback: %RGp - #1\n", GCPhys));
1348 return VINF_SUCCESS;
1349 }
1350
1351 /* Don't bother remapping it if it's a write request to a non-writable page. */
1352 if ( pState->fWriteAccess
1353 && !(pInfo->fNemProt & NEM_PAGE_PROT_WRITE))
1354 {
1355 Log4(("nemHCWinHandleMemoryAccessPageCheckerCallback: %RGp - #1w\n", GCPhys));
1356 return VINF_SUCCESS;
1357 }
1358
1359 /* Map the page. */
1360 rc = nemHCNativeSetPhysPage(pVM,
1361 pVCpu,
1362 GCPhysSrc & ~(RTGCPHYS)X86_PAGE_OFFSET_MASK,
1363 GCPhys & ~(RTGCPHYS)X86_PAGE_OFFSET_MASK,
1364 pInfo->fNemProt,
1365 &u2State,
1366 true /*fBackingState*/);
1367 pInfo->u2NemState = u2State;
1368 Log4(("nemHCWinHandleMemoryAccessPageCheckerCallback: %RGp - synced => %s + %Rrc\n",
1369 GCPhys, g_apszPageStates[u2State], rc));
1370 pState->fDidSomething = true;
1371 pState->fCanResume = true;
1372 return rc;
1373
1374 case NEM_WIN_PAGE_STATE_READABLE:
1375 if ( !(pInfo->fNemProt & NEM_PAGE_PROT_WRITE)
1376 && (pInfo->fNemProt & (NEM_PAGE_PROT_READ | NEM_PAGE_PROT_EXECUTE)))
1377 {
1378 Log4(("nemHCWinHandleMemoryAccessPageCheckerCallback: %RGp - #2\n", GCPhys));
1379 return VINF_SUCCESS;
1380 }
1381
1382 break;
1383
1384 case NEM_WIN_PAGE_STATE_WRITABLE:
1385 if (pInfo->fNemProt & NEM_PAGE_PROT_WRITE)
1386 {
1387 if (pInfo->u2OldNemState == NEM_WIN_PAGE_STATE_WRITABLE)
1388 Log4(("nemHCWinHandleMemoryAccessPageCheckerCallback: %RGp - #3a\n", GCPhys));
1389 else
1390 {
1391 pState->fCanResume = true;
1392 Log4(("nemHCWinHandleMemoryAccessPageCheckerCallback: %RGp - #3b (%s -> %s)\n",
1393 GCPhys, g_apszPageStates[pInfo->u2OldNemState], g_apszPageStates[u2State]));
1394 }
1395 return VINF_SUCCESS;
1396 }
1397 break;
1398
1399 default:
1400 AssertLogRelMsgFailedReturn(("u2State=%#x\n", u2State), VERR_NEM_IPE_4);
1401 }
1402
1403 /*
1404 * Unmap and restart the instruction.
1405 * If this fails, which it does every so often, just unmap everything for now.
1406 */
1407 /** @todo figure out whether we mess up the state or if it's WHv. */
1408 STAM_REL_PROFILE_START(&pVM->nem.s.StatProfUnmapGpaRangePage, a);
1409 HRESULT hrc = WHvUnmapGpaRange(pVM->nem.s.hPartition, GCPhys, X86_PAGE_SIZE);
1410 STAM_REL_PROFILE_STOP(&pVM->nem.s.StatProfUnmapGpaRangePage, a);
1411 if (SUCCEEDED(hrc))
1412 {
1413 pState->fDidSomething = true;
1414 pState->fCanResume = true;
1415 pInfo->u2NemState = NEM_WIN_PAGE_STATE_UNMAPPED;
1416 STAM_REL_COUNTER_INC(&pVM->nem.s.StatUnmapPage);
1417 uint32_t cMappedPages = ASMAtomicDecU32(&pVM->nem.s.cMappedPages); NOREF(cMappedPages);
1418 Log5(("NEM GPA unmapped/exit: %RGp (was %s, cMappedPages=%u)\n", GCPhys, g_apszPageStates[u2State], cMappedPages));
1419 return VINF_SUCCESS;
1420 }
1421 STAM_REL_COUNTER_INC(&pVM->nem.s.StatUnmapPageFailed);
1422 LogRel(("nemHCWinHandleMemoryAccessPageCheckerCallback/unmap: GCPhysDst=%RGp %s hrc=%Rhrc (%#x)\n",
1423 GCPhys, g_apszPageStates[u2State], hrc, hrc));
1424 return VERR_NEM_UNMAP_PAGES_FAILED;
1425}
1426
1427
1428/**
1429 * Wrapper around nemHCWinCopyStateFromHyperV.
1430 *
1431 * Unlike the wrapped APIs, this checks whether it's necessary.
1432 *
1433 * @returns VBox strict status code.
1434 * @param pVCpu The cross context per CPU structure.
1435 * @param fWhat What to import.
1436 * @param pszCaller Who is doing the importing.
1437 */
1438DECLINLINE(VBOXSTRICTRC) nemHCWinImportStateIfNeededStrict(PVMCPUCC pVCpu, uint64_t fWhat, const char *pszCaller)
1439{
1440 if (pVCpu->cpum.GstCtx.fExtrn & fWhat)
1441 {
1442 RT_NOREF(pszCaller);
1443 int rc = nemHCWinCopyStateFromHyperV(pVCpu->pVMR3, pVCpu, fWhat);
1444 AssertRCReturn(rc, rc);
1445 }
1446 return VINF_SUCCESS;
1447}
1448
1449
1450/**
1451 * Copies register state from the (common) exit context.
1452 *
1453 * ASSUMES no state copied yet.
1454 *
1455 * @param pVCpu The cross context per CPU structure.
1456 * @param pExitCtx The common exit context.
1457 * @sa nemHCWinCopyStateFromX64Header
1458 */
1459DECLINLINE(void) nemR3WinCopyStateFromX64Header(PVMCPUCC pVCpu, WHV_VP_EXIT_CONTEXT const *pExitCtx)
1460{
1461 Assert( (pVCpu->cpum.GstCtx.fExtrn & (CPUMCTX_EXTRN_RIP | CPUMCTX_EXTRN_RFLAGS | CPUMCTX_EXTRN_CS | CPUMCTX_EXTRN_INHIBIT_INT))
1462 == (CPUMCTX_EXTRN_RIP | CPUMCTX_EXTRN_RFLAGS | CPUMCTX_EXTRN_CS | CPUMCTX_EXTRN_INHIBIT_INT));
1463 NEM_WIN_COPY_BACK_SEG(pVCpu->cpum.GstCtx.cs, pExitCtx->Cs);
1464 pVCpu->cpum.GstCtx.rip = pExitCtx->Rip;
1465 pVCpu->cpum.GstCtx.rflags.u = pExitCtx->Rflags;
1466
1467 pVCpu->nem.s.fLastInterruptShadow = pExitCtx->ExecutionState.InterruptShadow;
1468 if (!pExitCtx->ExecutionState.InterruptShadow)
1469 {
1470 if (!VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS))
1471 { /* likely */ }
1472 else
1473 VMCPU_FF_CLEAR(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS);
1474 }
1475 else
1476 EMSetInhibitInterruptsPC(pVCpu, pExitCtx->Rip);
1477
1478 APICSetTpr(pVCpu, pExitCtx->Cr8 << 4);
1479
1480 pVCpu->cpum.GstCtx.fExtrn &= ~(CPUMCTX_EXTRN_RIP | CPUMCTX_EXTRN_RFLAGS | CPUMCTX_EXTRN_CS | CPUMCTX_EXTRN_INHIBIT_INT | CPUMCTX_EXTRN_APIC_TPR);
1481}
1482
1483
1484/**
1485 * Deals with memory access exits (WHvRunVpExitReasonMemoryAccess).
1486 *
1487 * @returns Strict VBox status code.
1488 * @param pVM The cross context VM structure.
1489 * @param pVCpu The cross context per CPU structure.
1490 * @param pExit The VM exit information to handle.
1491 * @sa nemHCWinHandleMessageMemory
1492 */
1493NEM_TMPL_STATIC VBOXSTRICTRC
1494nemR3WinHandleExitMemory(PVMCC pVM, PVMCPUCC pVCpu, WHV_RUN_VP_EXIT_CONTEXT const *pExit)
1495{
1496 uint64_t const uHostTsc = ASMReadTSC();
1497 Assert(pExit->MemoryAccess.AccessInfo.AccessType != 3);
1498
1499 /*
1500 * Whatever we do, we must clear pending event injection upon resume.
1501 */
1502 if (pExit->VpContext.ExecutionState.InterruptionPending)
1503 pVCpu->cpum.GstCtx.fExtrn &= ~CPUMCTX_EXTRN_NEM_WIN_EVENT_INJECT;
1504
1505 /*
1506 * Ask PGM for information about the given GCPhys. We need to check if we're
1507 * out of sync first.
1508 */
1509 NEMHCWINHMACPCCSTATE State = { pExit->MemoryAccess.AccessInfo.AccessType == WHvMemoryAccessWrite, false, false };
1510 PGMPHYSNEMPAGEINFO Info;
1511 int rc = PGMPhysNemPageInfoChecker(pVM, pVCpu, pExit->MemoryAccess.Gpa, State.fWriteAccess, &Info,
1512 nemHCWinHandleMemoryAccessPageCheckerCallback, &State);
1513 if (RT_SUCCESS(rc))
1514 {
1515 if (Info.fNemProt & ( pExit->MemoryAccess.AccessInfo.AccessType == WHvMemoryAccessWrite
1516 ? NEM_PAGE_PROT_WRITE : NEM_PAGE_PROT_READ))
1517 {
1518 if (State.fCanResume)
1519 {
1520 Log4(("MemExit/%u: %04x:%08RX64/%s: %RGp (=>%RHp) %s fProt=%u%s%s%s; restarting (%s)\n",
1521 pVCpu->idCpu, pExit->VpContext.Cs.Selector, pExit->VpContext.Rip, nemR3WinExecStateToLogStr(&pExit->VpContext),
1522 pExit->MemoryAccess.Gpa, Info.HCPhys, g_apszPageStates[Info.u2NemState], Info.fNemProt,
1523 Info.fHasHandlers ? " handlers" : "", Info.fZeroPage ? " zero-pg" : "",
1524 State.fDidSomething ? "" : " no-change", g_apszHvInterceptAccessTypes[pExit->MemoryAccess.AccessInfo.AccessType]));
1525 EMHistoryAddExit(pVCpu, EMEXIT_MAKE_FT(EMEXIT_F_KIND_NEM, NEMEXITTYPE_MEMORY_ACCESS),
1526 pExit->VpContext.Rip + pExit->VpContext.Cs.Base, uHostTsc);
1527 return VINF_SUCCESS;
1528 }
1529 }
1530 Log4(("MemExit/%u: %04x:%08RX64/%s: %RGp (=>%RHp) %s fProt=%u%s%s%s; emulating (%s)\n",
1531 pVCpu->idCpu, pExit->VpContext.Cs.Selector, pExit->VpContext.Rip, nemR3WinExecStateToLogStr(&pExit->VpContext),
1532 pExit->MemoryAccess.Gpa, Info.HCPhys, g_apszPageStates[Info.u2NemState], Info.fNemProt,
1533 Info.fHasHandlers ? " handlers" : "", Info.fZeroPage ? " zero-pg" : "",
1534 State.fDidSomething ? "" : " no-change", g_apszHvInterceptAccessTypes[pExit->MemoryAccess.AccessInfo.AccessType]));
1535 }
1536 else
1537 Log4(("MemExit/%u: %04x:%08RX64/%s: %RGp rc=%Rrc%s; emulating (%s)\n",
1538 pVCpu->idCpu, pExit->VpContext.Cs.Selector, pExit->VpContext.Rip, nemR3WinExecStateToLogStr(&pExit->VpContext),
1539 pExit->MemoryAccess.Gpa, rc, State.fDidSomething ? " modified-backing" : "",
1540 g_apszHvInterceptAccessTypes[pExit->MemoryAccess.AccessInfo.AccessType]));
1541
1542 /*
1543 * Emulate the memory access, either access handler or special memory.
1544 */
1545 PCEMEXITREC pExitRec = EMHistoryAddExit(pVCpu,
1546 pExit->MemoryAccess.AccessInfo.AccessType == WHvMemoryAccessWrite
1547 ? EMEXIT_MAKE_FT(EMEXIT_F_KIND_EM, EMEXITTYPE_MMIO_WRITE)
1548 : EMEXIT_MAKE_FT(EMEXIT_F_KIND_EM, EMEXITTYPE_MMIO_READ),
1549 pExit->VpContext.Rip + pExit->VpContext.Cs.Base, uHostTsc);
1550 nemR3WinCopyStateFromX64Header(pVCpu, &pExit->VpContext);
1551 rc = nemHCWinCopyStateFromHyperV(pVM, pVCpu, NEM_WIN_CPUMCTX_EXTRN_MASK_FOR_IEM | CPUMCTX_EXTRN_DS | CPUMCTX_EXTRN_ES);
1552 AssertRCReturn(rc, rc);
1553 if (pExit->VpContext.ExecutionState.Reserved0 || pExit->VpContext.ExecutionState.Reserved1)
1554 Log(("MemExit/Hdr/State: Reserved0=%#x Reserved1=%#x\n", pExit->VpContext.ExecutionState.Reserved0, pExit->VpContext.ExecutionState.Reserved1));
1555
1556 VBOXSTRICTRC rcStrict;
1557 if (!pExitRec)
1558 {
1559 //if (pMsg->InstructionByteCount > 0)
1560 // Log4(("InstructionByteCount=%#x %.16Rhxs\n", pMsg->InstructionByteCount, pMsg->InstructionBytes));
1561 if (pExit->MemoryAccess.InstructionByteCount > 0)
1562 rcStrict = IEMExecOneWithPrefetchedByPC(pVCpu, CPUMCTX2CORE(&pVCpu->cpum.GstCtx), pExit->VpContext.Rip,
1563 pExit->MemoryAccess.InstructionBytes, pExit->MemoryAccess.InstructionByteCount);
1564 else
1565 rcStrict = IEMExecOne(pVCpu);
1566 /** @todo do we need to do anything wrt debugging here? */
1567 }
1568 else
1569 {
1570 /* Frequent access or probing. */
1571 rcStrict = EMHistoryExec(pVCpu, pExitRec, 0);
1572 Log4(("MemExit/%u: %04x:%08RX64/%s: EMHistoryExec -> %Rrc + %04x:%08RX64\n",
1573 pVCpu->idCpu, pExit->VpContext.Cs.Selector, pExit->VpContext.Rip, nemR3WinExecStateToLogStr(&pExit->VpContext),
1574 VBOXSTRICTRC_VAL(rcStrict), pVCpu->cpum.GstCtx.cs.Sel, pVCpu->cpum.GstCtx.rip));
1575 }
1576 return rcStrict;
1577}
1578
1579
1580/**
1581 * Deals with I/O port access exits (WHvRunVpExitReasonX64IoPortAccess).
1582 *
1583 * @returns Strict VBox status code.
1584 * @param pVM The cross context VM structure.
1585 * @param pVCpu The cross context per CPU structure.
1586 * @param pExit The VM exit information to handle.
1587 * @sa nemHCWinHandleMessageIoPort
1588 */
1589NEM_TMPL_STATIC VBOXSTRICTRC nemR3WinHandleExitIoPort(PVMCC pVM, PVMCPUCC pVCpu, WHV_RUN_VP_EXIT_CONTEXT const *pExit)
1590{
1591 Assert( pExit->IoPortAccess.AccessInfo.AccessSize == 1
1592 || pExit->IoPortAccess.AccessInfo.AccessSize == 2
1593 || pExit->IoPortAccess.AccessInfo.AccessSize == 4);
1594
1595 /*
1596 * Whatever we do, we must clear pending event injection upon resume.
1597 */
1598 if (pExit->VpContext.ExecutionState.InterruptionPending)
1599 pVCpu->cpum.GstCtx.fExtrn &= ~CPUMCTX_EXTRN_NEM_WIN_EVENT_INJECT;
1600
1601 /*
1602 * Add history first to avoid two paths doing EMHistoryExec calls.
1603 */
1604 PCEMEXITREC pExitRec = EMHistoryAddExit(pVCpu,
1605 !pExit->IoPortAccess.AccessInfo.StringOp
1606 ? ( pExit->MemoryAccess.AccessInfo.AccessType == WHvMemoryAccessWrite
1607 ? EMEXIT_MAKE_FT(EMEXIT_F_KIND_EM, EMEXITTYPE_IO_PORT_WRITE)
1608 : EMEXIT_MAKE_FT(EMEXIT_F_KIND_EM, EMEXITTYPE_IO_PORT_READ))
1609 : ( pExit->MemoryAccess.AccessInfo.AccessType == WHvMemoryAccessWrite
1610 ? EMEXIT_MAKE_FT(EMEXIT_F_KIND_EM, EMEXITTYPE_IO_PORT_STR_WRITE)
1611 : EMEXIT_MAKE_FT(EMEXIT_F_KIND_EM, EMEXITTYPE_IO_PORT_STR_READ)),
1612 pExit->VpContext.Rip + pExit->VpContext.Cs.Base, ASMReadTSC());
1613 if (!pExitRec)
1614 {
1615 VBOXSTRICTRC rcStrict;
1616 if (!pExit->IoPortAccess.AccessInfo.StringOp)
1617 {
1618 /*
1619 * Simple port I/O.
1620 */
1621 static uint32_t const s_fAndMask[8] =
1622 { UINT32_MAX, UINT32_C(0xff), UINT32_C(0xffff), UINT32_MAX, UINT32_MAX, UINT32_MAX, UINT32_MAX, UINT32_MAX };
1623 uint32_t const fAndMask = s_fAndMask[pExit->IoPortAccess.AccessInfo.AccessSize];
1624 if (pExit->IoPortAccess.AccessInfo.IsWrite)
1625 {
1626 rcStrict = IOMIOPortWrite(pVM, pVCpu, pExit->IoPortAccess.PortNumber,
1627 (uint32_t)pExit->IoPortAccess.Rax & fAndMask,
1628 pExit->IoPortAccess.AccessInfo.AccessSize);
1629 Log4(("IOExit/%u: %04x:%08RX64/%s: OUT %#x, %#x LB %u rcStrict=%Rrc\n",
1630 pVCpu->idCpu, pExit->VpContext.Cs.Selector, pExit->VpContext.Rip, nemR3WinExecStateToLogStr(&pExit->VpContext),
1631 pExit->IoPortAccess.PortNumber, (uint32_t)pExit->IoPortAccess.Rax & fAndMask,
1632 pExit->IoPortAccess.AccessInfo.AccessSize, VBOXSTRICTRC_VAL(rcStrict) ));
1633 if (IOM_SUCCESS(rcStrict))
1634 {
1635 nemR3WinCopyStateFromX64Header(pVCpu, &pExit->VpContext);
1636 nemR3WinAdvanceGuestRipAndClearRF(pVCpu, &pExit->VpContext, 1);
1637 }
1638 }
1639 else
1640 {
1641 uint32_t uValue = 0;
1642 rcStrict = IOMIOPortRead(pVM, pVCpu, pExit->IoPortAccess.PortNumber, &uValue,
1643 pExit->IoPortAccess.AccessInfo.AccessSize);
1644 Log4(("IOExit/%u: %04x:%08RX64/%s: IN %#x LB %u -> %#x, rcStrict=%Rrc\n",
1645 pVCpu->idCpu, pExit->VpContext.Cs.Selector, pExit->VpContext.Rip, nemR3WinExecStateToLogStr(&pExit->VpContext),
1646 pExit->IoPortAccess.PortNumber, pExit->IoPortAccess.AccessInfo.AccessSize, uValue, VBOXSTRICTRC_VAL(rcStrict) ));
1647 if (IOM_SUCCESS(rcStrict))
1648 {
1649 if (pExit->IoPortAccess.AccessInfo.AccessSize != 4)
1650 pVCpu->cpum.GstCtx.rax = (pExit->IoPortAccess.Rax & ~(uint64_t)fAndMask) | (uValue & fAndMask);
1651 else
1652 pVCpu->cpum.GstCtx.rax = uValue;
1653 pVCpu->cpum.GstCtx.fExtrn &= ~CPUMCTX_EXTRN_RAX;
1654 Log4(("IOExit/%u: RAX %#RX64 -> %#RX64\n", pVCpu->idCpu, pExit->IoPortAccess.Rax, pVCpu->cpum.GstCtx.rax));
1655 nemR3WinCopyStateFromX64Header(pVCpu, &pExit->VpContext);
1656 nemR3WinAdvanceGuestRipAndClearRF(pVCpu, &pExit->VpContext, 1);
1657 }
1658 }
1659 }
1660 else
1661 {
1662 /*
1663 * String port I/O.
1664 */
1665 /** @todo Someone at Microsoft please explain how we can get the address mode
1666 * from the IoPortAccess.VpContext. CS.Attributes is only sufficient for
1667 * getting the default mode, it can always be overridden by a prefix. This
1668 * forces us to interpret the instruction from opcodes, which is suboptimal.
1669 * Both AMD-V and VT-x includes the address size in the exit info, at least on
1670 * CPUs that are reasonably new.
1671 *
1672 * Of course, it's possible this is an undocumented and we just need to do some
1673 * experiments to figure out how it's communicated. Alternatively, we can scan
1674 * the opcode bytes for possible evil prefixes.
1675 */
1676 nemR3WinCopyStateFromX64Header(pVCpu, &pExit->VpContext);
1677 pVCpu->cpum.GstCtx.fExtrn &= ~( CPUMCTX_EXTRN_RAX | CPUMCTX_EXTRN_RCX | CPUMCTX_EXTRN_RDI | CPUMCTX_EXTRN_RSI
1678 | CPUMCTX_EXTRN_DS | CPUMCTX_EXTRN_ES);
1679 NEM_WIN_COPY_BACK_SEG(pVCpu->cpum.GstCtx.ds, pExit->IoPortAccess.Ds);
1680 NEM_WIN_COPY_BACK_SEG(pVCpu->cpum.GstCtx.es, pExit->IoPortAccess.Es);
1681 pVCpu->cpum.GstCtx.rax = pExit->IoPortAccess.Rax;
1682 pVCpu->cpum.GstCtx.rcx = pExit->IoPortAccess.Rcx;
1683 pVCpu->cpum.GstCtx.rdi = pExit->IoPortAccess.Rdi;
1684 pVCpu->cpum.GstCtx.rsi = pExit->IoPortAccess.Rsi;
1685 int rc = nemHCWinCopyStateFromHyperV(pVM, pVCpu, NEM_WIN_CPUMCTX_EXTRN_MASK_FOR_IEM);
1686 AssertRCReturn(rc, rc);
1687
1688 Log4(("IOExit/%u: %04x:%08RX64/%s: %s%s %#x LB %u (emulating)\n",
1689 pVCpu->idCpu, pExit->VpContext.Cs.Selector, pExit->VpContext.Rip, nemR3WinExecStateToLogStr(&pExit->VpContext),
1690 pExit->IoPortAccess.AccessInfo.RepPrefix ? "REP " : "",
1691 pExit->IoPortAccess.AccessInfo.IsWrite ? "OUTS" : "INS",
1692 pExit->IoPortAccess.PortNumber, pExit->IoPortAccess.AccessInfo.AccessSize ));
1693 rcStrict = IEMExecOne(pVCpu);
1694 }
1695 if (IOM_SUCCESS(rcStrict))
1696 {
1697 /*
1698 * Do debug checks.
1699 */
1700 if ( pExit->VpContext.ExecutionState.DebugActive /** @todo Microsoft: Does DebugActive this only reflect DR7? */
1701 || (pExit->VpContext.Rflags & X86_EFL_TF)
1702 || DBGFBpIsHwIoArmed(pVM) )
1703 {
1704 /** @todo Debugging. */
1705 }
1706 }
1707 return rcStrict;
1708 }
1709
1710 /*
1711 * Frequent exit or something needing probing.
1712 * Get state and call EMHistoryExec.
1713 */
1714 nemR3WinCopyStateFromX64Header(pVCpu, &pExit->VpContext);
1715 if (!pExit->IoPortAccess.AccessInfo.StringOp)
1716 pVCpu->cpum.GstCtx.fExtrn &= ~CPUMCTX_EXTRN_RAX;
1717 else
1718 {
1719 pVCpu->cpum.GstCtx.fExtrn &= ~( CPUMCTX_EXTRN_RAX | CPUMCTX_EXTRN_RCX | CPUMCTX_EXTRN_RDI | CPUMCTX_EXTRN_RSI
1720 | CPUMCTX_EXTRN_DS | CPUMCTX_EXTRN_ES);
1721 NEM_WIN_COPY_BACK_SEG(pVCpu->cpum.GstCtx.ds, pExit->IoPortAccess.Ds);
1722 NEM_WIN_COPY_BACK_SEG(pVCpu->cpum.GstCtx.es, pExit->IoPortAccess.Es);
1723 pVCpu->cpum.GstCtx.rcx = pExit->IoPortAccess.Rcx;
1724 pVCpu->cpum.GstCtx.rdi = pExit->IoPortAccess.Rdi;
1725 pVCpu->cpum.GstCtx.rsi = pExit->IoPortAccess.Rsi;
1726 }
1727 pVCpu->cpum.GstCtx.rax = pExit->IoPortAccess.Rax;
1728 int rc = nemHCWinCopyStateFromHyperV(pVM, pVCpu, NEM_WIN_CPUMCTX_EXTRN_MASK_FOR_IEM);
1729 AssertRCReturn(rc, rc);
1730 Log4(("IOExit/%u: %04x:%08RX64/%s: %s%s%s %#x LB %u -> EMHistoryExec\n",
1731 pVCpu->idCpu, pExit->VpContext.Cs.Selector, pExit->VpContext.Rip, nemR3WinExecStateToLogStr(&pExit->VpContext),
1732 pExit->IoPortAccess.AccessInfo.RepPrefix ? "REP " : "",
1733 pExit->IoPortAccess.AccessInfo.IsWrite ? "OUT" : "IN",
1734 pExit->IoPortAccess.AccessInfo.StringOp ? "S" : "",
1735 pExit->IoPortAccess.PortNumber, pExit->IoPortAccess.AccessInfo.AccessSize));
1736 VBOXSTRICTRC rcStrict = EMHistoryExec(pVCpu, pExitRec, 0);
1737 Log4(("IOExit/%u: %04x:%08RX64/%s: EMHistoryExec -> %Rrc + %04x:%08RX64\n",
1738 pVCpu->idCpu, pExit->VpContext.Cs.Selector, pExit->VpContext.Rip, nemR3WinExecStateToLogStr(&pExit->VpContext),
1739 VBOXSTRICTRC_VAL(rcStrict), pVCpu->cpum.GstCtx.cs.Sel, pVCpu->cpum.GstCtx.rip));
1740 return rcStrict;
1741}
1742
1743
1744/**
1745 * Deals with interrupt window exits (WHvRunVpExitReasonX64InterruptWindow).
1746 *
1747 * @returns Strict VBox status code.
1748 * @param pVM The cross context VM structure.
1749 * @param pVCpu The cross context per CPU structure.
1750 * @param pExit The VM exit information to handle.
1751 * @sa nemHCWinHandleMessageInterruptWindow
1752 */
1753NEM_TMPL_STATIC VBOXSTRICTRC nemR3WinHandleExitInterruptWindow(PVMCC pVM, PVMCPUCC pVCpu, WHV_RUN_VP_EXIT_CONTEXT const *pExit)
1754{
1755 /*
1756 * Assert message sanity.
1757 */
1758 AssertMsg( pExit->InterruptWindow.DeliverableType == WHvX64PendingInterrupt
1759 || pExit->InterruptWindow.DeliverableType == WHvX64PendingNmi,
1760 ("%#x\n", pExit->InterruptWindow.DeliverableType));
1761
1762 /*
1763 * Just copy the state we've got and handle it in the loop for now.
1764 */
1765 EMHistoryAddExit(pVCpu, EMEXIT_MAKE_FT(EMEXIT_F_KIND_NEM, NEMEXITTYPE_INTTERRUPT_WINDOW),
1766 pExit->VpContext.Rip + pExit->VpContext.Cs.Base, ASMReadTSC());
1767
1768 nemR3WinCopyStateFromX64Header(pVCpu, &pExit->VpContext);
1769 Log4(("IntWinExit/%u: %04x:%08RX64/%s: %u IF=%d InterruptShadow=%d CR8=%#x\n",
1770 pVCpu->idCpu, pExit->VpContext.Cs.Selector, pExit->VpContext.Rip, nemR3WinExecStateToLogStr(&pExit->VpContext),
1771 pExit->InterruptWindow.DeliverableType, RT_BOOL(pExit->VpContext.Rflags & X86_EFL_IF),
1772 pExit->VpContext.ExecutionState.InterruptShadow, pExit->VpContext.Cr8));
1773
1774 /** @todo call nemHCWinHandleInterruptFF */
1775 RT_NOREF(pVM);
1776 return VINF_SUCCESS;
1777}
1778
1779
1780/**
1781 * Deals with CPUID exits (WHvRunVpExitReasonX64Cpuid).
1782 *
1783 * @returns Strict VBox status code.
1784 * @param pVM The cross context VM structure.
1785 * @param pVCpu The cross context per CPU structure.
1786 * @param pExit The VM exit information to handle.
1787 * @sa nemHCWinHandleMessageCpuId
1788 */
1789NEM_TMPL_STATIC VBOXSTRICTRC
1790nemR3WinHandleExitCpuId(PVMCC pVM, PVMCPUCC pVCpu, WHV_RUN_VP_EXIT_CONTEXT const *pExit)
1791{
1792 PCEMEXITREC pExitRec = EMHistoryAddExit(pVCpu, EMEXIT_MAKE_FT(EMEXIT_F_KIND_EM, EMEXITTYPE_CPUID),
1793 pExit->VpContext.Rip + pExit->VpContext.Cs.Base, ASMReadTSC());
1794 if (!pExitRec)
1795 {
1796 /*
1797 * Soak up state and execute the instruction.
1798 *
1799 * Note! If this grows slightly more complicated, combine into an IEMExecDecodedCpuId
1800 * function and make everyone use it.
1801 */
1802 /** @todo Combine implementations into IEMExecDecodedCpuId as this will
1803 * only get weirder with nested VT-x and AMD-V support. */
1804 nemR3WinCopyStateFromX64Header(pVCpu, &pExit->VpContext);
1805
1806 /* Copy in the low register values (top is always cleared). */
1807 pVCpu->cpum.GstCtx.rax = (uint32_t)pExit->CpuidAccess.Rax;
1808 pVCpu->cpum.GstCtx.rcx = (uint32_t)pExit->CpuidAccess.Rcx;
1809 pVCpu->cpum.GstCtx.rdx = (uint32_t)pExit->CpuidAccess.Rdx;
1810 pVCpu->cpum.GstCtx.rbx = (uint32_t)pExit->CpuidAccess.Rbx;
1811 pVCpu->cpum.GstCtx.fExtrn &= ~(CPUMCTX_EXTRN_RAX | CPUMCTX_EXTRN_RCX | CPUMCTX_EXTRN_RDX | CPUMCTX_EXTRN_RBX);
1812
1813 /* Get the correct values. */
1814 CPUMGetGuestCpuId(pVCpu, pVCpu->cpum.GstCtx.eax, pVCpu->cpum.GstCtx.ecx,
1815 &pVCpu->cpum.GstCtx.eax, &pVCpu->cpum.GstCtx.ebx, &pVCpu->cpum.GstCtx.ecx, &pVCpu->cpum.GstCtx.edx);
1816
1817 Log4(("CpuIdExit/%u: %04x:%08RX64/%s: rax=%08RX64 / rcx=%08RX64 / rdx=%08RX64 / rbx=%08RX64 -> %08RX32 / %08RX32 / %08RX32 / %08RX32 (hv: %08RX64 / %08RX64 / %08RX64 / %08RX64)\n",
1818 pVCpu->idCpu, pExit->VpContext.Cs.Selector, pExit->VpContext.Rip, nemR3WinExecStateToLogStr(&pExit->VpContext),
1819 pExit->CpuidAccess.Rax, pExit->CpuidAccess.Rcx, pExit->CpuidAccess.Rdx, pExit->CpuidAccess.Rbx,
1820 pVCpu->cpum.GstCtx.eax, pVCpu->cpum.GstCtx.ecx, pVCpu->cpum.GstCtx.edx, pVCpu->cpum.GstCtx.ebx,
1821 pExit->CpuidAccess.DefaultResultRax, pExit->CpuidAccess.DefaultResultRcx, pExit->CpuidAccess.DefaultResultRdx, pExit->CpuidAccess.DefaultResultRbx));
1822
1823 /* Move RIP and we're done. */
1824 nemR3WinAdvanceGuestRipAndClearRF(pVCpu, &pExit->VpContext, 2);
1825
1826 RT_NOREF_PV(pVM);
1827 return VINF_SUCCESS;
1828 }
1829
1830 /*
1831 * Frequent exit or something needing probing.
1832 * Get state and call EMHistoryExec.
1833 */
1834 nemR3WinCopyStateFromX64Header(pVCpu, &pExit->VpContext);
1835 pVCpu->cpum.GstCtx.rax = pExit->CpuidAccess.Rax;
1836 pVCpu->cpum.GstCtx.rcx = pExit->CpuidAccess.Rcx;
1837 pVCpu->cpum.GstCtx.rdx = pExit->CpuidAccess.Rdx;
1838 pVCpu->cpum.GstCtx.rbx = pExit->CpuidAccess.Rbx;
1839 pVCpu->cpum.GstCtx.fExtrn &= ~(CPUMCTX_EXTRN_RAX | CPUMCTX_EXTRN_RCX | CPUMCTX_EXTRN_RDX | CPUMCTX_EXTRN_RBX);
1840 Log4(("CpuIdExit/%u: %04x:%08RX64/%s: rax=%08RX64 / rcx=%08RX64 / rdx=%08RX64 / rbx=%08RX64 (hv: %08RX64 / %08RX64 / %08RX64 / %08RX64) ==> EMHistoryExec\n",
1841 pVCpu->idCpu, pExit->VpContext.Cs.Selector, pExit->VpContext.Rip, nemR3WinExecStateToLogStr(&pExit->VpContext),
1842 pExit->CpuidAccess.Rax, pExit->CpuidAccess.Rcx, pExit->CpuidAccess.Rdx, pExit->CpuidAccess.Rbx,
1843 pExit->CpuidAccess.DefaultResultRax, pExit->CpuidAccess.DefaultResultRcx, pExit->CpuidAccess.DefaultResultRdx, pExit->CpuidAccess.DefaultResultRbx));
1844 int rc = nemHCWinCopyStateFromHyperV(pVM, pVCpu, NEM_WIN_CPUMCTX_EXTRN_MASK_FOR_IEM);
1845 AssertRCReturn(rc, rc);
1846 VBOXSTRICTRC rcStrict = EMHistoryExec(pVCpu, pExitRec, 0);
1847 Log4(("CpuIdExit/%u: %04x:%08RX64/%s: EMHistoryExec -> %Rrc + %04x:%08RX64\n",
1848 pVCpu->idCpu, pExit->VpContext.Cs.Selector, pExit->VpContext.Rip, nemR3WinExecStateToLogStr(&pExit->VpContext),
1849 VBOXSTRICTRC_VAL(rcStrict), pVCpu->cpum.GstCtx.cs.Sel, pVCpu->cpum.GstCtx.rip));
1850 return rcStrict;
1851}
1852
1853
1854/**
1855 * Deals with MSR access exits (WHvRunVpExitReasonX64MsrAccess).
1856 *
1857 * @returns Strict VBox status code.
1858 * @param pVM The cross context VM structure.
1859 * @param pVCpu The cross context per CPU structure.
1860 * @param pExit The VM exit information to handle.
1861 * @sa nemHCWinHandleMessageMsr
1862 */
1863NEM_TMPL_STATIC VBOXSTRICTRC nemR3WinHandleExitMsr(PVMCC pVM, PVMCPUCC pVCpu, WHV_RUN_VP_EXIT_CONTEXT const *pExit)
1864{
1865 /*
1866 * Check CPL as that's common to both RDMSR and WRMSR.
1867 */
1868 VBOXSTRICTRC rcStrict;
1869 if (pExit->VpContext.ExecutionState.Cpl == 0)
1870 {
1871 /*
1872 * Get all the MSR state. Since we're getting EFER, we also need to
1873 * get CR0, CR4 and CR3.
1874 */
1875 PCEMEXITREC pExitRec = EMHistoryAddExit(pVCpu,
1876 pExit->MsrAccess.AccessInfo.IsWrite
1877 ? EMEXIT_MAKE_FT(EMEXIT_F_KIND_EM, EMEXITTYPE_MSR_WRITE)
1878 : EMEXIT_MAKE_FT(EMEXIT_F_KIND_EM, EMEXITTYPE_MSR_READ),
1879 pExit->VpContext.Rip + pExit->VpContext.Cs.Base, ASMReadTSC());
1880 nemR3WinCopyStateFromX64Header(pVCpu, &pExit->VpContext);
1881 rcStrict = nemHCWinImportStateIfNeededStrict(pVCpu,
1882 (!pExitRec ? 0 : IEM_CPUMCTX_EXTRN_MUST_MASK)
1883 | CPUMCTX_EXTRN_ALL_MSRS | CPUMCTX_EXTRN_CR0
1884 | CPUMCTX_EXTRN_CR3 | CPUMCTX_EXTRN_CR4,
1885 "MSRs");
1886 if (rcStrict == VINF_SUCCESS)
1887 {
1888 if (!pExitRec)
1889 {
1890 /*
1891 * Handle writes.
1892 */
1893 if (pExit->MsrAccess.AccessInfo.IsWrite)
1894 {
1895 rcStrict = CPUMSetGuestMsr(pVCpu, pExit->MsrAccess.MsrNumber,
1896 RT_MAKE_U64((uint32_t)pExit->MsrAccess.Rax, (uint32_t)pExit->MsrAccess.Rdx));
1897 Log4(("MsrExit/%u: %04x:%08RX64/%s: WRMSR %08x, %08x:%08x -> %Rrc\n", pVCpu->idCpu, pExit->VpContext.Cs.Selector,
1898 pExit->VpContext.Rip, nemR3WinExecStateToLogStr(&pExit->VpContext), pExit->MsrAccess.MsrNumber,
1899 (uint32_t)pExit->MsrAccess.Rax, (uint32_t)pExit->MsrAccess.Rdx, VBOXSTRICTRC_VAL(rcStrict) ));
1900 if (rcStrict == VINF_SUCCESS)
1901 {
1902 nemR3WinAdvanceGuestRipAndClearRF(pVCpu, &pExit->VpContext, 2);
1903 return VINF_SUCCESS;
1904 }
1905 LogRel(("MsrExit/%u: %04x:%08RX64/%s: WRMSR %08x, %08x:%08x -> %Rrc!\n", pVCpu->idCpu,
1906 pExit->VpContext.Cs.Selector, pExit->VpContext.Rip, nemR3WinExecStateToLogStr(&pExit->VpContext),
1907 pExit->MsrAccess.MsrNumber, (uint32_t)pExit->MsrAccess.Rax, (uint32_t)pExit->MsrAccess.Rdx,
1908 VBOXSTRICTRC_VAL(rcStrict) ));
1909 }
1910 /*
1911 * Handle reads.
1912 */
1913 else
1914 {
1915 uint64_t uValue = 0;
1916 rcStrict = CPUMQueryGuestMsr(pVCpu, pExit->MsrAccess.MsrNumber, &uValue);
1917 Log4(("MsrExit/%u: %04x:%08RX64/%s: RDMSR %08x -> %08RX64 / %Rrc\n", pVCpu->idCpu,
1918 pExit->VpContext.Cs.Selector, pExit->VpContext.Rip, nemR3WinExecStateToLogStr(&pExit->VpContext),
1919 pExit->MsrAccess.MsrNumber, uValue, VBOXSTRICTRC_VAL(rcStrict) ));
1920 if (rcStrict == VINF_SUCCESS)
1921 {
1922 pVCpu->cpum.GstCtx.rax = (uint32_t)uValue;
1923 pVCpu->cpum.GstCtx.rdx = uValue >> 32;
1924 pVCpu->cpum.GstCtx.fExtrn &= ~(CPUMCTX_EXTRN_RAX | CPUMCTX_EXTRN_RDX);
1925 nemR3WinAdvanceGuestRipAndClearRF(pVCpu, &pExit->VpContext, 2);
1926 return VINF_SUCCESS;
1927 }
1928 LogRel(("MsrExit/%u: %04x:%08RX64/%s: RDMSR %08x -> %08RX64 / %Rrc\n", pVCpu->idCpu, pExit->VpContext.Cs.Selector,
1929 pExit->VpContext.Rip, nemR3WinExecStateToLogStr(&pExit->VpContext), pExit->MsrAccess.MsrNumber,
1930 uValue, VBOXSTRICTRC_VAL(rcStrict) ));
1931 }
1932 }
1933 else
1934 {
1935 /*
1936 * Handle frequent exit or something needing probing.
1937 */
1938 Log4(("MsrExit/%u: %04x:%08RX64/%s: %sMSR %#08x\n",
1939 pVCpu->idCpu, pExit->VpContext.Cs.Selector, pExit->VpContext.Rip, nemR3WinExecStateToLogStr(&pExit->VpContext),
1940 pExit->MsrAccess.AccessInfo.IsWrite ? "WR" : "RD", pExit->MsrAccess.MsrNumber));
1941 rcStrict = EMHistoryExec(pVCpu, pExitRec, 0);
1942 Log4(("MsrExit/%u: %04x:%08RX64/%s: EMHistoryExec -> %Rrc + %04x:%08RX64\n",
1943 pVCpu->idCpu, pExit->VpContext.Cs.Selector, pExit->VpContext.Rip, nemR3WinExecStateToLogStr(&pExit->VpContext),
1944 VBOXSTRICTRC_VAL(rcStrict), pVCpu->cpum.GstCtx.cs.Sel, pVCpu->cpum.GstCtx.rip));
1945 return rcStrict;
1946 }
1947 }
1948 else
1949 {
1950 LogRel(("MsrExit/%u: %04x:%08RX64/%s: %sMSR %08x -> %Rrc - msr state import\n",
1951 pVCpu->idCpu, pExit->VpContext.Cs.Selector, pExit->VpContext.Rip, nemR3WinExecStateToLogStr(&pExit->VpContext),
1952 pExit->MsrAccess.AccessInfo.IsWrite ? "WR" : "RD", pExit->MsrAccess.MsrNumber, VBOXSTRICTRC_VAL(rcStrict) ));
1953 return rcStrict;
1954 }
1955 }
1956 else if (pExit->MsrAccess.AccessInfo.IsWrite)
1957 Log4(("MsrExit/%u: %04x:%08RX64/%s: CPL %u -> #GP(0); WRMSR %08x, %08x:%08x\n", pVCpu->idCpu, pExit->VpContext.Cs.Selector,
1958 pExit->VpContext.Rip, nemR3WinExecStateToLogStr(&pExit->VpContext), pExit->VpContext.ExecutionState.Cpl,
1959 pExit->MsrAccess.MsrNumber, (uint32_t)pExit->MsrAccess.Rax, (uint32_t)pExit->MsrAccess.Rdx ));
1960 else
1961 Log4(("MsrExit/%u: %04x:%08RX64/%s: CPL %u -> #GP(0); RDMSR %08x\n", pVCpu->idCpu, pExit->VpContext.Cs.Selector,
1962 pExit->VpContext.Rip, nemR3WinExecStateToLogStr(&pExit->VpContext), pExit->VpContext.ExecutionState.Cpl,
1963 pExit->MsrAccess.MsrNumber));
1964
1965 /*
1966 * If we get down here, we're supposed to #GP(0).
1967 */
1968 rcStrict = nemHCWinImportStateIfNeededStrict(pVCpu, NEM_WIN_CPUMCTX_EXTRN_MASK_FOR_IEM | CPUMCTX_EXTRN_ALL_MSRS, "MSR");
1969 if (rcStrict == VINF_SUCCESS)
1970 {
1971 rcStrict = IEMInjectTrap(pVCpu, X86_XCPT_GP, TRPM_TRAP, 0, 0, 0);
1972 if (rcStrict == VINF_IEM_RAISED_XCPT)
1973 rcStrict = VINF_SUCCESS;
1974 else if (rcStrict != VINF_SUCCESS)
1975 Log4(("MsrExit/%u: Injecting #GP(0) failed: %Rrc\n", VBOXSTRICTRC_VAL(rcStrict) ));
1976 }
1977
1978 RT_NOREF_PV(pVM);
1979 return rcStrict;
1980}
1981
1982
1983/**
1984 * Worker for nemHCWinHandleMessageException & nemR3WinHandleExitException that
1985 * checks if the given opcodes are of interest at all.
1986 *
1987 * @returns true if interesting, false if not.
1988 * @param cbOpcodes Number of opcode bytes available.
1989 * @param pbOpcodes The opcode bytes.
1990 * @param f64BitMode Whether we're in 64-bit mode.
1991 */
1992DECLINLINE(bool) nemHcWinIsInterestingUndefinedOpcode(uint8_t cbOpcodes, uint8_t const *pbOpcodes, bool f64BitMode)
1993{
1994 /*
1995 * Currently only interested in VMCALL and VMMCALL.
1996 */
1997 while (cbOpcodes >= 3)
1998 {
1999 switch (pbOpcodes[0])
2000 {
2001 case 0x0f:
2002 switch (pbOpcodes[1])
2003 {
2004 case 0x01:
2005 switch (pbOpcodes[2])
2006 {
2007 case 0xc1: /* 0f 01 c1 VMCALL */
2008 return true;
2009 case 0xd9: /* 0f 01 d9 VMMCALL */
2010 return true;
2011 default:
2012 break;
2013 }
2014 break;
2015 }
2016 break;
2017
2018 default:
2019 return false;
2020
2021 /* prefixes */
2022 case 0x40: case 0x41: case 0x42: case 0x43: case 0x44: case 0x45: case 0x46: case 0x47:
2023 case 0x48: case 0x49: case 0x4a: case 0x4b: case 0x4c: case 0x4d: case 0x4e: case 0x4f:
2024 if (!f64BitMode)
2025 return false;
2026 RT_FALL_THRU();
2027 case X86_OP_PRF_CS:
2028 case X86_OP_PRF_SS:
2029 case X86_OP_PRF_DS:
2030 case X86_OP_PRF_ES:
2031 case X86_OP_PRF_FS:
2032 case X86_OP_PRF_GS:
2033 case X86_OP_PRF_SIZE_OP:
2034 case X86_OP_PRF_SIZE_ADDR:
2035 case X86_OP_PRF_LOCK:
2036 case X86_OP_PRF_REPZ:
2037 case X86_OP_PRF_REPNZ:
2038 cbOpcodes--;
2039 pbOpcodes++;
2040 continue;
2041 }
2042 break;
2043 }
2044 return false;
2045}
2046
2047
2048/**
2049 * Copies state included in a exception intercept exit.
2050 *
2051 * @param pVCpu The cross context per CPU structure.
2052 * @param pExit The VM exit information.
2053 * @param fClearXcpt Clear pending exception.
2054 */
2055DECLINLINE(void) nemR3WinCopyStateFromExceptionMessage(PVMCPUCC pVCpu, WHV_RUN_VP_EXIT_CONTEXT const *pExit, bool fClearXcpt)
2056{
2057 nemR3WinCopyStateFromX64Header(pVCpu, &pExit->VpContext);
2058 if (fClearXcpt)
2059 pVCpu->cpum.GstCtx.fExtrn &= ~CPUMCTX_EXTRN_NEM_WIN_EVENT_INJECT;
2060}
2061
2062
2063/**
2064 * Advances the guest RIP by the number of bytes specified in @a cb.
2065 *
2066 * @param pVCpu The cross context virtual CPU structure.
2067 * @param cb RIP increment value in bytes.
2068 */
2069DECLINLINE(void) nemHcWinAdvanceRip(PVMCPUCC pVCpu, uint32_t cb)
2070{
2071 PCPUMCTX pCtx = &pVCpu->cpum.GstCtx;
2072 pCtx->rip += cb;
2073
2074 /* Update interrupt shadow. */
2075 if ( VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS)
2076 && pCtx->rip != EMGetInhibitInterruptsPC(pVCpu))
2077 VMCPU_FF_CLEAR(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS);
2078}
2079
2080
2081/**
2082 * Hacks its way around the lovely mesa driver's backdoor accesses.
2083 *
2084 * @sa hmR0VmxHandleMesaDrvGp
2085 * @sa hmR0SvmHandleMesaDrvGp
2086 */
2087static int nemHcWinHandleMesaDrvGp(PVMCPUCC pVCpu, PCPUMCTX pCtx)
2088{
2089 Assert(!(pCtx->fExtrn & (CPUMCTX_EXTRN_RIP | CPUMCTX_EXTRN_CS | CPUMCTX_EXTRN_RFLAGS | CPUMCTX_EXTRN_GPRS_MASK)));
2090 RT_NOREF(pCtx);
2091
2092 /* For now we'll just skip the instruction. */
2093 nemHcWinAdvanceRip(pVCpu, 1);
2094 return VINF_SUCCESS;
2095}
2096
2097
2098/**
2099 * Checks if the \#GP'ing instruction is the mesa driver doing it's lovely
2100 * backdoor logging w/o checking what it is running inside.
2101 *
2102 * This recognizes an "IN EAX,DX" instruction executed in flat ring-3, with the
2103 * backdoor port and magic numbers loaded in registers.
2104 *
2105 * @returns true if it is, false if it isn't.
2106 * @sa hmR0VmxIsMesaDrvGp
2107 * @sa hmR0SvmIsMesaDrvGp
2108 */
2109DECLINLINE(bool) nemHcWinIsMesaDrvGp(PVMCPUCC pVCpu, PCPUMCTX pCtx, const uint8_t *pbInsn, uint32_t cbInsn)
2110{
2111 /* #GP(0) is already checked by caller. */
2112
2113 /* Check magic and port. */
2114 Assert(!(pCtx->fExtrn & (CPUMCTX_EXTRN_RDX | CPUMCTX_EXTRN_RAX)));
2115 if (pCtx->dx != UINT32_C(0x5658))
2116 return false;
2117 if (pCtx->rax != UINT32_C(0x564d5868))
2118 return false;
2119
2120 /* Flat ring-3 CS. */
2121 if (CPUMGetGuestCPL(pVCpu) != 3)
2122 return false;
2123 if (pCtx->cs.u64Base != 0)
2124 return false;
2125
2126 /* 0xed: IN eAX,dx */
2127 if (cbInsn < 1) /* Play safe (shouldn't happen). */
2128 {
2129 uint8_t abInstr[1];
2130 int rc = PGMPhysSimpleReadGCPtr(pVCpu, abInstr, pCtx->rip, sizeof(abInstr));
2131 if (RT_FAILURE(rc))
2132 return false;
2133 if (abInstr[0] != 0xed)
2134 return false;
2135 }
2136 else
2137 {
2138 if (pbInsn[0] != 0xed)
2139 return false;
2140 }
2141
2142 return true;
2143}
2144
2145
2146/**
2147 * Deals with MSR access exits (WHvRunVpExitReasonException).
2148 *
2149 * @returns Strict VBox status code.
2150 * @param pVM The cross context VM structure.
2151 * @param pVCpu The cross context per CPU structure.
2152 * @param pExit The VM exit information to handle.
2153 * @sa nemR3WinHandleExitException
2154 */
2155NEM_TMPL_STATIC VBOXSTRICTRC nemR3WinHandleExitException(PVMCC pVM, PVMCPUCC pVCpu, WHV_RUN_VP_EXIT_CONTEXT const *pExit)
2156{
2157 /*
2158 * Get most of the register state since we'll end up making IEM inject the
2159 * event. The exception isn't normally flaged as a pending event, so duh.
2160 *
2161 * Note! We can optimize this later with event injection.
2162 */
2163 Log4(("XcptExit/%u: %04x:%08RX64/%s: %x errcd=%#x parm=%RX64\n", pVCpu->idCpu, pExit->VpContext.Cs.Selector,
2164 pExit->VpContext.Rip, nemR3WinExecStateToLogStr(&pExit->VpContext), pExit->VpException.ExceptionType,
2165 pExit->VpException.ErrorCode, pExit->VpException.ExceptionParameter ));
2166 nemR3WinCopyStateFromExceptionMessage(pVCpu, pExit, true /*fClearXcpt*/);
2167 uint64_t fWhat = NEM_WIN_CPUMCTX_EXTRN_MASK_FOR_IEM;
2168 if (pExit->VpException.ExceptionType == X86_XCPT_DB)
2169 fWhat |= CPUMCTX_EXTRN_DR0_DR3 | CPUMCTX_EXTRN_DR7 | CPUMCTX_EXTRN_DR6;
2170 VBOXSTRICTRC rcStrict = nemHCWinImportStateIfNeededStrict(pVCpu, fWhat, "Xcpt");
2171 if (rcStrict != VINF_SUCCESS)
2172 return rcStrict;
2173
2174 /*
2175 * Handle the intercept.
2176 */
2177 TRPMEVENT enmEvtType = TRPM_TRAP;
2178 switch (pExit->VpException.ExceptionType)
2179 {
2180 /*
2181 * We get undefined opcodes on VMMCALL(AMD) & VMCALL(Intel) instructions
2182 * and need to turn them over to GIM.
2183 *
2184 * Note! We do not check fGIMTrapXcptUD here ASSUMING that GIM only wants
2185 * #UD for handling non-native hypercall instructions. (IEM will
2186 * decode both and let the GIM provider decide whether to accept it.)
2187 */
2188 case X86_XCPT_UD:
2189 STAM_REL_COUNTER_INC(&pVCpu->nem.s.StatExitExceptionUd);
2190 EMHistoryAddExit(pVCpu, EMEXIT_MAKE_FT(EMEXIT_F_KIND_NEM, NEMEXITTYPE_XCPT_UD),
2191 pExit->VpContext.Rip + pExit->VpContext.Cs.Base, ASMReadTSC());
2192 if (nemHcWinIsInterestingUndefinedOpcode(pExit->VpException.InstructionByteCount, pExit->VpException.InstructionBytes,
2193 pExit->VpContext.ExecutionState.EferLma && pExit->VpContext.Cs.Long ))
2194 {
2195 rcStrict = IEMExecOneWithPrefetchedByPC(pVCpu, CPUMCTX2CORE(&pVCpu->cpum.GstCtx), pExit->VpContext.Rip,
2196 pExit->VpException.InstructionBytes,
2197 pExit->VpException.InstructionByteCount);
2198 Log4(("XcptExit/%u: %04x:%08RX64/%s: #UD -> emulated -> %Rrc\n",
2199 pVCpu->idCpu, pExit->VpContext.Cs.Selector, pExit->VpContext.Rip,
2200 nemR3WinExecStateToLogStr(&pExit->VpContext), VBOXSTRICTRC_VAL(rcStrict) ));
2201 STAM_REL_COUNTER_INC(&pVCpu->nem.s.StatExitExceptionUdHandled);
2202 return rcStrict;
2203 }
2204
2205 Log4(("XcptExit/%u: %04x:%08RX64/%s: #UD [%.*Rhxs] -> re-injected\n", pVCpu->idCpu,
2206 pExit->VpContext.Cs.Selector, pExit->VpContext.Rip, nemR3WinExecStateToLogStr(&pExit->VpContext),
2207 pExit->VpException.InstructionByteCount, pExit->VpException.InstructionBytes ));
2208 break;
2209
2210 /*
2211 * Workaround the lovely mesa driver assuming that vmsvga means vmware
2212 * hypervisor and tries to log stuff to the host.
2213 */
2214 case X86_XCPT_GP:
2215 STAM_REL_COUNTER_INC(&pVCpu->nem.s.StatExitExceptionGp);
2216 /** @todo r=bird: Need workaround in IEM for this, right?
2217 EMHistoryAddExit(pVCpu, EMEXIT_MAKE_FT(EMEXIT_F_KIND_NEM, NEMEXITTYPE_XCPT_GP),
2218 pExit->VpContext.Rip + pExit->VpContext.Cs.Base, ASMReadTSC()); */
2219 if ( !pVCpu->nem.s.fTrapXcptGpForLovelyMesaDrv
2220 || !nemHcWinIsMesaDrvGp(pVCpu, &pVCpu->cpum.GstCtx, pExit->VpException.InstructionBytes,
2221 pExit->VpException.InstructionByteCount))
2222 {
2223#if 1 /** @todo Need to emulate instruction or we get a triple fault when trying to inject the #GP... */
2224 rcStrict = IEMExecOneWithPrefetchedByPC(pVCpu, CPUMCTX2CORE(&pVCpu->cpum.GstCtx), pExit->VpContext.Rip,
2225 pExit->VpException.InstructionBytes,
2226 pExit->VpException.InstructionByteCount);
2227 Log4(("XcptExit/%u: %04x:%08RX64/%s: #GP -> emulated -> %Rrc\n",
2228 pVCpu->idCpu, pExit->VpContext.Cs.Selector, pExit->VpContext.Rip,
2229 nemR3WinExecStateToLogStr(&pExit->VpContext), VBOXSTRICTRC_VAL(rcStrict) ));
2230 STAM_REL_COUNTER_INC(&pVCpu->nem.s.StatExitExceptionUdHandled);
2231 return rcStrict;
2232#else
2233 break;
2234#endif
2235 }
2236 STAM_REL_COUNTER_INC(&pVCpu->nem.s.StatExitExceptionGpMesa);
2237 return nemHcWinHandleMesaDrvGp(pVCpu, &pVCpu->cpum.GstCtx);
2238
2239 /*
2240 * Filter debug exceptions.
2241 */
2242 case X86_XCPT_DB:
2243 STAM_REL_COUNTER_INC(&pVCpu->nem.s.StatExitExceptionDb);
2244 EMHistoryAddExit(pVCpu, EMEXIT_MAKE_FT(EMEXIT_F_KIND_NEM, NEMEXITTYPE_XCPT_DB),
2245 pExit->VpContext.Rip + pExit->VpContext.Cs.Base, ASMReadTSC());
2246 Log4(("XcptExit/%u: %04x:%08RX64/%s: #DB - TODO\n",
2247 pVCpu->idCpu, pExit->VpContext.Cs.Selector, pExit->VpContext.Rip, nemR3WinExecStateToLogStr(&pExit->VpContext) ));
2248 break;
2249
2250 case X86_XCPT_BP:
2251 STAM_REL_COUNTER_INC(&pVCpu->nem.s.StatExitExceptionBp);
2252 EMHistoryAddExit(pVCpu, EMEXIT_MAKE_FT(EMEXIT_F_KIND_NEM, NEMEXITTYPE_XCPT_BP),
2253 pExit->VpContext.Rip + pExit->VpContext.Cs.Base, ASMReadTSC());
2254 Log4(("XcptExit/%u: %04x:%08RX64/%s: #BP - TODO - %u\n", pVCpu->idCpu, pExit->VpContext.Cs.Selector,
2255 pExit->VpContext.Rip, nemR3WinExecStateToLogStr(&pExit->VpContext), pExit->VpContext.InstructionLength));
2256 enmEvtType = TRPM_SOFTWARE_INT; /* We're at the INT3 instruction, not after it. */
2257 break;
2258
2259 /* This shouldn't happen. */
2260 default:
2261 AssertLogRelMsgFailedReturn(("ExceptionType=%#x\n", pExit->VpException.ExceptionType), VERR_IEM_IPE_6);
2262 }
2263
2264 /*
2265 * Inject it.
2266 */
2267 rcStrict = IEMInjectTrap(pVCpu, pExit->VpException.ExceptionType, enmEvtType, pExit->VpException.ErrorCode,
2268 pExit->VpException.ExceptionParameter /*??*/, pExit->VpContext.InstructionLength);
2269 Log4(("XcptExit/%u: %04x:%08RX64/%s: %#u -> injected -> %Rrc\n",
2270 pVCpu->idCpu, pExit->VpContext.Cs.Selector, pExit->VpContext.Rip,
2271 nemR3WinExecStateToLogStr(&pExit->VpContext), pExit->VpException.ExceptionType, VBOXSTRICTRC_VAL(rcStrict) ));
2272
2273 RT_NOREF_PV(pVM);
2274 return rcStrict;
2275}
2276
2277
2278/**
2279 * Deals with MSR access exits (WHvRunVpExitReasonUnrecoverableException).
2280 *
2281 * @returns Strict VBox status code.
2282 * @param pVM The cross context VM structure.
2283 * @param pVCpu The cross context per CPU structure.
2284 * @param pExit The VM exit information to handle.
2285 * @sa nemHCWinHandleMessageUnrecoverableException
2286 */
2287NEM_TMPL_STATIC VBOXSTRICTRC nemR3WinHandleExitUnrecoverableException(PVMCC pVM, PVMCPUCC pVCpu, WHV_RUN_VP_EXIT_CONTEXT const *pExit)
2288{
2289#if 0
2290 /*
2291 * Just copy the state we've got and handle it in the loop for now.
2292 */
2293 nemR3WinCopyStateFromX64Header(pVCpu, &pExit->VpContext);
2294 Log(("TripleExit/%u: %04x:%08RX64/%s: RFL=%#RX64 -> VINF_EM_TRIPLE_FAULT\n", pVCpu->idCpu, pExit->VpContext.Cs.Selector,
2295 pExit->VpContext.Rip, nemR3WinExecStateToLogStr(&pExit->VpContext), pExit->VpContext.Rflags));
2296 RT_NOREF_PV(pVM);
2297 return VINF_EM_TRIPLE_FAULT;
2298#else
2299 /*
2300 * Let IEM decide whether this is really it.
2301 */
2302 EMHistoryAddExit(pVCpu, EMEXIT_MAKE_FT(EMEXIT_F_KIND_NEM, NEMEXITTYPE_UNRECOVERABLE_EXCEPTION),
2303 pExit->VpContext.Rip + pExit->VpContext.Cs.Base, ASMReadTSC());
2304 nemR3WinCopyStateFromX64Header(pVCpu, &pExit->VpContext);
2305 VBOXSTRICTRC rcStrict = nemHCWinImportStateIfNeededStrict(pVCpu, NEM_WIN_CPUMCTX_EXTRN_MASK_FOR_IEM | CPUMCTX_EXTRN_ALL, "TripleExit");
2306 if (rcStrict == VINF_SUCCESS)
2307 {
2308 rcStrict = IEMExecOne(pVCpu);
2309 if (rcStrict == VINF_SUCCESS)
2310 {
2311 Log(("UnrecovExit/%u: %04x:%08RX64/%s: RFL=%#RX64 -> VINF_SUCCESS\n", pVCpu->idCpu, pExit->VpContext.Cs.Selector,
2312 pExit->VpContext.Rip, nemR3WinExecStateToLogStr(&pExit->VpContext), pExit->VpContext.Rflags));
2313 pVCpu->cpum.GstCtx.fExtrn &= ~CPUMCTX_EXTRN_NEM_WIN_EVENT_INJECT; /* Make sure to reset pending #DB(0). */
2314 return VINF_SUCCESS;
2315 }
2316 if (rcStrict == VINF_EM_TRIPLE_FAULT)
2317 Log(("UnrecovExit/%u: %04x:%08RX64/%s: RFL=%#RX64 -> VINF_EM_TRIPLE_FAULT!\n", pVCpu->idCpu, pExit->VpContext.Cs.Selector,
2318 pExit->VpContext.Rip, nemR3WinExecStateToLogStr(&pExit->VpContext), pExit->VpContext.Rflags, VBOXSTRICTRC_VAL(rcStrict) ));
2319 else
2320 Log(("UnrecovExit/%u: %04x:%08RX64/%s: RFL=%#RX64 -> %Rrc (IEMExecOne)\n", pVCpu->idCpu, pExit->VpContext.Cs.Selector,
2321 pExit->VpContext.Rip, nemR3WinExecStateToLogStr(&pExit->VpContext), pExit->VpContext.Rflags, VBOXSTRICTRC_VAL(rcStrict) ));
2322 }
2323 else
2324 Log(("UnrecovExit/%u: %04x:%08RX64/%s: RFL=%#RX64 -> %Rrc (state import)\n", pVCpu->idCpu, pExit->VpContext.Cs.Selector,
2325 pExit->VpContext.Rip, nemR3WinExecStateToLogStr(&pExit->VpContext), pExit->VpContext.Rflags, VBOXSTRICTRC_VAL(rcStrict) ));
2326 RT_NOREF_PV(pVM);
2327 return rcStrict;
2328#endif
2329}
2330
2331
2332/**
2333 * Handles VM exits.
2334 *
2335 * @returns Strict VBox status code.
2336 * @param pVM The cross context VM structure.
2337 * @param pVCpu The cross context per CPU structure.
2338 * @param pExit The VM exit information to handle.
2339 * @sa nemHCWinHandleMessage
2340 */
2341NEM_TMPL_STATIC VBOXSTRICTRC nemR3WinHandleExit(PVMCC pVM, PVMCPUCC pVCpu, WHV_RUN_VP_EXIT_CONTEXT const *pExit)
2342{
2343 switch (pExit->ExitReason)
2344 {
2345 case WHvRunVpExitReasonMemoryAccess:
2346 STAM_REL_COUNTER_INC(&pVCpu->nem.s.StatExitMemUnmapped);
2347 return nemR3WinHandleExitMemory(pVM, pVCpu, pExit);
2348
2349 case WHvRunVpExitReasonX64IoPortAccess:
2350 STAM_REL_COUNTER_INC(&pVCpu->nem.s.StatExitPortIo);
2351 return nemR3WinHandleExitIoPort(pVM, pVCpu, pExit);
2352
2353 case WHvRunVpExitReasonX64Halt:
2354 STAM_REL_COUNTER_INC(&pVCpu->nem.s.StatExitHalt);
2355 EMHistoryAddExit(pVCpu, EMEXIT_MAKE_FT(EMEXIT_F_KIND_NEM, NEMEXITTYPE_HALT),
2356 pExit->VpContext.Rip + pExit->VpContext.Cs.Base, ASMReadTSC());
2357 Log4(("HaltExit/%u\n", pVCpu->idCpu));
2358 return VINF_EM_HALT;
2359
2360 case WHvRunVpExitReasonCanceled:
2361 Log4(("CanceledExit/%u\n", pVCpu->idCpu));
2362 return VINF_SUCCESS;
2363
2364 case WHvRunVpExitReasonX64InterruptWindow:
2365 STAM_REL_COUNTER_INC(&pVCpu->nem.s.StatExitInterruptWindow);
2366 return nemR3WinHandleExitInterruptWindow(pVM, pVCpu, pExit);
2367
2368 case WHvRunVpExitReasonX64Cpuid:
2369 STAM_REL_COUNTER_INC(&pVCpu->nem.s.StatExitCpuId);
2370 return nemR3WinHandleExitCpuId(pVM, pVCpu, pExit);
2371
2372 case WHvRunVpExitReasonX64MsrAccess:
2373 STAM_REL_COUNTER_INC(&pVCpu->nem.s.StatExitMsr);
2374 return nemR3WinHandleExitMsr(pVM, pVCpu, pExit);
2375
2376 case WHvRunVpExitReasonException:
2377 STAM_REL_COUNTER_INC(&pVCpu->nem.s.StatExitException);
2378 return nemR3WinHandleExitException(pVM, pVCpu, pExit);
2379
2380 case WHvRunVpExitReasonUnrecoverableException:
2381 STAM_REL_COUNTER_INC(&pVCpu->nem.s.StatExitUnrecoverable);
2382 return nemR3WinHandleExitUnrecoverableException(pVM, pVCpu, pExit);
2383
2384 case WHvRunVpExitReasonUnsupportedFeature:
2385 case WHvRunVpExitReasonInvalidVpRegisterValue:
2386 LogRel(("Unimplemented exit:\n%.*Rhxd\n", (int)sizeof(*pExit), pExit));
2387 AssertLogRelMsgFailedReturn(("Unexpected exit on CPU #%u: %#x\n%.32Rhxd\n",
2388 pVCpu->idCpu, pExit->ExitReason, pExit), VERR_NEM_IPE_3);
2389
2390 /* Undesired exits: */
2391 case WHvRunVpExitReasonNone:
2392 default:
2393 LogRel(("Unknown exit:\n%.*Rhxd\n", (int)sizeof(*pExit), pExit));
2394 AssertLogRelMsgFailedReturn(("Unknown exit on CPU #%u: %#x!\n", pVCpu->idCpu, pExit->ExitReason), VERR_NEM_IPE_3);
2395 }
2396}
2397
2398
2399/**
2400 * Deals with pending interrupt related force flags, may inject interrupt.
2401 *
2402 * @returns VBox strict status code.
2403 * @param pVM The cross context VM structure.
2404 * @param pVCpu The cross context per CPU structure.
2405 * @param pfInterruptWindows Where to return interrupt window flags.
2406 */
2407NEM_TMPL_STATIC VBOXSTRICTRC nemHCWinHandleInterruptFF(PVMCC pVM, PVMCPUCC pVCpu, uint8_t *pfInterruptWindows)
2408{
2409 Assert(!TRPMHasTrap(pVCpu));
2410 RT_NOREF_PV(pVM);
2411
2412 /*
2413 * First update APIC. We ASSUME this won't need TPR/CR8.
2414 */
2415 if (VMCPU_FF_TEST_AND_CLEAR(pVCpu, VMCPU_FF_UPDATE_APIC))
2416 {
2417 APICUpdatePendingInterrupts(pVCpu);
2418 if (!VMCPU_FF_IS_ANY_SET(pVCpu, VMCPU_FF_INTERRUPT_APIC | VMCPU_FF_INTERRUPT_PIC
2419 | VMCPU_FF_INTERRUPT_NMI | VMCPU_FF_INTERRUPT_SMI))
2420 return VINF_SUCCESS;
2421 }
2422
2423 /*
2424 * We don't currently implement SMIs.
2425 */
2426 AssertReturn(!VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_INTERRUPT_SMI), VERR_NEM_IPE_0);
2427
2428 /*
2429 * Check if we've got the minimum of state required for deciding whether we
2430 * can inject interrupts and NMIs. If we don't have it, get all we might require
2431 * for injection via IEM.
2432 */
2433 bool const fPendingNmi = VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_INTERRUPT_NMI);
2434 uint64_t fNeedExtrn = CPUMCTX_EXTRN_INHIBIT_INT | CPUMCTX_EXTRN_RIP | CPUMCTX_EXTRN_RFLAGS
2435 | (fPendingNmi ? CPUMCTX_EXTRN_INHIBIT_NMI : 0);
2436 if (pVCpu->cpum.GstCtx.fExtrn & fNeedExtrn)
2437 {
2438 VBOXSTRICTRC rcStrict = nemHCWinImportStateIfNeededStrict(pVCpu, NEM_WIN_CPUMCTX_EXTRN_MASK_FOR_IEM_XCPT, "IntFF");
2439 if (rcStrict != VINF_SUCCESS)
2440 return rcStrict;
2441 }
2442 bool const fInhibitInterrupts = VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS)
2443 && EMGetInhibitInterruptsPC(pVCpu) == pVCpu->cpum.GstCtx.rip;
2444
2445 /*
2446 * NMI? Try deliver it first.
2447 */
2448 if (fPendingNmi)
2449 {
2450 if ( !fInhibitInterrupts
2451 && !VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_BLOCK_NMIS))
2452 {
2453 VBOXSTRICTRC rcStrict = nemHCWinImportStateIfNeededStrict(pVCpu, NEM_WIN_CPUMCTX_EXTRN_MASK_FOR_IEM_XCPT, "NMI");
2454 if (rcStrict == VINF_SUCCESS)
2455 {
2456 VMCPU_FF_CLEAR(pVCpu, VMCPU_FF_INTERRUPT_NMI);
2457 rcStrict = IEMInjectTrap(pVCpu, X86_XCPT_NMI, TRPM_HARDWARE_INT, 0, 0, 0);
2458 Log8(("Injected NMI on %u (%d)\n", pVCpu->idCpu, VBOXSTRICTRC_VAL(rcStrict) ));
2459 }
2460 return rcStrict;
2461 }
2462 *pfInterruptWindows |= NEM_WIN_INTW_F_NMI;
2463 Log8(("NMI window pending on %u\n", pVCpu->idCpu));
2464 }
2465
2466 /*
2467 * APIC or PIC interrupt?
2468 */
2469 if (VMCPU_FF_IS_ANY_SET(pVCpu, VMCPU_FF_INTERRUPT_APIC | VMCPU_FF_INTERRUPT_PIC))
2470 {
2471 if ( !fInhibitInterrupts
2472 && pVCpu->cpum.GstCtx.rflags.Bits.u1IF)
2473 {
2474 AssertCompile(NEM_WIN_CPUMCTX_EXTRN_MASK_FOR_IEM_XCPT & CPUMCTX_EXTRN_APIC_TPR);
2475 VBOXSTRICTRC rcStrict = nemHCWinImportStateIfNeededStrict(pVCpu, NEM_WIN_CPUMCTX_EXTRN_MASK_FOR_IEM_XCPT, "NMI");
2476 if (rcStrict == VINF_SUCCESS)
2477 {
2478 uint8_t bInterrupt;
2479 int rc = PDMGetInterrupt(pVCpu, &bInterrupt);
2480 if (RT_SUCCESS(rc))
2481 {
2482 Log8(("Injecting interrupt %#x on %u: %04x:%08RX64 efl=%#x\n", bInterrupt, pVCpu->idCpu, pVCpu->cpum.GstCtx.cs.Sel, pVCpu->cpum.GstCtx.rip, pVCpu->cpum.GstCtx.eflags));
2483 rcStrict = IEMInjectTrap(pVCpu, bInterrupt, TRPM_HARDWARE_INT, 0, 0, 0);
2484 Log8(("Injected interrupt %#x on %u (%d)\n", bInterrupt, pVCpu->idCpu, VBOXSTRICTRC_VAL(rcStrict) ));
2485 }
2486 else if (rc == VERR_APIC_INTR_MASKED_BY_TPR)
2487 {
2488 *pfInterruptWindows |= ((bInterrupt >> 4) << NEM_WIN_INTW_F_PRIO_SHIFT) | NEM_WIN_INTW_F_REGULAR;
2489 Log8(("VERR_APIC_INTR_MASKED_BY_TPR: *pfInterruptWindows=%#x\n", *pfInterruptWindows));
2490 }
2491 else
2492 Log8(("PDMGetInterrupt failed -> %Rrc\n", rc));
2493 }
2494 return rcStrict;
2495 }
2496
2497 if (VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_INTERRUPT_APIC) && !VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_INTERRUPT_PIC))
2498 {
2499 /* If only an APIC interrupt is pending, we need to know its priority. Otherwise we'll
2500 * likely get pointless deliverability notifications with IF=1 but TPR still too high.
2501 */
2502 bool fPendingIntr = false;
2503 uint8_t bTpr = 0;
2504 uint8_t bPendingIntr = 0;
2505 int rc = APICGetTpr(pVCpu, &bTpr, &fPendingIntr, &bPendingIntr);
2506 AssertRC(rc);
2507 *pfInterruptWindows |= (bPendingIntr >> 4) << NEM_WIN_INTW_F_PRIO_SHIFT;
2508 Log8(("Interrupt window pending on %u: %#x (bTpr=%#x fPendingIntr=%d bPendingIntr=%#x)\n",
2509 pVCpu->idCpu, *pfInterruptWindows, bTpr, fPendingIntr, bPendingIntr));
2510 }
2511 else
2512 {
2513 *pfInterruptWindows |= NEM_WIN_INTW_F_REGULAR;
2514 Log8(("Interrupt window pending on %u: %#x\n", pVCpu->idCpu, *pfInterruptWindows));
2515 }
2516 }
2517
2518 return VINF_SUCCESS;
2519}
2520
2521
2522/**
2523 * Inner NEM runloop for windows.
2524 *
2525 * @returns Strict VBox status code.
2526 * @param pVM The cross context VM structure.
2527 * @param pVCpu The cross context per CPU structure.
2528 */
2529NEM_TMPL_STATIC VBOXSTRICTRC nemHCWinRunGC(PVMCC pVM, PVMCPUCC pVCpu)
2530{
2531 LogFlow(("NEM/%u: %04x:%08RX64 efl=%#08RX64 <=\n", pVCpu->idCpu, pVCpu->cpum.GstCtx.cs.Sel, pVCpu->cpum.GstCtx.rip, pVCpu->cpum.GstCtx.rflags));
2532#ifdef LOG_ENABLED
2533 if (LogIs3Enabled())
2534 nemHCWinLogState(pVM, pVCpu);
2535#endif
2536
2537 /*
2538 * Try switch to NEM runloop state.
2539 */
2540 if (VMCPU_CMPXCHG_STATE(pVCpu, VMCPUSTATE_STARTED_EXEC_NEM, VMCPUSTATE_STARTED))
2541 { /* likely */ }
2542 else
2543 {
2544 VMCPU_CMPXCHG_STATE(pVCpu, VMCPUSTATE_STARTED_EXEC_NEM, VMCPUSTATE_STARTED_EXEC_NEM_CANCELED);
2545 LogFlow(("NEM/%u: returning immediately because canceled\n", pVCpu->idCpu));
2546 return VINF_SUCCESS;
2547 }
2548
2549 /*
2550 * The run loop.
2551 *
2552 * Current approach to state updating to use the sledgehammer and sync
2553 * everything every time. This will be optimized later.
2554 */
2555 const bool fSingleStepping = DBGFIsStepping(pVCpu);
2556// const uint32_t fCheckVmFFs = !fSingleStepping ? VM_FF_HP_R0_PRE_HM_MASK
2557// : VM_FF_HP_R0_PRE_HM_STEP_MASK;
2558// const uint32_t fCheckCpuFFs = !fSingleStepping ? VMCPU_FF_HP_R0_PRE_HM_MASK : VMCPU_FF_HP_R0_PRE_HM_STEP_MASK;
2559 VBOXSTRICTRC rcStrict = VINF_SUCCESS;
2560 for (unsigned iLoop = 0;; iLoop++)
2561 {
2562 /*
2563 * Pending interrupts or such? Need to check and deal with this prior
2564 * to the state syncing.
2565 */
2566 pVCpu->nem.s.fDesiredInterruptWindows = 0;
2567 if (VMCPU_FF_IS_ANY_SET(pVCpu, VMCPU_FF_INTERRUPT_APIC | VMCPU_FF_UPDATE_APIC | VMCPU_FF_INTERRUPT_PIC
2568 | VMCPU_FF_INTERRUPT_NMI | VMCPU_FF_INTERRUPT_SMI))
2569 {
2570 /* Try inject interrupt. */
2571 rcStrict = nemHCWinHandleInterruptFF(pVM, pVCpu, &pVCpu->nem.s.fDesiredInterruptWindows);
2572 if (rcStrict == VINF_SUCCESS)
2573 { /* likely */ }
2574 else
2575 {
2576 LogFlow(("NEM/%u: breaking: nemHCWinHandleInterruptFF -> %Rrc\n", pVCpu->idCpu, VBOXSTRICTRC_VAL(rcStrict) ));
2577 STAM_REL_COUNTER_INC(&pVCpu->nem.s.StatBreakOnStatus);
2578 break;
2579 }
2580 }
2581
2582#ifndef NEM_WIN_WITH_A20
2583 /*
2584 * Do not execute in hyper-V if the A20 isn't enabled.
2585 */
2586 if (PGMPhysIsA20Enabled(pVCpu))
2587 { /* likely */ }
2588 else
2589 {
2590 rcStrict = VINF_EM_RESCHEDULE_REM;
2591 LogFlow(("NEM/%u: breaking: A20 disabled\n", pVCpu->idCpu));
2592 break;
2593 }
2594#endif
2595
2596 /*
2597 * Ensure that hyper-V has the whole state.
2598 * (We always update the interrupt windows settings when active as hyper-V seems
2599 * to forget about it after an exit.)
2600 */
2601 if ( (pVCpu->cpum.GstCtx.fExtrn & (CPUMCTX_EXTRN_ALL | CPUMCTX_EXTRN_NEM_WIN_MASK))
2602 != (CPUMCTX_EXTRN_ALL | CPUMCTX_EXTRN_NEM_WIN_MASK)
2603 || ( ( pVCpu->nem.s.fDesiredInterruptWindows
2604 || pVCpu->nem.s.fCurrentInterruptWindows != pVCpu->nem.s.fDesiredInterruptWindows) ) )
2605 {
2606 int rc2 = nemHCWinCopyStateToHyperV(pVM, pVCpu);
2607 AssertRCReturn(rc2, rc2);
2608 }
2609
2610 /*
2611 * Poll timers and run for a bit.
2612 *
2613 * With the VID approach (ring-0 or ring-3) we can specify a timeout here,
2614 * so we take the time of the next timer event and uses that as a deadline.
2615 * The rounding heuristics are "tuned" so that rhel5 (1K timer) will boot fine.
2616 */
2617 /** @todo See if we cannot optimize this TMTimerPollGIP by only redoing
2618 * the whole polling job when timers have changed... */
2619 uint64_t offDeltaIgnored;
2620 uint64_t const nsNextTimerEvt = TMTimerPollGIP(pVM, pVCpu, &offDeltaIgnored); NOREF(nsNextTimerEvt);
2621 if ( !VM_FF_IS_ANY_SET(pVM, VM_FF_EMT_RENDEZVOUS | VM_FF_TM_VIRTUAL_SYNC)
2622 && !VMCPU_FF_IS_ANY_SET(pVCpu, VMCPU_FF_HM_TO_R3_MASK))
2623 {
2624 if (VMCPU_CMPXCHG_STATE(pVCpu, VMCPUSTATE_STARTED_EXEC_NEM_WAIT, VMCPUSTATE_STARTED_EXEC_NEM))
2625 {
2626#ifdef LOG_ENABLED
2627 if (LogIsFlowEnabled())
2628 {
2629 static const WHV_REGISTER_NAME s_aNames[6] = { WHvX64RegisterCs, WHvX64RegisterRip, WHvX64RegisterRflags,
2630 WHvX64RegisterSs, WHvX64RegisterRsp, WHvX64RegisterCr0 };
2631 WHV_REGISTER_VALUE aRegs[RT_ELEMENTS(s_aNames)] = { {{0, 0} } };
2632 WHvGetVirtualProcessorRegisters(pVM->nem.s.hPartition, pVCpu->idCpu, s_aNames, RT_ELEMENTS(s_aNames), aRegs);
2633 LogFlow(("NEM/%u: Entry @ %04x:%08RX64 IF=%d EFL=%#RX64 SS:RSP=%04x:%08RX64 cr0=%RX64\n",
2634 pVCpu->idCpu, aRegs[0].Segment.Selector, aRegs[1].Reg64, RT_BOOL(aRegs[2].Reg64 & X86_EFL_IF),
2635 aRegs[2].Reg64, aRegs[3].Segment.Selector, aRegs[4].Reg64, aRegs[5].Reg64));
2636 }
2637#endif
2638 WHV_RUN_VP_EXIT_CONTEXT ExitReason = {0};
2639 TMNotifyStartOfExecution(pVM, pVCpu);
2640
2641 HRESULT hrc = WHvRunVirtualProcessor(pVM->nem.s.hPartition, pVCpu->idCpu, &ExitReason, sizeof(ExitReason));
2642
2643 VMCPU_CMPXCHG_STATE(pVCpu, VMCPUSTATE_STARTED_EXEC_NEM, VMCPUSTATE_STARTED_EXEC_NEM_WAIT);
2644 TMNotifyEndOfExecution(pVM, pVCpu, ASMReadTSC());
2645#ifdef LOG_ENABLED
2646 LogFlow(("NEM/%u: Exit @ %04X:%08RX64 IF=%d CR8=%#x Reason=%#x\n", pVCpu->idCpu, ExitReason.VpContext.Cs.Selector,
2647 ExitReason.VpContext.Rip, RT_BOOL(ExitReason.VpContext.Rflags & X86_EFL_IF), ExitReason.VpContext.Cr8,
2648 ExitReason.ExitReason));
2649#endif
2650 if (SUCCEEDED(hrc))
2651 {
2652 /*
2653 * Deal with the message.
2654 */
2655 rcStrict = nemR3WinHandleExit(pVM, pVCpu, &ExitReason);
2656 if (rcStrict == VINF_SUCCESS)
2657 { /* hopefully likely */ }
2658 else
2659 {
2660 LogFlow(("NEM/%u: breaking: nemHCWinHandleMessage -> %Rrc\n", pVCpu->idCpu, VBOXSTRICTRC_VAL(rcStrict) ));
2661 STAM_REL_COUNTER_INC(&pVCpu->nem.s.StatBreakOnStatus);
2662 break;
2663 }
2664 }
2665 else
2666 AssertLogRelMsgFailedReturn(("WHvRunVirtualProcessor failed for CPU #%u: %#x (%u)\n",
2667 pVCpu->idCpu, hrc, GetLastError()),
2668 VERR_NEM_IPE_0);
2669
2670 /*
2671 * If no relevant FFs are pending, loop.
2672 */
2673 if ( !VM_FF_IS_ANY_SET( pVM, !fSingleStepping ? VM_FF_HP_R0_PRE_HM_MASK : VM_FF_HP_R0_PRE_HM_STEP_MASK)
2674 && !VMCPU_FF_IS_ANY_SET(pVCpu, !fSingleStepping ? VMCPU_FF_HP_R0_PRE_HM_MASK : VMCPU_FF_HP_R0_PRE_HM_STEP_MASK) )
2675 continue;
2676
2677 /** @todo Try handle pending flags, not just return to EM loops. Take care
2678 * not to set important RCs here unless we've handled a message. */
2679 LogFlow(("NEM/%u: breaking: pending FF (%#x / %#RX64)\n",
2680 pVCpu->idCpu, pVM->fGlobalForcedActions, (uint64_t)pVCpu->fLocalForcedActions));
2681 STAM_REL_COUNTER_INC(&pVCpu->nem.s.StatBreakOnFFPost);
2682 }
2683 else
2684 {
2685 LogFlow(("NEM/%u: breaking: canceled %d (pre exec)\n", pVCpu->idCpu, VMCPU_GET_STATE(pVCpu) ));
2686 STAM_REL_COUNTER_INC(&pVCpu->nem.s.StatBreakOnCancel);
2687 }
2688 }
2689 else
2690 {
2691 LogFlow(("NEM/%u: breaking: pending FF (pre exec)\n", pVCpu->idCpu));
2692 STAM_REL_COUNTER_INC(&pVCpu->nem.s.StatBreakOnFFPre);
2693 }
2694 break;
2695 } /* the run loop */
2696
2697
2698 /*
2699 * If the CPU is running, make sure to stop it before we try sync back the
2700 * state and return to EM. We don't sync back the whole state if we can help it.
2701 */
2702 if (!VMCPU_CMPXCHG_STATE(pVCpu, VMCPUSTATE_STARTED, VMCPUSTATE_STARTED_EXEC_NEM))
2703 VMCPU_CMPXCHG_STATE(pVCpu, VMCPUSTATE_STARTED, VMCPUSTATE_STARTED_EXEC_NEM_CANCELED);
2704
2705 if (pVCpu->cpum.GstCtx.fExtrn & (CPUMCTX_EXTRN_ALL | (CPUMCTX_EXTRN_NEM_WIN_MASK & ~CPUMCTX_EXTRN_NEM_WIN_EVENT_INJECT)))
2706 {
2707 /* Try anticipate what we might need. */
2708 uint64_t fImport = IEM_CPUMCTX_EXTRN_MUST_MASK | CPUMCTX_EXTRN_INHIBIT_INT | CPUMCTX_EXTRN_INHIBIT_NMI;
2709 if ( (rcStrict >= VINF_EM_FIRST && rcStrict <= VINF_EM_LAST)
2710 || RT_FAILURE(rcStrict))
2711 fImport = CPUMCTX_EXTRN_ALL | (CPUMCTX_EXTRN_NEM_WIN_MASK & ~CPUMCTX_EXTRN_NEM_WIN_EVENT_INJECT);
2712 else if (VMCPU_FF_IS_ANY_SET(pVCpu, VMCPU_FF_INTERRUPT_PIC | VMCPU_FF_INTERRUPT_APIC
2713 | VMCPU_FF_INTERRUPT_NMI | VMCPU_FF_INTERRUPT_SMI))
2714 fImport |= IEM_CPUMCTX_EXTRN_XCPT_MASK;
2715
2716 if (pVCpu->cpum.GstCtx.fExtrn & fImport)
2717 {
2718 int rc2 = nemHCWinCopyStateFromHyperV(pVM, pVCpu, fImport | CPUMCTX_EXTRN_NEM_WIN_EVENT_INJECT);
2719 if (RT_SUCCESS(rc2))
2720 pVCpu->cpum.GstCtx.fExtrn &= ~fImport;
2721 else if (RT_SUCCESS(rcStrict))
2722 rcStrict = rc2;
2723 if (!(pVCpu->cpum.GstCtx.fExtrn & (CPUMCTX_EXTRN_ALL | (CPUMCTX_EXTRN_NEM_WIN_MASK & ~CPUMCTX_EXTRN_NEM_WIN_EVENT_INJECT))))
2724 pVCpu->cpum.GstCtx.fExtrn = 0;
2725 STAM_REL_COUNTER_INC(&pVCpu->nem.s.StatImportOnReturn);
2726 }
2727 else
2728 {
2729 STAM_REL_COUNTER_INC(&pVCpu->nem.s.StatImportOnReturnSkipped);
2730 pVCpu->cpum.GstCtx.fExtrn &= ~CPUMCTX_EXTRN_NEM_WIN_EVENT_INJECT;
2731 }
2732 }
2733 else
2734 {
2735 STAM_REL_COUNTER_INC(&pVCpu->nem.s.StatImportOnReturnSkipped);
2736 pVCpu->cpum.GstCtx.fExtrn = 0;
2737 }
2738
2739 LogFlow(("NEM/%u: %04x:%08RX64 efl=%#08RX64 => %Rrc\n",
2740 pVCpu->idCpu, pVCpu->cpum.GstCtx.cs.Sel, pVCpu->cpum.GstCtx.rip, pVCpu->cpum.GstCtx.rflags, VBOXSTRICTRC_VAL(rcStrict) ));
2741 return rcStrict;
2742}
2743
2744
2745/**
2746 * @callback_method_impl{FNPGMPHYSNEMCHECKPAGE}
2747 */
2748NEM_TMPL_STATIC DECLCALLBACK(int) nemHCWinUnsetForA20CheckerCallback(PVMCC pVM, PVMCPUCC pVCpu, RTGCPHYS GCPhys,
2749 PPGMPHYSNEMPAGEINFO pInfo, void *pvUser)
2750{
2751 /* We'll just unmap the memory. */
2752 if (pInfo->u2NemState > NEM_WIN_PAGE_STATE_UNMAPPED)
2753 {
2754 HRESULT hrc = WHvUnmapGpaRange(pVM->nem.s.hPartition, GCPhys, X86_PAGE_SIZE);
2755 if (SUCCEEDED(hrc))
2756 {
2757 STAM_REL_COUNTER_INC(&pVM->nem.s.StatUnmapPage);
2758 uint32_t cMappedPages = ASMAtomicDecU32(&pVM->nem.s.cMappedPages); NOREF(cMappedPages);
2759 Log5(("NEM GPA unmapped/A20: %RGp (was %s, cMappedPages=%u)\n", GCPhys, g_apszPageStates[pInfo->u2NemState], cMappedPages));
2760 pInfo->u2NemState = NEM_WIN_PAGE_STATE_UNMAPPED;
2761 }
2762 else
2763 {
2764 STAM_REL_COUNTER_INC(&pVM->nem.s.StatUnmapPageFailed);
2765 LogRel(("nemHCWinUnsetForA20CheckerCallback/unmap: GCPhys=%RGp hrc=%Rhrc (%#x) Last=%#x/%u\n",
2766 GCPhys, hrc, hrc, RTNtLastStatusValue(), RTNtLastErrorValue()));
2767 return VERR_NEM_IPE_2;
2768 }
2769 }
2770 RT_NOREF(pVCpu, pvUser);
2771 return VINF_SUCCESS;
2772}
2773
2774
2775/**
2776 * Unmaps a page from Hyper-V for the purpose of emulating A20 gate behavior.
2777 *
2778 * @returns The PGMPhysNemQueryPageInfo result.
2779 * @param pVM The cross context VM structure.
2780 * @param pVCpu The cross context virtual CPU structure.
2781 * @param GCPhys The page to unmap.
2782 */
2783NEM_TMPL_STATIC int nemHCWinUnmapPageForA20Gate(PVMCC pVM, PVMCPUCC pVCpu, RTGCPHYS GCPhys)
2784{
2785 PGMPHYSNEMPAGEINFO Info;
2786 return PGMPhysNemPageInfoChecker(pVM, pVCpu, GCPhys, false /*fMakeWritable*/, &Info,
2787 nemHCWinUnsetForA20CheckerCallback, NULL);
2788}
2789
2790
2791void nemHCNativeNotifyHandlerPhysicalRegister(PVMCC pVM, PGMPHYSHANDLERKIND enmKind, RTGCPHYS GCPhys, RTGCPHYS cb)
2792{
2793 Log5(("nemHCNativeNotifyHandlerPhysicalRegister: %RGp LB %RGp enmKind=%d\n", GCPhys, cb, enmKind));
2794 NOREF(pVM); NOREF(enmKind); NOREF(GCPhys); NOREF(cb);
2795}
2796
2797
2798VMM_INT_DECL(void) NEMHCNotifyHandlerPhysicalDeregister(PVMCC pVM, PGMPHYSHANDLERKIND enmKind, RTGCPHYS GCPhys, RTGCPHYS cb,
2799 RTR3PTR pvMemR3, uint8_t *pu2State)
2800{
2801 Log5(("NEMHCNotifyHandlerPhysicalDeregister: %RGp LB %RGp enmKind=%d pvMemR3=%p pu2State=%p (%d)\n",
2802 GCPhys, cb, enmKind, pvMemR3, pu2State, *pu2State));
2803
2804 *pu2State = UINT8_MAX;
2805 if (pvMemR3)
2806 {
2807 STAM_REL_PROFILE_START(&pVM->nem.s.StatProfMapGpaRange, a);
2808 HRESULT hrc = WHvMapGpaRange(pVM->nem.s.hPartition, pvMemR3, GCPhys, cb,
2809 WHvMapGpaRangeFlagRead | WHvMapGpaRangeFlagExecute | WHvMapGpaRangeFlagWrite);
2810 STAM_REL_PROFILE_STOP(&pVM->nem.s.StatProfMapGpaRange, a);
2811 if (SUCCEEDED(hrc))
2812 *pu2State = NEM_WIN_PAGE_STATE_WRITABLE;
2813 else
2814 AssertLogRelMsgFailed(("NEMHCNotifyHandlerPhysicalDeregister: WHvMapGpaRange(,%p,%RGp,%RGp,) -> %Rhrc\n",
2815 pvMemR3, GCPhys, cb, hrc));
2816 }
2817 RT_NOREF(enmKind);
2818}
2819
2820
2821void nemHCNativeNotifyHandlerPhysicalModify(PVMCC pVM, PGMPHYSHANDLERKIND enmKind, RTGCPHYS GCPhysOld,
2822 RTGCPHYS GCPhysNew, RTGCPHYS cb, bool fRestoreAsRAM)
2823{
2824 Log5(("nemHCNativeNotifyHandlerPhysicalModify: %RGp LB %RGp -> %RGp enmKind=%d fRestoreAsRAM=%d\n",
2825 GCPhysOld, cb, GCPhysNew, enmKind, fRestoreAsRAM));
2826 NOREF(pVM); NOREF(enmKind); NOREF(GCPhysOld); NOREF(GCPhysNew); NOREF(cb); NOREF(fRestoreAsRAM);
2827}
2828
2829
2830/**
2831 * Worker that maps pages into Hyper-V.
2832 *
2833 * This is used by the PGM physical page notifications as well as the memory
2834 * access VMEXIT handlers.
2835 *
2836 * @returns VBox status code.
2837 * @param pVM The cross context VM structure.
2838 * @param pVCpu The cross context virtual CPU structure of the
2839 * calling EMT.
2840 * @param GCPhysSrc The source page address.
2841 * @param GCPhysDst The hyper-V destination page. This may differ from
2842 * GCPhysSrc when A20 is disabled.
2843 * @param fPageProt NEM_PAGE_PROT_XXX.
2844 * @param pu2State Our page state (input/output).
2845 * @param fBackingChanged Set if the page backing is being changed.
2846 * @thread EMT(pVCpu)
2847 */
2848NEM_TMPL_STATIC int nemHCNativeSetPhysPage(PVMCC pVM, PVMCPUCC pVCpu, RTGCPHYS GCPhysSrc, RTGCPHYS GCPhysDst,
2849 uint32_t fPageProt, uint8_t *pu2State, bool fBackingChanged)
2850{
2851 /*
2852 * Looks like we need to unmap a page before we can change the backing
2853 * or even modify the protection. This is going to be *REALLY* efficient.
2854 * PGM lends us two bits to keep track of the state here.
2855 */
2856 RT_NOREF(pVCpu);
2857 uint8_t const u2OldState = *pu2State;
2858 uint8_t const u2NewState = fPageProt & NEM_PAGE_PROT_WRITE ? NEM_WIN_PAGE_STATE_WRITABLE
2859 : fPageProt & NEM_PAGE_PROT_READ ? NEM_WIN_PAGE_STATE_READABLE : NEM_WIN_PAGE_STATE_UNMAPPED;
2860 if ( fBackingChanged
2861 || u2NewState != u2OldState)
2862 {
2863 if (u2OldState > NEM_WIN_PAGE_STATE_UNMAPPED)
2864 {
2865 STAM_REL_PROFILE_START(&pVM->nem.s.StatProfUnmapGpaRangePage, a);
2866 HRESULT hrc = WHvUnmapGpaRange(pVM->nem.s.hPartition, GCPhysDst, X86_PAGE_SIZE);
2867 STAM_REL_PROFILE_STOP(&pVM->nem.s.StatProfUnmapGpaRangePage, a);
2868 if (SUCCEEDED(hrc))
2869 {
2870 *pu2State = NEM_WIN_PAGE_STATE_UNMAPPED;
2871 STAM_REL_COUNTER_INC(&pVM->nem.s.StatUnmapPage);
2872 uint32_t cMappedPages = ASMAtomicDecU32(&pVM->nem.s.cMappedPages); NOREF(cMappedPages);
2873 if (u2NewState == NEM_WIN_PAGE_STATE_UNMAPPED)
2874 {
2875 Log5(("NEM GPA unmapped/set: %RGp (was %s, cMappedPages=%u)\n",
2876 GCPhysDst, g_apszPageStates[u2OldState], cMappedPages));
2877 return VINF_SUCCESS;
2878 }
2879 }
2880 else
2881 {
2882 STAM_REL_COUNTER_INC(&pVM->nem.s.StatUnmapPageFailed);
2883 LogRel(("nemHCNativeSetPhysPage/unmap: GCPhysDst=%RGp hrc=%Rhrc (%#x) Last=%#x/%u\n",
2884 GCPhysDst, hrc, hrc, RTNtLastStatusValue(), RTNtLastErrorValue()));
2885 return VERR_NEM_INIT_FAILED;
2886 }
2887 }
2888 }
2889
2890 /*
2891 * Writeable mapping?
2892 */
2893 if (fPageProt & NEM_PAGE_PROT_WRITE)
2894 {
2895 void *pvPage;
2896 int rc = nemR3NativeGCPhys2R3PtrWriteable(pVM, GCPhysSrc, &pvPage);
2897 if (RT_SUCCESS(rc))
2898 {
2899 HRESULT hrc = WHvMapGpaRange(pVM->nem.s.hPartition, pvPage, GCPhysDst, X86_PAGE_SIZE,
2900 WHvMapGpaRangeFlagRead | WHvMapGpaRangeFlagExecute | WHvMapGpaRangeFlagWrite);
2901 if (SUCCEEDED(hrc))
2902 {
2903 *pu2State = NEM_WIN_PAGE_STATE_WRITABLE;
2904 STAM_REL_COUNTER_INC(&pVM->nem.s.StatMapPage);
2905 uint32_t cMappedPages = ASMAtomicIncU32(&pVM->nem.s.cMappedPages); NOREF(cMappedPages);
2906 Log5(("NEM GPA mapped/set: %RGp %s (was %s, cMappedPages=%u)\n",
2907 GCPhysDst, g_apszPageStates[u2NewState], g_apszPageStates[u2OldState], cMappedPages));
2908 return VINF_SUCCESS;
2909 }
2910 STAM_REL_COUNTER_INC(&pVM->nem.s.StatMapPageFailed);
2911 LogRel(("nemHCNativeSetPhysPage/writable: GCPhysDst=%RGp hrc=%Rhrc (%#x) Last=%#x/%u\n",
2912 GCPhysDst, hrc, hrc, RTNtLastStatusValue(), RTNtLastErrorValue()));
2913 return VERR_NEM_INIT_FAILED;
2914 }
2915 LogRel(("nemHCNativeSetPhysPage/writable: GCPhysSrc=%RGp rc=%Rrc\n", GCPhysSrc, rc));
2916 return rc;
2917 }
2918
2919 if (fPageProt & NEM_PAGE_PROT_READ)
2920 {
2921 const void *pvPage;
2922 int rc = nemR3NativeGCPhys2R3PtrReadOnly(pVM, GCPhysSrc, &pvPage);
2923 if (RT_SUCCESS(rc))
2924 {
2925 STAM_REL_PROFILE_START(&pVM->nem.s.StatProfMapGpaRangePage, a);
2926 HRESULT hrc = WHvMapGpaRange(pVM->nem.s.hPartition, (void *)pvPage, GCPhysDst, X86_PAGE_SIZE,
2927 WHvMapGpaRangeFlagRead | WHvMapGpaRangeFlagExecute);
2928 STAM_REL_PROFILE_STOP(&pVM->nem.s.StatProfMapGpaRangePage, a);
2929 if (SUCCEEDED(hrc))
2930 {
2931 *pu2State = NEM_WIN_PAGE_STATE_READABLE;
2932 STAM_REL_COUNTER_INC(&pVM->nem.s.StatMapPage);
2933 uint32_t cMappedPages = ASMAtomicIncU32(&pVM->nem.s.cMappedPages); NOREF(cMappedPages);
2934 Log5(("NEM GPA mapped/set: %RGp %s (was %s, cMappedPages=%u)\n",
2935 GCPhysDst, g_apszPageStates[u2NewState], g_apszPageStates[u2OldState], cMappedPages));
2936 return VINF_SUCCESS;
2937 }
2938 STAM_REL_COUNTER_INC(&pVM->nem.s.StatMapPageFailed);
2939 LogRel(("nemHCNativeSetPhysPage/readonly: GCPhysDst=%RGp hrc=%Rhrc (%#x) Last=%#x/%u\n",
2940 GCPhysDst, hrc, hrc, RTNtLastStatusValue(), RTNtLastErrorValue()));
2941 return VERR_NEM_INIT_FAILED;
2942 }
2943 LogRel(("nemHCNativeSetPhysPage/readonly: GCPhysSrc=%RGp rc=%Rrc\n", GCPhysSrc, rc));
2944 return rc;
2945 }
2946
2947 /* We already unmapped it above. */
2948 *pu2State = NEM_WIN_PAGE_STATE_UNMAPPED;
2949 return VINF_SUCCESS;
2950}
2951
2952
2953NEM_TMPL_STATIC int nemHCJustUnmapPageFromHyperV(PVMCC pVM, RTGCPHYS GCPhysDst, uint8_t *pu2State)
2954{
2955 if (*pu2State <= NEM_WIN_PAGE_STATE_UNMAPPED)
2956 {
2957 Log5(("nemHCJustUnmapPageFromHyperV: %RGp == unmapped\n", GCPhysDst));
2958 *pu2State = NEM_WIN_PAGE_STATE_UNMAPPED;
2959 return VINF_SUCCESS;
2960 }
2961
2962 STAM_REL_PROFILE_START(&pVM->nem.s.StatProfUnmapGpaRangePage, a);
2963 HRESULT hrc = WHvUnmapGpaRange(pVM->nem.s.hPartition, GCPhysDst & ~(RTGCPHYS)X86_PAGE_OFFSET_MASK, X86_PAGE_SIZE);
2964 STAM_REL_PROFILE_STOP(&pVM->nem.s.StatProfUnmapGpaRangePage, a);
2965 if (SUCCEEDED(hrc))
2966 {
2967 STAM_REL_COUNTER_INC(&pVM->nem.s.StatUnmapPage);
2968 uint32_t cMappedPages = ASMAtomicDecU32(&pVM->nem.s.cMappedPages); NOREF(cMappedPages);
2969 *pu2State = NEM_WIN_PAGE_STATE_UNMAPPED;
2970 Log5(("nemHCJustUnmapPageFromHyperV: %RGp => unmapped (total %u)\n", GCPhysDst, cMappedPages));
2971 return VINF_SUCCESS;
2972 }
2973 STAM_REL_COUNTER_INC(&pVM->nem.s.StatUnmapPageFailed);
2974 LogRel(("nemHCJustUnmapPageFromHyperV(%RGp): failed! hrc=%Rhrc (%#x) Last=%#x/%u\n",
2975 GCPhysDst, hrc, hrc, RTNtLastStatusValue(), RTNtLastErrorValue()));
2976 return VERR_NEM_IPE_6;
2977}
2978
2979
2980int nemHCNativeNotifyPhysPageAllocated(PVMCC pVM, RTGCPHYS GCPhys, RTHCPHYS HCPhys, uint32_t fPageProt,
2981 PGMPAGETYPE enmType, uint8_t *pu2State)
2982{
2983 Log5(("nemHCNativeNotifyPhysPageAllocated: %RGp HCPhys=%RHp fPageProt=%#x enmType=%d *pu2State=%d\n",
2984 GCPhys, HCPhys, fPageProt, enmType, *pu2State));
2985 RT_NOREF_PV(HCPhys); RT_NOREF_PV(enmType);
2986
2987 int rc;
2988 RT_NOREF_PV(fPageProt);
2989#ifdef NEM_WIN_WITH_A20
2990 if ( pVM->nem.s.fA20Enabled
2991 || !NEM_WIN_IS_RELEVANT_TO_A20(GCPhys))
2992#endif
2993 rc = nemHCJustUnmapPageFromHyperV(pVM, GCPhys, pu2State);
2994#ifdef NEM_WIN_WITH_A20
2995 else if (!NEM_WIN_IS_SUBJECT_TO_A20(GCPhys))
2996 rc = nemHCJustUnmapPageFromHyperV(pVM, GCPhys, pu2State);
2997 else
2998 rc = VINF_SUCCESS; /* ignore since we've got the alias page at this address. */
2999#endif
3000 return rc;
3001}
3002
3003
3004VMM_INT_DECL(void) NEMHCNotifyPhysPageProtChanged(PVMCC pVM, RTGCPHYS GCPhys, RTHCPHYS HCPhys, RTR3PTR pvR3, uint32_t fPageProt,
3005 PGMPAGETYPE enmType, uint8_t *pu2State)
3006{
3007 Log5(("NEMHCNotifyPhysPageProtChanged: %RGp HCPhys=%RHp fPageProt=%#x enmType=%d *pu2State=%d\n",
3008 GCPhys, HCPhys, fPageProt, enmType, *pu2State));
3009 Assert(VM_IS_NEM_ENABLED(pVM));
3010 RT_NOREF(HCPhys, enmType, pvR3);
3011
3012 RT_NOREF_PV(fPageProt);
3013#ifdef NEM_WIN_WITH_A20
3014 if ( pVM->nem.s.fA20Enabled
3015 || !NEM_WIN_IS_RELEVANT_TO_A20(GCPhys))
3016#endif
3017 nemHCJustUnmapPageFromHyperV(pVM, GCPhys, pu2State);
3018#ifdef NEM_WIN_WITH_A20
3019 else if (!NEM_WIN_IS_SUBJECT_TO_A20(GCPhys))
3020 nemHCJustUnmapPageFromHyperV(pVM, GCPhys, pu2State);
3021 /* else: ignore since we've got the alias page at this address. */
3022#endif
3023}
3024
3025
3026VMM_INT_DECL(void) NEMHCNotifyPhysPageChanged(PVMCC pVM, RTGCPHYS GCPhys, RTHCPHYS HCPhysPrev, RTHCPHYS HCPhysNew,
3027 RTR3PTR pvNewR3, uint32_t fPageProt, PGMPAGETYPE enmType, uint8_t *pu2State)
3028{
3029 Log5(("nemHCNativeNotifyPhysPageChanged: %RGp HCPhys=%RHp->%RHp pvNewR3=%p fPageProt=%#x enmType=%d *pu2State=%d\n",
3030 GCPhys, HCPhysPrev, HCPhysNew, pvNewR3, fPageProt, enmType, *pu2State));
3031 Assert(VM_IS_NEM_ENABLED(pVM));
3032 RT_NOREF(HCPhysPrev, HCPhysNew, pvNewR3, enmType);
3033
3034 RT_NOREF_PV(fPageProt);
3035#ifdef NEM_WIN_WITH_A20
3036 if ( pVM->nem.s.fA20Enabled
3037 || !NEM_WIN_IS_RELEVANT_TO_A20(GCPhys))
3038#endif
3039 nemHCJustUnmapPageFromHyperV(pVM, GCPhys, pu2State);
3040#ifdef NEM_WIN_WITH_A20
3041 else if (!NEM_WIN_IS_SUBJECT_TO_A20(GCPhys))
3042 nemHCJustUnmapPageFromHyperV(pVM, GCPhys, pu2State);
3043 /* else: ignore since we've got the alias page at this address. */
3044#endif
3045}
3046
3047
3048/**
3049 * Returns features supported by the NEM backend.
3050 *
3051 * @returns Flags of features supported by the native NEM backend.
3052 * @param pVM The cross context VM structure.
3053 */
3054VMM_INT_DECL(uint32_t) NEMHCGetFeatures(PVMCC pVM)
3055{
3056 RT_NOREF(pVM);
3057 /** @todo Make use of the WHvGetVirtualProcessorXsaveState/WHvSetVirtualProcessorXsaveState
3058 * interface added in 2019 to enable passthrough of xsave/xrstor (and depending) features to the guest. */
3059 /** @todo Is NEM_FEAT_F_FULL_GST_EXEC always true? */
3060 return NEM_FEAT_F_NESTED_PAGING | NEM_FEAT_F_FULL_GST_EXEC;
3061}
3062
Note: See TracBrowser for help on using the repository browser.

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