VirtualBox

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

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

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