Changeset 45110 in vbox for trunk/src

Timestamp:

Mar 20, 2013 6:17:29 PM (12 years ago)

Author:

vboxsync

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

84403

Message:

Raw conversion of semrw-lockless-generic.cpp into RTCritSectEx.

Location:

trunk/src/VBox/Runtime

Files:

• Makefile.kmk (modified) (1 diff)
• common/misc/lockvalidator.cpp (modified) (2 diffs)
• generic/cdrom-generic.cpp (modified) (1 diff)
• generic/critsectrw-generic.cpp (copied) (copied from trunk/src/VBox/Runtime/generic/semrw-lockless-generic.cpp ) (44 diffs)
• generic/semrw-lockless-generic.cpp (modified) (2 diffs)
• include/internal/strict.h (modified) (2 diffs)

trunk/src/VBox/Runtime/Makefile.kmk

@@ -448 +448 @@
         generic/createtemp-generic.cpp \
         generic/critsect-generic.cpp \
+        generic/critsectrw-generic.cpp \
         generic/env-generic.cpp \
         generic/RTDirCreateUniqueNumbered-generic.cpp \

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

@@ -3439 +3439 @@
 
 
+RTDECL(int)  RTLockValidatorRecSharedCreateV(PRTLOCKVALRECSHRD *ppRec, RTLOCKVALCLASS hClass,
+                                             uint32_t uSubClass, void *pvLock, bool fSignaller, bool fEnabled,
+                                             const char *pszNameFmt, va_list va)
+{
+    PRTLOCKVALRECSHRD pRec;
+    *ppRec = pRec = (PRTLOCKVALRECSHRD)RTMemAlloc(sizeof(*pRec));
+    if (!pRec)
+        return VERR_NO_MEMORY;
+    RTLockValidatorRecSharedInitV(pRec, hClass, uSubClass, pvLock, fSignaller, fEnabled, pszNameFmt, va);
+    return VINF_SUCCESS;
+}
+
+
+RTDECL(int)  RTLockValidatorRecSharedCreate(PRTLOCKVALRECSHRD *ppRec, RTLOCKVALCLASS hClass,
+                                            uint32_t uSubClass, void *pvLock, bool fSignaller, bool fEnabled,
+                                            const char *pszNameFmt, ...)
+{
+    va_list va;
+    va_start(va, pszNameFmt);
+    int rc = RTLockValidatorRecSharedCreateV(ppRec, hClass, uSubClass, pvLock, fSignaller, fEnabled, pszNameFmt, va);
+    va_end(va);
+    return rc;
+}
+
+
 RTDECL(void) RTLockValidatorRecSharedDelete(PRTLOCKVALRECSHRD pRec)
 {
@@ -3476 +3501 @@
     if (hClass != NIL_RTLOCKVALCLASS)
         RTLockValidatorClassRelease(hClass);
+}
+
+
+RTDECL(void) RTLockValidatorRecSharedDestroy(PRTLOCKVALRECSHRD *ppRec)
+{
+    PRTLOCKVALRECSHRD pRec = *ppRec;
+    *ppRec = NULL;
+    if (pRec)
+    {
+        RTLockValidatorRecSharedDelete(pRec);
+        RTMemFree(pRec);
+    }
 }
 

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

@@ -29 +29 @@
 *   Header Files                                                               *
 *******************************************************************************/
-#define RTCRITSECT_WITHOUT_REMAPPING
 #include <iprt/cdrom.h>
 #include "internal/iprt.h"

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

@@ -1 +1 @@
 /* $Id$ */
 /** @file
- * IPRT - Read-Write Semaphore, Generic, lockless variant.
+ * IPRT - Read/Write Critical Section, Generic.
  */
 
@@ -29 +29 @@
 *   Header Files                                                               *
 *******************************************************************************/
-#define RTSEMRW_WITHOUT_REMAPPING
+#define RTCRITSECTRW_WITHOUT_REMAPPING
 #define RTASSERT_QUIET
-#include <iprt/semaphore.h>
+#include <iprt/critsect.h>
 #include "internal/iprt.h"
 
@@ -39 +39 @@
 #include <iprt/lockvalidator.h>
 #include <iprt/mem.h>
+#include <iprt/semaphore.h>
 #include <iprt/thread.h>
 
 #include "internal/magics.h"
 #include "internal/strict.h"
-
-
-/*******************************************************************************
-*   Structures and Typedefs                                                    *
-*******************************************************************************/
-typedef struct RTSEMRWINTERNAL
-{
-    /** Magic value (RTSEMRW_MAGIC).  */
-    uint32_t volatile       u32Magic;
-    uint32_t                u32Padding; /**< alignment padding.*/
-    /* The state variable.
-     * All accesses are atomic and it bits are defined like this:
-     *      Bits 0..14  - cReads.
-     *      Bit 15      - Unused.
-     *      Bits 16..31 - cWrites. - doesn't make sense here
-     *      Bit 31      - fDirection; 0=Read, 1=Write.
-     *      Bits 32..46 - cWaitingReads
-     *      Bit 47      - Unused.
-     *      Bits 48..62 - cWaitingWrites
-     *      Bit 63      - Unused.
-     */
-    uint64_t volatile       u64State;
-    /** The write owner. */
-    RTNATIVETHREAD volatile hNativeWriter;
-    /** The number of reads made by the current writer. */
-    uint32_t volatile       cWriterReads;
-    /** The number of recursions made by the current writer. (The initial grabbing
-     *  of the lock counts as the first one.) */
-    uint32_t volatile       cWriteRecursions;
-
-    /** What the writer threads are blocking on. */
-    RTSEMEVENT              hEvtWrite;
-    /** What the read threads are blocking on when waiting for the writer to
-     * finish. */
-    RTSEMEVENTMULTI         hEvtRead;
-    /** Indicates whether hEvtRead needs resetting. */
-    bool volatile           fNeedReset;
-
-#ifdef RTSEMRW_STRICT
-    /** The validator record for the writer. */
-    RTLOCKVALRECEXCL        ValidatorWrite;
-    /** The validator record for the readers. */
-    RTLOCKVALRECSHRD        ValidatorRead;
-#endif
-} RTSEMRWINTERNAL;
 
 
@@ -93 +49 @@
 *   Defined Constants And Macros                                               *
 *******************************************************************************/
