/* 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 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; 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; }