1 files changed, 34 insertions, 205 deletions

diff --git a/libpthread/linuxthreads/rwlock.c b/libpthread/linuxthreads/rwlock.c
index 4a0fb1bba..977fd88af 100644
--- a/libpthread/linuxthreads/rwlock.c
+++ b/libpthread/linuxthreads/rwlock.c
@@ -1,20 +1,20 @@
 /* Read-write lock implementation.
-   Copyright (C) 1998, 2000 Free Software Foundation, Inc.
+   Copyright (C) 1998 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by Xavier Leroy <Xavier.Leroy@inria.fr>
    and Ulrich Drepper <drepper@cygnus.com>, 1998.
 
    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
+   modify it under the terms of the GNU Library General Public License as
+   published by the Free Software Foundation; either version 2 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.
+   Library General Public License for more details.
 
-   You should have received a copy of the GNU Lesser General Public
+   You should have received a copy of the GNU Library General Public
    License along with the GNU C Library; see the file COPYING.LIB.  If not,
    write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
    Boston, MA 02111-1307, USA.  */
@@ -27,33 +27,6 @@
 #include "spinlock.h"
 #include "restart.h"
 
-/* Function called by pthread_cancel to remove the thread from
-   waiting inside pthread_rwlock_timedrdlock or pthread_rwlock_timedwrlock. */
-
-static int rwlock_rd_extricate_func(void *obj, pthread_descr th)
-{
-  pthread_rwlock_t *rwlock = obj;
-  int did_remove = 0;
-
-  __pthread_lock(&rwlock->__rw_lock, NULL);
-  did_remove = remove_from_queue(&rwlock->__rw_read_waiting, th);
-  __pthread_unlock(&rwlock->__rw_lock);
-
-  return did_remove;
-}
-
-static int rwlock_wr_extricate_func(void *obj, pthread_descr th)
-{
-  pthread_rwlock_t *rwlock = obj;
-  int did_remove = 0;
-
-  __pthread_lock(&rwlock->__rw_lock, NULL);
-  did_remove = remove_from_queue(&rwlock->__rw_write_waiting, th);
-  __pthread_unlock(&rwlock->__rw_lock);
-
-  return did_remove;
-}
-
 /*
  * Check whether the calling thread already owns one or more read locks on the
  * specified lock. If so, return a pointer to the read lock info structure
@@ -65,8 +38,7 @@ rwlock_is_in_list(pthread_descr self, pthread_rwlock_t *rwlock)
 {
   pthread_readlock_info *info;
 
-  for (info = THREAD_GETMEM (self, p_readlock_list); info != NULL;
-       info = info->pr_next)
+  for (info = self->p_readlock_list; info != NULL; info = info->pr_next)
     {
       if (info->pr_lock == rwlock)
 	return info;
@@ -86,10 +58,10 @@ rwlock_is_in_list(pthread_descr self, pthread_rwlock_t *rwlock)
 static pthread_readlock_info *
 rwlock_add_to_list(pthread_descr self, pthread_rwlock_t *rwlock)
 {
-  pthread_readlock_info *info = THREAD_GETMEM (self, p_readlock_free);
+  pthread_readlock_info *info = self->p_readlock_free;
 
-  if (info != NULL)
-    THREAD_SETMEM (self, p_readlock_free, info->pr_next);
+  if (info != NULL) 
+    self->p_readlock_free = info->pr_next;
   else
     info = malloc(sizeof *info);
 
@@ -98,8 +70,8 @@ rwlock_add_to_list(pthread_descr self, pthread_rwlock_t *rwlock)
 
   info->pr_lock_count = 1;
   info->pr_lock = rwlock;
-  info->pr_next = THREAD_GETMEM (self, p_readlock_list);
-  THREAD_SETMEM (self, p_readlock_list, info);
+  info->pr_next = self->p_readlock_list;
+  self->p_readlock_list = info;
 
   return info;
 }
@@ -128,7 +100,7 @@ rwlock_remove_from_list(pthread_descr self, pthread_rwlock_t *rwlock)
 	  return info;
 	}
     }
-
+  
   return NULL;
 }
 
@@ -165,7 +137,7 @@ rwlock_can_rdlock(pthread_rwlock_t *rwlock, int have_lock_already)
  * This function helps support brain-damaged recursive read locking
  * semantics required by Unix 98, while maintaining write priority.
  * This basically determines whether this thread already holds a read lock
- * already. It returns 1 if so, otherwise it returns 0.
+ * already. It returns 1 if so, otherwise it returns 0.  
  *
  * If the thread has any ``untracked read locks'' then it just assumes
  * that this lock is among them, just to be safe, and returns 1.
@@ -189,12 +161,11 @@ rwlock_have_already(pthread_descr *pself, pthread_rwlock_t *rwlock,
   if (rwlock->__rw_kind == PTHREAD_RWLOCK_PREFER_WRITER_NP)
     {
       if (!self)
-	*pself = self = thread_self();
+	self = thread_self();
 
       existing = rwlock_is_in_list(self, rwlock);
 
-      if (existing != NULL
-	  || THREAD_GETMEM (self, p_untracked_readlock_count) > 0)
+      if (existing != NULL || self->p_untracked_readlock_count > 0)
 	have_lock_already = 1;
       else
 	{
@@ -206,6 +177,7 @@ rwlock_have_already(pthread_descr *pself, pthread_rwlock_t *rwlock,
 
   *pout_of_mem = out_of_mem;
   *pexisting = existing;
+  *pself = self;
 
   return have_lock_already;
 }
@@ -235,7 +207,6 @@ pthread_rwlock_init (pthread_rwlock_t *rwlock,
 }
 
 
-
 int
 pthread_rwlock_destroy (pthread_rwlock_t *rwlock)
 {
@@ -253,7 +224,6 @@ pthread_rwlock_destroy (pthread_rwlock_t *rwlock)
   return 0;
 }
 
-
 int
 pthread_rwlock_rdlock (pthread_rwlock_t *rwlock)
 {
@@ -262,65 +232,13 @@ pthread_rwlock_rdlock (pthread_rwlock_t *rwlock)
   int out_of_mem, have_lock_already;
 
   have_lock_already = rwlock_have_already(&self, rwlock,
-					  &existing, &out_of_mem);
-
-  if (self == NULL)
-    self = thread_self ();
+      &existing, &out_of_mem);
 
   for (;;)
     {
-      __pthread_lock (&rwlock->__rw_lock, self);
-
-      if (rwlock_can_rdlock(rwlock, have_lock_already))
-	break;
-
-      enqueue (&rwlock->__rw_read_waiting, self);
-      __pthread_unlock (&rwlock->__rw_lock);
-      suspend (self); /* This is not a cancellation point */
-    }
-
-  ++rwlock->__rw_readers;
-  __pthread_unlock (&rwlock->__rw_lock);
-
-  if (have_lock_already || out_of_mem)
-    {
-      if (existing != NULL)
-	++existing->pr_lock_count;
-      else
-	++self->p_untracked_readlock_count;
-    }
+      if (self == NULL)
+	self = thread_self ();
 
-  return 0;
-}
-
-
-int
-pthread_rwlock_timedrdlock (pthread_rwlock_t *rwlock,
-			      const struct timespec *abstime)
-{
-  pthread_descr self = NULL;
-  pthread_readlock_info *existing;
-  int out_of_mem, have_lock_already;
-  pthread_extricate_if extr;
-
-  if (abstime->tv_nsec < 0 || abstime->tv_nsec >= 1000000000)
-    return EINVAL;
-
-  have_lock_already = rwlock_have_already(&self, rwlock,
-					  &existing, &out_of_mem);
-
-  if (self == NULL)
-    self = thread_self ();
-
-  /* Set up extrication interface */
-  extr.pu_object = rwlock;
-  extr.pu_extricate_func = rwlock_rd_extricate_func;
-
-  /* Register extrication interface */
-  __pthread_set_own_extricate_if (self, &extr);
-
-  for (;;)
-    {
       __pthread_lock (&rwlock->__rw_lock, self);
 
       if (rwlock_can_rdlock(rwlock, have_lock_already))
@@ -328,43 +246,23 @@ pthread_rwlock_timedrdlock (pthread_rwlock_t *rwlock,
 
       enqueue (&rwlock->__rw_read_waiting, self);
       __pthread_unlock (&rwlock->__rw_lock);
-      /* This is not a cancellation point */
-      if (timedsuspend (self, abstime) == 0)
-	{
-	  int was_on_queue;
-
-	  __pthread_lock (&rwlock->__rw_lock, self);
-	  was_on_queue = remove_from_queue (&rwlock->__rw_read_waiting, self);
-	  __pthread_unlock (&rwlock->__rw_lock);
-
-	  if (was_on_queue)
-	    {
-	      __pthread_set_own_extricate_if (self, 0);
-	      return ETIMEDOUT;
-	    }
-
-	  /* Eat the outstanding restart() from the signaller */
-	  suspend (self);
-	}
+      suspend (self); /* This is not a cancellation point */
     }
 
-  __pthread_set_own_extricate_if (self, 0);
-
   ++rwlock->__rw_readers;
   __pthread_unlock (&rwlock->__rw_lock);
 
   if (have_lock_already || out_of_mem)
     {
       if (existing != NULL)
-	++existing->pr_lock_count;
+	existing->pr_lock_count++;
       else
-	++self->p_untracked_readlock_count;
+	self->p_untracked_readlock_count++;
     }
-
+  
   return 0;
 }
 
-
 int
 pthread_rwlock_tryrdlock (pthread_rwlock_t *rwlock)
 {
@@ -379,7 +277,7 @@ pthread_rwlock_tryrdlock (pthread_rwlock_t *rwlock)
   __pthread_lock (&rwlock->__rw_lock, self);
 
   /* 0 is passed to here instead of have_lock_already.
-     This is to meet Single Unix Spec requirements:
+     This is to meet Single Unix Spec requirements: 
      if writers are waiting, pthread_rwlock_tryrdlock
      does not acquire a read lock, even if the caller has
      one or more read locks already. */
@@ -397,17 +295,16 @@ pthread_rwlock_tryrdlock (pthread_rwlock_t *rwlock)
       if (have_lock_already || out_of_mem)
 	{
 	  if (existing != NULL)
-	    ++existing->pr_lock_count;
+	    existing->pr_lock_count++;
 	  else
-	    ++self->p_untracked_readlock_count;
+	    self->p_untracked_readlock_count++;
 	}
     }
-
+  
   return retval;
 }
 
 
-
 int
 pthread_rwlock_wrlock (pthread_rwlock_t *rwlock)
 {
@@ -431,64 +328,6 @@ pthread_rwlock_wrlock (pthread_rwlock_t *rwlock)
 }
 
 
-
-int
-pthread_rwlock_timedwrlock (pthread_rwlock_t *rwlock,
-			      const struct timespec *abstime)
-{
-  pthread_descr self;
-  pthread_extricate_if extr;
-
-  if (abstime->tv_nsec < 0 || abstime->tv_nsec >= 1000000000)
-    return EINVAL;
-
-  self = thread_self ();
-
-  /* Set up extrication interface */
-  extr.pu_object = rwlock;
-  extr.pu_extricate_func =  rwlock_wr_extricate_func;
-
-  /* Register extrication interface */
-  __pthread_set_own_extricate_if (self, &extr);
-
-  while(1)
-    {
-      __pthread_lock (&rwlock->__rw_lock, self);
-
-      if (rwlock->__rw_readers == 0 && rwlock->__rw_writer == NULL)
-	{
-	  rwlock->__rw_writer = self;
-	  __pthread_set_own_extricate_if (self, 0);
-	  __pthread_unlock (&rwlock->__rw_lock);
-	  return 0;
-	}
-
-      /* Suspend ourselves, then try again */
-      enqueue (&rwlock->__rw_write_waiting, self);
-      __pthread_unlock (&rwlock->__rw_lock);
-      /* This is not a cancellation point */
-      if (timedsuspend (self, abstime) == 0)
-	{
-	  int was_on_queue;
-
-	  __pthread_lock (&rwlock->__rw_lock, self);
-	  was_on_queue = remove_from_queue (&rwlock->__rw_write_waiting, self);
-	  __pthread_unlock (&rwlock->__rw_lock);
-
-	  if (was_on_queue)
-	    {
-	      __pthread_set_own_extricate_if (self, 0);
-	      return ETIMEDOUT;
-	    }
-
-	  /* Eat the outstanding restart() from the signaller */
-	  suspend (self);
-	}
-    }
-}
-
-
-
 int
 pthread_rwlock_trywrlock (pthread_rwlock_t *rwlock)
 {
@@ -506,7 +345,6 @@ pthread_rwlock_trywrlock (pthread_rwlock_t *rwlock)
 }
 
 
-
 int
 pthread_rwlock_unlock (pthread_rwlock_t *rwlock)
 {
@@ -524,9 +362,8 @@ pthread_rwlock_unlock (pthread_rwlock_t *rwlock)
 	}
       rwlock->__rw_writer = NULL;
 
-      if ((rwlock->__rw_kind == PTHREAD_RWLOCK_PREFER_READER_NP
-	   && !queue_is_empty(&rwlock->__rw_read_waiting))
-	  || (th = dequeue(&rwlock->__rw_write_waiting)) == NULL)
+      if (rwlock->__rw_kind == PTHREAD_RWLOCK_PREFER_READER_NP
+	  || (th = dequeue (&rwlock->__rw_write_waiting)) == NULL)
 	{
 	  /* Restart all waiting readers.  */
 	  torestart = rwlock->__rw_read_waiting;
@@ -573,15 +410,14 @@ pthread_rwlock_unlock (pthread_rwlock_t *rwlock)
 	    {
 	      if (victim->pr_lock_count == 0)
 		{
-		  victim->pr_next = THREAD_GETMEM (self, p_readlock_free);
-		  THREAD_SETMEM (self, p_readlock_free, victim);
+		  victim->pr_next = self->p_readlock_free;
+		  self->p_readlock_free = victim;
 		}
 	    }
 	  else
 	    {
-	      int val = THREAD_GETMEM (self, p_untracked_readlock_count);
-	      if (val > 0)
-		THREAD_SETMEM (self, p_untracked_readlock_count, val - 1);
+	      if (self->p_untracked_readlock_count > 0)
+		self->p_untracked_readlock_count--;
 	    }
 	}
     }
@@ -591,12 +427,11 @@ pthread_rwlock_unlock (pthread_rwlock_t *rwlock)
 
 
 
-
 int
 pthread_rwlockattr_init (pthread_rwlockattr_t *attr)
 {
   attr->__lockkind = 0;
-  attr->__pshared = PTHREAD_PROCESS_PRIVATE;
+  attr->__pshared = 0;
 
   return 0;
 }
@@ -609,7 +444,6 @@ pthread_rwlockattr_destroy (pthread_rwlockattr_t *attr)
 }
 
 
-
 int
 pthread_rwlockattr_getpshared (const pthread_rwlockattr_t *attr, int *pshared)
 {
@@ -624,10 +458,6 @@ pthread_rwlockattr_setpshared (pthread_rwlockattr_t *attr, int pshared)
   if (pshared != PTHREAD_PROCESS_PRIVATE && pshared != PTHREAD_PROCESS_SHARED)
     return EINVAL;
 
-  /* For now it is not possible to shared a conditional variable.  */
-  if (pshared != PTHREAD_PROCESS_PRIVATE)
-    return ENOSYS;
-
   attr->__pshared = pshared;
 
   return 0;
@@ -647,7 +477,6 @@ pthread_rwlockattr_setkind_np (pthread_rwlockattr_t *attr, int pref)
 {
   if (pref != PTHREAD_RWLOCK_PREFER_READER_NP
       && pref != PTHREAD_RWLOCK_PREFER_WRITER_NP
-      && pref != PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP
       && pref != PTHREAD_RWLOCK_DEFAULT_NP)
     return EINVAL;