Back to index

glibc  2.9
Functions
condvar.c File Reference
#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"
#include <shlib-compat.h>

Go to the source code of this file.

Functions

int __pthread_cond_init (pthread_cond_t *cond, const pthread_condattr_t *cond_attr)
 versioned_symbol (libpthread, __pthread_cond_init, pthread_cond_init, GLIBC_2_3_2)
int __pthread_cond_destroy (pthread_cond_t *cond)
 versioned_symbol (libpthread, __pthread_cond_destroy, pthread_cond_destroy, GLIBC_2_3_2)
static int cond_extricate_func (void *obj, pthread_descr th)
int __pthread_cond_wait (pthread_cond_t *cond, pthread_mutex_t *mutex)
 versioned_symbol (libpthread, __pthread_cond_wait, pthread_cond_wait, GLIBC_2_3_2)
static int pthread_cond_timedwait_relative (pthread_cond_t *cond, pthread_mutex_t *mutex, const struct timespec *abstime)
int __pthread_cond_timedwait (pthread_cond_t *cond, pthread_mutex_t *mutex, const struct timespec *abstime)
 versioned_symbol (libpthread, __pthread_cond_timedwait, pthread_cond_timedwait, GLIBC_2_3_2)
int __pthread_cond_signal (pthread_cond_t *cond)
 versioned_symbol (libpthread, __pthread_cond_signal, pthread_cond_signal, GLIBC_2_3_2)
int __pthread_cond_broadcast (pthread_cond_t *cond)
 versioned_symbol (libpthread, __pthread_cond_broadcast, pthread_cond_broadcast, GLIBC_2_3_2)
int __pthread_condattr_init (pthread_condattr_t *attr)
 strong_alias (__pthread_condattr_init, pthread_condattr_init)
 strong_alias (__pthread_condattr_destroy, pthread_condattr_destroy)
int pthread_condattr_setpshared (pthread_condattr_t *attr, int pshared)

Function Documentation

Definition at line 288 of file condvar.c.

{
  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;
}

Definition at line 44 of file condvar.c.

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

Definition at line 29 of file condvar.c.

{
  __pthread_init_lock(&cond->__c_lock);
  cond->__c_waiting = NULL;
  return 0;
}

Definition at line 266 of file condvar.c.

{
  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_timedwait ( pthread_cond_t cond,
pthread_mutex_t mutex,
const struct timespec abstime 
)

Definition at line 252 of file condvar.c.

{
  /* Indirect call through pointer! */
  return pthread_cond_timedwait_relative(cond, mutex, abstime);
}

Definition at line 73 of file condvar.c.

{
  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;
}

Definition at line 313 of file condvar.c.

{
  return 0;
}
static int cond_extricate_func ( void *  obj,
pthread_descr  th 
) [static]

Definition at line 60 of file condvar.c.

{
  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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int pthread_cond_timedwait_relative ( pthread_cond_t cond,
pthread_mutex_t mutex,
const struct timespec abstime 
) [static]

Definition at line 159 of file condvar.c.

{
  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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 331 of file condvar.c.

{
  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;
}

Here is the caller graph for this function:

Definition at line 317 of file condvar.c.

{
  return 0;
}

Definition at line 323 of file condvar.c.

{
  *pshared = PTHREAD_PROCESS_PRIVATE;
  return 0;
}
versioned_symbol ( libpthread  ,
__pthread_cond_init  ,
pthread_cond_init  ,
GLIBC_2_3_2   
)
versioned_symbol ( libpthread  ,
__pthread_cond_destroy  ,
pthread_cond_destroy  ,
GLIBC_2_3_2   
)
versioned_symbol ( libpthread  ,
__pthread_cond_wait  ,
pthread_cond_wait  ,
GLIBC_2_3_2   
)
versioned_symbol ( libpthread  ,
__pthread_cond_timedwait  ,
pthread_cond_timedwait  ,
GLIBC_2_3_2   
)
versioned_symbol ( libpthread  ,
__pthread_cond_signal  ,
pthread_cond_signal  ,
GLIBC_2_3_2   
)
versioned_symbol ( libpthread  ,
__pthread_cond_broadcast  ,
pthread_cond_broadcast  ,
GLIBC_2_3_2   
)