VirtualBox

source: vbox/trunk/src/VBox/VMM/VMMR0/HWVMXR0.cpp@ 22309

Last change on this file since 22309 was 22257, checked in by vboxsync, 15 years ago

Guestimate too high; was still seeing decreasing rdtsc values
  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 187.4 KB
Line 
1/* $Id: HWVMXR0.cpp 22257 2009-08-14 12:45:12Z vboxsync $ */
2/** @file
3 * HWACCM VMX - Host Context Ring 0.
4 */
5
6/*
7 * Copyright (C) 2006-2007 Sun Microsystems, Inc.
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 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
18 * Clara, CA 95054 USA or visit http://www.sun.com if you need
19 * additional information or have any questions.
20 */
21
22
23/*******************************************************************************
24* Header Files *
25*******************************************************************************/
26#define LOG_GROUP LOG_GROUP_HWACCM
27#include <VBox/hwaccm.h>
28#include "HWACCMInternal.h"
29#include <VBox/vm.h>
30#include <VBox/x86.h>
31#include <VBox/pgm.h>
32#include <VBox/pdm.h>
33#include <VBox/err.h>
34#include <VBox/log.h>
35#include <VBox/selm.h>
36#include <VBox/iom.h>
37#include <VBox/rem.h>
38#include <iprt/asm.h>
39#include <iprt/assert.h>
40#include <iprt/param.h>
41#include <iprt/string.h>
42#include <iprt/time.h>
43#ifdef VBOX_WITH_VMMR0_DISABLE_PREEMPTION
44# include <iprt/thread.h>
45#endif
46#include "HWVMXR0.h"
47
48/*******************************************************************************
49* Defined Constants And Macros *
50*******************************************************************************/
51#if defined(RT_ARCH_AMD64)
52# define VMX_IS_64BIT_HOST_MODE() (true)
53#elif defined(VBOX_WITH_HYBRID_32BIT_KERNEL)
54# define VMX_IS_64BIT_HOST_MODE() (g_fVMXIs64bitHost != 0)
55#else
56# define VMX_IS_64BIT_HOST_MODE() (false)
57#endif
58
59/*******************************************************************************
60* Global Variables *
61*******************************************************************************/
62/* IO operation lookup arrays. */
63static uint32_t const g_aIOSize[4] = {1, 2, 0, 4};
64static uint32_t const g_aIOOpAnd[4] = {0xff, 0xffff, 0, 0xffffffff};
65
66#ifdef VBOX_WITH_HYBRID_32BIT_KERNEL
67/** See HWACCMR0A.asm. */
68extern "C" uint32_t g_fVMXIs64bitHost;
69#endif
70
71/*******************************************************************************
72* Local Functions *
73*******************************************************************************/
74static void VMXR0ReportWorldSwitchError(PVM pVM, PVMCPU pVCpu, int rc, PCPUMCTX pCtx);
75static void vmxR0SetupTLBEPT(PVM pVM, PVMCPU pVCpu);
76static void vmxR0SetupTLBVPID(PVM pVM, PVMCPU pVCpu);
77static void vmxR0SetupTLBDummy(PVM pVM, PVMCPU pVCpu);
78static void vmxR0FlushEPT(PVM pVM, PVMCPU pVCpu, VMX_FLUSH enmFlush, RTGCPHYS GCPhys);
79static void vmxR0FlushVPID(PVM pVM, PVMCPU pVCpu, VMX_FLUSH enmFlush, RTGCPTR GCPtr);
80static void vmxR0UpdateExceptionBitmap(PVM pVM, PVMCPU pVCpu, PCPUMCTX pCtx);
81#ifdef VBOX_STRICT
82static bool vmxR0IsValidReadField(uint32_t idxField);
83static bool vmxR0IsValidWriteField(uint32_t idxField);
84#endif
85static void vmxR0SetMSRPermission(PVMCPU pVCpu, unsigned ulMSR, bool fRead, bool fWrite);
86
87static void VMXR0CheckError(PVM pVM, PVMCPU pVCpu, int rc)
88{
89 if (rc == VERR_VMX_GENERIC)
90 {
91 RTCCUINTREG instrError;
92
93 VMXReadVMCS(VMX_VMCS32_RO_VM_INSTR_ERROR, &instrError);
94 pVCpu->hwaccm.s.vmx.lasterror.ulInstrError = instrError;
95 }
96 pVM->hwaccm.s.lLastError = rc;
97}
98
99/**
100 * Sets up and activates VT-x on the current CPU
101 *
102 * @returns VBox status code.
103 * @param pCpu CPU info struct
104 * @param pVM The VM to operate on. (can be NULL after a resume!!)
105 * @param pvPageCpu Pointer to the global cpu page
106 * @param pPageCpuPhys Physical address of the global cpu page
107 */
108VMMR0DECL(int) VMXR0EnableCpu(PHWACCM_CPUINFO pCpu, PVM pVM, void *pvPageCpu, RTHCPHYS pPageCpuPhys)
109{
110 AssertReturn(pPageCpuPhys, VERR_INVALID_PARAMETER);
111 AssertReturn(pvPageCpu, VERR_INVALID_PARAMETER);
112
113#if defined(LOG_ENABLED) && !defined(DEBUG_bird)
114 SUPR0Printf("VMXR0EnableCpu cpu %d page (%x) %x\n", pCpu->idCpu, pvPageCpu, (uint32_t)pPageCpuPhys);
115#endif
116 if (pVM)
117 {
118 /* Set revision dword at the beginning of the VMXON structure. */
119 *(uint32_t *)pvPageCpu = MSR_IA32_VMX_BASIC_INFO_VMCS_ID(pVM->hwaccm.s.vmx.msr.vmx_basic_info);
120 }
121
122 /** @todo we should unmap the two pages from the virtual address space in order to prevent accidental corruption.
123 * (which can have very bad consequences!!!)
124 */
125
126 /* Make sure the VMX instructions don't cause #UD faults. */
127 ASMSetCR4(ASMGetCR4() | X86_CR4_VMXE);
128
129 /* Enter VMX Root Mode */
130 int rc = VMXEnable(pPageCpuPhys);
131 if (RT_FAILURE(rc))
132 {
133 if (pVM)
134 VMXR0CheckError(pVM, &pVM->aCpus[0], rc);
135 ASMSetCR4(ASMGetCR4() & ~X86_CR4_VMXE);
136 return VERR_VMX_VMXON_FAILED;
137 }
138 return VINF_SUCCESS;
139}
140
141/**
142 * Deactivates VT-x on the current CPU
143 *
144 * @returns VBox status code.
145 * @param pCpu CPU info struct
146 * @param pvPageCpu Pointer to the global cpu page
147 * @param pPageCpuPhys Physical address of the global cpu page
148 */
149VMMR0DECL(int) VMXR0DisableCpu(PHWACCM_CPUINFO pCpu, void *pvPageCpu, RTHCPHYS pPageCpuPhys)
150{
151 AssertReturn(pPageCpuPhys, VERR_INVALID_PARAMETER);
152 AssertReturn(pvPageCpu, VERR_INVALID_PARAMETER);
153
154 /* Leave VMX Root Mode. */
155 VMXDisable();
156
157 /* And clear the X86_CR4_VMXE bit */
158 ASMSetCR4(ASMGetCR4() & ~X86_CR4_VMXE);
159
160#if defined(LOG_ENABLED) && !defined(DEBUG_bird)
161 SUPR0Printf("VMXR0DisableCpu cpu %d\n", pCpu->idCpu);
162#endif
163 return VINF_SUCCESS;
164}
165
166/**
167 * Does Ring-0 per VM VT-x init.
168 *
169 * @returns VBox status code.
170 * @param pVM The VM to operate on.
171 */
172VMMR0DECL(int) VMXR0InitVM(PVM pVM)
173{
174 int rc;
175
176#ifdef LOG_ENABLED
177 SUPR0Printf("VMXR0InitVM %x\n", pVM);
178#endif
179
180 pVM->hwaccm.s.vmx.pMemObjAPIC = NIL_RTR0MEMOBJ;
181
182 if (pVM->hwaccm.s.vmx.msr.vmx_proc_ctls.n.allowed1 & VMX_VMCS_CTRL_PROC_EXEC_CONTROLS_USE_TPR_SHADOW)
183 {
184 /* Allocate one page for the APIC physical page (serves for filtering accesses). */
185 rc = RTR0MemObjAllocCont(&pVM->hwaccm.s.vmx.pMemObjAPIC, 1 << PAGE_SHIFT, true /* executable R0 mapping */);
186 AssertRC(rc);
187 if (RT_FAILURE(rc))
188 return rc;
189
190 pVM->hwaccm.s.vmx.pAPIC = (uint8_t *)RTR0MemObjAddress(pVM->hwaccm.s.vmx.pMemObjAPIC);
191 pVM->hwaccm.s.vmx.pAPICPhys = RTR0MemObjGetPagePhysAddr(pVM->hwaccm.s.vmx.pMemObjAPIC, 0);
192 ASMMemZero32(pVM->hwaccm.s.vmx.pAPIC, PAGE_SIZE);
193 }
194 else
195 {
196 pVM->hwaccm.s.vmx.pMemObjAPIC = 0;
197 pVM->hwaccm.s.vmx.pAPIC = 0;
198 pVM->hwaccm.s.vmx.pAPICPhys = 0;
199 }
200
201#ifdef VBOX_WITH_CRASHDUMP_MAGIC
202 {
203 rc = RTR0MemObjAllocCont(&pVM->hwaccm.s.vmx.pMemObjScratch, 1 << PAGE_SHIFT, true /* executable R0 mapping */);
204 AssertRC(rc);
205 if (RT_FAILURE(rc))
206 return rc;
207
208 pVM->hwaccm.s.vmx.pScratch = (uint8_t *)RTR0MemObjAddress(pVM->hwaccm.s.vmx.pMemObjScratch);
209 pVM->hwaccm.s.vmx.pScratchPhys = RTR0MemObjGetPagePhysAddr(pVM->hwaccm.s.vmx.pMemObjScratch, 0);
210
211 ASMMemZero32(pVM->hwaccm.s.vmx.pScratch, PAGE_SIZE);
212 strcpy((char *)pVM->hwaccm.s.vmx.pScratch, "SCRATCH Magic");
213 *(uint64_t *)(pVM->hwaccm.s.vmx.pScratch + 16) = UINT64_C(0xDEADBEEFDEADBEEF);
214 }
215#endif
216
217 /* Allocate VMCBs for all guest CPUs. */
218 for (unsigned i=0;i<pVM->cCPUs;i++)
219 {
220 PVMCPU pVCpu = &pVM->aCpus[i];
221
222 pVCpu->hwaccm.s.vmx.pMemObjVMCS = NIL_RTR0MEMOBJ;
223
224 /* Allocate one page for the VM control structure (VMCS). */
225 rc = RTR0MemObjAllocCont(&pVCpu->hwaccm.s.vmx.pMemObjVMCS, 1 << PAGE_SHIFT, true /* executable R0 mapping */);
226 AssertRC(rc);
227 if (RT_FAILURE(rc))
228 return rc;
229
230 pVCpu->hwaccm.s.vmx.pVMCS = RTR0MemObjAddress(pVCpu->hwaccm.s.vmx.pMemObjVMCS);
231 pVCpu->hwaccm.s.vmx.pVMCSPhys = RTR0MemObjGetPagePhysAddr(pVCpu->hwaccm.s.vmx.pMemObjVMCS, 0);
232 ASMMemZero32(pVCpu->hwaccm.s.vmx.pVMCS, PAGE_SIZE);
233
234 pVCpu->hwaccm.s.vmx.cr0_mask = 0;
235 pVCpu->hwaccm.s.vmx.cr4_mask = 0;
236
237 /* Allocate one page for the virtual APIC page for TPR caching. */
238 rc = RTR0MemObjAllocCont(&pVCpu->hwaccm.s.vmx.pMemObjVAPIC, 1 << PAGE_SHIFT, true /* executable R0 mapping */);
239 AssertRC(rc);
240 if (RT_FAILURE(rc))
241 return rc;
242
243 pVCpu->hwaccm.s.vmx.pVAPIC = (uint8_t *)RTR0MemObjAddress(pVCpu->hwaccm.s.vmx.pMemObjVAPIC);
244 pVCpu->hwaccm.s.vmx.pVAPICPhys = RTR0MemObjGetPagePhysAddr(pVCpu->hwaccm.s.vmx.pMemObjVAPIC, 0);
245 ASMMemZero32(pVCpu->hwaccm.s.vmx.pVAPIC, PAGE_SIZE);
246
247 /* Allocate the MSR bitmap if this feature is supported. */
248 if (pVM->hwaccm.s.vmx.msr.vmx_proc_ctls.n.allowed1 & VMX_VMCS_CTRL_PROC_EXEC_CONTROLS_USE_MSR_BITMAPS)
249 {
250 rc = RTR0MemObjAllocCont(&pVCpu->hwaccm.s.vmx.pMemObjMSRBitmap, 1 << PAGE_SHIFT, true /* executable R0 mapping */);
251 AssertRC(rc);
252 if (RT_FAILURE(rc))
253 return rc;
254
255 pVCpu->hwaccm.s.vmx.pMSRBitmap = (uint8_t *)RTR0MemObjAddress(pVCpu->hwaccm.s.vmx.pMemObjMSRBitmap);
256 pVCpu->hwaccm.s.vmx.pMSRBitmapPhys = RTR0MemObjGetPagePhysAddr(pVCpu->hwaccm.s.vmx.pMemObjMSRBitmap, 0);
257 memset(pVCpu->hwaccm.s.vmx.pMSRBitmap, 0xff, PAGE_SIZE);
258 }
259
260#ifdef VBOX_WITH_AUTO_MSR_LOAD_RESTORE
261 /* Allocate one page for the guest MSR load area (for preloading guest MSRs during the world switch). */
262 rc = RTR0MemObjAllocCont(&pVCpu->hwaccm.s.vmx.pMemObjGuestMSR, 1 << PAGE_SHIFT, true /* executable R0 mapping */);
263 AssertRC(rc);
264 if (RT_FAILURE(rc))
265 return rc;
266
267 pVCpu->hwaccm.s.vmx.pGuestMSR = (uint8_t *)RTR0MemObjAddress(pVCpu->hwaccm.s.vmx.pMemObjGuestMSR);
268 pVCpu->hwaccm.s.vmx.pGuestMSRPhys = RTR0MemObjGetPagePhysAddr(pVCpu->hwaccm.s.vmx.pMemObjGuestMSR, 0);
269 memset(pVCpu->hwaccm.s.vmx.pGuestMSR, 0, PAGE_SIZE);
270
271 /* Allocate one page for the host MSR load area (for restoring host MSRs after the world switch back). */
272 rc = RTR0MemObjAllocCont(&pVCpu->hwaccm.s.vmx.pMemObjHostMSR, 1 << PAGE_SHIFT, true /* executable R0 mapping */);
273 AssertRC(rc);
274 if (RT_FAILURE(rc))
275 return rc;
276
277 pVCpu->hwaccm.s.vmx.pHostMSR = (uint8_t *)RTR0MemObjAddress(pVCpu->hwaccm.s.vmx.pMemObjHostMSR);
278 pVCpu->hwaccm.s.vmx.pHostMSRPhys = RTR0MemObjGetPagePhysAddr(pVCpu->hwaccm.s.vmx.pMemObjHostMSR, 0);
279 memset(pVCpu->hwaccm.s.vmx.pHostMSR, 0, PAGE_SIZE);
280#endif /* VBOX_WITH_AUTO_MSR_LOAD_RESTORE */
281
282 /* Current guest paging mode. */
283 pVCpu->hwaccm.s.vmx.enmLastSeenGuestMode = PGMMODE_REAL;
284
285#ifdef LOG_ENABLED
286 SUPR0Printf("VMXR0InitVM %x VMCS=%x (%x)\n", pVM, pVCpu->hwaccm.s.vmx.pVMCS, (uint32_t)pVCpu->hwaccm.s.vmx.pVMCSPhys);
287#endif
288 }
289
290 return VINF_SUCCESS;
291}
292
293/**
294 * Does Ring-0 per VM VT-x termination.
295 *
296 * @returns VBox status code.
297 * @param pVM The VM to operate on.
298 */
299VMMR0DECL(int) VMXR0TermVM(PVM pVM)
300{
301 for (unsigned i=0;i<pVM->cCPUs;i++)
302 {
303 PVMCPU pVCpu = &pVM->aCpus[i];
304
305 if (pVCpu->hwaccm.s.vmx.pMemObjVMCS != NIL_RTR0MEMOBJ)
306 {
307 RTR0MemObjFree(pVCpu->hwaccm.s.vmx.pMemObjVMCS, false);
308 pVCpu->hwaccm.s.vmx.pMemObjVMCS = NIL_RTR0MEMOBJ;
309 pVCpu->hwaccm.s.vmx.pVMCS = 0;
310 pVCpu->hwaccm.s.vmx.pVMCSPhys = 0;
311 }
312 if (pVCpu->hwaccm.s.vmx.pMemObjVAPIC != NIL_RTR0MEMOBJ)
313 {
314 RTR0MemObjFree(pVCpu->hwaccm.s.vmx.pMemObjVAPIC, false);
315 pVCpu->hwaccm.s.vmx.pMemObjVAPIC = NIL_RTR0MEMOBJ;
316 pVCpu->hwaccm.s.vmx.pVAPIC = 0;
317 pVCpu->hwaccm.s.vmx.pVAPICPhys = 0;
318 }
319 if (pVCpu->hwaccm.s.vmx.pMemObjMSRBitmap != NIL_RTR0MEMOBJ)
320 {
321 RTR0MemObjFree(pVCpu->hwaccm.s.vmx.pMemObjMSRBitmap, false);
322 pVCpu->hwaccm.s.vmx.pMemObjMSRBitmap = NIL_RTR0MEMOBJ;
323 pVCpu->hwaccm.s.vmx.pMSRBitmap = 0;
324 pVCpu->hwaccm.s.vmx.pMSRBitmapPhys = 0;
325 }
326#ifdef VBOX_WITH_AUTO_MSR_LOAD_RESTORE
327 if (pVCpu->hwaccm.s.vmx.pMemObjHostMSR != NIL_RTR0MEMOBJ)
328 {
329 RTR0MemObjFree(pVCpu->hwaccm.s.vmx.pMemObjHostMSR, false);
330 pVCpu->hwaccm.s.vmx.pMemObjHostMSR = NIL_RTR0MEMOBJ;
331 pVCpu->hwaccm.s.vmx.pHostMSR = 0;
332 pVCpu->hwaccm.s.vmx.pHostMSRPhys = 0;
333 }
334 if (pVCpu->hwaccm.s.vmx.pMemObjGuestMSR != NIL_RTR0MEMOBJ)
335 {
336 RTR0MemObjFree(pVCpu->hwaccm.s.vmx.pMemObjGuestMSR, false);
337 pVCpu->hwaccm.s.vmx.pMemObjGuestMSR = NIL_RTR0MEMOBJ;
338 pVCpu->hwaccm.s.vmx.pGuestMSR = 0;
339 pVCpu->hwaccm.s.vmx.pGuestMSRPhys = 0;
340 }
341#endif /* VBOX_WITH_AUTO_MSR_LOAD_RESTORE */
342 }
343 if (pVM->hwaccm.s.vmx.pMemObjAPIC != NIL_RTR0MEMOBJ)
344 {
345 RTR0MemObjFree(pVM->hwaccm.s.vmx.pMemObjAPIC, false);
346 pVM->hwaccm.s.vmx.pMemObjAPIC = NIL_RTR0MEMOBJ;
347 pVM->hwaccm.s.vmx.pAPIC = 0;
348 pVM->hwaccm.s.vmx.pAPICPhys = 0;
349 }
350#ifdef VBOX_WITH_CRASHDUMP_MAGIC
351 if (pVM->hwaccm.s.vmx.pMemObjScratch != NIL_RTR0MEMOBJ)
352 {
353 ASMMemZero32(pVM->hwaccm.s.vmx.pScratch, PAGE_SIZE);
354 RTR0MemObjFree(pVM->hwaccm.s.vmx.pMemObjScratch, false);
355 pVM->hwaccm.s.vmx.pMemObjScratch = NIL_RTR0MEMOBJ;
356 pVM->hwaccm.s.vmx.pScratch = 0;
357 pVM->hwaccm.s.vmx.pScratchPhys = 0;
358 }
359#endif
360 return VINF_SUCCESS;
361}
362
363/**
364 * Sets up VT-x for the specified VM
365 *
366 * @returns VBox status code.
367 * @param pVM The VM to operate on.
368 */
369VMMR0DECL(int) VMXR0SetupVM(PVM pVM)
370{
371 int rc = VINF_SUCCESS;
372 uint32_t val;
373
374 AssertReturn(pVM, VERR_INVALID_PARAMETER);
375
376 for (unsigned i=0;i<pVM->cCPUs;i++)
377 {
378 PVMCPU pVCpu = &pVM->aCpus[i];
379
380 Assert(pVCpu->hwaccm.s.vmx.pVMCS);
381
382 /* Set revision dword at the beginning of the VMCS structure. */
383 *(uint32_t *)pVCpu->hwaccm.s.vmx.pVMCS = MSR_IA32_VMX_BASIC_INFO_VMCS_ID(pVM->hwaccm.s.vmx.msr.vmx_basic_info);
384
385 /* Clear VM Control Structure. */
386 Log(("pVMCSPhys = %RHp\n", pVCpu->hwaccm.s.vmx.pVMCSPhys));
387 rc = VMXClearVMCS(pVCpu->hwaccm.s.vmx.pVMCSPhys);
388 if (RT_FAILURE(rc))
389 goto vmx_end;
390
391 /* Activate the VM Control Structure. */
392 rc = VMXActivateVMCS(pVCpu->hwaccm.s.vmx.pVMCSPhys);
393 if (RT_FAILURE(rc))
394 goto vmx_end;
395
396 /* VMX_VMCS_CTRL_PIN_EXEC_CONTROLS
397 * Set required bits to one and zero according to the MSR capabilities.
398 */
399 val = pVM->hwaccm.s.vmx.msr.vmx_pin_ctls.n.disallowed0;
400 /* External and non-maskable interrupts cause VM-exits. */
401 val = val | VMX_VMCS_CTRL_PIN_EXEC_CONTROLS_EXT_INT_EXIT | VMX_VMCS_CTRL_PIN_EXEC_CONTROLS_NMI_EXIT;
402 val &= pVM->hwaccm.s.vmx.msr.vmx_pin_ctls.n.allowed1;
403
404 rc = VMXWriteVMCS(VMX_VMCS_CTRL_PIN_EXEC_CONTROLS, val);
405 AssertRC(rc);
406
407 /* VMX_VMCS_CTRL_PROC_EXEC_CONTROLS
408 * Set required bits to one and zero according to the MSR capabilities.
409 */
410 val = pVM->hwaccm.s.vmx.msr.vmx_proc_ctls.n.disallowed0;
411 /* Program which event cause VM-exits and which features we want to use. */
412 val = val | VMX_VMCS_CTRL_PROC_EXEC_CONTROLS_HLT_EXIT
413 | VMX_VMCS_CTRL_PROC_EXEC_CONTROLS_TSC_OFFSET
414 | VMX_VMCS_CTRL_PROC_EXEC_CONTROLS_MOV_DR_EXIT
415 | VMX_VMCS_CTRL_PROC_EXEC_CONTROLS_UNCOND_IO_EXIT
416 | VMX_VMCS_CTRL_PROC_EXEC_CONTROLS_RDPMC_EXIT
417 | VMX_VMCS_CTRL_PROC_EXEC_CONTROLS_MWAIT_EXIT; /* don't execute mwait or else we'll idle inside the guest (host thinks the cpu load is high) */
418
419 /* Without nested paging we should intercept invlpg and cr3 mov instructions. */
420 if (!pVM->hwaccm.s.fNestedPaging)
421 val |= VMX_VMCS_CTRL_PROC_EXEC_CONTROLS_INVLPG_EXIT
422 | VMX_VMCS_CTRL_PROC_EXEC_CONTROLS_CR3_LOAD_EXIT
423 | VMX_VMCS_CTRL_PROC_EXEC_CONTROLS_CR3_STORE_EXIT;
424
425 /* Note: VMX_VMCS_CTRL_PROC_EXEC_CONTROLS_MWAIT_EXIT might cause a vmlaunch failure with an invalid control fields error. (combined with some other exit reasons) */
426 if (pVM->hwaccm.s.vmx.msr.vmx_proc_ctls.n.allowed1 & VMX_VMCS_CTRL_PROC_EXEC_CONTROLS_USE_TPR_SHADOW)
427 {
428 /* CR8 reads from the APIC shadow page; writes cause an exit is they lower the TPR below the threshold */
429 val |= VMX_VMCS_CTRL_PROC_EXEC_CONTROLS_USE_TPR_SHADOW;
430 Assert(pVM->hwaccm.s.vmx.pAPIC);
431 }
432 else
433 /* Exit on CR8 reads & writes in case the TPR shadow feature isn't present. */
434 val |= VMX_VMCS_CTRL_PROC_EXEC_CONTROLS_CR8_STORE_EXIT | VMX_VMCS_CTRL_PROC_EXEC_CONTROLS_CR8_LOAD_EXIT;
435
436 if (pVM->hwaccm.s.vmx.msr.vmx_proc_ctls.n.allowed1 & VMX_VMCS_CTRL_PROC_EXEC_CONTROLS_USE_MSR_BITMAPS)
437 {
438 Assert(pVCpu->hwaccm.s.vmx.pMSRBitmapPhys);
439 val |= VMX_VMCS_CTRL_PROC_EXEC_CONTROLS_USE_MSR_BITMAPS;
440 }
441
442 /* We will use the secondary control if it's present. */
443 val |= VMX_VMCS_CTRL_PROC_EXEC_USE_SECONDARY_EXEC_CTRL;
444
445 /* Mask away the bits that the CPU doesn't support */
446 /** @todo make sure they don't conflict with the above requirements. */
447 val &= pVM->hwaccm.s.vmx.msr.vmx_proc_ctls.n.allowed1;
448 pVCpu->hwaccm.s.vmx.proc_ctls = val;
449
450 rc = VMXWriteVMCS(VMX_VMCS_CTRL_PROC_EXEC_CONTROLS, val);
451 AssertRC(rc);
452
453 if (pVM->hwaccm.s.vmx.msr.vmx_proc_ctls.n.allowed1 & VMX_VMCS_CTRL_PROC_EXEC_USE_SECONDARY_EXEC_CTRL)
454 {
455 /* VMX_VMCS_CTRL_PROC_EXEC_CONTROLS2
456 * Set required bits to one and zero according to the MSR capabilities.
457 */
458 val = pVM->hwaccm.s.vmx.msr.vmx_proc_ctls2.n.disallowed0;
459 val |= VMX_VMCS_CTRL_PROC_EXEC2_WBINVD_EXIT;
460
461#ifdef HWACCM_VTX_WITH_EPT
462 if (pVM->hwaccm.s.fNestedPaging)
463 val |= VMX_VMCS_CTRL_PROC_EXEC2_EPT;
464#endif /* HWACCM_VTX_WITH_EPT */
465#ifdef HWACCM_VTX_WITH_VPID
466 else
467 if (pVM->hwaccm.s.vmx.fVPID)
468 val |= VMX_VMCS_CTRL_PROC_EXEC2_VPID;
469#endif /* HWACCM_VTX_WITH_VPID */
470
471 if (pVM->hwaccm.s.fHasIoApic)
472 val |= VMX_VMCS_CTRL_PROC_EXEC2_VIRT_APIC;
473
474 /* Mask away the bits that the CPU doesn't support */
475 /** @todo make sure they don't conflict with the above requirements. */
476 val &= pVM->hwaccm.s.vmx.msr.vmx_proc_ctls2.n.allowed1;
477 pVCpu->hwaccm.s.vmx.proc_ctls2 = val;
478 rc = VMXWriteVMCS(VMX_VMCS_CTRL_PROC_EXEC_CONTROLS2, val);
479 AssertRC(rc);
480 }
481
482 /* VMX_VMCS_CTRL_CR3_TARGET_COUNT
483 * Set required bits to one and zero according to the MSR capabilities.
484 */
485 rc = VMXWriteVMCS(VMX_VMCS_CTRL_CR3_TARGET_COUNT, 0);
486 AssertRC(rc);
487
488 /* Forward all exception except #NM & #PF to the guest.
489 * We always need to check pagefaults since our shadow page table can be out of sync.
490 * And we always lazily sync the FPU & XMM state.
491 */
492
493 /** @todo Possible optimization:
494 * Keep the FPU and XMM state current in the EM thread. That way there's no need to
495 * lazily sync anything, but the downside is that we can't use the FPU stack or XMM
496 * registers ourselves of course.
497 *
498 * Note: only possible if the current state is actually ours (X86_CR0_TS flag)
499 */
500
501 /* Don't filter page faults; all of them should cause a switch. */
502 rc = VMXWriteVMCS(VMX_VMCS_CTRL_PAGEFAULT_ERROR_MASK, 0);
503 rc |= VMXWriteVMCS(VMX_VMCS_CTRL_PAGEFAULT_ERROR_MATCH, 0);
504 AssertRC(rc);
505
506 /* Init TSC offset to zero. */
507 rc = VMXWriteVMCS64(VMX_VMCS_CTRL_TSC_OFFSET_FULL, 0);
508 AssertRC(rc);
509
510 rc = VMXWriteVMCS64(VMX_VMCS_CTRL_IO_BITMAP_A_FULL, 0);
511 AssertRC(rc);
512
513 rc = VMXWriteVMCS64(VMX_VMCS_CTRL_IO_BITMAP_B_FULL, 0);
514 AssertRC(rc);
515
516 /* Set the MSR bitmap address. */
517 if (pVM->hwaccm.s.vmx.msr.vmx_proc_ctls.n.allowed1 & VMX_VMCS_CTRL_PROC_EXEC_CONTROLS_USE_MSR_BITMAPS)
518 {
519 Assert(pVCpu->hwaccm.s.vmx.pMSRBitmapPhys);
520
521 rc = VMXWriteVMCS64(VMX_VMCS_CTRL_MSR_BITMAP_FULL, pVCpu->hwaccm.s.vmx.pMSRBitmapPhys);
522 AssertRC(rc);
523
524 /* Allow the guest to directly modify these MSRs; they are restored and saved automatically. */
525 vmxR0SetMSRPermission(pVCpu, MSR_IA32_SYSENTER_CS, true, true);
526 vmxR0SetMSRPermission(pVCpu, MSR_IA32_SYSENTER_ESP, true, true);
527 vmxR0SetMSRPermission(pVCpu, MSR_IA32_SYSENTER_EIP, true, true);
528 vmxR0SetMSRPermission(pVCpu, MSR_K8_LSTAR, true, true);
529 vmxR0SetMSRPermission(pVCpu, MSR_K6_STAR, true, true);
530 vmxR0SetMSRPermission(pVCpu, MSR_K8_SF_MASK, true, true);
531 vmxR0SetMSRPermission(pVCpu, MSR_K8_KERNEL_GS_BASE, true, true);
532 vmxR0SetMSRPermission(pVCpu, MSR_K8_GS_BASE, true, true);
533 vmxR0SetMSRPermission(pVCpu, MSR_K8_FS_BASE, true, true);
534 }
535
536#ifdef VBOX_WITH_AUTO_MSR_LOAD_RESTORE
537 /* Set the guest & host MSR load/store physical addresses. */
538 Assert(pVCpu->hwaccm.s.vmx.pGuestMSRPhys);
539 rc = VMXWriteVMCS64(VMX_VMCS_CTRL_VMENTRY_MSR_LOAD_FULL, pVCpu->hwaccm.s.vmx.pGuestMSRPhys);
540 AssertRC(rc);
541 rc = VMXWriteVMCS64(VMX_VMCS_CTRL_VMEXIT_MSR_STORE_FULL, pVCpu->hwaccm.s.vmx.pGuestMSRPhys);
542 AssertRC(rc);
543
544 Assert(pVCpu->hwaccm.s.vmx.pHostMSRPhys);
545 rc = VMXWriteVMCS64(VMX_VMCS_CTRL_VMEXIT_MSR_LOAD_FULL, pVCpu->hwaccm.s.vmx.pHostMSRPhys);
546 AssertRC(rc);
547#endif /* VBOX_WITH_AUTO_MSR_LOAD_RESTORE */
548
549 rc = VMXWriteVMCS(VMX_VMCS_CTRL_ENTRY_MSR_LOAD_COUNT, 0);
550 AssertRC(rc);
551
552 rc = VMXWriteVMCS(VMX_VMCS_CTRL_EXIT_MSR_STORE_COUNT, 0);
553 AssertRC(rc);
554
555 if (pVM->hwaccm.s.vmx.msr.vmx_proc_ctls.n.allowed1 & VMX_VMCS_CTRL_PROC_EXEC_CONTROLS_USE_TPR_SHADOW)
556 {
557 Assert(pVM->hwaccm.s.vmx.pMemObjAPIC);
558 /* Optional */
559 rc = VMXWriteVMCS(VMX_VMCS_CTRL_TPR_THRESHOLD, 0);
560 rc |= VMXWriteVMCS64(VMX_VMCS_CTRL_VAPIC_PAGEADDR_FULL, pVCpu->hwaccm.s.vmx.pVAPICPhys);
561
562 if (pVM->hwaccm.s.vmx.msr.vmx_proc_ctls2.n.allowed1 & VMX_VMCS_CTRL_PROC_EXEC2_VIRT_APIC)
563 rc |= VMXWriteVMCS64(VMX_VMCS_CTRL_APIC_ACCESSADDR_FULL, pVM->hwaccm.s.vmx.pAPICPhys);
564
565 AssertRC(rc);
566 }
567
568 /* Set link pointer to -1. Not currently used. */
569 rc = VMXWriteVMCS64(VMX_VMCS_GUEST_LINK_PTR_FULL, 0xFFFFFFFFFFFFFFFFULL);
570 AssertRC(rc);
571
572 /* Clear VM Control Structure. Marking it inactive, clearing implementation specific data and writing back VMCS data to memory. */
573 rc = VMXClearVMCS(pVCpu->hwaccm.s.vmx.pVMCSPhys);
574 AssertRC(rc);
575
576 /* Configure the VMCS read cache. */
577 PVMCSCACHE pCache = &pVCpu->hwaccm.s.vmx.VMCSCache;
578
579 VMXSetupCachedReadVMCS(pCache, VMX_VMCS64_GUEST_RIP);
580 VMXSetupCachedReadVMCS(pCache, VMX_VMCS64_GUEST_RSP);
581 VMXSetupCachedReadVMCS(pCache, VMX_VMCS_GUEST_RFLAGS);
582 VMXSetupCachedReadVMCS(pCache, VMX_VMCS32_GUEST_INTERRUPTIBILITY_STATE);
583 VMXSetupCachedReadVMCS(pCache, VMX_VMCS_CTRL_CR0_READ_SHADOW);
584 VMXSetupCachedReadVMCS(pCache, VMX_VMCS64_GUEST_CR0);
585 VMXSetupCachedReadVMCS(pCache, VMX_VMCS_CTRL_CR4_READ_SHADOW);
586 VMXSetupCachedReadVMCS(pCache, VMX_VMCS64_GUEST_CR4);
587 VMXSetupCachedReadVMCS(pCache, VMX_VMCS64_GUEST_DR7);
588 VMXSetupCachedReadVMCS(pCache, VMX_VMCS32_GUEST_SYSENTER_CS);
589 VMXSetupCachedReadVMCS(pCache, VMX_VMCS64_GUEST_SYSENTER_EIP);
590 VMXSetupCachedReadVMCS(pCache, VMX_VMCS64_GUEST_SYSENTER_ESP);
591 VMXSetupCachedReadVMCS(pCache, VMX_VMCS32_GUEST_GDTR_LIMIT);
592 VMXSetupCachedReadVMCS(pCache, VMX_VMCS64_GUEST_GDTR_BASE);
593 VMXSetupCachedReadVMCS(pCache, VMX_VMCS32_GUEST_IDTR_LIMIT);
594 VMXSetupCachedReadVMCS(pCache, VMX_VMCS64_GUEST_IDTR_BASE);
595
596 VMX_SETUP_SELREG(ES, pCache);
597 VMX_SETUP_SELREG(SS, pCache);
598 VMX_SETUP_SELREG(CS, pCache);
599 VMX_SETUP_SELREG(DS, pCache);
600 VMX_SETUP_SELREG(FS, pCache);
601 VMX_SETUP_SELREG(GS, pCache);
602 VMX_SETUP_SELREG(LDTR, pCache);
603 VMX_SETUP_SELREG(TR, pCache);
604
605 /* Status code VMCS reads. */
606 VMXSetupCachedReadVMCS(pCache, VMX_VMCS32_RO_EXIT_REASON);
607 VMXSetupCachedReadVMCS(pCache, VMX_VMCS32_RO_VM_INSTR_ERROR);
608 VMXSetupCachedReadVMCS(pCache, VMX_VMCS32_RO_EXIT_INSTR_LENGTH);
609 VMXSetupCachedReadVMCS(pCache, VMX_VMCS32_RO_EXIT_INTERRUPTION_ERRCODE);
610 VMXSetupCachedReadVMCS(pCache, VMX_VMCS32_RO_EXIT_INTERRUPTION_INFO);
611 VMXSetupCachedReadVMCS(pCache, VMX_VMCS32_RO_EXIT_INSTR_INFO);
612 VMXSetupCachedReadVMCS(pCache, VMX_VMCS_RO_EXIT_QUALIFICATION);
613 VMXSetupCachedReadVMCS(pCache, VMX_VMCS32_RO_IDT_INFO);
614 VMXSetupCachedReadVMCS(pCache, VMX_VMCS32_RO_IDT_ERRCODE);
615
616 if (pVM->hwaccm.s.fNestedPaging)
617 {
618 VMXSetupCachedReadVMCS(pCache, VMX_VMCS64_GUEST_CR3);
619 VMXSetupCachedReadVMCS(pCache, VMX_VMCS_EXIT_PHYS_ADDR_FULL);
620 pCache->Read.cValidEntries = VMX_VMCS_MAX_NESTED_PAGING_CACHE_IDX;
621 }
622 else
623 pCache->Read.cValidEntries = VMX_VMCS_MAX_CACHE_IDX;
624 } /* for each VMCPU */
625
626 /* Choose the right TLB setup function. */
627 if (pVM->hwaccm.s.fNestedPaging)
628 {
629 pVM->hwaccm.s.vmx.pfnSetupTaggedTLB = vmxR0SetupTLBEPT;
630
631 /* Default values for flushing. */
632 pVM->hwaccm.s.vmx.enmFlushPage = VMX_FLUSH_ALL_CONTEXTS;
633 pVM->hwaccm.s.vmx.enmFlushContext = VMX_FLUSH_ALL_CONTEXTS;
634
635 /* If the capabilities specify we can do more, then make use of it. */
636 if (pVM->hwaccm.s.vmx.msr.vmx_eptcaps & MSR_IA32_VMX_EPT_CAPS_INVEPT_CAPS_INDIV)
637 pVM->hwaccm.s.vmx.enmFlushPage = VMX_FLUSH_PAGE;
638 else
639 if (pVM->hwaccm.s.vmx.msr.vmx_eptcaps & MSR_IA32_VMX_EPT_CAPS_INVEPT_CAPS_CONTEXT)
640 pVM->hwaccm.s.vmx.enmFlushPage = VMX_FLUSH_SINGLE_CONTEXT;
641
642 if (pVM->hwaccm.s.vmx.msr.vmx_eptcaps & MSR_IA32_VMX_EPT_CAPS_INVEPT_CAPS_CONTEXT)
643 pVM->hwaccm.s.vmx.enmFlushContext = VMX_FLUSH_SINGLE_CONTEXT;
644 }
645#ifdef HWACCM_VTX_WITH_VPID
646 else
647 if (pVM->hwaccm.s.vmx.fVPID)
648 {
649 pVM->hwaccm.s.vmx.pfnSetupTaggedTLB = vmxR0SetupTLBVPID;
650
651 /* Default values for flushing. */
652 pVM->hwaccm.s.vmx.enmFlushPage = VMX_FLUSH_ALL_CONTEXTS;
653 pVM->hwaccm.s.vmx.enmFlushContext = VMX_FLUSH_ALL_CONTEXTS;
654
655 /* If the capabilities specify we can do more, then make use of it. */
656 if (pVM->hwaccm.s.vmx.msr.vmx_eptcaps & MSR_IA32_VMX_EPT_CAPS_INVVPID_CAPS_INDIV)
657 pVM->hwaccm.s.vmx.enmFlushPage = VMX_FLUSH_PAGE;
658 else
659 if (pVM->hwaccm.s.vmx.msr.vmx_eptcaps & MSR_IA32_VMX_EPT_CAPS_INVVPID_CAPS_CONTEXT)
660 pVM->hwaccm.s.vmx.enmFlushPage = VMX_FLUSH_SINGLE_CONTEXT;
661
662 if (pVM->hwaccm.s.vmx.msr.vmx_eptcaps & MSR_IA32_VMX_EPT_CAPS_INVVPID_CAPS_CONTEXT)
663 pVM->hwaccm.s.vmx.enmFlushContext = VMX_FLUSH_SINGLE_CONTEXT;
664 }
665#endif /* HWACCM_VTX_WITH_VPID */
666 else
667 pVM->hwaccm.s.vmx.pfnSetupTaggedTLB = vmxR0SetupTLBDummy;
668
669vmx_end:
670 VMXR0CheckError(pVM, &pVM->aCpus[0], rc);
671 return rc;
672}
673
674/**
675 * Sets the permission bits for the specified MSR
676 *
677 * @param pVCpu The VMCPU to operate on.
678 * @param ulMSR MSR value
679 * @param fRead Reading allowed/disallowed
680 * @param fWrite Writing allowed/disallowed
681 */
682static void vmxR0SetMSRPermission(PVMCPU pVCpu, unsigned ulMSR, bool fRead, bool fWrite)
683{
684 unsigned ulBit;
685 uint8_t *pMSRBitmap = (uint8_t *)pVCpu->hwaccm.s.vmx.pMSRBitmap;
686
687 /* Layout:
688 * 0x000 - 0x3ff - Low MSR read bits
689 * 0x400 - 0x7ff - High MSR read bits
690 * 0x800 - 0xbff - Low MSR write bits
691 * 0xc00 - 0xfff - High MSR write bits
692 */
693 if (ulMSR <= 0x00001FFF)
694 {
695 /* Pentium-compatible MSRs */
696 ulBit = ulMSR;
697 }
698 else
699 if ( ulMSR >= 0xC0000000
700 && ulMSR <= 0xC0001FFF)
701 {
702 /* AMD Sixth Generation x86 Processor MSRs */
703 ulBit = (ulMSR - 0xC0000000);
704 pMSRBitmap += 0x400;
705 }
706 else
707 {
708 AssertFailed();
709 return;
710 }
711
712 Assert(ulBit <= 0x1fff);
713 if (fRead)
714 ASMBitClear(pMSRBitmap, ulBit);
715 else
716 ASMBitSet(pMSRBitmap, ulBit);
717
718 if (fWrite)
719 ASMBitClear(pMSRBitmap + 0x800, ulBit);
720 else
721 ASMBitSet(pMSRBitmap + 0x800, ulBit);
722}
723
724
725/**
726 * Injects an event (trap or external interrupt)
727 *
728 * @returns VBox status code.
729 * @param pVM The VM to operate on.
730 * @param pVCpu The VMCPU to operate on.
731 * @param pCtx CPU Context
732 * @param intInfo VMX interrupt info
733 * @param cbInstr Opcode length of faulting instruction
734 * @param errCode Error code (optional)
735 */
736static int VMXR0InjectEvent(PVM pVM, PVMCPU pVCpu, PCPUMCTX pCtx, uint32_t intInfo, uint32_t cbInstr, uint32_t errCode)
737{
738 int rc;
739 uint32_t iGate = VMX_EXIT_INTERRUPTION_INFO_VECTOR(intInfo);
740
741#ifdef VBOX_WITH_STATISTICS
742 STAM_COUNTER_INC(&pVCpu->hwaccm.s.paStatInjectedIrqsR0[iGate & MASK_INJECT_IRQ_STAT]);
743#endif
744
745#ifdef VBOX_STRICT
746 if (iGate == 0xE)
747 LogFlow(("VMXR0InjectEvent: Injecting interrupt %d at %RGv error code=%08x CR2=%RGv intInfo=%08x\n", iGate, (RTGCPTR)pCtx->rip, errCode, pCtx->cr2, intInfo));
748 else
749 if (iGate < 0x20)
750 LogFlow(("VMXR0InjectEvent: Injecting interrupt %d at %RGv error code=%08x\n", iGate, (RTGCPTR)pCtx->rip, errCode));
751 else
752 {
753 LogFlow(("INJ-EI: %x at %RGv\n", iGate, (RTGCPTR)pCtx->rip));
754 Assert(VMX_EXIT_INTERRUPTION_INFO_TYPE(intInfo) == VMX_EXIT_INTERRUPTION_INFO_TYPE_SW || !VMCPU_FF_ISSET(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS));
755 Assert(VMX_EXIT_INTERRUPTION_INFO_TYPE(intInfo) == VMX_EXIT_INTERRUPTION_INFO_TYPE_SW || pCtx->eflags.u32 & X86_EFL_IF);
756 }
757#endif
758
759#ifdef HWACCM_VMX_EMULATE_REALMODE
760 if (CPUMIsGuestInRealModeEx(pCtx))
761 {
762 RTGCPHYS GCPhysHandler;
763 uint16_t offset, ip;
764 RTSEL sel;
765
766 /* Injecting events doesn't work right with real mode emulation.
767 * (#GP if we try to inject external hardware interrupts)
768 * Inject the interrupt or trap directly instead.
769 *
770 * ASSUMES no access handlers for the bits we read or write below (should be safe).
771 */
772 Log(("Manual interrupt/trap '%x' inject (real mode)\n", iGate));
773
774 /* Check if the interrupt handler is present. */
775 if (iGate * 4 + 3 > pCtx->idtr.cbIdt)
776 {
777 Log(("IDT cbIdt violation\n"));
778 if (iGate != X86_XCPT_DF)
779 {
780 RTGCUINTPTR intInfo;
781
782 intInfo = (iGate == X86_XCPT_GP) ? (uint32_t)X86_XCPT_DF : iGate;
783 intInfo |= (1 << VMX_EXIT_INTERRUPTION_INFO_VALID_SHIFT);
784 intInfo |= VMX_EXIT_INTERRUPTION_INFO_ERROR_CODE_VALID;
785 intInfo |= (VMX_EXIT_INTERRUPTION_INFO_TYPE_HWEXCPT << VMX_EXIT_INTERRUPTION_INFO_TYPE_SHIFT);
786
787 return VMXR0InjectEvent(pVM, pVCpu, pCtx, intInfo, 0, 0 /* no error code according to the Intel docs */);
788 }
789 Log(("Triple fault -> reset the VM!\n"));
790 return VINF_EM_RESET;
791 }
792 if ( VMX_EXIT_INTERRUPTION_INFO_TYPE(intInfo) == VMX_EXIT_INTERRUPTION_INFO_TYPE_SW
793 || iGate == 3 /* Both #BP and #OF point to the instruction after. */
794 || iGate == 4)
795 {
796 ip = pCtx->ip + cbInstr;
797 }
798 else
799 ip = pCtx->ip;
800
801 /* Read the selector:offset pair of the interrupt handler. */
802 GCPhysHandler = (RTGCPHYS)pCtx->idtr.pIdt + iGate * 4;
803 rc = PGMPhysSimpleReadGCPhys(pVM, &offset, GCPhysHandler, sizeof(offset)); AssertRC(rc);
804 rc = PGMPhysSimpleReadGCPhys(pVM, &sel, GCPhysHandler + 2, sizeof(sel)); AssertRC(rc);
805
806 LogFlow(("IDT handler %04X:%04X\n", sel, offset));
807
808 /* Construct the stack frame. */
809 /** @todo should check stack limit. */
810 pCtx->sp -= 2;
811 LogFlow(("ss:sp %04X:%04X eflags=%x\n", pCtx->ss, pCtx->sp, pCtx->eflags.u));
812 rc = PGMPhysSimpleWriteGCPhys(pVM, pCtx->ssHid.u64Base + pCtx->sp, &pCtx->eflags, sizeof(uint16_t)); AssertRC(rc);
813 pCtx->sp -= 2;
814 LogFlow(("ss:sp %04X:%04X cs=%x\n", pCtx->ss, pCtx->sp, pCtx->cs));
815 rc = PGMPhysSimpleWriteGCPhys(pVM, pCtx->ssHid.u64Base + pCtx->sp, &pCtx->cs, sizeof(uint16_t)); AssertRC(rc);
816 pCtx->sp -= 2;
817 LogFlow(("ss:sp %04X:%04X ip=%x\n", pCtx->ss, pCtx->sp, ip));
818 rc = PGMPhysSimpleWriteGCPhys(pVM, pCtx->ssHid.u64Base + pCtx->sp, &ip, sizeof(ip)); AssertRC(rc);
819
820 /* Update the CPU state for executing the handler. */
821 pCtx->rip = offset;
822 pCtx->cs = sel;
823 pCtx->csHid.u64Base = sel << 4;
824 pCtx->eflags.u &= ~(X86_EFL_IF|X86_EFL_TF|X86_EFL_RF|X86_EFL_AC);
825
826 pVCpu->hwaccm.s.fContextUseFlags |= HWACCM_CHANGED_GUEST_SEGMENT_REGS;
827 return VINF_SUCCESS;
828 }
829#endif /* HWACCM_VMX_EMULATE_REALMODE */
830
831 /* Set event injection state. */
832 rc = VMXWriteVMCS(VMX_VMCS_CTRL_ENTRY_IRQ_INFO, intInfo | (1 << VMX_EXIT_INTERRUPTION_INFO_VALID_SHIFT));
833
834 rc |= VMXWriteVMCS(VMX_VMCS_CTRL_ENTRY_INSTR_LENGTH, cbInstr);
835 rc |= VMXWriteVMCS(VMX_VMCS_CTRL_ENTRY_EXCEPTION_ERRCODE, errCode);
836
837 AssertRC(rc);
838 return rc;
839}
840
841
842/**
843 * Checks for pending guest interrupts and injects them
844 *
845 * @returns VBox status code.
846 * @param pVM The VM to operate on.
847 * @param pVCpu The VMCPU to operate on.
848 * @param pCtx CPU Context
849 */
850static int VMXR0CheckPendingInterrupt(PVM pVM, PVMCPU pVCpu, CPUMCTX *pCtx)
851{
852 int rc;
853
854 /* Dispatch any pending interrupts. (injected before, but a VM exit occurred prematurely) */
855 if (pVCpu->hwaccm.s.Event.fPending)
856 {
857 Log(("CPU%d: Reinjecting event %RX64 %08x at %RGv cr2=%RX64\n", pVCpu->idCpu, pVCpu->hwaccm.s.Event.intInfo, pVCpu->hwaccm.s.Event.errCode, (RTGCPTR)pCtx->rip, pCtx->cr2));
858 STAM_COUNTER_INC(&pVCpu->hwaccm.s.StatIntReinject);
859 rc = VMXR0InjectEvent(pVM, pVCpu, pCtx, pVCpu->hwaccm.s.Event.intInfo, 0, pVCpu->hwaccm.s.Event.errCode);
860 AssertRC(rc);
861
862 pVCpu->hwaccm.s.Event.fPending = false;
863 return VINF_SUCCESS;
864 }
865
866 /* If an active trap is already pending, then we must forward it first! */
867 if (!TRPMHasTrap(pVCpu))
868 {
869 if (VMCPU_FF_TESTANDCLEAR(pVCpu, VMCPU_FF_INTERRUPT_NMI))
870 {
871 RTGCUINTPTR intInfo;
872
873 Log(("CPU%d: injecting #NMI\n", pVCpu->idCpu));
874
875 intInfo = X86_XCPT_NMI;
876 intInfo |= (1 << VMX_EXIT_INTERRUPTION_INFO_VALID_SHIFT);
877 intInfo |= (VMX_EXIT_INTERRUPTION_INFO_TYPE_NMI << VMX_EXIT_INTERRUPTION_INFO_TYPE_SHIFT);
878
879 rc = VMXR0InjectEvent(pVM, pVCpu, pCtx, intInfo, 0, 0);
880 AssertRC(rc);
881
882 return VINF_SUCCESS;
883 }
884
885 /* @todo SMI interrupts. */
886
887 /* When external interrupts are pending, we should exit the VM when IF is set. */
888 if (VMCPU_FF_ISPENDING(pVCpu, (VMCPU_FF_INTERRUPT_APIC|VMCPU_FF_INTERRUPT_PIC)))
889 {
890 if (!(pCtx->eflags.u32 & X86_EFL_IF))
891 {
892 if (!(pVCpu->hwaccm.s.vmx.proc_ctls & VMX_VMCS_CTRL_PROC_EXEC_CONTROLS_IRQ_WINDOW_EXIT))
893 {
894 LogFlow(("Enable irq window exit!\n"));
895 pVCpu->hwaccm.s.vmx.proc_ctls |= VMX_VMCS_CTRL_PROC_EXEC_CONTROLS_IRQ_WINDOW_EXIT;
896 rc = VMXWriteVMCS(VMX_VMCS_CTRL_PROC_EXEC_CONTROLS, pVCpu->hwaccm.s.vmx.proc_ctls);
897 AssertRC(rc);
898 }
899 /* else nothing to do but wait */
900 }
901 else
902 if (!VMCPU_FF_ISSET(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS))
903 {
904 uint8_t u8Interrupt;
905
906 rc = PDMGetInterrupt(pVCpu, &u8Interrupt);
907 Log(("CPU%d: Dispatch interrupt: u8Interrupt=%x (%d) rc=%Rrc cs:rip=%04X:%RGv\n", pVCpu->idCpu, u8Interrupt, u8Interrupt, rc, pCtx->cs, (RTGCPTR)pCtx->rip));
908 if (RT_SUCCESS(rc))
909 {
910 rc = TRPMAssertTrap(pVCpu, u8Interrupt, TRPM_HARDWARE_INT);
911 AssertRC(rc);
912 }
913 else
914 {
915 /* Can only happen in rare cases where a pending interrupt is cleared behind our back */
916 Assert(!VMCPU_FF_ISPENDING(pVCpu, (VMCPU_FF_INTERRUPT_APIC|VMCPU_FF_INTERRUPT_PIC)));
917 STAM_COUNTER_INC(&pVCpu->hwaccm.s.StatSwitchGuestIrq);
918 /* Just continue */
919 }
920 }
921 else
922 Log(("Pending interrupt blocked at %RGv by VM_FF_INHIBIT_INTERRUPTS!!\n", (RTGCPTR)pCtx->rip));
923 }
924 }
925
926#ifdef VBOX_STRICT
927 if (TRPMHasTrap(pVCpu))
928 {
929 uint8_t u8Vector;
930 rc = TRPMQueryTrapAll(pVCpu, &u8Vector, 0, 0, 0);
931 AssertRC(rc);
932 }
933#endif
934
935 if ( (pCtx->eflags.u32 & X86_EFL_IF)
936 && (!VMCPU_FF_ISSET(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS))
937 && TRPMHasTrap(pVCpu)
938 )
939 {
940 uint8_t u8Vector;
941 int rc;
942 TRPMEVENT enmType;
943 RTGCUINTPTR intInfo;
944 RTGCUINT errCode;
945
946 /* If a new event is pending, then dispatch it now. */
947 rc = TRPMQueryTrapAll(pVCpu, &u8Vector, &enmType, &errCode, 0);
948 AssertRC(rc);
949 Assert(pCtx->eflags.Bits.u1IF == 1 || enmType == TRPM_TRAP);
950 Assert(enmType != TRPM_SOFTWARE_INT);
951
952 /* Clear the pending trap. */
953 rc = TRPMResetTrap(pVCpu);
954 AssertRC(rc);
955
956 intInfo = u8Vector;
957 intInfo |= (1 << VMX_EXIT_INTERRUPTION_INFO_VALID_SHIFT);
958
959 if (enmType == TRPM_TRAP)
960 {
961 switch (u8Vector) {
962 case 8:
963 case 10:
964 case 11:
965 case 12:
966 case 13:
967 case 14:
968 case 17:
969 /* Valid error codes. */
970 intInfo |= VMX_EXIT_INTERRUPTION_INFO_ERROR_CODE_VALID;
971 break;
972 default:
973 break;
974 }
975 if (u8Vector == X86_XCPT_BP || u8Vector == X86_XCPT_OF)
976 intInfo |= (VMX_EXIT_INTERRUPTION_INFO_TYPE_SWEXCPT << VMX_EXIT_INTERRUPTION_INFO_TYPE_SHIFT);
977 else
978 intInfo |= (VMX_EXIT_INTERRUPTION_INFO_TYPE_HWEXCPT << VMX_EXIT_INTERRUPTION_INFO_TYPE_SHIFT);
979 }
980 else
981 intInfo |= (VMX_EXIT_INTERRUPTION_INFO_TYPE_EXT << VMX_EXIT_INTERRUPTION_INFO_TYPE_SHIFT);
982
983 STAM_COUNTER_INC(&pVCpu->hwaccm.s.StatIntInject);
984 rc = VMXR0InjectEvent(pVM, pVCpu, pCtx, intInfo, 0, errCode);
985 AssertRC(rc);
986 } /* if (interrupts can be dispatched) */
987
988 return VINF_SUCCESS;
989}
990
991/**
992 * Save the host state
993 *
994 * @returns VBox status code.
995 * @param pVM The VM to operate on.
996 * @param pVCpu The VMCPU to operate on.
997 */
998VMMR0DECL(int) VMXR0SaveHostState(PVM pVM, PVMCPU pVCpu)
999{
1000 int rc = VINF_SUCCESS;
1001
1002 /*
1003 * Host CPU Context
1004 */
1005 if (pVCpu->hwaccm.s.fContextUseFlags & HWACCM_CHANGED_HOST_CONTEXT)
1006 {
1007 RTIDTR idtr;
1008 RTGDTR gdtr;
1009 RTSEL SelTR;
1010 PX86DESCHC pDesc;
1011 uintptr_t trBase;
1012 RTSEL cs;
1013 RTSEL ss;
1014 uint64_t cr3;
1015
1016 /* Control registers */
1017 rc = VMXWriteVMCS(VMX_VMCS_HOST_CR0, ASMGetCR0());
1018#ifdef VBOX_WITH_HYBRID_32BIT_KERNEL
1019 if (VMX_IS_64BIT_HOST_MODE())
1020 {
1021 cr3 = hwaccmR0Get64bitCR3();
1022 rc |= VMXWriteVMCS64(VMX_VMCS_HOST_CR3, cr3);
1023 }
1024 else
1025#endif
1026 {
1027 cr3 = ASMGetCR3();
1028 rc |= VMXWriteVMCS(VMX_VMCS_HOST_CR3, cr3);
1029 }
1030 rc |= VMXWriteVMCS(VMX_VMCS_HOST_CR4, ASMGetCR4());
1031 AssertRC(rc);
1032 Log2(("VMX_VMCS_HOST_CR0 %08x\n", ASMGetCR0()));
1033 Log2(("VMX_VMCS_HOST_CR3 %08RX64\n", cr3));
1034 Log2(("VMX_VMCS_HOST_CR4 %08x\n", ASMGetCR4()));
1035
1036 /* Selector registers. */
1037#ifdef VBOX_WITH_HYBRID_32BIT_KERNEL
1038 if (VMX_IS_64BIT_HOST_MODE())
1039 {
1040 cs = (RTSEL)(uintptr_t)&SUPR0Abs64bitKernelCS;
1041 ss = (RTSEL)(uintptr_t)&SUPR0Abs64bitKernelSS;
1042 }
1043 else
1044 {
1045 /* sysenter loads LDT cs & ss, VMX doesn't like this. Load the GDT ones (safe). */
1046 cs = (RTSEL)(uintptr_t)&SUPR0AbsKernelCS;
1047 ss = (RTSEL)(uintptr_t)&SUPR0AbsKernelSS;
1048 }
1049#else
1050 cs = ASMGetCS();
1051 ss = ASMGetSS();
1052#endif
1053 Assert(!(cs & X86_SEL_LDT)); Assert((cs & X86_SEL_RPL) == 0);
1054 Assert(!(ss & X86_SEL_LDT)); Assert((ss & X86_SEL_RPL) == 0);
1055 rc = VMXWriteVMCS(VMX_VMCS16_HOST_FIELD_CS, cs);
1056 /* Note: VMX is (again) very picky about the RPL of the selectors here; we'll restore them manually. */
1057 rc |= VMXWriteVMCS(VMX_VMCS16_HOST_FIELD_DS, 0);
1058 rc |= VMXWriteVMCS(VMX_VMCS16_HOST_FIELD_ES, 0);
1059#if HC_ARCH_BITS == 32
1060 if (!VMX_IS_64BIT_HOST_MODE())
1061 {
1062 rc |= VMXWriteVMCS(VMX_VMCS16_HOST_FIELD_FS, 0);
1063 rc |= VMXWriteVMCS(VMX_VMCS16_HOST_FIELD_GS, 0);
1064 }
1065#endif
1066 rc |= VMXWriteVMCS(VMX_VMCS16_HOST_FIELD_SS, ss);
1067 SelTR = ASMGetTR();
1068 rc |= VMXWriteVMCS(VMX_VMCS16_HOST_FIELD_TR, SelTR);
1069 AssertRC(rc);
1070 Log2(("VMX_VMCS_HOST_FIELD_CS %08x (%08x)\n", cs, ASMGetSS()));
1071 Log2(("VMX_VMCS_HOST_FIELD_DS 00000000 (%08x)\n", ASMGetDS()));
1072 Log2(("VMX_VMCS_HOST_FIELD_ES 00000000 (%08x)\n", ASMGetES()));
1073 Log2(("VMX_VMCS_HOST_FIELD_FS 00000000 (%08x)\n", ASMGetFS()));
1074 Log2(("VMX_VMCS_HOST_FIELD_GS 00000000 (%08x)\n", ASMGetGS()));
1075 Log2(("VMX_VMCS_HOST_FIELD_SS %08x (%08x)\n", ss, ASMGetSS()));
1076 Log2(("VMX_VMCS_HOST_FIELD_TR %08x\n", ASMGetTR()));
1077
1078 /* GDTR & IDTR */
1079#ifdef VBOX_WITH_HYBRID_32BIT_KERNEL
1080 if (VMX_IS_64BIT_HOST_MODE())
1081 {
1082 X86XDTR64 gdtr64, idtr64;
1083 hwaccmR0Get64bitGDTRandIDTR(&gdtr64, &idtr64);
1084 rc = VMXWriteVMCS64(VMX_VMCS_HOST_GDTR_BASE, gdtr64.uAddr);
1085 rc |= VMXWriteVMCS64(VMX_VMCS_HOST_IDTR_BASE, gdtr64.uAddr);
1086 AssertRC(rc);
1087 Log2(("VMX_VMCS_HOST_GDTR_BASE %RX64\n", gdtr64.uAddr));
1088 Log2(("VMX_VMCS_HOST_IDTR_BASE %RX64\n", idtr64.uAddr));
1089 gdtr.cbGdt = gdtr64.cb;
1090 gdtr.pGdt = (uintptr_t)gdtr64.uAddr;
1091 }
1092 else
1093#endif
1094 {
1095 ASMGetGDTR(&gdtr);
1096 rc = VMXWriteVMCS(VMX_VMCS_HOST_GDTR_BASE, gdtr.pGdt);
1097 ASMGetIDTR(&idtr);
1098 rc |= VMXWriteVMCS(VMX_VMCS_HOST_IDTR_BASE, idtr.pIdt);
1099 AssertRC(rc);
1100 Log2(("VMX_VMCS_HOST_GDTR_BASE %RHv\n", gdtr.pGdt));
1101 Log2(("VMX_VMCS_HOST_IDTR_BASE %RHv\n", idtr.pIdt));
1102 }
1103
1104 /* Save the base address of the TR selector. */
1105 if (SelTR > gdtr.cbGdt)
1106 {
1107 AssertMsgFailed(("Invalid TR selector %x. GDTR.cbGdt=%x\n", SelTR, gdtr.cbGdt));
1108 return VERR_VMX_INVALID_HOST_STATE;
1109 }
1110
1111#ifdef VBOX_WITH_HYBRID_32BIT_KERNEL
1112 if (VMX_IS_64BIT_HOST_MODE())
1113 {
1114 pDesc = &((PX86DESCHC)gdtr.pGdt)[SelTR >> X86_SEL_SHIFT_HC]; /// ????
1115 uint64_t trBase64 = X86DESC64_BASE(*(PX86DESC64)pDesc);
1116 rc = VMXWriteVMCS64(VMX_VMCS_HOST_TR_BASE, trBase64);
1117 Log2(("VMX_VMCS_HOST_TR_BASE %RX64\n", trBase64));
1118 AssertRC(rc);
1119 }
1120 else
1121#endif
1122 {
1123 pDesc = &((PX86DESCHC)gdtr.pGdt)[SelTR >> X86_SEL_SHIFT_HC];
1124#if HC_ARCH_BITS == 64
1125 trBase = X86DESC64_BASE(*pDesc);
1126#else
1127 trBase = X86DESC_BASE(*pDesc);
1128#endif
1129 rc = VMXWriteVMCS(VMX_VMCS_HOST_TR_BASE, trBase);
1130 AssertRC(rc);
1131 Log2(("VMX_VMCS_HOST_TR_BASE %RHv\n", trBase));
1132 }
1133
1134 /* FS and GS base. */
1135#if HC_ARCH_BITS == 64 || defined(VBOX_WITH_HYBRID_32BIT_KERNEL)
1136 if (VMX_IS_64BIT_HOST_MODE())
1137 {
1138 Log2(("MSR_K8_FS_BASE = %RX64\n", ASMRdMsr(MSR_K8_FS_BASE)));
1139 Log2(("MSR_K8_GS_BASE = %RX64\n", ASMRdMsr(MSR_K8_GS_BASE)));
1140 rc = VMXWriteVMCS64(VMX_VMCS_HOST_FS_BASE, ASMRdMsr(MSR_K8_FS_BASE));
1141 rc |= VMXWriteVMCS64(VMX_VMCS_HOST_GS_BASE, ASMRdMsr(MSR_K8_GS_BASE));
1142 }
1143#endif
1144 AssertRC(rc);
1145
1146 /* Sysenter MSRs. */
1147 /** @todo expensive!! */
1148 rc = VMXWriteVMCS(VMX_VMCS32_HOST_SYSENTER_CS, ASMRdMsr_Low(MSR_IA32_SYSENTER_CS));
1149 Log2(("VMX_VMCS_HOST_SYSENTER_CS %08x\n", ASMRdMsr_Low(MSR_IA32_SYSENTER_CS)));
1150#ifdef VBOX_WITH_HYBRID_32BIT_KERNEL
1151 if (VMX_IS_64BIT_HOST_MODE())
1152 {
1153 Log2(("VMX_VMCS_HOST_SYSENTER_EIP %RX64\n", ASMRdMsr(MSR_IA32_SYSENTER_EIP)));
1154 Log2(("VMX_VMCS_HOST_SYSENTER_ESP %RX64\n", ASMRdMsr(MSR_IA32_SYSENTER_ESP)));
1155 rc |= VMXWriteVMCS64(VMX_VMCS_HOST_SYSENTER_ESP, ASMRdMsr(MSR_IA32_SYSENTER_ESP));
1156 rc |= VMXWriteVMCS64(VMX_VMCS_HOST_SYSENTER_EIP, ASMRdMsr(MSR_IA32_SYSENTER_EIP));
1157 }
1158 else
1159 {
1160 rc |= VMXWriteVMCS(VMX_VMCS_HOST_SYSENTER_ESP, ASMRdMsr_Low(MSR_IA32_SYSENTER_ESP));
1161 rc |= VMXWriteVMCS(VMX_VMCS_HOST_SYSENTER_EIP, ASMRdMsr_Low(MSR_IA32_SYSENTER_EIP));
1162 Log2(("VMX_VMCS_HOST_SYSENTER_EIP %RX32\n", ASMRdMsr_Low(MSR_IA32_SYSENTER_EIP)));
1163 Log2(("VMX_VMCS_HOST_SYSENTER_ESP %RX32\n", ASMRdMsr_Low(MSR_IA32_SYSENTER_ESP)));
1164 }
1165#elif HC_ARCH_BITS == 32
1166 rc |= VMXWriteVMCS(VMX_VMCS_HOST_SYSENTER_ESP, ASMRdMsr_Low(MSR_IA32_SYSENTER_ESP));
1167 rc |= VMXWriteVMCS(VMX_VMCS_HOST_SYSENTER_EIP, ASMRdMsr_Low(MSR_IA32_SYSENTER_EIP));
1168 Log2(("VMX_VMCS_HOST_SYSENTER_EIP %RX32\n", ASMRdMsr_Low(MSR_IA32_SYSENTER_EIP)));
1169 Log2(("VMX_VMCS_HOST_SYSENTER_ESP %RX32\n", ASMRdMsr_Low(MSR_IA32_SYSENTER_ESP)));
1170#else
1171 Log2(("VMX_VMCS_HOST_SYSENTER_EIP %RX64\n", ASMRdMsr(MSR_IA32_SYSENTER_EIP)));
1172 Log2(("VMX_VMCS_HOST_SYSENTER_ESP %RX64\n", ASMRdMsr(MSR_IA32_SYSENTER_ESP)));
1173 rc |= VMXWriteVMCS64(VMX_VMCS_HOST_SYSENTER_ESP, ASMRdMsr(MSR_IA32_SYSENTER_ESP));
1174 rc |= VMXWriteVMCS64(VMX_VMCS_HOST_SYSENTER_EIP, ASMRdMsr(MSR_IA32_SYSENTER_EIP));
1175#endif
1176 AssertRC(rc);
1177
1178#ifdef VBOX_WITH_AUTO_MSR_LOAD_RESTORE
1179 /* Store all host MSRs in the VM-Exit load area, so they will be reloaded after the world switch back to the host. */
1180 PVMXMSR pMsr = (PVMXMSR)pVCpu->hwaccm.s.vmx.pHostMSR;
1181 unsigned idxMsr = 0;
1182
1183 /* EFER MSR present? */
1184 if (ASMCpuId_EDX(0x80000001) & (X86_CPUID_AMD_FEATURE_EDX_NX|X86_CPUID_AMD_FEATURE_EDX_LONG_MODE))
1185 {
1186 if (ASMCpuId_EDX(0x80000001) & X86_CPUID_AMD_FEATURE_EDX_SEP)
1187 {
1188 pMsr->u32IndexMSR = MSR_K6_STAR;
1189 pMsr->u32Reserved = 0;
1190 pMsr->u64Value = ASMRdMsr(MSR_K6_STAR); /* legacy syscall eip, cs & ss */
1191 pMsr++; idxMsr++;
1192 }
1193
1194 pMsr->u32IndexMSR = MSR_K6_EFER;
1195 pMsr->u32Reserved = 0;
1196# if HC_ARCH_BITS == 32 && defined(VBOX_ENABLE_64_BITS_GUESTS) && !defined(VBOX_WITH_HYBRID_32BIT_KERNEL)
1197 if (CPUMIsGuestInLongMode(pVCpu))
1198 {
1199 /* Must match the efer value in our 64 bits switcher. */
1200 pMsr->u64Value = ASMRdMsr(MSR_K6_EFER) | MSR_K6_EFER_LME | MSR_K6_EFER_SCE | MSR_K6_EFER_NXE;
1201 }
1202 else
1203# endif
1204 pMsr->u64Value = ASMRdMsr(MSR_K6_EFER);
1205 pMsr++; idxMsr++;
1206 }
1207
1208# if HC_ARCH_BITS == 64 || defined(VBOX_WITH_HYBRID_32BIT_KERNEL)
1209 if (VMX_IS_64BIT_HOST_MODE())
1210 {
1211 pMsr->u32IndexMSR = MSR_K8_LSTAR;
1212 pMsr->u32Reserved = 0;
1213 pMsr->u64Value = ASMRdMsr(MSR_K8_LSTAR); /* 64 bits mode syscall rip */
1214 pMsr++; idxMsr++;
1215 pMsr->u32IndexMSR = MSR_K8_SF_MASK;
1216 pMsr->u32Reserved = 0;
1217 pMsr->u64Value = ASMRdMsr(MSR_K8_SF_MASK); /* syscall flag mask */
1218 pMsr++; idxMsr++;
1219 pMsr->u32IndexMSR = MSR_K8_KERNEL_GS_BASE;
1220 pMsr->u32Reserved = 0;
1221 pMsr->u64Value = ASMRdMsr(MSR_K8_KERNEL_GS_BASE); /* swapgs exchange value */
1222 pMsr++; idxMsr++;
1223 }
1224# endif
1225 rc = VMXWriteVMCS(VMX_VMCS_CTRL_EXIT_MSR_LOAD_COUNT, idxMsr);
1226 AssertRC(rc);
1227#endif /* VBOX_WITH_AUTO_MSR_LOAD_RESTORE */
1228
1229 pVCpu->hwaccm.s.fContextUseFlags &= ~HWACCM_CHANGED_HOST_CONTEXT;
1230 }
1231 return rc;
1232}
1233
1234/**
1235 * Prefetch the 4 PDPT pointers (PAE and nested paging only)
1236 *
1237 * @param pVM The VM to operate on.
1238 * @param pVCpu The VMCPU to operate on.
1239 * @param pCtx Guest context
1240 */
1241static void vmxR0PrefetchPAEPdptrs(PVM pVM, PVMCPU pVCpu, PCPUMCTX pCtx)
1242{
1243 if (CPUMIsGuestInPAEModeEx(pCtx))
1244 {
1245 X86PDPE Pdpe;
1246
1247 for (unsigned i=0;i<4;i++)
1248 {
1249 Pdpe = PGMGstGetPaePDPtr(pVCpu, i);
1250 int rc = VMXWriteVMCS64(VMX_VMCS_GUEST_PDPTR0_FULL + i*2, Pdpe.u);
1251 AssertRC(rc);
1252 }
1253 }
1254}
1255
1256/**
1257 * Update the exception bitmap according to the current CPU state
1258 *
1259 * @param pVM The VM to operate on.
1260 * @param pVCpu The VMCPU to operate on.
1261 * @param pCtx Guest context
1262 */
1263static void vmxR0UpdateExceptionBitmap(PVM pVM, PVMCPU pVCpu, PCPUMCTX pCtx)
1264{
1265 uint32_t u32TrapMask;
1266 Assert(pCtx);
1267
1268 u32TrapMask = HWACCM_VMX_TRAP_MASK;
1269#ifndef DEBUG
1270 if (pVM->hwaccm.s.fNestedPaging)
1271 u32TrapMask &= ~RT_BIT(X86_XCPT_PF); /* no longer need to intercept #PF. */
1272#endif
1273
1274 /* Also catch floating point exceptions as we need to report them to the guest in a different way. */
1275 if ( CPUMIsGuestFPUStateActive(pVCpu) == true
1276 && !(pCtx->cr0 & X86_CR0_NE)
1277 && !pVCpu->hwaccm.s.fFPUOldStyleOverride)
1278 {
1279 u32TrapMask |= RT_BIT(X86_XCPT_MF);
1280 pVCpu->hwaccm.s.fFPUOldStyleOverride = true;
1281 }
1282
1283#ifdef DEBUG /* till after branching, enable it by default then. */
1284 /* Intercept X86_XCPT_DB if stepping is enabled */
1285 if ( DBGFIsStepping(pVCpu)
1286 || CPUMIsHyperDebugStateActive(pVCpu))
1287 u32TrapMask |= RT_BIT(X86_XCPT_DB);
1288 /** @todo Don't trap it unless the debugger has armed breakpoints. */
1289 u32TrapMask |= RT_BIT(X86_XCPT_BP);
1290#endif
1291
1292#ifdef VBOX_STRICT
1293 Assert(u32TrapMask & RT_BIT(X86_XCPT_GP));
1294#endif
1295
1296# ifdef HWACCM_VMX_EMULATE_REALMODE
1297 /* Intercept all exceptions in real mode as none of them can be injected directly (#GP otherwise). */
1298 if (CPUMIsGuestInRealModeEx(pCtx) && pVM->hwaccm.s.vmx.pRealModeTSS)
1299 u32TrapMask |= HWACCM_VMX_TRAP_MASK_REALMODE;
1300# endif /* HWACCM_VMX_EMULATE_REALMODE */
1301
1302 int rc = VMXWriteVMCS(VMX_VMCS_CTRL_EXCEPTION_BITMAP, u32TrapMask);
1303 AssertRC(rc);
1304}
1305
1306/**
1307 * Loads the guest state
1308 *
1309 * NOTE: Don't do anything here that can cause a jump back to ring 3!!!!!
1310 *
1311 * @returns VBox status code.
1312 * @param pVM The VM to operate on.
1313 * @param pVCpu The VMCPU to operate on.
1314 * @param pCtx Guest context
1315 */
1316VMMR0DECL(int) VMXR0LoadGuestState(PVM pVM, PVMCPU pVCpu, PCPUMCTX pCtx)
1317{
1318 int rc = VINF_SUCCESS;
1319 RTGCUINTPTR val;
1320 X86EFLAGS eflags;
1321
1322 /* VMX_VMCS_CTRL_ENTRY_CONTROLS
1323 * Set required bits to one and zero according to the MSR capabilities.
1324 */
1325 val = pVM->hwaccm.s.vmx.msr.vmx_entry.n.disallowed0;
1326 /* Load guest debug controls (dr7 & IA32_DEBUGCTL_MSR) (forced to 1 on the 'first' VT-x capable CPUs; this actually includes the newest Nehalem CPUs) */
1327 val |= VMX_VMCS_CTRL_ENTRY_CONTROLS_LOAD_DEBUG;
1328 /* 64 bits guest mode? */
1329 if (CPUMIsGuestInLongModeEx(pCtx))
1330 val |= VMX_VMCS_CTRL_ENTRY_CONTROLS_IA64_MODE;
1331 /* else Must be zero when AMD64 is not available. */
1332
1333 /* Mask away the bits that the CPU doesn't support */
1334 val &= pVM->hwaccm.s.vmx.msr.vmx_entry.n.allowed1;
1335 rc = VMXWriteVMCS(VMX_VMCS_CTRL_ENTRY_CONTROLS, val);
1336 AssertRC(rc);
1337
1338 /* VMX_VMCS_CTRL_EXIT_CONTROLS
1339 * Set required bits to one and zero according to the MSR capabilities.
1340 */
1341 val = pVM->hwaccm.s.vmx.msr.vmx_exit.n.disallowed0;
1342
1343 /* Save debug controls (dr7 & IA32_DEBUGCTL_MSR) (forced to 1 on the 'first' VT-x capable CPUs; this actually includes the newest Nehalem CPUs) */
1344 val |= VMX_VMCS_CTRL_EXIT_CONTROLS_SAVE_DEBUG;
1345
1346#if HC_ARCH_BITS == 64 || defined(VBOX_WITH_HYBRID_32BIT_KERNEL)
1347 if (VMX_IS_64BIT_HOST_MODE())
1348 val |= VMX_VMCS_CTRL_EXIT_CONTROLS_HOST_AMD64;
1349 /* else: Must be zero when AMD64 is not available. */
1350#elif HC_ARCH_BITS == 32 && defined(VBOX_ENABLE_64_BITS_GUESTS)
1351 if (CPUMIsGuestInLongModeEx(pCtx))
1352 val |= VMX_VMCS_CTRL_EXIT_CONTROLS_HOST_AMD64; /* our switcher goes to long mode */
1353 else
1354 Assert(!(val & VMX_VMCS_CTRL_EXIT_CONTROLS_HOST_AMD64));
1355#endif
1356 val &= pVM->hwaccm.s.vmx.msr.vmx_exit.n.allowed1;
1357 /* Don't acknowledge external interrupts on VM-exit. */
1358 rc = VMXWriteVMCS(VMX_VMCS_CTRL_EXIT_CONTROLS, val);
1359 AssertRC(rc);
1360
1361 /* Guest CPU context: ES, CS, SS, DS, FS, GS. */
1362 if (pVCpu->hwaccm.s.fContextUseFlags & HWACCM_CHANGED_GUEST_SEGMENT_REGS)
1363 {
1364#ifdef HWACCM_VMX_EMULATE_REALMODE
1365 if (pVM->hwaccm.s.vmx.pRealModeTSS)
1366 {
1367 PGMMODE enmGuestMode = PGMGetGuestMode(pVCpu);
1368 if (pVCpu->hwaccm.s.vmx.enmLastSeenGuestMode != enmGuestMode)
1369 {
1370 /* Correct weird requirements for switching to protected mode. */
1371 if ( pVCpu->hwaccm.s.vmx.enmLastSeenGuestMode == PGMMODE_REAL
1372 && enmGuestMode >= PGMMODE_PROTECTED)
1373 {
1374 /* Flush the recompiler code cache as it's not unlikely
1375 * the guest will rewrite code it will later execute in real
1376 * mode (OpenBSD 4.0 is one such example)
1377 */
1378 REMFlushTBs(pVM);
1379
1380 /* DPL of all hidden selector registers must match the current CPL (0). */
1381 pCtx->csHid.Attr.n.u2Dpl = 0;
1382 pCtx->csHid.Attr.n.u4Type = X86_SEL_TYPE_CODE | X86_SEL_TYPE_RW_ACC;
1383
1384 pCtx->dsHid.Attr.n.u2Dpl = 0;
1385 pCtx->esHid.Attr.n.u2Dpl = 0;
1386 pCtx->fsHid.Attr.n.u2Dpl = 0;
1387 pCtx->gsHid.Attr.n.u2Dpl = 0;
1388 pCtx->ssHid.Attr.n.u2Dpl = 0;
1389
1390 /* The limit must correspond to the 32 bits setting. */
1391 if (!pCtx->csHid.Attr.n.u1DefBig)
1392 pCtx->csHid.u32Limit &= 0xffff;
1393 if (!pCtx->dsHid.Attr.n.u1DefBig)
1394 pCtx->dsHid.u32Limit &= 0xffff;
1395 if (!pCtx->esHid.Attr.n.u1DefBig)
1396 pCtx->esHid.u32Limit &= 0xffff;
1397 if (!pCtx->fsHid.Attr.n.u1DefBig)
1398 pCtx->fsHid.u32Limit &= 0xffff;
1399 if (!pCtx->gsHid.Attr.n.u1DefBig)
1400 pCtx->gsHid.u32Limit &= 0xffff;
1401 if (!pCtx->ssHid.Attr.n.u1DefBig)
1402 pCtx->ssHid.u32Limit &= 0xffff;
1403 }
1404 else
1405 /* Switching from protected mode to real mode. */
1406 if ( pVCpu->hwaccm.s.vmx.enmLastSeenGuestMode >= PGMMODE_PROTECTED
1407 && enmGuestMode == PGMMODE_REAL)
1408 {
1409 /* The limit must also be set to 0xffff. */
1410 pCtx->csHid.u32Limit = 0xffff;
1411 pCtx->dsHid.u32Limit = 0xffff;
1412 pCtx->esHid.u32Limit = 0xffff;
1413 pCtx->fsHid.u32Limit = 0xffff;
1414 pCtx->gsHid.u32Limit = 0xffff;
1415 pCtx->ssHid.u32Limit = 0xffff;
1416
1417 Assert(pCtx->csHid.u64Base <= 0xfffff);
1418 Assert(pCtx->dsHid.u64Base <= 0xfffff);
1419 Assert(pCtx->esHid.u64Base <= 0xfffff);
1420 Assert(pCtx->fsHid.u64Base <= 0xfffff);
1421 Assert(pCtx->gsHid.u64Base <= 0xfffff);
1422 }
1423 pVCpu->hwaccm.s.vmx.enmLastSeenGuestMode = enmGuestMode;
1424 }
1425 else
1426 /* VT-x will fail with a guest invalid state otherwise... (CPU state after a reset) */
1427 if ( CPUMIsGuestInRealModeEx(pCtx)
1428 && pCtx->csHid.u64Base == 0xffff0000)
1429 {
1430 pCtx->csHid.u64Base = 0xf0000;
1431 pCtx->cs = 0xf000;
1432 }
1433 }
1434#endif /* HWACCM_VMX_EMULATE_REALMODE */
1435
1436 VMX_WRITE_SELREG(ES, es);
1437 AssertRC(rc);
1438
1439 VMX_WRITE_SELREG(CS, cs);
1440 AssertRC(rc);
1441
1442 VMX_WRITE_SELREG(SS, ss);
1443 AssertRC(rc);
1444
1445 VMX_WRITE_SELREG(DS, ds);
1446 AssertRC(rc);
1447
1448 VMX_WRITE_SELREG(FS, fs);
1449 AssertRC(rc);
1450
1451 VMX_WRITE_SELREG(GS, gs);
1452 AssertRC(rc);
1453 }
1454
1455 /* Guest CPU context: LDTR. */
1456 if (pVCpu->hwaccm.s.fContextUseFlags & HWACCM_CHANGED_GUEST_LDTR)
1457 {
1458 if (pCtx->ldtr == 0)
1459 {
1460 rc = VMXWriteVMCS(VMX_VMCS16_GUEST_FIELD_LDTR, 0);
1461 rc |= VMXWriteVMCS(VMX_VMCS32_GUEST_LDTR_LIMIT, 0);
1462 rc |= VMXWriteVMCS64(VMX_VMCS64_GUEST_LDTR_BASE, 0);
1463 /* Note: vmlaunch will fail with 0 or just 0x02. No idea why. */
1464 rc |= VMXWriteVMCS(VMX_VMCS32_GUEST_LDTR_ACCESS_RIGHTS, 0x82 /* present, LDT */);
1465 }
1466 else
1467 {
1468 rc = VMXWriteVMCS(VMX_VMCS16_GUEST_FIELD_LDTR, pCtx->ldtr);
1469 rc |= VMXWriteVMCS(VMX_VMCS32_GUEST_LDTR_LIMIT, pCtx->ldtrHid.u32Limit);
1470 rc |= VMXWriteVMCS64(VMX_VMCS64_GUEST_LDTR_BASE, pCtx->ldtrHid.u64Base);
1471 rc |= VMXWriteVMCS(VMX_VMCS32_GUEST_LDTR_ACCESS_RIGHTS, pCtx->ldtrHid.Attr.u);
1472 }
1473 AssertRC(rc);
1474 }
1475 /* Guest CPU context: TR. */
1476 if (pVCpu->hwaccm.s.fContextUseFlags & HWACCM_CHANGED_GUEST_TR)
1477 {
1478#ifdef HWACCM_VMX_EMULATE_REALMODE
1479 /* Real mode emulation using v86 mode with CR4.VME (interrupt redirection using the int bitmap in the TSS) */
1480 if (CPUMIsGuestInRealModeEx(pCtx))
1481 {
1482 RTGCPHYS GCPhys;
1483
1484 /* We convert it here every time as pci regions could be reconfigured. */
1485 rc = PDMVMMDevHeapR3ToGCPhys(pVM, pVM->hwaccm.s.vmx.pRealModeTSS, &GCPhys);
1486 AssertRC(rc);
1487
1488 rc = VMXWriteVMCS(VMX_VMCS16_GUEST_FIELD_TR, 0);
1489 rc |= VMXWriteVMCS(VMX_VMCS32_GUEST_TR_LIMIT, HWACCM_VTX_TSS_SIZE);
1490 rc |= VMXWriteVMCS64(VMX_VMCS64_GUEST_TR_BASE, GCPhys /* phys = virt in this mode */);
1491
1492 X86DESCATTR attr;
1493
1494 attr.u = 0;
1495 attr.n.u1Present = 1;
1496 attr.n.u4Type = X86_SEL_TYPE_SYS_386_TSS_BUSY;
1497 val = attr.u;
1498 }
1499 else
1500#endif /* HWACCM_VMX_EMULATE_REALMODE */
1501 {
1502 rc = VMXWriteVMCS(VMX_VMCS16_GUEST_FIELD_TR, pCtx->tr);
1503 rc |= VMXWriteVMCS(VMX_VMCS32_GUEST_TR_LIMIT, pCtx->trHid.u32Limit);
1504 rc |= VMXWriteVMCS64(VMX_VMCS64_GUEST_TR_BASE, pCtx->trHid.u64Base);
1505
1506 val = pCtx->trHid.Attr.u;
1507
1508 /* The TSS selector must be busy. */
1509 if ((val & 0xF) == X86_SEL_TYPE_SYS_286_TSS_AVAIL)
1510 val = (val & ~0xF) | X86_SEL_TYPE_SYS_286_TSS_BUSY;
1511 else
1512 /* Default even if no TR selector has been set (otherwise vmlaunch will fail!) */
1513 val = (val & ~0xF) | X86_SEL_TYPE_SYS_386_TSS_BUSY;
1514
1515 }
1516 rc |= VMXWriteVMCS(VMX_VMCS32_GUEST_TR_ACCESS_RIGHTS, val);
1517 AssertRC(rc);
1518 }
1519 /* Guest CPU context: GDTR. */
1520 if (pVCpu->hwaccm.s.fContextUseFlags & HWACCM_CHANGED_GUEST_GDTR)
1521 {
1522 rc = VMXWriteVMCS(VMX_VMCS32_GUEST_GDTR_LIMIT, pCtx->gdtr.cbGdt);
1523 rc |= VMXWriteVMCS64(VMX_VMCS64_GUEST_GDTR_BASE, pCtx->gdtr.pGdt);
1524 AssertRC(rc);
1525 }
1526 /* Guest CPU context: IDTR. */
1527 if (pVCpu->hwaccm.s.fContextUseFlags & HWACCM_CHANGED_GUEST_IDTR)
1528 {
1529 rc = VMXWriteVMCS(VMX_VMCS32_GUEST_IDTR_LIMIT, pCtx->idtr.cbIdt);
1530 rc |= VMXWriteVMCS64(VMX_VMCS64_GUEST_IDTR_BASE, pCtx->idtr.pIdt);
1531 AssertRC(rc);
1532 }
1533
1534 /*
1535 * Sysenter MSRs (unconditional)
1536 */
1537 rc = VMXWriteVMCS(VMX_VMCS32_GUEST_SYSENTER_CS, pCtx->SysEnter.cs);
1538 rc |= VMXWriteVMCS64(VMX_VMCS64_GUEST_SYSENTER_EIP, pCtx->SysEnter.eip);
1539 rc |= VMXWriteVMCS64(VMX_VMCS64_GUEST_SYSENTER_ESP, pCtx->SysEnter.esp);
1540 AssertRC(rc);
1541
1542 /* Control registers */
1543 if (pVCpu->hwaccm.s.fContextUseFlags & HWACCM_CHANGED_GUEST_CR0)
1544 {
1545 val = pCtx->cr0;
1546 rc = VMXWriteVMCS(VMX_VMCS_CTRL_CR0_READ_SHADOW, val);
1547 Log2(("Guest CR0-shadow %08x\n", val));
1548 if (CPUMIsGuestFPUStateActive(pVCpu) == false)
1549 {
1550 /* Always use #NM exceptions to load the FPU/XMM state on demand. */
1551 val |= X86_CR0_TS | X86_CR0_ET | X86_CR0_NE | X86_CR0_MP;
1552 }
1553 else
1554 {
1555 /** @todo check if we support the old style mess correctly. */
1556 if (!(val & X86_CR0_NE))
1557 Log(("Forcing X86_CR0_NE!!!\n"));
1558
1559 val |= X86_CR0_NE; /* always turn on the native mechanism to report FPU errors (old style uses interrupts) */
1560 }
1561 /* Note: protected mode & paging are always enabled; we use them for emulating real and protected mode without paging too. */
1562 val |= X86_CR0_PE | X86_CR0_PG;
1563 if (pVM->hwaccm.s.fNestedPaging)
1564 {
1565 if (CPUMIsGuestInPagedProtectedModeEx(pCtx))
1566 {
1567 /* Disable cr3 read/write monitoring as we don't need it for EPT. */
1568 pVCpu->hwaccm.s.vmx.proc_ctls &= ~( VMX_VMCS_CTRL_PROC_EXEC_CONTROLS_CR3_LOAD_EXIT
1569 | VMX_VMCS_CTRL_PROC_EXEC_CONTROLS_CR3_STORE_EXIT);
1570 }
1571 else
1572 {
1573 /* Reenable cr3 read/write monitoring as our identity mapped page table is active. */
1574 pVCpu->hwaccm.s.vmx.proc_ctls |= VMX_VMCS_CTRL_PROC_EXEC_CONTROLS_CR3_LOAD_EXIT
1575 | VMX_VMCS_CTRL_PROC_EXEC_CONTROLS_CR3_STORE_EXIT;
1576 }
1577 rc = VMXWriteVMCS(VMX_VMCS_CTRL_PROC_EXEC_CONTROLS, pVCpu->hwaccm.s.vmx.proc_ctls);
1578 AssertRC(rc);
1579 }
1580 else
1581 {
1582 /* Note: We must also set this as we rely on protecting various pages for which supervisor writes must be caught. */
1583 val |= X86_CR0_WP;
1584 }
1585
1586 /* Always enable caching. */
1587 val &= ~(X86_CR0_CD|X86_CR0_NW);
1588
1589 rc |= VMXWriteVMCS64(VMX_VMCS64_GUEST_CR0, val);
1590 Log2(("Guest CR0 %08x\n", val));
1591 /* CR0 flags owned by the host; if the guests attempts to change them, then
1592 * the VM will exit.
1593 */
1594 val = X86_CR0_PE /* Must monitor this bit (assumptions are made for real mode emulation) */
1595 | X86_CR0_WP /* Must monitor this bit (it must always be enabled). */
1596 | X86_CR0_PG /* Must monitor this bit (assumptions are made for real mode & protected mode without paging emulation) */
1597 | X86_CR0_TS
1598 | X86_CR0_ET /* Bit not restored during VM-exit! */
1599 | X86_CR0_CD /* Bit not restored during VM-exit! */
1600 | X86_CR0_NW /* Bit not restored during VM-exit! */
1601 | X86_CR0_NE
1602 | X86_CR0_MP;
1603 pVCpu->hwaccm.s.vmx.cr0_mask = val;
1604
1605 rc |= VMXWriteVMCS(VMX_VMCS_CTRL_CR0_MASK, val);
1606 Log2(("Guest CR0-mask %08x\n", val));
1607 AssertRC(rc);
1608 }
1609 if (pVCpu->hwaccm.s.fContextUseFlags & HWACCM_CHANGED_GUEST_CR4)
1610 {
1611 /* CR4 */
1612 rc = VMXWriteVMCS(VMX_VMCS_CTRL_CR4_READ_SHADOW, pCtx->cr4);
1613 Log2(("Guest CR4-shadow %08x\n", pCtx->cr4));
1614 /* Set the required bits in cr4 too (currently X86_CR4_VMXE). */
1615 val = pCtx->cr4 | (uint32_t)pVM->hwaccm.s.vmx.msr.vmx_cr4_fixed0;
1616
1617 if (!pVM->hwaccm.s.fNestedPaging)
1618 {
1619 switch(pVCpu->hwaccm.s.enmShadowMode)
1620 {
1621 case PGMMODE_REAL: /* Real mode -> emulated using v86 mode */
1622 case PGMMODE_PROTECTED: /* Protected mode, no paging -> emulated using identity mapping. */
1623 case PGMMODE_32_BIT: /* 32-bit paging. */
1624 val &= ~X86_CR4_PAE;
1625 break;
1626
1627 case PGMMODE_PAE: /* PAE paging. */
1628 case PGMMODE_PAE_NX: /* PAE paging with NX enabled. */
1629 /** @todo use normal 32 bits paging */
1630 val |= X86_CR4_PAE;
1631 break;
1632
1633 case PGMMODE_AMD64: /* 64-bit AMD paging (long mode). */
1634 case PGMMODE_AMD64_NX: /* 64-bit AMD paging (long mode) with NX enabled. */
1635#ifdef VBOX_ENABLE_64_BITS_GUESTS
1636 break;
1637#else
1638 AssertFailed();
1639 return VERR_PGM_UNSUPPORTED_SHADOW_PAGING_MODE;
1640#endif
1641 default: /* shut up gcc */
1642 AssertFailed();
1643 return VERR_PGM_UNSUPPORTED_SHADOW_PAGING_MODE;
1644 }
1645 }
1646 else
1647 if (!CPUMIsGuestInPagedProtectedModeEx(pCtx))
1648 {
1649 /* We use 4 MB pages in our identity mapping page table for real and protected mode without paging. */
1650 val |= X86_CR4_PSE;
1651 /* Our identity mapping is a 32 bits page directory. */
1652 val &= ~X86_CR4_PAE;
1653 }
1654
1655 /* Turn off VME if we're in emulated real mode. */
1656 if (CPUMIsGuestInRealModeEx(pCtx))
1657 val &= ~X86_CR4_VME;
1658
1659 rc |= VMXWriteVMCS64(VMX_VMCS64_GUEST_CR4, val);
1660 Log2(("Guest CR4 %08x\n", val));
1661 /* CR4 flags owned by the host; if the guests attempts to change them, then
1662 * the VM will exit.
1663 */
1664 val = 0
1665 | X86_CR4_VME
1666 | X86_CR4_PAE
1667 | X86_CR4_PGE
1668 | X86_CR4_PSE
1669 | X86_CR4_VMXE;
1670 pVCpu->hwaccm.s.vmx.cr4_mask = val;
1671
1672 rc |= VMXWriteVMCS(VMX_VMCS_CTRL_CR4_MASK, val);
1673 Log2(("Guest CR4-mask %08x\n", val));
1674 AssertRC(rc);
1675 }
1676
1677 if (pVCpu->hwaccm.s.fContextUseFlags & HWACCM_CHANGED_GUEST_CR3)
1678 {
1679 if (pVM->hwaccm.s.fNestedPaging)
1680 {
1681 Assert(PGMGetHyperCR3(pVCpu));
1682 pVCpu->hwaccm.s.vmx.GCPhysEPTP = PGMGetHyperCR3(pVCpu);
1683
1684 Assert(!(pVCpu->hwaccm.s.vmx.GCPhysEPTP & 0xfff));
1685 /** @todo Check the IA32_VMX_EPT_VPID_CAP MSR for other supported memory types. */
1686 pVCpu->hwaccm.s.vmx.GCPhysEPTP |= VMX_EPT_MEMTYPE_WB
1687 | (VMX_EPT_PAGE_WALK_LENGTH_DEFAULT << VMX_EPT_PAGE_WALK_LENGTH_SHIFT);
1688
1689 rc = VMXWriteVMCS64(VMX_VMCS_CTRL_EPTP_FULL, pVCpu->hwaccm.s.vmx.GCPhysEPTP);
1690 AssertRC(rc);
1691
1692 if (!CPUMIsGuestInPagedProtectedModeEx(pCtx))
1693 {
1694 RTGCPHYS GCPhys;
1695
1696 /* We convert it here every time as pci regions could be reconfigured. */
1697 rc = PDMVMMDevHeapR3ToGCPhys(pVM, pVM->hwaccm.s.vmx.pNonPagingModeEPTPageTable, &GCPhys);
1698 AssertRC(rc);
1699
1700 /* We use our identity mapping page table here as we need to map guest virtual to guest physical addresses; EPT will
1701 * take care of the translation to host physical addresses.
1702 */
1703 val = GCPhys;
1704 }
1705 else
1706 {
1707 /* Save the real guest CR3 in VMX_VMCS_GUEST_CR3 */
1708 val = pCtx->cr3;
1709 /* Prefetch the four PDPT entries in PAE mode. */
1710 vmxR0PrefetchPAEPdptrs(pVM, pVCpu, pCtx);
1711 }
1712 }
1713 else
1714 {
1715 val = PGMGetHyperCR3(pVCpu);
1716 Assert(val || VMCPU_FF_ISPENDING(pVCpu, VMCPU_FF_PGM_SYNC_CR3 | VMCPU_FF_PGM_SYNC_CR3_NON_GLOBAL));
1717 }
1718
1719 /* Save our shadow CR3 register. */
1720 rc = VMXWriteVMCS64(VMX_VMCS64_GUEST_CR3, val);
1721 AssertRC(rc);
1722 }
1723
1724 /* Debug registers. */
1725 if (pVCpu->hwaccm.s.fContextUseFlags & HWACCM_CHANGED_GUEST_DEBUG)
1726 {
1727 pCtx->dr[6] |= X86_DR6_INIT_VAL; /* set all reserved bits to 1. */
1728 pCtx->dr[6] &= ~RT_BIT(12); /* must be zero. */
1729
1730 pCtx->dr[7] &= 0xffffffff; /* upper 32 bits reserved */
1731 pCtx->dr[7] &= ~(RT_BIT(11) | RT_BIT(12) | RT_BIT(14) | RT_BIT(15)); /* must be zero */
1732 pCtx->dr[7] |= 0x400; /* must be one */
1733
1734 /* Resync DR7 */
1735 rc = VMXWriteVMCS64(VMX_VMCS64_GUEST_DR7, pCtx->dr[7]);
1736 AssertRC(rc);
1737
1738#ifdef DEBUG
1739 /* Sync the hypervisor debug state now if any breakpoint is armed. */
1740 if ( CPUMGetHyperDR7(pVCpu) & (X86_DR7_ENABLED_MASK|X86_DR7_GD)
1741 && !CPUMIsHyperDebugStateActive(pVCpu)
1742 && !DBGFIsStepping(pVCpu))
1743 {
1744 /* Save the host and load the hypervisor debug state. */
1745 rc = CPUMR0LoadHyperDebugState(pVM, pVCpu, pCtx, true /* include DR6 */);
1746 AssertRC(rc);
1747
1748 /* DRx intercepts remain enabled. */
1749
1750 /* Override dr7 with the hypervisor value. */
1751 rc = VMXWriteVMCS64(VMX_VMCS64_GUEST_DR7, CPUMGetHyperDR7(pVCpu));
1752 AssertRC(rc);
1753 }
1754 else
1755#endif
1756 /* Sync the debug state now if any breakpoint is armed. */
1757 if ( (pCtx->dr[7] & (X86_DR7_ENABLED_MASK|X86_DR7_GD))
1758 && !CPUMIsGuestDebugStateActive(pVCpu)
1759 && !DBGFIsStepping(pVCpu))
1760 {
1761 STAM_COUNTER_INC(&pVCpu->hwaccm.s.StatDRxArmed);
1762
1763 /* Disable drx move intercepts. */
1764 pVCpu->hwaccm.s.vmx.proc_ctls &= ~VMX_VMCS_CTRL_PROC_EXEC_CONTROLS_MOV_DR_EXIT;
1765 rc = VMXWriteVMCS(VMX_VMCS_CTRL_PROC_EXEC_CONTROLS, pVCpu->hwaccm.s.vmx.proc_ctls);
1766 AssertRC(rc);
1767
1768 /* Save the host and load the guest debug state. */
1769 rc = CPUMR0LoadGuestDebugState(pVM, pVCpu, pCtx, true /* include DR6 */);
1770 AssertRC(rc);
1771 }
1772
1773 /* IA32_DEBUGCTL MSR. */
1774 rc = VMXWriteVMCS64(VMX_VMCS_GUEST_DEBUGCTL_FULL, 0);
1775 AssertRC(rc);
1776
1777 /** @todo do we really ever need this? */
1778 rc |= VMXWriteVMCS(VMX_VMCS_GUEST_DEBUG_EXCEPTIONS, 0);
1779 AssertRC(rc);
1780 }
1781
1782 /* EIP, ESP and EFLAGS */
1783 rc = VMXWriteVMCS64(VMX_VMCS64_GUEST_RIP, pCtx->rip);
1784 rc |= VMXWriteVMCS64(VMX_VMCS64_GUEST_RSP, pCtx->rsp);
1785 AssertRC(rc);
1786
1787 /* Bits 22-31, 15, 5 & 3 must be zero. Bit 1 must be 1. */
1788 eflags = pCtx->eflags;
1789 eflags.u32 &= VMX_EFLAGS_RESERVED_0;
1790 eflags.u32 |= VMX_EFLAGS_RESERVED_1;
1791
1792#ifdef HWACCM_VMX_EMULATE_REALMODE
1793 /* Real mode emulation using v86 mode. */
1794 if (CPUMIsGuestInRealModeEx(pCtx))
1795 {
1796 pVCpu->hwaccm.s.vmx.RealMode.eflags = eflags;
1797
1798 eflags.Bits.u1VM = 1;
1799 eflags.Bits.u2IOPL = 0; /* must always be 0 or else certain instructions won't cause faults. */
1800 }
1801#endif /* HWACCM_VMX_EMULATE_REALMODE */
1802 rc = VMXWriteVMCS(VMX_VMCS_GUEST_RFLAGS, eflags.u32);
1803 AssertRC(rc);
1804
1805 if (TMCpuTickCanUseRealTSC(pVCpu, &pVCpu->hwaccm.s.vmx.u64TSCOffset))
1806 {
1807 uint64_t u64CurTSC = ASMReadTSC();
1808 if (u64CurTSC + pVCpu->hwaccm.s.vmx.u64TSCOffset >= TMCpuTickGetLastSeen(pVCpu))
1809 {
1810 /* Note: VMX_VMCS_CTRL_PROC_EXEC_CONTROLS_RDTSC_EXIT takes precedence over TSC_OFFSET */
1811 rc = VMXWriteVMCS64(VMX_VMCS_CTRL_TSC_OFFSET_FULL, pVCpu->hwaccm.s.vmx.u64TSCOffset);
1812 AssertRC(rc);
1813
1814 pVCpu->hwaccm.s.vmx.proc_ctls &= ~VMX_VMCS_CTRL_PROC_EXEC_CONTROLS_RDTSC_EXIT;
1815 rc = VMXWriteVMCS(VMX_VMCS_CTRL_PROC_EXEC_CONTROLS, pVCpu->hwaccm.s.vmx.proc_ctls);
1816 AssertRC(rc);
1817 STAM_COUNTER_INC(&pVCpu->hwaccm.s.StatTSCOffset);
1818 }
1819 else
1820 {
1821 /* Fall back to rdtsc emulation as we would otherwise pass decreasing tsc values to the guest. */
1822 Log(("TSC %RX64 offset %RX64 time=%RX64 last=%RX64 (diff=%RX64, virt_tsc=%RX64)\n", u64CurTSC, pVCpu->hwaccm.s.vmx.u64TSCOffset, u64CurTSC + pVCpu->hwaccm.s.vmx.u64TSCOffset, TMCpuTickGetLastSeen(pVCpu), TMCpuTickGetLastSeen(pVCpu) - u64CurTSC - pVCpu->hwaccm.s.vmx.u64TSCOffset, TMCpuTickGet(pVCpu)));
1823 pVCpu->hwaccm.s.vmx.proc_ctls |= VMX_VMCS_CTRL_PROC_EXEC_CONTROLS_RDTSC_EXIT;
1824 rc = VMXWriteVMCS(VMX_VMCS_CTRL_PROC_EXEC_CONTROLS, pVCpu->hwaccm.s.vmx.proc_ctls);
1825 AssertRC(rc);
1826 STAM_COUNTER_INC(&pVCpu->hwaccm.s.StatTSCInterceptOverFlow);
1827 }
1828 }
1829 else
1830 {
1831 pVCpu->hwaccm.s.vmx.proc_ctls |= VMX_VMCS_CTRL_PROC_EXEC_CONTROLS_RDTSC_EXIT;
1832 rc = VMXWriteVMCS(VMX_VMCS_CTRL_PROC_EXEC_CONTROLS, pVCpu->hwaccm.s.vmx.proc_ctls);
1833 AssertRC(rc);
1834 STAM_COUNTER_INC(&pVCpu->hwaccm.s.StatTSCIntercept);
1835 }
1836
1837 /* 64 bits guest mode? */
1838 if (CPUMIsGuestInLongModeEx(pCtx))
1839 {
1840#if !defined(VBOX_ENABLE_64_BITS_GUESTS)
1841 return VERR_PGM_UNSUPPORTED_SHADOW_PAGING_MODE;
1842#elif HC_ARCH_BITS == 32 && !defined(VBOX_WITH_HYBRID_32BIT_KERNEL)
1843 pVCpu->hwaccm.s.vmx.pfnStartVM = VMXR0SwitcherStartVM64;
1844#else
1845# ifdef VBOX_WITH_HYBRID_32BIT_KERNEL
1846 if (!pVM->hwaccm.s.fAllow64BitGuests)
1847 return VERR_PGM_UNSUPPORTED_SHADOW_PAGING_MODE;
1848# endif
1849 pVCpu->hwaccm.s.vmx.pfnStartVM = VMXR0StartVM64;
1850#endif
1851 /* Unconditionally update these as wrmsr might have changed them. */
1852 rc = VMXWriteVMCS64(VMX_VMCS64_GUEST_FS_BASE, pCtx->fsHid.u64Base);
1853 AssertRC(rc);
1854 rc = VMXWriteVMCS64(VMX_VMCS64_GUEST_GS_BASE, pCtx->gsHid.u64Base);
1855 AssertRC(rc);
1856 }
1857 else
1858 {
1859 pVCpu->hwaccm.s.vmx.pfnStartVM = VMXR0StartVM32;
1860 }
1861
1862 vmxR0UpdateExceptionBitmap(pVM, pVCpu, pCtx);
1863
1864#ifdef VBOX_WITH_AUTO_MSR_LOAD_RESTORE
1865 /* Store all guest MSRs in the VM-Entry load area, so they will be loaded during the world switch. */
1866 PVMXMSR pMsr = (PVMXMSR)pVCpu->hwaccm.s.vmx.pGuestMSR;
1867 unsigned idxMsr = 0;
1868
1869 uint32_t ulEdx;
1870 uint32_t ulTemp;
1871 CPUMGetGuestCpuId(pVCpu, 0x80000001, &ulTemp, &ulTemp, &ulTemp, &ulEdx);
1872 /* EFER MSR present? */
1873 if (ulEdx & (X86_CPUID_AMD_FEATURE_EDX_NX|X86_CPUID_AMD_FEATURE_EDX_LONG_MODE))
1874 {
1875 pMsr->u32IndexMSR = MSR_K6_EFER;
1876 pMsr->u32Reserved = 0;
1877 pMsr->u64Value = pCtx->msrEFER;
1878 /* VT-x will complain if only MSR_K6_EFER_LME is set. */
1879 if (!CPUMIsGuestInLongModeEx(pCtx))
1880 pMsr->u64Value &= ~(MSR_K6_EFER_LMA|MSR_K6_EFER_LME);
1881 pMsr++; idxMsr++;
1882
1883 if (ulEdx & X86_CPUID_AMD_FEATURE_EDX_LONG_MODE)
1884 {
1885 pMsr->u32IndexMSR = MSR_K8_LSTAR;
1886 pMsr->u32Reserved = 0;
1887 pMsr->u64Value = pCtx->msrLSTAR; /* 64 bits mode syscall rip */
1888 pMsr++; idxMsr++;
1889 pMsr->u32IndexMSR = MSR_K6_STAR;
1890 pMsr->u32Reserved = 0;
1891 pMsr->u64Value = pCtx->msrSTAR; /* legacy syscall eip, cs & ss */
1892 pMsr++; idxMsr++;
1893 pMsr->u32IndexMSR = MSR_K8_SF_MASK;
1894 pMsr->u32Reserved = 0;
1895 pMsr->u64Value = pCtx->msrSFMASK; /* syscall flag mask */
1896 pMsr++; idxMsr++;
1897 pMsr->u32IndexMSR = MSR_K8_KERNEL_GS_BASE;
1898 pMsr->u32Reserved = 0;
1899 pMsr->u64Value = pCtx->msrKERNELGSBASE; /* swapgs exchange value */
1900 pMsr++; idxMsr++;
1901 }
1902 }
1903 pVCpu->hwaccm.s.vmx.cCachedMSRs = idxMsr;
1904
1905 rc = VMXWriteVMCS(VMX_VMCS_CTRL_ENTRY_MSR_LOAD_COUNT, idxMsr);
1906 AssertRC(rc);
1907
1908 rc = VMXWriteVMCS(VMX_VMCS_CTRL_EXIT_MSR_STORE_COUNT, idxMsr);
1909 AssertRC(rc);
1910#endif /* VBOX_WITH_AUTO_MSR_LOAD_RESTORE */
1911
1912 /* Done. */
1913 pVCpu->hwaccm.s.fContextUseFlags &= ~HWACCM_CHANGED_ALL_GUEST;
1914
1915 return rc;
1916}
1917
1918/**
1919 * Syncs back the guest state
1920 *
1921 * @returns VBox status code.
1922 * @param pVM The VM to operate on.
1923 * @param pVCpu The VMCPU to operate on.
1924 * @param pCtx Guest context
1925 */
1926DECLINLINE(int) VMXR0SaveGuestState(PVM pVM, PVMCPU pVCpu, PCPUMCTX pCtx)
1927{
1928 RTGCUINTREG val, valShadow;
1929 RTGCUINTPTR uInterruptState;
1930 int rc;
1931
1932 /* Let's first sync back eip, esp, and eflags. */
1933 rc = VMXReadCachedVMCS(VMX_VMCS64_GUEST_RIP, &val);
1934 AssertRC(rc);
1935 pCtx->rip = val;
1936 rc = VMXReadCachedVMCS(VMX_VMCS64_GUEST_RSP, &val);
1937 AssertRC(rc);
1938 pCtx->rsp = val;
1939 rc = VMXReadCachedVMCS(VMX_VMCS_GUEST_RFLAGS, &val);
1940 AssertRC(rc);
1941 pCtx->eflags.u32 = val;
1942
1943 /* Take care of instruction fusing (sti, mov ss) */
1944 rc |= VMXReadCachedVMCS(VMX_VMCS32_GUEST_INTERRUPTIBILITY_STATE, &val);
1945 uInterruptState = val;
1946 if (uInterruptState != 0)
1947 {
1948 Assert(uInterruptState <= 2); /* only sti & mov ss */
1949 Log(("uInterruptState %x eip=%RGv\n", (uint32_t)uInterruptState, pCtx->rip));
1950 EMSetInhibitInterruptsPC(pVCpu, pCtx->rip);
1951 }
1952 else
1953 VMCPU_FF_CLEAR(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS);
1954
1955 /* Control registers. */
1956 VMXReadCachedVMCS(VMX_VMCS_CTRL_CR0_READ_SHADOW, &valShadow);
1957 VMXReadCachedVMCS(VMX_VMCS64_GUEST_CR0, &val);
1958 val = (valShadow & pVCpu->hwaccm.s.vmx.cr0_mask) | (val & ~pVCpu->hwaccm.s.vmx.cr0_mask);
1959 CPUMSetGuestCR0(pVCpu, val);
1960
1961 VMXReadCachedVMCS(VMX_VMCS_CTRL_CR4_READ_SHADOW, &valShadow);
1962 VMXReadCachedVMCS(VMX_VMCS64_GUEST_CR4, &val);
1963 val = (valShadow & pVCpu->hwaccm.s.vmx.cr4_mask) | (val & ~pVCpu->hwaccm.s.vmx.cr4_mask);
1964 CPUMSetGuestCR4(pVCpu, val);
1965
1966 /* Note: no reason to sync back the CRx registers. They can't be changed by the guest. */
1967 /* Note: only in the nested paging case can CR3 & CR4 be changed by the guest. */
1968 if ( pVM->hwaccm.s.fNestedPaging
1969 && CPUMIsGuestInPagedProtectedModeEx(pCtx))
1970 {
1971 PVMCSCACHE pCache = &pVCpu->hwaccm.s.vmx.VMCSCache;
1972
1973 /* Can be updated behind our back in the nested paging case. */
1974 CPUMSetGuestCR2(pVCpu, pCache->cr2);
1975
1976 VMXReadCachedVMCS(VMX_VMCS64_GUEST_CR3, &val);
1977
1978 if (val != pCtx->cr3)
1979 {
1980 CPUMSetGuestCR3(pVCpu, val);
1981 PGMUpdateCR3(pVCpu, val);
1982 }
1983 /* Prefetch the four PDPT entries in PAE mode. */
1984 vmxR0PrefetchPAEPdptrs(pVM, pVCpu, pCtx);
1985 }
1986
1987 /* Sync back DR7 here. */
1988 VMXReadCachedVMCS(VMX_VMCS64_GUEST_DR7, &val);
1989 pCtx->dr[7] = val;
1990
1991 /* Guest CPU context: ES, CS, SS, DS, FS, GS. */
1992 VMX_READ_SELREG(ES, es);
1993 VMX_READ_SELREG(SS, ss);
1994 VMX_READ_SELREG(CS, cs);
1995 VMX_READ_SELREG(DS, ds);
1996 VMX_READ_SELREG(FS, fs);
1997 VMX_READ_SELREG(GS, gs);
1998
1999 /*
2000 * System MSRs
2001 */
2002 VMXReadCachedVMCS(VMX_VMCS32_GUEST_SYSENTER_CS, &val);
2003 pCtx->SysEnter.cs = val;
2004 VMXReadCachedVMCS(VMX_VMCS64_GUEST_SYSENTER_EIP, &val);
2005 pCtx->SysEnter.eip = val;
2006 VMXReadCachedVMCS(VMX_VMCS64_GUEST_SYSENTER_ESP, &val);
2007 pCtx->SysEnter.esp = val;
2008
2009 /* Misc. registers; must sync everything otherwise we can get out of sync when jumping to ring 3. */
2010 VMX_READ_SELREG(LDTR, ldtr);
2011
2012 VMXReadCachedVMCS(VMX_VMCS32_GUEST_GDTR_LIMIT, &val);
2013 pCtx->gdtr.cbGdt = val;
2014 VMXReadCachedVMCS(VMX_VMCS64_GUEST_GDTR_BASE, &val);
2015 pCtx->gdtr.pGdt = val;
2016
2017 VMXReadCachedVMCS(VMX_VMCS32_GUEST_IDTR_LIMIT, &val);
2018 pCtx->idtr.cbIdt = val;
2019 VMXReadCachedVMCS(VMX_VMCS64_GUEST_IDTR_BASE, &val);
2020 pCtx->idtr.pIdt = val;
2021
2022#ifdef HWACCM_VMX_EMULATE_REALMODE
2023 /* Real mode emulation using v86 mode. */
2024 if (CPUMIsGuestInRealModeEx(pCtx))
2025 {
2026 /* Hide our emulation flags */
2027 pCtx->eflags.Bits.u1VM = 0;
2028
2029 /* Restore original IOPL setting as we always use 0. */
2030 pCtx->eflags.Bits.u2IOPL = pVCpu->hwaccm.s.vmx.RealMode.eflags.Bits.u2IOPL;
2031
2032 /* Force a TR resync every time in case we switch modes. */
2033 pVCpu->hwaccm.s.fContextUseFlags |= HWACCM_CHANGED_GUEST_TR;
2034 }
2035 else
2036#endif /* HWACCM_VMX_EMULATE_REALMODE */
2037 {
2038 /* In real mode we have a fake TSS, so only sync it back when it's supposed to be valid. */
2039 VMX_READ_SELREG(TR, tr);
2040 }
2041
2042#ifdef VBOX_WITH_AUTO_MSR_LOAD_RESTORE
2043 /* Save the possibly changed MSRs that we automatically restore and save during a world switch. */
2044 for (unsigned i = 0; i < pVCpu->hwaccm.s.vmx.cCachedMSRs; i++)
2045 {
2046 PVMXMSR pMsr = (PVMXMSR)pVCpu->hwaccm.s.vmx.pGuestMSR;
2047 pMsr += i;
2048
2049 switch (pMsr->u32IndexMSR)
2050 {
2051 case MSR_K8_LSTAR:
2052 pCtx->msrLSTAR = pMsr->u64Value;
2053 break;
2054 case MSR_K6_STAR:
2055 pCtx->msrSTAR = pMsr->u64Value;
2056 break;
2057 case MSR_K8_SF_MASK:
2058 pCtx->msrSFMASK = pMsr->u64Value;
2059 break;
2060 case MSR_K8_KERNEL_GS_BASE:
2061 pCtx->msrKERNELGSBASE = pMsr->u64Value;
2062 break;
2063 case MSR_K6_EFER:
2064 /* EFER can't be changed without causing a VM-exit. */
2065// Assert(pCtx->msrEFER == pMsr->u64Value);
2066 break;
2067 default:
2068 AssertFailed();
2069 return VERR_INTERNAL_ERROR;
2070 }
2071 }
2072#endif /* VBOX_WITH_AUTO_MSR_LOAD_RESTORE */
2073 return VINF_SUCCESS;
2074}
2075
2076/**
2077 * Dummy placeholder
2078 *
2079 * @param pVM The VM to operate on.
2080 * @param pVCpu The VMCPU to operate on.
2081 */
2082static void vmxR0SetupTLBDummy(PVM pVM, PVMCPU pVCpu)
2083{
2084 NOREF(pVM);
2085 VMCPU_FF_CLEAR(pVCpu, VMCPU_FF_TLB_FLUSH);
2086 VMCPU_FF_CLEAR(pVCpu, VMCPU_FF_TLB_SHOOTDOWN);
2087 pVCpu->hwaccm.s.TlbShootdown.cPages = 0;
2088 return;
2089}
2090
2091/**
2092 * Setup the tagged TLB for EPT
2093 *
2094 * @returns VBox status code.
2095 * @param pVM The VM to operate on.
2096 * @param pVCpu The VMCPU to operate on.
2097 */
2098static void vmxR0SetupTLBEPT(PVM pVM, PVMCPU pVCpu)
2099{
2100 PHWACCM_CPUINFO pCpu;
2101
2102 Assert(pVM->hwaccm.s.fNestedPaging);
2103 Assert(!pVM->hwaccm.s.vmx.fVPID);
2104
2105 /* Deal with tagged TLBs if VPID or EPT is supported. */
2106 pCpu = HWACCMR0GetCurrentCpu();
2107 /* Force a TLB flush for the first world switch if the current cpu differs from the one we ran on last. */
2108 /* Note that this can happen both for start and resume due to long jumps back to ring 3. */
2109 if ( pVCpu->hwaccm.s.idLastCpu != pCpu->idCpu
2110 /* if the tlb flush count has changed, another VM has flushed the TLB of this cpu, so we can't use our current ASID anymore. */
2111 || pVCpu->hwaccm.s.cTLBFlushes != pCpu->cTLBFlushes)
2112 {
2113 /* Force a TLB flush on VM entry. */
2114 pVCpu->hwaccm.s.fForceTLBFlush = true;
2115 }
2116 else
2117 Assert(!pCpu->fFlushTLB);
2118
2119 /* Check for tlb shootdown flushes. */
2120 if (VMCPU_FF_TESTANDCLEAR(pVCpu, VMCPU_FF_TLB_FLUSH))
2121 pVCpu->hwaccm.s.fForceTLBFlush = true;
2122
2123 pVCpu->hwaccm.s.idLastCpu = pCpu->idCpu;
2124 pCpu->fFlushTLB = false;
2125
2126 if (pVCpu->hwaccm.s.fForceTLBFlush)
2127 {
2128 vmxR0FlushEPT(pVM, pVCpu, pVM->hwaccm.s.vmx.enmFlushContext, 0);
2129 }
2130 else
2131 if (VMCPU_FF_ISPENDING(pVCpu, VMCPU_FF_TLB_SHOOTDOWN))
2132 {
2133 /* Deal with pending TLB shootdown actions which were queued when we were not executing code. */
2134 STAM_COUNTER_INC(&pVCpu->hwaccm.s.StatTlbShootdown);
2135
2136 for (unsigned i=0;i<pVCpu->hwaccm.s.TlbShootdown.cPages;i++)
2137 {
2138 /* aTlbShootdownPages contains physical addresses in this case. */
2139 vmxR0FlushEPT(pVM, pVCpu, pVM->hwaccm.s.vmx.enmFlushContext, pVCpu->hwaccm.s.TlbShootdown.aPages[i]);
2140 }
2141 }
2142 pVCpu->hwaccm.s.TlbShootdown.cPages= 0;
2143 VMCPU_FF_CLEAR(pVCpu, VMCPU_FF_TLB_SHOOTDOWN);
2144
2145#ifdef VBOX_WITH_STATISTICS
2146 if (pVCpu->hwaccm.s.fForceTLBFlush)
2147 STAM_COUNTER_INC(&pVCpu->hwaccm.s.StatFlushTLBWorldSwitch);
2148 else
2149 STAM_COUNTER_INC(&pVCpu->hwaccm.s.StatNoFlushTLBWorldSwitch);
2150#endif
2151}
2152
2153#ifdef HWACCM_VTX_WITH_VPID
2154/**
2155 * Setup the tagged TLB for VPID
2156 *
2157 * @returns VBox status code.
2158 * @param pVM The VM to operate on.
2159 * @param pVCpu The VMCPU to operate on.
2160 */
2161static void vmxR0SetupTLBVPID(PVM pVM, PVMCPU pVCpu)
2162{
2163 PHWACCM_CPUINFO pCpu;
2164
2165 Assert(pVM->hwaccm.s.vmx.fVPID);
2166 Assert(!pVM->hwaccm.s.fNestedPaging);
2167
2168 /* Deal with tagged TLBs if VPID or EPT is supported. */
2169 pCpu = HWACCMR0GetCurrentCpu();
2170 /* Force a TLB flush for the first world switch if the current cpu differs from the one we ran on last. */
2171 /* Note that this can happen both for start and resume due to long jumps back to ring 3. */
2172 if ( pVCpu->hwaccm.s.idLastCpu != pCpu->idCpu
2173 /* if the tlb flush count has changed, another VM has flushed the TLB of this cpu, so we can't use our current ASID anymore. */
2174 || pVCpu->hwaccm.s.cTLBFlushes != pCpu->cTLBFlushes)
2175 {
2176 /* Force a TLB flush on VM entry. */
2177 pVCpu->hwaccm.s.fForceTLBFlush = true;
2178 }
2179 else
2180 Assert(!pCpu->fFlushTLB);
2181
2182 pVCpu->hwaccm.s.idLastCpu = pCpu->idCpu;
2183
2184 /* Check for tlb shootdown flushes. */
2185 if (VMCPU_FF_TESTANDCLEAR(pVCpu, VMCPU_FF_TLB_FLUSH))
2186 pVCpu->hwaccm.s.fForceTLBFlush = true;
2187
2188 /* Make sure we flush the TLB when required. Switch ASID to achieve the same thing, but without actually flushing the whole TLB (which is expensive). */
2189 if (pVCpu->hwaccm.s.fForceTLBFlush)
2190 {
2191 if ( ++pCpu->uCurrentASID >= pVM->hwaccm.s.uMaxASID
2192 || pCpu->fFlushTLB)
2193 {
2194 pCpu->fFlushTLB = false;
2195 pCpu->uCurrentASID = 1; /* start at 1; host uses 0 */
2196 pCpu->cTLBFlushes++;
2197 }
2198 else
2199 {
2200 STAM_COUNTER_INC(&pVCpu->hwaccm.s.StatFlushASID);
2201 pVCpu->hwaccm.s.fForceTLBFlush = false;
2202 }
2203
2204 pVCpu->hwaccm.s.cTLBFlushes = pCpu->cTLBFlushes;
2205 pVCpu->hwaccm.s.uCurrentASID = pCpu->uCurrentASID;
2206 }
2207 else
2208 {
2209 Assert(!pCpu->fFlushTLB);
2210 Assert(pVCpu->hwaccm.s.uCurrentASID && pCpu->uCurrentASID);
2211
2212 if (VMCPU_FF_ISPENDING(pVCpu, VMCPU_FF_TLB_SHOOTDOWN))
2213 {
2214 /* Deal with pending TLB shootdown actions which were queued when we were not executing code. */
2215 STAM_COUNTER_INC(&pVCpu->hwaccm.s.StatTlbShootdown);
2216 for (unsigned i=0;i<pVCpu->hwaccm.s.TlbShootdown.cPages;i++)
2217 vmxR0FlushVPID(pVM, pVCpu, pVM->hwaccm.s.vmx.enmFlushContext, pVCpu->hwaccm.s.TlbShootdown.aPages[i]);
2218 }
2219 }
2220 pVCpu->hwaccm.s.TlbShootdown.cPages = 0;
2221 VMCPU_FF_CLEAR(pVCpu, VMCPU_FF_TLB_SHOOTDOWN);
2222
2223 AssertMsg(pVCpu->hwaccm.s.cTLBFlushes == pCpu->cTLBFlushes, ("Flush count mismatch for cpu %d (%x vs %x)\n", pCpu->idCpu, pVCpu->hwaccm.s.cTLBFlushes, pCpu->cTLBFlushes));
2224 AssertMsg(pCpu->uCurrentASID >= 1 && pCpu->uCurrentASID < pVM->hwaccm.s.uMaxASID, ("cpu%d uCurrentASID = %x\n", pCpu->idCpu, pCpu->uCurrentASID));
2225 AssertMsg(pVCpu->hwaccm.s.uCurrentASID >= 1 && pVCpu->hwaccm.s.uCurrentASID < pVM->hwaccm.s.uMaxASID, ("cpu%d VM uCurrentASID = %x\n", pCpu->idCpu, pVCpu->hwaccm.s.uCurrentASID));
2226
2227 int rc = VMXWriteVMCS(VMX_VMCS16_GUEST_FIELD_VPID, pVCpu->hwaccm.s.uCurrentASID);
2228 AssertRC(rc);
2229
2230 if (pVCpu->hwaccm.s.fForceTLBFlush)
2231 vmxR0FlushVPID(pVM, pVCpu, pVM->hwaccm.s.vmx.enmFlushContext, 0);
2232
2233#ifdef VBOX_WITH_STATISTICS
2234 if (pVCpu->hwaccm.s.fForceTLBFlush)
2235 STAM_COUNTER_INC(&pVCpu->hwaccm.s.StatFlushTLBWorldSwitch);
2236 else
2237 STAM_COUNTER_INC(&pVCpu->hwaccm.s.StatNoFlushTLBWorldSwitch);
2238#endif
2239}
2240#endif /* HWACCM_VTX_WITH_VPID */
2241
2242/**
2243 * Runs guest code in a VT-x VM.
2244 *
2245 * @returns VBox status code.
2246 * @param pVM The VM to operate on.
2247 * @param pVCpu The VMCPU to operate on.
2248 * @param pCtx Guest context
2249 */
2250VMMR0DECL(int) VMXR0RunGuestCode(PVM pVM, PVMCPU pVCpu, PCPUMCTX pCtx)
2251{
2252 int rc = VINF_SUCCESS;
2253 RTGCUINTREG val;
2254 RTGCUINTREG exitReason = VMX_EXIT_INVALID;
2255 RTGCUINTREG instrError, cbInstr;
2256 RTGCUINTPTR exitQualification = 0;
2257 RTGCUINTPTR intInfo = 0; /* shut up buggy gcc 4 */
2258 RTGCUINTPTR errCode, instrInfo;
2259 bool fSetupTPRCaching = false;
2260 uint8_t u8LastTPR = 0;
2261 PHWACCM_CPUINFO pCpu = 0;
2262 RTCCUINTREG uOldEFlags = ~(RTCCUINTREG)0;
2263 unsigned cResume = 0;
2264#ifdef VBOX_STRICT
2265 RTCPUID idCpuCheck;
2266 bool fWasInLongMode = false;
2267#endif
2268#ifdef VBOX_HIGH_RES_TIMERS_HACK_IN_RING0
2269 uint64_t u64LastTime = RTTimeMilliTS();
2270#endif
2271#ifdef VBOX_WITH_STATISTICS
2272 bool fStatEntryStarted = true;
2273 bool fStatExit2Started = false;
2274#endif
2275
2276 Assert(!(pVM->hwaccm.s.vmx.msr.vmx_proc_ctls2.n.allowed1 & VMX_VMCS_CTRL_PROC_EXEC2_VIRT_APIC) || (pVCpu->hwaccm.s.vmx.pVAPIC && pVM->hwaccm.s.vmx.pAPIC));
2277
2278 /* Check if we need to use TPR shadowing. */
2279 if ( CPUMIsGuestInLongModeEx(pCtx)
2280 || ( (pVM->hwaccm.s.vmx.msr.vmx_proc_ctls2.n.allowed1 & VMX_VMCS_CTRL_PROC_EXEC2_VIRT_APIC)
2281 && pVM->hwaccm.s.fHasIoApic)
2282 )
2283 {
2284 fSetupTPRCaching = true;
2285 }
2286
2287 Log2(("\nE"));
2288
2289 STAM_PROFILE_ADV_START(&pVCpu->hwaccm.s.StatEntry, x);
2290
2291#ifdef VBOX_STRICT
2292 {
2293 RTCCUINTREG val;
2294
2295 rc = VMXReadVMCS(VMX_VMCS_CTRL_PIN_EXEC_CONTROLS, &val);
2296 AssertRC(rc);
2297 Log2(("VMX_VMCS_CTRL_PIN_EXEC_CONTROLS = %08x\n", val));
2298
2299 /* allowed zero */
2300 if ((val & pVM->hwaccm.s.vmx.msr.vmx_pin_ctls.n.disallowed0) != pVM->hwaccm.s.vmx.msr.vmx_pin_ctls.n.disallowed0)
2301 Log(("Invalid VMX_VMCS_CTRL_PIN_EXEC_CONTROLS: zero\n"));
2302
2303 /* allowed one */
2304 if ((val & ~pVM->hwaccm.s.vmx.msr.vmx_pin_ctls.n.allowed1) != 0)
2305 Log(("Invalid VMX_VMCS_CTRL_PIN_EXEC_CONTROLS: one\n"));
2306
2307 rc = VMXReadVMCS(VMX_VMCS_CTRL_PROC_EXEC_CONTROLS, &val);
2308 AssertRC(rc);
2309 Log2(("VMX_VMCS_CTRL_PROC_EXEC_CONTROLS = %08x\n", val));
2310
2311 /* Must be set according to the MSR, but can be cleared in case of EPT. */
2312 if (pVM->hwaccm.s.fNestedPaging)
2313 val |= VMX_VMCS_CTRL_PROC_EXEC_CONTROLS_INVLPG_EXIT
2314 | VMX_VMCS_CTRL_PROC_EXEC_CONTROLS_CR3_LOAD_EXIT
2315 | VMX_VMCS_CTRL_PROC_EXEC_CONTROLS_CR3_STORE_EXIT;
2316
2317 /* allowed zero */
2318 if ((val & pVM->hwaccm.s.vmx.msr.vmx_proc_ctls.n.disallowed0) != pVM->hwaccm.s.vmx.msr.vmx_proc_ctls.n.disallowed0)
2319 Log(("Invalid VMX_VMCS_CTRL_PROC_EXEC_CONTROLS: zero\n"));
2320
2321 /* allowed one */
2322 if ((val & ~pVM->hwaccm.s.vmx.msr.vmx_proc_ctls.n.allowed1) != 0)
2323 Log(("Invalid VMX_VMCS_CTRL_PROC_EXEC_CONTROLS: one\n"));
2324
2325 rc = VMXReadVMCS(VMX_VMCS_CTRL_ENTRY_CONTROLS, &val);
2326 AssertRC(rc);
2327 Log2(("VMX_VMCS_CTRL_ENTRY_CONTROLS = %08x\n", val));
2328
2329 /* allowed zero */
2330 if ((val & pVM->hwaccm.s.vmx.msr.vmx_entry.n.disallowed0) != pVM->hwaccm.s.vmx.msr.vmx_entry.n.disallowed0)
2331 Log(("Invalid VMX_VMCS_CTRL_ENTRY_CONTROLS: zero\n"));
2332
2333 /* allowed one */
2334 if ((val & ~pVM->hwaccm.s.vmx.msr.vmx_entry.n.allowed1) != 0)
2335 Log(("Invalid VMX_VMCS_CTRL_ENTRY_CONTROLS: one\n"));
2336
2337 rc = VMXReadVMCS(VMX_VMCS_CTRL_EXIT_CONTROLS, &val);
2338 AssertRC(rc);
2339 Log2(("VMX_VMCS_CTRL_EXIT_CONTROLS = %08x\n", val));
2340
2341 /* allowed zero */
2342 if ((val & pVM->hwaccm.s.vmx.msr.vmx_exit.n.disallowed0) != pVM->hwaccm.s.vmx.msr.vmx_exit.n.disallowed0)
2343 Log(("Invalid VMX_VMCS_CTRL_EXIT_CONTROLS: zero\n"));
2344
2345 /* allowed one */
2346 if ((val & ~pVM->hwaccm.s.vmx.msr.vmx_exit.n.allowed1) != 0)
2347 Log(("Invalid VMX_VMCS_CTRL_EXIT_CONTROLS: one\n"));
2348 }
2349 fWasInLongMode = CPUMIsGuestInLongMode(pVCpu);
2350#endif
2351
2352#ifdef VBOX_WITH_CRASHDUMP_MAGIC
2353 pVCpu->hwaccm.s.vmx.VMCSCache.u64TimeEntry = RTTimeNanoTS();
2354#endif
2355
2356 /* We can jump to this point to resume execution after determining that a VM-exit is innocent.
2357 */
2358ResumeExecution:
2359 STAM_STATS({
2360 if (fStatExit2Started) { STAM_PROFILE_ADV_STOP(&pVCpu->hwaccm.s.StatExit2, y); fStatExit2Started = false; }
2361 if (!fStatEntryStarted) { STAM_PROFILE_ADV_START(&pVCpu->hwaccm.s.StatEntry, x); fStatEntryStarted = true; }
2362 });
2363 AssertMsg(pVCpu->hwaccm.s.idEnteredCpu == RTMpCpuId(),
2364 ("Expected %d, I'm %d; cResume=%d exitReason=%RGv exitQualification=%RGv\n",
2365 (int)pVCpu->hwaccm.s.idEnteredCpu, (int)RTMpCpuId(), cResume, exitReason, exitQualification));
2366 Assert(!HWACCMR0SuspendPending());
2367 /* Not allowed to switch modes without reloading the host state (32->64 switcher)!! */
2368 Assert(fWasInLongMode == CPUMIsGuestInLongMode(pVCpu));
2369
2370 /* Safety precaution; looping for too long here can have a very bad effect on the host */
2371 if (RT_UNLIKELY(++cResume > pVM->hwaccm.s.cMaxResumeLoops))
2372 {
2373 STAM_COUNTER_INC(&pVCpu->hwaccm.s.StatExitMaxResume);
2374 rc = VINF_EM_RAW_INTERRUPT;
2375 goto end;
2376 }
2377
2378 /* Check for irq inhibition due to instruction fusing (sti, mov ss). */
2379 if (VMCPU_FF_ISSET(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS))
2380 {
2381 Log(("VM_FF_INHIBIT_INTERRUPTS at %RGv successor %RGv\n", (RTGCPTR)pCtx->rip, EMGetInhibitInterruptsPC(pVCpu)));
2382 if (pCtx->rip != EMGetInhibitInterruptsPC(pVCpu))
2383 {
2384 /* Note: we intentionally don't clear VM_FF_INHIBIT_INTERRUPTS here.
2385 * Before we are able to execute this instruction in raw mode (iret to guest code) an external interrupt might
2386 * force a world switch again. Possibly allowing a guest interrupt to be dispatched in the process. This could
2387 * break the guest. Sounds very unlikely, but such timing sensitive problems are not as rare as you might think.
2388 */
2389 VMCPU_FF_CLEAR(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS);
2390 /* Irq inhibition is no longer active; clear the corresponding VMX state. */
2391 rc = VMXWriteVMCS(VMX_VMCS32_GUEST_INTERRUPTIBILITY_STATE, 0);
2392 AssertRC(rc);
2393 }
2394 }
2395 else
2396 {
2397 /* Irq inhibition is no longer active; clear the corresponding VMX state. */
2398 rc = VMXWriteVMCS(VMX_VMCS32_GUEST_INTERRUPTIBILITY_STATE, 0);
2399 AssertRC(rc);
2400 }
2401
2402#ifdef VBOX_HIGH_RES_TIMERS_HACK_IN_RING0
2403 if (RT_UNLIKELY(cResume & 0xf) == 0)
2404 {
2405 uint64_t u64CurTime = RTTimeMilliTS();
2406
2407 if (RT_UNLIKELY(u64CurTime > u64LastTime))
2408 {
2409 u64LastTime = u64CurTime;
2410 TMTimerPollVoid(pVM, pVCpu);
2411 }
2412 }
2413#endif
2414
2415 /* Check for pending actions that force us to go back to ring 3. */
2416#ifdef DEBUG
2417 /* Intercept X86_XCPT_DB if stepping is enabled */
2418 if (!DBGFIsStepping(pVCpu))
2419#endif
2420 {
2421 if ( VM_FF_ISPENDING(pVM, VM_FF_HWACCM_TO_R3_MASK)
2422 || VMCPU_FF_ISPENDING(pVCpu, VMCPU_FF_HWACCM_TO_R3_MASK))
2423 {
2424 VMCPU_FF_CLEAR(pVCpu, VMCPU_FF_TO_R3);
2425 STAM_COUNTER_INC(&pVCpu->hwaccm.s.StatSwitchToR3);
2426 rc = RT_UNLIKELY(VM_FF_ISPENDING(pVM, VM_FF_PGM_NO_MEMORY)) ? VINF_EM_NO_MEMORY : VINF_EM_RAW_TO_R3;
2427 goto end;
2428 }
2429 }
2430
2431 /* Pending request packets might contain actions that need immediate attention, such as pending hardware interrupts. */
2432 if ( VM_FF_ISPENDING(pVM, VM_FF_REQUEST)
2433 || VMCPU_FF_ISPENDING(pVCpu, VMCPU_FF_REQUEST))
2434 {
2435 rc = VINF_EM_PENDING_REQUEST;
2436 goto end;
2437 }
2438
2439#ifdef VBOX_WITH_VMMR0_DISABLE_PREEMPTION
2440 /*
2441 * Exit to ring-3 preemption/work is pending.
2442 *
2443 * Interrupts are disabled before the call to make sure we don't miss any interrupt
2444 * that would flag preemption (IPI, timer tick, ++). (Would've been nice to do this
2445 * further down, but VMXR0CheckPendingInterrupt makes that impossible.)
2446 *
2447 * Note! Interrupts must be disabled done *before* we check for TLB flushes; TLB
2448 * shootdowns rely on this.
2449 */
2450 uOldEFlags = ASMIntDisableFlags();
2451 if (RTThreadPreemptIsPending(NIL_RTTHREAD))
2452 {
2453 STAM_COUNTER_INC(&pVCpu->hwaccm.s.StatExitPreemptPending);
2454 rc = VINF_EM_RAW_INTERRUPT;
2455 goto end;
2456 }
2457 VMCPU_SET_STATE(pVCpu, VMCPUSTATE_STARTED_EXEC);
2458#endif
2459
2460 /* When external interrupts are pending, we should exit the VM when IF is set. */
2461 /* Note! *After* VM_FF_INHIBIT_INTERRUPTS check!!! */
2462 rc = VMXR0CheckPendingInterrupt(pVM, pVCpu, pCtx);
2463 if (RT_FAILURE(rc))
2464 goto end;
2465
2466 /** @todo check timers?? */
2467
2468 /* TPR caching using CR8 is only available in 64 bits mode */
2469 /* Note the 32 bits exception for AMD (X86_CPUID_AMD_FEATURE_ECX_CR8L), but that appears missing in Intel CPUs */
2470 /* Note: we can't do this in LoadGuestState as PDMApicGetTPR can jump back to ring 3 (lock)!!!!! (no longer true) */
2471 /**
2472 * @todo query and update the TPR only when it could have been changed (mmio access & wrmsr (x2apic))
2473 */
2474 if (fSetupTPRCaching)
2475 {
2476 /* TPR caching in CR8 */
2477 bool fPending;
2478
2479 int rc = PDMApicGetTPR(pVCpu, &u8LastTPR, &fPending);
2480 AssertRC(rc);
2481 /* The TPR can be found at offset 0x80 in the APIC mmio page. */
2482 pVCpu->hwaccm.s.vmx.pVAPIC[0x80] = u8LastTPR;
2483
2484 /* Two options here:
2485 * - external interrupt pending, but masked by the TPR value.
2486 * -> a CR8 update that lower the current TPR value should cause an exit
2487 * - no pending interrupts
2488 * -> We don't need to be explicitely notified. There are enough world switches for detecting pending interrupts.
2489 */
2490 rc = VMXWriteVMCS(VMX_VMCS_CTRL_TPR_THRESHOLD, (fPending) ? (u8LastTPR >> 4) : 0); /* cr8 bits 3-0 correspond to bits 7-4 of the task priority mmio register. */
2491 AssertRC(rc);
2492 }
2493
2494#if defined(HWACCM_VTX_WITH_EPT) && defined(LOG_ENABLED)
2495 if ( pVM->hwaccm.s.fNestedPaging
2496# ifdef HWACCM_VTX_WITH_VPID
2497 || pVM->hwaccm.s.vmx.fVPID
2498# endif /* HWACCM_VTX_WITH_VPID */
2499 )
2500 {
2501 pCpu = HWACCMR0GetCurrentCpu();
2502 if ( pVCpu->hwaccm.s.idLastCpu != pCpu->idCpu
2503 || pVCpu->hwaccm.s.cTLBFlushes != pCpu->cTLBFlushes)
2504 {
2505 if (pVCpu->hwaccm.s.idLastCpu != pCpu->idCpu)
2506 Log(("Force TLB flush due to rescheduling to a different cpu (%d vs %d)\n", pVCpu->hwaccm.s.idLastCpu, pCpu->idCpu));
2507 else
2508 Log(("Force TLB flush due to changed TLB flush count (%x vs %x)\n", pVCpu->hwaccm.s.cTLBFlushes, pCpu->cTLBFlushes));
2509 }
2510 if (pCpu->fFlushTLB)
2511 Log(("Force TLB flush: first time cpu %d is used -> flush\n", pCpu->idCpu));
2512 else
2513 if (pVCpu->hwaccm.s.fForceTLBFlush)
2514 LogFlow(("Manual TLB flush\n"));
2515 }
2516#endif
2517#ifdef VBOX_WITH_2X_4GB_ADDR_SPACE_IN_R0
2518 PGMDynMapFlushAutoSet(pVCpu);
2519#endif
2520
2521 /*
2522 * NOTE: DO NOT DO ANYTHING AFTER THIS POINT THAT MIGHT JUMP BACK TO RING 3!
2523 * (until the actual world switch)
2524 */
2525#ifdef VBOX_STRICT
2526 idCpuCheck = RTMpCpuId();
2527#endif
2528#ifdef LOG_ENABLED
2529 VMMR0LogFlushDisable(pVCpu);
2530#endif
2531 /* Save the host state first. */
2532 rc = VMXR0SaveHostState(pVM, pVCpu);
2533 if (RT_UNLIKELY(rc != VINF_SUCCESS))
2534 {
2535 VMMR0LogFlushEnable(pVCpu);
2536 goto end;
2537 }
2538 /* Load the guest state */
2539 rc = VMXR0LoadGuestState(pVM, pVCpu, pCtx);
2540 if (RT_UNLIKELY(rc != VINF_SUCCESS))
2541 {
2542 VMMR0LogFlushEnable(pVCpu);
2543 goto end;
2544 }
2545
2546#ifndef VBOX_WITH_VMMR0_DISABLE_PREEMPTION
2547 /* Disable interrupts to make sure a poke will interrupt execution.
2548 * This must be done *before* we check for TLB flushes; TLB shootdowns rely on this.
2549 */
2550 uOldEFlags = ASMIntDisableFlags();
2551 VMCPU_SET_STATE(pVCpu, VMCPUSTATE_STARTED_EXEC);
2552#endif
2553
2554 /* Deal with tagged TLB setup and invalidation. */
2555 pVM->hwaccm.s.vmx.pfnSetupTaggedTLB(pVM, pVCpu);
2556
2557 /* Non-register state Guest Context */
2558 /** @todo change me according to cpu state */
2559 rc = VMXWriteVMCS(VMX_VMCS32_GUEST_ACTIVITY_STATE, VMX_CMS_GUEST_ACTIVITY_ACTIVE);
2560 AssertRC(rc);
2561
2562 STAM_STATS({ STAM_PROFILE_ADV_STOP(&pVCpu->hwaccm.s.StatEntry, x); fStatEntryStarted = false; });
2563
2564 /* Manual save and restore:
2565 * - General purpose registers except RIP, RSP
2566 *
2567 * Trashed:
2568 * - CR2 (we don't care)
2569 * - LDTR (reset to 0)
2570 * - DRx (presumably not changed at all)
2571 * - DR7 (reset to 0x400)
2572 * - EFLAGS (reset to RT_BIT(1); not relevant)
2573 *
2574 */
2575
2576
2577 /* All done! Let's start VM execution. */
2578 STAM_PROFILE_ADV_START(&pVCpu->hwaccm.s.StatInGC, z);
2579 Assert(idCpuCheck == RTMpCpuId());
2580
2581#ifdef VBOX_WITH_CRASHDUMP_MAGIC
2582 pVCpu->hwaccm.s.vmx.VMCSCache.cResume = cResume;
2583 pVCpu->hwaccm.s.vmx.VMCSCache.u64TimeSwitch = RTTimeNanoTS();
2584#endif
2585
2586 TMNotifyStartOfExecution(pVCpu);
2587#ifdef VBOX_WITH_KERNEL_USING_XMM
2588 rc = hwaccmR0VMXStartVMWrapXMM(pVCpu->hwaccm.s.fResumeVM, pCtx, &pVCpu->hwaccm.s.vmx.VMCSCache, pVM, pVCpu, pVCpu->hwaccm.s.vmx.pfnStartVM);
2589#else
2590 rc = pVCpu->hwaccm.s.vmx.pfnStartVM(pVCpu->hwaccm.s.fResumeVM, pCtx, &pVCpu->hwaccm.s.vmx.VMCSCache, pVM, pVCpu);
2591#endif
2592 /* Possibly the last TSC value seen by the guest (too high) (only when we're in tsc offset mode). */
2593 if (!(pVCpu->hwaccm.s.vmx.proc_ctls & VMX_VMCS_CTRL_PROC_EXEC_CONTROLS_RDTSC_EXIT))
2594 TMCpuTickSetLastSeen(pVCpu, ASMReadTSC() + pVCpu->hwaccm.s.vmx.u64TSCOffset - 0x400 /* guestimate of world switch overhead in clock ticks */);
2595
2596 TMNotifyEndOfExecution(pVCpu);
2597 VMCPU_SET_STATE(pVCpu, VMCPUSTATE_STARTED);
2598 Assert(!(ASMGetFlags() & X86_EFL_IF));
2599 ASMSetFlags(uOldEFlags);
2600#ifndef VBOX_WITH_VMMR0_DISABLE_PREEMPTION
2601 uOldEFlags = ~(RTCCUINTREG)0;
2602#endif
2603
2604 AssertMsg(!pVCpu->hwaccm.s.vmx.VMCSCache.Write.cValidEntries, ("pVCpu->hwaccm.s.vmx.VMCSCache.Write.cValidEntries=%d\n", pVCpu->hwaccm.s.vmx.VMCSCache.Write.cValidEntries));
2605
2606 /* In case we execute a goto ResumeExecution later on. */
2607 pVCpu->hwaccm.s.fResumeVM = true;
2608 pVCpu->hwaccm.s.fForceTLBFlush = false;
2609
2610 /*
2611 * !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
2612 * IMPORTANT: WE CAN'T DO ANY LOGGING OR OPERATIONS THAT CAN DO A LONGJMP BACK TO RING 3 *BEFORE* WE'VE SYNCED BACK (MOST OF) THE GUEST STATE
2613 * !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
2614 */
2615 STAM_PROFILE_ADV_STOP(&pVCpu->hwaccm.s.StatInGC, z);
2616 STAM_PROFILE_ADV_START(&pVCpu->hwaccm.s.StatExit1, v);
2617
2618 if (RT_UNLIKELY(rc != VINF_SUCCESS))
2619 {
2620 VMXR0ReportWorldSwitchError(pVM, pVCpu, rc, pCtx);
2621 VMMR0LogFlushEnable(pVCpu);
2622 goto end;
2623 }
2624
2625 /* Success. Query the guest state and figure out what has happened. */
2626
2627 /* Investigate why there was a VM-exit. */
2628 rc = VMXReadCachedVMCS(VMX_VMCS32_RO_EXIT_REASON, &exitReason);
2629 STAM_COUNTER_INC(&pVCpu->hwaccm.s.paStatExitReasonR0[exitReason & MASK_EXITREASON_STAT]);
2630
2631 exitReason &= 0xffff; /* bit 0-15 contain the exit code. */
2632 rc |= VMXReadCachedVMCS(VMX_VMCS32_RO_VM_INSTR_ERROR, &instrError);
2633 rc |= VMXReadCachedVMCS(VMX_VMCS32_RO_EXIT_INSTR_LENGTH, &cbInstr);
2634 rc |= VMXReadCachedVMCS(VMX_VMCS32_RO_EXIT_INTERRUPTION_INFO, &intInfo);
2635 /* might not be valid; depends on VMX_EXIT_INTERRUPTION_INFO_ERROR_CODE_IS_VALID. */
2636 rc |= VMXReadCachedVMCS(VMX_VMCS32_RO_EXIT_INTERRUPTION_ERRCODE, &errCode);
2637 rc |= VMXReadCachedVMCS(VMX_VMCS32_RO_EXIT_INSTR_INFO, &instrInfo);
2638 rc |= VMXReadCachedVMCS(VMX_VMCS_RO_EXIT_QUALIFICATION, &exitQualification);
2639 AssertRC(rc);
2640
2641 /* Sync back the guest state */
2642 rc = VMXR0SaveGuestState(pVM, pVCpu, pCtx);
2643 AssertRC(rc);
2644
2645 /* Note! NOW IT'S SAFE FOR LOGGING! */
2646 VMMR0LogFlushEnable(pVCpu);
2647 Log2(("Raw exit reason %08x\n", exitReason));
2648
2649 /* Check if an injected event was interrupted prematurely. */
2650 rc = VMXReadCachedVMCS(VMX_VMCS32_RO_IDT_INFO, &val);
2651 AssertRC(rc);
2652 pVCpu->hwaccm.s.Event.intInfo = VMX_VMCS_CTRL_ENTRY_IRQ_INFO_FROM_EXIT_INT_INFO(val);
2653 if ( VMX_EXIT_INTERRUPTION_INFO_VALID(pVCpu->hwaccm.s.Event.intInfo)
2654 /* Ignore 'int xx' as they'll be restarted anyway. */
2655 && VMX_EXIT_INTERRUPTION_INFO_TYPE(pVCpu->hwaccm.s.Event.intInfo) != VMX_EXIT_INTERRUPTION_INFO_TYPE_SW
2656 /* Ignore software exceptions (such as int3) as they'll reoccur when we restart the instruction anyway. */
2657 && VMX_EXIT_INTERRUPTION_INFO_TYPE(pVCpu->hwaccm.s.Event.intInfo) != VMX_EXIT_INTERRUPTION_INFO_TYPE_SWEXCPT)
2658 {
2659 Assert(!pVCpu->hwaccm.s.Event.fPending);
2660 pVCpu->hwaccm.s.Event.fPending = true;
2661 /* Error code present? */
2662 if (VMX_EXIT_INTERRUPTION_INFO_ERROR_CODE_IS_VALID(pVCpu->hwaccm.s.Event.intInfo))
2663 {
2664 rc = VMXReadCachedVMCS(VMX_VMCS32_RO_IDT_ERRCODE, &val);
2665 AssertRC(rc);
2666 pVCpu->hwaccm.s.Event.errCode = val;
2667 Log(("Pending inject %RX64 at %RGv exit=%08x intInfo=%08x exitQualification=%RGv pending error=%RX64\n", pVCpu->hwaccm.s.Event.intInfo, (RTGCPTR)pCtx->rip, exitReason, intInfo, exitQualification, val));
2668 }
2669 else
2670 {
2671 Log(("Pending inject %RX64 at %RGv exit=%08x intInfo=%08x exitQualification=%RGv\n", pVCpu->hwaccm.s.Event.intInfo, (RTGCPTR)pCtx->rip, exitReason, intInfo, exitQualification));
2672 pVCpu->hwaccm.s.Event.errCode = 0;
2673 }
2674 }
2675#ifdef VBOX_STRICT
2676 else
2677 if ( VMX_EXIT_INTERRUPTION_INFO_VALID(pVCpu->hwaccm.s.Event.intInfo)
2678 /* Ignore software exceptions (such as int3) as they're reoccur when we restart the instruction anyway. */
2679 && VMX_EXIT_INTERRUPTION_INFO_TYPE(pVCpu->hwaccm.s.Event.intInfo) == VMX_EXIT_INTERRUPTION_INFO_TYPE_SWEXCPT)
2680 {
2681 Log(("Ignore pending inject %RX64 at %RGv exit=%08x intInfo=%08x exitQualification=%RGv\n", pVCpu->hwaccm.s.Event.intInfo, (RTGCPTR)pCtx->rip, exitReason, intInfo, exitQualification));
2682 }
2683
2684 if (exitReason == VMX_EXIT_ERR_INVALID_GUEST_STATE)
2685 HWACCMDumpRegs(pVM, pVCpu, pCtx);
2686#endif
2687
2688 Log2(("E%d: New EIP=%RGv\n", exitReason, (RTGCPTR)pCtx->rip));
2689 Log2(("Exit reason %d, exitQualification %RGv\n", (uint32_t)exitReason, exitQualification));
2690 Log2(("instrInfo=%d instrError=%d instr length=%d\n", (uint32_t)instrInfo, (uint32_t)instrError, (uint32_t)cbInstr));
2691 Log2(("Interruption error code %d\n", (uint32_t)errCode));
2692 Log2(("IntInfo = %08x\n", (uint32_t)intInfo));
2693
2694 /* Sync back the TPR if it was changed. */
2695 if ( fSetupTPRCaching
2696 && u8LastTPR != pVCpu->hwaccm.s.vmx.pVAPIC[0x80])
2697 {
2698 rc = PDMApicSetTPR(pVCpu, pVCpu->hwaccm.s.vmx.pVAPIC[0x80]);
2699 AssertRC(rc);
2700 }
2701
2702 STAM_PROFILE_ADV_STOP(&pVCpu->hwaccm.s.StatExit1, v);
2703 STAM_STATS({ STAM_PROFILE_ADV_START(&pVCpu->hwaccm.s.StatExit2, y); fStatExit2Started = true; });
2704
2705 /* Some cases don't need a complete resync of the guest CPU state; handle them here. */
2706 switch (exitReason)
2707 {
2708 case VMX_EXIT_EXCEPTION: /* 0 Exception or non-maskable interrupt (NMI). */
2709 case VMX_EXIT_EXTERNAL_IRQ: /* 1 External interrupt. */
2710 {
2711 uint32_t vector = VMX_EXIT_INTERRUPTION_INFO_VECTOR(intInfo);
2712
2713 if (!VMX_EXIT_INTERRUPTION_INFO_VALID(intInfo))
2714 {
2715 Assert(exitReason == VMX_EXIT_EXTERNAL_IRQ);
2716 /* External interrupt; leave to allow it to be dispatched again. */
2717 rc = VINF_EM_RAW_INTERRUPT;
2718 break;
2719 }
2720 STAM_PROFILE_ADV_START(&pVCpu->hwaccm.s.StatExit2Sub3, y3);
2721 switch (VMX_EXIT_INTERRUPTION_INFO_TYPE(intInfo))
2722 {
2723 case VMX_EXIT_INTERRUPTION_INFO_TYPE_NMI: /* Non-maskable interrupt. */
2724 /* External interrupt; leave to allow it to be dispatched again. */
2725 rc = VINF_EM_RAW_INTERRUPT;
2726 break;
2727
2728 case VMX_EXIT_INTERRUPTION_INFO_TYPE_EXT: /* External hardware interrupt. */
2729 AssertFailed(); /* can't come here; fails the first check. */
2730 break;
2731
2732 case VMX_EXIT_INTERRUPTION_INFO_TYPE_DBEXCPT: /* Unknown why we get this type for #DB */
2733 case VMX_EXIT_INTERRUPTION_INFO_TYPE_SWEXCPT: /* Software exception. (#BP or #OF) */
2734 Assert(vector == 1 || vector == 3 || vector == 4);
2735 /* no break */
2736 case VMX_EXIT_INTERRUPTION_INFO_TYPE_HWEXCPT: /* Hardware exception. */
2737 Log2(("Hardware/software interrupt %d\n", vector));
2738 switch (vector)
2739 {
2740 case X86_XCPT_NM:
2741 {
2742 Log(("#NM fault at %RGv error code %x\n", (RTGCPTR)pCtx->rip, errCode));
2743
2744 /** @todo don't intercept #NM exceptions anymore when we've activated the guest FPU state. */
2745 /* If we sync the FPU/XMM state on-demand, then we can continue execution as if nothing has happened. */
2746 rc = CPUMR0LoadGuestFPU(pVM, pVCpu, pCtx);
2747 if (rc == VINF_SUCCESS)
2748 {
2749 Assert(CPUMIsGuestFPUStateActive(pVCpu));
2750
2751 STAM_COUNTER_INC(&pVCpu->hwaccm.s.StatExitShadowNM);
2752
2753 /* Continue execution. */
2754 pVCpu->hwaccm.s.fContextUseFlags |= HWACCM_CHANGED_GUEST_CR0;
2755
2756 STAM_PROFILE_ADV_STOP(&pVCpu->hwaccm.s.StatExit2Sub3, y3);
2757 goto ResumeExecution;
2758 }
2759
2760 Log(("Forward #NM fault to the guest\n"));
2761 STAM_COUNTER_INC(&pVCpu->hwaccm.s.StatExitGuestNM);
2762 rc = VMXR0InjectEvent(pVM, pVCpu, pCtx, VMX_VMCS_CTRL_ENTRY_IRQ_INFO_FROM_EXIT_INT_INFO(intInfo), cbInstr, 0);
2763 AssertRC(rc);
2764 STAM_PROFILE_ADV_STOP(&pVCpu->hwaccm.s.StatExit2Sub3, y3);
2765 goto ResumeExecution;
2766 }
2767
2768 case X86_XCPT_PF: /* Page fault */
2769 {
2770#ifdef DEBUG
2771 if (pVM->hwaccm.s.fNestedPaging)
2772 { /* A genuine pagefault.
2773 * Forward the trap to the guest by injecting the exception and resuming execution.
2774 */
2775 Log(("Guest page fault at %RGv cr2=%RGv error code %x rsp=%RGv\n", (RTGCPTR)pCtx->rip, exitQualification, errCode, (RTGCPTR)pCtx->rsp));
2776
2777 Assert(CPUMIsGuestInPagedProtectedModeEx(pCtx));
2778
2779 STAM_COUNTER_INC(&pVCpu->hwaccm.s.StatExitGuestPF);
2780
2781 /* Now we must update CR2. */
2782 pCtx->cr2 = exitQualification;
2783 rc = VMXR0InjectEvent(pVM, pVCpu, pCtx, VMX_VMCS_CTRL_ENTRY_IRQ_INFO_FROM_EXIT_INT_INFO(intInfo), cbInstr, errCode);
2784 AssertRC(rc);
2785
2786 STAM_PROFILE_ADV_STOP(&pVCpu->hwaccm.s.StatExit2Sub3, y3);
2787 goto ResumeExecution;
2788 }
2789#endif
2790 Assert(!pVM->hwaccm.s.fNestedPaging);
2791
2792 Log2(("Page fault at %RGv error code %x\n", exitQualification, errCode));
2793 /* Exit qualification contains the linear address of the page fault. */
2794 TRPMAssertTrap(pVCpu, X86_XCPT_PF, TRPM_TRAP);
2795 TRPMSetErrorCode(pVCpu, errCode);
2796 TRPMSetFaultAddress(pVCpu, exitQualification);
2797
2798 /* Shortcut for APIC TPR reads and writes. */
2799 if ( (exitQualification & 0xfff) == 0x080
2800 && !(errCode & X86_TRAP_PF_P) /* not present */
2801 && fSetupTPRCaching
2802 && (pVM->hwaccm.s.vmx.msr.vmx_proc_ctls2.n.allowed1 & VMX_VMCS_CTRL_PROC_EXEC2_VIRT_APIC))
2803 {
2804 RTGCPHYS GCPhysApicBase, GCPhys;
2805 PDMApicGetBase(pVM, &GCPhysApicBase); /* @todo cache this */
2806 GCPhysApicBase &= PAGE_BASE_GC_MASK;
2807
2808 rc = PGMGstGetPage(pVCpu, (RTGCPTR)exitQualification, NULL, &GCPhys);
2809 if ( rc == VINF_SUCCESS
2810 && GCPhys == GCPhysApicBase)
2811 {
2812 Log(("Enable VT-x virtual APIC access filtering\n"));
2813 rc = IOMMMIOMapMMIOHCPage(pVM, GCPhysApicBase, pVM->hwaccm.s.vmx.pAPICPhys, X86_PTE_RW | X86_PTE_P);
2814 AssertRC(rc);
2815 }
2816 }
2817
2818 /* Forward it to our trap handler first, in case our shadow pages are out of sync. */
2819 rc = PGMTrap0eHandler(pVCpu, errCode, CPUMCTX2CORE(pCtx), (RTGCPTR)exitQualification);
2820 Log2(("PGMTrap0eHandler %RGv returned %Rrc\n", (RTGCPTR)pCtx->rip, rc));
2821 if (rc == VINF_SUCCESS)
2822 { /* We've successfully synced our shadow pages, so let's just continue execution. */
2823 Log2(("Shadow page fault at %RGv cr2=%RGv error code %x\n", (RTGCPTR)pCtx->rip, exitQualification ,errCode));
2824 STAM_COUNTER_INC(&pVCpu->hwaccm.s.StatExitShadowPF);
2825
2826 TRPMResetTrap(pVCpu);
2827
2828 STAM_PROFILE_ADV_STOP(&pVCpu->hwaccm.s.StatExit2Sub3, y3);
2829 goto ResumeExecution;
2830 }
2831 else
2832 if (rc == VINF_EM_RAW_GUEST_TRAP)
2833 { /* A genuine pagefault.
2834 * Forward the trap to the guest by injecting the exception and resuming execution.
2835 */
2836 Log2(("Forward page fault to the guest\n"));
2837
2838 STAM_COUNTER_INC(&pVCpu->hwaccm.s.StatExitGuestPF);
2839 /* The error code might have been changed. */
2840 errCode = TRPMGetErrorCode(pVCpu);
2841
2842 TRPMResetTrap(pVCpu);
2843
2844 /* Now we must update CR2. */
2845 pCtx->cr2 = exitQualification;
2846 rc = VMXR0InjectEvent(pVM, pVCpu, pCtx, VMX_VMCS_CTRL_ENTRY_IRQ_INFO_FROM_EXIT_INT_INFO(intInfo), cbInstr, errCode);
2847 AssertRC(rc);
2848
2849 STAM_PROFILE_ADV_STOP(&pVCpu->hwaccm.s.StatExit2Sub3, y3);
2850 goto ResumeExecution;
2851 }
2852#ifdef VBOX_STRICT
2853 if (rc != VINF_EM_RAW_EMULATE_INSTR && rc != VINF_EM_RAW_EMULATE_IO_BLOCK)
2854 Log2(("PGMTrap0eHandler failed with %d\n", rc));
2855#endif
2856 /* Need to go back to the recompiler to emulate the instruction. */
2857 TRPMResetTrap(pVCpu);
2858 break;
2859 }
2860
2861 case X86_XCPT_MF: /* Floating point exception. */
2862 {
2863 STAM_COUNTER_INC(&pVCpu->hwaccm.s.StatExitGuestMF);
2864 if (!(pCtx->cr0 & X86_CR0_NE))
2865 {
2866 /* old style FPU error reporting needs some extra work. */
2867 /** @todo don't fall back to the recompiler, but do it manually. */
2868 rc = VINF_EM_RAW_EMULATE_INSTR;
2869 break;
2870 }
2871 Log(("Trap %x at %04X:%RGv\n", vector, pCtx->cs, (RTGCPTR)pCtx->rip));
2872 rc = VMXR0InjectEvent(pVM, pVCpu, pCtx, VMX_VMCS_CTRL_ENTRY_IRQ_INFO_FROM_EXIT_INT_INFO(intInfo), cbInstr, errCode);
2873 AssertRC(rc);
2874
2875 STAM_PROFILE_ADV_STOP(&pVCpu->hwaccm.s.StatExit2Sub3, y3);
2876 goto ResumeExecution;
2877 }
2878
2879 case X86_XCPT_DB: /* Debug exception. */
2880 {
2881 uint64_t uDR6;
2882
2883 /* DR6, DR7.GD and IA32_DEBUGCTL.LBR are not updated yet.
2884 *
2885 * Exit qualification bits:
2886 * 3:0 B0-B3 which breakpoint condition was met
2887 * 12:4 Reserved (0)
2888 * 13 BD - debug register access detected
2889 * 14 BS - single step execution or branch taken
2890 * 63:15 Reserved (0)
2891 */
2892 STAM_COUNTER_INC(&pVCpu->hwaccm.s.StatExitGuestDB);
2893
2894 /* Note that we don't support guest and host-initiated debugging at the same time. */
2895 Assert(DBGFIsStepping(pVCpu) || CPUMIsGuestInRealModeEx(pCtx) || CPUMIsHyperDebugStateActive(pVCpu));
2896
2897 uDR6 = X86_DR6_INIT_VAL;
2898 uDR6 |= (exitQualification & (X86_DR6_B0|X86_DR6_B1|X86_DR6_B2|X86_DR6_B3|X86_DR6_BD|X86_DR6_BS));
2899 rc = DBGFRZTrap01Handler(pVM, pVCpu, CPUMCTX2CORE(pCtx), uDR6);
2900 if (rc == VINF_EM_RAW_GUEST_TRAP)
2901 {
2902 /** @todo this isn't working, but we'll never get here normally. */
2903
2904 /* Update DR6 here. */
2905 pCtx->dr[6] = uDR6;
2906
2907 /* X86_DR7_GD will be cleared if drx accesses should be trapped inside the guest. */
2908 pCtx->dr[7] &= ~X86_DR7_GD;
2909
2910 /* Paranoia. */
2911 pCtx->dr[7] &= 0xffffffff; /* upper 32 bits reserved */
2912 pCtx->dr[7] &= ~(RT_BIT(11) | RT_BIT(12) | RT_BIT(14) | RT_BIT(15)); /* must be zero */
2913 pCtx->dr[7] |= 0x400; /* must be one */
2914
2915 /* Resync DR7 */
2916 rc = VMXWriteVMCS64(VMX_VMCS64_GUEST_DR7, pCtx->dr[7]);
2917 AssertRC(rc);
2918
2919 Log(("Trap %x (debug) at %RGv exit qualification %RX64\n", vector, (RTGCPTR)pCtx->rip, exitQualification));
2920 rc = VMXR0InjectEvent(pVM, pVCpu, pCtx, VMX_VMCS_CTRL_ENTRY_IRQ_INFO_FROM_EXIT_INT_INFO(intInfo), cbInstr, errCode);
2921 AssertRC(rc);
2922
2923 STAM_PROFILE_ADV_STOP(&pVCpu->hwaccm.s.StatExit2Sub3, y3);
2924 goto ResumeExecution;
2925 }
2926 /* Return to ring 3 to deal with the debug exit code. */
2927 Log(("Debugger hardware BP at %04x:%RGv (rc=%Rrc)\n", pCtx->cs, pCtx->rip, rc));
2928 break;
2929 }
2930
2931 case X86_XCPT_BP: /* Breakpoint. */
2932 {
2933 rc = DBGFRZTrap03Handler(pVM, pVCpu, CPUMCTX2CORE(pCtx));
2934 if (rc == VINF_EM_RAW_GUEST_TRAP)
2935 {
2936 Log(("Guest #BP at %04x:%RGv\n", pCtx->cs, pCtx->rip));
2937 rc = VMXR0InjectEvent(pVM, pVCpu, pCtx, VMX_VMCS_CTRL_ENTRY_IRQ_INFO_FROM_EXIT_INT_INFO(intInfo), cbInstr, errCode);
2938 AssertRC(rc);
2939 goto ResumeExecution;
2940 }
2941 if (rc == VINF_SUCCESS)
2942 goto ResumeExecution;
2943 Log(("Debugger BP at %04x:%RGv (rc=%Rrc)\n", pCtx->cs, pCtx->rip, rc));
2944 break;
2945 }
2946
2947 case X86_XCPT_GP: /* General protection failure exception.*/
2948 {
2949 uint32_t cbOp;
2950 uint32_t cbSize;
2951 PDISCPUSTATE pDis = &pVCpu->hwaccm.s.DisState;
2952
2953 STAM_COUNTER_INC(&pVCpu->hwaccm.s.StatExitGuestGP);
2954#ifdef VBOX_STRICT
2955 if (!CPUMIsGuestInRealModeEx(pCtx))
2956 {
2957 Log(("Trap %x at %04X:%RGv errorCode=%x\n", vector, pCtx->cs, (RTGCPTR)pCtx->rip, errCode));
2958 rc = VMXR0InjectEvent(pVM, pVCpu, pCtx, VMX_VMCS_CTRL_ENTRY_IRQ_INFO_FROM_EXIT_INT_INFO(intInfo), cbInstr, errCode);
2959 AssertRC(rc);
2960 STAM_PROFILE_ADV_STOP(&pVCpu->hwaccm.s.StatExit2Sub3, y3);
2961 goto ResumeExecution;
2962 }
2963#endif
2964 Assert(CPUMIsGuestInRealModeEx(pCtx));
2965
2966 LogFlow(("Real mode X86_XCPT_GP instruction emulation at %RGv\n", (RTGCPTR)pCtx->rip));
2967
2968 rc = EMInterpretDisasOne(pVM, pVCpu, CPUMCTX2CORE(pCtx), pDis, &cbOp);
2969 if (RT_SUCCESS(rc))
2970 {
2971 bool fUpdateRIP = true;
2972
2973 Assert(cbOp == pDis->opsize);
2974 switch (pDis->pCurInstr->opcode)
2975 {
2976 case OP_CLI:
2977 pCtx->eflags.Bits.u1IF = 0;
2978 STAM_COUNTER_INC(&pVCpu->hwaccm.s.StatExitCli);
2979 break;
2980
2981 case OP_STI:
2982 pCtx->eflags.Bits.u1IF = 1;
2983 EMSetInhibitInterruptsPC(pVCpu, pCtx->rip + pDis->opsize);
2984 Assert(VMCPU_FF_ISSET(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS));
2985 rc = VMXWriteVMCS(VMX_VMCS32_GUEST_INTERRUPTIBILITY_STATE, VMX_VMCS_GUEST_INTERRUPTIBILITY_STATE_BLOCK_STI);
2986 AssertRC(rc);
2987 STAM_COUNTER_INC(&pVCpu->hwaccm.s.StatExitSti);
2988 break;
2989
2990 case OP_HLT:
2991 fUpdateRIP = false;
2992 rc = VINF_EM_HALT;
2993 pCtx->rip += pDis->opsize;
2994 STAM_COUNTER_INC(&pVCpu->hwaccm.s.StatExitHlt);
2995 break;
2996
2997 case OP_POPF:
2998 {
2999 RTGCPTR GCPtrStack;
3000 uint32_t cbParm;
3001 uint32_t uMask;
3002 X86EFLAGS eflags;
3003
3004 if (pDis->prefix & PREFIX_OPSIZE)
3005 {
3006 cbParm = 4;
3007 uMask = 0xffffffff;
3008 }
3009 else
3010 {
3011 cbParm = 2;
3012 uMask = 0xffff;
3013 }
3014
3015 rc = SELMToFlatEx(pVM, DIS_SELREG_SS, CPUMCTX2CORE(pCtx), pCtx->esp & uMask, 0, &GCPtrStack);
3016 if (RT_FAILURE(rc))
3017 {
3018 rc = VERR_EM_INTERPRETER;
3019 break;
3020 }
3021 eflags.u = 0;
3022 rc = PGMPhysRead(pVM, (RTGCPHYS)GCPtrStack, &eflags.u, cbParm);
3023 if (RT_FAILURE(rc))
3024 {
3025 rc = VERR_EM_INTERPRETER;
3026 break;
3027 }
3028 LogFlow(("POPF %x -> %RGv mask=%x\n", eflags.u, pCtx->rsp, uMask));
3029 pCtx->eflags.u = (pCtx->eflags.u & ~(X86_EFL_POPF_BITS & uMask)) | (eflags.u & X86_EFL_POPF_BITS & uMask);
3030 /* RF cleared when popped in real mode; see pushf description in AMD manual. */
3031 pCtx->eflags.Bits.u1RF = 0;
3032 pCtx->esp += cbParm;
3033 pCtx->esp &= uMask;
3034
3035 STAM_COUNTER_INC(&pVCpu->hwaccm.s.StatExitPopf);
3036 break;
3037 }
3038
3039 case OP_PUSHF:
3040 {
3041 RTGCPTR GCPtrStack;
3042 uint32_t cbParm;
3043 uint32_t uMask;
3044 X86EFLAGS eflags;
3045
3046 if (pDis->prefix & PREFIX_OPSIZE)
3047 {
3048 cbParm = 4;
3049 uMask = 0xffffffff;
3050 }
3051 else
3052 {
3053 cbParm = 2;
3054 uMask = 0xffff;
3055 }
3056
3057 rc = SELMToFlatEx(pVM, DIS_SELREG_SS, CPUMCTX2CORE(pCtx), (pCtx->esp - cbParm) & uMask, 0, &GCPtrStack);
3058 if (RT_FAILURE(rc))
3059 {
3060 rc = VERR_EM_INTERPRETER;
3061 break;
3062 }
3063 eflags = pCtx->eflags;
3064 /* RF & VM cleared when pushed in real mode; see pushf description in AMD manual. */
3065 eflags.Bits.u1RF = 0;
3066 eflags.Bits.u1VM = 0;
3067
3068 rc = PGMPhysWrite(pVM, (RTGCPHYS)GCPtrStack, &eflags.u, cbParm);
3069 if (RT_FAILURE(rc))
3070 {
3071 rc = VERR_EM_INTERPRETER;
3072 break;
3073 }
3074 LogFlow(("PUSHF %x -> %RGv\n", eflags.u, GCPtrStack));
3075 pCtx->esp -= cbParm;
3076 pCtx->esp &= uMask;
3077 STAM_COUNTER_INC(&pVCpu->hwaccm.s.StatExitPushf);
3078 break;
3079 }
3080
3081 case OP_IRET:
3082 {
3083 RTGCPTR GCPtrStack;
3084 uint32_t uMask = 0xffff;
3085 uint16_t aIretFrame[3];
3086
3087 if (pDis->prefix & (PREFIX_OPSIZE | PREFIX_ADDRSIZE))
3088 {
3089 rc = VERR_EM_INTERPRETER;
3090 break;
3091 }
3092
3093 rc = SELMToFlatEx(pVM, DIS_SELREG_SS, CPUMCTX2CORE(pCtx), pCtx->esp & uMask, 0, &GCPtrStack);
3094 if (RT_FAILURE(rc))
3095 {
3096 rc = VERR_EM_INTERPRETER;
3097 break;
3098 }
3099 rc = PGMPhysRead(pVM, (RTGCPHYS)GCPtrStack, &aIretFrame[0], sizeof(aIretFrame));
3100 if (RT_FAILURE(rc))
3101 {
3102 rc = VERR_EM_INTERPRETER;
3103 break;
3104 }
3105 pCtx->ip = aIretFrame[0];
3106 pCtx->cs = aIretFrame[1];
3107 pCtx->csHid.u64Base = pCtx->cs << 4;
3108 pCtx->eflags.u = (pCtx->eflags.u & ~(X86_EFL_POPF_BITS & uMask)) | (aIretFrame[2] & X86_EFL_POPF_BITS & uMask);
3109 pCtx->sp += sizeof(aIretFrame);
3110
3111 LogFlow(("iret to %04x:%x\n", pCtx->cs, pCtx->ip));
3112 fUpdateRIP = false;
3113 STAM_COUNTER_INC(&pVCpu->hwaccm.s.StatExitIret);
3114 break;
3115 }
3116
3117 case OP_INT:
3118 {
3119 RTGCUINTPTR intInfo;
3120
3121 LogFlow(("Realmode: INT %x\n", pDis->param1.parval & 0xff));
3122 intInfo = pDis->param1.parval & 0xff;
3123 intInfo |= (1 << VMX_EXIT_INTERRUPTION_INFO_VALID_SHIFT);
3124 intInfo |= (VMX_EXIT_INTERRUPTION_INFO_TYPE_SW << VMX_EXIT_INTERRUPTION_INFO_TYPE_SHIFT);
3125
3126 rc = VMXR0InjectEvent(pVM, pVCpu, pCtx, intInfo, cbOp, 0);
3127 AssertRC(rc);
3128 fUpdateRIP = false;
3129 STAM_COUNTER_INC(&pVCpu->hwaccm.s.StatExitInt);
3130 break;
3131 }
3132
3133 case OP_INTO:
3134 {
3135 if (pCtx->eflags.Bits.u1OF)
3136 {
3137 RTGCUINTPTR intInfo;
3138
3139 LogFlow(("Realmode: INTO\n"));
3140 intInfo = X86_XCPT_OF;
3141 intInfo |= (1 << VMX_EXIT_INTERRUPTION_INFO_VALID_SHIFT);
3142 intInfo |= (VMX_EXIT_INTERRUPTION_INFO_TYPE_SW << VMX_EXIT_INTERRUPTION_INFO_TYPE_SHIFT);
3143
3144 rc = VMXR0InjectEvent(pVM, pVCpu, pCtx, intInfo, cbOp, 0);
3145 AssertRC(rc);
3146 fUpdateRIP = false;
3147 STAM_COUNTER_INC(&pVCpu->hwaccm.s.StatExitInt);
3148 }
3149 break;
3150 }
3151
3152 case OP_INT3:
3153 {
3154 RTGCUINTPTR intInfo;
3155
3156 LogFlow(("Realmode: INT 3\n"));
3157 intInfo = 3;
3158 intInfo |= (1 << VMX_EXIT_INTERRUPTION_INFO_VALID_SHIFT);
3159 intInfo |= (VMX_EXIT_INTERRUPTION_INFO_TYPE_SW << VMX_EXIT_INTERRUPTION_INFO_TYPE_SHIFT);
3160
3161 rc = VMXR0InjectEvent(pVM, pVCpu, pCtx, intInfo, cbOp, 0);
3162 AssertRC(rc);
3163 fUpdateRIP = false;
3164 STAM_COUNTER_INC(&pVCpu->hwaccm.s.StatExitInt);
3165 break;
3166 }
3167
3168 default:
3169 rc = EMInterpretInstructionCPU(pVM, pVCpu, pDis, CPUMCTX2CORE(pCtx), 0, &cbSize);
3170 break;
3171 }
3172
3173 if (rc == VINF_SUCCESS)
3174 {
3175 if (fUpdateRIP)
3176 pCtx->rip += cbOp; /* Move on to the next instruction. */
3177
3178 /* lidt, lgdt can end up here. In the future crx changes as well. Just reload the whole context to be done with it. */
3179 pVCpu->hwaccm.s.fContextUseFlags |= HWACCM_CHANGED_ALL;
3180
3181 /* Only resume if successful. */
3182 STAM_PROFILE_ADV_STOP(&pVCpu->hwaccm.s.StatExit2Sub3, y3);
3183 goto ResumeExecution;
3184 }
3185 }
3186 else
3187 rc = VERR_EM_INTERPRETER;
3188
3189 AssertMsg(rc == VERR_EM_INTERPRETER || rc == VINF_PGM_CHANGE_MODE || rc == VINF_EM_HALT, ("Unexpected rc=%Rrc\n", rc));
3190 break;
3191 }
3192
3193#ifdef VBOX_STRICT
3194 case X86_XCPT_DE: /* Divide error. */
3195 case X86_XCPT_UD: /* Unknown opcode exception. */
3196 case X86_XCPT_SS: /* Stack segment exception. */
3197 case X86_XCPT_NP: /* Segment not present exception. */
3198 {
3199 switch(vector)
3200 {
3201 case X86_XCPT_DE:
3202 STAM_COUNTER_INC(&pVCpu->hwaccm.s.StatExitGuestDE);
3203 break;
3204 case X86_XCPT_UD:
3205 STAM_COUNTER_INC(&pVCpu->hwaccm.s.StatExitGuestUD);
3206 break;
3207 case X86_XCPT_SS:
3208 STAM_COUNTER_INC(&pVCpu->hwaccm.s.StatExitGuestSS);
3209 break;
3210 case X86_XCPT_NP:
3211 STAM_COUNTER_INC(&pVCpu->hwaccm.s.StatExitGuestNP);
3212 break;
3213 }
3214
3215 Log(("Trap %x at %04X:%RGv\n", vector, pCtx->cs, (RTGCPTR)pCtx->rip));
3216 rc = VMXR0InjectEvent(pVM, pVCpu, pCtx, VMX_VMCS_CTRL_ENTRY_IRQ_INFO_FROM_EXIT_INT_INFO(intInfo), cbInstr, errCode);
3217 AssertRC(rc);
3218
3219 STAM_PROFILE_ADV_STOP(&pVCpu->hwaccm.s.StatExit2Sub3, y3);
3220 goto ResumeExecution;
3221 }
3222#endif
3223 default:
3224#ifdef HWACCM_VMX_EMULATE_REALMODE
3225 if (CPUMIsGuestInRealModeEx(pCtx))
3226 {
3227 Log(("Real Mode Trap %x at %04x:%04X error code %x\n", vector, pCtx->cs, pCtx->eip, errCode));
3228 rc = VMXR0InjectEvent(pVM, pVCpu, pCtx, VMX_VMCS_CTRL_ENTRY_IRQ_INFO_FROM_EXIT_INT_INFO(intInfo), cbInstr, errCode);
3229 AssertRC(rc);
3230
3231 /* Go back to ring 3 in case of a triple fault. */
3232 if ( vector == X86_XCPT_DF
3233 && rc == VINF_EM_RESET)
3234 break;
3235
3236 STAM_PROFILE_ADV_STOP(&pVCpu->hwaccm.s.StatExit2Sub3, y3);
3237 goto ResumeExecution;
3238 }
3239#endif
3240 AssertMsgFailed(("Unexpected vm-exit caused by exception %x\n", vector));
3241 rc = VERR_VMX_UNEXPECTED_EXCEPTION;
3242 break;
3243 } /* switch (vector) */
3244
3245 break;
3246
3247 default:
3248 rc = VERR_VMX_UNEXPECTED_INTERRUPTION_EXIT_CODE;
3249 AssertMsgFailed(("Unexpected interuption code %x\n", intInfo));
3250 break;
3251 }
3252
3253 STAM_PROFILE_ADV_STOP(&pVCpu->hwaccm.s.StatExit2Sub3, y3);
3254 break;
3255 }
3256
3257 case VMX_EXIT_EPT_VIOLATION: /* 48 EPT violation. An attempt to access memory with a guest-physical address was disallowed by the configuration of the EPT paging structures. */
3258 {
3259 RTGCPHYS GCPhys;
3260
3261 Assert(pVM->hwaccm.s.fNestedPaging);
3262
3263 rc = VMXReadVMCS64(VMX_VMCS_EXIT_PHYS_ADDR_FULL, &GCPhys);
3264 AssertRC(rc);
3265 Assert(((exitQualification >> 7) & 3) != 2);
3266
3267 /* Determine the kind of violation. */
3268 errCode = 0;
3269 if (exitQualification & VMX_EXIT_QUALIFICATION_EPT_INSTR_FETCH)
3270 errCode |= X86_TRAP_PF_ID;
3271
3272 if (exitQualification & VMX_EXIT_QUALIFICATION_EPT_DATA_WRITE)
3273 errCode |= X86_TRAP_PF_RW;
3274
3275 /* If the page is present, then it's a page level protection fault. */
3276 if (exitQualification & VMX_EXIT_QUALIFICATION_EPT_ENTRY_PRESENT)
3277 {
3278 errCode |= X86_TRAP_PF_P;
3279 }
3280 else {
3281 /* Shortcut for APIC TPR reads and writes. */
3282 if ( (GCPhys & 0xfff) == 0x080
3283 && GCPhys > 0x1000000 /* to skip VGA frame buffer accesses */
3284 && fSetupTPRCaching
3285 && (pVM->hwaccm.s.vmx.msr.vmx_proc_ctls2.n.allowed1 & VMX_VMCS_CTRL_PROC_EXEC2_VIRT_APIC))
3286 {
3287 RTGCPHYS GCPhysApicBase;
3288 PDMApicGetBase(pVM, &GCPhysApicBase); /* @todo cache this */
3289 GCPhysApicBase &= PAGE_BASE_GC_MASK;
3290 if (GCPhys == GCPhysApicBase + 0x80)
3291 {
3292 Log(("Enable VT-x virtual APIC access filtering\n"));
3293 rc = IOMMMIOMapMMIOHCPage(pVM, GCPhysApicBase, pVM->hwaccm.s.vmx.pAPICPhys, X86_PTE_RW | X86_PTE_P);
3294 AssertRC(rc);
3295 }
3296 }
3297 }
3298 Log(("EPT Page fault %x at %RGp error code %x\n", (uint32_t)exitQualification, GCPhys, errCode));
3299
3300 /* GCPhys contains the guest physical address of the page fault. */
3301 TRPMAssertTrap(pVCpu, X86_XCPT_PF, TRPM_TRAP);
3302 TRPMSetErrorCode(pVCpu, errCode);
3303 TRPMSetFaultAddress(pVCpu, GCPhys);
3304
3305 /* Handle the pagefault trap for the nested shadow table. */
3306 rc = PGMR0Trap0eHandlerNestedPaging(pVM, pVCpu, PGMMODE_EPT, errCode, CPUMCTX2CORE(pCtx), GCPhys);
3307 Log2(("PGMR0Trap0eHandlerNestedPaging %RGv returned %Rrc\n", (RTGCPTR)pCtx->rip, rc));
3308 if (rc == VINF_SUCCESS)
3309 { /* We've successfully synced our shadow pages, so let's just continue execution. */
3310 Log2(("Shadow page fault at %RGv cr2=%RGp error code %x\n", (RTGCPTR)pCtx->rip, exitQualification , errCode));
3311 STAM_COUNTER_INC(&pVCpu->hwaccm.s.StatExitReasonNPF);
3312
3313 TRPMResetTrap(pVCpu);
3314
3315 goto ResumeExecution;
3316 }
3317
3318#ifdef VBOX_STRICT
3319 if (rc != VINF_EM_RAW_EMULATE_INSTR)
3320 LogFlow(("PGMTrap0eHandlerNestedPaging failed with %d\n", rc));
3321#endif
3322 /* Need to go back to the recompiler to emulate the instruction. */
3323 TRPMResetTrap(pVCpu);
3324 break;
3325 }
3326
3327 case VMX_EXIT_EPT_MISCONFIG:
3328 {
3329 RTGCPHYS GCPhys;
3330
3331 Assert(pVM->hwaccm.s.fNestedPaging);
3332
3333 rc = VMXReadVMCS64(VMX_VMCS_EXIT_PHYS_ADDR_FULL, &GCPhys);
3334 AssertRC(rc);
3335
3336 Log(("VMX_EXIT_EPT_MISCONFIG for %VGp\n", GCPhys));
3337 break;
3338 }
3339
3340 case VMX_EXIT_IRQ_WINDOW: /* 7 Interrupt window. */
3341 /* Clear VM-exit on IF=1 change. */
3342 LogFlow(("VMX_EXIT_IRQ_WINDOW %RGv pending=%d IF=%d\n", (RTGCPTR)pCtx->rip, VMCPU_FF_ISPENDING(pVCpu, (VMCPU_FF_INTERRUPT_APIC|VMCPU_FF_INTERRUPT_PIC)), pCtx->eflags.Bits.u1IF));
3343 pVCpu->hwaccm.s.vmx.proc_ctls &= ~VMX_VMCS_CTRL_PROC_EXEC_CONTROLS_IRQ_WINDOW_EXIT;
3344 rc = VMXWriteVMCS(VMX_VMCS_CTRL_PROC_EXEC_CONTROLS, pVCpu->hwaccm.s.vmx.proc_ctls);
3345 AssertRC(rc);
3346 STAM_COUNTER_INC(&pVCpu->hwaccm.s.StatExitIrqWindow);
3347 goto ResumeExecution; /* we check for pending guest interrupts there */
3348
3349 case VMX_EXIT_WBINVD: /* 54 Guest software attempted to execute WBINVD. (conditional) */
3350 case VMX_EXIT_INVD: /* 13 Guest software attempted to execute INVD. (unconditional) */
3351 STAM_COUNTER_INC(&pVCpu->hwaccm.s.StatExitInvd);
3352 /* Skip instruction and continue directly. */
3353 pCtx->rip += cbInstr;
3354 /* Continue execution.*/
3355 goto ResumeExecution;
3356
3357 case VMX_EXIT_CPUID: /* 10 Guest software attempted to execute CPUID. */
3358 {
3359 Log2(("VMX: Cpuid %x\n", pCtx->eax));
3360 STAM_COUNTER_INC(&pVCpu->hwaccm.s.StatExitCpuid);
3361 rc = EMInterpretCpuId(pVM, pVCpu, CPUMCTX2CORE(pCtx));
3362 if (rc == VINF_SUCCESS)
3363 {
3364 /* Update EIP and continue execution. */
3365 Assert(cbInstr == 2);
3366 pCtx->rip += cbInstr;
3367 goto ResumeExecution;
3368 }
3369 AssertMsgFailed(("EMU: cpuid failed with %Rrc\n", rc));
3370 rc = VINF_EM_RAW_EMULATE_INSTR;
3371 break;
3372 }
3373
3374 case VMX_EXIT_RDPMC: /* 15 Guest software attempted to execute RDPMC. */
3375 {
3376 Log2(("VMX: Rdpmc %x\n", pCtx->ecx));
3377 STAM_COUNTER_INC(&pVCpu->hwaccm.s.StatExitRdpmc);
3378 rc = EMInterpretRdpmc(pVM, pVCpu, CPUMCTX2CORE(pCtx));
3379 if (rc == VINF_SUCCESS)
3380 {
3381 /* Update EIP and continue execution. */
3382 Assert(cbInstr == 2);
3383 pCtx->rip += cbInstr;
3384 goto ResumeExecution;
3385 }
3386 rc = VINF_EM_RAW_EMULATE_INSTR;
3387 break;
3388 }
3389
3390 case VMX_EXIT_RDTSC: /* 16 Guest software attempted to execute RDTSC. */
3391 {
3392 Log2(("VMX: Rdtsc\n"));
3393 STAM_COUNTER_INC(&pVCpu->hwaccm.s.StatExitRdtsc);
3394 rc = EMInterpretRdtsc(pVM, pVCpu, CPUMCTX2CORE(pCtx));
3395 if (rc == VINF_SUCCESS)
3396 {
3397 /* Update EIP and continue execution. */
3398 Assert(cbInstr == 2);
3399 pCtx->rip += cbInstr;
3400 goto ResumeExecution;
3401 }
3402 rc = VINF_EM_RAW_EMULATE_INSTR;
3403 break;
3404 }
3405
3406 case VMX_EXIT_INVPG: /* 14 Guest software attempted to execute INVPG. */
3407 {
3408 Log2(("VMX: invlpg\n"));
3409 Assert(!pVM->hwaccm.s.fNestedPaging);
3410
3411 STAM_COUNTER_INC(&pVCpu->hwaccm.s.StatExitInvpg);
3412 rc = EMInterpretInvlpg(pVM, pVCpu, CPUMCTX2CORE(pCtx), exitQualification);
3413 if (rc == VINF_SUCCESS)
3414 {
3415 /* Update EIP and continue execution. */
3416 pCtx->rip += cbInstr;
3417 goto ResumeExecution;
3418 }
3419 AssertMsg(rc == VERR_EM_INTERPRETER, ("EMU: invlpg %RGv failed with %Rrc\n", exitQualification, rc));
3420 break;
3421 }
3422
3423 case VMX_EXIT_RDMSR: /* 31 RDMSR. Guest software attempted to execute RDMSR. */
3424 case VMX_EXIT_WRMSR: /* 32 WRMSR. Guest software attempted to execute WRMSR. */
3425 {
3426 uint32_t cbSize;
3427
3428 STAM_COUNTER_INC((exitReason == VMX_EXIT_RDMSR) ? &pVCpu->hwaccm.s.StatExitRdmsr : &pVCpu->hwaccm.s.StatExitWrmsr);
3429
3430 /* Note: the intel manual claims there's a REX version of RDMSR that's slightly different, so we play safe by completely disassembling the instruction. */
3431 Log2(("VMX: %s\n", (exitReason == VMX_EXIT_RDMSR) ? "rdmsr" : "wrmsr"));
3432 rc = EMInterpretInstruction(pVM, pVCpu, CPUMCTX2CORE(pCtx), 0, &cbSize);
3433 if (rc == VINF_SUCCESS)
3434 {
3435 /* EIP has been updated already. */
3436
3437 /* Only resume if successful. */
3438 goto ResumeExecution;
3439 }
3440 AssertMsg(rc == VERR_EM_INTERPRETER, ("EMU: %s failed with %Rrc\n", (exitReason == VMX_EXIT_RDMSR) ? "rdmsr" : "wrmsr", rc));
3441 break;
3442 }
3443
3444 case VMX_EXIT_CRX_MOVE: /* 28 Control-register accesses. */
3445 {
3446 STAM_PROFILE_ADV_START(&pVCpu->hwaccm.s.StatExit2Sub2, y2);
3447
3448 switch (VMX_EXIT_QUALIFICATION_CRX_ACCESS(exitQualification))
3449 {
3450 case VMX_EXIT_QUALIFICATION_CRX_ACCESS_WRITE:
3451 Log2(("VMX: %RGv mov cr%d, x\n", (RTGCPTR)pCtx->rip, VMX_EXIT_QUALIFICATION_CRX_REGISTER(exitQualification)));
3452 STAM_COUNTER_INC(&pVCpu->hwaccm.s.StatExitCRxWrite[VMX_EXIT_QUALIFICATION_CRX_REGISTER(exitQualification)]);
3453 rc = EMInterpretCRxWrite(pVM, pVCpu, CPUMCTX2CORE(pCtx),
3454 VMX_EXIT_QUALIFICATION_CRX_REGISTER(exitQualification),
3455 VMX_EXIT_QUALIFICATION_CRX_GENREG(exitQualification));
3456
3457 switch (VMX_EXIT_QUALIFICATION_CRX_REGISTER(exitQualification))
3458 {
3459 case 0:
3460 pVCpu->hwaccm.s.fContextUseFlags |= HWACCM_CHANGED_GUEST_CR0 | HWACCM_CHANGED_GUEST_CR3;
3461 break;
3462 case 2:
3463 break;
3464 case 3:
3465 Assert(!pVM->hwaccm.s.fNestedPaging || !CPUMIsGuestInPagedProtectedModeEx(pCtx));
3466 pVCpu->hwaccm.s.fContextUseFlags |= HWACCM_CHANGED_GUEST_CR3;
3467 break;
3468 case 4:
3469 pVCpu->hwaccm.s.fContextUseFlags |= HWACCM_CHANGED_GUEST_CR4;
3470 break;
3471 case 8:
3472 /* CR8 contains the APIC TPR */
3473 Assert(!(pVM->hwaccm.s.vmx.msr.vmx_proc_ctls.n.allowed1 & VMX_VMCS_CTRL_PROC_EXEC_CONTROLS_USE_TPR_SHADOW));
3474 break;
3475
3476 default:
3477 AssertFailed();
3478 break;
3479 }
3480 /* Check if a sync operation is pending. */
3481 if ( rc == VINF_SUCCESS /* don't bother if we are going to ring 3 anyway */
3482 && VMCPU_FF_ISPENDING(pVCpu, VMCPU_FF_PGM_SYNC_CR3 | VMCPU_FF_PGM_SYNC_CR3_NON_GLOBAL))
3483 {
3484 rc = PGMSyncCR3(pVCpu, pCtx->cr0, pCtx->cr3, pCtx->cr4, VMCPU_FF_ISSET(pVCpu, VMCPU_FF_PGM_SYNC_CR3));
3485 AssertRC(rc);
3486 }
3487 break;
3488
3489 case VMX_EXIT_QUALIFICATION_CRX_ACCESS_READ:
3490 Log2(("VMX: mov x, crx\n"));
3491 STAM_COUNTER_INC(&pVCpu->hwaccm.s.StatExitCRxRead[VMX_EXIT_QUALIFICATION_CRX_REGISTER(exitQualification)]);
3492
3493 Assert(!pVM->hwaccm.s.fNestedPaging || !CPUMIsGuestInPagedProtectedModeEx(pCtx) || VMX_EXIT_QUALIFICATION_CRX_REGISTER(exitQualification) != USE_REG_CR3);
3494
3495 /* CR8 reads only cause an exit when the TPR shadow feature isn't present. */
3496 Assert(VMX_EXIT_QUALIFICATION_CRX_REGISTER(exitQualification) != 8 || !(pVM->hwaccm.s.vmx.msr.vmx_proc_ctls.n.allowed1 & VMX_VMCS_CTRL_PROC_EXEC_CONTROLS_USE_TPR_SHADOW));
3497
3498 rc = EMInterpretCRxRead(pVM, pVCpu, CPUMCTX2CORE(pCtx),
3499 VMX_EXIT_QUALIFICATION_CRX_GENREG(exitQualification),
3500 VMX_EXIT_QUALIFICATION_CRX_REGISTER(exitQualification));
3501 break;
3502
3503 case VMX_EXIT_QUALIFICATION_CRX_ACCESS_CLTS:
3504 Log2(("VMX: clts\n"));
3505 STAM_COUNTER_INC(&pVCpu->hwaccm.s.StatExitCLTS);
3506 rc = EMInterpretCLTS(pVM, pVCpu);
3507 pVCpu->hwaccm.s.fContextUseFlags |= HWACCM_CHANGED_GUEST_CR0;
3508 break;
3509
3510 case VMX_EXIT_QUALIFICATION_CRX_ACCESS_LMSW:
3511 Log2(("VMX: lmsw %x\n", VMX_EXIT_QUALIFICATION_CRX_LMSW_DATA(exitQualification)));
3512 STAM_COUNTER_INC(&pVCpu->hwaccm.s.StatExitLMSW);
3513 rc = EMInterpretLMSW(pVM, pVCpu, CPUMCTX2CORE(pCtx), VMX_EXIT_QUALIFICATION_CRX_LMSW_DATA(exitQualification));
3514 pVCpu->hwaccm.s.fContextUseFlags |= HWACCM_CHANGED_GUEST_CR0;
3515 break;
3516 }
3517
3518 /* Update EIP if no error occurred. */
3519 if (RT_SUCCESS(rc))
3520 pCtx->rip += cbInstr;
3521
3522 if (rc == VINF_SUCCESS)
3523 {
3524 /* Only resume if successful. */
3525 STAM_PROFILE_ADV_STOP(&pVCpu->hwaccm.s.StatExit2Sub2, y2);
3526 goto ResumeExecution;
3527 }
3528 Assert(rc == VERR_EM_INTERPRETER || rc == VINF_PGM_CHANGE_MODE || rc == VINF_PGM_SYNC_CR3);
3529 STAM_PROFILE_ADV_STOP(&pVCpu->hwaccm.s.StatExit2Sub2, y2);
3530 break;
3531 }
3532
3533 case VMX_EXIT_DRX_MOVE: /* 29 Debug-register accesses. */
3534 {
3535 if ( !DBGFIsStepping(pVCpu)
3536 && !CPUMIsHyperDebugStateActive(pVCpu))
3537 {
3538 /* Disable drx move intercepts. */
3539 pVCpu->hwaccm.s.vmx.proc_ctls &= ~VMX_VMCS_CTRL_PROC_EXEC_CONTROLS_MOV_DR_EXIT;
3540 rc = VMXWriteVMCS(VMX_VMCS_CTRL_PROC_EXEC_CONTROLS, pVCpu->hwaccm.s.vmx.proc_ctls);
3541 AssertRC(rc);
3542
3543 /* Save the host and load the guest debug state. */
3544 rc = CPUMR0LoadGuestDebugState(pVM, pVCpu, pCtx, true /* include DR6 */);
3545 AssertRC(rc);
3546
3547#ifdef VBOX_WITH_STATISTICS
3548 STAM_COUNTER_INC(&pVCpu->hwaccm.s.StatDRxContextSwitch);
3549 if (VMX_EXIT_QUALIFICATION_DRX_DIRECTION(exitQualification) == VMX_EXIT_QUALIFICATION_DRX_DIRECTION_WRITE)
3550 STAM_COUNTER_INC(&pVCpu->hwaccm.s.StatExitDRxWrite);
3551 else
3552 STAM_COUNTER_INC(&pVCpu->hwaccm.s.StatExitDRxRead);
3553#endif
3554
3555 goto ResumeExecution;
3556 }
3557
3558 /** @todo clear VMX_VMCS_CTRL_PROC_EXEC_CONTROLS_MOV_DR_EXIT after the first time and restore drx registers afterwards */
3559 if (VMX_EXIT_QUALIFICATION_DRX_DIRECTION(exitQualification) == VMX_EXIT_QUALIFICATION_DRX_DIRECTION_WRITE)
3560 {
3561 Log2(("VMX: mov drx%d, genreg%d\n", VMX_EXIT_QUALIFICATION_DRX_REGISTER(exitQualification), VMX_EXIT_QUALIFICATION_DRX_GENREG(exitQualification)));
3562 STAM_COUNTER_INC(&pVCpu->hwaccm.s.StatExitDRxWrite);
3563 rc = EMInterpretDRxWrite(pVM, pVCpu, CPUMCTX2CORE(pCtx),
3564 VMX_EXIT_QUALIFICATION_DRX_REGISTER(exitQualification),
3565 VMX_EXIT_QUALIFICATION_DRX_GENREG(exitQualification));
3566 pVCpu->hwaccm.s.fContextUseFlags |= HWACCM_CHANGED_GUEST_DEBUG;
3567 Log2(("DR7=%08x\n", pCtx->dr[7]));
3568 }
3569 else
3570 {
3571 Log2(("VMX: mov x, drx\n"));
3572 STAM_COUNTER_INC(&pVCpu->hwaccm.s.StatExitDRxRead);
3573 rc = EMInterpretDRxRead(pVM, pVCpu, CPUMCTX2CORE(pCtx),
3574 VMX_EXIT_QUALIFICATION_DRX_GENREG(exitQualification),
3575 VMX_EXIT_QUALIFICATION_DRX_REGISTER(exitQualification));
3576 }
3577 /* Update EIP if no error occurred. */
3578 if (RT_SUCCESS(rc))
3579 pCtx->rip += cbInstr;
3580
3581 if (rc == VINF_SUCCESS)
3582 {
3583 /* Only resume if successful. */
3584 goto ResumeExecution;
3585 }
3586 Assert(rc == VERR_EM_INTERPRETER);
3587 break;
3588 }
3589
3590 /* Note: We'll get a #GP if the IO instruction isn't allowed (IOPL or TSS bitmap); no need to double check. */
3591 case VMX_EXIT_PORT_IO: /* 30 I/O instruction. */
3592 {
3593 STAM_PROFILE_ADV_START(&pVCpu->hwaccm.s.StatExit2Sub1, y1);
3594 uint32_t uIOWidth = VMX_EXIT_QUALIFICATION_IO_WIDTH(exitQualification);
3595 uint32_t uPort;
3596 bool fIOWrite = (VMX_EXIT_QUALIFICATION_IO_DIRECTION(exitQualification) == VMX_EXIT_QUALIFICATION_IO_DIRECTION_OUT);
3597
3598 /** @todo necessary to make the distinction? */
3599 if (VMX_EXIT_QUALIFICATION_IO_ENCODING(exitQualification) == VMX_EXIT_QUALIFICATION_IO_ENCODING_DX)
3600 {
3601 uPort = pCtx->edx & 0xffff;
3602 }
3603 else
3604 uPort = VMX_EXIT_QUALIFICATION_IO_PORT(exitQualification); /* Immediate encoding. */
3605
3606 /* paranoia */
3607 if (RT_UNLIKELY(uIOWidth == 2 || uIOWidth >= 4))
3608 {
3609 rc = fIOWrite ? VINF_IOM_HC_IOPORT_WRITE : VINF_IOM_HC_IOPORT_READ;
3610 STAM_PROFILE_ADV_STOP(&pVCpu->hwaccm.s.StatExit2Sub1, y1);
3611 break;
3612 }
3613
3614 uint32_t cbSize = g_aIOSize[uIOWidth];
3615
3616 if (VMX_EXIT_QUALIFICATION_IO_STRING(exitQualification))
3617 {
3618 /* ins/outs */
3619 PDISCPUSTATE pDis = &pVCpu->hwaccm.s.DisState;
3620
3621 /* Disassemble manually to deal with segment prefixes. */
3622 /** @todo VMX_VMCS_EXIT_GUEST_LINEAR_ADDR contains the flat pointer operand of the instruction. */
3623 /** @todo VMX_VMCS32_RO_EXIT_INSTR_INFO also contains segment prefix info. */
3624 rc = EMInterpretDisasOne(pVM, pVCpu, CPUMCTX2CORE(pCtx), pDis, NULL);
3625 if (rc == VINF_SUCCESS)
3626 {
3627 if (fIOWrite)
3628 {
3629 Log2(("IOMInterpretOUTSEx %RGv %x size=%d\n", (RTGCPTR)pCtx->rip, uPort, cbSize));
3630 STAM_COUNTER_INC(&pVCpu->hwaccm.s.StatExitIOStringWrite);
3631 rc = IOMInterpretOUTSEx(pVM, CPUMCTX2CORE(pCtx), uPort, pDis->prefix, cbSize);
3632 }
3633 else
3634 {
3635 Log2(("IOMInterpretINSEx %RGv %x size=%d\n", (RTGCPTR)pCtx->rip, uPort, cbSize));
3636 STAM_COUNTER_INC(&pVCpu->hwaccm.s.StatExitIOStringRead);
3637 rc = IOMInterpretINSEx(pVM, CPUMCTX2CORE(pCtx), uPort, pDis->prefix, cbSize);
3638 }
3639 }
3640 else
3641 rc = VINF_EM_RAW_EMULATE_INSTR;
3642 }
3643 else
3644 {
3645 /* normal in/out */
3646 uint32_t uAndVal = g_aIOOpAnd[uIOWidth];
3647
3648 Assert(!VMX_EXIT_QUALIFICATION_IO_REP(exitQualification));
3649
3650 if (fIOWrite)
3651 {
3652 STAM_COUNTER_INC(&pVCpu->hwaccm.s.StatExitIOWrite);
3653 rc = IOMIOPortWrite(pVM, uPort, pCtx->eax & uAndVal, cbSize);
3654 if (rc == VINF_IOM_HC_IOPORT_WRITE)
3655 HWACCMR0SavePendingIOPortWrite(pVCpu, pCtx->rip, pCtx->rip + cbInstr, uPort, uAndVal, cbSize);
3656 }
3657 else
3658 {
3659 uint32_t u32Val = 0;
3660
3661 STAM_COUNTER_INC(&pVCpu->hwaccm.s.StatExitIORead);
3662 rc = IOMIOPortRead(pVM, uPort, &u32Val, cbSize);
3663 if (IOM_SUCCESS(rc))
3664 {
3665 /* Write back to the EAX register. */
3666 pCtx->eax = (pCtx->eax & ~uAndVal) | (u32Val & uAndVal);
3667 }
3668 else
3669 if (rc == VINF_IOM_HC_IOPORT_READ)
3670 HWACCMR0SavePendingIOPortRead(pVCpu, pCtx->rip, pCtx->rip + cbInstr, uPort, uAndVal, cbSize);
3671 }
3672 }
3673 /*
3674 * Handled the I/O return codes.
3675 * (The unhandled cases end up with rc == VINF_EM_RAW_EMULATE_INSTR.)
3676 */
3677 if (IOM_SUCCESS(rc))
3678 {
3679 /* Update EIP and continue execution. */
3680 pCtx->rip += cbInstr;
3681 if (RT_LIKELY(rc == VINF_SUCCESS))
3682 {
3683 /* If any IO breakpoints are armed, then we should check if a debug trap needs to be generated. */
3684 if (pCtx->dr[7] & X86_DR7_ENABLED_MASK)
3685 {
3686 STAM_COUNTER_INC(&pVCpu->hwaccm.s.StatDRxIOCheck);
3687 for (unsigned i=0;i<4;i++)
3688 {
3689 unsigned uBPLen = g_aIOSize[X86_DR7_GET_LEN(pCtx->dr[7], i)];
3690
3691 if ( (uPort >= pCtx->dr[i] && uPort < pCtx->dr[i] + uBPLen)
3692 && (pCtx->dr[7] & (X86_DR7_L(i) | X86_DR7_G(i)))
3693 && (pCtx->dr[7] & X86_DR7_RW(i, X86_DR7_RW_IO)) == X86_DR7_RW(i, X86_DR7_RW_IO))
3694 {
3695 uint64_t uDR6;
3696
3697 Assert(CPUMIsGuestDebugStateActive(pVCpu));
3698
3699 uDR6 = ASMGetDR6();
3700
3701 /* Clear all breakpoint status flags and set the one we just hit. */
3702 uDR6 &= ~(X86_DR6_B0|X86_DR6_B1|X86_DR6_B2|X86_DR6_B3);
3703 uDR6 |= (uint64_t)RT_BIT(i);
3704
3705 /* Note: AMD64 Architecture Programmer's Manual 13.1:
3706 * Bits 15:13 of the DR6 register is never cleared by the processor and must be cleared by software after
3707 * the contents have been read.
3708 */
3709 ASMSetDR6(uDR6);
3710
3711 /* X86_DR7_GD will be cleared if drx accesses should be trapped inside the guest. */
3712 pCtx->dr[7] &= ~X86_DR7_GD;
3713
3714 /* Paranoia. */
3715 pCtx->dr[7] &= 0xffffffff; /* upper 32 bits reserved */
3716 pCtx->dr[7] &= ~(RT_BIT(11) | RT_BIT(12) | RT_BIT(14) | RT_BIT(15)); /* must be zero */
3717 pCtx->dr[7] |= 0x400; /* must be one */
3718
3719 /* Resync DR7 */
3720 rc = VMXWriteVMCS64(VMX_VMCS64_GUEST_DR7, pCtx->dr[7]);
3721 AssertRC(rc);
3722
3723 /* Construct inject info. */
3724 intInfo = X86_XCPT_DB;
3725 intInfo |= (1 << VMX_EXIT_INTERRUPTION_INFO_VALID_SHIFT);
3726 intInfo |= (VMX_EXIT_INTERRUPTION_INFO_TYPE_HWEXCPT << VMX_EXIT_INTERRUPTION_INFO_TYPE_SHIFT);
3727
3728 Log(("Inject IO debug trap at %RGv\n", (RTGCPTR)pCtx->rip));
3729 rc = VMXR0InjectEvent(pVM, pVCpu, pCtx, VMX_VMCS_CTRL_ENTRY_IRQ_INFO_FROM_EXIT_INT_INFO(intInfo), 0, 0);
3730 AssertRC(rc);
3731
3732 STAM_PROFILE_ADV_STOP(&pVCpu->hwaccm.s.StatExit2Sub1, y1);
3733 goto ResumeExecution;
3734 }
3735 }
3736 }
3737
3738 STAM_PROFILE_ADV_STOP(&pVCpu->hwaccm.s.StatExit2Sub1, y1);
3739 goto ResumeExecution;
3740 }
3741 STAM_PROFILE_ADV_STOP(&pVCpu->hwaccm.s.StatExit2Sub1, y1);
3742 break;
3743 }
3744
3745#ifdef VBOX_STRICT
3746 if (rc == VINF_IOM_HC_IOPORT_READ)
3747 Assert(!fIOWrite);
3748 else if (rc == VINF_IOM_HC_IOPORT_WRITE)
3749 Assert(fIOWrite);
3750 else
3751 AssertMsg(RT_FAILURE(rc) || rc == VINF_EM_RAW_EMULATE_INSTR || rc == VINF_EM_RAW_GUEST_TRAP || rc == VINF_TRPM_XCPT_DISPATCHED, ("%Rrc\n", rc));
3752#endif
3753 STAM_PROFILE_ADV_STOP(&pVCpu->hwaccm.s.StatExit2Sub1, y1);
3754 break;
3755 }
3756
3757 case VMX_EXIT_TPR: /* 43 TPR below threshold. Guest software executed MOV to CR8. */
3758 LogFlow(("VMX_EXIT_TPR\n"));
3759 /* RIP is already set to the next instruction and the TPR has been synced back. Just resume. */
3760 STAM_PROFILE_ADV_STOP(&pVCpu->hwaccm.s.StatExit2Sub1, y1);
3761 goto ResumeExecution;
3762
3763 case VMX_EXIT_APIC_ACCESS: /* 44 APIC access. Guest software attempted to access memory at a physical address on the APIC-access page. */
3764 {
3765 LogFlow(("VMX_EXIT_APIC_ACCESS\n"));
3766 unsigned uAccessType = VMX_EXIT_QUALIFICATION_APIC_ACCESS_TYPE(exitQualification);
3767
3768 switch(uAccessType)
3769 {
3770 case VMX_APIC_ACCESS_TYPE_LINEAR_READ:
3771 case VMX_APIC_ACCESS_TYPE_LINEAR_WRITE:
3772 {
3773 RTGCPHYS GCPhys;
3774 PDMApicGetBase(pVM, &GCPhys);
3775 GCPhys &= PAGE_BASE_GC_MASK;
3776 GCPhys += VMX_EXIT_QUALIFICATION_APIC_ACCESS_OFFSET(exitQualification);
3777
3778 LogFlow(("Apic access at %RGp\n", GCPhys));
3779 rc = IOMMMIOPhysHandler(pVM, (uAccessType == VMX_APIC_ACCESS_TYPE_LINEAR_READ) ? 0 : X86_TRAP_PF_RW, CPUMCTX2CORE(pCtx), GCPhys);
3780 if (rc == VINF_SUCCESS)
3781 {
3782 STAM_PROFILE_ADV_STOP(&pVCpu->hwaccm.s.StatExit2Sub1, y1);
3783 goto ResumeExecution; /* rip already updated */
3784 }
3785 break;
3786 }
3787
3788 default:
3789 rc = VINF_EM_RAW_EMULATE_INSTR;
3790 break;
3791 }
3792 break;
3793 }
3794
3795 case VMX_EXIT_PREEMPTION_TIMER: /* 52 VMX-preemption timer expired. The preemption timer counted down to zero. */
3796 STAM_PROFILE_ADV_STOP(&pVCpu->hwaccm.s.StatExit2Sub1, y1);
3797 goto ResumeExecution;
3798
3799 default:
3800 /* The rest is handled after syncing the entire CPU state. */
3801 break;
3802 }
3803
3804 /* Note: the guest state isn't entirely synced back at this stage. */
3805
3806 /* Investigate why there was a VM-exit. (part 2) */
3807 switch (exitReason)
3808 {
3809 case VMX_EXIT_EXCEPTION: /* 0 Exception or non-maskable interrupt (NMI). */
3810 case VMX_EXIT_EXTERNAL_IRQ: /* 1 External interrupt. */
3811 case VMX_EXIT_EPT_VIOLATION:
3812 case VMX_EXIT_PREEMPTION_TIMER: /* 52 VMX-preemption timer expired. The preemption timer counted down to zero. */
3813 /* Already handled above. */
3814 break;
3815
3816 case VMX_EXIT_TRIPLE_FAULT: /* 2 Triple fault. */
3817 rc = VINF_EM_RESET; /* Triple fault equals a reset. */
3818 break;
3819
3820 case VMX_EXIT_INIT_SIGNAL: /* 3 INIT signal. */
3821 case VMX_EXIT_SIPI: /* 4 Start-up IPI (SIPI). */
3822 rc = VINF_EM_RAW_INTERRUPT;
3823 AssertFailed(); /* Can't happen. Yet. */
3824 break;
3825
3826 case VMX_EXIT_IO_SMI_IRQ: /* 5 I/O system-management interrupt (SMI). */
3827 case VMX_EXIT_SMI_IRQ: /* 6 Other SMI. */
3828 rc = VINF_EM_RAW_INTERRUPT;
3829 AssertFailed(); /* Can't happen afaik. */
3830 break;
3831
3832 case VMX_EXIT_TASK_SWITCH: /* 9 Task switch. */
3833 rc = VERR_EM_INTERPRETER;
3834 break;
3835
3836 case VMX_EXIT_HLT: /* 12 Guest software attempted to execute HLT. */
3837 /** Check if external interrupts are pending; if so, don't switch back. */
3838 STAM_COUNTER_INC(&pVCpu->hwaccm.s.StatExitHlt);
3839 pCtx->rip++; /* skip hlt */
3840 if ( pCtx->eflags.Bits.u1IF
3841 && VMCPU_FF_ISPENDING(pVCpu, (VMCPU_FF_INTERRUPT_APIC|VMCPU_FF_INTERRUPT_PIC)))
3842 goto ResumeExecution;
3843
3844 rc = VINF_EM_HALT;
3845 break;
3846
3847 case VMX_EXIT_MWAIT: /* 36 Guest software executed MWAIT. */
3848 Log2(("VMX: mwait\n"));
3849 STAM_COUNTER_INC(&pVCpu->hwaccm.s.StatExitMwait);
3850 rc = EMInterpretMWait(pVM, pVCpu, CPUMCTX2CORE(pCtx));
3851 if ( rc == VINF_EM_HALT
3852 || rc == VINF_SUCCESS)
3853 {
3854 /* Update EIP and continue execution. */
3855 pCtx->rip += cbInstr;
3856
3857 /** Check if external interrupts are pending; if so, don't switch back. */
3858 if ( rc == VINF_SUCCESS
3859 || ( rc == VINF_EM_HALT
3860 && pCtx->eflags.Bits.u1IF
3861 && VMCPU_FF_ISPENDING(pVCpu, (VMCPU_FF_INTERRUPT_APIC|VMCPU_FF_INTERRUPT_PIC)))
3862 )
3863 goto ResumeExecution;
3864 }
3865 AssertMsg(rc == VERR_EM_INTERPRETER || rc == VINF_EM_HALT, ("EMU: mwait failed with %Rrc\n", rc));
3866 break;
3867
3868 case VMX_EXIT_RSM: /* 17 Guest software attempted to execute RSM in SMM. */
3869 AssertFailed(); /* can't happen. */
3870 rc = VERR_EM_INTERPRETER;
3871 break;
3872
3873 case VMX_EXIT_VMCALL: /* 18 Guest software executed VMCALL. */
3874 case VMX_EXIT_VMCLEAR: /* 19 Guest software executed VMCLEAR. */
3875 case VMX_EXIT_VMLAUNCH: /* 20 Guest software executed VMLAUNCH. */
3876 case VMX_EXIT_VMPTRLD: /* 21 Guest software executed VMPTRLD. */
3877 case VMX_EXIT_VMPTRST: /* 22 Guest software executed VMPTRST. */
3878 case VMX_EXIT_VMREAD: /* 23 Guest software executed VMREAD. */
3879 case VMX_EXIT_VMRESUME: /* 24 Guest software executed VMRESUME. */
3880 case VMX_EXIT_VMWRITE: /* 25 Guest software executed VMWRITE. */
3881 case VMX_EXIT_VMXOFF: /* 26 Guest software executed VMXOFF. */
3882 case VMX_EXIT_VMXON: /* 27 Guest software executed VMXON. */
3883 /** @todo inject #UD immediately */
3884 rc = VERR_EM_INTERPRETER;
3885 break;
3886
3887 case VMX_EXIT_CPUID: /* 10 Guest software attempted to execute CPUID. */
3888 case VMX_EXIT_RDTSC: /* 16 Guest software attempted to execute RDTSC. */
3889 case VMX_EXIT_INVPG: /* 14 Guest software attempted to execute INVPG. */
3890 case VMX_EXIT_CRX_MOVE: /* 28 Control-register accesses. */
3891 case VMX_EXIT_DRX_MOVE: /* 29 Debug-register accesses. */
3892 case VMX_EXIT_PORT_IO: /* 30 I/O instruction. */
3893 case VMX_EXIT_RDPMC: /* 15 Guest software attempted to execute RDPMC. */
3894 /* already handled above */
3895 AssertMsg( rc == VINF_PGM_CHANGE_MODE
3896 || rc == VINF_EM_RAW_INTERRUPT
3897 || rc == VERR_EM_INTERPRETER
3898 || rc == VINF_EM_RAW_EMULATE_INSTR
3899 || rc == VINF_PGM_SYNC_CR3
3900 || rc == VINF_IOM_HC_IOPORT_READ
3901 || rc == VINF_IOM_HC_IOPORT_WRITE
3902 || rc == VINF_EM_RAW_GUEST_TRAP
3903 || rc == VINF_TRPM_XCPT_DISPATCHED
3904 || rc == VINF_EM_RESCHEDULE_REM,
3905 ("rc = %d\n", rc));
3906 break;
3907
3908 case VMX_EXIT_TPR: /* 43 TPR below threshold. Guest software executed MOV to CR8. */
3909 case VMX_EXIT_APIC_ACCESS: /* 44 APIC access. Guest software attempted to access memory at a physical address on the APIC-access page. */
3910 case VMX_EXIT_RDMSR: /* 31 RDMSR. Guest software attempted to execute RDMSR. */
3911 case VMX_EXIT_WRMSR: /* 32 WRMSR. Guest software attempted to execute WRMSR. */
3912 case VMX_EXIT_MONITOR: /* 39 Guest software attempted to execute MONITOR. */
3913 case VMX_EXIT_PAUSE: /* 40 Guest software attempted to execute PAUSE. */
3914 /* Note: If we decide to emulate them here, then we must sync the MSRs that could have been changed (sysenter, fs/gs base)!!! */
3915 rc = VERR_EM_INTERPRETER;
3916 break;
3917
3918 case VMX_EXIT_IRQ_WINDOW: /* 7 Interrupt window. */
3919 Assert(rc == VINF_EM_RAW_INTERRUPT);
3920 break;
3921
3922 case VMX_EXIT_ERR_INVALID_GUEST_STATE: /* 33 VM-entry failure due to invalid guest state. */
3923 {
3924#ifdef VBOX_STRICT
3925 RTCCUINTREG val = 0;
3926
3927 Log(("VMX_EXIT_ERR_INVALID_GUEST_STATE\n"));
3928
3929 VMXReadVMCS(VMX_VMCS64_GUEST_RIP, &val);
3930 Log(("Old eip %RGv new %RGv\n", (RTGCPTR)pCtx->rip, (RTGCPTR)val));
3931
3932 VMXReadVMCS(VMX_VMCS64_GUEST_CR0, &val);
3933 Log(("VMX_VMCS_GUEST_CR0 %RX64\n", (uint64_t)val));
3934
3935 VMXReadVMCS(VMX_VMCS64_GUEST_CR3, &val);
3936 Log(("VMX_VMCS_GUEST_CR3 %RX64\n", (uint64_t)val));
3937
3938 VMXReadVMCS(VMX_VMCS64_GUEST_CR4, &val);
3939 Log(("VMX_VMCS_GUEST_CR4 %RX64\n", (uint64_t)val));
3940
3941 VMXReadVMCS(VMX_VMCS_GUEST_RFLAGS, &val);
3942 Log(("VMX_VMCS_GUEST_RFLAGS %08x\n", val));
3943
3944 VMX_LOG_SELREG(CS, "CS");
3945 VMX_LOG_SELREG(DS, "DS");
3946 VMX_LOG_SELREG(ES, "ES");
3947 VMX_LOG_SELREG(FS, "FS");
3948 VMX_LOG_SELREG(GS, "GS");
3949 VMX_LOG_SELREG(SS, "SS");
3950 VMX_LOG_SELREG(TR, "TR");
3951 VMX_LOG_SELREG(LDTR, "LDTR");
3952
3953 VMXReadVMCS(VMX_VMCS64_GUEST_GDTR_BASE, &val);
3954 Log(("VMX_VMCS_GUEST_GDTR_BASE %RX64\n", (uint64_t)val));
3955 VMXReadVMCS(VMX_VMCS64_GUEST_IDTR_BASE, &val);
3956 Log(("VMX_VMCS_GUEST_IDTR_BASE %RX64\n", (uint64_t)val));
3957#endif /* VBOX_STRICT */
3958 rc = VERR_VMX_INVALID_GUEST_STATE;
3959 break;
3960 }
3961
3962 case VMX_EXIT_ERR_MSR_LOAD: /* 34 VM-entry failure due to MSR loading. */
3963 case VMX_EXIT_ERR_MACHINE_CHECK: /* 41 VM-entry failure due to machine-check. */
3964 default:
3965 rc = VERR_VMX_UNEXPECTED_EXIT_CODE;
3966 AssertMsgFailed(("Unexpected exit code %d\n", exitReason)); /* Can't happen. */
3967 break;
3968
3969 }
3970end:
3971
3972 /* Signal changes for the recompiler. */
3973 CPUMSetChangedFlags(pVCpu, CPUM_CHANGED_SYSENTER_MSR | CPUM_CHANGED_LDTR | CPUM_CHANGED_GDTR | CPUM_CHANGED_IDTR | CPUM_CHANGED_TR | CPUM_CHANGED_HIDDEN_SEL_REGS);
3974
3975 /* If we executed vmlaunch/vmresume and an external irq was pending, then we don't have to do a full sync the next time. */
3976 if ( exitReason == VMX_EXIT_EXTERNAL_IRQ
3977 && !VMX_EXIT_INTERRUPTION_INFO_VALID(intInfo))
3978 {
3979 STAM_COUNTER_INC(&pVCpu->hwaccm.s.StatPendingHostIrq);
3980 /* On the next entry we'll only sync the host context. */
3981 pVCpu->hwaccm.s.fContextUseFlags |= HWACCM_CHANGED_HOST_CONTEXT;
3982 }
3983 else
3984 {
3985 /* On the next entry we'll sync everything. */
3986 /** @todo we can do better than this */
3987 /* Not in the VINF_PGM_CHANGE_MODE though! */
3988 pVCpu->hwaccm.s.fContextUseFlags |= HWACCM_CHANGED_ALL;
3989 }
3990
3991 /* translate into a less severe return code */
3992 if (rc == VERR_EM_INTERPRETER)
3993 rc = VINF_EM_RAW_EMULATE_INSTR;
3994 else
3995 /* Try to extract more information about what might have gone wrong here. */
3996 if (rc == VERR_VMX_INVALID_VMCS_PTR)
3997 {
3998 VMXGetActivateVMCS(&pVCpu->hwaccm.s.vmx.lasterror.u64VMCSPhys);
3999 pVCpu->hwaccm.s.vmx.lasterror.ulVMCSRevision = *(uint32_t *)pVCpu->hwaccm.s.vmx.pVMCS;
4000 pVCpu->hwaccm.s.vmx.lasterror.idEnteredCpu = pVCpu->hwaccm.s.idEnteredCpu;
4001 pVCpu->hwaccm.s.vmx.lasterror.idCurrentCpu = RTMpCpuId();
4002 }
4003
4004 /* Just set the correct state here instead of trying to catch every goto above. */
4005 VMCPU_CMPXCHG_STATE(pVCpu, VMCPUSTATE_STARTED, VMCPUSTATE_STARTED_EXEC);
4006
4007#ifdef VBOX_WITH_VMMR0_DISABLE_PREEMPTION
4008 /* Restore interrupts if we exitted after disabling them. */
4009 if (uOldEFlags != ~(RTCCUINTREG)0)
4010 ASMSetFlags(uOldEFlags);
4011#endif
4012
4013 STAM_STATS({
4014 if (fStatExit2Started) STAM_PROFILE_ADV_STOP(&pVCpu->hwaccm.s.StatExit2, y);
4015 else if (fStatEntryStarted) STAM_PROFILE_ADV_STOP(&pVCpu->hwaccm.s.StatEntry, x);
4016 });
4017 Log2(("X"));
4018 return rc;
4019}
4020
4021
4022/**
4023 * Enters the VT-x session
4024 *
4025 * @returns VBox status code.
4026 * @param pVM The VM to operate on.
4027 * @param pVCpu The VMCPU to operate on.
4028 * @param pCpu CPU info struct
4029 */
4030VMMR0DECL(int) VMXR0Enter(PVM pVM, PVMCPU pVCpu, PHWACCM_CPUINFO pCpu)
4031{
4032 Assert(pVM->hwaccm.s.vmx.fSupported);
4033
4034 unsigned cr4 = ASMGetCR4();
4035 if (!(cr4 & X86_CR4_VMXE))
4036 {
4037 AssertMsgFailed(("X86_CR4_VMXE should be set!\n"));
4038 return VERR_VMX_X86_CR4_VMXE_CLEARED;
4039 }
4040
4041 /* Activate the VM Control Structure. */
4042 int rc = VMXActivateVMCS(pVCpu->hwaccm.s.vmx.pVMCSPhys);
4043 if (RT_FAILURE(rc))
4044 return rc;
4045
4046 pVCpu->hwaccm.s.fResumeVM = false;
4047 return VINF_SUCCESS;
4048}
4049
4050
4051/**
4052 * Leaves the VT-x session
4053 *
4054 * @returns VBox status code.
4055 * @param pVM The VM to operate on.
4056 * @param pVCpu The VMCPU to operate on.
4057 * @param pCtx CPU context
4058 */
4059VMMR0DECL(int) VMXR0Leave(PVM pVM, PVMCPU pVCpu, PCPUMCTX pCtx)
4060{
4061 Assert(pVM->hwaccm.s.vmx.fSupported);
4062
4063#ifdef DEBUG
4064 if (CPUMIsHyperDebugStateActive(pVCpu))
4065 {
4066 CPUMR0LoadHostDebugState(pVM, pVCpu);
4067 }
4068 else
4069#endif
4070 /* Save the guest debug state if necessary. */
4071 if (CPUMIsGuestDebugStateActive(pVCpu))
4072 {
4073 CPUMR0SaveGuestDebugState(pVM, pVCpu, pCtx, true /* save DR6 */);
4074
4075 /* Enable drx move intercepts again. */
4076 pVCpu->hwaccm.s.vmx.proc_ctls |= VMX_VMCS_CTRL_PROC_EXEC_CONTROLS_MOV_DR_EXIT;
4077 int rc = VMXWriteVMCS(VMX_VMCS_CTRL_PROC_EXEC_CONTROLS, pVCpu->hwaccm.s.vmx.proc_ctls);
4078 AssertRC(rc);
4079
4080 /* Resync the debug registers the next time. */
4081 pVCpu->hwaccm.s.fContextUseFlags |= HWACCM_CHANGED_GUEST_DEBUG;
4082 }
4083 else
4084 Assert(pVCpu->hwaccm.s.vmx.proc_ctls & VMX_VMCS_CTRL_PROC_EXEC_CONTROLS_MOV_DR_EXIT);
4085
4086 /* Clear VM Control Structure. Marking it inactive, clearing implementation specific data and writing back VMCS data to memory. */
4087 int rc = VMXClearVMCS(pVCpu->hwaccm.s.vmx.pVMCSPhys);
4088 AssertRC(rc);
4089
4090 return VINF_SUCCESS;
4091}
4092
4093/**
4094 * Flush the TLB (EPT)
4095 *
4096 * @returns VBox status code.
4097 * @param pVM The VM to operate on.
4098 * @param pVCpu The VM CPU to operate on.
4099 * @param enmFlush Type of flush
4100 * @param GCPhys Physical address of the page to flush
4101 */
4102static void vmxR0FlushEPT(PVM pVM, PVMCPU pVCpu, VMX_FLUSH enmFlush, RTGCPHYS GCPhys)
4103{
4104 uint64_t descriptor[2];
4105
4106 LogFlow(("vmxR0FlushEPT %d %RGv\n", enmFlush, GCPhys));
4107 Assert(pVM->hwaccm.s.fNestedPaging);
4108 descriptor[0] = pVCpu->hwaccm.s.vmx.GCPhysEPTP;
4109 descriptor[1] = GCPhys;
4110 int rc = VMXR0InvEPT(enmFlush, &descriptor[0]);
4111 AssertRC(rc);
4112}
4113
4114#ifdef HWACCM_VTX_WITH_VPID
4115/**
4116 * Flush the TLB (EPT)
4117 *
4118 * @returns VBox status code.
4119 * @param pVM The VM to operate on.
4120 * @param pVCpu The VM CPU to operate on.
4121 * @param enmFlush Type of flush
4122 * @param GCPtr Virtual address of the page to flush
4123 */
4124static void vmxR0FlushVPID(PVM pVM, PVMCPU pVCpu, VMX_FLUSH enmFlush, RTGCPTR GCPtr)
4125{
4126#if HC_ARCH_BITS == 32
4127 /* If we get a flush in 64 bits guest mode, then force a full TLB flush. Invvpid probably takes only 32 bits addresses. (@todo) */
4128 if ( CPUMIsGuestInLongMode(pVCpu)
4129 && !VMX_IS_64BIT_HOST_MODE())
4130 {
4131 VMCPU_FF_SET(pVCpu, VMCPU_FF_TLB_FLUSH);
4132 }
4133 else
4134#endif
4135 {
4136 uint64_t descriptor[2];
4137
4138 Assert(pVM->hwaccm.s.vmx.fVPID);
4139 descriptor[0] = pVCpu->hwaccm.s.uCurrentASID;
4140 descriptor[1] = GCPtr;
4141 int rc = VMXR0InvVPID(enmFlush, &descriptor[0]);
4142 AssertRC(rc);
4143 }
4144}
4145#endif /* HWACCM_VTX_WITH_VPID */
4146
4147/**
4148 * Invalidates a guest page
4149 *
4150 * @returns VBox status code.
4151 * @param pVM The VM to operate on.
4152 * @param pVCpu The VM CPU to operate on.
4153 * @param GCVirt Page to invalidate
4154 */
4155VMMR0DECL(int) VMXR0InvalidatePage(PVM pVM, PVMCPU pVCpu, RTGCPTR GCVirt)
4156{
4157 bool fFlushPending = VMCPU_FF_ISSET(pVCpu, VMCPU_FF_TLB_FLUSH);
4158
4159 Log2(("VMXR0InvalidatePage %RGv\n", GCVirt));
4160
4161 /* Only relevant if we want to use VPID.
4162 * In the nested paging case we still see such calls, but
4163 * can safely ignore them. (e.g. after cr3 updates)
4164 */
4165#ifdef HWACCM_VTX_WITH_VPID
4166 /* Skip it if a TLB flush is already pending. */
4167 if ( !fFlushPending
4168 && pVM->hwaccm.s.vmx.fVPID)
4169 vmxR0FlushVPID(pVM, pVCpu, pVM->hwaccm.s.vmx.enmFlushPage, GCVirt);
4170#endif /* HWACCM_VTX_WITH_VPID */
4171
4172 return VINF_SUCCESS;
4173}
4174
4175/**
4176 * Invalidates a guest page by physical address
4177 *
4178 * NOTE: Assumes the current instruction references this physical page though a virtual address!!
4179 *
4180 * @returns VBox status code.
4181 * @param pVM The VM to operate on.
4182 * @param pVCpu The VM CPU to operate on.
4183 * @param GCPhys Page to invalidate
4184 */
4185VMMR0DECL(int) VMXR0InvalidatePhysPage(PVM pVM, PVMCPU pVCpu, RTGCPHYS GCPhys)
4186{
4187 bool fFlushPending = VMCPU_FF_ISSET(pVCpu, VMCPU_FF_TLB_FLUSH);
4188
4189 Assert(pVM->hwaccm.s.fNestedPaging);
4190
4191 LogFlow(("VMXR0InvalidatePhysPage %RGp\n", GCPhys));
4192
4193 /* Skip it if a TLB flush is already pending. */
4194 if (!fFlushPending)
4195 vmxR0FlushEPT(pVM, pVCpu, pVM->hwaccm.s.vmx.enmFlushPage, GCPhys);
4196
4197 return VINF_SUCCESS;
4198}
4199
4200/**
4201 * Report world switch error and dump some useful debug info
4202 *
4203 * @param pVM The VM to operate on.
4204 * @param pVCpu The VMCPU to operate on.
4205 * @param rc Return code
4206 * @param pCtx Current CPU context (not updated)
4207 */
4208static void VMXR0ReportWorldSwitchError(PVM pVM, PVMCPU pVCpu, int rc, PCPUMCTX pCtx)
4209{
4210 switch (rc)
4211 {
4212 case VERR_VMX_INVALID_VMXON_PTR:
4213 AssertFailed();
4214 break;
4215
4216 case VERR_VMX_UNABLE_TO_START_VM:
4217 case VERR_VMX_UNABLE_TO_RESUME_VM:
4218 {
4219 int rc;
4220 RTCCUINTREG exitReason, instrError;
4221
4222 rc = VMXReadVMCS(VMX_VMCS32_RO_EXIT_REASON, &exitReason);
4223 rc |= VMXReadVMCS(VMX_VMCS32_RO_VM_INSTR_ERROR, &instrError);
4224 AssertRC(rc);
4225 if (rc == VINF_SUCCESS)
4226 {
4227 Log(("Unable to start/resume VM for reason: %x. Instruction error %x\n", (uint32_t)exitReason, (uint32_t)instrError));
4228 Log(("Current stack %08x\n", &rc));
4229
4230 pVCpu->hwaccm.s.vmx.lasterror.ulInstrError = instrError;
4231 pVCpu->hwaccm.s.vmx.lasterror.ulExitReason = exitReason;
4232
4233#ifdef VBOX_STRICT
4234 RTGDTR gdtr;
4235 PX86DESCHC pDesc;
4236 RTCCUINTREG val;
4237
4238 ASMGetGDTR(&gdtr);
4239
4240 VMXReadVMCS(VMX_VMCS64_GUEST_RIP, &val);
4241 Log(("Old eip %RGv new %RGv\n", (RTGCPTR)pCtx->rip, (RTGCPTR)val));
4242 VMXReadVMCS(VMX_VMCS_CTRL_PIN_EXEC_CONTROLS, &val);
4243 Log(("VMX_VMCS_CTRL_PIN_EXEC_CONTROLS %08x\n", val));
4244 VMXReadVMCS(VMX_VMCS_CTRL_PROC_EXEC_CONTROLS, &val);
4245 Log(("VMX_VMCS_CTRL_PROC_EXEC_CONTROLS %08x\n", val));
4246 VMXReadVMCS(VMX_VMCS_CTRL_ENTRY_CONTROLS, &val);
4247 Log(("VMX_VMCS_CTRL_ENTRY_CONTROLS %08x\n", val));
4248 VMXReadVMCS(VMX_VMCS_CTRL_EXIT_CONTROLS, &val);
4249 Log(("VMX_VMCS_CTRL_EXIT_CONTROLS %08x\n", val));
4250
4251 VMXReadVMCS(VMX_VMCS_HOST_CR0, &val);
4252 Log(("VMX_VMCS_HOST_CR0 %08x\n", val));
4253
4254 VMXReadVMCS(VMX_VMCS_HOST_CR3, &val);
4255 Log(("VMX_VMCS_HOST_CR3 %08x\n", val));
4256
4257 VMXReadVMCS(VMX_VMCS_HOST_CR4, &val);
4258 Log(("VMX_VMCS_HOST_CR4 %08x\n", val));
4259
4260 VMXReadVMCS(VMX_VMCS16_HOST_FIELD_CS, &val);
4261 Log(("VMX_VMCS_HOST_FIELD_CS %08x\n", val));
4262
4263 VMXReadVMCS(VMX_VMCS_GUEST_RFLAGS, &val);
4264 Log(("VMX_VMCS_GUEST_RFLAGS %08x\n", val));
4265
4266 if (val < gdtr.cbGdt)
4267 {
4268 pDesc = &((PX86DESCHC)gdtr.pGdt)[val >> X86_SEL_SHIFT_HC];
4269 HWACCMR0DumpDescriptor(pDesc, val, "CS: ");
4270 }
4271
4272 VMXReadVMCS(VMX_VMCS16_HOST_FIELD_DS, &val);
4273 Log(("VMX_VMCS_HOST_FIELD_DS %08x\n", val));
4274 if (val < gdtr.cbGdt)
4275 {
4276 pDesc = &((PX86DESCHC)gdtr.pGdt)[val >> X86_SEL_SHIFT_HC];
4277 HWACCMR0DumpDescriptor(pDesc, val, "DS: ");
4278 }
4279
4280 VMXReadVMCS(VMX_VMCS16_HOST_FIELD_ES, &val);
4281 Log(("VMX_VMCS_HOST_FIELD_ES %08x\n", val));
4282 if (val < gdtr.cbGdt)
4283 {
4284 pDesc = &((PX86DESCHC)gdtr.pGdt)[val >> X86_SEL_SHIFT_HC];
4285 HWACCMR0DumpDescriptor(pDesc, val, "ES: ");
4286 }
4287
4288 VMXReadVMCS(VMX_VMCS16_HOST_FIELD_FS, &val);
4289 Log(("VMX_VMCS16_HOST_FIELD_FS %08x\n", val));
4290 if (val < gdtr.cbGdt)
4291 {
4292 pDesc = &((PX86DESCHC)gdtr.pGdt)[val >> X86_SEL_SHIFT_HC];
4293 HWACCMR0DumpDescriptor(pDesc, val, "FS: ");
4294 }
4295
4296 VMXReadVMCS(VMX_VMCS16_HOST_FIELD_GS, &val);
4297 Log(("VMX_VMCS16_HOST_FIELD_GS %08x\n", val));
4298 if (val < gdtr.cbGdt)
4299 {
4300 pDesc = &((PX86DESCHC)gdtr.pGdt)[val >> X86_SEL_SHIFT_HC];
4301 HWACCMR0DumpDescriptor(pDesc, val, "GS: ");
4302 }
4303
4304 VMXReadVMCS(VMX_VMCS16_HOST_FIELD_SS, &val);
4305 Log(("VMX_VMCS16_HOST_FIELD_SS %08x\n", val));
4306 if (val < gdtr.cbGdt)
4307 {
4308 pDesc = &((PX86DESCHC)gdtr.pGdt)[val >> X86_SEL_SHIFT_HC];
4309 HWACCMR0DumpDescriptor(pDesc, val, "SS: ");
4310 }
4311
4312 VMXReadVMCS(VMX_VMCS16_HOST_FIELD_TR, &val);
4313 Log(("VMX_VMCS16_HOST_FIELD_TR %08x\n", val));
4314 if (val < gdtr.cbGdt)
4315 {
4316 pDesc = &((PX86DESCHC)gdtr.pGdt)[val >> X86_SEL_SHIFT_HC];
4317 HWACCMR0DumpDescriptor(pDesc, val, "TR: ");
4318 }
4319
4320 VMXReadVMCS(VMX_VMCS_HOST_TR_BASE, &val);
4321 Log(("VMX_VMCS_HOST_TR_BASE %RHv\n", val));
4322
4323 VMXReadVMCS(VMX_VMCS_HOST_GDTR_BASE, &val);
4324 Log(("VMX_VMCS_HOST_GDTR_BASE %RHv\n", val));
4325 VMXReadVMCS(VMX_VMCS_HOST_IDTR_BASE, &val);
4326 Log(("VMX_VMCS_HOST_IDTR_BASE %RHv\n", val));
4327
4328 VMXReadVMCS(VMX_VMCS32_HOST_SYSENTER_CS, &val);
4329 Log(("VMX_VMCS_HOST_SYSENTER_CS %08x\n", val));
4330
4331 VMXReadVMCS(VMX_VMCS_HOST_SYSENTER_EIP, &val);
4332 Log(("VMX_VMCS_HOST_SYSENTER_EIP %RHv\n", val));
4333
4334 VMXReadVMCS(VMX_VMCS_HOST_SYSENTER_ESP, &val);
4335 Log(("VMX_VMCS_HOST_SYSENTER_ESP %RHv\n", val));
4336
4337 VMXReadVMCS(VMX_VMCS_HOST_RSP, &val);
4338 Log(("VMX_VMCS_HOST_RSP %RHv\n", val));
4339 VMXReadVMCS(VMX_VMCS_HOST_RIP, &val);
4340 Log(("VMX_VMCS_HOST_RIP %RHv\n", val));
4341
4342# if HC_ARCH_BITS == 64 || defined(VBOX_WITH_HYBRID_32BIT_KERNEL)
4343 if (VMX_IS_64BIT_HOST_MODE())
4344 {
4345 Log(("MSR_K6_EFER = %RX64\n", ASMRdMsr(MSR_K6_EFER)));
4346 Log(("MSR_K6_STAR = %RX64\n", ASMRdMsr(MSR_K6_STAR)));
4347 Log(("MSR_K8_LSTAR = %RX64\n", ASMRdMsr(MSR_K8_LSTAR)));
4348 Log(("MSR_K8_CSTAR = %RX64\n", ASMRdMsr(MSR_K8_CSTAR)));
4349 Log(("MSR_K8_SF_MASK = %RX64\n", ASMRdMsr(MSR_K8_SF_MASK)));
4350 }
4351# endif
4352#endif /* VBOX_STRICT */
4353 }
4354 break;
4355 }
4356
4357 default:
4358 /* impossible */
4359 AssertMsgFailed(("%Rrc (%#x)\n", rc, rc));
4360 break;
4361 }
4362}
4363
4364#if HC_ARCH_BITS == 32 && defined(VBOX_ENABLE_64_BITS_GUESTS) && !defined(VBOX_WITH_HYBRID_32BIT_KERNEL)
4365/**
4366 * Prepares for and executes VMLAUNCH (64 bits guest mode)
4367 *
4368 * @returns VBox status code
4369 * @param fResume vmlauch/vmresume
4370 * @param pCtx Guest context
4371 * @param pCache VMCS cache
4372 * @param pVM The VM to operate on.
4373 * @param pVCpu The VMCPU to operate on.
4374 */
4375DECLASM(int) VMXR0SwitcherStartVM64(RTHCUINT fResume, PCPUMCTX pCtx, PVMCSCACHE pCache, PVM pVM, PVMCPU pVCpu)
4376{
4377 uint32_t aParam[6];
4378 PHWACCM_CPUINFO pCpu;
4379 RTHCPHYS pPageCpuPhys;
4380 int rc;
4381
4382 pCpu = HWACCMR0GetCurrentCpu();
4383 pPageCpuPhys = RTR0MemObjGetPagePhysAddr(pCpu->pMemObj, 0);
4384
4385#ifdef VBOX_WITH_CRASHDUMP_MAGIC
4386 pCache->uPos = 1;
4387 pCache->interPD = PGMGetInterPaeCR3(pVM);
4388 pCache->pSwitcher = (uint64_t)pVM->hwaccm.s.pfnHost32ToGuest64R0;
4389#endif
4390
4391#ifdef DEBUG
4392 pCache->TestIn.pPageCpuPhys = 0;
4393 pCache->TestIn.pVMCSPhys = 0;
4394 pCache->TestIn.pCache = 0;
4395 pCache->TestOut.pVMCSPhys = 0;
4396 pCache->TestOut.pCache = 0;
4397 pCache->TestOut.pCtx = 0;
4398 pCache->TestOut.eflags = 0;
4399#endif
4400
4401 aParam[0] = (uint32_t)(pPageCpuPhys); /* Param 1: VMXON physical address - Lo. */
4402 aParam[1] = (uint32_t)(pPageCpuPhys >> 32); /* Param 1: VMXON physical address - Hi. */
4403 aParam[2] = (uint32_t)(pVCpu->hwaccm.s.vmx.pVMCSPhys); /* Param 2: VMCS physical address - Lo. */
4404 aParam[3] = (uint32_t)(pVCpu->hwaccm.s.vmx.pVMCSPhys >> 32); /* Param 2: VMCS physical address - Hi. */
4405 aParam[4] = VM_RC_ADDR(pVM, &pVM->aCpus[pVCpu->idCpu].hwaccm.s.vmx.VMCSCache);
4406 aParam[5] = 0;
4407
4408#ifdef VBOX_WITH_CRASHDUMP_MAGIC
4409 pCtx->dr[4] = pVM->hwaccm.s.vmx.pScratchPhys + 16 + 8;
4410 *(uint32_t *)(pVM->hwaccm.s.vmx.pScratch + 16 + 8) = 1;
4411#endif
4412 rc = VMXR0Execute64BitsHandler(pVM, pVCpu, pCtx, pVM->hwaccm.s.pfnVMXGCStartVM64, 6, &aParam[0]);
4413
4414#ifdef VBOX_WITH_CRASHDUMP_MAGIC
4415 Assert(*(uint32_t *)(pVM->hwaccm.s.vmx.pScratch + 16 + 8) == 5);
4416 Assert(pCtx->dr[4] == 10);
4417 *(uint32_t *)(pVM->hwaccm.s.vmx.pScratch + 16 + 8) = 0xff;
4418#endif
4419
4420#ifdef DEBUG
4421 AssertMsg(pCache->TestIn.pPageCpuPhys == pPageCpuPhys, ("%RHp vs %RHp\n", pCache->TestIn.pPageCpuPhys, pPageCpuPhys));
4422 AssertMsg(pCache->TestIn.pVMCSPhys == pVCpu->hwaccm.s.vmx.pVMCSPhys, ("%RHp vs %RHp\n", pCache->TestIn.pVMCSPhys, pVCpu->hwaccm.s.vmx.pVMCSPhys));
4423 AssertMsg(pCache->TestIn.pVMCSPhys == pCache->TestOut.pVMCSPhys, ("%RHp vs %RHp\n", pCache->TestIn.pVMCSPhys, pCache->TestOut.pVMCSPhys));
4424 AssertMsg(pCache->TestIn.pCache == pCache->TestOut.pCache, ("%RGv vs %RGv\n", pCache->TestIn.pCache, pCache->TestOut.pCache));
4425 AssertMsg(pCache->TestIn.pCache == VM_RC_ADDR(pVM, &pVM->aCpus[pVCpu->idCpu].hwaccm.s.vmx.VMCSCache), ("%RGv vs %RGv\n", pCache->TestIn.pCache, VM_RC_ADDR(pVM, &pVM->aCpus[pVCpu->idCpu].hwaccm.s.vmx.VMCSCache)));
4426 AssertMsg(pCache->TestIn.pCtx == pCache->TestOut.pCtx, ("%RGv vs %RGv\n", pCache->TestIn.pCtx, pCache->TestOut.pCtx));
4427 Assert(!(pCache->TestOut.eflags & X86_EFL_IF));
4428#endif
4429 return rc;
4430}
4431
4432/**
4433 * Executes the specified handler in 64 mode
4434 *
4435 * @returns VBox status code.
4436 * @param pVM The VM to operate on.
4437 * @param pVCpu The VMCPU to operate on.
4438 * @param pCtx Guest context
4439 * @param pfnHandler RC handler
4440 * @param cbParam Number of parameters
4441 * @param paParam Array of 32 bits parameters
4442 */
4443VMMR0DECL(int) VMXR0Execute64BitsHandler(PVM pVM, PVMCPU pVCpu, PCPUMCTX pCtx, RTRCPTR pfnHandler, uint32_t cbParam, uint32_t *paParam)
4444{
4445 int rc, rc2;
4446 PHWACCM_CPUINFO pCpu;
4447 RTHCPHYS pPageCpuPhys;
4448
4449 /* @todo This code is not guest SMP safe (hyper stack and switchers) */
4450 AssertReturn(pVM->cCPUs == 1, VERR_TOO_MANY_CPUS);
4451 AssertReturn(pVM->hwaccm.s.pfnHost32ToGuest64R0, VERR_INTERNAL_ERROR);
4452 Assert(pVCpu->hwaccm.s.vmx.VMCSCache.Write.cValidEntries <= RT_ELEMENTS(pVCpu->hwaccm.s.vmx.VMCSCache.Write.aField));
4453 Assert(pVCpu->hwaccm.s.vmx.VMCSCache.Read.cValidEntries <= RT_ELEMENTS(pVCpu->hwaccm.s.vmx.VMCSCache.Read.aField));
4454
4455#ifdef VBOX_STRICT
4456 for (unsigned i=0;i<pVCpu->hwaccm.s.vmx.VMCSCache.Write.cValidEntries;i++)
4457 Assert(vmxR0IsValidWriteField(pVCpu->hwaccm.s.vmx.VMCSCache.Write.aField[i]));
4458
4459 for (unsigned i=0;i<pVCpu->hwaccm.s.vmx.VMCSCache.Read.cValidEntries;i++)
4460 Assert(vmxR0IsValidReadField(pVCpu->hwaccm.s.vmx.VMCSCache.Read.aField[i]));
4461#endif
4462
4463 pCpu = HWACCMR0GetCurrentCpu();
4464 pPageCpuPhys = RTR0MemObjGetPagePhysAddr(pCpu->pMemObj, 0);
4465
4466 /* Clear VM Control Structure. Marking it inactive, clearing implementation specific data and writing back VMCS data to memory. */
4467 VMXClearVMCS(pVCpu->hwaccm.s.vmx.pVMCSPhys);
4468
4469 /* Leave VMX Root Mode. */
4470 VMXDisable();
4471
4472 ASMSetCR4(ASMGetCR4() & ~X86_CR4_VMXE);
4473
4474 CPUMSetHyperESP(pVCpu, VMMGetStackRC(pVM));
4475 CPUMSetHyperEIP(pVCpu, pfnHandler);
4476 for (int i=(int)cbParam-1;i>=0;i--)
4477 CPUMPushHyper(pVCpu, paParam[i]);
4478
4479 STAM_PROFILE_ADV_START(&pVCpu->hwaccm.s.StatWorldSwitch3264, z);
4480 /* Call switcher. */
4481 rc = pVM->hwaccm.s.pfnHost32ToGuest64R0(pVM);
4482 STAM_PROFILE_ADV_STOP(&pVCpu->hwaccm.s.StatWorldSwitch3264, z);
4483
4484 /* Make sure the VMX instructions don't cause #UD faults. */
4485 ASMSetCR4(ASMGetCR4() | X86_CR4_VMXE);
4486
4487 /* Enter VMX Root Mode */
4488 rc2 = VMXEnable(pPageCpuPhys);
4489 if (RT_FAILURE(rc2))
4490 {
4491 if (pVM)
4492 VMXR0CheckError(pVM, pVCpu, rc2);
4493 ASMSetCR4(ASMGetCR4() & ~X86_CR4_VMXE);
4494 return VERR_VMX_VMXON_FAILED;
4495 }
4496
4497 rc2 = VMXActivateVMCS(pVCpu->hwaccm.s.vmx.pVMCSPhys);
4498 AssertRCReturn(rc2, rc2);
4499 Assert(!(ASMGetFlags() & X86_EFL_IF));
4500 return rc;
4501}
4502
4503#endif /* HC_ARCH_BITS == 32 && defined(VBOX_ENABLE_64_BITS_GUESTS) && !defined(VBOX_WITH_HYBRID_32BIT_KERNEL) */
4504
4505
4506#if HC_ARCH_BITS == 32 && !defined(VBOX_WITH_2X_4GB_ADDR_SPACE_IN_R0)
4507/**
4508 * Executes VMWRITE
4509 *
4510 * @returns VBox status code
4511 * @param pVCpu The VMCPU to operate on.
4512 * @param idxField VMCS index
4513 * @param u64Val 16, 32 or 64 bits value
4514 */
4515VMMR0DECL(int) VMXWriteVMCS64Ex(PVMCPU pVCpu, uint32_t idxField, uint64_t u64Val)
4516{
4517 int rc;
4518
4519 switch (idxField)
4520 {
4521 case VMX_VMCS_CTRL_TSC_OFFSET_FULL:
4522 case VMX_VMCS_CTRL_IO_BITMAP_A_FULL:
4523 case VMX_VMCS_CTRL_IO_BITMAP_B_FULL:
4524 case VMX_VMCS_CTRL_MSR_BITMAP_FULL:
4525 case VMX_VMCS_CTRL_VMEXIT_MSR_STORE_FULL:
4526 case VMX_VMCS_CTRL_VMEXIT_MSR_LOAD_FULL:
4527 case VMX_VMCS_CTRL_VMENTRY_MSR_LOAD_FULL:
4528 case VMX_VMCS_CTRL_VAPIC_PAGEADDR_FULL:
4529 case VMX_VMCS_CTRL_APIC_ACCESSADDR_FULL:
4530 case VMX_VMCS_GUEST_LINK_PTR_FULL:
4531 case VMX_VMCS_GUEST_PDPTR0_FULL:
4532 case VMX_VMCS_GUEST_PDPTR1_FULL:
4533 case VMX_VMCS_GUEST_PDPTR2_FULL:
4534 case VMX_VMCS_GUEST_PDPTR3_FULL:
4535 case VMX_VMCS_GUEST_DEBUGCTL_FULL:
4536 case VMX_VMCS_GUEST_EFER_FULL:
4537 case VMX_VMCS_CTRL_EPTP_FULL:
4538 /* These fields consist of two parts, which are both writable in 32 bits mode. */
4539 rc = VMXWriteVMCS32(idxField, u64Val);
4540 rc |= VMXWriteVMCS32(idxField + 1, (uint32_t)(u64Val >> 32ULL));
4541 AssertRC(rc);
4542 return rc;
4543
4544 case VMX_VMCS64_GUEST_LDTR_BASE:
4545 case VMX_VMCS64_GUEST_TR_BASE:
4546 case VMX_VMCS64_GUEST_GDTR_BASE:
4547 case VMX_VMCS64_GUEST_IDTR_BASE:
4548 case VMX_VMCS64_GUEST_SYSENTER_EIP:
4549 case VMX_VMCS64_GUEST_SYSENTER_ESP:
4550 case VMX_VMCS64_GUEST_CR0:
4551 case VMX_VMCS64_GUEST_CR4:
4552 case VMX_VMCS64_GUEST_CR3:
4553 case VMX_VMCS64_GUEST_DR7:
4554 case VMX_VMCS64_GUEST_RIP:
4555 case VMX_VMCS64_GUEST_RSP:
4556 case VMX_VMCS64_GUEST_CS_BASE:
4557 case VMX_VMCS64_GUEST_DS_BASE:
4558 case VMX_VMCS64_GUEST_ES_BASE:
4559 case VMX_VMCS64_GUEST_FS_BASE:
4560 case VMX_VMCS64_GUEST_GS_BASE:
4561 case VMX_VMCS64_GUEST_SS_BASE:
4562 /* Queue a 64 bits value as we can't set it in 32 bits host mode. */
4563 if (u64Val >> 32ULL)
4564 rc = VMXWriteCachedVMCSEx(pVCpu, idxField, u64Val);
4565 else
4566 rc = VMXWriteVMCS32(idxField, (uint32_t)u64Val);
4567
4568 return rc;
4569
4570 default:
4571 AssertMsgFailed(("Unexpected field %x\n", idxField));
4572 return VERR_INVALID_PARAMETER;
4573 }
4574}
4575
4576/**
4577 * Cache VMCS writes for performance reasons (Darwin) and for running 64 bits guests on 32 bits hosts.
4578 *
4579 * @param pVCpu The VMCPU to operate on.
4580 * @param idxField VMCS field
4581 * @param u64Val Value
4582 */
4583VMMR0DECL(int) VMXWriteCachedVMCSEx(PVMCPU pVCpu, uint32_t idxField, uint64_t u64Val)
4584{
4585 PVMCSCACHE pCache = &pVCpu->hwaccm.s.vmx.VMCSCache;
4586
4587 AssertMsgReturn(pCache->Write.cValidEntries < VMCSCACHE_MAX_ENTRY - 1, ("entries=%x\n", pCache->Write.cValidEntries), VERR_ACCESS_DENIED);
4588
4589 /* Make sure there are no duplicates. */
4590 for (unsigned i=0;i<pCache->Write.cValidEntries;i++)
4591 {
4592 if (pCache->Write.aField[i] == idxField)
4593 {
4594 pCache->Write.aFieldVal[i] = u64Val;
4595 return VINF_SUCCESS;
4596 }
4597 }
4598
4599 pCache->Write.aField[pCache->Write.cValidEntries] = idxField;
4600 pCache->Write.aFieldVal[pCache->Write.cValidEntries] = u64Val;
4601 pCache->Write.cValidEntries++;
4602 return VINF_SUCCESS;
4603}
4604
4605#endif /* HC_ARCH_BITS == 32 && !VBOX_WITH_2X_4GB_ADDR_SPACE_IN_R0 */
4606
4607#ifdef VBOX_STRICT
4608static bool vmxR0IsValidReadField(uint32_t idxField)
4609{
4610 switch(idxField)
4611 {
4612 case VMX_VMCS64_GUEST_RIP:
4613 case VMX_VMCS64_GUEST_RSP:
4614 case VMX_VMCS_GUEST_RFLAGS:
4615 case VMX_VMCS32_GUEST_INTERRUPTIBILITY_STATE:
4616 case VMX_VMCS_CTRL_CR0_READ_SHADOW:
4617 case VMX_VMCS64_GUEST_CR0:
4618 case VMX_VMCS_CTRL_CR4_READ_SHADOW:
4619 case VMX_VMCS64_GUEST_CR4:
4620 case VMX_VMCS64_GUEST_DR7:
4621 case VMX_VMCS32_GUEST_SYSENTER_CS:
4622 case VMX_VMCS64_GUEST_SYSENTER_EIP:
4623 case VMX_VMCS64_GUEST_SYSENTER_ESP:
4624 case VMX_VMCS32_GUEST_GDTR_LIMIT:
4625 case VMX_VMCS64_GUEST_GDTR_BASE:
4626 case VMX_VMCS32_GUEST_IDTR_LIMIT:
4627 case VMX_VMCS64_GUEST_IDTR_BASE:
4628 case VMX_VMCS16_GUEST_FIELD_CS:
4629 case VMX_VMCS32_GUEST_CS_LIMIT:
4630 case VMX_VMCS64_GUEST_CS_BASE:
4631 case VMX_VMCS32_GUEST_CS_ACCESS_RIGHTS:
4632 case VMX_VMCS16_GUEST_FIELD_DS:
4633 case VMX_VMCS32_GUEST_DS_LIMIT:
4634 case VMX_VMCS64_GUEST_DS_BASE:
4635 case VMX_VMCS32_GUEST_DS_ACCESS_RIGHTS:
4636 case VMX_VMCS16_GUEST_FIELD_ES:
4637 case VMX_VMCS32_GUEST_ES_LIMIT:
4638 case VMX_VMCS64_GUEST_ES_BASE:
4639 case VMX_VMCS32_GUEST_ES_ACCESS_RIGHTS:
4640 case VMX_VMCS16_GUEST_FIELD_FS:
4641 case VMX_VMCS32_GUEST_FS_LIMIT:
4642 case VMX_VMCS64_GUEST_FS_BASE:
4643 case VMX_VMCS32_GUEST_FS_ACCESS_RIGHTS:
4644 case VMX_VMCS16_GUEST_FIELD_GS:
4645 case VMX_VMCS32_GUEST_GS_LIMIT:
4646 case VMX_VMCS64_GUEST_GS_BASE:
4647 case VMX_VMCS32_GUEST_GS_ACCESS_RIGHTS:
4648 case VMX_VMCS16_GUEST_FIELD_SS:
4649 case VMX_VMCS32_GUEST_SS_LIMIT:
4650 case VMX_VMCS64_GUEST_SS_BASE:
4651 case VMX_VMCS32_GUEST_SS_ACCESS_RIGHTS:
4652 case VMX_VMCS16_GUEST_FIELD_LDTR:
4653 case VMX_VMCS32_GUEST_LDTR_LIMIT:
4654 case VMX_VMCS64_GUEST_LDTR_BASE:
4655 case VMX_VMCS32_GUEST_LDTR_ACCESS_RIGHTS:
4656 case VMX_VMCS16_GUEST_FIELD_TR:
4657 case VMX_VMCS32_GUEST_TR_LIMIT:
4658 case VMX_VMCS64_GUEST_TR_BASE:
4659 case VMX_VMCS32_GUEST_TR_ACCESS_RIGHTS:
4660 case VMX_VMCS32_RO_EXIT_REASON:
4661 case VMX_VMCS32_RO_VM_INSTR_ERROR:
4662 case VMX_VMCS32_RO_EXIT_INSTR_LENGTH:
4663 case VMX_VMCS32_RO_EXIT_INTERRUPTION_ERRCODE:
4664 case VMX_VMCS32_RO_EXIT_INTERRUPTION_INFO:
4665 case VMX_VMCS32_RO_EXIT_INSTR_INFO:
4666 case VMX_VMCS_RO_EXIT_QUALIFICATION:
4667 case VMX_VMCS32_RO_IDT_INFO:
4668 case VMX_VMCS32_RO_IDT_ERRCODE:
4669 case VMX_VMCS64_GUEST_CR3:
4670 case VMX_VMCS_EXIT_PHYS_ADDR_FULL:
4671 return true;
4672 }
4673 return false;
4674}
4675
4676static bool vmxR0IsValidWriteField(uint32_t idxField)
4677{
4678 switch(idxField)
4679 {
4680 case VMX_VMCS64_GUEST_LDTR_BASE:
4681 case VMX_VMCS64_GUEST_TR_BASE:
4682 case VMX_VMCS64_GUEST_GDTR_BASE:
4683 case VMX_VMCS64_GUEST_IDTR_BASE:
4684 case VMX_VMCS64_GUEST_SYSENTER_EIP:
4685 case VMX_VMCS64_GUEST_SYSENTER_ESP:
4686 case VMX_VMCS64_GUEST_CR0:
4687 case VMX_VMCS64_GUEST_CR4:
4688 case VMX_VMCS64_GUEST_CR3:
4689 case VMX_VMCS64_GUEST_DR7:
4690 case VMX_VMCS64_GUEST_RIP:
4691 case VMX_VMCS64_GUEST_RSP:
4692 case VMX_VMCS64_GUEST_CS_BASE:
4693 case VMX_VMCS64_GUEST_DS_BASE:
4694 case VMX_VMCS64_GUEST_ES_BASE:
4695 case VMX_VMCS64_GUEST_FS_BASE:
4696 case VMX_VMCS64_GUEST_GS_BASE:
4697 case VMX_VMCS64_GUEST_SS_BASE:
4698 return true;
4699 }
4700 return false;
4701}
4702
4703#endif
Note: See TracBrowser for help on using the repository browser.

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