VirtualBox

Changeset 90447 in vbox


Ignore:
Timestamp:
Jul 31, 2021 12:44:13 AM (4 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
146051
Message:

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

Location:
trunk/src/VBox
Files:
24 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Devices/Audio/DevHda.cpp

    r90331 r90447  
    8383#define DEVHDA_LOCK(a_pDevIns, a_pThis) \
    8484    do { \
    85         int rcLock = PDMDevHlpCritSectEnter((a_pDevIns), &(a_pThis)->CritSect, VERR_IGNORED); \
    86         AssertRC(rcLock); \
     85        int const rcLock = PDMDevHlpCritSectEnter((a_pDevIns), &(a_pThis)->CritSect, VERR_IGNORED); \
     86        PDM_CRITSECT_RELEASE_ASSERT_RC_DEV((a_pDevIns), &(a_pThis)->CritSect, rcLock); \
    8787    } while (0)
    8888
    … …  
    9292#define DEVHDA_LOCK_RETURN(a_pDevIns, a_pThis, a_rcBusy) \
    9393    do { \
    94         int rcLock = PDMDevHlpCritSectEnter((a_pDevIns), &(a_pThis)->CritSect, a_rcBusy); \
     94        int const rcLock = PDMDevHlpCritSectEnter((a_pDevIns), &(a_pThis)->CritSect, a_rcBusy); \
    9595        if (rcLock == VINF_SUCCESS) \
    9696        { /* likely */ } \
    … …  
    107107# define DEVHDA_LOCK_RETURN_VOID(a_pDevIns, a_pThis) \
    108108    do { \
    109         int rcLock = PDMDevHlpCritSectEnter((a_pDevIns), &(a_pThis)->CritSect, VERR_IGNORED); \
     109        int const rcLock = PDMDevHlpCritSectEnter((a_pDevIns), &(a_pThis)->CritSect, VERR_IGNORED); \
    110110        if (rcLock == VINF_SUCCESS) \
    111111        { /* likely */ } \
    112112        else \
    113113        { \
    114             AssertRC(rcLock); \
     114            PDM_CRITSECT_RELEASE_ASSERT_RC_DEV((a_pDevIns), &(a_pThis)->CritSect, rcLock); \
    115115            return; \
    116116        } \
    … …  
    40814081                            RT_ZERO(StreamDummyShared); RT_ZERO(StreamDummyR3));
    40824082
    4083         PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_IGNORED); /* timer code requires this */
     4083        rc = PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_IGNORED); /* timer code requires this */
     4084        AssertRCReturn(rc, rc);
    40844085        rc = hdaR3StreamSetUp(pDevIns, pThis, pStreamShared, pStreamR3, idStream);
    40854086        PDMDevHlpCritSectLeave(pDevIns, &pThis->CritSect);
    … …  
    47534754
    47544755    if (PDMDevHlpCritSectIsInitialized(pDevIns, &pThis->CritSect))
    4755         PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_IGNORED);
     4756        (void)PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_IGNORED);
    47564757
    47574758    PHDADRIVER pDrv;

  • trunk/src/VBox/Devices/Audio/DevIchAc97.cpp

    r90247 r90447  
    640640#define DEVAC97_LOCK(a_pDevIns, a_pThis) \
    641641    do { \
    642         int rcLock = PDMDevHlpCritSectEnter((a_pDevIns), &(a_pThis)->CritSect, VERR_IGNORED); \
    643         AssertRC(rcLock); \
     642        int const rcLock = PDMDevHlpCritSectEnter((a_pDevIns), &(a_pThis)->CritSect, VERR_IGNORED); \
     643        PDM_CRITSECT_RELEASE_ASSERT_RC_DEV((a_pDevIns), &(a_pThis)->CritSect, rcLock); \
    644644    } while (0)
    645645
    … …  
    651651        int rcLock = PDMDevHlpCritSectEnter((a_pDevIns), &(a_pThis)->CritSect, a_rcBusy); \
    652652        if (rcLock == VINF_SUCCESS) \
    653             break; \
    654         AssertRC(rcLock); \
    655         return rcLock; \
     653        { /* likely */ } \
     654        else \
     655        { \
     656            AssertRC(rcLock); \
     657            return rcLock; \
     658        } \
    656659    } while (0)
    657660

  • trunk/src/VBox/Devices/EFI/DevEFI.cpp

    r85950 r90447  
    11381138    RT_NOREF(pszArgs);
    11391139    PDEVEFIR3 pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PDEVEFIR3);
    1140     PDMDevHlpCritSectEnter(pDevIns, pDevIns->pCritSectRoR3, VERR_IGNORED);
     1140    int const rcLock = PDMDevHlpCritSectEnter(pDevIns, pDevIns->pCritSectRoR3, VERR_IGNORED);
     1141    PDM_CRITSECT_RELEASE_ASSERT_RC_DEV(pDevIns, pDevIns->pCritSectRoR3, rcLock); \
    11411142
    11421143    pHlp->pfnPrintf(pHlp, "NVRAM variables: %u\n", pThisCC->NVRAM.cVariables);

  • trunk/src/VBox/Devices/Graphics/DevVGA-SVGA.cpp

    r90323 r90447  
    12511251                RT_NOREF(pDevIns);
    12521252                break;
    1253 #else
     1253#else /* IN_RING3 */
    12541254# if defined(VMSVGA_USE_EMT_HALT_CODE)
    12551255                /* The guest is basically doing a HLT via the device here, but with
    … …  
    12651265                    PDMDevHlpCritSectLeave(pDevIns, &pThis->CritSect); /* hack around lock order issue. */
    12661266                    rc = VMR3WaitForDeviceReady(pVM, idCpu);
    1267                     PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_IGNORED);
     1267                    int const rcLock = PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_IGNORED);
     1268                    PDM_CRITSECT_RELEASE_ASSERT_RC_DEV(pDevIns, &pThis->CritSect, rcLock);
    12681269                }
    12691270                ASMAtomicDecU32(&pSVGAState->cBusyDelayedEmts);
    … …  
    13011302# endif
    13021303                *pu32 = pThis->svga.fBusy != 0;
    1303 #endif
     1304#endif /* IN_RING3 */
    13041305            }
    13051306            else
    … …  
    29622963static void vmsvgaR3CmdBufRaiseIRQ(PPDMDEVINS pDevIns, PVGASTATE pThis, uint32_t u32IrqStatus)
    29632964{
    2964     int rc = PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_IGNORED);
    2965     AssertRC(rc);
     2965    int const rcLock = PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_IGNORED);
     2966    PDM_CRITSECT_RELEASE_ASSERT_RC_DEV(pDevIns, &pThis->CritSect, rcLock);
    29662967
    29672968    if (pThis->svga.u32IrqMask & u32IrqStatus)
    … …  
    50475048                || (pThis->svga.u32IrqMask & SVGA_IRQFLAG_FIFO_PROGRESS))
    50485049            {
    5049                 int rc2 = PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_IGNORED);
    5050                 AssertRC(rc2);
     5050                int const rcLock = PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_IGNORED);
     5051                PDM_CRITSECT_RELEASE_ASSERT_RC_DEV(pDevIns, &pThis->CritSect, rcLock);
    50515052
    50525053                /* FIFO progress might trigger an interrupt. */

  • trunk/src/VBox/Devices/Graphics/DevVGA.cpp

    r90200 r90447  
    31473147                if (u32 == HGSMIOFFSET_VOID)
    31483148                {
    3149                     PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSectIRQ, VERR_SEM_BUSY);
     3149                    int const rcLock = PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSectIRQ, VERR_SEM_BUSY);
     3150                    PDM_CRITSECT_RELEASE_ASSERT_RC_DEV(pDevIns, &pThis->CritSectIRQ, rcLock);
    31503151
    31513152                    if (pThis->fu32PendingGuestFlags == 0)
    … …  
    47594760
    47604761    int rc = PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_SEM_BUSY);
    4761     AssertRC(rc);
     4762    AssertRCReturn(rc, rc);
    47624763
    47634764# ifdef VBOX_WITH_VMSVGA
    … …  
    48444845
    48454846    int rc = PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_SEM_BUSY);
    4846     AssertRC(rc);
     4847    AssertRCReturn(rc, rc);
    48474848
    48484849    rc = vboxR3UpdateDisplayAllInternal(pDevIns, pThis, pThisCC, fFailOnResize);
    … …  
    50325033
    50335034    int rc = PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_SEM_BUSY);
    5034     AssertRC(rc);
     5035    AssertRCReturn(rc, rc);
    50355036
    50365037    /*
    … …  
    51295130
    51305131    int rc = PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_SEM_BUSY);
    5131     AssertRC(rc);
     5132    PDM_CRITSECT_RELEASE_ASSERT_RC_DEV(pDevIns, &pThis->CritSect, rc);
    51325133
    51335134    /* Check if there is something to do at all. */
    … …  
    53405341
    53415342    int rc = PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_SEM_BUSY);
    5342     AssertRC(rc);
     5343    AssertRCReturn(rc, rc);
    53435344
    53445345    /* This method only works if the VGA device is in a VBE mode or not paused VBVA mode.
    … …  
    54305431    LogFlow(("vgaR3PortSetRenderVRAM: fRender = %d\n", fRender));
    54315432
    5432     int rc = PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_SEM_BUSY);
    5433     AssertRC(rc);
     5433    int const rcLock = PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_SEM_BUSY);
     5434    PDM_CRITSECT_RELEASE_ASSERT_RC_DEV(pDevIns, &pThis->CritSect, rcLock);
    54345435
    54355436    pThis->fRenderVRAM = fRender;
    … …  
    60716072    {
    60726073        PDMDevHlpCritSectLeave(pDevIns, &pThis->CritSect); /* hack around lock order issue. */
     6074
    60736075        pThisCC->pDrv->pfnReset(pThisCC->pDrv);
    60746076        pThisCC->pDrv->pfnVBVAMousePointerShape(pThisCC->pDrv, false, false, 0, 0, 0, 0, NULL);
    6075         PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_IGNORED);
     6077
     6078        int const rcLock = PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_IGNORED);
     6079        PDM_CRITSECT_RELEASE_ASSERT_RC_DEV(pDevIns, &pThis->CritSect, rcLock);
    60766080    }
    60776081

  • trunk/src/VBox/Devices/Graphics/DevVGA_VBVA.cpp

    r85121 r90447  
    904904        return;
    905905
    906     PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_SEM_BUSY);
     906    int const rcLock = PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_SEM_BUSY);
     907    PDM_CRITSECT_RELEASE_ASSERT_RC_DEV(pDevIns, &pThis->CritSect, rcLock);
    907908
    908909    VBOX_VHWA_PENDINGCMD *pIter, *pNext;
    … …  
    926927        return;
    927928
    928     PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_SEM_BUSY);
     929    int const rcLock = PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_SEM_BUSY);
     930    PDM_CRITSECT_RELEASE_ASSERT_RC_DEV(pDevIns, &pThis->CritSect, rcLock);
    929931
    930932    VBOX_VHWA_PENDINGCMD *pIter, *pNext;
    … …  
    951953            pCommand->Flags |= VBOXVHWACMD_FLAG_HG_ASYNCH;
    952954            pPend->pCommand = pCommand;
    953             PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_SEM_BUSY);
     955
     956            int const rcLock = PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_SEM_BUSY);
     957            PDM_CRITSECT_RELEASE_ASSERT_RC_DEV(pDevIns, &pThis->CritSect, rcLock);
     958
    954959            if (ASMAtomicUoReadU32(&pThis->pendingVhwaCommands.cPending) < VBOX_VHWA_MAX_PENDING_COMMANDS)
    955960            {
    … …  
    11081113        return true;
    11091114
    1110     PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_SEM_BUSY);
     1115    int const rcLock = PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_SEM_BUSY);
     1116    PDM_CRITSECT_RELEASE_ASSERT_RC_DEV(pDevIns, &pThis->CritSect, rcLock);
    11111117
    11121118    VBOX_VHWA_PENDINGCMD *pIter, *pNext;
    … …  
    21102116void VBVARaiseIrq(PPDMDEVINS pDevIns, PVGASTATE pThis, PVGASTATECC pThisCC, uint32_t fFlags)
    21112117{
    2112     PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSectIRQ, VERR_SEM_BUSY);
     2118    int const rcLock = PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSectIRQ, VERR_SEM_BUSY);
     2119    PDM_CRITSECT_RELEASE_ASSERT_RC_DEV(pDevIns, &pThis->CritSectIRQ, rcLock);
    21132120
    21142121    const uint32_t fu32CurrentGuestFlags = HGSMIGetHostGuestFlags(pThisCC->pHGSMI);
    … …  
    21372144void VBVAOnResume(PPDMDEVINS pDevIns, PVGASTATE pThis, PVGASTATECC pThisCC)
    21382145{
    2139     PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSectIRQ, VERR_SEM_BUSY);
     2146    int const rcLock = PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSectIRQ, VERR_SEM_BUSY);
     2147    PDM_CRITSECT_RELEASE_ASSERT_RC_DEV(pDevIns, &pThis->CritSectIRQ, rcLock);
    21402148
    21412149    if (HGSMIGetHostGuestFlags(pThisCC->pHGSMI) & HGSMIHOSTFLAGS_IRQ)
    … …  
    28102818    PVGASTATE   pThis   = PDMDEVINS_2_DATA(pDevIns, PVGASTATE);
    28112819    int rc = PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_SEM_BUSY);
    2812     AssertRC(rc);
     2820    AssertRCReturn(rc, rc);
    28132821
    28142822    rc = vbvaSendModeHintWorker(pDevIns, pThis, pThisCC, cx, cy, cBPP, iDisplay, dx, dy, fEnabled, fNotifyGuest);

  • trunk/src/VBox/Devices/Input/DevPS2K.cpp

    r90303 r90447  
    10461046
    10471047    /* Grab the lock to avoid races with event delivery or EMTs. */
    1048     int rc = PDMDevHlpCritSectEnter(pDevIns, pDevIns->pCritSectRoR3, VERR_SEM_BUSY);
    1049     AssertReleaseRC(rc);
     1048    int const rcLock = PDMDevHlpCritSectEnter(pDevIns, pDevIns->pCritSectRoR3, VERR_SEM_BUSY);
     1049    PDM_CRITSECT_RELEASE_ASSERT_RC_DEV(pDevIns, pDevIns->pCritSectRoR3, rcLock);
    10501050
    10511051    /* If data is available, poke the KBC. Once the data
    … …  
    12221222    PPDMDEVINS  pDevIns = pThisCC->pDevIns;
    12231223    PPS2K       pThis   = &PDMDEVINS_2_DATA(pDevIns, PKBDSTATE)->Kbd;
    1224     int         rc;
    12251224
    12261225    LogRelFlowFunc(("key code %08X\n", idUsage));
    12271226
    1228     rc = PDMDevHlpCritSectEnter(pDevIns, pDevIns->pCritSectRoR3, VERR_SEM_BUSY);
    1229     AssertReleaseRC(rc);
     1227    int const rcLock = PDMDevHlpCritSectEnter(pDevIns, pDevIns->pCritSectRoR3, VERR_SEM_BUSY);
     1228    PDM_CRITSECT_RELEASE_ASSERT_RC_DEV(pDevIns, pDevIns->pCritSectRoR3, rcLock);
    12301229
    12311230    /* The 'BAT fail' scancode is reused as a signal to release keys. No actual

  • trunk/src/VBox/Devices/Input/DevPS2M.cpp

    r90198 r90447  
    873873    PPDMDEVINS  pDevIns = pThisCC->pDevIns;
    874874    PPS2M       pThis   = &PDMDEVINS_2_DATA(pDevIns, PKBDSTATE)->Aux;
    875     int rc = PDMDevHlpCritSectEnter(pDevIns, pDevIns->pCritSectRoR3, VERR_SEM_BUSY);
    876     AssertReleaseRC(rc);
     875    int const   rcLock = PDMDevHlpCritSectEnter(pDevIns, pDevIns->pCritSectRoR3, VERR_SEM_BUSY);
     876    PDM_CRITSECT_RELEASE_ASSERT_RC_DEV(pDevIns, pDevIns->pCritSectRoR3, rcLock);
    877877
    878878    LogRelFlowFunc(("dX=%d dY=%d dZ=%d dW=%d buttons=%02X\n", dx, dy, dz, dw, fButtons));

  • 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    /*

  • trunk/src/VBox/Devices/PC/DevACPI.cpp

    r88484 r90447  
    6565    do { \
    6666        int rcLock = PDMDevHlpCritSectEnter((a_pDevIns), &(a_pThis)->CritSect, VERR_IGNORED); \
    67         AssertRC(rcLock); \
     67        PDM_CRITSECT_RELEASE_ASSERT_RC_DEV((a_pDevIns), &(a_pThis)->CritSect, rcLock); \
    6868    } while (0)
    6969#endif

  • trunk/src/VBox/Devices/PC/DevDMA.cpp

    r87127 r90447  
    638638        for (unsigned idxCh = 0; idxCh < RT_ELEMENTS(pThis->DMAC[idxCtl].ChState); idxCh++)
    639639            if (pThis->DMAC[idxCtl].ChState[idxCh].pDevInsHandler)
    640                 PDMDevHlpCritSectEnter(pDevIns, pThis->DMAC[idxCtl].ChState[idxCh].pDevInsHandler->pCritSectRoR3, VERR_IGNORED);
    641     PDMDevHlpCritSectEnter(pDevIns, pDevIns->pCritSectRoR3, VERR_IGNORED);
     640            {
     641                int const rc = PDMDevHlpCritSectEnter(pDevIns, pThis->DMAC[idxCtl].ChState[idxCh].pDevInsHandler->pCritSectRoR3,
     642                                                      VERR_IGNORED);
     643                PDM_CRITSECT_RELEASE_ASSERT_RC_DEV(pDevIns, pThis->DMAC[idxCtl].ChState[idxCh].pDevInsHandler->pCritSectRoR3, rc);
     644            }
     645    int const rc = PDMDevHlpCritSectEnter(pDevIns, pDevIns->pCritSectRoR3, VERR_IGNORED);
     646    PDM_CRITSECT_RELEASE_ASSERT_RC_DEV(pDevIns, pDevIns->pCritSectRoR3, rc);
    642647
    643648    /* Run all controllers and channels. */
    … …  
    680685    LogFlow(("dmaR3Register: pThis=%p uChannel=%u pfnTransferHandler=%p pvUser=%p\n", pThis, uChannel, pfnTransferHandler, pvUser));
    681686
    682     PDMDevHlpCritSectEnter(pDevIns, pDevIns->pCritSectRoR3, VERR_IGNORED);
     687    int const rcLock = PDMDevHlpCritSectEnter(pDevIns, pDevIns->pCritSectRoR3, VERR_IGNORED);
     688    PDM_CRITSECT_RELEASE_ASSERT_RC_DEV(pDevIns, pDevIns->pCritSectRoR3, rcLock);
     689
    683690    ch->pDevInsHandler = pDevInsHandler;
    684691    ch->pfnXferHandler = pfnTransferHandler;
    685692    ch->pvUser = pvUser;
     693
    686694    PDMDevHlpCritSectLeave(pDevIns, pDevIns->pCritSectRoR3);
    687695}
    … …  
    735743    LogFlow(("dmaR3ReadMemory: pThis=%p uChannel=%u pvBuffer=%p off=%u cbBlock=%u\n", pThis, uChannel, pvBuffer, off, cbBlock));
    736744
    737     PDMDevHlpCritSectEnter(pDevIns, pDevIns->pCritSectRoR3, VERR_IGNORED);
     745    int const rcLock = PDMDevHlpCritSectEnter(pDevIns, pDevIns->pCritSectRoR3, VERR_IGNORED);
     746    PDM_CRITSECT_RELEASE_ASSERT_RC_DEV(pDevIns, pDevIns->pCritSectRoR3, rcLock);
    738747
    739748    /* Build the address for this transfer. */
    … …  
    776785    }
    777786
    778     PDMDevHlpCritSectEnter(pDevIns, pDevIns->pCritSectRoR3, VERR_IGNORED);
     787    int const rcLock = PDMDevHlpCritSectEnter(pDevIns, pDevIns->pCritSectRoR3, VERR_IGNORED);
     788    PDM_CRITSECT_RELEASE_ASSERT_RC_DEV(pDevIns, pDevIns->pCritSectRoR3, rcLock);
    779789
    780790    /* Build the address for this transfer. */
    … …  
    813823    LogFlow(("dmaR3SetDREQ: pThis=%p uChannel=%u uLevel=%u\n", pThis, uChannel, uLevel));
    814824
    815     PDMDevHlpCritSectEnter(pDevIns, pDevIns->pCritSectRoR3, VERR_IGNORED);
     825    int const rcLock = PDMDevHlpCritSectEnter(pDevIns, pDevIns->pCritSectRoR3, VERR_IGNORED);
     826    PDM_CRITSECT_RELEASE_ASSERT_RC_DEV(pDevIns, pDevIns->pCritSectRoR3, rcLock);
     827
    816828    chidx  = uChannel & 3;
    817829    if (uLevel)
    … …  
    819831    else
    820832        dc->u8Status &= ~(1 << (chidx + 4));
     833
    821834    PDMDevHlpCritSectLeave(pDevIns, pDevIns->pCritSectRoR3);
    822835}
    … …  
    831844    LogFlow(("dmaR3GetChannelMode: pThis=%p uChannel=%u\n", pThis, uChannel));
    832845
    833     PDMDevHlpCritSectEnter(pDevIns, pDevIns->pCritSectRoR3, VERR_IGNORED);
     846    int const rcLock = PDMDevHlpCritSectEnter(pDevIns, pDevIns->pCritSectRoR3, VERR_IGNORED);
     847    PDM_CRITSECT_RELEASE_ASSERT_RC_DEV(pDevIns, pDevIns->pCritSectRoR3, rcLock);
     848
    834849    uint8_t u8Mode = pThis->DMAC[DMACH2C(uChannel)].ChState[uChannel & 3].u8Mode;
     850
    835851    PDMDevHlpCritSectLeave(pDevIns, pDevIns->pCritSectRoR3);
    836852    return u8Mode;

  • trunk/src/VBox/Devices/PC/DevHPET.cpp

    r90304 r90447  
    179179#define DEVHPET_LOCK_RETURN(a_pDevIns, a_pThis, a_rcBusy)  \
    180180    do { \
    181         int rcLock = PDMDevHlpCritSectEnter((a_pDevIns), &(a_pThis)->CritSect, (a_rcBusy)); \
     181        int const rcLock = PDMDevHlpCritSectEnter((a_pDevIns), &(a_pThis)->CritSect, (a_rcBusy)); \
    182182        if (RT_LIKELY(rcLock == VINF_SUCCESS)) \
    183183        { /* likely */ } \
    … …  
    15811581     * Set the timer frequency hints.
    15821582     */
    1583     PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_IGNORED);
     1583    rc = PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_IGNORED);
     1584    AssertRCReturn(rc, rc);
     1585
    15841586    for (uint32_t iTimer = 0; iTimer < cTimers; iTimer++)
    15851587    {
    … …  
    15881590            hpetTimerSetFrequencyHint(pDevIns, pThis, pHpetTimer, pHpetTimer->u64Config, pHpetTimer->u64Period);
    15891591    }
     1592
    15901593    PDMDevHlpCritSectLeave(pDevIns, &pThis->CritSect);
    15911594    return VINF_SUCCESS;

  • trunk/src/VBox/Devices/PC/DevPit-i8254.cpp

    r87773 r90447  
    107107#define DEVPIT_LOCK_RETURN(a_pDevIns, a_pThis, a_rcBusy)  \
    108108    do { \
    109         int rcLock = PDMDevHlpCritSectEnter((a_pDevIns), &(a_pThis)->CritSect, (a_rcBusy)); \
    110         if (rcLock != VINF_SUCCESS) \
    111             return rcLock; \
     109        int const rcLock = PDMDevHlpCritSectEnter((a_pDevIns), &(a_pThis)->CritSect, (a_rcBusy)); \
     110        if (rcLock == VINF_SUCCESS) { /* likely */ } \
     111        else return rcLock; \
    112112    } while (0)
    113113
    … …  
    981981    PPITSTATE     pThis = PDMDEVINS_2_DATA(pDevIns, PPITSTATE);
    982982    PCPDMDEVHLPR3 pHlp  = pDevIns->pHlpR3;
    983     PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_IGNORED);
     983    int rc = PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_IGNORED);
     984    AssertRCReturn(rc, rc);
    984985
    985986    /* The config. */
    … …  
    10851086        if (pChan->hTimer != NIL_TMTIMERHANDLE)
    10861087        {
    1087             PDMDevHlpTimerLoad(pDevIns, pChan->hTimer, pSSM);
     1088            rc = PDMDevHlpTimerLoad(pDevIns, pChan->hTimer, pSSM);
     1089            AssertRCReturn(rc, rc);
    10881090            LogRel(("PIT: mode=%d count=%#x (%u) - %d.%02d Hz (ch=%d) (restore)\n",
    10891091                    pChan->mode, pChan->count, pChan->count, PIT_FREQ / pChan->count, (PIT_FREQ * 100 / pChan->count) % 100, i));
    1090             PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_IGNORED);
     1092            rc = PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_IGNORED);
     1093            AssertRCReturn(rc, rc);
    10911094            PDMDevHlpTimerSetFrequencyHint(pDevIns, pChan->hTimer, PIT_FREQ / pChan->count);
    10921095            PDMDevHlpCritSectLeave(pDevIns, &pThis->CritSect);
    … …  
    11031106# endif
    11041107    if (uVersion > PIT_SAVED_STATE_VERSION_VBOX_31)
    1105         pHlp->pfnSSMGetBool(pSSM, &pThis->fDisabledByHpet);
     1108        rc = pHlp->pfnSSMGetBool(pSSM, &pThis->fDisabledByHpet);
    11061109
    11071110    return VINF_SUCCESS;
    … …  
    11831186    PPDMDEVINS   pDevIns = pThisCC->pDevIns;
    11841187    PPITSTATE    pThis   = PDMDEVINS_2_DATA(pDevIns, PPITSTATE);
    1185     PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_IGNORED);
     1188    int const    rcLock  = PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_IGNORED);
     1189    PDM_CRITSECT_RELEASE_ASSERT_RC_DEV(pDevIns, &pThis->CritSect, rcLock);
    11861190
    11871191    pThis->fDisabledByHpet = fActivated;

  • trunk/src/VBox/Devices/PC/DevRTC.cpp

    r90445 r90447  
    10341034{
    10351035    PRTCSTATECC pThisCC = RT_FROM_MEMBER(pInterface, RTCSTATER3, IHpetLegacyNotify);
    1036     PPDMDEVINS pDevIns = pThisCC->pDevInsR3;
    1037     PDMDevHlpCritSectEnter(pDevIns, pDevIns->pCritSectRoR3, VERR_IGNORED);
     1036    PPDMDEVINS  pDevIns = pThisCC->pDevInsR3;
     1037    int const   rcLock  = PDMDevHlpCritSectEnter(pDevIns, pDevIns->pCritSectRoR3, VERR_IGNORED);
     1038    PDM_CRITSECT_RELEASE_ASSERT_RC_DEV(pDevIns, pDevIns->pCritSectRoR3, rcLock);
    10381039
    10391040    pThisCC->pShared->fDisabledByHpet = fActivated;

  • trunk/src/VBox/Devices/Serial/UartCore.cpp

    r90445 r90447  
    15981598    AssertMsg((uint32_t)cbAvail == cbAvail, ("Too much data available\n"));
    15991599
    1600     PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_IGNORED);
     1600    int rcLock = PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_IGNORED);
     1601    AssertRCReturn(rcLock, rcLock);
     1602
    16011603    uint32_t cbAvailOld = ASMAtomicAddU32(&pThis->cbAvailRdr, (uint32_t)cbAvail);
    16021604    LogFlow(("    cbAvailRdr=%u -> cbAvailRdr=%u\n", cbAvailOld, cbAvail + cbAvailOld));
    … …  
    16151617        }
    16161618    }
     1619
    16171620    PDMDevHlpCritSectLeave(pDevIns, &pThis->CritSect);
    1618 
    16191621    return VINF_SUCCESS;
    16201622}
    … …  
    16321634
    16331635    /* Set the transmitter empty bit because everything was sent. */
    1634     PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_IGNORED);
     1636    int const rcLock = PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_IGNORED);
     1637    AssertRCReturn(rcLock, rcLock);
     1638
    16351639    UART_REG_SET(pThis->uRegLsr, UART_REG_LSR_TEMT);
    16361640    uartIrqUpdate(pDevIns, pThis, pThisCC);
     1641
    16371642    PDMDevHlpCritSectLeave(pDevIns, &pThis->CritSect);
    16381643    return VINF_SUCCESS;
    … …  
    16521657    AssertReturn(cbRead > 0, VERR_INVALID_PARAMETER);
    16531658
    1654     PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_IGNORED);
     1659    int const rcLock = PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_IGNORED);
     1660    AssertRCReturn(rcLock, rcLock);
     1661
    16551662    uartR3TxQueueCopyFrom(pDevIns, pThis, pThisCC, pvBuf, cbRead, pcbRead);
     1663
    16561664    PDMDevHlpCritSectLeave(pDevIns, &pThis->CritSect);
    1657 
    16581665    LogFlowFunc(("-> VINF_SUCCESS{*pcbRead=%zu}\n", *pcbRead));
    16591666    return VINF_SUCCESS;
    … …  
    16701677    PUARTCORE   pThis   = pThisCC->pShared;
    16711678    PPDMDEVINS  pDevIns = pThisCC->pDevIns;
    1672 
    1673     PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_IGNORED);
     1679    int const   rcLock  = PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_IGNORED);
     1680    AssertRCReturn(rcLock, rcLock);
     1681
    16741682    uartR3StsLinesUpdate(pDevIns, pThis, pThisCC, fNewStatusLines);
     1683
    16751684    PDMDevHlpCritSectLeave(pDevIns, &pThis->CritSect);
    16761685    return VINF_SUCCESS;
    … …  
    16871696    PUARTCORE   pThis   = pThisCC->pShared;
    16881697    PPDMDEVINS  pDevIns = pThisCC->pDevIns;
    1689 
    1690     PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_IGNORED);
     1698    int const   rcLock  = PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_IGNORED);
     1699    AssertRCReturn(rcLock, rcLock);
     1700
    16911701    UART_REG_SET(pThis->uRegLsr, UART_REG_LSR_BI);
    16921702    uartIrqUpdate(pDevIns, pThis, pThisCC);
     1703
    16931704    PDMDevHlpCritSectLeave(pDevIns, &pThis->CritSect);
    16941705    return VINF_SUCCESS;
    … …  
    19491960            return VERR_PDM_MISSING_INTERFACE;
    19501961        }
    1951         PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_IGNORED);
    1952         uartR3XferReset(pDevIns, pThis, pThisCC);
    1953         PDMDevHlpCritSectLeave(pDevIns, &pThis->CritSect);
     1962        rc = PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_IGNORED);
     1963        if (RT_SUCCESS(rc))
     1964        {
     1965            uartR3XferReset(pDevIns, pThis, pThisCC);
     1966            PDMDevHlpCritSectLeave(pDevIns, &pThis->CritSect);
     1967        }
    19541968    }
    19551969    else if (rc == VERR_PDM_NO_ATTACHED_DRIVER)
    … …  
    19571971        pThisCC->pDrvBase = NULL;
    19581972        pThisCC->pDrvSerial = NULL;
    1959         rc = VINF_SUCCESS;
    1960         PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_IGNORED);
    1961         uartR3XferReset(pDevIns, pThis, pThisCC);
    1962         PDMDevHlpCritSectLeave(pDevIns, &pThis->CritSect);
     1973        rc = PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_IGNORED);
     1974        if (RT_SUCCESS(rc))
     1975        {
     1976            uartR3XferReset(pDevIns, pThis, pThisCC);
     1977            PDMDevHlpCritSectLeave(pDevIns, &pThis->CritSect);
     1978        }
    19631979        LogRel(("Serial#%d: no unit\n", pDevIns->iInstance));
    19641980    }
    … …  
    19831999    pThisCC->pDrvBase   = NULL;
    19842000    pThisCC->pDrvSerial = NULL;
    1985     PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_IGNORED);
     2001    int const rcLock = PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_IGNORED);
     2002    PDM_CRITSECT_RELEASE_ASSERT_RC_DEV(pDevIns, &pThis->CritSect, rcLock);
     2003
    19862004    uartR3XferReset(pDevIns, pThis, pThisCC);
     2005
    19872006    PDMDevHlpCritSectLeave(pDevIns, &pThis->CritSect);
    19882007}

  • trunk/src/VBox/Devices/Storage/DevATA.cpp

    r90445 r90447  
    71047104            {
    71057105                /* Make it signal PDM & itself when its done */
    7106                 PDMDevHlpCritSectEnter(pDevIns, &pThis->aCts[i].AsyncIORequestLock, VERR_IGNORED);
     7106                int const rcLock = PDMDevHlpCritSectEnter(pDevIns, &pThis->aCts[i].AsyncIORequestLock, VERR_IGNORED);
     7107                PDM_CRITSECT_RELEASE_ASSERT_RC_DEV(pDevIns, &pThis->aCts[i].AsyncIORequestLock, rcLock);
     7108
    71077109                ASMAtomicWriteBool(&pThisCC->aCts[i].fSignalIdle, true);
     7110
    71087111                PDMDevHlpCritSectLeave(pDevIns, &pThis->aCts[i].AsyncIORequestLock);
    71097112
    … …  
    75577560    for (uint32_t i = 0; i < RT_ELEMENTS(pThis->aCts); i++)
    75587561    {
    7559         PDMDevHlpCritSectEnter(pDevIns, &pThis->aCts[i].lock, VERR_INTERNAL_ERROR);
     7562        int const rcLock = PDMDevHlpCritSectEnter(pDevIns, &pThis->aCts[i].lock, VERR_INTERNAL_ERROR);
     7563        PDM_CRITSECT_RELEASE_ASSERT_RC_DEV(pDevIns, &pThis->aCts[i].lock, rcLock);
     7564
    75607565        for (uint32_t j = 0; j < RT_ELEMENTS(pThis->aCts[i].aIfs); j++)
    75617566            ataR3ResetDevice(pDevIns, &pThis->aCts[i], &pThis->aCts[i].aIfs[j]);
     7567
    75627568        PDMDevHlpCritSectLeave(pDevIns, &pThis->aCts[i].lock);
    75637569    }
    … …  
    75807586    for (uint32_t i = 0; i < RT_ELEMENTS(pThis->aCts); i++)
    75817587    {
    7582         PDMDevHlpCritSectEnter(pDevIns, &pThis->aCts[i].lock, VERR_INTERNAL_ERROR);
     7588        int const rcLock = PDMDevHlpCritSectEnter(pDevIns, &pThis->aCts[i].lock, VERR_INTERNAL_ERROR);
     7589        PDM_CRITSECT_RELEASE_ASSERT_RC_DEV(pDevIns, &pThis->aCts[i].lock, rcLock);
    75837590
    75847591        pThis->aCts[i].iSelectedIf = 0;
    … …  
    76277634            {
    76287635                int rc = PDMDevHlpCritSectEnter(pDevIns, &pThis->aCts[i].AsyncIORequestLock, VERR_IGNORED);
    7629                 AssertRC(rc);
     7636                PDM_CRITSECT_RELEASE_ASSERT_RC_DEV(pDevIns, &pThis->aCts[i].AsyncIORequestLock, rc);
    76307637
    76317638                ASMAtomicWriteBool(&pThisCC->aCts[i].fSignalIdle, true);

  • trunk/src/VBox/Devices/USB/DevOHCI.cpp

    r90332 r90447  
    10351035    memset(pAvailable, 0, sizeof(*pAvailable));
    10361036
    1037     PDMDevHlpCritSectEnter(pDevIns, pDevIns->pCritSectRoR3, VERR_IGNORED);
     1037    int const  rcLock  = PDMDevHlpCritSectEnter(pDevIns, pDevIns->pCritSectRoR3, VERR_IGNORED);
     1038    PDM_CRITSECT_RELEASE_ASSERT_RC_DEV(pDevIns, pDevIns->pCritSectRoR3, rcLock);
     1039
     1040
    10381041    for (unsigned iPort = 0; iPort < OHCI_NDP_CFG(pThis); iPort++)
    10391042        if (!pThis->RootHub.aPorts[iPort].pDev)
    … …  
    10421045            ASMBitSet(pAvailable, iPort + 1);
    10431046        }
     1047
    10441048    PDMDevHlpCritSectLeave(pDevIns, pDevIns->pCritSectRoR3);
    1045 
    10461049    return cPorts;
    10471050}
    … …  
    10751078    VUSBSPEED  enmSpeed;
    10761079    LogFlow(("ohciR3RhAttach: pDev=%p uPort=%u\n", pDev, uPort));
    1077     PDMDevHlpCritSectEnter(pDevIns, pDevIns->pCritSectRoR3, VERR_IGNORED);
     1080    int const  rcLock  = PDMDevHlpCritSectEnter(pDevIns, pDevIns->pCritSectRoR3, VERR_IGNORED);
     1081    PDM_CRITSECT_RELEASE_ASSERT_RC_DEV(pDevIns, pDevIns->pCritSectRoR3, rcLock);
    10781082
    10791083    /*
    … …  
    11181122    RT_NOREF(pDev);
    11191123    LogFlow(("ohciR3RhDetach: pDev=%p uPort=%u\n", pDev, uPort));
    1120     PDMDevHlpCritSectEnter(pDevIns, pDevIns->pCritSectRoR3, VERR_IGNORED);
     1124    int const  rcLock  = PDMDevHlpCritSectEnter(pDevIns, pDevIns->pCritSectRoR3, VERR_IGNORED);
     1125    PDM_CRITSECT_RELEASE_ASSERT_RC_DEV(pDevIns, pDevIns->pCritSectRoR3, rcLock);
    11211126
    11221127    /*
    … …  
    11771182    PPDMDEVINS pDevIns = pThisCC->pDevInsR3;
    11781183    POHCI      pThis   = PDMDEVINS_2_DATA(pDevIns, POHCI);
    1179     PDMDevHlpCritSectEnter(pDevIns, pDevIns->pCritSectRoR3, VERR_IGNORED);
     1184    int const  rcLock  = PDMDevHlpCritSectEnter(pDevIns, pDevIns->pCritSectRoR3, VERR_IGNORED);
     1185    PDM_CRITSECT_RELEASE_ASSERT_RC_DEV(pDevIns, pDevIns->pCritSectRoR3, rcLock);
    11801186
    11811187    Log(("ohci: root hub reset%s\n", fResetOnLinux ? " (reset on linux)" : ""));
    … …  
    56095615     * Detach all proxied devices.
    56105616     */
    5611     PDMDevHlpCritSectEnter(pDevIns, pDevIns->pCritSectRoR3, VERR_IGNORED);
     5617    int rc = PDMDevHlpCritSectEnter(pDevIns, pDevIns->pCritSectRoR3, VERR_IGNORED);
     5618    AssertRCReturn(rc, rc);
     5619
    56125620    /** @todo this won't work well when continuing after saving! */
    56135621    for (unsigned i = 0; i < RT_ELEMENTS(pThis->RootHub.aPorts); i++)
    … …  
    56285636        }
    56295637    }
     5638
    56305639    PDMDevHlpCritSectLeave(pDevIns, pDevIns->pCritSectRoR3);
    56315640

  • trunk/src/VBox/Devices/VMMDev/VMMDev.cpp

    r90332 r90447  
    383383       )
    384384    {
    385         PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_IGNORED);
     385        int const rcLock = PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_IGNORED);
     386        PDM_CRITSECT_RELEASE_ASSERT_RC_DEV(pDevIns, &pThis->CritSect, rcLock);
     387
    386388        vmmdevNotifyGuestWorker(pDevIns, pThis, pThisCC, fAddEvents);
     389
    387390        PDMDevHlpCritSectLeave(pDevIns, &pThis->CritSect);
    388391    }
    … …  
    409412void VMMDevCtlSetGuestFilterMask(PPDMDEVINS pDevIns, PVMMDEV pThis, PVMMDEVCC pThisCC, uint32_t fOrMask, uint32_t fNotMask)
    410413{
    411     PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_IGNORED);
     414    int const rcLock = PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_IGNORED);
     415    PDM_CRITSECT_RELEASE_ASSERT_RC_DEV(pDevIns, &pThis->CritSect, rcLock);
    412416
    413417    const bool fHadEvents = (pThis->fHostEventFlags & pThis->fGuestFilterMask) != 0;
    … …  
    30683072                 */
    30693073                uint32_t fPostOptimize = 0;
    3070                 PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_IGNORED);
     3074                int const rcLock = PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_IGNORED);
     3075                PDM_CRITSECT_RELEASE_ASSERT_RC_DEV(pDevIns, &pThis->CritSect, rcLock);
     3076
    30713077                rcRet = vmmdevReqDispatcher(pDevIns, pThis, pThisCC, pRequestHeader, u32, tsArrival, &fPostOptimize, &pLock);
     3078
    30723079                PDMDevHlpCritSectLeave(pDevIns, &pThis->CritSect);
    30733080
    … …  
    35423549    PPDMDEVINS pDevIns = pThisCC->pDevIns;
    35433550    PVMMDEV    pThis   = PDMDEVINS_2_DATA(pDevIns, PVMMDEV);
    3544     PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_IGNORED);
     3551    int const  rcLock  = PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_IGNORED);
     3552    AssertRCReturn(rcLock, rcLock);
    35453553
    35463554    if (   pThis->xMouseAbs != xAbs
    … …  
    35793587    PPDMDEVINS pDevIns = pThisCC->pDevIns;
    35803588    PVMMDEV    pThis   = PDMDEVINS_2_DATA(pDevIns, PVMMDEV);
    3581     PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_IGNORED);
     3589    int const  rcLock  = PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_IGNORED);
     3590    AssertRCReturn(rcLock, rcLock);
    35823591
    35833592    uint32_t fOldCaps = pThis->fMouseCapabilities;
    … …  
    36383647    int         rc           = VINF_SUCCESS;
    36393648    bool        fNotifyGuest = false;
    3640 
    3641     PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_IGNORED);
     3649    int const   rcLock       = PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_IGNORED);
     3650    AssertRCReturn(rcLock, rcLock);
    36423651
    36433652    uint32_t i;
    … …  
    37053714    PPDMDEVINS pDevIns = pThisCC->pDevIns;
    37063715    PVMMDEV    pThis   = PDMDEVINS_2_DATA(pDevIns, PVMMDEV);
    3707     PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_IGNORED);
     3716    int const  rcLock  = PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_IGNORED);
     3717    AssertRCReturn(rcLock, rcLock);
    37083718
    37093719    /* Verify that the new resolution is different and that guest does not yet know about it. */
    … …  
    37333743    PPDMDEVINS pDevIns = pThisCC->pDevIns;
    37343744    PVMMDEV    pThis   = PDMDEVINS_2_DATA(pDevIns, PVMMDEV);
    3735     PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_IGNORED);
     3745    int const  rcLock  = PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_IGNORED);
     3746    AssertRCReturn(rcLock, rcLock);
    37363747
    37373748    /* Verify that the new resolution is different and that guest does not yet know about it. */
    … …  
    37583769    PPDMDEVINS pDevIns = pThisCC->pDevIns;
    37593770    PVMMDEV    pThis   = PDMDEVINS_2_DATA(pDevIns, PVMMDEV);
    3760     PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_IGNORED);
     3771    int const  rcLock  = PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_IGNORED);
     3772    AssertRCReturn(rcLock, rcLock);
    37613773
    37623774    bool fSame = (pThis->fVRDPEnabled == fVRDPEnabled);
    … …  
    37843796    PPDMDEVINS pDevIns = pThisCC->pDevIns;
    37853797    PVMMDEV    pThis   = PDMDEVINS_2_DATA(pDevIns, PVMMDEV);
    3786     PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_IGNORED);
     3798    int const  rcLock  = PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_IGNORED);
     3799    AssertRCReturn(rcLock, rcLock);
    37873800
    37883801    /* Verify that the new resolution is different and that guest does not yet know about it. */
    … …  
    38253838    AssertPtrReturn(pCredentials, VERR_NOT_SUPPORTED);
    38263839
    3827     PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_IGNORED);
     3840    int const rcLock = PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_IGNORED);
     3841    AssertRCReturn(rcLock, rcLock);
    38283842
    38293843    /*
    … …  
    38853899    PPDMDEVINS  pDevIns = pThisCC->pDevIns;
    38863900    PVMMDEV     pThis   = PDMDEVINS_2_DATA(pDevIns, PVMMDEV);
    3887     int         rc      = VINF_SUCCESS;
    38883901
    38893902    Log(("vmmdevIPort_CpuHotUnplug: idCpuCore=%u idCpuPackage=%u\n", idCpuCore, idCpuPackage));
    38903903
    3891     PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_IGNORED);
     3904    int rc = PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_IGNORED);
     3905    AssertRCReturn(rc, rc);
    38923906
    38933907    if (pThis->fCpuHotPlugEventsEnabled)
    … …  
    39133927    PPDMDEVINS  pDevIns = pThisCC->pDevIns;
    39143928    PVMMDEV     pThis   = PDMDEVINS_2_DATA(pDevIns, PVMMDEV);
    3915     int         rc      = VINF_SUCCESS;
    39163929
    39173930    Log(("vmmdevCpuPlug: idCpuCore=%u idCpuPackage=%u\n", idCpuCore, idCpuPackage));
    39183931
    3919     PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_IGNORED);
     3932    int rc = PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_IGNORED);
     3933    AssertRCReturn(rc, rc);
    39203934
    39213935    if (pThis->fCpuHotPlugEventsEnabled)
    … …  
    39613975    PVMMDEVCC       pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PVMMDEVCC);
    39623976    PCPDMDEVHLPR3   pHlp    = pDevIns->pHlpR3;
    3963     PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_IGNORED);
     3977    int rc = PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_IGNORED);
     3978    AssertRCReturn(rc, rc);
    39643979
    39653980    vmmdevLiveExec(pDevIns, pSSM, SSM_PASS_FINAL);
    … …  
    42444259    PVMMDEV   pThis   = PDMDEVINS_2_DATA(pDevIns, PVMMDEV);
    42454260    PVMMDEVCC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PVMMDEVCC);
    4246     PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_IGNORED);
     4261    int const rcLock  = PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_IGNORED);
     4262    PDM_CRITSECT_RELEASE_ASSERT_RC_DEV(pDevIns, &pThis->CritSect, rcLock);
    42474263
    42484264    /*

  • trunk/src/VBox/Devices/VMMDev/VMMDevHGCM.cpp

    r90266 r90447  
    473473        AssertStmt(idx < RT_ELEMENTS(pThisCC->aHgcmAcc), idx %= RT_ELEMENTS(pThisCC->aHgcmAcc));
    474474
    475         PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_IGNORED);
     475        int const rcLock = PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_IGNORED);
     476        PDM_CRITSECT_RELEASE_ASSERT_RC_DEV(pDevIns, &pThis->CritSect, rcLock);
    476477
    477478        Log5Func(("aHgcmAcc[%zu] %#RX64 += %#x (%p)\n", idx, pThisCC->aHgcmAcc[idx].cbHeapBudget, pCmd->cbHeapCost, pCmd));

  • trunk/src/VBox/Devices/VirtIO/Virtio.cpp

    r82968 r90447  
    931931    PDMDevHlpSTAMRegister(pDevIns, &pThis->StatIOWriteR0,   STAMTYPE_PROFILE, "IO/WriteR0",         STAMUNIT_TICKS_PER_CALL, "Profiling IO writes in R0");
    932932    PDMDevHlpSTAMRegister(pDevIns, &pThis->StatIOWriteRC,   STAMTYPE_PROFILE, "IO/WriteRC",         STAMUNIT_TICKS_PER_CALL, "Profiling IO writes in RC");
    933     PDMDevHlpSTAMRegister(pDevIns, &pThis->StatCsR3,        STAMTYPE_PROFILE, "Cs/CsR3",            STAMUNIT_TICKS_PER_CALL, "Profiling CS wait in R3");
    934     PDMDevHlpSTAMRegister(pDevIns, &pThis->StatCsR0,        STAMTYPE_PROFILE, "Cs/CsR0",            STAMUNIT_TICKS_PER_CALL, "Profiling CS wait in R0");
    935     PDMDevHlpSTAMRegister(pDevIns, &pThis->StatCsRC,        STAMTYPE_PROFILE, "Cs/CsRC",            STAMUNIT_TICKS_PER_CALL, "Profiling CS wait in RC");
    936933# endif /* VBOX_WITH_STATISTICS */
    937934

  • trunk/src/VBox/Devices/VirtIO/Virtio.h

    r85121 r90447  
    218218    STAMPROFILEADV          StatIOWriteR0;
    219219    STAMPROFILEADV          StatIOWriteRC;
    220     STAMPROFILE             StatCsR3;
    221     STAMPROFILE             StatCsR0;
    222     STAMPROFILE             StatCsRC;
    223220#endif
    224221} VPCISTATE;
    … …  
    298295
    299296#define VPCI_CS
     297
     298#ifdef VPCI_CS
     299# define VPCI_R3_CS_ENTER_RETURN_VOID(a_pDevIns, a_pThis) do { \
     300        int const rcLock = PDMDevHlpCritSectEnter(pDevIns, &(a_pThis)->cs, VERR_IGNORED); \
     301        PDM_CRITSECT_RELEASE_ASSERT_RC_DEV(pDevIns, &(a_pThis)->cs, rcLock); \
     302    } while (0)
     303#else
     304# define VPCI_R3_CS_ENTER_RETURN_VOID(a_pDevIns, a_pThis) do { } while (0)
     305#endif
     306
    300307DECLINLINE(int) vpciCsEnter(PPDMDEVINS pDevIns, PVPCISTATE pThis, int rcBusy)
    301308{
    302309#ifdef VPCI_CS
    303     STAM_PROFILE_START(&pThis->CTX_SUFF(StatCs), a);
    304     int rc = PDMDevHlpCritSectEnter(pDevIns, &pThis->cs, rcBusy);
    305     STAM_PROFILE_STOP(&pThis->CTX_SUFF(StatCs), a);
    306     return rc;
     310    return PDMDevHlpCritSectEnter(pDevIns, &pThis->cs, rcBusy);
    307311#else
    308312    RT_NOREF(pDevIns, pThis, rcBusy);

  • trunk/src/VBox/ExtPacks/BusMouseSample/DevBusMouse.cpp

    r87773 r90447  
    574574    PBMSSTATE   pThis   = PDMDEVINS_2_DATA(pDevIns, PBMSSTATE);
    575575    int rc = PDMDevHlpCritSectEnter(pDevIns, pDevIns->CTX_SUFF(pCritSectRo), VERR_SEM_BUSY);
    576     AssertReleaseRC(rc);
     576    PDM_CRITSECT_RELEASE_ASSERT_RC_DEV(pDevIns, pDevIns->CTX_SUFF(pCritSectRo), rc);
    577577
    578578    bmsR3MouseEvent(pThis, dx, dy, dz, dw, fButtons);
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