2000-10-10 Ross Johnson <rpj@setup1.ise.canberra.edu.au>

        * misc.c (pthread_self): Restore Win32 "last error"
        cleared by TlsGetValue() call in
        pthread_getspecific()
        - "Steven Reddie" <smr@essemer.com.au>

2000-09-20  Ross Johnson  <rpj@setup1.ise.canberra.edu.au>

        * mutex.c (pthread_mutex_lock): Record the owner
        of the mutex. This requires also keeping count of
        recursive locks ourselves rather than leaving it
        to Win32 since we need to know when to NULL the
        thread owner when the mutex is unlocked.
        (pthread_mutex_trylock): Likewise.
        (pthread_mutex_unlock): Check that the calling
        thread owns the mutex, decrement the recursive
        lock count, and NULL the owner if zero. Return
        EPERM if the mutex is owned by another thread.
        * implement.h (pthread_mutex_t_): Add ownerThread
        and lockCount members.
        - reported by Arthur Kantor <akantor@bexusa.com>

1 files changed, 62 insertions, 0 deletions

diff --git a/tests/mutex4.c b/tests/mutex4.c
new file mode 100644
index 0000000..5290f2a
--- /dev/null
+++ b/tests/mutex4.c
@@ -0,0 +1,62 @@
+/* 
+ * mutex4.c
+ *
+ * Thread A locks mutex - thread B tries to unlock.
+ *
+ * Depends on API functions: 
+ *	pthread_mutex_lock()
+ *	pthread_mutex_trylock()
+ *	pthread_mutex_unlock()
+ */
+
+#include "test.h"
+ 
+pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
+pthread_mutex_t locker_done = PTHREAD_MUTEX_INITIALIZER;
+pthread_mutex_t unlocker_done = PTHREAD_MUTEX_INITIALIZER;
+
+static int washere = 0;
+
+void * locker(void * arg)
+{
+  assert(pthread_mutex_lock(&locker_start) == 0);
+  assert(pthread_mutex_lock(&mutex1) == 0);
+  assert(pthread_mutex_unlock(&locker_start) == 0);
+
+  /* Wait for unlocker to finish */
+  assert(pthread_mutex_lock(&unlocker_end) == 0);
+  assert(pthread_mutex_unlock(&mutex1) == 0);
+
+  return 0;
+}
+ 
+void * unlocker(void * arg)
+{
+  /* Wait for locker to lock mutex1 */
+  assert(pthread_mutex_lock(&unlocker_start) == 0);
+
+  assert(pthread_mutex_unlock(&mutex1) == EPERM);
+
+  assert(pthread_mutex_unlock(&unlocker_start) == 0);
+
+  return 0;
+}
+ 
+int
+main()
+{
+  pthread_t t;
+
+  assert(pthread_mutex_lock(&locker_start) == 0);
+  assert(pthread_mutex_lock(&unlocker_start) == 0);
+
+  assert(pthread_create(&t, NULL, locker, NULL) == 0);
+  assert(pthread_mutex_unlock(&locker_start) == 0);
+  Sleep(0);
+
+  assert(pthread_create(&t, NULL, unlocker, NULL) == 0);
+  assert(pthread_mutex_unlock(&unlocker_start) == 0);
+  Sleep(0);
+
+  return 0;
+}