VirtualBox

source: vbox/trunk/src/VBox/VMM/VMMAll/CPUMAllRegs.cpp@ 93762

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

VMM: More arm64 adjustments. bugref:9898
  • Property svn:eol-style set to native
  • Property svn:keywords set to Id Revision
File size: 99.1 KB
Line 
1/* $Id: CPUMAllRegs.cpp 93725 2022-02-14 13:46:16Z vboxsync $ */
2/** @file
3 * CPUM - CPU Monitor(/Manager) - Getters and Setters.
4 */
5
6/*
7 * Copyright (C) 2006-2022 Oracle Corporation
8 *
9 * This file is part of VirtualBox Open Source Edition (OSE), as
10 * available from http://www.virtualbox.org. This file is free software;
11 * you can redistribute it and/or modify it under the terms of the GNU
12 * General Public License (GPL) as published by the Free Software
13 * Foundation, in version 2 as it comes in the "COPYING" file of the
14 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16 */
17
18
19/*********************************************************************************************************************************
20* Header Files *
21*********************************************************************************************************************************/
22#define LOG_GROUP LOG_GROUP_CPUM
23#include <VBox/vmm/cpum.h>
24#include <VBox/vmm/dbgf.h>
25#include <VBox/vmm/apic.h>
26#include <VBox/vmm/pgm.h>
27#include <VBox/vmm/mm.h>
28#include <VBox/vmm/em.h>
29#include <VBox/vmm/nem.h>
30#include <VBox/vmm/hm.h>
31#include "CPUMInternal.h"
32#include <VBox/vmm/vmcc.h>
33#include <VBox/err.h>
34#include <VBox/dis.h>
35#include <VBox/log.h>
36#include <VBox/vmm/hm.h>
37#include <VBox/vmm/tm.h>
38#include <iprt/assert.h>
39#include <iprt/asm.h>
40#if defined(RT_ARCH_AMD64) || defined(RT_ARCH_X86)
41# include <iprt/asm-amd64-x86.h>
42#endif
43#ifdef IN_RING3
44# include <iprt/thread.h>
45#endif
46
47/** Disable stack frame pointer generation here. */
48#if defined(_MSC_VER) && !defined(DEBUG) && defined(RT_ARCH_X86)
49# pragma optimize("y", off)
50#endif
51
52AssertCompile2MemberOffsets(VM, cpum.s.HostFeatures, cpum.ro.HostFeatures);
53AssertCompile2MemberOffsets(VM, cpum.s.GuestFeatures, cpum.ro.GuestFeatures);
54
55
56/*********************************************************************************************************************************
57* Defined Constants And Macros *
58*********************************************************************************************************************************/
59/**
60 * Converts a CPUMCPU::Guest pointer into a VMCPU pointer.
61 *
62 * @returns Pointer to the Virtual CPU.
63 * @param a_pGuestCtx Pointer to the guest context.
64 */
65#define CPUM_GUEST_CTX_TO_VMCPU(a_pGuestCtx) RT_FROM_MEMBER(a_pGuestCtx, VMCPU, cpum.s.Guest)
66
67/**
68 * Lazily loads the hidden parts of a selector register when using raw-mode.
69 */
70#define CPUMSELREG_LAZY_LOAD_HIDDEN_PARTS(a_pVCpu, a_pSReg) \
71 Assert(CPUMSELREG_ARE_HIDDEN_PARTS_VALID(a_pVCpu, a_pSReg))
72
73/** @def CPUM_INT_ASSERT_NOT_EXTRN
74 * Macro for asserting that @a a_fNotExtrn are present.
75 *
76 * @param a_pVCpu The cross context virtual CPU structure of the calling EMT.
77 * @param a_fNotExtrn Mask of CPUMCTX_EXTRN_XXX bits to check.
78 */
79#define CPUM_INT_ASSERT_NOT_EXTRN(a_pVCpu, a_fNotExtrn) \
80 AssertMsg(!((a_pVCpu)->cpum.s.Guest.fExtrn & (a_fNotExtrn)), \
81 ("%#RX64; a_fNotExtrn=%#RX64\n", (a_pVCpu)->cpum.s.Guest.fExtrn, (a_fNotExtrn)))
82
83
84VMMDECL(void) CPUMSetHyperCR3(PVMCPU pVCpu, uint32_t cr3)
85{
86 pVCpu->cpum.s.Hyper.cr3 = cr3;
87}
88
89VMMDECL(uint32_t) CPUMGetHyperCR3(PVMCPU pVCpu)
90{
91 return pVCpu->cpum.s.Hyper.cr3;
92}
93
94
95/** @def MAYBE_LOAD_DRx
96 * Macro for updating DRx values in raw-mode and ring-0 contexts.
97 */
98#ifdef IN_RING0
99# define MAYBE_LOAD_DRx(a_pVCpu, a_fnLoad, a_uValue) do { a_fnLoad(a_uValue); } while (0)
100#else
101# define MAYBE_LOAD_DRx(a_pVCpu, a_fnLoad, a_uValue) do { } while (0)
102#endif
103
104VMMDECL(void) CPUMSetHyperDR0(PVMCPU pVCpu, RTGCUINTREG uDr0)
105{
106 pVCpu->cpum.s.Hyper.dr[0] = uDr0;
107 MAYBE_LOAD_DRx(pVCpu, ASMSetDR0, uDr0);
108}
109
110
111VMMDECL(void) CPUMSetHyperDR1(PVMCPU pVCpu, RTGCUINTREG uDr1)
112{
113 pVCpu->cpum.s.Hyper.dr[1] = uDr1;
114 MAYBE_LOAD_DRx(pVCpu, ASMSetDR1, uDr1);
115}
116
117
118VMMDECL(void) CPUMSetHyperDR2(PVMCPU pVCpu, RTGCUINTREG uDr2)
119{
120 pVCpu->cpum.s.Hyper.dr[2] = uDr2;
121 MAYBE_LOAD_DRx(pVCpu, ASMSetDR2, uDr2);
122}
123
124
125VMMDECL(void) CPUMSetHyperDR3(PVMCPU pVCpu, RTGCUINTREG uDr3)
126{
127 pVCpu->cpum.s.Hyper.dr[3] = uDr3;
128 MAYBE_LOAD_DRx(pVCpu, ASMSetDR3, uDr3);
129}
130
131
132VMMDECL(void) CPUMSetHyperDR6(PVMCPU pVCpu, RTGCUINTREG uDr6)
133{
134 pVCpu->cpum.s.Hyper.dr[6] = uDr6;
135}
136
137
138VMMDECL(void) CPUMSetHyperDR7(PVMCPU pVCpu, RTGCUINTREG uDr7)
139{
140 pVCpu->cpum.s.Hyper.dr[7] = uDr7;
141}
142
143
144VMMDECL(RTGCUINTREG) CPUMGetHyperDR0(PVMCPU pVCpu)
145{
146 return pVCpu->cpum.s.Hyper.dr[0];
147}
148
149
150VMMDECL(RTGCUINTREG) CPUMGetHyperDR1(PVMCPU pVCpu)
151{
152 return pVCpu->cpum.s.Hyper.dr[1];
153}
154
155
156VMMDECL(RTGCUINTREG) CPUMGetHyperDR2(PVMCPU pVCpu)
157{
158 return pVCpu->cpum.s.Hyper.dr[2];
159}
160
161
162VMMDECL(RTGCUINTREG) CPUMGetHyperDR3(PVMCPU pVCpu)
163{
164 return pVCpu->cpum.s.Hyper.dr[3];
165}
166
167
168VMMDECL(RTGCUINTREG) CPUMGetHyperDR6(PVMCPU pVCpu)
169{
170 return pVCpu->cpum.s.Hyper.dr[6];
171}
172
173
174VMMDECL(RTGCUINTREG) CPUMGetHyperDR7(PVMCPU pVCpu)
175{
176 return pVCpu->cpum.s.Hyper.dr[7];
177}
178
179
180/**
181 * Gets the pointer to the internal CPUMCTXCORE structure.
182 * This is only for reading in order to save a few calls.
183 *
184 * @param pVCpu The cross context virtual CPU structure.
185 */
186VMMDECL(PCCPUMCTXCORE) CPUMGetGuestCtxCore(PVMCPU pVCpu)
187{
188 return CPUMCTX2CORE(&pVCpu->cpum.s.Guest);
189}
190
191
192/**
193 * Queries the pointer to the internal CPUMCTX structure.
194 *
195 * @returns The CPUMCTX pointer.
196 * @param pVCpu The cross context virtual CPU structure.
197 */
198VMMDECL(PCPUMCTX) CPUMQueryGuestCtxPtr(PVMCPU pVCpu)
199{
200 return &pVCpu->cpum.s.Guest;
201}
202
203
204/**
205 * Queries the pointer to the internal CPUMCTXMSRS structure.
206 *
207 * This is for NEM only.
208 *
209 * @returns The CPUMCTX pointer.
210 * @param pVCpu The cross context virtual CPU structure.
211 */
212VMM_INT_DECL(PCPUMCTXMSRS) CPUMQueryGuestCtxMsrsPtr(PVMCPU pVCpu)
213{
214 return &pVCpu->cpum.s.GuestMsrs;
215}
216
217
218VMMDECL(int) CPUMSetGuestGDTR(PVMCPU pVCpu, uint64_t GCPtrBase, uint16_t cbLimit)
219{
220 pVCpu->cpum.s.Guest.gdtr.cbGdt = cbLimit;
221 pVCpu->cpum.s.Guest.gdtr.pGdt = GCPtrBase;
222 pVCpu->cpum.s.Guest.fExtrn &= ~CPUMCTX_EXTRN_GDTR;
223 pVCpu->cpum.s.fChanged |= CPUM_CHANGED_GDTR;
224 return VINF_SUCCESS; /* formality, consider it void. */
225}
226
227
228VMMDECL(int) CPUMSetGuestIDTR(PVMCPU pVCpu, uint64_t GCPtrBase, uint16_t cbLimit)
229{
230 pVCpu->cpum.s.Guest.idtr.cbIdt = cbLimit;
231 pVCpu->cpum.s.Guest.idtr.pIdt = GCPtrBase;
232 pVCpu->cpum.s.Guest.fExtrn &= ~CPUMCTX_EXTRN_IDTR;
233 pVCpu->cpum.s.fChanged |= CPUM_CHANGED_IDTR;
234 return VINF_SUCCESS; /* formality, consider it void. */
235}
236
237
238VMMDECL(int) CPUMSetGuestTR(PVMCPU pVCpu, uint16_t tr)
239{
240 pVCpu->cpum.s.Guest.tr.Sel = tr;
241 pVCpu->cpum.s.fChanged |= CPUM_CHANGED_TR;
242 return VINF_SUCCESS; /* formality, consider it void. */
243}
244
245
246VMMDECL(int) CPUMSetGuestLDTR(PVMCPU pVCpu, uint16_t ldtr)
247{
248 pVCpu->cpum.s.Guest.ldtr.Sel = ldtr;
249 /* The caller will set more hidden bits if it has them. */
250 pVCpu->cpum.s.Guest.ldtr.ValidSel = 0;
251 pVCpu->cpum.s.Guest.ldtr.fFlags = 0;
252 pVCpu->cpum.s.fChanged |= CPUM_CHANGED_LDTR;
253 return VINF_SUCCESS; /* formality, consider it void. */
254}
255
256
257/**
258 * Set the guest CR0.
259 *
260 * When called in GC, the hyper CR0 may be updated if that is
261 * required. The caller only has to take special action if AM,
262 * WP, PG or PE changes.
263 *
264 * @returns VINF_SUCCESS (consider it void).
265 * @param pVCpu The cross context virtual CPU structure.
266 * @param cr0 The new CR0 value.
267 */
268VMMDECL(int) CPUMSetGuestCR0(PVMCPUCC pVCpu, uint64_t cr0)
269{
270 /*
271 * Check for changes causing TLB flushes (for REM).
272 * The caller is responsible for calling PGM when appropriate.
273 */
274 if ( (cr0 & (X86_CR0_PG | X86_CR0_WP | X86_CR0_PE))
275 != (pVCpu->cpum.s.Guest.cr0 & (X86_CR0_PG | X86_CR0_WP | X86_CR0_PE)))
276 pVCpu->cpum.s.fChanged |= CPUM_CHANGED_GLOBAL_TLB_FLUSH;
277 pVCpu->cpum.s.fChanged |= CPUM_CHANGED_CR0;
278
279 /*
280 * Let PGM know if the WP goes from 0 to 1 (netware WP0+RO+US hack)
281 */
282 if (((cr0 ^ pVCpu->cpum.s.Guest.cr0) & X86_CR0_WP) && (cr0 & X86_CR0_WP))
283 PGMCr0WpEnabled(pVCpu);
284
285 /* The ET flag is settable on a 386 and hardwired on 486+. */
286 if ( !(cr0 & X86_CR0_ET)
287 && pVCpu->CTX_SUFF(pVM)->cpum.s.GuestFeatures.enmMicroarch != kCpumMicroarch_Intel_80386)
288 cr0 |= X86_CR0_ET;
289
290 pVCpu->cpum.s.Guest.cr0 = cr0;
291 pVCpu->cpum.s.Guest.fExtrn &= ~CPUMCTX_EXTRN_CR0;
292 return VINF_SUCCESS;
293}
294
295
296VMMDECL(int) CPUMSetGuestCR2(PVMCPU pVCpu, uint64_t cr2)
297{
298 pVCpu->cpum.s.Guest.cr2 = cr2;
299 pVCpu->cpum.s.Guest.fExtrn &= ~CPUMCTX_EXTRN_CR2;
300 return VINF_SUCCESS;
301}
302
303
304VMMDECL(int) CPUMSetGuestCR3(PVMCPU pVCpu, uint64_t cr3)
305{
306 pVCpu->cpum.s.Guest.cr3 = cr3;
307 pVCpu->cpum.s.fChanged |= CPUM_CHANGED_CR3;
308 pVCpu->cpum.s.Guest.fExtrn &= ~CPUMCTX_EXTRN_CR3;
309 return VINF_SUCCESS;
310}
311
312
313VMMDECL(int) CPUMSetGuestCR4(PVMCPU pVCpu, uint64_t cr4)
314{
315 /* Note! We don't bother with OSXSAVE and legacy CPUID patches. */
316
317 if ( (cr4 & (X86_CR4_PGE | X86_CR4_PAE | X86_CR4_PSE))
318 != (pVCpu->cpum.s.Guest.cr4 & (X86_CR4_PGE | X86_CR4_PAE | X86_CR4_PSE)))
319 pVCpu->cpum.s.fChanged |= CPUM_CHANGED_GLOBAL_TLB_FLUSH;
320
321 pVCpu->cpum.s.fChanged |= CPUM_CHANGED_CR4;
322 pVCpu->cpum.s.Guest.cr4 = cr4;
323 pVCpu->cpum.s.Guest.fExtrn &= ~CPUMCTX_EXTRN_CR4;
324 return VINF_SUCCESS;
325}
326
327
328VMMDECL(int) CPUMSetGuestEFlags(PVMCPU pVCpu, uint32_t eflags)
329{
330 pVCpu->cpum.s.Guest.eflags.u32 = eflags;
331 pVCpu->cpum.s.Guest.fExtrn &= ~CPUMCTX_EXTRN_RFLAGS;
332 return VINF_SUCCESS;
333}
334
335
336VMMDECL(int) CPUMSetGuestEIP(PVMCPU pVCpu, uint32_t eip)
337{
338 pVCpu->cpum.s.Guest.eip = eip;
339 return VINF_SUCCESS;
340}
341
342
343VMMDECL(int) CPUMSetGuestEAX(PVMCPU pVCpu, uint32_t eax)
344{
345 pVCpu->cpum.s.Guest.eax = eax;
346 return VINF_SUCCESS;
347}
348
349
350VMMDECL(int) CPUMSetGuestEBX(PVMCPU pVCpu, uint32_t ebx)
351{
352 pVCpu->cpum.s.Guest.ebx = ebx;
353 return VINF_SUCCESS;
354}
355
356
357VMMDECL(int) CPUMSetGuestECX(PVMCPU pVCpu, uint32_t ecx)
358{
359 pVCpu->cpum.s.Guest.ecx = ecx;
360 return VINF_SUCCESS;
361}
362
363
364VMMDECL(int) CPUMSetGuestEDX(PVMCPU pVCpu, uint32_t edx)
365{
366 pVCpu->cpum.s.Guest.edx = edx;
367 return VINF_SUCCESS;
368}
369
370
371VMMDECL(int) CPUMSetGuestESP(PVMCPU pVCpu, uint32_t esp)
372{
373 pVCpu->cpum.s.Guest.esp = esp;
374 return VINF_SUCCESS;
375}
376
377
378VMMDECL(int) CPUMSetGuestEBP(PVMCPU pVCpu, uint32_t ebp)
379{
380 pVCpu->cpum.s.Guest.ebp = ebp;
381 return VINF_SUCCESS;
382}
383
384
385VMMDECL(int) CPUMSetGuestESI(PVMCPU pVCpu, uint32_t esi)
386{
387 pVCpu->cpum.s.Guest.esi = esi;
388 return VINF_SUCCESS;
389}
390
391
392VMMDECL(int) CPUMSetGuestEDI(PVMCPU pVCpu, uint32_t edi)
393{
394 pVCpu->cpum.s.Guest.edi = edi;
395 return VINF_SUCCESS;
396}
397
398
399VMMDECL(int) CPUMSetGuestSS(PVMCPU pVCpu, uint16_t ss)
400{
401 pVCpu->cpum.s.Guest.ss.Sel = ss;
402 return VINF_SUCCESS;
403}
404
405
406VMMDECL(int) CPUMSetGuestCS(PVMCPU pVCpu, uint16_t cs)
407{
408 pVCpu->cpum.s.Guest.cs.Sel = cs;
409 return VINF_SUCCESS;
410}
411
412
413VMMDECL(int) CPUMSetGuestDS(PVMCPU pVCpu, uint16_t ds)
414{
415 pVCpu->cpum.s.Guest.ds.Sel = ds;
416 return VINF_SUCCESS;
417}
418
419
420VMMDECL(int) CPUMSetGuestES(PVMCPU pVCpu, uint16_t es)
421{
422 pVCpu->cpum.s.Guest.es.Sel = es;
423 return VINF_SUCCESS;
424}
425
426
427VMMDECL(int) CPUMSetGuestFS(PVMCPU pVCpu, uint16_t fs)
428{
429 pVCpu->cpum.s.Guest.fs.Sel = fs;
430 return VINF_SUCCESS;
431}
432
433
434VMMDECL(int) CPUMSetGuestGS(PVMCPU pVCpu, uint16_t gs)
435{
436 pVCpu->cpum.s.Guest.gs.Sel = gs;
437 return VINF_SUCCESS;
438}
439
440
441VMMDECL(void) CPUMSetGuestEFER(PVMCPU pVCpu, uint64_t val)
442{
443 pVCpu->cpum.s.Guest.msrEFER = val;
444 pVCpu->cpum.s.Guest.fExtrn &= ~CPUMCTX_EXTRN_EFER;
445}
446
447
448VMMDECL(RTGCPTR) CPUMGetGuestIDTR(PCVMCPU pVCpu, uint16_t *pcbLimit)
449{
450 CPUM_INT_ASSERT_NOT_EXTRN(pVCpu, CPUMCTX_EXTRN_IDTR);
451 if (pcbLimit)
452 *pcbLimit = pVCpu->cpum.s.Guest.idtr.cbIdt;
453 return pVCpu->cpum.s.Guest.idtr.pIdt;
454}
455
456
457VMMDECL(RTSEL) CPUMGetGuestTR(PCVMCPU pVCpu, PCPUMSELREGHID pHidden)
458{
459 CPUM_INT_ASSERT_NOT_EXTRN(pVCpu, CPUMCTX_EXTRN_TR);
460 if (pHidden)
461 *pHidden = pVCpu->cpum.s.Guest.tr;
462 return pVCpu->cpum.s.Guest.tr.Sel;
463}
464
465
466VMMDECL(RTSEL) CPUMGetGuestCS(PCVMCPU pVCpu)
467{
468 CPUM_INT_ASSERT_NOT_EXTRN(pVCpu, CPUMCTX_EXTRN_CS);
469 return pVCpu->cpum.s.Guest.cs.Sel;
470}
471
472
473VMMDECL(RTSEL) CPUMGetGuestDS(PCVMCPU pVCpu)
474{
475 CPUM_INT_ASSERT_NOT_EXTRN(pVCpu, CPUMCTX_EXTRN_DS);
476 return pVCpu->cpum.s.Guest.ds.Sel;
477}
478
479
480VMMDECL(RTSEL) CPUMGetGuestES(PCVMCPU pVCpu)
481{
482 CPUM_INT_ASSERT_NOT_EXTRN(pVCpu, CPUMCTX_EXTRN_ES);
483 return pVCpu->cpum.s.Guest.es.Sel;
484}
485
486
487VMMDECL(RTSEL) CPUMGetGuestFS(PCVMCPU pVCpu)
488{
489 CPUM_INT_ASSERT_NOT_EXTRN(pVCpu, CPUMCTX_EXTRN_FS);
490 return pVCpu->cpum.s.Guest.fs.Sel;
491}
492
493
494VMMDECL(RTSEL) CPUMGetGuestGS(PCVMCPU pVCpu)
495{
496 CPUM_INT_ASSERT_NOT_EXTRN(pVCpu, CPUMCTX_EXTRN_GS);
497 return pVCpu->cpum.s.Guest.gs.Sel;
498}
499
500
501VMMDECL(RTSEL) CPUMGetGuestSS(PCVMCPU pVCpu)
502{
503 CPUM_INT_ASSERT_NOT_EXTRN(pVCpu, CPUMCTX_EXTRN_SS);
504 return pVCpu->cpum.s.Guest.ss.Sel;
505}
506
507
508VMMDECL(uint64_t) CPUMGetGuestFlatPC(PVMCPU pVCpu)
509{
510 CPUM_INT_ASSERT_NOT_EXTRN(pVCpu, CPUMCTX_EXTRN_RIP | CPUMCTX_EXTRN_CS | CPUMCTX_EXTRN_EFER);
511 CPUMSELREG_LAZY_LOAD_HIDDEN_PARTS(pVCpu, &pVCpu->cpum.s.Guest.cs);
512 if ( !CPUMIsGuestInLongMode(pVCpu)
513 || !pVCpu->cpum.s.Guest.cs.Attr.n.u1Long)
514 return pVCpu->cpum.s.Guest.eip + (uint32_t)pVCpu->cpum.s.Guest.cs.u64Base;
515 return pVCpu->cpum.s.Guest.rip + pVCpu->cpum.s.Guest.cs.u64Base;
516}
517
518
519VMMDECL(uint64_t) CPUMGetGuestFlatSP(PVMCPU pVCpu)
520{
521 CPUM_INT_ASSERT_NOT_EXTRN(pVCpu, CPUMCTX_EXTRN_RSP | CPUMCTX_EXTRN_SS | CPUMCTX_EXTRN_CS | CPUMCTX_EXTRN_EFER);
522 CPUMSELREG_LAZY_LOAD_HIDDEN_PARTS(pVCpu, &pVCpu->cpum.s.Guest.ss);
523 if ( !CPUMIsGuestInLongMode(pVCpu)
524 || !pVCpu->cpum.s.Guest.cs.Attr.n.u1Long)
525 return pVCpu->cpum.s.Guest.eip + (uint32_t)pVCpu->cpum.s.Guest.ss.u64Base;
526 return pVCpu->cpum.s.Guest.rip + pVCpu->cpum.s.Guest.ss.u64Base;
527}
528
529
530VMMDECL(RTSEL) CPUMGetGuestLDTR(PCVMCPU pVCpu)
531{
532 CPUM_INT_ASSERT_NOT_EXTRN(pVCpu, CPUMCTX_EXTRN_LDTR);
533 return pVCpu->cpum.s.Guest.ldtr.Sel;
534}
535
536
537VMMDECL(RTSEL) CPUMGetGuestLdtrEx(PCVMCPU pVCpu, uint64_t *pGCPtrBase, uint32_t *pcbLimit)
538{
539 CPUM_INT_ASSERT_NOT_EXTRN(pVCpu, CPUMCTX_EXTRN_LDTR);
540 *pGCPtrBase = pVCpu->cpum.s.Guest.ldtr.u64Base;
541 *pcbLimit = pVCpu->cpum.s.Guest.ldtr.u32Limit;
542 return pVCpu->cpum.s.Guest.ldtr.Sel;
543}
544
545
546VMMDECL(uint64_t) CPUMGetGuestCR0(PCVMCPU pVCpu)
547{
548 CPUM_INT_ASSERT_NOT_EXTRN(pVCpu, CPUMCTX_EXTRN_CR0);
549 return pVCpu->cpum.s.Guest.cr0;
550}
551
552
553VMMDECL(uint64_t) CPUMGetGuestCR2(PCVMCPU pVCpu)
554{
555 CPUM_INT_ASSERT_NOT_EXTRN(pVCpu, CPUMCTX_EXTRN_CR2);
556 return pVCpu->cpum.s.Guest.cr2;
557}
558
559
560VMMDECL(uint64_t) CPUMGetGuestCR3(PCVMCPU pVCpu)
561{
562 CPUM_INT_ASSERT_NOT_EXTRN(pVCpu, CPUMCTX_EXTRN_CR3);
563 return pVCpu->cpum.s.Guest.cr3;
564}
565
566
567VMMDECL(uint64_t) CPUMGetGuestCR4(PCVMCPU pVCpu)
568{
569 CPUM_INT_ASSERT_NOT_EXTRN(pVCpu, CPUMCTX_EXTRN_CR4);
570 return pVCpu->cpum.s.Guest.cr4;
571}
572
573
574VMMDECL(uint64_t) CPUMGetGuestCR8(PCVMCPUCC pVCpu)
575{
576 uint64_t u64;
577 int rc = CPUMGetGuestCRx(pVCpu, DISCREG_CR8, &u64);
578 if (RT_FAILURE(rc))
579 u64 = 0;
580 return u64;
581}
582
583
584VMMDECL(void) CPUMGetGuestGDTR(PCVMCPU pVCpu, PVBOXGDTR pGDTR)
585{
586 CPUM_INT_ASSERT_NOT_EXTRN(pVCpu, CPUMCTX_EXTRN_GDTR);
587 *pGDTR = pVCpu->cpum.s.Guest.gdtr;
588}
589
590
591VMMDECL(uint32_t) CPUMGetGuestEIP(PCVMCPU pVCpu)
592{
593 CPUM_INT_ASSERT_NOT_EXTRN(pVCpu, CPUMCTX_EXTRN_RIP);
594 return pVCpu->cpum.s.Guest.eip;
595}
596
597
598VMMDECL(uint64_t) CPUMGetGuestRIP(PCVMCPU pVCpu)
599{
600 CPUM_INT_ASSERT_NOT_EXTRN(pVCpu, CPUMCTX_EXTRN_RIP);
601 return pVCpu->cpum.s.Guest.rip;
602}
603
604
605VMMDECL(uint32_t) CPUMGetGuestEAX(PCVMCPU pVCpu)
606{
607 CPUM_INT_ASSERT_NOT_EXTRN(pVCpu, CPUMCTX_EXTRN_RAX);
608 return pVCpu->cpum.s.Guest.eax;
609}
610
611
612VMMDECL(uint32_t) CPUMGetGuestEBX(PCVMCPU pVCpu)
613{
614 CPUM_INT_ASSERT_NOT_EXTRN(pVCpu, CPUMCTX_EXTRN_RBX);
615 return pVCpu->cpum.s.Guest.ebx;
616}
617
618
619VMMDECL(uint32_t) CPUMGetGuestECX(PCVMCPU pVCpu)
620{
621 CPUM_INT_ASSERT_NOT_EXTRN(pVCpu, CPUMCTX_EXTRN_RCX);
622 return pVCpu->cpum.s.Guest.ecx;
623}
624
625
626VMMDECL(uint32_t) CPUMGetGuestEDX(PCVMCPU pVCpu)
627{
628 CPUM_INT_ASSERT_NOT_EXTRN(pVCpu, CPUMCTX_EXTRN_RDX);
629 return pVCpu->cpum.s.Guest.edx;
630}
631
632
633VMMDECL(uint32_t) CPUMGetGuestESI(PCVMCPU pVCpu)
634{
635 CPUM_INT_ASSERT_NOT_EXTRN(pVCpu, CPUMCTX_EXTRN_RSI);
636 return pVCpu->cpum.s.Guest.esi;
637}
638
639
640VMMDECL(uint32_t) CPUMGetGuestEDI(PCVMCPU pVCpu)
641{
642 CPUM_INT_ASSERT_NOT_EXTRN(pVCpu, CPUMCTX_EXTRN_RDI);
643 return pVCpu->cpum.s.Guest.edi;
644}
645
646
647VMMDECL(uint32_t) CPUMGetGuestESP(PCVMCPU pVCpu)
648{
649 CPUM_INT_ASSERT_NOT_EXTRN(pVCpu, CPUMCTX_EXTRN_RSP);
650 return pVCpu->cpum.s.Guest.esp;
651}
652
653
654VMMDECL(uint32_t) CPUMGetGuestEBP(PCVMCPU pVCpu)
655{
656 CPUM_INT_ASSERT_NOT_EXTRN(pVCpu, CPUMCTX_EXTRN_RBP);
657 return pVCpu->cpum.s.Guest.ebp;
658}
659
660
661VMMDECL(uint32_t) CPUMGetGuestEFlags(PCVMCPU pVCpu)
662{
663 CPUM_INT_ASSERT_NOT_EXTRN(pVCpu, CPUMCTX_EXTRN_RFLAGS);
664 return pVCpu->cpum.s.Guest.eflags.u32;
665}
666
667
668VMMDECL(int) CPUMGetGuestCRx(PCVMCPUCC pVCpu, unsigned iReg, uint64_t *pValue)
669{
670 switch (iReg)
671 {
672 case DISCREG_CR0:
673 CPUM_INT_ASSERT_NOT_EXTRN(pVCpu, CPUMCTX_EXTRN_CR0);
674 *pValue = pVCpu->cpum.s.Guest.cr0;
675 break;
676
677 case DISCREG_CR2:
678 CPUM_INT_ASSERT_NOT_EXTRN(pVCpu, CPUMCTX_EXTRN_CR2);
679 *pValue = pVCpu->cpum.s.Guest.cr2;
680 break;
681
682 case DISCREG_CR3:
683 CPUM_INT_ASSERT_NOT_EXTRN(pVCpu, CPUMCTX_EXTRN_CR3);
684 *pValue = pVCpu->cpum.s.Guest.cr3;
685 break;
686
687 case DISCREG_CR4:
688 CPUM_INT_ASSERT_NOT_EXTRN(pVCpu, CPUMCTX_EXTRN_CR4);
689 *pValue = pVCpu->cpum.s.Guest.cr4;
690 break;
691
692 case DISCREG_CR8:
693 {
694 CPUM_INT_ASSERT_NOT_EXTRN(pVCpu, CPUMCTX_EXTRN_APIC_TPR);
695 uint8_t u8Tpr;
696 int rc = APICGetTpr(pVCpu, &u8Tpr, NULL /* pfPending */, NULL /* pu8PendingIrq */);
697 if (RT_FAILURE(rc))
698 {
699 AssertMsg(rc == VERR_PDM_NO_APIC_INSTANCE, ("%Rrc\n", rc));
700 *pValue = 0;
701 return rc;
702 }
703 *pValue = u8Tpr >> 4; /* bits 7-4 contain the task priority that go in cr8, bits 3-0 */
704 break;
705 }
706
707 default:
708 return VERR_INVALID_PARAMETER;
709 }
710 return VINF_SUCCESS;
711}
712
713
714VMMDECL(uint64_t) CPUMGetGuestDR0(PCVMCPU pVCpu)
715{
716 CPUM_INT_ASSERT_NOT_EXTRN(pVCpu, CPUMCTX_EXTRN_DR0_DR3);
717 return pVCpu->cpum.s.Guest.dr[0];
718}
719
720
721VMMDECL(uint64_t) CPUMGetGuestDR1(PCVMCPU pVCpu)
722{
723 CPUM_INT_ASSERT_NOT_EXTRN(pVCpu, CPUMCTX_EXTRN_DR0_DR3);
724 return pVCpu->cpum.s.Guest.dr[1];
725}
726
727
728VMMDECL(uint64_t) CPUMGetGuestDR2(PCVMCPU pVCpu)
729{
730 CPUM_INT_ASSERT_NOT_EXTRN(pVCpu, CPUMCTX_EXTRN_DR0_DR3);
731 return pVCpu->cpum.s.Guest.dr[2];
732}
733
734
735VMMDECL(uint64_t) CPUMGetGuestDR3(PCVMCPU pVCpu)
736{
737 CPUM_INT_ASSERT_NOT_EXTRN(pVCpu, CPUMCTX_EXTRN_DR0_DR3);
738 return pVCpu->cpum.s.Guest.dr[3];
739}
740
741
742VMMDECL(uint64_t) CPUMGetGuestDR6(PCVMCPU pVCpu)
743{
744 CPUM_INT_ASSERT_NOT_EXTRN(pVCpu, CPUMCTX_EXTRN_DR6);
745 return pVCpu->cpum.s.Guest.dr[6];
746}
747
748
749VMMDECL(uint64_t) CPUMGetGuestDR7(PCVMCPU pVCpu)
750{
751 CPUM_INT_ASSERT_NOT_EXTRN(pVCpu, CPUMCTX_EXTRN_DR7);
752 return pVCpu->cpum.s.Guest.dr[7];
753}
754
755
756VMMDECL(int) CPUMGetGuestDRx(PCVMCPU pVCpu, uint32_t iReg, uint64_t *pValue)
757{
758 CPUM_INT_ASSERT_NOT_EXTRN(pVCpu, CPUMCTX_EXTRN_DR_MASK);
759 AssertReturn(iReg <= DISDREG_DR7, VERR_INVALID_PARAMETER);
760 /* DR4 is an alias for DR6, and DR5 is an alias for DR7. */
761 if (iReg == 4 || iReg == 5)
762 iReg += 2;
763 *pValue = pVCpu->cpum.s.Guest.dr[iReg];
764 return VINF_SUCCESS;
765}
766
767
768VMMDECL(uint64_t) CPUMGetGuestEFER(PCVMCPU pVCpu)
769{
770 CPUM_INT_ASSERT_NOT_EXTRN(pVCpu, CPUMCTX_EXTRN_EFER);
771 return pVCpu->cpum.s.Guest.msrEFER;
772}
773
774
775/**
776 * Looks up a CPUID leaf in the CPUID leaf array, no subleaf.
777 *
778 * @returns Pointer to the leaf if found, NULL if not.
779 *
780 * @param pVM The cross context VM structure.
781 * @param uLeaf The leaf to get.
782 */
783PCPUMCPUIDLEAF cpumCpuIdGetLeaf(PVM pVM, uint32_t uLeaf)
784{
785 unsigned iEnd = RT_MIN(pVM->cpum.s.GuestInfo.cCpuIdLeaves, RT_ELEMENTS(pVM->cpum.s.GuestInfo.aCpuIdLeaves));
786 if (iEnd)
787 {
788 unsigned iStart = 0;
789 PCPUMCPUIDLEAF paLeaves = pVM->cpum.s.GuestInfo.aCpuIdLeaves;
790 for (;;)
791 {
792 unsigned i = iStart + (iEnd - iStart) / 2U;
793 if (uLeaf < paLeaves[i].uLeaf)
794 {
795 if (i <= iStart)
796 return NULL;
797 iEnd = i;
798 }
799 else if (uLeaf > paLeaves[i].uLeaf)
800 {
801 i += 1;
802 if (i >= iEnd)
803 return NULL;
804 iStart = i;
805 }
806 else
807 {
808 if (RT_LIKELY(paLeaves[i].fSubLeafMask == 0 && paLeaves[i].uSubLeaf == 0))
809 return &paLeaves[i];
810
811 /* This shouldn't normally happen. But in case the it does due
812 to user configuration overrids or something, just return the
813 first sub-leaf. */
814 AssertMsgFailed(("uLeaf=%#x fSubLeafMask=%#x uSubLeaf=%#x\n",
815 uLeaf, paLeaves[i].fSubLeafMask, paLeaves[i].uSubLeaf));
816 while ( paLeaves[i].uSubLeaf != 0
817 && i > 0
818 && uLeaf == paLeaves[i - 1].uLeaf)
819 i--;
820 return &paLeaves[i];
821 }
822 }
823 }
824
825 return NULL;
826}
827
828
829/**
830 * Looks up a CPUID leaf in the CPUID leaf array.
831 *
832 * @returns Pointer to the leaf if found, NULL if not.
833 *
834 * @param pVM The cross context VM structure.
835 * @param uLeaf The leaf to get.
836 * @param uSubLeaf The subleaf, if applicable. Just pass 0 if it
837 * isn't.
838 * @param pfExactSubLeafHit Whether we've got an exact subleaf hit or not.
839 */
840PCPUMCPUIDLEAF cpumCpuIdGetLeafEx(PVM pVM, uint32_t uLeaf, uint32_t uSubLeaf, bool *pfExactSubLeafHit)
841{
842 unsigned iEnd = RT_MIN(pVM->cpum.s.GuestInfo.cCpuIdLeaves, RT_ELEMENTS(pVM->cpum.s.GuestInfo.aCpuIdLeaves));
843 if (iEnd)
844 {
845 unsigned iStart = 0;
846 PCPUMCPUIDLEAF paLeaves = pVM->cpum.s.GuestInfo.aCpuIdLeaves;
847 for (;;)
848 {
849 unsigned i = iStart + (iEnd - iStart) / 2U;
850 if (uLeaf < paLeaves[i].uLeaf)
851 {
852 if (i <= iStart)
853 return NULL;
854 iEnd = i;
855 }
856 else if (uLeaf > paLeaves[i].uLeaf)
857 {
858 i += 1;
859 if (i >= iEnd)
860 return NULL;
861 iStart = i;
862 }
863 else
864 {
865 uSubLeaf &= paLeaves[i].fSubLeafMask;
866 if (uSubLeaf == paLeaves[i].uSubLeaf)
867 *pfExactSubLeafHit = true;
868 else
869 {
870 /* Find the right subleaf. We return the last one before
871 uSubLeaf if we don't find an exact match. */
872 if (uSubLeaf < paLeaves[i].uSubLeaf)
873 while ( i > 0
874 && uLeaf == paLeaves[i - 1].uLeaf
875 && uSubLeaf <= paLeaves[i - 1].uSubLeaf)
876 i--;
877 else
878 while ( i + 1 < pVM->cpum.s.GuestInfo.cCpuIdLeaves
879 && uLeaf == paLeaves[i + 1].uLeaf
880 && uSubLeaf >= paLeaves[i + 1].uSubLeaf)
881 i++;
882 *pfExactSubLeafHit = uSubLeaf == paLeaves[i].uSubLeaf;
883 }
884 return &paLeaves[i];
885 }
886 }
887 }
888
889 *pfExactSubLeafHit = false;
890 return NULL;
891}
892
893
894/**
895 * Gets a CPUID leaf.
896 *
897 * @param pVCpu The cross context virtual CPU structure.
898 * @param uLeaf The CPUID leaf to get.
899 * @param uSubLeaf The CPUID sub-leaf to get, if applicable.
900 * @param pEax Where to store the EAX value.
901 * @param pEbx Where to store the EBX value.
902 * @param pEcx Where to store the ECX value.
903 * @param pEdx Where to store the EDX value.
904 */
905VMMDECL(void) CPUMGetGuestCpuId(PVMCPUCC pVCpu, uint32_t uLeaf, uint32_t uSubLeaf,
906 uint32_t *pEax, uint32_t *pEbx, uint32_t *pEcx, uint32_t *pEdx)
907{
908 bool fExactSubLeafHit;
909 PVM pVM = pVCpu->CTX_SUFF(pVM);
910 PCCPUMCPUIDLEAF pLeaf = cpumCpuIdGetLeafEx(pVM, uLeaf, uSubLeaf, &fExactSubLeafHit);
911 if (pLeaf)
912 {
913 AssertMsg(pLeaf->uLeaf == uLeaf, ("%#x %#x\n", pLeaf->uLeaf, uLeaf));
914 if (fExactSubLeafHit)
915 {
916 *pEax = pLeaf->uEax;
917 *pEbx = pLeaf->uEbx;
918 *pEcx = pLeaf->uEcx;
919 *pEdx = pLeaf->uEdx;
920
921 /*
922 * Deal with CPU specific information.
923 */
924 if (pLeaf->fFlags & ( CPUMCPUIDLEAF_F_CONTAINS_APIC_ID
925 | CPUMCPUIDLEAF_F_CONTAINS_OSXSAVE
926 | CPUMCPUIDLEAF_F_CONTAINS_APIC ))
927 {
928 if (uLeaf == 1)
929 {
930 /* EBX: Bits 31-24: Initial APIC ID. */
931 Assert(pVCpu->idCpu <= 255);
932 AssertMsg((pLeaf->uEbx >> 24) == 0, ("%#x\n", pLeaf->uEbx)); /* raw-mode assumption */
933 *pEbx = (pLeaf->uEbx & UINT32_C(0x00ffffff)) | (pVCpu->idCpu << 24);
934
935 /* EDX: Bit 9: AND with APICBASE.EN. */
936 if (!pVCpu->cpum.s.fCpuIdApicFeatureVisible && (pLeaf->fFlags & CPUMCPUIDLEAF_F_CONTAINS_APIC))
937 *pEdx &= ~X86_CPUID_FEATURE_EDX_APIC;
938
939 /* ECX: Bit 27: CR4.OSXSAVE mirror. */
940 *pEcx = (pLeaf->uEcx & ~X86_CPUID_FEATURE_ECX_OSXSAVE)
941 | (pVCpu->cpum.s.Guest.cr4 & X86_CR4_OSXSAVE ? X86_CPUID_FEATURE_ECX_OSXSAVE : 0);
942 }
943 else if (uLeaf == 0xb)
944 {
945 /* EDX: Initial extended APIC ID. */
946 AssertMsg(pLeaf->uEdx == 0, ("%#x\n", pLeaf->uEdx)); /* raw-mode assumption */
947 *pEdx = pVCpu->idCpu;
948 Assert(!(pLeaf->fFlags & ~(CPUMCPUIDLEAF_F_CONTAINS_APIC_ID | CPUMCPUIDLEAF_F_INTEL_TOPOLOGY_SUBLEAVES)));
949 }
950 else if (uLeaf == UINT32_C(0x8000001e))
951 {
952 /* EAX: Initial extended APIC ID. */
953 AssertMsg(pLeaf->uEax == 0, ("%#x\n", pLeaf->uEax)); /* raw-mode assumption */
954 *pEax = pVCpu->idCpu;
955 Assert(!(pLeaf->fFlags & ~CPUMCPUIDLEAF_F_CONTAINS_APIC_ID));
956 }
957 else if (uLeaf == UINT32_C(0x80000001))
958 {
959 /* EDX: Bit 9: AND with APICBASE.EN. */
960 if (!pVCpu->cpum.s.fCpuIdApicFeatureVisible)
961 *pEdx &= ~X86_CPUID_AMD_FEATURE_EDX_APIC;
962 Assert(!(pLeaf->fFlags & ~CPUMCPUIDLEAF_F_CONTAINS_APIC));
963 }
964 else
965 AssertMsgFailed(("uLeaf=%#x\n", uLeaf));
966 }
967 }
968 /*
969 * Out of range sub-leaves aren't quite as easy and pretty as we emulate
970 * them here, but we do the best we can here...
971 */
972 else
973 {
974 *pEax = *pEbx = *pEcx = *pEdx = 0;
975 if (pLeaf->fFlags & CPUMCPUIDLEAF_F_INTEL_TOPOLOGY_SUBLEAVES)
976 {
977 *pEcx = uSubLeaf & 0xff;
978 *pEdx = pVCpu->idCpu;
979 }
980 }
981 }
982 else
983 {
984 /*
985 * Different CPUs have different ways of dealing with unknown CPUID leaves.
986 */
987 switch (pVM->cpum.s.GuestInfo.enmUnknownCpuIdMethod)
988 {
989 default:
990 AssertFailed();
991 RT_FALL_THRU();
992 case CPUMUNKNOWNCPUID_DEFAULTS:
993 case CPUMUNKNOWNCPUID_LAST_STD_LEAF: /* ASSUME this is executed */
994 case CPUMUNKNOWNCPUID_LAST_STD_LEAF_WITH_ECX: /** @todo Implement CPUMUNKNOWNCPUID_LAST_STD_LEAF_WITH_ECX */
995 *pEax = pVM->cpum.s.GuestInfo.DefCpuId.uEax;
996 *pEbx = pVM->cpum.s.GuestInfo.DefCpuId.uEbx;
997 *pEcx = pVM->cpum.s.GuestInfo.DefCpuId.uEcx;
998 *pEdx = pVM->cpum.s.GuestInfo.DefCpuId.uEdx;
999 break;
1000 case CPUMUNKNOWNCPUID_PASSTHRU:
1001 *pEax = uLeaf;
1002 *pEbx = 0;
1003 *pEcx = uSubLeaf;
1004 *pEdx = 0;
1005 break;
1006 }
1007 }
1008 Log2(("CPUMGetGuestCpuId: uLeaf=%#010x/%#010x %RX32 %RX32 %RX32 %RX32\n", uLeaf, uSubLeaf, *pEax, *pEbx, *pEcx, *pEdx));
1009}
1010
1011
1012/**
1013 * Sets the visibility of the X86_CPUID_FEATURE_EDX_APIC and
1014 * X86_CPUID_AMD_FEATURE_EDX_APIC CPUID bits.
1015 *
1016 * @returns Previous value.
1017 * @param pVCpu The cross context virtual CPU structure to make the
1018 * change on. Usually the calling EMT.
1019 * @param fVisible Whether to make it visible (true) or hide it (false).
1020 *
1021 * @remarks This is "VMMDECL" so that it still links with
1022 * the old APIC code which is in VBoxDD2 and not in
1023 * the VMM module.
1024 */
1025VMMDECL(bool) CPUMSetGuestCpuIdPerCpuApicFeature(PVMCPU pVCpu, bool fVisible)
1026{
1027 bool fOld = pVCpu->cpum.s.fCpuIdApicFeatureVisible;
1028 pVCpu->cpum.s.fCpuIdApicFeatureVisible = fVisible;
1029 return fOld;
1030}
1031
1032
1033/**
1034 * Gets the host CPU vendor.
1035 *
1036 * @returns CPU vendor.
1037 * @param pVM The cross context VM structure.
1038 */
1039VMMDECL(CPUMCPUVENDOR) CPUMGetHostCpuVendor(PVM pVM)
1040{
1041 return (CPUMCPUVENDOR)pVM->cpum.s.HostFeatures.enmCpuVendor;
1042}
1043
1044
1045/**
1046 * Gets the host CPU microarchitecture.
1047 *
1048 * @returns CPU microarchitecture.
1049 * @param pVM The cross context VM structure.
1050 */
1051VMMDECL(CPUMMICROARCH) CPUMGetHostMicroarch(PCVM pVM)
1052{
1053 return pVM->cpum.s.HostFeatures.enmMicroarch;
1054}
1055
1056
1057/**
1058 * Gets the guest CPU vendor.
1059 *
1060 * @returns CPU vendor.
1061 * @param pVM The cross context VM structure.
1062 */
1063VMMDECL(CPUMCPUVENDOR) CPUMGetGuestCpuVendor(PVM pVM)
1064{
1065 return (CPUMCPUVENDOR)pVM->cpum.s.GuestFeatures.enmCpuVendor;
1066}
1067
1068
1069/**
1070 * Gets the guest CPU microarchitecture.
1071 *
1072 * @returns CPU microarchitecture.
1073 * @param pVM The cross context VM structure.
1074 */
1075VMMDECL(CPUMMICROARCH) CPUMGetGuestMicroarch(PCVM pVM)
1076{
1077 return pVM->cpum.s.GuestFeatures.enmMicroarch;
1078}
1079
1080
1081/**
1082 * Gets the maximum number of physical and linear address bits supported by the
1083 * guest.
1084 *
1085 * @param pVM The cross context VM structure.
1086 * @param pcPhysAddrWidth Where to store the physical address width.
1087 * @param pcLinearAddrWidth Where to store the linear address width.
1088 */
1089VMMDECL(void) CPUMGetGuestAddrWidths(PCVM pVM, uint8_t *pcPhysAddrWidth, uint8_t *pcLinearAddrWidth)
1090{
1091 AssertPtr(pVM);
1092 AssertReturnVoid(pcPhysAddrWidth);
1093 AssertReturnVoid(pcLinearAddrWidth);
1094 *pcPhysAddrWidth = pVM->cpum.s.GuestFeatures.cMaxPhysAddrWidth;
1095 *pcLinearAddrWidth = pVM->cpum.s.GuestFeatures.cMaxLinearAddrWidth;
1096}
1097
1098
1099VMMDECL(int) CPUMSetGuestDR0(PVMCPUCC pVCpu, uint64_t uDr0)
1100{
1101 pVCpu->cpum.s.Guest.dr[0] = uDr0;
1102 return CPUMRecalcHyperDRx(pVCpu, 0);
1103}
1104
1105
1106VMMDECL(int) CPUMSetGuestDR1(PVMCPUCC pVCpu, uint64_t uDr1)
1107{
1108 pVCpu->cpum.s.Guest.dr[1] = uDr1;
1109 return CPUMRecalcHyperDRx(pVCpu, 1);
1110}
1111
1112
1113VMMDECL(int) CPUMSetGuestDR2(PVMCPUCC pVCpu, uint64_t uDr2)
1114{
1115 pVCpu->cpum.s.Guest.dr[2] = uDr2;
1116 return CPUMRecalcHyperDRx(pVCpu, 2);
1117}
1118
1119
1120VMMDECL(int) CPUMSetGuestDR3(PVMCPUCC pVCpu, uint64_t uDr3)
1121{
1122 pVCpu->cpum.s.Guest.dr[3] = uDr3;
1123 return CPUMRecalcHyperDRx(pVCpu, 3);
1124}
1125
1126
1127VMMDECL(int) CPUMSetGuestDR6(PVMCPU pVCpu, uint64_t uDr6)
1128{
1129 pVCpu->cpum.s.Guest.dr[6] = uDr6;
1130 pVCpu->cpum.s.Guest.fExtrn &= ~CPUMCTX_EXTRN_DR6;
1131 return VINF_SUCCESS; /* No need to recalc. */
1132}
1133
1134
1135VMMDECL(int) CPUMSetGuestDR7(PVMCPUCC pVCpu, uint64_t uDr7)
1136{
1137 pVCpu->cpum.s.Guest.dr[7] = uDr7;
1138 pVCpu->cpum.s.Guest.fExtrn &= ~CPUMCTX_EXTRN_DR7;
1139 return CPUMRecalcHyperDRx(pVCpu, 7);
1140}
1141
1142
1143VMMDECL(int) CPUMSetGuestDRx(PVMCPUCC pVCpu, uint32_t iReg, uint64_t Value)
1144{
1145 AssertReturn(iReg <= DISDREG_DR7, VERR_INVALID_PARAMETER);
1146 /* DR4 is an alias for DR6, and DR5 is an alias for DR7. */
1147 if (iReg == 4 || iReg == 5)
1148 iReg += 2;
1149 pVCpu->cpum.s.Guest.dr[iReg] = Value;
1150 return CPUMRecalcHyperDRx(pVCpu, iReg);
1151}
1152
1153
1154/**
1155 * Recalculates the hypervisor DRx register values based on current guest
1156 * registers and DBGF breakpoints, updating changed registers depending on the
1157 * context.
1158 *
1159 * This is called whenever a guest DRx register is modified (any context) and
1160 * when DBGF sets a hardware breakpoint (ring-3 only, rendezvous).
1161 *
1162 * In raw-mode context this function will reload any (hyper) DRx registers which
1163 * comes out with a different value. It may also have to save the host debug
1164 * registers if that haven't been done already. In this context though, we'll
1165 * be intercepting and emulating all DRx accesses, so the hypervisor DRx values
1166 * are only important when breakpoints are actually enabled.
1167 *
1168 * In ring-0 (HM) context DR0-3 will be relocated by us, while DR7 will be
1169 * reloaded by the HM code if it changes. Further more, we will only use the
1170 * combined register set when the VBox debugger is actually using hardware BPs,
1171 * when it isn't we'll keep the guest DR0-3 + (maybe) DR6 loaded (DR6 doesn't
1172 * concern us here).
1173 *
1174 * In ring-3 we won't be loading anything, so well calculate hypervisor values
1175 * all the time.
1176 *
1177 * @returns VINF_SUCCESS.
1178 * @param pVCpu The cross context virtual CPU structure.
1179 * @param iGstReg The guest debug register number that was modified.
1180 * UINT8_MAX if not guest register.
1181 */
1182VMMDECL(int) CPUMRecalcHyperDRx(PVMCPUCC pVCpu, uint8_t iGstReg)
1183{
1184 PVM pVM = pVCpu->CTX_SUFF(pVM);
1185#ifndef IN_RING0
1186 RT_NOREF_PV(iGstReg);
1187#endif
1188
1189 /*
1190 * Compare the DR7s first.
1191 *
1192 * We only care about the enabled flags. GD is virtualized when we
1193 * dispatch the #DB, we never enable it. The DBGF DR7 value is will
1194 * always have the LE and GE bits set, so no need to check and disable
1195 * stuff if they're cleared like we have to for the guest DR7.
1196 */
1197 RTGCUINTREG uGstDr7 = CPUMGetGuestDR7(pVCpu);
1198 /** @todo This isn't correct. BPs work without setting LE and GE under AMD-V. They are also documented as unsupported by P6+. */
1199 if (!(uGstDr7 & (X86_DR7_LE | X86_DR7_GE)))
1200 uGstDr7 = 0;
1201 else if (!(uGstDr7 & X86_DR7_LE))
1202 uGstDr7 &= ~X86_DR7_LE_ALL;
1203 else if (!(uGstDr7 & X86_DR7_GE))
1204 uGstDr7 &= ~X86_DR7_GE_ALL;
1205
1206 const RTGCUINTREG uDbgfDr7 = DBGFBpGetDR7(pVM);
1207 if ((uGstDr7 | uDbgfDr7) & X86_DR7_ENABLED_MASK)
1208 {
1209 Assert(!CPUMIsGuestDebugStateActive(pVCpu));
1210
1211 /*
1212 * Ok, something is enabled. Recalc each of the breakpoints, taking
1213 * the VM debugger ones of the guest ones. In raw-mode context we will
1214 * not allow breakpoints with values inside the hypervisor area.
1215 */
1216 RTGCUINTREG uNewDr7 = X86_DR7_GE | X86_DR7_LE | X86_DR7_RA1_MASK;
1217
1218 /* bp 0 */
1219 RTGCUINTREG uNewDr0;
1220 if (uDbgfDr7 & (X86_DR7_L0 | X86_DR7_G0))
1221 {
1222 uNewDr7 |= uDbgfDr7 & (X86_DR7_L0 | X86_DR7_G0 | X86_DR7_RW0_MASK | X86_DR7_LEN0_MASK);
1223 uNewDr0 = DBGFBpGetDR0(pVM);
1224 }
1225 else if (uGstDr7 & (X86_DR7_L0 | X86_DR7_G0))
1226 {
1227 uNewDr0 = CPUMGetGuestDR0(pVCpu);
1228 uNewDr7 |= uGstDr7 & (X86_DR7_L0 | X86_DR7_G0 | X86_DR7_RW0_MASK | X86_DR7_LEN0_MASK);
1229 }
1230 else
1231 uNewDr0 = 0;
1232
1233 /* bp 1 */
1234 RTGCUINTREG uNewDr1;
1235 if (uDbgfDr7 & (X86_DR7_L1 | X86_DR7_G1))
1236 {
1237 uNewDr7 |= uDbgfDr7 & (X86_DR7_L1 | X86_DR7_G1 | X86_DR7_RW1_MASK | X86_DR7_LEN1_MASK);
1238 uNewDr1 = DBGFBpGetDR1(pVM);
1239 }
1240 else if (uGstDr7 & (X86_DR7_L1 | X86_DR7_G1))
1241 {
1242 uNewDr1 = CPUMGetGuestDR1(pVCpu);
1243 uNewDr7 |= uGstDr7 & (X86_DR7_L1 | X86_DR7_G1 | X86_DR7_RW1_MASK | X86_DR7_LEN1_MASK);
1244 }
1245 else
1246 uNewDr1 = 0;
1247
1248 /* bp 2 */
1249 RTGCUINTREG uNewDr2;
1250 if (uDbgfDr7 & (X86_DR7_L2 | X86_DR7_G2))
1251 {
1252 uNewDr7 |= uDbgfDr7 & (X86_DR7_L2 | X86_DR7_G2 | X86_DR7_RW2_MASK | X86_DR7_LEN2_MASK);
1253 uNewDr2 = DBGFBpGetDR2(pVM);
1254 }
1255 else if (uGstDr7 & (X86_DR7_L2 | X86_DR7_G2))
1256 {
1257 uNewDr2 = CPUMGetGuestDR2(pVCpu);
1258 uNewDr7 |= uGstDr7 & (X86_DR7_L2 | X86_DR7_G2 | X86_DR7_RW2_MASK | X86_DR7_LEN2_MASK);
1259 }
1260 else
1261 uNewDr2 = 0;
1262
1263 /* bp 3 */
1264 RTGCUINTREG uNewDr3;
1265 if (uDbgfDr7 & (X86_DR7_L3 | X86_DR7_G3))
1266 {
1267 uNewDr7 |= uDbgfDr7 & (X86_DR7_L3 | X86_DR7_G3 | X86_DR7_RW3_MASK | X86_DR7_LEN3_MASK);
1268 uNewDr3 = DBGFBpGetDR3(pVM);
1269 }
1270 else if (uGstDr7 & (X86_DR7_L3 | X86_DR7_G3))
1271 {
1272 uNewDr3 = CPUMGetGuestDR3(pVCpu);
1273 uNewDr7 |= uGstDr7 & (X86_DR7_L3 | X86_DR7_G3 | X86_DR7_RW3_MASK | X86_DR7_LEN3_MASK);
1274 }
1275 else
1276 uNewDr3 = 0;
1277
1278 /*
1279 * Apply the updates.
1280 */
1281 pVCpu->cpum.s.fUseFlags |= CPUM_USE_DEBUG_REGS_HYPER;
1282 if (uNewDr3 != pVCpu->cpum.s.Hyper.dr[3])
1283 CPUMSetHyperDR3(pVCpu, uNewDr3);
1284 if (uNewDr2 != pVCpu->cpum.s.Hyper.dr[2])
1285 CPUMSetHyperDR2(pVCpu, uNewDr2);
1286 if (uNewDr1 != pVCpu->cpum.s.Hyper.dr[1])
1287 CPUMSetHyperDR1(pVCpu, uNewDr1);
1288 if (uNewDr0 != pVCpu->cpum.s.Hyper.dr[0])
1289 CPUMSetHyperDR0(pVCpu, uNewDr0);
1290 if (uNewDr7 != pVCpu->cpum.s.Hyper.dr[7])
1291 CPUMSetHyperDR7(pVCpu, uNewDr7);
1292 }
1293#ifdef IN_RING0
1294 else if (CPUMIsGuestDebugStateActive(pVCpu))
1295 {
1296 /*
1297 * Reload the register that was modified. Normally this won't happen
1298 * as we won't intercept DRx writes when not having the hyper debug
1299 * state loaded, but in case we do for some reason we'll simply deal
1300 * with it.
1301 */
1302 switch (iGstReg)
1303 {
1304 case 0: ASMSetDR0(CPUMGetGuestDR0(pVCpu)); break;
1305 case 1: ASMSetDR1(CPUMGetGuestDR1(pVCpu)); break;
1306 case 2: ASMSetDR2(CPUMGetGuestDR2(pVCpu)); break;
1307 case 3: ASMSetDR3(CPUMGetGuestDR3(pVCpu)); break;
1308 default:
1309 AssertReturn(iGstReg != UINT8_MAX, VERR_INTERNAL_ERROR_3);
1310 }
1311 }
1312#endif
1313 else
1314 {
1315 /*
1316 * No active debug state any more. In raw-mode this means we have to
1317 * make sure DR7 has everything disabled now, if we armed it already.
1318 * In ring-0 we might end up here when just single stepping.
1319 */
1320#ifdef IN_RING0
1321 if (pVCpu->cpum.s.fUseFlags & CPUM_USED_DEBUG_REGS_HYPER)
1322 {
1323 if (pVCpu->cpum.s.Hyper.dr[0])
1324 ASMSetDR0(0);
1325 if (pVCpu->cpum.s.Hyper.dr[1])
1326 ASMSetDR1(0);
1327 if (pVCpu->cpum.s.Hyper.dr[2])
1328 ASMSetDR2(0);
1329 if (pVCpu->cpum.s.Hyper.dr[3])
1330 ASMSetDR3(0);
1331 pVCpu->cpum.s.fUseFlags &= ~CPUM_USED_DEBUG_REGS_HYPER;
1332 }
1333#endif
1334 pVCpu->cpum.s.fUseFlags &= ~CPUM_USE_DEBUG_REGS_HYPER;
1335
1336 /* Clear all the registers. */
1337 pVCpu->cpum.s.Hyper.dr[7] = X86_DR7_RA1_MASK;
1338 pVCpu->cpum.s.Hyper.dr[3] = 0;
1339 pVCpu->cpum.s.Hyper.dr[2] = 0;
1340 pVCpu->cpum.s.Hyper.dr[1] = 0;
1341 pVCpu->cpum.s.Hyper.dr[0] = 0;
1342
1343 }
1344 Log2(("CPUMRecalcHyperDRx: fUseFlags=%#x %RGr %RGr %RGr %RGr %RGr %RGr\n",
1345 pVCpu->cpum.s.fUseFlags, pVCpu->cpum.s.Hyper.dr[0], pVCpu->cpum.s.Hyper.dr[1],
1346 pVCpu->cpum.s.Hyper.dr[2], pVCpu->cpum.s.Hyper.dr[3], pVCpu->cpum.s.Hyper.dr[6],
1347 pVCpu->cpum.s.Hyper.dr[7]));
1348
1349 return VINF_SUCCESS;
1350}
1351
1352
1353/**
1354 * Set the guest XCR0 register.
1355 *
1356 * Will load additional state if the FPU state is already loaded (in ring-0 &
1357 * raw-mode context).
1358 *
1359 * @returns VINF_SUCCESS on success, VERR_CPUM_RAISE_GP_0 on invalid input
1360 * value.
1361 * @param pVCpu The cross context virtual CPU structure of the calling EMT.
1362 * @param uNewValue The new value.
1363 * @thread EMT(pVCpu)
1364 */
1365VMM_INT_DECL(int) CPUMSetGuestXcr0(PVMCPUCC pVCpu, uint64_t uNewValue)
1366{
1367 CPUM_INT_ASSERT_NOT_EXTRN(pVCpu, CPUMCTX_EXTRN_XCRx);
1368 if ( (uNewValue & ~pVCpu->CTX_SUFF(pVM)->cpum.s.fXStateGuestMask) == 0
1369 /* The X87 bit cannot be cleared. */
1370 && (uNewValue & XSAVE_C_X87)
1371 /* AVX requires SSE. */
1372 && (uNewValue & (XSAVE_C_SSE | XSAVE_C_YMM)) != XSAVE_C_YMM
1373 /* AVX-512 requires YMM, SSE and all of its three components to be enabled. */
1374 && ( (uNewValue & (XSAVE_C_OPMASK | XSAVE_C_ZMM_HI256 | XSAVE_C_ZMM_16HI)) == 0
1375 || (uNewValue & (XSAVE_C_SSE | XSAVE_C_YMM | XSAVE_C_OPMASK | XSAVE_C_ZMM_HI256 | XSAVE_C_ZMM_16HI))
1376 == (XSAVE_C_SSE | XSAVE_C_YMM | XSAVE_C_OPMASK | XSAVE_C_ZMM_HI256 | XSAVE_C_ZMM_16HI) )
1377 )
1378 {
1379 pVCpu->cpum.s.Guest.aXcr[0] = uNewValue;
1380
1381 /* If more state components are enabled, we need to take care to load
1382 them if the FPU/SSE state is already loaded. May otherwise leak
1383 host state to the guest. */
1384 uint64_t fNewComponents = ~pVCpu->cpum.s.Guest.fXStateMask & uNewValue;
1385 if (fNewComponents)
1386 {
1387#ifdef IN_RING0
1388 if (pVCpu->cpum.s.fUseFlags & CPUM_USED_FPU_GUEST)
1389 {
1390 if (pVCpu->cpum.s.Guest.fXStateMask != 0)
1391 /* Adding more components. */
1392 ASMXRstor(&pVCpu->cpum.s.Guest.XState, fNewComponents);
1393 else
1394 {
1395 /* We're switching from FXSAVE/FXRSTOR to XSAVE/XRSTOR. */
1396 pVCpu->cpum.s.Guest.fXStateMask |= XSAVE_C_X87 | XSAVE_C_SSE;
1397 if (uNewValue & ~(XSAVE_C_X87 | XSAVE_C_SSE))
1398 ASMXRstor(&pVCpu->cpum.s.Guest.XState, uNewValue & ~(XSAVE_C_X87 | XSAVE_C_SSE));
1399 }
1400 }
1401#endif
1402 pVCpu->cpum.s.Guest.fXStateMask |= uNewValue;
1403 }
1404 return VINF_SUCCESS;
1405 }
1406 return VERR_CPUM_RAISE_GP_0;
1407}
1408
1409
1410/**
1411 * Tests if the guest has No-Execute Page Protection Enabled (NXE).
1412 *
1413 * @returns true if in real mode, otherwise false.
1414 * @param pVCpu The cross context virtual CPU structure.
1415 */
1416VMMDECL(bool) CPUMIsGuestNXEnabled(PCVMCPU pVCpu)
1417{
1418 CPUM_INT_ASSERT_NOT_EXTRN(pVCpu, CPUMCTX_EXTRN_EFER);
1419 return !!(pVCpu->cpum.s.Guest.msrEFER & MSR_K6_EFER_NXE);
1420}
1421
1422
1423/**
1424 * Tests if the guest has the Page Size Extension enabled (PSE).
1425 *
1426 * @returns true if in real mode, otherwise false.
1427 * @param pVCpu The cross context virtual CPU structure.
1428 */
1429VMMDECL(bool) CPUMIsGuestPageSizeExtEnabled(PCVMCPU pVCpu)
1430{
1431 CPUM_INT_ASSERT_NOT_EXTRN(pVCpu, CPUMCTX_EXTRN_CR4);
1432 /* PAE or AMD64 implies support for big pages regardless of CR4.PSE */
1433 return !!(pVCpu->cpum.s.Guest.cr4 & (X86_CR4_PSE | X86_CR4_PAE));
1434}
1435
1436
1437/**
1438 * Tests if the guest has the paging enabled (PG).
1439 *
1440 * @returns true if in real mode, otherwise false.
1441 * @param pVCpu The cross context virtual CPU structure.
1442 */
1443VMMDECL(bool) CPUMIsGuestPagingEnabled(PCVMCPU pVCpu)
1444{
1445 CPUM_INT_ASSERT_NOT_EXTRN(pVCpu, CPUMCTX_EXTRN_CR0);
1446 return !!(pVCpu->cpum.s.Guest.cr0 & X86_CR0_PG);
1447}
1448
1449
1450/**
1451 * Tests if the guest has the paging enabled (PG).
1452 *
1453 * @returns true if in real mode, otherwise false.
1454 * @param pVCpu The cross context virtual CPU structure.
1455 */
1456VMMDECL(bool) CPUMIsGuestR0WriteProtEnabled(PCVMCPU pVCpu)
1457{
1458 CPUM_INT_ASSERT_NOT_EXTRN(pVCpu, CPUMCTX_EXTRN_CR0);
1459 return !!(pVCpu->cpum.s.Guest.cr0 & X86_CR0_WP);
1460}
1461
1462
1463/**
1464 * Tests if the guest is running in real mode or not.
1465 *
1466 * @returns true if in real mode, otherwise false.
1467 * @param pVCpu The cross context virtual CPU structure.
1468 */
1469VMMDECL(bool) CPUMIsGuestInRealMode(PCVMCPU pVCpu)
1470{
1471 CPUM_INT_ASSERT_NOT_EXTRN(pVCpu, CPUMCTX_EXTRN_CR0);
1472 return !(pVCpu->cpum.s.Guest.cr0 & X86_CR0_PE);
1473}
1474
1475
1476/**
1477 * Tests if the guest is running in real or virtual 8086 mode.
1478 *
1479 * @returns @c true if it is, @c false if not.
1480 * @param pVCpu The cross context virtual CPU structure.
1481 */
1482VMMDECL(bool) CPUMIsGuestInRealOrV86Mode(PCVMCPU pVCpu)
1483{
1484 CPUM_INT_ASSERT_NOT_EXTRN(pVCpu, CPUMCTX_EXTRN_CR0 | CPUMCTX_EXTRN_RFLAGS);
1485 return !(pVCpu->cpum.s.Guest.cr0 & X86_CR0_PE)
1486 || pVCpu->cpum.s.Guest.eflags.Bits.u1VM; /** @todo verify that this cannot be set in long mode. */
1487}
1488
1489
1490/**
1491 * Tests if the guest is running in protected or not.
1492 *
1493 * @returns true if in protected mode, otherwise false.
1494 * @param pVCpu The cross context virtual CPU structure.
1495 */
1496VMMDECL(bool) CPUMIsGuestInProtectedMode(PCVMCPU pVCpu)
1497{
1498 CPUM_INT_ASSERT_NOT_EXTRN(pVCpu, CPUMCTX_EXTRN_CR0);
1499 return !!(pVCpu->cpum.s.Guest.cr0 & X86_CR0_PE);
1500}
1501
1502
1503/**
1504 * Tests if the guest is running in paged protected or not.
1505 *
1506 * @returns true if in paged protected mode, otherwise false.
1507 * @param pVCpu The cross context virtual CPU structure.
1508 */
1509VMMDECL(bool) CPUMIsGuestInPagedProtectedMode(PCVMCPU pVCpu)
1510{
1511 CPUM_INT_ASSERT_NOT_EXTRN(pVCpu, CPUMCTX_EXTRN_CR0);
1512 return (pVCpu->cpum.s.Guest.cr0 & (X86_CR0_PE | X86_CR0_PG)) == (X86_CR0_PE | X86_CR0_PG);
1513}
1514
1515
1516/**
1517 * Tests if the guest is running in long mode or not.
1518 *
1519 * @returns true if in long mode, otherwise false.
1520 * @param pVCpu The cross context virtual CPU structure.
1521 */
1522VMMDECL(bool) CPUMIsGuestInLongMode(PCVMCPU pVCpu)
1523{
1524 CPUM_INT_ASSERT_NOT_EXTRN(pVCpu, CPUMCTX_EXTRN_EFER);
1525 return (pVCpu->cpum.s.Guest.msrEFER & MSR_K6_EFER_LMA) == MSR_K6_EFER_LMA;
1526}
1527
1528
1529/**
1530 * Tests if the guest is running in PAE mode or not.
1531 *
1532 * @returns true if in PAE mode, otherwise false.
1533 * @param pVCpu The cross context virtual CPU structure.
1534 */
1535VMMDECL(bool) CPUMIsGuestInPAEMode(PCVMCPU pVCpu)
1536{
1537 CPUM_INT_ASSERT_NOT_EXTRN(pVCpu, CPUMCTX_EXTRN_CR4 | CPUMCTX_EXTRN_CR0 | CPUMCTX_EXTRN_EFER);
1538 /* Intel mentions EFER.LMA and EFER.LME in different parts of their spec. We shall use EFER.LMA rather
1539 than EFER.LME as it reflects if the CPU has entered paging with EFER.LME set. */
1540 return (pVCpu->cpum.s.Guest.cr4 & X86_CR4_PAE)
1541 && (pVCpu->cpum.s.Guest.cr0 & X86_CR0_PG)
1542 && !(pVCpu->cpum.s.Guest.msrEFER & MSR_K6_EFER_LMA);
1543}
1544
1545
1546/**
1547 * Tests if the guest is running in 64 bits mode or not.
1548 *
1549 * @returns true if in 64 bits protected mode, otherwise false.
1550 * @param pVCpu The cross context virtual CPU structure of the calling EMT.
1551 */
1552VMMDECL(bool) CPUMIsGuestIn64BitCode(PVMCPU pVCpu)
1553{
1554 CPUM_INT_ASSERT_NOT_EXTRN(pVCpu, CPUMCTX_EXTRN_CS | CPUMCTX_EXTRN_EFER);
1555 if (!CPUMIsGuestInLongMode(pVCpu))
1556 return false;
1557 CPUMSELREG_LAZY_LOAD_HIDDEN_PARTS(pVCpu, &pVCpu->cpum.s.Guest.cs);
1558 return pVCpu->cpum.s.Guest.cs.Attr.n.u1Long;
1559}
1560
1561
1562/**
1563 * Helper for CPUMIsGuestIn64BitCodeEx that handles lazy resolving of hidden CS
1564 * registers.
1565 *
1566 * @returns true if in 64 bits protected mode, otherwise false.
1567 * @param pCtx Pointer to the current guest CPU context.
1568 */
1569VMM_INT_DECL(bool) CPUMIsGuestIn64BitCodeSlow(PCPUMCTX pCtx)
1570{
1571 return CPUMIsGuestIn64BitCode(CPUM_GUEST_CTX_TO_VMCPU(pCtx));
1572}
1573
1574
1575/**
1576 * Sets the specified changed flags (CPUM_CHANGED_*).
1577 *
1578 * @param pVCpu The cross context virtual CPU structure of the calling EMT.
1579 * @param fChangedAdd The changed flags to add.
1580 */
1581VMMDECL(void) CPUMSetChangedFlags(PVMCPU pVCpu, uint32_t fChangedAdd)
1582{
1583 pVCpu->cpum.s.fChanged |= fChangedAdd;
1584}
1585
1586
1587/**
1588 * Checks if the CPU supports the XSAVE and XRSTOR instruction.
1589 *
1590 * @returns true if supported.
1591 * @returns false if not supported.
1592 * @param pVM The cross context VM structure.
1593 */
1594VMMDECL(bool) CPUMSupportsXSave(PVM pVM)
1595{
1596 return pVM->cpum.s.HostFeatures.fXSaveRstor != 0;
1597}
1598
1599
1600/**
1601 * Checks if the host OS uses the SYSENTER / SYSEXIT instructions.
1602 * @returns true if used.
1603 * @returns false if not used.
1604 * @param pVM The cross context VM structure.
1605 */
1606VMMDECL(bool) CPUMIsHostUsingSysEnter(PVM pVM)
1607{
1608 return RT_BOOL(pVM->cpum.s.fHostUseFlags & CPUM_USE_SYSENTER);
1609}
1610
1611
1612/**
1613 * Checks if the host OS uses the SYSCALL / SYSRET instructions.
1614 * @returns true if used.
1615 * @returns false if not used.
1616 * @param pVM The cross context VM structure.
1617 */
1618VMMDECL(bool) CPUMIsHostUsingSysCall(PVM pVM)
1619{
1620 return RT_BOOL(pVM->cpum.s.fHostUseFlags & CPUM_USE_SYSCALL);
1621}
1622
1623
1624/**
1625 * Checks if we activated the FPU/XMM state of the guest OS.
1626 *
1627 * Obsolete: This differs from CPUMIsGuestFPUStateLoaded() in that it refers to
1628 * the next time we'll be executing guest code, so it may return true for
1629 * 64-on-32 when we still haven't actually loaded the FPU status, just scheduled
1630 * it to be loaded the next time we go thru the world switcher
1631 * (CPUM_SYNC_FPU_STATE).
1632 *
1633 * @returns true / false.
1634 * @param pVCpu The cross context virtual CPU structure.
1635 */
1636VMMDECL(bool) CPUMIsGuestFPUStateActive(PVMCPU pVCpu)
1637{
1638 bool fRet = RT_BOOL(pVCpu->cpum.s.fUseFlags & CPUM_USED_FPU_GUEST);
1639 AssertMsg(fRet == pVCpu->cpum.s.Guest.fUsedFpuGuest, ("fRet=%d\n", fRet));
1640 return fRet;
1641}
1642
1643
1644/**
1645 * Checks if we've really loaded the FPU/XMM state of the guest OS.
1646 *
1647 * @returns true / false.
1648 * @param pVCpu The cross context virtual CPU structure.
1649 */
1650VMMDECL(bool) CPUMIsGuestFPUStateLoaded(PVMCPU pVCpu)
1651{
1652 bool fRet = RT_BOOL(pVCpu->cpum.s.fUseFlags & CPUM_USED_FPU_GUEST);
1653 AssertMsg(fRet == pVCpu->cpum.s.Guest.fUsedFpuGuest, ("fRet=%d\n", fRet));
1654 return fRet;
1655}
1656
1657
1658/**
1659 * Checks if we saved the FPU/XMM state of the host OS.
1660 *
1661 * @returns true / false.
1662 * @param pVCpu The cross context virtual CPU structure.
1663 */
1664VMMDECL(bool) CPUMIsHostFPUStateSaved(PVMCPU pVCpu)
1665{
1666 return RT_BOOL(pVCpu->cpum.s.fUseFlags & CPUM_USED_FPU_HOST);
1667}
1668
1669
1670/**
1671 * Checks if the guest debug state is active.
1672 *
1673 * @returns boolean
1674 * @param pVCpu The cross context virtual CPU structure of the calling EMT.
1675 */
1676VMMDECL(bool) CPUMIsGuestDebugStateActive(PVMCPU pVCpu)
1677{
1678 return RT_BOOL(pVCpu->cpum.s.fUseFlags & CPUM_USED_DEBUG_REGS_GUEST);
1679}
1680
1681
1682/**
1683 * Checks if the hyper debug state is active.
1684 *
1685 * @returns boolean
1686 * @param pVCpu The cross context virtual CPU structure of the calling EMT.
1687 */
1688VMMDECL(bool) CPUMIsHyperDebugStateActive(PVMCPU pVCpu)
1689{
1690 return RT_BOOL(pVCpu->cpum.s.fUseFlags & CPUM_USED_DEBUG_REGS_HYPER);
1691}
1692
1693
1694/**
1695 * Mark the guest's debug state as inactive.
1696 *
1697 * @returns boolean
1698 * @param pVCpu The cross context virtual CPU structure of the calling EMT.
1699 * @todo This API doesn't make sense any more.
1700 */
1701VMMDECL(void) CPUMDeactivateGuestDebugState(PVMCPU pVCpu)
1702{
1703 Assert(!(pVCpu->cpum.s.fUseFlags & (CPUM_USED_DEBUG_REGS_GUEST | CPUM_USED_DEBUG_REGS_HYPER | CPUM_USED_DEBUG_REGS_HOST)));
1704 NOREF(pVCpu);
1705}
1706
1707
1708/**
1709 * Get the current privilege level of the guest.
1710 *
1711 * @returns CPL
1712 * @param pVCpu The cross context virtual CPU structure of the calling EMT.
1713 */
1714VMMDECL(uint32_t) CPUMGetGuestCPL(PVMCPU pVCpu)
1715{
1716 /*
1717 * CPL can reliably be found in SS.DPL (hidden regs valid) or SS if not.
1718 *
1719 * Note! We used to check CS.DPL here, assuming it was always equal to
1720 * CPL even if a conforming segment was loaded. But this turned out to
1721 * only apply to older AMD-V. With VT-x we had an ACP2 regression
1722 * during install after a far call to ring 2 with VT-x. Then on newer
1723 * AMD-V CPUs we have to move the VMCB.guest.u8CPL into cs.Attr.n.u2Dpl
1724 * as well as ss.Attr.n.u2Dpl to make this (and other) code work right.
1725 *
1726 * So, forget CS.DPL, always use SS.DPL.
1727 *
1728 * Note! The SS RPL is always equal to the CPL, while the CS RPL
1729 * isn't necessarily equal if the segment is conforming.
1730 * See section 4.11.1 in the AMD manual.
1731 *
1732 * Update: Where the heck does it say CS.RPL can differ from CPL other than
1733 * right after real->prot mode switch and when in V8086 mode? That
1734 * section says the RPL specified in a direct transfere (call, jmp,
1735 * ret) is not the one loaded into CS. Besides, if CS.RPL != CPL
1736 * it would be impossible for an exception handle or the iret
1737 * instruction to figure out whether SS:ESP are part of the frame
1738 * or not. VBox or qemu bug must've lead to this misconception.
1739 *
1740 * Update2: On an AMD bulldozer system here, I've no trouble loading a null
1741 * selector into SS with an RPL other than the CPL when CPL != 3 and
1742 * we're in 64-bit mode. The intel dev box doesn't allow this, on
1743 * RPL = CPL. Weird.
1744 */
1745 CPUM_INT_ASSERT_NOT_EXTRN(pVCpu, CPUMCTX_EXTRN_CR0 | CPUMCTX_EXTRN_RFLAGS | CPUMCTX_EXTRN_SS);
1746 uint32_t uCpl;
1747 if (pVCpu->cpum.s.Guest.cr0 & X86_CR0_PE)
1748 {
1749 if (!pVCpu->cpum.s.Guest.eflags.Bits.u1VM)
1750 {
1751 if (CPUMSELREG_ARE_HIDDEN_PARTS_VALID(pVCpu, &pVCpu->cpum.s.Guest.ss))
1752 uCpl = pVCpu->cpum.s.Guest.ss.Attr.n.u2Dpl;
1753 else
1754 uCpl = (pVCpu->cpum.s.Guest.ss.Sel & X86_SEL_RPL);
1755 }
1756 else
1757 uCpl = 3; /* V86 has CPL=3; REM doesn't set DPL=3 in V8086 mode. See @bugref{5130}. */
1758 }
1759 else
1760 uCpl = 0; /* Real mode is zero; CPL set to 3 for VT-x real-mode emulation. */
1761 return uCpl;
1762}
1763
1764
1765/**
1766 * Gets the current guest CPU mode.
1767 *
1768 * If paging mode is what you need, check out PGMGetGuestMode().
1769 *
1770 * @returns The CPU mode.
1771 * @param pVCpu The cross context virtual CPU structure.
1772 */
1773VMMDECL(CPUMMODE) CPUMGetGuestMode(PVMCPU pVCpu)
1774{
1775 CPUM_INT_ASSERT_NOT_EXTRN(pVCpu, CPUMCTX_EXTRN_CR0 | CPUMCTX_EXTRN_EFER);
1776 CPUMMODE enmMode;
1777 if (!(pVCpu->cpum.s.Guest.cr0 & X86_CR0_PE))
1778 enmMode = CPUMMODE_REAL;
1779 else if (!(pVCpu->cpum.s.Guest.msrEFER & MSR_K6_EFER_LMA))
1780 enmMode = CPUMMODE_PROTECTED;
1781 else
1782 enmMode = CPUMMODE_LONG;
1783
1784 return enmMode;
1785}
1786
1787
1788/**
1789 * Figure whether the CPU is currently executing 16, 32 or 64 bit code.
1790 *
1791 * @returns 16, 32 or 64.
1792 * @param pVCpu The cross context virtual CPU structure of the calling EMT.
1793 */
1794VMMDECL(uint32_t) CPUMGetGuestCodeBits(PVMCPU pVCpu)
1795{
1796 CPUM_INT_ASSERT_NOT_EXTRN(pVCpu, CPUMCTX_EXTRN_CR0 | CPUMCTX_EXTRN_EFER | CPUMCTX_EXTRN_RFLAGS | CPUMCTX_EXTRN_CS);
1797
1798 if (!(pVCpu->cpum.s.Guest.cr0 & X86_CR0_PE))
1799 return 16;
1800
1801 if (pVCpu->cpum.s.Guest.eflags.Bits.u1VM)
1802 {
1803 Assert(!(pVCpu->cpum.s.Guest.msrEFER & MSR_K6_EFER_LMA));
1804 return 16;
1805 }
1806
1807 CPUMSELREG_LAZY_LOAD_HIDDEN_PARTS(pVCpu, &pVCpu->cpum.s.Guest.cs);
1808 if ( pVCpu->cpum.s.Guest.cs.Attr.n.u1Long
1809 && (pVCpu->cpum.s.Guest.msrEFER & MSR_K6_EFER_LMA))
1810 return 64;
1811
1812 if (pVCpu->cpum.s.Guest.cs.Attr.n.u1DefBig)
1813 return 32;
1814
1815 return 16;
1816}
1817
1818
1819VMMDECL(DISCPUMODE) CPUMGetGuestDisMode(PVMCPU pVCpu)
1820{
1821 CPUM_INT_ASSERT_NOT_EXTRN(pVCpu, CPUMCTX_EXTRN_CR0 | CPUMCTX_EXTRN_EFER | CPUMCTX_EXTRN_RFLAGS | CPUMCTX_EXTRN_CS);
1822
1823 if (!(pVCpu->cpum.s.Guest.cr0 & X86_CR0_PE))
1824 return DISCPUMODE_16BIT;
1825
1826 if (pVCpu->cpum.s.Guest.eflags.Bits.u1VM)
1827 {
1828 Assert(!(pVCpu->cpum.s.Guest.msrEFER & MSR_K6_EFER_LMA));
1829 return DISCPUMODE_16BIT;
1830 }
1831
1832 CPUMSELREG_LAZY_LOAD_HIDDEN_PARTS(pVCpu, &pVCpu->cpum.s.Guest.cs);
1833 if ( pVCpu->cpum.s.Guest.cs.Attr.n.u1Long
1834 && (pVCpu->cpum.s.Guest.msrEFER & MSR_K6_EFER_LMA))
1835 return DISCPUMODE_64BIT;
1836
1837 if (pVCpu->cpum.s.Guest.cs.Attr.n.u1DefBig)
1838 return DISCPUMODE_32BIT;
1839
1840 return DISCPUMODE_16BIT;
1841}
1842
1843
1844/**
1845 * Gets the guest MXCSR_MASK value.
1846 *
1847 * This does not access the x87 state, but the value we determined at VM
1848 * initialization.
1849 *
1850 * @returns MXCSR mask.
1851 * @param pVM The cross context VM structure.
1852 */
1853VMMDECL(uint32_t) CPUMGetGuestMxCsrMask(PVM pVM)
1854{
1855 return pVM->cpum.s.GuestInfo.fMxCsrMask;
1856}
1857
1858
1859/**
1860 * Returns whether the guest has physical interrupts enabled.
1861 *
1862 * @returns @c true if interrupts are enabled, @c false otherwise.
1863 * @param pVCpu The cross context virtual CPU structure.
1864 *
1865 * @remarks Warning! This function does -not- take into account the global-interrupt
1866 * flag (GIF).
1867 */
1868VMM_INT_DECL(bool) CPUMIsGuestPhysIntrEnabled(PVMCPU pVCpu)
1869{
1870 if (!CPUMIsGuestInNestedHwvirtMode(&pVCpu->cpum.s.Guest))
1871 {
1872 uint32_t const fEFlags = pVCpu->cpum.s.Guest.eflags.u;
1873 return RT_BOOL(fEFlags & X86_EFL_IF);
1874 }
1875
1876 if (CPUMIsGuestInVmxNonRootMode(&pVCpu->cpum.s.Guest))
1877 return CPUMIsGuestVmxPhysIntrEnabled(&pVCpu->cpum.s.Guest);
1878
1879 Assert(CPUMIsGuestInSvmNestedHwVirtMode(&pVCpu->cpum.s.Guest));
1880 return CPUMIsGuestSvmPhysIntrEnabled(pVCpu, &pVCpu->cpum.s.Guest);
1881}
1882
1883
1884/**
1885 * Returns whether the nested-guest has virtual interrupts enabled.
1886 *
1887 * @returns @c true if interrupts are enabled, @c false otherwise.
1888 * @param pVCpu The cross context virtual CPU structure.
1889 *
1890 * @remarks Warning! This function does -not- take into account the global-interrupt
1891 * flag (GIF).
1892 */
1893VMM_INT_DECL(bool) CPUMIsGuestVirtIntrEnabled(PVMCPU pVCpu)
1894{
1895 PCCPUMCTX pCtx = &pVCpu->cpum.s.Guest;
1896 Assert(CPUMIsGuestInNestedHwvirtMode(pCtx));
1897
1898 if (CPUMIsGuestInVmxNonRootMode(pCtx))
1899 return CPUMIsGuestVmxVirtIntrEnabled(pCtx);
1900
1901 Assert(CPUMIsGuestInSvmNestedHwVirtMode(pCtx));
1902 return CPUMIsGuestSvmVirtIntrEnabled(pVCpu, pCtx);
1903}
1904
1905
1906/**
1907 * Calculates the interruptiblity of the guest.
1908 *
1909 * @returns Interruptibility level.
1910 * @param pVCpu The cross context virtual CPU structure.
1911 */
1912VMM_INT_DECL(CPUMINTERRUPTIBILITY) CPUMGetGuestInterruptibility(PVMCPU pVCpu)
1913{
1914#if 1
1915 /* Global-interrupt flag blocks pretty much everything we care about here. */
1916 if (CPUMGetGuestGif(&pVCpu->cpum.s.Guest))
1917 {
1918 /*
1919 * Physical interrupts are primarily blocked using EFLAGS. However, we cannot access
1920 * it directly here. If and how EFLAGS are used depends on the context (nested-guest
1921 * or raw-mode). Hence we use the function below which handles the details.
1922 */
1923 if ( CPUMIsGuestPhysIntrEnabled(pVCpu)
1924 && !VMCPU_FF_IS_ANY_SET(pVCpu, VMCPU_FF_BLOCK_NMIS | VMCPU_FF_INHIBIT_INTERRUPTS))
1925 {
1926 if ( !CPUMIsGuestInNestedHwvirtMode(&pVCpu->cpum.s.Guest)
1927 || CPUMIsGuestVirtIntrEnabled(pVCpu))
1928 return CPUMINTERRUPTIBILITY_UNRESTRAINED;
1929
1930 /* Physical interrupts are enabled, but nested-guest virtual interrupts are disabled. */
1931 return CPUMINTERRUPTIBILITY_VIRT_INT_DISABLED;
1932 }
1933
1934 /*
1935 * Blocking the delivery of NMIs during an interrupt shadow is CPU implementation
1936 * specific. Therefore, in practice, we can't deliver an NMI in an interrupt shadow.
1937 * However, there is some uncertainity regarding the converse, i.e. whether
1938 * NMI-blocking until IRET blocks delivery of physical interrupts.
1939 *
1940 * See Intel spec. 25.4.1 "Event Blocking".
1941 */
1942 if (VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_BLOCK_NMIS))
1943 return CPUMINTERRUPTIBILITY_NMI_INHIBIT;
1944
1945 if (VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS))
1946 return CPUMINTERRUPTIBILITY_INT_INHIBITED;
1947
1948 return CPUMINTERRUPTIBILITY_INT_DISABLED;
1949 }
1950 return CPUMINTERRUPTIBILITY_GLOBAL_INHIBIT;
1951#else
1952 if (pVCpu->cpum.s.Guest.rflags.Bits.u1IF)
1953 {
1954 if (pVCpu->cpum.s.Guest.hwvirt.fGif)
1955 {
1956 if (!VMCPU_FF_IS_ANY_SET(pVCpu, VMCPU_FF_BLOCK_NMIS | VMCPU_FF_INHIBIT_INTERRUPTS))
1957 return CPUMINTERRUPTIBILITY_UNRESTRAINED;
1958
1959 /** @todo does blocking NMIs mean interrupts are also inhibited? */
1960 if (VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS))
1961 {
1962 if (!VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_BLOCK_NMIS))
1963 return CPUMINTERRUPTIBILITY_INT_INHIBITED;
1964 return CPUMINTERRUPTIBILITY_NMI_INHIBIT;
1965 }
1966 AssertFailed();
1967 return CPUMINTERRUPTIBILITY_NMI_INHIBIT;
1968 }
1969 return CPUMINTERRUPTIBILITY_GLOBAL_INHIBIT;
1970 }
1971 else
1972 {
1973 if (pVCpu->cpum.s.Guest.hwvirt.fGif)
1974 {
1975 if (VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_BLOCK_NMIS))
1976 return CPUMINTERRUPTIBILITY_NMI_INHIBIT;
1977 return CPUMINTERRUPTIBILITY_INT_DISABLED;
1978 }
1979 return CPUMINTERRUPTIBILITY_GLOBAL_INHIBIT;
1980 }
1981#endif
1982}
1983
1984
1985/**
1986 * Gets whether the guest (or nested-guest) is currently blocking delivery of NMIs.
1987 *
1988 * @returns @c true if NMIs are blocked, @c false otherwise.
1989 * @param pVCpu The cross context virtual CPU structure.
1990 */
1991VMM_INT_DECL(bool) CPUMIsGuestNmiBlocking(PCVMCPU pVCpu)
1992{
1993 /*
1994 * Return the state of guest-NMI blocking in any of the following cases:
1995 * - We're not executing a nested-guest.
1996 * - We're executing an SVM nested-guest[1].
1997 * - We're executing a VMX nested-guest without virtual-NMIs enabled.
1998 *
1999 * [1] -- SVM does not support virtual-NMIs or virtual-NMI blocking.
2000 * SVM hypervisors must track NMI blocking themselves by intercepting
2001 * the IRET instruction after injection of an NMI.
2002 */
2003 PCCPUMCTX pCtx = &pVCpu->cpum.s.Guest;
2004 if ( !CPUMIsGuestInNestedHwvirtMode(pCtx)
2005 || CPUMIsGuestInSvmNestedHwVirtMode(pCtx)
2006 || !CPUMIsGuestVmxPinCtlsSet(pCtx, VMX_PIN_CTLS_VIRT_NMI))
2007 return VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_BLOCK_NMIS);
2008
2009 /*
2010 * Return the state of virtual-NMI blocking, if we are executing a
2011 * VMX nested-guest with virtual-NMIs enabled.
2012 */
2013 return CPUMIsGuestVmxVirtNmiBlocking(pCtx);
2014}
2015
2016
2017/**
2018 * Sets blocking delivery of NMIs to the guest.
2019 *
2020 * @param pVCpu The cross context virtual CPU structure.
2021 * @param fBlock Whether NMIs are blocked or not.
2022 */
2023VMM_INT_DECL(void) CPUMSetGuestNmiBlocking(PVMCPU pVCpu, bool fBlock)
2024{
2025 /*
2026 * Set the state of guest-NMI blocking in any of the following cases:
2027 * - We're not executing a nested-guest.
2028 * - We're executing an SVM nested-guest[1].
2029 * - We're executing a VMX nested-guest without virtual-NMIs enabled.
2030 *
2031 * [1] -- SVM does not support virtual-NMIs or virtual-NMI blocking.
2032 * SVM hypervisors must track NMI blocking themselves by intercepting
2033 * the IRET instruction after injection of an NMI.
2034 */
2035 PCPUMCTX pCtx = &pVCpu->cpum.s.Guest;
2036 if ( !CPUMIsGuestInNestedHwvirtMode(pCtx)
2037 || CPUMIsGuestInSvmNestedHwVirtMode(pCtx)
2038 || !CPUMIsGuestVmxPinCtlsSet(pCtx, VMX_PIN_CTLS_VIRT_NMI))
2039 {
2040 if (fBlock)
2041 {
2042 if (!VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_BLOCK_NMIS))
2043 VMCPU_FF_SET(pVCpu, VMCPU_FF_BLOCK_NMIS);
2044 }
2045 else
2046 {
2047 if (VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_BLOCK_NMIS))
2048 VMCPU_FF_CLEAR(pVCpu, VMCPU_FF_BLOCK_NMIS);
2049 }
2050 return;
2051 }
2052
2053 /*
2054 * Set the state of virtual-NMI blocking, if we are executing a
2055 * VMX nested-guest with virtual-NMIs enabled.
2056 */
2057 return CPUMSetGuestVmxVirtNmiBlocking(pCtx, fBlock);
2058}
2059
2060
2061/**
2062 * Checks whether the SVM nested-guest has physical interrupts enabled.
2063 *
2064 * @returns true if interrupts are enabled, false otherwise.
2065 * @param pVCpu The cross context virtual CPU structure of the calling EMT.
2066 * @param pCtx The guest-CPU context.
2067 *
2068 * @remarks This does -not- take into account the global-interrupt flag.
2069 */
2070VMM_INT_DECL(bool) CPUMIsGuestSvmPhysIntrEnabled(PCVMCPU pVCpu, PCCPUMCTX pCtx)
2071{
2072 /** @todo Optimization: Avoid this function call and use a pointer to the
2073 * relevant eflags instead (setup during VMRUN instruction emulation). */
2074 Assert(CPUMIsGuestInSvmNestedHwVirtMode(pCtx));
2075
2076 X86EFLAGS fEFlags;
2077 if (CPUMIsGuestSvmVirtIntrMasking(pVCpu, pCtx))
2078 fEFlags.u = pCtx->hwvirt.svm.HostState.rflags.u;
2079 else
2080 fEFlags.u = pCtx->eflags.u;
2081
2082 return fEFlags.Bits.u1IF;
2083}
2084
2085
2086/**
2087 * Checks whether the SVM nested-guest is in a state to receive virtual (setup
2088 * for injection by VMRUN instruction) interrupts.
2089 *
2090 * @returns VBox status code.
2091 * @retval true if it's ready, false otherwise.
2092 *
2093 * @param pVCpu The cross context virtual CPU structure of the calling EMT.
2094 * @param pCtx The guest-CPU context.
2095 */
2096VMM_INT_DECL(bool) CPUMIsGuestSvmVirtIntrEnabled(PCVMCPU pVCpu, PCCPUMCTX pCtx)
2097{
2098 RT_NOREF(pVCpu);
2099 Assert(CPUMIsGuestInSvmNestedHwVirtMode(pCtx));
2100
2101 PCSVMVMCBCTRL pVmcbCtrl = &pCtx->hwvirt.svm.Vmcb.ctrl;
2102 PCSVMINTCTRL pVmcbIntCtrl = &pVmcbCtrl->IntCtrl;
2103 Assert(!pVmcbIntCtrl->n.u1VGifEnable); /* We don't support passing virtual-GIF feature to the guest yet. */
2104 if ( !pVmcbIntCtrl->n.u1IgnoreTPR
2105 && pVmcbIntCtrl->n.u4VIntrPrio <= pVmcbIntCtrl->n.u8VTPR)
2106 return false;
2107
2108 return RT_BOOL(pCtx->eflags.u & X86_EFL_IF);
2109}
2110
2111
2112/**
2113 * Gets the pending SVM nested-guest interruptvector.
2114 *
2115 * @returns The nested-guest interrupt to inject.
2116 * @param pCtx The guest-CPU context.
2117 */
2118VMM_INT_DECL(uint8_t) CPUMGetGuestSvmVirtIntrVector(PCCPUMCTX pCtx)
2119{
2120 return pCtx->hwvirt.svm.Vmcb.ctrl.IntCtrl.n.u8VIntrVector;
2121}
2122
2123
2124/**
2125 * Restores the host-state from the host-state save area as part of a \#VMEXIT.
2126 *
2127 * @param pVCpu The cross context virtual CPU structure of the calling EMT.
2128 * @param pCtx The guest-CPU context.
2129 */
2130VMM_INT_DECL(void) CPUMSvmVmExitRestoreHostState(PVMCPUCC pVCpu, PCPUMCTX pCtx)
2131{
2132 /*
2133 * Reload the guest's "host state".
2134 */
2135 PSVMHOSTSTATE pHostState = &pCtx->hwvirt.svm.HostState;
2136 pCtx->es = pHostState->es;
2137 pCtx->cs = pHostState->cs;
2138 pCtx->ss = pHostState->ss;
2139 pCtx->ds = pHostState->ds;
2140 pCtx->gdtr = pHostState->gdtr;
2141 pCtx->idtr = pHostState->idtr;
2142 CPUMSetGuestEferMsrNoChecks(pVCpu, pCtx->msrEFER, pHostState->uEferMsr);
2143 CPUMSetGuestCR0(pVCpu, pHostState->uCr0 | X86_CR0_PE);
2144 pCtx->cr3 = pHostState->uCr3;
2145 CPUMSetGuestCR4(pVCpu, pHostState->uCr4);
2146 pCtx->rflags = pHostState->rflags;
2147 pCtx->rflags.Bits.u1VM = 0;
2148 pCtx->rip = pHostState->uRip;
2149 pCtx->rsp = pHostState->uRsp;
2150 pCtx->rax = pHostState->uRax;
2151 pCtx->dr[7] &= ~(X86_DR7_ENABLED_MASK | X86_DR7_RAZ_MASK | X86_DR7_MBZ_MASK);
2152 pCtx->dr[7] |= X86_DR7_RA1_MASK;
2153 Assert(pCtx->ss.Attr.n.u2Dpl == 0);
2154
2155 /** @todo if RIP is not canonical or outside the CS segment limit, we need to
2156 * raise \#GP(0) in the guest. */
2157
2158 /** @todo check the loaded host-state for consistency. Figure out what
2159 * exactly this involves? */
2160}
2161
2162
2163/**
2164 * Saves the host-state to the host-state save area as part of a VMRUN.
2165 *
2166 * @param pCtx The guest-CPU context.
2167 * @param cbInstr The length of the VMRUN instruction in bytes.
2168 */
2169VMM_INT_DECL(void) CPUMSvmVmRunSaveHostState(PCPUMCTX pCtx, uint8_t cbInstr)
2170{
2171 PSVMHOSTSTATE pHostState = &pCtx->hwvirt.svm.HostState;
2172 pHostState->es = pCtx->es;
2173 pHostState->cs = pCtx->cs;
2174 pHostState->ss = pCtx->ss;
2175 pHostState->ds = pCtx->ds;
2176 pHostState->gdtr = pCtx->gdtr;
2177 pHostState->idtr = pCtx->idtr;
2178 pHostState->uEferMsr = pCtx->msrEFER;
2179 pHostState->uCr0 = pCtx->cr0;
2180 pHostState->uCr3 = pCtx->cr3;
2181 pHostState->uCr4 = pCtx->cr4;
2182 pHostState->rflags = pCtx->rflags;
2183 pHostState->uRip = pCtx->rip + cbInstr;
2184 pHostState->uRsp = pCtx->rsp;
2185 pHostState->uRax = pCtx->rax;
2186}
2187
2188
2189/**
2190 * Applies the TSC offset of a nested-guest if any and returns the TSC value for the
2191 * nested-guest.
2192 *
2193 * @returns The TSC offset after applying any nested-guest TSC offset.
2194 * @param pVCpu The cross context virtual CPU structure of the calling EMT.
2195 * @param uTscValue The guest TSC.
2196 *
2197 * @sa CPUMRemoveNestedGuestTscOffset.
2198 */
2199VMM_INT_DECL(uint64_t) CPUMApplyNestedGuestTscOffset(PCVMCPU pVCpu, uint64_t uTscValue)
2200{
2201 PCCPUMCTX pCtx = &pVCpu->cpum.s.Guest;
2202 if (CPUMIsGuestInVmxNonRootMode(pCtx))
2203 {
2204 if (CPUMIsGuestVmxProcCtlsSet(pCtx, VMX_PROC_CTLS_USE_TSC_OFFSETTING))
2205 return uTscValue + pCtx->hwvirt.vmx.Vmcs.u64TscOffset.u;
2206 return uTscValue;
2207 }
2208
2209 if (CPUMIsGuestInSvmNestedHwVirtMode(pCtx))
2210 {
2211 uint64_t offTsc;
2212 if (!HMGetGuestSvmTscOffset(pVCpu, &offTsc))
2213 offTsc = pCtx->hwvirt.svm.Vmcb.ctrl.u64TSCOffset;
2214 return uTscValue + offTsc;
2215 }
2216 return uTscValue;
2217}
2218
2219
2220/**
2221 * Removes the TSC offset of a nested-guest if any and returns the TSC value for the
2222 * guest.
2223 *
2224 * @returns The TSC offset after removing any nested-guest TSC offset.
2225 * @param pVCpu The cross context virtual CPU structure of the calling EMT.
2226 * @param uTscValue The nested-guest TSC.
2227 *
2228 * @sa CPUMApplyNestedGuestTscOffset.
2229 */
2230VMM_INT_DECL(uint64_t) CPUMRemoveNestedGuestTscOffset(PCVMCPU pVCpu, uint64_t uTscValue)
2231{
2232 PCCPUMCTX pCtx = &pVCpu->cpum.s.Guest;
2233 if (CPUMIsGuestInVmxNonRootMode(pCtx))
2234 {
2235 if (CPUMIsGuestVmxProcCtlsSet(pCtx, VMX_PROC_CTLS_USE_TSC_OFFSETTING))
2236 return uTscValue - pCtx->hwvirt.vmx.Vmcs.u64TscOffset.u;
2237 return uTscValue;
2238 }
2239
2240 if (CPUMIsGuestInSvmNestedHwVirtMode(pCtx))
2241 {
2242 uint64_t offTsc;
2243 if (!HMGetGuestSvmTscOffset(pVCpu, &offTsc))
2244 offTsc = pCtx->hwvirt.svm.Vmcb.ctrl.u64TSCOffset;
2245 return uTscValue - offTsc;
2246 }
2247 return uTscValue;
2248}
2249
2250
2251/**
2252 * Used to dynamically imports state residing in NEM or HM.
2253 *
2254 * This is a worker for the CPUM_IMPORT_EXTRN_RET() macro and various IEM ones.
2255 *
2256 * @returns VBox status code.
2257 * @param pVCpu The cross context virtual CPU structure of the calling thread.
2258 * @param fExtrnImport The fields to import.
2259 * @thread EMT(pVCpu)
2260 */
2261VMM_INT_DECL(int) CPUMImportGuestStateOnDemand(PVMCPUCC pVCpu, uint64_t fExtrnImport)
2262{
2263 VMCPU_ASSERT_EMT(pVCpu);
2264 if (pVCpu->cpum.s.Guest.fExtrn & fExtrnImport)
2265 {
2266 switch (pVCpu->cpum.s.Guest.fExtrn & CPUMCTX_EXTRN_KEEPER_MASK)
2267 {
2268 case CPUMCTX_EXTRN_KEEPER_NEM:
2269 {
2270 int rc = NEMImportStateOnDemand(pVCpu, fExtrnImport);
2271 Assert(rc == VINF_SUCCESS || RT_FAILURE_NP(rc));
2272 return rc;
2273 }
2274
2275 case CPUMCTX_EXTRN_KEEPER_HM:
2276 {
2277#ifdef IN_RING0
2278 int rc = HMR0ImportStateOnDemand(pVCpu, fExtrnImport);
2279 Assert(rc == VINF_SUCCESS || RT_FAILURE_NP(rc));
2280 return rc;
2281#else
2282 AssertLogRelMsgFailed(("TODO Fetch HM state: %#RX64 vs %#RX64\n", pVCpu->cpum.s.Guest.fExtrn, fExtrnImport));
2283 return VINF_SUCCESS;
2284#endif
2285 }
2286 default:
2287 AssertLogRelMsgFailedReturn(("%#RX64 vs %#RX64\n", pVCpu->cpum.s.Guest.fExtrn, fExtrnImport), VERR_CPUM_IPE_2);
2288 }
2289 }
2290 return VINF_SUCCESS;
2291}
2292
2293
2294/**
2295 * Gets valid CR4 bits for the guest.
2296 *
2297 * @returns Valid CR4 bits.
2298 * @param pVM The cross context VM structure.
2299 */
2300VMM_INT_DECL(uint64_t) CPUMGetGuestCR4ValidMask(PVM pVM)
2301{
2302 PCCPUMFEATURES pGuestFeatures = &pVM->cpum.s.GuestFeatures;
2303 uint64_t fMask = X86_CR4_VME | X86_CR4_PVI
2304 | X86_CR4_TSD | X86_CR4_DE
2305 | X86_CR4_MCE | X86_CR4_PCE;
2306 if (pGuestFeatures->fPae)
2307 fMask |= X86_CR4_PAE;
2308 if (pGuestFeatures->fPge)
2309 fMask |= X86_CR4_PGE;
2310 if (pGuestFeatures->fPse)
2311 fMask |= X86_CR4_PSE;
2312 if (pGuestFeatures->fFxSaveRstor)
2313 fMask |= X86_CR4_OSFXSR;
2314 if (pGuestFeatures->fVmx)
2315 fMask |= X86_CR4_VMXE;
2316 if (pGuestFeatures->fXSaveRstor)
2317 fMask |= X86_CR4_OSXSAVE;
2318 if (pGuestFeatures->fPcid)
2319 fMask |= X86_CR4_PCIDE;
2320 if (pGuestFeatures->fFsGsBase)
2321 fMask |= X86_CR4_FSGSBASE;
2322 if (pGuestFeatures->fSse)
2323 fMask |= X86_CR4_OSXMMEEXCPT;
2324 return fMask;
2325}
2326
2327
2328/**
2329 * Sets the PAE PDPEs for the guest.
2330 *
2331 * @param pVCpu The cross context virtual CPU structure of the calling thread.
2332 * @param paPaePdpes The PAE PDPEs to set.
2333 */
2334VMM_INT_DECL(void) CPUMSetGuestPaePdpes(PVMCPU pVCpu, PCX86PDPE paPaePdpes)
2335{
2336 Assert(paPaePdpes);
2337 for (unsigned i = 0; i < RT_ELEMENTS(pVCpu->cpum.s.Guest.aPaePdpes); i++)
2338 pVCpu->cpum.s.Guest.aPaePdpes[i].u = paPaePdpes[i].u;
2339 pVCpu->cpum.s.Guest.fExtrn &= ~CPUMCTX_EXTRN_CR3;
2340}
2341
2342
2343/**
2344 * Gets the PAE PDPTEs for the guest.
2345 *
2346 * @param pVCpu The cross context virtual CPU structure of the calling thread.
2347 * @param paPaePdpes Where to store the PAE PDPEs.
2348 */
2349VMM_INT_DECL(void) CPUMGetGuestPaePdpes(PVMCPU pVCpu, PX86PDPE paPaePdpes)
2350{
2351 Assert(paPaePdpes);
2352 CPUM_INT_ASSERT_NOT_EXTRN(pVCpu, CPUMCTX_EXTRN_CR3);
2353 for (unsigned i = 0; i < RT_ELEMENTS(pVCpu->cpum.s.Guest.aPaePdpes); i++)
2354 paPaePdpes[i].u = pVCpu->cpum.s.Guest.aPaePdpes[i].u;
2355}
2356
2357
2358/**
2359 * Starts a VMX-preemption timer to expire as specified by the nested hypervisor.
2360 *
2361 * @returns VBox status code.
2362 * @param pVCpu The cross context virtual CPU structure of the calling thread.
2363 * @param uTimer The VMCS preemption timer value.
2364 * @param cShift The VMX-preemption timer shift (usually based on guest
2365 * VMX MSR rate).
2366 * @param pu64EntryTick Where to store the current tick when the timer is
2367 * programmed.
2368 * @thread EMT(pVCpu)
2369 */
2370VMM_INT_DECL(int) CPUMStartGuestVmxPremptTimer(PVMCPUCC pVCpu, uint32_t uTimer, uint8_t cShift, uint64_t *pu64EntryTick)
2371{
2372 Assert(uTimer);
2373 Assert(cShift <= 31);
2374 Assert(pu64EntryTick);
2375 VMCPU_ASSERT_EMT(pVCpu);
2376 uint64_t const cTicksToNext = uTimer << cShift;
2377 return TMTimerSetRelative(pVCpu->CTX_SUFF(pVM), pVCpu->cpum.s.hNestedVmxPreemptTimer, cTicksToNext, pu64EntryTick);
2378}
2379
2380
2381/**
2382 * Stops the VMX-preemption timer from firing.
2383 *
2384 * @returns VBox status code.
2385 * @param pVCpu The cross context virtual CPU structure of the calling thread.
2386 * @thread EMT.
2387 *
2388 * @remarks This can be called during VM reset, so we cannot assume it will be on
2389 * the EMT corresponding to @c pVCpu.
2390 */
2391VMM_INT_DECL(int) CPUMStopGuestVmxPremptTimer(PVMCPUCC pVCpu)
2392{
2393 /*
2394 * CPUM gets initialized before TM, so we defer creation of timers till CPUMR3InitCompleted().
2395 * However, we still get called during CPUMR3Init() and hence we need to check if we have
2396 * a valid timer object before trying to stop it.
2397 */
2398 int rc;
2399 TMTIMERHANDLE hTimer = pVCpu->cpum.s.hNestedVmxPreemptTimer;
2400 if (hTimer != NIL_TMTIMERHANDLE)
2401 {
2402 PVMCC pVM = pVCpu->CTX_SUFF(pVM);
2403 rc = TMTimerLock(pVM, hTimer, VERR_IGNORED);
2404 if (rc == VINF_SUCCESS)
2405 {
2406 if (TMTimerIsActive(pVM, hTimer))
2407 TMTimerStop(pVM, hTimer);
2408 TMTimerUnlock(pVM, hTimer);
2409 }
2410 }
2411 else
2412 rc = VERR_NOT_FOUND;
2413 return rc;
2414}
2415
2416
2417/**
2418 * Gets the read and write permission bits for an MSR in an MSR bitmap.
2419 *
2420 * @returns VMXMSRPM_XXX - the MSR permission.
2421 * @param pvMsrBitmap Pointer to the MSR bitmap.
2422 * @param idMsr The MSR to get permissions for.
2423 *
2424 * @sa hmR0VmxSetMsrPermission.
2425 */
2426VMM_INT_DECL(uint32_t) CPUMGetVmxMsrPermission(void const *pvMsrBitmap, uint32_t idMsr)
2427{
2428 AssertPtrReturn(pvMsrBitmap, VMXMSRPM_EXIT_RD | VMXMSRPM_EXIT_WR);
2429
2430 uint8_t const * const pbMsrBitmap = (uint8_t const * const)pvMsrBitmap;
2431
2432 /*
2433 * MSR Layout:
2434 * Byte index MSR range Interpreted as
2435 * 0x000 - 0x3ff 0x00000000 - 0x00001fff Low MSR read bits.
2436 * 0x400 - 0x7ff 0xc0000000 - 0xc0001fff High MSR read bits.
2437 * 0x800 - 0xbff 0x00000000 - 0x00001fff Low MSR write bits.
2438 * 0xc00 - 0xfff 0xc0000000 - 0xc0001fff High MSR write bits.
2439 *
2440 * A bit corresponding to an MSR within the above range causes a VM-exit
2441 * if the bit is 1 on executions of RDMSR/WRMSR. If an MSR falls out of
2442 * the MSR range, it always cause a VM-exit.
2443 *
2444 * See Intel spec. 24.6.9 "MSR-Bitmap Address".
2445 */
2446 uint32_t const offBitmapRead = 0;
2447 uint32_t const offBitmapWrite = 0x800;
2448 uint32_t offMsr;
2449 uint32_t iBit;
2450 if (idMsr <= UINT32_C(0x00001fff))
2451 {
2452 offMsr = 0;
2453 iBit = idMsr;
2454 }
2455 else if (idMsr - UINT32_C(0xc0000000) <= UINT32_C(0x00001fff))
2456 {
2457 offMsr = 0x400;
2458 iBit = idMsr - UINT32_C(0xc0000000);
2459 }
2460 else
2461 {
2462 LogFunc(("Warning! Out of range MSR %#RX32\n", idMsr));
2463 return VMXMSRPM_EXIT_RD | VMXMSRPM_EXIT_WR;
2464 }
2465
2466 /*
2467 * Get the MSR read permissions.
2468 */
2469 uint32_t fRet;
2470 uint32_t const offMsrRead = offBitmapRead + offMsr;
2471 Assert(offMsrRead + (iBit >> 3) < offBitmapWrite);
2472 if (ASMBitTest(pbMsrBitmap + offMsrRead, iBit))
2473 fRet = VMXMSRPM_EXIT_RD;
2474 else
2475 fRet = VMXMSRPM_ALLOW_RD;
2476
2477 /*
2478 * Get the MSR write permissions.
2479 */
2480 uint32_t const offMsrWrite = offBitmapWrite + offMsr;
2481 Assert(offMsrWrite + (iBit >> 3) < X86_PAGE_4K_SIZE);
2482 if (ASMBitTest(pbMsrBitmap + offMsrWrite, iBit))
2483 fRet |= VMXMSRPM_EXIT_WR;
2484 else
2485 fRet |= VMXMSRPM_ALLOW_WR;
2486
2487 Assert(VMXMSRPM_IS_FLAG_VALID(fRet));
2488 return fRet;
2489}
2490
2491
2492/**
2493 * Checks the permission bits for the specified I/O port from the given I/O bitmap
2494 * to see if causes a VM-exit.
2495 *
2496 * @returns @c true if the I/O port access must cause a VM-exit, @c false otherwise.
2497 * @param pbIoBitmap Pointer to I/O bitmap.
2498 * @param uPort The I/O port being accessed.
2499 * @param cbAccess e size of the I/O access in bytes (1, 2 or 4 bytes).
2500 */
2501static bool cpumGetVmxIoBitmapPermission(uint8_t const *pbIoBitmap, uint16_t uPort, uint8_t cbAccess)
2502{
2503 Assert(cbAccess == 1 || cbAccess == 2 || cbAccess == 4);
2504
2505 /*
2506 * If the I/O port access wraps around the 16-bit port I/O space, we must cause a
2507 * VM-exit.
2508 *
2509 * Reading 1, 2, 4 bytes at ports 0xffff, 0xfffe and 0xfffc are valid and do not
2510 * constitute a wrap around. However, reading 2 bytes at port 0xffff or 4 bytes
2511 * from port 0xffff/0xfffe/0xfffd constitute a wrap around. In other words, any
2512 * access to -both- ports 0xffff and port 0 is a wrap around.
2513 *
2514 * See Intel spec. 25.1.3 "Instructions That Cause VM Exits Conditionally".
2515 */
2516 uint32_t const uPortLast = uPort + cbAccess;
2517 if (uPortLast > 0x10000)
2518 return true;
2519
2520 /*
2521 * If any bit corresponding to the I/O access is set, we must cause a VM-exit.
2522 */
2523 uint16_t const offPerm = uPort >> 3; /* Byte offset of the port. */
2524 uint16_t const idxPermBit = uPort - (offPerm << 3); /* Bit offset within byte. */
2525 Assert(idxPermBit < 8);
2526 static const uint8_t s_afMask[] = { 0x0, 0x1, 0x3, 0x7, 0xf }; /* Bit-mask for all access sizes. */
2527 uint16_t const fMask = s_afMask[cbAccess] << idxPermBit; /* Bit-mask of the access. */
2528
2529 /* Fetch 8 or 16-bits depending on whether the access spans 8-bit boundary. */
2530 RTUINT16U uPerm;
2531 uPerm.s.Lo = pbIoBitmap[offPerm];
2532 if (idxPermBit + cbAccess > 8)
2533 uPerm.s.Hi = pbIoBitmap[offPerm + 1];
2534 else
2535 uPerm.s.Hi = 0;
2536
2537 /* If any bit for the access is 1, we must cause a VM-exit. */
2538 if (uPerm.u & fMask)
2539 return true;
2540
2541 return false;
2542}
2543
2544
2545/**
2546 * Returns whether the given VMCS field is valid and supported for the guest.
2547 *
2548 * @param pVM The cross context VM structure.
2549 * @param u64VmcsField The VMCS field.
2550 *
2551 * @remarks This takes into account the CPU features exposed to the guest.
2552 */
2553VMM_INT_DECL(bool) CPUMIsGuestVmxVmcsFieldValid(PVMCC pVM, uint64_t u64VmcsField)
2554{
2555 uint32_t const uFieldEncHi = RT_HI_U32(u64VmcsField);
2556 uint32_t const uFieldEncLo = RT_LO_U32(u64VmcsField);
2557 if (!uFieldEncHi)
2558 { /* likely */ }
2559 else
2560 return false;
2561
2562 PCCPUMFEATURES pFeat = &pVM->cpum.s.GuestFeatures;
2563 switch (uFieldEncLo)
2564 {
2565 /*
2566 * 16-bit fields.
2567 */
2568 /* Control fields. */
2569 case VMX_VMCS16_VPID: return pFeat->fVmxVpid;
2570 case VMX_VMCS16_POSTED_INT_NOTIFY_VECTOR: return pFeat->fVmxPostedInt;
2571 case VMX_VMCS16_EPTP_INDEX: return pFeat->fVmxEptXcptVe;
2572
2573 /* Guest-state fields. */
2574 case VMX_VMCS16_GUEST_ES_SEL:
2575 case VMX_VMCS16_GUEST_CS_SEL:
2576 case VMX_VMCS16_GUEST_SS_SEL:
2577 case VMX_VMCS16_GUEST_DS_SEL:
2578 case VMX_VMCS16_GUEST_FS_SEL:
2579 case VMX_VMCS16_GUEST_GS_SEL:
2580 case VMX_VMCS16_GUEST_LDTR_SEL:
2581 case VMX_VMCS16_GUEST_TR_SEL: return true;
2582 case VMX_VMCS16_GUEST_INTR_STATUS: return pFeat->fVmxVirtIntDelivery;
2583 case VMX_VMCS16_GUEST_PML_INDEX: return pFeat->fVmxPml;
2584
2585 /* Host-state fields. */
2586 case VMX_VMCS16_HOST_ES_SEL:
2587 case VMX_VMCS16_HOST_CS_SEL:
2588 case VMX_VMCS16_HOST_SS_SEL:
2589 case VMX_VMCS16_HOST_DS_SEL:
2590 case VMX_VMCS16_HOST_FS_SEL:
2591 case VMX_VMCS16_HOST_GS_SEL:
2592 case VMX_VMCS16_HOST_TR_SEL: return true;
2593
2594 /*
2595 * 64-bit fields.
2596 */
2597 /* Control fields. */
2598 case VMX_VMCS64_CTRL_IO_BITMAP_A_FULL:
2599 case VMX_VMCS64_CTRL_IO_BITMAP_A_HIGH:
2600 case VMX_VMCS64_CTRL_IO_BITMAP_B_FULL:
2601 case VMX_VMCS64_CTRL_IO_BITMAP_B_HIGH: return pFeat->fVmxUseIoBitmaps;
2602 case VMX_VMCS64_CTRL_MSR_BITMAP_FULL:
2603 case VMX_VMCS64_CTRL_MSR_BITMAP_HIGH: return pFeat->fVmxUseMsrBitmaps;
2604 case VMX_VMCS64_CTRL_EXIT_MSR_STORE_FULL:
2605 case VMX_VMCS64_CTRL_EXIT_MSR_STORE_HIGH:
2606 case VMX_VMCS64_CTRL_EXIT_MSR_LOAD_FULL:
2607 case VMX_VMCS64_CTRL_EXIT_MSR_LOAD_HIGH:
2608 case VMX_VMCS64_CTRL_ENTRY_MSR_LOAD_FULL:
2609 case VMX_VMCS64_CTRL_ENTRY_MSR_LOAD_HIGH:
2610 case VMX_VMCS64_CTRL_EXEC_VMCS_PTR_FULL:
2611 case VMX_VMCS64_CTRL_EXEC_VMCS_PTR_HIGH: return true;
2612 case VMX_VMCS64_CTRL_EXEC_PML_ADDR_FULL:
2613 case VMX_VMCS64_CTRL_EXEC_PML_ADDR_HIGH: return pFeat->fVmxPml;
2614 case VMX_VMCS64_CTRL_TSC_OFFSET_FULL:
2615 case VMX_VMCS64_CTRL_TSC_OFFSET_HIGH: return true;
2616 case VMX_VMCS64_CTRL_VIRT_APIC_PAGEADDR_FULL:
2617 case VMX_VMCS64_CTRL_VIRT_APIC_PAGEADDR_HIGH: return pFeat->fVmxUseTprShadow;
2618 case VMX_VMCS64_CTRL_APIC_ACCESSADDR_FULL:
2619 case VMX_VMCS64_CTRL_APIC_ACCESSADDR_HIGH: return pFeat->fVmxVirtApicAccess;
2620 case VMX_VMCS64_CTRL_POSTED_INTR_DESC_FULL:
2621 case VMX_VMCS64_CTRL_POSTED_INTR_DESC_HIGH: return pFeat->fVmxPostedInt;
2622 case VMX_VMCS64_CTRL_VMFUNC_CTRLS_FULL:
2623 case VMX_VMCS64_CTRL_VMFUNC_CTRLS_HIGH: return pFeat->fVmxVmFunc;
2624 case VMX_VMCS64_CTRL_EPTP_FULL:
2625 case VMX_VMCS64_CTRL_EPTP_HIGH: return pFeat->fVmxEpt;
2626 case VMX_VMCS64_CTRL_EOI_BITMAP_0_FULL:
2627 case VMX_VMCS64_CTRL_EOI_BITMAP_0_HIGH:
2628 case VMX_VMCS64_CTRL_EOI_BITMAP_1_FULL:
2629 case VMX_VMCS64_CTRL_EOI_BITMAP_1_HIGH:
2630 case VMX_VMCS64_CTRL_EOI_BITMAP_2_FULL:
2631 case VMX_VMCS64_CTRL_EOI_BITMAP_2_HIGH:
2632 case VMX_VMCS64_CTRL_EOI_BITMAP_3_FULL:
2633 case VMX_VMCS64_CTRL_EOI_BITMAP_3_HIGH: return pFeat->fVmxVirtIntDelivery;
2634 case VMX_VMCS64_CTRL_EPTP_LIST_FULL:
2635 case VMX_VMCS64_CTRL_EPTP_LIST_HIGH:
2636 {
2637 PCVMCPU pVCpu = pVM->CTX_SUFF(apCpus)[0];
2638 uint64_t const uVmFuncMsr = pVCpu->cpum.s.Guest.hwvirt.vmx.Msrs.u64VmFunc;
2639 return RT_BOOL(RT_BF_GET(uVmFuncMsr, VMX_BF_VMFUNC_EPTP_SWITCHING));
2640 }
2641 case VMX_VMCS64_CTRL_VMREAD_BITMAP_FULL:
2642 case VMX_VMCS64_CTRL_VMREAD_BITMAP_HIGH:
2643 case VMX_VMCS64_CTRL_VMWRITE_BITMAP_FULL:
2644 case VMX_VMCS64_CTRL_VMWRITE_BITMAP_HIGH: return pFeat->fVmxVmcsShadowing;
2645 case VMX_VMCS64_CTRL_VE_XCPT_INFO_ADDR_FULL:
2646 case VMX_VMCS64_CTRL_VE_XCPT_INFO_ADDR_HIGH: return pFeat->fVmxEptXcptVe;
2647 case VMX_VMCS64_CTRL_XSS_EXITING_BITMAP_FULL:
2648 case VMX_VMCS64_CTRL_XSS_EXITING_BITMAP_HIGH: return pFeat->fVmxXsavesXrstors;
2649 case VMX_VMCS64_CTRL_TSC_MULTIPLIER_FULL:
2650 case VMX_VMCS64_CTRL_TSC_MULTIPLIER_HIGH: return pFeat->fVmxUseTscScaling;
2651 case VMX_VMCS64_CTRL_PROC_EXEC3_FULL:
2652 case VMX_VMCS64_CTRL_PROC_EXEC3_HIGH: return pFeat->fVmxTertiaryExecCtls;
2653
2654 /* Read-only data fields. */
2655 case VMX_VMCS64_RO_GUEST_PHYS_ADDR_FULL:
2656 case VMX_VMCS64_RO_GUEST_PHYS_ADDR_HIGH: return pFeat->fVmxEpt;
2657
2658 /* Guest-state fields. */
2659 case VMX_VMCS64_GUEST_VMCS_LINK_PTR_FULL:
2660 case VMX_VMCS64_GUEST_VMCS_LINK_PTR_HIGH:
2661 case VMX_VMCS64_GUEST_DEBUGCTL_FULL:
2662 case VMX_VMCS64_GUEST_DEBUGCTL_HIGH: return true;
2663 case VMX_VMCS64_GUEST_PAT_FULL:
2664 case VMX_VMCS64_GUEST_PAT_HIGH: return pFeat->fVmxEntryLoadPatMsr || pFeat->fVmxExitSavePatMsr;
2665 case VMX_VMCS64_GUEST_EFER_FULL:
2666 case VMX_VMCS64_GUEST_EFER_HIGH: return pFeat->fVmxEntryLoadEferMsr || pFeat->fVmxExitSaveEferMsr;
2667 case VMX_VMCS64_GUEST_PDPTE0_FULL:
2668 case VMX_VMCS64_GUEST_PDPTE0_HIGH:
2669 case VMX_VMCS64_GUEST_PDPTE1_FULL:
2670 case VMX_VMCS64_GUEST_PDPTE1_HIGH:
2671 case VMX_VMCS64_GUEST_PDPTE2_FULL:
2672 case VMX_VMCS64_GUEST_PDPTE2_HIGH:
2673 case VMX_VMCS64_GUEST_PDPTE3_FULL:
2674 case VMX_VMCS64_GUEST_PDPTE3_HIGH: return pFeat->fVmxEpt;
2675
2676 /* Host-state fields. */
2677 case VMX_VMCS64_HOST_PAT_FULL:
2678 case VMX_VMCS64_HOST_PAT_HIGH: return pFeat->fVmxExitLoadPatMsr;
2679 case VMX_VMCS64_HOST_EFER_FULL:
2680 case VMX_VMCS64_HOST_EFER_HIGH: return pFeat->fVmxExitLoadEferMsr;
2681
2682 /*
2683 * 32-bit fields.
2684 */
2685 /* Control fields. */
2686 case VMX_VMCS32_CTRL_PIN_EXEC:
2687 case VMX_VMCS32_CTRL_PROC_EXEC:
2688 case VMX_VMCS32_CTRL_EXCEPTION_BITMAP:
2689 case VMX_VMCS32_CTRL_PAGEFAULT_ERROR_MASK:
2690 case VMX_VMCS32_CTRL_PAGEFAULT_ERROR_MATCH:
2691 case VMX_VMCS32_CTRL_CR3_TARGET_COUNT:
2692 case VMX_VMCS32_CTRL_EXIT:
2693 case VMX_VMCS32_CTRL_EXIT_MSR_STORE_COUNT:
2694 case VMX_VMCS32_CTRL_EXIT_MSR_LOAD_COUNT:
2695 case VMX_VMCS32_CTRL_ENTRY:
2696 case VMX_VMCS32_CTRL_ENTRY_MSR_LOAD_COUNT:
2697 case VMX_VMCS32_CTRL_ENTRY_INTERRUPTION_INFO:
2698 case VMX_VMCS32_CTRL_ENTRY_EXCEPTION_ERRCODE:
2699 case VMX_VMCS32_CTRL_ENTRY_INSTR_LENGTH: return true;
2700 case VMX_VMCS32_CTRL_TPR_THRESHOLD: return pFeat->fVmxUseTprShadow;
2701 case VMX_VMCS32_CTRL_PROC_EXEC2: return pFeat->fVmxSecondaryExecCtls;
2702 case VMX_VMCS32_CTRL_PLE_GAP:
2703 case VMX_VMCS32_CTRL_PLE_WINDOW: return pFeat->fVmxPauseLoopExit;
2704
2705 /* Read-only data fields. */
2706 case VMX_VMCS32_RO_VM_INSTR_ERROR:
2707 case VMX_VMCS32_RO_EXIT_REASON:
2708 case VMX_VMCS32_RO_EXIT_INTERRUPTION_INFO:
2709 case VMX_VMCS32_RO_EXIT_INTERRUPTION_ERROR_CODE:
2710 case VMX_VMCS32_RO_IDT_VECTORING_INFO:
2711 case VMX_VMCS32_RO_IDT_VECTORING_ERROR_CODE:
2712 case VMX_VMCS32_RO_EXIT_INSTR_LENGTH:
2713 case VMX_VMCS32_RO_EXIT_INSTR_INFO: return true;
2714
2715 /* Guest-state fields. */
2716 case VMX_VMCS32_GUEST_ES_LIMIT:
2717 case VMX_VMCS32_GUEST_CS_LIMIT:
2718 case VMX_VMCS32_GUEST_SS_LIMIT:
2719 case VMX_VMCS32_GUEST_DS_LIMIT:
2720 case VMX_VMCS32_GUEST_FS_LIMIT:
2721 case VMX_VMCS32_GUEST_GS_LIMIT:
2722 case VMX_VMCS32_GUEST_LDTR_LIMIT:
2723 case VMX_VMCS32_GUEST_TR_LIMIT:
2724 case VMX_VMCS32_GUEST_GDTR_LIMIT:
2725 case VMX_VMCS32_GUEST_IDTR_LIMIT:
2726 case VMX_VMCS32_GUEST_ES_ACCESS_RIGHTS:
2727 case VMX_VMCS32_GUEST_CS_ACCESS_RIGHTS:
2728 case VMX_VMCS32_GUEST_SS_ACCESS_RIGHTS:
2729 case VMX_VMCS32_GUEST_DS_ACCESS_RIGHTS:
2730 case VMX_VMCS32_GUEST_FS_ACCESS_RIGHTS:
2731 case VMX_VMCS32_GUEST_GS_ACCESS_RIGHTS:
2732 case VMX_VMCS32_GUEST_LDTR_ACCESS_RIGHTS:
2733 case VMX_VMCS32_GUEST_TR_ACCESS_RIGHTS:
2734 case VMX_VMCS32_GUEST_INT_STATE:
2735 case VMX_VMCS32_GUEST_ACTIVITY_STATE:
2736 case VMX_VMCS32_GUEST_SMBASE:
2737 case VMX_VMCS32_GUEST_SYSENTER_CS: return true;
2738 case VMX_VMCS32_PREEMPT_TIMER_VALUE: return pFeat->fVmxPreemptTimer;
2739
2740 /* Host-state fields. */
2741 case VMX_VMCS32_HOST_SYSENTER_CS: return true;
2742
2743 /*
2744 * Natural-width fields.
2745 */
2746 /* Control fields. */
2747 case VMX_VMCS_CTRL_CR0_MASK:
2748 case VMX_VMCS_CTRL_CR4_MASK:
2749 case VMX_VMCS_CTRL_CR0_READ_SHADOW:
2750 case VMX_VMCS_CTRL_CR4_READ_SHADOW:
2751 case VMX_VMCS_CTRL_CR3_TARGET_VAL0:
2752 case VMX_VMCS_CTRL_CR3_TARGET_VAL1:
2753 case VMX_VMCS_CTRL_CR3_TARGET_VAL2:
2754 case VMX_VMCS_CTRL_CR3_TARGET_VAL3: return true;
2755
2756 /* Read-only data fields. */
2757 case VMX_VMCS_RO_EXIT_QUALIFICATION:
2758 case VMX_VMCS_RO_IO_RCX:
2759 case VMX_VMCS_RO_IO_RSI:
2760 case VMX_VMCS_RO_IO_RDI:
2761 case VMX_VMCS_RO_IO_RIP:
2762 case VMX_VMCS_RO_GUEST_LINEAR_ADDR: return true;
2763
2764 /* Guest-state fields. */
2765 case VMX_VMCS_GUEST_CR0:
2766 case VMX_VMCS_GUEST_CR3:
2767 case VMX_VMCS_GUEST_CR4:
2768 case VMX_VMCS_GUEST_ES_BASE:
2769 case VMX_VMCS_GUEST_CS_BASE:
2770 case VMX_VMCS_GUEST_SS_BASE:
2771 case VMX_VMCS_GUEST_DS_BASE:
2772 case VMX_VMCS_GUEST_FS_BASE:
2773 case VMX_VMCS_GUEST_GS_BASE:
2774 case VMX_VMCS_GUEST_LDTR_BASE:
2775 case VMX_VMCS_GUEST_TR_BASE:
2776 case VMX_VMCS_GUEST_GDTR_BASE:
2777 case VMX_VMCS_GUEST_IDTR_BASE:
2778 case VMX_VMCS_GUEST_DR7:
2779 case VMX_VMCS_GUEST_RSP:
2780 case VMX_VMCS_GUEST_RIP:
2781 case VMX_VMCS_GUEST_RFLAGS:
2782 case VMX_VMCS_GUEST_PENDING_DEBUG_XCPTS:
2783 case VMX_VMCS_GUEST_SYSENTER_ESP:
2784 case VMX_VMCS_GUEST_SYSENTER_EIP: return true;
2785
2786 /* Host-state fields. */
2787 case VMX_VMCS_HOST_CR0:
2788 case VMX_VMCS_HOST_CR3:
2789 case VMX_VMCS_HOST_CR4:
2790 case VMX_VMCS_HOST_FS_BASE:
2791 case VMX_VMCS_HOST_GS_BASE:
2792 case VMX_VMCS_HOST_TR_BASE:
2793 case VMX_VMCS_HOST_GDTR_BASE:
2794 case VMX_VMCS_HOST_IDTR_BASE:
2795 case VMX_VMCS_HOST_SYSENTER_ESP:
2796 case VMX_VMCS_HOST_SYSENTER_EIP:
2797 case VMX_VMCS_HOST_RSP:
2798 case VMX_VMCS_HOST_RIP: return true;
2799 }
2800
2801 return false;
2802}
2803
2804
2805/**
2806 * Checks whether the given I/O access should cause a nested-guest VM-exit.
2807 *
2808 * @returns @c true if it causes a VM-exit, @c false otherwise.
2809 * @param pVCpu The cross context virtual CPU structure of the calling EMT.
2810 * @param u16Port The I/O port being accessed.
2811 * @param cbAccess The size of the I/O access in bytes (1, 2 or 4 bytes).
2812 */
2813VMM_INT_DECL(bool) CPUMIsGuestVmxIoInterceptSet(PCVMCPU pVCpu, uint16_t u16Port, uint8_t cbAccess)
2814{
2815 PCCPUMCTX pCtx = &pVCpu->cpum.s.Guest;
2816 if (CPUMIsGuestVmxProcCtlsSet(pCtx, VMX_PROC_CTLS_UNCOND_IO_EXIT))
2817 return true;
2818
2819 if (CPUMIsGuestVmxProcCtlsSet(pCtx, VMX_PROC_CTLS_USE_IO_BITMAPS))
2820 return cpumGetVmxIoBitmapPermission(pCtx->hwvirt.vmx.abIoBitmap, u16Port, cbAccess);
2821
2822 return false;
2823}
2824
2825
2826/**
2827 * Checks whether the Mov-to-CR3 instruction causes a nested-guest VM-exit.
2828 *
2829 * @returns @c true if it causes a VM-exit, @c false otherwise.
2830 * @param pVCpu The cross context virtual CPU structure of the calling EMT.
2831 * @param uNewCr3 The CR3 value being written.
2832 */
2833VMM_INT_DECL(bool) CPUMIsGuestVmxMovToCr3InterceptSet(PVMCPU pVCpu, uint64_t uNewCr3)
2834{
2835 /*
2836 * If the CR3-load exiting control is set and the new CR3 value does not
2837 * match any of the CR3-target values in the VMCS, we must cause a VM-exit.
2838 *
2839 * See Intel spec. 25.1.3 "Instructions That Cause VM Exits Conditionally".
2840 */
2841 PCCPUMCTX const pCtx = &pVCpu->cpum.s.Guest;
2842 if (CPUMIsGuestVmxProcCtlsSet(pCtx, VMX_PROC_CTLS_CR3_LOAD_EXIT))
2843 {
2844 uint32_t const uCr3TargetCount = pCtx->hwvirt.vmx.Vmcs.u32Cr3TargetCount;
2845 Assert(uCr3TargetCount <= VMX_V_CR3_TARGET_COUNT);
2846
2847 /* If the CR3-target count is 0, cause a VM-exit. */
2848 if (uCr3TargetCount == 0)
2849 return true;
2850
2851 /* If the CR3 being written doesn't match any of the target values, cause a VM-exit. */
2852 AssertCompile(VMX_V_CR3_TARGET_COUNT == 4);
2853 if ( uNewCr3 != pCtx->hwvirt.vmx.Vmcs.u64Cr3Target0.u
2854 && uNewCr3 != pCtx->hwvirt.vmx.Vmcs.u64Cr3Target1.u
2855 && uNewCr3 != pCtx->hwvirt.vmx.Vmcs.u64Cr3Target2.u
2856 && uNewCr3 != pCtx->hwvirt.vmx.Vmcs.u64Cr3Target3.u)
2857 return true;
2858 }
2859 return false;
2860}
2861
2862
2863/**
2864 * Checks whether a VMREAD or VMWRITE instruction for the given VMCS field causes a
2865 * VM-exit or not.
2866 *
2867 * @returns @c true if the VMREAD/VMWRITE is intercepted, @c false otherwise.
2868 * @param pVCpu The cross context virtual CPU structure.
2869 * @param uExitReason The VM-exit reason (VMX_EXIT_VMREAD or
2870 * VMX_EXIT_VMREAD).
2871 * @param u64VmcsField The VMCS field.
2872 */
2873VMM_INT_DECL(bool) CPUMIsGuestVmxVmreadVmwriteInterceptSet(PCVMCPU pVCpu, uint32_t uExitReason, uint64_t u64VmcsField)
2874{
2875 Assert(CPUMIsGuestInVmxNonRootMode(&pVCpu->cpum.s.Guest));
2876 Assert( uExitReason == VMX_EXIT_VMREAD
2877 || uExitReason == VMX_EXIT_VMWRITE);
2878
2879 /*
2880 * Without VMCS shadowing, all VMREAD and VMWRITE instructions are intercepted.
2881 */
2882 if (!CPUMIsGuestVmxProcCtls2Set(&pVCpu->cpum.s.Guest, VMX_PROC_CTLS2_VMCS_SHADOWING))
2883 return true;
2884
2885 /*
2886 * If any reserved bit in the 64-bit VMCS field encoding is set, the VMREAD/VMWRITE
2887 * is intercepted. This excludes any reserved bits in the valid parts of the field
2888 * encoding (i.e. bit 12).
2889 */
2890 if (u64VmcsField & VMX_VMCSFIELD_RSVD_MASK)
2891 return true;
2892
2893 /*
2894 * Finally, consult the VMREAD/VMWRITE bitmap whether to intercept the instruction or not.
2895 */
2896 uint32_t const u32VmcsField = RT_LO_U32(u64VmcsField);
2897 uint8_t const * const pbBitmap = uExitReason == VMX_EXIT_VMREAD
2898 ? &pVCpu->cpum.s.Guest.hwvirt.vmx.abVmreadBitmap[0]
2899 : &pVCpu->cpum.s.Guest.hwvirt.vmx.abVmwriteBitmap[0];
2900 Assert(pbBitmap);
2901 Assert(u32VmcsField >> 3 < VMX_V_VMREAD_VMWRITE_BITMAP_SIZE);
2902 return ASMBitTest(&pbBitmap[u32VmcsField >> 3], u32VmcsField & 7);
2903}
2904
2905
2906
2907/**
2908 * Determines whether the given I/O access should cause a nested-guest \#VMEXIT.
2909 *
2910 * @param pvIoBitmap Pointer to the nested-guest IO bitmap.
2911 * @param u16Port The IO port being accessed.
2912 * @param enmIoType The type of IO access.
2913 * @param cbReg The IO operand size in bytes.
2914 * @param cAddrSizeBits The address size bits (for 16, 32 or 64).
2915 * @param iEffSeg The effective segment number.
2916 * @param fRep Whether this is a repeating IO instruction (REP prefix).
2917 * @param fStrIo Whether this is a string IO instruction.
2918 * @param pIoExitInfo Pointer to the SVMIOIOEXITINFO struct to be filled.
2919 * Optional, can be NULL.
2920 */
2921VMM_INT_DECL(bool) CPUMIsSvmIoInterceptSet(void *pvIoBitmap, uint16_t u16Port, SVMIOIOTYPE enmIoType, uint8_t cbReg,
2922 uint8_t cAddrSizeBits, uint8_t iEffSeg, bool fRep, bool fStrIo,
2923 PSVMIOIOEXITINFO pIoExitInfo)
2924{
2925 Assert(cAddrSizeBits == 16 || cAddrSizeBits == 32 || cAddrSizeBits == 64);
2926 Assert(cbReg == 1 || cbReg == 2 || cbReg == 4 || cbReg == 8);
2927
2928 /*
2929 * The IOPM layout:
2930 * Each bit represents one 8-bit port. That makes a total of 0..65535 bits or
2931 * two 4K pages.
2932 *
2933 * For IO instructions that access more than a single byte, the permission bits
2934 * for all bytes are checked; if any bit is set to 1, the IO access is intercepted.
2935 *
2936 * Since it's possible to do a 32-bit IO access at port 65534 (accessing 4 bytes),
2937 * we need 3 extra bits beyond the second 4K page.
2938 */
2939 static const uint16_t s_auSizeMasks[] = { 0, 1, 3, 0, 0xf, 0, 0, 0 };
2940
2941 uint16_t const offIopm = u16Port >> 3;
2942 uint16_t const fSizeMask = s_auSizeMasks[(cAddrSizeBits >> SVM_IOIO_OP_SIZE_SHIFT) & 7];
2943 uint8_t const cShift = u16Port - (offIopm << 3);
2944 uint16_t const fIopmMask = (1 << cShift) | (fSizeMask << cShift);
2945
2946 uint8_t const *pbIopm = (uint8_t *)pvIoBitmap;
2947 Assert(pbIopm);
2948 pbIopm += offIopm;
2949 uint16_t const u16Iopm = *(uint16_t *)pbIopm;
2950 if (u16Iopm & fIopmMask)
2951 {
2952 if (pIoExitInfo)
2953 {
2954 static const uint32_t s_auIoOpSize[] =
2955 { SVM_IOIO_32_BIT_OP, SVM_IOIO_8_BIT_OP, SVM_IOIO_16_BIT_OP, 0, SVM_IOIO_32_BIT_OP, 0, 0, 0 };
2956
2957 static const uint32_t s_auIoAddrSize[] =
2958 { 0, SVM_IOIO_16_BIT_ADDR, SVM_IOIO_32_BIT_ADDR, 0, SVM_IOIO_64_BIT_ADDR, 0, 0, 0 };
2959
2960 pIoExitInfo->u = s_auIoOpSize[cbReg & 7];
2961 pIoExitInfo->u |= s_auIoAddrSize[(cAddrSizeBits >> 4) & 7];
2962 pIoExitInfo->n.u1Str = fStrIo;
2963 pIoExitInfo->n.u1Rep = fRep;
2964 pIoExitInfo->n.u3Seg = iEffSeg & 7;
2965 pIoExitInfo->n.u1Type = enmIoType;
2966 pIoExitInfo->n.u16Port = u16Port;
2967 }
2968 return true;
2969 }
2970
2971 /** @todo remove later (for debugging as VirtualBox always traps all IO
2972 * intercepts). */
2973 AssertMsgFailed(("CPUMSvmIsIOInterceptActive: We expect an IO intercept here!\n"));
2974 return false;
2975}
2976
2977
2978/**
2979 * Gets the MSR permission bitmap byte and bit offset for the specified MSR.
2980 *
2981 * @returns VBox status code.
2982 * @param idMsr The MSR being requested.
2983 * @param pbOffMsrpm Where to store the byte offset in the MSR permission
2984 * bitmap for @a idMsr.
2985 * @param puMsrpmBit Where to store the bit offset starting at the byte
2986 * returned in @a pbOffMsrpm.
2987 */
2988VMM_INT_DECL(int) CPUMGetSvmMsrpmOffsetAndBit(uint32_t idMsr, uint16_t *pbOffMsrpm, uint8_t *puMsrpmBit)
2989{
2990 Assert(pbOffMsrpm);
2991 Assert(puMsrpmBit);
2992
2993 /*
2994 * MSRPM Layout:
2995 * Byte offset MSR range
2996 * 0x000 - 0x7ff 0x00000000 - 0x00001fff
2997 * 0x800 - 0xfff 0xc0000000 - 0xc0001fff
2998 * 0x1000 - 0x17ff 0xc0010000 - 0xc0011fff
2999 * 0x1800 - 0x1fff Reserved
3000 *
3001 * Each MSR is represented by 2 permission bits (read and write).
3002 */
3003 if (idMsr <= 0x00001fff)
3004 {
3005 /* Pentium-compatible MSRs. */
3006 uint32_t const bitoffMsr = idMsr << 1;
3007 *pbOffMsrpm = bitoffMsr >> 3;
3008 *puMsrpmBit = bitoffMsr & 7;
3009 return VINF_SUCCESS;
3010 }
3011
3012 if ( idMsr >= 0xc0000000
3013 && idMsr <= 0xc0001fff)
3014 {
3015 /* AMD Sixth Generation x86 Processor MSRs. */
3016 uint32_t const bitoffMsr = (idMsr - 0xc0000000) << 1;
3017 *pbOffMsrpm = 0x800 + (bitoffMsr >> 3);
3018 *puMsrpmBit = bitoffMsr & 7;
3019 return VINF_SUCCESS;
3020 }
3021
3022 if ( idMsr >= 0xc0010000
3023 && idMsr <= 0xc0011fff)
3024 {
3025 /* AMD Seventh and Eighth Generation Processor MSRs. */
3026 uint32_t const bitoffMsr = (idMsr - 0xc0010000) << 1;
3027 *pbOffMsrpm = 0x1000 + (bitoffMsr >> 3);
3028 *puMsrpmBit = bitoffMsr & 7;
3029 return VINF_SUCCESS;
3030 }
3031
3032 *pbOffMsrpm = 0;
3033 *puMsrpmBit = 0;
3034 return VERR_OUT_OF_RANGE;
3035}
3036
3037
3038/**
3039 * Checks whether the guest is in VMX non-root mode and using EPT paging.
3040 *
3041 * @returns @c true if in VMX non-root operation with EPT, @c false otherwise.
3042 * @param pVCpu The cross context virtual CPU structure.
3043 */
3044VMM_INT_DECL(bool) CPUMIsGuestVmxEptPagingEnabled(PCVMCPUCC pVCpu)
3045{
3046 return CPUMIsGuestVmxEptPagingEnabledEx(&pVCpu->cpum.s.Guest);
3047}
3048
3049
3050/**
3051 * Checks whether the guest is in VMX non-root mode and using EPT paging and the
3052 * nested-guest is in PAE mode.
3053 *
3054 * @returns @c true if in VMX non-root operation with EPT, @c false otherwise.
3055 * @param pVCpu The cross context virtual CPU structure.
3056 */
3057VMM_INT_DECL(bool) CPUMIsGuestVmxEptPaePagingEnabled(PCVMCPUCC pVCpu)
3058{
3059 return CPUMIsGuestVmxEptPagingEnabledEx(&pVCpu->cpum.s.Guest)
3060 && CPUMIsGuestInPAEModeEx(&pVCpu->cpum.s.Guest);
3061}
3062
Note: See TracBrowser for help on using the repository browser.

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