2007-05-29 18:15:48 +02:00
|
|
|
/* Copyright (C) 2003, 2004, 2006, 2007 Free Software Foundation, Inc.
|
2003-02-05 10:54:24 +01:00
|
|
|
This file is part of the GNU C Library.
|
|
|
|
Contributed by Martin Schwidefsky <schwidefsky@de.ibm.com>, 2003.
|
|
|
|
|
|
|
|
The GNU C Library is free software; you can redistribute it and/or
|
|
|
|
modify it under the terms of the GNU Lesser General Public
|
|
|
|
License as published by the Free Software Foundation; either
|
|
|
|
version 2.1 of the License, or (at your option) any later version.
|
|
|
|
|
|
|
|
The GNU C Library 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
|
|
|
|
Lesser General Public License for more details.
|
|
|
|
|
|
|
|
You should have received a copy of the GNU Lesser General Public
|
|
|
|
License along with the GNU C Library; if not, write to the Free
|
|
|
|
Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
|
|
|
|
02111-1307 USA. */
|
|
|
|
|
|
|
|
#include <endian.h>
|
|
|
|
#include <errno.h>
|
|
|
|
#include <sysdep.h>
|
|
|
|
#include <lowlevellock.h>
|
|
|
|
#include <pthread.h>
|
|
|
|
#include <pthreadP.h>
|
|
|
|
|
|
|
|
#include <shlib-compat.h>
|
|
|
|
|
|
|
|
|
2003-03-03 22:11:12 +01:00
|
|
|
struct _condvar_cleanup_buffer
|
|
|
|
{
|
|
|
|
int oldtype;
|
|
|
|
pthread_cond_t *cond;
|
|
|
|
pthread_mutex_t *mutex;
|
2004-05-18 22:18:14 +02:00
|
|
|
unsigned int bc_seq;
|
2003-03-03 22:11:12 +01:00
|
|
|
};
|
|
|
|
|
2003-03-11 23:02:29 +01:00
|
|
|
|
2003-02-05 10:54:24 +01:00
|
|
|
void
|
|
|
|
__attribute__ ((visibility ("hidden")))
|
|
|
|
__condvar_cleanup (void *arg)
|
|
|
|
{
|
2003-03-03 22:11:12 +01:00
|
|
|
struct _condvar_cleanup_buffer *cbuffer =
|
|
|
|
(struct _condvar_cleanup_buffer *) arg;
|
2004-09-02 20:59:24 +02:00
|
|
|
unsigned int destroying;
|
2003-02-05 10:54:24 +01:00
|
|
|
|
|
|
|
/* We are going to modify shared data. */
|
2003-03-03 22:11:12 +01:00
|
|
|
lll_mutex_lock (cbuffer->cond->__data.__lock);
|
2003-02-05 10:54:24 +01:00
|
|
|
|
2004-05-18 22:18:14 +02:00
|
|
|
if (cbuffer->bc_seq == cbuffer->cond->__data.__broadcast_seq)
|
|
|
|
{
|
|
|
|
/* This thread is not waiting anymore. Adjust the sequence counters
|
2006-09-08 12:41:17 +02:00
|
|
|
appropriately. We do not increment WAKEUP_SEQ if this would
|
2006-09-09 13:21:48 +02:00
|
|
|
bump it over the value of TOTAL_SEQ. This can happen if a thread
|
2006-09-08 12:41:17 +02:00
|
|
|
was woken and then canceled. */
|
|
|
|
if (cbuffer->cond->__data.__wakeup_seq
|
|
|
|
< cbuffer->cond->__data.__total_seq)
|
2006-09-09 13:21:48 +02:00
|
|
|
{
|
|
|
|
++cbuffer->cond->__data.__wakeup_seq;
|
|
|
|
++cbuffer->cond->__data.__futex;
|
|
|
|
}
|
2004-05-18 22:18:14 +02:00
|
|
|
++cbuffer->cond->__data.__woken_seq;
|
|
|
|
}
|
2003-02-05 10:54:24 +01:00
|
|
|
|
2007-05-29 18:15:48 +02:00
|
|
|
cbuffer->cond->__data.__nwaiters -= 1 << COND_NWAITERS_SHIFT;
|
2004-09-02 20:59:24 +02:00
|
|
|
|
|
|
|
/* If pthread_cond_destroy was called on this variable already,
|
|
|
|
notify the pthread_cond_destroy caller all waiters have left
|
|
|
|
and it can be successfully destroyed. */
|
|
|
|
destroying = 0;
|
|
|
|
if (cbuffer->cond->__data.__total_seq == -1ULL
|
2007-05-29 18:15:48 +02:00
|
|
|
&& cbuffer->cond->__data.__nwaiters < (1 << COND_NWAITERS_SHIFT))
|
2004-09-02 20:59:24 +02:00
|
|
|
{
|
2007-06-08 04:50:59 +02:00
|
|
|
lll_futex_wake (&cbuffer->cond->__data.__nwaiters, 1,
|
|
|
|
// XYZ check mutex flag
|
|
|
|
LLL_SHARED);
|
2004-09-02 20:59:24 +02:00
|
|
|
destroying = 1;
|
|
|
|
}
|
|
|
|
|
2003-03-18 19:56:16 +01:00
|
|
|
/* We are done. */
|
|
|
|
lll_mutex_unlock (cbuffer->cond->__data.__lock);
|
|
|
|
|
2003-03-11 23:02:29 +01:00
|
|
|
/* Wake everybody to make sure no condvar signal gets lost. */
|
2004-09-02 20:59:24 +02:00
|
|
|
if (! destroying)
|
2007-06-08 04:50:59 +02:00
|
|
|
lll_futex_wake (&cbuffer->cond->__data.__futex, INT_MAX,
|
|
|
|
// XYZ check mutex flag
|
|
|
|
LLL_SHARED);
|
2003-03-11 23:02:29 +01:00
|
|
|
|
2003-03-03 22:11:12 +01:00
|
|
|
/* Get the mutex before returning unless asynchronous cancellation
|
|
|
|
is in effect. */
|
2003-05-26 04:47:39 +02:00
|
|
|
__pthread_mutex_cond_lock (cbuffer->mutex);
|
2003-02-05 10:54:24 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
int
|
|
|
|
__pthread_cond_wait (cond, mutex)
|
|
|
|
pthread_cond_t *cond;
|
|
|
|
pthread_mutex_t *mutex;
|
|
|
|
{
|
|
|
|
struct _pthread_cleanup_buffer buffer;
|
2003-03-03 22:11:12 +01:00
|
|
|
struct _condvar_cleanup_buffer cbuffer;
|
|
|
|
int err;
|
2003-02-05 10:54:24 +01:00
|
|
|
|
|
|
|
/* Make sure we are along. */
|
|
|
|
lll_mutex_lock (cond->__data.__lock);
|
|
|
|
|
|
|
|
/* Now we can release the mutex. */
|
2003-06-23 01:55:27 +02:00
|
|
|
err = __pthread_mutex_unlock_usercnt (mutex, 0);
|
2004-02-14 08:33:05 +01:00
|
|
|
if (__builtin_expect (err, 0))
|
2003-03-03 22:11:12 +01:00
|
|
|
{
|
|
|
|
lll_mutex_unlock (cond->__data.__lock);
|
|
|
|
return err;
|
|
|
|
}
|
2003-02-05 10:54:24 +01:00
|
|
|
|
|
|
|
/* We have one new user of the condvar. */
|
|
|
|
++cond->__data.__total_seq;
|
2004-06-03 18:04:11 +02:00
|
|
|
++cond->__data.__futex;
|
2007-05-29 18:15:48 +02:00
|
|
|
cond->__data.__nwaiters += 1 << COND_NWAITERS_SHIFT;
|
2003-02-05 10:54:24 +01:00
|
|
|
|
2003-05-26 04:47:39 +02:00
|
|
|
/* Remember the mutex we are using here. If there is already a
|
2003-11-21 11:00:11 +01:00
|
|
|
different address store this is a bad user bug. Do not store
|
|
|
|
anything for pshared condvars. */
|
|
|
|
if (cond->__data.__mutex != (void *) ~0l)
|
|
|
|
cond->__data.__mutex = mutex;
|
2003-05-26 04:47:39 +02:00
|
|
|
|
2003-03-03 22:11:12 +01:00
|
|
|
/* Prepare structure passed to cancellation handler. */
|
|
|
|
cbuffer.cond = cond;
|
|
|
|
cbuffer.mutex = mutex;
|
|
|
|
|
2003-02-05 10:54:24 +01:00
|
|
|
/* Before we block we enable cancellation. Therefore we have to
|
|
|
|
install a cancellation handler. */
|
2003-03-03 22:11:12 +01:00
|
|
|
__pthread_cleanup_push (&buffer, __condvar_cleanup, &cbuffer);
|
2003-02-05 10:54:24 +01:00
|
|
|
|
|
|
|
/* The current values of the wakeup counter. The "woken" counter
|
|
|
|
must exceed this value. */
|
|
|
|
unsigned long long int val;
|
|
|
|
unsigned long long int seq;
|
|
|
|
val = seq = cond->__data.__wakeup_seq;
|
2004-05-18 22:18:14 +02:00
|
|
|
/* Remember the broadcast counter. */
|
|
|
|
cbuffer.bc_seq = cond->__data.__broadcast_seq;
|
2003-02-05 10:54:24 +01:00
|
|
|
|
2003-03-17 11:11:31 +01:00
|
|
|
do
|
2003-02-05 10:54:24 +01:00
|
|
|
{
|
2004-06-03 18:04:11 +02:00
|
|
|
unsigned int futex_val = cond->__data.__futex;
|
|
|
|
|
2003-02-05 10:54:24 +01:00
|
|
|
/* Prepare to wait. Release the condvar futex. */
|
|
|
|
lll_mutex_unlock (cond->__data.__lock);
|
|
|
|
|
|
|
|
/* Enable asynchronous cancellation. Required by the standard. */
|
2003-05-26 04:47:39 +02:00
|
|
|
cbuffer.oldtype = __pthread_enable_asynccancel ();
|
2003-02-05 10:54:24 +01:00
|
|
|
|
2004-06-03 18:04:11 +02:00
|
|
|
/* Wait until woken by signal or broadcast. */
|
2007-06-08 04:50:59 +02:00
|
|
|
lll_futex_wait (&cond->__data.__futex, futex_val,
|
|
|
|
// XYZ check mutex flag
|
|
|
|
LLL_SHARED);
|
2003-02-05 10:54:24 +01:00
|
|
|
|
|
|
|
/* Disable asynchronous cancellation. */
|
2003-03-03 22:11:12 +01:00
|
|
|
__pthread_disable_asynccancel (cbuffer.oldtype);
|
2003-02-05 10:54:24 +01:00
|
|
|
|
2004-05-21 18:19:16 +02:00
|
|
|
/* We are going to look at shared data again, so get the lock. */
|
|
|
|
lll_mutex_lock (cond->__data.__lock);
|
|
|
|
|
2004-05-18 22:18:14 +02:00
|
|
|
/* If a broadcast happened, we are done. */
|
|
|
|
if (cbuffer.bc_seq != cond->__data.__broadcast_seq)
|
|
|
|
goto bc_out;
|
|
|
|
|
2003-02-05 10:54:24 +01:00
|
|
|
/* Check whether we are eligible for wakeup. */
|
|
|
|
val = cond->__data.__wakeup_seq;
|
|
|
|
}
|
2004-03-01 09:47:37 +01:00
|
|
|
while (val == seq || cond->__data.__woken_seq == val);
|
2003-02-05 10:54:24 +01:00
|
|
|
|
|
|
|
/* Another thread woken up. */
|
|
|
|
++cond->__data.__woken_seq;
|
|
|
|
|
2004-05-18 22:18:14 +02:00
|
|
|
bc_out:
|
2004-09-02 20:59:24 +02:00
|
|
|
|
2007-05-29 18:15:48 +02:00
|
|
|
cond->__data.__nwaiters -= 1 << COND_NWAITERS_SHIFT;
|
2004-09-02 20:59:24 +02:00
|
|
|
|
|
|
|
/* If pthread_cond_destroy was called on this varaible already,
|
|
|
|
notify the pthread_cond_destroy caller all waiters have left
|
|
|
|
and it can be successfully destroyed. */
|
|
|
|
if (cond->__data.__total_seq == -1ULL
|
2007-05-29 18:15:48 +02:00
|
|
|
&& cond->__data.__nwaiters < (1 << COND_NWAITERS_SHIFT))
|
2007-06-08 04:50:59 +02:00
|
|
|
lll_futex_wake (&cond->__data.__nwaiters, 1,
|
|
|
|
// XYZ check mutex flag
|
|
|
|
LLL_SHARED);
|
2004-09-02 20:59:24 +02:00
|
|
|
|
2003-02-05 10:54:24 +01:00
|
|
|
/* We are done with the condvar. */
|
|
|
|
lll_mutex_unlock (cond->__data.__lock);
|
|
|
|
|
|
|
|
/* The cancellation handling is back to normal, remove the handler. */
|
|
|
|
__pthread_cleanup_pop (&buffer, 0);
|
|
|
|
|
|
|
|
/* Get the mutex before returning. */
|
2003-05-26 04:47:39 +02:00
|
|
|
return __pthread_mutex_cond_lock (mutex);
|
2003-02-05 10:54:24 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
versioned_symbol (libpthread, __pthread_cond_wait, pthread_cond_wait,
|
|
|
|
GLIBC_2_3_2);
|