VirtualBox

Changeset 19474 in vbox


Ignore:
Timestamp:
May 7, 2009 10:08:32 AM (16 years ago)
Author:
vboxsync
Message:

MMIO locking

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

Legend:

Unmodified
Added
Removed
  • trunk/src/VBox/VMM/VMMAll/IOMAll.cpp

    r19472 r19474  
    5050int iomLock(PVM pVM)
    5151{
    52     Assert(!PGMIsLocked(pVM));
     52    Assert(!PGMIsLockOwner(pVM));
    5353    int rc = PDMCritSectEnter(&pVM->iom.s.EmtLock, VERR_SEM_BUSY);
    5454    return rc;
  • trunk/src/VBox/VMM/VMMAll/IOMAllMMIO.cpp

    r19141 r19474  
    10491049VMMDECL(int) IOMMMIOHandler(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pCtxCore, RTGCPTR pvFault, RTGCPHYS GCPhysFault, void *pvUser)
    10501050{
     1051    /* Take the IOM lock before performing any MMIO. */
     1052    int rc = iomLock(pVM);
     1053#ifndef IN_RING3
     1054    if (rc == VERR_SEM_BUSY)
     1055        return (uErrorCode & X86_TRAP_PF_RW) ? VINF_IOM_HC_MMIO_WRITE : VINF_IOM_HC_MMIO_READ;
     1056#endif
     1057    AssertRC(rc);
     1058
    10511059    STAM_PROFILE_START(&pVM->iom.s.StatRZMMIOHandler, a);
    10521060    Log(("IOMMMIOHandler: GCPhys=%RGp uErr=%#x pvFault=%RGv rip=%RGv\n",
     
    10651073    {
    10661074# ifdef IN_RING3
     1075        iomUnlock(pVM);
    10671076        return VERR_NO_MEMORY;
    10681077# else
    10691078        STAM_PROFILE_STOP(&pVM->iom.s.StatRZMMIOHandler, a);
    10701079        STAM_COUNTER_INC(&pVM->iom.s.StatRZMMIOFailures);
    1071         return uErrorCode & X86_TRAP_PF_RW ? VINF_IOM_HC_MMIO_WRITE : VINF_IOM_HC_MMIO_READ;
     1080        iomUnlock(pVM);
     1081        return (uErrorCode & X86_TRAP_PF_RW) ? VINF_IOM_HC_MMIO_WRITE : VINF_IOM_HC_MMIO_READ;
    10721082# endif
    10731083    }
     
    10911101        STAM_PROFILE_STOP(&pVM->iom.s.StatRZMMIOHandler, a);
    10921102        STAM_COUNTER_INC(&pVM->iom.s.StatRZMMIOFailures);
    1093         return uErrorCode & X86_TRAP_PF_RW ? VINF_IOM_HC_MMIO_WRITE : VINF_IOM_HC_MMIO_READ;
     1103        iomUnlock(pVM);
     1104        return (uErrorCode & X86_TRAP_PF_RW ? VINF_IOM_HC_MMIO_WRITE : VINF_IOM_HC_MMIO_READ);
    10941105    }
    10951106#endif /* !IN_RING3 */
     
    11001111    DISCPUSTATE Cpu;
    11011112    unsigned cbOp;
    1102     int rc = EMInterpretDisasOne(pVM, VMMGetCpu(pVM), pCtxCore, &Cpu, &cbOp);
    1103     AssertRCReturn(rc, rc);
     1113    rc = EMInterpretDisasOne(pVM, VMMGetCpu(pVM), pCtxCore, &Cpu, &cbOp);
     1114    AssertRC(rc);
     1115    if (RT_FAILURE(rc))
     1116    {
     1117        iomUnlock(pVM);
     1118        return rc;
     1119    }
    11041120    switch (Cpu.pCurInstr->opcode)
    11051121    {
     
    12241240
    12251241    STAM_PROFILE_STOP(&pVM->iom.s.StatRZMMIOHandler, a);
     1242    iomUnlock(pVM);
    12261243    return rc;
    12271244}
     
    12441261DECLCALLBACK(int) IOMR3MMIOHandler(PVM pVM, RTGCPHYS GCPhysFault, void *pvPhys, void *pvBuf, size_t cbBuf, PGMACCESSTYPE enmAccessType, void *pvUser)
    12451262{
    1246     int           rc;
    12471263    PIOMMMIORANGE pRange = (PIOMMMIORANGE)pvUser;
    12481264    STAM_COUNTER_INC(&pVM->iom.s.StatR3MMIOHandler);
     1265
     1266    /* Take the IOM lock before performing any MMIO. */
     1267    int rc = iomLock(pVM);
     1268    AssertRC(rc);
    12491269
    12501270    AssertMsg(cbBuf == 1 || cbBuf == 2 || cbBuf == 4 || cbBuf == 8, ("%zu\n", cbBuf));
     
    12591279
    12601280    AssertRC(rc);
     1281    iomUnlock(pVM);
    12611282    return rc;
    12621283}
    12631284#endif /* IN_RING3 */
    1264 
    12651285
    12661286/**
     
    12761296VMMDECL(int) IOMMMIORead(PVM pVM, RTGCPHYS GCPhys, uint32_t *pu32Value, size_t cbValue)
    12771297{
     1298    /* Take the IOM lock before performing any MMIO. */
     1299    int rc = iomLock(pVM);
     1300#ifndef IN_RING3
     1301    if (rc == VERR_SEM_BUSY)
     1302        return VINF_IOM_HC_MMIO_WRITE;
     1303#endif
     1304    AssertRC(rc);
     1305
    12781306    /*
    12791307     * Lookup the current context range node and statistics.
    12801308     */
    12811309    PIOMMMIORANGE pRange = iomMMIOGetRange(&pVM->iom.s, GCPhys);
    1282     AssertMsgReturn(pRange,
    1283                     ("Handlers and page tables are out of sync or something! GCPhys=%RGp cbValue=%d\n", GCPhys, cbValue),
    1284                     VERR_INTERNAL_ERROR);
     1310    AssertMsg(pRange, ("Handlers and page tables are out of sync or something! GCPhys=%RGp cbValue=%d\n", GCPhys, cbValue));
     1311    if (!pRange)
     1312    {
     1313        iomUnlock(pVM);
     1314        return VERR_INTERNAL_ERROR;
     1315    }
    12851316#ifdef VBOX_WITH_STATISTICS
    12861317    PIOMMMIOSTATS pStats = iomMMIOGetStats(&pVM->iom.s, GCPhys, pRange);
    12871318    if (!pStats)
     1319    {
     1320        iomUnlock(pVM);
    12881321# ifdef IN_RING3
    12891322        return VERR_NO_MEMORY;
     
    12911324        return VINF_IOM_HC_MMIO_READ;
    12921325# endif
     1326    }
    12931327#endif /* VBOX_WITH_STATISTICS */
    12941328    if (pRange->CTX_SUFF(pfnReadCallback))
     
    13001334        STAM_PROFILE_ADV_START(&pStats->CTX_SUFF_Z(ProfRead), a);
    13011335#endif
    1302         int rc = pRange->CTX_SUFF(pfnReadCallback)(pRange->CTX_SUFF(pDevIns), pRange->CTX_SUFF(pvUser), GCPhys, pu32Value, (unsigned)cbValue);
     1336        rc = pRange->CTX_SUFF(pfnReadCallback)(pRange->CTX_SUFF(pDevIns), pRange->CTX_SUFF(pvUser), GCPhys, pu32Value, (unsigned)cbValue);
    13031337#ifdef VBOX_WITH_STATISTICS
    13041338        STAM_PROFILE_ADV_STOP(&pStats->CTX_SUFF_Z(ProfRead), a);
     
    13111345            default:
    13121346                Log4(("IOMMMIORead: GCPhys=%RGp *pu32=%08RX32 cb=%d rc=%Rrc\n", GCPhys, *pu32Value, cbValue, rc));
     1347                iomUnlock(pVM);
    13131348                return rc;
    13141349
     
    13231358                }
    13241359                Log4(("IOMMMIORead: GCPhys=%RGp *pu32=%08RX32 cb=%d rc=%Rrc\n", GCPhys, *pu32Value, cbValue, rc));
     1360                iomUnlock(pVM);
    13251361                return VINF_SUCCESS;
    13261362
     
    13351371                }
    13361372                Log4(("IOMMMIORead: GCPhys=%RGp *pu32=%08RX32 cb=%d rc=%Rrc\n", GCPhys, *pu32Value, cbValue, rc));
     1373                iomUnlock(pVM);
    13371374                return VINF_SUCCESS;
    13381375        }
     
    13421379    {
    13431380        STAM_COUNTER_INC(&pStats->CTX_MID_Z(Read,ToR3));
     1381        iomUnlock(pVM);
    13441382        return VINF_IOM_HC_MMIO_READ;
    13451383    }
     
    13621400    }
    13631401    Log4(("IOMMMIORead: GCPhys=%RGp *pu32=%08RX32 cb=%d rc=VINF_SUCCESS\n", GCPhys, *pu32Value, cbValue));
     1402    iomUnlock(pVM);
    13641403    return VINF_SUCCESS;
    13651404}
     
    13781417VMMDECL(int) IOMMMIOWrite(PVM pVM, RTGCPHYS GCPhys, uint32_t u32Value, size_t cbValue)
    13791418{
     1419    /* Take the IOM lock before performing any MMIO. */
     1420    int rc = iomLock(pVM);
     1421#ifndef IN_RING3
     1422    if (rc == VERR_SEM_BUSY)
     1423        return VINF_IOM_HC_MMIO_WRITE;
     1424#endif
     1425    AssertRC(rc);
     1426
    13801427    /*
    13811428     * Lookup the current context range node.
    13821429     */
    13831430    PIOMMMIORANGE pRange = iomMMIOGetRange(&pVM->iom.s, GCPhys);
    1384     AssertMsgReturn(pRange,
    1385                     ("Handlers and page tables are out of sync or something! GCPhys=%RGp cbValue=%d\n", GCPhys, cbValue),
    1386                     VERR_INTERNAL_ERROR);
     1431    AssertMsg(pRange, ("Handlers and page tables are out of sync or something! GCPhys=%RGp cbValue=%d\n", GCPhys, cbValue));
     1432    if (!pRange)
     1433    {
     1434        iomUnlock(pVM);
     1435        return VERR_INTERNAL_ERROR;
     1436    }
    13871437#ifdef VBOX_WITH_STATISTICS
    13881438    PIOMMMIOSTATS pStats = iomMMIOGetStats(&pVM->iom.s, GCPhys, pRange);
    13891439    if (!pStats)
     1440    {
     1441        iomUnlock(pVM);
    13901442# ifdef IN_RING3
    13911443        return VERR_NO_MEMORY;
     
    13931445        return VINF_IOM_HC_MMIO_WRITE;
    13941446# endif
     1447    }
    13951448#endif /* VBOX_WITH_STATISTICS */
    13961449
     
    14041457        STAM_PROFILE_ADV_START(&pStats->CTX_SUFF_Z(ProfWrite), a);
    14051458#endif
    1406         int rc = pRange->CTX_SUFF(pfnWriteCallback)(pRange->CTX_SUFF(pDevIns), pRange->CTX_SUFF(pvUser), GCPhys, &u32Value, (unsigned)cbValue);
     1459        rc = pRange->CTX_SUFF(pfnWriteCallback)(pRange->CTX_SUFF(pDevIns), pRange->CTX_SUFF(pvUser), GCPhys, &u32Value, (unsigned)cbValue);
    14071460#ifdef VBOX_WITH_STATISTICS
    14081461        STAM_PROFILE_ADV_STOP(&pStats->CTX_SUFF_Z(ProfWrite), a);
     
    14111464#endif
    14121465        Log4(("IOMMMIOWrite: GCPhys=%RGp u32=%08RX32 cb=%d rc=%Rrc\n", GCPhys, u32Value, cbValue, rc));
     1466        iomUnlock(pVM);
    14131467        return rc;
    14141468    }
     
    14171471    {
    14181472        STAM_COUNTER_INC(&pStats->CTX_MID_Z(Write,ToR3));
     1473        iomUnlock(pVM);
    14191474        return VINF_IOM_HC_MMIO_WRITE;
    14201475    }
     
    14281483#endif
    14291484    Log4(("IOMMMIOWrite: GCPhys=%RGp u32=%08RX32 cb=%d rc=%Rrc\n", GCPhys, u32Value, cbValue, VINF_SUCCESS));
     1485    iomUnlock(pVM);
    14301486    return VINF_SUCCESS;
    14311487}
    1432 
    14331488
    14341489/**
  • trunk/src/VBox/VMM/VMMAll/PGMAll.cpp

    r19471 r19474  
    20302030}
    20312031
     2032
     2033/**
     2034 * Check if this VCPU currently owns the PGM lock.
     2035 *
     2036 * @returns bool owner/not owner
     2037 * @param   pVM         The VM to operate on.
     2038 */
     2039VMMDECL(bool) PGMIsLockOwner(PVM pVM)
     2040{
     2041    return PDMCritSectIsOwner(&pVM->pgm.s.CritSect);
     2042}
     2043
     2044
    20322045/**
    20332046 * Acquire the PGM lock.
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