newlib/newlib/libc/sys/linux/linuxthreads/condvar.c - native_client/nacl-toolchain - Git at Google

 /* Linuxthreads - a simple clone()-based implementation of Posix        */
 /* threads for Linux.                                                   */
 /* Copyright (C) 1996 Xavier Leroy (Xavier.Leroy@inria.fr)              */
 /* and Pavel Krauz (krauz@fsid.cvut.cz).                                */
 /*                                                                      */
 /* This program is free software; you can redistribute it and/or        */
 /* modify it under the terms of the GNU Library General Public License  */
 /* as published by the Free Software Foundation; either version 2       */
 /* of the License, or (at your option) any later version.               */
 /*                                                                      */
 /* This program is distributed in the hope that it will be useful,      */
 /* but WITHOUT ANY WARRANTY; without even the implied warranty of       */
 /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the        */
 /* GNU Library General Public License for more details.                 */

 /* Condition variables */

 #include <errno.h>
 #include <sched.h>
 #include <stddef.h>
 #include <sys/time.h>
 #include "pthread.h"
 #include "internals.h"
 #include "spinlock.h"
 #include "queue.h"
 #include "restart.h"

 int pthread_cond_init(pthread_cond_t *cond,
                       const pthread_condattr_t *cond_attr)
 {
   __pthread_init_lock(&cond->__c_lock);
   cond->__c_waiting = NULL;
   return 0;
 }

 int pthread_cond_destroy(pthread_cond_t *cond)
 {
   if (cond->__c_waiting != NULL) return EBUSY;
   return 0;
 }

 /* Function called by pthread_cancel to remove the thread from
    waiting on a condition variable queue. */

 static int cond_extricate_func(void *obj, pthread_descr th)
 {
   volatile pthread_descr self = thread_self();
   pthread_cond_t *cond = obj;
   int did_remove = 0;

   __pthread_lock(&cond->__c_lock, self);
   did_remove = remove_from_queue(&cond->__c_waiting, th);
   __pthread_unlock(&cond->__c_lock);

   return did_remove;
 }

 int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex)
 {
   volatile pthread_descr self = thread_self();
   pthread_extricate_if extr;
   int already_canceled = 0;
   int spurious_wakeup_count;

   /* Check whether the mutex is locked and owned by this thread.  */
   if (mutex->__m_kind != PTHREAD_MUTEX_TIMED_NP
       && mutex->__m_kind != PTHREAD_MUTEX_ADAPTIVE_NP
       && mutex->__m_owner != self)
     return EINVAL;

   /* Set up extrication interface */
   extr.pu_object = cond;
   extr.pu_extricate_func = cond_extricate_func;

   /* Register extrication interface */
   THREAD_SETMEM(self, p_condvar_avail, 0);
   __pthread_set_own_extricate_if(self, &extr);

   /* Atomically enqueue thread for waiting, but only if it is not
      canceled. If the thread is canceled, then it will fall through the
      suspend call below, and then call pthread_exit without
      having to worry about whether it is still on the condition variable queue.
      This depends on pthread_cancel setting p_canceled before calling the
      extricate function. */

   __pthread_lock(&cond->__c_lock, self);
   if (!(THREAD_GETMEM(self, p_canceled)
       && THREAD_GETMEM(self, p_cancelstate) == PTHREAD_CANCEL_ENABLE))
     enqueue(&cond->__c_waiting, self);
   else
     already_canceled = 1;
   __pthread_unlock(&cond->__c_lock);

   if (already_canceled) {
     __pthread_set_own_extricate_if(self, 0);
     __pthread_do_exit(PTHREAD_CANCELED, CURRENT_STACK_FRAME);
   }

   pthread_mutex_unlock(mutex);

   spurious_wakeup_count = 0;
   while (1)
     {
       suspend(self);
       if (THREAD_GETMEM(self, p_condvar_avail) == 0
 	  && (THREAD_GETMEM(self, p_woken_by_cancel) == 0
 	      || THREAD_GETMEM(self, p_cancelstate) != PTHREAD_CANCEL_ENABLE))
 	{
 	  /* Count resumes that don't belong to us. */
 	  spurious_wakeup_count++;
 	  continue;
 	}
       break;
     }

   __pthread_set_own_extricate_if(self, 0);

   /* Check for cancellation again, to provide correct cancellation
      point behavior */

   if (THREAD_GETMEM(self, p_woken_by_cancel)
       && THREAD_GETMEM(self, p_cancelstate) == PTHREAD_CANCEL_ENABLE) {
     THREAD_SETMEM(self, p_woken_by_cancel, 0);
     pthread_mutex_lock(mutex);
     __pthread_do_exit(PTHREAD_CANCELED, CURRENT_STACK_FRAME);
   }

   /* Put back any resumes we caught that don't belong to us. */
   while (spurious_wakeup_count--)
     restart(self);

   pthread_mutex_lock(mutex);
   return 0;
 }

 static int
 pthread_cond_timedwait_relative(pthread_cond_t *cond,
 				pthread_mutex_t *mutex,
 				const struct timespec * abstime)
 {
   volatile pthread_descr self = thread_self();
   int already_canceled = 0;
   pthread_extricate_if extr;
   int spurious_wakeup_count;

   /* Check whether the mutex is locked and owned by this thread.  */
   if (mutex->__m_kind != PTHREAD_MUTEX_TIMED_NP
       && mutex->__m_kind != PTHREAD_MUTEX_ADAPTIVE_NP
       && mutex->__m_owner != self)
     return EINVAL;

   /* Set up extrication interface */
   extr.pu_object = cond;
   extr.pu_extricate_func = cond_extricate_func;

   /* Register extrication interface */
   THREAD_SETMEM(self, p_condvar_avail, 0);
   __pthread_set_own_extricate_if(self, &extr);

   /* Enqueue to wait on the condition and check for cancellation. */
   __pthread_lock(&cond->__c_lock, self);
   if (!(THREAD_GETMEM(self, p_canceled)
       && THREAD_GETMEM(self, p_cancelstate) == PTHREAD_CANCEL_ENABLE))
     enqueue(&cond->__c_waiting, self);
   else
     already_canceled = 1;
   __pthread_unlock(&cond->__c_lock);

   if (already_canceled) {
     __pthread_set_own_extricate_if(self, 0);
     __pthread_do_exit(PTHREAD_CANCELED, CURRENT_STACK_FRAME);
   }

   pthread_mutex_unlock(mutex);

   spurious_wakeup_count = 0;
   while (1)
     {
       if (!timedsuspend(self, abstime)) {
 	int was_on_queue;

 	/* __pthread_lock will queue back any spurious restarts that
 	   may happen to it. */

 	__pthread_lock(&cond->__c_lock, self);
 	was_on_queue = remove_from_queue(&cond->__c_waiting, self);
 	__pthread_unlock(&cond->__c_lock);

 	if (was_on_queue) {
 	  __pthread_set_own_extricate_if(self, 0);
 	  pthread_mutex_lock(mutex);
 	  return ETIMEDOUT;
 	}

 	/* Eat the outstanding restart() from the signaller */
 	suspend(self);
       }

       if (THREAD_GETMEM(self, p_condvar_avail) == 0
 	  && (THREAD_GETMEM(self, p_woken_by_cancel) == 0
 	      || THREAD_GETMEM(self, p_cancelstate) != PTHREAD_CANCEL_ENABLE))
 	{
 	  /* Count resumes that don't belong to us. */
 	  spurious_wakeup_count++;
 	  continue;
 	}
       break;
     }

   __pthread_set_own_extricate_if(self, 0);

   /* The remaining logic is the same as in other cancellable waits,
      such as pthread_join sem_wait or pthread_cond wait. */

   if (THREAD_GETMEM(self, p_woken_by_cancel)
       && THREAD_GETMEM(self, p_cancelstate) == PTHREAD_CANCEL_ENABLE) {
     THREAD_SETMEM(self, p_woken_by_cancel, 0);
     pthread_mutex_lock(mutex);
     __pthread_do_exit(PTHREAD_CANCELED, CURRENT_STACK_FRAME);
   }

   /* Put back any resumes we caught that don't belong to us. */
   while (spurious_wakeup_count--)
     restart(self);

   pthread_mutex_lock(mutex);
   return 0;
 }

 int pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex,
                            const struct timespec * abstime)
 {
   /* Indirect call through pointer! */
   return pthread_cond_timedwait_relative(cond, mutex, abstime);
 }

 int pthread_cond_signal(pthread_cond_t *cond)
 {
   pthread_descr th;

   __pthread_lock(&cond->__c_lock, NULL);
   th = dequeue(&cond->__c_waiting);
   __pthread_unlock(&cond->__c_lock);
   if (th != NULL) {
     th->p_condvar_avail = 1;
     WRITE_MEMORY_BARRIER();
     restart(th);
   }
   return 0;
 }

 int pthread_cond_broadcast(pthread_cond_t *cond)
 {
   pthread_descr tosignal, th;

   __pthread_lock(&cond->__c_lock, NULL);
   /* Copy the current state of the waiting queue and empty it */
   tosignal = cond->__c_waiting;
   cond->__c_waiting = NULL;
   __pthread_unlock(&cond->__c_lock);
   /* Now signal each process in the queue */
   while ((th = dequeue(&tosignal)) != NULL) {
     th->p_condvar_avail = 1;
     WRITE_MEMORY_BARRIER();
     restart(th);
   }
   return 0;
 }

 int pthread_condattr_init(pthread_condattr_t *attr)
 {
   return 0;
 }

 int pthread_condattr_destroy(pthread_condattr_t *attr)
 {
   return 0;
 }

 #if !defined(_ELIX_LEVEL) || _ELIX_LEVEL >= 3

 int pthread_condattr_getpshared (const pthread_condattr_t *attr, int *pshared)
 {
   *pshared = PTHREAD_PROCESS_PRIVATE;
   return 0;
 }

 int pthread_condattr_setpshared (pthread_condattr_t *attr, int pshared)
 {
   if (pshared != PTHREAD_PROCESS_PRIVATE && pshared != PTHREAD_PROCESS_SHARED)
     return EINVAL;

   /* For now it is not possible to shared a conditional variable.  */
   if (pshared != PTHREAD_PROCESS_PRIVATE)
     return ENOSYS;

   return 0;
 }

 #endif /* !_ELIX_LEVEL || _ELIX_LEVEL >= 3 */
	/* Linuxthreads - a simple clone()-based implementation of Posix */
	/* threads for Linux. */
	/* Copyright (C) 1996 Xavier Leroy (Xavier.Leroy@inria.fr) */
	/* and Pavel Krauz (krauz@fsid.cvut.cz). */
	/* */
	/* This program is free software; you can redistribute it and/or */
	/* modify it under the terms of the GNU Library General Public License */
	/* as published by the Free Software Foundation; either version 2 */
	/* of the License, or (at your option) any later version. */
	/* */
	/* This program is distributed in the hope that it will be useful, */
	/* but WITHOUT ANY WARRANTY; without even the implied warranty of */
	/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
	/* GNU Library General Public License for more details. */

	/* Condition variables */

	#include <errno.h>
	#include <sched.h>
	#include <stddef.h>
	#include <sys/time.h>
	#include "pthread.h"
	#include "internals.h"
	#include "spinlock.h"
	#include "queue.h"
	#include "restart.h"

	int pthread_cond_init(pthread_cond_t *cond,
	const pthread_condattr_t *cond_attr)
	{
	__pthread_init_lock(&cond->__c_lock);
	cond->__c_waiting = NULL;
	return 0;
	}

	int pthread_cond_destroy(pthread_cond_t *cond)
	{
	if (cond->__c_waiting != NULL) return EBUSY;
	return 0;
	}

	/* Function called by pthread_cancel to remove the thread from
	waiting on a condition variable queue. */

	static int cond_extricate_func(void *obj, pthread_descr th)
	{
	volatile pthread_descr self = thread_self();
	pthread_cond_t *cond = obj;
	int did_remove = 0;

	__pthread_lock(&cond->__c_lock, self);
	did_remove = remove_from_queue(&cond->__c_waiting, th);
	__pthread_unlock(&cond->__c_lock);

	return did_remove;
	}

	int pthread_cond_wait(pthread_cond_t cond, pthread_mutex_t mutex)
	{
	volatile pthread_descr self = thread_self();
	pthread_extricate_if extr;
	int already_canceled = 0;
	int spurious_wakeup_count;

	/* Check whether the mutex is locked and owned by this thread. */
	if (mutex->__m_kind != PTHREAD_MUTEX_TIMED_NP
	&& mutex->__m_kind != PTHREAD_MUTEX_ADAPTIVE_NP
	&& mutex->__m_owner != self)
	return EINVAL;

	/* Set up extrication interface */
	extr.pu_object = cond;
	extr.pu_extricate_func = cond_extricate_func;

	/* Register extrication interface */
	THREAD_SETMEM(self, p_condvar_avail, 0);
	__pthread_set_own_extricate_if(self, &extr);

	/* Atomically enqueue thread for waiting, but only if it is not
	canceled. If the thread is canceled, then it will fall through the
	suspend call below, and then call pthread_exit without
	having to worry about whether it is still on the condition variable queue.
	This depends on pthread_cancel setting p_canceled before calling the
	extricate function. */

	__pthread_lock(&cond->__c_lock, self);
	if (!(THREAD_GETMEM(self, p_canceled)
	&& THREAD_GETMEM(self, p_cancelstate) == PTHREAD_CANCEL_ENABLE))
	enqueue(&cond->__c_waiting, self);
	else
	already_canceled = 1;
	__pthread_unlock(&cond->__c_lock);

	if (already_canceled) {
	__pthread_set_own_extricate_if(self, 0);
	__pthread_do_exit(PTHREAD_CANCELED, CURRENT_STACK_FRAME);
	}

	pthread_mutex_unlock(mutex);

	spurious_wakeup_count = 0;
	while (1)
	{
	suspend(self);
	if (THREAD_GETMEM(self, p_condvar_avail) == 0
	&& (THREAD_GETMEM(self, p_woken_by_cancel) == 0
	\|\| THREAD_GETMEM(self, p_cancelstate) != PTHREAD_CANCEL_ENABLE))
	{
	/* Count resumes that don't belong to us. */
	spurious_wakeup_count++;
	continue;
	}
	break;
	}

	__pthread_set_own_extricate_if(self, 0);

	/* Check for cancellation again, to provide correct cancellation
	point behavior */

	if (THREAD_GETMEM(self, p_woken_by_cancel)
	&& THREAD_GETMEM(self, p_cancelstate) == PTHREAD_CANCEL_ENABLE) {
	THREAD_SETMEM(self, p_woken_by_cancel, 0);
	pthread_mutex_lock(mutex);
	__pthread_do_exit(PTHREAD_CANCELED, CURRENT_STACK_FRAME);
	}

	/* Put back any resumes we caught that don't belong to us. */
	while (spurious_wakeup_count--)
	restart(self);

	pthread_mutex_lock(mutex);
	return 0;
	}

	static int
	pthread_cond_timedwait_relative(pthread_cond_t *cond,
	pthread_mutex_t *mutex,
	const struct timespec * abstime)
	{
	volatile pthread_descr self = thread_self();
	int already_canceled = 0;
	pthread_extricate_if extr;
	int spurious_wakeup_count;

	/* Check whether the mutex is locked and owned by this thread. */
	if (mutex->__m_kind != PTHREAD_MUTEX_TIMED_NP
	&& mutex->__m_kind != PTHREAD_MUTEX_ADAPTIVE_NP
	&& mutex->__m_owner != self)
	return EINVAL;

	/* Set up extrication interface */
	extr.pu_object = cond;
	extr.pu_extricate_func = cond_extricate_func;

	/* Register extrication interface */
	THREAD_SETMEM(self, p_condvar_avail, 0);
	__pthread_set_own_extricate_if(self, &extr);

	/* Enqueue to wait on the condition and check for cancellation. */
	__pthread_lock(&cond->__c_lock, self);
	if (!(THREAD_GETMEM(self, p_canceled)
	&& THREAD_GETMEM(self, p_cancelstate) == PTHREAD_CANCEL_ENABLE))
	enqueue(&cond->__c_waiting, self);
	else
	already_canceled = 1;
	__pthread_unlock(&cond->__c_lock);

	if (already_canceled) {
	__pthread_set_own_extricate_if(self, 0);
	__pthread_do_exit(PTHREAD_CANCELED, CURRENT_STACK_FRAME);
	}

	pthread_mutex_unlock(mutex);

	spurious_wakeup_count = 0;
	while (1)
	{
	if (!timedsuspend(self, abstime)) {
	int was_on_queue;

	/* __pthread_lock will queue back any spurious restarts that
	may happen to it. */

	__pthread_lock(&cond->__c_lock, self);
	was_on_queue = remove_from_queue(&cond->__c_waiting, self);
	__pthread_unlock(&cond->__c_lock);

	if (was_on_queue) {
	__pthread_set_own_extricate_if(self, 0);
	pthread_mutex_lock(mutex);
	return ETIMEDOUT;
	}

	/* Eat the outstanding restart() from the signaller */
	suspend(self);
	}

	if (THREAD_GETMEM(self, p_condvar_avail) == 0
	&& (THREAD_GETMEM(self, p_woken_by_cancel) == 0
	\|\| THREAD_GETMEM(self, p_cancelstate) != PTHREAD_CANCEL_ENABLE))
	{
	/* Count resumes that don't belong to us. */
	spurious_wakeup_count++;
	continue;
	}
	break;
	}

	__pthread_set_own_extricate_if(self, 0);

	/* The remaining logic is the same as in other cancellable waits,
	such as pthread_join sem_wait or pthread_cond wait. */

	if (THREAD_GETMEM(self, p_woken_by_cancel)
	&& THREAD_GETMEM(self, p_cancelstate) == PTHREAD_CANCEL_ENABLE) {
	THREAD_SETMEM(self, p_woken_by_cancel, 0);
	pthread_mutex_lock(mutex);
	__pthread_do_exit(PTHREAD_CANCELED, CURRENT_STACK_FRAME);
	}

	/* Put back any resumes we caught that don't belong to us. */
	while (spurious_wakeup_count--)
	restart(self);

	pthread_mutex_lock(mutex);
	return 0;
	}

	int pthread_cond_timedwait(pthread_cond_t cond, pthread_mutex_t mutex,
	const struct timespec * abstime)
	{
	/* Indirect call through pointer! */
	return pthread_cond_timedwait_relative(cond, mutex, abstime);
	}

	int pthread_cond_signal(pthread_cond_t *cond)
	{
	pthread_descr th;

	__pthread_lock(&cond->__c_lock, NULL);
	th = dequeue(&cond->__c_waiting);
	__pthread_unlock(&cond->__c_lock);
	if (th != NULL) {
	th->p_condvar_avail = 1;
	WRITE_MEMORY_BARRIER();
	restart(th);
	}
	return 0;
	}

	int pthread_cond_broadcast(pthread_cond_t *cond)
	{
	pthread_descr tosignal, th;

	__pthread_lock(&cond->__c_lock, NULL);
	/* Copy the current state of the waiting queue and empty it */
	tosignal = cond->__c_waiting;
	cond->__c_waiting = NULL;
	__pthread_unlock(&cond->__c_lock);
	/* Now signal each process in the queue */
	while ((th = dequeue(&tosignal)) != NULL) {
	th->p_condvar_avail = 1;
	WRITE_MEMORY_BARRIER();
	restart(th);
	}
	return 0;
	}

	int pthread_condattr_init(pthread_condattr_t *attr)
	{
	return 0;
	}

	int pthread_condattr_destroy(pthread_condattr_t *attr)
	{
	return 0;
	}

	#if !defined(_ELIX_LEVEL) \|\| _ELIX_LEVEL >= 3

	int pthread_condattr_getpshared (const pthread_condattr_t attr, int pshared)
	{
	*pshared = PTHREAD_PROCESS_PRIVATE;
	return 0;
	}

	int pthread_condattr_setpshared (pthread_condattr_t *attr, int pshared)
	{
	if (pshared != PTHREAD_PROCESS_PRIVATE && pshared != PTHREAD_PROCESS_SHARED)
	return EINVAL;

	/* For now it is not possible to shared a conditional variable. */
	if (pshared != PTHREAD_PROCESS_PRIVATE)
	return ENOSYS;

	return 0;
	}

	#endif /* !_ELIX_LEVEL \|\| _ELIX_LEVEL >= 3 */