Changeset 25284 in vbox for trunk/src

Timestamp:

Dec 9, 2009 9:26:28 PM (15 years ago)

Author:

vboxsync

Message:

Main: preparation for deadlock detection: add AutoWriterLockBase in preparation of AutoMulti* conversion

Location:

trunk/src/VBox/Main

Files:

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

trunk/src/VBox/Main/AutoLock.cpp

@@ -214 +214 @@
 ////////////////////////////////////////////////////////////////////////////////
 //
-// AutoWriteLock
+// AutoReadLock
+//
+////////////////////////////////////////////////////////////////////////////////
+
+/**
+ * Release all read locks acquired by this instance through the #lock()
+ * call and destroys the instance.
+ *
+ * Note that if there there are nested #lock() calls without the
+ * corresponding number of #unlock() calls when the destructor is called, it
+ * will assert. This is because having an unbalanced number of nested locks
+ * is a program logic error which must be fixed.
+ */
+/*virtual*/ AutoReadLock::~AutoReadLock()
+{
+    LockHandle *pHandle = m->aHandles[0];
+
+    if (pHandle)
+    {
+        if (m->fIsLocked)
+            pHandle->unlockRead();
+    }
+}
+
+/**
+ * Implementation of the pure virtual declared in AutoLockBase.
+ * This gets called by AutoLockBase.acquire() to actually request
+ * the semaphore; in the AutoReadLock implementation, we request
+ * the semaphore in read mode.
+ */
+/*virtual*/ void AutoReadLock::callLockImpl(LockHandle &l)
+{
+    l.lockRead();
+}
+
+/**
+ * Implementation of the pure virtual declared in AutoLockBase.
+ * This gets called by AutoLockBase.release() to actually release
+ * the semaphore; in the AutoReadLock implementation, we release
+ * the semaphore in read mode.
+ */
+/*virtual*/ void AutoReadLock::callUnlockImpl(LockHandle &l)
+{
+    l.unlockRead();
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//
+// AutoWriteLockBase
 //
 ////////////////////////////////////////////////////////////////////////////////
@@ -224 +272 @@
  * the semaphore in write mode.
  */
-/*virtual*/ void AutoWriteLock::callLockImpl(LockHandle &l)
+/*virtual*/ void AutoWriteLockBase::callLockImpl(LockHandle &l)
 {
     l.lockWrite();
@@ -235 +283 @@
  * the semaphore in write mode.
  */
-/*virtual*/ void AutoWriteLock::callUnlockImpl(LockHandle &l)
+/*virtual*/ void AutoWriteLockBase::callUnlockImpl(LockHandle &l)
 {
     l.unlockWrite();
+}
+
+/**
+ * Returns @c true if the current thread holds a write lock on the managed
+ * read/write semaphore. Returns @c false if the managed semaphore is @c
+ * NULL.
+ *
+ * @note Intended for debugging only.
+ */
+bool AutoWriteLockBase::isWriteLockOnCurrentThread() const
+{
+    return m->aHandles[0] ? m->aHandles[0]->isWriteLockOnCurrentThread() : false;
+}
+
+ /**
+ * Returns the current write lock level of the managed smaphore. The lock
+ * level determines the number of nested #lock() calls on the given
+ * semaphore handle. Returns @c 0 if the managed semaphore is @c
+ * NULL.
+ *
+ * Note that this call is valid only when the current thread owns a write
+ * lock on the given semaphore handle and will assert otherwise.
+ *
+ * @note Intended for debugging only.
+ */
+uint32_t AutoWriteLockBase::writeLockLevel() const
+{
+    return m->aHandles[0] ? m->aHandles[0]->writeLockLevel() : 0;
 }
 
@@ -261 +337 @@
  * write or a read lock is owned by some other thread by that time.
  */
-void AutoWriteLock::leave()
-{
-    LockHandle *pHandle = m->aHandles[0];
-
-    if (pHandle)
-    {
-        AssertMsg(m->fIsLocked, ("m->fIsLocked is false, cannot leave()!"));
-        AssertMsg(m->cUnlockedInLeave == 0, ("m->cUnlockedInLeave is %d, must be 0! Called leave() twice?", m->cUnlockedInLeave));
-
-        m->cUnlockedInLeave = pHandle->writeLockLevel();
-        AssertMsg(m->cUnlockedInLeave >= 1, ("m->cUnlockedInLeave is %d, must be >=1!", m->cUnlockedInLeave));
-
-        for (uint32_t left = m->cUnlockedInLeave;
-             left;
-             --left)
-            pHandle->unlockWrite();
+void AutoWriteLockBase::leave()
+{
+    AssertMsg(m->fIsLocked, ("m->fIsLocked is false, cannot leave()!"));
+    AssertMsg(m->cUnlockedInLeave == 0, ("m->cUnlockedInLeave is %d, must be 0! Called leave() twice?", m->cUnlockedInLeave));
+
+    for (HandlesVector::iterator it = m->aHandles.begin();
+         it != m->aHandles.end();
+         ++it)
+    {
+        LockHandle *pHandle = *it;
+        if (pHandle)
+        {
+            m->cUnlockedInLeave = pHandle->writeLockLevel();
+            AssertMsg(m->cUnlockedInLeave >= 1, ("m->cUnlockedInLeave is %d, must be >=1!", m->cUnlockedInLeave));
+
+            for (uint32_t left = m->cUnlockedInLeave;
+                 left;
+                 --left)
+                pHandle->unlockWrite();
+        }
     }
 }
@@ -286 +366 @@
  * between.
  */
-void AutoWriteLock::enter()
-{
-    LockHandle *pHandle = m->aHandles[0];
-
-    if (pHandle)
-    {
-        AssertMsg(m->fIsLocked, ("m->fIsLocked is false, cannot enter()!"));
-        AssertMsg(m->cUnlockedInLeave != 0, ("m->cUnlockedInLeave is 0! enter() without leave()?"));
-
-        for (; m->cUnlockedInLeave; --m->cUnlockedInLeave)
-            pHandle->lockWrite();
-    }
-}
+void AutoWriteLockBase::enter()
+{
+    AssertMsg(m->fIsLocked, ("m->fIsLocked is false, cannot enter()!"));
+    AssertMsg(m->cUnlockedInLeave != 0, ("m->cUnlockedInLeave is 0! enter() without leave()?"));
+
+    for (HandlesVector::iterator it = m->aHandles.begin();
+         it != m->aHandles.end();
+         ++it)
+    {
+        LockHandle *pHandle = *it;
+        if (pHandle)
+        {
+            for (; m->cUnlockedInLeave; --m->cUnlockedInLeave)
+                pHandle->lockWrite();
+        }
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//
+// AutoWriteLock
+//
+////////////////////////////////////////////////////////////////////////////////
 
 /**
@@ -335 +425 @@
 }
 
-/**
- * Returns @c true if the current thread holds a write lock on the managed
- * read/write semaphore. Returns @c false if the managed semaphore is @c
- * NULL.
- *
- * @note Intended for debugging only.
- */
-bool AutoWriteLock::isWriteLockOnCurrentThread() const
-{
-    return m->aHandles[0] ? m->aHandles[0]->isWriteLockOnCurrentThread() : false;
-}
-
- /**
- * Returns the current write lock level of the managed smaphore. The lock
- * level determines the number of nested #lock() calls on the given
- * semaphore handle. Returns @c 0 if the managed semaphore is @c
- * NULL.
- *
- * Note that this call is valid only when the current thread owns a write
- * lock on the given semaphore handle and will assert otherwise.
- *
- * @note Intended for debugging only.
- */
-uint32_t AutoWriteLock::writeLockLevel() const
-{
-    return m->aHandles[0] ? m->aHandles[0]->writeLockLevel() : 0;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-//
-// AutoReadLock
-//
-////////////////////////////////////////////////////////////////////////////////
-
-/**
- * Release all read locks acquired by this instance through the #lock()
- * call and destroys the instance.
- *
- * Note that if there there are nested #lock() calls without the
- * corresponding number of #unlock() calls when the destructor is called, it
- * will assert. This is because having an unbalanced number of nested locks
- * is a program logic error which must be fixed.
- */
-/*virtual*/ AutoReadLock::~AutoReadLock()
-{
-    LockHandle *pHandle = m->aHandles[0];
-
-    if (pHandle)
-    {
-        if (m->fIsLocked)
-            pHandle->unlockRead();
-    }
-}
-
-/**
- * Implementation of the pure virtual declared in AutoLockBase.
- * This gets called by AutoLockBase.acquire() to actually request
- * the semaphore; in the AutoReadLock implementation, we request
- * the semaphore in read mode.
- */
-/*virtual*/ void AutoReadLock::callLockImpl(LockHandle &l)
-{
-    l.lockRead();
-}
-
-/**
- * Implementation of the pure virtual declared in AutoLockBase.
- * This gets called by AutoLockBase.release() to actually release
- * the semaphore; in the AutoReadLock implementation, we release
- * the semaphore in read mode.
- */
-/*virtual*/ void AutoReadLock::callUnlockImpl(LockHandle &l)
-{
-    l.unlockRead();
-}
-
 } /* namespace util */
 /* vi: set tabstop=4 shiftwidth=4 expandtab: */

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

@@ -153 +153 @@
     DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP (LockHandle)
 
+    friend class AutoWriteLockBase;
     friend class AutoWriteLock;
     friend class AutoReadLock;
@@ -343 +344 @@
 ////////////////////////////////////////////////////////////////////////////////
 //
-// AutoWriteLock
-//
-////////////////////////////////////////////////////////////////////////////////
-
-class AutoWriteLock : public AutoLockBase
+// AutoReadLock
+//
+////////////////////////////////////////////////////////////////////////////////
+
+class AutoReadLock : public AutoLockBase
 {
 public:
@@ -359 +360 @@
      * runtime.
      */
-    AutoWriteLock()
+    AutoReadLock()
         : AutoLockBase(NULL)
     { }
@@ -365 +366 @@
     /**
      * Constructs a new instance that will start managing the given read/write
-     * semaphore by requesting a write lock.
-     */
-    AutoWriteLock(LockHandle *aHandle)
+     * semaphore by requesting a read lock.
+     */
+    AutoReadLock(LockHandle *aHandle)
         : AutoLockBase(aHandle)
     {
         acquire();
     }
+
+    /**
+     * Constructs a new instance that will start managing the given read/write
+     * semaphore by requesting a read lock.
+     */
+    AutoReadLock(LockHandle &aHandle)
+        : AutoLockBase(&aHandle)
+    {
+        acquire();
+    }
+
+    /**
+     * Constructs a new instance that will start managing the given read/write
+     * semaphore by requesting a read lock.
+     */
+    AutoReadLock(const Lockable &aLockable)
+        : AutoLockBase(aLockable.lockHandle())
+    {
+        acquire();
+    }
+
+    /**
+     * Constructs a new instance that will start managing the given read/write
+     * semaphore by requesting a read lock.
+     */
+    AutoReadLock(const Lockable *aLockable)
+        : AutoLockBase(aLockable ? aLockable->lockHandle() : NULL)
+    {
+        acquire();
+    }
+
+    virtual ~AutoReadLock();
+
+    virtual void callLockImpl(LockHandle &l);
+    virtual void callUnlockImpl(LockHandle &l);
+};
+
+////////////////////////////////////////////////////////////////////////////////
+//
+// AutoWriteLockBase
+//
+////////////////////////////////////////////////////////////////////////////////
+
+class AutoWriteLockBase : public AutoLockBase
+{
+protected:
+    AutoWriteLockBase(LockHandle *pHandle)
+        : AutoLockBase(pHandle)
+    { }
+
+    virtual ~AutoWriteLockBase()
+    { }
+
+    virtual void callLockImpl(LockHandle &l);
+    virtual void callUnlockImpl(LockHandle &l);
+
+public:
+    bool isWriteLockOnCurrentThread() const;
+    uint32_t writeLockLevel() const;
+
+    void leave();
+    void enter();
+
+    /**
+     * Same as #leave() but checks if the current thread actally owns the lock
+     * and only proceeds in this case. As a result, as opposed to #leave(),
+     * doesn't assert when called with no lock being held.
+     */
+    void maybeLeave()
+    {
+        if (isWriteLockOnCurrentThread())
+            leave();
+    }
+
+    /**
+     * Same as #enter() but checks if the current thread actally owns the lock
+     * and only proceeds if not. As a result, as opposed to #enter(), doesn't
+     * assert when called with the lock already being held.
+     */
+    void maybeEnter()
+    {
+        if (!isWriteLockOnCurrentThread())
+            enter();
+    }
+
+};
+
+////////////////////////////////////////////////////////////////////////////////
+//
+// AutoWriteLock
+//
+////////////////////////////////////////////////////////////////////////////////
+
+class AutoWriteLock : public AutoWriteLockBase
+{
+public:
+
+    /**
+     * Constructs a null instance that does not manage any read/write
+     * semaphore.
+     *
+     * Note that all method calls on a null instance are no-ops. This allows to
+     * have the code where lock protection can be selected (or omitted) at
+     * runtime.
+     */
+    AutoWriteLock()
+        : AutoWriteLockBase(NULL)
+    { }
 
     /**
@@ -377 +486 @@
      * semaphore by requesting a write lock.
      */
-    AutoWriteLock(LockHandle &aHandle)
-        : AutoLockBase(&aHandle)
+    AutoWriteLock(LockHandle *aHandle)
+        : AutoWriteLockBase(aHandle)
     {
         acquire();
@@ -387 +496 @@
      * semaphore by requesting a write lock.
      */
-    AutoWriteLock(const Lockable &aLockable)
-        : AutoLockBase(aLockable.lockHandle())
+    AutoWriteLock(LockHandle &aHandle)
+        : AutoWriteLockBase(&aHandle)
     {
         acquire();
@@ -397 +506 @@
      * semaphore by requesting a write lock.
      */
+    AutoWriteLock(const Lockable &aLockable)
+        : AutoWriteLockBase(aLockable.lockHandle())
+    {
+        acquire();
+    }
+
+    /**
+     * Constructs a new instance that will start managing the given read/write
+     * semaphore by requesting a write lock.
+     */
     AutoWriteLock(const Lockable *aLockable)
-        : AutoLockBase(aLockable ? aLockable->lockHandle() : NULL)
+        : AutoWriteLockBase(aLockable ? aLockable->lockHandle() : NULL)
     {
         acquire();
@@ -417 +536 @@
     }
 
-    virtual void callLockImpl(LockHandle &l);
-    virtual void callUnlockImpl(LockHandle &l);
-
-    void leave();
-    void enter();
-
-    /**
-     * Same as #leave() but checks if the current thread actally owns the lock
-     * and only proceeds in this case. As a result, as opposed to #leave(),
-     * doesn't assert when called with no lock being held.
-     */
-    void maybeLeave()
-    {
-        if (isWriteLockOnCurrentThread())
-            leave();
-    }
-
-    /**
-     * Same as #enter() but checks if the current thread actally owns the lock
-     * and only proceeds if not. As a result, as opposed to #enter(), doesn't
-     * assert when called with the lock already being held.
-     */
-    void maybeEnter()
-    {
-        if (!isWriteLockOnCurrentThread())
-            enter();
-    }
-
     void attach(LockHandle *aHandle);
 
@@ -466 +557 @@
 
     void attachRaw(LockHandle *ph);
-
-    bool isWriteLockOnCurrentThread() const;
-    uint32_t writeLockLevel() const;
-};
-
-////////////////////////////////////////////////////////////////////////////////
-//
-// AutoReadLock
-//
-////////////////////////////////////////////////////////////////////////////////
-
-class AutoReadLock : public AutoLockBase
-{
-public:
-
-    /**
-     * Constructs a null instance that does not manage any read/write
-     * semaphore.
-     *
-     * Note that all method calls on a null instance are no-ops. This allows to
-     * have the code where lock protection can be selected (or omitted) at
-     * runtime.
-     */
-    AutoReadLock()
-        : AutoLockBase(NULL)
-    { }
-
-    /**
-     * Constructs a new instance that will start managing the given read/write
-     * semaphore by requesting a read lock.
-     */
-    AutoReadLock(LockHandle *aHandle)
-        : AutoLockBase(aHandle)
-    {
-        acquire();
-    }
-
-    /**
-     * Constructs a new instance that will start managing the given read/write
-     * semaphore by requesting a read lock.
-     */
-    AutoReadLock(LockHandle &aHandle)
-        : AutoLockBase(&aHandle)
-    {
-        acquire();
-    }
-
-    /**
-     * Constructs a new instance that will start managing the given read/write
-     * semaphore by requesting a read lock.
-     */
-    AutoReadLock(const Lockable &aLockable)
-        : AutoLockBase(aLockable.lockHandle())
-    {
-        acquire();
-    }
-
-    /**
-     * Constructs a new instance that will start managing the given read/write
-     * semaphore by requesting a read lock.
-     */
-    AutoReadLock(const Lockable *aLockable)
-        : AutoLockBase(aLockable ? aLockable->lockHandle() : NULL)
-    {
-        acquire();
-    }
-
-    virtual ~AutoReadLock();
-
-    virtual void callLockImpl(LockHandle &l);
-    virtual void callUnlockImpl(LockHandle &l);
 };