Changeset 25382 in vbox for trunk/src/VBox/Runtime

Timestamp:

Dec 15, 2009 12:30:34 AM (15 years ago)

Author:

vboxsync

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

56006

Message:

semmutex-win.cpp: Use a structure instead of storing the native handle as the IPRT handle. This allows for the same parameter checking as elsewhere as well as lock validation.

Location:

trunk/src/VBox/Runtime

Files:

• r3/win/semmutex-win.cpp (modified) (4 diffs)
• testcase/Makefile.kmk (modified) (2 diffs)

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

@@ -37 +37 @@
 
 #include <iprt/semaphore.h>
+#include "internal/iprt.h"
+
+#include <iprt/assert.h>
+#include <iprt/asm.h>
+#include <iprt/err.h>
+#include <iprt/lockvalidator.h>
+#include <iprt/mem.h>
 #include <iprt/thread.h>
-#include <iprt/assert.h>
-#include <iprt/err.h>
+#include "internal/magics.h"
 #include "internal/strict.h"
 
@@ -46 +52 @@
 *   Defined Constants And Macros                                               *
 *******************************************************************************/
-/** Converts semaphore to win32 handle. */
-#define SEM2HND(Sem) ((HANDLE)(uintptr_t)Sem)
+/** Posix internal representation of a Mutex semaphore. */
+struct RTSEMMUTEXINTERNAL
+{
+    /** Magic value (RTSEMMUTEX_MAGIC). */
+    uint32_t            u32Magic;
+    /** The mutex handle. */
+    HANDLE              hMtx;
+#ifdef RTSEMMUTEX_STRICT
+    /** Lock validator record associated with this mutex. */
+    RTLOCKVALIDATORREC  ValidatorRec;
+#endif
+};
 
 
@@ -57 +73 @@
 RTDECL(int)  RTSemMutexCreate(PRTSEMMUTEX pMutexSem)
 {
+    int rc;
+
     /*
      * Create the semaphore.
      */
-    HANDLE hmtx = CreateMutex(NULL, FALSE, NULL);
-    if (hmtx)
+    HANDLE hMtx = CreateMutex(NULL, FALSE, NULL);
+    if (hMtx)
     {
-        *pMutexSem = (RTSEMMUTEX)(void *)hmtx;
+        RTSEMMUTEXINTERNAL *pThis = (RTSEMMUTEXINTERNAL *)RTMemAlloc(sizeof(*pThis));
+        if (pThis)
+        {
+            pThis->u32Magic = RTSEMMUTEX_MAGIC;
+            pThis->hMtx = hMtx;
+#ifdef RTSEMMUTEX_STRICT
+            RTLockValidatorInit(&pThis->ValidatorRec,  NIL_RTLOCKVALIDATORCLASS, RTLOCKVALIDATOR_SUB_CLASS_NONE, NULL, pThis);
+#endif
+            *pMutexSem = pThis;
+            return VINF_SUCCESS;
+        }
+
+        rc = VERR_NO_MEMORY;
+    }
+    else
+        rc = RTErrConvertFromWin32(GetLastError());
+    return rc;
+}
+
+
+RTDECL(int)  RTSemMutexDestroy(RTSEMMUTEX MutexSem)
+{
+    /*
+     * Validate.
+     */
+    RTSEMMUTEXINTERNAL *pThis = MutexSem;
+    if (pThis == NIL_RTSEMMUTEX)
         return VINF_SUCCESS;
+    AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
+    AssertReturn(pThis->u32Magic == RTSEMMUTEX_MAGIC, VERR_INVALID_HANDLE);
+
+    /*
+     * Close semaphore handle.
+     */
+    AssertReturn(ASMAtomicCmpXchgU32(&pThis->u32Magic, RTSEMMUTEX_MAGIC_DEAD, RTSEMMUTEX_MAGIC), VERR_INVALID_HANDLE);
+    HANDLE hMtx = pThis->hMtx;
+    ASMAtomicWritePtr((void * volatile *)&pThis->hMtx, (void *)INVALID_HANDLE_VALUE);
+
+    int rc = VINF_SUCCESS;
+    if (!CloseHandle(hMtx))
+    {
+        rc = RTErrConvertFromWin32(GetLastError());
+        AssertMsgFailed(("%p rc=%d lasterr=%d\n", pThis->hMtx, rc, GetLastError()));
     }
 
-    return RTErrConvertFromWin32(GetLastError());
-}
-
-
-RTDECL(int)  RTSemMutexDestroy(RTSEMMUTEX MutexSem)
-{
-    /*
-     * Close semaphore handle.
-     */
-    if (CloseHandle(SEM2HND(MutexSem)))
-        return VINF_SUCCESS;
-    AssertMsgFailed(("Destroy MutexSem %p failed, lasterr=%d\n", MutexSem, GetLastError()));
-    return RTErrConvertFromWin32(GetLastError());
-}
-
-
-RTDECL(int)  RTSemMutexRequestNoResume(RTSEMMUTEX MutexSem, unsigned cMillies)
-{
+#ifdef RTSEMMUTEX_STRICT
+    RTLockValidatorDelete(&pThis->ValidatorRec);
+#endif
+    RTMemFree(pThis);
+    return rc;
+}
+
+
+/**
+ * Internal worker for RTSemMutexRequestNoResume and it's debug companion.
+ *
+ * @returns Same as RTSEmMutexRequestNoResume
+ * @param   MutexSem                    The mutex handle.
+ * @param   cMillies                    The number of milliseconds to wait.
+ * @param   TSEMMUTEX_STRICT_POS_DECL   The source position of the caller.
+ */
+DECL_FORCE_INLINE(int) rtSemMutexRequestNoResume(RTSEMMUTEX MutexSem, unsigned cMillies, RTSEMMUTEX_STRICT_POS_DECL)
+{
+    /*
+     * Validate.
+     */
+    RTSEMMUTEXINTERNAL *pThis = MutexSem;
+    AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
+    AssertReturn(pThis->u32Magic == RTSEMMUTEX_MAGIC, VERR_INVALID_HANDLE);
+
+#ifdef RTSEMMUTEX_STRICT
+    RTTHREAD hThreadSelf = RTThreadSelfAutoAdopt();
+    RTLockValidatorCheckOrder(&pThis->ValidatorRec, hThreadSelf, RTSEMMUTEX_STRICT_POS_ARGS);
+#else
+    RTTHREAD hThreadSelf = RTThreadSelf();
+#endif
+
     /*
      * Lock mutex semaphore.
      */
-    int rc = WaitForSingleObjectEx(SEM2HND(MutexSem), cMillies == RT_INDEFINITE_WAIT ? INFINITE : cMillies, TRUE);
+    if (cMillies > 0)
+        RTThreadBlocking(hThreadSelf, RTTHREADSTATE_MUTEX, RTSEMMUTEX_STRICT_BLOCK_ARGS(&pThis->ValidatorRec));
+    int rc = WaitForSingleObjectEx(pThis->hMtx,
+                                   cMillies == RT_INDEFINITE_WAIT ? INFINITE : cMillies,
+                                   TRUE /*bAlertable*/);
+    RTThreadUnblocked(hThreadSelf, RTTHREADSTATE_MUTEX);
     switch (rc)
     {
         case WAIT_OBJECT_0:
-        {
-#ifdef RTSEMMUTEX_STRICT
-            RTTHREAD Thread = RTThreadSelf();
-            if (Thread != NIL_RTTHREAD)
-                RTThreadWriteLockInc(Thread);
+#ifdef RTSEMMUTEX_STRICT
+            RTThreadWriteLockInc(RTLockValidatorSetOwner(&pThis->ValidatorRec, hThreadSelf, RTSEMMUTEX_STRICT_POS_ARGS));
 #endif
             return VINF_SUCCESS;
-        }
 
         case WAIT_TIMEOUT:          return VERR_TIMEOUT;
@@ -118 +192 @@
 
 
-RTDECL(int)  RTSemMutexRequestNoResumeDebug(RTSEMMUTEX MutexSem, unsigned cMillies, RTHCUINTPTR uId, RT_SRC_POS_DECL)
-{
+RTDECL(int) RTSemMutexRequestNoResume(RTSEMMUTEX MutexSem, unsigned cMillies)
+{
+#ifndef RTSEMMUTEX_STRICT
+    return rtSemMutexRequestNoResume(MutexSem, cMillies, RTSEMMUTEX_STRICT_POS_ARGS);
+#else
+    return RTSemMutexRequestNoResumeDebug(MutexSem, cMillies, (uintptr_t)ASMReturnAddress(), RT_SRC_POS);
+#endif
+}
+
+
+RTDECL(int) RTSemMutexRequestNoResumeDebug(RTSEMMUTEX MutexSem, unsigned cMillies, RTHCUINTPTR uId, RT_SRC_POS_DECL)
+{
+#ifdef RTSEMMUTEX_STRICT
+    return rtSemMutexRequestNoResume(MutexSem, cMillies, RTSEMMUTEX_STRICT_POS_ARGS);
+#else
     return RTSemMutexRequestNoResume(MutexSem, cMillies);
-}
-
-
-RTDECL(int)  RTSemMutexRelease(RTSEMMUTEX MutexSem)
-{
+#endif
+}
+
+
+RTDECL(int) RTSemMutexRelease(RTSEMMUTEX MutexSem)
+{
+    /*
+     * Validate.
+     */
+    RTSEMMUTEXINTERNAL *pThis = MutexSem;
+    AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
+    AssertReturn(pThis->u32Magic == RTSEMMUTEX_MAGIC, VERR_INVALID_HANDLE);
+
     /*
      * Unlock mutex semaphore.
      */
 #ifdef RTSEMMUTEX_STRICT
-    RTTHREAD Thread = RTThreadSelf();
-    if (Thread != NIL_RTTHREAD)
-        RTThreadWriteLockDec(Thread);
-#endif
-    if (ReleaseMutex(SEM2HND(MutexSem)))
+    if (   pThis->ValidatorRec.hThread != NIL_RTTHREAD
+        && pThis->ValidatorRec.hThread == RTThreadSelf())
+        RTThreadWriteLockDec(RTLockValidatorUnsetOwner(&pThis->ValidatorRec));
+    else
+        AssertMsgFailed(("%p hThread=%RTthrd\n", pThis, pThis->ValidatorRec.hThread));
+#endif
+    if (ReleaseMutex(pThis->hMtx))
         return VINF_SUCCESS;
-
-#ifdef RTSEMMUTEX_STRICT
-    if (Thread != NIL_RTTHREAD)
-        RTThreadWriteLockInc(Thread);
-#endif
-    AssertMsgFailed(("Release MutexSem %p failed, lasterr=%d\n", MutexSem, GetLastError()));
-    return RTErrConvertFromWin32(GetLastError());
-}
-
+    int rc = RTErrConvertFromWin32(GetLastError());
+    AssertMsgFailed(("%p/%p, rc=%Rrc lasterr=%d\n", pThis, pThis->hMtx, rc, GetLastError()));
+    return rc;
+}
+

trunk/src/VBox/Runtime/testcase/Makefile.kmk

@@ -92 +92 @@
         tstSems \
         tstSemEvent \
+        tstSemMutex \
         tstSemPingPong \
         tstRTStrCache \
@@ -124 +125 @@
         tstInlineAsmPIC \
         tstInlineAsmPIC3 \
-        tstSemMutex \
         tstSemRW
 PROGRAMS.l4 += \