VirtualBox

Ignore:
Timestamp:
Apr 3, 2008 5:05:29 PM (17 years ago)
Author:
vboxsync
Message:

MMIO cleanup in progress.

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r7723 r7731  
    159159 * @warning VBOX_SUCCESS(rc=VINF_IOM_HC_MMIO_WRITE) is TRUE!
    160160 */
    161 DECLINLINE(int) iomMMIODoWrite(PVM pVM, CTXALLSUFF(PIOMMMIORANGE) pRange, RTGCPHYS GCPhysFault, const void *pvData, unsigned cbSize)
     161DECLINLINE(int) iomMMIODoWrite(PVM pVM, CTXALLSUFF(PIOMMMIORANGE) pRange, RTGCPHYS GCPhysFault, const void *pvData, unsigned cb)
    162162{
    163163#ifdef VBOX_WITH_STATISTICS
    164     if (pRange->cbSize <= PAGE_SIZE)
     164    if (pRange->cb <= PAGE_SIZE)
    165165    {
    166166        PIOMMMIOSTATS pStats = iomMMIOGetStats(&pVM->iom.s, GCPhysFault);
    … …  
    168168            return VINF_IOM_HC_MMIO_WRITE;
    169169
    170         int rc = pRange->pfnWriteCallback(pRange->pDevIns, pRange->pvUser, GCPhysFault, (void *)pvData, cbSize); /* @todo fix const!! */
     170        int rc = pRange->pfnWriteCallback(pRange->pDevIns, pRange->pvUser, GCPhysFault, (void *)pvData, cb); /* @todo fix const!! */
    171171        if (rc != VINF_IOM_HC_MMIO_WRITE)
    172172            STAM_COUNTER_INC(&pStats->WriteGC);
    … …  
    174174    }
    175175#endif
    176     return pRange->pfnWriteCallback(pRange->pDevIns, pRange->pvUser, GCPhysFault, (void *)pvData, cbSize);
     176    return pRange->pfnWriteCallback(pRange->pDevIns, pRange->pvUser, GCPhysFault, (void *)pvData, cb);
    177177}
    178178
    … …  
    180180 * Wrapper which does the read and updates range statistics when such are enabled.
    181181 */
    182 DECLINLINE(int) iomMMIODoRead(PVM pVM, CTXALLSUFF(PIOMMMIORANGE) pRange, RTGCPHYS GCPhysFault, void *pvData, unsigned cbSize)
     182DECLINLINE(int) iomMMIODoRead(PVM pVM, CTXALLSUFF(PIOMMMIORANGE) pRange, RTGCPHYS GCPhysFault, void *pvData, unsigned cb)
    183183{
    184184#ifdef VBOX_WITH_STATISTICS
    185     if (pRange->cbSize <= PAGE_SIZE)
     185    if (pRange->cb <= PAGE_SIZE)
    186186    {
    187187        PIOMMMIOSTATS pStats = iomMMIOGetStats(&pVM->iom.s, GCPhysFault);
    … …  
    189189            return VINF_IOM_HC_MMIO_READ;
    190190
    191         int rc = pRange->pfnReadCallback(pRange->pDevIns, pRange->pvUser, GCPhysFault, pvData, cbSize);
     191        int rc = pRange->pfnReadCallback(pRange->pDevIns, pRange->pvUser, GCPhysFault, pvData, cb);
    192192        if (rc != VINF_IOM_HC_MMIO_READ)
    193193            STAM_COUNTER_INC(&pStats->ReadGC);
    … …  
    195195    }
    196196#endif
    197     return pRange->pfnReadCallback(pRange->pDevIns, pRange->pvUser, GCPhysFault, pvData, cbSize);
     197    return pRange->pfnReadCallback(pRange->pDevIns, pRange->pvUser, GCPhysFault, pvData, cb);
    198198}
    199199
    … …  
    373373     * and call the handler function to get the data.
    374374     */
    375     unsigned cbSize = DISGetParamSize(pCpu, &pCpu->param2);
    376     AssertMsg(cbSize > 0 && cbSize <= sizeof(uint32_t), ("cbSize=%d\n", cbSize));
     375    unsigned cb = DISGetParamSize(pCpu, &pCpu->param2);
     376    AssertMsg(cb > 0 && cb <= sizeof(uint32_t), ("cb=%d\n", cb));
    377377
    378378    uint32_t u32Data = 0;
    379     int rc = iomMMIODoRead(pVM, pRange, GCPhysFault, &u32Data, cbSize);
     379    int rc = iomMMIODoRead(pVM, pRange, GCPhysFault, &u32Data, cb);
    380380    if (rc == VINF_SUCCESS)
    381381    {
    … …  
    386386        if (pCpu->pCurInstr->opcode == OP_MOVSX)
    387387        {
    388             if (cbSize == 1)
     388            if (cb == 1)
    389389            {
    390390                /* DWORD <- BYTE */
    … …  
    408408
    409409    if (rc == VINF_SUCCESS)
    410         iomMMIOStatLength(pVM, cbSize);
     410        iomMMIOStatLength(pVM, cb);
    411411    return rc;
    412412}
    … …  
    436436     * and call the callback to write it.
    437437     */
    438     unsigned cbSize = 0;
     438    unsigned cb = 0;
    439439    uint32_t u32Data  = 0;
    440     bool fRc = iomGetRegImmData(pCpu, &pCpu->param2, pRegFrame, &u32Data, &cbSize);
     440    bool fRc = iomGetRegImmData(pCpu, &pCpu->param2, pRegFrame, &u32Data, &cb);
    441441    AssertMsg(fRc, ("Failed to get reg/imm port number!\n")); NOREF(fRc);
    442442
    443     int rc = iomMMIODoWrite(pVM, pRange, GCPhysFault, &u32Data, cbSize);
     443    int rc = iomMMIODoWrite(pVM, pRange, GCPhysFault, &u32Data, cb);
    444444    if (rc == VINF_SUCCESS)
    445         iomMMIOStatLength(pVM, cbSize);
     445        iomMMIOStatLength(pVM, cb);
    446446    return rc;
    447447}
    … …  
    523523     * Get data size.
    524524     */
    525     unsigned cbSize = DISGetParamSize(pCpu, &pCpu->param1);
    526     Assert(cbSize);
    527     int      offIncrement = pRegFrame->eflags.Bits.u1DF ? -(signed)cbSize : (signed)cbSize;
     525    unsigned cb = DISGetParamSize(pCpu, &pCpu->param1);
     526    Assert(cb);
     527    int      offIncrement = pRegFrame->eflags.Bits.u1DF ? -(signed)cb : (signed)cb;
    528528
    529529#ifdef VBOX_WITH_STATISTICS
    530     if (pVM->iom.s.cMovsMaxBytes < (cTransfers << SIZE_2_SHIFT(cbSize)))
    531         pVM->iom.s.cMovsMaxBytes = cTransfers << SIZE_2_SHIFT(cbSize);
     530    if (pVM->iom.s.cMovsMaxBytes < (cTransfers << SIZE_2_SHIFT(cb)))
     531        pVM->iom.s.cMovsMaxBytes = cTransfers << SIZE_2_SHIFT(cb);
    532532#endif
    533533
    … …  
    558558
    559559            /* Access verification first; we currently can't recover properly from traps inside this instruction */
    560             rc = PGMVerifyAccess(pVM, pu8Virt, cTransfers * cbSize, (cpl == 3) ? X86_PTE_US : 0);
     560            rc = PGMVerifyAccess(pVM, pu8Virt, cTransfers * cb, (cpl == 3) ? X86_PTE_US : 0);
    561561            if (rc != VINF_SUCCESS)
    562562            {
    … …  
    574574            {
    575575                uint32_t u32Data = 0;
    576                 rc = iomRamRead(pVM, &u32Data, (RTGCPTR)pu8Virt, cbSize);
     576                rc = iomRamRead(pVM, &u32Data, (RTGCPTR)pu8Virt, cb);
    577577                if (rc != VINF_SUCCESS)
    578578                    break;
    579                 rc = iomMMIODoWrite(pVM, pRange, Phys, &u32Data, cbSize);
     579                rc = iomMMIODoWrite(pVM, pRange, Phys, &u32Data, cb);
    580580                if (rc != VINF_SUCCESS)
    581581                    break;
    … …  
    642642            {
    643643                uint32_t u32Data;
    644                 rc = iomMMIODoRead(pVM, pRange, Phys, &u32Data, cbSize);
     644                rc = iomMMIODoRead(pVM, pRange, Phys, &u32Data, cb);
    645645                if (rc != VINF_SUCCESS)
    646646                    break;
    647                 rc = iomMMIODoWrite(pVM, pMMIODst, PhysDst, &u32Data, cbSize);
     647                rc = iomMMIODoWrite(pVM, pMMIODst, PhysDst, &u32Data, cb);
    648648                if (rc != VINF_SUCCESS)
    649649                    break;
    … …  
    666666
    667667            /* Access verification first; we currently can't recover properly from traps inside this instruction */
    668             rc = PGMVerifyAccess(pVM, pu8Virt, cTransfers * cbSize, X86_PTE_RW | ((cpl == 3) ? X86_PTE_US : 0));
     668            rc = PGMVerifyAccess(pVM, pu8Virt, cTransfers * cb, X86_PTE_RW | ((cpl == 3) ? X86_PTE_US : 0));
    669669            if (rc != VINF_SUCCESS)
    670670            {
    … …  
    681681            {
    682682                uint32_t u32Data;
    683                 rc = iomMMIODoRead(pVM, pRange, Phys, &u32Data, cbSize);
     683                rc = iomMMIODoRead(pVM, pRange, Phys, &u32Data, cb);
    684684                if (rc != VINF_SUCCESS)
    685685                    break;
    686                 rc = iomRamWrite(pVM, (RTGCPTR)pu8Virt, &u32Data, cbSize);
     686                rc = iomRamWrite(pVM, (RTGCPTR)pu8Virt, &u32Data, cb);
    687687                if (rc != VINF_SUCCESS)
    688688                {
    689                     Log(("iomRamWrite %08X size=%d failed with %d\n", pu8Virt, cbSize, rc));
     689                    Log(("iomRamWrite %08X size=%d failed with %d\n", pu8Virt, cb, rc));
    690690                    break;
    691691                }
    … …  
    712712    {
    713713        STAM_PROFILE_STOP(&pVM->iom.s.StatGCInstMovs, a);
    714         iomMMIOStatLength(pVM, cbSize);
     714        iomMMIOStatLength(pVM, cb);
    715715    }
    716716    return rc;
    … …  
    763763     * Get data size.
    764764     */
    765     unsigned cbSize = DISGetParamSize(pCpu, &pCpu->param1);
    766     Assert(cbSize);
    767     int      offIncrement = pRegFrame->eflags.Bits.u1DF ? -(signed)cbSize : (signed)cbSize;
     765    unsigned cb = DISGetParamSize(pCpu, &pCpu->param1);
     766    Assert(cb);
     767    int      offIncrement = pRegFrame->eflags.Bits.u1DF ? -(signed)cb : (signed)cb;
    768768
    769769#ifdef VBOX_WITH_STATISTICS
    770     if (pVM->iom.s.cStosMaxBytes < (cTransfers << SIZE_2_SHIFT(cbSize)))
    771         pVM->iom.s.cStosMaxBytes = cTransfers << SIZE_2_SHIFT(cbSize);
     770    if (pVM->iom.s.cStosMaxBytes < (cTransfers << SIZE_2_SHIFT(cb)))
     771        pVM->iom.s.cStosMaxBytes = cTransfers << SIZE_2_SHIFT(cb);
    772772#endif
    773773
    … …  
    785785        {
    786786            /* addr++ variant. */
    787             rc = pRange->pfnFillCallback(pRange->pDevIns, pRange->pvUser, Phys, u32Data, cbSize, cTransfers);
     787            rc = pRange->pfnFillCallback(pRange->pDevIns, pRange->pvUser, Phys, u32Data, cb, cTransfers);
    788788            if (rc == VINF_SUCCESS)
    789789            {
    790790                /* Update registers. */
    791                 pRegFrame->edi += cTransfers << SIZE_2_SHIFT(cbSize);
     791                pRegFrame->edi += cTransfers << SIZE_2_SHIFT(cb);
    792792                if (pCpu->prefix & PREFIX_REP)
    793793                    pRegFrame->ecx = 0;
    … …  
    797797        {
    798798            /* addr-- variant. */
    799             rc = pRange->pfnFillCallback(pRange->pDevIns, pRange->pvUser, (Phys - (cTransfers - 1)) << SIZE_2_SHIFT(cbSize), u32Data, cbSize, cTransfers);
     799            rc = pRange->pfnFillCallback(pRange->pDevIns, pRange->pvUser, (Phys - (cTransfers - 1)) << SIZE_2_SHIFT(cb), u32Data, cb, cTransfers);
    800800            if (rc == VINF_SUCCESS)
    801801            {
    802802                /* Update registers. */
    803                 pRegFrame->edi -= cTransfers << SIZE_2_SHIFT(cbSize);
     803                pRegFrame->edi -= cTransfers << SIZE_2_SHIFT(cb);
    804804                if (pCpu->prefix & PREFIX_REP)
    805805                    pRegFrame->ecx = 0;
    … …  
    819819        do
    820820        {
    821             rc = iomMMIODoWrite(pVM, pRange, Phys, &u32Data, cbSize);
     821            rc = iomMMIODoWrite(pVM, pRange, Phys, &u32Data, cb);
    822822            if (rc != VINF_SUCCESS)
    823823                break;
    … …  
    839839    {
    840840        STAM_PROFILE_STOP(&pVM->iom.s.StatGCInstStos, a);
    841         iomMMIOStatLength(pVM, cbSize);
     841        iomMMIOStatLength(pVM, cb);
    842842    }
    843843    return rc;
    … …  
    878878     * Get data size.
    879879     */
    880     unsigned cbSize = DISGetParamSize(pCpu, &pCpu->param2);
    881     Assert(cbSize);
    882     int     offIncrement = pRegFrame->eflags.Bits.u1DF ? -(signed)cbSize : (signed)cbSize;
     880    unsigned cb = DISGetParamSize(pCpu, &pCpu->param2);
     881    Assert(cb);
     882    int     offIncrement = pRegFrame->eflags.Bits.u1DF ? -(signed)cb : (signed)cb;
    883883
    884884    /*
    885885     * Perform read.
    886886     */
    887     int rc = iomMMIODoRead(pVM, pRange, GCPhysFault, &pRegFrame->eax, cbSize);
     887    int rc = iomMMIODoRead(pVM, pRange, GCPhysFault, &pRegFrame->eax, cb);
    888888    if (rc == VINF_SUCCESS)
    889889        pRegFrame->esi += offIncrement;
    … …  
    895895    {
    896896        STAM_PROFILE_STOP(&pVM->iom.s.StatGCInstLods, a1);
    897         iomMMIOStatLength(pVM, cbSize);
     897        iomMMIOStatLength(pVM, cb);
    898898    }
    899899    return rc;
    … …  
    927927     * Get the operands.
    928928     */
    929     unsigned cbSize = 0;
     929    unsigned cb = 0;
    930930    uint32_t uData1;
    931931    uint32_t uData2;
    932932    int rc;
    933     if (iomGetRegImmData(pCpu, &pCpu->param1, pRegFrame, &uData1, &cbSize))
     933    if (iomGetRegImmData(pCpu, &pCpu->param1, pRegFrame, &uData1, &cb))
    934934        /* cmp reg, [MMIO]. */
    935         rc = iomMMIODoRead(pVM, pRange, GCPhysFault, &uData2, cbSize);
    936     else if (iomGetRegImmData(pCpu, &pCpu->param2, pRegFrame, &uData2, &cbSize))
     935        rc = iomMMIODoRead(pVM, pRange, GCPhysFault, &uData2, cb);
     936    else if (iomGetRegImmData(pCpu, &pCpu->param2, pRegFrame, &uData2, &cb))
    937937        /* cmp [MMIO], reg|imm. */
    938         rc = iomMMIODoRead(pVM, pRange, GCPhysFault, &uData1, cbSize);
     938        rc = iomMMIODoRead(pVM, pRange, GCPhysFault, &uData1, cb);
    939939    else
    940940    {
    … …  
    946946    {
    947947        /* Emulate CMP and update guest flags. */
    948         uint32_t eflags = EMEmulateCmp(uData1, uData2, cbSize);
     948        uint32_t eflags = EMEmulateCmp(uData1, uData2, cb);
    949949        pRegFrame->eflags.u32 = (pRegFrame->eflags.u32 & ~(X86_EFL_CF | X86_EFL_PF | X86_EFL_AF | X86_EFL_ZF | X86_EFL_SF | X86_EFL_OF))
    950950                              | (eflags                &  (X86_EFL_CF | X86_EFL_PF | X86_EFL_AF | X86_EFL_ZF | X86_EFL_SF | X86_EFL_OF));
    951951
    952952        STAM_PROFILE_STOP(&pVM->iom.s.StatGCInstCmp, a1);
    953         iomMMIOStatLength(pVM, cbSize);
     953        iomMMIOStatLength(pVM, cb);
    954954    }
    955955
    … …  
    979979    /* Check read callback. */
    980980
    981     unsigned    cbSize = 0;
     981    unsigned    cb = 0;
    982982    uint32_t    uData1;
    983983    uint32_t    uData2;
    984984    bool        fAndWrite;
    985985    int         rc;
    986     if (iomGetRegImmData(pCpu, &pCpu->param1, pRegFrame, &uData1, &cbSize))
     986    if (iomGetRegImmData(pCpu, &pCpu->param1, pRegFrame, &uData1, &cb))
    987987    {
    988988        /* and reg, [MMIO]. */
    989989        fAndWrite = false;
    990990        if (pRange->pfnReadCallback)
    991             rc = iomMMIODoRead(pVM, pRange, GCPhysFault, &uData2, cbSize);
     991            rc = iomMMIODoRead(pVM, pRange, GCPhysFault, &uData2, cb);
    992992        else
    993993            rc = VINF_IOM_HC_MMIO_READ;
    994994    }
    995     else if (iomGetRegImmData(pCpu, &pCpu->param2, pRegFrame, &uData2, &cbSize))
     995    else if (iomGetRegImmData(pCpu, &pCpu->param2, pRegFrame, &uData2, &cb))
    996996    {
    997997        /* and [MMIO], reg|imm. */
    998998        fAndWrite = true;
    999999        if (pRange->pfnReadCallback && pRange->pfnWriteCallback)
    1000             rc = iomMMIODoRead(pVM, pRange, GCPhysFault, &uData1, cbSize);
     1000            rc = iomMMIODoRead(pVM, pRange, GCPhysFault, &uData1, cb);
    10011001        else
    10021002            rc = VINF_IOM_HC_MMIO_READ_WRITE;
    … …  
    10111011    {
    10121012        /* Emulate AND and update guest flags. */
    1013         uint32_t eflags = EMEmulateAnd(&uData1, uData2, cbSize);
     1013        uint32_t eflags = EMEmulateAnd(&uData1, uData2, cb);
    10141014        if (fAndWrite)
    10151015            /* Store result to MMIO. */
    1016             rc = iomMMIODoWrite(pVM, pRange, GCPhysFault, &uData1, cbSize);
     1016            rc = iomMMIODoWrite(pVM, pRange, GCPhysFault, &uData1, cb);
    10171017        else
    10181018        {
    … …  
    10271027                                  | (eflags                &  (X86_EFL_CF | X86_EFL_PF | X86_EFL_AF | X86_EFL_ZF | X86_EFL_SF | X86_EFL_OF));
    10281028            STAM_PROFILE_STOP(&pVM->iom.s.StatGCInstAnd, a1);
    1029             iomMMIOStatLength(pVM, cbSize);
     1029            iomMMIOStatLength(pVM, cb);
    10301030        }
    10311031    }
    … …  
    10571057    /* Check read callback. */
    10581058
    1059     unsigned    cbSize = 0;
     1059    unsigned    cb = 0;
    10601060    uint32_t    uData1;
    10611061    uint32_t    uData2;
    10621062    int         rc;
    10631063
    1064     if (iomGetRegImmData(pCpu, &pCpu->param1, pRegFrame, &uData1, &cbSize))
     1064    if (iomGetRegImmData(pCpu, &pCpu->param1, pRegFrame, &uData1, &cb))
    10651065    {
    10661066        /* and test, [MMIO]. */
    10671067        if (pRange->pfnReadCallback)
    1068             rc = iomMMIODoRead(pVM, pRange, GCPhysFault, &uData2, cbSize);
     1068            rc = iomMMIODoRead(pVM, pRange, GCPhysFault, &uData2, cb);
    10691069        else
    10701070            rc = VINF_IOM_HC_MMIO_READ;
    10711071    }
    1072     else if (iomGetRegImmData(pCpu, &pCpu->param2, pRegFrame, &uData2, &cbSize))
     1072    else if (iomGetRegImmData(pCpu, &pCpu->param2, pRegFrame, &uData2, &cb))
    10731073    {
    10741074        /* test [MMIO], reg|imm. */
    10751075        if (pRange->pfnReadCallback)
    1076             rc = iomMMIODoRead(pVM, pRange, GCPhysFault, &uData1, cbSize);
     1076            rc = iomMMIODoRead(pVM, pRange, GCPhysFault, &uData1, cb);
    10771077        else
    10781078            rc = VINF_IOM_HC_MMIO_READ;
    … …  
    10871087    {
    10881088        /* Emulate TEST (=AND without write back) and update guest EFLAGS. */
    1089         uint32_t eflags = EMEmulateAnd(&uData1, uData2, cbSize);
     1089        uint32_t eflags = EMEmulateAnd(&uData1, uData2, cb);
    10901090        pRegFrame->eflags.u32 = (pRegFrame->eflags.u32 & ~(X86_EFL_CF | X86_EFL_PF | X86_EFL_AF | X86_EFL_ZF | X86_EFL_SF | X86_EFL_OF))
    10911091                              | (eflags                &  (X86_EFL_CF | X86_EFL_PF | X86_EFL_AF | X86_EFL_ZF | X86_EFL_SF | X86_EFL_OF));
    10921092        STAM_PROFILE_STOP(&pVM->iom.s.StatGCInstTest, a1);
    1093         iomMMIOStatLength(pVM, cbSize);
     1093        iomMMIOStatLength(pVM, cb);
    10941094    }
    10951095
    … …  
    11171117
    11181118    /* Check read callback. */
    1119     unsigned    cbSize = 0;
     1119    unsigned    cb = 0;
    11201120    uint32_t    uData1;
    11211121    uint32_t    uData2;
    … …  
    11281128    }
    11291129
    1130     if (iomGetRegImmData(pCpu, &pCpu->param1, pRegFrame, &uData1, &cbSize))
     1130    if (iomGetRegImmData(pCpu, &pCpu->param1, pRegFrame, &uData1, &cb))
    11311131    {
    11321132        /* xchg reg, [MMIO]. */
    1133         rc = iomMMIODoRead(pVM, pRange, GCPhysFault, &uData2, cbSize);
     1133        rc = iomMMIODoRead(pVM, pRange, GCPhysFault, &uData2, cb);
    11341134        if (rc == VINF_SUCCESS)
    11351135        {
    11361136            /* Store result to MMIO. */
    1137             rc = iomMMIODoWrite(pVM, pRange, GCPhysFault, &uData1, cbSize);
     1137            rc = iomMMIODoWrite(pVM, pRange, GCPhysFault, &uData1, cb);
    11381138
    11391139            if (rc == VINF_SUCCESS)
    … …  
    11501150    }
    11511151    else
    1152     if (iomGetRegImmData(pCpu, &pCpu->param2, pRegFrame, &uData2, &cbSize))
     1152    if (iomGetRegImmData(pCpu, &pCpu->param2, pRegFrame, &uData2, &cb))
    11531153    {
    11541154        /* xchg [MMIO], reg. */
    1155         rc = iomMMIODoRead(pVM, pRange, GCPhysFault, &uData1, cbSize);
     1155        rc = iomMMIODoRead(pVM, pRange, GCPhysFault, &uData1, cb);
    11561156        if (rc == VINF_SUCCESS)
    11571157        {
    11581158            /* Store result to MMIO. */
    1159             rc = iomMMIODoWrite(pVM, pRange, GCPhysFault, &uData2, cbSize);
     1159            rc = iomMMIODoWrite(pVM, pRange, GCPhysFault, &uData2, cb);
    11601160
    11611161            if (rc == VINF_SUCCESS)
    … …  
    14121412#ifdef VBOX_WITH_STATISTICS
    14131413    PIOMMMIOSTATS pStats = iomMMIOGetStats(&pVM->iom.s, GCPhys);
    1414     if (!pStats && (!pRange || pRange->cbSize <= PAGE_SIZE))
     1414    if (!pStats && (!pRange || pRange->cb <= PAGE_SIZE))
    14151415# ifdef IN_RING3
    14161416        pStats = iomR3MMIOStatsCreate(pVM, GCPhys, pRange ? pRange->pszDesc : NULL);
    … …  
    15131513#ifdef VBOX_WITH_STATISTICS
    15141514    PIOMMMIOSTATS pStats = iomMMIOGetStats(&pVM->iom.s, GCPhys);
    1515     if (!pStats && (!pRange || pRange->cbSize <= PAGE_SIZE))
     1515    if (!pStats && (!pRange || pRange->cb <= PAGE_SIZE))
    15161516# ifdef IN_RING3
    15171517        pStats = iomR3MMIOStatsCreate(pVM, GCPhys, pRange ? pRange->pszDesc : NULL);
    … …  
    17071707     * disassembler). And get the I/O register size from the opcode / prefix.
    17081708     */
    1709     uint32_t    uPort = pRegFrame->edx & 0xffff;
    1710     unsigned    cbSize = 0;
     1709    RTIOPORT    Port = pRegFrame->edx & 0xffff;
     1710    unsigned    cb = 0;
    17111711    if (pCpu->pCurInstr->opcode == OP_INSB)
    1712         cbSize = 1;
     1712        cb = 1;
    17131713    else
    1714         cbSize = pCpu->opmode == CPUMODE_32BIT ? 4 : 2;
    1715 
    1716     int rc = IOMInterpretCheckPortIOAccess(pVM, pRegFrame, uPort, cbSize);
     1714        cb = pCpu->opmode == CPUMODE_32BIT ? 4 : 2;
     1715
     1716    int rc = IOMInterpretCheckPortIOAccess(pVM, pRegFrame, Port, cb);
    17171717    if (RT_UNLIKELY(rc != VINF_SUCCESS))
    17181718    {
    … …  
    17211721    }
    17221722
    1723     return IOMInterpretINSEx(pVM, pRegFrame, uPort, pCpu->prefix, cbSize);
     1723    return IOMInterpretINSEx(pVM, pRegFrame, Port, pCpu->prefix, cb);
    17241724}
    17251725
    … …  
    18651865     * And get the I/O register size from the opcode / prefix.
    18661866     */
    1867     uint32_t    uPort = 0;
    1868     unsigned    cbSize = 0;
    1869     bool fRc = iomGetRegImmData(pCpu, &pCpu->param1, pRegFrame, &uPort, &cbSize);
     1867    uint32_t    Port = 0;
     1868    unsigned    cb = 0;
     1869    bool fRc = iomGetRegImmData(pCpu, &pCpu->param1, pRegFrame, &Port, &cb);
    18701870    AssertMsg(fRc, ("Failed to get reg/imm port number!\n")); NOREF(fRc);
    18711871    if (pCpu->pCurInstr->opcode == OP_OUTSB)
    1872         cbSize = 1;
     1872        cb = 1;
    18731873    else
    1874         cbSize = (pCpu->opmode == CPUMODE_32BIT) ? 4 : 2;
    1875 
    1876     int rc = IOMInterpretCheckPortIOAccess(pVM, pRegFrame, uPort, cbSize);
     1874        cb = (pCpu->opmode == CPUMODE_32BIT) ? 4 : 2;
     1875
     1876    int rc = IOMInterpretCheckPortIOAccess(pVM, pRegFrame, Port, cb);
    18771877    if (RT_UNLIKELY(rc != VINF_SUCCESS))
    18781878    {
    … …  
    18811881    }
    18821882
    1883     return IOMInterpretOUTSEx(pVM, pRegFrame, uPort, pCpu->prefix, cbSize);
    1884 }
    1885 
     1883    return IOMInterpretOUTSEx(pVM, pRegFrame, Port, pCpu->prefix, cb);
     1884}
     1885
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