2 * Copyright (c) 2005 David Xu <davidxu@freebsd.org>
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
8 * 1. Redistributions of source code must retain the above copyright
9 * notice unmodified, this list of conditions, and the following
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
16 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
17 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
18 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
19 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
20 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
21 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
22 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
24 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 * $DragonFly: src/lib/libthread_xu/thread/thr_cond.c,v 1.12 2008/04/15 01:45:22 dillon Exp $
29 #include "namespace.h"
30 #include <machine/tls.h>
36 #include "un-namespace.h"
38 #include "thr_private.h"
40 umtx_t _cond_static_lock;
42 int __pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex);
43 int __pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex,
44 const struct timespec *abstime);
48 static int cond_init(pthread_cond_t *cond, const pthread_condattr_t *attr);
49 static int cond_wait_common(pthread_cond_t *cond, pthread_mutex_t *mutex,
50 const struct timespec *abstime, int cancel);
51 static int cond_signal_common(pthread_cond_t *cond, int broadcast);
54 cond_init(pthread_cond_t *cond, const pthread_condattr_t *cond_attr)
59 if ((pcond = (pthread_cond_t)
60 malloc(sizeof(struct pthread_cond))) == NULL) {
64 * Initialise the condition variable structure:
66 _thr_umtx_init(&pcond->c_lock);
69 pcond->c_broadcast = 0;
70 if (cond_attr == NULL || *cond_attr == NULL) {
72 pcond->c_clockid = CLOCK_REALTIME;
74 pcond->c_pshared = (*cond_attr)->c_pshared;
75 pcond->c_clockid = (*cond_attr)->c_clockid;
79 /* Return the completion status: */
84 init_static(struct pthread *thread, pthread_cond_t *cond)
88 THR_LOCK_ACQUIRE(thread, &_cond_static_lock);
91 ret = cond_init(cond, NULL);
95 THR_LOCK_RELEASE(thread, &_cond_static_lock);
101 _pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *cond_attr)
104 return cond_init(cond, cond_attr);
108 _pthread_cond_destroy(pthread_cond_t *cond)
110 struct pthread_cond *cv;
111 struct pthread *curthread = tls_get_curthread();
117 /* Lock the condition variable structure: */
118 THR_LOCK_ACQUIRE(curthread, &(*cond)->c_lock);
119 if ((*cond)->c_waiters != 0) {
120 THR_LOCK_RELEASE(curthread, &(*cond)->c_lock);
125 * NULL the caller's pointer now that the condition
126 * variable has been destroyed:
131 /* Unlock the condition variable structure: */
132 THR_LOCK_RELEASE(curthread, &cv->c_lock);
134 /* Free the cond lock structure: */
137 * Free the memory allocated for the condition
138 * variable structure:
143 /* Return the completion status: */
147 struct cond_cancel_info
149 pthread_mutex_t *mutex;
150 pthread_cond_t *cond;
156 cond_cancel_handler(void *arg)
158 struct pthread *curthread = tls_get_curthread();
159 struct cond_cancel_info *info = (struct cond_cancel_info *)arg;
163 THR_LOCK_ACQUIRE(curthread, &cv->c_lock);
164 if (--cv->c_waiters == 0)
166 if (cv->c_seqno != info->seqno) {
167 _thr_umtx_wake(&cv->c_seqno, 1);
168 /* cv->c_seqno++; XXX why was this here? */
169 _thr_umtx_wake(&cv->c_seqno, 1);
171 THR_LOCK_RELEASE(curthread, &cv->c_lock);
173 _mutex_cv_lock(info->mutex, info->count);
177 cond_wait_common(pthread_cond_t *cond, pthread_mutex_t *mutex,
178 const struct timespec *abstime, int cancel)
180 struct pthread *curthread = tls_get_curthread();
181 struct timespec ts, ts2, *tsp;
182 struct cond_cancel_info info;
189 * If the condition variable is statically initialized,
190 * perform the dynamic initialization:
192 if (__predict_false(*cond == NULL &&
193 (ret = init_static(curthread, cond)) != 0))
197 /* fprintf(stderr, "waiton1 %p\n", cv);*/
198 THR_LOCK_ACQUIRE(curthread, &cv->c_lock);
199 oldseq = cv->c_seqno;
200 /* fprintf(stderr, "waiton2 %p %d\n", cv, oldseq);*/
201 ret = _mutex_cv_unlock(mutex, &info.count);
203 THR_LOCK_RELEASE(curthread, &cv->c_lock);
214 * loop if we have never been told to wake up
217 while (seq == oldseq /* || cv->c_wakeups == 0*/) {
218 THR_LOCK_RELEASE(curthread, &cv->c_lock);
220 if (abstime != NULL) {
221 clock_gettime(cv->c_clockid, &ts);
222 TIMESPEC_SUB(&ts2, abstime, &ts);
228 THR_CLEANUP_PUSH(curthread, cond_cancel_handler, &info);
229 oldcancel = _thr_cancel_enter(curthread);
230 ret = _thr_umtx_wait(&cv->c_seqno, seq, tsp,
232 _thr_cancel_leave(curthread, oldcancel);
233 THR_CLEANUP_POP(curthread, 0);
235 ret = _thr_umtx_wait(&cv->c_seqno, seq, tsp,
239 THR_LOCK_ACQUIRE(curthread, &cv->c_lock);
241 if (abstime != NULL && ret == ETIMEDOUT)
244 if (--cv->c_waiters == 0)
248 THR_LOCK_RELEASE(curthread, &cv->c_lock);
249 _mutex_cv_lock(mutex, info.count);
254 _pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex)
257 return (cond_wait_common(cond, mutex, NULL, 0));
261 __pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex)
264 return (cond_wait_common(cond, mutex, NULL, 1));
268 _pthread_cond_timedwait(pthread_cond_t * cond, pthread_mutex_t * mutex,
269 const struct timespec * abstime)
271 if (abstime == NULL || abstime->tv_sec < 0 || abstime->tv_nsec < 0 ||
272 abstime->tv_nsec >= 1000000000)
275 return (cond_wait_common(cond, mutex, abstime, 0));
279 __pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex,
280 const struct timespec *abstime)
282 if (abstime == NULL || abstime->tv_sec < 0 || abstime->tv_nsec < 0 ||
283 abstime->tv_nsec >= 1000000000)
286 return (cond_wait_common(cond, mutex, abstime, 1));
290 cond_signal_common(pthread_cond_t *cond, int broadcast)
292 struct pthread *curthread = tls_get_curthread();
297 * If the condition variable is statically initialized, perform dynamic
300 if (__predict_false(*cond == NULL &&
301 (ret = init_static(curthread, cond)) != 0))
305 /* fprintf(stderr, "signal %p\n", cv);*/
306 /* Lock the condition variable structure. */
307 THR_LOCK_ACQUIRE(curthread, &cv->c_lock);
309 if (cv->c_broadcast == 0)
310 cv->c_broadcast = broadcast;
314 _thr_umtx_wake(&cv->c_seqno, INT_MAX);
316 _thr_umtx_wake(&cv->c_seqno, 1);
318 THR_LOCK_RELEASE(curthread, &cv->c_lock);
323 _pthread_cond_signal(pthread_cond_t * cond)
326 return (cond_signal_common(cond, 0));
330 _pthread_cond_broadcast(pthread_cond_t * cond)
333 return (cond_signal_common(cond, 1));
337 * Double underscore versions are cancellation points. Single underscore
338 * versions are not and are provided for libc internal usage (which
339 * shouldn't introduce cancellation points).
341 __strong_reference(__pthread_cond_wait, pthread_cond_wait);
342 __strong_reference(__pthread_cond_timedwait, pthread_cond_timedwait);
344 __strong_reference(_pthread_cond_init, pthread_cond_init);
345 __strong_reference(_pthread_cond_destroy, pthread_cond_destroy);
346 __strong_reference(_pthread_cond_signal, pthread_cond_signal);
347 __strong_reference(_pthread_cond_broadcast, pthread_cond_broadcast);