VirtualBox

Changeset 88818 in vbox for trunk/src/VBox/Devices/Bus


Ignore:
Timestamp:
May 3, 2021 10:19:31 AM (4 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
144152
Message:

AMD IOMMU: bugref:9654 Lock cleanup.

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r88668 r88818  
    173173
    174174/** Acquires the cache lock. */
    175 #define IOMMU_LOCK_CACHE(a_pDevIns, a_pThis) \
     175#define IOMMU_CACHE_LOCK(a_pDevIns, a_pThis) \
    176176    do { \
    177         int const rcLock = PDMDevHlpCritSectEnter((a_pDevIns), &(a_pThis)->CritSectCache, VERR_SEM_BUSY); \
    178         if (rcLock == VINF_SUCCESS) \
    179         { /* likely */ } \
    180         else \
    181         { \
    182             AssertRC(rcLock); \
    183             return rcLock; \
    184         } \
    185     } while (0)
    186 
    187 /** Acquires the cache lock (asserts on failure). */
    188 # define IOMMU_LOCK_CACHE_NORET(a_pDevIns, a_pThis) \
    189     do { \
    190         int const rcLock = PDMDevHlpCritSectEnter((a_pDevIns), &(a_pThis)->CritSectCache, VERR_SEM_BUSY); \
     177        int const rcLock = PDMDevHlpCritSectEnter((a_pDevIns), &(a_pThis)->CritSectCache, VINF_SUCCESS); \
    191178        AssertRC(rcLock); \
    192179    } while (0)
    193180
    194181/** Releases the cache lock.  */
    195 # define IOMMU_UNLOCK_CACHE(a_pDevIns, a_pThis)     PDMDevHlpCritSectLeave((a_pDevIns), &(a_pThis)->CritSectCache)
     182# define IOMMU_CACHE_UNLOCK(a_pDevIns, a_pThis)     PDMDevHlpCritSectLeave((a_pDevIns), &(a_pThis)->CritSectCache)
    196183#endif  /* IOMMU_WITH_DTE_CACHE */
    197184
    … …  
    199186#define IOMMU_GET_PAGE_OFF_MASK(a_cShift)           (~(UINT64_C(0xffffffffffffffff) << (a_cShift)))
    200187
    201 /** Acquires the PDM lock. */
    202 #define IOMMU_LOCK(a_pDevIns, a_pThisCC, a_rcBusy)  \
     188/** Acquires the PDM lock (returns a_rcBusy on contention). */
     189#define IOMMU_LOCK_RET(a_pDevIns, a_pThisCC, a_rcBusy)  \
    203190    do { \
    204191        int const rcLock = (a_pThisCC)->CTX_SUFF(pIommuHlp)->pfnLock((a_pDevIns), (a_rcBusy)); \
    … …  
    209196    } while (0)
    210197
     198/** Acquires the PDM lock (shouldn't really fail). */
     199#ifdef IN_RING3
     200# define IOMMU_LOCK(a_pDevIns, a_pThisCC)           (a_pThisCC)->CTX_SUFF(pIommuHlp)->pfnLock((a_pDevIns), VERR_IGNORED)
     201#else
     202# define IOMMU_LOCK(a_pDevIns, a_pThisCC) \
     203    do { \
     204        int const rcLock = (a_pThisCC)->CTX_SUFF(pIommuHlp)->pfnLock((a_pDevIns), VINF_SUCCESS); \
     205        AssertRC(rcLock); \
     206    } while (0)
     207#endif
     208
    211209/** Checks if the current thread owns the PDM lock. */
    212210# define IOMMU_ASSERT_LOCK_IS_OWNER(a_pDevIns, a_pThisCC) \
    … …  
    215213        Assert((a_pThisCC)->CTX_SUFF(pIommuHlp)->pfnLockIsOwner((a_pDevIns))); \
    216214        NOREF(a_pThisCC); \
    217     } while (0)
    218 
    219 /** Acquires the PDM lock (asserts on failure). */
    220 #define IOMMU_LOCK_NORET(a_pDevIns, a_pThisCC)  \
    221     do { \
    222         int const rcLock = (a_pThisCC)->CTX_SUFF(pIommuHlp)->pfnLock((a_pDevIns), VERR_SEM_BUSY); \
    223         AssertRC(rcLock); \
    224215    } while (0)
    225216
    … …  
    954945
    955946    PIOMMU pThis = PDMDEVINS_2_DATA(pDevIns, PIOMMU);
    956     IOMMU_LOCK_CACHE_NORET(pDevIns, pThis);
     947    IOMMU_CACHE_LOCK(pDevIns, pThis);
    957948
    958949    uint16_t const cDteCache = RT_ELEMENTS(pThis->aDteCache);
    … …  
    972963        rc = VERR_OUT_OF_RESOURCES;
    973964
    974     IOMMU_UNLOCK_CACHE(pDevIns, pThis);
     965    IOMMU_CACHE_UNLOCK(pDevIns, pThis);
    975966    return rc;
    976967}
    … …  
    988979{
    989980    PIOMMU pThis = PDMDEVINS_2_DATA(pDevIns, PIOMMU);
    990     IOMMU_LOCK_CACHE_NORET(pDevIns, pThis);
     981    IOMMU_CACHE_LOCK(pDevIns, pThis);
    991982
    992983    uint16_t const cDteCache = RT_ELEMENTS(pThis->aDteCache);
    … …  
    996987        pThis->aDteCache[idxDte].fFlags |= fFlags;
    997988
    998     IOMMU_UNLOCK_CACHE(pDevIns, pThis);
     989    IOMMU_CACHE_UNLOCK(pDevIns, pThis);
    999990}
    1000991
    … …  
    10101001{
    10111002    PIOMMU pThis = PDMDEVINS_2_DATA(pDevIns, PIOMMU);
    1012     IOMMU_LOCK_CACHE_NORET(pDevIns, pThis);
     1003    IOMMU_CACHE_LOCK(pDevIns, pThis);
    10131004
    10141005    uint16_t const cDteCache = RT_ELEMENTS(pThis->aDteCache);
    … …  
    10201011    }
    10211012
    1022     IOMMU_UNLOCK_CACHE(pDevIns, pThis);
     1013    IOMMU_CACHE_UNLOCK(pDevIns, pThis);
    10231014}
    10241015
    … …  
    10321023{
    10331024    PIOMMU pThis = PDMDEVINS_2_DATA(pDevIns, PIOMMU);
    1034     IOMMU_LOCK_CACHE_NORET(pDevIns, pThis);
     1025    IOMMU_CACHE_LOCK(pDevIns, pThis);
    10351026    RT_ZERO(pThis->aDeviceIds);
    10361027    RT_ZERO(pThis->aDteCache);
    1037     IOMMU_UNLOCK_CACHE(pDevIns, pThis);
     1028    IOMMU_CACHE_UNLOCK(pDevIns, pThis);
    10381029}
    10391030# endif  /* IN_RING3 */
    … …  
    13101301    PIOMMU   pThis   = PDMDEVINS_2_DATA(pDevIns, PIOMMU);
    13111302    PIOMMUR3 pThisR3 = PDMDEVINS_2_DATA_CC(pDevIns, PIOMMUR3);
    1312     IOMMU_LOCK_CACHE_NORET(pDevIns, pThis);
     1303    IOMMU_CACHE_LOCK(pDevIns, pThis);
    13131304
    13141305    if (pThisR3->cCachedIotlbes > 0)
    … …  
    13221313    }
    13231314
    1324     IOMMU_UNLOCK_CACHE(pDevIns, pThis);
     1315    IOMMU_CACHE_UNLOCK(pDevIns, pThis);
    13251316}
    13261317
    … …  
    13441335    PIOMMU   pThis   = PDMDEVINS_2_DATA(pDevIns, PIOMMU);
    13451336    PIOMMUR3 pThisR3 = PDMDEVINS_2_DATA_CC(pDevIns, PIOMMUR3);
    1346     IOMMU_LOCK_CACHE_NORET(pDevIns, pThis);
     1337    IOMMU_CACHE_LOCK(pDevIns, pThis);
    13471338
    13481339    do
    … …  
    13561347    } while (cbInvalidate > 0);
    13571348
    1358     IOMMU_UNLOCK_CACHE(pDevIns, pThis);
     1349    IOMMU_CACHE_UNLOCK(pDevIns, pThis);
    13591350}
    13601351
    … …  
    13761367    PIOMMU   pThis   = PDMDEVINS_2_DATA(pDevIns, PIOMMU);
    13771368    PIOMMUR3 pThisR3 = PDMDEVINS_2_DATA_CC(pDevIns, PIOMMUR3);
    1378     IOMMU_LOCK_CACHE_NORET(pDevIns, pThis);
     1369    IOMMU_CACHE_LOCK(pDevIns, pThis);
    13791370
    13801371    IOTLBEFLUSHARG Args;
    … …  
    13831374    RTAvlU64DoWithAll(&pThisR3->TreeIotlbe, true /* fFromLeft */, iommuAmdIotlbEntryRemoveDomainId, &Args);
    13841375
    1385     IOMMU_UNLOCK_CACHE(pDevIns, pThis);
     1376    IOMMU_CACHE_UNLOCK(pDevIns, pThis);
    13861377}
    13871378
    … …  
    14181409    cPages = RT_MIN(cPages, IOMMU_IOTLBE_MAX);
    14191410
    1420     IOMMU_LOCK_CACHE_NORET(pDevIns, pThis);
     1411    IOMMU_CACHE_LOCK(pDevIns, pThis);
    14211412    /** @todo Re-check DTE cache? */
    14221413    do
    … …  
    14271418        --cPages;
    14281419    } while (cPages > 0);
    1429     IOMMU_UNLOCK_CACHE(pDevIns, pThis);
     1420    IOMMU_CACHE_UNLOCK(pDevIns, pThis);
    14301421}
    14311422#endif  /* IOMMU_WITH_IOTLBE_CACHE */
    … …  
    14971488
    14981489    PIOMMU pThis = PDMDEVINS_2_DATA(pDevIns, PIOMMU);
    1499     IOMMU_LOCK_CACHE_NORET(pDevIns, pThis);
     1490    IOMMU_CACHE_LOCK(pDevIns, pThis);
    15001491
    15011492    uint16_t const idxDteCache = iommuAmdDteCacheEntryLookup(pThis, idDevice);
    … …  
    15421533    }
    15431534
    1544     IOMMU_UNLOCK_CACHE(pDevIns, pThis);
     1535    IOMMU_CACHE_UNLOCK(pDevIns, pThis);
    15451536    return rc;
    15461537}
    … …  
    15641555    int rc = VINF_SUCCESS;
    15651556    PIOMMU pThis = PDMDEVINS_2_DATA(pDevIns, PIOMMU);
    1566     IOMMU_LOCK_CACHE_NORET(pDevIns, pThis);
     1557    IOMMU_CACHE_LOCK(pDevIns, pThis);
    15671558
    15681559    /* Find an existing entry or get an unused slot. */
    … …  
    15781569        rc = VERR_OUT_OF_RESOURCES;
    15791570
    1580     IOMMU_UNLOCK_CACHE(pDevIns, pThis);
     1571    IOMMU_CACHE_UNLOCK(pDevIns, pThis);
    15811572    return rc;
    15821573}
    … …  
    15931584{
    15941585    PIOMMU pThis = PDMDEVINS_2_DATA(pDevIns, PIOMMU);
    1595     IOMMU_LOCK_CACHE_NORET(pDevIns, pThis);
     1586    IOMMU_CACHE_LOCK(pDevIns, pThis);
    15961587    uint16_t const cIrteCache = RT_ELEMENTS(pThis->aIrteCache);
    15971588    for (uint16_t i = 0; i < cIrteCache; i++)
    … …  
    16051596        }
    16061597    }
    1607     IOMMU_UNLOCK_CACHE(pDevIns, pThis);
     1598    IOMMU_CACHE_UNLOCK(pDevIns, pThis);
    16081599}
    16091600
    … …  
    16171608{
    16181609    PIOMMU pThis = PDMDEVINS_2_DATA(pDevIns, PIOMMU);
    1619     IOMMU_LOCK_CACHE_NORET(pDevIns, pThis);
     1610    IOMMU_CACHE_LOCK(pDevIns, pThis);
    16201611    uint16_t const cIrteCache = RT_ELEMENTS(pThis->aIrteCache);
    16211612    for (uint16_t i = 0; i < cIrteCache; i++)
    … …  
    16241615        pThis->aIrteCache[i].Irte.u32 = 0;
    16251616    }
    1626     IOMMU_UNLOCK_CACHE(pDevIns, pThis);
     1617    IOMMU_CACHE_UNLOCK(pDevIns, pThis);
    16271618}
    16281619# endif /* IN_RING3 */
    … …  
    27452736        if (!(off & 7))
    27462737        {
    2747             IOMMU_LOCK(pDevIns, pThisCC, VINF_IOM_R3_MMIO_WRITE);
     2738            IOMMU_LOCK_RET(pDevIns, pThisCC, VINF_IOM_R3_MMIO_WRITE);
    27482739            VBOXSTRICTRC rcStrict = pReg->pfnWrite(pDevIns, pThis, off, uValue);
    27492740            IOMMU_UNLOCK(pDevIns, pThisCC);
    … …  
    27602751    {
    27612752        VBOXSTRICTRC rcStrict;
    2762         IOMMU_LOCK(pDevIns, pThisCC, VINF_IOM_R3_MMIO_WRITE);
     2753        IOMMU_LOCK_RET(pDevIns, pThisCC, VINF_IOM_R3_MMIO_WRITE);
    27632754
    27642755        /*
    … …  
    28712862    if (!(off & 7))
    28722863    {
    2873         IOMMU_LOCK(pDevIns, pThisCC, VINF_IOM_R3_MMIO_READ);
     2864        IOMMU_LOCK_RET(pDevIns, pThisCC, VINF_IOM_R3_MMIO_READ);
    28742865        VBOXSTRICTRC rcStrict = pReg->pfnRead(pDevIns, pThis, off, puResult);
    28752866        IOMMU_UNLOCK(pDevIns, pThisCC);
    … …  
    28842875    Assert(off & 7);
    28852876    Assert(off >= 4);
    2886     IOMMU_LOCK(pDevIns, pThisCC, VINF_IOM_R3_MMIO_READ);
     2877    IOMMU_LOCK_RET(pDevIns, pThisCC, VINF_IOM_R3_MMIO_READ);
    28872878    VBOXSTRICTRC rcStrict = pReg->pfnRead(pDevIns, pThis, off - 4, puResult);
    28882879    IOMMU_UNLOCK(pDevIns, pThisCC);
    … …  
    29482939    PIOMMUCC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PIOMMUCC);
    29492940
    2950     IOMMU_LOCK_NORET(pDevIns, pThisCC);
     2941    IOMMU_LOCK(pDevIns, pThisCC);
    29512942
    29522943    /* Check if event logging is active and the log has not overflowed. */
    … …  
    30673058
    30683059    PIOMMUCC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PIOMMUCC);
    3069     IOMMU_LOCK_NORET(pDevIns, pThisCC);
     3060    IOMMU_LOCK(pDevIns, pThisCC);
    30703061
    30713062    iommuAmdHwErrorSet(pDevIns, (PCEVT_GENERIC_T)pEvent);
    … …  
    31133104
    31143105    PIOMMUCC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PIOMMUCC);
    3115     IOMMU_LOCK_NORET(pDevIns, pThisCC);
     3106    IOMMU_LOCK(pDevIns, pThisCC);
    31163107
    31173108    iommuAmdHwErrorSet(pDevIns, (PCEVT_GENERIC_T)pEvent);
    … …  
    31653156
    31663157    PIOMMUCC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PIOMMUCC);
    3167     IOMMU_LOCK_NORET(pDevIns, pThisCC);
     3158    IOMMU_LOCK(pDevIns, pThisCC);
    31683159
    31693160    iommuAmdHwErrorSet(pDevIns, (PCEVT_GENERIC_T)pEvent);
    … …  
    34843475    PIOMMUCC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PIOMMUCC);
    34853476
    3486     IOMMU_LOCK(pDevIns, pThisCC, VERR_SEM_BUSY);
     3477    IOMMU_LOCK(pDevIns, pThisCC);
    34873478
    34883479    /* Figure out which device table segment is being accessed. */
    … …  
    41684159     * we don't want the DTE cache to be invalidate while we perform IOTBL lookups.
    41694160     */
    4170     IOMMU_LOCK_CACHE(pDevIns, pThis);
     4161    IOMMU_CACHE_LOCK(pDevIns, pThis);
    41714162
    41724163    /* Lookup the DTE cache entry. */
    … …  
    42244215        IOMMU_IOTLB_LOOKUP_FAILED(VERR_NOT_FOUND);
    42254216
    4226     IOMMU_UNLOCK_CACHE(pDevIns, pThis);
     4217    IOMMU_CACHE_UNLOCK(pDevIns, pThis);
    42274218
    42284219    return rc;
    … …  
    48784869                if (pCmdComWait->n.u1Interrupt)
    48794870                {
    4880                     IOMMU_LOCK(pDevIns, pThisR3, VERR_IGNORED);
     4871                    IOMMU_LOCK(pDevIns, pThisR3);
    48814872                    ASMAtomicOrU64(&pThis->Status.u64, IOMMU_STATUS_COMPLETION_WAIT_INTR);
    48824873                    bool const fRaiseInt = pThis->Ctrl.n.u1CompWaitIntrEn;
    … …  
    51085099         *        save on host memory a bit, we could (once PGM has the necessary APIs)
    51095100         *        lock the page mappings page mappings and access them directly. */
    5110         IOMMU_LOCK(pDevIns, pThisR3, VERR_IGNORED);
     5101        IOMMU_LOCK(pDevIns, pThisR3);
    51115102
    51125103        if (pThis->Status.n.u1CmdBufRunning)
    … …  
    51295120                IOMMU_UNLOCK(pDevIns, pThisR3);
    51305121                int rc = PDMDevHlpPCIPhysRead(pDevIns, GCPhysCmdBufBase, pvCmds, cbCmdBuf);
    5131                 IOMMU_LOCK(pDevIns, pThisR3, VERR_IGNORED);
     5122                IOMMU_LOCK(pDevIns, pThisR3);
    51325123
    51335124                if (RT_SUCCESS(rc))
    … …  
    52925283
    52935284    PIOMMUR3 pThisR3 = PDMDEVINS_2_DATA_CC(pDevIns, PIOMMUR3);
    5294     IOMMU_LOCK(pDevIns, pThisR3, VERR_IGNORED);
     5285    IOMMU_LOCK(pDevIns, pThisR3);
    52955286
    52965287    VBOXSTRICTRC rcStrict;
    … …  
    60246015    RT_NOREF(pszArgs);
    60256016    PIOMMU pThis = PDMDEVINS_2_DATA(pDevIns, PIOMMU);
    6026     IOMMU_LOCK_CACHE_NORET(pDevIns, pThis);
     6017    IOMMU_CACHE_LOCK(pDevIns, pThis);
    60276018
    60286019    uint16_t const cDteCache = RT_ELEMENTS(pThis->aDeviceIds);
    … …  
    60446035        }
    60456036    }
    6046     IOMMU_UNLOCK_CACHE(pDevIns, pThis);
     6037    IOMMU_CACHE_UNLOCK(pDevIns, pThis);
    60476038}
    60486039# endif /* IOMMU_WITH_DTE_CACHE */
    … …  
    60696060            Args.idDomain = idDomain;
    60706061
    6071             IOMMU_LOCK_CACHE_NORET(pDevIns, pThis);
     6062            IOMMU_CACHE_LOCK(pDevIns, pThis);
    60726063            RTAvlU64DoWithAll(&pThisR3->TreeIotlbe, true /* fFromLeft */, iommuAmdR3IotlbEntryInfo, &Args);
    6073             IOMMU_UNLOCK_CACHE(pDevIns, pThis);
     6064            IOMMU_CACHE_UNLOCK(pDevIns, pThis);
    60746065        }
    60756066        else
    … …  
    61086099
    61096100    PIOMMU pThis = PDMDEVINS_2_DATA(pDevIns, PIOMMU);
    6110     IOMMU_LOCK_CACHE_NORET(pDevIns, pThis);
     6101    IOMMU_CACHE_LOCK(pDevIns, pThis);
    61116102
    61126103    uint16_t const cIrteCache = RT_ELEMENTS(pThis->aIrteCache);
    … …  
    61386129        }
    61396130    }
    6140     IOMMU_UNLOCK_CACHE(pDevIns, pThis);
     6131    IOMMU_CACHE_UNLOCK(pDevIns, pThis);
    61416132}
    61426133# endif /* IOMMU_WITH_IRTE_CACHE */
    … …  
    66366627
    66376628    int rc;
    6638     IOMMU_LOCK(pDevIns, pThisR3, VERR_IGNORED);
     6629    IOMMU_LOCK(pDevIns, pThisR3);
    66396630
    66406631    /* Map MMIO regions if the IOMMU BAR is enabled. */
    … …  
    66756666    LogFlowFunc(("\n"));
    66766667
    6677     IOMMU_LOCK_NORET(pDevIns, pThisR3);
     6668    IOMMU_LOCK(pDevIns, pThisR3);
    66786669
    66796670    RT_ZERO(pThis->aDevTabBaseAddrs);
    … …  
    67706761    LogFlowFunc(("\n"));
    67716762
    6772     IOMMU_LOCK_NORET(pDevIns, pThisR3);
     6763    IOMMU_LOCK(pDevIns, pThisR3);
    67736764
    67746765    if (pThis->hEvtCmdThread != NIL_SUPSEMEVENT)
Note: See TracChangeset for help on using the changeset viewer.

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