* configure.in: Remove PTH_ALLOW.

	* cygwin.din: Remove @PTH_ALLOW@ prefixes to pthread functions.
	Add new pthread exports.
	* pthread.cc: New wrapper functions for the above new exports.
	* sched.cc (valid_sched_parameters): New function.
	(sched_setparam): Use it.
	(sched_set_thread_priority): New function. Used by pthread_sched*.
	* thread.cc (pthread_key_destructor::InsertAfter): New function.
	(pthread_key_destructor::UnlinkNext): New function.
	(pthread_key_destructor::Next): New function.
	(pthread_key_destructor_list::Insert): New function.
	(pthread_key_destructor_list::Remove): New function.
	(pthread_key_destructor_list::Pop): New function.
	(pthread_key_destructor::pthread_key_destructor): New function.
	(pthread_key_destructor_list::IterateNull): New function.
	(MTinterface::Init): Initialise new member.
	(pthread::pthread): Initialise new members.
	(pthread::create): Copy new attributes. Set the new thread priority.
	(pthread_attr::pthread_attr): Initialise new members.
	(pthread_key::pthread_key): Setup destructor function.
	(pthread_key::~pthread_key): Remove destructor function.
	(pthread_mutexattr::pthread_mutexattr): New function.
	(pthread_mutexattr::~pthread_mutexattr): New function.
	(__pthread_once): New function.
	(__pthread_cleanup): New function.
	(__pthread_cancel): New function.
	(__pthread_setcancelstate): New function.
	(__pthread_setcanceltype): New function.
	(__pthread_testcancel): New function.
	(__pthread_attr_getinheritsched): New function.
	(__pthread_attr_getschedparam): New function.
	(__pthread_attr_getschedpolicy): New function.
	(__pthread_attr_getscope): New function.
	(__pthread_attr_setinheritsched): New function.
	(__pthread_attr_setschedparam): New function.
	(__pthread_attr_setschedpolicy): New function.
	(__pthread_attr_setscope): New function.
	(__pthread_exit): Call any key destructors on thread exit.
	(__pthread_join): Use the embedded attr values.
	(__pthread_detach): Use the embedded attr values.
	(__pthread_getconcurrency): New function.
	(__pthread_getschedparam): New function.
	(__pthread_key_create): Pass the destructor on object creation.
	(__pthread_key_delete): Correct incorrect prototype.
	(__pthread_setconcurrency): New function.
	(__pthread_setschedparam): New function.
	(__pthread_cond_timedwait): Support static mutex initialisers.
	(__pthread_cond_wait): Ditto.
	(__pthread_mutex_getprioceiling): New function.
	(__pthread_mutex_lock): Support static mutex initialisers.
	(__pthread_mutex_trylock): Ditto.
	(__pthread_mutex_unlock): Ditto.
	(__pthread_mutex_destroy): Ditto.
	(__pthread_mutex_setprioceiling): New function.
	(__pthread_mutexattr_getprotocol): New function.
	(__pthread_mutexattr_getpshared): New function.
	(__pthread_mutexattr_gettype): New function.
	(__pthread_mutexattr_init): New function.
	(__pthread_mutexattr_destroy): New function.
	(__pthread_mutexattr_setprotocol): New function.
	(__pthread_mutexattr_setprioceiling): New function.
	(__pthread_mutexattr_getprioceiling): New function.
	(__pthread_mutexattr_setpshared): New function.
	(__pthread_mutexattr_settype): New function.
	Remove stubs for non MT_SAFE compilation.
	* thread.h: Remove duplicate #defines.
	Add prototypes for new functions in thread.cc.
	(pthread_key_destructor): New class.
	(pthread_key_destructor_list): New class.
	(pthread_attr): Add new members.
	(pthread): Remove members that are duplicated in the pthread_attr class.
	(pthread_mutex_attr): Add new members.
	(pthread_once): New class.
	* include/pthread.h: Add prototypes for new functions exported from cygwin1.dll.
	Remove typedefs.
	* include/sched.h: Add prototypes for new functions in sched.cc.
	* include/cygwin/types.h: Add typedefs from pthread.h

1 files changed, 285 insertions, 50 deletions

diff --git a/winsup/cygwin/pthread.cc b/winsup/cygwin/pthread.cc
index 171fe6386..c9f0bb2bf 100644
--- a/winsup/cygwin/pthread.cc
+++ b/winsup/cygwin/pthread.cc
@@ -17,111 +17,193 @@ extern "C"
 {
 /*  ThreadCreation */
 int
-  pthread_create (pthread_t * thread, const pthread_attr_t * attr,
-		  void *(*start_routine) (void *), void *arg)
+pthread_create (pthread_t * thread, const pthread_attr_t * attr,
+		void *(*start_routine) (void *), void *arg)
 {
   return __pthread_create (thread, attr, start_routine, arg);
 }
 
-int pthread_attr_init (pthread_attr_t * attr)
+int
+pthread_once (pthread_once_t * once_control, void (*init_routine) (void))
+{
+  return __pthread_once (once_control, init_routine);
+}
+
+int
+pthread_attr_init (pthread_attr_t * attr)
 {
   return __pthread_attr_init (attr);
 }
 
-int pthread_attr_destroy (pthread_attr_t * attr)
+int
+pthread_attr_destroy (pthread_attr_t * attr)
 {
   return __pthread_attr_destroy (attr);
 }
 
-int pthread_attr_setdetachstate (pthread_attr_t * attr, int detachstate)
+int
+pthread_attr_setdetachstate (pthread_attr_t * attr, int detachstate)
 {
   return __pthread_attr_setdetachstate (attr, detachstate);
 }
 
 int
-  pthread_attr_getdetachstate (const pthread_attr_t * attr,
-			       int *detachstate)
+pthread_attr_getdetachstate (const pthread_attr_t * attr, int *detachstate)
 {
   return __pthread_attr_getdetachstate (attr, detachstate);
 }
 
 
-int pthread_attr_setstacksize (pthread_attr_t * attr, size_t size)
+int
+pthread_attr_setstacksize (pthread_attr_t * attr, size_t size)
 {
   return __pthread_attr_setstacksize (attr, size);
 }
 
-int pthread_attr_getstacksize (pthread_attr_t * attr, size_t * size)
+int
+pthread_attr_getstacksize (const pthread_attr_t * attr, size_t * size)
 {
   return __pthread_attr_getstacksize (attr, size);
 }
 
+int
+pthread_attr_setinheritsched (pthread_attr_t * attr, int inheritsched)
+{
+  return __pthread_attr_setinheritsched (attr, inheritsched);
+}
+
+int
+pthread_attr_getinheritsched (const pthread_attr_t * attr, int *inheritsched)
+{
+  return __pthread_attr_getinheritsched (attr, inheritsched);
+}
+
+int
+pthread_attr_setschedparam (pthread_attr_t * attr,
+			    const struct sched_param *param)
+{
+  return __pthread_attr_setschedparam (attr, param);
+}
+
+int
+pthread_attr_getschedparam (const pthread_attr_t * attr,
+			    struct sched_param *param)
+{
+  return __pthread_attr_getschedparam (attr, param);
+}
+
+int
+pthread_attr_setschedpolicy (pthread_attr_t * attr, int policy)
+{
+  return __pthread_attr_setschedpolicy (attr, policy);
+}
+
+int
+pthread_attr_getschedpolicy (const pthread_attr_t * attr, int *policy)
+{
+  return __pthread_attr_getschedpolicy (attr, policy);
+}
+
+int
+pthread_attr_setscope (pthread_attr_t * attr, int contentionscope)
+{
+  return __pthread_attr_setscope (attr, contentionscope);
+}
+
+int
+pthread_attr_getscope (const pthread_attr_t * attr, int *contentionscope)
+{
+  return __pthread_attr_getscope (attr, contentionscope);
+}
+
+#ifdef _POSIX_THREAD_ATTR_STACKADDR
+int
+pthread_attr_setstackaddr (pthread_attr_t * attr, void *stackaddr)
+{
+  return __pthread_attr_setstackaddr (attr, stackaddr);
+}
 
-/*
- pthread_attr_setstackaddr(...){};
- pthread_attr_getstackaddr(...){};
-*/
+int
+pthread_attr_getstackaddr (const pthread_attr_t * attr, void **stackaddr)
+{
+  return __pthread_attr_getstackaddr (attr, stackaddr);
+}
+#endif
 
 /* Thread Exit */
-void pthread_exit (void *value_ptr)
+void
+pthread_exit (void *value_ptr)
 {
   return __pthread_exit (value_ptr);
 }
 
-int pthread_join (pthread_t thread, void **return_val)
+int
+pthread_join (pthread_t thread, void **return_val)
 {
   return __pthread_join (&thread, (void **) return_val);
 }
 
-int pthread_detach (pthread_t thread)
+int
+pthread_detach (pthread_t thread)
 {
   return __pthread_detach (&thread);
 }
 
-int pthread_suspend (pthread_t thread)
+
+/* This isn't a posix call... should we keep it? */
+int
+pthread_suspend (pthread_t thread)
 {
   return __pthread_suspend (&thread);
 }
 
-int pthread_continue (pthread_t thread)
+/* same */
+int
+pthread_continue (pthread_t thread)
 {
   return __pthread_continue (&thread);
 }
 
-unsigned long pthread_getsequence_np (pthread_t * thread)
+unsigned long
+pthread_getsequence_np (pthread_t * thread)
 {
   return __pthread_getsequence_np (thread);
 }
 
 /* Thread SpecificData */
-int pthread_key_create (pthread_key_t * key, void (*destructor) (void *))
+int
+pthread_key_create (pthread_key_t * key, void (*destructor) (void *))
 {
   return __pthread_key_create (key, destructor);
 }
 
-int pthread_key_delete (pthread_key_t * key)
+int
+pthread_key_delete (pthread_key_t key)
 {
   return __pthread_key_delete (key);
 }
 
-int pthread_setspecific (pthread_key_t key, const void *value)
+int
+pthread_setspecific (pthread_key_t key, const void *value)
 {
   return __pthread_setspecific (key, value);
 }
 
-void *pthread_getspecific (pthread_key_t key)
+void *
+pthread_getspecific (pthread_key_t key)
 {
   return (void *) __pthread_getspecific (key);
 }
 
 /* Thread signal */
-int pthread_kill (pthread_t * thread, int sig)
+int
+pthread_kill (pthread_t thread, int sig)
 {
   return __pthread_kill (thread, sig);
 }
 
 int
-  pthread_sigmask (int operation, const sigset_t * set, sigset_t * old_set)
+pthread_sigmask (int operation, const sigset_t * set, sigset_t * old_set)
 {
   return __pthread_sigmask (operation, set, old_set);
 }
@@ -133,120 +215,273 @@ pthread_t pthread_self ()
   return __pthread_self ();
 }
 
-int pthread_equal (pthread_t t1, pthread_t t2)
+int
+pthread_equal (pthread_t t1, pthread_t t2)
 {
   return __pthread_equal (&t1, &t2);
 }
 
 /* Mutexes  */
 int
-  pthread_mutex_init (pthread_mutex_t * mutex,
-		      const pthread_mutexattr_t * attr)
+pthread_mutex_init (pthread_mutex_t * mutex, const pthread_mutexattr_t * attr)
 {
   return __pthread_mutex_init (mutex, attr);
 }
 
-int pthread_mutex_lock (pthread_mutex_t * mutex)
+int
+pthread_mutex_lock (pthread_mutex_t * mutex)
 {
   return __pthread_mutex_lock (mutex);
 }
 
-int pthread_mutex_trylock (pthread_mutex_t * mutex)
+int
+pthread_mutex_trylock (pthread_mutex_t * mutex)
 {
   return __pthread_mutex_trylock (mutex);
 }
 
-int pthread_mutex_unlock (pthread_mutex_t * mutex)
+int
+pthread_mutex_unlock (pthread_mutex_t * mutex)
 {
   return __pthread_mutex_unlock (mutex);
 }
 
-int pthread_mutex_destroy (pthread_mutex_t * mutex)
+int
+pthread_mutex_destroy (pthread_mutex_t * mutex)
 {
   return __pthread_mutex_destroy (mutex);
 }
 
+int
+pthread_mutex_setprioceiling (pthread_mutex_t * mutex,
+			      int prioceiling, int *old_ceiling)
+{
+  return __pthread_mutex_setprioceiling (mutex, prioceiling, old_ceiling);
+}
+
+int
+pthread_mutex_getprioceiling (const pthread_mutex_t * mutex, int *prioceiling)
+{
+  return __pthread_mutex_getprioceiling (mutex, prioceiling);
+}
+
+
+
+int
+pthread_mutexattr_destroy (pthread_mutexattr_t * attr)
+{
+  return __pthread_mutexattr_destroy (attr);
+}
+
+int
+pthread_mutexattr_getprioceiling (const pthread_mutexattr_t * attr,
+				  int *prioceiling)
+{
+  return __pthread_mutexattr_getprioceiling (attr, prioceiling);
+}
+
+int
+pthread_mutexattr_getprotocol (const pthread_mutexattr_t * attr,
+			       int *protocol)
+{
+  return __pthread_mutexattr_getprotocol (attr, protocol);
+}
+
+int
+pthread_mutexattr_getpshared (const pthread_mutexattr_t * attr, int *pshared)
+{
+  return __pthread_mutexattr_getpshared (attr, pshared);
+}
+
+int
+pthread_mutexattr_gettype (const pthread_mutexattr_t * attr, int *type)
+{
+  return __pthread_mutexattr_gettype (attr, type);
+}
+
+int
+pthread_mutexattr_init (pthread_mutexattr_t * attr)
+{
+  return __pthread_mutexattr_init (attr);
+}
+
+int
+pthread_mutexattr_setprioceiling (pthread_mutexattr_t * attr, int prioceiling)
+{
+  return __pthread_mutexattr_setprioceiling (attr, prioceiling);
+}
+
+int
+pthread_mutexattr_setprotocol (pthread_mutexattr_t * attr, int protocol)
+{
+  return __pthread_mutexattr_setprotocol (attr, protocol);
+}
+
+int
+pthread_mutexattr_setpshared (pthread_mutexattr_t * attr, int pshared)
+{
+  return __pthread_mutexattr_setpshared (attr, pshared);
+}
+
+int
+pthread_mutexattr_settype (pthread_mutexattr_t * attr, int type)
+{
+  return __pthread_mutexattr_settype (attr, type);
+}
+
 /* Synchronisation */
 
