[apple/libc.git] / pthreads / pthread.h

/*
 * Copyright (c) 2000-2003 Apple Computer, Inc. All rights reserved.
 *
 * @APPLE_LICENSE_HEADER_START@
 *
 * This file contains Original Code and/or Modifications of Original Code
 * as defined in and that are subject to the Apple Public Source License
 * Version 2.0 (the 'License'). You may not use this file except in
 * compliance with the License. Please obtain a copy of the License at
 * http://www.opensource.apple.com/apsl/ and read it before using this
 * file.
 *
 * The Original Code and all software distributed under the License are
 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
 * Please see the License for the specific language governing rights and
 * limitations under the License.
 *
 * @APPLE_LICENSE_HEADER_END@
 */
/*
 * Copyright 1996 1995 by Open Software Foundation, Inc. 1997 1996 1995 1994 1993 1992 1991
 *              All Rights Reserved
 *
 * Permission to use, copy, modify, and distribute this software and
 * its documentation for any purpose and without fee is hereby granted,
 * provided that the above copyright notice appears in all copies and
 * that both the copyright notice and this permission notice appear in
 * supporting documentation.
 *
 * OSF DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE
 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 * FOR A PARTICULAR PURPOSE.
 *
 * IN NO EVENT SHALL OSF BE LIABLE FOR ANY SPECIAL, INDIRECT, OR
 * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
 * LOSS OF USE, DATA OR PROFITS, WHETHER IN ACTION OF CONTRACT,
 * NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
 * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 *
 */
/*
 * MkLinux
 */

/*
 * POSIX Threads - IEEE 1003.1c
 */

#ifndef _PTHREAD_H
#define _PTHREAD_H

#include <_types.h>
#ifndef __POSIX_LIB__
#include <pthread_impl.h>
#endif
#include <sched.h>
#include <time.h>

#ifndef _PTHREAD_ATTR_T
#define _PTHREAD_ATTR_T
typedef __darwin_pthread_attr_t		pthread_attr_t;
#endif

#ifndef _PTHREAD_COND_T
#define _PTHREAD_COND_T
typedef __darwin_pthread_cond_t		pthread_cond_t;
#endif

#ifndef _PTHREAD_CONDATTR_T
#define _PTHREAD_CONDATTR_T
typedef __darwin_pthread_condattr_t	pthread_condattr_t;
#endif

#ifndef _PTHREAD_KEY_T
#define _PTHREAD_KEY_T
typedef __darwin_pthread_key_t		pthread_key_t;
#endif

#ifndef _PTHREAD_MUTEX_T
#define _PTHREAD_MUTEX_T
typedef __darwin_pthread_mutex_t	pthread_mutex_t;
#endif

#ifndef _PTHREAD_MUTEXATTR_T
#define _PTHREAD_MUTEXATTR_T
typedef __darwin_pthread_mutexattr_t	pthread_mutexattr_t;
#endif

#ifndef _PTHREAD_ONCE_T
#define _PTHREAD_ONCE_T
typedef __darwin_pthread_once_t		pthread_once_t;
#endif

#ifndef _PTHREAD_RWLOCK_T
#define _PTHREAD_RWLOCK_T
typedef __darwin_pthread_rwlock_t	pthread_rwlock_t;
#endif

#ifndef _PTHREAD_RWLOCKATTR_T
#define _PTHREAD_RWLOCKATTR_T
typedef __darwin_pthread_rwlockattr_t	pthread_rwlockattr_t;
#endif

#ifndef _PTHREAD_T
#define _PTHREAD_T
typedef __darwin_pthread_t		pthread_t;
#endif

#if (!defined(_POSIX_C_SOURCE) && !defined(_XOPEN_SOURCE)) || defined(_DARWIN_C_SOURCE)

#ifndef _MACH_PORT_T
#define _MACH_PORT_T
typedef __darwin_mach_port_t		mach_port_t;
#endif

#ifndef _SIGSET_T
#define _SIGSET_T
typedef __darwin_sigset_t		sigset_t;
#endif

#endif /* (!_POSIX_C_SOURCE && !_XOPEN_SOURCE) || _DARWIN_C_SOURCE */

/*
 * These symbols indicate which [optional] features are available
 * They can be tested at compile time via '#ifdef XXX'
 * The way to check for pthreads is like so:

 * #include <unistd.h>
 * #ifdef _POSIX_THREADS
 * #include <pthread.h>
 * #endif

 */

/* These will be moved to unistd.h */

/*
 * Note: These data structures are meant to be opaque.  Only enough
 * structure is exposed to support initializers.
 * All of the typedefs will be moved to <sys/types.h>
 */

#include <sys/cdefs.h>

__BEGIN_DECLS
/*
 * Threads
 */


/*
 * Cancel cleanup handler management.  Note, since these are implemented as macros,
 * they *MUST* occur in matched pairs!
 */

#define pthread_cleanup_push(func, val) \
   { \
	     struct __darwin_pthread_handler_rec __handler; \
	     pthread_t __self = pthread_self(); \
	     __handler.__routine = func; \
	     __handler.__arg = val; \
	     __handler.__next = __self->__cleanup_stack; \
	     __self->__cleanup_stack = &__handler;

#define pthread_cleanup_pop(execute) \
	     /* Note: 'handler' must be in this same lexical context! */ \
	     __self->__cleanup_stack = __handler.__next; \
	     if (execute) (__handler.__routine)(__handler.__arg); \
   }

/*
 * Thread attributes
 */

#define PTHREAD_CREATE_JOINABLE      1
#define PTHREAD_CREATE_DETACHED      2

#define PTHREAD_INHERIT_SCHED        1
#define PTHREAD_EXPLICIT_SCHED       2

#define PTHREAD_CANCEL_ENABLE        0x01  /* Cancel takes place at next cancellation point */
#define PTHREAD_CANCEL_DISABLE       0x00  /* Cancel postponed */
#define PTHREAD_CANCEL_DEFERRED      0x02  /* Cancel waits until cancellation point */
#define PTHREAD_CANCEL_ASYNCHRONOUS  0x00  /* Cancel occurs immediately */

/* Value returned from pthread_join() when a thread is canceled */
#define PTHREAD_CANCELED	     ((void *) 1)

/* We only support PTHREAD_SCOPE_SYSTEM */
#define PTHREAD_SCOPE_SYSTEM         1
#define PTHREAD_SCOPE_PROCESS        2

/* We only support PTHREAD_PROCESS_PRIVATE */
#define PTHREAD_PROCESS_SHARED         1
#define PTHREAD_PROCESS_PRIVATE        2

/*
 * Mutex protocol attributes
 */
#define PTHREAD_PRIO_NONE            0
#define PTHREAD_PRIO_INHERIT         1
#define PTHREAD_PRIO_PROTECT         2

/*
 * Mutex type attributes
 */
#define PTHREAD_MUTEX_NORMAL		0
#define PTHREAD_MUTEX_ERRORCHECK	1
#define PTHREAD_MUTEX_RECURSIVE		2
#define PTHREAD_MUTEX_DEFAULT		PTHREAD_MUTEX_NORMAL
/*
 * RWLock variables
 */

#define PTHREAD_RWLOCK_INITIALIZER {_PTHREAD_RWLOCK_SIG_init, {0}}
/*
 * Mutex variables
 */

#define PTHREAD_MUTEX_INITIALIZER {_PTHREAD_MUTEX_SIG_init, {0}}

/*
 * Condition variable attributes
 */

/*
 * Condition variables
 */

#define PTHREAD_COND_INITIALIZER {_PTHREAD_COND_SIG_init, {0}}

/*
 * Initialization control (once) variables
 */

#define PTHREAD_ONCE_INIT {_PTHREAD_ONCE_SIG_init, {0}}

/*
 * Prototypes for all PTHREAD interfaces
 */
int       pthread_atfork(void (*)(void), void (*)(void),
                      void (*)(void));
int       pthread_attr_destroy(pthread_attr_t *);
int       pthread_attr_getdetachstate(const pthread_attr_t *,
				      int *);
int       pthread_attr_getguardsize(const pthread_attr_t * __restrict,
                                      size_t * __restrict);
int       pthread_attr_getinheritsched(const pthread_attr_t * __restrict,
				       int * __restrict);
int       pthread_attr_getschedparam(const pthread_attr_t * __restrict,
                                     struct sched_param * __restrict);
int       pthread_attr_getschedpolicy(const pthread_attr_t * __restrict,
				      int * __restrict);
int       pthread_attr_getscope(const pthread_attr_t * __restrict, int * __restrict);
int       pthread_attr_getstack(const pthread_attr_t * __restrict,
                                      void ** __restrict, size_t * __restrict);
int       pthread_attr_getstackaddr(const pthread_attr_t * __restrict,
                                      void ** __restrict);
int       pthread_attr_getstacksize(const pthread_attr_t * __restrict,
                                      size_t * __restrict);
int       pthread_attr_init(pthread_attr_t *);
int       pthread_attr_setdetachstate(pthread_attr_t *,
				      int );
int       pthread_attr_setguardsize(pthread_attr_t *, size_t );
int       pthread_attr_setinheritsched(pthread_attr_t *,
				       int );
int       pthread_attr_setschedparam(pthread_attr_t * __restrict,
                                     const struct sched_param * __restrict);
int       pthread_attr_setschedpolicy(pthread_attr_t *,
				      int );
int       pthread_attr_setscope(pthread_attr_t *, int);
int       pthread_attr_setstack(pthread_attr_t *,
                                      void *, size_t );
int       pthread_attr_setstackaddr(pthread_attr_t *,
                                      void *);
int       pthread_attr_setstacksize(pthread_attr_t *, size_t );
int       pthread_cancel(pthread_t ) __DARWIN_ALIAS(pthread_cancel);

int       pthread_cond_broadcast(pthread_cond_t *);
int       pthread_cond_destroy(pthread_cond_t *);
//Begin-Libc
#ifndef LIBC_ALIAS_PTHREAD_COND_INIT
//End-Libc
int       pthread_cond_init(pthread_cond_t * __restrict,
                            const pthread_condattr_t * __restrict) __DARWIN_ALIAS(pthread_cond_init);
//Begin-Libc
#else /* LIBC_ALIAS_PTHREAD_COND_INIT */
int       pthread_cond_init(pthread_cond_t * __restrict,
                            const pthread_condattr_t * __restrict) LIBC_ALIAS(pthread_cond_init);
#endif /* !LIBC_ALIAS_PTHREAD_COND_INIT */
//End-Libc
int       pthread_cond_signal(pthread_cond_t *);
//Begin-Libc
#ifndef LIBC_ALIAS_PTHREAD_COND_TIMEDWAIT
//End-Libc
int       pthread_cond_timedwait(pthread_cond_t * __restrict,
				 pthread_mutex_t * __restrict,
				 const struct timespec * __restrict) __DARWIN_ALIAS_C(pthread_cond_timedwait);
//Begin-Libc
#else /* LIBC_ALIAS_PTHREAD_COND_TIMEDWAIT */
int       pthread_cond_timedwait(pthread_cond_t * __restrict,
				 pthread_mutex_t * __restrict,
				 const struct timespec * __restrict) LIBC_ALIAS_C(pthread_cond_timedwait);
#endif /* !LIBC_ALIAS_PTHREAD_COND_TIMEDWAIT */
//End-Libc
//Begin-Libc
#ifndef LIBC_ALIAS_PTHREAD_COND_WAIT
//End-Libc
int       pthread_cond_wait(pthread_cond_t * __restrict,
			    pthread_mutex_t * __restrict) __DARWIN_ALIAS_C(pthread_cond_wait);
//Begin-Libc
#else /* LIBC_ALIAS_PTHREAD_COND_WAIT */
int       pthread_cond_wait(pthread_cond_t * __restrict,
			    pthread_mutex_t * __restrict) LIBC_ALIAS_C(pthread_cond_wait);
#endif /* !LIBC_ALIAS_PTHREAD_COND_WAIT */
//End-Libc
int       pthread_condattr_destroy(pthread_condattr_t *);
int       pthread_condattr_init(pthread_condattr_t *);
int       pthread_condattr_getpshared(const pthread_condattr_t * __restrict,
			int * __restrict);
int       pthread_condattr_setpshared(pthread_condattr_t *,
			int );
int       pthread_create(pthread_t * __restrict,
                         const pthread_attr_t * __restrict,
                         void *(*)(void *),
                         void * __restrict);
int       pthread_detach(pthread_t );
int       pthread_equal(pthread_t ,
			pthread_t );
void      pthread_exit(void *) __dead2;
int       pthread_getconcurrency(void);
int       pthread_getschedparam(pthread_t , int * __restrict, struct sched_param * __restrict);
void     *pthread_getspecific(pthread_key_t );
//Begin-Libc
#ifndef LIBC_ALIAS_PTHREAD_JOIN
//End-Libc
int       pthread_join(pthread_t , void **) __DARWIN_ALIAS_C(pthread_join);
//Begin-Libc
#else /* LIBC_ALIAS_PTHREAD_JOIN */
int       pthread_join(pthread_t , void **) LIBC_ALIAS_C(pthread_join);
#endif /* !LIBC_ALIAS_PTHREAD_JOIN */
//End-Libc
int       pthread_key_create(pthread_key_t *, void (*)(void *));
int       pthread_key_delete(pthread_key_t );
int       pthread_mutex_destroy(pthread_mutex_t *);
int       pthread_mutex_getprioceiling(const pthread_mutex_t * __restrict, int * __restrict);
int       pthread_mutex_init(pthread_mutex_t * __restrict, const pthread_mutexattr_t * __restrict);
int       pthread_mutex_lock(pthread_mutex_t *);
int       pthread_mutex_setprioceiling(pthread_mutex_t * __restrict, int, int * __restrict);
int       pthread_mutex_trylock(pthread_mutex_t *);
int       pthread_mutex_unlock(pthread_mutex_t *);
//Begin-Libc
#ifndef LIBC_ALIAS_PTHREAD_MUTEXATTR_DESTROY
//End-Libc
int       pthread_mutexattr_destroy(pthread_mutexattr_t *) __DARWIN_ALIAS(pthread_mutexattr_destroy);
//Begin-Libc
#else /* LIBC_ALIAS_PTHREAD_MUTEXATTR_DESTROY */
int       pthread_mutexattr_destroy(pthread_mutexattr_t *) LIBC_ALIAS(pthread_mutexattr_destroy);
#endif /* !LIBC_ALIAS_PTHREAD_MUTEXATTR_DESTROY */
//End-Libc
int       pthread_mutexattr_getprioceiling(const pthread_mutexattr_t * __restrict, int * __restrict);
int       pthread_mutexattr_getprotocol(const pthread_mutexattr_t * __restrict, int * __restrict);
int       pthread_mutexattr_getpshared(const pthread_mutexattr_t * __restrict, int * __restrict);
int       pthread_mutexattr_gettype(const pthread_mutexattr_t * __restrict, int * __restrict);
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));
//Begin-Libc
#ifndef LIBC_ALIAS_PTHREAD_RWLOCK_DESTROY
//End-Libc
int       pthread_rwlock_destroy(pthread_rwlock_t * ) __DARWIN_ALIAS(pthread_rwlock_destroy);
//Begin-Libc
#else /* LIBC_ALIAS_PTHREAD_RWLOCK_DESTROY */
int       pthread_rwlock_destroy(pthread_rwlock_t * ) LIBC_ALIAS(pthread_rwlock_destroy);
#endif /* !LIBC_ALIAS_PTHREAD_RWLOCK_DESTROY */
//End-Libc
//Begin-Libc
#ifndef LIBC_ALIAS_PTHREAD_RWLOCK_INIT
//End-Libc
int       pthread_rwlock_init(pthread_rwlock_t * __restrict, const pthread_rwlockattr_t * __restrict) __DARWIN_ALIAS(pthread_rwlock_init);
//Begin-Libc
#else /* LIBC_ALIAS_PTHREAD_RWLOCK_INIT */
int       pthread_rwlock_init(pthread_rwlock_t * __restrict, const pthread_rwlockattr_t * __restrict) LIBC_ALIAS(pthread_rwlock_init);
#endif /* !LIBC_ALIAS_PTHREAD_RWLOCK_INIT */
//End-Libc
//Begin-Libc
#ifndef LIBC_ALIAS_PTHREAD_RWLOCK_RDLOCK
//End-Libc
int       pthread_rwlock_rdlock(pthread_rwlock_t *) __DARWIN_ALIAS(pthread_rwlock_rdlock);
//Begin-Libc
#else /* LIBC_ALIAS_PTHREAD_RWLOCK_RDLOCK */
int       pthread_rwlock_rdlock(pthread_rwlock_t *) LIBC_ALIAS(pthread_rwlock_rdlock);
#endif /* !LIBC_ALIAS_PTHREAD_RWLOCK_RDLOCK */
//End-Libc
//Begin-Libc
#ifndef LIBC_ALIAS_PTHREAD_RWLOCK_TRYRDLOCK
//End-Libc
int       pthread_rwlock_tryrdlock(pthread_rwlock_t *) __DARWIN_ALIAS(pthread_rwlock_tryrdlock);
//Begin-Libc
#else /* LIBC_ALIAS_PTHREAD_RWLOCK_TRYRDLOCK */
int       pthread_rwlock_tryrdlock(pthread_rwlock_t *) LIBC_ALIAS(pthread_rwlock_tryrdlock);
#endif /* !LIBC_ALIAS_PTHREAD_RWLOCK_TRYRDLOCK */
//End-Libc
//Begin-Libc
#ifndef LIBC_ALIAS_PTHREAD_RWLOCK_TRYWRLOCK
//End-Libc
int       pthread_rwlock_trywrlock(pthread_rwlock_t *) __DARWIN_ALIAS(pthread_rwlock_trywrlock);
//Begin-Libc
#else /* LIBC_ALIAS_PTHREAD_RWLOCK_TRYWRLOCK */
int       pthread_rwlock_trywrlock(pthread_rwlock_t *) LIBC_ALIAS(pthread_rwlock_trywrlock);
#endif /* !LIBC_ALIAS_PTHREAD_RWLOCK_TRYWRLOCK */
//End-Libc
//Begin-Libc
#ifndef LIBC_ALIAS_PTHREAD_RWLOCK_WRLOCK
//End-Libc
int       pthread_rwlock_wrlock(pthread_rwlock_t *) __DARWIN_ALIAS(pthread_rwlock_wrlock);
//Begin-Libc
#else /* LIBC_ALIAS_PTHREAD_RWLOCK_WRLOCK */
int       pthread_rwlock_wrlock(pthread_rwlock_t *) LIBC_ALIAS(pthread_rwlock_wrlock);
#endif /* !LIBC_ALIAS_PTHREAD_RWLOCK_WRLOCK */
//End-Libc
//Begin-Libc
#ifndef LIBC_ALIAS_PTHREAD_RWLOCK_UNLOCK
//End-Libc
int       pthread_rwlock_unlock(pthread_rwlock_t *) __DARWIN_ALIAS(pthread_rwlock_unlock);
//Begin-Libc
#else /* LIBC_ALIAS_PTHREAD_RWLOCK_UNLOCK */
int       pthread_rwlock_unlock(pthread_rwlock_t *) LIBC_ALIAS(pthread_rwlock_unlock);
#endif /* !LIBC_ALIAS_PTHREAD_RWLOCK_UNLOCK */
//End-Libc
int       pthread_rwlockattr_destroy(pthread_rwlockattr_t *);
int       pthread_rwlockattr_getpshared(const pthread_rwlockattr_t * __restrict,
			int * __restrict);
int       pthread_rwlockattr_init(pthread_rwlockattr_t *);
int       pthread_rwlockattr_setpshared(pthread_rwlockattr_t *,
			int );
pthread_t pthread_self(void);

//Begin-Libc
#ifndef LIBC_ALIAS_PTHREAD_SETCANCELSTATE
//End-Libc
int       pthread_setcancelstate(int , int *) __DARWIN_ALIAS(pthread_setcancelstate);
//Begin-Libc
#else /* LIBC_ALIAS_PTHREAD_SETCANCELSTATE */
int       pthread_setcancelstate(int , int *) LIBC_ALIAS(pthread_setcancelstate);
#endif /* !LIBC_ALIAS_PTHREAD_SETCANCELSTATE */
//End-Libc
//Begin-Libc
#ifndef LIBC_ALIAS_PTHREAD_SETCANCELTYPE
//End-Libc
int       pthread_setcanceltype(int , int *) __DARWIN_ALIAS(pthread_setcanceltype);
//Begin-Libc
#else /* LIBC_ALIAS_PTHREAD_SETCANCELTYPE */
int       pthread_setcanceltype(int , int *) LIBC_ALIAS(pthread_setcanceltype);
#endif /* !LIBC_ALIAS_PTHREAD_SETCANCELTYPE */
//End-Libc
int       pthread_setconcurrency(int);
int       pthread_setschedparam(pthread_t ,
				int ,
                                const struct sched_param *);
int       pthread_setspecific(pthread_key_t ,
			      const void *);
void      pthread_testcancel(void) __DARWIN_ALIAS(pthread_testcancel);

#if (!defined(_POSIX_C_SOURCE) && !defined(_XOPEN_SOURCE)) || defined(_DARWIN_C_SOURCE)
/* returns non-zero if pthread_create or cthread_fork have been called */
int		pthread_is_threaded_np(void);

/* returns non-zero if the current thread is the main thread */
int		pthread_main_np(void);

/* return the mach thread bound to the pthread */
mach_port_t 	pthread_mach_thread_np(pthread_t);
size_t	 	pthread_get_stacksize_np(pthread_t);
void *		pthread_get_stackaddr_np(pthread_t);

/* Like pthread_cond_signal(), but only wake up the specified pthread */
int		pthread_cond_signal_thread_np(pthread_cond_t *, pthread_t);

/* Like pthread_cond_timedwait, but use a relative timeout */
int		pthread_cond_timedwait_relative_np(pthread_cond_t *,
				 pthread_mutex_t *,
				 const struct timespec *);

/* Like pthread_create(), but leaves the thread suspended */
int       pthread_create_suspended_np(pthread_t *,
                         const pthread_attr_t *,
                         void *(*)(void *),
                         void *);
int       pthread_kill(pthread_t, int);

pthread_t pthread_from_mach_thread_np(mach_port_t);

//Begin-Libc
#ifndef LIBC_ALIAS_PTHREAD_SIGMASK
//End-Libc
int       pthread_sigmask(int, const sigset_t *, sigset_t *) __DARWIN_ALIAS(pthread_sigmask);
//Begin-Libc
#else /* LIBC_ALIAS_PTHREAD_SIGMASK */
int       pthread_sigmask(int, const sigset_t *, sigset_t *) LIBC_ALIAS(pthread_sigmask);
#endif /* !LIBC_ALIAS_PTHREAD_SIGMASK */
//End-Libc
void	  pthread_yield_np(void);
#endif /* (!_POSIX_C_SOURCE && !_XOPEN_SOURCE) || _DARWIN_C_SOURCE */
__END_DECLS
#endif /* _PTHREAD_H */
Commit	Line	Data
9385eb3d A	1	/*
	2	* Copyright (c) 2000-2003 Apple Computer, Inc. All rights reserved.
	3	*
	4	* @APPLE_LICENSE_HEADER_START@
224c7076	5	*
9385eb3d A	6	* This file contains Original Code and/or Modifications of Original Code
	7	* as defined in and that are subject to the Apple Public Source License
	8	* Version 2.0 (the 'License'). You may not use this file except in
	9	* compliance with the License. Please obtain a copy of the License at
	10	* http://www.opensource.apple.com/apsl/ and read it before using this
	11	* file.
224c7076	12	*
9385eb3d A	13	* The Original Code and all software distributed under the License are
	14	* distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
	15	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
	16	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
	17	* FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
	18	* Please see the License for the specific language governing rights and
	19	* limitations under the License.
224c7076	20	*
9385eb3d A	21	* @APPLE_LICENSE_HEADER_END@
9385eb3d A	22	*/
e9ce8d39	23	/*
224c7076 A	24	* Copyright 1996 1995 by Open Software Foundation, Inc. 1997 1996 1995 1994 1993 1992 1991
	25	* All Rights Reserved
	26	*
	27	* Permission to use, copy, modify, and distribute this software and
	28	* its documentation for any purpose and without fee is hereby granted,
	29	* provided that the above copyright notice appears in all copies and
	30	* that both the copyright notice and this permission notice appear in
	31	* supporting documentation.
	32	*
	33	* OSF DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE
	34	* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
	35	* FOR A PARTICULAR PURPOSE.
	36	*
	37	* IN NO EVENT SHALL OSF BE LIABLE FOR ANY SPECIAL, INDIRECT, OR
	38	* CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
	39	* LOSS OF USE, DATA OR PROFITS, WHETHER IN ACTION OF CONTRACT,
	40	* NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
	41	* WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
	42	*
e9ce8d39 A	43	*/
	44	/*
	45	* MkLinux
	46	*/
	47
	48	/*
	49	* POSIX Threads - IEEE 1003.1c
	50	*/
	51
224c7076 A	52	#ifndef _PTHREAD_H
224c7076 A	53	#define _PTHREAD_H
e9ce8d39	54
3d9156a7	55	#include <_types.h>
e9ce8d39 A	56	#ifndef __POSIX_LIB__
	57	#include <pthread_impl.h>
	58	#endif
