PGMAllPhys.cpp revision d31ded334a29f575e23dc889b603b1a586759348
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * PGM - Page Manager and Monitor, Physical Memory Addressing.
1c94c0a63ba68be1a7b2c640e70d7a06464e4fcavboxsync * Copyright (C) 2006-2007 Sun Microsystems, Inc.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * This file is part of VirtualBox Open Source Edition (OSE), as
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * available from http://www.virtualbox.org. This file is free software;
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * you can redistribute it and/or modify it under the terms of the GNU
a16eb14ad7a4b5ef91ddc22d3e8e92d930f736fcvboxsync * General Public License (GPL) as published by the Free Software
a16eb14ad7a4b5ef91ddc22d3e8e92d930f736fcvboxsync * Foundation, in version 2 as it comes in the "COPYING" file of the
a16eb14ad7a4b5ef91ddc22d3e8e92d930f736fcvboxsync * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
a16eb14ad7a4b5ef91ddc22d3e8e92d930f736fcvboxsync * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
1c94c0a63ba68be1a7b2c640e70d7a06464e4fcavboxsync * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
1c94c0a63ba68be1a7b2c640e70d7a06464e4fcavboxsync * Clara, CA 95054 USA or visit http://www.sun.com if you need
1c94c0a63ba68be1a7b2c640e70d7a06464e4fcavboxsync * additional information or have any questions.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync/*******************************************************************************
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync* Header Files *
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync*******************************************************************************/
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync/*******************************************************************************
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync* Defined Constants And Macros *
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync*******************************************************************************/
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync/** Enable the physical TLB. */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * \#PF Handler callback for Guest ROM range write access.
afed5ab737f4aacfae3fe73776f40e989190a7cavboxsync * We simply ignore the writes or fall back to the recompiler if we don't support the instruction.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @returns VBox status code (appropritate for trap handling and GC return).
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param pVM VM Handle.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param uErrorCode CPU Error code.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param pRegFrame Trap register frame.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param pvFault The fault address (cr2).
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param GCPhysFault The GC physical address corresponding to pvFault.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param pvUser User argument. Pointer to the ROM range structure.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsyncVMMDECL(int) pgmPhysRomWriteHandler(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, RTGCPHYS GCPhysFault, void *pvUser)
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync uint32_t iPage = (GCPhysFault - pRom->GCPhys) >> PAGE_SHIFT;
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * If it's a simple instruction which doesn't change the cpu state
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * we will simply skip it. Otherwise we'll have to defer it to REM.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync rc = EMInterpretDisasOne(pVM, pVCpu, pRegFrame, pDis, &cbOp);
7e960d3a0a8a3a84d7aba2cca45d72b1c31cc97bvboxsync && pDis->mode == CPUMODE_32BIT /** @todo why does this matter? */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync && !(pDis->prefix & (PREFIX_REPNE | PREFIX_REP | PREFIX_SEG)))
726fc44ad0bd65a178ad4c3ab46ebd6cd3208e99vboxsync /** @todo Find other instructions we can safely skip, possibly
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * adding this kind of detection to DIS or EM. */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync STAM_COUNTER_INC(&pVCpu->pgm.s.StatRZGuestROMWriteHandled);
3080f6c0871099df43a4e91b31894d9c2b1369a8vboxsync rc = PGMHandlerPhysicalPageTempOff(pVM, pRom->GCPhys, GCPhysFault & X86_PTE_PG_MASK);
3080f6c0871099df43a4e91b31894d9c2b1369a8vboxsync break; /** @todo Must edit the shadow PT and restart the instruction, not use the interpreter! */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /* Handle it in ring-3 because it's *way* easier there. */
fdea543f71872a3ec3909536a4fce37ab7aa3a8bvboxsync AssertMsgFailedReturn(("enmProt=%d iPage=%d GCPhysFault=%RGp\n",
726fc44ad0bd65a178ad4c3ab46ebd6cd3208e99vboxsync STAM_COUNTER_INC(&pVCpu->pgm.s.StatRZGuestROMWriteUnhandled);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync#endif /* IN_RING3 */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Checks if Address Gate 20 is enabled or not.
50df3da42ff6589b0ecc4f50f2288811bc370186vboxsync * @returns true if enabled.
50df3da42ff6589b0ecc4f50f2288811bc370186vboxsync * @returns false if disabled.
50df3da42ff6589b0ecc4f50f2288811bc370186vboxsync * @param pVCpu VMCPU handle.
3080f6c0871099df43a4e91b31894d9c2b1369a8vboxsync LogFlow(("PGMPhysIsA20Enabled %d\n", pVCpu->pgm.s.fA20Enabled));
3080f6c0871099df43a4e91b31894d9c2b1369a8vboxsync * Validates a GC physical address.
3080f6c0871099df43a4e91b31894d9c2b1369a8vboxsync * @returns true if valid.
50df3da42ff6589b0ecc4f50f2288811bc370186vboxsync * @returns false if invalid.
726fc44ad0bd65a178ad4c3ab46ebd6cd3208e99vboxsync * @param pVM The VM handle.
50df3da42ff6589b0ecc4f50f2288811bc370186vboxsync * @param GCPhys The physical address to validate.
726fc44ad0bd65a178ad4c3ab46ebd6cd3208e99vboxsyncVMMDECL(bool) PGMPhysIsGCPhysValid(PVM pVM, RTGCPHYS GCPhys)
50df3da42ff6589b0ecc4f50f2288811bc370186vboxsync PPGMPAGE pPage = pgmPhysGetPage(&pVM->pgm.s, GCPhys);
50df3da42ff6589b0ecc4f50f2288811bc370186vboxsync * Checks if a GC physical address is a normal page,
726fc44ad0bd65a178ad4c3ab46ebd6cd3208e99vboxsync * i.e. not ROM, MMIO or reserved.
50df3da42ff6589b0ecc4f50f2288811bc370186vboxsync * @returns true if normal.
726fc44ad0bd65a178ad4c3ab46ebd6cd3208e99vboxsync * @returns false if invalid, ROM, MMIO or reserved page.
50df3da42ff6589b0ecc4f50f2288811bc370186vboxsync * @param pVM The VM handle.
26824086a3f6b36cd911058f1d9b4c0b944706fbvboxsync * @param GCPhys The physical address to check.
26824086a3f6b36cd911058f1d9b4c0b944706fbvboxsyncVMMDECL(bool) PGMPhysIsGCPhysNormal(PVM pVM, RTGCPHYS GCPhys)
68ef804c4ec232c58e2c03c8fc6afe3765c5c0d1vboxsync PPGMPAGE pPage = pgmPhysGetPage(&pVM->pgm.s, GCPhys);
26824086a3f6b36cd911058f1d9b4c0b944706fbvboxsync * Converts a GC physical address to a HC physical address.
50df3da42ff6589b0ecc4f50f2288811bc370186vboxsync * @returns VINF_SUCCESS on success.
b8aaccdbdd143967110d499670605dd7ff6ecc72vboxsync * @returns VERR_PGM_PHYS_PAGE_RESERVED it it's a valid GC physical
50df3da42ff6589b0ecc4f50f2288811bc370186vboxsync * page but has no physical backing.
50df3da42ff6589b0ecc4f50f2288811bc370186vboxsync * @returns VERR_PGM_INVALID_GC_PHYSICAL_ADDRESS if it's not a valid
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * GC physical address.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param pVM The VM handle.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param GCPhys The GC physical address to convert.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param pHCPhys Where to store the HC physical address on success.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsyncVMMDECL(int) PGMPhysGCPhys2HCPhys(PVM pVM, RTGCPHYS GCPhys, PRTHCPHYS pHCPhys)
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync int rc = pgmPhysGetPageEx(&pVM->pgm.s, GCPhys, &pPage);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync *pHCPhys = PGM_PAGE_GET_HCPHYS(pPage) | (GCPhys & PAGE_OFFSET_MASK);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Invalidates all page mapping TLBs.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param pVM The VM handle.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync STAM_COUNTER_INC(&pVM->pgm.s.StatPageMapTlbFlushes);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /* Clear the shared R0/R3 TLB completely. */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync for (unsigned i = 0; i < RT_ELEMENTS(pVM->pgm.s.PhysTlbHC.aEntries); i++)
b1c3cdef473df2fbc621d5da81acc82dbfb8a11avboxsync pVM->pgm.s.PhysTlbHC.aEntries[i].GCPhys = NIL_RTGCPHYS;
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /* @todo clear the RC TLB whenever we add it. */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Invalidates a page mapping TLB entry
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param pVM The VM handle.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param GCPhys GCPhys entry to flush
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsyncVMMDECL(void) PGMPhysInvalidatePageMapTLBEntry(PVM pVM, RTGCPHYS GCPhys)
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync STAM_COUNTER_INC(&pVM->pgm.s.StatPageMapTlbFlushEntry);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /* Clear the shared R0/R3 TLB entry. */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync pVM->pgm.s.PhysTlbHC.aEntries[idx].GCPhys = NIL_RTGCPHYS;
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync PPGMPAGEMAPTLBE pTlbe = &pVM->pgm.s.CTXSUFF(PhysTlb).aEntries[PGM_PAGEMAPTLB_IDX(GCPhys)];
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /* @todo clear the RC TLB whenever we add it. */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Makes sure that there is at least one handy page ready for use.
aaeb2e2f6ed5b164f1dec9a16a7adeb84f64cf31vboxsync * This will also take the appropriate actions when reaching water-marks.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @returns VBox status code.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @retval VINF_SUCCESS on success.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @retval VERR_EM_NO_MEMORY if we're really out of memory.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param pVM The VM handle.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @remarks Must be called from within the PGM critical section. It may
aaeb2e2f6ed5b164f1dec9a16a7adeb84f64cf31vboxsync * nip back to ring-3/0 in some cases.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync AssertMsg(pVM->pgm.s.cHandyPages <= RT_ELEMENTS(pVM->pgm.s.aHandyPages), ("%d\n", pVM->pgm.s.cHandyPages));
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Do we need to do anything special?
6b022885f2cb6a55167609edecd89570cd80001dvboxsync if (pVM->pgm.s.cHandyPages <= RT_MAX(PGM_HANDY_PAGES_SET_FF, PGM_HANDY_PAGES_R3_ALLOC))
50df3da42ff6589b0ecc4f50f2288811bc370186vboxsync if (pVM->pgm.s.cHandyPages <= RT_MAX(PGM_HANDY_PAGES_SET_FF, PGM_HANDY_PAGES_RZ_TO_R3))
6b022885f2cb6a55167609edecd89570cd80001dvboxsync * Allocate pages only if we're out of them, or in ring-3, almost out.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync if (pVM->pgm.s.cHandyPages <= PGM_HANDY_PAGES_R3_ALLOC)
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync if (pVM->pgm.s.cHandyPages <= PGM_HANDY_PAGES_RZ_ALLOC)
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync Log(("PGM: cHandyPages=%u out of %u -> allocate more; VM_FF_PGM_NO_MEMORY=%RTbool\n",
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync pVM->pgm.s.cHandyPages, RT_ELEMENTS(pVM->pgm.s.aHandyPages), VM_FF_ISSET(pVM, VM_FF_PGM_NO_MEMORY) ));
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync int rc = VMMRZCallRing3NoCpu(pVM, VMMCALLRING3_PGM_ALLOCATE_HANDY_PAGES, 0);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync AssertMsgReturn(rc == VINF_EM_NO_MEMORY, ("%Rrc\n", rc), VERR_IPE_UNEXPECTED_INFO_STATUS);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync Assert(VM_FF_ISSET(pVM, VM_FF_PGM_NEED_HANDY_PAGES));
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync VMCPU_FF_SET(VMMGetCpu(pVM), VMCPU_FF_TO_R3); /* paranoia */
9782b553bdb12385214a3ac596aff1476bcb7cbdvboxsync && pVM->pgm.s.cHandyPages <= RT_ELEMENTS(pVM->pgm.s.aHandyPages),
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync if (pVM->pgm.s.cHandyPages <= PGM_HANDY_PAGES_SET_FF)
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync if (pVM->pgm.s.cHandyPages <= PGM_HANDY_PAGES_RZ_TO_R3)
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync Log(("PGM: VM_FF_TO_R3 - cHandyPages=%u out of %u\n", pVM->pgm.s.cHandyPages, RT_ELEMENTS(pVM->pgm.s.aHandyPages)));
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Replace a zero or shared page with new page that we can write to.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @returns The following VBox status codes.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @retval VINF_SUCCESS on success, pPage is modified.
79b07d7ae28b916539c6397e010a5cc05e300551vboxsync * @retval VINF_PGM_SYNC_CR3 on success and a page pool flush is pending.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @retval VERR_EM_NO_MEMORY if we're totally out of memory.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @todo Propagate VERR_EM_NO_MEMORY up the call tree.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param pVM The VM address.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param pPage The physical page tracking structure. This will
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * be modified on success.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param GCPhys The address of the page.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @remarks Must be called from within the PGM critical section. It may
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * nip back to ring-3/0 in some cases.
da936e0446fb2b56b813d5d938f1dfc6e4bf8b13vboxsync * @remarks This function shouldn't really fail, however if it does
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * it probably means we've screwed up the size of handy pages and/or
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * the low-water mark. Or, that some device I/O is causing a lot of
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * pages to be allocated while while the host is in a low-memory
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * condition. This latter should be handled elsewhere and in a more
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * controlled manner, it's on the @bugref{3170} todo list...
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsyncint pgmPhysAllocPage(PVM pVM, PPGMPAGE pPage, RTGCPHYS GCPhys)
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync LogFlow(("pgmPhysAllocPage: %R[pgmpage] %RGp\n", pPage, GCPhys));
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync AssertMsg(PGM_PAGE_IS_ZERO(pPage) || PGM_PAGE_IS_SHARED(pPage), ("%R[pgmpage] %RGp\n", pPage, GCPhys));
533ffcb943c4af2c5fe6385d816d0ba3eda9383bvboxsync * Flush any shadow page table mappings of the page.
533ffcb943c4af2c5fe6385d816d0ba3eda9383bvboxsync * When VBOX_WITH_NEW_LAZY_PAGE_ALLOC isn't defined, there shouldn't be any.
533ffcb943c4af2c5fe6385d816d0ba3eda9383bvboxsync bool fFlushTLBs = false;
533ffcb943c4af2c5fe6385d816d0ba3eda9383bvboxsync int rc = pgmPoolTrackFlushGCPhys(pVM, pPage, &fFlushTLBs);
533ffcb943c4af2c5fe6385d816d0ba3eda9383bvboxsync AssertMsgReturn(rc == VINF_SUCCESS || rc == VINF_PGM_SYNC_CR3, ("%Rrc\n", rc), RT_FAILURE(rc) ? rc : VERR_IPE_UNEXPECTED_STATUS);
533ffcb943c4af2c5fe6385d816d0ba3eda9383bvboxsync * Ensure that we've got a page handy, take it and use it.
533ffcb943c4af2c5fe6385d816d0ba3eda9383bvboxsync /* re-assert preconditions since pgmPhysEnsureHandyPage may do a context switch. */
533ffcb943c4af2c5fe6385d816d0ba3eda9383bvboxsync AssertMsg(PGM_PAGE_IS_ZERO(pPage) || PGM_PAGE_IS_SHARED(pPage), ("%R[pgmpage] %RGp\n", pPage, GCPhys));
533ffcb943c4af2c5fe6385d816d0ba3eda9383bvboxsync AssertMsg(iHandyPage < RT_ELEMENTS(pVM->pgm.s.aHandyPages), ("%d\n", iHandyPage));
533ffcb943c4af2c5fe6385d816d0ba3eda9383bvboxsync Assert(pVM->pgm.s.aHandyPages[iHandyPage].HCPhysGCPhys != NIL_RTHCPHYS);
533ffcb943c4af2c5fe6385d816d0ba3eda9383bvboxsync Assert(!(pVM->pgm.s.aHandyPages[iHandyPage].HCPhysGCPhys & ~X86_PTE_PAE_PG_MASK));
533ffcb943c4af2c5fe6385d816d0ba3eda9383bvboxsync Assert(pVM->pgm.s.aHandyPages[iHandyPage].idPage != NIL_GMM_PAGEID);
533ffcb943c4af2c5fe6385d816d0ba3eda9383bvboxsync Assert(pVM->pgm.s.aHandyPages[iHandyPage].idSharedPage == NIL_GMM_PAGEID);
533ffcb943c4af2c5fe6385d816d0ba3eda9383bvboxsync * There are one or two action to be taken the next time we allocate handy pages:
533ffcb943c4af2c5fe6385d816d0ba3eda9383bvboxsync * - Tell the GMM (global memory manager) what the page is being used for.
533ffcb943c4af2c5fe6385d816d0ba3eda9383bvboxsync * (Speeds up replacement operations - sharing and defragmenting.)
533ffcb943c4af2c5fe6385d816d0ba3eda9383bvboxsync * - If the current backing is shared, it must be freed.
533ffcb943c4af2c5fe6385d816d0ba3eda9383bvboxsync const RTHCPHYS HCPhys = pVM->pgm.s.aHandyPages[iHandyPage].HCPhysGCPhys;
533ffcb943c4af2c5fe6385d816d0ba3eda9383bvboxsync pVM->pgm.s.aHandyPages[iHandyPage].HCPhysGCPhys = GCPhys & ~(RTGCPHYS)PAGE_OFFSET_MASK;
533ffcb943c4af2c5fe6385d816d0ba3eda9383bvboxsync pVM->pgm.s.aHandyPages[iHandyPage].idSharedPage = PGM_PAGE_GET_PAGEID(pPage);
533ffcb943c4af2c5fe6385d816d0ba3eda9383bvboxsync Assert(PGM_PAGE_GET_PAGEID(pPage) != NIL_GMM_PAGEID);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync Log2(("PGM: Replaced shared page %#x at %RGp with %#x / %RHp\n", PGM_PAGE_GET_PAGEID(pPage),
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync GCPhys, pVM->pgm.s.aHandyPages[iHandyPage].idPage, HCPhys));
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync STAM_COUNTER_INC(&pVM->pgm.s.CTX_MID_Z(Stat,PageReplaceShared));
e52f819639386db020b2a635b47a415248c7fbf9vboxsync AssertMsgFailed(("TODO: copy shared page content")); /** @todo err.. what about copying the page content? */
e02db9e0d46f862430895b82b10e8ecde075cf11vboxsync Log2(("PGM: Replaced zero page %RGp with %#x / %RHp\n", GCPhys, pVM->pgm.s.aHandyPages[iHandyPage].idPage, HCPhys));
79b07d7ae28b916539c6397e010a5cc05e300551vboxsync STAM_COUNTER_INC(&pVM->pgm.s.StatRZPageReplaceZero);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync Assert(pVM->pgm.s.aHandyPages[iHandyPage].idSharedPage == NIL_GMM_PAGEID);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Do the PGMPAGE modifications.
0e77737b0ba913683e614db11463b31ca67aacbevboxsync PGM_PAGE_SET_PAGEID(pPage, pVM->pgm.s.aHandyPages[iHandyPage].idPage);
e08de24d4792d31b7f2aac29db5cb8840d940009vboxsync PGM_PAGE_SET_STATE(pPage, PGM_PAGE_STATE_ALLOCATED);
2d53f6e472561965d363674e17f48d3bdffc24d3vboxsync * Deal with a write monitored page.
e9a217d585085a6a6d129d27ca0d96a1b8e6d0eevboxsync * @returns VBox strict status code.
2d53f6e472561965d363674e17f48d3bdffc24d3vboxsync * @param pVM The VM address.
0e77737b0ba913683e614db11463b31ca67aacbevboxsync * @param pPage The physical page tracking structure.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @remarks Called from within the PGM critical section.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsyncvoid pgmPhysPageMakeWriteMonitoredWritable(PVM pVM, PPGMPAGE pPage)
3080f6c0871099df43a4e91b31894d9c2b1369a8vboxsync Assert(PGM_PAGE_GET_STATE(pPage) == PGM_PAGE_STATE_WRITE_MONITORED);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync PGM_PAGE_SET_STATE(pPage, PGM_PAGE_STATE_ALLOCATED);
6b022885f2cb6a55167609edecd89570cd80001dvboxsync * Deal with pages that are not writable, i.e. not in the ALLOCATED state.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @returns VBox strict status code.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @retval VINF_SUCCESS on success.
d98e61ba075ed7d0b567a5d884bc85d643fe3de7vboxsync * @retval VINF_PGM_SYNC_CR3 on success and a page pool flush is pending.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @retval VERR_PGM_PHYS_PAGE_RESERVED it it's a valid page but has no physical backing.
e08de24d4792d31b7f2aac29db5cb8840d940009vboxsync * @param pVM The VM address.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param pPage The physical page tracking structure.
e08de24d4792d31b7f2aac29db5cb8840d940009vboxsync * @param GCPhys The address of the page.
e4ea543752422f1139923e3e506c625b0a1827c5vboxsync * @remarks Called from within the PGM critical section.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsyncint pgmPhysPageMakeWritable(PVM pVM, PPGMPAGE pPage, RTGCPHYS GCPhys)
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /* fall thru */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync default: /* to shut up GCC */
7e960d3a0a8a3a84d7aba2cca45d72b1c31cc97bvboxsync * Zero pages can be dummy pages for MMIO or reserved memory,
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * so we need to check the flags before joining cause with
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * shared page replacement.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /* fall thru */
65eb75d34c65a45c0945358715253950d63e440cvboxsync * Wrapper for pgmPhysPageMakeWritable which enters the critsect.
858aad6160628a88d8a273db0344fc3ba7dcc9abvboxsync * @returns VBox strict status code.
858aad6160628a88d8a273db0344fc3ba7dcc9abvboxsync * @retval VINF_SUCCESS on success.
858aad6160628a88d8a273db0344fc3ba7dcc9abvboxsync * @retval VINF_PGM_SYNC_CR3 on success and a page pool flush is pending.
d98e61ba075ed7d0b567a5d884bc85d643fe3de7vboxsync * @retval VERR_PGM_PHYS_PAGE_RESERVED it it's a valid page but has no physical backing.
d98e61ba075ed7d0b567a5d884bc85d643fe3de7vboxsync * @param pVM The VM address.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param pPage The physical page tracking structure.
6b022885f2cb6a55167609edecd89570cd80001dvboxsync * @param GCPhys The address of the page.
da936e0446fb2b56b813d5d938f1dfc6e4bf8b13vboxsyncint pgmPhysPageMakeWritableUnlocked(PVM pVM, PPGMPAGE pPage, RTGCPHYS GCPhys)
da936e0446fb2b56b813d5d938f1dfc6e4bf8b13vboxsync * Internal usage: Map the page specified by its GMM ID.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * This is similar to pgmPhysPageMap
d98e61ba075ed7d0b567a5d884bc85d643fe3de7vboxsync * @returns VBox status code.
d98e61ba075ed7d0b567a5d884bc85d643fe3de7vboxsync * @param pVM The VM handle.
da936e0446fb2b56b813d5d938f1dfc6e4bf8b13vboxsync * @param idPage The Page ID.
7e960d3a0a8a3a84d7aba2cca45d72b1c31cc97bvboxsync * @param HCPhys The physical address (for RC).
d98e61ba075ed7d0b567a5d884bc85d643fe3de7vboxsync * @param ppv Where to store the mapping address.
da936e0446fb2b56b813d5d938f1dfc6e4bf8b13vboxsync * @remarks Called from within the PGM critical section. The mapping is only
d98e61ba075ed7d0b567a5d884bc85d643fe3de7vboxsync * valid while your inside this section.
440444d68cda7866c59e2e3d3f236608ef1c316fvboxsyncint pgmPhysPageMapByPageID(PVM pVM, uint32_t idPage, RTHCPHYS HCPhys, void **ppv)
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Validation.
79b24ef0ab7cd4a03a3571b3954c52ab8b573137vboxsync AssertReturn(HCPhys && !(HCPhys & PAGE_OFFSET_MASK), VERR_INVALID_PARAMETER);
79b24ef0ab7cd4a03a3571b3954c52ab8b573137vboxsync const uint32_t idChunk = idPage >> GMM_CHUNKID_SHIFT;
da936e0446fb2b56b813d5d938f1dfc6e4bf8b13vboxsync AssertReturn(idChunk != NIL_GMM_CHUNKID, VERR_INVALID_PARAMETER);
6b022885f2cb6a55167609edecd89570cd80001dvboxsync * Map it by HCPhys.
3cac8f8c6923a3a89ecfccda5e89ad75f48658e0vboxsync * Map it by HCPhys.
3cac8f8c6923a3a89ecfccda5e89ad75f48658e0vboxsync return pgmR0DynMapHCPageInlined(&pVM->pgm.s, HCPhys, ppv);
3dde2f85d4cf477621a3128887a2c08a8bca7c01vboxsync * Find/make Chunk TLB entry for the mapping chunk.
5e797edc29f96c8367de4fbf5874171c24a89ba7vboxsync PPGMCHUNKR3MAPTLBE pTlbe = &pVM->pgm.s.ChunkR3Map.Tlb.aEntries[PGM_CHUNKR3MAPTLB_IDX(idChunk)];
5e797edc29f96c8367de4fbf5874171c24a89ba7vboxsync STAM_COUNTER_INC(&pVM->pgm.s.CTX_MID_Z(Stat,ChunkR3MapTlbHits));
3dde2f85d4cf477621a3128887a2c08a8bca7c01vboxsync STAM_COUNTER_INC(&pVM->pgm.s.CTX_MID_Z(Stat,ChunkR3MapTlbMisses));
3dde2f85d4cf477621a3128887a2c08a8bca7c01vboxsync * Find the chunk, map it if necessary.
e08de24d4792d31b7f2aac29db5cb8840d940009vboxsync pMap = (PPGMCHUNKR3MAP)RTAvlU32Get(&pVM->pgm.s.ChunkR3Map.pTree, idChunk);
5e797edc29f96c8367de4fbf5874171c24a89ba7vboxsync int rc = VMMRZCallRing3NoCpu(pVM, VMMCALLRING3_PGM_MAP_CHUNK, idChunk);
79b24ef0ab7cd4a03a3571b3954c52ab8b573137vboxsync pMap = (PPGMCHUNKR3MAP)RTAvlU32Get(&pVM->pgm.s.ChunkR3Map.pTree, idChunk);
3dde2f85d4cf477621a3128887a2c08a8bca7c01vboxsync * Enter it into the Chunk TLB.
3dde2f85d4cf477621a3128887a2c08a8bca7c01vboxsync *ppv = (uint8_t *)pMap->pv + ((idPage &GMM_PAGEID_IDX_MASK) << PAGE_SHIFT);
3080f6c0871099df43a4e91b31894d9c2b1369a8vboxsync * Maps a page into the current virtual address space so it can be accessed.
f9147fe1eaa4e35287f8f39282c7f92f0d7de0b7vboxsync * @returns VBox status code.
3080f6c0871099df43a4e91b31894d9c2b1369a8vboxsync * @retval VINF_SUCCESS on success.
f9147fe1eaa4e35287f8f39282c7f92f0d7de0b7vboxsync * @retval VERR_PGM_PHYS_PAGE_RESERVED it it's a valid page but has no physical backing.
3cac8f8c6923a3a89ecfccda5e89ad75f48658e0vboxsync * @param pVM The VM address.
7082d29724f6c3788977a51591b0379fd3acbf72vboxsync * @param pPage The physical page tracking structure.
7082d29724f6c3788977a51591b0379fd3acbf72vboxsync * @param GCPhys The address of the page.
7082d29724f6c3788977a51591b0379fd3acbf72vboxsync * @param ppMap Where to store the address of the mapping tracking structure.
da936e0446fb2b56b813d5d938f1dfc6e4bf8b13vboxsync * @param ppv Where to store the mapping address of the page. The page
f9147fe1eaa4e35287f8f39282c7f92f0d7de0b7vboxsync * offset is masked off!
f9147fe1eaa4e35287f8f39282c7f92f0d7de0b7vboxsync * @remarks Called from within the PGM critical section.
f9147fe1eaa4e35287f8f39282c7f92f0d7de0b7vboxsyncstatic int pgmPhysPageMapCommon(PVM pVM, PPGMPAGE pPage, RTGCPHYS GCPhys, PPPGMPAGEMAP ppMap, void **ppv)
f9147fe1eaa4e35287f8f39282c7f92f0d7de0b7vboxsync#if defined(IN_RC) || defined(VBOX_WITH_2X_4GB_ADDR_SPACE_IN_R0)
f9147fe1eaa4e35287f8f39282c7f92f0d7de0b7vboxsync * Just some sketchy GC/R0-darwin code.
f9147fe1eaa4e35287f8f39282c7f92f0d7de0b7vboxsync pgmR0DynMapHCPageInlined(&pVM->pgm.s, HCPhys, ppv);
6b022885f2cb6a55167609edecd89570cd80001dvboxsync#else /* IN_RING3 || IN_RING0 */
f9147fe1eaa4e35287f8f39282c7f92f0d7de0b7vboxsync * Special case: ZERO and MMIO2 pages.
f9147fe1eaa4e35287f8f39282c7f92f0d7de0b7vboxsync const uint32_t idChunk = PGM_PAGE_GET_CHUNKID(pPage);
65b61798a61dd4c32cce448db1dac70bba8d5cf5vboxsync AssertMsgReturn(PGM_PAGE_GET_PAGEID(pPage) == NIL_GMM_PAGEID, ("pPage=%R[pgmpage]\n", pPage), VERR_INTERNAL_ERROR_2);
65b61798a61dd4c32cce448db1dac70bba8d5cf5vboxsync /* Lookup the MMIO2 range and use pvR3 to calc the address. */
da936e0446fb2b56b813d5d938f1dfc6e4bf8b13vboxsync PPGMRAMRANGE pRam = pgmPhysGetRange(&pVM->pgm.s, GCPhys);
65b61798a61dd4c32cce448db1dac70bba8d5cf5vboxsync AssertMsgReturn(pRam || !pRam->pvR3, ("pRam=%p pPage=%R[pgmpage]\n", pRam, pPage), VERR_INTERNAL_ERROR_2);
65b61798a61dd4c32cce448db1dac70bba8d5cf5vboxsync *ppv = (void *)((uintptr_t)pRam->pvR3 + (GCPhys & ~(RTGCPHYS)PAGE_OFFSET_MASK) - pRam->GCPhys);
6b022885f2cb6a55167609edecd89570cd80001dvboxsync else if (PGM_PAGE_GET_TYPE(pPage) == PGMPAGETYPE_MMIO2_ALIAS_MMIO)
65b61798a61dd4c32cce448db1dac70bba8d5cf5vboxsync /** @todo deal with aliased MMIO2 pages somehow...
65b61798a61dd4c32cce448db1dac70bba8d5cf5vboxsync * One solution would be to seed MMIO2 pages to GMM and get unique Page IDs for
65b61798a61dd4c32cce448db1dac70bba8d5cf5vboxsync * them, that would also avoid this mess. It would actually be kind of
65b61798a61dd4c32cce448db1dac70bba8d5cf5vboxsync * elegant... */
65b61798a61dd4c32cce448db1dac70bba8d5cf5vboxsync AssertLogRelMsgFailedReturn(("%RGp\n", GCPhys), VERR_INTERNAL_ERROR_3);
8e8844a522f5d335f177a0313b03067d79cce201vboxsync /** @todo handle MMIO2 */
8e8844a522f5d335f177a0313b03067d79cce201vboxsync AssertMsgReturn(PGM_PAGE_IS_ZERO(pPage), ("pPage=%R[pgmpage]\n", pPage), VERR_INTERNAL_ERROR_2);
65b61798a61dd4c32cce448db1dac70bba8d5cf5vboxsync AssertMsgReturn(PGM_PAGE_GET_HCPHYS(pPage) == pVM->pgm.s.HCPhysZeroPg,
e4ea543752422f1139923e3e506c625b0a1827c5vboxsync * Find/make Chunk TLB entry for the mapping chunk.
65b61798a61dd4c32cce448db1dac70bba8d5cf5vboxsync PPGMCHUNKR3MAPTLBE pTlbe = &pVM->pgm.s.ChunkR3Map.Tlb.aEntries[PGM_CHUNKR3MAPTLB_IDX(idChunk)];
6b022885f2cb6a55167609edecd89570cd80001dvboxsync STAM_COUNTER_INC(&pVM->pgm.s.CTX_MID_Z(Stat,ChunkR3MapTlbHits));
65b61798a61dd4c32cce448db1dac70bba8d5cf5vboxsync STAM_COUNTER_INC(&pVM->pgm.s.CTX_MID_Z(Stat,ChunkR3MapTlbMisses));
8e8844a522f5d335f177a0313b03067d79cce201vboxsync * Find the chunk, map it if necessary.
65b61798a61dd4c32cce448db1dac70bba8d5cf5vboxsync pMap = (PPGMCHUNKR3MAP)RTAvlU32Get(&pVM->pgm.s.ChunkR3Map.pTree, idChunk);
65b61798a61dd4c32cce448db1dac70bba8d5cf5vboxsync int rc = VMMRZCallRing3NoCpu(pVM, VMMCALLRING3_PGM_MAP_CHUNK, idChunk);
65b61798a61dd4c32cce448db1dac70bba8d5cf5vboxsync pMap = (PPGMCHUNKR3MAP)RTAvlU32Get(&pVM->pgm.s.ChunkR3Map.pTree, idChunk);
3dde2f85d4cf477621a3128887a2c08a8bca7c01vboxsync * Enter it into the Chunk TLB.
3dde2f85d4cf477621a3128887a2c08a8bca7c01vboxsync *ppv = (uint8_t *)pMap->pv + (PGM_PAGE_GET_PAGE_IN_CHUNK(pPage) << PAGE_SHIFT);
e08de24d4792d31b7f2aac29db5cb8840d940009vboxsync#endif /* IN_RING3 */
3dde2f85d4cf477621a3128887a2c08a8bca7c01vboxsync * Combination of pgmPhysPageMakeWritable and pgmPhysPageMapWritable.
3dde2f85d4cf477621a3128887a2c08a8bca7c01vboxsync * This is typically used is paths where we cannot use the TLB methods (like ROM
3dde2f85d4cf477621a3128887a2c08a8bca7c01vboxsync * pages) or where there is no point in using them since we won't get many hits.
46df4404c8dbbf3672e7aae8cd0b2770356e5b73vboxsync * @returns VBox strict status code.
46df4404c8dbbf3672e7aae8cd0b2770356e5b73vboxsync * @retval VINF_SUCCESS on success.
46df4404c8dbbf3672e7aae8cd0b2770356e5b73vboxsync * @retval VINF_PGM_SYNC_CR3 on success and a page pool flush is pending.
46df4404c8dbbf3672e7aae8cd0b2770356e5b73vboxsync * @retval VERR_PGM_PHYS_PAGE_RESERVED it it's a valid page but has no physical backing.
585f64d6f624f9e683321dabeb21b0eb2e6aa473vboxsync * @param pVM The VM address.
3cac8f8c6923a3a89ecfccda5e89ad75f48658e0vboxsync * @param pPage The physical page tracking structure.
3cac8f8c6923a3a89ecfccda5e89ad75f48658e0vboxsync * @param GCPhys The address of the page.
585f64d6f624f9e683321dabeb21b0eb2e6aa473vboxsync * @param ppv Where to store the mapping address of the page. The page
585f64d6f624f9e683321dabeb21b0eb2e6aa473vboxsync * offset is masked off!
585f64d6f624f9e683321dabeb21b0eb2e6aa473vboxsync * @remarks Called from within the PGM critical section. The mapping is only
da936e0446fb2b56b813d5d938f1dfc6e4bf8b13vboxsync * valid while your inside this section.
585f64d6f624f9e683321dabeb21b0eb2e6aa473vboxsyncint pgmPhysPageMakeWritableAndMap(PVM pVM, PPGMPAGE pPage, RTGCPHYS GCPhys, void **ppv)
585f64d6f624f9e683321dabeb21b0eb2e6aa473vboxsync int rc = pgmPhysPageMakeWritable(pVM, pPage, GCPhys);
585f64d6f624f9e683321dabeb21b0eb2e6aa473vboxsync AssertMsg(rc == VINF_SUCCESS || rc == VINF_PGM_SYNC_CR3 /* returned */, ("%Rrc\n", rc));
585f64d6f624f9e683321dabeb21b0eb2e6aa473vboxsync int rc2 = pgmPhysPageMapCommon(pVM, pPage, GCPhys, &pMapIgnore, ppv);
585f64d6f624f9e683321dabeb21b0eb2e6aa473vboxsync * Maps a page into the current virtual address space so it can be accessed for
585f64d6f624f9e683321dabeb21b0eb2e6aa473vboxsync * both writing and reading.
585f64d6f624f9e683321dabeb21b0eb2e6aa473vboxsync * This is typically used is paths where we cannot use the TLB methods (like ROM
585f64d6f624f9e683321dabeb21b0eb2e6aa473vboxsync * pages) or where there is no point in using them since we won't get many hits.
65b61798a61dd4c32cce448db1dac70bba8d5cf5vboxsync * @returns VBox status code.
585f64d6f624f9e683321dabeb21b0eb2e6aa473vboxsync * @retval VINF_SUCCESS on success.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @retval VERR_PGM_PHYS_PAGE_RESERVED it it's a valid page but has no physical backing.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param pVM The VM address.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param pPage The physical page tracking structure. Must be in the
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * allocated state.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param GCPhys The address of the page.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param ppv Where to store the mapping address of the page. The page
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * offset is masked off!
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @remarks Called from within the PGM critical section. The mapping is only
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * valid while your inside this section.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsyncint pgmPhysPageMap(PVM pVM, PPGMPAGE pPage, RTGCPHYS GCPhys, void **ppv)
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync Assert(PGM_PAGE_GET_STATE(pPage) == PGM_PAGE_STATE_ALLOCATED);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync return pgmPhysPageMapCommon(pVM, pPage, GCPhys, &pMapIgnore, ppv);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Maps a page into the current virtual address space so it can be accessed for
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * This is typically used is paths where we cannot use the TLB methods (like ROM
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * pages) or where there is no point in using them since we won't get many hits.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @returns VBox status code.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @retval VINF_SUCCESS on success.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @retval VERR_PGM_PHYS_PAGE_RESERVED it it's a valid page but has no physical backing.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param pVM The VM address.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param pPage The physical page tracking structure.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param GCPhys The address of the page.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param ppv Where to store the mapping address of the page. The page
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * offset is masked off!
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @remarks Called from within the PGM critical section. The mapping is only
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * valid while your inside this section.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsyncint pgmPhysPageMapReadOnly(PVM pVM, PPGMPAGE pPage, RTGCPHYS GCPhys, void const **ppv)
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync return pgmPhysPageMapCommon(pVM, pPage, GCPhys, &pMapIgnore, (void **)ppv);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync#if !defined(IN_RC) && !defined(VBOX_WITH_2X_4GB_ADDR_SPACE_IN_R0)
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Load a guest page into the ring-3 physical TLB.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @returns VBox status code.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @retval VINF_SUCCESS on success
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @retval VERR_PGM_INVALID_GC_PHYSICAL_ADDRESS if it's not a valid physical address.
e9a217d585085a6a6d129d27ca0d96a1b8e6d0eevboxsync * @param pPGM The PGM instance pointer.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param GCPhys The guest physical address in question.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsyncint pgmPhysPageLoadIntoTlb(PPGM pPGM, RTGCPHYS GCPhys)
e9a217d585085a6a6d129d27ca0d96a1b8e6d0eevboxsync STAM_COUNTER_INC(&pPGM->CTX_MID_Z(Stat,PageMapTlbMisses));
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Find the ram range.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * 99.8% of requests are expected to be in the first range.
e17bd6c32a8dd64f2d42838f9028216465e2caf0vboxsync * Map the page.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Make a special case for the zero page as it is kind of special.
49748bb305bd71f672cd083af208f4bb08c5d6abvboxsync PPGMPAGEMAPTLBE pTlbe = &pPGM->CTXSUFF(PhysTlb).aEntries[PGM_PAGEMAPTLB_IDX(GCPhys)];
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync int rc = pgmPhysPageMapCommon(PGM2VM(pPGM), pPage, GCPhys, &pMap, &pv);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync Assert(!((uintptr_t)pTlbe->pv & PAGE_OFFSET_MASK));
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync Assert(PGM_PAGE_GET_HCPHYS(pPage) == pPGM->HCPhysZeroPg);
8b984478b755f4d3091b977d9beac9fb7434279fvboxsync * Load a guest page into the ring-3 physical TLB.
e9a217d585085a6a6d129d27ca0d96a1b8e6d0eevboxsync * @returns VBox status code.
e9a217d585085a6a6d129d27ca0d96a1b8e6d0eevboxsync * @retval VINF_SUCCESS on success
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @retval VERR_PGM_INVALID_GC_PHYSICAL_ADDRESS if it's not a valid physical address.
14e483cf65160fb363043534151245ae4c215766vboxsync * @param pPGM The PGM instance pointer.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param pPage Pointer to the PGMPAGE structure corresponding to
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param GCPhys The guest physical address in question.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsyncint pgmPhysPageLoadIntoTlbWithPage(PPGM pPGM, PPGMPAGE pPage, RTGCPHYS GCPhys)
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync STAM_COUNTER_INC(&pPGM->CTX_MID_Z(Stat,PageMapTlbMisses));
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Map the page.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Make a special case for the zero page as it is kind of special.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync PPGMPAGEMAPTLBE pTlbe = &pPGM->CTXSUFF(PhysTlb).aEntries[PGM_PAGEMAPTLB_IDX(GCPhys)];
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync int rc = pgmPhysPageMapCommon(PGM2VM(pPGM), pPage, GCPhys, &pMap, &pv);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync Assert(!((uintptr_t)pTlbe->pv & PAGE_OFFSET_MASK));
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync Assert(PGM_PAGE_GET_HCPHYS(pPage) == pPGM->HCPhysZeroPg);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync#endif /* !IN_RC && !VBOX_WITH_2X_4GB_ADDR_SPACE_IN_R0 */
f02b41a7e54fc4e6b714f4e60260d94614d6e2e7vboxsync * Internal version of PGMPhysGCPhys2CCPtr that expects the caller to
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * own the PGM lock and therefore not need to lock the mapped page.
5b6e2c9a765c3c72295acc15791af8a700746956vboxsync * @returns VBox status code.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @retval VINF_SUCCESS on success.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @retval VERR_PGM_PHYS_PAGE_RESERVED it it's a valid page but has no physical backing.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @retval VERR_PGM_INVALID_GC_PHYSICAL_ADDRESS if it's not a valid physical address.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param pVM The VM handle.
5b6e2c9a765c3c72295acc15791af8a700746956vboxsync * @param GCPhys The guest physical address of the page that should be mapped.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param pPage Pointer to the PGMPAGE structure for the page.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param ppv Where to store the address corresponding to GCPhys.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @internal
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsyncint pgmPhysGCPhys2CCPtrInternal(PVM pVM, PPGMPAGE pPage, RTGCPHYS GCPhys, void **ppv)
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Make sure the page is writable.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync if (RT_UNLIKELY(PGM_PAGE_GET_STATE(pPage) != PGM_PAGE_STATE_ALLOCATED))
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync AssertMsg(rc == VINF_SUCCESS || rc == VINF_PGM_SYNC_CR3 /* not returned */, ("%Rrc\n", rc));
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Get the mapping address.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync#if defined(IN_RC) || defined(VBOX_WITH_2X_4GB_ADDR_SPACE_IN_R0)
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync *ppv = pgmDynMapHCPageOff(&pVM->pgm.s, PGM_PAGE_GET_HCPHYS(pPage) | (GCPhys & PAGE_OFFSET_MASK));
3123bb2477edc752585e4bbd8e4cfedaf87997d1vboxsync rc = pgmPhysPageQueryTlbeWithPage(&pVM->pgm.s, pPage, GCPhys, &pTlbe);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync *ppv = (void *)((uintptr_t)pTlbe->pv | (GCPhys & PAGE_OFFSET_MASK));
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Internal version of PGMPhysGCPhys2CCPtrReadOnly that expects the caller to
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * own the PGM lock and therefore not need to lock the mapped page.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @returns VBox status code.
0975ae0a0fb615c945150c48e4a73187c1f4f84dvboxsync * @retval VINF_SUCCESS on success.
0975ae0a0fb615c945150c48e4a73187c1f4f84dvboxsync * @retval VERR_PGM_PHYS_PAGE_RESERVED it it's a valid page but has no physical backing.
0975ae0a0fb615c945150c48e4a73187c1f4f84dvboxsync * @retval VERR_PGM_INVALID_GC_PHYSICAL_ADDRESS if it's not a valid physical address.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param pVM The VM handle.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param GCPhys The guest physical address of the page that should be mapped.
0975ae0a0fb615c945150c48e4a73187c1f4f84dvboxsync * @param pPage Pointer to the PGMPAGE structure for the page.
0975ae0a0fb615c945150c48e4a73187c1f4f84dvboxsync * @param ppv Where to store the address corresponding to GCPhys.
0975ae0a0fb615c945150c48e4a73187c1f4f84dvboxsync * @internal
78a205e3fc6719d59e8c561b3d287d3a4f879852vboxsyncint pgmPhysGCPhys2CCPtrInternalReadOnly(PVM pVM, PPGMPAGE pPage, RTGCPHYS GCPhys, const void **ppv)
78a205e3fc6719d59e8c561b3d287d3a4f879852vboxsync * Get the mapping address.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync#if defined(IN_RC) || defined(VBOX_WITH_2X_4GB_ADDR_SPACE_IN_R0)
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync *ppv = pgmDynMapHCPageOff(&pVM->pgm.s, PGM_PAGE_GET_HCPHYS(pPage) | (GCPhys & PAGE_OFFSET_MASK)); /** @todo add a read only flag? */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync int rc = pgmPhysPageQueryTlbeWithPage(&pVM->pgm.s, pPage, GCPhys, &pTlbe);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync *ppv = (void *)((uintptr_t)pTlbe->pv | (GCPhys & PAGE_OFFSET_MASK));
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Requests the mapping of a guest page into the current context.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * This API should only be used for very short term, as it will consume
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * scarse resources (R0 and GC) in the mapping cache. When you're done
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * with the page, call PGMPhysReleasePageMappingLock() ASAP to release it.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * This API will assume your intention is to write to the page, and will
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * therefore replace shared and zero pages. If you do not intend to modify
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * the page, use the PGMPhysGCPhys2CCPtrReadOnly() API.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @returns VBox status code.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @retval VINF_SUCCESS on success.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @retval VERR_PGM_PHYS_PAGE_RESERVED it it's a valid page but has no physical backing.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @retval VERR_PGM_INVALID_GC_PHYSICAL_ADDRESS if it's not a valid physical address.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param pVM The VM handle.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param GCPhys The guest physical address of the page that should be mapped.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param ppv Where to store the address corresponding to GCPhys.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param pLock Where to store the lock information that PGMPhysReleasePageMappingLock needs.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @remarks The caller is responsible for dealing with access handlers.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @todo Add an informational return code for pages with access handlers?
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @remark Avoid calling this API from within critical sections (other than the
0975ae0a0fb615c945150c48e4a73187c1f4f84dvboxsync * PGM one) because of the deadlock risk. External threads may need to
0975ae0a0fb615c945150c48e4a73187c1f4f84dvboxsync * delegate jobs to the EMTs.
0975ae0a0fb615c945150c48e4a73187c1f4f84dvboxsync * @thread Any thread.
0975ae0a0fb615c945150c48e4a73187c1f4f84dvboxsyncVMMDECL(int) PGMPhysGCPhys2CCPtr(PVM pVM, RTGCPHYS GCPhys, void **ppv, PPGMPAGEMAPLOCK pLock)
0975ae0a0fb615c945150c48e4a73187c1f4f84dvboxsync#if defined(IN_RC) || defined(VBOX_WITH_2X_4GB_ADDR_SPACE_IN_R0)
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Find the page and make sure it's writable.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync int rc = pgmPhysGetPageEx(&pVM->pgm.s, GCPhys, &pPage);
47b5427d1a541bcd269bc625c35b19d849071edfvboxsync if (RT_UNLIKELY(PGM_PAGE_GET_STATE(pPage) != PGM_PAGE_STATE_ALLOCATED))
47b5427d1a541bcd269bc625c35b19d849071edfvboxsync *ppv = pgmDynMapHCPageOff(&pVM->pgm.s, PGM_PAGE_GET_HCPHYS(pPage) | (GCPhys & PAGE_OFFSET_MASK)); /** @todo add a read only flag? */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync AssertMsg(rc == VINF_SUCCESS || rc == VINF_PGM_SYNC_CR3 /* not returned */, ("%Rrc\n", rc));
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync#else /* IN_RING3 || IN_RING0 */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Query the Physical TLB entry for the page (may fail).
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync rc = pgmPhysPageQueryTlbe(&pVM->pgm.s, GCPhys, &pTlbe);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * If the page is shared, the zero page, or being write monitored
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * it must be converted to an page that's writable if possible.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync if (RT_UNLIKELY(PGM_PAGE_GET_STATE(pPage) != PGM_PAGE_STATE_ALLOCATED))
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync AssertMsg(rc == VINF_SUCCESS || rc == VINF_PGM_SYNC_CR3 /* not returned */, ("%Rrc\n", rc));
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync rc = pgmPhysPageQueryTlbeWithPage(&pVM->pgm.s, pPage, GCPhys, &pTlbe);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Now, just perform the locking and calculate the return address.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync else if (cLocks != PGM_PAGE_GET_WRITE_LOCKS(pPage))
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync AssertMsgFailed(("%RGp / %R[pgmpage] is entering permanent write locked state!\n", GCPhys, pPage));
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync pMap->cRefs++; /* Extra ref to prevent it from going away. */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync *ppv = (void *)((uintptr_t)pTlbe->pv | (GCPhys & PAGE_OFFSET_MASK));
e17bd6c32a8dd64f2d42838f9028216465e2caf0vboxsync pLock->uPageAndType = (uintptr_t)pPage | PGMPAGEMAPLOCK_TYPE_WRITE;
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync#endif /* IN_RING3 || IN_RING0 */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Requests the mapping of a guest page into the current context.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * This API should only be used for very short term, as it will consume
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * scarse resources (R0 and GC) in the mapping cache. When you're done
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * with the page, call PGMPhysReleasePageMappingLock() ASAP to release it.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @returns VBox status code.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @retval VINF_SUCCESS on success.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @retval VERR_PGM_PHYS_PAGE_RESERVED it it's a valid page but has no physical backing.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @retval VERR_PGM_INVALID_GC_PHYSICAL_ADDRESS if it's not a valid physical address.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param pVM The VM handle.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param GCPhys The guest physical address of the page that should be mapped.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param ppv Where to store the address corresponding to GCPhys.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param pLock Where to store the lock information that PGMPhysReleasePageMappingLock needs.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @remarks The caller is responsible for dealing with access handlers.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @todo Add an informational return code for pages with access handlers?
5b6e2c9a765c3c72295acc15791af8a700746956vboxsync * @remark Avoid calling this API from within critical sections (other than
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * the PGM one) because of the deadlock risk.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @thread Any thread.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsyncVMMDECL(int) PGMPhysGCPhys2CCPtrReadOnly(PVM pVM, RTGCPHYS GCPhys, void const **ppv, PPGMPAGEMAPLOCK pLock)
08bc90fc2848c80bf8270bedc883745b8398e186vboxsync#if defined(IN_RC) || defined(VBOX_WITH_2X_4GB_ADDR_SPACE_IN_R0)
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Find the page and make sure it's readable.
0f5d1b2abd9e82c7ee46f1327287c44856604bcbvboxsync int rc = pgmPhysGetPageEx(&pVM->pgm.s, GCPhys, &pPage);
0f5d1b2abd9e82c7ee46f1327287c44856604bcbvboxsync *ppv = pgmDynMapHCPageOff(&pVM->pgm.s, PGM_PAGE_GET_HCPHYS(pPage) | (GCPhys & PAGE_OFFSET_MASK)); /** @todo add a read only flag? */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync AssertMsg(rc == VINF_SUCCESS || rc == VINF_PGM_SYNC_CR3 /* not returned */, ("%Rrc\n", rc));
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync#else /* IN_RING3 || IN_RING0 */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Query the Physical TLB entry for the page (may fail).
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync rc = pgmPhysPageQueryTlbe(&pVM->pgm.s, GCPhys, &pTlbe);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /* MMIO pages doesn't have any readable backing. */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Now, just perform the locking and calculate the return address.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync AssertMsgFailed(("%RGp / %R[pgmpage] is entering permanent readonly locked state!\n", GCPhys, pPage));
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync pMap->cRefs++; /* Extra ref to prevent it from going away. */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync *ppv = (void *)((uintptr_t)pTlbe->pv | (GCPhys & PAGE_OFFSET_MASK));
b1c3cdef473df2fbc621d5da81acc82dbfb8a11avboxsync pLock->uPageAndType = (uintptr_t)pPage | PGMPAGEMAPLOCK_TYPE_READ;
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync#endif /* IN_RING3 || IN_RING0 */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Requests the mapping of a guest page given by virtual address into the current context.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * This API should only be used for very short term, as it will consume
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * scarse resources (R0 and GC) in the mapping cache. When you're done
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * with the page, call PGMPhysReleasePageMappingLock() ASAP to release it.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * This API will assume your intention is to write to the page, and will
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * therefore replace shared and zero pages. If you do not intend to modify
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * the page, use the PGMPhysGCPtr2CCPtrReadOnly() API.
6b022885f2cb6a55167609edecd89570cd80001dvboxsync * @returns VBox status code.
b45d66c0e496e2fd861479202f3d43aad592bd14vboxsync * @retval VINF_SUCCESS on success.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @retval VERR_PAGE_TABLE_NOT_PRESENT if the page directory for the virtual address isn't present.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @retval VERR_PAGE_NOT_PRESENT if the page at the virtual address isn't present.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @retval VERR_PGM_PHYS_PAGE_RESERVED it it's a valid page but has no physical backing.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @retval VERR_PGM_INVALID_GC_PHYSICAL_ADDRESS if it's not a valid physical address.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param pVCpu VMCPU handle.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param GCPhys The guest physical address of the page that should be mapped.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param ppv Where to store the address corresponding to GCPhys.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param pLock Where to store the lock information that PGMPhysReleasePageMappingLock needs.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @remark Avoid calling this API from within critical sections (other than
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * the PGM one) because of the deadlock risk.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @thread EMT
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsyncVMMDECL(int) PGMPhysGCPtr2CCPtr(PVMCPU pVCpu, RTGCPTR GCPtr, void **ppv, PPGMPAGEMAPLOCK pLock)
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync int rc = PGMPhysGCPtr2GCPhys(pVCpu, GCPtr, &GCPhys);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync rc = PGMPhysGCPhys2CCPtr(pVCpu->CTX_SUFF(pVM), GCPhys, ppv, pLock);
8b03ab0bcd5c238021bc8a43d887dd9d0870c0f5vboxsync * Requests the mapping of a guest page given by virtual address into the current context.
8b03ab0bcd5c238021bc8a43d887dd9d0870c0f5vboxsync * This API should only be used for very short term, as it will consume
8b03ab0bcd5c238021bc8a43d887dd9d0870c0f5vboxsync * scarse resources (R0 and GC) in the mapping cache. When you're done
8b03ab0bcd5c238021bc8a43d887dd9d0870c0f5vboxsync * with the page, call PGMPhysReleasePageMappingLock() ASAP to release it.
8b03ab0bcd5c238021bc8a43d887dd9d0870c0f5vboxsync * @returns VBox status code.
8b03ab0bcd5c238021bc8a43d887dd9d0870c0f5vboxsync * @retval VINF_SUCCESS on success.
8b03ab0bcd5c238021bc8a43d887dd9d0870c0f5vboxsync * @retval VERR_PAGE_TABLE_NOT_PRESENT if the page directory for the virtual address isn't present.
8b03ab0bcd5c238021bc8a43d887dd9d0870c0f5vboxsync * @retval VERR_PAGE_NOT_PRESENT if the page at the virtual address isn't present.
8b03ab0bcd5c238021bc8a43d887dd9d0870c0f5vboxsync * @retval VERR_PGM_PHYS_PAGE_RESERVED it it's a valid page but has no physical backing.
8b03ab0bcd5c238021bc8a43d887dd9d0870c0f5vboxsync * @retval VERR_PGM_INVALID_GC_PHYSICAL_ADDRESS if it's not a valid physical address.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param pVCpu VMCPU handle.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param GCPhys The guest physical address of the page that should be mapped.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param ppv Where to store the address corresponding to GCPhys.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param pLock Where to store the lock information that PGMPhysReleasePageMappingLock needs.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @remark Avoid calling this API from within critical sections (other than
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * the PGM one) because of the deadlock risk.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @thread EMT
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsyncVMMDECL(int) PGMPhysGCPtr2CCPtrReadOnly(PVMCPU pVCpu, RTGCPTR GCPtr, void const **ppv, PPGMPAGEMAPLOCK pLock)
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync int rc = PGMPhysGCPtr2GCPhys(pVCpu, GCPtr, &GCPhys);
223cf005b18af2c21352a70693ebaf0582f68ebcvboxsync rc = PGMPhysGCPhys2CCPtrReadOnly(pVCpu->CTX_SUFF(pVM), GCPhys, ppv, pLock);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Release the mapping of a guest page.
e85d76a7e5a047db3cdc8576ff5f412c7b73bbabvboxsync * This is the counter part of PGMPhysGCPhys2CCPtr, PGMPhysGCPhys2CCPtrReadOnly
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * PGMPhysGCPtr2CCPtr and PGMPhysGCPtr2CCPtrReadOnly.
e85d76a7e5a047db3cdc8576ff5f412c7b73bbabvboxsync * @param pVM The VM handle.
9b45880674da6f82ca27cc28b0272de3dd3cc7dfvboxsync * @param pLock The lock structure initialized by the mapping function.
61fa69e2bc9fc9e7490feed1c020273f3ddb238dvboxsyncVMMDECL(void) PGMPhysReleasePageMappingLock(PVM pVM, PPGMPAGEMAPLOCK pLock)
e85d76a7e5a047db3cdc8576ff5f412c7b73bbabvboxsync#if defined(IN_RC) || defined(VBOX_WITH_2X_4GB_ADDR_SPACE_IN_R0)
e85d76a7e5a047db3cdc8576ff5f412c7b73bbabvboxsync /* currently nothing to do here. */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync#else /* IN_RING3 */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync PPGMPAGE pPage = (PPGMPAGE)(pLock->uPageAndType & ~PGMPAGEMAPLOCK_TYPE_MASK);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync bool fWriteLock = (pLock->uPageAndType & PGMPAGEMAPLOCK_TYPE_MASK) == PGMPAGEMAPLOCK_TYPE_WRITE;
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync if (RT_LIKELY(cLocks > 0 && cLocks < PGM_PAGE_MAX_LOCKS))
61fa69e2bc9fc9e7490feed1c020273f3ddb238dvboxsync if (PGM_PAGE_GET_STATE(pPage) == PGM_PAGE_STATE_WRITE_MONITORED)
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync PGM_PAGE_SET_STATE(pPage, PGM_PAGE_STATE_ALLOCATED);
10e1bc06b2908a0af56d92ffdbadd25b36a5ef61vboxsync if (RT_LIKELY(cLocks > 0 && cLocks < PGM_PAGE_MAX_LOCKS))
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync#endif /* IN_RING3 */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Converts a GC physical address to a HC ring-3 pointer.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @returns VINF_SUCCESS on success.
3080f6c0871099df43a4e91b31894d9c2b1369a8vboxsync * @returns VERR_PGM_PHYS_PAGE_RESERVED it it's a valid GC physical
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * page but has no physical backing.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @returns VERR_PGM_INVALID_GC_PHYSICAL_ADDRESS if it's not a valid
8f7bc6ad2b7bbcb4b3b96248cd2478e45f2e3b88vboxsync * GC physical address.
3080f6c0871099df43a4e91b31894d9c2b1369a8vboxsync * @returns VERR_PGM_GCPHYS_RANGE_CROSSES_BOUNDARY if the range crosses
ec588a4ac8429a8b6c744544818b3ce3b2c75690vboxsync * a dynamic ram chunk boundary
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param pVM The VM handle.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param GCPhys The GC physical address to convert.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param cbRange Physical range
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param pR3Ptr Where to store the R3 pointer on success.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @deprecated Avoid when possible!
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsyncVMMDECL(int) PGMPhysGCPhys2R3Ptr(PVM pVM, RTGCPHYS GCPhys, RTUINT cbRange, PRTR3PTR pR3Ptr)
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync/** @todo this is kind of hacky and needs some more work. */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync VM_ASSERT_EMT(pVM); /* no longer safe for use outside the EMT thread! */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync Log(("PGMPhysGCPhys2R3Ptr(,%RGp,%#x,): dont use this API!\n", GCPhys, cbRange)); /** @todo eliminate this API! */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync#if defined(IN_RC) || defined(VBOX_WITH_2X_4GB_ADDR_SPACE_IN_R0)
7e960d3a0a8a3a84d7aba2cca45d72b1c31cc97bvboxsync int rc = pgmPhysGetPageAndRangeEx(&pVM->pgm.s, GCPhys, &pPage, &pRam);
b45d66c0e496e2fd861479202f3d43aad592bd14vboxsync rc = pgmPhysGCPhys2CCPtrInternal(pVM, pPage, GCPhys, (void **)pR3Ptr);
b1c3cdef473df2fbc621d5da81acc82dbfb8a11avboxsync * PGMPhysGCPhys2R3Ptr convenience for use with assertions.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @returns The R3Ptr, NIL_RTR3PTR on failure.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param pVM The VM handle.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param GCPhys The GC Physical addresss.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param cbRange Physical range.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @deprecated Avoid when possible.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsyncVMMDECL(RTR3PTR) PGMPhysGCPhys2R3PtrAssert(PVM pVM, RTGCPHYS GCPhys, RTUINT cbRange)
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync int rc = PGMPhysGCPhys2R3Ptr(pVM, GCPhys, cbRange, &R3Ptr);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync#endif /* VBOX_STRICT */
223cf005b18af2c21352a70693ebaf0582f68ebcvboxsync * Converts a guest pointer to a GC physical address.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * This uses the current CR3/CR0/CR4 of the guest.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @returns VBox status code.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param pVCpu The VMCPU Handle
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param GCPtr The guest pointer to convert.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param pGCPhys Where to store the GC physical address.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsyncVMMDECL(int) PGMPhysGCPtr2GCPhys(PVMCPU pVCpu, RTGCPTR GCPtr, PRTGCPHYS pGCPhys)
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync int rc = PGM_GST_PFN(GetPage,pVCpu)(pVCpu, (RTGCUINTPTR)GCPtr, NULL, pGCPhys);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Converts a guest pointer to a HC physical address.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * This uses the current CR3/CR0/CR4 of the guest.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @returns VBox status code.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param pVCpu The VMCPU Handle
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param GCPtr The guest pointer to convert.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param pHCPhys Where to store the HC physical address.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsyncVMMDECL(int) PGMPhysGCPtr2HCPhys(PVMCPU pVCpu, RTGCPTR GCPtr, PRTHCPHYS pHCPhys)
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync int rc = PGM_GST_PFN(GetPage,pVCpu)(pVCpu, (RTGCUINTPTR)GCPtr, NULL, &GCPhys);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync rc = PGMPhysGCPhys2HCPhys(pVM, GCPhys | ((RTGCUINTPTR)GCPtr & PAGE_OFFSET_MASK), pHCPhys);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Converts a guest pointer to a R3 pointer.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * This uses the current CR3/CR0/CR4 of the guest.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @returns VBox status code.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param pVCpu The VMCPU Handle
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param GCPtr The guest pointer to convert.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param pR3Ptr Where to store the R3 virtual address.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @deprecated Don't use this.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsyncVMMDECL(int) PGMPhysGCPtr2R3Ptr(PVMCPU pVCpu, RTGCPTR GCPtr, PRTR3PTR pR3Ptr)
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync VM_ASSERT_EMT(pVM); /* no longer safe for use outside the EMT thread! */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync int rc = PGM_GST_PFN(GetPage,pVCpu)(pVCpu, (RTGCUINTPTR)GCPtr, NULL, &GCPhys);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync rc = PGMPhysGCPhys2R3Ptr(pVM, GCPhys | ((RTGCUINTPTR)GCPtr & PAGE_OFFSET_MASK), 1 /* we always stay within one page */, pR3Ptr);
c33db29e7b41467a35675031f5f5233839909083vboxsync * Cache PGMPhys memory access
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param pVM VM Handle.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param pCache Cache structure pointer
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param GCPhys GC physical address
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param pbHC HC pointer corresponding to physical page
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @thread EMT.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsyncstatic void pgmPhysCacheAdd(PVM pVM, PGMPHYSCACHE *pCache, RTGCPHYS GCPhys, uint8_t *pbR3)
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync iCacheIndex = ((GCPhys >> PAGE_SHIFT) & PGM_MAX_PHYSCACHE_ENTRIES_MASK);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync#endif /* IN_RING3 */
3cac8f8c6923a3a89ecfccda5e89ad75f48658e0vboxsync * Deals with reading from a page with one or more ALL access handlers.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @returns VBox status code. Can be ignored in ring-3.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @retval VINF_SUCCESS.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @retval VERR_PGM_PHYS_WR_HIT_HANDLER in R0 and GC, NEVER in R3.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param pVM The VM handle.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param pPage The page descriptor.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param GCPhys The physical address to start reading at.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param pvBuf Where to put the bits we read.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param cb How much to read - less or equal to a page.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsyncstatic int pgmPhysReadHandler(PVM pVM, PPGMPAGE pPage, RTGCPHYS GCPhys, void *pvBuf, size_t cb)
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * The most frequent access here is MMIO and shadowed ROM.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * The current code ASSUMES all these access handlers covers full pages!
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Whatever we do we need the source page, map it first.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync int rc = pgmPhysGCPhys2CCPtrInternalReadOnly(pVM, pPage, GCPhys, &pvSrc);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync AssertLogRelMsgFailed(("pgmPhysGCPhys2CCPtrInternalReadOnly failed on %RGp / %R[pgmpage] -> %Rrc\n",
5db1d52ffbcaa46c3d944c6c2d9c552306817d9avboxsync * Deal with any physical handlers.
3080f6c0871099df43a4e91b31894d9c2b1369a8vboxsync if (PGM_PAGE_GET_HNDL_PHYS_STATE(pPage) == PGM_PAGE_HNDL_PHYS_STATE_ALL)
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync pPhys = (PPGMPHYSHANDLER)RTAvlroGCPhysRangeGet(&pVM->pgm.s.CTX_SUFF(pTrees)->PhysHandlers, GCPhys);
8f7bc6ad2b7bbcb4b3b96248cd2478e45f2e3b88vboxsync AssertReleaseMsg(pPhys, ("GCPhys=%RGp cb=%#x\n", GCPhys, cb));
3080f6c0871099df43a4e91b31894d9c2b1369a8vboxsync Assert(GCPhys >= pPhys->Core.Key && GCPhys <= pPhys->Core.KeyLast);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync Assert((pPhys->Core.KeyLast & PAGE_OFFSET_MASK) == PAGE_OFFSET_MASK);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync PFNPGMR3PHYSHANDLER pfnHandler = pPhys->CTX_SUFF(pfnHandler);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync Log5(("pgmPhysReadHandler: GCPhys=%RGp cb=%#x pPage=%R[pgmpage] phys %s\n", GCPhys, cb, pPage, R3STRING(pPhys->pszDesc) ));
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /* Release the PGM lock as MMIO handlers take the IOM lock. (deadlock prevention) */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync rc = pfnHandler(pVM, GCPhys, (void *)pvSrc, pvBuf, cb, PGMACCESSTYPE_READ, pvUser);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync pPhys = (PPGMPHYSHANDLER)RTAvlroGCPhysRangeGet(&pVM->pgm.s.CTX_SUFF(pTrees)->PhysHandlers, GCPhys);
ec588a4ac8429a8b6c744544818b3ce3b2c75690vboxsync AssertLogRelMsg(rc == VINF_SUCCESS || rc == VINF_PGM_HANDLER_DO_DEFAULT, ("rc=%Rrc GCPhys=%RGp\n", rc, GCPhys));
75fca099c974cbbd48f132af1378c60232614760vboxsync /* In R0 and RC the callbacks cannot handle this context, so we'll fail. */
75fca099c974cbbd48f132af1378c60232614760vboxsync //AssertReleaseMsgFailed(("Wrong API! GCPhys=%RGp cb=%#x\n", GCPhys, cb));
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Deal with any virtual handlers.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync if (PGM_PAGE_GET_HNDL_VIRT_STATE(pPage) == PGM_PAGE_HNDL_VIRT_STATE_ALL)
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync int rc2 = pgmHandlerVirtualFindByPhysAddr(pVM, GCPhys, &pVirt, &iPage);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync AssertReleaseMsg(RT_SUCCESS(rc2), ("GCPhys=%RGp cb=%#x rc2=%Rrc\n", GCPhys, cb, rc2));
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync Assert((pVirt->Core.KeyLast & PAGE_OFFSET_MASK) == PAGE_OFFSET_MASK);
3cac8f8c6923a3a89ecfccda5e89ad75f48658e0vboxsync Assert(GCPhys >= pVirt->aPhysToVirt[iPage].Core.Key && GCPhys <= pVirt->aPhysToVirt[iPage].Core.KeyLast);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync Log5(("pgmPhysReadHandler: GCPhys=%RGp cb=%#x pPage=%R[pgmpage] virt %s\n", GCPhys, cb, pPage, R3STRING(pVirt->pszDesc) ));
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync Log(("pgmPhysReadHandler: GCPhys=%RGp cb=%#x pPage=%R[pgmpage] phys/virt %s/%s\n", GCPhys, cb, pPage, R3STRING(pVirt->pszDesc), R3STRING(pPhys->pszDesc) ));
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync RTGCUINTPTR GCPtr = ((RTGCUINTPTR)pVirt->Core.Key & PAGE_BASE_GC_MASK)
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync rc2 = pVirt->CTX_SUFF(pfnHandler)(pVM, GCPtr, (void *)pvSrc, pvBuf, cb, PGMACCESSTYPE_READ, /*pVirt->CTX_SUFF(pvUser)*/ NULL);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync AssertLogRelMsg(rc2 == VINF_SUCCESS || rc2 == VINF_PGM_HANDLER_DO_DEFAULT, ("rc=%Rrc GCPhys=%RGp pPage=%R[pgmpage] %s\n", rc2, GCPhys, pPage, pVirt->pszDesc));
a27fbcbb29ffc2196c2ebd0f2dad92f40c7ec65dvboxsync Log5(("pgmPhysReadHandler: GCPhys=%RGp cb=%#x pPage=%R[pgmpage] virt %s [no handler]\n", GCPhys, cb, pPage, R3STRING(pVirt->pszDesc) ));
10e1bc06b2908a0af56d92ffdbadd25b36a5ef61vboxsync /* In R0 and RC the callbacks cannot handle this context, so we'll fail. */
315f443a509c31db47b8f5cb94d26e54c3d5c497vboxsync //AssertReleaseMsgFailed(("Wrong API! GCPhys=%RGp cb=%#x\n", GCPhys, cb));
3080f6c0871099df43a4e91b31894d9c2b1369a8vboxsync * Take the default action.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Read physical memory.
9b45880674da6f82ca27cc28b0272de3dd3cc7dfvboxsync * This API respects access handlers and MMIO. Use PGMPhysSimpleReadGCPhys() if you
61fa69e2bc9fc9e7490feed1c020273f3ddb238dvboxsync * want to ignore those.
61fa69e2bc9fc9e7490feed1c020273f3ddb238dvboxsync * @returns VBox status code. Can be ignored in ring-3.
ec588a4ac8429a8b6c744544818b3ce3b2c75690vboxsync * @retval VINF_SUCCESS.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @retval VERR_PGM_PHYS_WR_HIT_HANDLER in R0 and GC, NEVER in R3.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param pVM VM Handle.
a3db4ff1e0aa7f94c9176ef16264df572eec0aebvboxsync * @param GCPhys Physical address start reading from.
75fca099c974cbbd48f132af1378c60232614760vboxsync * @param pvBuf Where to put the read bits.
75fca099c974cbbd48f132af1378c60232614760vboxsync * @param cbRead How many bytes to read.
57f41f24b7a290eba73c63449f44017d7917561dvboxsyncVMMDECL(int) PGMPhysRead(PVM pVM, RTGCPHYS GCPhys, void *pvBuf, size_t cbRead)
a3db4ff1e0aa7f94c9176ef16264df572eec0aebvboxsync AssertMsgReturn(cbRead > 0, ("don't even think about reading zero bytes!\n"), VINF_SUCCESS);
a3db4ff1e0aa7f94c9176ef16264df572eec0aebvboxsync LogFlow(("PGMPhysRead: %RGp %d\n", GCPhys, cbRead));
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync STAM_COUNTER_INC(&pVM->pgm.s.CTX_MID_Z(Stat,PhysRead));
3080f6c0871099df43a4e91b31894d9c2b1369a8vboxsync STAM_COUNTER_ADD(&pVM->pgm.s.CTX_MID_Z(Stat,PhysReadBytes), cbRead);
e16fc293d8bdb6174849b7b4c6f7d9ef5f03ea83vboxsync * Copy loop on ram ranges.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync PPGMRAMRANGE pRam = pVM->pgm.s.CTX_SUFF(pRamRanges);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /* Find range. */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /* Inside range or not? */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Must work our way thru this page by page.
6b022885f2cb6a55167609edecd89570cd80001dvboxsync * Any ALL access handlers?
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync if (RT_UNLIKELY(PGM_PAGE_HAS_ACTIVE_ALL_HANDLERS(pPage)))
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync int rc = pgmPhysReadHandler(pVM, pPage, pRam->GCPhys + off, pvBuf, cb);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Get the pointer to the page.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync const void *pvSrc;
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync int rc = pgmPhysGCPhys2CCPtrInternalReadOnly(pVM, pPage, pRam->GCPhys + off, &pvSrc);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync AssertLogRelMsgFailed(("pgmPhysGCPhys2CCPtrInternalReadOnly failed on %RGp / %R[pgmpage] -> %Rrc\n",
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /* next page */
a27fbcbb29ffc2196c2ebd0f2dad92f40c7ec65dvboxsync } /* walk pages in ram range. */
3080f6c0871099df43a4e91b31894d9c2b1369a8vboxsync LogFlow(("PGMPhysRead: Unassigned %RGp size=%u\n", GCPhys, cbRead));
7cced997f7e362bb903898de921271b5e1011e3dvboxsync * Unassigned address space.
75fca099c974cbbd48f132af1378c60232614760vboxsync } /* Ram range walk */
3080f6c0871099df43a4e91b31894d9c2b1369a8vboxsync * Deals with writing to a page with one or more WRITE or ALL access handlers.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @returns VBox status code. Can be ignored in ring-3.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @retval VINF_SUCCESS.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @retval VERR_PGM_PHYS_WR_HIT_HANDLER in R0 and GC, NEVER in R3.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param pVM The VM handle.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param pPage The page descriptor.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param GCPhys The physical address to start writing at.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param pvBuf What to write.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param cbWrite How much to write - less or equal to a page.
6b022885f2cb6a55167609edecd89570cd80001dvboxsyncstatic int pgmPhysWriteHandler(PVM pVM, PPGMPAGE pPage, RTGCPHYS GCPhys, void const *pvBuf, size_t cbWrite)
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Give priority to physical handlers (like #PF does).
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Hope for a lonely physical handler first that covers the whole
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * write area. This should be a pretty frequent case with MMIO and
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * the heavy usage of full page handlers in the page pool.
09d4e754a010196fe0d9d972b6ccc005ecb8b116vboxsync || PGM_PAGE_IS_MMIO(pPage) /* screw virtual handlers on MMIO pages */)
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync PPGMPHYSHANDLER pCur = (PPGMPHYSHANDLER)RTAvlroGCPhysRangeGet(&pVM->pgm.s.CTX_SUFF(pTrees)->PhysHandlers, GCPhys);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync Assert(GCPhys >= pCur->Core.Key && GCPhys <= pCur->Core.KeyLast);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /* In R0 and RC the callbacks cannot handle this context, so we'll fail. */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync //AssertReleaseMsgFailed(("Wrong API! GCPhys=%RGp cbRange=%#x\n", GCPhys, cbRange));
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync#else /* IN_RING3 */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync Log5(("pgmPhysWriteHandler: GCPhys=%RGp cbRange=%#x pPage=%R[pgmpage] phys %s\n", GCPhys, cbRange, pPage, R3STRING(pCur->pszDesc) ));
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync rc = pgmPhysGCPhys2CCPtrInternal(pVM, pPage, GCPhys, &pvDst);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync PFNPGMR3PHYSHANDLER pfnHandler = pCur->CTX_SUFF(pfnHandler);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /* Release the PGM lock as MMIO handlers take the IOM lock. (deadlock prevention) */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync rc = pfnHandler(pVM, GCPhys, pvDst, (void *)pvBuf, cbRange, PGMACCESSTYPE_WRITE, pvUser);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync pCur = (PPGMPHYSHANDLER)RTAvlroGCPhysRangeGet(&pVM->pgm.s.CTX_SUFF(pTrees)->PhysHandlers, GCPhys);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync AssertLogRelMsg(rc == VINF_SUCCESS || rc == VINF_PGM_HANDLER_DO_DEFAULT, ("rc=%Rrc GCPhys=%RGp pPage=%R[pgmpage] %s\n", rc, GCPhys, pPage, (pCur) ? pCur->pszDesc : ""));
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync AssertLogRelMsgFailedReturn(("pgmPhysGCPhys2CCPtrInternal failed on %RGp / %R[pgmpage] -> %Rrc\n",
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /* more fun to be had below */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync#endif /* IN_RING3 */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /* else: the handler is somewhere else in the page, deal with it below. */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync Assert(!PGM_PAGE_IS_MMIO(pPage)); /* MMIO handlers are all PAGE_SIZEed! */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * A virtual handler without any interfering physical handlers.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Hopefully it'll conver the whole write.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync else if (!PGM_PAGE_HAS_ACTIVE_PHYSICAL_HANDLERS(pPage))
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync rc = pgmHandlerVirtualFindByPhysAddr(pVM, GCPhys, &pCur, &iPage);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync size_t cbRange = (PAGE_OFFSET_MASK & pCur->Core.KeyLast) - (PAGE_OFFSET_MASK & GCPhys) + 1;
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /* In R0 and RC the callbacks cannot handle this context, so we'll fail. */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync //AssertReleaseMsgFailed(("Wrong API! GCPhys=%RGp cbRange=%#x\n", GCPhys, cbRange));
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync#else /* IN_RING3 */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync Log5(("pgmPhysWriteHandler: GCPhys=%RGp cbRange=%#x pPage=%R[pgmpage] virt %s\n", GCPhys, cbRange, pPage, R3STRING(pCur->pszDesc) ));
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync rc = pgmPhysGCPhys2CCPtrInternal(pVM, pPage, GCPhys, &pvDst);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync RTGCUINTPTR GCPtr = ((RTGCUINTPTR)pCur->Core.Key & PAGE_BASE_GC_MASK)
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync rc = pCur->CTX_SUFF(pfnHandler)(pVM, GCPtr, pvDst, (void *)pvBuf, cbRange, PGMACCESSTYPE_WRITE, /*pCur->CTX_SUFF(pvUser)*/ NULL);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync AssertLogRelMsg(rc == VINF_SUCCESS, ("rc=%Rrc GCPhys=%RGp pPage=%R[pgmpage] %s\n", rc, GCPhys, pPage, pCur->pszDesc));
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync AssertLogRelMsgFailedReturn(("pgmPhysGCPhys2CCPtrInternal failed on %RGp / %R[pgmpage] -> %Rrc\n",
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /* more fun to be had below */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /* else: the handler is somewhere else in the page, deal with it below. */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Deal with all the odd ends.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /* We need a writable destination page. */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync rc = pgmPhysGCPhys2CCPtrInternal(pVM, pPage, GCPhys, &pvDst);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync ("pgmPhysGCPhys2CCPtrInternal failed on %RGp / %R[pgmpage] -> %Rrc\n",
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /* The loop state (big + ugly). */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync unsigned iVirtPage = 0;
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync bool fMoreVirt = PGM_PAGE_HAS_ACTIVE_VIRTUAL_HANDLERS(pPage);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync bool fMorePhys = PGM_PAGE_HAS_ACTIVE_PHYSICAL_HANDLERS(pPage);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /* The loop. */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Find the closest handler at or above GCPhys.
3cac8f8c6923a3a89ecfccda5e89ad75f48658e0vboxsync rc = pgmHandlerVirtualFindByPhysAddr(pVM, GCPhys, &pVirt, &iVirtPage);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync offVirtLast = (pVirt->aPhysToVirt[iVirtPage].Core.KeyLast & PAGE_OFFSET_MASK) - (GCPhys & PAGE_OFFSET_MASK);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync pVirtPhys = (PPGMPHYS2VIRTHANDLER)RTAvlroGCPhysGetBestFit(&pVM->pgm.s.CTX_SUFF(pTrees)->PhysToVirtHandlers,
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync && (pVirtPhys->Core.Key >> PAGE_SHIFT) == (GCPhys >> PAGE_SHIFT))
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /* ASSUME that pVirtPhys only covers one page. */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync Assert((pVirtPhys->Core.Key >> PAGE_SHIFT) == (pVirtPhys->Core.KeyLast >> PAGE_SHIFT));
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync pVirt = (PPGMVIRTHANDLER)((uintptr_t)pVirtPhys + pVirtPhys->offVirtHandler);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync iVirtPage = pVirtPhys - &pVirt->aPhysToVirt[0]; Assert(iVirtPage == 0);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync offVirt = (pVirtPhys->Core.Key & PAGE_OFFSET_MASK) - (GCPhys & PAGE_OFFSET_MASK);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync offVirtLast = (pVirtPhys->Core.KeyLast & PAGE_OFFSET_MASK) - (GCPhys & PAGE_OFFSET_MASK);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync pPhys = (PPGMPHYSHANDLER)RTAvlroGCPhysRangeGet(&pVM->pgm.s.CTX_SUFF(pTrees)->PhysHandlers, GCPhys);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync offPhysLast = pPhys->Core.KeyLast - GCPhys; /* ASSUMES < 4GB handlers... */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync pPhys = (PPGMPHYSHANDLER)RTAvlroGCPhysGetBestFit(&pVM->pgm.s.CTX_SUFF(pTrees)->PhysHandlers,
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync offPhysLast = pPhys->Core.KeyLast - GCPhys; /* ASSUMES < 4GB handlers... */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Handle access to space without handlers (that's easy).
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync Log5(("pgmPhysWriteHandler: GCPhys=%RGp cbRange=%#x pPage=%R[pgmpage] miss\n", GCPhys, cbRange, pPage));
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Physical handler.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync PFNPGMR3PHYSHANDLER pfnHandler = pPhys->CTX_SUFF(pfnHandler);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync Log5(("pgmPhysWriteHandler: GCPhys=%RGp cbRange=%#x pPage=%R[pgmpage] phys %s\n", GCPhys, cbRange, pPage, R3STRING(pPhys->pszDesc) ));
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /* Release the PGM lock as MMIO handlers take the IOM lock. (deadlock prevention) */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync rc = pfnHandler(pVM, GCPhys, pvDst, (void *)pvBuf, cbRange, PGMACCESSTYPE_WRITE, pvUser);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync pPhys = (PPGMPHYSHANDLER)RTAvlroGCPhysRangeGet(&pVM->pgm.s.CTX_SUFF(pTrees)->PhysHandlers, GCPhys);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync AssertLogRelMsg(rc == VINF_SUCCESS || rc == VINF_PGM_HANDLER_DO_DEFAULT, ("rc=%Rrc GCPhys=%RGp pPage=%R[pgmpage] %s\n", rc, GCPhys, pPage, (pPhys) ? pPhys->pszDesc : ""));
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /* In R0 and RC the callbacks cannot handle this context, so we'll fail. */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync //AssertReleaseMsgFailed(("Wrong API! GCPhys=%RGp cbRange=%#x\n", GCPhys, cbRange));
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Virtual handler.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync Log5(("pgmPhysWriteHandler: GCPhys=%RGp cbRange=%#x pPage=%R[pgmpage] phys %s\n", GCPhys, cbRange, pPage, R3STRING(pVirt->pszDesc) ));
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync RTGCUINTPTR GCPtr = ((RTGCUINTPTR)pVirt->Core.Key & PAGE_BASE_GC_MASK)
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync rc = pVirt->CTX_SUFF(pfnHandler)(pVM, GCPtr, pvDst, (void *)pvBuf, cbRange, PGMACCESSTYPE_WRITE, /*pCur->CTX_SUFF(pvUser)*/ NULL);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync AssertLogRelMsg(rc == VINF_SUCCESS || rc == VINF_PGM_HANDLER_DO_DEFAULT, ("rc=%Rrc GCPhys=%RGp pPage=%R[pgmpage] %s\n", rc, GCPhys, pPage, pVirt->pszDesc));
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /* In R0 and RC the callbacks cannot handle this context, so we'll fail. */
9c425bdea5f0991df62922b1584b805a86f2f898vboxsync //AssertReleaseMsgFailed(("Wrong API! GCPhys=%RGp cbRange=%#x\n", GCPhys, cbRange));
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Both... give the physical one priority.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync Log(("pgmPhysWriteHandler: overlapping phys and virt handlers at %RGp %R[pgmpage]; cbRange=%#x\n", GCPhys, pPage, cbRange));
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync Log5(("pgmPhysWriteHandler: GCPhys=%RGp cbRange=%#x pPage=%R[pgmpage] phys/virt %s/%s\n", GCPhys, cbRange, pPage, R3STRING(pPhys->pszDesc), R3STRING(pVirt->pszDesc) ));
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync PFNPGMR3PHYSHANDLER pfnHandler = pPhys->CTX_SUFF(pfnHandler);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /* Release the PGM lock as MMIO handlers take the IOM lock. (deadlock prevention) */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync rc = pfnHandler(pVM, GCPhys, pvDst, (void *)pvBuf, cbRange, PGMACCESSTYPE_WRITE, pvUser);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync pPhys = (PPGMPHYSHANDLER)RTAvlroGCPhysRangeGet(&pVM->pgm.s.CTX_SUFF(pTrees)->PhysHandlers, GCPhys);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync AssertLogRelMsg(rc == VINF_SUCCESS || rc == VINF_PGM_HANDLER_DO_DEFAULT, ("rc=%Rrc GCPhys=%RGp pPage=%R[pgmpage] %s\n", rc, GCPhys, pPage, (pPhys) ? pPhys->pszDesc : ""));
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync RTGCUINTPTR GCPtr = ((RTGCUINTPTR)pVirt->Core.Key & PAGE_BASE_GC_MASK)
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync int rc2 = pVirt->CTX_SUFF(pfnHandler)(pVM, GCPtr, pvDst, (void *)pvBuf, cbRange, PGMACCESSTYPE_WRITE, /*pCur->CTX_SUFF(pvUser)*/ NULL);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync if (rc2 == VINF_SUCCESS && rc == VINF_PGM_HANDLER_DO_DEFAULT)
18db01bbe01d709ed64ef78717e98b94b7fee056vboxsync AssertLogRelMsg(rc2 == VINF_SUCCESS || rc2 == VINF_PGM_HANDLER_DO_DEFAULT, ("rc=%Rrc GCPhys=%RGp pPage=%R[pgmpage] %s\n", rc, GCPhys, pPage, pVirt->pszDesc));
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /* In R0 and RC the callbacks cannot handle this context, so we'll fail. */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync //AssertReleaseMsgFailed(("Wrong API! GCPhys=%RGp cbRange=%#x\n", GCPhys, cbRange));
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Advance if we've got more stuff to do.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Write to physical memory.
06de36c1229f14000638fa27993b13c9133e85f5vboxsync * This API respects access handlers and MMIO. Use PGMPhysSimpleReadGCPhys() if you
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * want to ignore those.
5dda7f07dab8a954e6c4cf2378b15f921e60d9aavboxsync * @returns VBox status code. Can be ignored in ring-3.
5dda7f07dab8a954e6c4cf2378b15f921e60d9aavboxsync * @retval VINF_SUCCESS.
5dda7f07dab8a954e6c4cf2378b15f921e60d9aavboxsync * @retval VERR_PGM_PHYS_WR_HIT_HANDLER in R0 and GC, NEVER in R3.
5dda7f07dab8a954e6c4cf2378b15f921e60d9aavboxsync * @param pVM VM Handle.
5dda7f07dab8a954e6c4cf2378b15f921e60d9aavboxsync * @param GCPhys Physical address to write to.
5dda7f07dab8a954e6c4cf2378b15f921e60d9aavboxsync * @param pvBuf What to write.
5dda7f07dab8a954e6c4cf2378b15f921e60d9aavboxsync * @param cbWrite How many bytes to write.
5dda7f07dab8a954e6c4cf2378b15f921e60d9aavboxsyncVMMDECL(int) PGMPhysWrite(PVM pVM, RTGCPHYS GCPhys, const void *pvBuf, size_t cbWrite)
5dda7f07dab8a954e6c4cf2378b15f921e60d9aavboxsync AssertMsg(!pVM->pgm.s.fNoMorePhysWrites, ("Calling PGMPhysWrite after pgmR3Save()!\n"));
5dda7f07dab8a954e6c4cf2378b15f921e60d9aavboxsync AssertMsgReturn(cbWrite > 0, ("don't even think about writing zero bytes!\n"), VINF_SUCCESS);
5dda7f07dab8a954e6c4cf2378b15f921e60d9aavboxsync LogFlow(("PGMPhysWrite: %RGp %d\n", GCPhys, cbWrite));
5dda7f07dab8a954e6c4cf2378b15f921e60d9aavboxsync STAM_COUNTER_INC(&pVM->pgm.s.CTX_MID_Z(Stat,PhysWrite));
5dda7f07dab8a954e6c4cf2378b15f921e60d9aavboxsync STAM_COUNTER_ADD(&pVM->pgm.s.CTX_MID_Z(Stat,PhysWriteBytes), cbWrite);
5dda7f07dab8a954e6c4cf2378b15f921e60d9aavboxsync * Copy loop on ram ranges.
5dda7f07dab8a954e6c4cf2378b15f921e60d9aavboxsync PPGMRAMRANGE pRam = pVM->pgm.s.CTX_SUFF(pRamRanges);
5dda7f07dab8a954e6c4cf2378b15f921e60d9aavboxsync /* Find range. */
06de36c1229f14000638fa27993b13c9133e85f5vboxsync /* Inside range or not? */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Must work our way thru this page by page.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Any active WRITE or ALL access handlers?
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync int rc = pgmPhysWriteHandler(pVM, pPage, pRam->GCPhys + off, pvBuf, cb);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Get the pointer to the page.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync int rc = pgmPhysGCPhys2CCPtrInternal(pVM, pPage, pRam->GCPhys + off, &pvDst);
c657bea826c7455c93bd45eaebab63a4c7742c42vboxsync AssertLogRelMsgFailed(("pgmPhysGCPhys2CCPtrInternal failed on %RGp / %R[pgmpage] -> %Rrc\n",
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /* next page */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync } /* walk pages in ram range */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Unassigned address space, skip it.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync } /* Ram range walk */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Read from guest physical memory by GC physical address, bypassing
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * MMIO and access handlers.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @returns VBox status.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param pVM VM handle.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param pvDst The destination address.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param GCPhysSrc The source address (GC physical address).
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param cb The number of bytes to read.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsyncVMMDECL(int) PGMPhysSimpleReadGCPhys(PVM pVM, void *pvDst, RTGCPHYS GCPhysSrc, size_t cb)
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Treat the first page as a special case.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /* map the 1st page */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync void const *pvSrc;
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync int rc = PGMPhysGCPhys2CCPtrReadOnly(pVM, GCPhysSrc, &pvSrc, &Lock);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /* optimize for the case where access is completely within the first page. */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync size_t cbPage = PAGE_SIZE - (GCPhysSrc & PAGE_OFFSET_MASK);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /* copy to the end of the page. */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Page by page.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /* map the page */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync rc = PGMPhysGCPhys2CCPtrReadOnly(pVM, GCPhysSrc, &pvSrc, &Lock);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /* last page? */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /* copy the entire page and advance */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /* won't ever get here. */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Write to guest physical memory referenced by GC pointer.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Write memory to GC physical address in guest physical memory.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * This will bypass MMIO and access handlers.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @returns VBox status.
6b022885f2cb6a55167609edecd89570cd80001dvboxsync * @param pVM VM handle.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param GCPhysDst The GC physical address of the destination.
8a132edc1577cbe2a19cd778c1b2bea6ae5e8515vboxsync * @param pvSrc The source buffer.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param cb The number of bytes to write.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsyncVMMDECL(int) PGMPhysSimpleWriteGCPhys(PVM pVM, RTGCPHYS GCPhysDst, const void *pvSrc, size_t cb)
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync LogFlow(("PGMPhysSimpleWriteGCPhys: %RGp %zu\n", GCPhysDst, cb));
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Treat the first page as a special case.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /* map the 1st page */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync int rc = PGMPhysGCPhys2CCPtr(pVM, GCPhysDst, &pvDst, &Lock);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /* optimize for the case where access is completely within the first page. */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync size_t cbPage = PAGE_SIZE - (GCPhysDst & PAGE_OFFSET_MASK);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /* copy to the end of the page. */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Page by page.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /* map the page */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync rc = PGMPhysGCPhys2CCPtr(pVM, GCPhysDst, &pvDst, &Lock);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /* last page? */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /* copy the entire page and advance */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /* won't ever get here. */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Read from guest physical memory referenced by GC pointer.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * This function uses the current CR3/CR0/CR4 of the guest and will
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * bypass access handlers and not set any accessed bits.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @returns VBox status.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param pVCpu The VMCPU handle.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param pvDst The destination address.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param GCPtrSrc The source address (GC pointer).
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param cb The number of bytes to read.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsyncVMMDECL(int) PGMPhysSimpleReadGCPtr(PVMCPU pVCpu, void *pvDst, RTGCPTR GCPtrSrc, size_t cb)
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Treat the first page as a special case.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync STAM_COUNTER_INC(&pVM->pgm.s.CTX_MID_Z(Stat,PhysSimpleRead));
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync STAM_COUNTER_ADD(&pVM->pgm.s.CTX_MID_Z(Stat,PhysSimpleReadBytes), cb);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /* Take the PGM lock here, because many called functions take the lock for a very short period. That's counter-productive
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * when many VCPUs are fighting for the lock.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /* map the 1st page */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync void const *pvSrc;
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync int rc = PGMPhysGCPtr2CCPtrReadOnly(pVCpu, GCPtrSrc, &pvSrc, &Lock);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /* optimize for the case where access is completely within the first page. */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync size_t cbPage = PAGE_SIZE - ((RTGCUINTPTR)GCPtrSrc & PAGE_OFFSET_MASK);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /* copy to the end of the page. */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync GCPtrSrc = (RTGCPTR)((RTGCUINTPTR)GCPtrSrc + cbPage);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Page by page.
3080f6c0871099df43a4e91b31894d9c2b1369a8vboxsync /* map the page */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync rc = PGMPhysGCPtr2CCPtrReadOnly(pVCpu, GCPtrSrc, &pvSrc, &Lock);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /* last page? */
8f7bc6ad2b7bbcb4b3b96248cd2478e45f2e3b88vboxsync /* copy the entire page and advance */
ec588a4ac8429a8b6c744544818b3ce3b2c75690vboxsync GCPtrSrc = (RTGCPTR)((RTGCUINTPTR)GCPtrSrc + PAGE_SIZE);
61fa69e2bc9fc9e7490feed1c020273f3ddb238dvboxsync /* won't ever get here. */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Write to guest physical memory referenced by GC pointer.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * This function uses the current CR3/CR0/CR4 of the guest and will
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * bypass access handlers and not set dirty or accessed bits.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @returns VBox status.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param pVCpu The VMCPU handle.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param GCPtrDst The destination address (GC pointer).
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param pvSrc The source address.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param cb The number of bytes to write.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsyncVMMDECL(int) PGMPhysSimpleWriteGCPtr(PVMCPU pVCpu, RTGCPTR GCPtrDst, const void *pvSrc, size_t cb)
223cf005b18af2c21352a70693ebaf0582f68ebcvboxsync * Treat the first page as a special case.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync STAM_COUNTER_INC(&pVM->pgm.s.CTX_MID_Z(Stat,PhysSimpleWrite));
3080f6c0871099df43a4e91b31894d9c2b1369a8vboxsync STAM_COUNTER_ADD(&pVM->pgm.s.CTX_MID_Z(Stat,PhysSimpleWriteBytes), cb);
3080f6c0871099df43a4e91b31894d9c2b1369a8vboxsync /* map the 1st page */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync int rc = PGMPhysGCPtr2CCPtr(pVCpu, GCPtrDst, &pvDst, &Lock);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /* optimize for the case where access is completely within the first page. */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync size_t cbPage = PAGE_SIZE - ((RTGCUINTPTR)GCPtrDst & PAGE_OFFSET_MASK);
3080f6c0871099df43a4e91b31894d9c2b1369a8vboxsync /* copy to the end of the page. */
3080f6c0871099df43a4e91b31894d9c2b1369a8vboxsync GCPtrDst = (RTGCPTR)((RTGCUINTPTR)GCPtrDst + cbPage);
9b45880674da6f82ca27cc28b0272de3dd3cc7dfvboxsync * Page by page.
61fa69e2bc9fc9e7490feed1c020273f3ddb238dvboxsync /* map the page */
ec588a4ac8429a8b6c744544818b3ce3b2c75690vboxsync rc = PGMPhysGCPtr2CCPtr(pVCpu, GCPtrDst, &pvDst, &Lock);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /* last page? */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /* copy the entire page and advance */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync GCPtrDst = (RTGCPTR)((RTGCUINTPTR)GCPtrDst + PAGE_SIZE);
aaeb2e2f6ed5b164f1dec9a16a7adeb84f64cf31vboxsync /* won't ever get here. */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Write to guest physical memory referenced by GC pointer and update the PTE.
50df3da42ff6589b0ecc4f50f2288811bc370186vboxsync * This function uses the current CR3/CR0/CR4 of the guest and will
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * bypass access handlers but will set any dirty and accessed bits in the PTE.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * If you don't want to set the dirty bit, use PGMPhysSimpleWriteGCPtr().
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @returns VBox status.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param pVCpu The VMCPU handle.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param GCPtrDst The destination address (GC pointer).
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param pvSrc The source address.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param cb The number of bytes to write.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsyncVMMDECL(int) PGMPhysSimpleDirtyWriteGCPtr(PVMCPU pVCpu, RTGCPTR GCPtrDst, const void *pvSrc, size_t cb)
9c425bdea5f0991df62922b1584b805a86f2f898vboxsync * Treat the first page as a special case.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Btw. this is the same code as in PGMPhyssimpleWriteGCPtr excep for the PGMGstModifyPage.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /* map the 1st page */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync int rc = PGMPhysGCPtr2CCPtr(pVCpu, GCPtrDst, &pvDst, &Lock);
467e62e1aa999ec951e820d74498ef79dd1bedbdvboxsync /* optimize for the case where access is completely within the first page. */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync size_t cbPage = PAGE_SIZE - ((RTGCUINTPTR)GCPtrDst & PAGE_OFFSET_MASK);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync rc = PGMGstModifyPage(pVCpu, GCPtrDst, 1, X86_PTE_A | X86_PTE_D, ~(uint64_t)(X86_PTE_A | X86_PTE_D)); AssertRC(rc);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /* copy to the end of the page. */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync rc = PGMGstModifyPage(pVCpu, GCPtrDst, 1, X86_PTE_A | X86_PTE_D, ~(uint64_t)(X86_PTE_A | X86_PTE_D)); AssertRC(rc);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync GCPtrDst = (RTGCPTR)((RTGCUINTPTR)GCPtrDst + cbPage);
aaeb2e2f6ed5b164f1dec9a16a7adeb84f64cf31vboxsync * Page by page.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /* map the page */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync rc = PGMPhysGCPtr2CCPtr(pVCpu, GCPtrDst, &pvDst, &Lock);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /* last page? */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync rc = PGMGstModifyPage(pVCpu, GCPtrDst, 1, X86_PTE_A | X86_PTE_D, ~(uint64_t)(X86_PTE_A | X86_PTE_D)); AssertRC(rc);
8c9d2065ca6efecd5661174e382314868c0d4b94vboxsync /* copy the entire page and advance */
8c9d2065ca6efecd5661174e382314868c0d4b94vboxsync rc = PGMGstModifyPage(pVCpu, GCPtrDst, 1, X86_PTE_A | X86_PTE_D, ~(uint64_t)(X86_PTE_A | X86_PTE_D)); AssertRC(rc);
8c9d2065ca6efecd5661174e382314868c0d4b94vboxsync GCPtrDst = (RTGCPTR)((RTGCUINTPTR)GCPtrDst + PAGE_SIZE);
8c9d2065ca6efecd5661174e382314868c0d4b94vboxsync /* won't ever get here. */
8c9d2065ca6efecd5661174e382314868c0d4b94vboxsync * Read from guest physical memory referenced by GC pointer.
8c9d2065ca6efecd5661174e382314868c0d4b94vboxsync * This function uses the current CR3/CR0/CR4 of the guest and will
8c9d2065ca6efecd5661174e382314868c0d4b94vboxsync * respect access handlers and set accessed bits.
8c9d2065ca6efecd5661174e382314868c0d4b94vboxsync * @returns VBox status.
467e62e1aa999ec951e820d74498ef79dd1bedbdvboxsync * @param pVCpu The VMCPU handle.
8c9d2065ca6efecd5661174e382314868c0d4b94vboxsync * @param pvDst The destination address.
8c9d2065ca6efecd5661174e382314868c0d4b94vboxsync * @param GCPtrSrc The source address (GC pointer).
8c9d2065ca6efecd5661174e382314868c0d4b94vboxsync * @param cb The number of bytes to read.
8c9d2065ca6efecd5661174e382314868c0d4b94vboxsync * @thread The vCPU EMT.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsyncVMMDECL(int) PGMPhysReadGCPtr(PVMCPU pVCpu, void *pvDst, RTGCPTR GCPtrSrc, size_t cb)
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Anything to do?
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync LogFlow(("PGMPhysReadGCPtr: %RGv %zu\n", GCPtrSrc, cb));
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Optimize reads within a single page.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync if (((RTGCUINTPTR)GCPtrSrc & PAGE_OFFSET_MASK) + cb <= PAGE_SIZE)
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /* Convert virtual to physical address + flags */
aaeb2e2f6ed5b164f1dec9a16a7adeb84f64cf31vboxsync rc = PGM_GST_PFN(GetPage,pVCpu)(pVCpu, (RTGCUINTPTR)GCPtrSrc, &fFlags, &GCPhys);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync AssertMsgRCReturn(rc, ("GetPage failed with %Rrc for %RGv\n", rc, GCPtrSrc), rc);
50df3da42ff6589b0ecc4f50f2288811bc370186vboxsync GCPhys |= (RTGCUINTPTR)GCPtrSrc & PAGE_OFFSET_MASK;
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /* mark the guest page as accessed. */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync rc = PGMGstModifyPage(pVCpu, GCPtrSrc, 1, X86_PTE_A, ~(uint64_t)(X86_PTE_A));
223cf005b18af2c21352a70693ebaf0582f68ebcvboxsync * Page by page.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /* Convert virtual to physical address + flags */
50df3da42ff6589b0ecc4f50f2288811bc370186vboxsync rc = PGM_GST_PFN(GetPage,pVCpu)(pVCpu, (RTGCUINTPTR)GCPtrSrc, &fFlags, &GCPhys);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync AssertMsgRCReturn(rc, ("GetPage failed with %Rrc for %RGv\n", rc, GCPtrSrc), rc);
aaeb2e2f6ed5b164f1dec9a16a7adeb84f64cf31vboxsync GCPhys |= (RTGCUINTPTR)GCPtrSrc & PAGE_OFFSET_MASK;
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /* mark the guest page as accessed. */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync rc = PGMGstModifyPage(pVCpu, GCPtrSrc, 1, X86_PTE_A, ~(uint64_t)(X86_PTE_A));
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync size_t cbRead = PAGE_SIZE - ((RTGCUINTPTR)GCPtrSrc & PAGE_OFFSET_MASK);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Write to guest physical memory referenced by GC pointer.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * This function uses the current CR3/CR0/CR4 of the guest and will
3cac8f8c6923a3a89ecfccda5e89ad75f48658e0vboxsync * respect access handlers and set dirty and accessed bits.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @returns VBox status.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @retval VINF_SUCCESS.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @retval VERR_PGM_PHYS_WR_HIT_HANDLER in R0 and GC, NEVER in R3.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param pVCpu The VMCPU handle.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param GCPtrDst The destination address (GC pointer).
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param pvSrc The source address.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param cb The number of bytes to write.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsyncVMMDECL(int) PGMPhysWriteGCPtr(PVMCPU pVCpu, RTGCPTR GCPtrDst, const void *pvSrc, size_t cb)
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Anything to do?
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync LogFlow(("PGMPhysWriteGCPtr: %RGv %zu\n", GCPtrDst, cb));
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Optimize writes within a single page.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync if (((RTGCUINTPTR)GCPtrDst & PAGE_OFFSET_MASK) + cb <= PAGE_SIZE)
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /* Convert virtual to physical address + flags */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync rc = PGM_GST_PFN(GetPage,pVCpu)(pVCpu, (RTGCUINTPTR)GCPtrDst, &fFlags, &GCPhys);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync AssertMsgRCReturn(rc, ("GetPage failed with %Rrc for %RGv\n", rc, GCPtrDst), rc);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync GCPhys |= (RTGCUINTPTR)GCPtrDst & PAGE_OFFSET_MASK;
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /* Mention when we ignore X86_PTE_RW... */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync Log(("PGMPhysGCPtr2GCPhys: Writing to RO page %RGv %#x\n", GCPtrDst, cb));
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /* Mark the guest page as accessed and dirty if necessary. */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync if ((fFlags & (X86_PTE_A | X86_PTE_D)) != (X86_PTE_A | X86_PTE_D))
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync rc = PGMGstModifyPage(pVCpu, GCPtrDst, 1, X86_PTE_A | X86_PTE_D, ~(uint64_t)(X86_PTE_A | X86_PTE_D));
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Page by page.
9c425bdea5f0991df62922b1584b805a86f2f898vboxsync /* Convert virtual to physical address + flags */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync rc = PGM_GST_PFN(GetPage,pVCpu)(pVCpu, (RTGCUINTPTR)GCPtrDst, &fFlags, &GCPhys);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync AssertMsgRCReturn(rc, ("GetPage failed with %Rrc for %RGv\n", rc, GCPtrDst), rc);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync GCPhys |= (RTGCUINTPTR)GCPtrDst & PAGE_OFFSET_MASK;
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /* Mention when we ignore X86_PTE_RW... */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync Log(("PGMPhysGCPtr2GCPhys: Writing to RO page %RGv %#x\n", GCPtrDst, cb));
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /* Mark the guest page as accessed and dirty if necessary. */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync if ((fFlags & (X86_PTE_A | X86_PTE_D)) != (X86_PTE_A | X86_PTE_D))
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync rc = PGMGstModifyPage(pVCpu, GCPtrDst, 1, X86_PTE_A | X86_PTE_D, ~(uint64_t)(X86_PTE_A | X86_PTE_D));
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync size_t cbWrite = PAGE_SIZE - ((RTGCUINTPTR)GCPtrDst & PAGE_OFFSET_MASK);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Performs a read of guest virtual memory for instruction emulation.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * This will check permissions, raise exceptions and update the access bits.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * The current implementation will bypass all access handlers. It may later be
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * changed to at least respect MMIO.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @returns VBox status code suitable to scheduling.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @retval VINF_SUCCESS if the read was performed successfully.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @retval VINF_EM_RAW_GUEST_TRAP if an exception was raised but not dispatched yet.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @retval VINF_TRPM_XCPT_DISPATCHED if an exception was raised and dispatched.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param pVCpu The VMCPU handle.
aaeb2e2f6ed5b164f1dec9a16a7adeb84f64cf31vboxsync * @param pCtxCore The context core.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param pvDst Where to put the bytes we've read.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param GCPtrSrc The source address.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param cb The number of bytes to read. Not more than a page.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @remark This function will dynamically map physical pages in GC. This may unmap
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * mappings done by the caller. Be careful!
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsyncVMMDECL(int) PGMPhysInterpretedRead(PVMCPU pVCpu, PCPUMCTXCORE pCtxCore, void *pvDst, RTGCUINTPTR GCPtrSrc, size_t cb)
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync/** @todo r=bird: This isn't perfect!
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * -# It's not checking for reserved bits being 1.
da936e0446fb2b56b813d5d938f1dfc6e4bf8b13vboxsync * -# It's not correctly dealing with the access bit.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * -# It's not respecting MMIO memory or any other access handlers.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * 1. Translate virtual to physical. This may fault.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * 2. Map the physical address.
da936e0446fb2b56b813d5d938f1dfc6e4bf8b13vboxsync * 3. Do the read operation.
da936e0446fb2b56b813d5d938f1dfc6e4bf8b13vboxsync * 4. Set access bits if required.
da936e0446fb2b56b813d5d938f1dfc6e4bf8b13vboxsync unsigned cb1 = PAGE_SIZE - (GCPtrSrc & PAGE_OFFSET_MASK);
da936e0446fb2b56b813d5d938f1dfc6e4bf8b13vboxsync * Not crossing pages.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync rc = PGM_GST_PFN(GetPage,pVCpu)(pVCpu, GCPtrSrc, &fFlags, &GCPhys);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /** @todo we should check reserved bits ... */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync Log(("PGMPhysInterpretedRead: pvDst=%p pvSrc=%p cb=%d\n", pvDst, (uint8_t *)pvSrc + (GCPtrSrc & PAGE_OFFSET_MASK), cb));
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync memcpy(pvDst, (uint8_t *)pvSrc + (GCPtrSrc & PAGE_OFFSET_MASK), cb);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync memset(pvDst, 0, cb); /** @todo this is wrong, it should be 0xff */
3080f6c0871099df43a4e91b31894d9c2b1369a8vboxsync /** @todo access bit emulation isn't 100% correct. */
da936e0446fb2b56b813d5d938f1dfc6e4bf8b13vboxsync rc = PGMGstModifyPage(pVCpu, GCPtrSrc, 1, X86_PTE_A, ~(uint64_t)X86_PTE_A);
3080f6c0871099df43a4e91b31894d9c2b1369a8vboxsync * Crosses pages.
da936e0446fb2b56b813d5d938f1dfc6e4bf8b13vboxsync rc = PGM_GST_PFN(GetPage,pVCpu)(pVCpu, GCPtrSrc, &fFlags1, &GCPhys1);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync rc = PGM_GST_PFN(GetPage,pVCpu)(pVCpu, GCPtrSrc + cb1, &fFlags2, &GCPhys2);
75fca099c974cbbd48f132af1378c60232614760vboxsync /** @todo we should check reserved bits ... */
da936e0446fb2b56b813d5d938f1dfc6e4bf8b13vboxsync AssertMsgFailed(("cb=%d cb1=%d cb2=%d GCPtrSrc=%RGv\n", cb, cb1, cb2, GCPtrSrc));
8f7bc6ad2b7bbcb4b3b96248cd2478e45f2e3b88vboxsync memcpy(pvDst, (uint8_t *)pvSrc1 + (GCPtrSrc & PAGE_OFFSET_MASK), cb1);
4cad44a5f7cfa7db8d5fb255a1df3b3cd1687853vboxsync memset(pvDst, 0, cb1); /** @todo this is wrong, it should be 0xff */
61fa69e2bc9fc9e7490feed1c020273f3ddb238dvboxsync memset((uint8_t *)pvDst + cb1, 0, cb2); /** @todo this is wrong, it should be 0xff */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync rc = PGMGstModifyPage(pVCpu, GCPtrSrc, 1, X86_PTE_A, ~(uint64_t)X86_PTE_A);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync rc = PGMGstModifyPage(pVCpu, GCPtrSrc + cb1, 1, X86_PTE_A, ~(uint64_t)X86_PTE_A);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Raise a #PF.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /* Get the current privilege level. */
2b88b28162a49c6fa769c03d56767a9806d4f456vboxsync uErr = (cpl >= 2) ? X86_TRAP_PF_RSVD | X86_TRAP_PF_US : X86_TRAP_PF_RSVD;
3080f6c0871099df43a4e91b31894d9c2b1369a8vboxsync AssertMsgFailed(("rc=%Rrc GCPtrSrc=%RGv cb=%#x\n", rc, GCPtrSrc, cb));
3080f6c0871099df43a4e91b31894d9c2b1369a8vboxsync Log(("PGMPhysInterpretedRead: GCPtrSrc=%RGv cb=%#x -> #PF(%#x)\n", GCPtrSrc, cb, uErr));
54fe68d807196dc565de24055996e634ee40ee92vboxsync return TRPMRaiseXcptErrCR2(pVCpu, pCtxCore, X86_XCPT_PF, uErr, GCPtrSrc);
da936e0446fb2b56b813d5d938f1dfc6e4bf8b13vboxsync * Performs a read of guest virtual memory for instruction emulation.
5be6801527b2bb09f4b481e28d771f366961cdacvboxsync * This will check permissions, raise exceptions and update the access bits.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * The current implementation will bypass all access handlers. It may later be
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * changed to at least respect MMIO.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @returns VBox status code suitable to scheduling.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @retval VINF_SUCCESS if the read was performed successfully.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @retval VINF_EM_RAW_GUEST_TRAP if an exception was raised but not dispatched yet.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @retval VINF_TRPM_XCPT_DISPATCHED if an exception was raised and dispatched.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param pVCpu The VMCPU handle.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param pCtxCore The context core.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param pvDst Where to put the bytes we've read.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param GCPtrSrc The source address.
6b022885f2cb6a55167609edecd89570cd80001dvboxsync * @param cb The number of bytes to read. Not more than a page.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param fRaiseTrap If set the trap will be raised on as per spec, if clear
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * an appropriate error status will be returned (no
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * informational at all).
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @remarks Takes the PGM lock.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @remarks A page fault on the 2nd page of the access will be raised without
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * writing the bits on the first page since we're ASSUMING that the
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * caller is emulating an instruction access.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @remarks This function will dynamically map physical pages in GC. This may
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * unmap mappings done by the caller. Be careful!
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsyncVMMDECL(int) PGMPhysInterpretedReadNoHandlers(PVMCPU pVCpu, PCPUMCTXCORE pCtxCore, void *pvDst, RTGCUINTPTR GCPtrSrc, size_t cb, bool fRaiseTrap)
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * 1. Translate virtual to physical. This may fault.
3cac8f8c6923a3a89ecfccda5e89ad75f48658e0vboxsync * 2. Map the physical address.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * 3. Do the read operation.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * 4. Set access bits if required.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync unsigned cb1 = PAGE_SIZE - (GCPtrSrc & PAGE_OFFSET_MASK);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Not crossing pages.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync rc = PGM_GST_PFN(GetPage,pVCpu)(pVCpu, GCPtrSrc, &fFlags, &GCPhys);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync if (1) /** @todo we should check reserved bits ... */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync const void *pvSrc;
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync rc = PGMPhysGCPhys2CCPtrReadOnly(pVM, GCPhys, &pvSrc, &Lock);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync Log(("PGMPhysInterpretedReadNoHandlers: pvDst=%p pvSrc=%p (%RGv) cb=%d\n",
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync pvDst, (const uint8_t *)pvSrc + (GCPtrSrc & PAGE_OFFSET_MASK), GCPtrSrc, cb));
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync memcpy(pvDst, (const uint8_t *)pvSrc + (GCPtrSrc & PAGE_OFFSET_MASK), cb);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync AssertReturn(RT_FAILURE(rc), VERR_IPE_UNEXPECTED_INFO_STATUS);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /** @todo access bit emulation isn't 100% correct. */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync rc = PGMGstModifyPage(pVCpu, GCPtrSrc, 1, X86_PTE_A, ~(uint64_t)X86_PTE_A);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Crosses pages.
e4ea543752422f1139923e3e506c625b0a1827c5vboxsync rc = PGM_GST_PFN(GetPage,pVCpu)(pVCpu, GCPtrSrc, &fFlags1, &GCPhys1);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync rc = PGM_GST_PFN(GetPage,pVCpu)(pVCpu, GCPtrSrc + cb1, &fFlags2, &GCPhys2);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync if (1) /** @todo we should check reserved bits ... */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync const void *pvSrc;
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync rc = PGMPhysGCPhys2CCPtrReadOnly(pVM, GCPhys1, &pvSrc, &Lock);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync Log(("PGMPhysInterpretedReadNoHandlers: pvDst=%p pvSrc=%p (%RGv) cb=%d [2]\n",
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync pvDst, (const uint8_t *)pvSrc + (GCPtrSrc & PAGE_OFFSET_MASK), GCPtrSrc, cb1));
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync memcpy(pvDst, (const uint8_t *)pvSrc + (GCPtrSrc & PAGE_OFFSET_MASK), cb1);
6b022885f2cb6a55167609edecd89570cd80001dvboxsync AssertReturn(RT_FAILURE(rc), VERR_IPE_UNEXPECTED_INFO_STATUS);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync rc = PGMPhysGCPhys2CCPtrReadOnly(pVM, GCPhys2, &pvSrc, &Lock);
e4ea543752422f1139923e3e506c625b0a1827c5vboxsync AssertReturn(RT_FAILURE(rc), VERR_IPE_UNEXPECTED_INFO_STATUS);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync rc = PGMGstModifyPage(pVCpu, GCPtrSrc, 1, X86_PTE_A, ~(uint64_t)X86_PTE_A);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync rc = PGMGstModifyPage(pVCpu, GCPtrSrc + cb1, 1, X86_PTE_A, ~(uint64_t)X86_PTE_A);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /* sort out which page */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Raise a #PF if we're allowed to do that.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /* Calc the error bits. */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync uErr = (cpl >= 2) ? X86_TRAP_PF_RSVD | X86_TRAP_PF_US : X86_TRAP_PF_RSVD;
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync AssertMsgFailed(("rc=%Rrc GCPtrSrc=%RGv cb=%#x\n", rc, GCPtrSrc, cb));
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync AssertReturn(RT_FAILURE(rc), VERR_IPE_UNEXPECTED_INFO_STATUS);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync Log(("PGMPhysInterpretedReadNoHandlers: GCPtrSrc=%RGv cb=%#x -> Raised #PF(%#x)\n", GCPtrSrc, cb, uErr));
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync return TRPMRaiseXcptErrCR2(pVCpu, pCtxCore, X86_XCPT_PF, uErr, GCPtrSrc);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync Log(("PGMPhysInterpretedReadNoHandlers: GCPtrSrc=%RGv cb=%#x -> #PF(%#x) [!raised]\n", GCPtrSrc, cb, uErr));
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Performs a write to guest virtual memory for instruction emulation.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * This will check permissions, raise exceptions and update the dirty and access
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @returns VBox status code suitable to scheduling.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @retval VINF_SUCCESS if the read was performed successfully.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @retval VINF_EM_RAW_GUEST_TRAP if an exception was raised but not dispatched yet.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @retval VINF_TRPM_XCPT_DISPATCHED if an exception was raised and dispatched.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param pVCpu The VMCPU handle.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param pCtxCore The context core.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param GCPtrDst The destination address.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param pvSrc What to write.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param cb The number of bytes to write. Not more than a page.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param fRaiseTrap If set the trap will be raised on as per spec, if clear
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * an appropriate error status will be returned (no
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * informational at all).
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @remarks Takes the PGM lock.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @remarks A page fault on the 2nd page of the access will be raised without
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * writing the bits on the first page since we're ASSUMING that the
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * caller is emulating an instruction access.
aaeb2e2f6ed5b164f1dec9a16a7adeb84f64cf31vboxsync * @remarks This function will dynamically map physical pages in GC. This may
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * unmap mappings done by the caller. Be careful!
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsyncVMMDECL(int) PGMPhysInterpretedWriteNoHandlers(PVMCPU pVCpu, PCPUMCTXCORE pCtxCore, RTGCPTR GCPtrDst, const void *pvSrc, size_t cb, bool fRaiseTrap)
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * 1. Translate virtual to physical. This may fault.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * 2. Map the physical address.
6b022885f2cb6a55167609edecd89570cd80001dvboxsync * 3. Do the write operation.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * 4. Set access bits if required.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync unsigned cb1 = PAGE_SIZE - (GCPtrDst & PAGE_OFFSET_MASK);
e4ea543752422f1139923e3e506c625b0a1827c5vboxsync * Not crossing pages.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync rc = PGM_GST_PFN(GetPage,pVCpu)(pVCpu, GCPtrDst, &fFlags, &GCPhys);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync if ( (fFlags & X86_PTE_RW) /** @todo Also check reserved bits. */
aaeb2e2f6ed5b164f1dec9a16a7adeb84f64cf31vboxsync && CPUMGetGuestCPL(pVCpu, pCtxCore) <= 2) ) /** @todo it's 2, right? Check cpl check below as well. */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync rc = PGMPhysGCPhys2CCPtr(pVM, GCPhys, &pvDst, &Lock);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync Log(("PGMPhysInterpretedWriteNoHandlers: pvDst=%p (%RGv) pvSrc=%p cb=%d\n",
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync (uint8_t *)pvDst + (GCPtrDst & PAGE_OFFSET_MASK), GCPtrDst, pvSrc, cb));
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync memcpy((uint8_t *)pvDst + (GCPtrDst & PAGE_OFFSET_MASK), pvSrc, cb);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /* bit bucket */
aaeb2e2f6ed5b164f1dec9a16a7adeb84f64cf31vboxsync AssertReturn(RT_FAILURE(rc), VERR_IPE_UNEXPECTED_INFO_STATUS);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /** @todo dirty & access bit emulation isn't 100% correct. */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync rc = PGMGstModifyPage(pVCpu, GCPtrDst, 1, X86_PTE_A | X86_PTE_D, ~(uint64_t)(X86_PTE_A | X86_PTE_D));
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Crosses pages.
aaeb2e2f6ed5b164f1dec9a16a7adeb84f64cf31vboxsync rc = PGM_GST_PFN(GetPage,pVCpu)(pVCpu, GCPtrDst, &fFlags1, &GCPhys1);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync rc = PGM_GST_PFN(GetPage,pVCpu)(pVCpu, GCPtrDst + cb1, &fFlags2, &GCPhys2);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync if ( ( (fFlags1 & X86_PTE_RW) /** @todo Also check reserved bits. */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync rc = PGMPhysGCPhys2CCPtr(pVM, GCPhys1, &pvDst, &Lock);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync Log(("PGMPhysInterpretedWriteNoHandlers: pvDst=%p (%RGv) pvSrc=%p cb=%d\n",
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync (uint8_t *)pvDst + (GCPtrDst & PAGE_OFFSET_MASK), GCPtrDst, pvSrc, cb1));
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync memcpy((uint8_t *)pvDst + (GCPtrDst & PAGE_OFFSET_MASK), pvSrc, cb1);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /* bit bucket */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync AssertReturn(RT_FAILURE(rc), VERR_IPE_UNEXPECTED_INFO_STATUS);
8da94e4d6813b682cdb38eb9b151ada72d91b40evboxsync rc = PGMPhysGCPhys2CCPtr(pVM, GCPhys2, &pvDst, &Lock);
6f516ad9911d9037a18778742caa955fe362f8ffvboxsync /* bit bucket */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync AssertReturn(RT_FAILURE(rc), VERR_IPE_UNEXPECTED_INFO_STATUS);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync rc = PGMGstModifyPage(pVCpu, GCPtrDst, 1, (X86_PTE_A | X86_PTE_RW), ~(uint64_t)(X86_PTE_A | X86_PTE_RW));
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync rc = PGMGstModifyPage(pVCpu, GCPtrDst + cb1, 1, (X86_PTE_A | X86_PTE_RW), ~(uint64_t)(X86_PTE_A | X86_PTE_RW));
aaeb2e2f6ed5b164f1dec9a16a7adeb84f64cf31vboxsync * Raise a #PF if we're allowed to do that.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /* Calc the error bits. */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync uErr = (cpl >= 2) ? X86_TRAP_PF_RSVD | X86_TRAP_PF_US : X86_TRAP_PF_RSVD;
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync uErr = (cpl >= 2) ? X86_TRAP_PF_RW | X86_TRAP_PF_US : X86_TRAP_PF_RW;
aaeb2e2f6ed5b164f1dec9a16a7adeb84f64cf31vboxsync AssertMsgFailed(("rc=%Rrc GCPtrDst=%RGv cb=%#x\n", rc, GCPtrDst, cb));
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync AssertReturn(RT_FAILURE(rc), VERR_IPE_UNEXPECTED_INFO_STATUS);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync Log(("PGMPhysInterpretedWriteNoHandlers: GCPtrDst=%RGv cb=%#x -> Raised #PF(%#x)\n", GCPtrDst, cb, uErr));
b1c3cdef473df2fbc621d5da81acc82dbfb8a11avboxsync return TRPMRaiseXcptErrCR2(pVCpu, pCtxCore, X86_XCPT_PF, uErr, GCPtrDst);