From ceb336710e269470359ecebe2b179b79d9c7328c Mon Sep 17 00:00:00 2001 From: Doug Rabson Date: Fri, 1 Nov 2002 09:37:17 +0000 Subject: [PATCH] * Add stubs for pthread_cond_broadcast. * Fix typos in rwlock stubs. * Add pthread_XXX counterparts to the _pthread_XXX stubs which libraries like libX11 can use to ensure thread-safety without requiring the use of a thread library. Submitted by: Terry Lambert (pthread_cond_broadcast) Reviewed by: deischen --- lib/libc/gen/_pthread_stubs.c | 271 ++++++++++++++++++++++++++++++---- lib/libc/include/namespace.h | 1 + lib/libc/include/reentrant.h | 2 + 3 files changed, 246 insertions(+), 28 deletions(-) diff --git a/lib/libc/gen/_pthread_stubs.c b/lib/libc/gen/_pthread_stubs.c index 18669b6a7160..e7e9e4690cb8 100644 --- a/lib/libc/gen/_pthread_stubs.c +++ b/lib/libc/gen/_pthread_stubs.c @@ -31,6 +31,9 @@ __FBSDID("$FreeBSD$"); #include #include +void *_pthread_getspecific(pthread_key_t key); +pthread_t _pthread_self(void); + /* * Weak symbols: All libc internal usage of these functions should * use the weak symbol versions (_pthread_XXX). If libpthread is @@ -39,9 +42,15 @@ __FBSDID("$FreeBSD$"); * usage to avoid unwanted cancellation points and to differentiate * between application locks and libc locks (threads holding the * latter can't be allowed to exit/terminate). + * + * We also provide weak pthread_XXX stubs which call their + * _pthread_XXX counterparts. These stubs may be used be other + * libraries for ensuring thread-safety without requiring the presence + * of a thread library. */ __weak_reference(_pthread_cond_init_stub, _pthread_cond_init); __weak_reference(_pthread_cond_signal_stub, _pthread_cond_signal); +__weak_reference(_pthread_cond_broadcast_stub, _pthread_cond_broadcast); __weak_reference(_pthread_cond_wait_stub, _pthread_cond_wait); __weak_reference(_pthread_cond_destroy_stub, _pthread_cond_destroy); __weak_reference(_pthread_getspecific_stub, _pthread_getspecific); @@ -59,180 +68,386 @@ __weak_reference(_pthread_mutexattr_settype_stub, _pthread_mutexattr_settype); __weak_reference(_pthread_once_stub, _pthread_once); __weak_reference(_pthread_self_stub, _pthread_self); __weak_reference(_pthread_rwlock_init_stub, _pthread_rwlock_init); +__weak_reference(_pthread_rwlock_destroy_stub, _pthread_rwlock_destroy); __weak_reference(_pthread_rwlock_rdlock_stub, _pthread_rwlock_rdlock); __weak_reference(_pthread_rwlock_tryrdlock_stub, _pthread_rwlock_tryrdlock); -__weak_reference(_pthread_rwlock_trywrlock_stub, _pthread_rwlock_trywrloc); +__weak_reference(_pthread_rwlock_trywrlock_stub, _pthread_rwlock_trywrlock); __weak_reference(_pthread_rwlock_unlock_stub, _pthread_rwlock_unlock); __weak_reference(_pthread_rwlock_wrlock_stub, _pthread_rwlock_wrlock); __weak_reference(_pthread_setspecific_stub, _pthread_setspecific); __weak_reference(_pthread_sigmask_stub, _pthread_sigmask); +__weak_reference(pthread_cond_init_stub, pthread_cond_init); +__weak_reference(pthread_cond_signal_stub, pthread_cond_signal); +__weak_reference(pthread_cond_broadcast_stub, pthread_cond_broadcast); +__weak_reference(pthread_cond_wait_stub, pthread_cond_wait); +__weak_reference(pthread_cond_destroy_stub, pthread_cond_destroy); +__weak_reference(pthread_getspecific_stub, pthread_getspecific); +__weak_reference(pthread_key_create_stub, pthread_key_create); +__weak_reference(pthread_key_delete_stub, pthread_key_delete); +__weak_reference(pthread_main_np_stub, pthread_main_np); +__weak_reference(pthread_mutex_destroy_stub, pthread_mutex_destroy); +__weak_reference(pthread_mutex_init_stub, pthread_mutex_init); +__weak_reference(pthread_mutex_lock_stub, pthread_mutex_lock); +__weak_reference(pthread_mutex_trylock_stub, pthread_mutex_trylock); +__weak_reference(pthread_mutex_unlock_stub, pthread_mutex_unlock); +__weak_reference(pthread_mutexattr_init_stub, pthread_mutexattr_init); +__weak_reference(pthread_mutexattr_destroy_stub, pthread_mutexattr_destroy); +__weak_reference(pthread_mutexattr_settype_stub, pthread_mutexattr_settype); +__weak_reference(pthread_once_stub, pthread_once); +__weak_reference(pthread_self_stub, pthread_self); +__weak_reference(pthread_rwlock_init_stub, pthread_rwlock_init); +__weak_reference(pthread_rwlock_destroy_stub, pthread_rwlock_destroy); +__weak_reference(pthread_rwlock_rdlock_stub, pthread_rwlock_rdlock); +__weak_reference(pthread_rwlock_tryrdlock_stub, pthread_rwlock_tryrdlock); +__weak_reference(pthread_rwlock_trywrlock_stub, pthread_rwlock_trywrlock); +__weak_reference(pthread_rwlock_unlock_stub, pthread_rwlock_unlock); +__weak_reference(pthread_rwlock_wrlock_stub, pthread_rwlock_wrlock); +__weak_reference(pthread_setspecific_stub, pthread_setspecific); +__weak_reference(pthread_sigmask_stub, pthread_sigmask); + /* Define a null pthread structure just to satisfy _pthread_self. */ struct pthread { }; static struct pthread main_thread; -int +static int _pthread_cond_init_stub(pthread_cond_t *cond, const pthread_condattr_t *cond_attr) { return (0); } -int +static int _pthread_cond_signal_stub(pthread_cond_t *cond) { return (0); } -int +static int +_pthread_cond_broadcast_stub(pthread_cond_t *cond) +{ + return (0); +} + +static int _pthread_cond_wait_stub(pthread_cond_t *cond, pthread_mutex_t *mutex) { return (0); } -int +static int _pthread_cond_destroy_stub(pthread_cond_t *cond) { return (0); } -void * +static void * _pthread_getspecific_stub(pthread_key_t key) { return (NULL); } -int +static int _pthread_key_create_stub(pthread_key_t *key, void (*destructor) (void *)) { return (0); } -int +static int _pthread_key_delete_stub(pthread_key_t key) { return (0); } -int +static int _pthread_main_np_stub() { return (-1); } -int +static int _pthread_mutex_destroy_stub(pthread_mutex_t *mattr) { return (0); } -int +static int _pthread_mutex_init_stub(pthread_mutex_t *mutex, const pthread_mutexattr_t *mattr) { return (0); } -int +static int _pthread_mutex_lock_stub(pthread_mutex_t *mutex) { return (0); } -int +static int _pthread_mutex_trylock_stub(pthread_mutex_t *mutex) { return (0); } -int +static int _pthread_mutex_unlock_stub(pthread_mutex_t *mutex) { return (0); } -int +static int _pthread_mutexattr_init_stub(pthread_mutexattr_t *mattr) { return (0); } -int +static int _pthread_mutexattr_destroy_stub(pthread_mutexattr_t *mattr) { return (0); } -int +static int _pthread_mutexattr_settype_stub(pthread_mutexattr_t *mattr, int type) { return (0); } -int +static int _pthread_once_stub(pthread_once_t *once_control, void (*init_routine) (void)) { return (0); } -int +static int _pthread_rwlock_init_stub(pthread_rwlock_t *rwlock, const pthread_rwlockattr_t *attr) { return (0); } -int +static int _pthread_rwlock_destroy_stub(pthread_rwlock_t *rwlock) { return (0); } -int +static int _pthread_rwlock_rdlock_stub(pthread_rwlock_t *rwlock) { return (0); } -int +static int _pthread_rwlock_tryrdlock_stub(pthread_rwlock_t *rwlock) { return (0); } -int +static int _pthread_rwlock_trywrlock_stub(pthread_rwlock_t *rwlock) { return (0); } -int +static int _pthread_rwlock_unlock_stub(pthread_rwlock_t *rwlock) { return (0); } -int +static int _pthread_rwlock_wrlock_stub(pthread_rwlock_t *rwlock) { return (0); } -pthread_t +static pthread_t _pthread_self_stub(void) { return (&main_thread); } -int +static int _pthread_setspecific_stub(pthread_key_t key, const void *value) { return (0); } -int +static int _pthread_sigmask_stub(int how, const sigset_t *set, sigset_t *oset) { return (0); } + +static int +pthread_cond_init_stub(pthread_cond_t *cond, + const pthread_condattr_t *cond_attr) +{ + return (_pthread_cond_init(cond, cond_attr)); +} + +static int +pthread_cond_signal_stub(pthread_cond_t *cond) +{ + return (_pthread_cond_signal(cond)); +} + +static int +pthread_cond_broadcast_stub(pthread_cond_t *cond) +{ + return (_pthread_cond_broadcast(cond)); +} + +static int +pthread_cond_wait_stub(pthread_cond_t *cond, pthread_mutex_t *mutex) +{ + return (_pthread_cond_wait(cond, mutex)); +} + +static int +pthread_cond_destroy_stub(pthread_cond_t *cond) +{ + return (_pthread_cond_destroy(cond)); +} + +static void * +pthread_getspecific_stub(pthread_key_t key) +{ + return (_pthread_getspecific(key)); +} + +static int +pthread_key_create_stub(pthread_key_t *key, void (*destructor) (void *)) +{ + return (_pthread_key_create(key, destructor)); +} + +static int +pthread_key_delete_stub(pthread_key_t key) +{ + return (_pthread_key_delete(key)); +} + +static int +pthread_main_np_stub() +{ + return (_pthread_main_np()); +} + +static int +pthread_mutex_destroy_stub(pthread_mutex_t *mattr) +{ + return (_pthread_mutex_destroy(mattr)); +} + +static int +pthread_mutex_init_stub(pthread_mutex_t *mutex, const pthread_mutexattr_t *mattr) +{ + return (_pthread_mutex_init(mutex, mattr)); +} + +static int +pthread_mutex_lock_stub(pthread_mutex_t *mutex) +{ + return (_pthread_mutex_lock(mutex)); +} + +static int +pthread_mutex_trylock_stub(pthread_mutex_t *mutex) +{ + return (_pthread_mutex_trylock(mutex)); +} + +static int +pthread_mutex_unlock_stub(pthread_mutex_t *mutex) +{ + return (_pthread_mutex_unlock(mutex)); +} + +static int +pthread_mutexattr_init_stub(pthread_mutexattr_t *mattr) +{ + return (_pthread_mutexattr_init(mattr)); +} + +static int +pthread_mutexattr_destroy_stub(pthread_mutexattr_t *mattr) +{ + return (_pthread_mutexattr_destroy(mattr)); +} + +static int +pthread_mutexattr_settype_stub(pthread_mutexattr_t *mattr, int type) +{ + return (_pthread_mutexattr_settype(mattr, type)); +} + +static int +pthread_once_stub(pthread_once_t *once_control, void (*init_routine) (void)) +{ + return (_pthread_once(once_control, init_routine)); +} + +static int +pthread_rwlock_init_stub(pthread_rwlock_t *rwlock, + const pthread_rwlockattr_t *attr) +{ + return (_pthread_rwlock_init(rwlock, attr)); +} + +static int +pthread_rwlock_destroy_stub(pthread_rwlock_t *rwlock) +{ + return (_pthread_rwlock_destroy(rwlock)); +} + +static int +pthread_rwlock_rdlock_stub(pthread_rwlock_t *rwlock) +{ + return (_pthread_rwlock_rdlock(rwlock)); +} + +static int +pthread_rwlock_tryrdlock_stub(pthread_rwlock_t *rwlock) +{ + return (_pthread_rwlock_tryrdlock(rwlock)); +} + +static int +pthread_rwlock_trywrlock_stub(pthread_rwlock_t *rwlock) +{ + return (_pthread_rwlock_trywrlock(rwlock)); +} + +static int +pthread_rwlock_unlock_stub(pthread_rwlock_t *rwlock) +{ + return (_pthread_rwlock_unlock(rwlock)); +} + +static int +pthread_rwlock_wrlock_stub(pthread_rwlock_t *rwlock) +{ + return (_pthread_rwlock_wrlock(rwlock)); +} + +static pthread_t +pthread_self_stub(void) +{ + return (_pthread_self()); +} + +static int +pthread_setspecific_stub(pthread_key_t key, const void *value) +{ + return (_pthread_setspecific(key, value)); +} + +static int +pthread_sigmask_stub(int how, const sigset_t *set, sigset_t *oset) +{ + return (_pthread_sigmask(how, set, oset)); +} diff --git a/lib/libc/include/namespace.h b/lib/libc/include/namespace.h index bbd33c0ca8ee..bfe49e2c0f57 100644 --- a/lib/libc/include/namespace.h +++ b/lib/libc/include/namespace.h @@ -77,6 +77,7 @@ #define open _open #define poll _poll #define pthread_cond_signal _pthread_cond_signal +#define pthread_cond_broadcast _pthread_cond_broadcast #define pthread_cond_wait _pthread_cond_wait #define pthread_cond_init _pthread_cond_init #define pthread_exit _pthread_exit diff --git a/lib/libc/include/reentrant.h b/lib/libc/include/reentrant.h index e6ceb5ba1413..8ce3af67e304 100644 --- a/lib/libc/include/reentrant.h +++ b/lib/libc/include/reentrant.h @@ -109,6 +109,8 @@ #define cond_init(c, a, p) _pthread_cond_init(c, a) #define cond_signal(m) if (__isthreaded) \ _pthread_cond_signal(m) +#define cond_broadcast(m) if (__isthreaded) \ + _pthread_cond_broadcast(m) #define cond_wait(c, m) if (__isthreaded) \ _pthread_cond_wait(c, m)