PGMAllPhys.cpp@ 71416

Last change on this file since 71416 was 71081, checked in by vboxsync, 7 years ago
VMM,SUPDrv: More NEM/win experimentation. bugref:9044
Property svn:eol-style set to `native` Property svn:keywords set to `Id Revision`
File size: 178.1 KB

Line
1	/* $Id: PGMAllPhys.cpp 71081 2018-02-21 10:36:30Z vboxsync $ */
2	/** @file
3	* PGM - Page Manager and Monitor, Physical Memory Addressing.
4	*/
5
6	/*
7	* Copyright (C) 2006-2017 Oracle Corporation
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.virtualbox.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*/
17
18
19	/*********************************************************************************************************************************
20	* Header Files *
21	*********************************************************************************************************************************/
22	#define LOG_GROUP LOG_GROUP_PGM_PHYS
23	#include <VBox/vmm/pgm.h>
24	#include <VBox/vmm/trpm.h>
25	#include <VBox/vmm/vmm.h>
26	#include <VBox/vmm/iom.h>
27	#include <VBox/vmm/em.h>
28	#include <VBox/vmm/nem.h>
29	#ifdef VBOX_WITH_REM
30	# include <VBox/vmm/rem.h>
31	#endif
32	#include "PGMInternal.h"
33	#include <VBox/vmm/vm.h>
34	#include "PGMInline.h"
35	#include <VBox/param.h>
36	#include <VBox/err.h>
37	#include <iprt/assert.h>
38	#include <iprt/string.h>
39	#include <iprt/asm-amd64-x86.h>
40	#include <VBox/log.h>
41	#ifdef IN_RING3
42	# include <iprt/thread.h>
43	#endif
44
45
46	/*********************************************************************************************************************************
47	* Defined Constants And Macros *
48	*********************************************************************************************************************************/
49	/** Enable the physical TLB. */
50	#define PGM_WITH_PHYS_TLB
51
52	/** @def PGM_HANDLER_PHYS_IS_VALID_STATUS
53	* Checks if valid physical access handler return code (normal handler, not PF).
54	*
55	* Checks if the given strict status code is one of the expected ones for a
56	* physical access handler in the current context.
57	*
58	* @returns true or false.
59	* @param a_rcStrict The status code.
60	* @param a_fWrite Whether it is a write or read being serviced.
61	*
62	* @remarks We wish to keep the list of statuses here as short as possible.
63	* When changing, please make sure to update the PGMPhysRead,
64	* PGMPhysWrite, PGMPhysReadGCPtr and PGMPhysWriteGCPtr docs too.
65	*/
66	#ifdef IN_RING3
67	# define PGM_HANDLER_PHYS_IS_VALID_STATUS(a_rcStrict, a_fWrite) \
68	( (a_rcStrict) == VINF_SUCCESS \
69	\|\| (a_rcStrict) == VINF_PGM_HANDLER_DO_DEFAULT)
70	#elif defined(IN_RING0) \|\| defined(IN_RC)
71	#define PGM_HANDLER_PHYS_IS_VALID_STATUS(a_rcStrict, a_fWrite) \
72	( (a_rcStrict) == VINF_SUCCESS \
73	\|\| (a_rcStrict) == VINF_PGM_HANDLER_DO_DEFAULT \
74	\
75	\|\| (a_rcStrict) == ((a_fWrite) ? VINF_IOM_R3_MMIO_WRITE : VINF_IOM_R3_MMIO_READ) \
76	\|\| (a_rcStrict) == VINF_IOM_R3_MMIO_READ_WRITE \
77	\|\| ((a_rcStrict) == VINF_IOM_R3_MMIO_COMMIT_WRITE && (a_fWrite)) \
78	\
79	\|\| ((a_fWrite) ? (a_rcStrict) == VINF_EM_RAW_EMULATE_IO_BLOCK : false) \
80	\
81	\|\| (a_rcStrict) == VINF_EM_RAW_EMULATE_INSTR \
82	\|\| (a_rcStrict) == VINF_EM_DBG_STOP \
83	\|\| (a_rcStrict) == VINF_EM_DBG_EVENT \
84	\|\| (a_rcStrict) == VINF_EM_DBG_BREAKPOINT \
85	\|\| (a_rcStrict) == VINF_EM_OFF \
86	\|\| (a_rcStrict) == VINF_EM_SUSPEND \
87	\|\| (a_rcStrict) == VINF_EM_RESET \
88	)
89	#else
90	# error "Context?"
91	#endif
92
93	/** @def PGM_HANDLER_VIRT_IS_VALID_STATUS
94	* Checks if valid virtual access handler return code (normal handler, not PF).
95	*
96	* Checks if the given strict status code is one of the expected ones for a
97	* virtual access handler in the current context.
98	*
99	* @returns true or false.
100	* @param a_rcStrict The status code.
101	* @param a_fWrite Whether it is a write or read being serviced.
102	*
103	* @remarks We wish to keep the list of statuses here as short as possible.
104	* When changing, please make sure to update the PGMPhysRead,
105	* PGMPhysWrite, PGMPhysReadGCPtr and PGMPhysWriteGCPtr docs too.
106	*/
107	#ifdef IN_RING3
108	# define PGM_HANDLER_VIRT_IS_VALID_STATUS(a_rcStrict, a_fWrite) \
109	( (a_rcStrict) == VINF_SUCCESS \
110	\|\| (a_rcStrict) == VINF_PGM_HANDLER_DO_DEFAULT)
111	#elif defined(IN_RING0)
112	# define PGM_HANDLER_VIRT_IS_VALID_STATUS(a_rcStrict, a_fWrite) \
113	(false /* no virtual handlers in ring-0! */ )
114	#elif defined(IN_RC)
115	# define PGM_HANDLER_VIRT_IS_VALID_STATUS(a_rcStrict, a_fWrite) \
116	( (a_rcStrict) == VINF_SUCCESS \
117	\|\| (a_rcStrict) == VINF_PGM_HANDLER_DO_DEFAULT \
118	\
119	\|\| ((a_fWrite) ? (a_rcStrict) == VINF_EM_RAW_EMULATE_INSTR_GDT_FAULT : 0) \
120	\|\| ((a_fWrite) ? (a_rcStrict) == VINF_EM_RAW_EMULATE_INSTR_LDT_FAULT : 0) \
121	\|\| ((a_fWrite) ? (a_rcStrict) == VINF_EM_RAW_EMULATE_INSTR_TSS_FAULT : 0) \
122	\|\| ((a_fWrite) ? (a_rcStrict) == VINF_EM_RAW_EMULATE_INSTR_IDT_FAULT : 0) \
123	\|\| ((a_fWrite) ? (a_rcStrict) == VINF_SELM_SYNC_GDT : 0) \
124	\|\| ((a_fWrite) ? (a_rcStrict) == VINF_CSAM_PENDING_ACTION : 0) \
125	\|\| (a_rcStrict) == VINF_PATM_CHECK_PATCH_PAGE \
126	\
127	\|\| (a_rcStrict) == VINF_EM_RAW_EMULATE_INSTR \
128	\|\| (a_rcStrict) == VINF_EM_DBG_STOP \
129	\|\| (a_rcStrict) == VINF_EM_DBG_EVENT \
130	\|\| (a_rcStrict) == VINF_EM_DBG_BREAKPOINT \
131	)
132	#else
133	# error "Context?"
134	#endif
135
136
137
138	#ifndef IN_RING3
139
140	/**
141	* @callback_method_impl{FNPGMPHYSHANDLER,
142	* Dummy for forcing ring-3 handling of the access.}
143	*/
144	DECLEXPORT(VBOXSTRICTRC)
145	pgmPhysHandlerRedirectToHC(PVM pVM, PVMCPU pVCpu, RTGCPHYS GCPhys, void pvPhys, void pvBuf, size_t cbBuf,
146	PGMACCESSTYPE enmAccessType, PGMACCESSORIGIN enmOrigin, void *pvUser)
147	{
148	NOREF(pVM); NOREF(pVCpu); NOREF(GCPhys); NOREF(pvPhys); NOREF(pvBuf); NOREF(cbBuf);
149	NOREF(enmAccessType); NOREF(enmOrigin); NOREF(pvUser);
150	return VINF_EM_RAW_EMULATE_INSTR;
151	}
152
153
154	/**
155	* @callback_method_impl{FNPGMRZPHYSPFHANDLER,
156	* Dummy for forcing ring-3 handling of the access.}
157	*/
158	VMMDECL(VBOXSTRICTRC) pgmPhysPfHandlerRedirectToHC(PVM pVM, PVMCPU pVCpu, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame,
159	RTGCPTR pvFault, RTGCPHYS GCPhysFault, void *pvUser)
160	{
161	NOREF(pVM); NOREF(pVCpu); NOREF(uErrorCode); NOREF(pRegFrame); NOREF(pvFault); NOREF(GCPhysFault); NOREF(pvUser);
162	return VINF_EM_RAW_EMULATE_INSTR;
163	}
164
165
166	/**
167	* @callback_method_impl{FNPGMRZPHYSPFHANDLER,
168	* \#PF access handler callback for guest ROM range write access.}
169	*
170	* @remarks The @a pvUser argument points to the PGMROMRANGE.
171	*/
172	DECLEXPORT(VBOXSTRICTRC) pgmPhysRomWritePfHandler(PVM pVM, PVMCPU pVCpu, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame,
173	RTGCPTR pvFault, RTGCPHYS GCPhysFault, void *pvUser)
174	{
175	int rc;
176	PPGMROMRANGE pRom = (PPGMROMRANGE)pvUser;
177	uint32_t iPage = (GCPhysFault - pRom->GCPhys) >> PAGE_SHIFT;
178	NOREF(uErrorCode); NOREF(pvFault);
179
180	Assert(uErrorCode & X86_TRAP_PF_RW); /* This shall not be used for read access! */
181
182	Assert(iPage < (pRom->cb >> PAGE_SHIFT));
183	switch (pRom->aPages[iPage].enmProt)
184	{
185	case PGMROMPROT_READ_ROM_WRITE_IGNORE:
186	case PGMROMPROT_READ_RAM_WRITE_IGNORE:
187	{
188	/*
189	* If it's a simple instruction which doesn't change the cpu state
190	* we will simply skip it. Otherwise we'll have to defer it to REM.
191	*/
192	uint32_t cbOp;
193	PDISCPUSTATE pDis = &pVCpu->pgm.s.DisState;
194	rc = EMInterpretDisasCurrent(pVM, pVCpu, pDis, &cbOp);
195	if ( RT_SUCCESS(rc)
196	&& pDis->uCpuMode == DISCPUMODE_32BIT /** @todo why does this matter? */
197	&& !(pDis->fPrefix & (DISPREFIX_REPNE \| DISPREFIX_REP \| DISPREFIX_SEG)))
198	{
199	switch (pDis->bOpCode)
200	{
201	/** @todo Find other instructions we can safely skip, possibly
202	* adding this kind of detection to DIS or EM. */
203	case OP_MOV:
204	pRegFrame->rip += cbOp;
205	STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_SUFF(pStats)->StatRZGuestROMWriteHandled);
206	return VINF_SUCCESS;
207	}
208	}
209	break;
210	}
211
212	case PGMROMPROT_READ_RAM_WRITE_RAM:
213	pRom->aPages[iPage].LiveSave.fWrittenTo = true;
214	rc = PGMHandlerPhysicalPageTempOff(pVM, pRom->GCPhys, GCPhysFault & X86_PTE_PG_MASK);
215	AssertRC(rc);
216	break; /** @todo Must edit the shadow PT and restart the instruction, not use the interpreter! */
217
218	case PGMROMPROT_READ_ROM_WRITE_RAM:
219	/* Handle it in ring-3 because it's way easier there. */
220	pRom->aPages[iPage].LiveSave.fWrittenTo = true;
221	break;
222
223	default:
224	AssertMsgFailedReturn(("enmProt=%d iPage=%d GCPhysFault=%RGp\n",
225	pRom->aPages[iPage].enmProt, iPage, GCPhysFault),
226	VERR_IPE_NOT_REACHED_DEFAULT_CASE);
227	}
228
229	STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_SUFF(pStats)->StatRZGuestROMWriteUnhandled);
230	return VINF_EM_RAW_EMULATE_INSTR;
231	}
232
233	#endif /* !IN_RING3 */
234
235
236	/**
237	* @callback_method_impl{FNPGMPHYSHANDLER,
238	* Access handler callback for ROM write accesses.}
239	*
240	* @remarks The @a pvUser argument points to the PGMROMRANGE.
241	*/
242	PGM_ALL_CB2_DECL(VBOXSTRICTRC)
243	pgmPhysRomWriteHandler(PVM pVM, PVMCPU pVCpu, RTGCPHYS GCPhys, void pvPhys, void pvBuf, size_t cbBuf,
244	PGMACCESSTYPE enmAccessType, PGMACCESSORIGIN enmOrigin, void *pvUser)
245	{
246	PPGMROMRANGE pRom = (PPGMROMRANGE)pvUser;
247	const uint32_t iPage = (GCPhys - pRom->GCPhys) >> PAGE_SHIFT;
248	Assert(iPage < (pRom->cb >> PAGE_SHIFT));
249	PPGMROMPAGE pRomPage = &pRom->aPages[iPage];
250	Log5(("pgmPhysRomWriteHandler: %d %c %#08RGp %#04zx\n", pRomPage->enmProt, enmAccessType == PGMACCESSTYPE_READ ? 'R' : 'W', GCPhys, cbBuf));
251	NOREF(pVCpu); NOREF(pvPhys); NOREF(enmOrigin);
252
253	if (enmAccessType == PGMACCESSTYPE_READ)
254	{
255	switch (pRomPage->enmProt)
256	{
257	/*
258	* Take the default action.
259	*/
260	case PGMROMPROT_READ_ROM_WRITE_IGNORE:
261	case PGMROMPROT_READ_RAM_WRITE_IGNORE:
262	case PGMROMPROT_READ_ROM_WRITE_RAM:
263	case PGMROMPROT_READ_RAM_WRITE_RAM:
264	return VINF_PGM_HANDLER_DO_DEFAULT;
265
266	default:
267	AssertMsgFailedReturn(("enmProt=%d iPage=%d GCPhys=%RGp\n",
268	pRom->aPages[iPage].enmProt, iPage, GCPhys),
269	VERR_IPE_NOT_REACHED_DEFAULT_CASE);
270	}
271	}
272	else
273	{
274	Assert(enmAccessType == PGMACCESSTYPE_WRITE);
275	switch (pRomPage->enmProt)
276	{
277	/*
278	* Ignore writes.
279	*/
280	case PGMROMPROT_READ_ROM_WRITE_IGNORE:
281	case PGMROMPROT_READ_RAM_WRITE_IGNORE:
282	return VINF_SUCCESS;
283
284	/*
285	* Write to the RAM page.
286	*/
287	case PGMROMPROT_READ_ROM_WRITE_RAM:
288	case PGMROMPROT_READ_RAM_WRITE_RAM: /* yes this will get here too, it's way simpler that way. */
289	{
290	/* This should be impossible now, pvPhys doesn't work cross page anylonger. */
291	Assert(((GCPhys - pRom->GCPhys + cbBuf - 1) >> PAGE_SHIFT) == iPage);
292
293	/*
294	* Take the lock, do lazy allocation, map the page and copy the data.
295	*
296	* Note that we have to bypass the mapping TLB since it works on
297	* guest physical addresses and entering the shadow page would
298	* kind of screw things up...
299	*/
300	int rc = pgmLock(pVM);
301	AssertRC(rc);
302
303	PPGMPAGE pShadowPage = &pRomPage->Shadow;
304	if (!PGMROMPROT_IS_ROM(pRomPage->enmProt))
305	{
306	pShadowPage = pgmPhysGetPage(pVM, GCPhys);
307	AssertLogRelReturn(pShadowPage, VERR_PGM_PHYS_PAGE_GET_IPE);
308	}
309
310	void *pvDstPage;
311	rc = pgmPhysPageMakeWritableAndMap(pVM, pShadowPage, GCPhys & X86_PTE_PG_MASK, &pvDstPage);
312	if (RT_SUCCESS(rc))
313	{
314	memcpy((uint8_t *)pvDstPage + (GCPhys & PAGE_OFFSET_MASK), pvBuf, cbBuf);
315	pRomPage->LiveSave.fWrittenTo = true;
316
317	AssertMsg( rc == VINF_SUCCESS
318	\|\| ( rc == VINF_PGM_SYNC_CR3
319	&& VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_PGM_SYNC_CR3 \| VMCPU_FF_PGM_SYNC_CR3_NON_GLOBAL))
320	, ("%Rrc\n", rc));
321	rc = VINF_SUCCESS;
322	}
323
324	pgmUnlock(pVM);
325	return rc;
326	}
327
328	default:
329	AssertMsgFailedReturn(("enmProt=%d iPage=%d GCPhys=%RGp\n",
330	pRom->aPages[iPage].enmProt, iPage, GCPhys),
331	VERR_IPE_NOT_REACHED_DEFAULT_CASE);
332	}
333	}
334	}
335
336
337	/**
338	* Invalidates the RAM range TLBs.
339	*
340	* @param pVM The cross context VM structure.
341	*/
342	void pgmPhysInvalidRamRangeTlbs(PVM pVM)
343	{
344	pgmLock(pVM);
345	for (uint32_t i = 0; i < PGM_RAMRANGE_TLB_ENTRIES; i++)
346	{
347	pVM->pgm.s.apRamRangesTlbR3[i] = NIL_RTR3PTR;
348	pVM->pgm.s.apRamRangesTlbR0[i] = NIL_RTR0PTR;
349	pVM->pgm.s.apRamRangesTlbRC[i] = NIL_RTRCPTR;
350	}
351	pgmUnlock(pVM);
352	}
353
354
355	/**
356	* Tests if a value of type RTGCPHYS is negative if the type had been signed
357	* instead of unsigned.
358	*
359	* @returns @c true if negative, @c false if positive or zero.
360	* @param a_GCPhys The value to test.
361	* @todo Move me to iprt/types.h.
362	*/
363	#define RTGCPHYS_IS_NEGATIVE(a_GCPhys) ((a_GCPhys) & ((RTGCPHYS)1 << (sizeof(RTGCPHYS)*8 - 1)))
364
365
366	/**
367	* Slow worker for pgmPhysGetRange.
368	*
369	* @copydoc pgmPhysGetRange
370	*/
371	PPGMRAMRANGE pgmPhysGetRangeSlow(PVM pVM, RTGCPHYS GCPhys)
372	{
373	STAM_COUNTER_INC(&pVM->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,RamRangeTlbMisses));
374
375	PPGMRAMRANGE pRam = pVM->pgm.s.CTX_SUFF(pRamRangeTree);
376	while (pRam)
377	{
378	RTGCPHYS off = GCPhys - pRam->GCPhys;
379	if (off < pRam->cb)
380	{
381	pVM->pgm.s.CTX_SUFF(apRamRangesTlb)[PGM_RAMRANGE_TLB_IDX(GCPhys)] = pRam;
382	return pRam;
383	}
384	if (RTGCPHYS_IS_NEGATIVE(off))
385	pRam = pRam->CTX_SUFF(pLeft);
386	else
387	pRam = pRam->CTX_SUFF(pRight);
388	}
389	return NULL;
390	}
391
392
393	/**
394	* Slow worker for pgmPhysGetRangeAtOrAbove.
395	*
396	* @copydoc pgmPhysGetRangeAtOrAbove
397	*/
398	PPGMRAMRANGE pgmPhysGetRangeAtOrAboveSlow(PVM pVM, RTGCPHYS GCPhys)
399	{
400	STAM_COUNTER_INC(&pVM->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,RamRangeTlbMisses));
401
402	PPGMRAMRANGE pLastLeft = NULL;
403	PPGMRAMRANGE pRam = pVM->pgm.s.CTX_SUFF(pRamRangeTree);
404	while (pRam)
405	{
406	RTGCPHYS off = GCPhys - pRam->GCPhys;
407	if (off < pRam->cb)
408	{
409	pVM->pgm.s.CTX_SUFF(apRamRangesTlb)[PGM_RAMRANGE_TLB_IDX(GCPhys)] = pRam;
410	return pRam;
411	}
412	if (RTGCPHYS_IS_NEGATIVE(off))
413	{
414	pLastLeft = pRam;
415	pRam = pRam->CTX_SUFF(pLeft);
416	}
417	else
418	pRam = pRam->CTX_SUFF(pRight);
419	}
420	return pLastLeft;
421	}
422
423
424	/**
425	* Slow worker for pgmPhysGetPage.
426	*
427	* @copydoc pgmPhysGetPage
428	*/
429	PPGMPAGE pgmPhysGetPageSlow(PVM pVM, RTGCPHYS GCPhys)
430	{
431	STAM_COUNTER_INC(&pVM->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,RamRangeTlbMisses));
432
433	PPGMRAMRANGE pRam = pVM->pgm.s.CTX_SUFF(pRamRangeTree);
434	while (pRam)
435	{
436	RTGCPHYS off = GCPhys - pRam->GCPhys;
437	if (off < pRam->cb)
438	{
439	pVM->pgm.s.CTX_SUFF(apRamRangesTlb)[PGM_RAMRANGE_TLB_IDX(GCPhys)] = pRam;
440	return &pRam->aPages[off >> PAGE_SHIFT];
441	}
442
443	if (RTGCPHYS_IS_NEGATIVE(off))
444	pRam = pRam->CTX_SUFF(pLeft);
445	else
446	pRam = pRam->CTX_SUFF(pRight);
447	}
448	return NULL;
449	}
450
451
452	/**
453	* Slow worker for pgmPhysGetPageEx.
454	*
455	* @copydoc pgmPhysGetPageEx
456	*/
457	int pgmPhysGetPageExSlow(PVM pVM, RTGCPHYS GCPhys, PPPGMPAGE ppPage)
458	{
459	STAM_COUNTER_INC(&pVM->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,RamRangeTlbMisses));
460
461	PPGMRAMRANGE pRam = pVM->pgm.s.CTX_SUFF(pRamRangeTree);
462	while (pRam)
463	{
464	RTGCPHYS off = GCPhys - pRam->GCPhys;
465	if (off < pRam->cb)
466	{
467	pVM->pgm.s.CTX_SUFF(apRamRangesTlb)[PGM_RAMRANGE_TLB_IDX(GCPhys)] = pRam;
468	*ppPage = &pRam->aPages[off >> PAGE_SHIFT];
469	return VINF_SUCCESS;
470	}
471
472	if (RTGCPHYS_IS_NEGATIVE(off))
473	pRam = pRam->CTX_SUFF(pLeft);
474	else
475	pRam = pRam->CTX_SUFF(pRight);
476	}
477
478	*ppPage = NULL;
479	return VERR_PGM_INVALID_GC_PHYSICAL_ADDRESS;
480	}
481
482
483	/**
484	* Slow worker for pgmPhysGetPageAndRangeEx.
485	*
486	* @copydoc pgmPhysGetPageAndRangeEx
487	*/
488	int pgmPhysGetPageAndRangeExSlow(PVM pVM, RTGCPHYS GCPhys, PPPGMPAGE ppPage, PPGMRAMRANGE *ppRam)
489	{
490	STAM_COUNTER_INC(&pVM->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,RamRangeTlbMisses));
491
492	PPGMRAMRANGE pRam = pVM->pgm.s.CTX_SUFF(pRamRangeTree);
493	while (pRam)
494	{
495	RTGCPHYS off = GCPhys - pRam->GCPhys;
496	if (off < pRam->cb)
497	{
498	pVM->pgm.s.CTX_SUFF(apRamRangesTlb)[PGM_RAMRANGE_TLB_IDX(GCPhys)] = pRam;
499	*ppRam = pRam;
500	*ppPage = &pRam->aPages[off >> PAGE_SHIFT];
501	return VINF_SUCCESS;
502	}
503
504	if (RTGCPHYS_IS_NEGATIVE(off))
505	pRam = pRam->CTX_SUFF(pLeft);
506	else
507	pRam = pRam->CTX_SUFF(pRight);
508	}
509
510	*ppRam = NULL;
511	*ppPage = NULL;
512	return VERR_PGM_INVALID_GC_PHYSICAL_ADDRESS;
513	}
514
515
516	/**
517	* Checks if Address Gate 20 is enabled or not.
518	*
519	* @returns true if enabled.
520	* @returns false if disabled.
521	* @param pVCpu The cross context virtual CPU structure.
522	*/
523	VMMDECL(bool) PGMPhysIsA20Enabled(PVMCPU pVCpu)
524	{
525	LogFlow(("PGMPhysIsA20Enabled %d\n", pVCpu->pgm.s.fA20Enabled));
526	return pVCpu->pgm.s.fA20Enabled;
527	}
528
529
530	/**
531	* Validates a GC physical address.
532	*
533	* @returns true if valid.
534	* @returns false if invalid.
535	* @param pVM The cross context VM structure.
536	* @param GCPhys The physical address to validate.
537	*/
538	VMMDECL(bool) PGMPhysIsGCPhysValid(PVM pVM, RTGCPHYS GCPhys)
539	{
540	PPGMPAGE pPage = pgmPhysGetPage(pVM, GCPhys);
541	return pPage != NULL;
542	}
543
544
545	/**
546	* Checks if a GC physical address is a normal page,
547	* i.e. not ROM, MMIO or reserved.
548	*
549	* @returns true if normal.
550	* @returns false if invalid, ROM, MMIO or reserved page.
551	* @param pVM The cross context VM structure.
552	* @param GCPhys The physical address to check.
553	*/
554	VMMDECL(bool) PGMPhysIsGCPhysNormal(PVM pVM, RTGCPHYS GCPhys)
555	{
556	PPGMPAGE pPage = pgmPhysGetPage(pVM, GCPhys);
557	return pPage
558	&& PGM_PAGE_GET_TYPE(pPage) == PGMPAGETYPE_RAM;
559	}
560
561
562	/**
563	* Converts a GC physical address to a HC physical address.
564	*
565	* @returns VINF_SUCCESS on success.
566	* @returns VERR_PGM_PHYS_PAGE_RESERVED it it's a valid GC physical
567	* page but has no physical backing.
568	* @returns VERR_PGM_INVALID_GC_PHYSICAL_ADDRESS if it's not a valid
569	* GC physical address.
570	*
571	* @param pVM The cross context VM structure.
572	* @param GCPhys The GC physical address to convert.
573	* @param pHCPhys Where to store the HC physical address on success.
574	*/
575	VMM_INT_DECL(int) PGMPhysGCPhys2HCPhys(PVM pVM, RTGCPHYS GCPhys, PRTHCPHYS pHCPhys)
576	{
577	pgmLock(pVM);
578	PPGMPAGE pPage;
579	int rc = pgmPhysGetPageEx(pVM, GCPhys, &pPage);
580	if (RT_SUCCESS(rc))
581	*pHCPhys = PGM_PAGE_GET_HCPHYS(pPage) \| (GCPhys & PAGE_OFFSET_MASK);
582	pgmUnlock(pVM);
583	return rc;
584	}
585
586
587	/**
588	* Invalidates all page mapping TLBs.
589	*
590	* @param pVM The cross context VM structure.
591	*/
592	void pgmPhysInvalidatePageMapTLB(PVM pVM)
593	{
594	pgmLock(pVM);
595	STAM_COUNTER_INC(&pVM->pgm.s.CTX_SUFF(pStats)->StatPageMapTlbFlushes);
596
597	/* Clear the shared R0/R3 TLB completely. */
598	for (unsigned i = 0; i < RT_ELEMENTS(pVM->pgm.s.PhysTlbHC.aEntries); i++)
599	{
600	pVM->pgm.s.PhysTlbHC.aEntries[i].GCPhys = NIL_RTGCPHYS;
601	pVM->pgm.s.PhysTlbHC.aEntries[i].pPage = 0;
602	pVM->pgm.s.PhysTlbHC.aEntries[i].pMap = 0;
603	pVM->pgm.s.PhysTlbHC.aEntries[i].pv = 0;
604	}
605
606	/** @todo clear the RC TLB whenever we add it. */
607
608	pgmUnlock(pVM);
609	}
610
611
612	/**
613	* Invalidates a page mapping TLB entry
614	*
615	* @param pVM The cross context VM structure.
616	* @param GCPhys GCPhys entry to flush
617	*/
618	void pgmPhysInvalidatePageMapTLBEntry(PVM pVM, RTGCPHYS GCPhys)
619	{
620	PGM_LOCK_ASSERT_OWNER(pVM);
621
622	STAM_COUNTER_INC(&pVM->pgm.s.CTX_SUFF(pStats)->StatPageMapTlbFlushEntry);
623
624	#ifdef IN_RC
625	unsigned idx = PGM_PAGER3MAPTLB_IDX(GCPhys);
626	pVM->pgm.s.PhysTlbHC.aEntries[idx].GCPhys = NIL_RTGCPHYS;
627	pVM->pgm.s.PhysTlbHC.aEntries[idx].pPage = 0;
628	pVM->pgm.s.PhysTlbHC.aEntries[idx].pMap = 0;
629	pVM->pgm.s.PhysTlbHC.aEntries[idx].pv = 0;
630	#else
631	/* Clear the shared R0/R3 TLB entry. */
632	PPGMPAGEMAPTLBE pTlbe = &pVM->pgm.s.CTXSUFF(PhysTlb).aEntries[PGM_PAGEMAPTLB_IDX(GCPhys)];
633	pTlbe->GCPhys = NIL_RTGCPHYS;
634	pTlbe->pPage = 0;
635	pTlbe->pMap = 0;
636	pTlbe->pv = 0;
637	#endif
638
639	/** @todo clear the RC TLB whenever we add it. */
640	}
641
642
643	/**
644	* Makes sure that there is at least one handy page ready for use.
645	*
646	* This will also take the appropriate actions when reaching water-marks.
647	*
648	* @returns VBox status code.
649	* @retval VINF_SUCCESS on success.
650	* @retval VERR_EM_NO_MEMORY if we're really out of memory.
651	*
652	* @param pVM The cross context VM structure.
653	*
654	* @remarks Must be called from within the PGM critical section. It may
655	* nip back to ring-3/0 in some cases.
656	*/
657	static int pgmPhysEnsureHandyPage(PVM pVM)
658	{
659	AssertMsg(pVM->pgm.s.cHandyPages <= RT_ELEMENTS(pVM->pgm.s.aHandyPages), ("%d\n", pVM->pgm.s.cHandyPages));
660
661	/*
662	* Do we need to do anything special?
663	*/
664	#ifdef IN_RING3
665	if (pVM->pgm.s.cHandyPages <= RT_MAX(PGM_HANDY_PAGES_SET_FF, PGM_HANDY_PAGES_R3_ALLOC))
666	#else
667	if (pVM->pgm.s.cHandyPages <= RT_MAX(PGM_HANDY_PAGES_SET_FF, PGM_HANDY_PAGES_RZ_TO_R3))
668	#endif
669	{
670	/*
671	* Allocate pages only if we're out of them, or in ring-3, almost out.
672	*/
673	#ifdef IN_RING3
674	if (pVM->pgm.s.cHandyPages <= PGM_HANDY_PAGES_R3_ALLOC)
675	#else
676	if (pVM->pgm.s.cHandyPages <= PGM_HANDY_PAGES_RZ_ALLOC)
677	#endif
678	{
679	Log(("PGM: cHandyPages=%u out of %u -> allocate more; VM_FF_PGM_NO_MEMORY=%RTbool\n",
680	pVM->pgm.s.cHandyPages, RT_ELEMENTS(pVM->pgm.s.aHandyPages), VM_FF_IS_SET(pVM, VM_FF_PGM_NO_MEMORY) ));
681	#ifdef IN_RING3
682	int rc = PGMR3PhysAllocateHandyPages(pVM);
683	#else
684	int rc = VMMRZCallRing3NoCpu(pVM, VMMCALLRING3_PGM_ALLOCATE_HANDY_PAGES, 0);
685	#endif
686	if (RT_UNLIKELY(rc != VINF_SUCCESS))
687	{
688	if (RT_FAILURE(rc))
689	return rc;
690	AssertMsgReturn(rc == VINF_EM_NO_MEMORY, ("%Rrc\n", rc), VERR_IPE_UNEXPECTED_INFO_STATUS);
691	if (!pVM->pgm.s.cHandyPages)
692	{
693	LogRel(("PGM: no more handy pages!\n"));
694	return VERR_EM_NO_MEMORY;
695	}
696	Assert(VM_FF_IS_SET(pVM, VM_FF_PGM_NEED_HANDY_PAGES));
697	Assert(VM_FF_IS_SET(pVM, VM_FF_PGM_NO_MEMORY));
698	#ifdef IN_RING3
699	# ifdef VBOX_WITH_REM
700	REMR3NotifyFF(pVM);
701	# endif
702	#else
703	VMCPU_FF_SET(VMMGetCpu(pVM), VMCPU_FF_TO_R3); /* paranoia */
704	#endif
705	}
706	AssertMsgReturn( pVM->pgm.s.cHandyPages > 0
707	&& pVM->pgm.s.cHandyPages <= RT_ELEMENTS(pVM->pgm.s.aHandyPages),
708	("%u\n", pVM->pgm.s.cHandyPages),
709	VERR_PGM_HANDY_PAGE_IPE);
710	}
711	else
712	{
713	if (pVM->pgm.s.cHandyPages <= PGM_HANDY_PAGES_SET_FF)
714	VM_FF_SET(pVM, VM_FF_PGM_NEED_HANDY_PAGES);
715	#ifndef IN_RING3
716	if (pVM->pgm.s.cHandyPages <= PGM_HANDY_PAGES_RZ_TO_R3)
717	{
718	Log(("PGM: VM_FF_TO_R3 - cHandyPages=%u out of %u\n", pVM->pgm.s.cHandyPages, RT_ELEMENTS(pVM->pgm.s.aHandyPages)));
719	VMCPU_FF_SET(VMMGetCpu(pVM), VMCPU_FF_TO_R3);
720	}
721	#endif
722	}
723	}
724
725	return VINF_SUCCESS;
726	}
727
728
729
730	/**
731	* Replace a zero or shared page with new page that we can write to.
732	*
733	* @returns The following VBox status codes.
734	* @retval VINF_SUCCESS on success, pPage is modified.
735	* @retval VINF_PGM_SYNC_CR3 on success and a page pool flush is pending.
736	* @retval VERR_EM_NO_MEMORY if we're totally out of memory.
737	*
738	* @todo Propagate VERR_EM_NO_MEMORY up the call tree.
739	*
740	* @param pVM The cross context VM structure.
741	* @param pPage The physical page tracking structure. This will
742	* be modified on success.
743	* @param GCPhys The address of the page.
744	*
745	* @remarks Must be called from within the PGM critical section. It may
746	* nip back to ring-3/0 in some cases.
747	*
748	* @remarks This function shouldn't really fail, however if it does
749	* it probably means we've screwed up the size of handy pages and/or
750	* the low-water mark. Or, that some device I/O is causing a lot of
751	* pages to be allocated while while the host is in a low-memory
752	* condition. This latter should be handled elsewhere and in a more
753	* controlled manner, it's on the @bugref{3170} todo list...
754	*/
755	int pgmPhysAllocPage(PVM pVM, PPGMPAGE pPage, RTGCPHYS GCPhys)
756	{
757	LogFlow(("pgmPhysAllocPage: %R[pgmpage] %RGp\n", pPage, GCPhys));
758
759	/*
760	* Prereqs.
761	*/
762	PGM_LOCK_ASSERT_OWNER(pVM);
763	AssertMsg(PGM_PAGE_IS_ZERO(pPage) \|\| PGM_PAGE_IS_SHARED(pPage), ("%R[pgmpage] %RGp\n", pPage, GCPhys));
764	Assert(!PGM_PAGE_IS_MMIO_OR_ALIAS(pPage));
765
766	# ifdef PGM_WITH_LARGE_PAGES
767	/*
768	* Try allocate a large page if applicable.
769	*/
770	if ( PGMIsUsingLargePages(pVM)
771	&& PGM_PAGE_GET_TYPE(pPage) == PGMPAGETYPE_RAM
772	&& !VM_IS_NEM_ENABLED(pVM)) /** @todo NEM: Implement large pages support. */
773	{
774	RTGCPHYS GCPhysBase = GCPhys & X86_PDE2M_PAE_PG_MASK;
775	PPGMPAGE pBasePage;
776
777	int rc = pgmPhysGetPageEx(pVM, GCPhysBase, &pBasePage);
778	AssertRCReturn(rc, rc); /* paranoia; can't happen. */
779	if (PGM_PAGE_GET_PDE_TYPE(pBasePage) == PGM_PAGE_PDE_TYPE_DONTCARE)
780	{
781	rc = pgmPhysAllocLargePage(pVM, GCPhys);
782	if (rc == VINF_SUCCESS)
783	return rc;
784	}
785	/* Mark the base as type page table, so we don't check over and over again. */
786	PGM_PAGE_SET_PDE_TYPE(pVM, pBasePage, PGM_PAGE_PDE_TYPE_PT);
787
788	/* fall back to 4KB pages. */
789	}
790	# endif
791
792	/*
793	* Flush any shadow page table mappings of the page.
794	* When VBOX_WITH_NEW_LAZY_PAGE_ALLOC isn't defined, there shouldn't be any.
795	*/
796	bool fFlushTLBs = false;
797	int rc = pgmPoolTrackUpdateGCPhys(pVM, GCPhys, pPage, true /fFlushTLBs/, &fFlushTLBs);
798	AssertMsgReturn(rc == VINF_SUCCESS \|\| rc == VINF_PGM_SYNC_CR3, ("%Rrc\n", rc), RT_FAILURE(rc) ? rc : VERR_IPE_UNEXPECTED_STATUS);
799
800	/*
801	* Ensure that we've got a page handy, take it and use it.
802	*/
803	int rc2 = pgmPhysEnsureHandyPage(pVM);
804	if (RT_FAILURE(rc2))
805	{
806	if (fFlushTLBs)
807	PGM_INVL_ALL_VCPU_TLBS(pVM);
808	Assert(rc2 == VERR_EM_NO_MEMORY);
809	return rc2;
810	}
811	/* re-assert preconditions since pgmPhysEnsureHandyPage may do a context switch. */
812	PGM_LOCK_ASSERT_OWNER(pVM);
813	AssertMsg(PGM_PAGE_IS_ZERO(pPage) \|\| PGM_PAGE_IS_SHARED(pPage), ("%R[pgmpage] %RGp\n", pPage, GCPhys));
814	Assert(!PGM_PAGE_IS_MMIO_OR_ALIAS(pPage));
815
816	uint32_t iHandyPage = --pVM->pgm.s.cHandyPages;
817	AssertMsg(iHandyPage < RT_ELEMENTS(pVM->pgm.s.aHandyPages), ("%d\n", iHandyPage));
818	Assert(pVM->pgm.s.aHandyPages[iHandyPage].HCPhysGCPhys != NIL_RTHCPHYS);
819	Assert(!(pVM->pgm.s.aHandyPages[iHandyPage].HCPhysGCPhys & ~X86_PTE_PAE_PG_MASK));
820	Assert(pVM->pgm.s.aHandyPages[iHandyPage].idPage != NIL_GMM_PAGEID);
821	Assert(pVM->pgm.s.aHandyPages[iHandyPage].idSharedPage == NIL_GMM_PAGEID);
822
823	/*
824	* There are one or two action to be taken the next time we allocate handy pages:
825	* - Tell the GMM (global memory manager) what the page is being used for.
826	* (Speeds up replacement operations - sharing and defragmenting.)
827	* - If the current backing is shared, it must be freed.
828	*/
829	const RTHCPHYS HCPhys = pVM->pgm.s.aHandyPages[iHandyPage].HCPhysGCPhys;
830	pVM->pgm.s.aHandyPages[iHandyPage].HCPhysGCPhys = GCPhys & ~(RTGCPHYS)PAGE_OFFSET_MASK;
831
832	void const *pvSharedPage = NULL;
833	if (PGM_PAGE_IS_SHARED(pPage))
834	{
835	/* Mark this shared page for freeing/dereferencing. */
836	pVM->pgm.s.aHandyPages[iHandyPage].idSharedPage = PGM_PAGE_GET_PAGEID(pPage);
837	Assert(PGM_PAGE_GET_PAGEID(pPage) != NIL_GMM_PAGEID);
838
839	Log(("PGM: Replaced shared page %#x at %RGp with %#x / %RHp\n", PGM_PAGE_GET_PAGEID(pPage),
840	GCPhys, pVM->pgm.s.aHandyPages[iHandyPage].idPage, HCPhys));
841	STAM_COUNTER_INC(&pVM->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,PageReplaceShared));
842	pVM->pgm.s.cSharedPages--;
843
844	/* Grab the address of the page so we can make a copy later on. (safe) */
845	rc = pgmPhysPageMapReadOnly(pVM, pPage, GCPhys, &pvSharedPage);
846	AssertRC(rc);
847	}
848	else
849	{
850	Log2(("PGM: Replaced zero page %RGp with %#x / %RHp\n", GCPhys, pVM->pgm.s.aHandyPages[iHandyPage].idPage, HCPhys));
851	STAM_COUNTER_INC(&pVM->pgm.s.CTX_SUFF(pStats)->StatRZPageReplaceZero);
852	pVM->pgm.s.cZeroPages--;
853	}
854
855	/*
856	* Do the PGMPAGE modifications.
857	*/
858	pVM->pgm.s.cPrivatePages++;
859	PGM_PAGE_SET_HCPHYS(pVM, pPage, HCPhys);
860	PGM_PAGE_SET_PAGEID(pVM, pPage, pVM->pgm.s.aHandyPages[iHandyPage].idPage);
861	PGM_PAGE_SET_STATE(pVM, pPage, PGM_PAGE_STATE_ALLOCATED);
862	PGM_PAGE_SET_PDE_TYPE(pVM, pPage, PGM_PAGE_PDE_TYPE_PT);
863	pgmPhysInvalidatePageMapTLBEntry(pVM, GCPhys);
864
865	/* Copy the shared page contents to the replacement page. */
866	if (pvSharedPage)
867	{
868	/* Get the virtual address of the new page. */
869	PGMPAGEMAPLOCK PgMpLck;
870	void *pvNewPage;
871	rc = pgmPhysGCPhys2CCPtrInternal(pVM, pPage, GCPhys, &pvNewPage, &PgMpLck); AssertRC(rc);
872	if (RT_SUCCESS(rc))
873	{
874	memcpy(pvNewPage, pvSharedPage, PAGE_SIZE); /** @todo todo write ASMMemCopyPage */
875	pgmPhysReleaseInternalPageMappingLock(pVM, &PgMpLck);
876	}
877	}
878
879	if ( fFlushTLBs
880	&& rc != VINF_PGM_GCPHYS_ALIASED)
881	PGM_INVL_ALL_VCPU_TLBS(pVM);
882
883	#ifndef IN_RC
884	/*
885	* Notify NEM about the mapping change for this page.
886	*
887	* Note! Shadow ROM pages are complicated as they can definitely be
888	* allocated while not visible, so play safe.
889	*/
890	if (VM_IS_NEM_ENABLED(pVM))
891	{
892	PGMPAGETYPE enmType = (PGMPAGETYPE)PGM_PAGE_GET_TYPE(pPage);
893	if ( enmType != PGMPAGETYPE_ROM_SHADOW
894	\|\| pgmPhysGetPage(pVM, GCPhys) == pPage)
895	{
896	uint8_t u2State = PGM_PAGE_GET_NEM_STATE(pPage);
897	rc2 = NEMHCNotifyPhysPageAllocated(pVM, GCPhys & ~(RTGCPHYS)X86_PAGE_OFFSET_MASK, HCPhys,
898	pgmPhysPageCalcNemProtection(pPage, enmType), enmType, &u2State);
899	if (RT_SUCCESS(rc))
900	PGM_PAGE_SET_NEM_STATE(pPage, u2State);
901	else
902	rc = rc2;
903	}
904	}
905	#endif
906
907	return rc;
908	}
909
910	#ifdef PGM_WITH_LARGE_PAGES
911
912	/**
913	* Replace a 2 MB range of zero pages with new pages that we can write to.
914	*
915	* @returns The following VBox status codes.
916	* @retval VINF_SUCCESS on success, pPage is modified.
917	* @retval VINF_PGM_SYNC_CR3 on success and a page pool flush is pending.
918	* @retval VERR_EM_NO_MEMORY if we're totally out of memory.
919	*
920	* @todo Propagate VERR_EM_NO_MEMORY up the call tree.
921	*
922	* @param pVM The cross context VM structure.
923	* @param GCPhys The address of the page.
924	*
925	* @remarks Must be called from within the PGM critical section. It may
926	* nip back to ring-3/0 in some cases.
927	*/
928	int pgmPhysAllocLargePage(PVM pVM, RTGCPHYS GCPhys)
929	{
930	RTGCPHYS GCPhysBase = GCPhys & X86_PDE2M_PAE_PG_MASK;
931	LogFlow(("pgmPhysAllocLargePage: %RGp base %RGp\n", GCPhys, GCPhysBase));
932	Assert(!VM_IS_NEM_ENABLED(pVM)); /** @todo NEM: Large page support. */
933
934	/*
935	* Prereqs.
936	*/
937	PGM_LOCK_ASSERT_OWNER(pVM);
938	Assert(PGMIsUsingLargePages(pVM));
939
940	PPGMPAGE pFirstPage;
941	int rc = pgmPhysGetPageEx(pVM, GCPhysBase, &pFirstPage);
942	if ( RT_SUCCESS(rc)
943	&& PGM_PAGE_GET_TYPE(pFirstPage) == PGMPAGETYPE_RAM)
944	{
945	unsigned uPDEType = PGM_PAGE_GET_PDE_TYPE(pFirstPage);
946
947	/* Don't call this function for already allocated pages. */
948	Assert(uPDEType != PGM_PAGE_PDE_TYPE_PDE);
949
950	if ( uPDEType == PGM_PAGE_PDE_TYPE_DONTCARE
951	&& PGM_PAGE_GET_STATE(pFirstPage) == PGM_PAGE_STATE_ZERO)
952	{
953	/* Lazy approach: check all pages in the 2 MB range.
954	* The whole range must be ram and unallocated. */
955	GCPhys = GCPhysBase;
956	unsigned iPage;
957	for (iPage = 0; iPage < _2M/PAGE_SIZE; iPage++)
958	{
959	PPGMPAGE pSubPage;
960	rc = pgmPhysGetPageEx(pVM, GCPhys, &pSubPage);
961	if ( RT_FAILURE(rc)
962	\|\| PGM_PAGE_GET_TYPE(pSubPage) != PGMPAGETYPE_RAM /* Anything other than ram implies monitoring. */
963	\|\| PGM_PAGE_GET_STATE(pSubPage) != PGM_PAGE_STATE_ZERO) /* Allocated, monitored or shared means we can't use a large page here */
964	{
965	LogFlow(("Found page %RGp with wrong attributes (type=%d; state=%d); cancel check. rc=%d\n", GCPhys, PGM_PAGE_GET_TYPE(pSubPage), PGM_PAGE_GET_STATE(pSubPage), rc));
966	break;
967	}
968	Assert(PGM_PAGE_GET_PDE_TYPE(pSubPage) == PGM_PAGE_PDE_TYPE_DONTCARE);
969	GCPhys += PAGE_SIZE;
970	}
971	if (iPage != _2M/PAGE_SIZE)
972	{
973	/* Failed. Mark as requiring a PT so we don't check the whole thing again in the future. */
974	STAM_REL_COUNTER_INC(&pVM->pgm.s.StatLargePageRefused);
975	PGM_PAGE_SET_PDE_TYPE(pVM, pFirstPage, PGM_PAGE_PDE_TYPE_PT);
976	return VERR_PGM_INVALID_LARGE_PAGE_RANGE;
977	}
978
979	/*
980	* Do the allocation.
981	*/
982	# ifdef IN_RING3
983	rc = PGMR3PhysAllocateLargeHandyPage(pVM, GCPhysBase);
984	# else
985	rc = VMMRZCallRing3NoCpu(pVM, VMMCALLRING3_PGM_ALLOCATE_LARGE_HANDY_PAGE, GCPhysBase);
986	# endif
987	if (RT_SUCCESS(rc))
988	{
989	Assert(PGM_PAGE_GET_STATE(pFirstPage) == PGM_PAGE_STATE_ALLOCATED);
990	pVM->pgm.s.cLargePages++;
991	return VINF_SUCCESS;
992	}
993
994	/* If we fail once, it most likely means the host's memory is too
995	fragmented; don't bother trying again. */
996	LogFlow(("pgmPhysAllocLargePage failed with %Rrc\n", rc));
997	PGMSetLargePageUsage(pVM, false);
998	return rc;
999	}
1000	}
1001	return VERR_PGM_INVALID_LARGE_PAGE_RANGE;
1002	}
1003
1004
1005	/**
1006	* Recheck the entire 2 MB range to see if we can use it again as a large page.
1007	*
1008	* @returns The following VBox status codes.
1009	* @retval VINF_SUCCESS on success, the large page can be used again
1010	* @retval VERR_PGM_INVALID_LARGE_PAGE_RANGE if it can't be reused
1011	*
1012	* @param pVM The cross context VM structure.
1013	* @param GCPhys The address of the page.
1014	* @param pLargePage Page structure of the base page
1015	*/
1016	int pgmPhysRecheckLargePage(PVM pVM, RTGCPHYS GCPhys, PPGMPAGE pLargePage)
1017	{
1018	STAM_REL_COUNTER_INC(&pVM->pgm.s.StatLargePageRecheck);
1019
1020	Assert(!VM_IS_NEM_ENABLED(pVM)); /** @todo NEM: Large page support. */
1021
1022	GCPhys &= X86_PDE2M_PAE_PG_MASK;
1023
1024	/* Check the base page. */
1025	Assert(PGM_PAGE_GET_PDE_TYPE(pLargePage) == PGM_PAGE_PDE_TYPE_PDE_DISABLED);
1026	if ( PGM_PAGE_GET_STATE(pLargePage) != PGM_PAGE_STATE_ALLOCATED
1027	\|\| PGM_PAGE_GET_TYPE(pLargePage) != PGMPAGETYPE_RAM
1028	\|\| PGM_PAGE_GET_HNDL_PHYS_STATE(pLargePage) != PGM_PAGE_HNDL_PHYS_STATE_NONE)
1029	{
1030	LogFlow(("pgmPhysRecheckLargePage: checks failed for base page %x %x %x\n", PGM_PAGE_GET_STATE(pLargePage), PGM_PAGE_GET_TYPE(pLargePage), PGM_PAGE_GET_HNDL_PHYS_STATE(pLargePage)));
1031	return VERR_PGM_INVALID_LARGE_PAGE_RANGE;
1032	}
1033
1034	STAM_PROFILE_START(&pVM->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,IsValidLargePage), a);
1035	/* Check all remaining pages in the 2 MB range. */
1036	unsigned i;
1037	GCPhys += PAGE_SIZE;
1038	for (i = 1; i < _2M/PAGE_SIZE; i++)
1039	{
1040	PPGMPAGE pPage;
1041	int rc = pgmPhysGetPageEx(pVM, GCPhys, &pPage);
1042	AssertRCBreak(rc);
1043
1044	if ( PGM_PAGE_GET_STATE(pPage) != PGM_PAGE_STATE_ALLOCATED
1045	\|\| PGM_PAGE_GET_PDE_TYPE(pPage) != PGM_PAGE_PDE_TYPE_PDE
1046	\|\| PGM_PAGE_GET_TYPE(pPage) != PGMPAGETYPE_RAM
1047	\|\| PGM_PAGE_GET_HNDL_PHYS_STATE(pPage) != PGM_PAGE_HNDL_PHYS_STATE_NONE)
1048	{
1049	LogFlow(("pgmPhysRecheckLargePage: checks failed for page %d; %x %x %x\n", i, PGM_PAGE_GET_STATE(pPage), PGM_PAGE_GET_TYPE(pPage), PGM_PAGE_GET_HNDL_PHYS_STATE(pPage)));
1050	break;
1051	}
1052
1053	GCPhys += PAGE_SIZE;
1054	}
1055	STAM_PROFILE_STOP(&pVM->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,IsValidLargePage), a);
1056
1057	if (i == _2M/PAGE_SIZE)
1058	{
1059	PGM_PAGE_SET_PDE_TYPE(pVM, pLargePage, PGM_PAGE_PDE_TYPE_PDE);
1060	pVM->pgm.s.cLargePagesDisabled--;
1061	Log(("pgmPhysRecheckLargePage: page %RGp can be reused!\n", GCPhys - _2M));
1062	return VINF_SUCCESS;
1063	}
1064
1065	return VERR_PGM_INVALID_LARGE_PAGE_RANGE;
1066	}
1067
1068	#endif /* PGM_WITH_LARGE_PAGES */
1069
1070
1071	/**
1072	* Deal with a write monitored page.
1073	*
1074	* @returns VBox strict status code.
1075	*
1076	* @param pVM The cross context VM structure.
1077	* @param pPage The physical page tracking structure.
1078	* @param GCPhys The guest physical address of the page.
1079	* PGMPhysReleasePageMappingLock() passes NIL_RTGCPHYS in a
1080	* very unlikely situation where it is okay that we let NEM
1081	* fix the page access in a lazy fasion.
1082	*
1083	* @remarks Called from within the PGM critical section.
1084	*/
1085	void pgmPhysPageMakeWriteMonitoredWritable(PVM pVM, PPGMPAGE pPage, RTGCPHYS GCPhys)
1086	{
1087	Assert(PGM_PAGE_GET_STATE(pPage) == PGM_PAGE_STATE_WRITE_MONITORED);
1088	PGM_PAGE_SET_WRITTEN_TO(pVM, pPage);
1089	PGM_PAGE_SET_STATE(pVM, pPage, PGM_PAGE_STATE_ALLOCATED);
1090	Assert(pVM->pgm.s.cMonitoredPages > 0);
1091	pVM->pgm.s.cMonitoredPages--;
1092	pVM->pgm.s.cWrittenToPages++;
1093
1094	#ifndef IN_RC
1095	/*
1096	* Notify NEM about the protection change so we won't spin forever.
1097	*
1098	* Note! NEM need to be handle to lazily correct page protection as we cannot
1099	* really get it 100% right here it seems. The page pool does this too.
1100	*/
1101	if (VM_IS_NEM_ENABLED(pVM) && GCPhys != NIL_RTGCPHYS)
1102	{
1103	uint8_t u2State = PGM_PAGE_GET_NEM_STATE(pPage);
1104	PGMPAGETYPE enmType = (PGMPAGETYPE)PGM_PAGE_GET_TYPE(pPage);
1105	NEMHCNotifyPhysPageProtChanged(pVM, GCPhys, PGM_PAGE_GET_HCPHYS(pPage),
1106	pgmPhysPageCalcNemProtection(pPage, enmType), enmType, &u2State);
1107	PGM_PAGE_SET_NEM_STATE(pPage, u2State);
1108	}
1109	#else
1110	RT_NOREF(GCPhys);
1111	#endif
1112	}
1113
1114
1115	/**
1116	* Deal with pages that are not writable, i.e. not in the ALLOCATED state.
1117	*
1118	* @returns VBox strict status code.
1119	* @retval VINF_SUCCESS on success.
1120	* @retval VINF_PGM_SYNC_CR3 on success and a page pool flush is pending.
1121	* @retval VERR_PGM_PHYS_PAGE_RESERVED it it's a valid page but has no physical backing.
1122	*
1123	* @param pVM The cross context VM structure.
1124	* @param pPage The physical page tracking structure.
1125	* @param GCPhys The address of the page.
1126	*
1127	* @remarks Called from within the PGM critical section.
1128	*/
1129	int pgmPhysPageMakeWritable(PVM pVM, PPGMPAGE pPage, RTGCPHYS GCPhys)
1130	{
1131	PGM_LOCK_ASSERT_OWNER(pVM);
1132	switch (PGM_PAGE_GET_STATE(pPage))
1133	{
1134	case PGM_PAGE_STATE_WRITE_MONITORED:
1135	pgmPhysPageMakeWriteMonitoredWritable(pVM, pPage, GCPhys);
1136	RT_FALL_THRU();
1137	default: /* to shut up GCC */
1138	case PGM_PAGE_STATE_ALLOCATED:
1139	return VINF_SUCCESS;
1140
1141	/*
1142	* Zero pages can be dummy pages for MMIO or reserved memory,
1143	* so we need to check the flags before joining cause with
1144	* shared page replacement.
1145	*/
1146	case PGM_PAGE_STATE_ZERO:
1147	if (PGM_PAGE_IS_MMIO(pPage))
1148	return VERR_PGM_PHYS_PAGE_RESERVED;
1149	RT_FALL_THRU();
1150	case PGM_PAGE_STATE_SHARED:
1151	return pgmPhysAllocPage(pVM, pPage, GCPhys);
1152
1153	/* Not allowed to write to ballooned pages. */
1154	case PGM_PAGE_STATE_BALLOONED:
1155	return VERR_PGM_PHYS_PAGE_BALLOONED;
1156	}
1157	}
1158
1159
1160	/**
1161	* Internal usage: Map the page specified by its GMM ID.
1162	*
1163	* This is similar to pgmPhysPageMap
1164	*
1165	* @returns VBox status code.
1166	*
1167	* @param pVM The cross context VM structure.
1168	* @param idPage The Page ID.
1169	* @param HCPhys The physical address (for RC).
1170	* @param ppv Where to store the mapping address.
1171	*
1172	* @remarks Called from within the PGM critical section. The mapping is only
1173	* valid while you are inside this section.
1174	*/
1175	int pgmPhysPageMapByPageID(PVM pVM, uint32_t idPage, RTHCPHYS HCPhys, void **ppv)
1176	{
1177	/*
1178	* Validation.
1179	*/
1180	PGM_LOCK_ASSERT_OWNER(pVM);
1181	AssertReturn(HCPhys && !(HCPhys & PAGE_OFFSET_MASK), VERR_INVALID_PARAMETER);
1182	const uint32_t idChunk = idPage >> GMM_CHUNKID_SHIFT;
1183	AssertReturn(idChunk != NIL_GMM_CHUNKID, VERR_INVALID_PARAMETER);
1184
1185	#if defined(IN_RC) \|\| defined(VBOX_WITH_2X_4GB_ADDR_SPACE_IN_R0)
1186	/*
1187	* Map it by HCPhys.
1188	*/
1189	return pgmRZDynMapHCPageInlined(VMMGetCpu(pVM), HCPhys, ppv RTLOG_COMMA_SRC_POS);
1190
1191	#else
1192	/*
1193	* Find/make Chunk TLB entry for the mapping chunk.
1194	*/
1195	PPGMCHUNKR3MAP pMap;
1196	PPGMCHUNKR3MAPTLBE pTlbe = &pVM->pgm.s.ChunkR3Map.Tlb.aEntries[PGM_CHUNKR3MAPTLB_IDX(idChunk)];
1197	if (pTlbe->idChunk == idChunk)
1198	{
1199	STAM_COUNTER_INC(&pVM->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,ChunkR3MapTlbHits));
1200	pMap = pTlbe->pChunk;
1201	}
1202	else
1203	{
1204	STAM_COUNTER_INC(&pVM->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,ChunkR3MapTlbMisses));
1205
1206	/*
1207	* Find the chunk, map it if necessary.
1208	*/
1209	pMap = (PPGMCHUNKR3MAP)RTAvlU32Get(&pVM->pgm.s.ChunkR3Map.pTree, idChunk);
1210	if (pMap)
1211	pMap->iLastUsed = pVM->pgm.s.ChunkR3Map.iNow;
1212	else
1213	{
1214	# ifdef IN_RING0
1215	int rc = VMMRZCallRing3NoCpu(pVM, VMMCALLRING3_PGM_MAP_CHUNK, idChunk);
1216	AssertRCReturn(rc, rc);
1217	pMap = (PPGMCHUNKR3MAP)RTAvlU32Get(&pVM->pgm.s.ChunkR3Map.pTree, idChunk);
1218	Assert(pMap);
1219	# else
1220	int rc = pgmR3PhysChunkMap(pVM, idChunk, &pMap);
1221	if (RT_FAILURE(rc))
1222	return rc;
1223	# endif
1224	}
1225
1226	/*
1227	* Enter it into the Chunk TLB.
1228	*/
1229	pTlbe->idChunk = idChunk;
1230	pTlbe->pChunk = pMap;
1231	}
1232
1233	ppv = (uint8_t )pMap->pv + ((idPage &GMM_PAGEID_IDX_MASK) << PAGE_SHIFT);
1234	return VINF_SUCCESS;
1235	#endif
1236	}
1237
1238
1239	/**
1240	* Maps a page into the current virtual address space so it can be accessed.
1241	*
1242	* @returns VBox status code.
1243	* @retval VINF_SUCCESS on success.
1244	* @retval VERR_PGM_PHYS_PAGE_RESERVED it it's a valid page but has no physical backing.
1245	*
1246	* @param pVM The cross context VM structure.
1247	* @param pPage The physical page tracking structure.
1248	* @param GCPhys The address of the page.
1249	* @param ppMap Where to store the address of the mapping tracking structure.
1250	* @param ppv Where to store the mapping address of the page. The page
1251	* offset is masked off!
1252	*
1253	* @remarks Called from within the PGM critical section.
1254	*/
1255	static int pgmPhysPageMapCommon(PVM pVM, PPGMPAGE pPage, RTGCPHYS GCPhys, PPPGMPAGEMAP ppMap, void **ppv)
1256	{
1257	PGM_LOCK_ASSERT_OWNER(pVM);
1258	NOREF(GCPhys);
1259
1260	#if defined(IN_RC) \|\| defined(VBOX_WITH_2X_4GB_ADDR_SPACE_IN_R0)
1261	/*
1262	* Just some sketchy GC/R0-darwin code.
1263	*/
1264	*ppMap = NULL;
1265	RTHCPHYS HCPhys = PGM_PAGE_GET_HCPHYS(pPage);
1266	Assert(HCPhys != pVM->pgm.s.HCPhysZeroPg);
1267	pgmRZDynMapHCPageInlined(VMMGetCpu(pVM), HCPhys, ppv RTLOG_COMMA_SRC_POS);
1268	return VINF_SUCCESS;
1269
1270	#else /* IN_RING3 \|\| IN_RING0 */
1271
1272
1273	/*
1274	* Special cases: MMIO2, ZERO and specially aliased MMIO pages.
1275	*/
1276	if ( PGM_PAGE_GET_TYPE(pPage) == PGMPAGETYPE_MMIO2
1277	\|\| PGM_PAGE_GET_TYPE(pPage) == PGMPAGETYPE_MMIO2_ALIAS_MMIO)
1278	{
1279	/* Decode the page id to a page in a MMIO2 ram range. */
1280	uint8_t idMmio2 = PGM_MMIO2_PAGEID_GET_MMIO2_ID(PGM_PAGE_GET_PAGEID(pPage));
1281	uint32_t iPage = PGM_MMIO2_PAGEID_GET_IDX(PGM_PAGE_GET_PAGEID(pPage));
1282	AssertLogRelMsgReturn((uint8_t)(idMmio2 - 1U) < RT_ELEMENTS(pVM->pgm.s.CTX_SUFF(apMmio2Ranges)),
1283	("idMmio2=%u size=%u type=%u GCPHys=%#RGp Id=%u State=%u", idMmio2,
1284	RT_ELEMENTS(pVM->pgm.s.CTX_SUFF(apMmio2Ranges)), PGM_PAGE_GET_TYPE(pPage), GCPhys,
1285	pPage->s.idPage, pPage->s.uStateY),
1286	VERR_PGM_PHYS_PAGE_MAP_MMIO2_IPE);
1287	PPGMREGMMIORANGE pMmio2Range = pVM->pgm.s.CTX_SUFF(apMmio2Ranges)[idMmio2 - 1];
1288	AssertLogRelReturn(pMmio2Range, VERR_PGM_PHYS_PAGE_MAP_MMIO2_IPE);
1289	AssertLogRelReturn(pMmio2Range->idMmio2 == idMmio2, VERR_PGM_PHYS_PAGE_MAP_MMIO2_IPE);
1290	AssertLogRelReturn(iPage < (pMmio2Range->RamRange.cb >> PAGE_SHIFT), VERR_PGM_PHYS_PAGE_MAP_MMIO2_IPE);
1291	ppv = (uint8_t )pMmio2Range->RamRange.pvR3 + ((uintptr_t)iPage << PAGE_SHIFT);
1292	*ppMap = NULL;
1293	return VINF_SUCCESS;
1294	}
1295
1296	const uint32_t idChunk = PGM_PAGE_GET_CHUNKID(pPage);
1297	if (idChunk == NIL_GMM_CHUNKID)
1298	{
1299	AssertMsgReturn(PGM_PAGE_GET_PAGEID(pPage) == NIL_GMM_PAGEID, ("pPage=%R[pgmpage]\n", pPage),
1300	VERR_PGM_PHYS_PAGE_MAP_IPE_1);
1301	if (!PGM_PAGE_IS_SPECIAL_ALIAS_MMIO(pPage))
1302	{
1303	AssertMsgReturn(PGM_PAGE_IS_ZERO(pPage), ("pPage=%R[pgmpage]\n", pPage),
1304	VERR_PGM_PHYS_PAGE_MAP_IPE_3);
1305	AssertMsgReturn(PGM_PAGE_GET_HCPHYS(pPage)== pVM->pgm.s.HCPhysZeroPg, ("pPage=%R[pgmpage]\n", pPage),
1306	VERR_PGM_PHYS_PAGE_MAP_IPE_4);
1307	*ppv = pVM->pgm.s.CTXALLSUFF(pvZeroPg);
1308	}
1309	else
1310	# ifdef VBOX_WITH_2ND_IEM_STEP
1311	*ppv = pVM->pgm.s.CTXALLSUFF(pvZeroPg);
1312	# else
1313	{
1314	/* This kind of screws up the TLB entry if accessed from a different section afterwards. */
1315	static uint8_t s_abPlayItSafe[0x10002]; / I don't dare return the zero page at the moment. */
1316	ppv = (uint8_t )((uintptr_t)&s_abPlayItSafe[0x1000] & ~(uintptr_t)0xfff);
1317	}
1318	# endif
1319	*ppMap = NULL;
1320	return VINF_SUCCESS;
1321	}
1322
1323	/*
1324	* Find/make Chunk TLB entry for the mapping chunk.
1325	*/
1326	PPGMCHUNKR3MAP pMap;
1327	PPGMCHUNKR3MAPTLBE pTlbe = &pVM->pgm.s.ChunkR3Map.Tlb.aEntries[PGM_CHUNKR3MAPTLB_IDX(idChunk)];
1328	if (pTlbe->idChunk == idChunk)
1329	{
1330	STAM_COUNTER_INC(&pVM->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,ChunkR3MapTlbHits));
1331	pMap = pTlbe->pChunk;
1332	AssertPtr(pMap->pv);
1333	}
1334	else
1335	{
1336	STAM_COUNTER_INC(&pVM->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,ChunkR3MapTlbMisses));
1337
1338	/*
1339	* Find the chunk, map it if necessary.
1340	*/
1341	pMap = (PPGMCHUNKR3MAP)RTAvlU32Get(&pVM->pgm.s.ChunkR3Map.pTree, idChunk);
1342	if (pMap)
1343	{
1344	AssertPtr(pMap->pv);
1345	pMap->iLastUsed = pVM->pgm.s.ChunkR3Map.iNow;
1346	}
1347	else
1348	{
1349	#ifdef IN_RING0
1350	int rc = VMMRZCallRing3NoCpu(pVM, VMMCALLRING3_PGM_MAP_CHUNK, idChunk);
1351	AssertRCReturn(rc, rc);
1352	pMap = (PPGMCHUNKR3MAP)RTAvlU32Get(&pVM->pgm.s.ChunkR3Map.pTree, idChunk);
1353	Assert(pMap);
1354	#else
1355	int rc = pgmR3PhysChunkMap(pVM, idChunk, &pMap);
1356	if (RT_FAILURE(rc))
1357	return rc;
1358	#endif
1359	AssertPtr(pMap->pv);
1360	}
1361
1362	/*
1363	* Enter it into the Chunk TLB.
1364	*/
1365	pTlbe->idChunk = idChunk;
1366	pTlbe->pChunk = pMap;
1367	}
1368
1369	ppv = (uint8_t )pMap->pv + (PGM_PAGE_GET_PAGE_IN_CHUNK(pPage) << PAGE_SHIFT);
1370	*ppMap = pMap;
1371	return VINF_SUCCESS;
1372	#endif /* IN_RING3 */
1373	}
1374
1375
1376	/**
1377	* Combination of pgmPhysPageMakeWritable and pgmPhysPageMapWritable.
1378	*
1379	* This is typically used is paths where we cannot use the TLB methods (like ROM
1380	* pages) or where there is no point in using them since we won't get many hits.
1381	*
1382	* @returns VBox strict status code.
1383	* @retval VINF_SUCCESS on success.
1384	* @retval VINF_PGM_SYNC_CR3 on success and a page pool flush is pending.
1385	* @retval VERR_PGM_PHYS_PAGE_RESERVED it it's a valid page but has no physical backing.
1386	*
1387	* @param pVM The cross context VM structure.
1388	* @param pPage The physical page tracking structure.
1389	* @param GCPhys The address of the page.
1390	* @param ppv Where to store the mapping address of the page. The page
1391	* offset is masked off!
1392	*
1393	* @remarks Called from within the PGM critical section. The mapping is only
1394	* valid while you are inside section.
1395	*/
1396	int pgmPhysPageMakeWritableAndMap(PVM pVM, PPGMPAGE pPage, RTGCPHYS GCPhys, void **ppv)
1397	{
1398	int rc = pgmPhysPageMakeWritable(pVM, pPage, GCPhys);
1399	if (RT_SUCCESS(rc))
1400	{
1401	AssertMsg(rc == VINF_SUCCESS \|\| rc == VINF_PGM_SYNC_CR3 /* returned */, ("%Rrc\n", rc));
1402	PPGMPAGEMAP pMapIgnore;
1403	int rc2 = pgmPhysPageMapCommon(pVM, pPage, GCPhys, &pMapIgnore, ppv);
1404	if (RT_FAILURE(rc2)) /* preserve rc */
1405	rc = rc2;
1406	}
1407	return rc;
1408	}
1409
1410
1411	/**
1412	* Maps a page into the current virtual address space so it can be accessed for
1413	* both writing and reading.
1414	*
1415	* This is typically used is paths where we cannot use the TLB methods (like ROM
1416	* pages) or where there is no point in using them since we won't get many hits.
1417	*
1418	* @returns VBox status code.
1419	* @retval VINF_SUCCESS on success.
1420	* @retval VERR_PGM_PHYS_PAGE_RESERVED it it's a valid page but has no physical backing.
1421	*
1422	* @param pVM The cross context VM structure.
1423	* @param pPage The physical page tracking structure. Must be in the
1424	* allocated state.
1425	* @param GCPhys The address of the page.
1426	* @param ppv Where to store the mapping address of the page. The page
1427	* offset is masked off!
1428	*
1429	* @remarks Called from within the PGM critical section. The mapping is only
1430	* valid while you are inside section.
1431	*/
1432	int pgmPhysPageMap(PVM pVM, PPGMPAGE pPage, RTGCPHYS GCPhys, void **ppv)
1433	{
1434	Assert(PGM_PAGE_GET_STATE(pPage) == PGM_PAGE_STATE_ALLOCATED);
1435	PPGMPAGEMAP pMapIgnore;
1436	return pgmPhysPageMapCommon(pVM, pPage, GCPhys, &pMapIgnore, ppv);
1437	}
1438
1439
1440	/**
1441	* Maps a page into the current virtual address space so it can be accessed for
1442	* reading.
1443	*
1444	* This is typically used is paths where we cannot use the TLB methods (like ROM
1445	* pages) or where there is no point in using them since we won't get many hits.
1446	*
1447	* @returns VBox status code.
1448	* @retval VINF_SUCCESS on success.
1449	* @retval VERR_PGM_PHYS_PAGE_RESERVED it it's a valid page but has no physical backing.
1450	*
1451	* @param pVM The cross context VM structure.
1452	* @param pPage The physical page tracking structure.
1453	* @param GCPhys The address of the page.
1454	* @param ppv Where to store the mapping address of the page. The page
1455	* offset is masked off!
1456	*
1457	* @remarks Called from within the PGM critical section. The mapping is only
1458	* valid while you are inside this section.
1459	*/
1460	int pgmPhysPageMapReadOnly(PVM pVM, PPGMPAGE pPage, RTGCPHYS GCPhys, void const **ppv)
1461	{
1462	PPGMPAGEMAP pMapIgnore;
1463	return pgmPhysPageMapCommon(pVM, pPage, GCPhys, &pMapIgnore, (void **)ppv);
1464	}
1465
1466	#if !defined(IN_RC) && !defined(VBOX_WITH_2X_4GB_ADDR_SPACE_IN_R0)
1467
1468	/**
1469	* Load a guest page into the ring-3 physical TLB.
1470	*
1471	* @returns VBox status code.
1472	* @retval VINF_SUCCESS on success
1473	* @retval VERR_PGM_INVALID_GC_PHYSICAL_ADDRESS if it's not a valid physical address.
1474	* @param pPGM The PGM instance pointer.
1475	* @param GCPhys The guest physical address in question.
1476	*/
1477	int pgmPhysPageLoadIntoTlb(PVM pVM, RTGCPHYS GCPhys)
1478	{
1479	PGM_LOCK_ASSERT_OWNER(pVM);
1480
1481	/*
1482	* Find the ram range and page and hand it over to the with-page function.
1483	* 99.8% of requests are expected to be in the first range.
1484	*/
1485	PPGMPAGE pPage = pgmPhysGetPage(pVM, GCPhys);
1486	if (!pPage)
1487	{
1488	STAM_COUNTER_INC(&pVM->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,PageMapTlbMisses));
1489	return VERR_PGM_INVALID_GC_PHYSICAL_ADDRESS;
1490	}
1491
1492	return pgmPhysPageLoadIntoTlbWithPage(pVM, pPage, GCPhys);
1493	}
1494
1495
1496	/**
1497	* Load a guest page into the ring-3 physical TLB.
1498	*
1499	* @returns VBox status code.
1500	* @retval VINF_SUCCESS on success
1501	* @retval VERR_PGM_INVALID_GC_PHYSICAL_ADDRESS if it's not a valid physical address.
1502	*
1503	* @param pVM The cross context VM structure.
1504	* @param pPage Pointer to the PGMPAGE structure corresponding to
1505	* GCPhys.
1506	* @param GCPhys The guest physical address in question.
1507	*/
1508	int pgmPhysPageLoadIntoTlbWithPage(PVM pVM, PPGMPAGE pPage, RTGCPHYS GCPhys)
1509	{
1510	PGM_LOCK_ASSERT_OWNER(pVM);
1511	STAM_COUNTER_INC(&pVM->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,PageMapTlbMisses));
1512
1513	/*
1514	* Map the page.
1515	* Make a special case for the zero page as it is kind of special.
1516	*/
1517	PPGMPAGEMAPTLBE pTlbe = &pVM->pgm.s.CTXSUFF(PhysTlb).aEntries[PGM_PAGEMAPTLB_IDX(GCPhys)];
1518	if ( !PGM_PAGE_IS_ZERO(pPage)
1519	&& !PGM_PAGE_IS_BALLOONED(pPage))
1520	{
1521	void *pv;
1522	PPGMPAGEMAP pMap;
1523	int rc = pgmPhysPageMapCommon(pVM, pPage, GCPhys, &pMap, &pv);
1524	if (RT_FAILURE(rc))
1525	return rc;
1526	pTlbe->pMap = pMap;
1527	pTlbe->pv = pv;
1528	Assert(!((uintptr_t)pTlbe->pv & PAGE_OFFSET_MASK));
1529	}
1530	else
1531	{
1532	AssertMsg(PGM_PAGE_GET_HCPHYS(pPage) == pVM->pgm.s.HCPhysZeroPg, ("%RGp/%R[pgmpage]\n", GCPhys, pPage));
1533	pTlbe->pMap = NULL;
1534	pTlbe->pv = pVM->pgm.s.CTXALLSUFF(pvZeroPg);
1535	}
1536	#ifdef PGM_WITH_PHYS_TLB
1537	if ( PGM_PAGE_GET_TYPE(pPage) < PGMPAGETYPE_ROM_SHADOW
1538	\|\| PGM_PAGE_GET_TYPE(pPage) > PGMPAGETYPE_ROM)
1539	pTlbe->GCPhys = GCPhys & X86_PTE_PAE_PG_MASK;
1540	else
1541	pTlbe->GCPhys = NIL_RTGCPHYS; /* ROM: Problematic because of the two pages. :-/ */
1542	#else
1543	pTlbe->GCPhys = NIL_RTGCPHYS;
1544	#endif
1545	pTlbe->pPage = pPage;
1546	return VINF_SUCCESS;
1547	}
1548
1549	#endif /* !IN_RC && !VBOX_WITH_2X_4GB_ADDR_SPACE_IN_R0 */
1550
1551	/**
1552	* Internal version of PGMPhysGCPhys2CCPtr that expects the caller to
1553	* own the PGM lock and therefore not need to lock the mapped page.
1554	*
1555	* @returns VBox status code.
1556	* @retval VINF_SUCCESS on success.
1557	* @retval VERR_PGM_PHYS_PAGE_RESERVED it it's a valid page but has no physical backing.
1558	* @retval VERR_PGM_INVALID_GC_PHYSICAL_ADDRESS if it's not a valid physical address.
1559	*
1560	* @param pVM The cross context VM structure.
1561	* @param GCPhys The guest physical address of the page that should be mapped.
1562	* @param pPage Pointer to the PGMPAGE structure for the page.
1563	* @param ppv Where to store the address corresponding to GCPhys.
1564	*
1565	* @internal
1566	* @deprecated Use pgmPhysGCPhys2CCPtrInternalEx.
1567	*/
1568	int pgmPhysGCPhys2CCPtrInternalDepr(PVM pVM, PPGMPAGE pPage, RTGCPHYS GCPhys, void **ppv)
1569	{
1570	int rc;
1571	AssertReturn(pPage, VERR_PGM_PHYS_NULL_PAGE_PARAM);
1572	PGM_LOCK_ASSERT_OWNER(pVM);
1573	pVM->pgm.s.cDeprecatedPageLocks++;
1574
1575	/*
1576	* Make sure the page is writable.
1577	*/
1578	if (RT_UNLIKELY(PGM_PAGE_GET_STATE(pPage) != PGM_PAGE_STATE_ALLOCATED))
1579	{
1580	rc = pgmPhysPageMakeWritable(pVM, pPage, GCPhys);
1581	if (RT_FAILURE(rc))
1582	return rc;
1583	AssertMsg(rc == VINF_SUCCESS \|\| rc == VINF_PGM_SYNC_CR3 /* not returned */, ("%Rrc\n", rc));
1584	}
1585	Assert(PGM_PAGE_GET_HCPHYS(pPage) != 0);
1586
1587	/*
1588	* Get the mapping address.
1589	*/
1590	#if defined(IN_RC) \|\| defined(VBOX_WITH_2X_4GB_ADDR_SPACE_IN_R0)
1591	void *pv;
1592	rc = pgmRZDynMapHCPageInlined(VMMGetCpu(pVM),
1593	PGM_PAGE_GET_HCPHYS(pPage),
1594	&pv
1595	RTLOG_COMMA_SRC_POS);
1596	if (RT_FAILURE(rc))
1597	return rc;
1598	ppv = (void )((uintptr_t)pv \| (uintptr_t)(GCPhys & PAGE_OFFSET_MASK));
1599	#else
1600	PPGMPAGEMAPTLBE pTlbe;
1601	rc = pgmPhysPageQueryTlbeWithPage(pVM, pPage, GCPhys, &pTlbe);
1602	if (RT_FAILURE(rc))
1603	return rc;
1604	ppv = (void )((uintptr_t)pTlbe->pv \| (uintptr_t)(GCPhys & PAGE_OFFSET_MASK));
1605	#endif
1606	return VINF_SUCCESS;
1607	}
1608
1609	#if !defined(IN_RC) && !defined(VBOX_WITH_2X_4GB_ADDR_SPACE_IN_R0)
1610
1611	/**
1612	* Locks a page mapping for writing.
1613	*
1614	* @param pVM The cross context VM structure.
1615	* @param pPage The page.
1616	* @param pTlbe The mapping TLB entry for the page.
1617	* @param pLock The lock structure (output).
1618	*/
1619	DECLINLINE(void) pgmPhysPageMapLockForWriting(PVM pVM, PPGMPAGE pPage, PPGMPAGEMAPTLBE pTlbe, PPGMPAGEMAPLOCK pLock)
1620	{
1621	PPGMPAGEMAP pMap = pTlbe->pMap;
1622	if (pMap)
1623	pMap->cRefs++;
1624
1625	unsigned cLocks = PGM_PAGE_GET_WRITE_LOCKS(pPage);
1626	if (RT_LIKELY(cLocks < PGM_PAGE_MAX_LOCKS - 1))
1627	{
1628	if (cLocks == 0)
1629	pVM->pgm.s.cWriteLockedPages++;
1630	PGM_PAGE_INC_WRITE_LOCKS(pPage);
1631	}
1632	else if (cLocks != PGM_PAGE_MAX_LOCKS)
1633	{
1634	PGM_PAGE_INC_WRITE_LOCKS(pPage);
1635	AssertMsgFailed(("%R[pgmpage] is entering permanent write locked state!\n", pPage));
1636	if (pMap)
1637	pMap->cRefs++; /* Extra ref to prevent it from going away. */
1638	}
1639
1640	pLock->uPageAndType = (uintptr_t)pPage \| PGMPAGEMAPLOCK_TYPE_WRITE;
1641	pLock->pvMap = pMap;
1642	}
1643
1644	/**
1645	* Locks a page mapping for reading.
1646	*
1647	* @param pVM The cross context VM structure.
1648	* @param pPage The page.
1649	* @param pTlbe The mapping TLB entry for the page.
1650	* @param pLock The lock structure (output).
1651	*/
1652	DECLINLINE(void) pgmPhysPageMapLockForReading(PVM pVM, PPGMPAGE pPage, PPGMPAGEMAPTLBE pTlbe, PPGMPAGEMAPLOCK pLock)
1653	{
1654	PPGMPAGEMAP pMap = pTlbe->pMap;
1655	if (pMap)
1656	pMap->cRefs++;
1657
1658	unsigned cLocks = PGM_PAGE_GET_READ_LOCKS(pPage);
1659	if (RT_LIKELY(cLocks < PGM_PAGE_MAX_LOCKS - 1))
1660	{
1661	if (cLocks == 0)
1662	pVM->pgm.s.cReadLockedPages++;
1663	PGM_PAGE_INC_READ_LOCKS(pPage);
1664	}
1665	else if (cLocks != PGM_PAGE_MAX_LOCKS)
1666	{
1667	PGM_PAGE_INC_READ_LOCKS(pPage);
1668	AssertMsgFailed(("%R[pgmpage] is entering permanent read locked state!\n", pPage));
1669	if (pMap)
1670	pMap->cRefs++; /* Extra ref to prevent it from going away. */
1671	}
1672
1673	pLock->uPageAndType = (uintptr_t)pPage \| PGMPAGEMAPLOCK_TYPE_READ;
1674	pLock->pvMap = pMap;
1675	}
1676
1677	#endif /* !IN_RC && !VBOX_WITH_2X_4GB_ADDR_SPACE_IN_R0 */
1678
1679
1680	/**
1681	* Internal version of PGMPhysGCPhys2CCPtr that expects the caller to
1682	* own the PGM lock and have access to the page structure.
1683	*
1684	* @returns VBox status code.
1685	* @retval VINF_SUCCESS on success.
1686	* @retval VERR_PGM_PHYS_PAGE_RESERVED it it's a valid page but has no physical backing.
1687	* @retval VERR_PGM_INVALID_GC_PHYSICAL_ADDRESS if it's not a valid physical address.
1688	*
1689	* @param pVM The cross context VM structure.
1690	* @param GCPhys The guest physical address of the page that should be mapped.
1691	* @param pPage Pointer to the PGMPAGE structure for the page.
1692	* @param ppv Where to store the address corresponding to GCPhys.
1693	* @param pLock Where to store the lock information that
1694	* pgmPhysReleaseInternalPageMappingLock needs.
1695	*
1696	* @internal
1697	*/
1698	int pgmPhysGCPhys2CCPtrInternal(PVM pVM, PPGMPAGE pPage, RTGCPHYS GCPhys, void **ppv, PPGMPAGEMAPLOCK pLock)
1699	{
1700	int rc;
1701	AssertReturn(pPage, VERR_PGM_PHYS_NULL_PAGE_PARAM);
1702	PGM_LOCK_ASSERT_OWNER(pVM);
1703
1704	/*
1705	* Make sure the page is writable.
1706	*/
1707	if (RT_UNLIKELY(PGM_PAGE_GET_STATE(pPage) != PGM_PAGE_STATE_ALLOCATED))
1708	{
1709	rc = pgmPhysPageMakeWritable(pVM, pPage, GCPhys);
1710	if (RT_FAILURE(rc))
1711	return rc;
1712	AssertMsg(rc == VINF_SUCCESS \|\| rc == VINF_PGM_SYNC_CR3 /* not returned */, ("%Rrc\n", rc));
1713	}
1714	Assert(PGM_PAGE_GET_HCPHYS(pPage) != 0);
1715
1716	/*
1717	* Do the job.
1718	*/
1719	#if defined(IN_RC) \|\| defined(VBOX_WITH_2X_4GB_ADDR_SPACE_IN_R0)
1720	void *pv;
1721	PVMCPU pVCpu = VMMGetCpu(pVM);
1722	rc = pgmRZDynMapHCPageInlined(pVCpu,
1723	PGM_PAGE_GET_HCPHYS(pPage),
1724	&pv
1725	RTLOG_COMMA_SRC_POS);
1726	if (RT_FAILURE(rc))
1727	return rc;
1728	ppv = (void )((uintptr_t)pv \| (uintptr_t)(GCPhys & PAGE_OFFSET_MASK));
1729	pLock->pvPage = pv;
1730	pLock->pVCpu = pVCpu;
1731
1732	#else
1733	PPGMPAGEMAPTLBE pTlbe;
1734	rc = pgmPhysPageQueryTlbeWithPage(pVM, pPage, GCPhys, &pTlbe);
1735	if (RT_FAILURE(rc))
1736	return rc;
1737	pgmPhysPageMapLockForWriting(pVM, pPage, pTlbe, pLock);
1738	ppv = (void )((uintptr_t)pTlbe->pv \| (uintptr_t)(GCPhys & PAGE_OFFSET_MASK));
1739	#endif
1740	return VINF_SUCCESS;
1741	}
1742
1743
1744	/**
1745	* Internal version of PGMPhysGCPhys2CCPtrReadOnly that expects the caller to
1746	* own the PGM lock and have access to the page structure.
1747	*
1748	* @returns VBox status code.
1749	* @retval VINF_SUCCESS on success.
1750	* @retval VERR_PGM_PHYS_PAGE_RESERVED it it's a valid page but has no physical backing.
1751	* @retval VERR_PGM_INVALID_GC_PHYSICAL_ADDRESS if it's not a valid physical address.
1752	*
1753	* @param pVM The cross context VM structure.
1754	* @param GCPhys The guest physical address of the page that should be mapped.
1755	* @param pPage Pointer to the PGMPAGE structure for the page.
1756	* @param ppv Where to store the address corresponding to GCPhys.
1757	* @param pLock Where to store the lock information that
1758	* pgmPhysReleaseInternalPageMappingLock needs.
1759	*
1760	* @internal
1761	*/
1762	int pgmPhysGCPhys2CCPtrInternalReadOnly(PVM pVM, PPGMPAGE pPage, RTGCPHYS GCPhys, const void **ppv, PPGMPAGEMAPLOCK pLock)
1763	{
1764	AssertReturn(pPage, VERR_PGM_PHYS_NULL_PAGE_PARAM);
1765	PGM_LOCK_ASSERT_OWNER(pVM);
1766	Assert(PGM_PAGE_GET_HCPHYS(pPage) != 0);
1767
1768	/*
1769	* Do the job.
1770	*/
1771	#if defined(IN_RC) \|\| defined(VBOX_WITH_2X_4GB_ADDR_SPACE_IN_R0)
1772	void *pv;
1773	PVMCPU pVCpu = VMMGetCpu(pVM);
1774	int rc = pgmRZDynMapHCPageInlined(pVCpu,
1775	PGM_PAGE_GET_HCPHYS(pPage),
1776	&pv
1777	RTLOG_COMMA_SRC_POS); /** @todo add a read only flag? */
1778	if (RT_FAILURE(rc))
1779	return rc;
1780	ppv = (void )((uintptr_t)pv \| (uintptr_t)(GCPhys & PAGE_OFFSET_MASK));
1781	pLock->pvPage = pv;
1782	pLock->pVCpu = pVCpu;
1783
1784	#else
1785	PPGMPAGEMAPTLBE pTlbe;
1786	int rc = pgmPhysPageQueryTlbeWithPage(pVM, pPage, GCPhys, &pTlbe);
1787	if (RT_FAILURE(rc))
1788	return rc;
1789	pgmPhysPageMapLockForReading(pVM, pPage, pTlbe, pLock);
1790	ppv = (void )((uintptr_t)pTlbe->pv \| (uintptr_t)(GCPhys & PAGE_OFFSET_MASK));
1791	#endif
1792	return VINF_SUCCESS;
1793	}
1794
1795
1796	/**
1797	* Requests the mapping of a guest page into the current context.
1798	*
1799	* This API should only be used for very short term, as it will consume scarse
1800	* resources (R0 and GC) in the mapping cache. When you're done with the page,
1801	* call PGMPhysReleasePageMappingLock() ASAP to release it.
1802	*
1803	* This API will assume your intention is to write to the page, and will
1804	* therefore replace shared and zero pages. If you do not intend to modify
1805	* the page, use the PGMPhysGCPhys2CCPtrReadOnly() API.
1806	*
1807	* @returns VBox status code.
1808	* @retval VINF_SUCCESS on success.
1809	* @retval VERR_PGM_PHYS_PAGE_RESERVED it it's a valid page but has no physical backing.
1810	* @retval VERR_PGM_INVALID_GC_PHYSICAL_ADDRESS if it's not a valid physical address.
1811	*
1812	* @param pVM The cross context VM structure.
1813	* @param GCPhys The guest physical address of the page that should be
1814	* mapped.
1815	* @param ppv Where to store the address corresponding to GCPhys.
1816	* @param pLock Where to store the lock information that
1817	* PGMPhysReleasePageMappingLock needs.
1818	*
1819	* @remarks The caller is responsible for dealing with access handlers.
1820	* @todo Add an informational return code for pages with access handlers?
1821	*
1822	* @remark Avoid calling this API from within critical sections (other than
1823	* the PGM one) because of the deadlock risk. External threads may
1824	* need to delegate jobs to the EMTs.
1825	* @remarks Only one page is mapped! Make no assumption about what's after or
1826	* before the returned page!
1827	* @thread Any thread.
1828	*/
1829	VMM_INT_DECL(int) PGMPhysGCPhys2CCPtr(PVM pVM, RTGCPHYS GCPhys, void **ppv, PPGMPAGEMAPLOCK pLock)
1830	{
1831	int rc = pgmLock(pVM);
1832	AssertRCReturn(rc, rc);
1833
1834	#if defined(IN_RC) \|\| defined(VBOX_WITH_2X_4GB_ADDR_SPACE_IN_R0)
1835	/*
1836	* Find the page and make sure it's writable.
1837	*/
1838	PPGMPAGE pPage;
1839	rc = pgmPhysGetPageEx(pVM, GCPhys, &pPage);
1840	if (RT_SUCCESS(rc))
1841	{
1842	if (RT_UNLIKELY(PGM_PAGE_GET_STATE(pPage) != PGM_PAGE_STATE_ALLOCATED))
1843	rc = pgmPhysPageMakeWritable(pVM, pPage, GCPhys);
1844	if (RT_SUCCESS(rc))
1845	{
1846	AssertMsg(rc == VINF_SUCCESS \|\| rc == VINF_PGM_SYNC_CR3 /* not returned */, ("%Rrc\n", rc));
1847
1848	PVMCPU pVCpu = VMMGetCpu(pVM);
1849	void *pv;
1850	rc = pgmRZDynMapHCPageInlined(pVCpu,
1851	PGM_PAGE_GET_HCPHYS(pPage),
1852	&pv
1853	RTLOG_COMMA_SRC_POS);
1854	if (RT_SUCCESS(rc))
1855	{
1856	AssertRCSuccess(rc);
1857
1858	pv = (void *)((uintptr_t)pv \| (uintptr_t)(GCPhys & PAGE_OFFSET_MASK));
1859	*ppv = pv;
1860	pLock->pvPage = pv;
1861	pLock->pVCpu = pVCpu;
1862	}
1863	}
1864	}
1865
1866	#else /* IN_RING3 \|\| IN_RING0 */
1867	/*
1868	* Query the Physical TLB entry for the page (may fail).
1869	*/
1870	PPGMPAGEMAPTLBE pTlbe;
1871	rc = pgmPhysPageQueryTlbe(pVM, GCPhys, &pTlbe);
1872	if (RT_SUCCESS(rc))
1873	{
1874	/*
1875	* If the page is shared, the zero page, or being write monitored
1876	* it must be converted to a page that's writable if possible.
1877	*/
1878	PPGMPAGE pPage = pTlbe->pPage;
1879	if (RT_UNLIKELY(PGM_PAGE_GET_STATE(pPage) != PGM_PAGE_STATE_ALLOCATED))
1880	{
1881	rc = pgmPhysPageMakeWritable(pVM, pPage, GCPhys);
1882	if (RT_SUCCESS(rc))
1883	{
1884	AssertMsg(rc == VINF_SUCCESS \|\| rc == VINF_PGM_SYNC_CR3 /* not returned */, ("%Rrc\n", rc));
1885	rc = pgmPhysPageQueryTlbeWithPage(pVM, pPage, GCPhys, &pTlbe);
1886	}
1887	}
1888	if (RT_SUCCESS(rc))
1889	{
1890	/*
1891	* Now, just perform the locking and calculate the return address.
1892	*/
1893	pgmPhysPageMapLockForWriting(pVM, pPage, pTlbe, pLock);
1894	ppv = (void )((uintptr_t)pTlbe->pv \| (uintptr_t)(GCPhys & PAGE_OFFSET_MASK));
1895	}
1896	}
1897
1898	#endif /* IN_RING3 \|\| IN_RING0 */
1899	pgmUnlock(pVM);
1900	return rc;
1901	}
1902
1903
1904	/**
1905	* Requests the mapping of a guest page into the current context.
1906	*
1907	* This API should only be used for very short term, as it will consume scarse
1908	* resources (R0 and GC) in the mapping cache. When you're done with the page,
1909	* call PGMPhysReleasePageMappingLock() ASAP to release it.
1910	*
1911	* @returns VBox status code.
1912	* @retval VINF_SUCCESS on success.
1913	* @retval VERR_PGM_PHYS_PAGE_RESERVED it it's a valid page but has no physical backing.
1914	* @retval VERR_PGM_INVALID_GC_PHYSICAL_ADDRESS if it's not a valid physical address.
1915	*
1916	* @param pVM The cross context VM structure.
1917	* @param GCPhys The guest physical address of the page that should be
1918	* mapped.
1919	* @param ppv Where to store the address corresponding to GCPhys.
1920	* @param pLock Where to store the lock information that
1921	* PGMPhysReleasePageMappingLock needs.
1922	*
1923	* @remarks The caller is responsible for dealing with access handlers.
1924	* @todo Add an informational return code for pages with access handlers?
1925	*
1926	* @remarks Avoid calling this API from within critical sections (other than
1927	* the PGM one) because of the deadlock risk.
1928	* @remarks Only one page is mapped! Make no assumption about what's after or
1929	* before the returned page!
1930	* @thread Any thread.
1931	*/
1932	VMM_INT_DECL(int) PGMPhysGCPhys2CCPtrReadOnly(PVM pVM, RTGCPHYS GCPhys, void const **ppv, PPGMPAGEMAPLOCK pLock)
1933	{
1934	int rc = pgmLock(pVM);
1935	AssertRCReturn(rc, rc);
1936
1937	#if defined(IN_RC) \|\| defined(VBOX_WITH_2X_4GB_ADDR_SPACE_IN_R0)
1938	/*
1939	* Find the page and make sure it's readable.
1940	*/
1941	PPGMPAGE pPage;
1942	rc = pgmPhysGetPageEx(pVM, GCPhys, &pPage);
1943	if (RT_SUCCESS(rc))
1944	{
1945	if (RT_UNLIKELY(PGM_PAGE_IS_MMIO_OR_SPECIAL_ALIAS(pPage)))
1946	rc = VERR_PGM_PHYS_PAGE_RESERVED;
1947	else
1948	{
1949	PVMCPU pVCpu = VMMGetCpu(pVM);
1950	void *pv;
1951	rc = pgmRZDynMapHCPageInlined(pVCpu,
1952	PGM_PAGE_GET_HCPHYS(pPage),
1953	&pv
1954	RTLOG_COMMA_SRC_POS); /** @todo add a read only flag? */
1955	if (RT_SUCCESS(rc))
1956	{
1957	AssertRCSuccess(rc);
1958
1959	pv = (void *)((uintptr_t)pv \| (uintptr_t)(GCPhys & PAGE_OFFSET_MASK));
1960	*ppv = pv;
1961	pLock->pvPage = pv;
1962	pLock->pVCpu = pVCpu;
1963	}
1964	}
1965	}
1966
1967	#else /* IN_RING3 \|\| IN_RING0 */
1968	/*
1969	* Query the Physical TLB entry for the page (may fail).
1970	*/
1971	PPGMPAGEMAPTLBE pTlbe;
1972	rc = pgmPhysPageQueryTlbe(pVM, GCPhys, &pTlbe);
1973	if (RT_SUCCESS(rc))
1974	{
1975	/* MMIO pages doesn't have any readable backing. */
1976	PPGMPAGE pPage = pTlbe->pPage;
1977	if (RT_UNLIKELY(PGM_PAGE_IS_MMIO_OR_SPECIAL_ALIAS(pPage)))
1978	rc = VERR_PGM_PHYS_PAGE_RESERVED;
1979	else
1980	{
1981	/*
1982	* Now, just perform the locking and calculate the return address.
1983	*/
1984	pgmPhysPageMapLockForReading(pVM, pPage, pTlbe, pLock);
1985	ppv = (void )((uintptr_t)pTlbe->pv \| (uintptr_t)(GCPhys & PAGE_OFFSET_MASK));
1986	}
1987	}
1988
1989	#endif /* IN_RING3 \|\| IN_RING0 */
1990	pgmUnlock(pVM);
1991	return rc;
1992	}
1993
1994
1995	/**
1996	* Requests the mapping of a guest page given by virtual address into the current context.
1997	*
1998	* This API should only be used for very short term, as it will consume
1999	* scarse resources (R0 and GC) in the mapping cache. When you're done
2000	* with the page, call PGMPhysReleasePageMappingLock() ASAP to release it.
2001	*
2002	* This API will assume your intention is to write to the page, and will
2003	* therefore replace shared and zero pages. If you do not intend to modify
2004	* the page, use the PGMPhysGCPtr2CCPtrReadOnly() API.
2005	*
2006	* @returns VBox status code.
2007	* @retval VINF_SUCCESS on success.
2008	* @retval VERR_PAGE_TABLE_NOT_PRESENT if the page directory for the virtual address isn't present.
2009	* @retval VERR_PAGE_NOT_PRESENT if the page at the virtual address isn't present.
2010	* @retval VERR_PGM_PHYS_PAGE_RESERVED it it's a valid page but has no physical backing.
2011	* @retval VERR_PGM_INVALID_GC_PHYSICAL_ADDRESS if it's not a valid physical address.
2012	*
2013	* @param pVCpu The cross context virtual CPU structure.
2014	* @param GCPtr The guest physical address of the page that should be
2015	* mapped.
2016	* @param ppv Where to store the address corresponding to GCPhys.
2017	* @param pLock Where to store the lock information that PGMPhysReleasePageMappingLock needs.
2018	*
2019	* @remark Avoid calling this API from within critical sections (other than
2020	* the PGM one) because of the deadlock risk.
2021	* @thread EMT
2022	*/
2023	VMM_INT_DECL(int) PGMPhysGCPtr2CCPtr(PVMCPU pVCpu, RTGCPTR GCPtr, void **ppv, PPGMPAGEMAPLOCK pLock)
2024	{
2025	VM_ASSERT_EMT(pVCpu->CTX_SUFF(pVM));
2026	RTGCPHYS GCPhys;
2027	int rc = PGMPhysGCPtr2GCPhys(pVCpu, GCPtr, &GCPhys);
2028	if (RT_SUCCESS(rc))
2029	rc = PGMPhysGCPhys2CCPtr(pVCpu->CTX_SUFF(pVM), GCPhys, ppv, pLock);
2030	return rc;
2031	}
2032
2033
2034	/**
2035	* Requests the mapping of a guest page given by virtual address into the current context.
2036	*
2037	* This API should only be used for very short term, as it will consume
2038	* scarse resources (R0 and GC) in the mapping cache. When you're done
2039	* with the page, call PGMPhysReleasePageMappingLock() ASAP to release it.
2040	*
2041	* @returns VBox status code.
2042	* @retval VINF_SUCCESS on success.
2043	* @retval VERR_PAGE_TABLE_NOT_PRESENT if the page directory for the virtual address isn't present.
2044	* @retval VERR_PAGE_NOT_PRESENT if the page at the virtual address isn't present.
2045	* @retval VERR_PGM_PHYS_PAGE_RESERVED it it's a valid page but has no physical backing.
2046	* @retval VERR_PGM_INVALID_GC_PHYSICAL_ADDRESS if it's not a valid physical address.
2047	*
2048	* @param pVCpu The cross context virtual CPU structure.
2049	* @param GCPtr The guest physical address of the page that should be
2050	* mapped.
2051	* @param ppv Where to store the address corresponding to GCPtr.
2052	* @param pLock Where to store the lock information that PGMPhysReleasePageMappingLock needs.
2053	*
2054	* @remark Avoid calling this API from within critical sections (other than
2055	* the PGM one) because of the deadlock risk.
2056	* @thread EMT
2057	*/
2058	VMM_INT_DECL(int) PGMPhysGCPtr2CCPtrReadOnly(PVMCPU pVCpu, RTGCPTR GCPtr, void const **ppv, PPGMPAGEMAPLOCK pLock)
2059	{
2060	VM_ASSERT_EMT(pVCpu->CTX_SUFF(pVM));
2061	RTGCPHYS GCPhys;
2062	int rc = PGMPhysGCPtr2GCPhys(pVCpu, GCPtr, &GCPhys);
2063	if (RT_SUCCESS(rc))
2064	rc = PGMPhysGCPhys2CCPtrReadOnly(pVCpu->CTX_SUFF(pVM), GCPhys, ppv, pLock);
2065	return rc;
2066	}
2067
2068
2069	/**
2070	* Release the mapping of a guest page.
2071	*
2072	* This is the counter part of PGMPhysGCPhys2CCPtr, PGMPhysGCPhys2CCPtrReadOnly
2073	* PGMPhysGCPtr2CCPtr and PGMPhysGCPtr2CCPtrReadOnly.
2074	*
2075	* @param pVM The cross context VM structure.
2076	* @param pLock The lock structure initialized by the mapping function.
2077	*/
2078	VMMDECL(void) PGMPhysReleasePageMappingLock(PVM pVM, PPGMPAGEMAPLOCK pLock)
2079	{
2080	#if defined(IN_RC) \|\| defined(VBOX_WITH_2X_4GB_ADDR_SPACE_IN_R0)
2081	Assert(pLock->pvPage != NULL);
2082	Assert(pLock->pVCpu == VMMGetCpu(pVM)); RT_NOREF_PV(pVM);
2083	PGM_DYNMAP_UNUSED_HINT(pLock->pVCpu, pLock->pvPage);
2084	pLock->pVCpu = NULL;
2085	pLock->pvPage = NULL;
2086
2087	#else
2088	PPGMPAGEMAP pMap = (PPGMPAGEMAP)pLock->pvMap;
2089	PPGMPAGE pPage = (PPGMPAGE)(pLock->uPageAndType & ~PGMPAGEMAPLOCK_TYPE_MASK);
2090	bool fWriteLock = (pLock->uPageAndType & PGMPAGEMAPLOCK_TYPE_MASK) == PGMPAGEMAPLOCK_TYPE_WRITE;
2091
2092	pLock->uPageAndType = 0;
2093	pLock->pvMap = NULL;
2094
2095	pgmLock(pVM);
2096	if (fWriteLock)
2097	{
2098	unsigned cLocks = PGM_PAGE_GET_WRITE_LOCKS(pPage);
2099	Assert(cLocks > 0);
2100	if (RT_LIKELY(cLocks > 0 && cLocks < PGM_PAGE_MAX_LOCKS))
2101	{
2102	if (cLocks == 1)
2103	{
2104	Assert(pVM->pgm.s.cWriteLockedPages > 0);
2105	pVM->pgm.s.cWriteLockedPages--;
2106	}
2107	PGM_PAGE_DEC_WRITE_LOCKS(pPage);
2108	}
2109
2110	if (PGM_PAGE_GET_STATE(pPage) != PGM_PAGE_STATE_WRITE_MONITORED)
2111	{ /* probably extremely likely */ }
2112	else
2113	pgmPhysPageMakeWriteMonitoredWritable(pVM, pPage, NIL_RTGCPHYS);
2114	}
2115	else
2116	{
2117	unsigned cLocks = PGM_PAGE_GET_READ_LOCKS(pPage);
2118	Assert(cLocks > 0);
2119	if (RT_LIKELY(cLocks > 0 && cLocks < PGM_PAGE_MAX_LOCKS))
2120	{
2121	if (cLocks == 1)
2122	{
2123	Assert(pVM->pgm.s.cReadLockedPages > 0);
2124	pVM->pgm.s.cReadLockedPages--;
2125	}
2126	PGM_PAGE_DEC_READ_LOCKS(pPage);
2127	}
2128	}
2129
2130	if (pMap)
2131	{
2132	Assert(pMap->cRefs >= 1);
2133	pMap->cRefs--;
2134	}
2135	pgmUnlock(pVM);
2136	#endif /* IN_RING3 */
2137	}
2138
2139
2140	/**
2141	* Release the internal mapping of a guest page.
2142	*
2143	* This is the counter part of pgmPhysGCPhys2CCPtrInternalEx and
2144	* pgmPhysGCPhys2CCPtrInternalReadOnly.
2145	*
2146	* @param pVM The cross context VM structure.
2147	* @param pLock The lock structure initialized by the mapping function.
2148	*
2149	* @remarks Caller must hold the PGM lock.
2150	*/
2151	void pgmPhysReleaseInternalPageMappingLock(PVM pVM, PPGMPAGEMAPLOCK pLock)
2152	{
2153	PGM_LOCK_ASSERT_OWNER(pVM);
2154	PGMPhysReleasePageMappingLock(pVM, pLock); /* lazy for now */
2155	}
2156
2157
2158	/**
2159	* Converts a GC physical address to a HC ring-3 pointer.
2160	*
2161	* @returns VINF_SUCCESS on success.
2162	* @returns VERR_PGM_PHYS_PAGE_RESERVED it it's a valid GC physical
2163	* page but has no physical backing.
2164	* @returns VERR_PGM_INVALID_GC_PHYSICAL_ADDRESS if it's not a valid
2165	* GC physical address.
2166	* @returns VERR_PGM_GCPHYS_RANGE_CROSSES_BOUNDARY if the range crosses
2167	* a dynamic ram chunk boundary
2168	*
2169	* @param pVM The cross context VM structure.
2170	* @param GCPhys The GC physical address to convert.
2171	* @param pR3Ptr Where to store the R3 pointer on success.
2172	*
2173	* @deprecated Avoid when possible!
2174	*/
2175	int pgmPhysGCPhys2R3Ptr(PVM pVM, RTGCPHYS GCPhys, PRTR3PTR pR3Ptr)
2176	{
2177	/** @todo this is kind of hacky and needs some more work. */
2178	#ifndef DEBUG_sandervl
2179	VM_ASSERT_EMT(pVM); /* no longer safe for use outside the EMT thread! */
2180	#endif
2181
2182	Log(("pgmPhysGCPhys2R3Ptr(,%RGp,): dont use this API!\n", GCPhys)); /** @todo eliminate this API! */
2183	#if defined(IN_RC) \|\| defined(VBOX_WITH_2X_4GB_ADDR_SPACE_IN_R0)
2184	NOREF(pVM); NOREF(pR3Ptr); RT_NOREF_PV(GCPhys);
2185	AssertFailedReturn(VERR_NOT_IMPLEMENTED);
2186	#else
2187	pgmLock(pVM);
2188
2189	PPGMRAMRANGE pRam;
2190	PPGMPAGE pPage;
2191	int rc = pgmPhysGetPageAndRangeEx(pVM, GCPhys, &pPage, &pRam);
2192	if (RT_SUCCESS(rc))
2193	rc = pgmPhysGCPhys2CCPtrInternalDepr(pVM, pPage, GCPhys, (void **)pR3Ptr);
2194
2195	pgmUnlock(pVM);
2196	Assert(rc <= VINF_SUCCESS);
2197	return rc;
2198	#endif
2199	}
2200
2201	#if 0 /defined(IN_RC) \|\| defined(VBOX_WITH_2X_4GB_ADDR_SPACE_IN_R0)/
2202
2203	/**
2204	* Maps and locks a guest CR3 or PD (PAE) page.
2205	*
2206	* @returns VINF_SUCCESS on success.
2207	* @returns VERR_PGM_PHYS_PAGE_RESERVED it it's a valid GC physical
2208	* page but has no physical backing.
2209	* @returns VERR_PGM_INVALID_GC_PHYSICAL_ADDRESS if it's not a valid
2210	* GC physical address.
2211	* @returns VERR_PGM_GCPHYS_RANGE_CROSSES_BOUNDARY if the range crosses
2212	* a dynamic ram chunk boundary
2213	*
2214	* @param pVM The cross context VM structure.
2215	* @param GCPhys The GC physical address to convert.
2216	* @param pR3Ptr Where to store the R3 pointer on success. This may or
2217	* may not be valid in ring-0 depending on the
2218	* VBOX_WITH_2X_4GB_ADDR_SPACE_IN_R0 build option.
2219	*
2220	* @remarks The caller must own the PGM lock.
2221	*/
2222	int pgmPhysCr3ToHCPtr(PVM pVM, RTGCPHYS GCPhys, PRTR3PTR pR3Ptr)
2223	{
2224
2225	PPGMRAMRANGE pRam;
2226	PPGMPAGE pPage;
2227	int rc = pgmPhysGetPageAndRangeEx(pVM, GCPhys, &pPage, &pRam);
2228	if (RT_SUCCESS(rc))
2229	rc = pgmPhysGCPhys2CCPtrInternalDepr(pVM, pPage, GCPhys, (void **)pR3Ptr);
2230	Assert(rc <= VINF_SUCCESS);
2231	return rc;
2232	}
2233
2234
2235	int pgmPhysCr3ToHCPtr(PVM pVM, RTGCPHYS GCPhys, PRTR3PTR pR3Ptr)
2236	{
2237
2238	}
2239
2240	#endif
2241
2242	/**
2243	* Converts a guest pointer to a GC physical address.
2244	*
2245	* This uses the current CR3/CR0/CR4 of the guest.
2246	*
2247	* @returns VBox status code.
2248	* @param pVCpu The cross context virtual CPU structure.
2249	* @param GCPtr The guest pointer to convert.
2250	* @param pGCPhys Where to store the GC physical address.
2251	*/
2252	VMMDECL(int) PGMPhysGCPtr2GCPhys(PVMCPU pVCpu, RTGCPTR GCPtr, PRTGCPHYS pGCPhys)
2253	{
2254	int rc = PGM_GST_PFN(GetPage,pVCpu)(pVCpu, (RTGCUINTPTR)GCPtr, NULL, pGCPhys);
2255	if (pGCPhys && RT_SUCCESS(rc))
2256	*pGCPhys \|= (RTGCUINTPTR)GCPtr & PAGE_OFFSET_MASK;
2257	return rc;
2258	}
2259
2260
2261	/**
2262	* Converts a guest pointer to a HC physical address.
2263	*
2264	* This uses the current CR3/CR0/CR4 of the guest.
2265	*
2266	* @returns VBox status code.
2267	* @param pVCpu The cross context virtual CPU structure.
2268	* @param GCPtr The guest pointer to convert.
2269	* @param pHCPhys Where to store the HC physical address.
2270	*/
2271	VMM_INT_DECL(int) PGMPhysGCPtr2HCPhys(PVMCPU pVCpu, RTGCPTR GCPtr, PRTHCPHYS pHCPhys)
2272	{
2273	PVM pVM = pVCpu->CTX_SUFF(pVM);
2274	RTGCPHYS GCPhys;
2275	int rc = PGM_GST_PFN(GetPage,pVCpu)(pVCpu, (RTGCUINTPTR)GCPtr, NULL, &GCPhys);
2276	if (RT_SUCCESS(rc))
2277	rc = PGMPhysGCPhys2HCPhys(pVM, GCPhys \| ((RTGCUINTPTR)GCPtr & PAGE_OFFSET_MASK), pHCPhys);
2278	return rc;
2279	}
2280
2281
2282
2283	#undef LOG_GROUP
2284	#define LOG_GROUP LOG_GROUP_PGM_PHYS_ACCESS
2285
2286
2287	#if defined(IN_RING3) && defined(SOME_UNUSED_FUNCTION)
2288	/**
2289	* Cache PGMPhys memory access
2290	*
2291	* @param pVM The cross context VM structure.
2292	* @param pCache Cache structure pointer
2293	* @param GCPhys GC physical address
2294	* @param pbHC HC pointer corresponding to physical page
2295	*
2296	* @thread EMT.
2297	*/
2298	static void pgmPhysCacheAdd(PVM pVM, PGMPHYSCACHE pCache, RTGCPHYS GCPhys, uint8_t pbR3)
2299	{
2300	uint32_t iCacheIndex;
2301
2302	Assert(VM_IS_EMT(pVM));
2303
2304	GCPhys = PHYS_PAGE_ADDRESS(GCPhys);
2305	pbR3 = (uint8_t *)PAGE_ADDRESS(pbR3);
2306
2307	iCacheIndex = ((GCPhys >> PAGE_SHIFT) & PGM_MAX_PHYSCACHE_ENTRIES_MASK);
2308
2309	ASMBitSet(&pCache->aEntries, iCacheIndex);
2310
2311	pCache->Entry[iCacheIndex].GCPhys = GCPhys;
2312	pCache->Entry[iCacheIndex].pbR3 = pbR3;
2313	}
2314	#endif /* IN_RING3 */
2315
2316
2317	/**
2318	* Deals with reading from a page with one or more ALL access handlers.
2319	*
2320	* @returns Strict VBox status code in ring-0 and raw-mode, ignorable in ring-3.
2321	* See PGM_HANDLER_PHYS_IS_VALID_STATUS and
2322	* PGM_HANDLER_VIRT_IS_VALID_STATUS for details.
2323	*
2324	* @param pVM The cross context VM structure.
2325	* @param pPage The page descriptor.
2326	* @param GCPhys The physical address to start reading at.
2327	* @param pvBuf Where to put the bits we read.
2328	* @param cb How much to read - less or equal to a page.
2329	* @param enmOrigin The origin of this call.
2330	*/
2331	static VBOXSTRICTRC pgmPhysReadHandler(PVM pVM, PPGMPAGE pPage, RTGCPHYS GCPhys, void *pvBuf, size_t cb,
2332	PGMACCESSORIGIN enmOrigin)
2333	{
2334	/*
2335	* The most frequent access here is MMIO and shadowed ROM.
2336	* The current code ASSUMES all these access handlers covers full pages!
2337	*/
2338
2339	/*
2340	* Whatever we do we need the source page, map it first.
2341	*/
2342	PGMPAGEMAPLOCK PgMpLck;
2343	const void *pvSrc = NULL;
2344	int rc = pgmPhysGCPhys2CCPtrInternalReadOnly(pVM, pPage, GCPhys, &pvSrc, &PgMpLck);
2345	/** @todo Check how this can work for MMIO pages? */
2346	if (RT_FAILURE(rc))
2347	{
2348	AssertLogRelMsgFailed(("pgmPhysGCPhys2CCPtrInternalReadOnly failed on %RGp / %R[pgmpage] -> %Rrc\n",
2349	GCPhys, pPage, rc));
2350	memset(pvBuf, 0xff, cb);
2351	return VINF_SUCCESS;
2352	}
2353
2354	VBOXSTRICTRC rcStrict = VINF_PGM_HANDLER_DO_DEFAULT;
2355
2356	/*
2357	* Deal with any physical handlers.
2358	*/
2359	PVMCPU pVCpu = VMMGetCpu(pVM);
2360	PPGMPHYSHANDLER pPhys = NULL;
2361	if ( PGM_PAGE_GET_HNDL_PHYS_STATE(pPage) == PGM_PAGE_HNDL_PHYS_STATE_ALL
2362	\|\| PGM_PAGE_IS_MMIO_OR_SPECIAL_ALIAS(pPage))
2363	{
2364	pPhys = pgmHandlerPhysicalLookup(pVM, GCPhys);
2365	AssertReleaseMsg(pPhys, ("GCPhys=%RGp cb=%#x\n", GCPhys, cb));
2366	Assert(GCPhys >= pPhys->Core.Key && GCPhys <= pPhys->Core.KeyLast);
2367	Assert((pPhys->Core.Key & PAGE_OFFSET_MASK) == 0);
2368	Assert((pPhys->Core.KeyLast & PAGE_OFFSET_MASK) == PAGE_OFFSET_MASK);
2369	#ifndef IN_RING3
2370	if (enmOrigin != PGMACCESSORIGIN_IEM)
2371	{
2372	/* Cannot reliably handle informational status codes in this context */
2373	pgmPhysReleaseInternalPageMappingLock(pVM, &PgMpLck);
2374	return VERR_PGM_PHYS_WR_HIT_HANDLER;
2375	}
2376	#endif
2377	PFNPGMPHYSHANDLER pfnHandler = PGMPHYSHANDLER_GET_TYPE(pVM, pPhys)->CTX_SUFF(pfnHandler); Assert(pfnHandler);
2378	void *pvUser = pPhys->CTX_SUFF(pvUser);
2379
2380	Log5(("pgmPhysReadHandler: GCPhys=%RGp cb=%#x pPage=%R[pgmpage] phys %s\n", GCPhys, cb, pPage, R3STRING(pPhys->pszDesc) ));
2381	STAM_PROFILE_START(&pPhys->Stat, h);
2382	PGM_LOCK_ASSERT_OWNER(pVM);
2383
2384	/* Release the PGM lock as MMIO handlers take the IOM lock. (deadlock prevention) */
2385	pgmUnlock(pVM);
2386	rcStrict = pfnHandler(pVM, pVCpu, GCPhys, (void *)pvSrc, pvBuf, cb, PGMACCESSTYPE_READ, enmOrigin, pvUser);
2387	pgmLock(pVM);
2388
2389	#ifdef VBOX_WITH_STATISTICS
2390	pPhys = pgmHandlerPhysicalLookup(pVM, GCPhys);
2391	if (pPhys)
2392	STAM_PROFILE_STOP(&pPhys->Stat, h);
2393	#else
2394	pPhys = NULL; /* might not be valid anymore. */
2395	#endif
2396	AssertLogRelMsg(PGM_HANDLER_PHYS_IS_VALID_STATUS(rcStrict, false),
2397	("rcStrict=%Rrc GCPhys=%RGp\n", VBOXSTRICTRC_VAL(rcStrict), GCPhys));
2398	if ( rcStrict != VINF_PGM_HANDLER_DO_DEFAULT
2399	&& !PGM_PHYS_RW_IS_SUCCESS(rcStrict))
2400	{
2401	pgmPhysReleaseInternalPageMappingLock(pVM, &PgMpLck);
2402	return rcStrict;
2403	}
2404	}
2405
2406	#if !defined(IN_RING0) && defined(VBOX_WITH_RAW_MODE)
2407	/*
2408	* Deal with any virtual handlers.
2409	*/
2410	if (PGM_PAGE_GET_HNDL_VIRT_STATE(pPage) == PGM_PAGE_HNDL_VIRT_STATE_ALL)
2411	{
2412	unsigned iPage;
2413	PPGMVIRTHANDLER pVirt = pgmHandlerVirtualFindByPhysAddr(pVM, GCPhys, &iPage);
2414	AssertReleaseMsg(pVirt, ("GCPhys=%RGp cb=%#x\n", GCPhys, cb));
2415	Assert((pVirt->Core.Key & PAGE_OFFSET_MASK) == 0);
2416	Assert((pVirt->Core.KeyLast & PAGE_OFFSET_MASK) == PAGE_OFFSET_MASK);
2417	Assert(GCPhys >= pVirt->aPhysToVirt[iPage].Core.Key && GCPhys <= pVirt->aPhysToVirt[iPage].Core.KeyLast);
2418
2419	# ifndef IN_RING3
2420	if (enmOrigin != PGMACCESSORIGIN_IEM)
2421	{
2422	/* Cannot reliably handle informational status codes in this context */
2423	pgmPhysReleaseInternalPageMappingLock(pVM, &PgMpLck);
2424	return VERR_PGM_PHYS_WR_HIT_HANDLER;
2425	}
2426	# endif
2427	PPGMVIRTHANDLERTYPEINT pVirtType = PGMVIRTANDLER_GET_TYPE(pVM, pVirt);
2428	if (!pPhys)
2429	Log5(("pgmPhysReadHandler: GCPhys=%RGp cb=%#x pPage=%R[pgmpage] virt %s\n", GCPhys, cb, pPage, R3STRING(pVirt->pszDesc) ));
2430	else
2431	Log(("pgmPhysReadHandler: GCPhys=%RGp cb=%#x pPage=%R[pgmpage] phys/virt %s/%s\n", GCPhys, cb, pPage, R3STRING(pVirt->pszDesc), R3STRING(pPhys->pszDesc) ));
2432	RTGCUINTPTR GCPtr = ((RTGCUINTPTR)pVirt->Core.Key & PAGE_BASE_GC_MASK)
2433	+ (iPage << PAGE_SHIFT)
2434	+ (GCPhys & PAGE_OFFSET_MASK);
2435
2436	STAM_PROFILE_START(&pVirt->Stat, h);
2437	VBOXSTRICTRC rcStrict2 = pVirtType->CTX_SUFF(pfnHandler)(pVM, pVCpu, GCPtr, (void *)pvSrc, pvBuf, cb,
2438	PGMACCESSTYPE_READ, enmOrigin, pVirt->CTX_SUFF(pvUser));
2439	STAM_PROFILE_STOP(&pVirt->Stat, h);
2440
2441	/* Merge status codes. */
2442	if (rcStrict2 == VINF_SUCCESS)
2443	{
2444	if (rcStrict == VINF_PGM_HANDLER_DO_DEFAULT)
2445	rcStrict = VINF_SUCCESS;
2446	}
2447	else if (rcStrict2 != VINF_PGM_HANDLER_DO_DEFAULT)
2448	{
2449	AssertLogRelMsg(PGM_HANDLER_VIRT_IS_VALID_STATUS(rcStrict2, false),
2450	("rcStrict2=%Rrc (rcStrict=%Rrc) GCPhys=%RGp pPage=%R[pgmpage] %s\n",
2451	VBOXSTRICTRC_VAL(rcStrict2), VBOXSTRICTRC_VAL(rcStrict), GCPhys, pPage, pVirt->pszDesc));
2452	if (!PGM_PHYS_RW_IS_SUCCESS(rcStrict2))
2453	{
2454	pgmPhysReleaseInternalPageMappingLock(pVM, &PgMpLck);
2455	return rcStrict2;
2456	}
2457	if (rcStrict == VINF_PGM_HANDLER_DO_DEFAULT)
2458	rcStrict = rcStrict2;
2459	else
2460	PGM_PHYS_RW_DO_UPDATE_STRICT_RC(rcStrict, rcStrict2);
2461	}
2462	}
2463	#endif /* !IN_RING0 && VBOX_WITH_RAW_MODE */
2464
2465	/*
2466	* Take the default action.
2467	*/
2468	if (rcStrict == VINF_PGM_HANDLER_DO_DEFAULT)
2469	{
2470	memcpy(pvBuf, pvSrc, cb);
2471	rcStrict = VINF_SUCCESS;
2472	}
2473	pgmPhysReleaseInternalPageMappingLock(pVM, &PgMpLck);
2474	return rcStrict;
2475	}
2476
2477
2478	/**
2479	* Read physical memory.
2480	*
2481	* This API respects access handlers and MMIO. Use PGMPhysSimpleReadGCPhys() if you
2482	* want to ignore those.
2483	*
2484	* @returns Strict VBox status code in raw-mode and ring-0, normal VBox status
2485	* code in ring-3. Use PGM_PHYS_RW_IS_SUCCESS to check.
2486	* @retval VINF_SUCCESS in all context - read completed.
2487	*
2488	* @retval VINF_EM_OFF in RC and R0 - read completed.
2489	* @retval VINF_EM_SUSPEND in RC and R0 - read completed.
2490	* @retval VINF_EM_RESET in RC and R0 - read completed.
2491	* @retval VINF_EM_HALT in RC and R0 - read completed.
2492	* @retval VINF_SELM_SYNC_GDT in RC only - read completed.
2493	*
2494	* @retval VINF_EM_DBG_STOP in RC and R0 - read completed.
2495	* @retval VINF_EM_DBG_BREAKPOINT in RC and R0 - read completed.
2496	* @retval VINF_EM_RAW_EMULATE_INSTR in RC and R0 only.
2497	*
2498	* @retval VINF_IOM_R3_MMIO_READ in RC and R0.
2499	* @retval VINF_IOM_R3_MMIO_READ_WRITE in RC and R0.
2500	*
2501	* @retval VINF_PATM_CHECK_PATCH_PAGE in RC only.
2502	*
2503	* @retval VERR_PGM_PHYS_WR_HIT_HANDLER in RC and R0 for access origins that
2504	* haven't been cleared for strict status codes yet.
2505	*
2506	* @param pVM The cross context VM structure.
2507	* @param GCPhys Physical address start reading from.
2508	* @param pvBuf Where to put the read bits.
2509	* @param cbRead How many bytes to read.
2510	* @param enmOrigin The origin of this call.
2511	*/
2512	VMMDECL(VBOXSTRICTRC) PGMPhysRead(PVM pVM, RTGCPHYS GCPhys, void *pvBuf, size_t cbRead, PGMACCESSORIGIN enmOrigin)
2513	{
2514	AssertMsgReturn(cbRead > 0, ("don't even think about reading zero bytes!\n"), VINF_SUCCESS);
2515	LogFlow(("PGMPhysRead: %RGp %d\n", GCPhys, cbRead));
2516
2517	STAM_COUNTER_INC(&pVM->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,PhysRead));
2518	STAM_COUNTER_ADD(&pVM->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,PhysReadBytes), cbRead);
2519
2520	pgmLock(pVM);
2521
2522	/*
2523	* Copy loop on ram ranges.
2524	*/
2525	VBOXSTRICTRC rcStrict = VINF_SUCCESS;
2526	PPGMRAMRANGE pRam = pgmPhysGetRangeAtOrAbove(pVM, GCPhys);
2527	for (;;)
2528	{
2529	/* Inside range or not? */
2530	if (pRam && GCPhys >= pRam->GCPhys)
2531	{
2532	/*
2533	* Must work our way thru this page by page.
2534	*/
2535	RTGCPHYS off = GCPhys - pRam->GCPhys;
2536	while (off < pRam->cb)
2537	{
2538	unsigned iPage = off >> PAGE_SHIFT;
2539	PPGMPAGE pPage = &pRam->aPages[iPage];
2540	size_t cb = PAGE_SIZE - (off & PAGE_OFFSET_MASK);
2541	if (cb > cbRead)
2542	cb = cbRead;
2543
2544	/*
2545	* Normal page? Get the pointer to it.
2546	*/
2547	if ( !PGM_PAGE_HAS_ACTIVE_ALL_HANDLERS(pPage)
2548	&& !PGM_PAGE_IS_SPECIAL_ALIAS_MMIO(pPage))
2549	{
2550	/*
2551	* Get the pointer to the page.
2552	*/
2553	PGMPAGEMAPLOCK PgMpLck;
2554	const void *pvSrc;
2555	int rc = pgmPhysGCPhys2CCPtrInternalReadOnly(pVM, pPage, pRam->GCPhys + off, &pvSrc, &PgMpLck);
2556	if (RT_SUCCESS(rc))
2557	{
2558	memcpy(pvBuf, pvSrc, cb);
2559	pgmPhysReleaseInternalPageMappingLock(pVM, &PgMpLck);
2560	}
2561	else
2562	{
2563	AssertLogRelMsgFailed(("pgmPhysGCPhys2CCPtrInternalReadOnly failed on %RGp / %R[pgmpage] -> %Rrc\n",
2564	pRam->GCPhys + off, pPage, rc));
2565	memset(pvBuf, 0xff, cb);
2566	}
2567	}
2568	/*
2569	* Have ALL/MMIO access handlers.
2570	*/
2571	else
2572	{
2573	VBOXSTRICTRC rcStrict2 = pgmPhysReadHandler(pVM, pPage, pRam->GCPhys + off, pvBuf, cb, enmOrigin);
2574	if (PGM_PHYS_RW_IS_SUCCESS(rcStrict2))
2575	PGM_PHYS_RW_DO_UPDATE_STRICT_RC(rcStrict, rcStrict2);
2576	else
2577	{
2578	memset(pvBuf, 0xff, cb);
2579	pgmUnlock(pVM);
2580	return rcStrict2;
2581	}
2582	}
2583
2584	/* next page */
2585	if (cb >= cbRead)
2586	{
2587	pgmUnlock(pVM);
2588	return rcStrict;
2589	}
2590	cbRead -= cb;
2591	off += cb;
2592	pvBuf = (char *)pvBuf + cb;
2593	} /* walk pages in ram range. */
2594
2595	GCPhys = pRam->GCPhysLast + 1;
2596	}
2597	else
2598	{
2599	LogFlow(("PGMPhysRead: Unassigned %RGp size=%u\n", GCPhys, cbRead));
2600
2601	/*
2602	* Unassigned address space.
2603	*/
2604	size_t cb = pRam ? pRam->GCPhys - GCPhys : ~(size_t)0;
2605	if (cb >= cbRead)
2606	{
2607	memset(pvBuf, 0xff, cbRead);
2608	break;
2609	}
2610	memset(pvBuf, 0xff, cb);
2611
2612	cbRead -= cb;
2613	pvBuf = (char *)pvBuf + cb;
2614	GCPhys += cb;
2615	}
2616
2617	/* Advance range if necessary. */
2618	while (pRam && GCPhys > pRam->GCPhysLast)
2619	pRam = pRam->CTX_SUFF(pNext);
2620	} /* Ram range walk */
2621
2622	pgmUnlock(pVM);
2623	return rcStrict;
2624	}
2625
2626
2627	/**
2628	* Deals with writing to a page with one or more WRITE or ALL access handlers.
2629	*
2630	* @returns Strict VBox status code in ring-0 and raw-mode, ignorable in ring-3.
2631	* See PGM_HANDLER_PHYS_IS_VALID_STATUS and
2632	* PGM_HANDLER_VIRT_IS_VALID_STATUS for details.
2633	*
2634	* @param pVM The cross context VM structure.
2635	* @param pPage The page descriptor.
2636	* @param GCPhys The physical address to start writing at.
2637	* @param pvBuf What to write.
2638	* @param cbWrite How much to write - less or equal to a page.
2639	* @param enmOrigin The origin of this call.
2640	*/
2641	static VBOXSTRICTRC pgmPhysWriteHandler(PVM pVM, PPGMPAGE pPage, RTGCPHYS GCPhys, void const *pvBuf, size_t cbWrite,
2642	PGMACCESSORIGIN enmOrigin)
2643	{
2644	PGMPAGEMAPLOCK PgMpLck;
2645	void *pvDst = NULL;
2646	VBOXSTRICTRC rcStrict;
2647
2648	/*
2649	* Give priority to physical handlers (like #PF does).
2650	*
2651	* Hope for a lonely physical handler first that covers the whole
2652	* write area. This should be a pretty frequent case with MMIO and
2653	* the heavy usage of full page handlers in the page pool.
2654	*/
2655	PVMCPU pVCpu = VMMGetCpu(pVM);
2656	if ( !PGM_PAGE_HAS_ACTIVE_VIRTUAL_HANDLERS(pPage)
2657	\|\| PGM_PAGE_IS_MMIO_OR_SPECIAL_ALIAS(pPage) /* screw virtual handlers on MMIO pages */)
2658	{
2659	PPGMPHYSHANDLER pCur = pgmHandlerPhysicalLookup(pVM, GCPhys);
2660	if (pCur)
2661	{
2662	Assert(GCPhys >= pCur->Core.Key && GCPhys <= pCur->Core.KeyLast);
2663	#ifndef IN_RING3
2664	if (enmOrigin != PGMACCESSORIGIN_IEM)
2665	/* Cannot reliably handle informational status codes in this context */
2666	return VERR_PGM_PHYS_WR_HIT_HANDLER;
2667	#endif
2668	size_t cbRange = pCur->Core.KeyLast - GCPhys + 1;
2669	if (cbRange > cbWrite)
2670	cbRange = cbWrite;
2671
2672	Assert(PGMPHYSHANDLER_GET_TYPE(pVM, pCur)->CTX_SUFF(pfnHandler));
2673	Log5(("pgmPhysWriteHandler: GCPhys=%RGp cbRange=%#x pPage=%R[pgmpage] phys %s\n",
2674	GCPhys, cbRange, pPage, R3STRING(pCur->pszDesc) ));
2675	if (!PGM_PAGE_IS_MMIO_OR_SPECIAL_ALIAS(pPage))
2676	rcStrict = pgmPhysGCPhys2CCPtrInternal(pVM, pPage, GCPhys, &pvDst, &PgMpLck);
2677	else
2678	rcStrict = VINF_SUCCESS;
2679	if (RT_SUCCESS(rcStrict))
2680	{
2681	PFNPGMPHYSHANDLER pfnHandler = PGMPHYSHANDLER_GET_TYPE(pVM, pCur)->CTX_SUFF(pfnHandler);
2682	void *pvUser = pCur->CTX_SUFF(pvUser);
2683	STAM_PROFILE_START(&pCur->Stat, h);
2684
2685	/* Release the PGM lock as MMIO handlers take the IOM lock. (deadlock prevention) */
2686	PGM_LOCK_ASSERT_OWNER(pVM);
2687	pgmUnlock(pVM);
2688	rcStrict = pfnHandler(pVM, pVCpu, GCPhys, pvDst, (void *)pvBuf, cbRange, PGMACCESSTYPE_WRITE, enmOrigin, pvUser);
2689	pgmLock(pVM);
2690
2691	#ifdef VBOX_WITH_STATISTICS
2692	pCur = pgmHandlerPhysicalLookup(pVM, GCPhys);
2693	if (pCur)
2694	STAM_PROFILE_STOP(&pCur->Stat, h);
2695	#else
2696	pCur = NULL; /* might not be valid anymore. */
2697	#endif
2698	if (rcStrict == VINF_PGM_HANDLER_DO_DEFAULT)
2699	{
2700	if (pvDst)
2701	memcpy(pvDst, pvBuf, cbRange);
2702	rcStrict = VINF_SUCCESS;
2703	}
2704	else
2705	AssertLogRelMsg(PGM_HANDLER_PHYS_IS_VALID_STATUS(rcStrict, true),
2706	("rcStrict=%Rrc GCPhys=%RGp pPage=%R[pgmpage] %s\n",
2707	VBOXSTRICTRC_VAL(rcStrict), GCPhys, pPage, pCur ? R3STRING(pCur->pszDesc) : ""));
2708	}
2709	else
2710	AssertLogRelMsgFailedReturn(("pgmPhysGCPhys2CCPtrInternal failed on %RGp / %R[pgmpage] -> %Rrc\n",
2711	GCPhys, pPage, VBOXSTRICTRC_VAL(rcStrict)), rcStrict);
2712	if (RT_LIKELY(cbRange == cbWrite) \|\| !PGM_PHYS_RW_IS_SUCCESS(rcStrict))
2713	{
2714	if (pvDst)
2715	pgmPhysReleaseInternalPageMappingLock(pVM, &PgMpLck);
2716	return rcStrict;
2717	}
2718
2719	/* more fun to be had below */
2720	cbWrite -= cbRange;
2721	GCPhys += cbRange;
2722	pvBuf = (uint8_t *)pvBuf + cbRange;
2723	pvDst = (uint8_t *)pvDst + cbRange;
2724	}
2725	else /* The handler is somewhere else in the page, deal with it below. */
2726	rcStrict = VINF_SUCCESS;
2727	Assert(!PGM_PAGE_IS_MMIO_OR_ALIAS(pPage)); /* MMIO handlers are all PAGE_SIZEed! */
2728	}
2729	#if !defined(IN_RING0) && defined(VBOX_WITH_RAW_MODE)
2730	/*
2731	* A virtual handler without any interfering physical handlers.
2732	* Hopefully it'll cover the whole write.
2733	*/
2734	else if (!PGM_PAGE_HAS_ACTIVE_PHYSICAL_HANDLERS(pPage))
2735	{
2736	unsigned iPage;
2737	PPGMVIRTHANDLER pVirt = pgmHandlerVirtualFindByPhysAddr(pVM, GCPhys, &iPage);
2738	if (pVirt)
2739	{
2740	# ifndef IN_RING3
2741	if (enmOrigin != PGMACCESSORIGIN_IEM)
2742	/* Cannot reliably handle informational status codes in this context */
2743	return VERR_PGM_PHYS_WR_HIT_HANDLER;
2744	# endif
2745	PPGMVIRTHANDLERTYPEINT pVirtType = PGMVIRTANDLER_GET_TYPE(pVM, pVirt);
2746	size_t cbRange = (PAGE_OFFSET_MASK & pVirt->Core.KeyLast) - (PAGE_OFFSET_MASK & GCPhys) + 1;
2747	if (cbRange > cbWrite)
2748	cbRange = cbWrite;
2749
2750	Log5(("pgmPhysWriteHandler: GCPhys=%RGp cbRange=%#x pPage=%R[pgmpage] virt %s\n",
2751	GCPhys, cbRange, pPage, R3STRING(pVirt->pszDesc) ));
2752	rcStrict = pgmPhysGCPhys2CCPtrInternal(pVM, pPage, GCPhys, &pvDst, &PgMpLck);
2753	if (RT_SUCCESS(rcStrict))
2754	{
2755	Assert(pVirtType->CTX_SUFF(pfnHandler));
2756	RTGCUINTPTR GCPtr = ((RTGCUINTPTR)pVirt->Core.Key & PAGE_BASE_GC_MASK)
2757	+ (iPage << PAGE_SHIFT)
2758	+ (GCPhys & PAGE_OFFSET_MASK);
2759
2760	STAM_PROFILE_START(&pVirt->Stat, h);
2761	rcStrict = pVirtType->CTX_SUFF(pfnHandler)(pVM, pVCpu, GCPtr, pvDst, (void *)pvBuf, cbRange,
2762	PGMACCESSTYPE_WRITE, enmOrigin, pVirt->CTX_SUFF(pvUser));
2763	STAM_PROFILE_STOP(&pVirt->Stat, h);
2764	if (rcStrict == VINF_PGM_HANDLER_DO_DEFAULT)
2765	{
2766	memcpy(pvDst, pvBuf, cbRange);
2767	rcStrict = VINF_SUCCESS;
2768	}
2769	else
2770	AssertLogRelMsg(PGM_HANDLER_VIRT_IS_VALID_STATUS(rcStrict, true),
2771	("rcStrict=%Rrc GCPhys=%RGp pPage=%R[pgmpage] %s\n",
2772	VBOXSTRICTRC_VAL(rcStrict), GCPhys, pPage, R3STRING(pVirt->pszDesc)));
2773	}
2774	else
2775	AssertLogRelMsgFailedReturn(("pgmPhysGCPhys2CCPtrInternal failed on %RGp / %R[pgmpage] -> %Rrc\n",
2776	GCPhys, pPage, VBOXSTRICTRC_VAL(rcStrict)), rcStrict);
2777	if (RT_LIKELY(cbRange == cbWrite) \|\| !PGM_PHYS_RW_IS_SUCCESS(rcStrict))
2778	{
2779	pgmPhysReleaseInternalPageMappingLock(pVM, &PgMpLck);
2780	return rcStrict;
2781	}
2782
2783	/* more fun to be had below */
2784	cbWrite -= cbRange;
2785	GCPhys += cbRange;
2786	pvBuf = (uint8_t *)pvBuf + cbRange;
2787	pvDst = (uint8_t *)pvDst + cbRange;
2788	}
2789	else /* The handler is somewhere else in the page, deal with it below. */
2790	rcStrict = VINF_SUCCESS;
2791	}
2792	#endif /* !IN_RING0 && VBOX_WITH_RAW_MODE */
2793	else
2794	rcStrict = VINF_SUCCESS;
2795
2796
2797	/*
2798	* Deal with all the odd ends.
2799	*/
2800	Assert(rcStrict != VINF_PGM_HANDLER_DO_DEFAULT);
2801
2802	/* We need a writable destination page. */
2803	if (!pvDst)
2804	{
2805	int rc2 = pgmPhysGCPhys2CCPtrInternal(pVM, pPage, GCPhys, &pvDst, &PgMpLck);
2806	AssertLogRelMsgReturn(RT_SUCCESS(rc2),
2807	("pgmPhysGCPhys2CCPtrInternal failed on %RGp / %R[pgmpage] -> %Rrc\n", GCPhys, pPage, rc2),
2808	rc2);
2809	}
2810
2811	/* The loop state (big + ugly). */
2812	#if !defined(IN_RING0) && defined(VBOX_WITH_RAW_MODE)
2813	unsigned iVirtPage = 0;
2814	PPGMVIRTHANDLER pVirt = NULL;
2815	uint32_t offVirt = PAGE_SIZE;
2816	uint32_t offVirtLast = PAGE_SIZE;
2817	bool fMoreVirt = PGM_PAGE_HAS_ACTIVE_VIRTUAL_HANDLERS(pPage);
2818	#else
2819	uint32_t const offVirt = UINT32_MAX;
2820	#endif
2821
2822	PPGMPHYSHANDLER pPhys = NULL;
2823	uint32_t offPhys = PAGE_SIZE;
2824	uint32_t offPhysLast = PAGE_SIZE;
2825	bool fMorePhys = PGM_PAGE_HAS_ACTIVE_PHYSICAL_HANDLERS(pPage);
2826
2827	/* The loop. */
2828	for (;;)
2829	{
2830	#if !defined(IN_RING0) && defined(VBOX_WITH_RAW_MODE)
2831	/*
2832	* Find the closest handler at or above GCPhys.
2833	*/
2834	if (fMoreVirt && !pVirt)
2835	{
2836	pVirt = pgmHandlerVirtualFindByPhysAddr(pVM, GCPhys, &iVirtPage);
2837	if (pVirt)
2838	{
2839	offVirt = 0;
2840	offVirtLast = (pVirt->aPhysToVirt[iVirtPage].Core.KeyLast & PAGE_OFFSET_MASK) - (GCPhys & PAGE_OFFSET_MASK);
2841	}
2842	else
2843	{
2844	PPGMPHYS2VIRTHANDLER pVirtPhys;
2845	pVirtPhys = (PPGMPHYS2VIRTHANDLER)RTAvlroGCPhysGetBestFit(&pVM->pgm.s.CTX_SUFF(pTrees)->PhysToVirtHandlers,
2846	GCPhys, true /* fAbove */);
2847	if ( pVirtPhys
2848	&& (pVirtPhys->Core.Key >> PAGE_SHIFT) == (GCPhys >> PAGE_SHIFT))
2849	{
2850	/* ASSUME that pVirtPhys only covers one page. */
2851	Assert((pVirtPhys->Core.Key >> PAGE_SHIFT) == (pVirtPhys->Core.KeyLast >> PAGE_SHIFT));
2852	Assert(pVirtPhys->Core.Key > GCPhys);
2853
2854	pVirt = (PPGMVIRTHANDLER)((uintptr_t)pVirtPhys + pVirtPhys->offVirtHandler);
2855	iVirtPage = pVirtPhys - &pVirt->aPhysToVirt[0]; Assert(iVirtPage == 0);
2856	offVirt = (pVirtPhys->Core.Key & PAGE_OFFSET_MASK) - (GCPhys & PAGE_OFFSET_MASK);
2857	offVirtLast = (pVirtPhys->Core.KeyLast & PAGE_OFFSET_MASK) - (GCPhys & PAGE_OFFSET_MASK);
2858	}
2859	else
2860	{
2861	pVirt = NULL;
2862	fMoreVirt = false;
2863	offVirt = offVirtLast = PAGE_SIZE;
2864	}
2865	}
2866	}
2867	#endif
2868
2869	if (fMorePhys && !pPhys)
2870	{
2871	pPhys = pgmHandlerPhysicalLookup(pVM, GCPhys);
2872	if (pPhys)
2873	{
2874	offPhys = 0;
2875	offPhysLast = pPhys->Core.KeyLast - GCPhys; /* ASSUMES < 4GB handlers... */
2876	}
2877	else
2878	{
2879	pPhys = (PPGMPHYSHANDLER)RTAvlroGCPhysGetBestFit(&pVM->pgm.s.CTX_SUFF(pTrees)->PhysHandlers,
2880	GCPhys, true /* fAbove */);
2881	if ( pPhys
2882	&& pPhys->Core.Key <= GCPhys + (cbWrite - 1))
2883	{
2884	offPhys = pPhys->Core.Key - GCPhys;
2885	offPhysLast = pPhys->Core.KeyLast - GCPhys; /* ASSUMES < 4GB handlers... */
2886	}
2887	else
2888	{
2889	pPhys = NULL;
2890	fMorePhys = false;
2891	offPhys = offPhysLast = PAGE_SIZE;
2892	}
2893	}
2894	}
2895
2896	/*
2897	* Handle access to space without handlers (that's easy).
2898	*/
2899	VBOXSTRICTRC rcStrict2 = VINF_PGM_HANDLER_DO_DEFAULT;
2900	uint32_t cbRange = (uint32_t)cbWrite;
2901	if (offPhys != 0 && offVirt != 0)
2902	{
2903	if (cbRange > offPhys)
2904	cbRange = offPhys;
2905	if (cbRange > offVirt)
2906	cbRange = offVirt;
2907	Log5(("pgmPhysWriteHandler: GCPhys=%RGp cbRange=%#x pPage=%R[pgmpage] miss\n", GCPhys, cbRange, pPage));
2908	}
2909	/*
2910	* Physical handler.
2911	*/
2912	else if (!offPhys && offVirt)
2913	{
2914	#ifndef IN_RING3
2915	if (enmOrigin != PGMACCESSORIGIN_IEM)
2916	/* Cannot reliably handle informational status codes in this context */
2917	return VERR_PGM_PHYS_WR_HIT_HANDLER;
2918	#endif
2919	if (cbRange > offPhysLast + 1)
2920	cbRange = offPhysLast + 1;
2921	if (cbRange > offVirt)
2922	cbRange = offVirt;
2923
2924	PFNPGMPHYSHANDLER pfnHandler = PGMPHYSHANDLER_GET_TYPE(pVM, pPhys)->CTX_SUFF(pfnHandler);
2925	void *pvUser = pPhys->CTX_SUFF(pvUser);
2926
2927	Log5(("pgmPhysWriteHandler: GCPhys=%RGp cbRange=%#x pPage=%R[pgmpage] phys %s\n", GCPhys, cbRange, pPage, R3STRING(pPhys->pszDesc) ));
2928	STAM_PROFILE_START(&pPhys->Stat, h);
2929
2930	/* Release the PGM lock as MMIO handlers take the IOM lock. (deadlock prevention) */
2931	PGM_LOCK_ASSERT_OWNER(pVM);
2932	pgmUnlock(pVM);
2933	rcStrict2 = pfnHandler(pVM, pVCpu, GCPhys, pvDst, (void *)pvBuf, cbRange, PGMACCESSTYPE_WRITE, enmOrigin, pvUser);
2934	pgmLock(pVM);
2935
2936	#ifdef VBOX_WITH_STATISTICS
2937	pPhys = pgmHandlerPhysicalLookup(pVM, GCPhys);
2938	if (pPhys)
2939	STAM_PROFILE_STOP(&pPhys->Stat, h);
2940	#else
2941	pPhys = NULL; /* might not be valid anymore. */
2942	#endif
2943	AssertLogRelMsg(PGM_HANDLER_PHYS_IS_VALID_STATUS(rcStrict2, true),
2944	("rcStrict2=%Rrc (rcStrict=%Rrc) GCPhys=%RGp pPage=%R[pgmpage] %s\n", VBOXSTRICTRC_VAL(rcStrict2),
2945	VBOXSTRICTRC_VAL(rcStrict), GCPhys, pPage, pPhys ? R3STRING(pPhys->pszDesc) : ""));
2946	}
2947	#if !defined(IN_RING0) && defined(VBOX_WITH_RAW_MODE)
2948	/*
2949	* Virtual handler.
2950	*/
2951	else if (offPhys && !offVirt)
2952	{
2953	# ifndef IN_RING3
2954	if (enmOrigin != PGMACCESSORIGIN_IEM)
2955	/* Cannot reliably handle informational status codes in this context */
2956	return VERR_PGM_PHYS_WR_HIT_HANDLER;
2957	# endif
2958	if (cbRange > offVirtLast + 1)
2959	cbRange = offVirtLast + 1;
2960	if (cbRange > offPhys)
2961	cbRange = offPhys;
2962
2963	PPGMVIRTHANDLERTYPEINT pVirtType = PGMVIRTANDLER_GET_TYPE(pVM, pVirt);
2964	Log5(("pgmPhysWriteHandler: GCPhys=%RGp cbRange=%#x pPage=%R[pgmpage] phys %s\n", GCPhys, cbRange, pPage, R3STRING(pVirt->pszDesc) ));
2965	Assert(pVirtType->CTX_SUFF(pfnHandler));
2966	RTGCUINTPTR GCPtr = ((RTGCUINTPTR)pVirt->Core.Key & PAGE_BASE_GC_MASK)
2967	+ (iVirtPage << PAGE_SHIFT)
2968	+ (GCPhys & PAGE_OFFSET_MASK);
2969	STAM_PROFILE_START(&pVirt->Stat, h);
2970	rcStrict2 = pVirtType->CTX_SUFF(pfnHandler)(pVM, pVCpu, GCPtr, pvDst, (void *)pvBuf, cbRange, PGMACCESSTYPE_WRITE,
2971	enmOrigin, pVirt->CTX_SUFF(pvUser));
2972	STAM_PROFILE_STOP(&pVirt->Stat, h);
2973	AssertLogRelMsg(PGM_HANDLER_VIRT_IS_VALID_STATUS(rcStrict2, true),
2974	("rcStrict2=%Rrc (rcStrict=%Rrc) GCPhys=%RGp pPage=%R[pgmpage] %s\n", VBOXSTRICTRC_VAL(rcStrict2),
2975	VBOXSTRICTRC_VAL(rcStrict), GCPhys, pPage, pPhys ? R3STRING(pPhys->pszDesc) : ""));
2976	pVirt = NULL;
2977	}
2978	/*
2979	* Both... give the physical one priority.
2980	*/
2981	else
2982	{
2983	# ifndef IN_RING3
2984	if (enmOrigin != PGMACCESSORIGIN_IEM)
2985	/* Cannot reliably handle informational status codes in this context */
2986	return VERR_PGM_PHYS_WR_HIT_HANDLER;
2987	# endif
2988	Assert(!offPhys && !offVirt);
2989	if (cbRange > offVirtLast + 1)
2990	cbRange = offVirtLast + 1;
2991	if (cbRange > offPhysLast + 1)
2992	cbRange = offPhysLast + 1;
2993
2994	PPGMVIRTHANDLERTYPEINT pVirtType = PGMVIRTANDLER_GET_TYPE(pVM, pVirt);
2995	if (pVirtType->pfnHandlerR3)
2996	Log(("pgmPhysWriteHandler: overlapping phys and virt handlers at %RGp %R[pgmpage]; cbRange=%#x\n", GCPhys, pPage, cbRange));
2997	Log5(("pgmPhysWriteHandler: GCPhys=%RGp cbRange=%#x pPage=%R[pgmpage] phys/virt %s/%s\n", GCPhys, cbRange, pPage, R3STRING(pPhys->pszDesc), R3STRING(pVirt->pszDesc) ));
2998
2999	PFNPGMPHYSHANDLER pfnHandler = PGMPHYSHANDLER_GET_TYPE(pVM, pPhys)->CTX_SUFF(pfnHandler);
3000	void *pvUser = pPhys->CTX_SUFF(pvUser);
3001	STAM_PROFILE_START(&pPhys->Stat, h);
3002
3003	/* Release the PGM lock as MMIO handlers take the IOM lock. (deadlock prevention) */
3004	PGM_LOCK_ASSERT_OWNER(pVM);
3005	pgmUnlock(pVM);
3006	rcStrict2 = pfnHandler(pVM, pVCpu, GCPhys, pvDst, (void *)pvBuf, cbRange, PGMACCESSTYPE_WRITE, enmOrigin, pvUser);
3007	pgmLock(pVM);
3008
3009	# ifdef VBOX_WITH_STATISTICS
3010	pPhys = pgmHandlerPhysicalLookup(pVM, GCPhys);
3011	if (pPhys)
3012	STAM_PROFILE_STOP(&pPhys->Stat, h);
3013	# else
3014	pPhys = NULL; /* might not be valid anymore. */
3015	# endif
3016	AssertLogRelMsg(PGM_HANDLER_PHYS_IS_VALID_STATUS(rcStrict2, true),
3017	("rcStrict2=%Rrc (rcStrict=%Rrc) GCPhys=%RGp pPage=%R[pgmpage] %s\n", VBOXSTRICTRC_VAL(rcStrict2),
3018	VBOXSTRICTRC_VAL(rcStrict), GCPhys, pPage, pPhys ? R3STRING(pPhys->pszDesc) : ""));
3019	if (rcStrict2 == VINF_PGM_HANDLER_DO_DEFAULT \|\| PGM_PHYS_RW_IS_SUCCESS(rcStrict2))
3020	{
3021	Assert(pVirtType->CTX_SUFF(pfnHandler));
3022	RTGCUINTPTR GCPtr = ((RTGCUINTPTR)pVirt->Core.Key & PAGE_BASE_GC_MASK)
3023	+ (iVirtPage << PAGE_SHIFT)
3024	+ (GCPhys & PAGE_OFFSET_MASK);
3025	pvUser = pVirt->CTX_SUFF(pvUser);
3026
3027	STAM_PROFILE_START(&pVirt->Stat, h2);
3028	VBOXSTRICTRC rcStrict3 = pVirtType->CTX_SUFF(pfnHandler)(pVM, pVCpu, GCPtr, pvDst, (void *)pvBuf, cbRange,
3029	PGMACCESSTYPE_WRITE, enmOrigin, pvUser);
3030	STAM_PROFILE_STOP(&pVirt->Stat, h2);
3031
3032	/* Merge the 3rd status into the 2nd. */
3033	if (rcStrict3 == VINF_SUCCESS)
3034	{
3035	if (rcStrict2 == VINF_PGM_HANDLER_DO_DEFAULT)
3036	rcStrict2 = VINF_SUCCESS;
3037	}
3038	else if (rcStrict3 != VINF_PGM_HANDLER_DO_DEFAULT)
3039	{
3040	AssertLogRelMsg(PGM_HANDLER_VIRT_IS_VALID_STATUS(rcStrict3, true),
3041	("rcStrict3=%Rrc (rcStrict2=%Rrc) (rcStrict=%Rrc) GCPhys=%RGp pPage=%R[pgmpage] %s\n",
3042	VBOXSTRICTRC_VAL(rcStrict3), VBOXSTRICTRC_VAL(rcStrict2), VBOXSTRICTRC_VAL(rcStrict),
3043	GCPhys, pPage, R3STRING(pVirt->pszDesc) ));
3044	if (rcStrict2 == VINF_PGM_HANDLER_DO_DEFAULT)
3045	rcStrict2 = rcStrict3;
3046	else if (!PGM_PHYS_RW_IS_SUCCESS(rcStrict3))
3047	rcStrict2 = rcStrict3;
3048	else
3049	PGM_PHYS_RW_DO_UPDATE_STRICT_RC(rcStrict2, rcStrict3);
3050	}
3051	}
3052	pPhys = NULL;
3053	pVirt = NULL;
3054	}
3055	#endif /* !IN_RING0 && VBOX_WITH_RAW_MODE */
3056
3057
3058	/*
3059	* Execute the default action and merge the status codes.
3060	*/
3061	if (rcStrict2 == VINF_PGM_HANDLER_DO_DEFAULT)
3062	{
3063	memcpy(pvDst, pvBuf, cbRange);
3064	rcStrict2 = VINF_SUCCESS;
3065	}
3066	else if (!PGM_PHYS_RW_IS_SUCCESS(rcStrict2))
3067	{
3068	pgmPhysReleaseInternalPageMappingLock(pVM, &PgMpLck);
3069	return rcStrict2;
3070	}
3071	else
3072	PGM_PHYS_RW_DO_UPDATE_STRICT_RC(rcStrict, rcStrict2);
3073
3074	/*
3075	* Advance if we've got more stuff to do.
3076	*/
3077	if (cbRange >= cbWrite)
3078	{
3079	pgmPhysReleaseInternalPageMappingLock(pVM, &PgMpLck);
3080	return rcStrict;
3081	}
3082
3083
3084	cbWrite -= cbRange;
3085	GCPhys += cbRange;
3086	pvBuf = (uint8_t *)pvBuf + cbRange;
3087	pvDst = (uint8_t *)pvDst + cbRange;
3088
3089	offPhys -= cbRange;
3090	offPhysLast -= cbRange;
3091	#if !defined(IN_RING0) && defined(VBOX_WITH_RAW_MODE)
3092	offVirt -= cbRange;
3093	offVirtLast -= cbRange;
3094	#endif
3095	}
3096	}
3097
3098
3099	/**
3100	* Write to physical memory.
3101	*
3102	* This API respects access handlers and MMIO. Use PGMPhysSimpleWriteGCPhys() if you
3103	* want to ignore those.
3104	*
3105	* @returns Strict VBox status code in raw-mode and ring-0, normal VBox status
3106	* code in ring-3. Use PGM_PHYS_RW_IS_SUCCESS to check.
3107	* @retval VINF_SUCCESS in all context - write completed.
3108	*
3109	* @retval VINF_EM_OFF in RC and R0 - write completed.
3110	* @retval VINF_EM_SUSPEND in RC and R0 - write completed.
3111	* @retval VINF_EM_RESET in RC and R0 - write completed.
3112	* @retval VINF_EM_HALT in RC and R0 - write completed.
3113	* @retval VINF_SELM_SYNC_GDT in RC only - write completed.
3114	*
3115	* @retval VINF_EM_DBG_STOP in RC and R0 - write completed.
3116	* @retval VINF_EM_DBG_BREAKPOINT in RC and R0 - write completed.
3117	* @retval VINF_EM_RAW_EMULATE_INSTR in RC and R0 only.
3118	*
3119	* @retval VINF_IOM_R3_MMIO_WRITE in RC and R0.
3120	* @retval VINF_IOM_R3_MMIO_READ_WRITE in RC and R0.
3121	* @retval VINF_IOM_R3_MMIO_COMMIT_WRITE in RC and R0.
3122	*
3123	* @retval VINF_EM_RAW_EMULATE_IO_BLOCK in R0 only.
3124	*
3125	* @retval VINF_EM_RAW_EMULATE_INSTR_GDT_FAULT in RC only - write completed.
3126	* @retval VINF_EM_RAW_EMULATE_INSTR_LDT_FAULT in RC only.
3127	* @retval VINF_EM_RAW_EMULATE_INSTR_TSS_FAULT in RC only.
3128	* @retval VINF_EM_RAW_EMULATE_INSTR_IDT_FAULT in RC only.
3129	* @retval VINF_CSAM_PENDING_ACTION in RC only.
3130	* @retval VINF_PATM_CHECK_PATCH_PAGE in RC only.
3131	*
3132	* @retval VERR_PGM_PHYS_WR_HIT_HANDLER in RC and R0 for access origins that
3133	* haven't been cleared for strict status codes yet.
3134	*
3135	*
3136	* @param pVM The cross context VM structure.
3137	* @param GCPhys Physical address to write to.
3138	* @param pvBuf What to write.
3139	* @param cbWrite How many bytes to write.
3140	* @param enmOrigin Who is calling.
3141	*/
3142	VMMDECL(VBOXSTRICTRC) PGMPhysWrite(PVM pVM, RTGCPHYS GCPhys, const void *pvBuf, size_t cbWrite, PGMACCESSORIGIN enmOrigin)
3143	{
3144	AssertMsg(!pVM->pgm.s.fNoMorePhysWrites, ("Calling PGMPhysWrite after pgmR3Save()! enmOrigin=%d\n", enmOrigin));
3145	AssertMsgReturn(cbWrite > 0, ("don't even think about writing zero bytes!\n"), VINF_SUCCESS);
3146	LogFlow(("PGMPhysWrite: %RGp %d\n", GCPhys, cbWrite));
3147
3148	STAM_COUNTER_INC(&pVM->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,PhysWrite));
3149	STAM_COUNTER_ADD(&pVM->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,PhysWriteBytes), cbWrite);
3150
3151	pgmLock(pVM);
3152
3153	/*
3154	* Copy loop on ram ranges.
3155	*/
3156	VBOXSTRICTRC rcStrict = VINF_SUCCESS;
3157	PPGMRAMRANGE pRam = pgmPhysGetRangeAtOrAbove(pVM, GCPhys);
3158	for (;;)
3159	{
3160	/* Inside range or not? */
3161	if (pRam && GCPhys >= pRam->GCPhys)
3162	{
3163	/*
3164	* Must work our way thru this page by page.
3165	*/
3166	RTGCPTR off = GCPhys - pRam->GCPhys;
3167	while (off < pRam->cb)
3168	{
3169	RTGCPTR iPage = off >> PAGE_SHIFT;
3170	PPGMPAGE pPage = &pRam->aPages[iPage];
3171	size_t cb = PAGE_SIZE - (off & PAGE_OFFSET_MASK);
3172	if (cb > cbWrite)
3173	cb = cbWrite;
3174
3175	/*
3176	* Normal page? Get the pointer to it.
3177	*/
3178	if ( !PGM_PAGE_HAS_ACTIVE_HANDLERS(pPage)
3179	&& !PGM_PAGE_IS_SPECIAL_ALIAS_MMIO(pPage))
3180	{
3181	PGMPAGEMAPLOCK PgMpLck;
3182	void *pvDst;
3183	int rc = pgmPhysGCPhys2CCPtrInternal(pVM, pPage, pRam->GCPhys + off, &pvDst, &PgMpLck);
3184	if (RT_SUCCESS(rc))
3185	{
3186	Assert(!PGM_PAGE_IS_BALLOONED(pPage));
3187	memcpy(pvDst, pvBuf, cb);
3188	pgmPhysReleaseInternalPageMappingLock(pVM, &PgMpLck);
3189	}
3190	/* Ignore writes to ballooned pages. */
3191	else if (!PGM_PAGE_IS_BALLOONED(pPage))
3192	AssertLogRelMsgFailed(("pgmPhysGCPhys2CCPtrInternal failed on %RGp / %R[pgmpage] -> %Rrc\n",
3193	pRam->GCPhys + off, pPage, rc));
3194	}
3195	/*
3196	* Active WRITE or ALL access handlers.
3197	*/
3198	else
3199	{
3200	VBOXSTRICTRC rcStrict2 = pgmPhysWriteHandler(pVM, pPage, pRam->GCPhys + off, pvBuf, cb, enmOrigin);
3201	if (PGM_PHYS_RW_IS_SUCCESS(rcStrict2))
3202	PGM_PHYS_RW_DO_UPDATE_STRICT_RC(rcStrict, rcStrict2);
3203	else
3204	{
3205	pgmUnlock(pVM);
3206	return rcStrict2;
3207	}
3208	}
3209
3210	/* next page */
3211	if (cb >= cbWrite)
3212	{
3213	pgmUnlock(pVM);
3214	return rcStrict;
3215	}
3216
3217	cbWrite -= cb;
3218	off += cb;
3219	pvBuf = (const char *)pvBuf + cb;
3220	} /* walk pages in ram range */
3221
3222	GCPhys = pRam->GCPhysLast + 1;
3223	}
3224	else
3225	{
3226	/*
3227	* Unassigned address space, skip it.
3228	*/
3229	if (!pRam)
3230	break;
3231	size_t cb = pRam->GCPhys - GCPhys;
3232	if (cb >= cbWrite)
3233	break;
3234	cbWrite -= cb;
3235	pvBuf = (const char *)pvBuf + cb;
3236	GCPhys += cb;
3237	}
3238
3239	/* Advance range if necessary. */
3240	while (pRam && GCPhys > pRam->GCPhysLast)
3241	pRam = pRam->CTX_SUFF(pNext);
3242	} /* Ram range walk */
3243
3244	pgmUnlock(pVM);
3245	return rcStrict;
3246	}
3247
3248
3249	/**
3250	* Read from guest physical memory by GC physical address, bypassing
3251	* MMIO and access handlers.
3252	*
3253	* @returns VBox status code.
3254	* @param pVM The cross context VM structure.
3255	* @param pvDst The destination address.
3256	* @param GCPhysSrc The source address (GC physical address).
3257	* @param cb The number of bytes to read.
3258	*/
3259	VMMDECL(int) PGMPhysSimpleReadGCPhys(PVM pVM, void *pvDst, RTGCPHYS GCPhysSrc, size_t cb)
3260	{
3261	/*
3262	* Treat the first page as a special case.
3263	*/
3264	if (!cb)
3265	return VINF_SUCCESS;
3266
3267	/* map the 1st page */
3268	void const *pvSrc;
3269	PGMPAGEMAPLOCK Lock;
3270	int rc = PGMPhysGCPhys2CCPtrReadOnly(pVM, GCPhysSrc, &pvSrc, &Lock);
3271	if (RT_FAILURE(rc))
3272	return rc;
3273
3274	/* optimize for the case where access is completely within the first page. */
3275	size_t cbPage = PAGE_SIZE - (GCPhysSrc & PAGE_OFFSET_MASK);
3276	if (RT_LIKELY(cb <= cbPage))
3277	{
3278	memcpy(pvDst, pvSrc, cb);
3279	PGMPhysReleasePageMappingLock(pVM, &Lock);
3280	return VINF_SUCCESS;
3281	}
3282
3283	/* copy to the end of the page. */
3284	memcpy(pvDst, pvSrc, cbPage);
3285	PGMPhysReleasePageMappingLock(pVM, &Lock);
3286	GCPhysSrc += cbPage;
3287	pvDst = (uint8_t *)pvDst + cbPage;
3288	cb -= cbPage;
3289
3290	/*
3291	* Page by page.
3292	*/
3293	for (;;)
3294	{
3295	/* map the page */
3296	rc = PGMPhysGCPhys2CCPtrReadOnly(pVM, GCPhysSrc, &pvSrc, &Lock);
3297	if (RT_FAILURE(rc))
3298	return rc;
3299
3300	/* last page? */
3301	if (cb <= PAGE_SIZE)
3302	{
3303	memcpy(pvDst, pvSrc, cb);
3304	PGMPhysReleasePageMappingLock(pVM, &Lock);
3305	return VINF_SUCCESS;
3306	}
3307
3308	/* copy the entire page and advance */
3309	memcpy(pvDst, pvSrc, PAGE_SIZE);
3310	PGMPhysReleasePageMappingLock(pVM, &Lock);
3311	GCPhysSrc += PAGE_SIZE;
3312	pvDst = (uint8_t *)pvDst + PAGE_SIZE;
3313	cb -= PAGE_SIZE;
3314	}
3315	/* won't ever get here. */
3316	}
3317
3318
3319	/**
3320	* Write to guest physical memory referenced by GC pointer.
3321	* Write memory to GC physical address in guest physical memory.
3322	*
3323	* This will bypass MMIO and access handlers.
3324	*
3325	* @returns VBox status code.
3326	* @param pVM The cross context VM structure.
3327	* @param GCPhysDst The GC physical address of the destination.
3328	* @param pvSrc The source buffer.
3329	* @param cb The number of bytes to write.
3330	*/
3331	VMMDECL(int) PGMPhysSimpleWriteGCPhys(PVM pVM, RTGCPHYS GCPhysDst, const void *pvSrc, size_t cb)
3332	{
3333	LogFlow(("PGMPhysSimpleWriteGCPhys: %RGp %zu\n", GCPhysDst, cb));
3334
3335	/*
3336	* Treat the first page as a special case.
3337	*/
3338	if (!cb)
3339	return VINF_SUCCESS;
3340
3341	/* map the 1st page */
3342	void *pvDst;
3343	PGMPAGEMAPLOCK Lock;
3344	int rc = PGMPhysGCPhys2CCPtr(pVM, GCPhysDst, &pvDst, &Lock);
3345	if (RT_FAILURE(rc))
3346	return rc;
3347
3348	/* optimize for the case where access is completely within the first page. */
3349	size_t cbPage = PAGE_SIZE - (GCPhysDst & PAGE_OFFSET_MASK);
3350	if (RT_LIKELY(cb <= cbPage))
3351	{
3352	memcpy(pvDst, pvSrc, cb);
3353	PGMPhysReleasePageMappingLock(pVM, &Lock);
3354	return VINF_SUCCESS;
3355	}
3356
3357	/* copy to the end of the page. */
3358	memcpy(pvDst, pvSrc, cbPage);
3359	PGMPhysReleasePageMappingLock(pVM, &Lock);
3360	GCPhysDst += cbPage;
3361	pvSrc = (const uint8_t *)pvSrc + cbPage;
3362	cb -= cbPage;
3363
3364	/*
3365	* Page by page.
3366	*/
3367	for (;;)
3368	{
3369	/* map the page */
3370	rc = PGMPhysGCPhys2CCPtr(pVM, GCPhysDst, &pvDst, &Lock);
3371	if (RT_FAILURE(rc))
3372	return rc;
3373
3374	/* last page? */
3375	if (cb <= PAGE_SIZE)
3376	{
3377	memcpy(pvDst, pvSrc, cb);
3378	PGMPhysReleasePageMappingLock(pVM, &Lock);
3379	return VINF_SUCCESS;
3380	}
3381
3382	/* copy the entire page and advance */
3383	memcpy(pvDst, pvSrc, PAGE_SIZE);
3384	PGMPhysReleasePageMappingLock(pVM, &Lock);
3385	GCPhysDst += PAGE_SIZE;
3386	pvSrc = (const uint8_t *)pvSrc + PAGE_SIZE;
3387	cb -= PAGE_SIZE;
3388	}
3389	/* won't ever get here. */
3390	}
3391
3392
3393	/**
3394	* Read from guest physical memory referenced by GC pointer.
3395	*
3396	* This function uses the current CR3/CR0/CR4 of the guest and will
3397	* bypass access handlers and not set any accessed bits.
3398	*
3399	* @returns VBox status code.
3400	* @param pVCpu The cross context virtual CPU structure of the calling EMT.
3401	* @param pvDst The destination address.
3402	* @param GCPtrSrc The source address (GC pointer).
3403	* @param cb The number of bytes to read.
3404	*/
3405	VMMDECL(int) PGMPhysSimpleReadGCPtr(PVMCPU pVCpu, void *pvDst, RTGCPTR GCPtrSrc, size_t cb)
3406	{
3407	PVM pVM = pVCpu->CTX_SUFF(pVM);
3408	/** @todo fix the macro / state handling: VMCPU_ASSERT_EMT_OR_GURU(pVCpu); */
3409
3410	/*
3411	* Treat the first page as a special case.
3412	*/
3413	if (!cb)
3414	return VINF_SUCCESS;
3415
3416	STAM_COUNTER_INC(&pVM->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,PhysSimpleRead));
3417	STAM_COUNTER_ADD(&pVM->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,PhysSimpleReadBytes), cb);
3418
3419	/* Take the PGM lock here, because many called functions take the lock for a very short period. That's counter-productive
3420	* when many VCPUs are fighting for the lock.
3421	*/
3422	pgmLock(pVM);
3423
3424	/* map the 1st page */
3425	void const *pvSrc;
3426	PGMPAGEMAPLOCK Lock;
3427	int rc = PGMPhysGCPtr2CCPtrReadOnly(pVCpu, GCPtrSrc, &pvSrc, &Lock);
3428	if (RT_FAILURE(rc))
3429	{
3430	pgmUnlock(pVM);
3431	return rc;
3432	}
3433
3434	/* optimize for the case where access is completely within the first page. */
3435	size_t cbPage = PAGE_SIZE - ((RTGCUINTPTR)GCPtrSrc & PAGE_OFFSET_MASK);
3436	if (RT_LIKELY(cb <= cbPage))
3437	{
3438	memcpy(pvDst, pvSrc, cb);
3439	PGMPhysReleasePageMappingLock(pVM, &Lock);
3440	pgmUnlock(pVM);
3441	return VINF_SUCCESS;
3442	}
3443
3444	/* copy to the end of the page. */
3445	memcpy(pvDst, pvSrc, cbPage);
3446	PGMPhysReleasePageMappingLock(pVM, &Lock);
3447	GCPtrSrc = (RTGCPTR)((RTGCUINTPTR)GCPtrSrc + cbPage);
3448	pvDst = (uint8_t *)pvDst + cbPage;
3449	cb -= cbPage;
3450
3451	/*
3452	* Page by page.
3453	*/
3454	for (;;)
3455	{
3456	/* map the page */
3457	rc = PGMPhysGCPtr2CCPtrReadOnly(pVCpu, GCPtrSrc, &pvSrc, &Lock);
3458	if (RT_FAILURE(rc))
3459	{
3460	pgmUnlock(pVM);
3461	return rc;
3462	}
3463
3464	/* last page? */
3465	if (cb <= PAGE_SIZE)
3466	{
3467	memcpy(pvDst, pvSrc, cb);
3468	PGMPhysReleasePageMappingLock(pVM, &Lock);
3469	pgmUnlock(pVM);
3470	return VINF_SUCCESS;
3471	}
3472
3473	/* copy the entire page and advance */
3474	memcpy(pvDst, pvSrc, PAGE_SIZE);
3475	PGMPhysReleasePageMappingLock(pVM, &Lock);
3476	GCPtrSrc = (RTGCPTR)((RTGCUINTPTR)GCPtrSrc + PAGE_SIZE);
3477	pvDst = (uint8_t *)pvDst + PAGE_SIZE;
3478	cb -= PAGE_SIZE;
3479	}
3480	/* won't ever get here. */
3481	}
3482
3483
3484	/**
3485	* Write to guest physical memory referenced by GC pointer.
3486	*
3487	* This function uses the current CR3/CR0/CR4 of the guest and will
3488	* bypass access handlers and not set dirty or accessed bits.
3489	*
3490	* @returns VBox status code.
3491	* @param pVCpu The cross context virtual CPU structure of the calling EMT.
3492	* @param GCPtrDst The destination address (GC pointer).
3493	* @param pvSrc The source address.
3494	* @param cb The number of bytes to write.
3495	*/
3496	VMMDECL(int) PGMPhysSimpleWriteGCPtr(PVMCPU pVCpu, RTGCPTR GCPtrDst, const void *pvSrc, size_t cb)
3497	{
3498	PVM pVM = pVCpu->CTX_SUFF(pVM);
3499	VMCPU_ASSERT_EMT(pVCpu);
3500
3501	/*
3502	* Treat the first page as a special case.
3503	*/
3504	if (!cb)
3505	return VINF_SUCCESS;
3506
3507	STAM_COUNTER_INC(&pVM->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,PhysSimpleWrite));
3508	STAM_COUNTER_ADD(&pVM->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,PhysSimpleWriteBytes), cb);
3509
3510	/* map the 1st page */
3511	void *pvDst;
3512	PGMPAGEMAPLOCK Lock;
3513	int rc = PGMPhysGCPtr2CCPtr(pVCpu, GCPtrDst, &pvDst, &Lock);
3514	if (RT_FAILURE(rc))
3515	return rc;
3516
3517	/* optimize for the case where access is completely within the first page. */
3518	size_t cbPage = PAGE_SIZE - ((RTGCUINTPTR)GCPtrDst & PAGE_OFFSET_MASK);
3519	if (RT_LIKELY(cb <= cbPage))
3520	{
3521	memcpy(pvDst, pvSrc, cb);
3522	PGMPhysReleasePageMappingLock(pVM, &Lock);
3523	return VINF_SUCCESS;
3524	}
3525
3526	/* copy to the end of the page. */
3527	memcpy(pvDst, pvSrc, cbPage);
3528	PGMPhysReleasePageMappingLock(pVM, &Lock);
3529	GCPtrDst = (RTGCPTR)((RTGCUINTPTR)GCPtrDst + cbPage);
3530	pvSrc = (const uint8_t *)pvSrc + cbPage;
3531	cb -= cbPage;
3532
3533	/*
3534	* Page by page.
3535	*/
3536	for (;;)
3537	{
3538	/* map the page */
3539	rc = PGMPhysGCPtr2CCPtr(pVCpu, GCPtrDst, &pvDst, &Lock);
3540	if (RT_FAILURE(rc))
3541	return rc;
3542
3543	/* last page? */
3544	if (cb <= PAGE_SIZE)
3545	{
3546	memcpy(pvDst, pvSrc, cb);
3547	PGMPhysReleasePageMappingLock(pVM, &Lock);
3548	return VINF_SUCCESS;
3549	}
3550
3551	/* copy the entire page and advance */
3552	memcpy(pvDst, pvSrc, PAGE_SIZE);
3553	PGMPhysReleasePageMappingLock(pVM, &Lock);
3554	GCPtrDst = (RTGCPTR)((RTGCUINTPTR)GCPtrDst + PAGE_SIZE);
3555	pvSrc = (const uint8_t *)pvSrc + PAGE_SIZE;
3556	cb -= PAGE_SIZE;
3557	}
3558	/* won't ever get here. */
3559	}
3560
3561
3562	/**
3563	* Write to guest physical memory referenced by GC pointer and update the PTE.
3564	*
3565	* This function uses the current CR3/CR0/CR4 of the guest and will
3566	* bypass access handlers but will set any dirty and accessed bits in the PTE.
3567	*
3568	* If you don't want to set the dirty bit, use PGMPhysSimpleWriteGCPtr().
3569	*
3570	* @returns VBox status code.
3571	* @param pVCpu The cross context virtual CPU structure of the calling EMT.
3572	* @param GCPtrDst The destination address (GC pointer).
3573	* @param pvSrc The source address.
3574	* @param cb The number of bytes to write.
3575	*/
3576	VMMDECL(int) PGMPhysSimpleDirtyWriteGCPtr(PVMCPU pVCpu, RTGCPTR GCPtrDst, const void *pvSrc, size_t cb)
3577	{
3578	PVM pVM = pVCpu->CTX_SUFF(pVM);
3579	VMCPU_ASSERT_EMT(pVCpu);
3580
3581	/*
3582	* Treat the first page as a special case.
3583	* Btw. this is the same code as in PGMPhyssimpleWriteGCPtr excep for the PGMGstModifyPage.
3584	*/
3585	if (!cb)
3586	return VINF_SUCCESS;
3587
3588	/* map the 1st page */
3589	void *pvDst;
3590	PGMPAGEMAPLOCK Lock;
3591	int rc = PGMPhysGCPtr2CCPtr(pVCpu, GCPtrDst, &pvDst, &Lock);
3592	if (RT_FAILURE(rc))
3593	return rc;
3594
3595	/* optimize for the case where access is completely within the first page. */
3596	size_t cbPage = PAGE_SIZE - ((RTGCUINTPTR)GCPtrDst & PAGE_OFFSET_MASK);
3597	if (RT_LIKELY(cb <= cbPage))
3598	{
3599	memcpy(pvDst, pvSrc, cb);
3600	PGMPhysReleasePageMappingLock(pVM, &Lock);
3601	rc = PGMGstModifyPage(pVCpu, GCPtrDst, 1, X86_PTE_A \| X86_PTE_D, ~(uint64_t)(X86_PTE_A \| X86_PTE_D)); AssertRC(rc);
3602	return VINF_SUCCESS;
3603	}
3604
3605	/* copy to the end of the page. */
3606	memcpy(pvDst, pvSrc, cbPage);
3607	PGMPhysReleasePageMappingLock(pVM, &Lock);
3608	rc = PGMGstModifyPage(pVCpu, GCPtrDst, 1, X86_PTE_A \| X86_PTE_D, ~(uint64_t)(X86_PTE_A \| X86_PTE_D)); AssertRC(rc);
3609	GCPtrDst = (RTGCPTR)((RTGCUINTPTR)GCPtrDst + cbPage);
3610	pvSrc = (const uint8_t *)pvSrc + cbPage;
3611	cb -= cbPage;
3612
3613	/*
3614	* Page by page.
3615	*/
3616	for (;;)
3617	{
3618	/* map the page */
3619	rc = PGMPhysGCPtr2CCPtr(pVCpu, GCPtrDst, &pvDst, &Lock);
3620	if (RT_FAILURE(rc))
3621	return rc;
3622
3623	/* last page? */
3624	if (cb <= PAGE_SIZE)
3625	{
3626	memcpy(pvDst, pvSrc, cb);
3627	PGMPhysReleasePageMappingLock(pVM, &Lock);
3628	rc = PGMGstModifyPage(pVCpu, GCPtrDst, 1, X86_PTE_A \| X86_PTE_D, ~(uint64_t)(X86_PTE_A \| X86_PTE_D)); AssertRC(rc);
3629	return VINF_SUCCESS;
3630	}
3631
3632	/* copy the entire page and advance */
3633	memcpy(pvDst, pvSrc, PAGE_SIZE);
3634	PGMPhysReleasePageMappingLock(pVM, &Lock);
3635	rc = PGMGstModifyPage(pVCpu, GCPtrDst, 1, X86_PTE_A \| X86_PTE_D, ~(uint64_t)(X86_PTE_A \| X86_PTE_D)); AssertRC(rc);
3636	GCPtrDst = (RTGCPTR)((RTGCUINTPTR)GCPtrDst + PAGE_SIZE);
3637	pvSrc = (const uint8_t *)pvSrc + PAGE_SIZE;
3638	cb -= PAGE_SIZE;
3639	}
3640	/* won't ever get here. */
3641	}
3642
3643
3644	/**
3645	* Read from guest physical memory referenced by GC pointer.
3646	*
3647	* This function uses the current CR3/CR0/CR4 of the guest and will
3648	* respect access handlers and set accessed bits.
3649	*
3650	* @returns Strict VBox status, see PGMPhysRead for details.
3651	* @retval VERR_PAGE_TABLE_NOT_PRESENT if there is no page mapped at the
3652	* specified virtual address.
3653	*
3654	* @param pVCpu The cross context virtual CPU structure of the calling EMT.
3655	* @param pvDst The destination address.
3656	* @param GCPtrSrc The source address (GC pointer).
3657	* @param cb The number of bytes to read.
3658	* @param enmOrigin Who is calling.
3659	* @thread EMT(pVCpu)
3660	*/
3661	VMMDECL(VBOXSTRICTRC) PGMPhysReadGCPtr(PVMCPU pVCpu, void *pvDst, RTGCPTR GCPtrSrc, size_t cb, PGMACCESSORIGIN enmOrigin)
3662	{
3663	RTGCPHYS GCPhys;
3664	uint64_t fFlags;
3665	int rc;
3666	PVM pVM = pVCpu->CTX_SUFF(pVM);
3667	VMCPU_ASSERT_EMT(pVCpu);
3668
3669	/*
3670	* Anything to do?
3671	*/
3672	if (!cb)
3673	return VINF_SUCCESS;
3674
3675	LogFlow(("PGMPhysReadGCPtr: %RGv %zu\n", GCPtrSrc, cb));
3676
3677	/*
3678	* Optimize reads within a single page.
3679	*/
3680	if (((RTGCUINTPTR)GCPtrSrc & PAGE_OFFSET_MASK) + cb <= PAGE_SIZE)
3681	{
3682	/* Convert virtual to physical address + flags */
3683	rc = PGM_GST_PFN(GetPage,pVCpu)(pVCpu, (RTGCUINTPTR)GCPtrSrc, &fFlags, &GCPhys);
3684	AssertMsgRCReturn(rc, ("GetPage failed with %Rrc for %RGv\n", rc, GCPtrSrc), rc);
3685	GCPhys \|= (RTGCUINTPTR)GCPtrSrc & PAGE_OFFSET_MASK;
3686
3687	/* mark the guest page as accessed. */
3688	if (!(fFlags & X86_PTE_A))
3689	{
3690	rc = PGMGstModifyPage(pVCpu, GCPtrSrc, 1, X86_PTE_A, ~(uint64_t)(X86_PTE_A));
3691	AssertRC(rc);
3692	}
3693
3694	return PGMPhysRead(pVM, GCPhys, pvDst, cb, enmOrigin);
3695	}
3696
3697	/*
3698	* Page by page.
3699	*/
3700	for (;;)
3701	{
3702	/* Convert virtual to physical address + flags */
3703	rc = PGM_GST_PFN(GetPage,pVCpu)(pVCpu, (RTGCUINTPTR)GCPtrSrc, &fFlags, &GCPhys);
3704	AssertMsgRCReturn(rc, ("GetPage failed with %Rrc for %RGv\n", rc, GCPtrSrc), rc);
3705	GCPhys \|= (RTGCUINTPTR)GCPtrSrc & PAGE_OFFSET_MASK;
3706
3707	/* mark the guest page as accessed. */
3708	if (!(fFlags & X86_PTE_A))
3709	{
3710	rc = PGMGstModifyPage(pVCpu, GCPtrSrc, 1, X86_PTE_A, ~(uint64_t)(X86_PTE_A));
3711	AssertRC(rc);
3712	}
3713
3714	/* copy */
3715	size_t cbRead = PAGE_SIZE - ((RTGCUINTPTR)GCPtrSrc & PAGE_OFFSET_MASK);
3716	if (cbRead < cb)
3717	{
3718	VBOXSTRICTRC rcStrict = PGMPhysRead(pVM, GCPhys, pvDst, cbRead, enmOrigin);
3719	if (RT_LIKELY(rcStrict == VINF_SUCCESS))
3720	{ /* likely */ }
3721	else
3722	return rcStrict;
3723	}
3724	else /* Last page (cbRead is PAGE_SIZE, we only need cb!) */
3725	return PGMPhysRead(pVM, GCPhys, pvDst, cb, enmOrigin);
3726
3727	/* next */
3728	Assert(cb > cbRead);
3729	cb -= cbRead;
3730	pvDst = (uint8_t *)pvDst + cbRead;
3731	GCPtrSrc += cbRead;
3732	}
3733	}
3734
3735
3736	/**
3737	* Write to guest physical memory referenced by GC pointer.
3738	*
3739	* This function uses the current CR3/CR0/CR4 of the guest and will
3740	* respect access handlers and set dirty and accessed bits.
3741	*
3742	* @returns Strict VBox status, see PGMPhysWrite for details.
3743	* @retval VERR_PAGE_TABLE_NOT_PRESENT if there is no page mapped at the
3744	* specified virtual address.
3745	*
3746	* @param pVCpu The cross context virtual CPU structure of the calling EMT.
3747	* @param GCPtrDst The destination address (GC pointer).
3748	* @param pvSrc The source address.
3749	* @param cb The number of bytes to write.
3750	* @param enmOrigin Who is calling.
3751	*/
3752	VMMDECL(VBOXSTRICTRC) PGMPhysWriteGCPtr(PVMCPU pVCpu, RTGCPTR GCPtrDst, const void *pvSrc, size_t cb, PGMACCESSORIGIN enmOrigin)
3753	{
3754	RTGCPHYS GCPhys;
3755	uint64_t fFlags;
3756	int rc;
3757	PVM pVM = pVCpu->CTX_SUFF(pVM);
3758	VMCPU_ASSERT_EMT(pVCpu);
3759
3760	/*
3761	* Anything to do?
3762	*/
3763	if (!cb)
3764	return VINF_SUCCESS;
3765
3766	LogFlow(("PGMPhysWriteGCPtr: %RGv %zu\n", GCPtrDst, cb));
3767
3768	/*
3769	* Optimize writes within a single page.
3770	*/
3771	if (((RTGCUINTPTR)GCPtrDst & PAGE_OFFSET_MASK) + cb <= PAGE_SIZE)
3772	{
3773	/* Convert virtual to physical address + flags */
3774	rc = PGM_GST_PFN(GetPage,pVCpu)(pVCpu, (RTGCUINTPTR)GCPtrDst, &fFlags, &GCPhys);
3775	AssertMsgRCReturn(rc, ("GetPage failed with %Rrc for %RGv\n", rc, GCPtrDst), rc);
3776	GCPhys \|= (RTGCUINTPTR)GCPtrDst & PAGE_OFFSET_MASK;
3777
3778	/* Mention when we ignore X86_PTE_RW... */
3779	if (!(fFlags & X86_PTE_RW))
3780	Log(("PGMPhysWriteGCPtr: Writing to RO page %RGv %#x\n", GCPtrDst, cb));
3781
3782	/* Mark the guest page as accessed and dirty if necessary. */
3783	if ((fFlags & (X86_PTE_A \| X86_PTE_D)) != (X86_PTE_A \| X86_PTE_D))
3784	{
3785	rc = PGMGstModifyPage(pVCpu, GCPtrDst, 1, X86_PTE_A \| X86_PTE_D, ~(uint64_t)(X86_PTE_A \| X86_PTE_D));
3786	AssertRC(rc);
3787	}
3788
3789	return PGMPhysWrite(pVM, GCPhys, pvSrc, cb, enmOrigin);
3790	}
3791
3792	/*
3793	* Page by page.
3794	*/
3795	for (;;)
3796	{
3797	/* Convert virtual to physical address + flags */
3798	rc = PGM_GST_PFN(GetPage,pVCpu)(pVCpu, (RTGCUINTPTR)GCPtrDst, &fFlags, &GCPhys);
3799	AssertMsgRCReturn(rc, ("GetPage failed with %Rrc for %RGv\n", rc, GCPtrDst), rc);
3800	GCPhys \|= (RTGCUINTPTR)GCPtrDst & PAGE_OFFSET_MASK;
3801
3802	/* Mention when we ignore X86_PTE_RW... */
3803	if (!(fFlags & X86_PTE_RW))
3804	Log(("PGMPhysWriteGCPtr: Writing to RO page %RGv %#x\n", GCPtrDst, cb));
3805
3806	/* Mark the guest page as accessed and dirty if necessary. */
3807	if ((fFlags & (X86_PTE_A \| X86_PTE_D)) != (X86_PTE_A \| X86_PTE_D))
3808	{
3809	rc = PGMGstModifyPage(pVCpu, GCPtrDst, 1, X86_PTE_A \| X86_PTE_D, ~(uint64_t)(X86_PTE_A \| X86_PTE_D));
3810	AssertRC(rc);
3811	}
3812
3813	/* copy */
3814	size_t cbWrite = PAGE_SIZE - ((RTGCUINTPTR)GCPtrDst & PAGE_OFFSET_MASK);
3815	if (cbWrite < cb)
3816	{
3817	VBOXSTRICTRC rcStrict = PGMPhysWrite(pVM, GCPhys, pvSrc, cbWrite, enmOrigin);
3818	if (RT_LIKELY(rcStrict == VINF_SUCCESS))
3819	{ /* likely */ }
3820	else
3821	return rcStrict;
3822	}
3823	else /* Last page (cbWrite is PAGE_SIZE, we only need cb!) */
3824	return PGMPhysWrite(pVM, GCPhys, pvSrc, cb, enmOrigin);
3825
3826	/* next */
3827	Assert(cb > cbWrite);
3828	cb -= cbWrite;
3829	pvSrc = (uint8_t *)pvSrc + cbWrite;
3830	GCPtrDst += cbWrite;
3831	}
3832	}
3833
3834
3835	/**
3836	* Performs a read of guest virtual memory for instruction emulation.
3837	*
3838	* This will check permissions, raise exceptions and update the access bits.
3839	*
3840	* The current implementation will bypass all access handlers. It may later be
3841	* changed to at least respect MMIO.
3842	*
3843	*
3844	* @returns VBox status code suitable to scheduling.
3845	* @retval VINF_SUCCESS if the read was performed successfully.
3846	* @retval VINF_EM_RAW_GUEST_TRAP if an exception was raised but not dispatched yet.
3847	* @retval VINF_TRPM_XCPT_DISPATCHED if an exception was raised and dispatched.
3848	*
3849	* @param pVCpu The cross context virtual CPU structure of the calling EMT.
3850	* @param pCtxCore The context core.
3851	* @param pvDst Where to put the bytes we've read.
3852	* @param GCPtrSrc The source address.
3853	* @param cb The number of bytes to read. Not more than a page.
3854	*
3855	* @remark This function will dynamically map physical pages in GC. This may unmap
3856	* mappings done by the caller. Be careful!
3857	*/
3858	VMMDECL(int) PGMPhysInterpretedRead(PVMCPU pVCpu, PCPUMCTXCORE pCtxCore, void *pvDst, RTGCUINTPTR GCPtrSrc, size_t cb)
3859	{
3860	PVM pVM = pVCpu->CTX_SUFF(pVM);
3861	Assert(cb <= PAGE_SIZE);
3862	VMCPU_ASSERT_EMT(pVCpu);
3863
3864	/** @todo r=bird: This isn't perfect!
3865	* -# It's not checking for reserved bits being 1.
3866	* -# It's not correctly dealing with the access bit.
3867	* -# It's not respecting MMIO memory or any other access handlers.
3868	*/
3869	/*
3870	* 1. Translate virtual to physical. This may fault.
3871	* 2. Map the physical address.
3872	* 3. Do the read operation.
3873	* 4. Set access bits if required.
3874	*/
3875	int rc;
3876	unsigned cb1 = PAGE_SIZE - (GCPtrSrc & PAGE_OFFSET_MASK);
3877	if (cb <= cb1)
3878	{
3879	/*
3880	* Not crossing pages.
3881	*/
3882	RTGCPHYS GCPhys;
3883	uint64_t fFlags;
3884	rc = PGM_GST_PFN(GetPage,pVCpu)(pVCpu, GCPtrSrc, &fFlags, &GCPhys);
3885	if (RT_SUCCESS(rc))
3886	{
3887	/** @todo we should check reserved bits ... */
3888	PGMPAGEMAPLOCK PgMpLck;
3889	void const *pvSrc;
3890	rc = PGMPhysGCPhys2CCPtrReadOnly(pVM, GCPhys, &pvSrc, &PgMpLck);
3891	switch (rc)
3892	{
3893	case VINF_SUCCESS:
3894	Log(("PGMPhysInterpretedRead: pvDst=%p pvSrc=%p cb=%d\n", pvDst, (uint8_t *)pvSrc + (GCPtrSrc & PAGE_OFFSET_MASK), cb));
3895	memcpy(pvDst, (uint8_t *)pvSrc + (GCPtrSrc & PAGE_OFFSET_MASK), cb);
3896	PGMPhysReleasePageMappingLock(pVM, &PgMpLck);
3897	break;
3898	case VERR_PGM_PHYS_PAGE_RESERVED:
3899	case VERR_PGM_INVALID_GC_PHYSICAL_ADDRESS:
3900	memset(pvDst, 0xff, cb);
3901	break;
3902	default:
3903	Assert(RT_FAILURE_NP(rc));
3904	return rc;
3905	}
3906
3907	/** @todo access bit emulation isn't 100% correct. */
3908	if (!(fFlags & X86_PTE_A))
3909	{
3910	rc = PGMGstModifyPage(pVCpu, GCPtrSrc, 1, X86_PTE_A, ~(uint64_t)X86_PTE_A);
3911	AssertRC(rc);
3912	}
3913	return VINF_SUCCESS;
3914	}
3915	}
3916	else
3917	{
3918	/*
3919	* Crosses pages.
3920	*/
3921	size_t cb2 = cb - cb1;
3922	uint64_t fFlags1;
3923	RTGCPHYS GCPhys1;
3924	uint64_t fFlags2;
3925	RTGCPHYS GCPhys2;
3926	rc = PGM_GST_PFN(GetPage,pVCpu)(pVCpu, GCPtrSrc, &fFlags1, &GCPhys1);
3927	if (RT_SUCCESS(rc))
3928	{
3929	rc = PGM_GST_PFN(GetPage,pVCpu)(pVCpu, GCPtrSrc + cb1, &fFlags2, &GCPhys2);
3930	if (RT_SUCCESS(rc))
3931	{
3932	/** @todo we should check reserved bits ... */
3933	AssertMsgFailed(("cb=%d cb1=%d cb2=%d GCPtrSrc=%RGv\n", cb, cb1, cb2, GCPtrSrc));
3934	PGMPAGEMAPLOCK PgMpLck;
3935	void const *pvSrc1;
3936	rc = PGMPhysGCPhys2CCPtrReadOnly(pVM, GCPhys1, &pvSrc1, &PgMpLck);
3937	switch (rc)
3938	{
3939	case VINF_SUCCESS:
3940	memcpy(pvDst, (uint8_t *)pvSrc1 + (GCPtrSrc & PAGE_OFFSET_MASK), cb1);
3941	PGMPhysReleasePageMappingLock(pVM, &PgMpLck);
3942	break;
3943	case VERR_PGM_INVALID_GC_PHYSICAL_ADDRESS:
3944	memset(pvDst, 0xff, cb1);
3945	break;
3946	default:
3947	Assert(RT_FAILURE_NP(rc));
3948	return rc;
3949	}
3950
3951	void const *pvSrc2;
3952	rc = PGMPhysGCPhys2CCPtrReadOnly(pVM, GCPhys2, &pvSrc2, &PgMpLck);
3953	switch (rc)
3954	{
3955	case VINF_SUCCESS:
3956	memcpy((uint8_t *)pvDst + cb1, pvSrc2, cb2);
3957	PGMPhysReleasePageMappingLock(pVM, &PgMpLck);
3958	break;
3959	case VERR_PGM_INVALID_GC_PHYSICAL_ADDRESS:
3960	memset((uint8_t *)pvDst + cb1, 0xff, cb2);
3961	break;
3962	default:
3963	Assert(RT_FAILURE_NP(rc));
3964	return rc;
3965	}
3966
3967	if (!(fFlags1 & X86_PTE_A))
3968	{
3969	rc = PGMGstModifyPage(pVCpu, GCPtrSrc, 1, X86_PTE_A, ~(uint64_t)X86_PTE_A);
3970	AssertRC(rc);
3971	}
3972	if (!(fFlags2 & X86_PTE_A))
3973	{
3974	rc = PGMGstModifyPage(pVCpu, GCPtrSrc + cb1, 1, X86_PTE_A, ~(uint64_t)X86_PTE_A);
3975	AssertRC(rc);
3976	}
3977	return VINF_SUCCESS;
3978	}
3979	}
3980	}
3981
3982	/*
3983	* Raise a #PF.
3984	*/
3985	uint32_t uErr;
3986
3987	/* Get the current privilege level. */
3988	uint32_t cpl = CPUMGetGuestCPL(pVCpu);
3989	switch (rc)
3990	{
3991	case VINF_SUCCESS:
3992	uErr = (cpl >= 2) ? X86_TRAP_PF_RSVD \| X86_TRAP_PF_US : X86_TRAP_PF_RSVD;
3993	break;
3994
3995	case VERR_PAGE_NOT_PRESENT:
3996	case VERR_PAGE_TABLE_NOT_PRESENT:
3997	uErr = (cpl >= 2) ? X86_TRAP_PF_US : 0;
3998	break;
3999
4000	default:
4001	AssertMsgFailed(("rc=%Rrc GCPtrSrc=%RGv cb=%#x\n", rc, GCPtrSrc, cb));
4002	return rc;
4003	}
4004	Log(("PGMPhysInterpretedRead: GCPtrSrc=%RGv cb=%#x -> #PF(%#x)\n", GCPtrSrc, cb, uErr));
4005	return TRPMRaiseXcptErrCR2(pVCpu, pCtxCore, X86_XCPT_PF, uErr, GCPtrSrc);
4006	}
4007
4008
4009	/**
4010	* Performs a read of guest virtual memory for instruction emulation.
4011	*
4012	* This will check permissions, raise exceptions and update the access bits.
4013	*
4014	* The current implementation will bypass all access handlers. It may later be
4015	* changed to at least respect MMIO.
4016	*
4017	*
4018	* @returns VBox status code suitable to scheduling.
4019	* @retval VINF_SUCCESS if the read was performed successfully.
4020	* @retval VINF_EM_RAW_GUEST_TRAP if an exception was raised but not dispatched yet.
4021	* @retval VINF_TRPM_XCPT_DISPATCHED if an exception was raised and dispatched.
4022	*
4023	* @param pVCpu The cross context virtual CPU structure of the calling EMT.
4024	* @param pCtxCore The context core.
4025	* @param pvDst Where to put the bytes we've read.
4026	* @param GCPtrSrc The source address.
4027	* @param cb The number of bytes to read. Not more than a page.
4028	* @param fRaiseTrap If set the trap will be raised on as per spec, if clear
4029	* an appropriate error status will be returned (no
4030	* informational at all).
4031	*
4032	*
4033	* @remarks Takes the PGM lock.
4034	* @remarks A page fault on the 2nd page of the access will be raised without
4035	* writing the bits on the first page since we're ASSUMING that the
4036	* caller is emulating an instruction access.
4037	* @remarks This function will dynamically map physical pages in GC. This may
4038	* unmap mappings done by the caller. Be careful!
4039	*/
4040	VMMDECL(int) PGMPhysInterpretedReadNoHandlers(PVMCPU pVCpu, PCPUMCTXCORE pCtxCore, void *pvDst, RTGCUINTPTR GCPtrSrc, size_t cb,
4041	bool fRaiseTrap)
4042	{
4043	PVM pVM = pVCpu->CTX_SUFF(pVM);
4044	Assert(cb <= PAGE_SIZE);
4045	VMCPU_ASSERT_EMT(pVCpu);
4046
4047	/*
4048	* 1. Translate virtual to physical. This may fault.
4049	* 2. Map the physical address.
4050	* 3. Do the read operation.
4051	* 4. Set access bits if required.
4052	*/
4053	int rc;
4054	unsigned cb1 = PAGE_SIZE - (GCPtrSrc & PAGE_OFFSET_MASK);
4055	if (cb <= cb1)
4056	{
4057	/*
4058	* Not crossing pages.
4059	*/
4060	RTGCPHYS GCPhys;
4061	uint64_t fFlags;
4062	rc = PGM_GST_PFN(GetPage,pVCpu)(pVCpu, GCPtrSrc, &fFlags, &GCPhys);
4063	if (RT_SUCCESS(rc))
4064	{
4065	if (1) /** @todo we should check reserved bits ... */
4066	{
4067	const void *pvSrc;
4068	PGMPAGEMAPLOCK Lock;
4069	rc = PGMPhysGCPhys2CCPtrReadOnly(pVM, GCPhys, &pvSrc, &Lock);
4070	switch (rc)
4071	{
4072	case VINF_SUCCESS:
4073	Log(("PGMPhysInterpretedReadNoHandlers: pvDst=%p pvSrc=%p (%RGv) cb=%d\n",
4074	pvDst, (const uint8_t *)pvSrc + (GCPtrSrc & PAGE_OFFSET_MASK), GCPtrSrc, cb));
4075	memcpy(pvDst, (const uint8_t *)pvSrc + (GCPtrSrc & PAGE_OFFSET_MASK), cb);
4076	PGMPhysReleasePageMappingLock(pVM, &Lock);
4077	break;
4078	case VERR_PGM_PHYS_PAGE_RESERVED:
4079	case VERR_PGM_INVALID_GC_PHYSICAL_ADDRESS:
4080	memset(pvDst, 0xff, cb);
4081	break;
4082	default:
4083	AssertMsgFailed(("%Rrc\n", rc));
4084	AssertReturn(RT_FAILURE(rc), VERR_IPE_UNEXPECTED_INFO_STATUS);
4085	return rc;
4086	}
4087
4088	if (!(fFlags & X86_PTE_A))
4089	{
4090	/** @todo access bit emulation isn't 100% correct. */
4091	rc = PGMGstModifyPage(pVCpu, GCPtrSrc, 1, X86_PTE_A, ~(uint64_t)X86_PTE_A);
4092	AssertRC(rc);
4093	}
4094	return VINF_SUCCESS;
4095	}
4096	}
4097	}
4098	else
4099	{
4100	/*
4101	* Crosses pages.
4102	*/
4103	size_t cb2 = cb - cb1;
4104	uint64_t fFlags1;
4105	RTGCPHYS GCPhys1;
4106	uint64_t fFlags2;
4107	RTGCPHYS GCPhys2;
4108	rc = PGM_GST_PFN(GetPage,pVCpu)(pVCpu, GCPtrSrc, &fFlags1, &GCPhys1);
4109	if (RT_SUCCESS(rc))
4110	{
4111	rc = PGM_GST_PFN(GetPage,pVCpu)(pVCpu, GCPtrSrc + cb1, &fFlags2, &GCPhys2);
4112	if (RT_SUCCESS(rc))
4113	{
4114	if (1) /** @todo we should check reserved bits ... */
4115	{
4116	const void *pvSrc;
4117	PGMPAGEMAPLOCK Lock;
4118	rc = PGMPhysGCPhys2CCPtrReadOnly(pVM, GCPhys1, &pvSrc, &Lock);
4119	switch (rc)
4120	{
4121	case VINF_SUCCESS:
4122	Log(("PGMPhysInterpretedReadNoHandlers: pvDst=%p pvSrc=%p (%RGv) cb=%d [2]\n",
4123	pvDst, (const uint8_t *)pvSrc + (GCPtrSrc & PAGE_OFFSET_MASK), GCPtrSrc, cb1));
4124	memcpy(pvDst, (const uint8_t *)pvSrc + (GCPtrSrc & PAGE_OFFSET_MASK), cb1);
4125	PGMPhysReleasePageMappingLock(pVM, &Lock);
4126	break;
4127	case VERR_PGM_PHYS_PAGE_RESERVED:
4128	case VERR_PGM_INVALID_GC_PHYSICAL_ADDRESS:
4129	memset(pvDst, 0xff, cb1);
4130	break;
4131	default:
4132	AssertMsgFailed(("%Rrc\n", rc));
4133	AssertReturn(RT_FAILURE(rc), VERR_IPE_UNEXPECTED_INFO_STATUS);
4134	return rc;
4135	}
4136
4137	rc = PGMPhysGCPhys2CCPtrReadOnly(pVM, GCPhys2, &pvSrc, &Lock);
4138	switch (rc)
4139	{
4140	case VINF_SUCCESS:
4141	memcpy((uint8_t *)pvDst + cb1, pvSrc, cb2);
4142	PGMPhysReleasePageMappingLock(pVM, &Lock);
4143	break;
4144	case VERR_PGM_PHYS_PAGE_RESERVED:
4145	case VERR_PGM_INVALID_GC_PHYSICAL_ADDRESS:
4146	memset((uint8_t *)pvDst + cb1, 0xff, cb2);
4147	break;
4148	default:
4149	AssertMsgFailed(("%Rrc\n", rc));
4150	AssertReturn(RT_FAILURE(rc), VERR_IPE_UNEXPECTED_INFO_STATUS);
4151	return rc;
4152	}
4153
4154	if (!(fFlags1 & X86_PTE_A))
4155	{
4156	rc = PGMGstModifyPage(pVCpu, GCPtrSrc, 1, X86_PTE_A, ~(uint64_t)X86_PTE_A);
4157	AssertRC(rc);
4158	}
4159	if (!(fFlags2 & X86_PTE_A))
4160	{
4161	rc = PGMGstModifyPage(pVCpu, GCPtrSrc + cb1, 1, X86_PTE_A, ~(uint64_t)X86_PTE_A);
4162	AssertRC(rc);
4163	}
4164	return VINF_SUCCESS;
4165	}
4166	/* sort out which page */
4167	}
4168	else
4169	GCPtrSrc += cb1; /* fault on 2nd page */
4170	}
4171	}
4172
4173	/*
4174	* Raise a #PF if we're allowed to do that.
4175	*/
4176	/* Calc the error bits. */
4177	uint32_t cpl = CPUMGetGuestCPL(pVCpu);
4178	uint32_t uErr;
4179	switch (rc)
4180	{
4181	case VINF_SUCCESS:
4182	uErr = (cpl >= 2) ? X86_TRAP_PF_RSVD \| X86_TRAP_PF_US : X86_TRAP_PF_RSVD;
4183	rc = VERR_ACCESS_DENIED;
4184	break;
4185
4186	case VERR_PAGE_NOT_PRESENT:
4187	case VERR_PAGE_TABLE_NOT_PRESENT:
4188	uErr = (cpl >= 2) ? X86_TRAP_PF_US : 0;
4189	break;
4190
4191	default:
4192	AssertMsgFailed(("rc=%Rrc GCPtrSrc=%RGv cb=%#x\n", rc, GCPtrSrc, cb));
4193	AssertReturn(RT_FAILURE(rc), VERR_IPE_UNEXPECTED_INFO_STATUS);
4194	return rc;
4195	}
4196	if (fRaiseTrap)
4197	{
4198	Log(("PGMPhysInterpretedReadNoHandlers: GCPtrSrc=%RGv cb=%#x -> Raised #PF(%#x)\n", GCPtrSrc, cb, uErr));
4199	return TRPMRaiseXcptErrCR2(pVCpu, pCtxCore, X86_XCPT_PF, uErr, GCPtrSrc);
4200	}
4201	Log(("PGMPhysInterpretedReadNoHandlers: GCPtrSrc=%RGv cb=%#x -> #PF(%#x) [!raised]\n", GCPtrSrc, cb, uErr));
4202	return rc;
4203	}
4204
4205
4206	/**
4207	* Performs a write to guest virtual memory for instruction emulation.
4208	*
4209	* This will check permissions, raise exceptions and update the dirty and access
4210	* bits.
4211	*
4212	* @returns VBox status code suitable to scheduling.
4213	* @retval VINF_SUCCESS if the read was performed successfully.
4214	* @retval VINF_EM_RAW_GUEST_TRAP if an exception was raised but not dispatched yet.
4215	* @retval VINF_TRPM_XCPT_DISPATCHED if an exception was raised and dispatched.
4216	*
4217	* @param pVCpu The cross context virtual CPU structure of the calling EMT.
4218	* @param pCtxCore The context core.
4219	* @param GCPtrDst The destination address.
4220	* @param pvSrc What to write.
4221	* @param cb The number of bytes to write. Not more than a page.
4222	* @param fRaiseTrap If set the trap will be raised on as per spec, if clear
4223	* an appropriate error status will be returned (no
4224	* informational at all).
4225	*
4226	* @remarks Takes the PGM lock.
4227	* @remarks A page fault on the 2nd page of the access will be raised without
4228	* writing the bits on the first page since we're ASSUMING that the
4229	* caller is emulating an instruction access.
4230	* @remarks This function will dynamically map physical pages in GC. This may
4231	* unmap mappings done by the caller. Be careful!
4232	*/
4233	VMMDECL(int) PGMPhysInterpretedWriteNoHandlers(PVMCPU pVCpu, PCPUMCTXCORE pCtxCore, RTGCPTR GCPtrDst, const void *pvSrc,
4234	size_t cb, bool fRaiseTrap)
4235	{
4236	Assert(cb <= PAGE_SIZE);
4237	PVM pVM = pVCpu->CTX_SUFF(pVM);
4238	VMCPU_ASSERT_EMT(pVCpu);
4239
4240	/*
4241	* 1. Translate virtual to physical. This may fault.
4242	* 2. Map the physical address.
4243	* 3. Do the write operation.
4244	* 4. Set access bits if required.
4245	*/
4246	/** @todo Since this method is frequently used by EMInterpret or IOM
4247	* upon a write fault to an write access monitored page, we can
4248	* reuse the guest page table walking from the \#PF code. */
4249	int rc;
4250	unsigned cb1 = PAGE_SIZE - (GCPtrDst & PAGE_OFFSET_MASK);
4251	if (cb <= cb1)
4252	{
4253	/*
4254	* Not crossing pages.
4255	*/
4256	RTGCPHYS GCPhys;
4257	uint64_t fFlags;
4258	rc = PGM_GST_PFN(GetPage,pVCpu)(pVCpu, GCPtrDst, &fFlags, &GCPhys);
4259	if (RT_SUCCESS(rc))
4260	{
4261	if ( (fFlags & X86_PTE_RW) /** @todo Also check reserved bits. */
4262	\|\| ( !(CPUMGetGuestCR0(pVCpu) & X86_CR0_WP)
4263	&& CPUMGetGuestCPL(pVCpu) <= 2) ) /** @todo it's 2, right? Check cpl check below as well. */
4264	{
4265	void *pvDst;
4266	PGMPAGEMAPLOCK Lock;
4267	rc = PGMPhysGCPhys2CCPtr(pVM, GCPhys, &pvDst, &Lock);
4268	switch (rc)
4269	{
4270	case VINF_SUCCESS:
4271	Log(("PGMPhysInterpretedWriteNoHandlers: pvDst=%p (%RGv) pvSrc=%p cb=%d\n",
4272	(uint8_t *)pvDst + (GCPtrDst & PAGE_OFFSET_MASK), GCPtrDst, pvSrc, cb));
4273	memcpy((uint8_t *)pvDst + (GCPtrDst & PAGE_OFFSET_MASK), pvSrc, cb);
4274	PGMPhysReleasePageMappingLock(pVM, &Lock);
4275	break;
4276	case VERR_PGM_PHYS_PAGE_RESERVED:
4277	case VERR_PGM_INVALID_GC_PHYSICAL_ADDRESS:
4278	/* bit bucket */
4279	break;
4280	default:
4281	AssertMsgFailed(("%Rrc\n", rc));
4282	AssertReturn(RT_FAILURE(rc), VERR_IPE_UNEXPECTED_INFO_STATUS);
4283	return rc;
4284	}
4285
4286	if (!(fFlags & (X86_PTE_A \| X86_PTE_D)))
4287	{
4288	/** @todo dirty & access bit emulation isn't 100% correct. */
4289	rc = PGMGstModifyPage(pVCpu, GCPtrDst, 1, X86_PTE_A \| X86_PTE_D, ~(uint64_t)(X86_PTE_A \| X86_PTE_D));
4290	AssertRC(rc);
4291	}
4292	return VINF_SUCCESS;
4293	}
4294	rc = VERR_ACCESS_DENIED;
4295	}
4296	}
4297	else
4298	{
4299	/*
4300	* Crosses pages.
4301	*/
4302	size_t cb2 = cb - cb1;
4303	uint64_t fFlags1;
4304	RTGCPHYS GCPhys1;
4305	uint64_t fFlags2;
4306	RTGCPHYS GCPhys2;
4307	rc = PGM_GST_PFN(GetPage,pVCpu)(pVCpu, GCPtrDst, &fFlags1, &GCPhys1);
4308	if (RT_SUCCESS(rc))
4309	{
4310	rc = PGM_GST_PFN(GetPage,pVCpu)(pVCpu, GCPtrDst + cb1, &fFlags2, &GCPhys2);
4311	if (RT_SUCCESS(rc))
4312	{
4313	if ( ( (fFlags1 & X86_PTE_RW) /** @todo Also check reserved bits. */
4314	&& (fFlags2 & X86_PTE_RW))
4315	\|\| ( !(CPUMGetGuestCR0(pVCpu) & X86_CR0_WP)
4316	&& CPUMGetGuestCPL(pVCpu) <= 2) )
4317	{
4318	void *pvDst;
4319	PGMPAGEMAPLOCK Lock;
4320	rc = PGMPhysGCPhys2CCPtr(pVM, GCPhys1, &pvDst, &Lock);
4321	switch (rc)
4322	{
4323	case VINF_SUCCESS:
4324	Log(("PGMPhysInterpretedWriteNoHandlers: pvDst=%p (%RGv) pvSrc=%p cb=%d\n",
4325	(uint8_t *)pvDst + (GCPtrDst & PAGE_OFFSET_MASK), GCPtrDst, pvSrc, cb1));
4326	memcpy((uint8_t *)pvDst + (GCPtrDst & PAGE_OFFSET_MASK), pvSrc, cb1);
4327	PGMPhysReleasePageMappingLock(pVM, &Lock);
4328	break;
4329	case VERR_PGM_PHYS_PAGE_RESERVED:
4330	case VERR_PGM_INVALID_GC_PHYSICAL_ADDRESS:
4331	/* bit bucket */
4332	break;
4333	default:
4334	AssertMsgFailed(("%Rrc\n", rc));
4335	AssertReturn(RT_FAILURE(rc), VERR_IPE_UNEXPECTED_INFO_STATUS);
4336	return rc;
4337	}
4338
4339	rc = PGMPhysGCPhys2CCPtr(pVM, GCPhys2, &pvDst, &Lock);
4340	switch (rc)
4341	{
4342	case VINF_SUCCESS:
4343	memcpy(pvDst, (const uint8_t *)pvSrc + cb1, cb2);
4344	PGMPhysReleasePageMappingLock(pVM, &Lock);
4345	break;
4346	case VERR_PGM_PHYS_PAGE_RESERVED:
4347	case VERR_PGM_INVALID_GC_PHYSICAL_ADDRESS:
4348	/* bit bucket */
4349	break;
4350	default:
4351	AssertMsgFailed(("%Rrc\n", rc));
4352	AssertReturn(RT_FAILURE(rc), VERR_IPE_UNEXPECTED_INFO_STATUS);
4353	return rc;
4354	}
4355
4356	if (!(fFlags1 & (X86_PTE_A \| X86_PTE_RW)))
4357	{
4358	rc = PGMGstModifyPage(pVCpu, GCPtrDst, 1, (X86_PTE_A \| X86_PTE_RW), ~(uint64_t)(X86_PTE_A \| X86_PTE_RW));
4359	AssertRC(rc);
4360	}
4361	if (!(fFlags2 & (X86_PTE_A \| X86_PTE_RW)))
4362	{
4363	rc = PGMGstModifyPage(pVCpu, GCPtrDst + cb1, 1, (X86_PTE_A \| X86_PTE_RW), ~(uint64_t)(X86_PTE_A \| X86_PTE_RW));
4364	AssertRC(rc);
4365	}
4366	return VINF_SUCCESS;
4367	}
4368	if ((fFlags1 & (X86_PTE_RW)) == X86_PTE_RW)
4369	GCPtrDst += cb1; /* fault on the 2nd page. */
4370	rc = VERR_ACCESS_DENIED;
4371	}
4372	else
4373	GCPtrDst += cb1; /* fault on the 2nd page. */
4374	}
4375	}
4376
4377	/*
4378	* Raise a #PF if we're allowed to do that.
4379	*/
4380	/* Calc the error bits. */
4381	uint32_t uErr;
4382	uint32_t cpl = CPUMGetGuestCPL(pVCpu);
4383	switch (rc)
4384	{
4385	case VINF_SUCCESS:
4386	uErr = (cpl >= 2) ? X86_TRAP_PF_RSVD \| X86_TRAP_PF_US : X86_TRAP_PF_RSVD;
4387	rc = VERR_ACCESS_DENIED;
4388	break;
4389
4390	case VERR_ACCESS_DENIED:
4391	uErr = (cpl >= 2) ? X86_TRAP_PF_RW \| X86_TRAP_PF_US : X86_TRAP_PF_RW;
4392	break;
4393
4394	case VERR_PAGE_NOT_PRESENT:
4395	case VERR_PAGE_TABLE_NOT_PRESENT:
4396	uErr = (cpl >= 2) ? X86_TRAP_PF_US : 0;
4397	break;
4398
4399	default:
4400	AssertMsgFailed(("rc=%Rrc GCPtrDst=%RGv cb=%#x\n", rc, GCPtrDst, cb));
4401	AssertReturn(RT_FAILURE(rc), VERR_IPE_UNEXPECTED_INFO_STATUS);
4402	return rc;
4403	}
4404	if (fRaiseTrap)
4405	{
4406	Log(("PGMPhysInterpretedWriteNoHandlers: GCPtrDst=%RGv cb=%#x -> Raised #PF(%#x)\n", GCPtrDst, cb, uErr));
4407	return TRPMRaiseXcptErrCR2(pVCpu, pCtxCore, X86_XCPT_PF, uErr, GCPtrDst);
4408	}
4409	Log(("PGMPhysInterpretedWriteNoHandlers: GCPtrDst=%RGv cb=%#x -> #PF(%#x) [!raised]\n", GCPtrDst, cb, uErr));
4410	return rc;
4411	}
4412
4413
4414	/**
4415	* Return the page type of the specified physical address.
4416	*
4417	* @returns The page type.
4418	* @param pVM The cross context VM structure.
4419	* @param GCPhys Guest physical address
4420	*/
4421	VMM_INT_DECL(PGMPAGETYPE) PGMPhysGetPageType(PVM pVM, RTGCPHYS GCPhys)
4422	{
4423	pgmLock(pVM);
4424	PPGMPAGE pPage = pgmPhysGetPage(pVM, GCPhys);
4425	PGMPAGETYPE enmPgType = pPage ? (PGMPAGETYPE)PGM_PAGE_GET_TYPE(pPage) : PGMPAGETYPE_INVALID;
4426	pgmUnlock(pVM);
4427
4428	return enmPgType;
4429	}
4430
4431
4432	/**
4433	* Converts a GC physical address to a HC ring-3 pointer, with some
4434	* additional checks.
4435	*
4436	* @returns VBox status code (no informational statuses).
4437	*
4438	* @param pVM The cross context VM structure.
4439	* @param pVCpu The cross context virtual CPU structure of the
4440	* calling EMT.
4441	* @param GCPhys The GC physical address to convert. This API mask
4442	* the A20 line when necessary.
4443	* @param puTlbPhysRev Where to read the physical TLB revision. Needs to
4444	* be done while holding the PGM lock.
4445	* @param ppb Where to store the pointer corresponding to GCPhys
4446	* on success.
4447	* @param pfTlb The TLB flags and revision. We only add stuff.
4448	*
4449	* @remarks This is more or a less a copy of PGMR3PhysTlbGCPhys2Ptr and
4450	* PGMPhysIemGCPhys2Ptr.
4451	*
4452	* @thread EMT(pVCpu).
4453	*/
4454	VMM_INT_DECL(int) PGMPhysIemGCPhys2PtrNoLock(PVM pVM, PVMCPU pVCpu, RTGCPHYS GCPhys, uint64_t const volatile *puTlbPhysRev,
4455	#if defined(IN_RC) \|\| defined(VBOX_WITH_2X_4GB_ADDR_SPACE_IN_R0)
4456	R3PTRTYPE(uint8_t ) ppb,
4457	#else
4458	R3R0PTRTYPE(uint8_t ) ppb,
4459	#endif
4460	uint64_t *pfTlb)
4461	{
4462	PGM_A20_APPLY_TO_VAR(pVCpu, GCPhys);
4463	Assert(!(GCPhys & X86_PAGE_OFFSET_MASK));
4464
4465	pgmLock(pVM);
4466
4467	PPGMRAMRANGE pRam;
4468	PPGMPAGE pPage;
4469	int rc = pgmPhysGetPageAndRangeEx(pVM, GCPhys, &pPage, &pRam);
4470	if (RT_SUCCESS(rc))
4471	{
4472	if (!PGM_PAGE_IS_BALLOONED(pPage))
4473	{
4474	if (!PGM_PAGE_IS_SPECIAL_ALIAS_MMIO(pPage))
4475	{
4476	if (!PGM_PAGE_HAS_ANY_HANDLERS(pPage))
4477	{
4478	/*
4479	* No access handler.
4480	*/
4481	switch (PGM_PAGE_GET_STATE(pPage))
4482	{
4483	case PGM_PAGE_STATE_ALLOCATED:
4484	pfTlb \|= puTlbPhysRev;
4485	break;
4486	case PGM_PAGE_STATE_BALLOONED:
4487	AssertFailed();
4488	RT_FALL_THRU();
4489	case PGM_PAGE_STATE_ZERO:
4490	case PGM_PAGE_STATE_SHARED:
4491	case PGM_PAGE_STATE_WRITE_MONITORED:
4492	pfTlb \|= puTlbPhysRev \| PGMIEMGCPHYS2PTR_F_NO_WRITE;
4493	break;
4494	}
4495	#if defined(IN_RC) \|\| defined(VBOX_WITH_2X_4GB_ADDR_SPACE_IN_R0)
4496	*pfTlb \|= PGMIEMGCPHYS2PTR_F_NO_MAPPINGR3;
4497	*ppb = NULL;
4498	#else
4499	PPGMPAGER3MAPTLBE pTlbe;
4500	rc = pgmPhysPageQueryTlbeWithPage(pVM, pPage, GCPhys, &pTlbe);
4501	AssertLogRelRCReturn(rc, rc);
4502	ppb = (uint8_t )pTlbe->pv;
4503	#endif
4504	}
4505	else if (PGM_PAGE_HAS_ACTIVE_ALL_HANDLERS(pPage))
4506	{
4507	/*
4508	* MMIO or similar all access handler: Catch all access.
4509	*/
4510	pfTlb \|= puTlbPhysRev
4511	\| PGMIEMGCPHYS2PTR_F_NO_WRITE \| PGMIEMGCPHYS2PTR_F_NO_READ \| PGMIEMGCPHYS2PTR_F_NO_MAPPINGR3;
4512	*ppb = NULL;
4513	}
4514	else
4515	{
4516	/*
4517	* Write access handler: Catch write accesses if active.
4518	*/
4519	if (PGM_PAGE_HAS_ACTIVE_HANDLERS(pPage))
4520	pfTlb \|= puTlbPhysRev \| PGMIEMGCPHYS2PTR_F_NO_WRITE;
4521	else
4522	switch (PGM_PAGE_GET_STATE(pPage))
4523	{
4524	case PGM_PAGE_STATE_ALLOCATED:
4525	pfTlb \|= puTlbPhysRev;
4526	break;
4527	case PGM_PAGE_STATE_BALLOONED:
4528	AssertFailed();
4529	RT_FALL_THRU();
4530	case PGM_PAGE_STATE_ZERO:
4531	case PGM_PAGE_STATE_SHARED:
4532	case PGM_PAGE_STATE_WRITE_MONITORED:
4533	pfTlb \|= puTlbPhysRev \| PGMIEMGCPHYS2PTR_F_NO_WRITE;
4534	break;
4535	}
4536	#if defined(IN_RC) \|\| defined(VBOX_WITH_2X_4GB_ADDR_SPACE_IN_R0)
4537	*pfTlb \|= PGMIEMGCPHYS2PTR_F_NO_MAPPINGR3;
4538	*ppb = NULL;
4539	#else
4540	PPGMPAGER3MAPTLBE pTlbe;
4541	rc = pgmPhysPageQueryTlbeWithPage(pVM, pPage, GCPhys, &pTlbe);
4542	AssertLogRelRCReturn(rc, rc);
4543	ppb = (uint8_t )pTlbe->pv;
4544	#endif
4545	}
4546	}
4547	else
4548	{
4549	/* Alias MMIO: For now, we catch all access. */
4550	pfTlb \|= puTlbPhysRev
4551	\| PGMIEMGCPHYS2PTR_F_NO_WRITE \| PGMIEMGCPHYS2PTR_F_NO_READ \| PGMIEMGCPHYS2PTR_F_NO_MAPPINGR3;
4552	*ppb = NULL;
4553	}
4554	}
4555	else
4556	{
4557	/* Ballooned: Shouldn't get here, but we read zero page via PGMPhysRead and writes goes to /dev/null. */
4558	pfTlb \|= puTlbPhysRev \| PGMIEMGCPHYS2PTR_F_NO_WRITE \| PGMIEMGCPHYS2PTR_F_NO_READ \| PGMIEMGCPHYS2PTR_F_NO_MAPPINGR3;
4559	*ppb = NULL;
4560	}
4561	Log6(("PGMPhysIemGCPhys2PtrNoLock: GCPhys=%RGp ppb=%p pfTlb=%#RX64 pPage=%R[pgmpage]\n", GCPhys, ppb, pfTlb, pPage));
4562	}
4563	else
4564	{
4565	pfTlb \|= puTlbPhysRev \| PGMIEMGCPHYS2PTR_F_NO_WRITE \| PGMIEMGCPHYS2PTR_F_NO_READ \| PGMIEMGCPHYS2PTR_F_NO_MAPPINGR3;
4566	*ppb = NULL;
4567	Log6(("PGMPhysIemGCPhys2PtrNoLock: GCPhys=%RGp ppb=%p pfTlb=%#RX64 (rc=%Rrc)\n", GCPhys, ppb, pfTlb, rc));
4568	}
4569
4570	pgmUnlock(pVM);
4571	return VINF_SUCCESS;
4572	}
4573
4574
4575	/**
4576	* Converts a GC physical address to a HC ring-3 pointer, with some
4577	* additional checks.
4578	*
4579	* @returns VBox status code (no informational statuses).
4580	* @retval VINF_SUCCESS on success.
4581	* @retval VERR_PGM_PHYS_TLB_CATCH_WRITE and *ppv set if the page has a write
4582	* access handler of some kind.
4583	* @retval VERR_PGM_PHYS_TLB_CATCH_ALL if the page has a handler catching all
4584	* accesses or is odd in any way.
4585	* @retval VERR_PGM_PHYS_TLB_UNASSIGNED if the page doesn't exist.
4586	*
4587	* @param pVM The cross context VM structure.
4588	* @param pVCpu The cross context virtual CPU structure of the
4589	* calling EMT.
4590	* @param GCPhys The GC physical address to convert. This API mask
4591	* the A20 line when necessary.
4592	* @param fWritable Whether write access is required.
4593	* @param fByPassHandlers Whether to bypass access handlers.
4594	* @param ppv Where to store the pointer corresponding to GCPhys
4595	* on success.
4596	* @param pLock
4597	*
4598	* @remarks This is more or a less a copy of PGMR3PhysTlbGCPhys2Ptr.
4599	* @thread EMT(pVCpu).
4600	*/
4601	VMM_INT_DECL(int) PGMPhysIemGCPhys2Ptr(PVM pVM, PVMCPU pVCpu, RTGCPHYS GCPhys, bool fWritable, bool fByPassHandlers,
4602	void **ppv, PPGMPAGEMAPLOCK pLock)
4603	{
4604	PGM_A20_APPLY_TO_VAR(pVCpu, GCPhys);
4605
4606	pgmLock(pVM);
4607
4608	PPGMRAMRANGE pRam;
4609	PPGMPAGE pPage;
4610	int rc = pgmPhysGetPageAndRangeEx(pVM, GCPhys, &pPage, &pRam);
4611	if (RT_SUCCESS(rc))
4612	{
4613	if (PGM_PAGE_IS_BALLOONED(pPage))
4614	rc = VERR_PGM_PHYS_TLB_CATCH_WRITE;
4615	else if (PGM_PAGE_IS_SPECIAL_ALIAS_MMIO(pPage))
4616	rc = VERR_PGM_PHYS_TLB_CATCH_ALL;
4617	else if ( !PGM_PAGE_HAS_ANY_HANDLERS(pPage)
4618	\|\| (fByPassHandlers && !PGM_PAGE_IS_MMIO(pPage)) )
4619	rc = VINF_SUCCESS;
4620	else
4621	{
4622	if (PGM_PAGE_HAS_ACTIVE_ALL_HANDLERS(pPage)) /* catches MMIO */
4623	{
4624	Assert(!fByPassHandlers \|\| PGM_PAGE_IS_MMIO(pPage));
4625	rc = VERR_PGM_PHYS_TLB_CATCH_ALL;
4626	}
4627	else if (PGM_PAGE_HAS_ACTIVE_HANDLERS(pPage) && fWritable)
4628	{
4629	Assert(!fByPassHandlers);
4630	rc = VERR_PGM_PHYS_TLB_CATCH_WRITE;
4631	}
4632	}
4633	if (RT_SUCCESS(rc))
4634	{
4635	int rc2;
4636
4637	/* Make sure what we return is writable. */
4638	if (fWritable)
4639	switch (PGM_PAGE_GET_STATE(pPage))
4640	{
4641	case PGM_PAGE_STATE_ALLOCATED:
4642	break;
4643	case PGM_PAGE_STATE_BALLOONED:
4644	AssertFailed();
4645	break;
4646	case PGM_PAGE_STATE_ZERO:
4647	case PGM_PAGE_STATE_SHARED:
4648	case PGM_PAGE_STATE_WRITE_MONITORED:
4649	rc2 = pgmPhysPageMakeWritable(pVM, pPage, GCPhys & ~(RTGCPHYS)PAGE_OFFSET_MASK);
4650	AssertLogRelRCReturn(rc2, rc2);
4651	break;
4652	}
4653
4654	#if defined(IN_RC) \|\| defined(VBOX_WITH_2X_4GB_ADDR_SPACE_IN_R0)
4655	void *pv;
4656	rc = pgmRZDynMapHCPageInlined(pVCpu,
4657	PGM_PAGE_GET_HCPHYS(pPage),
4658	&pv
4659	RTLOG_COMMA_SRC_POS);
4660	if (RT_FAILURE(rc))
4661	return rc;
4662	ppv = (void )((uintptr_t)pv \| (uintptr_t)(GCPhys & PAGE_OFFSET_MASK));
4663	pLock->pvPage = pv;
4664	pLock->pVCpu = pVCpu;
4665
4666	#else
4667	/* Get a ring-3 mapping of the address. */
4668	PPGMPAGER3MAPTLBE pTlbe;
4669	rc2 = pgmPhysPageQueryTlbeWithPage(pVM, pPage, GCPhys, &pTlbe);
4670	AssertLogRelRCReturn(rc2, rc2);
4671
4672	/* Lock it and calculate the address. */
4673	if (fWritable)
4674	pgmPhysPageMapLockForWriting(pVM, pPage, pTlbe, pLock);
4675	else
4676	pgmPhysPageMapLockForReading(pVM, pPage, pTlbe, pLock);
4677	ppv = (void )((uintptr_t)pTlbe->pv \| (uintptr_t)(GCPhys & PAGE_OFFSET_MASK));
4678	#endif
4679
4680	Log6(("PGMPhysIemGCPhys2Ptr: GCPhys=%RGp rc=%Rrc pPage=%R[pgmpage] ppv=%p\n", GCPhys, rc, pPage, ppv));
4681	}
4682	else
4683	Log6(("PGMPhysIemGCPhys2Ptr: GCPhys=%RGp rc=%Rrc pPage=%R[pgmpage]\n", GCPhys, rc, pPage));
4684
4685	/* else: handler catching all access, no pointer returned. */
4686	}
4687	else
4688	rc = VERR_PGM_PHYS_TLB_UNASSIGNED;
4689
4690	pgmUnlock(pVM);
4691	return rc;
4692	}
4693
4694
4695	/**
4696	* Checks if the give GCPhys page requires special handling for the given access
4697	* because it's MMIO or otherwise monitored.
4698	*
4699	* @returns VBox status code (no informational statuses).
4700	* @retval VINF_SUCCESS on success.
4701	* @retval VERR_PGM_PHYS_TLB_CATCH_WRITE and *ppv set if the page has a write
4702	* access handler of some kind.
4703	* @retval VERR_PGM_PHYS_TLB_CATCH_ALL if the page has a handler catching all
4704	* accesses or is odd in any way.
4705	* @retval VERR_PGM_PHYS_TLB_UNASSIGNED if the page doesn't exist.
4706	*
4707	* @param pVM The cross context VM structure.
4708	* @param GCPhys The GC physical address to convert. Since this is
4709	* only used for filling the REM TLB, the A20 mask must
4710	* be applied before calling this API.
4711	* @param fWritable Whether write access is required.
4712	* @param fByPassHandlers Whether to bypass access handlers.
4713	*
4714	* @remarks This is a watered down version PGMPhysIemGCPhys2Ptr and really just
4715	* a stop gap thing that should be removed once there is a better TLB
4716	* for virtual address accesses.
4717	*/
4718	VMM_INT_DECL(int) PGMPhysIemQueryAccess(PVM pVM, RTGCPHYS GCPhys, bool fWritable, bool fByPassHandlers)
4719	{
4720	pgmLock(pVM);
4721	PGM_A20_ASSERT_MASKED(VMMGetCpu(pVM), GCPhys);
4722
4723	PPGMRAMRANGE pRam;
4724	PPGMPAGE pPage;
4725	int rc = pgmPhysGetPageAndRangeEx(pVM, GCPhys, &pPage, &pRam);
4726	if (RT_SUCCESS(rc))
4727	{
4728	if (PGM_PAGE_IS_BALLOONED(pPage))
4729	rc = VERR_PGM_PHYS_TLB_CATCH_WRITE;
4730	else if (PGM_PAGE_IS_SPECIAL_ALIAS_MMIO(pPage))
4731	rc = VERR_PGM_PHYS_TLB_CATCH_ALL;
4732	else if ( !PGM_PAGE_HAS_ANY_HANDLERS(pPage)
4733	\|\| (fByPassHandlers && !PGM_PAGE_IS_MMIO(pPage)) )
4734	rc = VINF_SUCCESS;
4735	else
4736	{
4737	if (PGM_PAGE_HAS_ACTIVE_ALL_HANDLERS(pPage)) /* catches MMIO */
4738	{
4739	Assert(!fByPassHandlers \|\| PGM_PAGE_IS_MMIO(pPage));
4740	rc = VERR_PGM_PHYS_TLB_CATCH_ALL;
4741	}
4742	else if (PGM_PAGE_HAS_ACTIVE_HANDLERS(pPage) && fWritable)
4743	{
4744	Assert(!fByPassHandlers);
4745	rc = VERR_PGM_PHYS_TLB_CATCH_WRITE;
4746	}
4747	}
4748	}
4749
4750	pgmUnlock(pVM);
4751	return rc;
4752	}
4753
4754	#ifndef IN_RC
4755
4756	/**
4757	* Interface used by NEM to check what to do on a memory access exit.
4758	*
4759	* @returns VBox status code.
4760	* @param pVM The cross context VM structure.
4761	* @param pVCpu The cross context per virtual CPU structure.
4762	* Optional.
4763	* @param GCPhys The guest physical address.
4764	* @param fMakeWritable Whether to try make the page writable or not. If it
4765	* cannot be made writable, NEM_PAGE_PROT_WRITE won't
4766	* be returned and the return code will be unaffected
4767	* @param pInfo Where to return the page information. This is
4768	* initialized even on failure.
4769	* @param pfnChecker Page in-sync checker callback. Optional.
4770	* @param pvUser User argument to pass to pfnChecker.
4771	*/
4772	VMM_INT_DECL(int) PGMPhysNemPageInfoChecker(PVM pVM, PVMCPU pVCpu, RTGCPHYS GCPhys, bool fMakeWritable, PPGMPHYSNEMPAGEINFO pInfo,
4773	PFNPGMPHYSNEMCHECKPAGE pfnChecker, void *pvUser)
4774	{
4775	pgmLock(pVM);
4776
4777	PPGMPAGE pPage;
4778	int rc = pgmPhysGetPageEx(pVM, GCPhys, &pPage);
4779	if (RT_SUCCESS(rc))
4780	{
4781	/* Try make it writable if requested. */
4782	if (fMakeWritable)
4783	switch (PGM_PAGE_GET_STATE(pPage))
4784	{
4785	case PGM_PAGE_STATE_SHARED:
4786	case PGM_PAGE_STATE_WRITE_MONITORED:
4787	case PGM_PAGE_STATE_ZERO:
4788	rc = pgmPhysPageMakeWritable(pVM, pPage, GCPhys);
4789	if (rc == VERR_PGM_PHYS_PAGE_RESERVED)
4790	rc = VINF_SUCCESS;
4791	break;
4792	}
4793
4794	/* Fill in the info. */
4795	pInfo->HCPhys = PGM_PAGE_GET_HCPHYS(pPage);
4796	pInfo->u2NemState = PGM_PAGE_GET_NEM_STATE(pPage);
4797	pInfo->fHasHandlers = PGM_PAGE_HAS_ACTIVE_HANDLERS(pPage) ? 1 : 0;
4798	PGMPAGETYPE const enmType = (PGMPAGETYPE)PGM_PAGE_GET_TYPE(pPage);
4799	pInfo->enmType = enmType;
4800	pInfo->fNemProt = pgmPhysPageCalcNemProtection(pPage, enmType);
4801	switch (PGM_PAGE_GET_STATE(pPage))
4802	{
4803	case PGM_PAGE_STATE_ALLOCATED:
4804	pInfo->fZeroPage = 0;
4805	break;
4806
4807	case PGM_PAGE_STATE_ZERO:
4808	pInfo->fZeroPage = 1;
4809	break;
4810
4811	case PGM_PAGE_STATE_WRITE_MONITORED:
4812	pInfo->fZeroPage = 0;
4813	break;
4814
4815	case PGM_PAGE_STATE_SHARED:
4816	pInfo->fZeroPage = 0;
4817	break;
4818
4819	case PGM_PAGE_STATE_BALLOONED:
4820	pInfo->fZeroPage = 1;
4821	break;
4822
4823	default:
4824	pInfo->fZeroPage = 1;
4825	AssertFailedStmt(rc = VERR_PGM_PHYS_PAGE_GET_IPE);
4826	}
4827
4828	/* Call the checker and update NEM state. */
4829	if (pfnChecker)
4830	{
4831	rc = pfnChecker(pVM, pVCpu, GCPhys, pInfo, pvUser);
4832	PGM_PAGE_SET_NEM_STATE(pPage, pInfo->u2NemState);
4833	}
4834
4835	/* Done. */
4836	pgmUnlock(pVM);
4837	}
4838	else
4839	{
4840	pgmUnlock(pVM);
4841
4842	pInfo->HCPhys = NIL_RTHCPHYS;
4843	pInfo->fNemProt = NEM_PAGE_PROT_NONE;
4844	pInfo->u2NemState = 0;
4845	pInfo->fHasHandlers = 0;
4846	pInfo->fZeroPage = 0;
4847	pInfo->enmType = PGMPAGETYPE_INVALID;
4848	}
4849
4850	return rc;
4851	}
4852
4853
4854	/**
4855	* NEM helper that performs @a pfnCallback on pages with NEM state @a uMinState
4856	* or higher.
4857	*
4858	* @returns VBox status code from callback.
4859	* @param pVM The cross context VM structure.
4860	* @param pVCpu The cross context per CPU structure. This is
4861	* optional as its only for passing to callback.
4862	* @param uMinState The minimum NEM state value to call on.
4863	* @param pfnCallback The callback function.
4864	* @param pvUser User argument for the callback.
4865	*/
4866	VMM_INT_DECL(int) PGMPhysNemEnumPagesByState(PVM pVM, PVMCPU pVCpu, uint8_t uMinState,
4867	PFNPGMPHYSNEMENUMCALLBACK pfnCallback, void *pvUser)
4868	{
4869	/*
4870	* Just brute force this problem.
4871	*/
4872	pgmLock(pVM);
4873	int rc = VINF_SUCCESS;
4874	for (PPGMRAMRANGE pRam = pVM->pgm.s.CTX_SUFF(pRamRangesX); pRam; pRam = pRam->CTX_SUFF(pNext))
4875	{
4876	uint32_t const cPages = pRam->cb >> X86_PAGE_SHIFT;
4877	for (uint32_t iPage = 0; iPage < cPages; iPage++)
4878	{
4879	uint8_t u2State = PGM_PAGE_GET_NEM_STATE(&pRam->aPages[iPage]);
4880	if (u2State < uMinState)
4881	{ /* likely */ }
4882	else
4883	{
4884	rc = pfnCallback(pVM, pVCpu, pRam->GCPhys + ((RTGCPHYS)iPage << X86_PAGE_SHIFT), &u2State, pvUser);
4885	if (RT_SUCCESS(rc))
4886	PGM_PAGE_SET_NEM_STATE(&pRam->aPages[iPage], u2State);
4887	else
4888	break;
4889	}
4890	}
4891	}
4892	pgmUnlock(pVM);
4893
4894	return rc;
4895
4896	}
4897
4898	#endif /* !IN_RC */
4899

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/VMM/VMMAll/PGMAllPhys.cpp@ 71416

Download in other formats: