VirtualBox

Changeset 90447 in vbox for trunk/src/VBox/Devices/Network


Ignore:
Timestamp:
Jul 31, 2021 12:44:13 AM (4 years ago)
Author:
vboxsync
Message:

Dev*: Checked up all the PDMDevHlpCritSectEnter calls to make sure the status code is checked. bugref:6695

Location:
trunk/src/VBox/Devices/Network
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Devices/Network/DevE1000.cpp

    r90332 r90447  
    16571657#endif /* IN_RING3 */
    16581658
    1659 #define e1kCsEnter(ps, rc) PDMDevHlpCritSectEnter(pDevIns, &ps->cs, rc)
    1660 #define e1kCsLeave(ps) PDMDevHlpCritSectLeave(pDevIns, &ps->cs)
    1661 
    1662 #define e1kCsRxEnter(ps, rc) PDMDevHlpCritSectEnter(pDevIns, &ps->csRx, rc)
    1663 #define e1kCsRxLeave(ps) PDMDevHlpCritSectLeave(pDevIns, &ps->csRx)
    1664 #define e1kCsRxIsOwner(ps) PDMDevHlpCritSectIsOwner(pDevIns, &ps->csRx)
     1659
     1660#define e1kCsEnter(ps, rcBusy) PDMDevHlpCritSectEnter(pDevIns, &(ps)->cs, (rcBusy))
     1661#define e1kCsEnterReturn(ps, rcBusy) do { \
     1662        int const rcLock = PDMDevHlpCritSectEnter(pDevIns, &(ps)->cs, (rcBusy)); \
     1663        if (rcLock == VINF_SUCCESS) { /* likely */ } \
     1664        else return rcLock; \
     1665    } while (0)
     1666#define e1kR3CsEnterAsserted(ps) do { \
     1667        int const rcLock = PDMDevHlpCritSectEnter(pDevIns, &(ps)->cs, VERR_SEM_BUSY); \
     1668        PDM_CRITSECT_RELEASE_ASSERT_RC_DEV(pDevIns, &(ps)->cs, rcLock); \
     1669    } while (0)
     1670#define e1kCsLeave(ps) PDMDevHlpCritSectLeave(pDevIns, &(ps)->cs)
     1671
     1672
     1673#define e1kCsRxEnter(ps, rcBusy) PDMDevHlpCritSectEnter(pDevIns, &(ps)->csRx, (rcBusy))
     1674#define e1kCsRxEnterReturn(ps) do { \
     1675        int const rcLock = PDMDevHlpCritSectEnter(pDevIns, &(ps)->csRx, VERR_SEM_BUSY); \
     1676        AssertRCReturn(rcLock, rcLock); \
     1677    } while (0)
     1678#define e1kR3CsRxEnterAsserted(ps) do { \
     1679        int const rcLock = PDMDevHlpCritSectEnter(pDevIns, &(ps)->csRx, VERR_SEM_BUSY); \
     1680        PDM_CRITSECT_RELEASE_ASSERT_RC_DEV(pDevIns, &(ps)->csRx, rcLock); \
     1681    } while (0)
     1682#define e1kCsRxLeave(ps) PDMDevHlpCritSectLeave(pDevIns, &(ps)->csRx)
     1683#define e1kCsRxIsOwner(ps) PDMDevHlpCritSectIsOwner(pDevIns, &(ps)->csRx)
     1684
    16651685
    16661686#ifndef E1K_WITH_TX_CS
    1667 # define e1kCsTxEnter(ps, rc) VINF_SUCCESS
     1687# define e1kCsTxEnter(ps, rcBusy) VINF_SUCCESS
     1688# define e1kR3CsTxEnterAsserted(ps) do { } while (0)
    16681689# define e1kCsTxLeave(ps) do { } while (0)
    16691690#else /* E1K_WITH_TX_CS */
    1670 # define e1kCsTxEnter(ps, rc) PDMDevHlpCritSectEnter(pDevIns, &ps->csTx, rc)
    1671 # define e1kCsTxLeave(ps) PDMDevHlpCritSectLeave(pDevIns, &ps->csTx)
    1672 # define e1kCsTxIsOwner(ps) PDMDevHlpCritSectIsOwner(pDevIns, &ps->csTx)
     1691# define e1kCsTxEnter(ps, rcBusy) PDMDevHlpCritSectEnter(pDevIns, &(ps)->csTx, (rcBusy))
     1692# define e1kR3CsTxEnterAsserted(ps) do { \
     1693        int const rcLock = PDMDevHlpCritSectEnter(pDevIns, &(ps)->csTx, VERR_SEM_BUSY); \
     1694        PDM_CRITSECT_RELEASE_ASSERT_RC_DEV(pDevIns, &(ps)->csTx, rcLock); \
     1695    } while (0)
     1696# define e1kCsTxLeave(ps) PDMDevHlpCritSectLeave(pDevIns, &(ps)->csTx)
     1697# define e1kCsTxIsOwner(ps) PDMDevHlpCritSectIsOwner(pDevIns, &(ps)->csTx)
    16731698#endif /* E1K_WITH_TX_CS */
    16741699
    … …  
    17991824    memset(pThis->auRegs,        0, sizeof(pThis->auRegs));
    18001825    memset(pThis->aRecAddr.au32, 0, sizeof(pThis->aRecAddr.au32));
    1801 #ifdef E1K_INIT_RA0
     1826# ifdef E1K_INIT_RA0
    18021827    memcpy(pThis->aRecAddr.au32, pThis->macConfigured.au8,
    18031828           sizeof(pThis->macConfigured.au8));
    18041829    pThis->aRecAddr.array[0].ctl |= RA_CTL_AV;
    1805 #endif /* E1K_INIT_RA0 */
     1830# endif /* E1K_INIT_RA0 */
    18061831    STATUS = 0x0081;    /* SPEED=10b (1000 Mb/s), FD=1b (Full Duplex) */
    18071832    EECD   = 0x0100;    /* EE_PRES=1b (EEPROM present) */
    … …  
    18191844        pThisCC->pDrvR3->pfnSetPromiscuousMode(pThisCC->pDrvR3, false);
    18201845
    1821 #ifdef E1K_WITH_TXD_CACHE
    1822     int rc = e1kCsTxEnter(pThis, VERR_SEM_BUSY);
    1823     if (RT_LIKELY(rc == VINF_SUCCESS))
    1824     {
    1825         pThis->nTxDFetched  = 0;
    1826         pThis->iTxDCurrent  = 0;
    1827         pThis->fGSO         = false;
    1828         pThis->cbTxAlloc    = 0;
    1829         e1kCsTxLeave(pThis);
    1830     }
    1831 #endif /* E1K_WITH_TXD_CACHE */
    1832 #ifdef E1K_WITH_RXD_CACHE
    1833     if (RT_LIKELY(e1kCsRxEnter(pThis, VERR_SEM_BUSY) == VINF_SUCCESS))
    1834     {
    1835         pThis->iRxDCurrent = pThis->nRxDFetched = 0;
    1836         e1kCsRxLeave(pThis);
    1837     }
    1838 #endif /* E1K_WITH_RXD_CACHE */
    1839 #ifdef E1K_LSC_ON_RESET
     1846# ifdef E1K_WITH_TXD_CACHE
     1847    e1kR3CsTxEnterAsserted(pThis);
     1848    pThis->nTxDFetched  = 0;
     1849    pThis->iTxDCurrent  = 0;
     1850    pThis->fGSO         = false;
     1851    pThis->cbTxAlloc    = 0;
     1852    e1kCsTxLeave(pThis);
     1853# endif /* E1K_WITH_TXD_CACHE */
     1854# ifdef E1K_WITH_RXD_CACHE
     1855    e1kR3CsRxEnterAsserted(pThis);
     1856    pThis->iRxDCurrent = pThis->nRxDFetched = 0;
     1857    e1kCsRxLeave(pThis);
     1858# endif /* E1K_WITH_RXD_CACHE */
     1859# ifdef E1K_LSC_ON_RESET
    18401860    E1kLog(("%s Will trigger LSC in %d seconds...\n",
    18411861            pThis->szPrf, pThis->cMsLinkUpDelay / 1000));
    18421862    e1kArmTimer(pDevIns, pThis, pThis->hLUTimer, pThis->cMsLinkUpDelay * 1000);
    1843 #endif /* E1K_LSC_ON_RESET */
     1863# endif /* E1K_LSC_ON_RESET */
    18441864}
    18451865
    … …  
    21842204static int e1kRaiseInterrupt(PPDMDEVINS pDevIns, PE1KSTATE pThis, int rcBusy, uint32_t u32IntCause)
    21852205{
     2206    /* Do NOT use e1kCsEnterReturn here as most callers doesn't check the
     2207       status code.  They'll pass a negative rcBusy. */
    21862208    int rc = e1kCsEnter(pThis, rcBusy);
    2187     if (RT_UNLIKELY(rc != VINF_SUCCESS))
     2209    if (RT_LIKELY(rc == VINF_SUCCESS))
     2210    { /* likely */ }
     2211    else
     2212    {
     2213        PDM_CRITSECT_RELEASE_ASSERT_RC_DEV(pDevIns, &pThis->cs, rc);
    21882214        return rc;
     2215    }
    21892216
    21902217    E1K_INC_ISTAT_CNT(pThis->uStatIntTry);
    … …  
    22652292{
    22662293    Assert(e1kCsRxIsOwner(pThis));
    2267     //e1kCsEnter(pThis, RT_SRC_POS);
     2294    //e1kR3CsEnterAsserted(pThis);
    22682295    if (++pRxdc->rdh * sizeof(E1KRXDESC) >= pRxdc->rdlen)
    22692296        pRxdc->rdh = 0;
    … …  
    25352562 *
    25362563 * @returns VBox status code.
    2537  * @param   pDevIns     The device instance.
    2538  * @param   pThis          The device state structure.
     2564 * @param   pDevIns         The device instance.
     2565 * @param   pThis           The device state structure.
    25392566 * @param   pvBuf           The available data.
    25402567 * @param   cb              Number of bytes available in the buffer.
    … …  
    25502577# endif /* E1K_WITH_RXD_CACHE */
    25512578
    2552     int rc = e1kCsRxEnter(pThis, VERR_SEM_BUSY);
    2553     if (RT_UNLIKELY(rc != VINF_SUCCESS))
    2554         return rc;
     2579    e1kCsRxEnterReturn(pThis);
    25552580# ifdef E1K_WITH_RXD_CACHE
    25562581    if (RT_UNLIKELY(!e1kUpdateRxDContext(pDevIns, pThis, &rxdc, "e1kHandleRxPacket")))
    … …  
    26862711                e1kCsRxLeave(pThis);
    26872712                e1kStoreRxFragment(pDevIns, pThis, pDesc, ptr, u16RxBufferSize);
    2688                 rc = e1kCsRxEnter(pThis, VERR_SEM_BUSY);
    2689                 if (RT_UNLIKELY(rc != VINF_SUCCESS))
    2690                     return rc;
     2713                e1kCsRxEnterReturn(pThis);
    26912714# ifdef E1K_WITH_RXD_CACHE
    26922715                if (RT_UNLIKELY(!e1kUpdateRxDContext(pDevIns, pThis, &rxdc, "e1kHandleRxPacket")))
    … …  
    27062729                e1kStoreRxFragment(pDevIns, pThis, pDesc, ptr, cb);
    27072730# ifdef E1K_WITH_RXD_CACHE
    2708                 rc = e1kCsRxEnter(pThis, VERR_SEM_BUSY);
    2709                 if (RT_UNLIKELY(rc != VINF_SUCCESS))
    2710                     return rc;
     2731                e1kCsRxEnterReturn(pThis);
    27112732                if (RT_UNLIKELY(!e1kUpdateRxDContext(pDevIns, pThis, &rxdc, "e1kHandleRxPacket")))
    27122733                {
    … …  
    32123233static int e1kRegReadICR(PPDMDEVINS pDevIns, PE1KSTATE pThis, uint32_t offset, uint32_t index, uint32_t *pu32Value)
    32133234{
    3214     int rc = e1kCsEnter(pThis, VINF_IOM_R3_MMIO_READ);
    3215     if (RT_UNLIKELY(rc != VINF_SUCCESS))
    3216         return rc;
     3235    e1kCsEnterReturn(pThis, VINF_IOM_R3_MMIO_READ);
    32173236
    32183237    uint32_t value = 0;
    3219     rc = e1kRegReadDefault(pDevIns, pThis, offset, index, &value);
     3238    int rc = e1kRegReadDefault(pDevIns, pThis, offset, index, &value);
    32203239    if (RT_SUCCESS(rc))
    32213240    {
    … …  
    33493368    RT_NOREF_PV(offset); RT_NOREF_PV(index);
    33503369
    3351     int rc = e1kCsEnter(pThis, VINF_IOM_R3_MMIO_WRITE);
    3352     if (RT_UNLIKELY(rc != VINF_SUCCESS))
    3353         return rc;
     3370    e1kCsEnterReturn(pThis, VINF_IOM_R3_MMIO_WRITE);
    33543371    if (pThis->fIntRaised)
    33553372    {
    … …  
    36743691    /*
    36753692     * This can happen if we set the link status to down when the Link up timer was
    3676      * already armed (shortly after e1kLoadDone() or when the cable was disconnected
     3693     * already armed (shortly after e1kR3LoadDone() or when the cable was disconnected
    36773694     * and connect+disconnect the cable very quick. Moreover, 82543GC triggers LSC
    36783695     * on reset even if the cable is unplugged (see @bugref{8942}).
    … …  
    42424259            rc = pDrv->pfnSendBuf(pDrv, pSg, fOnWorkerThread);
    42434260            STAM_PROFILE_STOP(&pThis->CTX_SUFF_Z(StatTransmitSend), a);
    4244             //e1kCsEnter(pThis, RT_SRC_POS);
     4261            //e1kR3CsEnterAsserted(pThis);
    42454262        }
    42464263    }
    … …  
    62126229             * Mask out irrelevant bits.
    62136230             */
    6214             //rc = e1kCsEnter(pThis, VERR_SEM_BUSY, RT_SRC_POS);
    6215             if (RT_UNLIKELY(rc != VINF_SUCCESS))
    6216                 return rc;
     6231            //e1kCsEnterReturn(pThis, VERR_SEM_BUSY);
    62176232            //pThis->fDelayInts = false;
    62186233            //pThis->iStatIntLost += pThis->iStatIntLostOne;
    … …  
    62736288             * Mask out irrelevant bits.
    62746289             */
    6275             //rc = e1kCsEnter(pThis, VERR_SEM_BUSY, RT_SRC_POS);
    6276             //if (RT_UNLIKELY(rc != VINF_SUCCESS))
    6277             //    return rc;
     6290            //e1kCsEnterReturn(pThis, VERR_SEM_BUSY);
    62786291            //pThis->fDelayInts = false;
    62796292            //pThis->iStatIntLost += pThis->iStatIntLostOne;
    … …  
    63236336            Log6(("%s At %08X write          %08X  to  %s (%s)\n",
    63246337                     pThis->szPrf, offReg, u32Value, g_aE1kRegMap[index].abbrev, g_aE1kRegMap[index].name));
    6325             //rc = e1kCsEnter(pThis, VERR_SEM_BUSY, RT_SRC_POS);
    6326             //if (RT_UNLIKELY(rc != VINF_SUCCESS))
    6327             //    return rc;
     6338            //e1kCsEnterReturn(pThis, VERR_SEM_BUSY);
    63286339            //pThis->fDelayInts = false;
    63296340            //pThis->iStatIntLost += pThis->iStatIntLostOne;
    … …  
    65436554 * This must be called before the pfnRecieve() method is called.
    65446555 *
    6545  * @returns Number of bytes the device can receive.
     6556 * @returns VBox status code.
     6557 * @retval  VERR_NET_NO_BUFFER_SPACE if we cannot receive.
    65466558 * @param   pDevIns     The device instance.
    65476559 * @param   pThis       The instance data.
    65486560 * @thread  EMT
    65496561 */
    6550 static int e1kCanReceive(PPDMDEVINS pDevIns, PE1KSTATE pThis)
    6551 {
    6552 #ifndef E1K_WITH_RXD_CACHE
     6562static int e1kR3CanReceive(PPDMDEVINS pDevIns, PE1KSTATE pThis)
     6563{
     6564# ifndef E1K_WITH_RXD_CACHE
    65536565    size_t cb;
    65546566
    6555     if (RT_UNLIKELY(e1kCsRxEnter(pThis, VERR_SEM_BUSY) != VINF_SUCCESS))
    6556         return VERR_NET_NO_BUFFER_SPACE;
     6567    e1kCsRxEnterReturn(pThis);
    65576568
    65586569    if (RT_UNLIKELY(RDLEN == sizeof(E1KRXDESC)))
    … …  
    65686579        cb = (RDT - RDH) * pThis->u16RxBSize;
    65696580    else if (RDH > RDT)
    6570         cb = (RDLEN/sizeof(E1KRXDESC) - RDH + RDT) * pThis->u16RxBSize;
     6581        cb = (RDLEN / sizeof(E1KRXDESC) - RDH + RDT) * pThis->u16RxBSize;
    65716582    else
    65726583    {
    … …  
    65746585        E1kLogRel(("E1000: OUT of RX descriptors!\n"));
    65756586    }
    6576     E1kLog2(("%s e1kCanReceive: at exit RDH=%d RDT=%d RDLEN=%d u16RxBSize=%d cb=%lu\n",
     6587    E1kLog2(("%s e1kR3CanReceive: at exit RDH=%d RDT=%d RDLEN=%d u16RxBSize=%d cb=%lu\n",
    65776588             pThis->szPrf, RDH, RDT, RDLEN, pThis->u16RxBSize, cb));
    65786589
    65796590    e1kCsRxLeave(pThis);
    65806591    return cb > 0 ? VINF_SUCCESS : VERR_NET_NO_BUFFER_SPACE;
    6581 #else /* E1K_WITH_RXD_CACHE */
     6592# else /* E1K_WITH_RXD_CACHE */
     6593
     6594    e1kCsRxEnterReturn(pThis);
     6595
     6596    E1KRXDC rxdc;
     6597    if (RT_UNLIKELY(!e1kUpdateRxDContext(pDevIns, pThis, &rxdc, "e1kR3CanReceive")))
     6598    {
     6599        e1kCsRxLeave(pThis);
     6600        E1kLog(("%s e1kR3CanReceive: failed to update Rx context, returning VERR_NET_NO_BUFFER_SPACE\n", pThis->szPrf));
     6601        return VERR_NET_NO_BUFFER_SPACE;
     6602    }
     6603
    65826604    int rc = VINF_SUCCESS;
    6583 
    6584     if (RT_UNLIKELY(e1kCsRxEnter(pThis, VERR_SEM_BUSY) != VINF_SUCCESS))
    6585         return VERR_NET_NO_BUFFER_SPACE;
    6586     E1KRXDC rxdc;
    6587     if (RT_UNLIKELY(!e1kUpdateRxDContext(pDevIns, pThis, &rxdc, "e1kCanReceive")))
    6588     {
    6589         e1kCsRxLeave(pThis);
    6590         E1kLog(("%s e1kCanReceive: failed to update Rx context, returning VERR_NET_NO_BUFFER_SPACE\n",  pThis->szPrf));
    6591         return VERR_NET_NO_BUFFER_SPACE;
    6592     }
    6593 
    65946605    if (RT_UNLIKELY(rxdc.rdlen == sizeof(E1KRXDESC)))
    65956606    {
    … …  
    66046615        rc = VERR_NET_NO_BUFFER_SPACE;
    66056616    }
    6606     E1kLog2(("%s e1kCanReceive: at exit in_cache=%d RDH=%d RDT=%d RDLEN=%d"
    6607              " u16RxBSize=%d rc=%Rrc\n", pThis->szPrf,
     6617    E1kLog2(("%s e1kR3CanReceive: at exit in_cache=%d RDH=%d RDT=%d RDLEN=%d u16RxBSize=%d rc=%Rrc\n", pThis->szPrf,
    66086618             e1kRxDInCache(pThis), rxdc.rdh, rxdc.rdt, rxdc.rdlen, pThis->u16RxBSize, rc));
    66096619
    66106620    e1kCsRxLeave(pThis);
    66116621    return rc;
    6612 #endif /* E1K_WITH_RXD_CACHE */
     6622# endif /* E1K_WITH_RXD_CACHE */
    66136623}
    66146624
    … …  
    66226632    PPDMDEVINS  pDevIns = pThisCC->pDevInsR3;
    66236633
    6624     int rc = e1kCanReceive(pDevIns, pThis);
    6625 
     6634    int rc = e1kR3CanReceive(pDevIns, pThis);
    66266635    if (RT_SUCCESS(rc))
    66276636        return VINF_SUCCESS;
     6637
    66286638    if (RT_UNLIKELY(cMillies == 0))
    66296639        return VERR_NET_NO_BUFFER_SPACE;
    … …  
    66366646                     ||  enmVMState == VMSTATE_RUNNING_LS))
    66376647    {
    6638         int rc2 = e1kCanReceive(pDevIns, pThis);
     6648        int rc2 = e1kR3CanReceive(pDevIns, pThis);
    66396649        if (RT_SUCCESS(rc2))
    66406650        {
    … …  
    68646874    STAM_PROFILE_ADV_START(&pThis->StatReceive, a);
    68656875
    6866     //if (!e1kCsEnter(pThis, RT_SRC_POS))
    6867     //    return VERR_PERMISSION_DENIED;
     6876    //e1kR3CsEnterAsserted(pThis);
    68686877
    68696878    e1kPacketDump(pDevIns, pThis, (const uint8_t*)pvBuf, cb, "<-- Incoming");
    68706879
    68716880    /* Update stats */
    6872     if (RT_LIKELY(e1kCsEnter(pThis, VERR_SEM_BUSY) == VINF_SUCCESS))
    6873     {
    6874         E1K_INC_CNT32(TPR);
    6875         E1K_ADD_CNT64(TORL, TORH, cb < 64? 64 : cb);
    6876         e1kCsLeave(pThis);
    6877     }
     6881    e1kR3CsEnterAsserted(pThis);
     6882    E1K_INC_CNT32(TPR);
     6883    E1K_ADD_CNT64(TORL, TORH, cb < 64? 64 : cb);
     6884    e1kCsLeave(pThis);
     6885
    68786886    STAM_PROFILE_ADV_START(&pThis->StatReceiveFilter, a);
    68796887    E1KRXDST status;
    … …  
    70017009 * @param   pSSM        The handle to the saved state.
    70027010 */
    7003 static void e1kSaveConfig(PCPDMDEVHLPR3 pHlp, PE1KSTATE pThis, PSSMHANDLE pSSM)
     7011static void e1kR3SaveConfig(PCPDMDEVHLPR3 pHlp, PE1KSTATE pThis, PSSMHANDLE pSSM)
    70047012{
    70057013    pHlp->pfnSSMPutMem(pSSM, &pThis->macConfigured, sizeof(pThis->macConfigured));
    … …  
    70107018 * @callback_method_impl{FNSSMDEVLIVEEXEC,Save basic configuration.}
    70117019 */
    7012 static DECLCALLBACK(int) e1kLiveExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, uint32_t uPass)
     7020static DECLCALLBACK(int) e1kR3LiveExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, uint32_t uPass)
    70137021{
    70147022    RT_NOREF(uPass);
    7015     e1kSaveConfig(pDevIns->pHlpR3, PDMDEVINS_2_DATA(pDevIns, PE1KSTATE), pSSM);
     7023    e1kR3SaveConfig(pDevIns->pHlpR3, PDMDEVINS_2_DATA(pDevIns, PE1KSTATE), pSSM);
    70167024    return VINF_SSM_DONT_CALL_AGAIN;
    70177025}
    … …  
    70207028 * @callback_method_impl{FNSSMDEVSAVEPREP,Synchronize.}
    70217029 */
    7022 static DECLCALLBACK(int) e1kSavePrep(PPDMDEVINS pDevIns, PSSMHANDLE pSSM)
     7030static DECLCALLBACK(int) e1kR3SavePrep(PPDMDEVINS pDevIns, PSSMHANDLE pSSM)
    70237031{
    70247032    RT_NOREF(pSSM);
    70257033    PE1KSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PE1KSTATE);
    70267034
    7027     int rc = e1kCsEnter(pThis, VERR_SEM_BUSY);
    7028     if (RT_UNLIKELY(rc != VINF_SUCCESS))
    7029         return rc;
     7035    e1kCsEnterReturn(pThis, VERR_SEM_BUSY);
    70307036    e1kCsLeave(pThis);
    70317037    return VINF_SUCCESS;
    … …  
    70607066 * @callback_method_impl{FNSSMDEVSAVEEXEC}
    70617067 */
    7062 static DECLCALLBACK(int) e1kSaveExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM)
     7068static DECLCALLBACK(int) e1kR3SaveExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM)
    70637069{
    70647070    PE1KSTATE     pThis   = PDMDEVINS_2_DATA(pDevIns, PE1KSTATE);
    … …  
    70667072    PCPDMDEVHLPR3 pHlp    = pDevIns->pHlpR3;
    70677073
    7068     e1kSaveConfig(pHlp, pThis, pSSM);
     7074    e1kR3SaveConfig(pHlp, pThis, pSSM);
    70697075    pThisCC->eeprom.save(pHlp, pSSM);
    70707076    e1kDumpState(pThis);
    … …  
    71307136 * @callback_method_impl{FNSSMDEVLOADPREP,Synchronize.}
    71317137 */
    7132 static DECLCALLBACK(int) e1kLoadPrep(PPDMDEVINS pDevIns, PSSMHANDLE pSSM)
     7138static DECLCALLBACK(int) e1kR3LoadPrep(PPDMDEVINS pDevIns, PSSMHANDLE pSSM)
    71337139{
    71347140    RT_NOREF(pSSM);
    71357141    PE1KSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PE1KSTATE);
    71367142
    7137     int rc = e1kCsEnter(pThis, VERR_SEM_BUSY);
    7138     if (RT_UNLIKELY(rc != VINF_SUCCESS))
    7139         return rc;
     7143    e1kCsEnterReturn(pThis, VERR_SEM_BUSY);
    71407144    e1kCsLeave(pThis);
    71417145    return VINF_SUCCESS;
    … …  
    71457149 * @callback_method_impl{FNSSMDEVLOADEXEC}
    71467150 */
    7147 static DECLCALLBACK(int) e1kLoadExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass)
     7151static DECLCALLBACK(int) e1kR3LoadExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass)
    71487152{
    71497153    PE1KSTATE       pThis   = PDMDEVINS_2_DATA(pDevIns, PE1KSTATE);
    … …  
    72577261 * @callback_method_impl{FNSSMDEVLOADDONE, Link status adjustments after loading.}
    72587262 */
    7259 static DECLCALLBACK(int) e1kLoadDone(PPDMDEVINS pDevIns, PSSMHANDLE pSSM)
     7263static DECLCALLBACK(int) e1kR3LoadDone(PPDMDEVINS pDevIns, PSSMHANDLE pSSM)
    72607264{
    72617265    PE1KSTATE   pThis   = PDMDEVINS_2_DATA(pDevIns, PE1KSTATE);
    … …  
    72887292 * @callback_method_impl{FNRTSTRFORMATTYPE}
    72897293 */
    7290 static DECLCALLBACK(size_t) e1kFmtRxDesc(PFNRTSTROUTPUT pfnOutput,
    7291                                          void *pvArgOutput,
    7292                                          const char *pszType,
    7293                                          void const *pvValue,
    7294                                          int cchWidth,
    7295                                          int cchPrecision,
    7296                                          unsigned fFlags,
    7297                                          void *pvUser)
     7294static DECLCALLBACK(size_t) e1kR3FmtRxDesc(PFNRTSTROUTPUT pfnOutput,
     7295                                           void *pvArgOutput,
     7296                                           const char *pszType,
     7297                                           void const *pvValue,
     7298                                           int cchWidth,
     7299                                           int cchPrecision,
     7300                                           unsigned fFlags,
     7301                                           void *pvUser)
    72987302{
    72997303    RT_NOREF(cchWidth,  cchPrecision,  fFlags, pvUser);
    … …  
    73277331 * @callback_method_impl{FNRTSTRFORMATTYPE}
    73287332 */
    7329 static DECLCALLBACK(size_t) e1kFmtTxDesc(PFNRTSTROUTPUT pfnOutput,
    7330                                          void *pvArgOutput,
    7331                                          const char *pszType,
    7332                                          void const *pvValue,
    7333                                          int cchWidth,
    7334                                          int cchPrecision,
    7335                                          unsigned fFlags,
    7336                                          void *pvUser)
     7333static DECLCALLBACK(size_t) e1kR3FmtTxDesc(PFNRTSTROUTPUT pfnOutput,
     7334                                           void *pvArgOutput,
     7335                                           const char *pszType,
     7336                                           void const *pvValue,
     7337                                           int cchWidth,
     7338                                           int cchPrecision,
     7339                                           unsigned fFlags,
     7340                                           void *pvUser)
    73377341{
    73387342    RT_NOREF(cchWidth, cchPrecision, fFlags, pvUser);
    … …  
    74127416
    74137417/** Initializes debug helpers (logging format types). */
    7414 static int e1kInitDebugHelpers(void)
     7418static int e1kR3InitDebugHelpers(void)
    74157419{
    74167420    int         rc                   = VINF_SUCCESS;
    … …  
    74197423    {
    74207424        s_fHelpersRegistered = true;
    7421         rc = RTStrFormatTypeRegister("e1krxd", e1kFmtRxDesc, NULL);
     7425        rc = RTStrFormatTypeRegister("e1krxd", e1kR3FmtRxDesc, NULL);
    74227426        AssertRCReturn(rc, rc);
    7423         rc = RTStrFormatTypeRegister("e1ktxd", e1kFmtTxDesc, NULL);
     7427        rc = RTStrFormatTypeRegister("e1ktxd", e1kR3FmtTxDesc, NULL);
    74247428        AssertRCReturn(rc, rc);
    74257429    }
    … …  
    74347438 * @param   pszArgs     The arguments.
    74357439 */
    7436 static DECLCALLBACK(void) e1kInfo(PPDMDEVINS pDevIns, PCDBGFINFOHLP pHlp, const char *pszArgs)
     7440static DECLCALLBACK(void) e1kR3Info(PPDMDEVINS pDevIns, PCDBGFINFOHLP pHlp, const char *pszArgs)
    74377441{
    74387442    RT_NOREF(pszArgs);
    … …  
    74617465                    pDevIns->fRCEnabled ? " RC" : "", pDevIns->fR0Enabled ? " R0" : "");
    74627466
    7463     e1kCsEnter(pThis, VERR_INTERNAL_ERROR); /* Not sure why but PCNet does it */
     7467    e1kR3CsEnterAsserted(pThis); /* Not sure why but PCNet does it */
    74647468
    74657469    for (i = 0; i < E1K_NUM_OF_32BIT_REGS; ++i)
    … …  
    76147618    AssertLogRelReturnVoid(iLUN == 0);
    76157619
    7616     PDMDevHlpCritSectEnter(pDevIns, &pThis->cs, VERR_SEM_BUSY);
    7617 
    7618     /** @todo r=pritesh still need to check if i missed
    7619      * to clean something in this function
    7620      */
     7620    e1kR3CsEnterAsserted(pThis);
    76217621
    76227622    /*
    … …  
    76547654    AssertLogRelReturn(iLUN == 0, VERR_PDM_NO_SUCH_LUN);
    76557655
    7656     PDMDevHlpCritSectEnter(pDevIns, &pThis->cs, VERR_SEM_BUSY);
     7656    e1kR3CsEnterAsserted(pThis);
    76577657
    76587658    /*
    … …  
    80318031    /* Saved state registration. */
    80328032    rc = PDMDevHlpSSMRegisterEx(pDevIns, E1K_SAVEDSTATE_VERSION, sizeof(E1KSTATE), NULL,
    8033                                 NULL,        e1kLiveExec, NULL,
    8034                                 e1kSavePrep, e1kSaveExec, NULL,
    8035                                 e1kLoadPrep, e1kLoadExec, e1kLoadDone);
     8033                                NULL,        e1kR3LiveExec, NULL,
     8034                                e1kR3SavePrep, e1kR3SaveExec, NULL,
     8035                                e1kR3LoadPrep, e1kR3LoadExec, e1kR3LoadDone);
    80368036    AssertRCReturn(rc, rc);
    80378037
    … …  
    81368136    char szTmp[20];
    81378137    RTStrPrintf(szTmp, sizeof(szTmp), "e1k%d", iInstance);
    8138     PDMDevHlpDBGFInfoRegister(pDevIns, szTmp, "E1000 info.", e1kInfo);
     8138    PDMDevHlpDBGFInfoRegister(pDevIns, szTmp, "E1000 info.", e1kR3Info);
    81398139
    81408140    /* Status driver */
    … …  
    81698169    AssertRCReturn(rc, rc);
    81708170
    8171     rc = e1kInitDebugHelpers();
     8171    rc = e1kR3InitDebugHelpers();
    81728172    AssertRCReturn(rc, rc);
    81738173

  • trunk/src/VBox/Devices/Network/DevPCNet.cpp

    r88498 r90447  
    13381338           )
    13391339        {
    1340             int rc = PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_SEM_BUSY);
    1341             AssertReleaseRC(rc);
     1340            int const rcLock = PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_SEM_BUSY);
     1341            PDM_CRITSECT_RELEASE_ASSERT_RC_DEV(pDevIns, &pThis->CritSect, rcLock);
     1342
    13421343            /* Check if we can do something now */
    13431344            pcnetPollRxTx(pDevIns, pThis, pThisCC);
    13441345            pcnetUpdateIrq(pDevIns, pThis);
     1346
    13451347            PDMDevHlpCritSectLeave(pDevIns, &pThis->CritSect);
    13461348        }
    … …  
    20382040            pcnetPhysWrite(pDevIns, pThis, rbadr, src, cbBuf);
    20392041            int rc = PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_SEM_BUSY);
    2040             AssertReleaseRC(rc);
     2042            PDM_CRITSECT_RELEASE_ASSERT_RC_DEV(pDevIns, &pThis->CritSect, rc);
    20412043
    20422044            /* RX disabled in the meantime? If so, abort RX. */
    … …  
    20852087                pcnetPhysWrite(pDevIns, pThis, rbadr2, src, cbBuf);
    20862088                rc = PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_SEM_BUSY);
    2087                 AssertReleaseRC(rc);
     2089                PDM_CRITSECT_RELEASE_ASSERT_RC_DEV(pDevIns, &pThis->CritSect, rc);
    20882090
    20892091                /* RX disabled in the meantime? If so, abort RX. */
    … …  
    40484050
    40494051    int rc = PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_SEM_BUSY);
    4050     AssertReleaseRC(rc);
     4052    PDM_CRITSECT_RELEASE_ASSERT_RC_DEV(pDevIns, &pThis->CritSect, rc);
    40514053
    40524054    rc = VERR_GENERAL_FAILURE;
    … …  
    41684170
    41694171
    4170     PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_INTERNAL_ERROR); /* Take it here so we know why we're hanging... */
     4172    int const rcLock = PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_INTERNAL_ERROR); /* Take it here so we know why we're hanging... */
     4173    PDM_CRITSECT_RELEASE_ASSERT_RC_DEV(pDevIns, &pThis->CritSect, rcLock);
    41714174
    41724175    pHlp->pfnPrintf(pHlp,
    … …  
    44714474
    44724475    int rc = PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_SEM_BUSY);
    4473     AssertRC(rc);
     4476    AssertRCReturn(rc, rc);
    44744477    PDMDevHlpCritSectLeave(pDevIns, &pThis->CritSect);
    4475 
    44764478    return VINF_SUCCESS;
    44774479}
    … …  
    45244526
    45254527    int rc = PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_SEM_BUSY);
    4526     AssertRC(rc);
     4528    AssertRCReturn(rc, rc);
    45274529
    45284530    uint32_t uVer = pHlp->pfnSSMHandleVersion(pSSM);
    … …  
    46824684{
    46834685    int rc = PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_SEM_BUSY);
    4684     AssertReleaseRC(rc);
     4686    PDM_CRITSECT_RELEASE_ASSERT_RC_DEV(pDevIns, &pThis->CritSect, rc);
    46854687
    46864688    rc = VERR_NET_NO_BUFFER_SPACE;
    … …  
    47384740         * is true -- even if (transmit) polling is disabled (CSR_DPOLL). */
    47394741        rc2 = PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_SEM_BUSY);
    4740         AssertReleaseRC(rc2);
     4742        PDM_CRITSECT_RELEASE_ASSERT_RC_DEV(pDevIns, &pThis->CritSect, rc2);
    47414743#ifndef PCNET_NO_POLLING
    47424744        pcnetPollTimerStart(pDevIns, pThis);
    … …  
    47634765    STAM_PROFILE_ADV_START(&pThis->StatReceive, a);
    47644766    int rc = PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_SEM_BUSY);
    4765     AssertReleaseRC(rc);
     4767    PDM_CRITSECT_RELEASE_ASSERT_RC_DEV(pDevIns, &pThis->CritSect, rc);
    47664768
    47674769    /*
    … …  
    49684970    AssertLogRelReturnVoid(iLUN == 0);
    49694971
    4970     PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_SEM_BUSY);
     4972    int const rcLock = PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_SEM_BUSY);
     4973    PDM_CRITSECT_RELEASE_ASSERT_RC_DEV(pDevIns, &pThis->CritSect, rcLock);
    49714974
    49724975    /** @todo r=pritesh still need to check if i missed
    … …  
    50015004    AssertLogRelReturn(iLUN == 0, VERR_PDM_NO_SUCH_LUN);
    50025005
    5003     PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_SEM_BUSY);
     5006    int const rcLock = PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_SEM_BUSY);
     5007    PDM_CRITSECT_RELEASE_ASSERT_RC_DEV(pDevIns, &pThis->CritSect, rcLock);
    50045008
    50055009    /*

  • trunk/src/VBox/Devices/Network/DevVirtioNet.cpp

    r90156 r90447  
    328328    return !!(pThis->VPCI.uGuestFeatures & VNET_F_MRG_RXBUF);
    329329}
     330
     331#define VNET_R3_CS_ENTER_RETURN_VOID(a_pDevIns, a_pThis) VPCI_R3_CS_ENTER_RETURN_VOID(a_pDevIns, &(a_pThis)->VPCI)
    330332
    331333DECLINLINE(int) vnetR3CsEnter(PPDMDEVINS pDevIns, PVNETSTATE pThis, int rcBusy)
    … …  
    648650    RT_NOREF(hTimer, pvUser);
    649651
    650     int rc = vnetR3CsEnter(pDevIns, pThis, VERR_SEM_BUSY);
    651     AssertRCReturnVoid(rc);
     652    VNET_R3_CS_ENTER_RETURN_VOID(pDevIns, pThis);
    652653
    653654    pThis->config.uStatus |= VNET_S_LINK_UP;
    … …  
    15091510        Log3(("%s vnetR3QueueTransmit: Got kicked with notification disabled, re-enable notification and flush TX queue\n", INSTANCE(pThis)));
    15101511        vnetR3TransmitPendingPackets(pDevIns, pThis, pThisCC, pQueue, false /*fOnWorkerThread*/);
    1511         if (RT_FAILURE(vnetR3CsEnter(pDevIns, pThis, VERR_SEM_BUSY)))
    1512             LogRel(("vnetR3QueueTransmit: Failed to enter critical section!/n"));
    1513         else
    1514         {
    1515             vringSetNotification(pDevIns, &pThisCC->pTxQueue->VRing, true);
    1516             vnetR3CsLeave(pDevIns, pThis);
    1517         }
     1512
     1513        VNET_R3_CS_ENTER_RETURN_VOID(pDevIns, pThis);
     1514
     1515        vringSetNotification(pDevIns, &pThisCC->pTxQueue->VRing, true);
     1516
     1517        vnetR3CsLeave(pDevIns, pThis);
    15181518    }
    15191519    else
    15201520    {
    1521         if (RT_FAILURE(vnetR3CsEnter(pDevIns, pThis, VERR_SEM_BUSY)))
    1522             LogRel(("vnetR3QueueTransmit: Failed to enter critical section!/n"));
    1523         else
    1524         {
    1525             vringSetNotification(pDevIns, &pThisCC->pTxQueue->VRing, false);
    1526             PDMDevHlpTimerSetMicro(pDevIns, pThis->hTxTimer, VNET_TX_DELAY);
    1527             pThis->u64NanoTS = RTTimeNanoTS();
    1528             vnetR3CsLeave(pDevIns, pThis);
    1529         }
     1521        VNET_R3_CS_ENTER_RETURN_VOID(pDevIns, pThis);
     1522
     1523        vringSetNotification(pDevIns, &pThisCC->pTxQueue->VRing, false);
     1524        PDMDevHlpTimerSetMicro(pDevIns, pThis->hTxTimer, VNET_TX_DELAY);
     1525        pThis->u64NanoTS = RTTimeNanoTS();
     1526
     1527        vnetR3CsLeave(pDevIns, pThis);
    15301528    }
    15311529}
    … …  
    15521550//    Log3(("%s vnetR3TxTimer: Expired\n", INSTANCE(pThis)));
    15531551    vnetR3TransmitPendingPackets(pDevIns, pThis, pThisCC, pThisCC->pTxQueue, false /*fOnWorkerThread*/);
    1554     int rc = vnetR3CsEnter(pDevIns, pThis, VERR_SEM_BUSY)
    1555     AssertLogRelRCReturnVoid(rc);
     1552
     1553    VNET_R3_CS_ENTER_RETURN_VOID(pDevIns, pThis);
    15561554    vringSetNotification(pDevIns, &pThisCC->pTxQueue->VRing, true);
    15571555    vnetR3CsLeave(pDevIns, pThis);
    … …  
    20432041    AssertLogRelReturnVoid(iLUN == 0);
    20442042
    2045     int rc = vnetR3CsEnter(pDevIns, pThis, VERR_SEM_BUSY);
    2046     if (RT_FAILURE(rc))
    2047     {
    2048         LogRel(("vnetR3Detach failed to enter critical section!\n"));
    2049         return;
    2050     }
     2043    VNET_R3_CS_ENTER_RETURN_VOID(pDevIns, pThis);
    20512044
    20522045    vnetR3DestroyTxThreadAndEvent(pDevIns, pThis, pThisCC);
    … …  
    20752068
    20762069    int rc = vnetR3CsEnter(pDevIns, pThis, VERR_SEM_BUSY);
    2077     if (RT_FAILURE(rc))
    2078     {
    2079         LogRel(("vnetR3Attach failed to enter critical section!\n"));
    2080         return rc;
    2081     }
     2070    AssertRCReturn(rc, rc);
    20822071
    20832072    /*
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