Changeset 25703 in vbox for trunk/src/VBox/Runtime/common/misc

Timestamp:

Jan 10, 2010 4:49:14 PM (15 years ago)

Author:

vboxsync

Message:

iprt/lockvalidator: Tested and debugged the basics of lock order validation.

File:

• trunk/src/VBox/Runtime/common/misc/lockvalidator.cpp (modified) (18 diffs)

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

@@ -62 +62 @@
 /** Hashes the class handle (pointer) into an apPriorLocksHash index. */
 #define RTLOCKVALCLASS_HASH(hClass) \
-    (   (uintptr_t)(hClass) \
+    (   ((uintptr_t)(hClass) >> 6 ) \
       % (  RT_SIZEOFMEMB(RTLOCKVALCLASSINT, apPriorLocksHash) \
          / sizeof(PRTLOCKVALCLASSREF)) )
@@ -202 +202 @@
     RTLOCKVALCLASSREFCHUNK  PriorLocks;
     /** Hash table containing frequently encountered prior locks. */
-    PRTLOCKVALCLASSREF      apPriorLocksHash[11];
+    PRTLOCKVALCLASSREF      apPriorLocksHash[17];
+    /** Class name. (Allocated after the end of the block as usual.) */
+    char const             *pszName;
+    /** Where this class was created.
+     *  This is mainly used for finding automatically created lock classes.
+     *  @remarks The strings are stored after this structure so we won't crash
+     *           if the class lives longer than the module (dll/so/dylib) that
+     *           spawned it. */
+    RTLOCKVALSRCPOS         CreatePos;
 #ifdef RTLOCKVAL_WITH_CLASS_HASH_STATS
     /** Hash hits. */
@@ -209 +217 @@
     uint32_t volatile       cHashMisses;
 #endif
-    /** Where this class was created.
-     *  This is mainly used for finding automatically created lock classes.
-     *  @remarks The strings are stored after this structure so we won't crash
-     *           if the class lives longer than the module (dll/so/dylib) that
-     *           spawned it. */
-    RTLOCKVALSRCPOS         CreatePos;
-    /** Class name. (Allocated after the end of the block as usual.) */
-    char const             *pszName;
 } RTLOCKVALCLASSINT;
 AssertCompileSize(AVLLU32NODECORE, ARCH_BITS == 32 ? 20 : 32);
@@ -251 +251 @@
 #endif
 /** Serializing class tree insert and lookups. */
-static RTSEMRW          g_hLockValClassTreeRWLock = NIL_RTSEMRW;
+static RTSEMRW          g_hLockValClassTreeRWLock= NIL_RTSEMRW;
 /** Class tree. */
-static PAVLLU32NODECORE g_LockValClassTree = NULL;
+static PAVLLU32NODECORE g_LockValClassTree       = NULL;
 /** Critical section serializing the teaching new rules to the classes. */
 static RTCRITSECT       g_LockValClassTeachCS;
@@ -1006 +1006 @@
     for (unsigned i = 0; i < RT_ELEMENTS(pThis->apPriorLocksHash); i++)
         pThis->apPriorLocksHash[i] = NULL;
+    char *pszDst = (char *)(pThis + 1);
+    pThis->pszName              = (char *)memcpy(pszDst, szName, cbName);
+    pszDst += cbName;
     rtLockValidatorSrcPosCopy(&pThis->CreatePos, pSrcPos);
-    char *pszDst = (char *)(pThis + 1);
     pThis->CreatePos.pszFile    = pSrcPos->pszFile     ? (char *)memcpy(pszDst, pSrcPos->pszFile,     cbFile)     : NULL;
     pszDst += cbFile;
     pThis->CreatePos.pszFunction= pSrcPos->pszFunction ? (char *)memcpy(pszDst, pSrcPos->pszFunction, cbFunction) : NULL;
-    pszDst += cbFunction;
     Assert(rtLockValidatorSrcPosHash(&pThis->CreatePos) == pThis->Core.Key);
-    pThis->pszName              = (char *)memcpy(pszDst, szName, cbName);
+#ifdef RTLOCKVAL_WITH_CLASS_HASH_STATS
+    pThis->cHashHits            = 0;
+    pThis->cHashMisses          = 0;
+#endif
 
     *phClass = pThis;
@@ -1084 +1088 @@
 static void rtLockValidatorClassDestroy(RTLOCKVALCLASSINT *pClass)
 {
-    AssertReturnVoid(pClass->fInTree);
+    AssertReturnVoid(!pClass->fInTree);
     ASMAtomicWriteU32(&pClass->u32Magic, RTLOCKVALCLASS_MAGIC_DEAD);
 
@@ -1104 +1108 @@
         if (pChunk != &pClass->PriorLocks)
             RTMemFree(pChunk);
-        pNext = pChunk;
+        pChunk = pNext;
     }
 
@@ -1122 +1126 @@
     {
         if (rtLockValidatorSrcPosCompare(&pClass->CreatePos, pSrcPos) == 0)
-        {
-            rtLockValidatorClassRetain(pClass);
             break;
-        }
         pClass = (RTLOCKVALCLASSINT *)pClass->Core.pList;
     }
@@ -1179 +1180 @@
 {
     RTLOCKVALCLASSINT *pClass = hClass;
+    if (pClass == NIL_RTLOCKVALCLASS)
+        return 0;
     AssertPtrReturn(pClass, UINT32_MAX);
     AssertReturn(pClass->u32Magic == RTLOCKVALCLASS_MAGIC, UINT32_MAX);
@@ -1349 +1352 @@
 
     return rtLockValidatorClassAddPriorClass(pClass, pPriorClass, false /*fAutodidacticism*/, NULL);
+}
+
+
+RTDECL(int) RTLockValidatorClassEnforceStrictReleaseOrder(RTLOCKVALCLASS hClass, bool fEnabled)
+{
+    RTLOCKVALCLASSINT *pClass = hClass;
+    AssertPtrReturn(pClass, VERR_INVALID_HANDLE);
+    AssertReturn(pClass->u32Magic == RTLOCKVALCLASS_MAGIC, VERR_INVALID_HANDLE);
+
+    ASMAtomicWriteBool(&pClass->fStrictReleaseOrder, fEnabled);
+    return VINF_SUCCESS;
 }
 
@@ -2076 +2090 @@
      * Something went wrong, pCur is pointing to where.
      */
-    if (rtLockValidatorClassIsPriorClass(pFirstBadClass, pClass))
+    if (   pClass == pFirstBadClass
+        || rtLockValidatorClassIsPriorClass(pFirstBadClass, pClass))
         return rtLockValidatorStackWrongOrder("Wrong locking order!", pSrcPos, pThreadSelf,
                                               pRec, pFirstBadRec, pClass, pFirstBadClass);
@@ -2285 +2300 @@
                   || (   pTop
                       && pTop->Core.u32Magic == RTLOCKVALRECNEST_MAGIC
-                      && pTop->Nest.pRec == pRec)))
+                      && pTop->Nest.pRec == pRec) ))
         return VINF_SUCCESS;
+
+#ifdef RTLOCKVAL_WITH_RECURSION_RECORDS
+    /* Look for a recursion record so the right frame is dumped and marked. */
+    while (pTop)
+    {
+        if (pTop->Core.u32Magic == RTLOCKVALRECNEST_MAGIC)
+        {
+            if (pTop->Nest.pRec == pRec)
+            {
+                pRec = pTop;
+                break;
+            }
+            pTop = pTop->Nest.pDown;
+        }
+        else if (pTop->Core.u32Magic == RTLOCKVALRECEXCL_MAGIC)
+            pTop = pTop->Excl.pDown;
+        else if (pTop->Core.u32Magic == RTLOCKVALRECSHRDOWN_MAGIC)
+            pTop = pTop->ShrdOwner.pDown;
+        else
+            break;
+    }
+#endif
 
     rtLockValComplainFirst("Wrong release order!", NULL, pThreadSelf, pRec, true);
     rtLockValComplainPanic();
