/* pthread.cc: posix pthread interface for Cygwin   Copyright 1998, 1999, 2000, 2001, 2002 Red Hat, Inc.   Originally written by Marco Fuykschot <marco@ddi.nl>   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. */#include "winsup.h"#include "thread.h"#include "errno.h"extern "C"{/*  ThreadCreation */intpthread_create (pthread_t * thread, const pthread_attr_t * attr,		void *(*start_routine) (void *), void *arg){  return pthread::create (thread, attr, start_routine, arg);}intpthread_once (pthread_once_t * once_control, void (*init_routine) (void)){  return pthread::once (once_control, init_routine);}intpthread_atfork (void (*prepare)(void), void (*parent)(void), void (*child)(void)){  return pthread::atfork (prepare, parent, child);}intpthread_attr_init (pthread_attr_t * attr){  return __pthread_attr_init (attr);}intpthread_attr_destroy (pthread_attr_t * attr){  return __pthread_attr_destroy (attr);}intpthread_attr_setdetachstate (pthread_attr_t * attr, int detachstate){  return __pthread_attr_setdetachstate (attr, detachstate);}intpthread_attr_getdetachstate (const pthread_attr_t * attr, int *detachstate){  return __pthread_attr_getdetachstate (attr, detachstate);}intpthread_attr_setstacksize (pthread_attr_t * attr, size_t size){  return __pthread_attr_setstacksize (attr, size);}intpthread_attr_getstacksize (const pthread_attr_t * attr, size_t * size){  return __pthread_attr_getstacksize (attr, size);}intpthread_attr_setinheritsched (pthread_attr_t * attr, int inheritsched){  return __pthread_attr_setinheritsched (attr, inheritsched);}intpthread_attr_getinheritsched (const pthread_attr_t * attr, int *inheritsched){  return __pthread_attr_getinheritsched (attr, inheritsched);}intpthread_attr_setschedparam (pthread_attr_t * attr,			    const struct sched_param *param){  return __pthread_attr_setschedparam (attr, param);}intpthread_attr_getschedparam (const pthread_attr_t * attr,			    struct sched_param *param){  return __pthread_attr_getschedparam (attr, param);}intpthread_attr_setschedpolicy (pthread_attr_t * attr, int policy){  return __pthread_attr_setschedpolicy (attr, policy);}intpthread_attr_getschedpolicy (const pthread_attr_t * attr, int *policy){  return __pthread_attr_getschedpolicy (attr, policy);}intpthread_attr_setscope (pthread_attr_t * attr, int contentionscope){  return __pthread_attr_setscope (attr, contentionscope);}intpthread_attr_getscope (const pthread_attr_t * attr, int *contentionscope){  return __pthread_attr_getscope (attr, contentionscope);}#ifdef _POSIX_THREAD_ATTR_STACKADDRintpthread_attr_setstackaddr (pthread_attr_t * attr, void *stackaddr){  return __pthread_attr_setstackaddr (attr, stackaddr);}intpthread_attr_getstackaddr (const pthread_attr_t * attr, void **stackaddr){  return __pthread_attr_getstackaddr (attr, stackaddr);}#endif/* Thread Exit */voidpthread_exit (void *value_ptr){  return pthread::self ()->exit (value_ptr);}intpthread_join (pthread_t thread, void **return_val){  return pthread::join (&thread, (void **) return_val);}intpthread_detach (pthread_t thread){  return pthread::detach (&thread);}/* This isn't a posix call... should we keep it? */intpthread_suspend (pthread_t thread){  return pthread::suspend (&thread);}/* same */intpthread_continue (pthread_t thread){  return pthread::resume (&thread);}unsigned longpthread_getsequence_np (pthread_t * thread){  if (!pthread::isGoodObject (thread))    return EINVAL;  return (*thread)->getsequence_np ();}/* Thread SpecificData */intpthread_key_create (pthread_key_t * key, void (*destructor) (void *)){  return __pthread_key_create (key, destructor);}intpthread_key_delete (pthread_key_t key){  return __pthread_key_delete (key);}intpthread_setspecific (pthread_key_t key, const void *value){  return __pthread_setspecific (key, value);}void *pthread_getspecific (pthread_key_t key){  return (void *) __pthread_getspecific (key);}/* Thread signal */intpthread_kill (pthread_t thread, int sig){  return __pthread_kill (thread, sig);}intpthread_sigmask (int operation, const sigset_t * set, sigset_t * old_set){  return __pthread_sigmask (operation, set, old_set);}/*  ID */pthread_t pthread_self (){  return pthread::self ();}intpthread_equal (pthread_t t1, pthread_t t2){  return __pthread_equal (&t1, &t2);}/* Mutexes  */intpthread_mutex_init (pthread_mutex_t * mutex, const pthread_mutexattr_t * attr){  return pthread_mutex::init (mutex, attr);}intpthread_mutex_lock (pthread_mutex_t * mutex){  return __pthread_mutex_lock (mutex);}intpthread_mutex_trylock (pthread_mutex_t * mutex){  return __pthread_mutex_trylock (mutex);}intpthread_mutex_unlock (pthread_mutex_t * mutex){  return __pthread_mutex_unlock (mutex);}intpthread_mutex_destroy (pthread_mutex_t * mutex){  return __pthread_mutex_destroy (mutex);}intpthread_mutex_setprioceiling (pthread_mutex_t * mutex,			      int prioceiling, int *old_ceiling){  return __pthread_mutex_setprioceiling (mutex, prioceiling, old_ceiling);}intpthread_mutex_getprioceiling (const pthread_mutex_t * mutex, int *prioceiling){  return __pthread_mutex_getprioceiling (mutex, prioceiling);}intpthread_mutexattr_destroy (pthread_mutexattr_t * attr){  return __pthread_mutexattr_destroy (attr);}intpthread_mutexattr_getprioceiling (const pthread_mutexattr_t * attr,				  int *prioceiling){  return __pthread_mutexattr_getprioceiling (attr, prioceiling);}intpthread_mutexattr_getprotocol (const pthread_mutexattr_t * attr,			       int *protocol){  return __pthread_mutexattr_getprotocol (attr, protocol);}intpthread_mutexattr_getpshared (const pthread_mutexattr_t * attr, int *pshared){  return __pthread_mutexattr_getpshared (attr, pshared);}intpthread_mutexattr_gettype (const pthread_mutexattr_t * attr, int *type){  return __pthread_mutexattr_gettype (attr, type);}intpthread_mutexattr_init (pthread_mutexattr_t * attr){  return __pthread_mutexattr_init (attr);}intpthread_mutexattr_setprioceiling (pthread_mutexattr_t * attr, int prioceiling){  return __pthread_mutexattr_setprioceiling (attr, prioceiling);}intpthread_mutexattr_setprotocol (pthread_mutexattr_t * attr, int protocol){  return __pthread_mutexattr_setprotocol (attr, protocol);}intpthread_mutexattr_setpshared (pthread_mutexattr_t * attr, int pshared){  return __pthread_mutexattr_setpshared (attr, pshared);}intpthread_mutexattr_settype (pthread_mutexattr_t * attr, int type){  return __pthread_mutexattr_settype (attr, type);}/* Synchronisation */intpthread_cond_destroy (pthread_cond_t * cond){  return __pthread_cond_destroy (cond);}intpthread_cond_init (pthread_cond_t * cond, const pthread_condattr_t * attr){  return __pthread_cond_init (cond, attr);}intpthread_cond_signal (pthread_cond_t * cond){  return __pthread_cond_signal (cond);}intpthread_cond_broadcast (pthread_cond_t * cond){  return __pthread_cond_broadcast (cond);}intpthread_condattr_init (pthread_condattr_t * condattr){  return __pthread_condattr_init (condattr);}intpthread_condattr_destroy (pthread_condattr_t * condattr){  return __pthread_condattr_destroy (condattr);}intpthread_condattr_getpshared (const pthread_condattr_t * attr, int *pshared){  return __pthread_condattr_getpshared (attr, pshared);}intpthread_condattr_setpshared (pthread_condattr_t * attr, int pshared){  return __pthread_condattr_setpshared (attr, pshared);}/* Scheduling */intpthread_getconcurrency (void){  return __pthread_getconcurrency ();}intpthread_setconcurrency (int new_level){  return __pthread_setconcurrency (new_level);}intpthread_getschedparam (pthread_t thread, int *policy,		       struct sched_param *param){  return __pthread_getschedparam (thread, policy, param);}intpthread_setschedparam (pthread_t thread, int policy,		       const struct sched_param *param){  return __pthread_setschedparam (thread, policy, param);}/* Cancelability */intpthread_cancel (pthread_t thread){  return pthread::cancel (thread);}intpthread_setcancelstate (int state, int *oldstate){  return pthread::self ()->setcancelstate (state, oldstate);}intpthread_setcanceltype (int type, int *oldtype){  return pthread::self ()->setcanceltype (type, oldtype);}voidpthread_testcancel (void){  pthread::self ()->testcancel ();}void_pthread_cleanup_push (__pthread_cleanup_handler *handler){  pthread::self ()->push_cleanup_handler (handler);}void_pthread_cleanup_pop (int execute){  pthread::self ()->pop_cleanup_handler (execute);}/* Semaphores */intsem_init (sem_t * sem, int pshared, unsigned int value){  return semaphore::init (sem, pshared, value);}intsem_destroy (sem_t * sem){  return semaphore::destroy (sem);}intsem_wait (sem_t * sem){  return semaphore::wait (sem);}intsem_trywait (sem_t * sem){  return semaphore::trywait (sem);}intsem_post (sem_t * sem){  return semaphore::post (sem);}}