VirtualBox

source: vbox/trunk/src/VBox/VMM/VMMAll/PGMAllGstSlatEpt.cpp.h@ 92561

Last change on this file since 92561 was 92541, checked in by vboxsync, 3 years ago

VMM: Nested VMX: bugref:10092 Allow forcing mapping/unmapping of CR3 even when the paging mode deosn't actually change. This is required for VMX/SVM guest transitions.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 14.4 KB
Line 
1/* $Id: PGMAllGstSlatEpt.cpp.h 92541 2021-11-22 06:35:38Z vboxsync $ */
2/** @file
3 * VBox - Page Manager, Guest EPT SLAT - All context code.
4 */
5
6/*
7 * Copyright (C) 2021 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#if PGM_GST_TYPE == PGM_TYPE_EPT
19DECLINLINE(bool) PGM_GST_SLAT_NAME_EPT(WalkIsPermValid)(PCVMCPUCC pVCpu, uint64_t uEntry)
20{
21 if (!(uEntry & VMX_BF_EPT_PT_READ_MASK))
22 {
23 if (uEntry & VMX_BF_EPT_PT_WRITE_MASK)
24 return false;
25
26 Assert(!pVCpu->CTX_SUFF(pVM)->cpum.ro.GuestFeatures.fVmxModeBasedExecuteEpt);
27 if ( !RT_BF_GET(pVCpu->pgm.s.uEptVpidCapMsr, VMX_BF_EPT_VPID_CAP_EXEC_ONLY)
28 && (uEntry & VMX_BF_EPT_PT_EXECUTE_MASK))
29 return false;
30 }
31 return true;
32}
33
34
35DECLINLINE(bool) PGM_GST_SLAT_NAME_EPT(WalkIsMemTypeValid)(uint64_t uEntry, uint8_t uLevel)
36{
37 Assert(uLevel >= 3 && uLevel <= 1); NOREF(uLevel);
38 uint64_t const fEptMemTypeMask = uEntry & VMX_BF_EPT_PT_MEMTYPE_MASK;
39 if ( fEptMemTypeMask == EPT_E_MEMTYPE_INVALID_2
40 || fEptMemTypeMask == EPT_E_MEMTYPE_INVALID_3
41 || fEptMemTypeMask == EPT_E_MEMTYPE_INVALID_7)
42 return false;
43 return true;
44}
45
46
47DECLINLINE(int) PGM_GST_SLAT_NAME_EPT(WalkReturnNotPresent)(PCVMCPUCC pVCpu, PPGMPTWALK pWalk, uint64_t uEntry, uint8_t uLevel)
48{
49 static PGMSLATFAIL const s_aEptViolation[] = { PGMSLATFAIL_EPT_VIOLATION, PGMSLATFAIL_EPT_VIOLATION_CONVERTIBLE };
50 uint8_t const fEptVeSupported = pVCpu->CTX_SUFF(pVM)->cpum.ro.GuestFeatures.fVmxEptXcptVe;
51 uint8_t const idxViolationType = fEptVeSupported & !RT_BF_GET(uEntry, VMX_BF_EPT_PT_SUPPRESS_VE);
52
53 pWalk->fNotPresent = true;
54 pWalk->uLevel = uLevel;
55 pWalk->enmSlatFail = s_aEptViolation[idxViolationType];
56 return VERR_PAGE_TABLE_NOT_PRESENT;
57}
58
59
60DECLINLINE(int) PGM_GST_SLAT_NAME_EPT(WalkReturnBadPhysAddr)(PCVMCPUCC pVCpu, PPGMPTWALK pWalk, uint8_t uLevel, int rc)
61{
62 AssertMsg(rc == VERR_PGM_INVALID_GC_PHYSICAL_ADDRESS, ("%Rrc\n", rc)); NOREF(rc); NOREF(pVCpu);
63 pWalk->fBadPhysAddr = true;
64 pWalk->uLevel = uLevel;
65 pWalk->enmSlatFail = PGMSLATFAIL_EPT_VIOLATION;
66 return VERR_PAGE_TABLE_NOT_PRESENT;
67}
68
69
70DECLINLINE(int) PGM_GST_SLAT_NAME_EPT(WalkReturnRsvdError)(PVMCPUCC pVCpu, PPGMPTWALK pWalk, uint8_t uLevel)
71{
72 NOREF(pVCpu);
73 pWalk->fRsvdError = true;
74 pWalk->uLevel = uLevel;
75 pWalk->enmSlatFail = PGMSLATFAIL_EPT_MISCONFIG;
76 return VERR_PAGE_TABLE_NOT_PRESENT;
77}
78
79
80DECLINLINE(int) PGM_GST_SLAT_NAME_EPT(Walk)(PVMCPUCC pVCpu, RTGCPHYS GCPhysNested, bool fIsLinearAddrValid, RTGCPTR GCPtrNested,
81 PPGMPTWALK pWalk, PGSTPTWALK pGstWalk)
82{
83 /*
84 * Init walk structures.
85 */
86 RT_ZERO(*pWalk);
87 RT_ZERO(*pGstWalk);
88
89 pWalk->GCPtr = GCPtrNested;
90 pWalk->GCPhysNested = GCPhysNested;
91 pWalk->fIsLinearAddrValid = fIsLinearAddrValid;
92 pWalk->fIsSlat = true;
93
94 /*
95 * Figure out EPT attributes that are cumulative (logical-AND) across page walks.
96 * - R, W, X_SUPER are unconditionally cumulative.
97 * See Intel spec. Table 26-7 "Exit Qualification for EPT Violations".
98 *
99 * - X_USER is cumulative but relevant only when mode-based execute control for EPT
100 * which we currently don't support it (asserted below).
101 *
102 * - MEMTYPE is not cumulative and only applicable to the final paging entry.
103 *
104 * - A, D EPT bits map to the regular page-table bit positions. Thus, they're not
105 * included in the mask below and handled separately. Accessed bits are
106 * cumulative but dirty bits are not cumulative as they're only applicable to
107 * the final paging entry.
108 */
109 Assert(!pVCpu->CTX_SUFF(pVM)->cpum.ro.GuestFeatures.fVmxModeBasedExecuteEpt);
110 uint64_t const fCumulativeEpt = PGM_PTATTRS_EPT_R_MASK
111 | PGM_PTATTRS_EPT_W_MASK
112 | PGM_PTATTRS_EPT_X_SUPER_MASK;
113
114 /*
115 * Do the walk.
116 */
117 uint64_t fEffective;
118 {
119 /*
120 * Start with reading the EPT PML4E pointer.
121 *
122 * We currently only support 4 level EPT paging.
123 * EPT 5 level paging was documented at some point (bit 7 of MSR_IA32_VMX_EPT_VPID_CAP)
124 * but for some reason seems to have been removed from subsequent specs.
125 */
126 int const rc = pgmGstGetEptPML4PtrEx(pVCpu, &pGstWalk->pPml4);
127 if (RT_SUCCESS(rc))
128 { /* likely */ }
129 else
130 return PGM_GST_SLAT_NAME_EPT(WalkReturnBadPhysAddr)(pVCpu, pWalk, 4, rc);
131 }
132 {
133 /*
134 * PML4E.
135 */
136 PEPTPML4E pPml4e;
137 pGstWalk->pPml4e = pPml4e = &pGstWalk->pPml4->a[(GCPhysNested >> EPT_PML4_SHIFT) & EPT_PML4_MASK];
138 EPTPML4E Pml4e;
139 pGstWalk->Pml4e.u = Pml4e.u = pPml4e->u;
140
141 if (GST_IS_PGENTRY_PRESENT(pVCpu, Pml4e)) { /* probable */ }
142 else return PGM_GST_SLAT_NAME_EPT(WalkReturnNotPresent)(pVCpu, pWalk, Pml4e.u, 4);
143
144 if (RT_LIKELY(GST_IS_PML4E_VALID(pVCpu, Pml4e))) { /* likely */ }
145 else return PGM_GST_SLAT_NAME_EPT(WalkReturnRsvdError)(pVCpu, pWalk, 4);
146
147 Assert(!pVCpu->CTX_SUFF(pVM)->cpum.ro.GuestFeatures.fVmxModeBasedExecuteEpt);
148 uint64_t const fEptAttrs = Pml4e.u & EPT_PML4E_ATTR_MASK;
149 uint8_t const fRead = RT_BF_GET(fEptAttrs, VMX_BF_EPT_PT_READ);
150 uint8_t const fWrite = RT_BF_GET(fEptAttrs, VMX_BF_EPT_PT_WRITE);
151 uint8_t const fAccessed = RT_BF_GET(fEptAttrs, VMX_BF_EPT_PT_ACCESSED);
152 uint64_t const fEffectiveEpt = (fEptAttrs << PGM_PTATTRS_EPT_SHIFT) & PGM_PTATTRS_EPT_MASK;
153 fEffective = RT_BF_MAKE(PGM_PTATTRS_R, fRead)
154 | RT_BF_MAKE(PGM_PTATTRS_W, fWrite)
155 | RT_BF_MAKE(PGM_PTATTRS_A, fAccessed)
156 | fEffectiveEpt;
157 pWalk->fEffective = fEffective;
158
159 int const rc = PGM_GCPHYS_2_PTR_BY_VMCPU(pVCpu, Pml4e.u & EPT_PML4E_PG_MASK, &pGstWalk->pPdpt);
160 if (RT_SUCCESS(rc)) { /* probable */ }
161 else return PGM_GST_SLAT_NAME_EPT(WalkReturnBadPhysAddr)(pVCpu, pWalk, 3, rc);
162 }
163 {
164 /*
165 * PDPTE.
166 */
167 PEPTPDPTE pPdpte;
168 pGstWalk->pPdpte = pPdpte = &pGstWalk->pPdpt->a[(GCPhysNested >> GST_PDPT_SHIFT) & GST_PDPT_MASK];
169 EPTPDPTE Pdpte;
170 pGstWalk->Pdpte.u = Pdpte.u = pPdpte->u;
171
172 if (GST_IS_PGENTRY_PRESENT(pVCpu, Pdpte)) { /* probable */ }
173 else return PGM_GST_SLAT_NAME_EPT(WalkReturnNotPresent)(pVCpu, pWalk, Pdpte.u, 3);
174
175 /* The order of the following 2 "if" statements matter. */
176 if (GST_IS_PDPE_VALID(pVCpu, Pdpte))
177 {
178 uint64_t const fEptAttrs = Pdpte.u & EPT_PDPTE_ATTR_MASK;
179 uint8_t const fRead = RT_BF_GET(fEptAttrs, VMX_BF_EPT_PT_READ);
180 uint8_t const fWrite = RT_BF_GET(fEptAttrs, VMX_BF_EPT_PT_WRITE);
181 uint8_t const fAccessed = RT_BF_GET(fEptAttrs, VMX_BF_EPT_PT_ACCESSED);
182 uint64_t const fEffectiveEpt = (fEptAttrs << PGM_PTATTRS_EPT_SHIFT) & PGM_PTATTRS_EPT_MASK;
183 fEffective &= RT_BF_MAKE(PGM_PTATTRS_R, fRead)
184 | RT_BF_MAKE(PGM_PTATTRS_W, fWrite)
185 | RT_BF_MAKE(PGM_PTATTRS_A, fAccessed)
186 | (fEffectiveEpt & fCumulativeEpt);
187 pWalk->fEffective = fEffective;
188 }
189 else if ( GST_IS_BIG_PDPE_VALID(pVCpu, Pdpte)
190 && PGM_GST_SLAT_NAME_EPT(WalkIsMemTypeValid)(Pdpte.u, 3))
191 {
192 uint64_t const fEptAttrs = Pdpte.u & EPT_PDPTE1G_ATTR_MASK;
193 uint8_t const fRead = RT_BF_GET(fEptAttrs, VMX_BF_EPT_PT_READ);
194 uint8_t const fWrite = RT_BF_GET(fEptAttrs, VMX_BF_EPT_PT_WRITE);
195 uint8_t const fAccessed = RT_BF_GET(fEptAttrs, VMX_BF_EPT_PT_ACCESSED);
196 uint8_t const fDirty = RT_BF_GET(fEptAttrs, VMX_BF_EPT_PT_DIRTY);
197 uint8_t const fMemType = RT_BF_GET(fEptAttrs, VMX_BF_EPT_PT_MEMTYPE);
198 uint64_t const fEffectiveEpt = (fEptAttrs << PGM_PTATTRS_EPT_SHIFT) & PGM_PTATTRS_EPT_MASK;
199 fEffective &= RT_BF_MAKE(PGM_PTATTRS_R, fRead)
200 | RT_BF_MAKE(PGM_PTATTRS_W, fWrite)
201 | RT_BF_MAKE(PGM_PTATTRS_A, fAccessed)
202 | (fEffectiveEpt & fCumulativeEpt);
203 fEffective |= RT_BF_MAKE(PGM_PTATTRS_D, fDirty)
204 | RT_BF_MAKE(PGM_PTATTRS_EPT_MEMTYPE, fMemType);
205 pWalk->fEffective = fEffective;
206
207 pWalk->fGigantPage = true;
208 pWalk->fSucceeded = true;
209 pWalk->GCPhys = GST_GET_BIG_PDPE_GCPHYS(pVCpu->CTX_SUFF(pVM), Pdpte)
210 | (GCPhysNested & GST_GIGANT_PAGE_OFFSET_MASK);
211 PGM_A20_APPLY_TO_VAR(pVCpu, pWalk->GCPhys);
212 return VINF_SUCCESS;
213 }
214 else return PGM_GST_SLAT_NAME_EPT(WalkReturnRsvdError)(pVCpu, pWalk, 3);
215
216 int const rc = PGM_GCPHYS_2_PTR_BY_VMCPU(pVCpu, Pdpte.u & EPT_PDPTE_PG_MASK, &pGstWalk->pPd);
217 if (RT_SUCCESS(rc)) { /* probable */ }
218 else return PGM_GST_SLAT_NAME_EPT(WalkReturnBadPhysAddr)(pVCpu, pWalk, 3, rc);
219 }
220 {
221 /*
222 * PDE.
223 */
224 PGSTPDE pPde;
225 pGstWalk->pPde = pPde = &pGstWalk->pPd->a[(GCPhysNested >> GST_PD_SHIFT) & GST_PD_MASK];
226 GSTPDE Pde;
227 pGstWalk->Pde.u = Pde.u = pPde->u;
228
229 if (GST_IS_PGENTRY_PRESENT(pVCpu, Pde)) { /* probable */ }
230 else return PGM_GST_SLAT_NAME_EPT(WalkReturnNotPresent)(pVCpu, pWalk, Pde.u, 2);
231
232 /* The order of the following 2 "if" statements matter. */
233 if (GST_IS_PDE_VALID(pVCpu, Pde))
234 {
235 uint64_t const fEptAttrs = Pde.u & EPT_PDE_ATTR_MASK;
236 uint8_t const fRead = RT_BF_GET(fEptAttrs, VMX_BF_EPT_PT_READ);
237 uint8_t const fWrite = RT_BF_GET(fEptAttrs, VMX_BF_EPT_PT_WRITE);
238 uint8_t const fAccessed = RT_BF_GET(fEptAttrs, VMX_BF_EPT_PT_ACCESSED);
239 uint64_t const fEffectiveEpt = (fEptAttrs << PGM_PTATTRS_EPT_SHIFT) & PGM_PTATTRS_EPT_MASK;
240 fEffective &= RT_BF_MAKE(PGM_PTATTRS_R, fRead)
241 | RT_BF_MAKE(PGM_PTATTRS_W, fWrite)
242 | RT_BF_MAKE(PGM_PTATTRS_A, fAccessed)
243 | (fEffectiveEpt & fCumulativeEpt);
244 pWalk->fEffective = fEffective;
245
246 }
247 else if ( GST_IS_BIG_PDE_VALID(pVCpu, Pde)
248 && PGM_GST_SLAT_NAME_EPT(WalkIsMemTypeValid)(Pde.u, 2))
249 {
250 uint64_t const fEptAttrs = Pde.u & EPT_PDE2M_ATTR_MASK;
251 uint8_t const fRead = RT_BF_GET(fEptAttrs, VMX_BF_EPT_PT_READ);
252 uint8_t const fWrite = RT_BF_GET(fEptAttrs, VMX_BF_EPT_PT_WRITE);
253 uint8_t const fAccessed = RT_BF_GET(fEptAttrs, VMX_BF_EPT_PT_ACCESSED);
254 uint8_t const fDirty = RT_BF_GET(fEptAttrs, VMX_BF_EPT_PT_DIRTY);
255 uint8_t const fMemType = RT_BF_GET(fEptAttrs, VMX_BF_EPT_PT_MEMTYPE);
256 uint64_t const fEffectiveEpt = (fEptAttrs << PGM_PTATTRS_EPT_SHIFT) & PGM_PTATTRS_EPT_MASK;
257 fEffective &= RT_BF_MAKE(PGM_PTATTRS_R, fRead)
258 | RT_BF_MAKE(PGM_PTATTRS_W, fWrite)
259 | RT_BF_MAKE(PGM_PTATTRS_A, fAccessed)
260 | (fEffectiveEpt & fCumulativeEpt);
261 fEffective |= RT_BF_MAKE(PGM_PTATTRS_D, fDirty)
262 | RT_BF_MAKE(PGM_PTATTRS_EPT_MEMTYPE, fMemType);
263 pWalk->fEffective = fEffective;
264
265 pWalk->fBigPage = true;
266 pWalk->fSucceeded = true;
267 pWalk->GCPhys = GST_GET_BIG_PDE_GCPHYS(pVCpu->CTX_SUFF(pVM), Pde)
268 | (GCPhysNested & GST_BIG_PAGE_OFFSET_MASK);
269 PGM_A20_APPLY_TO_VAR(pVCpu, pWalk->GCPhys);
270 return VINF_SUCCESS;
271 }
272 else return PGM_GST_SLAT_NAME_EPT(WalkReturnRsvdError)(pVCpu, pWalk, 2);
273
274 int const rc = PGM_GCPHYS_2_PTR_BY_VMCPU(pVCpu, GST_GET_PDE_GCPHYS(Pde), &pGstWalk->pPt);
275 if (RT_SUCCESS(rc)) { /* probable */ }
276 else return PGM_GST_SLAT_NAME_EPT(WalkReturnBadPhysAddr)(pVCpu, pWalk, 1, rc);
277 }
278 {
279 /*
280 * PTE.
281 */
282 PGSTPTE pPte;
283 pGstWalk->pPte = pPte = &pGstWalk->pPt->a[(GCPhysNested >> GST_PT_SHIFT) & GST_PT_MASK];
284 GSTPTE Pte;
285 pGstWalk->Pte.u = Pte.u = pPte->u;
286
287 if (GST_IS_PGENTRY_PRESENT(pVCpu, Pte)) { /* probable */ }
288 else return PGM_GST_SLAT_NAME_EPT(WalkReturnNotPresent)(pVCpu, pWalk, Pte.u, 1);
289
290 if ( GST_IS_PTE_VALID(pVCpu, Pte)
291 && PGM_GST_SLAT_NAME_EPT(WalkIsMemTypeValid)(Pte.u, 1))
292 { /* likely*/ }
293 else
294 return PGM_GST_SLAT_NAME_EPT(WalkReturnRsvdError)(pVCpu, pWalk, 1);
295
296 uint64_t const fEptAttrs = Pte.u & EPT_PTE_ATTR_MASK;
297 uint8_t const fRead = RT_BF_GET(fEptAttrs, VMX_BF_EPT_PT_READ);
298 uint8_t const fWrite = RT_BF_GET(fEptAttrs, VMX_BF_EPT_PT_WRITE);
299 uint8_t const fAccessed = RT_BF_GET(fEptAttrs, VMX_BF_EPT_PT_ACCESSED);
300 uint8_t const fDirty = RT_BF_GET(fEptAttrs, VMX_BF_EPT_PT_DIRTY);
301 uint8_t const fMemType = RT_BF_GET(fEptAttrs, VMX_BF_EPT_PT_MEMTYPE);
302 uint64_t const fEffectiveEpt = (fEptAttrs << PGM_PTATTRS_EPT_SHIFT) & PGM_PTATTRS_EPT_MASK;
303 fEffective &= RT_BF_MAKE(PGM_PTATTRS_R, fRead)
304 | RT_BF_MAKE(PGM_PTATTRS_W, fWrite)
305 | RT_BF_MAKE(PGM_PTATTRS_A, fAccessed)
306 | (fEffectiveEpt & fCumulativeEpt);
307 fEffective |= RT_BF_MAKE(PGM_PTATTRS_D, fDirty)
308 | RT_BF_MAKE(PGM_PTATTRS_EPT_MEMTYPE, fMemType);
309 pWalk->fEffective = fEffective;
310
311 pWalk->fSucceeded = true;
312 pWalk->GCPhys = GST_GET_PTE_GCPHYS(Pte) | (GCPhysNested & PAGE_OFFSET_MASK);
313 return VINF_SUCCESS;
314 }
315}
316#else
317# error "Guest paging type must be EPT."
318#endif
319
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