VirtualBox

Changeset 45305 in vbox


Ignore:
Timestamp:
Apr 3, 2013 11:15:02 AM (11 years ago)
Author:
vboxsync
Message:

IOM: Adding pVCpu to a lot of calls and moving the lookup caches from VM to VMCPU.

Location:
trunk
Files:
20 edited

Legend:

Unmodified
Added
Removed

  • trunk/include/VBox/vmm/iom.h

    r45301 r45305  
    271271typedef FNIOMMMIOFILL *PFNIOMMMIOFILL;
    272272
    273 VMMDECL(VBOXSTRICTRC)   IOMIOPortRead(PVM pVM, RTIOPORT Port, uint32_t *pu32Value, size_t cbValue);
    274 VMMDECL(VBOXSTRICTRC)   IOMIOPortWrite(PVM pVM, RTIOPORT Port, uint32_t u32Value, size_t cbValue);
    275 VMMDECL(VBOXSTRICTRC)   IOMInterpretOUT(PVM pVM, PCPUMCTXCORE pRegFrame, PDISCPUSTATE pCpu);
    276 VMMDECL(VBOXSTRICTRC)   IOMInterpretIN(PVM pVM, PCPUMCTXCORE pRegFrame, PDISCPUSTATE pCpu);
    277 VMMDECL(VBOXSTRICTRC)   IOMIOPortReadString(PVM pVM, RTIOPORT Port, PRTGCPTR pGCPtrDst, PRTGCUINTREG pcTransfers, unsigned cb);
    278 VMMDECL(VBOXSTRICTRC)   IOMIOPortWriteString(PVM pVM, RTIOPORT Port, PRTGCPTR pGCPtrSrc, PRTGCUINTREG pcTransfers, unsigned cb);
    279 VMMDECL(VBOXSTRICTRC)   IOMInterpretINS(PVM pVM, PCPUMCTXCORE pRegFrame, PDISCPUSTATE pCpu);
    280 VMMDECL(VBOXSTRICTRC)   IOMInterpretINSEx(PVM pVM, PCPUMCTXCORE pRegFrame, uint32_t uPort, uint32_t uPrefix, DISCPUMODE enmAddrMode, uint32_t cbTransfer);
    281 VMMDECL(VBOXSTRICTRC)   IOMInterpretOUTS(PVM pVM, PCPUMCTXCORE pRegFrame, PDISCPUSTATE pCpu);
    282 VMMDECL(VBOXSTRICTRC)   IOMInterpretOUTSEx(PVM pVM, PCPUMCTXCORE pRegFrame, uint32_t uPort, uint32_t uPrefix, DISCPUMODE enmAddrMode, uint32_t cbTransfer);
    283 VMMDECL(VBOXSTRICTRC)   IOMMMIORead(PVM pVM, RTGCPHYS GCPhys, uint32_t *pu32Value, size_t cbValue);
    284 VMMDECL(VBOXSTRICTRC)   IOMMMIOWrite(PVM pVM, RTGCPHYS GCPhys, uint32_t u32Value, size_t cbValue);
    285 VMMDECL(VBOXSTRICTRC)   IOMMMIOPhysHandler(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pCtxCore, RTGCPHYS GCPhysFault);
     273VMMDECL(VBOXSTRICTRC)   IOMIOPortRead(PVM pVM, PVMCPU pVCpu, RTIOPORT Port, uint32_t *pu32Value, size_t cbValue);
     274VMMDECL(VBOXSTRICTRC)   IOMIOPortWrite(PVM pVM, PVMCPU pVCpu, RTIOPORT Port, uint32_t u32Value, size_t cbValue);
     275VMMDECL(VBOXSTRICTRC)   IOMInterpretOUT(PVM pVM, PVMCPU pVCpu, PCPUMCTXCORE pRegFrame, PDISCPUSTATE pCpu);
     276VMMDECL(VBOXSTRICTRC)   IOMInterpretIN(PVM pVM, PVMCPU pVCpu, PCPUMCTXCORE pRegFrame, PDISCPUSTATE pCpu);
     277VMMDECL(VBOXSTRICTRC)   IOMIOPortReadString(PVM pVM, PVMCPU pVCpu, RTIOPORT Port, PRTGCPTR pGCPtrDst, PRTGCUINTREG pcTransfers, unsigned cb);
     278VMMDECL(VBOXSTRICTRC)   IOMIOPortWriteString(PVM pVM, PVMCPU pVCpu, RTIOPORT Port, PRTGCPTR pGCPtrSrc, PRTGCUINTREG pcTransfers, unsigned cb);
     279VMMDECL(VBOXSTRICTRC)   IOMInterpretINS(PVM pVM, PVMCPU pVCpu, PCPUMCTXCORE pRegFrame, PDISCPUSTATE pCpu);
     280VMMDECL(VBOXSTRICTRC)   IOMInterpretINSEx(PVM pVM, PVMCPU pVCpu, PCPUMCTXCORE pRegFrame, uint32_t uPort, uint32_t uPrefix, DISCPUMODE enmAddrMode, uint32_t cbTransfer);
     281VMMDECL(VBOXSTRICTRC)   IOMInterpretOUTS(PVM pVM, PVMCPU pVCpu, PCPUMCTXCORE pRegFrame, PDISCPUSTATE pCpu);
     282VMMDECL(VBOXSTRICTRC)   IOMInterpretOUTSEx(PVM pVM, PVMCPU pVCpu, PCPUMCTXCORE pRegFrame, uint32_t uPort, uint32_t uPrefix, DISCPUMODE enmAddrMode, uint32_t cbTransfer);
     283VMMDECL(VBOXSTRICTRC)   IOMMMIORead(PVM pVM, PVMCPU pVCpu, RTGCPHYS GCPhys, uint32_t *pu32Value, size_t cbValue);
     284VMMDECL(VBOXSTRICTRC)   IOMMMIOWrite(PVM pVM, PVMCPU pVCpu, RTGCPHYS GCPhys, uint32_t u32Value, size_t cbValue);
     285VMMDECL(VBOXSTRICTRC)   IOMMMIOPhysHandler(PVM pVM, PVMCPU pVCpu, RTGCUINT uErrorCode, PCPUMCTXCORE pCtxCore, RTGCPHYS GCPhysFault);
    286286VMMDECL(VBOXSTRICTRC)   IOMInterpretCheckPortIOAccess(PVM pVM, PCPUMCTXCORE pCtxCore, RTIOPORT Port, unsigned cb);
    287287VMMDECL(int)            IOMMMIOMapMMIO2Page(PVM pVM, RTGCPHYS GCPhys, RTGCPHYS GCPhysRemapped, uint64_t fPageFlags);
    … …  
    295295 * @{
    296296 */
    297 VMMRCDECL(VBOXSTRICTRC) IOMRCIOPortHandler(PVM pVM, PCPUMCTXCORE pRegFrame, PDISCPUSTATE pCpu);
     297VMMRCDECL(VBOXSTRICTRC) IOMRCIOPortHandler(PVM pVM, PVMCPU pVCpu, PCPUMCTXCORE pRegFrame, PDISCPUSTATE pCpu);
    298298/** @} */
    299299#endif /* IN_RC */

  • trunk/src/VBox/Devices/Bus/DevPCI.cpp

    r45025 r45305  
    18401840{
    18411841    unsigned    i;
    1842     uint8_t     elcr[2] = {0, 0};
     1842    uint8_t     elcr[2]  = {0, 0};
    18431843    PPCIGLOBALS pGlobals = PDMINS_2_DATA(pDevIns, PPCIGLOBALS);
    1844     PVM         pVM = PDMDevHlpGetVM(pDevIns);
    1845     Assert(pVM);
     1844    PVM         pVM      = PDMDevHlpGetVM(pDevIns); Assert(pVM);
     1845    PVMCPU      pVCpu    = PDMDevHlpGetVMCPU(pDevIns); Assert(pVM);
    18461846
    18471847    /*
    … …  
    18651865
    18661866    /* Tell to the PIC. */
    1867     VBOXSTRICTRC rcStrict = IOMIOPortWrite(pVM, 0x4d0, elcr[0], sizeof(uint8_t));
     1867    VBOXSTRICTRC rcStrict = IOMIOPortWrite(pVM, pVCpu, 0x4d0, elcr[0], sizeof(uint8_t));
    18681868    if (rcStrict == VINF_SUCCESS)
    1869         rcStrict = IOMIOPortWrite(pVM, 0x4d1, elcr[1], sizeof(uint8_t));
     1869        rcStrict = IOMIOPortWrite(pVM, pVCpu, 0x4d1, elcr[1], sizeof(uint8_t));
    18701870    if (rcStrict != VINF_SUCCESS)
    18711871    {

  • trunk/src/VBox/Devices/Graphics/DevVGA.cpp

    r45055 r45305  
    12151215            /** @todo only allow read access (doesn't work now) */
    12161216            STAM_COUNTER_INC(&pThis->StatMapPage);
    1217             IOMMMIOMapMMIO2Page(PDMDevHlpGetVM(pThis->CTX_SUFF(pDevIns)), GCPhys, pThis->GCPhysVRAM + addr, X86_PTE_RW|X86_PTE_P);
     1217            IOMMMIOMapMMIO2Page(PDMDevHlpGetVM(pThis->CTX_SUFF(pDevIns)), GCPhys,
     1218                                pThis->GCPhysVRAM + addr, X86_PTE_RW | X86_PTE_P);
    12181219            /* Set as dirty as write accesses won't be noticed now. */
    12191220            vga_set_dirty(pThis, addr);
    … …  
    12971298            {
    12981299                STAM_COUNTER_INC(&pThis->StatMapPage);
    1299                 IOMMMIOMapMMIO2Page(PDMDevHlpGetVM(pThis->CTX_SUFF(pDevIns)), GCPhys, pThis->GCPhysVRAM + addr, X86_PTE_RW | X86_PTE_P);
     1300                IOMMMIOMapMMIO2Page(PDMDevHlpGetVM(pThis->CTX_SUFF(pDevIns)), GCPhys,
     1301                                    pThis->GCPhysVRAM + addr, X86_PTE_RW | X86_PTE_P);
    13001302                pThis->fRemappedVGA = true;
    13011303            }

  • trunk/src/VBox/VMM/VMMAll/IEMAllCImpl.cpp.h

    r42778 r45305  
    38383838    uint32_t u32Value;
    38393839    if (!IEM_VERIFICATION_ENABLED(pIemCpu))
    3840         rcStrict = IOMIOPortRead(IEMCPU_TO_VM(pIemCpu), u16Port, &u32Value, cbReg);
     3840        rcStrict = IOMIOPortRead(IEMCPU_TO_VM(pIemCpu), IEMCPU_TO_VMCPU(pIemCpu), u16Port, &u32Value, cbReg);
    38413841    else
    38423842        rcStrict = iemVerifyFakeIOPortRead(pIemCpu, u16Port, &u32Value, cbReg);
    … …  
    39003900    }
    39013901    if (!IEM_VERIFICATION_ENABLED(pIemCpu))
    3902         rcStrict = IOMIOPortWrite(IEMCPU_TO_VM(pIemCpu), u16Port, u32Value, cbReg);
     3902        rcStrict = IOMIOPortWrite(IEMCPU_TO_VM(pIemCpu), IEMCPU_TO_VMCPU(pIemCpu), u16Port, u32Value, cbReg);
    39033903    else
    39043904        rcStrict = iemVerifyFakeIOPortWrite(pIemCpu, u16Port, u32Value, cbReg);

  • trunk/src/VBox/VMM/VMMAll/IEMAllCImplStrInstr.cpp.h

    r42761 r45305  
    10611061    uint32_t        u32Value;
    10621062    if (!IEM_VERIFICATION_ENABLED(pIemCpu))
    1063         rcStrict = IOMIOPortRead(pVM, pCtx->dx, &u32Value, OP_SIZE / 8);
     1063        rcStrict = IOMIOPortRead(pVM, IEMCPU_TO_VMCPU(pIemCpu), pCtx->dx, &u32Value, OP_SIZE / 8);
    10641064    else
    10651065        rcStrict = iemVerifyFakeIOPortRead(pIemCpu, pCtx->dx, &u32Value, OP_SIZE / 8);
    … …  
    10911091IEM_CIMPL_DEF_0(RT_CONCAT4(iemCImpl_rep_ins_op,OP_SIZE,_addr,ADDR_SIZE))
    10921092{
    1093     PVM         pVM  = IEMCPU_TO_VM(pIemCpu);
    1094     PCPUMCTX    pCtx = pIemCpu->CTX_SUFF(pCtx);
     1093    PVM         pVM   = IEMCPU_TO_VM(pIemCpu);
     1094    PVMCPU      pVCpu = IEMCPU_TO_VMCPU(pIemCpu);
     1095    PCPUMCTX    pCtx  = pIemCpu->CTX_SUFF(pCtx);
    10951096
    10961097    /*
    … …  
    11731174                    uint32_t u32Value;
    11741175                    if (!IEM_VERIFICATION_ENABLED(pIemCpu))
    1175                         rcStrict = IOMIOPortRead(pVM, u16Port, &u32Value, OP_SIZE / 8);
     1176                        rcStrict = IOMIOPortRead(pVM, pVCpu, u16Port, &u32Value, OP_SIZE / 8);
    11761177                    else
    11771178                        rcStrict = iemVerifyFakeIOPortRead(pIemCpu, u16Port, &u32Value, OP_SIZE / 8);
    … …  
    12241225            uint32_t u32Value;
    12251226            if (!IEM_VERIFICATION_ENABLED(pIemCpu))
    1226                 rcStrict = IOMIOPortRead(pVM, u16Port, &u32Value, OP_SIZE / 8);
     1227                rcStrict = IOMIOPortRead(pVM, pVCpu, u16Port, &u32Value, OP_SIZE / 8);
    12271228            else
    12281229                rcStrict = iemVerifyFakeIOPortRead(pIemCpu, u16Port, &u32Value, OP_SIZE / 8);
    … …  
    12801281    {
    12811282        if (!IEM_VERIFICATION_ENABLED(pIemCpu))
    1282             rcStrict = IOMIOPortWrite(pVM, pCtx->dx, uValue, OP_SIZE / 8);
     1283            rcStrict = IOMIOPortWrite(pVM, IEMCPU_TO_VMCPU(pIemCpu), pCtx->dx, uValue, OP_SIZE / 8);
    12831284        else
    12841285            rcStrict = iemVerifyFakeIOPortWrite(pIemCpu, pCtx->dx, uValue, OP_SIZE / 8);
    … …  
    13031304IEM_CIMPL_DEF_1(RT_CONCAT4(iemCImpl_rep_outs_op,OP_SIZE,_addr,ADDR_SIZE), uint8_t, iEffSeg)
    13041305{
    1305     PVM         pVM  = IEMCPU_TO_VM(pIemCpu);
    1306     PCPUMCTX    pCtx = pIemCpu->CTX_SUFF(pCtx);
     1306    PVM         pVM   = IEMCPU_TO_VM(pIemCpu);
     1307    PVMCPU      pVCpu = IEMCPU_TO_VMCPU(pIemCpu);
     1308    PCPUMCTX    pCtx  = pIemCpu->CTX_SUFF(pCtx);
    13071309
    13081310    /*
    … …  
    13771379                    uint32_t u32Value = *puMem++;
    13781380                    if (!IEM_VERIFICATION_ENABLED(pIemCpu))
    1379                         rcStrict = IOMIOPortWrite(pVM, u16Port, u32Value, OP_SIZE / 8);
     1381                        rcStrict = IOMIOPortWrite(pVM, pVCpu, u16Port, u32Value, OP_SIZE / 8);
    13801382                    else
    13811383                        rcStrict = iemVerifyFakeIOPortWrite(pIemCpu, u16Port, u32Value, OP_SIZE / 8);
    … …  
    14261428
    14271429            if (!IEM_VERIFICATION_ENABLED(pIemCpu))
    1428                 rcStrict = IOMIOPortWrite(pVM, u16Port, uValue, OP_SIZE / 8);
     1430                rcStrict = IOMIOPortWrite(pVM, pVCpu, u16Port, uValue, OP_SIZE / 8);
    14291431            else
    14301432                rcStrict = iemVerifyFakeIOPortWrite(pIemCpu, u16Port, uValue, OP_SIZE / 8);

  • trunk/src/VBox/VMM/VMMAll/IOMAll.cpp

    r45301 r45305  
    220220 *
    221221 * @param   pVM         Pointer to the VM.
     222 * @param   pVCpu       Pointer to the virtual CPU structure of the caller.
    222223 * @param   Port        The port to read.
    223224 * @param   pu32Value   Where to store the value read.
    224225 * @param   cbValue     The size of the register to read in bytes. 1, 2 or 4 bytes.
    225226 */
    226 VMMDECL(VBOXSTRICTRC) IOMIOPortRead(PVM pVM, RTIOPORT Port, uint32_t *pu32Value, size_t cbValue)
     227VMMDECL(VBOXSTRICTRC) IOMIOPortRead(PVM pVM, PVMCPU pVCpu, RTIOPORT Port, uint32_t *pu32Value, size_t cbValue)
    227228{
    228229/** @todo should initialize *pu32Value here because it can happen that some
    … …  
    243244     * Get the statistics record.
    244245     */
    245     PIOMIOPORTSTATS  pStats = pVM->iom.s.CTX_SUFF(pStatsLastRead);
     246    PIOMIOPORTSTATS  pStats = pVCpu->iom.s.CTX_SUFF(pStatsLastRead);
    246247    if (!pStats || pStats->Core.Key != Port)
    247248    {
    248249        pStats = (PIOMIOPORTSTATS)RTAvloIOPortGet(&pVM->iom.s.CTX_SUFF(pTrees)->IOPortStatTree, Port);
    249250        if (pStats)
    250             pVM->iom.s.CTX_SUFF(pStatsLastRead) = pStats;
     251            pVCpu->iom.s.CTX_SUFF(pStatsLastRead) = pStats;
    251252    }
    252253#endif
    … …  
    255256     * Get handler for current context.
    256257     */
    257     CTX_SUFF(PIOMIOPORTRANGE) pRange = pVM->iom.s.CTX_SUFF(pRangeLastRead);
     258    CTX_SUFF(PIOMIOPORTRANGE) pRange = pVCpu->iom.s.CTX_SUFF(pRangeLastRead);
    258259    if (    !pRange
    259260        ||   (unsigned)Port - (unsigned)pRange->Port >= (unsigned)pRange->cPorts)
    … …  
    261262        pRange = iomIOPortGetRange(pVM, Port);
    262263        if (pRange)
    263             pVM->iom.s.CTX_SUFF(pRangeLastRead) = pRange;
     264            pVCpu->iom.s.CTX_SUFF(pRangeLastRead) = pRange;
    264265    }
    265266    MMHYPER_RC_ASSERT_RCPTR(pVM, pRange);
    … …  
    393394 *
    394395 * @param   pVM         Pointer to the VM.
     396 * @param   pVCpu       Pointer to the virtual CPU structure of the caller.
    395397 * @param   Port        The port to read.
    396398 * @param   pGCPtrDst   Pointer to the destination buffer (GC, incremented appropriately).
    … …  
    398400 * @param   cb          Size of the transfer unit (1, 2 or 4 bytes).
    399401 */
    400 VMMDECL(VBOXSTRICTRC) IOMIOPortReadString(PVM pVM, RTIOPORT Port, PRTGCPTR pGCPtrDst, PRTGCUINTREG pcTransfers, unsigned cb)
     402VMMDECL(VBOXSTRICTRC) IOMIOPortReadString(PVM pVM, PVMCPU pVCpu, RTIOPORT Port,
     403                                          PRTGCPTR pGCPtrDst, PRTGCUINTREG pcTransfers, unsigned cb)
    401404{
    402405    /* Take the IOM lock before performing any device I/O. */
    … …  
    418421     * Get the statistics record.
    419422     */
    420     PIOMIOPORTSTATS pStats = pVM->iom.s.CTX_SUFF(pStatsLastRead);
     423    PIOMIOPORTSTATS pStats = pVCpu->iom.s.CTX_SUFF(pStatsLastRead);
    421424    if (!pStats || pStats->Core.Key != Port)
    422425    {
    423426        pStats = (PIOMIOPORTSTATS)RTAvloIOPortGet(&pVM->iom.s.CTX_SUFF(pTrees)->IOPortStatTree, Port);
    424427        if (pStats)
    425             pVM->iom.s.CTX_SUFF(pStatsLastRead) = pStats;
     428            pVCpu->iom.s.CTX_SUFF(pStatsLastRead) = pStats;
    426429    }
    427430#endif
    … …  
    430433     * Get handler for current context.
    431434     */
    432     CTX_SUFF(PIOMIOPORTRANGE) pRange = pVM->iom.s.CTX_SUFF(pRangeLastRead);
     435    CTX_SUFF(PIOMIOPORTRANGE) pRange = pVCpu->iom.s.CTX_SUFF(pRangeLastRead);
    433436    if (    !pRange
    434437        ||   (unsigned)Port - (unsigned)pRange->Port >= (unsigned)pRange->cPorts)
    … …  
    436439        pRange = iomIOPortGetRange(pVM, Port);
    437440        if (pRange)
    438             pVM->iom.s.CTX_SUFF(pRangeLastRead) = pRange;
     441            pVCpu->iom.s.CTX_SUFF(pRangeLastRead) = pRange;
    439442    }
    440443    MMHYPER_RC_ASSERT_RCPTR(pVM, pRange);
    … …  
    545548 *
    546549 * @param   pVM         Pointer to the VM.
     550 * @param   pVCpu       Pointer to the virtual CPU structure of the caller.
    547551 * @param   Port        The port to write to.
    548552 * @param   u32Value    The value to write.
    549553 * @param   cbValue     The size of the register to read in bytes. 1, 2 or 4 bytes.
    550554 */
    551 VMMDECL(VBOXSTRICTRC) IOMIOPortWrite(PVM pVM, RTIOPORT Port, uint32_t u32Value, size_t cbValue)
     555VMMDECL(VBOXSTRICTRC) IOMIOPortWrite(PVM pVM, PVMCPU pVCpu, RTIOPORT Port, uint32_t u32Value, size_t cbValue)
    552556{
    553557    /* Take the IOM lock before performing any device I/O. */
    … …  
    568572     * Find the statistics record.
    569573     */
    570     PIOMIOPORTSTATS pStats = pVM->iom.s.CTX_SUFF(pStatsLastWrite);
     574    PIOMIOPORTSTATS pStats = pVCpu->iom.s.CTX_SUFF(pStatsLastWrite);
    571575    if (!pStats || pStats->Core.Key != Port)
    572576    {
    573577        pStats = (PIOMIOPORTSTATS)RTAvloIOPortGet(&pVM->iom.s.CTX_SUFF(pTrees)->IOPortStatTree, Port);
    574578        if (pStats)
    575             pVM->iom.s.CTX_SUFF(pStatsLastWrite) = pStats;
     579            pVCpu->iom.s.CTX_SUFF(pStatsLastWrite) = pStats;
    576580    }
    577581#endif
    … …  
    580584     * Get handler for current context.
    581585     */
    582     CTX_SUFF(PIOMIOPORTRANGE) pRange = pVM->iom.s.CTX_SUFF(pRangeLastWrite);
     586    CTX_SUFF(PIOMIOPORTRANGE) pRange = pVCpu->iom.s.CTX_SUFF(pRangeLastWrite);
    583587    if (    !pRange
    584588        ||   (unsigned)Port - (unsigned)pRange->Port >= (unsigned)pRange->cPorts)
    … …  
    586590        pRange = iomIOPortGetRange(pVM, Port);
    587591        if (pRange)
    588             pVM->iom.s.CTX_SUFF(pRangeLastWrite) = pRange;
     592            pVCpu->iom.s.CTX_SUFF(pRangeLastWrite) = pRange;
    589593    }
    590594    MMHYPER_RC_ASSERT_RCPTR(pVM, pRange);
    … …  
    693697 *
    694698 * @param   pVM         Pointer to the VM.
     699 * @param   pVCpu       Pointer to the virtual CPU structure of the caller.
    695700 * @param   Port        The port to write.
    696701 * @param   pGCPtrSrc   Pointer to the source buffer (GC, incremented appropriately).
    697702 * @param   pcTransfers Pointer to the number of transfer units to write, on return remaining transfer units.
    698703 * @param   cb          Size of the transfer unit (1, 2 or 4 bytes).
    699  *   */
    700 VMMDECL(VBOXSTRICTRC) IOMIOPortWriteString(PVM pVM, RTIOPORT Port, PRTGCPTR pGCPtrSrc, PRTGCUINTREG pcTransfers, unsigned cb)
     704 */
     705VMMDECL(VBOXSTRICTRC) IOMIOPortWriteString(PVM pVM, PVMCPU pVCpu, RTIOPORT Port,
     706                                           PRTGCPTR pGCPtrSrc, PRTGCUINTREG pcTransfers, unsigned cb)
    701707{
    702708    /* Take the IOM lock before performing any device I/O. */
    … …  
    718724     * Get the statistics record.
    719725     */
    720     PIOMIOPORTSTATS     pStats = pVM->iom.s.CTX_SUFF(pStatsLastWrite);
     726    PIOMIOPORTSTATS     pStats = pVCpu->iom.s.CTX_SUFF(pStatsLastWrite);
    721727    if (!pStats || pStats->Core.Key != Port)
    722728    {
    723729        pStats = (PIOMIOPORTSTATS)RTAvloIOPortGet(&pVM->iom.s.CTX_SUFF(pTrees)->IOPortStatTree, Port);
    724730        if (pStats)
    725             pVM->iom.s.CTX_SUFF(pStatsLastWrite) = pStats;
     731            pVCpu->iom.s.CTX_SUFF(pStatsLastWrite) = pStats;
    726732    }
    727733#endif
    … …  
    730736     * Get handler for current context.
    731737     */
    732     CTX_SUFF(PIOMIOPORTRANGE) pRange = pVM->iom.s.CTX_SUFF(pRangeLastWrite);
     738    CTX_SUFF(PIOMIOPORTRANGE) pRange = pVCpu->iom.s.CTX_SUFF(pRangeLastWrite);
    733739    if (    !pRange
    734740        ||   (unsigned)Port - (unsigned)pRange->Port >= (unsigned)pRange->cPorts)
    … …  
    736742        pRange = iomIOPortGetRange(pVM, Port);
    737743        if (pRange)
    738             pVM->iom.s.CTX_SUFF(pRangeLastWrite) = pRange;
     744            pVCpu->iom.s.CTX_SUFF(pRangeLastWrite) = pRange;
    739745    }
    740746    MMHYPER_RC_ASSERT_RCPTR(pVM, pRange);
    … …  
    947953 *
    948954 * @param   pVM         The virtual machine (GC pointer of course).
     955 * @param   pVCpu       Pointer to the virtual CPU structure of the caller.
    949956 * @param   pRegFrame   Pointer to CPUMCTXCORE guest registers structure.
    950957 * @param   pCpu        Disassembler CPU state.
    951958 */
    952 VMMDECL(VBOXSTRICTRC) IOMInterpretIN(PVM pVM, PCPUMCTXCORE pRegFrame, PDISCPUSTATE pCpu)
     959VMMDECL(VBOXSTRICTRC) IOMInterpretIN(PVM pVM, PVMCPU pVCpu, PCPUMCTXCORE pRegFrame, PDISCPUSTATE pCpu)
    953960{
    954961#ifdef IN_RC
    … …  
    974981         */
    975982        uint32_t u32Data = UINT32_C(0xffffffff);
    976         rcStrict = IOMIOPortRead(pVM, uPort, &u32Data, cbSize);
     983        rcStrict = IOMIOPortRead(pVM, pVCpu, uPort, &u32Data, cbSize);
    977984        if (IOM_SUCCESS(rcStrict))
    978985        {
    … …  
    10071014 *
    10081015 * @param   pVM         The virtual machine (GC pointer of course).
     1016 * @param   pVCpu       Pointer to the virtual CPU structure of the caller.
    10091017 * @param   pRegFrame   Pointer to CPUMCTXCORE guest registers structure.
    10101018 * @param   pCpu        Disassembler CPU state.
    10111019 */
    1012 VMMDECL(VBOXSTRICTRC) IOMInterpretOUT(PVM pVM, PCPUMCTXCORE pRegFrame, PDISCPUSTATE pCpu)
     1020VMMDECL(VBOXSTRICTRC) IOMInterpretOUT(PVM pVM, PVMCPU pVCpu, PCPUMCTXCORE pRegFrame, PDISCPUSTATE pCpu)
    10131021{
    10141022#ifdef IN_RC
    … …  
    10351043         * Attempt to write to the port.
    10361044         */
    1037         rcStrict = IOMIOPortWrite(pVM, uPort, u64Data, cbSize);
     1045        rcStrict = IOMIOPortWrite(pVM, pVCpu, uPort, u64Data, cbSize);
    10381046        AssertMsg(rcStrict == VINF_SUCCESS || rcStrict == VINF_IOM_R3_IOPORT_WRITE || (rcStrict >= VINF_EM_FIRST && rcStrict <= VINF_EM_LAST) || RT_FAILURE(rcStrict), ("%Rrc\n", VBOXSTRICTRC_VAL(rcStrict)));
    10391047    }

  • trunk/src/VBox/VMM/VMMAll/IOMAllMMIO.cpp

    r44715 r45305  
    274274 * @warning RT_SUCCESS(rc=VINF_IOM_R3_MMIO_WRITE) is TRUE!
    275275 */
    276 static int iomMMIODoWrite(PVM pVM, PIOMMMIORANGE pRange, RTGCPHYS GCPhysFault, const void *pvData, unsigned cb)
     276static int iomMMIODoWrite(PVM pVM, PVMCPU pVCpu, PIOMMMIORANGE pRange, RTGCPHYS GCPhysFault, const void *pvData, unsigned cb)
    277277{
    278278#ifdef VBOX_WITH_STATISTICS
    279     PIOMMMIOSTATS pStats = iomMmioGetStats(pVM, GCPhysFault, pRange);
     279    PIOMMMIOSTATS pStats = iomMmioGetStats(pVM, pVCpu, GCPhysFault, pRange);
    280280    Assert(pStats);
    281281#endif
    … …  
    481481 * Wrapper which does the read and updates range statistics when such are enabled.
    482482 */
    483 DECLINLINE(int) iomMMIODoRead(PVM pVM, PIOMMMIORANGE pRange, RTGCPHYS GCPhys, void *pvValue, unsigned cbValue)
     483DECLINLINE(int) iomMMIODoRead(PVM pVM, PVMCPU pVCpu, PIOMMMIORANGE pRange, RTGCPHYS GCPhys, void *pvValue, unsigned cbValue)
    484484{
    485485#ifdef VBOX_WITH_STATISTICS
    486     PIOMMMIOSTATS pStats = iomMmioGetStats(pVM, GCPhys, pRange);
     486    PIOMMMIOSTATS pStats = iomMmioGetStats(pVM, pVCpu, GCPhys, pRange);
    487487    Assert(pStats);
    488488    STAM_PROFILE_START(&pStats->CTX_SUFF_Z(ProfRead), a);
    … …  
    557557 *
    558558 * @param   pVM         The virtual machine.
     559 * @param   pVCpu       Pointer to the virtual CPU structure of the caller.
    559560 * @param   pRegFrame   Pointer to CPUMCTXCORE guest registers structure.
    560561 * @param   pCpu        Disassembler CPU state.
    … …  
    562563 * @param   GCPhysFault The GC physical address corresponding to pvFault.
    563564 */
    564 static int iomInterpretMOVxXRead(PVM pVM, PCPUMCTXCORE pRegFrame, PDISCPUSTATE pCpu, PIOMMMIORANGE pRange, RTGCPHYS GCPhysFault)
     565static int iomInterpretMOVxXRead(PVM pVM, PVMCPU pVCpu, PCPUMCTXCORE pRegFrame, PDISCPUSTATE pCpu,
     566                                 PIOMMMIORANGE pRange, RTGCPHYS GCPhysFault)
    565567{
    566568    Assert(pRange->CTX_SUFF(pfnReadCallback) || !pRange->pfnReadCallbackR3);
    … …  
    574576
    575577    uint64_t u64Data = 0;
    576     int rc = iomMMIODoRead(pVM, pRange, GCPhysFault, &u64Data, cb);
     578    int rc = iomMMIODoRead(pVM, pVCpu, pRange, GCPhysFault, &u64Data, cb);
    577579    if (rc == VINF_SUCCESS)
    578580    {
    … …  
    616618 *
    617619 * @param   pVM         The virtual machine.
     620 * @param   pVCpu       Pointer to the virtual CPU structure of the caller.
    618621 * @param   pRegFrame   Pointer to CPUMCTXCORE guest registers structure.
    619622 * @param   pCpu        Disassembler CPU state.
    … …  
    621624 * @param   GCPhysFault The GC physical address corresponding to pvFault.
    622625 */
    623 static int iomInterpretMOVxXWrite(PVM pVM, PCPUMCTXCORE pRegFrame, PDISCPUSTATE pCpu, PIOMMMIORANGE pRange, RTGCPHYS GCPhysFault)
     626static int iomInterpretMOVxXWrite(PVM pVM, PVMCPU pVCpu, PCPUMCTXCORE pRegFrame, PDISCPUSTATE pCpu,
     627                                  PIOMMMIORANGE pRange, RTGCPHYS GCPhysFault)
    624628{
    625629    Assert(pRange->CTX_SUFF(pfnWriteCallback) || !pRange->pfnWriteCallbackR3);
    … …  
    634638    AssertMsg(fRc, ("Failed to get reg/imm port number!\n")); NOREF(fRc);
    635639
    636     int rc = iomMMIODoWrite(pVM, pRange, GCPhysFault, &u64Data, cb);
     640    int rc = iomMMIODoWrite(pVM, pVCpu, pRange, GCPhysFault, &u64Data, cb);
    637641    if (rc == VINF_SUCCESS)
    638642        iomMMIOStatLength(pVM, cb);
    … …  
    950954 *
    951955 * @param   pVM         The virtual machine.
     956 * @param   pVCpu       Pointer to the virtual CPU structure of the caller.
    952957 * @param   pRegFrame   Trap register frame.
    953958 * @param   GCPhysFault The GC physical address corresponding to pvFault.
    … …  
    955960 * @param   pRange      Pointer MMIO range.
    956961 */
    957 static int iomInterpretSTOS(PVM pVM, PCPUMCTXCORE pRegFrame, RTGCPHYS GCPhysFault, PDISCPUSTATE pCpu, PIOMMMIORANGE pRange)
     962static int iomInterpretSTOS(PVM pVM, PVMCPU pVCpu, PCPUMCTXCORE pRegFrame, RTGCPHYS GCPhysFault,
     963                            PDISCPUSTATE pCpu, PIOMMMIORANGE pRange)
    958964{
    959965    /*
    … …  
    10461052        do
    10471053        {
    1048             rc = iomMMIODoWrite(pVM, pRange, Phys, &u64Data, cb);
     1054            rc = iomMMIODoWrite(pVM, pVCpu, pRange, Phys, &u64Data, cb);
    10491055            if (rc != VINF_SUCCESS)
    10501056                break;
    … …  
    10821088 *
    10831089 * @param   pVM         The virtual machine.
     1090 * @param   pVCpu       Pointer to the virtual CPU structure of the caller.
    10841091 * @param   pRegFrame   Trap register frame.
    10851092 * @param   GCPhysFault The GC physical address corresponding to pvFault.
    … …  
    10871094 * @param   pRange      Pointer MMIO range.
    10881095 */
    1089 static int iomInterpretLODS(PVM pVM, PCPUMCTXCORE pRegFrame, RTGCPHYS GCPhysFault, PDISCPUSTATE pCpu, PIOMMMIORANGE pRange)
     1096static int iomInterpretLODS(PVM pVM, PVMCPU pVCpu, PCPUMCTXCORE pRegFrame, RTGCPHYS GCPhysFault, PDISCPUSTATE pCpu,
     1097                            PIOMMMIORANGE pRange)
    10901098{
    10911099    Assert(pRange->CTX_SUFF(pfnReadCallback) || !pRange->pfnReadCallbackR3);
    … …  
    11071115     * Perform read.
    11081116     */
    1109     int rc = iomMMIODoRead(pVM, pRange, GCPhysFault, &pRegFrame->rax, cb);
     1117    int rc = iomMMIODoRead(pVM, pVCpu, pRange, GCPhysFault, &pRegFrame->rax, cb);
    11101118    if (rc == VINF_SUCCESS)
    11111119    {
    … …  
    11391147 * @param   pRange      Pointer MMIO range.
    11401148 */
    1141 static int iomInterpretCMP(PVM pVM, PCPUMCTXCORE pRegFrame, RTGCPHYS GCPhysFault, PDISCPUSTATE pCpu, PIOMMMIORANGE pRange)
     1149static int iomInterpretCMP(PVM pVM, PVMCPU pVCpu, PCPUMCTXCORE pRegFrame, RTGCPHYS GCPhysFault, PDISCPUSTATE pCpu,
     1150                           PIOMMMIORANGE pRange)
    11421151{
    11431152    Assert(pRange->CTX_SUFF(pfnReadCallback) || !pRange->pfnReadCallbackR3);
    … …  
    11521161    if (iomGetRegImmData(pCpu, &pCpu->Param1, pRegFrame, &uData1, &cb))
    11531162        /* cmp reg, [MMIO]. */
    1154         rc = iomMMIODoRead(pVM, pRange, GCPhysFault, &uData2, cb);
     1163        rc = iomMMIODoRead(pVM, pVCpu, pRange, GCPhysFault, &uData2, cb);
    11551164    else if (iomGetRegImmData(pCpu, &pCpu->Param2, pRegFrame, &uData2, &cb))
    11561165        /* cmp [MMIO], reg|imm. */
    1157         rc = iomMMIODoRead(pVM, pRange, GCPhysFault, &uData1, cb);
     1166        rc = iomMMIODoRead(pVM, pVCpu, pRange, GCPhysFault, &uData1, cb);
    11581167    else
    11591168    {
    … …  
    11921201 *
    11931202 * @param   pVM         The virtual machine.
     1203 * @param   pVCpu       Pointer to the virtual CPU structure of the caller.
    11941204 * @param   pRegFrame   Trap register frame.
    11951205 * @param   GCPhysFault The GC physical address corresponding to pvFault.
    … …  
    11981208 * @param   pfnEmulate  Instruction emulation function.
    11991209 */
    1200 static int iomInterpretOrXorAnd(PVM pVM, PCPUMCTXCORE pRegFrame, RTGCPHYS GCPhysFault, PDISCPUSTATE pCpu, PIOMMMIORANGE pRange, PFNEMULATEPARAM3 pfnEmulate)
     1210static int iomInterpretOrXorAnd(PVM pVM, PVMCPU pVCpu, PCPUMCTXCORE pRegFrame, RTGCPHYS GCPhysFault, PDISCPUSTATE pCpu,
     1211                                PIOMMMIORANGE pRange, PFNEMULATEPARAM3 pfnEmulate)
    12011212{
    12021213    unsigned    cb     = 0;
    … …  
    12291240        Assert(pRange->CTX_SUFF(pfnReadCallback) || !pRange->pfnReadCallbackR3);
    12301241        fAndWrite = false;
    1231         rc = iomMMIODoRead(pVM, pRange, GCPhysFault, &uData2, cb);
     1242        rc = iomMMIODoRead(pVM, pVCpu, pRange, GCPhysFault, &uData2, cb);
    12321243    }
    12331244    else if (iomGetRegImmData(pCpu, &pCpu->Param2, pRegFrame, &uData2, &cb))
    … …  
    12421253        if (    (pRange->CTX_SUFF(pfnReadCallback) || !pRange->pfnReadCallbackR3)
    12431254            &&  (pRange->CTX_SUFF(pfnWriteCallback) || !pRange->pfnWriteCallbackR3))
    1244             rc = iomMMIODoRead(pVM, pRange, GCPhysFault, &uData1, cb);
     1255            rc = iomMMIODoRead(pVM, pVCpu, pRange, GCPhysFault, &uData1, cb);
    12451256        else
    12461257            rc = VINF_IOM_R3_MMIO_READ_WRITE;
    … …  
    12611272        if (fAndWrite)
    12621273            /* Store result to MMIO. */
    1263             rc = iomMMIODoWrite(pVM, pRange, GCPhysFault, &uData1, cb);
     1274            rc = iomMMIODoWrite(pVM, pVCpu, pRange, GCPhysFault, &uData1, cb);
    12641275        else
    12651276        {
    … …  
    12911302 *
    12921303 * @param   pVM         The virtual machine.
     1304 * @param   pVCpu       Pointer to the virtual CPU structure of the caller.
    12931305 * @param   pRegFrame   Trap register frame.
    12941306 * @param   GCPhysFault The GC physical address corresponding to pvFault.
    … …  
    12961308 * @param   pRange      Pointer MMIO range.
    12971309 */
    1298 static int iomInterpretTEST(PVM pVM, PCPUMCTXCORE pRegFrame, RTGCPHYS GCPhysFault, PDISCPUSTATE pCpu, PIOMMMIORANGE pRange)
     1310static int iomInterpretTEST(PVM pVM, PVMCPU pVCpu, PCPUMCTXCORE pRegFrame, RTGCPHYS GCPhysFault, PDISCPUSTATE pCpu,
     1311                            PIOMMMIORANGE pRange)
    12991312{
    13001313    Assert(pRange->CTX_SUFF(pfnReadCallback) || !pRange->pfnReadCallbackR3);
    … …  
    13081321    {
    13091322        /* and test, [MMIO]. */
    1310         rc = iomMMIODoRead(pVM, pRange, GCPhysFault, &uData2, cb);
     1323        rc = iomMMIODoRead(pVM, pVCpu, pRange, GCPhysFault, &uData2, cb);
    13111324    }
    13121325    else if (iomGetRegImmData(pCpu, &pCpu->Param2, pRegFrame, &uData2, &cb))
    13131326    {
    13141327        /* test [MMIO], reg|imm. */
    1315         rc = iomMMIODoRead(pVM, pRange, GCPhysFault, &uData1, cb);
     1328        rc = iomMMIODoRead(pVM, pVCpu, pRange, GCPhysFault, &uData1, cb);
    13161329    }
    13171330    else
    … …  
    13491362 *
    13501363 * @param   pVM         The virtual machine.
     1364 * @param   pVCpu       Pointer to the virtual CPU structure of the caller.
    13511365 * @param   pRegFrame   Trap register frame.
    13521366 * @param   GCPhysFault The GC physical address corresponding to pvFault.
    … …  
    13541368 * @param   pRange      Pointer MMIO range.
    13551369 */
    1356 static int iomInterpretBT(PVM pVM, PCPUMCTXCORE pRegFrame, RTGCPHYS GCPhysFault, PDISCPUSTATE pCpu, PIOMMMIORANGE pRange)
     1370static int iomInterpretBT(PVM pVM, PVMCPU pVCpu, PCPUMCTXCORE pRegFrame, RTGCPHYS GCPhysFault, PDISCPUSTATE pCpu,
     1371                          PIOMMMIORANGE pRange)
    13571372{
    13581373    Assert(pRange->CTX_SUFF(pfnReadCallback) || !pRange->pfnReadCallbackR3);
    … …  
    13711386
    13721387    /* bt [MMIO], reg|imm. */
    1373     int rc = iomMMIODoRead(pVM, pRange, GCPhysFault, &uData, cbData);
     1388    int rc = iomMMIODoRead(pVM, pVCpu, pRange, GCPhysFault, &uData, cbData);
    13741389    if (rc == VINF_SUCCESS)
    13751390    {
    … …  
    13921407 *
    13931408 * @param   pVM         The virtual machine.
     1409 * @param   pVCpu       Pointer to the virtual CPU structure of the caller.
    13941410 * @param   pRegFrame   Trap register frame.
    13951411 * @param   GCPhysFault The GC physical address corresponding to pvFault.
    … …  
    13971413 * @param   pRange      Pointer MMIO range.
    13981414 */
    1399 static int iomInterpretXCHG(PVM pVM, PCPUMCTXCORE pRegFrame, RTGCPHYS GCPhysFault, PDISCPUSTATE pCpu, PIOMMMIORANGE pRange)
     1415static int iomInterpretXCHG(PVM pVM, PVMCPU pVCpu, PCPUMCTXCORE pRegFrame, RTGCPHYS GCPhysFault, PDISCPUSTATE pCpu,
     1416                            PIOMMMIORANGE pRange)
    14001417{
    14011418    /* Check for read & write handlers since IOMMMIOHandler doesn't cover this. */
    … …  
    14111428    {
    14121429        /* xchg reg, [MMIO]. */
    1413         rc = iomMMIODoRead(pVM, pRange, GCPhysFault, &uData2, cb);
     1430        rc = iomMMIODoRead(pVM, pVCpu, pRange, GCPhysFault, &uData2, cb);
    14141431        if (rc == VINF_SUCCESS)
    14151432        {
    14161433            /* Store result to MMIO. */
    1417             rc = iomMMIODoWrite(pVM, pRange, GCPhysFault, &uData1, cb);
     1434            rc = iomMMIODoWrite(pVM, pVCpu, pRange, GCPhysFault, &uData1, cb);
    14181435
    14191436            if (rc == VINF_SUCCESS)
    … …  
    14321449    {
    14331450        /* xchg [MMIO], reg. */
    1434         rc = iomMMIODoRead(pVM, pRange, GCPhysFault, &uData1, cb);
     1451        rc = iomMMIODoRead(pVM, pVCpu, pRange, GCPhysFault, &uData1, cb);
    14351452        if (rc == VINF_SUCCESS)
    14361453        {
    14371454            /* Store result to MMIO. */
    1438             rc = iomMMIODoWrite(pVM, pRange, GCPhysFault, &uData2, cb);
     1455            rc = iomMMIODoWrite(pVM, pVCpu, pRange, GCPhysFault, &uData2, cb);
    14391456            if (rc == VINF_SUCCESS)
    14401457            {
    … …  
    14631480 * @returns VBox status code (appropriate for GC return).
    14641481 * @param   pVM         Pointer to the VM.
     1482 * @param   pVCpu       Pointer to the virtual CPU structure of the caller.
    14651483 * @param   uErrorCode  CPU Error code.  This is UINT32_MAX when we don't have
    14661484 *                      any error code (the EPT misconfig hack).
    … …  
    14691487 * @param   pvUser      Pointer to the MMIO ring-3 range entry.
    14701488 */
    1471 static int iomMMIOHandler(PVM pVM, uint32_t uErrorCode, PCPUMCTXCORE pCtxCore, RTGCPHYS GCPhysFault, void *pvUser)
    1472 {
    1473     /* Take the IOM lock before performing any MMIO. */
     1489static int iomMMIOHandler(PVM pVM, PVMCPU pVCpu, uint32_t uErrorCode, PCPUMCTXCORE pCtxCore, RTGCPHYS GCPhysFault, void *pvUser)
     1490{
    14741491    int rc = IOM_LOCK(pVM);
    14751492#ifndef IN_RING3
    … …  
    14801497
    14811498    STAM_PROFILE_START(&pVM->iom.s.StatRZMMIOHandler, a);
    1482     Log(("iomMMIOHandler: GCPhys=%RGp uErr=%#x rip=%RGv\n",
    1483          GCPhysFault, uErrorCode, (RTGCPTR)pCtxCore->rip));
     1499    Log(("iomMMIOHandler: GCPhys=%RGp uErr=%#x rip=%RGv\n", GCPhysFault, uErrorCode, (RTGCPTR)pCtxCore->rip));
    14841500
    14851501    PIOMMMIORANGE pRange = (PIOMMMIORANGE)pvUser;
    14861502    Assert(pRange);
    1487     Assert(pRange == iomMmioGetRange(pVM, GCPhysFault));
     1503    Assert(pRange == iomMmioGetRange(pVM, pVCpu, GCPhysFault));
    14881504
    14891505#ifdef VBOX_WITH_STATISTICS
    … …  
    14911507     * Locate the statistics, if > PAGE_SIZE we'll use the first byte for everything.
    14921508     */
    1493     PIOMMMIOSTATS pStats = iomMmioGetStats(pVM, GCPhysFault, pRange);
     1509    PIOMMMIOSTATS pStats = iomMmioGetStats(pVM, pVCpu, GCPhysFault, pRange);
    14941510    if (!pStats)
    14951511    {
    … …  
    15501566     * Disassemble the instruction and interpret it.
    15511567     */
    1552     PVMCPU          pVCpu = VMMGetCpu(pVM);
    15531568    PDISCPUSTATE    pDis  = &pVCpu->iom.s.DisState;
    15541569    unsigned        cbOp;
    … …  
    15711586                ? uErrorCode & X86_TRAP_PF_RW
    15721587                : DISUSE_IS_EFFECTIVE_ADDR(pDis->Param1.fUse))
    1573                 rc = iomInterpretMOVxXWrite(pVM, pCtxCore, pDis, pRange, GCPhysFault);
     1588                rc = iomInterpretMOVxXWrite(pVM, pVCpu, pCtxCore, pDis, pRange, GCPhysFault);
    15741589            else
    1575                 rc = iomInterpretMOVxXRead(pVM, pCtxCore, pDis, pRange, GCPhysFault);
     1590                rc = iomInterpretMOVxXRead(pVM, pVCpu, pCtxCore, pDis, pRange, GCPhysFault);
    15761591            STAM_PROFILE_STOP(&pVM->iom.s.StatRZInstMov, b);
    15771592            break;
    … …  
    16001615            Assert(uErrorCode & X86_TRAP_PF_RW);
    16011616            STAM_PROFILE_START(&pVM->iom.s.StatRZInstStos, d);
    1602             rc = iomInterpretSTOS(pVM, pCtxCore, GCPhysFault, pDis, pRange);
     1617            rc = iomInterpretSTOS(pVM, pVCpu, pCtxCore, GCPhysFault, pDis, pRange);
    16031618            STAM_PROFILE_STOP(&pVM->iom.s.StatRZInstStos, d);
    16041619            break;
    … …  
    16081623            Assert(!(uErrorCode & X86_TRAP_PF_RW) || uErrorCode == UINT32_MAX);
    16091624            STAM_PROFILE_START(&pVM->iom.s.StatRZInstLods, e);
    1610             rc = iomInterpretLODS(pVM, pCtxCore, GCPhysFault, pDis, pRange);
     1625            rc = iomInterpretLODS(pVM, pVCpu, pCtxCore, GCPhysFault, pDis, pRange);
    16111626            STAM_PROFILE_STOP(&pVM->iom.s.StatRZInstLods, e);
    16121627            break;
    … …  
    16151630            Assert(!(uErrorCode & X86_TRAP_PF_RW) || uErrorCode == UINT32_MAX);
    16161631            STAM_PROFILE_START(&pVM->iom.s.StatRZInstCmp, f);
    1617             rc = iomInterpretCMP(pVM, pCtxCore, GCPhysFault, pDis, pRange);
     1632            rc = iomInterpretCMP(pVM, pVCpu, pCtxCore, GCPhysFault, pDis, pRange);
    16181633            STAM_PROFILE_STOP(&pVM->iom.s.StatRZInstCmp, f);
    16191634            break;
    … …  
    16211636        case OP_AND:
    16221637            STAM_PROFILE_START(&pVM->iom.s.StatRZInstAnd, g);
    1623             rc = iomInterpretOrXorAnd(pVM, pCtxCore, GCPhysFault, pDis, pRange, EMEmulateAnd);
     1638            rc = iomInterpretOrXorAnd(pVM, pVCpu, pCtxCore, GCPhysFault, pDis, pRange, EMEmulateAnd);
    16241639            STAM_PROFILE_STOP(&pVM->iom.s.StatRZInstAnd, g);
    16251640            break;
    … …  
    16271642        case OP_OR:
    16281643            STAM_PROFILE_START(&pVM->iom.s.StatRZInstOr, k);
    1629             rc = iomInterpretOrXorAnd(pVM, pCtxCore, GCPhysFault, pDis, pRange, EMEmulateOr);
     1644            rc = iomInterpretOrXorAnd(pVM, pVCpu, pCtxCore, GCPhysFault, pDis, pRange, EMEmulateOr);
    16301645            STAM_PROFILE_STOP(&pVM->iom.s.StatRZInstOr, k);
    16311646            break;
    … …  
    16331648        case OP_XOR:
    16341649            STAM_PROFILE_START(&pVM->iom.s.StatRZInstXor, m);
    1635             rc = iomInterpretOrXorAnd(pVM, pCtxCore, GCPhysFault, pDis, pRange, EMEmulateXor);
     1650            rc = iomInterpretOrXorAnd(pVM, pVCpu, pCtxCore, GCPhysFault, pDis, pRange, EMEmulateXor);
    16361651            STAM_PROFILE_STOP(&pVM->iom.s.StatRZInstXor, m);
    16371652            break;
    … …  
    16401655            Assert(!(uErrorCode & X86_TRAP_PF_RW) || uErrorCode == UINT32_MAX);
    16411656            STAM_PROFILE_START(&pVM->iom.s.StatRZInstTest, h);
    1642             rc = iomInterpretTEST(pVM, pCtxCore, GCPhysFault, pDis, pRange);
     1657            rc = iomInterpretTEST(pVM, pVCpu, pCtxCore, GCPhysFault, pDis, pRange);
    16431658            STAM_PROFILE_STOP(&pVM->iom.s.StatRZInstTest, h);
    16441659            break;
    … …  
    16471662            Assert(!(uErrorCode & X86_TRAP_PF_RW) || uErrorCode == UINT32_MAX);
    16481663            STAM_PROFILE_START(&pVM->iom.s.StatRZInstBt, l);
    1649             rc = iomInterpretBT(pVM, pCtxCore, GCPhysFault, pDis, pRange);
     1664            rc = iomInterpretBT(pVM, pVCpu, pCtxCore, GCPhysFault, pDis, pRange);
    16501665            STAM_PROFILE_STOP(&pVM->iom.s.StatRZInstBt, l);
    16511666            break;
    … …  
    16531668        case OP_XCHG:
    16541669            STAM_PROFILE_START(&pVM->iom.s.StatRZInstXchg, i);
    1655             rc = iomInterpretXCHG(pVM, pCtxCore, GCPhysFault, pDis, pRange);
     1670            rc = iomInterpretXCHG(pVM, pVCpu, pCtxCore, GCPhysFault, pDis, pRange);
    16561671            STAM_PROFILE_STOP(&pVM->iom.s.StatRZInstXchg, i);
    16571672            break;
    … …  
    17101725    LogFlow(("IOMMMIOHandler: GCPhys=%RGp uErr=%#x pvFault=%RGv rip=%RGv\n",
    17111726             GCPhysFault, (uint32_t)uErrorCode, pvFault, (RTGCPTR)pCtxCore->rip));
    1712     VBOXSTRICTRC rcStrict = iomMMIOHandler(pVM, (uint32_t)uErrorCode, pCtxCore, GCPhysFault, pvUser);
     1727    VBOXSTRICTRC rcStrict = iomMMIOHandler(pVM, VMMGetCpu(pVM), (uint32_t)uErrorCode, pCtxCore, GCPhysFault, pvUser);
    17131728    return VBOXSTRICTRC_VAL(rcStrict);
    17141729}
    … …  
    17191734 * @returns VBox status code (appropriate for GC return).
    17201735 * @param   pVM         Pointer to the VM.
     1736 * @param   pVCpu       Pointer to the virtual CPU structure of the caller.
    17211737 * @param   uErrorCode  CPU Error code.
    17221738 * @param   pCtxCore    Trap register frame.
    17231739 * @param   GCPhysFault The GC physical address.
    17241740 */
    1725 VMMDECL(VBOXSTRICTRC) IOMMMIOPhysHandler(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pCtxCore, RTGCPHYS GCPhysFault)
     1741VMMDECL(VBOXSTRICTRC) IOMMMIOPhysHandler(PVM pVM, PVMCPU pVCpu, RTGCUINT uErrorCode, PCPUMCTXCORE pCtxCore, RTGCPHYS GCPhysFault)
    17261742{
    17271743    int rc2 = IOM_LOCK(pVM); NOREF(rc2);
    … …  
    17301746        return VINF_IOM_R3_MMIO_READ_WRITE;
    17311747#endif
    1732     VBOXSTRICTRC rcStrict = iomMMIOHandler(pVM, (uint32_t)uErrorCode, pCtxCore, GCPhysFault, iomMmioGetRange(pVM, GCPhysFault));
     1748    VBOXSTRICTRC rcStrict = iomMMIOHandler(pVM, pVCpu, (uint32_t)uErrorCode, pCtxCore, GCPhysFault,
     1749                                           iomMmioGetRange(pVM, pVCpu, GCPhysFault));
    17331750    IOM_UNLOCK(pVM);
    17341751    return VBOXSTRICTRC_VAL(rcStrict);
    … …  
    17531770                                   PGMACCESSTYPE enmAccessType, void *pvUser)
    17541771{
     1772    PVMCPU        pVCpu = VMMGetCpu(pVM);
    17551773    PIOMMMIORANGE pRange = (PIOMMMIORANGE)pvUser;
    17561774    STAM_COUNTER_INC(&pVM->iom.s.StatR3MMIOHandler);
    … …  
    17651783    int rc = IOM_LOCK(pVM);
    17661784    AssertRC(rc);
    1767     Assert(pRange == iomMmioGetRange(pVM, GCPhysFault));
     1785    Assert(pRange == iomMmioGetRange(pVM, pVCpu, GCPhysFault));
    17681786
    17691787    /*
    … …  
    17841802     */
    17851803    if (enmAccessType == PGMACCESSTYPE_READ)
    1786         rc = iomMMIODoRead(pVM, pRange, GCPhysFault, pvBuf, (unsigned)cbBuf);
     1804        rc = iomMMIODoRead(pVM, pVCpu, pRange, GCPhysFault, pvBuf, (unsigned)cbBuf);
    17871805    else
    1788         rc = iomMMIODoWrite(pVM, pRange, GCPhysFault, pvBuf, (unsigned)cbBuf);
     1806        rc = iomMMIODoWrite(pVM, pVCpu, pRange, GCPhysFault, pvBuf, (unsigned)cbBuf);
    17891807
    17901808    AssertRC(rc);
    … …  
    18021820 *
    18031821 * @param   pVM         Pointer to the VM.
     1822 * @param   pVCpu       Pointer to the virtual CPU structure of the caller.
    18041823 * @param   GCPhys      The physical address to read.
    18051824 * @param   pu32Value   Where to store the value read.
    18061825 * @param   cbValue     The size of the register to read in bytes. 1, 2 or 4 bytes.
    18071826 */
    1808 VMMDECL(VBOXSTRICTRC) IOMMMIORead(PVM pVM, RTGCPHYS GCPhys, uint32_t *pu32Value, size_t cbValue)
     1827VMMDECL(VBOXSTRICTRC) IOMMMIORead(PVM pVM, PVMCPU pVCpu, RTGCPHYS GCPhys, uint32_t *pu32Value, size_t cbValue)
    18091828{
    18101829    /* Take the IOM lock before performing any MMIO. */
    … …  
    18221841     * Lookup the current context range node and statistics.
    18231842     */
    1824     PIOMMMIORANGE pRange = iomMmioGetRange(pVM, GCPhys);
     1843    PIOMMMIORANGE pRange = iomMmioGetRange(pVM, pVCpu, GCPhys);
    18251844    if (!pRange)
    18261845    {
    … …  
    18301849    }
    18311850#ifdef VBOX_WITH_STATISTICS
    1832     PIOMMMIOSTATS pStats = iomMmioGetStats(pVM, GCPhys, pRange);
     1851    PIOMMMIOSTATS pStats = iomMmioGetStats(pVM, pVCpu, GCPhys, pRange);
    18331852    if (!pStats)
    18341853    {
    … …  
    19311950 *
    19321951 * @param   pVM         Pointer to the VM.
     1952 * @param   pVCpu       Pointer to the virtual CPU structure of the caller.
    19331953 * @param   GCPhys      The physical address to write to.
    19341954 * @param   u32Value    The value to write.
    19351955 * @param   cbValue     The size of the register to read in bytes. 1, 2 or 4 bytes.
    19361956 */
    1937 VMMDECL(VBOXSTRICTRC) IOMMMIOWrite(PVM pVM, RTGCPHYS GCPhys, uint32_t u32Value, size_t cbValue)
     1957VMMDECL(VBOXSTRICTRC) IOMMMIOWrite(PVM pVM, PVMCPU pVCpu, RTGCPHYS GCPhys, uint32_t u32Value, size_t cbValue)
    19381958{
    19391959    /* Take the IOM lock before performing any MMIO. */
    … …  
    19511971     * Lookup the current context range node.
    19521972     */
    1953     PIOMMMIORANGE pRange = iomMmioGetRange(pVM, GCPhys);
     1973    PIOMMMIORANGE pRange = iomMmioGetRange(pVM, pVCpu, GCPhys);
    19541974    if (!pRange)
    19551975    {
    … …  
    19591979    }
    19601980#ifdef VBOX_WITH_STATISTICS
    1961     PIOMMMIOSTATS pStats = iomMmioGetStats(pVM, GCPhys, pRange);
     1981    PIOMMMIOSTATS pStats = iomMmioGetStats(pVM, pVCpu, GCPhys, pRange);
    19621982    if (!pStats)
    19631983    {
    … …  
    20472067 *
    20482068 * @param   pVM             The virtual machine.
     2069 * @param   pVCpu       Pointer to the virtual CPU structure of the caller.
    20492070 * @param   pRegFrame       Pointer to CPUMCTXCORE guest registers structure.
    20502071 * @param   uPort           IO Port
    … …  
    20532074 * @param   cbTransfer      Size of transfer unit
    20542075 */
    2055 VMMDECL(VBOXSTRICTRC) IOMInterpretINSEx(PVM pVM, PCPUMCTXCORE pRegFrame, uint32_t uPort, uint32_t uPrefix,
     2076VMMDECL(VBOXSTRICTRC) IOMInterpretINSEx(PVM pVM, PVMCPU pVCpu, PCPUMCTXCORE pRegFrame, uint32_t uPort, uint32_t uPrefix,
    20562077                                        DISCPUMODE enmAddrMode, uint32_t cbTransfer)
    20572078{
    … …  
    20652086        || pRegFrame->eflags.Bits.u1DF)
    20662087        return VINF_EM_RAW_EMULATE_INSTR;
    2067 
    2068     PVMCPU pVCpu = VMMGetCpu(pVM);
    20692088
    20702089    /*
    … …  
    21132132         * much as it wants. The rest is done with single-word transfers. */
    21142133        const RTGCUINTREG cTransfersOrg = cTransfers;
    2115         rcStrict = IOMIOPortReadString(pVM, uPort, &GCPtrDst, &cTransfers, cbTransfer);
     2134        rcStrict = IOMIOPortReadString(pVM, pVCpu, uPort, &GCPtrDst, &cTransfers, cbTransfer);
    21162135        AssertRC(VBOXSTRICTRC_VAL(rcStrict)); Assert(cTransfers <= cTransfersOrg);
    21172136        pRegFrame->rdi  = ((pRegFrame->rdi + (cTransfersOrg - cTransfers) * cbTransfer) & fAddrMask)
    … …  
    21252144    {
    21262145        uint32_t u32Value;
    2127         rcStrict = IOMIOPortRead(pVM, uPort, &u32Value, cbTransfer);
     2146        rcStrict = IOMIOPortRead(pVM, pVCpu, uPort, &u32Value, cbTransfer);
    21282147        if (!IOM_SUCCESS(rcStrict))
    21292148            break;
    … …  
    21652184 *
    21662185 * @param   pVM         The virtual machine.
     2186 * @param   pVCpu       Pointer to the virtual CPU structure of the caller.
    21672187 * @param   pRegFrame   Pointer to CPUMCTXCORE guest registers structure.
    21682188 * @param   pCpu        Disassembler CPU state.
    21692189 */
    2170 VMMDECL(VBOXSTRICTRC) IOMInterpretINS(PVM pVM, PCPUMCTXCORE pRegFrame, PDISCPUSTATE pCpu)
     2190VMMDECL(VBOXSTRICTRC) IOMInterpretINS(PVM pVM, PVMCPU pVCpu, PCPUMCTXCORE pRegFrame, PDISCPUSTATE pCpu)
    21712191{
    21722192    /*
    … …  
    21882208    }
    21892209
    2190     return IOMInterpretINSEx(pVM, pRegFrame, Port, pCpu->fPrefix, (DISCPUMODE)pCpu->uAddrMode, cb);
     2210    return IOMInterpretINSEx(pVM, pVCpu, pRegFrame, Port, pCpu->fPrefix, (DISCPUMODE)pCpu->uAddrMode, cb);
    21912211}
    21922212
    … …  
    22092229 *
    22102230 * @param   pVM             The virtual machine.
     2231 * @param   pVCpu       Pointer to the virtual CPU structure of the caller.
    22112232 * @param   pRegFrame       Pointer to CPUMCTXCORE guest registers structure.
    22122233 * @param   uPort           IO Port
    … …  
    22152236 * @param   cbTransfer      Size of transfer unit
    22162237 */
    2217 VMMDECL(VBOXSTRICTRC) IOMInterpretOUTSEx(PVM pVM, PCPUMCTXCORE pRegFrame, uint32_t uPort, uint32_t uPrefix,
     2238VMMDECL(VBOXSTRICTRC) IOMInterpretOUTSEx(PVM pVM, PVMCPU pVCpu, PCPUMCTXCORE pRegFrame, uint32_t uPort, uint32_t uPrefix,
    22182239                                         DISCPUMODE enmAddrMode, uint32_t cbTransfer)
    22192240{
    … …  
    22272248        || pRegFrame->eflags.Bits.u1DF)
    22282249        return VINF_EM_RAW_EMULATE_INSTR;
    2229 
    2230     PVMCPU pVCpu = VMMGetCpu(pVM);
    22312250
    22322251    /*
    … …  
    22772296         */
    22782297        const RTGCUINTREG cTransfersOrg = cTransfers;
    2279         rcStrict = IOMIOPortWriteString(pVM, uPort, &GCPtrSrc, &cTransfers, cbTransfer);
     2298        rcStrict = IOMIOPortWriteString(pVM, pVCpu, uPort, &GCPtrSrc, &cTransfers, cbTransfer);
    22802299        AssertRC(VBOXSTRICTRC_VAL(rcStrict)); Assert(cTransfers <= cTransfersOrg);
    22812300        pRegFrame->rsi  = ((pRegFrame->rsi + (cTransfersOrg - cTransfers) * cbTransfer) & fAddrMask)
    … …  
    22932312        if (rcStrict != VINF_SUCCESS)
    22942313            break;
    2295         rcStrict = IOMIOPortWrite(pVM, uPort, u32Value, cbTransfer);
     2314        rcStrict = IOMIOPortWrite(pVM, pVCpu, uPort, u32Value, cbTransfer);
    22962315        if (!IOM_SUCCESS(rcStrict))
    22972316            break;
    … …  
    23322351 *
    23332352 * @param   pVM         The virtual machine.
     2353 * @param   pVCpu       Pointer to the virtual CPU structure of the caller.
    23342354 * @param   pRegFrame   Pointer to CPUMCTXCORE guest registers structure.
    23352355 * @param   pCpu        Disassembler CPU state.
    23362356 */
    2337 VMMDECL(VBOXSTRICTRC) IOMInterpretOUTS(PVM pVM, PCPUMCTXCORE pRegFrame, PDISCPUSTATE pCpu)
     2357VMMDECL(VBOXSTRICTRC) IOMInterpretOUTS(PVM pVM, PVMCPU pVCpu, PCPUMCTXCORE pRegFrame, PDISCPUSTATE pCpu)
    23382358{
    23392359    /*
    … …  
    23572377    }
    23582378
    2359     return IOMInterpretOUTSEx(pVM, pRegFrame, Port, pCpu->fPrefix, (DISCPUMODE)pCpu->uAddrMode, cb);
     2379    return IOMInterpretOUTSEx(pVM, pVCpu, pRegFrame, Port, pCpu->fPrefix, (DISCPUMODE)pCpu->uAddrMode, cb);
    23602380}
    23612381
    … …  
    23962416     * Lookup the context range node the page belongs to.
    23972417     */
    2398     PIOMMMIORANGE pRange = iomMmioGetRange(pVM, GCPhys);
     2418    PIOMMMIORANGE pRange = iomMmioGetRange(pVM, pVCpu, GCPhys);
    23992419    AssertMsgReturn(pRange,
    24002420                    ("Handlers and page tables are out of sync or something! GCPhys=%RGp\n", GCPhys), VERR_IOM_MMIO_RANGE_NOT_FOUND);
    … …  
    24612481#ifdef VBOX_STRICT
    24622482    /* Can't lock IOM here due to potential deadlocks in the VGA device; not safe to access. */
    2463     PIOMMMIORANGE pRange = iomMMIOGetRangeUnsafe(pVM, GCPhys);
     2483    PIOMMMIORANGE pRange = iomMMIOGetRangeUnsafe(pVM, pVCpu, GCPhys);
    24642484    AssertMsgReturn(pRange,
    24652485            ("Handlers and page tables are out of sync or something! GCPhys=%RGp\n", GCPhys), VERR_IOM_MMIO_RANGE_NOT_FOUND);
    … …  
    25142534#ifdef VBOX_STRICT
    25152535    /* Can't lock IOM here due to potential deadlocks in the VGA device; not safe to access. */
    2516     PIOMMMIORANGE pRange = iomMMIOGetRangeUnsafe(pVM, GCPhys);
     2536    PIOMMMIORANGE pRange = iomMMIOGetRangeUnsafe(pVM, pVCpu, GCPhys);
    25172537    AssertMsgReturn(pRange,
    25182538            ("Handlers and page tables are out of sync or something! GCPhys=%RGp\n", GCPhys), VERR_IOM_MMIO_RANGE_NOT_FOUND);

  • trunk/src/VBox/VMM/VMMR0/HWSVMR0.cpp

    r45235 r45305  
    24752475                    Log2(("IOMInterpretOUTSEx %RGv %x size=%d\n", (RTGCPTR)pCtx->rip, IoExitInfo.n.u16Port, uIOSize));
    24762476                    STAM_COUNTER_INC(&pVCpu->hm.s.StatExitIOStringWrite);
    2477                     rc = IOMInterpretOUTSEx(pVM, CPUMCTX2CORE(pCtx), IoExitInfo.n.u16Port, pDis->fPrefix,
     2477                    rc = IOMInterpretOUTSEx(pVM, pVCpu, CPUMCTX2CORE(pCtx), IoExitInfo.n.u16Port, pDis->fPrefix,
    24782478                                            (DISCPUMODE)pDis->uAddrMode, uIOSize);
    24792479                }
    … …  
    24822482                    Log2(("IOMInterpretINSEx  %RGv %x size=%d\n", (RTGCPTR)pCtx->rip, IoExitInfo.n.u16Port, uIOSize));
    24832483                    STAM_COUNTER_INC(&pVCpu->hm.s.StatExitIOStringRead);
    2484                     rc = IOMInterpretINSEx(pVM, CPUMCTX2CORE(pCtx), IoExitInfo.n.u16Port, pDis->fPrefix,
     2484                    rc = IOMInterpretINSEx(pVM, pVCpu, CPUMCTX2CORE(pCtx), IoExitInfo.n.u16Port, pDis->fPrefix,
    24852485                                           (DISCPUMODE)pDis->uAddrMode, uIOSize);
    24862486                }
    … …  
    24992499                      uIOSize));
    25002500                STAM_COUNTER_INC(&pVCpu->hm.s.StatExitIOWrite);
    2501                 rc = IOMIOPortWrite(pVM, IoExitInfo.n.u16Port, pCtx->eax & uAndVal, uIOSize);
     2501                rc = IOMIOPortWrite(pVM, pVCpu, IoExitInfo.n.u16Port, pCtx->eax & uAndVal, uIOSize);
    25022502                if (rc == VINF_IOM_R3_IOPORT_WRITE)
    25032503                {
    … …  
    25112511
    25122512                STAM_COUNTER_INC(&pVCpu->hm.s.StatExitIORead);
    2513                 rc = IOMIOPortRead(pVM, IoExitInfo.n.u16Port, &u32Val, uIOSize);
     2513                rc = IOMIOPortRead(pVM, pVCpu, IoExitInfo.n.u16Port, &u32Val, uIOSize);
    25142514                if (IOM_SUCCESS(rc))
    25152515                {

  • trunk/src/VBox/VMM/VMMR0/HWVMXR0.cpp

    r45237 r45305  
    46094609                    Log2(("IOMInterpretOUTSEx %RGv %x size=%d\n", (RTGCPTR)pCtx->rip, uPort, cbSize));
    46104610                    STAM_COUNTER_INC(&pVCpu->hm.s.StatExitIOStringWrite);
    4611                     rc = IOMInterpretOUTSEx(pVM, CPUMCTX2CORE(pCtx), uPort, pDis->fPrefix, (DISCPUMODE)pDis->uAddrMode, cbSize);
     4611                    rc = IOMInterpretOUTSEx(pVM, pVCpu, CPUMCTX2CORE(pCtx), uPort, pDis->fPrefix,
     4612                                            (DISCPUMODE)pDis->uAddrMode, cbSize);
    46124613                }
    46134614                else
    … …  
    46154616                    Log2(("IOMInterpretINSEx  %RGv %x size=%d\n", (RTGCPTR)pCtx->rip, uPort, cbSize));
    46164617                    STAM_COUNTER_INC(&pVCpu->hm.s.StatExitIOStringRead);
    4617                     rc = IOMInterpretINSEx(pVM, CPUMCTX2CORE(pCtx), uPort, pDis->fPrefix, (DISCPUMODE)pDis->uAddrMode, cbSize);
     4618                    rc = IOMInterpretINSEx(pVM, pVCpu, CPUMCTX2CORE(pCtx), uPort, pDis->fPrefix,
     4619                                           (DISCPUMODE)pDis->uAddrMode, cbSize);
    46184620                }
    46194621            }
    … …  
    46314633            {
    46324634                STAM_COUNTER_INC(&pVCpu->hm.s.StatExitIOWrite);
    4633                 rc = IOMIOPortWrite(pVM, uPort, pCtx->eax & uAndVal, cbSize);
     4635                rc = IOMIOPortWrite(pVM, pVCpu, uPort, pCtx->eax & uAndVal, cbSize);
    46344636                if (rc == VINF_IOM_R3_IOPORT_WRITE)
    46354637                    HMR0SavePendingIOPortWrite(pVCpu, pCtx->rip, pCtx->rip + cbInstr, uPort, uAndVal, cbSize);
    … …  
    46404642
    46414643                STAM_COUNTER_INC(&pVCpu->hm.s.StatExitIORead);
    4642                 rc = IOMIOPortRead(pVM, uPort, &u32Val, cbSize);
     4644                rc = IOMIOPortRead(pVM, pVCpu, uPort, &u32Val, cbSize);
    46434645                if (IOM_SUCCESS(rc))
    46444646                {
    … …  
    47634765
    47644766                LogFlow(("Apic access at %RGp\n", GCPhys));
    4765                 rc = IOMMMIOPhysHandler(pVM, (uAccessType == VMX_APIC_ACCESS_TYPE_LINEAR_READ) ? 0 : X86_TRAP_PF_RW,
     4767                rc = IOMMMIOPhysHandler(pVM, pVCpu, (uAccessType == VMX_APIC_ACCESS_TYPE_LINEAR_READ) ? 0 : X86_TRAP_PF_RW,
    47664768                                        CPUMCTX2CORE(pCtx), GCPhys);
    47674769                if (rc == VINF_SUCCESS)

  • trunk/src/VBox/VMM/VMMR3/EMHM.cpp

    r45276 r45305  
    313313                {
    314314                    STAM_COUNTER_INC(&pVCpu->em.s.CTX_SUFF(pStats)->StatIn);
    315                     rcStrict = IOMInterpretIN(pVM, CPUMCTX2CORE(pCtx), &Cpu);
     315                    rcStrict = IOMInterpretIN(pVM, pVCpu, CPUMCTX2CORE(pCtx), &Cpu);
    316316                    break;
    317317                }
    … …  
    320320                {
    321321                    STAM_COUNTER_INC(&pVCpu->em.s.CTX_SUFF(pStats)->StatOut);
    322                     rcStrict = IOMInterpretOUT(pVM, CPUMCTX2CORE(pCtx), &Cpu);
     322                    rcStrict = IOMInterpretOUT(pVM, pVCpu, CPUMCTX2CORE(pCtx), &Cpu);
    323323                    break;
    324324                }
    … …  
    333333                {
    334334                    STAM_COUNTER_INC(&pVCpu->em.s.CTX_SUFF(pStats)->StatIn);
    335                     rcStrict = IOMInterpretINS(pVM, CPUMCTX2CORE(pCtx), &Cpu);
     335                    rcStrict = IOMInterpretINS(pVM, pVCpu, CPUMCTX2CORE(pCtx), &Cpu);
    336336                    break;
    337337                }
    … …  
    341341                {
    342342                    STAM_COUNTER_INC(&pVCpu->em.s.CTX_SUFF(pStats)->StatOut);
    343                     rcStrict = IOMInterpretOUTS(pVM, CPUMCTX2CORE(pCtx), &Cpu);
     343                    rcStrict = IOMInterpretOUTS(pVM, pVCpu, CPUMCTX2CORE(pCtx), &Cpu);
    344344                    break;
    345345                }

  • trunk/src/VBox/VMM/VMMR3/EMRaw.cpp

    r45276 r45305  
    435435                {
    436436                    STAM_COUNTER_INC(&pVCpu->em.s.CTX_SUFF(pStats)->StatIn);
    437                     rcStrict = IOMInterpretIN(pVM, CPUMCTX2CORE(pCtx), &Cpu);
     437                    rcStrict = IOMInterpretIN(pVM, pVCpu, CPUMCTX2CORE(pCtx), &Cpu);
    438438                    break;
    439439                }
    … …  
    442442                {
    443443                    STAM_COUNTER_INC(&pVCpu->em.s.CTX_SUFF(pStats)->StatOut);
    444                     rcStrict = IOMInterpretOUT(pVM, CPUMCTX2CORE(pCtx), &Cpu);
     444                    rcStrict = IOMInterpretOUT(pVM, pVCpu, CPUMCTX2CORE(pCtx), &Cpu);
    445445                    break;
    446446                }
    … …  
    455455                {
    456456                    STAM_COUNTER_INC(&pVCpu->em.s.CTX_SUFF(pStats)->StatIn);
    457                     rcStrict = IOMInterpretINS(pVM, CPUMCTX2CORE(pCtx), &Cpu);
     457                    rcStrict = IOMInterpretINS(pVM, pVCpu, CPUMCTX2CORE(pCtx), &Cpu);
    458458                    break;
    459459                }
    … …  
    463463                {
    464464                    STAM_COUNTER_INC(&pVCpu->em.s.CTX_SUFF(pStats)->StatOut);
    465                     rcStrict = IOMInterpretOUTS(pVM, CPUMCTX2CORE(pCtx), &Cpu);
     465                    rcStrict = IOMInterpretOUTS(pVM, pVCpu, CPUMCTX2CORE(pCtx), &Cpu);
    466466                    break;
    467467                }

  • trunk/src/VBox/VMM/VMMR3/HM.cpp

    r45291 r45305  
    25522552            uint32_t u32Val  = 0;
    25532553
    2554             rcStrict = IOMIOPortRead(pVM, pVCpu->hm.s.PendingIO.s.Port.uPort,
     2554            rcStrict = IOMIOPortRead(pVM, pVCpu, pVCpu->hm.s.PendingIO.s.Port.uPort,
    25552555                                     &u32Val,
    25562556                                     pVCpu->hm.s.PendingIO.s.Port.cbSize);
    … …  
    25652565
    25662566        case HMPENDINGIO_PORT_WRITE:
    2567             rcStrict = IOMIOPortWrite(pVM, pVCpu->hm.s.PendingIO.s.Port.uPort,
     2567            rcStrict = IOMIOPortWrite(pVM, pVCpu, pVCpu->hm.s.PendingIO.s.Port.uPort,
    25682568                                      pCtx->eax & pVCpu->hm.s.PendingIO.s.Port.uAndVal,
    25692569                                      pVCpu->hm.s.PendingIO.s.Port.cbSize);

  • trunk/src/VBox/VMM/VMMR3/IOM.cpp

    r45301 r45305  
    238238static void iomR3FlushCache(PVM pVM)
    239239{
     240    /*
     241     * Since all relevant (1) cache use requires at least read access to the
     242     * critical section, we can exclude all other EMTs by grabbing exclusive
     243     * access to the critical section and then safely update the caches of
     244     * other EMTs.
     245     * (1) The irrelvant access not holding the lock is in assertion code.
     246     */
    240247    IOM_LOCK(pVM);
    241 
    242     /*
    243      * Caching of port and statistics (saves some time in rep outs/ins instruction emulation)
    244      */
    245     pVM->iom.s.pRangeLastReadR0  = NIL_RTR0PTR;
    246     pVM->iom.s.pRangeLastWriteR0 = NIL_RTR0PTR;
    247     pVM->iom.s.pStatsLastReadR0  = NIL_RTR0PTR;
    248     pVM->iom.s.pStatsLastWriteR0 = NIL_RTR0PTR;
    249     pVM->iom.s.pMMIORangeLastR0  = NIL_RTR0PTR;
    250     pVM->iom.s.pMMIOStatsLastR0  = NIL_RTR0PTR;
    251 
    252     pVM->iom.s.pRangeLastReadR3  = NULL;
    253     pVM->iom.s.pRangeLastWriteR3 = NULL;
    254     pVM->iom.s.pStatsLastReadR3  = NULL;
    255     pVM->iom.s.pStatsLastWriteR3 = NULL;
    256     pVM->iom.s.pMMIORangeLastR3  = NULL;
    257     pVM->iom.s.pMMIOStatsLastR3  = NULL;
    258 
    259     pVM->iom.s.pRangeLastReadRC  = NIL_RTRCPTR;
    260     pVM->iom.s.pRangeLastWriteRC = NIL_RTRCPTR;
    261     pVM->iom.s.pStatsLastReadRC  = NIL_RTRCPTR;
    262     pVM->iom.s.pStatsLastWriteRC = NIL_RTRCPTR;
    263     pVM->iom.s.pMMIORangeLastRC  = NIL_RTRCPTR;
    264     pVM->iom.s.pMMIOStatsLastRC  = NIL_RTRCPTR;
     248    VMCPUID iCpu = pVM->cCpus;
     249    while (iCpu-- > 0)
     250    {
     251        PVMCPU pVCpu = &pVM->aCpus[iCpu];
     252        pVCpu->iom.s.pRangeLastReadR0  = NIL_RTR0PTR;
     253        pVCpu->iom.s.pRangeLastWriteR0 = NIL_RTR0PTR;
     254        pVCpu->iom.s.pStatsLastReadR0  = NIL_RTR0PTR;
     255        pVCpu->iom.s.pStatsLastWriteR0 = NIL_RTR0PTR;
     256        pVCpu->iom.s.pMMIORangeLastR0  = NIL_RTR0PTR;
     257        pVCpu->iom.s.pMMIOStatsLastR0  = NIL_RTR0PTR;
     258
     259        pVCpu->iom.s.pRangeLastReadR3  = NULL;
     260        pVCpu->iom.s.pRangeLastWriteR3 = NULL;
     261        pVCpu->iom.s.pStatsLastReadR3  = NULL;
     262        pVCpu->iom.s.pStatsLastWriteR3 = NULL;
     263        pVCpu->iom.s.pMMIORangeLastR3  = NULL;
     264        pVCpu->iom.s.pMMIOStatsLastR3  = NULL;
     265
     266        pVCpu->iom.s.pRangeLastReadRC  = NIL_RTRCPTR;
     267        pVCpu->iom.s.pRangeLastWriteRC = NIL_RTRCPTR;
     268        pVCpu->iom.s.pStatsLastReadRC  = NIL_RTRCPTR;
     269        pVCpu->iom.s.pStatsLastWriteRC = NIL_RTRCPTR;
     270        pVCpu->iom.s.pMMIORangeLastRC  = NIL_RTRCPTR;
     271        pVCpu->iom.s.pMMIOStatsLastRC  = NIL_RTRCPTR;
     272    }
    265273
    266274    IOM_UNLOCK(pVM);
    … …  
    304312
    305313    /*
    306      * Apply relocations to the cached GC handlers
    307      */
    308     if (pVM->iom.s.pRangeLastReadRC)
    309         pVM->iom.s.pRangeLastReadRC  += offDelta;
    310     if (pVM->iom.s.pRangeLastWriteRC)
    311         pVM->iom.s.pRangeLastWriteRC += offDelta;
    312     if (pVM->iom.s.pStatsLastReadRC)
    313         pVM->iom.s.pStatsLastReadRC  += offDelta;
    314     if (pVM->iom.s.pStatsLastWriteRC)
    315         pVM->iom.s.pStatsLastWriteRC += offDelta;
    316     if (pVM->iom.s.pMMIORangeLastRC)
    317         pVM->iom.s.pMMIORangeLastRC  += offDelta;
    318     if (pVM->iom.s.pMMIOStatsLastRC)
    319         pVM->iom.s.pMMIOStatsLastRC  += offDelta;
     314     * Reset the raw-mode cache (don't bother relocating it).
     315     */
     316    VMCPUID iCpu = pVM->cCpus;
     317    while (iCpu-- > 0)
     318    {
     319        PVMCPU pVCpu = &pVM->aCpus[iCpu];
     320        pVCpu->iom.s.pRangeLastReadRC  = NIL_RTRCPTR;
     321        pVCpu->iom.s.pRangeLastWriteRC = NIL_RTRCPTR;
     322        pVCpu->iom.s.pStatsLastReadRC  = NIL_RTRCPTR;
     323        pVCpu->iom.s.pStatsLastWriteRC = NIL_RTRCPTR;
     324        pVCpu->iom.s.pMMIORangeLastRC  = NIL_RTRCPTR;
     325        pVCpu->iom.s.pMMIOStatsLastRC  = NIL_RTRCPTR;
     326    }
    320327}
    321328
    … …  
    13171324                    sizeof(RTRCPTR) * 2,      "pvUser          ");
    13181325    RTAvlroIOPortDoWithAll(&pVM->iom.s.pTreesR3->IOPortTreeRC, true, iomR3IOPortInfoOneRC, (void *)pHlp);
    1319 
    1320     if (pVM->iom.s.pRangeLastReadRC)
    1321     {
    1322         PIOMIOPORTRANGERC pRange = (PIOMIOPORTRANGERC)MMHyperRCToCC(pVM, pVM->iom.s.pRangeLastReadRC);
    1323         pHlp->pfnPrintf(pHlp, "RC Read  Ports: %#04x-%#04x %RRv %s\n",
    1324                         pRange->Port, pRange->Port + pRange->cPorts, pVM->iom.s.pRangeLastReadRC, pRange->pszDesc);
    1325     }
    1326     if (pVM->iom.s.pStatsLastReadRC)
    1327     {
    1328         PIOMIOPORTSTATS pRange = (PIOMIOPORTSTATS)MMHyperRCToCC(pVM, pVM->iom.s.pStatsLastReadRC);
    1329         pHlp->pfnPrintf(pHlp, "RC Read  Stats: %#04x %RRv\n",
    1330                         pRange->Core.Key, pVM->iom.s.pStatsLastReadRC);
    1331     }
    1332 
    1333     if (pVM->iom.s.pRangeLastWriteRC)
    1334     {
    1335         PIOMIOPORTRANGERC pRange = (PIOMIOPORTRANGERC)MMHyperRCToCC(pVM, pVM->iom.s.pRangeLastWriteRC);
    1336         pHlp->pfnPrintf(pHlp, "RC Write Ports: %#04x-%#04x %RRv %s\n",
    1337                         pRange->Port, pRange->Port + pRange->cPorts, pVM->iom.s.pRangeLastWriteRC, pRange->pszDesc);
    1338     }
    1339     if (pVM->iom.s.pStatsLastWriteRC)
    1340     {
    1341         PIOMIOPORTSTATS pRange = (PIOMIOPORTSTATS)MMHyperRCToCC(pVM, pVM->iom.s.pStatsLastWriteRC);
    1342         pHlp->pfnPrintf(pHlp, "RC Write Stats: %#04x %RRv\n",
    1343                         pRange->Core.Key, pVM->iom.s.pStatsLastWriteRC);
    1344     }
    1345 
    1346     if (pVM->iom.s.pRangeLastReadR3)
    1347     {
    1348         PIOMIOPORTRANGER3 pRange = pVM->iom.s.pRangeLastReadR3;
    1349         pHlp->pfnPrintf(pHlp, "R3 Read  Ports: %#04x-%#04x %p %s\n",
    1350                         pRange->Port, pRange->Port + pRange->cPorts, pRange, pRange->pszDesc);
    1351     }
    1352     if (pVM->iom.s.pStatsLastReadR3)
    1353     {
    1354         PIOMIOPORTSTATS pRange = pVM->iom.s.pStatsLastReadR3;
    1355         pHlp->pfnPrintf(pHlp, "R3 Read  Stats: %#04x %p\n",
    1356                         pRange->Core.Key, pRange);
    1357     }
    1358 
    1359     if (pVM->iom.s.pRangeLastWriteR3)
    1360     {
    1361         PIOMIOPORTRANGER3 pRange = pVM->iom.s.pRangeLastWriteR3;
    1362         pHlp->pfnPrintf(pHlp, "R3 Write Ports: %#04x-%#04x %p %s\n",
    1363                         pRange->Port, pRange->Port + pRange->cPorts, pRange, pRange->pszDesc);
    1364     }
    1365     if (pVM->iom.s.pStatsLastWriteR3)
    1366     {
    1367         PIOMIOPORTSTATS pRange = pVM->iom.s.pStatsLastWriteR3;
    1368         pHlp->pfnPrintf(pHlp, "R3 Write Stats: %#04x %p\n",
    1369                         pRange->Core.Key, pRange);
    1370     }
    1371 
    1372     if (pVM->iom.s.pRangeLastReadR0)
    1373     {
    1374         PIOMIOPORTRANGER0 pRange = (PIOMIOPORTRANGER0)MMHyperR0ToCC(pVM, pVM->iom.s.pRangeLastReadR0);
    1375         pHlp->pfnPrintf(pHlp, "R0 Read  Ports: %#04x-%#04x %p %s\n",
    1376                         pRange->Port, pRange->Port + pRange->cPorts, pRange, pRange->pszDesc);
    1377     }
    1378     if (pVM->iom.s.pStatsLastReadR0)
    1379     {
    1380         PIOMIOPORTSTATS pRange = (PIOMIOPORTSTATS)MMHyperR0ToCC(pVM, pVM->iom.s.pStatsLastReadR0);
    1381         pHlp->pfnPrintf(pHlp, "R0 Read  Stats: %#04x %p\n",
    1382                         pRange->Core.Key, pRange);
    1383     }
    1384 
    1385     if (pVM->iom.s.pRangeLastWriteR0)
    1386     {
    1387         PIOMIOPORTRANGER0 pRange = (PIOMIOPORTRANGER0)MMHyperR0ToCC(pVM, pVM->iom.s.pRangeLastWriteR0);
    1388         pHlp->pfnPrintf(pHlp, "R0 Write Ports: %#04x-%#04x %p %s\n",
    1389                         pRange->Port, pRange->Port + pRange->cPorts, pRange, pRange->pszDesc);
    1390     }
    1391     if (pVM->iom.s.pStatsLastWriteR0)
    1392     {
    1393         PIOMIOPORTSTATS pRange = (PIOMIOPORTSTATS)MMHyperR0ToCC(pVM, pVM->iom.s.pStatsLastWriteR0);
    1394         pHlp->pfnPrintf(pHlp, "R0 Write Stats: %#04x %p\n",
    1395                         pRange->Core.Key, pRange);
    1396     }
    13971326}
    13981327
    … …  
    15321461 * @param   pfnReadCallback     Pointer to function which is gonna handle Read operations.
    15331462 * @param   pfnFillCallback     Pointer to function which is gonna handle Fill/memset operations.
     1463 * @thread  EMT
    15341464 */
    15351465VMMR3_INT_DECL(int)
    … …  
    15491479        return VERR_INVALID_PARAMETER;
    15501480    }
     1481    PVMCPU pVCpu = VMMGetCpu(pVM); Assert(pVCpu);
    15511482
    15521483    /*
    … …  
    15541485     */
    15551486    IOM_LOCK(pVM);
    1556     PIOMMMIORANGE pRange = iomMmioGetRange(pVM, GCPhysStart);
     1487    PIOMMMIORANGE pRange = iomMmioGetRange(pVM, pVCpu, GCPhysStart);
    15571488    AssertReturnStmt(pRange, IOM_UNLOCK(pVM), VERR_IOM_MMIO_RANGE_NOT_FOUND);
    15581489    AssertReturnStmt(pRange->pDevInsR3 == pDevIns, IOM_UNLOCK(pVM), VERR_IOM_NOT_MMIO_RANGE_OWNER);
    … …  
    15881519 * @param   pfnReadCallback     Pointer to function which is gonna handle Read operations.
    15891520 * @param   pfnFillCallback     Pointer to function which is gonna handle Fill/memset operations.
     1521 * @thread  EMT
    15901522 */
    15911523VMMR3_INT_DECL(int)
    … …  
    16061538        return VERR_INVALID_PARAMETER;
    16071539    }
     1540    PVMCPU pVCpu = VMMGetCpu(pVM); Assert(pVCpu);
    16081541
    16091542    /*
    … …  
    16111544     */
    16121545    IOM_LOCK(pVM);
    1613     PIOMMMIORANGE pRange = iomMmioGetRange(pVM, GCPhysStart);
     1546    PIOMMMIORANGE pRange = iomMmioGetRange(pVM, pVCpu, GCPhysStart);
    16141547    AssertReturnStmt(pRange, IOM_UNLOCK(pVM), VERR_IOM_MMIO_RANGE_NOT_FOUND);
    16151548    AssertReturnStmt(pRange->pDevInsR3 == pDevIns, IOM_UNLOCK(pVM), VERR_IOM_NOT_MMIO_RANGE_OWNER);
    … …  
    16561589        return VERR_IOM_INVALID_MMIO_RANGE;
    16571590    }
     1591    PVMCPU pVCpu = VMMGetCpu(pVM); Assert(pVCpu);
    16581592
    16591593    IOM_LOCK(pVM);
    … …  
    16651599    while (GCPhys <= GCPhysLast && GCPhys >= GCPhysStart)
    16661600    {
    1667         PIOMMMIORANGE pRange = iomMmioGetRange(pVM, GCPhys);
     1601        PIOMMMIORANGE pRange = iomMmioGetRange(pVM, pVCpu, GCPhys);
    16681602        if (!pRange)
    16691603        {

  • trunk/src/VBox/VMM/VMMRC/IOMRC.cpp

    r41965 r45305  
    6262 *
    6363 * @param   pVM         The virtual machine handle.
     64 * @param   pVCpu       Pointer to the virtual CPU structure of the caller.
    6465 * @param   pRegFrame   Pointer to CPUMCTXCORE guest registers structure.
    6566 * @param   pCpu        Disassembler CPU state.
    6667 */
    67 VMMRCDECL(VBOXSTRICTRC) IOMRCIOPortHandler(PVM pVM, PCPUMCTXCORE pRegFrame, PDISCPUSTATE pCpu)
     68VMMRCDECL(VBOXSTRICTRC) IOMRCIOPortHandler(PVM pVM, PVMCPU pVCpu, PCPUMCTXCORE pRegFrame, PDISCPUSTATE pCpu)
    6869{
    6970    switch (pCpu->pCurInstr->uOpcode)
    7071    {
    7172        case OP_IN:
    72             return IOMInterpretIN(pVM, pRegFrame, pCpu);
     73            return IOMInterpretIN(pVM, pVCpu, pRegFrame, pCpu);
    7374
    7475        case OP_OUT:
    75             return IOMInterpretOUT(pVM, pRegFrame, pCpu);
     76            return IOMInterpretOUT(pVM, pVCpu, pRegFrame, pCpu);
    7677
    7778        case OP_INSB:
    7879        case OP_INSWD:
    79             return IOMInterpretINS(pVM, pRegFrame, pCpu);
     80            return IOMInterpretINS(pVM, pVCpu, pRegFrame, pCpu);
    8081
    8182        case OP_OUTSB:
    8283        case OP_OUTSWD:
    83             return IOMInterpretOUTS(pVM, pRegFrame, pCpu);
     84            return IOMInterpretOUTS(pVM, pVCpu, pRegFrame, pCpu);
    8485
    8586        /*

  • trunk/src/VBox/VMM/VMMRC/TRPMRCHandlers.cpp

    r45276 r45305  
    10721072        &&  (Cpu.pCurInstr->fOpType & DISOPTYPE_PORTIO))
    10731073    {
    1074         VBOXSTRICTRC rcStrict = IOMRCIOPortHandler(pVM, pRegFrame, &Cpu);
     1074        VBOXSTRICTRC rcStrict = IOMRCIOPortHandler(pVM, pVCpu, pRegFrame, &Cpu);
    10751075        if (IOM_SUCCESS(rcStrict))
    10761076            pRegFrame->rip += cbOp;

  • trunk/src/VBox/VMM/include/IOMInline.h

    r45301 r45305  
    6363 *
    6464 * @param   pVM     Pointer to the VM.
    65  * @param   GCPhys  Physical address to lookup.
    66  */
    67 DECLINLINE(PIOMMMIORANGE) iomMmioGetRange(PVM pVM, RTGCPHYS GCPhys)
     65 * @param   pVCpu   Pointer to the virtual CPU structure of the caller.
     66 * @param   GCPhys  Physical address to lookup.
     67 */
     68DECLINLINE(PIOMMMIORANGE) iomMmioGetRange(PVM pVM, PVMCPU pVCpu, RTGCPHYS GCPhys)
    6869{
    6970    Assert(IOM_IS_SHARED_LOCK_OWNER(pVM));
    70     PIOMMMIORANGE pRange = pVM->iom.s.CTX_SUFF(pMMIORangeLast);
     71    PIOMMMIORANGE pRange = pVCpu->iom.s.CTX_SUFF(pMMIORangeLast);
    7172    if (    !pRange
    7273        ||  GCPhys - pRange->GCPhys >= pRange->cb)
    73         pVM->iom.s.CTX_SUFF(pMMIORangeLast) = pRange
     74        pVCpu->iom.s.CTX_SUFF(pMMIORangeLast) = pRange
    7475            = (PIOMMMIORANGE)RTAvlroGCPhysRangeGet(&pVM->iom.s.CTX_SUFF(pTrees)->MMIOTree, GCPhys);
    7576    return pRange;
    … …  
    9899 *
    99100 * @param   pVM     Pointer to the VM.
    100  * @param   GCPhys  Physical address to lookup.
    101  */
    102 DECLINLINE(PIOMMMIORANGE) iomMmioGetRangeWithRef(PVM pVM, RTGCPHYS GCPhys)
     101 * @param   pVCpu   Pointer to the virtual CPU structure of the caller.
     102 * @param   GCPhys  Physical address to lookup.
     103 */
     104DECLINLINE(PIOMMMIORANGE) iomMmioGetRangeWithRef(PVM pVM, PVMCPU pVCpu, RTGCPHYS GCPhys)
    103105{
    104106    int rc = IOM_LOCK_SHARED_EX(pVM, VINF_SUCCESS);
    105107    AssertRCReturn(rc, NULL);
    106108
    107     PIOMMMIORANGE pRange = pVM->iom.s.CTX_SUFF(pMMIORangeLast);
     109    PIOMMMIORANGE pRange = pVCpu->iom.s.CTX_SUFF(pMMIORangeLast);
    108110    if (   !pRange
    109111        || GCPhys - pRange->GCPhys >= pRange->cb)
    110         pVM->iom.s.CTX_SUFF(pMMIORangeLast) = pRange
     112        pVCpu->iom.s.CTX_SUFF(pMMIORangeLast) = pRange
    111113            = (PIOMMMIORANGE)RTAvlroGCPhysRangeGet(&pVM->iom.s.CTX_SUFF(pTrees)->MMIOTree, GCPhys);
    112114    if (pRange)
    … …  
    140142 *
    141143 * @param   pVM     Pointer to the VM.
    142  * @param   GCPhys  Physical address to lookup.
    143  */
    144 DECLINLINE(PIOMMMIORANGE) iomMMIOGetRangeUnsafe(PVM pVM, RTGCPHYS GCPhys)
    145 {
    146     PIOMMMIORANGE pRange = pVM->iom.s.CTX_SUFF(pMMIORangeLast);
     144 * @param   pVCpu   Pointer to the virtual CPU structure of the caller.
     145 * @param   GCPhys  Physical address to lookup.
     146 */
     147DECLINLINE(PIOMMMIORANGE) iomMMIOGetRangeUnsafe(PVM pVM, PVMCPU pVCpu, RTGCPHYS GCPhys)
     148{
     149    PIOMMMIORANGE pRange = pVCpu->iom.s.CTX_SUFF(pMMIORangeLast);
    147150    if (    !pRange
    148151        ||  GCPhys - pRange->GCPhys >= pRange->cb)
    149         pVM->iom.s.CTX_SUFF(pMMIORangeLast) = pRange
     152        pVCpu->iom.s.CTX_SUFF(pMMIORangeLast) = pRange
    150153            = (PIOMMMIORANGE)RTAvlroGCPhysRangeGet(&pVM->iom.s.CTX_SUFF(pTrees)->MMIOTree, GCPhys);
    151154    return pRange;
    … …  
    164167 * @returns NULL if not found (R0/GC), or out of memory (R3).
    165168 *
    166  * @param   pVM         Pointer to the VM.
    167  * @param   GCPhys      Physical address to lookup.
    168  * @param   pRange      The MMIO range.
    169  */
    170 DECLINLINE(PIOMMMIOSTATS) iomMmioGetStats(PVM pVM, RTGCPHYS GCPhys, PIOMMMIORANGE pRange)
     169 * @param   pVM     Pointer to the VM.
     170 * @param   pVCpu   Pointer to the virtual CPU structure of the caller.
     171 * @param   GCPhys  Physical address to lookup.
     172 * @param   pRange  The MMIO range.
     173 */
     174DECLINLINE(PIOMMMIOSTATS) iomMmioGetStats(PVM pVM, PVMCPU pVCpu, RTGCPHYS GCPhys, PIOMMMIORANGE pRange)
    171175{
    172176    IOM_LOCK_SHARED_EX(pVM, VINF_SUCCESS);
    … …  
    176180        GCPhys = pRange->GCPhys;
    177181
    178     PIOMMMIOSTATS pStats = pVM->iom.s.CTX_SUFF(pMMIOStatsLast);
     182    PIOMMMIOSTATS pStats = pVCpu->iom.s.CTX_SUFF(pMMIOStatsLast);
    179183    if (    !pStats
    180184        ||  pStats->Core.Key != GCPhys)

  • trunk/src/VBox/VMM/include/IOMInternal.h

    r45301 r45305  
    335335#endif
    336336
    337     /** @name Caching of I/O Port and MMIO ranges and statistics.
    338      * (Saves quite some time in rep outs/ins instruction emulation.)
    339      * @{ */
    340     R3PTRTYPE(PIOMIOPORTRANGER3)    pRangeLastReadR3;
    341     R3PTRTYPE(PIOMIOPORTRANGER3)    pRangeLastWriteR3;
    342     R3PTRTYPE(PIOMIOPORTSTATS)      pStatsLastReadR3;
    343     R3PTRTYPE(PIOMIOPORTSTATS)      pStatsLastWriteR3;
    344     R3PTRTYPE(PIOMMMIORANGE)        pMMIORangeLastR3;
    345     R3PTRTYPE(PIOMMMIOSTATS)        pMMIOStatsLastR3;
    346 
    347     R0PTRTYPE(PIOMIOPORTRANGER0)    pRangeLastReadR0;
    348     R0PTRTYPE(PIOMIOPORTRANGER0)    pRangeLastWriteR0;
    349     R0PTRTYPE(PIOMIOPORTSTATS)      pStatsLastReadR0;
    350     R0PTRTYPE(PIOMIOPORTSTATS)      pStatsLastWriteR0;
    351     R0PTRTYPE(PIOMMMIORANGE)        pMMIORangeLastR0;
    352     R0PTRTYPE(PIOMMMIOSTATS)        pMMIOStatsLastR0;
    353 
    354     RCPTRTYPE(PIOMIOPORTRANGERC)    pRangeLastReadRC;
    355     RCPTRTYPE(PIOMIOPORTRANGERC)    pRangeLastWriteRC;
    356     RCPTRTYPE(PIOMIOPORTSTATS)      pStatsLastReadRC;
    357     RCPTRTYPE(PIOMIOPORTSTATS)      pStatsLastWriteRC;
    358     RCPTRTYPE(PIOMMMIORANGE)        pMMIORangeLastRC;
    359     RCPTRTYPE(PIOMMMIOSTATS)        pMMIOStatsLastRC;
    360     /** @} */
    361 
    362337    /** @name I/O Port statistics.
    363338     * @{ */
    … …  
    414389     * on the stack. */
    415390    DISCPUSTATE                     DisState;
     391
     392    /** @name Caching of I/O Port and MMIO ranges and statistics.
     393     * (Saves quite some time in rep outs/ins instruction emulation.)
     394     * @{ */
     395    R3PTRTYPE(PIOMIOPORTRANGER3)    pRangeLastReadR3;
     396    R3PTRTYPE(PIOMIOPORTRANGER3)    pRangeLastWriteR3;
     397    R3PTRTYPE(PIOMIOPORTSTATS)      pStatsLastReadR3;
     398    R3PTRTYPE(PIOMIOPORTSTATS)      pStatsLastWriteR3;
     399    R3PTRTYPE(PIOMMMIORANGE)        pMMIORangeLastR3;
     400    R3PTRTYPE(PIOMMMIOSTATS)        pMMIOStatsLastR3;
     401
     402    R0PTRTYPE(PIOMIOPORTRANGER0)    pRangeLastReadR0;
     403    R0PTRTYPE(PIOMIOPORTRANGER0)    pRangeLastWriteR0;
     404    R0PTRTYPE(PIOMIOPORTSTATS)      pStatsLastReadR0;
     405    R0PTRTYPE(PIOMIOPORTSTATS)      pStatsLastWriteR0;
     406    R0PTRTYPE(PIOMMMIORANGE)        pMMIORangeLastR0;
     407    R0PTRTYPE(PIOMMMIOSTATS)        pMMIOStatsLastR0;
     408
     409    RCPTRTYPE(PIOMIOPORTRANGERC)    pRangeLastReadRC;
     410    RCPTRTYPE(PIOMIOPORTRANGERC)    pRangeLastWriteRC;
     411    RCPTRTYPE(PIOMIOPORTSTATS)      pStatsLastReadRC;
     412    RCPTRTYPE(PIOMIOPORTSTATS)      pStatsLastWriteRC;
     413    RCPTRTYPE(PIOMMMIORANGE)        pMMIORangeLastRC;
     414    RCPTRTYPE(PIOMMMIOSTATS)        pMMIOStatsLastRC;
     415    /** @} */
    416416} IOMCPU;
    417417/** Pointer to IOM per virtual CPU instance data. */

  • trunk/src/VBox/VMM/testcase/tstVMStruct.h

    r45152 r45305  
    276276    GEN_CHECK_OFF(IOM, pTreesR3);
    277277    GEN_CHECK_OFF(IOM, pTreesR0);
    278     GEN_CHECK_OFF(IOM, pMMIORangeLastR3);
    279     GEN_CHECK_OFF(IOM, pMMIOStatsLastR3);
    280     GEN_CHECK_OFF(IOM, pMMIORangeLastR0);
    281     GEN_CHECK_OFF(IOM, pMMIOStatsLastR0);
    282     GEN_CHECK_OFF(IOM, pMMIORangeLastRC);
    283     GEN_CHECK_OFF(IOM, pMMIOStatsLastRC);
    284     GEN_CHECK_OFF(IOM, pRangeLastReadR0);
    285     GEN_CHECK_OFF(IOM, pRangeLastReadRC);
    286278
    287279    GEN_CHECK_SIZE(IOMCPU);
    288280    GEN_CHECK_OFF(IOMCPU, DisState);
     281    GEN_CHECK_OFF(IOMCPU, pMMIORangeLastR3);
     282    GEN_CHECK_OFF(IOMCPU, pMMIOStatsLastR3);
     283    GEN_CHECK_OFF(IOMCPU, pMMIORangeLastR0);
     284    GEN_CHECK_OFF(IOMCPU, pMMIOStatsLastR0);
     285    GEN_CHECK_OFF(IOMCPU, pMMIORangeLastRC);
     286    GEN_CHECK_OFF(IOMCPU, pMMIOStatsLastRC);
     287    GEN_CHECK_OFF(IOMCPU, pRangeLastReadR0);
     288    GEN_CHECK_OFF(IOMCPU, pRangeLastReadRC);
    289289
    290290    GEN_CHECK_SIZE(IOMMMIORANGE);

  • trunk/src/recompiler/VBoxREMWrapper.cpp

    r44528 r45305  
    680680{
    681681    { REMPARMDESC_FLAGS_INT,        sizeof(PVM),                NULL },
     682    { REMPARMDESC_FLAGS_INT,        sizeof(PVMCPU),             NULL },
    682683    { REMPARMDESC_FLAGS_INT,        sizeof(RTIOPORT),           NULL },
    683684    { REMPARMDESC_FLAGS_INT,        sizeof(uint32_t *),         NULL },
    … …  
    687688{
    688689    { REMPARMDESC_FLAGS_INT,        sizeof(PVM),                NULL },
     690    { REMPARMDESC_FLAGS_INT,        sizeof(PVMCPU),             NULL },
    689691    { REMPARMDESC_FLAGS_INT,        sizeof(RTIOPORT),           NULL },
    690692    { REMPARMDESC_FLAGS_INT,        sizeof(uint32_t),           NULL },
    … …  
    694696{
    695697    { REMPARMDESC_FLAGS_INT,        sizeof(PVM),                NULL },
     698    { REMPARMDESC_FLAGS_INT,        sizeof(PVMCPU),             NULL },
    696699    { REMPARMDESC_FLAGS_GCPHYS,     sizeof(RTGCPHYS),           NULL },
    697700    { REMPARMDESC_FLAGS_INT,        sizeof(uint32_t *),         NULL },
    … …  
    701704{
    702705    { REMPARMDESC_FLAGS_INT,        sizeof(PVM),                NULL },
     706    { REMPARMDESC_FLAGS_INT,        sizeof(PVMCPU),             NULL },
    703707    { REMPARMDESC_FLAGS_GCPHYS,     sizeof(RTGCPHYS),           NULL },
    704708    { REMPARMDESC_FLAGS_INT,        sizeof(uint32_t),           NULL },
    … …  
    12341238    { "EMGetInhibitInterruptsPC",               VMM_FN(EMGetInhibitInterruptsPC),       &g_aArgsVMCPU[0],                           RT_ELEMENTS(g_aArgsVMCPU),                             REMFNDESC_FLAGS_RET_INT,    sizeof(RTGCPTR),    NULL },
    12351239    { "EMSetInhibitInterruptsPC",               VMM_FN(EMSetInhibitInterruptsPC),       &g_aArgsEMSetInhibitInterruptsPC[0],        RT_ELEMENTS(g_aArgsEMSetInhibitInterruptsPC),          REMFNDESC_FLAGS_RET_INT,    sizeof(int),        NULL },
    1236     { "HMR3CanExecuteGuest",                VMM_FN(HMR3CanExecuteGuest),        &g_aArgsHMR3CanExecuteGuest[0],         RT_ELEMENTS(g_aArgsHMR3CanExecuteGuest),           REMFNDESC_FLAGS_RET_INT,    sizeof(int),        NULL },
     1240    { "HMR3CanExecuteGuest",                    VMM_FN(HMR3CanExecuteGuest),            &g_aArgsHMR3CanExecuteGuest[0],             RT_ELEMENTS(g_aArgsHMR3CanExecuteGuest),               REMFNDESC_FLAGS_RET_INT,    sizeof(int),        NULL },
    12371241    { "IOMIOPortRead",                          VMM_FN(IOMIOPortRead),                  &g_aArgsIOMIOPortRead[0],                   RT_ELEMENTS(g_aArgsIOMIOPortRead),                     REMFNDESC_FLAGS_RET_INT,    sizeof(int),        NULL },
    12381242    { "IOMIOPortWrite",                         VMM_FN(IOMIOPortWrite),                 &g_aArgsIOMIOPortWrite[0],                  RT_ELEMENTS(g_aArgsIOMIOPortWrite),                    REMFNDESC_FLAGS_RET_INT,    sizeof(int),        NULL },

  • trunk/src/recompiler/VBoxRecompiler.c

    r45276 r45305  
    9393static int      remR3InitPhysRamSizeAndDirtyMap(PVM pVM, bool fGuarded);
    9494
    95 static uint32_t remR3MMIOReadU8(void *pvVM, target_phys_addr_t GCPhys);
    96 static uint32_t remR3MMIOReadU16(void *pvVM, target_phys_addr_t GCPhys);
    97 static uint32_t remR3MMIOReadU32(void *pvVM, target_phys_addr_t GCPhys);
    98 static void     remR3MMIOWriteU8(void *pvVM, target_phys_addr_t GCPhys, uint32_t u32);
    99 static void     remR3MMIOWriteU16(void *pvVM, target_phys_addr_t GCPhys, uint32_t u32);
    100 static void     remR3MMIOWriteU32(void *pvVM, target_phys_addr_t GCPhys, uint32_t u32);
     95static uint32_t remR3MMIOReadU8(void *pvEnv, target_phys_addr_t GCPhys);
     96static uint32_t remR3MMIOReadU16(void *pvEnv, target_phys_addr_t GCPhys);
     97static uint32_t remR3MMIOReadU32(void *pvEnv, target_phys_addr_t GCPhys);
     98static void     remR3MMIOWriteU8(void *pvEnv, target_phys_addr_t GCPhys, uint32_t u32);
     99static void     remR3MMIOWriteU16(void *pvEnv, target_phys_addr_t GCPhys, uint32_t u32);
     100static void     remR3MMIOWriteU32(void *pvEnv, target_phys_addr_t GCPhys, uint32_t u32);
    101101
    102102static uint32_t remR3HandlerReadU8(void *pvVM, target_phys_addr_t GCPhys);
    … …  
    334334     * Register ram types.
    335335     */
    336     pVM->rem.s.iMMIOMemType    = cpu_register_io_memory(g_apfnMMIORead, g_apfnMMIOWrite, pVM);
     336    pVM->rem.s.iMMIOMemType    = cpu_register_io_memory(g_apfnMMIORead, g_apfnMMIOWrite, &pVM->rem.s.Env);
    337337    AssertReleaseMsg(pVM->rem.s.iMMIOMemType >= 0, ("pVM->rem.s.iMMIOMemType=%d\n", pVM->rem.s.iMMIOMemType));
    338338    pVM->rem.s.iHandlerMemType = cpu_register_io_memory(g_apfnHandlerRead, g_apfnHandlerWrite, pVM);
    … …  
    37853785
    37863786/** Read MMIO memory. */
    3787 static uint32_t remR3MMIOReadU8(void *pvVM, target_phys_addr_t GCPhys)
    3788 {
    3789     uint32_t u32 = 0;
    3790     int rc = IOMMMIORead((PVM)pvVM, GCPhys, &u32, 1);
     3787static uint32_t remR3MMIOReadU8(void *pvEnv, target_phys_addr_t GCPhys)
     3788{
     3789    CPUX86State *env = (CPUX86State *)pvEnv;
     3790    uint32_t     u32 = 0;
     3791    int rc = IOMMMIORead(env->pVM, env->pVCpu, GCPhys, &u32, 1);
    37913792    AssertMsg(rc == VINF_SUCCESS, ("rc=%Rrc\n", rc)); NOREF(rc);
    37923793    Log2(("remR3MMIOReadU8: GCPhys=%RGp -> %02x\n", (RTGCPHYS)GCPhys, u32));
    … …  
    37953796
    37963797/** Read MMIO memory. */
    3797 static uint32_t remR3MMIOReadU16(void *pvVM, target_phys_addr_t GCPhys)
    3798 {
    3799     uint32_t u32 = 0;
    3800     int rc = IOMMMIORead((PVM)pvVM, GCPhys, &u32, 2);
     3798static uint32_t remR3MMIOReadU16(void *pvEnv, target_phys_addr_t GCPhys)
     3799{
     3800    CPUX86State *env = (CPUX86State *)pvEnv;
     3801    uint32_t     u32 = 0;
     3802    int rc = IOMMMIORead(env->pVM, env->pVCpu, GCPhys, &u32, 2);
    38013803    AssertMsg(rc == VINF_SUCCESS, ("rc=%Rrc\n", rc)); NOREF(rc);
    38023804    Log2(("remR3MMIOReadU16: GCPhys=%RGp -> %04x\n", (RTGCPHYS)GCPhys, u32));
    … …  
    38053807
    38063808/** Read MMIO memory. */
    3807 static uint32_t remR3MMIOReadU32(void *pvVM, target_phys_addr_t GCPhys)
    3808 {
    3809     uint32_t u32 = 0;
    3810     int rc = IOMMMIORead((PVM)pvVM, GCPhys, &u32, 4);
     3809static uint32_t remR3MMIOReadU32(void *pvEnv, target_phys_addr_t GCPhys)
     3810{
     3811    CPUX86State *env = (CPUX86State *)pvEnv;
     3812    uint32_t     u32 = 0;
     3813    int rc = IOMMMIORead(env->pVM, env->pVCpu, GCPhys, &u32, 4);
    38113814    AssertMsg(rc == VINF_SUCCESS, ("rc=%Rrc\n", rc)); NOREF(rc);
    38123815    Log2(("remR3MMIOReadU32: GCPhys=%RGp -> %08x\n", (RTGCPHYS)GCPhys, u32));
    … …  
    38153818
    38163819/** Write to MMIO memory. */
    3817 static void     remR3MMIOWriteU8(void *pvVM, target_phys_addr_t GCPhys, uint32_t u32)
    3818 {
    3819     int rc;
     3820static void     remR3MMIOWriteU8(void *pvEnv, target_phys_addr_t GCPhys, uint32_t u32)
     3821{
     3822    CPUX86State *env = (CPUX86State *)pvEnv;
     3823    int          rc;
    38203824    Log2(("remR3MMIOWriteU8: GCPhys=%RGp u32=%#x\n", (RTGCPHYS)GCPhys, u32));
    3821     rc = IOMMMIOWrite((PVM)pvVM, GCPhys, u32, 1);
     3825    rc = IOMMMIOWrite(env->pVM, env->pVCpu, GCPhys, u32, 1);
    38223826    AssertMsg(rc == VINF_SUCCESS, ("rc=%Rrc\n", rc)); NOREF(rc);
    38233827}
    38243828
    38253829/** Write to MMIO memory. */
    3826 static void     remR3MMIOWriteU16(void *pvVM, target_phys_addr_t GCPhys, uint32_t u32)
    3827 {
    3828     int rc;
     3830static void     remR3MMIOWriteU16(void *pvEnv, target_phys_addr_t GCPhys, uint32_t u32)
     3831{
     3832    CPUX86State *env = (CPUX86State *)pvEnv;
     3833    int          rc;
    38293834    Log2(("remR3MMIOWriteU16: GCPhys=%RGp u32=%#x\n", (RTGCPHYS)GCPhys, u32));
    3830     rc = IOMMMIOWrite((PVM)pvVM, GCPhys, u32, 2);
     3835    rc = IOMMMIOWrite(env->pVM, env->pVCpu, GCPhys, u32, 2);
    38313836    AssertMsg(rc == VINF_SUCCESS, ("rc=%Rrc\n", rc)); NOREF(rc);
    38323837}
    38333838
    38343839/** Write to MMIO memory. */
    3835 static void     remR3MMIOWriteU32(void *pvVM, target_phys_addr_t GCPhys, uint32_t u32)
    3836 {
    3837     int rc;
     3840static void     remR3MMIOWriteU32(void *pvEnv, target_phys_addr_t GCPhys, uint32_t u32)
     3841{
     3842    CPUX86State *env = (CPUX86State *)pvEnv;
     3843    int          rc;
    38383844    Log2(("remR3MMIOWriteU32: GCPhys=%RGp u32=%#x\n", (RTGCPHYS)GCPhys, u32));
    3839     rc = IOMMMIOWrite((PVM)pvVM, GCPhys, u32, 4);
     3845    rc = IOMMMIOWrite(env->pVM, env->pVCpu, GCPhys, u32, 4);
    38403846    AssertMsg(rc == VINF_SUCCESS, ("rc=%Rrc\n", rc)); NOREF(rc);
    38413847}
    … …  
    45574563        Log2(("cpu_outb: addr=%#06x val=%#x\n", addr, val));
    45584564
    4559     rc = IOMIOPortWrite(env->pVM, (RTIOPORT)addr, val, 1);
     4565    rc = IOMIOPortWrite(env->pVM, env->pVCpu, (RTIOPORT)addr, val, 1);
    45604566    if (RT_LIKELY(rc == VINF_SUCCESS))
    45614567        return;
    … …  
    45724578{
    45734579    //Log2(("cpu_outw: addr=%#06x val=%#x\n", addr, val));
    4574     int rc = IOMIOPortWrite(env->pVM, (RTIOPORT)addr, val, 2);
     4580    int rc = IOMIOPortWrite(env->pVM, env->pVCpu, (RTIOPORT)addr, val, 2);
    45754581    if (RT_LIKELY(rc == VINF_SUCCESS))
    45764582        return;
    … …  
    45884594    int rc;
    45894595    Log2(("cpu_outl: addr=%#06x val=%#x\n", addr, val));
    4590     rc = IOMIOPortWrite(env->pVM, (RTIOPORT)addr, val, 4);
     4596    rc = IOMIOPortWrite(env->pVM, env->pVCpu, (RTIOPORT)addr, val, 4);
    45914597    if (RT_LIKELY(rc == VINF_SUCCESS))
    45924598        return;
    … …  
    46034609{
    46044610    uint32_t u32 = 0;
    4605     int rc = IOMIOPortRead(env->pVM, (RTIOPORT)addr, &u32, 1);
     4611    int rc = IOMIOPortRead(env->pVM, env->pVCpu, (RTIOPORT)addr, &u32, 1);
    46064612    if (RT_LIKELY(rc == VINF_SUCCESS))
    46074613    {
    … …  
    46234629{
    46244630    uint32_t u32 = 0;
    4625     int rc = IOMIOPortRead(env->pVM, (RTIOPORT)addr, &u32, 2);
     4631    int rc = IOMIOPortRead(env->pVM, env->pVCpu, (RTIOPORT)addr, &u32, 2);
    46264632    if (RT_LIKELY(rc == VINF_SUCCESS))
    46274633    {
    … …  
    46424648{
    46434649    uint32_t u32 = 0;
    4644     int rc = IOMIOPortRead(env->pVM, (RTIOPORT)addr, &u32, 4);
     4650    int rc = IOMIOPortRead(env->pVM, env->pVCpu, (RTIOPORT)addr, &u32, 4);
    46454651    if (RT_LIKELY(rc == VINF_SUCCESS))
    46464652    {
Note: See TracChangeset for help on using the changeset viewer.

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