PGMAllHandler.cpp@ 4284

Last change on this file since 4284 was 4071, checked in by vboxsync, 17 years ago
Biggest check-in ever. New source code headers for all (C) innotek files.
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 40.0 KB

Line
1	/* $Id: PGMAllHandler.cpp 4071 2007-08-07 17:07:59Z vboxsync $ */
2	/** @file
3	* PGM - Page Manager / Monitor, Access Handlers.
4	*/
5
6	/*
7	* Copyright (C) 2006-2007 innotek GmbH
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 as published by the Free Software Foundation,
13	* in version 2 as it comes in the "COPYING" file of the VirtualBox OSE
14	* distribution. VirtualBox OSE is distributed in the hope that it will
15	* be useful, but WITHOUT ANY WARRANTY of any kind.
16	*/
17
18
19	/*******************************************************************************
20	* Header Files *
21	*******************************************************************************/
22	#define LOG_GROUP LOG_GROUP_PGM
23	#include <VBox/dbgf.h>
24	#include <VBox/pgm.h>
25	#include <VBox/iom.h>
26	#include <VBox/mm.h>
27	#include <VBox/em.h>
28	#include <VBox/stam.h>
29	#include <VBox/rem.h>
30	#include <VBox/dbgf.h>
31	#include <VBox/rem.h>
32	#include "PGMInternal.h"
33	#include <VBox/vm.h>
34
35	#include <VBox/log.h>
36	#include <iprt/assert.h>
37	#include <iprt/asm.h>
38	#include <iprt/string.h>
39	#include <VBox/param.h>
40	#include <VBox/err.h>
41	#include <VBox/selm.h>
42
43
44	/*******************************************************************************
45	* Internal Functions *
46	*******************************************************************************/
47	DECLINLINE(unsigned) pgmHandlerPhysicalCalcFlags(PPGMPHYSHANDLER pCur);
48	static int pgmHandlerPhysicalSetRamFlagsAndFlushShadowPTs(PVM pVM, PPGMPHYSHANDLER pCur, PPGMRAMRANGE pRam);
49	static void pgmHandlerPhysicalDeregisterNotifyREM(PVM pVM, PPGMPHYSHANDLER pCur);
50	static void pgmHandlerPhysicalResetRamFlags(PVM pVM, PPGMPHYSHANDLER pCur);
51
52
53
54	/**
55	* Register a access handler for a physical range.
56	*
57	* @returns VBox status code.
58	* @retval VINF_SUCCESS when successfully installed.
59	* @retval VINF_PGM_GCPHYS_ALIASED when the shadow PTs could be updated because
60	* the guest page aliased or/and mapped by multiple PTs. A CR3 sync has been
61	* flagged together with a pool clearing.
62	* @retval VERR_PGM_HANDLER_PHYSICAL_CONFLICT if the range conflicts with an existing
63	* one. A debug assertion is raised.
64	*
65	* @param pVM VM Handle.
66	* @param enmType Handler type. Any of the PGMPHYSHANDLERTYPE_PHYSICAL* enums.
67	* @param GCPhys Start physical address.
68	* @param GCPhysLast Last physical address. (inclusive)
69	* @param pfnHandlerR3 The R3 handler.
70	* @param pvUserR3 User argument to the R3 handler.
71	* @param pfnHandlerR0 The R0 handler.
72	* @param pvUserR0 User argument to the R0 handler.
73	* @param pfnHandlerGC The GC handler.
74	* @param pvUserGC User argument to the GC handler.
75	* This must be a GC pointer because it will be relocated!
76	* @param pszDesc Pointer to description string. This must not be freed.
77	*/
78	PGMDECL(int) PGMHandlerPhysicalRegisterEx(PVM pVM, PGMPHYSHANDLERTYPE enmType, RTGCPHYS GCPhys, RTGCPHYS GCPhysLast,
79	R3PTRTYPE(PFNPGMR3PHYSHANDLER) pfnHandlerR3, RTR3PTR pvUserR3,
80	R0PTRTYPE(PFNPGMR0PHYSHANDLER) pfnHandlerR0, RTR0PTR pvUserR0,
81	GCPTRTYPE(PFNPGMGCPHYSHANDLER) pfnHandlerGC, RTGCPTR pvUserGC,
82	R3PTRTYPE(const char *) pszDesc)
83	{
84	Log(("PGMHandlerPhysicalRegisterEx: enmType=%d GCPhys=%VGp GCPhysLast=%VGp pfnHandlerR3=%VHv pvUserR3=%VHv pfnHandlerR0=%VHv pvUserR0=%VHv pfnHandlerGC=%VGv pvUserGC=%VGv pszDesc=%s\n",
85	enmType, GCPhys, GCPhysLast, pfnHandlerR3, pvUserR3, pfnHandlerR0, pvUserR0, pfnHandlerGC, pvUserGC, HCSTRING(pszDesc)));
86
87	/*
88	* Validate input.
89	*/
90	if (GCPhys >= GCPhysLast)
91	{
92	AssertMsgFailed(("GCPhys >= GCPhysLast (%#x >= %#x)\n", GCPhys, GCPhysLast));
93	return VERR_INVALID_PARAMETER;
94	}
95	switch (enmType)
96	{
97	case PGMPHYSHANDLERTYPE_MMIO:
98	case PGMPHYSHANDLERTYPE_PHYSICAL:
99	case PGMPHYSHANDLERTYPE_PHYSICAL_WRITE:
100	case PGMPHYSHANDLERTYPE_PHYSICAL_ALL:
101	break;
102	default:
103	AssertMsgFailed(("Invalid input enmType=%d!\n", enmType));
104	return VERR_INVALID_PARAMETER;
105	}
106	if ( (RTGCUINTPTR)pvUserGC >= 0x10000
107	&& MMHyperHC2GC(pVM, MMHyperGC2HC(pVM, pvUserGC)) != pvUserGC)
108	{
109	AssertMsgFailed(("Not GC pointer! pvUserGC=%VGv\n", pvUserGC));
110	return VERR_INVALID_PARAMETER;
111	}
112	AssertReturn(pfnHandlerR3 \|\| pfnHandlerR0 \|\| pfnHandlerGC, VERR_INVALID_PARAMETER);
113
114	/*
115	* We require the range to be within registered ram.
116	* There is no apparent need to support ranges which cover more than one ram range.
117	*/
118	PPGMRAMRANGE pRam = CTXSUFF(pVM->pgm.s.pRamRanges);
119	while (pRam && GCPhys > pRam->GCPhysLast)
120	pRam = CTXSUFF(pRam->pNext);
121	if ( !pRam
122	\|\| GCPhysLast < pRam->GCPhys
123	\|\| GCPhys > pRam->GCPhysLast)
124	{
125	#ifdef IN_RING3
126	/*
127	* If this is an MMIO registration, we'll just add a range for it.
128	*/
129	if ( enmType == PGMPHYSHANDLERTYPE_MMIO
130	&& ( !pRam
131	\|\| GCPhysLast < pRam->GCPhys)
132	)
133	{
134	size_t cb = GCPhysLast - GCPhys + 1;
135	Assert(cb == RT_ALIGN_Z(cb, PAGE_SIZE));
136	int rc = PGMR3PhysRegister(pVM, NULL, GCPhys, cb, MM_RAM_FLAGS_RESERVED \| MM_RAM_FLAGS_MMIO, NULL, pszDesc);
137	if (VBOX_FAILURE(rc))
138	return rc;
139
140	/* search again. */
141	pRam = CTXSUFF(pVM->pgm.s.pRamRanges);
142	while (pRam && GCPhys > pRam->GCPhysLast)
143	pRam = CTXSUFF(pRam->pNext);
144	}
145
146	if ( !pRam
147	\|\| GCPhysLast < pRam->GCPhys
148	\|\| GCPhys > pRam->GCPhysLast)
149	#endif /* IN_RING3 */
150	{
151	#ifdef IN_RING3
152	DBGFR3Info(pVM, "phys", NULL, NULL);
153	#endif
154	AssertMsgFailed(("No RAM range for %VGp-%VGp\n", GCPhys, GCPhysLast));
155	return VERR_PGM_HANDLER_PHYSICAL_NO_RAM_RANGE;
156	}
157	}
158
159	/*
160	* Allocate and initialize the new entry.
161	*/
162	PPGMPHYSHANDLER pNew;
163	int rc = MMHyperAlloc(pVM, sizeof(pNew), 0, MM_TAG_PGM_HANDLERS, (void *)&pNew);
164	if (VBOX_FAILURE(rc))
165	return rc;
166
167	pNew->Core.Key = GCPhys;
168	pNew->Core.KeyLast = GCPhysLast;
169	pNew->enmType = enmType;
170	pNew->cPages = (GCPhysLast - (GCPhys & X86_PTE_PAE_PG_MASK) + PAGE_SIZE) >> PAGE_SHIFT;
171	pNew->pfnHandlerR3 = pfnHandlerR3;
172	pNew->pvUserR3 = pvUserR3;
173	pNew->pfnHandlerR0 = pfnHandlerR0;
174	pNew->pvUserR0 = pvUserR0;
175	pNew->pfnHandlerGC = pfnHandlerGC;
176	pNew->pvUserGC = pvUserGC;
177	pNew->pszDesc = pszDesc;
178
179	pgmLock(pVM);
180
181	/*
182	* Try insert into list.
183	*/
184	if (RTAvlroGCPhysInsert(&pVM->pgm.s.CTXSUFF(pTrees)->PhysHandlers, &pNew->Core))
185	{
186	rc = pgmHandlerPhysicalSetRamFlagsAndFlushShadowPTs(pVM, pNew, pRam);
187	if (rc == VINF_PGM_GCPHYS_ALIASED)
188	{
189	pVM->pgm.s.fSyncFlags \|= PGM_SYNC_CLEAR_PGM_POOL;
190	VM_FF_SET(pVM, VM_FF_PGM_SYNC_CR3);
191	}
192	pVM->pgm.s.fPhysCacheFlushPending = true;
193	#ifndef IN_RING3
194	REMNotifyHandlerPhysicalRegister(pVM, enmType, GCPhys, GCPhysLast - GCPhys + 1, !!pfnHandlerR3);
195	#else
196	REMR3NotifyHandlerPhysicalRegister(pVM, enmType, GCPhys, GCPhysLast - GCPhys + 1, !!pfnHandlerR3);
197	#endif
198	pgmUnlock(pVM);
199	if (rc != VINF_SUCCESS)
200	Log(("PGMHandlerPhysicalRegisterEx: returns %Vrc (%VGp-%VGp)\n", rc, GCPhys, GCPhysLast));
201	return rc;
202	}
203	pgmUnlock(pVM);
204
205	#if defined(IN_RING3) && defined(VBOX_STRICT)
206	DBGFR3Info(pVM, "handlers", "phys nostats", NULL);
207	#endif
208	AssertMsgFailed(("Conflict! GCPhys=%VGp GCPhysLast=%VGp pszDesc=%s\n", GCPhys, GCPhysLast, pszDesc));
209	MMHyperFree(pVM, pNew);
210	return VERR_PGM_HANDLER_PHYSICAL_CONFLICT;
211	}
212
213
214	/**
215	* Sets ram range flags and attempts updating shadow PTs.
216	*
217	* @returns VBox status code.
218	* @retval VINF_SUCCESS when shadow PTs was successfully updated.
219	* @retval VINF_PGM_GCPHYS_ALIASED when the shadow PTs could be updated because
220	* the guest page aliased or/and mapped by multiple PTs.
221	* @param pVM The VM handle.
222	* @param pCur The physical handler.
223	*/
224	static int pgmHandlerPhysicalSetRamFlagsAndFlushShadowPTs(PVM pVM, PPGMPHYSHANDLER pCur, PPGMRAMRANGE pRam)
225	{
226	/*
227	* Iterate the guest ram pages updating the flags and flushing PT entries
228	* mapping the page.
229	*/
230	bool fFlushTLBs = false;
231	#if defined(PGMPOOL_WITH_GCPHYS_TRACKING) \|\| defined(PGMPOOL_WITH_CACHE)
232	int rc = VINF_SUCCESS;
233	#else
234	const int rc = VINF_PGM_GCPHYS_ALIASED;
235	#endif
236	const unsigned fFlags = pgmHandlerPhysicalCalcFlags(pCur); Assert(!(fFlags & X86_PTE_PAE_PG_MASK));
237	RTUINT cPages = pCur->cPages;
238	RTUINT i = (pCur->Core.Key - pRam->GCPhys) >> PAGE_SHIFT;
239	for (;;)
240	{
241	/* Physical chunk in dynamically allocated range not present? */
242	if (RT_UNLIKELY(!(pRam->aHCPhys[i] & X86_PTE_PAE_PG_MASK)))
243	{
244	RTGCPHYS GCPhys = pRam->GCPhys + (i << PAGE_SHIFT);
245	#ifdef IN_RING3
246	int rc2 = pgmr3PhysGrowRange(pVM, GCPhys);
247	#else
248	int rc2 = CTXALLMID(VMM, CallHost)(pVM, VMMCALLHOST_PGM_RAM_GROW_RANGE, GCPhys);
249	#endif
250	if (rc2 != VINF_SUCCESS)
251	return rc2;
252	}
253
254	if ((pRam->aHCPhys[i] & fFlags) != fFlags)
255	{
256	pRam->aHCPhys[i] \|= fFlags;
257
258	Assert(pRam->aHCPhys[i] & X86_PTE_PAE_PG_MASK);
259
260	#ifdef PGMPOOL_WITH_GCPHYS_TRACKING
261	/* This code also makes ASSUMPTIONS about the cRefs and stuff. */
262	Assert(MM_RAM_FLAGS_IDX_SHIFT < MM_RAM_FLAGS_CREFS_SHIFT);
263	const uint16_t u16 = pRam->aHCPhys[i] >> MM_RAM_FLAGS_IDX_SHIFT;
264	if (u16)
265	{
266	if ((u16 >> (MM_RAM_FLAGS_CREFS_SHIFT - MM_RAM_FLAGS_IDX_SHIFT)) != MM_RAM_FLAGS_CREFS_PHYSEXT)
267	pgmPoolTrackFlushGCPhysPT(pVM,
268	&pRam->aHCPhys[i],
269	u16 & MM_RAM_FLAGS_IDX_MASK,
270	u16 >> (MM_RAM_FLAGS_CREFS_SHIFT - MM_RAM_FLAGS_IDX_SHIFT));
271	else if (u16 != ((MM_RAM_FLAGS_CREFS_PHYSEXT << (MM_RAM_FLAGS_CREFS_SHIFT - MM_RAM_FLAGS_IDX_SHIFT)) \| MM_RAM_FLAGS_IDX_OVERFLOWED))
272	pgmPoolTrackFlushGCPhysPTs(pVM, &pRam->aHCPhys[i], u16 & MM_RAM_FLAGS_IDX_MASK);
273	else
274	rc = pgmPoolTrackFlushGCPhysPTsSlow(pVM, &pRam->aHCPhys[i]);
275	fFlushTLBs = true;
276	}
277	#elif defined(PGMPOOL_WITH_CACHE)
278	rc = pgmPoolTrackFlushGCPhysPTsSlow(pVM, &pRam->aHCPhys[i]);
279	fFlushTLBs = true;
280	#endif
281	}
282
283	/* next */
284	if (--cPages == 0)
285	break;
286	i++;
287	}
288
289	if (fFlushTLBs && rc == VINF_SUCCESS)
290	{
291	PGM_INVL_GUEST_TLBS();
292	Log(("pgmHandlerPhysicalSetRamFlagsAndFlushShadowPTs: flushing guest TLBs\n"));
293	}
294	else
295	Log(("pgmHandlerPhysicalSetRamFlagsAndFlushShadowPTs: doesn't flush guest TLBs. rc=%Vrc\n", rc));
296	return rc;
297	}
298
299
300	/**
301	* Register a physical page access handler.
302	*
303	* @returns VBox status code.
304	* @param pVM VM Handle.
305	* @param GCPhys Start physical address.
306	*/
307	PGMDECL(int) PGMHandlerPhysicalDeregister(PVM pVM, RTGCPHYS GCPhys)
308	{
309	/*
310	* Find the handler.
311	*/
312	pgmLock(pVM);
313	PPGMPHYSHANDLER pCur = (PPGMPHYSHANDLER)RTAvlroGCPhysRemove(&pVM->pgm.s.CTXSUFF(pTrees)->PhysHandlers, GCPhys);
314	if (pCur)
315	{
316	LogFlow(("PGMHandlerPhysicalDeregister: Removing Range %#VGp-%#VGp %s\n",
317	pCur->Core.Key, pCur->Core.KeyLast, HCSTRING(pCur->pszDesc)));
318
319	/*
320	* Clear the page bits and notify the REM about this change.
321	*/
322	pgmHandlerPhysicalResetRamFlags(pVM, pCur);
323	pgmHandlerPhysicalDeregisterNotifyREM(pVM, pCur);
324	pgmUnlock(pVM);
325	MMHyperFree(pVM, pCur);
326	return VINF_SUCCESS;
327	}
328	pgmUnlock(pVM);
329
330	AssertMsgFailed(("Didn't find range starting at %VGp\n", GCPhys));
331	return VERR_PGM_HANDLER_NOT_FOUND;
332	}
333
334
335	/**
336	* Shared code with modify.
337	*/
338	static void pgmHandlerPhysicalDeregisterNotifyREM(PVM pVM, PPGMPHYSHANDLER pCur)
339	{
340	RTGCPHYS GCPhysStart = pCur->Core.Key;
341	RTGCPHYS GCPhysLast = pCur->Core.KeyLast;
342
343	/*
344	* Page align the range.
345	*/
346	if ( (pCur->Core.Key & PAGE_OFFSET_MASK)
347	\|\| ((pCur->Core.KeyLast + 1) & PAGE_OFFSET_MASK))
348	{
349	if (GCPhysStart & PAGE_OFFSET_MASK)
350	{
351	if (PGMRamTestFlags(&pVM->pgm.s, GCPhysStart, MM_RAM_FLAGS_MMIO \| MM_RAM_FLAGS_PHYSICAL_HANDLER \| MM_RAM_FLAGS_PHYSICAL_ALL \| MM_RAM_FLAGS_PHYSICAL_WRITE \| MM_RAM_FLAGS_PHYSICAL_TEMP_OFF))
352	{
353	RTGCPHYS GCPhys = (GCPhysStart + (PAGE_SIZE - 1)) & X86_PTE_PAE_PG_MASK;
354	if ( GCPhys > GCPhysLast
355	\|\| GCPhys < GCPhysStart)
356	return;
357	GCPhysStart = GCPhys;
358	}
359	else
360	GCPhysStart = GCPhysStart & X86_PTE_PAE_PG_MASK;
361	}
362	if (GCPhysLast & PAGE_OFFSET_MASK)
363	{
364	if (PGMRamTestFlags(&pVM->pgm.s, GCPhysLast, MM_RAM_FLAGS_MMIO \| MM_RAM_FLAGS_PHYSICAL_HANDLER \| MM_RAM_FLAGS_PHYSICAL_ALL \| MM_RAM_FLAGS_PHYSICAL_WRITE \| MM_RAM_FLAGS_PHYSICAL_TEMP_OFF))
365	{
366	RTGCPHYS GCPhys = (GCPhysStart & X86_PTE_PAE_PG_MASK) - 1;
367	if ( GCPhys < GCPhysStart
368	\|\| GCPhys > GCPhysLast)
369	return;
370	GCPhysLast = GCPhys;
371	}
372	else
373	GCPhysLast += PAGE_SIZE - 1 - (GCPhysLast & PAGE_OFFSET_MASK);
374	}
375	}
376
377	/*
378	* Tell REM.
379	*/
380	RTHCPTR pvRange = 0;
381	if (pCur->pfnHandlerR3 && pCur->enmType != PGMPHYSHANDLERTYPE_MMIO)
382	PGMRamGCPhys2HCPtr(&pVM->pgm.s, GCPhysStart, &pvRange); /* ASSUMES it doesn't change pvRange on failure. */
383	#ifndef IN_RING3
384	REMNotifyHandlerPhysicalDeregister(pVM, pCur->enmType, GCPhysStart, GCPhysLast - GCPhysStart + 1, !!pCur->pfnHandlerR3, pvRange);
385	#else
386	REMR3NotifyHandlerPhysicalDeregister(pVM, pCur->enmType, GCPhysStart, GCPhysLast - GCPhysStart + 1, !!pCur->pfnHandlerR3, pvRange);
387	#endif
388	}
389
390
391	/**
392	* Resets ram range flags.
393	*
394	* @returns VBox status code.
395	* @retval VINF_SUCCESS when shadow PTs was successfully updated.
396	* @param pVM The VM handle.
397	* @param pCur The physical handler.
398	*
399	* @remark We don't start messing with the shadow page tables, as we've already got code
400	* in Trap0e which deals with out of sync handler flags (originally conceived for
401	* global pages).
402	*/
403	static void pgmHandlerPhysicalResetRamFlags(PVM pVM, PPGMPHYSHANDLER pCur)
404	{
405	/*
406	* Iterate the guest ram pages updating the flags and flushing PT entries
407	* mapping the page.
408	*/
409	RTUINT cPages = pCur->cPages;
410	RTGCPHYS GCPhys = pCur->Core.Key;
411	PPGMRAMRANGE pRamHint = NULL;
412	PPGM pPGM = &pVM->pgm.s;
413	for (;;)
414	{
415	PGMRamFlagsClearByGCPhysWithHint(pPGM, GCPhys,
416	MM_RAM_FLAGS_PHYSICAL_HANDLER \| MM_RAM_FLAGS_PHYSICAL_WRITE \| MM_RAM_FLAGS_PHYSICAL_ALL,
417	&pRamHint);
418	/* next */
419	if (--cPages == 0)
420	break;
421	GCPhys += PAGE_SIZE;
422	}
423
424	/*
425	* Check for partial start page.
426	*/
427	if (pCur->Core.Key & PAGE_OFFSET_MASK)
428	{
429	RTGCPHYS GCPhys = pCur->Core.Key - 1;
430	for (;;)
431	{
432	PPGMPHYSHANDLER pBelow = (PPGMPHYSHANDLER)RTAvlroGCPhysGetBestFit(&pVM->pgm.s.CTXSUFF(pTrees)->PhysHandlers, GCPhys, false);
433	if ( !pBelow
434	\|\| (pBelow->Core.KeyLast >> PAGE_SHIFT) != (pCur->Core.Key >> PAGE_SHIFT))
435	break;
436	PGMRamFlagsSetByGCPhysWithHint(pPGM, GCPhys, pgmHandlerPhysicalCalcFlags(pCur), &pRamHint);
437
438	/* next? */
439	if ( (pBelow->Core.Key >> PAGE_SHIFT) != (pCur->Core.Key >> PAGE_SHIFT)
440	\|\| !(pBelow->Core.Key & PAGE_OFFSET_MASK))
441	break;
442	GCPhys = pBelow->Core.Key - 1;
443	}
444	}
445
446	/*
447	* Check for partial end page.
448	*/
449	if ((pCur->Core.KeyLast & PAGE_OFFSET_MASK) != PAGE_SIZE - 1)
450	{
451	RTGCPHYS GCPhys = pCur->Core.KeyLast + 1;
452	for (;;)
453	{
454	PPGMPHYSHANDLER pAbove = (PPGMPHYSHANDLER)RTAvlroGCPhysGetBestFit(&pVM->pgm.s.CTXSUFF(pTrees)->PhysHandlers, GCPhys, true);
455	if ( !pAbove
456	\|\| (pAbove->Core.Key >> PAGE_SHIFT) != (pCur->Core.KeyLast >> PAGE_SHIFT))
457	break;
458	PGMRamFlagsSetByGCPhysWithHint(pPGM, GCPhys, pgmHandlerPhysicalCalcFlags(pCur), &pRamHint);
459
460	/* next? */
461	if ( (pAbove->Core.KeyLast >> PAGE_SHIFT) != (pCur->Core.KeyLast >> PAGE_SHIFT)
462	\|\| (pAbove->Core.KeyLast & PAGE_OFFSET_MASK) == PAGE_SIZE - 1)
463	break;
464	GCPhys = pAbove->Core.KeyLast + 1;
465	}
466	}
467	}
468
469
470	/**
471	* Modify a physical page access handler.
472	*
473	* Modification can only be done to the range it self, not the type or anything else.
474	*
475	* @returns VBox status code.
476	* For all return codes other than VERR_PGM_HANDLER_NOT_FOUND and VINF_SUCCESS the range is deregistered
477	* and a new registration must be performed!
478	* @param pVM VM handle.
479	* @param GCPhysCurrent Current location.
480	* @param GCPhys New location.
481	* @param GCPhysLast New last location.
482	*/
483	PGMDECL(int) PGMHandlerPhysicalModify(PVM pVM, RTGCPHYS GCPhysCurrent, RTGCPHYS GCPhys, RTGCPHYS GCPhysLast)
484	{
485	/*
486	* Remove it.
487	*/
488	int rc;
489	pgmLock(pVM);
490	PPGMPHYSHANDLER pCur = (PPGMPHYSHANDLER)RTAvlroGCPhysRemove(&pVM->pgm.s.CTXSUFF(pTrees)->PhysHandlers, GCPhysCurrent);
491	if (pCur)
492	{
493	/*
494	* Clear the ram flags. (We're gonna move or free it!)
495	*/
496	pgmHandlerPhysicalResetRamFlags(pVM, pCur);
497	RTHCPTR pvRange = 0;
498	if (pCur->pfnHandlerR3 && pCur->enmType != PGMPHYSHANDLERTYPE_MMIO)
499	PGMRamGCPhys2HCPtr(&pVM->pgm.s, GCPhysCurrent, &pvRange); /* ASSUMES it doesn't change pvRange on failure. */
500
501	/*
502	* Validate the new range, modify and reinsert.
503	*/
504	if (GCPhysLast >= GCPhys)
505	{
506	/*
507	* We require the range to be within registered ram.
508	* There is no apparent need to support ranges which cover more than one ram range.
509	*/
510	PPGMRAMRANGE pRam = CTXSUFF(pVM->pgm.s.pRamRanges);
511	while (pRam && GCPhys > pRam->GCPhysLast)
512	pRam = CTXSUFF(pRam->pNext);
513	if ( pRam
514	&& GCPhys <= pRam->GCPhysLast
515	&& GCPhysLast >= pRam->GCPhys)
516	{
517	pCur->Core.Key = GCPhys;
518	pCur->Core.KeyLast = GCPhysLast;
519	pCur->cPages = (GCPhysLast - (GCPhys & X86_PTE_PAE_PG_MASK) + 1) >> PAGE_SHIFT;
520
521	if (RTAvlroGCPhysInsert(&pVM->pgm.s.CTXSUFF(pTrees)->PhysHandlers, &pCur->Core))
522	{
523	/*
524	* Set ram flags, flush shadow PT entries and finally tell REM about this.
525	*/
526	rc = pgmHandlerPhysicalSetRamFlagsAndFlushShadowPTs(pVM, pCur, pRam);
527	if (rc == VINF_PGM_GCPHYS_ALIASED)
528	{
529	pVM->pgm.s.fSyncFlags \|= PGM_SYNC_CLEAR_PGM_POOL;
530	VM_FF_SET(pVM, VM_FF_PGM_SYNC_CR3);
531	}
532	pVM->pgm.s.fPhysCacheFlushPending = true;
533
534	#ifndef IN_RING3
535	REMNotifyHandlerPhysicalModify(pVM, pCur->enmType, GCPhysCurrent, GCPhys,
536	pCur->Core.KeyLast - GCPhys + 1, !!pCur->pfnHandlerR3, pvRange);
537	#else
538	REMR3NotifyHandlerPhysicalModify(pVM, pCur->enmType, GCPhysCurrent, GCPhys,
539	pCur->Core.KeyLast - GCPhys + 1, !!pCur->pfnHandlerR3, pvRange);
540	#endif
541	pgmUnlock(pVM);
542	Log(("PGMHandlerPhysicalModify: GCPhysCurrent=%VGp -> GCPhys=%VGp GCPhysLast=%VGp\n",
543	GCPhysCurrent, GCPhys, GCPhysLast));
544	return VINF_SUCCESS;
545	}
546	AssertMsgFailed(("Conflict! GCPhys=%VGp GCPhysLast=%VGp\n", GCPhys, GCPhysLast));
547	rc = VERR_PGM_HANDLER_PHYSICAL_CONFLICT;
548	}
549	else
550	{
551	AssertMsgFailed(("No RAM range for %VGp-%VGp\n", GCPhys, GCPhysLast));
552	rc = VERR_PGM_HANDLER_PHYSICAL_NO_RAM_RANGE;
553	}
554	}
555	else
556	{
557	AssertMsgFailed(("Invalid range %VGp-%VGp\n", GCPhys, GCPhysLast));
558	rc = VERR_INVALID_PARAMETER;
559	}
560
561	/*
562	* Invalid new location, free it.
563	* We've only gotta notify REM and free the memory.
564	*/
565	pgmHandlerPhysicalDeregisterNotifyREM(pVM, pCur);
566	MMHyperFree(pVM, pCur);
567	}
568	else
569	{
570	AssertMsgFailed(("Didn't find range starting at %VGp\n", GCPhysCurrent));
571	rc = VERR_PGM_HANDLER_NOT_FOUND;
572	}
573
574	pgmUnlock(pVM);
575	return rc;
576	}
577
578
579	/**
580	* Changes the callbacks associated with a physical access handler.
581	*
582	* @returns VBox status code.
583	* @param pVM VM Handle.
584	* @param GCPhys Start physical address.
585	* @param pfnHandlerR3 The R3 handler.
586	* @param pvUserR3 User argument to the R3 handler.
587	* @param pfnHandlerR0 The R0 handler.
588	* @param pvUserR0 User argument to the R0 handler.
589	* @param pfnHandlerGC The GC handler.
590	* @param pvUserGC User argument to the GC handler.
591	* This must be a GC pointer because it will be relocated!
592	* @param pszDesc Pointer to description string. This must not be freed.
593	*/
594	PGMDECL(int) PGMHandlerPhysicalChangeCallbacks(PVM pVM, RTGCPHYS GCPhys,
595	R3PTRTYPE(PFNPGMR3PHYSHANDLER) pfnHandlerR3, RTR3PTR pvUserR3,
596	R0PTRTYPE(PFNPGMR0PHYSHANDLER) pfnHandlerR0, RTR0PTR pvUserR0,
597	GCPTRTYPE(PFNPGMGCPHYSHANDLER) pfnHandlerGC, RTGCPTR pvUserGC,
598	R3PTRTYPE(const char *) pszDesc)
599	{
600	/*
601	* Get the handler.
602	*/
603	int rc = VINF_SUCCESS;
604	pgmLock(pVM);
605	PPGMPHYSHANDLER pCur = (PPGMPHYSHANDLER)RTAvlroGCPhysGet(&pVM->pgm.s.CTXSUFF(pTrees)->PhysHandlers, GCPhys);
606	if (pCur)
607	{
608	/*
609	* Change callbacks.
610	*/
611	pCur->pfnHandlerR3 = pfnHandlerR3;
612	pCur->pvUserR3 = pvUserR3;
613	pCur->pfnHandlerR0 = pfnHandlerR0;
614	pCur->pvUserR0 = pvUserR0;
615	pCur->pfnHandlerGC = pfnHandlerGC;
616	pCur->pvUserGC = pvUserGC;
617	pCur->pszDesc = pszDesc;
618	}
619	else
620	{
621	AssertMsgFailed(("Didn't find range starting at %VGp\n", GCPhys));
622	rc = VERR_PGM_HANDLER_NOT_FOUND;
623	}
624
625	pgmUnlock(pVM);
626	return rc;
627	}
628
629
630	/**
631	* Splitts a physical access handler in two.
632	*
633	* @returns VBox status code.
634	* @param pVM VM Handle.
635	* @param GCPhys Start physical address of the handler.
636	* @param GCPhysSplit The split address.
637	*/
638	PGMDECL(int) PGMHandlerPhysicalSplit(PVM pVM, RTGCPHYS GCPhys, RTGCPHYS GCPhysSplit)
639	{
640	AssertReturn(GCPhys < GCPhysSplit, VERR_INVALID_PARAMETER);
641
642	/*
643	* Do the allocation without owning the lock.
644	*/
645	PPGMPHYSHANDLER pNew;
646	int rc = MMHyperAlloc(pVM, sizeof(pNew), 0, MM_TAG_PGM_HANDLERS, (void *)&pNew);
647	if (VBOX_FAILURE(rc))
648	return rc;
649
650	/*
651	* Get the handler.
652	*/
653	pgmLock(pVM);
654	PPGMPHYSHANDLER pCur = (PPGMPHYSHANDLER)RTAvlroGCPhysGet(&pVM->pgm.s.CTXSUFF(pTrees)->PhysHandlers, GCPhys);
655	if (pCur)
656	{
657	if (GCPhysSplit <= pCur->Core.KeyLast)
658	{
659	/*
660	* Create new handler node for the 2nd half.
661	*/
662	pNew = pCur;
663	pNew->Core.Key = GCPhysSplit;
664	pNew->cPages = (pNew->Core.KeyLast - (pNew->Core.Key & X86_PTE_PAE_PG_MASK) + PAGE_SIZE) >> PAGE_SHIFT;
665
666	pCur->Core.KeyLast = GCPhysSplit - 1;
667	pCur->cPages = (pCur->Core.KeyLast - (pCur->Core.Key & X86_PTE_PAE_PG_MASK) + PAGE_SIZE) >> PAGE_SHIFT;
668
669	if (RTAvlroGCPhysInsert(&pVM->pgm.s.CTXSUFF(pTrees)->PhysHandlers, &pNew->Core))
670	{
671	LogFlow(("PGMHandlerPhysicalSplit: %VGp-%VGp and %VGp-%VGp\n",
672	pCur->Core.Key, pCur->Core.KeyLast, pNew->Core.Key, pNew->Core.KeyLast));
673	pgmUnlock(pVM);
674	return VINF_SUCCESS;
675	}
676	AssertMsgFailed(("whu?\n"));
677	rc = VERR_INTERNAL_ERROR;
678	}
679	else
680	{
681	AssertMsgFailed(("outside range: %VGp-%VGp split %VGp\n", pCur->Core.Key, pCur->Core.KeyLast, GCPhysSplit));
682	rc = VERR_INVALID_PARAMETER;
683	}
684	}
685	else
686	{
687	AssertMsgFailed(("Didn't find range starting at %VGp\n", GCPhys));
688	rc = VERR_PGM_HANDLER_NOT_FOUND;
689	}
690	pgmUnlock(pVM);
691	MMHyperFree(pVM, pNew);
692	return rc;
693	}
694
695
696	/**
697	* Joins up two adjacent physical access handlers which has the same callbacks.
698	*
699	* @returns VBox status code.
700	* @param pVM VM Handle.
701	* @param GCPhys1 Start physical address of the first handler.
702	* @param GCPhys2 Start physical address of the second handler.
703	*/
704	PGMDECL(int) PGMHandlerPhysicalJoin(PVM pVM, RTGCPHYS GCPhys1, RTGCPHYS GCPhys2)
705	{
706	/*
707	* Get the handlers.
708	*/
709	int rc;
710	pgmLock(pVM);
711	PPGMPHYSHANDLER pCur1 = (PPGMPHYSHANDLER)RTAvlroGCPhysGet(&pVM->pgm.s.CTXSUFF(pTrees)->PhysHandlers, GCPhys1);
712	if (pCur1)
713	{
714	PPGMPHYSHANDLER pCur2 = (PPGMPHYSHANDLER)RTAvlroGCPhysGet(&pVM->pgm.s.CTXSUFF(pTrees)->PhysHandlers, GCPhys2);
715	if (pCur2)
716	{
717	/*
718	* Make sure that they are adjacent, and that they've got the same callbacks.
719	*/
720	if (pCur1->Core.KeyLast + 1 == pCur2->Core.Key)
721	{
722	if ( pCur1->pfnHandlerGC == pCur2->pfnHandlerGC
723	&& pCur1->pfnHandlerR0 == pCur2->pfnHandlerR0
724	&& pCur1->pfnHandlerR3 == pCur2->pfnHandlerR3)
725	{
726	PPGMPHYSHANDLER pCur3 = (PPGMPHYSHANDLER)RTAvlroGCPhysRemove(&pVM->pgm.s.CTXSUFF(pTrees)->PhysHandlers, GCPhys2);
727	if (pCur3 == pCur2)
728	{
729	pCur1->Core.KeyLast = pCur2->Core.KeyLast;
730	pCur1->cPages = (pCur1->Core.KeyLast - (pCur1->Core.Key & X86_PTE_PAE_PG_MASK) + PAGE_SIZE) >> PAGE_SHIFT;
731	LogFlow(("PGMHandlerPhysicalJoin: %VGp-%VGp %VGp-%VGp\n",
732	pCur1->Core.Key, pCur1->Core.KeyLast, pCur2->Core.Key, pCur2->Core.KeyLast));
733	pgmUnlock(pVM);
734	MMHyperFree(pVM, pCur2);
735	return VINF_SUCCESS;
736	}
737	Assert(pCur3 == pCur2);
738	rc = VERR_INTERNAL_ERROR;
739	}
740	else
741	{
742	AssertMsgFailed(("mismatching handlers\n"));
743	rc = VERR_ACCESS_DENIED;
744	}
745	}
746	else
747	{
748	AssertMsgFailed(("not adjacent: %VGp-%VGp %VGp-%VGp\n",
749	pCur1->Core.Key, pCur1->Core.KeyLast, pCur2->Core.Key, pCur2->Core.KeyLast));
750	rc = VERR_INVALID_PARAMETER;
751	}
752	}
753	else
754	{
755	AssertMsgFailed(("Didn't find range starting at %VGp\n", GCPhys2));
756	rc = VERR_PGM_HANDLER_NOT_FOUND;
757	}
758	}
759	else
760	{
761	AssertMsgFailed(("Didn't find range starting at %VGp\n", GCPhys1));
762	rc = VERR_PGM_HANDLER_NOT_FOUND;
763	}
764	pgmUnlock(pVM);
765	return rc;
766
767	}
768
769
770	/**
771	* Resets any modifications to individual pages in a physical
772	* page access handler region.
773	*
774	* This is used in pair with PGMHandlerPhysicalModify().
775	*
776	* @returns VBox status code.
777	* @param pVM VM Handle
778	* @param GCPhys Start physical address earlier passed to PGMR3HandlerPhysicalRegister().
779	*/
780	PGMDECL(int) PGMHandlerPhysicalReset(PVM pVM, RTGCPHYS GCPhys)
781	{
782	/*
783	* Find the handler.
784	*/
785	pgmLock(pVM);
786	PPGMPHYSHANDLER pCur = (PPGMPHYSHANDLER)RTAvlroGCPhysGet(&pVM->pgm.s.CTXSUFF(pTrees)->PhysHandlers, GCPhys);
787	if (pCur)
788	{
789	/*
790	* Validate type.
791	*/
792	switch (pCur->enmType)
793	{
794	case PGMPHYSHANDLERTYPE_PHYSICAL_WRITE:
795	case PGMPHYSHANDLERTYPE_PHYSICAL_ALL:
796	{
797	/*
798	* Set the flags and flush shadow PT entries.
799	*/
800	STAM_COUNTER_INC(&pVM->pgm.s.StatHandlePhysicalReset);
801	PPGMRAMRANGE pRam = CTXSUFF(pVM->pgm.s.pRamRanges);
802	while (pRam && GCPhys > pRam->GCPhysLast)
803	pRam = CTXSUFF(pRam->pNext);
804	int rc = pgmHandlerPhysicalSetRamFlagsAndFlushShadowPTs(pVM, pCur, pRam);
805	if (rc == VINF_PGM_GCPHYS_ALIASED)
806	{
807	pVM->pgm.s.fSyncFlags \|= PGM_SYNC_CLEAR_PGM_POOL;
808	VM_FF_SET(pVM, VM_FF_PGM_SYNC_CR3);
809	}
810	pVM->pgm.s.fPhysCacheFlushPending = true;
811	pgmUnlock(pVM);
812	return VINF_SUCCESS;
813	}
814
815	/*
816	* Invalid.
817	*/
818	case PGMPHYSHANDLERTYPE_PHYSICAL:
819	case PGMPHYSHANDLERTYPE_MMIO:
820	AssertMsgFailed(("Can't reset type %d!\n", pCur->enmType));
821	pgmUnlock(pVM);
822	return VERR_INTERNAL_ERROR;
823
824	default:
825	AssertMsgFailed(("Invalid type %d! Corruption!\n", pCur->enmType));
826	pgmUnlock(pVM);
827	return VERR_INTERNAL_ERROR;
828	}
829	}
830	pgmUnlock(pVM);
831	AssertMsgFailed(("Didn't find MMIO Range starting at %#x\n", GCPhys));
832	return VERR_PGM_HANDLER_NOT_FOUND;
833	}
834
835
836	/**
837	* Search for virtual handler with matching physical address
838	*
839	* @returns VBox status code
840	* @param pVM The VM handle.
841	* @param GCPhys GC physical address to search for.
842	* @param ppVirt Where to store the pointer to the virtual handler structure.
843	* @param piPage Where to store the pointer to the index of the cached physical page.
844	*/
845	int pgmHandlerVirtualFindByPhysAddr(PVM pVM, RTGCPHYS GCPhys, PPGMVIRTHANDLER ppVirt, unsigned piPage)
846	{
847	STAM_PROFILE_START(CTXSUFF(&pVM->pgm.s.StatVirtHandleSearchByPhys), a);
848	Assert(ppVirt);
849
850	PPGMPHYS2VIRTHANDLER pCur;
851	pCur = (PPGMPHYS2VIRTHANDLER)RTAvlroGCPhysRangeGet(&CTXSUFF(pVM->pgm.s.pTrees)->PhysToVirtHandlers, GCPhys);
852	if (pCur)
853	{
854	/* found a match! */
855	#ifdef VBOX_STRICT_PGM_HANDLER_VIRTUAL
856	AssertRelease(pCur->offNextAlias & PGMPHYS2VIRTHANDLER_IS_HEAD);
857	#endif
858	*ppVirt = (PPGMVIRTHANDLER)((uintptr_t)pCur + pCur->offVirtHandler);
859	piPage = pCur - &(ppVirt)->aPhysToVirt[0];
860
861	LogFlow(("PHYS2VIRT: found match for %VGp -> %VGv *piPage=%#x\n",
862	GCPhys, (ppVirt)->GCPtr, piPage));
863	STAM_PROFILE_STOP(CTXSUFF(&pVM->pgm.s.StatVirtHandleSearchByPhys), a);
864	return VINF_SUCCESS;
865	}
866
867	*ppVirt = NULL;
868	STAM_PROFILE_STOP(CTXSUFF(&pVM->pgm.s.StatVirtHandleSearchByPhys), a);
869	return VERR_PGM_HANDLER_NOT_FOUND;
870	}
871
872
873	/**
874	* Deal with aliases in phys2virt.
875	*
876	* @param pVM The VM handle.
877	* @param pPhys2Virt The node we failed insert.
878	*/
879	static void pgmHandlerVirtualInsertAliased(PVM pVM, PPGMPHYS2VIRTHANDLER pPhys2Virt)
880	{
881	/*
882	* First find the node which is conflicting with us.
883	*/
884	/** @todo Deal with partial overlapping. (Unlikly situation, so I'm too lazy to do anything about it now.) */
885	PPGMPHYS2VIRTHANDLER pHead = (PPGMPHYS2VIRTHANDLER)RTAvlroGCPhysGet(&pVM->pgm.s.CTXSUFF(pTrees)->PhysToVirtHandlers, pPhys2Virt->Core.Key);
886	if (!pHead)
887	{
888	/** @todo do something clever here... */
889	#ifdef IN_RING3
890	LogRel(("pgmHandlerVirtualInsertAliased: %VGp-%VGp\n", pPhys2Virt->Core.Key, pPhys2Virt->Core.KeyLast));
891	#endif
892	pPhys2Virt->offNextAlias = 0;
893	return;
894	}
895	#ifdef VBOX_STRICT_PGM_HANDLER_VIRTUAL
896	AssertReleaseMsg(pHead != pPhys2Virt, ("%VGp-%VGp offVirtHandler=%#RX32\n",
897	pPhys2Virt->Core.Key, pPhys2Virt->Core.KeyLast, pPhys2Virt->offVirtHandler));
898	#endif
899
900	/** @todo check if the current head node covers the ground we do. This is highly unlikely
901	* and I'm too lazy to implement this now as it will require sorting the list and stuff like that. */
902
903	/*
904	* Insert ourselves as the next node.
905	*/
906	if (!(pHead->offNextAlias & PGMPHYS2VIRTHANDLER_OFF_MASK))
907	pPhys2Virt->offNextAlias = PGMPHYS2VIRTHANDLER_IN_TREE;
908	else
909	{
910	PPGMPHYS2VIRTHANDLER pNext = (PPGMPHYS2VIRTHANDLER)((intptr_t)pHead + (pHead->offNextAlias & PGMPHYS2VIRTHANDLER_OFF_MASK));
911	pPhys2Virt->offNextAlias = ((intptr_t)pNext - (intptr_t)pPhys2Virt)
912	\| PGMPHYS2VIRTHANDLER_IN_TREE;
913	}
914	pHead->offNextAlias = ((intptr_t)pPhys2Virt - (intptr_t)pHead)
915	\| (pHead->offNextAlias & ~PGMPHYS2VIRTHANDLER_OFF_MASK);
916	Log(("pgmHandlerVirtualInsertAliased: %VGp-%VGp offNextAlias=%#RX32\n", pPhys2Virt->Core.Key, pPhys2Virt->Core.KeyLast, pPhys2Virt->offNextAlias));
917	}
918
919
920	/**
921	* Resets one virtual handler range.
922	*
923	* @returns 0
924	* @param pNode Pointer to a PGMVIRTHANDLER.
925	* @param pvUser The VM handle.
926	*/
927	DECLCALLBACK(int) pgmHandlerVirtualResetOne(PAVLROGCPTRNODECORE pNode, void *pvUser)
928	{
929	PPGMVIRTHANDLER pCur = (PPGMVIRTHANDLER)pNode;
930	PVM pVM = (PVM)pvUser;
931
932	/*
933	* Calc flags.
934	*/
935	unsigned fFlags;
936	switch (pCur->enmType)
937	{
938	case PGMVIRTHANDLERTYPE_EIP:
939	case PGMVIRTHANDLERTYPE_NORMAL: fFlags = MM_RAM_FLAGS_VIRTUAL_HANDLER; break;
940	case PGMVIRTHANDLERTYPE_WRITE: fFlags = MM_RAM_FLAGS_VIRTUAL_HANDLER \| MM_RAM_FLAGS_VIRTUAL_WRITE; break;
941	case PGMVIRTHANDLERTYPE_ALL: fFlags = MM_RAM_FLAGS_VIRTUAL_HANDLER \| MM_RAM_FLAGS_VIRTUAL_ALL; break;
942	/* hypervisor handlers need no flags and wouldn't have nowhere to put them in any case. */
943	case PGMVIRTHANDLERTYPE_HYPERVISOR:
944	return 0;
945	default:
946	AssertMsgFailed(("Invalid type %d\n", pCur->enmType));
947	return 0;
948	}
949
950	/*
951	* Iterate the pages and apply the flags.
952	*/
953	PPGMRAMRANGE pRamHint = NULL;
954	RTGCUINTPTR offPage = ((RTGCUINTPTR)pCur->GCPtr & PAGE_OFFSET_MASK);
955	RTGCUINTPTR cbLeft = pCur->cb;
956	for (unsigned iPage = 0; iPage < pCur->cPages; iPage++)
957	{
958	PPGMPHYS2VIRTHANDLER pPhys2Virt = &pCur->aPhysToVirt[iPage];
959	if (pPhys2Virt->Core.Key != NIL_RTGCPHYS)
960	{
961	/* Update the flags. */
962	int rc = PGMRamFlagsSetByGCPhysWithHint(&pVM->pgm.s, pPhys2Virt->Core.Key, fFlags, &pRamHint);
963	AssertRC(rc);
964
965	/* Need to insert the page in the Phys2Virt lookup tree? */
966	if (pPhys2Virt->Core.KeyLast == NIL_RTGCPHYS)
967	{
968	#ifdef VBOX_STRICT_PGM_HANDLER_VIRTUAL
969	AssertRelease(!pPhys2Virt->offNextAlias);
970	#endif
971	unsigned cbPhys = cbLeft;
972	if (cbPhys > PAGE_SIZE - offPage)
973	cbPhys = PAGE_SIZE - offPage;
974	else
975	Assert(iPage == pCur->cPages - 1);
976	pPhys2Virt->Core.KeyLast = pPhys2Virt->Core.Key + cbPhys - 1; /* inclusive */
977	pPhys2Virt->offNextAlias = PGMPHYS2VIRTHANDLER_IS_HEAD \| PGMPHYS2VIRTHANDLER_IN_TREE;
978	if (!RTAvlroGCPhysInsert(&pVM->pgm.s.CTXSUFF(pTrees)->PhysToVirtHandlers, &pPhys2Virt->Core))
979	pgmHandlerVirtualInsertAliased(pVM, pPhys2Virt);
980	#ifdef VBOX_STRICT_PGM_HANDLER_VIRTUAL
981	else
982	AssertReleaseMsg(RTAvlroGCPhysGet(&pVM->pgm.s.CTXSUFF(pTrees)->PhysToVirtHandlers, pPhys2Virt->Core.Key) == &pPhys2Virt->Core,
983	("%VGp-%VGp offNextAlias=%#RX32\n",
984	pPhys2Virt->Core.Key, pPhys2Virt->Core.KeyLast, pPhys2Virt->offNextAlias));
985	#endif
986	Log2(("PHYS2VIRT: Insert physical range %VGp-%VGp offNextAlias=%#RX32 %s\n",
987	pPhys2Virt->Core.Key, pPhys2Virt->Core.KeyLast, pPhys2Virt->offNextAlias, R3STRING(pCur->pszDesc)));
988	}
989	}
990	cbLeft -= PAGE_SIZE - offPage;
991	offPage = 0;
992	}
993
994	return 0;
995	}
996
997
998	#ifndef IN_RING3
999
1000	# ifdef IN_RING0
1001	/** @todo try combine this with iom and em. */
1002
1003	/**
1004	* Read callback for disassembly function; supports reading bytes that cross a page boundary
1005	*
1006	* @returns VBox status code.
1007	* @param pSrc GC source pointer
1008	* @param pDest HC destination pointer
1009	* @param size Number of bytes to read
1010	* @param dwUserdata Callback specific user data (pCpu)
1011	*
1012	*/
1013	DECLCALLBACK(int32_t) pgmReadBytes(RTHCUINTPTR pSrc, uint8_t *pDest, uint32_t size, RTHCUINTPTR dwUserdata)
1014	{
1015	DISCPUSTATE pCpu = (DISCPUSTATE )dwUserdata;
1016	PVM pVM = (PVM)pCpu->dwUserData[0];
1017
1018	int rc = PGMPhysReadGCPtr(pVM, pDest, pSrc, size);
1019	AssertRC(rc);
1020	return rc;
1021	}
1022
1023	inline int pgmDisCoreOne(PVM pVM, DISCPUSTATE pCpu, RTGCUINTPTR InstrGC, uint32_t pOpsize)
1024	{
1025	return DISCoreOneEx(InstrGC, pCpu->mode, pgmReadBytes, pVM, pCpu, pOpsize);
1026	}
1027
1028	# else /* !IN_RING0 (i.e. in IN_GC) */
1029	inline int pgmDisCoreOne(PVM pVM, DISCPUSTATE pCpu, RTGCUINTPTR InstrGC, uint32_t pOpsize)
1030	{
1031	return DISCoreOne(pCpu, InstrGC, pOpsize);
1032	}
1033
1034	#endif /* !IN_RING0 (i.e. in IN_GC) */
1035
1036
1037	/**
1038	* \#PF Handler callback for Guest ROM range write access.
1039	* We simply ignore the writes or fall back to the recompiler if we don't support the instruction.
1040	*
1041	* @returns VBox status code (appropritate for trap handling and GC return).
1042	* @param pVM VM Handle.
1043	* @param uErrorCode CPU Error code.
1044	* @param pRegFrame Trap register frame.
1045	* @param pvFault The fault address (cr2).
1046	* @param GCPhysFault The GC physical address corresponding to pvFault.
1047	* @param pvUser User argument.
1048	*/
1049	PGMDECL(int) pgmGuestROMWriteHandler(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, void pvFault, RTGCPHYS GCPhysFault, void pvUser)
1050	{
1051	DISCPUSTATE Cpu;
1052	Cpu.mode = SELMIsSelector32Bit(pVM, pRegFrame->eflags, pRegFrame->cs, &pRegFrame->csHid) ? CPUMODE_32BIT : CPUMODE_16BIT;
1053	if (Cpu.mode == CPUMODE_32BIT)
1054	{
1055	RTGCPTR GCPtrCode;
1056	int rc = SELMValidateAndConvertCSAddr(pVM, pRegFrame->eflags, pRegFrame->ss, pRegFrame->cs, &pRegFrame->csHid, (RTGCPTR)pRegFrame->eip, &GCPtrCode);
1057	if (VBOX_SUCCESS(rc))
1058	{
1059	uint32_t cbOp;
1060	rc = pgmDisCoreOne(pVM, &Cpu, (RTGCUINTPTR)GCPtrCode, &cbOp);
1061	if (VBOX_SUCCESS(rc))
1062	{
1063	/* ASSUMES simple instructions.
1064	* For instance 'pop [ROM_ADDRESS]' or 'and [ROM_ADDRESS], eax' better
1065	* not occure or we'll screw up the cpu state.
1066	*/
1067	/** @todo We're assuming too much here I think. */
1068	if (!(Cpu.prefix & (PREFIX_REPNE \| PREFIX_REP \| PREFIX_SEG)))
1069	{
1070	/*
1071	* Move on to the next instruction.
1072	*/
1073	pRegFrame->eip += cbOp;
1074	STAM_COUNTER_INC(&pVM->pgm.s.StatGCGuestROMWriteHandled);
1075	return VINF_SUCCESS;
1076	}
1077	LogFlow(("pgmGuestROMWriteHandler: wrong prefix!!\n"));
1078	}
1079	}
1080	}
1081
1082	STAM_COUNTER_INC(&pVM->pgm.s.StatGCGuestROMWriteUnhandled);
1083	return VINF_EM_RAW_EMULATE_INSTR;
1084	}
1085	#endif /* !IN_RING3 */

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

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

Download in other formats: