rename current stable linuxthreads to linuxthreads.old to prepare for import of latest glibc version

1 files changed, 0 insertions, 486 deletions

diff --git a/libpthread/linuxthreads/rwlock.c b/libpthread/linuxthreads/rwlock.c
deleted file mode 100644
index 977fd88af..000000000
--- a/libpthread/linuxthreads/rwlock.c
+++ /dev/null
@@ -1,486 +0,0 @@
-/* Read-write lock implementation.
-   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 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
-   Library General Public License for more details.
-
-   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.  */
-
-#include <errno.h>
-#include <pthread.h>
-#include <stdlib.h>
-#include "internals.h"
-#include "queue.h"
-#include "spinlock.h"
-#include "restart.h"
-
-/*
- * 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
- * corresponding to that lock.
- */
-
-static pthread_readlock_info *
-rwlock_is_in_list(pthread_descr self, pthread_rwlock_t *rwlock)
-{
-  pthread_readlock_info *info;
-
-  for (info = self->p_readlock_list; info != NULL; info = info->pr_next)
-    {
-      if (info->pr_lock == rwlock)
-	return info;
-    }
-
-  return NULL;
-}
-
-/*
- * Add a new lock to the thread's list of locks for which it has a read lock.
- * A new info node must be allocated for this, which is taken from the thread's
- * free list, or by calling malloc. If malloc fails, a null pointer is
- * returned. Otherwise the lock info structure is initialized and pushed
- * onto the thread's list.
- */
-
-static pthread_readlock_info *
-rwlock_add_to_list(pthread_descr self, pthread_rwlock_t *rwlock)
-{
-  pthread_readlock_info *info = self->p_readlock_free;
-
-  if (info != NULL) 
-    self->p_readlock_free = info->pr_next;
-  else
-    info = malloc(sizeof *info);
-
-  if (info == NULL)
-    return NULL;
-
-  info->pr_lock_count = 1;
-  info->pr_lock = rwlock;
-  info->pr_next = self->p_readlock_list;
-  self->p_readlock_list = info;
-
-  return info;
-}
-
-/*
- * If the thread owns a read lock over the given pthread_rwlock_t,
- * and this read lock is tracked in the thread's lock list,
- * this function returns a pointer to the info node in that list.
- * It also decrements the lock count within that node, and if
- * it reaches zero, it removes the node from the list.
- * If nothing is found, it returns a null pointer.
- */
-
-static pthread_readlock_info *
-rwlock_remove_from_list(pthread_descr self, pthread_rwlock_t *rwlock)
-{
-  pthread_readlock_info **pinfo;
-
-  for (pinfo = &self->p_readlock_list; *pinfo != NULL; pinfo = &(*pinfo)->pr_next)
-    {
-      if ((*pinfo)->pr_lock == rwlock)
-	{
-	  pthread_readlock_info *info = *pinfo;
-	  if (--info->pr_lock_count == 0)
-	    *pinfo = info->pr_next;
-	  return info;
-	}
-    }
-  
-  return NULL;
-}
-
-/*
- * This function checks whether the conditions are right to place a read lock.
- * It returns 1 if so, otherwise zero. The rwlock's internal lock must be
- * locked upon entry.
- */
-
-static int
-rwlock_can_rdlock(pthread_rwlock_t *rwlock, int have_lock_already)
-{
-  /* Can't readlock; it is write locked. */
-  if (rwlock->__rw_writer != NULL)
-    return 0;
-
-  /* Lock prefers readers; get it. */
-  if (rwlock->__rw_kind == PTHREAD_RWLOCK_PREFER_READER_NP)
-    return 1;
-
-  /* Lock prefers writers, but none are waiting. */
-  if (queue_is_empty(&rwlock->__rw_write_waiting))
-    return 1;
-
-  /* Writers are waiting, but this thread already has a read lock */
-  if (have_lock_already)
-    return 1;
-
-  /* Writers are waiting, and this is a new lock */
-  return 0;
-}
-
-/*
- * 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.  
- *
- * 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.
- *
- * Also, if it finds the thread's lock in the list, it sets the pointer
- * referenced by pexisting to refer to the list entry.
- *
- * If the thread has no untracked locks, and the lock is not found
- * in its list, then it is added to the list. If this fails,
- * then *pout_of_mem is set to 1.
- */
-
-static int
-rwlock_have_already(pthread_descr *pself, pthread_rwlock_t *rwlock,
-    pthread_readlock_info **pexisting, int *pout_of_mem)
-{
-  pthread_readlock_info *existing = NULL;
-  int out_of_mem = 0, have_lock_already = 0;
-  pthread_descr self = *pself;
-
-  if (rwlock->__rw_kind == PTHREAD_RWLOCK_PREFER_WRITER_NP)
-    {
-      if (!self)
-	self = thread_self();
-
-      existing = rwlock_is_in_list(self, rwlock);
-
-      if (existing != NULL || self->p_untracked_readlock_count > 0)
-	have_lock_already = 1;
-      else
-	{
-	  existing = rwlock_add_to_list(self, rwlock);
-	  if (existing == NULL)
-	    out_of_mem = 1;
-	}
-    }
-
-  *pout_of_mem = out_of_mem;
-  *pexisting = existing;
-  *pself = self;
-
-  return have_lock_already;
-}
-
-int
-pthread_rwlock_init (pthread_rwlock_t *rwlock,
-		     const pthread_rwlockattr_t *attr)
-{
-  __pthread_init_lock(&rwlock->__rw_lock);
-  rwlock->__rw_readers = 0;
-  rwlock->__rw_writer = NULL;
-  rwlock->__rw_read_waiting = NULL;
-  rwlock->__rw_write_waiting = NULL;
-
-  if (attr == NULL)
-    {
-      rwlock->__rw_kind = PTHREAD_RWLOCK_DEFAULT_NP;
-      rwlock->__rw_pshared = PTHREAD_PROCESS_PRIVATE;
-    }
-  else
-    {
-      rwlock->__rw_kind = attr->__lockkind;
-      rwlock->__rw_pshared = attr->__pshared;
-    }
-
-  return 0;
-}
-
-
-int
-pthread_rwlock_destroy (pthread_rwlock_t *rwlock)
-{
-  int readers;
-  _pthread_descr writer;
-
-  __pthread_lock (&rwlock->__rw_lock, NULL);
-  readers = rwlock->__rw_readers;
-  writer = rwlock->__rw_writer;
-  __pthread_unlock (&rwlock->__rw_lock);
-
-  if (readers > 0 || writer != NULL)
-    return EBUSY;
-
-  return 0;
-}
-
-int
-pthread_rwlock_rdlock (pthread_rwlock_t *rwlock)
-{
-  pthread_descr self = NULL;
-  pthread_readlock_info *existing;
-  int out_of_mem, have_lock_already;
-
-  have_lock_already = rwlock_have_already(&self, rwlock,
-      &existing, &out_of_mem);
-
-  for (;;)
-    {
-      if (self == NULL)
-	self = thread_self ();
-
-      __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++;
-    }
-  
-  return 0;
-}
-
-int
-pthread_rwlock_tryrdlock (pthread_rwlock_t *rwlock)
-{
-  pthread_descr self = thread_self();
-  pthread_readlock_info *existing;
-  int out_of_mem, have_lock_already;
-  int retval = EBUSY;
-
-  have_lock_already = rwlock_have_already(&self, rwlock,
-      &existing, &out_of_mem);
-
-  __pthread_lock (&rwlock->__rw_lock, self);
-
-  /* 0 is passed to here instead of have_lock_already.
-     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. */
-
-  if (rwlock_can_rdlock(rwlock, 0))
-    {
-      ++rwlock->__rw_readers;
-      retval = 0;
-    }
-
-  __pthread_unlock (&rwlock->__rw_lock);
-
-  if (retval == 0)
-    {
-      if (have_lock_already || out_of_mem)
-	{
-	  if (existing != NULL)
-	    existing->pr_lock_count++;
-	  else
-	    self->p_untracked_readlock_count++;
-	}
-    }
-  
-  return retval;
-}
-
-
-int
-pthread_rwlock_wrlock (pthread_rwlock_t *rwlock)
-{
-  pthread_descr self = thread_self ();
-
-  while(1)
-    {
-      __pthread_lock (&rwlock->__rw_lock, self);
-      if (rwlock->__rw_readers == 0 && rwlock->__rw_writer == NULL)
-	{
-	  rwlock->__rw_writer = self;
-	  __pthread_unlock (&rwlock->__rw_lock);
-	  return 0;
-	}
-
-      /* Suspend ourselves, then try again */
-      enqueue (&rwlock->__rw_write_waiting, self);
-      __pthread_unlock (&rwlock->__rw_lock);
-      suspend (self); /* This is not a cancellation point */
-    }
-}
-
-
-int
-pthread_rwlock_trywrlock (pthread_rwlock_t *rwlock)
-{
-  int result = EBUSY;
-
-  __pthread_lock (&rwlock->__rw_lock, NULL);
-  if (rwlock->__rw_readers == 0 && rwlock->__rw_writer == NULL)
-    {
-      rwlock->__rw_writer = thread_self ();
-      result = 0;
-    }
-  __pthread_unlock (&rwlock->__rw_lock);
-
-  return result;
-}
-
-
-int
-pthread_rwlock_unlock (pthread_rwlock_t *rwlock)
-{
-  pthread_descr torestart;
-  pthread_descr th;
-
-  __pthread_lock (&rwlock->__rw_lock, NULL);
-  if (rwlock->__rw_writer != NULL)
-    {
-      /* Unlocking a write lock.  */
-      if (rwlock->__rw_writer != thread_self ())
-	{
-	  __pthread_unlock (&rwlock->__rw_lock);
-	  return EPERM;
-	}
-      rwlock->__rw_writer = 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;
-	  rwlock->__rw_read_waiting = NULL;
-	  __pthread_unlock (&rwlock->__rw_lock);
-	  while ((th = dequeue (&torestart)) != NULL)
-	    restart (th);
-	}
-      else
-	{
-	  /* Restart one waiting writer.  */
-	  __pthread_unlock (&rwlock->__rw_lock);
-	  restart (th);
-	}
-    }
-  else
-    {
-      /* Unlocking a read lock.  */
-      if (rwlock->__rw_readers == 0)
-	{
-	  __pthread_unlock (&rwlock->__rw_lock);
-	  return EPERM;
-	}
-
-      --rwlock->__rw_readers;
-      if (rwlock->__rw_readers == 0)
-	/* Restart one waiting writer, if any.  */
-	th = dequeue (&rwlock->__rw_write_waiting);
-      else
-	th = NULL;
-
-      __pthread_unlock (&rwlock->__rw_lock);
-      if (th != NULL)
-	restart (th);
-
-      /* Recursive lock fixup */
-
-      if (rwlock->__rw_kind == PTHREAD_RWLOCK_PREFER_WRITER_NP)
-	{
-	  pthread_descr self = thread_self();
-	  pthread_readlock_info *victim = rwlock_remove_from_list(self, rwlock);
-
-	  if (victim != NULL)
-	    {
-	      if (victim->pr_lock_count == 0)
-		{
-		  victim->pr_next = self->p_readlock_free;
-		  self->p_readlock_free = victim;
-		}
-	    }
-	  else
-	    {
-	      if (self->p_untracked_readlock_count > 0)
-		self->p_untracked_readlock_count--;
-	    }
-	}
-    }
-
-  return 0;
-}
-
-
-
-int
-pthread_rwlockattr_init (pthread_rwlockattr_t *attr)
-{
-  attr->__lockkind = 0;
-  attr->__pshared = 0;
-
-  return 0;
-}
-
-
-int
-pthread_rwlockattr_destroy (pthread_rwlockattr_t *attr)
-{
-  return 0;
-}
-
-
-int
-pthread_rwlockattr_getpshared (const pthread_rwlockattr_t *attr, int *pshared)
-{
-  *pshared = attr->__pshared;
-  return 0;
-}
-
-
-int
-pthread_rwlockattr_setpshared (pthread_rwlockattr_t *attr, int pshared)
-{
-  if (pshared != PTHREAD_PROCESS_PRIVATE && pshared != PTHREAD_PROCESS_SHARED)
-    return EINVAL;
-
-  attr->__pshared = pshared;
-
-  return 0;
-}
-
-
-int
-pthread_rwlockattr_getkind_np (const pthread_rwlockattr_t *attr, int *pref)
-{
-  *pref = attr->__lockkind;
-  return 0;
-}
-
-
-int
-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_DEFAULT_NP)
-    return EINVAL;
-
-  attr->__lockkind = pref;
-
-  return 0;
-}