PGMAllHandler.cpp@ 27778

Last change on this file since 27778 was 27402, checked in by vboxsync, 15 years ago
Flush for warnings too (VINF_PGM_SYNC_CR3).
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 67.9 KB

Line
1	/* $Id: PGMAllHandler.cpp 27402 2010-03-16 13:19:51Z vboxsync $ */
2	/** @file
3	* PGM - Page Manager / Monitor, Access Handlers.
4	*/
5
6	/*
7	* Copyright (C) 2006-2007 Sun Microsystems, Inc.
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.virtualbox.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*
17	* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
18	* Clara, CA 95054 USA or visit http://www.sun.com if you need
19	* additional information or have any questions.
20	*/
21
22
23	/*******************************************************************************
24	* Header Files *
25	*******************************************************************************/
26	#define LOG_GROUP LOG_GROUP_PGM
27	#include <VBox/dbgf.h>
28	#include <VBox/pgm.h>
29	#include <VBox/iom.h>
30	#include <VBox/mm.h>
31	#include <VBox/em.h>
32	#include <VBox/stam.h>
33	#include <VBox/rem.h>
34	#include <VBox/dbgf.h>
35	#include <VBox/rem.h>
36	#include "../PGMInternal.h"
37	#include <VBox/vm.h>
38	#include "../PGMInline.h"
39
40	#include <VBox/log.h>
41	#include <iprt/assert.h>
42	#include <iprt/asm.h>
43	#include <iprt/string.h>
44	#include <VBox/param.h>
45	#include <VBox/err.h>
46	#include <VBox/selm.h>
47
48
49	/*******************************************************************************
50	* Internal Functions *
51	*******************************************************************************/
52	static int pgmHandlerPhysicalSetRamFlagsAndFlushShadowPTs(PVM pVM, PPGMPHYSHANDLER pCur, PPGMRAMRANGE pRam);
53	static void pgmHandlerPhysicalDeregisterNotifyREM(PVM pVM, PPGMPHYSHANDLER pCur);
54	static void pgmHandlerPhysicalResetRamFlags(PVM pVM, PPGMPHYSHANDLER pCur);
55
56
57
58	/**
59	* Register a access handler for a physical range.
60	*
61	* @returns VBox status code.
62	* @retval VINF_SUCCESS when successfully installed.
63	* @retval VINF_PGM_GCPHYS_ALIASED when the shadow PTs could be updated because
64	* the guest page aliased or/and mapped by multiple PTs. A CR3 sync has been
65	* flagged together with a pool clearing.
66	* @retval VERR_PGM_HANDLER_PHYSICAL_CONFLICT if the range conflicts with an existing
67	* one. A debug assertion is raised.
68	*
69	* @param pVM VM Handle.
70	* @param enmType Handler type. Any of the PGMPHYSHANDLERTYPE_PHYSICAL* enums.
71	* @param GCPhys Start physical address.
72	* @param GCPhysLast Last physical address. (inclusive)
73	* @param pfnHandlerR3 The R3 handler.
74	* @param pvUserR3 User argument to the R3 handler.
75	* @param pfnHandlerR0 The R0 handler.
76	* @param pvUserR0 User argument to the R0 handler.
77	* @param pfnHandlerRC The RC handler.
78	* @param pvUserRC User argument to the RC handler. This can be a value
79	* less that 0x10000 or a (non-null) pointer that is
80	* automatically relocatated.
81	* @param pszDesc Pointer to description string. This must not be freed.
82	*/
83	VMMDECL(int) PGMHandlerPhysicalRegisterEx(PVM pVM, PGMPHYSHANDLERTYPE enmType, RTGCPHYS GCPhys, RTGCPHYS GCPhysLast,
84	R3PTRTYPE(PFNPGMR3PHYSHANDLER) pfnHandlerR3, RTR3PTR pvUserR3,
85	R0PTRTYPE(PFNPGMR0PHYSHANDLER) pfnHandlerR0, RTR0PTR pvUserR0,
86	RCPTRTYPE(PFNPGMRCPHYSHANDLER) pfnHandlerRC, RTRCPTR pvUserRC,
87	R3PTRTYPE(const char *) pszDesc)
88	{
89	Log(("PGMHandlerPhysicalRegisterEx: enmType=%d GCPhys=%RGp GCPhysLast=%RGp pfnHandlerR3=%RHv pvUserR3=%RHv pfnHandlerR0=%RHv pvUserR0=%RHv pfnHandlerGC=%RRv pvUserGC=%RRv pszDesc=%s\n",
90	enmType, GCPhys, GCPhysLast, pfnHandlerR3, pvUserR3, pfnHandlerR0, pvUserR0, pfnHandlerRC, pvUserRC, R3STRING(pszDesc)));
91
92	/*
93	* Validate input.
94	*/
95	AssertMsgReturn(GCPhys < GCPhysLast, ("GCPhys >= GCPhysLast (%#x >= %#x)\n", GCPhys, GCPhysLast), VERR_INVALID_PARAMETER);
96	switch (enmType)
97	{
98	case PGMPHYSHANDLERTYPE_PHYSICAL_WRITE:
99	break;
100	case PGMPHYSHANDLERTYPE_MMIO:
101	case PGMPHYSHANDLERTYPE_PHYSICAL_ALL:
102	/* Simplification in PGMPhysRead among other places. */
103	AssertMsgReturn(!(GCPhys & PAGE_OFFSET_MASK), ("%RGp\n", GCPhys), VERR_INVALID_PARAMETER);
104	AssertMsgReturn((GCPhysLast & PAGE_OFFSET_MASK) == PAGE_OFFSET_MASK, ("%RGp\n", GCPhysLast), VERR_INVALID_PARAMETER);
105	break;
106	default:
107	AssertMsgFailed(("Invalid input enmType=%d!\n", enmType));
108	return VERR_INVALID_PARAMETER;
109	}
110	AssertMsgReturn( (RTRCUINTPTR)pvUserRC < 0x10000
111	\|\| MMHyperR3ToRC(pVM, MMHyperRCToR3(pVM, pvUserRC)) == pvUserRC,
112	("Not RC pointer! pvUserRC=%RRv\n", pvUserRC),
113	VERR_INVALID_PARAMETER);
114	AssertMsgReturn( (RTR0UINTPTR)pvUserR0 < 0x10000
115	\|\| MMHyperR3ToR0(pVM, MMHyperR0ToR3(pVM, pvUserR0)) == pvUserR0,
116	("Not R0 pointer! pvUserR0=%RHv\n", pvUserR0),
117	VERR_INVALID_PARAMETER);
118	AssertPtrReturn(pfnHandlerR3, VERR_INVALID_POINTER);
119	AssertReturn(pfnHandlerR0, VERR_INVALID_PARAMETER);
120	AssertReturn(pfnHandlerRC, VERR_INVALID_PARAMETER);
121
122	/*
123	* We require the range to be within registered ram.
124	* There is no apparent need to support ranges which cover more than one ram range.
125	*/
126	PPGMRAMRANGE pRam = pVM->pgm.s.CTX_SUFF(pRamRanges);
127	while (pRam && GCPhys > pRam->GCPhysLast)
128	pRam = pRam->CTX_SUFF(pNext);
129	if ( !pRam
130	\|\| GCPhysLast < pRam->GCPhys
131	\|\| GCPhys > pRam->GCPhysLast)
132	{
133	#ifdef IN_RING3
134	DBGFR3Info(pVM, "phys", NULL, NULL);
135	#endif
136	AssertMsgFailed(("No RAM range for %RGp-%RGp\n", GCPhys, GCPhysLast));
137	return VERR_PGM_HANDLER_PHYSICAL_NO_RAM_RANGE;
138	}
139
140	/*
141	* Allocate and initialize the new entry.
142	*/
143	PPGMPHYSHANDLER pNew;
144	int rc = MMHyperAlloc(pVM, sizeof(pNew), 0, MM_TAG_PGM_HANDLERS, (void *)&pNew);
145	if (RT_FAILURE(rc))
146	return rc;
147
148	pNew->Core.Key = GCPhys;
149	pNew->Core.KeyLast = GCPhysLast;
150	pNew->enmType = enmType;
151	pNew->cPages = (GCPhysLast - (GCPhys & X86_PTE_PAE_PG_MASK) + PAGE_SIZE) >> PAGE_SHIFT;
152	pNew->pfnHandlerR3 = pfnHandlerR3;
153	pNew->pvUserR3 = pvUserR3;
154	pNew->pfnHandlerR0 = pfnHandlerR0;
155	pNew->pvUserR0 = pvUserR0;
156	pNew->pfnHandlerRC = pfnHandlerRC;
157	pNew->pvUserRC = pvUserRC;
158	pNew->pszDesc = pszDesc;
159
160	pgmLock(pVM);
161
162	/*
163	* Try insert into list.
164	*/
165	if (RTAvlroGCPhysInsert(&pVM->pgm.s.CTX_SUFF(pTrees)->PhysHandlers, &pNew->Core))
166	{
167	rc = pgmHandlerPhysicalSetRamFlagsAndFlushShadowPTs(pVM, pNew, pRam);
168	if (rc == VINF_PGM_SYNC_CR3)
169	rc = VINF_PGM_GCPHYS_ALIASED;
170	pgmUnlock(pVM);
171	#ifndef IN_RING3
172	REMNotifyHandlerPhysicalRegister(pVM, enmType, GCPhys, GCPhysLast - GCPhys + 1, !!pfnHandlerR3);
173	#else
174	REMR3NotifyHandlerPhysicalRegister(pVM, enmType, GCPhys, GCPhysLast - GCPhys + 1, !!pfnHandlerR3);
175	#endif
176	if (rc != VINF_SUCCESS)
177	Log(("PGMHandlerPhysicalRegisterEx: returns %Rrc (%RGp-%RGp)\n", rc, GCPhys, GCPhysLast));
178	return rc;
179	}
180
181	pgmUnlock(pVM);
182
183	#if defined(IN_RING3) && defined(VBOX_STRICT)
184	DBGFR3Info(pVM, "handlers", "phys nostats", NULL);
185	#endif
186	AssertMsgFailed(("Conflict! GCPhys=%RGp GCPhysLast=%RGp pszDesc=%s\n", GCPhys, GCPhysLast, pszDesc));
187	MMHyperFree(pVM, pNew);
188	return VERR_PGM_HANDLER_PHYSICAL_CONFLICT;
189	}
190
191
192	/**
193	* Sets ram range flags and attempts updating shadow PTs.
194	*
195	* @returns VBox status code.
196	* @retval VINF_SUCCESS when shadow PTs was successfully updated.
197	* @retval VINF_PGM_SYNC_CR3 when the shadow PTs could be updated because
198	* the guest page aliased or/and mapped by multiple PTs. FFs set.
199	* @param pVM The VM handle.
200	* @param pCur The physical handler.
201	* @param pRam The RAM range.
202	*/
203	static int pgmHandlerPhysicalSetRamFlagsAndFlushShadowPTs(PVM pVM, PPGMPHYSHANDLER pCur, PPGMRAMRANGE pRam)
204	{
205	/*
206	* Iterate the guest ram pages updating the flags and flushing PT entries
207	* mapping the page.
208	*/
209	bool fFlushTLBs = false;
210	int rc = VINF_SUCCESS;
211	const unsigned uState = pgmHandlerPhysicalCalcState(pCur);
212	uint32_t cPages = pCur->cPages;
213	uint32_t i = (pCur->Core.Key - pRam->GCPhys) >> PAGE_SHIFT;
214	for (;;)
215	{
216	PPGMPAGE pPage = &pRam->aPages[i];
217	AssertMsg(pCur->enmType != PGMPHYSHANDLERTYPE_MMIO \|\| PGM_PAGE_IS_MMIO(pPage),
218	("%RGp %R[pgmpage]\n", pRam->GCPhys + (i << PAGE_SHIFT), pPage));
219
220	/* Only do upgrades. */
221	if (PGM_PAGE_GET_HNDL_PHYS_STATE(pPage) < uState)
222	{
223	PGM_PAGE_SET_HNDL_PHYS_STATE(pPage, uState);
224
225	int rc2 = pgmPoolTrackUpdateGCPhys(pVM, pRam->GCPhys + (i << PAGE_SHIFT), pPage, false /* allow updates of PTEs (instead of flushing) */, &fFlushTLBs);
226	if (rc2 != VINF_SUCCESS && rc == VINF_SUCCESS)
227	rc = rc2;
228	}
229
230	/* next */
231	if (--cPages == 0)
232	break;
233	i++;
234	}
235
236	if (fFlushTLBs && RT_SUCCESS(rc))
237	{
238	PGM_INVL_ALL_VCPU_TLBS(pVM);
239	Log(("pgmHandlerPhysicalSetRamFlagsAndFlushShadowPTs: flushing guest TLBs; rc=%d\n", rc));
240	}
241	else
242	{
243	Log(("pgmHandlerPhysicalSetRamFlagsAndFlushShadowPTs: doesn't flush guest TLBs. rc=%Rrc; sync flags=%x VMCPU_FF_PGM_SYNC_CR3=%d\n", rc, VMMGetCpu(pVM)->pgm.s.fSyncFlags, VMCPU_FF_ISSET(VMMGetCpu(pVM), VMCPU_FF_PGM_SYNC_CR3)));
244	}
245	return rc;
246	}
247
248
249	/**
250	* Register a physical page access handler.
251	*
252	* @returns VBox status code.
253	* @param pVM VM Handle.
254	* @param GCPhys Start physical address.
255	*/
256	VMMDECL(int) PGMHandlerPhysicalDeregister(PVM pVM, RTGCPHYS GCPhys)
257	{
258	/*
259	* Find the handler.
260	*/
261	pgmLock(pVM);
262	PPGMPHYSHANDLER pCur = (PPGMPHYSHANDLER)RTAvlroGCPhysRemove(&pVM->pgm.s.CTX_SUFF(pTrees)->PhysHandlers, GCPhys);
263	if (pCur)
264	{
265	LogFlow(("PGMHandlerPhysicalDeregister: Removing Range %RGp-%RGp %s\n",
266	pCur->Core.Key, pCur->Core.KeyLast, R3STRING(pCur->pszDesc)));
267
268	/*
269	* Clear the page bits and notify the REM about this change.
270	*/
271	pgmHandlerPhysicalResetRamFlags(pVM, pCur);
272	pgmHandlerPhysicalDeregisterNotifyREM(pVM, pCur);
273	MMHyperFree(pVM, pCur);
274	pgmUnlock(pVM);
275	return VINF_SUCCESS;
276	}
277	pgmUnlock(pVM);
278
279	AssertMsgFailed(("Didn't find range starting at %RGp\n", GCPhys));
280	return VERR_PGM_HANDLER_NOT_FOUND;
281	}
282
283
284	/**
285	* Shared code with modify.
286	*/
287	static void pgmHandlerPhysicalDeregisterNotifyREM(PVM pVM, PPGMPHYSHANDLER pCur)
288	{
289	RTGCPHYS GCPhysStart = pCur->Core.Key;
290	RTGCPHYS GCPhysLast = pCur->Core.KeyLast;
291
292	/*
293	* Page align the range.
294	*
295	* Since we've reset (recalculated) the physical handler state of all pages
296	* we can make use of the page states to figure out whether a page should be
297	* included in the REM notification or not.
298	*/
299	if ( (pCur->Core.Key & PAGE_OFFSET_MASK)
300	\|\| ((pCur->Core.KeyLast + 1) & PAGE_OFFSET_MASK))
301	{
302	Assert(pCur->enmType != PGMPHYSHANDLERTYPE_MMIO);
303
304	if (GCPhysStart & PAGE_OFFSET_MASK)
305	{
306	PPGMPAGE pPage = pgmPhysGetPage(&pVM->pgm.s, GCPhysStart);
307	if ( pPage
308	&& PGM_PAGE_GET_HNDL_PHYS_STATE(pPage) != PGM_PAGE_HNDL_PHYS_STATE_NONE)
309	{
310	RTGCPHYS GCPhys = (GCPhysStart + (PAGE_SIZE - 1)) & X86_PTE_PAE_PG_MASK;
311	if ( GCPhys > GCPhysLast
312	\|\| GCPhys < GCPhysStart)
313	return;
314	GCPhysStart = GCPhys;
315	}
316	else
317	GCPhysStart &= X86_PTE_PAE_PG_MASK;
318	Assert(!pPage \|\| PGM_PAGE_GET_TYPE(pPage) != PGMPAGETYPE_MMIO); /* these are page aligned atm! */
319	}
320
321	if (GCPhysLast & PAGE_OFFSET_MASK)
322	{
323	PPGMPAGE pPage = pgmPhysGetPage(&pVM->pgm.s, GCPhysLast);
324	if ( pPage
325	&& PGM_PAGE_GET_HNDL_PHYS_STATE(pPage) != PGM_PAGE_HNDL_PHYS_STATE_NONE)
326	{
327	RTGCPHYS GCPhys = (GCPhysLast & X86_PTE_PAE_PG_MASK) - 1;
328	if ( GCPhys < GCPhysStart
329	\|\| GCPhys > GCPhysLast)
330	return;
331	GCPhysLast = GCPhys;
332	}
333	else
334	GCPhysLast \|= PAGE_OFFSET_MASK;
335	Assert(!pPage \|\| PGM_PAGE_GET_TYPE(pPage) != PGMPAGETYPE_MMIO); /* these are page aligned atm! */
336	}
337	}
338
339	/*
340	* Tell REM.
341	*/
342	const bool fRestoreAsRAM = pCur->pfnHandlerR3
343	&& pCur->enmType != PGMPHYSHANDLERTYPE_MMIO; /** @todo this isn't entirely correct. */
344	#ifndef IN_RING3
345	REMNotifyHandlerPhysicalDeregister(pVM, pCur->enmType, GCPhysStart, GCPhysLast - GCPhysStart + 1, !!pCur->pfnHandlerR3, fRestoreAsRAM);
346	#else
347	REMR3NotifyHandlerPhysicalDeregister(pVM, pCur->enmType, GCPhysStart, GCPhysLast - GCPhysStart + 1, !!pCur->pfnHandlerR3, fRestoreAsRAM);
348	#endif
349	}
350
351
352	/**
353	* pgmHandlerPhysicalResetRamFlags helper that checks for
354	* other handlers on edge pages.
355	*/
356	DECLINLINE(void) pgmHandlerPhysicalRecalcPageState(PPGM pPGM, RTGCPHYS GCPhys, bool fAbove, PPGMRAMRANGE *ppRamHint)
357	{
358	/*
359	* Look for other handlers.
360	*/
361	unsigned uState = PGM_PAGE_HNDL_PHYS_STATE_NONE;
362	for (;;)
363	{
364	PPGMPHYSHANDLER pCur = (PPGMPHYSHANDLER)RTAvlroGCPhysGetBestFit(&pPGM->CTX_SUFF(pTrees)->PhysHandlers, GCPhys, fAbove);
365	if ( !pCur
366	\|\| ((fAbove ? pCur->Core.Key : pCur->Core.KeyLast) >> PAGE_SHIFT) != (GCPhys >> PAGE_SHIFT))
367	break;
368	unsigned uThisState = pgmHandlerPhysicalCalcState(pCur);
369	uState = RT_MAX(uState, uThisState);
370
371	/* next? */
372	RTGCPHYS GCPhysNext = fAbove
373	? pCur->Core.KeyLast + 1
374	: pCur->Core.Key - 1;
375	if ((GCPhysNext >> PAGE_SHIFT) != (GCPhys >> PAGE_SHIFT))
376	break;
377	GCPhys = GCPhysNext;
378	}
379
380	/*
381	* Update if we found something that is a higher priority
382	* state than the current.
383	*/
384	if (uState != PGM_PAGE_HNDL_PHYS_STATE_NONE)
385	{
386	PPGMPAGE pPage;
387	int rc = pgmPhysGetPageWithHintEx(pPGM, GCPhys, &pPage, ppRamHint);
388	if ( RT_SUCCESS(rc)
389	&& PGM_PAGE_GET_HNDL_PHYS_STATE(pPage) < uState)
390	PGM_PAGE_SET_HNDL_PHYS_STATE(pPage, uState);
391	else
392	AssertRC(rc);
393	}
394	}
395
396
397	/**
398	* Resets an aliased page.
399	*
400	* @param pVM The VM.
401	* @param pPage The page.
402	* @param GCPhysPage The page address in case it comes in handy.
403	*/
404	void pgmHandlerPhysicalResetAliasedPage(PVM pVM, PPGMPAGE pPage, RTGCPHYS GCPhysPage)
405	{
406	Assert(PGM_PAGE_GET_TYPE(pPage) == PGMPAGETYPE_MMIO2_ALIAS_MMIO);
407	Assert(PGM_PAGE_GET_HNDL_PHYS_STATE(pPage) == PGM_PAGE_HNDL_PHYS_STATE_DISABLED);
408
409	/*
410	* Flush any shadow page table references first.
411	*/
412	bool fFlushTLBs = false;
413	int rc = pgmPoolTrackFlushGCPhys(pVM, GCPhysPage, pPage, &fFlushTLBs);
414	AssertLogRelRCReturnVoid(rc);
415	# ifdef IN_RC
416	if (fFlushTLBs && rc != VINF_PGM_SYNC_CR3)
417	PGM_INVL_VCPU_TLBS(VMMGetCpu0(pVM));
418	# else
419	HWACCMFlushTLBOnAllVCpus(pVM);
420	# endif
421
422	/*
423	* Make it an MMIO/Zero page.
424	*/
425	PGM_PAGE_SET_HCPHYS(pPage, pVM->pgm.s.HCPhysZeroPg);
426	PGM_PAGE_SET_TYPE(pPage, PGMPAGETYPE_MMIO);
427	PGM_PAGE_SET_STATE(pPage, PGM_PAGE_STATE_ZERO);
428	PGM_PAGE_SET_PAGEID(pPage, NIL_GMM_PAGEID);
429	PGM_PAGE_SET_HNDL_PHYS_STATE(pPage, PGM_PAGE_HNDL_PHYS_STATE_ALL);
430
431	/* Flush its TLB entry. */
432	PGMPhysInvalidatePageMapTLBEntry(pVM, GCPhysPage);
433
434	NOREF(GCPhysPage);
435	}
436
437
438	/**
439	* Resets ram range flags.
440	*
441	* @returns VBox status code.
442	* @retval VINF_SUCCESS when shadow PTs was successfully updated.
443	* @param pVM The VM handle.
444	* @param pCur The physical handler.
445	*
446	* @remark We don't start messing with the shadow page tables, as we've already got code
447	* in Trap0e which deals with out of sync handler flags (originally conceived for
448	* global pages).
449	*/
450	static void pgmHandlerPhysicalResetRamFlags(PVM pVM, PPGMPHYSHANDLER pCur)
451	{
452	/*
453	* Iterate the guest ram pages updating the state.
454	*/
455	RTUINT cPages = pCur->cPages;
456	RTGCPHYS GCPhys = pCur->Core.Key;
457	PPGMRAMRANGE pRamHint = NULL;
458	PPGM pPGM = &pVM->pgm.s;
459	for (;;)
460	{
461	PPGMPAGE pPage;
462	int rc = pgmPhysGetPageWithHintEx(pPGM, GCPhys, &pPage, &pRamHint);
463	if (RT_SUCCESS(rc))
464	{
465	/* Reset MMIO2 for MMIO pages to MMIO, since this aliasing is our business.
466	(We don't flip MMIO to RAM though, that's PGMPhys.cpp's job.) */
467	if (PGM_PAGE_GET_TYPE(pPage) == PGMPAGETYPE_MMIO2_ALIAS_MMIO)
468	pgmHandlerPhysicalResetAliasedPage(pVM, pPage, GCPhys);
469	AssertMsg(pCur->enmType != PGMPHYSHANDLERTYPE_MMIO \|\| PGM_PAGE_IS_MMIO(pPage), ("%RGp %R[pgmpage]\n", GCPhys, pPage));
470	PGM_PAGE_SET_HNDL_PHYS_STATE(pPage, PGM_PAGE_HNDL_PHYS_STATE_NONE);
471	}
472	else
473	AssertRC(rc);
474
475	/* next */
476	if (--cPages == 0)
477	break;
478	GCPhys += PAGE_SIZE;
479	}
480
481	/*
482	* Check for partial start and end pages.
483	*/
484	if (pCur->Core.Key & PAGE_OFFSET_MASK)
485	pgmHandlerPhysicalRecalcPageState(pPGM, pCur->Core.Key - 1, false /* fAbove */, &pRamHint);
486	if ((pCur->Core.KeyLast & PAGE_OFFSET_MASK) != PAGE_SIZE - 1)
487	pgmHandlerPhysicalRecalcPageState(pPGM, pCur->Core.KeyLast + 1, true /* fAbove */, &pRamHint);
488	}
489
490
491	/**
492	* Modify a physical page access handler.
493	*
494	* Modification can only be done to the range it self, not the type or anything else.
495	*
496	* @returns VBox status code.
497	* For all return codes other than VERR_PGM_HANDLER_NOT_FOUND and VINF_SUCCESS the range is deregistered
498	* and a new registration must be performed!
499	* @param pVM VM handle.
500	* @param GCPhysCurrent Current location.
501	* @param GCPhys New location.
502	* @param GCPhysLast New last location.
503	*/
504	VMMDECL(int) PGMHandlerPhysicalModify(PVM pVM, RTGCPHYS GCPhysCurrent, RTGCPHYS GCPhys, RTGCPHYS GCPhysLast)
505	{
506	/*
507	* Remove it.
508	*/
509	int rc;
510	pgmLock(pVM);
511	PPGMPHYSHANDLER pCur = (PPGMPHYSHANDLER)RTAvlroGCPhysRemove(&pVM->pgm.s.CTX_SUFF(pTrees)->PhysHandlers, GCPhysCurrent);
512	if (pCur)
513	{
514	/*
515	* Clear the ram flags. (We're gonna move or free it!)
516	*/
517	pgmHandlerPhysicalResetRamFlags(pVM, pCur);
518	const bool fRestoreAsRAM = pCur->pfnHandlerR3
519	&& pCur->enmType != PGMPHYSHANDLERTYPE_MMIO; /** @todo this isn't entirely correct. */
520
521	/*
522	* Validate the new range, modify and reinsert.
523	*/
524	if (GCPhysLast >= GCPhys)
525	{
526	/*
527	* We require the range to be within registered ram.
528	* There is no apparent need to support ranges which cover more than one ram range.
529	*/
530	PPGMRAMRANGE pRam = pVM->pgm.s.CTX_SUFF(pRamRanges);
531	while (pRam && GCPhys > pRam->GCPhysLast)
532	pRam = pRam->CTX_SUFF(pNext);
533	if ( pRam
534	&& GCPhys <= pRam->GCPhysLast
535	&& GCPhysLast >= pRam->GCPhys)
536	{
537	pCur->Core.Key = GCPhys;
538	pCur->Core.KeyLast = GCPhysLast;
539	pCur->cPages = (GCPhysLast - (GCPhys & X86_PTE_PAE_PG_MASK) + 1) >> PAGE_SHIFT;
540
541	if (RTAvlroGCPhysInsert(&pVM->pgm.s.CTX_SUFF(pTrees)->PhysHandlers, &pCur->Core))
542	{
543	PGMPHYSHANDLERTYPE enmType = pCur->enmType;
544	RTGCPHYS cb = GCPhysLast - GCPhys + 1;
545	bool fHasHCHandler = !!pCur->pfnHandlerR3;
546
547	/*
548	* Set ram flags, flush shadow PT entries and finally tell REM about this.
549	*/
550	rc = pgmHandlerPhysicalSetRamFlagsAndFlushShadowPTs(pVM, pCur, pRam);
551	pgmUnlock(pVM);
552
553	#ifndef IN_RING3
554	REMNotifyHandlerPhysicalModify(pVM, enmType, GCPhysCurrent, GCPhys, cb,
555	fHasHCHandler, fRestoreAsRAM);
556	#else
557	REMR3NotifyHandlerPhysicalModify(pVM, enmType, GCPhysCurrent, GCPhys, cb,
558	fHasHCHandler, fRestoreAsRAM);
559	#endif
560	PGM_INVL_ALL_VCPU_TLBS(pVM);
561	Log(("PGMHandlerPhysicalModify: GCPhysCurrent=%RGp -> GCPhys=%RGp GCPhysLast=%RGp\n",
562	GCPhysCurrent, GCPhys, GCPhysLast));
563	return VINF_SUCCESS;
564	}
565
566	AssertMsgFailed(("Conflict! GCPhys=%RGp GCPhysLast=%RGp\n", GCPhys, GCPhysLast));
567	rc = VERR_PGM_HANDLER_PHYSICAL_CONFLICT;
568	}
569	else
570	{
571	AssertMsgFailed(("No RAM range for %RGp-%RGp\n", GCPhys, GCPhysLast));
572	rc = VERR_PGM_HANDLER_PHYSICAL_NO_RAM_RANGE;
573	}
574	}
575	else
576	{
577	AssertMsgFailed(("Invalid range %RGp-%RGp\n", GCPhys, GCPhysLast));
578	rc = VERR_INVALID_PARAMETER;
579	}
580
581	/*
582	* Invalid new location, free it.
583	* We've only gotta notify REM and free the memory.
584	*/
585	pgmHandlerPhysicalDeregisterNotifyREM(pVM, pCur);
586	MMHyperFree(pVM, pCur);
587	}
588	else
589	{
590	AssertMsgFailed(("Didn't find range starting at %RGp\n", GCPhysCurrent));
591	rc = VERR_PGM_HANDLER_NOT_FOUND;
592	}
593
594	pgmUnlock(pVM);
595	return rc;
596	}
597
598
599	/**
600	* Changes the callbacks associated with a physical access handler.
601	*
602	* @returns VBox status code.
603	* @param pVM VM Handle.
604	* @param GCPhys Start physical address.
605	* @param pfnHandlerR3 The R3 handler.
606	* @param pvUserR3 User argument to the R3 handler.
607	* @param pfnHandlerR0 The R0 handler.
608	* @param pvUserR0 User argument to the R0 handler.
609	* @param pfnHandlerRC The RC handler.
610	* @param pvUserRC User argument to the RC handler. Values larger or
611	* equal to 0x10000 will be relocated automatically.
612	* @param pszDesc Pointer to description string. This must not be freed.
613	*/
614	VMMDECL(int) PGMHandlerPhysicalChangeCallbacks(PVM pVM, RTGCPHYS GCPhys,
615	R3PTRTYPE(PFNPGMR3PHYSHANDLER) pfnHandlerR3, RTR3PTR pvUserR3,
616	R0PTRTYPE(PFNPGMR0PHYSHANDLER) pfnHandlerR0, RTR0PTR pvUserR0,
617	RCPTRTYPE(PFNPGMRCPHYSHANDLER) pfnHandlerRC, RTRCPTR pvUserRC,
618	R3PTRTYPE(const char *) pszDesc)
619	{
620	/*
621	* Get the handler.
622	*/
623	int rc = VINF_SUCCESS;
624	pgmLock(pVM);
625	PPGMPHYSHANDLER pCur = (PPGMPHYSHANDLER)RTAvlroGCPhysGet(&pVM->pgm.s.CTX_SUFF(pTrees)->PhysHandlers, GCPhys);
626	if (pCur)
627	{
628	/*
629	* Change callbacks.
630	*/
631	pCur->pfnHandlerR3 = pfnHandlerR3;
632	pCur->pvUserR3 = pvUserR3;
633	pCur->pfnHandlerR0 = pfnHandlerR0;
634	pCur->pvUserR0 = pvUserR0;
635	pCur->pfnHandlerRC = pfnHandlerRC;
636	pCur->pvUserRC = pvUserRC;
637	pCur->pszDesc = pszDesc;
638	}
639	else
640	{
641	AssertMsgFailed(("Didn't find range starting at %RGp\n", GCPhys));
642	rc = VERR_PGM_HANDLER_NOT_FOUND;
643	}
644
645	pgmUnlock(pVM);
646	return rc;
647	}
648
649
650	/**
651	* Splits a physical access handler in two.
652	*
653	* @returns VBox status code.
654	* @param pVM VM Handle.
655	* @param GCPhys Start physical address of the handler.
656	* @param GCPhysSplit The split address.
657	*/
658	VMMDECL(int) PGMHandlerPhysicalSplit(PVM pVM, RTGCPHYS GCPhys, RTGCPHYS GCPhysSplit)
659	{
660	AssertReturn(GCPhys < GCPhysSplit, VERR_INVALID_PARAMETER);
661
662	/*
663	* Do the allocation without owning the lock.
664	*/
665	PPGMPHYSHANDLER pNew;
666	int rc = MMHyperAlloc(pVM, sizeof(pNew), 0, MM_TAG_PGM_HANDLERS, (void *)&pNew);
667	if (RT_FAILURE(rc))
668	return rc;
669
670	/*
671	* Get the handler.
672	*/
673	pgmLock(pVM);
674	PPGMPHYSHANDLER pCur = (PPGMPHYSHANDLER)RTAvlroGCPhysGet(&pVM->pgm.s.CTX_SUFF(pTrees)->PhysHandlers, GCPhys);
675	if (RT_LIKELY(pCur))
676	{
677	if (RT_LIKELY(GCPhysSplit <= pCur->Core.KeyLast))
678	{
679	/*
680	* Create new handler node for the 2nd half.
681	*/
682	pNew = pCur;
683	pNew->Core.Key = GCPhysSplit;
684	pNew->cPages = (pNew->Core.KeyLast - (pNew->Core.Key & X86_PTE_PAE_PG_MASK) + PAGE_SIZE) >> PAGE_SHIFT;
685
686	pCur->Core.KeyLast = GCPhysSplit - 1;
687	pCur->cPages = (pCur->Core.KeyLast - (pCur->Core.Key & X86_PTE_PAE_PG_MASK) + PAGE_SIZE) >> PAGE_SHIFT;
688
689	if (RT_LIKELY(RTAvlroGCPhysInsert(&pVM->pgm.s.CTX_SUFF(pTrees)->PhysHandlers, &pNew->Core)))
690	{
691	LogFlow(("PGMHandlerPhysicalSplit: %RGp-%RGp and %RGp-%RGp\n",
692	pCur->Core.Key, pCur->Core.KeyLast, pNew->Core.Key, pNew->Core.KeyLast));
693	pgmUnlock(pVM);
694	return VINF_SUCCESS;
695	}
696	AssertMsgFailed(("whu?\n"));
697	rc = VERR_INTERNAL_ERROR;
698	}
699	else
700	{
701	AssertMsgFailed(("outside range: %RGp-%RGp split %RGp\n", pCur->Core.Key, pCur->Core.KeyLast, GCPhysSplit));
702	rc = VERR_INVALID_PARAMETER;
703	}
704	}
705	else
706	{
707	AssertMsgFailed(("Didn't find range starting at %RGp\n", GCPhys));
708	rc = VERR_PGM_HANDLER_NOT_FOUND;
709	}
710	pgmUnlock(pVM);
711	MMHyperFree(pVM, pNew);
712	return rc;
713	}
714
715
716	/**
717	* Joins up two adjacent physical access handlers which has the same callbacks.
718	*
719	* @returns VBox status code.
720	* @param pVM VM Handle.
721	* @param GCPhys1 Start physical address of the first handler.
722	* @param GCPhys2 Start physical address of the second handler.
723	*/
724	VMMDECL(int) PGMHandlerPhysicalJoin(PVM pVM, RTGCPHYS GCPhys1, RTGCPHYS GCPhys2)
725	{
726	/*
727	* Get the handlers.
728	*/
729	int rc;
730	pgmLock(pVM);
731	PPGMPHYSHANDLER pCur1 = (PPGMPHYSHANDLER)RTAvlroGCPhysGet(&pVM->pgm.s.CTX_SUFF(pTrees)->PhysHandlers, GCPhys1);
732	if (RT_LIKELY(pCur1))
733	{
734	PPGMPHYSHANDLER pCur2 = (PPGMPHYSHANDLER)RTAvlroGCPhysGet(&pVM->pgm.s.CTX_SUFF(pTrees)->PhysHandlers, GCPhys2);
735	if (RT_LIKELY(pCur2))
736	{
737	/*
738	* Make sure that they are adjacent, and that they've got the same callbacks.
739	*/
740	if (RT_LIKELY(pCur1->Core.KeyLast + 1 == pCur2->Core.Key))
741	{
742	if (RT_LIKELY( pCur1->pfnHandlerRC == pCur2->pfnHandlerRC
743	&& pCur1->pfnHandlerR0 == pCur2->pfnHandlerR0
744	&& pCur1->pfnHandlerR3 == pCur2->pfnHandlerR3))
745	{
746	PPGMPHYSHANDLER pCur3 = (PPGMPHYSHANDLER)RTAvlroGCPhysRemove(&pVM->pgm.s.CTX_SUFF(pTrees)->PhysHandlers, GCPhys2);
747	if (RT_LIKELY(pCur3 == pCur2))
748	{
749	pCur1->Core.KeyLast = pCur2->Core.KeyLast;
750	pCur1->cPages = (pCur1->Core.KeyLast - (pCur1->Core.Key & X86_PTE_PAE_PG_MASK) + PAGE_SIZE) >> PAGE_SHIFT;
751	LogFlow(("PGMHandlerPhysicalJoin: %RGp-%RGp %RGp-%RGp\n",
752	pCur1->Core.Key, pCur1->Core.KeyLast, pCur2->Core.Key, pCur2->Core.KeyLast));
753	MMHyperFree(pVM, pCur2);
754	pgmUnlock(pVM);
755	return VINF_SUCCESS;
756	}
757
758	Assert(pCur3 == pCur2);
759	rc = VERR_INTERNAL_ERROR;
760	}
761	else
762	{
763	AssertMsgFailed(("mismatching handlers\n"));
764	rc = VERR_ACCESS_DENIED;
765	}
766	}
767	else
768	{
769	AssertMsgFailed(("not adjacent: %RGp-%RGp %RGp-%RGp\n",
770	pCur1->Core.Key, pCur1->Core.KeyLast, pCur2->Core.Key, pCur2->Core.KeyLast));
771	rc = VERR_INVALID_PARAMETER;
772	}
773	}
774	else
775	{
776	AssertMsgFailed(("Didn't find range starting at %RGp\n", GCPhys2));
777	rc = VERR_PGM_HANDLER_NOT_FOUND;
778	}
779	}
780	else
781	{
782	AssertMsgFailed(("Didn't find range starting at %RGp\n", GCPhys1));
783	rc = VERR_PGM_HANDLER_NOT_FOUND;
784	}
785	pgmUnlock(pVM);
786	return rc;
787
788	}
789
790
791	/**
792	* Resets any modifications to individual pages in a physical
793	* page access handler region.
794	*
795	* This is used in pair with PGMHandlerPhysicalPageTempOff() or
796	* PGMHandlerPhysicalPageAlias().
797	*
798	* @returns VBox status code.
799	* @param pVM VM Handle
800	* @param GCPhys The start address of the handler regions, i.e. what you
801	* passed to PGMR3HandlerPhysicalRegister(),
802	* PGMHandlerPhysicalRegisterEx() or
803	* PGMHandlerPhysicalModify().
804	*/
805	VMMDECL(int) PGMHandlerPhysicalReset(PVM pVM, RTGCPHYS GCPhys)
806	{
807	LogFlow(("PGMHandlerPhysicalReset GCPhys=%RGp\n", GCPhys));
808	pgmLock(pVM);
809
810	/*
811	* Find the handler.
812	*/
813	int rc;
814	PPGMPHYSHANDLER pCur = (PPGMPHYSHANDLER)RTAvlroGCPhysGet(&pVM->pgm.s.CTX_SUFF(pTrees)->PhysHandlers, GCPhys);
815	if (RT_LIKELY(pCur))
816	{
817	/*
818	* Validate type.
819	*/
820	switch (pCur->enmType)
821	{
822	case PGMPHYSHANDLERTYPE_PHYSICAL_WRITE:
823	case PGMPHYSHANDLERTYPE_PHYSICAL_ALL:
824	case PGMPHYSHANDLERTYPE_MMIO: /* NOTE: Only use when clearing MMIO ranges with aliased MMIO2 pages! */
825	{
826	STAM_COUNTER_INC(&pVM->pgm.s.CTX_MID_Z(Stat,PhysHandlerReset)); /*@Todo move out of switch /
827	PPGMRAMRANGE pRam = pgmPhysGetRange(&pVM->pgm.s, GCPhys);
828	Assert(pRam);
829	Assert(pRam->GCPhys <= pCur->Core.Key);
830	Assert(pRam->GCPhysLast >= pCur->Core.KeyLast);
831
832	if (pCur->enmType == PGMPHYSHANDLERTYPE_MMIO)
833	{
834	/*
835	* Reset all the PGMPAGETYPE_MMIO2_ALIAS_MMIO pages first and that's it.
836	* This could probably be optimized a bit wrt to flushing, but I'm too lazy
837	* to do that now...
838	*/
839	PPGMPAGE pPage = &pRam->aPages[(pCur->Core.Key - pRam->GCPhys) >> PAGE_SHIFT];
840	uint32_t cLeft = pCur->cPages;
841	while (cLeft-- > 0)
842	{
843	if (PGM_PAGE_GET_TYPE(pPage) == PGMPAGETYPE_MMIO2_ALIAS_MMIO)
844	pgmHandlerPhysicalResetAliasedPage(pVM, pPage, pRam->GCPhys + ((RTGCPHYS)(uintptr_t)(pPage - &pRam->aPages[0]) << PAGE_SHIFT));
845	Assert(PGM_PAGE_GET_TYPE(pPage) == PGMPAGETYPE_MMIO);
846	pPage++;
847	}
848	}
849	else
850	{
851	/*
852	* Set the flags and flush shadow PT entries.
853	*/
854	rc = pgmHandlerPhysicalSetRamFlagsAndFlushShadowPTs(pVM, pCur, pRam);
855	}
856
857	rc = VINF_SUCCESS;
858	break;
859	}
860
861	/*
862	* Invalid.
863	*/
864	default:
865	AssertMsgFailed(("Invalid type %d! Corruption!\n", pCur->enmType));
866	rc = VERR_INTERNAL_ERROR;
867	break;
868	}
869	}
870	else
871	{
872	AssertMsgFailed(("Didn't find MMIO Range starting at %#x\n", GCPhys));
873	rc = VERR_PGM_HANDLER_NOT_FOUND;
874	}
875
876	pgmUnlock(pVM);
877	return rc;
878	}
879
880
881	/**
882	* Temporarily turns off the access monitoring of a page within a monitored
883	* physical write/all page access handler region.
884	*
885	* Use this when no further \#PFs are required for that page. Be aware that
886	* a page directory sync might reset the flags, and turn on access monitoring
887	* for the page.
888	*
889	* The caller must do required page table modifications.
890	*
891	* @returns VBox status code.
892	* @param pVM VM Handle
893	* @param GCPhys The start address of the access handler. This
894	* must be a fully page aligned range or we risk
895	* messing up other handlers installed for the
896	* start and end pages.
897	* @param GCPhysPage The physical address of the page to turn off
898	* access monitoring for.
899	*/
900	VMMDECL(int) PGMHandlerPhysicalPageTempOff(PVM pVM, RTGCPHYS GCPhys, RTGCPHYS GCPhysPage)
901	{
902	LogFlow(("PGMHandlerPhysicalPageTempOff GCPhys=%RGp\n", GCPhys));
903
904	pgmLock(pVM);
905	/*
906	* Validate the range.
907	*/
908	PPGMPHYSHANDLER pCur = (PPGMPHYSHANDLER)RTAvlroGCPhysGet(&pVM->pgm.s.CTX_SUFF(pTrees)->PhysHandlers, GCPhys);
909	if (RT_LIKELY(pCur))
910	{
911	if (RT_LIKELY( GCPhysPage >= pCur->Core.Key
912	&& GCPhysPage <= pCur->Core.KeyLast))
913	{
914	Assert(!(pCur->Core.Key & PAGE_OFFSET_MASK));
915	Assert((pCur->Core.KeyLast & PAGE_OFFSET_MASK) == PAGE_OFFSET_MASK);
916
917	AssertReturnStmt( pCur->enmType == PGMPHYSHANDLERTYPE_PHYSICAL_WRITE
918	\|\| pCur->enmType == PGMPHYSHANDLERTYPE_PHYSICAL_ALL,
919	pgmUnlock(pVM), VERR_ACCESS_DENIED);
920
921	/*
922	* Change the page status.
923	*/
924	PPGMPAGE pPage;
925	int rc = pgmPhysGetPageEx(&pVM->pgm.s, GCPhysPage, &pPage);
926	AssertReturnStmt(RT_SUCCESS_NP(rc), pgmUnlock(pVM), rc);
927	PGM_PAGE_SET_HNDL_PHYS_STATE(pPage, PGM_PAGE_HNDL_PHYS_STATE_DISABLED);
928	pgmUnlock(pVM);
929	return VINF_SUCCESS;
930	}
931	pgmUnlock(pVM);
932	AssertMsgFailed(("The page %#x is outside the range %#x-%#x\n",
933	GCPhysPage, pCur->Core.Key, pCur->Core.KeyLast));
934	return VERR_INVALID_PARAMETER;
935	}
936	pgmUnlock(pVM);
937	AssertMsgFailed(("Specified physical handler start address %#x is invalid.\n", GCPhys));
938	return VERR_PGM_HANDLER_NOT_FOUND;
939	}
940
941
942	/**
943	* Replaces an MMIO page with an MMIO2 page.
944	*
945	* This is a worker for IOMMMIOMapMMIO2Page that works in a similar way to
946	* PGMHandlerPhysicalPageTempOff but for an MMIO page. Since an MMIO page has no
947	* backing, the caller must provide a replacement page. For various reasons the
948	* replacement page must be an MMIO2 page.
949	*
950	* The caller must do required page table modifications. You can get away
951	* without making any modifations since it's an MMIO page, the cost is an extra
952	* \#PF which will the resync the page.
953	*
954	* Call PGMHandlerPhysicalReset() to restore the MMIO page.
955	*
956	* The caller may still get handler callback even after this call and must be
957	* able to deal correctly with such calls. The reason for these callbacks are
958	* either that we're executing in the recompiler (which doesn't know about this
959	* arrangement) or that we've been restored from saved state (where we won't
960	* save the change).
961	*
962	* @returns VBox status code.
963	* @param pVM The VM handle
964	* @param GCPhys The start address of the access handler. This
965	* must be a fully page aligned range or we risk
966	* messing up other handlers installed for the
967	* start and end pages.
968	* @param GCPhysPage The physical address of the page to turn off
969	* access monitoring for.
970	* @param GCPhysPageRemap The physical address of the MMIO2 page that
971	* serves as backing memory.
972	*
973	* @remark May cause a page pool flush if used on a page that is already
974	* aliased.
975	*
976	* @note This trick does only work reliably if the two pages are never ever
977	* mapped in the same page table. If they are the page pool code will
978	* be confused should either of them be flushed. See the special case
979	* of zero page aliasing mentioned in #3170.
980	*
981	*/
982	VMMDECL(int) PGMHandlerPhysicalPageAlias(PVM pVM, RTGCPHYS GCPhys, RTGCPHYS GCPhysPage, RTGCPHYS GCPhysPageRemap)
983	{
984	/// Assert(!IOMIsLockOwner(pVM)); /* We mustn't own any other locks when calling this */
985
986	pgmLock(pVM);
987	/*
988	* Lookup and validate the range.
989	*/
990	PPGMPHYSHANDLER pCur = (PPGMPHYSHANDLER)RTAvlroGCPhysGet(&pVM->pgm.s.CTX_SUFF(pTrees)->PhysHandlers, GCPhys);
991	if (RT_LIKELY(pCur))
992	{
993	if (RT_LIKELY( GCPhysPage >= pCur->Core.Key
994	&& GCPhysPage <= pCur->Core.KeyLast))
995	{
996	AssertReturnStmt(pCur->enmType == PGMPHYSHANDLERTYPE_MMIO, pgmUnlock(pVM), VERR_ACCESS_DENIED);
997	AssertReturnStmt(!(pCur->Core.Key & PAGE_OFFSET_MASK), pgmUnlock(pVM), VERR_INVALID_PARAMETER);
998	AssertReturnStmt((pCur->Core.KeyLast & PAGE_OFFSET_MASK) == PAGE_OFFSET_MASK, pgmUnlock(pVM), VERR_INVALID_PARAMETER);
999
1000	/*
1001	* Get and validate the two pages.
1002	*/
1003	PPGMPAGE pPageRemap;
1004	int rc = pgmPhysGetPageEx(&pVM->pgm.s, GCPhysPageRemap, &pPageRemap);
1005	AssertReturnStmt(RT_SUCCESS_NP(rc), pgmUnlock(pVM), rc);
1006	AssertMsgReturnStmt(PGM_PAGE_GET_TYPE(pPageRemap) == PGMPAGETYPE_MMIO2,
1007	("GCPhysPageRemap=%RGp %R[pgmpage]\n", GCPhysPageRemap, pPageRemap),
1008	pgmUnlock(pVM), VERR_PGM_PHYS_NOT_MMIO2);
1009
1010	PPGMPAGE pPage;
1011	rc = pgmPhysGetPageEx(&pVM->pgm.s, GCPhysPage, &pPage);
1012	AssertReturnStmt(RT_SUCCESS_NP(rc), pgmUnlock(pVM), rc);
1013	if (PGM_PAGE_GET_TYPE(pPage) != PGMPAGETYPE_MMIO)
1014	{
1015	AssertMsgReturn(PGM_PAGE_GET_TYPE(pPage) == PGMPAGETYPE_MMIO2_ALIAS_MMIO,
1016	("GCPhysPage=%RGp %R[pgmpage]\n", GCPhysPage, pPage),
1017	VERR_PGM_PHYS_NOT_MMIO2);
1018	if (PGM_PAGE_GET_HCPHYS(pPage) == PGM_PAGE_GET_HCPHYS(pPageRemap))
1019	{
1020	pgmUnlock(pVM);
1021	return VINF_PGM_HANDLER_ALREADY_ALIASED;
1022	}
1023
1024	/*
1025	* The page is already mapped as some other page, reset it
1026	* to an MMIO/ZERO page before doing the new mapping.
1027	*/
1028	Log(("PGMHandlerPhysicalPageAlias: GCPhysPage=%RGp (%R[pgmpage]; %RHp -> %RHp\n",
1029	GCPhysPage, pPage, PGM_PAGE_GET_HCPHYS(pPage), PGM_PAGE_GET_HCPHYS(pPageRemap)));
1030	pgmHandlerPhysicalResetAliasedPage(pVM, pPage, GCPhysPage);
1031	}
1032	Assert(PGM_PAGE_IS_ZERO(pPage));
1033
1034	/*
1035	* Do the actual remapping here.
1036	* This page now serves as an alias for the backing memory specified.
1037	*/
1038	LogFlow(("PGMHandlerPhysicalPageAlias: %RGp (%R[pgmpage]) alias for %RGp (%R[pgmpage])\n",
1039	GCPhysPage, pPage, GCPhysPageRemap, pPageRemap ));
1040	PGM_PAGE_SET_HCPHYS(pPage, PGM_PAGE_GET_HCPHYS(pPageRemap));
1041	PGM_PAGE_SET_TYPE(pPage, PGMPAGETYPE_MMIO2_ALIAS_MMIO);
1042	PGM_PAGE_SET_STATE(pPage, PGM_PAGE_STATE_ALLOCATED);
1043	PGM_PAGE_SET_PAGEID(pPage, PGM_PAGE_GET_PAGEID(pPageRemap));
1044	PGM_PAGE_SET_HNDL_PHYS_STATE(pPage, PGM_PAGE_HNDL_PHYS_STATE_DISABLED);
1045
1046	/* Flush its TLB entry. */
1047	PGMPhysInvalidatePageMapTLBEntry(pVM, GCPhysPage);
1048
1049	LogFlow(("PGMHandlerPhysicalPageAlias: => %R[pgmpage]\n", pPage));
1050	pgmUnlock(pVM);
1051	return VINF_SUCCESS;
1052	}
1053
1054	pgmUnlock(pVM);
1055	AssertMsgFailed(("The page %#x is outside the range %#x-%#x\n",
1056	GCPhysPage, pCur->Core.Key, pCur->Core.KeyLast));
1057	return VERR_INVALID_PARAMETER;
1058	}
1059
1060	pgmUnlock(pVM);
1061	AssertMsgFailed(("Specified physical handler start address %#x is invalid.\n", GCPhys));
1062	return VERR_PGM_HANDLER_NOT_FOUND;
1063	}
1064
1065	/**
1066	* Replaces an MMIO page with an arbitrary HC page.
1067	*
1068	* This is a worker for IOMMMIOMapMMIO2Page that works in a similar way to
1069	* PGMHandlerPhysicalPageTempOff but for an MMIO page. Since an MMIO page has no
1070	* backing, the caller must provide a replacement page. For various reasons the
1071	* replacement page must be an MMIO2 page.
1072	*
1073	* The caller must do required page table modifications. You can get away
1074	* without making any modifations since it's an MMIO page, the cost is an extra
1075	* \#PF which will the resync the page.
1076	*
1077	* Call PGMHandlerPhysicalReset() to restore the MMIO page.
1078	*
1079	* The caller may still get handler callback even after this call and must be
1080	* able to deal correctly with such calls. The reason for these callbacks are
1081	* either that we're executing in the recompiler (which doesn't know about this
1082	* arrangement) or that we've been restored from saved state (where we won't
1083	* save the change).
1084	*
1085	* @returns VBox status code.
1086	* @param pVM The VM handle
1087	* @param GCPhys The start address of the access handler. This
1088	* must be a fully page aligned range or we risk
1089	* messing up other handlers installed for the
1090	* start and end pages.
1091	* @param GCPhysPage The physical address of the page to turn off
1092	* access monitoring for.
1093	* @param HCPhysPageRemap The physical address of the HC page that
1094	* serves as backing memory.
1095	*
1096	* @remark May cause a page pool flush if used on a page that is already
1097	* aliased.
1098	*/
1099	VMMDECL(int) PGMHandlerPhysicalPageAliasHC(PVM pVM, RTGCPHYS GCPhys, RTGCPHYS GCPhysPage, RTHCPHYS HCPhysPageRemap)
1100	{
1101	/// Assert(!IOMIsLockOwner(pVM)); /* We mustn't own any other locks when calling this */
1102
1103	/*
1104	* Lookup and validate the range.
1105	*/
1106	pgmLock(pVM);
1107	PPGMPHYSHANDLER pCur = (PPGMPHYSHANDLER)RTAvlroGCPhysGet(&pVM->pgm.s.CTX_SUFF(pTrees)->PhysHandlers, GCPhys);
1108	if (RT_LIKELY(pCur))
1109	{
1110	if (RT_LIKELY( GCPhysPage >= pCur->Core.Key
1111	&& GCPhysPage <= pCur->Core.KeyLast))
1112	{
1113	AssertReturnStmt(pCur->enmType == PGMPHYSHANDLERTYPE_MMIO, pgmUnlock(pVM), VERR_ACCESS_DENIED);
1114	AssertReturnStmt(!(pCur->Core.Key & PAGE_OFFSET_MASK), pgmUnlock(pVM), VERR_INVALID_PARAMETER);
1115	AssertReturnStmt((pCur->Core.KeyLast & PAGE_OFFSET_MASK) == PAGE_OFFSET_MASK, pgmUnlock(pVM), VERR_INVALID_PARAMETER);
1116
1117	/*
1118	* Get and validate the pages.
1119	*/
1120	PPGMPAGE pPage;
1121	int rc = pgmPhysGetPageEx(&pVM->pgm.s, GCPhysPage, &pPage);
1122	AssertReturnStmt(RT_SUCCESS_NP(rc), pgmUnlock(pVM), rc);
1123	if (PGM_PAGE_GET_TYPE(pPage) != PGMPAGETYPE_MMIO)
1124	{
1125	pgmUnlock(pVM);
1126	AssertMsgReturn(PGM_PAGE_GET_TYPE(pPage) == PGMPAGETYPE_MMIO2_ALIAS_MMIO,
1127	("GCPhysPage=%RGp %R[pgmpage]\n", GCPhysPage, pPage),
1128	VERR_PGM_PHYS_NOT_MMIO2);
1129	return VINF_PGM_HANDLER_ALREADY_ALIASED;
1130	}
1131	Assert(PGM_PAGE_IS_ZERO(pPage));
1132
1133	/*
1134	* Do the actual remapping here.
1135	* This page now serves as an alias for the backing memory specified.
1136	*/
1137	LogFlow(("PGMHandlerPhysicalPageAlias: %RGp (%R[pgmpage]) alias for %RHp\n",
1138	GCPhysPage, pPage, HCPhysPageRemap));
1139	PGM_PAGE_SET_HCPHYS(pPage, HCPhysPageRemap);
1140	PGM_PAGE_SET_TYPE(pPage, PGMPAGETYPE_MMIO2_ALIAS_MMIO);
1141	PGM_PAGE_SET_STATE(pPage, PGM_PAGE_STATE_ALLOCATED);
1142	/** @todo hack alert
1143	* This needs to be done properly. Currently we get away with it as the recompiler directly calls
1144	* IOM read and write functions. Access through PGMPhysRead/Write will crash the process.
1145	*/
1146	PGM_PAGE_SET_PAGEID(pPage, NIL_GMM_PAGEID);
1147	PGM_PAGE_SET_HNDL_PHYS_STATE(pPage, PGM_PAGE_HNDL_PHYS_STATE_DISABLED);
1148
1149	/* Flush its TLB entry. */
1150	PGMPhysInvalidatePageMapTLBEntry(pVM, GCPhysPage);
1151	LogFlow(("PGMHandlerPhysicalPageAliasHC: => %R[pgmpage]\n", pPage));
1152	pgmUnlock(pVM);
1153	return VINF_SUCCESS;
1154	}
1155	pgmUnlock(pVM);
1156	AssertMsgFailed(("The page %#x is outside the range %#x-%#x\n",
1157	GCPhysPage, pCur->Core.Key, pCur->Core.KeyLast));
1158	return VERR_INVALID_PARAMETER;
1159	}
1160	pgmUnlock(pVM);
1161
1162	AssertMsgFailed(("Specified physical handler start address %#x is invalid.\n", GCPhys));
1163	return VERR_PGM_HANDLER_NOT_FOUND;
1164	}
1165
1166
1167	/**
1168	* Checks if a physical range is handled
1169	*
1170	* @returns boolean
1171	* @param pVM VM Handle.
1172	* @param GCPhys Start physical address earlier passed to PGMR3HandlerPhysicalRegister().
1173	* @remarks Caller must take the PGM lock...
1174	* @thread EMT.
1175	*/
1176	VMMDECL(bool) PGMHandlerPhysicalIsRegistered(PVM pVM, RTGCPHYS GCPhys)
1177	{
1178	/*
1179	* Find the handler.
1180	*/
1181	pgmLock(pVM);
1182	PPGMPHYSHANDLER pCur = (PPGMPHYSHANDLER)RTAvlroGCPhysRangeGet(&pVM->pgm.s.CTX_SUFF(pTrees)->PhysHandlers, GCPhys);
1183	if (pCur)
1184	{
1185	Assert(GCPhys >= pCur->Core.Key && GCPhys <= pCur->Core.KeyLast);
1186	Assert( pCur->enmType == PGMPHYSHANDLERTYPE_PHYSICAL_WRITE
1187	\|\| pCur->enmType == PGMPHYSHANDLERTYPE_PHYSICAL_ALL
1188	\|\| pCur->enmType == PGMPHYSHANDLERTYPE_MMIO);
1189	pgmUnlock(pVM);
1190	return true;
1191	}
1192	pgmUnlock(pVM);
1193	return false;
1194	}
1195
1196
1197	/**
1198	* Checks if it's an disabled all access handler or write access handler at the
1199	* given address.
1200	*
1201	* @returns true if it's an all access handler, false if it's a write access
1202	* handler.
1203	* @param pVM Pointer to the shared VM structure.
1204	* @param GCPhys The address of the page with a disabled handler.
1205	*
1206	* @remarks The caller, PGMR3PhysTlbGCPhys2Ptr, must hold the PGM lock.
1207	*/
1208	bool pgmHandlerPhysicalIsAll(PVM pVM, RTGCPHYS GCPhys)
1209	{
1210	pgmLock(pVM);
1211	PPGMPHYSHANDLER pCur = (PPGMPHYSHANDLER)RTAvlroGCPhysRangeGet(&pVM->pgm.s.CTX_SUFF(pTrees)->PhysHandlers, GCPhys);
1212	if (!pCur)
1213	{
1214	pgmUnlock(pVM);
1215	AssertFailed();
1216	return true;
1217	}
1218	Assert( pCur->enmType == PGMPHYSHANDLERTYPE_PHYSICAL_WRITE
1219	\|\| pCur->enmType == PGMPHYSHANDLERTYPE_PHYSICAL_ALL
1220	\|\| pCur->enmType == PGMPHYSHANDLERTYPE_MMIO); /* sanity */
1221	/* Only whole pages can be disabled. */
1222	Assert( pCur->Core.Key <= (GCPhys & ~(RTGCPHYS)PAGE_OFFSET_MASK)
1223	&& pCur->Core.KeyLast >= (GCPhys \| PAGE_OFFSET_MASK));
1224
1225	bool bRet = pCur->enmType != PGMPHYSHANDLERTYPE_PHYSICAL_WRITE;
1226	pgmUnlock(pVM);
1227	return bRet;
1228	}
1229
1230
1231	/**
1232	* Check if particular guest's VA is being monitored.
1233	*
1234	* @returns true or false
1235	* @param pVM VM handle.
1236	* @param GCPtr Virtual address.
1237	* @remarks Will acquire the PGM lock.
1238	* @thread Any.
1239	*/
1240	VMMDECL(bool) PGMHandlerVirtualIsRegistered(PVM pVM, RTGCPTR GCPtr)
1241	{
1242	pgmLock(pVM);
1243	PPGMVIRTHANDLER pCur = (PPGMVIRTHANDLER)RTAvlroGCPtrGet(&pVM->pgm.s.CTX_SUFF(pTrees)->VirtHandlers, GCPtr);
1244	pgmUnlock(pVM);
1245
1246	return pCur != NULL;
1247	}
1248
1249
1250	/**
1251	* Search for virtual handler with matching physical address
1252	*
1253	* @returns VBox status code
1254	* @param pVM The VM handle.
1255	* @param GCPhys GC physical address to search for.
1256	* @param ppVirt Where to store the pointer to the virtual handler structure.
1257	* @param piPage Where to store the pointer to the index of the cached physical page.
1258	*/
1259	int pgmHandlerVirtualFindByPhysAddr(PVM pVM, RTGCPHYS GCPhys, PPGMVIRTHANDLER ppVirt, unsigned piPage)
1260	{
1261	STAM_PROFILE_START(&pVM->pgm.s.CTX_MID_Z(Stat,VirtHandlerSearchByPhys), a);
1262	Assert(ppVirt);
1263
1264	pgmLock(pVM);
1265	PPGMPHYS2VIRTHANDLER pCur;
1266	pCur = (PPGMPHYS2VIRTHANDLER)RTAvlroGCPhysRangeGet(&pVM->pgm.s.CTX_SUFF(pTrees)->PhysToVirtHandlers, GCPhys);
1267	if (pCur)
1268	{
1269	/* found a match! */
1270	*ppVirt = (PPGMVIRTHANDLER)((uintptr_t)pCur + pCur->offVirtHandler);
1271	piPage = pCur - &(ppVirt)->aPhysToVirt[0];
1272	pgmUnlock(pVM);
1273
1274	#ifdef VBOX_STRICT_PGM_HANDLER_VIRTUAL
1275	AssertRelease(pCur->offNextAlias & PGMPHYS2VIRTHANDLER_IS_HEAD);
1276	#endif
1277	LogFlow(("PHYS2VIRT: found match for %RGp -> %RGv piPage=%#x\n", GCPhys, (ppVirt)->Core.Key, *piPage));
1278	STAM_PROFILE_STOP(&pVM->pgm.s.CTX_MID_Z(Stat,VirtHandlerSearchByPhys), a);
1279	return VINF_SUCCESS;
1280	}
1281
1282	pgmUnlock(pVM);
1283	*ppVirt = NULL;
1284	STAM_PROFILE_STOP(&pVM->pgm.s.CTX_MID_Z(Stat,VirtHandlerSearchByPhys), a);
1285	return VERR_PGM_HANDLER_NOT_FOUND;
1286	}
1287
1288
1289	/**
1290	* Deal with aliases in phys2virt.
1291	*
1292	* As pointed out by the various todos, this currently only deals with
1293	* aliases where the two ranges match 100%.
1294	*
1295	* @param pVM The VM handle.
1296	* @param pPhys2Virt The node we failed insert.
1297	*/
1298	static void pgmHandlerVirtualInsertAliased(PVM pVM, PPGMPHYS2VIRTHANDLER pPhys2Virt)
1299	{
1300	/*
1301	* First find the node which is conflicting with us.
1302	*/
1303	/** @todo Deal with partial overlapping. (Unlikly situation, so I'm too lazy to do anything about it now.) */
1304	/** @todo check if the current head node covers the ground we do. This is highly unlikely
1305	* and I'm too lazy to implement this now as it will require sorting the list and stuff like that. */
1306	PPGMPHYS2VIRTHANDLER pHead = (PPGMPHYS2VIRTHANDLER)RTAvlroGCPhysGet(&pVM->pgm.s.CTX_SUFF(pTrees)->PhysToVirtHandlers, pPhys2Virt->Core.Key);
1307	#ifdef VBOX_STRICT_PGM_HANDLER_VIRTUAL
1308	AssertReleaseMsg(pHead != pPhys2Virt, ("%RGp-%RGp offVirtHandler=%#RX32\n",
1309	pPhys2Virt->Core.Key, pPhys2Virt->Core.KeyLast, pPhys2Virt->offVirtHandler));
1310	#endif
1311	if (RT_UNLIKELY(!pHead \|\| pHead->Core.KeyLast != pPhys2Virt->Core.KeyLast))
1312	{
1313	/** @todo do something clever here... */
1314	LogRel(("pgmHandlerVirtualInsertAliased: %RGp-%RGp\n", pPhys2Virt->Core.Key, pPhys2Virt->Core.KeyLast));
1315	pPhys2Virt->offNextAlias = 0;
1316	return;
1317	}
1318
1319	/*
1320	* Insert ourselves as the next node.
1321	*/
1322	if (!(pHead->offNextAlias & PGMPHYS2VIRTHANDLER_OFF_MASK))
1323	pPhys2Virt->offNextAlias = PGMPHYS2VIRTHANDLER_IN_TREE;
1324	else
1325	{
1326	PPGMPHYS2VIRTHANDLER pNext = (PPGMPHYS2VIRTHANDLER)((intptr_t)pHead + (pHead->offNextAlias & PGMPHYS2VIRTHANDLER_OFF_MASK));
1327	pPhys2Virt->offNextAlias = ((intptr_t)pNext - (intptr_t)pPhys2Virt)
1328	\| PGMPHYS2VIRTHANDLER_IN_TREE;
1329	}
1330	pHead->offNextAlias = ((intptr_t)pPhys2Virt - (intptr_t)pHead)
1331	\| (pHead->offNextAlias & ~PGMPHYS2VIRTHANDLER_OFF_MASK);
1332	Log(("pgmHandlerVirtualInsertAliased: %RGp-%RGp offNextAlias=%#RX32\n", pPhys2Virt->Core.Key, pPhys2Virt->Core.KeyLast, pPhys2Virt->offNextAlias));
1333	}
1334
1335
1336	/**
1337	* Resets one virtual handler range.
1338	*
1339	* This is called by HandlerVirtualUpdate when it has detected some kind of
1340	* problem and have started clearing the virtual handler page states (or
1341	* when there have been registration/deregistrations). For this reason this
1342	* function will only update the page status if it's lower than desired.
1343	*
1344	* @returns 0
1345	* @param pNode Pointer to a PGMVIRTHANDLER.
1346	* @param pvUser The VM handle.
1347	*/
1348	DECLCALLBACK(int) pgmHandlerVirtualResetOne(PAVLROGCPTRNODECORE pNode, void *pvUser)
1349	{
1350	PPGMVIRTHANDLER pCur = (PPGMVIRTHANDLER)pNode;
1351	PVM pVM = (PVM)pvUser;
1352
1353	Assert(PGMIsLockOwner(pVM));
1354	/*
1355	* Iterate the pages and apply the new state.
1356	*/
1357	unsigned uState = pgmHandlerVirtualCalcState(pCur);
1358	PPGMRAMRANGE pRamHint = NULL;
1359	RTGCUINTPTR offPage = ((RTGCUINTPTR)pCur->Core.Key & PAGE_OFFSET_MASK);
1360	RTGCUINTPTR cbLeft = pCur->cb;
1361	for (unsigned iPage = 0; iPage < pCur->cPages; iPage++)
1362	{
1363	PPGMPHYS2VIRTHANDLER pPhys2Virt = &pCur->aPhysToVirt[iPage];
1364	if (pPhys2Virt->Core.Key != NIL_RTGCPHYS)
1365	{
1366	/*
1367	* Update the page state wrt virtual handlers.
1368	*/
1369	PPGMPAGE pPage;
1370	int rc = pgmPhysGetPageWithHintEx(&pVM->pgm.s, pPhys2Virt->Core.Key, &pPage, &pRamHint);
1371	if ( RT_SUCCESS(rc)
1372	&& PGM_PAGE_GET_HNDL_VIRT_STATE(pPage) < uState)
1373	PGM_PAGE_SET_HNDL_VIRT_STATE(pPage, uState);
1374	else
1375	AssertRC(rc);
1376
1377	/*
1378	* Need to insert the page in the Phys2Virt lookup tree?
1379	*/
1380	if (pPhys2Virt->Core.KeyLast == NIL_RTGCPHYS)
1381	{
1382	#ifdef VBOX_STRICT_PGM_HANDLER_VIRTUAL
1383	AssertRelease(!pPhys2Virt->offNextAlias);
1384	#endif
1385	unsigned cbPhys = cbLeft;
1386	if (cbPhys > PAGE_SIZE - offPage)
1387	cbPhys = PAGE_SIZE - offPage;
1388	else
1389	Assert(iPage == pCur->cPages - 1);
1390	pPhys2Virt->Core.KeyLast = pPhys2Virt->Core.Key + cbPhys - 1; /* inclusive */
1391	pPhys2Virt->offNextAlias = PGMPHYS2VIRTHANDLER_IS_HEAD \| PGMPHYS2VIRTHANDLER_IN_TREE;
1392	if (!RTAvlroGCPhysInsert(&pVM->pgm.s.CTX_SUFF(pTrees)->PhysToVirtHandlers, &pPhys2Virt->Core))
1393	pgmHandlerVirtualInsertAliased(pVM, pPhys2Virt);
1394	#ifdef VBOX_STRICT_PGM_HANDLER_VIRTUAL
1395	else
1396	AssertReleaseMsg(RTAvlroGCPhysGet(&pVM->pgm.s.CTX_SUFF(pTrees)->PhysToVirtHandlers, pPhys2Virt->Core.Key) == &pPhys2Virt->Core,
1397	("%RGp-%RGp offNextAlias=%#RX32\n",
1398	pPhys2Virt->Core.Key, pPhys2Virt->Core.KeyLast, pPhys2Virt->offNextAlias));
1399	#endif
1400	Log2(("PHYS2VIRT: Insert physical range %RGp-%RGp offNextAlias=%#RX32 %s\n",
1401	pPhys2Virt->Core.Key, pPhys2Virt->Core.KeyLast, pPhys2Virt->offNextAlias, R3STRING(pCur->pszDesc)));
1402	}
1403	}
1404	cbLeft -= PAGE_SIZE - offPage;
1405	offPage = 0;
1406	}
1407
1408	return 0;
1409	}
1410
1411	#if defined(VBOX_STRICT) \|\| defined(LOG_ENABLED)
1412
1413	/**
1414	* Worker for pgmHandlerVirtualDumpPhysPages.
1415	*
1416	* @returns 0 (continue enumeration).
1417	* @param pNode The virtual handler node.
1418	* @param pvUser User argument, unused.
1419	*/
1420	static DECLCALLBACK(int) pgmHandlerVirtualDumpPhysPagesCallback(PAVLROGCPHYSNODECORE pNode, void *pvUser)
1421	{
1422	PPGMPHYS2VIRTHANDLER pCur = (PPGMPHYS2VIRTHANDLER)pNode;
1423	PPGMVIRTHANDLER pVirt = (PPGMVIRTHANDLER)((uintptr_t)pCur + pCur->offVirtHandler);
1424	Log(("PHYS2VIRT: Range %RGp-%RGp for virtual handler: %s\n", pCur->Core.Key, pCur->Core.KeyLast, pVirt->pszDesc));
1425	return 0;
1426	}
1427
1428
1429	/**
1430	* Assertion / logging helper for dumping all the
1431	* virtual handlers to the log.
1432	*
1433	* @param pVM Pointer to the shared VM structure.
1434	*/
1435	void pgmHandlerVirtualDumpPhysPages(PVM pVM)
1436	{
1437	RTAvlroGCPhysDoWithAll(&pVM->pgm.s.CTX_SUFF(pTrees)->PhysToVirtHandlers, true /* from left */,
1438	pgmHandlerVirtualDumpPhysPagesCallback, 0);
1439	}
1440
1441	#endif /* VBOX_STRICT \|\| LOG_ENABLED */
1442	#ifdef VBOX_STRICT
1443
1444	/**
1445	* State structure used by the PGMAssertHandlerAndFlagsInSync() function
1446	* and its AVL enumerators.
1447	*/
1448	typedef struct PGMAHAFIS
1449	{
1450	/** The current physical address. */
1451	RTGCPHYS GCPhys;
1452	/** The state we've calculated. */
1453	unsigned uVirtStateFound;
1454	/** The state we're matching up to. */
1455	unsigned uVirtState;
1456	/** Number of errors. */
1457	unsigned cErrors;
1458	/** The VM handle. */
1459	PVM pVM;
1460	} PGMAHAFIS, *PPGMAHAFIS;
1461
1462
1463	#if 0 /* unused */
1464	/**
1465	* Verify virtual handler by matching physical address.
1466	*
1467	* @returns 0
1468	* @param pNode Pointer to a PGMVIRTHANDLER.
1469	* @param pvUser Pointer to user parameter.
1470	*/
1471	static DECLCALLBACK(int) pgmHandlerVirtualVerifyOneByPhysAddr(PAVLROGCPTRNODECORE pNode, void *pvUser)
1472	{
1473	PPGMVIRTHANDLER pCur = (PPGMVIRTHANDLER)pNode;
1474	PPGMAHAFIS pState = (PPGMAHAFIS)pvUser;
1475
1476	for (unsigned iPage = 0; iPage < pCur->cPages; iPage++)
1477	{
1478	if ((pCur->aPhysToVirt[iPage].Core.Key & X86_PTE_PAE_PG_MASK) == pState->GCPhys)
1479	{
1480	unsigned uState = pgmHandlerVirtualCalcState(pCur);
1481	if (pState->uVirtState < uState)
1482	{
1483	error
1484	}
1485
1486	if (pState->uVirtState == uState)
1487	break; //??
1488	}
1489	}
1490	return 0;
1491	}
1492	#endif /* unused */
1493
1494
1495	/**
1496	* Verify a virtual handler (enumeration callback).
1497	*
1498	* Called by PGMAssertHandlerAndFlagsInSync to check the sanity of all
1499	* the virtual handlers, esp. that the physical addresses matches up.
1500	*
1501	* @returns 0
1502	* @param pNode Pointer to a PGMVIRTHANDLER.
1503	* @param pvUser Pointer to a PPGMAHAFIS structure.
1504	*/
1505	static DECLCALLBACK(int) pgmHandlerVirtualVerifyOne(PAVLROGCPTRNODECORE pNode, void *pvUser)
1506	{
1507	PPGMVIRTHANDLER pVirt = (PPGMVIRTHANDLER)pNode;
1508	PPGMAHAFIS pState = (PPGMAHAFIS)pvUser;
1509	PVM pVM = pState->pVM;
1510
1511	/*
1512	* Validate the type and calc state.
1513	*/
1514	switch (pVirt->enmType)
1515	{
1516	case PGMVIRTHANDLERTYPE_WRITE:
1517	case PGMVIRTHANDLERTYPE_ALL:
1518	break;
1519	default:
1520	AssertMsgFailed(("unknown/wrong enmType=%d\n", pVirt->enmType));
1521	pState->cErrors++;
1522	return 0;
1523	}
1524	const unsigned uState = pgmHandlerVirtualCalcState(pVirt);
1525
1526	/*
1527	* Check key alignment.
1528	*/
1529	if ( (pVirt->aPhysToVirt[0].Core.Key & PAGE_OFFSET_MASK) != ((RTGCUINTPTR)pVirt->Core.Key & PAGE_OFFSET_MASK)
1530	&& pVirt->aPhysToVirt[0].Core.Key != NIL_RTGCPHYS)
1531	{
1532	AssertMsgFailed(("virt handler phys has incorrect key! %RGp %RGv %s\n",
1533	pVirt->aPhysToVirt[0].Core.Key, pVirt->Core.Key, R3STRING(pVirt->pszDesc)));
1534	pState->cErrors++;
1535	}
1536
1537	if ( (pVirt->aPhysToVirt[pVirt->cPages - 1].Core.KeyLast & PAGE_OFFSET_MASK) != ((RTGCUINTPTR)pVirt->Core.KeyLast & PAGE_OFFSET_MASK)
1538	&& pVirt->aPhysToVirt[pVirt->cPages - 1].Core.Key != NIL_RTGCPHYS)
1539	{
1540	AssertMsgFailed(("virt handler phys has incorrect key! %RGp %RGv %s\n",
1541	pVirt->aPhysToVirt[pVirt->cPages - 1].Core.KeyLast, pVirt->Core.KeyLast, R3STRING(pVirt->pszDesc)));
1542	pState->cErrors++;
1543	}
1544
1545	/*
1546	* Check pages for sanity and state.
1547	*/
1548	RTGCUINTPTR GCPtr = (RTGCUINTPTR)pVirt->Core.Key;
1549	for (unsigned iPage = 0; iPage < pVirt->cPages; iPage++, GCPtr += PAGE_SIZE)
1550	{
1551	for (VMCPUID i = 0; i < pVM->cCpus; i++)
1552	{
1553	PVMCPU pVCpu = &pVM->aCpus[i];
1554
1555	RTGCPHYS GCPhysGst;
1556	uint64_t fGst;
1557	int rc = PGMGstGetPage(pVCpu, (RTGCPTR)GCPtr, &fGst, &GCPhysGst);
1558	if ( rc == VERR_PAGE_NOT_PRESENT
1559	\|\| rc == VERR_PAGE_TABLE_NOT_PRESENT)
1560	{
1561	if (pVirt->aPhysToVirt[iPage].Core.Key != NIL_RTGCPHYS)
1562	{
1563	AssertMsgFailed(("virt handler phys out of sync. %RGp GCPhysNew=~0 iPage=%#x %RGv %s\n",
1564	pVirt->aPhysToVirt[iPage].Core.Key, iPage, GCPtr, R3STRING(pVirt->pszDesc)));
1565	pState->cErrors++;
1566	}
1567	continue;
1568	}
1569
1570	AssertRCReturn(rc, 0);
1571	if ((pVirt->aPhysToVirt[iPage].Core.Key & X86_PTE_PAE_PG_MASK) != GCPhysGst)
1572	{
1573	AssertMsgFailed(("virt handler phys out of sync. %RGp GCPhysGst=%RGp iPage=%#x %RGv %s\n",
1574	pVirt->aPhysToVirt[iPage].Core.Key, GCPhysGst, iPage, GCPtr, R3STRING(pVirt->pszDesc)));
1575	pState->cErrors++;
1576	continue;
1577	}
1578
1579	PPGMPAGE pPage = pgmPhysGetPage(&pVM->pgm.s, GCPhysGst);
1580	if (!pPage)
1581	{
1582	AssertMsgFailed(("virt handler getting ram flags. GCPhysGst=%RGp iPage=%#x %RGv %s\n",
1583	GCPhysGst, iPage, GCPtr, R3STRING(pVirt->pszDesc)));
1584	pState->cErrors++;
1585	continue;
1586	}
1587
1588	if (PGM_PAGE_GET_HNDL_VIRT_STATE(pPage) < uState)
1589	{
1590	AssertMsgFailed(("virt handler state mismatch. pPage=%R[pgmpage] GCPhysGst=%RGp iPage=%#x %RGv state=%d expected>=%d %s\n",
1591	pPage, GCPhysGst, iPage, GCPtr, PGM_PAGE_GET_HNDL_VIRT_STATE(pPage), uState, R3STRING(pVirt->pszDesc)));
1592	pState->cErrors++;
1593	continue;
1594	}
1595	} /* for each VCPU */
1596	} /* for pages in virtual mapping. */
1597
1598	return 0;
1599	}
1600
1601
1602	/**
1603	* Asserts that the handlers+guest-page-tables == ramrange-flags and
1604	* that the physical addresses associated with virtual handlers are correct.
1605	*
1606	* @returns Number of mismatches.
1607	* @param pVM The VM handle.
1608	*/
1609	VMMDECL(unsigned) PGMAssertHandlerAndFlagsInSync(PVM pVM)
1610	{
1611	PPGM pPGM = &pVM->pgm.s;
1612	PGMAHAFIS State;
1613	State.GCPhys = 0;
1614	State.uVirtState = 0;
1615	State.uVirtStateFound = 0;
1616	State.cErrors = 0;
1617	State.pVM = pVM;
1618
1619	Assert(PGMIsLockOwner(pVM));
1620
1621	/*
1622	* Check the RAM flags against the handlers.
1623	*/
1624	for (PPGMRAMRANGE pRam = pPGM->CTX_SUFF(pRamRanges); pRam; pRam = pRam->CTX_SUFF(pNext))
1625	{
1626	const unsigned cPages = pRam->cb >> PAGE_SHIFT;
1627	for (unsigned iPage = 0; iPage < cPages; iPage++)
1628	{
1629	PGMPAGE const *pPage = &pRam->aPages[iPage];
1630	if (PGM_PAGE_HAS_ANY_HANDLERS(pPage))
1631	{
1632	State.GCPhys = pRam->GCPhys + (iPage << PAGE_SHIFT);
1633
1634	/*
1635	* Physical first - calculate the state based on the handlers
1636	* active on the page, then compare.
1637	*/
1638	if (PGM_PAGE_HAS_ANY_PHYSICAL_HANDLERS(pPage))
1639	{
1640	/* the first */
1641	PPGMPHYSHANDLER pPhys = (PPGMPHYSHANDLER)RTAvlroGCPhysRangeGet(&pPGM->CTX_SUFF(pTrees)->PhysHandlers, State.GCPhys);
1642	if (!pPhys)
1643	{
1644	pPhys = (PPGMPHYSHANDLER)RTAvlroGCPhysGetBestFit(&pPGM->CTX_SUFF(pTrees)->PhysHandlers, State.GCPhys, true);
1645	if ( pPhys
1646	&& pPhys->Core.Key > (State.GCPhys + PAGE_SIZE - 1))
1647	pPhys = NULL;
1648	Assert(!pPhys \|\| pPhys->Core.Key >= State.GCPhys);
1649	}
1650	if (pPhys)
1651	{
1652	unsigned uState = pgmHandlerPhysicalCalcState(pPhys);
1653
1654	/* more? */
1655	while (pPhys->Core.KeyLast < (State.GCPhys \| PAGE_OFFSET_MASK))
1656	{
1657	PPGMPHYSHANDLER pPhys2 = (PPGMPHYSHANDLER)RTAvlroGCPhysGetBestFit(&pPGM->CTX_SUFF(pTrees)->PhysHandlers,
1658	pPhys->Core.KeyLast + 1, true);
1659	if ( !pPhys2
1660	\|\| pPhys2->Core.Key > (State.GCPhys \| PAGE_OFFSET_MASK))
1661	break;
1662	unsigned uState2 = pgmHandlerPhysicalCalcState(pPhys2);
1663	uState = RT_MAX(uState, uState2);
1664	pPhys = pPhys2;
1665	}
1666
1667	/* compare.*/
1668	if ( PGM_PAGE_GET_HNDL_PHYS_STATE(pPage) != uState
1669	&& PGM_PAGE_GET_HNDL_PHYS_STATE(pPage) != PGM_PAGE_HNDL_PHYS_STATE_DISABLED)
1670	{
1671	AssertMsgFailed(("ram range vs phys handler flags mismatch. GCPhys=%RGp state=%d expected=%d %s\n",
1672	State.GCPhys, PGM_PAGE_GET_HNDL_PHYS_STATE(pPage), uState, pPhys->pszDesc));
1673	State.cErrors++;
1674	}
1675
1676	#ifdef IN_RING3
1677	/* validate that REM is handling it. */
1678	if ( !REMR3IsPageAccessHandled(pVM, State.GCPhys)
1679	/* ignore shadowed ROM for the time being. */
1680	&& PGM_PAGE_GET_TYPE(pPage) != PGMPAGETYPE_ROM_SHADOW)
1681	{
1682	AssertMsgFailed(("ram range vs phys handler REM mismatch. GCPhys=%RGp state=%d %s\n",
1683	State.GCPhys, PGM_PAGE_GET_HNDL_PHYS_STATE(pPage), pPhys->pszDesc));
1684	State.cErrors++;
1685	}
1686	#endif
1687	}
1688	else
1689	{
1690	AssertMsgFailed(("ram range vs phys handler mismatch. no handler for GCPhys=%RGp\n", State.GCPhys));
1691	State.cErrors++;
1692	}
1693	}
1694
1695	/*
1696	* Virtual handlers.
1697	*/
1698	if (PGM_PAGE_HAS_ACTIVE_VIRTUAL_HANDLERS(pPage))
1699	{
1700	State.uVirtState = PGM_PAGE_GET_HNDL_VIRT_STATE(pPage);
1701	#if 1
1702	/* locate all the matching physical ranges. */
1703	State.uVirtStateFound = PGM_PAGE_HNDL_VIRT_STATE_NONE;
1704	RTGCPHYS GCPhysKey = State.GCPhys;
1705	for (;;)
1706	{
1707	PPGMPHYS2VIRTHANDLER pPhys2Virt = (PPGMPHYS2VIRTHANDLER)RTAvlroGCPhysGetBestFit(&pVM->pgm.s.CTX_SUFF(pTrees)->PhysToVirtHandlers,
1708	GCPhysKey, true /* above-or-equal */);
1709	if ( !pPhys2Virt
1710	\|\| (pPhys2Virt->Core.Key & X86_PTE_PAE_PG_MASK) != State.GCPhys)
1711	break;
1712
1713	/* the head */
1714	GCPhysKey = pPhys2Virt->Core.KeyLast;
1715	PPGMVIRTHANDLER pCur = (PPGMVIRTHANDLER)((uintptr_t)pPhys2Virt + pPhys2Virt->offVirtHandler);
1716	unsigned uState = pgmHandlerVirtualCalcState(pCur);
1717	State.uVirtStateFound = RT_MAX(State.uVirtStateFound, uState);
1718
1719	/* any aliases */
1720	while (pPhys2Virt->offNextAlias & PGMPHYS2VIRTHANDLER_OFF_MASK)
1721	{
1722	pPhys2Virt = (PPGMPHYS2VIRTHANDLER)((uintptr_t)pPhys2Virt + (pPhys2Virt->offNextAlias & PGMPHYS2VIRTHANDLER_OFF_MASK));
1723	pCur = (PPGMVIRTHANDLER)((uintptr_t)pPhys2Virt + pPhys2Virt->offVirtHandler);
1724	uState = pgmHandlerVirtualCalcState(pCur);
1725	State.uVirtStateFound = RT_MAX(State.uVirtStateFound, uState);
1726	}
1727
1728	/* done? */
1729	if ((GCPhysKey & X86_PTE_PAE_PG_MASK) != State.GCPhys)
1730	break;
1731	}
1732	#else
1733	/* very slow */
1734	RTAvlroGCPtrDoWithAll(&pVM->pgm.s.CTX_SUFF(pTrees)->VirtHandlers, true, pgmHandlerVirtualVerifyOneByPhysAddr, &State);
1735	#endif
1736	if (State.uVirtState != State.uVirtStateFound)
1737	{
1738	AssertMsgFailed(("ram range vs virt handler flags mismatch. GCPhys=%RGp uVirtState=%#x uVirtStateFound=%#x\n",
1739	State.GCPhys, State.uVirtState, State.uVirtStateFound));
1740	State.cErrors++;
1741	}
1742	}
1743	}
1744	} /* foreach page in ram range. */
1745	} /* foreach ram range. */
1746
1747	/*
1748	* Check that the physical addresses of the virtual handlers matches up
1749	* and that they are otherwise sane.
1750	*/
1751	RTAvlroGCPtrDoWithAll(&pVM->pgm.s.CTX_SUFF(pTrees)->VirtHandlers, true, pgmHandlerVirtualVerifyOne, &State);
1752
1753	/*
1754	* Do the reverse check for physical handlers.
1755	*/
1756	/** @todo */
1757
1758	return State.cErrors;
1759	}
1760
1761	#endif /* VBOX_STRICT */
1762

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

source: vbox/trunk/src/VBox/VMM/VMMAll/PGMAllHandler.cpp@ 27778

Download in other formats: