IEMAllCImplSvmInstr.cpp.h@ 71416

Last change on this file since 71416 was 71307, checked in by vboxsync, 7 years ago
VMM/IEM: Nested Hw.virt: Use different IPE for weird failure.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 61.0 KB

Line
1	/* $Id: IEMAllCImplSvmInstr.cpp.h 71307 2018-03-13 08:19:42Z vboxsync $ */
2	/** @file
3	* IEM - AMD-V (Secure Virtual Machine) instruction implementation.
4	*/
5
6	/*
7	* Copyright (C) 2011-2017 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	* Converts an IEM exception event type to an SVM event type.
21	*
22	* @returns The SVM event type.
23	* @retval UINT8_MAX if the specified type of event isn't among the set
24	* of recognized IEM event types.
25	*
26	* @param uVector The vector of the event.
27	* @param fIemXcptFlags The IEM exception / interrupt flags.
28	*/
29	IEM_STATIC uint8_t iemGetSvmEventType(uint32_t uVector, uint32_t fIemXcptFlags)
30	{
31	if (fIemXcptFlags & IEM_XCPT_FLAGS_T_CPU_XCPT)
32	{
33	if (uVector != X86_XCPT_NMI)
34	return SVM_EVENT_EXCEPTION;
35	return SVM_EVENT_NMI;
36	}
37
38	/* See AMD spec. Table 15-1. "Guest Exception or Interrupt Types". */
39	if (fIemXcptFlags & (IEM_XCPT_FLAGS_BP_INSTR \| IEM_XCPT_FLAGS_ICEBP_INSTR \| IEM_XCPT_FLAGS_OF_INSTR))
40	return SVM_EVENT_EXCEPTION;
41
42	if (fIemXcptFlags & IEM_XCPT_FLAGS_T_EXT_INT)
43	return SVM_EVENT_EXTERNAL_IRQ;
44
45	if (fIemXcptFlags & IEM_XCPT_FLAGS_T_SOFT_INT)
46	return SVM_EVENT_SOFTWARE_INT;
47
48	AssertMsgFailed(("iemGetSvmEventType: Invalid IEM xcpt/int. type %#x, uVector=%#x\n", fIemXcptFlags, uVector));
49	return UINT8_MAX;
50	}
51
52
53	/**
54	* Performs an SVM world-switch (VMRUN, \#VMEXIT) updating PGM and IEM internals.
55	*
56	* @returns Strict VBox status code.
57	* @param pVCpu The cross context virtual CPU structure.
58	* @param pCtx The guest-CPU context.
59	*/
60	DECLINLINE(VBOXSTRICTRC) iemSvmWorldSwitch(PVMCPU pVCpu, PCPUMCTX pCtx)
61	{
62	/*
63	* Inform PGM about paging mode changes.
64	* We include X86_CR0_PE because PGM doesn't handle paged-real mode yet,
65	* see comment in iemMemPageTranslateAndCheckAccess().
66	*/
67	int rc = PGMChangeMode(pVCpu, pCtx->cr0 \| X86_CR0_PE, pCtx->cr4, pCtx->msrEFER);
68	#ifdef IN_RING3
69	Assert(rc != VINF_PGM_CHANGE_MODE);
70	#endif
71	AssertRCReturn(rc, rc);
72
73	/* Inform CPUM (recompiler), can later be removed. */
74	CPUMSetChangedFlags(pVCpu, CPUM_CHANGED_ALL);
75
76	/*
77	* Flush the TLB with new CR3. This is required in case the PGM mode change
78	* above doesn't actually change anything.
79	*/
80	if (rc == VINF_SUCCESS)
81	{
82	rc = PGMFlushTLB(pVCpu, pCtx->cr3, true);
83	AssertRCReturn(rc, rc);
84	}
85
86	/* Re-initialize IEM cache/state after the drastic mode switch. */
87	iemReInitExec(pVCpu);
88	return rc;
89	}
90
91
92	/**
93	* SVM \#VMEXIT handler.
94	*
95	* @returns Strict VBox status code.
96	* @retval VINF_SVM_VMEXIT when the \#VMEXIT is successful.
97	* @retval VERR_SVM_VMEXIT_FAILED when the \#VMEXIT failed restoring the guest's
98	* "host state" and a shutdown is required.
99	*
100	* @param pVCpu The cross context virtual CPU structure.
101	* @param pCtx The guest-CPU context.
102	* @param uExitCode The exit code.
103	* @param uExitInfo1 The exit info. 1 field.
104	* @param uExitInfo2 The exit info. 2 field.
105	*/
106	IEM_STATIC VBOXSTRICTRC iemSvmVmexit(PVMCPU pVCpu, PCPUMCTX pCtx, uint64_t uExitCode, uint64_t uExitInfo1, uint64_t uExitInfo2)
107	{
108	VBOXSTRICTRC rcStrict;
109	if ( CPUMIsGuestInSvmNestedHwVirtMode(pCtx)
110	\|\| uExitCode == SVM_EXIT_INVALID)
111	{
112	LogFlow(("iemSvmVmexit: CS:RIP=%04x:%08RX64 uExitCode=%#RX64 uExitInfo1=%#RX64 uExitInfo2=%#RX64\n", pCtx->cs.Sel,
113	pCtx->rip, uExitCode, uExitInfo1, uExitInfo2));
114
115	/*
116	* Disable the global interrupt flag to prevent interrupts during the 'atomic' world switch.
117	*/
118	pCtx->hwvirt.fGif = false;
119
120	Assert(CPUMSELREG_ARE_HIDDEN_PARTS_VALID(pVCpu, &pCtx->es));
121	Assert(CPUMSELREG_ARE_HIDDEN_PARTS_VALID(pVCpu, &pCtx->cs));
122	Assert(CPUMSELREG_ARE_HIDDEN_PARTS_VALID(pVCpu, &pCtx->ss));
123	Assert(CPUMSELREG_ARE_HIDDEN_PARTS_VALID(pVCpu, &pCtx->ds));
124
125	/*
126	* Save the nested-guest state into the VMCB state-save area.
127	*/
128	PSVMVMCB pVmcbNstGst = pCtx->hwvirt.svm.CTX_SUFF(pVmcb);
129	PSVMVMCBCTRL pVmcbNstGstCtrl = &pVmcbNstGst->ctrl;
130	PSVMVMCBSTATESAVE pVmcbNstGstState = &pVmcbNstGst->guest;
131
132	HMSVM_SEG_REG_COPY_TO_VMCB(pCtx, pVmcbNstGstState, ES, es);
133	HMSVM_SEG_REG_COPY_TO_VMCB(pCtx, pVmcbNstGstState, CS, cs);
134	HMSVM_SEG_REG_COPY_TO_VMCB(pCtx, pVmcbNstGstState, SS, ss);
135	HMSVM_SEG_REG_COPY_TO_VMCB(pCtx, pVmcbNstGstState, DS, ds);
136	pVmcbNstGstState->GDTR.u32Limit = pCtx->gdtr.cbGdt;
137	pVmcbNstGstState->GDTR.u64Base = pCtx->gdtr.pGdt;
138	pVmcbNstGstState->IDTR.u32Limit = pCtx->idtr.cbIdt;
139	pVmcbNstGstState->IDTR.u64Base = pCtx->idtr.pIdt;
140	pVmcbNstGstState->u64EFER = pCtx->msrEFER;
141	pVmcbNstGstState->u64CR4 = pCtx->cr4;
142	pVmcbNstGstState->u64CR3 = pCtx->cr3;
143	pVmcbNstGstState->u64CR2 = pCtx->cr2;
144	pVmcbNstGstState->u64CR0 = pCtx->cr0;
145	/** @todo Nested paging. */
146	pVmcbNstGstState->u64RFlags = pCtx->rflags.u64;
147	pVmcbNstGstState->u64RIP = pCtx->rip;
148	pVmcbNstGstState->u64RSP = pCtx->rsp;
149	pVmcbNstGstState->u64RAX = pCtx->rax;
150	pVmcbNstGstState->u64DR7 = pCtx->dr[7];
151	pVmcbNstGstState->u64DR6 = pCtx->dr[6];
152	pVmcbNstGstState->u8CPL = pCtx->ss.Attr.n.u2Dpl; /* See comment in CPUMGetGuestCPL(). */
153	Assert(CPUMGetGuestCPL(pVCpu) == pCtx->ss.Attr.n.u2Dpl);
154
155	PSVMVMCBCTRL pVmcbCtrl = &pCtx->hwvirt.svm.CTX_SUFF(pVmcb)->ctrl;
156
157	/*
158	* Save additional state and intercept information.
159	*
160	* - Interrupt shadow: Tracked using VMCPU_FF_INHIBIT_INTERRUPTS and RIP.
161	* - V_TPR: Already updated by iemCImpl_load_CrX or by the physical CPU for
162	* hardware-assisted SVM execution.
163	* - V_IRQ: Tracked using VMCPU_FF_INTERRUPT_NESTED_GUEST force-flag and updated below.
164	*/
165	if ( VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS)
166	&& EMGetInhibitInterruptsPC(pVCpu) == pCtx->rip)
167	{
168	pVmcbCtrl->IntShadow.n.u1IntShadow = 1;
169
170	/* Clear the inhibit-interrupt force-flag so as to not affect the outer guest. */
171	VMCPU_FF_CLEAR(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS);
172	LogFlow(("iemSvmVmexit: Interrupt shadow till %#RX64\n", pCtx->rip));
173	}
174
175	if (VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_INTERRUPT_NESTED_GUEST))
176	{
177	Assert(pVmcbCtrl->IntCtrl.n.u1VIrqPending);
178	VMCPU_FF_CLEAR(pVCpu, VMCPU_FF_INTERRUPT_NESTED_GUEST);
179	}
180	else
181	pVmcbCtrl->IntCtrl.n.u1VIrqPending = 0;
182
183	/** @todo NRIP. */
184
185	/* Save exit information. */
186	pVmcbCtrl->u64ExitCode = uExitCode;
187	pVmcbCtrl->u64ExitInfo1 = uExitInfo1;
188	pVmcbCtrl->u64ExitInfo2 = uExitInfo2;
189
190	/*
191	* Update the exit interrupt-information field if this #VMEXIT happened as a result
192	* of delivering an event through IEM.
193	*
194	* Don't update the exit interrupt-information field if the event wasn't being injected
195	* through IEM, as it may have been updated by real hardware if the nested-guest was
196	* executed using hardware-assisted SVM.
197	*/
198	{
199	uint8_t uExitIntVector;
200	uint32_t uExitIntErr;
201	uint32_t fExitIntFlags;
202	bool const fRaisingEvent = IEMGetCurrentXcpt(pVCpu, &uExitIntVector, &fExitIntFlags, &uExitIntErr,
203	NULL /* uExitIntCr2 */);
204	if (fRaisingEvent)
205	{
206	pVmcbCtrl->ExitIntInfo.n.u1Valid = 1;
207	pVmcbCtrl->ExitIntInfo.n.u8Vector = uExitIntVector;
208	pVmcbCtrl->ExitIntInfo.n.u3Type = iemGetSvmEventType(uExitIntVector, fExitIntFlags);
209	if (fExitIntFlags & IEM_XCPT_FLAGS_ERR)
210	{
211	pVmcbCtrl->ExitIntInfo.n.u1ErrorCodeValid = true;
212	pVmcbCtrl->ExitIntInfo.n.u32ErrorCode = uExitIntErr;
213	}
214	}
215	}
216
217	/*
218	* Clear event injection in the VMCB.
219	*/
220	pVmcbCtrl->EventInject.n.u1Valid = 0;
221
222	/*
223	* Notify HM in case the nested-guest was executed using hardware-assisted SVM (which
224	* would have modified some VMCB state) that need to be restored on #VMEXIT before
225	* writing the VMCB back to guest memory.
226	*/
227	HMSvmNstGstVmExitNotify(pVCpu, pCtx);
228
229	/*
230	* Write back the nested-guest's VMCB to its guest physical memory location.
231	*/
232	rcStrict = PGMPhysSimpleWriteGCPhys(pVCpu->CTX_SUFF(pVM), pCtx->hwvirt.svm.GCPhysVmcb, pVmcbNstGst, sizeof(*pVmcbNstGst));
233
234	/*
235	* Prepare for guest's "host mode" by clearing internal processor state bits.
236	*
237	* We don't need to zero out the state-save area, just the controls should be
238	* sufficient because it has the critical bit of indicating whether we're inside
239	* the nested-guest or not.
240	*/
241	memset(pVmcbNstGstCtrl, 0, sizeof(*pVmcbNstGstCtrl));
242	Assert(!CPUMIsGuestInSvmNestedHwVirtMode(pCtx));
243
244	/*
245	* Restore the subset of force-flags that were preserved.
246	*/
247	if (pCtx->hwvirt.fLocalForcedActions)
248	{
249	VMCPU_FF_SET(pVCpu, pCtx->hwvirt.fLocalForcedActions);
250	pCtx->hwvirt.fLocalForcedActions = 0;
251	}
252
253	if (RT_SUCCESS(rcStrict))
254	{
255	/** @todo Nested paging. */
256	/** @todo ASID. */
257
258	/*
259	* Reload the guest's "host state".
260	*/
261	CPUMSvmVmExitRestoreHostState(pVCpu, pCtx);
262
263	/*
264	* Update PGM, IEM and others of a world-switch.
265	*/
266	rcStrict = iemSvmWorldSwitch(pVCpu, pCtx);
267	if (rcStrict == VINF_SUCCESS)
268	rcStrict = VINF_SVM_VMEXIT;
269	else if (RT_SUCCESS(rcStrict))
270	{
271	LogFlow(("iemSvmVmexit: Setting passup status from iemSvmWorldSwitch %Rrc\n", VBOXSTRICTRC_VAL(rcStrict)));
272	iemSetPassUpStatus(pVCpu, rcStrict);
273	rcStrict = VINF_SVM_VMEXIT;
274	}
275	else
276	LogFlow(("iemSvmVmexit: iemSvmWorldSwitch unexpected failure. rc=%Rrc\n", VBOXSTRICTRC_VAL(rcStrict)));
277	}
278	else
279	{
280	LogFlow(("iemSvmVmexit: Writing VMCB at %#RGp failed. rc=%Rrc\n", pCtx->hwvirt.svm.GCPhysVmcb,
281	VBOXSTRICTRC_VAL(rcStrict)));
282	rcStrict = VERR_SVM_VMEXIT_FAILED;
283	}
284	}
285	else
286	{
287	Log(("iemSvmVmexit: Not in SVM guest mode! uExitCode=%#RX64 uExitInfo1=%#RX64 uExitInfo2=%#RX64\n", uExitCode,
288	uExitInfo1, uExitInfo2));
289	AssertMsgFailed(("iemSvmVmexit: Unexpected SVM-exit failure uExitCode=%#RX64\n", uExitCode));
290	rcStrict = VERR_SVM_IPE_3;
291	}
292
293	# if defined(VBOX_WITH_NESTED_HWVIRT_ONLY_IN_IEM) && defined(IN_RING3)
294	/* CLGI/STGI may not have been intercepted and thus not executed in IEM. */
295	if (HMSvmIsVGifActive(pVCpu->CTX_SUFF(pVM)))
296	return EMR3SetExecutionPolicy(pVCpu->CTX_SUFF(pVM)->pUVM, EMEXECPOLICY_IEM_ALL, false);
297	# endif
298	return rcStrict;
299	}
300
301
302	/**
303	* Performs the operations necessary that are part of the vmrun instruction
304	* execution in the guest.
305	*
306	* @returns Strict VBox status code (i.e. informational status codes too).
307	* @retval VINF_SUCCESS successully executed VMRUN and entered nested-guest
308	* code execution.
309	* @retval VINF_SVM_VMEXIT when executing VMRUN causes a \#VMEXIT
310	* (SVM_EXIT_INVALID most likely).
311	*
312	* @param pVCpu The cross context virtual CPU structure.
313	* @param pCtx Pointer to the guest-CPU context.
314	* @param cbInstr The length of the VMRUN instruction.
315	* @param GCPhysVmcb Guest physical address of the VMCB to run.
316	*/
317	IEM_STATIC VBOXSTRICTRC iemSvmVmrun(PVMCPU pVCpu, PCPUMCTX pCtx, uint8_t cbInstr, RTGCPHYS GCPhysVmcb)
318	{
319	LogFlow(("iemSvmVmrun\n"));
320
321	#ifdef IN_RING0
322	/*
323	* Until PGM can handle switching the guest paging mode in ring-0,
324	* there's no point in trying to emulate VMRUN in ring-0 as we have
325	* to go back to ring-3 anyway, see @bugref{7243#c48}.
326	*/
327	RT_NOREF(pVCpu, pCtx, cbInstr, GCPhysVmcb);
328	return VERR_IEM_ASPECT_NOT_IMPLEMENTED;
329	#else
330
331	/*
332	* Cache the physical address of the VMCB for #VMEXIT exceptions.
333	*/
334	pCtx->hwvirt.svm.GCPhysVmcb = GCPhysVmcb;
335
336	/*
337	* Save the host state.
338	*/
339	CPUMSvmVmRunSaveHostState(pCtx, cbInstr);
340
341	/*
342	* Read the guest VMCB state.
343	*/
344	PVM pVM = pVCpu->CTX_SUFF(pVM);
345	int rc = PGMPhysSimpleReadGCPhys(pVM, pCtx->hwvirt.svm.CTX_SUFF(pVmcb), GCPhysVmcb, sizeof(SVMVMCB));
346	if (RT_SUCCESS(rc))
347	{
348	PSVMVMCBCTRL pVmcbCtrl = &pCtx->hwvirt.svm.CTX_SUFF(pVmcb)->ctrl;
349	PSVMVMCBSTATESAVE pVmcbNstGst = &pCtx->hwvirt.svm.CTX_SUFF(pVmcb)->guest;
350
351	/*
352	* Validate guest-state and controls.
353	*/
354	/* VMRUN must always be intercepted. */
355	if (!CPUMIsGuestSvmCtrlInterceptSet(pVCpu, pCtx, SVM_CTRL_INTERCEPT_VMRUN))
356	{
357	Log(("iemSvmVmrun: VMRUN instruction not intercepted -> #VMEXIT\n"));
358	return iemSvmVmexit(pVCpu, pCtx, SVM_EXIT_INVALID, 0 /* uExitInfo1 /, 0 / uExitInfo2 */);
359	}
360
361	/* Nested paging. */
362	if ( pVmcbCtrl->NestedPaging.n.u1NestedPaging
363	&& !pVM->cpum.ro.GuestFeatures.fSvmNestedPaging)
364	{
365	Log(("iemSvmVmrun: Nested paging not supported -> #VMEXIT\n"));
366	return iemSvmVmexit(pVCpu, pCtx, SVM_EXIT_INVALID, 0 /* uExitInfo1 /, 0 / uExitInfo2 */);
367	}
368
369	/* AVIC. */
370	if ( pVmcbCtrl->IntCtrl.n.u1AvicEnable
371	&& !pVM->cpum.ro.GuestFeatures.fSvmAvic)
372	{
373	Log(("iemSvmVmrun: AVIC not supported -> #VMEXIT\n"));
374	return iemSvmVmexit(pVCpu, pCtx, SVM_EXIT_INVALID, 0 /* uExitInfo1 /, 0 / uExitInfo2 */);
375	}
376
377	/* Last branch record (LBR) virtualization. */
378	if ( pVmcbCtrl->LbrVirt.n.u1LbrVirt
379	&& !pVM->cpum.ro.GuestFeatures.fSvmLbrVirt)
380	{
381	Log(("iemSvmVmrun: LBR virtualization not supported -> #VMEXIT\n"));
382	return iemSvmVmexit(pVCpu, pCtx, SVM_EXIT_INVALID, 0 /* uExitInfo1 /, 0 / uExitInfo2 */);
383	}
384
385	/* Virtualized VMSAVE/VMLOAD. */
386	if ( pVmcbCtrl->LbrVirt.n.u1VirtVmsaveVmload
387	&& !pVM->cpum.ro.GuestFeatures.fSvmVirtVmsaveVmload)
388	{
389	Log(("iemSvmVmrun: Virtualized VMSAVE/VMLOAD not supported -> #VMEXIT\n"));
390	return iemSvmVmexit(pVCpu, pCtx, SVM_EXIT_INVALID, 0 /* uExitInfo1 /, 0 / uExitInfo2 */);
391	}
392
393	/* Virtual GIF. */
394	if ( pVmcbCtrl->IntCtrl.n.u1VGifEnable
395	&& !pVM->cpum.ro.GuestFeatures.fSvmVGif)
396	{
397	Log(("iemSvmVmrun: Virtual GIF not supported -> #VMEXIT\n"));
398	return iemSvmVmexit(pVCpu, pCtx, SVM_EXIT_INVALID, 0 /* uExitInfo1 /, 0 / uExitInfo2 */);
399	}
400
401	/* Guest ASID. */
402	if (!pVmcbCtrl->TLBCtrl.n.u32ASID)
403	{
404	Log(("iemSvmVmrun: Guest ASID is invalid -> #VMEXIT\n"));
405	return iemSvmVmexit(pVCpu, pCtx, SVM_EXIT_INVALID, 0 /* uExitInfo1 /, 0 / uExitInfo2 */);
406	}
407
408	/* Flush by ASID. */
409	if ( !pVM->cpum.ro.GuestFeatures.fSvmFlusbByAsid
410	&& pVmcbCtrl->TLBCtrl.n.u8TLBFlush != SVM_TLB_FLUSH_NOTHING
411	&& pVmcbCtrl->TLBCtrl.n.u8TLBFlush != SVM_TLB_FLUSH_ENTIRE)
412	{
413	Log(("iemSvmVmrun: Flush-by-ASID not supported -> #VMEXIT\n"));
414	return iemSvmVmexit(pVCpu, pCtx, SVM_EXIT_INVALID, 0 /* uExitInfo1 /, 0 / uExitInfo2 */);
415	}
416
417	/* IO permission bitmap. */
418	RTGCPHYS const GCPhysIOBitmap = pVmcbCtrl->u64IOPMPhysAddr;
419	if ( (GCPhysIOBitmap & X86_PAGE_4K_OFFSET_MASK)
420	\|\| !PGMPhysIsGCPhysNormal(pVM, GCPhysIOBitmap)
421	\|\| !PGMPhysIsGCPhysNormal(pVM, GCPhysIOBitmap + X86_PAGE_4K_SIZE)
422	\|\| !PGMPhysIsGCPhysNormal(pVM, GCPhysIOBitmap + (X86_PAGE_4K_SIZE << 1)))
423	{
424	Log(("iemSvmVmrun: IO bitmap physaddr invalid. GCPhysIOBitmap=%#RX64 -> #VMEXIT\n", GCPhysIOBitmap));
425	return iemSvmVmexit(pVCpu, pCtx, SVM_EXIT_INVALID, 0 /* uExitInfo1 /, 0 / uExitInfo2 */);
426	}
427
428	/* MSR permission bitmap. */
429	RTGCPHYS const GCPhysMsrBitmap = pVmcbCtrl->u64MSRPMPhysAddr;
430	if ( (GCPhysMsrBitmap & X86_PAGE_4K_OFFSET_MASK)
431	\|\| !PGMPhysIsGCPhysNormal(pVM, GCPhysMsrBitmap)
432	\|\| !PGMPhysIsGCPhysNormal(pVM, GCPhysMsrBitmap + X86_PAGE_4K_SIZE))
433	{
434	Log(("iemSvmVmrun: MSR bitmap physaddr invalid. GCPhysMsrBitmap=%#RX64 -> #VMEXIT\n", GCPhysMsrBitmap));
435	return iemSvmVmexit(pVCpu, pCtx, SVM_EXIT_INVALID, 0 /* uExitInfo1 /, 0 / uExitInfo2 */);
436	}
437
438	/* CR0. */
439	if ( !(pVmcbNstGst->u64CR0 & X86_CR0_CD)
440	&& (pVmcbNstGst->u64CR0 & X86_CR0_NW))
441	{
442	Log(("iemSvmVmrun: CR0 no-write through with cache disabled. CR0=%#RX64 -> #VMEXIT\n", pVmcbNstGst->u64CR0));
443	return iemSvmVmexit(pVCpu, pCtx, SVM_EXIT_INVALID, 0 /* uExitInfo1 /, 0 / uExitInfo2 */);
444	}
445	if (pVmcbNstGst->u64CR0 >> 32)
446	{
447	Log(("iemSvmVmrun: CR0 reserved bits set. CR0=%#RX64 -> #VMEXIT\n", pVmcbNstGst->u64CR0));
448	return iemSvmVmexit(pVCpu, pCtx, SVM_EXIT_INVALID, 0 /* uExitInfo1 /, 0 / uExitInfo2 */);
449	}
450	/** @todo Implement all reserved bits/illegal combinations for CR3, CR4. */
451
452	/* DR6 and DR7. */
453	if ( pVmcbNstGst->u64DR6 >> 32
454	\|\| pVmcbNstGst->u64DR7 >> 32)
455	{
456	Log(("iemSvmVmrun: DR6 and/or DR7 reserved bits set. DR6=%#RX64 DR7=%#RX64 -> #VMEXIT\n", pVmcbNstGst->u64DR6,
457	pVmcbNstGst->u64DR6));
458	return iemSvmVmexit(pVCpu, pCtx, SVM_EXIT_INVALID, 0 /* uExitInfo1 /, 0 / uExitInfo2 */);
459	}
460
461	/** @todo gPAT MSR validation? */
462
463	/*
464	* Copy the IO permission bitmap into the cache.
465	*/
466	Assert(pCtx->hwvirt.svm.CTX_SUFF(pvIoBitmap));
467	rc = PGMPhysSimpleReadGCPhys(pVM, pCtx->hwvirt.svm.CTX_SUFF(pvIoBitmap), GCPhysIOBitmap,
468	SVM_IOPM_PAGES * X86_PAGE_4K_SIZE);
469	if (RT_FAILURE(rc))
470	{
471	Log(("iemSvmVmrun: Failed reading the IO permission bitmap at %#RGp. rc=%Rrc\n", GCPhysIOBitmap, rc));
472	return iemSvmVmexit(pVCpu, pCtx, SVM_EXIT_INVALID, 0 /* uExitInfo1 /, 0 / uExitInfo2 */);
473	}
474
475	/*
476	* Copy the MSR permission bitmap into the cache.
477	*/
478	Assert(pCtx->hwvirt.svm.CTX_SUFF(pvMsrBitmap));
479	rc = PGMPhysSimpleReadGCPhys(pVM, pCtx->hwvirt.svm.CTX_SUFF(pvMsrBitmap), GCPhysMsrBitmap,
480	SVM_MSRPM_PAGES * X86_PAGE_4K_SIZE);
481	if (RT_FAILURE(rc))
482	{
483	Log(("iemSvmVmrun: Failed reading the MSR permission bitmap at %#RGp. rc=%Rrc\n", GCPhysMsrBitmap, rc));
484	return iemSvmVmexit(pVCpu, pCtx, SVM_EXIT_INVALID, 0 /* uExitInfo1 /, 0 / uExitInfo2 */);
485	}
486
487	/*
488	* Copy segments from nested-guest VMCB state to the guest-CPU state.
489	*
490	* We do this here as we need to use the CS attributes and it's easier this way
491	* then using the VMCB format selectors. It doesn't really matter where we copy
492	* the state, we restore the guest-CPU context state on the \#VMEXIT anyway.
493	*/
494	HMSVM_SEG_REG_COPY_FROM_VMCB(pCtx, pVmcbNstGst, ES, es);
495	HMSVM_SEG_REG_COPY_FROM_VMCB(pCtx, pVmcbNstGst, CS, cs);
496	HMSVM_SEG_REG_COPY_FROM_VMCB(pCtx, pVmcbNstGst, SS, ss);
497	HMSVM_SEG_REG_COPY_FROM_VMCB(pCtx, pVmcbNstGst, DS, ds);
498
499	/** @todo Segment attribute overrides by VMRUN. */
500
501	/*
502	* CPL adjustments and overrides.
503	*
504	* SS.DPL is apparently the CPU's CPL, see comment in CPUMGetGuestCPL().
505	* We shall thus adjust both CS.DPL and SS.DPL here.
506	*/
507	pCtx->cs.Attr.n.u2Dpl = pCtx->ss.Attr.n.u2Dpl = pVmcbNstGst->u8CPL;
508	if (CPUMIsGuestInV86ModeEx(pCtx))
509	pCtx->cs.Attr.n.u2Dpl = pCtx->ss.Attr.n.u2Dpl = 3;
510	if (CPUMIsGuestInRealModeEx(pCtx))
511	pCtx->cs.Attr.n.u2Dpl = pCtx->ss.Attr.n.u2Dpl = 0;
512	Assert(CPUMSELREG_ARE_HIDDEN_PARTS_VALID(pVCpu, &pCtx->ss));
513
514	/*
515	* Continue validating guest-state and controls.
516	*
517	* We pass CR0 as 0 to CPUMQueryValidatedGuestEfer below to skip the illegal
518	* EFER.LME bit transition check. We pass the nested-guest's EFER as both the
519	* old and new EFER value to not have any guest EFER bits influence the new
520	* nested-guest EFER.
521	*/
522	uint64_t uValidEfer;
523	rc = CPUMQueryValidatedGuestEfer(pVM, 0 /* CR0 */, pVmcbNstGst->u64EFER, pVmcbNstGst->u64EFER, &uValidEfer);
524	if (RT_FAILURE(rc))
525	{
526	Log(("iemSvmVmrun: EFER invalid uOldEfer=%#RX64 -> #VMEXIT\n", pVmcbNstGst->u64EFER));
527	return iemSvmVmexit(pVCpu, pCtx, SVM_EXIT_INVALID, 0 /* uExitInfo1 /, 0 / uExitInfo2 */);
528	}
529
530	/* Validate paging and CPU mode bits. */
531	bool const fSvm = RT_BOOL(uValidEfer & MSR_K6_EFER_SVME);
532	bool const fLongModeSupported = RT_BOOL(pVM->cpum.ro.GuestFeatures.fLongMode);
533	bool const fLongModeEnabled = RT_BOOL(uValidEfer & MSR_K6_EFER_LME);
534	bool const fPaging = RT_BOOL(pVmcbNstGst->u64CR0 & X86_CR0_PG);
535	bool const fPae = RT_BOOL(pVmcbNstGst->u64CR4 & X86_CR4_PAE);
536	bool const fProtMode = RT_BOOL(pVmcbNstGst->u64CR0 & X86_CR0_PE);
537	bool const fLongModeWithPaging = fLongModeEnabled && fPaging;
538	bool const fLongModeConformCS = pCtx->cs.Attr.n.u1Long && pCtx->cs.Attr.n.u1DefBig;
539	/* Adjust EFER.LMA (this is normally done by the CPU when system software writes CR0). */
540	if (fLongModeWithPaging)
541	uValidEfer \|= MSR_K6_EFER_LMA;
542	bool const fLongModeActiveOrEnabled = RT_BOOL(uValidEfer & (MSR_K6_EFER_LME \| MSR_K6_EFER_LMA));
543	if ( !fSvm
544	\|\| (!fLongModeSupported && fLongModeActiveOrEnabled)
545	\|\| (fLongModeWithPaging && !fPae)
546	\|\| (fLongModeWithPaging && !fProtMode)
547	\|\| ( fLongModeEnabled
548	&& fPaging
549	&& fPae
550	&& fLongModeConformCS))
551	{
552	Log(("iemSvmVmrun: EFER invalid. uValidEfer=%#RX64 -> #VMEXIT\n", uValidEfer));
553	return iemSvmVmexit(pVCpu, pCtx, SVM_EXIT_INVALID, 0 /* uExitInfo1 /, 0 / uExitInfo2 */);
554	}
555
556	/*
557	* Preserve the required force-flags.
558	*
559	* We only preserve the force-flags that would affect the execution of the
560	* nested-guest (or the guest).
561	*
562	* - VMCPU_FF_INHIBIT_INTERRUPTS need -not- be preserved as it's for a single
563	* instruction which is this VMRUN instruction itself.
564	*
565	* - VMCPU_FF_BLOCK_NMIS needs to be preserved as it blocks NMI until the
566	* execution of a subsequent IRET instruction in the guest.
567	*
568	* - The remaining FFs (e.g. timers) can stay in place so that we will be
569	* able to generate interrupts that should cause #VMEXITs for the
570	* nested-guest.
571	*/
572	pCtx->hwvirt.fLocalForcedActions = pVCpu->fLocalForcedActions & VMCPU_FF_BLOCK_NMIS;
573	VMCPU_FF_CLEAR(pVCpu, VMCPU_FF_BLOCK_NMIS);
574
575	/*
576	* Interrupt shadow.
577	*/
578	if (pVmcbCtrl->IntShadow.n.u1IntShadow)
579	{
580	LogFlow(("iemSvmVmrun: setting interrupt shadow. inhibit PC=%#RX64\n", pVmcbNstGst->u64RIP));
581	/** @todo will this cause trouble if the nested-guest is 64-bit but the guest is 32-bit? */
582	EMSetInhibitInterruptsPC(pVCpu, pVmcbNstGst->u64RIP);
583	}
584
585	/*
586	* TLB flush control.
587	* Currently disabled since it's redundant as we unconditionally flush the TLB
588	* in iemSvmWorldSwitch() below.
589	*/
590	#if 0
591	/** @todo @bugref{7243}: ASID based PGM TLB flushes. */
592	if ( pVmcbCtrl->TLBCtrl.n.u8TLBFlush == SVM_TLB_FLUSH_ENTIRE
593	\|\| pVmcbCtrl->TLBCtrl.n.u8TLBFlush == SVM_TLB_FLUSH_SINGLE_CONTEXT
594	\|\| pVmcbCtrl->TLBCtrl.n.u8TLBFlush == SVM_TLB_FLUSH_SINGLE_CONTEXT_RETAIN_GLOBALS)
595	PGMFlushTLB(pVCpu, pVmcbNstGst->u64CR3, true /* fGlobal */);
596	#endif
597
598	/*
599	* Copy the remaining guest state from the VMCB to the guest-CPU context.
600	*/
601	pCtx->gdtr.cbGdt = pVmcbNstGst->GDTR.u32Limit;
602	pCtx->gdtr.pGdt = pVmcbNstGst->GDTR.u64Base;
603	pCtx->idtr.cbIdt = pVmcbNstGst->IDTR.u32Limit;
604	pCtx->idtr.pIdt = pVmcbNstGst->IDTR.u64Base;
605	CPUMSetGuestCR0(pVCpu, pVmcbNstGst->u64CR0);
606	CPUMSetGuestCR4(pVCpu, pVmcbNstGst->u64CR4);
607	pCtx->cr3 = pVmcbNstGst->u64CR3;
608	pCtx->cr2 = pVmcbNstGst->u64CR2;
609	pCtx->dr[6] = pVmcbNstGst->u64DR6;
610	pCtx->dr[7] = pVmcbNstGst->u64DR7;
611	pCtx->rflags.u64 = pVmcbNstGst->u64RFlags;
612	pCtx->rax = pVmcbNstGst->u64RAX;
613	pCtx->rsp = pVmcbNstGst->u64RSP;
614	pCtx->rip = pVmcbNstGst->u64RIP;
615	CPUMSetGuestMsrEferNoCheck(pVCpu, pCtx->msrEFER, uValidEfer);
616
617	/* Mask DR6, DR7 bits mandatory set/clear bits. */
618	pCtx->dr[6] &= ~(X86_DR6_RAZ_MASK \| X86_DR6_MBZ_MASK);
619	pCtx->dr[6] \|= X86_DR6_RA1_MASK;
620	pCtx->dr[7] &= ~(X86_DR7_RAZ_MASK \| X86_DR7_MBZ_MASK);
621	pCtx->dr[7] \|= X86_DR7_RA1_MASK;
622
623	/*
624	* Check for pending virtual interrupts.
625	*/
626	if (pVmcbCtrl->IntCtrl.n.u1VIrqPending)
627	VMCPU_FF_SET(pVCpu, VMCPU_FF_INTERRUPT_NESTED_GUEST);
628	else
629	Assert(!VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_INTERRUPT_NESTED_GUEST));
630
631	/*
632	* Update PGM, IEM and others of a world-switch.
633	*/
634	VBOXSTRICTRC rcStrict = iemSvmWorldSwitch(pVCpu, pCtx);
635	if (rcStrict == VINF_SUCCESS)
636	{ /* likely */ }
637	else if (RT_SUCCESS(rcStrict))
638	{
639	LogFlow(("iemSvmVmrun: iemSvmWorldSwitch returned %Rrc, setting passup status\n", VBOXSTRICTRC_VAL(rcStrict)));
640	rcStrict = iemSetPassUpStatus(pVCpu, rcStrict);
641	}
642	else
643	{
644	LogFlow(("iemSvmVmrun: iemSvmWorldSwitch unexpected failure. rc=%Rrc\n", VBOXSTRICTRC_VAL(rcStrict)));
645	return rcStrict;
646	}
647
648	/*
649	* Clear global interrupt flags to allow interrupts in the guest.
650	*/
651	pCtx->hwvirt.fGif = true;
652
653	/*
654	* Event injection.
655	*/
656	PCSVMEVENT pEventInject = &pVmcbCtrl->EventInject;
657	pCtx->hwvirt.svm.fInterceptEvents = !pEventInject->n.u1Valid;
658	if (pEventInject->n.u1Valid)
659	{
660	uint8_t const uVector = pEventInject->n.u8Vector;
661	TRPMEVENT const enmType = HMSvmEventToTrpmEventType(pEventInject);
662	uint16_t const uErrorCode = pEventInject->n.u1ErrorCodeValid ? pEventInject->n.u32ErrorCode : 0;
663
664	/* Validate vectors for hardware exceptions, see AMD spec. 15.20 "Event Injection". */
665	if (RT_UNLIKELY(enmType == TRPM_32BIT_HACK))
666	{
667	Log(("iemSvmVmrun: Invalid event type =%#x -> #VMEXIT\n", (uint8_t)pEventInject->n.u3Type));
668	return iemSvmVmexit(pVCpu, pCtx, SVM_EXIT_INVALID, 0 /* uExitInfo1 /, 0 / uExitInfo2 */);
669	}
670	if (pEventInject->n.u3Type == SVM_EVENT_EXCEPTION)
671	{
672	if ( uVector == X86_XCPT_NMI
673	\|\| uVector > X86_XCPT_LAST)
674	{
675	Log(("iemSvmVmrun: Invalid vector for hardware exception. uVector=%#x -> #VMEXIT\n", uVector));
676	return iemSvmVmexit(pVCpu, pCtx, SVM_EXIT_INVALID, 0 /* uExitInfo1 /, 0 / uExitInfo2 */);
677	}
678	if ( uVector == X86_XCPT_BR
679	&& CPUMIsGuestInLongModeEx(pCtx))
680	{
681	Log(("iemSvmVmrun: Cannot inject #BR when not in long mode -> #VMEXIT\n"));
682	return iemSvmVmexit(pVCpu, pCtx, SVM_EXIT_INVALID, 0 /* uExitInfo1 /, 0 / uExitInfo2 */);
683	}
684	/** @todo any others? */
685	}
686
687	/*
688	* Invalidate the exit interrupt-information field here. This field is fully updated
689	* on #VMEXIT as events other than the one below can also cause intercepts during
690	* their injection (e.g. exceptions).
691	*/
692	pVmcbCtrl->ExitIntInfo.n.u1Valid = 0;
693
694	/*
695	* Clear the event injection valid bit here. While the AMD spec. mentions that the CPU
696	* clears this bit from the VMCB unconditionally on #VMEXIT, internally the CPU could be
697	* clearing it at any time, most likely before/after injecting the event. Since VirtualBox
698	* doesn't have any virtual-CPU internal representation of this bit, we clear/update the
699	* VMCB here. This also has the added benefit that we avoid the risk of injecting the event
700	* twice if we fallback to executing the nested-guest using hardware-assisted SVM after
701	* injecting the event through IEM here.
702	*/
703	pVmcbCtrl->EventInject.n.u1Valid = 0;
704
705	/** @todo NRIP: Software interrupts can only be pushed properly if we support
706	* NRIP for the nested-guest to calculate the instruction length
707	* below. */
708	LogFlow(("iemSvmVmrun: Injecting event: %04x:%08RX64 vec=%#x type=%d uErr=%u cr2=%#RX64 cr3=%#RX64 efer=%#RX64\n",
709	pCtx->cs.Sel, pCtx->rip, uVector, enmType, uErrorCode, pCtx->cr2, pCtx->cr3, pCtx->msrEFER));
710	#if 0
711	rcStrict = IEMInjectTrap(pVCpu, uVector, enmType, uErrorCode, pCtx->cr2, 0 /* cbInstr */);
712	#else
713	TRPMAssertTrap(pVCpu, uVector, enmType);
714	if (pEventInject->n.u1ErrorCodeValid)
715	TRPMSetErrorCode(pVCpu, uErrorCode);
716	if ( enmType == TRPM_TRAP
717	&& uVector == X86_XCPT_PF)
718	TRPMSetFaultAddress(pVCpu, pCtx->cr2);
719	#endif
720	}
721	else
722	LogFlow(("iemSvmVmrun: Entering nested-guest: %04x:%08RX64 cr0=%#RX64 cr3=%#RX64 cr4=%#RX64 efer=%#RX64 efl=%#x\n",
723	pCtx->cs.Sel, pCtx->rip, pCtx->cr0, pCtx->cr3, pCtx->cr4, pCtx->msrEFER, pCtx->rflags.u64));
724
725	LogFlow(("iemSvmVmrun: returns %d\n", VBOXSTRICTRC_VAL(rcStrict)));
726
727	# if defined(VBOX_WITH_NESTED_HWVIRT_ONLY_IN_IEM) && defined(IN_RING3)
728	/* If CLGI/STGI isn't intercepted we force IEM-only nested-guest execution here. */
729	if (HMSvmIsVGifActive(pVM))
730	return EMR3SetExecutionPolicy(pVCpu->CTX_SUFF(pVM)->pUVM, EMEXECPOLICY_IEM_ALL, true);
731	# endif
732
733	return rcStrict;
734	}
735
736	/* Shouldn't really happen as the caller should've validated the physical address already. */
737	Log(("iemSvmVmrun: Failed to read nested-guest VMCB at %#RGp (rc=%Rrc) -> #VMEXIT\n", GCPhysVmcb, rc));
738	return rc;
739	#endif
740	}
741
742
743	#if 0
744	/**
745	* Handles nested-guest SVM control intercepts and performs the \#VMEXIT if the
746	* intercept is active.
747	*
748	* @returns Strict VBox status code.
749	* @retval VINF_SVM_INTERCEPT_NOT_ACTIVE if the intercept is not active or
750	* we're not executing a nested-guest.
751	* @retval VINF_SVM_VMEXIT if the intercept is active and the \#VMEXIT occurred
752	* successfully.
753	* @retval VERR_SVM_VMEXIT_FAILED if the intercept is active and the \#VMEXIT
754	* failed and a shutdown needs to be initiated for the geust.
755	*
756	* @param pVCpu The cross context virtual CPU structure.
757	* @param pCtx The guest-CPU context.
758	* @param uExitCode The SVM exit code (see SVM_EXIT_XXX).
759	* @param uExitInfo1 The exit info. 1 field.
760	* @param uExitInfo2 The exit info. 2 field.
761	*/
762	VMM_INT_DECL(VBOXSTRICTRC) HMSvmNstGstHandleCtrlIntercept(PVMCPU pVCpu, PCPUMCTX pCtx, uint64_t uExitCode, uint64_t uExitInfo1,
763	uint64_t uExitInfo2)
764	{
765	#define HMSVM_CTRL_INTERCEPT_VMEXIT(a_Intercept) \
766	do { \
767	if (CPUMIsGuestSvmCtrlInterceptSet(pCtx, (a_Intercept))) \
768	return iemSvmVmexit(pVCpu, pCtx, uExitCode, uExitInfo1, uExitInfo2); \
769	break; \
770	} while (0)
771
772	if (!CPUMIsGuestInSvmNestedHwVirtMode(pCtx))
773	return VINF_HM_INTERCEPT_NOT_ACTIVE;
774
775	switch (uExitCode)
776	{
777	case SVM_EXIT_EXCEPTION_0: case SVM_EXIT_EXCEPTION_1: case SVM_EXIT_EXCEPTION_2: case SVM_EXIT_EXCEPTION_3:
778	case SVM_EXIT_EXCEPTION_4: case SVM_EXIT_EXCEPTION_5: case SVM_EXIT_EXCEPTION_6: case SVM_EXIT_EXCEPTION_7:
779	case SVM_EXIT_EXCEPTION_8: case SVM_EXIT_EXCEPTION_9: case SVM_EXIT_EXCEPTION_10: case SVM_EXIT_EXCEPTION_11:
780	case SVM_EXIT_EXCEPTION_12: case SVM_EXIT_EXCEPTION_13: case SVM_EXIT_EXCEPTION_14: case SVM_EXIT_EXCEPTION_15:
781	case SVM_EXIT_EXCEPTION_16: case SVM_EXIT_EXCEPTION_17: case SVM_EXIT_EXCEPTION_18: case SVM_EXIT_EXCEPTION_19:
782	case SVM_EXIT_EXCEPTION_20: case SVM_EXIT_EXCEPTION_21: case SVM_EXIT_EXCEPTION_22: case SVM_EXIT_EXCEPTION_23:
783	case SVM_EXIT_EXCEPTION_24: case SVM_EXIT_EXCEPTION_25: case SVM_EXIT_EXCEPTION_26: case SVM_EXIT_EXCEPTION_27:
784	case SVM_EXIT_EXCEPTION_28: case SVM_EXIT_EXCEPTION_29: case SVM_EXIT_EXCEPTION_30: case SVM_EXIT_EXCEPTION_31:
785	{
786	if (CPUMIsGuestSvmXcptInterceptSet(pCtx, (X86XCPT)(uExitCode - SVM_EXIT_EXCEPTION_0)))
787	return iemSvmVmexit(pVCpu, pCtx, uExitCode, uExitInfo1, uExitInfo2);
788	break;
789	}
790
791	case SVM_EXIT_WRITE_CR0: case SVM_EXIT_WRITE_CR1: case SVM_EXIT_WRITE_CR2: case SVM_EXIT_WRITE_CR3:
792	case SVM_EXIT_WRITE_CR4: case SVM_EXIT_WRITE_CR5: case SVM_EXIT_WRITE_CR6: case SVM_EXIT_WRITE_CR7:
793	case SVM_EXIT_WRITE_CR8: case SVM_EXIT_WRITE_CR9: case SVM_EXIT_WRITE_CR10: case SVM_EXIT_WRITE_CR11:
794	case SVM_EXIT_WRITE_CR12: case SVM_EXIT_WRITE_CR13: case SVM_EXIT_WRITE_CR14: case SVM_EXIT_WRITE_CR15:
795	{
796	if (CPUMIsGuestSvmWriteCRxInterceptSet(pCtx, uExitCode - SVM_EXIT_WRITE_CR0))
797	return iemSvmVmexit(pVCpu, pCtx, uExitCode, uExitInfo1, uExitInfo2);
798	break;
799	}
800
801	case SVM_EXIT_READ_CR0: case SVM_EXIT_READ_CR1: case SVM_EXIT_READ_CR2: case SVM_EXIT_READ_CR3:
802	case SVM_EXIT_READ_CR4: case SVM_EXIT_READ_CR5: case SVM_EXIT_READ_CR6: case SVM_EXIT_READ_CR7:
803	case SVM_EXIT_READ_CR8: case SVM_EXIT_READ_CR9: case SVM_EXIT_READ_CR10: case SVM_EXIT_READ_CR11:
804	case SVM_EXIT_READ_CR12: case SVM_EXIT_READ_CR13: case SVM_EXIT_READ_CR14: case SVM_EXIT_READ_CR15:
805	{
806	if (CPUMIsGuestSvmReadCRxInterceptSet(pCtx, uExitCode - SVM_EXIT_READ_CR0))
807	return iemSvmVmexit(pVCpu, pCtx, uExitCode, uExitInfo1, uExitInfo2);
808	break;
809	}
810
811	case SVM_EXIT_READ_DR0: case SVM_EXIT_READ_DR1: case SVM_EXIT_READ_DR2: case SVM_EXIT_READ_DR3:
812	case SVM_EXIT_READ_DR4: case SVM_EXIT_READ_DR5: case SVM_EXIT_READ_DR6: case SVM_EXIT_READ_DR7:
813	case SVM_EXIT_READ_DR8: case SVM_EXIT_READ_DR9: case SVM_EXIT_READ_DR10: case SVM_EXIT_READ_DR11:
814	case SVM_EXIT_READ_DR12: case SVM_EXIT_READ_DR13: case SVM_EXIT_READ_DR14: case SVM_EXIT_READ_DR15:
815	{
816	if (CPUMIsGuestSvmReadDRxInterceptSet(pCtx, uExitCode - SVM_EXIT_READ_DR0))
817	return iemSvmVmexit(pVCpu, pCtx, uExitCode, uExitInfo1, uExitInfo2);
818	break;
819	}
820
821	case SVM_EXIT_WRITE_DR0: case SVM_EXIT_WRITE_DR1: case SVM_EXIT_WRITE_DR2: case SVM_EXIT_WRITE_DR3:
822	case SVM_EXIT_WRITE_DR4: case SVM_EXIT_WRITE_DR5: case SVM_EXIT_WRITE_DR6: case SVM_EXIT_WRITE_DR7:
823	case SVM_EXIT_WRITE_DR8: case SVM_EXIT_WRITE_DR9: case SVM_EXIT_WRITE_DR10: case SVM_EXIT_WRITE_DR11:
824	case SVM_EXIT_WRITE_DR12: case SVM_EXIT_WRITE_DR13: case SVM_EXIT_WRITE_DR14: case SVM_EXIT_WRITE_DR15:
825	{
826	if (CPUMIsGuestSvmWriteDRxInterceptSet(pCtx, uExitCode - SVM_EXIT_WRITE_DR0))
827	return iemSvmVmexit(pVCpu, pCtx, uExitCode, uExitInfo1, uExitInfo2);
828	break;
829	}
830
831	case SVM_EXIT_INTR: HMSVM_CTRL_INTERCEPT_VMEXIT(SVM_CTRL_INTERCEPT_INTR);
832	case SVM_EXIT_NMI: HMSVM_CTRL_INTERCEPT_VMEXIT(SVM_CTRL_INTERCEPT_NMI);
833	case SVM_EXIT_SMI: HMSVM_CTRL_INTERCEPT_VMEXIT(SVM_CTRL_INTERCEPT_SMI);
834	case SVM_EXIT_INIT: HMSVM_CTRL_INTERCEPT_VMEXIT(SVM_CTRL_INTERCEPT_INIT);
835	case SVM_EXIT_VINTR: HMSVM_CTRL_INTERCEPT_VMEXIT(SVM_CTRL_INTERCEPT_VINTR);
836	case SVM_EXIT_CR0_SEL_WRITE: HMSVM_CTRL_INTERCEPT_VMEXIT(SVM_CTRL_INTERCEPT_CR0_SEL_WRITES);
837	case SVM_EXIT_IDTR_READ: HMSVM_CTRL_INTERCEPT_VMEXIT(SVM_CTRL_INTERCEPT_IDTR_READS);
838	case SVM_EXIT_GDTR_READ: HMSVM_CTRL_INTERCEPT_VMEXIT(SVM_CTRL_INTERCEPT_GDTR_READS);
839	case SVM_EXIT_LDTR_READ: HMSVM_CTRL_INTERCEPT_VMEXIT(SVM_CTRL_INTERCEPT_LDTR_READS);
840	case SVM_EXIT_TR_READ: HMSVM_CTRL_INTERCEPT_VMEXIT(SVM_CTRL_INTERCEPT_TR_READS);
841	case SVM_EXIT_IDTR_WRITE: HMSVM_CTRL_INTERCEPT_VMEXIT(SVM_CTRL_INTERCEPT_IDTR_WRITES);
842	case SVM_EXIT_GDTR_WRITE: HMSVM_CTRL_INTERCEPT_VMEXIT(SVM_CTRL_INTERCEPT_GDTR_WRITES);
843	case SVM_EXIT_LDTR_WRITE: HMSVM_CTRL_INTERCEPT_VMEXIT(SVM_CTRL_INTERCEPT_LDTR_WRITES);
844	case SVM_EXIT_TR_WRITE: HMSVM_CTRL_INTERCEPT_VMEXIT(SVM_CTRL_INTERCEPT_TR_WRITES);
845	case SVM_EXIT_RDTSC: HMSVM_CTRL_INTERCEPT_VMEXIT(SVM_CTRL_INTERCEPT_RDTSC);
846	case SVM_EXIT_RDPMC: HMSVM_CTRL_INTERCEPT_VMEXIT(SVM_CTRL_INTERCEPT_RDPMC);
847	case SVM_EXIT_PUSHF: HMSVM_CTRL_INTERCEPT_VMEXIT(SVM_CTRL_INTERCEPT_PUSHF);
848	case SVM_EXIT_POPF: HMSVM_CTRL_INTERCEPT_VMEXIT(SVM_CTRL_INTERCEPT_POPF);
849	case SVM_EXIT_CPUID: HMSVM_CTRL_INTERCEPT_VMEXIT(SVM_CTRL_INTERCEPT_CPUID);
850	case SVM_EXIT_RSM: HMSVM_CTRL_INTERCEPT_VMEXIT(SVM_CTRL_INTERCEPT_RSM);
851	case SVM_EXIT_IRET: HMSVM_CTRL_INTERCEPT_VMEXIT(SVM_CTRL_INTERCEPT_IRET);
852	case SVM_EXIT_SWINT: HMSVM_CTRL_INTERCEPT_VMEXIT(SVM_CTRL_INTERCEPT_INTN);
853	case SVM_EXIT_INVD: HMSVM_CTRL_INTERCEPT_VMEXIT(SVM_CTRL_INTERCEPT_INVD);
854	case SVM_EXIT_PAUSE: HMSVM_CTRL_INTERCEPT_VMEXIT(SVM_CTRL_INTERCEPT_PAUSE);
855	case SVM_EXIT_HLT: HMSVM_CTRL_INTERCEPT_VMEXIT(SVM_CTRL_INTERCEPT_HLT);
856	case SVM_EXIT_INVLPG: HMSVM_CTRL_INTERCEPT_VMEXIT(SVM_CTRL_INTERCEPT_INVLPG);
857	case SVM_EXIT_INVLPGA: HMSVM_CTRL_INTERCEPT_VMEXIT(SVM_CTRL_INTERCEPT_INVLPGA);
858	case SVM_EXIT_TASK_SWITCH: HMSVM_CTRL_INTERCEPT_VMEXIT(SVM_CTRL_INTERCEPT_TASK_SWITCH);
859	case SVM_EXIT_FERR_FREEZE: HMSVM_CTRL_INTERCEPT_VMEXIT(SVM_CTRL_INTERCEPT_FERR_FREEZE);
860	case SVM_EXIT_SHUTDOWN: HMSVM_CTRL_INTERCEPT_VMEXIT(SVM_CTRL_INTERCEPT_SHUTDOWN);
861	case SVM_EXIT_VMRUN: HMSVM_CTRL_INTERCEPT_VMEXIT(SVM_CTRL_INTERCEPT_VMRUN);
862	case SVM_EXIT_VMMCALL: HMSVM_CTRL_INTERCEPT_VMEXIT(SVM_CTRL_INTERCEPT_VMMCALL);
863	case SVM_EXIT_VMLOAD: HMSVM_CTRL_INTERCEPT_VMEXIT(SVM_CTRL_INTERCEPT_VMLOAD);
864	case SVM_EXIT_VMSAVE: HMSVM_CTRL_INTERCEPT_VMEXIT(SVM_CTRL_INTERCEPT_VMSAVE);
865	case SVM_EXIT_STGI: HMSVM_CTRL_INTERCEPT_VMEXIT(SVM_CTRL_INTERCEPT_STGI);
866	case SVM_EXIT_CLGI: HMSVM_CTRL_INTERCEPT_VMEXIT(SVM_CTRL_INTERCEPT_CLGI);
867	case SVM_EXIT_SKINIT: HMSVM_CTRL_INTERCEPT_VMEXIT(SVM_CTRL_INTERCEPT_SKINIT);
868	case SVM_EXIT_RDTSCP: HMSVM_CTRL_INTERCEPT_VMEXIT(SVM_CTRL_INTERCEPT_RDTSCP);
869	case SVM_EXIT_ICEBP: HMSVM_CTRL_INTERCEPT_VMEXIT(SVM_CTRL_INTERCEPT_ICEBP);
870	case SVM_EXIT_WBINVD: HMSVM_CTRL_INTERCEPT_VMEXIT(SVM_CTRL_INTERCEPT_WBINVD);
871	case SVM_EXIT_MONITOR: HMSVM_CTRL_INTERCEPT_VMEXIT(SVM_CTRL_INTERCEPT_MONITOR);
872	case SVM_EXIT_MWAIT: HMSVM_CTRL_INTERCEPT_VMEXIT(SVM_CTRL_INTERCEPT_MWAIT);
873	case SVM_EXIT_MWAIT_ARMED: HMSVM_CTRL_INTERCEPT_VMEXIT(SVM_CTRL_INTERCEPT_MWAIT_ARMED);
874	case SVM_EXIT_XSETBV: HMSVM_CTRL_INTERCEPT_VMEXIT(SVM_CTRL_INTERCEPT_XSETBV);
875
876	case SVM_EXIT_IOIO:
877	AssertMsgFailed(("Use HMSvmNstGstHandleMsrIntercept!\n"));
878	return VERR_SVM_IPE_1;
879
880	case SVM_EXIT_MSR:
881	AssertMsgFailed(("Use HMSvmNstGstHandleMsrIntercept!\n"));
882	return VERR_SVM_IPE_1;
883
884	case SVM_EXIT_NPF:
885	case SVM_EXIT_AVIC_INCOMPLETE_IPI:
886	case SVM_EXIT_AVIC_NOACCEL:
887	AssertMsgFailed(("Todo Implement.\n"));
888	return VERR_SVM_IPE_1;
889
890	default:
891	AssertMsgFailed(("Unsupported SVM exit code %#RX64\n", uExitCode));
892	return VERR_SVM_IPE_1;
893	}
894
895	return VINF_HM_INTERCEPT_NOT_ACTIVE;
896
897	#undef HMSVM_CTRL_INTERCEPT_VMEXIT
898	}
899	#endif
900
901
902	/**
903	* Checks if the event intercepts and performs the \#VMEXIT if the corresponding
904	* intercept is active.
905	*
906	* @returns Strict VBox status code.
907	* @retval VINF_HM_INTERCEPT_NOT_ACTIVE if the intercept is not active or
908	* we're not executing a nested-guest.
909	* @retval VINF_SVM_VMEXIT if the intercept is active and the \#VMEXIT occurred
910	* successfully.
911	* @retval VERR_SVM_VMEXIT_FAILED if the intercept is active and the \#VMEXIT
912	* failed and a shutdown needs to be initiated for the geust.
913	*
914	* @returns VBox strict status code.
915	* @param pVCpu The cross context virtual CPU structure of the calling thread.
916	* @param u16Port The IO port being accessed.
917	* @param enmIoType The type of IO access.
918	* @param cbReg The IO operand size in bytes.
919	* @param cAddrSizeBits The address size bits (for 16, 32 or 64).
920	* @param iEffSeg The effective segment number.
921	* @param fRep Whether this is a repeating IO instruction (REP prefix).
922	* @param fStrIo Whether this is a string IO instruction.
923	*/
924	IEM_STATIC VBOXSTRICTRC iemHandleSvmEventIntercept(PVMCPU pVCpu, PCPUMCTX pCtx, uint8_t u8Vector, uint32_t fFlags, uint32_t uErr,
925	uint64_t uCr2)
926	{
927	Assert(CPUMIsGuestInSvmNestedHwVirtMode(pCtx));
928
929	/*
930	* Handle SVM exception and software interrupt intercepts, see AMD spec. 15.12 "Exception Intercepts".
931	*
932	* - NMI intercepts have their own exit code and do not cause SVM_EXIT_EXCEPTION_2 #VMEXITs.
933	* - External interrupts and software interrupts (INTn instruction) do not check the exception intercepts
934	* even when they use a vector in the range 0 to 31.
935	* - ICEBP should not trigger #DB intercept, but its own intercept.
936	* - For #PF exceptions, its intercept is checked before CR2 is written by the exception.
937	*/
938	/* Check NMI intercept */
939	if ( u8Vector == X86_XCPT_NMI
940	&& (fFlags & IEM_XCPT_FLAGS_T_CPU_XCPT)
941	&& IEM_IS_SVM_CTRL_INTERCEPT_SET(pVCpu, SVM_CTRL_INTERCEPT_NMI))
942	{
943	Log2(("iemHandleSvmNstGstEventIntercept: NMI intercept -> #VMEXIT\n"));
944	IEM_RETURN_SVM_VMEXIT(pVCpu, SVM_EXIT_NMI, 0 /* uExitInfo1 /, 0 / uExitInfo2 */);
945	}
946
947	/* Check ICEBP intercept. */
948	if ( (fFlags & IEM_XCPT_FLAGS_ICEBP_INSTR)
949	&& IEM_IS_SVM_CTRL_INTERCEPT_SET(pVCpu, SVM_CTRL_INTERCEPT_ICEBP))
950	{
951	Log2(("iemHandleSvmNstGstEventIntercept: ICEBP intercept -> #VMEXIT\n"));
952	IEM_SVM_UPDATE_NRIP(pVCpu);
953	IEM_RETURN_SVM_VMEXIT(pVCpu, SVM_EXIT_ICEBP, 0 /* uExitInfo1 /, 0 / uExitInfo2 */);
954	}
955
956	/* Check CPU exception intercepts. */
957	if ( (fFlags & IEM_XCPT_FLAGS_T_CPU_XCPT)
958	&& IEM_IS_SVM_XCPT_INTERCEPT_SET(pVCpu, u8Vector))
959	{
960	Assert(u8Vector <= X86_XCPT_LAST);
961	uint64_t const uExitInfo1 = fFlags & IEM_XCPT_FLAGS_ERR ? uErr : 0;
962	uint64_t const uExitInfo2 = fFlags & IEM_XCPT_FLAGS_CR2 ? uCr2 : 0;
963	if ( IEM_GET_GUEST_CPU_FEATURES(pVCpu)->fSvmDecodeAssists
964	&& u8Vector == X86_XCPT_PF
965	&& !(uErr & X86_TRAP_PF_ID))
966	{
967	PSVMVMCBCTRL pVmcbCtrl = &pCtx->hwvirt.svm.CTX_SUFF(pVmcb)->ctrl;
968	#ifdef IEM_WITH_CODE_TLB
969	uint8_t const *pbInstrBuf = pVCpu->iem.s.pbInstrBuf;
970	uint8_t const cbInstrBuf = pVCpu->iem.s.cbInstrBuf;
971	pVmcbCtrl->cbInstrFetched = RT_MIN(cbInstrBuf, SVM_CTRL_GUEST_INSTR_BYTES_MAX);
972	if ( pbInstrBuf
973	&& cbInstrBuf > 0)
974	memcpy(&pVmcbCtrl->abInstr[0], pbInstrBuf, pVmcbCtrl->cbInstrFetched);
975	#else
976	uint8_t const cbOpcode = pVCpu->iem.s.cbOpcode;
977	pVmcbCtrl->cbInstrFetched = RT_MIN(cbOpcode, SVM_CTRL_GUEST_INSTR_BYTES_MAX);
978	if (cbOpcode > 0)
979	memcpy(&pVmcbCtrl->abInstr[0], &pVCpu->iem.s.abOpcode[0], pVmcbCtrl->cbInstrFetched);
980	#endif
981	}
982	if (u8Vector == X86_XCPT_BR)
983	IEM_SVM_UPDATE_NRIP(pVCpu);
984	Log2(("iemHandleSvmNstGstEventIntercept: Xcpt intercept u32InterceptXcpt=%#RX32 u8Vector=%#x "
985	"uExitInfo1=%#RX64 uExitInfo2=%#RX64 -> #VMEXIT\n", pCtx->hwvirt.svm.CTX_SUFF(pVmcb)->ctrl.u32InterceptXcpt,
986	u8Vector, uExitInfo1, uExitInfo2));
987	IEM_RETURN_SVM_VMEXIT(pVCpu, SVM_EXIT_EXCEPTION_0 + u8Vector, uExitInfo1, uExitInfo2);
988	}
989
990	/* Check software interrupt (INTn) intercepts. */
991	if ( (fFlags & ( IEM_XCPT_FLAGS_T_SOFT_INT
992	\| IEM_XCPT_FLAGS_BP_INSTR
993	\| IEM_XCPT_FLAGS_ICEBP_INSTR
994	\| IEM_XCPT_FLAGS_OF_INSTR)) == IEM_XCPT_FLAGS_T_SOFT_INT
995	&& IEM_IS_SVM_CTRL_INTERCEPT_SET(pVCpu, SVM_CTRL_INTERCEPT_INTN))
996	{
997	uint64_t const uExitInfo1 = IEM_GET_GUEST_CPU_FEATURES(pVCpu)->fSvmDecodeAssists ? u8Vector : 0;
998	Log2(("iemHandleSvmNstGstEventIntercept: Software INT intercept (u8Vector=%#x) -> #VMEXIT\n", u8Vector));
999	IEM_SVM_UPDATE_NRIP(pVCpu);
1000	IEM_RETURN_SVM_VMEXIT(pVCpu, SVM_EXIT_SWINT, uExitInfo1, 0 /* uExitInfo2 */);
1001	}
1002
1003	return VINF_HM_INTERCEPT_NOT_ACTIVE;
1004	}
1005
1006
1007	/**
1008	* Checks the SVM IO permission bitmap and performs the \#VMEXIT if the
1009	* corresponding intercept is active.
1010	*
1011	* @returns Strict VBox status code.
1012	* @retval VINF_HM_INTERCEPT_NOT_ACTIVE if the intercept is not active or
1013	* we're not executing a nested-guest.
1014	* @retval VINF_SVM_VMEXIT if the intercept is active and the \#VMEXIT occurred
1015	* successfully.
1016	* @retval VERR_SVM_VMEXIT_FAILED if the intercept is active and the \#VMEXIT
1017	* failed and a shutdown needs to be initiated for the geust.
1018	*
1019	* @returns VBox strict status code.
1020	* @param pVCpu The cross context virtual CPU structure of the calling thread.
1021	* @param u16Port The IO port being accessed.
1022	* @param enmIoType The type of IO access.
1023	* @param cbReg The IO operand size in bytes.
1024	* @param cAddrSizeBits The address size bits (for 16, 32 or 64).
1025	* @param iEffSeg The effective segment number.
1026	* @param fRep Whether this is a repeating IO instruction (REP prefix).
1027	* @param fStrIo Whether this is a string IO instruction.
1028	* @param cbInstr The length of the IO instruction in bytes.
1029	*/
1030	IEM_STATIC VBOXSTRICTRC iemSvmHandleIOIntercept(PVMCPU pVCpu, uint16_t u16Port, SVMIOIOTYPE enmIoType, uint8_t cbReg,
1031	uint8_t cAddrSizeBits, uint8_t iEffSeg, bool fRep, bool fStrIo, uint8_t cbInstr)
1032	{
1033	Assert(IEM_IS_SVM_CTRL_INTERCEPT_SET(pVCpu, SVM_CTRL_INTERCEPT_IOIO_PROT));
1034	Assert(cAddrSizeBits == 16 \|\| cAddrSizeBits == 32 \|\| cAddrSizeBits == 64);
1035	Assert(cbReg == 1 \|\| cbReg == 2 \|\| cbReg == 4 \|\| cbReg == 8);
1036
1037	Log3(("iemSvmHandleIOIntercept: u16Port=%#x (%u)\n", u16Port, u16Port));
1038
1039	SVMIOIOEXITINFO IoExitInfo;
1040	PCPUMCTX pCtx = IEM_GET_CTX(pVCpu);
1041	void *pvIoBitmap = pCtx->hwvirt.svm.CTX_SUFF(pvIoBitmap);
1042	bool const fIntercept = HMSvmIsIOInterceptActive(pvIoBitmap, u16Port, enmIoType, cbReg, cAddrSizeBits, iEffSeg, fRep, fStrIo,
1043	&IoExitInfo);
1044	if (fIntercept)
1045	{
1046	Log3(("iemSvmHandleIOIntercept: u16Port=%#x (%u) -> #VMEXIT\n", u16Port, u16Port));
1047	IEM_SVM_UPDATE_NRIP(pVCpu);
1048	return iemSvmVmexit(pVCpu, pCtx, SVM_EXIT_IOIO, IoExitInfo.u, pCtx->rip + cbInstr);
1049	}
1050
1051	/** @todo remove later (for debugging as VirtualBox always traps all IO
1052	* intercepts). */
1053	AssertMsgFailed(("iemSvmHandleIOIntercept: We expect an IO intercept here!\n"));
1054	return VINF_HM_INTERCEPT_NOT_ACTIVE;
1055	}
1056
1057
1058	/**
1059	* Checks the SVM MSR permission bitmap and performs the \#VMEXIT if the
1060	* corresponding intercept is active.
1061	*
1062	* @returns Strict VBox status code.
1063	* @retval VINF_HM_INTERCEPT_NOT_ACTIVE if the MSR permission bitmap does not
1064	* specify interception of the accessed MSR @a idMsr.
1065	* @retval VINF_SVM_VMEXIT if the intercept is active and the \#VMEXIT occurred
1066	* successfully.
1067	* @retval VERR_SVM_VMEXIT_FAILED if the intercept is active and the \#VMEXIT
1068	* failed and a shutdown needs to be initiated for the geust.
1069	*
1070	* @param pVCpu The cross context virtual CPU structure.
1071	* @param pCtx The guest-CPU context.
1072	* @param idMsr The MSR being accessed in the nested-guest.
1073	* @param fWrite Whether this is an MSR write access, @c false implies an
1074	* MSR read.
1075	* @param cbInstr The length of the MSR read/write instruction in bytes.
1076	*/
1077	IEM_STATIC VBOXSTRICTRC iemSvmHandleMsrIntercept(PVMCPU pVCpu, PCPUMCTX pCtx, uint32_t idMsr, bool fWrite)
1078	{
1079	/*
1080	* Check if any MSRs are being intercepted.
1081	*/
1082	Assert(CPUMIsGuestSvmCtrlInterceptSet(pVCpu, pCtx, SVM_CTRL_INTERCEPT_MSR_PROT));
1083	Assert(CPUMIsGuestInSvmNestedHwVirtMode(pCtx));
1084
1085	uint64_t const uExitInfo1 = fWrite ? SVM_EXIT1_MSR_WRITE : SVM_EXIT1_MSR_READ;
1086
1087	/*
1088	* Get the byte and bit offset of the permission bits corresponding to the MSR.
1089	*/
1090	uint16_t offMsrpm;
1091	uint32_t uMsrpmBit;
1092	int rc = HMSvmGetMsrpmOffsetAndBit(idMsr, &offMsrpm, &uMsrpmBit);
1093	if (RT_SUCCESS(rc))
1094	{
1095	Assert(uMsrpmBit < 0x3fff);
1096	Assert(offMsrpm < SVM_MSRPM_PAGES << X86_PAGE_4K_SHIFT);
1097	if (fWrite)
1098	++uMsrpmBit;
1099
1100	/*
1101	* Check if the bit is set, if so, trigger a #VMEXIT.
1102	*/
1103	uint8_t pbMsrpm = (uint8_t )pCtx->hwvirt.svm.CTX_SUFF(pvMsrBitmap);
1104	pbMsrpm += offMsrpm;
1105	if (ASMBitTest(pbMsrpm, uMsrpmBit))
1106	{
1107	IEM_SVM_UPDATE_NRIP(pVCpu);
1108	return iemSvmVmexit(pVCpu, pCtx, SVM_EXIT_MSR, uExitInfo1, 0 /* uExitInfo2 */);
1109	}
1110	}
1111	else
1112	{
1113	/*
1114	* This shouldn't happen, but if it does, cause a #VMEXIT and let the "host" (guest hypervisor) deal with it.
1115	*/
1116	Log(("iemSvmHandleMsrIntercept: Invalid/out-of-range MSR %#RX32 fWrite=%RTbool -> #VMEXIT\n", idMsr, fWrite));
1117	return iemSvmVmexit(pVCpu, pCtx, SVM_EXIT_MSR, uExitInfo1, 0 /* uExitInfo2 */);
1118	}
1119	return VINF_HM_INTERCEPT_NOT_ACTIVE;
1120	}
1121
1122
1123
1124	/**
1125	* Implements 'VMRUN'.
1126	*/
1127	IEM_CIMPL_DEF_0(iemCImpl_vmrun)
1128	{
1129	#if defined(VBOX_WITH_NESTED_HWVIRT_ONLY_IN_IEM) && !defined(IN_RING3)
1130	RT_NOREF2(pVCpu, cbInstr);
1131	return VINF_EM_RAW_EMULATE_INSTR;
1132	#else
1133	LogFlow(("iemCImpl_vmrun\n"));
1134	PCPUMCTX pCtx = IEM_GET_CTX(pVCpu);
1135	IEM_SVM_INSTR_COMMON_CHECKS(pVCpu, vmrun);
1136
1137	/** @todo Check effective address size using address size prefix. */
1138	RTGCPHYS const GCPhysVmcb = pVCpu->iem.s.enmCpuMode == IEMMODE_64BIT ? pCtx->rax : pCtx->eax;
1139	if ( (GCPhysVmcb & X86_PAGE_4K_OFFSET_MASK)
1140	\|\| !PGMPhysIsGCPhysNormal(pVCpu->CTX_SUFF(pVM), GCPhysVmcb))
1141	{
1142	Log(("vmrun: VMCB physaddr (%#RGp) not valid -> #GP(0)\n", GCPhysVmcb));
1143	return iemRaiseGeneralProtectionFault0(pVCpu);
1144	}
1145
1146	if (IEM_IS_SVM_CTRL_INTERCEPT_SET(pVCpu, SVM_CTRL_INTERCEPT_VMRUN))
1147	{
1148	Log(("vmrun: Guest intercept -> #VMEXIT\n"));
1149	IEM_RETURN_SVM_VMEXIT(pVCpu, SVM_EXIT_VMRUN, 0 /* uExitInfo1 /, 0 / uExitInfo2 */);
1150	}
1151
1152	VBOXSTRICTRC rcStrict = iemSvmVmrun(pVCpu, pCtx, cbInstr, GCPhysVmcb);
1153	if (rcStrict == VERR_SVM_VMEXIT_FAILED)
1154	{
1155	Assert(!CPUMIsGuestInSvmNestedHwVirtMode(pCtx));
1156	rcStrict = VINF_EM_TRIPLE_FAULT;
1157	}
1158	return rcStrict;
1159	#endif
1160	}
1161
1162
1163	/**
1164	* Implements 'VMMCALL'.
1165	*/
1166	IEM_CIMPL_DEF_0(iemCImpl_vmmcall)
1167	{
1168	PCPUMCTX pCtx = IEM_GET_CTX(pVCpu);
1169	if (IEM_IS_SVM_CTRL_INTERCEPT_SET(pVCpu, SVM_CTRL_INTERCEPT_VMMCALL))
1170	{
1171	Log(("vmmcall: Guest intercept -> #VMEXIT\n"));
1172	IEM_RETURN_SVM_VMEXIT(pVCpu, SVM_EXIT_VMMCALL, 0 /* uExitInfo1 /, 0 / uExitInfo2 */);
1173	}
1174
1175	bool fUpdatedRipAndRF;
1176	VBOXSTRICTRC rcStrict = HMSvmVmmcall(pVCpu, pCtx, &fUpdatedRipAndRF);
1177	if (RT_SUCCESS(rcStrict))
1178	{
1179	if (!fUpdatedRipAndRF)
1180	iemRegAddToRipAndClearRF(pVCpu, cbInstr);
1181	return rcStrict;
1182	}
1183
1184	return iemRaiseUndefinedOpcode(pVCpu);
1185	}
1186
1187
1188	/**
1189	* Implements 'VMLOAD'.
1190	*/
1191	IEM_CIMPL_DEF_0(iemCImpl_vmload)
1192	{
1193	#if defined(VBOX_WITH_NESTED_HWVIRT_ONLY_IN_IEM) && !defined(IN_RING3)
1194	RT_NOREF2(pVCpu, cbInstr);
1195	return VINF_EM_RAW_EMULATE_INSTR;
1196	#else
1197	LogFlow(("iemCImpl_vmload\n"));
1198	PCPUMCTX pCtx = IEM_GET_CTX(pVCpu);
1199	IEM_SVM_INSTR_COMMON_CHECKS(pVCpu, vmload);
1200
1201	/** @todo Check effective address size using address size prefix. */
1202	RTGCPHYS const GCPhysVmcb = pVCpu->iem.s.enmCpuMode == IEMMODE_64BIT ? pCtx->rax : pCtx->eax;
1203	if ( (GCPhysVmcb & X86_PAGE_4K_OFFSET_MASK)
1204	\|\| !PGMPhysIsGCPhysNormal(pVCpu->CTX_SUFF(pVM), GCPhysVmcb))
1205	{
1206	Log(("vmload: VMCB physaddr (%#RGp) not valid -> #GP(0)\n", GCPhysVmcb));
1207	return iemRaiseGeneralProtectionFault0(pVCpu);
1208	}
1209
1210	if (IEM_IS_SVM_CTRL_INTERCEPT_SET(pVCpu, SVM_CTRL_INTERCEPT_VMLOAD))
1211	{
1212	Log(("vmload: Guest intercept -> #VMEXIT\n"));
1213	IEM_RETURN_SVM_VMEXIT(pVCpu, SVM_EXIT_VMLOAD, 0 /* uExitInfo1 /, 0 / uExitInfo2 */);
1214	}
1215
1216	SVMVMCBSTATESAVE VmcbNstGst;
1217	VBOXSTRICTRC rcStrict = PGMPhysSimpleReadGCPhys(pVCpu->CTX_SUFF(pVM), &VmcbNstGst, GCPhysVmcb + RT_OFFSETOF(SVMVMCB, guest),
1218	sizeof(SVMVMCBSTATESAVE));
1219	if (rcStrict == VINF_SUCCESS)
1220	{
1221	LogFlow(("vmload: Loading VMCB at %#RGp enmEffAddrMode=%d\n", GCPhysVmcb, pVCpu->iem.s.enmEffAddrMode));
1222	HMSVM_SEG_REG_COPY_FROM_VMCB(pCtx, &VmcbNstGst, FS, fs);
1223	HMSVM_SEG_REG_COPY_FROM_VMCB(pCtx, &VmcbNstGst, GS, gs);
1224	HMSVM_SEG_REG_COPY_FROM_VMCB(pCtx, &VmcbNstGst, TR, tr);
1225	HMSVM_SEG_REG_COPY_FROM_VMCB(pCtx, &VmcbNstGst, LDTR, ldtr);
1226
1227	pCtx->msrKERNELGSBASE = VmcbNstGst.u64KernelGSBase;
1228	pCtx->msrSTAR = VmcbNstGst.u64STAR;
1229	pCtx->msrLSTAR = VmcbNstGst.u64LSTAR;
1230	pCtx->msrCSTAR = VmcbNstGst.u64CSTAR;
1231	pCtx->msrSFMASK = VmcbNstGst.u64SFMASK;
1232
1233	pCtx->SysEnter.cs = VmcbNstGst.u64SysEnterCS;
1234	pCtx->SysEnter.esp = VmcbNstGst.u64SysEnterESP;
1235	pCtx->SysEnter.eip = VmcbNstGst.u64SysEnterEIP;
1236
1237	iemRegAddToRipAndClearRF(pVCpu, cbInstr);
1238	}
1239	return rcStrict;
1240	#endif
1241	}
1242
1243
1244	/**
1245	* Implements 'VMSAVE'.
1246	*/
1247	IEM_CIMPL_DEF_0(iemCImpl_vmsave)
1248	{
1249	#if defined(VBOX_WITH_NESTED_HWVIRT_ONLY_IN_IEM) && !defined(IN_RING3)
1250	RT_NOREF2(pVCpu, cbInstr);
1251	return VINF_EM_RAW_EMULATE_INSTR;
1252	#else
1253	LogFlow(("iemCImpl_vmsave\n"));
1254	PCPUMCTX pCtx = IEM_GET_CTX(pVCpu);
1255	IEM_SVM_INSTR_COMMON_CHECKS(pVCpu, vmsave);
1256
1257	/** @todo Check effective address size using address size prefix. */
1258	RTGCPHYS const GCPhysVmcb = pVCpu->iem.s.enmCpuMode == IEMMODE_64BIT ? pCtx->rax : pCtx->eax;
1259	if ( (GCPhysVmcb & X86_PAGE_4K_OFFSET_MASK)
1260	\|\| !PGMPhysIsGCPhysNormal(pVCpu->CTX_SUFF(pVM), GCPhysVmcb))
1261	{
1262	Log(("vmsave: VMCB physaddr (%#RGp) not valid -> #GP(0)\n", GCPhysVmcb));
1263	return iemRaiseGeneralProtectionFault0(pVCpu);
1264	}
1265
1266	if (IEM_IS_SVM_CTRL_INTERCEPT_SET(pVCpu, SVM_CTRL_INTERCEPT_VMSAVE))
1267	{
1268	Log(("vmsave: Guest intercept -> #VMEXIT\n"));
1269	IEM_RETURN_SVM_VMEXIT(pVCpu, SVM_EXIT_VMSAVE, 0 /* uExitInfo1 /, 0 / uExitInfo2 */);
1270	}
1271
1272	SVMVMCBSTATESAVE VmcbNstGst;
1273	VBOXSTRICTRC rcStrict = PGMPhysSimpleReadGCPhys(pVCpu->CTX_SUFF(pVM), &VmcbNstGst, GCPhysVmcb + RT_OFFSETOF(SVMVMCB, guest),
1274	sizeof(SVMVMCBSTATESAVE));
1275	if (rcStrict == VINF_SUCCESS)
1276	{
1277	LogFlow(("vmsave: Saving VMCB at %#RGp enmEffAddrMode=%d\n", GCPhysVmcb, pVCpu->iem.s.enmEffAddrMode));
1278	HMSVM_SEG_REG_COPY_TO_VMCB(pCtx, &VmcbNstGst, FS, fs);
1279	HMSVM_SEG_REG_COPY_TO_VMCB(pCtx, &VmcbNstGst, GS, gs);
1280	HMSVM_SEG_REG_COPY_TO_VMCB(pCtx, &VmcbNstGst, TR, tr);
1281	HMSVM_SEG_REG_COPY_TO_VMCB(pCtx, &VmcbNstGst, LDTR, ldtr);
1282
1283	VmcbNstGst.u64KernelGSBase = pCtx->msrKERNELGSBASE;
1284	VmcbNstGst.u64STAR = pCtx->msrSTAR;
1285	VmcbNstGst.u64LSTAR = pCtx->msrLSTAR;
1286	VmcbNstGst.u64CSTAR = pCtx->msrCSTAR;
1287	VmcbNstGst.u64SFMASK = pCtx->msrSFMASK;
1288
1289	VmcbNstGst.u64SysEnterCS = pCtx->SysEnter.cs;
1290	VmcbNstGst.u64SysEnterESP = pCtx->SysEnter.esp;
1291	VmcbNstGst.u64SysEnterEIP = pCtx->SysEnter.eip;
1292
1293	rcStrict = PGMPhysSimpleWriteGCPhys(pVCpu->CTX_SUFF(pVM), GCPhysVmcb + RT_OFFSETOF(SVMVMCB, guest), &VmcbNstGst,
1294	sizeof(SVMVMCBSTATESAVE));
1295	if (rcStrict == VINF_SUCCESS)
1296	iemRegAddToRipAndClearRF(pVCpu, cbInstr);
1297	}
1298	return rcStrict;
1299	#endif
1300	}
1301
1302
1303	/**
1304	* Implements 'CLGI'.
1305	*/
1306	IEM_CIMPL_DEF_0(iemCImpl_clgi)
1307	{
1308	#if defined(VBOX_WITH_NESTED_HWVIRT_ONLY_IN_IEM) && !defined(IN_RING3)
1309	RT_NOREF2(pVCpu, cbInstr);
1310	return VINF_EM_RAW_EMULATE_INSTR;
1311	#else
1312	LogFlow(("iemCImpl_clgi\n"));
1313	PCPUMCTX pCtx = IEM_GET_CTX(pVCpu);
1314	IEM_SVM_INSTR_COMMON_CHECKS(pVCpu, clgi);
1315	if (IEM_IS_SVM_CTRL_INTERCEPT_SET(pVCpu, SVM_CTRL_INTERCEPT_CLGI))
1316	{
1317	Log(("clgi: Guest intercept -> #VMEXIT\n"));
1318	IEM_RETURN_SVM_VMEXIT(pVCpu, SVM_EXIT_CLGI, 0 /* uExitInfo1 /, 0 / uExitInfo2 */);
1319	}
1320
1321	pCtx->hwvirt.fGif = false;
1322	iemRegAddToRipAndClearRF(pVCpu, cbInstr);
1323
1324	# if defined(VBOX_WITH_NESTED_HWVIRT_ONLY_IN_IEM) && defined(IN_RING3)
1325	return EMR3SetExecutionPolicy(pVCpu->CTX_SUFF(pVM)->pUVM, EMEXECPOLICY_IEM_ALL, true);
1326	# else
1327	return VINF_SUCCESS;
1328	# endif
1329	#endif
1330	}
1331
1332
1333	/**
1334	* Implements 'STGI'.
1335	*/
1336	IEM_CIMPL_DEF_0(iemCImpl_stgi)
1337	{
1338	#if defined(VBOX_WITH_NESTED_HWVIRT_ONLY_IN_IEM) && !defined(IN_RING3)
1339	RT_NOREF2(pVCpu, cbInstr);
1340	return VINF_EM_RAW_EMULATE_INSTR;
1341	#else
1342	LogFlow(("iemCImpl_stgi\n"));
1343	PCPUMCTX pCtx = IEM_GET_CTX(pVCpu);
1344	IEM_SVM_INSTR_COMMON_CHECKS(pVCpu, stgi);
1345	if (IEM_IS_SVM_CTRL_INTERCEPT_SET(pVCpu, SVM_CTRL_INTERCEPT_STGI))
1346	{
1347	Log2(("stgi: Guest intercept -> #VMEXIT\n"));
1348	IEM_RETURN_SVM_VMEXIT(pVCpu, SVM_EXIT_STGI, 0 /* uExitInfo1 /, 0 / uExitInfo2 */);
1349	}
1350
1351	pCtx->hwvirt.fGif = true;
1352	iemRegAddToRipAndClearRF(pVCpu, cbInstr);
1353
1354	# if defined(VBOX_WITH_NESTED_HWVIRT_ONLY_IN_IEM) && defined(IN_RING3)
1355	return EMR3SetExecutionPolicy(pVCpu->CTX_SUFF(pVM)->pUVM, EMEXECPOLICY_IEM_ALL, false);
1356	# else
1357	return VINF_SUCCESS;
1358	# endif
1359	#endif
1360	}
1361
1362
1363	/**
1364	* Implements 'INVLPGA'.
1365	*/
1366	IEM_CIMPL_DEF_0(iemCImpl_invlpga)
1367	{
1368	PCPUMCTX pCtx = IEM_GET_CTX(pVCpu);
1369	/** @todo Check effective address size using address size prefix. */
1370	RTGCPTR const GCPtrPage = pVCpu->iem.s.enmCpuMode == IEMMODE_64BIT ? pCtx->rax : pCtx->eax;
1371	/** @todo PGM needs virtual ASID support. */
1372	#if 0
1373	uint32_t const uAsid = pCtx->ecx;
1374	#endif
1375
1376	IEM_SVM_INSTR_COMMON_CHECKS(pVCpu, invlpga);
1377	if (IEM_IS_SVM_CTRL_INTERCEPT_SET(pVCpu, SVM_CTRL_INTERCEPT_INVLPGA))
1378	{
1379	Log2(("invlpga: Guest intercept (%RGp) -> #VMEXIT\n", GCPtrPage));
1380	IEM_RETURN_SVM_VMEXIT(pVCpu, SVM_EXIT_INVLPGA, 0 /* uExitInfo1 /, 0 / uExitInfo2 */);
1381	}
1382
1383	PGMInvalidatePage(pVCpu, GCPtrPage);
1384	iemRegAddToRipAndClearRF(pVCpu, cbInstr);
1385	return VINF_SUCCESS;
1386	}
1387
1388
1389	/**
1390	* Implements 'SKINIT'.
1391	*/
1392	IEM_CIMPL_DEF_0(iemCImpl_skinit)
1393	{
1394	IEM_SVM_INSTR_COMMON_CHECKS(pVCpu, invlpga);
1395
1396	uint32_t uIgnore;
1397	uint32_t fFeaturesECX;
1398	CPUMGetGuestCpuId(pVCpu, 0x80000001, 0 /* iSubLeaf */, &uIgnore, &uIgnore, &fFeaturesECX, &uIgnore);
1399	if (!(fFeaturesECX & X86_CPUID_AMD_FEATURE_ECX_SKINIT))
1400	return iemRaiseUndefinedOpcode(pVCpu);
1401
1402	if (IEM_IS_SVM_CTRL_INTERCEPT_SET(pVCpu, SVM_CTRL_INTERCEPT_SKINIT))
1403	{
1404	Log2(("skinit: Guest intercept -> #VMEXIT\n"));
1405	IEM_RETURN_SVM_VMEXIT(pVCpu, SVM_EXIT_SKINIT, 0 /* uExitInfo1 /, 0 / uExitInfo2 */);
1406	}
1407
1408	RT_NOREF(cbInstr);
1409	return VERR_IEM_INSTR_NOT_IMPLEMENTED;
1410	}
1411

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

source: vbox/trunk/src/VBox/VMM/VMMAll/IEMAllCImplSvmInstr.cpp.h@ 71416

Download in other formats: