diff options
Diffstat (limited to 'pthread.h')
| -rw-r--r-- | pthread.h | 1041 |
1 files changed, 819 insertions, 222 deletions
@@ -1,33 +1,199 @@ /* This is the POSIX thread API (POSIX 1003). - -This 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. - -This 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 this library; if not, write to the Free Software -Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. -*/ - -/* FIXME: do not include function prototypes for functions which are - not yet implemented. This will allow us to keep a better handle on - where we're at. */ - -#ifndef _PTHREADS_H -#define _PTHREADS_H - -/* Convert these to defined when implemented. */ -#define _POSIX_THREAD_ATTR_STACKSIZE -#ifdef _POSIX_THREAD_ATTR_STACKADDR -#undef _POSIX_THREAD_ATTR_STACKADDR + * + * This 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. + * + * This 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 this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + +/* + * ------------------------------------------------------------- + * + * + * Module: pthread.h + * + * Purpose: + * Provides an implementation of PThreads based upon the + * standard: + * + * POSIX 1003.1c-1995 (POSIX.1c) + * + * Authors: + * Contributors are listed in the file "MAINTAINERS". + * + * The following functions are implemented: + * --------------------------- + * PThreads + * --------------------------- + * pthread_attr_init + * pthread_attr_destroy + * pthread_attr_getdetachstate + * pthread_attr_getstackaddr + * pthread_attr_getstacksize + * pthread_attr_setdetachstate + * pthread_attr_setstackaddr + * pthread_attr_setstacksize + * + * pthread_create + * pthread_detach + * pthread_equal + * pthread_exit + * pthread_join + * pthread_self + * sched_yield + * + * pthread_cancel + * pthread_cleanup_pop + * pthread_cleanup_push + * pthread_setcancelstate + * pthread_setcanceltype + * pthread_testcancel + * + * --------------------------- + * Thread Specific Data + * --------------------------- + * pthread_key_create + * pthread_key_delete + * pthread_setspecific + * pthread_getspecific + * + * --------------------------- + * Mutexes + * --------------------------- + * pthread_mutexattr_init + * pthread_mutexattr_destroy + * pthread_mutexattr_getpshared + * pthread_mutexattr_setpshared + * + * pthread_mutex_init + * pthread_mutex_destroy + * pthread_mutex_lock + * pthread_mutex_trylock + * pthread_mutex_unlock + * + * --------------------------- + * Condition Variables + * --------------------------- + * pthread_condattr_init + * pthread_condattr_destroy + * pthread_condattr_getpshared + * pthread_condattr_setpshared + * + * pthread_cond_init + * pthread_cond_destroy + * pthread_cond_wait + * pthread_cond_timedwait + * pthread_cond_signal + * pthread_cond_broadcast + * + * --------------------------- + * Protected Methods + * --------------------------- + * pthreadCancelableWait + * + * --------------------------- + * RealTime Scheduling: + * --------------------------- + * pthread_attr_getschedparam + * pthread_attr_setschedparam + * pthread_getschedparam + * pthread_setschedparam + * sched_get_priority_max + * sched_get_priority_min + * + * --------------------------- + * Signals: + * --------------------------- + * pthread_sigmask + * + * Limitations + * =========== + * The following functions are not implemented: + * + * --------------------------- + * RealTime Scheduling: + * --------------------------- + * pthread_attr_getinheritsched + * pthread_attr_getschedpolicy + * pthread_attr_getscope + * pthread_attr_setinheritsched + * pthread_attr_setschedpolicy + * pthread_attr_setscope + * pthread_mutex_getprioceiling + * pthread_mutex_setprioceiling + * pthread_mutex_attr_getprioceiling + * pthread_mutex_attr_getprotocol + * pthread_mutex_attr_setprioceiling + * pthread_mutex_attr_setprotocol + * + * --------------------------- + * Fork Handlers: + * --------------------------- + * pthread_atfork + * + * --------------------------- + * Stdio: + * --------------------------- + * flockfile + * ftrylockfile + * funlockfile + * getc_unlocked + * getchar_unlocked + * putc_unlocked + * putchar_unlocked + * + * --------------------------- + * Thread-Safe C Runtime Library: + * --------------------------- + * readdir_r + * getgrgid_r + * getgrnam_r + * getpwuid_r + * getpwnam_r + * + * --------------------------- + * Signals: + * --------------------------- + * pthread_kill + * sigtimedwait + * sigwait + * sigwaitinfo + * + * + * ------------------------------------------------------------- + */ +#if !defined( PTHREAD_H ) +#define PTHREAD_H + +#ifdef _WIN32 +/* + * Disable following warnings when including Windows headers + * + * warning C4115: named type definition in parentheses + * warning C4116: unnamed type definition in parentheses + * warning C4127: conditional expression is constant + * warning C4201: nonstandard extension used : nameless struct/union + * warning C4214: nonstandard extension used : bit field types other than int + * warning C4514: unreferenced inline function has been removed + */ +#pragma warning( disable : 4115 4116 4127 4201 4214 4514) #endif +/* + * ----------------- + * autoconf switches + * ----------------- + */ + #if HAVE_CONFIG_H #include "config.h" #endif /* HAVE_CONFIG_H */ @@ -58,299 +224,730 @@ struct timespec { #define SIG_SETMASK 2 #endif /* SIG_SETMASK */ -#define PTHREAD_STACK_MIN 65535 -/* Thread scheduling policies */ +#include <process.h> +#include <errno.h> -#define SCHED_OTHER 0 -#define SCHED_FIFO 1 -#define SCHED_RR 2 - -#define SCHED_MIN SCHED_OTHER -#define SCHED_MAX SCHED_RR +#ifdef _WIN32 +/* + * Re-enable all but 4127, 4514 + */ +#pragma warning( default : 4115 4116 4201 4214) +#endif -/* Cancelation return value. - This value must be neither NULL nor the value of any - pointer to an object in memory. */ -#define PTHREAD_CANCELED ((void *) 1) +#if !defined( TRUE ) +#define TRUE !FALSE +#define FALSE 0 +#endif /* !TRUE */ -#define PTHREAD_MUTEX_INITIALIZER {0 /* ignore internals */ } -#define PTHREAD_ONCE_INIT { 0, PTHREAD_MUTEX_INITIALIZER } -typedef struct _pthread * pthread_t; -typedef struct { - int valid; - CRITICAL_SECTION cs; -} pthread_mutex_t; +#include <semaphore.h> +/* #include <sched.h> /**/ -typedef DWORD pthread_key_t; +#ifdef __cplusplus +extern "C" +{ +#endif /* __cplusplus */ + +/* + * ------------------------------------------------------------- + * + * POSIX 1003.1c-1995 Options + * =========================== + * + * _POSIX_SEMAPHORES + * Semaphores come from POSIX.1b (POSIX 1003.1b-1993) + * rather than from PThreads. This macro indicates + * that POSIX Semaphores are supported: + * sem_destroy + * sem_init + * sem_wait + * sem_trywait + * sem_post + * + * _POSIX_THREADS (set) + * If set, you can use threads + * + * _POSIX_THREAD_ATTR_STACKSIZE (set) + * If set, you can control the size of a thread's + * stack + * pthread_attr_getstacksize + * pthread_attr_setstacksize + * + * _POSIX_THREAD_ATTR_STACKADDR (not set) + * If set, you can allocate and control a thread's + * stack. If not supported, the following functions + * will return ENOSYS, indicating they are not + * supported: + * pthread_attr_getstackaddr + * pthread_attr_setstackaddr + * + * _POSIX_THREAD_PRIORITY_SCHEDULING (not set) + * If set, you can use realtime scheduling. + * Indicates the availability of: + * pthread_attr_getinheritsched + * pthread_attr_getschedparam + * pthread_attr_getschedpolicy + * pthread_attr_getscope + * pthread_attr_setinheritsched + * pthread_attr_setschedparam + * pthread_attr_setschedpolicy + * pthread_attr_setscope + * pthread_getschedparam + * pthread_setschedparam + * pthread_get_priority_max + * pthread_get_priority_min + * + * _POSIX_THREAD_PRIO_INHERIT (not set) + * If set, you can create priority inheritance + * mutexes. + * pthread_mutexattr_getprotocol + + * pthread_mutexattr_setprotocol + + * + * _POSIX_THREAD_PRIO_PROTECT (not set) + * If set, you can create priority ceiling mutexes + * Indicates the availability of: + * pthread_mutex_getprioceiling + * pthread_mutex_setprioceiling + * pthread_mutexattr_getprioceiling + * pthread_mutexattr_getprotocol + + * pthread_mutexattr_setprioceiling + * pthread_mutexattr_setprotocol + + * + * _POSIX_THREAD_PROCESS_SHARED (not set) + * If set, you can create mutexes and condition + * variables that can be shared with another + * process.If set, indicates the availability + * of: + * pthread_mutexattr_getpshared + * pthread_mutexattr_setpshared + * pthread_condattr_getpshared + * pthread_condattr_setpshared + * + * _POSIX_THREAD_SAFE_FUNCTIONS (set) + * If set you can use the special *_r library + * functions that provide thread-safe behaviour + * + * + These functions provide both 'inherit' and/or + * 'protect' protocol, based upon these macro + * settings. + * + * POSIX 1003.1c-1995 Limits + * =========================== + * + * PTHREAD_DESTRUCTOR_ITERATIONS + * Maximum number of attempts to destroy + * a thread's thread-specific data on + * termination (must be at least 4) + * + * PTHREAD_KEYS_MAX + * Maximum number of thread-specific data keys + * available per process (must be at least 128) + * + * PTHREAD_STACK_MIN + * Minimum supported stack size for a thread + * + * PTHREAD_THREADS_MAX + * Maximum number of threads supported per + * process (must be at least 64). + * + * ------------------------------------------------------------- + */ + +/* + * POSIX Options + */ +#define _POSIX_THREADS +#define _POSIX_SEMAPHORES +#define _POSIX_THREAD_SAFE_FUNCTIONS +#define _POSIX_THREAD_ATTR_STACKSIZE -/* Related constants */ -typedef struct { - long valid; +#if defined( KLUDGE ) +/* + * The following are not supported + */ +#define _POSIX_THREAD_ATTR_STACKADDR +#define _POSIX_THREAD_PRIORITY_SCHEDULING +#define _POSIX_THREAD_PRIO_INHERIT +#define _POSIX_THREAD_PRIO_PROTECT +#define _POSIX_THREAD_PROCESS_SHARED + +#endif /* KLUDGE */ + +/* + * POSIX Limits + * + * PTHREAD_DESTRUCTOR_ITERATIONS + * Standard states this must be at least + * 4. + * + * PTHREAD_KEYS_MAX + * WIN32 permits only 64 TLS keys per process. + * This limitation could be worked around by + * simply simulating keys. + * + * PTHREADS_STACK_MIN + * artibrarily chose 1K. By default, WIN32 + * selects 1Meg stacks. + * + * PTHREAD_THREADS_MAX + * Not documented by WIN32. Wrote a test program + * that kept creating threads until it failed + * revealed this approximate number. + * + */ +#define PTHREAD_DESTRUCTOR_ITERATIONS 4 +#define PTHREAD_KEYS_MAX 64 +#define PTHREAD_STACK_MIN 1024 +#define PTHREAD_THREADS_MAX 2019 + + + typedef struct pthread_t_ *pthread_t; + typedef struct pthread_attr_t_ *pthread_attr_t; + typedef struct pthread_once_t_ pthread_once_t; + typedef struct pthread_key_t_ *pthread_key_t; + typedef struct pthread_mutex_t_ pthread_mutex_t; + typedef struct pthread_mutexattr_t_ pthread_mutexattr_t; + typedef struct pthread_cond_t_ *pthread_cond_t; + typedef struct pthread_condattr_t_ *pthread_condattr_t; + + +/* + * ==================== + * ==================== + * POSIX Threads + * ==================== + * ==================== + */ + +/* + * pthread_attr_{get,set}detachstate + */ +#define PTHREAD_CREATE_JOINABLE 0 +#define PTHREAD_CREATE_DETACHED 1 + +/* + * pthread_attr{get,set}inheritsched + */ +#define PTHREAD_INHERIT_SCHED 0 +#define PTHREAD_EXPLICIT_SCHED 1 + +/* + * pthread_setcancelstate paramters + */ +#define PTHREAD_CANCEL_ENABLE 0 +#define PTHREAD_CANCEL_DISABLE 1 + +/* + * pthread_setcanceltype parameters + */ +#define PTHREAD_CANCEL_ASYNCHRONOUS 0 +#define PTHREAD_CANCEL_DEFERRED 1 + +/* + * ==================== + * ==================== + * Mutex + * ==================== + * ==================== + */ + +/* FIXME: Replace the NULL with a valid critical section initializer + * and then also change the 0 (first element) to 1. + */ +#define PTHREAD_MUTEX_INITIALIZER { 0, NULL } + + +/* + * pthread_mutexattr_{get,set}pshared + * pthread_condattr_{get,set}pshared + */ +#define PTHREAD_PROCESS_PRIVATE 0 +#define PTHREAD_PROCESS_SHARED 1 + + +/* + * ==================== + * ==================== + * Once Key + * ==================== + * ==================== + */ +#define PTHREAD_ONCE_INIT { 0, PTHREAD_MUTEX_INITIALIZER } + + +/* + * ==================== + * ==================== + * Condition Variable + * ==================== + * ==================== + */ +#define PTHREAD_COND_INITIALIZER { {0, 0}, 0, PTHREAD_MUTEX_INITIALIZER } + + +/* + * ==================== + * ==================== + * Opaque Structure Definitions + * ==================== + * ==================== + */ + +typedef enum { + /* + * This enumeration represents the state of the thread; + * The thread is still "alive" if the numeric value of the + * state is greater or equal "PThreadStateRunning". + */ + PThreadStateInitial = 0, /* Thread not running */ + PThreadStateRunning, /* Thread alive & kicking */ + PThreadStateSuspended, /* Thread alive but suspended */ + PThreadStateCanceling, /* Thread alive but and is */ + /* in the process of terminating */ + /* due to a cancellation request */ + PThreadStateException, /* Thread alive but exiting */ + /* due to an exception */ + PThreadStateLast +} +PThreadState; + + +typedef enum { + /* + * This enumeration represents the reason why a thread has + * terminated/is terminating. + */ + PThreadDemisePeaceful = 0, /* Death due natural causes */ + PThreadDemiseCancelled, /* Death due to user cancel */ + PThreadDemiseException, /* Death due to unhandled */ + /* exception */ + PThreadDemiseNotDead /* I'm not dead! */ +} +PThreadDemise; + + +struct pthread_t_ { + DWORD thread; + HANDLE threadH; + PThreadState state; + PThreadDemise demise; + void *exitStatus; + void *parms; + int detachState; + int cancelState; + int cancelType; + HANDLE cancelEvent; + int implicit:1; + void *keys; +}; -#ifdef _POSIX_THREAD_ATTR_STACKSIZE - size_t stacksize; /* PTHREAD_STACK_MIN */ -#endif - int detachedstate; /* PTHREAD_CREATE_DETACHED - PTHREAD_CREATE_JOINABLE */ +/* + * Special value to mark attribute objects as valid. + */ +#define _PTHREAD_ATTR_VALID 0xC4C0FFEE +struct pthread_attr_t_ { + long valid; + void *stackaddr; + size_t stacksize; + int detachstate; + int priority; #if HAVE_SIGSET_T sigset_t sigmask; #endif /* HAVE_SIGSET_T */ +}; - int priority; -} pthread_attr_t; +struct pthread_mutex_t_ { + int valid; + CRITICAL_SECTION cs; + }; + + +struct pthread_mutexattr_t_ { + int pshared; +}; -/* I don't know why this structure isn't in some kind of namespace. - According to my O'Reilly book, this is what this struct is - called. */ -struct sched_param { - int sched_priority; + +struct pthread_key_t_ { + DWORD key; + void (*destructor) (void *); + pthread_mutex_t threadsLock; + void *threads; }; -enum { SIGNAL, BROADCAST, NUM_EVENTS }; -typedef struct { - /* Signal and broadcast event HANDLEs. */ - HANDLE events[NUM_EVENTS]; +struct pthread_cond_t_ { + long waiters; /* # waiting threads */ + pthread_mutex_t waitersLock; /* Mutex that guards access to + waiter count */ + sem_t sema; /* Queue up threads waiting for the + condition to become signaled */ + HANDLE waitersDone; /* An auto reset event used by the + broadcast/signal thread to wait + for the waiting thread(s) to wake + up and get a chance at the + semaphore */ + int wasBroadcast; /* keeps track if we are signaling + or broadcasting */ +}; + - /* Count of the number of waiters. */ - unsigned waiters_count; - - /* Serialize access to waiters_count. */ - pthread_mutex_t waiters_count_lock; -} pthread_cond_t; +struct pthread_condattr_t_ { + int pshared; +}; -typedef struct { void * dummy; } pthread_condattr_t; -typedef struct { void * dummy; } pthread_mutexattr_t; -typedef struct { +struct pthread_once_t_ { unsigned short flag; pthread_mutex_t lock; -} pthread_once_t; +}; -#ifdef __cplusplus -extern "C" { -#endif /* __cplusplus */ -int pthread_atfork (void (*prepare)(void), - void (*parent)(void), - void (*child)(void)); +/* + * ==================== + * ==================== + * Scheduling + * ==================== + * ==================== + */ -int pthread_create(pthread_t *thread, - const pthread_attr_t *attr, - void * (*start_routine) (void *), - void * arg); +/* Thread scheduling policies */ -void pthread_exit(void *value); +#define SCHED_OTHER 0 +#define SCHED_FIFO 1 +#define SCHED_RR 2 -pthread_t pthread_self(void); +#define SCHED_MIN SCHED_OTHER +#define SCHED_MAX SCHED_RR -int pthread_equal(pthread_t t1, pthread_t t2); + struct sched_param { + int sched_priority; + }; -int pthread_join(pthread_t thread, void ** valueptr); -int pthread_detach(pthread_t thread); -int pthread_once(pthread_once_t *once_control, void (*init_routine)(void)); +/* There are three implementations of cancel cleanup. + * + * C + * C++ (as per Cygwin32 or Mingw32) + * WIN32 SEH or C++ + */ -/* Functions for manipulating thread attribute objects. */ + typedef struct _pthread_cleanup_t _pthread_cleanup_t; -int pthread_attr_init(pthread_attr_t *attr); + struct _pthread_cleanup_t + { + void (*routine) (void *); + void *arg; +#if !defined(__cplusplus) + _pthread_cleanup_t *prev; +#endif + }; + +#ifndef __cplusplus + +/* + * C implementation of PThreads cancel cleanup + */ + +#define pthread_cleanup_push( _rout, _arg ) \ + { \ + _pthread_cleanup_t _cleanup; \ + \ + _pthread_push_cleanup( &_cleanup, (_rout), (_arg) ); \ + +#define pthread_cleanup_pop( _execute ) \ + (void) _pthread_pop_cleanup( _execute ); \ + } + +#else /* !__cplusplus */ + +#ifdef _WIN32 + /* + * WIN32 SEH version of cancel cleanup. + */ + +#define pthread_cleanup_push( _rout, _arg ) \ + { \ + _pthread_cleanup_t _cleanup; \ + \ + _cleanup.routine = (_rout); \ + _cleanup.arg = (_arg); \ + __try \ + { \ + +#define pthread_cleanup_pop( _execute ) \ + } \ + __finally \ + { \ + if( _execute || AbnormalTermination()) \ + { \ + (*(_cleanup.routine))( _cleanup.arg ); \ + } \ + } \ + } + +#else /* _WIN32 */ + + /* + * C++ (ie. Cygwin32 or Mingw32) version of cancel cleanup. + * + * Emulate try-finally behaviour. + */ + +#define pthread_cleanup_push( _rout, _arg ) \ + { \ + _pthread_cleanup_t _cleanup; \ + \ + _cleanup.routine = (_rout); \ + _cleanup.arg = (_arg); \ + try \ + { \ + +#define pthread_cleanup_pop( _execute ) \ + } \ + catch(...) \ + { \ + (*(_cleanup.routine))( _cleanup.arg ); \ + \ + throw; \ + } \ + \ + if (_execute) \ + { \ + (*(_cleanup.routine))( _cleanup.arg ); \ + } \ + } -int pthread_attr_destroy(pthread_attr_t *attr); +#endif /* _WIN32 */ -int pthread_attr_setstacksize(pthread_attr_t *attr, - size_t stacksize); +#endif /* !__cplusplus */ -int pthread_attr_getstacksize(const pthread_attr_t *attr, - size_t *stacksize); +/* + * =============== + * =============== + * Methods + * =============== + * =============== + */ -int pthread_attr_setstackaddr(pthread_attr_t *attr, - void *stackaddr); +/* + * PThread Attribute Functions + */ +int pthread_attr_init (pthread_attr_t * attr); -int pthread_attr_getstackaddr(const pthread_attr_t *attr, - void **stackaddr); +int pthread_attr_destroy (pthread_attr_t * attr); -int pthread_attr_getschedparam(const pthread_attr_t *attr, - struct sched_param *param); +int pthread_attr_getdetachstate (const pthread_attr_t * attr, + int *detachstate); -int pthread_attr_setschedparam(pthread_attr_t *attr, - const struct sched_param *param); +int pthread_attr_getstackaddr (const pthread_attr_t * attr, + void **stackaddr); -int pthread_attr_getdetachstate(const pthread_attr_t *attr, - int *detachstate); +int pthread_attr_getstacksize (const pthread_attr_t * attr, + size_t * stacksize); -int pthread_attr_setdetachstate(pthread_attr_t *attr, - int detachstate); - -int pthread_setschedparam(pthread_t thread, - int policy, - const struct sched_param *param); +int pthread_attr_setdetachstate (pthread_attr_t * attr, + int detachstate); -int pthread_getschedparam(pthread_t thread, - int *policy, - struct sched_param *param); +int pthread_attr_setstackaddr (pthread_attr_t * attr, + void *stackaddr); -int sched_get_priority_min(int policy); +int pthread_attr_setstacksize (pthread_attr_t * attr, + size_t stacksize); -int sched_get_priority_max(int policy); +/* + * PThread Functions + */ +int pthread_create (pthread_t * tid, + const pthread_attr_t * attr, + void *(*start) (void *), + void *arg); -int pthread_setcancelstate(int state, - int *oldstate); +int pthread_detach (pthread_t tid); -int pthread_setcanceltype(int type, - int *oldtype); +int pthread_equal (pthread_t t1, + pthread_t t2); -/* Functions for manipulating cond. var. attribute objects. */ +int pthread_exit (void *value_ptr); -int pthread_condattr_init(pthread_condattr_t *attr); +int pthread_join (pthread_t thread, + void **value_ptr); -int pthread_condattr_setpshared(pthread_condattr_t *attr, - int pshared); +pthread_t pthread_self (void); -int pthread_condattr_getpshared(pthread_condattr_t *attr, - int *pshared); +int pthread_cancel (pthread_t thread); -int pthread_condattr_destroy(pthread_condattr_t *attr); +#ifndef __cplusplus +_pthread_cleanup_t *_pthread_pop_cleanup (int execute); -/* Functions for manipulating mutex attribute objects. */ +void _pthread_push_cleanup (_pthread_cleanup_t * cleanup, + void (*routine) (void *), + void *arg); +#endif /* !__cplusplus */ -int pthread_mutexattr_init(pthread_mutexattr_t *attr); +int pthread_setcancelstate (int state, + int *oldstate); -int pthread_mutexattr_destroy(pthread_mutexattr_t *attr); +int pthread_setcanceltype (int type, + int *oldtype); -/* Primitives for condition variables. */ +void pthread_testcancel (void); -int pthread_cond_init(pthread_cond_t *cv, - const pthread_condattr_t *attr); +int pthread_once (pthread_once_t * once_control, + void (*init_routine) (void)); -int pthread_cond_broadcast(pthread_cond_t *cv); +/* + * Thread Specific Data Functions + */ +int pthread_key_create (pthread_key_t * key, + void (*destructor) (void *)); -int pthread_cond_signal(pthread_cond_t *cv); +int pthread_key_delete (pthread_key_t key); -int pthread_cond_timedwait(pthread_cond_t *cv, - pthread_mutex_t *mutex, - const struct timespec *abstime); +int pthread_setspecific (pthread_key_t key, + const void *value); -int pthread_cond_wait(pthread_cond_t *cv, - pthread_mutex_t *mutex); +void *pthread_getspecific (pthread_key_t key); -int pthread_cond_destroy(pthread_cond_t *cv); -/* Primitives for mutexes. */ +/* + * Mutex Attribute Functions + */ +int pthread_mutexattr_init (pthread_mutexattr_t * attr); -int pthread_mutex_init(pthread_mutex_t *mutex, - const pthread_mutexattr_t *attr); +int pthread_mutexattr_destroy (pthread_mutexattr_t * attr); -int pthread_mutex_destroy(pthread_mutex_t *mutex); +int pthread_mutexattr_getpshared (const pthread_mutexattr_t + * attr, + int *pshared); -int pthread_mutex_lock(pthread_mutex_t *mutex); +int pthread_mutexattr_setpshared (pthread_mutexattr_t * attr, + int pshared); -int pthread_mutex_trylock(pthread_mutex_t *mutex); +/* + * Mutex Functions + */ +int pthread_mutex_init (pthread_mutex_t * mutex, + const pthread_mutexattr_t * attr); -int pthread_mutex_unlock(pthread_mutex_t *mutex); +int pthread_mutex_destroy (pthread_mutex_t * mutex); -/* Primitives for thread-specific data (TSD). */ +int pthread_mutex_lock (pthread_mutex_t * mutex); -int pthread_key_create(pthread_key_t *key, - void (*destructor)(void *)); +int pthread_mutex_trylock (pthread_mutex_t * mutex); -int pthread_setspecific(pthread_key_t key, void *value); +int pthread_mutex_unlock (pthread_mutex_t * mutex); -void *pthread_getspecific(pthread_key_t key); +/* + * Condition Variable Attribute Functions + */ +int pthread_condattr_init (pthread_condattr_t * attr); -int pthread_key_delete(pthread_key_t key); +int pthread_condattr_destroy (pthread_condattr_t * attr); -/* Signal handling. */ +int pthread_condattr_getpshared (const pthread_condattr_t * attr, + int *pshared); -#if HAVE_SIGSET_T -int pthread_sigmask(int how, - const sigset_t *set, - sigset_t *oset); -#endif /* HAVE_SIGSET_T */ +int pthread_condattr_setpshared (pthread_condattr_t * attr, + int pshared); -/* Thread cancelation functions. */ +/* + * Condition Variable Functions + */ +int pthread_cond_init (pthread_cond_t * cond, + const pthread_condattr_t * attr); -void pthread_testcancel(void); +int pthread_cond_destroy (pthread_cond_t * cond); -int pthread_cancel(pthread_t thread); +int pthread_cond_wait (pthread_cond_t * cond, + pthread_mutex_t * mutex); -#ifdef __cplusplus -} -#endif /* __cplusplus */ +int pthread_cond_timedwait (pthread_cond_t * cond, + pthread_mutex_t * mutex, + const struct timespec *abstime); -/* Constants declared in global.c */ -extern const int _POSIX_THREAD_THREADS_MAX; -extern const int _POSIX_THREAD_DESTRUCTOR_ITERATIONS; -extern const int _POSIX_THREAD_KEYS_MAX; +int pthread_cond_signal (pthread_cond_t * cond); -extern const int _pthread_create_joinable; -extern const int _pthread_create_detached; +int pthread_cond_broadcast (pthread_cond_t * cond); -extern const int _pthread_cancel_enable; -extern const int _pthread_cancel_disable; +/* + * Scheduling + */ -extern const int _pthread_cancel_asynchronous; -extern const int _pthread_cancel_deferred; +int pthread_setschedparam (pthread_t thread, + int policy, + const struct sched_param *param); -#define PTHREAD_DESTRUCTOR_ITERATIONS _POSIX_THREAD_DESTRUCTOR_ITERATIONS -#define PTHREAD_KEYS_MAX _POSIX_THREAD_KEYS_MAX -#define PTHREAD_THREADS_MAX _POSIX_THREAD_THREADS_MAX +int pthread_getschedparam (pthread_t thread, + int *policy, + struct sched_param *param); -#define PTHREAD_CREATE_JOINABLE _pthread_create_joinable -#define PTHREAD_CREATE_DETACHED _pthread_create_detached +int sched_get_priority_min (int policy); -/* Cancelability attributes */ -#define PTHREAD_CANCEL_ENABLE _pthread_cancel_enable -#define PTHREAD_CANCEL_DISABLE _pthread_cancel_disable +int sched_get_priority_max (int policy); -#define PTHREAD_CANCEL_ASYNCHRONOUS _pthread_cancel_asynchronous -#define PTHREAD_CANCEL_DEFERRED _pthread_cancel_deferred +int pthread_attr_getschedparam (const pthread_attr_t *attr, + struct sched_param *param); +int pthread_attr_setschedparam (pthread_attr_t *attr, + const struct sched_param *param); -/* The following #defines implement POSIX cleanup handlers. - The standard requires that these functions be used as statements and - be used pairwise in the same scope. The standard suggests that, in C, they - may be implemented as macros starting and ending the same block. - POSIX requires that applications observe scoping requirements, but - doesn't say if the implemention must enforce them. The macros below - partially enforce scope but can lead to compile or runtime errors. */ +/* + * Protected Methods + * + * This function blocks until the given WIN32 handle + * is signaled or pthread_cancel had been called. + * This function allows the caller to hook into the + * PThreads cancel mechanism. It is implemented using + * + * WaitForMultipleObjects + * + * on 'waitHandle' and a manually reset WIN32 Event + * used to implement pthread_cancel. + */ +int pthreadCancelableWait (HANDLE waitHandle); -enum { - _PTHREAD_HANDLER_POP_LIFO, - _PTHREAD_HANDLER_POP_FIFO -}; +/* + * Thread-Safe C Runtime Library Mappings + * WIN32 C runtime library had been made thread-safe + * without affecting the user interface. Provide + * mappings from the UNIX thread-safe versions to + * the standard C runtime library calls. + * Only provide function mappings for functions that + * actually exist on WIN32. + */ +#define strtok_r( _s, _sep, _lasts ) \ + ( *(_lasts) = strtok( (_s), (_sep) ) ) -enum { - _PTHREAD_CLEANUP_STACK, - _PTHREAD_DESTRUCTOR_STACK, - _PTHREAD_FORKPREPARE_STACK, - _PTHREAD_FORKPARENT_STACK, - _PTHREAD_FORKCHILD_STACK -}; +#define asctime_r( _tm, _buf ) \ + ( strcpy( (_buf), asctime( (_tm) ) ), \ + (_buf) ) -#ifdef pthread_cleanup_push -#undef pthread_cleanup_push -#endif +#define ctime_r( _clock, _buf ) \ + ( strcpy( (_buf), ctime( (_tm) ) ), \ + (_buf) ) -#define pthread_cleanup_push(routine, arg) \ -{ \ - (void ) _pthread_handler_push(_PTHREAD_CLEANUP_STACK, \ - _PTHREAD_HANDLER_POP_LIFO, routine, arg); +#define gmtime_r( _clock, _result ) \ + ( *(_result) = *gmtime( (_clock) ), \ + (_result) ) -#ifdef pthread_cleanup_pop -#undef pthread_cleanup_pop -#endif +#define localtime_r( _clock, _result ) \ + ( *(_result) = *localtime( (_clock) ), \ + (_result) ) -#define pthread_cleanup_pop(execute) \ - _pthread_handler_pop(_PTHREAD_CLEANUP_STACK, execute);\ -} +#define rand_r( _seed ) \ + rand() + + +#ifdef __cplusplus +} /* End of extern "C" */ +#endif /* __cplusplus */ -#endif /* _PTHREADS_H */ +#endif /* PTHREAD_H */ |