mirror of
git://sourceware.org/git/newlib-cygwin.git
synced 2025-02-01 03:50:28 +08:00
* configure.in: Remove PTH_ALLOW.
* cygwin.din: Remove @PTH_ALLOW@ prefixes to pthread functions. Add new pthread exports. * pthread.cc: New wrapper functions for the above new exports. * sched.cc (valid_sched_parameters): New function. (sched_setparam): Use it. (sched_set_thread_priority): New function. Used by pthread_sched*. * thread.cc (pthread_key_destructor::InsertAfter): New function. (pthread_key_destructor::UnlinkNext): New function. (pthread_key_destructor::Next): New function. (pthread_key_destructor_list::Insert): New function. (pthread_key_destructor_list::Remove): New function. (pthread_key_destructor_list::Pop): New function. (pthread_key_destructor::pthread_key_destructor): New function. (pthread_key_destructor_list::IterateNull): New function. (MTinterface::Init): Initialise new member. (pthread::pthread): Initialise new members. (pthread::create): Copy new attributes. Set the new thread priority. (pthread_attr::pthread_attr): Initialise new members. (pthread_key::pthread_key): Setup destructor function. (pthread_key::~pthread_key): Remove destructor function. (pthread_mutexattr::pthread_mutexattr): New function. (pthread_mutexattr::~pthread_mutexattr): New function. (__pthread_once): New function. (__pthread_cleanup): New function. (__pthread_cancel): New function. (__pthread_setcancelstate): New function. (__pthread_setcanceltype): New function. (__pthread_testcancel): New function. (__pthread_attr_getinheritsched): New function. (__pthread_attr_getschedparam): New function. (__pthread_attr_getschedpolicy): New function. (__pthread_attr_getscope): New function. (__pthread_attr_setinheritsched): New function. (__pthread_attr_setschedparam): New function. (__pthread_attr_setschedpolicy): New function. (__pthread_attr_setscope): New function. (__pthread_exit): Call any key destructors on thread exit. (__pthread_join): Use the embedded attr values. (__pthread_detach): Use the embedded attr values. (__pthread_getconcurrency): New function. (__pthread_getschedparam): New function. (__pthread_key_create): Pass the destructor on object creation. (__pthread_key_delete): Correct incorrect prototype. (__pthread_setconcurrency): New function. (__pthread_setschedparam): New function. (__pthread_cond_timedwait): Support static mutex initialisers. (__pthread_cond_wait): Ditto. (__pthread_mutex_getprioceiling): New function. (__pthread_mutex_lock): Support static mutex initialisers. (__pthread_mutex_trylock): Ditto. (__pthread_mutex_unlock): Ditto. (__pthread_mutex_destroy): Ditto. (__pthread_mutex_setprioceiling): New function. (__pthread_mutexattr_getprotocol): New function. (__pthread_mutexattr_getpshared): New function. (__pthread_mutexattr_gettype): New function. (__pthread_mutexattr_init): New function. (__pthread_mutexattr_destroy): New function. (__pthread_mutexattr_setprotocol): New function. (__pthread_mutexattr_setprioceiling): New function. (__pthread_mutexattr_getprioceiling): New function. (__pthread_mutexattr_setpshared): New function. (__pthread_mutexattr_settype): New function. Remove stubs for non MT_SAFE compilation. * thread.h: Remove duplicate #defines. Add prototypes for new functions in thread.cc. (pthread_key_destructor): New class. (pthread_key_destructor_list): New class. (pthread_attr): Add new members. (pthread): Remove members that are duplicated in the pthread_attr class. (pthread_mutex_attr): Add new members. (pthread_once): New class. * include/pthread.h: Add prototypes for new functions exported from cygwin1.dll. Remove typedefs. * include/sched.h: Add prototypes for new functions in sched.cc. * include/cygwin/types.h: Add typedefs from pthread.h
This commit is contained in:
Robert Collins
parent
eae0943a1f
commit
5c83f260b8
@ -119,7 +119,6 @@ AC_LANG_RESTORE
|
||||
dnl set default mt safeness and then process the options.
|
||||
mt_safe_val=1
|
||||
MT_SAFE=yes
|
||||
PTH_ALLOW=''
|
||||
|
||||
AC_ARG_ENABLE(threadsafe,
|
||||
[ --enable-threadsafe=[runtime] Build a cygwin DLL which is thread safe],
|
||||
@ -134,7 +133,6 @@ runtime)
|
||||
no)
|
||||
mt_safe_val=0
|
||||
MT_SAFE=no
|
||||
PTH_ALLOW=';'
|
||||
;;
|
||||
esac
|
||||
])
|
||||
@ -159,7 +157,6 @@ fi
|
||||
|
||||
dnl Makefile uses MT_SAFE, so we subst as well as defining it.
|
||||
AC_SUBST(MT_SAFE)
|
||||
AC_SUBST(PTH_ALLOW)
|
||||
|
||||
AC_ARG_ENABLE(debugging,
|
||||
[ --enable-debugging Build a cygwin DLL which has more consistency checking for debugging],
|
||||
|
||||
@ -498,6 +498,7 @@ memset
|
||||
_memset = memset
|
||||
mkdir
|
||||
_mkdir = mkdir
|
||||
mkfifo
|
||||
mknod
|
||||
_mknod = mknod
|
||||
mkstemp
|
||||
@ -1075,44 +1076,75 @@ cygwin_attach_handle_to_fd
|
||||
cygwin32_attach_handle_to_fd = cygwin_attach_handle_to_fd
|
||||
cygwin_internal
|
||||
cygwin32_internal = cygwin_internal
|
||||
@PTH_ALLOW@pthread_create
|
||||
@PTH_ALLOW@pthread_attr_init
|
||||
@PTH_ALLOW@pthread_attr_destroy
|
||||
@PTH_ALLOW@pthread_attr_setstacksize
|
||||
@PTH_ALLOW@pthread_attr_getstacksize
|
||||
@PTH_ALLOW@pthread_exit
|
||||
@PTH_ALLOW@pthread_join
|
||||
@PTH_ALLOW@pthread_detach
|
||||
@PTH_ALLOW@pthread_suspend
|
||||
@PTH_ALLOW@pthread_continue
|
||||
@PTH_ALLOW@pthread_key_create
|
||||
@PTH_ALLOW@pthread_key_delete
|
||||
@PTH_ALLOW@pthread_setspecific
|
||||
@PTH_ALLOW@pthread_getspecific
|
||||
@PTH_ALLOW@pthread_kill
|
||||
@PTH_ALLOW@pthread_sigmask
|
||||
@PTH_ALLOW@pthread_self
|
||||
@PTH_ALLOW@pthread_equal
|
||||
@PTH_ALLOW@pthread_mutex_init
|
||||
@PTH_ALLOW@pthread_mutex_lock
|
||||
@PTH_ALLOW@pthread_mutex_trylock
|
||||
@PTH_ALLOW@pthread_mutex_unlock
|
||||
@PTH_ALLOW@pthread_mutex_destroy
|
||||
@PTH_ALLOW@pthread_cond_init
|
||||
@PTH_ALLOW@pthread_cond_destroy
|
||||
@PTH_ALLOW@pthread_cond_broadcast
|
||||
@PTH_ALLOW@pthread_cond_signal
|
||||
@PTH_ALLOW@pthread_cond_wait
|
||||
@PTH_ALLOW@pthread_cond_timedwait
|
||||
@PTH_ALLOW@pthread_condattr_init
|
||||
@PTH_ALLOW@pthread_condattr_destroy
|
||||
@PTH_ALLOW@pthread_condattr_getpshared
|
||||
@PTH_ALLOW@pthread_condattr_setpshared
|
||||
@PTH_ALLOW@sem_init
|
||||
@PTH_ALLOW@sem_destroy
|
||||
@PTH_ALLOW@sem_wait
|
||||
@PTH_ALLOW@sem_trywait
|
||||
@PTH_ALLOW@sem_post
|
||||
pthread_attr_destroy
|
||||
pthread_attr_getdetachstate
|
||||
pthread_attr_getinheritsched
|
||||
pthread_attr_getschedparam
|
||||
pthread_attr_getschedpolicy
|
||||
pthread_attr_getscope
|
||||
pthread_attr_getstacksize
|
||||
pthread_attr_init
|
||||
pthread_attr_setdetachstate
|
||||
pthread_attr_setinheritsched
|
||||
pthread_attr_setschedparam
|
||||
pthread_attr_setschedpolicy
|
||||
pthread_attr_setscope
|
||||
pthread_attr_setstacksize
|
||||
pthread_cancel
|
||||
pthread_cond_broadcast
|
||||
pthread_cond_destroy
|
||||
pthread_cond_init
|
||||
pthread_cond_signal
|
||||
pthread_cond_timedwait
|
||||
pthread_cond_wait
|
||||
pthread_condattr_destroy
|
||||
pthread_condattr_getpshared
|
||||
pthread_condattr_init
|
||||
pthread_condattr_setpshared
|
||||
pthread_create
|
||||
pthread_detach
|
||||
pthread_equal
|
||||
pthread_exit
|
||||
pthread_getconcurrency
|
||||
pthread_getschedparam
|
||||
pthread_getspecific
|
||||
pthread_join
|
||||
pthread_key_create
|
||||
pthread_key_delete
|
||||
pthread_mutex_destroy
|
||||
pthread_mutex_getprioceiling
|
||||
pthread_mutex_init
|
||||
pthread_mutex_lock
|
||||
pthread_mutex_setprioceiling
|
||||
pthread_mutex_trylock
|
||||
pthread_mutex_unlock
|
||||
pthread_mutexattr_destroy
|
||||
pthread_mutexattr_getprioceiling
|
||||
pthread_mutexattr_getprotocol
|
||||
pthread_mutexattr_getpshared
|
||||
pthread_mutexattr_gettype
|
||||
pthread_mutexattr_init
|
||||
pthread_mutexattr_setprioceiling
|
||||
pthread_mutexattr_setprotocol
|
||||
pthread_mutexattr_setpshared
|
||||
pthread_mutexattr_settype
|
||||
pthread_once
|
||||
pthread_self
|
||||
pthread_setcancelstate
|
||||
pthread_setcanceltype
|
||||
pthread_setconcurrency
|
||||
pthread_setschedparam
|
||||
pthread_setspecific
|
||||
pthread_testcancel
|
||||
pthread_suspend
|
||||
pthread_continue
|
||||
pthread_kill
|
||||
pthread_sigmask
|
||||
sem_init
|
||||
sem_destroy
|
||||
sem_wait
|
||||
sem_trywait
|
||||
sem_post
|
||||
sched_get_priority_max
|
||||
sched_get_priority_min
|
||||
sched_getparam
|
||||
|
||||
@ -1 +1,63 @@
|
||||
/* types.h */
|
||||
/* types.h
|
||||
|
||||
Copyright 2001 Red Hat Inc.
|
||||
Written by Robert Collins <rbtcollins@hotmail.com>
|
||||
|
||||
This file is part of Cygwin.
|
||||
|
||||
This software is a copyrighted work licensed under the terms of the
|
||||
Cygwin license. Please consult the file "CYGWIN_LICENSE" for
|
||||
details. */
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C"
|
||||
{
|
||||
#endif
|
||||
|
||||
#ifndef _CYGWIN_TYPES_H
|
||||
#define _CYGWIN_TYPES_H
|
||||
|
||||
#if !defined(__INSIDE_CYGWIN__) || !defined(__cplusplus)
|
||||
|
||||
typedef void *pthread_t;
|
||||
typedef void *pthread_mutex_t;
|
||||
|
||||
typedef void *pthread_key_t;
|
||||
typedef void *pthread_attr_t;
|
||||
typedef void *pthread_mutexattr_t;
|
||||
typedef void *pthread_condattr_t;
|
||||
typedef void *pthread_cond_t;
|
||||
|
||||
/* These variables are not user alterable. This means you!. */
|
||||
typedef struct
|
||||
{
|
||||
pthread_mutex_t mutex;
|
||||
int state;
|
||||
}
|
||||
pthread_once_t;
|
||||
typedef void *pthread_rwlock_t;
|
||||
typedef void *pthread_rwlockattr_t;
|
||||
|
||||
#else
|
||||
|
||||
/* pthreads types */
|
||||
|
||||
typedef class pthread *pthread_t;
|
||||
typedef class pthread_mutex *pthread_mutex_t;
|
||||
typedef class pthread_key *pthread_key_t;
|
||||
typedef class pthread_attr *pthread_attr_t;
|
||||
typedef class pthread_mutexattr *pthread_mutexattr_t;
|
||||
typedef class pthread_condattr *pthread_condattr_t;
|
||||
typedef class pthread_cond *pthread_cond_t;
|
||||
typedef class pthread_once pthread_once_t;
|
||||
typedef class pthread_rwlock *pthread_rwlock_t;
|
||||
typedef class pthread_rwlockattr *pthread_rwlockattr_t;
|
||||
|
||||
/* semaphores types */
|
||||
typedef class semaphore *sem_t;
|
||||
#endif /* __INSIDE_CYGWIN__ */
|
||||
#endif /* _CYGWIN_TYPES_H */
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
@ -12,6 +12,7 @@
|
||||
|
||||
#include <sys/types.h>
|
||||
#include <signal.h>
|
||||
#include <sched.h>
|
||||
|
||||
#ifndef _PTHREAD_H
|
||||
#define _PTHREAD_H
|
||||
@ -29,87 +30,148 @@ extern "C"
|
||||
would normally be written to the passed parameter of pthread_cond_init(lvalue, NULL); */
|
||||
// #define PTHREAD_COND_INITIALIZER 0
|
||||
|
||||
#define PTHREAD_PROCESS_PRIVATE 0
|
||||
#define PTHREAD_PROCESS_SHARED 1
|
||||
#define PTHREAD_DESTRUCTOR_ITERATIONS 1
|
||||
/* Tls has 64 items for pre win2000 - and we don't want to use them all :]
|
||||
* Before committing discuss this with the list
|
||||
*/
|
||||
#define PTHREAD_KEYS_MAX 32
|
||||
/* the default : joinable */
|
||||
|
||||
#define PTHREAD_CANCEL_ASYNCHRONOUS 1
|
||||
/* defaults are enable, deferred */
|
||||
#define PTHREAD_CANCEL_ENABLE 0
|
||||
#define PTHREAD_CANCEL_DEFERRED 0
|
||||
#define PTHREAD_CANCEL_DISABLE 1
|
||||
#define PTHREAD_CANCELED
|
||||
#define PTHREAD_COND_INITIALIZER
|
||||
#define PTHREAD_CREATE_DETACHED 1
|
||||
/* the default : joinable */
|
||||
#define PTHREAD_CREATE_JOINABLE 0
|
||||
#define PTHREAD_EXPLICIT_SCHED 1
|
||||
#define PTHREAD_INHERIT_SCHED 0
|
||||
#define PTHREAD_MUTEX_DEFAULT 0
|
||||
#define PTHREAD_MUTEX_ERRORCHECK 1
|
||||
#define PTHREAD_MUTEX_NORMAL 2
|
||||
/* this should be too low to ever be a valid address */
|
||||
#define PTHREAD_MUTEX_INITIALIZER (void *)20
|
||||
#define PTHREAD_MUTEX_RECURSIVE 0
|
||||
#define PTHREAD_ONCE_INIT { PTHREAD_MUTEX_INITIALIZER, 0 }
|
||||
#define PTHREAD_PRIO_INHERIT
|
||||
#define PTHREAD_PRIO_NONE
|
||||
#define PTHREAD_PRIO_PROTECT
|
||||
#define PTHREAD_PROCESS_SHARED 1
|
||||
#define PTHREAD_PROCESS_PRIVATE 0
|
||||
#define PTHREAD_RWLOCK_INITIALIZER
|
||||
/* process is the default */
|
||||
#define PTHREAD_SCOPE_PROCESS 0
|
||||
#define PTHREAD_SCOPE_SYSTEM 1
|
||||
|
||||
|
||||
/* these shouldn't be defined here but in sys/types.
|
||||
* defining in sys/types mught also allow us to override them for the internal functions
|
||||
* more easily (internal sys/types vs external sys/type - dev thoughts on this?
|
||||
/* Attributes */
|
||||
int pthread_attr_destroy (pthread_attr_t *);
|
||||
int pthread_attr_getdetachstate (const pthread_attr_t *, int *);
|
||||
int pthread_attr_getinheritsched (const pthread_attr_t *, int *);
|
||||
int pthread_attr_getschedparam (const pthread_attr_t *, struct sched_param *);
|
||||
int pthread_attr_getschedpolicy (const pthread_attr_t *, int *);
|
||||
int pthread_attr_getscope (const pthread_attr_t *, int *);
|
||||
int pthread_attr_init (pthread_attr_t *);
|
||||
int pthread_attr_setdetachstate (pthread_attr_t *, int);
|
||||
int pthread_attr_setinheritsched (pthread_attr_t *, int);
|
||||
int pthread_attr_setschedparam (pthread_attr_t *, const struct sched_param *);
|
||||
int pthread_attr_setschedpolicy (pthread_attr_t *, int);
|
||||
int pthread_attr_setscope (pthread_attr_t *, int);
|
||||
|
||||
#ifdef _POSIX_THREAD_ATTR_STACKADDR
|
||||
/* These functions may be implementable via some low level trickery. For now they are
|
||||
* Not supported or implemented. The prototypes are here so if someone greps the
|
||||
* source they will see these comments
|
||||
*/
|
||||
typedef void *pthread_t;
|
||||
typedef void *pthread_mutex_t;
|
||||
int pthread_attr_getstackaddr (const pthread_attr_t *, void **);
|
||||
int pthread_attr_setstackaddr (pthread_attr_t *, void *);
|
||||
#endif
|
||||
|
||||
typedef void *pthread_key_t;
|
||||
typedef void *pthread_attr_t;
|
||||
typedef void *pthread_mutexattr_t;
|
||||
typedef void *pthread_condattr_t;
|
||||
typedef void *pthread_cond_t;
|
||||
#ifdef _POSIX_THREAD_ATTR_STACKSIZE
|
||||
int pthread_attr_getstacksize (const pthread_attr_t *, size_t *);
|
||||
int pthread_attr_setstacksize (pthread_attr_t *, size_t);
|
||||
#endif
|
||||
|
||||
/* ThreadCreation */
|
||||
int pthread_create (pthread_t * thread, const pthread_attr_t * attr,
|
||||
void *(*)(void *), void *arg);
|
||||
int pthread_attr_init (pthread_attr_t * attr);
|
||||
int pthread_attr_destroy (pthread_attr_t * attr);
|
||||
int pthread_attr_setdetachstate (pthread_attr_t *, int);
|
||||
int pthread_attr_getdetachstate (const pthread_attr_t *, int *);
|
||||
int pthread_attr_setstacksize (pthread_attr_t * attr, size_t size);
|
||||
int pthread_attr_getstacksize (pthread_attr_t * attr, size_t * size);
|
||||
int pthread_cancel (pthread_t);
|
||||
/* Macros for cleanup_push and pop;
|
||||
* The function definitions are
|
||||
void pthread_cleanup_push(void (*routine)(void*), void *arg);
|
||||
void pthread_cleanup_pop(int execute);
|
||||
*/
|
||||
typedef void __cleanup_routine_type (void *);
|
||||
|
||||
#define pthread_cleanup_push (fn, arg) { __cleanup_routine_type __cleanup_routine=fn; \
|
||||
void *__cleanup_param=arg;
|
||||
#define pthread_cleanup_pop (execute) if (execute) __cleanup_routine(__cleanup_param); }
|
||||
|
||||
/* Condition variables */
|
||||
int pthread_cond_broadcast (pthread_cond_t *);
|
||||
int pthread_cond_destroy (pthread_cond_t *);
|
||||
int pthread_cond_init (pthread_cond_t *, const pthread_condattr_t *);
|
||||
int pthread_cond_signal (pthread_cond_t *);
|
||||
int pthread_cond_timedwait (pthread_cond_t *,
|
||||
pthread_mutex_t *, const struct timespec *);
|
||||
int pthread_cond_wait (pthread_cond_t *, pthread_mutex_t *);
|
||||
int pthread_condattr_destroy (pthread_condattr_t *);
|
||||
int pthread_condattr_getpshared (const pthread_condattr_t *, int *);
|
||||
int pthread_condattr_init (pthread_condattr_t *);
|
||||
int pthread_condattr_setpshared (pthread_condattr_t *, int);
|
||||
int pthread_cond_broadcast (pthread_cond_t *);
|
||||
int pthread_cond_destroy (pthread_cond_t *);
|
||||
int pthread_cond_init (pthread_cond_t *, const pthread_condattr_t *);
|
||||
int pthread_cond_signal (pthread_cond_t *);
|
||||
int pthread_cond_timedwait (pthread_cond_t *,
|
||||
pthread_mutex_t *, const struct timespec *);
|
||||
int pthread_cond_wait (pthread_cond_t *, pthread_mutex_t *);
|
||||
int pthread_condattr_destroy (pthread_condattr_t *);
|
||||
int pthread_condattr_getpshared (const pthread_condattr_t *, int *);
|
||||
int pthread_condattr_init (pthread_condattr_t *);
|
||||
int pthread_condattr_setpshared (pthread_condattr_t *, int);
|
||||
|
||||
int pthread_create (pthread_t *, const pthread_attr_t *,
|
||||
void *(*)(void *), void *);
|
||||
int pthread_detach (pthread_t);
|
||||
int pthread_equal (pthread_t, pthread_t);
|
||||
void pthread_exit (void *);
|
||||
int pthread_getschedparam (pthread_t, int *, struct sched_param *);
|
||||
void *pthread_getspecific (pthread_key_t);
|
||||
int pthread_join (pthread_t, void **);
|
||||
int pthread_key_create (pthread_key_t *, void (*)(void *));
|
||||
int pthread_key_delete (pthread_key_t);
|
||||
|
||||
/* Mutex's */
|
||||
int pthread_mutex_destroy (pthread_mutex_t *);
|
||||
int pthread_mutex_getprioceiling (const pthread_mutex_t *, int *);
|
||||
int pthread_mutex_init (pthread_mutex_t *, const pthread_mutexattr_t *);
|
||||
int pthread_mutex_lock (pthread_mutex_t *);
|
||||
int pthread_mutex_setprioceiling (pthread_mutex_t *, int, int *);
|
||||
int pthread_mutex_trylock (pthread_mutex_t *);
|
||||
int pthread_mutex_unlock (pthread_mutex_t *);
|
||||
int pthread_mutexattr_destroy (pthread_mutexattr_t *);
|
||||
int pthread_mutexattr_getprioceiling (const pthread_mutexattr_t *, int *);
|
||||
int pthread_mutexattr_getprotocol (const pthread_mutexattr_t *, int *);
|
||||
int pthread_mutexattr_getpshared (const pthread_mutexattr_t *, int *);
|
||||
int pthread_mutexattr_gettype (const pthread_mutexattr_t *, int *);
|
||||
int pthread_mutexattr_init (pthread_mutexattr_t *);
|
||||
int pthread_mutexattr_setprioceiling (pthread_mutexattr_t *, int);
|
||||
int pthread_mutexattr_setprotocol (pthread_mutexattr_t *, int);
|
||||
int pthread_mutexattr_setpshared (pthread_mutexattr_t *, int);
|
||||
int pthread_mutexattr_settype (pthread_mutexattr_t *, int);
|
||||
|
||||
int pthread_once (pthread_once_t *, void (*)(void));
|
||||
|
||||
/* Concurrency levels - X/Open interface */
|
||||
int pthread_getconcurrency (void);
|
||||
int pthread_setconcurrency (int);
|
||||
|
||||
|
||||
/* Thread Control */
|
||||
int pthread_detach (pthread_t thread);
|
||||
int pthread_join (pthread_t thread, void **value_ptr);
|
||||
pthread_t pthread_self (void);
|
||||
int pthread_setcancelstate (int, int *);
|
||||
int pthread_setcanceltype (int, int *);
|
||||
int pthread_setschedparam (pthread_t, int, const struct sched_param *);
|
||||
int pthread_setspecific (pthread_key_t, const void *);
|
||||
void pthread_testcancel (void);
|
||||
|
||||
/* Thread Exit */
|
||||
void pthread_exit (void *value_ptr);
|
||||
/* Non posix calls */
|
||||
|
||||
/* Thread SpecificData */
|
||||
int pthread_key_create (pthread_key_t *, void (*)(void *));
|
||||
int pthread_key_delete (pthread_key_t * key);
|
||||
int pthread_setspecific (pthread_key_t key, const void *value);
|
||||
void *pthread_getspecific (pthread_key_t key);
|
||||
int pthread_suspend (pthread_t);
|
||||
int pthread_continue (pthread_t);
|
||||
|
||||
/* Thread signal (should be in signal.h) */
|
||||
int pthread_kill (pthread_t * thread, int sig);
|
||||
int pthread_sigmask (int operation, const sigset_t * set,
|
||||
sigset_t * old_set);
|
||||
|
||||
/* ID */
|
||||
pthread_t pthread_self ();
|
||||
int pthread_equal (pthread_t t1, pthread_t t2);
|
||||
|
||||
/* Mutexes */
|
||||
int pthread_mutex_init (pthread_mutex_t * mutex,
|
||||
const pthread_mutexattr_t *);
|
||||
int pthread_mutex_lock (pthread_mutex_t * mutext);
|
||||
int pthread_mutex_trylock (pthread_mutex_t * mutext);
|
||||
int pthread_mutex_unlock (pthread_mutex_t * mutext);
|
||||
int pthread_mutex_destroy (pthread_mutex_t * mutext);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* _PTHREAD_H */
|
||||
#endif /* _PTHREAD_H */
|
||||
|
||||
@ -31,21 +31,32 @@ extern "C" {
|
||||
#endif
|
||||
|
||||
/* max priority for policy */
|
||||
int sched_get_priority_max (int);
|
||||
int sched_get_priority_max (int);
|
||||
/* min priority for policy */
|
||||
int sched_get_priority_min (int);
|
||||
int sched_get_priority_min (int);
|
||||
/* get sched params for process */
|
||||
int sched_getparam (pid_t, struct sched_param *);
|
||||
int sched_getparam (pid_t, struct sched_param *);
|
||||
/* get the scheduler for pid */
|
||||
int sched_getscheduler (pid_t);
|
||||
int sched_getscheduler (pid_t);
|
||||
/* get the time quantum for pid */
|
||||
int sched_rr_get_interval (pid_t, struct timespec *);
|
||||
int sched_rr_get_interval (pid_t, struct timespec *);
|
||||
/* set the scheduling parameters */
|
||||
int sched_setparam (pid_t, const struct sched_param *);
|
||||
int sched_setparam (pid_t, const struct sched_param *);
|
||||
/* set the scheduler */
|
||||
int sched_setscheduler (pid_t, int, const struct sched_param *);
|
||||
int sched_setscheduler (pid_t, int, const struct sched_param *);
|
||||
/* yield the cpu */
|
||||
int sched_yield (void);
|
||||
int sched_yield (void);
|
||||
|
||||
#if defined(__INSIDE_CYGWIN__)
|
||||
/* These are private helper functions used to calculate scheduler settings and
|
||||
* validate parameters */
|
||||
|
||||
/* check parameters for validity */
|
||||
int valid_sched_parameters(const struct sched_param *);
|
||||
/* set a single thread's priority */
|
||||
int sched_set_thread_priority(HANDLE thread, int priority);
|
||||
|
||||
#endif /* INSIDE_CYGWIN */
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
|
||||
@ -17,111 +17,193 @@ extern "C"
|
||||
{
|
||||
/* ThreadCreation */
|
||||
int
|
||||
pthread_create (pthread_t * thread, const pthread_attr_t * attr,
|
||||
void *(*start_routine) (void *), void *arg)
|
||||
pthread_create (pthread_t * thread, const pthread_attr_t * attr,
|
||||
void *(*start_routine) (void *), void *arg)
|
||||
{
|
||||
return __pthread_create (thread, attr, start_routine, arg);
|
||||
}
|
||||
|
||||
int pthread_attr_init (pthread_attr_t * attr)
|
||||
int
|
||||
pthread_once (pthread_once_t * once_control, void (*init_routine) (void))
|
||||
{
|
||||
return __pthread_once (once_control, init_routine);
|
||||
}
|
||||
|
||||
int
|
||||
pthread_attr_init (pthread_attr_t * attr)
|
||||
{
|
||||
return __pthread_attr_init (attr);
|
||||
}
|
||||
|
||||
int pthread_attr_destroy (pthread_attr_t * attr)
|
||||
int
|
||||
pthread_attr_destroy (pthread_attr_t * attr)
|
||||
{
|
||||
return __pthread_attr_destroy (attr);
|
||||
}
|
||||
|
||||
int pthread_attr_setdetachstate (pthread_attr_t * attr, int detachstate)
|
||||
int
|
||||
pthread_attr_setdetachstate (pthread_attr_t * attr, int detachstate)
|
||||
{
|
||||
return __pthread_attr_setdetachstate (attr, detachstate);
|
||||
}
|
||||
|
||||
int
|
||||
pthread_attr_getdetachstate (const pthread_attr_t * attr,
|
||||
int *detachstate)
|
||||
pthread_attr_getdetachstate (const pthread_attr_t * attr, int *detachstate)
|
||||
{
|
||||
return __pthread_attr_getdetachstate (attr, detachstate);
|
||||
}
|
||||
|
||||
|
||||
int pthread_attr_setstacksize (pthread_attr_t * attr, size_t size)
|
||||
int
|
||||
pthread_attr_setstacksize (pthread_attr_t * attr, size_t size)
|
||||
{
|
||||
return __pthread_attr_setstacksize (attr, size);
|
||||
}
|
||||
|
||||
int pthread_attr_getstacksize (pthread_attr_t * attr, size_t * size)
|
||||
int
|
||||
pthread_attr_getstacksize (const pthread_attr_t * attr, size_t * size)
|
||||
{
|
||||
return __pthread_attr_getstacksize (attr, size);
|
||||
}
|
||||
|
||||
int
|
||||
pthread_attr_setinheritsched (pthread_attr_t * attr, int inheritsched)
|
||||
{
|
||||
return __pthread_attr_setinheritsched (attr, inheritsched);
|
||||
}
|
||||
|
||||
/*
|
||||
pthread_attr_setstackaddr(...){};
|
||||
pthread_attr_getstackaddr(...){};
|
||||
*/
|
||||
int
|
||||
pthread_attr_getinheritsched (const pthread_attr_t * attr, int *inheritsched)
|
||||
{
|
||||
return __pthread_attr_getinheritsched (attr, inheritsched);
|
||||
}
|
||||
|
||||
int
|
||||
pthread_attr_setschedparam (pthread_attr_t * attr,
|
||||
const struct sched_param *param)
|
||||
{
|
||||
return __pthread_attr_setschedparam (attr, param);
|
||||
}
|
||||
|
||||
int
|
||||
pthread_attr_getschedparam (const pthread_attr_t * attr,
|
||||
struct sched_param *param)
|
||||
{
|
||||
return __pthread_attr_getschedparam (attr, param);
|
||||
}
|
||||
|
||||
int
|
||||
pthread_attr_setschedpolicy (pthread_attr_t * attr, int policy)
|
||||
{
|
||||
return __pthread_attr_setschedpolicy (attr, policy);
|
||||
}
|
||||
|
||||
int
|
||||
pthread_attr_getschedpolicy (const pthread_attr_t * attr, int *policy)
|
||||
{
|
||||
return __pthread_attr_getschedpolicy (attr, policy);
|
||||
}
|
||||
|
||||
int
|
||||
pthread_attr_setscope (pthread_attr_t * attr, int contentionscope)
|
||||
{
|
||||
return __pthread_attr_setscope (attr, contentionscope);
|
||||
}
|
||||
|
||||
int
|
||||
pthread_attr_getscope (const pthread_attr_t * attr, int *contentionscope)
|
||||
{
|
||||
return __pthread_attr_getscope (attr, contentionscope);
|
||||
}
|
||||
|
||||
#ifdef _POSIX_THREAD_ATTR_STACKADDR
|
||||
int
|
||||
pthread_attr_setstackaddr (pthread_attr_t * attr, void *stackaddr)
|
||||
{
|
||||
return __pthread_attr_setstackaddr (attr, stackaddr);
|
||||
}
|
||||
|
||||
int
|
||||
pthread_attr_getstackaddr (const pthread_attr_t * attr, void **stackaddr)
|
||||
{
|
||||
return __pthread_attr_getstackaddr (attr, stackaddr);
|
||||
}
|
||||
#endif
|
||||
|
||||
/* Thread Exit */
|
||||
void pthread_exit (void *value_ptr)
|
||||
void
|
||||
pthread_exit (void *value_ptr)
|
||||
{
|
||||
return __pthread_exit (value_ptr);
|
||||
}
|
||||
|
||||
int pthread_join (pthread_t thread, void **return_val)
|
||||
int
|
||||
pthread_join (pthread_t thread, void **return_val)
|
||||
{
|
||||
return __pthread_join (&thread, (void **) return_val);
|
||||
}
|
||||
|
||||
int pthread_detach (pthread_t thread)
|
||||
int
|
||||
pthread_detach (pthread_t thread)
|
||||
{
|
||||
return __pthread_detach (&thread);
|
||||
}
|
||||
|
||||
int pthread_suspend (pthread_t thread)
|
||||
|
||||
/* This isn't a posix call... should we keep it? */
|
||||
int
|
||||
pthread_suspend (pthread_t thread)
|
||||
{
|
||||
return __pthread_suspend (&thread);
|
||||
}
|
||||
|
||||
int pthread_continue (pthread_t thread)
|
||||
/* same */
|
||||
int
|
||||
pthread_continue (pthread_t thread)
|
||||
{
|
||||
return __pthread_continue (&thread);
|
||||
}
|
||||
|
||||
unsigned long pthread_getsequence_np (pthread_t * thread)
|
||||
unsigned long
|
||||
pthread_getsequence_np (pthread_t * thread)
|
||||
{
|
||||
return __pthread_getsequence_np (thread);
|
||||
}
|
||||
|
||||
/* Thread SpecificData */
|
||||
int pthread_key_create (pthread_key_t * key, void (*destructor) (void *))
|
||||
int
|
||||
pthread_key_create (pthread_key_t * key, void (*destructor) (void *))
|
||||
{
|
||||
return __pthread_key_create (key, destructor);
|
||||
}
|
||||
|
||||
int pthread_key_delete (pthread_key_t * key)
|
||||
int
|
||||
pthread_key_delete (pthread_key_t key)
|
||||
{
|
||||
return __pthread_key_delete (key);
|
||||
}
|
||||
|
||||
int pthread_setspecific (pthread_key_t key, const void *value)
|
||||
int
|
||||
pthread_setspecific (pthread_key_t key, const void *value)
|
||||
{
|
||||
return __pthread_setspecific (key, value);
|
||||
}
|
||||
|
||||
void *pthread_getspecific (pthread_key_t key)
|
||||
void *
|
||||
pthread_getspecific (pthread_key_t key)
|
||||
{
|
||||
return (void *) __pthread_getspecific (key);
|
||||
}
|
||||
|
||||
/* Thread signal */
|
||||
int pthread_kill (pthread_t * thread, int sig)
|
||||
int
|
||||
pthread_kill (pthread_t thread, int sig)
|
||||
{
|
||||
return __pthread_kill (thread, sig);
|
||||
}
|
||||
|
||||
int
|
||||
pthread_sigmask (int operation, const sigset_t * set, sigset_t * old_set)
|
||||
pthread_sigmask (int operation, const sigset_t * set, sigset_t * old_set)
|
||||
{
|
||||
return __pthread_sigmask (operation, set, old_set);
|
||||
}
|
||||
@ -133,120 +215,273 @@ pthread_t pthread_self ()
|
||||
return __pthread_self ();
|
||||
}
|
||||
|
||||
int pthread_equal (pthread_t t1, pthread_t t2)
|
||||
int
|
||||
pthread_equal (pthread_t t1, pthread_t t2)
|
||||
{
|
||||
return __pthread_equal (&t1, &t2);
|
||||
}
|
||||
|
||||
/* Mutexes */
|
||||
int
|
||||
pthread_mutex_init (pthread_mutex_t * mutex,
|
||||
const pthread_mutexattr_t * attr)
|
||||
pthread_mutex_init (pthread_mutex_t * mutex, const pthread_mutexattr_t * attr)
|
||||
{
|
||||
return __pthread_mutex_init (mutex, attr);
|
||||
}
|
||||
|
||||
int pthread_mutex_lock (pthread_mutex_t * mutex)
|
||||
int
|
||||
pthread_mutex_lock (pthread_mutex_t * mutex)
|
||||
{
|
||||
return __pthread_mutex_lock (mutex);
|
||||
}
|
||||
|
||||
int pthread_mutex_trylock (pthread_mutex_t * mutex)
|
||||
int
|
||||
pthread_mutex_trylock (pthread_mutex_t * mutex)
|
||||
{
|
||||
return __pthread_mutex_trylock (mutex);
|
||||
}
|
||||
|
||||
int pthread_mutex_unlock (pthread_mutex_t * mutex)
|
||||
int
|
||||
pthread_mutex_unlock (pthread_mutex_t * mutex)
|
||||
{
|
||||
return __pthread_mutex_unlock (mutex);
|
||||
}
|
||||
|
||||
int pthread_mutex_destroy (pthread_mutex_t * mutex)
|
||||
int
|
||||
pthread_mutex_destroy (pthread_mutex_t * mutex)
|
||||
{
|
||||
return __pthread_mutex_destroy (mutex);
|
||||
}
|
||||
|
||||
int
|
||||
pthread_mutex_setprioceiling (pthread_mutex_t * mutex,
|
||||
int prioceiling, int *old_ceiling)
|
||||
{
|
||||
return __pthread_mutex_setprioceiling (mutex, prioceiling, old_ceiling);
|
||||
}
|
||||
|
||||
int
|
||||
pthread_mutex_getprioceiling (const pthread_mutex_t * mutex, int *prioceiling)
|
||||
{
|
||||
return __pthread_mutex_getprioceiling (mutex, prioceiling);
|
||||
}
|
||||
|
||||
|
||||
|
||||
int
|
||||
pthread_mutexattr_destroy (pthread_mutexattr_t * attr)
|
||||
{
|
||||
return __pthread_mutexattr_destroy (attr);
|
||||
}
|
||||
|
||||
int
|
||||
pthread_mutexattr_getprioceiling (const pthread_mutexattr_t * attr,
|
||||
int *prioceiling)
|
||||
{
|
||||
return __pthread_mutexattr_getprioceiling (attr, prioceiling);
|
||||
}
|
||||
|
||||
int
|
||||
pthread_mutexattr_getprotocol (const pthread_mutexattr_t * attr,
|
||||
int *protocol)
|
||||
{
|
||||
return __pthread_mutexattr_getprotocol (attr, protocol);
|
||||
}
|
||||
|
||||
int
|
||||
pthread_mutexattr_getpshared (const pthread_mutexattr_t * attr, int *pshared)
|
||||
{
|
||||
return __pthread_mutexattr_getpshared (attr, pshared);
|
||||
}
|
||||
|
||||
int
|
||||
pthread_mutexattr_gettype (const pthread_mutexattr_t * attr, int *type)
|
||||
{
|
||||
return __pthread_mutexattr_gettype (attr, type);
|
||||
}
|
||||
|
||||
int
|
||||
pthread_mutexattr_init (pthread_mutexattr_t * attr)
|
||||
{
|
||||
return __pthread_mutexattr_init (attr);
|
||||
}
|
||||
|
||||
int
|
||||
pthread_mutexattr_setprioceiling (pthread_mutexattr_t * attr, int prioceiling)
|
||||
{
|
||||
return __pthread_mutexattr_setprioceiling (attr, prioceiling);
|
||||
}
|
||||
|
||||
int
|
||||
pthread_mutexattr_setprotocol (pthread_mutexattr_t * attr, int protocol)
|
||||
{
|
||||
return __pthread_mutexattr_setprotocol (attr, protocol);
|
||||
}
|
||||
|
||||
int
|
||||
pthread_mutexattr_setpshared (pthread_mutexattr_t * attr, int pshared)
|
||||
{
|
||||
return __pthread_mutexattr_setpshared (attr, pshared);
|
||||
}
|
||||
|
||||
int
|
||||
pthread_mutexattr_settype (pthread_mutexattr_t * attr, int type)
|
||||
{
|
||||
return __pthread_mutexattr_settype (attr, type);
|
||||
}
|
||||
|
||||
/* Synchronisation */
|
||||
|
||||
int pthread_cond_destroy (pthread_cond_t * cond)
|
||||
int
|
||||
pthread_cond_destroy (pthread_cond_t * cond)
|
||||
{
|
||||
return __pthread_cond_destroy (cond);
|
||||
}
|
||||
|
||||
int
|
||||
pthread_cond_init (pthread_cond_t * cond, const pthread_condattr_t * attr)
|
||||
pthread_cond_init (pthread_cond_t * cond, const pthread_condattr_t * attr)
|
||||
{
|
||||
return __pthread_cond_init (cond, attr);
|
||||
}
|
||||
|
||||
int pthread_cond_signal (pthread_cond_t * cond)
|
||||
int
|
||||
pthread_cond_signal (pthread_cond_t * cond)
|
||||
{
|
||||
return __pthread_cond_signal (cond);
|
||||
}
|
||||
|
||||
int pthread_cond_broadcast (pthread_cond_t * cond)
|
||||
int
|
||||
pthread_cond_broadcast (pthread_cond_t * cond)
|
||||
{
|
||||
return __pthread_cond_broadcast (cond);
|
||||
}
|
||||
|
||||
int
|
||||
pthread_cond_timedwait (pthread_cond_t * cond,
|
||||
pthread_mutex_t * mutex,
|
||||
const struct timespec *abstime)
|
||||
pthread_cond_timedwait (pthread_cond_t * cond,
|
||||
pthread_mutex_t * mutex,
|
||||
const struct timespec *abstime)
|
||||
{
|
||||
return __pthread_cond_timedwait (cond, mutex, abstime);
|
||||
}
|
||||
|
||||
int pthread_cond_wait (pthread_cond_t * cond, pthread_mutex_t * mutex)
|
||||
int
|
||||
pthread_cond_wait (pthread_cond_t * cond, pthread_mutex_t * mutex)
|
||||
{
|
||||
return __pthread_cond_wait (cond, mutex);
|
||||
}
|
||||
|
||||
int pthread_condattr_init (pthread_condattr_t * condattr)
|
||||
int
|
||||
pthread_condattr_init (pthread_condattr_t * condattr)
|
||||
{
|
||||
return __pthread_condattr_init (condattr);
|
||||
}
|
||||
|
||||
int pthread_condattr_destroy (pthread_condattr_t * condattr)
|
||||
int
|
||||
pthread_condattr_destroy (pthread_condattr_t * condattr)
|
||||
{
|
||||
return __pthread_condattr_destroy (condattr);
|
||||
}
|
||||
|
||||
int
|
||||
pthread_condattr_getpshared (const pthread_condattr_t * attr,
|
||||
int *pshared)
|
||||
pthread_condattr_getpshared (const pthread_condattr_t * attr, int *pshared)
|
||||
{
|
||||
return __pthread_condattr_getpshared (attr, pshared);
|
||||
}
|
||||
|
||||
int pthread_condattr_setpshared (pthread_condattr_t * attr, int pshared)
|
||||
int
|
||||
pthread_condattr_setpshared (pthread_condattr_t * attr, int pshared)
|
||||
{
|
||||
return __pthread_condattr_setpshared (attr, pshared);
|
||||
}
|
||||
|
||||
/* Scheduling */
|
||||
|
||||
int
|
||||
pthread_getconcurrency (void)
|
||||
{
|
||||
return __pthread_getconcurrency ();
|
||||
}
|
||||
|
||||
int
|
||||
pthread_setconcurrency (int new_level)
|
||||
{
|
||||
return __pthread_setconcurrency (new_level);
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
int
|
||||
pthread_getschedparam (pthread_t thread, int *policy,
|
||||
struct sched_param *param)
|
||||
{
|
||||
return __pthread_getschedparam (thread, policy, param);
|
||||
}
|
||||
|
||||
int
|
||||
pthread_setschedparam (pthread_t thread, int policy,
|
||||
const struct sched_param *param)
|
||||
{
|
||||
return __pthread_setschedparam (thread, policy, param);
|
||||
}
|
||||
|
||||
|
||||
/* Cancelability */
|
||||
|
||||
int
|
||||
pthread_cancel (pthread_t thread)
|
||||
{
|
||||
return __pthread_cancel (thread);
|
||||
}
|
||||
|
||||
|
||||
|
||||
int
|
||||
pthread_setcancelstate (int state, int *oldstate)
|
||||
{
|
||||
return __pthread_setcancelstate (state, oldstate);
|
||||
}
|
||||
|
||||
int
|
||||
pthread_setcanceltype (int type, int *oldtype)
|
||||
{
|
||||
return __pthread_setcanceltype (type, oldtype);
|
||||
}
|
||||
|
||||
void
|
||||
pthread_testcancel (void)
|
||||
{
|
||||
__pthread_testcancel ();
|
||||
}
|
||||
|
||||
/* Semaphores */
|
||||
int sem_init (sem_t * sem, int pshared, unsigned int value)
|
||||
int
|
||||
sem_init (sem_t * sem, int pshared, unsigned int value)
|
||||
{
|
||||
return __sem_init (sem, pshared, value);
|
||||
}
|
||||
|
||||
int sem_destroy (sem_t * sem)
|
||||
int
|
||||
sem_destroy (sem_t * sem)
|
||||
{
|
||||
return __sem_destroy (sem);
|
||||
}
|
||||
|
||||
int sem_wait (sem_t * sem)
|
||||
int
|
||||
sem_wait (sem_t * sem)
|
||||
{
|
||||
return __sem_wait (sem);
|
||||
}
|
||||
|
||||
int sem_trywait (sem_t * sem)
|
||||
int
|
||||
sem_trywait (sem_t * sem)
|
||||
{
|
||||
return __sem_trywait (sem);
|
||||
}
|
||||
|
||||
int sem_post (sem_t * sem)
|
||||
int
|
||||
sem_post (sem_t * sem)
|
||||
{
|
||||
return __sem_post (sem);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@ -81,6 +81,18 @@ sched_get_priority_min (int policy)
|
||||
return 15;
|
||||
}
|
||||
|
||||
/* Check a scheduler parameter struct for valid settings */
|
||||
int
|
||||
valid_sched_parameters(const struct sched_param *param)
|
||||
{
|
||||
if (param->sched_priority < -14 || param->sched_priority > 15)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
return -1;
|
||||
|
||||
}
|
||||
|
||||
/* get sched params for process
|
||||
|
||||
Note, I'm never returning EPERM,
|
||||
@ -273,7 +285,7 @@ sched_setparam (pid_t pid, const struct sched_param *param)
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (param->sched_priority < -14 || param->sched_priority > 15)
|
||||
if (!valid_sched_parameters(param))
|
||||
{
|
||||
set_errno (EINVAL);
|
||||
return -1;
|
||||
@ -384,6 +396,36 @@ sched_setparam (pid_t pid, const struct sched_param *param)
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* we map -14 to 15, and 15 to 1 via (16- ((n+16) >> 1)). This lines up with the allowed
|
||||
* valueswe return elsewhere in the sched* functions. We then map in groups of three to
|
||||
* allowed thread priority's. The reason for dropping accuracy while still returning
|
||||
* a wide range of values is to allow more flexible code in the future.
|
||||
*/
|
||||
int
|
||||
sched_set_thread_priority(HANDLE thread, int priority)
|
||||
{
|
||||
int real_pri;
|
||||
real_pri = 16 - ((priority + 16) >> 1);
|
||||
if (real_pri <1 || real_pri > 15)
|
||||
return EINVAL;
|
||||
|
||||
if (real_pri < 4)
|
||||
real_pri = THREAD_PRIORITY_LOWEST;
|
||||
else if (real_pri < 7)
|
||||
real_pri = THREAD_PRIORITY_BELOW_NORMAL;
|
||||
else if (real_pri < 10)
|
||||
real_pri = THREAD_PRIORITY_NORMAL;
|
||||
else if (real_pri < 13)
|
||||
real_pri = THREAD_PRIORITY_ABOVE_NORMAL;
|
||||
else
|
||||
real_pri = THREAD_PRIORITY_HIGHEST;
|
||||
|
||||
if (!SetThreadPriority(thread, real_pri))
|
||||
/* invalid handle, no access are the only expected errors. */
|
||||
return EPERM;
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* set the scheduler */
|
||||
int
|
||||
sched_setscheduler (pid_t pid, int policy,
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@ -26,7 +26,7 @@ details. */
|
||||
extern "C"
|
||||
{
|
||||
#if defined (_CYG_THREAD_FAILSAFE) && defined (_MT_SAFE)
|
||||
void AssertResourceOwner (int, int);
|
||||
void AssertResourceOwner (int, int);
|
||||
#else
|
||||
#define AssertResourceOwner(i,ii)
|
||||
#endif
|
||||
@ -39,21 +39,7 @@ void AssertResourceOwner (int, int);
|
||||
|
||||
#else
|
||||
|
||||
//#include <pthread.h>
|
||||
/* FIXME: these are defined in pthread.h, but pthread.h defines symbols it shouldn't -
|
||||
* all the types.
|
||||
*/
|
||||
#define PTHREAD_PROCESS_PRIVATE 0
|
||||
#define PTHREAD_PROCESS_SHARED 1
|
||||
#define PTHREAD_DESTRUCTOR_ITERATIONS 1
|
||||
/* Tls has 64 items for pre win2000 - and we don't want to use them all :]
|
||||
* Before committing discuss this with the list
|
||||
*/
|
||||
#define PTHREAD_KEYS_MAX 32
|
||||
#define PTHREAD_CREATE_DETACHED 1
|
||||
/* the default : joinable */
|
||||
#define PTHREAD_CREATE_JOINABLE 0
|
||||
|
||||
#include <pthread.h>
|
||||
#include <signal.h>
|
||||
#include <pwd.h>
|
||||
#include <grp.h>
|
||||
@ -66,8 +52,8 @@ extern "C"
|
||||
struct _winsup_t
|
||||
{
|
||||
/*
|
||||
Needed for the group functions
|
||||
*/
|
||||
Needed for the group functions
|
||||
*/
|
||||
struct group _grp;
|
||||
char *_namearray[2];
|
||||
int _grp_pos;
|
||||
@ -136,7 +122,9 @@ class pinfo;
|
||||
class ResourceLocks
|
||||
{
|
||||
public:
|
||||
ResourceLocks () {}
|
||||
ResourceLocks ()
|
||||
{
|
||||
}
|
||||
LPCRITICAL_SECTION Lock (int);
|
||||
void Init ();
|
||||
void Delete ();
|
||||
@ -157,26 +145,74 @@ private:
|
||||
#define PTHREAD_COND_MAGIC PTHREAD_MAGIC+5
|
||||
#define PTHREAD_CONDATTR_MAGIC PTHREAD_MAGIC+6
|
||||
#define SEM_MAGIC PTHREAD_MAGIC+7
|
||||
#define PTHREAD_ONCE_MAGIC PTHREAD_MAGIC+8;
|
||||
|
||||
/* verifyable_object should not be defined here - it's a general purpose class */
|
||||
|
||||
class verifyable_object
|
||||
{
|
||||
public:
|
||||
long magic;
|
||||
|
||||
verifyable_object (long);
|
||||
~verifyable_object ();
|
||||
verifyable_object (long);
|
||||
~verifyable_object ();
|
||||
};
|
||||
|
||||
int verifyable_object_isvalid (verifyable_object *, long);
|
||||
|
||||
class pthread_key:public verifyable_object
|
||||
{
|
||||
public:
|
||||
|
||||
DWORD dwTlsIndex;
|
||||
int set (const void *);
|
||||
void *get ();
|
||||
|
||||
pthread_key (void (*)(void *));
|
||||
~pthread_key ();
|
||||
};
|
||||
|
||||
/* FIXME: test using multiple inheritance and merging key_destructor into pthread_key
|
||||
* for efficiency */
|
||||
class pthread_key_destructor
|
||||
{
|
||||
public:
|
||||
void (*destructor) (void *);
|
||||
pthread_key_destructor *InsertAfter (pthread_key_destructor * node);
|
||||
pthread_key_destructor *UnlinkNext ();
|
||||
pthread_key_destructor *Next ();
|
||||
|
||||
pthread_key_destructor (void (*thedestructor) (void *), pthread_key * key);
|
||||
pthread_key_destructor *next;
|
||||
pthread_key *key;
|
||||
};
|
||||
|
||||
class pthread_key_destructor_list
|
||||
{
|
||||
public:
|
||||
void Insert (pthread_key_destructor * node);
|
||||
/* remove a given dataitem, wherever in the list it is */
|
||||
pthread_key_destructor *Remove (pthread_key_destructor * item);
|
||||
/* get the first item and remove at the same time */
|
||||
pthread_key_destructor *Pop ();
|
||||
pthread_key_destructor *Remove (pthread_key * key);
|
||||
void IterateNull ();
|
||||
private:
|
||||
pthread_key_destructor * head;
|
||||
};
|
||||
|
||||
|
||||
class pthread_attr:public verifyable_object
|
||||
{
|
||||
public:
|
||||
int joinable;
|
||||
int contentionscope;
|
||||
int inheritsched;
|
||||
struct sched_param schedparam;
|
||||
size_t stacksize;
|
||||
|
||||
pthread_attr ();
|
||||
~pthread_attr ();
|
||||
pthread_attr ();
|
||||
~pthread_attr ();
|
||||
};
|
||||
|
||||
class pthread:public verifyable_object
|
||||
@ -188,7 +224,9 @@ public:
|
||||
void *arg;
|
||||
void *return_ptr;
|
||||
bool suspended;
|
||||
int joinable;
|
||||
int cancelstate, canceltype;
|
||||
// int joinable;
|
||||
|
||||
DWORD GetThreadId ()
|
||||
{
|
||||
return thread_id;
|
||||
@ -204,18 +242,20 @@ public:
|
||||
LONG *sigtodo;
|
||||
void create (void *(*)(void *), pthread_attr *, void *);
|
||||
|
||||
pthread ();
|
||||
~pthread ();
|
||||
pthread ();
|
||||
~pthread ();
|
||||
|
||||
private:
|
||||
DWORD thread_id;
|
||||
DWORD thread_id;
|
||||
};
|
||||
|
||||
class pthread_mutexattr:public verifyable_object
|
||||
{
|
||||
public:
|
||||
pthread_mutexattr ();
|
||||
~pthread_mutexattr ();
|
||||
int pshared;
|
||||
int mutextype;
|
||||
pthread_mutexattr ();
|
||||
~pthread_mutexattr ();
|
||||
};
|
||||
|
||||
class pthread_mutex:public verifyable_object
|
||||
@ -228,20 +268,8 @@ public:
|
||||
int TryLock ();
|
||||
int UnLock ();
|
||||
|
||||
pthread_mutex (pthread_mutexattr *);
|
||||
~pthread_mutex ();
|
||||
};
|
||||
|
||||
class pthread_key:public verifyable_object
|
||||
{
|
||||
public:
|
||||
|
||||
DWORD dwTlsIndex;
|
||||
int set (const void *);
|
||||
void *get ();
|
||||
|
||||
pthread_key ();
|
||||
~pthread_key ();
|
||||
pthread_mutex (pthread_mutexattr *);
|
||||
~pthread_mutex ();
|
||||
};
|
||||
|
||||
class pthread_condattr:public verifyable_object
|
||||
@ -249,8 +277,8 @@ class pthread_condattr:public verifyable_object
|
||||
public:
|
||||
int shared;
|
||||
|
||||
pthread_condattr ();
|
||||
~pthread_condattr ();
|
||||
pthread_condattr ();
|
||||
~pthread_condattr ();
|
||||
};
|
||||
|
||||
class pthread_cond:public verifyable_object
|
||||
@ -264,8 +292,15 @@ public:
|
||||
void BroadCast ();
|
||||
void Signal ();
|
||||
|
||||
pthread_cond (pthread_condattr *);
|
||||
~pthread_cond ();
|
||||
pthread_cond (pthread_condattr *);
|
||||
~pthread_cond ();
|
||||
};
|
||||
|
||||
class pthread_once
|
||||
{
|
||||
public:
|
||||
pthread_mutex_t mutex;
|
||||
int state;
|
||||
};
|
||||
|
||||
/* shouldn't be here */
|
||||
@ -278,21 +313,10 @@ public:
|
||||
void Post ();
|
||||
int TryWait ();
|
||||
|
||||
semaphore (int, unsigned int);
|
||||
~semaphore ();
|
||||
semaphore (int, unsigned int);
|
||||
~semaphore ();
|
||||
};
|
||||
|
||||
typedef class pthread *pthread_t;
|
||||
typedef class pthread_mutex *pthread_mutex_t;
|
||||
/* sem routines belong in semaphore.cc */
|
||||
typedef class semaphore *sem_t;
|
||||
|
||||
typedef class pthread_key *pthread_key_t;
|
||||
typedef class pthread_attr *pthread_attr_t;
|
||||
typedef class pthread_mutexattr *pthread_mutexattr_t;
|
||||
typedef class pthread_condattr *pthread_condattr_t;
|
||||
typedef class pthread_cond *pthread_cond_t;
|
||||
|
||||
class MTinterface
|
||||
{
|
||||
public:
|
||||
@ -301,94 +325,143 @@ public:
|
||||
DWORD thread_self_dwTlsIndex;
|
||||
/* we may get 0 for the Tls index.. grrr */
|
||||
int indexallocated;
|
||||
int concurrency;
|
||||
|
||||
// Used for main thread data, and sigproc thread
|
||||
struct __reent_t reents;
|
||||
struct _winsup_t winsup_reent;
|
||||
pthread mainthread;
|
||||
|
||||
pthread_key_destructor_list destructors;
|
||||
|
||||
void Init (int);
|
||||
|
||||
MTinterface ():reent_index (0), indexallocated (0)
|
||||
{}
|
||||
MTinterface ():reent_index (0), indexallocated (0)
|
||||
{
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
extern "C"
|
||||
{
|
||||
void *thread_init_wrapper (void *);
|
||||
void *thread_init_wrapper (void *);
|
||||
|
||||
/* ThreadCreation */
|
||||
int __pthread_create (pthread_t * thread, const pthread_attr_t * attr,
|
||||
void *(*start_routine) (void *), void *arg);
|
||||
int __pthread_attr_init (pthread_attr_t * attr);
|
||||
int __pthread_attr_destroy (pthread_attr_t * attr);
|
||||
int __pthread_attr_setdetachstate (pthread_attr_t *, int);
|
||||
int __pthread_attr_getdetachstate (const pthread_attr_t *, int *);
|
||||
int __pthread_attr_setstacksize (pthread_attr_t * attr, size_t size);
|
||||
int __pthread_attr_getstacksize (pthread_attr_t * attr, size_t * size);
|
||||
/*
|
||||
__pthread_attr_setstackaddr(...);
|
||||
__pthread_attr_getstackaddr(...);
|
||||
*/
|
||||
int __pthread_create (pthread_t * thread, const pthread_attr_t * attr,
|
||||
void *(*start_routine) (void *), void *arg);
|
||||
int __pthread_once (pthread_once_t *, void (*)(void));
|
||||
|
||||
int __pthread_attr_init (pthread_attr_t * attr);
|
||||
int __pthread_attr_destroy (pthread_attr_t * attr);
|
||||
int __pthread_attr_setdetachstate (pthread_attr_t *, int);
|
||||
int __pthread_attr_getdetachstate (const pthread_attr_t *, int *);
|
||||
int __pthread_attr_setstacksize (pthread_attr_t * attr, size_t size);
|
||||
int __pthread_attr_getstacksize (const pthread_attr_t * attr, size_t * size);
|
||||
|
||||
int __pthread_attr_getinheritsched (const pthread_attr_t *, int *);
|
||||
int __pthread_attr_getschedparam (const pthread_attr_t *,
|
||||
struct sched_param *);
|
||||
int __pthread_attr_getschedpolicy (const pthread_attr_t *, int *);
|
||||
int __pthread_attr_getscope (const pthread_attr_t *, int *);
|
||||
int __pthread_attr_getstackaddr (const pthread_attr_t *, void **);
|
||||
int __pthread_attr_setinheritsched (pthread_attr_t *, int);
|
||||
int __pthread_attr_setschedparam (pthread_attr_t *,
|
||||
const struct sched_param *);
|
||||
int __pthread_attr_setschedpolicy (pthread_attr_t *, int);
|
||||
int __pthread_attr_setscope (pthread_attr_t *, int);
|
||||
int __pthread_attr_setstackaddr (pthread_attr_t *, void *);
|
||||
|
||||
|
||||
|
||||
/* Thread Exit */
|
||||
void __pthread_exit (void *value_ptr);
|
||||
int __pthread_join (pthread_t * thread, void **return_val);
|
||||
int __pthread_detach (pthread_t * thread);
|
||||
void __pthread_exit (void *value_ptr);
|
||||
int __pthread_join (pthread_t * thread, void **return_val);
|
||||
int __pthread_detach (pthread_t * thread);
|
||||
|
||||
/* Thread suspend */
|
||||
|
||||
int __pthread_suspend (pthread_t * thread);
|
||||
int __pthread_continue (pthread_t * thread);
|
||||
int __pthread_suspend (pthread_t * thread);
|
||||
int __pthread_continue (pthread_t * thread);
|
||||
|
||||
unsigned long __pthread_getsequence_np (pthread_t * thread);
|
||||
unsigned long __pthread_getsequence_np (pthread_t * thread);
|
||||
|
||||
/* Thread SpecificData */
|
||||
int __pthread_key_create (pthread_key_t * key, void (*destructor) (void *));
|
||||
int __pthread_key_delete (pthread_key_t * key);
|
||||
int __pthread_setspecific (pthread_key_t key, const void *value);
|
||||
void *__pthread_getspecific (pthread_key_t key);
|
||||
int __pthread_key_create (pthread_key_t * key, void (*destructor) (void *));
|
||||
int __pthread_key_delete (pthread_key_t key);
|
||||
int __pthread_setspecific (pthread_key_t key, const void *value);
|
||||
void *__pthread_getspecific (pthread_key_t key);
|
||||
|
||||
/* Thead synchroniation */
|
||||
int __pthread_cond_destroy (pthread_cond_t * cond);
|
||||
int __pthread_cond_init (pthread_cond_t * cond,
|
||||
const pthread_condattr_t * attr);
|
||||
int __pthread_cond_signal (pthread_cond_t * cond);
|
||||
int __pthread_cond_broadcast (pthread_cond_t * cond);
|
||||
int __pthread_cond_timedwait (pthread_cond_t * cond,
|
||||
pthread_mutex_t * mutex,
|
||||
const struct timespec *abstime);
|
||||
int __pthread_cond_wait (pthread_cond_t * cond, pthread_mutex_t * mutex);
|
||||
int __pthread_condattr_init (pthread_condattr_t * condattr);
|
||||
int __pthread_condattr_destroy (pthread_condattr_t * condattr);
|
||||
int __pthread_condattr_getpshared (const pthread_condattr_t * attr,
|
||||
int *pshared);
|
||||
int __pthread_condattr_setpshared (pthread_condattr_t * attr, int pshared);
|
||||
int __pthread_cond_destroy (pthread_cond_t * cond);
|
||||
int __pthread_cond_init (pthread_cond_t * cond,
|
||||
const pthread_condattr_t * attr);
|
||||
int __pthread_cond_signal (pthread_cond_t * cond);
|
||||
int __pthread_cond_broadcast (pthread_cond_t * cond);
|
||||
int __pthread_cond_timedwait (pthread_cond_t * cond,
|
||||
pthread_mutex_t * mutex,
|
||||
const struct timespec *abstime);
|
||||
int __pthread_cond_wait (pthread_cond_t * cond, pthread_mutex_t * mutex);
|
||||
int __pthread_condattr_init (pthread_condattr_t * condattr);
|
||||
int __pthread_condattr_destroy (pthread_condattr_t * condattr);
|
||||
int __pthread_condattr_getpshared (const pthread_condattr_t * attr,
|
||||
int *pshared);
|
||||
int __pthread_condattr_setpshared (pthread_condattr_t * attr, int pshared);
|
||||
|
||||
/* Thread signal */
|
||||
int __pthread_kill (pthread_t * thread, int sig);
|
||||
int __pthread_sigmask (int operation, const sigset_t * set,
|
||||
sigset_t * old_set);
|
||||
int __pthread_kill (pthread_t thread, int sig);
|
||||
int __pthread_sigmask (int operation, const sigset_t * set,
|
||||
sigset_t * old_set);
|
||||
|
||||
/* ID */
|
||||
pthread_t __pthread_self ();
|
||||
int __pthread_equal (pthread_t * t1, pthread_t * t2);
|
||||
pthread_t __pthread_self ();
|
||||
int __pthread_equal (pthread_t * t1, pthread_t * t2);
|
||||
|
||||
|
||||
/* Mutexes */
|
||||
int __pthread_mutex_init (pthread_mutex_t *, const pthread_mutexattr_t *);
|
||||
int __pthread_mutex_lock (pthread_mutex_t *);
|
||||
int __pthread_mutex_trylock (pthread_mutex_t *);
|
||||
int __pthread_mutex_unlock (pthread_mutex_t *);
|
||||
int __pthread_mutex_destroy (pthread_mutex_t *);
|
||||
int __pthread_mutex_init (pthread_mutex_t *, const pthread_mutexattr_t *);
|
||||
int __pthread_mutex_lock (pthread_mutex_t *);
|
||||
int __pthread_mutex_trylock (pthread_mutex_t *);
|
||||
int __pthread_mutex_unlock (pthread_mutex_t *);
|
||||
int __pthread_mutex_destroy (pthread_mutex_t *);
|
||||
int __pthread_mutex_setprioceiling (pthread_mutex_t * mutex,
|
||||
int prioceiling, int *old_ceiling);
|
||||
int __pthread_mutex_getprioceiling (const pthread_mutex_t * mutex,
|
||||
int *prioceiling);
|
||||
|
||||
|
||||
int __pthread_mutexattr_destroy (pthread_mutexattr_t *);
|
||||
int __pthread_mutexattr_getprioceiling (const pthread_mutexattr_t *, int *);
|
||||
int __pthread_mutexattr_getprotocol (const pthread_mutexattr_t *, int *);
|
||||
int __pthread_mutexattr_getpshared (const pthread_mutexattr_t *, int *);
|
||||
int __pthread_mutexattr_gettype (const pthread_mutexattr_t *, int *);
|
||||
int __pthread_mutexattr_init (pthread_mutexattr_t *);
|
||||
int __pthread_mutexattr_setprioceiling (pthread_mutexattr_t *, int);
|
||||
int __pthread_mutexattr_setprotocol (pthread_mutexattr_t *, int);
|
||||
int __pthread_mutexattr_setpshared (pthread_mutexattr_t *, int);
|
||||
int __pthread_mutexattr_settype (pthread_mutexattr_t *, int);
|
||||
|
||||
|
||||
/* Scheduling */
|
||||
int __pthread_getconcurrency (void);
|
||||
int __pthread_setconcurrency (int new_level);
|
||||
int __pthread_getschedparam (pthread_t thread, int *policy,
|
||||
struct sched_param *param);
|
||||
int __pthread_setschedparam (pthread_t thread, int policy,
|
||||
const struct sched_param *param);
|
||||
|
||||
/* cancelability states */
|
||||
int __pthread_cancel (pthread_t thread);
|
||||
int __pthread_setcancelstate (int state, int *oldstate);
|
||||
int __pthread_setcanceltype (int type, int *oldtype);
|
||||
void __pthread_testcancel (void);
|
||||
|
||||
|
||||
/* Semaphores */
|
||||
int __sem_init (sem_t * sem, int pshared, unsigned int value);
|
||||
int __sem_destroy (sem_t * sem);
|
||||
int __sem_wait (sem_t * sem);
|
||||
int __sem_trywait (sem_t * sem);
|
||||
int __sem_post (sem_t * sem);
|
||||
int __sem_init (sem_t * sem, int pshared, unsigned int value);
|
||||
int __sem_destroy (sem_t * sem);
|
||||
int __sem_wait (sem_t * sem);
|
||||
int __sem_trywait (sem_t * sem);
|
||||
int __sem_post (sem_t * sem);
|
||||
};
|
||||
|
||||
#endif // MT_SAFE
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user