PGMPhys.cpp@ 4738

Last change on this file since 4738 was 4738, checked in by vboxsync, 17 years ago
more new phys code.
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 30.3 KB

Line
1	/* $Id: PGMPhys.cpp 4738 2007-09-12 16:00:54Z 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
19	/*******************************************************************************
20	* Header Files *
21	*******************************************************************************/
22	#define LOG_GROUP LOG_GROUP_PGM
23	#include <VBox/pgm.h>
24	#include <VBox/cpum.h>
25	#include <VBox/iom.h>
26	#include <VBox/sup.h>
27	#include <VBox/mm.h>
28	#include <VBox/stam.h>
29	#include <VBox/rem.h>
30	#include <VBox/csam.h>
31	#include "PGMInternal.h"
32	#include <VBox/vm.h>
33	#include <VBox/dbg.h>
34	#include <VBox/param.h>
35	#include <VBox/err.h>
36	#include <iprt/assert.h>
37	#include <iprt/alloc.h>
38	#include <iprt/asm.h>
39	#include <VBox/log.h>
40	#include <iprt/thread.h>
41	#include <iprt/string.h>
42
43
44
45	/*
46	* PGMR3PhysReadByte/Word/Dword
47	* PGMR3PhysWriteByte/Word/Dword
48	*/
49
50	#define PGMPHYSFN_READNAME PGMR3PhysReadByte
51	#define PGMPHYSFN_WRITENAME PGMR3PhysWriteByte
52	#define PGMPHYS_DATASIZE 1
53	#define PGMPHYS_DATATYPE uint8_t
54	#include "PGMPhys.h"
55
56	#define PGMPHYSFN_READNAME PGMR3PhysReadWord
57	#define PGMPHYSFN_WRITENAME PGMR3PhysWriteWord
58	#define PGMPHYS_DATASIZE 2
59	#define PGMPHYS_DATATYPE uint16_t
60	#include "PGMPhys.h"
61
62	#define PGMPHYSFN_READNAME PGMR3PhysReadDword
63	#define PGMPHYSFN_WRITENAME PGMR3PhysWriteDword
64	#define PGMPHYS_DATASIZE 4
65	#define PGMPHYS_DATATYPE uint32_t
66	#include "PGMPhys.h"
67
68
69
70
71	/**
72	* Interface that the MMR3RamRegister(), MMR3RomRegister() and MMIO handler
73	* registration APIs calls to inform PGM about memory registrations.
74	*
75	* It registers the physical memory range with PGM. MM is responsible
76	* for the toplevel things - allocation and locking - while PGM is taking
77	* care of all the details and implements the physical address space virtualization.
78	*
79	* @returns VBox status.
80	* @param pVM The VM handle.
81	* @param pvRam HC virtual address of the RAM range. (page aligned)
82	* @param GCPhys GC physical address of the RAM range. (page aligned)
83	* @param cb Size of the RAM range. (page aligned)
84	* @param fFlags Flags, MM_RAM_*.
85	* @param paPages Pointer an array of physical page descriptors.
86	* @param pszDesc Description string.
87	*/
88	PGMR3DECL(int) PGMR3PhysRegister(PVM pVM, void pvRam, RTGCPHYS GCPhys, size_t cb, unsigned fFlags, const SUPPAGE paPages, const char *pszDesc)
89	{
90	/*
91	* Validate input.
92	* (Not so important because callers are only MMR3PhysRegister()
93	* and PGMR3HandlerPhysicalRegisterEx(), but anyway...)
94	*/
95	Log(("PGMR3PhysRegister %08X %x bytes flags %x %s\n", GCPhys, cb, fFlags, pszDesc));
96
97	Assert((fFlags & (MM_RAM_FLAGS_RESERVED \| MM_RAM_FLAGS_MMIO \| MM_RAM_FLAGS_DYNAMIC_ALLOC)) \|\| paPages);
98	/Assert(!(fFlags & MM_RAM_FLAGS_RESERVED) \|\| !paPages);/
99	Assert((fFlags == (MM_RAM_FLAGS_RESERVED \| MM_RAM_FLAGS_MMIO)) \|\| (fFlags & MM_RAM_FLAGS_DYNAMIC_ALLOC) \|\| pvRam);
100	/Assert(!(fFlags & MM_RAM_FLAGS_RESERVED) \|\| !pvRam);/
101	Assert(!(fFlags & ~0xfff));
102	Assert(RT_ALIGN_Z(cb, PAGE_SIZE) == cb && cb);
103	Assert(RT_ALIGN_P(pvRam, PAGE_SIZE) == pvRam);
104	Assert(!(fFlags & ~(MM_RAM_FLAGS_RESERVED \| MM_RAM_FLAGS_ROM \| MM_RAM_FLAGS_MMIO \| MM_RAM_FLAGS_MMIO2 \| MM_RAM_FLAGS_DYNAMIC_ALLOC)));
105	Assert(RT_ALIGN_T(GCPhys, PAGE_SIZE, RTGCPHYS) == GCPhys);
106	RTGCPHYS GCPhysLast = GCPhys + (cb - 1);
107	if (GCPhysLast < GCPhys)
108	{
109	AssertMsgFailed(("The range wraps! GCPhys=%VGp cb=%#x\n", GCPhys, cb));
110	return VERR_INVALID_PARAMETER;
111	}
112
113	/*
114	* Find range location and check for conflicts.
115	*/
116	PPGMRAMRANGE pPrev = NULL;
117	PPGMRAMRANGE pCur = pVM->pgm.s.pRamRangesHC;
118	while (pCur)
119	{
120	if (GCPhys <= pCur->GCPhysLast && GCPhysLast >= pCur->GCPhys)
121	{
122	AssertMsgFailed(("Conflict! This cannot happen!\n"));
123	return VERR_PGM_RAM_CONFLICT;
124	}
125	if (GCPhysLast < pCur->GCPhys)
126	break;
127
128	/* next */
129	pPrev = pCur;
130	pCur = pCur->pNextHC;
131	}
132
133	/*
134	* Allocate RAM range.
135	* Small ranges are allocated from the heap, big ones have separate mappings.
136	*/
137	size_t cbRam = RT_OFFSETOF(PGMRAMRANGE, aPages[cb >> PAGE_SHIFT]);
138	PPGMRAMRANGE pNew;
139	RTGCPTR GCPtrNew;
140	int rc;
141	if (cbRam > PAGE_SIZE / 2)
142	{ /* large */
143	cbRam = RT_ALIGN_Z(cbRam, PAGE_SIZE);
144	rc = SUPPageAlloc(cbRam >> PAGE_SHIFT, (void **)&pNew);
145	if (VBOX_SUCCESS(rc))
146	{
147	rc = MMR3HyperMapHCRam(pVM, pNew, cbRam, true, pszDesc, &GCPtrNew);
148	if (VBOX_SUCCESS(rc))
149	{
150	Assert(MMHyperHC2GC(pVM, pNew) == GCPtrNew);
151	rc = MMR3HyperReserve(pVM, PAGE_SIZE, "fence", NULL);
152	}
153	else
154	{
155	AssertMsgFailed(("MMR3HyperMapHCRam(,,%#x,,,) -> %Vrc\n", cbRam, rc));
156	SUPPageFree(pNew, cbRam >> PAGE_SHIFT);
157	}
158	}
159	else
160	AssertMsgFailed(("SUPPageAlloc(%#x,,) -> %Vrc\n", cbRam >> PAGE_SHIFT, rc));
161	}
162	else
163	{ /* small */
164	rc = MMHyperAlloc(pVM, cbRam, 16, MM_TAG_PGM, (void **)&pNew);
165	if (VBOX_SUCCESS(rc))
166	GCPtrNew = MMHyperHC2GC(pVM, pNew);
167	else
168	AssertMsgFailed(("MMHyperAlloc(,%#x,,,) -> %Vrc\n", cbRam, cb));
169	}
170	if (VBOX_SUCCESS(rc))
171	{
172	/*
173	* Initialize the range.
174	*/
175	pNew->pvHC = pvRam;
176	pNew->GCPhys = GCPhys;
177	pNew->GCPhysLast = GCPhysLast;
178	pNew->cb = cb;
179	pNew->fFlags = fFlags;
180	pNew->pavHCChunkHC = NULL;
181	pNew->pavHCChunkGC = 0;
182
183	unsigned iPage = cb >> PAGE_SHIFT;
184	if (paPages)
185	{
186	while (iPage-- > 0)
187	{
188	pNew->aPages[iPage].HCPhys = (paPages[iPage].Phys & X86_PTE_PAE_PG_MASK) \| fFlags; /** @todo PAGE FLAGS */
189	pNew->aPages[iPage].u2State = PGM_PAGE_STATE_ALLOCATED;
190	pNew->aPages[iPage].fWrittenTo = 0;
191	pNew->aPages[iPage].fSomethingElse = 0;
192	pNew->aPages[iPage].idPage = 0;
193	pNew->aPages[iPage].u32B = 0;
194	}
195	}
196	else if (fFlags & MM_RAM_FLAGS_DYNAMIC_ALLOC)
197	{
198	/* Allocate memory for chunk to HC ptr lookup array. */
199	rc = MMHyperAlloc(pVM, (cb >> PGM_DYNAMIC_CHUNK_SHIFT) * sizeof(void ), 16, MM_TAG_PGM, (void *)&pNew->pavHCChunkHC);
200	AssertMsgReturn(rc == VINF_SUCCESS, ("MMHyperAlloc(,%#x,,,) -> %Vrc\n", cbRam, cb), rc);
201
202	pNew->pavHCChunkGC = MMHyperHC2GC(pVM, pNew->pavHCChunkHC);
203	Assert(pNew->pavHCChunkGC);
204
205	/* Physical memory will be allocated on demand. */
206	while (iPage-- > 0)
207	{
208	pNew->aPages[iPage].HCPhys = fFlags; /** @todo PAGE FLAGS */
209	pNew->aPages[iPage].u2State = PGM_PAGE_STATE_ZERO;
210	pNew->aPages[iPage].fWrittenTo = 0;
211	pNew->aPages[iPage].fSomethingElse = 0;
212	pNew->aPages[iPage].idPage = 0;
213	pNew->aPages[iPage].u32B = 0;
214	}
215	}
216	else
217	{
218	Assert(fFlags == (MM_RAM_FLAGS_RESERVED \| MM_RAM_FLAGS_MMIO));
219	RTHCPHYS HCPhysDummyPage = (MMR3PageDummyHCPhys(pVM) & X86_PTE_PAE_PG_MASK) \| fFlags; /** @todo PAGE FLAGS */
220	while (iPage-- > 0)
221	{
222	pNew->aPages[iPage].HCPhys = HCPhysDummyPage; /** @todo PAGE FLAGS */
223	pNew->aPages[iPage].u2State = PGM_PAGE_STATE_ZERO;
224	pNew->aPages[iPage].fWrittenTo = 0;
225	pNew->aPages[iPage].fSomethingElse = 0;
226	pNew->aPages[iPage].idPage = 0;
227	pNew->aPages[iPage].u32B = 0;
228	}
229	}
230
231	/*
232	* Insert the new RAM range.
233	*/
234	pgmLock(pVM);
235	pNew->pNextHC = pCur;
236	pNew->pNextGC = pCur ? MMHyperHC2GC(pVM, pCur) : 0;
237	if (pPrev)
238	{
239	pPrev->pNextHC = pNew;
240	pPrev->pNextGC = GCPtrNew;
241	}
242	else
243	{
244	pVM->pgm.s.pRamRangesHC = pNew;
245	pVM->pgm.s.pRamRangesGC = GCPtrNew;
246	}
247	pgmUnlock(pVM);
248	}
249	return rc;
250	}
251
252
253	/**
254	* Register a chunk of a the physical memory range with PGM. MM is responsible
255	* for the toplevel things - allocation and locking - while PGM is taking
256	* care of all the details and implements the physical address space virtualization.
257	*
258	*
259	* @returns VBox status.
260	* @param pVM The VM handle.
261	* @param pvRam HC virtual address of the RAM range. (page aligned)
262	* @param GCPhys GC physical address of the RAM range. (page aligned)
263	* @param cb Size of the RAM range. (page aligned)
264	* @param fFlags Flags, MM_RAM_*.
265	* @param paPages Pointer an array of physical page descriptors.
266	* @param pszDesc Description string.
267	*/
268	PGMR3DECL(int) PGMR3PhysRegisterChunk(PVM pVM, void pvRam, RTGCPHYS GCPhys, size_t cb, unsigned fFlags, const SUPPAGE paPages, const char *pszDesc)
269	{
270	#ifdef PGM_DYNAMIC_RAM_ALLOC
271	NOREF(pszDesc);
272
273	/*
274	* Validate input.
275	* (Not so important because callers are only MMR3PhysRegister()
276	* and PGMR3HandlerPhysicalRegisterEx(), but anyway...)
277	*/
278	Log(("PGMR3PhysRegisterChunk %08X %x bytes flags %x %s\n", GCPhys, cb, fFlags, pszDesc));
279
280	Assert(paPages);
281	Assert(pvRam);
282	Assert(!(fFlags & ~0xfff));
283	Assert(RT_ALIGN_Z(cb, PAGE_SIZE) == cb && cb);
284	Assert(RT_ALIGN_P(pvRam, PAGE_SIZE) == pvRam);
285	Assert(!(fFlags & ~(MM_RAM_FLAGS_RESERVED \| MM_RAM_FLAGS_ROM \| MM_RAM_FLAGS_MMIO \| MM_RAM_FLAGS_MMIO2 \| MM_RAM_FLAGS_DYNAMIC_ALLOC)));
286	Assert(RT_ALIGN_T(GCPhys, PAGE_SIZE, RTGCPHYS) == GCPhys);
287	Assert(VM_IS_EMT(pVM));
288	Assert(!(GCPhys & PGM_DYNAMIC_CHUNK_OFFSET_MASK));
289	Assert(cb == PGM_DYNAMIC_CHUNK_SIZE);
290
291	RTGCPHYS GCPhysLast = GCPhys + (cb - 1);
292	if (GCPhysLast < GCPhys)
293	{
294	AssertMsgFailed(("The range wraps! GCPhys=%VGp cb=%#x\n", GCPhys, cb));
295	return VERR_INVALID_PARAMETER;
296	}
297
298	/*
299	* Find existing range location.
300	*/
301	PPGMRAMRANGE pRam = CTXSUFF(pVM->pgm.s.pRamRanges);
302	while (pRam)
303	{
304	RTGCPHYS off = GCPhys - pRam->GCPhys;
305	if ( off < pRam->cb
306	&& (pRam->fFlags & MM_RAM_FLAGS_DYNAMIC_ALLOC))
307	break;
308
309	pRam = CTXSUFF(pRam->pNext);
310	}
311	AssertReturn(pRam, VERR_PGM_INVALID_GC_PHYSICAL_ADDRESS);
312
313	unsigned off = (GCPhys - pRam->GCPhys) >> PAGE_SHIFT;
314	unsigned iPage = cb >> PAGE_SHIFT;
315	if (paPages)
316	{
317	while (iPage-- > 0)
318	pRam->aPages[off + iPage].HCPhys = (paPages[iPage].Phys & X86_PTE_PAE_PG_MASK) \| fFlags; /** @todo PAGE FLAGS */
319	}
320	off >>= (PGM_DYNAMIC_CHUNK_SHIFT - PAGE_SHIFT);
321	pRam->pavHCChunkHC[off] = pvRam;
322
323	/* Notify the recompiler. */
324	REMR3NotifyPhysRamChunkRegister(pVM, GCPhys, PGM_DYNAMIC_CHUNK_SIZE, (RTHCUINTPTR)pvRam, fFlags);
325
326	return VINF_SUCCESS;
327	#else /* !PGM_DYNAMIC_RAM_ALLOC */
328	AssertReleaseMsgFailed(("Shouldn't ever get here when PGM_DYNAMIC_RAM_ALLOC isn't defined!\n"));
329	return VERR_INTERNAL_ERROR;
330	#endif /* !PGM_DYNAMIC_RAM_ALLOC */
331	}
332
333
334	/**
335	* Allocate missing physical pages for an existing guest RAM range.
336	*
337	* @returns VBox status.
338	* @param pVM The VM handle.
339	* @param GCPhys GC physical address of the RAM range. (page aligned)
340	*/
341	PGMR3DECL(int) PGM3PhysGrowRange(PVM pVM, RTGCPHYS GCPhys)
342	{
343	/*
344	* Walk range list.
345	*/
346	pgmLock(pVM);
347
348	PPGMRAMRANGE pRam = CTXSUFF(pVM->pgm.s.pRamRanges);
349	while (pRam)
350	{
351	RTGCPHYS off = GCPhys - pRam->GCPhys;
352	if ( off < pRam->cb
353	&& (pRam->fFlags & MM_RAM_FLAGS_DYNAMIC_ALLOC))
354	{
355	bool fRangeExists = false;
356	unsigned off = (GCPhys - pRam->GCPhys) >> PGM_DYNAMIC_CHUNK_SHIFT;
357
358	/** @note A request made from another thread may end up in EMT after somebody else has already allocated the range. */
359	if (pRam->pavHCChunkHC[off])
360	fRangeExists = true;
361
362	pgmUnlock(pVM);
363	if (fRangeExists)
364	return VINF_SUCCESS;
365	return pgmr3PhysGrowRange(pVM, GCPhys);
366	}
367
368	pRam = CTXSUFF(pRam->pNext);
369	}
370	pgmUnlock(pVM);
371	return VERR_PGM_INVALID_GC_PHYSICAL_ADDRESS;
372	}
373
374	#ifndef NEW_PHYS_CODE
375
376	/**
377	* Allocate missing physical pages for an existing guest RAM range.
378	*
379	* @returns VBox status.
380	* @param pVM The VM handle.
381	* @param pRamRange RAM range
382	* @param GCPhys GC physical address of the RAM range. (page aligned)
383	*/
384	int pgmr3PhysGrowRange(PVM pVM, RTGCPHYS GCPhys)
385	{
386	void *pvRam;
387	int rc;
388
389	/* We must execute this function in the EMT thread, otherwise we'll run into problems. */
390	if (!VM_IS_EMT(pVM))
391	{
392	PVMREQ pReq;
393
394	AssertMsg(!PDMCritSectIsOwner(&pVM->pgm.s.CritSect), ("We own the PGM lock -> deadlock danger!!\n"));
395
396	rc = VMR3ReqCall(pVM, &pReq, RT_INDEFINITE_WAIT, (PFNRT)PGM3PhysGrowRange, 2, pVM, GCPhys);
397	if (VBOX_SUCCESS(rc))
398	{
399	rc = pReq->iStatus;
400	VMR3ReqFree(pReq);
401	}
402	return rc;
403	}
404
405	/* Round down to chunk boundary */
406	GCPhys = GCPhys & PGM_DYNAMIC_CHUNK_BASE_MASK;
407
408	STAM_COUNTER_INC(&pVM->pgm.s.StatDynRamGrow);
409	STAM_COUNTER_ADD(&pVM->pgm.s.StatDynRamTotal, PGM_DYNAMIC_CHUNK_SIZE/(1024*1024));
410
411	Log(("pgmr3PhysGrowRange: allocate chunk of size 0x%X at %VGp\n", PGM_DYNAMIC_CHUNK_SIZE, GCPhys));
412
413	unsigned cPages = PGM_DYNAMIC_CHUNK_SIZE >> PAGE_SHIFT;
414	rc = SUPPageAlloc(cPages, &pvRam);
415	if (VBOX_SUCCESS(rc))
416	{
417	VMSTATE enmVMState = VMR3GetState(pVM);
418
419	rc = MMR3PhysRegisterEx(pVM, pvRam, GCPhys, PGM_DYNAMIC_CHUNK_SIZE, 0, MM_PHYS_TYPE_DYNALLOC_CHUNK, "Main Memory");
420	if ( VBOX_SUCCESS(rc)
421	\|\| enmVMState != VMSTATE_RUNNING)
422	{
423	if (VBOX_FAILURE(rc))
424	{
425	AssertMsgFailed(("Out of memory while trying to allocate a guest RAM chunk at %VGp!\n", GCPhys));
426	LogRel(("PGM: Out of memory while trying to allocate a guest RAM chunk at %VGp (VMstate=%s)!\n", GCPhys, VMR3GetStateName(enmVMState)));
427	}
428	return rc;
429	}
430
431	SUPPageFree(pvRam, cPages);
432
433	LogRel(("pgmr3PhysGrowRange: out of memory. pause until the user resumes execution.\n"));
434
435	/* Pause first, then inform Main. */
436	rc = VMR3SuspendNoSave(pVM);
437	AssertRC(rc);
438
439	VMSetRuntimeError(pVM, false, "HostMemoryLow", "Unable to allocate and lock memory. The virtual machine will be paused. Please close applications to free up memory or close the VM.");
440
441	/* Wait for resume event; will only return in that case. If the VM is stopped, the EMT thread will be destroyed. */
442	rc = VMR3WaitForResume(pVM);
443
444	/* Retry */
445	LogRel(("pgmr3PhysGrowRange: VM execution resumed -> retry.\n"));
446	return pgmr3PhysGrowRange(pVM, GCPhys);
447	}
448	return rc;
449	}
450
451	#endif /* !NEW_PHYS_CODE */
452
453	/**
454	* Interface MMIO handler relocation calls.
455	*
456	* It relocates an existing physical memory range with PGM.
457	*
458	* @returns VBox status.
459	* @param pVM The VM handle.
460	* @param GCPhysOld Previous GC physical address of the RAM range. (page aligned)
461	* @param GCPhysNew New GC physical address of the RAM range. (page aligned)
462	* @param cb Size of the RAM range. (page aligned)
463	*/
464	PGMR3DECL(int) PGMR3PhysRelocate(PVM pVM, RTGCPHYS GCPhysOld, RTGCPHYS GCPhysNew, size_t cb)
465	{
466	/*
467	* Validate input.
468	* (Not so important because callers are only MMR3PhysRelocate(),
469	* but anyway...)
470	*/
471	Log(("PGMR3PhysRelocate Old %VGp New %VGp (%#x bytes)\n", GCPhysOld, GCPhysNew, cb));
472
473	Assert(RT_ALIGN_Z(cb, PAGE_SIZE) == cb && cb);
474	Assert(RT_ALIGN_T(GCPhysOld, PAGE_SIZE, RTGCPHYS) == GCPhysOld);
475	Assert(RT_ALIGN_T(GCPhysNew, PAGE_SIZE, RTGCPHYS) == GCPhysNew);
476	RTGCPHYS GCPhysLast;
477	GCPhysLast = GCPhysOld + (cb - 1);
478	if (GCPhysLast < GCPhysOld)
479	{
480	AssertMsgFailed(("The old range wraps! GCPhys=%VGp cb=%#x\n", GCPhysOld, cb));
481	return VERR_INVALID_PARAMETER;
482	}
483	GCPhysLast = GCPhysNew + (cb - 1);
484	if (GCPhysLast < GCPhysNew)
485	{
486	AssertMsgFailed(("The new range wraps! GCPhys=%VGp cb=%#x\n", GCPhysNew, cb));
487	return VERR_INVALID_PARAMETER;
488	}
489
490	/*
491	* Find and remove old range location.
492	*/
493	pgmLock(pVM);
494	PPGMRAMRANGE pPrev = NULL;
495	PPGMRAMRANGE pCur = pVM->pgm.s.pRamRangesHC;
496	while (pCur)
497	{
498	if (pCur->GCPhys == GCPhysOld && pCur->cb == cb)
499	break;
500
501	/* next */
502	pPrev = pCur;
503	pCur = pCur->pNextHC;
504	}
505	if (pPrev)
506	{
507	pPrev->pNextHC = pCur->pNextHC;
508	pPrev->pNextGC = pCur->pNextGC;
509	}
510	else
511	{
512	pVM->pgm.s.pRamRangesHC = pCur->pNextHC;
513	pVM->pgm.s.pRamRangesGC = pCur->pNextGC;
514	}
515
516	/*
517	* Update the range.
518	*/
519	pCur->GCPhys = GCPhysNew;
520	pCur->GCPhysLast= GCPhysLast;
521	PPGMRAMRANGE pNew = pCur;
522
523	/*
524	* Find range location and check for conflicts.
525	*/
526	pPrev = NULL;
527	pCur = pVM->pgm.s.pRamRangesHC;
528	while (pCur)
529	{
530	if (GCPhysNew <= pCur->GCPhysLast && GCPhysLast >= pCur->GCPhys)
531	{
532	AssertMsgFailed(("Conflict! This cannot happen!\n"));
533	pgmUnlock(pVM);
534	return VERR_PGM_RAM_CONFLICT;
535	}
536	if (GCPhysLast < pCur->GCPhys)
537	break;
538
539	/* next */
540	pPrev = pCur;
541	pCur = pCur->pNextHC;
542	}
543
544	/*
545	* Reinsert the RAM range.
546	*/
547	pNew->pNextHC = pCur;
548	pNew->pNextGC = pCur ? MMHyperHC2GC(pVM, pCur) : 0;
549	if (pPrev)
550	{
551	pPrev->pNextHC = pNew;
552	pPrev->pNextGC = MMHyperHC2GC(pVM, pNew);
553	}
554	else
555	{
556	pVM->pgm.s.pRamRangesHC = pNew;
557	pVM->pgm.s.pRamRangesGC = MMHyperHC2GC(pVM, pNew);
558	}
559
560	pgmUnlock(pVM);
561	return VINF_SUCCESS;
562	}
563
564
565	/**
566	* Interface MMR3RomRegister() and MMR3PhysReserve calls to update the
567	* flags of existing RAM ranges.
568	*
569	* @returns VBox status.
570	* @param pVM The VM handle.
571	* @param GCPhys GC physical address of the RAM range. (page aligned)
572	* @param cb Size of the RAM range. (page aligned)
573	* @param fFlags The Or flags, MM_RAM_* \#defines.
574	* @param fMask The and mask for the flags.
575	*/
576	PGMR3DECL(int) PGMR3PhysSetFlags(PVM pVM, RTGCPHYS GCPhys, size_t cb, unsigned fFlags, unsigned fMask)
577	{
578	Log(("PGMR3PhysSetFlags %08X %x %x %x\n", GCPhys, cb, fFlags, fMask));
579
580	/*
581	* Validate input.
582	* (Not so important because caller is always MMR3RomRegister() and MMR3PhysReserve(), but anyway...)
583	*/
584	Assert(!(fFlags & ~(MM_RAM_FLAGS_RESERVED \| MM_RAM_FLAGS_ROM \| MM_RAM_FLAGS_MMIO \| MM_RAM_FLAGS_MMIO2)));
585	Assert(RT_ALIGN_Z(cb, PAGE_SIZE) == cb && cb);
586	Assert(RT_ALIGN_T(GCPhys, PAGE_SIZE, RTGCPHYS) == GCPhys);
587	RTGCPHYS GCPhysLast = GCPhys + (cb - 1);
588	AssertReturn(GCPhysLast > GCPhys, VERR_INVALID_PARAMETER);
589
590	/*
591	* Lookup the range.
592	*/
593	PPGMRAMRANGE pRam = CTXSUFF(pVM->pgm.s.pRamRanges);
594	while (pRam && GCPhys > pRam->GCPhysLast)
595	pRam = CTXSUFF(pRam->pNext);
596	if ( !pRam
597	\|\| GCPhys > pRam->GCPhysLast
598	\|\| GCPhysLast < pRam->GCPhys)
599	{
600	AssertMsgFailed(("No RAM range for %VGp-%VGp\n", GCPhys, GCPhysLast));
601	return VERR_INVALID_PARAMETER;
602	}
603
604	/*
605	* Update the requested flags.
606	*/
607	RTHCPHYS fFullMask = ~(RTHCPHYS)(MM_RAM_FLAGS_RESERVED \| MM_RAM_FLAGS_ROM \| MM_RAM_FLAGS_MMIO \| MM_RAM_FLAGS_MMIO2)
608	\| fMask;
609	unsigned iPageEnd = (GCPhysLast - pRam->GCPhys + 1) >> PAGE_SHIFT;
610	unsigned iPage = (GCPhys - pRam->GCPhys) >> PAGE_SHIFT;
611	for ( ; iPage < iPageEnd; iPage++)
612	pRam->aPages[iPage].HCPhys = (pRam->aPages[iPage].HCPhys & fFullMask) \| fFlags; /** @todo PAGE FLAGS */
613
614	return VINF_SUCCESS;
615	}
616
617
618	/**
619	* Sets the Address Gate 20 state.
620	*
621	* @param pVM VM handle.
622	* @param fEnable True if the gate should be enabled.
623	* False if the gate should be disabled.
624	*/
625	PGMDECL(void) PGMR3PhysSetA20(PVM pVM, bool fEnable)
626	{
627	LogFlow(("PGMR3PhysSetA20 %d (was %d)\n", fEnable, pVM->pgm.s.fA20Enabled));
628	if (pVM->pgm.s.fA20Enabled != (RTUINT)fEnable)
629	{
630	pVM->pgm.s.fA20Enabled = fEnable;
631	pVM->pgm.s.GCPhysA20Mask = ~(RTGCPHYS)(!fEnable << 20);
632	REMR3A20Set(pVM, fEnable);
633	}
634	}
635
636
637	/**
638	* Tree enumeration callback for dealing with age rollover.
639	* It will perform a simple compression of the current age.
640	*/
641	static DECLCALLBACK(int) pgmR3PhysChunkAgeingRolloverCallback(PAVLU32NODECORE pNode, void *pvUser)
642	{
643	/* Age compression - ASSUMES iNow == 4. */
644	PPGMCHUNKR3MAP pChunk = (PPGMCHUNKR3MAP)pNode;
645	if (pChunk->iAge >= UINT32_C(0xffffff00))
646	pChunk->iAge = 3;
647	else if (pChunk->iAge >= UINT32_C(0xfffff000))
648	pChunk->iAge = 2;
649	else if (pChunk->iAge)
650	pChunk->iAge = 1;
651	else /* iAge = 0 */
652	pChunk->iAge = 4;
653
654	/* reinsert */
655	PVM pVM = (PVM)pvUser;
656	RTAvllU32Remove(&pVM->pgm.s.ChunkR3Map.pAgeTree, pChunk->AgeCore.Key);
657	pChunk->AgeCore.Key = pChunk->iAge;
658	RTAvllU32Insert(&pVM->pgm.s.ChunkR3Map.pAgeTree, &pChunk->AgeCore);
659	return 0;
660	}
661
662
663	/**
664	* Tree enumeration callback that updates the chunks that have
665	* been used since the last
666	*/
667	static DECLCALLBACK(int) pgmR3PhysChunkAgeingCallback(PAVLU32NODECORE pNode, void *pvUser)
668	{
669	PPGMCHUNKR3MAP pChunk = (PPGMCHUNKR3MAP)pNode;
670	if (!pChunk->iAge)
671	{
672	PVM pVM = (PVM)pvUser;
673	RTAvllU32Remove(&pVM->pgm.s.ChunkR3Map.pAgeTree, pChunk->AgeCore.Key);
674	pChunk->AgeCore.Key = pChunk->iAge = pVM->pgm.s.ChunkR3Map.iNow;
675	RTAvllU32Insert(&pVM->pgm.s.ChunkR3Map.pAgeTree, &pChunk->AgeCore);
676	}
677
678	return 0;
679	}
680
681
682	/**
683	* Performs ageing of the ring-3 chunk mappings.
684	*
685	* @param pVM The VM handle.
686	*/
687	PGMR3DECL(void) PGMR3PhysChunkAgeing(PVM pVM)
688	{
689	pVM->pgm.s.ChunkR3Map.AgeingCountdown = RT_MIN(pVM->pgm.s.ChunkR3Map.cMax / 4, 1024);
690	pVM->pgm.s.ChunkR3Map.iNow++;
691	if (pVM->pgm.s.ChunkR3Map.iNow == 0)
692	{
693	pVM->pgm.s.ChunkR3Map.iNow = 4;
694	RTAvlU32DoWithAll(&pVM->pgm.s.ChunkR3Map.pTree, true /fFromLeft/, pgmR3PhysChunkAgeingRolloverCallback, pVM);
695	}
696	else
697	RTAvlU32DoWithAll(&pVM->pgm.s.ChunkR3Map.pTree, true /fFromLeft/, pgmR3PhysChunkAgeingCallback, pVM);
698	}
699
700
701	/**
702	* The structure passed in the pvUser argument of pgmR3PhysChunkUnmapCandidateCallback().
703	*/
704	typedef struct PGMR3PHYSCHUNKUNMAPCB
705	{
706	PVM pVM; /*< The VM handle. /
707	PPGMCHUNKR3MAP pChunk; /*< The chunk to unmap. /
708	} PGMR3PHYSCHUNKUNMAPCB, *PPGMR3PHYSCHUNKUNMAPCB;
709
710
711	/**
712	* Callback used to find the mapping that's been unused for
713	* the longest time.
714	*/
715	static DECLCALLBACK(int) pgmR3PhysChunkUnmapCandidateCallback(PAVLLU32NODECORE pNode, void *pvUser)
716	{
717	do
718	{
719	PPGMCHUNKR3MAP pChunk = (PPGMCHUNKR3MAP)((uint8_t *)pNode - RT_OFFSETOF(PGMCHUNKR3MAP, AgeCore));
720	if ( pChunk->iAge
721	&& !pChunk->cRefs)
722	{
723	/*
724	* Check that it's not in any of the TLBs.
725	*/
726	PVM pVM = ((PPGMR3PHYSCHUNKUNMAPCB)pvUser)->pVM;
727	for (unsigned i = 0; i < RT_ELEMENTS(pVM->pgm.s.ChunkR3Map.Tlb.aEntries); i++)
728	if (pVM->pgm.s.ChunkR3Map.Tlb.aEntries[i].pChunk == pChunk)
729	{
730	pChunk = NULL;
731	break;
732	}
733	if (pChunk)
734	for (unsigned i = 0; i < RT_ELEMENTS(pVM->pgm.s.PhysTlbHC.aEntries); i++)
735	if (pVM->pgm.s.PhysTlbHC.aEntries[i].pMap == pChunk)
736	{
737	pChunk = NULL;
738	break;
739	}
740	if (pChunk)
741	{
742	((PPGMR3PHYSCHUNKUNMAPCB)pvUser)->pChunk = pChunk;
743	return 1; /* done */
744	}
745	}
746
747	/* next with the same age - this version of the AVL API doesn't enumerate the list, so we have to do it. */
748	pNode = pNode->pList;
749	} while (pNode);
750	return 0;
751	}
752
753
754	/**
755	* Finds a good candidate for unmapping when the ring-3 mapping cache is full.
756	*
757	* The candidate will not be part of any TLBs, so no need to flush
758	* anything afterwards.
759	*
760	* @returns Chunk id.
761	* @param pVM The VM handle.
762	*/
763	static int32_t pgmR3PhysChunkFindUnmapCandidate(PVM pVM)
764	{
765	/*
766	* Do tree ageing first?
767	*/
768	if (pVM->pgm.s.ChunkR3Map.AgeingCountdown-- == 0)
769	PGMR3PhysChunkAgeing(pVM);
770
771	/*
772	* Enumerate the age tree starting with the left most node.
773	*/
774	PGMR3PHYSCHUNKUNMAPCB Args;
775	Args.pVM = pVM;
776	Args.pChunk = NULL;
777	if (RTAvllU32DoWithAll(&pVM->pgm.s.ChunkR3Map.pAgeTree, true /fFromLeft/, pgmR3PhysChunkUnmapCandidateCallback, pVM))
778	return Args.pChunk->Core.Key;
779	return INT32_MAX;
780	}
781
782
783	/**
784	* Argument package for the VMMR0_DO_GMM_MAP_UNMAP_CHUNK request.
785	*/
786	typedef struct GMMMAPUNMAPCHUNKREQ
787	{
788	/** The chunk to map, UINT32_MAX if unmap only. (IN) */
789	uint32_t idChunkMap;
790	/** The chunk to unmap, UINT32_MAX if map only. (IN) */
791	uint32_t idChunkUnmap;
792	/** Where the mapping address is returned. (OUT) */
793	RTR3PTR pvR3;
794	} GMMMAPUNMAPCHUNKREQ;
795
796
797	/**
798	* Maps the given chunk into the ring-3 mapping cache.
799	*
800	* This will call ring-0.
801	*
802	* @returns VBox status code.
803	* @param pVM The VM handle.
804	* @param idChunk The chunk in question.
805	* @param ppChunk Where to store the chunk tracking structure.
806	*
807	* @remarks Called from within the PGM critical section.
808	*/
809	int pgmR3PhysChunkMap(PVM pVM, uint32_t idChunk, PPPGMCHUNKR3MAP ppChunk)
810	{
811	int rc;
812	/*
813	* Allocate a new tracking structure first.
814	*/
815	#if 0 /* for later when we've got a separate mapping method for ring-0. */
816	PPGMCHUNKR3MAP pChunk = (PPGMCHUNKR3MAP)MMR3HeapAlloc(pVM, MM_TAG_PGM_CHUNK_MAPPING, sizeof(*pChunk));
817	AssertReturn(pChunk, VERR_NO_MEMORY);
818	#else
819	PPGMCHUNKR3MAP pChunk;
820	rc = MMHyperAlloc(pVM, sizeof(pChunk), 0, MM_TAG_PGM_CHUNK_MAPPING, (void *)&pChunk);
821	AssertRCReturn(rc, rc);
822	#endif
823	pChunk->Core.Key = idChunk;
824	pChunk->AgeCore.Key = pVM->pgm.s.ChunkR3Map.iNow;
825	pChunk->iAge = 0;
826	pChunk->cRefs = 0;
827	pChunk->cPermRefs = 0;
828	pChunk->pv = NULL;
829
830	/*
831	* Request the ring-0 part to map the chunk in question and if
832	* necessary unmap another one to make space in the mapping cache.
833	*/
834	GMMMAPUNMAPCHUNKREQ Req;
835	Req.pvR3 = NULL;
836	Req.idChunkMap = idChunk;
837	Req.idChunkUnmap = INT32_MAX;
838	if (pVM->pgm.s.ChunkR3Map.c >= pVM->pgm.s.ChunkR3Map.cMax)
839	Req.idChunkUnmap = pgmR3PhysChunkFindUnmapCandidate(pVM);
840	/** @todo SUPCallVMMR0Ex needs to support in+out or similar. */
841	rc = SUPCallVMMR0Ex(pVM->pVMR0, VMMR0_DO_GMM_MAP_UNMAP_CHUNK, &Req, sizeof(Req));
842	if (VBOX_SUCCESS(rc))
843	{
844	/*
845	* Update the tree.
846	*/
847	/* insert the new one. */
848	AssertPtr(Req.pvR3);
849	pChunk->pv = Req.pvR3;
850	bool fRc = RTAvlU32Insert(&pVM->pgm.s.ChunkR3Map.pTree, &pChunk->Core);
851	AssertRelease(fRc);
852	pVM->pgm.s.ChunkR3Map.c++;
853
854	fRc = RTAvllU32Insert(&pVM->pgm.s.ChunkR3Map.pAgeTree, &pChunk->AgeCore);
855	AssertRelease(fRc);
856
857	/* remove the unmapped one. */
858	if (Req.idChunkUnmap != INT32_MAX)
859	{
860	PPGMCHUNKR3MAP pUnmappedChunk = (PPGMCHUNKR3MAP)RTAvlU32Remove(&pVM->pgm.s.ChunkR3Map.pTree, Req.idChunkUnmap);
861	AssertRelease(pUnmappedChunk);
862	pUnmappedChunk->pv = NULL;
863	pUnmappedChunk->Core.Key = UINT32_MAX;
864	#if 0 /* for later when we've got a separate mapping method for ring-0. */
865	MMR3HeapFree(pUnmappedChunk);
866	#else
867	MMHyperFree(pVM, pUnmappedChunk);
868	#endif
869	pVM->pgm.s.ChunkR3Map.c--;
870	}
871	}
872	else
873	{
874	AssertRC(rc);
875	#if 0 /* for later when we've got a separate mapping method for ring-0. */
876	MMR3HeapFree(pChunk);
877	#else
878	MMHyperFree(pVM, pChunk);
879	#endif
880	pChunk = NULL;
881	}
882
883	*ppChunk = pChunk;
884	return rc;
885	}
886
887
888	/**
889	* For VMMCALLHOST_PGM_MAP_CHUNK, considered internal.
890	*
891	* @returns see pgmR3PhysChunkMap.
892	* @param pVM The VM handle.
893	* @param idChunk The chunk to map.
894	*/
895	PDMR3DECL(int) PGMR3PhysChunkMap(PVM pVM, uint32_t idChunk)
896	{
897	PPGMCHUNKR3MAP pChunk;
898	return pgmR3PhysChunkMap(pVM, idChunk, &pChunk);
899	}
900
901
902	/**
903	* Invalidates the TLB for the ring-3 mapping cache.
904	*
905	* @param pVM The VM handle.
906	*/
907	PGMR3DECL(void) PGMR3PhysChunkInvalidateTLB(PVM pVM)
908	{
909	pgmLock(pVM);
910	for (unsigned i = 0; i < RT_ELEMENTS(pVM->pgm.s.ChunkR3Map.Tlb.aEntries); i++)
911	{
912	pVM->pgm.s.ChunkR3Map.Tlb.aEntries[i].idChunk = NIL_GMM_CHUNKID;
913	pVM->pgm.s.ChunkR3Map.Tlb.aEntries[i].pChunk = NULL;
914	}
915	pgmUnlock(pVM);
916	}
917
918
919	/**
920	* Response to VM_FF_PGM_NEED_HANDY_PAGES and VMMCALLHOST_PGM_ALLOCATE_HANDY_PAGES.
921	*
922	* @returns The following VBox status codes.
923	* @retval VINF_SUCCESS on success. FF cleared.
924	* @retval VINF_EM_NO_MEMORY if we're out of memory. The FF is not cleared in this case.
925	*
926	* @param pVM The VM handle.
927	*/
928	PDMR3DECL(int) PGMR3PhysAllocateHandyPages(PVM pVM)
929	{
930	pgmLock(pVM);
931	int rc = SUPCallVMMR0Ex(pVM->pVMR0, VMMR0_DO_PGM_ALLOCATE_HANDY_PAGES, NULL, 0);
932	if (rc == VERR_GMM_SEED_ME)
933	{
934	void *pvChunk;
935	rc = SUPPageAlloc(GMM_CHUNK_SIZE >> PAGE_SHIFT, &pvChunk);
936	if (VBOX_SUCCESS(rc))
937	rc = SUPCallVMMR0Ex(pVM->pVMR0, VMMR0_DO_GMM_SEED_CHUNK, pvChunk, 0);
938	if (VBOX_FAILURE(rc))
939	{
940	LogRel(("PGM: GMM Seeding failed, rc=%Vrc\n", rc));
941	rc = VINF_EM_NO_MEMORY;
942	}
943	}
944	pgmUnlock(pVM);
945	Assert(rc == VINF_SUCCESS \|\| rc == VINF_EM_NO_MEMORY);
946	return rc;
947	}
948

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

source: vbox/trunk/src/VBox/VMM/PGMPhys.cpp@ 4738

Download in other formats: