PGMAllPhys.cpp@ 4714

Last change on this file since 4714 was 4714, checked in by vboxsync, 17 years ago
ZeroPg
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 72.4 KB

Line
1	/* $Id: PGMAllPhys.cpp 4714 2007-09-11 16:30:42Z vboxsync $ */
2	/** @file
3	* PGM - Page Manager and Monitor, Physical Memory Addressing.
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	/** @def PGM_IGNORE_RAM_FLAGS_RESERVED
19	* Don't respect the MM_RAM_FLAGS_RESERVED flag when converting to HC addresses.
20	*
21	* Since this flag is currently incorrectly kept set for ROM regions we will
22	* have to ignore it for now so we don't break stuff.
23	*
24	* @todo this has been fixed now I believe, remove this hack.
25	*/
26	#define PGM_IGNORE_RAM_FLAGS_RESERVED
27
28
29	/*******************************************************************************
30	* Header Files *
31	*******************************************************************************/
32	#define LOG_GROUP LOG_GROUP_PGM_PHYS
33	#include <VBox/pgm.h>
34	#include <VBox/trpm.h>
35	#include <VBox/vmm.h>
36	#include <VBox/iom.h>
37	#include "PGMInternal.h"
38	#include <VBox/vm.h>
39	#include <VBox/param.h>
40	#include <VBox/err.h>
41	#include <iprt/assert.h>
42	#include <iprt/string.h>
43	#include <iprt/asm.h>
44	#include <VBox/log.h>
45	#ifdef IN_RING3
46	# include <iprt/thread.h>
47	#endif
48
49
50
51	/**
52	* Checks if Address Gate 20 is enabled or not.
53	*
54	* @returns true if enabled.
55	* @returns false if disabled.
56	* @param pVM VM handle.
57	*/
58	PGMDECL(bool) PGMPhysIsA20Enabled(PVM pVM)
59	{
60	LogFlow(("PGMPhysIsA20Enabled %d\n", pVM->pgm.s.fA20Enabled));
61	return !!pVM->pgm.s.fA20Enabled ; /* stupid MS compiler doesn't trust me. */
62	}
63
64
65	/**
66	* Validates a GC physical address.
67	*
68	* @returns true if valid.
69	* @returns false if invalid.
70	* @param pVM The VM handle.
71	* @param GCPhys The physical address to validate.
72	*/
73	PGMDECL(bool) PGMPhysIsGCPhysValid(PVM pVM, RTGCPHYS GCPhys)
74	{
75	PPGMPAGE pPage = pgmPhysGetPage(&pVM->pgm.s, GCPhys);
76	return pPage != NULL;
77	}
78
79
80	/**
81	* Checks if a GC physical address is a normal page,
82	* i.e. not ROM, MMIO or reserved.
83	*
84	* @returns true if normal.
85	* @returns false if invalid, ROM, MMIO or reserved page.
86	* @param pVM The VM handle.
87	* @param GCPhys The physical address to check.
88	*/
89	PGMDECL(bool) PGMPhysIsGCPhysNormal(PVM pVM, RTGCPHYS GCPhys)
90	{
91	PPGMPAGE pPage = pgmPhysGetPage(&pVM->pgm.s, GCPhys);
92	return pPage
93	&& !(pPage->HCPhys & (MM_RAM_FLAGS_MMIO \| MM_RAM_FLAGS_ROM \| MM_RAM_FLAGS_RESERVED \| MM_RAM_FLAGS_MMIO2));
94	}
95
96
97	/**
98	* Converts a GC physical address to a HC physical address.
99	*
100	* @returns VINF_SUCCESS on success.
101	* @returns VERR_PGM_PHYS_PAGE_RESERVED it it's a valid GC physical
102	* page but has no physical backing.
103	* @returns VERR_PGM_INVALID_GC_PHYSICAL_ADDRESS if it's not a valid
104	* GC physical address.
105	*
106	* @param pVM The VM handle.
107	* @param GCPhys The GC physical address to convert.
108	* @param pHCPhys Where to store the HC physical address on success.
109	*/
110	PGMDECL(int) PGMPhysGCPhys2HCPhys(PVM pVM, RTGCPHYS GCPhys, PRTHCPHYS pHCPhys)
111	{
112	PPGMPAGE pPage;
113	int rc = pgmPhysGetPageEx(&pVM->pgm.s, GCPhys, &pPage);
114	if (VBOX_FAILURE(rc))
115	return rc;
116
117	#ifndef PGM_IGNORE_RAM_FLAGS_RESERVED
118	if (RT_UNLIKELY(pPage->HCPhys & MM_RAM_FLAGS_RESERVED)) /** @todo PAGE FLAGS */
119	return VERR_PGM_PHYS_PAGE_RESERVED;
120	#endif
121
122	*pHCPhys = PGM_PAGE_GET_HCPHYS(pPage) \| (GCPhys & PAGE_OFFSET_MASK);
123	return VINF_SUCCESS;
124	}
125
126
127	/**
128	* Invalidates the GC page mapping TLB.
129	*
130	* @param pVM The VM handle.
131	*/
132	PDMDECL(void) PGMPhysInvalidatePageGCMapTLB(PVM pVM)
133	{
134	/* later */
135	NOREF(pVM);
136	}
137
138
139	/**
140	* Invalidates the ring-0 page mapping TLB.
141	*
142	* @param pVM The VM handle.
143	*/
144	PDMDECL(void) PGMPhysInvalidatePageR0MapTLB(PVM pVM)
145	{
146	PGMPhysInvalidatePageR3MapTLB(pVM);
147	}
148
149
150	/**
151	* Invalidates the ring-3 page mapping TLB.
152	*
153	* @param pVM The VM handle.
154	*/
155	PDMDECL(void) PGMPhysInvalidatePageR3MapTLB(PVM pVM)
156	{
157	pgmLock(pVM);
158	for (unsigned i = 0; i < RT_ELEMENTS(pVM->pgm.s.PhysTlbHC.aEntries); i++)
159	{
160	pVM->pgm.s.PhysTlbHC.aEntries[i].GCPhys = NIL_RTGCPHYS;
161	pVM->pgm.s.PhysTlbHC.aEntries[i].pPage = 0;
162	pVM->pgm.s.PhysTlbHC.aEntries[i].pMap = 0;
163	pVM->pgm.s.PhysTlbHC.aEntries[i].pv = 0;
164	}
165	pgmUnlock(pVM);
166	}
167
168
169	/**
170	* Replace a zero or shared page with new page that we can write to.
171	*
172	* @returns VBox status.
173	* @todo Define the return values and propagate them up the call tree..
174	*
175	* @param pVM The VM address.
176	* @param pPage The physical page tracking structure.
177	* @param GCPhys The address of the page.
178	*
179	* @remarks Called from within the PGM critical section.
180	*/
181	int pgmPhysAllocPage(PVM pVM, PPGMPAGE pPage, RTGCPHYS GCPhys)
182	{
183	return VERR_NOT_IMPLEMENTED;
184	}
185
186
187	/**
188	* Deal with pages that are not writable, i.e. not in the ALLOCATED state.
189	*
190	* @returns VBox status code.
191	* @retval VINF_SUCCESS on success.
192	* @retval VERR_PGM_PHYS_PAGE_RESERVED it it's a valid page but has no physical backing.
193	*
194	* @param pVM The VM address.
195	* @param pPage The physical page tracking structure.
196	* @param GCPhys The address of the page.
197	*
198	* @remarks Called from within the PGM critical section.
199	*/
200	int pgmPhysPageMakeWritable(PVM pVM, PPGMPAGE pPage, RTGCPHYS GCPhys)
201	{
202	switch (pPage->u2State)
203	{
204	case PGM_PAGE_STATE_WRITE_MONITORED:
205	pPage->fWrittenTo = true;
206	pPage->u2State = PGM_PAGE_STATE_ALLOCATED;
207	/* fall thru */
208	default: /* to shut up GCC */
209	case PGM_PAGE_STATE_ALLOCATED:
210	return VINF_SUCCESS;
211
212	/*
213	* Zero pages can be dummy pages for MMIO or reserved memory,
214	* so we need to check the flags before joining cause with
215	* shared page replacement.
216	*/
217	case PGM_PAGE_STATE_ZERO:
218	if ( PGM_PAGE_IS_MMIO(pPage)
219	\|\| PGM_PAGE_IS_RESERVED(pPage))
220	return VERR_PGM_PHYS_PAGE_RESERVED;
221	/* fall thru */
222	case PGM_PAGE_STATE_SHARED:
223	return pgmPhysAllocPage(pVM, pPage, GCPhys);
224	}
225	}
226
227
228	/**
229	* Maps a page into the current virtual address space so it can be accessed.
230	*
231	* @returns VBox status code.
232	* @retval VINF_SUCCESS on success.
233	* @retval VERR_PGM_PHYS_PAGE_RESERVED it it's a valid page but has no physical backing.
234	*
235	* @param pVM The VM address.
236	* @param pPage The physical page tracking structure.
237	* @param GCPhys The address of the page.
238	* @param ppMap Where to store the address of the mapping tracking structure.
239	* @param ppv Where to store the mapping address of the page. The page
240	* offset is masked off!
241	*
242	* @remarks Called from within the PGM critical section.
243	*/
244	int pgmPhysPageMap(PVM pVM, PPGMPAGE pPage, RTGCPHYS GCPhys, PPPGMPAGEMAP ppMap, void **ppv)
245	{
246	#ifdef IN_GC
247	/*
248	* Just some sketchy GC code.
249	*/
250	*ppMap = NULL;
251	RTHCPHYS HCPhys = PGM_PAGE_GET_HCPHYS(pPage);
252	Assert(HCPhys != pVM->pgm.s.HCPhysZeroPg);
253	return PGMGCDynMapHCPage(pVM, HCPhys, ppv);
254
255	#else /* IN_RING3 \|\| IN_RING0 */
256
257	/*
258	* Find/make Chunk TLB entry for the mapping chunk.
259	*/
260	PPGMCHUNKR3MAP pMap;
261	const uint32_t idChunk = PGM_PAGE_GET_CHUNKID(pPage);
262	PPGMCHUNKR3MAPTLBE pTlbe = &pVM->pgm.s.ChunkR3Map.Tlb.aEntries[PGM_CHUNKR3MAPTLB_IDX(idChunk)];
263	if (pTlbe->idChunk == idChunk)
264	{
265	STAM_COUNTER_INC(&pVM->pgm.s.StatChunkR3MapTlbHits);
266	pMap = pTlbe->pChunk;
267	}
268	else if (idChunk != NIL_GPM_CHUNKID)
269	{
270	STAM_COUNTER_INC(&pVM->pgm.s.StatChunkR3MapTlbMisses);
271
272	/*
273	* Find the chunk, map it if necessary.
274	*/
275	pMap = (PPGMCHUNKR3MAP)RTAvlU32Get(&pVM->pgm.s.ChunkR3Map.pTree, idChunk);
276	if (!pMap)
277	{
278	#ifdef IN_RING0
279	int rc = VMMR0CallHost(pVM, VMMCALLHOST_PGM_MAP_CHUNK, idChunk);
280	AssertRCReturn(rc, rc);
281	pMap = (PPGMCHUNKR3MAP)RTAvlU32Get(&pVM->pgm.s.ChunkR3Map.pTree, idChunk);
282	Assert(pMap);
283	#else
284	int rc = pgmR3PhysChunkMap(pVM, idChunk, &pMap);
285	if (VBOX_FAILURE(rc))
286	return rc;
287	#endif
288	}
289
290	/*
291	* Enter it into the Chunk TLB.
292	*/
293	pTlbe->idChunk = idChunk;
294	pTlbe->pChunk = pMap;
295	pMap->iAge = 0;
296	}
297	else
298	{
299	Assert(PGM_PAGE_IS_ZERO(pPage));
300	*ppv = pVM->pgm.s.CTXALLSUFF(pvZeroPg);
301	*ppMap = NULL;
302	return VINF_SUCCESS;
303	}
304
305	ppv = (uint8_t )pMap->pv + (PGM_PAGE_GET_PAGE_IN_CHUNK(pPage) << PAGE_SHIFT);
306	*ppMap = pMap;
307	return VINF_SUCCESS;
308	#endif /* IN_RING3 */
309	}
310
311
312	#ifndef IN_GC
313	/**
314	* Load a guest page into the ring-3 physical TLB.
315	*
316	* @returns VBox status code.
317	* @retval VINF_SUCCESS on success
318	* @retval VERR_PGM_INVALID_GC_PHYSICAL_ADDRESS if it's not a valid physical address.
319	* @param pPGM The PGM instance pointer.
320	* @param GCPhys The guest physical address in question.
321	*/
322	int pgmPhysPageLoadIntoTlb(PPGM pPGM, RTGCPHYS GCPhys)
323	{
324	STAM_COUNTER_INC(&pPGM->CTXMID(StatPage,MapTlbMisses));
325
326	/*
327	* Find the ram range.
328	* 99.8% of requests are expected to be in the first range.
329	*/
330	PPGMRAMRANGE pRam = CTXSUFF(pPGM->pRamRanges);
331	RTGCPHYS off = GCPhys - pRam->GCPhys;
332	if (RT_UNLIKELY(off >= pRam->cb))
333	{
334	do
335	{
336	pRam = CTXSUFF(pRam->pNext);
337	if (!pRam)
338	return VERR_PGM_INVALID_GC_PHYSICAL_ADDRESS;
339	off = GCPhys - pRam->GCPhys;
340	} while (off >= pRam->cb);
341	}
342
343	/*
344	* Map the page.
345	* Make a special case for the zero page as it is kind of special.
346	*/
347	PPGMPAGE pPage = &pRam->aPages[off >> PAGE_SHIFT];
348	PPGMPAGEMAPTLBE pTlbe = &pPGM->CTXSUFF(PhysTlb).aEntries[PGM_PAGEMAPTLB_IDX(GCPhys)];
349	if (!PGM_PAGE_IS_ZERO(pPage))
350	{
351	void *pv;
352	PPGMPAGEMAP pMap;
353	int rc = pgmPhysPageMap(PGM2VM(pPGM), pPage, GCPhys, &pMap, &pv);
354	if (VBOX_FAILURE(rc))
355	return rc;
356	pTlbe->pMap = pMap;
357	pTlbe->pv = pv;
358	}
359	else
360	{
361	Assert(PGM_PAGE_GET_HCPHYS(pPage) == pPGM->HCPhysZeroPg);
362	pTlbe->pMap = NULL;
363	pTlbe->pv = pPGM->CTXALLSUFF(pvZeroPg);
364	}
365	pTlbe->pPage = pPage;
366	return VINF_SUCCESS;
367	}
368	#endif /* !IN_GC */
369
370
371	/**
372	* Requests the mapping of a guest page into the current context.
373	*
374	* This API should only be used for very short term, as it will consume
375	* scarse resources (R0 and GC) in the mapping cache. When you're done
376	* with the page, call PGMPhysReleasePageMappingLock() ASAP to release it.
377	*
378	* This API will assume your intention is to write to the page, and will
379	* therefore replace shared and zero pages. If you do not intend to modify
380	* the page, use the PGMPhysGCPhys2CCPtrReadOnly() API.
381	*
382	* @returns VBox status code.
383	* @retval VINF_SUCCESS on success.
384	* @retval VERR_PGM_PHYS_PAGE_RESERVED it it's a valid page but has no physical backing.
385	* @retval VERR_PGM_INVALID_GC_PHYSICAL_ADDRESS if it's not a valid physical address.
386	*
387	* @param pVM The VM handle.
388	* @param GCPhys The guest physical address of the page that should be mapped.
389	* @param ppv Where to store the address corresponding to GCPhys.
390	* @param pLock Where to store the lock information that PGMPhysReleasePageMappingLock needs.
391	*
392	* @remark Avoid calling this API from within critical sections (other than
393	* the PGM one) because of the deadlock risk.
394	* @thread Any thread.
395	*/
396	PGMDECL(int) PGMPhysGCPhys2CCPtr(PVM pVM, RTGCPHYS GCPhys, void **ppv, PPGMPAGEMAPLOCK pLock)
397	{
398	#ifdef NEW_PHYS_CODE
399	#ifdef IN_GC
400	/* Until a physical TLB is implemented for GC, let PGMGCDynMapGCPageEx handle it. */
401	return PGMGCDynMapGCPageEx(pVM, GCPhys, ppv);
402	#else
403	int rc = pgmLock(pVM);
404	AssertRCReturn(rc);
405
406	/*
407	* Query the Physical TLB entry for the page (may fail).
408	*/
409	PGMPHYSTLBE pTlbe;
410	int rc = pgmPhysPageQueryTlbe(&pVM->pgm.s, GCPhys, &pTlbe);
411	if (RT_SUCCESS(rc))
412	{
413	/*
414	* If the page is shared, the zero page, or being write monitored
415	* it must be converted to an page that's writable if possible.
416	*/
417	PPGMPAGE pPage = pTlbe->pPage;
418	if (RT_UNLIKELY(pPage->u2State != PGM_PAGE_STATE_ALLOCATED))
419	rc = pgmPhysPageMakeWritable(pVM, pPage, GCPhys);
420	if (RT_SUCCESS(rc))
421	{
422	/*
423	* Now, just perform the locking and calculate the return address.
424	*/
425	PPGMPAGEMAP pMap = pTlbe->pMap;
426	pMap->cRefs++;
427	if (RT_LIKELY(pPage->cLocks != PGM_PAGE_MAX_LOCKS))
428	if (RT_UNLIKELY(++pPage->cLocks == PGM_PAGE_MAX_LOCKS))
429	{
430	AssertMsgFailed(("%VGp is entering permanent locked state!\n", GCPhys));
431	pMap->cRefs++; /* Extra ref to prevent it from going away. */
432	}
433
434	ppv = (void )((uintptr_t)pTlbe->pv \| (GCPhys & PAGE_OFFSET_MASK));
435	pLock->pvPage = pPage;
436	pLock->pvMap = pMap;
437	}
438	}
439
440	pgmUnlock(pVM);
441	return rc;
442
443	#endif /* IN_RING3 \|\| IN_RING0 */
444
445	#else
446	/*
447	* Temporary fallback code.
448	*/
449	# ifdef IN_GC
450	return PGMGCDynMapGCPageEx(pVM, GCPhys, ppv);
451	# else
452	return PGMPhysGCPhys2HCPtr(pVM, GCPhys, 1, ppv);
453	# endif
454	#endif
455	}
456
457
458	/**
459	* Requests the mapping of a guest page into the current context.
460	*
461	* This API should only be used for very short term, as it will consume
462	* scarse resources (R0 and GC) in the mapping cache. When you're done
463	* with the page, call PGMPhysReleasePageMappingLock() ASAP to release it.
464	*
465	* @returns VBox status code.
466	* @retval VINF_SUCCESS on success.
467	* @retval VERR_PGM_PHYS_PAGE_RESERVED it it's a valid page but has no physical backing.
468	* @retval VERR_PGM_INVALID_GC_PHYSICAL_ADDRESS if it's not a valid physical address.
469	*
470	* @param pVM The VM handle.
471	* @param GCPhys The guest physical address of the page that should be mapped.
472	* @param ppv Where to store the address corresponding to GCPhys.
473	* @param pLock Where to store the lock information that PGMPhysReleasePageMappingLock needs.
474	*
475	* @remark Avoid calling this API from within critical sections (other than
476	* the PGM one) because of the deadlock risk.
477	* @thread Any thread.
478	*/
479	PGMDECL(int) PGMPhysGCPhys2CCPtrReadOnly(PVM pVM, RTGCPHYS GCPhys, void * const *ppv, PPGMPAGEMAPLOCK pLock)
480	{
481	/** @todo implement this */
482	return PGMPhysGCPhys2CCPtr(pVM, GCPhys, (void **)ppv, pLock);
483	}
484
485
486	/**
487	* Requests the mapping of a guest page given by virtual address into the current context.
488	*
489	* This API should only be used for very short term, as it will consume
490	* scarse resources (R0 and GC) in the mapping cache. When you're done
491	* with the page, call PGMPhysReleasePageMappingLock() ASAP to release it.
492	*
493	* This API will assume your intention is to write to the page, and will
494	* therefore replace shared and zero pages. If you do not intend to modify
495	* the page, use the PGMPhysGCPtr2CCPtrReadOnly() API.
496	*
497	* @returns VBox status code.
498	* @retval VINF_SUCCESS on success.
499	* @retval VERR_PAGE_TABLE_NOT_PRESENT if the page directory for the virtual address isn't present.
500	* @retval VERR_PAGE_NOT_PRESENT if the page at the virtual address isn't present.
501	* @retval VERR_PGM_PHYS_PAGE_RESERVED it it's a valid page but has no physical backing.
502	* @retval VERR_PGM_INVALID_GC_PHYSICAL_ADDRESS if it's not a valid physical address.
503	*
504	* @param pVM The VM handle.
505	* @param GCPhys The guest physical address of the page that should be mapped.
506	* @param ppv Where to store the address corresponding to GCPhys.
507	* @param pLock Where to store the lock information that PGMPhysReleasePageMappingLock needs.
508	*
509	* @remark Avoid calling this API from within critical sections (other than
510	* the PGM one) because of the deadlock risk.
511	* @thread EMT
512	*/
513	PGMDECL(int) PGMPhysGCPtr2CCPtr(PVM pVM, RTGCPTR GCPtr, void **ppv, PPGMPAGEMAPLOCK pLock)
514	{
515	RTGCPHYS GCPhys;
516	int rc = PGMPhysGCPtr2GCPhys(pVM, GCPtr, &GCPhys);
517	if (VBOX_SUCCESS(rc))
518	rc = PGMPhysGCPhys2CCPtr(pVM, GCPhys, ppv, pLock);
519	return rc;
520	}
521
522
523	/**
524	* Requests the mapping of a guest page given by virtual address into the current context.
525	*
526	* This API should only be used for very short term, as it will consume
527	* scarse resources (R0 and GC) in the mapping cache. When you're done
528	* with the page, call PGMPhysReleasePageMappingLock() ASAP to release it.
529	*
530	* @returns VBox status code.
531	* @retval VINF_SUCCESS on success.
532	* @retval VERR_PAGE_TABLE_NOT_PRESENT if the page directory for the virtual address isn't present.
533	* @retval VERR_PAGE_NOT_PRESENT if the page at the virtual address isn't present.
534	* @retval VERR_PGM_PHYS_PAGE_RESERVED it it's a valid page but has no physical backing.
535	* @retval VERR_PGM_INVALID_GC_PHYSICAL_ADDRESS if it's not a valid physical address.
536	*
537	* @param pVM The VM handle.
538	* @param GCPhys The guest physical address of the page that should be mapped.
539	* @param ppv Where to store the address corresponding to GCPhys.
540	* @param pLock Where to store the lock information that PGMPhysReleasePageMappingLock needs.
541	*
542	* @remark Avoid calling this API from within critical sections (other than
543	* the PGM one) because of the deadlock risk.
544	* @thread EMT
545	*/
546	PGMDECL(int) PGMPhysGCPtr2CCPtrReadOnly(PVM pVM, RTGCPTR GCPtr, void * const *ppv, PPGMPAGEMAPLOCK pLock)
547	{
548	RTGCPHYS GCPhys;
549	int rc = PGMPhysGCPtr2GCPhys(pVM, GCPtr, &GCPhys);
550	if (VBOX_SUCCESS(rc))
551	rc = PGMPhysGCPhys2CCPtrReadOnly(pVM, GCPhys, ppv, pLock);
552	return rc;
553	}
554
555
556	/**
557	* Release the mapping of a guest page.
558	*
559	* This is the counter part of PGMPhysGCPhys2CCPtr, PGMPhysGCPhys2CCPtrReadOnly
560	* PGMPhysGCPtr2CCPtr and PGMPhysGCPtr2CCPtrReadOnly.
561	*
562	* @param pVM The VM handle.
563	* @param pLock The lock structure initialized by the mapping function.
564	*/
565	PGMDECL(void) PGMPhysReleasePageMappingLock(PVM pVM, PPGMPAGEMAPLOCK pLock)
566	{
567	#ifdef NEW_PHYS_CODE
568	#ifdef IN_GC
569	/* currently nothing to do here. */
570	/* --- postponed
571	#elif defined(IN_RING0)
572	*/
573
574	#else /* IN_RING3 */
575	pgmLock(pVM);
576
577	PPGMPAGE pPage = (PPGMPAGE)pLock->pvPage;
578	Assert(pPage->cLocks >= 1);
579	if (pPage->cLocks != PGM_PAGE_MAX_LOCKS)
580	pPage->cLocks--;
581
582	PPGMCHUNKR3MAP pChunk = (PPGMCHUNKR3MAP)pLock->pvChunk;
583	Assert(pChunk->cRefs >= 1);
584	pChunk->cRefs--;
585	pChunk->iAge = 0;
586
587	pgmUnlock(pVM);
588	#endif /* IN_RING3 */
589	#else
590	NOREF(pVM);
591	NOREF(pLock);
592	#endif
593	}
594
595
596	/**
597	* Converts a GC physical address to a HC pointer.
598	*
599	* @returns VINF_SUCCESS on success.
600	* @returns VERR_PGM_PHYS_PAGE_RESERVED it it's a valid GC physical
601	* page but has no physical backing.
602	* @returns VERR_PGM_INVALID_GC_PHYSICAL_ADDRESS if it's not a valid
603	* GC physical address.
604	* @returns VERR_PGM_GCPHYS_RANGE_CROSSES_BOUNDARY if the range crosses
605	* a dynamic ram chunk boundary
606	* @param pVM The VM handle.
607	* @param GCPhys The GC physical address to convert.
608	* @param cbRange Physical range
609	* @param pHCPtr Where to store the HC pointer on success.
610	*/
611	PGMDECL(int) PGMPhysGCPhys2HCPtr(PVM pVM, RTGCPHYS GCPhys, RTUINT cbRange, PRTHCPTR pHCPtr)
612	{
613	#ifdef PGM_DYNAMIC_RAM_ALLOC
614	if ((GCPhys & PGM_DYNAMIC_CHUNK_BASE_MASK) != ((GCPhys+cbRange-1) & PGM_DYNAMIC_CHUNK_BASE_MASK))
615	{
616	AssertMsgFailed(("%VGp - %VGp crosses a chunk boundary!!\n", GCPhys, GCPhys+cbRange));
617	LogRel(("PGMPhysGCPhys2HCPtr %VGp - %VGp crosses a chunk boundary!!\n", GCPhys, GCPhys+cbRange));
618	return VERR_PGM_GCPHYS_RANGE_CROSSES_BOUNDARY;
619	}
620	#endif
621
622	PPGMRAMRANGE pRam;
623	PPGMPAGE pPage;
624	int rc = pgmPhysGetPageAndRangeEx(&pVM->pgm.s, GCPhys, &pPage, &pRam);
625	if (VBOX_FAILURE(rc))
626	return rc;
627
628	#ifndef PGM_IGNORE_RAM_FLAGS_RESERVED
629	if (RT_UNLIKELY(PGM_PAGE_IS_RESERVED(pPage)))
630	return VERR_PGM_PHYS_PAGE_RESERVED;
631	#endif
632
633	RTGCPHYS off = GCPhys - pRam->GCPhys;
634	if (RT_UNLIKELY(off + cbRange > pRam->cb))
635	{
636	AssertMsgFailed(("%VGp - %VGp crosses a chunk boundary!!\n", GCPhys, GCPhys + cbRange));
637	return VERR_PGM_GCPHYS_RANGE_CROSSES_BOUNDARY;
638	}
639
640	if (pRam->fFlags & MM_RAM_FLAGS_DYNAMIC_ALLOC)
641	{
642	unsigned iChunk = (off >> PGM_DYNAMIC_CHUNK_SHIFT);
643	*pHCPtr = (RTHCPTR)((RTHCUINTPTR)CTXSUFF(pRam->pavHCChunk)[iChunk] + (off & PGM_DYNAMIC_CHUNK_OFFSET_MASK));
644	}
645	else if (RT_LIKELY(pRam->pvHC))
646	*pHCPtr = (RTHCPTR)((RTHCUINTPTR)pRam->pvHC + off);
647	else
648	return VERR_PGM_PHYS_PAGE_RESERVED;
649	return VINF_SUCCESS;
650	}
651
652
653	/**
654	* Converts a guest pointer to a GC physical address.
655	*
656	* This uses the current CR3/CR0/CR4 of the guest.
657	*
658	* @returns VBox status code.
659	* @param pVM The VM Handle
660	* @param GCPtr The guest pointer to convert.
661	* @param pGCPhys Where to store the GC physical address.
662	*/
663	PGMDECL(int) PGMPhysGCPtr2GCPhys(PVM pVM, RTGCPTR GCPtr, PRTGCPHYS pGCPhys)
664	{
665	int rc = PGM_GST_PFN(GetPage,pVM)(pVM, (RTGCUINTPTR)GCPtr, NULL, pGCPhys);
666	if (pGCPhys && VBOX_SUCCESS(rc))
667	*pGCPhys \|= (RTGCUINTPTR)GCPtr & PAGE_OFFSET_MASK;
668	return rc;
669	}
670
671
672	/**
673	* Converts a guest pointer to a HC physical address.
674	*
675	* This uses the current CR3/CR0/CR4 of the guest.
676	*
677	* @returns VBox status code.
678	* @param pVM The VM Handle
679	* @param GCPtr The guest pointer to convert.
680	* @param pHCPhys Where to store the HC physical address.
681	*/
682	PGMDECL(int) PGMPhysGCPtr2HCPhys(PVM pVM, RTGCPTR GCPtr, PRTHCPHYS pHCPhys)
683	{
684	RTGCPHYS GCPhys;
685	int rc = PGM_GST_PFN(GetPage,pVM)(pVM, (RTGCUINTPTR)GCPtr, NULL, &GCPhys);
686	if (VBOX_SUCCESS(rc))
687	rc = PGMPhysGCPhys2HCPhys(pVM, GCPhys \| ((RTGCUINTPTR)GCPtr & PAGE_OFFSET_MASK), pHCPhys);
688	return rc;
689	}
690
691
692	/**
693	* Converts a guest pointer to a HC pointer.
694	*
695	* This uses the current CR3/CR0/CR4 of the guest.
696	*
697	* @returns VBox status code.
698	* @param pVM The VM Handle
699	* @param GCPtr The guest pointer to convert.
700	* @param pHCPtr Where to store the HC virtual address.
701	*/
702	PGMDECL(int) PGMPhysGCPtr2HCPtr(PVM pVM, RTGCPTR GCPtr, PRTHCPTR pHCPtr)
703	{
704	RTGCPHYS GCPhys;
705	int rc = PGM_GST_PFN(GetPage,pVM)(pVM, (RTGCUINTPTR)GCPtr, NULL, &GCPhys);
706	if (VBOX_SUCCESS(rc))
707	rc = PGMPhysGCPhys2HCPtr(pVM, GCPhys \| ((RTGCUINTPTR)GCPtr & PAGE_OFFSET_MASK), 1 /* we always stay within one page */, pHCPtr);
708	return rc;
709	}
710
711
712	/**
713	* Converts a guest virtual address to a HC pointer by specfied CR3 and flags.
714	*
715	* @returns VBox status code.
716	* @param pVM The VM Handle
717	* @param GCPtr The guest pointer to convert.
718	* @param cr3 The guest CR3.
719	* @param fFlags Flags used for interpreting the PD correctly: X86_CR4_PSE and X86_CR4_PAE
720	* @param pHCPtr Where to store the HC pointer.
721	*
722	* @remark This function is used by the REM at a time where PGM could
723	* potentially not be in sync. It could also be used by a
724	* future DBGF API to cpu state independent conversions.
725	*/
726	PGMDECL(int) PGMPhysGCPtr2HCPtrByGstCR3(PVM pVM, RTGCPTR GCPtr, uint32_t cr3, unsigned fFlags, PRTHCPTR pHCPtr)
727	{
728	/*
729	* PAE or 32-bit?
730	*/
731	int rc;
732	if (!(fFlags & X86_CR4_PAE))
733	{
734	PX86PD pPD;
735	rc = PGM_GCPHYS_2_PTR(pVM, cr3 & X86_CR3_PAGE_MASK, &pPD);
736	if (VBOX_SUCCESS(rc))
737	{
738	VBOXPDE Pde = pPD->a[(RTGCUINTPTR)GCPtr >> X86_PD_SHIFT];
739	if (Pde.n.u1Present)
740	{
741	if ((fFlags & X86_CR4_PSE) && Pde.b.u1Size)
742	{ /* (big page) */
743	rc = PGMPhysGCPhys2HCPtr(pVM, (Pde.u & X86_PDE4M_PG_MASK) \| ((RTGCUINTPTR)GCPtr & X86_PAGE_4M_OFFSET_MASK), 1 /* we always stay within one page */, pHCPtr);
744	}
745	else
746	{ /* (normal page) */
747	PVBOXPT pPT;
748	rc = PGM_GCPHYS_2_PTR(pVM, Pde.u & X86_PDE_PG_MASK, &pPT);
749	if (VBOX_SUCCESS(rc))
750	{
751	VBOXPTE Pte = pPT->a[((RTGCUINTPTR)GCPtr >> X86_PT_SHIFT) & X86_PT_MASK];
752	if (Pte.n.u1Present)
753	return PGMPhysGCPhys2HCPtr(pVM, (Pte.u & X86_PTE_PG_MASK) \| ((RTGCUINTPTR)GCPtr & PAGE_OFFSET_MASK), 1 /* we always stay within one page */, pHCPtr);
754	rc = VERR_PAGE_NOT_PRESENT;
755	}
756	}
757	}
758	else
759	rc = VERR_PAGE_TABLE_NOT_PRESENT;
760	}
761	}
762	else
763	{
764	/** @todo long mode! */
765	PX86PDPTR pPdptr;
766	rc = PGM_GCPHYS_2_PTR(pVM, cr3 & X86_CR3_PAE_PAGE_MASK, &pPdptr);
767	if (VBOX_SUCCESS(rc))
768	{
769	X86PDPE Pdpe = pPdptr->a[((RTGCUINTPTR)GCPtr >> X86_PDPTR_SHIFT) & X86_PDPTR_MASK];
770	if (Pdpe.n.u1Present)
771	{
772	PX86PDPAE pPD;
773	rc = PGM_GCPHYS_2_PTR(pVM, Pdpe.u & X86_PDPE_PG_MASK, &pPD);
774	if (VBOX_SUCCESS(rc))
775	{
776	X86PDEPAE Pde = pPD->a[((RTGCUINTPTR)GCPtr >> X86_PD_PAE_SHIFT) & X86_PD_PAE_MASK];
777	if (Pde.n.u1Present)
778	{
779	if ((fFlags & X86_CR4_PSE) && Pde.b.u1Size)
780	{ /* (big page) */
781	rc = PGMPhysGCPhys2HCPtr(pVM, (Pde.u & X86_PDE4M_PAE_PG_MASK) \| ((RTGCUINTPTR)GCPtr & X86_PAGE_4M_OFFSET_MASK), 1 /* we always stay within one page */, pHCPtr);
782	}
783	else
784	{ /* (normal page) */
785	PX86PTPAE pPT;
786	rc = PGM_GCPHYS_2_PTR(pVM, (Pde.u & X86_PDE_PAE_PG_MASK), &pPT);
787	if (VBOX_SUCCESS(rc))
788	{
789	X86PTEPAE Pte = pPT->a[((RTGCUINTPTR)GCPtr >> X86_PT_PAE_SHIFT) & X86_PT_PAE_MASK];
790	if (Pte.n.u1Present)
791	return PGMPhysGCPhys2HCPtr(pVM, (Pte.u & X86_PTE_PAE_PG_MASK) \| ((RTGCUINTPTR)GCPtr & PAGE_OFFSET_MASK), 1 /* we always stay within one page */, pHCPtr);
792	rc = VERR_PAGE_NOT_PRESENT;
793	}
794	}
795	}
796	else
797	rc = VERR_PAGE_TABLE_NOT_PRESENT;
798	}
799	}
800	else
801	rc = VERR_PAGE_TABLE_NOT_PRESENT;
802	}
803	}
804	return rc;
805	}
806
807
808	#undef LOG_GROUP
809	#define LOG_GROUP LOG_GROUP_PGM_PHYS_ACCESS
810
811
812	#ifdef IN_RING3
813	/**
814	* Cache PGMPhys memory access
815	*
816	* @param pVM VM Handle.
817	* @param pCache Cache structure pointer
818	* @param GCPhys GC physical address
819	* @param pbHC HC pointer corresponding to physical page
820	*
821	* @thread EMT.
822	*/
823	static void pgmPhysCacheAdd(PVM pVM, PGMPHYSCACHE pCache, RTGCPHYS GCPhys, uint8_t pbHC)
824	{
825	uint32_t iCacheIndex;
826
827	GCPhys = PAGE_ADDRESS(GCPhys);
828	pbHC = (uint8_t *)PAGE_ADDRESS(pbHC);
829
830	iCacheIndex = ((GCPhys >> PAGE_SHIFT) & PGM_MAX_PHYSCACHE_ENTRIES_MASK);
831
832	ASMBitSet(&pCache->aEntries, iCacheIndex);
833
834	pCache->Entry[iCacheIndex].GCPhys = GCPhys;
835	pCache->Entry[iCacheIndex].pbHC = pbHC;
836	}
837	#endif
838
839	/**
840	* Read physical memory.
841	*
842	* This API respects access handlers and MMIO. Use PGMPhysReadGCPhys() if you
843	* want to ignore those.
844	*
845	* @param pVM VM Handle.
846	* @param GCPhys Physical address start reading from.
847	* @param pvBuf Where to put the read bits.
848	* @param cbRead How many bytes to read.
849	*/
850	PGMDECL(void) PGMPhysRead(PVM pVM, RTGCPHYS GCPhys, void *pvBuf, size_t cbRead)
851	{
852	#ifdef IN_RING3
853	bool fGrabbedLock = false;
854	#endif
855
856	AssertMsg(cbRead > 0, ("don't even think about reading zero bytes!\n"));
857	if (cbRead == 0)
858	return;
859
860	LogFlow(("PGMPhysRead: %VGp %d\n", GCPhys, cbRead));
861
862	#ifdef IN_RING3
863	if (!VM_IS_EMT(pVM))
864	{
865	pgmLock(pVM);
866	fGrabbedLock = true;
867	}
868	#endif
869
870	/*
871	* Copy loop on ram ranges.
872	*/
873	PPGMRAMRANGE pCur = CTXSUFF(pVM->pgm.s.pRamRanges);
874	for (;;)
875	{
876	/* Find range. */
877	while (pCur && GCPhys > pCur->GCPhysLast)
878	pCur = CTXSUFF(pCur->pNext);
879	/* Inside range or not? */
880	if (pCur && GCPhys >= pCur->GCPhys)
881	{
882	/*
883	* Must work our way thru this page by page.
884	*/
885	RTGCPHYS off = GCPhys - pCur->GCPhys;
886	while (off < pCur->cb)
887	{
888	unsigned iPage = off >> PAGE_SHIFT;
889	PPGMPAGE pPage = &pCur->aPages[iPage];
890	size_t cb;
891
892	/* Physical chunk in dynamically allocated range not present? */
893	if (RT_UNLIKELY(!PGM_PAGE_GET_HCPHYS(pPage)))
894	{
895	/* Treat it as reserved; return zeros */
896	cb = PAGE_SIZE - (off & PAGE_OFFSET_MASK);
897	if (cb >= cbRead)
898	{
899	memset(pvBuf, 0, cbRead);
900	goto end;
901	}
902	memset(pvBuf, 0, cb);
903	}
904	else
905	{
906	switch (pPage->HCPhys & (MM_RAM_FLAGS_RESERVED \| MM_RAM_FLAGS_MMIO \| MM_RAM_FLAGS_VIRTUAL_ALL \| MM_RAM_FLAGS_PHYSICAL_ALL \| MM_RAM_FLAGS_ROM)) /** @todo PAGE FLAGS */
907	{
908	/*
909	* Normal memory or ROM.
910	*/
911	case 0:
912	case MM_RAM_FLAGS_ROM:
913	case MM_RAM_FLAGS_ROM \| MM_RAM_FLAGS_RESERVED:
914	//case MM_RAM_FLAGS_ROM \| MM_RAM_FLAGS_MMIO2: /* = shadow */ - //MMIO2 isn't in the mask.
915	case MM_RAM_FLAGS_PHYSICAL_WRITE:
916	case MM_RAM_FLAGS_MMIO2 \| MM_RAM_FLAGS_PHYSICAL_WRITE: // MMIO2 isn't in the mask.
917	case MM_RAM_FLAGS_VIRTUAL_WRITE:
918	{
919	#ifdef IN_GC
920	void *pvSrc = NULL;
921	PGMGCDynMapHCPage(pVM, PGM_PAGE_GET_HCPHYS(pPage), &pvSrc);
922	pvSrc = (char *)pvSrc + (off & PAGE_OFFSET_MASK);
923	#else
924	void *pvSrc = PGMRAMRANGE_GETHCPTR(pCur, off)
925	#endif
926	cb = PAGE_SIZE - (off & PAGE_OFFSET_MASK);
927	if (cb >= cbRead)
928	{
929	#if defined(IN_RING3) && defined(PGM_PHYSMEMACCESS_CACHING)
930	if (cbRead <= 4 && !fGrabbedLock /* i.e. EMT */)
931	pgmPhysCacheAdd(pVM, &pVM->pgm.s.pgmphysreadcache, GCPhys, (uint8_t*)pvSrc);
932	#endif /* IN_RING3 && PGM_PHYSMEMACCESS_CACHING */
933	memcpy(pvBuf, pvSrc, cbRead);
934	goto end;
935	}
936	memcpy(pvBuf, pvSrc, cb);
937	break;
938	}
939
940	/*
941	* All reserved, nothing there.
942	*/
943	case MM_RAM_FLAGS_RESERVED:
944	cb = PAGE_SIZE - (off & PAGE_OFFSET_MASK);
945	if (cb >= cbRead)
946	{
947	memset(pvBuf, 0, cbRead);
948	goto end;
949	}
950	memset(pvBuf, 0, cb);
951	break;
952
953	/*
954	* Physical handler.
955	*/
956	case MM_RAM_FLAGS_PHYSICAL_ALL:
957	case MM_RAM_FLAGS_MMIO2 \| MM_RAM_FLAGS_PHYSICAL_ALL: /** r=bird: MMIO2 isn't in the mask! */
958	{
959	int rc = VINF_PGM_HANDLER_DO_DEFAULT;
960	cb = PAGE_SIZE - (off & PAGE_OFFSET_MASK);
961	#ifdef IN_RING3 /** @todo deal with this in GC and R0! */
962
963	/* find and call the handler */
964	PPGMPHYSHANDLER pNode = (PPGMPHYSHANDLER)RTAvlroGCPhysRangeGet(&pVM->pgm.s.pTreesHC->PhysHandlers, GCPhys);
965	if (pNode && pNode->pfnHandlerR3)
966	{
967	size_t cbRange = pNode->Core.KeyLast - GCPhys + 1;
968	if (cbRange < cb)
969	cb = cbRange;
970	if (cb > cbRead)
971	cb = cbRead;
972
973	void *pvSrc = PGMRAMRANGE_GETHCPTR(pCur, off)
974
975	/** @note Dangerous assumption that HC handlers don't do anything that really requires an EMT lock! */
976	rc = pNode->pfnHandlerR3(pVM, GCPhys, pvSrc, pvBuf, cb, PGMACCESSTYPE_READ, pNode->pvUserR3);
977	}
978	#endif /* IN_RING3 */
979	if (rc == VINF_PGM_HANDLER_DO_DEFAULT)
980	{
981	#ifdef IN_GC
982	void *pvSrc = NULL;
983	PGMGCDynMapHCPage(pVM, PGM_PAGE_GET_HCPHYS(pPage), &pvSrc);
984	pvSrc = (char *)pvSrc + (off & PAGE_OFFSET_MASK);
985	#else
986	void *pvSrc = PGMRAMRANGE_GETHCPTR(pCur, off)
987	#endif
988
989	if (cb >= cbRead)
990	{
991	memcpy(pvBuf, pvSrc, cbRead);
992	goto end;
993	}
994	memcpy(pvBuf, pvSrc, cb);
995	}
996	else if (cb >= cbRead)
997	goto end;
998	break;
999	}
1000
1001	case MM_RAM_FLAGS_VIRTUAL_ALL:
1002	{
1003	int rc = VINF_PGM_HANDLER_DO_DEFAULT;
1004	cb = PAGE_SIZE - (off & PAGE_OFFSET_MASK);
1005	#ifdef IN_RING3 /** @todo deal with this in GC and R0! */
1006	/* Search the whole tree for matching physical addresses (rather expensive!) */
1007	PPGMVIRTHANDLER pNode;
1008	unsigned iPage;
1009	int rc2 = pgmHandlerVirtualFindByPhysAddr(pVM, GCPhys, &pNode, &iPage);
1010	if (VBOX_SUCCESS(rc2) && pNode->pfnHandlerHC)
1011	{
1012	size_t cbRange = pNode->Core.KeyLast - GCPhys + 1;
1013	if (cbRange < cb)
1014	cb = cbRange;
1015	if (cb > cbRead)
1016	cb = cbRead;
1017	RTGCUINTPTR GCPtr = ((RTGCUINTPTR)pNode->GCPtr & PAGE_BASE_GC_MASK)
1018	+ (iPage << PAGE_SHIFT) + (off & PAGE_OFFSET_MASK);
1019
1020	void *pvSrc = PGMRAMRANGE_GETHCPTR(pCur, off)
1021
1022	/** @note Dangerous assumption that HC handlers don't do anything that really requires an EMT lock! */
1023	rc = pNode->pfnHandlerHC(pVM, (RTGCPTR)GCPtr, pvSrc, pvBuf, cb, PGMACCESSTYPE_READ, 0);
1024	}
1025	#endif /* IN_RING3 */
1026	if (rc == VINF_PGM_HANDLER_DO_DEFAULT)
1027	{
1028	#ifdef IN_GC
1029	void *pvSrc = NULL;
1030	PGMGCDynMapHCPage(pVM, PGM_PAGE_GET_HCPHYS(pPage), &pvSrc);
1031	pvSrc = (char *)pvSrc + (off & PAGE_OFFSET_MASK);
1032	#else
1033	void *pvSrc = PGMRAMRANGE_GETHCPTR(pCur, off)
1034	#endif
1035	if (cb >= cbRead)
1036	{
1037	memcpy(pvBuf, pvSrc, cbRead);
1038	goto end;
1039	}
1040	memcpy(pvBuf, pvSrc, cb);
1041	}
1042	else if (cb >= cbRead)
1043	goto end;
1044	break;
1045	}
1046
1047	/*
1048	* The rest needs to be taken more carefully.
1049	*/
1050	default:
1051	#if 1 /** @todo r=bird: Can you do this properly please. */
1052	/** @todo Try MMIO; quick hack */
1053	if (cbRead <= 4 && IOMMMIORead(pVM, GCPhys, (uint32_t *)pvBuf, cbRead) == VINF_SUCCESS)
1054	goto end;
1055	#endif
1056
1057	/** @todo fix me later. */
1058	AssertReleaseMsgFailed(("Unknown read at %VGp size %d implement the complex physical reading case %x\n",
1059	GCPhys, cbRead,
1060	pPage->HCPhys & (MM_RAM_FLAGS_RESERVED \| MM_RAM_FLAGS_MMIO \| MM_RAM_FLAGS_VIRTUAL_ALL \| MM_RAM_FLAGS_PHYSICAL_ALL \| MM_RAM_FLAGS_ROM))); /** @todo PAGE FLAGS */
1061	cb = PAGE_SIZE - (off & PAGE_OFFSET_MASK);
1062	break;
1063	}
1064	}
1065	cbRead -= cb;
1066	off += cb;
1067	pvBuf = (char *)pvBuf + cb;
1068	}
1069
1070	GCPhys = pCur->GCPhysLast + 1;
1071	}
1072	else
1073	{
1074	LogFlow(("PGMPhysRead: Unassigned %VGp size=%d\n", GCPhys, cbRead));
1075
1076	/*
1077	* Unassigned address space.
1078	*/
1079	size_t cb;
1080	if ( !pCur
1081	\|\| (cb = pCur->GCPhys - GCPhys) >= cbRead)
1082	{
1083	memset(pvBuf, 0, cbRead);
1084	goto end;
1085	}
1086
1087	memset(pvBuf, 0, cb);
1088	cbRead -= cb;
1089	pvBuf = (char *)pvBuf + cb;
1090	GCPhys += cb;
1091	}
1092	}
1093	end:
1094	#ifdef IN_RING3
1095	if (fGrabbedLock)
1096	pgmUnlock(pVM);
1097	#endif
1098	return;
1099	}
1100
1101	/**
1102	* Write to physical memory.
1103	*
1104	* This API respects access handlers and MMIO. Use PGMPhysReadGCPhys() if you
1105	* want to ignore those.
1106	*
1107	* @param pVM VM Handle.
1108	* @param GCPhys Physical address to write to.
1109	* @param pvBuf What to write.
1110	* @param cbWrite How many bytes to write.
1111	*/
1112	PGMDECL(void) PGMPhysWrite(PVM pVM, RTGCPHYS GCPhys, const void *pvBuf, size_t cbWrite)
1113	{
1114	#ifdef IN_RING3
1115	bool fGrabbedLock = false;
1116	#endif
1117
1118	AssertMsg(!pVM->pgm.s.fNoMorePhysWrites, ("Calling PGMPhysWrite after pgmR3Save()!\n"));
1119	AssertMsg(cbWrite > 0, ("don't even think about writing zero bytes!\n"));
1120	if (cbWrite == 0)
1121	return;
1122
1123	LogFlow(("PGMPhysWrite: %VGp %d\n", GCPhys, cbWrite));
1124
1125	#ifdef IN_RING3
1126	if (!VM_IS_EMT(pVM))
1127	{
1128	pgmLock(pVM);
1129	fGrabbedLock = true;
1130	}
1131	#endif
1132	/*
1133	* Copy loop on ram ranges.
1134	*/
1135	PPGMRAMRANGE pCur = CTXSUFF(pVM->pgm.s.pRamRanges);
1136	for (;;)
1137	{
1138	/* Find range. */
1139	while (pCur && GCPhys > pCur->GCPhysLast)
1140	pCur = CTXSUFF(pCur->pNext);
1141	/* Inside range or not? */
1142	if (pCur && GCPhys >= pCur->GCPhys)
1143	{
1144	/*
1145	* Must work our way thru this page by page.
1146	*/
1147	unsigned off = GCPhys - pCur->GCPhys;
1148	while (off < pCur->cb)
1149	{
1150	unsigned iPage = off >> PAGE_SHIFT;
1151	PPGMPAGE pPage = &pCur->aPages[iPage];
1152
1153	/* Physical chunk in dynamically allocated range not present? */
1154	if (RT_UNLIKELY(!PGM_PAGE_GET_HCPHYS(pPage)))
1155	{
1156	int rc;
1157	#ifdef IN_RING3
1158	if (fGrabbedLock)
1159	{
1160	pgmUnlock(pVM);
1161	rc = pgmr3PhysGrowRange(pVM, GCPhys);
1162	if (rc == VINF_SUCCESS)
1163	PGMPhysWrite(pVM, GCPhys, pvBuf, cbWrite); /* try again; can't assume pCur is still valid (paranoia) */
1164	return;
1165	}
1166	rc = pgmr3PhysGrowRange(pVM, GCPhys);
1167	#else
1168	rc = CTXALLMID(VMM, CallHost)(pVM, VMMCALLHOST_PGM_RAM_GROW_RANGE, GCPhys);
1169	#endif
1170	if (rc != VINF_SUCCESS)
1171	goto end;
1172	}
1173
1174	size_t cb;
1175	/** @todo r=bird: missing MM_RAM_FLAGS_ROM here, we shall not allow anyone to overwrite the ROM! */
1176	switch (pPage->HCPhys & (MM_RAM_FLAGS_RESERVED \| MM_RAM_FLAGS_MMIO \| MM_RAM_FLAGS_MMIO2 \| MM_RAM_FLAGS_VIRTUAL_ALL \| MM_RAM_FLAGS_VIRTUAL_WRITE \| MM_RAM_FLAGS_PHYSICAL_ALL \| MM_RAM_FLAGS_PHYSICAL_WRITE)) /** @todo PAGE FLAGS */
1177	{
1178	/*
1179	* Normal memory, MMIO2 or writable shadow ROM.
1180	*/
1181	case 0:
1182	case MM_RAM_FLAGS_MMIO2:
1183	case MM_RAM_FLAGS_ROM \| MM_RAM_FLAGS_MMIO2: /* shadow rom */
1184	{
1185	#ifdef IN_GC
1186	void *pvDst = NULL;
1187	PGMGCDynMapHCPage(pVM, PGM_PAGE_GET_HCPHYS(pPage), &pvDst);
1188	pvDst = (char *)pvDst + (off & PAGE_OFFSET_MASK);
1189	#else
1190	void *pvDst = PGMRAMRANGE_GETHCPTR(pCur, off)
1191	#endif
1192	cb = PAGE_SIZE - (off & PAGE_OFFSET_MASK);
1193	if (cb >= cbWrite)
1194	{
1195	#if defined(IN_RING3) && defined(PGM_PHYSMEMACCESS_CACHING)
1196	if (cbWrite <= 4 && !fGrabbedLock /* i.e. EMT */)
1197	pgmPhysCacheAdd(pVM, &pVM->pgm.s.pgmphyswritecache, GCPhys, (uint8_t*)pvDst);
1198	#endif /* IN_RING3 && PGM_PHYSMEMACCESS_CACHING */
1199	memcpy(pvDst, pvBuf, cbWrite);
1200	goto end;
1201	}
1202	memcpy(pvDst, pvBuf, cb);
1203	break;
1204	}
1205
1206	/*
1207	* All reserved, nothing there.
1208	*/
1209	case MM_RAM_FLAGS_RESERVED:
1210	case MM_RAM_FLAGS_RESERVED \| MM_RAM_FLAGS_MMIO2:
1211	cb = PAGE_SIZE - (off & PAGE_OFFSET_MASK);
1212	if (cb >= cbWrite)
1213	goto end;
1214	break;
1215
1216	/*
1217	* Physical handler.
1218	*/
1219	case MM_RAM_FLAGS_PHYSICAL_ALL:
1220	case MM_RAM_FLAGS_PHYSICAL_WRITE:
1221	case MM_RAM_FLAGS_MMIO2 \| MM_RAM_FLAGS_PHYSICAL_ALL:
1222	case MM_RAM_FLAGS_MMIO2 \| MM_RAM_FLAGS_PHYSICAL_WRITE:
1223	{
1224	int rc = VINF_PGM_HANDLER_DO_DEFAULT;
1225	cb = PAGE_SIZE - (off & PAGE_OFFSET_MASK);
1226	#ifdef IN_RING3 /** @todo deal with this in GC and R0! */
1227	/* find and call the handler */
1228	PPGMPHYSHANDLER pNode = (PPGMPHYSHANDLER)RTAvlroGCPhysRangeGet(&pVM->pgm.s.pTreesHC->PhysHandlers, GCPhys);
1229	if (pNode && pNode->pfnHandlerR3)
1230	{
1231	size_t cbRange = pNode->Core.KeyLast - GCPhys + 1;
1232	if (cbRange < cb)
1233	cb = cbRange;
1234	if (cb > cbWrite)
1235	cb = cbWrite;
1236
1237	void *pvDst = PGMRAMRANGE_GETHCPTR(pCur, off)
1238
1239	/** @note Dangerous assumption that HC handlers don't do anything that really requires an EMT lock! */
1240	rc = pNode->pfnHandlerR3(pVM, GCPhys, pvDst, (void *)pvBuf, cb, PGMACCESSTYPE_WRITE, pNode->pvUserR3);
1241	}
1242	#endif /* IN_RING3 */
1243	if (rc == VINF_PGM_HANDLER_DO_DEFAULT)
1244	{
1245	#ifdef IN_GC
1246	void *pvDst = NULL;
1247	PGMGCDynMapHCPage(pVM, PGM_PAGE_GET_HCPHYS(pPage), &pvDst);
1248	pvDst = (char *)pvDst + (off & PAGE_OFFSET_MASK);
1249	#else
1250	void *pvDst = PGMRAMRANGE_GETHCPTR(pCur, off)
1251	#endif
1252	if (cb >= cbWrite)
1253	{
1254	memcpy(pvDst, pvBuf, cbWrite);
1255	goto end;
1256	}
1257	memcpy(pvDst, pvBuf, cb);
1258	}
1259	else if (cb >= cbWrite)
1260	goto end;
1261	break;
1262	}
1263
1264	case MM_RAM_FLAGS_VIRTUAL_ALL:
1265	case MM_RAM_FLAGS_VIRTUAL_WRITE:
1266	{
1267	int rc = VINF_PGM_HANDLER_DO_DEFAULT;
1268	cb = PAGE_SIZE - (off & PAGE_OFFSET_MASK);
1269	#ifdef IN_RING3
1270	/** @todo deal with this in GC and R0! */
1271	/* Search the whole tree for matching physical addresses (rather expensive!) */
1272	PPGMVIRTHANDLER pNode;
1273	unsigned iPage;
1274	int rc2 = pgmHandlerVirtualFindByPhysAddr(pVM, GCPhys, &pNode, &iPage);
1275	if (VBOX_SUCCESS(rc2) && pNode->pfnHandlerHC)
1276	{
1277	size_t cbRange = pNode->Core.KeyLast - GCPhys + 1;
1278	if (cbRange < cb)
1279	cb = cbRange;
1280	if (cb > cbWrite)
1281	cb = cbWrite;
1282	RTGCUINTPTR GCPtr = ((RTGCUINTPTR)pNode->GCPtr & PAGE_BASE_GC_MASK)
1283	+ (iPage << PAGE_SHIFT) + (off & PAGE_OFFSET_MASK);
1284
1285	void *pvDst = PGMRAMRANGE_GETHCPTR(pCur, off)
1286
1287	/** @note Dangerous assumption that HC handlers don't do anything that really requires an EMT lock! */
1288	rc = pNode->pfnHandlerHC(pVM, (RTGCPTR)GCPtr, pvDst, (void *)pvBuf, cb, PGMACCESSTYPE_WRITE, 0);
1289	}
1290	#endif /* IN_RING3 */
1291	if (rc == VINF_PGM_HANDLER_DO_DEFAULT)
1292	{
1293	#ifdef IN_GC
1294	void *pvDst = NULL;
1295	PGMGCDynMapHCPage(pVM, PGM_PAGE_GET_HCPHYS(pPage), &pvDst);
1296	pvDst = (char *)pvDst + (off & PAGE_OFFSET_MASK);
1297	#else
1298	void *pvDst = PGMRAMRANGE_GETHCPTR(pCur, off)
1299	#endif
1300	if (cb >= cbWrite)
1301	{
1302	memcpy(pvDst, pvBuf, cbWrite);
1303	goto end;
1304	}
1305	memcpy(pvDst, pvBuf, cb);
1306	}
1307	else if (cb >= cbWrite)
1308	goto end;
1309	break;
1310	}
1311
1312	/*
1313	* Physical write handler + virtual write handler.
1314	* Consider this a quick workaround for the CSAM + shadow caching problem.
1315	*
1316	* We hand it to the shadow caching first since it requires the unchanged
1317	* data. CSAM will have to put up with it already being changed.
1318	*/
1319	case MM_RAM_FLAGS_PHYSICAL_WRITE \| MM_RAM_FLAGS_VIRTUAL_WRITE:
1320	{
1321	int rc = VINF_PGM_HANDLER_DO_DEFAULT;
1322	cb = PAGE_SIZE - (off & PAGE_OFFSET_MASK);
1323	#ifdef IN_RING3 /** @todo deal with this in GC and R0! */
1324	/* 1. The physical handler */
1325	PPGMPHYSHANDLER pPhysNode = (PPGMPHYSHANDLER)RTAvlroGCPhysRangeGet(&pVM->pgm.s.pTreesHC->PhysHandlers, GCPhys);
1326	if (pPhysNode && pPhysNode->pfnHandlerR3)
1327	{
1328	size_t cbRange = pPhysNode->Core.KeyLast - GCPhys + 1;
1329	if (cbRange < cb)
1330	cb = cbRange;
1331	if (cb > cbWrite)
1332	cb = cbWrite;
1333
1334	void *pvDst = PGMRAMRANGE_GETHCPTR(pCur, off)
1335
1336	/** @note Dangerous assumption that HC handlers don't do anything that really requires an EMT lock! */
1337	rc = pPhysNode->pfnHandlerR3(pVM, GCPhys, pvDst, (void *)pvBuf, cb, PGMACCESSTYPE_WRITE, pPhysNode->pvUserR3);
1338	}
1339
1340	/* 2. The virtual handler (will see incorrect data) */
1341	PPGMVIRTHANDLER pVirtNode;
1342	unsigned iPage;
1343	int rc2 = pgmHandlerVirtualFindByPhysAddr(pVM, GCPhys, &pVirtNode, &iPage);
1344	if (VBOX_SUCCESS(rc2) && pVirtNode->pfnHandlerHC)
1345	{
1346	size_t cbRange = pVirtNode->Core.KeyLast - GCPhys + 1;
1347	if (cbRange < cb)
1348	cb = cbRange;
1349	if (cb > cbWrite)
1350	cb = cbWrite;
1351	RTGCUINTPTR GCPtr = ((RTGCUINTPTR)pVirtNode->GCPtr & PAGE_BASE_GC_MASK)
1352	+ (iPage << PAGE_SHIFT) + (off & PAGE_OFFSET_MASK);
1353
1354	void *pvDst = PGMRAMRANGE_GETHCPTR(pCur, off)
1355
1356	/** @note Dangerous assumption that HC handlers don't do anything that really requires an EMT lock! */
1357	rc2 = pVirtNode->pfnHandlerHC(pVM, (RTGCPTR)GCPtr, pvDst, (void *)pvBuf, cb, PGMACCESSTYPE_WRITE, 0);
1358	if ( ( rc2 != VINF_PGM_HANDLER_DO_DEFAULT
1359	&& rc == VINF_PGM_HANDLER_DO_DEFAULT)
1360	\|\| ( VBOX_FAILURE(rc2)
1361	&& VBOX_SUCCESS(rc)))
1362	rc = rc2;
1363	}
1364	#endif /* IN_RING3 */
1365	if (rc == VINF_PGM_HANDLER_DO_DEFAULT)
1366	{
1367	#ifdef IN_GC
1368	void *pvDst = NULL;
1369	PGMGCDynMapHCPage(pVM, PGM_PAGE_GET_HCPHYS(pPage), &pvDst);
1370	pvDst = (char *)pvDst + (off & PAGE_OFFSET_MASK);
1371	#else
1372	void *pvDst = PGMRAMRANGE_GETHCPTR(pCur, off)
1373	#endif
1374	if (cb >= cbWrite)
1375	{
1376	memcpy(pvDst, pvBuf, cbWrite);
1377	goto end;
1378	}
1379	memcpy(pvDst, pvBuf, cb);
1380	}
1381	else if (cb >= cbWrite)
1382	goto end;
1383	break;
1384	}
1385
1386
1387	/*
1388	* The rest needs to be taken more carefully.
1389	*/
1390	default:
1391	#if 1 /** @todo r=bird: Can you do this properly please. */
1392	/** @todo Try MMIO; quick hack */
1393	if (cbWrite <= 4 && IOMMMIOWrite(pVM, GCPhys, (uint32_t )pvBuf, cbWrite) == VINF_SUCCESS)
1394	goto end;
1395	#endif
1396
1397	/** @todo fix me later. */
1398	AssertReleaseMsgFailed(("Unknown write at %VGp size %d implement the complex physical writing case %x\n",
1399	GCPhys, cbWrite,
1400	(pPage->HCPhys & (MM_RAM_FLAGS_RESERVED \| MM_RAM_FLAGS_MMIO \| MM_RAM_FLAGS_MMIO2 \| MM_RAM_FLAGS_VIRTUAL_ALL \| MM_RAM_FLAGS_VIRTUAL_WRITE \| MM_RAM_FLAGS_PHYSICAL_ALL \| MM_RAM_FLAGS_PHYSICAL_WRITE)))); /** @todo PAGE FLAGS */
1401	/* skip the write */
1402	cb = cbWrite;
1403	break;
1404	}
1405
1406	cbWrite -= cb;
1407	off += cb;
1408	pvBuf = (const char *)pvBuf + cb;
1409	}
1410
1411	GCPhys = pCur->GCPhysLast + 1;
1412	}
1413	else
1414	{
1415	/*
1416	* Unassigned address space.
1417	*/
1418	size_t cb;
1419	if ( !pCur
1420	\|\| (cb = pCur->GCPhys - GCPhys) >= cbWrite)
1421	goto end;
1422
1423	cbWrite -= cb;
1424	pvBuf = (const char *)pvBuf + cb;
1425	GCPhys += cb;
1426	}
1427	}
1428	end:
1429	#ifdef IN_RING3
1430	if (fGrabbedLock)
1431	pgmUnlock(pVM);
1432	#endif
1433	return;
1434	}
1435
1436	#ifndef IN_GC /* Ring 0 & 3 only */
1437
1438	/**
1439	* Read from guest physical memory by GC physical address, bypassing
1440	* MMIO and access handlers.
1441	*
1442	* @returns VBox status.
1443	* @param pVM VM handle.
1444	* @param pvDst The destination address.
1445	* @param GCPhysSrc The source address (GC physical address).
1446	* @param cb The number of bytes to read.
1447	*/
1448	PGMDECL(int) PGMPhysReadGCPhys(PVM pVM, void *pvDst, RTGCPHYS GCPhysSrc, size_t cb)
1449	{
1450	/*
1451	* Anything to be done?
1452	*/
1453	if (!cb)
1454	return VINF_SUCCESS;
1455
1456	/*
1457	* Loop ram ranges.
1458	*/
1459	for (PPGMRAMRANGE pRam = CTXSUFF(pVM->pgm.s.pRamRanges);
1460	pRam;
1461	pRam = pRam->CTXSUFF(pNext))
1462	{
1463	RTGCPHYS off = GCPhysSrc - pRam->GCPhys;
1464	if (off < pRam->cb)
1465	{
1466	if (pRam->fFlags & MM_RAM_FLAGS_DYNAMIC_ALLOC)
1467	{
1468	/* Copy page by page as we're not dealing with a linear HC range. */
1469	for (;;)
1470	{
1471	/* convert */
1472	void *pvSrc;
1473	int rc = pgmRamGCPhys2HCPtrWithRange(pVM, pRam, GCPhysSrc, &pvSrc);
1474	if (VBOX_FAILURE(rc))
1475	return rc;
1476
1477	/* copy */
1478	size_t cbRead = PAGE_SIZE - ((RTGCUINTPTR)GCPhysSrc & PAGE_OFFSET_MASK);
1479	if (cbRead >= cb)
1480	{
1481	memcpy(pvDst, pvSrc, cb);
1482	return VINF_SUCCESS;
1483	}
1484	memcpy(pvDst, pvSrc, cbRead);
1485
1486	/* next */
1487	cb -= cbRead;
1488	pvDst = (uint8_t *)pvDst + cbRead;
1489	GCPhysSrc += cbRead;
1490	}
1491	}
1492	else if (pRam->pvHC)
1493	{
1494	/* read */
1495	size_t cbRead = pRam->cb - off;
1496	if (cbRead >= cb)
1497	{
1498	memcpy(pvDst, (uint8_t *)pRam->pvHC + off, cb);
1499	return VINF_SUCCESS;
1500	}
1501	memcpy(pvDst, (uint8_t *)pRam->pvHC + off, cbRead);
1502
1503	/* next */
1504	cb -= cbRead;
1505	pvDst = (uint8_t *)pvDst + cbRead;
1506	GCPhysSrc += cbRead;
1507	}
1508	else
1509	return VERR_PGM_PHYS_PAGE_RESERVED;
1510	}
1511	else if (GCPhysSrc < pRam->GCPhysLast)
1512	break;
1513	}
1514	return VERR_PGM_INVALID_GC_PHYSICAL_ADDRESS;
1515	}
1516
1517
1518	/**
1519	* Write to guest physical memory referenced by GC pointer.
1520	* Write memory to GC physical address in guest physical memory.
1521	*
1522	* This will bypass MMIO and access handlers.
1523	*
1524	* @returns VBox status.
1525	* @param pVM VM handle.
1526	* @param GCPhysDst The GC physical address of the destination.
1527	* @param pvSrc The source buffer.
1528	* @param cb The number of bytes to write.
1529	*/
1530	PGMDECL(int) PGMPhysWriteGCPhys(PVM pVM, RTGCPHYS GCPhysDst, const void *pvSrc, size_t cb)
1531	{
1532	/*
1533	* Anything to be done?
1534	*/
1535	if (!cb)
1536	return VINF_SUCCESS;
1537
1538	LogFlow(("PGMPhysWriteGCPhys: %VGp %d\n", GCPhysDst, cb));
1539
1540	/*
1541	* Loop ram ranges.
1542	*/
1543	for (PPGMRAMRANGE pRam = CTXSUFF(pVM->pgm.s.pRamRanges);
1544	pRam;
1545	pRam = pRam->CTXSUFF(pNext))
1546	{
1547	RTGCPHYS off = GCPhysDst - pRam->GCPhys;
1548	if (off < pRam->cb)
1549	{
1550	#ifdef NEW_PHYS_CODE
1551	/** @todo PGMRamGCPhys2HCPtrWithRange. */
1552	#endif
1553	if (pRam->fFlags & MM_RAM_FLAGS_DYNAMIC_ALLOC)
1554	{
1555	/* Copy page by page as we're not dealing with a linear HC range. */
1556	for (;;)
1557	{
1558	/* convert */
1559	void *pvDst;
1560	int rc = pgmRamGCPhys2HCPtrWithRange(pVM, pRam, GCPhysDst, &pvDst);
1561	if (VBOX_FAILURE(rc))
1562	return rc;
1563
1564	/* copy */
1565	size_t cbWrite = PAGE_SIZE - ((RTGCUINTPTR)GCPhysDst & PAGE_OFFSET_MASK);
1566	if (cbWrite >= cb)
1567	{
1568	memcpy(pvDst, pvSrc, cb);
1569	return VINF_SUCCESS;
1570	}
1571	memcpy(pvDst, pvSrc, cbWrite);
1572
1573	/* next */
1574	cb -= cbWrite;
1575	pvSrc = (uint8_t *)pvSrc + cbWrite;
1576	GCPhysDst += cbWrite;
1577	}
1578	}
1579	else if (pRam->pvHC)
1580	{
1581	/* write */
1582	size_t cbWrite = pRam->cb - off;
1583	if (cbWrite >= cb)
1584	{
1585	memcpy((uint8_t *)pRam->pvHC + off, pvSrc, cb);
1586	return VINF_SUCCESS;
1587	}
1588	memcpy((uint8_t *)pRam->pvHC + off, pvSrc, cbWrite);
1589
1590	/* next */
1591	cb -= cbWrite;
1592	GCPhysDst += cbWrite;
1593	pvSrc = (uint8_t *)pvSrc + cbWrite;
1594	}
1595	else
1596	return VERR_PGM_PHYS_PAGE_RESERVED;
1597	}
1598	else if (GCPhysDst < pRam->GCPhysLast)
1599	break;
1600	}
1601	return VERR_PGM_INVALID_GC_PHYSICAL_ADDRESS;
1602	}
1603
1604
1605	/**
1606	* Read from guest physical memory referenced by GC pointer.
1607	*
1608	* This function uses the current CR3/CR0/CR4 of the guest and will
1609	* bypass access handlers and not set any accessed bits.
1610	*
1611	* @returns VBox status.
1612	* @param pVM VM handle.
1613	* @param pvDst The destination address.
1614	* @param GCPtrSrc The source address (GC pointer).
1615	* @param cb The number of bytes to read.
1616	*/
1617	PGMDECL(int) PGMPhysReadGCPtr(PVM pVM, void *pvDst, RTGCPTR GCPtrSrc, size_t cb)
1618	{
1619	/*
1620	* Anything to do?
1621	*/
1622	if (!cb)
1623	return VINF_SUCCESS;
1624
1625	/*
1626	* Optimize reads within a single page.
1627	*/
1628	if (((RTGCUINTPTR)GCPtrSrc & PAGE_OFFSET_MASK) + cb <= PAGE_SIZE)
1629	{
1630	void *pvSrc;
1631	int rc = PGMPhysGCPtr2HCPtr(pVM, GCPtrSrc, &pvSrc);
1632	if (VBOX_FAILURE(rc))
1633	return rc;
1634	memcpy(pvDst, pvSrc, cb);
1635	return VINF_SUCCESS;
1636	}
1637
1638	/*
1639	* Page by page.
1640	*/
1641	for (;;)
1642	{
1643	/* convert */
1644	void *pvSrc;
1645	int rc = PGMPhysGCPtr2HCPtr(pVM, GCPtrSrc, &pvSrc);
1646	if (VBOX_FAILURE(rc))
1647	return rc;
1648
1649	/* copy */
1650	size_t cbRead = PAGE_SIZE - ((RTGCUINTPTR)GCPtrSrc & PAGE_OFFSET_MASK);
1651	if (cbRead >= cb)
1652	{
1653	memcpy(pvDst, pvSrc, cb);
1654	return VINF_SUCCESS;
1655	}
1656	memcpy(pvDst, pvSrc, cbRead);
1657
1658	/* next */
1659	cb -= cbRead;
1660	pvDst = (uint8_t *)pvDst + cbRead;
1661	GCPtrSrc += cbRead;
1662	}
1663	}
1664
1665
1666	/**
1667	* Write to guest physical memory referenced by GC pointer.
1668	*
1669	* This function uses the current CR3/CR0/CR4 of the guest and will
1670	* bypass access handlers and not set dirty or accessed bits.
1671	*
1672	* @returns VBox status.
1673	* @param pVM VM handle.
1674	* @param GCPtrDst The destination address (GC pointer).
1675	* @param pvSrc The source address.
1676	* @param cb The number of bytes to write.
1677	*/
1678	PGMDECL(int) PGMPhysWriteGCPtr(PVM pVM, RTGCPTR GCPtrDst, const void *pvSrc, size_t cb)
1679	{
1680	/*
1681	* Anything to do?
1682	*/
1683	if (!cb)
1684	return VINF_SUCCESS;
1685
1686	LogFlow(("PGMPhysWriteGCPtr: %VGv %d\n", GCPtrDst, cb));
1687
1688	/*
1689	* Optimize writes within a single page.
1690	*/
1691	if (((RTGCUINTPTR)GCPtrDst & PAGE_OFFSET_MASK) + cb <= PAGE_SIZE)
1692	{
1693	void *pvDst;
1694	int rc = PGMPhysGCPtr2HCPtr(pVM, GCPtrDst, &pvDst);
1695	if (VBOX_FAILURE(rc))
1696	return rc;
1697	memcpy(pvDst, pvSrc, cb);
1698	return VINF_SUCCESS;
1699	}
1700
1701	/*
1702	* Page by page.
1703	*/
1704	for (;;)
1705	{
1706	/* convert */
1707	void *pvDst;
1708	int rc = PGMPhysGCPtr2HCPtr(pVM, GCPtrDst, &pvDst);
1709	if (VBOX_FAILURE(rc))
1710	return rc;
1711
1712	/* copy */
1713	size_t cbWrite = PAGE_SIZE - ((RTGCUINTPTR)GCPtrDst & PAGE_OFFSET_MASK);
1714	if (cbWrite >= cb)
1715	{
1716	memcpy(pvDst, pvSrc, cb);
1717	return VINF_SUCCESS;
1718	}
1719	memcpy(pvDst, pvSrc, cbWrite);
1720
1721	/* next */
1722	cb -= cbWrite;
1723	pvSrc = (uint8_t *)pvSrc + cbWrite;
1724	GCPtrDst += cbWrite;
1725	}
1726	}
1727
1728	/**
1729	* Read from guest physical memory referenced by GC pointer.
1730	*
1731	* This function uses the current CR3/CR0/CR4 of the guest and will
1732	* respect access handlers and set accessed bits.
1733	*
1734	* @returns VBox status.
1735	* @param pVM VM handle.
1736	* @param pvDst The destination address.
1737	* @param GCPtrSrc The source address (GC pointer).
1738	* @param cb The number of bytes to read.
1739	*/
1740	/** @todo use the PGMPhysReadGCPtr name and rename the unsafe one to something appropriate */
1741	PGMDECL(int) PGMPhysReadGCPtrSafe(PVM pVM, void *pvDst, RTGCPTR GCPtrSrc, size_t cb)
1742	{
1743	RTGCPHYS GCPhys;
1744	int rc;
1745
1746	/*
1747	* Anything to do?
1748	*/
1749	if (!cb)
1750	return VINF_SUCCESS;
1751
1752	LogFlow(("PGMPhysReadGCPtrSafe: %VGv %d\n", GCPtrSrc, cb));
1753
1754	/*
1755	* Optimize reads within a single page.
1756	*/
1757	if (((RTGCUINTPTR)GCPtrSrc & PAGE_OFFSET_MASK) + cb <= PAGE_SIZE)
1758	{
1759	/* Convert virtual to physical address */
1760	rc = PGMPhysGCPtr2GCPhys(pVM, GCPtrSrc, &GCPhys);
1761	AssertRCReturn(rc, rc);
1762
1763	/* mark the guest page as accessed. */
1764	rc = PGMGstModifyPage(pVM, GCPtrSrc, 1, X86_PTE_A, ~(uint64_t)(X86_PTE_A));
1765	AssertRC(rc);
1766
1767	PGMPhysRead(pVM, GCPhys, pvDst, cb);
1768	return VINF_SUCCESS;
1769	}
1770
1771	/*
1772	* Page by page.
1773	*/
1774	for (;;)
1775	{
1776	/* Convert virtual to physical address */
1777	rc = PGMPhysGCPtr2GCPhys(pVM, GCPtrSrc, &GCPhys);
1778	AssertRCReturn(rc, rc);
1779
1780	/* mark the guest page as accessed. */
1781	int rc = PGMGstModifyPage(pVM, GCPtrSrc, 1, X86_PTE_A, ~(uint64_t)(X86_PTE_A));
1782	AssertRC(rc);
1783
1784	/* copy */
1785	size_t cbRead = PAGE_SIZE - ((RTGCUINTPTR)GCPtrSrc & PAGE_OFFSET_MASK);
1786	if (cbRead >= cb)
1787	{
1788	PGMPhysRead(pVM, GCPhys, pvDst, cb);
1789	return VINF_SUCCESS;
1790	}
1791	PGMPhysRead(pVM, GCPhys, pvDst, cbRead);
1792
1793	/* next */
1794	cb -= cbRead;
1795	pvDst = (uint8_t *)pvDst + cbRead;
1796	GCPtrSrc += cbRead;
1797	}
1798	}
1799
1800
1801	/**
1802	* Write to guest physical memory referenced by GC pointer.
1803	*
1804	* This function uses the current CR3/CR0/CR4 of the guest and will
1805	* respect access handlers and set dirty and accessed bits.
1806	*
1807	* @returns VBox status.
1808	* @param pVM VM handle.
1809	* @param GCPtrDst The destination address (GC pointer).
1810	* @param pvSrc The source address.
1811	* @param cb The number of bytes to write.
1812	*/
1813	/** @todo use the PGMPhysWriteGCPtr name and rename the unsafe one to something appropriate */
1814	PGMDECL(int) PGMPhysWriteGCPtrSafe(PVM pVM, RTGCPTR GCPtrDst, const void *pvSrc, size_t cb)
1815	{
1816	RTGCPHYS GCPhys;
1817	int rc;
1818
1819	/*
1820	* Anything to do?
1821	*/
1822	if (!cb)
1823	return VINF_SUCCESS;
1824
1825	LogFlow(("PGMPhysWriteGCPtrSafe: %VGv %d\n", GCPtrDst, cb));
1826
1827	/*
1828	* Optimize writes within a single page.
1829	*/
1830	if (((RTGCUINTPTR)GCPtrDst & PAGE_OFFSET_MASK) + cb <= PAGE_SIZE)
1831	{
1832	/* Convert virtual to physical address */
1833	rc = PGMPhysGCPtr2GCPhys(pVM, GCPtrDst, &GCPhys);
1834	AssertRCReturn(rc, rc);
1835
1836	/* mark the guest page as accessed and dirty. */
1837	rc = PGMGstModifyPage(pVM, GCPtrDst, 1, X86_PTE_A \| X86_PTE_D, ~(uint64_t)(X86_PTE_A \| X86_PTE_D));
1838	AssertRC(rc);
1839
1840	PGMPhysWrite(pVM, GCPhys, pvSrc, cb);
1841	return VINF_SUCCESS;
1842	}
1843
1844	/*
1845	* Page by page.
1846	*/
1847	for (;;)
1848	{
1849	/* Convert virtual to physical address */
1850	rc = PGMPhysGCPtr2GCPhys(pVM, GCPtrDst, &GCPhys);
1851	AssertRCReturn(rc, rc);
1852
1853	/* mark the guest page as accessed and dirty. */
1854	rc = PGMGstModifyPage(pVM, GCPtrDst, 1, X86_PTE_A \| X86_PTE_D, ~(uint64_t)(X86_PTE_A \| X86_PTE_D));
1855	AssertRC(rc);
1856
1857	/* copy */
1858	size_t cbWrite = PAGE_SIZE - ((RTGCUINTPTR)GCPtrDst & PAGE_OFFSET_MASK);
1859	if (cbWrite >= cb)
1860	{
1861	PGMPhysWrite(pVM, GCPhys, pvSrc, cb);
1862	return VINF_SUCCESS;
1863	}
1864	PGMPhysWrite(pVM, GCPhys, pvSrc, cbWrite);
1865
1866	/* next */
1867	cb -= cbWrite;
1868	pvSrc = (uint8_t *)pvSrc + cbWrite;
1869	GCPtrDst += cbWrite;
1870	}
1871	}
1872
1873	/**
1874	* Write to guest physical memory referenced by GC pointer and update the PTE.
1875	*
1876	* This function uses the current CR3/CR0/CR4 of the guest and will
1877	* bypass access handlers and set any dirty and accessed bits in the PTE.
1878	*
1879	* If you don't want to set the dirty bit, use PGMPhysWriteGCPtr().
1880	*
1881	* @returns VBox status.
1882	* @param pVM VM handle.
1883	* @param GCPtrDst The destination address (GC pointer).
1884	* @param pvSrc The source address.
1885	* @param cb The number of bytes to write.
1886	*/
1887	PGMDECL(int) PGMPhysWriteGCPtrDirty(PVM pVM, RTGCPTR GCPtrDst, const void *pvSrc, size_t cb)
1888	{
1889	/*
1890	* Anything to do?
1891	*/
1892	if (!cb)
1893	return VINF_SUCCESS;
1894
1895	/*
1896	* Optimize writes within a single page.
1897	*/
1898	if (((RTGCUINTPTR)GCPtrDst & PAGE_OFFSET_MASK) + cb <= PAGE_SIZE)
1899	{
1900	void *pvDst;
1901	int rc = PGMPhysGCPtr2HCPtr(pVM, GCPtrDst, &pvDst);
1902	if (VBOX_FAILURE(rc))
1903	return rc;
1904	memcpy(pvDst, pvSrc, cb);
1905	rc = PGMGstModifyPage(pVM, GCPtrDst, cb, X86_PTE_A \| X86_PTE_D, ~(uint64_t)(X86_PTE_A \| X86_PTE_D));
1906	AssertRC(rc);
1907	return VINF_SUCCESS;
1908	}
1909
1910	/*
1911	* Page by page.
1912	*/
1913	for (;;)
1914	{
1915	/* convert */
1916	void *pvDst;
1917	int rc = PGMPhysGCPtr2HCPtr(pVM, GCPtrDst, &pvDst);
1918	if (VBOX_FAILURE(rc))
1919	return rc;
1920
1921	/* mark the guest page as accessed and dirty. */
1922	rc = PGMGstModifyPage(pVM, GCPtrDst, 1, X86_PTE_A \| X86_PTE_D, ~(uint64_t)(X86_PTE_A \| X86_PTE_D));
1923	AssertRC(rc);
1924
1925	/* copy */
1926	size_t cbWrite = PAGE_SIZE - ((RTGCUINTPTR)GCPtrDst & PAGE_OFFSET_MASK);
1927	if (cbWrite >= cb)
1928	{
1929	memcpy(pvDst, pvSrc, cb);
1930	return VINF_SUCCESS;
1931	}
1932	memcpy(pvDst, pvSrc, cbWrite);
1933
1934	/* next */
1935	cb -= cbWrite;
1936	GCPtrDst += cbWrite;
1937	pvSrc = (char *)pvSrc + cbWrite;
1938	}
1939	}
1940
1941	#endif /* !IN_GC */
1942
1943
1944
1945	/**
1946	* Performs a read of guest virtual memory for instruction emulation.
1947	*
1948	* This will check permissions, raise exceptions and update the access bits.
1949	*
1950	* The current implementation will bypass all access handlers. It may later be
1951	* changed to at least respect MMIO.
1952	*
1953	*
1954	* @returns VBox status code suitable to scheduling.
1955	* @retval VINF_SUCCESS if the read was performed successfully.
1956	* @retval VINF_EM_RAW_GUEST_TRAP if an exception was raised but not dispatched yet.
1957	* @retval VINF_TRPM_XCPT_DISPATCHED if an exception was raised and dispatched.
1958	*
1959	* @param pVM The VM handle.
1960	* @param pCtxCore The context core.
1961	* @param pvDst Where to put the bytes we've read.
1962	* @param GCPtrSrc The source address.
1963	* @param cb The number of bytes to read. Not more than a page.
1964	*
1965	* @remark This function will dynamically map physical pages in GC. This may unmap
1966	* mappings done by the caller. Be careful!
1967	*/
1968	PGMDECL(int) PGMPhysInterpretedRead(PVM pVM, PCPUMCTXCORE pCtxCore, void *pvDst, RTGCUINTPTR GCPtrSrc, size_t cb)
1969	{
1970	Assert(cb <= PAGE_SIZE);
1971
1972	/** @todo r=bird: This isn't perfect!
1973	* -# It's not checking for reserved bits being 1.
1974	* -# It's not correctly dealing with the access bit.
1975	* -# It's not respecting MMIO memory or any other access handlers.
1976	*/
1977	/*
1978	* 1. Translate virtual to physical. This may fault.
1979	* 2. Map the physical address.
1980	* 3. Do the read operation.
1981	* 4. Set access bits if required.
1982	*/
1983	int rc;
1984	unsigned cb1 = PAGE_SIZE - (GCPtrSrc & PAGE_OFFSET_MASK);
1985	if (cb <= cb1)
1986	{
1987	/*
1988	* Not crossing pages.
1989	*/
1990	RTGCPHYS GCPhys;
1991	uint64_t fFlags;
1992	rc = PGM_GST_PFN(GetPage,pVM)(pVM, GCPtrSrc, &fFlags, &GCPhys);
1993	if (VBOX_SUCCESS(rc))
1994	{
1995	/** @todo we should check reserved bits ... */
1996	void *pvSrc;
1997	rc = PGM_GCPHYS_2_PTR(pVM, GCPhys, &pvSrc);
1998	switch (rc)
1999	{
2000	case VINF_SUCCESS:
2001	Log(("PGMPhysInterpretedRead: pvDst=%p pvSrc=%p cb=%d\n", pvDst, (uint8_t *)pvSrc + (GCPtrSrc & PAGE_OFFSET_MASK), cb));
2002	memcpy(pvDst, (uint8_t *)pvSrc + (GCPtrSrc & PAGE_OFFSET_MASK), cb);
2003	break;
2004	case VERR_PGM_PHYS_PAGE_RESERVED:
2005	case VERR_PGM_INVALID_GC_PHYSICAL_ADDRESS:
2006	memset(pvDst, 0, cb);
2007	break;
2008	default:
2009	return rc;
2010	}
2011
2012	/** @todo access bit emulation isn't 100% correct. */
2013	if (!(fFlags & X86_PTE_A))
2014	{
2015	rc = PGM_GST_PFN(ModifyPage,pVM)(pVM, GCPtrSrc, 1, X86_PTE_A, ~(uint64_t)X86_PTE_A);
2016	AssertRC(rc);
2017	}
2018	return VINF_SUCCESS;
2019	}
2020	}
2021	else
2022	{
2023	/*
2024	* Crosses pages.
2025	*/
2026	unsigned cb2 = cb - cb1;
2027	uint64_t fFlags1;
2028	RTGCPHYS GCPhys1;
2029	uint64_t fFlags2;
2030	RTGCPHYS GCPhys2;
2031	rc = PGM_GST_PFN(GetPage,pVM)(pVM, GCPtrSrc, &fFlags1, &GCPhys1);
2032	if (VBOX_SUCCESS(rc))
2033	rc = PGM_GST_PFN(GetPage,pVM)(pVM, GCPtrSrc + cb1, &fFlags2, &GCPhys2);
2034	if (VBOX_SUCCESS(rc))
2035	{
2036	/** @todo we should check reserved bits ... */
2037	AssertMsgFailed(("cb=%d cb1=%d cb2=%d GCPtrSrc=%VGv\n", cb, cb1, cb2, GCPtrSrc));
2038	void *pvSrc1;
2039	rc = PGM_GCPHYS_2_PTR(pVM, GCPhys1, &pvSrc1);
2040	switch (rc)
2041	{
2042	case VINF_SUCCESS:
2043	memcpy(pvDst, (uint8_t *)pvSrc1 + (GCPtrSrc & PAGE_OFFSET_MASK), cb1);
2044	break;
2045	case VERR_PGM_INVALID_GC_PHYSICAL_ADDRESS:
2046	memset(pvDst, 0, cb1);
2047	break;
2048	default:
2049	return rc;
2050	}
2051
2052	void *pvSrc2;
2053	rc = PGM_GCPHYS_2_PTR(pVM, GCPhys2, &pvSrc2);
2054	switch (rc)
2055	{
2056	case VINF_SUCCESS:
2057	memcpy((uint8_t *)pvDst + cb2, pvSrc2, cb2);
2058	break;
2059	case VERR_PGM_INVALID_GC_PHYSICAL_ADDRESS:
2060	memset((uint8_t *)pvDst + cb2, 0, cb2);
2061	break;
2062	default:
2063	return rc;
2064	}
2065
2066	if (!(fFlags1 & X86_PTE_A))
2067	{
2068	rc = PGM_GST_PFN(ModifyPage,pVM)(pVM, GCPtrSrc, 1, X86_PTE_A, ~(uint64_t)X86_PTE_A);
2069	AssertRC(rc);
2070	}
2071	if (!(fFlags2 & X86_PTE_A))
2072	{
2073	rc = PGM_GST_PFN(ModifyPage,pVM)(pVM, GCPtrSrc + cb1, 1, X86_PTE_A, ~(uint64_t)X86_PTE_A);
2074	AssertRC(rc);
2075	}
2076	return VINF_SUCCESS;
2077	}
2078	}
2079
2080	/*
2081	* Raise a #PF.
2082	*/
2083	uint32_t uErr;
2084
2085	/* Get the current privilege level. */
2086	uint32_t cpl = CPUMGetGuestCPL(pVM, pCtxCore);
2087	switch (rc)
2088	{
2089	case VINF_SUCCESS:
2090	uErr = (cpl >= 2) ? X86_TRAP_PF_RSVD \| X86_TRAP_PF_US : X86_TRAP_PF_RSVD;
2091	break;
2092
2093	case VERR_PAGE_NOT_PRESENT:
2094	case VERR_PAGE_TABLE_NOT_PRESENT:
2095	uErr = (cpl >= 2) ? X86_TRAP_PF_US : 0;
2096	break;
2097
2098	default:
2099	AssertMsgFailed(("rc=%Vrc GCPtrSrc=%VGv cb=%#x\n", rc, GCPtrSrc, cb));
2100	return rc;
2101	}
2102	Log(("PGMPhysInterpretedRead: GCPtrSrc=%VGv cb=%#x -> #PF(%#x)\n", GCPtrSrc, cb, uErr));
2103	return TRPMRaiseXcptErrCR2(pVM, pCtxCore, X86_XCPT_PF, uErr, GCPtrSrc);
2104	}
2105
2106	/// @todo PGMDECL(int) PGMPhysInterpretedWrite(PVM pVM, PCPUMCTXCORE pCtxCore, RTGCPTR GCPtrDst, const void *pvSrc, size_t cb)
2107

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

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

Download in other formats: