1/*
2 * Copyright (c) 1995 John Birrell <jb@cimlogic.com.au>.
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 * 3. All advertising materials mentioning features or use of this software
14 * must display the following acknowledgement:
15 * This product includes software developed by John Birrell.
16 * 4. Neither the name of the author nor the names of any co-contributors
17 * may be used to endorse or promote products derived from this software
18 * without specific prior written permission.
19 *
20 * THIS SOFTWARE IS PROVIDED BY JOHN BIRRELL AND CONTRIBUTORS ``AS IS'' AND
21 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
24 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
30 * SUCH DAMAGE.
31 *
| 1/*
2 * Copyright (c) 1995 John Birrell <jb@cimlogic.com.au>.
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 * 3. All advertising materials mentioning features or use of this software
14 * must display the following acknowledgement:
15 * This product includes software developed by John Birrell.
16 * 4. Neither the name of the author nor the names of any co-contributors
17 * may be used to endorse or promote products derived from this software
18 * without specific prior written permission.
19 *
20 * THIS SOFTWARE IS PROVIDED BY JOHN BIRRELL AND CONTRIBUTORS ``AS IS'' AND
21 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
24 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
30 * SUCH DAMAGE.
31 *
|
106 free(pcond);
107 rval = ENOMEM;
108 } else {
109 /*
110 * Initialise the condition variable
111 * structure:
112 */
113 TAILQ_INIT(&pcond->c_queue);
114 pcond->c_flags |= COND_FLAGS_INITED;
115 pcond->c_type = type;
116 pcond->c_mutex = NULL;
117 pcond->c_seqno = 0;
118 *cond = pcond;
119 }
120 }
121 }
122 /* Return the completion status: */
123 return (rval);
124}
125
126int
127_pthread_cond_destroy(pthread_cond_t *cond)
128{
129 struct pthread_cond *cv;
130 struct pthread *curthread = _get_curthread();
131 int rval = 0;
132
133 if (cond == NULL || *cond == NULL)
134 rval = EINVAL;
135 else {
136 /* Lock the condition variable structure: */
137 THR_LOCK_ACQUIRE(curthread, &(*cond)->c_lock);
138
139 /*
140 * NULL the caller's pointer now that the condition
141 * variable has been destroyed:
142 */
143 cv = *cond;
144 *cond = NULL;
145
146 /* Unlock the condition variable structure: */
147 THR_LOCK_RELEASE(curthread, &cv->c_lock);
148
149 /*
150 * Free the memory allocated for the condition
151 * variable structure:
152 */
153 free(cv);
154
155 }
156 /* Return the completion status: */
157 return (rval);
158}
159
160int
161_pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex)
162{
163 struct pthread *curthread = _get_curthread();
164 int rval = 0;
165 int done = 0;
166 int interrupted = 0;
167 int unlock_mutex = 1;
168 int seqno;
169
170 _thr_enter_cancellation_point(curthread);
171
172 if (cond == NULL) {
173 _thr_leave_cancellation_point(curthread);
174 return (EINVAL);
175 }
176
177 /*
178 * If the condition variable is statically initialized,
179 * perform the dynamic initialization:
180 */
181 if (*cond == NULL &&
182 (rval = pthread_cond_init(cond, NULL)) != 0) {
183 _thr_leave_cancellation_point(curthread);
184 return (rval);
185 }
186
187 /*
188 * Enter a loop waiting for a condition signal or broadcast
189 * to wake up this thread. A loop is needed in case the waiting
190 * thread is interrupted by a signal to execute a signal handler.
191 * It is not (currently) possible to remain in the waiting queue
192 * while running a handler. Instead, the thread is interrupted
193 * and backed out of the waiting queue prior to executing the
194 * signal handler.
195 */
196 do {
197 /* Lock the condition variable structure: */
198 THR_LOCK_ACQUIRE(curthread, &(*cond)->c_lock);
199
200 /*
201 * If the condvar was statically allocated, properly
202 * initialize the tail queue.
203 */
204 if (((*cond)->c_flags & COND_FLAGS_INITED) == 0) {
205 TAILQ_INIT(&(*cond)->c_queue);
206 (*cond)->c_flags |= COND_FLAGS_INITED;
207 }
208
209 /* Process according to condition variable type: */
210 switch ((*cond)->c_type) {
211 /* Fast condition variable: */
212 case COND_TYPE_FAST:
213 if ((mutex == NULL) || (((*cond)->c_mutex != NULL) &&
214 ((*cond)->c_mutex != *mutex))) {
215 /* Unlock the condition variable structure: */
216 THR_LOCK_RELEASE(curthread, &(*cond)->c_lock);
217
218 /* Return invalid argument error: */
219 rval = EINVAL;
220 } else {
221 /* Reset the timeout and interrupted flags: */
222 curthread->timeout = 0;
223 curthread->interrupted = 0;
224
225 /*
226 * Queue the running thread for the condition
227 * variable:
228 */
229 cond_queue_enq(*cond, curthread);
230
231 /* Remember the mutex and sequence number: */
232 (*cond)->c_mutex = *mutex;
233 seqno = (*cond)->c_seqno;
234
235 /* Wait forever: */
236 curthread->wakeup_time.tv_sec = -1;
237
238 /* Unlock the mutex: */
239 if ((unlock_mutex != 0) &&
240 ((rval = _mutex_cv_unlock(mutex)) != 0)) {
241 /*
242 * Cannot unlock the mutex, so remove
243 * the running thread from the condition
244 * variable queue:
245 */
246 cond_queue_remove(*cond, curthread);
247
248 /* Check for no more waiters: */
249 if (TAILQ_FIRST(&(*cond)->c_queue) == NULL)
250 (*cond)->c_mutex = NULL;
251
252 /* Unlock the condition variable structure: */
253 THR_LOCK_RELEASE(curthread, &(*cond)->c_lock);
254 }
255 else {
256 /*
257 * Don't unlock the mutex the next
258 * time through the loop (if the
259 * thread has to be requeued after
260 * handling a signal).
261 */
262 unlock_mutex = 0;
263
264 /*
265 * This thread is active and is in a
266 * critical region (holding the cv
267 * lock); we should be able to safely
268 * set the state.
269 */
270 THR_SET_STATE(curthread, PS_COND_WAIT);
271
272 /* Remember the CV: */
273 curthread->data.cond = *cond;
274
275 /* Unlock the CV structure: */
276 THR_LOCK_RELEASE(curthread,
277 &(*cond)->c_lock);
278
279 /* Schedule the next thread: */
280 _thr_sched_switch(curthread);
281
282 curthread->data.cond = NULL;
283
284 /*
285 * XXX - This really isn't a good check
286 * since there can be more than one
287 * thread waiting on the CV. Signals
288 * sent to threads waiting on mutexes
289 * or CVs should really be deferred
290 * until the threads are no longer
291 * waiting, but POSIX says that signals
292 * should be sent "as soon as possible".
293 */
294 done = (seqno != (*cond)->c_seqno);
295
296 if (THR_IN_SYNCQ(curthread)) {
297 /*
298 * Lock the condition variable
299 * while removing the thread.
300 */
301 THR_LOCK_ACQUIRE(curthread,
302 &(*cond)->c_lock);
303
304 cond_queue_remove(*cond,
305 curthread);
306
307 /* Check for no more waiters: */
308 if (TAILQ_FIRST(&(*cond)->c_queue) == NULL)
309 (*cond)->c_mutex = NULL;
310
311 THR_LOCK_RELEASE(curthread,
312 &(*cond)->c_lock);
313 }
314
315 /*
316 * Save the interrupted flag; locking
317 * the mutex may destroy it.
318 */
319 interrupted = curthread->interrupted;
320
321 /*
322 * Note that even though this thread may
323 * have been canceled, POSIX requires
324 * that the mutex be reaquired prior to
325 * cancellation.
326 */
327 if (done != 0)
328 rval = _mutex_cv_lock(mutex);
329 }
330 }
331 break;
332
333 /* Trap invalid condition variable types: */
334 default:
335 /* Unlock the condition variable structure: */
336 THR_LOCK_RELEASE(curthread, &(*cond)->c_lock);
337
338 /* Return an invalid argument error: */
339 rval = EINVAL;
340 break;
341 }
342
343 if ((interrupted != 0) && (curthread->continuation != NULL))
344 curthread->continuation((void *) curthread);
345 } while ((done == 0) && (rval == 0));
346
347 _thr_leave_cancellation_point(curthread);
348
349 /* Return the completion status: */
350 return (rval);
351}
352
353int
354__pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex)
355{
356 struct pthread *curthread = _get_curthread();
357 int ret;
358
359 _thr_enter_cancellation_point(curthread);
360 ret = _pthread_cond_wait(cond, mutex);
361 _thr_leave_cancellation_point(curthread);
362 return (ret);
363}
364
365int
366_pthread_cond_timedwait(pthread_cond_t * cond, pthread_mutex_t * mutex,
367 const struct timespec * abstime)
368{
369 struct pthread *curthread = _get_curthread();
370 int rval = 0;
371 int done = 0;
372 int interrupted = 0;
373 int unlock_mutex = 1;
374 int seqno;
375
376 _thr_enter_cancellation_point(curthread);
377
378 if (abstime == NULL || abstime->tv_sec < 0 || abstime->tv_nsec < 0 ||
379 abstime->tv_nsec >= 1000000000) {
380 _thr_leave_cancellation_point(curthread);
381 return (EINVAL);
382 }
383 /*
384 * If the condition variable is statically initialized, perform dynamic
385 * initialization.
386 */
387 if (*cond == NULL && (rval = pthread_cond_init(cond, NULL)) != 0) {
388 _thr_leave_cancellation_point(curthread);
389 return (rval);
390 }
391
392 /*
393 * Enter a loop waiting for a condition signal or broadcast
394 * to wake up this thread. A loop is needed in case the waiting
395 * thread is interrupted by a signal to execute a signal handler.
396 * It is not (currently) possible to remain in the waiting queue
397 * while running a handler. Instead, the thread is interrupted
398 * and backed out of the waiting queue prior to executing the
399 * signal handler.
400 */
401 do {
402 /* Lock the condition variable structure: */
403 THR_LOCK_ACQUIRE(curthread, &(*cond)->c_lock);
404
405 /*
406 * If the condvar was statically allocated, properly
407 * initialize the tail queue.
408 */
409 if (((*cond)->c_flags & COND_FLAGS_INITED) == 0) {
410 TAILQ_INIT(&(*cond)->c_queue);
411 (*cond)->c_flags |= COND_FLAGS_INITED;
412 }
413
414 /* Process according to condition variable type: */
415 switch ((*cond)->c_type) {
416 /* Fast condition variable: */
417 case COND_TYPE_FAST:
418 if ((mutex == NULL) || (((*cond)->c_mutex != NULL) &&
419 ((*cond)->c_mutex != *mutex))) {
420 /* Return invalid argument error: */
421 rval = EINVAL;
422
423 /* Unlock the condition variable structure: */
424 THR_LOCK_RELEASE(curthread, &(*cond)->c_lock);
425 } else {
426 /* Set the wakeup time: */
427 curthread->wakeup_time.tv_sec = abstime->tv_sec;
428 curthread->wakeup_time.tv_nsec =
429 abstime->tv_nsec;
430
431 /* Reset the timeout and interrupted flags: */
432 curthread->timeout = 0;
433 curthread->interrupted = 0;
434
435 /*
436 * Queue the running thread for the condition
437 * variable:
438 */
439 cond_queue_enq(*cond, curthread);
440
441 /* Remember the mutex and sequence number: */
442 (*cond)->c_mutex = *mutex;
443 seqno = (*cond)->c_seqno;
444
445 /* Unlock the mutex: */
446 if ((unlock_mutex != 0) &&
447 ((rval = _mutex_cv_unlock(mutex)) != 0)) {
448 /*
449 * Cannot unlock the mutex; remove the
450 * running thread from the condition
451 * variable queue:
452 */
453 cond_queue_remove(*cond, curthread);
454
455 /* Check for no more waiters: */
456 if (TAILQ_FIRST(&(*cond)->c_queue) == NULL)
457 (*cond)->c_mutex = NULL;
458
459 /* Unlock the condition variable structure: */
460 THR_LOCK_RELEASE(curthread, &(*cond)->c_lock);
461 } else {
462 /*
463 * Don't unlock the mutex the next
464 * time through the loop (if the
465 * thread has to be requeued after
466 * handling a signal).
467 */
468 unlock_mutex = 0;
469
470 /*
471 * This thread is active and is in a
472 * critical region (holding the cv
473 * lock); we should be able to safely
474 * set the state.
475 */
476 THR_SET_STATE(curthread, PS_COND_WAIT);
477
478 /* Remember the CV: */
479 curthread->data.cond = *cond;
480
481 /* Unlock the CV structure: */
482 THR_LOCK_RELEASE(curthread,
483 &(*cond)->c_lock);
484
485 /* Schedule the next thread: */
486 _thr_sched_switch(curthread);
487
488 curthread->data.cond = NULL;
489
490 /*
491 * XXX - This really isn't a good check
492 * since there can be more than one
493 * thread waiting on the CV. Signals
494 * sent to threads waiting on mutexes
495 * or CVs should really be deferred
496 * until the threads are no longer
497 * waiting, but POSIX says that signals
498 * should be sent "as soon as possible".
499 */
500 done = (seqno != (*cond)->c_seqno);
501
502 if (THR_IN_CONDQ(curthread)) {
503 /*
504 * Lock the condition variable
505 * while removing the thread.
506 */
507 THR_LOCK_ACQUIRE(curthread,
508 &(*cond)->c_lock);
509
510 cond_queue_remove(*cond,
511 curthread);
512
513 /* Check for no more waiters: */
514 if (TAILQ_FIRST(&(*cond)->c_queue) == NULL)
515 (*cond)->c_mutex = NULL;
516
517 THR_LOCK_RELEASE(curthread,
518 &(*cond)->c_lock);
519 }
520
521 /*
522 * Save the interrupted flag; locking
523 * the mutex may destroy it.
524 */
525 interrupted = curthread->interrupted;
526 if (curthread->timeout != 0) {
527 /* The wait timedout. */
528 rval = ETIMEDOUT;
529 (void)_mutex_cv_lock(mutex);
530 } else if ((interrupted == 0) ||
531 (done != 0))
532 rval = _mutex_cv_lock(mutex);
533 }
534 }
535 break;
536
537 /* Trap invalid condition variable types: */
538 default:
539 /* Unlock the condition variable structure: */
540 THR_LOCK_RELEASE(curthread, &(*cond)->c_lock);
541
542 /* Return an invalid argument error: */
543 rval = EINVAL;
544 break;
545 }
546
547 if ((interrupted != 0) && (curthread->continuation != NULL))
548 curthread->continuation((void *)curthread);
549 } while ((done == 0) && (rval == 0));
550
551 _thr_leave_cancellation_point(curthread);
552
553 /* Return the completion status: */
554 return (rval);
555}
556
557int
558__pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex,
559 const struct timespec *abstime)
560{
561 struct pthread *curthread = _get_curthread();
562 int ret;
563
564 _thr_enter_cancellation_point(curthread);
565 ret = _pthread_cond_timedwait(cond, mutex, abstime);
566 _thr_leave_cancellation_point(curthread);
567 return (ret);
568}
569
570
571int
572_pthread_cond_signal(pthread_cond_t * cond)
573{
574 struct pthread *curthread = _get_curthread();
575 struct pthread *pthread;
576 int rval = 0;
577
578 if (cond == NULL)
579 rval = EINVAL;
580 /*
581 * If the condition variable is statically initialized, perform dynamic
582 * initialization.
583 */
584 else if (*cond != NULL || (rval = pthread_cond_init(cond, NULL)) == 0) {
585 /* Lock the condition variable structure: */
586 THR_LOCK_ACQUIRE(curthread, &(*cond)->c_lock);
587
588 /* Process according to condition variable type: */
589 switch ((*cond)->c_type) {
590 /* Fast condition variable: */
591 case COND_TYPE_FAST:
592 /* Increment the sequence number: */
593 (*cond)->c_seqno++;
594
595 /*
596 * Wakeups have to be done with the CV lock held;
597 * otherwise there is a race condition where the
598 * thread can timeout, run on another KSE, and enter
599 * another blocking state (including blocking on a CV).
600 */
601 if ((pthread = TAILQ_FIRST(&(*cond)->c_queue))
602 != NULL) {
603 THR_SCHED_LOCK(curthread, pthread);
604 cond_queue_remove(*cond, pthread);
605 _thr_setrunnable_unlocked(pthread);
606 THR_SCHED_UNLOCK(curthread, pthread);
607 }
608 /* Check for no more waiters: */
609 if (TAILQ_FIRST(&(*cond)->c_queue) == NULL)
610 (*cond)->c_mutex = NULL;
611 break;
612
613 /* Trap invalid condition variable types: */
614 default:
615 /* Return an invalid argument error: */
616 rval = EINVAL;
617 break;
618 }
619
620 /* Unlock the condition variable structure: */
621 THR_LOCK_RELEASE(curthread, &(*cond)->c_lock);
622 }
623
624 /* Return the completion status: */
625 return (rval);
626}
627
628int
629_pthread_cond_broadcast(pthread_cond_t * cond)
630{
631 struct pthread *curthread = _get_curthread();
632 struct pthread *pthread;
633 int rval = 0;
634
635 if (cond == NULL)
636 rval = EINVAL;
637 /*
638 * If the condition variable is statically initialized, perform dynamic
639 * initialization.
640 */
641 else if (*cond != NULL || (rval = pthread_cond_init(cond, NULL)) == 0) {
642 /* Lock the condition variable structure: */
643 THR_LOCK_ACQUIRE(curthread, &(*cond)->c_lock);
644
645 /* Process according to condition variable type: */
646 switch ((*cond)->c_type) {
647 /* Fast condition variable: */
648 case COND_TYPE_FAST:
649 /* Increment the sequence number: */
650 (*cond)->c_seqno++;
651
652 /*
653 * Enter a loop to bring all threads off the
654 * condition queue:
655 */
656 while ((pthread = TAILQ_FIRST(&(*cond)->c_queue))
657 != NULL) {
658 THR_SCHED_LOCK(curthread, pthread);
659 cond_queue_remove(*cond, pthread);
660 _thr_setrunnable_unlocked(pthread);
661 THR_SCHED_UNLOCK(curthread, pthread);
662 }
663
664 /* There are no more waiting threads: */
665 (*cond)->c_mutex = NULL;
666 break;
667
668 /* Trap invalid condition variable types: */
669 default:
670 /* Return an invalid argument error: */
671 rval = EINVAL;
672 break;
673 }
674
675 /* Unlock the condition variable structure: */
676 THR_LOCK_RELEASE(curthread, &(*cond)->c_lock);
677 }
678
679 /* Return the completion status: */
680 return (rval);
681}
682
683void
684_cond_wait_backout(struct pthread *curthread)
685{
686 pthread_cond_t cond;
687
688 cond = curthread->data.cond;
689 if (cond != NULL) {
690 /* Lock the condition variable structure: */
691 THR_LOCK_ACQUIRE(curthread, &cond->c_lock);
692
693 /* Process according to condition variable type: */
694 switch (cond->c_type) {
695 /* Fast condition variable: */
696 case COND_TYPE_FAST:
697 cond_queue_remove(cond, curthread);
698
699 /* Check for no more waiters: */
700 if (TAILQ_FIRST(&cond->c_queue) == NULL)
701 cond->c_mutex = NULL;
702 break;
703
704 default:
705 break;
706 }
707
708 /* Unlock the condition variable structure: */
709 THR_LOCK_RELEASE(curthread, &cond->c_lock);
710 }
711}
712
713/*
714 * Dequeue a waiting thread from the head of a condition queue in
715 * descending priority order.
716 */
717static inline struct pthread *
718cond_queue_deq(pthread_cond_t cond)
719{
720 struct pthread *pthread;
721
722 while ((pthread = TAILQ_FIRST(&cond->c_queue)) != NULL) {
723 TAILQ_REMOVE(&cond->c_queue, pthread, sqe);
724 THR_CONDQ_SET(pthread);
725 if ((pthread->timeout == 0) && (pthread->interrupted == 0))
726 /*
727 * Only exit the loop when we find a thread
728 * that hasn't timed out or been canceled;
729 * those threads are already running and don't
730 * need their run state changed.
731 */
732 break;
733 }
734
735 return (pthread);
736}
737
738/*
739 * Remove a waiting thread from a condition queue in descending priority
740 * order.
741 */
742static inline void
743cond_queue_remove(pthread_cond_t cond, struct pthread *pthread)
744{
745 /*
746 * Because pthread_cond_timedwait() can timeout as well
747 * as be signaled by another thread, it is necessary to
748 * guard against removing the thread from the queue if
749 * it isn't in the queue.
750 */
751 if (THR_IN_CONDQ(pthread)) {
752 TAILQ_REMOVE(&cond->c_queue, pthread, sqe);
753 THR_CONDQ_CLEAR(pthread);
754 }
755}
756
757/*
758 * Enqueue a waiting thread to a condition queue in descending priority
759 * order.
760 */
761static inline void
762cond_queue_enq(pthread_cond_t cond, struct pthread *pthread)
763{
764 struct pthread *tid = TAILQ_LAST(&cond->c_queue, cond_head);
765
766 THR_ASSERT(!THR_IN_SYNCQ(pthread),
767 "cond_queue_enq: thread already queued!");
768
769 /*
770 * For the common case of all threads having equal priority,
771 * we perform a quick check against the priority of the thread
772 * at the tail of the queue.
773 */
774 if ((tid == NULL) || (pthread->active_priority <= tid->active_priority))
775 TAILQ_INSERT_TAIL(&cond->c_queue, pthread, sqe);
776 else {
777 tid = TAILQ_FIRST(&cond->c_queue);
778 while (pthread->active_priority <= tid->active_priority)
779 tid = TAILQ_NEXT(tid, sqe);
780 TAILQ_INSERT_BEFORE(tid, pthread, sqe);
781 }
782 THR_CONDQ_SET(pthread);
783 pthread->data.cond = cond;
784}
| 106 free(pcond);
107 rval = ENOMEM;
108 } else {
109 /*
110 * Initialise the condition variable
111 * structure:
112 */
113 TAILQ_INIT(&pcond->c_queue);
114 pcond->c_flags |= COND_FLAGS_INITED;
115 pcond->c_type = type;
116 pcond->c_mutex = NULL;
117 pcond->c_seqno = 0;
118 *cond = pcond;
119 }
120 }
121 }
122 /* Return the completion status: */
123 return (rval);
124}
125
126int
127_pthread_cond_destroy(pthread_cond_t *cond)
128{
129 struct pthread_cond *cv;
130 struct pthread *curthread = _get_curthread();
131 int rval = 0;
132
133 if (cond == NULL || *cond == NULL)
134 rval = EINVAL;
135 else {
136 /* Lock the condition variable structure: */
137 THR_LOCK_ACQUIRE(curthread, &(*cond)->c_lock);
138
139 /*
140 * NULL the caller's pointer now that the condition
141 * variable has been destroyed:
142 */
143 cv = *cond;
144 *cond = NULL;
145
146 /* Unlock the condition variable structure: */
147 THR_LOCK_RELEASE(curthread, &cv->c_lock);
148
149 /*
150 * Free the memory allocated for the condition
151 * variable structure:
152 */
153 free(cv);
154
155 }
156 /* Return the completion status: */
157 return (rval);
158}
159
160int
161_pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex)
162{
163 struct pthread *curthread = _get_curthread();
164 int rval = 0;
165 int done = 0;
166 int interrupted = 0;
167 int unlock_mutex = 1;
168 int seqno;
169
170 _thr_enter_cancellation_point(curthread);
171
172 if (cond == NULL) {
173 _thr_leave_cancellation_point(curthread);
174 return (EINVAL);
175 }
176
177 /*
178 * If the condition variable is statically initialized,
179 * perform the dynamic initialization:
180 */
181 if (*cond == NULL &&
182 (rval = pthread_cond_init(cond, NULL)) != 0) {
183 _thr_leave_cancellation_point(curthread);
184 return (rval);
185 }
186
187 /*
188 * Enter a loop waiting for a condition signal or broadcast
189 * to wake up this thread. A loop is needed in case the waiting
190 * thread is interrupted by a signal to execute a signal handler.
191 * It is not (currently) possible to remain in the waiting queue
192 * while running a handler. Instead, the thread is interrupted
193 * and backed out of the waiting queue prior to executing the
194 * signal handler.
195 */
196 do {
197 /* Lock the condition variable structure: */
198 THR_LOCK_ACQUIRE(curthread, &(*cond)->c_lock);
199
200 /*
201 * If the condvar was statically allocated, properly
202 * initialize the tail queue.
203 */
204 if (((*cond)->c_flags & COND_FLAGS_INITED) == 0) {
205 TAILQ_INIT(&(*cond)->c_queue);
206 (*cond)->c_flags |= COND_FLAGS_INITED;
207 }
208
209 /* Process according to condition variable type: */
210 switch ((*cond)->c_type) {
211 /* Fast condition variable: */
212 case COND_TYPE_FAST:
213 if ((mutex == NULL) || (((*cond)->c_mutex != NULL) &&
214 ((*cond)->c_mutex != *mutex))) {
215 /* Unlock the condition variable structure: */
216 THR_LOCK_RELEASE(curthread, &(*cond)->c_lock);
217
218 /* Return invalid argument error: */
219 rval = EINVAL;
220 } else {
221 /* Reset the timeout and interrupted flags: */
222 curthread->timeout = 0;
223 curthread->interrupted = 0;
224
225 /*
226 * Queue the running thread for the condition
227 * variable:
228 */
229 cond_queue_enq(*cond, curthread);
230
231 /* Remember the mutex and sequence number: */
232 (*cond)->c_mutex = *mutex;
233 seqno = (*cond)->c_seqno;
234
235 /* Wait forever: */
236 curthread->wakeup_time.tv_sec = -1;
237
238 /* Unlock the mutex: */
239 if ((unlock_mutex != 0) &&
240 ((rval = _mutex_cv_unlock(mutex)) != 0)) {
241 /*
242 * Cannot unlock the mutex, so remove
243 * the running thread from the condition
244 * variable queue:
245 */
246 cond_queue_remove(*cond, curthread);
247
248 /* Check for no more waiters: */
249 if (TAILQ_FIRST(&(*cond)->c_queue) == NULL)
250 (*cond)->c_mutex = NULL;
251
252 /* Unlock the condition variable structure: */
253 THR_LOCK_RELEASE(curthread, &(*cond)->c_lock);
254 }
255 else {
256 /*
257 * Don't unlock the mutex the next
258 * time through the loop (if the
259 * thread has to be requeued after
260 * handling a signal).
261 */
262 unlock_mutex = 0;
263
264 /*
265 * This thread is active and is in a
266 * critical region (holding the cv
267 * lock); we should be able to safely
268 * set the state.
269 */
270 THR_SET_STATE(curthread, PS_COND_WAIT);
271
272 /* Remember the CV: */
273 curthread->data.cond = *cond;
274
275 /* Unlock the CV structure: */
276 THR_LOCK_RELEASE(curthread,
277 &(*cond)->c_lock);
278
279 /* Schedule the next thread: */
280 _thr_sched_switch(curthread);
281
282 curthread->data.cond = NULL;
283
284 /*
285 * XXX - This really isn't a good check
286 * since there can be more than one
287 * thread waiting on the CV. Signals
288 * sent to threads waiting on mutexes
289 * or CVs should really be deferred
290 * until the threads are no longer
291 * waiting, but POSIX says that signals
292 * should be sent "as soon as possible".
293 */
294 done = (seqno != (*cond)->c_seqno);
295
296 if (THR_IN_SYNCQ(curthread)) {
297 /*
298 * Lock the condition variable
299 * while removing the thread.
300 */
301 THR_LOCK_ACQUIRE(curthread,
302 &(*cond)->c_lock);
303
304 cond_queue_remove(*cond,
305 curthread);
306
307 /* Check for no more waiters: */
308 if (TAILQ_FIRST(&(*cond)->c_queue) == NULL)
309 (*cond)->c_mutex = NULL;
310
311 THR_LOCK_RELEASE(curthread,
312 &(*cond)->c_lock);
313 }
314
315 /*
316 * Save the interrupted flag; locking
317 * the mutex may destroy it.
318 */
319 interrupted = curthread->interrupted;
320
321 /*
322 * Note that even though this thread may
323 * have been canceled, POSIX requires
324 * that the mutex be reaquired prior to
325 * cancellation.
326 */
327 if (done != 0)
328 rval = _mutex_cv_lock(mutex);
329 }
330 }
331 break;
332
333 /* Trap invalid condition variable types: */
334 default:
335 /* Unlock the condition variable structure: */
336 THR_LOCK_RELEASE(curthread, &(*cond)->c_lock);
337
338 /* Return an invalid argument error: */
339 rval = EINVAL;
340 break;
341 }
342
343 if ((interrupted != 0) && (curthread->continuation != NULL))
344 curthread->continuation((void *) curthread);
345 } while ((done == 0) && (rval == 0));
346
347 _thr_leave_cancellation_point(curthread);
348
349 /* Return the completion status: */
350 return (rval);
351}
352
353int
354__pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex)
355{
356 struct pthread *curthread = _get_curthread();
357 int ret;
358
359 _thr_enter_cancellation_point(curthread);
360 ret = _pthread_cond_wait(cond, mutex);
361 _thr_leave_cancellation_point(curthread);
362 return (ret);
363}
364
365int
366_pthread_cond_timedwait(pthread_cond_t * cond, pthread_mutex_t * mutex,
367 const struct timespec * abstime)
368{
369 struct pthread *curthread = _get_curthread();
370 int rval = 0;
371 int done = 0;
372 int interrupted = 0;
373 int unlock_mutex = 1;
374 int seqno;
375
376 _thr_enter_cancellation_point(curthread);
377
378 if (abstime == NULL || abstime->tv_sec < 0 || abstime->tv_nsec < 0 ||
379 abstime->tv_nsec >= 1000000000) {
380 _thr_leave_cancellation_point(curthread);
381 return (EINVAL);
382 }
383 /*
384 * If the condition variable is statically initialized, perform dynamic
385 * initialization.
386 */
387 if (*cond == NULL && (rval = pthread_cond_init(cond, NULL)) != 0) {
388 _thr_leave_cancellation_point(curthread);
389 return (rval);
390 }
391
392 /*
393 * Enter a loop waiting for a condition signal or broadcast
394 * to wake up this thread. A loop is needed in case the waiting
395 * thread is interrupted by a signal to execute a signal handler.
396 * It is not (currently) possible to remain in the waiting queue
397 * while running a handler. Instead, the thread is interrupted
398 * and backed out of the waiting queue prior to executing the
399 * signal handler.
400 */
401 do {
402 /* Lock the condition variable structure: */
403 THR_LOCK_ACQUIRE(curthread, &(*cond)->c_lock);
404
405 /*
406 * If the condvar was statically allocated, properly
407 * initialize the tail queue.
408 */
409 if (((*cond)->c_flags & COND_FLAGS_INITED) == 0) {
410 TAILQ_INIT(&(*cond)->c_queue);
411 (*cond)->c_flags |= COND_FLAGS_INITED;
412 }
413
414 /* Process according to condition variable type: */
415 switch ((*cond)->c_type) {
416 /* Fast condition variable: */
417 case COND_TYPE_FAST:
418 if ((mutex == NULL) || (((*cond)->c_mutex != NULL) &&
419 ((*cond)->c_mutex != *mutex))) {
420 /* Return invalid argument error: */
421 rval = EINVAL;
422
423 /* Unlock the condition variable structure: */
424 THR_LOCK_RELEASE(curthread, &(*cond)->c_lock);
425 } else {
426 /* Set the wakeup time: */
427 curthread->wakeup_time.tv_sec = abstime->tv_sec;
428 curthread->wakeup_time.tv_nsec =
429 abstime->tv_nsec;
430
431 /* Reset the timeout and interrupted flags: */
432 curthread->timeout = 0;
433 curthread->interrupted = 0;
434
435 /*
436 * Queue the running thread for the condition
437 * variable:
438 */
439 cond_queue_enq(*cond, curthread);
440
441 /* Remember the mutex and sequence number: */
442 (*cond)->c_mutex = *mutex;
443 seqno = (*cond)->c_seqno;
444
445 /* Unlock the mutex: */
446 if ((unlock_mutex != 0) &&
447 ((rval = _mutex_cv_unlock(mutex)) != 0)) {
448 /*
449 * Cannot unlock the mutex; remove the
450 * running thread from the condition
451 * variable queue:
452 */
453 cond_queue_remove(*cond, curthread);
454
455 /* Check for no more waiters: */
456 if (TAILQ_FIRST(&(*cond)->c_queue) == NULL)
457 (*cond)->c_mutex = NULL;
458
459 /* Unlock the condition variable structure: */
460 THR_LOCK_RELEASE(curthread, &(*cond)->c_lock);
461 } else {
462 /*
463 * Don't unlock the mutex the next
464 * time through the loop (if the
465 * thread has to be requeued after
466 * handling a signal).
467 */
468 unlock_mutex = 0;
469
470 /*
471 * This thread is active and is in a
472 * critical region (holding the cv
473 * lock); we should be able to safely
474 * set the state.
475 */
476 THR_SET_STATE(curthread, PS_COND_WAIT);
477
478 /* Remember the CV: */
479 curthread->data.cond = *cond;
480
481 /* Unlock the CV structure: */
482 THR_LOCK_RELEASE(curthread,
483 &(*cond)->c_lock);
484
485 /* Schedule the next thread: */
486 _thr_sched_switch(curthread);
487
488 curthread->data.cond = NULL;
489
490 /*
491 * XXX - This really isn't a good check
492 * since there can be more than one
493 * thread waiting on the CV. Signals
494 * sent to threads waiting on mutexes
495 * or CVs should really be deferred
496 * until the threads are no longer
497 * waiting, but POSIX says that signals
498 * should be sent "as soon as possible".
499 */
500 done = (seqno != (*cond)->c_seqno);
501
502 if (THR_IN_CONDQ(curthread)) {
503 /*
504 * Lock the condition variable
505 * while removing the thread.
506 */
507 THR_LOCK_ACQUIRE(curthread,
508 &(*cond)->c_lock);
509
510 cond_queue_remove(*cond,
511 curthread);
512
513 /* Check for no more waiters: */
514 if (TAILQ_FIRST(&(*cond)->c_queue) == NULL)
515 (*cond)->c_mutex = NULL;
516
517 THR_LOCK_RELEASE(curthread,
518 &(*cond)->c_lock);
519 }
520
521 /*
522 * Save the interrupted flag; locking
523 * the mutex may destroy it.
524 */
525 interrupted = curthread->interrupted;
526 if (curthread->timeout != 0) {
527 /* The wait timedout. */
528 rval = ETIMEDOUT;
529 (void)_mutex_cv_lock(mutex);
530 } else if ((interrupted == 0) ||
531 (done != 0))
532 rval = _mutex_cv_lock(mutex);
533 }
534 }
535 break;
536
537 /* Trap invalid condition variable types: */
538 default:
539 /* Unlock the condition variable structure: */
540 THR_LOCK_RELEASE(curthread, &(*cond)->c_lock);
541
542 /* Return an invalid argument error: */
543 rval = EINVAL;
544 break;
545 }
546
547 if ((interrupted != 0) && (curthread->continuation != NULL))
548 curthread->continuation((void *)curthread);
549 } while ((done == 0) && (rval == 0));
550
551 _thr_leave_cancellation_point(curthread);
552
553 /* Return the completion status: */
554 return (rval);
555}
556
557int
558__pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex,
559 const struct timespec *abstime)
560{
561 struct pthread *curthread = _get_curthread();
562 int ret;
563
564 _thr_enter_cancellation_point(curthread);
565 ret = _pthread_cond_timedwait(cond, mutex, abstime);
566 _thr_leave_cancellation_point(curthread);
567 return (ret);
568}
569
570
571int
572_pthread_cond_signal(pthread_cond_t * cond)
573{
574 struct pthread *curthread = _get_curthread();
575 struct pthread *pthread;
576 int rval = 0;
577
578 if (cond == NULL)
579 rval = EINVAL;
580 /*
581 * If the condition variable is statically initialized, perform dynamic
582 * initialization.
583 */
584 else if (*cond != NULL || (rval = pthread_cond_init(cond, NULL)) == 0) {
585 /* Lock the condition variable structure: */
586 THR_LOCK_ACQUIRE(curthread, &(*cond)->c_lock);
587
588 /* Process according to condition variable type: */
589 switch ((*cond)->c_type) {
590 /* Fast condition variable: */
591 case COND_TYPE_FAST:
592 /* Increment the sequence number: */
593 (*cond)->c_seqno++;
594
595 /*
596 * Wakeups have to be done with the CV lock held;
597 * otherwise there is a race condition where the
598 * thread can timeout, run on another KSE, and enter
599 * another blocking state (including blocking on a CV).
600 */
601 if ((pthread = TAILQ_FIRST(&(*cond)->c_queue))
602 != NULL) {
603 THR_SCHED_LOCK(curthread, pthread);
604 cond_queue_remove(*cond, pthread);
605 _thr_setrunnable_unlocked(pthread);
606 THR_SCHED_UNLOCK(curthread, pthread);
607 }
608 /* Check for no more waiters: */
609 if (TAILQ_FIRST(&(*cond)->c_queue) == NULL)
610 (*cond)->c_mutex = NULL;
611 break;
612
613 /* Trap invalid condition variable types: */
614 default:
615 /* Return an invalid argument error: */
616 rval = EINVAL;
617 break;
618 }
619
620 /* Unlock the condition variable structure: */
621 THR_LOCK_RELEASE(curthread, &(*cond)->c_lock);
622 }
623
624 /* Return the completion status: */
625 return (rval);
626}
627
628int
629_pthread_cond_broadcast(pthread_cond_t * cond)
630{
631 struct pthread *curthread = _get_curthread();
632 struct pthread *pthread;
633 int rval = 0;
634
635 if (cond == NULL)
636 rval = EINVAL;
637 /*
638 * If the condition variable is statically initialized, perform dynamic
639 * initialization.
640 */
641 else if (*cond != NULL || (rval = pthread_cond_init(cond, NULL)) == 0) {
642 /* Lock the condition variable structure: */
643 THR_LOCK_ACQUIRE(curthread, &(*cond)->c_lock);
644
645 /* Process according to condition variable type: */
646 switch ((*cond)->c_type) {
647 /* Fast condition variable: */
648 case COND_TYPE_FAST:
649 /* Increment the sequence number: */
650 (*cond)->c_seqno++;
651
652 /*
653 * Enter a loop to bring all threads off the
654 * condition queue:
655 */
656 while ((pthread = TAILQ_FIRST(&(*cond)->c_queue))
657 != NULL) {
658 THR_SCHED_LOCK(curthread, pthread);
659 cond_queue_remove(*cond, pthread);
660 _thr_setrunnable_unlocked(pthread);
661 THR_SCHED_UNLOCK(curthread, pthread);
662 }
663
664 /* There are no more waiting threads: */
665 (*cond)->c_mutex = NULL;
666 break;
667
668 /* Trap invalid condition variable types: */
669 default:
670 /* Return an invalid argument error: */
671 rval = EINVAL;
672 break;
673 }
674
675 /* Unlock the condition variable structure: */
676 THR_LOCK_RELEASE(curthread, &(*cond)->c_lock);
677 }
678
679 /* Return the completion status: */
680 return (rval);
681}
682
683void
684_cond_wait_backout(struct pthread *curthread)
685{
686 pthread_cond_t cond;
687
688 cond = curthread->data.cond;
689 if (cond != NULL) {
690 /* Lock the condition variable structure: */
691 THR_LOCK_ACQUIRE(curthread, &cond->c_lock);
692
693 /* Process according to condition variable type: */
694 switch (cond->c_type) {
695 /* Fast condition variable: */
696 case COND_TYPE_FAST:
697 cond_queue_remove(cond, curthread);
698
699 /* Check for no more waiters: */
700 if (TAILQ_FIRST(&cond->c_queue) == NULL)
701 cond->c_mutex = NULL;
702 break;
703
704 default:
705 break;
706 }
707
708 /* Unlock the condition variable structure: */
709 THR_LOCK_RELEASE(curthread, &cond->c_lock);
710 }
711}
712
713/*
714 * Dequeue a waiting thread from the head of a condition queue in
715 * descending priority order.
716 */
717static inline struct pthread *
718cond_queue_deq(pthread_cond_t cond)
719{
720 struct pthread *pthread;
721
722 while ((pthread = TAILQ_FIRST(&cond->c_queue)) != NULL) {
723 TAILQ_REMOVE(&cond->c_queue, pthread, sqe);
724 THR_CONDQ_SET(pthread);
725 if ((pthread->timeout == 0) && (pthread->interrupted == 0))
726 /*
727 * Only exit the loop when we find a thread
728 * that hasn't timed out or been canceled;
729 * those threads are already running and don't
730 * need their run state changed.
731 */
732 break;
733 }
734
735 return (pthread);
736}
737
738/*
739 * Remove a waiting thread from a condition queue in descending priority
740 * order.
741 */
742static inline void
743cond_queue_remove(pthread_cond_t cond, struct pthread *pthread)
744{
745 /*
746 * Because pthread_cond_timedwait() can timeout as well
747 * as be signaled by another thread, it is necessary to
748 * guard against removing the thread from the queue if
749 * it isn't in the queue.
750 */
751 if (THR_IN_CONDQ(pthread)) {
752 TAILQ_REMOVE(&cond->c_queue, pthread, sqe);
753 THR_CONDQ_CLEAR(pthread);
754 }
755}
756
757/*
758 * Enqueue a waiting thread to a condition queue in descending priority
759 * order.
760 */
761static inline void
762cond_queue_enq(pthread_cond_t cond, struct pthread *pthread)
763{
764 struct pthread *tid = TAILQ_LAST(&cond->c_queue, cond_head);
765
766 THR_ASSERT(!THR_IN_SYNCQ(pthread),
767 "cond_queue_enq: thread already queued!");
768
769 /*
770 * For the common case of all threads having equal priority,
771 * we perform a quick check against the priority of the thread
772 * at the tail of the queue.
773 */
774 if ((tid == NULL) || (pthread->active_priority <= tid->active_priority))
775 TAILQ_INSERT_TAIL(&cond->c_queue, pthread, sqe);
776 else {
777 tid = TAILQ_FIRST(&cond->c_queue);
778 while (pthread->active_priority <= tid->active_priority)
779 tid = TAILQ_NEXT(tid, sqe);
780 TAILQ_INSERT_BEFORE(tid, pthread, sqe);
781 }
782 THR_CONDQ_SET(pthread);
783 pthread->data.cond = cond;
784}
|