Ticket #8798: 0001-pthread_rwlock-use-a-mutex-for-process-private-locks.patch

headers/posix/pthread.h

@@ -80 +80 @@
     { PTHREAD_MUTEX_RECURSIVE, 0, -42, -1, 0 }
 #define PTHREAD_COND_INITIALIZER    \
     { 0, -42, NULL, 0, 0 }
+#define PTHREAD_RWLOCK_INITIALIZER  \
+    { 0, -1, {{0}} }
 
 /* mutex functions */
 extern int pthread_mutex_destroy(pthread_mutex_t *mutex);

headers/posix/sys/types.h

@@ -105 +105 @@
     __haiku_std_int32   owner;
     union {
         struct {
-            __haiku_std_int32   sem;
-        } shared;
-        struct {
-            __haiku_std_int32   lock_sem;
-            __haiku_std_int32   lock_count;
+            __haiku_std_int32   mutex;
+            __haiku_std_int32   unused;
             __haiku_std_int32   reader_count;
             __haiku_std_int32   writer_count;
             void*               waiters[2];
         } local;
+        struct {
+            __haiku_std_int32   sem;
+        } shared;
     } u;
 };
 

src/system/libroot/posix/pthread/pthread_rwlock.cpp

@@ -12 +12 @@
 #include <AutoLocker.h>
 #include <libroot_lock.h>
 #include <syscalls.h>
+#include <user_mutex_defs.h>
 #include <user_thread.h>
 #include <util/DoublyLinkedList.h>
 
 #include "pthread_private.h"
 
-
 #define MAX_READER_COUNT    1000000
 
 #define RWLOCK_FLAG_SHARED  0x01
@@ -93 +93 @@
 struct LocalRWLock {
     uint32_t    flags;
     int32_t     owner;
-    int32_t     lock_sem;
-    int32_t     lock_count;
+    int32_t     mutex;
+    int32_t     unused;
     int32_t     reader_count;
     int32_t     writer_count;
         // Note, that reader_count and writer_count are not used the same way.
@@ -106 +106 @@
     {
         flags = 0;
         owner = -1;
-        lock_sem = create_sem(0, "pthread rwlock");
-        lock_count = 1;
+        mutex = 0;
         reader_count = 0;
         writer_count = 0;
         new(&waiters) WaiterList;
 
-        return lock_sem >= 0 ? B_OK : EAGAIN;
+        return B_OK;
     }
 
     status_t Destroy()
     {
-        if (lock_sem < 0)
-            return B_BAD_VALUE;
-        return delete_sem(lock_sem) == B_OK ? B_OK : B_BAD_VALUE;
+        Locker locker(this);
+        if (reader_count > 0 || waiters.Head() != NULL || writer_count > 0)
+            return EBUSY;
+        return B_OK;
     }
 
     bool StructureLock()
     {
-        if (atomic_add((int32*)&lock_count, -1) <= 0)
-            acquire_sem(lock_sem);
+        // Enter critical region: lock the mutex
+        int32 status = atomic_or((int32*)&mutex, B_USER_MUTEX_LOCKED);
+
+        // If already locked, call the kernel
+        if ((status & (B_USER_MUTEX_LOCKED | B_USER_MUTEX_WAITING)) != 0) {
+            do {
+                status = _kern_mutex_lock((int32*)&mutex, NULL, 0, 0);
+            } while (status == B_INTERRUPTED);
+
+            if (status != B_OK)
+                return false;
+        }
         return true;
     }
 
     void StructureUnlock()
     {
-        if (atomic_add((int32*)&lock_count, 1) < 0)
-            release_sem(lock_sem);
+        // Exit critical region: unlock the mutex
+        int32 status = atomic_and((int32*)&mutex,
+            ~(int32)B_USER_MUTEX_LOCKED);
+
+        if ((status & B_USER_MUTEX_WAITING) != 0)
+            _kern_mutex_unlock((int32*)&mutex, 0);
     }
 
     status_t ReadLock(bigtime_t timeout)