Changeset 25624 in vbox

Timestamp:

Jan 3, 2010 3:23:27 PM (15 years ago)

Author:

vboxsync

Message:

iprt/semmutex*: Added RTSemMutexIsOwned. Rewrote mutex recursion handling for windows (semmutex-win.cpp).

Location:

trunk

Files:

• include/iprt/semaphore.h (modified) (1 diff)
• src/VBox/Runtime/r3/linux/semmutex-linux.cpp (modified) (1 diff)
• src/VBox/Runtime/r3/os2/sems-os2.cpp (modified) (1 diff)
• src/VBox/Runtime/r3/posix/semmutex-posix.cpp (modified) (2 diffs)
• src/VBox/Runtime/r3/win/semmutex-win.cpp (modified) (7 diffs)

trunk/include/iprt/semaphore.h

@@ -281 +281 @@
  */
 RTDECL(int)  RTSemMutexRelease(RTSEMMUTEX MutexSem);
+
+/**
+ * Checks if the mutex semaphore is owned or not.
+ *
+ * @returns true if owned, false if not.
+ * @param   hMutex              The mutex semaphore.
+ */
+RTDECL(bool) RTSemMutexIsOwned(RTSEMMUTEX hMutex);
 
 /* Strict build: Remap the two request calls to the debug versions. */

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

@@ -409 +409 @@
 }
 
+
+RTDECL(bool) RTSemMutexIsOwned(RTSEMMUTEX hMutex)
+{
+    /*
+     * Validate.
+     */
+    RTSEMMUTEXINTERNAL *pThis = hMutex;
+    AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
+    AssertReturn(pThis->u32Magic == RTSEMMUTEX_MAGIC, VERR_INVALID_HANDLE);
+
+    return pThis->Owner != (pthread_t)~0;
+}
+

trunk/src/VBox/Runtime/r3/os2/sems-os2.cpp

@@ -279 +279 @@
 
 
-
+RTDECL(bool) RTSemMutexIsOwned(RTSEMMUTEX hMutex);
+{
+    /*
+     * Unlock mutex semaphore.
+     */
+    PID     pid;
+    TID     tid;
+    ULONG   cRecursions;
+    int rc = DosQueryMutexSem(SEM2HND(MutexSem), &pid, &tid, &cRecursions);
+    if (!rc)
+        return cRecursions != 0;
+    AssertMsgFailed(("DosQueryMutexSem %p failed, rc=%d\n", MutexSem, rc));
+    return rc == ERROR_SEM_OWNER_DIED;
+}
+
+
+

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

@@ -331 +331 @@
      */
     pThis->Owner = (pthread_t)-1;
-    ASMAtomicXchgU32(&pThis->cNesting, 0);
+    ASMAtomicWriteU32(&pThis->cNesting, 0);
 
     /*
@@ -346 +346 @@
 }
 
+
+RTDECL(bool) RTSemMutexIsOwned(RTSEMMUTEX hMutex)
+{
+    /*
+     * Validate.
+     */
+    RTSEMMUTEXINTERNAL *pThis = hMutex;
+    AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
+    AssertReturn(pThis->u32Magic == RTSEMMUTEX_MAGIC, VERR_INVALID_HANDLE);
+
+    return pThis->Owner != (pthread_t)-1;
+}
+

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

@@ -56 +56 @@
 {
     /** Magic value (RTSEMMUTEX_MAGIC). */
-    uint32_t            u32Magic;
+    uint32_t                u32Magic;
+    /** Recursion count. */
+    uint32_t volatile       cRecursions;
+    /** The owner thread. */
+    RTNATIVETHREAD volatile hNativeOwner;
     /** The mutex handle. */
-    HANDLE              hMtx;
+    HANDLE                  hMtx;
 #ifdef RTSEMMUTEX_STRICT
     /** Lock validator record associated with this mutex. */
-    RTLOCKVALRECEXCL    ValidatorRec;
+    RTLOCKVALRECEXCL        ValidatorRec;
 #endif
 };
