Changeset 25398 in vbox

Timestamp:

Dec 15, 2009 12:58:08 PM (15 years ago)

Author:

vboxsync

svn:sync-xref-src-repo-rev:

56024

Message:

IPRT,PDMAllocCritSect: Don't bitch when recursivly entering a mutex.

Location:

trunk

Files:

• include/iprt/lockvalidator.h (modified) (2 diffs)
• include/iprt/thread.h (modified) (3 diffs)
• src/VBox/Runtime/common/misc/thread.cpp (modified) (2 diffs)
• src/VBox/Runtime/generic/critsect-generic.cpp (modified) (1 diff)
• src/VBox/Runtime/include/internal/strict.h (modified) (2 diffs)
• src/VBox/Runtime/r3/linux/semmutex-linux.cpp (modified) (1 diff)
• src/VBox/Runtime/r3/posix/semmutex-posix.cpp (modified) (2 diffs)
• src/VBox/Runtime/r3/win/semmutex-win.cpp (modified) (1 diff)
• src/VBox/VMM/VMMAll/PDMAllCritSect.cpp (modified) (16 diffs)

trunk/include/iprt/lockvalidator.h

@@ -166 +166 @@
 RTDECL(int)  RTLockValidatorCheckOrder(PRTLOCKVALIDATORREC pRec, RTTHREAD hThread, RTHCUINTPTR uId, RT_SRC_POS_DECL);
 
-
-/**
- * Record the specified thread as lock owner.
- *
- * This is typically called after acquiring the lock.
- *
- * @returns hThread resolved.  Can return NIL_RTHREAD iff we fail to adopt the
- *          alien thread or if pRec is invalid.
+/**
+ * Check the exit order.
+ *
+ * This is called by routines implementing lock acquisition.
+ *
+ * @retval  VINF_SUCCESS on success.
+ * @retval  VERR_DEADLOCK if the order is wrong, after having whined and
+ *          asserted.
  *
  * @param   pRec                The validator record.
@@ -187 +187 @@
  *                              from.  Optional.
  */
+RTDECL(int)  RTLockValidatorCheckReleaseOrder(PRTLOCKVALIDATORREC pRec, RTTHREAD hThread);
+
+/**
+ * Record the specified thread as lock owner.
+ *
+ * This is typically called after acquiring the lock.
+ *
+ * @returns hThread resolved.  Can return NIL_RTHREAD iff we fail to adopt the
+ *          alien thread or if pRec is invalid.
+ *
+ * @param   pRec                The validator record.
+ * @param   hThread             The handle of the calling thread.  If not known,
+ *                              pass NIL_RTTHREAD and this method will figure it
+ *                              out.
+ * @param   uId                 Some kind of locking location ID.  Typically a
+ *                              return address up the stack.  Optional (0).
+ * @param   pszFile             The file where the lock is being acquired from.
+ *                              Optional.
+ * @param   iLine               The line number in that file.  Optional (0).
+ * @param   pszFunction         The functionn where the lock is being acquired
+ *                              from.  Optional.
+ */
 RTDECL(RTTHREAD) RTLockValidatorSetOwner(PRTLOCKVALIDATORREC pRec, RTTHREAD hThread, RTHCUINTPTR uId, RT_SRC_POS_DECL);
 

trunk/include/iprt/thread.h

@@ -632 +632 @@
  * Unblocks a thread.
  *
- * This function is paired with rtThreadBlocking.
+ * This function is paired with RTThreadBlocking and RTThreadBlockingDebug.
  *
  * @param   hThread     The current thread.
@@ -641 +641 @@
 
 /**
+ * Change the thread state to blocking.
+ *
+ * @param   hThread         The current thread.
+ * @param   enmState        The sleep state.
+ */
+RTDECL(void) RTThreadBlocking(RTTHREAD hThread, RTTHREADSTATE enmState);
+
+/**
  * Change the thread state to blocking and do deadlock detection.
  *
@@ -648 +656 @@
  * @param   enmState        The sleep state.
  * @param   pvBlock         Pointer to a RTLOCKVALIDATORREC structure.
+ * @param   fRecursiveOk    Whether it's ok to recurse.
  * @param   uId             Where we are blocking.
  * @param   RT_SRC_POS_DECL Where we are blocking.
- */
-RTDECL(void) RTThreadBlocking(RTTHREAD hThread, RTTHREADSTATE enmState,
-                              PRTLOCKVALIDATORREC pValidatorRec, RTHCUINTPTR uId, RT_SRC_POS_DECL);
+ *
+ * @todo    Move this to RTLockValidator.
+ */
+RTDECL(void) RTThreadBlockingDebug(RTTHREAD hThread, RTTHREADSTATE enmState, bool fRecursiveOk,
+                                   PRTLOCKVALIDATORREC pValidatorRec, RTHCUINTPTR uId, RT_SRC_POS_DECL);
 
 

