NEMAllNativeTemplate-win.cpp.h@ 72417

Last change on this file since 72417 was 72417, checked in by vboxsync, 7 years ago
NEM/win: MSR access fixes. bugref:9044
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 171.3 KB

Line
1	/* $Id: NEMAllNativeTemplate-win.cpp.h 72417 2018-06-01 21:02:06Z vboxsync $ */
2	/** @file
3	* NEM - Native execution manager, Windows code template ring-0/3.
4	*/
5
6	/*
7	* Copyright (C) 2018 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
19	/*********************************************************************************************************************************
20	* Defined Constants And Macros *
21	*********************************************************************************************************************************/
22	/** Copy back a segment from hyper-V. */
23	#define NEM_WIN_COPY_BACK_SEG(a_Dst, a_Src) \
24	do { \
25	(a_Dst).u64Base = (a_Src).Base; \
26	(a_Dst).u32Limit = (a_Src).Limit; \
27	(a_Dst).ValidSel = (a_Dst).Sel = (a_Src).Selector; \
28	(a_Dst).Attr.u = (a_Src).Attributes; \
29	(a_Dst).fFlags = CPUMSELREG_FLAGS_VALID; \
30	} while (0)
31
32
33	/*********************************************************************************************************************************
34	* Global Variables *
35	*********************************************************************************************************************************/
36	/** NEM_WIN_PAGE_STATE_XXX names. */
37	NEM_TMPL_STATIC const char * const g_apszPageStates[4] = { "not-set", "unmapped", "readable", "writable" };
38
39	/** HV_INTERCEPT_ACCESS_TYPE names. */
40	static const char * const g_apszHvInterceptAccessTypes[4] = { "read", "write", "exec", "!undefined!" };
41
42
43	/*********************************************************************************************************************************
44	* Internal Functions *
45	*********************************************************************************************************************************/
46	NEM_TMPL_STATIC int nemHCNativeSetPhysPage(PVM pVM, PVMCPU pVCpu, RTGCPHYS GCPhysSrc, RTGCPHYS GCPhysDst,
47	uint32_t fPageProt, uint8_t *pu2State, bool fBackingChanged);
48
49
50	#ifdef NEM_WIN_USE_HYPERCALLS_FOR_PAGES
51
52	/**
53	* Wrapper around VMMR0_DO_NEM_MAP_PAGES for a single page.
54	*
55	* @returns VBox status code.
56	* @param pVM The cross context VM structure.
57	* @param pVCpu The cross context virtual CPU structure of the caller.
58	* @param GCPhysSrc The source page. Does not need to be page aligned.
59	* @param GCPhysDst The destination page. Same as @a GCPhysSrc except for
60	* when A20 is disabled.
61	* @param fFlags HV_MAP_GPA_XXX.
62	*/
63	DECLINLINE(int) nemHCWinHypercallMapPage(PVM pVM, PVMCPU pVCpu, RTGCPHYS GCPhysSrc, RTGCPHYS GCPhysDst, uint32_t fFlags)
64	{
65	#ifdef IN_RING0
66	/** @todo optimize further, caller generally has the physical address. */
67	PGVM pGVM = GVMMR0FastGetGVMByVM(pVM);
68	AssertReturn(pGVM, VERR_INVALID_VM_HANDLE);
69	return nemR0WinMapPages(pGVM, pVM, &pGVM->aCpus[pVCpu->idCpu],
70	GCPhysSrc & ~(RTGCPHYS)X86_PAGE_OFFSET_MASK,
71	GCPhysDst & ~(RTGCPHYS)X86_PAGE_OFFSET_MASK,
72	1, fFlags);
73	#else
74	pVCpu->nem.s.Hypercall.MapPages.GCPhysSrc = GCPhysSrc & ~(RTGCPHYS)X86_PAGE_OFFSET_MASK;
75	pVCpu->nem.s.Hypercall.MapPages.GCPhysDst = GCPhysDst & ~(RTGCPHYS)X86_PAGE_OFFSET_MASK;
76	pVCpu->nem.s.Hypercall.MapPages.cPages = 1;
77	pVCpu->nem.s.Hypercall.MapPages.fFlags = fFlags;
78	return VMMR3CallR0Emt(pVM, pVCpu, VMMR0_DO_NEM_MAP_PAGES, 0, NULL);
79	#endif
80	}
81
82
83	/**
84	* Wrapper around VMMR0_DO_NEM_UNMAP_PAGES for a single page.
85	*
86	* @returns VBox status code.
87	* @param pVM The cross context VM structure.
88	* @param pVCpu The cross context virtual CPU structure of the caller.
89	* @param GCPhys The page to unmap. Does not need to be page aligned.
90	*/
91	DECLINLINE(int) nemHCWinHypercallUnmapPage(PVM pVM, PVMCPU pVCpu, RTGCPHYS GCPhys)
92	{
93	# ifdef IN_RING0
94	PGVM pGVM = GVMMR0FastGetGVMByVM(pVM);
95	AssertReturn(pGVM, VERR_INVALID_VM_HANDLE);
96	return nemR0WinUnmapPages(pGVM, &pGVM->aCpus[pVCpu->idCpu], GCPhys & ~(RTGCPHYS)X86_PAGE_OFFSET_MASK, 1);
97	# else
98	pVCpu->nem.s.Hypercall.UnmapPages.GCPhys = GCPhys & ~(RTGCPHYS)X86_PAGE_OFFSET_MASK;
99	pVCpu->nem.s.Hypercall.UnmapPages.cPages = 1;
100	return VMMR3CallR0Emt(pVM, pVCpu, VMMR0_DO_NEM_UNMAP_PAGES, 0, NULL);
101	# endif
102	}
103
104	#endif /* NEM_WIN_USE_HYPERCALLS_FOR_PAGES */
105	#ifndef IN_RING0
106
107	NEM_TMPL_STATIC int nemHCWinCopyStateToHyperV(PVM pVM, PVMCPU pVCpu, PCPUMCTX pCtx)
108	{
109	# ifdef NEM_WIN_USE_HYPERCALLS_FOR_REGISTERS
110	NOREF(pCtx);
111	int rc = VMMR3CallR0Emt(pVM, pVCpu, VMMR0_DO_NEM_EXPORT_STATE, 0, NULL);
112	AssertLogRelRCReturn(rc, rc);
113	return rc;
114
115	# else
116	/*
117	* The following is very similar to what nemR0WinExportState() does.
118	*/
119	WHV_REGISTER_NAME aenmNames[128];
120	WHV_REGISTER_VALUE aValues[128];
121
122	uint64_t const fWhat = ~pCtx->fExtrn & (CPUMCTX_EXTRN_ALL \| CPUMCTX_EXTRN_NEM_WIN_MASK);
123	if ( !fWhat
124	&& pVCpu->nem.s.fCurrentInterruptWindows == pVCpu->nem.s.fDesiredInterruptWindows)
125	return VINF_SUCCESS;
126	uintptr_t iReg = 0;
127
128	# define ADD_REG64(a_enmName, a_uValue) do { \
129	aenmNames[iReg] = (a_enmName); \
130	aValues[iReg].Reg128.High64 = 0; \
131	aValues[iReg].Reg64 = (a_uValue); \
132	iReg++; \
133	} while (0)
134	# define ADD_REG128(a_enmName, a_uValueLo, a_uValueHi) do { \
135	aenmNames[iReg] = (a_enmName); \
136	aValues[iReg].Reg128.Low64 = (a_uValueLo); \
137	aValues[iReg].Reg128.High64 = (a_uValueHi); \
138	iReg++; \
139	} while (0)
140
141	/* GPRs */
142	if (fWhat & CPUMCTX_EXTRN_GPRS_MASK)
143	{
144	if (fWhat & CPUMCTX_EXTRN_RAX)
145	ADD_REG64(WHvX64RegisterRax, pCtx->rax);
146	if (fWhat & CPUMCTX_EXTRN_RCX)
147	ADD_REG64(WHvX64RegisterRcx, pCtx->rcx);
148	if (fWhat & CPUMCTX_EXTRN_RDX)
149	ADD_REG64(WHvX64RegisterRdx, pCtx->rdx);
150	if (fWhat & CPUMCTX_EXTRN_RBX)
151	ADD_REG64(WHvX64RegisterRbx, pCtx->rbx);
152	if (fWhat & CPUMCTX_EXTRN_RSP)
153	ADD_REG64(WHvX64RegisterRsp, pCtx->rsp);
154	if (fWhat & CPUMCTX_EXTRN_RBP)
155	ADD_REG64(WHvX64RegisterRbp, pCtx->rbp);
156	if (fWhat & CPUMCTX_EXTRN_RSI)
157	ADD_REG64(WHvX64RegisterRsi, pCtx->rsi);
158	if (fWhat & CPUMCTX_EXTRN_RDI)
159	ADD_REG64(WHvX64RegisterRdi, pCtx->rdi);
160	if (fWhat & CPUMCTX_EXTRN_R8_R15)
161	{
162	ADD_REG64(WHvX64RegisterR8, pCtx->r8);
163	ADD_REG64(WHvX64RegisterR9, pCtx->r9);
164	ADD_REG64(WHvX64RegisterR10, pCtx->r10);
165	ADD_REG64(WHvX64RegisterR11, pCtx->r11);
166	ADD_REG64(WHvX64RegisterR12, pCtx->r12);
167	ADD_REG64(WHvX64RegisterR13, pCtx->r13);
168	ADD_REG64(WHvX64RegisterR14, pCtx->r14);
169	ADD_REG64(WHvX64RegisterR15, pCtx->r15);
170	}
171	}
172
173	/* RIP & Flags */
174	if (fWhat & CPUMCTX_EXTRN_RIP)
175	ADD_REG64(WHvX64RegisterRip, pCtx->rip);
176	if (fWhat & CPUMCTX_EXTRN_RFLAGS)
177	ADD_REG64(WHvX64RegisterRflags, pCtx->rflags.u);
178
179	/* Segments */
180	# define ADD_SEG(a_enmName, a_SReg) \
181	do { \
182	aenmNames[iReg] = a_enmName; \
183	aValues[iReg].Segment.Base = (a_SReg).u64Base; \
184	aValues[iReg].Segment.Limit = (a_SReg).u32Limit; \
185	aValues[iReg].Segment.Selector = (a_SReg).Sel; \
186	aValues[iReg].Segment.Attributes = (a_SReg).Attr.u; \
187	iReg++; \
188	} while (0)
189	if (fWhat & CPUMCTX_EXTRN_SREG_MASK)
190	{
191	if (fWhat & CPUMCTX_EXTRN_ES)
192	ADD_SEG(WHvX64RegisterEs, pCtx->es);
193	if (fWhat & CPUMCTX_EXTRN_CS)
194	ADD_SEG(WHvX64RegisterCs, pCtx->cs);
195	if (fWhat & CPUMCTX_EXTRN_SS)
196	ADD_SEG(WHvX64RegisterSs, pCtx->ss);
197	if (fWhat & CPUMCTX_EXTRN_DS)
198	ADD_SEG(WHvX64RegisterDs, pCtx->ds);
199	if (fWhat & CPUMCTX_EXTRN_FS)
200	ADD_SEG(WHvX64RegisterFs, pCtx->fs);
201	if (fWhat & CPUMCTX_EXTRN_GS)
202	ADD_SEG(WHvX64RegisterGs, pCtx->gs);
203	}
204
205	/* Descriptor tables & task segment. */
206	if (fWhat & CPUMCTX_EXTRN_TABLE_MASK)
207	{
208	if (fWhat & CPUMCTX_EXTRN_LDTR)
209	ADD_SEG(WHvX64RegisterLdtr, pCtx->ldtr);
210	if (fWhat & CPUMCTX_EXTRN_TR)
211	ADD_SEG(WHvX64RegisterTr, pCtx->tr);
212	if (fWhat & CPUMCTX_EXTRN_IDTR)
213	{
214	aenmNames[iReg] = WHvX64RegisterIdtr;
215	aValues[iReg].Table.Limit = pCtx->idtr.cbIdt;
216	aValues[iReg].Table.Base = pCtx->idtr.pIdt;
217	iReg++;
218	}
219	if (fWhat & CPUMCTX_EXTRN_GDTR)
220	{
221	aenmNames[iReg] = WHvX64RegisterGdtr;
222	aValues[iReg].Table.Limit = pCtx->gdtr.cbGdt;
223	aValues[iReg].Table.Base = pCtx->gdtr.pGdt;
224	iReg++;
225	}
226	}
227
228	/* Control registers. */
229	if (fWhat & CPUMCTX_EXTRN_CR_MASK)
230	{
231	if (fWhat & CPUMCTX_EXTRN_CR0)
232	ADD_REG64(WHvX64RegisterCr0, pCtx->cr0);
233	if (fWhat & CPUMCTX_EXTRN_CR2)
234	ADD_REG64(WHvX64RegisterCr2, pCtx->cr2);
235	if (fWhat & CPUMCTX_EXTRN_CR3)
236	ADD_REG64(WHvX64RegisterCr3, pCtx->cr3);
237	if (fWhat & CPUMCTX_EXTRN_CR4)
238	ADD_REG64(WHvX64RegisterCr4, pCtx->cr4);
239	}
240
241	/** @todo CR8/TPR */
242	ADD_REG64(WHvX64RegisterCr8, CPUMGetGuestCR8(pVCpu));
243
244	/* Debug registers. */
245	/** @todo fixme. Figure out what the hyper-v version of KVM_SET_GUEST_DEBUG would be. */
246	if (fWhat & CPUMCTX_EXTRN_DR0_DR3)
247	{
248	ADD_REG64(WHvX64RegisterDr0, pCtx->dr[0]); // CPUMGetHyperDR0(pVCpu));
249	ADD_REG64(WHvX64RegisterDr1, pCtx->dr[1]); // CPUMGetHyperDR1(pVCpu));
250	ADD_REG64(WHvX64RegisterDr2, pCtx->dr[2]); // CPUMGetHyperDR2(pVCpu));
251	ADD_REG64(WHvX64RegisterDr3, pCtx->dr[3]); // CPUMGetHyperDR3(pVCpu));
252	}
253	if (fWhat & CPUMCTX_EXTRN_DR6)
254	ADD_REG64(WHvX64RegisterDr6, pCtx->dr[6]); // CPUMGetHyperDR6(pVCpu));
255	if (fWhat & CPUMCTX_EXTRN_DR7)
256	ADD_REG64(WHvX64RegisterDr7, pCtx->dr[7]); // CPUMGetHyperDR7(pVCpu));
257
258	/* Floating point state. */
259	if (fWhat & CPUMCTX_EXTRN_X87)
260	{
261	ADD_REG128(WHvX64RegisterFpMmx0, pCtx->pXStateR3->x87.aRegs[0].au64[0], pCtx->pXStateR3->x87.aRegs[0].au64[1]);
262	ADD_REG128(WHvX64RegisterFpMmx1, pCtx->pXStateR3->x87.aRegs[1].au64[0], pCtx->pXStateR3->x87.aRegs[1].au64[1]);
263	ADD_REG128(WHvX64RegisterFpMmx2, pCtx->pXStateR3->x87.aRegs[2].au64[0], pCtx->pXStateR3->x87.aRegs[2].au64[1]);
264	ADD_REG128(WHvX64RegisterFpMmx3, pCtx->pXStateR3->x87.aRegs[3].au64[0], pCtx->pXStateR3->x87.aRegs[3].au64[1]);
265	ADD_REG128(WHvX64RegisterFpMmx4, pCtx->pXStateR3->x87.aRegs[4].au64[0], pCtx->pXStateR3->x87.aRegs[4].au64[1]);
266	ADD_REG128(WHvX64RegisterFpMmx5, pCtx->pXStateR3->x87.aRegs[5].au64[0], pCtx->pXStateR3->x87.aRegs[5].au64[1]);
267	ADD_REG128(WHvX64RegisterFpMmx6, pCtx->pXStateR3->x87.aRegs[6].au64[0], pCtx->pXStateR3->x87.aRegs[6].au64[1]);
268	ADD_REG128(WHvX64RegisterFpMmx7, pCtx->pXStateR3->x87.aRegs[7].au64[0], pCtx->pXStateR3->x87.aRegs[7].au64[1]);
269
270	aenmNames[iReg] = WHvX64RegisterFpControlStatus;
271	aValues[iReg].FpControlStatus.FpControl = pCtx->pXStateR3->x87.FCW;
272	aValues[iReg].FpControlStatus.FpStatus = pCtx->pXStateR3->x87.FSW;
273	aValues[iReg].FpControlStatus.FpTag = pCtx->pXStateR3->x87.FTW;
274	aValues[iReg].FpControlStatus.Reserved = pCtx->pXStateR3->x87.FTW >> 8;
275	aValues[iReg].FpControlStatus.LastFpOp = pCtx->pXStateR3->x87.FOP;
276	aValues[iReg].FpControlStatus.LastFpRip = (pCtx->pXStateR3->x87.FPUIP)
277	\| ((uint64_t)pCtx->pXStateR3->x87.CS << 32)
278	\| ((uint64_t)pCtx->pXStateR3->x87.Rsrvd1 << 48);
279	iReg++;
280
281	aenmNames[iReg] = WHvX64RegisterXmmControlStatus;
282	aValues[iReg].XmmControlStatus.LastFpRdp = (pCtx->pXStateR3->x87.FPUDP)
283	\| ((uint64_t)pCtx->pXStateR3->x87.DS << 32)
284	\| ((uint64_t)pCtx->pXStateR3->x87.Rsrvd2 << 48);
285	aValues[iReg].XmmControlStatus.XmmStatusControl = pCtx->pXStateR3->x87.MXCSR;
286	aValues[iReg].XmmControlStatus.XmmStatusControlMask = pCtx->pXStateR3->x87.MXCSR_MASK; /** @todo ??? (Isn't this an output field?) */
287	iReg++;
288	}
289
290	/* Vector state. */
291	if (fWhat & CPUMCTX_EXTRN_SSE_AVX)
292	{
293	ADD_REG128(WHvX64RegisterXmm0, pCtx->pXStateR3->x87.aXMM[ 0].uXmm.s.Lo, pCtx->pXStateR3->x87.aXMM[ 0].uXmm.s.Hi);
294	ADD_REG128(WHvX64RegisterXmm1, pCtx->pXStateR3->x87.aXMM[ 1].uXmm.s.Lo, pCtx->pXStateR3->x87.aXMM[ 1].uXmm.s.Hi);
295	ADD_REG128(WHvX64RegisterXmm2, pCtx->pXStateR3->x87.aXMM[ 2].uXmm.s.Lo, pCtx->pXStateR3->x87.aXMM[ 2].uXmm.s.Hi);
296	ADD_REG128(WHvX64RegisterXmm3, pCtx->pXStateR3->x87.aXMM[ 3].uXmm.s.Lo, pCtx->pXStateR3->x87.aXMM[ 3].uXmm.s.Hi);
297	ADD_REG128(WHvX64RegisterXmm4, pCtx->pXStateR3->x87.aXMM[ 4].uXmm.s.Lo, pCtx->pXStateR3->x87.aXMM[ 4].uXmm.s.Hi);
298	ADD_REG128(WHvX64RegisterXmm5, pCtx->pXStateR3->x87.aXMM[ 5].uXmm.s.Lo, pCtx->pXStateR3->x87.aXMM[ 5].uXmm.s.Hi);
299	ADD_REG128(WHvX64RegisterXmm6, pCtx->pXStateR3->x87.aXMM[ 6].uXmm.s.Lo, pCtx->pXStateR3->x87.aXMM[ 6].uXmm.s.Hi);
300	ADD_REG128(WHvX64RegisterXmm7, pCtx->pXStateR3->x87.aXMM[ 7].uXmm.s.Lo, pCtx->pXStateR3->x87.aXMM[ 7].uXmm.s.Hi);
301	ADD_REG128(WHvX64RegisterXmm8, pCtx->pXStateR3->x87.aXMM[ 8].uXmm.s.Lo, pCtx->pXStateR3->x87.aXMM[ 8].uXmm.s.Hi);
302	ADD_REG128(WHvX64RegisterXmm9, pCtx->pXStateR3->x87.aXMM[ 9].uXmm.s.Lo, pCtx->pXStateR3->x87.aXMM[ 9].uXmm.s.Hi);
303	ADD_REG128(WHvX64RegisterXmm10, pCtx->pXStateR3->x87.aXMM[10].uXmm.s.Lo, pCtx->pXStateR3->x87.aXMM[10].uXmm.s.Hi);
304	ADD_REG128(WHvX64RegisterXmm10, pCtx->pXStateR3->x87.aXMM[11].uXmm.s.Lo, pCtx->pXStateR3->x87.aXMM[11].uXmm.s.Hi);
305	ADD_REG128(WHvX64RegisterXmm10, pCtx->pXStateR3->x87.aXMM[12].uXmm.s.Lo, pCtx->pXStateR3->x87.aXMM[12].uXmm.s.Hi);
306	ADD_REG128(WHvX64RegisterXmm10, pCtx->pXStateR3->x87.aXMM[13].uXmm.s.Lo, pCtx->pXStateR3->x87.aXMM[13].uXmm.s.Hi);
307	ADD_REG128(WHvX64RegisterXmm10, pCtx->pXStateR3->x87.aXMM[14].uXmm.s.Lo, pCtx->pXStateR3->x87.aXMM[14].uXmm.s.Hi);
308	ADD_REG128(WHvX64RegisterXmm10, pCtx->pXStateR3->x87.aXMM[15].uXmm.s.Lo, pCtx->pXStateR3->x87.aXMM[15].uXmm.s.Hi);
309	}
310
311	/* MSRs */
312	// WHvX64RegisterTsc - don't touch
313	if (fWhat & CPUMCTX_EXTRN_EFER)
314	ADD_REG64(WHvX64RegisterEfer, pCtx->msrEFER);
315	if (fWhat & CPUMCTX_EXTRN_KERNEL_GS_BASE)
316	ADD_REG64(WHvX64RegisterKernelGsBase, pCtx->msrKERNELGSBASE);
317	if (fWhat & CPUMCTX_EXTRN_SYSENTER_MSRS)
318	{
319	ADD_REG64(WHvX64RegisterSysenterCs, pCtx->SysEnter.cs);
320	ADD_REG64(WHvX64RegisterSysenterEip, pCtx->SysEnter.eip);
321	ADD_REG64(WHvX64RegisterSysenterEsp, pCtx->SysEnter.esp);
322	}
323	if (fWhat & CPUMCTX_EXTRN_SYSCALL_MSRS)
324	{
325	ADD_REG64(WHvX64RegisterStar, pCtx->msrSTAR);
326	ADD_REG64(WHvX64RegisterLstar, pCtx->msrLSTAR);
327	ADD_REG64(WHvX64RegisterCstar, pCtx->msrCSTAR);
328	ADD_REG64(WHvX64RegisterSfmask, pCtx->msrSFMASK);
329	}
330	if (fWhat & CPUMCTX_EXTRN_OTHER_MSRS)
331	{
332	ADD_REG64(WHvX64RegisterApicBase, APICGetBaseMsrNoCheck(pVCpu));
333	ADD_REG64(WHvX64RegisterPat, pCtx->msrPAT);
334	#if 0 /** @todo check if WHvX64RegisterMsrMtrrCap works here... */
335	ADD_REG64(WHvX64RegisterMsrMtrrCap, CPUMGetGuestIa32MtrrCap(pVCpu));
336	#endif
337	PCPUMCTXMSRS pCtxMsrs = CPUMQueryGuestCtxMsrsPtr(pVCpu);
338	ADD_REG64(WHvX64RegisterMsrMtrrDefType, pCtxMsrs->msr.MtrrDefType);
339	ADD_REG64(WHvX64RegisterMsrMtrrFix64k00000, pCtxMsrs->msr.MtrrFix64K_00000);
340	ADD_REG64(WHvX64RegisterMsrMtrrFix16k80000, pCtxMsrs->msr.MtrrFix16K_80000);
341	ADD_REG64(WHvX64RegisterMsrMtrrFix16kA0000, pCtxMsrs->msr.MtrrFix16K_A0000);
342	ADD_REG64(WHvX64RegisterMsrMtrrFix4kC0000, pCtxMsrs->msr.MtrrFix4K_C0000);
343	ADD_REG64(WHvX64RegisterMsrMtrrFix4kC8000, pCtxMsrs->msr.MtrrFix4K_C8000);
344	ADD_REG64(WHvX64RegisterMsrMtrrFix4kD0000, pCtxMsrs->msr.MtrrFix4K_D0000);
345	ADD_REG64(WHvX64RegisterMsrMtrrFix4kD8000, pCtxMsrs->msr.MtrrFix4K_D8000);
346	ADD_REG64(WHvX64RegisterMsrMtrrFix4kE0000, pCtxMsrs->msr.MtrrFix4K_E0000);
347	ADD_REG64(WHvX64RegisterMsrMtrrFix4kE8000, pCtxMsrs->msr.MtrrFix4K_E8000);
348	ADD_REG64(WHvX64RegisterMsrMtrrFix4kF0000, pCtxMsrs->msr.MtrrFix4K_F0000);
349	ADD_REG64(WHvX64RegisterMsrMtrrFix4kF8000, pCtxMsrs->msr.MtrrFix4K_F8000);
350	ADD_REG64(WHvX64RegisterTscAux, pCtxMsrs->msr.TscAux);
351	#if 0 /** @todo these registers aren't available? Might explain something.. .*/
352	const CPUMCPUVENDOR enmCpuVendor = CPUMGetHostCpuVendor(pGVM->pVM);
353	if (enmCpuVendor != CPUMCPUVENDOR_AMD)
354	{
355	ADD_REG64(HvX64RegisterIa32MiscEnable, pCtxMsrs->msr.MiscEnable);
356	ADD_REG64(HvX64RegisterIa32FeatureControl, CPUMGetGuestIa32FeatureControl(pVCpu));
357	}
358	#endif
359	}
360
361	/* event injection (clear it). */
362	if (fWhat & CPUMCTX_EXTRN_NEM_WIN_EVENT_INJECT)
363	ADD_REG64(WHvRegisterPendingInterruption, 0);
364
365	/* Interruptibility state. This can get a little complicated since we get
366	half of the state via HV_X64_VP_EXECUTION_STATE. */
367	if ( (fWhat & (CPUMCTX_EXTRN_NEM_WIN_INHIBIT_INT \| CPUMCTX_EXTRN_NEM_WIN_INHIBIT_NMI))
368	== (CPUMCTX_EXTRN_NEM_WIN_INHIBIT_INT \| CPUMCTX_EXTRN_NEM_WIN_INHIBIT_NMI) )
369	{
370	ADD_REG64(WHvRegisterInterruptState, 0);
371	if ( VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS)
372	&& EMGetInhibitInterruptsPC(pVCpu) == pCtx->rip)
373	aValues[iReg - 1].InterruptState.InterruptShadow = 1;
374	if (VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_BLOCK_NMIS))
375	aValues[iReg - 1].InterruptState.NmiMasked = 1;
376	}
377	else if (fWhat & CPUMCTX_EXTRN_NEM_WIN_INHIBIT_INT)
378	{
379	if ( pVCpu->nem.s.fLastInterruptShadow
380	\|\| ( VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS)
381	&& EMGetInhibitInterruptsPC(pVCpu) == pCtx->rip))
382	{
383	ADD_REG64(WHvRegisterInterruptState, 0);
384	if ( VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS)
385	&& EMGetInhibitInterruptsPC(pVCpu) == pCtx->rip)
386	aValues[iReg - 1].InterruptState.InterruptShadow = 1;
387	/** @todo Retrieve NMI state, currently assuming it's zero. (yes this may happen on I/O) */
388	//if (VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_BLOCK_NMIS))
389	// aValues[iReg - 1].InterruptState.NmiMasked = 1;
390	}
391	}
392	else
393	Assert(!(fWhat & CPUMCTX_EXTRN_NEM_WIN_INHIBIT_NMI));
394
395	/* Interrupt windows. Always set if active as Hyper-V seems to be forgetful. */
396	uint8_t const fDesiredIntWin = pVCpu->nem.s.fDesiredInterruptWindows;
397	if ( fDesiredIntWin
398	\|\| pVCpu->nem.s.fCurrentInterruptWindows != fDesiredIntWin)
399	{
400	pVCpu->nem.s.fCurrentInterruptWindows = pVCpu->nem.s.fDesiredInterruptWindows;
401	ADD_REG64(WHvX64RegisterDeliverabilityNotifications, fDesiredIntWin);
402	Assert(aValues[iReg - 1].DeliverabilityNotifications.NmiNotification == RT_BOOL(fDesiredIntWin & NEM_WIN_INTW_F_NMI));
403	Assert(aValues[iReg - 1].DeliverabilityNotifications.InterruptNotification == RT_BOOL(fDesiredIntWin & NEM_WIN_INTW_F_REGULAR));
404	Assert(aValues[iReg - 1].DeliverabilityNotifications.InterruptPriority == (fDesiredIntWin & NEM_WIN_INTW_F_PRIO_MASK) >> NEM_WIN_INTW_F_PRIO_SHIFT);
405	}
406
407	/// @todo WHvRegisterPendingEvent0
408	/// @todo WHvRegisterPendingEvent1
409
410	/*
411	* Set the registers.
412	*/
413	Assert(iReg < RT_ELEMENTS(aValues));
414	Assert(iReg < RT_ELEMENTS(aenmNames));
415	# ifdef NEM_WIN_INTERCEPT_NT_IO_CTLS
416	Log12(("Calling WHvSetVirtualProcessorRegisters(%p, %u, %p, %u, %p)\n",
417	pVM->nem.s.hPartition, pVCpu->idCpu, aenmNames, iReg, aValues));
418	# endif
419	HRESULT hrc = WHvSetVirtualProcessorRegisters(pVM->nem.s.hPartition, pVCpu->idCpu, aenmNames, iReg, aValues);
420	if (SUCCEEDED(hrc))
421	{
422	pCtx->fExtrn \|= CPUMCTX_EXTRN_ALL \| CPUMCTX_EXTRN_NEM_WIN_MASK \| CPUMCTX_EXTRN_KEEPER_NEM;
423	return VINF_SUCCESS;
424	}
425	AssertLogRelMsgFailed(("WHvSetVirtualProcessorRegisters(%p, %u,,%u,) -> %Rhrc (Last=%#x/%u)\n",
426	pVM->nem.s.hPartition, pVCpu->idCpu, iReg,
427	hrc, RTNtLastStatusValue(), RTNtLastErrorValue()));
428	return VERR_INTERNAL_ERROR;
429
430	# undef ADD_REG64
431	# undef ADD_REG128
432	# undef ADD_SEG
433
434	# endif /* !NEM_WIN_USE_HYPERCALLS_FOR_REGISTERS */
435	}
436
437
438	NEM_TMPL_STATIC int nemHCWinCopyStateFromHyperV(PVM pVM, PVMCPU pVCpu, PCPUMCTX pCtx, uint64_t fWhat)
439	{
440	# ifdef NEM_WIN_USE_HYPERCALLS_FOR_REGISTERS
441	/* See NEMR0ImportState */
442	NOREF(pCtx);
443	int rc = VMMR3CallR0Emt(pVM, pVCpu, VMMR0_DO_NEM_IMPORT_STATE, fWhat, NULL);
444	if (RT_SUCCESS(rc))
445	return rc;
446	if (rc == VERR_NEM_FLUSH_TLB)
447	return PGMFlushTLB(pVCpu, pCtx->cr3, true /fGlobal/);
448	if (rc == VERR_NEM_CHANGE_PGM_MODE)
449	return PGMChangeMode(pVCpu, pCtx->cr0, pCtx->cr4, pCtx->msrEFER);
450	AssertLogRelRCReturn(rc, rc);
451	return rc;
452
453	# else
454	WHV_REGISTER_NAME aenmNames[128];
455
456	fWhat &= pCtx->fExtrn;
457	uintptr_t iReg = 0;
458
459	/* GPRs */
460	if (fWhat & CPUMCTX_EXTRN_GPRS_MASK)
461	{
462	if (fWhat & CPUMCTX_EXTRN_RAX)
463	aenmNames[iReg++] = WHvX64RegisterRax;
464	if (fWhat & CPUMCTX_EXTRN_RCX)
465	aenmNames[iReg++] = WHvX64RegisterRcx;
466	if (fWhat & CPUMCTX_EXTRN_RDX)
467	aenmNames[iReg++] = WHvX64RegisterRdx;
468	if (fWhat & CPUMCTX_EXTRN_RBX)
469	aenmNames[iReg++] = WHvX64RegisterRbx;
470	if (fWhat & CPUMCTX_EXTRN_RSP)
471	aenmNames[iReg++] = WHvX64RegisterRsp;
472	if (fWhat & CPUMCTX_EXTRN_RBP)
473	aenmNames[iReg++] = WHvX64RegisterRbp;
474	if (fWhat & CPUMCTX_EXTRN_RSI)
475	aenmNames[iReg++] = WHvX64RegisterRsi;
476	if (fWhat & CPUMCTX_EXTRN_RDI)
477	aenmNames[iReg++] = WHvX64RegisterRdi;
478	if (fWhat & CPUMCTX_EXTRN_R8_R15)
479	{
480	aenmNames[iReg++] = WHvX64RegisterR8;
481	aenmNames[iReg++] = WHvX64RegisterR9;
482	aenmNames[iReg++] = WHvX64RegisterR10;
483	aenmNames[iReg++] = WHvX64RegisterR11;
484	aenmNames[iReg++] = WHvX64RegisterR12;
485	aenmNames[iReg++] = WHvX64RegisterR13;
486	aenmNames[iReg++] = WHvX64RegisterR14;
487	aenmNames[iReg++] = WHvX64RegisterR15;
488	}
489	}
490
491	/* RIP & Flags */
492	if (fWhat & CPUMCTX_EXTRN_RIP)
493	aenmNames[iReg++] = WHvX64RegisterRip;
494	if (fWhat & CPUMCTX_EXTRN_RFLAGS)
495	aenmNames[iReg++] = WHvX64RegisterRflags;
496
497	/* Segments */
498	if (fWhat & CPUMCTX_EXTRN_SREG_MASK)
499	{
500	if (fWhat & CPUMCTX_EXTRN_ES)
501	aenmNames[iReg++] = WHvX64RegisterEs;
502	if (fWhat & CPUMCTX_EXTRN_CS)
503	aenmNames[iReg++] = WHvX64RegisterCs;
504	if (fWhat & CPUMCTX_EXTRN_SS)
505	aenmNames[iReg++] = WHvX64RegisterSs;
506	if (fWhat & CPUMCTX_EXTRN_DS)
507	aenmNames[iReg++] = WHvX64RegisterDs;
508	if (fWhat & CPUMCTX_EXTRN_FS)
509	aenmNames[iReg++] = WHvX64RegisterFs;
510	if (fWhat & CPUMCTX_EXTRN_GS)
511	aenmNames[iReg++] = WHvX64RegisterGs;
512	}
513
514	/* Descriptor tables. */
515	if (fWhat & CPUMCTX_EXTRN_TABLE_MASK)
516	{
517	if (fWhat & CPUMCTX_EXTRN_LDTR)
518	aenmNames[iReg++] = WHvX64RegisterLdtr;
519	if (fWhat & CPUMCTX_EXTRN_TR)
520	aenmNames[iReg++] = WHvX64RegisterTr;
521	if (fWhat & CPUMCTX_EXTRN_IDTR)
522	aenmNames[iReg++] = WHvX64RegisterIdtr;
523	if (fWhat & CPUMCTX_EXTRN_GDTR)
524	aenmNames[iReg++] = WHvX64RegisterGdtr;
525	}
526
527	/* Control registers. */
528	if (fWhat & CPUMCTX_EXTRN_CR_MASK)
529	{
530	if (fWhat & CPUMCTX_EXTRN_CR0)
531	aenmNames[iReg++] = WHvX64RegisterCr0;
532	if (fWhat & CPUMCTX_EXTRN_CR2)
533	aenmNames[iReg++] = WHvX64RegisterCr2;
534	if (fWhat & CPUMCTX_EXTRN_CR3)
535	aenmNames[iReg++] = WHvX64RegisterCr3;
536	if (fWhat & CPUMCTX_EXTRN_CR4)
537	aenmNames[iReg++] = WHvX64RegisterCr4;
538	}
539	aenmNames[iReg++] = WHvX64RegisterCr8; /// @todo CR8/TPR
540
541	/* Debug registers. */
542	if (fWhat & CPUMCTX_EXTRN_DR0_DR3)
543	{
544	aenmNames[iReg++] = WHvX64RegisterDr0;
545	aenmNames[iReg++] = WHvX64RegisterDr1;
546	aenmNames[iReg++] = WHvX64RegisterDr2;
547	aenmNames[iReg++] = WHvX64RegisterDr3;
548	}
549	if (fWhat & CPUMCTX_EXTRN_DR6)
550	aenmNames[iReg++] = WHvX64RegisterDr6;
551	if (fWhat & CPUMCTX_EXTRN_DR7)
552	aenmNames[iReg++] = WHvX64RegisterDr7;
553
554	/* Floating point state. */
555	if (fWhat & CPUMCTX_EXTRN_X87)
556	{
557	aenmNames[iReg++] = WHvX64RegisterFpMmx0;
558	aenmNames[iReg++] = WHvX64RegisterFpMmx1;
559	aenmNames[iReg++] = WHvX64RegisterFpMmx2;
560	aenmNames[iReg++] = WHvX64RegisterFpMmx3;
561	aenmNames[iReg++] = WHvX64RegisterFpMmx4;
562	aenmNames[iReg++] = WHvX64RegisterFpMmx5;
563	aenmNames[iReg++] = WHvX64RegisterFpMmx6;
564	aenmNames[iReg++] = WHvX64RegisterFpMmx7;
565	aenmNames[iReg++] = WHvX64RegisterFpControlStatus;
566	}
567	if (fWhat & (CPUMCTX_EXTRN_X87 \| CPUMCTX_EXTRN_SSE_AVX))
568	aenmNames[iReg++] = WHvX64RegisterXmmControlStatus;
569
570	/* Vector state. */
571	if (fWhat & CPUMCTX_EXTRN_SSE_AVX)
572	{
573	aenmNames[iReg++] = WHvX64RegisterXmm0;
574	aenmNames[iReg++] = WHvX64RegisterXmm1;
575	aenmNames[iReg++] = WHvX64RegisterXmm2;
576	aenmNames[iReg++] = WHvX64RegisterXmm3;
577	aenmNames[iReg++] = WHvX64RegisterXmm4;
578	aenmNames[iReg++] = WHvX64RegisterXmm5;
579	aenmNames[iReg++] = WHvX64RegisterXmm6;
580	aenmNames[iReg++] = WHvX64RegisterXmm7;
581	aenmNames[iReg++] = WHvX64RegisterXmm8;
582	aenmNames[iReg++] = WHvX64RegisterXmm9;
583	aenmNames[iReg++] = WHvX64RegisterXmm10;
584	aenmNames[iReg++] = WHvX64RegisterXmm11;
585	aenmNames[iReg++] = WHvX64RegisterXmm12;
586	aenmNames[iReg++] = WHvX64RegisterXmm13;
587	aenmNames[iReg++] = WHvX64RegisterXmm14;
588	aenmNames[iReg++] = WHvX64RegisterXmm15;
589	}
590
591	/* MSRs */
592	// WHvX64RegisterTsc - don't touch
593	if (fWhat & CPUMCTX_EXTRN_EFER)
594	aenmNames[iReg++] = WHvX64RegisterEfer;
595	if (fWhat & CPUMCTX_EXTRN_KERNEL_GS_BASE)
596	aenmNames[iReg++] = WHvX64RegisterKernelGsBase;
597	if (fWhat & CPUMCTX_EXTRN_SYSENTER_MSRS)
598	{
599	aenmNames[iReg++] = WHvX64RegisterSysenterCs;
600	aenmNames[iReg++] = WHvX64RegisterSysenterEip;
601	aenmNames[iReg++] = WHvX64RegisterSysenterEsp;
602	}
603	if (fWhat & CPUMCTX_EXTRN_SYSCALL_MSRS)
604	{
605	aenmNames[iReg++] = WHvX64RegisterStar;
606	aenmNames[iReg++] = WHvX64RegisterLstar;
607	aenmNames[iReg++] = WHvX64RegisterCstar;
608	aenmNames[iReg++] = WHvX64RegisterSfmask;
609	}
610
611	//#ifdef LOG_ENABLED
612	// const CPUMCPUVENDOR enmCpuVendor = CPUMGetHostCpuVendor(pGVM->pVM);
613	//#endif
614	if (fWhat & CPUMCTX_EXTRN_OTHER_MSRS)
615	{
616	aenmNames[iReg++] = WHvX64RegisterApicBase; /// @todo APIC BASE
617	aenmNames[iReg++] = WHvX64RegisterPat;
618	#if 0 /def LOG_ENABLED/ /** @todo Check if WHvX64RegisterMsrMtrrCap works... */
619	aenmNames[iReg++] = WHvX64RegisterMsrMtrrCap;
620	#endif
621	aenmNames[iReg++] = WHvX64RegisterMsrMtrrDefType;
622	aenmNames[iReg++] = WHvX64RegisterMsrMtrrFix64k00000;
623	aenmNames[iReg++] = WHvX64RegisterMsrMtrrFix16k80000;
624	aenmNames[iReg++] = WHvX64RegisterMsrMtrrFix16kA0000;
625	aenmNames[iReg++] = WHvX64RegisterMsrMtrrFix4kC0000;
626	aenmNames[iReg++] = WHvX64RegisterMsrMtrrFix4kC8000;
627	aenmNames[iReg++] = WHvX64RegisterMsrMtrrFix4kD0000;
628	aenmNames[iReg++] = WHvX64RegisterMsrMtrrFix4kD8000;
629	aenmNames[iReg++] = WHvX64RegisterMsrMtrrFix4kE0000;
630	aenmNames[iReg++] = WHvX64RegisterMsrMtrrFix4kE8000;
631	aenmNames[iReg++] = WHvX64RegisterMsrMtrrFix4kF0000;
632	aenmNames[iReg++] = WHvX64RegisterMsrMtrrFix4kF8000;
633	aenmNames[iReg++] = WHvX64RegisterTscAux;
634	/** @todo look for HvX64RegisterIa32MiscEnable and HvX64RegisterIa32FeatureControl? */
635	//#ifdef LOG_ENABLED
636	// if (enmCpuVendor != CPUMCPUVENDOR_AMD)
637	// aenmNames[iReg++] = HvX64RegisterIa32FeatureControl;
638	//#endif
639	}
640
641	/* Interruptibility. */
642	if (fWhat & (CPUMCTX_EXTRN_NEM_WIN_INHIBIT_INT \| CPUMCTX_EXTRN_NEM_WIN_INHIBIT_NMI))
643	{
644	aenmNames[iReg++] = WHvRegisterInterruptState;
645	aenmNames[iReg++] = WHvX64RegisterRip;
646	}
647
648	/* event injection */
649	aenmNames[iReg++] = WHvRegisterPendingInterruption;
650	aenmNames[iReg++] = WHvRegisterPendingEvent0;
651	aenmNames[iReg++] = WHvRegisterPendingEvent1;
652
653	size_t const cRegs = iReg;
654	Assert(cRegs < RT_ELEMENTS(aenmNames));
655
656	/*
657	* Get the registers.
658	*/
659	WHV_REGISTER_VALUE aValues[128];
660	RT_ZERO(aValues);
661	Assert(RT_ELEMENTS(aValues) >= cRegs);
662	Assert(RT_ELEMENTS(aenmNames) >= cRegs);
663	# ifdef NEM_WIN_INTERCEPT_NT_IO_CTLS
664	Log12(("Calling WHvGetVirtualProcessorRegisters(%p, %u, %p, %u, %p)\n",
665	pVM->nem.s.hPartition, pVCpu->idCpu, aenmNames, cRegs, aValues));
666	# endif
667	HRESULT hrc = WHvGetVirtualProcessorRegisters(pVM->nem.s.hPartition, pVCpu->idCpu, aenmNames, (uint32_t)cRegs, aValues);
668	AssertLogRelMsgReturn(SUCCEEDED(hrc),
669	("WHvGetVirtualProcessorRegisters(%p, %u,,%u,) -> %Rhrc (Last=%#x/%u)\n",
670	pVM->nem.s.hPartition, pVCpu->idCpu, cRegs, hrc, RTNtLastStatusValue(), RTNtLastErrorValue())
671	, VERR_NEM_GET_REGISTERS_FAILED);
672
673	iReg = 0;
674	# define GET_REG64(a_DstVar, a_enmName) do { \
675	Assert(aenmNames[iReg] == (a_enmName)); \
676	(a_DstVar) = aValues[iReg].Reg64; \
677	iReg++; \
678	} while (0)
679	# define GET_REG64_LOG7(a_DstVar, a_enmName, a_szLogName) do { \
680	Assert(aenmNames[iReg] == (a_enmName)); \
681	if ((a_DstVar) != aValues[iReg].Reg64) \
682	Log7(("NEM/%u: " a_szLogName " changed %RX64 -> %RX64\n", pVCpu->idCpu, (a_DstVar), aValues[iReg].Reg64)); \
683	(a_DstVar) = aValues[iReg].Reg64; \
684	iReg++; \
685	} while (0)
686	# define GET_REG128(a_DstVarLo, a_DstVarHi, a_enmName) do { \
687	Assert(aenmNames[iReg] == a_enmName); \
688	(a_DstVarLo) = aValues[iReg].Reg128.Low64; \
689	(a_DstVarHi) = aValues[iReg].Reg128.High64; \
690	iReg++; \
691	} while (0)
692	# define GET_SEG(a_SReg, a_enmName) do { \
693	Assert(aenmNames[iReg] == (a_enmName)); \
694	NEM_WIN_COPY_BACK_SEG(a_SReg, aValues[iReg].Segment); \
695	iReg++; \
696	} while (0)
697
698	/* GPRs */
699	if (fWhat & CPUMCTX_EXTRN_GPRS_MASK)
700	{
701	if (fWhat & CPUMCTX_EXTRN_RAX)
702	GET_REG64(pCtx->rax, WHvX64RegisterRax);
703	if (fWhat & CPUMCTX_EXTRN_RCX)
704	GET_REG64(pCtx->rcx, WHvX64RegisterRcx);
705	if (fWhat & CPUMCTX_EXTRN_RDX)
706	GET_REG64(pCtx->rdx, WHvX64RegisterRdx);
707	if (fWhat & CPUMCTX_EXTRN_RBX)
708	GET_REG64(pCtx->rbx, WHvX64RegisterRbx);
709	if (fWhat & CPUMCTX_EXTRN_RSP)
710	GET_REG64(pCtx->rsp, WHvX64RegisterRsp);
711	if (fWhat & CPUMCTX_EXTRN_RBP)
712	GET_REG64(pCtx->rbp, WHvX64RegisterRbp);
713	if (fWhat & CPUMCTX_EXTRN_RSI)
714	GET_REG64(pCtx->rsi, WHvX64RegisterRsi);
715	if (fWhat & CPUMCTX_EXTRN_RDI)
716	GET_REG64(pCtx->rdi, WHvX64RegisterRdi);
717	if (fWhat & CPUMCTX_EXTRN_R8_R15)
718	{
719	GET_REG64(pCtx->r8, WHvX64RegisterR8);
720	GET_REG64(pCtx->r9, WHvX64RegisterR9);
721	GET_REG64(pCtx->r10, WHvX64RegisterR10);
722	GET_REG64(pCtx->r11, WHvX64RegisterR11);
723	GET_REG64(pCtx->r12, WHvX64RegisterR12);
724	GET_REG64(pCtx->r13, WHvX64RegisterR13);
725	GET_REG64(pCtx->r14, WHvX64RegisterR14);
726	GET_REG64(pCtx->r15, WHvX64RegisterR15);
727	}
728	}
729
730	/* RIP & Flags */
731	if (fWhat & CPUMCTX_EXTRN_RIP)
732	GET_REG64(pCtx->rip, WHvX64RegisterRip);
733	if (fWhat & CPUMCTX_EXTRN_RFLAGS)
734	GET_REG64(pCtx->rflags.u, WHvX64RegisterRflags);
735
736	/* Segments */
737	if (fWhat & CPUMCTX_EXTRN_SREG_MASK)
738	{
739	if (fWhat & CPUMCTX_EXTRN_ES)
740	GET_SEG(pCtx->es, WHvX64RegisterEs);
741	if (fWhat & CPUMCTX_EXTRN_CS)
742	GET_SEG(pCtx->cs, WHvX64RegisterCs);
743	if (fWhat & CPUMCTX_EXTRN_SS)
744	GET_SEG(pCtx->ss, WHvX64RegisterSs);
745	if (fWhat & CPUMCTX_EXTRN_DS)
746	GET_SEG(pCtx->ds, WHvX64RegisterDs);
747	if (fWhat & CPUMCTX_EXTRN_FS)
748	GET_SEG(pCtx->fs, WHvX64RegisterFs);
749	if (fWhat & CPUMCTX_EXTRN_GS)
750	GET_SEG(pCtx->gs, WHvX64RegisterGs);
751	}
752
753	/* Descriptor tables and the task segment. */
754	if (fWhat & CPUMCTX_EXTRN_TABLE_MASK)
755	{
756	if (fWhat & CPUMCTX_EXTRN_LDTR)
757	GET_SEG(pCtx->ldtr, WHvX64RegisterLdtr);
758
759	if (fWhat & CPUMCTX_EXTRN_TR)
760	{
761	/* AMD-V likes loading TR with in AVAIL state, whereas intel insists on BUSY. So,
762	avoid to trigger sanity assertions around the code, always fix this. */
763	GET_SEG(pCtx->tr, WHvX64RegisterTr);
764	switch (pCtx->tr.Attr.n.u4Type)
765	{
766	case X86_SEL_TYPE_SYS_386_TSS_BUSY:
767	case X86_SEL_TYPE_SYS_286_TSS_BUSY:
768	break;
769	case X86_SEL_TYPE_SYS_386_TSS_AVAIL:
770	pCtx->tr.Attr.n.u4Type = X86_SEL_TYPE_SYS_386_TSS_BUSY;
771	break;
772	case X86_SEL_TYPE_SYS_286_TSS_AVAIL:
773	pCtx->tr.Attr.n.u4Type = X86_SEL_TYPE_SYS_286_TSS_BUSY;
774	break;
775	}
776	}
777	if (fWhat & CPUMCTX_EXTRN_IDTR)
778	{
779	Assert(aenmNames[iReg] == WHvX64RegisterIdtr);
780	pCtx->idtr.cbIdt = aValues[iReg].Table.Limit;
781	pCtx->idtr.pIdt = aValues[iReg].Table.Base;
782	iReg++;
783	}
784	if (fWhat & CPUMCTX_EXTRN_GDTR)
785	{
786	Assert(aenmNames[iReg] == WHvX64RegisterGdtr);
787	pCtx->gdtr.cbGdt = aValues[iReg].Table.Limit;
788	pCtx->gdtr.pGdt = aValues[iReg].Table.Base;
789	iReg++;
790	}
791	}
792
793	/* Control registers. */
794	bool fMaybeChangedMode = false;
795	bool fFlushTlb = false;
796	bool fFlushGlobalTlb = false;
797	if (fWhat & CPUMCTX_EXTRN_CR_MASK)
798	{
799	if (fWhat & CPUMCTX_EXTRN_CR0)
800	{
801	Assert(aenmNames[iReg] == WHvX64RegisterCr0);
802	if (pCtx->cr0 != aValues[iReg].Reg64)
803	{
804	CPUMSetGuestCR0(pVCpu, aValues[iReg].Reg64);
805	fMaybeChangedMode = true;
806	fFlushTlb = fFlushGlobalTlb = true; /// @todo fix this
807	}
808	iReg++;
809	}
810	if (fWhat & CPUMCTX_EXTRN_CR2)
811	GET_REG64(pCtx->cr2, WHvX64RegisterCr2);
812	if (fWhat & CPUMCTX_EXTRN_CR3)
813	{
814	if (pCtx->cr3 != aValues[iReg].Reg64)
815	{
816	CPUMSetGuestCR3(pVCpu, aValues[iReg].Reg64);
817	fFlushTlb = true;
818	}
819	iReg++;
820	}
821	if (fWhat & CPUMCTX_EXTRN_CR4)
822	{
823	if (pCtx->cr4 != aValues[iReg].Reg64)
824	{
825	CPUMSetGuestCR4(pVCpu, aValues[iReg].Reg64);
826	fMaybeChangedMode = true;
827	fFlushTlb = fFlushGlobalTlb = true; /// @todo fix this
828	}
829	iReg++;
830	}
831	}
832
833	/// @todo CR8/TPR
834	Assert(aenmNames[iReg] == WHvX64RegisterCr8);
835	APICSetTpr(pVCpu, (uint8_t)aValues[iReg].Reg64 << 4);
836	iReg++;
837
838	/* Debug registers. */
839	/** @todo fixme */
840	if (fWhat & CPUMCTX_EXTRN_DR0_DR3)
841	{
842	Assert(aenmNames[iReg] == WHvX64RegisterDr0);
843	Assert(aenmNames[iReg+3] == WHvX64RegisterDr3);
844	if (pCtx->dr[0] != aValues[iReg].Reg64)
845	CPUMSetGuestDR0(pVCpu, aValues[iReg].Reg64);
846	iReg++;
847	if (pCtx->dr[1] != aValues[iReg].Reg64)
848	CPUMSetGuestDR1(pVCpu, aValues[iReg].Reg64);
849	iReg++;
850	if (pCtx->dr[2] != aValues[iReg].Reg64)
851	CPUMSetGuestDR2(pVCpu, aValues[iReg].Reg64);
852	iReg++;
853	if (pCtx->dr[3] != aValues[iReg].Reg64)
854	CPUMSetGuestDR3(pVCpu, aValues[iReg].Reg64);
855	iReg++;
856	}
857	if (fWhat & CPUMCTX_EXTRN_DR6)
858	{
859	Assert(aenmNames[iReg] == WHvX64RegisterDr6);
860	if (pCtx->dr[6] != aValues[iReg].Reg64)
861	CPUMSetGuestDR6(pVCpu, aValues[iReg].Reg64);
862	iReg++;
863	}
864	if (fWhat & CPUMCTX_EXTRN_DR7)
865	{
866	Assert(aenmNames[iReg] == WHvX64RegisterDr7);
867	if (pCtx->dr[7] != aValues[iReg].Reg64)
868	CPUMSetGuestDR7(pVCpu, aValues[iReg].Reg64);
869	iReg++;
870	}
871
872	/* Floating point state. */
873	if (fWhat & CPUMCTX_EXTRN_X87)
874	{
875	GET_REG128(pCtx->pXStateR3->x87.aRegs[0].au64[0], pCtx->pXStateR3->x87.aRegs[0].au64[1], WHvX64RegisterFpMmx0);
876	GET_REG128(pCtx->pXStateR3->x87.aRegs[1].au64[0], pCtx->pXStateR3->x87.aRegs[1].au64[1], WHvX64RegisterFpMmx1);
877	GET_REG128(pCtx->pXStateR3->x87.aRegs[2].au64[0], pCtx->pXStateR3->x87.aRegs[2].au64[1], WHvX64RegisterFpMmx2);
878	GET_REG128(pCtx->pXStateR3->x87.aRegs[3].au64[0], pCtx->pXStateR3->x87.aRegs[3].au64[1], WHvX64RegisterFpMmx3);
879	GET_REG128(pCtx->pXStateR3->x87.aRegs[4].au64[0], pCtx->pXStateR3->x87.aRegs[4].au64[1], WHvX64RegisterFpMmx4);
880	GET_REG128(pCtx->pXStateR3->x87.aRegs[5].au64[0], pCtx->pXStateR3->x87.aRegs[5].au64[1], WHvX64RegisterFpMmx5);
881	GET_REG128(pCtx->pXStateR3->x87.aRegs[6].au64[0], pCtx->pXStateR3->x87.aRegs[6].au64[1], WHvX64RegisterFpMmx6);
882	GET_REG128(pCtx->pXStateR3->x87.aRegs[7].au64[0], pCtx->pXStateR3->x87.aRegs[7].au64[1], WHvX64RegisterFpMmx7);
883
884	Assert(aenmNames[iReg] == WHvX64RegisterFpControlStatus);
885	pCtx->pXStateR3->x87.FCW = aValues[iReg].FpControlStatus.FpControl;
886	pCtx->pXStateR3->x87.FSW = aValues[iReg].FpControlStatus.FpStatus;
887	pCtx->pXStateR3->x87.FTW = aValues[iReg].FpControlStatus.FpTag
888	/\| (aValues[iReg].FpControlStatus.Reserved << 8)/;
889	pCtx->pXStateR3->x87.FOP = aValues[iReg].FpControlStatus.LastFpOp;
890	pCtx->pXStateR3->x87.FPUIP = (uint32_t)aValues[iReg].FpControlStatus.LastFpRip;
891	pCtx->pXStateR3->x87.CS = (uint16_t)(aValues[iReg].FpControlStatus.LastFpRip >> 32);
892	pCtx->pXStateR3->x87.Rsrvd1 = (uint16_t)(aValues[iReg].FpControlStatus.LastFpRip >> 48);
893	iReg++;
894	}
895
896	if (fWhat & (CPUMCTX_EXTRN_X87 \| CPUMCTX_EXTRN_SSE_AVX))
897	{
898	Assert(aenmNames[iReg] == WHvX64RegisterXmmControlStatus);
899	if (fWhat & CPUMCTX_EXTRN_X87)
900	{
901	pCtx->pXStateR3->x87.FPUDP = (uint32_t)aValues[iReg].XmmControlStatus.LastFpRdp;
902	pCtx->pXStateR3->x87.DS = (uint16_t)(aValues[iReg].XmmControlStatus.LastFpRdp >> 32);
903	pCtx->pXStateR3->x87.Rsrvd2 = (uint16_t)(aValues[iReg].XmmControlStatus.LastFpRdp >> 48);
904	}
905	pCtx->pXStateR3->x87.MXCSR = aValues[iReg].XmmControlStatus.XmmStatusControl;
906	pCtx->pXStateR3->x87.MXCSR_MASK = aValues[iReg].XmmControlStatus.XmmStatusControlMask; /** @todo ??? (Isn't this an output field?) */
907	iReg++;
908	}
909
910	/* Vector state. */
911	if (fWhat & CPUMCTX_EXTRN_SSE_AVX)
912	{
913	GET_REG128(pCtx->pXStateR3->x87.aXMM[ 0].uXmm.s.Lo, pCtx->pXStateR3->x87.aXMM[ 0].uXmm.s.Hi, WHvX64RegisterXmm0);
914	GET_REG128(pCtx->pXStateR3->x87.aXMM[ 1].uXmm.s.Lo, pCtx->pXStateR3->x87.aXMM[ 1].uXmm.s.Hi, WHvX64RegisterXmm1);
915	GET_REG128(pCtx->pXStateR3->x87.aXMM[ 2].uXmm.s.Lo, pCtx->pXStateR3->x87.aXMM[ 2].uXmm.s.Hi, WHvX64RegisterXmm2);
916	GET_REG128(pCtx->pXStateR3->x87.aXMM[ 3].uXmm.s.Lo, pCtx->pXStateR3->x87.aXMM[ 3].uXmm.s.Hi, WHvX64RegisterXmm3);
917	GET_REG128(pCtx->pXStateR3->x87.aXMM[ 4].uXmm.s.Lo, pCtx->pXStateR3->x87.aXMM[ 4].uXmm.s.Hi, WHvX64RegisterXmm4);
918	GET_REG128(pCtx->pXStateR3->x87.aXMM[ 5].uXmm.s.Lo, pCtx->pXStateR3->x87.aXMM[ 5].uXmm.s.Hi, WHvX64RegisterXmm5);
919	GET_REG128(pCtx->pXStateR3->x87.aXMM[ 6].uXmm.s.Lo, pCtx->pXStateR3->x87.aXMM[ 6].uXmm.s.Hi, WHvX64RegisterXmm6);
920	GET_REG128(pCtx->pXStateR3->x87.aXMM[ 7].uXmm.s.Lo, pCtx->pXStateR3->x87.aXMM[ 7].uXmm.s.Hi, WHvX64RegisterXmm7);
921	GET_REG128(pCtx->pXStateR3->x87.aXMM[ 8].uXmm.s.Lo, pCtx->pXStateR3->x87.aXMM[ 8].uXmm.s.Hi, WHvX64RegisterXmm8);
922	GET_REG128(pCtx->pXStateR3->x87.aXMM[ 9].uXmm.s.Lo, pCtx->pXStateR3->x87.aXMM[ 9].uXmm.s.Hi, WHvX64RegisterXmm9);
923	GET_REG128(pCtx->pXStateR3->x87.aXMM[10].uXmm.s.Lo, pCtx->pXStateR3->x87.aXMM[10].uXmm.s.Hi, WHvX64RegisterXmm10);
924	GET_REG128(pCtx->pXStateR3->x87.aXMM[11].uXmm.s.Lo, pCtx->pXStateR3->x87.aXMM[11].uXmm.s.Hi, WHvX64RegisterXmm11);
925	GET_REG128(pCtx->pXStateR3->x87.aXMM[12].uXmm.s.Lo, pCtx->pXStateR3->x87.aXMM[12].uXmm.s.Hi, WHvX64RegisterXmm12);
926	GET_REG128(pCtx->pXStateR3->x87.aXMM[13].uXmm.s.Lo, pCtx->pXStateR3->x87.aXMM[13].uXmm.s.Hi, WHvX64RegisterXmm13);
927	GET_REG128(pCtx->pXStateR3->x87.aXMM[14].uXmm.s.Lo, pCtx->pXStateR3->x87.aXMM[14].uXmm.s.Hi, WHvX64RegisterXmm14);
928	GET_REG128(pCtx->pXStateR3->x87.aXMM[15].uXmm.s.Lo, pCtx->pXStateR3->x87.aXMM[15].uXmm.s.Hi, WHvX64RegisterXmm15);
929	}
930
931	/* MSRs */
932	// WHvX64RegisterTsc - don't touch
933	if (fWhat & CPUMCTX_EXTRN_EFER)
934	{
935	Assert(aenmNames[iReg] == WHvX64RegisterEfer);
936	if (aValues[iReg].Reg64 != pCtx->msrEFER)
937	{
938	Log7(("NEM/%u: MSR EFER changed %RX64 -> %RX64\n", pVCpu->idCpu, pCtx->msrEFER, aValues[iReg].Reg64));
939	if ((aValues[iReg].Reg64 ^ pCtx->msrEFER) & MSR_K6_EFER_NXE)
940	PGMNotifyNxeChanged(pVCpu, RT_BOOL(aValues[iReg].Reg64 & MSR_K6_EFER_NXE));
941	pCtx->msrEFER = aValues[iReg].Reg64;
942	fMaybeChangedMode = true;
943	}
944	iReg++;
945	}
946	if (fWhat & CPUMCTX_EXTRN_KERNEL_GS_BASE)
947	GET_REG64_LOG7(pCtx->msrKERNELGSBASE, WHvX64RegisterKernelGsBase, "MSR KERNEL_GS_BASE");
948	if (fWhat & CPUMCTX_EXTRN_SYSENTER_MSRS)
949	{
950	GET_REG64_LOG7(pCtx->SysEnter.cs, WHvX64RegisterSysenterCs, "MSR SYSENTER.CS");
951	GET_REG64_LOG7(pCtx->SysEnter.eip, WHvX64RegisterSysenterEip, "MSR SYSENTER.EIP");
952	GET_REG64_LOG7(pCtx->SysEnter.esp, WHvX64RegisterSysenterEsp, "MSR SYSENTER.ESP");
953	}
954	if (fWhat & CPUMCTX_EXTRN_SYSCALL_MSRS)
955	{
956	GET_REG64_LOG7(pCtx->msrSTAR, WHvX64RegisterStar, "MSR STAR");
957	GET_REG64_LOG7(pCtx->msrLSTAR, WHvX64RegisterLstar, "MSR LSTAR");
958	GET_REG64_LOG7(pCtx->msrCSTAR, WHvX64RegisterCstar, "MSR CSTAR");
959	GET_REG64_LOG7(pCtx->msrSFMASK, WHvX64RegisterSfmask, "MSR SFMASK");
960	}
961	if (fWhat & CPUMCTX_EXTRN_OTHER_MSRS)
962	{
963	Assert(aenmNames[iReg] == WHvX64RegisterApicBase);
964	const uint64_t uOldBase = APICGetBaseMsrNoCheck(pVCpu);
965	if (aValues[iReg].Reg64 != uOldBase)
966	{
967	Log7(("NEM/%u: MSR APICBase changed %RX64 -> %RX64 (%RX64)\n",
968	pVCpu->idCpu, uOldBase, aValues[iReg].Reg64, aValues[iReg].Reg64 ^ uOldBase));
969	VBOXSTRICTRC rc2 = APICSetBaseMsr(pVCpu, aValues[iReg].Reg64);
970	AssertLogRelMsg(rc2 == VINF_SUCCESS, ("%Rrc %RX64\n", VBOXSTRICTRC_VAL(rc2), aValues[iReg].Reg64));
971	}
972	iReg++;
973
974	GET_REG64_LOG7(pCtx->msrPAT, WHvX64RegisterPat, "MSR PAT");
975	#if 0 /def LOG_ENABLED/ /** @todo something's wrong with HvX64RegisterMtrrCap? (AMD) */
976	GET_REG64_LOG7(pCtx->msrPAT, WHvX64RegisterMsrMtrrCap);
977	#endif
978	PCPUMCTXMSRS pCtxMsrs = CPUMQueryGuestCtxMsrsPtr(pVCpu);
979	GET_REG64_LOG7(pCtxMsrs->msr.MtrrDefType, WHvX64RegisterMsrMtrrDefType, "MSR MTRR_DEF_TYPE");
980	GET_REG64_LOG7(pCtxMsrs->msr.MtrrFix64K_00000, WHvX64RegisterMsrMtrrFix64k00000, "MSR MTRR_FIX_64K_00000");
981	GET_REG64_LOG7(pCtxMsrs->msr.MtrrFix16K_80000, WHvX64RegisterMsrMtrrFix16k80000, "MSR MTRR_FIX_16K_80000");
982	GET_REG64_LOG7(pCtxMsrs->msr.MtrrFix16K_A0000, WHvX64RegisterMsrMtrrFix16kA0000, "MSR MTRR_FIX_16K_A0000");
983	GET_REG64_LOG7(pCtxMsrs->msr.MtrrFix4K_C0000, WHvX64RegisterMsrMtrrFix4kC0000, "MSR MTRR_FIX_4K_C0000");
984	GET_REG64_LOG7(pCtxMsrs->msr.MtrrFix4K_C8000, WHvX64RegisterMsrMtrrFix4kC8000, "MSR MTRR_FIX_4K_C8000");
985	GET_REG64_LOG7(pCtxMsrs->msr.MtrrFix4K_D0000, WHvX64RegisterMsrMtrrFix4kD0000, "MSR MTRR_FIX_4K_D0000");
986	GET_REG64_LOG7(pCtxMsrs->msr.MtrrFix4K_D8000, WHvX64RegisterMsrMtrrFix4kD8000, "MSR MTRR_FIX_4K_D8000");
987	GET_REG64_LOG7(pCtxMsrs->msr.MtrrFix4K_E0000, WHvX64RegisterMsrMtrrFix4kE0000, "MSR MTRR_FIX_4K_E0000");
988	GET_REG64_LOG7(pCtxMsrs->msr.MtrrFix4K_E8000, WHvX64RegisterMsrMtrrFix4kE8000, "MSR MTRR_FIX_4K_E8000");
989	GET_REG64_LOG7(pCtxMsrs->msr.MtrrFix4K_F0000, WHvX64RegisterMsrMtrrFix4kF0000, "MSR MTRR_FIX_4K_F0000");
990	GET_REG64_LOG7(pCtxMsrs->msr.MtrrFix4K_F8000, WHvX64RegisterMsrMtrrFix4kF8000, "MSR MTRR_FIX_4K_F8000");
991	GET_REG64_LOG7(pCtxMsrs->msr.TscAux, WHvX64RegisterTscAux, "MSR TSC_AUX");
992	/** @todo look for HvX64RegisterIa32MiscEnable and HvX64RegisterIa32FeatureControl? */
993	}
994
995	/* Interruptibility. */
996	if (fWhat & (CPUMCTX_EXTRN_NEM_WIN_INHIBIT_INT \| CPUMCTX_EXTRN_NEM_WIN_INHIBIT_NMI))
997	{
998	Assert(aenmNames[iReg] == WHvRegisterInterruptState);
999	Assert(aenmNames[iReg + 1] == WHvX64RegisterRip);
1000
1001	if (!(pCtx->fExtrn & CPUMCTX_EXTRN_NEM_WIN_INHIBIT_INT))
1002	{
1003	pVCpu->nem.s.fLastInterruptShadow = aValues[iReg].InterruptState.InterruptShadow;
1004	if (aValues[iReg].InterruptState.InterruptShadow)
1005	EMSetInhibitInterruptsPC(pVCpu, aValues[iReg + 1].Reg64);
1006	else
1007	VMCPU_FF_CLEAR(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS);
1008	}
1009
1010	if (!(pCtx->fExtrn & CPUMCTX_EXTRN_NEM_WIN_INHIBIT_NMI))
1011	{
1012	if (aValues[iReg].InterruptState.NmiMasked)
1013	VMCPU_FF_SET(pVCpu, VMCPU_FF_BLOCK_NMIS);
1014	else
1015	VMCPU_FF_CLEAR(pVCpu, VMCPU_FF_BLOCK_NMIS);
1016	}
1017
1018	fWhat \|= CPUMCTX_EXTRN_NEM_WIN_INHIBIT_INT \| CPUMCTX_EXTRN_NEM_WIN_INHIBIT_NMI;
1019	iReg += 2;
1020	}
1021
1022	/* Event injection. */
1023	/// @todo WHvRegisterPendingInterruption
1024	Assert(aenmNames[iReg] == WHvRegisterPendingInterruption);
1025	if (aValues[iReg].PendingInterruption.InterruptionPending)
1026	{
1027	Log7(("PendingInterruption: type=%u vector=%#x errcd=%RTbool/%#x instr-len=%u nested=%u\n",
1028	aValues[iReg].PendingInterruption.InterruptionType, aValues[iReg].PendingInterruption.InterruptionVector,
1029	aValues[iReg].PendingInterruption.DeliverErrorCode, aValues[iReg].PendingInterruption.ErrorCode,
1030	aValues[iReg].PendingInterruption.InstructionLength, aValues[iReg].PendingInterruption.NestedEvent));
1031	AssertMsg((aValues[iReg].PendingInterruption.AsUINT64 & UINT64_C(0xfc00)) == 0,
1032	("%#RX64\n", aValues[iReg].PendingInterruption.AsUINT64));
1033	}
1034
1035	/// @todo WHvRegisterPendingEvent0
1036	/// @todo WHvRegisterPendingEvent1
1037
1038	/* Almost done, just update extrn flags and maybe change PGM mode. */
1039	pCtx->fExtrn &= ~fWhat;
1040
1041	/* Typical. */
1042	if (!fMaybeChangedMode && !fFlushTlb)
1043	return VINF_SUCCESS;
1044
1045	/*
1046	* Slow.
1047	*/
1048	if (fMaybeChangedMode)
1049	{
1050	int rc = PGMChangeMode(pVCpu, pCtx->cr0, pCtx->cr4, pCtx->msrEFER);
1051	AssertMsg(rc == VINF_SUCCESS, ("rc=%Rrc\n", rc));
1052	}
1053
1054	if (fFlushTlb)
1055	{
1056	int rc = PGMFlushTLB(pVCpu, pCtx->cr3, fFlushGlobalTlb);
1057	AssertMsg(rc == VINF_SUCCESS, ("rc=%Rrc\n", rc));
1058	}
1059
1060	return VINF_SUCCESS;
1061	# endif /* !NEM_WIN_USE_HYPERCALLS_FOR_REGISTERS */
1062	}
1063
1064	#endif /* !IN_RING0 */
1065
1066
1067	#ifdef LOG_ENABLED
1068	/**
1069	* Get the virtual processor running status.
1070	*/
1071	DECLINLINE(VID_PROCESSOR_STATUS) nemHCWinCpuGetRunningStatus(PVMCPU pVCpu)
1072	{
1073	# ifdef IN_RING0
1074	NOREF(pVCpu);
1075	return VidProcessorStatusUndefined;
1076	# else
1077	RTERRVARS Saved;
1078	RTErrVarsSave(&Saved);
1079
1080	/*
1081	* This API is disabled in release builds, it seems. On build 17101 it requires
1082	* the following patch to be enabled (windbg): eb vid+12180 0f 84 98 00 00 00
1083	*/
1084	VID_PROCESSOR_STATUS enmCpuStatus = VidProcessorStatusUndefined;
1085	NTSTATUS rcNt = g_pfnVidGetVirtualProcessorRunningStatus(pVCpu->pVMR3->nem.s.hPartitionDevice, pVCpu->idCpu, &enmCpuStatus);
1086	AssertRC(rcNt);
1087
1088	RTErrVarsRestore(&Saved);
1089	return enmCpuStatus;
1090	# endif
1091	}
1092	#endif
1093
1094
1095	#ifdef NEM_WIN_USE_OUR_OWN_RUN_API
1096	# ifdef IN_RING3 /* hopefully not needed in ring-0, as we'd need KTHREADs and KeAlertThread. */
1097	/**
1098	* Our own WHvCancelRunVirtualProcessor that can later be moved to ring-0.
1099	*
1100	* This is an experiment only.
1101	*
1102	* @returns VBox status code.
1103	* @param pVM The cross context VM structure.
1104	* @param pVCpu The cross context virtual CPU structure of the
1105	* calling EMT.
1106	*/
1107	NEM_TMPL_STATIC int nemHCWinCancelRunVirtualProcessor(PVM pVM, PVMCPU pVCpu)
1108	{
1109	/*
1110	* Work the state.
1111	*
1112	* From the looks of things, we should let the EMT call VidStopVirtualProcessor.
1113	* So, we just need to modify the state and kick the EMT if it's waiting on
1114	* messages. For the latter we use QueueUserAPC / KeAlterThread.
1115	*/
1116	for (;;)
1117	{
1118	VMCPUSTATE enmState = VMCPU_GET_STATE(pVCpu);
1119	switch (enmState)
1120	{
1121	case VMCPUSTATE_STARTED_EXEC_NEM:
1122	if (VMCPU_CMPXCHG_STATE(pVCpu, VMCPUSTATE_STARTED_EXEC_NEM_CANCELED, VMCPUSTATE_STARTED_EXEC_NEM))
1123	{
1124	Log8(("nemHCWinCancelRunVirtualProcessor: Switched %u to canceled state\n", pVCpu->idCpu));
1125	STAM_REL_COUNTER_INC(&pVCpu->nem.s.StatCancelChangedState);
1126	return VINF_SUCCESS;
1127	}
1128	break;
1129
1130	case VMCPUSTATE_STARTED_EXEC_NEM_WAIT:
1131	if (VMCPU_CMPXCHG_STATE(pVCpu, VMCPUSTATE_STARTED_EXEC_NEM_CANCELED, VMCPUSTATE_STARTED_EXEC_NEM_WAIT))
1132	{
1133	# ifdef IN_RING0
1134	NTSTATUS rcNt = KeAlertThread(??);
1135	# else
1136	NTSTATUS rcNt = NtAlertThread(pVCpu->nem.s.hNativeThreadHandle);
1137	# endif
1138	Log8(("nemHCWinCancelRunVirtualProcessor: Alerted %u: %#x\n", pVCpu->idCpu, rcNt));
1139	Assert(rcNt == STATUS_SUCCESS);
1140	if (NT_SUCCESS(rcNt))
1141	{
1142	STAM_REL_COUNTER_INC(&pVCpu->nem.s.StatCancelAlertedThread);
1143	return VINF_SUCCESS;
1144	}
1145	AssertLogRelMsgFailedReturn(("NtAlertThread failed: %#x\n", rcNt), RTErrConvertFromNtStatus(rcNt));
1146	}
1147	break;
1148
1149	default:
1150	return VINF_SUCCESS;
1151	}
1152
1153	ASMNopPause();
1154	RT_NOREF(pVM);
1155	}
1156	}
1157	# endif /* IN_RING3 */
1158	#endif /* NEM_WIN_USE_OUR_OWN_RUN_API */
1159
1160
1161	#ifdef LOG_ENABLED
1162	/**
1163	* Logs the current CPU state.
1164	*/
1165	NEM_TMPL_STATIC void nemHCWinLogState(PVM pVM, PVMCPU pVCpu)
1166	{
1167	if (LogIs3Enabled())
1168	{
1169	# ifdef IN_RING3
1170	char szRegs[4096];
1171	DBGFR3RegPrintf(pVM->pUVM, pVCpu->idCpu, &szRegs[0], sizeof(szRegs),
1172	"rax=%016VR{rax} rbx=%016VR{rbx} rcx=%016VR{rcx} rdx=%016VR{rdx}\n"
1173	"rsi=%016VR{rsi} rdi=%016VR{rdi} r8 =%016VR{r8} r9 =%016VR{r9}\n"
1174	"r10=%016VR{r10} r11=%016VR{r11} r12=%016VR{r12} r13=%016VR{r13}\n"
1175	"r14=%016VR{r14} r15=%016VR{r15} %VRF{rflags}\n"
1176	"rip=%016VR{rip} rsp=%016VR{rsp} rbp=%016VR{rbp}\n"
1177	"cs={%04VR{cs} base=%016VR{cs_base} limit=%08VR{cs_lim} flags=%04VR{cs_attr}} cr0=%016VR{cr0}\n"
1178	"ds={%04VR{ds} base=%016VR{ds_base} limit=%08VR{ds_lim} flags=%04VR{ds_attr}} cr2=%016VR{cr2}\n"
1179	"es={%04VR{es} base=%016VR{es_base} limit=%08VR{es_lim} flags=%04VR{es_attr}} cr3=%016VR{cr3}\n"
1180	"fs={%04VR{fs} base=%016VR{fs_base} limit=%08VR{fs_lim} flags=%04VR{fs_attr}} cr4=%016VR{cr4}\n"
1181	"gs={%04VR{gs} base=%016VR{gs_base} limit=%08VR{gs_lim} flags=%04VR{gs_attr}} cr8=%016VR{cr8}\n"
1182	"ss={%04VR{ss} base=%016VR{ss_base} limit=%08VR{ss_lim} flags=%04VR{ss_attr}}\n"
1183	"dr0=%016VR{dr0} dr1=%016VR{dr1} dr2=%016VR{dr2} dr3=%016VR{dr3}\n"
1184	"dr6=%016VR{dr6} dr7=%016VR{dr7}\n"
1185	"gdtr=%016VR{gdtr_base}:%04VR{gdtr_lim} idtr=%016VR{idtr_base}:%04VR{idtr_lim} rflags=%08VR{rflags}\n"
1186	"ldtr={%04VR{ldtr} base=%016VR{ldtr_base} limit=%08VR{ldtr_lim} flags=%08VR{ldtr_attr}}\n"
1187	"tr ={%04VR{tr} base=%016VR{tr_base} limit=%08VR{tr_lim} flags=%08VR{tr_attr}}\n"
1188	" sysenter={cs=%04VR{sysenter_cs} eip=%08VR{sysenter_eip} esp=%08VR{sysenter_esp}}\n"
1189	" efer=%016VR{efer}\n"
1190	" pat=%016VR{pat}\n"
1191	" sf_mask=%016VR{sf_mask}\n"
1192	"krnl_gs_base=%016VR{krnl_gs_base}\n"
1193	" lstar=%016VR{lstar}\n"
1194	" star=%016VR{star} cstar=%016VR{cstar}\n"
1195	"fcw=%04VR{fcw} fsw=%04VR{fsw} ftw=%04VR{ftw} mxcsr=%04VR{mxcsr} mxcsr_mask=%04VR{mxcsr_mask}\n"
1196	);
1197
1198	char szInstr[256];
1199	DBGFR3DisasInstrEx(pVM->pUVM, pVCpu->idCpu, 0, 0,
1200	DBGF_DISAS_FLAGS_CURRENT_GUEST \| DBGF_DISAS_FLAGS_DEFAULT_MODE,
1201	szInstr, sizeof(szInstr), NULL);
1202	Log3(("%s%s\n", szRegs, szInstr));
1203	# else
1204	/** @todo stat logging in ring-0 */
1205	RT_NOREF(pVM, pVCpu);
1206	# endif
1207	}
1208	}
1209	#endif /* LOG_ENABLED */
1210
1211
1212	#ifdef LOG_ENABLED
1213	/** Macro used by nemHCWinExecStateToLogStr and nemR3WinExecStateToLogStr. */
1214	# define SWITCH_IT(a_szPrefix) \
1215	do \
1216	switch (u)\
1217	{ \
1218	case 0x00: return a_szPrefix ""; \
1219	case 0x01: return a_szPrefix ",Pnd"; \
1220	case 0x02: return a_szPrefix ",Dbg"; \
1221	case 0x03: return a_szPrefix ",Pnd,Dbg"; \
1222	case 0x04: return a_szPrefix ",Shw"; \
1223	case 0x05: return a_szPrefix ",Pnd,Shw"; \
1224	case 0x06: return a_szPrefix ",Shw,Dbg"; \
1225	case 0x07: return a_szPrefix ",Pnd,Shw,Dbg"; \
1226	default: AssertFailedReturn("WTF?"); \
1227	} \
1228	while (0)
1229
1230	# ifdef NEM_WIN_USE_OUR_OWN_RUN_API
1231	/**
1232	* Translates the execution stat bitfield into a short log string, VID version.
1233	*
1234	* @returns Read-only log string.
1235	* @param pMsgHdr The header which state to summarize.
1236	*/
1237	static const char nemHCWinExecStateToLogStr(HV_X64_INTERCEPT_MESSAGE_HEADER const pMsgHdr)
1238	{
1239	unsigned u = (unsigned)pMsgHdr->ExecutionState.InterruptionPending
1240	\| ((unsigned)pMsgHdr->ExecutionState.DebugActive << 1)
1241	\| ((unsigned)pMsgHdr->ExecutionState.InterruptShadow << 2);
1242	if (pMsgHdr->ExecutionState.EferLma)
1243	SWITCH_IT("LM");
1244	else if (pMsgHdr->ExecutionState.Cr0Pe)
1245	SWITCH_IT("PM");
1246	else
1247	SWITCH_IT("RM");
1248	}
1249	# elif defined(IN_RING3)
1250	/**
1251	* Translates the execution stat bitfield into a short log string, WinHv version.
1252	*
1253	* @returns Read-only log string.
1254	* @param pExitCtx The exit context which state to summarize.
1255	*/
1256	static const char nemR3WinExecStateToLogStr(WHV_VP_EXIT_CONTEXT const pExitCtx)
1257	{
1258	unsigned u = (unsigned)pExitCtx->ExecutionState.InterruptionPending
1259	\| ((unsigned)pExitCtx->ExecutionState.DebugActive << 1)
1260	\| ((unsigned)pExitCtx->ExecutionState.InterruptShadow << 2);
1261	if (pExitCtx->ExecutionState.EferLma)
1262	SWITCH_IT("LM");
1263	else if (pExitCtx->ExecutionState.Cr0Pe)
1264	SWITCH_IT("PM");
1265	else
1266	SWITCH_IT("RM");
1267	}
1268	# endif /* IN_RING3 && !NEM_WIN_USE_OUR_OWN_RUN_API */
1269	# undef SWITCH_IT
1270	#endif /* LOG_ENABLED */
1271
1272
1273	#ifdef NEM_WIN_USE_OUR_OWN_RUN_API
1274	/**
1275	* Advances the guest RIP and clear EFLAGS.RF, VID version.
1276	*
1277	* This may clear VMCPU_FF_INHIBIT_INTERRUPTS.
1278	*
1279	* @param pVCpu The cross context virtual CPU structure.
1280	* @param pCtx The CPU context to update.
1281	* @param pExitCtx The exit context.
1282	*/
1283	DECLINLINE(void) nemHCWinAdvanceGuestRipAndClearRF(PVMCPU pVCpu, PCPUMCTX pCtx, HV_X64_INTERCEPT_MESSAGE_HEADER const *pMsgHdr)
1284	{
1285	Assert(!(pCtx->fExtrn & (CPUMCTX_EXTRN_RIP \| CPUMCTX_EXTRN_RFLAGS)));
1286
1287	/* Advance the RIP. */
1288	Assert(pMsgHdr->InstructionLength > 0 && pMsgHdr->InstructionLength < 16);
1289	pCtx->rip += pMsgHdr->InstructionLength;
1290	pCtx->rflags.Bits.u1RF = 0;
1291
1292	/* Update interrupt inhibition. */
1293	if (!VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS))
1294	{ /* likely */ }
1295	else if (pCtx->rip != EMGetInhibitInterruptsPC(pVCpu))
1296	VMCPU_FF_CLEAR(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS);
1297	}
1298	#elif defined(IN_RING3)
1299	/**
1300	* Advances the guest RIP and clear EFLAGS.RF, WinHv version.
1301	*
1302	* This may clear VMCPU_FF_INHIBIT_INTERRUPTS.
1303	*
1304	* @param pVCpu The cross context virtual CPU structure.
1305	* @param pCtx The CPU context to update.
1306	* @param pExitCtx The exit context.
1307	*/
1308	DECLINLINE(void) nemR3WinAdvanceGuestRipAndClearRF(PVMCPU pVCpu, PCPUMCTX pCtx, WHV_VP_EXIT_CONTEXT const *pExitCtx)
1309	{
1310	Assert(!(pCtx->fExtrn & (CPUMCTX_EXTRN_RIP \| CPUMCTX_EXTRN_RFLAGS)));
1311
1312	/* Advance the RIP. */
1313	Assert(pExitCtx->InstructionLength > 0 && pExitCtx->InstructionLength < 16);
1314	pCtx->rip += pExitCtx->InstructionLength;
1315	pCtx->rflags.Bits.u1RF = 0;
1316
1317	/* Update interrupt inhibition. */
1318	if (!VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS))
1319	{ /* likely */ }
1320	else if (pCtx->rip != EMGetInhibitInterruptsPC(pVCpu))
1321	VMCPU_FF_CLEAR(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS);
1322	}
1323	#endif /* IN_RING3 && !NEM_WIN_USE_OUR_OWN_RUN_API */
1324
1325
1326
1327	NEM_TMPL_STATIC DECLCALLBACK(int)
1328	nemHCWinUnmapOnePageCallback(PVM pVM, PVMCPU pVCpu, RTGCPHYS GCPhys, uint8_t pu2NemState, void pvUser)
1329	{
1330	RT_NOREF_PV(pvUser);
1331	#ifdef NEM_WIN_USE_HYPERCALLS_FOR_PAGES
1332	int rc = nemHCWinHypercallUnmapPage(pVM, pVCpu, GCPhys);
1333	AssertRC(rc);
1334	if (RT_SUCCESS(rc))
1335	#else
1336	RT_NOREF_PV(pVCpu);
1337	HRESULT hrc = WHvUnmapGpaRange(pVM->nem.s.hPartition, GCPhys, X86_PAGE_SIZE);
1338	if (SUCCEEDED(hrc))
1339	#endif
1340	{
1341	Log5(("NEM GPA unmap all: %RGp (cMappedPages=%u)\n", GCPhys, pVM->nem.s.cMappedPages - 1));
1342	*pu2NemState = NEM_WIN_PAGE_STATE_UNMAPPED;
1343	}
1344	else
1345	{
1346	#ifdef NEM_WIN_USE_HYPERCALLS_FOR_PAGES
1347	LogRel(("nemR3WinUnmapOnePageCallback: GCPhys=%RGp rc=%Rrc\n", GCPhys, rc));
1348	#else
1349	LogRel(("nemR3WinUnmapOnePageCallback: GCPhys=%RGp %s hrc=%Rhrc (%#x) Last=%#x/%u (cMappedPages=%u)\n",
1350	GCPhys, g_apszPageStates[*pu2NemState], hrc, hrc, RTNtLastStatusValue(),
1351	RTNtLastErrorValue(), pVM->nem.s.cMappedPages));
1352	#endif
1353	*pu2NemState = NEM_WIN_PAGE_STATE_NOT_SET;
1354	}
1355	if (pVM->nem.s.cMappedPages > 0)
1356	ASMAtomicDecU32(&pVM->nem.s.cMappedPages);
1357	return VINF_SUCCESS;
1358	}
1359
1360
1361	/**
1362	* State to pass between nemHCWinHandleMemoryAccess / nemR3WinWHvHandleMemoryAccess
1363	* and nemHCWinHandleMemoryAccessPageCheckerCallback.
1364	*/
1365	typedef struct NEMHCWINHMACPCCSTATE
1366	{
1367	/** Input: Write access. */
1368	bool fWriteAccess;
1369	/** Output: Set if we did something. */
1370	bool fDidSomething;
1371	/** Output: Set it we should resume. */
1372	bool fCanResume;
1373	} NEMHCWINHMACPCCSTATE;
1374
1375	/**
1376	* @callback_method_impl{FNPGMPHYSNEMCHECKPAGE,
1377	* Worker for nemR3WinHandleMemoryAccess; pvUser points to a
1378	* NEMHCWINHMACPCCSTATE structure. }
1379	*/
1380	NEM_TMPL_STATIC DECLCALLBACK(int)
1381	nemHCWinHandleMemoryAccessPageCheckerCallback(PVM pVM, PVMCPU pVCpu, RTGCPHYS GCPhys, PPGMPHYSNEMPAGEINFO pInfo, void *pvUser)
1382	{
1383	NEMHCWINHMACPCCSTATE pState = (NEMHCWINHMACPCCSTATE )pvUser;
1384	pState->fDidSomething = false;
1385	pState->fCanResume = false;
1386
1387	/* If A20 is disabled, we may need to make another query on the masked
1388	page to get the correct protection information. */
1389	uint8_t u2State = pInfo->u2NemState;
1390	RTGCPHYS GCPhysSrc;
1391	if ( pVM->nem.s.fA20Enabled
1392	\|\| !NEM_WIN_IS_SUBJECT_TO_A20(GCPhys))
1393	GCPhysSrc = GCPhys;
1394	else
1395	{
1396	GCPhysSrc = GCPhys & ~(RTGCPHYS)RT_BIT_32(20);
1397	PGMPHYSNEMPAGEINFO Info2;
1398	int rc = PGMPhysNemPageInfoChecker(pVM, pVCpu, GCPhysSrc, pState->fWriteAccess, &Info2, NULL, NULL);
1399	AssertRCReturn(rc, rc);
1400
1401	*pInfo = Info2;
1402	pInfo->u2NemState = u2State;
1403	}
1404
1405	/*
1406	* Consolidate current page state with actual page protection and access type.
1407	* We don't really consider downgrades here, as they shouldn't happen.
1408	*/
1409	#ifndef NEM_WIN_USE_HYPERCALLS_FOR_PAGES
1410	/** @todo Someone at microsoft please explain:
1411	* I'm not sure WTF was going on, but I ended up in a loop if I remapped a
1412	* readonly page as writable (unmap, then map again). Specifically, this was an
1413	* issue with the big VRAM mapping at 0xe0000000 when booing DSL 4.4.1. So, in
1414	* a hope to work around that we no longer pre-map anything, just unmap stuff
1415	* and do it lazily here. And here we will first unmap, restart, and then remap
1416	* with new protection or backing.
1417	*/
1418	#endif
1419	int rc;
1420	switch (u2State)
1421	{
1422	case NEM_WIN_PAGE_STATE_UNMAPPED:
1423	case NEM_WIN_PAGE_STATE_NOT_SET:
1424	if (pInfo->fNemProt == NEM_PAGE_PROT_NONE)
1425	{
1426	Log4(("nemHCWinHandleMemoryAccessPageCheckerCallback: %RGp - #1\n", GCPhys));
1427	return VINF_SUCCESS;
1428	}
1429
1430	/* Don't bother remapping it if it's a write request to a non-writable page. */
1431	if ( pState->fWriteAccess
1432	&& !(pInfo->fNemProt & NEM_PAGE_PROT_WRITE))
1433	{
1434	Log4(("nemHCWinHandleMemoryAccessPageCheckerCallback: %RGp - #1w\n", GCPhys));
1435	return VINF_SUCCESS;
1436	}
1437
1438	/* Map the page. */
1439	rc = nemHCNativeSetPhysPage(pVM,
1440	pVCpu,
1441	GCPhysSrc & ~(RTGCPHYS)X86_PAGE_OFFSET_MASK,
1442	GCPhys & ~(RTGCPHYS)X86_PAGE_OFFSET_MASK,
1443	pInfo->fNemProt,
1444	&u2State,
1445	true /fBackingState/);
1446	pInfo->u2NemState = u2State;
1447	Log4(("nemHCWinHandleMemoryAccessPageCheckerCallback: %RGp - synced => %s + %Rrc\n",
1448	GCPhys, g_apszPageStates[u2State], rc));
1449	pState->fDidSomething = true;
1450	pState->fCanResume = true;
1451	return rc;
1452
1453	case NEM_WIN_PAGE_STATE_READABLE:
1454	if ( !(pInfo->fNemProt & NEM_PAGE_PROT_WRITE)
1455	&& (pInfo->fNemProt & (NEM_PAGE_PROT_READ \| NEM_PAGE_PROT_EXECUTE)))
1456	{
1457	Log4(("nemHCWinHandleMemoryAccessPageCheckerCallback: %RGp - #2\n", GCPhys));
1458	return VINF_SUCCESS;
1459	}
1460
1461	#ifdef NEM_WIN_USE_HYPERCALLS_FOR_PAGES
1462	/* Upgrade page to writable. */
1463	/** @todo test this*/
1464	if ( (pInfo->fNemProt & NEM_PAGE_PROT_WRITE)
1465	&& pState->fWriteAccess)
1466	{
1467	rc = nemHCWinHypercallMapPage(pVM, pVCpu, GCPhysSrc, GCPhys,
1468	HV_MAP_GPA_READABLE \| HV_MAP_GPA_WRITABLE
1469	\| HV_MAP_GPA_EXECUTABLE \| HV_MAP_GPA_EXECUTABLE_AGAIN);
1470	AssertRC(rc);
1471	if (RT_SUCCESS(rc))
1472	{
1473	pInfo->u2NemState = NEM_WIN_PAGE_STATE_WRITABLE;
1474	pState->fDidSomething = true;
1475	pState->fCanResume = true;
1476	Log5(("NEM GPA write-upgrade/exit: %RGp (was %s, cMappedPages=%u)\n",
1477	GCPhys, g_apszPageStates[u2State], pVM->nem.s.cMappedPages));
1478	}
1479	}
1480	else
1481	{
1482	/* Need to emulate the acces. */
1483	AssertBreak(pInfo->fNemProt != NEM_PAGE_PROT_NONE); /* There should be no downgrades. */
1484	rc = VINF_SUCCESS;
1485	}
1486	return rc;
1487	#else
1488	break;
1489	#endif
1490
1491	case NEM_WIN_PAGE_STATE_WRITABLE:
1492	if (pInfo->fNemProt & NEM_PAGE_PROT_WRITE)
1493	{
1494	Log4(("nemHCWinHandleMemoryAccessPageCheckerCallback: %RGp - #3\n", GCPhys));
1495	return VINF_SUCCESS;
1496	}
1497	#ifdef NEM_WIN_USE_HYPERCALLS_FOR_PAGES
1498	AssertFailed(); /* There should be no downgrades. */
1499	#endif
1500	break;
1501
1502	default:
1503	AssertLogRelMsgFailedReturn(("u2State=%#x\n", u2State), VERR_NEM_IPE_4);
1504	}
1505
1506	/*
1507	* Unmap and restart the instruction.
1508	* If this fails, which it does every so often, just unmap everything for now.
1509	*/
1510	#ifdef NEM_WIN_USE_HYPERCALLS_FOR_PAGES
1511	rc = nemHCWinHypercallUnmapPage(pVM, pVCpu, GCPhys);
1512	AssertRC(rc);
1513	if (RT_SUCCESS(rc))
1514	#else
1515	/** @todo figure out whether we mess up the state or if it's WHv. */
1516	HRESULT hrc = WHvUnmapGpaRange(pVM->nem.s.hPartition, GCPhys, X86_PAGE_SIZE);
1517	if (SUCCEEDED(hrc))
1518	#endif
1519	{
1520	pState->fDidSomething = true;
1521	pState->fCanResume = true;
1522	pInfo->u2NemState = NEM_WIN_PAGE_STATE_UNMAPPED;
1523	uint32_t cMappedPages = ASMAtomicDecU32(&pVM->nem.s.cMappedPages); NOREF(cMappedPages);
1524	Log5(("NEM GPA unmapped/exit: %RGp (was %s, cMappedPages=%u)\n", GCPhys, g_apszPageStates[u2State], cMappedPages));
1525	return VINF_SUCCESS;
1526	}
1527	#ifdef NEM_WIN_USE_HYPERCALLS_FOR_PAGES
1528	LogRel(("nemHCWinHandleMemoryAccessPageCheckerCallback/unmap: GCPhysDst=%RGp rc=%Rrc\n", GCPhys, rc));
1529	return rc;
1530	#else
1531	LogRel(("nemHCWinHandleMemoryAccessPageCheckerCallback/unmap: GCPhysDst=%RGp %s hrc=%Rhrc (%#x) Last=%#x/%u (cMappedPages=%u)\n",
1532	GCPhys, g_apszPageStates[u2State], hrc, hrc, RTNtLastStatusValue(), RTNtLastErrorValue(),
1533	pVM->nem.s.cMappedPages));
1534
1535	PGMPhysNemEnumPagesByState(pVM, pVCpu, NEM_WIN_PAGE_STATE_READABLE, nemR3WinUnmapOnePageCallback, NULL);
1536	Log(("nemHCWinHandleMemoryAccessPageCheckerCallback: Unmapped all (cMappedPages=%u)\n", pVM->nem.s.cMappedPages));
1537
1538	pState->fDidSomething = true;
1539	pState->fCanResume = true;
1540	pInfo->u2NemState = NEM_WIN_PAGE_STATE_UNMAPPED;
1541	return VINF_SUCCESS;
1542	#endif
1543	}
1544
1545
1546
1547	#if defined(IN_RING0) && defined(NEM_WIN_USE_OUR_OWN_RUN_API)
1548	/**
1549	* Wrapper around nemR0WinImportState that converts VERR_NEM_CHANGE_PGM_MODE and
1550	* VERR_NEM_FLUSH_TBL into informational status codes and logs+asserts statuses.
1551	*
1552	* @returns VBox strict status code.
1553	* @param pGVM The global (ring-0) VM structure.
1554	* @param pGVCpu The global (ring-0) per CPU structure.
1555	* @param pCtx The CPU context to import into.
1556	* @param fWhat What to import.
1557	* @param pszCaller Who is doing the importing.
1558	*/
1559	DECLINLINE(VBOXSTRICTRC) nemR0WinImportStateStrict(PGVM pGVM, PGVMCPU pGVCpu, PCPUMCTX pCtx, uint64_t fWhat, const char *pszCaller)
1560	{
1561	int rc = nemR0WinImportState(pGVM, pGVCpu, pCtx, fWhat);
1562	if (RT_SUCCESS(rc))
1563	{
1564	Assert(rc == VINF_SUCCESS);
1565	return VINF_SUCCESS;
1566	}
1567
1568	if (rc == VERR_NEM_CHANGE_PGM_MODE \|\| rc == VERR_NEM_FLUSH_TLB \|\| rc == VERR_NEM_UPDATE_APIC_BASE)
1569	{
1570	Log4(("%s/%u: nemR0WinImportState -> %Rrc\n", pszCaller, pGVCpu->idCpu, -rc));
1571	return -rc;
1572	}
1573	RT_NOREF(pszCaller);
1574	AssertMsgFailedReturn(("%s/%u: nemR0WinImportState failed: %Rrc\n", pszCaller, pGVCpu->idCpu, rc), rc);
1575	}
1576	#endif /* IN_RING0 && NEM_WIN_USE_OUR_OWN_RUN_API*/
1577
1578	#if defined(NEM_WIN_USE_OUR_OWN_RUN_API) \|\| defined(IN_RING3)
1579	/**
1580	* Wrapper around nemR0WinImportStateStrict and nemHCWinCopyStateFromHyperV.
1581	*
1582	* Unlike the wrapped APIs, this checks whether it's necessary.
1583	*
1584	* @returns VBox strict status code.
1585	* @param pGVM The global (ring-0) VM structure.
1586	* @param pGVCpu The global (ring-0) per CPU structure.
1587	* @param pCtx The CPU context to import into.
1588	* @param fWhat What to import.
1589	* @param pszCaller Who is doing the importing.
1590	*/
1591	DECLINLINE(VBOXSTRICTRC) nemHCWinImportStateIfNeededStrict(PVMCPU pVCpu, PGVMCPU pGVCpu, PCPUMCTX pCtx,
1592	uint64_t fWhat, const char *pszCaller)
1593	{
1594	if (pCtx->fExtrn & fWhat)
1595	{
1596	#ifdef IN_RING0
1597	RT_NOREF(pVCpu);
1598	return nemR0WinImportStateStrict(pGVCpu->pGVM, pGVCpu, pCtx, fWhat, pszCaller);
1599	#else
1600	RT_NOREF(pGVCpu, pszCaller);
1601	int rc = nemHCWinCopyStateFromHyperV(pVCpu->pVMR3, pVCpu, pCtx, NEM_WIN_CPUMCTX_EXTRN_MASK_FOR_IEM);
1602	AssertRCReturn(rc, rc);
1603	#endif
1604	}
1605	return VINF_SUCCESS;
1606	}
1607	#endif /* NEM_WIN_USE_OUR_OWN_RUN_API \|\| IN_RING3 */
1608
1609	#ifdef NEM_WIN_USE_OUR_OWN_RUN_API
1610	/**
1611	* Copies register state from the X64 intercept message header.
1612	*
1613	* ASSUMES no state copied yet.
1614	*
1615	* @param pVCpu The cross context per CPU structure.
1616	* @param pCtx The registe rcontext.
1617	* @param pHdr The X64 intercept message header.
1618	* @sa nemR3WinCopyStateFromX64Header
1619	*/
1620	DECLINLINE(void) nemHCWinCopyStateFromX64Header(PVMCPU pVCpu, PCPUMCTX pCtx, HV_X64_INTERCEPT_MESSAGE_HEADER const *pHdr)
1621	{
1622	Assert( (pCtx->fExtrn & (CPUMCTX_EXTRN_RIP \| CPUMCTX_EXTRN_RFLAGS \| CPUMCTX_EXTRN_CS \| CPUMCTX_EXTRN_NEM_WIN_INHIBIT_INT))
1623	== (CPUMCTX_EXTRN_RIP \| CPUMCTX_EXTRN_RFLAGS \| CPUMCTX_EXTRN_CS \| CPUMCTX_EXTRN_NEM_WIN_INHIBIT_INT));
1624	NEM_WIN_COPY_BACK_SEG(pCtx->cs, pHdr->CsSegment);
1625	pCtx->rip = pHdr->Rip;
1626	pCtx->rflags.u = pHdr->Rflags;
1627
1628	pVCpu->nem.s.fLastInterruptShadow = pHdr->ExecutionState.InterruptShadow;
1629	if (!pHdr->ExecutionState.InterruptShadow)
1630	{
1631	if (!VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS))
1632	{ /* likely */ }
1633	else
1634	VMCPU_FF_CLEAR(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS);
1635	}
1636	else
1637	EMSetInhibitInterruptsPC(pVCpu, pHdr->Rip);
1638
1639	pCtx->fExtrn &= ~(CPUMCTX_EXTRN_RIP \| CPUMCTX_EXTRN_RFLAGS \| CPUMCTX_EXTRN_CS \| CPUMCTX_EXTRN_NEM_WIN_INHIBIT_INT);
1640	}
1641	#elif defined(IN_RING3)
1642	/**
1643	* Copies register state from the (common) exit context.
1644	*
1645	* ASSUMES no state copied yet.
1646	*
1647	* @param pVCpu The cross context per CPU structure.
1648	* @param pCtx The registe rcontext.
1649	* @param pExitCtx The common exit context.
1650	* @sa nemHCWinCopyStateFromX64Header
1651	*/
1652	DECLINLINE(void) nemR3WinCopyStateFromX64Header(PVMCPU pVCpu, PCPUMCTX pCtx, WHV_VP_EXIT_CONTEXT const *pExitCtx)
1653	{
1654	Assert( (pCtx->fExtrn & (CPUMCTX_EXTRN_RIP \| CPUMCTX_EXTRN_RFLAGS \| CPUMCTX_EXTRN_CS \| CPUMCTX_EXTRN_NEM_WIN_INHIBIT_INT))
1655	== (CPUMCTX_EXTRN_RIP \| CPUMCTX_EXTRN_RFLAGS \| CPUMCTX_EXTRN_CS \| CPUMCTX_EXTRN_NEM_WIN_INHIBIT_INT));
1656	NEM_WIN_COPY_BACK_SEG(pCtx->cs, pExitCtx->Cs);
1657	pCtx->rip = pExitCtx->Rip;
1658	pCtx->rflags.u = pExitCtx->Rflags;
1659
1660	pVCpu->nem.s.fLastInterruptShadow = pExitCtx->ExecutionState.InterruptShadow;
1661	if (!pExitCtx->ExecutionState.InterruptShadow)
1662	{
1663	if (!VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS))
1664	{ /* likely */ }
1665	else
1666	VMCPU_FF_CLEAR(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS);
1667	}
1668	else
1669	EMSetInhibitInterruptsPC(pVCpu, pExitCtx->Rip);
1670
1671	pCtx->fExtrn &= ~(CPUMCTX_EXTRN_RIP \| CPUMCTX_EXTRN_RFLAGS \| CPUMCTX_EXTRN_CS \| CPUMCTX_EXTRN_NEM_WIN_INHIBIT_INT);
1672	}
1673	#endif /* IN_RING3 && !NEM_WIN_USE_OUR_OWN_RUN_API */
1674
1675
1676	#ifdef NEM_WIN_USE_OUR_OWN_RUN_API
1677	/**
1678	* Deals with memory intercept message.
1679	*
1680	* @returns Strict VBox status code.
1681	* @param pVM The cross context VM structure.
1682	* @param pVCpu The cross context per CPU structure.
1683	* @param pMsg The message.
1684	* @param pCtx The register context.
1685	* @param pGVCpu The global (ring-0) per CPU structure (NULL in r3).
1686	* @sa nemR3WinHandleExitMemory
1687	*/
1688	NEM_TMPL_STATIC VBOXSTRICTRC
1689	nemHCWinHandleMessageMemory(PVM pVM, PVMCPU pVCpu, HV_X64_MEMORY_INTERCEPT_MESSAGE const *pMsg, PCPUMCTX pCtx, PGVMCPU pGVCpu)
1690	{
1691	Assert( pMsg->Header.InterceptAccessType == HV_INTERCEPT_ACCESS_READ
1692	\|\| pMsg->Header.InterceptAccessType == HV_INTERCEPT_ACCESS_WRITE
1693	\|\| pMsg->Header.InterceptAccessType == HV_INTERCEPT_ACCESS_EXECUTE);
1694	AssertMsg(pMsg->Header.InstructionLength < 0x10, ("%#x\n", pMsg->Header.InstructionLength));
1695
1696	/*
1697	* Whatever we do, we must clear pending event injection upon resume.
1698	*/
1699	if (pMsg->Header.ExecutionState.InterruptionPending)
1700	pCtx->fExtrn &= ~CPUMCTX_EXTRN_NEM_WIN_EVENT_INJECT;
1701
1702	#if 0 /* Experiment: 20K -> 34K exit/s. */
1703	if ( pMsg->Header.ExecutionState.EferLma
1704	&& pMsg->Header.CsSegment.Long
1705	&& pMsg->Header.InterceptAccessType == HV_INTERCEPT_ACCESS_WRITE)
1706	{
1707	if ( pMsg->Header.Rip - (uint64_t)0xf65a < (uint64_t)(0xf662 - 0xf65a)
1708	&& pMsg->InstructionBytes[0] == 0x89
1709	&& pMsg->InstructionBytes[1] == 0x03)
1710	{
1711	pCtx->rip = pMsg->Header.Rip + 2;
1712	pCtx->fExtrn &= ~CPUMCTX_EXTRN_RIP;
1713	AssertMsg(pMsg->Header.InstructionLength == 2, ("%#x\n", pMsg->Header.InstructionLength));
1714	//Log(("%RX64 msg:\n%.80Rhxd\n", pCtx->rip, pMsg));
1715	return VINF_SUCCESS;
1716	}
1717	}
1718	#endif
1719
1720	/*
1721	* Ask PGM for information about the given GCPhys. We need to check if we're
1722	* out of sync first.
1723	*/
1724	NEMHCWINHMACPCCSTATE State = { pMsg->Header.InterceptAccessType == HV_INTERCEPT_ACCESS_WRITE, false, false };
1725	PGMPHYSNEMPAGEINFO Info;
1726	int rc = PGMPhysNemPageInfoChecker(pVM, pVCpu, pMsg->GuestPhysicalAddress, State.fWriteAccess, &Info,
1727	nemHCWinHandleMemoryAccessPageCheckerCallback, &State);
1728	if (RT_SUCCESS(rc))
1729	{
1730	if (Info.fNemProt & ( pMsg->Header.InterceptAccessType == HV_INTERCEPT_ACCESS_WRITE
1731	? NEM_PAGE_PROT_WRITE : NEM_PAGE_PROT_READ))
1732	{
1733	if (State.fCanResume)
1734	{
1735	Log4(("MemExit/%u: %04x:%08RX64/%s: %RGp (=>%RHp) %s fProt=%u%s%s%s; restarting (%s)\n",
1736	pVCpu->idCpu, pMsg->Header.CsSegment.Selector, pMsg->Header.Rip, nemHCWinExecStateToLogStr(&pMsg->Header),
1737	pMsg->GuestPhysicalAddress, Info.HCPhys, g_apszPageStates[Info.u2NemState], Info.fNemProt,
1738	Info.fHasHandlers ? " handlers" : "", Info.fZeroPage ? " zero-pg" : "",
1739	State.fDidSomething ? "" : " no-change", g_apszHvInterceptAccessTypes[pMsg->Header.InterceptAccessType]));
1740	return VINF_SUCCESS;
1741	}
1742	}
1743	Log4(("MemExit/%u: %04x:%08RX64/%s: %RGp (=>%RHp) %s fProt=%u%s%s%s; emulating (%s)\n",
1744	pVCpu->idCpu, pMsg->Header.CsSegment.Selector, pMsg->Header.Rip, nemHCWinExecStateToLogStr(&pMsg->Header),
1745	pMsg->GuestPhysicalAddress, Info.HCPhys, g_apszPageStates[Info.u2NemState], Info.fNemProt,
1746	Info.fHasHandlers ? " handlers" : "", Info.fZeroPage ? " zero-pg" : "",
1747	State.fDidSomething ? "" : " no-change", g_apszHvInterceptAccessTypes[pMsg->Header.InterceptAccessType]));
1748	}
1749	else
1750	Log4(("MemExit/%u: %04x:%08RX64/%s: %RGp rc=%Rrc%s; emulating (%s)\n",
1751	pVCpu->idCpu, pMsg->Header.CsSegment.Selector, pMsg->Header.Rip, nemHCWinExecStateToLogStr(&pMsg->Header),
1752	pMsg->GuestPhysicalAddress, rc, State.fDidSomething ? " modified-backing" : "",
1753	g_apszHvInterceptAccessTypes[pMsg->Header.InterceptAccessType]));
1754
1755	/*
1756	* Emulate the memory access, either access handler or special memory.
1757	*/
1758	nemHCWinCopyStateFromX64Header(pVCpu, pCtx, &pMsg->Header);
1759	VBOXSTRICTRC rcStrict;
1760	# ifdef IN_RING0
1761	rcStrict = nemR0WinImportStateStrict(pGVCpu->pGVM, pGVCpu, pCtx, NEM_WIN_CPUMCTX_EXTRN_MASK_FOR_IEM, "MemExit");
1762	if (rcStrict != VINF_SUCCESS)
1763	return rcStrict;
1764	# else
1765	rc = nemHCWinCopyStateFromHyperV(pVM, pVCpu, pCtx, NEM_WIN_CPUMCTX_EXTRN_MASK_FOR_IEM);
1766	AssertRCReturn(rc, rc);
1767	NOREF(pGVCpu);
1768	# endif
1769
1770	if (pMsg->Reserved1)
1771	Log(("MemExit/Reserved1=%#x\n", pMsg->Reserved1));
1772	if (pMsg->Header.ExecutionState.Reserved0 \|\| pMsg->Header.ExecutionState.Reserved1)
1773	Log(("MemExit/Hdr/State: Reserved0=%#x Reserved1=%#x\n", pMsg->Header.ExecutionState.Reserved0, pMsg->Header.ExecutionState.Reserved1));
1774	//if (pMsg->InstructionByteCount > 0)
1775	// Log4(("InstructionByteCount=%#x %.16Rhxs\n", pMsg->InstructionByteCount, pMsg->InstructionBytes));
1776
1777	if (pMsg->InstructionByteCount > 0)
1778	rcStrict = IEMExecOneWithPrefetchedByPC(pVCpu, CPUMCTX2CORE(pCtx), pMsg->Header.Rip,
1779	pMsg->InstructionBytes, pMsg->InstructionByteCount);
1780	else
1781	rcStrict = IEMExecOne(pVCpu);
1782	/** @todo do we need to do anything wrt debugging here? */
1783	return rcStrict;
1784	}
1785	#elif defined(IN_RING3)
1786	/**
1787	* Deals with memory access exits (WHvRunVpExitReasonMemoryAccess).
1788	*
1789	* @returns Strict VBox status code.
1790	* @param pVM The cross context VM structure.
1791	* @param pVCpu The cross context per CPU structure.
1792	* @param pExit The VM exit information to handle.
1793	* @param pCtx The register context.
1794	* @sa nemHCWinHandleMessageMemory
1795	*/
1796	NEM_TMPL_STATIC VBOXSTRICTRC
1797	nemR3WinHandleExitMemory(PVM pVM, PVMCPU pVCpu, WHV_RUN_VP_EXIT_CONTEXT const *pExit, PCPUMCTX pCtx)
1798	{
1799	Assert(pExit->MemoryAccess.AccessInfo.AccessType != 3);
1800	AssertMsg(pExit->VpContext.InstructionLength < 0x10, ("%#x\n", pExit->VpContext.InstructionLength));
1801
1802	/*
1803	* Whatever we do, we must clear pending event injection upon resume.
1804	*/
1805	if (pExit->VpContext.ExecutionState.InterruptionPending)
1806	pCtx->fExtrn &= ~CPUMCTX_EXTRN_NEM_WIN_EVENT_INJECT;
1807
1808	/*
1809	* Ask PGM for information about the given GCPhys. We need to check if we're
1810	* out of sync first.
1811	*/
1812	NEMHCWINHMACPCCSTATE State = { pExit->MemoryAccess.AccessInfo.AccessType == WHvMemoryAccessWrite, false, false };
1813	PGMPHYSNEMPAGEINFO Info;
1814	int rc = PGMPhysNemPageInfoChecker(pVM, pVCpu, pExit->MemoryAccess.Gpa, State.fWriteAccess, &Info,
1815	nemHCWinHandleMemoryAccessPageCheckerCallback, &State);
1816	if (RT_SUCCESS(rc))
1817	{
1818	if (Info.fNemProt & ( pExit->MemoryAccess.AccessInfo.AccessType == WHvMemoryAccessWrite
1819	? NEM_PAGE_PROT_WRITE : NEM_PAGE_PROT_READ))
1820	{
1821	if (State.fCanResume)
1822	{
1823	Log4(("MemExit/%u: %04x:%08RX64/%s: %RGp (=>%RHp) %s fProt=%u%s%s%s; restarting (%s)\n",
1824	pVCpu->idCpu, pExit->VpContext.Cs.Selector, pExit->VpContext.Rip, nemR3WinExecStateToLogStr(&pExit->VpContext),
1825	pExit->MemoryAccess.Gpa, Info.HCPhys, g_apszPageStates[Info.u2NemState], Info.fNemProt,
1826	Info.fHasHandlers ? " handlers" : "", Info.fZeroPage ? " zero-pg" : "",
1827	State.fDidSomething ? "" : " no-change", g_apszHvInterceptAccessTypes[pExit->MemoryAccess.AccessInfo.AccessType]));
1828	return VINF_SUCCESS;
1829	}
1830	}
1831	Log4(("MemExit/%u: %04x:%08RX64/%s: %RGp (=>%RHp) %s fProt=%u%s%s%s; emulating (%s)\n",
1832	pVCpu->idCpu, pExit->VpContext.Cs.Selector, pExit->VpContext.Rip, nemR3WinExecStateToLogStr(&pExit->VpContext),
1833	pExit->MemoryAccess.Gpa, Info.HCPhys, g_apszPageStates[Info.u2NemState], Info.fNemProt,
1834	Info.fHasHandlers ? " handlers" : "", Info.fZeroPage ? " zero-pg" : "",
1835	State.fDidSomething ? "" : " no-change", g_apszHvInterceptAccessTypes[pExit->MemoryAccess.AccessInfo.AccessType]));
1836	}
1837	else
1838	Log4(("MemExit/%u: %04x:%08RX64/%s: %RGp rc=%Rrc%s; emulating (%s)\n",
1839	pVCpu->idCpu, pExit->VpContext.Cs.Selector, pExit->VpContext.Rip, nemR3WinExecStateToLogStr(&pExit->VpContext),
1840	pExit->MemoryAccess.Gpa, rc, State.fDidSomething ? " modified-backing" : "",
1841	g_apszHvInterceptAccessTypes[pExit->MemoryAccess.AccessInfo.AccessType]));
1842
1843	/*
1844	* Emulate the memory access, either access handler or special memory.
1845	*/
1846	nemR3WinCopyStateFromX64Header(pVCpu, pCtx, &pExit->VpContext);
1847	rc = nemHCWinCopyStateFromHyperV(pVM, pVCpu, pCtx, NEM_WIN_CPUMCTX_EXTRN_MASK_FOR_IEM);
1848	AssertRCReturn(rc, rc);
1849
1850	if (pExit->VpContext.ExecutionState.Reserved0 \|\| pExit->VpContext.ExecutionState.Reserved1)
1851	Log(("MemExit/Hdr/State: Reserved0=%#x Reserved1=%#x\n", pExit->VpContext.ExecutionState.Reserved0, pExit->VpContext.ExecutionState.Reserved1));
1852	//if (pMsg->InstructionByteCount > 0)
1853	// Log4(("InstructionByteCount=%#x %.16Rhxs\n", pMsg->InstructionByteCount, pMsg->InstructionBytes));
1854
1855	VBOXSTRICTRC rcStrict;
1856	if (pExit->MemoryAccess.InstructionByteCount > 0)
1857	rcStrict = IEMExecOneWithPrefetchedByPC(pVCpu, CPUMCTX2CORE(pCtx), pExit->VpContext.Rip,
1858	pExit->MemoryAccess.InstructionBytes, pExit->MemoryAccess.InstructionByteCount);
1859	else
1860	rcStrict = IEMExecOne(pVCpu);
1861	/** @todo do we need to do anything wrt debugging here? */
1862	return rcStrict;
1863	}
1864	#endif /* IN_RING3 && !NEM_WIN_USE_OUR_OWN_RUN_API */
1865
1866
1867	#ifdef NEM_WIN_USE_OUR_OWN_RUN_API
1868	/**
1869	* Deals with I/O port intercept message.
1870	*
1871	* @returns Strict VBox status code.
1872	* @param pVM The cross context VM structure.
1873	* @param pVCpu The cross context per CPU structure.
1874	* @param pMsg The message.
1875	* @param pCtx The register context.
1876	* @param pGVCpu The global (ring-0) per CPU structure (NULL in r3).
1877	*/
1878	NEM_TMPL_STATIC VBOXSTRICTRC
1879	nemHCWinHandleMessageIoPort(PVM pVM, PVMCPU pVCpu, HV_X64_IO_PORT_INTERCEPT_MESSAGE const *pMsg, PCPUMCTX pCtx, PGVMCPU pGVCpu)
1880	{
1881	Assert( pMsg->AccessInfo.AccessSize == 1
1882	\|\| pMsg->AccessInfo.AccessSize == 2
1883	\|\| pMsg->AccessInfo.AccessSize == 4);
1884	Assert( pMsg->Header.InterceptAccessType == HV_INTERCEPT_ACCESS_READ
1885	\|\| pMsg->Header.InterceptAccessType == HV_INTERCEPT_ACCESS_WRITE);
1886	AssertMsg(pMsg->Header.InstructionLength < 0x10, ("%#x\n", pMsg->Header.InstructionLength));
1887
1888	/*
1889	* Whatever we do, we must clear pending event injection upon resume.
1890	*/
1891	if (pMsg->Header.ExecutionState.InterruptionPending)
1892	pCtx->fExtrn &= ~CPUMCTX_EXTRN_NEM_WIN_EVENT_INJECT;
1893
1894	VBOXSTRICTRC rcStrict;
1895	if (!pMsg->AccessInfo.StringOp)
1896	{
1897	/*
1898	* Simple port I/O.
1899	*/
1900	static uint32_t const s_fAndMask[8] =
1901	{ UINT32_MAX, UINT32_C(0xff), UINT32_C(0xffff), UINT32_MAX, UINT32_MAX, UINT32_MAX, UINT32_MAX, UINT32_MAX };
1902	uint32_t const fAndMask = s_fAndMask[pMsg->AccessInfo.AccessSize];
1903	if (pMsg->Header.InterceptAccessType == HV_INTERCEPT_ACCESS_WRITE)
1904	{
1905	rcStrict = IOMIOPortWrite(pVM, pVCpu, pMsg->PortNumber, (uint32_t)pMsg->Rax & fAndMask, pMsg->AccessInfo.AccessSize);
1906	Log4(("IOExit/%u: %04x:%08RX64/%s: OUT %#x, %#x LB %u rcStrict=%Rrc\n",
1907	pVCpu->idCpu, pMsg->Header.CsSegment.Selector, pMsg->Header.Rip, nemHCWinExecStateToLogStr(&pMsg->Header),
1908	pMsg->PortNumber, (uint32_t)pMsg->Rax & fAndMask, pMsg->AccessInfo.AccessSize, VBOXSTRICTRC_VAL(rcStrict) ));
1909	if (IOM_SUCCESS(rcStrict))
1910	{
1911	nemHCWinCopyStateFromX64Header(pVCpu, pCtx, &pMsg->Header);
1912	nemHCWinAdvanceGuestRipAndClearRF(pVCpu, pCtx, &pMsg->Header);
1913	}
1914	}
1915	else
1916	{
1917	uint32_t uValue = 0;
1918	rcStrict = IOMIOPortRead(pVM, pVCpu, pMsg->PortNumber, &uValue, pMsg->AccessInfo.AccessSize);
1919	Log4(("IOExit/%u: %04x:%08RX64/%s: IN %#x LB %u -> %#x, rcStrict=%Rrc\n",
1920	pVCpu->idCpu, pMsg->Header.CsSegment.Selector, pMsg->Header.Rip, nemHCWinExecStateToLogStr(&pMsg->Header),
1921	pMsg->PortNumber, pMsg->AccessInfo.AccessSize, uValue, VBOXSTRICTRC_VAL(rcStrict) ));
1922	if (IOM_SUCCESS(rcStrict))
1923	{
1924	if (pMsg->AccessInfo.AccessSize != 4)
1925	pCtx->rax = (pMsg->Rax & ~(uint64_t)fAndMask) \| (uValue & fAndMask);
1926	else
1927	pCtx->rax = uValue;
1928	pCtx->fExtrn &= ~CPUMCTX_EXTRN_RAX;
1929	Log4(("IOExit/%u: RAX %#RX64 -> %#RX64\n", pVCpu->idCpu, pMsg->Rax, pCtx->rax));
1930	nemHCWinCopyStateFromX64Header(pVCpu, pCtx, &pMsg->Header);
1931	nemHCWinAdvanceGuestRipAndClearRF(pVCpu, pCtx, &pMsg->Header);
1932	}
1933	}
1934	}
1935	else
1936	{
1937	/*
1938	* String port I/O.
1939	*/
1940	/** @todo Someone at Microsoft please explain how we can get the address mode
1941	* from the IoPortAccess.VpContext. CS.Attributes is only sufficient for
1942	* getting the default mode, it can always be overridden by a prefix. This
1943	* forces us to interpret the instruction from opcodes, which is suboptimal.
1944	* Both AMD-V and VT-x includes the address size in the exit info, at least on
1945	* CPUs that are reasonably new.
1946	*
1947	* Of course, it's possible this is an undocumented and we just need to do some
1948	* experiments to figure out how it's communicated. Alternatively, we can scan
1949	* the opcode bytes for possible evil prefixes.
1950	*/
1951	nemHCWinCopyStateFromX64Header(pVCpu, pCtx, &pMsg->Header);
1952	pCtx->fExtrn &= ~( CPUMCTX_EXTRN_RAX \| CPUMCTX_EXTRN_RCX \| CPUMCTX_EXTRN_RDI \| CPUMCTX_EXTRN_RSI
1953	\| CPUMCTX_EXTRN_DS \| CPUMCTX_EXTRN_ES);
1954	NEM_WIN_COPY_BACK_SEG(pCtx->ds, pMsg->DsSegment);
1955	NEM_WIN_COPY_BACK_SEG(pCtx->es, pMsg->EsSegment);
1956	pCtx->rax = pMsg->Rax;
1957	pCtx->rcx = pMsg->Rcx;
1958	pCtx->rdi = pMsg->Rdi;
1959	pCtx->rsi = pMsg->Rsi;
1960	# ifdef IN_RING0
1961	rcStrict = nemR0WinImportStateStrict(pGVCpu->pGVM, pGVCpu, pCtx, NEM_WIN_CPUMCTX_EXTRN_MASK_FOR_IEM, "IOExit");
1962	if (rcStrict != VINF_SUCCESS)
1963	return rcStrict;
1964	# else
1965	int rc = nemHCWinCopyStateFromHyperV(pVM, pVCpu, pCtx, NEM_WIN_CPUMCTX_EXTRN_MASK_FOR_IEM);
1966	AssertRCReturn(rc, rc);
1967	RT_NOREF(pGVCpu);
1968	# endif
1969
1970	Log4(("IOExit/%u: %04x:%08RX64/%s: %s%s %#x LB %u (emulating)\n",
1971	pVCpu->idCpu, pMsg->Header.CsSegment.Selector, pMsg->Header.Rip, nemHCWinExecStateToLogStr(&pMsg->Header),
1972	pMsg->AccessInfo.RepPrefix ? "REP " : "",
1973	pMsg->Header.InterceptAccessType == HV_INTERCEPT_ACCESS_WRITE ? "OUTS" : "INS",
1974	pMsg->PortNumber, pMsg->AccessInfo.AccessSize ));
1975	rcStrict = IEMExecOne(pVCpu);
1976	}
1977	if (IOM_SUCCESS(rcStrict))
1978	{
1979	/*
1980	* Do debug checks.
1981	*/
1982	if ( pMsg->Header.ExecutionState.DebugActive /** @todo Microsoft: Does DebugActive this only reflect DR7? */
1983	\|\| (pMsg->Header.Rflags & X86_EFL_TF)
1984	\|\| DBGFBpIsHwIoArmed(pVM) )
1985	{
1986	/** @todo Debugging. */
1987	}
1988	}
1989	return rcStrict;
1990	}
1991	#elif defined(IN_RING3)
1992	/**
1993	* Deals with I/O port access exits (WHvRunVpExitReasonX64IoPortAccess).
1994	*
1995	* @returns Strict VBox status code.
1996	* @param pVM The cross context VM structure.
1997	* @param pVCpu The cross context per CPU structure.
1998	* @param pExit The VM exit information to handle.
1999	* @param pCtx The register context.
2000	* @sa nemHCWinHandleMessageIoPort
2001	*/
2002	NEM_TMPL_STATIC VBOXSTRICTRC
2003	nemR3WinHandleExitIoPort(PVM pVM, PVMCPU pVCpu, WHV_RUN_VP_EXIT_CONTEXT const *pExit, PCPUMCTX pCtx)
2004	{
2005	Assert( pExit->IoPortAccess.AccessInfo.AccessSize == 1
2006	\|\| pExit->IoPortAccess.AccessInfo.AccessSize == 2
2007	\|\| pExit->IoPortAccess.AccessInfo.AccessSize == 4);
2008	AssertMsg(pExit->VpContext.InstructionLength < 0x10, ("%#x\n", pExit->VpContext.InstructionLength));
2009
2010	/*
2011	* Whatever we do, we must clear pending event injection upon resume.
2012	*/
2013	if (pExit->VpContext.ExecutionState.InterruptionPending)
2014	pCtx->fExtrn &= ~CPUMCTX_EXTRN_NEM_WIN_EVENT_INJECT;
2015
2016	VBOXSTRICTRC rcStrict;
2017	if (!pExit->IoPortAccess.AccessInfo.StringOp)
2018	{
2019	/*
2020	* Simple port I/O.
2021	*/
2022	static uint32_t const s_fAndMask[8] =
2023	{ UINT32_MAX, UINT32_C(0xff), UINT32_C(0xffff), UINT32_MAX, UINT32_MAX, UINT32_MAX, UINT32_MAX, UINT32_MAX };
2024	uint32_t const fAndMask = s_fAndMask[pExit->IoPortAccess.AccessInfo.AccessSize];
2025	if (pExit->IoPortAccess.AccessInfo.IsWrite)
2026	{
2027	rcStrict = IOMIOPortWrite(pVM, pVCpu, pExit->IoPortAccess.PortNumber, (uint32_t)pExit->IoPortAccess.Rax & fAndMask,
2028	pExit->IoPortAccess.AccessInfo.AccessSize);
2029	Log4(("IOExit/%u: %04x:%08RX64/%s: OUT %#x, %#x LB %u rcStrict=%Rrc\n",
2030	pVCpu->idCpu, pExit->VpContext.Cs.Selector, pExit->VpContext.Rip, nemR3WinExecStateToLogStr(&pExit->VpContext),
2031	pExit->IoPortAccess.PortNumber, (uint32_t)pExit->IoPortAccess.Rax & fAndMask,
2032	pExit->IoPortAccess.AccessInfo.AccessSize, VBOXSTRICTRC_VAL(rcStrict) ));
2033	if (IOM_SUCCESS(rcStrict))
2034	{
2035	nemR3WinCopyStateFromX64Header(pVCpu, pCtx, &pExit->VpContext);
2036	nemR3WinAdvanceGuestRipAndClearRF(pVCpu, pCtx, &pExit->VpContext);
2037	}
2038	}
2039	else
2040	{
2041	uint32_t uValue = 0;
2042	rcStrict = IOMIOPortRead(pVM, pVCpu, pExit->IoPortAccess.PortNumber, &uValue, pExit->IoPortAccess.AccessInfo.AccessSize);
2043	Log4(("IOExit/%u: %04x:%08RX64/%s: IN %#x LB %u -> %#x, rcStrict=%Rrc\n",
2044	pVCpu->idCpu, pExit->VpContext.Cs.Selector, pExit->VpContext.Rip, nemR3WinExecStateToLogStr(&pExit->VpContext),
2045	pExit->IoPortAccess.PortNumber, pExit->IoPortAccess.AccessInfo.AccessSize, uValue, VBOXSTRICTRC_VAL(rcStrict) ));
2046	if (IOM_SUCCESS(rcStrict))
2047	{
2048	if (pExit->IoPortAccess.AccessInfo.AccessSize != 4)
2049	pCtx->rax = (pExit->IoPortAccess.Rax & ~(uint64_t)fAndMask) \| (uValue & fAndMask);
2050	else
2051	pCtx->rax = uValue;
2052	pCtx->fExtrn &= ~CPUMCTX_EXTRN_RAX;
2053	Log4(("IOExit/%u: RAX %#RX64 -> %#RX64\n", pVCpu->idCpu, pExit->IoPortAccess.Rax, pCtx->rax));
2054	nemR3WinCopyStateFromX64Header(pVCpu, pCtx, &pExit->VpContext);
2055	nemR3WinAdvanceGuestRipAndClearRF(pVCpu, pCtx, &pExit->VpContext);
2056	}
2057	}
2058	}
2059	else
2060	{
2061	/*
2062	* String port I/O.
2063	*/
2064	/** @todo Someone at Microsoft please explain how we can get the address mode
2065	* from the IoPortAccess.VpContext. CS.Attributes is only sufficient for
2066	* getting the default mode, it can always be overridden by a prefix. This
2067	* forces us to interpret the instruction from opcodes, which is suboptimal.
2068	* Both AMD-V and VT-x includes the address size in the exit info, at least on
2069	* CPUs that are reasonably new.
2070	*
2071	* Of course, it's possible this is an undocumented and we just need to do some
2072	* experiments to figure out how it's communicated. Alternatively, we can scan
2073	* the opcode bytes for possible evil prefixes.
2074	*/
2075	nemR3WinCopyStateFromX64Header(pVCpu, pCtx, &pExit->VpContext);
2076	pCtx->fExtrn &= ~( CPUMCTX_EXTRN_RAX \| CPUMCTX_EXTRN_RCX \| CPUMCTX_EXTRN_RDI \| CPUMCTX_EXTRN_RSI
2077	\| CPUMCTX_EXTRN_DS \| CPUMCTX_EXTRN_ES);
2078	NEM_WIN_COPY_BACK_SEG(pCtx->ds, pExit->IoPortAccess.Ds);
2079	NEM_WIN_COPY_BACK_SEG(pCtx->es, pExit->IoPortAccess.Es);
2080	pCtx->rax = pExit->IoPortAccess.Rax;
2081	pCtx->rcx = pExit->IoPortAccess.Rcx;
2082	pCtx->rdi = pExit->IoPortAccess.Rdi;
2083	pCtx->rsi = pExit->IoPortAccess.Rsi;
2084	# ifdef IN_RING0
2085	rcStrict = nemR0WinImportStateStrict(pGVCpu->pGVM, pGVCpu, pCtx, NEM_WIN_CPUMCTX_EXTRN_MASK_FOR_IEM, "IOExit");
2086	if (rcStrict != VINF_SUCCESS)
2087	return rcStrict;
2088	# else
2089	int rc = nemHCWinCopyStateFromHyperV(pVM, pVCpu, pCtx, NEM_WIN_CPUMCTX_EXTRN_MASK_FOR_IEM);
2090	AssertRCReturn(rc, rc);
2091	# endif
2092
2093	Log4(("IOExit/%u: %04x:%08RX64/%s: %s%s %#x LB %u (emulating)\n",
2094	pVCpu->idCpu, pExit->VpContext.Cs.Selector, pExit->VpContext.Rip, nemR3WinExecStateToLogStr(&pExit->VpContext),
2095	pExit->IoPortAccess.AccessInfo.RepPrefix ? "REP " : "",
2096	pExit->IoPortAccess.AccessInfo.IsWrite ? "OUTS" : "INS",
2097	pExit->IoPortAccess.PortNumber, pExit->IoPortAccess.AccessInfo.AccessSize ));
2098	rcStrict = IEMExecOne(pVCpu);
2099	}
2100	if (IOM_SUCCESS(rcStrict))
2101	{
2102	/*
2103	* Do debug checks.
2104	*/
2105	if ( pExit->VpContext.ExecutionState.DebugActive /** @todo Microsoft: Does DebugActive this only reflect DR7? */
2106	\|\| (pExit->VpContext.Rflags & X86_EFL_TF)
2107	\|\| DBGFBpIsHwIoArmed(pVM) )
2108	{
2109	/** @todo Debugging. */
2110	}
2111	}
2112	return rcStrict;
2113
2114	}
2115	#endif /* IN_RING3 && !NEM_WIN_USE_OUR_OWN_RUN_API */
2116
2117	#ifdef NEM_WIN_USE_OUR_OWN_RUN_API
2118	/**
2119	* Deals with interrupt window message.
2120	*
2121	* @returns Strict VBox status code.
2122	* @param pVM The cross context VM structure.
2123	* @param pVCpu The cross context per CPU structure.
2124	* @param pMsg The message.
2125	* @param pCtx The register context.
2126	* @param pGVCpu The global (ring-0) per CPU structure (NULL in r3).
2127	* @sa nemR3WinHandleExitInterruptWindow
2128	*/
2129	NEM_TMPL_STATIC VBOXSTRICTRC
2130	nemHCWinHandleMessageInterruptWindow(PVM pVM, PVMCPU pVCpu, HV_X64_INTERRUPT_WINDOW_MESSAGE const *pMsg,
2131	PCPUMCTX pCtx, PGVMCPU pGVCpu)
2132	{
2133	/*
2134	* Assert message sanity.
2135	*/
2136	Assert( pMsg->Header.InterceptAccessType == HV_INTERCEPT_ACCESS_EXECUTE
2137	\|\| pMsg->Header.InterceptAccessType == HV_INTERCEPT_ACCESS_READ // READ & WRITE are probably not used here
2138	\|\| pMsg->Header.InterceptAccessType == HV_INTERCEPT_ACCESS_WRITE);
2139	AssertMsg(pMsg->Header.InstructionLength < 0x10, ("%#x\n", pMsg->Header.InstructionLength));
2140	AssertMsg(pMsg->Type == HvX64PendingInterrupt \|\| pMsg->Type == HvX64PendingNmi, ("%#x\n", pMsg->Type));
2141
2142	/*
2143	* Just copy the state we've got and handle it in the loop for now.
2144	*/
2145	nemHCWinCopyStateFromX64Header(pVCpu, pCtx, &pMsg->Header);
2146	Log4(("IntWinExit/%u: %04x:%08RX64/%s: %u IF=%d InterruptShadow=%d\n",
2147	pVCpu->idCpu, pMsg->Header.CsSegment.Selector, pMsg->Header.Rip, nemHCWinExecStateToLogStr(&pMsg->Header),
2148	pMsg->Type, RT_BOOL(pMsg->Header.Rflags & X86_EFL_IF), pMsg->Header.ExecutionState.InterruptShadow));
2149
2150	/** @todo call nemHCWinHandleInterruptFF */
2151	RT_NOREF(pVM, pGVCpu);
2152	return VINF_SUCCESS;
2153	}
2154	#elif defined(IN_RING3)
2155	/**
2156	* Deals with interrupt window exits (WHvRunVpExitReasonX64InterruptWindow).
2157	*
2158	* @returns Strict VBox status code.
2159	* @param pVM The cross context VM structure.
2160	* @param pVCpu The cross context per CPU structure.
2161	* @param pExit The VM exit information to handle.
2162	* @param pCtx The register context.
2163	* @sa nemHCWinHandleMessageInterruptWindow
2164	*/
2165	NEM_TMPL_STATIC VBOXSTRICTRC
2166	nemR3WinHandleExitInterruptWindow(PVM pVM, PVMCPU pVCpu, WHV_RUN_VP_EXIT_CONTEXT const *pExit, PCPUMCTX pCtx)
2167	{
2168	/*
2169	* Assert message sanity.
2170	*/
2171	AssertMsg(pExit->VpContext.InstructionLength < 0x10, ("%#x\n", pExit->VpContext.InstructionLength));
2172	AssertMsg( pExit->InterruptWindow.DeliverableType == WHvX64PendingInterrupt
2173	\|\| pExit->InterruptWindow.DeliverableType == WHvX64PendingNmi,
2174	("%#x\n", pExit->InterruptWindow.DeliverableType));
2175
2176	/*
2177	* Just copy the state we've got and handle it in the loop for now.
2178	*/
2179	nemR3WinCopyStateFromX64Header(pVCpu, pCtx, &pExit->VpContext);
2180	Log4(("IntWinExit/%u: %04x:%08RX64/%s: %u IF=%d InterruptShadow=%d\n",
2181	pVCpu->idCpu, pExit->VpContext.Cs.Selector, pExit->VpContext.Rip, nemR3WinExecStateToLogStr(&pExit->VpContext),
2182	pExit->InterruptWindow.DeliverableType, RT_BOOL(pExit->VpContext.Rflags & X86_EFL_IF),
2183	pExit->VpContext.ExecutionState.InterruptShadow));
2184
2185	/** @todo call nemHCWinHandleInterruptFF */
2186	RT_NOREF(pVM);
2187	return VINF_SUCCESS;
2188	}
2189	#endif /* IN_RING3 && !NEM_WIN_USE_OUR_OWN_RUN_API */
2190
2191	#ifdef NEM_WIN_USE_OUR_OWN_RUN_API
2192	/**
2193	* Deals with CPUID intercept message.
2194	*
2195	* @returns Strict VBox status code.
2196	* @param pVCpu The cross context per CPU structure.
2197	* @param pMsg The message.
2198	* @param pCtx The register context.
2199	*/
2200	NEM_TMPL_STATIC VBOXSTRICTRC nemHCWinHandleMessageCpuId(PVMCPU pVCpu, HV_X64_CPUID_INTERCEPT_MESSAGE const *pMsg, PCPUMCTX pCtx)
2201	{
2202	AssertMsg(pMsg->Header.InstructionLength < 0x10, ("%#x\n", pMsg->Header.InstructionLength));
2203
2204	/*
2205	* Soak up state and execute the instruction.
2206	*
2207	* Note! If this grows slightly more complicated, combine into an IEMExecDecodedCpuId
2208	* function and make everyone use it.
2209	*/
2210	/** @todo Combine implementations into IEMExecDecodedCpuId as this will
2211	* only get weirder with nested VT-x and AMD-V support. */
2212	nemHCWinCopyStateFromX64Header(pVCpu, pCtx, &pMsg->Header);
2213
2214	/* Copy in the low register values (top is always cleared). */
2215	pCtx->rax = (uint32_t)pMsg->Rax;
2216	pCtx->rcx = (uint32_t)pMsg->Rcx;
2217	pCtx->rdx = (uint32_t)pMsg->Rdx;
2218	pCtx->rbx = (uint32_t)pMsg->Rbx;
2219	pCtx->fExtrn &= ~(CPUMCTX_EXTRN_RAX \| CPUMCTX_EXTRN_RCX \| CPUMCTX_EXTRN_RDX \| CPUMCTX_EXTRN_RBX);
2220
2221	/* Get the correct values. */
2222	CPUMGetGuestCpuId(pVCpu, pCtx->eax, pCtx->ecx, &pCtx->eax, &pCtx->ebx, &pCtx->ecx, &pCtx->edx);
2223
2224	Log4(("CpuIdExit/%u: %04x:%08RX64/%s: rax=%08RX64 / rcx=%08RX64 / rdx=%08RX64 / rbx=%08RX64 -> %08RX32 / %08RX32 / %08RX32 / %08RX32 (hv: %08RX64 / %08RX64 / %08RX64 / %08RX64)\n",
2225	pVCpu->idCpu, pMsg->Header.CsSegment.Selector, pMsg->Header.Rip, nemHCWinExecStateToLogStr(&pMsg->Header),
2226	pMsg->Rax, pMsg->Rcx, pMsg->Rdx, pMsg->Rbx,
2227	pCtx->eax, pCtx->ecx, pCtx->edx, pCtx->ebx,
2228	pMsg->DefaultResultRax, pMsg->DefaultResultRcx, pMsg->DefaultResultRdx, pMsg->DefaultResultRbx));
2229
2230	/* Move RIP and we're done. */
2231	nemHCWinAdvanceGuestRipAndClearRF(pVCpu, pCtx, &pMsg->Header);
2232
2233	return VINF_SUCCESS;
2234	}
2235	#elif defined(IN_RING3)
2236	/**
2237	* Deals with CPUID exits (WHvRunVpExitReasonX64Cpuid).
2238	*
2239	* @returns Strict VBox status code.
2240	* @param pVM The cross context VM structure.
2241	* @param pVCpu The cross context per CPU structure.
2242	* @param pExit The VM exit information to handle.
2243	* @param pCtx The register context.
2244	* @sa nemHCWinHandleMessageInterruptWindow
2245	*/
2246	NEM_TMPL_STATIC VBOXSTRICTRC
2247	nemR3WinHandleExitCpuId(PVM pVM, PVMCPU pVCpu, WHV_RUN_VP_EXIT_CONTEXT const *pExit, PCPUMCTX pCtx)
2248	{
2249	AssertMsg(pExit->VpContext.InstructionLength < 0x10, ("%#x\n", pExit->VpContext.InstructionLength));
2250
2251	/*
2252	* Soak up state and execute the instruction.
2253	*
2254	* Note! If this grows slightly more complicated, combine into an IEMExecDecodedCpuId
2255	* function and make everyone use it.
2256	*/
2257	/** @todo Combine implementations into IEMExecDecodedCpuId as this will
2258	* only get weirder with nested VT-x and AMD-V support. */
2259	nemR3WinCopyStateFromX64Header(pVCpu, pCtx, &pExit->VpContext);
2260
2261	/* Copy in the low register values (top is always cleared). */
2262	pCtx->rax = (uint32_t)pExit->CpuidAccess.Rax;
2263	pCtx->rcx = (uint32_t)pExit->CpuidAccess.Rcx;
2264	pCtx->rdx = (uint32_t)pExit->CpuidAccess.Rdx;
2265	pCtx->rbx = (uint32_t)pExit->CpuidAccess.Rbx;
2266	pCtx->fExtrn &= ~(CPUMCTX_EXTRN_RAX \| CPUMCTX_EXTRN_RCX \| CPUMCTX_EXTRN_RDX \| CPUMCTX_EXTRN_RBX);
2267
2268	/* Get the correct values. */
2269	CPUMGetGuestCpuId(pVCpu, pCtx->eax, pCtx->ecx, &pCtx->eax, &pCtx->ebx, &pCtx->ecx, &pCtx->edx);
2270
2271	Log4(("CpuIdExit/%u: %04x:%08RX64/%s: rax=%08RX64 / rcx=%08RX64 / rdx=%08RX64 / rbx=%08RX64 -> %08RX32 / %08RX32 / %08RX32 / %08RX32 (hv: %08RX64 / %08RX64 / %08RX64 / %08RX64)\n",
2272	pVCpu->idCpu, pExit->VpContext.Cs.Selector, pExit->VpContext.Rip, nemR3WinExecStateToLogStr(&pExit->VpContext),
2273	pExit->CpuidAccess.Rax, pExit->CpuidAccess.Rcx, pExit->CpuidAccess.Rdx, pExit->CpuidAccess.Rbx,
2274	pCtx->eax, pCtx->ecx, pCtx->edx, pCtx->ebx,
2275	pExit->CpuidAccess.DefaultResultRax, pExit->CpuidAccess.DefaultResultRcx, pExit->CpuidAccess.DefaultResultRdx, pExit->CpuidAccess.DefaultResultRbx));
2276
2277	/* Move RIP and we're done. */
2278	nemR3WinAdvanceGuestRipAndClearRF(pVCpu, pCtx, &pExit->VpContext);
2279
2280	RT_NOREF_PV(pVM);
2281	return VINF_SUCCESS;
2282	}
2283	#endif /* IN_RING3 && !NEM_WIN_USE_OUR_OWN_RUN_API */
2284
2285	#ifdef NEM_WIN_USE_OUR_OWN_RUN_API
2286	/**
2287	* Deals with MSR intercept message.
2288	*
2289	* @returns Strict VBox status code.
2290	* @param pVCpu The cross context per CPU structure.
2291	* @param pMsg The message.
2292	* @param pCtx The register context.
2293	* @param pGVCpu The global (ring-0) per CPU structure (NULL in r3).
2294	* @sa nemR3WinHandleExitMsr
2295	*/
2296	NEM_TMPL_STATIC VBOXSTRICTRC nemHCWinHandleMessageMsr(PVMCPU pVCpu, HV_X64_MSR_INTERCEPT_MESSAGE const *pMsg,
2297	PCPUMCTX pCtx, PGVMCPU pGVCpu)
2298	{
2299	/*
2300	* A wee bit of sanity first.
2301	*/
2302	AssertMsg(pMsg->Header.InstructionLength < 0x10, ("%#x\n", pMsg->Header.InstructionLength));
2303	Assert( pMsg->Header.InterceptAccessType == HV_INTERCEPT_ACCESS_READ
2304	\|\| pMsg->Header.InterceptAccessType == HV_INTERCEPT_ACCESS_WRITE);
2305
2306	/*
2307	* Check CPL as that's common to both RDMSR and WRMSR.
2308	*/
2309	VBOXSTRICTRC rcStrict;
2310	if (pMsg->Header.ExecutionState.Cpl == 0)
2311	{
2312	/*
2313	* Get all the MSR state. Since we're getting EFER, we also need to
2314	* get CR0, CR4 and CR3.
2315	*/
2316	nemHCWinCopyStateFromX64Header(pVCpu, pCtx, &pMsg->Header);
2317	rcStrict = nemHCWinImportStateIfNeededStrict(pVCpu, pGVCpu, pCtx,
2318	CPUMCTX_EXTRN_ALL_MSRS \| CPUMCTX_EXTRN_CR0
2319	\| CPUMCTX_EXTRN_CR3 \| CPUMCTX_EXTRN_CR4,
2320	"MSRs");
2321	if (rcStrict == VINF_SUCCESS)
2322	{
2323
2324	/*
2325	* Handle writes.
2326	*/
2327	if (pMsg->Header.InterceptAccessType == HV_INTERCEPT_ACCESS_WRITE)
2328	{
2329	rcStrict = CPUMSetGuestMsr(pVCpu, pMsg->MsrNumber, RT_MAKE_U64((uint32_t)pMsg->Rax, (uint32_t)pMsg->Rdx));
2330	Log4(("MsrExit/%u: %04x:%08RX64/%s: WRMSR %08x, %08x:%08x -> %Rrc\n",
2331	pVCpu->idCpu, pMsg->Header.CsSegment.Selector, pMsg->Header.Rip, nemHCWinExecStateToLogStr(&pMsg->Header),
2332	pMsg->MsrNumber, (uint32_t)pMsg->Rax, (uint32_t)pMsg->Rdx, VBOXSTRICTRC_VAL(rcStrict) ));
2333	if (rcStrict == VINF_SUCCESS)
2334	{
2335	nemHCWinAdvanceGuestRipAndClearRF(pVCpu, pCtx, &pMsg->Header);
2336	return VINF_SUCCESS;
2337	}
2338	# ifndef IN_RING3
2339	/* move to ring-3 and handle the trap/whatever there, as we want to LogRel this. */
2340	if (rcStrict == VERR_CPUM_RAISE_GP_0)
2341	rcStrict = VINF_CPUM_R3_MSR_WRITE;
2342	return rcStrict;
2343	# else
2344	LogRel(("MsrExit/%u: %04x:%08RX64/%s: WRMSR %08x, %08x:%08x -> %Rrc!\n",
2345	pVCpu->idCpu, pMsg->Header.CsSegment.Selector, pMsg->Header.Rip, nemHCWinExecStateToLogStr(&pMsg->Header),
2346	pMsg->MsrNumber, (uint32_t)pMsg->Rax, (uint32_t)pMsg->Rdx, VBOXSTRICTRC_VAL(rcStrict) ));
2347	# endif
2348	}
2349	/*
2350	* Handle reads.
2351	*/
2352	else
2353	{
2354	uint64_t uValue = 0;
2355	rcStrict = CPUMQueryGuestMsr(pVCpu, pMsg->MsrNumber, &uValue);
2356	Log4(("MsrExit/%u: %04x:%08RX64/%s: RDMSR %08x -> %08RX64 / %Rrc\n",
2357	pVCpu->idCpu, pMsg->Header.CsSegment.Selector, pMsg->Header.Rip, nemHCWinExecStateToLogStr(&pMsg->Header),
2358	pMsg->MsrNumber, uValue, VBOXSTRICTRC_VAL(rcStrict) ));
2359	if (rcStrict == VINF_SUCCESS)
2360	{
2361	pCtx->rax = (uint32_t)uValue;
2362	pCtx->rdx = uValue >> 32;
2363	pCtx->fExtrn &= ~(CPUMCTX_EXTRN_RAX \| CPUMCTX_EXTRN_RDX);
2364	nemHCWinAdvanceGuestRipAndClearRF(pVCpu, pCtx, &pMsg->Header);
2365	return VINF_SUCCESS;
2366	}
2367	# ifndef IN_RING3
2368	/* move to ring-3 and handle the trap/whatever there, as we want to LogRel this. */
2369	if (rcStrict == VERR_CPUM_RAISE_GP_0)
2370	rcStrict = VINF_CPUM_R3_MSR_READ;
2371	return rcStrict;
2372	# else
2373	LogRel(("MsrExit/%u: %04x:%08RX64/%s: RDMSR %08x -> %08RX64 / %Rrc\n",
2374	pVCpu->idCpu, pMsg->Header.CsSegment.Selector, pMsg->Header.Rip, nemHCWinExecStateToLogStr(&pMsg->Header),
2375	pMsg->MsrNumber, uValue, VBOXSTRICTRC_VAL(rcStrict) ));
2376	# endif
2377	}
2378	}
2379	else
2380	{
2381	LogRel(("MsrExit/%u: %04x:%08RX64/%s: %sMSR %08x -> %Rrc - msr state import\n",
2382	pVCpu->idCpu, pMsg->Header.CsSegment.Selector, pMsg->Header.Rip, nemHCWinExecStateToLogStr(&pMsg->Header),
2383	pMsg->Header.InterceptAccessType == HV_INTERCEPT_ACCESS_WRITE ? "WR" : "RD",
2384	pMsg->MsrNumber, VBOXSTRICTRC_VAL(rcStrict) ));
2385	return rcStrict;
2386	}
2387	}
2388	else if (pMsg->Header.InterceptAccessType == HV_INTERCEPT_ACCESS_WRITE)
2389	Log4(("MsrExit/%u: %04x:%08RX64/%s: CPL %u -> #GP(0); WRMSR %08x, %08x:%08x\n",
2390	pVCpu->idCpu, pMsg->Header.CsSegment.Selector, pMsg->Header.Rip, nemHCWinExecStateToLogStr(&pMsg->Header),
2391	pMsg->Header.ExecutionState.Cpl, pMsg->MsrNumber, (uint32_t)pMsg->Rax, (uint32_t)pMsg->Rdx ));
2392	else
2393	Log4(("MsrExit/%u: %04x:%08RX64/%s: CPL %u -> #GP(0); RDMSR %08x\n",
2394	pVCpu->idCpu, pMsg->Header.CsSegment.Selector, pMsg->Header.Rip, nemHCWinExecStateToLogStr(&pMsg->Header),
2395	pMsg->Header.ExecutionState.Cpl, pMsg->MsrNumber));
2396
2397	/*
2398	* If we get down here, we're supposed to #GP(0).
2399	*/
2400	rcStrict = nemHCWinImportStateIfNeededStrict(pVCpu, pGVCpu, pCtx, NEM_WIN_CPUMCTX_EXTRN_MASK_FOR_IEM, "MSR");
2401	if (rcStrict == VINF_SUCCESS)
2402	{
2403	rcStrict = IEMInjectTrap(pVCpu, X86_XCPT_GP, TRPM_TRAP, 0, 0, 0);
2404	if (rcStrict == VINF_IEM_RAISED_XCPT)
2405	rcStrict = VINF_SUCCESS;
2406	else if (rcStrict != VINF_SUCCESS)
2407	Log4(("MsrExit/%u: Injecting #GP(0) failed: %Rrc\n", VBOXSTRICTRC_VAL(rcStrict) ));
2408	}
2409	return rcStrict;
2410	}
2411	#elif defined(IN_RING3)
2412	/**
2413	* Deals with MSR access exits (WHvRunVpExitReasonX64MsrAccess).
2414	*
2415	* @returns Strict VBox status code.
2416	* @param pVM The cross context VM structure.
2417	* @param pVCpu The cross context per CPU structure.
2418	* @param pExit The VM exit information to handle.
2419	* @param pCtx The register context.
2420	* @sa nemHCWinHandleMessageMsr
2421	*/
2422	NEM_TMPL_STATIC VBOXSTRICTRC
2423	nemR3WinHandleExitMsr(PVM pVM, PVMCPU pVCpu, WHV_RUN_VP_EXIT_CONTEXT const *pExit, PCPUMCTX pCtx)
2424	{
2425	AssertMsg(pExit->VpContext.InstructionLength < 0x10, ("%#x\n", pExit->VpContext.InstructionLength));
2426
2427	/*
2428	* Check CPL as that's common to both RDMSR and WRMSR.
2429	*/
2430	VBOXSTRICTRC rcStrict;
2431	if (pExit->VpContext.ExecutionState.Cpl == 0)
2432	{
2433	/*
2434	* Get all the MSR state. Since we're getting EFER, we also need to
2435	* get CR0, CR4 and CR3.
2436	*/
2437	nemR3WinCopyStateFromX64Header(pVCpu, pCtx, &pExit->VpContext);
2438	rcStrict = nemHCWinImportStateIfNeededStrict(pVCpu, NULL, pCtx,
2439	CPUMCTX_EXTRN_ALL_MSRS \| CPUMCTX_EXTRN_CR0
2440	\| CPUMCTX_EXTRN_CR3 \| CPUMCTX_EXTRN_CR4,
2441	"MSRs");
2442	if (rcStrict == VINF_SUCCESS)
2443	{
2444	/*
2445	* Handle writes.
2446	*/
2447	if (pExit->MsrAccess.AccessInfo.IsWrite)
2448	{
2449	rcStrict = CPUMSetGuestMsr(pVCpu, pExit->MsrAccess.MsrNumber,
2450	RT_MAKE_U64((uint32_t)pExit->MsrAccess.Rax, (uint32_t)pExit->MsrAccess.Rdx));
2451	Log4(("MsrExit/%u: %04x:%08RX64/%s: WRMSR %08x, %08x:%08x -> %Rrc\n", pVCpu->idCpu, pExit->VpContext.Cs.Selector,
2452	pExit->VpContext.Rip, nemR3WinExecStateToLogStr(&pExit->VpContext), pExit->MsrAccess.MsrNumber,
2453	(uint32_t)pExit->MsrAccess.Rax, (uint32_t)pExit->MsrAccess.Rdx, VBOXSTRICTRC_VAL(rcStrict) ));
2454	if (rcStrict == VINF_SUCCESS)
2455	{
2456	nemR3WinAdvanceGuestRipAndClearRF(pVCpu, pCtx, &pExit->VpContext);
2457	return VINF_SUCCESS;
2458	}
2459	LogRel(("MsrExit/%u: %04x:%08RX64/%s: WRMSR %08x, %08x:%08x -> %Rrc!\n", pVCpu->idCpu,
2460	pExit->VpContext.Cs.Selector, pExit->VpContext.Rip, nemR3WinExecStateToLogStr(&pExit->VpContext),
2461	pExit->MsrAccess.MsrNumber, (uint32_t)pExit->MsrAccess.Rax, (uint32_t)pExit->MsrAccess.Rdx,
2462	VBOXSTRICTRC_VAL(rcStrict) ));
2463	}
2464	/*
2465	* Handle reads.
2466	*/
2467	else
2468	{
2469	uint64_t uValue = 0;
2470	rcStrict = CPUMQueryGuestMsr(pVCpu, pExit->MsrAccess.MsrNumber, &uValue);
2471	Log4(("MsrExit/%u: %04x:%08RX64/%s: RDMSR %08x -> %08RX64 / %Rrc\n", pVCpu->idCpu,
2472	pExit->VpContext.Cs.Selector, pExit->VpContext.Rip, nemR3WinExecStateToLogStr(&pExit->VpContext),
2473	pExit->MsrAccess.MsrNumber, uValue, VBOXSTRICTRC_VAL(rcStrict) ));
2474	if (rcStrict == VINF_SUCCESS)
2475	{
2476	pCtx->rax = (uint32_t)uValue;
2477	pCtx->rdx = uValue >> 32;
2478	pCtx->fExtrn &= ~(CPUMCTX_EXTRN_RAX \| CPUMCTX_EXTRN_RDX);
2479	nemR3WinAdvanceGuestRipAndClearRF(pVCpu, pCtx, &pExit->VpContext);
2480	return VINF_SUCCESS;
2481	}
2482	LogRel(("MsrExit/%u: %04x:%08RX64/%s: RDMSR %08x -> %08RX64 / %Rrc\n", pVCpu->idCpu, pExit->VpContext.Cs.Selector,
2483	pExit->VpContext.Rip, nemR3WinExecStateToLogStr(&pExit->VpContext), pExit->MsrAccess.MsrNumber,
2484	uValue, VBOXSTRICTRC_VAL(rcStrict) ));
2485	}
2486	}
2487	else
2488	{
2489	LogRel(("MsrExit/%u: %04x:%08RX64/%s: %sMSR %08x -> %Rrc - msr state import\n",
2490	pVCpu->idCpu, pExit->VpContext.Cs.Selector, pExit->VpContext.Rip, nemR3WinExecStateToLogStr(&pExit->VpContext),
2491	pExit->MsrAccess.AccessInfo.IsWrite ? "WR" : "RD", pExit->MsrAccess.MsrNumber, VBOXSTRICTRC_VAL(rcStrict) ));
2492	return rcStrict;
2493	}
2494	}
2495	else if (pExit->MsrAccess.AccessInfo.IsWrite)
2496	Log4(("MsrExit/%u: %04x:%08RX64/%s: CPL %u -> #GP(0); WRMSR %08x, %08x:%08x\n", pVCpu->idCpu, pExit->VpContext.Cs.Selector,
2497	pExit->VpContext.Rip, nemR3WinExecStateToLogStr(&pExit->VpContext), pExit->VpContext.ExecutionState.Cpl,
2498	pExit->MsrAccess.MsrNumber, (uint32_t)pExit->MsrAccess.Rax, (uint32_t)pExit->MsrAccess.Rdx ));
2499	else
2500	Log4(("MsrExit/%u: %04x:%08RX64/%s: CPL %u -> #GP(0); RDMSR %08x\n", pVCpu->idCpu, pExit->VpContext.Cs.Selector,
2501	pExit->VpContext.Rip, nemR3WinExecStateToLogStr(&pExit->VpContext), pExit->VpContext.ExecutionState.Cpl,
2502	pExit->MsrAccess.MsrNumber));
2503
2504	/*
2505	* If we get down here, we're supposed to #GP(0).
2506	*/
2507	rcStrict = nemHCWinImportStateIfNeededStrict(pVCpu, NULL, pCtx, NEM_WIN_CPUMCTX_EXTRN_MASK_FOR_IEM, "MSR");
2508	if (rcStrict == VINF_SUCCESS)
2509	{
2510	rcStrict = IEMInjectTrap(pVCpu, X86_XCPT_GP, TRPM_TRAP, 0, 0, 0);
2511	if (rcStrict == VINF_IEM_RAISED_XCPT)
2512	rcStrict = VINF_SUCCESS;
2513	else if (rcStrict != VINF_SUCCESS)
2514	Log4(("MsrExit/%u: Injecting #GP(0) failed: %Rrc\n", VBOXSTRICTRC_VAL(rcStrict) ));
2515	}
2516
2517	RT_NOREF_PV(pVM);
2518	return rcStrict;
2519	}
2520	#endif /* IN_RING3 && !NEM_WIN_USE_OUR_OWN_RUN_API */
2521
2522	#ifdef NEM_WIN_USE_OUR_OWN_RUN_API
2523	/**
2524	* Deals with unrecoverable exception (triple fault).
2525	*
2526	* Seen WRMSR 0x201 (IA32_MTRR_PHYSMASK0) writes from grub / debian9 ending up
2527	* here too. So we'll leave it to IEM to decide.
2528	*
2529	* @returns Strict VBox status code.
2530	* @param pVCpu The cross context per CPU structure.
2531	* @param pMsgHdr The message header.
2532	* @param pCtx The register context.
2533	* @param pGVCpu The global (ring-0) per CPU structure (NULL in r3).
2534	* @sa nemR3WinHandleExitUnrecoverableException
2535	*/
2536	NEM_TMPL_STATIC VBOXSTRICTRC nemHCWinHandleMessageUnrecoverableException(PVMCPU pVCpu,
2537	HV_X64_INTERCEPT_MESSAGE_HEADER const *pMsgHdr,
2538	PCPUMCTX pCtx, PGVMCPU pGVCpu)
2539	{
2540	AssertMsg(pMsgHdr->InstructionLength < 0x10, ("%#x\n", pMsgHdr->InstructionLength));
2541
2542	# if 0
2543	/*
2544	* Just copy the state we've got and handle it in the loop for now.
2545	*/
2546	nemHCWinCopyStateFromX64Header(pVCpu, pCtx, pMsgHdr);
2547	Log(("TripleExit/%u: %04x:%08RX64/%s: RFL=%#RX64 -> VINF_EM_TRIPLE_FAULT\n",
2548	pVCpu->idCpu, pMsgHdr->CsSegment.Selector, pMsgHdr->Rip, nemHCWinExecStateToLogStr(&pMsg->Header), pMsgHdr->Rflags));
2549	return VINF_EM_TRIPLE_FAULT;
2550	# else
2551	/*
2552	* Let IEM decide whether this is really it.
2553	*/
2554	nemHCWinCopyStateFromX64Header(pVCpu, pCtx, pMsgHdr);
2555	VBOXSTRICTRC rcStrict = nemHCWinImportStateIfNeededStrict(pVCpu, pGVCpu, pCtx,
2556	NEM_WIN_CPUMCTX_EXTRN_MASK_FOR_IEM \| CPUMCTX_EXTRN_ALL, "TripleExit");
2557	if (rcStrict == VINF_SUCCESS)
2558	{
2559	rcStrict = IEMExecOne(pVCpu);
2560	if (rcStrict == VINF_SUCCESS)
2561	{
2562	Log(("UnrecovExit/%u: %04x:%08RX64/%s: RFL=%#RX64 -> VINF_SUCCESS\n", pVCpu->idCpu, pMsgHdr->CsSegment.Selector,
2563	pMsgHdr->Rip, nemHCWinExecStateToLogStr(pMsgHdr), pMsgHdr->Rflags ));
2564	pCtx->fExtrn &= ~CPUMCTX_EXTRN_NEM_WIN_EVENT_INJECT; /* Make sure to reset pending #DB(0). */
2565	return VINF_SUCCESS;
2566	}
2567	if (rcStrict == VINF_EM_TRIPLE_FAULT)
2568	Log(("UnrecovExit/%u: %04x:%08RX64/%s: RFL=%#RX64 -> VINF_EM_TRIPLE_FAULT!\n", pVCpu->idCpu, pMsgHdr->CsSegment.Selector,
2569	pMsgHdr->Rip, nemHCWinExecStateToLogStr(pMsgHdr), pMsgHdr->Rflags, VBOXSTRICTRC_VAL(rcStrict) ));
2570	else
2571	Log(("UnrecovExit/%u: %04x:%08RX64/%s: RFL=%#RX64 -> %Rrc (IEMExecOne)\n", pVCpu->idCpu, pMsgHdr->CsSegment.Selector,
2572	pMsgHdr->Rip, nemHCWinExecStateToLogStr(pMsgHdr), pMsgHdr->Rflags, VBOXSTRICTRC_VAL(rcStrict) ));
2573	}
2574	else
2575	Log(("UnrecovExit/%u: %04x:%08RX64/%s: RFL=%#RX64 -> %Rrc (state import)\n", pVCpu->idCpu, pMsgHdr->CsSegment.Selector,
2576	pMsgHdr->Rip, nemHCWinExecStateToLogStr(pMsgHdr), pMsgHdr->Rflags, VBOXSTRICTRC_VAL(rcStrict) ));
2577	return rcStrict;
2578	# endif
2579	}
2580	#elif defined(IN_RING3)
2581	/**
2582	* Deals with MSR access exits (WHvRunVpExitReasonUnrecoverableException).
2583	*
2584	* @returns Strict VBox status code.
2585	* @param pVM The cross context VM structure.
2586	* @param pVCpu The cross context per CPU structure.
2587	* @param pExit The VM exit information to handle.
2588	* @param pCtx The register context.
2589	* @sa nemHCWinHandleMessageUnrecoverableException
2590	*/
2591	NEM_TMPL_STATIC VBOXSTRICTRC
2592	nemR3WinHandleExitUnrecoverableException(PVM pVM, PVMCPU pVCpu, WHV_RUN_VP_EXIT_CONTEXT const *pExit, PCPUMCTX pCtx)
2593	{
2594	AssertMsg(pExit->VpContext.InstructionLength < 0x10, ("%#x\n", pExit->VpContext.InstructionLength));
2595
2596	# if 0
2597	/*
2598	* Just copy the state we've got and handle it in the loop for now.
2599	*/
2600	nemR3WinCopyStateFromX64Header(pVCpu, pCtx, &pExit->VpContext);
2601	Log(("TripleExit/%u: %04x:%08RX64/%s: RFL=%#RX64 -> VINF_EM_TRIPLE_FAULT\n", pVCpu->idCpu, pExit->VpContext.Cs.Selector,
2602	pExit->VpContext.Rip, nemR3WinExecStateToLogStr(&pExit->VpContext), pExit->VpContext.Rflags));
2603	RT_NOREF_PV(pVM);
2604	return VINF_EM_TRIPLE_FAULT;
2605	# else
2606	/*
2607	* Let IEM decide whether this is really it.
2608	*/
2609	nemR3WinCopyStateFromX64Header(pVCpu, pCtx, &pExit->VpContext);
2610	VBOXSTRICTRC rcStrict = nemHCWinImportStateIfNeededStrict(pVCpu, NULL, pCtx,
2611	NEM_WIN_CPUMCTX_EXTRN_MASK_FOR_IEM \| CPUMCTX_EXTRN_ALL, "TripleExit");
2612	if (rcStrict == VINF_SUCCESS)
2613	{
2614	rcStrict = IEMExecOne(pVCpu);
2615	if (rcStrict == VINF_SUCCESS)
2616	{
2617	Log(("UnrecovExit/%u: %04x:%08RX64/%s: RFL=%#RX64 -> VINF_SUCCESS\n", pVCpu->idCpu, pExit->VpContext.Cs.Selector,
2618	pExit->VpContext.Rip, nemR3WinExecStateToLogStr(&pExit->VpContext), pExit->VpContext.Rflags));
2619	pCtx->fExtrn &= ~CPUMCTX_EXTRN_NEM_WIN_EVENT_INJECT; /* Make sure to reset pending #DB(0). */
2620	return VINF_SUCCESS;
2621	}
2622	if (rcStrict == VINF_EM_TRIPLE_FAULT)
2623	Log(("UnrecovExit/%u: %04x:%08RX64/%s: RFL=%#RX64 -> VINF_EM_TRIPLE_FAULT!\n", pVCpu->idCpu, pExit->VpContext.Cs.Selector,
2624	pExit->VpContext.Rip, nemR3WinExecStateToLogStr(&pExit->VpContext), pExit->VpContext.Rflags, VBOXSTRICTRC_VAL(rcStrict) ));
2625	else
2626	Log(("UnrecovExit/%u: %04x:%08RX64/%s: RFL=%#RX64 -> %Rrc (IEMExecOne)\n", pVCpu->idCpu, pExit->VpContext.Cs.Selector,
2627	pExit->VpContext.Rip, nemR3WinExecStateToLogStr(&pExit->VpContext), pExit->VpContext.Rflags, VBOXSTRICTRC_VAL(rcStrict) ));
2628	}
2629	else
2630	Log(("UnrecovExit/%u: %04x:%08RX64/%s: RFL=%#RX64 -> %Rrc (state import)\n", pVCpu->idCpu, pExit->VpContext.Cs.Selector,
2631	pExit->VpContext.Rip, nemR3WinExecStateToLogStr(&pExit->VpContext), pExit->VpContext.Rflags, VBOXSTRICTRC_VAL(rcStrict) ));
2632	RT_NOREF_PV(pVM);
2633	return rcStrict;
2634	# endif
2635
2636	}
2637	#endif /* IN_RING3 && !NEM_WIN_USE_OUR_OWN_RUN_API */
2638
2639	#ifdef NEM_WIN_USE_OUR_OWN_RUN_API
2640	/**
2641	* Handles messages (VM exits).
2642	*
2643	* @returns Strict VBox status code.
2644	* @param pVM The cross context VM structure.
2645	* @param pVCpu The cross context per CPU structure.
2646	* @param pMappingHeader The message slot mapping.
2647	* @param pCtx The register context.
2648	* @param pGVCpu The global (ring-0) per CPU structure (NULL in r3).
2649	* @sa nemR3WinHandleExit
2650	*/
2651	NEM_TMPL_STATIC VBOXSTRICTRC nemHCWinHandleMessage(PVM pVM, PVMCPU pVCpu, VID_MESSAGE_MAPPING_HEADER volatile *pMappingHeader,
2652	PCPUMCTX pCtx, PGVMCPU pGVCpu)
2653	{
2654	if (pMappingHeader->enmVidMsgType == VidMessageHypervisorMessage)
2655	{
2656	AssertMsg(pMappingHeader->cbMessage == HV_MESSAGE_SIZE, ("%#x\n", pMappingHeader->cbMessage));
2657	HV_MESSAGE const pMsg = (HV_MESSAGE const )(pMappingHeader + 1);
2658	switch (pMsg->Header.MessageType)
2659	{
2660	case HvMessageTypeUnmappedGpa:
2661	Assert(pMsg->Header.PayloadSize == RT_UOFFSETOF(HV_X64_MEMORY_INTERCEPT_MESSAGE, DsSegment));
2662	STAM_REL_COUNTER_INC(&pVCpu->nem.s.StatExitMemUnmapped);
2663	return nemHCWinHandleMessageMemory(pVM, pVCpu, &pMsg->X64MemoryIntercept, pCtx, pGVCpu);
2664
2665	case HvMessageTypeGpaIntercept:
2666	Assert(pMsg->Header.PayloadSize == RT_UOFFSETOF(HV_X64_MEMORY_INTERCEPT_MESSAGE, DsSegment));
2667	STAM_REL_COUNTER_INC(&pVCpu->nem.s.StatExitMemIntercept);
2668	return nemHCWinHandleMessageMemory(pVM, pVCpu, &pMsg->X64MemoryIntercept, pCtx, pGVCpu);
2669
2670	case HvMessageTypeX64IoPortIntercept:
2671	Assert(pMsg->Header.PayloadSize == sizeof(pMsg->X64IoPortIntercept));
2672	STAM_REL_COUNTER_INC(&pVCpu->nem.s.StatExitPortIo);
2673	return nemHCWinHandleMessageIoPort(pVM, pVCpu, &pMsg->X64IoPortIntercept, pCtx, pGVCpu);
2674
2675	case HvMessageTypeX64Halt:
2676	STAM_REL_COUNTER_INC(&pVCpu->nem.s.StatExitHalt);
2677	Log4(("HaltExit\n"));
2678	return VINF_EM_HALT;
2679
2680	case HvMessageTypeX64InterruptWindow:
2681	Assert(pMsg->Header.PayloadSize == sizeof(pMsg->X64InterruptWindow));
2682	STAM_REL_COUNTER_INC(&pVCpu->nem.s.StatExitInterruptWindow);
2683	return nemHCWinHandleMessageInterruptWindow(pVM, pVCpu, &pMsg->X64InterruptWindow, pCtx, pGVCpu);
2684
2685	case HvMessageTypeX64CpuidIntercept:
2686	Assert(pMsg->Header.PayloadSize == sizeof(pMsg->X64CpuIdIntercept));
2687	STAM_REL_COUNTER_INC(&pVCpu->nem.s.StatExitCpuId);
2688	return nemHCWinHandleMessageCpuId(pVCpu, &pMsg->X64CpuIdIntercept, pCtx);
2689
2690	case HvMessageTypeX64MsrIntercept:
2691	Assert(pMsg->Header.PayloadSize == sizeof(pMsg->X64MsrIntercept));
2692	STAM_REL_COUNTER_INC(&pVCpu->nem.s.StatExitMsr);
2693	return nemHCWinHandleMessageMsr(pVCpu, &pMsg->X64MsrIntercept, pCtx, pGVCpu);
2694
2695	case HvMessageTypeUnrecoverableException:
2696	Assert(pMsg->Header.PayloadSize == sizeof(pMsg->X64InterceptHeader));
2697	STAM_REL_COUNTER_INC(&pVCpu->nem.s.StatExitUnrecoverable);
2698	return nemHCWinHandleMessageUnrecoverableException(pVCpu, &pMsg->X64InterceptHeader, pCtx, pGVCpu);
2699
2700	case HvMessageTypeInvalidVpRegisterValue:
2701	case HvMessageTypeUnsupportedFeature:
2702	case HvMessageTypeTlbPageSizeMismatch:
2703	LogRel(("Unimplemented msg:\n%.Rhxd\n", (int)sizeof(pMsg), pMsg));
2704	AssertLogRelMsgFailedReturn(("Message type %#x not implemented!\n%.32Rhxd\n", pMsg->Header.MessageType, pMsg),
2705	VERR_NEM_IPE_3);
2706
2707	case HvMessageTypeX64ExceptionIntercept:
2708	case HvMessageTypeX64ApicEoi:
2709	case HvMessageTypeX64LegacyFpError:
2710	case HvMessageTypeX64RegisterIntercept:
2711	case HvMessageTypeApicEoi:
2712	case HvMessageTypeFerrAsserted:
2713	case HvMessageTypeEventLogBufferComplete:
2714	case HvMessageTimerExpired:
2715	LogRel(("Unexpected msg:\n%.Rhxd\n", (int)sizeof(pMsg), pMsg));
2716	AssertLogRelMsgFailedReturn(("Unexpected message on CPU #%u: %#x\n", pVCpu->idCpu, pMsg->Header.MessageType),
2717	VERR_NEM_IPE_3);
2718
2719	default:
2720	LogRel(("Unknown msg:\n%.Rhxd\n", (int)sizeof(pMsg), pMsg));
2721	AssertLogRelMsgFailedReturn(("Unknown message on CPU #%u: %#x\n", pVCpu->idCpu, pMsg->Header.MessageType),
2722	VERR_NEM_IPE_3);
2723	}
2724	}
2725	else
2726	AssertLogRelMsgFailedReturn(("Unexpected VID message type on CPU #%u: %#x LB %u\n",
2727	pVCpu->idCpu, pMappingHeader->enmVidMsgType, pMappingHeader->cbMessage),
2728	VERR_NEM_IPE_4);
2729	}
2730	#elif defined(IN_RING3)
2731	/**
2732	* Handles VM exits.
2733	*
2734	* @returns Strict VBox status code.
2735	* @param pVM The cross context VM structure.
2736	* @param pVCpu The cross context per CPU structure.
2737	* @param pExit The VM exit information to handle.
2738	* @param pCtx The register context.
2739	* @sa nemHCWinHandleMessage
2740	*/
2741	NEM_TMPL_STATIC VBOXSTRICTRC nemR3WinHandleExit(PVM pVM, PVMCPU pVCpu, WHV_RUN_VP_EXIT_CONTEXT const *pExit, PCPUMCTX pCtx)
2742	{
2743	switch (pExit->ExitReason)
2744	{
2745	case WHvRunVpExitReasonMemoryAccess:
2746	STAM_REL_COUNTER_INC(&pVCpu->nem.s.StatExitMemUnmapped);
2747	return nemR3WinHandleExitMemory(pVM, pVCpu, pExit, pCtx);
2748
2749	case WHvRunVpExitReasonX64IoPortAccess:
2750	STAM_REL_COUNTER_INC(&pVCpu->nem.s.StatExitPortIo);
2751	return nemR3WinHandleExitIoPort(pVM, pVCpu, pExit, pCtx);
2752
2753	case WHvRunVpExitReasonX64Halt:
2754	STAM_REL_COUNTER_INC(&pVCpu->nem.s.StatExitHalt);
2755	Log4(("HaltExit\n"));
2756	return VINF_EM_HALT;
2757
2758	case WHvRunVpExitReasonCanceled:
2759	return VINF_SUCCESS;
2760
2761	case WHvRunVpExitReasonX64InterruptWindow:
2762	STAM_REL_COUNTER_INC(&pVCpu->nem.s.StatExitInterruptWindow);
2763	return nemR3WinHandleExitInterruptWindow(pVM, pVCpu, pExit, pCtx);
2764
2765	case WHvRunVpExitReasonX64Cpuid:
2766	STAM_REL_COUNTER_INC(&pVCpu->nem.s.StatExitCpuId);
2767	return nemR3WinHandleExitCpuId(pVM, pVCpu, pExit, pCtx);
2768
2769	case WHvRunVpExitReasonX64MsrAccess:
2770	STAM_REL_COUNTER_INC(&pVCpu->nem.s.StatExitMsr);
2771	return nemR3WinHandleExitMsr(pVM, pVCpu, pExit, pCtx);
2772
2773	case WHvRunVpExitReasonUnrecoverableException:
2774	STAM_REL_COUNTER_INC(&pVCpu->nem.s.StatExitUnrecoverable);
2775	return nemR3WinHandleExitUnrecoverableException(pVM, pVCpu, pExit, pCtx);
2776
2777	case WHvRunVpExitReasonException: /* needs configuring */
2778	case WHvRunVpExitReasonUnsupportedFeature:
2779	case WHvRunVpExitReasonInvalidVpRegisterValue:
2780	LogRel(("Unimplemented exit:\n%.Rhxd\n", (int)sizeof(pExit), pExit));
2781	AssertLogRelMsgFailedReturn(("Unexpected exit on CPU #%u: %#x\n%.32Rhxd\n",
2782	pVCpu->idCpu, pExit->ExitReason, pExit), VERR_NEM_IPE_3);
2783
2784	/* Undesired exits: */
2785	case WHvRunVpExitReasonNone:
2786	default:
2787	LogRel(("Unknown exit:\n%.Rhxd\n", (int)sizeof(pExit), pExit));
2788	AssertLogRelMsgFailedReturn(("Unknown exit on CPU #%u: %#x!\n", pVCpu->idCpu, pExit->ExitReason), VERR_NEM_IPE_3);
2789	}
2790	}
2791	#endif /* IN_RING3 && !NEM_WIN_USE_OUR_OWN_RUN_API */
2792
2793	#ifdef NEM_WIN_USE_OUR_OWN_RUN_API
2794	/**
2795	* Worker for nemHCWinRunGC that stops the execution on the way out.
2796	*
2797	* The CPU was running the last time we checked, no there are no messages that
2798	* needs being marked handled/whatever. Caller checks this.
2799	*
2800	* @returns rcStrict on success, error status on failure.
2801	* @param pVM The cross context VM structure.
2802	* @param pVCpu The cross context per CPU structure.
2803	* @param rcStrict The nemHCWinRunGC return status. This is a little
2804	* bit unnecessary, except in internal error cases,
2805	* since we won't need to stop the CPU if we took an
2806	* exit.
2807	* @param pMappingHeader The message slot mapping.
2808	* @param pGVM The global (ring-0) VM structure (NULL in r3).
2809	* @param pGVCpu The global (ring-0) per CPU structure (NULL in r3).
2810	*/
2811	NEM_TMPL_STATIC VBOXSTRICTRC nemHCWinStopCpu(PVM pVM, PVMCPU pVCpu, VBOXSTRICTRC rcStrict,
2812	VID_MESSAGE_MAPPING_HEADER volatile *pMappingHeader,
2813	PGVM pGVM, PGVMCPU pGVCpu)
2814	{
2815	/*
2816	* Try stopping the processor. If we're lucky we manage to do this before it
2817	* does another VM exit.
2818	*/
2819	# ifdef IN_RING0
2820	pVCpu->nem.s.uIoCtlBuf.idCpu = pGVCpu->idCpu;
2821	NTSTATUS rcNt = nemR0NtPerformIoControl(pGVM, pGVM->nem.s.IoCtlStopVirtualProcessor.uFunction,
2822	&pVCpu->nem.s.uIoCtlBuf.idCpu, sizeof(pVCpu->nem.s.uIoCtlBuf.idCpu),
2823	NULL, 0);
2824	if (NT_SUCCESS(rcNt))
2825	{
2826	Log8(("nemHCWinStopCpu: Stopping CPU succeeded (cpu status %u)\n", nemHCWinCpuGetRunningStatus(pVCpu) ));
2827	STAM_REL_COUNTER_INC(&pVCpu->nem.s.StatStopCpuSuccess);
2828	return rcStrict;
2829	}
2830	# else
2831	BOOL fRet = VidStopVirtualProcessor(pVM->nem.s.hPartitionDevice, pVCpu->idCpu);
2832	if (fRet)
2833	{
2834	Log8(("nemHCWinStopCpu: Stopping CPU succeeded (cpu status %u)\n", nemHCWinCpuGetRunningStatus(pVCpu) ));
2835	STAM_REL_COUNTER_INC(&pVCpu->nem.s.StatStopCpuSuccess);
2836	return rcStrict;
2837	}
2838	RT_NOREF(pGVM, pGVCpu);
2839	# endif
2840
2841	/*
2842	* Dang. The CPU stopped by itself and we got a couple of message to deal with.
2843	*/
2844	# ifdef IN_RING0
2845	AssertLogRelMsgReturn(rcNt == ERROR_VID_STOP_PENDING, ("rcNt=%#x\n", rcNt),
2846	RT_SUCCESS(rcStrict) ? VERR_NEM_IPE_5 : rcStrict);
2847	# else
2848	DWORD dwErr = RTNtLastErrorValue();
2849	AssertLogRelMsgReturn(dwErr == ERROR_VID_STOP_PENDING, ("dwErr=%#u (%#x)\n", dwErr, dwErr),
2850	RT_SUCCESS(rcStrict) ? VERR_NEM_IPE_5 : rcStrict);
2851	# endif
2852	Log8(("nemHCWinStopCpu: Stopping CPU pending...\n"));
2853	STAM_REL_COUNTER_INC(&pVCpu->nem.s.StatStopCpuPending);
2854
2855	/*
2856	* First message: Exit or similar.
2857	* Note! We can safely ASSUME that rcStrict isn't an important information one.
2858	*/
2859	# ifdef IN_RING0
2860	pVCpu->nem.s.uIoCtlBuf.MsgSlotHandleAndGetNext.iCpu = pGVCpu->idCpu;
2861	pVCpu->nem.s.uIoCtlBuf.MsgSlotHandleAndGetNext.fFlags = VID_MSHAGN_F_GET_NEXT_MESSAGE;
2862	pVCpu->nem.s.uIoCtlBuf.MsgSlotHandleAndGetNext.cMillies = 30000; /ms/
2863	rcNt = nemR0NtPerformIoControl(pGVM, pGVM->nem.s.IoCtlMessageSlotHandleAndGetNext.uFunction,
2864	&pVCpu->nem.s.uIoCtlBuf.MsgSlotHandleAndGetNext,
2865	sizeof(pVCpu->nem.s.uIoCtlBuf.MsgSlotHandleAndGetNext),
2866	NULL, 0);
2867	AssertLogRelMsgReturn(NT_SUCCESS(rcNt), ("1st VidMessageSlotHandleAndGetNext after ERROR_VID_STOP_PENDING failed: %#x\n", rcNt),
2868	RT_SUCCESS(rcStrict) ? VERR_NEM_IPE_5 : rcStrict);
2869	# else
2870	BOOL fWait = g_pfnVidMessageSlotHandleAndGetNext(pVM->nem.s.hPartitionDevice, pVCpu->idCpu,
2871	VID_MSHAGN_F_GET_NEXT_MESSAGE, 30000 /ms/);
2872	AssertLogRelMsgReturn(fWait, ("1st VidMessageSlotHandleAndGetNext after ERROR_VID_STOP_PENDING failed: %u\n", RTNtLastErrorValue()),
2873	RT_SUCCESS(rcStrict) ? VERR_NEM_IPE_5 : rcStrict);
2874	# endif
2875
2876	/* It should be a hypervisor message and definitely not a stop request completed message. */
2877	VID_MESSAGE_TYPE enmVidMsgType = pMappingHeader->enmVidMsgType;
2878	AssertLogRelMsgReturn(enmVidMsgType != VidMessageStopRequestComplete,
2879	("Unexpected 1st message following ERROR_VID_STOP_PENDING: %#x LB %#x\n",
2880	enmVidMsgType, pMappingHeader->cbMessage),
2881	RT_SUCCESS(rcStrict) ? VERR_NEM_IPE_5 : rcStrict);
2882
2883	VBOXSTRICTRC rcStrict2 = nemHCWinHandleMessage(pVM, pVCpu, pMappingHeader, CPUMQueryGuestCtxPtr(pVCpu), pGVCpu);
2884	if (rcStrict2 != VINF_SUCCESS && RT_SUCCESS(rcStrict))
2885	rcStrict = rcStrict2;
2886
2887	/*
2888	* Mark it as handled and get the stop request completed message, then mark
2889	* that as handled too. CPU is back into fully stopped stated then.
2890	*/
2891	# ifdef IN_RING0
2892	pVCpu->nem.s.uIoCtlBuf.MsgSlotHandleAndGetNext.iCpu = pGVCpu->idCpu;
2893	pVCpu->nem.s.uIoCtlBuf.MsgSlotHandleAndGetNext.fFlags = VID_MSHAGN_F_HANDLE_MESSAGE \| VID_MSHAGN_F_GET_NEXT_MESSAGE;
2894	pVCpu->nem.s.uIoCtlBuf.MsgSlotHandleAndGetNext.cMillies = 30000; /ms/
2895	rcNt = nemR0NtPerformIoControl(pGVM, pGVM->nem.s.IoCtlMessageSlotHandleAndGetNext.uFunction,
2896	&pVCpu->nem.s.uIoCtlBuf.MsgSlotHandleAndGetNext,
2897	sizeof(pVCpu->nem.s.uIoCtlBuf.MsgSlotHandleAndGetNext),
2898	NULL, 0);
2899	AssertLogRelMsgReturn(NT_SUCCESS(rcNt), ("2st VidMessageSlotHandleAndGetNext after ERROR_VID_STOP_PENDING failed: %#x\n", rcNt),
2900	RT_SUCCESS(rcStrict) ? VERR_NEM_IPE_5 : rcStrict);
2901	# else
2902	fWait = g_pfnVidMessageSlotHandleAndGetNext(pVM->nem.s.hPartitionDevice, pVCpu->idCpu,
2903	VID_MSHAGN_F_HANDLE_MESSAGE \| VID_MSHAGN_F_GET_NEXT_MESSAGE, 30000 /ms/);
2904	AssertLogRelMsgReturn(fWait, ("2nd VidMessageSlotHandleAndGetNext after ERROR_VID_STOP_PENDING failed: %u\n", RTNtLastErrorValue()),
2905	RT_SUCCESS(rcStrict) ? VERR_NEM_IPE_5 : rcStrict);
2906	# endif
2907
2908	/* It should be a stop request completed message. */
2909	enmVidMsgType = pMappingHeader->enmVidMsgType;
2910	AssertLogRelMsgReturn(enmVidMsgType == VidMessageStopRequestComplete,
2911	("Unexpected 2nd message following ERROR_VID_STOP_PENDING: %#x LB %#x\n",
2912	enmVidMsgType, pMappingHeader->cbMessage),
2913	RT_SUCCESS(rcStrict) ? VERR_NEM_IPE_5 : rcStrict);
2914
2915	/* Mark this as handled. */
2916	# ifdef IN_RING0
2917	pVCpu->nem.s.uIoCtlBuf.MsgSlotHandleAndGetNext.iCpu = pGVCpu->idCpu;
2918	pVCpu->nem.s.uIoCtlBuf.MsgSlotHandleAndGetNext.fFlags = VID_MSHAGN_F_HANDLE_MESSAGE;
2919	pVCpu->nem.s.uIoCtlBuf.MsgSlotHandleAndGetNext.cMillies = 30000; /ms/
2920	rcNt = nemR0NtPerformIoControl(pGVM, pGVM->nem.s.IoCtlMessageSlotHandleAndGetNext.uFunction,
2921	&pVCpu->nem.s.uIoCtlBuf.MsgSlotHandleAndGetNext,
2922	sizeof(pVCpu->nem.s.uIoCtlBuf.MsgSlotHandleAndGetNext),
2923	NULL, 0);
2924	AssertLogRelMsgReturn(NT_SUCCESS(rcNt), ("3rd VidMessageSlotHandleAndGetNext after ERROR_VID_STOP_PENDING failed: %#x\n", rcNt),
2925	RT_SUCCESS(rcStrict) ? VERR_NEM_IPE_5 : rcStrict);
2926	# else
2927	fWait = g_pfnVidMessageSlotHandleAndGetNext(pVM->nem.s.hPartitionDevice, pVCpu->idCpu, VID_MSHAGN_F_HANDLE_MESSAGE, 30000 /ms/);
2928	AssertLogRelMsgReturn(fWait, ("3rd VidMessageSlotHandleAndGetNext after ERROR_VID_STOP_PENDING failed: %u\n", RTNtLastErrorValue()),
2929	RT_SUCCESS(rcStrict) ? VERR_NEM_IPE_5 : rcStrict);
2930	# endif
2931	Log8(("nemHCWinStopCpu: Stopped the CPU (rcStrict=%Rrc)\n", VBOXSTRICTRC_VAL(rcStrict) ));
2932	return rcStrict;
2933	}
2934	#endif /* NEM_WIN_USE_OUR_OWN_RUN_API */
2935
2936	#if defined(NEM_WIN_USE_OUR_OWN_RUN_API) \|\| defined(IN_RING3)
2937
2938	/**
2939	* Deals with pending interrupt related force flags, may inject interrupt.
2940	*
2941	* @returns VBox strict status code.
2942	* @param pVM The cross context VM structure.
2943	* @param pVCpu The cross context per CPU structure.
2944	* @param pGVCpu The global (ring-0) per CPU structure.
2945	* @param pCtx The register context.
2946	* @param pfInterruptWindows Where to return interrupt window flags.
2947	*/
2948	NEM_TMPL_STATIC VBOXSTRICTRC
2949	nemHCWinHandleInterruptFF(PVM pVM, PVMCPU pVCpu, PGVMCPU pGVCpu, PCPUMCTX pCtx, uint8_t *pfInterruptWindows)
2950	{
2951	Assert(!TRPMHasTrap(pVCpu));
2952	RT_NOREF_PV(pVM);
2953
2954	/*
2955	* First update APIC.
2956	*/
2957	if (VMCPU_FF_TEST_AND_CLEAR(pVCpu, VMCPU_FF_UPDATE_APIC))
2958	{
2959	APICUpdatePendingInterrupts(pVCpu);
2960	if (!VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_INTERRUPT_APIC \| VMCPU_FF_INTERRUPT_PIC
2961	\| VMCPU_FF_INTERRUPT_NMI \| VMCPU_FF_INTERRUPT_SMI))
2962	return VINF_SUCCESS;
2963	}
2964
2965	/*
2966	* We don't currently implement SMIs.
2967	*/
2968	AssertReturn(!VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_INTERRUPT_SMI), VERR_NEM_IPE_0);
2969
2970	/*
2971	* Check if we've got the minimum of state required for deciding whether we
2972	* can inject interrupts and NMIs. If we don't have it, get all we might require
2973	* for injection via IEM.
2974	*/
2975	bool const fPendingNmi = VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_INTERRUPT_NMI);
2976	uint64_t fNeedExtrn = CPUMCTX_EXTRN_NEM_WIN_INHIBIT_INT \| CPUMCTX_EXTRN_RIP \| CPUMCTX_EXTRN_RFLAGS
2977	\| (fPendingNmi ? CPUMCTX_EXTRN_NEM_WIN_INHIBIT_NMI : 0);
2978	if (pCtx->fExtrn & fNeedExtrn)
2979	{
2980	VBOXSTRICTRC rcStrict = nemHCWinImportStateIfNeededStrict(pVCpu, pGVCpu, pCtx, NEM_WIN_CPUMCTX_EXTRN_MASK_FOR_IEM, "IntFF");
2981	if (rcStrict != VINF_SUCCESS)
2982	return rcStrict;
2983	}
2984	bool const fInhibitInterrupts = VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS)
2985	&& EMGetInhibitInterruptsPC(pVCpu) == pCtx->rip;
2986
2987	/*
2988	* NMI? Try deliver it first.
2989	*/
2990	if (fPendingNmi)
2991	{
2992	if ( !fInhibitInterrupts
2993	&& !VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_BLOCK_NMIS))
2994	{
2995	VBOXSTRICTRC rcStrict = nemHCWinImportStateIfNeededStrict(pVCpu, pGVCpu, pCtx, NEM_WIN_CPUMCTX_EXTRN_MASK_FOR_IEM, "NMI");
2996	if (rcStrict == VINF_SUCCESS)
2997	{
2998	VMCPU_FF_CLEAR(pVCpu, VMCPU_FF_INTERRUPT_NMI);
2999	rcStrict = IEMInjectTrap(pVCpu, X86_XCPT_NMI, TRPM_HARDWARE_INT, 0, 0, 0);
3000	Log8(("Injected NMI on %u (%d)\n", pVCpu->idCpu, VBOXSTRICTRC_VAL(rcStrict) ));
3001	}
3002	return rcStrict;
3003	}
3004	*pfInterruptWindows \|= NEM_WIN_INTW_F_NMI;
3005	Log8(("NMI window pending on %u\n", pVCpu->idCpu));
3006	}
3007
3008	/*
3009	* APIC or PIC interrupt?
3010	*/
3011	if (VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_INTERRUPT_APIC \| VMCPU_FF_INTERRUPT_PIC))
3012	{
3013	if ( !fInhibitInterrupts
3014	&& pCtx->rflags.Bits.u1IF)
3015	{
3016	VBOXSTRICTRC rcStrict = nemHCWinImportStateIfNeededStrict(pVCpu, pGVCpu, pCtx, NEM_WIN_CPUMCTX_EXTRN_MASK_FOR_IEM, "NMI");
3017	if (rcStrict == VINF_SUCCESS)
3018	{
3019	uint8_t bInterrupt;
3020	int rc = PDMGetInterrupt(pVCpu, &bInterrupt);
3021	if (RT_SUCCESS(rc))
3022	{
3023	rcStrict = IEMInjectTrap(pVCpu, bInterrupt, TRPM_HARDWARE_INT, 0, 0, 0);
3024	Log8(("Injected interrupt %#x on %u (%d)\n", bInterrupt, pVCpu->idCpu, VBOXSTRICTRC_VAL(rcStrict) ));
3025	}
3026	else if (rc == VERR_APIC_INTR_MASKED_BY_TPR)
3027	{
3028	pfInterruptWindows \|= (bInterrupt >> 4 /??*/) << NEM_WIN_INTW_F_PRIO_SHIFT;
3029	Log8(("VERR_APIC_INTR_MASKED_BY_TPR: pfInterruptWindows=%#x\n", pfInterruptWindows));
3030	}
3031	else
3032	Log8(("PDMGetInterrupt failed -> %d\n", rc));
3033	}
3034	return rcStrict;
3035	}
3036	*pfInterruptWindows \|= NEM_WIN_INTW_F_REGULAR;
3037	Log8(("Interrupt window pending on %u\n", pVCpu->idCpu));
3038	}
3039
3040	return VINF_SUCCESS;
3041	}
3042
3043
3044	/**
3045	* Inner NEM runloop for windows.
3046	*
3047	* @returns Strict VBox status code.
3048	* @param pVM The cross context VM structure.
3049	* @param pVCpu The cross context per CPU structure.
3050	* @param pGVM The ring-0 VM structure (NULL in ring-3).
3051	* @param pGVCpu The ring-0 per CPU structure (NULL in ring-3).
3052	*/
3053	NEM_TMPL_STATIC VBOXSTRICTRC nemHCWinRunGC(PVM pVM, PVMCPU pVCpu, PGVM pGVM, PGVMCPU pGVCpu)
3054	{
3055	PCPUMCTX pCtx = CPUMQueryGuestCtxPtr(pVCpu);
3056	LogFlow(("NEM/%u: %04x:%08RX64 efl=%#08RX64 <=\n", pVCpu->idCpu, pCtx->cs.Sel, pCtx->rip, pCtx->rflags));
3057	# ifdef LOG_ENABLED
3058	if (LogIs3Enabled())
3059	nemHCWinLogState(pVM, pVCpu);
3060	# endif
3061
3062	/*
3063	* Try switch to NEM runloop state.
3064	*/
3065	if (VMCPU_CMPXCHG_STATE(pVCpu, VMCPUSTATE_STARTED_EXEC_NEM, VMCPUSTATE_STARTED))
3066	{ /* likely */ }
3067	else
3068	{
3069	VMCPU_CMPXCHG_STATE(pVCpu, VMCPUSTATE_STARTED_EXEC_NEM, VMCPUSTATE_STARTED_EXEC_NEM_CANCELED);
3070	LogFlow(("NEM/%u: returning immediately because canceled\n", pVCpu->idCpu));
3071	return VINF_SUCCESS;
3072	}
3073
3074	/*
3075	* The run loop.
3076	*
3077	* Current approach to state updating to use the sledgehammer and sync
3078	* everything every time. This will be optimized later.
3079	*/
3080	# ifdef NEM_WIN_USE_OUR_OWN_RUN_API
3081	VID_MESSAGE_MAPPING_HEADER volatile pMappingHeader = (VID_MESSAGE_MAPPING_HEADER volatile )pVCpu->nem.s.pvMsgSlotMapping;
3082	uint32_t cMillies = 5000; /** @todo lower this later... */
3083	# endif
3084	const bool fSingleStepping = DBGFIsStepping(pVCpu);
3085	// const uint32_t fCheckVmFFs = !fSingleStepping ? VM_FF_HP_R0_PRE_HM_MASK
3086	// : VM_FF_HP_R0_PRE_HM_STEP_MASK;
3087	// const uint32_t fCheckCpuFFs = !fSingleStepping ? VMCPU_FF_HP_R0_PRE_HM_MASK : VMCPU_FF_HP_R0_PRE_HM_STEP_MASK;
3088	VBOXSTRICTRC rcStrict = VINF_SUCCESS;
3089	for (unsigned iLoop = 0;; iLoop++)
3090	{
3091	# ifndef NEM_WIN_USE_HYPERCALLS_FOR_PAGES
3092	/*
3093	* Hack alert!
3094	*/
3095	uint32_t const cMappedPages = pVM->nem.s.cMappedPages;
3096	if (cMappedPages >= 4000)
3097	{
3098	PGMPhysNemEnumPagesByState(pVM, pVCpu, NEM_WIN_PAGE_STATE_READABLE, nemR3WinWHvUnmapOnePageCallback, NULL);
3099	Log(("nemHCWinRunGC: Unmapped all; cMappedPages=%u -> %u\n", cMappedPages, pVM->nem.s.cMappedPages));
3100	}
3101	# endif
3102
3103	/*
3104	* Pending interrupts or such? Need to check and deal with this prior
3105	* to the state syncing.
3106	*/
3107	pVCpu->nem.s.fDesiredInterruptWindows = 0;
3108	if (VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_INTERRUPT_APIC \| VMCPU_FF_UPDATE_APIC \| VMCPU_FF_INTERRUPT_PIC
3109	\| VMCPU_FF_INTERRUPT_NMI \| VMCPU_FF_INTERRUPT_SMI))
3110	{
3111	# ifdef NEM_WIN_USE_OUR_OWN_RUN_API
3112	/* Make sure the CPU isn't executing. */
3113	if (pVCpu->nem.s.fHandleAndGetFlags == VID_MSHAGN_F_GET_NEXT_MESSAGE)
3114	{
3115	pVCpu->nem.s.fHandleAndGetFlags = 0;
3116	rcStrict = nemHCWinStopCpu(pVM, pVCpu, rcStrict, pMappingHeader, pGVM, pGVCpu);
3117	if (rcStrict == VINF_SUCCESS)
3118	{ /* likely */ }
3119	else
3120	{
3121	LogFlow(("NEM/%u: breaking: nemHCWinStopCpu -> %Rrc\n", pVCpu->idCpu, VBOXSTRICTRC_VAL(rcStrict) ));
3122	STAM_REL_COUNTER_INC(&pVCpu->nem.s.StatBreakOnStatus);
3123	break;
3124	}
3125	}
3126	# endif
3127
3128	/* Try inject interrupt. */
3129	rcStrict = nemHCWinHandleInterruptFF(pVM, pVCpu, pGVCpu, pCtx, &pVCpu->nem.s.fDesiredInterruptWindows);
3130	if (rcStrict == VINF_SUCCESS)
3131	{ /* likely */ }
3132	else
3133	{
3134	LogFlow(("NEM/%u: breaking: nemHCWinHandleInterruptFF -> %Rrc\n", pVCpu->idCpu, VBOXSTRICTRC_VAL(rcStrict) ));
3135	STAM_REL_COUNTER_INC(&pVCpu->nem.s.StatBreakOnStatus);
3136	break;
3137	}
3138	}
3139
3140	/*
3141	* Ensure that hyper-V has the whole state.
3142	* (We always update the interrupt windows settings when active as hyper-V seems
3143	* to forget about it after an exit.)
3144	*/
3145	if ( (pCtx->fExtrn & (CPUMCTX_EXTRN_ALL \| CPUMCTX_EXTRN_NEM_WIN_MASK))
3146	!= (CPUMCTX_EXTRN_ALL \| CPUMCTX_EXTRN_NEM_WIN_MASK)
3147	\|\| pVCpu->nem.s.fDesiredInterruptWindows
3148	\|\| pVCpu->nem.s.fCurrentInterruptWindows != pVCpu->nem.s.fDesiredInterruptWindows)
3149	{
3150	# ifdef NEM_WIN_USE_OUR_OWN_RUN_API
3151	Assert(pVCpu->nem.s.fHandleAndGetFlags != VID_MSHAGN_F_GET_NEXT_MESSAGE /* not running */);
3152	# endif
3153	# ifdef IN_RING0
3154	int rc2 = nemR0WinExportState(pGVM, pGVCpu, pCtx);
3155	# else
3156	int rc2 = nemHCWinCopyStateToHyperV(pVM, pVCpu, pCtx);
3157	RT_NOREF(pGVM, pGVCpu);
3158	# endif
3159	AssertRCReturn(rc2, rc2);
3160	}
3161
3162	/*
3163	* Run a bit.
3164	*/
3165	if ( !VM_FF_IS_PENDING(pVM, VM_FF_EMT_RENDEZVOUS \| VM_FF_TM_VIRTUAL_SYNC)
3166	&& !VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_HM_TO_R3_MASK))
3167	{
3168	# ifdef NEM_WIN_USE_OUR_OWN_RUN_API
3169	if (pVCpu->nem.s.fHandleAndGetFlags)
3170	{ /* Very likely that the CPU does NOT need starting (pending msg, running). */ }
3171	else
3172	{
3173	# ifdef IN_RING0
3174	pVCpu->nem.s.uIoCtlBuf.idCpu = pGVCpu->idCpu;
3175	NTSTATUS rcNt = nemR0NtPerformIoControl(pGVM, pGVM->nem.s.IoCtlStartVirtualProcessor.uFunction,
3176	&pVCpu->nem.s.uIoCtlBuf.idCpu, sizeof(pVCpu->nem.s.uIoCtlBuf.idCpu),
3177	NULL, 0);
3178	LogFlow(("NEM/%u: IoCtlStartVirtualProcessor -> %#x\n", pVCpu->idCpu, rcNt));
3179	AssertLogRelMsgReturn(NT_SUCCESS(rcNt), ("VidStartVirtualProcessor failed for CPU #%u: %#x\n", pGVCpu->idCpu, rcNt),
3180	VERR_NEM_IPE_5);
3181	# else
3182	AssertLogRelMsgReturn(g_pfnVidStartVirtualProcessor(pVM->nem.s.hPartitionDevice, pVCpu->idCpu),
3183	("VidStartVirtualProcessor failed for CPU #%u: %u (%#x, rcNt=%#x)\n",
3184	pVCpu->idCpu, RTNtLastErrorValue(), RTNtLastErrorValue(), RTNtLastStatusValue()),
3185	VERR_NEM_IPE_5);
3186	# endif
3187	pVCpu->nem.s.fHandleAndGetFlags = VID_MSHAGN_F_GET_NEXT_MESSAGE;
3188	}
3189	# endif /* NEM_WIN_USE_OUR_OWN_RUN_API */
3190
3191	if (VMCPU_CMPXCHG_STATE(pVCpu, VMCPUSTATE_STARTED_EXEC_NEM_WAIT, VMCPUSTATE_STARTED_EXEC_NEM))
3192	{
3193	# ifdef NEM_WIN_USE_OUR_OWN_RUN_API
3194	# ifdef IN_RING0
3195	pVCpu->nem.s.uIoCtlBuf.MsgSlotHandleAndGetNext.iCpu = pGVCpu->idCpu;
3196	pVCpu->nem.s.uIoCtlBuf.MsgSlotHandleAndGetNext.fFlags = pVCpu->nem.s.fHandleAndGetFlags;
3197	pVCpu->nem.s.uIoCtlBuf.MsgSlotHandleAndGetNext.cMillies = cMillies;
3198	NTSTATUS rcNt = nemR0NtPerformIoControl(pGVM, pGVM->nem.s.IoCtlMessageSlotHandleAndGetNext.uFunction,
3199	&pVCpu->nem.s.uIoCtlBuf.MsgSlotHandleAndGetNext,
3200	sizeof(pVCpu->nem.s.uIoCtlBuf.MsgSlotHandleAndGetNext),
3201	NULL, 0);
3202	VMCPU_CMPXCHG_STATE(pVCpu, VMCPUSTATE_STARTED_EXEC_NEM, VMCPUSTATE_STARTED_EXEC_NEM_WAIT);
3203	if (rcNt == STATUS_SUCCESS)
3204	# else
3205	BOOL fRet = VidMessageSlotHandleAndGetNext(pVM->nem.s.hPartitionDevice, pVCpu->idCpu,
3206	pVCpu->nem.s.fHandleAndGetFlags, cMillies);
3207	VMCPU_CMPXCHG_STATE(pVCpu, VMCPUSTATE_STARTED_EXEC_NEM, VMCPUSTATE_STARTED_EXEC_NEM_WAIT);
3208	if (fRet)
3209	# endif
3210	# else
3211	WHV_RUN_VP_EXIT_CONTEXT ExitReason;
3212	RT_ZERO(ExitReason);
3213	HRESULT hrc = WHvRunVirtualProcessor(pVM->nem.s.hPartition, pVCpu->idCpu, &ExitReason, sizeof(ExitReason));
3214	VMCPU_CMPXCHG_STATE(pVCpu, VMCPUSTATE_STARTED_EXEC_NEM, VMCPUSTATE_STARTED_EXEC_NEM_WAIT);
3215	if (SUCCEEDED(hrc))
3216	# endif
3217	{
3218	/*
3219	* Deal with the message.
3220	*/
3221	# ifdef NEM_WIN_USE_OUR_OWN_RUN_API
3222	rcStrict = nemHCWinHandleMessage(pVM, pVCpu, pMappingHeader, pCtx, pGVCpu);
3223	pVCpu->nem.s.fHandleAndGetFlags \|= VID_MSHAGN_F_HANDLE_MESSAGE;
3224	# else
3225	rcStrict = nemR3WinHandleExit(pVM, pVCpu, &ExitReason, pCtx);
3226	# endif
3227	if (rcStrict == VINF_SUCCESS)
3228	{ /* hopefully likely */ }
3229	else
3230	{
3231	LogFlow(("NEM/%u: breaking: nemHCWinHandleMessage -> %Rrc\n", pVCpu->idCpu, VBOXSTRICTRC_VAL(rcStrict) ));
3232	STAM_REL_COUNTER_INC(&pVCpu->nem.s.StatBreakOnStatus);
3233	break;
3234	}
3235	}
3236	else
3237	{
3238	# ifdef NEM_WIN_USE_OUR_OWN_RUN_API
3239
3240	/* VID.SYS merges STATUS_ALERTED and STATUS_USER_APC into STATUS_TIMEOUT,
3241	so after NtAlertThread we end up here with a STATUS_TIMEOUT. And yeah,
3242	the error code conversion is into WAIT_XXX, i.e. NT status codes. */
3243	# ifndef IN_RING0
3244	DWORD rcNt = GetLastError();
3245	# endif
3246	LogFlow(("NEM/%u: VidMessageSlotHandleAndGetNext -> %#x\n", pVCpu->idCpu, rcNt));
3247	AssertLogRelMsgReturn( rcNt == STATUS_TIMEOUT
3248	\|\| rcNt == STATUS_ALERTED /* just in case */
3249	\|\| rcNt == STATUS_USER_APC /* ditto */
3250	, ("VidMessageSlotHandleAndGetNext failed for CPU #%u: %#x (%u)\n",
3251	pVCpu->idCpu, rcNt, rcNt),
3252	VERR_NEM_IPE_0);
3253	pVCpu->nem.s.fHandleAndGetFlags = VID_MSHAGN_F_GET_NEXT_MESSAGE;
3254	STAM_REL_COUNTER_INC(&pVCpu->nem.s.StatGetMsgTimeout);
3255	# else
3256	AssertLogRelMsgFailedReturn(("WHvRunVirtualProcessor failed for CPU #%u: %#x (%u)\n",
3257	pVCpu->idCpu, hrc, GetLastError()),
3258	VERR_NEM_IPE_0);
3259
3260	# endif
3261	}
3262
3263	/*
3264	* If no relevant FFs are pending, loop.
3265	*/
3266	if ( !VM_FF_IS_PENDING( pVM, !fSingleStepping ? VM_FF_HP_R0_PRE_HM_MASK : VM_FF_HP_R0_PRE_HM_STEP_MASK)
3267	&& !VMCPU_FF_IS_PENDING(pVCpu, !fSingleStepping ? VMCPU_FF_HP_R0_PRE_HM_MASK : VMCPU_FF_HP_R0_PRE_HM_STEP_MASK) )
3268	continue;
3269
3270	/** @todo Try handle pending flags, not just return to EM loops. Take care
3271	* not to set important RCs here unless we've handled a message. */
3272	LogFlow(("NEM/%u: breaking: pending FF (%#x / %#x)\n",
3273	pVCpu->idCpu, pVM->fGlobalForcedActions, pVCpu->fLocalForcedActions));
3274	STAM_REL_COUNTER_INC(&pVCpu->nem.s.StatBreakOnFFPost);
3275	}
3276	else
3277	{
3278	LogFlow(("NEM/%u: breaking: canceled %d (pre exec)\n", pVCpu->idCpu, VMCPU_GET_STATE(pVCpu) ));
3279	STAM_REL_COUNTER_INC(&pVCpu->nem.s.StatBreakOnCancel);
3280	}
3281	}
3282	else
3283	{
3284	LogFlow(("NEM/%u: breaking: pending FF (pre exec)\n", pVCpu->idCpu));
3285	STAM_REL_COUNTER_INC(&pVCpu->nem.s.StatBreakOnFFPre);
3286	}
3287	break;
3288	} /* the run loop */
3289
3290
3291	/*
3292	* If the CPU is running, make sure to stop it before we try sync back the
3293	* state and return to EM.
3294	*/
3295	# ifdef NEM_WIN_USE_OUR_OWN_RUN_API
3296	if (pVCpu->nem.s.fHandleAndGetFlags == VID_MSHAGN_F_GET_NEXT_MESSAGE)
3297	{
3298	pVCpu->nem.s.fHandleAndGetFlags = 0;
3299	rcStrict = nemHCWinStopCpu(pVM, pVCpu, rcStrict, pMappingHeader, pGVM, pGVCpu);
3300	}
3301	# endif
3302
3303	if (!VMCPU_CMPXCHG_STATE(pVCpu, VMCPUSTATE_STARTED, VMCPUSTATE_STARTED_EXEC_NEM))
3304	VMCPU_CMPXCHG_STATE(pVCpu, VMCPUSTATE_STARTED, VMCPUSTATE_STARTED_EXEC_NEM_CANCELED);
3305
3306	if (pCtx->fExtrn & (CPUMCTX_EXTRN_ALL \| (CPUMCTX_EXTRN_NEM_WIN_MASK & ~CPUMCTX_EXTRN_NEM_WIN_EVENT_INJECT)))
3307	{
3308	# ifdef IN_RING0
3309	int rc2 = nemR0WinImportState(pGVM, pGVCpu, pCtx, CPUMCTX_EXTRN_ALL \| CPUMCTX_EXTRN_NEM_WIN_MASK);
3310	if (RT_SUCCESS(rc2))
3311	pCtx->fExtrn = 0;
3312	else if (rc2 == VERR_NEM_CHANGE_PGM_MODE \|\| rc2 == VERR_NEM_FLUSH_TLB \|\| rc2 == VERR_NEM_UPDATE_APIC_BASE)
3313	{
3314	pCtx->fExtrn = 0;
3315	if (rcStrict == VINF_SUCCESS \|\| rcStrict == -rc2)
3316	rcStrict = -rc2;
3317	else
3318	{
3319	pVCpu->nem.s.rcPending = -rc2;
3320	LogFlow(("NEM/%u: rcPending=%Rrc (rcStrict=%Rrc)\n", pVCpu->idCpu, rc2, VBOXSTRICTRC_VAL(rcStrict) ));
3321	}
3322	}
3323	# else
3324	int rc2 = nemHCWinCopyStateFromHyperV(pVM, pVCpu, pCtx, CPUMCTX_EXTRN_ALL \| CPUMCTX_EXTRN_NEM_WIN_MASK);
3325	if (RT_SUCCESS(rc2))
3326	pCtx->fExtrn = 0;
3327	# endif
3328	else if (RT_SUCCESS(rcStrict))
3329	rcStrict = rc2;
3330	}
3331	else
3332	pCtx->fExtrn = 0;
3333
3334	LogFlow(("NEM/%u: %04x:%08RX64 efl=%#08RX64 => %Rrc\n",
3335	pVCpu->idCpu, pCtx->cs.Sel, pCtx->rip, pCtx->rflags, VBOXSTRICTRC_VAL(rcStrict) ));
3336	return rcStrict;
3337	}
3338
3339	#endif /* defined(NEM_WIN_USE_OUR_OWN_RUN_API) \|\| defined(IN_RING3) */
3340
3341	/**
3342	* @callback_method_impl{FNPGMPHYSNEMCHECKPAGE}
3343	*/
3344	NEM_TMPL_STATIC DECLCALLBACK(int) nemHCWinUnsetForA20CheckerCallback(PVM pVM, PVMCPU pVCpu, RTGCPHYS GCPhys,
3345	PPGMPHYSNEMPAGEINFO pInfo, void *pvUser)
3346	{
3347	/* We'll just unmap the memory. */
3348	if (pInfo->u2NemState > NEM_WIN_PAGE_STATE_UNMAPPED)
3349	{
3350	#ifdef NEM_WIN_USE_HYPERCALLS_FOR_PAGES
3351	int rc = nemHCWinHypercallUnmapPage(pVM, pVCpu, GCPhys);
3352	AssertRC(rc);
3353	if (RT_SUCCESS(rc))
3354	#else
3355	HRESULT hrc = WHvUnmapGpaRange(pVM->nem.s.hPartition, GCPhys, X86_PAGE_SIZE);
3356	if (SUCCEEDED(hrc))
3357	#endif
3358	{
3359	uint32_t cMappedPages = ASMAtomicDecU32(&pVM->nem.s.cMappedPages); NOREF(cMappedPages);
3360	Log5(("NEM GPA unmapped/A20: %RGp (was %s, cMappedPages=%u)\n", GCPhys, g_apszPageStates[pInfo->u2NemState], cMappedPages));
3361	pInfo->u2NemState = NEM_WIN_PAGE_STATE_UNMAPPED;
3362	}
3363	else
3364	{
3365	#ifdef NEM_WIN_USE_HYPERCALLS_FOR_PAGES
3366	LogRel(("nemHCWinUnsetForA20CheckerCallback/unmap: GCPhys=%RGp rc=%Rrc\n", GCPhys, rc));
3367	return rc;
3368	#else
3369	LogRel(("nemHCWinUnsetForA20CheckerCallback/unmap: GCPhys=%RGp hrc=%Rhrc (%#x) Last=%#x/%u\n",
3370	GCPhys, hrc, hrc, RTNtLastStatusValue(), RTNtLastErrorValue()));
3371	return VERR_NEM_IPE_2;
3372	#endif
3373	}
3374	}
3375	RT_NOREF(pVCpu, pvUser);
3376	return VINF_SUCCESS;
3377	}
3378
3379
3380	/**
3381	* Unmaps a page from Hyper-V for the purpose of emulating A20 gate behavior.
3382	*
3383	* @returns The PGMPhysNemQueryPageInfo result.
3384	* @param pVM The cross context VM structure.
3385	* @param pVCpu The cross context virtual CPU structure.
3386	* @param GCPhys The page to unmap.
3387	*/
3388	NEM_TMPL_STATIC int nemHCWinUnmapPageForA20Gate(PVM pVM, PVMCPU pVCpu, RTGCPHYS GCPhys)
3389	{
3390	PGMPHYSNEMPAGEINFO Info;
3391	return PGMPhysNemPageInfoChecker(pVM, pVCpu, GCPhys, false /fMakeWritable/, &Info,
3392	nemHCWinUnsetForA20CheckerCallback, NULL);
3393	}
3394
3395
3396	void nemHCNativeNotifyHandlerPhysicalRegister(PVM pVM, PGMPHYSHANDLERKIND enmKind, RTGCPHYS GCPhys, RTGCPHYS cb)
3397	{
3398	Log5(("nemHCNativeNotifyHandlerPhysicalRegister: %RGp LB %RGp enmKind=%d\n", GCPhys, cb, enmKind));
3399	NOREF(pVM); NOREF(enmKind); NOREF(GCPhys); NOREF(cb);
3400	}
3401
3402
3403	void nemHCNativeNotifyHandlerPhysicalDeregister(PVM pVM, PGMPHYSHANDLERKIND enmKind, RTGCPHYS GCPhys, RTGCPHYS cb,
3404	int fRestoreAsRAM, bool fRestoreAsRAM2)
3405	{
3406	Log5(("nemHCNativeNotifyHandlerPhysicalDeregister: %RGp LB %RGp enmKind=%d fRestoreAsRAM=%d fRestoreAsRAM2=%d\n",
3407	GCPhys, cb, enmKind, fRestoreAsRAM, fRestoreAsRAM2));
3408	NOREF(pVM); NOREF(enmKind); NOREF(GCPhys); NOREF(cb); NOREF(fRestoreAsRAM); NOREF(fRestoreAsRAM2);
3409	}
3410
3411
3412	void nemHCNativeNotifyHandlerPhysicalModify(PVM pVM, PGMPHYSHANDLERKIND enmKind, RTGCPHYS GCPhysOld,
3413	RTGCPHYS GCPhysNew, RTGCPHYS cb, bool fRestoreAsRAM)
3414	{
3415	Log5(("nemHCNativeNotifyHandlerPhysicalModify: %RGp LB %RGp -> %RGp enmKind=%d fRestoreAsRAM=%d\n",
3416	GCPhysOld, cb, GCPhysNew, enmKind, fRestoreAsRAM));
3417	NOREF(pVM); NOREF(enmKind); NOREF(GCPhysOld); NOREF(GCPhysNew); NOREF(cb); NOREF(fRestoreAsRAM);
3418	}
3419
3420
3421	/**
3422	* Worker that maps pages into Hyper-V.
3423	*
3424	* This is used by the PGM physical page notifications as well as the memory
3425	* access VMEXIT handlers.
3426	*
3427	* @returns VBox status code.
3428	* @param pVM The cross context VM structure.
3429	* @param pVCpu The cross context virtual CPU structure of the
3430	* calling EMT.
3431	* @param GCPhysSrc The source page address.
3432	* @param GCPhysDst The hyper-V destination page. This may differ from
3433	* GCPhysSrc when A20 is disabled.
3434	* @param fPageProt NEM_PAGE_PROT_XXX.
3435	* @param pu2State Our page state (input/output).
3436	* @param fBackingChanged Set if the page backing is being changed.
3437	* @thread EMT(pVCpu)
3438	*/
3439	NEM_TMPL_STATIC int nemHCNativeSetPhysPage(PVM pVM, PVMCPU pVCpu, RTGCPHYS GCPhysSrc, RTGCPHYS GCPhysDst,
3440	uint32_t fPageProt, uint8_t *pu2State, bool fBackingChanged)
3441	{
3442	#ifdef NEM_WIN_USE_HYPERCALLS_FOR_PAGES
3443	/*
3444	* When using the hypercalls instead of the ring-3 APIs, we don't need to
3445	* unmap memory before modifying it. We still want to track the state though,
3446	* since unmap will fail when called an unmapped page and we don't want to redo
3447	* upgrades/downgrades.
3448	*/
3449	uint8_t const u2OldState = *pu2State;
3450	int rc;
3451	if (fPageProt == NEM_PAGE_PROT_NONE)
3452	{
3453	if (u2OldState > NEM_WIN_PAGE_STATE_UNMAPPED)
3454	{
3455	rc = nemHCWinHypercallUnmapPage(pVM, pVCpu, GCPhysDst);
3456	if (RT_SUCCESS(rc))
3457	{
3458	*pu2State = NEM_WIN_PAGE_STATE_UNMAPPED;
3459	uint32_t cMappedPages = ASMAtomicDecU32(&pVM->nem.s.cMappedPages); NOREF(cMappedPages);
3460	Log5(("NEM GPA unmapped/set: %RGp (was %s, cMappedPages=%u)\n", GCPhysDst, g_apszPageStates[u2OldState], cMappedPages));
3461	}
3462	else
3463	AssertLogRelMsgFailed(("nemHCNativeSetPhysPage/unmap: GCPhysDst=%RGp rc=%Rrc\n", GCPhysDst, rc));
3464	}
3465	else
3466	rc = VINF_SUCCESS;
3467	}
3468	else if (fPageProt & NEM_PAGE_PROT_WRITE)
3469	{
3470	if (u2OldState != NEM_WIN_PAGE_STATE_WRITABLE \|\| fBackingChanged)
3471	{
3472	rc = nemHCWinHypercallMapPage(pVM, pVCpu, GCPhysSrc, GCPhysDst,
3473	HV_MAP_GPA_READABLE \| HV_MAP_GPA_WRITABLE
3474	\| HV_MAP_GPA_EXECUTABLE \| HV_MAP_GPA_EXECUTABLE_AGAIN);
3475	if (RT_SUCCESS(rc))
3476	{
3477	*pu2State = NEM_WIN_PAGE_STATE_WRITABLE;
3478	uint32_t cMappedPages = u2OldState <= NEM_WIN_PAGE_STATE_UNMAPPED
3479	? ASMAtomicIncU32(&pVM->nem.s.cMappedPages) : pVM->nem.s.cMappedPages;
3480	Log5(("NEM GPA writable/set: %RGp (was %s, cMappedPages=%u)\n", GCPhysDst, g_apszPageStates[u2OldState], cMappedPages));
3481	NOREF(cMappedPages);
3482	}
3483	else
3484	AssertLogRelMsgFailed(("nemHCNativeSetPhysPage/writable: GCPhysDst=%RGp rc=%Rrc\n", GCPhysDst, rc));
3485	}
3486	else
3487	rc = VINF_SUCCESS;
3488	}
3489	else
3490	{
3491	if (u2OldState != NEM_WIN_PAGE_STATE_READABLE \|\| fBackingChanged)
3492	{
3493	rc = nemHCWinHypercallMapPage(pVM, pVCpu, GCPhysSrc, GCPhysDst,
3494	HV_MAP_GPA_READABLE \| HV_MAP_GPA_EXECUTABLE \| HV_MAP_GPA_EXECUTABLE_AGAIN);
3495	if (RT_SUCCESS(rc))
3496	{
3497	*pu2State = NEM_WIN_PAGE_STATE_READABLE;
3498	uint32_t cMappedPages = u2OldState <= NEM_WIN_PAGE_STATE_UNMAPPED
3499	? ASMAtomicIncU32(&pVM->nem.s.cMappedPages) : pVM->nem.s.cMappedPages;
3500	Log5(("NEM GPA read+exec/set: %RGp (was %s, cMappedPages=%u)\n", GCPhysDst, g_apszPageStates[u2OldState], cMappedPages));
3501	NOREF(cMappedPages);
3502	}
3503	else
3504	AssertLogRelMsgFailed(("nemHCNativeSetPhysPage/writable: GCPhysDst=%RGp rc=%Rrc\n", GCPhysDst, rc));
3505	}
3506	else
3507	rc = VINF_SUCCESS;
3508	}
3509
3510	return VINF_SUCCESS;
3511
3512	#else
3513	/*
3514	* Looks like we need to unmap a page before we can change the backing
3515	* or even modify the protection. This is going to be REALLY efficient.
3516	* PGM lends us two bits to keep track of the state here.
3517	*/
3518	uint8_t const u2OldState = *pu2State;
3519	uint8_t const u2NewState = fPageProt & NEM_PAGE_PROT_WRITE ? NEM_WIN_PAGE_STATE_WRITABLE
3520	: fPageProt & NEM_PAGE_PROT_READ ? NEM_WIN_PAGE_STATE_READABLE : NEM_WIN_PAGE_STATE_UNMAPPED;
3521	if ( fBackingChanged
3522	\|\| u2NewState != u2OldState)
3523	{
3524	if (u2OldState > NEM_WIN_PAGE_STATE_UNMAPPED)
3525	{
3526	# ifdef NEM_WIN_USE_HYPERCALLS_FOR_PAGES
3527	int rc = nemHCWinHypercallUnmapPage(pVM, pVCpu, GCPhysDst);
3528	AssertRC(rc);
3529	if (RT_SUCCESS(rc))
3530	{
3531	*pu2State = NEM_WIN_PAGE_STATE_UNMAPPED;
3532	uint32_t cMappedPages = ASMAtomicDecU32(&pVM->nem.s.cMappedPages); NOREF(cMappedPages);
3533	if (u2NewState == NEM_WIN_PAGE_STATE_UNMAPPED)
3534	{
3535	Log5(("NEM GPA unmapped/set: %RGp (was %s, cMappedPages=%u)\n",
3536	GCPhysDst, g_apszPageStates[u2OldState], cMappedPages));
3537	return VINF_SUCCESS;
3538	}
3539	}
3540	else
3541	{
3542	LogRel(("nemHCNativeSetPhysPage/unmap: GCPhysDst=%RGp rc=%Rrc\n", GCPhysDst, rc));
3543	return rc;
3544	}
3545	# else
3546	HRESULT hrc = WHvUnmapGpaRange(pVM->nem.s.hPartition, GCPhysDst, X86_PAGE_SIZE);
3547	if (SUCCEEDED(hrc))
3548	{
3549	*pu2State = NEM_WIN_PAGE_STATE_UNMAPPED;
3550	uint32_t cMappedPages = ASMAtomicDecU32(&pVM->nem.s.cMappedPages); NOREF(cMappedPages);
3551	if (u2NewState == NEM_WIN_PAGE_STATE_UNMAPPED)
3552	{
3553	Log5(("NEM GPA unmapped/set: %RGp (was %s, cMappedPages=%u)\n",
3554	GCPhysDst, g_apszPageStates[u2OldState], cMappedPages));
3555	return VINF_SUCCESS;
3556	}
3557	}
3558	else
3559	{
3560	LogRel(("nemHCNativeSetPhysPage/unmap: GCPhysDst=%RGp hrc=%Rhrc (%#x) Last=%#x/%u\n",
3561	GCPhysDst, hrc, hrc, RTNtLastStatusValue(), RTNtLastErrorValue()));
3562	return VERR_NEM_INIT_FAILED;
3563	}
3564	# endif
3565	}
3566	}
3567
3568	/*
3569	* Writeable mapping?
3570	*/
3571	if (fPageProt & NEM_PAGE_PROT_WRITE)
3572	{
3573	# ifdef NEM_WIN_USE_HYPERCALLS_FOR_PAGES
3574	int rc = nemHCWinHypercallMapPage(pVM, pVCpu, GCPhysSrc, GCPhysDst,
3575	HV_MAP_GPA_READABLE \| HV_MAP_GPA_WRITABLE
3576	\| HV_MAP_GPA_EXECUTABLE \| HV_MAP_GPA_EXECUTABLE_AGAIN);
3577	AssertRC(rc);
3578	if (RT_SUCCESS(rc))
3579	{
3580	*pu2State = NEM_WIN_PAGE_STATE_WRITABLE;
3581	uint32_t cMappedPages = ASMAtomicIncU32(&pVM->nem.s.cMappedPages); NOREF(cMappedPages);
3582	Log5(("NEM GPA mapped/set: %RGp %s (was %s, cMappedPages=%u)\n",
3583	GCPhysDst, g_apszPageStates[u2NewState], g_apszPageStates[u2OldState], cMappedPages));
3584	return VINF_SUCCESS;
3585	}
3586	LogRel(("nemHCNativeSetPhysPage/writable: GCPhysDst=%RGp rc=%Rrc\n", GCPhysDst, rc));
3587	return rc;
3588	# else
3589	void *pvPage;
3590	int rc = nemR3NativeGCPhys2R3PtrWriteable(pVM, GCPhysSrc, &pvPage);
3591	if (RT_SUCCESS(rc))
3592	{
3593	HRESULT hrc = WHvMapGpaRange(pVM->nem.s.hPartition, pvPage, GCPhysDst, X86_PAGE_SIZE,
3594	WHvMapGpaRangeFlagRead \| WHvMapGpaRangeFlagExecute \| WHvMapGpaRangeFlagWrite);
3595	if (SUCCEEDED(hrc))
3596	{
3597	*pu2State = NEM_WIN_PAGE_STATE_WRITABLE;
3598	uint32_t cMappedPages = ASMAtomicIncU32(&pVM->nem.s.cMappedPages); NOREF(cMappedPages);
3599	Log5(("NEM GPA mapped/set: %RGp %s (was %s, cMappedPages=%u)\n",
3600	GCPhysDst, g_apszPageStates[u2NewState], g_apszPageStates[u2OldState], cMappedPages));
3601	return VINF_SUCCESS;
3602	}
3603	LogRel(("nemHCNativeSetPhysPage/writable: GCPhysDst=%RGp hrc=%Rhrc (%#x) Last=%#x/%u\n",
3604	GCPhysDst, hrc, hrc, RTNtLastStatusValue(), RTNtLastErrorValue()));
3605	return VERR_NEM_INIT_FAILED;
3606	}
3607	LogRel(("nemHCNativeSetPhysPage/writable: GCPhysSrc=%RGp rc=%Rrc\n", GCPhysSrc, rc));
3608	return rc;
3609	# endif
3610	}
3611
3612	if (fPageProt & NEM_PAGE_PROT_READ)
3613	{
3614	# ifdef NEM_WIN_USE_HYPERCALLS_FOR_PAGES
3615	int rc = nemHCWinHypercallMapPage(pVM, pVCpu, GCPhysSrc, GCPhysDst,
3616	HV_MAP_GPA_READABLE \| HV_MAP_GPA_EXECUTABLE \| HV_MAP_GPA_EXECUTABLE_AGAIN);
3617	AssertRC(rc);
3618	if (RT_SUCCESS(rc))
3619	{
3620	*pu2State = NEM_WIN_PAGE_STATE_READABLE;
3621	uint32_t cMappedPages = ASMAtomicIncU32(&pVM->nem.s.cMappedPages); NOREF(cMappedPages);
3622	Log5(("NEM GPA mapped/set: %RGp %s (was %s, cMappedPages=%u)\n",
3623	GCPhysDst, g_apszPageStates[u2NewState], g_apszPageStates[u2OldState], cMappedPages));
3624	return VINF_SUCCESS;
3625	}
3626	LogRel(("nemHCNativeSetPhysPage/readonly: GCPhysDst=%RGp rc=%Rrc\n", GCPhysDst, rc));
3627	return rc;
3628	# else
3629	const void *pvPage;
3630	int rc = nemR3NativeGCPhys2R3PtrReadOnly(pVM, GCPhysSrc, &pvPage);
3631	if (RT_SUCCESS(rc))
3632	{
3633	HRESULT hrc = WHvMapGpaRange(pVM->nem.s.hPartition, (void *)pvPage, GCPhysDst, X86_PAGE_SIZE,
3634	WHvMapGpaRangeFlagRead \| WHvMapGpaRangeFlagExecute);
3635	if (SUCCEEDED(hrc))
3636	{
3637	*pu2State = NEM_WIN_PAGE_STATE_READABLE;
3638	uint32_t cMappedPages = ASMAtomicIncU32(&pVM->nem.s.cMappedPages); NOREF(cMappedPages);
3639	Log5(("NEM GPA mapped/set: %RGp %s (was %s, cMappedPages=%u)\n",
3640	GCPhysDst, g_apszPageStates[u2NewState], g_apszPageStates[u2OldState], cMappedPages));
3641	return VINF_SUCCESS;
3642	}
3643	LogRel(("nemHCNativeSetPhysPage/readonly: GCPhysDst=%RGp hrc=%Rhrc (%#x) Last=%#x/%u\n",
3644	GCPhysDst, hrc, hrc, RTNtLastStatusValue(), RTNtLastErrorValue()));
3645	return VERR_NEM_INIT_FAILED;
3646	}
3647	LogRel(("nemHCNativeSetPhysPage/readonly: GCPhysSrc=%RGp rc=%Rrc\n", GCPhysSrc, rc));
3648	return rc;
3649	# endif
3650	}
3651
3652	/* We already unmapped it above. */
3653	*pu2State = NEM_WIN_PAGE_STATE_UNMAPPED;
3654	return VINF_SUCCESS;
3655	#endif /* !NEM_WIN_USE_HYPERCALLS_FOR_PAGES */
3656	}
3657
3658
3659	NEM_TMPL_STATIC int nemHCJustUnmapPageFromHyperV(PVM pVM, RTGCPHYS GCPhysDst, uint8_t *pu2State)
3660	{
3661	if (*pu2State <= NEM_WIN_PAGE_STATE_UNMAPPED)
3662	{
3663	Log5(("nemHCJustUnmapPageFromHyperV: %RGp == unmapped\n", GCPhysDst));
3664	*pu2State = NEM_WIN_PAGE_STATE_UNMAPPED;
3665	return VINF_SUCCESS;
3666	}
3667
3668	#if defined(NEM_WIN_USE_HYPERCALLS_FOR_PAGES) \|\| defined(IN_RING0)
3669	PVMCPU pVCpu = VMMGetCpu(pVM);
3670	int rc = nemHCWinHypercallUnmapPage(pVM, pVCpu, GCPhysDst);
3671	AssertRC(rc);
3672	if (RT_SUCCESS(rc))
3673	{
3674	uint32_t cMappedPages = ASMAtomicDecU32(&pVM->nem.s.cMappedPages); NOREF(cMappedPages);
3675	Log5(("NEM GPA unmapped/just: %RGp (was %s, cMappedPages=%u)\n", GCPhysDst, g_apszPageStates[*pu2State], cMappedPages));
3676	*pu2State = NEM_WIN_PAGE_STATE_UNMAPPED;
3677	return VINF_SUCCESS;
3678	}
3679	LogRel(("nemHCJustUnmapPageFromHyperV/unmap: GCPhysDst=%RGp rc=%Rrc\n", GCPhysDst, rc));
3680	return rc;
3681	#else
3682	HRESULT hrc = WHvUnmapGpaRange(pVM->nem.s.hPartition, GCPhysDst & ~(RTGCPHYS)X86_PAGE_OFFSET_MASK, X86_PAGE_SIZE);
3683	if (SUCCEEDED(hrc))
3684	{
3685	uint32_t cMappedPages = ASMAtomicDecU32(&pVM->nem.s.cMappedPages); NOREF(cMappedPages);
3686	*pu2State = NEM_WIN_PAGE_STATE_UNMAPPED;
3687	Log5(("nemHCJustUnmapPageFromHyperV: %RGp => unmapped (total %u)\n", GCPhysDst, cMappedPages));
3688	return VINF_SUCCESS;
3689	}
3690	LogRel(("nemHCJustUnmapPageFromHyperV(%RGp): failed! hrc=%Rhrc (%#x) Last=%#x/%u\n",
3691	GCPhysDst, hrc, hrc, RTNtLastStatusValue(), RTNtLastErrorValue()));
3692	return VERR_NEM_IPE_6;
3693	#endif
3694	}
3695
3696
3697	int nemHCNativeNotifyPhysPageAllocated(PVM pVM, RTGCPHYS GCPhys, RTHCPHYS HCPhys, uint32_t fPageProt,
3698	PGMPAGETYPE enmType, uint8_t *pu2State)
3699	{
3700	Log5(("nemHCNativeNotifyPhysPageAllocated: %RGp HCPhys=%RHp fPageProt=%#x enmType=%d *pu2State=%d\n",
3701	GCPhys, HCPhys, fPageProt, enmType, *pu2State));
3702	RT_NOREF_PV(HCPhys); RT_NOREF_PV(enmType);
3703
3704	int rc;
3705	#if defined(NEM_WIN_USE_HYPERCALLS_FOR_PAGES) \|\| defined(IN_RING0)
3706	PVMCPU pVCpu = VMMGetCpu(pVM);
3707	if ( pVM->nem.s.fA20Enabled
3708	\|\| !NEM_WIN_IS_RELEVANT_TO_A20(GCPhys))
3709	rc = nemHCNativeSetPhysPage(pVM, pVCpu, GCPhys, GCPhys, fPageProt, pu2State, true /fBackingChanged/);
3710	else
3711	{
3712	/* To keep effort at a minimum, we unmap the HMA page alias and resync it lazily when needed. */
3713	rc = nemHCWinUnmapPageForA20Gate(pVM, pVCpu, GCPhys \| RT_BIT_32(20));
3714	if (!NEM_WIN_IS_SUBJECT_TO_A20(GCPhys) && RT_SUCCESS(rc))
3715	rc = nemHCNativeSetPhysPage(pVM, pVCpu, GCPhys, GCPhys, fPageProt, pu2State, true /fBackingChanged/);
3716
3717	}
3718	#else
3719	RT_NOREF_PV(fPageProt);
3720	if ( pVM->nem.s.fA20Enabled
3721	\|\| !NEM_WIN_IS_RELEVANT_TO_A20(GCPhys))
3722	rc = nemR3JustUnmapPageFromHyperV(pVM, GCPhys, pu2State);
3723	else if (!NEM_WIN_IS_SUBJECT_TO_A20(GCPhys))
3724	rc = nemR3JustUnmapPageFromHyperV(pVM, GCPhys, pu2State);
3725	else
3726	rc = VINF_SUCCESS; /* ignore since we've got the alias page at this address. */
3727	#endif
3728	return rc;
3729	}
3730
3731
3732	void nemHCNativeNotifyPhysPageProtChanged(PVM pVM, RTGCPHYS GCPhys, RTHCPHYS HCPhys, uint32_t fPageProt,
3733	PGMPAGETYPE enmType, uint8_t *pu2State)
3734	{
3735	Log5(("nemHCNativeNotifyPhysPageProtChanged: %RGp HCPhys=%RHp fPageProt=%#x enmType=%d *pu2State=%d\n",
3736	GCPhys, HCPhys, fPageProt, enmType, *pu2State));
3737	RT_NOREF_PV(HCPhys); RT_NOREF_PV(enmType);
3738
3739	#if defined(NEM_WIN_USE_HYPERCALLS_FOR_PAGES) \|\| defined(IN_RING0)
3740	PVMCPU pVCpu = VMMGetCpu(pVM);
3741	if ( pVM->nem.s.fA20Enabled
3742	\|\| !NEM_WIN_IS_RELEVANT_TO_A20(GCPhys))
3743	nemHCNativeSetPhysPage(pVM, pVCpu, GCPhys, GCPhys, fPageProt, pu2State, false /fBackingChanged/);
3744	else
3745	{
3746	/* To keep effort at a minimum, we unmap the HMA page alias and resync it lazily when needed. */
3747	nemHCWinUnmapPageForA20Gate(pVM, pVCpu, GCPhys \| RT_BIT_32(20));
3748	if (!NEM_WIN_IS_SUBJECT_TO_A20(GCPhys))
3749	nemHCNativeSetPhysPage(pVM, pVCpu, GCPhys, GCPhys, fPageProt, pu2State, false /fBackingChanged/);
3750	}
3751	#else
3752	RT_NOREF_PV(fPageProt);
3753	if ( pVM->nem.s.fA20Enabled
3754	\|\| !NEM_WIN_IS_RELEVANT_TO_A20(GCPhys))
3755	nemR3JustUnmapPageFromHyperV(pVM, GCPhys, pu2State);
3756	else if (!NEM_WIN_IS_SUBJECT_TO_A20(GCPhys))
3757	nemR3JustUnmapPageFromHyperV(pVM, GCPhys, pu2State);
3758	/* else: ignore since we've got the alias page at this address. */
3759	#endif
3760	}
3761
3762
3763	void nemHCNativeNotifyPhysPageChanged(PVM pVM, RTGCPHYS GCPhys, RTHCPHYS HCPhysPrev, RTHCPHYS HCPhysNew,
3764	uint32_t fPageProt, PGMPAGETYPE enmType, uint8_t *pu2State)
3765	{
3766	Log5(("nemHCNativeNotifyPhysPageChanged: %RGp HCPhys=%RHp->%RHp fPageProt=%#x enmType=%d *pu2State=%d\n",
3767	GCPhys, HCPhysPrev, HCPhysNew, fPageProt, enmType, *pu2State));
3768	RT_NOREF_PV(HCPhysPrev); RT_NOREF_PV(HCPhysNew); RT_NOREF_PV(enmType);
3769
3770	#if defined(NEM_WIN_USE_HYPERCALLS_FOR_PAGES) \|\| defined(IN_RING0)
3771	PVMCPU pVCpu = VMMGetCpu(pVM);
3772	if ( pVM->nem.s.fA20Enabled
3773	\|\| !NEM_WIN_IS_RELEVANT_TO_A20(GCPhys))
3774	nemHCNativeSetPhysPage(pVM, pVCpu, GCPhys, GCPhys, fPageProt, pu2State, true /fBackingChanged/);
3775	else
3776	{
3777	/* To keep effort at a minimum, we unmap the HMA page alias and resync it lazily when needed. */
3778	nemHCWinUnmapPageForA20Gate(pVM, pVCpu, GCPhys \| RT_BIT_32(20));
3779	if (!NEM_WIN_IS_SUBJECT_TO_A20(GCPhys))
3780	nemHCNativeSetPhysPage(pVM, pVCpu, GCPhys, GCPhys, fPageProt, pu2State, true /fBackingChanged/);
3781	}
3782	#else
3783	RT_NOREF_PV(fPageProt);
3784	if ( pVM->nem.s.fA20Enabled
3785	\|\| !NEM_WIN_IS_RELEVANT_TO_A20(GCPhys))
3786	nemR3JustUnmapPageFromHyperV(pVM, GCPhys, pu2State);
3787	else if (!NEM_WIN_IS_SUBJECT_TO_A20(GCPhys))
3788	nemR3JustUnmapPageFromHyperV(pVM, GCPhys, pu2State);
3789	/* else: ignore since we've got the alias page at this address. */
3790	#endif
3791	}
3792

Note: See TracBrowser for help on using the repository browser.

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

Download in other formats: