VirtualBox

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

Last change on this file since 26295 was 26259, checked in by vboxsync, 15 years ago

PGMPhys.cpp: warnings
  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 120.2 KB
Line 
1/* $Id: PGMPhys.cpp 26259 2010-02-05 01:34:23Z vboxsync $ */
2/** @file
3 * PGM - Page Manager and Monitor, Physical Memory Addressing.
4 */
5
6/*
7 * Copyright (C) 2006-2007 Sun Microsystems, Inc.
8 *
9 * This file is part of VirtualBox Open Source Edition (OSE), as
10 * available from http://www.virtualbox.org. This file is free software;
11 * you can redistribute it and/or modify it under the terms of the GNU
12 * General Public License (GPL) as published by the Free Software
13 * Foundation, in version 2 as it comes in the "COPYING" file of the
14 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16 *
17 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
18 * Clara, CA 95054 USA or visit http://www.sun.com if you need
19 * additional information or have any questions.
20 */
21
22
23/*******************************************************************************
24* Header Files *
25*******************************************************************************/
26#define LOG_GROUP LOG_GROUP_PGM_PHYS
27#include <VBox/pgm.h>
28#include <VBox/iom.h>
29#include <VBox/mm.h>
30#include <VBox/stam.h>
31#include <VBox/rem.h>
32#include <VBox/pdmdev.h>
33#include "PGMInternal.h"
34#include <VBox/vm.h>
35#include "PGMInline.h"
36#include <VBox/sup.h>
37#include <VBox/param.h>
38#include <VBox/err.h>
39#include <VBox/log.h>
40#include <iprt/assert.h>
41#include <iprt/alloc.h>
42#include <iprt/asm.h>
43#include <iprt/thread.h>
44#include <iprt/string.h>
45
46
47/*******************************************************************************
48* Defined Constants And Macros *
49*******************************************************************************/
50/** The number of pages to free in one batch. */
51#define PGMPHYS_FREE_PAGE_BATCH_SIZE 128
52
53
54/*******************************************************************************
55* Internal Functions *
56*******************************************************************************/
57static DECLCALLBACK(int) pgmR3PhysRomWriteHandler(PVM pVM, RTGCPHYS GCPhys, void *pvPhys, void *pvBuf, size_t cbBuf, PGMACCESSTYPE enmAccessType, void *pvUser);
58static int pgmPhysFreePage(PVM pVM, PGMMFREEPAGESREQ pReq, uint32_t *pcPendingPages, PPGMPAGE pPage, RTGCPHYS GCPhys);
59
60
61/*
62 * PGMR3PhysReadU8-64
63 * PGMR3PhysWriteU8-64
64 */
65#define PGMPHYSFN_READNAME PGMR3PhysReadU8
66#define PGMPHYSFN_WRITENAME PGMR3PhysWriteU8
67#define PGMPHYS_DATASIZE 1
68#define PGMPHYS_DATATYPE uint8_t
69#include "PGMPhysRWTmpl.h"
70
71#define PGMPHYSFN_READNAME PGMR3PhysReadU16
72#define PGMPHYSFN_WRITENAME PGMR3PhysWriteU16
73#define PGMPHYS_DATASIZE 2
74#define PGMPHYS_DATATYPE uint16_t
75#include "PGMPhysRWTmpl.h"
76
77#define PGMPHYSFN_READNAME PGMR3PhysReadU32
78#define PGMPHYSFN_WRITENAME PGMR3PhysWriteU32
79#define PGMPHYS_DATASIZE 4
80#define PGMPHYS_DATATYPE uint32_t
81#include "PGMPhysRWTmpl.h"
82
83#define PGMPHYSFN_READNAME PGMR3PhysReadU64
84#define PGMPHYSFN_WRITENAME PGMR3PhysWriteU64
85#define PGMPHYS_DATASIZE 8
86#define PGMPHYS_DATATYPE uint64_t
87#include "PGMPhysRWTmpl.h"
88
89
90/**
91 * EMT worker for PGMR3PhysReadExternal.
92 */
93static DECLCALLBACK(int) pgmR3PhysReadExternalEMT(PVM pVM, PRTGCPHYS pGCPhys, void *pvBuf, size_t cbRead)
94{
95 PGMPhysRead(pVM, *pGCPhys, pvBuf, cbRead);
96 return VINF_SUCCESS;
97}
98
99
100/**
101 * Write to physical memory, external users.
102 *
103 * @returns VBox status code.
104 * @retval VINF_SUCCESS.
105 *
106 * @param pVM VM Handle.
107 * @param GCPhys Physical address to write to.
108 * @param pvBuf What to write.
109 * @param cbWrite How many bytes to write.
110 *
111 * @thread Any but EMTs.
112 */
113VMMR3DECL(int) PGMR3PhysReadExternal(PVM pVM, RTGCPHYS GCPhys, void *pvBuf, size_t cbRead)
114{
115 VM_ASSERT_OTHER_THREAD(pVM);
116
117 AssertMsgReturn(cbRead > 0, ("don't even think about reading zero bytes!\n"), VINF_SUCCESS);
118 LogFlow(("PGMR3PhysReadExternal: %RGp %d\n", GCPhys, cbRead));
119
120 pgmLock(pVM);
121
122 /*
123 * Copy loop on ram ranges.
124 */
125 PPGMRAMRANGE pRam = pVM->pgm.s.CTX_SUFF(pRamRanges);
126 for (;;)
127 {
128 /* Find range. */
129 while (pRam && GCPhys > pRam->GCPhysLast)
130 pRam = pRam->CTX_SUFF(pNext);
131 /* Inside range or not? */
132 if (pRam && GCPhys >= pRam->GCPhys)
133 {
134 /*
135 * Must work our way thru this page by page.
136 */
137 RTGCPHYS off = GCPhys - pRam->GCPhys;
138 while (off < pRam->cb)
139 {
140 unsigned iPage = off >> PAGE_SHIFT;
141 PPGMPAGE pPage = &pRam->aPages[iPage];
142
143 /*
144 * If the page has an ALL access handler, we'll have to
145 * delegate the job to EMT.
146 */
147 if (PGM_PAGE_HAS_ACTIVE_ALL_HANDLERS(pPage))
148 {
149 pgmUnlock(pVM);
150
151 return VMR3ReqCallWait(pVM, VMCPUID_ANY, (PFNRT)pgmR3PhysReadExternalEMT, 4,
152 pVM, &GCPhys, pvBuf, cbRead);
153 }
154 Assert(!PGM_PAGE_IS_MMIO(pPage));
155
156 /*
157 * Simple stuff, go ahead.
158 */
159 size_t cb = PAGE_SIZE - (off & PAGE_OFFSET_MASK);
160 if (cb > cbRead)
161 cb = cbRead;
162 const void *pvSrc;
163 int rc = pgmPhysGCPhys2CCPtrInternalReadOnly(pVM, pPage, pRam->GCPhys + off, &pvSrc);
164 if (RT_SUCCESS(rc))
165 memcpy(pvBuf, pvSrc, cb);
166 else
167 {
168 AssertLogRelMsgFailed(("pgmPhysGCPhys2CCPtrInternalReadOnly failed on %RGp / %R[pgmpage] -> %Rrc\n",
169 pRam->GCPhys + off, pPage, rc));
170 memset(pvBuf, 0xff, cb);
171 }
172
173 /* next page */
174 if (cb >= cbRead)
175 {
176 pgmUnlock(pVM);
177 return VINF_SUCCESS;
178 }
179 cbRead -= cb;
180 off += cb;
181 GCPhys += cb;
182 pvBuf = (char *)pvBuf + cb;
183 } /* walk pages in ram range. */
184 }
185 else
186 {
187 LogFlow(("PGMPhysRead: Unassigned %RGp size=%u\n", GCPhys, cbRead));
188
189 /*
190 * Unassigned address space.
191 */
192 if (!pRam)
193 break;
194 size_t cb = pRam->GCPhys - GCPhys;
195 if (cb >= cbRead)
196 {
197 memset(pvBuf, 0xff, cbRead);
198 break;
199 }
200 memset(pvBuf, 0xff, cb);
201
202 cbRead -= cb;
203 pvBuf = (char *)pvBuf + cb;
204 GCPhys += cb;
205 }
206 } /* Ram range walk */
207
208 pgmUnlock(pVM);
209
210 return VINF_SUCCESS;
211}
212
213
214/**
215 * EMT worker for PGMR3PhysWriteExternal.
216 */
217static DECLCALLBACK(int) pgmR3PhysWriteExternalEMT(PVM pVM, PRTGCPHYS pGCPhys, const void *pvBuf, size_t cbWrite)
218{
219 /** @todo VERR_EM_NO_MEMORY */
220 PGMPhysWrite(pVM, *pGCPhys, pvBuf, cbWrite);
221 return VINF_SUCCESS;
222}
223
224
225/**
226 * Write to physical memory, external users.
227 *
228 * @returns VBox status code.
229 * @retval VINF_SUCCESS.
230 * @retval VERR_EM_NO_MEMORY.
231 *
232 * @param pVM VM Handle.
233 * @param GCPhys Physical address to write to.
234 * @param pvBuf What to write.
235 * @param cbWrite How many bytes to write.
236 * @param pszWho Who is writing. For tracking down who is writing
237 * after we've saved the state.
238 *
239 * @thread Any but EMTs.
240 */
241VMMDECL(int) PGMR3PhysWriteExternal(PVM pVM, RTGCPHYS GCPhys, const void *pvBuf, size_t cbWrite, const char *pszWho)
242{
243 VM_ASSERT_OTHER_THREAD(pVM);
244
245 AssertMsg(!pVM->pgm.s.fNoMorePhysWrites,
246 ("Calling PGMR3PhysWriteExternal after pgmR3Save()! GCPhys=%RGp cbWrite=%#x pszWho=%s\n",
247 GCPhys, cbWrite, pszWho));
248 AssertMsgReturn(cbWrite > 0, ("don't even think about writing zero bytes!\n"), VINF_SUCCESS);
249 LogFlow(("PGMR3PhysWriteExternal: %RGp %d\n", GCPhys, cbWrite));
250
251 pgmLock(pVM);
252
253 /*
254 * Copy loop on ram ranges, stop when we hit something difficult.
255 */
256 PPGMRAMRANGE pRam = pVM->pgm.s.CTX_SUFF(pRamRanges);
257 for (;;)
258 {
259 /* Find range. */
260 while (pRam && GCPhys > pRam->GCPhysLast)
261 pRam = pRam->CTX_SUFF(pNext);
262 /* Inside range or not? */
263 if (pRam && GCPhys >= pRam->GCPhys)
264 {
265 /*
266 * Must work our way thru this page by page.
267 */
268 RTGCPTR off = GCPhys - pRam->GCPhys;
269 while (off < pRam->cb)
270 {
271 RTGCPTR iPage = off >> PAGE_SHIFT;
272 PPGMPAGE pPage = &pRam->aPages[iPage];
273
274 /*
275 * Is the page problematic, we have to do the work on the EMT.
276 *
277 * Allocating writable pages and access handlers are
278 * problematic, write monitored pages are simple and can be
279 * dealth with here.
280 */
281 if ( PGM_PAGE_HAS_ACTIVE_HANDLERS(pPage)
282 || PGM_PAGE_GET_STATE(pPage) != PGM_PAGE_STATE_ALLOCATED)
283 {
284 if ( PGM_PAGE_GET_STATE(pPage) == PGM_PAGE_STATE_WRITE_MONITORED
285 && !PGM_PAGE_HAS_ACTIVE_HANDLERS(pPage))
286 pgmPhysPageMakeWriteMonitoredWritable(pVM, pPage);
287 else
288 {
289 pgmUnlock(pVM);
290
291 return VMR3ReqCallWait(pVM, VMCPUID_ANY, (PFNRT)pgmR3PhysWriteExternalEMT, 4,
292 pVM, &GCPhys, pvBuf, cbWrite);
293 }
294 }
295 Assert(!PGM_PAGE_IS_MMIO(pPage));
296
297 /*
298 * Simple stuff, go ahead.
299 */
300 size_t cb = PAGE_SIZE - (off & PAGE_OFFSET_MASK);
301 if (cb > cbWrite)
302 cb = cbWrite;
303 void *pvDst;
304 int rc = pgmPhysGCPhys2CCPtrInternal(pVM, pPage, pRam->GCPhys + off, &pvDst);
305 if (RT_SUCCESS(rc))
306 memcpy(pvDst, pvBuf, cb);
307 else
308 AssertLogRelMsgFailed(("pgmPhysGCPhys2CCPtrInternal failed on %RGp / %R[pgmpage] -> %Rrc\n",
309 pRam->GCPhys + off, pPage, rc));
310
311 /* next page */
312 if (cb >= cbWrite)
313 {
314 pgmUnlock(pVM);
315 return VINF_SUCCESS;
316 }
317
318 cbWrite -= cb;
319 off += cb;
320 GCPhys += cb;
321 pvBuf = (const char *)pvBuf + cb;
322 } /* walk pages in ram range */
323 }
324 else
325 {
326 /*
327 * Unassigned address space, skip it.
328 */
329 if (!pRam)
330 break;
331 size_t cb = pRam->GCPhys - GCPhys;
332 if (cb >= cbWrite)
333 break;
334 cbWrite -= cb;
335 pvBuf = (const char *)pvBuf + cb;
336 GCPhys += cb;
337 }
338 } /* Ram range walk */
339
340 pgmUnlock(pVM);
341 return VINF_SUCCESS;
342}
343
344
345/**
346 * VMR3ReqCall worker for PGMR3PhysGCPhys2CCPtrExternal to make pages writable.
347 *
348 * @returns see PGMR3PhysGCPhys2CCPtrExternal
349 * @param pVM The VM handle.
350 * @param pGCPhys Pointer to the guest physical address.
351 * @param ppv Where to store the mapping address.
352 * @param pLock Where to store the lock.
353 */
354static DECLCALLBACK(int) pgmR3PhysGCPhys2CCPtrDelegated(PVM pVM, PRTGCPHYS pGCPhys, void **ppv, PPGMPAGEMAPLOCK pLock)
355{
356 /*
357 * Just hand it to PGMPhysGCPhys2CCPtr and check that it's not a page with
358 * an access handler after it succeeds.
359 */
360 int rc = pgmLock(pVM);
361 AssertRCReturn(rc, rc);
362
363 rc = PGMPhysGCPhys2CCPtr(pVM, *pGCPhys, ppv, pLock);
364 if (RT_SUCCESS(rc))
365 {
366 PPGMPAGEMAPTLBE pTlbe;
367 int rc2 = pgmPhysPageQueryTlbe(&pVM->pgm.s, *pGCPhys, &pTlbe);
368 AssertFatalRC(rc2);
369 PPGMPAGE pPage = pTlbe->pPage;
370 if (PGM_PAGE_IS_MMIO(pPage))
371 {
372 PGMPhysReleasePageMappingLock(pVM, pLock);
373 rc = VERR_PGM_PHYS_PAGE_RESERVED;
374 }
375 else if ( PGM_PAGE_HAS_ACTIVE_HANDLERS(pPage)
376#ifdef PGMPOOL_WITH_OPTIMIZED_DIRTY_PT
377 || pgmPoolIsDirtyPage(pVM, *pGCPhys)
378#endif
379 )
380 {
381 /* We *must* flush any corresponding pgm pool page here, otherwise we'll
382 * not be informed about writes and keep bogus gst->shw mappings around.
383 */
384 pgmPoolFlushPageByGCPhys(pVM, *pGCPhys);
385 Assert(!PGM_PAGE_HAS_ACTIVE_HANDLERS(pPage));
386 /** @todo r=bird: return VERR_PGM_PHYS_PAGE_RESERVED here if it still has
387 * active handlers, see the PGMR3PhysGCPhys2CCPtrExternal docs. */
388 }
389 }
390
391 pgmUnlock(pVM);
392 return rc;
393}
394
395
396/**
397 * Requests the mapping of a guest page into ring-3, external threads.
398 *
399 * When you're done with the page, call PGMPhysReleasePageMappingLock() ASAP to
400 * release it.
401 *
402 * This API will assume your intention is to write to the page, and will
403 * therefore replace shared and zero pages. If you do not intend to modify the
404 * page, use the PGMR3PhysGCPhys2CCPtrReadOnlyExternal() API.
405 *
406 * @returns VBox status code.
407 * @retval VINF_SUCCESS on success.
408 * @retval VERR_PGM_PHYS_PAGE_RESERVED it it's a valid page but has no physical
409 * backing or if the page has any active access handlers. The caller
410 * must fall back on using PGMR3PhysWriteExternal.
411 * @retval VERR_PGM_INVALID_GC_PHYSICAL_ADDRESS if it's not a valid physical address.
412 *
413 * @param pVM The VM handle.
414 * @param GCPhys The guest physical address of the page that should be mapped.
415 * @param ppv Where to store the address corresponding to GCPhys.
416 * @param pLock Where to store the lock information that PGMPhysReleasePageMappingLock needs.
417 *
418 * @remark Avoid calling this API from within critical sections (other than the
419 * PGM one) because of the deadlock risk when we have to delegating the
420 * task to an EMT.
421 * @thread Any.
422 */
423VMMR3DECL(int) PGMR3PhysGCPhys2CCPtrExternal(PVM pVM, RTGCPHYS GCPhys, void **ppv, PPGMPAGEMAPLOCK pLock)
424{
425 AssertPtr(ppv);
426 AssertPtr(pLock);
427
428 Assert(VM_IS_EMT(pVM) || !PGMIsLockOwner(pVM));
429
430 int rc = pgmLock(pVM);
431 AssertRCReturn(rc, rc);
432
433 /*
434 * Query the Physical TLB entry for the page (may fail).
435 */
436 PPGMPAGEMAPTLBE pTlbe;
437 rc = pgmPhysPageQueryTlbe(&pVM->pgm.s, GCPhys, &pTlbe);
438 if (RT_SUCCESS(rc))
439 {
440 PPGMPAGE pPage = pTlbe->pPage;
441 if (PGM_PAGE_IS_MMIO(pPage))
442 rc = VERR_PGM_PHYS_PAGE_RESERVED;
443 else
444 {
445 /*
446 * If the page is shared, the zero page, or being write monitored
447 * it must be converted to an page that's writable if possible.
448 * We can only deal with write monitored pages here, the rest have
449 * to be on an EMT.
450 */
451 if ( PGM_PAGE_HAS_ACTIVE_HANDLERS(pPage)
452 || PGM_PAGE_GET_STATE(pPage) != PGM_PAGE_STATE_ALLOCATED
453#ifdef PGMPOOL_WITH_OPTIMIZED_DIRTY_PT
454 || pgmPoolIsDirtyPage(pVM, GCPhys)
455#endif
456 )
457 {
458 if ( PGM_PAGE_GET_STATE(pPage) == PGM_PAGE_STATE_WRITE_MONITORED
459 && !PGM_PAGE_HAS_ACTIVE_HANDLERS(pPage)
460#ifdef PGMPOOL_WITH_OPTIMIZED_DIRTY_PT
461 && !pgmPoolIsDirtyPage(pVM, GCPhys)
462#endif
463 )
464 pgmPhysPageMakeWriteMonitoredWritable(pVM, pPage);
465 else
466 {
467 pgmUnlock(pVM);
468
469 return VMR3ReqCallWait(pVM, VMCPUID_ANY, (PFNRT)pgmR3PhysGCPhys2CCPtrDelegated, 4,
470 pVM, &GCPhys, ppv, pLock);
471 }
472 }
473
474 /*
475 * Now, just perform the locking and calculate the return address.
476 */
477 PPGMPAGEMAP pMap = pTlbe->pMap;
478 if (pMap)
479 pMap->cRefs++;
480
481 unsigned cLocks = PGM_PAGE_GET_WRITE_LOCKS(pPage);
482 if (RT_LIKELY(cLocks < PGM_PAGE_MAX_LOCKS - 1))
483 {
484 if (cLocks == 0)
485 pVM->pgm.s.cWriteLockedPages++;
486 PGM_PAGE_INC_WRITE_LOCKS(pPage);
487 }
488 else if (cLocks != PGM_PAGE_GET_WRITE_LOCKS(pPage))
489 {
490 PGM_PAGE_INC_WRITE_LOCKS(pPage);
491 AssertMsgFailed(("%RGp / %R[pgmpage] is entering permanent write locked state!\n", GCPhys, pPage));
492 if (pMap)
493 pMap->cRefs++; /* Extra ref to prevent it from going away. */
494 }
495
496 *ppv = (void *)((uintptr_t)pTlbe->pv | (uintptr_t)(GCPhys & PAGE_OFFSET_MASK));
497 pLock->uPageAndType = (uintptr_t)pPage | PGMPAGEMAPLOCK_TYPE_WRITE;
498 pLock->pvMap = pMap;
499 }
500 }
501
502 pgmUnlock(pVM);
503 return rc;
504}
505
506
507/**
508 * Requests the mapping of a guest page into ring-3, external threads.
509 *
510 * When you're done with the page, call PGMPhysReleasePageMappingLock() ASAP to
511 * release it.
512 *
513 * @returns VBox status code.
514 * @retval VINF_SUCCESS on success.
515 * @retval VERR_PGM_PHYS_PAGE_RESERVED it it's a valid page but has no physical
516 * backing or if the page as an active ALL access handler. The caller
517 * must fall back on using PGMPhysRead.
518 * @retval VERR_PGM_INVALID_GC_PHYSICAL_ADDRESS if it's not a valid physical address.
519 *
520 * @param pVM The VM handle.
521 * @param GCPhys The guest physical address of the page that should be mapped.
522 * @param ppv Where to store the address corresponding to GCPhys.
523 * @param pLock Where to store the lock information that PGMPhysReleasePageMappingLock needs.
524 *
525 * @remark Avoid calling this API from within critical sections (other than
526 * the PGM one) because of the deadlock risk.
527 * @thread Any.
528 */
529VMMR3DECL(int) PGMR3PhysGCPhys2CCPtrReadOnlyExternal(PVM pVM, RTGCPHYS GCPhys, void const **ppv, PPGMPAGEMAPLOCK pLock)
530{
531 int rc = pgmLock(pVM);
532 AssertRCReturn(rc, rc);
533
534 /*
535 * Query the Physical TLB entry for the page (may fail).
536 */
537 PPGMPAGEMAPTLBE pTlbe;
538 rc = pgmPhysPageQueryTlbe(&pVM->pgm.s, GCPhys, &pTlbe);
539 if (RT_SUCCESS(rc))
540 {
541 PPGMPAGE pPage = pTlbe->pPage;
542#if 1
543 /* MMIO pages doesn't have any readable backing. */
544 if (PGM_PAGE_IS_MMIO(pPage))
545 rc = VERR_PGM_PHYS_PAGE_RESERVED;
546#else
547 if (PGM_PAGE_HAS_ACTIVE_ALL_HANDLERS(pPage))
548 rc = VERR_PGM_PHYS_PAGE_RESERVED;
549#endif
550 else
551 {
552 /*
553 * Now, just perform the locking and calculate the return address.
554 */
555 PPGMPAGEMAP pMap = pTlbe->pMap;
556 if (pMap)
557 pMap->cRefs++;
558
559 unsigned cLocks = PGM_PAGE_GET_READ_LOCKS(pPage);
560 if (RT_LIKELY(cLocks < PGM_PAGE_MAX_LOCKS - 1))
561 {
562 if (cLocks == 0)
563 pVM->pgm.s.cReadLockedPages++;
564 PGM_PAGE_INC_READ_LOCKS(pPage);
565 }
566 else if (cLocks != PGM_PAGE_GET_READ_LOCKS(pPage))
567 {
568 PGM_PAGE_INC_READ_LOCKS(pPage);
569 AssertMsgFailed(("%RGp / %R[pgmpage] is entering permanent readonly locked state!\n", GCPhys, pPage));
570 if (pMap)
571 pMap->cRefs++; /* Extra ref to prevent it from going away. */
572 }
573
574 *ppv = (void *)((uintptr_t)pTlbe->pv | (uintptr_t)(GCPhys & PAGE_OFFSET_MASK));
575 pLock->uPageAndType = (uintptr_t)pPage | PGMPAGEMAPLOCK_TYPE_READ;
576 pLock->pvMap = pMap;
577 }
578 }
579
580 pgmUnlock(pVM);
581 return rc;
582}
583
584
585/**
586 * Relinks the RAM ranges using the pSelfRC and pSelfR0 pointers.
587 *
588 * Called when anything was relocated.
589 *
590 * @param pVM Pointer to the shared VM structure.
591 */
592void pgmR3PhysRelinkRamRanges(PVM pVM)
593{
594 PPGMRAMRANGE pCur;
595
596#ifdef VBOX_STRICT
597 for (pCur = pVM->pgm.s.pRamRangesR3; pCur; pCur = pCur->pNextR3)
598 {
599 Assert((pCur->fFlags & PGM_RAM_RANGE_FLAGS_FLOATING) || pCur->pSelfR0 == MMHyperCCToR0(pVM, pCur));
600 Assert((pCur->fFlags & PGM_RAM_RANGE_FLAGS_FLOATING) || pCur->pSelfRC == MMHyperCCToRC(pVM, pCur));
601 Assert((pCur->GCPhys & PAGE_OFFSET_MASK) == 0);
602 Assert((pCur->GCPhysLast & PAGE_OFFSET_MASK) == PAGE_OFFSET_MASK);
603 Assert((pCur->cb & PAGE_OFFSET_MASK) == 0);
604 Assert(pCur->cb == pCur->GCPhysLast - pCur->GCPhys + 1);
605 for (PPGMRAMRANGE pCur2 = pVM->pgm.s.pRamRangesR3; pCur2; pCur2 = pCur2->pNextR3)
606 Assert( pCur2 == pCur
607 || strcmp(pCur2->pszDesc, pCur->pszDesc)); /** @todo fix MMIO ranges!! */
608 }
609#endif
610
611 pCur = pVM->pgm.s.pRamRangesR3;
612 if (pCur)
613 {
614 pVM->pgm.s.pRamRangesR0 = pCur->pSelfR0;
615 pVM->pgm.s.pRamRangesRC = pCur->pSelfRC;
616
617 for (; pCur->pNextR3; pCur = pCur->pNextR3)
618 {
619 pCur->pNextR0 = pCur->pNextR3->pSelfR0;
620 pCur->pNextRC = pCur->pNextR3->pSelfRC;
621 }
622
623 Assert(pCur->pNextR0 == NIL_RTR0PTR);
624 Assert(pCur->pNextRC == NIL_RTRCPTR);
625 }
626 else
627 {
628 Assert(pVM->pgm.s.pRamRangesR0 == NIL_RTR0PTR);
629 Assert(pVM->pgm.s.pRamRangesRC == NIL_RTRCPTR);
630 }
631 ASMAtomicIncU32(&pVM->pgm.s.idRamRangesGen);
632}
633
634
635/**
636 * Links a new RAM range into the list.
637 *
638 * @param pVM Pointer to the shared VM structure.
639 * @param pNew Pointer to the new list entry.
640 * @param pPrev Pointer to the previous list entry. If NULL, insert as head.
641 */
642static void pgmR3PhysLinkRamRange(PVM pVM, PPGMRAMRANGE pNew, PPGMRAMRANGE pPrev)
643{
644 AssertMsg(pNew->pszDesc, ("%RGp-%RGp\n", pNew->GCPhys, pNew->GCPhysLast));
645 Assert((pNew->fFlags & PGM_RAM_RANGE_FLAGS_FLOATING) || pNew->pSelfR0 == MMHyperCCToR0(pVM, pNew));
646 Assert((pNew->fFlags & PGM_RAM_RANGE_FLAGS_FLOATING) || pNew->pSelfRC == MMHyperCCToRC(pVM, pNew));
647
648 pgmLock(pVM);
649
650 PPGMRAMRANGE pRam = pPrev ? pPrev->pNextR3 : pVM->pgm.s.pRamRangesR3;
651 pNew->pNextR3 = pRam;
652 pNew->pNextR0 = pRam ? pRam->pSelfR0 : NIL_RTR0PTR;
653 pNew->pNextRC = pRam ? pRam->pSelfRC : NIL_RTRCPTR;
654
655 if (pPrev)
656 {
657 pPrev->pNextR3 = pNew;
658 pPrev->pNextR0 = pNew->pSelfR0;
659 pPrev->pNextRC = pNew->pSelfRC;
660 }
661 else
662 {
663 pVM->pgm.s.pRamRangesR3 = pNew;
664 pVM->pgm.s.pRamRangesR0 = pNew->pSelfR0;
665 pVM->pgm.s.pRamRangesRC = pNew->pSelfRC;
666 }
667 ASMAtomicIncU32(&pVM->pgm.s.idRamRangesGen);
668 pgmUnlock(pVM);
669}
670
671
672/**
673 * Unlink an existing RAM range from the list.
674 *
675 * @param pVM Pointer to the shared VM structure.
676 * @param pRam Pointer to the new list entry.
677 * @param pPrev Pointer to the previous list entry. If NULL, insert as head.
678 */
679static void pgmR3PhysUnlinkRamRange2(PVM pVM, PPGMRAMRANGE pRam, PPGMRAMRANGE pPrev)
680{
681 Assert(pPrev ? pPrev->pNextR3 == pRam : pVM->pgm.s.pRamRangesR3 == pRam);
682 Assert((pRam->fFlags & PGM_RAM_RANGE_FLAGS_FLOATING) || pRam->pSelfR0 == MMHyperCCToR0(pVM, pRam));
683 Assert((pRam->fFlags & PGM_RAM_RANGE_FLAGS_FLOATING) || pRam->pSelfRC == MMHyperCCToRC(pVM, pRam));
684
685 pgmLock(pVM);
686
687 PPGMRAMRANGE pNext = pRam->pNextR3;
688 if (pPrev)
689 {
690 pPrev->pNextR3 = pNext;
691 pPrev->pNextR0 = pNext ? pNext->pSelfR0 : NIL_RTR0PTR;
692 pPrev->pNextRC = pNext ? pNext->pSelfRC : NIL_RTRCPTR;
693 }
694 else
695 {
696 Assert(pVM->pgm.s.pRamRangesR3 == pRam);
697 pVM->pgm.s.pRamRangesR3 = pNext;
698 pVM->pgm.s.pRamRangesR0 = pNext ? pNext->pSelfR0 : NIL_RTR0PTR;
699 pVM->pgm.s.pRamRangesRC = pNext ? pNext->pSelfRC : NIL_RTRCPTR;
700 }
701 ASMAtomicIncU32(&pVM->pgm.s.idRamRangesGen);
702 pgmUnlock(pVM);
703}
704
705
706/**
707 * Unlink an existing RAM range from the list.
708 *
709 * @param pVM Pointer to the shared VM structure.
710 * @param pRam Pointer to the new list entry.
711 */
712static void pgmR3PhysUnlinkRamRange(PVM pVM, PPGMRAMRANGE pRam)
713{
714 pgmLock(pVM);
715
716 /* find prev. */
717 PPGMRAMRANGE pPrev = NULL;
718 PPGMRAMRANGE pCur = pVM->pgm.s.pRamRangesR3;
719 while (pCur != pRam)
720 {
721 pPrev = pCur;
722 pCur = pCur->pNextR3;
723 }
724 AssertFatal(pCur);
725
726 pgmR3PhysUnlinkRamRange2(pVM, pRam, pPrev);
727 pgmUnlock(pVM);
728}
729
730
731/**
732 * Frees a range of pages, replacing them with ZERO pages of the specified type.
733 *
734 * @returns VBox status code.
735 * @param pVM The VM handle.
736 * @param pRam The RAM range in which the pages resides.
737 * @param GCPhys The address of the first page.
738 * @param GCPhysLast The address of the last page.
739 * @param uType The page type to replace then with.
740 */
741static int pgmR3PhysFreePageRange(PVM pVM, PPGMRAMRANGE pRam, RTGCPHYS GCPhys, RTGCPHYS GCPhysLast, uint8_t uType)
742{
743 uint32_t cPendingPages = 0;
744 PGMMFREEPAGESREQ pReq;
745 int rc = GMMR3FreePagesPrepare(pVM, &pReq, PGMPHYS_FREE_PAGE_BATCH_SIZE, GMMACCOUNT_BASE);
746 AssertLogRelRCReturn(rc, rc);
747
748 /* Itegerate the pages. */
749 PPGMPAGE pPageDst = &pRam->aPages[(GCPhys - pRam->GCPhys) >> PAGE_SHIFT];
750 uint32_t cPagesLeft = ((GCPhysLast - GCPhys) >> PAGE_SHIFT) + 1;
751 while (cPagesLeft-- > 0)
752 {
753 rc = pgmPhysFreePage(pVM, pReq, &cPendingPages, pPageDst, GCPhys);
754 AssertLogRelRCReturn(rc, rc); /* We're done for if this goes wrong. */
755
756 PGM_PAGE_SET_TYPE(pPageDst, uType);
757
758 GCPhys += PAGE_SIZE;
759 pPageDst++;
760 }
761
762 if (cPendingPages)
763 {
764 rc = GMMR3FreePagesPerform(pVM, pReq, cPendingPages);
765 AssertLogRelRCReturn(rc, rc);
766 }
767 GMMR3FreePagesCleanup(pReq);
768
769 return rc;
770}
771
772
773/**
774 * PGMR3PhysRegisterRam worker that initializes and links a RAM range.
775 *
776 * @param pVM The VM handle.
777 * @param pNew The new RAM range.
778 * @param GCPhys The address of the RAM range.
779 * @param GCPhysLast The last address of the RAM range.
780 * @param RCPtrNew The RC address if the range is floating. NIL_RTRCPTR
781 * if in HMA.
782 * @param R0PtrNew Ditto for R0.
783 * @param pszDesc The description.
784 * @param pPrev The previous RAM range (for linking).
785 */
786static void pgmR3PhysInitAndLinkRamRange(PVM pVM, PPGMRAMRANGE pNew, RTGCPHYS GCPhys, RTGCPHYS GCPhysLast,
787 RTRCPTR RCPtrNew, RTR0PTR R0PtrNew, const char *pszDesc, PPGMRAMRANGE pPrev)
788{
789 /*
790 * Initialize the range.
791 */
792 pNew->pSelfR0 = R0PtrNew != NIL_RTR0PTR ? R0PtrNew : MMHyperCCToR0(pVM, pNew);
793 pNew->pSelfRC = RCPtrNew != NIL_RTRCPTR ? RCPtrNew : MMHyperCCToRC(pVM, pNew);
794 pNew->GCPhys = GCPhys;
795 pNew->GCPhysLast = GCPhysLast;
796 pNew->cb = GCPhysLast - GCPhys + 1;
797 pNew->pszDesc = pszDesc;
798 pNew->fFlags = RCPtrNew != NIL_RTRCPTR ? PGM_RAM_RANGE_FLAGS_FLOATING : 0;
799 pNew->pvR3 = NULL;
800 pNew->paLSPages = NULL;
801
802 uint32_t const cPages = pNew->cb >> PAGE_SHIFT;
803 RTGCPHYS iPage = cPages;
804 while (iPage-- > 0)
805 PGM_PAGE_INIT_ZERO(&pNew->aPages[iPage], pVM, PGMPAGETYPE_RAM);
806
807 /* Update the page count stats. */
808 pVM->pgm.s.cZeroPages += cPages;
809 pVM->pgm.s.cAllPages += cPages;
810
811 /*
812 * Link it.
813 */
814 pgmR3PhysLinkRamRange(pVM, pNew, pPrev);
815}
816
817
818/**
819 * Relocate a floating RAM range.
820 *
821 * @copydoc FNPGMRELOCATE.
822 */
823static DECLCALLBACK(bool) pgmR3PhysRamRangeRelocate(PVM pVM, RTGCPTR GCPtrOld, RTGCPTR GCPtrNew, PGMRELOCATECALL enmMode, void *pvUser)
824{
825 PPGMRAMRANGE pRam = (PPGMRAMRANGE)pvUser;
826 Assert(pRam->fFlags & PGM_RAM_RANGE_FLAGS_FLOATING);
827 Assert(pRam->pSelfRC == GCPtrOld + PAGE_SIZE);
828
829 switch (enmMode)
830 {
831 case PGMRELOCATECALL_SUGGEST:
832 return true;
833 case PGMRELOCATECALL_RELOCATE:
834 {
835 /* Update myself and then relink all the ranges. */
836 pgmLock(pVM);
837 pRam->pSelfRC = (RTRCPTR)(GCPtrNew + PAGE_SIZE);
838 pgmR3PhysRelinkRamRanges(pVM);
839 pgmUnlock(pVM);
840 return true;
841 }
842
843 default:
844 AssertFailedReturn(false);
845 }
846}
847
848
849/**
850 * PGMR3PhysRegisterRam worker that registers a high chunk.
851 *
852 * @returns VBox status code.
853 * @param pVM The VM handle.
854 * @param GCPhys The address of the RAM.
855 * @param cRamPages The number of RAM pages to register.
856 * @param cbChunk The size of the PGMRAMRANGE guest mapping.
857 * @param iChunk The chunk number.
858 * @param pszDesc The RAM range description.
859 * @param ppPrev Previous RAM range pointer. In/Out.
860 */
861static int pgmR3PhysRegisterHighRamChunk(PVM pVM, RTGCPHYS GCPhys, uint32_t cRamPages,
862 uint32_t cbChunk, uint32_t iChunk, const char *pszDesc,
863 PPGMRAMRANGE *ppPrev)
864{
865 const char *pszDescChunk = iChunk == 0
866 ? pszDesc
867 : MMR3HeapAPrintf(pVM, MM_TAG_PGM_PHYS, "%s (#%u)", pszDesc, iChunk + 1);
868 AssertReturn(pszDescChunk, VERR_NO_MEMORY);
869
870 /*
871 * Allocate memory for the new chunk.
872 */
873 size_t const cChunkPages = RT_ALIGN_Z(RT_UOFFSETOF(PGMRAMRANGE, aPages[cRamPages]), PAGE_SIZE) >> PAGE_SHIFT;
874 PSUPPAGE paChunkPages = (PSUPPAGE)RTMemTmpAllocZ(sizeof(SUPPAGE) * cChunkPages);
875 AssertReturn(paChunkPages, VERR_NO_TMP_MEMORY);
876 RTR0PTR R0PtrChunk = NIL_RTR0PTR;
877 void *pvChunk = NULL;
878 int rc = SUPR3PageAllocEx(cChunkPages, 0 /*fFlags*/, &pvChunk,
879#ifdef VBOX_WITH_2X_4GB_ADDR_SPACE
880 VMMIsHwVirtExtForced(pVM) ? &R0PtrChunk : NULL,
881#else
882 NULL,
883#endif
884 paChunkPages);
885 if (RT_SUCCESS(rc))
886 {
887#ifdef VBOX_WITH_2X_4GB_ADDR_SPACE
888 if (!VMMIsHwVirtExtForced(pVM))
889 R0PtrChunk = NIL_RTR0PTR;
890#else
891 R0PtrChunk = (uintptr_t)pvChunk;
892#endif
893 memset(pvChunk, 0, cChunkPages << PAGE_SHIFT);
894
895 PPGMRAMRANGE pNew = (PPGMRAMRANGE)pvChunk;
896
897 /*
898 * Create a mapping and map the pages into it.
899 * We push these in below the HMA.
900 */
901 RTGCPTR GCPtrChunkMap = pVM->pgm.s.GCPtrPrevRamRangeMapping - cbChunk;
902 rc = PGMR3MapPT(pVM, GCPtrChunkMap, cbChunk, 0 /*fFlags*/, pgmR3PhysRamRangeRelocate, pNew, pszDescChunk);
903 if (RT_SUCCESS(rc))
904 {
905 pVM->pgm.s.GCPtrPrevRamRangeMapping = GCPtrChunkMap;
906
907 RTGCPTR const GCPtrChunk = GCPtrChunkMap + PAGE_SIZE;
908 RTGCPTR GCPtrPage = GCPtrChunk;
909 for (uint32_t iPage = 0; iPage < cChunkPages && RT_SUCCESS(rc); iPage++, GCPtrPage += PAGE_SIZE)
910 rc = PGMMap(pVM, GCPtrPage, paChunkPages[iPage].Phys, PAGE_SIZE, 0);
911 if (RT_SUCCESS(rc))
912 {
913 /*
914 * Ok, init and link the range.
915 */
916 pgmR3PhysInitAndLinkRamRange(pVM, pNew, GCPhys, GCPhys + ((RTGCPHYS)cRamPages << PAGE_SHIFT) - 1,
917 (RTRCPTR)GCPtrChunk, R0PtrChunk, pszDescChunk, *ppPrev);
918 *ppPrev = pNew;
919 }
920 }
921
922 if (RT_FAILURE(rc))
923 SUPR3PageFreeEx(pvChunk, cChunkPages);
924 }
925
926 RTMemTmpFree(paChunkPages);
927 return rc;
928}
929
930
931/**
932 * Sets up a range RAM.
933 *
934 * This will check for conflicting registrations, make a resource
935 * reservation for the memory (with GMM), and setup the per-page
936 * tracking structures (PGMPAGE).
937 *
938 * @returns VBox stutus code.
939 * @param pVM Pointer to the shared VM structure.
940 * @param GCPhys The physical address of the RAM.
941 * @param cb The size of the RAM.
942 * @param pszDesc The description - not copied, so, don't free or change it.
943 */
944VMMR3DECL(int) PGMR3PhysRegisterRam(PVM pVM, RTGCPHYS GCPhys, RTGCPHYS cb, const char *pszDesc)
945{
946 /*
947 * Validate input.
948 */
949 Log(("PGMR3PhysRegisterRam: GCPhys=%RGp cb=%RGp pszDesc=%s\n", GCPhys, cb, pszDesc));
950 AssertReturn(RT_ALIGN_T(GCPhys, PAGE_SIZE, RTGCPHYS) == GCPhys, VERR_INVALID_PARAMETER);
951 AssertReturn(RT_ALIGN_T(cb, PAGE_SIZE, RTGCPHYS) == cb, VERR_INVALID_PARAMETER);
952 AssertReturn(cb > 0, VERR_INVALID_PARAMETER);
953 RTGCPHYS GCPhysLast = GCPhys + (cb - 1);
954 AssertMsgReturn(GCPhysLast > GCPhys, ("The range wraps! GCPhys=%RGp cb=%RGp\n", GCPhys, cb), VERR_INVALID_PARAMETER);
955 AssertPtrReturn(pszDesc, VERR_INVALID_POINTER);
956 VM_ASSERT_EMT_RETURN(pVM, VERR_VM_THREAD_NOT_EMT);
957
958 pgmLock(pVM);
959
960 /*
961 * Find range location and check for conflicts.
962 * (We don't lock here because the locking by EMT is only required on update.)
963 */
964 PPGMRAMRANGE pPrev = NULL;
965 PPGMRAMRANGE pRam = pVM->pgm.s.pRamRangesR3;
966 while (pRam && GCPhysLast >= pRam->GCPhys)
967 {
968 if ( GCPhysLast >= pRam->GCPhys
969 && GCPhys <= pRam->GCPhysLast)
970 AssertLogRelMsgFailedReturn(("%RGp-%RGp (%s) conflicts with existing %RGp-%RGp (%s)\n",
971 GCPhys, GCPhysLast, pszDesc,
972 pRam->GCPhys, pRam->GCPhysLast, pRam->pszDesc),
973 VERR_PGM_RAM_CONFLICT);
974
975 /* next */
976 pPrev = pRam;
977 pRam = pRam->pNextR3;
978 }
979
980 /*
981 * Register it with GMM (the API bitches).
982 */
983 const RTGCPHYS cPages = cb >> PAGE_SHIFT;
984 int rc = MMR3IncreaseBaseReservation(pVM, cPages);
985 if (RT_FAILURE(rc))
986 {
987 pgmUnlock(pVM);
988 return rc;
989 }
990
991 if ( GCPhys >= _4G
992 && cPages > 256)
993 {
994 /*
995 * The PGMRAMRANGE structures for the high memory can get very big.
996 * In order to avoid SUPR3PageAllocEx allocation failures due to the
997 * allocation size limit there and also to avoid being unable to find
998 * guest mapping space for them, we split this memory up into 4MB in
999 * (potential) raw-mode configs and 16MB chunks in forced AMD-V/VT-x
1000 * mode.
1001 *
1002 * The first and last page of each mapping are guard pages and marked
1003 * not-present. So, we've got 4186112 and 16769024 bytes available for
1004 * the PGMRAMRANGE structure.
1005 *
1006 * Note! The sizes used here will influence the saved state.
1007 */
1008 uint32_t cbChunk;
1009 uint32_t cPagesPerChunk;
1010 if (VMMIsHwVirtExtForced(pVM))
1011 {
1012 cbChunk = 16U*_1M;
1013 cPagesPerChunk = 1048048; /* max ~1048059 */
1014 AssertCompile(sizeof(PGMRAMRANGE) + sizeof(PGMPAGE) * 1048048 < 16U*_1M - PAGE_SIZE * 2);
1015 }
1016 else
1017 {
1018 cbChunk = 4U*_1M;
1019 cPagesPerChunk = 261616; /* max ~261627 */
1020 AssertCompile(sizeof(PGMRAMRANGE) + sizeof(PGMPAGE) * 261616 < 4U*_1M - PAGE_SIZE * 2);
1021 }
1022 AssertRelease(RT_UOFFSETOF(PGMRAMRANGE, aPages[cPagesPerChunk]) + PAGE_SIZE * 2 <= cbChunk);
1023
1024 RTGCPHYS cPagesLeft = cPages;
1025 RTGCPHYS GCPhysChunk = GCPhys;
1026 uint32_t iChunk = 0;
1027 while (cPagesLeft > 0)
1028 {
1029 uint32_t cPagesInChunk = cPagesLeft;
1030 if (cPagesInChunk > cPagesPerChunk)
1031 cPagesInChunk = cPagesPerChunk;
1032
1033 rc = pgmR3PhysRegisterHighRamChunk(pVM, GCPhysChunk, cPagesInChunk, cbChunk, iChunk, pszDesc, &pPrev);
1034 AssertRCReturn(rc, rc);
1035
1036 /* advance */
1037 GCPhysChunk += (RTGCPHYS)cPagesInChunk << PAGE_SHIFT;
1038 cPagesLeft -= cPagesInChunk;
1039 iChunk++;
1040 }
1041 }
1042 else
1043 {
1044 /*
1045 * Allocate, initialize and link the new RAM range.
1046 */
1047 const size_t cbRamRange = RT_OFFSETOF(PGMRAMRANGE, aPages[cPages]);
1048 PPGMRAMRANGE pNew;
1049 rc = MMR3HyperAllocOnceNoRel(pVM, cbRamRange, 0, MM_TAG_PGM_PHYS, (void **)&pNew);
1050 AssertLogRelMsgRCReturn(rc, ("cbRamRange=%zu\n", cbRamRange), rc);
1051
1052 pgmR3PhysInitAndLinkRamRange(pVM, pNew, GCPhys, GCPhysLast, NIL_RTRCPTR, NIL_RTR0PTR, pszDesc, pPrev);
1053 }
1054 PGMPhysInvalidatePageMapTLB(pVM);
1055 pgmUnlock(pVM);
1056
1057 /*
1058 * Notify REM.
1059 */
1060 REMR3NotifyPhysRamRegister(pVM, GCPhys, cb, REM_NOTIFY_PHYS_RAM_FLAGS_RAM);
1061
1062 return VINF_SUCCESS;
1063}
1064
1065
1066/**
1067 * Worker called by PGMR3InitFinalize if we're configured to pre-allocate RAM.
1068 *
1069 * We do this late in the init process so that all the ROM and MMIO ranges have
1070 * been registered already and we don't go wasting memory on them.
1071 *
1072 * @returns VBox status code.
1073 *
1074 * @param pVM Pointer to the shared VM structure.
1075 */
1076int pgmR3PhysRamPreAllocate(PVM pVM)
1077{
1078 Assert(pVM->pgm.s.fRamPreAlloc);
1079 Log(("pgmR3PhysRamPreAllocate: enter\n"));
1080
1081 /*
1082 * Walk the RAM ranges and allocate all RAM pages, halt at
1083 * the first allocation error.
1084 */
1085 uint64_t cPages = 0;
1086 uint64_t NanoTS = RTTimeNanoTS();
1087 pgmLock(pVM);
1088 for (PPGMRAMRANGE pRam = pVM->pgm.s.pRamRangesR3; pRam; pRam = pRam->pNextR3)
1089 {
1090 PPGMPAGE pPage = &pRam->aPages[0];
1091 RTGCPHYS GCPhys = pRam->GCPhys;
1092 uint32_t cLeft = pRam->cb >> PAGE_SHIFT;
1093 while (cLeft-- > 0)
1094 {
1095 if (PGM_PAGE_GET_TYPE(pPage) == PGMPAGETYPE_RAM)
1096 {
1097 switch (PGM_PAGE_GET_STATE(pPage))
1098 {
1099 case PGM_PAGE_STATE_ZERO:
1100 {
1101 int rc = pgmPhysAllocPage(pVM, pPage, GCPhys);
1102 if (RT_FAILURE(rc))
1103 {
1104 LogRel(("PGM: RAM Pre-allocation failed at %RGp (in %s) with rc=%Rrc\n", GCPhys, pRam->pszDesc, rc));
1105 pgmUnlock(pVM);
1106 return rc;
1107 }
1108 cPages++;
1109 break;
1110 }
1111
1112 case PGM_PAGE_STATE_ALLOCATED:
1113 case PGM_PAGE_STATE_WRITE_MONITORED:
1114 case PGM_PAGE_STATE_SHARED:
1115 /* nothing to do here. */
1116 break;
1117 }
1118 }
1119
1120 /* next */
1121 pPage++;
1122 GCPhys += PAGE_SIZE;
1123 }
1124 }
1125 pgmUnlock(pVM);
1126 NanoTS = RTTimeNanoTS() - NanoTS;
1127
1128 LogRel(("PGM: Pre-allocated %llu pages in %llu ms\n", cPages, NanoTS / 1000000));
1129 Log(("pgmR3PhysRamPreAllocate: returns VINF_SUCCESS\n"));
1130 return VINF_SUCCESS;
1131}
1132
1133
1134/**
1135 * Resets (zeros) the RAM.
1136 *
1137 * ASSUMES that the caller owns the PGM lock.
1138 *
1139 * @returns VBox status code.
1140 * @param pVM Pointer to the shared VM structure.
1141 */
1142int pgmR3PhysRamReset(PVM pVM)
1143{
1144 Assert(PGMIsLockOwner(pVM));
1145
1146 /*
1147 * We batch up pages that should be freed instead of calling GMM for
1148 * each and every one of them.
1149 */
1150 uint32_t cPendingPages = 0;
1151 PGMMFREEPAGESREQ pReq;
1152 int rc = GMMR3FreePagesPrepare(pVM, &pReq, PGMPHYS_FREE_PAGE_BATCH_SIZE, GMMACCOUNT_BASE);
1153 AssertLogRelRCReturn(rc, rc);
1154
1155 /*
1156 * Walk the ram ranges.
1157 */
1158 for (PPGMRAMRANGE pRam = pVM->pgm.s.pRamRangesR3; pRam; pRam = pRam->pNextR3)
1159 {
1160 uint32_t iPage = pRam->cb >> PAGE_SHIFT;
1161 AssertMsg(((RTGCPHYS)iPage << PAGE_SHIFT) == pRam->cb, ("%RGp %RGp\n", (RTGCPHYS)iPage << PAGE_SHIFT, pRam->cb));
1162
1163 if (!pVM->pgm.s.fRamPreAlloc)
1164 {
1165 /* Replace all RAM pages by ZERO pages. */
1166 while (iPage-- > 0)
1167 {
1168 PPGMPAGE pPage = &pRam->aPages[iPage];
1169 switch (PGM_PAGE_GET_TYPE(pPage))
1170 {
1171 case PGMPAGETYPE_RAM:
1172 if (!PGM_PAGE_IS_ZERO(pPage))
1173 {
1174 rc = pgmPhysFreePage(pVM, pReq, &cPendingPages, pPage, pRam->GCPhys + ((RTGCPHYS)iPage << PAGE_SHIFT));
1175 AssertLogRelRCReturn(rc, rc);
1176 }
1177 break;
1178
1179 case PGMPAGETYPE_MMIO2_ALIAS_MMIO:
1180 pgmHandlerPhysicalResetAliasedPage(pVM, pPage, pRam->GCPhys + ((RTGCPHYS)iPage << PAGE_SHIFT));
1181 break;
1182
1183 case PGMPAGETYPE_MMIO2:
1184 case PGMPAGETYPE_ROM_SHADOW: /* handled by pgmR3PhysRomReset. */
1185 case PGMPAGETYPE_ROM:
1186 case PGMPAGETYPE_MMIO:
1187 break;
1188 default:
1189 AssertFailed();
1190 }
1191 } /* for each page */
1192 }
1193 else
1194 {
1195 /* Zero the memory. */
1196 while (iPage-- > 0)
1197 {
1198 PPGMPAGE pPage = &pRam->aPages[iPage];
1199 switch (PGM_PAGE_GET_TYPE(pPage))
1200 {
1201 case PGMPAGETYPE_RAM:
1202 switch (PGM_PAGE_GET_STATE(pPage))
1203 {
1204 case PGM_PAGE_STATE_ZERO:
1205 break;
1206 case PGM_PAGE_STATE_SHARED:
1207 case PGM_PAGE_STATE_WRITE_MONITORED:
1208 rc = pgmPhysPageMakeWritable(pVM, pPage, pRam->GCPhys + ((RTGCPHYS)iPage << PAGE_SHIFT));
1209 AssertLogRelRCReturn(rc, rc);
1210 case PGM_PAGE_STATE_ALLOCATED:
1211 {
1212 void *pvPage;
1213 rc = pgmPhysPageMap(pVM, pPage, pRam->GCPhys + ((RTGCPHYS)iPage << PAGE_SHIFT), &pvPage);
1214 AssertLogRelRCReturn(rc, rc);
1215 ASMMemZeroPage(pvPage);
1216 break;
1217 }
1218 }
1219 break;
1220
1221 case PGMPAGETYPE_MMIO2_ALIAS_MMIO:
1222 pgmHandlerPhysicalResetAliasedPage(pVM, pPage, pRam->GCPhys + ((RTGCPHYS)iPage << PAGE_SHIFT));
1223 break;
1224
1225 case PGMPAGETYPE_MMIO2:
1226 case PGMPAGETYPE_ROM_SHADOW:
1227 case PGMPAGETYPE_ROM:
1228 case PGMPAGETYPE_MMIO:
1229 break;
1230 default:
1231 AssertFailed();
1232
1233 }
1234 } /* for each page */
1235 }
1236
1237 }
1238
1239 /*
1240 * Finish off any pages pending freeing.
1241 */
1242 if (cPendingPages)
1243 {
1244 rc = GMMR3FreePagesPerform(pVM, pReq, cPendingPages);
1245 AssertLogRelRCReturn(rc, rc);
1246 }
1247 GMMR3FreePagesCleanup(pReq);
1248
1249 return VINF_SUCCESS;
1250}
1251
1252
1253/**
1254 * This is the interface IOM is using to register an MMIO region.
1255 *
1256 * It will check for conflicts and ensure that a RAM range structure
1257 * is present before calling the PGMR3HandlerPhysicalRegister API to
1258 * register the callbacks.
1259 *
1260 * @returns VBox status code.
1261 *
1262 * @param pVM Pointer to the shared VM structure.
1263 * @param GCPhys The start of the MMIO region.
1264 * @param cb The size of the MMIO region.
1265 * @param pfnHandlerR3 The address of the ring-3 handler. (IOMR3MMIOHandler)
1266 * @param pvUserR3 The user argument for R3.
1267 * @param pfnHandlerR0 The address of the ring-0 handler. (IOMMMIOHandler)
1268 * @param pvUserR0 The user argument for R0.
1269 * @param pfnHandlerRC The address of the RC handler. (IOMMMIOHandler)
1270 * @param pvUserRC The user argument for RC.
1271 * @param pszDesc The description of the MMIO region.
1272 */
1273VMMR3DECL(int) PGMR3PhysMMIORegister(PVM pVM, RTGCPHYS GCPhys, RTGCPHYS cb,
1274 R3PTRTYPE(PFNPGMR3PHYSHANDLER) pfnHandlerR3, RTR3PTR pvUserR3,
1275 R0PTRTYPE(PFNPGMR0PHYSHANDLER) pfnHandlerR0, RTR0PTR pvUserR0,
1276 RCPTRTYPE(PFNPGMRCPHYSHANDLER) pfnHandlerRC, RTRCPTR pvUserRC,
1277 R3PTRTYPE(const char *) pszDesc)
1278{
1279 /*
1280 * Assert on some assumption.
1281 */
1282 VM_ASSERT_EMT(pVM);
1283 AssertReturn(!(cb & PAGE_OFFSET_MASK), VERR_INVALID_PARAMETER);
1284 AssertReturn(!(GCPhys & PAGE_OFFSET_MASK), VERR_INVALID_PARAMETER);
1285 AssertPtrReturn(pszDesc, VERR_INVALID_POINTER);
1286 AssertReturn(*pszDesc, VERR_INVALID_PARAMETER);
1287
1288 /*
1289 * Make sure there's a RAM range structure for the region.
1290 */
1291 int rc;
1292 RTGCPHYS GCPhysLast = GCPhys + (cb - 1);
1293 bool fRamExists = false;
1294 PPGMRAMRANGE pRamPrev = NULL;
1295 PPGMRAMRANGE pRam = pVM->pgm.s.pRamRangesR3;
1296 while (pRam && GCPhysLast >= pRam->GCPhys)
1297 {
1298 if ( GCPhysLast >= pRam->GCPhys
1299 && GCPhys <= pRam->GCPhysLast)
1300 {
1301 /* Simplification: all within the same range. */
1302 AssertLogRelMsgReturn( GCPhys >= pRam->GCPhys
1303 && GCPhysLast <= pRam->GCPhysLast,
1304 ("%RGp-%RGp (MMIO/%s) falls partly outside %RGp-%RGp (%s)\n",
1305 GCPhys, GCPhysLast, pszDesc,
1306 pRam->GCPhys, pRam->GCPhysLast, pRam->pszDesc),
1307 VERR_PGM_RAM_CONFLICT);
1308
1309 /* Check that it's all RAM or MMIO pages. */
1310 PCPGMPAGE pPage = &pRam->aPages[(GCPhys - pRam->GCPhys) >> PAGE_SHIFT];
1311 uint32_t cLeft = cb >> PAGE_SHIFT;
1312 while (cLeft-- > 0)
1313 {
1314 AssertLogRelMsgReturn( PGM_PAGE_GET_TYPE(pPage) == PGMPAGETYPE_RAM
1315 || PGM_PAGE_GET_TYPE(pPage) == PGMPAGETYPE_MMIO,
1316 ("%RGp-%RGp (MMIO/%s): %RGp is not a RAM or MMIO page - type=%d desc=%s\n",
1317 GCPhys, GCPhysLast, pszDesc, PGM_PAGE_GET_TYPE(pPage), pRam->pszDesc),
1318 VERR_PGM_RAM_CONFLICT);
1319 pPage++;
1320 }
1321
1322 /* Looks good. */
1323 fRamExists = true;
1324 break;
1325 }
1326
1327 /* next */
1328 pRamPrev = pRam;
1329 pRam = pRam->pNextR3;
1330 }
1331 PPGMRAMRANGE pNew;
1332 if (fRamExists)
1333 {
1334 pNew = NULL;
1335
1336 /*
1337 * Make all the pages in the range MMIO/ZERO pages, freeing any
1338 * RAM pages currently mapped here. This might not be 100% correct
1339 * for PCI memory, but we're doing the same thing for MMIO2 pages.
1340 */
1341 rc = pgmLock(pVM);
1342 if (RT_SUCCESS(rc))
1343 {
1344 rc = pgmR3PhysFreePageRange(pVM, pRam, GCPhys, GCPhysLast, PGMPAGETYPE_MMIO);
1345 pgmUnlock(pVM);
1346 }
1347 AssertRCReturn(rc, rc);
1348 }
1349 else
1350 {
1351 pgmLock(pVM);
1352
1353 /*
1354 * No RAM range, insert an ad hoc one.
1355 *
1356 * Note that we don't have to tell REM about this range because
1357 * PGMHandlerPhysicalRegisterEx will do that for us.
1358 */
1359 Log(("PGMR3PhysMMIORegister: Adding ad hoc MMIO range for %RGp-%RGp %s\n", GCPhys, GCPhysLast, pszDesc));
1360
1361 const uint32_t cPages = cb >> PAGE_SHIFT;
1362 const size_t cbRamRange = RT_OFFSETOF(PGMRAMRANGE, aPages[cPages]);
1363 rc = MMHyperAlloc(pVM, RT_OFFSETOF(PGMRAMRANGE, aPages[cPages]), 16, MM_TAG_PGM_PHYS, (void **)&pNew);
1364 AssertLogRelMsgRCReturn(rc, ("cbRamRange=%zu\n", cbRamRange), rc);
1365
1366 /* Initialize the range. */
1367 pNew->pSelfR0 = MMHyperCCToR0(pVM, pNew);
1368 pNew->pSelfRC = MMHyperCCToRC(pVM, pNew);
1369 pNew->GCPhys = GCPhys;
1370 pNew->GCPhysLast = GCPhysLast;
1371 pNew->cb = cb;
1372 pNew->pszDesc = pszDesc;
1373 pNew->fFlags = PGM_RAM_RANGE_FLAGS_AD_HOC_MMIO;
1374 pNew->pvR3 = NULL;
1375 pNew->paLSPages = NULL;
1376
1377 uint32_t iPage = cPages;
1378 while (iPage-- > 0)
1379 PGM_PAGE_INIT_ZERO(&pNew->aPages[iPage], pVM, PGMPAGETYPE_MMIO);
1380 Assert(PGM_PAGE_GET_TYPE(&pNew->aPages[0]) == PGMPAGETYPE_MMIO);
1381
1382 /* update the page count stats. */
1383 pVM->pgm.s.cPureMmioPages += cPages;
1384 pVM->pgm.s.cAllPages += cPages;
1385
1386 /* link it */
1387 pgmR3PhysLinkRamRange(pVM, pNew, pRamPrev);
1388
1389 pgmUnlock(pVM);
1390 }
1391
1392 /*
1393 * Register the access handler.
1394 */
1395 rc = PGMHandlerPhysicalRegisterEx(pVM, PGMPHYSHANDLERTYPE_MMIO, GCPhys, GCPhysLast,
1396 pfnHandlerR3, pvUserR3,
1397 pfnHandlerR0, pvUserR0,
1398 pfnHandlerRC, pvUserRC, pszDesc);
1399 if ( RT_FAILURE(rc)
1400 && !fRamExists)
1401 {
1402 pVM->pgm.s.cPureMmioPages -= cb >> PAGE_SHIFT;
1403 pVM->pgm.s.cAllPages -= cb >> PAGE_SHIFT;
1404
1405 /* remove the ad hoc range. */
1406 pgmR3PhysUnlinkRamRange2(pVM, pNew, pRamPrev);
1407 pNew->cb = pNew->GCPhys = pNew->GCPhysLast = NIL_RTGCPHYS;
1408 MMHyperFree(pVM, pRam);
1409 }
1410 PGMPhysInvalidatePageMapTLB(pVM);
1411
1412 return rc;
1413}
1414
1415
1416/**
1417 * This is the interface IOM is using to register an MMIO region.
1418 *
1419 * It will take care of calling PGMHandlerPhysicalDeregister and clean up
1420 * any ad hoc PGMRAMRANGE left behind.
1421 *
1422 * @returns VBox status code.
1423 * @param pVM Pointer to the shared VM structure.
1424 * @param GCPhys The start of the MMIO region.
1425 * @param cb The size of the MMIO region.
1426 */
1427VMMR3DECL(int) PGMR3PhysMMIODeregister(PVM pVM, RTGCPHYS GCPhys, RTGCPHYS cb)
1428{
1429 VM_ASSERT_EMT(pVM);
1430
1431 /*
1432 * First deregister the handler, then check if we should remove the ram range.
1433 */
1434 int rc = PGMHandlerPhysicalDeregister(pVM, GCPhys);
1435 if (RT_SUCCESS(rc))
1436 {
1437 RTGCPHYS GCPhysLast = GCPhys + (cb - 1);
1438 PPGMRAMRANGE pRamPrev = NULL;
1439 PPGMRAMRANGE pRam = pVM->pgm.s.pRamRangesR3;
1440 while (pRam && GCPhysLast >= pRam->GCPhys)
1441 {
1442 /** @todo We're being a bit too careful here. rewrite. */
1443 if ( GCPhysLast == pRam->GCPhysLast
1444 && GCPhys == pRam->GCPhys)
1445 {
1446 Assert(pRam->cb == cb);
1447
1448 /*
1449 * See if all the pages are dead MMIO pages.
1450 */
1451 uint32_t const cPages = cb >> PAGE_SHIFT;
1452 bool fAllMMIO = true;
1453 uint32_t iPage = 0;
1454 uint32_t cLeft = cPages;
1455 while (cLeft-- > 0)
1456 {
1457 PPGMPAGE pPage = &pRam->aPages[iPage];
1458 if ( PGM_PAGE_GET_TYPE(pPage) != PGMPAGETYPE_MMIO
1459 /*|| not-out-of-action later */)
1460 {
1461 fAllMMIO = false;
1462 Assert(PGM_PAGE_GET_TYPE(pPage) != PGMPAGETYPE_MMIO2_ALIAS_MMIO);
1463 AssertMsgFailed(("%RGp %R[pgmpage]\n", pRam->GCPhys + ((RTGCPHYS)iPage << PAGE_SHIFT), pPage));
1464 break;
1465 }
1466 Assert(PGM_PAGE_IS_ZERO(pPage));
1467 pPage++;
1468 }
1469 if (fAllMMIO)
1470 {
1471 /*
1472 * Ad-hoc range, unlink and free it.
1473 */
1474 Log(("PGMR3PhysMMIODeregister: Freeing ad hoc MMIO range for %RGp-%RGp %s\n",
1475 GCPhys, GCPhysLast, pRam->pszDesc));
1476
1477 pVM->pgm.s.cAllPages -= cPages;
1478 pVM->pgm.s.cPureMmioPages -= cPages;
1479
1480 pgmR3PhysUnlinkRamRange2(pVM, pRam, pRamPrev);
1481 pRam->cb = pRam->GCPhys = pRam->GCPhysLast = NIL_RTGCPHYS;
1482 MMHyperFree(pVM, pRam);
1483 break;
1484 }
1485 }
1486
1487 /*
1488 * Range match? It will all be within one range (see PGMAllHandler.cpp).
1489 */
1490 if ( GCPhysLast >= pRam->GCPhys
1491 && GCPhys <= pRam->GCPhysLast)
1492 {
1493 Assert(GCPhys >= pRam->GCPhys);
1494 Assert(GCPhysLast <= pRam->GCPhysLast);
1495
1496 /*
1497 * Turn the pages back into RAM pages.
1498 */
1499 uint32_t iPage = (GCPhys - pRam->GCPhys) >> PAGE_SHIFT;
1500 uint32_t cLeft = cb >> PAGE_SHIFT;
1501 while (cLeft--)
1502 {
1503 PPGMPAGE pPage = &pRam->aPages[iPage];
1504 AssertMsg(PGM_PAGE_IS_MMIO(pPage), ("%RGp %R[pgmpage]\n", pRam->GCPhys + ((RTGCPHYS)iPage << PAGE_SHIFT), pPage));
1505 AssertMsg(PGM_PAGE_IS_ZERO(pPage), ("%RGp %R[pgmpage]\n", pRam->GCPhys + ((RTGCPHYS)iPage << PAGE_SHIFT), pPage));
1506 if (PGM_PAGE_GET_TYPE(pPage) == PGMPAGETYPE_MMIO)
1507 PGM_PAGE_SET_TYPE(pPage, PGMPAGETYPE_RAM);
1508 }
1509 break;
1510 }
1511
1512 /* next */
1513 pRamPrev = pRam;
1514 pRam = pRam->pNextR3;
1515 }
1516 }
1517
1518 PGMPhysInvalidatePageMapTLB(pVM);
1519 return rc;
1520}
1521
1522
1523/**
1524 * Locate a MMIO2 range.
1525 *
1526 * @returns Pointer to the MMIO2 range.
1527 * @param pVM Pointer to the shared VM structure.
1528 * @param pDevIns The device instance owning the region.
1529 * @param iRegion The region.
1530 */
1531DECLINLINE(PPGMMMIO2RANGE) pgmR3PhysMMIO2Find(PVM pVM, PPDMDEVINS pDevIns, uint32_t iRegion)
1532{
1533 /*
1534 * Search the list.
1535 */
1536 for (PPGMMMIO2RANGE pCur = pVM->pgm.s.pMmio2RangesR3; pCur; pCur = pCur->pNextR3)
1537 if ( pCur->pDevInsR3 == pDevIns
1538 && pCur->iRegion == iRegion)
1539 return pCur;
1540 return NULL;
1541}
1542
1543
1544/**
1545 * Allocate and register an MMIO2 region.
1546 *
1547 * As mentioned elsewhere, MMIO2 is just RAM spelled differently. It's
1548 * RAM associated with a device. It is also non-shared memory with a
1549 * permanent ring-3 mapping and page backing (presently).
1550 *
1551 * A MMIO2 range may overlap with base memory if a lot of RAM
1552 * is configured for the VM, in which case we'll drop the base
1553 * memory pages. Presently we will make no attempt to preserve
1554 * anything that happens to be present in the base memory that
1555 * is replaced, this is of course incorrectly but it's too much
1556 * effort.
1557 *
1558 * @returns VBox status code.
1559 * @retval VINF_SUCCESS on success, *ppv pointing to the R3 mapping of the memory.
1560 * @retval VERR_ALREADY_EXISTS if the region already exists.
1561 *
1562 * @param pVM Pointer to the shared VM structure.
1563 * @param pDevIns The device instance owning the region.
1564 * @param iRegion The region number. If the MMIO2 memory is a PCI I/O region
1565 * this number has to be the number of that region. Otherwise
1566 * it can be any number safe UINT8_MAX.
1567 * @param cb The size of the region. Must be page aligned.
1568 * @param fFlags Reserved for future use, must be zero.
1569 * @param ppv Where to store the pointer to the ring-3 mapping of the memory.
1570 * @param pszDesc The description.
1571 */
1572VMMR3DECL(int) PGMR3PhysMMIO2Register(PVM pVM, PPDMDEVINS pDevIns, uint32_t iRegion, RTGCPHYS cb, uint32_t fFlags, void **ppv, const char *pszDesc)
1573{
1574 /*
1575 * Validate input.
1576 */
1577 VM_ASSERT_EMT_RETURN(pVM, VERR_VM_THREAD_NOT_EMT);
1578 AssertPtrReturn(pDevIns, VERR_INVALID_PARAMETER);
1579 AssertReturn(iRegion <= UINT8_MAX, VERR_INVALID_PARAMETER);
1580 AssertPtrReturn(ppv, VERR_INVALID_POINTER);
1581 AssertPtrReturn(pszDesc, VERR_INVALID_POINTER);
1582 AssertReturn(*pszDesc, VERR_INVALID_PARAMETER);
1583 AssertReturn(pgmR3PhysMMIO2Find(pVM, pDevIns, iRegion) == NULL, VERR_ALREADY_EXISTS);
1584 AssertReturn(!(cb & PAGE_OFFSET_MASK), VERR_INVALID_PARAMETER);
1585 AssertReturn(cb, VERR_INVALID_PARAMETER);
1586 AssertReturn(!fFlags, VERR_INVALID_PARAMETER);
1587
1588 const uint32_t cPages = cb >> PAGE_SHIFT;
1589 AssertLogRelReturn(((RTGCPHYS)cPages << PAGE_SHIFT) == cb, VERR_INVALID_PARAMETER);
1590 AssertLogRelReturn(cPages <= INT32_MAX / 2, VERR_NO_MEMORY);
1591
1592 /*
1593 * For the 2nd+ instance, mangle the description string so it's unique.
1594 */
1595 if (pDevIns->iInstance > 0) /** @todo Move to PDMDevHlp.cpp and use a real string cache. */
1596 {
1597 pszDesc = MMR3HeapAPrintf(pVM, MM_TAG_PGM_PHYS, "%s [%u]", pszDesc, pDevIns->iInstance);
1598 if (!pszDesc)
1599 return VERR_NO_MEMORY;
1600 }
1601
1602 /*
1603 * Try reserve and allocate the backing memory first as this is what is
1604 * most likely to fail.
1605 */
1606 int rc = MMR3AdjustFixedReservation(pVM, cPages, pszDesc);
1607 if (RT_SUCCESS(rc))
1608 {
1609 void *pvPages;
1610 PSUPPAGE paPages = (PSUPPAGE)RTMemTmpAlloc(cPages * sizeof(SUPPAGE));
1611 if (RT_SUCCESS(rc))
1612 rc = SUPR3PageAllocEx(cPages, 0 /*fFlags*/, &pvPages, NULL /*pR0Ptr*/, paPages);
1613 if (RT_SUCCESS(rc))
1614 {
1615 memset(pvPages, 0, cPages * PAGE_SIZE);
1616
1617 /*
1618 * Create the MMIO2 range record for it.
1619 */
1620 const size_t cbRange = RT_OFFSETOF(PGMMMIO2RANGE, RamRange.aPages[cPages]);
1621 PPGMMMIO2RANGE pNew;
1622 rc = MMR3HyperAllocOnceNoRel(pVM, cbRange, 0, MM_TAG_PGM_PHYS, (void **)&pNew);
1623 AssertLogRelMsgRC(rc, ("cbRamRange=%zu\n", cbRange));
1624 if (RT_SUCCESS(rc))
1625 {
1626 pNew->pDevInsR3 = pDevIns;
1627 pNew->pvR3 = pvPages;
1628 //pNew->pNext = NULL;
1629 //pNew->fMapped = false;
1630 //pNew->fOverlapping = false;
1631 pNew->iRegion = iRegion;
1632 pNew->idSavedState = UINT8_MAX;
1633 pNew->RamRange.pSelfR0 = MMHyperCCToR0(pVM, &pNew->RamRange);
1634 pNew->RamRange.pSelfRC = MMHyperCCToRC(pVM, &pNew->RamRange);
1635 pNew->RamRange.GCPhys = NIL_RTGCPHYS;
1636 pNew->RamRange.GCPhysLast = NIL_RTGCPHYS;
1637 pNew->RamRange.pszDesc = pszDesc;
1638 pNew->RamRange.cb = cb;
1639 pNew->RamRange.fFlags = PGM_RAM_RANGE_FLAGS_AD_HOC_MMIO2;
1640 pNew->RamRange.pvR3 = pvPages;
1641 //pNew->RamRange.paLSPages = NULL;
1642
1643 uint32_t iPage = cPages;
1644 while (iPage-- > 0)
1645 {
1646 PGM_PAGE_INIT(&pNew->RamRange.aPages[iPage],
1647 paPages[iPage].Phys, NIL_GMM_PAGEID,
1648 PGMPAGETYPE_MMIO2, PGM_PAGE_STATE_ALLOCATED);
1649 }
1650
1651 /* update page count stats */
1652 pVM->pgm.s.cAllPages += cPages;
1653 pVM->pgm.s.cPrivatePages += cPages;
1654
1655 /*
1656 * Link it into the list.
1657 * Since there is no particular order, just push it.
1658 */
1659 pgmLock(pVM);
1660 pNew->pNextR3 = pVM->pgm.s.pMmio2RangesR3;
1661 pVM->pgm.s.pMmio2RangesR3 = pNew;
1662 pgmUnlock(pVM);
1663
1664 *ppv = pvPages;
1665 RTMemTmpFree(paPages);
1666 PGMPhysInvalidatePageMapTLB(pVM);
1667 return VINF_SUCCESS;
1668 }
1669
1670 SUPR3PageFreeEx(pvPages, cPages);
1671 }
1672 RTMemTmpFree(paPages);
1673 MMR3AdjustFixedReservation(pVM, -(int32_t)cPages, pszDesc);
1674 }
1675 if (pDevIns->iInstance > 0)
1676 MMR3HeapFree((void *)pszDesc);
1677 return rc;
1678}
1679
1680
1681/**
1682 * Deregisters and frees an MMIO2 region.
1683 *
1684 * Any physical (and virtual) access handlers registered for the region must
1685 * be deregistered before calling this function.
1686 *
1687 * @returns VBox status code.
1688 * @param pVM Pointer to the shared VM structure.
1689 * @param pDevIns The device instance owning the region.
1690 * @param iRegion The region. If it's UINT32_MAX it'll be a wildcard match.
1691 */
1692VMMR3DECL(int) PGMR3PhysMMIO2Deregister(PVM pVM, PPDMDEVINS pDevIns, uint32_t iRegion)
1693{
1694 /*
1695 * Validate input.
1696 */
1697 VM_ASSERT_EMT_RETURN(pVM, VERR_VM_THREAD_NOT_EMT);
1698 AssertPtrReturn(pDevIns, VERR_INVALID_PARAMETER);
1699 AssertReturn(iRegion <= UINT8_MAX || iRegion == UINT32_MAX, VERR_INVALID_PARAMETER);
1700
1701 pgmLock(pVM);
1702 int rc = VINF_SUCCESS;
1703 unsigned cFound = 0;
1704 PPGMMMIO2RANGE pPrev = NULL;
1705 PPGMMMIO2RANGE pCur = pVM->pgm.s.pMmio2RangesR3;
1706 while (pCur)
1707 {
1708 if ( pCur->pDevInsR3 == pDevIns
1709 && ( iRegion == UINT32_MAX
1710 || pCur->iRegion == iRegion))
1711 {
1712 cFound++;
1713
1714 /*
1715 * Unmap it if it's mapped.
1716 */
1717 if (pCur->fMapped)
1718 {
1719 int rc2 = PGMR3PhysMMIO2Unmap(pVM, pCur->pDevInsR3, pCur->iRegion, pCur->RamRange.GCPhys);
1720 AssertRC(rc2);
1721 if (RT_FAILURE(rc2) && RT_SUCCESS(rc))
1722 rc = rc2;
1723 }
1724
1725 /*
1726 * Unlink it
1727 */
1728 PPGMMMIO2RANGE pNext = pCur->pNextR3;
1729 if (pPrev)
1730 pPrev->pNextR3 = pNext;
1731 else
1732 pVM->pgm.s.pMmio2RangesR3 = pNext;
1733 pCur->pNextR3 = NULL;
1734
1735 /*
1736 * Free the memory.
1737 */
1738 int rc2 = SUPR3PageFreeEx(pCur->pvR3, pCur->RamRange.cb >> PAGE_SHIFT);
1739 AssertRC(rc2);
1740 if (RT_FAILURE(rc2) && RT_SUCCESS(rc))
1741 rc = rc2;
1742
1743 uint32_t const cPages = pCur->RamRange.cb >> PAGE_SHIFT;
1744 rc2 = MMR3AdjustFixedReservation(pVM, -(int32_t)cPages, pCur->RamRange.pszDesc);
1745 AssertRC(rc2);
1746 if (RT_FAILURE(rc2) && RT_SUCCESS(rc))
1747 rc = rc2;
1748
1749 /* we're leaking hyper memory here if done at runtime. */
1750#ifdef VBOX_STRICT
1751 VMSTATE const enmState = VMR3GetState(pVM);
1752 AssertMsg( enmState == VMSTATE_POWERING_OFF
1753 || enmState == VMSTATE_POWERING_OFF_LS
1754 || enmState == VMSTATE_OFF
1755 || enmState == VMSTATE_OFF_LS
1756 || enmState == VMSTATE_DESTROYING
1757 || enmState == VMSTATE_TERMINATED
1758 || enmState == VMSTATE_CREATING
1759 , ("%s\n", VMR3GetStateName(enmState)));
1760#endif
1761 /*rc = MMHyperFree(pVM, pCur);
1762 AssertRCReturn(rc, rc); - not safe, see the alloc call. */
1763
1764
1765 /* update page count stats */
1766 pVM->pgm.s.cAllPages -= cPages;
1767 pVM->pgm.s.cPrivatePages -= cPages;
1768
1769 /* next */
1770 pCur = pNext;
1771 }
1772 else
1773 {
1774 pPrev = pCur;
1775 pCur = pCur->pNextR3;
1776 }
1777 }
1778 PGMPhysInvalidatePageMapTLB(pVM);
1779 pgmUnlock(pVM);
1780 return !cFound && iRegion != UINT32_MAX ? VERR_NOT_FOUND : rc;
1781}
1782
1783
1784/**
1785 * Maps a MMIO2 region.
1786 *
1787 * This is done when a guest / the bios / state loading changes the
1788 * PCI config. The replacing of base memory has the same restrictions
1789 * as during registration, of course.
1790 *
1791 * @returns VBox status code.
1792 *
1793 * @param pVM Pointer to the shared VM structure.
1794 * @param pDevIns The
1795 */
1796VMMR3DECL(int) PGMR3PhysMMIO2Map(PVM pVM, PPDMDEVINS pDevIns, uint32_t iRegion, RTGCPHYS GCPhys)
1797{
1798 /*
1799 * Validate input
1800 */
1801 VM_ASSERT_EMT_RETURN(pVM, VERR_VM_THREAD_NOT_EMT);
1802 AssertPtrReturn(pDevIns, VERR_INVALID_PARAMETER);
1803 AssertReturn(iRegion <= UINT8_MAX, VERR_INVALID_PARAMETER);
1804 AssertReturn(GCPhys != NIL_RTGCPHYS, VERR_INVALID_PARAMETER);
1805 AssertReturn(GCPhys != 0, VERR_INVALID_PARAMETER);
1806 AssertReturn(!(GCPhys & PAGE_OFFSET_MASK), VERR_INVALID_PARAMETER);
1807
1808 PPGMMMIO2RANGE pCur = pgmR3PhysMMIO2Find(pVM, pDevIns, iRegion);
1809 AssertReturn(pCur, VERR_NOT_FOUND);
1810 AssertReturn(!pCur->fMapped, VERR_WRONG_ORDER);
1811 Assert(pCur->RamRange.GCPhys == NIL_RTGCPHYS);
1812 Assert(pCur->RamRange.GCPhysLast == NIL_RTGCPHYS);
1813
1814 const RTGCPHYS GCPhysLast = GCPhys + pCur->RamRange.cb - 1;
1815 AssertReturn(GCPhysLast > GCPhys, VERR_INVALID_PARAMETER);
1816
1817 /*
1818 * Find our location in the ram range list, checking for
1819 * restriction we don't bother implementing yet (partially overlapping).
1820 */
1821 bool fRamExists = false;
1822 PPGMRAMRANGE pRamPrev = NULL;
1823 PPGMRAMRANGE pRam = pVM->pgm.s.pRamRangesR3;
1824 while (pRam && GCPhysLast >= pRam->GCPhys)
1825 {
1826 if ( GCPhys <= pRam->GCPhysLast
1827 && GCPhysLast >= pRam->GCPhys)
1828 {
1829 /* completely within? */
1830 AssertLogRelMsgReturn( GCPhys >= pRam->GCPhys
1831 && GCPhysLast <= pRam->GCPhysLast,
1832 ("%RGp-%RGp (MMIO2/%s) falls partly outside %RGp-%RGp (%s)\n",
1833 GCPhys, GCPhysLast, pCur->RamRange.pszDesc,
1834 pRam->GCPhys, pRam->GCPhysLast, pRam->pszDesc),
1835 VERR_PGM_RAM_CONFLICT);
1836 fRamExists = true;
1837 break;
1838 }
1839
1840 /* next */
1841 pRamPrev = pRam;
1842 pRam = pRam->pNextR3;
1843 }
1844 if (fRamExists)
1845 {
1846 PPGMPAGE pPage = &pRam->aPages[(GCPhys - pRam->GCPhys) >> PAGE_SHIFT];
1847 uint32_t cPagesLeft = pCur->RamRange.cb >> PAGE_SHIFT;
1848 while (cPagesLeft-- > 0)
1849 {
1850 AssertLogRelMsgReturn(PGM_PAGE_GET_TYPE(pPage) == PGMPAGETYPE_RAM,
1851 ("%RGp isn't a RAM page (%d) - mapping %RGp-%RGp (MMIO2/%s).\n",
1852 GCPhys, PGM_PAGE_GET_TYPE(pPage), GCPhys, GCPhysLast, pCur->RamRange.pszDesc),
1853 VERR_PGM_RAM_CONFLICT);
1854 pPage++;
1855 }
1856 }
1857 Log(("PGMR3PhysMMIO2Map: %RGp-%RGp fRamExists=%RTbool %s\n",
1858 GCPhys, GCPhysLast, fRamExists, pCur->RamRange.pszDesc));
1859
1860 /*
1861 * Make the changes.
1862 */
1863 pgmLock(pVM);
1864
1865 pCur->RamRange.GCPhys = GCPhys;
1866 pCur->RamRange.GCPhysLast = GCPhysLast;
1867 pCur->fMapped = true;
1868 pCur->fOverlapping = fRamExists;
1869
1870 if (fRamExists)
1871 {
1872/** @todo use pgmR3PhysFreePageRange here. */
1873 uint32_t cPendingPages = 0;
1874 PGMMFREEPAGESREQ pReq;
1875 int rc = GMMR3FreePagesPrepare(pVM, &pReq, PGMPHYS_FREE_PAGE_BATCH_SIZE, GMMACCOUNT_BASE);
1876 AssertLogRelRCReturn(rc, rc);
1877
1878 /* replace the pages, freeing all present RAM pages. */
1879 PPGMPAGE pPageSrc = &pCur->RamRange.aPages[0];
1880 PPGMPAGE pPageDst = &pRam->aPages[(GCPhys - pRam->GCPhys) >> PAGE_SHIFT];
1881 uint32_t cPagesLeft = pCur->RamRange.cb >> PAGE_SHIFT;
1882 while (cPagesLeft-- > 0)
1883 {
1884 rc = pgmPhysFreePage(pVM, pReq, &cPendingPages, pPageDst, GCPhys);
1885 AssertLogRelRCReturn(rc, rc); /* We're done for if this goes wrong. */
1886
1887 RTHCPHYS const HCPhys = PGM_PAGE_GET_HCPHYS(pPageSrc);
1888 PGM_PAGE_SET_HCPHYS(pPageDst, HCPhys);
1889 PGM_PAGE_SET_TYPE(pPageDst, PGMPAGETYPE_MMIO2);
1890 PGM_PAGE_SET_STATE(pPageDst, PGM_PAGE_STATE_ALLOCATED);
1891
1892 pVM->pgm.s.cZeroPages--;
1893 GCPhys += PAGE_SIZE;
1894 pPageSrc++;
1895 pPageDst++;
1896 }
1897
1898 /* Flush physical page map TLB. */
1899 PGMPhysInvalidatePageMapTLB(pVM);
1900
1901 if (cPendingPages)
1902 {
1903 rc = GMMR3FreePagesPerform(pVM, pReq, cPendingPages);
1904 AssertLogRelRCReturn(rc, rc);
1905 }
1906 GMMR3FreePagesCleanup(pReq);
1907 pgmUnlock(pVM);
1908 }
1909 else
1910 {
1911 RTGCPHYS cb = pCur->RamRange.cb;
1912
1913 /* link in the ram range */
1914 pgmR3PhysLinkRamRange(pVM, &pCur->RamRange, pRamPrev);
1915 pgmUnlock(pVM);
1916
1917 REMR3NotifyPhysRamRegister(pVM, GCPhys, cb, REM_NOTIFY_PHYS_RAM_FLAGS_MMIO2);
1918 }
1919
1920 PGMPhysInvalidatePageMapTLB(pVM);
1921 return VINF_SUCCESS;
1922}
1923
1924
1925/**
1926 * Unmaps a MMIO2 region.
1927 *
1928 * This is done when a guest / the bios / state loading changes the
1929 * PCI config. The replacing of base memory has the same restrictions
1930 * as during registration, of course.
1931 */
1932VMMR3DECL(int) PGMR3PhysMMIO2Unmap(PVM pVM, PPDMDEVINS pDevIns, uint32_t iRegion, RTGCPHYS GCPhys)
1933{
1934 /*
1935 * Validate input
1936 */
1937 VM_ASSERT_EMT_RETURN(pVM, VERR_VM_THREAD_NOT_EMT);
1938 AssertPtrReturn(pDevIns, VERR_INVALID_PARAMETER);
1939 AssertReturn(iRegion <= UINT8_MAX, VERR_INVALID_PARAMETER);
1940 AssertReturn(GCPhys != NIL_RTGCPHYS, VERR_INVALID_PARAMETER);
1941 AssertReturn(GCPhys != 0, VERR_INVALID_PARAMETER);
1942 AssertReturn(!(GCPhys & PAGE_OFFSET_MASK), VERR_INVALID_PARAMETER);
1943
1944 PPGMMMIO2RANGE pCur = pgmR3PhysMMIO2Find(pVM, pDevIns, iRegion);
1945 AssertReturn(pCur, VERR_NOT_FOUND);
1946 AssertReturn(pCur->fMapped, VERR_WRONG_ORDER);
1947 AssertReturn(pCur->RamRange.GCPhys == GCPhys, VERR_INVALID_PARAMETER);
1948 Assert(pCur->RamRange.GCPhysLast != NIL_RTGCPHYS);
1949
1950 Log(("PGMR3PhysMMIO2Unmap: %RGp-%RGp %s\n",
1951 pCur->RamRange.GCPhys, pCur->RamRange.GCPhysLast, pCur->RamRange.pszDesc));
1952
1953 /*
1954 * Unmap it.
1955 */
1956 pgmLock(pVM);
1957
1958 RTGCPHYS GCPhysRangeREM;
1959 RTGCPHYS cbRangeREM;
1960 bool fInformREM;
1961 if (pCur->fOverlapping)
1962 {
1963 /* Restore the RAM pages we've replaced. */
1964 PPGMRAMRANGE pRam = pVM->pgm.s.pRamRangesR3;
1965 while (pRam->GCPhys > pCur->RamRange.GCPhysLast)
1966 pRam = pRam->pNextR3;
1967
1968 RTHCPHYS const HCPhysZeroPg = pVM->pgm.s.HCPhysZeroPg;
1969 Assert(HCPhysZeroPg != 0 && HCPhysZeroPg != NIL_RTHCPHYS);
1970 PPGMPAGE pPageDst = &pRam->aPages[(pCur->RamRange.GCPhys - pRam->GCPhys) >> PAGE_SHIFT];
1971 uint32_t cPagesLeft = pCur->RamRange.cb >> PAGE_SHIFT;
1972 while (cPagesLeft-- > 0)
1973 {
1974 PGM_PAGE_SET_HCPHYS(pPageDst, HCPhysZeroPg);
1975 PGM_PAGE_SET_TYPE(pPageDst, PGMPAGETYPE_RAM);
1976 PGM_PAGE_SET_STATE(pPageDst, PGM_PAGE_STATE_ZERO);
1977 PGM_PAGE_SET_PAGEID(pPageDst, NIL_GMM_PAGEID);
1978
1979 pVM->pgm.s.cZeroPages++;
1980 pPageDst++;
1981 }
1982
1983 /* Flush physical page map TLB. */
1984 PGMPhysInvalidatePageMapTLB(pVM);
1985
1986 GCPhysRangeREM = NIL_RTGCPHYS; /* shuts up gcc */
1987 cbRangeREM = RTGCPHYS_MAX; /* ditto */
1988 fInformREM = false;
1989 }
1990 else
1991 {
1992 GCPhysRangeREM = pCur->RamRange.GCPhys;
1993 cbRangeREM = pCur->RamRange.cb;
1994 fInformREM = true;
1995
1996 pgmR3PhysUnlinkRamRange(pVM, &pCur->RamRange);
1997 }
1998
1999 pCur->RamRange.GCPhys = NIL_RTGCPHYS;
2000 pCur->RamRange.GCPhysLast = NIL_RTGCPHYS;
2001 pCur->fOverlapping = false;
2002 pCur->fMapped = false;
2003
2004 PGMPhysInvalidatePageMapTLB(pVM);
2005 pgmUnlock(pVM);
2006
2007 if (fInformREM)
2008 REMR3NotifyPhysRamDeregister(pVM, GCPhysRangeREM, cbRangeREM);
2009
2010 return VINF_SUCCESS;
2011}
2012
2013
2014/**
2015 * Checks if the given address is an MMIO2 base address or not.
2016 *
2017 * @returns true/false accordingly.
2018 * @param pVM Pointer to the shared VM structure.
2019 * @param pDevIns The owner of the memory, optional.
2020 * @param GCPhys The address to check.
2021 */
2022VMMR3DECL(bool) PGMR3PhysMMIO2IsBase(PVM pVM, PPDMDEVINS pDevIns, RTGCPHYS GCPhys)
2023{
2024 /*
2025 * Validate input
2026 */
2027 VM_ASSERT_EMT_RETURN(pVM, false);
2028 AssertPtrReturn(pDevIns, false);
2029 AssertReturn(GCPhys != NIL_RTGCPHYS, false);
2030 AssertReturn(GCPhys != 0, false);
2031 AssertReturn(!(GCPhys & PAGE_OFFSET_MASK), false);
2032
2033 /*
2034 * Search the list.
2035 */
2036 pgmLock(pVM);
2037 for (PPGMMMIO2RANGE pCur = pVM->pgm.s.pMmio2RangesR3; pCur; pCur = pCur->pNextR3)
2038 if (pCur->RamRange.GCPhys == GCPhys)
2039 {
2040 Assert(pCur->fMapped);
2041 pgmUnlock(pVM);
2042 return true;
2043 }
2044 pgmUnlock(pVM);
2045 return false;
2046}
2047
2048
2049/**
2050 * Gets the HC physical address of a page in the MMIO2 region.
2051 *
2052 * This is API is intended for MMHyper and shouldn't be called
2053 * by anyone else...
2054 *
2055 * @returns VBox status code.
2056 * @param pVM Pointer to the shared VM structure.
2057 * @param pDevIns The owner of the memory, optional.
2058 * @param iRegion The region.
2059 * @param off The page expressed an offset into the MMIO2 region.
2060 * @param pHCPhys Where to store the result.
2061 */
2062VMMR3DECL(int) PGMR3PhysMMIO2GetHCPhys(PVM pVM, PPDMDEVINS pDevIns, uint32_t iRegion, RTGCPHYS off, PRTHCPHYS pHCPhys)
2063{
2064 /*
2065 * Validate input
2066 */
2067 VM_ASSERT_EMT_RETURN(pVM, VERR_VM_THREAD_NOT_EMT);
2068 AssertPtrReturn(pDevIns, VERR_INVALID_PARAMETER);
2069 AssertReturn(iRegion <= UINT8_MAX, VERR_INVALID_PARAMETER);
2070
2071 pgmLock(pVM);
2072 PPGMMMIO2RANGE pCur = pgmR3PhysMMIO2Find(pVM, pDevIns, iRegion);
2073 AssertReturn(pCur, VERR_NOT_FOUND);
2074 AssertReturn(off < pCur->RamRange.cb, VERR_INVALID_PARAMETER);
2075
2076 PCPGMPAGE pPage = &pCur->RamRange.aPages[off >> PAGE_SHIFT];
2077 *pHCPhys = PGM_PAGE_GET_HCPHYS(pPage);
2078 pgmUnlock(pVM);
2079 return VINF_SUCCESS;
2080}
2081
2082
2083/**
2084 * Maps a portion of an MMIO2 region into kernel space (host).
2085 *
2086 * The kernel mapping will become invalid when the MMIO2 memory is deregistered
2087 * or the VM is terminated.
2088 *
2089 * @return VBox status code.
2090 *
2091 * @param pVM Pointer to the shared VM structure.
2092 * @param pDevIns The device owning the MMIO2 memory.
2093 * @param iRegion The region.
2094 * @param off The offset into the region. Must be page aligned.
2095 * @param cb The number of bytes to map. Must be page aligned.
2096 * @param pszDesc Mapping description.
2097 * @param pR0Ptr Where to store the R0 address.
2098 */
2099VMMR3DECL(int) PGMR3PhysMMIO2MapKernel(PVM pVM, PPDMDEVINS pDevIns, uint32_t iRegion, RTGCPHYS off, RTGCPHYS cb,
2100 const char *pszDesc, PRTR0PTR pR0Ptr)
2101{
2102 /*
2103 * Validate input.
2104 */
2105 VM_ASSERT_EMT_RETURN(pVM, VERR_VM_THREAD_NOT_EMT);
2106 AssertPtrReturn(pDevIns, VERR_INVALID_PARAMETER);
2107 AssertReturn(iRegion <= UINT8_MAX, VERR_INVALID_PARAMETER);
2108
2109 PPGMMMIO2RANGE pCur = pgmR3PhysMMIO2Find(pVM, pDevIns, iRegion);
2110 AssertReturn(pCur, VERR_NOT_FOUND);
2111 AssertReturn(off < pCur->RamRange.cb, VERR_INVALID_PARAMETER);
2112 AssertReturn(cb <= pCur->RamRange.cb, VERR_INVALID_PARAMETER);
2113 AssertReturn(off + cb <= pCur->RamRange.cb, VERR_INVALID_PARAMETER);
2114
2115 /*
2116 * Pass the request on to the support library/driver.
2117 */
2118 int rc = SUPR3PageMapKernel(pCur->pvR3, off, cb, 0, pR0Ptr);
2119
2120 return rc;
2121}
2122
2123
2124/**
2125 * Registers a ROM image.
2126 *
2127 * Shadowed ROM images requires double the amount of backing memory, so,
2128 * don't use that unless you have to. Shadowing of ROM images is process
2129 * where we can select where the reads go and where the writes go. On real
2130 * hardware the chipset provides means to configure this. We provide
2131 * PGMR3PhysProtectROM() for this purpose.
2132 *
2133 * A read-only copy of the ROM image will always be kept around while we
2134 * will allocate RAM pages for the changes on demand (unless all memory
2135 * is configured to be preallocated).
2136 *
2137 * @returns VBox status.
2138 * @param pVM VM Handle.
2139 * @param pDevIns The device instance owning the ROM.
2140 * @param GCPhys First physical address in the range.
2141 * Must be page aligned!
2142 * @param cbRange The size of the range (in bytes).
2143 * Must be page aligned!
2144 * @param pvBinary Pointer to the binary data backing the ROM image.
2145 * This must be exactly \a cbRange in size.
2146 * @param fFlags Mask of flags. PGMPHYS_ROM_FLAGS_SHADOWED
2147 * and/or PGMPHYS_ROM_FLAGS_PERMANENT_BINARY.
2148 * @param pszDesc Pointer to description string. This must not be freed.
2149 *
2150 * @remark There is no way to remove the rom, automatically on device cleanup or
2151 * manually from the device yet. This isn't difficult in any way, it's
2152 * just not something we expect to be necessary for a while.
2153 */
2154VMMR3DECL(int) PGMR3PhysRomRegister(PVM pVM, PPDMDEVINS pDevIns, RTGCPHYS GCPhys, RTGCPHYS cb,
2155 const void *pvBinary, uint32_t fFlags, const char *pszDesc)
2156{
2157 Log(("PGMR3PhysRomRegister: pDevIns=%p GCPhys=%RGp(-%RGp) cb=%RGp pvBinary=%p fFlags=%#x pszDesc=%s\n",
2158 pDevIns, GCPhys, GCPhys + cb, cb, pvBinary, fFlags, pszDesc));
2159
2160 /*
2161 * Validate input.
2162 */
2163 AssertPtrReturn(pDevIns, VERR_INVALID_PARAMETER);
2164 AssertReturn(RT_ALIGN_T(GCPhys, PAGE_SIZE, RTGCPHYS) == GCPhys, VERR_INVALID_PARAMETER);
2165 AssertReturn(RT_ALIGN_T(cb, PAGE_SIZE, RTGCPHYS) == cb, VERR_INVALID_PARAMETER);
2166 RTGCPHYS GCPhysLast = GCPhys + (cb - 1);
2167 AssertReturn(GCPhysLast > GCPhys, VERR_INVALID_PARAMETER);
2168 AssertPtrReturn(pvBinary, VERR_INVALID_PARAMETER);
2169 AssertPtrReturn(pszDesc, VERR_INVALID_POINTER);
2170 AssertReturn(!(fFlags & ~(PGMPHYS_ROM_FLAGS_SHADOWED | PGMPHYS_ROM_FLAGS_PERMANENT_BINARY)), VERR_INVALID_PARAMETER);
2171 VM_ASSERT_STATE_RETURN(pVM, VMSTATE_CREATING, VERR_VM_INVALID_VM_STATE);
2172
2173 const uint32_t cPages = cb >> PAGE_SHIFT;
2174
2175 /*
2176 * Find the ROM location in the ROM list first.
2177 */
2178 PPGMROMRANGE pRomPrev = NULL;
2179 PPGMROMRANGE pRom = pVM->pgm.s.pRomRangesR3;
2180 while (pRom && GCPhysLast >= pRom->GCPhys)
2181 {
2182 if ( GCPhys <= pRom->GCPhysLast
2183 && GCPhysLast >= pRom->GCPhys)
2184 AssertLogRelMsgFailedReturn(("%RGp-%RGp (%s) conflicts with existing %RGp-%RGp (%s)\n",
2185 GCPhys, GCPhysLast, pszDesc,
2186 pRom->GCPhys, pRom->GCPhysLast, pRom->pszDesc),
2187 VERR_PGM_RAM_CONFLICT);
2188 /* next */
2189 pRomPrev = pRom;
2190 pRom = pRom->pNextR3;
2191 }
2192
2193 /*
2194 * Find the RAM location and check for conflicts.
2195 *
2196 * Conflict detection is a bit different than for RAM
2197 * registration since a ROM can be located within a RAM
2198 * range. So, what we have to check for is other memory
2199 * types (other than RAM that is) and that we don't span
2200 * more than one RAM range (layz).
2201 */
2202 bool fRamExists = false;
2203 PPGMRAMRANGE pRamPrev = NULL;
2204 PPGMRAMRANGE pRam = pVM->pgm.s.pRamRangesR3;
2205 while (pRam && GCPhysLast >= pRam->GCPhys)
2206 {
2207 if ( GCPhys <= pRam->GCPhysLast
2208 && GCPhysLast >= pRam->GCPhys)
2209 {
2210 /* completely within? */
2211 AssertLogRelMsgReturn( GCPhys >= pRam->GCPhys
2212 && GCPhysLast <= pRam->GCPhysLast,
2213 ("%RGp-%RGp (%s) falls partly outside %RGp-%RGp (%s)\n",
2214 GCPhys, GCPhysLast, pszDesc,
2215 pRam->GCPhys, pRam->GCPhysLast, pRam->pszDesc),
2216 VERR_PGM_RAM_CONFLICT);
2217 fRamExists = true;
2218 break;
2219 }
2220
2221 /* next */
2222 pRamPrev = pRam;
2223 pRam = pRam->pNextR3;
2224 }
2225 if (fRamExists)
2226 {
2227 PPGMPAGE pPage = &pRam->aPages[(GCPhys - pRam->GCPhys) >> PAGE_SHIFT];
2228 uint32_t cPagesLeft = cPages;
2229 while (cPagesLeft-- > 0)
2230 {
2231 AssertLogRelMsgReturn(PGM_PAGE_GET_TYPE(pPage) == PGMPAGETYPE_RAM,
2232 ("%RGp (%R[pgmpage]) isn't a RAM page - registering %RGp-%RGp (%s).\n",
2233 pRam->GCPhys + ((RTGCPHYS)(uintptr_t)(pPage - &pRam->aPages[0]) << PAGE_SHIFT),
2234 pPage, GCPhys, GCPhysLast, pszDesc), VERR_PGM_RAM_CONFLICT);
2235 Assert(PGM_PAGE_IS_ZERO(pPage));
2236 pPage++;
2237 }
2238 }
2239
2240 /*
2241 * Update the base memory reservation if necessary.
2242 */
2243 uint32_t cExtraBaseCost = fRamExists ? 0 : cPages;
2244 if (fFlags & PGMPHYS_ROM_FLAGS_SHADOWED)
2245 cExtraBaseCost += cPages;
2246 if (cExtraBaseCost)
2247 {
2248 int rc = MMR3IncreaseBaseReservation(pVM, cExtraBaseCost);
2249 if (RT_FAILURE(rc))
2250 return rc;
2251 }
2252
2253 /*
2254 * Allocate memory for the virgin copy of the RAM.
2255 */
2256 PGMMALLOCATEPAGESREQ pReq;
2257 int rc = GMMR3AllocatePagesPrepare(pVM, &pReq, cPages, GMMACCOUNT_BASE);
2258 AssertRCReturn(rc, rc);
2259
2260 for (uint32_t iPage = 0; iPage < cPages; iPage++)
2261 {
2262 pReq->aPages[iPage].HCPhysGCPhys = GCPhys + (iPage << PAGE_SHIFT);
2263 pReq->aPages[iPage].idPage = NIL_GMM_PAGEID;
2264 pReq->aPages[iPage].idSharedPage = NIL_GMM_PAGEID;
2265 }
2266
2267 pgmLock(pVM);
2268 rc = GMMR3AllocatePagesPerform(pVM, pReq);
2269 pgmUnlock(pVM);
2270 if (RT_FAILURE(rc))
2271 {
2272 GMMR3AllocatePagesCleanup(pReq);
2273 return rc;
2274 }
2275
2276 /*
2277 * Allocate the new ROM range and RAM range (if necessary).
2278 */
2279 PPGMROMRANGE pRomNew;
2280 rc = MMHyperAlloc(pVM, RT_OFFSETOF(PGMROMRANGE, aPages[cPages]), 0, MM_TAG_PGM_PHYS, (void **)&pRomNew);
2281 if (RT_SUCCESS(rc))
2282 {
2283 PPGMRAMRANGE pRamNew = NULL;
2284 if (!fRamExists)
2285 rc = MMHyperAlloc(pVM, RT_OFFSETOF(PGMRAMRANGE, aPages[cPages]), sizeof(PGMPAGE), MM_TAG_PGM_PHYS, (void **)&pRamNew);
2286 if (RT_SUCCESS(rc))
2287 {
2288 pgmLock(pVM);
2289
2290 /*
2291 * Initialize and insert the RAM range (if required).
2292 */
2293 PPGMROMPAGE pRomPage = &pRomNew->aPages[0];
2294 if (!fRamExists)
2295 {
2296 pRamNew->pSelfR0 = MMHyperCCToR0(pVM, pRamNew);
2297 pRamNew->pSelfRC = MMHyperCCToRC(pVM, pRamNew);
2298 pRamNew->GCPhys = GCPhys;
2299 pRamNew->GCPhysLast = GCPhysLast;
2300 pRamNew->cb = cb;
2301 pRamNew->pszDesc = pszDesc;
2302 pRamNew->fFlags = PGM_RAM_RANGE_FLAGS_AD_HOC_ROM;
2303 pRamNew->pvR3 = NULL;
2304 pRamNew->paLSPages = NULL;
2305
2306 PPGMPAGE pPage = &pRamNew->aPages[0];
2307 for (uint32_t iPage = 0; iPage < cPages; iPage++, pPage++, pRomPage++)
2308 {
2309 PGM_PAGE_INIT(pPage,
2310 pReq->aPages[iPage].HCPhysGCPhys,
2311 pReq->aPages[iPage].idPage,
2312 PGMPAGETYPE_ROM,
2313 PGM_PAGE_STATE_ALLOCATED);
2314
2315 pRomPage->Virgin = *pPage;
2316 }
2317
2318 pVM->pgm.s.cAllPages += cPages;
2319 pgmR3PhysLinkRamRange(pVM, pRamNew, pRamPrev);
2320 }
2321 else
2322 {
2323 PPGMPAGE pPage = &pRam->aPages[(GCPhys - pRam->GCPhys) >> PAGE_SHIFT];
2324 for (uint32_t iPage = 0; iPage < cPages; iPage++, pPage++, pRomPage++)
2325 {
2326 PGM_PAGE_SET_TYPE(pPage, PGMPAGETYPE_ROM);
2327 PGM_PAGE_SET_HCPHYS(pPage, pReq->aPages[iPage].HCPhysGCPhys);
2328 PGM_PAGE_SET_STATE(pPage, PGM_PAGE_STATE_ALLOCATED);
2329 PGM_PAGE_SET_PAGEID(pPage, pReq->aPages[iPage].idPage);
2330
2331 pRomPage->Virgin = *pPage;
2332 }
2333
2334 pRamNew = pRam;
2335
2336 pVM->pgm.s.cZeroPages -= cPages;
2337 }
2338 pVM->pgm.s.cPrivatePages += cPages;
2339
2340 /* Flush physical page map TLB. */
2341 PGMPhysInvalidatePageMapTLB(pVM);
2342
2343 pgmUnlock(pVM);
2344
2345
2346 /*
2347 * !HACK ALERT! REM + (Shadowed) ROM ==> mess.
2348 *
2349 * If it's shadowed we'll register the handler after the ROM notification
2350 * so we get the access handler callbacks that we should. If it isn't
2351 * shadowed we'll do it the other way around to make REM use the built-in
2352 * ROM behavior and not the handler behavior (which is to route all access
2353 * to PGM atm).
2354 */
2355 if (fFlags & PGMPHYS_ROM_FLAGS_SHADOWED)
2356 {
2357 REMR3NotifyPhysRomRegister(pVM, GCPhys, cb, NULL, true /* fShadowed */);
2358 rc = PGMR3HandlerPhysicalRegister(pVM,
2359 fFlags & PGMPHYS_ROM_FLAGS_SHADOWED
2360 ? PGMPHYSHANDLERTYPE_PHYSICAL_ALL
2361 : PGMPHYSHANDLERTYPE_PHYSICAL_WRITE,
2362 GCPhys, GCPhysLast,
2363 pgmR3PhysRomWriteHandler, pRomNew,
2364 NULL, "pgmPhysRomWriteHandler", MMHyperCCToR0(pVM, pRomNew),
2365 NULL, "pgmPhysRomWriteHandler", MMHyperCCToRC(pVM, pRomNew), pszDesc);
2366 }
2367 else
2368 {
2369 rc = PGMR3HandlerPhysicalRegister(pVM,
2370 fFlags & PGMPHYS_ROM_FLAGS_SHADOWED
2371 ? PGMPHYSHANDLERTYPE_PHYSICAL_ALL
2372 : PGMPHYSHANDLERTYPE_PHYSICAL_WRITE,
2373 GCPhys, GCPhysLast,
2374 pgmR3PhysRomWriteHandler, pRomNew,
2375 NULL, "pgmPhysRomWriteHandler", MMHyperCCToR0(pVM, pRomNew),
2376 NULL, "pgmPhysRomWriteHandler", MMHyperCCToRC(pVM, pRomNew), pszDesc);
2377 REMR3NotifyPhysRomRegister(pVM, GCPhys, cb, NULL, false /* fShadowed */);
2378 }
2379 if (RT_SUCCESS(rc))
2380 {
2381 pgmLock(pVM);
2382
2383 /*
2384 * Copy the image over to the virgin pages.
2385 * This must be done after linking in the RAM range.
2386 */
2387 PPGMPAGE pRamPage = &pRamNew->aPages[(GCPhys - pRamNew->GCPhys) >> PAGE_SHIFT];
2388 for (uint32_t iPage = 0; iPage < cPages; iPage++, pRamPage++)
2389 {
2390 void *pvDstPage;
2391 rc = pgmPhysPageMap(pVM, pRamPage, GCPhys + (iPage << PAGE_SHIFT), &pvDstPage);
2392 if (RT_FAILURE(rc))
2393 {
2394 VMSetError(pVM, rc, RT_SRC_POS, "Failed to map virgin ROM page at %RGp", GCPhys);
2395 break;
2396 }
2397 memcpy(pvDstPage, (const uint8_t *)pvBinary + (iPage << PAGE_SHIFT), PAGE_SIZE);
2398 }
2399 if (RT_SUCCESS(rc))
2400 {
2401 /*
2402 * Initialize the ROM range.
2403 * Note that the Virgin member of the pages has already been initialized above.
2404 */
2405 pRomNew->GCPhys = GCPhys;
2406 pRomNew->GCPhysLast = GCPhysLast;
2407 pRomNew->cb = cb;
2408 pRomNew->fFlags = fFlags;
2409 pRomNew->idSavedState = UINT8_MAX;
2410 pRomNew->pvOriginal = fFlags & PGMPHYS_ROM_FLAGS_PERMANENT_BINARY ? pvBinary : NULL;
2411 pRomNew->pszDesc = pszDesc;
2412
2413 for (unsigned iPage = 0; iPage < cPages; iPage++)
2414 {
2415 PPGMROMPAGE pPage = &pRomNew->aPages[iPage];
2416 pPage->enmProt = PGMROMPROT_READ_ROM_WRITE_IGNORE;
2417 PGM_PAGE_INIT_ZERO(&pPage->Shadow, pVM, PGMPAGETYPE_ROM_SHADOW);
2418 }
2419
2420 /* update the page count stats for the shadow pages. */
2421 if (fFlags & PGMPHYS_ROM_FLAGS_SHADOWED)
2422 {
2423 pVM->pgm.s.cZeroPages += cPages;
2424 pVM->pgm.s.cAllPages += cPages;
2425 }
2426
2427 /*
2428 * Insert the ROM range, tell REM and return successfully.
2429 */
2430 pRomNew->pNextR3 = pRom;
2431 pRomNew->pNextR0 = pRom ? MMHyperCCToR0(pVM, pRom) : NIL_RTR0PTR;
2432 pRomNew->pNextRC = pRom ? MMHyperCCToRC(pVM, pRom) : NIL_RTRCPTR;
2433
2434 if (pRomPrev)
2435 {
2436 pRomPrev->pNextR3 = pRomNew;
2437 pRomPrev->pNextR0 = MMHyperCCToR0(pVM, pRomNew);
2438 pRomPrev->pNextRC = MMHyperCCToRC(pVM, pRomNew);
2439 }
2440 else
2441 {
2442 pVM->pgm.s.pRomRangesR3 = pRomNew;
2443 pVM->pgm.s.pRomRangesR0 = MMHyperCCToR0(pVM, pRomNew);
2444 pVM->pgm.s.pRomRangesRC = MMHyperCCToRC(pVM, pRomNew);
2445 }
2446
2447 PGMPhysInvalidatePageMapTLB(pVM);
2448 GMMR3AllocatePagesCleanup(pReq);
2449 pgmUnlock(pVM);
2450 return VINF_SUCCESS;
2451 }
2452
2453 /* bail out */
2454
2455 pgmUnlock(pVM);
2456 int rc2 = PGMHandlerPhysicalDeregister(pVM, GCPhys);
2457 AssertRC(rc2);
2458 pgmLock(pVM);
2459 }
2460
2461 if (!fRamExists)
2462 {
2463 pgmR3PhysUnlinkRamRange2(pVM, pRamNew, pRamPrev);
2464 MMHyperFree(pVM, pRamNew);
2465 }
2466 }
2467 MMHyperFree(pVM, pRomNew);
2468 }
2469
2470 /** @todo Purge the mapping cache or something... */
2471 GMMR3FreeAllocatedPages(pVM, pReq);
2472 GMMR3AllocatePagesCleanup(pReq);
2473 pgmUnlock(pVM);
2474 return rc;
2475}
2476
2477
2478/**
2479 * \#PF Handler callback for ROM write accesses.
2480 *
2481 * @returns VINF_SUCCESS if the handler have carried out the operation.
2482 * @returns VINF_PGM_HANDLER_DO_DEFAULT if the caller should carry out the access operation.
2483 * @param pVM VM Handle.
2484 * @param GCPhys The physical address the guest is writing to.
2485 * @param pvPhys The HC mapping of that address.
2486 * @param pvBuf What the guest is reading/writing.
2487 * @param cbBuf How much it's reading/writing.
2488 * @param enmAccessType The access type.
2489 * @param pvUser User argument.
2490 */
2491static DECLCALLBACK(int) pgmR3PhysRomWriteHandler(PVM pVM, RTGCPHYS GCPhys, void *pvPhys, void *pvBuf, size_t cbBuf, PGMACCESSTYPE enmAccessType, void *pvUser)
2492{
2493 PPGMROMRANGE pRom = (PPGMROMRANGE)pvUser;
2494 const uint32_t iPage = (GCPhys - pRom->GCPhys) >> PAGE_SHIFT;
2495 Assert(iPage < (pRom->cb >> PAGE_SHIFT));
2496 PPGMROMPAGE pRomPage = &pRom->aPages[iPage];
2497 Log5(("pgmR3PhysRomWriteHandler: %d %c %#08RGp %#04zx\n", pRomPage->enmProt, enmAccessType == PGMACCESSTYPE_READ ? 'R' : 'W', GCPhys, cbBuf));
2498
2499 if (enmAccessType == PGMACCESSTYPE_READ)
2500 {
2501 switch (pRomPage->enmProt)
2502 {
2503 /*
2504 * Take the default action.
2505 */
2506 case PGMROMPROT_READ_ROM_WRITE_IGNORE:
2507 case PGMROMPROT_READ_RAM_WRITE_IGNORE:
2508 case PGMROMPROT_READ_ROM_WRITE_RAM:
2509 case PGMROMPROT_READ_RAM_WRITE_RAM:
2510 return VINF_PGM_HANDLER_DO_DEFAULT;
2511
2512 default:
2513 AssertMsgFailedReturn(("enmProt=%d iPage=%d GCPhys=%RGp\n",
2514 pRom->aPages[iPage].enmProt, iPage, GCPhys),
2515 VERR_INTERNAL_ERROR);
2516 }
2517 }
2518 else
2519 {
2520 Assert(enmAccessType == PGMACCESSTYPE_WRITE);
2521 switch (pRomPage->enmProt)
2522 {
2523 /*
2524 * Ignore writes.
2525 */
2526 case PGMROMPROT_READ_ROM_WRITE_IGNORE:
2527 case PGMROMPROT_READ_RAM_WRITE_IGNORE:
2528 return VINF_SUCCESS;
2529
2530 /*
2531 * Write to the ram page.
2532 */
2533 case PGMROMPROT_READ_ROM_WRITE_RAM:
2534 case PGMROMPROT_READ_RAM_WRITE_RAM: /* yes this will get here too, it's *way* simpler that way. */
2535 {
2536 /* This should be impossible now, pvPhys doesn't work cross page anylonger. */
2537 Assert(((GCPhys - pRom->GCPhys + cbBuf - 1) >> PAGE_SHIFT) == iPage);
2538
2539 /*
2540 * Take the lock, do lazy allocation, map the page and copy the data.
2541 *
2542 * Note that we have to bypass the mapping TLB since it works on
2543 * guest physical addresses and entering the shadow page would
2544 * kind of screw things up...
2545 */
2546 int rc = pgmLock(pVM);
2547 AssertRC(rc);
2548
2549 PPGMPAGE pShadowPage = &pRomPage->Shadow;
2550 if (!PGMROMPROT_IS_ROM(pRomPage->enmProt))
2551 {
2552 pShadowPage = pgmPhysGetPage(&pVM->pgm.s, GCPhys);
2553 AssertLogRelReturn(pShadowPage, VERR_INTERNAL_ERROR);
2554 }
2555
2556 void *pvDstPage;
2557 rc = pgmPhysPageMakeWritableAndMap(pVM, pShadowPage, GCPhys & X86_PTE_PG_MASK, &pvDstPage);
2558 if (RT_SUCCESS(rc))
2559 {
2560 memcpy((uint8_t *)pvDstPage + (GCPhys & PAGE_OFFSET_MASK), pvBuf, cbBuf);
2561 pRomPage->LiveSave.fWrittenTo = true;
2562 }
2563
2564 pgmUnlock(pVM);
2565 return rc;
2566 }
2567
2568 default:
2569 AssertMsgFailedReturn(("enmProt=%d iPage=%d GCPhys=%RGp\n",
2570 pRom->aPages[iPage].enmProt, iPage, GCPhys),
2571 VERR_INTERNAL_ERROR);
2572 }
2573 }
2574}
2575
2576
2577/**
2578 * Called by PGMR3Reset to reset the shadow, switch to the virgin,
2579 * and verify that the virgin part is untouched.
2580 *
2581 * This is done after the normal memory has been cleared.
2582 *
2583 * ASSUMES that the caller owns the PGM lock.
2584 *
2585 * @param pVM The VM handle.
2586 */
2587int pgmR3PhysRomReset(PVM pVM)
2588{
2589 Assert(PGMIsLockOwner(pVM));
2590 for (PPGMROMRANGE pRom = pVM->pgm.s.pRomRangesR3; pRom; pRom = pRom->pNextR3)
2591 {
2592 const uint32_t cPages = pRom->cb >> PAGE_SHIFT;
2593
2594 if (pRom->fFlags & PGMPHYS_ROM_FLAGS_SHADOWED)
2595 {
2596 /*
2597 * Reset the physical handler.
2598 */
2599 int rc = PGMR3PhysRomProtect(pVM, pRom->GCPhys, pRom->cb, PGMROMPROT_READ_ROM_WRITE_IGNORE);
2600 AssertRCReturn(rc, rc);
2601
2602 /*
2603 * What we do with the shadow pages depends on the memory
2604 * preallocation option. If not enabled, we'll just throw
2605 * out all the dirty pages and replace them by the zero page.
2606 */
2607 if (!pVM->pgm.s.fRamPreAlloc)
2608 {
2609 /* Free the dirty pages. */
2610 uint32_t cPendingPages = 0;
2611 PGMMFREEPAGESREQ pReq;
2612 rc = GMMR3FreePagesPrepare(pVM, &pReq, PGMPHYS_FREE_PAGE_BATCH_SIZE, GMMACCOUNT_BASE);
2613 AssertRCReturn(rc, rc);
2614
2615 for (uint32_t iPage = 0; iPage < cPages; iPage++)
2616 if (PGM_PAGE_GET_STATE(&pRom->aPages[iPage].Shadow) != PGM_PAGE_STATE_ZERO)
2617 {
2618 Assert(PGM_PAGE_GET_STATE(&pRom->aPages[iPage].Shadow) == PGM_PAGE_STATE_ALLOCATED);
2619 rc = pgmPhysFreePage(pVM, pReq, &cPendingPages, &pRom->aPages[iPage].Shadow, pRom->GCPhys + (iPage << PAGE_SHIFT));
2620 AssertLogRelRCReturn(rc, rc);
2621 }
2622
2623 if (cPendingPages)
2624 {
2625 rc = GMMR3FreePagesPerform(pVM, pReq, cPendingPages);
2626 AssertLogRelRCReturn(rc, rc);
2627 }
2628 GMMR3FreePagesCleanup(pReq);
2629 }
2630 else
2631 {
2632 /* clear all the shadow pages. */
2633 for (uint32_t iPage = 0; iPage < cPages; iPage++)
2634 {
2635 Assert(PGM_PAGE_GET_STATE(&pRom->aPages[iPage].Shadow) != PGM_PAGE_STATE_ZERO);
2636 void *pvDstPage;
2637 const RTGCPHYS GCPhys = pRom->GCPhys + (iPage << PAGE_SHIFT);
2638 rc = pgmPhysPageMakeWritableAndMap(pVM, &pRom->aPages[iPage].Shadow, GCPhys, &pvDstPage);
2639 if (RT_FAILURE(rc))
2640 break;
2641 ASMMemZeroPage(pvDstPage);
2642 }
2643 AssertRCReturn(rc, rc);
2644 }
2645 }
2646
2647#ifdef VBOX_STRICT
2648 /*
2649 * Verify that the virgin page is unchanged if possible.
2650 */
2651 if (pRom->pvOriginal)
2652 {
2653 uint8_t const *pbSrcPage = (uint8_t const *)pRom->pvOriginal;
2654 for (uint32_t iPage = 0; iPage < cPages; iPage++, pbSrcPage += PAGE_SIZE)
2655 {
2656 const RTGCPHYS GCPhys = pRom->GCPhys + (iPage << PAGE_SHIFT);
2657 void const *pvDstPage;
2658 int rc = pgmPhysPageMapReadOnly(pVM, &pRom->aPages[iPage].Virgin, GCPhys, &pvDstPage);
2659 if (RT_FAILURE(rc))
2660 break;
2661 if (memcmp(pvDstPage, pbSrcPage, PAGE_SIZE))
2662 LogRel(("pgmR3PhysRomReset: %RGp rom page changed (%s) - loaded saved state?\n",
2663 GCPhys, pRom->pszDesc));
2664 }
2665 }
2666#endif
2667 }
2668
2669 return VINF_SUCCESS;
2670}
2671
2672
2673/**
2674 * Change the shadowing of a range of ROM pages.
2675 *
2676 * This is intended for implementing chipset specific memory registers
2677 * and will not be very strict about the input. It will silently ignore
2678 * any pages that are not the part of a shadowed ROM.
2679 *
2680 * @returns VBox status code.
2681 * @retval VINF_PGM_SYNC_CR3
2682 *
2683 * @param pVM Pointer to the shared VM structure.
2684 * @param GCPhys Where to start. Page aligned.
2685 * @param cb How much to change. Page aligned.
2686 * @param enmProt The new ROM protection.
2687 */
2688VMMR3DECL(int) PGMR3PhysRomProtect(PVM pVM, RTGCPHYS GCPhys, RTGCPHYS cb, PGMROMPROT enmProt)
2689{
2690 /*
2691 * Check input
2692 */
2693 if (!cb)
2694 return VINF_SUCCESS;
2695 AssertReturn(!(GCPhys & PAGE_OFFSET_MASK), VERR_INVALID_PARAMETER);
2696 AssertReturn(!(cb & PAGE_OFFSET_MASK), VERR_INVALID_PARAMETER);
2697 RTGCPHYS GCPhysLast = GCPhys + (cb - 1);
2698 AssertReturn(GCPhysLast > GCPhys, VERR_INVALID_PARAMETER);
2699 AssertReturn(enmProt >= PGMROMPROT_INVALID && enmProt <= PGMROMPROT_END, VERR_INVALID_PARAMETER);
2700
2701 /*
2702 * Process the request.
2703 */
2704 pgmLock(pVM);
2705 int rc = VINF_SUCCESS;
2706 bool fFlushTLB = false;
2707 for (PPGMROMRANGE pRom = pVM->pgm.s.pRomRangesR3; pRom; pRom = pRom->pNextR3)
2708 {
2709 if ( GCPhys <= pRom->GCPhysLast
2710 && GCPhysLast >= pRom->GCPhys
2711 && (pRom->fFlags & PGMPHYS_ROM_FLAGS_SHADOWED))
2712 {
2713 /*
2714 * Iterate the relevant pages and make necessary the changes.
2715 */
2716 bool fChanges = false;
2717 uint32_t const cPages = pRom->GCPhysLast <= GCPhysLast
2718 ? pRom->cb >> PAGE_SHIFT
2719 : (GCPhysLast - pRom->GCPhys + 1) >> PAGE_SHIFT;
2720 for (uint32_t iPage = (GCPhys - pRom->GCPhys) >> PAGE_SHIFT;
2721 iPage < cPages;
2722 iPage++)
2723 {
2724 PPGMROMPAGE pRomPage = &pRom->aPages[iPage];
2725 if (PGMROMPROT_IS_ROM(pRomPage->enmProt) != PGMROMPROT_IS_ROM(enmProt))
2726 {
2727 fChanges = true;
2728
2729 /* flush references to the page. */
2730 PPGMPAGE pRamPage = pgmPhysGetPage(&pVM->pgm.s, pRom->GCPhys + (iPage << PAGE_SHIFT));
2731 int rc2 = pgmPoolTrackFlushGCPhys(pVM, pRamPage, &fFlushTLB);
2732 if (rc2 != VINF_SUCCESS && (rc == VINF_SUCCESS || RT_FAILURE(rc2)))
2733 rc = rc2;
2734
2735 PPGMPAGE pOld = PGMROMPROT_IS_ROM(pRomPage->enmProt) ? &pRomPage->Virgin : &pRomPage->Shadow;
2736 PPGMPAGE pNew = PGMROMPROT_IS_ROM(pRomPage->enmProt) ? &pRomPage->Shadow : &pRomPage->Virgin;
2737
2738 *pOld = *pRamPage;
2739 *pRamPage = *pNew;
2740 /** @todo preserve the volatile flags (handlers) when these have been moved out of HCPhys! */
2741 }
2742 pRomPage->enmProt = enmProt;
2743 }
2744
2745 /*
2746 * Reset the access handler if we made changes, no need
2747 * to optimize this.
2748 */
2749 if (fChanges)
2750 {
2751 int rc2 = PGMHandlerPhysicalReset(pVM, pRom->GCPhys);
2752 if (RT_FAILURE(rc2))
2753 {
2754 pgmUnlock(pVM);
2755 AssertRC(rc);
2756 return rc2;
2757 }
2758 }
2759
2760 /* Advance - cb isn't updated. */
2761 GCPhys = pRom->GCPhys + (cPages << PAGE_SHIFT);
2762 }
2763 }
2764 pgmUnlock(pVM);
2765 if (fFlushTLB)
2766 PGM_INVL_ALL_VCPU_TLBS(pVM);
2767
2768 return rc;
2769}
2770
2771
2772/**
2773 * Sets the Address Gate 20 state.
2774 *
2775 * @param pVCpu The VCPU to operate on.
2776 * @param fEnable True if the gate should be enabled.
2777 * False if the gate should be disabled.
2778 */
2779VMMDECL(void) PGMR3PhysSetA20(PVMCPU pVCpu, bool fEnable)
2780{
2781 LogFlow(("PGMR3PhysSetA20 %d (was %d)\n", fEnable, pVCpu->pgm.s.fA20Enabled));
2782 if (pVCpu->pgm.s.fA20Enabled != fEnable)
2783 {
2784 pVCpu->pgm.s.fA20Enabled = fEnable;
2785 pVCpu->pgm.s.GCPhysA20Mask = ~(RTGCPHYS)(!fEnable << 20);
2786 REMR3A20Set(pVCpu->pVMR3, pVCpu, fEnable);
2787 /** @todo we're not handling this correctly for VT-x / AMD-V. See #2911 */
2788 }
2789}
2790
2791
2792/**
2793 * Tree enumeration callback for dealing with age rollover.
2794 * It will perform a simple compression of the current age.
2795 */
2796static DECLCALLBACK(int) pgmR3PhysChunkAgeingRolloverCallback(PAVLU32NODECORE pNode, void *pvUser)
2797{
2798 Assert(PGMIsLockOwner((PVM)pvUser));
2799 /* Age compression - ASSUMES iNow == 4. */
2800 PPGMCHUNKR3MAP pChunk = (PPGMCHUNKR3MAP)pNode;
2801 if (pChunk->iAge >= UINT32_C(0xffffff00))
2802 pChunk->iAge = 3;
2803 else if (pChunk->iAge >= UINT32_C(0xfffff000))
2804 pChunk->iAge = 2;
2805 else if (pChunk->iAge)
2806 pChunk->iAge = 1;
2807 else /* iAge = 0 */
2808 pChunk->iAge = 4;
2809
2810 /* reinsert */
2811 PVM pVM = (PVM)pvUser;
2812 RTAvllU32Remove(&pVM->pgm.s.ChunkR3Map.pAgeTree, pChunk->AgeCore.Key);
2813 pChunk->AgeCore.Key = pChunk->iAge;
2814 RTAvllU32Insert(&pVM->pgm.s.ChunkR3Map.pAgeTree, &pChunk->AgeCore);
2815 return 0;
2816}
2817
2818
2819/**
2820 * Tree enumeration callback that updates the chunks that have
2821 * been used since the last
2822 */
2823static DECLCALLBACK(int) pgmR3PhysChunkAgeingCallback(PAVLU32NODECORE pNode, void *pvUser)
2824{
2825 PPGMCHUNKR3MAP pChunk = (PPGMCHUNKR3MAP)pNode;
2826 if (!pChunk->iAge)
2827 {
2828 PVM pVM = (PVM)pvUser;
2829 RTAvllU32Remove(&pVM->pgm.s.ChunkR3Map.pAgeTree, pChunk->AgeCore.Key);
2830 pChunk->AgeCore.Key = pChunk->iAge = pVM->pgm.s.ChunkR3Map.iNow;
2831 RTAvllU32Insert(&pVM->pgm.s.ChunkR3Map.pAgeTree, &pChunk->AgeCore);
2832 }
2833
2834 return 0;
2835}
2836
2837
2838/**
2839 * Performs ageing of the ring-3 chunk mappings.
2840 *
2841 * @param pVM The VM handle.
2842 */
2843VMMR3DECL(void) PGMR3PhysChunkAgeing(PVM pVM)
2844{
2845 pgmLock(pVM);
2846 pVM->pgm.s.ChunkR3Map.AgeingCountdown = RT_MIN(pVM->pgm.s.ChunkR3Map.cMax / 4, 1024);
2847 pVM->pgm.s.ChunkR3Map.iNow++;
2848 if (pVM->pgm.s.ChunkR3Map.iNow == 0)
2849 {
2850 pVM->pgm.s.ChunkR3Map.iNow = 4;
2851 RTAvlU32DoWithAll(&pVM->pgm.s.ChunkR3Map.pTree, true /*fFromLeft*/, pgmR3PhysChunkAgeingRolloverCallback, pVM);
2852 }
2853 else
2854 RTAvlU32DoWithAll(&pVM->pgm.s.ChunkR3Map.pTree, true /*fFromLeft*/, pgmR3PhysChunkAgeingCallback, pVM);
2855 pgmUnlock(pVM);
2856}
2857
2858
2859/**
2860 * The structure passed in the pvUser argument of pgmR3PhysChunkUnmapCandidateCallback().
2861 */
2862typedef struct PGMR3PHYSCHUNKUNMAPCB
2863{
2864 PVM pVM; /**< The VM handle. */
2865 PPGMCHUNKR3MAP pChunk; /**< The chunk to unmap. */
2866} PGMR3PHYSCHUNKUNMAPCB, *PPGMR3PHYSCHUNKUNMAPCB;
2867
2868
2869/**
2870 * Callback used to find the mapping that's been unused for
2871 * the longest time.
2872 */
2873static DECLCALLBACK(int) pgmR3PhysChunkUnmapCandidateCallback(PAVLLU32NODECORE pNode, void *pvUser)
2874{
2875 do
2876 {
2877 PPGMCHUNKR3MAP pChunk = (PPGMCHUNKR3MAP)((uint8_t *)pNode - RT_OFFSETOF(PGMCHUNKR3MAP, AgeCore));
2878 if ( pChunk->iAge
2879 && !pChunk->cRefs)
2880 {
2881 /*
2882 * Check that it's not in any of the TLBs.
2883 */
2884 PVM pVM = ((PPGMR3PHYSCHUNKUNMAPCB)pvUser)->pVM;
2885 for (unsigned i = 0; i < RT_ELEMENTS(pVM->pgm.s.ChunkR3Map.Tlb.aEntries); i++)
2886 if (pVM->pgm.s.ChunkR3Map.Tlb.aEntries[i].pChunk == pChunk)
2887 {
2888 pChunk = NULL;
2889 break;
2890 }
2891 if (pChunk)
2892 for (unsigned i = 0; i < RT_ELEMENTS(pVM->pgm.s.PhysTlbHC.aEntries); i++)
2893 if (pVM->pgm.s.PhysTlbHC.aEntries[i].pMap == pChunk)
2894 {
2895 pChunk = NULL;
2896 break;
2897 }
2898 if (pChunk)
2899 {
2900 ((PPGMR3PHYSCHUNKUNMAPCB)pvUser)->pChunk = pChunk;
2901 return 1; /* done */
2902 }
2903 }
2904
2905 /* next with the same age - this version of the AVL API doesn't enumerate the list, so we have to do it. */
2906 pNode = pNode->pList;
2907 } while (pNode);
2908 return 0;
2909}
2910
2911
2912/**
2913 * Finds a good candidate for unmapping when the ring-3 mapping cache is full.
2914 *
2915 * The candidate will not be part of any TLBs, so no need to flush
2916 * anything afterwards.
2917 *
2918 * @returns Chunk id.
2919 * @param pVM The VM handle.
2920 */
2921static int32_t pgmR3PhysChunkFindUnmapCandidate(PVM pVM)
2922{
2923 Assert(PGMIsLockOwner(pVM));
2924
2925 /*
2926 * Do tree ageing first?
2927 */
2928 if (pVM->pgm.s.ChunkR3Map.AgeingCountdown-- == 0)
2929 PGMR3PhysChunkAgeing(pVM);
2930
2931 /*
2932 * Enumerate the age tree starting with the left most node.
2933 */
2934 PGMR3PHYSCHUNKUNMAPCB Args;
2935 Args.pVM = pVM;
2936 Args.pChunk = NULL;
2937 if (RTAvllU32DoWithAll(&pVM->pgm.s.ChunkR3Map.pAgeTree, true /*fFromLeft*/, pgmR3PhysChunkUnmapCandidateCallback, pVM))
2938 return Args.pChunk->Core.Key;
2939 return INT32_MAX;
2940}
2941
2942
2943/**
2944 * Maps the given chunk into the ring-3 mapping cache.
2945 *
2946 * This will call ring-0.
2947 *
2948 * @returns VBox status code.
2949 * @param pVM The VM handle.
2950 * @param idChunk The chunk in question.
2951 * @param ppChunk Where to store the chunk tracking structure.
2952 *
2953 * @remarks Called from within the PGM critical section.
2954 */
2955int pgmR3PhysChunkMap(PVM pVM, uint32_t idChunk, PPPGMCHUNKR3MAP ppChunk)
2956{
2957 int rc;
2958
2959 Assert(PGMIsLockOwner(pVM));
2960 /*
2961 * Allocate a new tracking structure first.
2962 */
2963#ifdef VBOX_WITH_2X_4GB_ADDR_SPACE
2964 PPGMCHUNKR3MAP pChunk = (PPGMCHUNKR3MAP)MMR3HeapAlloc(pVM, MM_TAG_PGM_CHUNK_MAPPING, sizeof(*pChunk));
2965#else
2966 PPGMCHUNKR3MAP pChunk = (PPGMCHUNKR3MAP)MMR3UkHeapAlloc(pVM, MM_TAG_PGM_CHUNK_MAPPING, sizeof(*pChunk), NULL);
2967#endif
2968 AssertReturn(pChunk, VERR_NO_MEMORY);
2969 pChunk->Core.Key = idChunk;
2970 pChunk->AgeCore.Key = pVM->pgm.s.ChunkR3Map.iNow;
2971 pChunk->iAge = 0;
2972 pChunk->cRefs = 0;
2973 pChunk->cPermRefs = 0;
2974 pChunk->pv = NULL;
2975
2976 /*
2977 * Request the ring-0 part to map the chunk in question and if
2978 * necessary unmap another one to make space in the mapping cache.
2979 */
2980 GMMMAPUNMAPCHUNKREQ Req;
2981 Req.Hdr.u32Magic = SUPVMMR0REQHDR_MAGIC;
2982 Req.Hdr.cbReq = sizeof(Req);
2983 Req.pvR3 = NULL;
2984 Req.idChunkMap = idChunk;
2985 Req.idChunkUnmap = NIL_GMM_CHUNKID;
2986 if (pVM->pgm.s.ChunkR3Map.c >= pVM->pgm.s.ChunkR3Map.cMax)
2987 Req.idChunkUnmap = pgmR3PhysChunkFindUnmapCandidate(pVM);
2988/** @todo This is wrong. Any thread in the VM process should be able to do this,
2989 * there are depenenecies on this. What currently saves the day is that
2990 * we don't unmap anything and that all non-zero memory will therefore
2991 * be present when non-EMTs tries to access it. */
2992 rc = VMMR3CallR0(pVM, VMMR0_DO_GMM_MAP_UNMAP_CHUNK, 0, &Req.Hdr);
2993 if (RT_SUCCESS(rc))
2994 {
2995 /*
2996 * Update the tree.
2997 */
2998 /* insert the new one. */
2999 AssertPtr(Req.pvR3);
3000 pChunk->pv = Req.pvR3;
3001 bool fRc = RTAvlU32Insert(&pVM->pgm.s.ChunkR3Map.pTree, &pChunk->Core);
3002 AssertRelease(fRc);
3003 pVM->pgm.s.ChunkR3Map.c++;
3004
3005 fRc = RTAvllU32Insert(&pVM->pgm.s.ChunkR3Map.pAgeTree, &pChunk->AgeCore);
3006 AssertRelease(fRc);
3007
3008 /* remove the unmapped one. */
3009 if (Req.idChunkUnmap != NIL_GMM_CHUNKID)
3010 {
3011 PPGMCHUNKR3MAP pUnmappedChunk = (PPGMCHUNKR3MAP)RTAvlU32Remove(&pVM->pgm.s.ChunkR3Map.pTree, Req.idChunkUnmap);
3012 AssertRelease(pUnmappedChunk);
3013 pUnmappedChunk->pv = NULL;
3014 pUnmappedChunk->Core.Key = UINT32_MAX;
3015#ifdef VBOX_WITH_2X_4GB_ADDR_SPACE
3016 MMR3HeapFree(pUnmappedChunk);
3017#else
3018 MMR3UkHeapFree(pVM, pUnmappedChunk, MM_TAG_PGM_CHUNK_MAPPING);
3019#endif
3020 pVM->pgm.s.ChunkR3Map.c--;
3021
3022 /* Chunk removed, so clear the page map TBL as well (might still be referenced). */
3023 PGMPhysInvalidatePageMapTLB(pVM);
3024 }
3025 }
3026 else
3027 {
3028 AssertRC(rc);
3029#ifdef VBOX_WITH_2X_4GB_ADDR_SPACE
3030 MMR3HeapFree(pChunk);
3031#else
3032 MMR3UkHeapFree(pVM, pChunk, MM_TAG_PGM_CHUNK_MAPPING);
3033#endif
3034 pChunk = NULL;
3035 }
3036
3037 *ppChunk = pChunk;
3038 return rc;
3039}
3040
3041
3042/**
3043 * For VMMCALLRING3_PGM_MAP_CHUNK, considered internal.
3044 *
3045 * @returns see pgmR3PhysChunkMap.
3046 * @param pVM The VM handle.
3047 * @param idChunk The chunk to map.
3048 */
3049VMMR3DECL(int) PGMR3PhysChunkMap(PVM pVM, uint32_t idChunk)
3050{
3051 PPGMCHUNKR3MAP pChunk;
3052 int rc;
3053
3054 pgmLock(pVM);
3055 rc = pgmR3PhysChunkMap(pVM, idChunk, &pChunk);
3056 pgmUnlock(pVM);
3057 return rc;
3058}
3059
3060
3061/**
3062 * Invalidates the TLB for the ring-3 mapping cache.
3063 *
3064 * @param pVM The VM handle.
3065 */
3066VMMR3DECL(void) PGMR3PhysChunkInvalidateTLB(PVM pVM)
3067{
3068 pgmLock(pVM);
3069 for (unsigned i = 0; i < RT_ELEMENTS(pVM->pgm.s.ChunkR3Map.Tlb.aEntries); i++)
3070 {
3071 pVM->pgm.s.ChunkR3Map.Tlb.aEntries[i].idChunk = NIL_GMM_CHUNKID;
3072 pVM->pgm.s.ChunkR3Map.Tlb.aEntries[i].pChunk = NULL;
3073 }
3074 /* The page map TLB references chunks, so invalidate that one too. */
3075 PGMPhysInvalidatePageMapTLB(pVM);
3076 pgmUnlock(pVM);
3077}
3078
3079
3080/**
3081 * Response to VM_FF_PGM_NEED_HANDY_PAGES and VMMCALLRING3_PGM_ALLOCATE_HANDY_PAGES.
3082 *
3083 * This function will also work the VM_FF_PGM_NO_MEMORY force action flag, to
3084 * signal and clear the out of memory condition. When contracted, this API is
3085 * used to try clear the condition when the user wants to resume.
3086 *
3087 * @returns The following VBox status codes.
3088 * @retval VINF_SUCCESS on success. FFs cleared.
3089 * @retval VINF_EM_NO_MEMORY if we're out of memory. The FF is not cleared in
3090 * this case and it gets accompanied by VM_FF_PGM_NO_MEMORY.
3091 *
3092 * @param pVM The VM handle.
3093 *
3094 * @remarks The VINF_EM_NO_MEMORY status is for the benefit of the FF processing
3095 * in EM.cpp and shouldn't be propagated outside TRPM, HWACCM, EM and
3096 * pgmPhysEnsureHandyPage. There is one exception to this in the \#PF
3097 * handler.
3098 */
3099VMMR3DECL(int) PGMR3PhysAllocateHandyPages(PVM pVM)
3100{
3101 pgmLock(pVM);
3102
3103 /*
3104 * Allocate more pages, noting down the index of the first new page.
3105 */
3106 uint32_t iClear = pVM->pgm.s.cHandyPages;
3107 AssertMsgReturn(iClear <= RT_ELEMENTS(pVM->pgm.s.aHandyPages), ("%d", iClear), VERR_INTERNAL_ERROR);
3108 Log(("PGMR3PhysAllocateHandyPages: %d -> %d\n", iClear, RT_ELEMENTS(pVM->pgm.s.aHandyPages)));
3109 int rcAlloc = VINF_SUCCESS;
3110 int rcSeed = VINF_SUCCESS;
3111 int rc = VMMR3CallR0(pVM, VMMR0_DO_PGM_ALLOCATE_HANDY_PAGES, 0, NULL);
3112 while (rc == VERR_GMM_SEED_ME)
3113 {
3114 void *pvChunk;
3115 rcAlloc = rc = SUPR3PageAlloc(GMM_CHUNK_SIZE >> PAGE_SHIFT, &pvChunk);
3116 if (RT_SUCCESS(rc))
3117 {
3118 rcSeed = rc = VMMR3CallR0(pVM, VMMR0_DO_GMM_SEED_CHUNK, (uintptr_t)pvChunk, NULL);
3119 if (RT_FAILURE(rc))
3120 SUPR3PageFree(pvChunk, GMM_CHUNK_SIZE >> PAGE_SHIFT);
3121 }
3122 if (RT_SUCCESS(rc))
3123 rc = VMMR3CallR0(pVM, VMMR0_DO_PGM_ALLOCATE_HANDY_PAGES, 0, NULL);
3124 }
3125
3126 if (RT_SUCCESS(rc))
3127 {
3128 AssertMsg(rc == VINF_SUCCESS, ("%Rrc\n", rc));
3129 Assert(pVM->pgm.s.cHandyPages > 0);
3130 VM_FF_CLEAR(pVM, VM_FF_PGM_NEED_HANDY_PAGES);
3131 VM_FF_CLEAR(pVM, VM_FF_PGM_NO_MEMORY);
3132
3133 /*
3134 * Clear the pages.
3135 */
3136 while (iClear < pVM->pgm.s.cHandyPages)
3137 {
3138 PGMMPAGEDESC pPage = &pVM->pgm.s.aHandyPages[iClear];
3139 void *pv;
3140 rc = pgmPhysPageMapByPageID(pVM, pPage->idPage, pPage->HCPhysGCPhys, &pv);
3141 AssertLogRelMsgBreak(RT_SUCCESS(rc), ("idPage=%#x HCPhysGCPhys=%RHp rc=%Rrc", pPage->idPage, pPage->HCPhysGCPhys, rc));
3142 ASMMemZeroPage(pv);
3143 iClear++;
3144 Log3(("PGMR3PhysAllocateHandyPages: idPage=%#x HCPhys=%RGp\n", pPage->idPage, pPage->HCPhysGCPhys));
3145 }
3146 }
3147 else
3148 {
3149 /*
3150 * We should never get here unless there is a genuine shortage of
3151 * memory (or some internal error). Flag the error so the VM can be
3152 * suspended ASAP and the user informed. If we're totally out of
3153 * handy pages we will return failure.
3154 */
3155 /* Report the failure. */
3156 LogRel(("PGM: Failed to procure handy pages; rc=%Rrc rcAlloc=%Rrc rcSeed=%Rrc cHandyPages=%#x\n"
3157 " cAllPages=%#x cPrivatePages=%#x cSharedPages=%#x cZeroPages=%#x\n",
3158 rc, rcAlloc, rcSeed,
3159 pVM->pgm.s.cHandyPages,
3160 pVM->pgm.s.cAllPages,
3161 pVM->pgm.s.cPrivatePages,
3162 pVM->pgm.s.cSharedPages,
3163 pVM->pgm.s.cZeroPages));
3164 if ( rc != VERR_NO_MEMORY
3165 && rc != VERR_LOCK_FAILED)
3166 {
3167 for (uint32_t i = 0; i < RT_ELEMENTS(pVM->pgm.s.aHandyPages); i++)
3168 {
3169 LogRel(("PGM: aHandyPages[#%#04x] = {.HCPhysGCPhys=%RHp, .idPage=%#08x, .idSharedPage=%#08x}\n",
3170 i, pVM->pgm.s.aHandyPages[i].HCPhysGCPhys, pVM->pgm.s.aHandyPages[i].idPage,
3171 pVM->pgm.s.aHandyPages[i].idSharedPage));
3172 uint32_t const idPage = pVM->pgm.s.aHandyPages[i].idPage;
3173 if (idPage != NIL_GMM_PAGEID)
3174 {
3175 for (PPGMRAMRANGE pRam = pVM->pgm.s.pRamRangesR3;
3176 pRam;
3177 pRam = pRam->pNextR3)
3178 {
3179 uint32_t const cPages = pRam->cb >> PAGE_SHIFT;
3180 for (uint32_t iPage = 0; iPage < cPages; iPage++)
3181 if (PGM_PAGE_GET_PAGEID(&pRam->aPages[iPage]) == idPage)
3182 LogRel(("PGM: Used by %RGp %R[pgmpage] (%s)\n",
3183 pRam->GCPhys + ((RTGCPHYS)iPage << PAGE_SHIFT), &pRam->aPages[iPage], pRam->pszDesc));
3184 }
3185 }
3186 }
3187 }
3188
3189 /* Set the FFs and adjust rc. */
3190 VM_FF_SET(pVM, VM_FF_PGM_NEED_HANDY_PAGES);
3191 VM_FF_SET(pVM, VM_FF_PGM_NO_MEMORY);
3192 if ( rc == VERR_NO_MEMORY
3193 || rc == VERR_LOCK_FAILED)
3194 rc = VINF_EM_NO_MEMORY;
3195 }
3196
3197 pgmUnlock(pVM);
3198 return rc;
3199}
3200
3201
3202/**
3203 * Frees the specified RAM page and replaces it with the ZERO page.
3204 *
3205 * This is used by ballooning, remapping MMIO2 and RAM reset.
3206 *
3207 * @param pVM Pointer to the shared VM structure.
3208 * @param pReq Pointer to the request.
3209 * @param pPage Pointer to the page structure.
3210 * @param GCPhys The guest physical address of the page, if applicable.
3211 *
3212 * @remarks The caller must own the PGM lock.
3213 */
3214static int pgmPhysFreePage(PVM pVM, PGMMFREEPAGESREQ pReq, uint32_t *pcPendingPages, PPGMPAGE pPage, RTGCPHYS GCPhys)
3215{
3216 /*
3217 * Assert sanity.
3218 */
3219 Assert(PGMIsLockOwner(pVM));
3220 if (RT_UNLIKELY( PGM_PAGE_GET_TYPE(pPage) != PGMPAGETYPE_RAM
3221 && PGM_PAGE_GET_TYPE(pPage) != PGMPAGETYPE_ROM_SHADOW))
3222 {
3223 AssertMsgFailed(("GCPhys=%RGp pPage=%R[pgmpage]\n", GCPhys, pPage));
3224 return VMSetError(pVM, VERR_PGM_PHYS_NOT_RAM, RT_SRC_POS, "GCPhys=%RGp type=%d", GCPhys, PGM_PAGE_GET_TYPE(pPage));
3225 }
3226
3227 if (PGM_PAGE_GET_STATE(pPage) == PGM_PAGE_STATE_ZERO)
3228 return VINF_SUCCESS;
3229
3230 const uint32_t idPage = PGM_PAGE_GET_PAGEID(pPage);
3231 Log3(("pgmPhysFreePage: idPage=%#x HCPhys=%RGp pPage=%R[pgmpage]\n", idPage, pPage));
3232 if (RT_UNLIKELY( idPage == NIL_GMM_PAGEID
3233 || idPage > GMM_PAGEID_LAST
3234 || PGM_PAGE_GET_CHUNKID(pPage) == NIL_GMM_CHUNKID))
3235 {
3236 AssertMsgFailed(("GCPhys=%RGp pPage=%R[pgmpage]\n", GCPhys, pPage));
3237 return VMSetError(pVM, VERR_PGM_PHYS_INVALID_PAGE_ID, RT_SRC_POS, "GCPhys=%RGp idPage=%#x", GCPhys, pPage);
3238 }
3239
3240 /* update page count stats. */
3241 if (PGM_PAGE_IS_SHARED(pPage))
3242 pVM->pgm.s.cSharedPages--;
3243 else
3244 pVM->pgm.s.cPrivatePages--;
3245 pVM->pgm.s.cZeroPages++;
3246
3247 /* Deal with write monitored pages. */
3248 if (PGM_PAGE_GET_STATE(pPage) == PGM_PAGE_STATE_WRITE_MONITORED)
3249 {
3250 PGM_PAGE_SET_WRITTEN_TO(pPage);
3251 pVM->pgm.s.cWrittenToPages++;
3252 }
3253
3254 /*
3255 * pPage = ZERO page.
3256 */
3257 PGM_PAGE_SET_HCPHYS(pPage, pVM->pgm.s.HCPhysZeroPg);
3258 PGM_PAGE_SET_STATE(pPage, PGM_PAGE_STATE_ZERO);
3259 PGM_PAGE_SET_PAGEID(pPage, NIL_GMM_PAGEID);
3260
3261 /* Flush physical page map TLB entry. */
3262 PGMPhysInvalidatePageMapTLBEntry(pVM, GCPhys);
3263
3264 /*
3265 * Make sure it's not in the handy page array.
3266 */
3267 for (uint32_t i = pVM->pgm.s.cHandyPages; i < RT_ELEMENTS(pVM->pgm.s.aHandyPages); i++)
3268 {
3269 if (pVM->pgm.s.aHandyPages[i].idPage == idPage)
3270 {
3271 pVM->pgm.s.aHandyPages[i].idPage = NIL_GMM_PAGEID;
3272 break;
3273 }
3274 if (pVM->pgm.s.aHandyPages[i].idSharedPage == idPage)
3275 {
3276 pVM->pgm.s.aHandyPages[i].idSharedPage = NIL_GMM_PAGEID;
3277 break;
3278 }
3279 }
3280
3281 /*
3282 * Push it onto the page array.
3283 */
3284 uint32_t iPage = *pcPendingPages;
3285 Assert(iPage < PGMPHYS_FREE_PAGE_BATCH_SIZE);
3286 *pcPendingPages += 1;
3287
3288 pReq->aPages[iPage].idPage = idPage;
3289
3290 if (iPage + 1 < PGMPHYS_FREE_PAGE_BATCH_SIZE)
3291 return VINF_SUCCESS;
3292
3293 /*
3294 * Flush the pages.
3295 */
3296 int rc = GMMR3FreePagesPerform(pVM, pReq, PGMPHYS_FREE_PAGE_BATCH_SIZE);
3297 if (RT_SUCCESS(rc))
3298 {
3299 GMMR3FreePagesRePrep(pVM, pReq, PGMPHYS_FREE_PAGE_BATCH_SIZE, GMMACCOUNT_BASE);
3300 *pcPendingPages = 0;
3301 }
3302 return rc;
3303}
3304
3305
3306/**
3307 * Converts a GC physical address to a HC ring-3 pointer, with some
3308 * additional checks.
3309 *
3310 * @returns VBox status code.
3311 * @retval VINF_SUCCESS on success.
3312 * @retval VINF_PGM_PHYS_TLB_CATCH_WRITE and *ppv set if the page has a write
3313 * access handler of some kind.
3314 * @retval VERR_PGM_PHYS_TLB_CATCH_ALL if the page has a handler catching all
3315 * accesses or is odd in any way.
3316 * @retval VERR_PGM_PHYS_TLB_UNASSIGNED if the page doesn't exist.
3317 *
3318 * @param pVM The VM handle.
3319 * @param GCPhys The GC physical address to convert.
3320 * @param fWritable Whether write access is required.
3321 * @param ppv Where to store the pointer corresponding to GCPhys on
3322 * success.
3323 */
3324VMMR3DECL(int) PGMR3PhysTlbGCPhys2Ptr(PVM pVM, RTGCPHYS GCPhys, bool fWritable, void **ppv)
3325{
3326 pgmLock(pVM);
3327
3328 PPGMRAMRANGE pRam;
3329 PPGMPAGE pPage;
3330 int rc = pgmPhysGetPageAndRangeEx(&pVM->pgm.s, GCPhys, &pPage, &pRam);
3331 if (RT_SUCCESS(rc))
3332 {
3333 if (!PGM_PAGE_HAS_ANY_HANDLERS(pPage))
3334 rc = VINF_SUCCESS;
3335 else
3336 {
3337 if (PGM_PAGE_HAS_ACTIVE_ALL_HANDLERS(pPage)) /* catches MMIO */
3338 rc = VERR_PGM_PHYS_TLB_CATCH_ALL;
3339 else if (PGM_PAGE_HAS_ACTIVE_HANDLERS(pPage))
3340 {
3341 /** @todo Handle TLB loads of virtual handlers so ./test.sh can be made to work
3342 * in -norawr0 mode. */
3343 if (fWritable)
3344 rc = VINF_PGM_PHYS_TLB_CATCH_WRITE;
3345 }
3346 else
3347 {
3348 /* Temporarily disabled physical handler(s), since the recompiler
3349 doesn't get notified when it's reset we'll have to pretend it's
3350 operating normally. */
3351 if (pgmHandlerPhysicalIsAll(pVM, GCPhys))
3352 rc = VERR_PGM_PHYS_TLB_CATCH_ALL;
3353 else
3354 rc = VINF_PGM_PHYS_TLB_CATCH_WRITE;
3355 }
3356 }
3357 if (RT_SUCCESS(rc))
3358 {
3359 int rc2;
3360
3361 /* Make sure what we return is writable. */
3362 if (fWritable && rc != VINF_PGM_PHYS_TLB_CATCH_WRITE)
3363 switch (PGM_PAGE_GET_STATE(pPage))
3364 {
3365 case PGM_PAGE_STATE_ALLOCATED:
3366 break;
3367 case PGM_PAGE_STATE_ZERO:
3368 case PGM_PAGE_STATE_SHARED:
3369 case PGM_PAGE_STATE_WRITE_MONITORED:
3370 rc2 = pgmPhysPageMakeWritable(pVM, pPage, GCPhys & ~(RTGCPHYS)PAGE_OFFSET_MASK);
3371 AssertLogRelRCReturn(rc2, rc2);
3372 break;
3373 }
3374
3375 /* Get a ring-3 mapping of the address. */
3376 PPGMPAGER3MAPTLBE pTlbe;
3377 rc2 = pgmPhysPageQueryTlbe(&pVM->pgm.s, GCPhys, &pTlbe);
3378 AssertLogRelRCReturn(rc2, rc2);
3379 *ppv = (void *)((uintptr_t)pTlbe->pv | (uintptr_t)(GCPhys & PAGE_OFFSET_MASK));
3380 /** @todo mapping/locking hell; this isn't horribly efficient since
3381 * pgmPhysPageLoadIntoTlb will repeat the lookup we've done here. */
3382
3383 Log6(("PGMR3PhysTlbGCPhys2Ptr: GCPhys=%RGp rc=%Rrc pPage=%R[pgmpage] *ppv=%p\n", GCPhys, rc, pPage, *ppv));
3384 }
3385 else
3386 Log6(("PGMR3PhysTlbGCPhys2Ptr: GCPhys=%RGp rc=%Rrc pPage=%R[pgmpage]\n", GCPhys, rc, pPage));
3387
3388 /* else: handler catching all access, no pointer returned. */
3389 }
3390 else
3391 rc = VERR_PGM_PHYS_TLB_UNASSIGNED;
3392
3393 pgmUnlock(pVM);
3394 return rc;
3395}
3396
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette