Implement cond_*, mutex_* (lots of refactoring)
authorDavid Bartley <dtbartle@csclub.uwaterloo.ca>
Sat, 16 Aug 2008 06:59:03 +0000 (02:59 -0400)
committerDavid Bartley <dtbartle@csclub.uwaterloo.ca>
Sat, 16 Aug 2008 06:59:43 +0000 (02:59 -0400)
42 files changed:
nptl/sysdeps/unix/sysv/solaris2/opensolaris-gnu/Makefile
nptl/sysdeps/unix/sysv/solaris2/opensolaris-gnu/Versions
nptl/sysdeps/unix/sysv/solaris2/opensolaris-gnu/cond_broadcast.c [new file with mode: 0644]
nptl/sysdeps/unix/sysv/solaris2/opensolaris-gnu/cond_destroy.c [new file with mode: 0644]
nptl/sysdeps/unix/sysv/solaris2/opensolaris-gnu/cond_init.c
nptl/sysdeps/unix/sysv/solaris2/opensolaris-gnu/cond_reltimedwait.c
nptl/sysdeps/unix/sysv/solaris2/opensolaris-gnu/cond_signal.c [new file with mode: 0644]
nptl/sysdeps/unix/sysv/solaris2/opensolaris-gnu/cond_timedwait.c [new file with mode: 0644]
nptl/sysdeps/unix/sysv/solaris2/opensolaris-gnu/cond_wait.c [new file with mode: 0644]
nptl/sysdeps/unix/sysv/solaris2/opensolaris-gnu/fastlock.c
nptl/sysdeps/unix/sysv/solaris2/opensolaris-gnu/internaltypes.h
nptl/sysdeps/unix/sysv/solaris2/opensolaris-gnu/mutex_consistent.c [new file with mode: 0644]
nptl/sysdeps/unix/sysv/solaris2/opensolaris-gnu/mutex_destroy.c [new file with mode: 0644]
nptl/sysdeps/unix/sysv/solaris2/opensolaris-gnu/mutex_init.c
nptl/sysdeps/unix/sysv/solaris2/opensolaris-gnu/mutex_lock.c [new file with mode: 0644]
nptl/sysdeps/unix/sysv/solaris2/opensolaris-gnu/mutex_timedlock.c [new file with mode: 0644]
nptl/sysdeps/unix/sysv/solaris2/opensolaris-gnu/mutex_trylock.c [new file with mode: 0644]
nptl/sysdeps/unix/sysv/solaris2/opensolaris-gnu/mutex_unlock.c [new file with mode: 0644]
nptl/sysdeps/unix/sysv/solaris2/opensolaris-gnu/pthreadP.h
nptl/sysdeps/unix/sysv/solaris2/opensolaris-gnu/pthread_barrier_wait.c
nptl/sysdeps/unix/sysv/solaris2/opensolaris-gnu/pthread_cond_broadcast.c
nptl/sysdeps/unix/sysv/solaris2/opensolaris-gnu/pthread_cond_destroy.c
nptl/sysdeps/unix/sysv/solaris2/opensolaris-gnu/pthread_cond_init.c
nptl/sysdeps/unix/sysv/solaris2/opensolaris-gnu/pthread_cond_signal.c
nptl/sysdeps/unix/sysv/solaris2/opensolaris-gnu/pthread_cond_timedwait.c
nptl/sysdeps/unix/sysv/solaris2/opensolaris-gnu/pthread_cond_wait.c
nptl/sysdeps/unix/sysv/solaris2/opensolaris-gnu/pthread_mutex_consistent.c
nptl/sysdeps/unix/sysv/solaris2/opensolaris-gnu/pthread_mutex_destroy.c
nptl/sysdeps/unix/sysv/solaris2/opensolaris-gnu/pthread_mutex_init.c
nptl/sysdeps/unix/sysv/solaris2/opensolaris-gnu/pthread_mutex_lock.c
nptl/sysdeps/unix/sysv/solaris2/opensolaris-gnu/pthread_mutex_timedlock.c
nptl/sysdeps/unix/sysv/solaris2/opensolaris-gnu/pthread_mutex_trylock.c
nptl/sysdeps/unix/sysv/solaris2/opensolaris-gnu/pthread_mutex_unlock.c
nptl/sysdeps/unix/sysv/solaris2/opensolaris-gnu/pthread_rwlock_destroy.c
nptl/sysdeps/unix/sysv/solaris2/opensolaris-gnu/pthread_rwlock_rdlock.c
nptl/sysdeps/unix/sysv/solaris2/opensolaris-gnu/pthread_rwlock_timedrdlock.c
nptl/sysdeps/unix/sysv/solaris2/opensolaris-gnu/pthread_rwlock_timedwrlock.c
nptl/sysdeps/unix/sysv/solaris2/opensolaris-gnu/pthread_rwlock_tryrdlock.c
nptl/sysdeps/unix/sysv/solaris2/opensolaris-gnu/pthread_rwlock_trywrlock.c
nptl/sysdeps/unix/sysv/solaris2/opensolaris-gnu/pthread_rwlock_unlock.c
nptl/sysdeps/unix/sysv/solaris2/opensolaris-gnu/pthread_rwlock_wrlock.c
nptl/sysdeps/unix/sysv/solaris2/opensolaris-gnu/synch.h

index 2947a1b..69736cc 100644 (file)
@@ -7,10 +7,13 @@ libpthread-sysdep_routines += pt-fork fastlock clock_gettime \
     sys_lwp_mutex_register sys_lwp_cond_wait sys_lwp_cond_signal \
     sys_lwp_cond_broadcast sys_lwp_sema_post sys_lwp_sema_trywait \
     sys_lwp_sema_timedwait sys_lwp_create sys_lwp_wait sys_lwp_exit \
-    sys_lwp_kill sys_lwp_suspend sys_lwp_continue
-libpthread-routines += sys_lwp_self \
-    thr_create thr_join thr_exit thr_self \
-    mutex_init cond_init cond_reltimedwait rwlock_init
+    sys_lwp_kill sys_lwp_suspend sys_lwp_continue sys_write
+libpthread-routines += sys_lwp_self
+
+# solaris threads/synch
+libpthread-routines += mutex_init mutex_lock mutex_trylock mutex_unlock \
+    mutex_destroy mutex_timedlock mutex_consistent cond_init cond_wait \
+    cond_timedwait cond_reltimedwait cond_signal cond_broadcast cond_destroy
 endif
 
 ifeq ($(subdir),posix)
index 04b767d..9675de2 100644 (file)
@@ -33,6 +33,6 @@ libpthread {
     thr_create; thr_join; thr_exit; thr_suspend; thr_continue; thr_self;
     thr_setconcurrency; thr_getconcurrency; thr_main; thr_kill; thr_yield;
     thr_setprio; thr_getprio; thr_keycreate; thr_keycreate_once; thr_min_stack;
-    thr_setspecific;
+    thr_setspecific; thr_sigsetmask; thr_stksegment; thr_main;
   }
 }
diff --git a/nptl/sysdeps/unix/sysv/solaris2/opensolaris-gnu/cond_broadcast.c b/nptl/sysdeps/unix/sysv/solaris2/opensolaris-gnu/cond_broadcast.c
new file mode 100644 (file)
index 0000000..00d6885
--- /dev/null
@@ -0,0 +1,36 @@
+/* Copyright (C) 2008 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+   Contributed by David Bartley <dtbartle@csclub.uwaterloo.ca>, 2008.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, write to the Free
+   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+   02111-1307 USA.  */
+
+#include <inline-syscall.h>
+#include <pthreadP.h>
+#include <synch.h>
+#include <errno.h>
+
+DECLARE_INLINE_SYSCALL (int, lwp_cond_broadcast, cond_t *cv);
+
+
+int cond_broadcast (cond)
+      cond_t *cond;
+{
+  /* Don't bother entering the kernel if there are no waiters.  */
+  if (cond->cond_waiters_kernel == 0)
+    return 0;
+
+  return INLINE_SYSCALL (lwp_cond_broadcast, 1, cond);
+}
diff --git a/nptl/sysdeps/unix/sysv/solaris2/opensolaris-gnu/cond_destroy.c b/nptl/sysdeps/unix/sysv/solaris2/opensolaris-gnu/cond_destroy.c
new file mode 100644 (file)
index 0000000..2b502ee
--- /dev/null
@@ -0,0 +1,31 @@
+/* Copyright (C) 2008 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+   Contributed by David Bartley <dtbartle@csclub.uwaterloo.ca>, 2008.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, write to the Free
+   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+   02111-1307 USA.  */
+
+#include <inline-syscall.h>
+#include <pthreadP.h>
+#include <synch.h>
+#include <errno.h>
+
+
+int cond_destroy (cond)
+      cond_t *cond;
+{
+  memset (cond, 0, sizeof(cond_t));
+  return 0;
+}
index d629d13..9de9b80 100644 (file)
    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
    02111-1307 USA.  */
 
+#include <inline-syscall.h>
 #include <pthreadP.h>
-#include <string.h>
 #include <synch.h>
-#include <synch_priv.h>
+#include <errno.h>
 
-int cond_init (cond_t *cond, int type, void *arg)
+
+int cond_init (cond, type, arg)
+      cond_t *cond;
+      int type;
+      void *arg;
 {
   // TODO: check type
-  memset (cond, 0, sizeof(cond_t));
+
+  memset (cond, 0, sizeof(pthread_cond_t));
   cond->cond_type = type;
   cond->cond_magic = COND_MAGIC;
-
-  return 0;
 }
index 39f860e..103e59f 100644 (file)
    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
    02111-1307 USA.  */
 
+#include <inline-syscall.h>
 #include <pthreadP.h>
-#include <string.h>
-#include <time.h>
 #include <synch.h>
-#include <synch_priv.h>
-#include <inline-syscall.h>
+#include <errno.h>
 
-DECLARE_INLINE_SYSCALL (int, lwp_cond_wait, cond_t *cond, mutex_t *mutex,
+DECLARE_INLINE_SYSCALL (int, lwp_cond_wait, cond_t *cv, mutex_t *mp,
     struct timespec *tsp, int check_park);
 
-int cond_reltimedwait (cond_t *cond, mutex_t *mutex,
-    const struct timespec *reltime)
+struct _condvar_cleanup_buffer
+{
+  int oldtype;
+  cond_t *cond;
+  mutex_t *mutex;
+  int old_cond_waiters;
+  int old_mutex_rcount;
+};
+
+void
+__attribute__ ((visibility ("hidden")))
+__condvar_cleanup (void *arg)
+{
+  struct _condvar_cleanup_buffer *cbuffer =
+    (struct _condvar_cleanup_buffer *) arg;
+  mutex_t *mutex = cbuffer->mutex;
+
+  /* Note: we don't whether the mutex was unlocked by the kernel or not.  */
+
+  /* The condition variable is no longer using the mutex.  */
+  mutex->mutex_cond_waiters = cbuffer->old_cond_waiters;
+
+  int errval = 0;
+  while (1)
+    {
+      if (mutex->mutex_lockbyte == LOCKBYTE_SET &&
+        ((mutex->mutex_type & LOCK_SHARED) == 0 ||
+          mutex->mutex_ownerpid == THREAD_GETMEM (THREAD_SELF, pid)) &&
+         (mutex->mutex_owner == (uintptr_t)THREAD_SELF))
+        {
+          /* The lock is held by us (we didn't get signaled).  */
+          break;
+        }
+      else if (mutex->mutex_lockbyte == 0)
+        {
+          /* The mutex is unlocked.  */
+          errval = mutex_lock (mutex);
+          break;
+        }
+    }
+
+  /* Restore the mutex_rcount.  */
+  if (errval == 0)
+    mutex->mutex_rcount = cbuffer->old_mutex_rcount;
+}
+
+
+int
+__cond_reltimedwait_internal (cond, mutex, reltime, cancel)
+     cond_t *cond;
+     mutex_t *mutex;
+     struct timespec *reltime;
+     int cancel;
+{
+  struct _pthread_cleanup_buffer buffer;
+  struct _condvar_cleanup_buffer cbuffer;
+
+  /* Reject invalid timeouts.  */
+  if (reltime && (reltime->tv_nsec < 0 || reltime->tv_nsec >= 1000000000))
+    return EINVAL;
+
+  if ((mutex->mutex_type & LOCK_ERRORCHECK) &&
+     ((mutex->mutex_lockbyte != LOCKBYTE_SET ||
+       mutex->mutex_owner != (uintptr_t)THREAD_SELF ||
+     ((mutex->mutex_type & LOCK_SHARED) &&
+       mutex->mutex_ownerpid != THREAD_GETMEM (THREAD_SELF, pid)))))
+    {
+      /* Error checking: lock not held by this thread.  */
+      return EPERM;
+    }
+  else if ((mutex->mutex_type & LOCK_RECURSIVE) &&
+            mutex->mutex_lockbyte == LOCKBYTE_SET &&
+          ((mutex->mutex_type & LOCK_SHARED) == 0 ||
+            mutex->mutex_ownerpid == THREAD_GETMEM (THREAD_SELF, pid)) &&
+            mutex->mutex_owner == (uintptr_t)THREAD_SELF &&
+            mutex->mutex_rcount > 0)
+    {
+      /* Recursively held lock. XXX: Using recursive mutexes with condition
+         variables is undefined; we do what sun's libc does, namely fully
+         release the lock.  */
+      cbuffer.old_mutex_rcount = mutex->mutex_rcount;
+      mutex->mutex_rcount = 0;
+    }
+
+  /* Mark the mutex as still in use.  */
+  cbuffer.old_cond_waiters = mutex->mutex_cond_waiters;
+  if (cbuffer.old_cond_waiters == 0)
+    mutex->mutex_cond_waiters = 1;
+
+  /* Prepare structure passed to cancellation handler.  */
+  cbuffer.cond = cond;
+  cbuffer.mutex = mutex;
+
+  if (cancel)
+    {
+      /* Before we block we enable cancellation.  Therefore we have to
+         install a cancellation handler.  */
+      __pthread_cleanup_push (&buffer, __condvar_cleanup, &cbuffer);
+
+      /* Enable asynchronous cancellation.  Required by the standard.  */
+      cbuffer.oldtype = __pthread_enable_asynccancel ();
+    }
+
+  if (reltime && reltime->tv_sec < 0)
+    return ETIME;
+  int errval = INLINE_SYSCALL (lwp_cond_wait, 4, cond, mutex, reltime, 1);
+
+  /* The docs say to return 0 when interrupted.  */
+  if (errval == EINTR)
+    errval = 0;
+
+  if (cancel)
+    {
+      /* Disable asynchronous cancellation.  */
+      __pthread_disable_asynccancel (cbuffer.oldtype);
+
+      /* The cancellation handling is back to normal, remove the handler.  */
+      __pthread_cleanup_pop (&buffer, 0);
+    }
+
+  /* Re-acquire the lock. The docs say we must always re-acquire so we don't
+     use __mutex_timedlock. Note that even if the above wait fails the kernel
+     always unlocks the mutex.  */
+  int errval2 = mutex_lock (mutex);
+  if (errval2 == EINTR)
+    return 0;
+  else if (errval2 != 0)
+    return errval2;
+
+  /* Restore the mutex_rcount.  */
+  if (mutex->mutex_type & LOCK_RECURSIVE)
+    mutex->mutex_rcount = cbuffer.old_mutex_rcount;
+
+  /* The condition variable is no longer using the mutex.  */
+  if (cbuffer.old_cond_waiters == 0)
+    mutex->mutex_cond_waiters = 0;
+
+  return errval;
+}
+
+
+int cond_reltimedwait (cond, mutex, reltime)
+      cond_t *cond;
+      mutex_t *mutex;
+      struct timespec *reltime;
 {
-  // TODO
-  return INLINE_SYSCALL (lwp_cond_wait, 4, cond, mutex, reltime, 1);
+  return __cond_reltimedwait_internal (cond, mutex, reltime, 1);
 }
diff --git a/nptl/sysdeps/unix/sysv/solaris2/opensolaris-gnu/cond_signal.c b/nptl/sysdeps/unix/sysv/solaris2/opensolaris-gnu/cond_signal.c
new file mode 100644 (file)
index 0000000..0c39bc5
--- /dev/null
@@ -0,0 +1,36 @@
+/* Copyright (C) 2008 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+   Contributed by David Bartley <dtbartle@csclub.uwaterloo.ca>, 2008.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, write to the Free
+   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+   02111-1307 USA.  */
+
+#include <inline-syscall.h>
+#include <pthreadP.h>
+#include <synch.h>
+#include <errno.h>
+
+DECLARE_INLINE_SYSCALL (int, lwp_cond_signal, cond_t *cv);
+
+
+int cond_signal (cond)
+      cond_t *cond;
+{
+  /* Don't bother entering the kernel if there are no waiters.  */
+  if (cond->cond_waiters_kernel == 0)
+    return 0;
+
+  return INLINE_SYSCALL (lwp_cond_signal, 1, cond);
+}
diff --git a/nptl/sysdeps/unix/sysv/solaris2/opensolaris-gnu/cond_timedwait.c b/nptl/sysdeps/unix/sysv/solaris2/opensolaris-gnu/cond_timedwait.c
new file mode 100644 (file)
index 0000000..9c43fe2
--- /dev/null
@@ -0,0 +1,38 @@
+/* Copyright (C) 2008 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+   Contributed by David Bartley <dtbartle@csclub.uwaterloo.ca>, 2008.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, write to the Free
+   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+   02111-1307 USA.  */
+
+#include <inline-syscall.h>
+#include <pthreadP.h>
+#include <synch.h>
+#include <abstime-to-reltime.h>
+
+
+int cond_timedwait (cond, mutex, abstime)
+      cond_t *cond;
+      mutex_t *mutex;
+      struct timespec *abstime;
+{
+  /* Reject invalid timeouts.  */
+  if (abstime && (abstime->tv_nsec < 0 || abstime->tv_nsec >= 1000000000))
+    return EINVAL;
+
+  struct timespec _reltime;
+  struct timespec *reltime = abstime_to_reltime (abstime, &_reltime);
+  return cond_reltimedwait (cond, mutex, reltime);
+}
diff --git a/nptl/sysdeps/unix/sysv/solaris2/opensolaris-gnu/cond_wait.c b/nptl/sysdeps/unix/sysv/solaris2/opensolaris-gnu/cond_wait.c
new file mode 100644 (file)
index 0000000..40c0280
--- /dev/null
@@ -0,0 +1,31 @@
+/* Copyright (C) 2008 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+   Contributed by David Bartley <dtbartle@csclub.uwaterloo.ca>, 2008.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, write to the Free
+   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+   02111-1307 USA.  */
+
+#include <inline-syscall.h>
+#include <pthreadP.h>
+#include <synch.h>
+#include <errno.h>
+
+
+int cond_wait (cond, mutex)
+      cond_t *cond;
+      mutex_t *mutex;
+{
+  return cond_reltimedwait (cond, mutex, NULL);
+}
index d462dc2..72048a5 100644 (file)
    02111-1307 USA.  */
 
 #include <errno.h>
-#include "pthreadP.h"
+#include <pthreadP.h>
 #include <synch_priv.h>
 #include <sys/synch.h>
 #include <stdbool.h>
 #include <assert.h>
 
-int __mutex_lock_fast (pthread_mutex_t *mutex, bool try)
+int __mutex_lock_fast (mutex_t *mutex, bool try)
 {
   if (mutex->mutex_lockword32 == LOCKWORD32_UNSET_NO_WAITERS)
     {
@@ -88,7 +88,7 @@ int __mutex_lock_fast (pthread_mutex_t *mutex, bool try)
 }
 
 
-int __mutex_unlock_fast (pthread_mutex_t *mutex)
+int __mutex_unlock_fast (mutex_t *mutex)
 {
   if ((mutex->mutex_type & LOCK_RECURSIVE) &&
        mutex->mutex_lockbyte == LOCKBYTE_SET &&
index 640b93f..b7a7d37 100644 (file)
@@ -58,8 +58,13 @@ struct pthread_attr
 /* Mutex attribute data structure.  */
 struct pthread_mutexattr
 {
+  /* Identifier for the kind of mutex.
+
+     Bit 31 is set if the mutex is to be shared between processes.
+
+     Bit 0 to 30 contain one of the PTHREAD_MUTEX_ values to identify
+     the type of the mutex.  */
   int mutexkind;
-  int ceiling;
 };
 
 
diff --git a/nptl/sysdeps/unix/sysv/solaris2/opensolaris-gnu/mutex_consistent.c b/nptl/sysdeps/unix/sysv/solaris2/opensolaris-gnu/mutex_consistent.c
new file mode 100644 (file)
index 0000000..9227bb2
--- /dev/null
@@ -0,0 +1,39 @@
+/* Copyright (C) 2008 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+   Contributed by David Bartley <dtbartle@csclub.uwaterloo.ca>, 2008.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, write to the Free
+   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+   02111-1307 USA.  */
+
+#include <pthreadP.h>
+#include <synch.h>
+#include <errno.h>
+
+
+int mutex_consistent (mutex)
+      mutex_t *mutex;
+{
+  if ((mutex->mutex_type & LOCK_ROBUST) == 0 ||
+      (mutex->mutex_flag & LOCK_INITED) == 0 ||
+      (mutex->mutex_flag & (LOCK_OWNERDEAD | LOCK_UNMAPPED)) == 0)
+    return EINVAL;
+
+  mutex->mutex_flag &= ~(LOCK_OWNERDEAD | LOCK_UNMAPPED);
+
+  /* The lock cannot be recursively held since it was just reclaimed.  */
+  mutex->mutex_rcount = 0;
+
+  return 0;
+}
diff --git a/nptl/sysdeps/unix/sysv/solaris2/opensolaris-gnu/mutex_destroy.c b/nptl/sysdeps/unix/sysv/solaris2/opensolaris-gnu/mutex_destroy.c
new file mode 100644 (file)
index 0000000..6063636
--- /dev/null
@@ -0,0 +1,35 @@
+/* Copyright (C) 2008 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+   Contributed by David Bartley <dtbartle@csclub.uwaterloo.ca>, 2008.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, write to the Free
+   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+   02111-1307 USA.  */
+
+#include <pthreadP.h>
+#include <synch.h>
+#include <errno.h>
+#include <synch_priv.h>
+
+
+int mutex_destroy (mutex)
+      mutex_t *mutex;
+{
+  if (mutex->mutex_type & LOCK_ROBUST)
+    memset (mutex, 0, sizeof(mutex_t));
+  else
+    mutex->mutex_magic = -1;
+
+  return 0;
+}
index 70cfa70..7c60dc4 100644 (file)
    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
    02111-1307 USA.  */
 
+#include <inline-syscall.h>
 #include <pthreadP.h>
-#include <string.h>
 #include <synch.h>
-#include <synch_priv.h>
+#include <errno.h>
 
-int mutex_init (mutex_t *mutex, int type, void * arg)
+DECLARE_INLINE_SYSCALL (int, lwp_mutex_register, mutex_t *lp);
+
+
+int mutex_init (mutex, type, arg)
+      mutex_t *mutex;
+      int type;
+      void * arg;
 {
-  // TODO: check type and ceil (arg)
+  // TODO: check type
+
   if (type & LOCK_ROBUST)
     {
-      // TODO
+      if ((mutex->mutex_type & LOCK_INITED))
+        return EBUSY;
     }
   else
     {
-      memset (mutex, 0, sizeof(mutex_t));
+      memset (mutex, 0, sizeof(pthread_mutex_t));
     }
   mutex->mutex_type = type;
   mutex->mutex_flag = LOCK_INITED;
   mutex->mutex_magic = MUTEX_MAGIC;
-  mutex->mutex_ceiling = *(int *)arg;
+  mutex->mutex_ceiling = (int)arg;
+  mutex->mutex_cond_waiters = 0;
+
+  /* Register robust shared lock.  */
+  if ((type & (LOCK_ROBUST | LOCK_SHARED)) == (LOCK_ROBUST | LOCK_SHARED))
+    {
+      int errval = INLINE_SYSCALL (lwp_mutex_register, 1, mutex);
+      if (errval != 0)
+        return errval;
+    }
 
   return 0;
 }
diff --git a/nptl/sysdeps/unix/sysv/solaris2/opensolaris-gnu/mutex_lock.c b/nptl/sysdeps/unix/sysv/solaris2/opensolaris-gnu/mutex_lock.c
new file mode 100644 (file)
index 0000000..0f7a1bb
--- /dev/null
@@ -0,0 +1,27 @@
+/* Copyright (C) 2008 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+   Contributed by David Bartley <dtbartle@csclub.uwaterloo.ca>, 2008.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, write to the Free
+   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+   02111-1307 USA.  */
+
+#include <pthreadP.h>
+#include <synch.h>
+
+int mutex_lock (mutex)
+      mutex_t *mutex;
+{
+  return __mutex_timedlock (mutex, NULL);
+}
diff --git a/nptl/sysdeps/unix/sysv/solaris2/opensolaris-gnu/mutex_timedlock.c b/nptl/sysdeps/unix/sysv/solaris2/opensolaris-gnu/mutex_timedlock.c
new file mode 100644 (file)
index 0000000..5616ece
--- /dev/null
@@ -0,0 +1,107 @@
+/* Copyright (C) 2008 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+   Contributed by David Bartley <dtbartle@csclub.uwaterloo.ca>, 2008.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, write to the Free
+   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+   02111-1307 USA.  */
+
+#include <inline-syscall.h>
+#include <pthreadP.h>
+#include <synch.h>
+#include <errno.h>
+#include <time.h>
+#include <synch_priv.h>
+#include <abstime-to-reltime.h>
+
+DECLARE_INLINE_SYSCALL (int, lwp_mutex_timedlock, mutex_t *lp,
+    struct timespec *tsp);
+
+extern int __mutex_lock_fast (mutex_t *mutex, bool try);
+
+
+int __mutex_timedlock (mutex, abstime)
+      mutex_t *mutex;
+      const struct timespec *abstime;
+{
+  /* Handle inconsistent robust mutexes.  */
+  if ((mutex->mutex_type & LOCK_ROBUST) &&
+      (mutex->mutex_flag & LOCK_NOTRECOVERABLE))
+    return ENOTRECOVERABLE;
+
+  /* Reject invalid timeouts.  */
+  if (abstime && (abstime->tv_nsec < 0 || abstime->tv_nsec >= 1000000000))
+    return EINVAL;
+
+  /* Always hit the kernel for priority inherit locks.  */
+  if ((mutex->mutex_type & LOCK_PRIO_INHERIT) == 0)
+    {
+      int res = __mutex_lock_fast (mutex, false);
+      if(res >= 0)
+        return res;
+    }
+  else
+    {
+      /* Except when we already hold a recursive lock.  */
+      if ((mutex->mutex_type & LOCK_RECURSIVE) &&
+           mutex->mutex_lockbyte == LOCKBYTE_SET &&
+         ((mutex->mutex_type & LOCK_SHARED) == 0 ||
+           mutex->mutex_ownerpid == THREAD_GETMEM (THREAD_SELF, pid)) &&
+           mutex->mutex_owner == (uintptr_t)THREAD_SELF)
+        {
+          /* XXX: Solaris mutexes have no overflow check and don't know about
+             EAGAIN; in practice overflow will not occur so we don't care.  */
+          if (mutex->mutex_rcount == RECURSION_MAX)
+            return EAGAIN;
+          ++mutex->mutex_rcount;
+          return 0;
+        }
+    }
+
+  struct timespec _reltime;
+  struct timespec *reltime = abstime_to_reltime (abstime, &_reltime);
+  if (reltime && reltime->tv_sec < 0)
+    return ETIME;
+  int errval = INLINE_SYSCALL (lwp_mutex_timedlock, 2, mutex, reltime);
+
+  /* The kernel sets EDEADLK for priority inherit mutexes.  */
+  if (errval == EDEADLK && (mutex->mutex_type & LOCK_PRIO_INHERIT) &&
+        (mutex->mutex_type & LOCK_ERRORCHECK) == 0)
+    {
+      /* We aren't an error checking mutex so we need to block.  */
+      INTERNAL_SYSCALL_DECL (err);
+      if (abstime)
+        {
+          int result = INTERNAL_SYSCALL (nanosleep, err, 2, reltime, NULL);
+          errval = INTERNAL_SYSCALL_ERRNO (result, err) ? EINTR: ETIMEDOUT;
+        }
+      else
+        {
+          INTERNAL_SYSCALL (pause, err, 1, 0);
+          errval = EINTR;
+        }
+    }
+  if (errval != 0 && errval != EOWNERDEAD)
+    return errval;
+
+  /* The kernel does not set mutex_owner so we set it here.  */
+  if (mutex->mutex_type & (LOCK_RECURSIVE | LOCK_ERRORCHECK))
+    mutex->mutex_owner = (uintptr_t)THREAD_SELF;
+
+  /* The kernel does not set the lockbyte for priority inherit mutexes.  */
+  if (mutex->mutex_type & LOCK_PRIO_INHERIT)
+    mutex->mutex_lockbyte = 1;
+
+  return errval;
+}
diff --git a/nptl/sysdeps/unix/sysv/solaris2/opensolaris-gnu/mutex_trylock.c b/nptl/sysdeps/unix/sysv/solaris2/opensolaris-gnu/mutex_trylock.c
new file mode 100644 (file)
index 0000000..f1054dc
--- /dev/null
@@ -0,0 +1,80 @@
+/* Copyright (C) 2008 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+   Contributed by David Bartley <dtbartle@csclub.uwaterloo.ca>, 2008.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, write to the Free
+   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+   02111-1307 USA.  */
+
+#include <inline-syscall.h>
+#include <pthreadP.h>
+#include <synch.h>
+#include <errno.h>
+#include <synch_priv.h>
+
+DECLARE_INLINE_SYSCALL (int, lwp_mutex_trylock, mutex_t *lp);
+
+extern int __mutex_lock_fast(pthread_mutex_t *mutex, bool try);
+
+
+int mutex_trylock (mutex)
+      mutex_t *mutex;
+{
+  /* Handle inconsistent robust mutexes.  */
+  if ((mutex->mutex_type & LOCK_ROBUST) &&
+      (mutex->mutex_flag & LOCK_NOTRECOVERABLE))
+    return ENOTRECOVERABLE;
+
+  /* Always hit the kernel for priority inherit locks.  */
+  if ((mutex->mutex_type & LOCK_PRIO_INHERIT) == 0)
+    {
+      int result = __mutex_lock_fast (mutex, true);
+      if(result >= 0)
+        return result;
+    }
+  else
+    {
+      /* Except when we already hold a recursive lock.  */
+      if ((mutex->mutex_type & LOCK_RECURSIVE) &&
+           mutex->mutex_lockbyte == LOCKBYTE_SET &&
+         ((mutex->mutex_type & LOCK_SHARED) == 0 ||
+           mutex->mutex_ownerpid == THREAD_GETMEM (THREAD_SELF, pid)) &&
+           mutex->mutex_owner == (uintptr_t)THREAD_SELF &&
+           mutex->mutex_rcount > 0)
+        {
+          if (mutex->mutex_rcount == RECURSION_MAX)
+            return EAGAIN;
+          ++mutex->mutex_rcount;
+          return 0;
+        }
+    }
+
+  int errval = INLINE_SYSCALL (lwp_mutex_trylock, 1, mutex);
+
+  /* The kernel sets EDEADLK for priority inherit mutexes.  */
+  if (mutex->mutex_type & LOCK_PRIO_INHERIT && errval == EDEADLK)
+    return EBUSY;
+  if (errval != 0 && errval != EOWNERDEAD)
+    return errval;
+
+  /* The kernel does not set mutex_owner so we set it here.  */
+  if (mutex->mutex_type & (LOCK_RECURSIVE | LOCK_ERRORCHECK))
+    mutex->mutex_owner = (uintptr_t)THREAD_SELF;
+
+  /* The kernel does not set the lockbyte for priority inherit mutexes.  */
+  if (mutex->mutex_type & LOCK_PRIO_INHERIT)
+    mutex->mutex_lockbyte = 1;
+
+  return errval;
+}
diff --git a/nptl/sysdeps/unix/sysv/solaris2/opensolaris-gnu/mutex_unlock.c b/nptl/sysdeps/unix/sysv/solaris2/opensolaris-gnu/mutex_unlock.c
new file mode 100644 (file)
index 0000000..f2cd306
--- /dev/null
@@ -0,0 +1,74 @@
+/* Copyright (C) 2008 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+   Contributed by David Bartley <dtbartle@csclub.uwaterloo.ca>, 2008.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, write to the Free
+   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+   02111-1307 USA.  */
+
+#include <inline-syscall.h>
+#include <pthreadP.h>
+#include <synch.h>
+#include <errno.h>
+#include <synch_priv.h>
+
+DECLARE_INLINE_SYSCALL (int, lwp_mutex_unlock, mutex_t *lp);
+
+int __mutex_unlock_fast (mutex_t *mutex);
+
+
+int mutex_unlock (mutex)
+      mutex_t *mutex;
+{
+  /* Handle inconsistent robust mutexes.  */
+  if ((mutex->mutex_type & LOCK_ROBUST) &&
+       (mutex->mutex_flag & LOCK_NOTRECOVERABLE))
+    return ENOTRECOVERABLE;
+
+  /* Always hit the kernel for priority inherit locks.  */
+  if ((mutex->mutex_type & LOCK_PRIO_INHERIT) == 0)
+    {
+      int result = __mutex_unlock_fast (mutex);
+      if(result >= 0)
+        return result;
+    }
+  else
+    {
+      /* Except when we already hold a recursive lock.  */
+      if ((mutex->mutex_type & LOCK_RECURSIVE) &&
+           mutex->mutex_lockbyte == LOCKBYTE_SET &&
+         ((mutex->mutex_type & LOCK_SHARED) == 0 ||
+           mutex->mutex_ownerpid == THREAD_GETMEM (THREAD_SELF, pid)) &&
+           mutex->mutex_owner == (uintptr_t)THREAD_SELF &&
+           mutex->mutex_rcount > 0)
+        {
+          --mutex->mutex_rcount;
+          return 0;
+        }
+    }
+
+  int errval = INLINE_SYSCALL(lwp_mutex_unlock, 1, mutex);
+  if (errval != 0)
+    return errval;
+
+  /* The kernel does not clear the lockbyte for priority inherit mutexes.  */
+  if (mutex->mutex_type & LOCK_PRIO_INHERIT)
+    mutex->mutex_lockbyte = 0;
+
+  /* The kernel does not clear mutex_owner so we clear it here.  */
+  if (mutex->mutex_type & (LOCK_RECURSIVE | LOCK_ERRORCHECK))
+    mutex->mutex_owner = 0;
+
+  return errval;
+}
index c3e60b7..41488cf 100644 (file)
@@ -53,6 +53,7 @@
 #include <errno.h>
 #include <inline-syscall.h>
 #include <synch_priv.h>
+#include <synch.h>
 
 DECLARE_INLINE_SYSCALL (pthread_t, lwp_self, void);
 DECLARE_INLINE_SYSCALL (int, lwp_kill, pthread_t lwpid, int sig);
@@ -124,7 +125,9 @@ static inline int __cond_has_waiters (pthread_cond_t *cond)
 {
   return cond->cond_waiters_kernel;
 }
-extern int __pthread_cond_timedwait_internal (pthread_cond_t *cond,
-    pthread_mutex_t *mutex, const struct timespec *abstime, int cancel);
+extern int __cond_reltimedwait_internal (cond_t *cond, mutex_t *mutex,
+    struct timespec *reltime, int cancel);
+
+extern int __mutex_timedlock (mutex_t *mutex, const struct timespec *abstime);
 
 #endif /* _OPENSOLARIS_PTHREADP_H */
index b1ec699..568df52 100644 (file)
@@ -38,11 +38,6 @@ pthread_barrier_wait (barrier)
 
   /* A thread entered the barrier.  */
   --ibarrier->left;
-#if 0
-char buf[100];
-sprintf(buf, "%d: pthread_barrier_wait (%p): FOO 1: %d\n", pthread_self (), ibarrier, ibarrier->left);
-write (2, buf, strlen (buf));
-#endif
 
   if (ibarrier->left == 0)
     {
@@ -67,8 +62,8 @@ write (2, buf, strlen (buf));
   int curr_event = ibarrier->curr_event;
   do
     {
-      errval = __pthread_cond_timedwait_internal (&ibarrier->cond,
-          &ibarrier->mutex, NULL, 0);
+      errval = __cond_reltimedwait_internal ((cond_t *)&ibarrier->cond,
+          (mutex_t *)&ibarrier->mutex, NULL, 0);
       if (errval != 0)
         return errval;
     }
index c0afb39..62ffe09 100644 (file)
    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
    02111-1307 USA.  */
 
-#include <errno.h>
-#include <sysdep.h>
-#include <pthread.h>
 #include <pthreadP.h>
-
+#include <synch.h>
 #include <shlib-compat.h>
-#include <inline-syscall.h>
-#include <synch_priv.h>
-#include <stdio.h>
-
-DECLARE_INLINE_SYSCALL (int, lwp_cond_broadcast, pthread_cond_t *cv);
 
 
 int
 __pthread_cond_broadcast (cond)
      pthread_cond_t *cond;
 {
-  /* Don't bother entering the kernel if there are no waiters.  */
-  if (cond->cond_waiters_kernel == 0)
-    return 0;
-
-  return INLINE_SYSCALL (lwp_cond_broadcast, 1, cond);
+  return cond_broadcast ((cond_t *)cond);
 }
 
 versioned_symbol (libpthread, __pthread_cond_broadcast, pthread_cond_broadcast,
index c3c637f..00bd75e 100644 (file)
@@ -29,10 +29,10 @@ int
 __pthread_cond_destroy (cond)
      pthread_cond_t *cond;
 {
-  memset(cond, 0, sizeof(pthread_cond_t));
+  // TODO: make sure we're done with cond (EBUSY)
 
+  cond->cond_magic = -1;
   return 0;
 }
 versioned_symbol (libpthread, __pthread_cond_destroy,
                  pthread_cond_destroy, GLIBC_2_3_2);
-weak_alias (__pthread_cond_destroy, cond_destroy);
index 1e77243..2a43abe 100644 (file)
@@ -22,7 +22,7 @@
 
 
 #include <shlib-compat.h>
-#include "pthreadP.h"
+#include <pthreadP.h>
 #include <string.h>
 #include <sys/synch.h>
 #include <synch_priv.h>
index a32f56d..d5731d8 100644 (file)
    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
    02111-1307 USA.  */
 
-#include <endian.h>
-#include <errno.h>
-#include <sysdep.h>
-#include <pthread.h>
 #include <pthreadP.h>
-
+#include <synch.h>
 #include <shlib-compat.h>
-#include <inline-syscall.h>
-#include <synch_priv.h>
-
-DECLARE_INLINE_SYSCALL (int, lwp_cond_signal, pthread_cond_t *cv);
 
 
 int
 __pthread_cond_signal (cond)
      pthread_cond_t *cond;
 {
-  /* Don't bother entering the kernel if there are no waiters.  */
-  if (cond->cond_waiters_kernel == 0)
-    return 0;
-
-  return INLINE_SYSCALL (lwp_cond_signal, 1, cond);
+  return cond_signal ((cond_t *)cond);
 }
 
 versioned_symbol (libpthread, __pthread_cond_signal, pthread_cond_signal,
index 51b9617..19c18d5 100644 (file)
    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
    02111-1307 USA.  */
 
-#include <endian.h>
-#include <errno.h>
-#include <sysdep.h>
-#include <pthread.h>
 #include <pthreadP.h>
-
+#include <synch.h>
 #include <shlib-compat.h>
-#include <inline-syscall.h>
 #include <abstime-to-reltime.h>
-#include <sys/synch.h>
-#include <synch_priv.h>
-
-DECLARE_INLINE_SYSCALL (int, lwp_cond_wait, pthread_cond_t *cv,
-    pthread_mutex_t *mp, struct timespec *tsp, int check_park);
-
-struct _condvar_cleanup_buffer
-{
-  int oldtype;
-  pthread_cond_t *cond;
-  pthread_mutex_t *mutex;
-  int old_cond_waiters;
-  int old_mutex_rcount;
-};
-
-void
-__attribute__ ((visibility ("hidden")))
-__condvar_cleanup (void *arg)
-{
-  struct _condvar_cleanup_buffer *cbuffer =
-    (struct _condvar_cleanup_buffer *) arg;
-  pthread_mutex_t *mutex = cbuffer->mutex;
-
-  /* Note: we don't whether the mutex was unlocked by the kernel or not.  */
-
-  /* The condition variable is no longer using the mutex.  */
-  mutex->mutex_cond_waiters = cbuffer->old_cond_waiters;
-
-  int errval = 0;
-  while (1)
-    {
-      if (mutex->mutex_lockbyte == LOCKBYTE_SET &&
-        ((mutex->mutex_type & LOCK_SHARED) == 0 ||
-          mutex->mutex_ownerpid == THREAD_GETMEM (THREAD_SELF, pid)) &&
-         (mutex->mutex_owner == (uintptr_t)THREAD_SELF))
-        {
-          /* The lock is held by us (we didn't get signaled).  */
-          break;
-        }
-      else if (mutex->mutex_lockbyte == 0)
-        {
-          /* The mutex is unlocked.  */
-          errval = pthread_mutex_lock (mutex);
-          break;
-        }
-    }
-
-  /* Restore the mutex_rcount.  */
-  if (errval == 0)
-    mutex->mutex_rcount = cbuffer->old_mutex_rcount;
-}
-
 
 int
-__pthread_cond_timedwait_internal (cond, mutex, abstime, cancel)
+__pthread_cond_timedwait (cond, mutex, abstime)
      pthread_cond_t *cond;
      pthread_mutex_t *mutex;
      const struct timespec *abstime;
-     int cancel;
 {
-  struct _pthread_cleanup_buffer buffer;
-  struct _condvar_cleanup_buffer cbuffer;
-
   /* Reject invalid timeouts.  */
   if (abstime && (abstime->tv_nsec < 0 || abstime->tv_nsec >= 1000000000))
     return EINVAL;
 
-  if ((mutex->mutex_type & LOCK_ERRORCHECK) &&
-     ((mutex->mutex_lockbyte != LOCKBYTE_SET ||
-       mutex->mutex_owner != (uintptr_t)THREAD_SELF ||
-     ((mutex->mutex_type & LOCK_SHARED) &&
-       mutex->mutex_ownerpid != THREAD_GETMEM (THREAD_SELF, pid)))))
-    {
-      /* Error checking: lock not held by this thread.  */
-      return EPERM;
-    }
-  else if ((mutex->mutex_type & LOCK_RECURSIVE) &&
-            mutex->mutex_lockbyte == LOCKBYTE_SET &&
-          ((mutex->mutex_type & LOCK_SHARED) == 0 ||
-            mutex->mutex_ownerpid == THREAD_GETMEM (THREAD_SELF, pid)) &&
-            mutex->mutex_owner == (uintptr_t)THREAD_SELF &&
-            mutex->mutex_rcount > 0)
-    {
-      /* Recursively held lock. XXX: Using recursive mutexes with condition
-         variables is undefined; we do what sun's libc does, namely fully
-          release the lock.  */
-      cbuffer.old_mutex_rcount = mutex->mutex_rcount;
-      mutex->mutex_rcount = 0;
-    }
-
-  /* Mark the mutex as still in use.  */
-  cbuffer.old_cond_waiters = mutex->mutex_cond_waiters;
-  if (cbuffer.old_cond_waiters == 0)
-    mutex->mutex_cond_waiters = 1;
-
-  /* Prepare structure passed to cancellation handler.  */
-  cbuffer.cond = cond;
-  cbuffer.mutex = mutex;
-
-  if (cancel)
-    {
-      /* Before we block we enable cancellation.  Therefore we have to
-         install a cancellation handler.  */
-      __pthread_cleanup_push (&buffer, __condvar_cleanup, &cbuffer);
-
-      /* Enable asynchronous cancellation.  Required by the standard.  */
-      cbuffer.oldtype = __pthread_enable_asynccancel ();
-    }
-
   struct timespec _reltime;
   struct timespec *reltime = abstime_to_reltime (abstime, &_reltime);
-  if (reltime && reltime->tv_sec < 0)
-    return ETIMEDOUT;
-  int errval = INLINE_SYSCALL (lwp_cond_wait, 4, cond, mutex, reltime, 1);
+  int errval = cond_reltimedwait ((cond_t *)cond, (mutex_t *)mutex, reltime);
   if (errval == ETIME)
-    errval = ETIMEDOUT;
-  /* The docs say to return 0 when interrupted.  */
-  else if (errval == EINTR)
-    errval = 0;
-
-  if (cancel)
-    {
-      /* Disable asynchronous cancellation.  */
-      __pthread_disable_asynccancel (cbuffer.oldtype);
-
-      /* The cancellation handling is back to normal, remove the handler.  */
-      __pthread_cleanup_pop (&buffer, 0);
-    }
-
-  /* Re-acquire the lock. The docs say we must always re-acquire so we don't
-     use pthread_mutex_timedlock. Note that even if the above wait fails the
-     kernel always unlocks the mutex.  */
-  int errval2 = pthread_mutex_lock (mutex);
-  if (errval2 == EINTR)
-    return 0;
-  else if (errval2 != 0)
-    return EINVAL;
-
-  /* Restore the mutex_rcount.  */
-  if (mutex->mutex_type & LOCK_RECURSIVE)
-    mutex->mutex_rcount = cbuffer.old_mutex_rcount;
-
-  /* The condition variable is no longer using the mutex.  */
-  if (cbuffer.old_cond_waiters == 0)
-    mutex->mutex_cond_waiters = 0;
-
+    return ETIMEDOUT;
   return errval;
 }
 
-
-int
-__pthread_cond_timedwait (cond, mutex, abstime)
-     pthread_cond_t *cond;
-     pthread_mutex_t *mutex;
-     const struct timespec *abstime;
-{
-  return __pthread_cond_timedwait_internal (cond, mutex, abstime, 1);
-}
-
 versioned_symbol (libpthread, __pthread_cond_timedwait, pthread_cond_timedwait,
                  GLIBC_2_3_2);
index 30fcdaf..1234bf1 100644 (file)
    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
    02111-1307 USA.  */
 
-#include <endian.h>
-#include <errno.h>
-#include <sysdep.h>
-#include <pthread.h>
 #include <pthreadP.h>
-
+#include <synch.h>
 #include <shlib-compat.h>
-#include <stddef.h>
 
 
 int
@@ -34,7 +29,10 @@ __pthread_cond_wait (cond, mutex)
      pthread_cond_t *cond;
      pthread_mutex_t *mutex;
 {
-  return pthread_cond_timedwait (cond, mutex, NULL);
+  int errval = cond_reltimedwait ((cond_t *)cond, (mutex_t *)mutex, NULL);
+  if (errval == ETIME)
+    return ETIMEDOUT;
+  return errval;
 }
 
 versioned_symbol (libpthread, __pthread_cond_wait, pthread_cond_wait,
index dcdfeb4..351ffbb 100644 (file)
 
 #include <errno.h>
 #include <pthreadP.h>
+#include <synch.h>
 
 
 int
 pthread_mutex_consistent_np (mutex)
      pthread_mutex_t *mutex;
 {
-  if ((mutex->mutex_type & LOCK_ROBUST) == 0 ||
-      (mutex->mutex_flag & LOCK_INITED) == 0 ||
-      (mutex->mutex_flag & (LOCK_OWNERDEAD | LOCK_UNMAPPED) == 0))
-    return EINVAL;
-
-  mutex->mutex_flag &= ~(LOCK_OWNERDEAD | LOCK_UNMAPPED);
-  mutex->mutex_lockword64 = 0;
-
-  return 0;
+  return mutex_consistent ((mutex_t *)mutex);
 }
-weak_alias (pthread_mutex_consistent_np, mutex_consistent)
index dad6eb3..6ca847b 100644 (file)
@@ -29,14 +29,15 @@ __pthread_mutex_destroy (mutex)
      pthread_mutex_t *mutex;
 {
   if (mutex->mutex_lockbyte != LOCKBYTE_UNSET ||
-        mutex->mutex_cond_waiters != 0)
+      mutex->mutex_cond_waiters != 0)
     return EBUSY;
 
-  /* Set magic to an invalid value.  */
-  mutex->mutex_magic = -1;
+  if (mutex->mutex_type & LOCK_ROBUST)
+    memset (mutex, 0, sizeof(mutex_t));
+  else
+    mutex->mutex_magic = -1;
 
   return 0;
 }
 strong_alias (__pthread_mutex_destroy, pthread_mutex_destroy)
 INTDEF(__pthread_mutex_destroy)
-weak_alias (__pthread_mutex_destroy, mutex_destroy)
index bd14a28..361702c 100644 (file)
@@ -27,8 +27,6 @@
 #include <sys/synch.h>
 #include <synch_priv.h>
 
-DECLARE_INLINE_SYSCALL (int, lwp_mutex_register, pthread_mutex_t *lp);
-
 static const struct pthread_mutexattr default_attr =
   {
     /* Default is a normal mutex, not shared between processes.  */
@@ -45,33 +43,10 @@ __pthread_mutex_init (mutex, mutexattr)
 
   imutexattr = (const struct pthread_mutexattr *) mutexattr ?: &default_attr;
 
-  if (imutexattr->mutexkind & LOCK_ROBUST)
-    {
-write (2, "MAGIC 1\n", 9);
-      if ((mutex->mutex_type & LOCK_INITED))
-        return EBUSY;
-    }
-  else
-    {
-      memset (mutex, 0, sizeof(pthread_mutex_t));
-    }
-  mutex->mutex_type = imutexattr->mutexkind;
-  mutex->mutex_flag = LOCK_INITED;
-  mutex->mutex_magic = MUTEX_MAGIC;
-  mutex->mutex_ceiling = imutexattr->ceiling;
-  mutex->mutex_cond_waiters = 0;
-
-  /* Register robust shared lock.  */
-  if ((imutexattr->mutexkind & (LOCK_ROBUST | LOCK_SHARED)) ==
-        (LOCK_ROBUST | LOCK_SHARED))
-    {
-write (2, "MAGIC 2\n", 9);
-      int errval = INLINE_SYSCALL (lwp_mutex_register, 1, mutex);
-      if (errval != 0)
-        return errval;
-    }
+  int ceiling = (imutexattr->mutexkind & PTHREAD_MUTEXATTR_PRIO_CEILING_MASK)
+      >> PTHREAD_MUTEXATTR_PRIO_CEILING_SHIFT;
 
-  return 0;
+  return mutex_init ((mutex_t *)mutex, imutexattr->mutexkind, (void *)ceiling);
 }
 strong_alias (__pthread_mutex_init, pthread_mutex_init)
 INTDEF(__pthread_mutex_init)
index b4e23c3..849b81d 100644 (file)
    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
    02111-1307 USA.  */
 
-#include <assert.h>
-#include <errno.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <not-cancel.h>
 #include <pthreadP.h>
+#include <synch.h>
 
 
 int
 __pthread_mutex_lock (mutex)
      pthread_mutex_t *mutex;
 {
-  return pthread_mutex_timedlock (mutex, NULL);
+  int errval = __mutex_timedlock ((mutex_t *)mutex, NULL);
+  if (errval == ETIME)
+    return ETIMEDOUT;
+  return errval;
 }
 #ifndef __pthread_mutex_lock
 strong_alias (__pthread_mutex_lock, pthread_mutex_lock)
 strong_alias (__pthread_mutex_lock, __pthread_mutex_lock_internal)
 #endif
-weak_alias (__pthread_mutex_lock, mutex_lock)
index 6dda3d0..afcfd8d 100644 (file)
    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
    02111-1307 USA.  */
 
-#include <assert.h>
-#include <errno.h>
-#include <time.h>
 #include <pthreadP.h>
-#include <not-cancel.h>
-#include <inline-syscall.h>
-#include <stdbool.h>
-#include <abstime-to-reltime.h>
-#include <stdio.h>
-
-#include <unistd.h>
-#include <string.h>
-#include <sys/synch.h>
-#include <synch_priv.h>
-
-DECLARE_INLINE_SYSCALL (int, lwp_mutex_timedlock, pthread_mutex_t *lp,
-    struct timespec *tsp);
-
-extern int __mutex_lock_fast(pthread_mutex_t *mutex, bool try);
+#include <synch.h>
 
 int
 pthread_mutex_timedlock (mutex, abstime)
      pthread_mutex_t *mutex;
      const struct timespec *abstime;
 {
-  /* Handle inconsistent robust mutexes.  */
-  if ((mutex->mutex_type & LOCK_ROBUST) &&
-      (mutex->mutex_flag & LOCK_NOTRECOVERABLE))
-    return ENOTRECOVERABLE;
-
-  /* Reject invalid timeouts.  */
-  if (abstime && (abstime->tv_nsec < 0 || abstime->tv_nsec >= 1000000000))
-    return EINVAL;
-
-  /* Always hit the kernel for priority inherit locks.  */
-  if ((mutex->mutex_type & LOCK_PRIO_INHERIT) == 0)
-    {
-      int res = __mutex_lock_fast (mutex, false);
-      if(res >= 0)
-        return res;
-    }
-  else
-    {
-      /* Except when we already hold a recursive lock.  */
-      if ((mutex->mutex_type & LOCK_RECURSIVE) &&
-           mutex->mutex_lockbyte == LOCKBYTE_SET &&
-         ((mutex->mutex_type & LOCK_SHARED) == 0 ||
-           mutex->mutex_ownerpid == THREAD_GETMEM (THREAD_SELF, pid)) &&
-           mutex->mutex_owner == (uintptr_t)THREAD_SELF)
-        {
-          if (mutex->mutex_rcount == RECURSION_MAX)
-            return EAGAIN;
-          ++mutex->mutex_rcount;
-          return 0;
-        }
-    }
-
-  struct timespec _reltime;
-  struct timespec *reltime = abstime_to_reltime (abstime, &_reltime);
-  if (reltime && reltime->tv_sec < 0)
-    return ETIMEDOUT;
-  int errval = INLINE_SYSCALL (lwp_mutex_timedlock, 2, mutex, reltime);
+  int errval = __mutex_timedlock ((mutex_t *)mutex, abstime);
   if (errval == ETIME)
-    errval = ETIMEDOUT;
-  if (errval != 0 && errval != EOWNERDEAD)
-    {
-      /* The kernel sets EDEADLK for priority inherit mutexes.  */
-      if ((mutex->mutex_type & LOCK_PRIO_INHERIT) &&
-            (mutex->mutex_type & LOCK_ERRORCHECK) == 0 &&
-            errval == EDEADLK)
-        {
-          /* We aren't an error checking mutex so we need to block.  */
-          INTERNAL_SYSCALL_DECL (err);
-          if (abstime)
-            {
-              int result = INTERNAL_SYSCALL (nanosleep, err, 2, reltime, NULL);
-              errval = INTERNAL_SYSCALL_ERRNO (result, err) ? EINTR: ETIMEDOUT;
-            }
-          else
-            {
-              INTERNAL_SYSCALL (pause, err, 1, 0);
-              errval = EINTR;
-            }
-        }
-      return errval;
-    }
-
-  /* The kernel does not set mutex_owner so we set it here.  */
-  if (mutex->mutex_type & (LOCK_RECURSIVE | LOCK_ERRORCHECK))
-    mutex->mutex_owner = (uintptr_t)THREAD_SELF;
-
-  /* The kernel does not set the lockbyte for priority inherit mutexes.  */
-  if (mutex->mutex_type & LOCK_PRIO_INHERIT)
-    mutex->mutex_lockbyte = 1;
-
+    return ETIMEDOUT;
   return errval;
 }
index 09a94e4..8213127 100644 (file)
    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
    02111-1307 USA.  */
 
-#include <assert.h>
-#include <errno.h>
-#include <stdlib.h>
 #include <pthreadP.h>
-#include <inline-syscall.h>
-#include <stdbool.h>
-
-#include <synch_priv.h>
-#include <sys/synch.h>
-
-DECLARE_INLINE_SYSCALL (int, lwp_mutex_trylock, pthread_mutex_t *lp);
-
-extern int __mutex_lock_fast(pthread_mutex_t *mutex, bool try);
+#include <synch.h>
 
 int
 __pthread_mutex_trylock (mutex)
      pthread_mutex_t *mutex;
 {
-  /* Handle inconsistent robust mutexes.  */
-  if ((mutex->mutex_type & LOCK_ROBUST) &&
-      (mutex->mutex_flag & LOCK_NOTRECOVERABLE))
-    return ENOTRECOVERABLE;
-
-  /* Always hit the kernel for priority inherit locks.  */
-  if ((mutex->mutex_type & LOCK_PRIO_INHERIT) == 0)
-    {
-      int result = __mutex_lock_fast (mutex, true);
-      if(result >= 0)
-        return result;
-    }
-  else
-    {
-      /* Except when we already hold a recursive lock.  */
-      if ((mutex->mutex_type & LOCK_RECURSIVE) &&
-           mutex->mutex_lockbyte == LOCKBYTE_SET &&
-         ((mutex->mutex_type & LOCK_SHARED) == 0 ||
-           mutex->mutex_ownerpid == THREAD_GETMEM (THREAD_SELF, pid)) &&
-           mutex->mutex_owner == (uintptr_t)THREAD_SELF &&
-           mutex->mutex_rcount > 0)
-        {
-          if (mutex->mutex_rcount == RECURSION_MAX)
-            return EAGAIN;
-          ++mutex->mutex_rcount;
-          return 0;
-        }
-    }
-
-  int errval = INLINE_SYSCALL (lwp_mutex_trylock, 1, mutex);
-  if (errval != 0 && errval != EOWNERDEAD)
-    {
-      /* The kernel sets EDEADLK for priority inherit mutexes.  */
-      if ((mutex->mutex_type & LOCK_PRIO_INHERIT) &&
-            (mutex->mutex_type & LOCK_ERRORCHECK) == 0 && errval == EDEADLK)
-        errval = EBUSY;
-      return errval;
-    }
-
-  /* The kernel does not set mutex_owner so we set it here.  */
-  if (mutex->mutex_type & (LOCK_RECURSIVE | LOCK_ERRORCHECK))
-    mutex->mutex_owner = (uintptr_t)THREAD_SELF;
-
-  /* The kernel does not set the lockbyte for priority inherit mutexes.  */
-  if (mutex->mutex_type & LOCK_PRIO_INHERIT)
-    mutex->mutex_lockbyte = 1;
-
-  return errval;
+  return mutex_trylock ((mutex_t *)mutex);
 }
 strong_alias (__pthread_mutex_trylock, pthread_mutex_trylock)
-weak_alias (__pthread_mutex_trylock, mutex_trylock)
index 7855d5c..4d0fe07 100644 (file)
    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
    02111-1307 USA.  */
 
-#include <errno.h>
-#include <stdlib.h>
 #include <pthreadP.h>
-#include <inline-syscall.h>
-
-#include <string.h>
-#include <sys/synch.h>
-#include <synch_priv.h>
-#include <assert.h>
-
-DECLARE_INLINE_SYSCALL (int, lwp_mutex_unlock, pthread_mutex_t *lp);
-
-int __mutex_unlock_fast(pthread_mutex_t *mutex);
-
-int
-internal_function attribute_hidden
-__pthread_mutex_unlock_usercnt (mutex, decr)
-     pthread_mutex_t *mutex;
-     int decr;
-{
-  /* Handle inconsistent robust mutexes.  */
-  if (mutex->mutex_type & LOCK_ROBUST)
-    {
-      if (mutex->mutex_flag & LOCK_NOTRECOVERABLE)
-        {
-          return ENOTRECOVERABLE;
-        }
-      else if (mutex->mutex_flag & (LOCK_OWNERDEAD | LOCK_UNMAPPED))
-        {
-          mutex->mutex_flag |= LOCK_NOTRECOVERABLE;
-          return ENOTRECOVERABLE;
-        }
-    }
-
-  /* Always hit the kernel for priority inherit locks.  */
-  if ((mutex->mutex_type & LOCK_PRIO_INHERIT) == 0)
-    {
-      int result = __mutex_unlock_fast (mutex);
-      if(result >= 0)
-        return result;
-    }
-  else
-    {
-      /* Except when we already hold a recursive lock.  */
-      if ((mutex->mutex_type & LOCK_RECURSIVE) &&
-           mutex->mutex_lockbyte == LOCKBYTE_SET &&
-         ((mutex->mutex_type & LOCK_SHARED) == 0 ||
-           mutex->mutex_ownerpid == THREAD_GETMEM (THREAD_SELF, pid)) &&
-           mutex->mutex_owner == (uintptr_t)THREAD_SELF &&
-           mutex->mutex_rcount > 0)
-        {
-          --mutex->mutex_rcount;
-          return 0;
-        }
-    }
-
-  int errval = INLINE_SYSCALL(lwp_mutex_unlock, 1, mutex);
-  if (errval != 0)
-    return errval;
-
-  /* The kernel does not clear the lockbyte for priority inherit mutexes.  */
-  if (mutex->mutex_type & LOCK_PRIO_INHERIT)
-    mutex->mutex_lockbyte = 0;
-
-  /* The kernel does not clear mutex_owner so we clear it here.  */
-  if (mutex->mutex_type & (LOCK_RECURSIVE | LOCK_ERRORCHECK))
-    mutex->mutex_owner = 0;
-
-  return errval;
-}
-
+#include <synch.h>
 
 int
 __pthread_mutex_unlock (mutex)
      pthread_mutex_t *mutex;
 {
-  return __pthread_mutex_unlock_usercnt (mutex, 1);
+  return mutex_unlock ((mutex_t *)mutex);
 }
 strong_alias (__pthread_mutex_unlock, pthread_mutex_unlock)
 strong_alias (__pthread_mutex_unlock, __pthread_mutex_unlock_internal)
-weak_alias (__pthread_mutex_unlock, mutex_unlock)
index 87c7efe..bf05991 100644 (file)
@@ -35,4 +35,3 @@ __pthread_rwlock_destroy (rwlock)
   return 0;
 }
 strong_alias (__pthread_rwlock_destroy, pthread_rwlock_destroy)
-weak_alias (__pthread_rwlock_destroy, rwlock_destroy)
index 9f836e5..9d95f96 100644 (file)
@@ -36,4 +36,3 @@ __pthread_rwlock_rdlock (rwlock)
 
 weak_alias (__pthread_rwlock_rdlock, pthread_rwlock_rdlock)
 strong_alias (__pthread_rwlock_rdlock, __pthread_rwlock_rdlock_internal)
-weak_alias (__pthread_rwlock_rdlock, rw_rdlock)
index 47f71d0..5c753ab 100644 (file)
@@ -28,6 +28,7 @@
 #include <stdio.h>
 #include <atomic.h>
 #include <sys/synch.h>
+#include <abstime-to-reltime.h>
 
 
 /* Try to acquire read lock for RWLOCK or return after specfied time.  */
@@ -40,6 +41,9 @@ pthread_rwlock_timedrdlock (rwlock, abstime)
   if (abstime && (abstime->tv_nsec < 0 || abstime->tv_nsec >= 1000000000))
     return EINVAL;
 
+  struct timespec _reltime;
+  struct timespec *reltime = abstime_to_reltime (abstime, &_reltime);
+
   int errval = pthread_mutex_lock (&rwlock->mutex);
   if (errval != 0)
     return errval;
@@ -55,8 +59,8 @@ pthread_rwlock_timedrdlock (rwlock, abstime)
         __cond_has_waiters (&rwlock->writercv))
     {
       /* Wait for writer to wake us up.  */
-      errval = __pthread_cond_timedwait_internal (&rwlock->readercv,
-          &rwlock->mutex, abstime, 0);
+      errval = __cond_reltimedwait_internal ((cond_t *)&rwlock->readercv,
+          (mutex_t *)&rwlock->mutex, reltime, 0);
       if (errval != 0)
         return pthread_mutex_unlock (&rwlock->mutex) ?: errval;
     }
index 3a2e816..947cc08 100644 (file)
@@ -26,6 +26,8 @@
 #include <inline-syscall.h>
 #include <stddef.h>
 #include <sys/synch.h>
+#include <abstime-to-reltime.h>
+
 
 /* Try to acquire write lock for RWLOCK or return after specfied time. */
 int
@@ -37,6 +39,9 @@ pthread_rwlock_timedwrlock (rwlock, abstime)
   if (abstime && (abstime->tv_nsec < 0 || abstime->tv_nsec >= 1000000000))
     return EINVAL;
 
+  struct timespec _reltime;
+  struct timespec *reltime = abstime_to_reltime (abstime, &_reltime);
+
   int errval = pthread_mutex_lock (&rwlock->mutex);
   if (errval != 0)
     return errval;
@@ -50,8 +55,8 @@ pthread_rwlock_timedwrlock (rwlock, abstime)
   /* Wait until we can acquire the write lock.  */
   while (rwlock->readers & (_RWLOCK_RD_MASK | _RWLOCK_WR_LOCK))
     {
-      errval = __pthread_cond_timedwait_internal (&rwlock->writercv,
-          &rwlock->mutex, abstime, 0);
+      errval = __cond_reltimedwait_internal ((cond_t *)&rwlock->writercv,
+          (mutex_t *)&rwlock->mutex, reltime, 0);
       if (errval != 0)
         return pthread_mutex_unlock (&rwlock->mutex) ?: errval;
     }
index 0c90eef..8be0ca5 100644 (file)
@@ -45,4 +45,3 @@ __pthread_rwlock_tryrdlock (rwlock)
   return pthread_mutex_unlock (&rwlock->mutex);
 }
 strong_alias (__pthread_rwlock_tryrdlock, pthread_rwlock_tryrdlock)
-weak_alias (__pthread_rwlock_tryrdlock, rw_tryrdlock)
index 7f57e50..ca437fa 100644 (file)
@@ -46,4 +46,3 @@ __pthread_rwlock_trywrlock (rwlock)
   return pthread_mutex_unlock (&rwlock->mutex);
 }
 strong_alias (__pthread_rwlock_trywrlock, pthread_rwlock_trywrlock)
-weak_alias (__pthread_rwlock_trywrlock, rw_trywrlock)
index 2d91d29..ddff5a5 100644 (file)
@@ -67,4 +67,3 @@ __pthread_rwlock_unlock (pthread_rwlock_t *rwlock)
 
 weak_alias (__pthread_rwlock_unlock, pthread_rwlock_unlock)
 strong_alias (__pthread_rwlock_unlock, __pthread_rwlock_unlock_internal)
-weak_alias (__pthread_rwlock_unlock, rw_unlock)
index a3efe4c..226cbe4 100644 (file)
@@ -37,4 +37,3 @@ __pthread_rwlock_wrlock (rwlock)
 
 weak_alias (__pthread_rwlock_wrlock, pthread_rwlock_wrlock)
 strong_alias (__pthread_rwlock_wrlock, __pthread_rwlock_wrlock_internal)
-weak_alias (__pthread_rwlock_wrlock, rw_wrlock)
index 389a279..498293e 100644 (file)
@@ -21,6 +21,7 @@
 #define _SYNCH_H
 
 #include <sys/synch.h>
+#include <features.h>
 
 typedef lwp_mutex_t mutex_t;
 
@@ -40,9 +41,9 @@ int   cond_destroy(cond_t *);
 
 int    cond_wait(cond_t *, mutex_t *);
 
-int    cond_timedwait(cond_t *, mutex_t *, const struct timespec *);
+int    cond_timedwait(cond_t *, mutex_t *, struct timespec *);
 
-int    cond_reltimedwait(cond_t *, mutex_t *, const struct timespec *);
+int    cond_reltimedwait(cond_t *, mutex_t *, struct timespec *);
 
 int    cond_signal(cond_t *);
 
@@ -86,7 +87,7 @@ int   sema_destroy(sema_t *);
 
 int    sema_wait(sema_t *);
 
-int    sema_timedwait(sema_t *, const struct timespec *);
+int    sema_timedwait(sema_t *, struct timespec *);
 
 int    sema_reltimedwait(sema_t *, const struct timespec *);