@@ -84 +88 @@
         if (pThis)
         {
-            pThis->u32Magic = RTSEMMUTEX_MAGIC;
-            pThis->hMtx = hMtx;
+            pThis->u32Magic     = RTSEMMUTEX_MAGIC;
+            pThis->hMtx         = hMtx;
+            pThis->hNativeOwner = NIL_RTNATIVETHREAD;
+            pThis->cRecursions  = 0;
 #ifdef RTSEMMUTEX_STRICT
             RTLockValidatorRecExclInit(&pThis->ValidatorRec,  NIL_RTLOCKVALIDATORCLASS, RTLOCKVALIDATOR_SUB_CLASS_NONE, "RTSemMutex", pThis);
@@ -152 +158 @@
 
     /*
+     * Check for recursive entry.
+     */
+    RTNATIVETHREAD hNativeSelf = RTThreadNativeSelf();
+    RTNATIVETHREAD hNativeOwner;
+    ASMAtomicReadHandle(&pThis->hNativeOwner, hNativeOwner);
+    if (hNativeOwner == hNativeSelf)
+    {
+#ifdef RTSEMMUTEX_STRICT
+        int rc9 = RTLockValidatorRecExclRecursion(&pThis->ValidatorRec, pSrcPos);
+        if (RT_FAILURE(rc9))
+            return rc9;
+#endif
+        ASMAtomicIncU32(&pThis->cRecursions);
+        return VINF_SUCCESS;
+    }
+
+    /*
      * Lock mutex semaphore.
      */
-    RTTHREAD hThreadSelf = NIL_RTTHREAD;
+    RTTHREAD        hThreadSelf = NIL_RTTHREAD;
     if (cMillies > 0)
     {
@@ -175 +198 @@
         case WAIT_OBJECT_0:
 #ifdef RTSEMMUTEX_STRICT
-            RTLockValidatorRecExclSetOwner(&pThis->ValidatorRec, hThreadSelf, pSrcPos, false /* we don't know */);
-#endif
-/** @todo record who owns this thing and avoid kernel calls during recursion. */
+            RTLockValidatorRecExclSetOwner(&pThis->ValidatorRec, hThreadSelf, pSrcPos, true);
+#endif
+            ASMAtomicWriteHandle(&pThis->hNativeOwner, hNativeSelf);
+            ASMAtomicWriteU32(&pThis->cRecursions, 1);
             return VINF_SUCCESS;
 
@@ -224 +248 @@
     AssertReturn(pThis->u32Magic == RTSEMMUTEX_MAGIC, VERR_INVALID_HANDLE);
 
+    /*
+     * Check ownership and recursions.
+     */
+    RTNATIVETHREAD hNativeSelf = RTThreadNativeSelf();
+    RTNATIVETHREAD hNativeOwner;
+    ASMAtomicReadHandle(&pThis->hNativeOwner, hNativeOwner);
+    if (RT_UNLIKELY(hNativeOwner != hNativeSelf))
+    {
+        AssertMsgFailed(("Not owner of mutex %p!! hNativeSelf=%RTntrd Owner=%RTntrd cRecursions=%d\n",
+                         pThis, hNativeSelf, hNativeOwner, pThis->cRecursions));
+        return VERR_NOT_OWNER;
+    }
+    if (pThis->cRecursions > 1)
+    {
+#ifdef RTSEMMUTEX_STRICT
+        int rc9 = RTLockValidatorRecExclUnwind(&pThis->ValidatorRec);
+        if (RT_FAILURE(rc9))
+            return rc9;
+#endif
+        ASMAtomicDecU32(&pThis->cRecursions);
+        return VINF_SUCCESS;
+    }
+
+    /*
+     * Unlock mutex semaphore.
+     */
 #ifdef RTSEMMUTEX_STRICT
     int rc9 = RTLockValidatorRecExclReleaseOwner(&pThis->ValidatorRec, false);
@@ -229 +279 @@
         return rc9;
 #endif
-
-    /*
-     * Unlock mutex semaphore.
-     */
+    ASMAtomicWriteU32(&pThis->cRecursions, 0);
+    ASMAtomicWriteHandle(&pThis->hNativeOwner, NIL_RTNATIVETHREAD);
+
     if (ReleaseMutex(pThis->hMtx))
         return VINF_SUCCESS;
+
     int rc = RTErrConvertFromWin32(GetLastError());
     AssertMsgFailed(("%p/%p, rc=%Rrc lasterr=%d\n", pThis, pThis->hMtx, rc, GetLastError()));
@@ -240 +290 @@
 }
 
+
+RTDECL(bool) RTSemMutexIsOwned(RTSEMMUTEX hMutex)
+{
+    /*
+     * Validate.
+     */
+    RTSEMMUTEXINTERNAL *pThis = hMutex;
+    AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
+    AssertReturn(pThis->u32Magic == RTSEMMUTEX_MAGIC, VERR_INVALID_HANDLE);
+
+    RTNATIVETHREAD hNativeOwner;
+    ASMAtomicReadHandle(&pThis->hNativeOwner, hNativeOwner);
+    return hNativeOwner == NIL_RTNATIVETHREAD;
+}
+