-#define RTSEMRW_CNT_BITS            15
-#define RTSEMRW_CNT_MASK            UINT64_C(0x00007fff)
-
-#define RTSEMRW_CNT_RD_SHIFT        0
-#define RTSEMRW_CNT_RD_MASK         (RTSEMRW_CNT_MASK << RTSEMRW_CNT_RD_SHIFT)
-#define RTSEMRW_CNT_WR_SHIFT        16
-#define RTSEMRW_CNT_WR_MASK         (RTSEMRW_CNT_MASK << RTSEMRW_CNT_WR_SHIFT)
-#define RTSEMRW_DIR_SHIFT           31
-#define RTSEMRW_DIR_MASK            RT_BIT_64(RTSEMRW_DIR_SHIFT)
-#define RTSEMRW_DIR_READ            UINT64_C(0)
-#define RTSEMRW_DIR_WRITE           UINT64_C(1)
-
-#define RTSEMRW_WAIT_CNT_RD_SHIFT   32
-#define RTSEMRW_WAIT_CNT_RD_MASK    (RTSEMRW_CNT_MASK << RTSEMRW_WAIT_CNT_RD_SHIFT)
-//#define RTSEMRW_WAIT_CNT_WR_SHIFT   48
-//#define RTSEMRW_WAIT_CNT_WR_MASK    (RTSEMRW_CNT_MASK << RTSEMRW_WAIT_CNT_WR_SHIFT)
-
-
-RTDECL(int) RTSemRWCreate(PRTSEMRW phRWSem)
-{
-    return RTSemRWCreateEx(phRWSem, 0 /*fFlags*/, NIL_RTLOCKVALCLASS, RTLOCKVAL_SUB_CLASS_NONE, "RTSemRW");
-}
-RT_EXPORT_SYMBOL(RTSemRWCreate);
-
-
-RTDECL(int) RTSemRWCreateEx(PRTSEMRW phRWSem, uint32_t fFlags,
-                            RTLOCKVALCLASS hClass, uint32_t uSubClass, const char *pszNameFmt, ...)
-{
-    AssertReturn(!(fFlags & ~RTSEMRW_FLAGS_NO_LOCK_VAL), VERR_INVALID_PARAMETER);
-
-    RTSEMRWINTERNAL *pThis = (RTSEMRWINTERNAL *)RTMemAlloc(sizeof(*pThis));
-    if (!pThis)
-        return VERR_NO_MEMORY;
-
-    int rc = RTSemEventMultiCreate(&pThis->hEvtRead);
+/* Note! Using RTCSRW instead of RTCRITSECTRW to save space. */
+#define RTCSRW_CNT_BITS            15
+#define RTCSRW_CNT_MASK            UINT64_C(0x00007fff)
+
+#define RTCSRW_CNT_RD_SHIFT        0
+#define RTCSRW_CNT_RD_MASK         (RTCSRW_CNT_MASK << RTCSRW_CNT_RD_SHIFT)
+#define RTCSRW_CNT_WR_SHIFT        16
+#define RTCSRW_CNT_WR_MASK         (RTCSRW_CNT_MASK << RTCSRW_CNT_WR_SHIFT)
+#define RTCSRW_DIR_SHIFT           31
+#define RTCSRW_DIR_MASK            RT_BIT_64(RTCSRW_DIR_SHIFT)
+#define RTCSRW_DIR_READ            UINT64_C(0)
+#define RTCSRW_DIR_WRITE           UINT64_C(1)
+
+#define RTCSRW_WAIT_CNT_RD_SHIFT   32
+#define RTCSRW_WAIT_CNT_RD_MASK    (RTCSRW_CNT_MASK << RTCSRW_WAIT_CNT_RD_SHIFT)
+//#define RTCSRW_WAIT_CNT_WR_SHIFT   48
+//#define RTCSRW_WAIT_CNT_WR_MASK    (RTCSRW_CNT_MASK << RTCSRW_WAIT_CNT_WR_SHIFT)
+
+
+RTDECL(int) RTCritSectRwInit(PRTCRITSECTRW pThis)
+{
+    return RTCritSectRwInitEx(pThis, 0, NIL_RTLOCKVALCLASS, RTLOCKVAL_SUB_CLASS_NONE, "RTCritSectRw");
+}
+RT_EXPORT_SYMBOL(RTCritSectRwInit);
+
+
+RTDECL(int) RTCritSectRwInitEx(PRTCRITSECTRW pThis, uint32_t fFlags,
+                               RTLOCKVALCLASS hClass, uint32_t uSubClass, const char *pszNameFmt, ...)
+{
+    int rc;
+    AssertReturn(!(fFlags & ~( RTCRITSECT_FLAGS_NO_NESTING | RTCRITSECT_FLAGS_NO_LOCK_VAL | RTCRITSECT_FLAGS_BOOTSTRAP_HACK
+                              | RTCRITSECT_FLAGS_NOP )),
+                 VERR_INVALID_PARAMETER);
+
+    /*
+     * Initialize the structure, allocate the lock validator stuff and sems.
+     */
+    pThis->u32Magic         = RTCRITSECTRW_MAGIC_DEAD;
+    pThis->fNeedReset       = false;
+    pThis->u64State         = 0;
+    pThis->hNativeWriter    = NIL_RTNATIVETHREAD;
+    pThis->cWriterReads     = 0;
+    pThis->cWriteRecursions = 0;
+    pThis->hEvtWrite        = NIL_RTSEMEVENT;
+    pThis->hEvtRead         = NIL_RTSEMEVENTMULTI;
+    pThis->pValidatorWrite  = NULL;
+    pThis->pValidatorRead   = NULL;
+#if HC_ARCH_BITS == 32
+    pThis->HCPtrPadding     = NIL_RTHCPTR;
+#endif
+
+#ifdef RTCRITSECTRW_STRICT
+    bool const fLVEnabled = !(fFlags & RTSEMRW_FLAGS_NO_LOCK_VAL);
+    if (!pszNameFmt)
+    {
+        static uint32_t volatile s_iAnon = 0;
+        uint32_t i = ASMAtomicIncU32(&s_iAnon) - 1;
+        rc = RTLockValidatorRecExclCreate(&pThis->pValidatorWrite, hClass, uSubClass, pThis,
+                                          fLVEnabled, "RTCritSectRw-%u", i);
+        if (RT_SUCCESS(rc))
+            rc = RTLockValidatorRecSharedCreate(&pThis->pValidatorRead, hClass, uSubClass, pThis,
+                                                false /*fSignaller*/, fLVEnabled, "RTCritSectRw-%u", i);
+    }
+    else
+    {
+        va_list va;
+        va_start(va, pszNameFmt);
+        rc = RTLockValidatorRecExclCreateV(&pThis->pValidatorWrite, hClass, uSubClass, pThis,
+                                           fLVEnabled, pszNameFmt, va);
+        va_end(va);
+        if (RT_SUCCESS(rc))
+        {
+            va_start(va, pszNameFmt);
+            RTLockValidatorRecSharedCreateV(&pThis->pValidatorRead, hClass, uSubClass, pThis,
+                                            false /*fSignaller*/, fLVEnabled, pszNameFmt, va);
+            va_end(va);
+        }
+    }
     if (RT_SUCCESS(rc))
-    {
-        rc = RTSemEventCreate(&pThis->hEvtWrite);
+        rc = RTLockValidatorRecMakeSiblings(&pThis->pValidatorWrite->Core, &pThis->pValidatorRead->Core);
+
+    if (RT_SUCCESS(rc))
+#endif
+    {
+        rc = RTSemEventMultiCreate(&pThis->hEvtRead);
         if (RT_SUCCESS(rc))
         {
-            pThis->u32Magic             = RTSEMRW_MAGIC;
-            pThis->u32Padding           = 0;
-            pThis->u64State             = 0;
-            pThis->hNativeWriter        = NIL_RTNATIVETHREAD;
-            pThis->cWriterReads         = 0;
-            pThis->cWriteRecursions     = 0;
-            pThis->fNeedReset           = false;
-#ifdef RTSEMRW_STRICT
-            bool const fLVEnabled = !(fFlags & RTSEMRW_FLAGS_NO_LOCK_VAL);
-            if (!pszNameFmt)
-            {
-                static uint32_t volatile s_iSemRWAnon = 0;
-                uint32_t i = ASMAtomicIncU32(&s_iSemRWAnon) - 1;
-                RTLockValidatorRecExclInit(&pThis->ValidatorWrite, hClass, uSubClass, pThis,
-                                           fLVEnabled, "RTSemRW-%u", i);
-                RTLockValidatorRecSharedInit(&pThis->ValidatorRead, hClass, uSubClass, pThis,
-                                             false /*fSignaller*/, fLVEnabled, "RTSemRW-%u", i);
-            }
-            else
-            {
-                va_list va;
-                va_start(va, pszNameFmt);
-                RTLockValidatorRecExclInitV(&pThis->ValidatorWrite, hClass, uSubClass, pThis,
-                                            fLVEnabled, pszNameFmt, va);
-                va_end(va);
-                va_start(va, pszNameFmt);
-                RTLockValidatorRecSharedInitV(&pThis->ValidatorRead, hClass, uSubClass, pThis,
-                                              false /*fSignaller*/, fLVEnabled, pszNameFmt, va);
-                va_end(va);
-            }
-            RTLockValidatorRecMakeSiblings(&pThis->ValidatorWrite.Core, &pThis->ValidatorRead.Core);
-#endif
-
-            *phRWSem = pThis;
-            return VINF_SUCCESS;
-        }
-        RTSemEventMultiDestroy(pThis->hEvtRead);
-    }
+            rc = RTSemEventCreate(&pThis->hEvtWrite);
+            if (RT_SUCCESS(rc))
+            {
+                pThis->u32Magic = RTCRITSECTRW_MAGIC;
+                return VINF_SUCCESS;
+            }
+            RTSemEventMultiDestroy(pThis->hEvtRead);
+        }
+    }
+
+#ifdef RTCRITSECTRW_STRICT
+    RTLockValidatorRecSharedDestroy(&pThis->pValidatorRead);
+    RTLockValidatorRecExclDestroy(&pThis->pValidatorWrite);
+#endif
     return rc;
 }