e9ce8d39 A	59	#include <sched.h>
e9ce8d39 A	60	#include <time.h>
5b2abdfb	61
3d9156a7 A	62	#ifndef _PTHREAD_ATTR_T
	63	#define _PTHREAD_ATTR_T
	64	typedef __darwin_pthread_attr_t pthread_attr_t;
	65	#endif
	66
	67	#ifndef _PTHREAD_COND_T
	68	#define _PTHREAD_COND_T
	69	typedef __darwin_pthread_cond_t pthread_cond_t;
	70	#endif
	71
	72	#ifndef _PTHREAD_CONDATTR_T
	73	#define _PTHREAD_CONDATTR_T
	74	typedef __darwin_pthread_condattr_t pthread_condattr_t;
	75	#endif
	76
	77	#ifndef _PTHREAD_KEY_T
	78	#define _PTHREAD_KEY_T
	79	typedef __darwin_pthread_key_t pthread_key_t;
	80	#endif
	81
	82	#ifndef _PTHREAD_MUTEX_T
	83	#define _PTHREAD_MUTEX_T
	84	typedef __darwin_pthread_mutex_t pthread_mutex_t;
	85	#endif
	86
	87	#ifndef _PTHREAD_MUTEXATTR_T
	88	#define _PTHREAD_MUTEXATTR_T
	89	typedef __darwin_pthread_mutexattr_t pthread_mutexattr_t;
	90	#endif
	91
	92	#ifndef _PTHREAD_ONCE_T
	93	#define _PTHREAD_ONCE_T
	94	typedef __darwin_pthread_once_t pthread_once_t;
	95	#endif
	96
	97	#ifndef _PTHREAD_RWLOCK_T
	98	#define _PTHREAD_RWLOCK_T
	99	typedef __darwin_pthread_rwlock_t pthread_rwlock_t;
	100	#endif
	101
	102	#ifndef _PTHREAD_RWLOCKATTR_T
	103	#define _PTHREAD_RWLOCKATTR_T
	104	typedef __darwin_pthread_rwlockattr_t pthread_rwlockattr_t;
	105	#endif
	106
	107	#ifndef _PTHREAD_T
	108	#define _PTHREAD_T
	109	typedef __darwin_pthread_t pthread_t;
	110	#endif
	111
224c7076	112	#if (!defined(_POSIX_C_SOURCE) && !defined(_XOPEN_SOURCE)) \|\| defined(_DARWIN_C_SOURCE)
3d9156a7 A	113
	114	#ifndef _MACH_PORT_T
	115	#define _MACH_PORT_T
	116	typedef __darwin_mach_port_t mach_port_t;
	117	#endif
	118
	119	#ifndef _SIGSET_T
	120	#define _SIGSET_T
	121	typedef __darwin_sigset_t sigset_t;
	122	#endif
	123
224c7076	124	#endif /* (!_POSIX_C_SOURCE && !_XOPEN_SOURCE) \|\| _DARWIN_C_SOURCE */
e9ce8d39 A	125
	126	/*
	127	* These symbols indicate which [optional] features are available
	128	* They can be tested at compile time via '#ifdef XXX'
	129	* The way to check for pthreads is like so:
224c7076	130
e9ce8d39 A	131	* #include <unistd.h>
	132	* #ifdef _POSIX_THREADS
	133	* #include <pthread.h>
	134	* #endif
	135
	136	*/
	137
	138	/* These will be moved to unistd.h */
	139
e9ce8d39 A	140	/*
	141	* Note: These data structures are meant to be opaque. Only enough
	142	* structure is exposed to support initializers.
	143	* All of the typedefs will be moved to <sys/types.h>
	144	*/
	145
	146	#include <sys/cdefs.h>
	147
	148	__BEGIN_DECLS
	149	/*
	150	* Threads
	151	*/
	152
	153
	154	/*
	155	* Cancel cleanup handler management. Note, since these are implemented as macros,
	156	* they MUST occur in matched pairs!
	157	*/
	158
	159	#define pthread_cleanup_push(func, val) \
	160	{ \
3d9156a7	161	struct __darwin_pthread_handler_rec __handler; \
e9ce8d39	162	pthread_t __self = pthread_self(); \
3d9156a7 A	163	__handler.__routine = func; \
	164	__handler.__arg = val; \
	165	__handler.__next = __self->__cleanup_stack; \
	166	__self->__cleanup_stack = &__handler;
e9ce8d39 A	167
	168	#define pthread_cleanup_pop(execute) \
	169	/* Note: 'handler' must be in this same lexical context! */ \
3d9156a7 A	170	__self->__cleanup_stack = __handler.__next; \
3d9156a7 A	171	if (execute) (__handler.__routine)(__handler.__arg); \
e9ce8d39	172	}
3d9156a7	173
e9ce8d39 A	174	/*
	175	* Thread attributes
	176	*/
	177
	178	#define PTHREAD_CREATE_JOINABLE 1
	179	#define PTHREAD_CREATE_DETACHED 2
	180
	181	#define PTHREAD_INHERIT_SCHED 1
	182	#define PTHREAD_EXPLICIT_SCHED 2
	183
	184	#define PTHREAD_CANCEL_ENABLE 0x01 /* Cancel takes place at next cancellation point */
	185	#define PTHREAD_CANCEL_DISABLE 0x00 /* Cancel postponed */
	186	#define PTHREAD_CANCEL_DEFERRED 0x02 /* Cancel waits until cancellation point */
	187	#define PTHREAD_CANCEL_ASYNCHRONOUS 0x00 /* Cancel occurs immediately */
	188
3d9156a7 A	189	/* Value returned from pthread_join() when a thread is canceled */
	190	#define PTHREAD_CANCELED ((void *) 1)
	191
e9ce8d39 A	192	/* We only support PTHREAD_SCOPE_SYSTEM */
	193	#define PTHREAD_SCOPE_SYSTEM 1
	194	#define PTHREAD_SCOPE_PROCESS 2
	195
5b2abdfb A	196	/* We only support PTHREAD_PROCESS_PRIVATE */
	197	#define PTHREAD_PROCESS_SHARED 1
	198	#define PTHREAD_PROCESS_PRIVATE 2
	199
e9ce8d39	200	/*
5b2abdfb	201	* Mutex protocol attributes
e9ce8d39 A	202	*/
	203	#define PTHREAD_PRIO_NONE 0
	204	#define PTHREAD_PRIO_INHERIT 1
	205	#define PTHREAD_PRIO_PROTECT 2
	206
5b2abdfb A	207	/*
	208	* Mutex type attributes
	209	*/
	210	#define PTHREAD_MUTEX_NORMAL 0
224c7076	211	#define PTHREAD_MUTEX_ERRORCHECK 1
5b2abdfb A	212	#define PTHREAD_MUTEX_RECURSIVE 2
5b2abdfb A	213	#define PTHREAD_MUTEX_DEFAULT PTHREAD_MUTEX_NORMAL
224c7076 A	214	/*
	215	* RWLock variables
	216	*/
	217
	218	#define PTHREAD_RWLOCK_INITIALIZER {_PTHREAD_RWLOCK_SIG_init, {0}}
e9ce8d39 A	219	/*
	220	* Mutex variables
	221	*/
	222
9385eb3d	223	#define PTHREAD_MUTEX_INITIALIZER {_PTHREAD_MUTEX_SIG_init, {0}}
e9ce8d39 A	224
	225	/*
	226	* Condition variable attributes
	227	*/
	228
	229	/*
	230	* Condition variables
	231	*/
	232
9385eb3d	233	#define PTHREAD_COND_INITIALIZER {_PTHREAD_COND_SIG_init, {0}}
e9ce8d39 A	234
	235	/*
	236	* Initialization control (once) variables
	237	*/
	238
9385eb3d	239	#define PTHREAD_ONCE_INIT {_PTHREAD_ONCE_SIG_init, {0}}
e9ce8d39	240
e9ce8d39 A	241	/*
	242	* Prototypes for all PTHREAD interfaces
	243	*/
224c7076 A	244	int pthread_atfork(void ()(void), void ()(void),
	245	void (*)(void));
	246	int pthread_attr_destroy(pthread_attr_t *);
	247	int pthread_attr_getdetachstate(const pthread_attr_t *,
	248	int *);
	249	int pthread_attr_getguardsize(const pthread_attr_t * __restrict,
	250	size_t * __restrict);
	251	int pthread_attr_getinheritsched(const pthread_attr_t * __restrict,
	252	int * __restrict);
	253	int pthread_attr_getschedparam(const pthread_attr_t * __restrict,
	254	struct sched_param * __restrict);
	255	int pthread_attr_getschedpolicy(const pthread_attr_t * __restrict,
	256	int * __restrict);
	257	int pthread_attr_getscope(const pthread_attr_t * __restrict, int * __restrict);
	258	int pthread_attr_getstack(const pthread_attr_t * __restrict,
	259	void ** __restrict, size_t * __restrict);
	260	int pthread_attr_getstackaddr(const pthread_attr_t * __restrict,
	261	void ** __restrict);
	262	int pthread_attr_getstacksize(const pthread_attr_t * __restrict,
	263	size_t * __restrict);
	264	int pthread_attr_init(pthread_attr_t *);
	265	int pthread_attr_setdetachstate(pthread_attr_t *,
	266	int );
	267	int pthread_attr_setguardsize(pthread_attr_t *, size_t );
	268	int pthread_attr_setinheritsched(pthread_attr_t *,
	269	int );
	270	int pthread_attr_setschedparam(pthread_attr_t * __restrict,
	271	const struct sched_param * __restrict);
	272	int pthread_attr_setschedpolicy(pthread_attr_t *,
	273	int );
3d9156a7	274	int pthread_attr_setscope(pthread_attr_t *, int);
224c7076 A	275	int pthread_attr_setstack(pthread_attr_t *,
	276	void *, size_t );
	277	int pthread_attr_setstackaddr(pthread_attr_t *,
	278	void *);
	279	int pthread_attr_setstacksize(pthread_attr_t *, size_t );
	280	int pthread_cancel(pthread_t ) __DARWIN_ALIAS(pthread_cancel);
	281
	282	int pthread_cond_broadcast(pthread_cond_t *);
	283	int pthread_cond_destroy(pthread_cond_t *);
	284	//Begin-Libc
	285	#ifndef LIBC_ALIAS_PTHREAD_COND_INIT
	286	//End-Libc
	287	int pthread_cond_init(pthread_cond_t * __restrict,
	288	const pthread_condattr_t * __restrict) __DARWIN_ALIAS(pthread_cond_init);
	289	//Begin-Libc
	290	#else /* LIBC_ALIAS_PTHREAD_COND_INIT */
	291	int pthread_cond_init(pthread_cond_t * __restrict,
	292	const pthread_condattr_t * __restrict) LIBC_ALIAS(pthread_cond_init);
	293	#endif /* !LIBC_ALIAS_PTHREAD_COND_INIT */
	294	//End-Libc
	295	int pthread_cond_signal(pthread_cond_t *);
	296	//Begin-Libc
	297	#ifndef LIBC_ALIAS_PTHREAD_COND_TIMEDWAIT
	298	//End-Libc
	299	int pthread_cond_timedwait(pthread_cond_t * __restrict,
	300	pthread_mutex_t * __restrict,
	301	const struct timespec * __restrict) __DARWIN_ALIAS_C(pthread_cond_timedwait);
	302	//Begin-Libc
	303	#else /* LIBC_ALIAS_PTHREAD_COND_TIMEDWAIT */
	304	int pthread_cond_timedwait(pthread_cond_t * __restrict,
	305	pthread_mutex_t * __restrict,
	306	const struct timespec * __restrict) LIBC_ALIAS_C(pthread_cond_timedwait);
	307	#endif /* !LIBC_ALIAS_PTHREAD_COND_TIMEDWAIT */
	308	//End-Libc
	309	//Begin-Libc
	310	#ifndef LIBC_ALIAS_PTHREAD_COND_WAIT
	311	//End-Libc
	312	int pthread_cond_wait(pthread_cond_t * __restrict,
	313	pthread_mutex_t * __restrict) __DARWIN_ALIAS_C(pthread_cond_wait);
	314	//Begin-Libc
	315	#else /* LIBC_ALIAS_PTHREAD_COND_WAIT */
	316	int pthread_cond_wait(pthread_cond_t * __restrict,
	317	pthread_mutex_t * __restrict) LIBC_ALIAS_C(pthread_cond_wait);
	318	#endif /* !LIBC_ALIAS_PTHREAD_COND_WAIT */
	319	//End-Libc
	320	int pthread_condattr_destroy(pthread_condattr_t *);
	321	int pthread_condattr_init(pthread_condattr_t *);
	322	int pthread_condattr_getpshared(const pthread_condattr_t * __restrict,
	323	int * __restrict);
	324	int pthread_condattr_setpshared(pthread_condattr_t *,
	325	int );
	326	int pthread_create(pthread_t * __restrict,
	327	const pthread_attr_t * __restrict,
	328	void ()(void *),
	329	void * __restrict);
	330	int pthread_detach(pthread_t );
	331	int pthread_equal(pthread_t ,
	332	pthread_t );
	333	void pthread_exit(void *) __dead2;
