VirtualBox

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

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

PGM: Merged PGMGCInvalidatePage into PGMInvalidatePage nad fixed the callers of it to handle the return codes correctly. other cleanup.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 65.2 KB
Line 
1/* $Id: PGMAll.cpp 13235 2008-10-13 20:48:53Z 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*******************************************************************************/
71
72/*
73 * Shadow - 32-bit mode
74 */
75#define PGM_SHW_TYPE PGM_TYPE_32BIT
76#define PGM_SHW_NAME(name) PGM_SHW_NAME_32BIT(name)
77#include "PGMAllShw.h"
78
79/* Guest - real mode */
80#define PGM_GST_TYPE PGM_TYPE_REAL
81#define PGM_GST_NAME(name) PGM_GST_NAME_REAL(name)
82#define PGM_BTH_NAME(name) PGM_BTH_NAME_32BIT_REAL(name)
83#define BTH_PGMPOOLKIND_PT_FOR_PT PGMPOOLKIND_32BIT_PT_FOR_PHYS
84#include "PGMAllGst.h"
85#include "PGMAllBth.h"
86#undef BTH_PGMPOOLKIND_PT_FOR_PT
87#undef PGM_BTH_NAME
88#undef PGM_GST_TYPE
89#undef PGM_GST_NAME
90
91/* Guest - protected mode */
92#define PGM_GST_TYPE PGM_TYPE_PROT
93#define PGM_GST_NAME(name) PGM_GST_NAME_PROT(name)
94#define PGM_BTH_NAME(name) PGM_BTH_NAME_32BIT_PROT(name)
95#define BTH_PGMPOOLKIND_PT_FOR_PT PGMPOOLKIND_32BIT_PT_FOR_PHYS
96#include "PGMAllGst.h"
97#include "PGMAllBth.h"
98#undef BTH_PGMPOOLKIND_PT_FOR_PT
99#undef PGM_BTH_NAME
100#undef PGM_GST_TYPE
101#undef PGM_GST_NAME
102
103/* Guest - 32-bit mode */
104#define PGM_GST_TYPE PGM_TYPE_32BIT
105#define PGM_GST_NAME(name) PGM_GST_NAME_32BIT(name)
106#define PGM_BTH_NAME(name) PGM_BTH_NAME_32BIT_32BIT(name)
107#define BTH_PGMPOOLKIND_PT_FOR_PT PGMPOOLKIND_32BIT_PT_FOR_32BIT_PT
108#define BTH_PGMPOOLKIND_PT_FOR_BIG PGMPOOLKIND_32BIT_PT_FOR_32BIT_4MB
109#include "PGMAllGst.h"
110#include "PGMAllBth.h"
111#undef BTH_PGMPOOLKIND_PT_FOR_BIG
112#undef BTH_PGMPOOLKIND_PT_FOR_PT
113#undef PGM_BTH_NAME
114#undef PGM_GST_TYPE
115#undef PGM_GST_NAME
116
117#undef PGM_SHW_TYPE
118#undef PGM_SHW_NAME
119
120
121/*
122 * Shadow - PAE mode
123 */
124#define PGM_SHW_TYPE PGM_TYPE_PAE
125#define PGM_SHW_NAME(name) PGM_SHW_NAME_PAE(name)
126#define PGM_BTH_NAME(name) PGM_BTH_NAME_PAE_REAL(name)
127#include "PGMAllShw.h"
128
129/* Guest - real mode */
130#define PGM_GST_TYPE PGM_TYPE_REAL
131#define PGM_GST_NAME(name) PGM_GST_NAME_REAL(name)
132#define PGM_BTH_NAME(name) PGM_BTH_NAME_PAE_REAL(name)
133#define BTH_PGMPOOLKIND_PT_FOR_PT PGMPOOLKIND_PAE_PT_FOR_PHYS
134#include "PGMAllBth.h"
135#undef BTH_PGMPOOLKIND_PT_FOR_PT
136#undef PGM_BTH_NAME
137#undef PGM_GST_TYPE
138#undef PGM_GST_NAME
139
140/* Guest - protected mode */
141#define PGM_GST_TYPE PGM_TYPE_PROT
142#define PGM_GST_NAME(name) PGM_GST_NAME_PROT(name)
143#define PGM_BTH_NAME(name) PGM_BTH_NAME_PAE_PROT(name)
144#define BTH_PGMPOOLKIND_PT_FOR_PT PGMPOOLKIND_PAE_PT_FOR_PHYS
145#include "PGMAllBth.h"
146#undef BTH_PGMPOOLKIND_PT_FOR_PT
147#undef PGM_BTH_NAME
148#undef PGM_GST_TYPE
149#undef PGM_GST_NAME
150
151/* Guest - 32-bit mode */
152#define PGM_GST_TYPE PGM_TYPE_32BIT
153#define PGM_GST_NAME(name) PGM_GST_NAME_32BIT(name)
154#define PGM_BTH_NAME(name) PGM_BTH_NAME_PAE_32BIT(name)
155#define BTH_PGMPOOLKIND_PT_FOR_PT PGMPOOLKIND_PAE_PT_FOR_32BIT_PT
156#define BTH_PGMPOOLKIND_PT_FOR_BIG PGMPOOLKIND_PAE_PT_FOR_32BIT_4MB
157#include "PGMAllBth.h"
158#undef BTH_PGMPOOLKIND_PT_FOR_BIG
159#undef BTH_PGMPOOLKIND_PT_FOR_PT
160#undef PGM_BTH_NAME
161#undef PGM_GST_TYPE
162#undef PGM_GST_NAME
163
164
165/* Guest - PAE mode */
166#define PGM_GST_TYPE PGM_TYPE_PAE
167#define PGM_GST_NAME(name) PGM_GST_NAME_PAE(name)
168#define PGM_BTH_NAME(name) PGM_BTH_NAME_PAE_PAE(name)
169#define BTH_PGMPOOLKIND_PT_FOR_PT PGMPOOLKIND_PAE_PT_FOR_PAE_PT
170#define BTH_PGMPOOLKIND_PT_FOR_BIG PGMPOOLKIND_PAE_PT_FOR_PAE_2MB
171#include "PGMAllGst.h"
172#include "PGMAllBth.h"
173#undef BTH_PGMPOOLKIND_PT_FOR_BIG
174#undef BTH_PGMPOOLKIND_PT_FOR_PT
175#undef PGM_BTH_NAME
176#undef PGM_GST_TYPE
177#undef PGM_GST_NAME
178
179#undef PGM_SHW_TYPE
180#undef PGM_SHW_NAME
181
182
183#ifndef IN_GC /* AMD64 implies VT-x/AMD-V */
184/*
185 * Shadow - AMD64 mode
186 */
187# define PGM_SHW_TYPE PGM_TYPE_AMD64
188# define PGM_SHW_NAME(name) PGM_SHW_NAME_AMD64(name)
189# include "PGMAllShw.h"
190
191/* Guest - protected mode */
192# define PGM_GST_TYPE PGM_TYPE_PROT
193# define PGM_GST_NAME(name) PGM_GST_NAME_PROT(name)
194# define PGM_BTH_NAME(name) PGM_BTH_NAME_AMD64_PROT(name)
195# define BTH_PGMPOOLKIND_PT_FOR_PT PGMPOOLKIND_PAE_PT_FOR_PHYS
196# include "PGMAllBth.h"
197# undef BTH_PGMPOOLKIND_PT_FOR_PT
198# undef PGM_BTH_NAME
199# undef PGM_GST_TYPE
200# undef PGM_GST_NAME
201
202# ifdef VBOX_WITH_64_BITS_GUESTS
203/* Guest - AMD64 mode */
204# define PGM_GST_TYPE PGM_TYPE_AMD64
205# define PGM_GST_NAME(name) PGM_GST_NAME_AMD64(name)
206# define PGM_BTH_NAME(name) PGM_BTH_NAME_AMD64_AMD64(name)
207# define BTH_PGMPOOLKIND_PT_FOR_PT PGMPOOLKIND_PAE_PT_FOR_PAE_PT
208# define BTH_PGMPOOLKIND_PT_FOR_BIG PGMPOOLKIND_PAE_PT_FOR_PAE_2MB
209# include "PGMAllGst.h"
210# include "PGMAllBth.h"
211# undef BTH_PGMPOOLKIND_PT_FOR_BIG
212# undef BTH_PGMPOOLKIND_PT_FOR_PT
213# undef PGM_BTH_NAME
214# undef PGM_GST_TYPE
215# undef PGM_GST_NAME
216# endif /* VBOX_WITH_64_BITS_GUESTS */
217
218# undef PGM_SHW_TYPE
219# undef PGM_SHW_NAME
220
221
222/*
223 * Shadow - Nested paging mode
224 */
225# define PGM_SHW_TYPE PGM_TYPE_NESTED
226# define PGM_SHW_NAME(name) PGM_SHW_NAME_NESTED(name)
227# include "PGMAllShw.h"
228
229/* Guest - real mode */
230# define PGM_GST_TYPE PGM_TYPE_REAL
231# define PGM_GST_NAME(name) PGM_GST_NAME_REAL(name)
232# define PGM_BTH_NAME(name) PGM_BTH_NAME_NESTED_REAL(name)
233# include "PGMAllBth.h"
234# undef PGM_BTH_NAME
235# undef PGM_GST_TYPE
236# undef PGM_GST_NAME
237
238/* Guest - protected mode */
239# define PGM_GST_TYPE PGM_TYPE_PROT
240# define PGM_GST_NAME(name) PGM_GST_NAME_PROT(name)
241# define PGM_BTH_NAME(name) PGM_BTH_NAME_NESTED_PROT(name)
242# include "PGMAllBth.h"
243# undef PGM_BTH_NAME
244# undef PGM_GST_TYPE
245# undef PGM_GST_NAME
246
247/* Guest - 32-bit mode */
248# define PGM_GST_TYPE PGM_TYPE_32BIT
249# define PGM_GST_NAME(name) PGM_GST_NAME_32BIT(name)
250# define PGM_BTH_NAME(name) PGM_BTH_NAME_NESTED_32BIT(name)
251# include "PGMAllBth.h"
252# undef PGM_BTH_NAME
253# undef PGM_GST_TYPE
254# undef PGM_GST_NAME
255
256/* Guest - PAE mode */
257# define PGM_GST_TYPE PGM_TYPE_PAE
258# define PGM_GST_NAME(name) PGM_GST_NAME_PAE(name)
259# define PGM_BTH_NAME(name) PGM_BTH_NAME_NESTED_PAE(name)
260# include "PGMAllBth.h"
261# undef PGM_BTH_NAME
262# undef PGM_GST_TYPE
263# undef PGM_GST_NAME
264
265# ifdef VBOX_WITH_64_BITS_GUESTS
266/* Guest - AMD64 mode */
267# define PGM_GST_TYPE PGM_TYPE_AMD64
268# define PGM_GST_NAME(name) PGM_GST_NAME_AMD64(name)
269# define PGM_BTH_NAME(name) PGM_BTH_NAME_NESTED_AMD64(name)
270# include "PGMAllBth.h"
271# undef PGM_BTH_NAME
272# undef PGM_GST_TYPE
273# undef PGM_GST_NAME
274# endif /* VBOX_WITH_64_BITS_GUESTS */
275
276# undef PGM_SHW_TYPE
277# undef PGM_SHW_NAME
278
279
280/*
281 * Shadow - EPT
282 */
283# define PGM_SHW_TYPE PGM_TYPE_EPT
284# define PGM_SHW_NAME(name) PGM_SHW_NAME_EPT(name)
285# include "PGMAllShw.h"
286
287/* Guest - real mode */
288# define PGM_GST_TYPE PGM_TYPE_REAL
289# define PGM_GST_NAME(name) PGM_GST_NAME_REAL(name)
290# define PGM_BTH_NAME(name) PGM_BTH_NAME_EPT_REAL(name)
291# define BTH_PGMPOOLKIND_PT_FOR_PT PGMPOOLKIND_EPT_PT_FOR_PHYS
292# include "PGMAllBth.h"
293# undef BTH_PGMPOOLKIND_PT_FOR_PT
294# undef PGM_BTH_NAME
295# undef PGM_GST_TYPE
296# undef PGM_GST_NAME
297
298/* Guest - protected mode */
299# define PGM_GST_TYPE PGM_TYPE_PROT
300# define PGM_GST_NAME(name) PGM_GST_NAME_PROT(name)
301# define PGM_BTH_NAME(name) PGM_BTH_NAME_EPT_PROT(name)
302# define BTH_PGMPOOLKIND_PT_FOR_PT PGMPOOLKIND_EPT_PT_FOR_PHYS
303# include "PGMAllBth.h"
304# undef BTH_PGMPOOLKIND_PT_FOR_PT
305# undef PGM_BTH_NAME
306# undef PGM_GST_TYPE
307# undef PGM_GST_NAME
308
309/* Guest - 32-bit mode */
310# define PGM_GST_TYPE PGM_TYPE_32BIT
311# define PGM_GST_NAME(name) PGM_GST_NAME_32BIT(name)
312# define PGM_BTH_NAME(name) PGM_BTH_NAME_EPT_32BIT(name)
313# define BTH_PGMPOOLKIND_PT_FOR_PT PGMPOOLKIND_EPT_PT_FOR_PHYS
314# include "PGMAllBth.h"
315# undef BTH_PGMPOOLKIND_PT_FOR_PT
316# undef PGM_BTH_NAME
317# undef PGM_GST_TYPE
318# undef PGM_GST_NAME
319
320/* Guest - PAE mode */
321# define PGM_GST_TYPE PGM_TYPE_PAE
322# define PGM_GST_NAME(name) PGM_GST_NAME_PAE(name)
323# define PGM_BTH_NAME(name) PGM_BTH_NAME_EPT_PAE(name)
324# define BTH_PGMPOOLKIND_PT_FOR_PT PGMPOOLKIND_EPT_PT_FOR_PHYS
325# include "PGMAllBth.h"
326# undef BTH_PGMPOOLKIND_PT_FOR_PT
327# undef PGM_BTH_NAME
328# undef PGM_GST_TYPE
329# undef PGM_GST_NAME
330
331# ifdef VBOX_WITH_64_BITS_GUESTS
332/* Guest - AMD64 mode */
333# define PGM_GST_TYPE PGM_TYPE_AMD64
334# define PGM_GST_NAME(name) PGM_GST_NAME_AMD64(name)
335# define PGM_BTH_NAME(name) PGM_BTH_NAME_EPT_AMD64(name)
336# define BTH_PGMPOOLKIND_PT_FOR_PT PGMPOOLKIND_EPT_PT_FOR_PHYS
337# include "PGMAllBth.h"
338# undef BTH_PGMPOOLKIND_PT_FOR_PT
339# undef PGM_BTH_NAME
340# undef PGM_GST_TYPE
341# undef PGM_GST_NAME
342# endif /* VBOX_WITH_64_BITS_GUESTS */
343
344# undef PGM_SHW_TYPE
345# undef PGM_SHW_NAME
346
347#endif /* !IN_GC */
348
349
350#ifndef IN_RING3
351/**
352 * #PF Handler.
353 *
354 * @returns VBox status code (appropriate for trap handling and GC return).
355 * @param pVM VM Handle.
356 * @param uErr The trap error code.
357 * @param pRegFrame Trap register frame.
358 * @param pvFault The fault address.
359 */
360VMMDECL(int) PGMTrap0eHandler(PVM pVM, RTGCUINT uErr, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault)
361{
362 LogFlow(("PGMTrap0eHandler: uErr=%RGu pvFault=%VGv eip=%VGv\n", uErr, pvFault, pRegFrame->rip));
363 STAM_PROFILE_START(&pVM->pgm.s.StatRZTrap0e, a);
364 STAM_STATS({ pVM->pgm.s.CTX_SUFF(pStatTrap0eAttribution) = NULL; } );
365
366
367#ifdef VBOX_WITH_STATISTICS
368 /*
369 * Error code stats.
370 */
371 if (uErr & X86_TRAP_PF_US)
372 {
373 if (!(uErr & X86_TRAP_PF_P))
374 {
375 if (uErr & X86_TRAP_PF_RW)
376 STAM_COUNTER_INC(&pVM->pgm.s.StatRZTrap0eUSNotPresentWrite);
377 else
378 STAM_COUNTER_INC(&pVM->pgm.s.StatRZTrap0eUSNotPresentRead);
379 }
380 else if (uErr & X86_TRAP_PF_RW)
381 STAM_COUNTER_INC(&pVM->pgm.s.StatRZTrap0eUSWrite);
382 else if (uErr & X86_TRAP_PF_RSVD)
383 STAM_COUNTER_INC(&pVM->pgm.s.StatRZTrap0eUSReserved);
384 else if (uErr & X86_TRAP_PF_ID)
385 STAM_COUNTER_INC(&pVM->pgm.s.StatRZTrap0eUSNXE);
386 else
387 STAM_COUNTER_INC(&pVM->pgm.s.StatRZTrap0eUSRead);
388 }
389 else
390 { /* Supervisor */
391 if (!(uErr & X86_TRAP_PF_P))
392 {
393 if (uErr & X86_TRAP_PF_RW)
394 STAM_COUNTER_INC(&pVM->pgm.s.StatRZTrap0eSVNotPresentWrite);
395 else
396 STAM_COUNTER_INC(&pVM->pgm.s.StatRZTrap0eSVNotPresentRead);
397 }
398 else if (uErr & X86_TRAP_PF_RW)
399 STAM_COUNTER_INC(&pVM->pgm.s.StatRZTrap0eSVWrite);
400 else if (uErr & X86_TRAP_PF_ID)
401 STAM_COUNTER_INC(&pVM->pgm.s.StatRZTrap0eSNXE);
402 else if (uErr & X86_TRAP_PF_RSVD)
403 STAM_COUNTER_INC(&pVM->pgm.s.StatRZTrap0eSVReserved);
404 }
405#endif /* VBOX_WITH_STATISTICS */
406
407 /*
408 * Call the worker.
409 */
410 int rc = PGM_BTH_PFN(Trap0eHandler, pVM)(pVM, uErr, pRegFrame, pvFault);
411 if (rc == VINF_PGM_SYNCPAGE_MODIFIED_PDE)
412 rc = VINF_SUCCESS;
413 STAM_STATS({ if (rc == VINF_EM_RAW_GUEST_TRAP) STAM_COUNTER_INC(&pVM->pgm.s.StatRZTrap0eGuestPF); });
414 STAM_STATS({ if (!pVM->pgm.s.CTX_SUFF(pStatTrap0eAttribution))
415 pVM->pgm.s.CTX_SUFF(pStatTrap0eAttribution) = &pVM->pgm.s.StatRZTrap0eTime2Misc; });
416 STAM_PROFILE_STOP_EX(&pVM->pgm.s.StatRZTrap0e, pVM->pgm.s.CTX_SUFF(pStatTrap0eAttribution), a);
417 return rc;
418}
419#endif /* !IN_RING3 */
420
421
422/**
423 * Prefetch a page
424 *
425 * Typically used to sync commonly used pages before entering raw mode
426 * after a CR3 reload.
427 *
428 * @returns VBox status code suitable for scheduling.
429 * @retval VINF_SUCCESS on success.
430 * @retval VINF_PGM_SYNC_CR3 if we're out of shadow pages or something like that.
431 * @param pVM VM handle.
432 * @param GCPtrPage Page to invalidate.
433 */
434VMMDECL(int) PGMPrefetchPage(PVM pVM, RTGCPTR GCPtrPage)
435{
436 STAM_PROFILE_START(&pVM->pgm.s.CTX_MID_Z(Stat,Prefetch), a);
437 int rc = PGM_BTH_PFN(PrefetchPage, pVM)(pVM, (RTGCUINTPTR)GCPtrPage);
438 STAM_PROFILE_STOP(&pVM->pgm.s.CTX_MID_Z(Stat,Prefetch), a);
439 AssertMsg(rc == VINF_SUCCESS || rc == VINF_PGM_SYNC_CR3 || VBOX_FAILURE(rc), ("rc=%Vrc\n", rc));
440 return rc;
441}
442
443
444/**
445 * Gets the mapping corresponding to the specified address (if any).
446 *
447 * @returns Pointer to the mapping.
448 * @returns NULL if not
449 *
450 * @param pVM The virtual machine.
451 * @param GCPtr The guest context pointer.
452 */
453PPGMMAPPING pgmGetMapping(PVM pVM, RTGCPTR GCPtr)
454{
455 PPGMMAPPING pMapping = pVM->pgm.s.CTX_SUFF(pMappings);
456 while (pMapping)
457 {
458 if ((uintptr_t)GCPtr < (uintptr_t)pMapping->GCPtr)
459 break;
460 if ((uintptr_t)GCPtr - (uintptr_t)pMapping->GCPtr < pMapping->cb)
461 return pMapping;
462 pMapping = pMapping->CTX_SUFF(pNext);
463 }
464 return NULL;
465}
466
467
468/**
469 * Verifies a range of pages for read or write access
470 *
471 * Only checks the guest's page tables
472 *
473 * @returns VBox status code.
474 * @param pVM VM handle.
475 * @param Addr Guest virtual address to check
476 * @param cbSize Access size
477 * @param fAccess Access type (r/w, user/supervisor (X86_PTE_*))
478 * @remarks Current not in use.
479 */
480VMMDECL(int) PGMIsValidAccess(PVM pVM, RTGCUINTPTR Addr, uint32_t cbSize, uint32_t fAccess)
481{
482 /*
483 * Validate input.
484 */
485 if (fAccess & ~(X86_PTE_US | X86_PTE_RW))
486 {
487 AssertMsgFailed(("PGMIsValidAccess: invalid access type %08x\n", fAccess));
488 return VERR_INVALID_PARAMETER;
489 }
490
491 uint64_t fPage;
492 int rc = PGMGstGetPage(pVM, (RTGCPTR)Addr, &fPage, NULL);
493 if (VBOX_FAILURE(rc))
494 {
495 Log(("PGMIsValidAccess: access violation for %VGv rc=%d\n", Addr, rc));
496 return VINF_EM_RAW_GUEST_TRAP;
497 }
498
499 /*
500 * Check if the access would cause a page fault
501 *
502 * Note that hypervisor page directories are not present in the guest's tables, so this check
503 * is sufficient.
504 */
505 bool fWrite = !!(fAccess & X86_PTE_RW);
506 bool fUser = !!(fAccess & X86_PTE_US);
507 if ( !(fPage & X86_PTE_P)
508 || (fWrite && !(fPage & X86_PTE_RW))
509 || (fUser && !(fPage & X86_PTE_US)) )
510 {
511 Log(("PGMIsValidAccess: access violation for %VGv attr %#llx vs %d:%d\n", Addr, fPage, fWrite, fUser));
512 return VINF_EM_RAW_GUEST_TRAP;
513 }
514 if ( VBOX_SUCCESS(rc)
515 && PAGE_ADDRESS(Addr) != PAGE_ADDRESS(Addr + cbSize))
516 return PGMIsValidAccess(pVM, Addr + PAGE_SIZE, (cbSize > PAGE_SIZE) ? cbSize - PAGE_SIZE : 1, fAccess);
517 return rc;
518}
519
520
521/**
522 * Verifies a range of pages for read or write access
523 *
524 * Supports handling of pages marked for dirty bit tracking and CSAM
525 *
526 * @returns VBox status code.
527 * @param pVM VM handle.
528 * @param Addr Guest virtual address to check
529 * @param cbSize Access size
530 * @param fAccess Access type (r/w, user/supervisor (X86_PTE_*))
531 */
532VMMDECL(int) PGMVerifyAccess(PVM pVM, RTGCUINTPTR Addr, uint32_t cbSize, uint32_t fAccess)
533{
534 AssertMsg(!(fAccess & ~(X86_PTE_US | X86_PTE_RW)), ("PGMVerifyAccess: invalid access type %08x\n", fAccess));
535
536 /*
537 * Get going.
538 */
539 uint64_t fPageGst;
540 int rc = PGMGstGetPage(pVM, (RTGCPTR)Addr, &fPageGst, NULL);
541 if (VBOX_FAILURE(rc))
542 {
543 Log(("PGMVerifyAccess: access violation for %VGv rc=%d\n", Addr, rc));
544 return VINF_EM_RAW_GUEST_TRAP;
545 }
546
547 /*
548 * Check if the access would cause a page fault
549 *
550 * Note that hypervisor page directories are not present in the guest's tables, so this check
551 * is sufficient.
552 */
553 const bool fWrite = !!(fAccess & X86_PTE_RW);
554 const bool fUser = !!(fAccess & X86_PTE_US);
555 if ( !(fPageGst & X86_PTE_P)
556 || (fWrite && !(fPageGst & X86_PTE_RW))
557 || (fUser && !(fPageGst & X86_PTE_US)) )
558 {
559 Log(("PGMVerifyAccess: access violation for %VGv attr %#llx vs %d:%d\n", Addr, fPageGst, fWrite, fUser));
560 return VINF_EM_RAW_GUEST_TRAP;
561 }
562
563 if (!HWACCMIsNestedPagingActive(pVM))
564 {
565 /*
566 * Next step is to verify if we protected this page for dirty bit tracking or for CSAM scanning
567 */
568 rc = PGMShwGetPage(pVM, (RTGCPTR)Addr, NULL, NULL);
569 if ( rc == VERR_PAGE_NOT_PRESENT
570 || rc == VERR_PAGE_TABLE_NOT_PRESENT)
571 {
572 /*
573 * Page is not present in our page tables.
574 * Try to sync it!
575 */
576 Assert(X86_TRAP_PF_RW == X86_PTE_RW && X86_TRAP_PF_US == X86_PTE_US);
577 uint32_t uErr = fAccess & (X86_TRAP_PF_RW | X86_TRAP_PF_US);
578 rc = PGM_BTH_PFN(VerifyAccessSyncPage, pVM)(pVM, Addr, fPageGst, uErr);
579 if (rc != VINF_SUCCESS)
580 return rc;
581 }
582 else
583 AssertMsg(rc == VINF_SUCCESS, ("PGMShwGetPage %VGv failed with %Vrc\n", Addr, rc));
584 }
585
586#if 0 /* def VBOX_STRICT; triggers too often now */
587 /*
588 * This check is a bit paranoid, but useful.
589 */
590 /** @note this will assert when writing to monitored pages (a bit annoying actually) */
591 uint64_t fPageShw;
592 rc = PGMShwGetPage(pVM, (RTGCPTR)Addr, &fPageShw, NULL);
593 if ( (rc == VERR_PAGE_NOT_PRESENT || VBOX_FAILURE(rc))
594 || (fWrite && !(fPageShw & X86_PTE_RW))
595 || (fUser && !(fPageShw & X86_PTE_US)) )
596 {
597 AssertMsgFailed(("Unexpected access violation for %VGv! rc=%Vrc write=%d user=%d\n",
598 Addr, rc, fWrite && !(fPageShw & X86_PTE_RW), fUser && !(fPageShw & X86_PTE_US)));
599 return VINF_EM_RAW_GUEST_TRAP;
600 }
601#endif
602
603 if ( VBOX_SUCCESS(rc)
604 && ( PAGE_ADDRESS(Addr) != PAGE_ADDRESS(Addr + cbSize - 1)
605 || Addr + cbSize < Addr))
606 {
607 /* Don't recursively call PGMVerifyAccess as we might run out of stack. */
608 for (;;)
609 {
610 Addr += PAGE_SIZE;
611 if (cbSize > PAGE_SIZE)
612 cbSize -= PAGE_SIZE;
613 else
614 cbSize = 1;
615 rc = PGMVerifyAccess(pVM, Addr, 1, fAccess);
616 if (rc != VINF_SUCCESS)
617 break;
618 if (PAGE_ADDRESS(Addr) == PAGE_ADDRESS(Addr + cbSize - 1))
619 break;
620 }
621 }
622 return rc;
623}
624
625
626/**
627 * Emulation of the invlpg instruction (HC only actually).
628 *
629 * @returns VBox status code, special care required.
630 * @retval VINF_PGM_SYNC_CR3 - handled.
631 * @retval VINF_EM_RAW_EMULATE_INSTR - not handled (RC only).
632 * @retval VERR_REM_FLUSHED_PAGES_OVERFLOW - not handled.
633 *
634 * @param pVM VM handle.
635 * @param GCPtrPage Page to invalidate.
636 *
637 * @remark ASSUMES the page table entry or page directory is valid. Fairly
638 * safe, but there could be edge cases!
639 *
640 * @todo Flush page or page directory only if necessary!
641 */
642VMMDECL(int) PGMInvalidatePage(PVM pVM, RTGCPTR GCPtrPage)
643{
644 int rc;
645 Log3(("PGMInvalidatePage: GCPtrPage=%VGv\n", GCPtrPage));
646
647#ifndef IN_RING3
648 /*
649 * Notify the recompiler so it can record this instruction.
650 * Failure happens when it's out of space. We'll return to HC in that case.
651 */
652 rc = REMNotifyInvalidatePage(pVM, GCPtrPage);
653 if (rc != VINF_SUCCESS)
654 return rc;
655#endif /* !IN_RING3 */
656
657
658#ifdef IN_GC
659 /*
660 * Check for conflicts and pending CR3 monitoring updates.
661 */
662 if (!pVM->pgm.s.fMappingsFixed)
663 {
664 if ( pgmGetMapping(pVM, GCPtrPage)
665 && PGMGstGetPage(pVM, GCPtrPage, NULL, NULL) != VERR_PAGE_TABLE_NOT_PRESENT)
666 {
667 LogFlow(("PGMGCInvalidatePage: Conflict!\n"));
668 VM_FF_SET(pVM, VM_FF_PGM_SYNC_CR3);
669 STAM_COUNTER_INC(&pVM->pgm.s.StatRCInvlPgConflict);
670 return VINF_PGM_SYNC_CR3;
671 }
672
673 if (pVM->pgm.s.fSyncFlags & PGM_SYNC_MONITOR_CR3)
674 {
675 LogFlow(("PGMGCInvalidatePage: PGM_SYNC_MONITOR_CR3 -> reinterpret instruction in R3\n"));
676 STAM_COUNTER_INC(&pVM->pgm.s.StatRCInvlPgSyncMonCR3);
677 return VINF_EM_RAW_EMULATE_INSTR;
678 }
679 }
680#endif /* IN_GC */
681
682 /*
683 * Call paging mode specific worker.
684 */
685 STAM_PROFILE_START(&pVM->pgm.s.CTX_MID_Z(Stat,InvalidatePage), a);
686 rc = PGM_BTH_PFN(InvalidatePage, pVM)(pVM, GCPtrPage);
687 STAM_PROFILE_STOP(&pVM->pgm.s.CTX_MID_Z(Stat,InvalidatePage), a);
688
689#ifdef IN_RING3
690 /*
691 * Check if we have a pending update of the CR3 monitoring.
692 */
693 if ( VBOX_SUCCESS(rc)
694 && (pVM->pgm.s.fSyncFlags & PGM_SYNC_MONITOR_CR3))
695 {
696 pVM->pgm.s.fSyncFlags &= ~PGM_SYNC_MONITOR_CR3;
697 Assert(!pVM->pgm.s.fMappingsFixed);
698 Assert(pVM->pgm.s.GCPhysCR3 == pVM->pgm.s.GCPhysGstCR3Monitored);
699 rc = PGM_GST_PFN(MonitorCR3, pVM)(pVM, pVM->pgm.s.GCPhysCR3);
700 }
701
702 /*
703 * Inform CSAM about the flush
704 *
705 * Note: This is to check if monitored pages have been changed; when we implement
706 * callbacks for virtual handlers, this is no longer required.
707 */
708 CSAMR3FlushPage(pVM, GCPtrPage);
709#endif /* IN_RING3 */
710 return rc;
711}
712
713
714/**
715 * Executes an instruction using the interpreter.
716 *
717 * @returns VBox status code (appropriate for trap handling and GC return).
718 * @param pVM VM handle.
719 * @param pRegFrame Register frame.
720 * @param pvFault Fault address.
721 */
722VMMDECL(int) PGMInterpretInstruction(PVM pVM, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault)
723{
724 uint32_t cb;
725 int rc = EMInterpretInstruction(pVM, pRegFrame, pvFault, &cb);
726 if (rc == VERR_EM_INTERPRETER)
727 rc = VINF_EM_RAW_EMULATE_INSTR;
728 if (rc != VINF_SUCCESS)
729 Log(("PGMInterpretInstruction: returns %Rrc (pvFault=%VGv)\n", rc, pvFault));
730 return rc;
731}
732
733
734/**
735 * Gets effective page information (from the VMM page directory).
736 *
737 * @returns VBox status.
738 * @param pVM VM Handle.
739 * @param GCPtr Guest Context virtual address of the page.
740 * @param pfFlags Where to store the flags. These are X86_PTE_*.
741 * @param pHCPhys Where to store the HC physical address of the page.
742 * This is page aligned.
743 * @remark You should use PGMMapGetPage() for pages in a mapping.
744 */
745VMMDECL(int) PGMShwGetPage(PVM pVM, RTGCPTR GCPtr, uint64_t *pfFlags, PRTHCPHYS pHCPhys)
746{
747 return PGM_SHW_PFN(GetPage,pVM)(pVM, (RTGCUINTPTR)GCPtr, pfFlags, pHCPhys);
748}
749
750
751/**
752 * Sets (replaces) the page flags for a range of pages in the shadow context.
753 *
754 * @returns VBox status.
755 * @param pVM VM handle.
756 * @param GCPtr The address of the first page.
757 * @param cb The size of the range in bytes.
758 * @param fFlags Page flags X86_PTE_*, excluding the page mask of course.
759 * @remark You must use PGMMapSetPage() for pages in a mapping.
760 */
761VMMDECL(int) PGMShwSetPage(PVM pVM, RTGCPTR GCPtr, size_t cb, uint64_t fFlags)
762{
763 return PGMShwModifyPage(pVM, GCPtr, cb, fFlags, 0);
764}
765
766
767/**
768 * Modify page flags for a range of pages in the shadow context.
769 *
770 * The existing flags are ANDed with the fMask and ORed with the fFlags.
771 *
772 * @returns VBox status code.
773 * @param pVM VM handle.
774 * @param GCPtr Virtual address of the first page in the range.
775 * @param cb Size (in bytes) of the range to apply the modification to.
776 * @param fFlags The OR mask - page flags X86_PTE_*, excluding the page mask of course.
777 * @param fMask The AND mask - page flags X86_PTE_*.
778 * Be very CAREFUL when ~'ing constants which could be 32-bit!
779 * @remark You must use PGMMapModifyPage() for pages in a mapping.
780 */
781VMMDECL(int) PGMShwModifyPage(PVM pVM, RTGCPTR GCPtr, size_t cb, uint64_t fFlags, uint64_t fMask)
782{
783 AssertMsg(!(fFlags & X86_PTE_PAE_PG_MASK), ("fFlags=%#llx\n", fFlags));
784 Assert(cb);
785
786 /*
787 * Align the input.
788 */
789 cb += (RTGCUINTPTR)GCPtr & PAGE_OFFSET_MASK;
790 cb = RT_ALIGN_Z(cb, PAGE_SIZE);
791 GCPtr = (RTGCPTR)((RTGCUINTPTR)GCPtr & PAGE_BASE_GC_MASK); /** @todo this ain't necessary, right... */
792
793 /*
794 * Call worker.
795 */
796 return PGM_SHW_PFN(ModifyPage, pVM)(pVM, (RTGCUINTPTR)GCPtr, cb, fFlags, fMask);
797}
798
799
800/**
801 * Syncs the SHADOW page directory pointer for the specified address.
802 *
803 * Allocates backing pages in case the PDPT entry is missing.
804 *
805 * @returns VBox status.
806 * @param pVM VM handle.
807 * @param GCPtr The address.
808 * @param pGstPdpe Guest PDPT entry
809 * @param ppPD Receives address of page directory
810 */
811VMMDECL(int) PGMShwSyncPAEPDPtr(PVM pVM, RTGCUINTPTR GCPtr, PX86PDPE pGstPdpe, PX86PDPAE *ppPD)
812{
813 PPGM pPGM = &pVM->pgm.s;
814 PPGMPOOL pPool = pPGM->CTX_SUFF(pPool);
815 PPGMPOOLPAGE pShwPage;
816 int rc;
817
818 Assert(!HWACCMIsNestedPagingActive(pVM));
819
820 const unsigned iPdPt = (GCPtr >> X86_PDPT_SHIFT) & X86_PDPT_MASK_PAE;
821 PX86PDPT pPdpt = pVM->pgm.s.CTXMID(p,PaePDPT);
822 PX86PDPE pPdpe = &pPdpt->a[iPdPt];
823
824 /* Allocate page directory if not present. */
825 if ( !pPdpe->n.u1Present
826 && !(pPdpe->u & X86_PDPE_PG_MASK))
827 {
828 PX86PDPE pPdptGst = &CTXSUFF(pPGM->pGstPaePDPT)->a[iPdPt];
829
830 Assert(!(pPdpe->u & X86_PDPE_PG_MASK));
831 /* Create a reference back to the PDPT by using the index in its shadow page. */
832 rc = pgmPoolAlloc(pVM, pPdptGst->u & X86_PDPE_PG_MASK, PGMPOOLKIND_PAE_PD_FOR_PAE_PD, PGMPOOL_IDX_PDPT, iPdPt, &pShwPage);
833 if (rc == VERR_PGM_POOL_FLUSHED)
834 {
835 Assert(pVM->pgm.s.fSyncFlags & PGM_SYNC_CLEAR_PGM_POOL);
836 VM_FF_SET(pVM, VM_FF_PGM_SYNC_CR3);
837 return VINF_PGM_SYNC_CR3;
838 }
839 AssertRCReturn(rc, rc);
840 }
841 else
842 {
843 pShwPage = pgmPoolGetPage(pPool, pPdpe->u & X86_PDPE_PG_MASK);
844 AssertReturn(pShwPage, VERR_INTERNAL_ERROR);
845 }
846 /* The PD was cached or created; hook it up now. */
847 pPdpe->u |= pShwPage->Core.Key
848 | (pGstPdpe->u & ~(X86_PDPE_PG_MASK | X86_PDPE_AVL_MASK | X86_PDPE_PCD | X86_PDPE_PWT));
849
850 *ppPD = (PX86PDPAE)PGMPOOL_PAGE_2_PTR(pVM, pShwPage);
851 return VINF_SUCCESS;
852}
853
854
855/**
856 * Gets the SHADOW page directory pointer for the specified address.
857 *
858 * @returns VBox status.
859 * @param pVM VM handle.
860 * @param GCPtr The address.
861 * @param ppPdpt Receives address of pdpt
862 * @param ppPD Receives address of page directory
863 */
864VMMDECL(int) PGMShwGetPAEPDPtr(PVM pVM, RTGCUINTPTR GCPtr, PX86PDPT *ppPdpt, PX86PDPAE *ppPD)
865{
866 PPGM pPGM = &pVM->pgm.s;
867 PPGMPOOL pPool = pPGM->CTX_SUFF(pPool);
868 PPGMPOOLPAGE pShwPage;
869
870 Assert(!HWACCMIsNestedPagingActive(pVM));
871
872 const unsigned iPdPt = (GCPtr >> X86_PDPT_SHIFT) & X86_PDPT_MASK_PAE;
873 PX86PDPT pPdpt = pVM->pgm.s.CTXMID(p,PaePDPT);
874 PX86PDPE pPdpe = &pPdpt->a[iPdPt];
875
876 *ppPdpt = pPdpt;
877 if (!pPdpe->n.u1Present)
878 return VERR_PAGE_DIRECTORY_PTR_NOT_PRESENT;
879
880 pShwPage = pgmPoolGetPage(pPool, pPdpe->u & X86_PDPE_PG_MASK);
881 AssertReturn(pShwPage, VERR_INTERNAL_ERROR);
882
883 *ppPD = (PX86PDPAE)PGMPOOL_PAGE_2_PTR(pVM, pShwPage);
884 return VINF_SUCCESS;
885}
886
887#ifndef IN_GC
888
889/**
890 * Syncs the SHADOW page directory pointer for the specified address. Allocates
891 * backing pages in case the PDPT or PML4 entry is missing.
892 *
893 * @returns VBox status.
894 * @param pVM VM handle.
895 * @param GCPtr The address.
896 * @param pGstPml4e Guest PML4 entry
897 * @param pGstPdpe Guest PDPT entry
898 * @param ppPD Receives address of page directory
899 */
900VMMDECL(int) PGMShwSyncLongModePDPtr(PVM pVM, RTGCUINTPTR64 GCPtr, PX86PML4E pGstPml4e, PX86PDPE pGstPdpe, PX86PDPAE *ppPD)
901{
902 PPGM pPGM = &pVM->pgm.s;
903 const unsigned iPml4e = (GCPtr >> X86_PML4_SHIFT) & X86_PML4_MASK;
904 PPGMPOOL pPool = pPGM->CTX_SUFF(pPool);
905 PX86PML4E pPml4e;
906 PPGMPOOLPAGE pShwPage;
907 int rc;
908 bool fNestedPaging = HWACCMIsNestedPagingActive(pVM);
909
910 Assert(pVM->pgm.s.pHCPaePML4);
911
912 /* Allocate page directory pointer table if not present. */
913 pPml4e = &pPGM->pHCPaePML4->a[iPml4e];
914 if ( !pPml4e->n.u1Present
915 && !(pPml4e->u & X86_PML4E_PG_MASK))
916 {
917 Assert(!(pPml4e->u & X86_PML4E_PG_MASK));
918
919 if (!fNestedPaging)
920 {
921 Assert(pVM->pgm.s.pHCShwAmd64CR3);
922 Assert(pPGM->pGstPaePML4HC);
923
924 PX86PML4E pPml4eGst = &pPGM->pGstPaePML4HC->a[iPml4e];
925
926 rc = pgmPoolAlloc(pVM, pPml4eGst->u & X86_PML4E_PG_MASK,
927 PGMPOOLKIND_64BIT_PDPT_FOR_64BIT_PDPT, pVM->pgm.s.pHCShwAmd64CR3->idx, iPml4e, &pShwPage);
928 }
929 else
930 rc = pgmPoolAlloc(pVM, GCPtr + RT_BIT_64(63) /* hack: make the address unique */,
931 PGMPOOLKIND_64BIT_PDPT_FOR_PHYS, PGMPOOL_IDX_NESTED_ROOT, iPml4e, &pShwPage);
932
933 if (rc == VERR_PGM_POOL_FLUSHED)
934 {
935 Log(("PGMShwSyncLongModePDPtr: PGM pool flushed (1) -> signal sync cr3\n"));
936 Assert(pVM->pgm.s.fSyncFlags & PGM_SYNC_CLEAR_PGM_POOL);
937 VM_FF_SET(pVM, VM_FF_PGM_SYNC_CR3);
938 return VINF_PGM_SYNC_CR3;
939 }
940 AssertRCReturn(rc, rc);
941 }
942 else
943 {
944 pShwPage = pgmPoolGetPage(pPool, pPml4e->u & X86_PML4E_PG_MASK);
945 AssertReturn(pShwPage, VERR_INTERNAL_ERROR);
946 }
947 /* The PDPT was cached or created; hook it up now. */
948 pPml4e->u |= pShwPage->Core.Key
949 | (pGstPml4e->u & ~(X86_PML4E_PG_MASK | X86_PML4E_AVL_MASK | X86_PML4E_PCD | X86_PML4E_PWT));
950
951 const unsigned iPdPt = (GCPtr >> X86_PDPT_SHIFT) & X86_PDPT_MASK_AMD64;
952 PX86PDPT pPdpt = (PX86PDPT)PGMPOOL_PAGE_2_PTR(pVM, pShwPage);
953 PX86PDPE pPdpe = &pPdpt->a[iPdPt];
954
955 /* Allocate page directory if not present. */
956 if ( !pPdpe->n.u1Present
957 && !(pPdpe->u & X86_PDPE_PG_MASK))
958 {
959 if (!fNestedPaging)
960 {
961 Assert(pPGM->pGstPaePML4HC);
962
963 PX86PML4E pPml4eGst = &pPGM->pGstPaePML4HC->a[iPml4e];
964 PX86PDPT pPdptGst;
965 rc = PGM_GCPHYS_2_PTR(pVM, pPml4eGst->u & X86_PML4E_PG_MASK, &pPdptGst);
966 AssertRCReturn(rc, rc);
967
968 Assert(!(pPdpe->u & X86_PDPE_PG_MASK));
969 /* Create a reference back to the PDPT by using the index in its shadow page. */
970 rc = pgmPoolAlloc(pVM, pPdptGst->a[iPdPt].u & X86_PDPE_PG_MASK, PGMPOOLKIND_64BIT_PD_FOR_64BIT_PD, pShwPage->idx, iPdPt, &pShwPage);
971 }
972 else
973 rc = pgmPoolAlloc(pVM, GCPtr + RT_BIT_64(62) /* hack: make the address unique */, PGMPOOLKIND_64BIT_PD_FOR_PHYS, pShwPage->idx, iPdPt, &pShwPage);
974
975 if (rc == VERR_PGM_POOL_FLUSHED)
976 {
977 Log(("PGMShwSyncLongModePDPtr: PGM pool flushed (2) -> signal sync cr3\n"));
978 Assert(pVM->pgm.s.fSyncFlags & PGM_SYNC_CLEAR_PGM_POOL);
979 VM_FF_SET(pVM, VM_FF_PGM_SYNC_CR3);
980 return VINF_PGM_SYNC_CR3;
981 }
982 AssertRCReturn(rc, rc);
983 }
984 else
985 {
986 pShwPage = pgmPoolGetPage(pPool, pPdpe->u & X86_PDPE_PG_MASK);
987 AssertReturn(pShwPage, VERR_INTERNAL_ERROR);
988 }
989 /* The PD was cached or created; hook it up now. */
990 pPdpe->u |= pShwPage->Core.Key
991 | (pGstPdpe->u & ~(X86_PDPE_PG_MASK | X86_PDPE_AVL_MASK | X86_PDPE_PCD | X86_PDPE_PWT));
992
993 *ppPD = (PX86PDPAE)PGMPOOL_PAGE_2_PTR(pVM, pShwPage);
994 return VINF_SUCCESS;
995}
996
997
998/**
999 * Gets the SHADOW page directory pointer for the specified address.
1000 *
1001 * @returns VBox status.
1002 * @param pVM VM handle.
1003 * @param GCPtr The address.
1004 * @param ppPdpt Receives address of pdpt
1005 * @param ppPD Receives address of page directory
1006 */
1007VMMDECL(int) PGMShwGetLongModePDPtr(PVM pVM, RTGCUINTPTR64 GCPtr, PX86PDPT *ppPdpt, PX86PDPAE *ppPD)
1008{
1009 PPGM pPGM = &pVM->pgm.s;
1010 const unsigned iPml4e = (GCPtr >> X86_PML4_SHIFT) & X86_PML4_MASK;
1011 PPGMPOOL pPool = pPGM->CTX_SUFF(pPool);
1012 PX86PML4E pPml4e;
1013 PPGMPOOLPAGE pShwPage;
1014
1015 AssertReturn(pVM->pgm.s.pHCPaePML4, VERR_INTERNAL_ERROR);
1016
1017 pPml4e = &pPGM->pHCPaePML4->a[iPml4e];
1018 if (!pPml4e->n.u1Present)
1019 return VERR_PAGE_MAP_LEVEL4_NOT_PRESENT;
1020
1021 pShwPage = pgmPoolGetPage(pPool, pPml4e->u & X86_PML4E_PG_MASK);
1022 AssertReturn(pShwPage, VERR_INTERNAL_ERROR);
1023
1024 const unsigned iPdPt = (GCPtr >> X86_PDPT_SHIFT) & X86_PDPT_MASK_AMD64;
1025 PX86PDPT pPdpt = (PX86PDPT)PGMPOOL_PAGE_2_PTR(pVM, pShwPage);
1026 PX86PDPE pPdpe = &pPdpt->a[iPdPt];
1027
1028 *ppPdpt = pPdpt;
1029 if (!pPdpe->n.u1Present)
1030 return VERR_PAGE_DIRECTORY_PTR_NOT_PRESENT;
1031
1032 pShwPage = pgmPoolGetPage(pPool, pPdpe->u & X86_PDPE_PG_MASK);
1033 AssertReturn(pShwPage, VERR_INTERNAL_ERROR);
1034
1035 *ppPD = (PX86PDPAE)PGMPOOL_PAGE_2_PTR(pVM, pShwPage);
1036 return VINF_SUCCESS;
1037}
1038
1039
1040/**
1041 * Syncs the SHADOW EPT page directory pointer for the specified address. Allocates
1042 * backing pages in case the PDPT or PML4 entry is missing.
1043 *
1044 * @returns VBox status.
1045 * @param pVM VM handle.
1046 * @param GCPtr The address.
1047 * @param ppPdpt Receives address of pdpt
1048 * @param ppPD Receives address of page directory
1049 */
1050VMMDECL(int) PGMShwGetEPTPDPtr(PVM pVM, RTGCUINTPTR64 GCPtr, PEPTPDPT *ppPdpt, PEPTPD *ppPD)
1051{
1052 PPGM pPGM = &pVM->pgm.s;
1053 const unsigned iPml4e = (GCPtr >> EPT_PML4_SHIFT) & EPT_PML4_MASK;
1054 PPGMPOOL pPool = pPGM->CTX_SUFF(pPool);
1055 PEPTPML4 pPml4 = (PEPTPML4)pPGM->pHCNestedRoot;
1056 PEPTPML4E pPml4e;
1057 PPGMPOOLPAGE pShwPage;
1058 int rc;
1059
1060 Assert(HWACCMIsNestedPagingActive(pVM));
1061 Assert(pPml4);
1062
1063 /* Allocate page directory pointer table if not present. */
1064 pPml4e = &pPml4->a[iPml4e];
1065 if ( !pPml4e->n.u1Present
1066 && !(pPml4e->u & EPT_PML4E_PG_MASK))
1067 {
1068 Assert(!(pPml4e->u & EPT_PML4E_PG_MASK));
1069
1070 rc = pgmPoolAlloc(pVM, (GCPtr & EPT_PML4E_PG_MASK) + RT_BIT_64(63) /* hack: make the address unique */, PGMPOOLKIND_EPT_PDPT_FOR_PHYS, PGMPOOL_IDX_NESTED_ROOT, iPml4e, &pShwPage);
1071 if (rc == VERR_PGM_POOL_FLUSHED)
1072 {
1073 Log(("PGMShwSyncEPTPDPtr: PGM pool flushed (1) -> signal sync cr3\n"));
1074 Assert(pVM->pgm.s.fSyncFlags & PGM_SYNC_CLEAR_PGM_POOL);
1075 VM_FF_SET(pVM, VM_FF_PGM_SYNC_CR3);
1076 return VINF_PGM_SYNC_CR3;
1077 }
1078 AssertRCReturn(rc, rc);
1079 }
1080 else
1081 {
1082 pShwPage = pgmPoolGetPage(pPool, pPml4e->u & EPT_PML4E_PG_MASK);
1083 AssertReturn(pShwPage, VERR_INTERNAL_ERROR);
1084 }
1085 /* The PDPT was cached or created; hook it up now and fill with the default value. */
1086 pPml4e->u = pShwPage->Core.Key;
1087 pPml4e->n.u1Present = 1;
1088 pPml4e->n.u1Write = 1;
1089 pPml4e->n.u1Execute = 1;
1090
1091 const unsigned iPdPt = (GCPtr >> EPT_PDPT_SHIFT) & EPT_PDPT_MASK;
1092 PEPTPDPT pPdpt = (PEPTPDPT)PGMPOOL_PAGE_2_PTR(pVM, pShwPage);
1093 PEPTPDPTE pPdpe = &pPdpt->a[iPdPt];
1094
1095 if (ppPdpt)
1096 *ppPdpt = pPdpt;
1097
1098 /* Allocate page directory if not present. */
1099 if ( !pPdpe->n.u1Present
1100 && !(pPdpe->u & EPT_PDPTE_PG_MASK))
1101 {
1102 rc = pgmPoolAlloc(pVM, (GCPtr & EPT_PDPTE_PG_MASK) + RT_BIT_64(62) /* hack: make the address unique */, PGMPOOLKIND_64BIT_PD_FOR_PHYS, pShwPage->idx, iPdPt, &pShwPage);
1103 if (rc == VERR_PGM_POOL_FLUSHED)
1104 {
1105 Log(("PGMShwSyncEPTPDPtr: PGM pool flushed (2) -> signal sync cr3\n"));
1106 Assert(pVM->pgm.s.fSyncFlags & PGM_SYNC_CLEAR_PGM_POOL);
1107 VM_FF_SET(pVM, VM_FF_PGM_SYNC_CR3);
1108 return VINF_PGM_SYNC_CR3;
1109 }
1110 AssertRCReturn(rc, rc);
1111 }
1112 else
1113 {
1114 pShwPage = pgmPoolGetPage(pPool, pPdpe->u & EPT_PDPTE_PG_MASK);
1115 AssertReturn(pShwPage, VERR_INTERNAL_ERROR);
1116 }
1117 /* The PD was cached or created; hook it up now and fill with the default value. */
1118 pPdpe->u = pShwPage->Core.Key;
1119 pPdpe->n.u1Present = 1;
1120 pPdpe->n.u1Write = 1;
1121 pPdpe->n.u1Execute = 1;
1122
1123 *ppPD = (PEPTPD)PGMPOOL_PAGE_2_PTR(pVM, pShwPage);
1124 return VINF_SUCCESS;
1125}
1126
1127#endif /* IN_GC */
1128
1129/**
1130 * Gets effective Guest OS page information.
1131 *
1132 * When GCPtr is in a big page, the function will return as if it was a normal
1133 * 4KB page. If the need for distinguishing between big and normal page becomes
1134 * necessary at a later point, a PGMGstGetPage() will be created for that
1135 * purpose.
1136 *
1137 * @returns VBox status.
1138 * @param pVM VM Handle.
1139 * @param GCPtr Guest Context virtual address of the page.
1140 * @param pfFlags Where to store the flags. These are X86_PTE_*, even for big pages.
1141 * @param pGCPhys Where to store the GC physical address of the page.
1142 * This is page aligned. The fact that the
1143 */
1144VMMDECL(int) PGMGstGetPage(PVM pVM, RTGCPTR GCPtr, uint64_t *pfFlags, PRTGCPHYS pGCPhys)
1145{
1146 return PGM_GST_PFN(GetPage,pVM)(pVM, (RTGCUINTPTR)GCPtr, pfFlags, pGCPhys);
1147}
1148
1149
1150/**
1151 * Checks if the page is present.
1152 *
1153 * @returns true if the page is present.
1154 * @returns false if the page is not present.
1155 * @param pVM The VM handle.
1156 * @param GCPtr Address within the page.
1157 */
1158VMMDECL(bool) PGMGstIsPagePresent(PVM pVM, RTGCPTR GCPtr)
1159{
1160 int rc = PGMGstGetPage(pVM, GCPtr, NULL, NULL);
1161 return VBOX_SUCCESS(rc);
1162}
1163
1164
1165/**
1166 * Sets (replaces) the page flags for a range of pages in the guest's tables.
1167 *
1168 * @returns VBox status.
1169 * @param pVM VM handle.
1170 * @param GCPtr The address of the first page.
1171 * @param cb The size of the range in bytes.
1172 * @param fFlags Page flags X86_PTE_*, excluding the page mask of course.
1173 */
1174VMMDECL(int) PGMGstSetPage(PVM pVM, RTGCPTR GCPtr, size_t cb, uint64_t fFlags)
1175{
1176 return PGMGstModifyPage(pVM, GCPtr, cb, fFlags, 0);
1177}
1178
1179
1180/**
1181 * Modify page flags for a range of pages in the guest's tables
1182 *
1183 * The existing flags are ANDed with the fMask and ORed with the fFlags.
1184 *
1185 * @returns VBox status code.
1186 * @param pVM VM handle.
1187 * @param GCPtr Virtual address of the first page in the range.
1188 * @param cb Size (in bytes) of the range to apply the modification to.
1189 * @param fFlags The OR mask - page flags X86_PTE_*, excluding the page mask of course.
1190 * @param fMask The AND mask - page flags X86_PTE_*, excluding the page mask of course.
1191 * Be very CAREFUL when ~'ing constants which could be 32-bit!
1192 */
1193VMMDECL(int) PGMGstModifyPage(PVM pVM, RTGCPTR GCPtr, size_t cb, uint64_t fFlags, uint64_t fMask)
1194{
1195 STAM_PROFILE_START(&pVM->pgm.s.CTX_MID_Z(Stat,GstModifyPage), a);
1196
1197 /*
1198 * Validate input.
1199 */
1200 AssertMsg(!(fFlags & X86_PTE_PAE_PG_MASK), ("fFlags=%#llx\n", fFlags));
1201 Assert(cb);
1202
1203 LogFlow(("PGMGstModifyPage %VGv %d bytes fFlags=%08llx fMask=%08llx\n", GCPtr, cb, fFlags, fMask));
1204
1205 /*
1206 * Adjust input.
1207 */
1208 cb += (RTGCUINTPTR)GCPtr & PAGE_OFFSET_MASK;
1209 cb = RT_ALIGN_Z(cb, PAGE_SIZE);
1210 GCPtr = (RTGCPTR)((RTGCUINTPTR)GCPtr & PAGE_BASE_GC_MASK);
1211
1212 /*
1213 * Call worker.
1214 */
1215 int rc = PGM_GST_PFN(ModifyPage, pVM)(pVM, (RTGCUINTPTR)GCPtr, cb, fFlags, fMask);
1216
1217 STAM_PROFILE_STOP(&pVM->pgm.s.CTX_MID_Z(Stat,GstModifyPage), a);
1218 return rc;
1219}
1220
1221
1222/**
1223 * Gets the specified page directory pointer table entry.
1224 *
1225 * @returns PDP entry
1226 * @param pPGM Pointer to the PGM instance data.
1227 * @param iPdpt PDPT index
1228 */
1229VMMDECL(X86PDPE) PGMGstGetPaePDPtr(PVM pVM, unsigned iPdpt)
1230{
1231 Assert(iPdpt <= 3);
1232 return pVM->pgm.s.CTXSUFF(pGstPaePDPT)->a[iPdpt & 3];
1233}
1234
1235
1236/**
1237 * Gets the current CR3 register value for the shadow memory context.
1238 * @returns CR3 value.
1239 * @param pVM The VM handle.
1240 */
1241VMMDECL(RTHCPHYS) PGMGetHyperCR3(PVM pVM)
1242{
1243 PGMMODE enmShadowMode = pVM->pgm.s.enmShadowMode;
1244 switch (enmShadowMode)
1245 {
1246 case PGMMODE_32_BIT:
1247 return pVM->pgm.s.HCPhys32BitPD;
1248
1249 case PGMMODE_PAE:
1250 case PGMMODE_PAE_NX:
1251 return pVM->pgm.s.HCPhysPaePDPT;
1252
1253 case PGMMODE_AMD64:
1254 case PGMMODE_AMD64_NX:
1255 return pVM->pgm.s.HCPhysPaePML4;
1256
1257 case PGMMODE_EPT:
1258 return pVM->pgm.s.HCPhysNestedRoot;
1259
1260 case PGMMODE_NESTED:
1261 return PGMGetNestedCR3(pVM, PGMGetHostMode(pVM));
1262
1263 default:
1264 AssertMsgFailed(("enmShadowMode=%d\n", enmShadowMode));
1265 return ~0;
1266 }
1267}
1268
1269
1270/**
1271 * Gets the current CR3 register value for the nested memory context.
1272 * @returns CR3 value.
1273 * @param pVM The VM handle.
1274 */
1275VMMDECL(RTHCPHYS) PGMGetNestedCR3(PVM pVM, PGMMODE enmShadowMode)
1276{
1277 switch (enmShadowMode)
1278 {
1279 case PGMMODE_32_BIT:
1280 return pVM->pgm.s.HCPhys32BitPD;
1281
1282 case PGMMODE_PAE:
1283 case PGMMODE_PAE_NX:
1284 return pVM->pgm.s.HCPhysPaePDPT;
1285
1286 case PGMMODE_AMD64:
1287 case PGMMODE_AMD64_NX:
1288 return pVM->pgm.s.HCPhysPaePML4;
1289
1290 default:
1291 AssertMsgFailed(("enmShadowMode=%d\n", enmShadowMode));
1292 return ~0;
1293 }
1294}
1295
1296
1297/**
1298 * Gets the current CR3 register value for the EPT paging memory context.
1299 * @returns CR3 value.
1300 * @param pVM The VM handle.
1301 */
1302VMMDECL(RTHCPHYS) PGMGetEPTCR3(PVM pVM)
1303{
1304 return pVM->pgm.s.HCPhysNestedRoot;
1305}
1306
1307
1308/**
1309 * Gets the CR3 register value for the 32-Bit shadow memory context.
1310 * @returns CR3 value.
1311 * @param pVM The VM handle.
1312 */
1313VMMDECL(RTHCPHYS) PGMGetHyper32BitCR3(PVM pVM)
1314{
1315 return pVM->pgm.s.HCPhys32BitPD;
1316}
1317
1318
1319/**
1320 * Gets the CR3 register value for the PAE shadow memory context.
1321 * @returns CR3 value.
1322 * @param pVM The VM handle.
1323 */
1324VMMDECL(RTHCPHYS) PGMGetHyperPaeCR3(PVM pVM)
1325{
1326 return pVM->pgm.s.HCPhysPaePDPT;
1327}
1328
1329
1330/**
1331 * Gets the CR3 register value for the AMD64 shadow memory context.
1332 * @returns CR3 value.
1333 * @param pVM The VM handle.
1334 */
1335VMMDECL(RTHCPHYS) PGMGetHyperAmd64CR3(PVM pVM)
1336{
1337 return pVM->pgm.s.HCPhysPaePML4;
1338}
1339
1340
1341/**
1342 * Gets the current CR3 register value for the HC intermediate memory context.
1343 * @returns CR3 value.
1344 * @param pVM The VM handle.
1345 */
1346VMMDECL(RTHCPHYS) PGMGetInterHCCR3(PVM pVM)
1347{
1348 switch (pVM->pgm.s.enmHostMode)
1349 {
1350 case SUPPAGINGMODE_32_BIT:
1351 case SUPPAGINGMODE_32_BIT_GLOBAL:
1352 return pVM->pgm.s.HCPhysInterPD;
1353
1354 case SUPPAGINGMODE_PAE:
1355 case SUPPAGINGMODE_PAE_GLOBAL:
1356 case SUPPAGINGMODE_PAE_NX:
1357 case SUPPAGINGMODE_PAE_GLOBAL_NX:
1358 return pVM->pgm.s.HCPhysInterPaePDPT;
1359
1360 case SUPPAGINGMODE_AMD64:
1361 case SUPPAGINGMODE_AMD64_GLOBAL:
1362 case SUPPAGINGMODE_AMD64_NX:
1363 case SUPPAGINGMODE_AMD64_GLOBAL_NX:
1364 return pVM->pgm.s.HCPhysInterPaePDPT;
1365
1366 default:
1367 AssertMsgFailed(("enmHostMode=%d\n", pVM->pgm.s.enmHostMode));
1368 return ~0;
1369 }
1370}
1371
1372
1373/**
1374 * Gets the current CR3 register value for the RC intermediate memory context.
1375 * @returns CR3 value.
1376 * @param pVM The VM handle.
1377 */
1378VMMDECL(RTHCPHYS) PGMGetInterRCCR3(PVM pVM)
1379{
1380 switch (pVM->pgm.s.enmShadowMode)
1381 {
1382 case PGMMODE_32_BIT:
1383 return pVM->pgm.s.HCPhysInterPD;
1384
1385 case PGMMODE_PAE:
1386 case PGMMODE_PAE_NX:
1387 return pVM->pgm.s.HCPhysInterPaePDPT;
1388
1389 case PGMMODE_AMD64:
1390 case PGMMODE_AMD64_NX:
1391 return pVM->pgm.s.HCPhysInterPaePML4;
1392
1393 case PGMMODE_EPT:
1394 case PGMMODE_NESTED:
1395 return 0; /* not relevant */
1396
1397 default:
1398 AssertMsgFailed(("enmShadowMode=%d\n", pVM->pgm.s.enmShadowMode));
1399 return ~0;
1400 }
1401}
1402
1403
1404/**
1405 * Gets the CR3 register value for the 32-Bit intermediate memory context.
1406 * @returns CR3 value.
1407 * @param pVM The VM handle.
1408 */
1409VMMDECL(RTHCPHYS) PGMGetInter32BitCR3(PVM pVM)
1410{
1411 return pVM->pgm.s.HCPhysInterPD;
1412}
1413
1414
1415/**
1416 * Gets the CR3 register value for the PAE intermediate memory context.
1417 * @returns CR3 value.
1418 * @param pVM The VM handle.
1419 */
1420VMMDECL(RTHCPHYS) PGMGetInterPaeCR3(PVM pVM)
1421{
1422 return pVM->pgm.s.HCPhysInterPaePDPT;
1423}
1424
1425
1426/**
1427 * Gets the CR3 register value for the AMD64 intermediate memory context.
1428 * @returns CR3 value.
1429 * @param pVM The VM handle.
1430 */
1431VMMDECL(RTHCPHYS) PGMGetInterAmd64CR3(PVM pVM)
1432{
1433 return pVM->pgm.s.HCPhysInterPaePML4;
1434}
1435
1436
1437/**
1438 * Performs and schedules necessary updates following a CR3 load or reload.
1439 *
1440 * This will normally involve mapping the guest PD or nPDPT
1441 *
1442 * @returns VBox status code.
1443 * @retval VINF_PGM_SYNC_CR3 if monitoring requires a CR3 sync. This can
1444 * safely be ignored and overridden since the FF will be set too then.
1445 * @param pVM VM handle.
1446 * @param cr3 The new cr3.
1447 * @param fGlobal Indicates whether this is a global flush or not.
1448 */
1449VMMDECL(int) PGMFlushTLB(PVM pVM, uint64_t cr3, bool fGlobal)
1450{
1451 STAM_PROFILE_START(&pVM->pgm.s.CTX_MID_Z(Stat,FlushTLB), a);
1452
1453 /*
1454 * Always flag the necessary updates; necessary for hardware acceleration
1455 */
1456 VM_FF_SET(pVM, VM_FF_PGM_SYNC_CR3_NON_GLOBAL);
1457 if (fGlobal)
1458 VM_FF_SET(pVM, VM_FF_PGM_SYNC_CR3);
1459 LogFlow(("PGMFlushTLB: cr3=%VX64 OldCr3=%VX64 fGlobal=%d\n", cr3, pVM->pgm.s.GCPhysCR3, fGlobal));
1460
1461 /*
1462 * Remap the CR3 content and adjust the monitoring if CR3 was actually changed.
1463 */
1464 int rc = VINF_SUCCESS;
1465 RTGCPHYS GCPhysCR3;
1466 if ( pVM->pgm.s.enmGuestMode == PGMMODE_PAE
1467 || pVM->pgm.s.enmGuestMode == PGMMODE_PAE_NX
1468 || pVM->pgm.s.enmGuestMode == PGMMODE_AMD64
1469 || pVM->pgm.s.enmGuestMode == PGMMODE_AMD64_NX)
1470 GCPhysCR3 = (RTGCPHYS)(cr3 & X86_CR3_PAE_PAGE_MASK);
1471 else
1472 GCPhysCR3 = (RTGCPHYS)(cr3 & X86_CR3_PAGE_MASK);
1473 if (pVM->pgm.s.GCPhysCR3 != GCPhysCR3)
1474 {
1475 pVM->pgm.s.GCPhysCR3 = GCPhysCR3;
1476 rc = PGM_GST_PFN(MapCR3, pVM)(pVM, GCPhysCR3);
1477 if (VBOX_SUCCESS(rc) && !pVM->pgm.s.fMappingsFixed)
1478 {
1479 pVM->pgm.s.fSyncFlags &= ~PGM_SYNC_MONITOR_CR3;
1480 rc = PGM_GST_PFN(MonitorCR3, pVM)(pVM, GCPhysCR3);
1481 }
1482 if (fGlobal)
1483 STAM_COUNTER_INC(&pVM->pgm.s.CTX_MID_Z(Stat,FlushTLBNewCR3Global));
1484 else
1485 STAM_COUNTER_INC(&pVM->pgm.s.CTX_MID_Z(Stat,FlushTLBNewCR3));
1486 }
1487 else
1488 {
1489 /*
1490 * Check if we have a pending update of the CR3 monitoring.
1491 */
1492 if (pVM->pgm.s.fSyncFlags & PGM_SYNC_MONITOR_CR3)
1493 {
1494 pVM->pgm.s.fSyncFlags &= ~PGM_SYNC_MONITOR_CR3;
1495 Assert(!pVM->pgm.s.fMappingsFixed);
1496 rc = PGM_GST_PFN(MonitorCR3, pVM)(pVM, GCPhysCR3);
1497 }
1498 if (fGlobal)
1499 STAM_COUNTER_INC(&pVM->pgm.s.CTX_MID_Z(Stat,FlushTLBSameCR3Global));
1500 else
1501 STAM_COUNTER_INC(&pVM->pgm.s.CTX_MID_Z(Stat,FlushTLBSameCR3));
1502 }
1503
1504 STAM_PROFILE_STOP(&pVM->pgm.s.CTX_MID_Z(Stat,FlushTLB), a);
1505 return rc;
1506}
1507
1508
1509/**
1510 * Performs and schedules necessary updates following a CR3 load or reload when
1511 * using nested or extended paging.
1512 *
1513 * This API is an alterantive to PDMFlushTLB that avoids actually flushing the
1514 * TLB and triggering a SyncCR3.
1515 *
1516 * This will normally involve mapping the guest PD or nPDPT
1517 *
1518 * @returns VBox status code.
1519 * @retval VINF_PGM_SYNC_CR3 if monitoring requires a CR3 sync. This can
1520 * safely be ignored and overridden since the FF will be set too then.
1521 * @param pVM VM handle.
1522 * @param cr3 The new cr3.
1523 */
1524VMMDECL(int) PGMUpdateCR3(PVM pVM, uint64_t cr3)
1525{
1526 LogFlow(("PGMUpdateCR3: cr3=%VX64 OldCr3=%VX64\n", cr3, pVM->pgm.s.GCPhysCR3));
1527
1528 /* We assume we're only called in nested paging mode. */
1529 Assert(pVM->pgm.s.fMappingsFixed);
1530 Assert(!(pVM->pgm.s.fSyncFlags & PGM_SYNC_MONITOR_CR3));
1531 Assert(pVM->pgm.s.enmShadowMode == PGMMODE_NESTED || pVM->pgm.s.enmShadowMode == PGMMODE_EPT);
1532
1533 /*
1534 * Remap the CR3 content and adjust the monitoring if CR3 was actually changed.
1535 */
1536 int rc = VINF_SUCCESS;
1537 RTGCPHYS GCPhysCR3;
1538 if ( pVM->pgm.s.enmGuestMode == PGMMODE_PAE
1539 || pVM->pgm.s.enmGuestMode == PGMMODE_PAE_NX
1540 || pVM->pgm.s.enmGuestMode == PGMMODE_AMD64
1541 || pVM->pgm.s.enmGuestMode == PGMMODE_AMD64_NX)
1542 GCPhysCR3 = (RTGCPHYS)(cr3 & X86_CR3_PAE_PAGE_MASK);
1543 else
1544 GCPhysCR3 = (RTGCPHYS)(cr3 & X86_CR3_PAGE_MASK);
1545 if (pVM->pgm.s.GCPhysCR3 != GCPhysCR3)
1546 {
1547 pVM->pgm.s.GCPhysCR3 = GCPhysCR3;
1548 rc = PGM_GST_PFN(MapCR3, pVM)(pVM, GCPhysCR3);
1549 }
1550 AssertRC(rc);
1551 return rc;
1552}
1553
1554
1555/**
1556 * Synchronize the paging structures.
1557 *
1558 * This function is called in response to the VM_FF_PGM_SYNC_CR3 and
1559 * VM_FF_PGM_SYNC_CR3_NONGLOBAL. Those two force action flags are set
1560 * in several places, most importantly whenever the CR3 is loaded.
1561 *
1562 * @returns VBox status code.
1563 * @param pVM The virtual machine.
1564 * @param cr0 Guest context CR0 register
1565 * @param cr3 Guest context CR3 register
1566 * @param cr4 Guest context CR4 register
1567 * @param fGlobal Including global page directories or not
1568 */
1569VMMDECL(int) PGMSyncCR3(PVM pVM, uint64_t cr0, uint64_t cr3, uint64_t cr4, bool fGlobal)
1570{
1571 /*
1572 * We might be called when we shouldn't.
1573 *
1574 * The mode switching will ensure that the PD is resynced
1575 * after every mode switch. So, if we find ourselves here
1576 * when in protected or real mode we can safely disable the
1577 * FF and return immediately.
1578 */
1579 if (pVM->pgm.s.enmGuestMode <= PGMMODE_PROTECTED)
1580 {
1581 Assert((cr0 & (X86_CR0_PG | X86_CR0_PE)) != (X86_CR0_PG | X86_CR0_PE));
1582 VM_FF_CLEAR(pVM, VM_FF_PGM_SYNC_CR3);
1583 VM_FF_CLEAR(pVM, VM_FF_PGM_SYNC_CR3_NON_GLOBAL);
1584 return VINF_SUCCESS;
1585 }
1586
1587 /* If global pages are not supported, then all flushes are global */
1588 if (!(cr4 & X86_CR4_PGE))
1589 fGlobal = true;
1590 LogFlow(("PGMSyncCR3: cr0=%VX64 cr3=%VX64 cr4=%VX64 fGlobal=%d[%d,%d]\n", cr0, cr3, cr4, fGlobal,
1591 VM_FF_ISSET(pVM, VM_FF_PGM_SYNC_CR3), VM_FF_ISSET(pVM, VM_FF_PGM_SYNC_CR3_NON_GLOBAL)));
1592
1593 /*
1594 * Let the 'Bth' function do the work and we'll just keep track of the flags.
1595 */
1596 STAM_PROFILE_START(&pVM->pgm.s.CTX_MID_Z(Stat,SyncCR3), a);
1597 int rc = PGM_BTH_PFN(SyncCR3, pVM)(pVM, cr0, cr3, cr4, fGlobal);
1598 STAM_PROFILE_STOP(&pVM->pgm.s.CTX_MID_Z(Stat,SyncCR3), a);
1599 AssertMsg(rc == VINF_SUCCESS || rc == VINF_PGM_SYNC_CR3 || VBOX_FAILURE(rc), ("rc=%VRc\n", rc));
1600 if (rc == VINF_SUCCESS)
1601 {
1602 if (!(pVM->pgm.s.fSyncFlags & PGM_SYNC_ALWAYS))
1603 {
1604 VM_FF_CLEAR(pVM, VM_FF_PGM_SYNC_CR3);
1605 VM_FF_CLEAR(pVM, VM_FF_PGM_SYNC_CR3_NON_GLOBAL);
1606 }
1607
1608 /*
1609 * Check if we have a pending update of the CR3 monitoring.
1610 */
1611 if (pVM->pgm.s.fSyncFlags & PGM_SYNC_MONITOR_CR3)
1612 {
1613 pVM->pgm.s.fSyncFlags &= ~PGM_SYNC_MONITOR_CR3;
1614 Assert(!pVM->pgm.s.fMappingsFixed);
1615 Assert(pVM->pgm.s.GCPhysCR3 == pVM->pgm.s.GCPhysGstCR3Monitored);
1616 rc = PGM_GST_PFN(MonitorCR3, pVM)(pVM, pVM->pgm.s.GCPhysCR3);
1617 }
1618 }
1619
1620 /*
1621 * Now flush the CR3 (guest context).
1622 */
1623 if (rc == VINF_SUCCESS)
1624 PGM_INVL_GUEST_TLBS();
1625 return rc;
1626}
1627
1628
1629/**
1630 * Called whenever CR0 or CR4 in a way which may change
1631 * the paging mode.
1632 *
1633 * @returns VBox status code fit for scheduling in GC and R0.
1634 * @retval VINF_SUCCESS if the was no change, or it was successfully dealt with.
1635 * @retval VINF_PGM_CHANGE_MODE if we're in GC or R0 and the mode changes.
1636 * @param pVM VM handle.
1637 * @param cr0 The new cr0.
1638 * @param cr4 The new cr4.
1639 * @param efer The new extended feature enable register.
1640 */
1641VMMDECL(int) PGMChangeMode(PVM pVM, uint64_t cr0, uint64_t cr4, uint64_t efer)
1642{
1643 PGMMODE enmGuestMode;
1644
1645 /*
1646 * Calc the new guest mode.
1647 */
1648 if (!(cr0 & X86_CR0_PE))
1649 enmGuestMode = PGMMODE_REAL;
1650 else if (!(cr0 & X86_CR0_PG))
1651 enmGuestMode = PGMMODE_PROTECTED;
1652 else if (!(cr4 & X86_CR4_PAE))
1653 enmGuestMode = PGMMODE_32_BIT;
1654 else if (!(efer & MSR_K6_EFER_LME))
1655 {
1656 if (!(efer & MSR_K6_EFER_NXE))
1657 enmGuestMode = PGMMODE_PAE;
1658 else
1659 enmGuestMode = PGMMODE_PAE_NX;
1660 }
1661 else
1662 {
1663 if (!(efer & MSR_K6_EFER_NXE))
1664 enmGuestMode = PGMMODE_AMD64;
1665 else
1666 enmGuestMode = PGMMODE_AMD64_NX;
1667 }
1668
1669 /*
1670 * Did it change?
1671 */
1672 if (pVM->pgm.s.enmGuestMode == enmGuestMode)
1673 return VINF_SUCCESS;
1674
1675 /* Flush the TLB */
1676 PGM_INVL_GUEST_TLBS();
1677
1678#ifdef IN_RING3
1679 return PGMR3ChangeMode(pVM, enmGuestMode);
1680#else
1681 Log(("PGMChangeMode: returns VINF_PGM_CHANGE_MODE.\n"));
1682 return VINF_PGM_CHANGE_MODE;
1683#endif
1684}
1685
1686
1687/**
1688 * Gets the current guest paging mode.
1689 *
1690 * If you just need the CPU mode (real/protected/long), use CPUMGetGuestMode().
1691 *
1692 * @returns The current paging mode.
1693 * @param pVM The VM handle.
1694 */
1695VMMDECL(PGMMODE) PGMGetGuestMode(PVM pVM)
1696{
1697 return pVM->pgm.s.enmGuestMode;
1698}
1699
1700
1701/**
1702 * Gets the current shadow paging mode.
1703 *
1704 * @returns The current paging mode.
1705 * @param pVM The VM handle.
1706 */
1707VMMDECL(PGMMODE) PGMGetShadowMode(PVM pVM)
1708{
1709 return pVM->pgm.s.enmShadowMode;
1710}
1711
1712/**
1713 * Gets the current host paging mode.
1714 *
1715 * @returns The current paging mode.
1716 * @param pVM The VM handle.
1717 */
1718VMMDECL(PGMMODE) PGMGetHostMode(PVM pVM)
1719{
1720 switch (pVM->pgm.s.enmHostMode)
1721 {
1722 case SUPPAGINGMODE_32_BIT:
1723 case SUPPAGINGMODE_32_BIT_GLOBAL:
1724 return PGMMODE_32_BIT;
1725
1726 case SUPPAGINGMODE_PAE:
1727 case SUPPAGINGMODE_PAE_GLOBAL:
1728 return PGMMODE_PAE;
1729
1730 case SUPPAGINGMODE_PAE_NX:
1731 case SUPPAGINGMODE_PAE_GLOBAL_NX:
1732 return PGMMODE_PAE_NX;
1733
1734 case SUPPAGINGMODE_AMD64:
1735 case SUPPAGINGMODE_AMD64_GLOBAL:
1736 return PGMMODE_AMD64;
1737
1738 case SUPPAGINGMODE_AMD64_NX:
1739 case SUPPAGINGMODE_AMD64_GLOBAL_NX:
1740 return PGMMODE_AMD64_NX;
1741
1742 default: AssertMsgFailed(("enmHostMode=%d\n", pVM->pgm.s.enmHostMode)); break;
1743 }
1744
1745 return PGMMODE_INVALID;
1746}
1747
1748
1749/**
1750 * Get mode name.
1751 *
1752 * @returns read-only name string.
1753 * @param enmMode The mode which name is desired.
1754 */
1755VMMDECL(const char *) PGMGetModeName(PGMMODE enmMode)
1756{
1757 switch (enmMode)
1758 {
1759 case PGMMODE_REAL: return "Real";
1760 case PGMMODE_PROTECTED: return "Protected";
1761 case PGMMODE_32_BIT: return "32-bit";
1762 case PGMMODE_PAE: return "PAE";
1763 case PGMMODE_PAE_NX: return "PAE+NX";
1764 case PGMMODE_AMD64: return "AMD64";
1765 case PGMMODE_AMD64_NX: return "AMD64+NX";
1766 case PGMMODE_NESTED: return "Nested";
1767 case PGMMODE_EPT: return "EPT";
1768 default: return "unknown mode value";
1769 }
1770}
1771
1772
1773/**
1774 * Acquire the PGM lock.
1775 *
1776 * @returns VBox status code
1777 * @param pVM The VM to operate on.
1778 */
1779int pgmLock(PVM pVM)
1780{
1781 int rc = PDMCritSectEnter(&pVM->pgm.s.CritSect, VERR_SEM_BUSY);
1782#ifdef IN_GC
1783 if (rc == VERR_SEM_BUSY)
1784 rc = VMMGCCallHost(pVM, VMMCALLHOST_PGM_LOCK, 0);
1785#elif defined(IN_RING0)
1786 if (rc == VERR_SEM_BUSY)
1787 rc = VMMR0CallHost(pVM, VMMCALLHOST_PGM_LOCK, 0);
1788#endif
1789 AssertRC(rc);
1790 return rc;
1791}
1792
1793
1794/**
1795 * Release the PGM lock.
1796 *
1797 * @returns VBox status code
1798 * @param pVM The VM to operate on.
1799 */
1800void pgmUnlock(PVM pVM)
1801{
1802 PDMCritSectLeave(&pVM->pgm.s.CritSect);
1803}
1804
1805#if defined(IN_GC) || defined(VBOX_WITH_2X_4GB_ADDR_SPACE_IN_R0)
1806
1807/**
1808 * Temporarily maps one guest page specified by GC physical address.
1809 * These pages must have a physical mapping in HC, i.e. they cannot be MMIO pages.
1810 *
1811 * Be WARNED that the dynamic page mapping area is small, 8 pages, thus the space is
1812 * reused after 8 mappings (or perhaps a few more if you score with the cache).
1813 *
1814 * @returns VBox status.
1815 * @param pVM VM handle.
1816 * @param GCPhys GC Physical address of the page.
1817 * @param ppv Where to store the address of the mapping.
1818 */
1819VMMDECL(int) PGMDynMapGCPage(PVM pVM, RTGCPHYS GCPhys, void **ppv)
1820{
1821 AssertMsg(!(GCPhys & PAGE_OFFSET_MASK), ("GCPhys=%RGp\n", GCPhys));
1822
1823 /*
1824 * Get the ram range.
1825 */
1826 PPGMRAMRANGE pRam = pVM->pgm.s.CTX_SUFF(pRamRanges);
1827 while (pRam && GCPhys - pRam->GCPhys >= pRam->cb)
1828 pRam = pRam->CTX_SUFF(pNext);
1829 if (!pRam)
1830 {
1831 AssertMsgFailed(("Invalid physical address %RGp!\n", GCPhys));
1832 return VERR_PGM_INVALID_GC_PHYSICAL_ADDRESS;
1833 }
1834
1835 /*
1836 * Pass it on to PGMDynMapHCPage.
1837 */
1838 RTHCPHYS HCPhys = PGM_PAGE_GET_HCPHYS(&pRam->aPages[(GCPhys - pRam->GCPhys) >> PAGE_SHIFT]);
1839 //Log(("PGMDynMapGCPage: GCPhys=%VGp HCPhys=%VHp\n", GCPhys, HCPhys));
1840 return PGMDynMapHCPage(pVM, HCPhys, ppv);
1841}
1842
1843
1844/**
1845 * Temporarily maps one guest page specified by unaligned GC physical address.
1846 * These pages must have a physical mapping in HC, i.e. they cannot be MMIO pages.
1847 *
1848 * Be WARNED that the dynamic page mapping area is small, 8 pages, thus the space is
1849 * reused after 8 mappings (or perhaps a few more if you score with the cache).
1850 *
1851 * The caller is aware that only the speicifed page is mapped and that really bad things
1852 * will happen if writing beyond the page!
1853 *
1854 * @returns VBox status.
1855 * @param pVM VM handle.
1856 * @param GCPhys GC Physical address within the page to be mapped.
1857 * @param ppv Where to store the address of the mapping address corresponding to GCPhys.
1858 */
1859VMMDECL(int) PGMDynMapGCPageOff(PVM pVM, RTGCPHYS GCPhys, void **ppv)
1860{
1861 /*
1862 * Get the ram range.
1863 */
1864 PPGMRAMRANGE pRam = pVM->pgm.s.CTX_SUFF(pRamRanges);
1865 while (pRam && GCPhys - pRam->GCPhys >= pRam->cb)
1866 pRam = pRam->CTX_SUFF(pNext);
1867 if (!pRam)
1868 {
1869 AssertMsgFailed(("Invalid physical address %VGp!\n", GCPhys));
1870 return VERR_PGM_INVALID_GC_PHYSICAL_ADDRESS;
1871 }
1872
1873 /*
1874 * Pass it on to PGMDynMapHCPage.
1875 */
1876 RTHCPHYS HCPhys = PGM_PAGE_GET_HCPHYS(&pRam->aPages[(GCPhys - pRam->GCPhys) >> PAGE_SHIFT]);
1877 int rc = PGMDynMapHCPage(pVM, HCPhys, ppv);
1878 if (RT_SUCCESS(rc))
1879 *ppv = (void *)((uintptr_t)*ppv | (GCPhys & PAGE_OFFSET_MASK));
1880 return rc;
1881}
1882
1883
1884/**
1885 * Temporarily maps one host page specified by HC physical address.
1886 *
1887 * Be WARNED that the dynamic page mapping area is small, 8 pages, thus the space is
1888 * reused after 8 mappings (or perhaps a few more if you score with the cache).
1889 *
1890 * @returns VBox status.
1891 * @param pVM VM handle.
1892 * @param HCPhys HC Physical address of the page.
1893 * @param ppv Where to store the address of the mapping. This is the
1894 * address of the PAGE not the exact address corresponding
1895 * to HCPhys. Use PGMDynMapHCPageOff if you care for the
1896 * page offset.
1897 */
1898VMMDECL(int) PGMDynMapHCPage(PVM pVM, RTHCPHYS HCPhys, void **ppv)
1899{
1900 AssertMsg(!(HCPhys & PAGE_OFFSET_MASK), ("HCPhys=%RHp\n", HCPhys));
1901# ifdef IN_GC
1902
1903 /*
1904 * Check the cache.
1905 */
1906 register unsigned iCache;
1907 if ( pVM->pgm.s.aHCPhysDynPageMapCache[iCache = 0] == HCPhys
1908 || pVM->pgm.s.aHCPhysDynPageMapCache[iCache = 1] == HCPhys
1909 || pVM->pgm.s.aHCPhysDynPageMapCache[iCache = 2] == HCPhys
1910 || pVM->pgm.s.aHCPhysDynPageMapCache[iCache = 3] == HCPhys)
1911 {
1912 static const uint8_t au8Trans[MM_HYPER_DYNAMIC_SIZE >> PAGE_SHIFT][RT_ELEMENTS(pVM->pgm.s.aHCPhysDynPageMapCache)] =
1913 {
1914 { 0, 5, 6, 7 },
1915 { 0, 1, 6, 7 },
1916 { 0, 1, 2, 7 },
1917 { 0, 1, 2, 3 },
1918 { 4, 1, 2, 3 },
1919 { 4, 5, 2, 3 },
1920 { 4, 5, 6, 3 },
1921 { 4, 5, 6, 7 },
1922 };
1923 Assert(RT_ELEMENTS(au8Trans) == 8);
1924 Assert(RT_ELEMENTS(au8Trans[0]) == 4);
1925 int iPage = au8Trans[pVM->pgm.s.iDynPageMapLast][iCache];
1926 void *pv = pVM->pgm.s.pbDynPageMapBaseGC + (iPage << PAGE_SHIFT);
1927 *ppv = pv;
1928 STAM_COUNTER_INC(&pVM->pgm.s.StatRCDynMapCacheHits);
1929 //Log(("PGMGCDynMapHCPage: HCPhys=%VHp pv=%VGv iPage=%d iCache=%d\n", HCPhys, pv, iPage, iCache));
1930 return VINF_SUCCESS;
1931 }
1932 Assert(RT_ELEMENTS(pVM->pgm.s.aHCPhysDynPageMapCache) == 4);
1933 STAM_COUNTER_INC(&pVM->pgm.s.StatRCDynMapCacheMisses);
1934
1935 /*
1936 * Update the page tables.
1937 */
1938 register unsigned iPage = pVM->pgm.s.iDynPageMapLast;
1939 pVM->pgm.s.iDynPageMapLast = iPage = (iPage + 1) & ((MM_HYPER_DYNAMIC_SIZE >> PAGE_SHIFT) - 1);
1940 Assert((MM_HYPER_DYNAMIC_SIZE >> PAGE_SHIFT) == 8);
1941
1942 pVM->pgm.s.aHCPhysDynPageMapCache[iPage & (RT_ELEMENTS(pVM->pgm.s.aHCPhysDynPageMapCache) - 1)] = HCPhys;
1943 pVM->pgm.s.paDynPageMap32BitPTEsGC[iPage].u = (uint32_t)HCPhys | X86_PTE_P | X86_PTE_A | X86_PTE_D;
1944 pVM->pgm.s.paDynPageMapPaePTEsGC[iPage].u = HCPhys | X86_PTE_P | X86_PTE_A | X86_PTE_D;
1945
1946 void *pv = pVM->pgm.s.pbDynPageMapBaseGC + (iPage << PAGE_SHIFT);
1947 *ppv = pv;
1948 ASMInvalidatePage(pv);
1949 Log4(("PGMGCDynMapHCPage: HCPhys=%VHp pv=%VGv iPage=%d\n", HCPhys, pv, iPage));
1950 return VINF_SUCCESS;
1951
1952#else /* VBOX_WITH_2X_4GB_ADDR_SPACE_IN_R0 */
1953 /** @todo @bugref{3202}: Implement ring-0 mapping cache similar to the one in
1954 * RC. To begin with, a simple but expensive one based on
1955 * RTR0MemObjEnterPhys can be used to get things started. Later a
1956 * global cache with mappings per CPU (to avoid shootdown) should be
1957 * employed. */
1958 AssertFailed();
1959 return VERR_NOT_IMPLEMENTED;
1960#endif /* VBOX_WITH_2X_4GB_ADDR_SPACE_IN_R0 */
1961}
1962
1963
1964/**
1965 * Temporarily maps one host page specified by HC physical address, returning
1966 * pointer within the page.
1967 *
1968 * Be WARNED that the dynamic page mapping area is small, 8 pages, thus the space is
1969 * reused after 8 mappings (or perhaps a few more if you score with the cache).
1970 *
1971 * @returns VBox status.
1972 * @param pVM VM handle.
1973 * @param HCPhys HC Physical address of the page.
1974 * @param ppv Where to store the address corresponding to HCPhys.
1975 */
1976VMMDECL(int) PGMDynMapHCPageOff(PVM pVM, RTHCPHYS HCPhys, void **ppv)
1977{
1978 int rc = PGMDynMapHCPage(pVM, HCPhys & ~(RTHCPHYS)PAGE_OFFSET_MASK, ppv);
1979 if (RT_SUCCESS(rc))
1980 *ppv = (void *)((uintptr_t)*ppv | (HCPhys & PAGE_OFFSET_MASK));
1981 return rc;
1982}
1983
1984#endif /* IN_GC || VBOX_WITH_2X_4GB_ADDR_SPACE_IN_R0 */
1985#ifdef VBOX_STRICT
1986
1987/**
1988 * Asserts that there are no mapping conflicts.
1989 *
1990 * @returns Number of conflicts.
1991 * @param pVM The VM Handle.
1992 */
1993VMMDECL(unsigned) PGMAssertNoMappingConflicts(PVM pVM)
1994{
1995 unsigned cErrors = 0;
1996
1997 /*
1998 * Check for mapping conflicts.
1999 */
2000 for (PPGMMAPPING pMapping = pVM->pgm.s.CTX_SUFF(pMappings);
2001 pMapping;
2002 pMapping = pMapping->CTX_SUFF(pNext))
2003 {
2004 /** @todo This is slow and should be optimized, but since it's just assertions I don't care now. */
2005 for (RTGCUINTPTR GCPtr = (RTGCUINTPTR)pMapping->GCPtr;
2006 GCPtr <= (RTGCUINTPTR)pMapping->GCPtrLast;
2007 GCPtr += PAGE_SIZE)
2008 {
2009 int rc = PGMGstGetPage(pVM, (RTGCPTR)GCPtr, NULL, NULL);
2010 if (rc != VERR_PAGE_TABLE_NOT_PRESENT)
2011 {
2012 AssertMsgFailed(("Conflict at %VGv with %s\n", GCPtr, R3STRING(pMapping->pszDesc)));
2013 cErrors++;
2014 break;
2015 }
2016 }
2017 }
2018
2019 return cErrors;
2020}
2021
2022
2023/**
2024 * Asserts that everything related to the guest CR3 is correctly shadowed.
2025 *
2026 * This will call PGMAssertNoMappingConflicts() and PGMAssertHandlerAndFlagsInSync(),
2027 * and assert the correctness of the guest CR3 mapping before asserting that the
2028 * shadow page tables is in sync with the guest page tables.
2029 *
2030 * @returns Number of conflicts.
2031 * @param pVM The VM Handle.
2032 * @param cr3 The current guest CR3 register value.
2033 * @param cr4 The current guest CR4 register value.
2034 */
2035VMMDECL(unsigned) PGMAssertCR3(PVM pVM, uint64_t cr3, uint64_t cr4)
2036{
2037 STAM_PROFILE_START(&pVM->pgm.s.CTX_MID_Z(Stat,SyncCR3), a);
2038 unsigned cErrors = PGM_BTH_PFN(AssertCR3, pVM)(pVM, cr3, cr4, 0, ~(RTGCUINTPTR)0);
2039 STAM_PROFILE_STOP(&pVM->pgm.s.CTX_MID_Z(Stat,SyncCR3), a);
2040 return cErrors;
2041 return 0;
2042}
2043
2044#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