Subversion Repositories openrisc

/* Read-write lock implementation.
   Copyright (C) 1998, 2000 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 <bits/libc-lock.h>
#include <errno.h>
#include <pthread.h>
#include <stdlib.h>
#include "internals.h"
#include "queue.h"
#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
 * 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 = THREAD_GETMEM (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 = THREAD_GETMEM (self, p_readlock_free);
 
  if (info != NULL)
    THREAD_SETMEM (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 = THREAD_GETMEM (self, p_readlock_list);
  THREAD_SETMEM (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)
	*pself = self = thread_self();
 
      existing = rwlock_is_in_list(self, rwlock);
 
      if (existing != NULL
	  || THREAD_GETMEM (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;
 
  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;
}
strong_alias (__pthread_rwlock_init, pthread_rwlock_init)
 
 
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;
}
strong_alias (__pthread_rwlock_destroy, pthread_rwlock_destroy)
 
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);
 
  if (self == NULL)
    self = thread_self ();
 
  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;
    }
 
  return 0;
}
strong_alias (__pthread_rwlock_rdlock, pthread_rwlock_rdlock)
 
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))
	break;
 
      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);
	}
    }
 
  __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;
      else
	++self->p_untracked_readlock_count;
    }
 
  return 0;
}
strong_alias (__pthread_rwlock_timedrdlock, pthread_rwlock_timedrdlock)
 
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;
}
strong_alias (__pthread_rwlock_tryrdlock, pthread_rwlock_tryrdlock)
 
 
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 */
    }
}
strong_alias (__pthread_rwlock_wrlock, pthread_rwlock_wrlock)
 
 
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);
	}
    }
}
strong_alias (__pthread_rwlock_timedwrlock, pthread_rwlock_timedwrlock)
 
 
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;
}
strong_alias (__pthread_rwlock_trywrlock, pthread_rwlock_trywrlock)
 
 
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
	   && !queue_is_empty(&rwlock->__rw_read_waiting))
	  || (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 = THREAD_GETMEM (self, p_readlock_free);
		  THREAD_SETMEM (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);
	    }
	}
    }
 
  return 0;
}
strong_alias (__pthread_rwlock_unlock, pthread_rwlock_unlock)
 
 
 
int
pthread_rwlockattr_init (pthread_rwlockattr_t *attr)
{
  attr->__lockkind = 0;
  attr->__pshared = PTHREAD_PROCESS_PRIVATE;
 
  return 0;
}
 
 
int
__pthread_rwlockattr_destroy (pthread_rwlockattr_t *attr)
{
  return 0;
}
strong_alias (__pthread_rwlockattr_destroy, pthread_rwlockattr_destroy)
 
 
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;
 
  /* For now it is not possible to shared a conditional variable.  */
  if (pshared != PTHREAD_PROCESS_PRIVATE)
    return ENOSYS;
 
  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_PREFER_WRITER_NONRECURSIVE_NP
      && pref != PTHREAD_RWLOCK_DEFAULT_NP)
    return EINVAL;
 
  attr->__lockkind = pref;
 
  return 0;
}