3d9156a7	334	int pthread_getconcurrency(void);
224c7076 A	335	int pthread_getschedparam(pthread_t , int * __restrict, struct sched_param * __restrict);
	336	void *pthread_getspecific(pthread_key_t );
	337	//Begin-Libc
	338	#ifndef LIBC_ALIAS_PTHREAD_JOIN
	339	//End-Libc
	340	int pthread_join(pthread_t , void **) __DARWIN_ALIAS_C(pthread_join);
	341	//Begin-Libc
	342	#else /* LIBC_ALIAS_PTHREAD_JOIN */
	343	int pthread_join(pthread_t , void **) LIBC_ALIAS_C(pthread_join);
	344	#endif /* !LIBC_ALIAS_PTHREAD_JOIN */
	345	//End-Libc
	346	int pthread_key_create(pthread_key_t , void ()(void *));
	347	int pthread_key_delete(pthread_key_t );
	348	int pthread_mutex_destroy(pthread_mutex_t *);
	349	int pthread_mutex_getprioceiling(const pthread_mutex_t * __restrict, int * __restrict);
	350	int pthread_mutex_init(pthread_mutex_t * __restrict, const pthread_mutexattr_t * __restrict);
	351	int pthread_mutex_lock(pthread_mutex_t *);
	352	int pthread_mutex_setprioceiling(pthread_mutex_t * __restrict, int, int * __restrict);
	353	int pthread_mutex_trylock(pthread_mutex_t *);
	354	int pthread_mutex_unlock(pthread_mutex_t *);
	355	//Begin-Libc
	356	#ifndef LIBC_ALIAS_PTHREAD_MUTEXATTR_DESTROY
	357	//End-Libc
	358	int pthread_mutexattr_destroy(pthread_mutexattr_t *) __DARWIN_ALIAS(pthread_mutexattr_destroy);
	359	//Begin-Libc
	360	#else /* LIBC_ALIAS_PTHREAD_MUTEXATTR_DESTROY */
	361	int pthread_mutexattr_destroy(pthread_mutexattr_t *) LIBC_ALIAS(pthread_mutexattr_destroy);
	362	#endif /* !LIBC_ALIAS_PTHREAD_MUTEXATTR_DESTROY */
	363	//End-Libc
	364	int pthread_mutexattr_getprioceiling(const pthread_mutexattr_t * __restrict, int * __restrict);
	365	int pthread_mutexattr_getprotocol(const pthread_mutexattr_t * __restrict, int * __restrict);
	366	int pthread_mutexattr_getpshared(const pthread_mutexattr_t * __restrict, int * __restrict);
	367	int pthread_mutexattr_gettype(const pthread_mutexattr_t * __restrict, int * __restrict);
	368	int pthread_mutexattr_init(pthread_mutexattr_t *);
	369	int pthread_mutexattr_setprioceiling(pthread_mutexattr_t *, int);
	370	int pthread_mutexattr_setprotocol(pthread_mutexattr_t *, int);
	371	int pthread_mutexattr_setpshared(pthread_mutexattr_t *, int );
	372	int pthread_mutexattr_settype(pthread_mutexattr_t *, int);
	373	int pthread_once(pthread_once_t , void ()(void));
	374	//Begin-Libc
	375	#ifndef LIBC_ALIAS_PTHREAD_RWLOCK_DESTROY
	376	//End-Libc
	377	int pthread_rwlock_destroy(pthread_rwlock_t * ) __DARWIN_ALIAS(pthread_rwlock_destroy);
	378	//Begin-Libc
	379	#else /* LIBC_ALIAS_PTHREAD_RWLOCK_DESTROY */
	380	int pthread_rwlock_destroy(pthread_rwlock_t * ) LIBC_ALIAS(pthread_rwlock_destroy);
	381	#endif /* !LIBC_ALIAS_PTHREAD_RWLOCK_DESTROY */
	382	//End-Libc
	383	//Begin-Libc
	384	#ifndef LIBC_ALIAS_PTHREAD_RWLOCK_INIT
	385	//End-Libc
	386	int pthread_rwlock_init(pthread_rwlock_t * __restrict, const pthread_rwlockattr_t * __restrict) __DARWIN_ALIAS(pthread_rwlock_init);
	387	//Begin-Libc
	388	#else /* LIBC_ALIAS_PTHREAD_RWLOCK_INIT */
	389	int pthread_rwlock_init(pthread_rwlock_t * __restrict, const pthread_rwlockattr_t * __restrict) LIBC_ALIAS(pthread_rwlock_init);
	390	#endif /* !LIBC_ALIAS_PTHREAD_RWLOCK_INIT */
	391	//End-Libc
	392	//Begin-Libc
	393	#ifndef LIBC_ALIAS_PTHREAD_RWLOCK_RDLOCK
	394	//End-Libc
	395	int pthread_rwlock_rdlock(pthread_rwlock_t *) __DARWIN_ALIAS(pthread_rwlock_rdlock);
	396	//Begin-Libc
	397	#else /* LIBC_ALIAS_PTHREAD_RWLOCK_RDLOCK */
	398	int pthread_rwlock_rdlock(pthread_rwlock_t *) LIBC_ALIAS(pthread_rwlock_rdlock);
