208 lines
6.3 KiB
C
208 lines
6.3 KiB
C
|
/* 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;
|
||
|
}
|
||
|
}
|
||
|
}
|