summaryrefslogtreecommitdiff
path: root/pthread.h
diff options
context:
space:
mode:
Diffstat (limited to 'pthread.h')
-rw-r--r--pthread.h949
1 files changed, 706 insertions, 243 deletions
diff --git a/pthread.h b/pthread.h
index ef22d80..458ef6e 100644
--- a/pthread.h
+++ b/pthread.h
@@ -1,33 +1,191 @@
/* 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
+ *
+ * Limitations
+ * ===========
+ * The following functions are not implemented:
+ *
+ * ---------------------------
+ * RealTime Scheduling:
+ * ---------------------------
+ * 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_mutex_getprioceiling
+ * pthread_mutex_setprioceiling
+ * pthread_mutex_attr_getprioceiling
+ * pthread_mutex_attr_getprotocol
+ * pthread_mutex_attr_setprioceiling
+ * pthread_mutex_attr_setprotocol
+ * pthread_setschedparam
+ * sched_get_priority_max
+ * sched_get_priority_min
+ *
+ * ---------------------------
+ * 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
+ * pthread_sigmask
+ * 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 +216,604 @@ struct timespec {
#define SIG_SETMASK 2
#endif /* SIG_SETMASK */
-#define PTHREAD_STACK_MIN 65535
-
-/* Thread scheduling policies */
-
-#define SCHED_OTHER 0
-#define SCHED_FIFO 1
-#define SCHED_RR 2
-
-#define SCHED_MIN SCHED_OTHER
-#define SCHED_MAX SCHED_RR
-
-/* 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)
-
-#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;
-
-
-typedef DWORD pthread_key_t;
-
-/* Related constants */
-typedef struct {
- long valid;
+#include <process.h>
+#include <errno.h>
-#ifdef _POSIX_THREAD_ATTR_STACKSIZE
- size_t stacksize; /* PTHREAD_STACK_MIN */
+#ifdef _WIN32
+/*
+ * Re-enable all but 4127, 4514
+ */
+#pragma warning( default : 4115 4116 4201 4214)
#endif
- int detachedstate; /* PTHREAD_CREATE_DETACHED
- PTHREAD_CREATE_JOINABLE */
+#if !defined( TRUE )
+#define TRUE !FALSE
+#define FALSE 0
+#endif /* !TRUE */
-#if HAVE_SIGSET_T
- sigset_t sigmask;
-#endif /* HAVE_SIGSET_T */
- int priority;
+#include <semaphore.h>
+#include <sched.h>
-} pthread_attr_t;
-
-/* 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;
-};
-
-enum { SIGNAL, BROADCAST, NUM_EVENTS };
-
-typedef struct {
- /* Signal and broadcast event HANDLEs. */
- HANDLE events[NUM_EVENTS];
-
- /* Count of the number of waiters. */
- unsigned waiters_count;
-
- /* Serialize access to waiters_count. */
- pthread_mutex_t waiters_count_lock;
-} pthread_cond_t;
-
-typedef struct { void * dummy; } pthread_condattr_t;
-typedef struct { void * dummy; } pthread_mutexattr_t;
-
-typedef struct {
- 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));
-
-int pthread_create(pthread_t *thread,
- const pthread_attr_t *attr,
- void * (*start_routine) (void *),
- void * arg);
+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
-void pthread_exit(void *value);
-
-pthread_t pthread_self(void);
+#define _POSIX_THREAD_ATTR_STACKSIZE
-int pthread_equal(pthread_t t1, pthread_t t2);
+#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 }
+
+
+/*
+ * ====================
+ * ====================
+ * Scheduling
+ * ====================
+ * ====================
+ */
-int pthread_join(pthread_t thread, void ** valueptr);
+/* Thread scheduling policies */
-int pthread_detach(pthread_t thread);
+#define SCHED_OTHER 0
+#define SCHED_FIFO 1
+#define SCHED_RR 2
-int pthread_once(pthread_once_t *once_control, void (*init_routine)(void));
+#define SCHED_MIN SCHED_OTHER
+#define SCHED_MAX SCHED_RR
-/* Functions for manipulating thread attribute objects. */
+ struct sched_param {
+ int sched_priority;
+ };
+
+
+
+/* There are three implementations of cancel cleanup.
+ *
+ * C
+ * C++ (as per Cygwin32 or Mingw32)
+ * WIN32 SEH or C++
+ */
+
+#ifndef __cplusplus
+
+/*
+ * C implementation of PThreads cancel cleanup
+ */
+ typedef struct pthread_cleanup_t pthread_cleanup_t;
+
+ struct pthread_cleanup_t
+ {
+ void (*routine) (void *);
+ void *arg;
+ pthread_cleanup_t *prev;
+ };
+
+#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_init(pthread_attr_t *attr);
+#endif /* _WIN32 */
-int pthread_attr_destroy(pthread_attr_t *attr);
+#endif /* !__cplusplus */
-int pthread_attr_setstacksize(pthread_attr_t *attr,
- size_t stacksize);
+/*
+ * ===============
+ * ===============
+ * Methods
+ * ===============
+ * ===============
+ */
+
+/*
+ * PThread Attribute Functions
+ */
+int pthread_attr_init (pthread_attr_t * attr);
-int pthread_attr_getstacksize(const pthread_attr_t *attr,
- size_t *stacksize);
+int pthread_attr_destroy (pthread_attr_t * attr);
-int pthread_attr_setstackaddr(pthread_attr_t *attr,
- void *stackaddr);
+int pthread_attr_getdetachstate (const pthread_attr_t * attr,
+ int *detachstate);
-int pthread_attr_getstackaddr(const pthread_attr_t *attr,
- void **stackaddr);
+int pthread_attr_getstackaddr (const pthread_attr_t * attr,
+ void **stackaddr);
-int pthread_attr_getschedparam(const pthread_attr_t *attr,
- struct sched_param *param);
+int pthread_attr_getstacksize (const pthread_attr_t * attr,
+ size_t * stacksize);
-int pthread_attr_setschedparam(pthread_attr_t *attr,
- const struct sched_param *param);
+int pthread_attr_setdetachstate (pthread_attr_t * attr,
+ int detachstate);
-int pthread_attr_getdetachstate(const pthread_attr_t *attr,
- int *detachstate);
+int pthread_attr_setstackaddr (pthread_attr_t * attr,
+ void *stackaddr);
-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_setstacksize (pthread_attr_t * attr,
+ size_t stacksize);
-int pthread_getschedparam(pthread_t thread,
- int *policy,
- struct sched_param *param);
+/*
+ * PThread Functions
+ */
+int pthread_create (pthread_t * tid,
+ const pthread_attr_t * attr,
+ void *(*start) (void *),
+ void *arg);
-int sched_get_priority_min(int policy);
+int pthread_detach (pthread_t tid);
-int sched_get_priority_max(int policy);
+int pthread_equal (pthread_t t1,
+ pthread_t t2);
-int pthread_setcancelstate(int state,
- int *oldstate);
+int pthread_exit (void *value_ptr);
-int pthread_setcanceltype(int type,
- int *oldtype);
+int pthread_join (pthread_t thread,
+ void **value_ptr);
-/* Functions for manipulating cond. var. attribute objects. */
+pthread_t pthread_self (void);
-int pthread_condattr_init(pthread_condattr_t *attr);
+int pthread_cancel (pthread_t thread);
-int pthread_condattr_setpshared(pthread_condattr_t *attr,
- int pshared);
+pthread_cleanup_t *pthread_pop_cleanup (int execute);
-int pthread_condattr_getpshared(pthread_condattr_t *attr,
- int *pshared);
+void pthread_push_cleanup (pthread_cleanup_t * cleanup,
+ void (*routine) (void *),
+ void *arg);
-int pthread_condattr_destroy(pthread_condattr_t *attr);
+int pthread_setcancelstate (int state,
+ int *oldstate);
-/* Functions for manipulating mutex attribute objects. */
+int pthread_setcanceltype (int type,
+ int *oldtype);
-int pthread_mutexattr_init(pthread_mutexattr_t *attr);
+void pthread_testcancel (void);
-int pthread_mutexattr_destroy(pthread_mutexattr_t *attr);
+int pthread_once (pthread_once_t * once_control,
+ void (*init_routine) (void));
-/* Primitives for condition variables. */
+/*
+ * Thread Specific Data Functions
+ */
+int pthread_key_create (pthread_key_t * key,
+ void (*destructor) (void *));
-int pthread_cond_init(pthread_cond_t *cv,
- const pthread_condattr_t *attr);
+int pthread_key_delete (pthread_key_t key);
-int pthread_cond_broadcast(pthread_cond_t *cv);
+int pthread_setspecific (pthread_key_t key,
+ const void *value);
-int pthread_cond_signal(pthread_cond_t *cv);
+void *pthread_getspecific (pthread_key_t key);
-int pthread_cond_timedwait(pthread_cond_t *cv,
- pthread_mutex_t *mutex,
- const struct timespec *abstime);
-int pthread_cond_wait(pthread_cond_t *cv,
- pthread_mutex_t *mutex);
+/*
+ * Mutex Attribute Functions
+ */
+int pthread_mutexattr_init (pthread_mutexattr_t * attr);
-int pthread_cond_destroy(pthread_cond_t *cv);
+int pthread_mutexattr_destroy (pthread_mutexattr_t * attr);
-/* Primitives for mutexes. */
+int pthread_mutexattr_getpshared (const pthread_mutexattr_t
+ * attr,
+ int *pshared);
-int pthread_mutex_init(pthread_mutex_t *mutex,
- const pthread_mutexattr_t *attr);
+int pthread_mutexattr_setpshared (pthread_mutexattr_t * attr,
+ int pshared);
-int pthread_mutex_destroy(pthread_mutex_t *mutex);
+/*
+ * Mutex Functions
+ */
+int pthread_mutex_init (pthread_mutex_t * mutex,
+ const pthread_mutexattr_t * attr);
-int pthread_mutex_lock(pthread_mutex_t *mutex);
+int pthread_mutex_destroy (pthread_mutex_t * mutex);
-int pthread_mutex_trylock(pthread_mutex_t *mutex);
+int pthread_mutex_lock (pthread_mutex_t * mutex);
-int pthread_mutex_unlock(pthread_mutex_t *mutex);
+int pthread_mutex_trylock (pthread_mutex_t * mutex);
-/* Primitives for thread-specific data (TSD). */
+int pthread_mutex_unlock (pthread_mutex_t * mutex);
-int pthread_key_create(pthread_key_t *key,
- void (*destructor)(void *));
+/*
+ * Condition Variable Attribute Functions
+ */
+int pthread_condattr_init (pthread_condattr_t * attr);
-int pthread_setspecific(pthread_key_t key, void *value);
+int pthread_condattr_destroy (pthread_condattr_t * attr);
-void *pthread_getspecific(pthread_key_t key);
+int pthread_condattr_getpshared (const pthread_condattr_t * attr,
+ int *pshared);
-int pthread_key_delete(pthread_key_t key);
+int pthread_condattr_setpshared (pthread_condattr_t * attr,
+ int pshared);
-/* Signal handling. */
+/*
+ * Condition Variable Functions
+ */
+int pthread_cond_init (pthread_cond_t * cond,
+ const pthread_condattr_t * attr);
-#if HAVE_SIGSET_T
-int pthread_sigmask(int how,
- const sigset_t *set,
- sigset_t *oset);
-#endif /* HAVE_SIGSET_T */
+int pthread_cond_destroy (pthread_cond_t * cond);
-/* Thread cancelation functions. */
+int pthread_cond_wait (pthread_cond_t * cond,
+ pthread_mutex_t * mutex);
-void pthread_testcancel(void);
+int pthread_cond_timedwait (pthread_cond_t * cond,
+ pthread_mutex_t * mutex,
+ const struct timespec *abstime);
-int pthread_cancel(pthread_t thread);
+int pthread_cond_signal (pthread_cond_t * cond);
-#ifdef __cplusplus
-}
-#endif /* __cplusplus */
+int pthread_cond_broadcast (pthread_cond_t * cond);
-/* 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;
+/*
+ * Scheduling
+ */
-extern const int _pthread_create_joinable;
-extern const int _pthread_create_detached;
+int pthread_setschedparam (pthread_t thread,
+ int policy,
+ const struct sched_param *param);
-extern const int _pthread_cancel_enable;
-extern const int _pthread_cancel_disable;
+int pthread_getschedparam (pthread_t thread,
+ int *policy,
+ struct sched_param *param);
-extern const int _pthread_cancel_asynchronous;
-extern const int _pthread_cancel_deferred;
+int sched_get_priority_min (int policy);
-#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 sched_get_priority_max (int policy);
-#define PTHREAD_CREATE_JOINABLE _pthread_create_joinable
-#define PTHREAD_CREATE_DETACHED _pthread_create_detached
+int pthread_attr_getschedparam (const pthread_attr_t *attr,
+ struct sched_param *param);
-/* Cancelability attributes */
-#define PTHREAD_CANCEL_ENABLE _pthread_cancel_enable
-#define PTHREAD_CANCEL_DISABLE _pthread_cancel_disable
+int pthread_attr_setschedparam (pthread_attr_t *attr,
+ const struct sched_param *param);
-#define PTHREAD_CANCEL_ASYNCHRONOUS _pthread_cancel_asynchronous
-#define PTHREAD_CANCEL_DEFERRED _pthread_cancel_deferred
+/*
+ * 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);
-/* 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.
+/*
+ * 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) ) )
- 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. */
+#define asctime_r( _tm, _buf ) \
+ ( strcpy( (_buf), asctime( (_tm) ) ), \
+ (_buf) )
-enum {
- _PTHREAD_HANDLER_POP_LIFO,
- _PTHREAD_HANDLER_POP_FIFO
-};
+#define ctime_r( _clock, _buf ) \
+ ( strcpy( (_buf), ctime( (_tm) ) ), \
+ (_buf) )
-enum {
- _PTHREAD_CLEANUP_STACK,
- _PTHREAD_DESTRUCTOR_STACK,
- _PTHREAD_FORKPREPARE_STACK,
- _PTHREAD_FORKPARENT_STACK,
- _PTHREAD_FORKCHILD_STACK
-};
+#define gmtime_r( _clock, _result ) \
+ ( *(_result) = *gmtime( (_clock) ), \
+ (_result) )
-#ifdef pthread_cleanup_push
-#undef pthread_cleanup_push
-#endif
+#define localtime_r( _clock, _result ) \
+ ( *(_result) = *localtime( (_clock) ), \
+ (_result) )
-#define pthread_cleanup_push(routine, arg) \
-{ \
- (void ) _pthread_handler_push(_PTHREAD_CLEANUP_STACK, \
- _PTHREAD_HANDLER_POP_LIFO, routine, arg);
+#define rand_r( _seed ) \
+ rand()
-#ifdef pthread_cleanup_pop
-#undef pthread_cleanup_pop
-#endif
-#define pthread_cleanup_pop(execute) \
- _pthread_handler_pop(_PTHREAD_CLEANUP_STACK, execute);\
-}
+#ifdef __cplusplus
+} /* End of extern "C" */
+#endif /* __cplusplus */
-#endif /* _PTHREADS_H */