Changeset 8421 in vbox for trunk/src/VBox/Main

Timestamp:

Apr 28, 2008 1:32:35 PM (17 years ago)

Author:

vboxsync

Message:

Main/AutoLock: Distinguish between the number of normal read locks and read locks nested into a write lock (to make sure the reader wait sempahore is properly reset before waiting on it).

Location:

trunk/src/VBox/Main

Files:

• AutoLock.cpp (modified) (6 diffs)
• include/AutoLock.h (modified) (1 diff)

trunk/src/VBox/Main/AutoLock.cpp

@@ -46 +46 @@
 
     mReadLockCount = 0;
+    mSelfReadLockCount = 0;
+
     mWriteLockLevel = 0;
     mWriteLockPending = 0;
@@ -94 +96 @@
     RTCritSectEnter (&mCritSect);
 
-    if (mWriteLockThread != RTThreadNativeSelf())
+    RTNATIVETHREAD threadSelf = RTThreadNativeSelf();
+
+    if (mWriteLockThread != threadSelf)
     {
         if (mReadLockCount != 0 || mWriteLockThread != NIL_RTNATIVETHREAD ||
@@ -110 +114 @@
         Assert (mWriteLockLevel == 0);
         Assert (mWriteLockThread == NIL_RTNATIVETHREAD);
-
-        mWriteLockThread = RTThreadNativeSelf();
+        Assert (mSelfReadLockCount == 0 /* missing unlockRead()? */);
+
+        mWriteLockThread = threadSelf;
     }
 
@@ -139 +144 @@
         if (mWriteLockLevel == 0)
         {
+            Assert (mSelfReadLockCount == 0
+                    /* mixed unlockWrite()/unlockRead() order? */);
+
             mWriteLockThread = NIL_RTNATIVETHREAD;
 
@@ -166 +174 @@
     RTCritSectEnter (&mCritSect);
 
-    ++ mReadLockCount;
-    Assert (mReadLockCount != 0 /* read lock overflow? */);
+    RTNATIVETHREAD threadSelf = RTThreadNativeSelf();
 
     bool isWriteLock = mWriteLockLevel != 0;
     bool isFirstReadLock = mReadLockCount == 1;
 
-    if (isWriteLock && mWriteLockThread == RTThreadNativeSelf())
-    {
-        /* read lock nested into the write lock, cause return immediately */
+    if (isWriteLock && mWriteLockThread == threadSelf)
+    {
+        /* read lock nested into the write lock */
+        ++ mSelfReadLockCount;
+        Assert (mSelfReadLockCount != 0 /* self read lock overflow? */);
+
+        /* cause to return immediately */
         isWriteLock = false;
     }
     else
     {
+        ++ mReadLockCount;
+        Assert (mReadLockCount != 0 /* read lock overflow? */);
+
         if (!isWriteLock)
         {
+            Assert (mSelfReadLockCount == 0 /* missing unlockRead()? */);
+
             /* write locks are top priority, so let them go if they are
              * pending */
@@ -218 +234 @@
     RTCritSectEnter (&mCritSect);
 
-    Assert (mReadLockCount != 0 /* unlockRead() w/o preceding lockRead()? */);
-    if (mReadLockCount != 0)
-    {
-        if (mWriteLockLevel != 0)
-        {
-            /* read unlock nested into the write lock, just decrease the
-             * counter */
-            Assert (mWriteLockThread == RTThreadNativeSelf()
-                    /* unlockRead() after lockWrite()? */);
-            if (mWriteLockThread == RTThreadNativeSelf())
-                -- mReadLockCount;
-        }
-        else
+    RTNATIVETHREAD threadSelf = RTThreadNativeSelf();
+
+    if (mWriteLockLevel != 0)
+    {
+        /* read unlock nested into the write lock */
+        Assert (mWriteLockThread == threadSelf
+                /* unlockRead() after lockWrite()? */);
+        if (mWriteLockThread == threadSelf)
+        {
+            Assert (mSelfReadLockCount != 0
+                    /* unlockRead() w/o preceding lockRead()? */);
+            if (mSelfReadLockCount != 0)
+            {
+                -- mSelfReadLockCount;
+            }
+        }
+    }
+    else
+    {
+        Assert (mReadLockCount != 0
+                /* unlockRead() w/o preceding lockRead()? */);
+        if (mReadLockCount != 0)
         {
             -- mReadLockCount;

trunk/src/VBox/Main/include/AutoLock.h

@@ -193 +193 @@
     RTNATIVETHREAD mWriteLockThread;
 
-    uint32_t mReadLockCount;
+    uint32_t mReadLockCount;     /*< Number of read locks */
+    uint32_t mSelfReadLockCount; /*< Number of read locks nested in write lock */
+
     uint32_t mWriteLockLevel;
     uint32_t mWriteLockPending;