/* 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"
static void remove_from_queue(pthread_queue * q, pthread_descr th);
int pthread_cond_init(pthread_cond_t *cond,
const pthread_condattr_t *cond_attr)
{
cond->c_spinlock = 0;
queue_init(&cond->c_waiting);
return 0;
}
int pthread_cond_destroy(pthread_cond_t *cond)
{
pthread_descr head;
acquire(&cond->c_spinlock);
head = cond->c_waiting.head;
release(&cond->c_spinlock);
if (head != NULL) return EBUSY;
return 0;
}
int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex)
{
volatile pthread_descr self = thread_self();
acquire(&cond->c_spinlock);
enqueue(&cond->c_waiting, self);
release(&cond->c_spinlock);
pthread_mutex_unlock(mutex);
suspend_with_cancellation(self);
pthread_mutex_lock(mutex);
/* This is a cancellation point */
if (self->p_canceled && self->p_cancelstate == PTHREAD_CANCEL_ENABLE) {
/* Remove ourselves from the waiting queue if we're still on it */
acquire(&cond->c_spinlock);
remove_from_queue(&cond->c_waiting, self);
release(&cond->c_spinlock);
pthread_exit(PTHREAD_CANCELED);
}
return 0;
}
static inline int
pthread_cond_timedwait_relative(pthread_cond_t *cond,
pthread_mutex_t *mutex,
const struct timespec * reltime)
{
volatile pthread_descr self = thread_self();
sigset_t unblock, initial_mask;
int retsleep;
sigjmp_buf jmpbuf;
/* Wait on the condition */
acquire(&cond->c_spinlock);
enqueue(&cond->c_waiting, self);
release(&cond->c_spinlock);
pthread_mutex_unlock(mutex);
/* Set up a longjmp handler for the restart signal */
/* No need to save the signal mask, since PTHREAD_SIG_RESTART will be
blocked when doing the siglongjmp, and we'll just leave it blocked. */
if (sigsetjmp(jmpbuf, 0) == 0) {
self->p_signal_jmp = &jmpbuf;
self->p_signal = 0;
/* Check for cancellation */
if (self->p_canceled && self->p_cancelstate == PTHREAD_CANCEL_ENABLE) {
retsleep = -1;
} else {
/* Unblock the restart signal */
sigemptyset(&unblock);
sigaddset(&unblock, PTHREAD_SIG_RESTART);
sigprocmask(SIG_UNBLOCK, &unblock, &initial_mask);
/* Sleep for the required duration */
retsleep = __libc_nanosleep(reltime, NULL);
/* Block the restart signal again */
sigprocmask(SIG_SETMASK, &initial_mask, NULL);
}
} else {
retsleep = -1;
}
self->p_signal_jmp = NULL;
/* Here, either the condition was signaled (self->p_signal != 0)
or we got canceled (self->p_canceled != 0)
or the timeout occurred (retsleep == 0)
or another interrupt occurred (retsleep == -1) */
/* Re-acquire the spinlock */
acquire(&cond->c_spinlock);
/* This is a cancellation point */
if (self->p_canceled && self->p_cancelstate == PTHREAD_CANCEL_ENABLE) {
remove_from_queue(&cond->c_waiting, self);
release(&cond->c_spinlock);
pthread_mutex_lock(mutex);
pthread_exit(PTHREAD_CANCELED);
}
/* If not signaled: also remove ourselves and return an error code */
if (self->p_signal == 0) {
remove_from_queue(&cond->c_waiting, self);
release(&cond->c_spinlock);
pthread_mutex_lock(mutex);
return retsleep == 0 ? ETIMEDOUT : EINTR;
}
/* Otherwise, return normally */
release(&cond->c_spinlock);
pthread_mutex_lock(mutex);
return 0;
}
int pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex,
const struct timespec * abstime)
{
struct timeval now;
struct timespec reltime;
/* Compute a time offset relative to now */
__gettimeofday(&now, NULL);
reltime.tv_sec = abstime->tv_sec - now.tv_sec;
reltime.tv_nsec = abstime->tv_nsec - now.tv_usec * 1000;
if (reltime.tv_nsec < 0) {
reltime.tv_nsec += 1000000000;
reltime.tv_sec -= 1;
}
if (reltime.tv_sec < 0) return ETIMEDOUT;
return pthread_cond_timedwait_relative(cond, mutex, &reltime);
}
int pthread_cond_signal(pthread_cond_t *cond)
{
pthread_descr th;
acquire(&cond->c_spinlock);
th = dequeue(&cond->c_waiting);
release(&cond->c_spinlock);
if (th != NULL) restart(th);
return 0;
}
int pthread_cond_broadcast(pthread_cond_t *cond)
{
pthread_queue tosignal;
pthread_descr th;
acquire(&cond->c_spinlock);
/* Copy the current state of the waiting queue and empty it */
tosignal = cond->c_waiting;
queue_init(&cond->c_waiting);
release(&cond->c_spinlock);
/* Now signal each process in the queue */
while ((th = dequeue(&tosignal)) != NULL) restart(th);
return 0;
}
int pthread_condattr_init(pthread_condattr_t *attr)
{
return 0;
}
int pthread_condattr_destroy(pthread_condattr_t *attr)
{
return 0;
}
/* Auxiliary function on queues */
static void remove_from_queue(pthread_queue * q, pthread_descr th)
{
pthread_descr t;
if (q->head == NULL) return;
if (q->head == th) {
q->head = th->p_nextwaiting;
if (q->head == NULL) q->tail = NULL;
th->p_nextwaiting = NULL;
return;
}
for (t = q->head; t->p_nextwaiting != NULL; t = t->p_nextwaiting) {
if (t->p_nextwaiting == th) {
t->p_nextwaiting = th->p_nextwaiting;
if (th->p_nextwaiting == NULL) q->tail = t;
th->p_nextwaiting = NULL;
return;
}
}
}