-int pthread_cond_destroy (pthread_cond_t * cond)
+int
+pthread_cond_destroy (pthread_cond_t * cond)
 {
   return __pthread_cond_destroy (cond);
 }
 
 int
-  pthread_cond_init (pthread_cond_t * cond, const pthread_condattr_t * attr)
+pthread_cond_init (pthread_cond_t * cond, const pthread_condattr_t * attr)
 {
   return __pthread_cond_init (cond, attr);
 }
 
-int pthread_cond_signal (pthread_cond_t * cond)
+int
+pthread_cond_signal (pthread_cond_t * cond)
 {
   return __pthread_cond_signal (cond);
 }
 
-int pthread_cond_broadcast (pthread_cond_t * cond)
+int
+pthread_cond_broadcast (pthread_cond_t * cond)
 {
   return __pthread_cond_broadcast (cond);
 }
 
 int
-  pthread_cond_timedwait (pthread_cond_t * cond,
-			  pthread_mutex_t * mutex,
-			  const struct timespec *abstime)
+pthread_cond_timedwait (pthread_cond_t * cond,
+			pthread_mutex_t * mutex,
+			const struct timespec *abstime)
 {
   return __pthread_cond_timedwait (cond, mutex, abstime);
 }
 
-int pthread_cond_wait (pthread_cond_t * cond, pthread_mutex_t * mutex)
+int
+pthread_cond_wait (pthread_cond_t * cond, pthread_mutex_t * mutex)
 {
   return __pthread_cond_wait (cond, mutex);
 }
 
-int pthread_condattr_init (pthread_condattr_t * condattr)
+int
+pthread_condattr_init (pthread_condattr_t * condattr)
 {
   return __pthread_condattr_init (condattr);
 }
 
-int pthread_condattr_destroy (pthread_condattr_t * condattr)
+int
+pthread_condattr_destroy (pthread_condattr_t * condattr)
 {
   return __pthread_condattr_destroy (condattr);
 }
 
 int
-  pthread_condattr_getpshared (const pthread_condattr_t * attr,
-			       int *pshared)
+pthread_condattr_getpshared (const pthread_condattr_t * attr, int *pshared)
 {
   return __pthread_condattr_getpshared (attr, pshared);
 }
 
-int pthread_condattr_setpshared (pthread_condattr_t * attr, int pshared)
+int
+pthread_condattr_setpshared (pthread_condattr_t * attr, int pshared)
 {
   return __pthread_condattr_setpshared (attr, pshared);
 }
 
+/* Scheduling */
+
+int
+pthread_getconcurrency (void)
+{
+  return __pthread_getconcurrency ();
+}
+
+int
+pthread_setconcurrency (int new_level)
+{
+  return __pthread_setconcurrency (new_level);
+}
+
+
+
+
+int
+pthread_getschedparam (pthread_t thread, int *policy,
+		       struct sched_param *param)
+{
+  return __pthread_getschedparam (thread, policy, param);
+}
+
+int
+pthread_setschedparam (pthread_t thread, int policy,
+		       const struct sched_param *param)
+{
+  return __pthread_setschedparam (thread, policy, param);
+}
+
+
+/* Cancelability */
+
+int
+pthread_cancel (pthread_t thread)
+{
+  return __pthread_cancel (thread);
+}
+
+
+
+int
+pthread_setcancelstate (int state, int *oldstate)
+{
+  return __pthread_setcancelstate (state, oldstate);
+}
+
+int
+pthread_setcanceltype (int type, int *oldtype)
+{
+  return __pthread_setcanceltype (type, oldtype);
+}
+
+void
+pthread_testcancel (void)
+{
+  __pthread_testcancel ();
+}
+
 /* Semaphores */
-int sem_init (sem_t * sem, int pshared, unsigned int value)
+int
+sem_init (sem_t * sem, int pshared, unsigned int value)
 {
   return __sem_init (sem, pshared, value);
 }
 
-int sem_destroy (sem_t * sem)
+int
+sem_destroy (sem_t * sem)
 {
   return __sem_destroy (sem);
 }
 
-int sem_wait (sem_t * sem)
+int
+sem_wait (sem_t * sem)
 {
   return __sem_wait (sem);
 }
 
-int sem_trywait (sem_t * sem)
+int
+sem_trywait (sem_t * sem)
 {
   return __sem_trywait (sem);
 }
 
-int sem_post (sem_t * sem)
+int
+sem_post (sem_t * sem)
 {
   return __sem_post (sem);
 }
+
 }