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.1 2005/02/01 12:38:27 davidxu Exp $
35 #include "thr_private.h"
40 static int cond_init(pthread_cond_t *cond, const pthread_condattr_t *attr);
41 static int cond_wait_common(pthread_cond_t *cond, pthread_mutex_t *mutex,
42 const struct timespec *abstime, int cancel);
43 static int cond_signal_common(pthread_cond_t *cond, int broadcast);
46 * Double underscore versions are cancellation points. Single underscore
47 * versions are not and are provided for libc internal usage (which
48 * shouldn't introduce cancellation points).
50 __weak_reference(__pthread_cond_wait, pthread_cond_wait);
51 __weak_reference(__pthread_cond_timedwait, pthread_cond_timedwait);
53 __weak_reference(_pthread_cond_init, pthread_cond_init);
54 __weak_reference(_pthread_cond_destroy, pthread_cond_destroy);
55 __weak_reference(_pthread_cond_signal, pthread_cond_signal);
56 __weak_reference(_pthread_cond_broadcast, pthread_cond_broadcast);
59 cond_init(pthread_cond_t *cond, const pthread_condattr_t *cond_attr)
64 if ((pcond = (pthread_cond_t)
65 malloc(sizeof(struct pthread_cond))) == NULL) {
69 * Initialise the condition variable structure:
71 _thr_umtx_init(&pcond->c_lock);
75 if (cond_attr == NULL || *cond_attr == NULL) {
77 pcond->c_clockid = CLOCK_REALTIME;
79 pcond->c_pshared = (*cond_attr)->c_pshared;
80 pcond->c_clockid = (*cond_attr)->c_clockid;
84 /* Return the completion status: */
89 init_static(struct pthread *thread, pthread_cond_t *cond)
93 THR_LOCK_ACQUIRE(thread, &_cond_static_lock);
96 ret = cond_init(cond, NULL);
100 THR_LOCK_RELEASE(thread, &_cond_static_lock);
106 _pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *cond_attr)
109 return cond_init(cond, cond_attr);
113 _pthread_cond_destroy(pthread_cond_t *cond)
115 struct pthread_cond *cv;
116 struct pthread *curthread = _get_curthread();
122 /* Lock the condition variable structure: */
123 THR_LOCK_ACQUIRE(curthread, &(*cond)->c_lock);
124 if ((*cond)->c_waiters + (*cond)->c_wakeups != 0) {
125 THR_LOCK_RELEASE(curthread, &(*cond)->c_lock);
130 * NULL the caller's pointer now that the condition
131 * variable has been destroyed:
136 /* Unlock the condition variable structure: */
137 THR_LOCK_RELEASE(curthread, &cv->c_lock);
139 /* Free the cond lock structure: */
142 * Free the memory allocated for the condition
143 * variable structure:
148 /* Return the completion status: */
152 struct cond_cancel_info
154 pthread_mutex_t *mutex;
155 pthread_cond_t *cond;
160 cond_cancel_handler(void *arg)
162 struct pthread *curthread = _get_curthread();
163 struct cond_cancel_info *cci = (struct cond_cancel_info *)arg;
167 THR_LOCK_ACQUIRE(curthread, &cv->c_lock);
168 if (cv->c_seqno != cci->seqno && cv->c_wakeups != 0) {
169 if (cv->c_waiters > 0) {
171 _thr_umtx_wake(&cv->c_seqno, 1);
177 THR_LOCK_RELEASE(curthread, &cv->c_lock);
179 _mutex_cv_lock(cci->mutex);
183 cond_wait_common(pthread_cond_t *cond, pthread_mutex_t *mutex,
184 const struct timespec *abstime, int cancel)
186 struct pthread *curthread = _get_curthread();
187 struct timespec ts, ts2, *tsp;
188 struct cond_cancel_info cci;
195 * If the condition variable is statically initialized,
196 * perform the dynamic initialization:
198 if (__predict_false(*cond == NULL &&
199 (ret = init_static(curthread, cond)) != 0))
203 THR_LOCK_ACQUIRE(curthread, &cv->c_lock);
204 ret = _mutex_cv_unlock(mutex);
206 THR_LOCK_RELEASE(curthread, &cv->c_lock);
209 oldseq = seq = cv->c_seqno;
216 THR_LOCK_RELEASE(curthread, &cv->c_lock);
218 if (abstime != NULL) {
219 clock_gettime(cv->c_clockid, &ts);
220 TIMESPEC_SUB(&ts2, abstime, &ts);
226 THR_CLEANUP_PUSH(curthread, cond_cancel_handler, &cci);
227 oldcancel = _thr_cancel_enter(curthread);
228 ret = _thr_umtx_wait(&cv->c_seqno, seq, tsp);
229 _thr_cancel_leave(curthread, oldcancel);
230 THR_CLEANUP_POP(curthread, 0);
232 ret = _thr_umtx_wait(&cv->c_seqno, seq, tsp);
235 THR_LOCK_ACQUIRE(curthread, &cv->c_lock);
237 if (abstime != NULL && ret == ETIMEDOUT)
241 * loop if we have never been told to wake up
244 } while (seq == oldseq || cv->c_wakeups == 0);
246 if (seq != oldseq && cv->c_wakeups != 0) {
252 THR_LOCK_RELEASE(curthread, &cv->c_lock);
253 _mutex_cv_lock(mutex);
258 _pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex)
260 return cond_wait_common(cond, mutex, NULL, 0);
263 __strong_reference(_pthread_cond_wait, _thr_cond_wait);
266 __pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex)
270 ret = cond_wait_common(cond, mutex, NULL, 1);
275 _pthread_cond_timedwait(pthread_cond_t * cond, pthread_mutex_t * mutex,
276 const struct timespec * abstime)
278 if (abstime == NULL || abstime->tv_sec < 0 || abstime->tv_nsec < 0 ||
279 abstime->tv_nsec >= 1000000000)
282 return cond_wait_common(cond, mutex, abstime, 0);
285 __strong_reference(_pthread_cond_timedwait, _thr_cond_timedwait);
288 __pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex,
289 const struct timespec *abstime)
291 if (abstime == NULL || abstime->tv_sec < 0 || abstime->tv_nsec < 0 ||
292 abstime->tv_nsec >= 1000000000)
295 return cond_wait_common(cond, mutex, abstime, 1);
299 cond_signal_common(pthread_cond_t *cond, int broadcast)
301 struct pthread *curthread = _get_curthread();
306 * If the condition variable is statically initialized, perform dynamic
309 if (__predict_false(*cond == NULL &&
310 (ret = init_static(curthread, cond)) != 0))
314 /* Lock the condition variable structure. */
315 THR_LOCK_ACQUIRE(curthread, &cv->c_lock);
321 _thr_umtx_wake(&cv->c_seqno, 1);
323 cv->c_wakeups += cv->c_waiters;
326 _thr_umtx_wake(&cv->c_seqno, INT_MAX);
329 THR_LOCK_RELEASE(curthread, &cv->c_lock);
334 _pthread_cond_signal(pthread_cond_t * cond)
336 return cond_signal_common(cond, 0);
339 __strong_reference(_pthread_cond_signal, _thr_cond_signal);
342 _pthread_cond_broadcast(pthread_cond_t * cond)
344 return cond_signal_common(cond, 1);
347 __strong_reference(_pthread_cond_broadcast, _thr_cond_broadcast);