JehanneOS/newlib
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

* configure.in: Remove PTH_ALLOW.

Browse Source 
* 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
2001-04-12 04:04:53 +00:00
parent eae0943a1f
commit 5c83f260b8
9 changed files with 1535 additions and 479 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
winsup/cygwin/configure.in
View File

@@ -119,7 +119,6 @@ AC_LANG_RESTORE
dnl set default mt safeness and then process the options. dnl set default mt safeness and then process the options.
mt_safe_val=1 mt_safe_val=1
MT_SAFE=yes MT_SAFE=yes
PTH_ALLOW=''
AC_ARG_ENABLE(threadsafe, AC_ARG_ENABLE(threadsafe,
[ --enable-threadsafe=[runtime] Build a cygwin DLL which is thread safe], [ --enable-threadsafe=[runtime] Build a cygwin DLL which is thread safe],
@@ -134,7 +133,6 @@ runtime)
no) no)
mt_safe_val=0 mt_safe_val=0
MT_SAFE=no MT_SAFE=no
PTH_ALLOW=';'
;; ;;
esac esac
]) ])
@@ -159,7 +157,6 @@ fi
dnl Makefile uses MT_SAFE, so we subst as well as defining it. dnl Makefile uses MT_SAFE, so we subst as well as defining it.
AC_SUBST(MT_SAFE) AC_SUBST(MT_SAFE)
AC_SUBST(PTH_ALLOW)
AC_ARG_ENABLE(debugging, AC_ARG_ENABLE(debugging,
[ --enable-debugging Build a cygwin DLL which has more consistency checking for debugging], [ --enable-debugging Build a cygwin DLL which has more consistency checking for debugging],

108
winsup/cygwin/cygwin.din
View File

@@ -498,6 +498,7 @@ memset
_memset = memset _memset = memset
mkdir mkdir
_mkdir = mkdir _mkdir = mkdir
mkfifo
mknod mknod
_mknod = mknod _mknod = mknod
mkstemp mkstemp
@@ -1075,44 +1076,75 @@ cygwin_attach_handle_to_fd
cygwin32_attach_handle_to_fd = cygwin_attach_handle_to_fd cygwin32_attach_handle_to_fd = cygwin_attach_handle_to_fd
cygwin_internal cygwin_internal
cygwin32_internal = cygwin_internal cygwin32_internal = cygwin_internal
@PTH_ALLOW@pthread_create pthread_attr_destroy
@PTH_ALLOW@pthread_attr_init pthread_attr_getdetachstate
@PTH_ALLOW@pthread_attr_destroy pthread_attr_getinheritsched
@PTH_ALLOW@pthread_attr_setstacksize pthread_attr_getschedparam
@PTH_ALLOW@pthread_attr_getstacksize pthread_attr_getschedpolicy
@PTH_ALLOW@pthread_exit pthread_attr_getscope
@PTH_ALLOW@pthread_join pthread_attr_getstacksize
@PTH_ALLOW@pthread_detach pthread_attr_init
@PTH_ALLOW@pthread_suspend pthread_attr_setdetachstate
@PTH_ALLOW@pthread_continue pthread_attr_setinheritsched
@PTH_ALLOW@pthread_key_create pthread_attr_setschedparam
@PTH_ALLOW@pthread_key_delete pthread_attr_setschedpolicy
@PTH_ALLOW@pthread_setspecific pthread_attr_setscope
@PTH_ALLOW@pthread_getspecific pthread_attr_setstacksize
@PTH_ALLOW@pthread_kill pthread_cancel
@PTH_ALLOW@pthread_sigmask pthread_cond_broadcast
@PTH_ALLOW@pthread_self pthread_cond_destroy
@PTH_ALLOW@pthread_equal pthread_cond_init
@PTH_ALLOW@pthread_mutex_init pthread_cond_signal
@PTH_ALLOW@pthread_mutex_lock pthread_cond_timedwait
@PTH_ALLOW@pthread_mutex_trylock pthread_cond_wait
@PTH_ALLOW@pthread_mutex_unlock pthread_condattr_destroy
@PTH_ALLOW@pthread_mutex_destroy pthread_condattr_getpshared
@PTH_ALLOW@pthread_cond_init pthread_condattr_init
@PTH_ALLOW@pthread_cond_destroy pthread_condattr_setpshared
@PTH_ALLOW@pthread_cond_broadcast pthread_create
@PTH_ALLOW@pthread_cond_signal pthread_detach
@PTH_ALLOW@pthread_cond_wait pthread_equal
@PTH_ALLOW@pthread_cond_timedwait pthread_exit
@PTH_ALLOW@pthread_condattr_init pthread_getconcurrency
@PTH_ALLOW@pthread_condattr_destroy pthread_getschedparam
@PTH_ALLOW@pthread_condattr_getpshared pthread_getspecific
@PTH_ALLOW@pthread_condattr_setpshared pthread_join
@PTH_ALLOW@sem_init pthread_key_create
@PTH_ALLOW@sem_destroy pthread_key_delete
@PTH_ALLOW@sem_wait pthread_mutex_destroy
@PTH_ALLOW@sem_trywait pthread_mutex_getprioceiling
@PTH_ALLOW@sem_post 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_max
sched_get_priority_min sched_get_priority_min
sched_getparam sched_getparam

64
winsup/cygwin/include/cygwin/types.h
View File

@@ -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

176
winsup/cygwin/include/pthread.h
View File

@@ -12,6 +12,7 @@
#include <sys/types.h> #include <sys/types.h>
#include <signal.h> #include <signal.h>
#include <sched.h>
#ifndef _PTHREAD_H #ifndef _PTHREAD_H
#define _PTHREAD_H #define _PTHREAD_H
@@ -29,84 +30,145 @@ extern "C"
would normally be written to the passed parameter of pthread_cond_init(lvalue, NULL); */ would normally be written to the passed parameter of pthread_cond_init(lvalue, NULL); */
// #define PTHREAD_COND_INITIALIZER 0 // #define PTHREAD_COND_INITIALIZER 0
#define PTHREAD_PROCESS_PRIVATE 0
#define PTHREAD_PROCESS_SHARED 1
#define PTHREAD_DESTRUCTOR_ITERATIONS 1 #define PTHREAD_DESTRUCTOR_ITERATIONS 1
/* Tls has 64 items for pre win2000 - and we don't want to use them all :] /* Tls has 64 items for pre win2000 - and we don't want to use them all :]
* Before committing discuss this with the list * Before committing discuss this with the list
*/ */
#define PTHREAD_KEYS_MAX 32 #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 #define PTHREAD_CREATE_DETACHED 1
/* the default : joinable */ /* the default : joinable */
#define PTHREAD_CREATE_JOINABLE 0 #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. /* Attributes */
* defining in sys/types mught also allow us to override them for the internal functions int pthread_attr_destroy (pthread_attr_t *);
* more easily (internal sys/types vs external sys/type - dev thoughts on this? 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; int pthread_attr_getstackaddr (const pthread_attr_t *, void **);
typedef void *pthread_mutex_t; int pthread_attr_setstackaddr (pthread_attr_t *, void *);
#endif
typedef void *pthread_key_t; #ifdef _POSIX_THREAD_ATTR_STACKSIZE
typedef void *pthread_attr_t; int pthread_attr_getstacksize (const pthread_attr_t *, size_t *);
typedef void *pthread_mutexattr_t; int pthread_attr_setstacksize (pthread_attr_t *, size_t);
typedef void *pthread_condattr_t; #endif
typedef void *pthread_cond_t;
/* ThreadCreation */ int pthread_cancel (pthread_t);
int pthread_create (pthread_t * thread, const pthread_attr_t * attr, /* Macros for cleanup_push and pop;
void *(*)(void *), void *arg); * The function definitions are
int pthread_attr_init (pthread_attr_t * attr); void pthread_cleanup_push(void (*routine)(void*), void *arg);
int pthread_attr_destroy (pthread_attr_t * attr); void pthread_cleanup_pop(int execute);
int pthread_attr_setdetachstate (pthread_attr_t *, int); */
int pthread_attr_getdetachstate (const pthread_attr_t *, int *); typedef void __cleanup_routine_type (void *);
int pthread_attr_setstacksize (pthread_attr_t * attr, size_t size);
int pthread_attr_getstacksize (pthread_attr_t * attr, size_t * size); #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 */ /* Condition variables */
int pthread_cond_broadcast (pthread_cond_t *); int pthread_cond_broadcast (pthread_cond_t *);
int pthread_cond_destroy (pthread_cond_t *); int pthread_cond_destroy (pthread_cond_t *);
int pthread_cond_init (pthread_cond_t *, const pthread_condattr_t *); int pthread_cond_init (pthread_cond_t *, const pthread_condattr_t *);
int pthread_cond_signal (pthread_cond_t *); int pthread_cond_signal (pthread_cond_t *);
int pthread_cond_timedwait (pthread_cond_t *, int pthread_cond_timedwait (pthread_cond_t *,
pthread_mutex_t *, const struct timespec *); pthread_mutex_t *, const struct timespec *);
int pthread_cond_wait (pthread_cond_t *, pthread_mutex_t *); int pthread_cond_wait (pthread_cond_t *, pthread_mutex_t *);
int pthread_condattr_destroy (pthread_condattr_t *); int pthread_condattr_destroy (pthread_condattr_t *);
int pthread_condattr_getpshared (const pthread_condattr_t *, int *); int pthread_condattr_getpshared (const pthread_condattr_t *, int *);
int pthread_condattr_init (pthread_condattr_t *); int pthread_condattr_init (pthread_condattr_t *);
int pthread_condattr_setpshared (pthread_condattr_t *, int); 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 */ pthread_t pthread_self (void);
int pthread_detach (pthread_t thread); int pthread_setcancelstate (int, int *);
int pthread_join (pthread_t thread, void **value_ptr); 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 */ /* Non posix calls */
void pthread_exit (void *value_ptr);
/* Thread SpecificData */ int pthread_suspend (pthread_t);
int pthread_key_create (pthread_key_t *, void (*)(void *)); int pthread_continue (pthread_t);
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);
/* 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 #ifdef __cplusplus
} }

27
winsup/cygwin/include/sched.h
View File

@@ -31,21 +31,32 @@ extern "C" {
#endif #endif
/* max priority for policy */ /* max priority for policy */
int sched_get_priority_max (int); int sched_get_priority_max (int);
/* min priority for policy */ /* min priority for policy */
int sched_get_priority_min (int); int sched_get_priority_min (int);
/* get sched params for process */ /* 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 */ /* get the scheduler for pid */
int sched_getscheduler (pid_t); int sched_getscheduler (pid_t);
/* get the time quantum for pid */ /* 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 */ /* 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 */ /* 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 */ /* 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 #ifdef __cplusplus
} }

329
winsup/cygwin/pthread.cc
View File

@@ -17,111 +17,193 @@ extern "C"
{ {
/* ThreadCreation */ /* ThreadCreation */
int int
pthread_create (pthread_t * thread, const pthread_attr_t * attr, pthread_create (pthread_t * thread, const pthread_attr_t * attr,
void *(*start_routine) (void *), void *arg) void *(*start_routine) (void *), void *arg)
{ {
return __pthread_create (thread, attr, start_routine, 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); 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); 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); return __pthread_attr_setdetachstate (attr, detachstate);
} }
int int
pthread_attr_getdetachstate (const pthread_attr_t * attr, pthread_attr_getdetachstate (const pthread_attr_t * attr, int *detachstate)
int *detachstate)
{ {
return __pthread_attr_getdetachstate (attr, 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); 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); return __pthread_attr_getstacksize (attr, size);
} }
int
pthread_attr_setinheritsched (pthread_attr_t * attr, int inheritsched)
{
return __pthread_attr_setinheritsched (attr, inheritsched);
}
/* int
pthread_attr_setstackaddr(...){}; pthread_attr_getinheritsched (const pthread_attr_t * attr, int *inheritsched)
pthread_attr_getstackaddr(...){}; {
*/ 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 */ /* Thread Exit */
void pthread_exit (void *value_ptr) void
pthread_exit (void *value_ptr)
{ {
return __pthread_exit (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); return __pthread_join (&thread, (void **) return_val);
} }
int pthread_detach (pthread_t thread) int
pthread_detach (pthread_t thread)
{ {
return __pthread_detach (&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); return __pthread_suspend (&thread);
} }
int pthread_continue (pthread_t thread) /* same */
int
pthread_continue (pthread_t thread)
{ {
return __pthread_continue (&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); return __pthread_getsequence_np (thread);
} }
/* Thread SpecificData */ /* 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); 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); 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); return __pthread_setspecific (key, value);
} }
void *pthread_getspecific (pthread_key_t key) void *
pthread_getspecific (pthread_key_t key)
{ {
return (void *) __pthread_getspecific (key); return (void *) __pthread_getspecific (key);
} }
/* Thread signal */ /* Thread signal */
int pthread_kill (pthread_t * thread, int sig) int
pthread_kill (pthread_t thread, int sig)
{ {
return __pthread_kill (thread, sig); return __pthread_kill (thread, sig);
} }
int 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); return __pthread_sigmask (operation, set, old_set);
} }
@@ -133,120 +215,273 @@ pthread_t pthread_self ()
return __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); return __pthread_equal (&t1, &t2);
} }
/* Mutexes */ /* Mutexes */
int int
pthread_mutex_init (pthread_mutex_t * mutex, pthread_mutex_init (pthread_mutex_t * mutex, const pthread_mutexattr_t * attr)
const pthread_mutexattr_t * attr)
{ {
return __pthread_mutex_init (mutex, 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); 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); 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); 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); 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 */ /* Synchronisation */
int pthread_cond_destroy (pthread_cond_t * cond) int
pthread_cond_destroy (pthread_cond_t * cond)
{ {
return __pthread_cond_destroy (cond); return __pthread_cond_destroy (cond);
} }
int 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); 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); 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); return __pthread_cond_broadcast (cond);
} }
int int
pthread_cond_timedwait (pthread_cond_t * cond, pthread_cond_timedwait (pthread_cond_t * cond,
pthread_mutex_t * mutex, pthread_mutex_t * mutex,
const struct timespec *abstime) const struct timespec *abstime)
{ {
return __pthread_cond_timedwait (cond, mutex, 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); 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); 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); return __pthread_condattr_destroy (condattr);
} }
int int
pthread_condattr_getpshared (const pthread_condattr_t * attr, pthread_condattr_getpshared (const pthread_condattr_t * attr, int *pshared)
int *pshared)
{ {
return __pthread_condattr_getpshared (attr, 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); 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 */ /* 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); return __sem_init (sem, pshared, value);
} }
int sem_destroy (sem_t * sem) int
sem_destroy (sem_t * sem)
{ {
return __sem_destroy (sem); return __sem_destroy (sem);
} }
int sem_wait (sem_t * sem) int
sem_wait (sem_t * sem)
{ {
return __sem_wait (sem); return __sem_wait (sem);
} }
int sem_trywait (sem_t * sem) int
sem_trywait (sem_t * sem)
{ {
return __sem_trywait (sem); return __sem_trywait (sem);
} }
int sem_post (sem_t * sem) int
sem_post (sem_t * sem)
{ {
return __sem_post (sem); return __sem_post (sem);
} }
} }

44
winsup/cygwin/sched.cc
View File

@@ -81,6 +81,18 @@ sched_get_priority_min (int policy)
return 15; 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 /* get sched params for process
Note, I'm never returning EPERM, Note, I'm never returning EPERM,
@@ -273,7 +285,7 @@ sched_setparam (pid_t pid, const struct sched_param *param)
return -1; return -1;
} }
if (param->sched_priority < -14 || param->sched_priority > 15) if (!valid_sched_parameters(param))
{ {
set_errno (EINVAL); set_errno (EINVAL);
return -1; return -1;
@@ -384,6 +396,36 @@ sched_setparam (pid_t pid, const struct sched_param *param)
return 0; 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 */ /* set the scheduler */
int int
sched_setscheduler (pid_t pid, int policy, sched_setscheduler (pid_t pid, int policy,

938
winsup/cygwin/thread.cc
View File

File diff suppressed because it is too large Load Diff

249
winsup/cygwin/thread.h
View File

@@ -26,7 +26,7 @@ details. */
extern "C" extern "C"
{ {
#if defined (_CYG_THREAD_FAILSAFE) && defined (_MT_SAFE) #if defined (_CYG_THREAD_FAILSAFE) && defined (_MT_SAFE)
void AssertResourceOwner (int, int); void AssertResourceOwner (int, int);
#else #else
#define AssertResourceOwner(i,ii) #define AssertResourceOwner(i,ii)
#endif #endif
@@ -39,21 +39,7 @@ void AssertResourceOwner (int, int);
#else #else
//#include <pthread.h> #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 <signal.h> #include <signal.h>
#include <pwd.h> #include <pwd.h>
#include <grp.h> #include <grp.h>
@@ -136,7 +122,9 @@ class pinfo;
class ResourceLocks class ResourceLocks
{ {
public: public:
ResourceLocks () {} ResourceLocks ()
{
}
LPCRITICAL_SECTION Lock (int); LPCRITICAL_SECTION Lock (int);
void Init (); void Init ();
void Delete (); void Delete ();
@@ -157,6 +145,9 @@ private:
#define PTHREAD_COND_MAGIC PTHREAD_MAGIC+5 #define PTHREAD_COND_MAGIC PTHREAD_MAGIC+5
#define PTHREAD_CONDATTR_MAGIC PTHREAD_MAGIC+6 #define PTHREAD_CONDATTR_MAGIC PTHREAD_MAGIC+6
#define SEM_MAGIC PTHREAD_MAGIC+7 #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 class verifyable_object
{ {
@@ -169,10 +160,55 @@ public:
int verifyable_object_isvalid (verifyable_object *, long); 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 class pthread_attr:public verifyable_object
{ {
public: public:
int joinable; int joinable;
int contentionscope;
int inheritsched;
struct sched_param schedparam;
size_t stacksize; size_t stacksize;
pthread_attr (); pthread_attr ();
@@ -188,7 +224,9 @@ public:
void *arg; void *arg;
void *return_ptr; void *return_ptr;
bool suspended; bool suspended;
int joinable; int cancelstate, canceltype;
// int joinable;
DWORD GetThreadId () DWORD GetThreadId ()
{ {
return thread_id; return thread_id;
@@ -214,6 +252,8 @@ private:
class pthread_mutexattr:public verifyable_object class pthread_mutexattr:public verifyable_object
{ {
public: public:
int pshared;
int mutextype;
pthread_mutexattr (); pthread_mutexattr ();
~pthread_mutexattr (); ~pthread_mutexattr ();
}; };
@@ -232,18 +272,6 @@ public:
~pthread_mutex (); ~pthread_mutex ();
}; };
class pthread_key:public verifyable_object
{
public:
DWORD dwTlsIndex;
int set (const void *);
void *get ();
pthread_key ();
~pthread_key ();
};
class pthread_condattr:public verifyable_object class pthread_condattr:public verifyable_object
{ {
public: public:
@@ -268,6 +296,13 @@ public:
~pthread_cond (); ~pthread_cond ();
}; };
class pthread_once
{
public:
pthread_mutex_t mutex;
int state;
};
/* shouldn't be here */ /* shouldn't be here */
class semaphore:public verifyable_object class semaphore:public verifyable_object
{ {
@@ -282,17 +317,6 @@ public:
~semaphore (); ~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 class MTinterface
{ {
public: public:
@@ -301,94 +325,143 @@ public:
DWORD thread_self_dwTlsIndex; DWORD thread_self_dwTlsIndex;
/* we may get 0 for the Tls index.. grrr */ /* we may get 0 for the Tls index.. grrr */
int indexallocated; int indexallocated;
int concurrency;
// Used for main thread data, and sigproc thread // Used for main thread data, and sigproc thread
struct __reent_t reents; struct __reent_t reents;
struct _winsup_t winsup_reent; struct _winsup_t winsup_reent;
pthread mainthread; pthread mainthread;
pthread_key_destructor_list destructors;
void Init (int); void Init (int);
MTinterface ():reent_index (0), indexallocated (0) MTinterface ():reent_index (0), indexallocated (0)
{} {
}
}; };
extern "C" extern "C"
{ {
void *thread_init_wrapper (void *); void *thread_init_wrapper (void *);
/* ThreadCreation */ /* ThreadCreation */
int __pthread_create (pthread_t * thread, const pthread_attr_t * attr, int __pthread_create (pthread_t * thread, const pthread_attr_t * attr,
void *(*start_routine) (void *), void *arg); void *(*start_routine) (void *), void *arg);
int __pthread_attr_init (pthread_attr_t * attr); int __pthread_once (pthread_once_t *, void (*)(void));
int __pthread_attr_destroy (pthread_attr_t * attr);
int __pthread_attr_setdetachstate (pthread_attr_t *, int); int __pthread_attr_init (pthread_attr_t * attr);
int __pthread_attr_getdetachstate (const pthread_attr_t *, int *); int __pthread_attr_destroy (pthread_attr_t * attr);
int __pthread_attr_setstacksize (pthread_attr_t * attr, size_t size); int __pthread_attr_setdetachstate (pthread_attr_t *, int);
int __pthread_attr_getstacksize (pthread_attr_t * attr, size_t * size); int __pthread_attr_getdetachstate (const pthread_attr_t *, int *);
/* int __pthread_attr_setstacksize (pthread_attr_t * attr, size_t size);
__pthread_attr_setstackaddr(...); int __pthread_attr_getstacksize (const pthread_attr_t * attr, size_t * size);
__pthread_attr_getstackaddr(...);
*/ 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 */ /* Thread Exit */
void __pthread_exit (void *value_ptr); void __pthread_exit (void *value_ptr);
int __pthread_join (pthread_t * thread, void **return_val); int __pthread_join (pthread_t * thread, void **return_val);
int __pthread_detach (pthread_t * thread); int __pthread_detach (pthread_t * thread);
/* Thread suspend */ /* Thread suspend */
int __pthread_suspend (pthread_t * thread); int __pthread_suspend (pthread_t * thread);
int __pthread_continue (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 */ /* Thread SpecificData */
int __pthread_key_create (pthread_key_t * key, void (*destructor) (void *)); int __pthread_key_create (pthread_key_t * key, void (*destructor) (void *));
int __pthread_key_delete (pthread_key_t * key); int __pthread_key_delete (pthread_key_t key);
int __pthread_setspecific (pthread_key_t key, const void *value); int __pthread_setspecific (pthread_key_t key, const void *value);
void *__pthread_getspecific (pthread_key_t key); void *__pthread_getspecific (pthread_key_t key);
/* Thead synchroniation */ /* Thead synchroniation */
int __pthread_cond_destroy (pthread_cond_t * cond); int __pthread_cond_destroy (pthread_cond_t * cond);
int __pthread_cond_init (pthread_cond_t * cond, int __pthread_cond_init (pthread_cond_t * cond,
const pthread_condattr_t * attr); const pthread_condattr_t * attr);
int __pthread_cond_signal (pthread_cond_t * cond); int __pthread_cond_signal (pthread_cond_t * cond);
int __pthread_cond_broadcast (pthread_cond_t * cond); int __pthread_cond_broadcast (pthread_cond_t * cond);
int __pthread_cond_timedwait (pthread_cond_t * cond, int __pthread_cond_timedwait (pthread_cond_t * cond,
pthread_mutex_t * mutex, pthread_mutex_t * mutex,
const struct timespec *abstime); const struct timespec *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);
int __pthread_condattr_init (pthread_condattr_t * condattr); int __pthread_condattr_init (pthread_condattr_t * condattr);
int __pthread_condattr_destroy (pthread_condattr_t * condattr); int __pthread_condattr_destroy (pthread_condattr_t * condattr);
int __pthread_condattr_getpshared (const pthread_condattr_t * attr, int __pthread_condattr_getpshared (const pthread_condattr_t * attr,
int *pshared); int *pshared);
int __pthread_condattr_setpshared (pthread_condattr_t * attr, int pshared); int __pthread_condattr_setpshared (pthread_condattr_t * attr, int pshared);
/* Thread signal */ /* Thread signal */
int __pthread_kill (pthread_t * thread, int sig); int __pthread_kill (pthread_t thread, int sig);
int __pthread_sigmask (int operation, const sigset_t * set, int __pthread_sigmask (int operation, const sigset_t * set,
sigset_t * old_set); sigset_t * old_set);
/* ID */ /* ID */
pthread_t __pthread_self (); pthread_t __pthread_self ();
int __pthread_equal (pthread_t * t1, pthread_t * t2); int __pthread_equal (pthread_t * t1, pthread_t * t2);
/* Mutexes */ /* Mutexes */
int __pthread_mutex_init (pthread_mutex_t *, const pthread_mutexattr_t *); int __pthread_mutex_init (pthread_mutex_t *, const pthread_mutexattr_t *);
int __pthread_mutex_lock (pthread_mutex_t *); int __pthread_mutex_lock (pthread_mutex_t *);
int __pthread_mutex_trylock (pthread_mutex_t *); int __pthread_mutex_trylock (pthread_mutex_t *);
int __pthread_mutex_unlock (pthread_mutex_t *); int __pthread_mutex_unlock (pthread_mutex_t *);
int __pthread_mutex_destroy (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 */ /* Semaphores */
int __sem_init (sem_t * sem, int pshared, unsigned int value); int __sem_init (sem_t * sem, int pshared, unsigned int value);
int __sem_destroy (sem_t * sem); int __sem_destroy (sem_t * sem);
int __sem_wait (sem_t * sem); int __sem_wait (sem_t * sem);
int __sem_trywait (sem_t * sem); int __sem_trywait (sem_t * sem);
int __sem_post (sem_t * sem); int __sem_post (sem_t * sem);
}; };
#endif // MT_SAFE #endif // MT_SAFE