Changeset 25607 in vbox

Timestamp:

Dec 31, 2009 1:21:39 PM (15 years ago)

Author:

vboxsync

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

56298

Message:

iprt,pdmcritsect: Shortening and cleaning up the lock validator structure names.

Location:

trunk

Files:

• include/iprt/critsect.h (modified) (1 diff)
• include/iprt/lockvalidator.h (modified) (32 diffs)
• include/iprt/types.h (modified) (1 diff)
• src/VBox/Runtime/common/misc/lockvalidator.cpp (modified) (65 diffs)
• src/VBox/Runtime/generic/critsect-generic.cpp (modified) (12 diffs)
• src/VBox/Runtime/include/internal/lockvalidator.h (modified) (2 diffs)
• src/VBox/Runtime/include/internal/magics.h (modified) (1 diff)
• src/VBox/Runtime/r3/linux/semmutex-linux.cpp (modified) (8 diffs)
• src/VBox/Runtime/r3/posix/semmutex-posix.cpp (modified) (8 diffs)
• src/VBox/Runtime/r3/posix/semrw-posix.cpp (modified) (9 diffs)
• src/VBox/Runtime/r3/win/semmutex-win.cpp (modified) (6 diffs)
• src/VBox/VMM/PDMCritSect.cpp (modified) (3 diffs)
• src/VBox/VMM/VMMAll/PDMAllCritSect.cpp (modified) (8 diffs)

trunk/include/iprt/critsect.h

@@ -87 +87 @@
     RTSEMEVENT                          EventSem;
     /** Lock validator record.  Only used in strict builds. */
-    R3R0PTRTYPE(PRTLOCKVALIDATORREC)    pValidatorRec;
+    R3R0PTRTYPE(PRTLOCKVALRECEXCL)      pValidatorRec;
     /** Alignmnet padding. */
     RTHCPTR                             Alignment;

trunk/include/iprt/lockvalidator.h

@@ -46 +46 @@
 /** Pointer to a record union.
  * @internal  */
-typedef union RTLOCKVALIDATORRECUNION *PRTLOCKVALIDATORRECUNION;
+typedef union RTLOCKVALRECUNION *PRTLOCKVALRECUNION;
 
 /**
  * Source position.
  */
-typedef struct RTLOCKVALIDATORSRCPOS
+typedef struct RTLOCKVALSRCPOS
 {
     /** The file where the lock was taken. */
@@ -64 +64 @@
     uint32_t                            u32Padding; /**< Alignment padding. */
 #endif
-} RTLOCKVALIDATORSRCPOS;
-AssertCompileSize(RTLOCKVALIDATORSRCPOS, HC_ARCH_BITS == 32 ? 16 : 32);
+} RTLOCKVALSRCPOS;
+AssertCompileSize(RTLOCKVALSRCPOS, HC_ARCH_BITS == 32 ? 16 : 32);
 /* The pointer types are defined in iprt/types.h. */
 
-/** @def RTLOCKVALIDATORSRCPOS_INIT
- * Initializer for a RTLOCKVALIDATORSRCPOS variable.
+/** @def RTLOCKVALSRCPOS_INIT
+ * Initializer for a RTLOCKVALSRCPOS variable.
  *
  * @param   pszFile         The file name.  Optional (NULL).
@@ -78 +78 @@
  */
 #if HC_ARCH_BITS == 64
-# define RTLOCKVALIDATORSRCPOS_INIT(pszFile, uLine, pszFunction, uId) \
+# define RTLOCKVALSRCPOS_INIT(pszFile, uLine, pszFunction, uId) \
     { (pszFile), (pszFunction), (uId), (uLine), 0 }
 #else
-# define RTLOCKVALIDATORSRCPOS_INIT(pszFile, uLine, pszFunction, uId) \
+# define RTLOCKVALSRCPOS_INIT(pszFile, uLine, pszFunction, uId) \
     { (pszFile), (pszFunction), (uId), (uLine) }
 #endif
 
-/** @def RTLOCKVALIDATORSRCPOS_INIT_DEBUG_API
- * Initializer for a RTLOCKVALIDATORSRCPOS variable in a typicial debug API
+/** @def RTLOCKVALSRCPOS_INIT_DEBUG_API
+ * Initializer for a RTLOCKVALSRCPOS variable in a typicial debug API
  * variant.  Assumes RT_SRC_POS_DECL and RTHCUINTPTR uId as arguments.
  */
-#define RTLOCKVALIDATORSRCPOS_INIT_DEBUG_API()  \
-    RTLOCKVALIDATORSRCPOS_INIT(pszFile, iLine, pszFunction, uId)
-
-/** @def RTLOCKVALIDATORSRCPOS_INIT_NORMAL_API
- * Initializer for a RTLOCKVALIDATORSRCPOS variable in a normal API
+#define RTLOCKVALSRCPOS_INIT_DEBUG_API()  \
+    RTLOCKVALSRCPOS_INIT(pszFile, iLine, pszFunction, uId)
+
+/** @def RTLOCKVALSRCPOS_INIT_NORMAL_API
+ * Initializer for a RTLOCKVALSRCPOS variable in a normal API
  * variant.  Assumes iprt/asm.h is included.
  */
-#define RTLOCKVALIDATORSRCPOS_INIT_NORMAL_API() \
-    RTLOCKVALIDATORSRCPOS_INIT(__FILE__, __LINE__, __PRETTY_FUNCTION__, (uintptr_t)ASMReturnAddress())
+#define RTLOCKVALSRCPOS_INIT_NORMAL_API() \
+    RTLOCKVALSRCPOS_INIT(__FILE__, __LINE__, __PRETTY_FUNCTION__, (uintptr_t)ASMReturnAddress())
 
 /** Pointer to a record of one ownership share.  */
-typedef struct RTLOCKVALIDATORSHARED *PRTLOCKVALIDATORSHARED;
+typedef struct RTLOCKVALRECSHRD *PRTLOCKVALRECSHRD;
 
 
@@ -110 +110 @@
     /** The magic value indicating the record type. */
     uint32_t                            u32Magic;
-} RTLOCKVALIDATORRECCORE;
+} RTLOCKVALRECCORE;
 /** Pointer to a lock validator record core. */
-typedef RTLOCKVALIDATORRECCORE *PRTLOCKVALIDATORRECCORE;
+typedef RTLOCKVALRECCORE *PRTLOCKVALRECCORE;
 /** Pointer to a const lock validator record core. */
-typedef RTLOCKVALIDATORRECCORE const *PCRTLOCKVALIDATORRECCORE;
-
-
-/**
- * Record recording the ownership of a lock.
+typedef RTLOCKVALRECCORE const *PCRTLOCKVALRECCORE;
+
+
+/**
+ * Record recording the exclusive ownership of a lock.
  *
  * This is typically part of the per-lock data structure when compiling with
  * the lock validator.
  */
-typedef struct RTLOCKVALIDATORREC
+typedef struct RTLOCKVALRECEXCL
 {
-    /** Record core with RTLOCKVALIDATORREC_MAGIC as the magic value. */
-    RTLOCKVALIDATORRECCORE              Core;
+    /** Record core with RTLOCKVALRECEXCL_MAGIC as the magic value. */
+    RTLOCKVALRECCORE                    Core;
     /** Whether it's enabled or not. */
     bool                                fEnabled;
@@ -132 +132 @@
     bool                                afReserved[3];
     /** Source position where the lock was taken. */
-    RTLOCKVALIDATORSRCPOS               SrcPos;
+    RTLOCKVALSRCPOS                     SrcPos;
     /** The current owner thread. */
     RTTHREAD volatile                   hThread;
     /** Pointer to the lock record below us. Only accessed by the owner. */
-    R3R0PTRTYPE(PRTLOCKVALIDATORREC)    pDown;
+    R3R0PTRTYPE(PRTLOCKVALRECUNION)     pDown;
     /** Recursion count */
     uint32_t                            cRecursion;
@@ -149 +149 @@
     /** Pointer to the next sibling record.
      * This is used to find the read side of a read-write lock.  */
-    R3R0PTRTYPE(PRTLOCKVALIDATORRECUNION) pSibling;
-} RTLOCKVALIDATORREC;
-AssertCompileSize(RTLOCKVALIDATORREC, HC_ARCH_BITS == 32 ? 8 + 16 + 32 : 8 + 32 + 56);
+    R3R0PTRTYPE(PRTLOCKVALRECUNION) pSibling;
+} RTLOCKVALRECEXCL;
+AssertCompileSize(RTLOCKVALRECEXCL, HC_ARCH_BITS == 32 ? 8 + 16 + 32 : 8 + 32 + 56);
 /* The pointer type is defined in iprt/types.h. */
 
@@ -157 +157 @@
  * For recording the one ownership share.
  */
-typedef struct RTLOCKVALIDATORSHAREDONE
+typedef struct RTLOCKVALRECSHRDOWN
 {
-    /** Record core with RTLOCKVALIDATORSHAREDONE_MAGIC as the magic value. */
-    RTLOCKVALIDATORRECCORE              Core;
+    /** Record core with RTLOCKVALRECSHRDOWN_MAGIC as the magic value. */
+    RTLOCKVALRECCORE                    Core;
     /** Recursion count */
     uint32_t                            cRecursion;
@@ -166 +166 @@
     RTTHREAD volatile                   hThread;
     /** Pointer to the lock record below us. Only accessed by the owner. */
-    R3R0PTRTYPE(PRTLOCKVALIDATORREC)    pDown;
+    R3R0PTRTYPE(PRTLOCKVALRECUNION)     pDown;
     /** Pointer back to the shared record. */
-    R3R0PTRTYPE(PRTLOCKVALIDATORSHARED) pSharedRec;
+    R3R0PTRTYPE(PRTLOCKVALRECSHRD)      pSharedRec;
 #if HC_ARCH_BITS == 32
     /** Reserved. */
@@ -174 +174 @@
 #endif
     /** Source position where the lock was taken. */
-    RTLOCKVALIDATORSRCPOS               SrcPos;
-} RTLOCKVALIDATORSHAREDONE;
-AssertCompileSize(RTLOCKVALIDATORSHAREDONE, HC_ARCH_BITS == 32 ? 24 + 16 : 32 + 32);
-/** Pointer to a RTLOCKVALIDATORSHAREDONE. */
-typedef RTLOCKVALIDATORSHAREDONE *PRTLOCKVALIDATORSHAREDONE;
+    RTLOCKVALSRCPOS                     SrcPos;
+} RTLOCKVALRECSHRDOWN;
+AssertCompileSize(RTLOCKVALRECSHRDOWN, HC_ARCH_BITS == 32 ? 24 + 16 : 32 + 32);
+/** Pointer to a RTLOCKVALRECSHRDOWN. */
+typedef RTLOCKVALRECSHRDOWN *PRTLOCKVALRECSHRDOWN;
 
 /**
@@ -186 +186 @@
  * the lock validator.
  */
-typedef struct RTLOCKVALIDATORSHARED
+typedef struct RTLOCKVALRECSHRD
 {
-    /** Record core with RTLOCKVALIDATORSHARED_MAGIC as the magic value. */
-    RTLOCKVALIDATORRECCORE              Core;
+    /** Record core with RTLOCKVALRECSHRD_MAGIC as the magic value. */
+    RTLOCKVALRECCORE                    Core;
     /** The lock sub-class. */
     uint32_t volatile                   uSubClass;
@@ -200 +200 @@
     /** Pointer to the next sibling record.
      * This is used to find the write side of a read-write lock.  */
-    R3R0PTRTYPE(PRTLOCKVALIDATORRECUNION) pSibling;
+    R3R0PTRTYPE(PRTLOCKVALRECUNION)     pSibling;
 
     /** The number of entries in the table.
@@ -219 +219 @@
     bool                                afPadding[2];
     /** Pointer to a table containing pointers to records of all the owners. */
-    R3R0PTRTYPE(PRTLOCKVALIDATORSHAREDONE volatile *) papOwners;
+    R3R0PTRTYPE(PRTLOCKVALRECSHRDOWN volatile *) papOwners;
 #if HC_ARCH_BITS == 32
     /** Alignment padding. */
     uint32_t                            u32Alignment;
 #endif
-} RTLOCKVALIDATORSHARED;
-AssertCompileSize(RTLOCKVALIDATORSHARED, HC_ARCH_BITS == 32 ? 24 + 20 + 4 : 40 + 24);
+} RTLOCKVALRECSHRD;
+AssertCompileSize(RTLOCKVALRECSHRD, HC_ARCH_BITS == 32 ? 24 + 20 + 4 : 40 + 24);
 
 
@@ -244 +244 @@
  * Initialize a lock validator record.
  *
- * Use RTLockValidatorRecDelete to deinitialize it.
+ * Use RTLockValidatorRecExclDelete to deinitialize it.
  *
  * @param   pRec                The record.
@@ -255 +255 @@
  * @param   hLock               The lock handle.
  */
-RTDECL(void) RTLockValidatorRecInit(PRTLOCKVALIDATORREC pRec, RTLOCKVALIDATORCLASS hClass,
-                                    uint32_t uSubClass, const char *pszName, void *hLock);
+RTDECL(void) RTLockValidatorRecExclInit(PRTLOCKVALRECEXCL pRec, RTLOCKVALIDATORCLASS hClass,
+                                        uint32_t uSubClass, const char *pszName, void *hLock);
 /**
  * Uninitialize a lock validator record previously initialized by
@@ -263 +263 @@
  * @param   pRec                The record.  Must be valid.
  */
-RTDECL(void) RTLockValidatorRecDelete(PRTLOCKVALIDATORREC pRec);
+RTDECL(void) RTLockValidatorRecExclDelete(PRTLOCKVALRECEXCL pRec);
 
 /**
  * Create and initialize a lock validator record.
  *
- * Use RTLockValidatorRecDestroy to deinitialize and destroy the returned
+ * Use RTLockValidatorRecExclDestroy to deinitialize and destroy the returned
  * record.
  *
@@ -281 +281 @@
  * @param   hLock               The lock handle.
  */
-RTDECL(int)  RTLockValidatorRecCreate(PRTLOCKVALIDATORREC *ppRec, RTLOCKVALIDATORCLASS hClass,
-                                      uint32_t uSubClass, const char *pszName, void *hLock);
-
-/**
- * Deinitialize and destroy a record created by RTLockValidatorRecCreate.
+RTDECL(int)  RTLockValidatorRecExclCreate(PRTLOCKVALRECEXCL *ppRec, RTLOCKVALIDATORCLASS hClass,
+                                          uint32_t uSubClass, const char *pszName, void *hLock);
+
+/**
+ * Deinitialize and destroy a record created by RTLockValidatorRecExclCreate.
  *
  * @param   ppRec               Pointer to the record pointer.  Will be set to
  *                              NULL.
  */
-RTDECL(void) RTLockValidatorRecDestroy(PRTLOCKVALIDATORREC *ppRec);
+RTDECL(void) RTLockValidatorRecExclDestroy(PRTLOCKVALRECEXCL *ppRec);
 
 /**
  * Initialize a lock validator record for a shared lock.
  *
- * Use RTLockValidatorSharedRecDelete to deinitialize it.
+ * Use RTLockValidatorRecSharedDelete to deinitialize it.
  *
  * @param   pRec                The shared lock record.
@@ -306 +306 @@
  * @param   hLock               The lock handle.
  */
-RTDECL(void) RTLockValidatorSharedRecInit(PRTLOCKVALIDATORSHARED pRec, RTLOCKVALIDATORCLASS hClass,
+RTDECL(void) RTLockValidatorRecSharedInit(PRTLOCKVALRECSHRD pRec, RTLOCKVALIDATORCLASS hClass,
                                           uint32_t uSubClass, const char *pszName, void *hLock);
 /**
  * Uninitialize a lock validator record previously initialized by
- * RTLockValidatorSharedRecInit.
+ * RTLockValidatorRecSharedInit.
  *
  * @param   pRec                The shared lock record.  Must be valid.
  */
-RTDECL(void) RTLockValidatorSharedRecDelete(PRTLOCKVALIDATORSHARED pRec);
+RTDECL(void) RTLockValidatorRecSharedDelete(PRTLOCKVALRECSHRD pRec);
 
 /**
@@ -324 +324 @@
  * @param   pRec2               Record 2.
  */
-RTDECL(int) RTLockValidatorMakeSiblings(PRTLOCKVALIDATORRECCORE pRec1, PRTLOCKVALIDATORRECCORE pRec2);
+RTDECL(int) RTLockValidatorRecMakeSiblings(PRTLOCKVALRECCORE pRec1, PRTLOCKVALRECCORE pRec2);
 
 /**
@@ -342 +342 @@
  * @param   pSrcPos             The source position of the lock operation.
  */
-RTDECL(int)  RTLockValidatorCheckOrder(PRTLOCKVALIDATORREC pRec, RTTHREAD hThread, PCRTLOCKVALIDATORSRCPOS pSrcPos);
+RTDECL(int)  RTLockValidatorCheckOrder(PRTLOCKVALRECEXCL pRec, RTTHREAD hThread, PCRTLOCKVALSRCPOS pSrcPos);
 
 /**
@@ -361 +361 @@
  * @param   pSrcPos             The source position of the lock operation.
  */
-RTDECL(int) RTLockValidatorCheckBlocking(PRTLOCKVALIDATORREC pRec, RTTHREAD hThread,
+RTDECL(int) RTLockValidatorCheckBlocking(PRTLOCKVALRECEXCL pRec, RTTHREAD hThread,
                                          RTTHREADSTATE enmState, bool fRecursiveOk,
-                                         PCRTLOCKVALIDATORSRCPOS pSrcPos);
+                                         PCRTLOCKVALSRCPOS pSrcPos);
 
 /**
@@ -384 +384 @@
  * @param   pSrcPos             The source position of the lock operation.
  */
-RTDECL(int) RTLockValidatorCheckWriteOrderBlocking(PRTLOCKVALIDATORREC pWrite, PRTLOCKVALIDATORSHARED pRead,
+RTDECL(int) RTLockValidatorCheckWriteOrderBlocking(PRTLOCKVALRECEXCL pWrite, PRTLOCKVALRECSHRD pRead,
                                                    RTTHREAD hThread, RTTHREADSTATE enmState, bool fRecursiveOk,
-                                                   PCRTLOCKVALIDATORSRCPOS pSrcPos);
+                                                   PCRTLOCKVALSRCPOS pSrcPos);
 
 /**
@@ -407 +407 @@
  * @param   pSrcPos             The source position of the lock operation.
  */
-RTDECL(int) RTLockValidatorCheckReadOrderBlocking(PRTLOCKVALIDATORSHARED pRead, PRTLOCKVALIDATORREC pWrite,
+RTDECL(int) RTLockValidatorCheckReadOrderBlocking(PRTLOCKVALRECSHRD pRead, PRTLOCKVALRECEXCL pWrite,
                                                   RTTHREAD hThread, RTTHREADSTATE enmState, bool fRecursiveOk,
-                                                  PCRTLOCKVALIDATORSRCPOS pSrcPos);
+                                                  PCRTLOCKVALSRCPOS pSrcPos);
 
 /**
@@ -423 +423 @@
  * @param   pRec                The validator record.
  */
-RTDECL(int)  RTLockValidatorCheckAndRelease(PRTLOCKVALIDATORREC pRec);
+RTDECL(int)  RTLockValidatorCheckAndRelease(PRTLOCKVALRECEXCL pRec);
 
 /**
@@ -438 +438 @@
  * @param   hThread             The handle of the calling thread.
  */
-RTDECL(int)  RTLockValidatorCheckAndReleaseReadOwner(PRTLOCKVALIDATORSHARED pRead, RTTHREAD hThread);
+RTDECL(int)  RTLockValidatorCheckAndReleaseReadOwner(PRTLOCKVALRECSHRD pRead, RTTHREAD hThread);
 
 /**
@@ -453 +453 @@
  * @param   pSrcPos             The source position of the lock operation.
  */
-RTDECL(int) RTLockValidatorRecordRecursion(PRTLOCKVALIDATORREC pRec, PCRTLOCKVALIDATORSRCPOS pSrcPos);
+RTDECL(int) RTLockValidatorRecordRecursion(PRTLOCKVALRECEXCL pRec, PCRTLOCKVALSRCPOS pSrcPos);
 
 /**
@@ -467 +467 @@
  * @param   pRec                The validator record.
  */
-RTDECL(int) RTLockValidatorUnwindRecursion(PRTLOCKVALIDATORREC pRec);
+RTDECL(int) RTLockValidatorUnwindRecursion(PRTLOCKVALRECEXCL pRec);
 
 /**
@@ -485 +485 @@
  * @param   pWrite              The validator record for the writer.
  */
-RTDECL(int) RTLockValidatorRecordReadWriteRecursion(PRTLOCKVALIDATORREC pWrite, PRTLOCKVALIDATORSHARED pRead, PCRTLOCKVALIDATORSRCPOS pSrcPos);
+RTDECL(int) RTLockValidatorRecordReadWriteRecursion(PRTLOCKVALRECEXCL pWrite, PRTLOCKVALRECSHRD pRead, PCRTLOCKVALSRCPOS pSrcPos);
 
 /**
@@ -501 +501 @@
  * @param   pWrite              The validator record for the writer.
  */
-RTDECL(int) RTLockValidatorUnwindReadWriteRecursion(PRTLOCKVALIDATORREC pWrite, PRTLOCKVALIDATORSHARED pRead);
+RTDECL(int) RTLockValidatorUnwindReadWriteRecursion(PRTLOCKVALRECEXCL pWrite, PRTLOCKVALRECSHRD pRead);
 
 /**
@@ -517 +517 @@
  * @param   pSrcPos             The source position of the lock operation.
  */
-RTDECL(RTTHREAD) RTLockValidatorSetOwner(PRTLOCKVALIDATORREC pRec, RTTHREAD hThread, PCRTLOCKVALIDATORSRCPOS pSrcPos);
+RTDECL(RTTHREAD) RTLockValidatorSetOwner(PRTLOCKVALRECEXCL pRec, RTTHREAD hThread, PCRTLOCKVALSRCPOS pSrcPos);
 
 /**
@@ -528 +528 @@
  * @param   pRec                The validator record.
  */
-RTDECL(RTTHREAD) RTLockValidatorUnsetOwner(PRTLOCKVALIDATORREC pRec);
+RTDECL(RTTHREAD) RTLockValidatorUnsetOwner(PRTLOCKVALRECEXCL pRec);
 
 /**
@@ -540 +540 @@
  * @param   pSrcPos             The source position of the lock operation.
  */
-RTDECL(void) RTLockValidatorAddReadOwner(PRTLOCKVALIDATORSHARED pRead, RTTHREAD hThread, PCRTLOCKVALIDATORSRCPOS pSrcPos);
+RTDECL(void) RTLockValidatorAddReadOwner(PRTLOCKVALRECSHRD pRead, RTTHREAD hThread, PCRTLOCKVALSRCPOS pSrcPos);
 
 /**
@@ -551 +551 @@
  * @param   hThread             The thread to to remove.
  */
-RTDECL(void) RTLockValidatorRemoveReadOwner(PRTLOCKVALIDATORSHARED pRead, RTTHREAD hThread);
+RTDECL(void) RTLockValidatorRemoveReadOwner(PRTLOCKVALRECSHRD pRead, RTTHREAD hThread);
 
 /**

trunk/include/iprt/types.h

@@ -1479 +1479 @@
 /** Pointer to a lock validator record.
  * The structure definition is found in iprt/lockvalidator.h.  */
-typedef struct RTLOCKVALIDATORREC          *PRTLOCKVALIDATORREC;
+typedef struct RTLOCKVALRECEXCL        *PRTLOCKVALRECEXCL;
 /** Pointer to a lock validator source poisition.
  * The structure definition is found in iprt/lockvalidator.h.  */
-typedef struct RTLOCKVALIDATORSRCPOS       *PRTLOCKVALIDATORSRCPOS;
+typedef struct RTLOCKVALSRCPOS         *PRTLOCKVALSRCPOS;
 /** Pointer to a const lock validator source poisition.
  * The structure definition is found in iprt/lockvalidator.h.  */
-typedef struct RTLOCKVALIDATORSRCPOS const *PCRTLOCKVALIDATORSRCPOS;
+typedef struct RTLOCKVALSRCPOS const   *PCRTLOCKVALSRCPOS;
 
 

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

@@ -58 +58 @@
 {
     /** The current record. */
-    PRTLOCKVALIDATORRECUNION    pRec;
+    PRTLOCKVALRECUNION    pRec;
     /** The current entry number if pRec is a shared one. */
     uint32_t                    iEntry;
@@ -70 +70 @@
      * siblings.  This is used for validating a deadlock stack as well as
      * terminating the sibling walk. */
-    PRTLOCKVALIDATORRECUNION    pFirstSibling;
+    PRTLOCKVALRECUNION    pFirstSibling;
 } RTLOCKVALIDATORDDENTRY;
 
@@ -92 +92 @@
 *******************************************************************************/
 /** Serializing object destruction and deadlock detection.
- * NS: RTLOCKVALIDATORREC and RTTHREADINT destruction.
+ * NS: RTLOCKVALIDATORREC* and RTTHREADINT destruction.
  * EW: Deadlock detection.
  */
@@ -114 +114 @@
 
 /** Wrapper around ASMAtomicReadPtr. */
-DECL_FORCE_INLINE(PRTLOCKVALIDATORRECUNION) rtLockValidatorReadRecUnionPtr(PRTLOCKVALIDATORRECUNION volatile *ppRec)
-{
-    return (PRTLOCKVALIDATORRECUNION)ASMAtomicReadPtr((void * volatile *)ppRec);
+DECL_FORCE_INLINE(PRTLOCKVALRECUNION) rtLockValidatorReadRecUnionPtr(PRTLOCKVALRECUNION volatile *ppRec)
+{
+    return (PRTLOCKVALRECUNION)ASMAtomicReadPtr((void * volatile *)ppRec);
 }
 
 
 /** Wrapper around ASMAtomicWritePtr. */
-DECL_FORCE_INLINE(void) rtLockValidatorWriteRecUnionPtr(PRTLOCKVALIDATORRECUNION volatile *ppRec, PRTLOCKVALIDATORRECUNION pRecNew)
+DECL_FORCE_INLINE(void) rtLockValidatorWriteRecUnionPtr(PRTLOCKVALRECUNION volatile *ppRec, PRTLOCKVALRECUNION pRecNew)
 {
     ASMAtomicWritePtr((void * volatile *)ppRec, pRecNew);
@@ -135 +135 @@
 
 /** Wrapper around ASMAtomicUoReadPtr. */
-DECL_FORCE_INLINE(PRTLOCKVALIDATORSHAREDONE) rtLockValidatorUoReadSharedOwner(PRTLOCKVALIDATORSHAREDONE volatile *ppOwner)
-{
-    return (PRTLOCKVALIDATORSHAREDONE)ASMAtomicUoReadPtr((void * volatile *)ppOwner);
+DECL_FORCE_INLINE(PRTLOCKVALRECSHRDOWN) rtLockValidatorUoReadSharedOwner(PRTLOCKVALRECSHRDOWN volatile *ppOwner)
+{
+    return (PRTLOCKVALRECSHRDOWN)ASMAtomicUoReadPtr((void * volatile *)ppOwner);
 }
 
@@ -189 +189 @@
  * @param   pszPrefix           Message suffix.
  */
-static void rtLockValidatorComplainAboutLock(const char *pszPrefix, PRTLOCKVALIDATORRECUNION pRec, const char *pszSuffix)
+static void rtLockValidatorComplainAboutLock(const char *pszPrefix, PRTLOCKVALRECUNION pRec, const char *pszSuffix)
 {
     if (    VALID_PTR(pRec)
@@ -196 +196 @@
         switch (pRec->Core.u32Magic)
         {
-            case RTLOCKVALIDATORREC_MAGIC:
+            case RTLOCKVALRECEXCL_MAGIC:
                 RTAssertMsg2AddWeak("%s%p %s xrec=%p own=%s nest=%u pos={%Rbn(%u) %Rfn %p}%s", pszPrefix,
                                     pRec->Excl.hLock, pRec->Excl.pszName, pRec,
@@ -204 +204 @@
                 break;
 
-            case RTLOCKVALIDATORSHARED_MAGIC:
+            case RTLOCKVALRECSHRD_MAGIC:
                 RTAssertMsg2AddWeak("%s%p %s srec=%p%s", pszPrefix,
                                     pRec->Shared.hLock, pRec->Shared.pszName, pRec,
@@ -210 +210 @@
                 break;
 
-            case RTLOCKVALIDATORSHAREDONE_MAGIC:
+            case RTLOCKVALRECSHRDOWN_MAGIC:
             {
-                PRTLOCKVALIDATORSHARED pShared = pRec->SharedOne.pSharedRec;
+                PRTLOCKVALRECSHRD pShared = pRec->SharedOwn.pSharedRec;
                 if (    VALID_PTR(pShared)
-                    &&  pShared->Core.u32Magic == RTLOCKVALIDATORSHARED_MAGIC)
+                    &&  pShared->Core.u32Magic == RTLOCKVALRECSHRD_MAGIC)
                     RTAssertMsg2AddWeak("%s%p %s srec=%p trec=%p thr=%s nest=%u pos={%Rbn(%u) %Rfn %p}%s", pszPrefix,
                                         pShared->hLock, pShared->pszName, pShared,
-                                        pRec, rtLockValidatorNameThreadHandle(&pRec->SharedOne.hThread), pRec->SharedOne.cRecursion,
-                                        pRec->SharedOne.SrcPos.pszFile, pRec->SharedOne.SrcPos.uLine, pRec->SharedOne.SrcPos.pszFunction, pRec->SharedOne.SrcPos.uId,
+                                        pRec, rtLockValidatorNameThreadHandle(&pRec->SharedOwn.hThread), pRec->SharedOwn.cRecursion,
+                                        pRec->SharedOwn.SrcPos.pszFile, pRec->SharedOwn.SrcPos.uLine, pRec->SharedOwn.SrcPos.pszFunction, pRec->SharedOwn.SrcPos.uId,
                                         pszSuffix);
                 else
                     RTAssertMsg2AddWeak("%sbad srec=%p trec=%p thr=%s nest=%u pos={%Rbn(%u) %Rfn %p}%s", pszPrefix,
                                         pShared,
-                                        pRec, rtLockValidatorNameThreadHandle(&pRec->SharedOne.hThread), pRec->SharedOne.cRecursion,
-                                        pRec->SharedOne.SrcPos.pszFile, pRec->SharedOne.SrcPos.uLine, pRec->SharedOne.SrcPos.pszFunction, pRec->SharedOne.SrcPos.uId,
+                                        pRec, rtLockValidatorNameThreadHandle(&pRec->SharedOwn.hThread), pRec->SharedOwn.cRecursion,
+                                        pRec->SharedOwn.SrcPos.pszFile, pRec->SharedOwn.SrcPos.uLine, pRec->SharedOwn.SrcPos.pszFunction, pRec->SharedOwn.SrcPos.uId,
                                         pszSuffix);
                 break;
@@ -245 +245 @@
  * @param   pRec                The main lock involved. Can be NULL.
  */
-static void rtLockValidatorComplainFirst(const char *pszWhat, PCRTLOCKVALIDATORSRCPOS pSrcPos, PRTTHREADINT pThreadSelf, PRTLOCKVALIDATORRECUNION pRec)
+static void rtLockValidatorComplainFirst(const char *pszWhat, PCRTLOCKVALSRCPOS pSrcPos, PRTTHREADINT pThreadSelf, PRTLOCKVALRECUNION pRec)
 {
     if (!ASMAtomicUoReadBool(&g_fLockValidatorQuiet))
@@ -293 +293 @@
  * @param   pSrc                The source.
  */
-DECL_FORCE_INLINE(void) rtLockValidatorCopySrcPos(PRTLOCKVALIDATORSRCPOS pDst, PCRTLOCKVALIDATORSRCPOS pSrc)
+DECL_FORCE_INLINE(void) rtLockValidatorCopySrcPos(PRTLOCKVALSRCPOS pDst, PCRTLOCKVALSRCPOS pSrc)
 {
     ASMAtomicUoWriteU32(&pDst->uLine,                           pSrc->uLine);
@@ -307 +307 @@
  * @param   pSrcPos             The source position record.
  */
-DECL_FORCE_INLINE(void) rtLockValidatorInitSrcPos(PRTLOCKVALIDATORSRCPOS pSrcPos)
+DECL_FORCE_INLINE(void) rtLockValidatorInitSrcPos(PRTLOCKVALSRCPOS pSrcPos)
 {
     pSrcPos->pszFile        = NULL;
@@ -320 +320 @@
 
 /**
- * Serializes destruction of RTLOCKVALIDATORREC and RTTHREADINT structures.
+ * Serializes destruction of RTLOCKVALIDATORREC* and RTTHREADINT structures.
  */
 DECLHIDDEN(void) rtLockValidatorSerializeDestructEnter(void)
@@ -364 +364 @@
 
 
-RTDECL(void) RTLockValidatorRecInit(PRTLOCKVALIDATORREC pRec, RTLOCKVALIDATORCLASS hClass,
-                                    uint32_t uSubClass, const char *pszName, void *hLock)
-{
-    pRec->Core.u32Magic = RTLOCKVALIDATORREC_MAGIC;
+/**
+ * Unlinks all siblings.
+ *
+ * This is used during record deletion and assumes no races.
+ *
+ * @param   pCore               One of the siblings.
+ */
+static void rtLockValidatorUnlinkAllSiblings(PRTLOCKVALRECCORE pCore)
+{
+    /* ASSUMES sibling destruction doesn't involve any races and that all
+       related records are to be disposed off now.  */
+    PRTLOCKVALRECUNION pSibling = (PRTLOCKVALRECUNION)pCore;
+    while (pSibling)
+    {
+        PRTLOCKVALRECUNION volatile *ppCoreNext;
+        switch (pSibling->Core.u32Magic)
+        {
+            case RTLOCKVALRECEXCL_MAGIC:
+            case RTLOCKVALRECEXCL_MAGIC_DEAD:
+                ppCoreNext = &pSibling->Excl.pSibling;
+                break;
+
+            case RTLOCKVALRECSHRD_MAGIC:
+            case RTLOCKVALRECSHRD_MAGIC_DEAD:
+                ppCoreNext = &pSibling->Shared.pSibling;
+                break;
+
+            default:
+                AssertFailed();
+                ppCoreNext = NULL;
+                break;
+        }
+        if (RT_UNLIKELY(ppCoreNext))
+            break;
+        pSibling = (PRTLOCKVALRECUNION)ASMAtomicXchgPtr((void * volatile *)ppCoreNext, NULL);
+    }
+}
+
+
+RTDECL(void) RTLockValidatorRecExclInit(PRTLOCKVALRECEXCL pRec, RTLOCKVALIDATORCLASS hClass,
+                                        uint32_t uSubClass, const char *pszName, void *hLock)
+{
+    pRec->Core.u32Magic = RTLOCKVALRECEXCL_MAGIC;
     pRec->fEnabled      = RTLockValidatorIsEnabled();
     pRec->afReserved[0] = 0;
@@ -396 +435 @@
 
 
-RTDECL(int)  RTLockValidatorRecCreate(PRTLOCKVALIDATORREC *ppRec, RTLOCKVALIDATORCLASS hClass,
-                                      uint32_t uSubClass, const char *pszName, void *pvLock)
-{
-    PRTLOCKVALIDATORREC pRec;
-    *ppRec = pRec = (PRTLOCKVALIDATORREC)RTMemAlloc(sizeof(*pRec));
+RTDECL(int)  RTLockValidatorRecExclCreate(PRTLOCKVALRECEXCL *ppRec, RTLOCKVALIDATORCLASS hClass,
+                                          uint32_t uSubClass, const char *pszName, void *pvLock)
+{
+    PRTLOCKVALRECEXCL pRec;
+    *ppRec = pRec = (PRTLOCKVALRECEXCL)RTMemAlloc(sizeof(*pRec));
     if (!pRec)
         return VERR_NO_MEMORY;
 
-    RTLockValidatorRecInit(pRec, hClass, uSubClass, pszName, pvLock);
+    RTLockValidatorRecExclInit(pRec, hClass, uSubClass, pszName, pvLock);
 
     return VINF_SUCCESS;
@@ -410 +449 @@
 
 
-/**
- * Unlinks all siblings.
- *
- * This is used during record deletion and assumes no races.
- *
- * @param   pCore               One of the siblings.
- */
-static void rtLockValidatorUnlinkAllSiblings(PRTLOCKVALIDATORRECCORE pCore)
-{
-    /* ASSUMES sibling destruction doesn't involve any races and that all
-       related records are to be disposed off now.  */
-    PRTLOCKVALIDATORRECUNION pSibling = (PRTLOCKVALIDATORRECUNION)pCore;
-    while (pSibling)
-    {
-        PRTLOCKVALIDATORRECUNION volatile *ppCoreNext;
-        switch (pSibling->Core.u32Magic)
-        {
-            case RTLOCKVALIDATORREC_MAGIC:
-            case RTLOCKVALIDATORREC_MAGIC_DEAD:
-                ppCoreNext = &pSibling->Excl.pSibling;
-                break;
-
-            case RTLOCKVALIDATORSHARED_MAGIC:
-            case RTLOCKVALIDATORSHARED_MAGIC_DEAD:
-                ppCoreNext = &pSibling->Shared.pSibling;
-                break;
-
-            default:
-                AssertFailed();
-                ppCoreNext = NULL;
-                break;
-        }
-        if (RT_UNLIKELY(ppCoreNext))
-            break;
-        pSibling = (PRTLOCKVALIDATORRECUNION)ASMAtomicXchgPtr((void * volatile *)ppCoreNext, NULL);
-    }
-}
-
-
-RTDECL(void) RTLockValidatorRecDelete(PRTLOCKVALIDATORREC pRec)
-{
-    Assert(pRec->Core.u32Magic == RTLOCKVALIDATORREC_MAGIC);
+RTDECL(void) RTLockValidatorRecExclDelete(PRTLOCKVALRECEXCL pRec)
+{
+    Assert(pRec->Core.u32Magic == RTLOCKVALRECEXCL_MAGIC);
 
     rtLockValidatorSerializeDestructEnter();
 
-    ASMAtomicWriteU32(&pRec->Core.u32Magic, RTLOCKVALIDATORREC_MAGIC_DEAD);
+    ASMAtomicWriteU32(&pRec->Core.u32Magic, RTLOCKVALRECEXCL_MAGIC_DEAD);
     ASMAtomicWriteHandle(&pRec->hThread, NIL_RTTHREAD);
     ASMAtomicWriteHandle(&pRec->hClass, NIL_RTLOCKVALIDATORCLASS);
@@ -464 +464 @@
 
 
-RTDECL(void) RTLockValidatorRecDestroy(PRTLOCKVALIDATORREC *ppRec)
-{
-    PRTLOCKVALIDATORREC pRec = *ppRec;
+RTDECL(void) RTLockValidatorRecExclDestroy(PRTLOCKVALRECEXCL *ppRec)
+{
+    PRTLOCKVALRECEXCL pRec = *ppRec;
     *ppRec = NULL;
     if (pRec)
     {
-        RTLockValidatorRecDelete(pRec);
+        RTLockValidatorRecExclDelete(pRec);
         RTMemFree(pRec);
     }
@@ -476 +476 @@
 
 
-RTDECL(void) RTLockValidatorSharedRecInit(PRTLOCKVALIDATORSHARED pRec, RTLOCKVALIDATORCLASS hClass,
+RTDECL(void) RTLockValidatorRecSharedInit(PRTLOCKVALRECSHRD pRec, RTLOCKVALIDATORCLASS hClass,
                                           uint32_t uSubClass, const char *pszName, void *hLock)
 {
-    pRec->Core.u32Magic = RTLOCKVALIDATORSHARED_MAGIC;
+    pRec->Core.u32Magic = RTLOCKVALRECSHRD_MAGIC;
     pRec->uSubClass     = uSubClass;
     pRec->hClass        = hClass;
@@ -501 +501 @@
 
 
-RTDECL(void) RTLockValidatorSharedRecDelete(PRTLOCKVALIDATORSHARED pRec)
-{
-    Assert(pRec->Core.u32Magic == RTLOCKVALIDATORSHARED_MAGIC);
+RTDECL(void) RTLockValidatorRecSharedDelete(PRTLOCKVALRECSHRD pRec)
+{
+    Assert(pRec->Core.u32Magic == RTLOCKVALRECSHRD_MAGIC);
 
     /*
@@ -519 +519 @@
     }
 
-    ASMAtomicWriteU32(&pRec->Core.u32Magic, RTLOCKVALIDATORSHARED_MAGIC_DEAD);
+    ASMAtomicWriteU32(&pRec->Core.u32Magic, RTLOCKVALRECSHRD_MAGIC_DEAD);
     ASMAtomicUoWriteHandle(&pRec->hClass, NIL_RTLOCKVALIDATORCLASS);
     if (pRec->papOwners)
     {
-        PRTLOCKVALIDATORSHAREDONE volatile *papOwners = pRec->papOwners;
+        PRTLOCKVALRECSHRDOWN volatile *papOwners = pRec->papOwners;
         ASMAtomicUoWritePtr((void * volatile *)&pRec->papOwners, NULL);
         ASMAtomicUoWriteU32(&pRec->cAllocated, 0);
@@ -545 +545 @@
  * @param   piEntry             Where to optionally return the table in index.
  */
-DECLINLINE(PRTLOCKVALIDATORSHAREDONE)
-rtLockValidatorSharedRecFindThread(PRTLOCKVALIDATORSHARED pShared, RTTHREAD hThread, uint32_t *piEntry)
+DECLINLINE(PRTLOCKVALRECSHRDOWN)
+rtLockValidatorSharedRecFindThread(PRTLOCKVALRECSHRD pShared, RTTHREAD hThread, uint32_t *piEntry)
 {
     rtLockValidatorSerializeDetectionEnter();
     if (pShared->papOwners)
     {
-        PRTLOCKVALIDATORSHAREDONE volatile *papOwners = pShared->papOwners;
+        PRTLOCKVALRECSHRDOWN volatile *papOwners = pShared->papOwners;
         uint32_t const                      cMax      = pShared->cAllocated;
         for (uint32_t iEntry = 0; iEntry < cMax; iEntry++)
         {
-            PRTLOCKVALIDATORSHAREDONE pEntry = rtLockValidatorUoReadSharedOwner(&papOwners[iEntry]);
+            PRTLOCKVALRECSHRDOWN pEntry = rtLockValidatorUoReadSharedOwner(&papOwners[iEntry]);
             if (pEntry && pEntry->hThread == hThread)
             {
@@ -578 +578 @@
  * @param   pSrcPos             The source position.
  */
-DECLINLINE(PRTLOCKVALIDATORSHAREDONE)
-rtLockValidatorSharedRecAllocThread(PRTLOCKVALIDATORSHARED pRead, RTTHREAD hThread, PCRTLOCKVALIDATORSRCPOS pSrcPos)
-{
-    PRTLOCKVALIDATORSHAREDONE pEntry;
-
-    pEntry = (PRTLOCKVALIDATORSHAREDONE)RTMemAlloc(sizeof(RTLOCKVALIDATORSHAREDONE));
+DECLINLINE(PRTLOCKVALRECSHRDOWN)
+rtLockValidatorSharedRecAllocThread(PRTLOCKVALRECSHRD pRead, RTTHREAD hThread, PCRTLOCKVALSRCPOS pSrcPos)
+{
+    PRTLOCKVALRECSHRDOWN pEntry;
+
+    pEntry = (PRTLOCKVALRECSHRDOWN)RTMemAlloc(sizeof(RTLOCKVALRECSHRDOWN));
     if (pEntry)
     {
-        pEntry->Core.u32Magic   = RTLOCKVALIDATORSHAREDONE_MAGIC;
+        pEntry->Core.u32Magic   = RTLOCKVALRECSHRDOWN_MAGIC;
         pEntry->cRecursion      = 1;
         pEntry->hThread         = hThread;
@@ -608 +608 @@
  * @param   pEntry              The thread entry.
  */
-DECLINLINE(void) rtLockValidatorSharedRecFreeThread(PRTLOCKVALIDATORSHAREDONE pEntry)
+DECLINLINE(void) rtLockValidatorSharedRecFreeThread(PRTLOCKVALRECSHRDOWN pEntry)
 {
     if (pEntry)
     {
         rtLockValidatorSerializeDestructEnter();
-        ASMAtomicWriteU32(&pEntry->Core.u32Magic, RTLOCKVALIDATORSHAREDONE_MAGIC_DEAD);
+        ASMAtomicWriteU32(&pEntry->Core.u32Magic, RTLOCKVALRECSHRDOWN_MAGIC_DEAD);
         ASMAtomicWriteHandle(&pEntry->hThread, NIL_RTTHREAD);
         rtLockValidatorSerializeDestructLeave();
@@ -631 +631 @@
  * @param   pShared             The shared lock record.
  */
-static bool rtLockValidatorSharedRecMakeRoom(PRTLOCKVALIDATORSHARED pShared)
+static bool rtLockValidatorSharedRecMakeRoom(PRTLOCKVALRECSHRD pShared)
 {
     for (unsigned i = 0; i < 1000; i++)
@@ -649 +649 @@
          * Try grab the privilege to reallocating the table.
          */
-        if (    pShared->Core.u32Magic == RTLOCKVALIDATORSHARED_MAGIC
+        if (    pShared->Core.u32Magic == RTLOCKVALRECSHRD_MAGIC
             &&  ASMAtomicCmpXchgBool(&pShared->fReallocating, true, false))
         {
@@ -663 +663 @@
                 uint32_t                    cInc = RT_ALIGN_32(pShared->cEntries - cAllocated, 1);
 #endif
-                PRTLOCKVALIDATORSHAREDONE  *papOwners;
-                papOwners = (PRTLOCKVALIDATORSHAREDONE *)RTMemRealloc((void *)pShared->papOwners,
+                PRTLOCKVALRECSHRDOWN  *papOwners;
+                papOwners = (PRTLOCKVALRECSHRDOWN *)RTMemRealloc((void *)pShared->papOwners,
                                                                       (cAllocated + cInc) * sizeof(void *));
                 if (!papOwners)
@@ -688 +688 @@
 
         rtLockValidatorSerializeDetectionEnter();
-        if (RT_UNLIKELY(pShared->Core.u32Magic != RTLOCKVALIDATORSHARED_MAGIC))
+        if (RT_UNLIKELY(pShared->Core.u32Magic != RTLOCKVALRECSHRD_MAGIC))
             break;
 
@@ -708 +708 @@
  * @param   pEntry              The thread entry.
  */
-DECLINLINE(bool) rtLockValidatorSharedRecAddThread(PRTLOCKVALIDATORSHARED pShared, PRTLOCKVALIDATORSHAREDONE pEntry)
+DECLINLINE(bool) rtLockValidatorSharedRecAddThread(PRTLOCKVALRECSHRD pShared, PRTLOCKVALRECSHRDOWN pEntry)
 {
     rtLockValidatorSerializeDetectionEnter();
-    if (RT_LIKELY(pShared->Core.u32Magic == RTLOCKVALIDATORSHARED_MAGIC)) /* paranoia */
+    if (RT_LIKELY(pShared->Core.u32Magic == RTLOCKVALRECSHRD_MAGIC)) /* paranoia */
     {
         if (   ASMAtomicIncU32(&pShared->cEntries) > pShared->cAllocated /** @todo add fudge */
@@ -717 +717 @@
             return false; /* the worker leave the lock */
 
-        PRTLOCKVALIDATORSHAREDONE volatile *papOwners = pShared->papOwners;
+        PRTLOCKVALRECSHRDOWN volatile *papOwners = pShared->papOwners;
         uint32_t const                      cMax      = pShared->cAllocated;
         for (unsigned i = 0; i < 100; i++)
@@ -745 +745 @@
  * @param   iEntry              The last known index.
  */
-DECLINLINE(void) rtLockValidatorSharedRecRemoveAndFree(PRTLOCKVALIDATORSHARED pShared, PRTLOCKVALIDATORSHAREDONE pEntry,
+DECLINLINE(void) rtLockValidatorSharedRecRemoveAndFree(PRTLOCKVALRECSHRD pShared, PRTLOCKVALRECSHRDOWN pEntry,
                                                        uint32_t iEntry)
 {
@@ -752 +752 @@
      */
     rtLockValidatorSerializeDetectionEnter();
-    AssertReturnVoidStmt(pShared->Core.u32Magic == RTLOCKVALIDATORSHARED_MAGIC, rtLockValidatorSerializeDetectionLeave());
+    AssertReturnVoidStmt(pShared->Core.u32Magic == RTLOCKVALRECSHRD_MAGIC, rtLockValidatorSerializeDetectionLeave());
     if (RT_UNLIKELY(   iEntry >= pShared->cAllocated
                     || !ASMAtomicCmpXchgPtr((void * volatile *)&pShared->papOwners[iEntry], NULL, pEntry)))
@@ -758 +758 @@
         /* this shouldn't happen yet... */
         AssertFailed();
-        PRTLOCKVALIDATORSHAREDONE volatile *papOwners = pShared->papOwners;
+        PRTLOCKVALRECSHRDOWN volatile *papOwners = pShared->papOwners;
         uint32_t const                      cMax      = pShared->cAllocated;
         for (iEntry = 0; iEntry < cMax; iEntry++)
@@ -776 +776 @@
 
 
-RTDECL(int) RTLockValidatorMakeSiblings(PRTLOCKVALIDATORRECCORE pRec1, PRTLOCKVALIDATORRECCORE pRec2)
+RTDECL(int) RTLockValidatorRecMakeSiblings(PRTLOCKVALRECCORE pRec1, PRTLOCKVALRECCORE pRec2)
 {
     /*
      * Validate input.
      */
-    PRTLOCKVALIDATORRECUNION p1 = (PRTLOCKVALIDATORRECUNION)pRec1;
-    PRTLOCKVALIDATORRECUNION p2 = (PRTLOCKVALIDATORRECUNION)pRec2;
+    PRTLOCKVALRECUNION p1 = (PRTLOCKVALRECUNION)pRec1;
+    PRTLOCKVALRECUNION p2 = (PRTLOCKVALRECUNION)pRec2;
 
     AssertPtrReturn(p1, VERR_SEM_LV_INVALID_PARAMETER);
-    AssertReturn(   p1->Core.u32Magic == RTLOCKVALIDATORREC_MAGIC
-                 || p1->Core.u32Magic == RTLOCKVALIDATORSHARED_MAGIC
+    AssertReturn(   p1->Core.u32Magic == RTLOCKVALRECEXCL_MAGIC
+                 || p1->Core.u32Magic == RTLOCKVALRECSHRD_MAGIC
                  , VERR_SEM_LV_INVALID_PARAMETER);
 
     AssertPtrReturn(p2, VERR_SEM_LV_INVALID_PARAMETER);
-    AssertReturn(   p2->Core.u32Magic == RTLOCKVALIDATORREC_MAGIC
-                 || p2->Core.u32Magic == RTLOCKVALIDATORSHARED_MAGIC
+    AssertReturn(   p2->Core.u32Magic == RTLOCKVALRECEXCL_MAGIC
+                 || p2->Core.u32Magic == RTLOCKVALRECSHRD_MAGIC
                  , VERR_SEM_LV_INVALID_PARAMETER);
 
     /*
-     * Link them.
-     */
-    if (    p1->Core.u32Magic == RTLOCKVALIDATORREC_MAGIC
-        &&  p2->Core.u32Magic == RTLOCKVALIDATORSHARED_MAGIC)
+     * Link them (circular list).
+     */
+    if (    p1->Core.u32Magic == RTLOCKVALRECEXCL_MAGIC
+        &&  p2->Core.u32Magic == RTLOCKVALRECSHRD_MAGIC)
     {
         p1->Excl.pSibling   = p2;
         p2->Shared.pSibling = p1;
     }
-    else if (   p1->Core.u32Magic == RTLOCKVALIDATORSHARED_MAGIC
-             && p2->Core.u32Magic == RTLOCKVALIDATORREC_MAGIC)
+    else if (   p1->Core.u32Magic == RTLOCKVALRECSHRD_MAGIC
+             && p2->Core.u32Magic == RTLOCKVALRECEXCL_MAGIC)
     {
         p1->Shared.pSibling = p2;
@@ -816 +816 @@
 
 
-RTDECL(int) RTLockValidatorCheckOrder(PRTLOCKVALIDATORREC pRec, RTTHREAD hThread, PCRTLOCKVALIDATORSRCPOS pSrcPos)
-{
-    AssertReturn(pRec->Core.u32Magic == RTLOCKVALIDATORREC_MAGIC, VERR_SEM_LV_INVALID_PARAMETER);
+RTDECL(int) RTLockValidatorCheckOrder(PRTLOCKVALRECEXCL pRec, RTTHREAD hThread, PCRTLOCKVALSRCPOS pSrcPos)
+{
+    AssertReturn(pRec->Core.u32Magic == RTLOCKVALRECEXCL_MAGIC, VERR_SEM_LV_INVALID_PARAMETER);
     if (!pRec->fEnabled)
         return VINF_SUCCESS;
@@ -835 +835 @@
 
 
-RTDECL(int)  RTLockValidatorCheckAndRelease(PRTLOCKVALIDATORREC pRec)
-{
-    AssertReturn(pRec->Core.u32Magic == RTLOCKVALIDATORREC_MAGIC, VERR_SEM_LV_INVALID_PARAMETER);
+RTDECL(int)  RTLockValidatorCheckAndRelease(PRTLOCKVALRECEXCL pRec)
+{
+    AssertReturn(pRec->Core.u32Magic == RTLOCKVALRECEXCL_MAGIC, VERR_SEM_LV_INVALID_PARAMETER);
     if (!pRec->fEnabled)
         return VINF_SUCCESS;
@@ -847 +847 @@
 
 
-RTDECL(int)  RTLockValidatorCheckAndReleaseReadOwner(PRTLOCKVALIDATORSHARED pRead, RTTHREAD hThread)
-{
-    AssertReturn(pRead->Core.u32Magic == RTLOCKVALIDATORSHARED_MAGIC, VERR_SEM_LV_INVALID_PARAMETER);
+RTDECL(int)  RTLockValidatorCheckAndReleaseReadOwner(PRTLOCKVALRECSHRD pRead, RTTHREAD hThread)
+{
+    AssertReturn(pRead->Core.u32Magic == RTLOCKVALRECSHRD_MAGIC, VERR_SEM_LV_INVALID_PARAMETER);
     if (!pRead->fEnabled)
         return VINF_SUCCESS;
@@ -858 +858 @@
      */
     uint32_t                    iEntry = 0;
-    PRTLOCKVALIDATORSHAREDONE   pEntry = rtLockValidatorSharedRecFindThread(pRead, hThread, &iEntry);
+    PRTLOCKVALRECSHRDOWN   pEntry = rtLockValidatorSharedRecFindThread(pRead, hThread, &iEntry);
     AssertReturn(pEntry, VERR_SEM_LV_NOT_OWNER);
 
@@ -882 +882 @@
 
 
-RTDECL(int) RTLockValidatorRecordRecursion(PRTLOCKVALIDATORREC pRec, PCRTLOCKVALIDATORSRCPOS pSrcPos)
-{
-    AssertReturn(pRec->Core.u32Magic == RTLOCKVALIDATORREC_MAGIC, VERR_SEM_LV_INVALID_PARAMETER);
+RTDECL(int) RTLockValidatorRecordRecursion(PRTLOCKVALRECEXCL pRec, PCRTLOCKVALSRCPOS pSrcPos)
+{
+    AssertReturn(pRec->Core.u32Magic == RTLOCKVALRECEXCL_MAGIC, VERR_SEM_LV_INVALID_PARAMETER);
     if (!pRec->fEnabled)
         return VINF_SUCCESS;
@@ -896 +896 @@
 
 
-RTDECL(int) RTLockValidatorUnwindRecursion(PRTLOCKVALIDATORREC pRec)
-{
-    AssertReturn(pRec->Core.u32Magic == RTLOCKVALIDATORREC_MAGIC, VERR_SEM_LV_INVALID_PARAMETER);
+RTDECL(int) RTLockValidatorUnwindRecursion(PRTLOCKVALRECEXCL pRec)
+{
+    AssertReturn(pRec->Core.u32Magic == RTLOCKVALRECEXCL_MAGIC, VERR_SEM_LV_INVALID_PARAMETER);
     if (!pRec->fEnabled)
         return VINF_SUCCESS;
@@ -910 +910 @@
 
 
-RTDECL(int) RTLockValidatorRecordReadWriteRecursion(PRTLOCKVALIDATORREC pWrite, PRTLOCKVALIDATORSHARED pRead, PCRTLOCKVALIDATORSRCPOS pSrcPos)
-{
-    AssertReturn(pWrite->Core.u32Magic == RTLOCKVALIDATORREC_MAGIC, VERR_SEM_LV_INVALID_PARAMETER);
-    AssertReturn(pRead->Core.u32Magic == RTLOCKVALIDATORSHARED_MAGIC, VERR_SEM_LV_INVALID_PARAMETER);
+RTDECL(int) RTLockValidatorRecordReadWriteRecursion(PRTLOCKVALRECEXCL pWrite, PRTLOCKVALRECSHRD pRead, PCRTLOCKVALSRCPOS pSrcPos)
+{
+    AssertReturn(pWrite->Core.u32Magic == RTLOCKVALRECEXCL_MAGIC, VERR_SEM_LV_INVALID_PARAMETER);
+    AssertReturn(pRead->Core.u32Magic == RTLOCKVALRECSHRD_MAGIC, VERR_SEM_LV_INVALID_PARAMETER);
     AssertReturn(pRead->fEnabled == pWrite->fEnabled, VERR_SEM_LV_INVALID_PARAMETER);
     if (!pWrite->fEnabled)
@@ -927 +927 @@
 
 
-RTDECL(int) RTLockValidatorUnwindReadWriteRecursion(PRTLOCKVALIDATORREC pWrite, PRTLOCKVALIDATORSHARED pRead)
-{
-    AssertReturn(pWrite->Core.u32Magic == RTLOCKVALIDATORREC_MAGIC, VERR_SEM_LV_INVALID_PARAMETER);
-    AssertReturn(pRead->Core.u32Magic == RTLOCKVALIDATORSHARED_MAGIC, VERR_SEM_LV_INVALID_PARAMETER);
+RTDECL(int) RTLockValidatorUnwindReadWriteRecursion(PRTLOCKVALRECEXCL pWrite, PRTLOCKVALRECSHRD pRead)
+{
+    AssertReturn(pWrite->Core.u32Magic == RTLOCKVALRECEXCL_MAGIC, VERR_SEM_LV_INVALID_PARAMETER);
+    AssertReturn(pRead->Core.u32Magic == RTLOCKVALRECSHRD_MAGIC, VERR_SEM_LV_INVALID_PARAMETER);
     AssertReturn(pRead->fEnabled == pWrite->fEnabled, VERR_SEM_LV_INVALID_PARAMETER);
     if (!pWrite->fEnabled)
@@ -943 +943 @@
 
 
-RTDECL(RTTHREAD) RTLockValidatorSetOwner(PRTLOCKVALIDATORREC pRec, RTTHREAD hThread, PCRTLOCKVALIDATORSRCPOS pSrcPos)
-{
-    AssertReturn(pRec->Core.u32Magic == RTLOCKVALIDATORREC_MAGIC, NIL_RTTHREAD);
+RTDECL(RTTHREAD) RTLockValidatorSetOwner(PRTLOCKVALRECEXCL pRec, RTTHREAD hThread, PCRTLOCKVALSRCPOS pSrcPos)
+{
+    AssertReturn(pRec->Core.u32Magic == RTLOCKVALRECEXCL_MAGIC, NIL_RTTHREAD);
     if (!pRec->fEnabled)
         return VINF_SUCCESS;
@@ -979 +979 @@
 
 
-RTDECL(RTTHREAD) RTLockValidatorUnsetOwner(PRTLOCKVALIDATORREC pRec)
-{
-    AssertReturn(pRec->Core.u32Magic == RTLOCKVALIDATORREC_MAGIC, NIL_RTTHREAD);
+RTDECL(RTTHREAD) RTLockValidatorUnsetOwner(PRTLOCKVALRECEXCL pRec)
+{
+    AssertReturn(pRec->Core.u32Magic == RTLOCKVALRECEXCL_MAGIC, NIL_RTTHREAD);
     if (!pRec->fEnabled)
         return VINF_SUCCESS;
@@ -1006 +1006 @@
 
 
-RTDECL(void) RTLockValidatorAddReadOwner(PRTLOCKVALIDATORSHARED pRead, RTTHREAD hThread, PCRTLOCKVALIDATORSRCPOS pSrcPos)
-{
-    AssertReturnVoid(pRead->Core.u32Magic == RTLOCKVALIDATORSHARED_MAGIC);
+RTDECL(void) RTLockValidatorAddReadOwner(PRTLOCKVALRECSHRD pRead, RTTHREAD hThread, PCRTLOCKVALSRCPOS pSrcPos)
+{
+    AssertReturnVoid(pRead->Core.u32Magic == RTLOCKVALRECSHRD_MAGIC);
     if (!pRead->fEnabled)
         return;
@@ -1020 +1020 @@
      *       so it can wait til later sometime.
      */
-    PRTLOCKVALIDATORSHAREDONE pEntry = rtLockValidatorSharedRecFindThread(pRead, hThread, NULL);
+    PRTLOCKVALRECSHRDOWN pEntry = rtLockValidatorSharedRecFindThread(pRead, hThread, NULL);
     if (pEntry)
     {
@@ -1037 +1037 @@
 
 
-RTDECL(void) RTLockValidatorRemoveReadOwner(PRTLOCKVALIDATORSHARED pRead, RTTHREAD hThread)
-{
-    AssertReturnVoid(pRead->Core.u32Magic == RTLOCKVALIDATORSHARED_MAGIC);
+RTDECL(void) RTLockValidatorRemoveReadOwner(PRTLOCKVALRECSHRD pRead, RTTHREAD hThread)
+{
+    AssertReturnVoid(pRead->Core.u32Magic == RTLOCKVALRECSHRD_MAGIC);
     if (!pRead->fEnabled)
         return;
@@ -1048 +1048 @@
      */
     uint32_t iEntry;
-    PRTLOCKVALIDATORSHAREDONE pEntry = rtLockValidatorSharedRecFindThread(pRead, hThread, &iEntry);
+    PRTLOCKVALRECSHRDOWN pEntry = rtLockValidatorSharedRecFindThread(pRead, hThread, &iEntry);
     AssertReturnVoid(pEntry);
     if (pEntry->cRecursion > 1)
@@ -1193 +1193 @@
  * @param   pFirstSibling   The first record we examined.
  */
-DECL_FORCE_INLINE(bool) rtLockValidatorDdMoreWorkLeft(PRTLOCKVALIDATORRECUNION pRec, uint32_t iEntry, PRTLOCKVALIDATORRECUNION pFirstSibling)
-{
-    PRTLOCKVALIDATORRECUNION pSibling;
+DECL_FORCE_INLINE(bool) rtLockValidatorDdMoreWorkLeft(PRTLOCKVALRECUNION pRec, uint32_t iEntry, PRTLOCKVALRECUNION pFirstSibling)
+{
+    PRTLOCKVALRECUNION pSibling;
 
     switch (pRec->Core.u32Magic)
     {
-        case RTLOCKVALIDATORREC_MAGIC:
+        case RTLOCKVALRECEXCL_MAGIC:
             pSibling = pRec->Excl.pSibling;
             break;
 
-        case RTLOCKVALIDATORSHARED_MAGIC:
+        case RTLOCKVALRECSHRD_MAGIC:
             if (iEntry + 1 < pRec->Shared.cAllocated)
                 return true;
@@ -1230 +1230 @@
  * @param   pThreadSelf     The calling thread.
  */
-static int rtLockValidatorDdDoDetection(PRTLOCKVALIDATORDDSTACK pStack, PRTLOCKVALIDATORRECUNION const pOriginalRec,
+static int rtLockValidatorDdDoDetection(PRTLOCKVALIDATORDDSTACK pStack, PRTLOCKVALRECUNION const pOriginalRec,
                                         PRTTHREADINT const pThreadSelf)
 {
@@ -1237 +1237 @@
     /* We could use a single RTLOCKVALIDATORDDENTRY variable here, but the
        compiler may make a better job of it when using individual variables. */
-    PRTLOCKVALIDATORRECUNION    pRec            = pOriginalRec;
-    PRTLOCKVALIDATORRECUNION    pFirstSibling   = pOriginalRec;
+    PRTLOCKVALRECUNION    pRec            = pOriginalRec;
+    PRTLOCKVALRECUNION    pFirstSibling   = pOriginalRec;
     uint32_t                    iEntry          = UINT32_MAX;
     PRTTHREADINT                pThread         = NIL_RTTHREAD;
@@ -1251 +1251 @@
         switch (pRec->Core.u32Magic)
         {
-            case RTLOCKVALIDATORREC_MAGIC:
+            case RTLOCKVALRECEXCL_MAGIC:
                 Assert(iEntry == UINT32_MAX);
                 pNextThread = rtLockValidatorReadThreadHandle(&pRec->Excl.hThread);
@@ -1268 +1268 @@
                 break;
 
-            case RTLOCKVALIDATORSHARED_MAGIC:
+            case RTLOCKVALRECSHRD_MAGIC:
                 /* Skip to the next sibling if same side.  ASSUMES reader priority. */
                 /** @todo The read side of a read-write lock is problematic if
@@ -1295 +1295 @@
                 {
                     uint32_t                            cAllocated = ASMAtomicUoReadU32(&pRec->Shared.cAllocated);
-                    PRTLOCKVALIDATORSHAREDONE volatile *papOwners  = pRec->Shared.papOwners;
+                    PRTLOCKVALRECSHRDOWN volatile *papOwners  = pRec->Shared.papOwners;
                     while (++iEntry < cAllocated)
                     {
-                        PRTLOCKVALIDATORSHAREDONE pEntry = rtLockValidatorUoReadSharedOwner(&papOwners[iEntry]);
+                        PRTLOCKVALRECSHRDOWN pEntry = rtLockValidatorUoReadSharedOwner(&papOwners[iEntry]);
                         if (   pEntry
-                            && pEntry->Core.u32Magic == RTLOCKVALIDATORSHAREDONE_MAGIC)
+                            && pEntry->Core.u32Magic == RTLOCKVALRECSHRDOWN_MAGIC)
                         {
                             pNextThread = rtLockValidatorReadThreadHandle(&pEntry->hThread);
@@ -1312 +1312 @@
                         }
                         else
-                            Assert(!pEntry || pEntry->Core.u32Magic == RTLOCKVALIDATORSHAREDONE_MAGIC_DEAD);
+                            Assert(!pEntry || pEntry->Core.u32Magic == RTLOCKVALRECSHRDOWN_MAGIC_DEAD);
                     }
                     if (pNextThread == NIL_RTTHREAD)
@@ -1328 +1328 @@
                 break;
 
-            case RTLOCKVALIDATORREC_MAGIC_DEAD:
-            case RTLOCKVALIDATORSHARED_MAGIC_DEAD:
+            case RTLOCKVALRECEXCL_MAGIC_DEAD:
+            case RTLOCKVALRECSHRD_MAGIC_DEAD:
                 pNextThread = NIL_RTTHREAD;
                 break;
 
-            case RTLOCKVALIDATORSHAREDONE_MAGIC:
-            case RTLOCKVALIDATORSHAREDONE_MAGIC_DEAD:
+            case RTLOCKVALRECSHRDOWN_MAGIC:
+            case RTLOCKVALRECSHRDOWN_MAGIC_DEAD:
             default:
                 AssertMsgFailed(("%p: %#x\n", pRec, pRec->Core));
@@ -1343 +1343 @@
         /* If we found a thread, check if it is still waiting for something. */
         RTTHREADSTATE               enmNextState = RTTHREADSTATE_RUNNING;
-        PRTLOCKVALIDATORRECUNION    pNextRec     = NULL;
+        PRTLOCKVALRECUNION    pNextRec     = NULL;
         if (   pNextThread != NIL_RTTHREAD
             && RT_LIKELY(pNextThread->u32Magic == RTTHREADINT_MAGIC))
@@ -1423 +1423 @@
  * @param   pOriginalRec    The original record.
  */
-DECLINLINE(int) rtLockValidatorIsSimpleNoDeadlockCase(PRTLOCKVALIDATORRECUNION pOriginalRec)
-{
-    if (    pOriginalRec->Excl.Core.u32Magic == RTLOCKVALIDATORREC_MAGIC
+DECLINLINE(int) rtLockValidatorIsSimpleNoDeadlockCase(PRTLOCKVALRECUNION pOriginalRec)
+{
+    if (    pOriginalRec->Excl.Core.u32Magic == RTLOCKVALRECEXCL_MAGIC
         &&  !pOriginalRec->Excl.pSibling)
     {
@@ -1450 +1450 @@
  * @param   rc              The return code.
  */
-static void rcLockValidatorDoDeadlockComplaining(PRTLOCKVALIDATORDDSTACK pStack, PRTLOCKVALIDATORRECUNION pRec,
-                                                 PRTTHREADINT pThreadSelf, PCRTLOCKVALIDATORSRCPOS pSrcPos, int rc)
+static void rcLockValidatorDoDeadlockComplaining(PRTLOCKVALIDATORDDSTACK pStack, PRTLOCKVALRECUNION pRec,
+                                                 PRTTHREADINT pThreadSelf, PCRTLOCKVALSRCPOS pSrcPos, int rc)
 {
     if (!ASMAtomicUoReadBool(&g_fLockValidatorQuiet))
@@ -1468 +1468 @@
             char szPrefix[24];
             RTStrPrintf(szPrefix, sizeof(szPrefix), "#%02u: ", i);
-            PRTLOCKVALIDATORSHAREDONE pSharedOne = NULL;
-            if (pStack->a[i].pRec->Core.u32Magic == RTLOCKVALIDATORSHARED_MAGIC)
-                pSharedOne = pStack->a[i].pRec->Shared.papOwners[pStack->a[i].iEntry];
-            if (VALID_PTR(pSharedOne) && pSharedOne->Core.u32Magic == RTLOCKVALIDATORSHAREDONE_MAGIC)
-                rtLockValidatorComplainAboutLock(szPrefix, (PRTLOCKVALIDATORRECUNION)pSharedOne, "\n");
+            PRTLOCKVALRECSHRDOWN pSharedOwn = NULL;
+            if (pStack->a[i].pRec->Core.u32Magic == RTLOCKVALRECSHRD_MAGIC)
+                pSharedOwn = pStack->a[i].pRec->Shared.papOwners[pStack->a[i].iEntry];
+            if (VALID_PTR(pSharedOwn) && pSharedOwn->Core.u32Magic == RTLOCKVALRECSHRDOWN_MAGIC)
+                rtLockValidatorComplainAboutLock(szPrefix, (PRTLOCKVALRECUNION)pSharedOwn, "\n");
             else
                 rtLockValidatorComplainAboutLock(szPrefix, pStack->a[i].pRec, "\n");
@@ -1495 +1495 @@
  * @param   pSrcPos         The position of the current lock operation.
  */
-static int rtLockValidatorDeadlockDetection(PRTLOCKVALIDATORRECUNION pRec, PRTTHREADINT pThreadSelf, PCRTLOCKVALIDATORSRCPOS pSrcPos)
+static int rtLockValidatorDeadlockDetection(PRTLOCKVALRECUNION pRec, PRTTHREADINT pThreadSelf, PCRTLOCKVALSRCPOS pSrcPos)
 {
 #ifdef DEBUG_bird
@@ -1527 +1527 @@
 
 
-RTDECL(int) RTLockValidatorCheckWriteOrderBlocking(PRTLOCKVALIDATORREC pWrite, PRTLOCKVALIDATORSHARED pRead,
+RTDECL(int) RTLockValidatorCheckWriteOrderBlocking(PRTLOCKVALRECEXCL pWrite, PRTLOCKVALRECSHRD pRead,
                                                    RTTHREAD hThread, RTTHREADSTATE enmState, bool fRecursiveOk,
-                                                   PCRTLOCKVALIDATORSRCPOS pSrcPos)
+                                                   PCRTLOCKVALSRCPOS pSrcPos)
 {
     /*
      * Fend off wild life.
      */
-    PRTLOCKVALIDATORRECUNION pWriteU = (PRTLOCKVALIDATORRECUNION)pWrite; /* (avoid break aliasing rules) */
+    PRTLOCKVALRECUNION pWriteU = (PRTLOCKVALRECUNION)pWrite; /* (avoid break aliasing rules) */
     AssertPtrReturn(pWriteU, VERR_SEM_LV_INVALID_PARAMETER);
-    AssertReturn(pWriteU->Core.u32Magic == RTLOCKVALIDATORREC_MAGIC, VERR_SEM_LV_INVALID_PARAMETER);
-    PRTLOCKVALIDATORRECUNION pReadU = (PRTLOCKVALIDATORRECUNION)pRead;
+    AssertReturn(pWriteU->Core.u32Magic == RTLOCKVALRECEXCL_MAGIC, VERR_SEM_LV_INVALID_PARAMETER);
+    PRTLOCKVALRECUNION pReadU = (PRTLOCKVALRECUNION)pRead;
     AssertPtrReturn(pRead, VERR_SEM_LV_INVALID_PARAMETER);
-    AssertReturn(pReadU->Core.u32Magic == RTLOCKVALIDATORSHARED_MAGIC, VERR_SEM_LV_INVALID_PARAMETER);
+    AssertReturn(pReadU->Core.u32Magic == RTLOCKVALRECSHRD_MAGIC, VERR_SEM_LV_INVALID_PARAMETER);
     AssertReturn(pReadU->Shared.fEnabled == pWriteU->Excl.fEnabled, VERR_SEM_LV_INVALID_PARAMETER);
     if (!pWriteU->Excl.fEnabled)
@@ -1556 +1556 @@
      * Check for attempts at doing a read upgrade.
      */
-    PRTLOCKVALIDATORSHAREDONE pEntry = rtLockValidatorSharedRecFindThread(&pReadU->Shared, hThread, NULL);
+    PRTLOCKVALRECSHRDOWN pEntry = rtLockValidatorSharedRecFindThread(&pReadU->Shared, hThread, NULL);
     if (pEntry)
     {
-        rtLockValidatorComplainFirst("Read lock upgrade", pSrcPos, pThread, (PRTLOCKVALIDATORRECUNION)pEntry);
+        rtLockValidatorComplainFirst("Read lock upgrade", pSrcPos, pThread, (PRTLOCKVALRECUNION)pEntry);
         rtLockValidatorComplainPanic();
         return VERR_SEM_LV_UPGRADE;
@@ -1570 +1570 @@
 
 
-RTDECL(int) RTLockValidatorCheckReadOrderBlocking(PRTLOCKVALIDATORSHARED pRead, PRTLOCKVALIDATORREC pWrite,
+RTDECL(int) RTLockValidatorCheckReadOrderBlocking(PRTLOCKVALRECSHRD pRead, PRTLOCKVALRECEXCL pWrite,
                                                   RTTHREAD hThread, RTTHREADSTATE enmState, bool fRecursiveOk,
-                                                  PCRTLOCKVALIDATORSRCPOS pSrcPos)
+                                                  PCRTLOCKVALSRCPOS pSrcPos)
 {
     /*
@@ -1578 +1578 @@
      */
     AssertPtrReturn(pRead, VERR_SEM_LV_INVALID_PARAMETER);
-    AssertReturn(pRead->Core.u32Magic == RTLOCKVALIDATORSHARED_MAGIC, VERR_SEM_LV_INVALID_PARAMETER);
+    AssertReturn(pRead->Core.u32Magic == RTLOCKVALRECSHRD_MAGIC, VERR_SEM_LV_INVALID_PARAMETER);
     AssertPtrReturn(pWrite, VERR_SEM_LV_INVALID_PARAMETER);
-    AssertReturn(pWrite->Core.u32Magic == RTLOCKVALIDATORREC_MAGIC, VERR_SEM_LV_INVALID_PARAMETER);
+    AssertReturn(pWrite->Core.u32Magic == RTLOCKVALRECEXCL_MAGIC, VERR_SEM_LV_INVALID_PARAMETER);
     AssertReturn(pRead->fEnabled == pWrite->fEnabled, VERR_SEM_LV_INVALID_PARAMETER);
     if (!pRead->fEnabled)
@@ -1600 +1600 @@
 
 
-RTDECL(int) RTLockValidatorCheckBlocking(PRTLOCKVALIDATORREC pRec, RTTHREAD hThread,
+RTDECL(int) RTLockValidatorCheckBlocking(PRTLOCKVALRECEXCL pRec, RTTHREAD hThread,
                                          RTTHREADSTATE enmState, bool fRecursiveOk,
-                                         PCRTLOCKVALIDATORSRCPOS pSrcPos)
+                                         PCRTLOCKVALSRCPOS pSrcPos)
 {
     /*
      * Fend off wild life.
      */
-    PRTLOCKVALIDATORRECUNION pRecU = (PRTLOCKVALIDATORRECUNION)pRec;
+    PRTLOCKVALRECUNION pRecU = (PRTLOCKVALRECUNION)pRec;
     AssertPtrReturn(pRecU, VERR_SEM_LV_INVALID_PARAMETER);
-    AssertReturn(pRecU->Core.u32Magic == RTLOCKVALIDATORREC_MAGIC, VERR_SEM_LV_INVALID_PARAMETER);
+    AssertReturn(pRecU->Core.u32Magic == RTLOCKVALRECEXCL_MAGIC, VERR_SEM_LV_INVALID_PARAMETER);
     if (!pRecU->Excl.fEnabled)
         return VINF_SUCCESS;

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

@@ -69 +69 @@
     pCritSect->cLockers             = -1;
     pCritSect->NativeThreadOwner    = NIL_RTNATIVETHREAD;
-    int rc = RTLockValidatorRecCreate(&pCritSect->pValidatorRec, NIL_RTLOCKVALIDATORCLASS, 0, "RTCritSect", pCritSect);
+    int rc = RTLockValidatorRecExclCreate(&pCritSect->pValidatorRec, NIL_RTLOCKVALIDATORCLASS, 0, "RTCritSect", pCritSect);
     if (RT_SUCCESS(rc))
     {
@@ -75 +75 @@
         if (RT_SUCCESS(rc))
             return VINF_SUCCESS;
-        RTLockValidatorRecDestroy(&pCritSect->pValidatorRec);
+        RTLockValidatorRecExclDestroy(&pCritSect->pValidatorRec);
     }
 
@@ -86 +86 @@
 
 
-DECL_FORCE_INLINE(int) rtCritSectTryEnter(PRTCRITSECT pCritSect, PCRTLOCKVALIDATORSRCPOS pSrcPos)
+DECL_FORCE_INLINE(int) rtCritSectTryEnter(PRTCRITSECT pCritSect, PCRTLOCKVALSRCPOS pSrcPos)
 {
     Assert(pCritSect);
@@ -137 +137 @@
     return rtCritSectTryEnter(pCritSect, NULL);
 #else
-    RTLOCKVALIDATORSRCPOS SrcPos = RTLOCKVALIDATORSRCPOS_INIT_NORMAL_API();
+    RTLOCKVALSRCPOS SrcPos = RTLOCKVALSRCPOS_INIT_NORMAL_API();
     return rtCritSectTryEnter(pCritSect, &SrcPos);
 #endif
@@ -146 +146 @@
 RTDECL(int) RTCritSectTryEnterDebug(PRTCRITSECT pCritSect, RTHCUINTPTR uId, RT_SRC_POS_DECL)
 {
-    RTLOCKVALIDATORSRCPOS SrcPos = RTLOCKVALIDATORSRCPOS_INIT_DEBUG_API();
+    RTLOCKVALSRCPOS SrcPos = RTLOCKVALSRCPOS_INIT_DEBUG_API();
     return rtCritSectTryEnter(pCritSect, &SrcPos);
 }
@@ -152 +152 @@
 
 
-DECL_FORCE_INLINE(int) rtCritSectEnter(PRTCRITSECT pCritSect, PCRTLOCKVALIDATORSRCPOS pSrcPos)
+DECL_FORCE_INLINE(int) rtCritSectEnter(PRTCRITSECT pCritSect, PCRTLOCKVALSRCPOS pSrcPos)
 {
     Assert(pCritSect);
@@ -238 +238 @@
     return rtCritSectEnter(pCritSect, NULL);
 #else
-    RTLOCKVALIDATORSRCPOS SrcPos = RTLOCKVALIDATORSRCPOS_INIT_NORMAL_API();
+    RTLOCKVALSRCPOS SrcPos = RTLOCKVALSRCPOS_INIT_NORMAL_API();
     return rtCritSectEnter(pCritSect, &SrcPos);
 #endif
@@ -247 +247 @@
 RTDECL(int) RTCritSectEnterDebug(PRTCRITSECT pCritSect, RTHCUINTPTR uId, RT_SRC_POS_DECL)
 {
-    RTLOCKVALIDATORSRCPOS SrcPos = RTLOCKVALIDATORSRCPOS_INIT_DEBUG_API();
+    RTLOCKVALSRCPOS SrcPos = RTLOCKVALSRCPOS_INIT_DEBUG_API();
     return rtCritSectEnter(pCritSect, &SrcPos);
 }
@@ -294 +294 @@
 
 
-static int rtCritSectEnterMultiple(size_t cCritSects, PRTCRITSECT *papCritSects, PCRTLOCKVALIDATORSRCPOS pSrcPos)
+static int rtCritSectEnterMultiple(size_t cCritSects, PRTCRITSECT *papCritSects, PCRTLOCKVALSRCPOS pSrcPos)
 {
     Assert(cCritSects > 0);
@@ -377 +377 @@
     return rtCritSectEnterMultiple(cCritSects, papCritSects, NULL);
 #else
-    RTLOCKVALIDATORSRCPOS SrcPos = RTLOCKVALIDATORSRCPOS_INIT_NORMAL_API();
+    RTLOCKVALSRCPOS SrcPos = RTLOCKVALSRCPOS_INIT_NORMAL_API();
     return rtCritSectEnterMultiple(cCritSects, papCritSects, &SrcPos);
 #endif
@@ -386 +386 @@
 RTDECL(int) RTCritSectEnterMultipleDebug(size_t cCritSects, PRTCRITSECT *papCritSects, RTUINTPTR uId, RT_SRC_POS_DECL)
 {
-    RTLOCKVALIDATORSRCPOS SrcPos = RTLOCKVALIDATORSRCPOS_INIT_DEBUG_API();
+    RTLOCKVALSRCPOS SrcPos = RTLOCKVALSRCPOS_INIT_DEBUG_API();
     return rtCritSectEnterMultiple(cCritSects, papCritSects, &SrcPos);
 }
@@ -435 +435 @@
     AssertRC(rc);
 
-    RTLockValidatorRecDestroy(&pCritSect->pValidatorRec);
+    RTLockValidatorRecExclDestroy(&pCritSect->pValidatorRec);
 
     return rc;

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

@@ -41 +41 @@
  * Record union for simplifying internal processing.
  */
-typedef union RTLOCKVALIDATORRECUNION
+typedef union RTLOCKVALRECUNION
 {
-    RTLOCKVALIDATORRECCORE      Core;
-    RTLOCKVALIDATORREC          Excl;
-    RTLOCKVALIDATORSHARED       Shared;
-    RTLOCKVALIDATORSHAREDONE    SharedOne;
-} RTLOCKVALIDATORRECUNION;
+    RTLOCKVALRECCORE      Core;
+    RTLOCKVALRECEXCL      Excl;
+    RTLOCKVALRECSHRD      Shared;
+    RTLOCKVALRECSHRDOWN   SharedOwn;
+} RTLOCKVALRECUNION;
 
 
@@ -58 +58 @@
 {
     /** What we're blocking on. */
-    PRTLOCKVALIDATORRECUNION volatile   pRec;
+    PRTLOCKVALRECUNION volatile     pRec;
     /** Where we are blocking. */
-    RTLOCKVALIDATORSRCPOS               SrcPos;
+    RTLOCKVALSRCPOS                 SrcPos;
     /** Number of registered write locks, mutexes and critsects that this thread owns. */
-    int32_t volatile                    cWriteLocks;
+    int32_t volatile                cWriteLocks;
     /** Number of registered read locks that this thread owns, nesting included. */
-    int32_t volatile                    cReadLocks;
+    int32_t volatile                cReadLocks;
 } RTLOCKVALIDATORPERTHREAD;
 

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

@@ -68 +68 @@
 #define RTLOCALIPCSESSION_MAGIC     0x19530414
 /** The magic value for RTLOCKVALIDATORREC::u32Magic. (Vladimir Vladimirovich Nabokov) */
-#define RTLOCKVALIDATORREC_MAGIC            0x18990422
+#define RTLOCKVALRECEXCL_MAGIC      0x18990422
 /** The dead magic value for RTLOCKVALIDATORREC::u32Magic. */
-#define RTLOCKVALIDATORREC_MAGIC_DEAD       0x19770702
-/** The magic value for RTLOCKVALIDATORSHARED::u32Magic. (Agnar Mykle) */
-#define RTLOCKVALIDATORSHARED_MAGIC         0x19150808
-/** The magic value for RTLOCKVALIDATORSHARED::u32Magic after deletion. */
-#define RTLOCKVALIDATORSHARED_MAGIC_DEAD    0x19940115
-/** The magic value for RTLOCKVALIDATORSHAREDONE::u32Magic. (Jens Ingvald Bjoerneboe) */
-#define RTLOCKVALIDATORSHAREDONE_MAGIC      0x19201009
-/** The magic value for RTLOCKVALIDATORSHAREDONE::u32Magic after deletion. */
-#define RTLOCKVALIDATORSHAREDONE_MAGIC_DEAD 0x19760509
+#define RTLOCKVALRECEXCL_MAGIC_DEAD 0x19770702
+/** The magic value for RTLOCKVALRECSHRD::u32Magic. (Agnar Mykle) */
+#define RTLOCKVALRECSHRD_MAGIC      0x19150808
+/** The magic value for RTLOCKVALRECSHRD::u32Magic after deletion. */
+#define RTLOCKVALRECSHRD_MAGIC_DEAD 0x19940115
+/** The magic value for RTLOCKVALRECSHRDOWN::u32Magic. (Jens Ingvald Bjoerneboe) */
+#define RTLOCKVALRECSHRDOWN_MAGIC   0x19201009
+/** The magic value for RTLOCKVALRECSHRDOWN::u32Magic after deletion. */
+#define RTLOCKVALRECSHRDOWN_MAGIC_DEAD 0x19760509
 /** Magic number for RTMEMCACHEINT::u32Magic. (Joseph Weizenbaum) */
 #define RTMEMCACHE_MAGIC            0x19230108

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

@@ -81 +81 @@
 #ifdef RTSEMMUTEX_STRICT
     /** Lock validator record associated with this mutex. */
-    RTLOCKVALIDATORREC  ValidatorRec;
+    RTLOCKVALRECEXCL    ValidatorRec;
 #endif
 };
@@ -120 +120 @@
         pThis->cNesting = 0;
 #ifdef RTSEMMUTEX_STRICT
-        RTLockValidatorRecInit(&pThis->ValidatorRec, NIL_RTLOCKVALIDATORCLASS, RTLOCKVALIDATOR_SUB_CLASS_NONE, "RTSemMutex", pThis);
+        RTLockValidatorRecExclInit(&pThis->ValidatorRec, NIL_RTLOCKVALIDATORCLASS, RTLOCKVALIDATOR_SUB_CLASS_NONE, "RTSemMutex", pThis);
 #endif
 
@@ -156 +156 @@
     pThis->cNesting = 0;
 #ifdef RTSEMMUTEX_STRICT
-    RTLockValidatorRecDelete(&pThis->ValidatorRec);
+    RTLockValidatorRecExclDelete(&pThis->ValidatorRec);
 #endif
 
@@ -167 +167 @@
 
 
-DECL_FORCE_INLINE(int) rtSemMutexRequest(RTSEMMUTEX MutexSem, unsigned cMillies, bool fAutoResume, PCRTLOCKVALIDATORSRCPOS pSrcPos)
+DECL_FORCE_INLINE(int) rtSemMutexRequest(RTSEMMUTEX MutexSem, unsigned cMillies, bool fAutoResume, PCRTLOCKVALSRCPOS pSrcPos)
 {
     /*
@@ -310 +310 @@
     int rc = rtSemMutexRequest(MutexSem, cMillies, true, NULL);
 #else
-    RTLOCKVALIDATORSRCPOS SrcPos = RTLOCKVALIDATORSRCPOS_INIT_NORMAL_API();
+    RTLOCKVALSRCPOS SrcPos = RTLOCKVALSRCPOS_INIT_NORMAL_API();
     int rc = rtSemMutexRequest(MutexSem, cMillies, true, &SrcPos);
 #endif
@@ -320 +320 @@
 RTDECL(int) RTSemMutexRequestDebug(RTSEMMUTEX MutexSem, unsigned cMillies, RTHCUINTPTR uId, RT_SRC_POS_DECL)
 {
-    RTLOCKVALIDATORSRCPOS SrcPos = RTLOCKVALIDATORSRCPOS_INIT_DEBUG_API();
+    RTLOCKVALSRCPOS SrcPos = RTLOCKVALSRCPOS_INIT_DEBUG_API();
     int rc = rtSemMutexRequest(MutexSem, cMillies, true, &SrcPos);
     Assert(rc != VERR_INTERRUPTED);
@@ -332 +332 @@
     return rtSemMutexRequest(MutexSem, cMillies, false, NULL);
 #else
-    RTLOCKVALIDATORSRCPOS SrcPos = RTLOCKVALIDATORSRCPOS_INIT_NORMAL_API();
+    RTLOCKVALSRCPOS SrcPos = RTLOCKVALSRCPOS_INIT_NORMAL_API();
     return rtSemMutexRequest(MutexSem, cMillies, false, &SrcPos);
 #endif
@@ -340 +340 @@
 RTDECL(int) RTSemMutexRequestNoResumeDebug(RTSEMMUTEX MutexSem, unsigned cMillies, RTHCUINTPTR uId, RT_SRC_POS_DECL)
 {
-    RTLOCKVALIDATORSRCPOS SrcPos = RTLOCKVALIDATORSRCPOS_INIT_DEBUG_API();
+    RTLOCKVALSRCPOS SrcPos = RTLOCKVALSRCPOS_INIT_DEBUG_API();
     return rtSemMutexRequest(MutexSem, cMillies, false, &SrcPos);
 }

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

@@ -66 +66 @@
 #ifdef RTSEMMUTEX_STRICT
     /** Lock validator record associated with this mutex. */
-    RTLOCKVALIDATORREC  ValidatorRec;
+    RTLOCKVALRECEXCL    ValidatorRec;
 #endif
 };
@@ -102 +102 @@
                 pThis->u32Magic = RTSEMMUTEX_MAGIC;
 #ifdef RTSEMMUTEX_STRICT
-                RTLockValidatorRecInit(&pThis->ValidatorRec, NIL_RTLOCKVALIDATORCLASS, RTLOCKVALIDATOR_SUB_CLASS_NONE, "RTSemMutex", pThis);
+                RTLockValidatorRecExclInit(&pThis->ValidatorRec, NIL_RTLOCKVALIDATORCLASS, RTLOCKVALIDATOR_SUB_CLASS_NONE, "RTSemMutex", pThis);
 #endif
 
@@ -147 +147 @@
     pThis->cNesting = UINT32_MAX;
 #ifdef RTSEMMUTEX_STRICT
-    RTLockValidatorRecDelete(&pThis->ValidatorRec);
+    RTLockValidatorRecExclDelete(&pThis->ValidatorRec);
 #endif
     RTMemTmpFree(pThis);
@@ -155 +155 @@
 
 
-DECL_FORCE_INLINE(int) rtSemMutexRequest(RTSEMMUTEX MutexSem, unsigned cMillies, PCRTLOCKVALIDATORSRCPOS pSrcPos)
+DECL_FORCE_INLINE(int) rtSemMutexRequest(RTSEMMUTEX MutexSem, unsigned cMillies, PCRTLOCKVALSRCPOS pSrcPos)
 {
     /*
@@ -259 +259 @@
     return rtSemMutexRequest(MutexSem, cMillies, NULL);
 #else
-    RTLOCKVALIDATORSRCPOS SrcPos = RTLOCKVALIDATORSRCPOS_INIT_NORMAL_API();
+    RTLOCKVALSRCPOS SrcPos = RTLOCKVALSRCPOS_INIT_NORMAL_API();
     return rtSemMutexRequest(MutexSem, cMillies, &SrcPos);
 #endif
@@ -267 +267 @@
 RTDECL(int) RTSemMutexRequestDebug(RTSEMMUTEX MutexSem, unsigned cMillies, RTHCUINTPTR uId, RT_SRC_POS_DECL)
 {
-    RTLOCKVALIDATORSRCPOS SrcPos = RTLOCKVALIDATORSRCPOS_INIT_DEBUG_API();
+    RTLOCKVALSRCPOS SrcPos = RTLOCKVALSRCPOS_INIT_DEBUG_API();
     return rtSemMutexRequest(MutexSem, cMillies, &SrcPos);
 }
@@ -278 +278 @@
     return rtSemMutexRequest(MutexSem, cMillies, NULL);
 #else
-    RTLOCKVALIDATORSRCPOS SrcPos = RTLOCKVALIDATORSRCPOS_INIT_NORMAL_API();
+    RTLOCKVALSRCPOS SrcPos = RTLOCKVALSRCPOS_INIT_NORMAL_API();
     return rtSemMutexRequest(MutexSem, cMillies, &SrcPos);
 #endif
@@ -286 +286 @@
 RTDECL(int) RTSemMutexRequestNoResumeDebug(RTSEMMUTEX MutexSem, unsigned cMillies, RTHCUINTPTR uId, RT_SRC_POS_DECL)
 {
-    RTLOCKVALIDATORSRCPOS SrcPos = RTLOCKVALIDATORSRCPOS_INIT_DEBUG_API();
+    RTLOCKVALSRCPOS SrcPos = RTLOCKVALSRCPOS_INIT_DEBUG_API();
     return rtSemMutexRequest(MutexSem, cMillies, &SrcPos);
 }

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

@@ -86 +86 @@
 #ifdef RTSEMRW_STRICT
     /** The validator record for the writer. */
-    RTLOCKVALIDATORREC      ValidatorWrite;
+    RTLOCKVALRECEXCL    ValidatorWrite;
     /** The validator record for the readers. */
-    RTLOCKVALIDATORSHARED   ValidatorRead;
+    RTLOCKVALRECSHRD    ValidatorRead;
 #endif
 };
@@ -119 +119 @@
                 pThis->Writer       = (pthread_t)-1;
 #ifdef RTSEMRW_STRICT
-                RTLockValidatorRecInit(&pThis->ValidatorWrite, NIL_RTLOCKVALIDATORCLASS, RTLOCKVALIDATOR_SUB_CLASS_NONE, "RTSemRW", pThis);
-                RTLockValidatorSharedRecInit(&pThis->ValidatorRead,  NIL_RTLOCKVALIDATORCLASS, RTLOCKVALIDATOR_SUB_CLASS_NONE, "RTSemRW", pThis);
-                RTLockValidatorMakeSiblings(&pThis->ValidatorWrite.Core, &pThis->ValidatorRead.Core);
+                RTLockValidatorRecExclInit(&pThis->ValidatorWrite, NIL_RTLOCKVALIDATORCLASS, RTLOCKVALIDATOR_SUB_CLASS_NONE, "RTSemRW", pThis);
+                RTLockValidatorRecSharedInit(&pThis->ValidatorRead,  NIL_RTLOCKVALIDATORCLASS, RTLOCKVALIDATOR_SUB_CLASS_NONE, "RTSemRW", pThis);
+                RTLockValidatorRecMakeSiblings(&pThis->ValidatorWrite.Core, &pThis->ValidatorRead.Core);
 #endif
                 *pRWSem = pThis;
@@ -163 +163 @@
     {
 #ifdef RTSEMRW_STRICT
-        RTLockValidatorSharedRecDelete(&pThis->ValidatorRead);
-        RTLockValidatorRecDelete(&pThis->ValidatorWrite);
+        RTLockValidatorRecSharedDelete(&pThis->ValidatorRead);
+        RTLockValidatorRecExclDelete(&pThis->ValidatorWrite);
 #endif
         RTMemFree(pThis);
@@ -182 +182 @@
 RTDECL(int) RTSemRWRequestRead(RTSEMRW RWSem, unsigned cMillies)
 {
-    PRTLOCKVALIDATORSRCPOS pSrcPos = NULL;
+    PRTLOCKVALSRCPOS pSrcPos = NULL;
 
     /*
@@ -346 +346 @@
 
 
-DECL_FORCE_INLINE(int) rtSemRWRequestWrite(RTSEMRW RWSem, unsigned cMillies, PCRTLOCKVALIDATORSRCPOS pSrcPos)
+DECL_FORCE_INLINE(int) rtSemRWRequestWrite(RTSEMRW RWSem, unsigned cMillies, PCRTLOCKVALSRCPOS pSrcPos)
 {
     /*
@@ -452 +452 @@
     return rtSemRWRequestWrite(RWSem, cMillies, NULL);
 #else
-    RTLOCKVALIDATORSRCPOS SrcPos = RTLOCKVALIDATORSRCPOS_INIT_NORMAL_API();
+    RTLOCKVALSRCPOS SrcPos = RTLOCKVALSRCPOS_INIT_NORMAL_API();
     return rtSemRWRequestWrite(RWSem, cMillies, &SrcPos);
 #endif
@@ -460 +460 @@
 RTDECL(int) RTSemRWRequestWriteDebug(RTSEMRW RWSem, unsigned cMillies, RTHCUINTPTR uId, RT_SRC_POS_DECL)
 {
-    RTLOCKVALIDATORSRCPOS SrcPos = RTLOCKVALIDATORSRCPOS_INIT_DEBUG_API();
+    RTLOCKVALSRCPOS SrcPos = RTLOCKVALSRCPOS_INIT_DEBUG_API();
     return rtSemRWRequestWrite(RWSem, cMillies, &SrcPos);
 }
@@ -471 +471 @@
     return rtSemRWRequestWrite(RWSem, cMillies, NULL);
 #else
-    RTLOCKVALIDATORSRCPOS SrcPos = RTLOCKVALIDATORSRCPOS_INIT_NORMAL_API();
+    RTLOCKVALSRCPOS SrcPos = RTLOCKVALSRCPOS_INIT_NORMAL_API();
     return rtSemRWRequestWrite(RWSem, cMillies, &SrcPos);
 #endif
@@ -480 +480 @@
 {
     /* EINTR isn't returned by the wait functions we're using. */
-    RTLOCKVALIDATORSRCPOS SrcPos = RTLOCKVALIDATORSRCPOS_INIT_DEBUG_API();
+    RTLOCKVALSRCPOS SrcPos = RTLOCKVALSRCPOS_INIT_DEBUG_API();
     return rtSemRWRequestWrite(RWSem, cMillies, &SrcPos);
 }

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

@@ -61 +61 @@
 #ifdef RTSEMMUTEX_STRICT
     /** Lock validator record associated with this mutex. */
-    RTLOCKVALIDATORREC  ValidatorRec;
+    RTLOCKVALRECEXCL    ValidatorRec;
 #endif
 };
@@ -87 +87 @@
             pThis->hMtx = hMtx;
 #ifdef RTSEMMUTEX_STRICT
-            RTLockValidatorRecInit(&pThis->ValidatorRec,  NIL_RTLOCKVALIDATORCLASS, RTLOCKVALIDATOR_SUB_CLASS_NONE, "RTSemMutex", pThis);
+            RTLockValidatorRecExclInit(&pThis->ValidatorRec,  NIL_RTLOCKVALIDATORCLASS, RTLOCKVALIDATOR_SUB_CLASS_NONE, "RTSemMutex", pThis);
 #endif
             *pMutexSem = pThis;
@@ -127 +127 @@
 
 #ifdef RTSEMMUTEX_STRICT
-    RTLockValidatorRecDelete(&pThis->ValidatorRec);
+    RTLockValidatorRecExclDelete(&pThis->ValidatorRec);
 #endif
     RTMemFree(pThis);
@@ -142 +142 @@
  * @param   pSrcPos             The source position of the caller.
  */
-DECL_FORCE_INLINE(int) rtSemMutexRequestNoResume(RTSEMMUTEX MutexSem, unsigned cMillies, PCRTLOCKVALIDATORSRCPOS pSrcPos)
+DECL_FORCE_INLINE(int) rtSemMutexRequestNoResume(RTSEMMUTEX MutexSem, unsigned cMillies, PCRTLOCKVALSRCPOS pSrcPos)
 {
     /*
@@ -205 +205 @@
     return rtSemMutexRequestNoResume(MutexSem, cMillies, NULL);
 #else
-    RTLOCKVALIDATORSRCPOS SrcPos = RTLOCKVALIDATORSRCPOS_INIT_NORMAL_API();
+    RTLOCKVALSRCPOS SrcPos = RTLOCKVALSRCPOS_INIT_NORMAL_API();
     return rtSemMutexRequestNoResume(MutexSem, cMillies, &SrcPos);
 #endif
@@ -213 +213 @@
 RTDECL(int) RTSemMutexRequestNoResumeDebug(RTSEMMUTEX MutexSem, unsigned cMillies, RTHCUINTPTR uId, RT_SRC_POS_DECL)
 {
-    RTLOCKVALIDATORSRCPOS SrcPos = RTLOCKVALIDATORSRCPOS_INIT_DEBUG_API();
+    RTLOCKVALSRCPOS SrcPos = RTLOCKVALSRCPOS_INIT_DEBUG_API();
     return rtSemMutexRequestNoResume(MutexSem, cMillies, &SrcPos);
 }

trunk/src/VBox/VMM/PDMCritSect.cpp

@@ -127 +127 @@
     if (RT_SUCCESS(rc))
     {
-        rc = RTLockValidatorRecCreate(&pCritSect->Core.pValidatorRec, NIL_RTLOCKVALIDATORCLASS, 0, pszName, pCritSect);
+        rc = RTLockValidatorRecExclCreate(&pCritSect->Core.pValidatorRec, NIL_RTLOCKVALIDATORCLASS, 0, pszName, pCritSect);
         if (RT_SUCCESS(rc))
         {
@@ -245 +245 @@
     int rc = SUPSemEventClose(pVM->pSession, hEvent);
     AssertRC(rc);
-    RTLockValidatorRecDestroy(&pCritSect->Core.pValidatorRec);
+    RTLockValidatorRecExclDestroy(&pCritSect->Core.pValidatorRec);
     pCritSect->pNext   = NULL;
     pCritSect->pvKey   = NULL;
@@ -396 +396 @@
 
 #ifdef PDMCRITSECT_STRICT
-    RTLOCKVALIDATORSRCPOS const SrcPos = pCritSect->s.Core.pValidatorRec->SrcPos;
+    RTLOCKVALSRCPOS const SrcPos = pCritSect->s.Core.pValidatorRec->SrcPos;
 #endif
     PDMCritSectLeave(pCritSect);

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

@@ -88 +88 @@
  * @param   hNativeSelf     The native handle of this thread.
  */
-DECL_FORCE_INLINE(int) pdmCritSectEnterFirst(PPDMCRITSECT pCritSect, RTNATIVETHREAD hNativeSelf, PCRTLOCKVALIDATORSRCPOS pSrcPos)
+DECL_FORCE_INLINE(int) pdmCritSectEnterFirst(PPDMCRITSECT pCritSect, RTNATIVETHREAD hNativeSelf, PCRTLOCKVALSRCPOS pSrcPos)
 {
     AssertMsg(pCritSect->s.Core.NativeThreadOwner == NIL_RTNATIVETHREAD, ("NativeThreadOwner=%p\n", pCritSect->s.Core.NativeThreadOwner));
@@ -113 +113 @@
  * @param   hNativeSelf         The native thread handle.
  */
-static int pdmR3CritSectEnterContended(PPDMCRITSECT pCritSect, RTNATIVETHREAD hNativeSelf, PCRTLOCKVALIDATORSRCPOS pSrcPos)
+static int pdmR3CritSectEnterContended(PPDMCRITSECT pCritSect, RTNATIVETHREAD hNativeSelf, PCRTLOCKVALSRCPOS pSrcPos)
 {
     /*
@@ -170 +170 @@
  *                              and the section is busy.
  */
-DECL_FORCE_INLINE(int) pdmCritSectEnter(PPDMCRITSECT pCritSect, int rcBusy, PCRTLOCKVALIDATORSRCPOS pSrcPos)
+DECL_FORCE_INLINE(int) pdmCritSectEnter(PPDMCRITSECT pCritSect, int rcBusy, PCRTLOCKVALSRCPOS pSrcPos)
 {
     Assert(pCritSect->s.Core.cNestings < 8);  /* useful to catch incorrect locking */
@@ -248 +248 @@
     return pdmCritSectEnter(pCritSect, rcBusy, NULL);
 #else
-    RTLOCKVALIDATORSRCPOS SrcPos = RTLOCKVALIDATORSRCPOS_INIT_NORMAL_API();
+    RTLOCKVALSRCPOS SrcPos = RTLOCKVALSRCPOS_INIT_NORMAL_API();
     return pdmCritSectEnter(pCritSect, rcBusy, &SrcPos);
 #endif
@@ -275 +275 @@
 {
 #ifdef PDMCRITSECT_STRICT
-    RTLOCKVALIDATORSRCPOS SrcPos = RTLOCKVALIDATORSRCPOS_INIT_DEBUG_API();
+    RTLOCKVALSRCPOS SrcPos = RTLOCKVALSRCPOS_INIT_DEBUG_API();
     return pdmCritSectEnter(pCritSect, rcBusy, &SrcPos);
 #else
@@ -293 +293 @@
  * @param   pCritSect   The critical section.
  */
-static int pdmCritSectTryEnter(PPDMCRITSECT pCritSect, PCRTLOCKVALIDATORSRCPOS pSrcPos)
+static int pdmCritSectTryEnter(PPDMCRITSECT pCritSect, PCRTLOCKVALSRCPOS pSrcPos)
 {
     /*
@@ -349 +349 @@
     return pdmCritSectTryEnter(pCritSect, NULL);
 #else
-    RTLOCKVALIDATORSRCPOS SrcPos = RTLOCKVALIDATORSRCPOS_INIT_NORMAL_API();
+    RTLOCKVALSRCPOS SrcPos = RTLOCKVALSRCPOS_INIT_NORMAL_API();
     return pdmCritSectTryEnter(pCritSect, &SrcPos);
 #endif
@@ -375 +375 @@
 {
 #ifdef PDMCRITSECT_STRICT
-    RTLOCKVALIDATORSRCPOS SrcPos = RTLOCKVALIDATORSRCPOS_INIT_DEBUG_API();
+    RTLOCKVALSRCPOS SrcPos = RTLOCKVALSRCPOS_INIT_DEBUG_API();
     return pdmCritSectTryEnter(pCritSect, &SrcPos);
 #else