From 524a6c841c467da890061cbdc2ace08d30e6e780 Mon Sep 17 00:00:00 2001 From: deischen Date: Wed, 13 Nov 2002 18:13:26 +0000 Subject: At initialization, override the pthread stub routines in libc by filling in the jump table. Convert uses of pthread routines within libc_r to use the internal versions (_pthread_foo instead of pthread_foo). Remove a couple of globals from application namespace. --- lib/libc_r/uthread/pthread_private.h | 17 ++---- lib/libc_r/uthread/uthread_attr_init.c | 2 +- lib/libc_r/uthread/uthread_autoinit.c | 3 + lib/libc_r/uthread/uthread_cond.c | 73 ++++++++++++++++------- lib/libc_r/uthread/uthread_condattr_init.c | 8 ++- lib/libc_r/uthread/uthread_create.c | 11 ++-- lib/libc_r/uthread/uthread_exit.c | 11 ++-- lib/libc_r/uthread/uthread_gc.c | 10 ++-- lib/libc_r/uthread/uthread_init.c | 80 ++++++++++++++++++++++---- lib/libc_r/uthread/uthread_join.c | 6 +- lib/libc_r/uthread/uthread_mattr_init.c | 8 ++- lib/libc_r/uthread/uthread_mutex.c | 27 ++++----- lib/libc_r/uthread/uthread_mutex_prioceiling.c | 6 +- lib/libc_r/uthread/uthread_once.c | 6 +- lib/libc_r/uthread/uthread_pselect.c | 4 +- lib/libc_r/uthread/uthread_rwlock.c | 57 +++++++++--------- lib/libc_r/uthread/uthread_sem.c | 38 ++++++------ lib/libc_r/uthread/uthread_sig.c | 3 +- lib/libc_r/uthread/uthread_stack.c | 11 ++-- 19 files changed, 245 insertions(+), 136 deletions(-) (limited to 'lib/libc_r') diff --git a/lib/libc_r/uthread/pthread_private.h b/lib/libc_r/uthread/pthread_private.h index 5078b3c..2688914 100644 --- a/lib/libc_r/uthread/pthread_private.h +++ b/lib/libc_r/uthread/pthread_private.h @@ -944,7 +944,7 @@ SCLASS struct pthread *_thread_initial #endif /* Default thread attributes: */ -SCLASS struct pthread_attr pthread_attr_default +SCLASS struct pthread_attr _pthread_attr_default #ifdef GLOBAL_PTHREAD_PRIVATE = { SCHED_RR, 0, TIMESLICE_USEC, PTHREAD_DEFAULT_PRIORITY, PTHREAD_CREATE_RUNNING, PTHREAD_CREATE_JOINABLE, NULL, NULL, NULL, @@ -954,20 +954,11 @@ SCLASS struct pthread_attr pthread_attr_default #endif /* Default mutex attributes: */ -SCLASS struct pthread_mutex_attr pthread_mutexattr_default -#ifdef GLOBAL_PTHREAD_PRIVATE -= { PTHREAD_MUTEX_DEFAULT, PTHREAD_PRIO_NONE, 0, 0 }; -#else -; -#endif +#define PTHREAD_MUTEXATTR_DEFAULT \ + { PTHREAD_MUTEX_DEFAULT, PTHREAD_PRIO_NONE, 0, 0 } /* Default condition variable attributes: */ -SCLASS struct pthread_cond_attr pthread_condattr_default -#ifdef GLOBAL_PTHREAD_PRIVATE -= { COND_TYPE_FAST, 0 }; -#else -; -#endif +#define PTHREAD_CONDATTR_DEFAULT { COND_TYPE_FAST, 0 } /* * Standard I/O file descriptors need special flag treatment since diff --git a/lib/libc_r/uthread/uthread_attr_init.c b/lib/libc_r/uthread/uthread_attr_init.c index e10d521..10423ce 100644 --- a/lib/libc_r/uthread/uthread_attr_init.c +++ b/lib/libc_r/uthread/uthread_attr_init.c @@ -51,7 +51,7 @@ _pthread_attr_init(pthread_attr_t *attr) ret = ENOMEM; else { /* Initialise the attribute object with the defaults: */ - memcpy(pattr, &pthread_attr_default, sizeof(struct pthread_attr)); + memcpy(pattr, &_pthread_attr_default, sizeof(*pattr)); /* Return a pointer to the attribute object: */ *attr = pattr; diff --git a/lib/libc_r/uthread/uthread_autoinit.c b/lib/libc_r/uthread/uthread_autoinit.c index 31e2d48..03ee58d 100644 --- a/lib/libc_r/uthread/uthread_autoinit.c +++ b/lib/libc_r/uthread/uthread_autoinit.c @@ -33,6 +33,9 @@ * $FreeBSD$ */ +#include +#include + /* * This module uses GCC extentions to initialize the * threads package at program start-up time. diff --git a/lib/libc_r/uthread/uthread_cond.c b/lib/libc_r/uthread/uthread_cond.c index cb45725..c3ca741 100644 --- a/lib/libc_r/uthread/uthread_cond.c +++ b/lib/libc_r/uthread/uthread_cond.c @@ -34,7 +34,9 @@ #include #include #include +#include "namespace.h" #include +#include "un-namespace.h" #include "pthread_private.h" /* @@ -43,16 +45,30 @@ static inline pthread_t cond_queue_deq(pthread_cond_t); static inline void cond_queue_remove(pthread_cond_t, pthread_t); static inline void cond_queue_enq(pthread_cond_t, pthread_t); +int __pthread_cond_timedwait(pthread_cond_t *, + pthread_mutex_t *, const struct timespec *); +int __pthread_cond_wait(pthread_cond_t *, + pthread_mutex_t *); + + +/* + * Double underscore versions are cancellation points. Single underscore + * versions are not and are provided for libc internal usage (which + * shouldn't introduce cancellation points). + */ +__weak_reference(__pthread_cond_wait, pthread_cond_wait); +__weak_reference(__pthread_cond_timedwait, pthread_cond_timedwait); __weak_reference(_pthread_cond_init, pthread_cond_init); __weak_reference(_pthread_cond_destroy, pthread_cond_destroy); -__weak_reference(_pthread_cond_wait, pthread_cond_wait); -__weak_reference(_pthread_cond_timedwait, pthread_cond_timedwait); __weak_reference(_pthread_cond_signal, pthread_cond_signal); __weak_reference(_pthread_cond_broadcast, pthread_cond_broadcast); -/* Reinitialize a condition variable to defaults. */ +/* + * Reinitialize a private condition variable; this is only used for + * internal condition variables. Currently, there is no difference. + */ int _cond_reinit(pthread_cond_t *cond) { @@ -61,7 +77,7 @@ _cond_reinit(pthread_cond_t *cond) if (cond == NULL) ret = EINVAL; else if (*cond == NULL) - ret = pthread_cond_init(cond, NULL); + ret = _pthread_cond_init(cond, NULL); else { /* * Initialize the condition variable structure: @@ -172,8 +188,6 @@ _pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex) int interrupted = 0; int seqno; - _thread_enter_cancellation_point(); - if (cond == NULL) return (EINVAL); @@ -182,7 +196,7 @@ _pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex) * perform the dynamic initialization: */ if (*cond == NULL && - (rval = pthread_cond_init(cond, NULL)) != 0) + (rval = _pthread_cond_init(cond, NULL)) != 0) return (rval); /* @@ -316,15 +330,24 @@ _pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex) curthread->continuation((void *) curthread); } while ((done == 0) && (rval == 0)); - _thread_leave_cancellation_point(); - /* Return the completion status: */ return (rval); } int -_pthread_cond_timedwait(pthread_cond_t * cond, pthread_mutex_t * mutex, - const struct timespec * abstime) +__pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex) +{ + int ret; + + _thread_enter_cancellation_point(); + ret = _pthread_cond_wait(cond, mutex); + _thread_leave_cancellation_point(); + return (ret); +} + +int +_pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex, + const struct timespec *abstime) { struct pthread *curthread = _get_curthread(); int rval = 0; @@ -332,8 +355,6 @@ _pthread_cond_timedwait(pthread_cond_t * cond, pthread_mutex_t * mutex, int interrupted = 0; int seqno; - _thread_enter_cancellation_point(); - if (abstime == NULL || abstime->tv_sec < 0 || abstime->tv_nsec < 0 || abstime->tv_nsec >= 1000000000) return (EINVAL); @@ -341,7 +362,7 @@ _pthread_cond_timedwait(pthread_cond_t * cond, pthread_mutex_t * mutex, * If the condition variable is statically initialized, perform dynamic * initialization. */ - if (*cond == NULL && (rval = pthread_cond_init(cond, NULL)) != 0) + if (*cond == NULL && (rval = _pthread_cond_init(cond, NULL)) != 0) return (rval); /* @@ -487,14 +508,24 @@ _pthread_cond_timedwait(pthread_cond_t * cond, pthread_mutex_t * mutex, curthread->continuation((void *) curthread); } while ((done == 0) && (rval == 0)); - _thread_leave_cancellation_point(); - /* Return the completion status: */ return (rval); } int -_pthread_cond_signal(pthread_cond_t * cond) +__pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex, + const struct timespec *abstime) +{ + int ret; + + _thread_enter_cancellation_point(); + ret = _pthread_cond_timedwait(cond, mutex, abstime); + _thread_enter_cancellation_point(); + return (ret); +} + +int +_pthread_cond_signal(pthread_cond_t *cond) { int rval = 0; pthread_t pthread; @@ -505,7 +536,8 @@ _pthread_cond_signal(pthread_cond_t * cond) * If the condition variable is statically initialized, perform dynamic * initialization. */ - else if (*cond != NULL || (rval = pthread_cond_init(cond, NULL)) == 0) { + else if (*cond != NULL || + (rval = _pthread_cond_init(cond, NULL)) == 0) { /* * Defer signals to protect the scheduling queues * from access by the signal handler: @@ -556,7 +588,7 @@ _pthread_cond_signal(pthread_cond_t * cond) } int -_pthread_cond_broadcast(pthread_cond_t * cond) +_pthread_cond_broadcast(pthread_cond_t *cond) { int rval = 0; pthread_t pthread; @@ -567,7 +599,8 @@ _pthread_cond_broadcast(pthread_cond_t * cond) * If the condition variable is statically initialized, perform dynamic * initialization. */ - else if (*cond != NULL || (rval = pthread_cond_init(cond, NULL)) == 0) { + else if (*cond != NULL || + (rval = _pthread_cond_init(cond, NULL)) == 0) { /* * Defer signals to protect the scheduling queues * from access by the signal handler: diff --git a/lib/libc_r/uthread/uthread_condattr_init.c b/lib/libc_r/uthread/uthread_condattr_init.c index cfc1e4a..92ce709 100644 --- a/lib/libc_r/uthread/uthread_condattr_init.c +++ b/lib/libc_r/uthread/uthread_condattr_init.c @@ -39,6 +39,8 @@ __weak_reference(_pthread_condattr_init, pthread_condattr_init); +static struct pthread_cond_attr default_condattr = PTHREAD_CONDATTR_DEFAULT; + int _pthread_condattr_init(pthread_condattr_t *attr) { @@ -46,11 +48,11 @@ _pthread_condattr_init(pthread_condattr_t *attr) pthread_condattr_t pattr; if ((pattr = (pthread_condattr_t) - malloc(sizeof(struct pthread_cond_attr))) == NULL) { + malloc(sizeof(struct pthread_cond_attr))) == NULL) { ret = ENOMEM; } else { - memcpy(pattr, &pthread_condattr_default, - sizeof(struct pthread_cond_attr)); + memcpy(pattr, &default_condattr, + sizeof(struct pthread_cond_attr)); *attr = pattr; ret = 0; } diff --git a/lib/libc_r/uthread/uthread_create.c b/lib/libc_r/uthread/uthread_create.c index 6769428..d101721 100644 --- a/lib/libc_r/uthread/uthread_create.c +++ b/lib/libc_r/uthread/uthread_create.c @@ -39,7 +39,10 @@ #include #include #include +#include "namespace.h" #include +#include "un-namespace.h" + #include "pthread_private.h" #include "libc_private.h" @@ -88,7 +91,7 @@ _pthread_create(pthread_t *thread, const pthread_attr_t *attr, /* Check if default thread attributes are required: */ if (attr == NULL || *attr == NULL) { /* Use the default thread attributes: */ - pattr = &pthread_attr_default; + pattr = &_pthread_attr_default; } else { pattr = *attr; } @@ -244,8 +247,8 @@ _pthread_create(pthread_t *thread, const pthread_attr_t *attr, * Start a garbage collector thread * if necessary. */ - if (f_gc && pthread_create(&gc_thread,NULL, - _thread_gc,NULL) != 0) + if (f_gc && _pthread_create(&gc_thread, NULL, + _thread_gc, NULL) != 0) PANIC("Can't create gc thread"); } @@ -264,7 +267,7 @@ _thread_start(void) _thread_kern_in_sched = 0; /* Run the current thread's start routine with argument: */ - pthread_exit(curthread->start_routine(curthread->arg)); + _pthread_exit(curthread->start_routine(curthread->arg)); /* This point should never be reached. */ PANIC("Thread has resumed after exit"); diff --git a/lib/libc_r/uthread/uthread_exit.c b/lib/libc_r/uthread/uthread_exit.c index 8af1c1f..d9b497c 100644 --- a/lib/libc_r/uthread/uthread_exit.c +++ b/lib/libc_r/uthread/uthread_exit.c @@ -37,12 +37,11 @@ #include #include #include +#include "namespace.h" #include +#include "un-namespace.h" #include "pthread_private.h" -#define FLAGS_IN_SCHEDQ \ - (PTHREAD_FLAGS_IN_PRIOQ|PTHREAD_FLAGS_IN_WAITQ|PTHREAD_FLAGS_IN_WORKQ) - __weak_reference(_pthread_exit, pthread_exit); void _exit(int status) @@ -173,7 +172,7 @@ _pthread_exit(void *status) * Lock the garbage collector mutex to ensure that the garbage * collector is not using the dead thread list. */ - if (pthread_mutex_lock(&_gc_mutex) != 0) + if (_pthread_mutex_lock(&_gc_mutex) != 0) PANIC("Cannot lock gc mutex"); /* Add this thread to the list of dead threads. */ @@ -183,7 +182,7 @@ _pthread_exit(void *status) * Signal the garbage collector thread that there is something * to clean up. */ - if (pthread_cond_signal(&_gc_cond) != 0) + if (_pthread_cond_signal(&_gc_cond) != 0) PANIC("Cannot signal gc cond"); /* @@ -194,7 +193,7 @@ _pthread_exit(void *status) _thread_kern_sig_defer(); /* Unlock the garbage collector mutex: */ - if (pthread_mutex_unlock(&_gc_mutex) != 0) + if (_pthread_mutex_unlock(&_gc_mutex) != 0) PANIC("Cannot unlock gc mutex"); /* Check if there is a thread joining this one: */ diff --git a/lib/libc_r/uthread/uthread_gc.c b/lib/libc_r/uthread/uthread_gc.c index 9c93028..cdc5fa7 100644 --- a/lib/libc_r/uthread/uthread_gc.c +++ b/lib/libc_r/uthread/uthread_gc.c @@ -40,7 +40,9 @@ #include #include #include +#include "namespace.h" #include +#include "un-namespace.h" #include "pthread_private.h" pthread_addr_t @@ -58,7 +60,7 @@ _thread_gc(pthread_addr_t arg) /* Block all signals */ sigfillset(&mask); - pthread_sigmask(SIG_BLOCK, &mask, NULL); + _pthread_sigmask(SIG_BLOCK, &mask, NULL); /* Mark this thread as a library thread (not a user thread). */ curthread->flags |= PTHREAD_FLAGS_PRIVATE; @@ -104,7 +106,7 @@ _thread_gc(pthread_addr_t arg) * Lock the garbage collector mutex which ensures that * this thread sees another thread exit: */ - if (pthread_mutex_lock(&_gc_mutex) != 0) + if (_pthread_mutex_lock(&_gc_mutex) != 0) PANIC("Cannot lock gc mutex"); /* @@ -187,13 +189,13 @@ _thread_gc(pthread_addr_t arg) * Wait for a signal from a dying thread or a * timeout (for a backup poll). */ - if ((ret = pthread_cond_timedwait(&_gc_cond, + if ((ret = _pthread_cond_timedwait(&_gc_cond, &_gc_mutex, &abstime)) != 0 && ret != ETIMEDOUT) PANIC("gc cannot wait for a signal"); } /* Unlock the garbage collector mutex: */ - if (pthread_mutex_unlock(&_gc_mutex) != 0) + if (_pthread_mutex_unlock(&_gc_mutex) != 0) PANIC("Cannot unlock gc mutex"); /* diff --git a/lib/libc_r/uthread/uthread_init.c b/lib/libc_r/uthread/uthread_init.c index fd4aef4..d1d116e 100644 --- a/lib/libc_r/uthread/uthread_init.c +++ b/lib/libc_r/uthread/uthread_init.c @@ -58,6 +58,7 @@ #include #include #include +#include #include #include #include @@ -65,11 +66,16 @@ #include #include "un-namespace.h" +#include "libc_private.h" #include "pthread_private.h" +int __pthread_cond_wait(pthread_cond_t *, pthread_mutex_t *); +int __pthread_mutex_lock(pthread_mutex_t *); +int __pthread_mutex_trylock(pthread_mutex_t *); + /* * All weak references used within libc should be in this table. - * This will is so that static libraries will work. + * This allows static libraries to work. */ static void *references[] = { &_accept, @@ -96,6 +102,10 @@ static void *references[] = { &_listen, &_nanosleep, &_open, + &_pthread_cond_destroy, + &_pthread_cond_init, + &_pthread_cond_signal, + &_pthread_cond_wait, &_pthread_getspecific, &_pthread_key_create, &_pthread_key_delete, @@ -129,9 +139,9 @@ static void *references[] = { /* * These are needed when linking statically. All references within - * libgcc (and in the future libc) to these routines are weak, but - * if they are not (strongly) referenced by the application or other - * libraries, then the actual functions will not be loaded. + * libgcc (and libc) to these routines are weak, but if they are not + * (strongly) referenced by the application or other libraries, then + * the actual functions will not be loaded. */ static void *libgcc_references[] = { &_pthread_once, @@ -146,6 +156,43 @@ static void *libgcc_references[] = { &_pthread_mutex_unlock }; +#define DUAL_ENTRY(entry) \ + (pthread_func_t)entry, (pthread_func_t)entry + +static pthread_func_t jmp_table[][2] = { + {DUAL_ENTRY(_pthread_cond_broadcast)}, /* PJT_COND_BROADCAST */ + {DUAL_ENTRY(_pthread_cond_destroy)}, /* PJT_COND_DESTROY */ + {DUAL_ENTRY(_pthread_cond_init)}, /* PJT_COND_INIT */ + {DUAL_ENTRY(_pthread_cond_signal)}, /* PJT_COND_SIGNAL */ + {(pthread_func_t)__pthread_cond_wait, + (pthread_func_t)_pthread_cond_wait}, /* PJT_COND_WAIT */ + {DUAL_ENTRY(_pthread_getspecific)}, /* PJT_GETSPECIFIC */ + {DUAL_ENTRY(_pthread_key_create)}, /* PJT_KEY_CREATE */ + {DUAL_ENTRY(_pthread_key_delete)}, /* PJT_KEY_DELETE*/ + {DUAL_ENTRY(_pthread_main_np)}, /* PJT_MAIN_NP */ + {DUAL_ENTRY(_pthread_mutex_destroy)}, /* PJT_MUTEX_DESTROY */ + {DUAL_ENTRY(_pthread_mutex_init)}, /* PJT_MUTEX_INIT */ + {(pthread_func_t)__pthread_mutex_lock, + (pthread_func_t)_pthread_mutex_lock}, /* PJT_MUTEX_LOCK */ + {(pthread_func_t)__pthread_mutex_trylock, + (pthread_func_t)_pthread_mutex_trylock},/* PJT_MUTEX_TRYLOCK */ + {DUAL_ENTRY(_pthread_mutex_unlock)}, /* PJT_MUTEX_UNLOCK */ + {DUAL_ENTRY(_pthread_mutexattr_destroy)}, /* PJT_MUTEXATTR_DESTROY */ + {DUAL_ENTRY(_pthread_mutexattr_init)}, /* PJT_MUTEXATTR_INIT */ + {DUAL_ENTRY(_pthread_mutexattr_settype)}, /* PJT_MUTEXATTR_SETTYPE */ + {DUAL_ENTRY(_pthread_once)}, /* PJT_ONCE */ + {DUAL_ENTRY(_pthread_rwlock_destroy)}, /* PJT_RWLOCK_DESTROY */ + {DUAL_ENTRY(_pthread_rwlock_init)}, /* PJT_RWLOCK_INIT */ + {DUAL_ENTRY(_pthread_rwlock_rdlock)}, /* PJT_RWLOCK_RDLOCK */ + {DUAL_ENTRY(_pthread_rwlock_tryrdlock)},/* PJT_RWLOCK_TRYRDLOCK */ + {DUAL_ENTRY(_pthread_rwlock_trywrlock)},/* PJT_RWLOCK_TRYWRLOCK */ + {DUAL_ENTRY(_pthread_rwlock_unlock)}, /* PJT_RWLOCK_UNLOCK */ + {DUAL_ENTRY(_pthread_rwlock_wrlock)}, /* PJT_RWLOCK_WRLOCK */ + {DUAL_ENTRY(_pthread_self)}, /* PJT_SELF */ + {DUAL_ENTRY(_pthread_setspecific)}, /* PJT_SETSPECIFIC */ + {DUAL_ENTRY(_pthread_sigmask)} /* PJT_SIGMASK */ +}; + int _pthread_guard_default; int _pthread_page_size; @@ -165,18 +212,18 @@ _thread_init(void) struct clockinfo clockinfo; struct sigaction act; - _pthread_page_size = getpagesize(); - _pthread_guard_default = getpagesize(); - sched_stack_size = getpagesize(); - - pthread_attr_default.guardsize_attr = _pthread_guard_default; - /* Check if this function has already been called: */ if (_thread_initial) /* Only initialise the threaded application once. */ return; + _pthread_page_size = getpagesize();; + _pthread_guard_default = _pthread_page_size; + sched_stack_size = _pthread_page_size; + + _pthread_attr_default.guardsize_attr = _pthread_guard_default; + /* * Make gcc quiescent about {,libgcc_}references not being * referenced: @@ -185,6 +232,14 @@ _thread_init(void) PANIC("Failed loading mandatory references in _thread_init"); /* + * Check the size of the jump table to make sure it is preset + * with the correct number of entries. + */ + if (sizeof(jmp_table) != (sizeof(pthread_func_t) * PJT_MAX * 2)) + PANIC("Thread jump table not properly initialized"); + memcpy(__thr_jtable, jmp_table, sizeof(jmp_table)); + + /* * Check for the special case of this process running as * or in place of init as pid = 1: */ @@ -288,7 +343,7 @@ _thread_init(void) _sched_switch_hook = NULL; /* Give this thread default attributes: */ - memcpy((void *) &_thread_initial->attr, &pthread_attr_default, + memcpy((void *) &_thread_initial->attr, &_pthread_attr_default, sizeof(struct pthread_attr)); /* Find the stack top */ @@ -480,10 +535,11 @@ _thread_init(void) /* Initialise the garbage collector mutex and condition variable. */ if (_pthread_mutex_init(&_gc_mutex,NULL) != 0 || - pthread_cond_init(&_gc_cond,NULL) != 0) + _pthread_cond_init(&_gc_cond,NULL) != 0) PANIC("Failed to initialise garbage collector mutex or condvar"); } + /* * Special start up code for NetBSD/Alpha */ diff --git a/lib/libc_r/uthread/uthread_join.c b/lib/libc_r/uthread/uthread_join.c index 0f5e8fc..75ec1f0 100644 --- a/lib/libc_r/uthread/uthread_join.c +++ b/lib/libc_r/uthread/uthread_join.c @@ -32,7 +32,9 @@ * $FreeBSD$ */ #include +#include "namespace.h" #include +#include "un-namespace.h" #include "pthread_private.h" __weak_reference(_pthread_join, pthread_join); @@ -64,7 +66,7 @@ _pthread_join(pthread_t pthread, void **thread_return) * Lock the garbage collector mutex to ensure that the garbage * collector is not using the dead thread list. */ - if (pthread_mutex_lock(&_gc_mutex) != 0) + if (_pthread_mutex_lock(&_gc_mutex) != 0) PANIC("Cannot lock gc mutex"); /* @@ -77,7 +79,7 @@ _pthread_join(pthread_t pthread, void **thread_return) * Unlock the garbage collector mutex, now that the garbage collector * can't be run: */ - if (pthread_mutex_unlock(&_gc_mutex) != 0) + if (_pthread_mutex_unlock(&_gc_mutex) != 0) PANIC("Cannot lock gc mutex"); /* diff --git a/lib/libc_r/uthread/uthread_mattr_init.c b/lib/libc_r/uthread/uthread_mattr_init.c index e4e2e50..5e4af71 100644 --- a/lib/libc_r/uthread/uthread_mattr_init.c +++ b/lib/libc_r/uthread/uthread_mattr_init.c @@ -39,6 +39,8 @@ __weak_reference(_pthread_mutexattr_init, pthread_mutexattr_init); +static struct pthread_mutex_attr default_mutexattr = PTHREAD_MUTEXATTR_DEFAULT; + int _pthread_mutexattr_init(pthread_mutexattr_t *attr) { @@ -49,10 +51,10 @@ _pthread_mutexattr_init(pthread_mutexattr_t *attr) malloc(sizeof(struct pthread_mutex_attr))) == NULL) { ret = ENOMEM; } else { - memcpy(pattr, &pthread_mutexattr_default, - sizeof(struct pthread_mutex_attr)); + memcpy(pattr, &default_mutexattr, + sizeof(struct pthread_mutex_attr)); *attr = pattr; ret = 0; } - return(ret); + return (ret); } diff --git a/lib/libc_r/uthread/uthread_mutex.c b/lib/libc_r/uthread/uthread_mutex.c index 7951815..dc94d45 100644 --- a/lib/libc_r/uthread/uthread_mutex.c +++ b/lib/libc_r/uthread/uthread_mutex.c @@ -88,7 +88,9 @@ __weak_reference(_pthread_mutex_destroy, pthread_mutex_destroy); __weak_reference(_pthread_mutex_unlock, pthread_mutex_unlock); -/* Reinitialize a mutex to defaults. */ +/* + * Reinitialize a private mutex; this is only used for internal mutexes. + */ int _mutex_reinit(pthread_mutex_t * mutex) { @@ -97,7 +99,7 @@ _mutex_reinit(pthread_mutex_t * mutex) if (mutex == NULL) ret = EINVAL; else if (*mutex == NULL) - ret = pthread_mutex_init(mutex, NULL); + ret = _pthread_mutex_init(mutex, NULL); else { /* * Initialize the mutex structure: @@ -107,8 +109,7 @@ _mutex_reinit(pthread_mutex_t * mutex) TAILQ_INIT(&(*mutex)->m_queue); (*mutex)->m_owner = NULL; (*mutex)->m_data.m_count = 0; - (*mutex)->m_flags &= MUTEX_FLAGS_PRIVATE; - (*mutex)->m_flags |= MUTEX_FLAGS_INITED; + (*mutex)->m_flags |= MUTEX_FLAGS_INITED | MUTEX_FLAGS_PRIVATE; (*mutex)->m_refcount = 0; (*mutex)->m_prio = 0; (*mutex)->m_saved_prio = 0; @@ -133,7 +134,7 @@ _pthread_mutex_init(pthread_mutex_t * mutex, ret = EINVAL; /* Check if default mutex attributes: */ - else if (mutex_attr == NULL || *mutex_attr == NULL) { + if (mutex_attr == NULL || *mutex_attr == NULL) { /* Default to a (error checking) POSIX mutex: */ type = PTHREAD_MUTEX_ERRORCHECK; protocol = PTHREAD_PRIO_NONE; @@ -213,7 +214,7 @@ _pthread_mutex_init(pthread_mutex_t * mutex, } } /* Return the completion status: */ - return(ret); + return (ret); } int @@ -272,7 +273,7 @@ init_static(pthread_mutex_t *mutex) _SPINUNLOCK(&static_init_lock); - return(ret); + return (ret); } static int @@ -289,7 +290,7 @@ init_static_private(pthread_mutex_t *mutex) _SPINUNLOCK(&static_init_lock); - return(ret); + return (ret); } static int @@ -759,7 +760,7 @@ int _mutex_cv_lock(pthread_mutex_t * mutex) { int ret; - if ((ret = pthread_mutex_lock(mutex)) == 0) + if ((ret = _pthread_mutex_lock(mutex)) == 0) (*mutex)->m_refcount--; return (ret); } @@ -791,7 +792,7 @@ mutex_self_trylock(pthread_mutex_t mutex) ret = EINVAL; } - return(ret); + return (ret); } static inline int @@ -828,7 +829,7 @@ mutex_self_lock(pthread_mutex_t mutex) ret = EINVAL; } - return(ret); + return (ret); } static inline int @@ -1445,7 +1446,7 @@ _mutex_unlock_private(pthread_t pthread) for (m = TAILQ_FIRST(&pthread->mutexq); m != NULL; m = m_next) { m_next = TAILQ_NEXT(m, m_qe); if ((m->m_flags & MUTEX_FLAGS_PRIVATE) != 0) - pthread_mutex_unlock(&m); + _pthread_mutex_unlock(&m); } } @@ -1502,7 +1503,7 @@ mutex_queue_deq(pthread_mutex_t mutex) break; } - return(pthread); + return (pthread); } /* diff --git a/lib/libc_r/uthread/uthread_mutex_prioceiling.c b/lib/libc_r/uthread/uthread_mutex_prioceiling.c index 2682abc..eccc9e4 100644 --- a/lib/libc_r/uthread/uthread_mutex_prioceiling.c +++ b/lib/libc_r/uthread/uthread_mutex_prioceiling.c @@ -34,7 +34,9 @@ #include #include #include +#include "namespace.h" #include +#include "un-namespace.h" #include "pthread_private.h" __weak_reference(_pthread_mutexattr_getprioceiling, pthread_mutexattr_getprioceiling); @@ -100,13 +102,13 @@ _pthread_mutex_setprioceiling(pthread_mutex_t *mutex, ret = EINVAL; else { /* Lock the mutex: */ - if ((ret = pthread_mutex_lock(mutex)) == 0) { + if ((ret = _pthread_mutex_lock(mutex)) == 0) { /* Return the old ceiling and set the new ceiling: */ *old_ceiling = (*mutex)->m_prio; (*mutex)->m_prio = prioceiling; /* Unlock the mutex: */ - ret = pthread_mutex_unlock(mutex); + ret = _pthread_mutex_unlock(mutex); } } return(ret); diff --git a/lib/libc_r/uthread/uthread_once.c b/lib/libc_r/uthread/uthread_once.c index 20e2904..1815f2a 100644 --- a/lib/libc_r/uthread/uthread_once.c +++ b/lib/libc_r/uthread/uthread_once.c @@ -31,7 +31,9 @@ * * $FreeBSD$ */ +#include "namespace.h" #include +#include "un-namespace.h" #include "pthread_private.h" __weak_reference(_pthread_once, pthread_once); @@ -42,12 +44,12 @@ _pthread_once(pthread_once_t * once_control, void (*init_routine) (void)) if (once_control->state == PTHREAD_NEEDS_INIT) { if (_thread_initial == NULL) _thread_init(); - pthread_mutex_lock(&(once_control->mutex)); + _pthread_mutex_lock(&(once_control->mutex)); if (once_control->state == PTHREAD_NEEDS_INIT) { init_routine(); once_control->state = PTHREAD_DONE_INIT; } - pthread_mutex_unlock(&(once_control->mutex)); + _pthread_mutex_unlock(&(once_control->mutex)); } return (0); } diff --git a/lib/libc_r/uthread/uthread_pselect.c b/lib/libc_r/uthread/uthread_pselect.c index 5a3d378..9848863 100644 --- a/lib/libc_r/uthread/uthread_pselect.c +++ b/lib/libc_r/uthread/uthread_pselect.c @@ -40,8 +40,10 @@ __FBSDID("$FreeBSD$"); extern int __pselect(int count, fd_set *rfds, fd_set *wfds, fd_set *efds, const struct timespec *timo, const sigset_t *mask); +__weak_reference(_pselect, pselect); + int -pselect(int count, fd_set *rfds, fd_set *wfds, fd_set *efds, +_pselect(int count, fd_set *rfds, fd_set *wfds, fd_set *efds, const struct timespec *timo, const sigset_t *mask) { int ret; diff --git a/lib/libc_r/uthread/uthread_rwlock.c b/lib/libc_r/uthread/uthread_rwlock.c index 2f55f03..09a84f2 100644 --- a/lib/libc_r/uthread/uthread_rwlock.c +++ b/lib/libc_r/uthread/uthread_rwlock.c @@ -30,7 +30,10 @@ #include #include +#include "namespace.h" #include +#include "un-namespace.h" + #include "pthread_private.h" /* maximum number of times a read lock may be obtained */ @@ -56,7 +59,7 @@ init_static (pthread_rwlock_t *rwlock) _SPINLOCK(&static_init_lock); if (*rwlock == NULL) - ret = pthread_rwlock_init(rwlock, NULL); + ret = _pthread_rwlock_init(rwlock, NULL); else ret = 0; @@ -77,9 +80,9 @@ _pthread_rwlock_destroy (pthread_rwlock_t *rwlock) prwlock = *rwlock; - pthread_mutex_destroy(&prwlock->lock); - pthread_cond_destroy(&prwlock->read_signal); - pthread_cond_destroy(&prwlock->write_signal); + _pthread_mutex_destroy(&prwlock->lock); + _pthread_cond_destroy(&prwlock->read_signal); + _pthread_cond_destroy(&prwlock->write_signal); free(prwlock); *rwlock = NULL; @@ -103,22 +106,22 @@ _pthread_rwlock_init (pthread_rwlock_t *rwlock, const pthread_rwlockattr_t *attr return(ENOMEM); /* initialize the lock */ - if ((ret = pthread_mutex_init(&prwlock->lock, NULL)) != 0) + if ((ret = _pthread_mutex_init(&prwlock->lock, NULL)) != 0) free(prwlock); else { /* initialize the read condition signal */ - ret = pthread_cond_init(&prwlock->read_signal, NULL); + ret = _pthread_cond_init(&prwlock->read_signal, NULL); if (ret != 0) { - pthread_mutex_destroy(&prwlock->lock); + _pthread_mutex_destroy(&prwlock->lock); free(prwlock); } else { /* initialize the write condition signal */ - ret = pthread_cond_init(&prwlock->write_signal, NULL); + ret = _pthread_cond_init(&prwlock->write_signal, NULL); if (ret != 0) { - pthread_cond_destroy(&prwlock->read_signal); - pthread_mutex_destroy(&prwlock->lock); + _pthread_cond_destroy(&prwlock->read_signal); + _pthread_mutex_destroy(&prwlock->lock); free(prwlock); } else { /* success */ @@ -153,16 +156,16 @@ _pthread_rwlock_rdlock (pthread_rwlock_t *rwlock) } /* grab the monitor lock */ - if ((ret = pthread_mutex_lock(&prwlock->lock)) != 0) + if ((ret = _pthread_mutex_lock(&prwlock->lock)) != 0) return(ret); /* give writers priority over readers */ while (prwlock->blocked_writers || prwlock->state < 0) { - ret = pthread_cond_wait(&prwlock->read_signal, &prwlock->lock); + ret = _pthread_cond_wait(&prwlock->read_signal, &prwlock->lock); if (ret != 0) { /* can't do a whole lot if this fails */ - pthread_mutex_unlock(&prwlock->lock); + _pthread_mutex_unlock(&prwlock->lock); return(ret); } } @@ -179,7 +182,7 @@ _pthread_rwlock_rdlock (pthread_rwlock_t *rwlock) * lock. Decrementing 'state' is no good because we probably * don't have the monitor lock. */ - pthread_mutex_unlock(&prwlock->lock); + _pthread_mutex_unlock(&prwlock->lock); return(ret); } @@ -204,7 +207,7 @@ _pthread_rwlock_tryrdlock (pthread_rwlock_t *rwlock) } /* grab the monitor lock */ - if ((ret = pthread_mutex_lock(&prwlock->lock)) != 0) + if ((ret = _pthread_mutex_lock(&prwlock->lock)) != 0) return(ret); /* give writers priority over readers */ @@ -216,7 +219,7 @@ _pthread_rwlock_tryrdlock (pthread_rwlock_t *rwlock) ++prwlock->state; /* indicate we are locked for reading */ /* see the comment on this in pthread_rwlock_rdlock */ - pthread_mutex_unlock(&prwlock->lock); + _pthread_mutex_unlock(&prwlock->lock); return(ret); } @@ -241,7 +244,7 @@ _pthread_rwlock_trywrlock (pthread_rwlock_t *rwlock) } /* grab the monitor lock */ - if ((ret = pthread_mutex_lock(&prwlock->lock)) != 0) + if ((ret = _pthread_mutex_lock(&prwlock->lock)) != 0) return(ret); if (prwlock->state != 0) @@ -251,7 +254,7 @@ _pthread_rwlock_trywrlock (pthread_rwlock_t *rwlock) prwlock->state = -1; /* see the comment on this in pthread_rwlock_rdlock */ - pthread_mutex_unlock(&prwlock->lock); + _pthread_mutex_unlock(&prwlock->lock); return(ret); } @@ -271,24 +274,24 @@ _pthread_rwlock_unlock (pthread_rwlock_t *rwlock) return(EINVAL); /* grab the monitor lock */ - if ((ret = pthread_mutex_lock(&prwlock->lock)) != 0) + if ((ret = _pthread_mutex_lock(&prwlock->lock)) != 0) return(ret); if (prwlock->state > 0) { if (--prwlock->state == 0 && prwlock->blocked_writers) - ret = pthread_cond_signal(&prwlock->write_signal); + ret = _pthread_cond_signal(&prwlock->write_signal); } else if (prwlock->state < 0) { prwlock->state = 0; if (prwlock->blocked_writers) - ret = pthread_cond_signal(&prwlock->write_signal); + ret = _pthread_cond_signal(&prwlock->write_signal); else - ret = pthread_cond_broadcast(&prwlock->read_signal); + ret = _pthread_cond_broadcast(&prwlock->read_signal); } else ret = EINVAL; /* see the comment on this in pthread_rwlock_rdlock */ - pthread_mutex_unlock(&prwlock->lock); + _pthread_mutex_unlock(&prwlock->lock); return(ret); } @@ -313,17 +316,17 @@ _pthread_rwlock_wrlock (pthread_rwlock_t *rwlock) } /* grab the monitor lock */ - if ((ret = pthread_mutex_lock(&prwlock->lock)) != 0) + if ((ret = _pthread_mutex_lock(&prwlock->lock)) != 0) return(ret); while (prwlock->state != 0) { ++prwlock->blocked_writers; - ret = pthread_cond_wait(&prwlock->write_signal, &prwlock->lock); + ret = _pthread_cond_wait(&prwlock->write_signal, &prwlock->lock); if (ret != 0) { --prwlock->blocked_writers; - pthread_mutex_unlock(&prwlock->lock); + _pthread_mutex_unlock(&prwlock->lock); return(ret); } @@ -334,7 +337,7 @@ _pthread_rwlock_wrlock (pthread_rwlock_t *rwlock) prwlock->state = -1; /* see the comment on this in pthread_rwlock_rdlock */ - pthread_mutex_unlock(&prwlock->lock); + _pthread_mutex_unlock(&prwlock->lock); return(ret); } diff --git a/lib/libc_r/uthread/uthread_sem.c b/lib/libc_r/uthread/uthread_sem.c index 851eca2..f85bb91 100644 --- a/lib/libc_r/uthread/uthread_sem.c +++ b/lib/libc_r/uthread/uthread_sem.c @@ -32,7 +32,9 @@ #include #include #include +#include "namespace.h" #include +#include "un-namespace.h" #include "pthread_private.h" #define _SEM_CHECK_VALIDITY(sem) \ @@ -88,15 +90,15 @@ _sem_init(sem_t *sem, int pshared, unsigned int value) /* * Initialize the semaphore. */ - if (pthread_mutex_init(&(*sem)->lock, NULL) != 0) { + if (_pthread_mutex_init(&(*sem)->lock, NULL) != 0) { free(*sem); errno = ENOSPC; retval = -1; goto RETURN; } - if (pthread_cond_init(&(*sem)->gtzero, NULL) != 0) { - pthread_mutex_destroy(&(*sem)->lock); + if (_pthread_cond_init(&(*sem)->gtzero, NULL) != 0) { + _pthread_mutex_destroy(&(*sem)->lock); free(*sem); errno = ENOSPC; retval = -1; @@ -120,17 +122,17 @@ _sem_destroy(sem_t *sem) _SEM_CHECK_VALIDITY(sem); /* Make sure there are no waiters. */ - pthread_mutex_lock(&(*sem)->lock); + _pthread_mutex_lock(&(*sem)->lock); if ((*sem)->nwaiters > 0) { - pthread_mutex_unlock(&(*sem)->lock); + _pthread_mutex_unlock(&(*sem)->lock); errno = EBUSY; retval = -1; goto RETURN; } - pthread_mutex_unlock(&(*sem)->lock); + _pthread_mutex_unlock(&(*sem)->lock); - pthread_mutex_destroy(&(*sem)->lock); - pthread_cond_destroy(&(*sem)->gtzero); + _pthread_mutex_destroy(&(*sem)->lock); + _pthread_cond_destroy(&(*sem)->gtzero); (*sem)->magic = 0; free(*sem); @@ -170,16 +172,16 @@ _sem_wait(sem_t *sem) _SEM_CHECK_VALIDITY(sem); - pthread_mutex_lock(&(*sem)->lock); + _pthread_mutex_lock(&(*sem)->lock); while ((*sem)->count == 0) { (*sem)->nwaiters++; - pthread_cond_wait(&(*sem)->gtzero, &(*sem)->lock); + _pthread_cond_wait(&(*sem)->gtzero, &(*sem)->lock); (*sem)->nwaiters--; } (*sem)->count--; - pthread_mutex_unlock(&(*sem)->lock); + _pthread_mutex_unlock(&(*sem)->lock); retval = 0; RETURN: @@ -194,7 +196,7 @@ _sem_trywait(sem_t *sem) _SEM_CHECK_VALIDITY(sem); - pthread_mutex_lock(&(*sem)->lock); + _pthread_mutex_lock(&(*sem)->lock); if ((*sem)->count > 0) { (*sem)->count--; @@ -204,7 +206,7 @@ _sem_trywait(sem_t *sem) retval = -1; } - pthread_mutex_unlock(&(*sem)->lock); + _pthread_mutex_unlock(&(*sem)->lock); RETURN: return retval; @@ -223,13 +225,13 @@ _sem_post(sem_t *sem) */ _thread_kern_sig_defer(); - pthread_mutex_lock(&(*sem)->lock); + _pthread_mutex_lock(&(*sem)->lock); (*sem)->count++; if ((*sem)->nwaiters > 0) - pthread_cond_signal(&(*sem)->gtzero); + _pthread_cond_signal(&(*sem)->gtzero); - pthread_mutex_unlock(&(*sem)->lock); + _pthread_mutex_unlock(&(*sem)->lock); _thread_kern_sig_undefer(); retval = 0; @@ -244,9 +246,9 @@ _sem_getvalue(sem_t *sem, int *sval) _SEM_CHECK_VALIDITY(sem); - pthread_mutex_lock(&(*sem)->lock); + _pthread_mutex_lock(&(*sem)->lock); *sval = (int)(*sem)->count; - pthread_mutex_unlock(&(*sem)->lock); + _pthread_mutex_unlock(&(*sem)->lock); retval = 0; RETURN: diff --git a/lib/libc_r/uthread/uthread_sig.c b/lib/libc_r/uthread/uthread_sig.c index cf319c6..5e3c9b9 100644 --- a/lib/libc_r/uthread/uthread_sig.c +++ b/lib/libc_r/uthread/uthread_sig.c @@ -35,10 +35,11 @@ #include #include #include +#include #include #include #include -#include +#include #include #include "pthread_private.h" diff --git a/lib/libc_r/uthread/uthread_stack.c b/lib/libc_r/uthread/uthread_stack.c index 80c9d53..63fa4cd 100644 --- a/lib/libc_r/uthread/uthread_stack.c +++ b/lib/libc_r/uthread/uthread_stack.c @@ -26,6 +26,7 @@ * * $FreeBSD$ */ +#include "namespace.h" #include #include #include @@ -33,6 +34,8 @@ #include #include #include +#include "un-namespace.h" + #include "pthread_private.h" /* Spare thread stack. */ @@ -144,7 +147,7 @@ _thread_stack_alloc(size_t stacksize, size_t guardsize) * Use the garbage collector mutex for synchronization of the * spare stack list. */ - if (pthread_mutex_lock(&_gc_mutex) != 0) + if (_pthread_mutex_lock(&_gc_mutex) != 0) PANIC("Cannot lock gc mutex"); if ((spare_stack = LIST_FIRST(&_dstackq)) != NULL) { @@ -154,7 +157,7 @@ _thread_stack_alloc(size_t stacksize, size_t guardsize) } /* Unlock the garbage collector mutex. */ - if (pthread_mutex_unlock(&_gc_mutex) != 0) + if (_pthread_mutex_unlock(&_gc_mutex) != 0) PANIC("Cannot unlock gc mutex"); } /* @@ -167,7 +170,7 @@ _thread_stack_alloc(size_t stacksize, size_t guardsize) * Use the garbage collector mutex for synchronization of the * spare stack list. */ - if (pthread_mutex_lock(&_gc_mutex) != 0) + if (_pthread_mutex_lock(&_gc_mutex) != 0) PANIC("Cannot lock gc mutex"); LIST_FOREACH(spare_stack, &_mstackq, qe) { @@ -180,7 +183,7 @@ _thread_stack_alloc(size_t stacksize, size_t guardsize) } /* Unlock the garbage collector mutex. */ - if (pthread_mutex_unlock(&_gc_mutex) != 0) + if (_pthread_mutex_unlock(&_gc_mutex) != 0) PANIC("Cannot unlock gc mutex"); } -- cgit v1.1