Index: /trunk/include/VBox/vmm/pgm.h =================================================================== --- /trunk/include/VBox/vmm/pgm.h (revision 55898) +++ /trunk/include/VBox/vmm/pgm.h (revision 55899) @@ -205,4 +205,6 @@ * @returns VINF_PGM_HANDLER_DO_DEFAULT if the caller should carry out the access operation. * @param pVM VM Handle. + * @param pVCpu Pointer to the cross context CPU context for the + * calling EMT. * @param GCPtr The virtual address the guest is writing to. (not correct if it's an alias!) * @param pvPtr The HC mapping of that address. @@ -398,12 +400,27 @@ VMMDECL(int) PGMPhysGCPtr2GCPhys(PVMCPU pVCpu, RTGCPTR GCPtr, PRTGCPHYS pGCPhys); VMMDECL(void) PGMPhysReleasePageMappingLock(PVM pVM, PPGMPAGEMAPLOCK pLock); -VMMDECL(int) PGMPhysRead(PVM pVM, RTGCPHYS GCPhys, void *pvBuf, size_t cbRead); -VMMDECL(int) PGMPhysWrite(PVM pVM, RTGCPHYS GCPhys, const void *pvBuf, size_t cbWrite); +/** Memory access origin. */ +typedef enum PGMACCESSORIGIN +{ + PGMACCESSORIGIN_INVALID = 0, + PGMACCESSORIGIN_IEM, + PGMACCESSORIGIN_HM, + PGMACCESSORIGIN_DEVICE, + PGMACCESSORIGIN_DEBUGGER, + PGMACCESSORIGIN_SELM, + PGMACCESSORIGIN_FTM, + PGMACCESSORIGIN_IOM, + PGMACCESSORIGIN_REM, + PGMACCESSORIGIN_END, + PGMACCESSORIGIN_32BIT_HACK = 0x7fffffff +} PGMACCESSORIGIN; +VMMDECL(int) PGMPhysRead(PVM pVM, RTGCPHYS GCPhys, void *pvBuf, size_t cbRead, PGMACCESSORIGIN enmOrigin); +VMMDECL(int) PGMPhysWrite(PVM pVM, RTGCPHYS GCPhys, const void *pvBuf, size_t cbWrite, PGMACCESSORIGIN enmOrigin); +VMMDECL(int) PGMPhysReadGCPtr(PVMCPU pVCpu, void *pvDst, RTGCPTR GCPtrSrc, size_t cb, PGMACCESSORIGIN enmOrigin); +VMMDECL(int) PGMPhysWriteGCPtr(PVMCPU pVCpu, RTGCPTR GCPtrDst, const void *pvSrc, size_t cb, PGMACCESSORIGIN enmOrigin); VMMDECL(int) PGMPhysSimpleReadGCPhys(PVM pVM, void *pvDst, RTGCPHYS GCPhysSrc, size_t cb); VMMDECL(int) PGMPhysSimpleWriteGCPhys(PVM pVM, RTGCPHYS GCPhysDst, const void *pvSrc, size_t cb); VMMDECL(int) PGMPhysSimpleReadGCPtr(PVMCPU pVCpu, void *pvDst, RTGCPTR GCPtrSrc, size_t cb); VMMDECL(int) PGMPhysSimpleWriteGCPtr(PVMCPU pVCpu, RTGCPTR GCPtrDst, const void *pvSrc, size_t cb); -VMMDECL(int) PGMPhysReadGCPtr(PVMCPU pVCpu, void *pvDst, RTGCPTR GCPtrSrc, size_t cb); -VMMDECL(int) PGMPhysWriteGCPtr(PVMCPU pVCpu, RTGCPTR GCPtrDst, const void *pvSrc, size_t cb); VMMDECL(int) PGMPhysSimpleDirtyWriteGCPtr(PVMCPU pVCpu, RTGCPTR GCPtrDst, const void *pvSrc, size_t cb); VMMDECL(int) PGMPhysInterpretedRead(PVMCPU pVCpu, PCPUMCTXCORE pCtxCore, void *pvDst, RTGCPTR GCPtrSrc, size_t cb); @@ -567,14 +584,14 @@ VMMR3DECL(int) PGMR3PhysTlbGCPhys2Ptr(PVM pVM, RTGCPHYS GCPhys, bool fWritable, void **ppv); -VMMR3DECL(uint8_t) PGMR3PhysReadU8(PVM pVM, RTGCPHYS GCPhys); -VMMR3DECL(uint16_t) PGMR3PhysReadU16(PVM pVM, RTGCPHYS GCPhys); -VMMR3DECL(uint32_t) PGMR3PhysReadU32(PVM pVM, RTGCPHYS GCPhys); -VMMR3DECL(uint64_t) PGMR3PhysReadU64(PVM pVM, RTGCPHYS GCPhys); -VMMR3DECL(void) PGMR3PhysWriteU8(PVM pVM, RTGCPHYS GCPhys, uint8_t Value); -VMMR3DECL(void) PGMR3PhysWriteU16(PVM pVM, RTGCPHYS GCPhys, uint16_t Value); -VMMR3DECL(void) PGMR3PhysWriteU32(PVM pVM, RTGCPHYS GCPhys, uint32_t Value); -VMMR3DECL(void) PGMR3PhysWriteU64(PVM pVM, RTGCPHYS GCPhys, uint64_t Value); -VMMR3DECL(int) PGMR3PhysReadExternal(PVM pVM, RTGCPHYS GCPhys, void *pvBuf, size_t cbRead); -VMMR3DECL(int) PGMR3PhysWriteExternal(PVM pVM, RTGCPHYS GCPhys, const void *pvBuf, size_t cbWrite, const char *pszWho); +VMMR3DECL(uint8_t) PGMR3PhysReadU8(PVM pVM, RTGCPHYS GCPhys, PGMACCESSORIGIN enmOrigin); +VMMR3DECL(uint16_t) PGMR3PhysReadU16(PVM pVM, RTGCPHYS GCPhys, PGMACCESSORIGIN enmOrigin); +VMMR3DECL(uint32_t) PGMR3PhysReadU32(PVM pVM, RTGCPHYS GCPhys, PGMACCESSORIGIN enmOrigin); +VMMR3DECL(uint64_t) PGMR3PhysReadU64(PVM pVM, RTGCPHYS GCPhys, PGMACCESSORIGIN enmOrigin); +VMMR3DECL(void) PGMR3PhysWriteU8(PVM pVM, RTGCPHYS GCPhys, uint8_t Value, PGMACCESSORIGIN enmOrigin); +VMMR3DECL(void) PGMR3PhysWriteU16(PVM pVM, RTGCPHYS GCPhys, uint16_t Value, PGMACCESSORIGIN enmOrigin); +VMMR3DECL(void) PGMR3PhysWriteU32(PVM pVM, RTGCPHYS GCPhys, uint32_t Value, PGMACCESSORIGIN enmOrigin); +VMMR3DECL(void) PGMR3PhysWriteU64(PVM pVM, RTGCPHYS GCPhys, uint64_t Value, PGMACCESSORIGIN enmOrigin); +VMMR3DECL(int) PGMR3PhysReadExternal(PVM pVM, RTGCPHYS GCPhys, void *pvBuf, size_t cbRead, PGMACCESSORIGIN enmOrigin); +VMMR3DECL(int) PGMR3PhysWriteExternal(PVM pVM, RTGCPHYS GCPhys, const void *pvBuf, size_t cbWrite, PGMACCESSORIGIN enmOrigin); VMMR3DECL(int) PGMR3PhysGCPhys2CCPtrExternal(PVM pVM, RTGCPHYS GCPhys, void **ppv, PPGMPAGEMAPLOCK pLock); VMMR3DECL(int) PGMR3PhysGCPhys2CCPtrReadOnlyExternal(PVM pVM, RTGCPHYS GCPhys, void const **ppv, PPGMPAGEMAPLOCK pLock); Index: /trunk/src/VBox/VMM/VMMAll/IEMAll.cpp =================================================================== --- /trunk/src/VBox/VMM/VMMAll/IEMAll.cpp (revision 55898) +++ /trunk/src/VBox/VMM/VMMAll/IEMAll.cpp (revision 55899) @@ -1027,5 +1027,5 @@ if (!pIemCpu->fBypassHandlers) - rc = PGMPhysRead(pVM, GCPhys, pIemCpu->abOpcode, cbToTryRead); + rc = PGMPhysRead(pVM, GCPhys, pIemCpu->abOpcode, cbToTryRead, PGMACCESSORIGIN_IEM); else rc = PGMPhysSimpleReadGCPhys(pVM, pIemCpu->abOpcode, GCPhys, cbToTryRead); @@ -1145,5 +1145,5 @@ */ if (!pIemCpu->fBypassHandlers) - rc = PGMPhysRead(IEMCPU_TO_VM(pIemCpu), GCPhys, &pIemCpu->abOpcode[pIemCpu->cbOpcode], cbToTryRead); + rc = PGMPhysRead(IEMCPU_TO_VM(pIemCpu), GCPhys, &pIemCpu->abOpcode[pIemCpu->cbOpcode], cbToTryRead, PGMACCESSORIGIN_IEM); else rc = PGMPhysSimpleReadGCPhys(IEMCPU_TO_VM(pIemCpu), &pIemCpu->abOpcode[pIemCpu->cbOpcode], GCPhys, cbToTryRead); @@ -6430,10 +6430,12 @@ pIemCpu->aMemBbMappings[iMemMap].GCPhysFirst, pbBuf, - cbFirst); + cbFirst, + PGMACCESSORIGIN_IEM); if (cbSecond && rc == VINF_SUCCESS) rc = PGMPhysWrite(IEMCPU_TO_VM(pIemCpu), pIemCpu->aMemBbMappings[iMemMap].GCPhysSecond, pbBuf + cbFirst, - cbSecond); + cbSecond, + PGMACCESSORIGIN_IEM); } else @@ -6575,5 +6577,5 @@ if (!pIemCpu->fBypassHandlers) { - rc = PGMPhysRead(IEMCPU_TO_VM(pIemCpu), GCPhysFirst, pbBuf, cbFirstPage); + rc = PGMPhysRead(IEMCPU_TO_VM(pIemCpu), GCPhysFirst, pbBuf, cbFirstPage, PGMACCESSORIGIN_IEM); if (rc != VINF_SUCCESS) { @@ -6582,5 +6584,5 @@ return rc; } - rc = PGMPhysRead(IEMCPU_TO_VM(pIemCpu), GCPhysSecond, pbBuf + cbFirstPage, cbSecondPage); + rc = PGMPhysRead(IEMCPU_TO_VM(pIemCpu), GCPhysSecond, pbBuf + cbFirstPage, cbSecondPage, PGMACCESSORIGIN_IEM); if (rc != VINF_SUCCESS) { @@ -6695,5 +6697,5 @@ int rc; if (!pIemCpu->fBypassHandlers) - rc = PGMPhysRead(IEMCPU_TO_VM(pIemCpu), GCPhysFirst, pbBuf, cbMem); + rc = PGMPhysRead(IEMCPU_TO_VM(pIemCpu), GCPhysFirst, pbBuf, cbMem, PGMACCESSORIGIN_IEM); else rc = PGMPhysSimpleReadGCPhys(IEMCPU_TO_VM(pIemCpu), pbBuf, GCPhysFirst, cbMem); Index: /trunk/src/VBox/VMM/VMMAll/IOMAllMMIO.cpp =================================================================== --- /trunk/src/VBox/VMM/VMMAll/IOMAllMMIO.cpp (revision 55898) +++ /trunk/src/VBox/VMM/VMMAll/IOMAllMMIO.cpp (revision 55899) @@ -678,5 +678,5 @@ return rc; #else - return PGMPhysReadGCPtr(pVCpu, pDest, GCSrc, cb); + return PGMPhysReadGCPtr(pVCpu, pDest, GCSrc, cb, PGMACCESSORIGIN_IOM); #endif } @@ -696,5 +696,5 @@ #else NOREF(pCtxCore); - return PGMPhysWriteGCPtr(pVCpu, GCPtrDst, pvSrc, cb); + return PGMPhysWriteGCPtr(pVCpu, GCPtrDst, pvSrc, cb, PGMACCESSORIGIN_IOM); #endif } Index: /trunk/src/VBox/VMM/VMMAll/PGMAllPhys.cpp =================================================================== --- /trunk/src/VBox/VMM/VMMAll/PGMAllPhys.cpp (revision 55898) +++ /trunk/src/VBox/VMM/VMMAll/PGMAllPhys.cpp (revision 55899) @@ -2215,6 +2215,7 @@ * @param pvBuf Where to put the read bits. * @param cbRead How many bytes to read. - */ -VMMDECL(int) PGMPhysRead(PVM pVM, RTGCPHYS GCPhys, void *pvBuf, size_t cbRead) + * @param enmOrigin The origin of this call. + */ +VMMDECL(int) PGMPhysRead(PVM pVM, RTGCPHYS GCPhys, void *pvBuf, size_t cbRead, PGMACCESSORIGIN enmOrigin) { AssertMsgReturn(cbRead > 0, ("don't even think about reading zero bytes!\n"), VINF_SUCCESS); @@ -2760,8 +2761,9 @@ * @param pvBuf What to write. * @param cbWrite How many bytes to write. - */ -VMMDECL(int) PGMPhysWrite(PVM pVM, RTGCPHYS GCPhys, const void *pvBuf, size_t cbWrite) -{ - AssertMsg(!pVM->pgm.s.fNoMorePhysWrites, ("Calling PGMPhysWrite after pgmR3Save()!\n")); + * @param enmOrigin Who is calling. + */ +VMMDECL(int) PGMPhysWrite(PVM pVM, RTGCPHYS GCPhys, const void *pvBuf, size_t cbWrite, PGMACCESSORIGIN enmOrigin) +{ + AssertMsg(!pVM->pgm.s.fNoMorePhysWrites, ("Calling PGMPhysWrite after pgmR3Save()! enmOrigin=%d\n", enmOrigin)); AssertMsgReturn(cbWrite > 0, ("don't even think about writing zero bytes!\n"), VINF_SUCCESS); LogFlow(("PGMPhysWrite: %RGp %d\n", GCPhys, cbWrite)); @@ -3271,7 +3273,8 @@ * @param GCPtrSrc The source address (GC pointer). * @param cb The number of bytes to read. - * @thread The vCPU EMT. - */ -VMMDECL(int) PGMPhysReadGCPtr(PVMCPU pVCpu, void *pvDst, RTGCPTR GCPtrSrc, size_t cb) + * @param enmOrigin Who is calling. + * @thread EMT(pVCpu) + */ +VMMDECL(int) PGMPhysReadGCPtr(PVMCPU pVCpu, void *pvDst, RTGCPTR GCPtrSrc, size_t cb, PGMACCESSORIGIN enmOrigin) { RTGCPHYS GCPhys; @@ -3306,5 +3309,5 @@ } - return PGMPhysRead(pVM, GCPhys, pvDst, cb); + return PGMPhysRead(pVM, GCPhys, pvDst, cb, enmOrigin); } @@ -3330,10 +3333,10 @@ if (cbRead < cb) { - rc = PGMPhysRead(pVM, GCPhys, pvDst, cbRead); + rc = PGMPhysRead(pVM, GCPhys, pvDst, cbRead, enmOrigin); if (RT_FAILURE(rc)) return rc; } else /* Last page (cbRead is PAGE_SIZE, we only need cb!) */ - return PGMPhysRead(pVM, GCPhys, pvDst, cb); + return PGMPhysRead(pVM, GCPhys, pvDst, cb, enmOrigin); /* next */ @@ -3360,6 +3363,7 @@ * @param pvSrc The source address. * @param cb The number of bytes to write. - */ -VMMDECL(int) PGMPhysWriteGCPtr(PVMCPU pVCpu, RTGCPTR GCPtrDst, const void *pvSrc, size_t cb) + * @param enmOrigin Who is calling. + */ +VMMDECL(int) PGMPhysWriteGCPtr(PVMCPU pVCpu, RTGCPTR GCPtrDst, const void *pvSrc, size_t cb, PGMACCESSORIGIN enmOrigin) { RTGCPHYS GCPhys; @@ -3398,5 +3402,5 @@ } - return PGMPhysWrite(pVM, GCPhys, pvSrc, cb); + return PGMPhysWrite(pVM, GCPhys, pvSrc, cb, enmOrigin); } @@ -3426,10 +3430,10 @@ if (cbWrite < cb) { - rc = PGMPhysWrite(pVM, GCPhys, pvSrc, cbWrite); + rc = PGMPhysWrite(pVM, GCPhys, pvSrc, cbWrite, enmOrigin); if (RT_FAILURE(rc)) return rc; } else /* Last page (cbWrite is PAGE_SIZE, we only need cb!) */ - rc = PGMPhysWrite(pVM, GCPhys, pvSrc, cb); + rc = PGMPhysWrite(pVM, GCPhys, pvSrc, cb, enmOrigin); /* next */ Index: /trunk/src/VBox/VMM/VMMAll/SELMAll.cpp =================================================================== --- /trunk/src/VBox/VMM/VMMAll/SELMAll.cpp (revision 55898) +++ /trunk/src/VBox/VMM/VMMAll/SELMAll.cpp (revision 55899) @@ -496,5 +496,5 @@ */ X86DESC GstDesc; - int rc = PGMPhysReadGCPtr(pVCpu, &GstDesc, GCPtrDesc, sizeof(GstDesc)); + int rc = PGMPhysReadGCPtr(pVCpu, &GstDesc, GCPtrDesc, sizeof(GstDesc), PGMACCESSORIGIN_IOM); if (RT_FAILURE(rc)) { Index: /trunk/src/VBox/VMM/VMMR0/HMVMXR0.cpp =================================================================== --- /trunk/src/VBox/VMM/VMMR0/HMVMXR0.cpp (revision 55898) +++ /trunk/src/VBox/VMM/VMMR0/HMVMXR0.cpp (revision 55899) @@ -12064,5 +12064,5 @@ Assert(sizeof(Eflags.u32) >= cbParm); Eflags.u32 = 0; - rc = PGMPhysRead(pVM, (RTGCPHYS)GCPtrStack, &Eflags.u32, cbParm); + rc = PGMPhysRead(pVM, (RTGCPHYS)GCPtrStack, &Eflags.u32, cbParm, PGMACCESSORIGIN_HM); } if (RT_FAILURE(rc)) @@ -12117,5 +12117,5 @@ Eflags.Bits.u1VM = 0; - rc = PGMPhysWrite(pVM, (RTGCPHYS)GCPtrStack, &Eflags.u, cbParm); + rc = PGMPhysWrite(pVM, (RTGCPHYS)GCPtrStack, &Eflags.u, cbParm, PGMACCESSORIGIN_HM); if (RT_FAILURE(rc)) { @@ -12152,5 +12152,5 @@ &GCPtrStack); if (RT_SUCCESS(rc)) - rc = PGMPhysRead(pVM, (RTGCPHYS)GCPtrStack, &aIretFrame[0], sizeof(aIretFrame)); + rc = PGMPhysRead(pVM, (RTGCPHYS)GCPtrStack, &aIretFrame[0], sizeof(aIretFrame), PGMACCESSORIGIN_HM); if (RT_FAILURE(rc)) { Index: /trunk/src/VBox/VMM/VMMR0/PDMR0Device.cpp =================================================================== --- /trunk/src/VBox/VMM/VMMR0/PDMR0Device.cpp (revision 55898) +++ /trunk/src/VBox/VMM/VMMR0/PDMR0Device.cpp (revision 55899) @@ -205,5 +205,5 @@ pDevIns, pDevIns->iInstance, GCPhys, pvBuf, cbRead)); - int rc = PGMPhysRead(pDevIns->Internal.s.pVMR0, GCPhys, pvBuf, cbRead); + int rc = PGMPhysRead(pDevIns->Internal.s.pVMR0, GCPhys, pvBuf, cbRead, PGMACCESSORIGIN_DEVICE); AssertRC(rc); /** @todo track down the users for this bugger. */ @@ -220,5 +220,5 @@ pDevIns, pDevIns->iInstance, GCPhys, pvBuf, cbWrite)); - int rc = PGMPhysWrite(pDevIns->Internal.s.pVMR0, GCPhys, pvBuf, cbWrite); + int rc = PGMPhysWrite(pDevIns->Internal.s.pVMR0, GCPhys, pvBuf, cbWrite, PGMACCESSORIGIN_DEVICE); AssertRC(rc); /** @todo track down the users for this bugger. */ Index: /trunk/src/VBox/VMM/VMMR3/FTM.cpp =================================================================== --- /trunk/src/VBox/VMM/VMMR3/FTM.cpp (revision 55898) +++ /trunk/src/VBox/VMM/VMMR3/FTM.cpp (revision 55899) @@ -925,5 +925,5 @@ { /* Update the guest memory of the standby VM. */ - int rc = PGMR3PhysWriteExternal(pVM, pNode->Core.Key, pNode->pPage, PAGE_SIZE, "FTMemSync"); + int rc = PGMR3PhysWriteExternal(pVM, pNode->Core.Key, pNode->pPage, PAGE_SIZE, PGMACCESSORIGIN_FTM); AssertRC(rc); } Index: /trunk/src/VBox/VMM/VMMR3/PDMDevHlp.cpp =================================================================== --- /trunk/src/VBox/VMM/VMMR3/PDMDevHlp.cpp (revision 55898) +++ /trunk/src/VBox/VMM/VMMR3/PDMDevHlp.cpp (revision 55899) @@ -717,7 +717,7 @@ int rc; if (VM_IS_EMT(pVM)) - rc = PGMPhysRead(pVM, GCPhys, pvBuf, cbRead); - else - rc = PGMR3PhysReadExternal(pVM, GCPhys, pvBuf, cbRead); + rc = PGMPhysRead(pVM, GCPhys, pvBuf, cbRead, PGMACCESSORIGIN_DEVICE); + else + rc = PGMR3PhysReadExternal(pVM, GCPhys, pvBuf, cbRead, PGMACCESSORIGIN_DEVICE); Log(("pdmR3DevHlp_PhysRead: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc)); @@ -745,7 +745,7 @@ int rc; if (VM_IS_EMT(pVM)) - rc = PGMPhysWrite(pVM, GCPhys, pvBuf, cbWrite); - else - rc = PGMR3PhysWriteExternal(pVM, GCPhys, pvBuf, cbWrite, pDevIns->pReg->szName); + rc = PGMPhysWrite(pVM, GCPhys, pvBuf, cbWrite, PGMACCESSORIGIN_DEVICE); + else + rc = PGMR3PhysWriteExternal(pVM, GCPhys, pvBuf, cbWrite, PGMACCESSORIGIN_DEVICE); Log(("pdmR3DevHlp_PhysWrite: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc)); Index: /trunk/src/VBox/VMM/VMMR3/PGMPhys.cpp =================================================================== --- /trunk/src/VBox/VMM/VMMR3/PGMPhys.cpp (revision 55898) +++ /trunk/src/VBox/VMM/VMMR3/PGMPhys.cpp (revision 55899) @@ -87,7 +87,8 @@ * EMT worker for PGMR3PhysReadExternal. */ -static DECLCALLBACK(int) pgmR3PhysReadExternalEMT(PVM pVM, PRTGCPHYS pGCPhys, void *pvBuf, size_t cbRead) -{ - PGMPhysRead(pVM, *pGCPhys, pvBuf, cbRead); +static DECLCALLBACK(int) pgmR3PhysReadExternalEMT(PVM pVM, PRTGCPHYS pGCPhys, void *pvBuf, size_t cbRead, + PGMACCESSORIGIN enmOrigin) +{ + PGMPhysRead(pVM, *pGCPhys, pvBuf, cbRead, enmOrigin); return VINF_SUCCESS; } @@ -104,8 +105,9 @@ * @param pvBuf Where to read into. * @param cbRead How many bytes to read. + * @param enmOrigin Who is calling. * * @thread Any but EMTs. */ -VMMR3DECL(int) PGMR3PhysReadExternal(PVM pVM, RTGCPHYS GCPhys, void *pvBuf, size_t cbRead) +VMMR3DECL(int) PGMR3PhysReadExternal(PVM pVM, RTGCPHYS GCPhys, void *pvBuf, size_t cbRead, PGMACCESSORIGIN enmOrigin) { VM_ASSERT_OTHER_THREAD(pVM); @@ -143,6 +145,6 @@ pgmUnlock(pVM); - return VMR3ReqPriorityCallWait(pVM, VMCPUID_ANY, (PFNRT)pgmR3PhysReadExternalEMT, 4, - pVM, &GCPhys, pvBuf, cbRead); + return VMR3ReqPriorityCallWait(pVM, VMCPUID_ANY, (PFNRT)pgmR3PhysReadExternalEMT, 5, + pVM, &GCPhys, pvBuf, cbRead, enmOrigin); } Assert(!PGM_PAGE_IS_MMIO_OR_SPECIAL_ALIAS(pPage)); @@ -215,8 +217,9 @@ * EMT worker for PGMR3PhysWriteExternal. */ -static DECLCALLBACK(int) pgmR3PhysWriteExternalEMT(PVM pVM, PRTGCPHYS pGCPhys, const void *pvBuf, size_t cbWrite) +static DECLCALLBACK(int) pgmR3PhysWriteExternalEMT(PVM pVM, PRTGCPHYS pGCPhys, const void *pvBuf, size_t cbWrite, + PGMACCESSORIGIN enmOrigin) { /** @todo VERR_EM_NO_MEMORY */ - PGMPhysWrite(pVM, *pGCPhys, pvBuf, cbWrite); + PGMPhysWrite(pVM, *pGCPhys, pvBuf, cbWrite, enmOrigin); return VINF_SUCCESS; } @@ -234,16 +237,15 @@ * @param pvBuf What to write. * @param cbWrite How many bytes to write. - * @param pszWho Who is writing. For tracking down who is writing - * after we've saved the state. + * @param enmOrigin Who is calling. * * @thread Any but EMTs. */ -VMMDECL(int) PGMR3PhysWriteExternal(PVM pVM, RTGCPHYS GCPhys, const void *pvBuf, size_t cbWrite, const char *pszWho) +VMMDECL(int) PGMR3PhysWriteExternal(PVM pVM, RTGCPHYS GCPhys, const void *pvBuf, size_t cbWrite, PGMACCESSORIGIN enmOrigin) { VM_ASSERT_OTHER_THREAD(pVM); AssertMsg(!pVM->pgm.s.fNoMorePhysWrites, - ("Calling PGMR3PhysWriteExternal after pgmR3Save()! GCPhys=%RGp cbWrite=%#x pszWho=%s\n", - GCPhys, cbWrite, pszWho)); + ("Calling PGMR3PhysWriteExternal after pgmR3Save()! GCPhys=%RGp cbWrite=%#x enmOrigin=%d\n", + GCPhys, cbWrite, enmOrigin)); AssertMsgReturn(cbWrite > 0, ("don't even think about writing zero bytes!\n"), VINF_SUCCESS); LogFlow(("PGMR3PhysWriteExternal: %RGp %d\n", GCPhys, cbWrite)); @@ -287,6 +289,6 @@ pgmUnlock(pVM); - return VMR3ReqPriorityCallWait(pVM, VMCPUID_ANY, (PFNRT)pgmR3PhysWriteExternalEMT, 4, - pVM, &GCPhys, pvBuf, cbWrite); + return VMR3ReqPriorityCallWait(pVM, VMCPUID_ANY, (PFNRT)pgmR3PhysWriteExternalEMT, 5, + pVM, &GCPhys, pvBuf, cbWrite, enmOrigin); } } Index: /trunk/src/VBox/VMM/VMMR3/PGMPhysRWTmpl.h =================================================================== --- /trunk/src/VBox/VMM/VMMR3/PGMPhysRWTmpl.h (revision 55898) +++ /trunk/src/VBox/VMM/VMMR3/PGMPhysRWTmpl.h (revision 55899) @@ -5,5 +5,5 @@ /* - * Copyright (C) 2006-2012 Oracle Corporation + * Copyright (C) 2006-2015 Oracle Corporation * * This file is part of VirtualBox Open Source Edition (OSE), as @@ -25,10 +25,11 @@ * @param pVM Pointer to the VM. * @param GCPhys Physical address start reading from. + * @param enmOrigin Who is calling. */ -VMMDECL(PGMPHYS_DATATYPE) PGMPHYSFN_READNAME(PVM pVM, RTGCPHYS GCPhys) +VMMDECL(PGMPHYS_DATATYPE) PGMPHYSFN_READNAME(PVM pVM, RTGCPHYS GCPhys, PGMACCESSORIGIN enmOrigin) { Assert(VM_IS_EMT(pVM)); PGMPHYS_DATATYPE val; - PGMPhysRead(pVM, GCPhys, &val, sizeof(val)); + PGMPhysRead(pVM, GCPhys, &val, sizeof(val), enmOrigin); return val; } @@ -44,9 +45,10 @@ * @param GCPhys Physical address to write to. * @param val What to write. + * @param enmOrigin Who is calling. */ -VMMDECL(void) PGMPHYSFN_WRITENAME(PVM pVM, RTGCPHYS GCPhys, PGMPHYS_DATATYPE val) +VMMDECL(void) PGMPHYSFN_WRITENAME(PVM pVM, RTGCPHYS GCPhys, PGMPHYS_DATATYPE val, PGMACCESSORIGIN enmOrigin) { Assert(VM_IS_EMT(pVM)); - PGMPhysWrite(pVM, GCPhys, &val, sizeof(val)); + PGMPhysWrite(pVM, GCPhys, &val, sizeof(val), enmOrigin); } Index: /trunk/src/VBox/VMM/VMMRC/PDMRCDevice.cpp =================================================================== --- /trunk/src/VBox/VMM/VMMRC/PDMRCDevice.cpp (revision 55898) +++ /trunk/src/VBox/VMM/VMMRC/PDMRCDevice.cpp (revision 55899) @@ -201,5 +201,5 @@ pDevIns, pDevIns->iInstance, GCPhys, pvBuf, cbRead)); - int rc = PGMPhysRead(pDevIns->Internal.s.pVMRC, GCPhys, pvBuf, cbRead); + int rc = PGMPhysRead(pDevIns->Internal.s.pVMRC, GCPhys, pvBuf, cbRead, PGMACCESSORIGIN_DEVICE); AssertRC(rc); /** @todo track down the users for this bugger. */ @@ -216,5 +216,5 @@ pDevIns, pDevIns->iInstance, GCPhys, pvBuf, cbWrite)); - int rc = PGMPhysWrite(pDevIns->Internal.s.pVMRC, GCPhys, pvBuf, cbWrite); + int rc = PGMPhysWrite(pDevIns->Internal.s.pVMRC, GCPhys, pvBuf, cbWrite, PGMACCESSORIGIN_DEVICE); AssertRC(rc); /** @todo track down the users for this bugger. */ Index: /trunk/src/VBox/VMM/testcase/tstAnimate.cpp =================================================================== --- /trunk/src/VBox/VMM/testcase/tstAnimate.cpp (revision 55898) +++ /trunk/src/VBox/VMM/testcase/tstAnimate.cpp (revision 55899) @@ -311,5 +311,5 @@ /* Write that page to the guest - skip known rom areas for now. */ if (GCPhys < 0xa0000 || GCPhys >= 0x100000) /* ASSUME size of a8Page is a power of 2. */ - PGMPhysWrite(pVM, GCPhys, &au8Page, cbRead); + PGMPhysWrite(pVM, GCPhys, &au8Page, cbRead, PGMACCESSORIGIN_DEBUGGER); GCPhys += cbRead; } Index: /trunk/src/recompiler/VBoxREMWrapper.cpp =================================================================== --- /trunk/src/recompiler/VBoxREMWrapper.cpp (revision 55898) +++ /trunk/src/recompiler/VBoxREMWrapper.cpp (revision 55899) @@ -832,5 +832,6 @@ { REMPARMDESC_FLAGS_GCPHYS, sizeof(RTGCPHYS), NULL }, { REMPARMDESC_FLAGS_INT, sizeof(void *), NULL }, - { REMPARMDESC_FLAGS_INT, sizeof(size_t), NULL } + { REMPARMDESC_FLAGS_INT, sizeof(size_t), NULL }, + { REMPARMDESC_FLAGS_INT, sizeof(PGMACCESSORIGIN), NULL } }; static const REMPARMDESC g_aArgsPGMPhysSimpleReadGCPtr[] = @@ -846,5 +847,6 @@ { REMPARMDESC_FLAGS_GCPHYS, sizeof(RTGCPHYS), NULL }, { REMPARMDESC_FLAGS_INT, sizeof(const void *), NULL }, - { REMPARMDESC_FLAGS_INT, sizeof(size_t), NULL } + { REMPARMDESC_FLAGS_INT, sizeof(size_t), NULL }, + { REMPARMDESC_FLAGS_INT, sizeof(PGMACCESSORIGIN), NULL } }; static const REMPARMDESC g_aArgsPGMChangeMode[] = @@ -864,5 +866,6 @@ { { REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL }, - { REMPARMDESC_FLAGS_GCPHYS, sizeof(RTGCPHYS), NULL } + { REMPARMDESC_FLAGS_GCPHYS, sizeof(RTGCPHYS), NULL }, + { REMPARMDESC_FLAGS_INT, sizeof(PGMACCESSORIGIN), NULL } }; static const REMPARMDESC g_aArgsPGMR3PhysWriteU8[] = @@ -870,5 +873,6 @@ { REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL }, { REMPARMDESC_FLAGS_GCPHYS, sizeof(RTGCPHYS), NULL }, - { REMPARMDESC_FLAGS_INT, sizeof(uint8_t), NULL } + { REMPARMDESC_FLAGS_INT, sizeof(uint8_t), NULL }, + { REMPARMDESC_FLAGS_INT, sizeof(PGMACCESSORIGIN), NULL } }; static const REMPARMDESC g_aArgsPGMR3PhysWriteU16[] = @@ -876,5 +880,6 @@ { REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL }, { REMPARMDESC_FLAGS_GCPHYS, sizeof(RTGCPHYS), NULL }, - { REMPARMDESC_FLAGS_INT, sizeof(uint16_t), NULL } + { REMPARMDESC_FLAGS_INT, sizeof(uint16_t), NULL }, + { REMPARMDESC_FLAGS_INT, sizeof(PGMACCESSORIGIN), NULL } }; static const REMPARMDESC g_aArgsPGMR3PhysWriteU32[] = @@ -882,5 +887,6 @@ { REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL }, { REMPARMDESC_FLAGS_GCPHYS, sizeof(RTGCPHYS), NULL }, - { REMPARMDESC_FLAGS_INT, sizeof(uint32_t), NULL } + { REMPARMDESC_FLAGS_INT, sizeof(uint32_t), NULL }, + { REMPARMDESC_FLAGS_INT, sizeof(PGMACCESSORIGIN), NULL } }; static const REMPARMDESC g_aArgsPGMR3PhysWriteU64[] = @@ -888,5 +894,6 @@ { REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL }, { REMPARMDESC_FLAGS_GCPHYS, sizeof(RTGCPHYS), NULL }, - { REMPARMDESC_FLAGS_INT, sizeof(uint64_t), NULL } + { REMPARMDESC_FLAGS_INT, sizeof(uint64_t), NULL }, + { REMPARMDESC_FLAGS_INT, sizeof(PGMACCESSORIGIN), NULL } }; static const REMPARMDESC g_aArgsRTMemReallocTag[] = Index: /trunk/src/recompiler/VBoxRecompiler.c =================================================================== --- /trunk/src/recompiler/VBoxRecompiler.c (revision 55898) +++ /trunk/src/recompiler/VBoxRecompiler.c (revision 55899) @@ -3565,5 +3565,5 @@ STAM_PROFILE_ADV_START(&gStatMemRead, a); VBOX_CHECK_ADDR(SrcGCPhys); - PGMPhysRead(cpu_single_env->pVM, SrcGCPhys, pvDst, cb); + PGMPhysRead(cpu_single_env->pVM, SrcGCPhys, pvDst, cb, PGMACCESSORIGIN_REM); #ifdef VBOX_DEBUG_PHYS LogRel(("read(%d): %08x\n", cb, (uint32_t)SrcGCPhys)); @@ -3583,5 +3583,5 @@ STAM_PROFILE_ADV_START(&gStatMemRead, a); VBOX_CHECK_ADDR(SrcGCPhys); - val = PGMR3PhysReadU8(cpu_single_env->pVM, SrcGCPhys); + val = PGMR3PhysReadU8(cpu_single_env->pVM, SrcGCPhys, PGMACCESSORIGIN_REM); STAM_PROFILE_ADV_STOP(&gStatMemRead, a); #ifdef VBOX_DEBUG_PHYS @@ -3602,5 +3602,5 @@ STAM_PROFILE_ADV_START(&gStatMemRead, a); VBOX_CHECK_ADDR(SrcGCPhys); - val = PGMR3PhysReadU8(cpu_single_env->pVM, SrcGCPhys); + val = PGMR3PhysReadU8(cpu_single_env->pVM, SrcGCPhys, PGMACCESSORIGIN_REM); STAM_PROFILE_ADV_STOP(&gStatMemRead, a); #ifdef VBOX_DEBUG_PHYS @@ -3621,5 +3621,5 @@ STAM_PROFILE_ADV_START(&gStatMemRead, a); VBOX_CHECK_ADDR(SrcGCPhys); - val = PGMR3PhysReadU16(cpu_single_env->pVM, SrcGCPhys); + val = PGMR3PhysReadU16(cpu_single_env->pVM, SrcGCPhys, PGMACCESSORIGIN_REM); STAM_PROFILE_ADV_STOP(&gStatMemRead, a); #ifdef VBOX_DEBUG_PHYS @@ -3640,5 +3640,5 @@ STAM_PROFILE_ADV_START(&gStatMemRead, a); VBOX_CHECK_ADDR(SrcGCPhys); - val = PGMR3PhysReadU16(cpu_single_env->pVM, SrcGCPhys); + val = PGMR3PhysReadU16(cpu_single_env->pVM, SrcGCPhys, PGMACCESSORIGIN_REM); STAM_PROFILE_ADV_STOP(&gStatMemRead, a); #ifdef VBOX_DEBUG_PHYS @@ -3659,5 +3659,5 @@ STAM_PROFILE_ADV_START(&gStatMemRead, a); VBOX_CHECK_ADDR(SrcGCPhys); - val = PGMR3PhysReadU32(cpu_single_env->pVM, SrcGCPhys); + val = PGMR3PhysReadU32(cpu_single_env->pVM, SrcGCPhys, PGMACCESSORIGIN_REM); STAM_PROFILE_ADV_STOP(&gStatMemRead, a); #ifdef VBOX_DEBUG_PHYS @@ -3678,5 +3678,5 @@ STAM_PROFILE_ADV_START(&gStatMemRead, a); VBOX_CHECK_ADDR(SrcGCPhys); - val = PGMR3PhysReadU32(cpu_single_env->pVM, SrcGCPhys); + val = PGMR3PhysReadU32(cpu_single_env->pVM, SrcGCPhys, PGMACCESSORIGIN_REM); STAM_PROFILE_ADV_STOP(&gStatMemRead, a); #ifdef VBOX_DEBUG_PHYS @@ -3697,5 +3697,5 @@ STAM_PROFILE_ADV_START(&gStatMemRead, a); VBOX_CHECK_ADDR(SrcGCPhys); - val = PGMR3PhysReadU64(cpu_single_env->pVM, SrcGCPhys); + val = PGMR3PhysReadU64(cpu_single_env->pVM, SrcGCPhys, PGMACCESSORIGIN_REM); STAM_PROFILE_ADV_STOP(&gStatMemRead, a); #ifdef VBOX_DEBUG_PHYS @@ -3716,5 +3716,5 @@ STAM_PROFILE_ADV_START(&gStatMemRead, a); VBOX_CHECK_ADDR(SrcGCPhys); - val = PGMR3PhysReadU64(cpu_single_env->pVM, SrcGCPhys); + val = PGMR3PhysReadU64(cpu_single_env->pVM, SrcGCPhys, PGMACCESSORIGIN_REM); STAM_PROFILE_ADV_STOP(&gStatMemRead, a); #ifdef VBOX_DEBUG_PHYS @@ -3736,5 +3736,5 @@ STAM_PROFILE_ADV_START(&gStatMemWrite, a); VBOX_CHECK_ADDR(DstGCPhys); - PGMPhysWrite(cpu_single_env->pVM, DstGCPhys, pvSrc, cb); + PGMPhysWrite(cpu_single_env->pVM, DstGCPhys, pvSrc, cb, PGMACCESSORIGIN_REM); STAM_PROFILE_ADV_STOP(&gStatMemWrite, a); #ifdef VBOX_DEBUG_PHYS @@ -3754,5 +3754,5 @@ STAM_PROFILE_ADV_START(&gStatMemWrite, a); VBOX_CHECK_ADDR(DstGCPhys); - PGMR3PhysWriteU8(cpu_single_env->pVM, DstGCPhys, val); + PGMR3PhysWriteU8(cpu_single_env->pVM, DstGCPhys, val, PGMACCESSORIGIN_REM); STAM_PROFILE_ADV_STOP(&gStatMemWrite, a); #ifdef VBOX_DEBUG_PHYS @@ -3772,5 +3772,5 @@ STAM_PROFILE_ADV_START(&gStatMemWrite, a); VBOX_CHECK_ADDR(DstGCPhys); - PGMR3PhysWriteU16(cpu_single_env->pVM, DstGCPhys, val); + PGMR3PhysWriteU16(cpu_single_env->pVM, DstGCPhys, val, PGMACCESSORIGIN_REM); STAM_PROFILE_ADV_STOP(&gStatMemWrite, a); #ifdef VBOX_DEBUG_PHYS @@ -3790,5 +3790,5 @@ STAM_PROFILE_ADV_START(&gStatMemWrite, a); VBOX_CHECK_ADDR(DstGCPhys); - PGMR3PhysWriteU32(cpu_single_env->pVM, DstGCPhys, val); + PGMR3PhysWriteU32(cpu_single_env->pVM, DstGCPhys, val, PGMACCESSORIGIN_REM); STAM_PROFILE_ADV_STOP(&gStatMemWrite, a); #ifdef VBOX_DEBUG_PHYS @@ -3808,5 +3808,5 @@ STAM_PROFILE_ADV_START(&gStatMemWrite, a); VBOX_CHECK_ADDR(DstGCPhys); - PGMR3PhysWriteU64(cpu_single_env->pVM, DstGCPhys, val); + PGMR3PhysWriteU64(cpu_single_env->pVM, DstGCPhys, val, PGMACCESSORIGIN_REM); STAM_PROFILE_ADV_STOP(&gStatMemWrite, a); #ifdef VBOX_DEBUG_PHYS @@ -3891,5 +3891,5 @@ uint8_t u8; Log2(("remR3HandlerReadU8: GCPhys=%RGp\n", (RTGCPHYS)GCPhys)); - PGMPhysRead((PVM)pvVM, GCPhys, &u8, sizeof(u8)); + PGMPhysRead((PVM)pvVM, GCPhys, &u8, sizeof(u8), PGMACCESSORIGIN_REM); return u8; } @@ -3899,5 +3899,5 @@ uint16_t u16; Log2(("remR3HandlerReadU16: GCPhys=%RGp\n", (RTGCPHYS)GCPhys)); - PGMPhysRead((PVM)pvVM, GCPhys, &u16, sizeof(u16)); + PGMPhysRead((PVM)pvVM, GCPhys, &u16, sizeof(u16), PGMACCESSORIGIN_REM); return u16; } @@ -3907,5 +3907,5 @@ uint32_t u32; Log2(("remR3HandlerReadU32: GCPhys=%RGp\n", (RTGCPHYS)GCPhys)); - PGMPhysRead((PVM)pvVM, GCPhys, &u32, sizeof(u32)); + PGMPhysRead((PVM)pvVM, GCPhys, &u32, sizeof(u32), PGMACCESSORIGIN_REM); return u32; } @@ -3914,5 +3914,5 @@ { Log2(("remR3HandlerWriteU8: GCPhys=%RGp u32=%#x\n", (RTGCPHYS)GCPhys, u32)); - PGMPhysWrite((PVM)pvVM, GCPhys, &u32, sizeof(uint8_t)); + PGMPhysWrite((PVM)pvVM, GCPhys, &u32, sizeof(uint8_t), PGMACCESSORIGIN_REM); } @@ -3920,5 +3920,5 @@ { Log2(("remR3HandlerWriteU16: GCPhys=%RGp u32=%#x\n", (RTGCPHYS)GCPhys, u32)); - PGMPhysWrite((PVM)pvVM, GCPhys, &u32, sizeof(uint16_t)); + PGMPhysWrite((PVM)pvVM, GCPhys, &u32, sizeof(uint16_t), PGMACCESSORIGIN_REM); } @@ -3926,5 +3926,5 @@ { Log2(("remR3HandlerWriteU32: GCPhys=%RGp u32=%#x\n", (RTGCPHYS)GCPhys, u32)); - PGMPhysWrite((PVM)pvVM, GCPhys, &u32, sizeof(uint32_t)); + PGMPhysWrite((PVM)pvVM, GCPhys, &u32, sizeof(uint32_t), PGMACCESSORIGIN_REM); }