Changeset 26257

Timestamp:

07/04/08 20:17:00 (5 months ago)

Author:

bonefish

Message:

* Reenabled ASSERT_LOCKED_{MUTEX,RECURSIVE}() macros.
* Added mutex_switch_lock(), which unlocks one lock and locks another

one in an atomic manner (similar to switch_sem()).

Location:

haiku/branches/developer/bonefish/vm

Files:

• headers/private/kernel/lock.h (modified) (3 diffs)
• src/system/kernel/lock.cpp (modified) (2 diffs)

haiku/branches/developer/bonefish/vm/headers/private/kernel/lock.h

@@ -53 +53 @@
 
 
-#if 0 && KDEBUG // XXX disable this for now, it causes problems when including thread.h here
-#       include <thread.h>
-#define ASSERT_LOCKED_RECURSIVE(r) { ASSERT(thread_get_current_thread_id() == (r)->holder); }
-#define ASSERT_LOCKED_MUTEX(m) { ASSERT(thread_get_current_thread_id() == (m)->holder); }
+#if KDEBUG
+#       define ASSERT_LOCKED_RECURSIVE(r) \
+                { ASSERT(find_thread(NULL) == (r)->lock.holder); }
+#       define ASSERT_LOCKED_MUTEX(m) { ASSERT(find_thread(NULL) == (m)->holder); }
 #else
-#define ASSERT_LOCKED_RECURSIVE(r)
-#define ASSERT_LOCKED_MUTEX(m)
+#       define ASSERT_LOCKED_RECURSIVE(r)       do {} while (false)
+#       define ASSERT_LOCKED_MUTEX(m)           do {} while (false)
 #endif
 
@@ -101 +101 @@
 extern void mutex_init_etc(mutex* lock, const char* name, uint32 flags);
 extern void mutex_destroy(mutex* lock);
+extern status_t mutex_switch_lock(mutex* from, mutex* to);
+        // Unlocks "from" and locks "to" such that unlocking and starting to wait
+        // for the lock is atomically. I.e. if "from" guards the object "to" belongs
+        // to, the operation is safe as long as "from" is held while destroying
+        // "to".
 
 // implementation private:
 extern status_t _mutex_lock(mutex* lock, bool threadsLocked);
-extern void _mutex_unlock(mutex* lock);
+extern void _mutex_unlock(mutex* lock, bool threadsLocked);
 extern status_t _mutex_trylock(mutex* lock);
 
@@ -150 +155 @@
 mutex_unlock(mutex* lock)
 {
-#ifdef KDEBUG
-        _mutex_unlock(lock);
-#else
+#if !defined(KDEBUG)
         if (atomic_add(&lock->count, 1) < -1)
-                _mutex_unlock(lock);
 #endif
+                _mutex_unlock(lock, false);
 }
 

haiku/branches/developer/bonefish/vm/src/system/kernel/lock.cpp

@@ -382 +382 @@
 
         free(name);
+}
+
+
+status_t
+mutex_switch_lock(mutex* from, mutex* to)
+{
+        InterruptsSpinLocker locker(thread_spinlock);
+
+#if !defined(KDEBUG)
+        if (atomic_add(&from->count, 1) < -1)
+#endif
+                _mutex_unlock(from, true);
+
+        return mutex_lock_threads_locked(to);
 }
 
@@ -442 +456 @@
 
 void
-_mutex_unlock(mutex* lock)
-{
-        InterruptsSpinLocker _(thread_spinlock);
+_mutex_unlock(mutex* lock, bool threadsLocked)
+{
+        // lock only, if !threadsLocked
+        InterruptsSpinLocker locker(thread_spinlock, false, !threadsLocked);
 
 #ifdef KDEBUG