VirtualBox

Changeset 90347 in vbox


Ignore:
Timestamp:
Jul 26, 2021 8:36:28 PM (4 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
145911
Message:

VMM: Pass pVM to PDMCritSectRw APIs. bugref:9218 bugref:10074

Location:
trunk
Files:
9 edited

Legend:

Unmodified
Added
Removed

  • trunk/include/VBox/vmm/pdmcritsectrw.h

    r82968 r90347  
    5656VMMR3DECL(int)      PDMR3CritSectRwInit(PVM pVM, PPDMCRITSECTRW pCritSect, RT_SRC_POS_DECL,
    5757                                        const char *pszNameFmt, ...) RT_IPRT_FORMAT_ATTR(6, 7);
    58 VMMR3DECL(int)      PDMR3CritSectRwDelete(PPDMCRITSECTRW pCritSect);
     58VMMR3DECL(int)      PDMR3CritSectRwDelete(PVM pVM, PPDMCRITSECTRW pCritSect);
    5959VMMR3DECL(const char *) PDMR3CritSectRwName(PCPDMCRITSECTRW pCritSect);
    60 VMMR3DECL(int)      PDMR3CritSectRwEnterSharedEx(PPDMCRITSECTRW pThis, bool fCallRing3);
    61 VMMR3DECL(int)      PDMR3CritSectRwEnterExclEx(PPDMCRITSECTRW pThis, bool fCallRing3);
     60VMMR3DECL(int)      PDMR3CritSectRwEnterSharedEx(PVM pVM, PPDMCRITSECTRW pThis, bool fCallRing3);
     61VMMR3DECL(int)      PDMR3CritSectRwEnterExclEx(PVM pVM, PPDMCRITSECTRW pThis, bool fCallRing3);
    6262
    63 VMMDECL(int)        PDMCritSectRwEnterShared(PPDMCRITSECTRW pCritSect, int rcBusy);
    64 VMMDECL(int)        PDMCritSectRwEnterSharedDebug(PPDMCRITSECTRW pCritSect, int rcBusy, RTHCUINTPTR uId, RT_SRC_POS_DECL);
    65 VMMDECL(int)        PDMCritSectRwTryEnterShared(PPDMCRITSECTRW pCritSect);
     63VMMDECL(int)        PDMCritSectRwEnterShared(PVMCC pVM, PPDMCRITSECTRW pCritSect, int rcBusy);
     64VMMDECL(int)        PDMCritSectRwEnterSharedDebug(PVMCC pVM, PPDMCRITSECTRW pCritSect, int rcBusy, RTHCUINTPTR uId, RT_SRC_POS_DECL);
     65VMMDECL(int)        PDMCritSectRwTryEnterShared(PVMCC pVM, PPDMCRITSECTRW pCritSect);
    6666VMMDECL(int)        PDMCritSectRwTryEnterSharedDebug(PPDMCRITSECTRW pCritSect, RTHCUINTPTR uId, RT_SRC_POS_DECL);
    67 VMMDECL(int)        PDMCritSectRwLeaveShared(PPDMCRITSECTRW pCritSect);
    68 VMMDECL(int)        PDMCritSectRwEnterExcl(PPDMCRITSECTRW pCritSect, int rcBusy);
    69 VMMDECL(int)        PDMCritSectRwEnterExclDebug(PPDMCRITSECTRW pCritSect, int rcBusy, RTHCUINTPTR uId, RT_SRC_POS_DECL);
    70 VMMDECL(int)        PDMCritSectRwTryEnterExcl(PPDMCRITSECTRW pCritSect);
    71 VMMDECL(int)        PDMCritSectRwTryEnterExclDebug(PPDMCRITSECTRW pCritSect, RTHCUINTPTR uId, RT_SRC_POS_DECL);
    72 VMMDECL(int)        PDMCritSectRwLeaveExcl(PPDMCRITSECTRW pCritSect);
     67VMMDECL(int)        PDMCritSectRwLeaveShared(PVMCC pVM, PPDMCRITSECTRW pCritSect);
     68VMMDECL(int)        PDMCritSectRwEnterExcl(PVMCC pVM, PPDMCRITSECTRW pCritSect, int rcBusy);
     69VMMDECL(int)        PDMCritSectRwEnterExclDebug(PVMCC pVM, PPDMCRITSECTRW pCritSect, int rcBusy, RTHCUINTPTR uId, RT_SRC_POS_DECL);
     70VMMDECL(int)        PDMCritSectRwTryEnterExcl(PVMCC pVM, PPDMCRITSECTRW pCritSect);
     71VMMDECL(int)        PDMCritSectRwTryEnterExclDebug(PVMCC pVM, PPDMCRITSECTRW pCritSect, RTHCUINTPTR uId, RT_SRC_POS_DECL);
     72VMMDECL(int)        PDMCritSectRwLeaveExcl(PVMCC pVM, PPDMCRITSECTRW pCritSect);
    7373
    74 VMMDECL(bool)       PDMCritSectRwIsWriteOwner(PPDMCRITSECTRW pCritSect);
    75 VMMDECL(bool)       PDMCritSectRwIsReadOwner(PPDMCRITSECTRW pCritSect, bool fWannaHear);
     74VMMDECL(bool)       PDMCritSectRwIsWriteOwner(PVMCC pVM, PPDMCRITSECTRW pCritSect);
     75VMMDECL(bool)       PDMCritSectRwIsReadOwner(PVMCC pVM, PPDMCRITSECTRW pCritSect, bool fWannaHear);
    7676VMMDECL(uint32_t)   PDMCritSectRwGetWriteRecursion(PPDMCRITSECTRW pCritSect);
    7777VMMDECL(uint32_t)   PDMCritSectRwGetWriterReadRecursion(PPDMCRITSECTRW pCritSect);
    … …  
    8282#ifdef VBOX_STRICT
    8383# ifdef IPRT_INCLUDED_asm_h
    84 #  define PDMCritSectRwEnterExcl(pCritSect, rcBusy)     PDMCritSectRwEnterExclDebug(pCritSect, rcBusy, (uintptr_t)ASMReturnAddress(), RT_SRC_POS)
    85 #  define PDMCritSectRwTryEnterExcl(pCritSect)          PDMCritSectRwTryEnterExclDebug(pCritSect, (uintptr_t)ASMReturnAddress(), RT_SRC_POS)
    86 #  define PDMCritSectRwEnterShared(pCritSect, rcBusy)   PDMCritSectRwEnterSharedDebug(pCritSect, rcBusy, (uintptr_t)ASMReturnAddress(), RT_SRC_POS)
    87 #  define PDMCritSectRwTryEnterShared(pCritSect)        PDMCritSectRwTryEnterSharedDebug(pCritSect, (uintptr_t)ASMReturnAddress(), RT_SRC_POS)
     84#  define PDMCritSectRwEnterExcl(a_pVM, pCritSect, rcBusy)      PDMCritSectRwEnterExclDebug((a_pVM), pCritSect, rcBusy, (uintptr_t)ASMReturnAddress(), RT_SRC_POS)
     85#  define PDMCritSectRwTryEnterExcl(a_pVM, pCritSect)           PDMCritSectRwTryEnterExclDebug((a_pVM), pCritSect, (uintptr_t)ASMReturnAddress(), RT_SRC_POS)
     86#  define PDMCritSectRwEnterShared(a_pVM, pCritSect, rcBusy)    PDMCritSectRwEnterSharedDebug((a_pVM), pCritSect, rcBusy, (uintptr_t)ASMReturnAddress(), RT_SRC_POS)
     87#  define PDMCritSectRwTryEnterShared(a_pVM, pCritSect)         PDMCritSectRwTryEnterSharedDebug((a_pVM), pCritSect, (uintptr_t)ASMReturnAddress(), RT_SRC_POS)
    8888# else
    89 #  define PDMCritSectRwEnterExcl(pCritSect, rcBusy)     PDMCritSectRwEnterExclDebug(pCritSect, rcBusy, 0, RT_SRC_POS)
    90 #  define PDMCritSectRwTryEnterExcl(pCritSect)          PDMCritSectRwTryEnterExclDebug(pCritSect, 0, RT_SRC_POS)
    91 #  define PDMCritSectRwEnterShared(pCritSect, rcBusy)   PDMCritSectRwEnterSharedDebug(pCritSect, rcBusy, 0, RT_SRC_POS)
    92 #  define PDMCritSectRwTryEnterShared(pCritSect)        PDMCritSectRwTryEnterSharedDebug(pCritSect, 0, RT_SRC_POS)
     89#  define PDMCritSectRwEnterExcl(a_pVM, pCritSect, rcBusy)      PDMCritSectRwEnterExclDebug((a_pVM), pCritSect, rcBusy, 0, RT_SRC_POS)
     90#  define PDMCritSectRwTryEnterExcl(a_pVM, pCritSect)           PDMCritSectRwTryEnterExclDebug((a_pVM), pCritSect, 0, RT_SRC_POS)
     91#  define PDMCritSectRwEnterShared(a_pVM, pCritSect, rcBusy)    PDMCritSectRwEnterSharedDebug((a_pVM), pCritSect, rcBusy, 0, RT_SRC_POS)
     92#  define PDMCritSectRwTryEnterShared(a_pVM, pCritSect)         PDMCritSectRwTryEnterSharedDebug((a_pVM), pCritSect, 0, RT_SRC_POS)
    9393# endif
    9494#endif

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

    r90346 r90347  
    5858# endif
    5959
    60         pdmCritSectRwLeaveSharedQueued(pCritSectRw);
     60        pdmCritSectRwLeaveSharedQueued(pVM, pCritSectRw);
    6161        LogFlow(("PDMR3CritSectFF: %p (R/W)\n", pCritSectRw));
    6262    }
    … …  
    7474# endif
    7575
    76         pdmCritSectRwLeaveExclQueued(pCritSectRw);
     76        pdmCritSectRwLeaveExclQueued(pVM, pCritSectRw);
    7777        LogFlow(("PDMR3CritSectFF: %p (R/W)\n", pCritSectRw));
    7878    }

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

    r82968 r90347  
    7474 *                      R0 and RC.
    7575 */
    76 DECL_FORCE_INLINE(RTNATIVETHREAD) pdmCritSectRwGetNativeSelf(PCPDMCRITSECTRW pThis)
     76DECL_FORCE_INLINE(RTNATIVETHREAD) pdmCritSectRwGetNativeSelf(PVMCC pVM, PCPDMCRITSECTRW pThis)
    7777{
    7878#ifdef IN_RING3
    79     NOREF(pThis);
     79    RT_NOREF(pVM, pThis);
    8080    RTNATIVETHREAD  hNativeSelf = RTThreadNativeSelf();
    8181#else
    8282    AssertMsgReturn(pThis->s.Core.u32Magic == RTCRITSECTRW_MAGIC, ("%RX32\n", pThis->s.Core.u32Magic),
    8383                    NIL_RTNATIVETHREAD);
    84     PVMCC           pVM         = pThis->s.CTX_SUFF(pVM);   AssertPtr(pVM);
    85     PVMCPUCC        pVCpu       = VMMGetCpu(pVM);           AssertPtr(pVCpu);
    86     RTNATIVETHREAD  hNativeSelf = pVCpu->hNativeThread;     Assert(hNativeSelf != NIL_RTNATIVETHREAD);
     84    PVMCPUCC        pVCpu       = VMMGetCpu(pVM); AssertPtr(pVCpu);
     85    RTNATIVETHREAD  hNativeSelf = pVCpu ? pVCpu->hNativeThread : NIL_RTNATIVETHREAD;
     86    Assert(hNativeSelf != NIL_RTNATIVETHREAD);
    8787#endif
    8888    return hNativeSelf;
    … …  
    143143 *
    144144 * @returns VBox status code.
     145 * @param   pVM         The cross context VM structure.
    145146 * @param   pThis       Pointer to the read/write critical section.
    146147 * @param   rcBusy      The busy return code for ring-0 and ring-3.
    … …  
    149150 * @param   fNoVal      No validation records.
    150151 */
    151 static int pdmCritSectRwEnterShared(PPDMCRITSECTRW pThis, int rcBusy, bool fTryOnly, PCRTLOCKVALSRCPOS pSrcPos, bool fNoVal)
     152static int pdmCritSectRwEnterShared(PVMCC pVM, PPDMCRITSECTRW pThis, int rcBusy, bool fTryOnly,
     153                                    PCRTLOCKVALSRCPOS pSrcPos, bool fNoVal)
    152154{
    153155    /*
    … …  
    156158    AssertPtr(pThis);
    157159    AssertReturn(pThis->s.Core.u32Magic == RTCRITSECTRW_MAGIC, VERR_SEM_DESTROYED);
     160    Assert(pThis->s.CTX_SUFF(pVM) == pVM);
    158161
    159162#if !defined(PDMCRITSECTRW_STRICT) || !defined(IN_RING3)
    … …  
    163166#ifdef IN_RING3
    164167    NOREF(rcBusy);
     168    NOREF(pVM);
    165169#endif
    166170
    … …  
    172176        RTNATIVETHREAD hNativeWriter;
    173177        ASMAtomicUoReadHandle(&pThis->s.Core.hNativeWriter, &hNativeWriter);
    174         if (hNativeWriter != NIL_RTTHREAD && hNativeWriter == pdmCritSectRwGetNativeSelf(pThis))
     178        if (hNativeWriter != NIL_RTTHREAD && hNativeWriter == pdmCritSectRwGetNativeSelf(pVM, pThis))
    175179            rc9 = RTLockValidatorRecExclCheckOrder(pThis->s.Core.pValidatorWrite, hThreadSelf, pSrcPos, RT_INDEFINITE_WAIT);
    176180        else
    … …  
    224228        {
    225229            /* Is the writer perhaps doing a read recursion? */
    226             RTNATIVETHREAD hNativeSelf = pdmCritSectRwGetNativeSelf(pThis);
     230            RTNATIVETHREAD hNativeSelf = pdmCritSectRwGetNativeSelf(pVM, pThis);
    227231            RTNATIVETHREAD hNativeWriter;
    228232            ASMAtomicUoReadHandle(&pThis->s.Core.hNativeWriter, &hNativeWriter);
    … …  
    291295                            for (;;)
    292296                            {
    293                                 rc = SUPSemEventMultiWaitNoResume(pThis->s.CTX_SUFF(pVM)->pSession,
     297                                rc = SUPSemEventMultiWaitNoResume(pVM->pSession,
    294298                                                                  (SUPSEMEVENTMULTI)pThis->s.Core.hEvtRead,
    295299                                                                  RT_INDEFINITE_WAIT);
    … …  
    349353                                if (ASMAtomicXchgBool(&pThis->s.Core.fNeedReset, false))
    350354                                {
    351                                     int rc = SUPSemEventMultiReset(pThis->s.CTX_SUFF(pVM)->pSession,
    352                                                                    (SUPSEMEVENTMULTI)pThis->s.Core.hEvtRead);
     355                                    int rc = SUPSemEventMultiReset(pVM->pSession, (SUPSEMEVENTMULTI)pThis->s.Core.hEvtRead);
    353356                                    AssertRCReturn(rc, rc);
    354357                                }
    … …  
    379382                if (rcBusy == VINF_SUCCESS)
    380383                {
    381                     PVMCC     pVM   = pThis->s.CTX_SUFF(pVM);     AssertPtr(pVM);
    382                     PVMCPUCC  pVCpu = VMMGetCpu(pVM);             AssertPtr(pVCpu);
     384                    PVMCPUCC  pVCpu = VMMGetCpu(pVM); AssertPtr(pVCpu);
    383385                    /** @todo Should actually do this in via VMMR0.cpp instead of going all the way
    384386                     *        back to ring-3. Goes for both kind of crit sects. */
    … …  
    416418 *          during the operation.
    417419 *
     420 * @param   pVM         The cross context VM structure.
    418421 * @param   pThis       Pointer to the read/write critical section.
    419422 * @param   rcBusy      The status code to return when we're in RC or R0 and the
    … …  
    424427 *          RTCritSectRwEnterShared.
    425428 */
    426 VMMDECL(int) PDMCritSectRwEnterShared(PPDMCRITSECTRW pThis, int rcBusy)
     429VMMDECL(int) PDMCritSectRwEnterShared(PVMCC pVM, PPDMCRITSECTRW pThis, int rcBusy)
    427430{
    428431#if !defined(PDMCRITSECTRW_STRICT) || !defined(IN_RING3)
    429     return pdmCritSectRwEnterShared(pThis, rcBusy, false /*fTryOnly*/, NULL,    false /*fNoVal*/);
     432    return pdmCritSectRwEnterShared(pVM, pThis, rcBusy, false /*fTryOnly*/, NULL,    false /*fNoVal*/);
    430433#else
    431434    RTLOCKVALSRCPOS SrcPos = RTLOCKVALSRCPOS_INIT_NORMAL_API();
    432     return pdmCritSectRwEnterShared(pThis, rcBusy, false /*fTryOnly*/, &SrcPos, false /*fNoVal*/);
     435    return pdmCritSectRwEnterShared(pVM, pThis, rcBusy, false /*fTryOnly*/, &SrcPos, false /*fNoVal*/);
    433436#endif
    434437}
    … …  
    445448 *          during the operation.
    446449 *
     450 * @param   pVM         The cross context VM structure.
    447451 * @param   pThis       Pointer to the read/write critical section.
    448452 * @param   rcBusy      The status code to return when we're in RC or R0 and the
    … …  
    455459 *          RTCritSectRwEnterSharedDebug.
    456460 */
    457 VMMDECL(int) PDMCritSectRwEnterSharedDebug(PPDMCRITSECTRW pThis, int rcBusy, RTHCUINTPTR uId, RT_SRC_POS_DECL)
     461VMMDECL(int) PDMCritSectRwEnterSharedDebug(PVMCC pVM, PPDMCRITSECTRW pThis, int rcBusy, RTHCUINTPTR uId, RT_SRC_POS_DECL)
    458462{
    459463    NOREF(uId); NOREF(pszFile); NOREF(iLine); NOREF(pszFunction);
    460464#if !defined(PDMCRITSECTRW_STRICT) || !defined(IN_RING3)
    461     return pdmCritSectRwEnterShared(pThis, rcBusy, false /*fTryOnly*/, NULL,    false /*fNoVal*/);
     465    return pdmCritSectRwEnterShared(pVM, pThis, rcBusy, false /*fTryOnly*/, NULL,    false /*fNoVal*/);
    462466#else
    463467    RTLOCKVALSRCPOS SrcPos = RTLOCKVALSRCPOS_INIT_DEBUG_API();
    464     return pdmCritSectRwEnterShared(pThis, rcBusy, false /*fTryOnly*/, &SrcPos, false /*fNoVal*/);
     468    return pdmCritSectRwEnterShared(pVM, pThis, rcBusy, false /*fTryOnly*/, &SrcPos, false /*fNoVal*/);
    465469#endif
    466470}
    … …  
    477481 *          during the operation.
    478482 *
     483 * @param   pVM         The cross context VM structure.
    479484 * @param   pThis       Pointer to the read/write critical section.
    480485 * @sa      PDMCritSectRwTryEnterSharedDebug, PDMCritSectRwEnterShared,
    … …  
    482487 *          RTCritSectRwTryEnterShared.
    483488 */
    484 VMMDECL(int) PDMCritSectRwTryEnterShared(PPDMCRITSECTRW pThis)
     489VMMDECL(int) PDMCritSectRwTryEnterShared(PVMCC pVM, PPDMCRITSECTRW pThis)
    485490{
    486491#if !defined(PDMCRITSECTRW_STRICT) || !defined(IN_RING3)
    487     return pdmCritSectRwEnterShared(pThis, VERR_SEM_BUSY, true /*fTryOnly*/, NULL,    false /*fNoVal*/);
     492    return pdmCritSectRwEnterShared(pVM, pThis, VERR_SEM_BUSY, true /*fTryOnly*/, NULL,    false /*fNoVal*/);
    488493#else
    489494    RTLOCKVALSRCPOS SrcPos = RTLOCKVALSRCPOS_INIT_NORMAL_API();
    490     return pdmCritSectRwEnterShared(pThis, VERR_SEM_BUSY, true /*fTryOnly*/, &SrcPos, false /*fNoVal*/);
     495    return pdmCritSectRwEnterShared(pVM, pThis, VERR_SEM_BUSY, true /*fTryOnly*/, &SrcPos, false /*fNoVal*/);
    491496#endif
    492497}
    … …  
    503508 *          during the operation.
    504509 *
     510 * @param   pVM         The cross context VM structure.
    505511 * @param   pThis       Pointer to the read/write critical section.
    506512 * @param   uId         Where we're entering the section.
    … …  
    510516 *          RTCritSectRwTryEnterSharedDebug.
    511517 */
    512 VMMDECL(int) PDMCritSectRwTryEnterSharedDebug(PPDMCRITSECTRW pThis, RTHCUINTPTR uId, RT_SRC_POS_DECL)
     518VMMDECL(int) PDMCritSectRwTryEnterSharedDebug(PVMCC pVM, PPDMCRITSECTRW pThis, RTHCUINTPTR uId, RT_SRC_POS_DECL)
    513519{
    514520    NOREF(uId); NOREF(pszFile); NOREF(iLine); NOREF(pszFunction);
    515521#if !defined(PDMCRITSECTRW_STRICT) || !defined(IN_RING3)
    516     return pdmCritSectRwEnterShared(pThis, VERR_SEM_BUSY, true /*fTryOnly*/, NULL,    false /*fNoVal*/);
     522    return pdmCritSectRwEnterShared(pVM, pThis, VERR_SEM_BUSY, true /*fTryOnly*/, NULL,    false /*fNoVal*/);
    517523#else
    518524    RTLOCKVALSRCPOS SrcPos = RTLOCKVALSRCPOS_INIT_DEBUG_API();
    519     return pdmCritSectRwEnterShared(pThis, VERR_SEM_BUSY, true /*fTryOnly*/, &SrcPos, false /*fNoVal*/);
     525    return pdmCritSectRwEnterShared(pVM, pThis, VERR_SEM_BUSY, true /*fTryOnly*/, &SrcPos, false /*fNoVal*/);
    520526#endif
    521527}
    … …  
    530536 *          during the operation.
    531537 *
     538 * @param   pVM         The cross context VM structure.
    532539 * @param   pThis       Pointer to the read/write critical section.
    533540 * @param   fCallRing3  Whether this is a VMMRZCallRing3()request.
    534541 */
    535 VMMR3DECL(int) PDMR3CritSectRwEnterSharedEx(PPDMCRITSECTRW pThis, bool fCallRing3)
    536 {
    537     return pdmCritSectRwEnterShared(pThis, VERR_SEM_BUSY, false /*fTryAgain*/, NULL, fCallRing3);
     542VMMR3DECL(int) PDMR3CritSectRwEnterSharedEx(PVM pVM, PPDMCRITSECTRW pThis, bool fCallRing3)
     543{
     544    return pdmCritSectRwEnterShared(pVM, pThis, VERR_SEM_BUSY, false /*fTryAgain*/, NULL, fCallRing3);
    538545}
    539546#endif
    … …  
    546553 * @retval  VERR_SEM_DESTROYED if the critical section is delete before or
    547554 *          during the operation.
     555 * @param   pVM         The cross context VM structure.
    548556 * @param   pThis       Pointer to the read/write critical section.
    549557 * @param   fNoVal      No validation records (i.e. queued release).
    … …  
    552560 *          PDMCritSectRwLeaveExcl, RTCritSectRwLeaveShared.
    553561 */
    554 static int pdmCritSectRwLeaveSharedWorker(PPDMCRITSECTRW pThis, bool fNoVal)
     562static int pdmCritSectRwLeaveSharedWorker(PVMCC pVM, PPDMCRITSECTRW pThis, bool fNoVal)
    555563{
    556564    /*
    … …  
    559567    AssertPtr(pThis);
    560568    AssertReturn(pThis->s.Core.u32Magic == RTCRITSECTRW_MAGIC, VERR_SEM_DESTROYED);
     569    Assert(pThis->s.CTX_SUFF(pVM) == pVM);
    561570
    562571#if !defined(PDMCRITSECTRW_STRICT) || !defined(IN_RING3)
    … …  
    609618                    if (ASMAtomicCmpXchgU64(&pThis->s.Core.u64State, u64State, u64OldState))
    610619                    {
    611                         int rc = SUPSemEventSignal(pThis->s.CTX_SUFF(pVM)->pSession, (SUPSEMEVENT)pThis->s.Core.hEvtWrite);
     620                        int rc = SUPSemEventSignal(pVM->pSession, (SUPSEMEVENT)pThis->s.Core.hEvtWrite);
    612621                        AssertRC(rc);
    613622                        break;
    … …  
    621630                {
    622631                    /* Queue the exit request (ring-3). */
    623                     PVMCC       pVM   = pThis->s.CTX_SUFF(pVM);         AssertPtr(pVM);
    624632                    PVMCPUCC    pVCpu = VMMGetCpu(pVM);                 AssertPtr(pVCpu);
    625633                    uint32_t    i     = pVCpu->pdm.s.cQueuedCritSectRwShrdLeaves++;
    … …  
    643651    else
    644652    {
    645         RTNATIVETHREAD hNativeSelf = pdmCritSectRwGetNativeSelf(pThis);
     653        RTNATIVETHREAD hNativeSelf = pdmCritSectRwGetNativeSelf(pVM, pThis);
    646654        RTNATIVETHREAD hNativeWriter;
    647655        ASMAtomicUoReadHandle(&pThis->s.Core.hNativeWriter, &hNativeWriter);
    … …  
    668676 * @retval  VERR_SEM_DESTROYED if the critical section is delete before or
    669677 *          during the operation.
     678 * @param   pVM         The cross context VM structure.
    670679 * @param   pThis       Pointer to the read/write critical section.
    671680 * @sa      PDMCritSectRwEnterShared, PDMCritSectRwTryEnterShared,
    … …  
    673682 *          PDMCritSectRwLeaveExcl, RTCritSectRwLeaveShared.
    674683 */
    675 VMMDECL(int) PDMCritSectRwLeaveShared(PPDMCRITSECTRW pThis)
    676 {
    677     return pdmCritSectRwLeaveSharedWorker(pThis, false /*fNoVal*/);
     684VMMDECL(int) PDMCritSectRwLeaveShared(PVMCC pVM, PPDMCRITSECTRW pThis)
     685{
     686    return pdmCritSectRwLeaveSharedWorker(pVM, pThis, false /*fNoVal*/);
    678687}
    679688
    … …  
    683692 * PDMCritSectBothFF interface.
    684693 *
    685  * @param   pThis       Pointer to the read/write critical section.
    686  */
    687 void pdmCritSectRwLeaveSharedQueued(PPDMCRITSECTRW pThis)
    688 {
    689     pdmCritSectRwLeaveSharedWorker(pThis, true /*fNoVal*/);
     694 * @param   pVM         The cross context VM structure.
     695 * @param   pThis       Pointer to the read/write critical section.
     696 */
     697void pdmCritSectRwLeaveSharedQueued(PVMCC pVM, PPDMCRITSECTRW pThis)
     698{
     699    pdmCritSectRwLeaveSharedWorker(pVM, pThis, true /*fNoVal*/);
    690700}
    691701#endif
    … …  
    696706 *
    697707 * @returns VBox status code.
     708 * @param   pVM         The cross context VM structure.
    698709 * @param   pThis       Pointer to the read/write critical section.
    699710 * @param   rcBusy      The busy return code for ring-0 and ring-3.
    … …  
    702713 * @param   fNoVal      No validation records.
    703714 */
    704 static int pdmCritSectRwEnterExcl(PPDMCRITSECTRW pThis, int rcBusy, bool fTryOnly, PCRTLOCKVALSRCPOS pSrcPos, bool fNoVal)
     715static int pdmCritSectRwEnterExcl(PVMCC pVM, PPDMCRITSECTRW pThis, int rcBusy, bool fTryOnly,
     716                                  PCRTLOCKVALSRCPOS pSrcPos, bool fNoVal)
    705717{
    706718    /*
    … …  
    709721    AssertPtr(pThis);
    710722    AssertReturn(pThis->s.Core.u32Magic == RTCRITSECTRW_MAGIC, VERR_SEM_DESTROYED);
     723    Assert(pThis->s.CTX_SUFF(pVM) == pVM);
    711724
    712725#if !defined(PDMCRITSECTRW_STRICT) || !defined(IN_RING3)
    … …  
    716729#ifdef IN_RING3
    717730    NOREF(rcBusy);
     731    NOREF(pVM);
    718732#endif
    719733
    … …  
    732746     * Check if we're already the owner and just recursing.
    733747     */
    734     RTNATIVETHREAD hNativeSelf = pdmCritSectRwGetNativeSelf(pThis);
     748    RTNATIVETHREAD hNativeSelf = pdmCritSectRwGetNativeSelf(pVM, pThis);
    735749    RTNATIVETHREAD hNativeWriter;
    736750    ASMAtomicUoReadHandle(&pThis->s.Core.hNativeWriter, &hNativeWriter);
    … …  
    852866                    for (;;)
    853867                    {
    854                         rc = SUPSemEventWaitNoResume(pThis->s.CTX_SUFF(pVM)->pSession,
     868                        rc = SUPSemEventWaitNoResume(pVM->pSession,
    855869                                                     (SUPSEMEVENT)pThis->s.Core.hEvtWrite,
    856870                                                     RT_INDEFINITE_WAIT);
    … …  
    922936            {
    923937                Assert(!fTryOnly);
    924                 PVMCC     pVM   = pThis->s.CTX_SUFF(pVM);     AssertPtr(pVM);
    925                 PVMCPUCC  pVCpu = VMMGetCpu(pVM);             AssertPtr(pVCpu);
     938                PVMCPUCC  pVCpu = VMMGetCpu(pVM); AssertPtr(pVCpu);
    926939                /** @todo Should actually do this in via VMMR0.cpp instead of going all the way
    927940                 *        back to ring-3. Goes for both kind of crit sects. */
    … …  
    960973 *          during the operation.
    961974 *
     975 * @param   pVM         The cross context VM structure.
    962976 * @param   pThis       Pointer to the read/write critical section.
    963977 * @param   rcBusy      The status code to return when we're in RC or R0 and the
    … …  
    969983 * RTCritSectRwEnterExcl.
    970984 */
    971 VMMDECL(int) PDMCritSectRwEnterExcl(PPDMCRITSECTRW pThis, int rcBusy)
     985VMMDECL(int) PDMCritSectRwEnterExcl(PVMCC pVM, PPDMCRITSECTRW pThis, int rcBusy)
    972986{
    973987#if !defined(PDMCRITSECTRW_STRICT) || !defined(IN_RING3)
    974     return pdmCritSectRwEnterExcl(pThis, rcBusy, false /*fTryAgain*/, NULL,    false /*fNoVal*/);
     988    return pdmCritSectRwEnterExcl(pVM, pThis, rcBusy, false /*fTryAgain*/, NULL,    false /*fNoVal*/);
    975989#else
    976990    RTLOCKVALSRCPOS SrcPos = RTLOCKVALSRCPOS_INIT_NORMAL_API();
    977     return pdmCritSectRwEnterExcl(pThis, rcBusy, false /*fTryAgain*/, &SrcPos, false /*fNoVal*/);
     991    return pdmCritSectRwEnterExcl(pVM, pThis, rcBusy, false /*fTryAgain*/, &SrcPos, false /*fNoVal*/);
    978992#endif
    979993}
    … …  
    9901004 *          during the operation.
    9911005 *
     1006 * @param   pVM         The cross context VM structure.
    9921007 * @param   pThis       Pointer to the read/write critical section.
    9931008 * @param   rcBusy      The status code to return when we're in RC or R0 and the
    … …  
    10011016 *          RTCritSectRwEnterExclDebug.
    10021017 */
    1003 VMMDECL(int) PDMCritSectRwEnterExclDebug(PPDMCRITSECTRW pThis, int rcBusy, RTHCUINTPTR uId, RT_SRC_POS_DECL)
     1018VMMDECL(int) PDMCritSectRwEnterExclDebug(PVMCC pVM, PPDMCRITSECTRW pThis, int rcBusy, RTHCUINTPTR uId, RT_SRC_POS_DECL)
    10041019{
    10051020    NOREF(uId); NOREF(pszFile); NOREF(iLine); NOREF(pszFunction);
    10061021#if !defined(PDMCRITSECTRW_STRICT) || !defined(IN_RING3)
    1007     return pdmCritSectRwEnterExcl(pThis, rcBusy, false /*fTryAgain*/, NULL,    false /*fNoVal*/);
     1022    return pdmCritSectRwEnterExcl(pVM, pThis, rcBusy, false /*fTryAgain*/, NULL,    false /*fNoVal*/);
    10081023#else
    10091024    RTLOCKVALSRCPOS SrcPos = RTLOCKVALSRCPOS_INIT_DEBUG_API();
    1010     return pdmCritSectRwEnterExcl(pThis, rcBusy, false /*fTryAgain*/, &SrcPos, false /*fNoVal*/);
     1025    return pdmCritSectRwEnterExcl(pVM, pThis, rcBusy, false /*fTryAgain*/, &SrcPos, false /*fNoVal*/);
    10111026#endif
    10121027}
    … …  
    10221037 *          during the operation.
    10231038 *
     1039 * @param   pVM         The cross context VM structure.
    10241040 * @param   pThis       Pointer to the read/write critical section.
    10251041 * @sa      PDMCritSectRwEnterExcl, PDMCritSectRwTryEnterExclDebug,
    … …  
    10281044 *          RTCritSectRwTryEnterExcl.
    10291045 */
    1030 VMMDECL(int) PDMCritSectRwTryEnterExcl(PPDMCRITSECTRW pThis)
     1046VMMDECL(int) PDMCritSectRwTryEnterExcl(PVMCC pVM, PPDMCRITSECTRW pThis)
    10311047{
    10321048#if !defined(PDMCRITSECTRW_STRICT) || !defined(IN_RING3)
    1033     return pdmCritSectRwEnterExcl(pThis, VERR_SEM_BUSY, true /*fTryAgain*/, NULL,    false /*fNoVal*/);
     1049    return pdmCritSectRwEnterExcl(pVM, pThis, VERR_SEM_BUSY, true /*fTryAgain*/, NULL,    false /*fNoVal*/);
    10341050#else
    10351051    RTLOCKVALSRCPOS SrcPos = RTLOCKVALSRCPOS_INIT_NORMAL_API();
    1036     return pdmCritSectRwEnterExcl(pThis, VERR_SEM_BUSY, true /*fTryAgain*/, &SrcPos, false /*fNoVal*/);
     1052    return pdmCritSectRwEnterExcl(pVM, pThis, VERR_SEM_BUSY, true /*fTryAgain*/, &SrcPos, false /*fNoVal*/);
    10371053#endif
    10381054}
    … …  
    10481064 *          during the operation.
    10491065 *
     1066 * @param   pVM         The cross context VM structure.
    10501067 * @param   pThis       Pointer to the read/write critical section.
    10511068 * @param   uId         Where we're entering the section.
    … …  
    10561073 *          RTCritSectRwTryEnterExclDebug.
    10571074 */
    1058 VMMDECL(int) PDMCritSectRwTryEnterExclDebug(PPDMCRITSECTRW pThis, RTHCUINTPTR uId, RT_SRC_POS_DECL)
     1075VMMDECL(int) PDMCritSectRwTryEnterExclDebug(PVMCC pVM, PPDMCRITSECTRW pThis, RTHCUINTPTR uId, RT_SRC_POS_DECL)
    10591076{
    10601077    NOREF(uId); NOREF(pszFile); NOREF(iLine); NOREF(pszFunction);
    10611078#if !defined(PDMCRITSECTRW_STRICT) || !defined(IN_RING3)
    1062     return pdmCritSectRwEnterExcl(pThis, VERR_SEM_BUSY, true /*fTryAgain*/, NULL,    false /*fNoVal*/);
     1079    return pdmCritSectRwEnterExcl(pVM, pThis, VERR_SEM_BUSY, true /*fTryAgain*/, NULL,    false /*fNoVal*/);
    10631080#else
    10641081    RTLOCKVALSRCPOS SrcPos = RTLOCKVALSRCPOS_INIT_DEBUG_API();
    1065     return pdmCritSectRwEnterExcl(pThis, VERR_SEM_BUSY, true /*fTryAgain*/, &SrcPos, false /*fNoVal*/);
     1082    return pdmCritSectRwEnterExcl(pVM, pThis, VERR_SEM_BUSY, true /*fTryAgain*/, &SrcPos, false /*fNoVal*/);
    10661083#endif
    10671084}
    … …  
    10761093 *          during the operation.
    10771094 *
     1095 * @param   pVM         The cross context VM structure.
    10781096 * @param   pThis       Pointer to the read/write critical section.
    10791097 * @param   fCallRing3  Whether this is a VMMRZCallRing3()request.
    10801098 */
    1081 VMMR3DECL(int) PDMR3CritSectRwEnterExclEx(PPDMCRITSECTRW pThis, bool fCallRing3)
    1082 {
    1083     return pdmCritSectRwEnterExcl(pThis, VERR_SEM_BUSY, false /*fTryAgain*/, NULL, fCallRing3 /*fNoVal*/);
     1099VMMR3DECL(int) PDMR3CritSectRwEnterExclEx(PVM pVM, PPDMCRITSECTRW pThis, bool fCallRing3)
     1100{
     1101    return pdmCritSectRwEnterExcl(pVM, pThis, VERR_SEM_BUSY, false /*fTryAgain*/, NULL, fCallRing3 /*fNoVal*/);
    10841102}
    10851103#endif /* IN_RING3 */
    … …  
    10921110 * @retval  VERR_SEM_DESTROYED if the critical section is delete before or
    10931111 *          during the operation.
     1112 * @param   pVM         The cross context VM structure.
    10941113 * @param   pThis       Pointer to the read/write critical section.
    10951114 * @param   fNoVal      No validation records (i.e. queued release).
    10961115 * @sa      PDMCritSectRwLeaveShared, RTCritSectRwLeaveExcl.
    10971116 */
    1098 static int pdmCritSectRwLeaveExclWorker(PPDMCRITSECTRW pThis, bool fNoVal)
     1117static int pdmCritSectRwLeaveExclWorker(PVMCC pVM, PPDMCRITSECTRW pThis, bool fNoVal)
    10991118{
    11001119    /*
    … …  
    11031122    AssertPtr(pThis);
    11041123    AssertReturn(pThis->s.Core.u32Magic == RTCRITSECTRW_MAGIC, VERR_SEM_DESTROYED);
     1124    Assert(pThis->s.CTX_SUFF(pVM) == pVM);
    11051125
    11061126#if !defined(PDMCRITSECTRW_STRICT) || !defined(IN_RING3)
    … …  
    11081128#endif
    11091129
    1110     RTNATIVETHREAD hNativeSelf = pdmCritSectRwGetNativeSelf(pThis);
     1130    RTNATIVETHREAD hNativeSelf = pdmCritSectRwGetNativeSelf(pVM, pThis);
    11111131    RTNATIVETHREAD hNativeWriter;
    11121132    ASMAtomicUoReadHandle(&pThis->s.Core.hNativeWriter, &hNativeWriter);
    … …  
    11611181                        if (c > 0)
    11621182                        {
    1163                             int rc = SUPSemEventSignal(pThis->s.CTX_SUFF(pVM)->pSession, (SUPSEMEVENT)pThis->s.Core.hEvtWrite);
     1183                            int rc = SUPSemEventSignal(pVM->pSession, (SUPSEMEVENT)pThis->s.Core.hEvtWrite);
    11641184                            AssertRC(rc);
    11651185                        }
    … …  
    11761196                        Assert(!pThis->s.Core.fNeedReset);
    11771197                        ASMAtomicWriteBool(&pThis->s.Core.fNeedReset, true);
    1178                         int rc = SUPSemEventMultiSignal(pThis->s.CTX_SUFF(pVM)->pSession, (SUPSEMEVENTMULTI)pThis->s.Core.hEvtRead);
     1198                        int rc = SUPSemEventMultiSignal(pVM->pSession, (SUPSEMEVENTMULTI)pThis->s.Core.hEvtRead);
    11791199                        AssertRC(rc);
    11801200                        break;
    … …  
    11971217             * so queue the exit request (ring-3).
    11981218             */
    1199             PVMCC       pVM   = pThis->s.CTX_SUFF(pVM);         AssertPtr(pVM);
    1200             PVMCPUCC    pVCpu = VMMGetCpu(pVM);                 AssertPtr(pVCpu);
     1219            PVMCPUCC    pVCpu = VMMGetCpu(pVM); AssertPtr(pVCpu);
    12011220            uint32_t    i     = pVCpu->pdm.s.cQueuedCritSectRwExclLeaves++;
    12021221            LogFlow(("PDMCritSectRwLeaveShared: [%d]=%p => R3\n", i, pThis));
    … …  
    12391258 * @retval  VERR_SEM_DESTROYED if the critical section is delete before or
    12401259 *          during the operation.
     1260 * @param   pVM         The cross context VM structure.
    12411261 * @param   pThis       Pointer to the read/write critical section.
    12421262 * @sa      PDMCritSectRwLeaveShared, RTCritSectRwLeaveExcl.
    12431263 */
    1244 VMMDECL(int) PDMCritSectRwLeaveExcl(PPDMCRITSECTRW pThis)
    1245 {
    1246     return pdmCritSectRwLeaveExclWorker(pThis, false /*fNoVal*/);
     1264VMMDECL(int) PDMCritSectRwLeaveExcl(PVMCC pVM, PPDMCRITSECTRW pThis)
     1265{
     1266    return pdmCritSectRwLeaveExclWorker(pVM, pThis, false /*fNoVal*/);
    12471267}
    12481268
    … …  
    12521272 * PDMCritSectBothFF interface.
    12531273 *
    1254  * @param   pThis       Pointer to the read/write critical section.
    1255  */
    1256 void pdmCritSectRwLeaveExclQueued(PPDMCRITSECTRW pThis)
    1257 {
    1258     pdmCritSectRwLeaveExclWorker(pThis, true /*fNoVal*/);
     1274 * @param   pVM         The cross context VM structure.
     1275 * @param   pThis       Pointer to the read/write critical section.
     1276 */
     1277void pdmCritSectRwLeaveExclQueued(PVMCC pVM, PPDMCRITSECTRW pThis)
     1278{
     1279    pdmCritSectRwLeaveExclWorker(pVM, pThis, true /*fNoVal*/);
    12591280}
    12601281#endif
    … …  
    12661287 * @retval  true if owner.
    12671288 * @retval  false if not owner.
     1289 * @param   pVM         The cross context VM structure.
    12681290 * @param   pThis       Pointer to the read/write critical section.
    12691291 * @sa      PDMCritSectRwIsReadOwner, PDMCritSectIsOwner,
    12701292 *          RTCritSectRwIsWriteOwner.
    12711293 */
    1272 VMMDECL(bool) PDMCritSectRwIsWriteOwner(PPDMCRITSECTRW pThis)
     1294VMMDECL(bool) PDMCritSectRwIsWriteOwner(PVMCC pVM, PPDMCRITSECTRW pThis)
    12731295{
    12741296    /*
    … …  
    12851307    if (hNativeWriter == NIL_RTNATIVETHREAD)
    12861308        return false;
    1287     return hNativeWriter == pdmCritSectRwGetNativeSelf(pThis);
     1309    return hNativeWriter == pdmCritSectRwGetNativeSelf(pVM, pThis);
    12881310}
    12891311
    … …  
    13031325 *
    13041326 * @returns @c true if reader, @c false if not.
     1327 * @param   pVM         The cross context VM structure.
    13051328 * @param   pThis       Pointer to the read/write critical section.
    13061329 * @param   fWannaHear  What you'd like to hear when lock validation is not
    … …  
    13081331 * @sa      PDMCritSectRwIsWriteOwner, RTCritSectRwIsReadOwner.
    13091332 */
    1310 VMMDECL(bool) PDMCritSectRwIsReadOwner(PPDMCRITSECTRW pThis, bool fWannaHear)
     1333VMMDECL(bool) PDMCritSectRwIsReadOwner(PVMCC pVM, PPDMCRITSECTRW pThis, bool fWannaHear)
    13111334{
    13121335    /*
    … …  
    13301353        if (hWriter == NIL_RTNATIVETHREAD)
    13311354            return false;
    1332         return hWriter == pdmCritSectRwGetNativeSelf(pThis);
     1355        return hWriter == pdmCritSectRwGetNativeSelf(pVM, pThis);
    13331356    }
    13341357

  • trunk/src/VBox/VMM/VMMR0/TMR0.cpp

    r87814 r90347  
    9797    PTMTIMERQUEUER0 pQueueR0     = &pGVM->tmr0.s.aTimerQueues[idxQueue];
    9898    PTMTIMERQUEUE   pQueueShared = &pGVM->tm.s.aTimerQueues[idxQueue];
    99     AssertMsgReturn(PDMCritSectRwIsWriteOwner(&pQueueShared->AllocLock),
     99    AssertMsgReturn(PDMCritSectRwIsWriteOwner(pGVM, &pQueueShared->AllocLock),
    100100                    ("queue=%s %.*Rhxs\n", pQueueShared->szName, sizeof(pQueueShared->AllocLock), &pQueueShared->AllocLock),
    101101                    VERR_NOT_OWNER);

  • trunk/src/VBox/VMM/VMMR3/PDMCritSect.cpp

    r90346 r90347  
    770770 *
    771771 * @returns VBox status code.
     772 * @param   pVM                 The cross context VM structure.
    772773 * @param   pCritSect           The PDM read/write critical section to destroy.
    773774 */
    774 VMMR3DECL(int) PDMR3CritSectRwDelete(PPDMCRITSECTRW pCritSect)
     775VMMR3DECL(int) PDMR3CritSectRwDelete(PVM pVM, PPDMCRITSECTRW pCritSect)
    775776{
    776777    if (!PDMCritSectRwIsInitialized(pCritSect))
    … …  
    780781     * Find and unlink it.
    781782     */
    782     PVM                 pVM   = pCritSect->s.pVMR3;
     783    Assert(pCritSect->s.pVMR3 == pVM);
    783784    PUVM                pUVM  = pVM->pUVM;
    784785    AssertReleaseReturn(pVM, VERR_PDM_CRITSECT_IPE);
    … …  
    10051006    {
    10061007        if (   pCur->Core.hNativeWriter == hNativeThread
    1007             || PDMCritSectRwIsReadOwner((PPDMCRITSECTRW)pCur, false /*fWannaHear*/) )
     1008            || PDMCritSectRwIsReadOwner(pVM, (PPDMCRITSECTRW)pCur, false /*fWannaHear*/) )
    10081009        {
    10091010            cCritSects++;

  • trunk/src/VBox/VMM/VMMR3/TM.cpp

    r90346 r90347  
    11341134        if (s_aExtra[i].cExtra > pQueue->cTimersFree)
    11351135        {
    1136             PDMCritSectRwEnterExcl(&pQueue->AllocLock, VERR_IGNORED);
     1136            PDMCritSectRwEnterExcl(pVM, &pQueue->AllocLock, VERR_IGNORED);
    11371137            uint32_t cTimersAlloc = pQueue->cTimersAlloc + s_aExtra[i].cExtra - pQueue->cTimersFree;
    11381138            rc = VMMR3CallR0Emt(pVM, VMMGetCpu(pVM), VMMR0_DO_TM_GROW_TIMER_QUEUE,
    11391139                                RT_MAKE_U64(cTimersAlloc, s_aExtra[i].idxQueue), NULL);
    11401140            AssertLogRelMsgReturn(RT_SUCCESS(rc), ("rc=%Rrc cTimersAlloc=%u %s\n", rc, cTimersAlloc, pQueue->szName), rc);
    1141             PDMCritSectRwLeaveExcl(&pQueue->AllocLock);
     1141            PDMCritSectRwLeaveExcl(pVM, &pQueue->AllocLock);
    11421142        }
    11431143    }
    … …  
    16171617     */
    16181618    PTMTIMERQUEUE pQueue = &pVM->tm.s.aTimerQueues[enmClock];
    1619     int rc = PDMCritSectRwEnterExcl(&pQueue->AllocLock, VERR_IGNORED);
     1619    int rc = PDMCritSectRwEnterExcl(pVM, &pQueue->AllocLock, VERR_IGNORED);
    16201620    AssertRCReturn(rc, rc);
    16211621
    … …  
    16301630        rc = VMMR3CallR0Emt(pVM, VMMGetCpu(pVM), VMMR0_DO_TM_GROW_TIMER_QUEUE,
    16311631                            RT_MAKE_U64(cTimersAlloc, (uint64_t)(pQueue - &pVM->tm.s.aTimerQueues[0])), NULL);
    1632         AssertLogRelRCReturnStmt(rc, PDMCritSectRwLeaveExcl(&pQueue->AllocLock), rc);
    1633         AssertReturnStmt(pQueue->cTimersAlloc >= cTimersAlloc, PDMCritSectRwLeaveExcl(&pQueue->AllocLock), VERR_TM_IPE_3);
     1632        AssertLogRelRCReturnStmt(rc, PDMCritSectRwLeaveExcl(pVM, &pQueue->AllocLock), rc);
     1633        AssertReturnStmt(pQueue->cTimersAlloc >= cTimersAlloc, PDMCritSectRwLeaveExcl(pVM, &pQueue->AllocLock), VERR_TM_IPE_3);
    16341634    }
    16351635
    … …  
    16571657    AssertLogRelMsgReturnStmt(pTimer != NULL, ("cTimersFree=%u cTimersAlloc=%u enmClock=%s\n", pQueue->cTimersFree,
    16581658                                               pQueue->cTimersAlloc, pQueue->szName),
    1659                               PDMCritSectRwLeaveExcl(&pQueue->AllocLock), VERR_INTERNAL_ERROR_3);
     1659                              PDMCritSectRwLeaveExcl(pVM, &pQueue->AllocLock), VERR_INTERNAL_ERROR_3);
    16601660    pQueue->cTimersFree -= 1;
    16611661
    … …  
    16861686#endif
    16871687
    1688     PDMCritSectRwLeaveExcl(&pQueue->AllocLock);
     1688    PDMCritSectRwLeaveExcl(pVM, &pQueue->AllocLock);
    16891689
    16901690#ifdef VBOX_WITH_STATISTICS
    … …  
    18851885     * like create does. All the work is done here.
    18861886     */
    1887     PDMCritSectRwEnterExcl(&pQueue->AllocLock, VERR_IGNORED);
     1887    PDMCritSectRwEnterExcl(pVM, &pQueue->AllocLock, VERR_IGNORED);
    18881888    PDMCritSectEnter(pVM, &pQueue->TimerLock, VERR_IGNORED);
    18891889
    … …  
    19251925                AssertMsgFailed(("%p:.enmState=%s %s\n", pTimer, tmTimerState(enmState), pTimer->szName));
    19261926                PDMCritSectLeave(pVM, &pQueue->TimerLock);
    1927                 PDMCritSectRwLeaveExcl(&pQueue->AllocLock);
     1927                PDMCritSectRwLeaveExcl(pVM, &pQueue->AllocLock);
    19281928
    19291929                AssertMsgReturn(cRetries > 0, ("Failed waiting for stable state. state=%d (%s)\n", pTimer->enmState, pTimer->szName),
    … …  
    19321932                    RTThreadSleep(1);
    19331933
    1934                 PDMCritSectRwEnterExcl(&pQueue->AllocLock, VERR_IGNORED);
     1934                PDMCritSectRwEnterExcl(pVM, &pQueue->AllocLock, VERR_IGNORED);
    19351935                PDMCritSectEnter(pVM, &pQueue->TimerLock, VERR_IGNORED);
    19361936                continue;
    … …  
    19421942            case TMTIMERSTATE_DESTROY:
    19431943                PDMCritSectLeave(pVM, &pQueue->TimerLock);
    1944                 PDMCritSectRwLeaveExcl(&pQueue->AllocLock);
     1944                PDMCritSectRwLeaveExcl(pVM, &pQueue->AllocLock);
    19451945                AssertLogRelMsgFailedReturn(("pTimer=%p %s\n", pTimer, tmTimerState(enmState)), VERR_TM_INVALID_STATE);
    19461946
    … …  
    19481948                AssertMsgFailed(("Unknown timer state %d (%s)\n", enmState, pTimer->szName));
    19491949                PDMCritSectLeave(pVM, &pQueue->TimerLock);
    1950                 PDMCritSectRwLeaveExcl(&pQueue->AllocLock);
     1950                PDMCritSectRwLeaveExcl(pVM, &pQueue->AllocLock);
    19511951                return VERR_TM_UNKNOWN_STATE;
    19521952        }
    … …  
    19621962        AssertMsgFailed(("%p:.enmState=%s %s\n", pTimer, tmTimerState(enmState), pTimer->szName));
    19631963        PDMCritSectLeave(pVM, &pQueue->TimerLock);
    1964         PDMCritSectRwLeaveExcl(&pQueue->AllocLock);
     1964        PDMCritSectRwLeaveExcl(pVM, &pQueue->AllocLock);
    19651965
    19661966        AssertMsgReturn(cRetries > 0, ("Failed waiting for stable state. state=%d (%s)\n", pTimer->enmState, pTimer->szName),
    19671967                        VERR_TM_UNSTABLE_STATE);
    19681968
    1969         PDMCritSectRwEnterExcl(&pQueue->AllocLock, VERR_IGNORED);
     1969        PDMCritSectRwEnterExcl(pVM, &pQueue->AllocLock, VERR_IGNORED);
    19701970        PDMCritSectEnter(pVM, &pQueue->TimerLock, VERR_IGNORED);
    19711971    }
    … …  
    20262026#endif
    20272027    PDMCritSectLeave(pVM, &pQueue->TimerLock);
    2028     PDMCritSectRwLeaveExcl(&pQueue->AllocLock);
     2028    PDMCritSectRwLeaveExcl(pVM, &pQueue->AllocLock);
    20292029    return VINF_SUCCESS;
    20302030}
    … …  
    20642064    {
    20652065        PTMTIMERQUEUE pQueue = &pVM->tm.s.aTimerQueues[idxQueue];
    2066         PDMCritSectRwEnterShared(&pQueue->AllocLock, VERR_IGNORED);
     2066        PDMCritSectRwEnterShared(pVM, &pQueue->AllocLock, VERR_IGNORED);
    20672067        uint32_t idxTimer = pQueue->cTimersAlloc;
    20682068        while (idxTimer-- > 0)
    … …  
    20732073                && pTimer->enmState < TMTIMERSTATE_DESTROY)
    20742074            {
    2075                 PDMCritSectRwLeaveShared(&pQueue->AllocLock);
     2075                PDMCritSectRwLeaveShared(pVM, &pQueue->AllocLock);
    20762076
    20772077                int rc = tmR3TimerDestroy(pVM, pQueue, pTimer);
    20782078                AssertRC(rc);
    20792079
    2080                 PDMCritSectRwEnterShared(&pQueue->AllocLock, VERR_IGNORED);
     2080                PDMCritSectRwEnterShared(pVM, &pQueue->AllocLock, VERR_IGNORED);
    20812081            }
    20822082        }
    2083         PDMCritSectRwLeaveShared(&pQueue->AllocLock);
     2083        PDMCritSectRwLeaveShared(pVM, &pQueue->AllocLock);
    20842084    }
    20852085
    … …  
    21052105    {
    21062106        PTMTIMERQUEUE pQueue = &pVM->tm.s.aTimerQueues[idxQueue];
    2107         PDMCritSectRwEnterShared(&pQueue->AllocLock, VERR_IGNORED);
     2107        PDMCritSectRwEnterShared(pVM, &pQueue->AllocLock, VERR_IGNORED);
    21082108        uint32_t idxTimer = pQueue->cTimersAlloc;
    21092109        while (idxTimer-- > 0)
    … …  
    21142114                && pTimer->enmState < TMTIMERSTATE_DESTROY)
    21152115            {
    2116                 PDMCritSectRwLeaveShared(&pQueue->AllocLock);
     2116                PDMCritSectRwLeaveShared(pVM, &pQueue->AllocLock);
    21172117
    21182118                int rc = tmR3TimerDestroy(pVM, pQueue, pTimer);
    21192119                AssertRC(rc);
    21202120
    2121                 PDMCritSectRwEnterShared(&pQueue->AllocLock, VERR_IGNORED);
     2121                PDMCritSectRwEnterShared(pVM, &pQueue->AllocLock, VERR_IGNORED);
    21222122            }
    21232123        }
    2124         PDMCritSectRwLeaveShared(&pQueue->AllocLock);
     2124        PDMCritSectRwLeaveShared(pVM, &pQueue->AllocLock);
    21252125    }
    21262126
    … …  
    21462146    {
    21472147        PTMTIMERQUEUE pQueue = &pVM->tm.s.aTimerQueues[idxQueue];
    2148         PDMCritSectRwEnterShared(&pQueue->AllocLock, VERR_IGNORED);
     2148        PDMCritSectRwEnterShared(pVM, &pQueue->AllocLock, VERR_IGNORED);
    21492149        uint32_t idxTimer = pQueue->cTimersAlloc;
    21502150        while (idxTimer-- > 0)
    … …  
    21552155                && pTimer->enmState < TMTIMERSTATE_DESTROY)
    21562156            {
    2157                 PDMCritSectRwLeaveShared(&pQueue->AllocLock);
     2157                PDMCritSectRwLeaveShared(pVM, &pQueue->AllocLock);
    21582158
    21592159                int rc = tmR3TimerDestroy(pVM, pQueue, pTimer);
    21602160                AssertRC(rc);
    21612161
    2162                 PDMCritSectRwEnterShared(&pQueue->AllocLock, VERR_IGNORED);
     2162                PDMCritSectRwEnterShared(pVM, &pQueue->AllocLock, VERR_IGNORED);
    21632163            }
    21642164        }
    2165         PDMCritSectRwLeaveShared(&pQueue->AllocLock);
     2165        PDMCritSectRwLeaveShared(pVM, &pQueue->AllocLock);
    21662166    }
    21672167
    … …  
    38833883        PTMTIMERQUEUE const pQueue   = &pVM->tm.s.aTimerQueues[idxQueue];
    38843884        const char * const  pszClock = tmR3Get5CharClockName(pQueue->enmClock);
    3885         PDMCritSectRwEnterShared(&pQueue->AllocLock, VERR_IGNORED);
     3885        PDMCritSectRwEnterShared(pVM, &pQueue->AllocLock, VERR_IGNORED);
    38863886        for (uint32_t idxTimer = 0; idxTimer < pQueue->cTimersAlloc; idxTimer++)
    38873887        {
    … …  
    39023902                                pTimer->szName);
    39033903        }
    3904         PDMCritSectRwLeaveShared(&pQueue->AllocLock);
     3904        PDMCritSectRwLeaveShared(pVM, &pQueue->AllocLock);
    39053905    }
    39063906}
    … …  
    39333933        PTMTIMERQUEUE const pQueue   = &pVM->tm.s.aTimerQueues[idxQueue];
    39343934        const char * const  pszClock = tmR3Get5CharClockName(pQueue->enmClock);
    3935         PDMCritSectRwEnterShared(&pQueue->AllocLock, VERR_IGNORED);
     3935        PDMCritSectRwEnterShared(pVM, &pQueue->AllocLock, VERR_IGNORED);
    39363936        PDMCritSectEnter(pVM, &pQueue->TimerLock, VERR_IGNORED);
    39373937
    … …  
    39553955
    39563956        PDMCritSectLeave(pVM, &pQueue->TimerLock);
    3957         PDMCritSectRwLeaveShared(&pQueue->AllocLock);
     3957        PDMCritSectRwLeaveShared(pVM, &pQueue->AllocLock);
    39583958    }
    39593959}

  • trunk/src/VBox/VMM/VMMR3/VMM.cpp

    r90346 r90347  
    23902390        case VMMCALLRING3_PDM_CRIT_SECT_RW_ENTER_EXCL:
    23912391        {
    2392             pVCpu->vmm.s.rcCallRing3 = PDMR3CritSectRwEnterExclEx((PPDMCRITSECTRW)(uintptr_t)pVCpu->vmm.s.u64CallRing3Arg,
    2393                                                                     true /*fCallRing3*/);
     2392            pVCpu->vmm.s.rcCallRing3 = PDMR3CritSectRwEnterExclEx(pVM, (PPDMCRITSECTRW)(uintptr_t)pVCpu->vmm.s.u64CallRing3Arg,
     2393                                                                  true /*fCallRing3*/);
    23942394            break;
    23952395        }
    … …  
    24002400        case VMMCALLRING3_PDM_CRIT_SECT_RW_ENTER_SHARED:
    24012401        {
    2402             pVCpu->vmm.s.rcCallRing3 = PDMR3CritSectRwEnterSharedEx((PPDMCRITSECTRW)(uintptr_t)pVCpu->vmm.s.u64CallRing3Arg,
     2402            pVCpu->vmm.s.rcCallRing3 = PDMR3CritSectRwEnterSharedEx(pVM, (PPDMCRITSECTRW)(uintptr_t)pVCpu->vmm.s.u64CallRing3Arg,
    24032403                                                                    true /*fCallRing3*/);
    24042404            break;

  • trunk/src/VBox/VMM/include/IOMInternal.h

    r90346 r90347  
    571571/* IOM locking helpers. */
    572572#ifdef IOM_WITH_CRIT_SECT_RW
    573 # define IOM_LOCK_EXCL(a_pVM)                   PDMCritSectRwEnterExcl(&(a_pVM)->iom.s.CritSect, VERR_SEM_BUSY)
    574 # define IOM_UNLOCK_EXCL(a_pVM)                 do { PDMCritSectRwLeaveExcl(&(a_pVM)->iom.s.CritSect); } while (0)
     573# define IOM_LOCK_EXCL(a_pVM)                   PDMCritSectRwEnterExcl((a_pVM), &(a_pVM)->iom.s.CritSect, VERR_SEM_BUSY)
     574# define IOM_UNLOCK_EXCL(a_pVM)                 do { PDMCritSectRwLeaveExcl((a_pVM), &(a_pVM)->iom.s.CritSect); } while (0)
    575575# if 0 /* (in case needed for debugging) */
    576576# define IOM_LOCK_SHARED_EX(a_pVM, a_rcBusy)    PDMCritSectRwEnterExcl(&(a_pVM)->iom.s.CritSect, (a_rcBusy))
    … …  
    578578# define IOM_IS_SHARED_LOCK_OWNER(a_pVM)        PDMCritSectRwIsWriteOwner(&(a_pVM)->iom.s.CritSect)
    579579# else
    580 # define IOM_LOCK_SHARED_EX(a_pVM, a_rcBusy)    PDMCritSectRwEnterShared(&(a_pVM)->iom.s.CritSect, (a_rcBusy))
    581 # define IOM_UNLOCK_SHARED(a_pVM)               do { PDMCritSectRwLeaveShared(&(a_pVM)->iom.s.CritSect); } while (0)
    582 # define IOM_IS_SHARED_LOCK_OWNER(a_pVM)        PDMCritSectRwIsReadOwner(&(a_pVM)->iom.s.CritSect, true)
     580# define IOM_LOCK_SHARED_EX(a_pVM, a_rcBusy)    PDMCritSectRwEnterShared((a_pVM), &(a_pVM)->iom.s.CritSect, (a_rcBusy))
     581# define IOM_UNLOCK_SHARED(a_pVM)               do { PDMCritSectRwLeaveShared((a_pVM), &(a_pVM)->iom.s.CritSect); } while (0)
     582# define IOM_IS_SHARED_LOCK_OWNER(a_pVM)        PDMCritSectRwIsReadOwner((a_pVM), &(a_pVM)->iom.s.CritSect, true)
    583583# endif
    584 # define IOM_IS_EXCL_LOCK_OWNER(a_pVM)          PDMCritSectRwIsWriteOwner(&(a_pVM)->iom.s.CritSect)
     584# define IOM_IS_EXCL_LOCK_OWNER(a_pVM)          PDMCritSectRwIsWriteOwner((a_pVM), &(a_pVM)->iom.s.CritSect)
    585585#else
    586586# define IOM_LOCK_EXCL(a_pVM)                   PDMCritSectEnter((a_pVM), &(a_pVM)->iom.s.CritSect, VERR_SEM_BUSY)

  • trunk/src/VBox/VMM/include/PDMInternal.h

    r90346 r90347  
    17161716
    17171717#if defined(IN_RING3) || defined(IN_RING0)
    1718 void        pdmCritSectRwLeaveSharedQueued(PPDMCRITSECTRW pThis);
    1719 void        pdmCritSectRwLeaveExclQueued(PPDMCRITSECTRW pThis);
     1718void        pdmCritSectRwLeaveSharedQueued(PVMCC pVM, PPDMCRITSECTRW pThis);
     1719void        pdmCritSectRwLeaveExclQueued(PVMCC pVM, PPDMCRITSECTRW pThis);
    17201720#endif
    17211721
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