399	#endif /* !LIBC_ALIAS_PTHREAD_RWLOCK_RDLOCK */
400	//End-Libc
401	//Begin-Libc
402	#ifndef LIBC_ALIAS_PTHREAD_RWLOCK_TRYRDLOCK
403	//End-Libc
404	int pthread_rwlock_tryrdlock(pthread_rwlock_t *) __DARWIN_ALIAS(pthread_rwlock_tryrdlock);
405	//Begin-Libc
406	#else /* LIBC_ALIAS_PTHREAD_RWLOCK_TRYRDLOCK */
407	int pthread_rwlock_tryrdlock(pthread_rwlock_t *) LIBC_ALIAS(pthread_rwlock_tryrdlock);
408	#endif /* !LIBC_ALIAS_PTHREAD_RWLOCK_TRYRDLOCK */
409	//End-Libc
410	//Begin-Libc
411	#ifndef LIBC_ALIAS_PTHREAD_RWLOCK_TRYWRLOCK
412	//End-Libc
413	int pthread_rwlock_trywrlock(pthread_rwlock_t *) __DARWIN_ALIAS(pthread_rwlock_trywrlock);
414	//Begin-Libc
415	#else /* LIBC_ALIAS_PTHREAD_RWLOCK_TRYWRLOCK */
416	int pthread_rwlock_trywrlock(pthread_rwlock_t *) LIBC_ALIAS(pthread_rwlock_trywrlock);
417	#endif /* !LIBC_ALIAS_PTHREAD_RWLOCK_TRYWRLOCK */
418	//End-Libc
419	//Begin-Libc
420	#ifndef LIBC_ALIAS_PTHREAD_RWLOCK_WRLOCK
421	//End-Libc
422	int pthread_rwlock_wrlock(pthread_rwlock_t *) __DARWIN_ALIAS(pthread_rwlock_wrlock);
423	//Begin-Libc
424	#else /* LIBC_ALIAS_PTHREAD_RWLOCK_WRLOCK */
425	int pthread_rwlock_wrlock(pthread_rwlock_t *) LIBC_ALIAS(pthread_rwlock_wrlock);
426	#endif /* !LIBC_ALIAS_PTHREAD_RWLOCK_WRLOCK */
427	//End-Libc
428	//Begin-Libc
429	#ifndef LIBC_ALIAS_PTHREAD_RWLOCK_UNLOCK
430	//End-Libc
431	int pthread_rwlock_unlock(pthread_rwlock_t *) __DARWIN_ALIAS(pthread_rwlock_unlock);
432	//Begin-Libc
433	#else /* LIBC_ALIAS_PTHREAD_RWLOCK_UNLOCK */
434	int pthread_rwlock_unlock(pthread_rwlock_t *) LIBC_ALIAS(pthread_rwlock_unlock);
435	#endif /* !LIBC_ALIAS_PTHREAD_RWLOCK_UNLOCK */
436	//End-Libc
437	int pthread_rwlockattr_destroy(pthread_rwlockattr_t *);
438	int pthread_rwlockattr_getpshared(const pthread_rwlockattr_t * __restrict,
439	int * __restrict);
440	int pthread_rwlockattr_init(pthread_rwlockattr_t *);
441	int pthread_rwlockattr_setpshared(pthread_rwlockattr_t *,
442	int );
3d9156a7	443	pthread_t pthread_self(void);
5b2abdfb	444
224c7076 A	445	//Begin-Libc
	446	#ifndef LIBC_ALIAS_PTHREAD_SETCANCELSTATE
	447	//End-Libc
	448	int pthread_setcancelstate(int , int *) __DARWIN_ALIAS(pthread_setcancelstate);
	449	//Begin-Libc
	450	#else /* LIBC_ALIAS_PTHREAD_SETCANCELSTATE */
	451	int pthread_setcancelstate(int , int *) LIBC_ALIAS(pthread_setcancelstate);
	452	#endif /* !LIBC_ALIAS_PTHREAD_SETCANCELSTATE */
	453	//End-Libc
	454	//Begin-Libc
	455	#ifndef LIBC_ALIAS_PTHREAD_SETCANCELTYPE
	456	//End-Libc
	457	int pthread_setcanceltype(int , int *) __DARWIN_ALIAS(pthread_setcanceltype);
	458	//Begin-Libc
	459	#else /* LIBC_ALIAS_PTHREAD_SETCANCELTYPE */
	460	int pthread_setcanceltype(int , int *) LIBC_ALIAS(pthread_setcanceltype);
	461	#endif /* !LIBC_ALIAS_PTHREAD_SETCANCELTYPE */
	462	//End-Libc
3d9156a7	463	int pthread_setconcurrency(int);
224c7076 A	464	int pthread_setschedparam(pthread_t ,
	465	int ,
	466	const struct sched_param *);
	467	int pthread_setspecific(pthread_key_t ,
	468	const void *);
3d9156a7 A	469	void pthread_testcancel(void) __DARWIN_ALIAS(pthread_testcancel);
3d9156a7 A	470
224c7076	471	#if (!defined(_POSIX_C_SOURCE) && !defined(_XOPEN_SOURCE)) \|\| defined(_DARWIN_C_SOURCE)
e9ce8d39	472	/* returns non-zero if pthread_create or cthread_fork have been called */
9385eb3d	473	int pthread_is_threaded_np(void);
e9ce8d39	474
5b2abdfb	475	/* returns non-zero if the current thread is the main thread */
9385eb3d	476	int pthread_main_np(void);
5b2abdfb	477
e9ce8d39	478	/* return the mach thread bound to the pthread */
9385eb3d A	479	mach_port_t pthread_mach_thread_np(pthread_t);
	480	size_t pthread_get_stacksize_np(pthread_t);
	481	void * pthread_get_stackaddr_np(pthread_t);
e9ce8d39 A	482
e9ce8d39 A	483	/* Like pthread_cond_signal(), but only wake up the specified pthread */
9385eb3d	484	int pthread_cond_signal_thread_np(pthread_cond_t *, pthread_t);
e9ce8d39	485
5b2abdfb	486	/* Like pthread_cond_timedwait, but use a relative timeout */
224c7076 A	487	int pthread_cond_timedwait_relative_np(pthread_cond_t *,
	488	pthread_mutex_t *,
	489	const struct timespec *);
5b2abdfb	490
e9ce8d39	491	/* Like pthread_create(), but leaves the thread suspended */
224c7076 A	492	int pthread_create_suspended_np(pthread_t *,
	493	const pthread_attr_t *,
	494	void ()(void *),
	495	void *);
3d9156a7	496	int pthread_kill(pthread_t, int);
224c7076 A	497
	498	pthread_t pthread_from_mach_thread_np(mach_port_t);
	499
	500	//Begin-Libc
	501	#ifndef LIBC_ALIAS_PTHREAD_SIGMASK
	502	//End-Libc
	503	int pthread_sigmask(int, const sigset_t , sigset_t ) __DARWIN_ALIAS(pthread_sigmask);
	504	//Begin-Libc
	505	#else /* LIBC_ALIAS_PTHREAD_SIGMASK */
	506	int pthread_sigmask(int, const sigset_t , sigset_t ) LIBC_ALIAS(pthread_sigmask);
	507	#endif /* !LIBC_ALIAS_PTHREAD_SIGMASK */
	508	//End-Libc
3d9156a7	509	void pthread_yield_np(void);
224c7076	510	#endif /* (!_POSIX_C_SOURCE && !_XOPEN_SOURCE) \|\| _DARWIN_C_SOURCE */
e9ce8d39	511	__END_DECLS
224c7076	512	#endif /* _PTHREAD_H */