trunk/src/VBox/Runtime/common/misc/thread.cpp

@@ -1545 +1545 @@
 
 /**
- * Change the thread state to blocking and do deadlock detection.
- *
- * This is a RT_STRICT method for debugging locks and detecting deadlocks.
+ * Change the thread state to blocking.
  *
  * @param   hThread         The current thread.
  * @param   enmState        The sleep state.
- * @param   pvBlock         Pointer to a RTLOCKVALIDATORREC structure.
- * @param   uId             Where we are blocking.
- * @param   RT_SRC_POS_DECL Where we are blocking.
- */
-RTDECL(void) RTThreadBlocking(RTTHREAD hThread, RTTHREADSTATE enmState,
-                              PRTLOCKVALIDATORREC pValidatorRec, RTHCUINTPTR uId, RT_SRC_POS_DECL)
+ */
+RTDECL(void) RTThreadBlocking(RTTHREAD hThread, RTTHREADSTATE enmState)
 
 {
@@ -1570 +1564 @@
         return;
 
-    if (!pValidatorRec)
-        /*
-         * If no validator record, just update the thread state.
-         */
-        rtThreadSetState(pThread, enmState);
-    else
-    {
-        /*
-         * Record the location and everything before changing the state and
-         * performing deadlock detection.
-         */
-        /** @todo This has to be serialized! The deadlock detection isn't 100% safe!!! */
-        pThread->Block.pRec         = pValidatorRec;
-        pThread->pszBlockFunction   = pszFunction;
-        pThread->pszBlockFile       = pszFile;
-        pThread->uBlockLine         = iLine;
-        pThread->uBlockId           = uId;
-        rtThreadSetState(pThread, enmState);
-
+    /*
+     * Do the job.
+     */
+    rtThreadSetState(pThread, enmState);
+}
+
+
+/**
+ * Change the thread state to blocking and do deadlock detection.
+ *
+ * This is a RT_STRICT method for debugging locks and detecting deadlocks.
+ *
+ * @param   hThread         The current thread.
+ * @param   enmState        The sleep state.
+ * @param   pvBlock         Pointer to a RTLOCKVALIDATORREC structure.
+ * @param   fRecursiveOk    Whether it's ok to recurse.
+ * @param   uId             Where we are blocking.
+ * @param   RT_SRC_POS_DECL Where we are blocking.
+ *
+ * @todo    Move this to RTLockValidator.
+ */
+RTDECL(void) RTThreadBlockingDebug(RTTHREAD hThread, RTTHREADSTATE enmState, bool fRecursiveOk,
+                                   PRTLOCKVALIDATORREC pValidatorRec, RTHCUINTPTR uId, RT_SRC_POS_DECL)
+
+{
+    /*
+     * Fend off wild life.
+     */
+    AssertReturnVoid(RTTHREAD_IS_SLEEPING(enmState));
+    AssertPtrReturnVoid(pValidatorRec);
+    AssertReturnVoid(pValidatorRec->u32Magic == RTLOCKVALIDATORREC_MAGIC);
+    PRTTHREADINT pThread = hThread;
+    AssertPtrReturnVoid(pThread);
+    AssertReturnVoid(pThread->u32Magic == RTTHREADINT_MAGIC);
+    AssertReturnVoid(rtThreadGetState(pThread) == RTTHREADSTATE_RUNNING);
+
+    /*
+     * Record the location and everything before changing the state and
+     * performing deadlock detection.
+     */
+    /** @todo This has to be serialized! The deadlock detection isn't 100% safe!!! */
+    pThread->Block.pRec         = pValidatorRec;
+    pThread->pszBlockFunction   = pszFunction;
+    pThread->pszBlockFile       = pszFile;
+    pThread->uBlockLine         = iLine;
+    pThread->uBlockId           = uId;
+    rtThreadSetState(pThread, enmState);
+
+    /*
+     * Don't do deadlock detection if we're recursing and that's OK.
+     *
+     * On some hosts we don't do recursion accounting our selves and there
+     * isn't any other place to check for this.  semmutex-win.cpp for instance.
+     */
+    if (    !fRecursiveOk
+        ||  pValidatorRec->hThread != pThread)
+    {
         /*
          * Do deadlock detection.

trunk/src/VBox/Runtime/generic/critsect-generic.cpp

@@ -321 +321 @@
         for (;;)
         {
-            RTThreadBlocking(hThreadSelf, RTTHREADSTATE_CRITSECT, RTCRITSECT_STRICT_BLOCK_ARGS(pCritSect->pValidatorRec));
+            RTCRITSECT_STRICT_BLOCK(hThreadSelf, pCritSect->pValidatorRec, !(pCritSect->fFlags & RTCRITSECT_FLAGS_NO_NESTING));
             int rc = RTSemEventWait(pCritSect->EventSem, RT_INDEFINITE_WAIT);
-            RTThreadUnblocked(hThreadSelf, RTTHREADSTATE_CRITSECT);
+            RTCRITSECT_STRICT_UNBLOCK(hThreadSelf);
             if (pCritSect->u32Magic != RTCRITSECT_MAGIC)
                 return VERR_SEM_DESTROYED;

trunk/src/VBox/Runtime/include/internal/strict.h

@@ -43 +43 @@
 
 #ifdef RTCRITSECT_STRICT
-# define RTCRITSECT_STRICT_POS_DECL         RTHCUINTPTR uId, RT_SRC_POS_DECL
-# define RTCRITSECT_STRICT_POS_ARGS         uId, RT_SRC_POS_ARGS
-# define RTCRITSECT_STRICT_BLOCK_ARGS(pRec) pRec,     uId, RT_SRC_POS_ARGS
+# define RTCRITSECT_STRICT_POS_DECL             RTHCUINTPTR uId, RT_SRC_POS_DECL
+# define RTCRITSECT_STRICT_POS_ARGS             uId, RT_SRC_POS_ARGS
+# define RTCRITSECT_STRICT_BLOCK(hThread, pRec, fRecursive) \
+                                                RTThreadBlockingDebug((hThread), RTTHREADSTATE_CRITSECT, fRecursive, pRec, uId, RT_SRC_POS_ARGS)
 #else
-# define RTCRITSECT_STRICT_POS_DECL         int iDummy
-# define RTCRITSECT_STRICT_POS_ARGS         0
-# define RTCRITSECT_STRICT_BLOCK_ARGS(pRec) NULL, 0, NULL, 0, NULL
+# define RTCRITSECT_STRICT_POS_DECL             int iDummy
+# define RTCRITSECT_STRICT_POS_ARGS             0
+# define RTCRITSECT_STRICT_BLOCK(hThread, pRec, fRecursive) \
+                                                RTThreadBlocking((hThread), RTTHREADSTATE_CRITSECT)
 #endif
+#define  RTCRITSECT_STRICT_UNBLOCK(hThread)     RTThreadUnblocked((hThread), RTTHREADSTATE_CRITSECT)
 
 
@@ -61 +64 @@
 
 #ifdef RTSEMMUTEX_STRICT
-# define RTSEMMUTEX_STRICT_POS_DECL         RTHCUINTPTR uId, RT_SRC_POS_DECL
-# define RTSEMMUTEX_STRICT_POS_ARGS         uId, RT_SRC_POS_ARGS
-# define RTSEMMUTEX_STRICT_BLOCK_ARGS(pRec) pRec,     uId, RT_SRC_POS_ARGS
+# define RTSEMMUTEX_STRICT_POS_DECL             RTHCUINTPTR uId, RT_SRC_POS_DECL
+# define RTSEMMUTEX_STRICT_POS_ARGS             uId, RT_SRC_POS_ARGS
+# define RTSEMMUTEX_STRICT_BLOCK(hThread, pRec) RTThreadBlockingDebug((hThread), RTTHREADSTATE_MUTEX, true, pRec, uId, RT_SRC_POS_ARGS)
 #else
-# define RTSEMMUTEX_STRICT_POS_DECL         int iDummy
-# define RTSEMMUTEX_STRICT_POS_ARGS         0
-# define RTSEMMUTEX_STRICT_BLOCK_ARGS(pRec) NULL, 0, NULL, 0, NULL
+# define RTSEMMUTEX_STRICT_POS_DECL             int iDummy
+# define RTSEMMUTEX_STRICT_POS_ARGS             0
+# define RTSEMMUTEX_STRICT_BLOCK(hThread, pRec) RTThreadBlocking((hThread), RTTHREADSTATE_MUTEX)
 #endif
+#define  RTSEMMUTEX_STRICT_UNBLOCK(hThread)     RTThreadUnblocked((hThread), RTTHREADSTATE_MUTEX)
 
 

trunk/src/VBox/Runtime/r3/linux/semmutex-linux.cpp

@@ -229 +229 @@
              */
             if (pTimeout && ( pTimeout->tv_sec || pTimeout->tv_nsec ))
-                RTThreadBlocking(hThreadSelf, RTTHREADSTATE_MUTEX, RTSEMMUTEX_STRICT_BLOCK_ARGS(&pThis->ValidatorRec));
+                RTSEMMUTEX_STRICT_BLOCK(hThreadSelf, &pThis->ValidatorRec);
             long rc = sys_futex(&pThis->iState, FUTEX_WAIT, 2, pTimeout, NULL, 0);
-            RTThreadUnblocked(hThreadSelf, RTTHREADSTATE_MUTEX);
+            RTSEMMUTEX_STRICT_UNBLOCK(hThreadSelf);
             if (RT_UNLIKELY(pThis->u32Magic != RTSEMMUTEX_MAGIC))
                 return VERR_SEM_DESTROYED;

trunk/src/VBox/Runtime/r3/posix/semmutex-posix.cpp

@@ -189 +189 @@
     {
         /* take mutex */
-        RTThreadBlocking(hThreadSelf, RTTHREADSTATE_MUTEX, RTSEMMUTEX_STRICT_BLOCK_ARGS(&pThis->ValidatorRec));
+        RTSEMMUTEX_STRICT_BLOCK(hThreadSelf, &pThis->ValidatorRec);
         int rc = pthread_mutex_lock(&pThis->Mutex);
-        RTThreadUnblocked(hThreadSelf, RTTHREADSTATE_MUTEX);
+        RTSEMMUTEX_STRICT_UNBLOCK(hThreadSelf);
         if (rc)
         {
@@ -218 +218 @@
                 ts.tv_sec++;
             }
-            RTThreadBlocking(hThreadSelf, RTTHREADSTATE_MUTEX, RTSEMMUTEX_STRICT_BLOCK_ARGS(&pThis->ValidatorRec));
+            RTSEMMUTEX_STRICT_BLOCK(hThreadSelf, &pThis->ValidatorRec);
         }
 
         /* take mutex */
         int rc = pthread_mutex_timedlock(&pThis->Mutex, &ts);
-        RTThreadUnblocked(hThreadSelf, RTTHREADSTATE_MUTEX);
+        RTSEMMUTEX_STRICT_UNBLOCK(hThreadSelf);
         if (rc)
         {

trunk/src/VBox/Runtime/r3/win/semmutex-win.cpp

@@ -162 +162 @@
      */
     if (cMillies > 0)
-        RTThreadBlocking(hThreadSelf, RTTHREADSTATE_MUTEX, RTSEMMUTEX_STRICT_BLOCK_ARGS(&pThis->ValidatorRec));
+        RTSEMMUTEX_STRICT_BLOCK(hThreadSelf, &pThis->ValidatorRec);
     int rc = WaitForSingleObjectEx(pThis->hMtx,
                                    cMillies == RT_INDEFINITE_WAIT ? INFINITE : cMillies,
                                    TRUE /*bAlertable*/);
-    RTThreadUnblocked(hThreadSelf, RTTHREADSTATE_MUTEX);
+    RTSEMMUTEX_STRICT_UNBLOCK(hThreadSelf);
     switch (rc)
     {

trunk/src/VBox/VMM/VMMAll/PDMAllCritSect.cpp

@@ -52 +52 @@
 
 #ifdef PDMCRITSECT_STRICT
-# define PDMCRITSECT_STRICT_ARGS_DECL       RTHCUINTPTR uId, RT_SRC_POS_DECL
-# define PDMCRITSECT_STRICT_ARGS_PASS_ON    uId, RT_SRC_POS_ARGS
-#else
-# define PDMCRITSECT_STRICT_ARGS_DECL       int iDummy
-# define PDMCRITSECT_STRICT_ARGS_PASS_ON    0
-#endif
-
+# define PDMCRITSECT_STRICT_POS_DECL            RTHCUINTPTR uId, RT_SRC_POS_DECL
+# define PDMCRITSECT_STRICT_POS_ARGS            uId, RT_SRC_POS_ARGS
+# define PDMCRITSECT_STRICT_BLOCK(hThread, pRec, fRecursive) \
+                                                RTThreadBlockingDebug((hThread), RTTHREADSTATE_CRITSECT, fRecursive, pRec, uId, RT_SRC_POS_ARGS)
+#else
+# define PDMCRITSECT_STRICT_POS_DECL            int iDummy
+# define PDMCRITSECT_STRICT_POS_ARGS            0
+# define PDMCRITSECT_STRICT_BLOCK(hThread, pRec, fRecursive) \
+                                                RTThreadBlocking((hThread), RTTHREADSTATE_CRITSECT)
+#endif
+#define  PDMCRITSECT_STRICT_UNBLOCK(hThread)    RTThreadUnblocked((hThread), RTTHREADSTATE_CRITSECT)
 
 /* Undefine the automatic VBOX_STRICT API mappings. */
@@ -95 +99 @@
  * @param   hNativeSelf     The native handle of this thread.
  */
-DECL_FORCE_INLINE(int) pdmCritSectEnterFirst(PPDMCRITSECT pCritSect, RTNATIVETHREAD hNativeSelf, PDMCRITSECT_STRICT_ARGS_DECL)
+DECL_FORCE_INLINE(int) pdmCritSectEnterFirst(PPDMCRITSECT pCritSect, RTNATIVETHREAD hNativeSelf, PDMCRITSECT_STRICT_POS_DECL)
 {
     AssertMsg(pCritSect->s.Core.NativeThreadOwner == NIL_RTNATIVETHREAD, ("NativeThreadOwner=%p\n", pCritSect->s.Core.NativeThreadOwner));
@@ -104 +108 @@
 
 # if defined(PDMCRITSECT_STRICT) && defined(IN_RING3)
-    RTThreadWriteLockInc(RTLockValidatorSetOwner(pCritSect->s.Core.pValidatorRec, NIL_RTTHREAD, PDMCRITSECT_STRICT_ARGS_PASS_ON));
+    RTThreadWriteLockInc(RTLockValidatorSetOwner(pCritSect->s.Core.pValidatorRec, NIL_RTTHREAD, PDMCRITSECT_STRICT_POS_ARGS));
 # endif
 
@@ -120 +124 @@
  * @param   hNativeSelf         The native thread handle.
  */
-static int pdmR3CritSectEnterContended(PPDMCRITSECT pCritSect, RTNATIVETHREAD hNativeSelf, PDMCRITSECT_STRICT_ARGS_DECL)
+static int pdmR3CritSectEnterContended(PPDMCRITSECT pCritSect, RTNATIVETHREAD hNativeSelf, PDMCRITSECT_STRICT_POS_DECL)
 {
     /*
@@ -126 +130 @@
      */
     if (ASMAtomicIncS32(&pCritSect->s.Core.cLockers) == 0)
-        return pdmCritSectEnterFirst(pCritSect, hNativeSelf, PDMCRITSECT_STRICT_ARGS_PASS_ON);
+        return pdmCritSectEnterFirst(pCritSect, hNativeSelf, PDMCRITSECT_STRICT_POS_ARGS);
     STAM_COUNTER_INC(&pCritSect->s.StatContentionR3);
 
@@ -140 +144 @@
     for (;;)
     {
-# ifdef PDMCRITSECT_STRICT
-        RTThreadBlocking(hSelf, RTTHREADSTATE_CRITSECT, pCritSect->s.Core.pValidatorRec, 0, NULL, 0, NULL);
-# endif
+        PDMCRITSECT_STRICT_BLOCK(hSelf, pCritSect->s.Core.pValidatorRec, !(pCritSect->s.Core.fFlags & RTCRITSECT_FLAGS_NO_NESTING));
         int rc = SUPSemEventWaitNoResume(pSession, hEvent, RT_INDEFINITE_WAIT);
-# ifdef PDMCRITSECT_STRICT
-        RTThreadUnblocked(hSelf, RTTHREADSTATE_CRITSECT);
-# endif
+        PDMCRITSECT_STRICT_UNBLOCK(hSelf);
         if (RT_UNLIKELY(pCritSect->s.Core.u32Magic != RTCRITSECT_MAGIC))
             return VERR_SEM_DESTROYED;
         if (rc == VINF_SUCCESS)
-            return pdmCritSectEnterFirst(pCritSect, hNativeSelf, PDMCRITSECT_STRICT_ARGS_PASS_ON);
+            return pdmCritSectEnterFirst(pCritSect, hNativeSelf, PDMCRITSECT_STRICT_POS_ARGS);
         AssertMsg(rc == VERR_INTERRUPTED, ("rc=%Rrc\n", rc));
     }
@@ -169 +169 @@
  *                              and the section is busy.
  */
-DECL_FORCE_INLINE(int) pdmCritSectEnter(PPDMCRITSECT pCritSect, int rcBusy, PDMCRITSECT_STRICT_ARGS_DECL)
+DECL_FORCE_INLINE(int) pdmCritSectEnter(PPDMCRITSECT pCritSect, int rcBusy, PDMCRITSECT_STRICT_POS_DECL)
 {
     Assert(pCritSect->s.Core.cNestings < 8);  /* useful to catch incorrect locking */
@@ -186 +186 @@
     /* Not owned ... */
     if (ASMAtomicCmpXchgS32(&pCritSect->s.Core.cLockers, 0, -1))
-        return pdmCritSectEnterFirst(pCritSect, hNativeSelf, PDMCRITSECT_STRICT_ARGS_PASS_ON);
+        return pdmCritSectEnterFirst(pCritSect, hNativeSelf, PDMCRITSECT_STRICT_POS_ARGS);
 
     /* ... or nested. */
@@ -206 +206 @@
     {
         if (ASMAtomicCmpXchgS32(&pCritSect->s.Core.cLockers, 0, -1))
-            return pdmCritSectEnterFirst(pCritSect, hNativeSelf, PDMCRITSECT_STRICT_ARGS_PASS_ON);
+            return pdmCritSectEnterFirst(pCritSect, hNativeSelf, PDMCRITSECT_STRICT_POS_ARGS);
         ASMNopPause();
         /** @todo Should use monitor/mwait on e.g. &cLockers here, possibly with a
@@ -219 +219 @@
      * Take the slow path.
      */
-    return pdmR3CritSectEnterContended(pCritSect, hNativeSelf, PDMCRITSECT_STRICT_ARGS_PASS_ON);
+    return pdmR3CritSectEnterContended(pCritSect, hNativeSelf, PDMCRITSECT_STRICT_POS_ARGS);
 #else
     /*
@@ -245 +245 @@
 {
 #ifndef PDMCRITSECT_STRICT
-    return pdmCritSectEnter(pCritSect, rcBusy, PDMCRITSECT_STRICT_ARGS_PASS_ON);
+    return pdmCritSectEnter(pCritSect, rcBusy, PDMCRITSECT_STRICT_POS_ARGS);
 #else
     /* No need for a second code instance. */
@@ -274 +274 @@
 {
 #ifdef PDMCRITSECT_STRICT
-    return pdmCritSectEnter(pCritSect, rcBusy, PDMCRITSECT_STRICT_ARGS_PASS_ON);
+    return pdmCritSectEnter(pCritSect, rcBusy, PDMCRITSECT_STRICT_POS_ARGS);
 #else
     /* No need for a second code instance. */
@@ -292 +292 @@
  * @param   pCritSect   The critical section.
  */
-static int pdmCritSectTryEnter(PPDMCRITSECT pCritSect, PDMCRITSECT_STRICT_ARGS_DECL)
+static int pdmCritSectTryEnter(PPDMCRITSECT pCritSect, PDMCRITSECT_STRICT_POS_DECL)
 {
     /*
@@ -307 +307 @@
     /* Not owned ... */
     if (ASMAtomicCmpXchgS32(&pCritSect->s.Core.cLockers, 0, -1))
-        return pdmCritSectEnterFirst(pCritSect, hNativeSelf, PDMCRITSECT_STRICT_ARGS_PASS_ON);
+        return pdmCritSectEnterFirst(pCritSect, hNativeSelf, PDMCRITSECT_STRICT_POS_ARGS);
 
     /* ... or nested. */
@@ -346 +346 @@
 {
 #ifndef PDMCRITSECT_STRICT
-    return pdmCritSectTryEnter(pCritSect, PDMCRITSECT_STRICT_ARGS_PASS_ON);
+    return pdmCritSectTryEnter(pCritSect, PDMCRITSECT_STRICT_POS_ARGS);
 #else
     /* No need for a second code instance. */
@@ -374 +374 @@
 {
 #ifdef PDMCRITSECT_STRICT
-    return pdmCritSectTryEnter(pCritSect, PDMCRITSECT_STRICT_ARGS_PASS_ON);
+    return pdmCritSectTryEnter(pCritSect, PDMCRITSECT_STRICT_POS_ARGS);
 #else
     /* No need for a second code instance. */