VirtualBox

Changeset 55966 in vbox for trunk/src/VBox/VMM/VMMAll


Ignore:
Timestamp:
May 20, 2015 12:42:53 PM (10 years ago)
Author:
vboxsync
Message:

PGM,++: VBOXSTRICTRC for physical access handlers.

Location:
trunk/src/VBox/VMM/VMMAll
Files:
5 edited

Legend:

Unmodified
Added
Removed

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

    r55909 r55966  
    276276 * @warning RT_SUCCESS(rc=VINF_IOM_R3_MMIO_WRITE) is TRUE!
    277277 */
    278 static int iomMMIODoWrite(PVM pVM, PVMCPU pVCpu, PIOMMMIORANGE pRange, RTGCPHYS GCPhysFault, const void *pvData, unsigned cb)
     278static VBOXSTRICTRC iomMMIODoWrite(PVM pVM, PVMCPU pVCpu, PIOMMMIORANGE pRange, RTGCPHYS GCPhysFault,
     279                                   const void *pvData, unsigned cb)
    279280{
    280281#ifdef VBOX_WITH_STATISTICS
    … …  
    292293#endif
    293294
    294     VBOXSTRICTRC rc;
     295    VBOXSTRICTRC rcStrict;
    295296    if (RT_LIKELY(pRange->CTX_SUFF(pfnWriteCallback)))
    296297    {
    … …  
    298299            || (pRange->fFlags & IOMMMIO_FLAGS_WRITE_MODE) == IOMMMIO_FLAGS_WRITE_PASSTHRU
    299300            || (cb == 8 && !(GCPhysFault & 7) && IOMMMIO_DOES_WRITE_MODE_ALLOW_QWORD(pRange->fFlags)) )
    300             rc = pRange->CTX_SUFF(pfnWriteCallback)(pRange->CTX_SUFF(pDevIns), pRange->CTX_SUFF(pvUser),
    301                                                     GCPhysFault, (void *)pvData, cb); /** @todo fix const!! */
     301            rcStrict = pRange->CTX_SUFF(pfnWriteCallback)(pRange->CTX_SUFF(pDevIns), pRange->CTX_SUFF(pvUser),
     302                                                          GCPhysFault, (void *)pvData, cb); /** @todo fix const!! */
    302303        else
    303             rc = iomMMIODoComplicatedWrite(pVM, pRange, GCPhysFault, pvData, cb);
     304            rcStrict = iomMMIODoComplicatedWrite(pVM, pRange, GCPhysFault, pvData, cb);
    304305    }
    305306    else
    306         rc = VINF_SUCCESS;
     307        rcStrict = VINF_SUCCESS;
    307308
    308309    STAM_PROFILE_STOP(&pStats->CTX_SUFF_Z(ProfWrite), a);
    309310    STAM_COUNTER_INC(&pStats->Accesses);
    310     return VBOXSTRICTRC_TODO(rc);
     311    return rcStrict;
    311312}
    312313
    … …  
    492493 * Wrapper which does the read and updates range statistics when such are enabled.
    493494 */
    494 DECLINLINE(int) iomMMIODoRead(PVM pVM, PVMCPU pVCpu, PIOMMMIORANGE pRange, RTGCPHYS GCPhys, void *pvValue, unsigned cbValue)
     495DECLINLINE(VBOXSTRICTRC) iomMMIODoRead(PVM pVM, PVMCPU pVCpu, PIOMMMIORANGE pRange, RTGCPHYS GCPhys,
     496                                       void *pvValue, unsigned cbValue)
    495497{
    496498#ifdef VBOX_WITH_STATISTICS
    … …  
    508510#endif
    509511
    510     VBOXSTRICTRC rc;
     512    VBOXSTRICTRC rcStrict;
    511513    if (RT_LIKELY(pRange->CTX_SUFF(pfnReadCallback)))
    512514    {
    … …  
    517519                && !(GCPhys & 7)
    518520                && (pRange->fFlags & IOMMMIO_FLAGS_READ_MODE) == IOMMMIO_FLAGS_READ_DWORD_QWORD ) )
    519             rc = pRange->CTX_SUFF(pfnReadCallback)(pRange->CTX_SUFF(pDevIns), pRange->CTX_SUFF(pvUser), GCPhys, pvValue, cbValue);
     521            rcStrict = pRange->CTX_SUFF(pfnReadCallback)(pRange->CTX_SUFF(pDevIns), pRange->CTX_SUFF(pvUser), GCPhys,
     522                                                         pvValue, cbValue);
    520523        else
    521             rc = iomMMIODoComplicatedRead(pVM, pRange, GCPhys, pvValue, cbValue);
     524            rcStrict = iomMMIODoComplicatedRead(pVM, pRange, GCPhys, pvValue, cbValue);
    522525    }
    523526    else
    524         rc = VINF_IOM_MMIO_UNUSED_FF;
    525     if (rc != VINF_SUCCESS)
    526     {
    527         switch (VBOXSTRICTRC_VAL(rc))
     527        rcStrict = VINF_IOM_MMIO_UNUSED_FF;
     528    if (rcStrict != VINF_SUCCESS)
     529    {
     530        switch (VBOXSTRICTRC_VAL(rcStrict))
    528531        {
    529             case VINF_IOM_MMIO_UNUSED_FF: rc = iomMMIODoReadFFs(pvValue, cbValue); break;
    530             case VINF_IOM_MMIO_UNUSED_00: rc = iomMMIODoRead00s(pvValue, cbValue); break;
     532            case VINF_IOM_MMIO_UNUSED_FF: rcStrict = iomMMIODoReadFFs(pvValue, cbValue); break;
     533            case VINF_IOM_MMIO_UNUSED_00: rcStrict = iomMMIODoRead00s(pvValue, cbValue); break;
    531534        }
    532535    }
    … …  
    534537    STAM_PROFILE_STOP(&pStats->CTX_SUFF_Z(ProfRead), a);
    535538    STAM_COUNTER_INC(&pStats->Accesses);
    536     return VBOXSTRICTRC_VAL(rc);
     539    return rcStrict;
    537540}
    538541
    … …  
    596599
    597600    uint64_t u64Data = 0;
    598     int rc = iomMMIODoRead(pVM, pVCpu, pRange, GCPhysFault, &u64Data, cb);
     601    int rc = VBOXSTRICTRC_TODO(iomMMIODoRead(pVM, pVCpu, pRange, GCPhysFault, &u64Data, cb));
    599602    if (rc == VINF_SUCCESS)
    600603    {
    … …  
    658661    AssertMsg(fRc, ("Failed to get reg/imm port number!\n")); NOREF(fRc);
    659662
    660     int rc = iomMMIODoWrite(pVM, pVCpu, pRange, GCPhysFault, &u64Data, cb);
     663    int rc = VBOXSTRICTRC_TODO(iomMMIODoWrite(pVM, pVCpu, pRange, GCPhysFault, &u64Data, cb));
    661664    if (rc == VINF_SUCCESS)
    662665        iomMMIOStatLength(pVM, cb);
    … …  
    809812                if (rc != VINF_SUCCESS)
    810813                    break;
    811                 rc = iomMMIODoWrite(pVM, pRange, Phys, &u32Data, cb);
     814                rc = VBOXSTRICTRC_TODO(iomMMIODoWrite(pVM, pRange, Phys, &u32Data, cb));
    812815                if (rc != VINF_SUCCESS)
    813816                    break;
    … …  
    874877            {
    875878                uint32_t u32Data;
    876                 rc = iomMMIODoRead(pVM, pRange, Phys, &u32Data, cb);
     879                rc = VBOXSTRICTRC_TODO(iomMMIODoRead(pVM, pRange, Phys, &u32Data, cb));
    877880                if (rc != VINF_SUCCESS)
    878881                    break;
    879                 rc = iomMMIODoWrite(pVM, pMMIODst, PhysDst, &u32Data, cb);
     882                rc = VBOXSTRICTRC_TODO(iomMMIODoWrite(pVM, pMMIODst, PhysDst, &u32Data, cb));
    880883                if (rc != VINF_SUCCESS)
    881884                    break;
    … …  
    909912            {
    910913                uint32_t u32Data;
    911                 rc = iomMMIODoRead(pVM, pRange, Phys, &u32Data, cb);
     914                rc = VBOXSTRICTRC_TODO(iomMMIODoRead(pVM, pRange, Phys, &u32Data, cb));
    912915                if (rc != VINF_SUCCESS)
    913916                    break;
    … …  
    10721075        do
    10731076        {
    1074             rc = iomMMIODoWrite(pVM, pVCpu, pRange, Phys, &u64Data, cb);
     1077            rc = VBOXSTRICTRC_TODO(iomMMIODoWrite(pVM, pVCpu, pRange, Phys, &u64Data, cb));
    10751078            if (rc != VINF_SUCCESS)
    10761079                break;
    … …  
    11351138     * Perform read.
    11361139     */
    1137     int rc = iomMMIODoRead(pVM, pVCpu, pRange, GCPhysFault, &pRegFrame->rax, cb);
     1140    int rc = VBOXSTRICTRC_TODO(iomMMIODoRead(pVM, pVCpu, pRange, GCPhysFault, &pRegFrame->rax, cb));
    11381141    if (rc == VINF_SUCCESS)
    11391142    {
    … …  
    11811184    if (iomGetRegImmData(pCpu, &pCpu->Param1, pRegFrame, &uData1, &cb))
    11821185        /* cmp reg, [MMIO]. */
    1183         rc = iomMMIODoRead(pVM, pVCpu, pRange, GCPhysFault, &uData2, cb);
     1186        rc = VBOXSTRICTRC_TODO(iomMMIODoRead(pVM, pVCpu, pRange, GCPhysFault, &uData2, cb));
    11841187    else if (iomGetRegImmData(pCpu, &pCpu->Param2, pRegFrame, &uData2, &cb))
    11851188        /* cmp [MMIO], reg|imm. */
    1186         rc = iomMMIODoRead(pVM, pVCpu, pRange, GCPhysFault, &uData1, cb);
     1189        rc = VBOXSTRICTRC_TODO(iomMMIODoRead(pVM, pVCpu, pRange, GCPhysFault, &uData1, cb));
    11871190    else
    11881191    {
    … …  
    12601263        Assert(pRange->CTX_SUFF(pfnReadCallback) || !pRange->pfnReadCallbackR3);
    12611264        fAndWrite = false;
    1262         rc = iomMMIODoRead(pVM, pVCpu, pRange, GCPhysFault, &uData2, cb);
     1265        rc = VBOXSTRICTRC_TODO(iomMMIODoRead(pVM, pVCpu, pRange, GCPhysFault, &uData2, cb));
    12631266    }
    12641267    else if (iomGetRegImmData(pCpu, &pCpu->Param2, pRegFrame, &uData2, &cb))
    … …  
    12731276        if (    (pRange->CTX_SUFF(pfnReadCallback) || !pRange->pfnReadCallbackR3)
    12741277            &&  (pRange->CTX_SUFF(pfnWriteCallback) || !pRange->pfnWriteCallbackR3))
    1275             rc = iomMMIODoRead(pVM, pVCpu, pRange, GCPhysFault, &uData1, cb);
     1278            rc = VBOXSTRICTRC_TODO(iomMMIODoRead(pVM, pVCpu, pRange, GCPhysFault, &uData1, cb));
    12761279        else
    12771280            rc = VINF_IOM_R3_MMIO_READ_WRITE;
    … …  
    12921295        if (fAndWrite)
    12931296            /* Store result to MMIO. */
    1294             rc = iomMMIODoWrite(pVM, pVCpu, pRange, GCPhysFault, &uData1, cb);
     1297            rc = VBOXSTRICTRC_TODO(iomMMIODoWrite(pVM, pVCpu, pRange, GCPhysFault, &uData1, cb));
    12951298        else
    12961299        {
    … …  
    13411344    {
    13421345        /* and test, [MMIO]. */
    1343         rc = iomMMIODoRead(pVM, pVCpu, pRange, GCPhysFault, &uData2, cb);
     1346        rc = VBOXSTRICTRC_TODO(iomMMIODoRead(pVM, pVCpu, pRange, GCPhysFault, &uData2, cb));
    13441347    }
    13451348    else if (iomGetRegImmData(pCpu, &pCpu->Param2, pRegFrame, &uData2, &cb))
    13461349    {
    13471350        /* test [MMIO], reg|imm. */
    1348         rc = iomMMIODoRead(pVM, pVCpu, pRange, GCPhysFault, &uData1, cb);
     1351        rc = VBOXSTRICTRC_TODO(iomMMIODoRead(pVM, pVCpu, pRange, GCPhysFault, &uData1, cb));
    13491352    }
    13501353    else
    … …  
    14061409
    14071410    /* bt [MMIO], reg|imm. */
    1408     int rc = iomMMIODoRead(pVM, pVCpu, pRange, GCPhysFault, &uData, cbData);
     1411    int rc = VBOXSTRICTRC_TODO(iomMMIODoRead(pVM, pVCpu, pRange, GCPhysFault, &uData, cbData));
    14091412    if (rc == VINF_SUCCESS)
    14101413    {
    … …  
    14481451    {
    14491452        /* xchg reg, [MMIO]. */
    1450         rc = iomMMIODoRead(pVM, pVCpu, pRange, GCPhysFault, &uData2, cb);
     1453        rc = VBOXSTRICTRC_TODO(iomMMIODoRead(pVM, pVCpu, pRange, GCPhysFault, &uData2, cb));
    14511454        if (rc == VINF_SUCCESS)
    14521455        {
    14531456            /* Store result to MMIO. */
    1454             rc = iomMMIODoWrite(pVM, pVCpu, pRange, GCPhysFault, &uData1, cb);
     1457            rc = VBOXSTRICTRC_TODO(iomMMIODoWrite(pVM, pVCpu, pRange, GCPhysFault, &uData1, cb));
    14551458
    14561459            if (rc == VINF_SUCCESS)
    … …  
    14691472    {
    14701473        /* xchg [MMIO], reg. */
    1471         rc = iomMMIODoRead(pVM, pVCpu, pRange, GCPhysFault, &uData1, cb);
     1474        rc = VBOXSTRICTRC_TODO(iomMMIODoRead(pVM, pVCpu, pRange, GCPhysFault, &uData1, cb));
    14721475        if (rc == VINF_SUCCESS)
    14731476        {
    14741477            /* Store result to MMIO. */
    1475             rc = iomMMIODoWrite(pVM, pVCpu, pRange, GCPhysFault, &uData2, cb);
     1478            rc = VBOXSTRICTRC_TODO(iomMMIODoWrite(pVM, pVCpu, pRange, GCPhysFault, &uData2, cb));
    14761479            if (rc == VINF_SUCCESS)
    14771480            {
    … …  
    17431746 * @param   pvUser      Pointer to the MMIO ring-3 range entry.
    17441747 */
    1745 DECLEXPORT(int) iomMmioPfHandler(PVM pVM, PVMCPU pVCpu, RTGCUINT uErrorCode, PCPUMCTXCORE pCtxCore, RTGCPTR pvFault,
    1746                                  RTGCPHYS GCPhysFault, void *pvUser)
     1748DECLEXPORT(VBOXSTRICTRC) iomMmioPfHandler(PVM pVM, PVMCPU pVCpu, RTGCUINT uErrorCode, PCPUMCTXCORE pCtxCore, RTGCPTR pvFault,
     1749                                          RTGCPHYS GCPhysFault, void *pvUser)
    17471750{
    17481751    LogFlow(("iomMmioPfHandler: GCPhys=%RGp uErr=%#x pvFault=%RGv rip=%RGv\n",
    17491752             GCPhysFault, (uint32_t)uErrorCode, pvFault, (RTGCPTR)pCtxCore->rip));
    1750     VBOXSTRICTRC rcStrict = iomMMIOHandler(pVM, pVCpu, (uint32_t)uErrorCode, pCtxCore, GCPhysFault, pvUser);
    1751     return VBOXSTRICTRC_VAL(rcStrict);
     1753    return iomMMIOHandler(pVM, pVCpu, (uint32_t)uErrorCode, pCtxCore, GCPhysFault, pvUser);
    17521754}
    17531755
    … …  
    18031805 * @param   pvUser          Pointer to the MMIO range entry.
    18041806 */
    1805 PGM_ALL_CB2_DECL(int) iomMmioHandler(PVM pVM, PVMCPU pVCpu, RTGCPHYS GCPhysFault, void *pvPhys, void *pvBuf, size_t cbBuf,
    1806                                      PGMACCESSTYPE enmAccessType, PGMACCESSORIGIN enmOrigin, void *pvUser)
     1807PGM_ALL_CB2_DECL(VBOXSTRICTRC) iomMmioHandler(PVM pVM, PVMCPU pVCpu, RTGCPHYS GCPhysFault, void *pvPhys, void *pvBuf,
     1808                                              size_t cbBuf, PGMACCESSTYPE enmAccessType, PGMACCESSORIGIN enmOrigin, void *pvUser)
    18071809{
    18081810    PIOMMMIORANGE pRange = (PIOMMMIORANGE)pvUser;
    … …  
    18361838     * Perform the access.
    18371839     */
     1840    VBOXSTRICTRC rcStrict;
    18381841    if (enmAccessType == PGMACCESSTYPE_READ)
    1839         rc = iomMMIODoRead(pVM, pVCpu, pRange, GCPhysFault, pvBuf, (unsigned)cbBuf);
     1842        rcStrict = iomMMIODoRead(pVM, pVCpu, pRange, GCPhysFault, pvBuf, (unsigned)cbBuf);
    18401843    else
    1841         rc = iomMMIODoWrite(pVM, pVCpu, pRange, GCPhysFault, pvBuf, (unsigned)cbBuf);
    1842 
    1843     AssertRC(rc);
     1844        rcStrict = iomMMIODoWrite(pVM, pVCpu, pRange, GCPhysFault, pvBuf, (unsigned)cbBuf);
     1845    AssertRC(rcStrict);
     1846
    18441847    iomMmioReleaseRange(pVM, pRange);
    18451848    PDMCritSectLeave(pDevIns->CTX_SUFF(pCritSectRo));
    1846     return rc;
     1849    return rcStrict;
    18471850}
    18481851

  • trunk/src/VBox/VMM/VMMAll/PGMAllBth.h

    r55903 r55966  
    164164#endif
    165165    PVM             pVM         = pVCpu->CTX_SUFF(pVM);
    166     int             rc;
     166    VBOXSTRICTRC    rcStrict;
    167167
    168168    if (PGM_PAGE_HAS_ANY_PHYSICAL_HANDLERS(pPage))
    … …  
    193193            {
    194194#   if PGM_WITH_PAGING(PGM_GST_TYPE, PGM_SHW_TYPE)
    195                 rc = PGM_BTH_NAME(SyncPage)(pVCpu, pGstWalk->Pde, pvFault, PGM_SYNC_NR_PAGES, uErr);
     195                rcStrict = PGM_BTH_NAME(SyncPage)(pVCpu, pGstWalk->Pde, pvFault, PGM_SYNC_NR_PAGES, uErr);
    196196#   else
    197                 rc = PGM_BTH_NAME(SyncPage)(pVCpu, PdeSrcDummy, pvFault, PGM_SYNC_NR_PAGES, uErr);
     197                rcStrict = PGM_BTH_NAME(SyncPage)(pVCpu, PdeSrcDummy, pvFault, PGM_SYNC_NR_PAGES, uErr);
    198198#   endif
    199                 if (    RT_FAILURE(rc)
     199                if (    RT_FAILURE(rcStrict)
    200200                    || !(uErr & X86_TRAP_PF_RW)
    201                     || rc == VINF_PGM_SYNCPAGE_MODIFIED_PDE)
     201                    || rcStrict == VINF_PGM_SYNCPAGE_MODIFIED_PDE)
    202202                {
    203                     AssertRC(rc);
     203                    AssertRC(rcStrict);
    204204                    STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_SUFF(pStats)->StatRZTrap0eHandlersOutOfSync);
    205205                    STAM_STATS({ pVCpu->pgm.s.CTX_SUFF(pStatTrap0eAttribution) = &pVCpu->pgm.s.CTX_SUFF(pStats)->StatRZTrap0eTime2OutOfSyncHndPhys; });
    206                     return rc;
     206                    return rcStrict;
    207207                }
    208208            }
    … …  
    221221            {
    222222#   if PGM_WITH_PAGING(PGM_GST_TYPE, PGM_SHW_TYPE)
    223                 rc = PGM_BTH_NAME(SyncPage)(pVCpu, pGstWalk->Pde, pvFault, PGM_SYNC_NR_PAGES, uErr);
     223                rcStrict = PGM_BTH_NAME(SyncPage)(pVCpu, pGstWalk->Pde, pvFault, PGM_SYNC_NR_PAGES, uErr);
    224224#   else
    225                 rc = PGM_BTH_NAME(SyncPage)(pVCpu, PdeSrcDummy, pvFault, PGM_SYNC_NR_PAGES, uErr);
     225                rcStrict = PGM_BTH_NAME(SyncPage)(pVCpu, PdeSrcDummy, pvFault, PGM_SYNC_NR_PAGES, uErr);
    226226#   endif
    227                 if (    RT_FAILURE(rc)
    228                     || rc == VINF_PGM_SYNCPAGE_MODIFIED_PDE)
     227                if (    RT_FAILURE(rcStrict)
     228                    || rcStrict == VINF_PGM_SYNCPAGE_MODIFIED_PDE)
    229229                {
    230                     AssertRC(rc);
     230                    AssertRC(rcStrict);
    231231                    STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_SUFF(pStats)->StatRZTrap0eHandlersOutOfSync);
    232232                    STAM_STATS({ pVCpu->pgm.s.CTX_SUFF(pStatTrap0eAttribution) = &pVCpu->pgm.s.CTX_SUFF(pStats)->StatRZTrap0eTime2OutOfSyncHndPhys; });
    233                     return rc;
     233                    return rcStrict;
    234234                }
    235235            }
    … …  
    260260                }
    261261
    262                 rc = pCurType->CTX_SUFF(pfnPfHandler)(pVM, pVCpu, uErr, pRegFrame, pvFault, GCPhysFault, pvUser);
     262                rcStrict = pCurType->CTX_SUFF(pfnPfHandler)(pVM, pVCpu, uErr, pRegFrame, pvFault, GCPhysFault, pvUser);
    263263
    264264#  ifdef VBOX_WITH_STATISTICS
    … …  
    271271            }
    272272            else
    273                 rc = VINF_EM_RAW_EMULATE_INSTR;
     273                rcStrict = VINF_EM_RAW_EMULATE_INSTR;
    274274
    275275            STAM_STATS({ pVCpu->pgm.s.CTX_SUFF(pStatTrap0eAttribution) = &pVCpu->pgm.s.CTX_SUFF(pStats)->StatRZTrap0eTime2HndPhys; });
    276             return rc;
     276            return rcStrict;
    277277        }
    278278    }
    … …  
    289289            && !(uErr & X86_TRAP_PF_P))
    290290        {
    291             rc = PGM_BTH_NAME(SyncPage)(pVCpu, pGstWalk->Pde, pvFault, PGM_SYNC_NR_PAGES, uErr);
    292             if (    RT_FAILURE(rc)
    293                 ||  rc == VINF_PGM_SYNCPAGE_MODIFIED_PDE
     291            rcStrict = PGM_BTH_NAME(SyncPage)(pVCpu, pGstWalk->Pde, pvFault, PGM_SYNC_NR_PAGES, uErr);
     292            if (    RT_FAILURE(rcStrict)
     293                ||  rcStrict == VINF_PGM_SYNCPAGE_MODIFIED_PDE
    294294                ||  !(uErr & X86_TRAP_PF_RW))
    295295            {
    296                 AssertRC(rc);
     296                AssertRC(rcStrict);
    297297                STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_SUFF(pStats)->StatRZTrap0eHandlersOutOfSync);
    298298                STAM_STATS({ pVCpu->pgm.s.CTX_SUFF(pStatTrap0eAttribution) = &pVCpu->pgm.s.CTX_SUFF(pStats)->StatRZTrap0eTime2OutOfSyncHndVirt; });
    299                 return rc;
     299                return rcStrict;
    300300            }
    301301        }
    … …  
    334334                *pfLockTaken = false;
    335335
    336                 rc = pCurType->CTX_SUFF(pfnPfHandler)(pVM, pVCpu, uErr, pRegFrame, pvFault, GCPtrStart,
    337                                                       pvFault - GCPtrStart, pvUser);
     336                rcStrict = pCurType->CTX_SUFF(pfnPfHandler)(pVM, pVCpu, uErr, pRegFrame, pvFault, GCPtrStart,
     337                                                            pvFault - GCPtrStart, pvUser);
    338338
    339339#    ifdef VBOX_WITH_STATISTICS
    … …  
    345345#    endif
    346346#   else
    347                 rc = VINF_EM_RAW_EMULATE_INSTR; /** @todo for VMX */
     347                rcStrict = VINF_EM_RAW_EMULATE_INSTR; /** @todo for VMX */
    348348#   endif
    349349                STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_SUFF(pStats)->StatRZTrap0eHandlersVirtual);
    350350                STAM_STATS({ pVCpu->pgm.s.CTX_SUFF(pStatTrap0eAttribution) = &pVCpu->pgm.s.CTX_SUFF(pStats)->StatRZTrap0eTime2HndVirt; });
    351                 return rc;
     351                return rcStrict;
    352352            }
    353353            /* Unhandled part of a monitored page */
    … …  
    358358           /* Check by physical address. */
    359359            unsigned iPage;
    360             rc = pgmHandlerVirtualFindByPhysAddr(pVM, pGstWalk->Core.GCPhys, &pCur, &iPage);
    361             Assert(RT_SUCCESS(rc) || !pCur);
     360            pCur = pgmHandlerVirtualFindByPhysAddr(pVM, pGstWalk->Core.GCPhys, &iPage);
    362361            if (pCur)
    363362            {
    … …  
    379378                                - (GCPtrStart & PAGE_OFFSET_MASK);
    380379                    Assert(off < pCur->cb);
    381                     rc = pCurType->CTX_SUFF(pfnPfHandler)(pVM, pVCpu, uErr, pRegFrame, pvFault, GCPtrStart, off, pvUser);
     380                    rcStrict = pCurType->CTX_SUFF(pfnPfHandler)(pVM, pVCpu, uErr, pRegFrame, pvFault, GCPtrStart, off, pvUser);
    382381
    383382#    ifdef VBOX_WITH_STATISTICS
    … …  
    389388#    endif
    390389#   else
    391                     rc = VINF_EM_RAW_EMULATE_INSTR; /** @todo for VMX */
     390                    rcStrict = VINF_EM_RAW_EMULATE_INSTR; /** @todo for VMX */
    392391#   endif
    393392                    STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_SUFF(pStats)->StatRZTrap0eHandlersVirtualByPhys);
    394393                    STAM_STATS({ pVCpu->pgm.s.CTX_SUFF(pStatTrap0eAttribution) = &pVCpu->pgm.s.CTX_SUFF(pStats)->StatRZTrap0eTime2HndVirt; });
    395                     return rc;
     394                    return rcStrict;
    396395                }
    397396            }
    … …  
    414413    {
    415414#  if PGM_WITH_PAGING(PGM_GST_TYPE, PGM_SHW_TYPE)
    416         rc = PGM_BTH_NAME(SyncPage)(pVCpu, pGstWalk->Pde, pvFault, PGM_SYNC_NR_PAGES, uErr);
     415        rcStrict = PGM_BTH_NAME(SyncPage)(pVCpu, pGstWalk->Pde, pvFault, PGM_SYNC_NR_PAGES, uErr);
    417416#  else
    418         rc = PGM_BTH_NAME(SyncPage)(pVCpu, PdeSrcDummy, pvFault, PGM_SYNC_NR_PAGES, uErr);
    419 #  endif
    420         if (    RT_FAILURE(rc)
    421             ||  rc == VINF_PGM_SYNCPAGE_MODIFIED_PDE
     417        rcStrict = PGM_BTH_NAME(SyncPage)(pVCpu, PdeSrcDummy, pvFault, PGM_SYNC_NR_PAGES, uErr);
     418#  endif
     419        if (    RT_FAILURE(rcStrict)
     420            ||  rcStrict == VINF_PGM_SYNCPAGE_MODIFIED_PDE
    422421            ||  !(uErr & X86_TRAP_PF_RW))
    423422        {
    424             AssertRC(rc);
     423            AssertRC(rcStrict);
    425424            STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_SUFF(pStats)->StatRZTrap0eHandlersOutOfSync);
    426425            STAM_STATS({ pVCpu->pgm.s.CTX_SUFF(pStatTrap0eAttribution) = &pVCpu->pgm.s.CTX_SUFF(pStats)->StatRZTrap0eTime2OutOfSyncHndPhys; });
    427             return rc;
     426            return rcStrict;
    428427        }
    429428    }
    … …  
    432431     *        It's writing to an unhandled part of the LDT page several million times.
    433432     */
    434     rc = VBOXSTRICTRC_TODO(PGMInterpretInstruction(pVM, pVCpu, pRegFrame, pvFault));
    435     LogFlow(("PGM: PGMInterpretInstruction -> rc=%d pPage=%R[pgmpage]\n", rc, pPage));
     433    rcStrict = PGMInterpretInstruction(pVM, pVCpu, pRegFrame, pvFault);
     434    LogFlow(("PGM: PGMInterpretInstruction -> rcStrict=%d pPage=%R[pgmpage]\n", VBOXSTRICTRC_VAL(rcStrict), pPage));
    436435    STAM_STATS({ pVCpu->pgm.s.CTX_SUFF(pStatTrap0eAttribution) = &pVCpu->pgm.s.CTX_SUFF(pStats)->StatRZTrap0eTime2HndUnhandled; });
    437     return rc;
     436    return rcStrict;
    438437} /* if any kind of handler */
    439438

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

    r55889 r55966  
    164164        case PGMPHYSHANDLERKIND_MMIO:
    165165        case PGMPHYSHANDLERKIND_ALL:
    166             /* Simplification for PGMPhysRead, PGMR0Trap0eHandlerNPMisconfig and others. */
     166            /* Simplification for PGMPhysRead, PGMR0Trap0eHandlerNPMisconfig and others: Full pages. */
    167167            AssertMsgReturn(!(GCPhys & PAGE_OFFSET_MASK), ("%RGp\n", GCPhys), VERR_INVALID_PARAMETER);
    168168            AssertMsgReturn((GCPhysLast & PAGE_OFFSET_MASK) == PAGE_OFFSET_MASK, ("%RGp\n", GCPhysLast), VERR_INVALID_PARAMETER);
    … …  
    14551455 * Search for virtual handler with matching physical address
    14561456 *
    1457  * @returns VBox status code
     1457 * @returns Pointer to the virtual handler structure if found, otherwise NULL.
    14581458 * @param   pVM         Pointer to the VM.
    14591459 * @param   GCPhys      GC physical address to search for.
    1460  * @param   ppVirt      Where to store the pointer to the virtual handler structure.
    14611460 * @param   piPage      Where to store the pointer to the index of the cached physical page.
    14621461 */
    1463 int pgmHandlerVirtualFindByPhysAddr(PVM pVM, RTGCPHYS GCPhys, PPGMVIRTHANDLER *ppVirt, unsigned *piPage)
     1462PPGMVIRTHANDLER pgmHandlerVirtualFindByPhysAddr(PVM pVM, RTGCPHYS GCPhys, unsigned *piPage)
    14641463{
    14651464    STAM_PROFILE_START(&pVM->pgm.s.CTX_MID_Z(Stat,VirtHandlerSearchByPhys), a);
    1466     Assert(ppVirt);
    14671465
    14681466    pgmLock(pVM);
    … …  
    14721470    {
    14731471        /* found a match! */
    1474         *ppVirt = (PPGMVIRTHANDLER)((uintptr_t)pCur + pCur->offVirtHandler);
    1475         *piPage = pCur - &(*ppVirt)->aPhysToVirt[0];
     1472        PPGMVIRTHANDLER pVirt = (PPGMVIRTHANDLER)((uintptr_t)pCur + pCur->offVirtHandler);
     1473        *piPage = pCur - &pVirt->aPhysToVirt[0];
    14761474        pgmUnlock(pVM);
    14771475
    … …  
    14791477        AssertRelease(pCur->offNextAlias & PGMPHYS2VIRTHANDLER_IS_HEAD);
    14801478#endif
    1481         LogFlow(("PHYS2VIRT: found match for %RGp -> %RGv *piPage=%#x\n", GCPhys, (*ppVirt)->Core.Key, *piPage));
     1479        LogFlow(("PHYS2VIRT: found match for %RGp -> %RGv *piPage=%#x\n", GCPhys, pVirt->Core.Key, *piPage));
    14821480        STAM_PROFILE_STOP(&pVM->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,VirtHandlerSearchByPhys), a);
    1483         return VINF_SUCCESS;
     1481        return pVirt;
    14841482    }
    14851483
    14861484    pgmUnlock(pVM);
    1487     *ppVirt = NULL;
    14881485    STAM_PROFILE_STOP(&pVM->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,VirtHandlerSearchByPhys), a);
    1489     return VERR_PGM_HANDLER_NOT_FOUND;
     1486    return NULL;
    14901487}
    14911488

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

    r55909 r55966  
    6666 * @param   pvUser      User argument.
    6767 */
    68 VMMDECL(int) pgmPhysPfHandlerRedirectToHC(PVM pVM, PVMCPU pVCpu, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault,
    69                                           RTGCPHYS GCPhysFault, void *pvUser)
     68VMMDECL(VBOXSTRICTRC) pgmPhysPfHandlerRedirectToHC(PVM pVM, PVMCPU pVCpu, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame,
     69                                                   RTGCPTR pvFault, RTGCPHYS GCPhysFault, void *pvUser)
    7070{
    7171    NOREF(pVM); NOREF(pVCpu); NOREF(uErrorCode); NOREF(pRegFrame); NOREF(pvFault); NOREF(GCPhysFault); NOREF(pvUser);
    … …  
    8888 * @param   pvUser      User argument. Pointer to the ROM range structure.
    8989 */
    90 DECLEXPORT(int) pgmPhysRomWritePfHandler(PVM pVM, PVMCPU pVCpu, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault,
    91                                          RTGCPHYS GCPhysFault, void *pvUser)
     90DECLEXPORT(VBOXSTRICTRC) pgmPhysRomWritePfHandler(PVM pVM, PVMCPU pVCpu, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame,
     91                                                  RTGCPTR pvFault, RTGCPHYS GCPhysFault, void *pvUser)
    9292{
    9393    int             rc;
    … …  
    167167 * @param   pvUser          User argument.
    168168 */
    169 PGM_ALL_CB2_DECL(int) pgmPhysRomWriteHandler(PVM pVM, PVMCPU pVCpu, RTGCPHYS GCPhys, void *pvPhys, void *pvBuf, size_t cbBuf,
    170                                              PGMACCESSTYPE enmAccessType, PGMACCESSORIGIN enmOrigin, void *pvUser)
     169PGM_ALL_CB2_DECL(VBOXSTRICTRC)
     170pgmPhysRomWriteHandler(PVM pVM, PVMCPU pVCpu, RTGCPHYS GCPhys, void *pvPhys, void *pvBuf, size_t cbBuf,
     171                       PGMACCESSTYPE enmAccessType, PGMACCESSORIGIN enmOrigin, void *pvUser)
    171172{
    172173    PPGMROMRANGE    pRom     = (PPGMROMRANGE)pvUser;
    … …  
    21802181 * Deals with reading from a page with one or more ALL access handlers.
    21812182 *
    2182  * @returns VBox status code. Can be ignored in ring-3.
     2183 * @returns Strict VBox status code in ring-0 and raw-mode, ignorable in ring-3.
    21832184 * @retval  VINF_SUCCESS.
    2184  * @retval  VERR_PGM_PHYS_WR_HIT_HANDLER in R0 and GC, NEVER in R3.
     2185 * @retval  VERR_PGM_PHYS_WR_HIT_HANDLER in R0 and GC, NEVER in R3 or with
     2186 *          PGMACCESSORIGIN_IEM.
    21852187 *
    21862188 * @param   pVM         Pointer to the VM.
    … …  
    21912193 * @param   enmOrigin       The origin of this call.
    21922194 */
    2193 static int pgmPhysReadHandler(PVM pVM, PPGMPAGE pPage, RTGCPHYS GCPhys, void *pvBuf, size_t cb, PGMACCESSORIGIN enmOrigin)
     2195static VBOXSTRICTRC pgmPhysReadHandler(PVM pVM, PPGMPAGE pPage, RTGCPHYS GCPhys, void *pvBuf, size_t cb,
     2196                                       PGMACCESSORIGIN enmOrigin)
    21942197{
    21952198    /*
    … …  
    22112214        return VINF_SUCCESS;
    22122215    }
    2213     rc = VINF_PGM_HANDLER_DO_DEFAULT;
     2216
     2217    VBOXSTRICTRC rcStrict = VINF_PGM_HANDLER_DO_DEFAULT;
    22142218
    22152219    /*
    … …  
    22382242        /* Release the PGM lock as MMIO handlers take the IOM lock. (deadlock prevention) */
    22392243        pgmUnlock(pVM);
    2240         rc = pfnHandler(pVM, pVCpu, GCPhys, (void *)pvSrc, pvBuf, cb, PGMACCESSTYPE_READ, enmOrigin, pvUser);
     2244        rcStrict = pfnHandler(pVM, pVCpu, GCPhys, (void *)pvSrc, pvBuf, cb, PGMACCESSTYPE_READ, enmOrigin, pvUser);
    22412245        pgmLock(pVM);
    22422246# ifdef VBOX_WITH_STATISTICS
    … …  
    22472251        pPhys = NULL; /* might not be valid anymore. */
    22482252# endif
    2249         AssertLogRelMsg(rc == VINF_SUCCESS || rc == VINF_PGM_HANDLER_DO_DEFAULT, ("rc=%Rrc GCPhys=%RGp\n", rc, GCPhys));
     2253        AssertLogRelMsg(rcStrict == VINF_SUCCESS || rcStrict == VINF_PGM_HANDLER_DO_DEFAULT,
     2254                        ("rcStrict=%Rrc GCPhys=%RGp\n", VBOXSTRICTRC_VAL(rcStrict), GCPhys));
     2255
    22502256#else
    22512257        /* In R0 and RC the callbacks cannot handle this context, so we'll fail. */
    … …  
    22622268    {
    22632269        unsigned        iPage;
    2264         PPGMVIRTHANDLER pVirt;
    2265 
    2266         int rc2 = pgmHandlerVirtualFindByPhysAddr(pVM, GCPhys, &pVirt, &iPage);
    2267         AssertReleaseMsg(RT_SUCCESS(rc2), ("GCPhys=%RGp cb=%#x rc2=%Rrc\n", GCPhys, cb, rc2));
     2270        PPGMVIRTHANDLER pVirt = pgmHandlerVirtualFindByPhysAddr(pVM, GCPhys, &iPage);
     2271        AssertReleaseMsg(pVirt, ("GCPhys=%RGp cb=%#x\n", GCPhys, cb));
    22682272        Assert((pVirt->Core.Key     & PAGE_OFFSET_MASK) == 0);
    22692273        Assert((pVirt->Core.KeyLast & PAGE_OFFSET_MASK) == PAGE_OFFSET_MASK);
    … …  
    22832287
    22842288            STAM_PROFILE_START(&pVirt->Stat, h);
    2285             rc2 = pVirtType->CTX_SUFF(pfnHandler)(pVM, pVCpu, GCPtr, (void *)pvSrc, pvBuf, cb, PGMACCESSTYPE_READ, enmOrigin,
    2286                                                   pVirt->CTX_SUFF(pvUser));
     2289            VBOXSTRICTRC rcStrict2 = pVirtType->CTX_SUFF(pfnHandler)(pVM, pVCpu, GCPtr, (void *)pvSrc, pvBuf, cb,
     2290                                                                     PGMACCESSTYPE_READ, enmOrigin, pVirt->CTX_SUFF(pvUser));
    22872291            STAM_PROFILE_STOP(&pVirt->Stat, h);
    2288             if (rc2 == VINF_SUCCESS)
    2289                 rc = VINF_SUCCESS;
    2290             AssertLogRelMsg(rc2 == VINF_SUCCESS || rc2 == VINF_PGM_HANDLER_DO_DEFAULT, ("rc=%Rrc GCPhys=%RGp pPage=%R[pgmpage] %s\n", rc2, GCPhys, pPage, pVirt->pszDesc));
     2292            if (rcStrict2 == VINF_SUCCESS)
     2293                rcStrict = rcStrict == VINF_PGM_HANDLER_DO_DEFAULT ? VINF_SUCCESS : rcStrict;
     2294            else if (rcStrict2 != VINF_PGM_HANDLER_DO_DEFAULT)
     2295            {
     2296                AssertLogRelMsgFailed(("rcStrict2=%Rrc GCPhys=%RGp pPage=%R[pgmpage] %s\n",
     2297                                       VBOXSTRICTRC_VAL(rcStrict2), GCPhys, pPage, pVirt->pszDesc));
     2298                if (rcStrict == VINF_SUCCESS || rcStrict == VINF_PGM_HANDLER_DO_DEFAULT || rcStrict2 < rcStrict)
     2299                    rcStrict = rcStrict2;
     2300            }
    22912301        }
    22922302        else
    … …  
    23032313     * Take the default action.
    23042314     */
    2305     if (rc == VINF_PGM_HANDLER_DO_DEFAULT)
     2315    if (rcStrict == VINF_PGM_HANDLER_DO_DEFAULT)
     2316    {
    23062317        memcpy(pvBuf, pvSrc, cb);
     2318        rcStrict = VINF_SUCCESS;
     2319    }
    23072320    pgmPhysReleaseInternalPageMappingLock(pVM, &PgMpLck);
    2308     return rc;
     2321    return rcStrict;
    23092322}
    23102323
    … …  
    23582371
    23592372                /*
    2360                  * Any ALL access handlers?
     2373                 * Normal page? Get the pointer to it.
    23612374                 */
    2362                 if (RT_UNLIKELY(   PGM_PAGE_HAS_ACTIVE_ALL_HANDLERS(pPage)
    2363                                 || PGM_PAGE_IS_SPECIAL_ALIAS_MMIO(pPage)))
    2364                 {
    2365                     int rc = pgmPhysReadHandler(pVM, pPage, pRam->GCPhys + off, pvBuf, cb, enmOrigin);
    2366                     if (RT_FAILURE(rc))
    2367                     {
    2368                         pgmUnlock(pVM);
    2369                         return rc;
    2370                     }
    2371                 }
    2372                 else
     2375                if (   !PGM_PAGE_HAS_ACTIVE_ALL_HANDLERS(pPage)
     2376                    && !PGM_PAGE_IS_SPECIAL_ALIAS_MMIO(pPage))
    23732377                {
    23742378                    /*
    … …  
    23902394                    }
    23912395                }
     2396                /*
     2397                 * Have ALL/MMIO access handlers.
     2398                 */
     2399                else
     2400                {
     2401                    VBOXSTRICTRC rcStrict = pgmPhysReadHandler(pVM, pPage, pRam->GCPhys + off, pvBuf, cb, enmOrigin);
     2402                    if (rcStrict != VINF_SUCCESS)
     2403                    {
     2404                        pgmUnlock(pVM);
     2405                        return VBOXSTRICTRC_TODO(rcStrict);
     2406                    }
     2407                }
    23922408
    23932409                /* next page */
    … …  
    24372453 * Deals with writing to a page with one or more WRITE or ALL access handlers.
    24382454 *
    2439  * @returns VBox status code. Can be ignored in ring-3.
     2455 * @returns Strict VBox status code in ring-0 and raw-mode, ignorable in ring-3.
    24402456 * @retval  VINF_SUCCESS.
    2441  * @retval  VERR_PGM_PHYS_WR_HIT_HANDLER in R0 and GC, NEVER in R3.
     2457 * @retval  VERR_PGM_PHYS_WR_HIT_HANDLER in R0 and GC, NEVER in R3 or with
     2458 *          PGMACCESSORIGIN_IEM.
    24422459 *
    24432460 * @param   pVM         Pointer to the VM.
    … …  
    24462463 * @param   pvBuf       What to write.
    24472464 * @param   cbWrite     How much to write - less or equal to a page.
    2448  * @param   enmOrigin       The origin of this call.
    2449  */
    2450 static int pgmPhysWriteHandler(PVM pVM, PPGMPAGE pPage, RTGCPHYS GCPhys, void const *pvBuf, size_t cbWrite,
    2451                                PGMACCESSORIGIN enmOrigin)
     2465 * @param   enmOrigin   The origin of this call.
     2466 */
     2467static VBOXSTRICTRC pgmPhysWriteHandler(PVM pVM, PPGMPAGE pPage, RTGCPHYS GCPhys, void const *pvBuf, size_t cbWrite,
     2468                                        PGMACCESSORIGIN enmOrigin)
    24522469{
    24532470    PGMPAGEMAPLOCK  PgMpLck;
    24542471    void           *pvDst = NULL;
    2455     int             rc;
     2472    VBOXSTRICTRC    rcStrict;
    24562473
    24572474    /*
    … …  
    24862503                  GCPhys, cbRange, pPage, R3STRING(pCur->pszDesc) ));
    24872504            if (!PGM_PAGE_IS_MMIO_OR_SPECIAL_ALIAS(pPage))
    2488                 rc = pgmPhysGCPhys2CCPtrInternal(pVM, pPage, GCPhys, &pvDst, &PgMpLck);
     2505                rcStrict = pgmPhysGCPhys2CCPtrInternal(pVM, pPage, GCPhys, &pvDst, &PgMpLck);
    24892506            else
    2490                 rc = VINF_SUCCESS;
    2491             if (RT_SUCCESS(rc))
     2507                rcStrict = VINF_SUCCESS;
     2508            if (RT_SUCCESS(rcStrict))
    24922509            {
    24932510                PFNPGMPHYSHANDLER pfnHandler = PGMPHYSHANDLER_GET_TYPE(pVM, pCur)->CTX_SUFF(pfnHandler);
    … …  
    24982515                /* Release the PGM lock as MMIO handlers take the IOM lock. (deadlock prevention) */
    24992516                pgmUnlock(pVM);
    2500                 rc = pfnHandler(pVM, pVCpu, GCPhys, pvDst, (void *)pvBuf, cbRange, PGMACCESSTYPE_WRITE, enmOrigin, pvUser);
     2517                rcStrict = pfnHandler(pVM, pVCpu, GCPhys, pvDst, (void *)pvBuf, cbRange, PGMACCESSTYPE_WRITE, enmOrigin, pvUser);
    25012518                pgmLock(pVM);
    25022519# ifdef VBOX_WITH_STATISTICS
    … …  
    25072524                pCur = NULL; /* might not be valid anymore. */
    25082525# endif
    2509                 if (rc == VINF_PGM_HANDLER_DO_DEFAULT && pvDst)
     2526                if (rcStrict == VINF_PGM_HANDLER_DO_DEFAULT)
    25102527                {
    25112528                    if (pvDst)
    25122529                        memcpy(pvDst, pvBuf, cbRange);
     2530                    rcStrict = VINF_SUCCESS;
    25132531                }
    25142532                else
    2515                     AssertLogRelMsg(rc == VINF_SUCCESS || rc == VINF_PGM_HANDLER_DO_DEFAULT,
    2516                                     ("rc=%Rrc GCPhys=%RGp pPage=%R[pgmpage] %s\n", rc, GCPhys, pPage, pCur ? pCur->pszDesc : ""));
     2533                    AssertLogRelMsg(rcStrict == VINF_SUCCESS,
     2534                                    ("rcStrict=%Rrc GCPhys=%RGp pPage=%R[pgmpage] %s\n",
     2535                                     VBOXSTRICTRC_VAL(rcStrict), GCPhys, pPage, pCur ? pCur->pszDesc : ""));
    25172536            }
    25182537            else
    25192538                AssertLogRelMsgFailedReturn(("pgmPhysGCPhys2CCPtrInternal failed on %RGp / %R[pgmpage] -> %Rrc\n",
    2520                                              GCPhys, pPage, rc), rc);
    2521             if (RT_LIKELY(cbRange == cbWrite))
     2539                                             GCPhys, pPage, VBOXSTRICTRC_VAL(rcStrict)), rcStrict);
     2540            if (RT_LIKELY(cbRange == cbWrite) || rcStrict != VINF_SUCCESS)
    25222541            {
    25232542                if (pvDst)
    25242543                    pgmPhysReleaseInternalPageMappingLock(pVM, &PgMpLck);
    2525                 return VINF_SUCCESS;
     2544                return rcStrict;
    25262545            }
    25272546
    … …  
    25432562    {
    25442563        unsigned        iPage;
    2545         PPGMVIRTHANDLER pCur;
    2546         rc = pgmHandlerVirtualFindByPhysAddr(pVM, GCPhys, &pCur, &iPage);
    2547         if (RT_SUCCESS(rc))
    2548         {
    2549             PPGMVIRTHANDLERTYPEINT pCurType = PGMVIRTANDLER_GET_TYPE(pVM, pCur);
    2550 
    2551             size_t cbRange = (PAGE_OFFSET_MASK & pCur->Core.KeyLast) - (PAGE_OFFSET_MASK & GCPhys) + 1;
     2564        PPGMVIRTHANDLER pVirt = pgmHandlerVirtualFindByPhysAddr(pVM, GCPhys, &iPage);
     2565        if (pVirt)
     2566        {
     2567            PPGMVIRTHANDLERTYPEINT pVirtType = PGMVIRTANDLER_GET_TYPE(pVM, pVirt);
     2568
     2569            size_t cbRange = (PAGE_OFFSET_MASK & pVirt->Core.KeyLast) - (PAGE_OFFSET_MASK & GCPhys) + 1;
    25522570            if (cbRange > cbWrite)
    25532571                cbRange = cbWrite;
    … …  
    25612579#else  /* IN_RING3 */
    25622580
    2563             Log5(("pgmPhysWriteHandler: GCPhys=%RGp cbRange=%#x pPage=%R[pgmpage] virt %s\n", GCPhys, cbRange, pPage, R3STRING(pCur->pszDesc) ));
    2564             rc = pgmPhysGCPhys2CCPtrInternal(pVM, pPage, GCPhys, &pvDst, &PgMpLck);
    2565             if (RT_SUCCESS(rc))
     2581            Log5(("pgmPhysWriteHandler: GCPhys=%RGp cbRange=%#x pPage=%R[pgmpage] virt %s\n",
     2582                  GCPhys, cbRange, pPage, R3STRING(pVirt->pszDesc) ));
     2583            rcStrict = pgmPhysGCPhys2CCPtrInternal(pVM, pPage, GCPhys, &pvDst, &PgMpLck);
     2584            if (RT_SUCCESS(rcStrict))
    25662585            {
    2567                 rc = VINF_PGM_HANDLER_DO_DEFAULT;
    2568                 if (pCurType->pfnHandlerR3)
     2586                if (pVirtType->pfnHandlerR3)
    25692587                {
    2570                     RTGCUINTPTR GCPtr = ((RTGCUINTPTR)pCur->Core.Key & PAGE_BASE_GC_MASK)
     2588                    RTGCUINTPTR GCPtr = ((RTGCUINTPTR)pVirt->Core.Key & PAGE_BASE_GC_MASK)
    25712589                                      + (iPage << PAGE_SHIFT)
    25722590                                      + (GCPhys & PAGE_OFFSET_MASK);
    25732591
    2574                     STAM_PROFILE_START(&pCur->Stat, h);
    2575                     rc = pCurType->CTX_SUFF(pfnHandler)(pVM, pVCpu, GCPtr, pvDst, (void *)pvBuf, cbRange, PGMACCESSTYPE_WRITE,
    2576                                                         enmOrigin, pCur->CTX_SUFF(pvUser));
    2577                     STAM_PROFILE_STOP(&pCur->Stat, h);
     2592                    STAM_PROFILE_START(&pVirt->Stat, h);
     2593                    rcStrict = pVirtType->CTX_SUFF(pfnHandler)(pVM, pVCpu, GCPtr, pvDst, (void *)pvBuf, cbRange,
     2594                                                               PGMACCESSTYPE_WRITE, enmOrigin, pVirt->CTX_SUFF(pvUser));
     2595                    STAM_PROFILE_STOP(&pVirt->Stat, h);
    25782596                }
    2579                 if (rc == VINF_PGM_HANDLER_DO_DEFAULT)
     2597                else
     2598                    rcStrict = VINF_PGM_HANDLER_DO_DEFAULT;
     2599                if (rcStrict == VINF_PGM_HANDLER_DO_DEFAULT)
     2600                {
    25802601                    memcpy(pvDst, pvBuf, cbRange);
     2602                    rcStrict = VINF_SUCCESS;
     2603                }
    25812604                else
    2582                     AssertLogRelMsg(rc == VINF_SUCCESS, ("rc=%Rrc GCPhys=%RGp pPage=%R[pgmpage] %s\n", rc, GCPhys, pPage, pCur->pszDesc));
     2605                    AssertLogRelMsg(rcStrict == VINF_SUCCESS,
     2606                                    ("rcStrict=%Rrc GCPhys=%RGp pPage=%R[pgmpage] %s\n",
     2607                                     VBOXSTRICTRC_VAL(rcStrict), GCPhys, pPage, pVirt->pszDesc));
    25832608            }
    25842609            else
    25852610                AssertLogRelMsgFailedReturn(("pgmPhysGCPhys2CCPtrInternal failed on %RGp / %R[pgmpage] -> %Rrc\n",
    2586                                              GCPhys, pPage, rc), rc);
    2587             if (RT_LIKELY(cbRange == cbWrite))
     2611                                             GCPhys, pPage, VBOXSTRICTRC_VAL(rcStrict)), rcStrict);
     2612            if (RT_LIKELY(cbRange == cbWrite) || rcStrict != VINF_SUCCESS)
    25882613            {
    25892614                pgmPhysReleaseInternalPageMappingLock(pVM, &PgMpLck);
    2590                 return VINF_SUCCESS;
     2615                return rcStrict;
    25912616            }
    25922617
    … …  
    26082633    if (!pvDst)
    26092634    {
    2610         rc = pgmPhysGCPhys2CCPtrInternal(pVM, pPage, GCPhys, &pvDst, &PgMpLck);
    2611         AssertLogRelMsgReturn(RT_SUCCESS(rc),
     2635        rcStrict = pgmPhysGCPhys2CCPtrInternal(pVM, pPage, GCPhys, &pvDst, &PgMpLck);
     2636        AssertLogRelMsgReturn(RT_SUCCESS(rcStrict),
    26122637                              ("pgmPhysGCPhys2CCPtrInternal failed on %RGp / %R[pgmpage] -> %Rrc\n",
    2613                                GCPhys, pPage, rc), rc);
     2638                               GCPhys, pPage, VBOXSTRICTRC_VAL(rcStrict)), rcStrict);
    26142639    }
    26152640
    … …  
    26342659        if (fMoreVirt && !pVirt)
    26352660        {
    2636             rc = pgmHandlerVirtualFindByPhysAddr(pVM, GCPhys, &pVirt, &iVirtPage);
    2637             if (RT_SUCCESS(rc))
     2661            pVirt = pgmHandlerVirtualFindByPhysAddr(pVM, GCPhys, &iVirtPage);
     2662            if (pVirt)
    26382663            {
    26392664                offVirt = 0;
    … …  
    26962721         * Handle access to space without handlers (that's easy).
    26972722         */
    2698         rc = VINF_PGM_HANDLER_DO_DEFAULT;
     2723        rcStrict = VINF_PGM_HANDLER_DO_DEFAULT;
    26992724        uint32_t cbRange = (uint32_t)cbWrite;
    27002725        if (offPhys && offVirt)
    … …  
    27242749            /* Release the PGM lock as MMIO handlers take the IOM lock. (deadlock prevention) */
    27252750            pgmUnlock(pVM);
    2726             rc = pfnHandler(pVM, pVCpu, GCPhys, pvDst, (void *)pvBuf, cbRange, PGMACCESSTYPE_WRITE, enmOrigin, pvUser);
     2751            rcStrict = pfnHandler(pVM, pVCpu, GCPhys, pvDst, (void *)pvBuf, cbRange, PGMACCESSTYPE_WRITE, enmOrigin, pvUser);
    27272752            pgmLock(pVM);
    27282753# ifdef VBOX_WITH_STATISTICS
    … …  
    27332758            pPhys = NULL; /* might not be valid anymore. */
    27342759# endif
    2735             AssertLogRelMsg(rc == VINF_SUCCESS || rc == VINF_PGM_HANDLER_DO_DEFAULT, ("rc=%Rrc GCPhys=%RGp pPage=%R[pgmpage] %s\n", rc, GCPhys, pPage, (pPhys) ? pPhys->pszDesc : ""));
     2760            AssertLogRelMsg(rcStrict == VINF_SUCCESS || rcStrict == VINF_PGM_HANDLER_DO_DEFAULT,
     2761                            ("rcStrict=%Rrc GCPhys=%RGp pPage=%R[pgmpage] %s\n",
     2762                             VBOXSTRICTRC_VAL(rcStrict), GCPhys, pPage, (pPhys) ? pPhys->pszDesc : ""));
    27362763#else
    27372764            /* In R0 and RC the callbacks cannot handle this context, so we'll fail. */
    … …  
    27612788                                  + (GCPhys & PAGE_OFFSET_MASK);
    27622789                STAM_PROFILE_START(&pVirt->Stat, h);
    2763                 rc = pVirtType->CTX_SUFF(pfnHandler)(pVM, pVCpu, GCPtr, pvDst, (void *)pvBuf, cbRange, PGMACCESSTYPE_WRITE,
    2764                                                      enmOrigin, pVirt->CTX_SUFF(pvUser));
     2790                rcStrict = pVirtType->CTX_SUFF(pfnHandler)(pVM, pVCpu, GCPtr, pvDst, (void *)pvBuf, cbRange, PGMACCESSTYPE_WRITE,
     2791                                                           enmOrigin, pVirt->CTX_SUFF(pvUser));
    27652792                STAM_PROFILE_STOP(&pVirt->Stat, h);
    2766                 AssertLogRelMsg(rc == VINF_SUCCESS || rc == VINF_PGM_HANDLER_DO_DEFAULT, ("rc=%Rrc GCPhys=%RGp pPage=%R[pgmpage] %s\n", rc, GCPhys, pPage, pVirt->pszDesc));
     2793                AssertLogRelMsg(rcStrict == VINF_SUCCESS || rcStrict == VINF_PGM_HANDLER_DO_DEFAULT,
     2794                                ("rcStrict=%Rrc GCPhys=%RGp pPage=%R[pgmpage] %s\n",
     2795                                 VBOXSTRICTRC_VAL(rcStrict), GCPhys, pPage, pVirt->pszDesc));
    27672796            }
    27682797            pVirt = NULL;
    … …  
    27992828            /* Release the PGM lock as MMIO handlers take the IOM lock. (deadlock prevention) */
    28002829            pgmUnlock(pVM);
    2801             rc = pfnHandler(pVM, pVCpu, GCPhys, pvDst, (void *)pvBuf, cbRange, PGMACCESSTYPE_WRITE, enmOrigin, pvUser);
     2830            rcStrict = pfnHandler(pVM, pVCpu, GCPhys, pvDst, (void *)pvBuf, cbRange, PGMACCESSTYPE_WRITE, enmOrigin, pvUser);
    28022831            pgmLock(pVM);
    28032832# ifdef VBOX_WITH_STATISTICS
    … …  
    28082837            pPhys = NULL; /* might not be valid anymore. */
    28092838# endif
    2810             AssertLogRelMsg(rc == VINF_SUCCESS || rc == VINF_PGM_HANDLER_DO_DEFAULT, ("rc=%Rrc GCPhys=%RGp pPage=%R[pgmpage] %s\n", rc, GCPhys, pPage, (pPhys) ? pPhys->pszDesc : ""));
     2839            AssertLogRelMsg(rcStrict == VINF_SUCCESS || rcStrict == VINF_PGM_HANDLER_DO_DEFAULT,
     2840                            ("rcStrict=%Rrc GCPhys=%RGp pPage=%R[pgmpage] %s\n",
     2841                             VBOXSTRICTRC_VAL(rcStrict), GCPhys, pPage, (pPhys) ? pPhys->pszDesc : ""));
    28112842            if (pVirtType->pfnHandlerR3)
    28122843            {
    … …  
    28162847                                  + (GCPhys & PAGE_OFFSET_MASK);
    28172848                STAM_PROFILE_START(&pVirt->Stat, h2);
    2818                 int rc2 = pVirtType->CTX_SUFF(pfnHandler)(pVM, pVCpu, GCPtr, pvDst, (void *)pvBuf, cbRange, PGMACCESSTYPE_WRITE,
    2819                                                           enmOrigin, pVirt->CTX_SUFF(pvUser));
     2849                VBOXSTRICTRC rcStrict2 = pVirtType->CTX_SUFF(pfnHandler)(pVM, pVCpu, GCPtr, pvDst, (void *)pvBuf, cbRange,
     2850                                                                         PGMACCESSTYPE_WRITE, enmOrigin, pVirt->CTX_SUFF(pvUser));
    28202851                STAM_PROFILE_STOP(&pVirt->Stat, h2);
    2821                 if (rc2 == VINF_SUCCESS && rc == VINF_PGM_HANDLER_DO_DEFAULT)
    2822                     rc = VINF_SUCCESS;
    2823                 else
    2824                     AssertLogRelMsg(rc2 == VINF_SUCCESS || rc2 == VINF_PGM_HANDLER_DO_DEFAULT, ("rc=%Rrc GCPhys=%RGp pPage=%R[pgmpage] %s\n", rc, GCPhys, pPage, pVirt->pszDesc));
     2852                if (rcStrict2 == VINF_SUCCESS)
     2853                    rcStrict = rcStrict == VINF_PGM_HANDLER_DO_DEFAULT ? VINF_SUCCESS : rcStrict;
     2854                else if (rcStrict2 != VINF_PGM_HANDLER_DO_DEFAULT)
     2855                {
     2856                    AssertLogRelMsgFailed(("rcStrict2=%Rrc GCPhys=%RGp pPage=%R[pgmpage] %s\n",
     2857                                           VBOXSTRICTRC_VAL(rcStrict2), GCPhys, pPage, pVirt->pszDesc));
     2858                    if (rcStrict == VINF_SUCCESS || rcStrict == VINF_PGM_HANDLER_DO_DEFAULT || rcStrict2 < rcStrict)
     2859                        rcStrict = rcStrict2;
     2860                }
    28252861            }
    28262862            pPhys = NULL;
    … …  
    28342870#endif
    28352871        }
    2836         if (rc == VINF_PGM_HANDLER_DO_DEFAULT)
     2872        if (rcStrict == VINF_PGM_HANDLER_DO_DEFAULT)
     2873        {
    28372874            memcpy(pvDst, pvBuf, cbRange);
     2875            rcStrict = VINF_SUCCESS;
     2876        }
    28382877
    28392878        /*
    28402879         * Advance if we've got more stuff to do.
    28412880         */
    2842         if (cbRange >= cbWrite)
     2881        if (cbRange >= cbWrite || rcStrict != VINF_SUCCESS)
    28432882        {
    28442883            pgmPhysReleaseInternalPageMappingLock(pVM, &PgMpLck);
    2845             return VINF_SUCCESS;
     2884            return rcStrict;
    28462885        }
    28472886
    … …  
    29082947
    29092948                /*
    2910                  * Any active WRITE or ALL access handlers?
     2949                 * Normal page? Get the pointer to it.
    29112950                 */
    2912                 if (   PGM_PAGE_HAS_ACTIVE_HANDLERS(pPage)
    2913                     || PGM_PAGE_IS_SPECIAL_ALIAS_MMIO(pPage))
     2951                if (   !PGM_PAGE_HAS_ACTIVE_HANDLERS(pPage)
     2952                    && !PGM_PAGE_IS_SPECIAL_ALIAS_MMIO(pPage))
    29142953                {
    2915                     int rc = pgmPhysWriteHandler(pVM, pPage, pRam->GCPhys + off, pvBuf, cb, enmOrigin);
    2916                     if (RT_FAILURE(rc))
    2917                     {
    2918                         pgmUnlock(pVM);
    2919                         return rc;
    2920                     }
    2921                 }
    2922                 else
    2923                 {
    2924                     /*
    2925                      * Get the pointer to the page.
    2926                      */
    29272954                    PGMPAGEMAPLOCK PgMpLck;
    29282955                    void          *pvDst;
    … …  
    29382965                        AssertLogRelMsgFailed(("pgmPhysGCPhys2CCPtrInternal failed on %RGp / %R[pgmpage] -> %Rrc\n",
    29392966                                                pRam->GCPhys + off, pPage, rc));
     2967                }
     2968                /*
     2969                 * Active WRITE or ALL access handlers.
     2970                 */
     2971                else
     2972                {
     2973                    VBOXSTRICTRC rcStrict = pgmPhysWriteHandler(pVM, pPage, pRam->GCPhys + off, pvBuf, cb, enmOrigin);
     2974                    if (rcStrict != VINF_SUCCESS)
     2975                    {
     2976                        pgmUnlock(pVM);
     2977                        return VBOXSTRICTRC_TODO(rcStrict);
     2978                    }
    29402979                }
    29412980

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

    r55910 r55966  
    10551055 * @param   pvUser      User argument.
    10561056 */
    1057 DECLEXPORT(int) pgmPoolAccessPfHandler(PVM pVM, PVMCPU pVCpu, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault,
    1058                                        RTGCPHYS GCPhysFault, void *pvUser)
     1057DECLEXPORT(VBOXSTRICTRC) pgmPoolAccessPfHandler(PVM pVM, PVMCPU pVCpu, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame,
     1058                                                RTGCPTR pvFault, RTGCPHYS GCPhysFault, void *pvUser)
    10591059{
    10601060    STAM_PROFILE_START(&pVM->pgm.s.CTX_SUFF(pPool)->CTX_SUFF_Z(StatMonitor), a);
    … …  
    13701370 * @param   pvUser          User argument.
    13711371 */
    1372 PGM_ALL_CB2_DECL(int) pgmPoolAccessHandler(PVM pVM, PVMCPU pVCpu, RTGCPHYS GCPhys, void *pvPhys, void *pvBuf, size_t cbBuf,
    1373                                            PGMACCESSTYPE enmAccessType, PGMACCESSORIGIN enmOrigin, void *pvUser)
     1372PGM_ALL_CB2_DECL(VBOXSTRICTRC)
     1373pgmPoolAccessHandler(PVM pVM, PVMCPU pVCpu, RTGCPHYS GCPhys, void *pvPhys, void *pvBuf, size_t cbBuf,
     1374                     PGMACCESSTYPE enmAccessType, PGMACCESSORIGIN enmOrigin, void *pvUser)
    13741375{
    13751376    PPGMPOOL        pPool = pVM->pgm.s.CTX_SUFF(pPool);
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