VirtualBox

source: vbox/trunk/src/VBox/VMM/VMMAll/PGMAll.cpp@ 17658

Last change on this file since 17658 was 17658, checked in by vboxsync, 16 years ago

PGMGetHyperCR3: mac fix.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 77.8 KB
Line 
1/* $Id: PGMAll.cpp 17658 2009-03-11 08:07:58Z vboxsync $ */
2/** @file
3 * PGM - Page Manager and Monitor - All context code.
4 */
5
6/*
7 * Copyright (C) 2006-2007 Sun Microsystems, Inc.
8 *
9 * This file is part of VirtualBox Open Source Edition (OSE), as
10 * available from http://www.virtualbox.org. This file is free software;
11 * you can redistribute it and/or modify it under the terms of the GNU
12 * General Public License (GPL) as published by the Free Software
13 * Foundation, in version 2 as it comes in the "COPYING" file of the
14 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16 *
17 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
18 * Clara, CA 95054 USA or visit http://www.sun.com if you need
19 * additional information or have any questions.
20 */
21
22/*******************************************************************************
23* Header Files *
24*******************************************************************************/
25#define LOG_GROUP LOG_GROUP_PGM
26#include <VBox/pgm.h>
27#include <VBox/cpum.h>
28#include <VBox/selm.h>
29#include <VBox/iom.h>
30#include <VBox/sup.h>
31#include <VBox/mm.h>
32#include <VBox/stam.h>
33#include <VBox/csam.h>
34#include <VBox/patm.h>
35#include <VBox/trpm.h>
36#include <VBox/rem.h>
37#include <VBox/em.h>
38#include <VBox/hwaccm.h>
39#include <VBox/hwacc_vmx.h>
40#include "PGMInternal.h"
41#include <VBox/vm.h>
42#include <iprt/assert.h>
43#include <iprt/asm.h>
44#include <iprt/string.h>
45#include <VBox/log.h>
46#include <VBox/param.h>
47#include <VBox/err.h>
48
49
50/*******************************************************************************
51* Structures and Typedefs *
52*******************************************************************************/
53/**
54 * Stated structure for PGM_GST_NAME(HandlerVirtualUpdate) that's
55 * passed to PGM_GST_NAME(VirtHandlerUpdateOne) during enumeration.
56 */
57typedef struct PGMHVUSTATE
58{
59 /** The VM handle. */
60 PVM pVM;
61 /** The todo flags. */
62 RTUINT fTodo;
63 /** The CR4 register value. */
64 uint32_t cr4;
65} PGMHVUSTATE, *PPGMHVUSTATE;
66
67
68/*******************************************************************************
69* Internal Functions *
70*******************************************************************************/
71DECLINLINE(int) pgmShwGetLongModePDPtr(PVM pVM, RTGCPTR64 GCPtr, PX86PML4E *ppPml4e, PX86PDPT *ppPdpt, PX86PDPAE *ppPD);
72DECLINLINE(int) pgmShwGetPAEPDPtr(PVM pVM, RTGCPTR GCPtr, PX86PDPT *ppPdpt, PX86PDPAE *ppPD);
73DECLINLINE(int) pgmShwGetPaePoolPagePD(PPGM pPGM, RTGCPTR GCPtr, PPGMPOOLPAGE *ppShwPde);
74
75/*
76 * Shadow - 32-bit mode
77 */
78#define PGM_SHW_TYPE PGM_TYPE_32BIT
79#define PGM_SHW_NAME(name) PGM_SHW_NAME_32BIT(name)
80#include "PGMAllShw.h"
81
82/* Guest - real mode */
83#define PGM_GST_TYPE PGM_TYPE_REAL
84#define PGM_GST_NAME(name) PGM_GST_NAME_REAL(name)
85#define PGM_BTH_NAME(name) PGM_BTH_NAME_32BIT_REAL(name)
86#define BTH_PGMPOOLKIND_PT_FOR_PT PGMPOOLKIND_32BIT_PT_FOR_PHYS
87#define BTH_PGMPOOLKIND_ROOT PGMPOOLKIND_32BIT_PD_PHYS
88#include "PGMGstDefs.h"
89#include "PGMAllGst.h"
90#include "PGMAllBth.h"
91#undef BTH_PGMPOOLKIND_PT_FOR_PT
92#undef BTH_PGMPOOLKIND_ROOT
93#undef PGM_BTH_NAME
94#undef PGM_GST_TYPE
95#undef PGM_GST_NAME
96
97/* Guest - protected mode */
98#define PGM_GST_TYPE PGM_TYPE_PROT
99#define PGM_GST_NAME(name) PGM_GST_NAME_PROT(name)
100#define PGM_BTH_NAME(name) PGM_BTH_NAME_32BIT_PROT(name)
101#define BTH_PGMPOOLKIND_PT_FOR_PT PGMPOOLKIND_32BIT_PT_FOR_PHYS
102#define BTH_PGMPOOLKIND_ROOT PGMPOOLKIND_32BIT_PD_PHYS
103#include "PGMGstDefs.h"
104#include "PGMAllGst.h"
105#include "PGMAllBth.h"
106#undef BTH_PGMPOOLKIND_PT_FOR_PT
107#undef BTH_PGMPOOLKIND_ROOT
108#undef PGM_BTH_NAME
109#undef PGM_GST_TYPE
110#undef PGM_GST_NAME
111
112/* Guest - 32-bit mode */
113#define PGM_GST_TYPE PGM_TYPE_32BIT
114#define PGM_GST_NAME(name) PGM_GST_NAME_32BIT(name)
115#define PGM_BTH_NAME(name) PGM_BTH_NAME_32BIT_32BIT(name)
116#define BTH_PGMPOOLKIND_PT_FOR_PT PGMPOOLKIND_32BIT_PT_FOR_32BIT_PT
117#define BTH_PGMPOOLKIND_PT_FOR_BIG PGMPOOLKIND_32BIT_PT_FOR_32BIT_4MB
118#define BTH_PGMPOOLKIND_ROOT PGMPOOLKIND_32BIT_PD
119#include "PGMGstDefs.h"
120#include "PGMAllGst.h"
121#include "PGMAllBth.h"
122#undef BTH_PGMPOOLKIND_PT_FOR_BIG
123#undef BTH_PGMPOOLKIND_PT_FOR_PT
124#undef BTH_PGMPOOLKIND_ROOT
125#undef PGM_BTH_NAME
126#undef PGM_GST_TYPE
127#undef PGM_GST_NAME
128
129#undef PGM_SHW_TYPE
130#undef PGM_SHW_NAME
131
132
133/*
134 * Shadow - PAE mode
135 */
136#define PGM_SHW_TYPE PGM_TYPE_PAE
137#define PGM_SHW_NAME(name) PGM_SHW_NAME_PAE(name)
138#define PGM_BTH_NAME(name) PGM_BTH_NAME_PAE_REAL(name)
139#include "PGMAllShw.h"
140
141/* Guest - real mode */
142#define PGM_GST_TYPE PGM_TYPE_REAL
143#define PGM_GST_NAME(name) PGM_GST_NAME_REAL(name)
144#define PGM_BTH_NAME(name) PGM_BTH_NAME_PAE_REAL(name)
145#define BTH_PGMPOOLKIND_PT_FOR_PT PGMPOOLKIND_PAE_PT_FOR_PHYS
146#define BTH_PGMPOOLKIND_ROOT PGMPOOLKIND_PAE_PDPT_PHYS
147#include "PGMGstDefs.h"
148#include "PGMAllBth.h"
149#undef BTH_PGMPOOLKIND_PT_FOR_PT
150#undef BTH_PGMPOOLKIND_ROOT
151#undef PGM_BTH_NAME
152#undef PGM_GST_TYPE
153#undef PGM_GST_NAME
154
155/* Guest - protected mode */
156#define PGM_GST_TYPE PGM_TYPE_PROT
157#define PGM_GST_NAME(name) PGM_GST_NAME_PROT(name)
158#define PGM_BTH_NAME(name) PGM_BTH_NAME_PAE_PROT(name)
159#define BTH_PGMPOOLKIND_PT_FOR_PT PGMPOOLKIND_PAE_PT_FOR_PHYS
160#define BTH_PGMPOOLKIND_ROOT PGMPOOLKIND_PAE_PDPT_PHYS
161#include "PGMGstDefs.h"
162#include "PGMAllBth.h"
163#undef BTH_PGMPOOLKIND_PT_FOR_PT
164#undef BTH_PGMPOOLKIND_ROOT
165#undef PGM_BTH_NAME
166#undef PGM_GST_TYPE
167#undef PGM_GST_NAME
168
169/* Guest - 32-bit mode */
170#define PGM_GST_TYPE PGM_TYPE_32BIT
171#define PGM_GST_NAME(name) PGM_GST_NAME_32BIT(name)
172#define PGM_BTH_NAME(name) PGM_BTH_NAME_PAE_32BIT(name)
173#define BTH_PGMPOOLKIND_PT_FOR_PT PGMPOOLKIND_PAE_PT_FOR_32BIT_PT
174#define BTH_PGMPOOLKIND_PT_FOR_BIG PGMPOOLKIND_PAE_PT_FOR_32BIT_4MB
175#define BTH_PGMPOOLKIND_ROOT PGMPOOLKIND_PAE_PDPT_FOR_32BIT
176#include "PGMGstDefs.h"
177#include "PGMAllBth.h"
178#undef BTH_PGMPOOLKIND_PT_FOR_BIG
179#undef BTH_PGMPOOLKIND_PT_FOR_PT
180#undef BTH_PGMPOOLKIND_ROOT
181#undef PGM_BTH_NAME
182#undef PGM_GST_TYPE
183#undef PGM_GST_NAME
184
185
186/* Guest - PAE mode */
187#define PGM_GST_TYPE PGM_TYPE_PAE
188#define PGM_GST_NAME(name) PGM_GST_NAME_PAE(name)
189#define PGM_BTH_NAME(name) PGM_BTH_NAME_PAE_PAE(name)
190#define BTH_PGMPOOLKIND_PT_FOR_PT PGMPOOLKIND_PAE_PT_FOR_PAE_PT
191#define BTH_PGMPOOLKIND_PT_FOR_BIG PGMPOOLKIND_PAE_PT_FOR_PAE_2MB
192#define BTH_PGMPOOLKIND_ROOT PGMPOOLKIND_PAE_PDPT
193#include "PGMGstDefs.h"
194#include "PGMAllGst.h"
195#include "PGMAllBth.h"
196#undef BTH_PGMPOOLKIND_PT_FOR_BIG
197#undef BTH_PGMPOOLKIND_PT_FOR_PT
198#undef BTH_PGMPOOLKIND_ROOT
199#undef PGM_BTH_NAME
200#undef PGM_GST_TYPE
201#undef PGM_GST_NAME
202
203#undef PGM_SHW_TYPE
204#undef PGM_SHW_NAME
205
206
207#ifndef IN_RC /* AMD64 implies VT-x/AMD-V */
208/*
209 * Shadow - AMD64 mode
210 */
211# define PGM_SHW_TYPE PGM_TYPE_AMD64
212# define PGM_SHW_NAME(name) PGM_SHW_NAME_AMD64(name)
213# include "PGMAllShw.h"
214
215/* Guest - protected mode (only used for AMD-V nested paging in 64 bits mode) */
216# define PGM_GST_TYPE PGM_TYPE_PROT
217# define PGM_GST_NAME(name) PGM_GST_NAME_PROT(name)
218# define PGM_BTH_NAME(name) PGM_BTH_NAME_AMD64_PROT(name)
219# define BTH_PGMPOOLKIND_PT_FOR_PT PGMPOOLKIND_PAE_PT_FOR_PHYS
220# define BTH_PGMPOOLKIND_ROOT PGMPOOLKIND_PAE_PD_PHYS
221# include "PGMGstDefs.h"
222# include "PGMAllBth.h"
223# undef BTH_PGMPOOLKIND_PT_FOR_PT
224# undef BTH_PGMPOOLKIND_ROOT
225# undef PGM_BTH_NAME
226# undef PGM_GST_TYPE
227# undef PGM_GST_NAME
228
229# ifdef VBOX_WITH_64_BITS_GUESTS
230/* Guest - AMD64 mode */
231# define PGM_GST_TYPE PGM_TYPE_AMD64
232# define PGM_GST_NAME(name) PGM_GST_NAME_AMD64(name)
233# define PGM_BTH_NAME(name) PGM_BTH_NAME_AMD64_AMD64(name)
234# define BTH_PGMPOOLKIND_PT_FOR_PT PGMPOOLKIND_PAE_PT_FOR_PAE_PT
235# define BTH_PGMPOOLKIND_PT_FOR_BIG PGMPOOLKIND_PAE_PT_FOR_PAE_2MB
236# define BTH_PGMPOOLKIND_ROOT PGMPOOLKIND_64BIT_PML4
237# include "PGMGstDefs.h"
238# include "PGMAllGst.h"
239# include "PGMAllBth.h"
240# undef BTH_PGMPOOLKIND_PT_FOR_BIG
241# undef BTH_PGMPOOLKIND_PT_FOR_PT
242# undef BTH_PGMPOOLKIND_ROOT
243# undef PGM_BTH_NAME
244# undef PGM_GST_TYPE
245# undef PGM_GST_NAME
246# endif /* VBOX_WITH_64_BITS_GUESTS */
247
248# undef PGM_SHW_TYPE
249# undef PGM_SHW_NAME
250
251
252/*
253 * Shadow - Nested paging mode
254 */
255# define PGM_SHW_TYPE PGM_TYPE_NESTED
256# define PGM_SHW_NAME(name) PGM_SHW_NAME_NESTED(name)
257# include "PGMAllShw.h"
258
259/* Guest - real mode */
260# define PGM_GST_TYPE PGM_TYPE_REAL
261# define PGM_GST_NAME(name) PGM_GST_NAME_REAL(name)
262# define PGM_BTH_NAME(name) PGM_BTH_NAME_NESTED_REAL(name)
263# include "PGMGstDefs.h"
264# include "PGMAllBth.h"
265# undef PGM_BTH_NAME
266# undef PGM_GST_TYPE
267# undef PGM_GST_NAME
268
269/* Guest - protected mode */
270# define PGM_GST_TYPE PGM_TYPE_PROT
271# define PGM_GST_NAME(name) PGM_GST_NAME_PROT(name)
272# define PGM_BTH_NAME(name) PGM_BTH_NAME_NESTED_PROT(name)
273# include "PGMGstDefs.h"
274# include "PGMAllBth.h"
275# undef PGM_BTH_NAME
276# undef PGM_GST_TYPE
277# undef PGM_GST_NAME
278
279/* Guest - 32-bit mode */
280# define PGM_GST_TYPE PGM_TYPE_32BIT
281# define PGM_GST_NAME(name) PGM_GST_NAME_32BIT(name)
282# define PGM_BTH_NAME(name) PGM_BTH_NAME_NESTED_32BIT(name)
283# include "PGMGstDefs.h"
284# include "PGMAllBth.h"
285# undef PGM_BTH_NAME
286# undef PGM_GST_TYPE
287# undef PGM_GST_NAME
288
289/* Guest - PAE mode */
290# define PGM_GST_TYPE PGM_TYPE_PAE
291# define PGM_GST_NAME(name) PGM_GST_NAME_PAE(name)
292# define PGM_BTH_NAME(name) PGM_BTH_NAME_NESTED_PAE(name)
293# include "PGMGstDefs.h"
294# include "PGMAllBth.h"
295# undef PGM_BTH_NAME
296# undef PGM_GST_TYPE
297# undef PGM_GST_NAME
298
299# ifdef VBOX_WITH_64_BITS_GUESTS
300/* Guest - AMD64 mode */
301# define PGM_GST_TYPE PGM_TYPE_AMD64
302# define PGM_GST_NAME(name) PGM_GST_NAME_AMD64(name)
303# define PGM_BTH_NAME(name) PGM_BTH_NAME_NESTED_AMD64(name)
304# include "PGMGstDefs.h"
305# include "PGMAllBth.h"
306# undef PGM_BTH_NAME
307# undef PGM_GST_TYPE
308# undef PGM_GST_NAME
309# endif /* VBOX_WITH_64_BITS_GUESTS */
310
311# undef PGM_SHW_TYPE
312# undef PGM_SHW_NAME
313
314
315/*
316 * Shadow - EPT
317 */
318# define PGM_SHW_TYPE PGM_TYPE_EPT
319# define PGM_SHW_NAME(name) PGM_SHW_NAME_EPT(name)
320# include "PGMAllShw.h"
321
322/* Guest - real mode */
323# define PGM_GST_TYPE PGM_TYPE_REAL
324# define PGM_GST_NAME(name) PGM_GST_NAME_REAL(name)
325# define PGM_BTH_NAME(name) PGM_BTH_NAME_EPT_REAL(name)
326# define BTH_PGMPOOLKIND_PT_FOR_PT PGMPOOLKIND_EPT_PT_FOR_PHYS
327# include "PGMGstDefs.h"
328# include "PGMAllBth.h"
329# undef BTH_PGMPOOLKIND_PT_FOR_PT
330# undef PGM_BTH_NAME
331# undef PGM_GST_TYPE
332# undef PGM_GST_NAME
333
334/* Guest - protected mode */
335# define PGM_GST_TYPE PGM_TYPE_PROT
336# define PGM_GST_NAME(name) PGM_GST_NAME_PROT(name)
337# define PGM_BTH_NAME(name) PGM_BTH_NAME_EPT_PROT(name)
338# define BTH_PGMPOOLKIND_PT_FOR_PT PGMPOOLKIND_EPT_PT_FOR_PHYS
339# include "PGMGstDefs.h"
340# include "PGMAllBth.h"
341# undef BTH_PGMPOOLKIND_PT_FOR_PT
342# undef PGM_BTH_NAME
343# undef PGM_GST_TYPE
344# undef PGM_GST_NAME
345
346/* Guest - 32-bit mode */
347# define PGM_GST_TYPE PGM_TYPE_32BIT
348# define PGM_GST_NAME(name) PGM_GST_NAME_32BIT(name)
349# define PGM_BTH_NAME(name) PGM_BTH_NAME_EPT_32BIT(name)
350# define BTH_PGMPOOLKIND_PT_FOR_PT PGMPOOLKIND_EPT_PT_FOR_PHYS
351# include "PGMGstDefs.h"
352# include "PGMAllBth.h"
353# undef BTH_PGMPOOLKIND_PT_FOR_PT
354# undef PGM_BTH_NAME
355# undef PGM_GST_TYPE
356# undef PGM_GST_NAME
357
358/* Guest - PAE mode */
359# define PGM_GST_TYPE PGM_TYPE_PAE
360# define PGM_GST_NAME(name) PGM_GST_NAME_PAE(name)
361# define PGM_BTH_NAME(name) PGM_BTH_NAME_EPT_PAE(name)
362# define BTH_PGMPOOLKIND_PT_FOR_PT PGMPOOLKIND_EPT_PT_FOR_PHYS
363# include "PGMGstDefs.h"
364# include "PGMAllBth.h"
365# undef BTH_PGMPOOLKIND_PT_FOR_PT
366# undef PGM_BTH_NAME
367# undef PGM_GST_TYPE
368# undef PGM_GST_NAME
369
370# ifdef VBOX_WITH_64_BITS_GUESTS
371/* Guest - AMD64 mode */
372# define PGM_GST_TYPE PGM_TYPE_AMD64
373# define PGM_GST_NAME(name) PGM_GST_NAME_AMD64(name)
374# define PGM_BTH_NAME(name) PGM_BTH_NAME_EPT_AMD64(name)
375# define BTH_PGMPOOLKIND_PT_FOR_PT PGMPOOLKIND_EPT_PT_FOR_PHYS
376# include "PGMGstDefs.h"
377# include "PGMAllBth.h"
378# undef BTH_PGMPOOLKIND_PT_FOR_PT
379# undef PGM_BTH_NAME
380# undef PGM_GST_TYPE
381# undef PGM_GST_NAME
382# endif /* VBOX_WITH_64_BITS_GUESTS */
383
384# undef PGM_SHW_TYPE
385# undef PGM_SHW_NAME
386
387#endif /* !IN_RC */
388
389
390#ifndef IN_RING3
391/**
392 * #PF Handler.
393 *
394 * @returns VBox status code (appropriate for trap handling and GC return).
395 * @param pVM VM Handle.
396 * @param uErr The trap error code.
397 * @param pRegFrame Trap register frame.
398 * @param pvFault The fault address.
399 */
400VMMDECL(int) PGMTrap0eHandler(PVM pVM, RTGCUINT uErr, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault)
401{
402 LogFlow(("PGMTrap0eHandler: uErr=%RGu pvFault=%RGv eip=%RGv\n", uErr, pvFault, (RTGCPTR)pRegFrame->rip));
403 STAM_PROFILE_START(&pVM->pgm.s.StatRZTrap0e, a);
404 STAM_STATS({ pVM->pgm.s.CTX_SUFF(pStatTrap0eAttribution) = NULL; } );
405
406
407#ifdef VBOX_WITH_STATISTICS
408 /*
409 * Error code stats.
410 */
411 if (uErr & X86_TRAP_PF_US)
412 {
413 if (!(uErr & X86_TRAP_PF_P))
414 {
415 if (uErr & X86_TRAP_PF_RW)
416 STAM_COUNTER_INC(&pVM->pgm.s.StatRZTrap0eUSNotPresentWrite);
417 else
418 STAM_COUNTER_INC(&pVM->pgm.s.StatRZTrap0eUSNotPresentRead);
419 }
420 else if (uErr & X86_TRAP_PF_RW)
421 STAM_COUNTER_INC(&pVM->pgm.s.StatRZTrap0eUSWrite);
422 else if (uErr & X86_TRAP_PF_RSVD)
423 STAM_COUNTER_INC(&pVM->pgm.s.StatRZTrap0eUSReserved);
424 else if (uErr & X86_TRAP_PF_ID)
425 STAM_COUNTER_INC(&pVM->pgm.s.StatRZTrap0eUSNXE);
426 else
427 STAM_COUNTER_INC(&pVM->pgm.s.StatRZTrap0eUSRead);
428 }
429 else
430 { /* Supervisor */
431 if (!(uErr & X86_TRAP_PF_P))
432 {
433 if (uErr & X86_TRAP_PF_RW)
434 STAM_COUNTER_INC(&pVM->pgm.s.StatRZTrap0eSVNotPresentWrite);
435 else
436 STAM_COUNTER_INC(&pVM->pgm.s.StatRZTrap0eSVNotPresentRead);
437 }
438 else if (uErr & X86_TRAP_PF_RW)
439 STAM_COUNTER_INC(&pVM->pgm.s.StatRZTrap0eSVWrite);
440 else if (uErr & X86_TRAP_PF_ID)
441 STAM_COUNTER_INC(&pVM->pgm.s.StatRZTrap0eSNXE);
442 else if (uErr & X86_TRAP_PF_RSVD)
443 STAM_COUNTER_INC(&pVM->pgm.s.StatRZTrap0eSVReserved);
444 }
445#endif /* VBOX_WITH_STATISTICS */
446
447 /*
448 * Call the worker.
449 */
450 int rc = PGM_BTH_PFN(Trap0eHandler, pVM)(pVM, uErr, pRegFrame, pvFault);
451 if (rc == VINF_PGM_SYNCPAGE_MODIFIED_PDE)
452 rc = VINF_SUCCESS;
453 STAM_STATS({ if (rc == VINF_EM_RAW_GUEST_TRAP) STAM_COUNTER_INC(&pVM->pgm.s.StatRZTrap0eGuestPF); });
454 STAM_STATS({ if (!pVM->pgm.s.CTX_SUFF(pStatTrap0eAttribution))
455 pVM->pgm.s.CTX_SUFF(pStatTrap0eAttribution) = &pVM->pgm.s.StatRZTrap0eTime2Misc; });
456 STAM_PROFILE_STOP_EX(&pVM->pgm.s.StatRZTrap0e, pVM->pgm.s.CTX_SUFF(pStatTrap0eAttribution), a);
457 return rc;
458}
459#endif /* !IN_RING3 */
460
461
462/**
463 * Prefetch a page
464 *
465 * Typically used to sync commonly used pages before entering raw mode
466 * after a CR3 reload.
467 *
468 * @returns VBox status code suitable for scheduling.
469 * @retval VINF_SUCCESS on success.
470 * @retval VINF_PGM_SYNC_CR3 if we're out of shadow pages or something like that.
471 * @param pVM VM handle.
472 * @param GCPtrPage Page to invalidate.
473 */
474VMMDECL(int) PGMPrefetchPage(PVM pVM, RTGCPTR GCPtrPage)
475{
476 STAM_PROFILE_START(&pVM->pgm.s.CTX_MID_Z(Stat,Prefetch), a);
477 int rc = PGM_BTH_PFN(PrefetchPage, pVM)(pVM, GCPtrPage);
478 STAM_PROFILE_STOP(&pVM->pgm.s.CTX_MID_Z(Stat,Prefetch), a);
479 AssertMsg(rc == VINF_SUCCESS || rc == VINF_PGM_SYNC_CR3 || RT_FAILURE(rc), ("rc=%Rrc\n", rc));
480 return rc;
481}
482
483
484/**
485 * Gets the mapping corresponding to the specified address (if any).
486 *
487 * @returns Pointer to the mapping.
488 * @returns NULL if not
489 *
490 * @param pVM The virtual machine.
491 * @param GCPtr The guest context pointer.
492 */
493PPGMMAPPING pgmGetMapping(PVM pVM, RTGCPTR GCPtr)
494{
495 PPGMMAPPING pMapping = pVM->pgm.s.CTX_SUFF(pMappings);
496 while (pMapping)
497 {
498 if ((uintptr_t)GCPtr < (uintptr_t)pMapping->GCPtr)
499 break;
500 if ((uintptr_t)GCPtr - (uintptr_t)pMapping->GCPtr < pMapping->cb)
501 return pMapping;
502 pMapping = pMapping->CTX_SUFF(pNext);
503 }
504 return NULL;
505}
506
507
508/**
509 * Verifies a range of pages for read or write access
510 *
511 * Only checks the guest's page tables
512 *
513 * @returns VBox status code.
514 * @param pVM VM handle.
515 * @param Addr Guest virtual address to check
516 * @param cbSize Access size
517 * @param fAccess Access type (r/w, user/supervisor (X86_PTE_*))
518 * @remarks Current not in use.
519 */
520VMMDECL(int) PGMIsValidAccess(PVM pVM, RTGCPTR Addr, uint32_t cbSize, uint32_t fAccess)
521{
522 /*
523 * Validate input.
524 */
525 if (fAccess & ~(X86_PTE_US | X86_PTE_RW))
526 {
527 AssertMsgFailed(("PGMIsValidAccess: invalid access type %08x\n", fAccess));
528 return VERR_INVALID_PARAMETER;
529 }
530
531 uint64_t fPage;
532 int rc = PGMGstGetPage(pVM, (RTGCPTR)Addr, &fPage, NULL);
533 if (RT_FAILURE(rc))
534 {
535 Log(("PGMIsValidAccess: access violation for %RGv rc=%d\n", Addr, rc));
536 return VINF_EM_RAW_GUEST_TRAP;
537 }
538
539 /*
540 * Check if the access would cause a page fault
541 *
542 * Note that hypervisor page directories are not present in the guest's tables, so this check
543 * is sufficient.
544 */
545 bool fWrite = !!(fAccess & X86_PTE_RW);
546 bool fUser = !!(fAccess & X86_PTE_US);
547 if ( !(fPage & X86_PTE_P)
548 || (fWrite && !(fPage & X86_PTE_RW))
549 || (fUser && !(fPage & X86_PTE_US)) )
550 {
551 Log(("PGMIsValidAccess: access violation for %RGv attr %#llx vs %d:%d\n", Addr, fPage, fWrite, fUser));
552 return VINF_EM_RAW_GUEST_TRAP;
553 }
554 if ( RT_SUCCESS(rc)
555 && PAGE_ADDRESS(Addr) != PAGE_ADDRESS(Addr + cbSize))
556 return PGMIsValidAccess(pVM, Addr + PAGE_SIZE, (cbSize > PAGE_SIZE) ? cbSize - PAGE_SIZE : 1, fAccess);
557 return rc;
558}
559
560
561/**
562 * Verifies a range of pages for read or write access
563 *
564 * Supports handling of pages marked for dirty bit tracking and CSAM
565 *
566 * @returns VBox status code.
567 * @param pVM VM handle.
568 * @param Addr Guest virtual address to check
569 * @param cbSize Access size
570 * @param fAccess Access type (r/w, user/supervisor (X86_PTE_*))
571 */
572VMMDECL(int) PGMVerifyAccess(PVM pVM, RTGCPTR Addr, uint32_t cbSize, uint32_t fAccess)
573{
574 AssertMsg(!(fAccess & ~(X86_PTE_US | X86_PTE_RW)), ("PGMVerifyAccess: invalid access type %08x\n", fAccess));
575
576 /*
577 * Get going.
578 */
579 uint64_t fPageGst;
580 int rc = PGMGstGetPage(pVM, (RTGCPTR)Addr, &fPageGst, NULL);
581 if (RT_FAILURE(rc))
582 {
583 Log(("PGMVerifyAccess: access violation for %RGv rc=%d\n", Addr, rc));
584 return VINF_EM_RAW_GUEST_TRAP;
585 }
586
587 /*
588 * Check if the access would cause a page fault
589 *
590 * Note that hypervisor page directories are not present in the guest's tables, so this check
591 * is sufficient.
592 */
593 const bool fWrite = !!(fAccess & X86_PTE_RW);
594 const bool fUser = !!(fAccess & X86_PTE_US);
595 if ( !(fPageGst & X86_PTE_P)
596 || (fWrite && !(fPageGst & X86_PTE_RW))
597 || (fUser && !(fPageGst & X86_PTE_US)) )
598 {
599 Log(("PGMVerifyAccess: access violation for %RGv attr %#llx vs %d:%d\n", Addr, fPageGst, fWrite, fUser));
600 return VINF_EM_RAW_GUEST_TRAP;
601 }
602
603 if (!HWACCMIsNestedPagingActive(pVM))
604 {
605 /*
606 * Next step is to verify if we protected this page for dirty bit tracking or for CSAM scanning
607 */
608 rc = PGMShwGetPage(pVM, (RTGCPTR)Addr, NULL, NULL);
609 if ( rc == VERR_PAGE_NOT_PRESENT
610 || rc == VERR_PAGE_TABLE_NOT_PRESENT)
611 {
612 /*
613 * Page is not present in our page tables.
614 * Try to sync it!
615 */
616 Assert(X86_TRAP_PF_RW == X86_PTE_RW && X86_TRAP_PF_US == X86_PTE_US);
617 uint32_t uErr = fAccess & (X86_TRAP_PF_RW | X86_TRAP_PF_US);
618 rc = PGM_BTH_PFN(VerifyAccessSyncPage, pVM)(pVM, Addr, fPageGst, uErr);
619 if (rc != VINF_SUCCESS)
620 return rc;
621 }
622 else
623 AssertMsg(rc == VINF_SUCCESS, ("PGMShwGetPage %RGv failed with %Rrc\n", Addr, rc));
624 }
625
626#if 0 /* def VBOX_STRICT; triggers too often now */
627 /*
628 * This check is a bit paranoid, but useful.
629 */
630 /** @note this will assert when writing to monitored pages (a bit annoying actually) */
631 uint64_t fPageShw;
632 rc = PGMShwGetPage(pVM, (RTGCPTR)Addr, &fPageShw, NULL);
633 if ( (rc == VERR_PAGE_NOT_PRESENT || RT_FAILURE(rc))
634 || (fWrite && !(fPageShw & X86_PTE_RW))
635 || (fUser && !(fPageShw & X86_PTE_US)) )
636 {
637 AssertMsgFailed(("Unexpected access violation for %RGv! rc=%Rrc write=%d user=%d\n",
638 Addr, rc, fWrite && !(fPageShw & X86_PTE_RW), fUser && !(fPageShw & X86_PTE_US)));
639 return VINF_EM_RAW_GUEST_TRAP;
640 }
641#endif
642
643 if ( RT_SUCCESS(rc)
644 && ( PAGE_ADDRESS(Addr) != PAGE_ADDRESS(Addr + cbSize - 1)
645 || Addr + cbSize < Addr))
646 {
647 /* Don't recursively call PGMVerifyAccess as we might run out of stack. */
648 for (;;)
649 {
650 Addr += PAGE_SIZE;
651 if (cbSize > PAGE_SIZE)
652 cbSize -= PAGE_SIZE;
653 else
654 cbSize = 1;
655 rc = PGMVerifyAccess(pVM, Addr, 1, fAccess);
656 if (rc != VINF_SUCCESS)
657 break;
658 if (PAGE_ADDRESS(Addr) == PAGE_ADDRESS(Addr + cbSize - 1))
659 break;
660 }
661 }
662 return rc;
663}
664
665
666/**
667 * Emulation of the invlpg instruction (HC only actually).
668 *
669 * @returns VBox status code, special care required.
670 * @retval VINF_PGM_SYNC_CR3 - handled.
671 * @retval VINF_EM_RAW_EMULATE_INSTR - not handled (RC only).
672 * @retval VERR_REM_FLUSHED_PAGES_OVERFLOW - not handled.
673 *
674 * @param pVM VM handle.
675 * @param GCPtrPage Page to invalidate.
676 *
677 * @remark ASSUMES the page table entry or page directory is valid. Fairly
678 * safe, but there could be edge cases!
679 *
680 * @todo Flush page or page directory only if necessary!
681 */
682VMMDECL(int) PGMInvalidatePage(PVM pVM, RTGCPTR GCPtrPage)
683{
684 int rc;
685 Log3(("PGMInvalidatePage: GCPtrPage=%RGv\n", GCPtrPage));
686
687#ifndef IN_RING3
688 /*
689 * Notify the recompiler so it can record this instruction.
690 * Failure happens when it's out of space. We'll return to HC in that case.
691 */
692 rc = REMNotifyInvalidatePage(pVM, GCPtrPage);
693 if (rc != VINF_SUCCESS)
694 return rc;
695#endif /* !IN_RING3 */
696
697
698#ifdef IN_RC
699 /*
700 * Check for conflicts and pending CR3 monitoring updates.
701 */
702 if (!pVM->pgm.s.fMappingsFixed)
703 {
704 if ( pgmGetMapping(pVM, GCPtrPage)
705 && PGMGstGetPage(pVM, GCPtrPage, NULL, NULL) != VERR_PAGE_TABLE_NOT_PRESENT)
706 {
707 LogFlow(("PGMGCInvalidatePage: Conflict!\n"));
708 VM_FF_SET(pVM, VM_FF_PGM_SYNC_CR3);
709 STAM_COUNTER_INC(&pVM->pgm.s.StatRCInvlPgConflict);
710 return VINF_PGM_SYNC_CR3;
711 }
712
713 if (pVM->pgm.s.fSyncFlags & PGM_SYNC_MONITOR_CR3)
714 {
715 LogFlow(("PGMGCInvalidatePage: PGM_SYNC_MONITOR_CR3 -> reinterpret instruction in R3\n"));
716 STAM_COUNTER_INC(&pVM->pgm.s.StatRCInvlPgSyncMonCR3);
717 return VINF_EM_RAW_EMULATE_INSTR;
718 }
719 }
720#endif /* IN_RC */
721
722 /*
723 * Call paging mode specific worker.
724 */
725 STAM_PROFILE_START(&pVM->pgm.s.CTX_MID_Z(Stat,InvalidatePage), a);
726 rc = PGM_BTH_PFN(InvalidatePage, pVM)(pVM, GCPtrPage);
727 STAM_PROFILE_STOP(&pVM->pgm.s.CTX_MID_Z(Stat,InvalidatePage), a);
728
729#ifdef IN_RING3
730 /*
731 * Check if we have a pending update of the CR3 monitoring.
732 */
733 if ( RT_SUCCESS(rc)
734 && (pVM->pgm.s.fSyncFlags & PGM_SYNC_MONITOR_CR3))
735 {
736 pVM->pgm.s.fSyncFlags &= ~PGM_SYNC_MONITOR_CR3;
737 Assert(!pVM->pgm.s.fMappingsFixed);
738 }
739
740 /*
741 * Inform CSAM about the flush
742 *
743 * Note: This is to check if monitored pages have been changed; when we implement
744 * callbacks for virtual handlers, this is no longer required.
745 */
746 CSAMR3FlushPage(pVM, GCPtrPage);
747#endif /* IN_RING3 */
748 return rc;
749}
750
751
752/**
753 * Executes an instruction using the interpreter.
754 *
755 * @returns VBox status code (appropriate for trap handling and GC return).
756 * @param pVM VM handle.
757 * @param pRegFrame Register frame.
758 * @param pvFault Fault address.
759 */
760VMMDECL(int) PGMInterpretInstruction(PVM pVM, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault)
761{
762 uint32_t cb;
763 int rc = EMInterpretInstruction(pVM, pRegFrame, pvFault, &cb);
764 if (rc == VERR_EM_INTERPRETER)
765 rc = VINF_EM_RAW_EMULATE_INSTR;
766 if (rc != VINF_SUCCESS)
767 Log(("PGMInterpretInstruction: returns %Rrc (pvFault=%RGv)\n", rc, pvFault));
768 return rc;
769}
770
771
772/**
773 * Gets effective page information (from the VMM page directory).
774 *
775 * @returns VBox status.
776 * @param pVM VM Handle.
777 * @param GCPtr Guest Context virtual address of the page.
778 * @param pfFlags Where to store the flags. These are X86_PTE_*.
779 * @param pHCPhys Where to store the HC physical address of the page.
780 * This is page aligned.
781 * @remark You should use PGMMapGetPage() for pages in a mapping.
782 */
783VMMDECL(int) PGMShwGetPage(PVM pVM, RTGCPTR GCPtr, uint64_t *pfFlags, PRTHCPHYS pHCPhys)
784{
785 return PGM_SHW_PFN(GetPage,pVM)(pVM, GCPtr, pfFlags, pHCPhys);
786}
787
788
789/**
790 * Sets (replaces) the page flags for a range of pages in the shadow context.
791 *
792 * @returns VBox status.
793 * @param pVM VM handle.
794 * @param GCPtr The address of the first page.
795 * @param cb The size of the range in bytes.
796 * @param fFlags Page flags X86_PTE_*, excluding the page mask of course.
797 * @remark You must use PGMMapSetPage() for pages in a mapping.
798 */
799VMMDECL(int) PGMShwSetPage(PVM pVM, RTGCPTR GCPtr, size_t cb, uint64_t fFlags)
800{
801 return PGMShwModifyPage(pVM, GCPtr, cb, fFlags, 0);
802}
803
804
805/**
806 * Modify page flags for a range of pages in the shadow context.
807 *
808 * The existing flags are ANDed with the fMask and ORed with the fFlags.
809 *
810 * @returns VBox status code.
811 * @param pVM VM handle.
812 * @param GCPtr Virtual address of the first page in the range.
813 * @param cb Size (in bytes) of the range to apply the modification to.
814 * @param fFlags The OR mask - page flags X86_PTE_*, excluding the page mask of course.
815 * @param fMask The AND mask - page flags X86_PTE_*.
816 * Be very CAREFUL when ~'ing constants which could be 32-bit!
817 * @remark You must use PGMMapModifyPage() for pages in a mapping.
818 */
819VMMDECL(int) PGMShwModifyPage(PVM pVM, RTGCPTR GCPtr, size_t cb, uint64_t fFlags, uint64_t fMask)
820{
821 AssertMsg(!(fFlags & X86_PTE_PAE_PG_MASK), ("fFlags=%#llx\n", fFlags));
822 Assert(cb);
823
824 /*
825 * Align the input.
826 */
827 cb += GCPtr & PAGE_OFFSET_MASK;
828 cb = RT_ALIGN_Z(cb, PAGE_SIZE);
829 GCPtr = (GCPtr & PAGE_BASE_GC_MASK); /** @todo this ain't necessary, right... */
830
831 /*
832 * Call worker.
833 */
834 return PGM_SHW_PFN(ModifyPage, pVM)(pVM, GCPtr, cb, fFlags, fMask);
835}
836
837
838/**
839 * Gets the SHADOW page directory pointer for the specified address.
840 *
841 * @returns VBox status.
842 * @param pVM VM handle.
843 * @param GCPtr The address.
844 * @param ppPdpt Receives address of pdpt
845 * @param ppPD Receives address of page directory
846 * @remarks Unused.
847 */
848DECLINLINE(int) pgmShwGetPAEPDPtr(PVM pVM, RTGCPTR GCPtr, PX86PDPT *ppPdpt, PX86PDPAE *ppPD)
849{
850 PPGM pPGM = &pVM->pgm.s;
851 PPGMPOOL pPool = pPGM->CTX_SUFF(pPool);
852 PPGMPOOLPAGE pShwPage;
853
854 Assert(!HWACCMIsNestedPagingActive(pVM));
855
856 const unsigned iPdPt = (GCPtr >> X86_PDPT_SHIFT) & X86_PDPT_MASK_PAE;
857 PX86PDPT pPdpt = pgmShwGetPaePDPTPtr(&pVM->pgm.s);
858 PX86PDPE pPdpe = &pPdpt->a[iPdPt];
859
860 *ppPdpt = pPdpt;
861 if (!pPdpe->n.u1Present)
862 return VERR_PAGE_DIRECTORY_PTR_NOT_PRESENT;
863
864 Assert(pPdpe->u & X86_PDPE_PG_MASK);
865 pShwPage = pgmPoolGetPage(pPool, pPdpe->u & X86_PDPE_PG_MASK);
866 AssertReturn(pShwPage, VERR_INTERNAL_ERROR);
867
868 *ppPD = (PX86PDPAE)PGMPOOL_PAGE_2_PTR(pVM, pShwPage);
869 return VINF_SUCCESS;
870}
871
872/**
873 * Gets the shadow page directory for the specified address, PAE.
874 *
875 * @returns Pointer to the shadow PD.
876 * @param pVM VM handle.
877 * @param GCPtr The address.
878 * @param pGstPdpe Guest PDPT entry
879 * @param ppPD Receives address of page directory
880 */
881int pgmShwSyncPaePDPtr(PVM pVM, RTGCPTR GCPtr, PX86PDPE pGstPdpe, PX86PDPAE *ppPD)
882{
883 const unsigned iPdPt = (GCPtr >> X86_PDPT_SHIFT) & X86_PDPT_MASK_PAE;
884 PX86PDPT pPdpt = pgmShwGetPaePDPTPtr(&pVM->pgm.s);
885 PX86PDPE pPdpe = &pPdpt->a[iPdPt];
886 PPGMPOOL pPool = pVM->pgm.s.CTX_SUFF(pPool);
887 PPGMPOOLPAGE pShwPage;
888 int rc;
889
890 /* Allocate page directory if not present. */
891 if ( !pPdpe->n.u1Present
892 && !(pPdpe->u & X86_PDPE_PG_MASK))
893 {
894 bool fNestedPaging = HWACCMIsNestedPagingActive(pVM);
895 bool fPaging = !!(CPUMGetGuestCR0(pVM) & X86_CR0_PG);
896 RTGCPTR64 GCPdPt;
897 PGMPOOLKIND enmKind;
898
899# if defined(IN_RC)
900 /* Make sure the dynamic pPdeDst mapping will not be reused during this function. */
901 PGMDynLockHCPage(pVM, (uint8_t *)pPdpe);
902# endif
903
904 if (fNestedPaging || !fPaging)
905 {
906 /* AMD-V nested paging or real/protected mode without paging */
907 GCPdPt = (RTGCPTR64)iPdPt << X86_PDPT_SHIFT;
908 enmKind = PGMPOOLKIND_PAE_PD_PHYS;
909 }
910 else
911 {
912 Assert(pGstPdpe);
913
914 if (CPUMGetGuestCR4(pVM) & X86_CR4_PAE)
915 {
916 if (!pGstPdpe->n.u1Present)
917 {
918 /* PD not present; guest must reload CR3 to change it.
919 * No need to monitor anything in this case.
920 */
921 Assert(!HWACCMIsEnabled(pVM));
922
923 GCPdPt = pGstPdpe->u & X86_PDPE_PG_MASK;
924 enmKind = PGMPOOLKIND_PAE_PD_PHYS;
925 pGstPdpe->n.u1Present = 1;
926 }
927 else
928 {
929 GCPdPt = pGstPdpe->u & X86_PDPE_PG_MASK;
930 enmKind = PGMPOOLKIND_PAE_PD_FOR_PAE_PD;
931 }
932 }
933 else
934 {
935 GCPdPt = CPUMGetGuestCR3(pVM);
936 enmKind = (PGMPOOLKIND)(PGMPOOLKIND_PAE_PD0_FOR_32BIT_PD + iPdPt);
937 }
938 }
939
940 /* Create a reference back to the PDPT by using the index in its shadow page. */
941 rc = pgmPoolAlloc(pVM, GCPdPt, enmKind, pVM->pgm.s.CTX_SUFF(pShwPageCR3)->idx, iPdPt, &pShwPage);
942 if (rc == VERR_PGM_POOL_FLUSHED)
943 {
944 Log(("pgmShwSyncPaePDPtr: PGM pool flushed -> signal sync cr3\n"));
945 Assert(pVM->pgm.s.fSyncFlags & PGM_SYNC_CLEAR_PGM_POOL);
946 VM_FF_SET(pVM, VM_FF_PGM_SYNC_CR3);
947# if defined(IN_RC)
948 PGMDynUnlockHCPage(pVM, (uint8_t *)pPdpe);
949# endif
950 return VINF_PGM_SYNC_CR3;
951 }
952 AssertRCReturn(rc, rc);
953
954 /* The PD was cached or created; hook it up now. */
955 pPdpe->u |= pShwPage->Core.Key
956 | (pGstPdpe->u & ~(X86_PDPE_PG_MASK | X86_PDPE_AVL_MASK | X86_PDPE_PCD | X86_PDPE_PWT));
957
958# if defined(IN_RC)
959 /* In 32 bits PAE mode we *must* invalidate the TLB when changing a PDPT entry; the CPU fetches them only during cr3 load, so any
960 * non-present PDPT will continue to cause page faults.
961 */
962 ASMReloadCR3();
963 PGMDynUnlockHCPage(pVM, (uint8_t *)pPdpe);
964# endif
965 }
966 else
967 {
968 pShwPage = pgmPoolGetPage(pPool, pPdpe->u & X86_PDPE_PG_MASK);
969 AssertReturn(pShwPage, VERR_INTERNAL_ERROR);
970
971 Assert((pPdpe->u & X86_PDPE_PG_MASK) == pShwPage->Core.Key);
972 }
973 *ppPD = (PX86PDPAE)PGMPOOL_PAGE_2_PTR(pVM, pShwPage);
974 return VINF_SUCCESS;
975}
976
977
978/**
979 * Gets the pointer to the shadow page directory entry for an address, PAE.
980 *
981 * @returns Pointer to the PDE.
982 * @param pPGM Pointer to the PGM instance data.
983 * @param GCPtr The address.
984 * @param ppShwPde Receives the address of the pgm pool page for the shadow page directory
985 */
986DECLINLINE(int) pgmShwGetPaePoolPagePD(PPGM pPGM, RTGCPTR GCPtr, PPGMPOOLPAGE *ppShwPde)
987{
988 const unsigned iPdPt = (GCPtr >> X86_PDPT_SHIFT) & X86_PDPT_MASK_PAE;
989 PX86PDPT pPdpt = pgmShwGetPaePDPTPtr(pPGM);
990 AssertReturn(pPdpt, VERR_PAGE_DIRECTORY_PTR_NOT_PRESENT); /* can't happen */
991 if (!pPdpt->a[iPdPt].n.u1Present)
992 {
993 LogFlow(("pgmShwGetPaePoolPagePD: PD %d not present (%RX64)\n", iPdPt, pPdpt->a[iPdPt].u));
994 return VERR_PAGE_DIRECTORY_PTR_NOT_PRESENT;
995 }
996 AssertMsg(pPdpt->a[iPdPt].u & X86_PDPE_PG_MASK, ("GCPtr=%RGv\n", GCPtr));
997
998 /* Fetch the pgm pool shadow descriptor. */
999 PPGMPOOLPAGE pShwPde = pgmPoolGetPageByHCPhys(PGM2VM(pPGM), pPdpt->a[iPdPt].u & X86_PDPE_PG_MASK);
1000 AssertReturn(pShwPde, VERR_INTERNAL_ERROR);
1001
1002 *ppShwPde = pShwPde;
1003 return VINF_SUCCESS;
1004}
1005
1006#ifndef IN_RC
1007
1008/**
1009 * Syncs the SHADOW page directory pointer for the specified address.
1010 *
1011 * Allocates backing pages in case the PDPT or PML4 entry is missing.
1012 *
1013 * The caller is responsible for making sure the guest has a valid PD before
1014 * calling this function.
1015 *
1016 * @returns VBox status.
1017 * @param pVM VM handle.
1018 * @param GCPtr The address.
1019 * @param pGstPml4e Guest PML4 entry
1020 * @param pGstPdpe Guest PDPT entry
1021 * @param ppPD Receives address of page directory
1022 */
1023int pgmShwSyncLongModePDPtr(PVM pVM, RTGCPTR64 GCPtr, PX86PML4E pGstPml4e, PX86PDPE pGstPdpe, PX86PDPAE *ppPD)
1024{
1025 PPGM pPGM = &pVM->pgm.s;
1026 PPGMPOOL pPool = pPGM->CTX_SUFF(pPool);
1027 const unsigned iPml4 = (GCPtr >> X86_PML4_SHIFT) & X86_PML4_MASK;
1028 PX86PML4E pPml4e = pgmShwGetLongModePML4EPtr(pPGM, iPml4);
1029 bool fNestedPaging = HWACCMIsNestedPagingActive(pVM);
1030 bool fPaging = !!(CPUMGetGuestCR0(pVM) & X86_CR0_PG);
1031 PPGMPOOLPAGE pShwPage;
1032 int rc;
1033
1034 /* Allocate page directory pointer table if not present. */
1035 if ( !pPml4e->n.u1Present
1036 && !(pPml4e->u & X86_PML4E_PG_MASK))
1037 {
1038 RTGCPTR64 GCPml4;
1039 PGMPOOLKIND enmKind;
1040
1041 Assert(pVM->pgm.s.CTX_SUFF(pShwPageCR3));
1042
1043 if (fNestedPaging || !fPaging)
1044 {
1045 /* AMD-V nested paging or real/protected mode without paging */
1046 GCPml4 = (RTGCPTR64)iPml4 << X86_PML4_SHIFT;
1047 enmKind = PGMPOOLKIND_64BIT_PDPT_FOR_PHYS;
1048 }
1049 else
1050 {
1051 Assert(pGstPml4e && pGstPdpe);
1052
1053 GCPml4 = pGstPml4e->u & X86_PML4E_PG_MASK;
1054 enmKind = PGMPOOLKIND_64BIT_PDPT_FOR_64BIT_PDPT;
1055 }
1056
1057 /* Create a reference back to the PDPT by using the index in its shadow page. */
1058 rc = pgmPoolAlloc(pVM, GCPml4, enmKind, pVM->pgm.s.CTX_SUFF(pShwPageCR3)->idx, iPml4, &pShwPage);
1059 if (rc == VERR_PGM_POOL_FLUSHED)
1060 {
1061 Log(("PGMShwSyncLongModePDPtr: PGM pool flushed (1) -> signal sync cr3\n"));
1062 Assert(pVM->pgm.s.fSyncFlags & PGM_SYNC_CLEAR_PGM_POOL);
1063 VM_FF_SET(pVM, VM_FF_PGM_SYNC_CR3);
1064 return VINF_PGM_SYNC_CR3;
1065 }
1066 AssertRCReturn(rc, rc);
1067 }
1068 else
1069 {
1070 pShwPage = pgmPoolGetPage(pPool, pPml4e->u & X86_PML4E_PG_MASK);
1071 AssertReturn(pShwPage, VERR_INTERNAL_ERROR);
1072 }
1073 /* The PDPT was cached or created; hook it up now. */
1074 pPml4e->u |= pShwPage->Core.Key
1075 | (pGstPml4e->u & ~(X86_PML4E_PG_MASK | X86_PML4E_AVL_MASK | X86_PML4E_PCD | X86_PML4E_PWT));
1076
1077 const unsigned iPdPt = (GCPtr >> X86_PDPT_SHIFT) & X86_PDPT_MASK_AMD64;
1078 PX86PDPT pPdpt = (PX86PDPT)PGMPOOL_PAGE_2_PTR(pVM, pShwPage);
1079 PX86PDPE pPdpe = &pPdpt->a[iPdPt];
1080
1081 /* Allocate page directory if not present. */
1082 if ( !pPdpe->n.u1Present
1083 && !(pPdpe->u & X86_PDPE_PG_MASK))
1084 {
1085 RTGCPTR64 GCPdPt;
1086 PGMPOOLKIND enmKind;
1087
1088 if (fNestedPaging || !fPaging)
1089 {
1090 /* AMD-V nested paging or real/protected mode without paging */
1091 GCPdPt = (RTGCPTR64)iPdPt << X86_PDPT_SHIFT;
1092 enmKind = PGMPOOLKIND_64BIT_PD_FOR_PHYS;
1093 }
1094 else
1095 {
1096 Assert(pGstPdpe);
1097
1098 GCPdPt = pGstPdpe->u & X86_PDPE_PG_MASK;
1099 enmKind = PGMPOOLKIND_64BIT_PD_FOR_64BIT_PD;
1100 }
1101
1102 /* Create a reference back to the PDPT by using the index in its shadow page. */
1103 rc = pgmPoolAlloc(pVM, GCPdPt, enmKind, pShwPage->idx, iPdPt, &pShwPage);
1104 if (rc == VERR_PGM_POOL_FLUSHED)
1105 {
1106 Log(("PGMShwSyncLongModePDPtr: PGM pool flushed (2) -> signal sync cr3\n"));
1107 Assert(pVM->pgm.s.fSyncFlags & PGM_SYNC_CLEAR_PGM_POOL);
1108 VM_FF_SET(pVM, VM_FF_PGM_SYNC_CR3);
1109 return VINF_PGM_SYNC_CR3;
1110 }
1111 AssertRCReturn(rc, rc);
1112 }
1113 else
1114 {
1115 pShwPage = pgmPoolGetPage(pPool, pPdpe->u & X86_PDPE_PG_MASK);
1116 AssertReturn(pShwPage, VERR_INTERNAL_ERROR);
1117 }
1118 /* The PD was cached or created; hook it up now. */
1119 pPdpe->u |= pShwPage->Core.Key
1120 | (pGstPdpe->u & ~(X86_PDPE_PG_MASK | X86_PDPE_AVL_MASK | X86_PDPE_PCD | X86_PDPE_PWT));
1121
1122 *ppPD = (PX86PDPAE)PGMPOOL_PAGE_2_PTR(pVM, pShwPage);
1123 return VINF_SUCCESS;
1124}
1125
1126
1127/**
1128 * Gets the SHADOW page directory pointer for the specified address (long mode).
1129 *
1130 * @returns VBox status.
1131 * @param pVM VM handle.
1132 * @param GCPtr The address.
1133 * @param ppPdpt Receives address of pdpt
1134 * @param ppPD Receives address of page directory
1135 */
1136DECLINLINE(int) pgmShwGetLongModePDPtr(PVM pVM, RTGCPTR64 GCPtr, PX86PML4E *ppPml4e, PX86PDPT *ppPdpt, PX86PDPAE *ppPD)
1137{
1138 PPGM pPGM = &pVM->pgm.s;
1139 const unsigned iPml4 = (GCPtr >> X86_PML4_SHIFT) & X86_PML4_MASK;
1140 PCX86PML4E pPml4e = pgmShwGetLongModePML4EPtr(pPGM, iPml4);
1141 AssertReturn(pPml4e, VERR_INTERNAL_ERROR);
1142 if (ppPml4e)
1143 *ppPml4e = (PX86PML4E)pPml4e;
1144 if (!pPml4e->n.u1Present)
1145 return VERR_PAGE_MAP_LEVEL4_NOT_PRESENT;
1146
1147 PPGMPOOL pPool = pPGM->CTX_SUFF(pPool);
1148 PPGMPOOLPAGE pShwPage = pgmPoolGetPage(pPool, pPml4e->u & X86_PML4E_PG_MASK);
1149 AssertReturn(pShwPage, VERR_INTERNAL_ERROR);
1150
1151 const unsigned iPdPt = (GCPtr >> X86_PDPT_SHIFT) & X86_PDPT_MASK_AMD64;
1152 PCX86PDPT pPdpt = *ppPdpt = (PX86PDPT)PGMPOOL_PAGE_2_PTR(pVM, pShwPage);
1153 if (!pPdpt->a[iPdPt].n.u1Present)
1154 return VERR_PAGE_DIRECTORY_PTR_NOT_PRESENT;
1155
1156 pShwPage = pgmPoolGetPage(pPool, pPdpt->a[iPdPt].u & X86_PDPE_PG_MASK);
1157 AssertReturn(pShwPage, VERR_INTERNAL_ERROR);
1158
1159 *ppPD = (PX86PDPAE)PGMPOOL_PAGE_2_PTR(pVM, pShwPage);
1160 return VINF_SUCCESS;
1161}
1162
1163
1164/**
1165 * Syncs the SHADOW EPT page directory pointer for the specified address. Allocates
1166 * backing pages in case the PDPT or PML4 entry is missing.
1167 *
1168 * @returns VBox status.
1169 * @param pVM VM handle.
1170 * @param GCPtr The address.
1171 * @param ppPdpt Receives address of pdpt
1172 * @param ppPD Receives address of page directory
1173 */
1174int pgmShwGetEPTPDPtr(PVM pVM, RTGCPTR64 GCPtr, PEPTPDPT *ppPdpt, PEPTPD *ppPD)
1175{
1176 PPGM pPGM = &pVM->pgm.s;
1177 const unsigned iPml4 = (GCPtr >> EPT_PML4_SHIFT) & EPT_PML4_MASK;
1178 PPGMPOOL pPool = pPGM->CTX_SUFF(pPool);
1179 PEPTPML4 pPml4;
1180 PEPTPML4E pPml4e;
1181 PPGMPOOLPAGE pShwPage;
1182 int rc;
1183
1184 Assert(HWACCMIsNestedPagingActive(pVM));
1185
1186 pPml4 = (PEPTPML4)PGMPOOL_PAGE_2_PTR_BY_PGM(pPGM, pPGM->CTX_SUFF(pShwPageCR3));
1187 Assert(pPml4);
1188
1189 /* Allocate page directory pointer table if not present. */
1190 pPml4e = &pPml4->a[iPml4];
1191 if ( !pPml4e->n.u1Present
1192 && !(pPml4e->u & EPT_PML4E_PG_MASK))
1193 {
1194 Assert(!(pPml4e->u & EPT_PML4E_PG_MASK));
1195 RTGCPTR64 GCPml4 = (RTGCPTR64)iPml4 << EPT_PML4_SHIFT;
1196
1197 rc = pgmPoolAlloc(pVM, GCPml4, PGMPOOLKIND_EPT_PDPT_FOR_PHYS, PGMPOOL_IDX_NESTED_ROOT, iPml4, &pShwPage);
1198 if (rc == VERR_PGM_POOL_FLUSHED)
1199 {
1200 Log(("PGMShwSyncEPTPDPtr: PGM pool flushed (1) -> signal sync cr3\n"));
1201 Assert(pVM->pgm.s.fSyncFlags & PGM_SYNC_CLEAR_PGM_POOL);
1202 VM_FF_SET(pVM, VM_FF_PGM_SYNC_CR3);
1203 return VINF_PGM_SYNC_CR3;
1204 }
1205 AssertRCReturn(rc, rc);
1206 }
1207 else
1208 {
1209 pShwPage = pgmPoolGetPage(pPool, pPml4e->u & EPT_PML4E_PG_MASK);
1210 AssertReturn(pShwPage, VERR_INTERNAL_ERROR);
1211 }
1212 /* The PDPT was cached or created; hook it up now and fill with the default value. */
1213 pPml4e->u = pShwPage->Core.Key;
1214 pPml4e->n.u1Present = 1;
1215 pPml4e->n.u1Write = 1;
1216 pPml4e->n.u1Execute = 1;
1217
1218 const unsigned iPdPt = (GCPtr >> EPT_PDPT_SHIFT) & EPT_PDPT_MASK;
1219 PEPTPDPT pPdpt = (PEPTPDPT)PGMPOOL_PAGE_2_PTR(pVM, pShwPage);
1220 PEPTPDPTE pPdpe = &pPdpt->a[iPdPt];
1221
1222 if (ppPdpt)
1223 *ppPdpt = pPdpt;
1224
1225 /* Allocate page directory if not present. */
1226 if ( !pPdpe->n.u1Present
1227 && !(pPdpe->u & EPT_PDPTE_PG_MASK))
1228 {
1229 RTGCPTR64 GCPdPt = (RTGCPTR64)iPdPt << EPT_PDPT_SHIFT;
1230
1231 rc = pgmPoolAlloc(pVM, GCPdPt, PGMPOOLKIND_64BIT_PD_FOR_PHYS, pShwPage->idx, iPdPt, &pShwPage);
1232 if (rc == VERR_PGM_POOL_FLUSHED)
1233 {
1234 Log(("PGMShwSyncEPTPDPtr: PGM pool flushed (2) -> signal sync cr3\n"));
1235 Assert(pVM->pgm.s.fSyncFlags & PGM_SYNC_CLEAR_PGM_POOL);
1236 VM_FF_SET(pVM, VM_FF_PGM_SYNC_CR3);
1237 return VINF_PGM_SYNC_CR3;
1238 }
1239 AssertRCReturn(rc, rc);
1240 }
1241 else
1242 {
1243 pShwPage = pgmPoolGetPage(pPool, pPdpe->u & EPT_PDPTE_PG_MASK);
1244 AssertReturn(pShwPage, VERR_INTERNAL_ERROR);
1245 }
1246 /* The PD was cached or created; hook it up now and fill with the default value. */
1247 pPdpe->u = pShwPage->Core.Key;
1248 pPdpe->n.u1Present = 1;
1249 pPdpe->n.u1Write = 1;
1250 pPdpe->n.u1Execute = 1;
1251
1252 *ppPD = (PEPTPD)PGMPOOL_PAGE_2_PTR(pVM, pShwPage);
1253 return VINF_SUCCESS;
1254}
1255
1256#endif /* IN_RC */
1257
1258/**
1259 * Gets effective Guest OS page information.
1260 *
1261 * When GCPtr is in a big page, the function will return as if it was a normal
1262 * 4KB page. If the need for distinguishing between big and normal page becomes
1263 * necessary at a later point, a PGMGstGetPage() will be created for that
1264 * purpose.
1265 *
1266 * @returns VBox status.
1267 * @param pVM VM Handle.
1268 * @param GCPtr Guest Context virtual address of the page.
1269 * @param pfFlags Where to store the flags. These are X86_PTE_*, even for big pages.
1270 * @param pGCPhys Where to store the GC physical address of the page.
1271 * This is page aligned. The fact that the
1272 */
1273VMMDECL(int) PGMGstGetPage(PVM pVM, RTGCPTR GCPtr, uint64_t *pfFlags, PRTGCPHYS pGCPhys)
1274{
1275 return PGM_GST_PFN(GetPage,pVM)(pVM, GCPtr, pfFlags, pGCPhys);
1276}
1277
1278
1279/**
1280 * Checks if the page is present.
1281 *
1282 * @returns true if the page is present.
1283 * @returns false if the page is not present.
1284 * @param pVM The VM handle.
1285 * @param GCPtr Address within the page.
1286 */
1287VMMDECL(bool) PGMGstIsPagePresent(PVM pVM, RTGCPTR GCPtr)
1288{
1289 int rc = PGMGstGetPage(pVM, GCPtr, NULL, NULL);
1290 return RT_SUCCESS(rc);
1291}
1292
1293
1294/**
1295 * Sets (replaces) the page flags for a range of pages in the guest's tables.
1296 *
1297 * @returns VBox status.
1298 * @param pVM VM handle.
1299 * @param GCPtr The address of the first page.
1300 * @param cb The size of the range in bytes.
1301 * @param fFlags Page flags X86_PTE_*, excluding the page mask of course.
1302 */
1303VMMDECL(int) PGMGstSetPage(PVM pVM, RTGCPTR GCPtr, size_t cb, uint64_t fFlags)
1304{
1305 return PGMGstModifyPage(pVM, GCPtr, cb, fFlags, 0);
1306}
1307
1308
1309/**
1310 * Modify page flags for a range of pages in the guest's tables
1311 *
1312 * The existing flags are ANDed with the fMask and ORed with the fFlags.
1313 *
1314 * @returns VBox status code.
1315 * @param pVM VM handle.
1316 * @param GCPtr Virtual address of the first page in the range.
1317 * @param cb Size (in bytes) of the range to apply the modification to.
1318 * @param fFlags The OR mask - page flags X86_PTE_*, excluding the page mask of course.
1319 * @param fMask The AND mask - page flags X86_PTE_*, excluding the page mask of course.
1320 * Be very CAREFUL when ~'ing constants which could be 32-bit!
1321 */
1322VMMDECL(int) PGMGstModifyPage(PVM pVM, RTGCPTR GCPtr, size_t cb, uint64_t fFlags, uint64_t fMask)
1323{
1324 STAM_PROFILE_START(&pVM->pgm.s.CTX_MID_Z(Stat,GstModifyPage), a);
1325
1326 /*
1327 * Validate input.
1328 */
1329 AssertMsg(!(fFlags & X86_PTE_PAE_PG_MASK), ("fFlags=%#llx\n", fFlags));
1330 Assert(cb);
1331
1332 LogFlow(("PGMGstModifyPage %RGv %d bytes fFlags=%08llx fMask=%08llx\n", GCPtr, cb, fFlags, fMask));
1333
1334 /*
1335 * Adjust input.
1336 */
1337 cb += GCPtr & PAGE_OFFSET_MASK;
1338 cb = RT_ALIGN_Z(cb, PAGE_SIZE);
1339 GCPtr = (GCPtr & PAGE_BASE_GC_MASK);
1340
1341 /*
1342 * Call worker.
1343 */
1344 int rc = PGM_GST_PFN(ModifyPage, pVM)(pVM, GCPtr, cb, fFlags, fMask);
1345
1346 STAM_PROFILE_STOP(&pVM->pgm.s.CTX_MID_Z(Stat,GstModifyPage), a);
1347 return rc;
1348}
1349
1350
1351/**
1352 * Gets the specified page directory pointer table entry.
1353 *
1354 * @returns PDP entry
1355 * @param pPGM Pointer to the PGM instance data.
1356 * @param iPdpt PDPT index
1357 */
1358VMMDECL(X86PDPE) PGMGstGetPaePDPtr(PVM pVM, unsigned iPdpt)
1359{
1360 Assert(iPdpt <= 3);
1361 return pgmGstGetPaePDPTPtr(&pVM->pgm.s)->a[iPdpt & 3];
1362}
1363
1364
1365/**
1366 * Gets the current CR3 register value for the shadow memory context.
1367 * @returns CR3 value.
1368 * @param pVM The VM handle.
1369 */
1370VMMDECL(RTHCPHYS) PGMGetHyperCR3(PVM pVM)
1371{
1372 PPGMPOOLPAGE pPoolPage = pVM->pgm.s.CTX_SUFF(pShwPageCR3);
1373 AssertPtrReturn(pPoolPage, 0);
1374 return pPoolPage->Core.Key;
1375}
1376
1377
1378/**
1379 * Gets the current CR3 register value for the nested memory context.
1380 * @returns CR3 value.
1381 * @param pVM The VM handle.
1382 */
1383VMMDECL(RTHCPHYS) PGMGetNestedCR3(PVM pVM, PGMMODE enmShadowMode)
1384{
1385 Assert(pVM->pgm.s.CTX_SUFF(pShwPageCR3));
1386 return pVM->pgm.s.CTX_SUFF(pShwPageCR3)->Core.Key;
1387}
1388
1389
1390/**
1391 * Gets the CR3 register value for the 32-Bit shadow memory context.
1392 * @returns CR3 value.
1393 * @param pVM The VM handle.
1394 */
1395VMMDECL(RTHCPHYS) PGMGetHyper32BitCR3(PVM pVM)
1396{
1397 Assert(pVM->pgm.s.CTX_SUFF(pShwPageCR3));
1398 return pVM->pgm.s.CTX_SUFF(pShwPageCR3)->Core.Key;
1399}
1400
1401
1402/**
1403 * Gets the CR3 register value for the PAE shadow memory context.
1404 * @returns CR3 value.
1405 * @param pVM The VM handle.
1406 */
1407VMMDECL(RTHCPHYS) PGMGetHyperPaeCR3(PVM pVM)
1408{
1409 Assert(pVM->pgm.s.CTX_SUFF(pShwPageCR3));
1410 return pVM->pgm.s.CTX_SUFF(pShwPageCR3)->Core.Key;
1411}
1412
1413
1414/**
1415 * Gets the CR3 register value for the AMD64 shadow memory context.
1416 * @returns CR3 value.
1417 * @param pVM The VM handle.
1418 */
1419VMMDECL(RTHCPHYS) PGMGetHyperAmd64CR3(PVM pVM)
1420{
1421 Assert(pVM->pgm.s.CTX_SUFF(pShwPageCR3));
1422 return pVM->pgm.s.CTX_SUFF(pShwPageCR3)->Core.Key;
1423}
1424
1425
1426/**
1427 * Gets the current CR3 register value for the HC intermediate memory context.
1428 * @returns CR3 value.
1429 * @param pVM The VM handle.
1430 */
1431VMMDECL(RTHCPHYS) PGMGetInterHCCR3(PVM pVM)
1432{
1433 switch (pVM->pgm.s.enmHostMode)
1434 {
1435 case SUPPAGINGMODE_32_BIT:
1436 case SUPPAGINGMODE_32_BIT_GLOBAL:
1437 return pVM->pgm.s.HCPhysInterPD;
1438
1439 case SUPPAGINGMODE_PAE:
1440 case SUPPAGINGMODE_PAE_GLOBAL:
1441 case SUPPAGINGMODE_PAE_NX:
1442 case SUPPAGINGMODE_PAE_GLOBAL_NX:
1443 return pVM->pgm.s.HCPhysInterPaePDPT;
1444
1445 case SUPPAGINGMODE_AMD64:
1446 case SUPPAGINGMODE_AMD64_GLOBAL:
1447 case SUPPAGINGMODE_AMD64_NX:
1448 case SUPPAGINGMODE_AMD64_GLOBAL_NX:
1449 return pVM->pgm.s.HCPhysInterPaePDPT;
1450
1451 default:
1452 AssertMsgFailed(("enmHostMode=%d\n", pVM->pgm.s.enmHostMode));
1453 return ~0;
1454 }
1455}
1456
1457
1458/**
1459 * Gets the current CR3 register value for the RC intermediate memory context.
1460 * @returns CR3 value.
1461 * @param pVM The VM handle.
1462 */
1463VMMDECL(RTHCPHYS) PGMGetInterRCCR3(PVM pVM)
1464{
1465 switch (pVM->pgm.s.enmShadowMode)
1466 {
1467 case PGMMODE_32_BIT:
1468 return pVM->pgm.s.HCPhysInterPD;
1469
1470 case PGMMODE_PAE:
1471 case PGMMODE_PAE_NX:
1472 return pVM->pgm.s.HCPhysInterPaePDPT;
1473
1474 case PGMMODE_AMD64:
1475 case PGMMODE_AMD64_NX:
1476 return pVM->pgm.s.HCPhysInterPaePML4;
1477
1478 case PGMMODE_EPT:
1479 case PGMMODE_NESTED:
1480 return 0; /* not relevant */
1481
1482 default:
1483 AssertMsgFailed(("enmShadowMode=%d\n", pVM->pgm.s.enmShadowMode));
1484 return ~0;
1485 }
1486}
1487
1488
1489/**
1490 * Gets the CR3 register value for the 32-Bit intermediate memory context.
1491 * @returns CR3 value.
1492 * @param pVM The VM handle.
1493 */
1494VMMDECL(RTHCPHYS) PGMGetInter32BitCR3(PVM pVM)
1495{
1496 return pVM->pgm.s.HCPhysInterPD;
1497}
1498
1499
1500/**
1501 * Gets the CR3 register value for the PAE intermediate memory context.
1502 * @returns CR3 value.
1503 * @param pVM The VM handle.
1504 */
1505VMMDECL(RTHCPHYS) PGMGetInterPaeCR3(PVM pVM)
1506{
1507 return pVM->pgm.s.HCPhysInterPaePDPT;
1508}
1509
1510
1511/**
1512 * Gets the CR3 register value for the AMD64 intermediate memory context.
1513 * @returns CR3 value.
1514 * @param pVM The VM handle.
1515 */
1516VMMDECL(RTHCPHYS) PGMGetInterAmd64CR3(PVM pVM)
1517{
1518 return pVM->pgm.s.HCPhysInterPaePML4;
1519}
1520
1521
1522/**
1523 * Performs and schedules necessary updates following a CR3 load or reload.
1524 *
1525 * This will normally involve mapping the guest PD or nPDPT
1526 *
1527 * @returns VBox status code.
1528 * @retval VINF_PGM_SYNC_CR3 if monitoring requires a CR3 sync. This can
1529 * safely be ignored and overridden since the FF will be set too then.
1530 * @param pVM VM handle.
1531 * @param cr3 The new cr3.
1532 * @param fGlobal Indicates whether this is a global flush or not.
1533 */
1534VMMDECL(int) PGMFlushTLB(PVM pVM, uint64_t cr3, bool fGlobal)
1535{
1536 STAM_PROFILE_START(&pVM->pgm.s.CTX_MID_Z(Stat,FlushTLB), a);
1537
1538 /*
1539 * Always flag the necessary updates; necessary for hardware acceleration
1540 */
1541 /** @todo optimize this, it shouldn't always be necessary. */
1542 VM_FF_SET(pVM, VM_FF_PGM_SYNC_CR3_NON_GLOBAL);
1543 if (fGlobal)
1544 VM_FF_SET(pVM, VM_FF_PGM_SYNC_CR3);
1545 LogFlow(("PGMFlushTLB: cr3=%RX64 OldCr3=%RX64 fGlobal=%d\n", cr3, pVM->pgm.s.GCPhysCR3, fGlobal));
1546
1547 /*
1548 * Remap the CR3 content and adjust the monitoring if CR3 was actually changed.
1549 */
1550 int rc = VINF_SUCCESS;
1551 RTGCPHYS GCPhysCR3;
1552 switch (pVM->pgm.s.enmGuestMode)
1553 {
1554 case PGMMODE_PAE:
1555 case PGMMODE_PAE_NX:
1556 GCPhysCR3 = (RTGCPHYS)(cr3 & X86_CR3_PAE_PAGE_MASK);
1557 break;
1558 case PGMMODE_AMD64:
1559 case PGMMODE_AMD64_NX:
1560 GCPhysCR3 = (RTGCPHYS)(cr3 & X86_CR3_AMD64_PAGE_MASK);
1561 break;
1562 default:
1563 GCPhysCR3 = (RTGCPHYS)(cr3 & X86_CR3_PAGE_MASK);
1564 break;
1565 }
1566
1567 if (pVM->pgm.s.GCPhysCR3 != GCPhysCR3)
1568 {
1569 RTGCPHYS GCPhysOldCR3 = pVM->pgm.s.GCPhysCR3;
1570 pVM->pgm.s.GCPhysCR3 = GCPhysCR3;
1571 rc = PGM_BTH_PFN(MapCR3, pVM)(pVM, GCPhysCR3);
1572 if (RT_LIKELY(rc == VINF_SUCCESS))
1573 {
1574 if (!pVM->pgm.s.fMappingsFixed)
1575 {
1576 pVM->pgm.s.fSyncFlags &= ~PGM_SYNC_MONITOR_CR3;
1577 }
1578 }
1579 else
1580 {
1581 AssertMsg(rc == VINF_PGM_SYNC_CR3, ("%Rrc\n", rc));
1582 Assert(VM_FF_ISPENDING(pVM, VM_FF_PGM_SYNC_CR3_NON_GLOBAL | VM_FF_PGM_SYNC_CR3));
1583 pVM->pgm.s.GCPhysCR3 = GCPhysOldCR3;
1584 pVM->pgm.s.fSyncFlags |= PGM_SYNC_MAP_CR3;
1585 if (!pVM->pgm.s.fMappingsFixed)
1586 pVM->pgm.s.fSyncFlags |= PGM_SYNC_MONITOR_CR3;
1587 }
1588
1589 if (fGlobal)
1590 STAM_COUNTER_INC(&pVM->pgm.s.CTX_MID_Z(Stat,FlushTLBNewCR3Global));
1591 else
1592 STAM_COUNTER_INC(&pVM->pgm.s.CTX_MID_Z(Stat,FlushTLBNewCR3));
1593 }
1594 else
1595 {
1596 /*
1597 * Check if we have a pending update of the CR3 monitoring.
1598 */
1599 if (pVM->pgm.s.fSyncFlags & PGM_SYNC_MONITOR_CR3)
1600 {
1601 pVM->pgm.s.fSyncFlags &= ~PGM_SYNC_MONITOR_CR3;
1602 Assert(!pVM->pgm.s.fMappingsFixed);
1603 }
1604 if (fGlobal)
1605 STAM_COUNTER_INC(&pVM->pgm.s.CTX_MID_Z(Stat,FlushTLBSameCR3Global));
1606 else
1607 STAM_COUNTER_INC(&pVM->pgm.s.CTX_MID_Z(Stat,FlushTLBSameCR3));
1608 }
1609
1610 STAM_PROFILE_STOP(&pVM->pgm.s.CTX_MID_Z(Stat,FlushTLB), a);
1611 return rc;
1612}
1613
1614
1615/**
1616 * Performs and schedules necessary updates following a CR3 load or reload when
1617 * using nested or extended paging.
1618 *
1619 * This API is an alterantive to PDMFlushTLB that avoids actually flushing the
1620 * TLB and triggering a SyncCR3.
1621 *
1622 * This will normally involve mapping the guest PD or nPDPT
1623 *
1624 * @returns VBox status code.
1625 * @retval VINF_SUCCESS.
1626 * @retval (If applied when not in nested mode: VINF_PGM_SYNC_CR3 if monitoring
1627 * requires a CR3 sync. This can safely be ignored and overridden since
1628 * the FF will be set too then.)
1629 * @param pVM VM handle.
1630 * @param cr3 The new cr3.
1631 */
1632VMMDECL(int) PGMUpdateCR3(PVM pVM, uint64_t cr3)
1633{
1634 LogFlow(("PGMUpdateCR3: cr3=%RX64 OldCr3=%RX64\n", cr3, pVM->pgm.s.GCPhysCR3));
1635
1636 /* We assume we're only called in nested paging mode. */
1637 Assert(pVM->pgm.s.fMappingsFixed);
1638 Assert(!(pVM->pgm.s.fSyncFlags & PGM_SYNC_MONITOR_CR3));
1639 Assert(pVM->pgm.s.enmShadowMode == PGMMODE_NESTED || pVM->pgm.s.enmShadowMode == PGMMODE_EPT);
1640
1641 /*
1642 * Remap the CR3 content and adjust the monitoring if CR3 was actually changed.
1643 */
1644 int rc = VINF_SUCCESS;
1645 RTGCPHYS GCPhysCR3;
1646 switch (pVM->pgm.s.enmGuestMode)
1647 {
1648 case PGMMODE_PAE:
1649 case PGMMODE_PAE_NX:
1650 GCPhysCR3 = (RTGCPHYS)(cr3 & X86_CR3_PAE_PAGE_MASK);
1651 break;
1652 case PGMMODE_AMD64:
1653 case PGMMODE_AMD64_NX:
1654 GCPhysCR3 = (RTGCPHYS)(cr3 & X86_CR3_AMD64_PAGE_MASK);
1655 break;
1656 default:
1657 GCPhysCR3 = (RTGCPHYS)(cr3 & X86_CR3_PAGE_MASK);
1658 break;
1659 }
1660 if (pVM->pgm.s.GCPhysCR3 != GCPhysCR3)
1661 {
1662 pVM->pgm.s.GCPhysCR3 = GCPhysCR3;
1663 rc = PGM_BTH_PFN(MapCR3, pVM)(pVM, GCPhysCR3);
1664 AssertRCSuccess(rc); /* Assumes VINF_PGM_SYNC_CR3 doesn't apply to nested paging. */ /** @todo this isn't true for the mac, but we need hw to test/fix this. */
1665 }
1666 return rc;
1667}
1668
1669
1670/**
1671 * Synchronize the paging structures.
1672 *
1673 * This function is called in response to the VM_FF_PGM_SYNC_CR3 and
1674 * VM_FF_PGM_SYNC_CR3_NONGLOBAL. Those two force action flags are set
1675 * in several places, most importantly whenever the CR3 is loaded.
1676 *
1677 * @returns VBox status code.
1678 * @param pVM The virtual machine.
1679 * @param cr0 Guest context CR0 register
1680 * @param cr3 Guest context CR3 register
1681 * @param cr4 Guest context CR4 register
1682 * @param fGlobal Including global page directories or not
1683 */
1684VMMDECL(int) PGMSyncCR3(PVM pVM, uint64_t cr0, uint64_t cr3, uint64_t cr4, bool fGlobal)
1685{
1686 int rc;
1687
1688 /*
1689 * We might be called when we shouldn't.
1690 *
1691 * The mode switching will ensure that the PD is resynced
1692 * after every mode switch. So, if we find ourselves here
1693 * when in protected or real mode we can safely disable the
1694 * FF and return immediately.
1695 */
1696 if (pVM->pgm.s.enmGuestMode <= PGMMODE_PROTECTED)
1697 {
1698 Assert((cr0 & (X86_CR0_PG | X86_CR0_PE)) != (X86_CR0_PG | X86_CR0_PE));
1699 VM_FF_CLEAR(pVM, VM_FF_PGM_SYNC_CR3);
1700 VM_FF_CLEAR(pVM, VM_FF_PGM_SYNC_CR3_NON_GLOBAL);
1701 return VINF_SUCCESS;
1702 }
1703
1704 /* If global pages are not supported, then all flushes are global. */
1705 if (!(cr4 & X86_CR4_PGE))
1706 fGlobal = true;
1707 LogFlow(("PGMSyncCR3: cr0=%RX64 cr3=%RX64 cr4=%RX64 fGlobal=%d[%d,%d]\n", cr0, cr3, cr4, fGlobal,
1708 VM_FF_ISSET(pVM, VM_FF_PGM_SYNC_CR3), VM_FF_ISSET(pVM, VM_FF_PGM_SYNC_CR3_NON_GLOBAL)));
1709
1710#ifdef PGMPOOL_WITH_MONITORING
1711 /*
1712 * The pool may have pending stuff and even require a return to ring-3 to
1713 * clear the whole thing.
1714 */
1715 rc = pgmPoolSyncCR3(pVM);
1716 if (rc != VINF_SUCCESS)
1717 return rc;
1718#endif
1719
1720 /*
1721 * Check if we need to finish an aborted MapCR3 call (see PGMFlushTLB).
1722 * This should be done before SyncCR3.
1723 */
1724 if (pVM->pgm.s.fSyncFlags & PGM_SYNC_MAP_CR3)
1725 {
1726 pVM->pgm.s.fSyncFlags &= ~PGM_SYNC_MAP_CR3;
1727
1728 RTGCPHYS GCPhysCR3Old = pVM->pgm.s.GCPhysCR3;
1729 RTGCPHYS GCPhysCR3;
1730 switch (pVM->pgm.s.enmGuestMode)
1731 {
1732 case PGMMODE_PAE:
1733 case PGMMODE_PAE_NX:
1734 GCPhysCR3 = (RTGCPHYS)(cr3 & X86_CR3_PAE_PAGE_MASK);
1735 break;
1736 case PGMMODE_AMD64:
1737 case PGMMODE_AMD64_NX:
1738 GCPhysCR3 = (RTGCPHYS)(cr3 & X86_CR3_AMD64_PAGE_MASK);
1739 break;
1740 default:
1741 GCPhysCR3 = (RTGCPHYS)(cr3 & X86_CR3_PAGE_MASK);
1742 break;
1743 }
1744
1745 if (pVM->pgm.s.GCPhysCR3 != GCPhysCR3)
1746 {
1747 pVM->pgm.s.GCPhysCR3 = GCPhysCR3;
1748 rc = PGM_BTH_PFN(MapCR3, pVM)(pVM, GCPhysCR3);
1749 }
1750#ifdef IN_RING3
1751 if (rc == VINF_PGM_SYNC_CR3)
1752 rc = pgmPoolSyncCR3(pVM);
1753#else
1754 if (rc == VINF_PGM_SYNC_CR3)
1755 {
1756 pVM->pgm.s.GCPhysCR3 = GCPhysCR3Old;
1757 return rc;
1758 }
1759#endif
1760 AssertRCReturn(rc, rc);
1761 AssertRCSuccessReturn(rc, VERR_INTERNAL_ERROR);
1762 }
1763
1764 /*
1765 * Let the 'Bth' function do the work and we'll just keep track of the flags.
1766 */
1767 STAM_PROFILE_START(&pVM->pgm.s.CTX_MID_Z(Stat,SyncCR3), a);
1768 rc = PGM_BTH_PFN(SyncCR3, pVM)(pVM, cr0, cr3, cr4, fGlobal);
1769 STAM_PROFILE_STOP(&pVM->pgm.s.CTX_MID_Z(Stat,SyncCR3), a);
1770 AssertMsg(rc == VINF_SUCCESS || rc == VINF_PGM_SYNC_CR3 || RT_FAILURE(rc), ("rc=%Rrc\n", rc));
1771 if (rc == VINF_SUCCESS)
1772 {
1773 if (!(pVM->pgm.s.fSyncFlags & PGM_SYNC_ALWAYS))
1774 {
1775 VM_FF_CLEAR(pVM, VM_FF_PGM_SYNC_CR3);
1776 VM_FF_CLEAR(pVM, VM_FF_PGM_SYNC_CR3_NON_GLOBAL);
1777 }
1778
1779 /*
1780 * Check if we have a pending update of the CR3 monitoring.
1781 */
1782 if (pVM->pgm.s.fSyncFlags & PGM_SYNC_MONITOR_CR3)
1783 {
1784 pVM->pgm.s.fSyncFlags &= ~PGM_SYNC_MONITOR_CR3;
1785 Assert(!pVM->pgm.s.fMappingsFixed);
1786 }
1787 }
1788
1789 /*
1790 * Now flush the CR3 (guest context).
1791 */
1792 if (rc == VINF_SUCCESS)
1793 PGM_INVL_GUEST_TLBS();
1794 return rc;
1795}
1796
1797
1798/**
1799 * Called whenever CR0 or CR4 in a way which may change
1800 * the paging mode.
1801 *
1802 * @returns VBox status code fit for scheduling in GC and R0.
1803 * @retval VINF_SUCCESS if the was no change, or it was successfully dealt with.
1804 * @retval VINF_PGM_CHANGE_MODE if we're in GC or R0 and the mode changes.
1805 * @param pVM VM handle.
1806 * @param cr0 The new cr0.
1807 * @param cr4 The new cr4.
1808 * @param efer The new extended feature enable register.
1809 */
1810VMMDECL(int) PGMChangeMode(PVM pVM, uint64_t cr0, uint64_t cr4, uint64_t efer)
1811{
1812 PGMMODE enmGuestMode;
1813
1814 /*
1815 * Calc the new guest mode.
1816 */
1817 if (!(cr0 & X86_CR0_PE))
1818 enmGuestMode = PGMMODE_REAL;
1819 else if (!(cr0 & X86_CR0_PG))
1820 enmGuestMode = PGMMODE_PROTECTED;
1821 else if (!(cr4 & X86_CR4_PAE))
1822 enmGuestMode = PGMMODE_32_BIT;
1823 else if (!(efer & MSR_K6_EFER_LME))
1824 {
1825 if (!(efer & MSR_K6_EFER_NXE))
1826 enmGuestMode = PGMMODE_PAE;
1827 else
1828 enmGuestMode = PGMMODE_PAE_NX;
1829 }
1830 else
1831 {
1832 if (!(efer & MSR_K6_EFER_NXE))
1833 enmGuestMode = PGMMODE_AMD64;
1834 else
1835 enmGuestMode = PGMMODE_AMD64_NX;
1836 }
1837
1838 /*
1839 * Did it change?
1840 */
1841 if (pVM->pgm.s.enmGuestMode == enmGuestMode)
1842 return VINF_SUCCESS;
1843
1844 /* Flush the TLB */
1845 PGM_INVL_GUEST_TLBS();
1846
1847#ifdef IN_RING3
1848 return PGMR3ChangeMode(pVM, enmGuestMode);
1849#else
1850 LogFlow(("PGMChangeMode: returns VINF_PGM_CHANGE_MODE.\n"));
1851 return VINF_PGM_CHANGE_MODE;
1852#endif
1853}
1854
1855
1856/**
1857 * Gets the current guest paging mode.
1858 *
1859 * If you just need the CPU mode (real/protected/long), use CPUMGetGuestMode().
1860 *
1861 * @returns The current paging mode.
1862 * @param pVM The VM handle.
1863 */
1864VMMDECL(PGMMODE) PGMGetGuestMode(PVM pVM)
1865{
1866 return pVM->pgm.s.enmGuestMode;
1867}
1868
1869
1870/**
1871 * Gets the current shadow paging mode.
1872 *
1873 * @returns The current paging mode.
1874 * @param pVM The VM handle.
1875 */
1876VMMDECL(PGMMODE) PGMGetShadowMode(PVM pVM)
1877{
1878 return pVM->pgm.s.enmShadowMode;
1879}
1880
1881/**
1882 * Gets the current host paging mode.
1883 *
1884 * @returns The current paging mode.
1885 * @param pVM The VM handle.
1886 */
1887VMMDECL(PGMMODE) PGMGetHostMode(PVM pVM)
1888{
1889 switch (pVM->pgm.s.enmHostMode)
1890 {
1891 case SUPPAGINGMODE_32_BIT:
1892 case SUPPAGINGMODE_32_BIT_GLOBAL:
1893 return PGMMODE_32_BIT;
1894
1895 case SUPPAGINGMODE_PAE:
1896 case SUPPAGINGMODE_PAE_GLOBAL:
1897 return PGMMODE_PAE;
1898
1899 case SUPPAGINGMODE_PAE_NX:
1900 case SUPPAGINGMODE_PAE_GLOBAL_NX:
1901 return PGMMODE_PAE_NX;
1902
1903 case SUPPAGINGMODE_AMD64:
1904 case SUPPAGINGMODE_AMD64_GLOBAL:
1905 return PGMMODE_AMD64;
1906
1907 case SUPPAGINGMODE_AMD64_NX:
1908 case SUPPAGINGMODE_AMD64_GLOBAL_NX:
1909 return PGMMODE_AMD64_NX;
1910
1911 default: AssertMsgFailed(("enmHostMode=%d\n", pVM->pgm.s.enmHostMode)); break;
1912 }
1913
1914 return PGMMODE_INVALID;
1915}
1916
1917
1918/**
1919 * Get mode name.
1920 *
1921 * @returns read-only name string.
1922 * @param enmMode The mode which name is desired.
1923 */
1924VMMDECL(const char *) PGMGetModeName(PGMMODE enmMode)
1925{
1926 switch (enmMode)
1927 {
1928 case PGMMODE_REAL: return "Real";
1929 case PGMMODE_PROTECTED: return "Protected";
1930 case PGMMODE_32_BIT: return "32-bit";
1931 case PGMMODE_PAE: return "PAE";
1932 case PGMMODE_PAE_NX: return "PAE+NX";
1933 case PGMMODE_AMD64: return "AMD64";
1934 case PGMMODE_AMD64_NX: return "AMD64+NX";
1935 case PGMMODE_NESTED: return "Nested";
1936 case PGMMODE_EPT: return "EPT";
1937 default: return "unknown mode value";
1938 }
1939}
1940
1941
1942/**
1943 * Acquire the PGM lock.
1944 *
1945 * @returns VBox status code
1946 * @param pVM The VM to operate on.
1947 */
1948int pgmLock(PVM pVM)
1949{
1950 int rc = PDMCritSectEnter(&pVM->pgm.s.CritSect, VERR_SEM_BUSY);
1951#ifdef IN_RC
1952 if (rc == VERR_SEM_BUSY)
1953 rc = VMMGCCallHost(pVM, VMMCALLHOST_PGM_LOCK, 0);
1954#elif defined(IN_RING0)
1955 if (rc == VERR_SEM_BUSY)
1956 rc = VMMR0CallHost(pVM, VMMCALLHOST_PGM_LOCK, 0);
1957#endif
1958 AssertMsg(rc == VINF_SUCCESS, ("%Rrc\n", rc));
1959 return rc;
1960}
1961
1962
1963/**
1964 * Release the PGM lock.
1965 *
1966 * @returns VBox status code
1967 * @param pVM The VM to operate on.
1968 */
1969void pgmUnlock(PVM pVM)
1970{
1971 PDMCritSectLeave(&pVM->pgm.s.CritSect);
1972}
1973
1974#if defined(IN_RC) || defined(VBOX_WITH_2X_4GB_ADDR_SPACE_IN_R0)
1975
1976/**
1977 * Temporarily maps one guest page specified by GC physical address.
1978 * These pages must have a physical mapping in HC, i.e. they cannot be MMIO pages.
1979 *
1980 * Be WARNED that the dynamic page mapping area is small, 8 pages, thus the space is
1981 * reused after 8 mappings (or perhaps a few more if you score with the cache).
1982 *
1983 * @returns VBox status.
1984 * @param pVM VM handle.
1985 * @param GCPhys GC Physical address of the page.
1986 * @param ppv Where to store the address of the mapping.
1987 */
1988VMMDECL(int) PGMDynMapGCPage(PVM pVM, RTGCPHYS GCPhys, void **ppv)
1989{
1990 AssertMsg(!(GCPhys & PAGE_OFFSET_MASK), ("GCPhys=%RGp\n", GCPhys));
1991
1992 /*
1993 * Get the ram range.
1994 */
1995 PPGMRAMRANGE pRam = pVM->pgm.s.CTX_SUFF(pRamRanges);
1996 while (pRam && GCPhys - pRam->GCPhys >= pRam->cb)
1997 pRam = pRam->CTX_SUFF(pNext);
1998 if (!pRam)
1999 {
2000 AssertMsgFailed(("Invalid physical address %RGp!\n", GCPhys));
2001 return VERR_PGM_INVALID_GC_PHYSICAL_ADDRESS;
2002 }
2003
2004 /*
2005 * Pass it on to PGMDynMapHCPage.
2006 */
2007 RTHCPHYS HCPhys = PGM_PAGE_GET_HCPHYS(&pRam->aPages[(GCPhys - pRam->GCPhys) >> PAGE_SHIFT]);
2008 //Log(("PGMDynMapGCPage: GCPhys=%RGp HCPhys=%RHp\n", GCPhys, HCPhys));
2009#ifdef VBOX_WITH_2X_4GB_ADDR_SPACE_IN_R0
2010 pgmR0DynMapHCPageInlined(&pVM->pgm.s, HCPhys, ppv);
2011#else
2012 PGMDynMapHCPage(pVM, HCPhys, ppv);
2013#endif
2014 return VINF_SUCCESS;
2015}
2016
2017
2018/**
2019 * Temporarily maps one guest page specified by unaligned GC physical address.
2020 * These pages must have a physical mapping in HC, i.e. they cannot be MMIO pages.
2021 *
2022 * Be WARNED that the dynamic page mapping area is small, 8 pages, thus the space is
2023 * reused after 8 mappings (or perhaps a few more if you score with the cache).
2024 *
2025 * The caller is aware that only the speicifed page is mapped and that really bad things
2026 * will happen if writing beyond the page!
2027 *
2028 * @returns VBox status.
2029 * @param pVM VM handle.
2030 * @param GCPhys GC Physical address within the page to be mapped.
2031 * @param ppv Where to store the address of the mapping address corresponding to GCPhys.
2032 */
2033VMMDECL(int) PGMDynMapGCPageOff(PVM pVM, RTGCPHYS GCPhys, void **ppv)
2034{
2035 /*
2036 * Get the ram range.
2037 */
2038 PPGMRAMRANGE pRam = pVM->pgm.s.CTX_SUFF(pRamRanges);
2039 while (pRam && GCPhys - pRam->GCPhys >= pRam->cb)
2040 pRam = pRam->CTX_SUFF(pNext);
2041 if (!pRam)
2042 {
2043 AssertMsgFailed(("Invalid physical address %RGp!\n", GCPhys));
2044 return VERR_PGM_INVALID_GC_PHYSICAL_ADDRESS;
2045 }
2046
2047 /*
2048 * Pass it on to PGMDynMapHCPage.
2049 */
2050 RTHCPHYS HCPhys = PGM_PAGE_GET_HCPHYS(&pRam->aPages[(GCPhys - pRam->GCPhys) >> PAGE_SHIFT]);
2051#ifdef VBOX_WITH_2X_4GB_ADDR_SPACE_IN_R0
2052 pgmR0DynMapHCPageInlined(&pVM->pgm.s, HCPhys, ppv);
2053#else
2054 PGMDynMapHCPage(pVM, HCPhys, ppv);
2055#endif
2056 *ppv = (void *)((uintptr_t)*ppv | (GCPhys & PAGE_OFFSET_MASK));
2057 return VINF_SUCCESS;
2058}
2059
2060# ifdef IN_RC
2061
2062/**
2063 * Temporarily maps one host page specified by HC physical address.
2064 *
2065 * Be WARNED that the dynamic page mapping area is small, 16 pages, thus the space is
2066 * reused after 16 mappings (or perhaps a few more if you score with the cache).
2067 *
2068 * @returns VINF_SUCCESS, will bail out to ring-3 on failure.
2069 * @param pVM VM handle.
2070 * @param HCPhys HC Physical address of the page.
2071 * @param ppv Where to store the address of the mapping. This is the
2072 * address of the PAGE not the exact address corresponding
2073 * to HCPhys. Use PGMDynMapHCPageOff if you care for the
2074 * page offset.
2075 */
2076VMMDECL(int) PGMDynMapHCPage(PVM pVM, RTHCPHYS HCPhys, void **ppv)
2077{
2078 AssertMsg(!(HCPhys & PAGE_OFFSET_MASK), ("HCPhys=%RHp\n", HCPhys));
2079
2080 /*
2081 * Check the cache.
2082 */
2083 register unsigned iCache;
2084 for (iCache = 0;iCache < RT_ELEMENTS(pVM->pgm.s.aHCPhysDynPageMapCache);iCache++)
2085 {
2086 static const uint8_t au8Trans[MM_HYPER_DYNAMIC_SIZE >> PAGE_SHIFT][RT_ELEMENTS(pVM->pgm.s.aHCPhysDynPageMapCache)] =
2087 {
2088 { 0, 9, 10, 11, 12, 13, 14, 15},
2089 { 0, 1, 10, 11, 12, 13, 14, 15},
2090 { 0, 1, 2, 11, 12, 13, 14, 15},
2091 { 0, 1, 2, 3, 12, 13, 14, 15},
2092 { 0, 1, 2, 3, 4, 13, 14, 15},
2093 { 0, 1, 2, 3, 4, 5, 14, 15},
2094 { 0, 1, 2, 3, 4, 5, 6, 15},
2095 { 0, 1, 2, 3, 4, 5, 6, 7},
2096 { 8, 1, 2, 3, 4, 5, 6, 7},
2097 { 8, 9, 2, 3, 4, 5, 6, 7},
2098 { 8, 9, 10, 3, 4, 5, 6, 7},
2099 { 8, 9, 10, 11, 4, 5, 6, 7},
2100 { 8, 9, 10, 11, 12, 5, 6, 7},
2101 { 8, 9, 10, 11, 12, 13, 6, 7},
2102 { 8, 9, 10, 11, 12, 13, 14, 7},
2103 { 8, 9, 10, 11, 12, 13, 14, 15},
2104 };
2105 AssertCompile(RT_ELEMENTS(au8Trans) == 16);
2106 AssertCompile(RT_ELEMENTS(au8Trans[0]) == 8);
2107
2108 if (pVM->pgm.s.aHCPhysDynPageMapCache[iCache] == HCPhys)
2109 {
2110 int iPage = au8Trans[pVM->pgm.s.iDynPageMapLast][iCache];
2111
2112 /* The cache can get out of sync with locked entries. (10 locked, 2 overwrites its cache position, last = 11, lookup 2 -> page 10 instead of 2) */
2113 if ((pVM->pgm.s.paDynPageMap32BitPTEsGC[iPage].u & X86_PTE_PG_MASK) == HCPhys)
2114 {
2115 void *pv = pVM->pgm.s.pbDynPageMapBaseGC + (iPage << PAGE_SHIFT);
2116 *ppv = pv;
2117 STAM_COUNTER_INC(&pVM->pgm.s.StatRCDynMapCacheHits);
2118 Log4(("PGMGCDynMapHCPage: HCPhys=%RHp pv=%p iPage=%d iCache=%d\n", HCPhys, pv, iPage, iCache));
2119 return VINF_SUCCESS;
2120 }
2121 else
2122 LogFlow(("Out of sync entry %d\n", iPage));
2123 }
2124 }
2125 AssertCompile(RT_ELEMENTS(pVM->pgm.s.aHCPhysDynPageMapCache) == 8);
2126 AssertCompile((MM_HYPER_DYNAMIC_SIZE >> PAGE_SHIFT) == 16);
2127 STAM_COUNTER_INC(&pVM->pgm.s.StatRCDynMapCacheMisses);
2128
2129 /*
2130 * Update the page tables.
2131 */
2132 register unsigned iPage = pVM->pgm.s.iDynPageMapLast;
2133 unsigned i;
2134 for (i=0;i<(MM_HYPER_DYNAMIC_SIZE >> PAGE_SHIFT);i++)
2135 {
2136 pVM->pgm.s.iDynPageMapLast = iPage = (iPage + 1) & ((MM_HYPER_DYNAMIC_SIZE >> PAGE_SHIFT) - 1);
2137 if (!pVM->pgm.s.aLockedDynPageMapCache[iPage])
2138 break;
2139 iPage++;
2140 }
2141 AssertRelease(i != (MM_HYPER_DYNAMIC_SIZE >> PAGE_SHIFT));
2142
2143 pVM->pgm.s.aHCPhysDynPageMapCache[iPage & (RT_ELEMENTS(pVM->pgm.s.aHCPhysDynPageMapCache) - 1)] = HCPhys;
2144 pVM->pgm.s.paDynPageMap32BitPTEsGC[iPage].u = (uint32_t)HCPhys | X86_PTE_P | X86_PTE_A | X86_PTE_D;
2145 pVM->pgm.s.paDynPageMapPaePTEsGC[iPage].u = HCPhys | X86_PTE_P | X86_PTE_A | X86_PTE_D;
2146 pVM->pgm.s.aLockedDynPageMapCache[iPage] = 0;
2147
2148 void *pv = pVM->pgm.s.pbDynPageMapBaseGC + (iPage << PAGE_SHIFT);
2149 *ppv = pv;
2150 ASMInvalidatePage(pv);
2151 Log4(("PGMGCDynMapHCPage: HCPhys=%RHp pv=%p iPage=%d\n", HCPhys, pv, iPage));
2152 return VINF_SUCCESS;
2153}
2154
2155
2156/**
2157 * Temporarily lock a dynamic page to prevent it from being reused.
2158 *
2159 * @param pVM VM handle.
2160 * @param GCPage GC address of page
2161 */
2162VMMDECL(void) PGMDynLockHCPage(PVM pVM, RCPTRTYPE(uint8_t *) GCPage)
2163{
2164 unsigned iPage;
2165
2166 Assert(GCPage >= pVM->pgm.s.pbDynPageMapBaseGC && GCPage < (pVM->pgm.s.pbDynPageMapBaseGC + MM_HYPER_DYNAMIC_SIZE));
2167 iPage = ((uintptr_t)(GCPage - pVM->pgm.s.pbDynPageMapBaseGC)) >> PAGE_SHIFT;
2168 ASMAtomicIncU32(&pVM->pgm.s.aLockedDynPageMapCache[iPage]);
2169 Log4(("PGMDynLockHCPage %RRv iPage=%d\n", GCPage, iPage));
2170}
2171
2172
2173/**
2174 * Unlock a dynamic page
2175 *
2176 * @param pVM VM handle.
2177 * @param GCPage GC address of page
2178 */
2179VMMDECL(void) PGMDynUnlockHCPage(PVM pVM, RCPTRTYPE(uint8_t *) GCPage)
2180{
2181 unsigned iPage;
2182
2183 AssertCompile(RT_ELEMENTS(pVM->pgm.s.aHCPhysDynPageMapCache) == RT_ELEMENTS(pVM->pgm.s.aLockedDynPageMapCache));
2184
2185 Assert(GCPage >= pVM->pgm.s.pbDynPageMapBaseGC && GCPage < (pVM->pgm.s.pbDynPageMapBaseGC + MM_HYPER_DYNAMIC_SIZE));
2186 iPage = ((uintptr_t)(GCPage - pVM->pgm.s.pbDynPageMapBaseGC)) >> PAGE_SHIFT;
2187 Assert(pVM->pgm.s.aLockedDynPageMapCache[iPage]);
2188 ASMAtomicDecU32(&pVM->pgm.s.aLockedDynPageMapCache[iPage]);
2189 Log4(("PGMDynUnlockHCPage %RRv iPage=%d\n", GCPage, iPage));
2190}
2191
2192
2193# ifdef VBOX_STRICT
2194/**
2195 * Check for lock leaks.
2196 *
2197 * @param pVM VM handle.
2198 */
2199VMMDECL(void) PGMDynCheckLocks(PVM pVM)
2200{
2201 for (unsigned i=0;i<RT_ELEMENTS(pVM->pgm.s.aLockedDynPageMapCache);i++)
2202 Assert(!pVM->pgm.s.aLockedDynPageMapCache[i]);
2203}
2204# endif /* VBOX_STRICT */
2205
2206# endif /* IN_RC */
2207#endif /* IN_RC || VBOX_WITH_2X_4GB_ADDR_SPACE_IN_R0 */
2208
2209#if !defined(IN_R0) || defined(LOG_ENABLED)
2210
2211/** Format handler for PGMPAGE.
2212 * @copydoc FNRTSTRFORMATTYPE */
2213static DECLCALLBACK(size_t) pgmFormatTypeHandlerPage(PFNRTSTROUTPUT pfnOutput, void *pvArgOutput,
2214 const char *pszType, void const *pvValue,
2215 int cchWidth, int cchPrecision, unsigned fFlags,
2216 void *pvUser)
2217{
2218 size_t cch;
2219 PCPGMPAGE pPage = (PCPGMPAGE)pvValue;
2220 if (VALID_PTR(pPage))
2221 {
2222 char szTmp[64+80];
2223
2224 cch = 0;
2225
2226 /* The single char state stuff. */
2227 static const char s_achPageStates[4] = { 'Z', 'A', 'W', 'S' };
2228 szTmp[cch++] = s_achPageStates[PGM_PAGE_GET_STATE(pPage)];
2229
2230#define IS_PART_INCLUDED(lvl) ( !(fFlags & RTSTR_F_PRECISION) || cchPrecision == (lvl) || cchPrecision >= (lvl)+10 )
2231 if (IS_PART_INCLUDED(5))
2232 {
2233 static const char s_achHandlerStates[4] = { '-', 't', 'w', 'a' };
2234 szTmp[cch++] = s_achHandlerStates[PGM_PAGE_GET_HNDL_PHYS_STATE(pPage)];
2235 szTmp[cch++] = s_achHandlerStates[PGM_PAGE_GET_HNDL_VIRT_STATE(pPage)];
2236 }
2237
2238 /* The type. */
2239 if (IS_PART_INCLUDED(4))
2240 {
2241 szTmp[cch++] = ':';
2242 static const char s_achPageTypes[8][4] = { "INV", "RAM", "MI2", "M2A", "SHA", "ROM", "MIO", "BAD" };
2243 szTmp[cch++] = s_achPageTypes[PGM_PAGE_GET_TYPE(pPage)][0];
2244 szTmp[cch++] = s_achPageTypes[PGM_PAGE_GET_TYPE(pPage)][1];
2245 szTmp[cch++] = s_achPageTypes[PGM_PAGE_GET_TYPE(pPage)][2];
2246 }
2247
2248 /* The numbers. */
2249 if (IS_PART_INCLUDED(3))
2250 {
2251 szTmp[cch++] = ':';
2252 cch += RTStrFormatNumber(&szTmp[cch], PGM_PAGE_GET_HCPHYS(pPage), 16, 12, 0, RTSTR_F_ZEROPAD | RTSTR_F_64BIT);
2253 }
2254
2255 if (IS_PART_INCLUDED(2))
2256 {
2257 szTmp[cch++] = ':';
2258 cch += RTStrFormatNumber(&szTmp[cch], PGM_PAGE_GET_PAGEID(pPage), 16, 7, 0, RTSTR_F_ZEROPAD | RTSTR_F_32BIT);
2259 }
2260
2261 if (IS_PART_INCLUDED(6))
2262 {
2263 szTmp[cch++] = ':';
2264 static const char s_achRefs[4] = { '-', 'U', '!', 'L' };
2265 szTmp[cch++] = s_achRefs[PGM_PAGE_GET_TD_CREFS(pPage)];
2266 cch += RTStrFormatNumber(&szTmp[cch], PGM_PAGE_GET_TD_IDX(pPage), 16, 4, 0, RTSTR_F_ZEROPAD | RTSTR_F_16BIT);
2267 }
2268#undef IS_PART_INCLUDED
2269
2270 cch = pfnOutput(pvArgOutput, szTmp, cch);
2271 }
2272 else
2273 cch = pfnOutput(pvArgOutput, "<bad-pgmpage-ptr>", sizeof("<bad-pgmpage-ptr>") - 1);
2274 return cch;
2275}
2276
2277
2278/** Format handler for PGMRAMRANGE.
2279 * @copydoc FNRTSTRFORMATTYPE */
2280static DECLCALLBACK(size_t) pgmFormatTypeHandlerRamRange(PFNRTSTROUTPUT pfnOutput, void *pvArgOutput,
2281 const char *pszType, void const *pvValue,
2282 int cchWidth, int cchPrecision, unsigned fFlags,
2283 void *pvUser)
2284{
2285 size_t cch;
2286 PGMRAMRANGE const *pRam = (PGMRAMRANGE const *)pvValue;
2287 if (VALID_PTR(pRam))
2288 {
2289 char szTmp[80];
2290 cch = RTStrPrintf(szTmp, sizeof(szTmp), "%RGp-%RGp", pRam->GCPhys, pRam->GCPhysLast);
2291 cch = pfnOutput(pvArgOutput, szTmp, cch);
2292 }
2293 else
2294 cch = pfnOutput(pvArgOutput, "<bad-pgmramrange-ptr>", sizeof("<bad-pgmramrange-ptr>") - 1);
2295 return cch;
2296}
2297
2298/** Format type andlers to be registered/deregistered. */
2299static const struct
2300{
2301 char szType[24];
2302 PFNRTSTRFORMATTYPE pfnHandler;
2303} g_aPgmFormatTypes[] =
2304{
2305 { "pgmpage", pgmFormatTypeHandlerPage },
2306 { "pgmramrange", pgmFormatTypeHandlerRamRange }
2307};
2308
2309#endif /* !IN_R0 || LOG_ENABLED */
2310
2311
2312/**
2313 * Registers the global string format types.
2314 *
2315 * This should be called at module load time or in some other manner that ensure
2316 * that it's called exactly one time.
2317 *
2318 * @returns IPRT status code on RTStrFormatTypeRegister failure.
2319 */
2320VMMDECL(int) PGMRegisterStringFormatTypes(void)
2321{
2322#if !defined(IN_R0) || defined(LOG_ENABLED)
2323 int rc = VINF_SUCCESS;
2324 unsigned i;
2325 for (i = 0; RT_SUCCESS(rc) && i < RT_ELEMENTS(g_aPgmFormatTypes); i++)
2326 {
2327 rc = RTStrFormatTypeRegister(g_aPgmFormatTypes[i].szType, g_aPgmFormatTypes[i].pfnHandler, NULL);
2328# ifdef IN_RING0
2329 if (rc == VERR_ALREADY_EXISTS)
2330 {
2331 /* in case of cleanup failure in ring-0 */
2332 RTStrFormatTypeDeregister(g_aPgmFormatTypes[i].szType);
2333 rc = RTStrFormatTypeRegister(g_aPgmFormatTypes[i].szType, g_aPgmFormatTypes[i].pfnHandler, NULL);
2334 }
2335# endif
2336 }
2337 if (RT_FAILURE(rc))
2338 while (i-- > 0)
2339 RTStrFormatTypeDeregister(g_aPgmFormatTypes[i].szType);
2340
2341 return rc;
2342#else
2343 return VINF_SUCCESS;
2344#endif
2345}
2346
2347
2348/**
2349 * Deregisters the global string format types.
2350 *
2351 * This should be called at module unload time or in some other manner that
2352 * ensure that it's called exactly one time.
2353 */
2354VMMDECL(void) PGMDeregisterStringFormatTypes(void)
2355{
2356#if !defined(IN_R0) || defined(LOG_ENABLED)
2357 for (unsigned i = 0; i < RT_ELEMENTS(g_aPgmFormatTypes); i++)
2358 RTStrFormatTypeDeregister(g_aPgmFormatTypes[i].szType);
2359#endif
2360}
2361
2362#ifdef VBOX_STRICT
2363
2364/**
2365 * Asserts that there are no mapping conflicts.
2366 *
2367 * @returns Number of conflicts.
2368 * @param pVM The VM Handle.
2369 */
2370VMMDECL(unsigned) PGMAssertNoMappingConflicts(PVM pVM)
2371{
2372 unsigned cErrors = 0;
2373
2374 /*
2375 * Check for mapping conflicts.
2376 */
2377 for (PPGMMAPPING pMapping = pVM->pgm.s.CTX_SUFF(pMappings);
2378 pMapping;
2379 pMapping = pMapping->CTX_SUFF(pNext))
2380 {
2381 /** @todo This is slow and should be optimized, but since it's just assertions I don't care now. */
2382 for (RTGCPTR GCPtr = pMapping->GCPtr;
2383 GCPtr <= pMapping->GCPtrLast;
2384 GCPtr += PAGE_SIZE)
2385 {
2386 int rc = PGMGstGetPage(pVM, (RTGCPTR)GCPtr, NULL, NULL);
2387 if (rc != VERR_PAGE_TABLE_NOT_PRESENT)
2388 {
2389 AssertMsgFailed(("Conflict at %RGv with %s\n", GCPtr, R3STRING(pMapping->pszDesc)));
2390 cErrors++;
2391 break;
2392 }
2393 }
2394 }
2395
2396 return cErrors;
2397}
2398
2399
2400/**
2401 * Asserts that everything related to the guest CR3 is correctly shadowed.
2402 *
2403 * This will call PGMAssertNoMappingConflicts() and PGMAssertHandlerAndFlagsInSync(),
2404 * and assert the correctness of the guest CR3 mapping before asserting that the
2405 * shadow page tables is in sync with the guest page tables.
2406 *
2407 * @returns Number of conflicts.
2408 * @param pVM The VM Handle.
2409 * @param cr3 The current guest CR3 register value.
2410 * @param cr4 The current guest CR4 register value.
2411 */
2412VMMDECL(unsigned) PGMAssertCR3(PVM pVM, uint64_t cr3, uint64_t cr4)
2413{
2414 STAM_PROFILE_START(&pVM->pgm.s.CTX_MID_Z(Stat,SyncCR3), a);
2415 unsigned cErrors = PGM_BTH_PFN(AssertCR3, pVM)(pVM, cr3, cr4, 0, ~(RTGCPTR)0);
2416 STAM_PROFILE_STOP(&pVM->pgm.s.CTX_MID_Z(Stat,SyncCR3), a);
2417 return cErrors;
2418}
2419
2420#endif /* VBOX_STRICT */
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