-    return VERR_SEM_LV_WRONG_ORDER;
+    return VERR_SEM_LV_WRONG_RELEASE_ORDER;
 }
 
@@ -2810 +2847 @@
     ASMAtomicWriteU32(&pRec->Core.u32Magic, RTLOCKVALRECEXCL_MAGIC_DEAD);
     ASMAtomicWriteHandle(&pRec->hThread, NIL_RTTHREAD);
-    ASMAtomicWriteHandle(&pRec->hClass, NIL_RTLOCKVALCLASS);
+    RTLOCKVALCLASS hClass;
+    ASMAtomicXchgHandle(&pRec->hClass, NIL_RTLOCKVALCLASS, &hClass);
     if (pRec->pSibling)
         rtLockValidatorUnlinkAllSiblings(&pRec->Core);
     rtLockValidatorSerializeDestructLeave();
+    if (hClass != NIL_RTLOCKVALCLASS)
+        RTLockValidatorClassRelease(hClass);
 }
 
@@ -3019 +3059 @@
                                              PCRTLOCKVALSRCPOS pSrcPos, RTMSINTERVAL cMillies)
 {
+    /*
+     * Validate and adjust input.  Quit early if order validation is disabled.
+     */
     PRTLOCKVALRECUNION pRecU = (PRTLOCKVALRECUNION)pRec;
     AssertReturn(pRecU->Core.u32Magic == RTLOCKVALRECEXCL_MAGIC, VERR_SEM_LV_INVALID_PARAMETER);
@@ -3034 +3077 @@
     AssertReturn(hThreadSelf->u32Magic == RTTHREADINT_MAGIC, VERR_SEM_LV_INVALID_PARAMETER);
     Assert(hThreadSelf == RTThreadSelf());
+
+    /*
+     * Detect recursion as it isn't subject to order restrictions.
+     */
+    if (pRec->hThread == hThreadSelf)
+        return VINF_SUCCESS;
 
     return rtLockValidatorStackCheckLockingOrder(pRecU->Excl.hClass, pRecU->Excl.uSubClass, hThreadSelf, pRecU, pSrcPos);
@@ -3234 +3283 @@
                                                PCRTLOCKVALSRCPOS pSrcPos, RTMSINTERVAL cMillies)
 {
+    /*
+     * Validate and adjust input.  Quit early if order validation is disabled.
+     */
     PRTLOCKVALRECUNION pRecU = (PRTLOCKVALRECUNION)pRec;
     AssertReturn(pRecU->Core.u32Magic == RTLOCKVALRECSHRD_MAGIC, VERR_SEM_LV_INVALID_PARAMETER);
@@ -3250 +3302 @@
     AssertReturn(hThreadSelf->u32Magic == RTTHREADINT_MAGIC, VERR_SEM_LV_INVALID_PARAMETER);
     Assert(hThreadSelf == RTThreadSelf());
+
+    /*
+     * Detect recursion as it isn't subject to order restrictions.
+     */
+    PRTLOCKVALRECUNION pEntry = rtLockValidatorRecSharedFindOwner(&pRecU->Shared, hThreadSelf, NULL);
+    if (pEntry)
+        return VINF_SUCCESS;
 
     return rtLockValidatorStackCheckLockingOrder(pRecU->Shared.hClass, pRecU->Shared.uSubClass, hThreadSelf, pRecU, pSrcPos);
@@ -3960 +4019 @@
 
 
-RTDECL(bool) RTLockValidatorAreQuiet(void)
+RTDECL(bool) RTLockValidatorIsQuiet(void)
 {
     return ASMAtomicUoReadBool(&g_fLockValidatorQuiet);
 }
-RT_EXPORT_SYMBOL(RTLockValidatorAreQuiet);
+RT_EXPORT_SYMBOL(RTLockValidatorIsQuiet);