-RT_EXPORT_SYMBOL(RTSemRWCreateEx);
-
-
-RTDECL(int) RTSemRWDestroy(RTSEMRW hRWSem)
+RT_EXPORT_SYMBOL(RTCritSectRwInitEx);
+
+
+RTDECL(uint32_t) RTCritSectRwSetSubClass(PRTCRITSECTRW pThis, uint32_t uSubClass)
+{
+    AssertPtrReturn(pThis, RTLOCKVAL_SUB_CLASS_INVALID);
+    AssertReturn(pThis->u32Magic == RTCRITSECTRW_MAGIC, RTLOCKVAL_SUB_CLASS_INVALID);
+#ifdef RTCRITSECTRW_STRICT
+    AssertReturn(!(pThis->fFlags & RTCRITSECT_FLAGS_NOP), RTLOCKVAL_SUB_CLASS_INVALID);
+
+    RTLockValidatorRecSharedSetSubClass(pThis->pValidatorRead, uSubClass);
+    return RTLockValidatorRecExclSetSubClass(pThis->pValidatorWrite, uSubClass);
+#else
+    NOREF(uSubClass);
+    return RTLOCKVAL_SUB_CLASS_INVALID;
+#endif
+}
+RT_EXPORT_SYMBOL(RTCritSectRwSetSubClass);
+
+
+static int rtCritSectRwEnterShared(PRTCRITSECTRW pThis, PCRTLOCKVALSRCPOS pSrcPos, bool fTryOnly)
 {
     /*
      * Validate input.
      */
-    RTSEMRWINTERNAL *pThis = hRWSem;
-    if (pThis == NIL_RTSEMRW)
-        return VINF_SUCCESS;
-    AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
-    AssertReturn(pThis->u32Magic == RTSEMRW_MAGIC, VERR_INVALID_HANDLE);
-    Assert(!(ASMAtomicReadU64(&pThis->u64State) & (RTSEMRW_CNT_RD_MASK | RTSEMRW_CNT_WR_MASK)));
-
-    /*
-     * Invalidate the object and free up the resources.
-     */
-    AssertReturn(ASMAtomicCmpXchgU32(&pThis->u32Magic, ~RTSEMRW_MAGIC, RTSEMRW_MAGIC), VERR_INVALID_HANDLE);
-
-    RTSEMEVENTMULTI hEvtRead;
-    ASMAtomicXchgHandle(&pThis->hEvtRead, NIL_RTSEMEVENTMULTI, &hEvtRead);
-    int rc = RTSemEventMultiDestroy(hEvtRead);
-    AssertRC(rc);
-
-    RTSEMEVENT hEvtWrite;
-    ASMAtomicXchgHandle(&pThis->hEvtWrite, NIL_RTSEMEVENT, &hEvtWrite);
-    rc = RTSemEventDestroy(hEvtWrite);
-    AssertRC(rc);
-
-#ifdef RTSEMRW_STRICT
-    RTLockValidatorRecSharedDelete(&pThis->ValidatorRead);
-    RTLockValidatorRecExclDelete(&pThis->ValidatorWrite);
-#endif
-    RTMemFree(pThis);
-    return VINF_SUCCESS;
-}
-RT_EXPORT_SYMBOL(RTSemRWDestroy);
-
-
-RTDECL(uint32_t) RTSemRWSetSubClass(RTSEMRW hRWSem, uint32_t uSubClass)
-{
-#ifdef RTSEMRW_STRICT
-    /*
-     * Validate handle.
-     */
-    struct RTSEMRWINTERNAL *pThis = hRWSem;
-    AssertPtrReturn(pThis, RTLOCKVAL_SUB_CLASS_INVALID);
-    AssertReturn(pThis->u32Magic == RTSEMRW_MAGIC, RTLOCKVAL_SUB_CLASS_INVALID);
-
-    RTLockValidatorRecSharedSetSubClass(&pThis->ValidatorRead, uSubClass);
-    return RTLockValidatorRecExclSetSubClass(&pThis->ValidatorWrite, uSubClass);
-#else
-    return RTLOCKVAL_SUB_CLASS_INVALID;
-#endif
-}
-RT_EXPORT_SYMBOL(RTSemRWSetSubClass);
-
-
-static int rtSemRWRequestRead(RTSEMRW hRWSem, RTMSINTERVAL cMillies, bool fInterruptible, PCRTLOCKVALSRCPOS pSrcPos)
-{
-    /*
-     * Validate input.
-     */
-    RTSEMRWINTERNAL *pThis = hRWSem;
-    if (pThis == NIL_RTSEMRW)
-        return VINF_SUCCESS;
-    AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
-    AssertReturn(pThis->u32Magic == RTSEMRW_MAGIC, VERR_INVALID_HANDLE);
-
-#ifdef RTSEMRW_STRICT
+    AssertPtr(pThis);
+    AssertReturn(pThis->u32Magic == RTCRITSECTRW_MAGIC, VERR_SEM_DESTROYED);
+
+#ifdef RTCRITSECTRW_STRICT
     RTTHREAD hThreadSelf = RTThreadSelfAutoAdopt();
-    if (cMillies > 0)
+    if (!fTryOnly)
     {
         int            rc9;
@@ -251 +188 @@
         ASMAtomicUoReadHandle(&pThis->hNativeWriter, &hNativeWriter);
         if (hNativeWriter != NIL_RTTHREAD && hNativeWriter == RTThreadNativeSelf())
-            rc9 = RTLockValidatorRecExclCheckOrder(&pThis->ValidatorWrite, hThreadSelf, pSrcPos, cMillies);
+            rc9 = RTLockValidatorRecExclCheckOrder(pThis->pValidatorWrite, hThreadSelf, pSrcPos, RT_INDEFINITE_WAIT);
         else
-            rc9 = RTLockValidatorRecSharedCheckOrder(&pThis->ValidatorRead, hThreadSelf, pSrcPos, cMillies);
+            rc9 = RTLockValidatorRecSharedCheckOrder(pThis->pValidatorRead, hThreadSelf, pSrcPos, RT_INDEFINITE_WAIT);
         if (RT_FAILURE(rc9))
             return rc9;
@@ -267 +204 @@
     for (;;)
     {
-        if ((u64State & RTSEMRW_DIR_MASK) == (RTSEMRW_DIR_READ << RTSEMRW_DIR_SHIFT))
+        if ((u64State & RTCSRW_DIR_MASK) == (RTCSRW_DIR_READ << RTCSRW_DIR_SHIFT))
         {
             /* It flows in the right direction, try follow it before it changes. */
-            uint64_t c = (u64State & RTSEMRW_CNT_RD_MASK) >> RTSEMRW_CNT_RD_SHIFT;
+            uint64_t c = (u64State & RTCSRW_CNT_RD_MASK) >> RTCSRW_CNT_RD_SHIFT;
             c++;
-            Assert(c < RTSEMRW_CNT_MASK / 2);
-            u64State &= ~RTSEMRW_CNT_RD_MASK;
-            u64State |= c << RTSEMRW_CNT_RD_SHIFT;
+            Assert(c < RTCSRW_CNT_MASK / 2);
+            u64State &= ~RTCSRW_CNT_RD_MASK;
+            u64State |= c << RTCSRW_CNT_RD_SHIFT;
             if (ASMAtomicCmpXchgU64(&pThis->u64State, u64State, u64OldState))
             {
-#ifdef RTSEMRW_STRICT
-                RTLockValidatorRecSharedAddOwner(&pThis->ValidatorRead, hThreadSelf, pSrcPos);
+#ifdef RTCRITSECTRW_STRICT
+                RTLockValidatorRecSharedAddOwner(pThis->pValidatorRead, hThreadSelf, pSrcPos);
 #endif
                 break;
             }
         }
-        else if ((u64State & (RTSEMRW_CNT_RD_MASK | RTSEMRW_CNT_WR_MASK)) == 0)
+        else if ((u64State & (RTCSRW_CNT_RD_MASK | RTCSRW_CNT_WR_MASK)) == 0)
         {
             /* Wrong direction, but we're alone here and can simply try switch the direction. */
-            u64State &= ~(RTSEMRW_CNT_RD_MASK | RTSEMRW_CNT_WR_MASK | RTSEMRW_DIR_MASK);
-            u64State |= (UINT64_C(1) << RTSEMRW_CNT_RD_SHIFT) | (RTSEMRW_DIR_READ << RTSEMRW_DIR_SHIFT);
+            u64State &= ~(RTCSRW_CNT_RD_MASK | RTCSRW_CNT_WR_MASK | RTCSRW_DIR_MASK);
+            u64State |= (UINT64_C(1) << RTCSRW_CNT_RD_SHIFT) | (RTCSRW_DIR_READ << RTCSRW_DIR_SHIFT);
             if (ASMAtomicCmpXchgU64(&pThis->u64State, u64State, u64OldState))
             {
                 Assert(!pThis->fNeedReset);
-#ifdef RTSEMRW_STRICT
-                RTLockValidatorRecSharedAddOwner(&pThis->ValidatorRead, hThreadSelf, pSrcPos);
+#ifdef RTCRITSECTRW_STRICT
+                RTLockValidatorRecSharedAddOwner(pThis->pValidatorRead, hThreadSelf, pSrcPos);
 #endif
                 break;
@@ -305 +242 @@
             if (hNativeSelf == hNativeWriter)
             {
-#ifdef RTSEMRW_STRICT
-                int rc9 = RTLockValidatorRecExclRecursionMixed(&pThis->ValidatorWrite, &pThis->ValidatorRead.Core, pSrcPos);
+#ifdef RTCRITSECTRW_STRICT
+                int rc9 = RTLockValidatorRecExclRecursionMixed(pThis->pValidatorWrite, &pThis->pValidatorRead->Core, pSrcPos);
                 if (RT_FAILURE(rc9))
                     return rc9;
@@ -315 +252 @@
             }
 
-            /* If the timeout is 0, return already. */
-            if (!cMillies)
-                return VERR_TIMEOUT;
+            /* If we're only trying, return already. */
+            if (fTryOnly)
+                return VERR_SEM_BUSY;
 
             /* Add ourselves to the queue and wait for the direction to change. */
-            uint64_t c = (u64State & RTSEMRW_CNT_RD_MASK) >> RTSEMRW_CNT_RD_SHIFT;
+            uint64_t c = (u64State & RTCSRW_CNT_RD_MASK) >> RTCSRW_CNT_RD_SHIFT;
             c++;
-            Assert(c < RTSEMRW_CNT_MASK / 2);
-
-            uint64_t cWait = (u64State & RTSEMRW_WAIT_CNT_RD_MASK) >> RTSEMRW_WAIT_CNT_RD_SHIFT;
+            Assert(c < RTCSRW_CNT_MASK / 2);
+
+            uint64_t cWait = (u64State & RTCSRW_WAIT_CNT_RD_MASK) >> RTCSRW_WAIT_CNT_RD_SHIFT;
             cWait++;
             Assert(cWait <= c);
-            Assert(cWait < RTSEMRW_CNT_MASK / 2);
-
-            u64State &= ~(RTSEMRW_CNT_RD_MASK | RTSEMRW_WAIT_CNT_RD_MASK);
-            u64State |= (c << RTSEMRW_CNT_RD_SHIFT) | (cWait << RTSEMRW_WAIT_CNT_RD_SHIFT);
+            Assert(cWait < RTCSRW_CNT_MASK / 2);
+
+            u64State &= ~(RTCSRW_CNT_RD_MASK | RTCSRW_WAIT_CNT_RD_MASK);
+            u64State |= (c << RTCSRW_CNT_RD_SHIFT) | (cWait << RTCSRW_WAIT_CNT_RD_SHIFT);
 
             if (ASMAtomicCmpXchgU64(&pThis->u64State, u64State, u64OldState))
@@ -337 +274 @@
                 {
                     int rc;
-#ifdef RTSEMRW_STRICT
-                    rc = RTLockValidatorRecSharedCheckBlocking(&pThis->ValidatorRead, hThreadSelf, pSrcPos, true,
-                                                               cMillies, RTTHREADSTATE_RW_READ, false);
+#ifdef RTCRITSECTRW_STRICT
+                    rc = RTLockValidatorRecSharedCheckBlocking(pThis->pValidatorRead, hThreadSelf, pSrcPos, true,
+                                                               RT_INDEFINITE_WAIT, RTTHREADSTATE_RW_READ, false);
                     if (RT_SUCCESS(rc))
 #else
@@ -346 +283 @@
 #endif
                     {
-                        if (fInterruptible)
-                            rc = RTSemEventMultiWaitNoResume(pThis->hEvtRead, cMillies);
-                        else
-                            rc = RTSemEventMultiWait(pThis->hEvtRead, cMillies);
+                        rc = RTSemEventMultiWait(pThis->hEvtRead, RT_INDEFINITE_WAIT);
                         RTThreadUnblocked(hThreadSelf, RTTHREADSTATE_RW_READ);
-                        if (pThis->u32Magic != RTSEMRW_MAGIC)
+                        if (pThis->u32Magic != RTCRITSECTRW_MAGIC)
                             return VERR_SEM_DESTROYED;
                     }
@@ -360 +294 @@
                         {
                             u64OldState = u64State = ASMAtomicReadU64(&pThis->u64State);
-                            c = (u64State & RTSEMRW_CNT_RD_MASK) >> RTSEMRW_CNT_RD_SHIFT; Assert(c > 0);
+                            c = (u64State & RTCSRW_CNT_RD_MASK) >> RTCSRW_CNT_RD_SHIFT; Assert(c > 0);
                             c--;
-                            cWait = (u64State & RTSEMRW_WAIT_CNT_RD_MASK) >> RTSEMRW_WAIT_CNT_RD_SHIFT; Assert(cWait > 0);
+                            cWait = (u64State & RTCSRW_WAIT_CNT_RD_MASK) >> RTCSRW_WAIT_CNT_RD_SHIFT; Assert(cWait > 0);
                             cWait--;
-                            u64State &= ~(RTSEMRW_CNT_RD_MASK | RTSEMRW_WAIT_CNT_RD_MASK);
-                            u64State |= (c << RTSEMRW_CNT_RD_SHIFT) | (cWait << RTSEMRW_WAIT_CNT_RD_SHIFT);
+                            u64State &= ~(RTCSRW_CNT_RD_MASK | RTCSRW_WAIT_CNT_RD_MASK);
+                            u64State |= (c << RTCSRW_CNT_RD_SHIFT) | (cWait << RTCSRW_WAIT_CNT_RD_SHIFT);
                             if (ASMAtomicCmpXchgU64(&pThis->u64State, u64State, u64OldState))
                                 break;
@@ -374 +308 @@
                     Assert(pThis->fNeedReset);
                     u64State = ASMAtomicReadU64(&pThis->u64State);
-                    if ((u64State & RTSEMRW_DIR_MASK) == (RTSEMRW_DIR_READ << RTSEMRW_DIR_SHIFT))
+                    if ((u64State & RTCSRW_DIR_MASK) == (RTCSRW_DIR_READ << RTCSRW_DIR_SHIFT))
                         break;
                     AssertMsg(iLoop < 1, ("%u\n", iLoop));
@@ -384 +318 @@
                     u64OldState = u64State;
 
-                    cWait = (u64State & RTSEMRW_WAIT_CNT_RD_MASK) >> RTSEMRW_WAIT_CNT_RD_SHIFT;
+                    cWait = (u64State & RTCSRW_WAIT_CNT_RD_MASK) >> RTCSRW_WAIT_CNT_RD_SHIFT;
                     Assert(cWait > 0);
                     cWait--;
-                    u64State &= ~RTSEMRW_WAIT_CNT_RD_MASK;
-                    u64State |= cWait << RTSEMRW_WAIT_CNT_RD_SHIFT;
+                    u64State &= ~RTCSRW_WAIT_CNT_RD_MASK;
+                    u64State |= cWait << RTCSRW_WAIT_CNT_RD_SHIFT;
 
                     if (ASMAtomicCmpXchgU64(&pThis->u64State, u64State, u64OldState))
@@ -405 +339 @@
                 }
 
-#ifdef RTSEMRW_STRICT
-                RTLockValidatorRecSharedAddOwner(&pThis->ValidatorRead, hThreadSelf, pSrcPos);
+#ifdef RTCRITSECTRW_STRICT
+                RTLockValidatorRecSharedAddOwner(pThis->pValidatorRead, hThreadSelf, pSrcPos);
 #endif
                 break;
@@ -412 +346 @@
         }
 
-        if (pThis->u32Magic != RTSEMRW_MAGIC)
+        if (pThis->u32Magic != RTCRITSECTRW_MAGIC)
             return VERR_SEM_DESTROYED;
 
@@ -421 +355 @@
 
     /* got it! */
-    Assert((ASMAtomicReadU64(&pThis->u64State) & RTSEMRW_DIR_MASK) == (RTSEMRW_DIR_READ << RTSEMRW_DIR_SHIFT));
+    Assert((ASMAtomicReadU64(&pThis->u64State) & RTCSRW_DIR_MASK) == (RTCSRW_DIR_READ << RTCSRW_DIR_SHIFT));
     return VINF_SUCCESS;
 
@@ -427 +361 @@
 
 
-RTDECL(int) RTSemRWRequestRead(RTSEMRW hRWSem, RTMSINTERVAL cMillies)
-{
-#ifndef RTSEMRW_STRICT
-    return rtSemRWRequestRead(hRWSem, cMillies, false, NULL);
+RTDECL(int) RTCritSectRwEnterShared(PRTCRITSECTRW pThis)
+{
+#ifndef RTCRITSECTRW_STRICT
+    return rtCritSectRwEnterShared(pThis, NULL, false /*fTryOnly*/);
 #else
     RTLOCKVALSRCPOS SrcPos = RTLOCKVALSRCPOS_INIT_NORMAL_API();
-    return rtSemRWRequestRead(hRWSem, cMillies, false, &SrcPos);
-#endif
-}
-RT_EXPORT_SYMBOL(RTSemRWRequestRead);
-
-
-RTDECL(int) RTSemRWRequestReadDebug(RTSEMRW hRWSem, RTMSINTERVAL cMillies, RTHCUINTPTR uId, RT_SRC_POS_DECL)
+    return rtCritSectRwEnterShared(pThis, &SrcPos, false /*fTryOnly*/);
+#endif
+}
+RT_EXPORT_SYMBOL(RTCritSectRwEnterShared);
+
+
+RTDECL(int) RTCritSectRwEnterSharedDebug(PRTCRITSECTRW pThis, RTHCUINTPTR uId, RT_SRC_POS_DECL)
 {
     RTLOCKVALSRCPOS SrcPos = RTLOCKVALSRCPOS_INIT_DEBUG_API();
-    return rtSemRWRequestRead(hRWSem, cMillies, false, &SrcPos);
-}
-RT_EXPORT_SYMBOL(RTSemRWRequestReadDebug);
-
-
-RTDECL(int) RTSemRWRequestReadNoResume(RTSEMRW hRWSem, RTMSINTERVAL cMillies)
-{
-#ifndef RTSEMRW_STRICT
-    return rtSemRWRequestRead(hRWSem, cMillies, true, NULL);
+    return rtCritSectRwEnterShared(pThis, &SrcPos, false /*fTryOnly*/);
+}
+RT_EXPORT_SYMBOL(RTCritSectRwEnterSharedDebug);
+
+
+RTDECL(int) RTCritSectRwTryEnterShared(PRTCRITSECTRW pThis)
+{
+#ifndef RTCRITSECTRW_STRICT
+    return rtCritSectRwEnterShared(pThis, NULL, true /*fTryOnly*/);
 #else
     RTLOCKVALSRCPOS SrcPos = RTLOCKVALSRCPOS_INIT_NORMAL_API();
-    return rtSemRWRequestRead(hRWSem, cMillies, true, &SrcPos);
-#endif
-}
-RT_EXPORT_SYMBOL(RTSemRWRequestReadNoResume);
-
-
-RTDECL(int) RTSemRWRequestReadNoResumeDebug(RTSEMRW hRWSem, RTMSINTERVAL cMillies, RTHCUINTPTR uId, RT_SRC_POS_DECL)
+    return rtCritSectRwEnterShared(pThis, &SrcPos, true /*fTryOnly*/);
+#endif
+}
+RT_EXPORT_SYMBOL(RTCritSectRwEnterShared);
+
+
+RTDECL(int) RTCritSectRwTryEnterSharedDebug(PRTCRITSECTRW pThis, RTHCUINTPTR uId, RT_SRC_POS_DECL)
 {
     RTLOCKVALSRCPOS SrcPos = RTLOCKVALSRCPOS_INIT_DEBUG_API();
-    return rtSemRWRequestRead(hRWSem, cMillies, true, &SrcPos);
-}
-RT_EXPORT_SYMBOL(RTSemRWRequestReadNoResumeDebug);
-
-
-
-RTDECL(int) RTSemRWReleaseRead(RTSEMRW hRWSem)
+    return rtCritSectRwEnterShared(pThis, &SrcPos, true /*fTryOnly*/);
+}
+RT_EXPORT_SYMBOL(RTCritSectRwEnterSharedDebug);
+
+
+
+RTDECL(int) RTCritSectRwLeaveShared(PRTCRITSECTRW pThis)
 {
     /*
      * Validate handle.
      */
-    RTSEMRWINTERNAL *pThis = hRWSem;
-    AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
-    AssertReturn(pThis->u32Magic == RTSEMRW_MAGIC, VERR_INVALID_HANDLE);
+    AssertPtr(pThis);
+    AssertReturn(pThis->u32Magic == RTCRITSECTRW_MAGIC, VERR_SEM_DESTROYED);
 
     /*
@@ -482 +415 @@
     uint64_t u64State    = ASMAtomicReadU64(&pThis->u64State);
     uint64_t u64OldState = u64State;
-    if ((u64State & RTSEMRW_DIR_MASK) == (RTSEMRW_DIR_READ << RTSEMRW_DIR_SHIFT))
-    {
-#ifdef RTSEMRW_STRICT
-        int rc9 = RTLockValidatorRecSharedCheckAndRelease(&pThis->ValidatorRead, NIL_RTTHREAD);
+    if ((u64State & RTCSRW_DIR_MASK) == (RTCSRW_DIR_READ << RTCSRW_DIR_SHIFT))
+    {
+#ifdef RTCRITSECTRW_STRICT
+        int rc9 = RTLockValidatorRecSharedCheckAndRelease(pThis->pValidatorRead, NIL_RTTHREAD);
         if (RT_FAILURE(rc9))
             return rc9;
@@ -491 +424 @@
         for (;;)
         {
-            uint64_t c = (u64State & RTSEMRW_CNT_RD_MASK) >> RTSEMRW_CNT_RD_SHIFT;
+            uint64_t c = (u64State & RTCSRW_CNT_RD_MASK) >> RTCSRW_CNT_RD_SHIFT;
             AssertReturn(c > 0, VERR_NOT_OWNER);
             c--;
 
             if (   c > 0
-                || (u64State & RTSEMRW_CNT_RD_MASK) == 0)
+                || (u64State & RTCSRW_CNT_RD_MASK) == 0)
             {
                 /* Don't change the direction. */
-                u64State &= ~RTSEMRW_CNT_RD_MASK;
-                u64State |= c << RTSEMRW_CNT_RD_SHIFT;
+                u64State &= ~RTCSRW_CNT_RD_MASK;
+                u64State |= c << RTCSRW_CNT_RD_SHIFT;
                 if (ASMAtomicCmpXchgU64(&pThis->u64State, u64State, u64OldState))
                     break;
@@ -507 +440 @@
             {
                 /* Reverse the direction and signal the reader threads. */
-                u64State &= ~(RTSEMRW_CNT_RD_MASK | RTSEMRW_DIR_MASK);
-                u64State |= RTSEMRW_DIR_WRITE << RTSEMRW_DIR_SHIFT;
+                u64State &= ~(RTCSRW_CNT_RD_MASK | RTCSRW_DIR_MASK);
+                u64State |= RTCSRW_DIR_WRITE << RTCSRW_DIR_SHIFT;
                 if (ASMAtomicCmpXchgU64(&pThis->u64State, u64State, u64OldState))
                 {
@@ -529 +462 @@
         AssertReturn(hNativeSelf == hNativeWriter, VERR_NOT_OWNER);
         AssertReturn(pThis->cWriterReads > 0, VERR_NOT_OWNER);
-#ifdef RTSEMRW_STRICT
-        int rc = RTLockValidatorRecExclUnwindMixed(&pThis->ValidatorWrite, &pThis->ValidatorRead.Core);
+#ifdef RTCRITSECTRW_STRICT
+        int rc = RTLockValidatorRecExclUnwindMixed(pThis->pValidatorWrite, &pThis->pValidatorRead->Core);
         if (RT_FAILURE(rc))
             return rc;
@@ -539 +472 @@
     return VINF_SUCCESS;
 }
-RT_EXPORT_SYMBOL(RTSemRWReleaseRead);
-
-
-DECL_FORCE_INLINE(int) rtSemRWRequestWrite(RTSEMRW hRWSem, RTMSINTERVAL cMillies, bool fInterruptible, PCRTLOCKVALSRCPOS pSrcPos)
+RT_EXPORT_SYMBOL(RTCritSectRwLeaveShared);
+
+
+static int rtCritSectRwEnterExcl(PRTCRITSECTRW pThis, PCRTLOCKVALSRCPOS pSrcPos, bool fTryOnly)
 {
     /*
      * Validate input.
      */
-    RTSEMRWINTERNAL *pThis = hRWSem;
-    if (pThis == NIL_RTSEMRW)
-        return VINF_SUCCESS;
-    AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
-    AssertReturn(pThis->u32Magic == RTSEMRW_MAGIC, VERR_INVALID_HANDLE);
-
-#ifdef RTSEMRW_STRICT
+    AssertPtr(pThis);
+    AssertReturn(pThis->u32Magic == RTCRITSECTRW_MAGIC, VERR_SEM_DESTROYED);
+
+#ifdef RTCRITSECTRW_STRICT
     RTTHREAD hThreadSelf = NIL_RTTHREAD;
-    if (cMillies)
+    if (!fTryOnly)
     {
         hThreadSelf = RTThreadSelfAutoAdopt();
-        int rc9 = RTLockValidatorRecExclCheckOrder(&pThis->ValidatorWrite, hThreadSelf, pSrcPos, cMillies);
+        int rc9 = RTLockValidatorRecExclCheckOrder(pThis->pValidatorWrite, hThreadSelf, pSrcPos, RT_INDEFINITE_WAIT);
         if (RT_FAILURE(rc9))
             return rc9;
@@ -572 +502 @@
     if (hNativeSelf == hNativeWriter)
     {
-        Assert((ASMAtomicReadU64(&pThis->u64State) & RTSEMRW_DIR_MASK) == (RTSEMRW_DIR_WRITE << RTSEMRW_DIR_SHIFT));
-#ifdef RTSEMRW_STRICT
-        int rc9 = RTLockValidatorRecExclRecursion(&pThis->ValidatorWrite, pSrcPos);
+        Assert((ASMAtomicReadU64(&pThis->u64State) & RTCSRW_DIR_MASK) == (RTCSRW_DIR_WRITE << RTCSRW_DIR_SHIFT));
+#ifdef RTCRITSECTRW_STRICT
+        int rc9 = RTLockValidatorRecExclRecursion(pThis->pValidatorWrite, pSrcPos);
         if (RT_FAILURE(rc9))
             return rc9;
@@ -591 +521 @@
     for (;;)
     {
-        if (   (u64State & RTSEMRW_DIR_MASK) == (RTSEMRW_DIR_WRITE << RTSEMRW_DIR_SHIFT)
-            || (u64State & (RTSEMRW_CNT_RD_MASK | RTSEMRW_CNT_WR_MASK)) != 0)
+        if (   (u64State & RTCSRW_DIR_MASK) == (RTCSRW_DIR_WRITE << RTCSRW_DIR_SHIFT)
+            || (u64State & (RTCSRW_CNT_RD_MASK | RTCSRW_CNT_WR_MASK)) != 0)
         {
             /* It flows in the right direction, try follow it before it changes. */
-            uint64_t c = (u64State & RTSEMRW_CNT_WR_MASK) >> RTSEMRW_CNT_WR_SHIFT;
+            uint64_t c = (u64State & RTCSRW_CNT_WR_MASK) >> RTCSRW_CNT_WR_SHIFT;
             c++;
-            Assert(c < RTSEMRW_CNT_MASK / 2);
-            u64State &= ~RTSEMRW_CNT_WR_MASK;
-            u64State |= c << RTSEMRW_CNT_WR_SHIFT;
+            Assert(c < RTCSRW_CNT_MASK / 2);
+            u64State &= ~RTCSRW_CNT_WR_MASK;
+            u64State |= c << RTCSRW_CNT_WR_SHIFT;
             if (ASMAtomicCmpXchgU64(&pThis->u64State, u64State, u64OldState))
                 break;
         }
-        else if ((u64State & (RTSEMRW_CNT_RD_MASK | RTSEMRW_CNT_WR_MASK)) == 0)
+        else if ((u64State & (RTCSRW_CNT_RD_MASK | RTCSRW_CNT_WR_MASK)) == 0)
         {
             /* Wrong direction, but we're alone here and can simply try switch the direction. */
-            u64State &= ~(RTSEMRW_CNT_RD_MASK | RTSEMRW_CNT_WR_MASK | RTSEMRW_DIR_MASK);
-            u64State |= (UINT64_C(1) << RTSEMRW_CNT_WR_SHIFT) | (RTSEMRW_DIR_WRITE << RTSEMRW_DIR_SHIFT);
+            u64State &= ~(RTCSRW_CNT_RD_MASK | RTCSRW_CNT_WR_MASK | RTCSRW_DIR_MASK);
+            u64State |= (UINT64_C(1) << RTCSRW_CNT_WR_SHIFT) | (RTCSRW_DIR_WRITE << RTCSRW_DIR_SHIFT);
             if (ASMAtomicCmpXchgU64(&pThis->u64State, u64State, u64OldState))
                 break;
         }
-        else if (!cMillies)
+        else if (fTryOnly)
             /* Wrong direction and we're not supposed to wait, just return. */
-            return VERR_TIMEOUT;
+            return VERR_SEM_BUSY;
         else
         {
             /* Add ourselves to the write count and break out to do the wait. */
-            uint64_t c = (u64State & RTSEMRW_CNT_WR_MASK) >> RTSEMRW_CNT_WR_SHIFT;
+            uint64_t c = (u64State & RTCSRW_CNT_WR_MASK) >> RTCSRW_CNT_WR_SHIFT;
             c++;
-            Assert(c < RTSEMRW_CNT_MASK / 2);
-            u64State &= ~RTSEMRW_CNT_WR_MASK;
-            u64State |= c << RTSEMRW_CNT_WR_SHIFT;
+            Assert(c < RTCSRW_CNT_MASK / 2);
+            u64State &= ~RTCSRW_CNT_WR_MASK;
+            u64State |= c << RTCSRW_CNT_WR_SHIFT;
             if (ASMAtomicCmpXchgU64(&pThis->u64State, u64State, u64OldState))
                 break;
         }
 
-        if (pThis->u32Magic != RTSEMRW_MAGIC)
+        if (pThis->u32Magic != RTCRITSECTRW_MAGIC)
             return VERR_SEM_DESTROYED;
 
@@ -638 +568 @@
      * are threads already waiting.
      */
-    bool fDone = (u64State & RTSEMRW_DIR_MASK) == (RTSEMRW_DIR_WRITE << RTSEMRW_DIR_SHIFT)
-              && (  ((u64State & RTSEMRW_CNT_WR_MASK) >> RTSEMRW_CNT_WR_SHIFT) == 1
-                  || cMillies == 0);
+    bool fDone = (u64State & RTCSRW_DIR_MASK) == (RTCSRW_DIR_WRITE << RTCSRW_DIR_SHIFT)
+              && (  ((u64State & RTCSRW_CNT_WR_MASK) >> RTCSRW_CNT_WR_SHIFT) == 1
+                  || fTryOnly);
     if (fDone)
         ASMAtomicCmpXchgHandle(&pThis->hNativeWriter, hNativeSelf, NIL_RTNATIVETHREAD, fDone);
@@ -651 +581 @@
         {
             int rc;
-#ifdef RTSEMRW_STRICT
-            if (cMillies)
+#ifdef RTCRITSECTRW_STRICT
+            if (!fTryOnly)
             {
                 if (hThreadSelf == NIL_RTTHREAD)
                     hThreadSelf = RTThreadSelfAutoAdopt();
-                rc = RTLockValidatorRecExclCheckBlocking(&pThis->ValidatorWrite, hThreadSelf, pSrcPos, true,
-                                                         cMillies, RTTHREADSTATE_RW_WRITE, false);
+                rc = RTLockValidatorRecExclCheckBlocking(pThis->pValidatorWrite, hThreadSelf, pSrcPos, true,
+                                                         RT_INDEFINITE_WAIT, RTTHREADSTATE_RW_WRITE, false);
             }
             else
@@ -667 +597 @@
 #endif
             {
-                if (fInterruptible)
-                    rc = RTSemEventWaitNoResume(pThis->hEvtWrite, cMillies);
-                else
-                    rc = RTSemEventWait(pThis->hEvtWrite, cMillies);
+                rc = RTSemEventWait(pThis->hEvtWrite, RT_INDEFINITE_WAIT);
                 RTThreadUnblocked(hThreadSelf, RTTHREADSTATE_RW_WRITE);
-                if (pThis->u32Magic != RTSEMRW_MAGIC)
+                if (pThis->u32Magic != RTCRITSECTRW_MAGIC)
                     return VERR_SEM_DESTROYED;
             }
@@ -681 +608 @@
                 {
                     u64OldState = u64State = ASMAtomicReadU64(&pThis->u64State);
-                    uint64_t c = (u64State & RTSEMRW_CNT_WR_MASK) >> RTSEMRW_CNT_WR_SHIFT; Assert(c > 0);
+                    uint64_t c = (u64State & RTCSRW_CNT_WR_MASK) >> RTCSRW_CNT_WR_SHIFT; Assert(c > 0);
                     c--;
-                    u64State &= ~RTSEMRW_CNT_WR_MASK;
-                    u64State |= c << RTSEMRW_CNT_WR_SHIFT;
+                    u64State &= ~RTCSRW_CNT_WR_MASK;
+                    u64State |= c << RTCSRW_CNT_WR_SHIFT;
                     if (ASMAtomicCmpXchgU64(&pThis->u64State, u64State, u64OldState))
                         break;
@@ -692 +619 @@
 
             u64State = ASMAtomicReadU64(&pThis->u64State);
-            if ((u64State & RTSEMRW_DIR_MASK) == (RTSEMRW_DIR_WRITE << RTSEMRW_DIR_SHIFT))
+            if ((u64State & RTCSRW_DIR_MASK) == (RTCSRW_DIR_WRITE << RTCSRW_DIR_SHIFT))
             {
                 ASMAtomicCmpXchgHandle(&pThis->hNativeWriter, hNativeSelf, NIL_RTNATIVETHREAD, fDone);
@@ -705 +632 @@
      * Got it!
      */
-    Assert((ASMAtomicReadU64(&pThis->u64State) & RTSEMRW_DIR_MASK) == (RTSEMRW_DIR_WRITE << RTSEMRW_DIR_SHIFT));
+    Assert((ASMAtomicReadU64(&pThis->u64State) & RTCSRW_DIR_MASK) == (RTCSRW_DIR_WRITE << RTCSRW_DIR_SHIFT));
     ASMAtomicWriteU32(&pThis->cWriteRecursions, 1);
     Assert(pThis->cWriterReads == 0);
-#ifdef RTSEMRW_STRICT
-    RTLockValidatorRecExclSetOwner(&pThis->ValidatorWrite, hThreadSelf, pSrcPos, true);
+#ifdef RTCRITSECTRW_STRICT
+    RTLockValidatorRecExclSetOwner(pThis->pValidatorWrite, hThreadSelf, pSrcPos, true);
 #endif
 
@@ -716 +643 @@
 
 
-RTDECL(int) RTSemRWRequestWrite(RTSEMRW hRWSem, RTMSINTERVAL cMillies)
-{
-#ifndef RTSEMRW_STRICT
-    return rtSemRWRequestWrite(hRWSem, cMillies, false, NULL);
+RTDECL(int) RTCritSectRwEnterExcl(PRTCRITSECTRW pThis)
+{
+#ifndef RTCRITSECTRW_STRICT
+    return rtCritSectRwEnterExcl(pThis, NULL, false /*fTryAgain*/);
 #else
     RTLOCKVALSRCPOS SrcPos = RTLOCKVALSRCPOS_INIT_NORMAL_API();
-    return rtSemRWRequestWrite(hRWSem, cMillies, false, &SrcPos);
-#endif
-}
-RT_EXPORT_SYMBOL(RTSemRWRequestWrite);
-
-
-RTDECL(int) RTSemRWRequestWriteDebug(RTSEMRW hRWSem, RTMSINTERVAL cMillies, RTHCUINTPTR uId, RT_SRC_POS_DECL)
+    return rtCritSectRwEnterExcl(pThis, &SrcPos, false /*fTryAgain*/);
+#endif
+}
+RT_EXPORT_SYMBOL(RTCritSectRwEnterExcl);
+
+
+RTDECL(int) RTCritSectRwEnterExclDebug(PRTCRITSECTRW pThis, RTHCUINTPTR uId, RT_SRC_POS_DECL)
 {
     RTLOCKVALSRCPOS SrcPos = RTLOCKVALSRCPOS_INIT_DEBUG_API();
-    return rtSemRWRequestWrite(hRWSem, cMillies, false, &SrcPos);
-}
-RT_EXPORT_SYMBOL(RTSemRWRequestWriteDebug);
-
-
-RTDECL(int) RTSemRWRequestWriteNoResume(RTSEMRW hRWSem, RTMSINTERVAL cMillies)
-{
-#ifndef RTSEMRW_STRICT
-    return rtSemRWRequestWrite(hRWSem, cMillies, true, NULL);
+    return rtCritSectRwEnterExcl(pThis, &SrcPos, false /*fTryAgain*/);
+}
+RT_EXPORT_SYMBOL(RTCritSectRwEnterExclDebug);
+
+
+RTDECL(int) RTCritSectRwTryEnterExcl(PRTCRITSECTRW pThis)
+{
+#ifndef RTCRITSECTRW_STRICT
+    return rtCritSectRwEnterExcl(pThis, NULL, true /*fTryAgain*/);
 #else
     RTLOCKVALSRCPOS SrcPos = RTLOCKVALSRCPOS_INIT_NORMAL_API();
-    return rtSemRWRequestWrite(hRWSem, cMillies, true, &SrcPos);
-#endif
-}
-RT_EXPORT_SYMBOL(RTSemRWRequestWriteNoResume);
-
-
-RTDECL(int) RTSemRWRequestWriteNoResumeDebug(RTSEMRW hRWSem, RTMSINTERVAL cMillies, RTHCUINTPTR uId, RT_SRC_POS_DECL)
+    return rtCritSectRwEnterExcl(pThis, &SrcPos, true /*fTryAgain*/);
+#endif
+}
+RT_EXPORT_SYMBOL(RTCritSectRwTryEnterExcl);
+
+
+RTDECL(int) RTCritSectRwTryEnterExclDebug(PRTCRITSECTRW pThis, RTHCUINTPTR uId, RT_SRC_POS_DECL)
 {
     RTLOCKVALSRCPOS SrcPos = RTLOCKVALSRCPOS_INIT_DEBUG_API();
-    return rtSemRWRequestWrite(hRWSem, cMillies, true, &SrcPos);
-}
-RT_EXPORT_SYMBOL(RTSemRWRequestWriteNoResumeDebug);
-
-
-RTDECL(int) RTSemRWReleaseWrite(RTSEMRW hRWSem)
-{
-
+    return rtCritSectRwEnterExcl(pThis, &SrcPos, true /*fTryAgain*/);
+}
+RT_EXPORT_SYMBOL(RTCritSectRwTryEnterExclDebug);
+
+
+RTDECL(int) RTCritSectRwLeaveExcl(PRTCRITSECTRW pThis)
+{
     /*
      * Validate handle.
      */
-    struct RTSEMRWINTERNAL *pThis = hRWSem;
-    AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
-    AssertReturn(pThis->u32Magic == RTSEMRW_MAGIC, VERR_INVALID_HANDLE);
+    AssertPtr(pThis);
+    AssertReturn(pThis->u32Magic == RTCRITSECTRW_MAGIC, VERR_SEM_DESTROYED);
 
     RTNATIVETHREAD hNativeSelf = RTThreadNativeSelf();
@@ -777 +702 @@
     {
         AssertReturn(pThis->cWriterReads == 0, VERR_WRONG_ORDER); /* (must release all read recursions before the final write.) */
-#ifdef RTSEMRW_STRICT
-        int rc9 = RTLockValidatorRecExclReleaseOwner(&pThis->ValidatorWrite, true);
+#ifdef RTCRITSECTRW_STRICT
+        int rc9 = RTLockValidatorRecExclReleaseOwner(pThis->pValidatorWrite, true);
         if (RT_FAILURE(rc9))
             return rc9;
@@ -793 +718 @@
             uint64_t u64OldState = u64State;
 
-            uint64_t c = (u64State & RTSEMRW_CNT_WR_MASK) >> RTSEMRW_CNT_WR_SHIFT;
+            uint64_t c = (u64State & RTCSRW_CNT_WR_MASK) >> RTCSRW_CNT_WR_SHIFT;
             Assert(c > 0);
             c--;
 
             if (   c > 0
-                || (u64State & RTSEMRW_CNT_RD_MASK) == 0)
+                || (u64State & RTCSRW_CNT_RD_MASK) == 0)
             {
                 /* Don't change the direction, wait up the next writer if any. */
-                u64State &= ~RTSEMRW_CNT_WR_MASK;
-                u64State |= c << RTSEMRW_CNT_WR_SHIFT;
+                u64State &= ~RTCSRW_CNT_WR_MASK;
+                u64State |= c << RTCSRW_CNT_WR_SHIFT;
                 if (ASMAtomicCmpXchgU64(&pThis->u64State, u64State, u64OldState))
                 {
@@ -816 +741 @@
             {
                 /* Reverse the direction and signal the reader threads. */
-                u64State &= ~(RTSEMRW_CNT_WR_MASK | RTSEMRW_DIR_MASK);
-                u64State |= RTSEMRW_DIR_READ << RTSEMRW_DIR_SHIFT;
+                u64State &= ~(RTCSRW_CNT_WR_MASK | RTCSRW_DIR_MASK);
+                u64State |= RTCSRW_DIR_READ << RTCSRW_DIR_SHIFT;
                 if (ASMAtomicCmpXchgU64(&pThis->u64State, u64State, u64OldState))
                 {
@@ -829 +754 @@
 
             ASMNopPause();
-            if (pThis->u32Magic != RTSEMRW_MAGIC)
+            if (pThis->u32Magic != RTCRITSECTRW_MAGIC)
                 return VERR_SEM_DESTROYED;
         }
@@ -836 +761 @@
     {
         Assert(pThis->cWriteRecursions != 0);
-#ifdef RTSEMRW_STRICT
-        int rc9 = RTLockValidatorRecExclUnwind(&pThis->ValidatorWrite);
+#ifdef RTCRITSECTRW_STRICT
+        int rc9 = RTLockValidatorRecExclUnwind(pThis->pValidatorWrite);
         if (RT_FAILURE(rc9))
             return rc9;
@@ -849 +774 @@
 
 
-RTDECL(bool) RTSemRWIsWriteOwner(RTSEMRW hRWSem)
+RTDECL(bool) RTCritSectRwIsWriteOwner(PRTCRITSECTRW pThis)
 {
     /*
      * Validate handle.
      */
-    struct RTSEMRWINTERNAL *pThis = hRWSem;
-    AssertPtrReturn(pThis, false);
-    AssertReturn(pThis->u32Magic == RTSEMRW_MAGIC, false);
+    AssertPtr(pThis);
+    AssertReturn(pThis->u32Magic == RTCRITSECTRW_MAGIC, false);
 
     /*
@@ -866 +790 @@
     return hNativeWriter == hNativeSelf;
 }
-RT_EXPORT_SYMBOL(RTSemRWIsWriteOwner);
-
-
-RTDECL(bool)  RTSemRWIsReadOwner(RTSEMRW hRWSem, bool fWannaHear)
+RT_EXPORT_SYMBOL(RTCritSectRwIsWriteOwner);
+
+
+RTDECL(bool) RTCritSectRwIsReadOwner(PRTCRITSECTRW pThis, bool fWannaHear)
 {
     /*
      * Validate handle.
      */
-    struct RTSEMRWINTERNAL *pThis = hRWSem;
-    AssertPtrReturn(pThis, false);
-    AssertReturn(pThis->u32Magic == RTSEMRW_MAGIC, false);
+    AssertPtr(pThis);
+    AssertReturn(pThis->u32Magic == RTCRITSECTRW_MAGIC, false);
 
     /*
@@ -882 +805 @@
      */
     uint64_t u64State = ASMAtomicReadU64(&pThis->u64State);
-    if ((u64State & RTSEMRW_DIR_MASK) == (RTSEMRW_DIR_WRITE << RTSEMRW_DIR_SHIFT))
+    if ((u64State & RTCSRW_DIR_MASK) == (RTCSRW_DIR_WRITE << RTCSRW_DIR_SHIFT))
     {
         /*
@@ -897 +820 @@
      * Read mode.  If there are no current readers, then we cannot be a reader.
      */
-    if (!(u64State & RTSEMRW_CNT_RD_MASK))
+    if (!(u64State & RTCSRW_CNT_RD_MASK))
         return false;
 
-#ifdef RTSEMRW_STRICT
+#ifdef RTCRITSECTRW_STRICT
     /*
      * Ask the lock validator.
      */
-    return RTLockValidatorRecSharedIsOwner(&pThis->ValidatorRead, NIL_RTTHREAD);
+    return RTLockValidatorRecSharedIsOwner(pThis->pValidatorRead, NIL_RTTHREAD);
 #else
     /*
@@ -912 +835 @@
 #endif
 }
-RT_EXPORT_SYMBOL(RTSemRWIsReadOwner);
-
-
-RTDECL(uint32_t) RTSemRWGetWriteRecursion(RTSEMRW hRWSem)
+RT_EXPORT_SYMBOL(RTCritSectRwIsReadOwner);
+
+
+RTDECL(uint32_t) RTCritSectRwGetWriteRecursion(PRTCRITSECTRW pThis)
 {
     /*
      * Validate handle.
      */
-    struct RTSEMRWINTERNAL *pThis = hRWSem;
-    AssertPtrReturn(pThis, 0);
-    AssertReturn(pThis->u32Magic == RTSEMRW_MAGIC, 0);
+    AssertPtr(pThis);
+    AssertReturn(pThis->u32Magic == RTCRITSECTRW_MAGIC, 0);
 
     /*
@@ -929 +851 @@
     return pThis->cWriteRecursions;
 }
-RT_EXPORT_SYMBOL(RTSemRWGetWriteRecursion);
-
-
-RTDECL(uint32_t) RTSemRWGetWriterReadRecursion(RTSEMRW hRWSem)
+RT_EXPORT_SYMBOL(RTCritSectRwGetWriteRecursion);
+
+
+RTDECL(uint32_t) RTCritSectRwGetWriterReadRecursion(PRTCRITSECTRW pThis)
 {
     /*
      * Validate handle.
      */
-    struct RTSEMRWINTERNAL *pThis = hRWSem;
-    AssertPtrReturn(pThis, 0);
-    AssertReturn(pThis->u32Magic == RTSEMRW_MAGIC, 0);
+    AssertPtr(pThis);
+    AssertReturn(pThis->u32Magic == RTCRITSECTRW_MAGIC, 0);
 
     /*
@@ -949 +870 @@
 
 
-RTDECL(uint32_t) RTSemRWGetReadCount(RTSEMRW hRWSem)
+RTDECL(uint32_t) RTSemRWGetReadCount(PRTCRITSECTRW pThis)
 {
     /*
      * Validate input.
      */
-    struct RTSEMRWINTERNAL *pThis = hRWSem;
-    AssertPtrReturn(pThis, 0);
-    AssertMsgReturn(pThis->u32Magic == RTSEMRW_MAGIC,
-                    ("pThis=%p u32Magic=%#x\n", pThis, pThis->u32Magic),
-                    0);
+    AssertPtr(pThis);
+    AssertReturn(pThis->u32Magic == RTCRITSECTRW_MAGIC, 0);
 
     /*
@@ -964 +882 @@
      */
     uint64_t u64State = ASMAtomicReadU64(&pThis->u64State);
-    if ((u64State & RTSEMRW_DIR_MASK) != (RTSEMRW_DIR_READ << RTSEMRW_DIR_SHIFT))
+    if ((u64State & RTCSRW_DIR_MASK) != (RTCSRW_DIR_READ << RTCSRW_DIR_SHIFT))
         return 0;
-    return (u64State & RTSEMRW_CNT_RD_MASK) >> RTSEMRW_CNT_RD_SHIFT;
+    return (u64State & RTCSRW_CNT_RD_MASK) >> RTCSRW_CNT_RD_SHIFT;
 }
 RT_EXPORT_SYMBOL(RTSemRWGetReadCount);
 
+
+RTDECL(int) RTCritSectRwDelete(PRTCRITSECTRW pThis)
+{
+    /*
+     * Assert free waiters and so on.
+     */
+    AssertPtr(pThis);
+    Assert(pThis->u32Magic == RTCRITSECTRW_MAGIC);
+    //Assert(pThis->cNestings == 0);
+    //Assert(pThis->cLockers == -1);
+    Assert(pThis->hNativeWriter == NIL_RTNATIVETHREAD);
+
+    /*
+     * Invalidate the structure and free the semaphores.
+     */
+    if (!ASMAtomicCmpXchgU32(&pThis->u32Magic, RTCRITSECTRW_MAGIC_DEAD, RTCRITSECTRW_MAGIC))
+        return VERR_INVALID_PARAMETER;
+
+    pThis->fFlags   = 0;
+    pThis->u64State = 0;
+
+    RTSEMEVENT      hEvtWrite = pThis->hEvtWrite;
+    pThis->hEvtWrite = NIL_RTSEMEVENT;
+    RTSEMEVENTMULTI hEvtRead  = pThis->hEvtRead;
+    pThis->hEvtRead  = NIL_RTSEMEVENTMULTI;
+
+    int rc1 = RTSemEventDestroy(hEvtWrite);     AssertRC(rc1);
+    int rc2 = RTSemEventMultiDestroy(hEvtRead); AssertRC(rc2);
+
+    RTLockValidatorRecSharedDestroy(&pThis->pValidatorRead);
+    RTLockValidatorRecExclDestroy(&pThis->pValidatorWrite);
+
+    return RT_SUCCESS(rc1) ? rc2 : rc1;
+}
+RT_EXPORT_SYMBOL(RTCritSectRwDelete);
+

trunk/src/VBox/Runtime/generic/semrw-lockless-generic.cpp

@@ -52 +52 @@
     /** Magic value (RTSEMRW_MAGIC).  */
     uint32_t volatile       u32Magic;
-    uint32_t                u32Padding; /**< alignment padding.*/
-    /* The state variable.
+    /** Indicates whether hEvtRead needs resetting. */
+    bool volatile           fNeedReset;
+
+    /** The state variable.
      * All accesses are atomic and it bits are defined like this:
      *      Bits 0..14  - cReads.
@@ -78 +80 @@
      * finish. */
     RTSEMEVENTMULTI         hEvtRead;
-    /** Indicates whether hEvtRead needs resetting. */
-    bool volatile           fNeedReset;
 
 #ifdef RTSEMRW_STRICT

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

@@ -5 +5 @@
 
 /*
- * Copyright (C) 2007-2010 Oracle Corporation
+ * Copyright (C) 2007-2013 Oracle Corporation
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -36 +36 @@
 #if (!defined(RTCRITSECT_STRICT)      && defined(IN_RING3) && defined(RT_LOCK_STRICT)) || defined(DOXYGEN_RUNNING)
 # define RTCRITSECT_STRICT
+#endif
+
+/** @def RTCRITSECTRW_STRICT
+ * Enables strictness checks and lock accounting of the RTCritSectRw API.
+ */
+#if (!defined(RTCRITSECTRW_STRICT)    && defined(IN_RING3) && defined(RT_LOCK_STRICT)) || defined(DOXYGEN_RUNNING)
+# define RTCRITSECTRW_STRICT
 #endif