MMPhys.cpp@ 6734

Last change on this file since 6734 was 6627, checked in by vboxsync, 17 years ago
Memory reservation. Changed MM saved state version and kept backwards compatability.
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 21.2 KB

Line
1	/* $Id: MMPhys.cpp 6627 2008-01-30 19:34:55Z vboxsync $ */
2	/** @file
3	* MM - Memory Monitor(/Manager) - Physical Memory.
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 (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*/
17
18
19	/*******************************************************************************
20	* Header Files *
21	*******************************************************************************/
22	#define LOG_GROUP LOG_GROUP_MM_PHYS
23	#include <VBox/mm.h>
24	#include <VBox/pgm.h>
25	#include <VBox/rem.h>
26	#include "MMInternal.h"
27	#include <VBox/vm.h>
28
29	#include <VBox/log.h>
30	#include <VBox/param.h>
31	#include <VBox/err.h>
32	#include <iprt/alloc.h>
33	#include <iprt/assert.h>
34	#include <iprt/string.h>
35
36
37	/**
38	* Register externally allocated RAM for the virtual machine.
39	*
40	* The memory registered with the VM thru this interface must not be freed
41	* before the virtual machine has been destroyed. Bad things may happen... :-)
42	*
43	* @return VBox status code.
44	* @param pVM VM handle.
45	* @param pvRam Virtual address of the guest's physical memory range Must be page aligned.
46	* @param GCPhys The physical address the ram shall be registered at.
47	* @param cb Size of the memory. Must be page aligend.
48	* @param fFlags Flags of the MM_RAM_FLAGS_* defines.
49	* @param pszDesc Description of the memory.
50	*/
51	MMR3DECL(int) MMR3PhysRegister(PVM pVM, void pvRam, RTGCPHYS GCPhys, unsigned cb, unsigned fFlags, const char pszDesc)
52	{
53	return MMR3PhysRegisterEx(pVM, pvRam, GCPhys, cb, fFlags, MM_PHYS_TYPE_NORMAL, pszDesc);
54	}
55
56
57	/**
58	* Register externally allocated RAM for the virtual machine.
59	*
60	* The memory registered with the VM thru this interface must not be freed
61	* before the virtual machine has been destroyed. Bad things may happen... :-)
62	*
63	* @return VBox status code.
64	* @param pVM VM handle.
65	* @param pvRam Virtual address of the guest's physical memory range Must be page aligned.
66	* @param GCPhys The physical address the ram shall be registered at.
67	* @param cb Size of the memory. Must be page aligend.
68	* @param fFlags Flags of the MM_RAM_FLAGS_* defines.
69	* @param enmType Physical range type (MM_PHYS_TYPE_*)
70	* @param pszDesc Description of the memory.
71	* @thread The Emulation Thread.
72	*
73	* @deprecated For the old dynamic allocation code only. Will be removed with VBOX_WITH_NEW_PHYS_CODE.
74	*/
75	/** @todo this function description is not longer up-to-date */
76	MMR3DECL(int) MMR3PhysRegisterEx(PVM pVM, void pvRam, RTGCPHYS GCPhys, unsigned cb, unsigned fFlags, MMPHYSREG enmType, const char pszDesc)
77	{
78	int rc = VINF_SUCCESS;
79
80	Log(("MMR3PhysRegister: pvRam=%p GCPhys=%VGp cb=%#x fFlags=%#x\n", pvRam, GCPhys, cb, fFlags));
81
82	/*
83	* Validate input.
84	*/
85	AssertMsg(pVM, ("Invalid VM pointer\n"));
86	if (pvRam)
87	AssertReturn(RT_ALIGN_P(pvRam, PAGE_SIZE) == pvRam, VERR_INVALID_PARAMETER);
88	else
89	AssertReturn(fFlags & MM_RAM_FLAGS_DYNAMIC_ALLOC, VERR_INVALID_PARAMETER);
90	AssertReturn(RT_ALIGN_T(GCPhys, PAGE_SIZE, RTGCPHYS) == GCPhys, VERR_INVALID_PARAMETER);
91	AssertReturn(RT_ALIGN_Z(cb, PAGE_SIZE) == cb, VERR_INVALID_PARAMETER);
92	AssertReturn(enmType == MM_PHYS_TYPE_NORMAL \|\| enmType == MM_PHYS_TYPE_DYNALLOC_CHUNK, VERR_INVALID_PARAMETER);
93	RTGCPHYS GCPhysLast = GCPhys + (cb - 1);
94	AssertReturn(GCPhysLast > GCPhys, VERR_INVALID_PARAMETER);
95
96
97	/*
98	* Check for conflicts.
99	*
100	* We do not support overlapping physical memory regions yet,
101	* even if that's what the MM_RAM_FLAGS_MMIO2 flags is trying to
102	* tell us to do. Provided that all MMIO2 addresses are very high
103	* there is no real danger we'll be able to assign so much memory
104	* for a guest that it'll ever be a problem.
105	*/
106	AssertMsg(!(fFlags & MM_RAM_FLAGS_MMIO2) \|\| GCPhys > 0xc0000000,
107	("MMIO2 addresses should be above 3GB for avoiding conflicts with real RAM.\n"));
108	PMMLOCKEDMEM pCur = pVM->mm.s.pLockedMem;
109	while (pCur)
110	{
111	if ( pCur->eType == MM_LOCKED_TYPE_PHYS
112	&& ( GCPhys - pCur->u.phys.GCPhys < pCur->cb
113	\|\| pCur->u.phys.GCPhys - GCPhys < cb)
114	)
115	{
116	AssertMsgFailed(("Conflicting RAM range. Existing %#x LB%#x, Req %#x LB%#x\n",
117	pCur->u.phys.GCPhys, pCur->cb, GCPhys, cb));
118	return VERR_MM_RAM_CONFLICT;
119	}
120
121	/* next */
122	pCur = pCur->pNext;
123	}
124
125
126	/* Dynamic/on-demand allocation of backing memory? */
127	if (fFlags & MM_RAM_FLAGS_DYNAMIC_ALLOC)
128	{
129	/*
130	* Register the ram with PGM.
131	*/
132	rc = PGMR3PhysRegister(pVM, pvRam, GCPhys, cb, fFlags, NULL, pszDesc);
133	if (VBOX_SUCCESS(rc))
134	{
135	if (fFlags == MM_RAM_FLAGS_DYNAMIC_ALLOC)
136	pVM->mm.s.cBasePages += cb >> PAGE_SHIFT;
137
138	REMR3NotifyPhysRamRegister(pVM, GCPhys, cb, fFlags);
139	return rc;
140	}
141	}
142	else
143	{
144	/*
145	* Lock the memory. (fully allocated by caller)
146	*/
147	PMMLOCKEDMEM pLockedMem;
148	rc = mmR3LockMem(pVM, pvRam, cb, MM_LOCKED_TYPE_PHYS, &pLockedMem, enmType == MM_PHYS_TYPE_DYNALLOC_CHUNK /* fSilentFailure */);
149	if (VBOX_SUCCESS(rc))
150	{
151	pLockedMem->u.phys.GCPhys = GCPhys;
152
153	/*
154	* We set any page flags specified.
155	*/
156	if (fFlags)
157	for (unsigned i = 0; i < cb >> PAGE_SHIFT; i++)
158	pLockedMem->aPhysPages[i].Phys \|= fFlags;
159
160	/*
161	* Register the ram with PGM.
162	*/
163	if (enmType == MM_PHYS_TYPE_NORMAL)
164	{
165	rc = PGMR3PhysRegister(pVM, pvRam, pLockedMem->u.phys.GCPhys, cb, fFlags, &pLockedMem->aPhysPages[0], pszDesc);
166	if (VBOX_SUCCESS(rc))
167	{
168	if (!fFlags)
169	pVM->mm.s.cBasePages += cb >> PAGE_SHIFT;
170
171	REMR3NotifyPhysRamRegister(pVM, GCPhys, cb, fFlags);
172	return rc;
173	}
174	}
175	else
176	{
177	Assert(enmType == MM_PHYS_TYPE_DYNALLOC_CHUNK);
178	return PGMR3PhysRegisterChunk(pVM, pvRam, pLockedMem->u.phys.GCPhys, cb, fFlags, &pLockedMem->aPhysPages[0], pszDesc);
179	}
180	}
181	/* Cleanup is done in VM destruction to which failure of this function will lead. */
182	/* Not true in case of MM_PHYS_TYPE_DYNALLOC_CHUNK */
183	}
184
185	return rc;
186	}
187
188
189	/**
190	* Relocate previously registered externally allocated RAM for the virtual machine.
191	*
192	* Use this only for MMIO ranges or the guest will become very confused.
193	* The memory registered with the VM thru this interface must not be freed
194	* before the virtual machine has been destroyed. Bad things may happen... :-)
195	*
196	* @return VBox status code.
197	* @param pVM VM handle.
198	* @param GCPhysOld The physical address the ram was registered at.
199	* @param GCPhysNew The physical address the ram shall be registered at.
200	* @param cb Size of the memory. Must be page aligend.
201	*/
202	MMR3DECL(int) MMR3PhysRelocate(PVM pVM, RTGCPHYS GCPhysOld, RTGCPHYS GCPhysNew, unsigned cb)
203	{
204	Log(("MMR3PhysRelocate: GCPhysOld=%VGp GCPhysNew=%VGp cb=%#x\n", GCPhysOld, GCPhysNew, cb));
205
206	/*
207	* Validate input.
208	*/
209	AssertMsg(pVM, ("Invalid VM pointer\n"));
210	AssertReturn(RT_ALIGN_T(GCPhysOld, PAGE_SIZE, RTGCPHYS) == GCPhysOld, VERR_INVALID_PARAMETER);
211	AssertReturn(RT_ALIGN_T(GCPhysNew, PAGE_SIZE, RTGCPHYS) == GCPhysNew, VERR_INVALID_PARAMETER);
212	AssertReturn(RT_ALIGN(cb, PAGE_SIZE) == cb, VERR_INVALID_PARAMETER);
213	RTGCPHYS GCPhysLast;
214	GCPhysLast = GCPhysOld + (cb - 1);
215	AssertReturn(GCPhysLast > GCPhysOld, VERR_INVALID_PARAMETER);
216	GCPhysLast = GCPhysNew + (cb - 1);
217	AssertReturn(GCPhysLast > GCPhysNew, VERR_INVALID_PARAMETER);
218
219	/*
220	* Find the old memory region.
221	*/
222	PMMLOCKEDMEM pCur = pVM->mm.s.pLockedMem;
223	while (pCur)
224	{
225	if ( pCur->eType == MM_LOCKED_TYPE_PHYS
226	&& GCPhysOld == pCur->u.phys.GCPhys
227	&& cb == pCur->cb)
228	break;
229
230	/* next */
231	pCur = pCur->pNext;
232	}
233	if (!pCur)
234	{
235	AssertMsgFailed(("Unknown old region! %VGp LB%#x\n", GCPhysOld, cb));
236	return VERR_INVALID_PARAMETER;
237	}
238
239	/*
240	* Region is already locked, just need to change GC address.
241	*/
242	/** @todo r=bird: check for conflicts? */
243	pCur->u.phys.GCPhys = GCPhysNew;
244
245	/*
246	* Relocate the registered RAM range with PGM.
247	*/
248	int rc = PGMR3PhysRelocate(pVM, GCPhysOld, GCPhysNew, cb);
249	if (VBOX_SUCCESS(rc))
250	{
251	/* Somewhat hackish way to relocate the region with REM. There
252	* is unfortunately no official way to unregister anything with
253	* REM, as there is no way to unregister memory with QEMU.
254	* This implementation seems to work, but is not very pretty. */
255	/// @todo one day provide a proper MMIO relocation operation
256	REMR3NotifyPhysReserve(pVM, GCPhysOld, cb);
257	REMR3NotifyPhysRamRegister(pVM, GCPhysNew, cb,
258	pCur->aPhysPages[0].Phys & (MM_RAM_FLAGS_RESERVED \| MM_RAM_FLAGS_ROM \| MM_RAM_FLAGS_MMIO \| MM_RAM_FLAGS_MMIO2));
259	}
260
261	return rc;
262	}
263
264
265	/**
266	* Register a ROM (BIOS) region.
267	*
268	* It goes without saying that this is read-only memory. The memory region must be
269	* in unassigned memory. I.e. from the top of the address space or on the PC in
270	* the 0xa0000-0xfffff range.
271	*
272	* @returns VBox status.
273	* @param pVM VM Handle.
274	* @param pDevIns The device instance owning the ROM region.
275	* @param GCPhys First physical address in the range.
276	* Must be page aligned!
277	* @param cbRange The size of the range (in bytes).
278	* Must be page aligned!
279	* @param pvBinary Pointer to the binary data backing the ROM image.
280	* This must be cbRange bytes big.
281	* It will be copied and doesn't have to stick around.
282	* It will be copied and doesn't have to stick around if fShadow is clear.
283	* @param fShadow Whether to emulate ROM shadowing. This involves leaving
284	* the ROM writable for a while during the POST and refreshing
285	* it at reset. When this flag is set, the memory pointed to by
286	* pvBinary has to stick around for the lifespan of the VM.
287	* @param pszDesc Pointer to description string. This must not be freed.
288	* @remark There is no way to remove the rom, automatically on device cleanup or
289	* manually from the device yet. At present I doubt we need such features...
290	*/
291	MMR3DECL(int) MMR3PhysRomRegister(PVM pVM, PPDMDEVINS pDevIns, RTGCPHYS GCPhys, RTUINT cbRange, const void *pvBinary,
292	bool fShadow, const char *pszDesc)
293	{
294	/*
295	* Validate input.
296	*/
297	AssertPtrReturn(pDevIns, VERR_INVALID_PARAMETER);
298	AssertReturn(RT_ALIGN_T(GCPhys, PAGE_SIZE, RTGCPHYS) == GCPhys, VERR_INVALID_PARAMETER);
299	AssertReturn(RT_ALIGN(cbRange, PAGE_SIZE) == cbRange, VERR_INVALID_PARAMETER);
300	RTGCPHYS GCPhysLast = GCPhys + (cbRange - 1);
301	AssertReturn(GCPhysLast > GCPhys, VERR_INVALID_PARAMETER);
302	AssertPtrReturn(pvBinary, VERR_INVALID_PARAMETER);
303
304
305	/*
306	* Check if this can fit in an existing range.
307	*
308	* We do not handle the case where a new chunk of locked memory is
309	* required to accommodate the ROM since we assume MMR3PhysReserve()
310	* have been called to reserve the memory first.
311	*
312	* To make things even simpler, the pages in question must be
313	* marked as reserved.
314	*/
315	PMMLOCKEDMEM pCur = pVM->mm.s.pLockedMem;
316	for ( ; pCur; pCur = pCur->pNext)
317	if ( pCur->eType == MM_LOCKED_TYPE_PHYS
318	&& GCPhys - pCur->u.phys.GCPhys < pCur->cb)
319	break;
320	if (!pCur)
321	{
322	AssertMsgFailed(("No physical range was found matching the ROM location (%#VGp LB%#x)\n", GCPhys, cbRange));
323	return VERR_INVALID_PARAMETER;
324	}
325	if (GCPhysLast - pCur->u.phys.GCPhys >= pCur->cb)
326	{
327	AssertMsgFailed(("The ROM range (%#VGp LB%#x) was crossing the end of the physical range (%#VGp LB%#x)\n",
328	GCPhys, cbRange, pCur->u.phys.GCPhys, pCur->cb));
329	return VERR_INVALID_PARAMETER;
330	}
331
332	/* flags must be all reserved. */
333	unsigned iPage = (GCPhys - pCur->u.phys.GCPhys) >> PAGE_SHIFT;
334	unsigned iPageEnd = cbRange >> PAGE_SHIFT;
335	for (; iPage < iPageEnd; iPage++)
336	if ( (pCur->aPhysPages[iPage].Phys & (MM_RAM_FLAGS_RESERVED \| MM_RAM_FLAGS_ROM \| MM_RAM_FLAGS_MMIO \| MM_RAM_FLAGS_MMIO2))
337	!= MM_RAM_FLAGS_RESERVED)
338	{
339	AssertMsgFailed(("Flags conflict at %VGp, HCPhys=%VHp.\n", pCur->u.phys.GCPhys + (iPage << PAGE_SHIFT), pCur->aPhysPages[iPage].Phys));
340	return VERR_INVALID_PARAMETER;
341	}
342
343	/*
344	* Copy the ram and update the flags.
345	*/
346	iPage = (GCPhys - pCur->u.phys.GCPhys) >> PAGE_SHIFT;
347	void pvCopy = (char )pCur->pv + (iPage << PAGE_SHIFT);
348	memcpy(pvCopy, pvBinary, cbRange);
349
350	const unsigned fSet = fShadow ? MM_RAM_FLAGS_ROM \| MM_RAM_FLAGS_MMIO2 : MM_RAM_FLAGS_ROM;
351	for (; iPage < iPageEnd; iPage++)
352	{
353	pCur->aPhysPages[iPage].Phys &= ~MM_RAM_FLAGS_RESERVED;
354	pCur->aPhysPages[iPage].Phys \|= fSet;
355	}
356	int rc = PGMR3PhysSetFlags(pVM, GCPhys, cbRange, fSet, ~MM_RAM_FLAGS_RESERVED);
357	AssertRC(rc);
358	if (VBOX_SUCCESS(rc))
359	{
360	/*
361	* To prevent the shadow page table mappings from being RW in raw-mode, we
362	* must currently employ a little hack. We register an write access handler
363	* and thereby ensures a RO mapping of the pages. This is NOT very nice,
364	* and wasn't really my intention when writing the code, consider it a PGM bug.
365	*
366	* ASSUMES that REMR3NotifyPhysRomRegister doesn't call cpu_register_physical_memory
367	* when there is no HC handler. The result would probably be immediate boot failure.
368	*/
369	rc = PGMR3HandlerPhysicalRegister(pVM, PGMPHYSHANDLERTYPE_PHYSICAL_WRITE, GCPhys, GCPhys + cbRange - 1,
370	NULL, NULL,
371	NULL, "pgmGuestROMWriteHandler", 0,
372	NULL, "pgmGuestROMWriteHandler", 0, pszDesc);
373	AssertRC(rc);
374	}
375
376	/*
377	* Create a ROM range it so we can make a 'info rom' thingy and more importantly
378	* reload and protect/unprotect shadow ROM correctly.
379	*/
380	if (VBOX_SUCCESS(rc))
381	{
382	PMMROMRANGE pRomRange = (PMMROMRANGE)MMR3HeapAlloc(pVM, MM_TAG_MM, sizeof(*pRomRange));
383	AssertReturn(pRomRange, VERR_NO_MEMORY);
384	pRomRange->GCPhys = GCPhys;
385	pRomRange->cbRange = cbRange;
386	pRomRange->pszDesc = pszDesc;
387	pRomRange->fShadow = fShadow;
388	pRomRange->fWritable = fShadow;
389	pRomRange->pvBinary = fShadow ? pvBinary : NULL;
390	pRomRange->pvCopy = pvCopy;
391
392	/* sort it for 'info rom' readability. */
393	PMMROMRANGE pPrev = NULL;
394	PMMROMRANGE pCur = pVM->mm.s.pRomHead;
395	while (pCur && pCur->GCPhys < GCPhys)
396	{
397	pPrev = pCur;
398	pCur = pCur->pNext;
399	}
400	pRomRange->pNext = pCur;
401	if (pPrev)
402	pPrev->pNext = pRomRange;
403	else
404	pVM->mm.s.pRomHead = pRomRange;
405	}
406
407	REMR3NotifyPhysRomRegister(pVM, GCPhys, cbRange, pvCopy, fShadow);
408	return rc; /* we're sloppy with error cleanup here, but we're toast anyway if this fails. */
409	}
410
411
412	/**
413	* Reserve physical address space for ROM and MMIO ranges.
414	*
415	* @returns VBox status code.
416	* @param pVM VM Handle.
417	* @param GCPhys Start physical address.
418	* @param cbRange The size of the range.
419	* @param pszDesc Description string.
420	*/
421	MMR3DECL(int) MMR3PhysReserve(PVM pVM, RTGCPHYS GCPhys, RTUINT cbRange, const char *pszDesc)
422	{
423	/*
424	* Validate input.
425	*/
426	AssertReturn(RT_ALIGN_T(GCPhys, PAGE_SIZE, RTGCPHYS) == GCPhys, VERR_INVALID_PARAMETER);
427	AssertReturn(RT_ALIGN(cbRange, PAGE_SIZE) == cbRange, VERR_INVALID_PARAMETER);
428	RTGCPHYS GCPhysLast = GCPhys + (cbRange - 1);
429	AssertReturn(GCPhysLast > GCPhys, VERR_INVALID_PARAMETER);
430
431	/*
432	* Do we have an existing physical address range for the request?
433	*/
434	PMMLOCKEDMEM pCur = pVM->mm.s.pLockedMem;
435	for ( ; pCur; pCur = pCur->pNext)
436	if ( pCur->eType == MM_LOCKED_TYPE_PHYS
437	&& GCPhys - pCur->u.phys.GCPhys < pCur->cb)
438	break;
439	if (!pCur)
440	{
441	/*
442	* No range, we'll just allocate backing pages and register
443	* them as reserved using the Ram interface.
444	*/
445	void *pvPages;
446	int rc = SUPPageAlloc(cbRange >> PAGE_SHIFT, &pvPages);
447	if (VBOX_SUCCESS(rc))
448	{
449	rc = MMR3PhysRegister(pVM, pvPages, GCPhys, cbRange, MM_RAM_FLAGS_RESERVED, pszDesc);
450	if (VBOX_FAILURE(rc))
451	SUPPageFree(pvPages, cbRange >> PAGE_SHIFT);
452	}
453	return rc;
454	}
455	if (GCPhysLast - pCur->u.phys.GCPhys >= pCur->cb)
456	{
457	AssertMsgFailed(("The reserved range (%#VGp LB%#x) was crossing the end of the physical range (%#VGp LB%#x)\n",
458	GCPhys, cbRange, pCur->u.phys.GCPhys, pCur->cb));
459	return VERR_INVALID_PARAMETER;
460	}
461
462	/*
463	* Update the flags.
464	*/
465	unsigned iPage = (GCPhys - pCur->u.phys.GCPhys) >> PAGE_SHIFT;
466	unsigned iPageEnd = cbRange >> PAGE_SHIFT;
467	for (; iPage < iPageEnd; iPage++)
468	pCur->aPhysPages[iPage].Phys \|= MM_RAM_FLAGS_RESERVED;
469	int rc = PGMR3PhysSetFlags(pVM, GCPhys, cbRange, MM_RAM_FLAGS_RESERVED, ~0);
470	AssertRC(rc);
471
472	REMR3NotifyPhysReserve(pVM, GCPhys, cbRange);
473	return rc;
474	}
475
476
477	/**
478	* Get the size of the base RAM.
479	* This usually means the size of the first contigous block of physical memory.
480	*
481	* @returns The guest base RAM size.
482	* @param pVM The VM handle.
483	* @thread Any.
484	*/
485	MMR3DECL(uint64_t) MMR3PhysGetRamSize(PVM pVM)
486	{
487	return pVM->mm.s.cbRamBase;
488	}
489
490
491	/**
492	* Called by MMR3Reset to reset the shadow ROM.
493	*
494	* Resetting involves reloading the ROM into RAM and make it
495	* wriable again (as it was made read only at the end of the POST).
496	*
497	* @param pVM The VM handle.
498	*/
499	void mmR3PhysRomReset(PVM pVM)
500	{
501	for (PMMROMRANGE pCur = pVM->mm.s.pRomHead; pCur; pCur = pCur->pNext)
502	if (pCur->fShadow)
503	{
504	memcpy(pCur->pvCopy, pCur->pvBinary, pCur->cbRange);
505	if (!pCur->fWritable)
506	{
507	int rc = PGMHandlerPhysicalDeregister(pVM, pCur->GCPhys);
508	AssertRC(rc);
509	pCur->fWritable = true;
510
511	rc = PGMR3PhysSetFlags(pVM, pCur->GCPhys, pCur->cbRange, MM_RAM_FLAGS_MMIO2, ~0); /* ROM -> ROM + MMIO2 */
512	AssertRC(rc);
513
514	REMR3NotifyPhysRomRegister(pVM, pCur->GCPhys, pCur->cbRange, pCur->pvCopy, true /* read-write now */);
515	}
516	}
517	}
518
519
520	/**
521	* Write-protects a shadow ROM range.
522	*
523	* This is called late in the POST for shadow ROM ranges.
524	*
525	* @returns VBox status code.
526	* @param pVM The VM handle.
527	* @param GCPhys Start of the registered shadow ROM range
528	* @param cbRange The length of the registered shadow ROM range.
529	* This can be NULL (not sure about the BIOS interface yet).
530	*/
531	MMR3DECL(int) MMR3PhysRomProtect(PVM pVM, RTGCPHYS GCPhys, RTUINT cbRange)
532	{
533	for (PMMROMRANGE pCur = pVM->mm.s.pRomHead; pCur; pCur = pCur->pNext)
534	if ( pCur->GCPhys == GCPhys
535	&& ( pCur->cbRange == cbRange
536	\|\| !cbRange))
537	{
538	if (pCur->fWritable)
539	{
540	cbRange = pCur->cbRange;
541	int rc = PGMR3HandlerPhysicalRegister(pVM, PGMPHYSHANDLERTYPE_PHYSICAL_WRITE, GCPhys, GCPhys + cbRange - 1,
542	NULL, NULL,
543	NULL, "pgmGuestROMWriteHandler", 0,
544	NULL, "pgmGuestROMWriteHandler", 0, pCur->pszDesc);
545	AssertRCReturn(rc, rc);
546	pCur->fWritable = false;
547
548	rc = PGMR3PhysSetFlags(pVM, GCPhys, cbRange, 0, ~MM_RAM_FLAGS_MMIO2); /* ROM + MMIO2 -> ROM */
549	AssertRCReturn(rc, rc);
550	/* Don't bother with the MM page flags here because I don't think they are
551	really used beyond conflict checking at ROM, RAM, Reservation, etc. */
552
553	REMR3NotifyPhysRomRegister(pVM, GCPhys, cbRange, pCur->pvCopy, false /* read-only now */);
554	}
555	return VINF_SUCCESS;
556	}
557	AssertMsgFailed(("GCPhys=%VGp cbRange=%#x\n", GCPhys, cbRange));
558	return VERR_INVALID_PARAMETER;
559	}
560

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

source: vbox/trunk/src/VBox/VMM/MMPhys.cpp@ 6734

Download in other formats: