1 /* $NetBSD: pthread_cond.c,v 1.61 2013/04/01 13:28:21 christos Exp $ */ 2 3 /*- 4 * Copyright (c) 2001, 2006, 2007, 2008 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by Nathan J. Williams and Andrew Doran. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 29 * POSSIBILITY OF SUCH DAMAGE. 30 */ 31 32 /* 33 * We assume that there will be no contention on pthread_cond_t::ptc_lock 34 * because functioning applications must call both the wait and wakeup 35 * functions while holding the same application provided mutex. The 36 * spinlock is present only to prevent libpthread causing the application 37 * to crash or malfunction as a result of corrupted data structures, in 38 * the event that the application is buggy. 39 * 40 * If there is contention on spinlock when real-time threads are in use, 41 * it could cause a deadlock due to priority inversion: the thread holding 42 * the spinlock may not get CPU time to make forward progress and release 43 * the spinlock to a higher priority thread that is waiting for it. 44 * Contention on the spinlock will only occur with buggy applications, 45 * so at the time of writing it's not considered a major bug in libpthread. 46 */ 47 48 #include <sys/cdefs.h> 49 __RCSID("$NetBSD: pthread_cond.c,v 1.61 2013/04/01 13:28:21 christos Exp $"); 50 51 #include <stdlib.h> 52 #include <errno.h> 53 #include <sys/time.h> 54 #include <sys/types.h> 55 56 #include "pthread.h" 57 #include "pthread_int.h" 58 #include "reentrant.h" 59 60 int _sys___nanosleep50(const struct timespec *, struct timespec *); 61 62 extern int pthread__started; 63 64 static int pthread_cond_wait_nothread(pthread_t, pthread_mutex_t *, 65 pthread_cond_t *, const struct timespec *); 66 67 int _pthread_cond_has_waiters_np(pthread_cond_t *); 68 69 __weak_alias(pthread_cond_has_waiters_np,_pthread_cond_has_waiters_np) 70 71 __strong_alias(__libc_cond_init,pthread_cond_init) 72 __strong_alias(__libc_cond_signal,pthread_cond_signal) 73 __strong_alias(__libc_cond_broadcast,pthread_cond_broadcast) 74 __strong_alias(__libc_cond_wait,pthread_cond_wait) 75 __strong_alias(__libc_cond_timedwait,pthread_cond_timedwait) 76 __strong_alias(__libc_cond_destroy,pthread_cond_destroy) 77 78 static clockid_t 79 pthread_cond_getclock(const pthread_cond_t *cond) 80 { 81 return cond->ptc_private ? 82 *(clockid_t *)cond->ptc_private : CLOCK_REALTIME; 83 } 84 85 int 86 pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *attr) 87 { 88 if (__predict_false(__uselibcstub)) 89 return __libc_cond_init_stub(cond, attr); 90 91 pthread__error(EINVAL, "Invalid condition variable attribute", 92 (attr == NULL) || (attr->ptca_magic == _PT_CONDATTR_MAGIC)); 93 94 cond->ptc_magic = _PT_COND_MAGIC; 95 pthread_lockinit(&cond->ptc_lock); 96 PTQ_INIT(&cond->ptc_waiters); 97 cond->ptc_mutex = NULL; 98 if (attr && attr->ptca_private) { 99 cond->ptc_private = malloc(sizeof(clockid_t)); 100 if (cond->ptc_private == NULL) 101 return errno; 102 *(clockid_t *)cond->ptc_private = 103 *(clockid_t *)attr->ptca_private; 104 } else 105 cond->ptc_private = NULL; 106 107 return 0; 108 } 109 110 111 int 112 pthread_cond_destroy(pthread_cond_t *cond) 113 { 114 if (__predict_false(__uselibcstub)) 115 return __libc_cond_destroy_stub(cond); 116 117 pthread__error(EINVAL, "Invalid condition variable", 118 cond->ptc_magic == _PT_COND_MAGIC); 119 pthread__error(EBUSY, "Destroying condition variable in use", 120 cond->ptc_mutex == NULL); 121 122 cond->ptc_magic = _PT_COND_DEAD; 123 free(cond->ptc_private); 124 125 return 0; 126 } 127 128 int 129 pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex, 130 const struct timespec *abstime) 131 { 132 pthread_t self; 133 int retval; 134 struct timespec mono; 135 136 if (__predict_false(__uselibcstub)) 137 return __libc_cond_timedwait_stub(cond, mutex, abstime); 138 139 pthread__error(EINVAL, "Invalid condition variable", 140 cond->ptc_magic == _PT_COND_MAGIC); 141 pthread__error(EINVAL, "Invalid mutex", 142 mutex->ptm_magic == _PT_MUTEX_MAGIC); 143 pthread__error(EPERM, "Mutex not locked in condition wait", 144 mutex->ptm_owner != NULL); 145 if (abstime != NULL) { 146 /* 147 * XXX: This should be done in the kernel to avoid 148 * extra system calls! 149 */ 150 if (pthread_cond_getclock(cond) == CLOCK_MONOTONIC) { 151 struct timespec real; 152 if (clock_gettime(CLOCK_REALTIME, &real) == -1 || 153 clock_gettime(CLOCK_MONOTONIC, &mono) == -1) 154 return errno; 155 timespecsub(abstime, &mono, &mono); 156 timespecadd(&mono, &real, &mono); 157 abstime = &mono; 158 } 159 pthread__error(EINVAL, "Invalid wait time", 160 (abstime->tv_sec >= 0) && 161 (abstime->tv_nsec >= 0) && 162 (abstime->tv_nsec < 1000000000)); 163 } 164 165 self = pthread__self(); 166 167 /* Just hang out for a while if threads aren't running yet. */ 168 if (__predict_false(pthread__started == 0)) { 169 return pthread_cond_wait_nothread(self, mutex, cond, abstime); 170 } 171 if (__predict_false(self->pt_cancel)) { 172 pthread__cancelled(); 173 } 174 175 /* Note this thread as waiting on the CV. */ 176 pthread__spinlock(self, &cond->ptc_lock); 177 cond->ptc_mutex = mutex; 178 PTQ_INSERT_HEAD(&cond->ptc_waiters, self, pt_sleep); 179 self->pt_sleepobj = cond; 180 pthread__spinunlock(self, &cond->ptc_lock); 181 182 do { 183 self->pt_willpark = 1; 184 pthread_mutex_unlock(mutex); 185 self->pt_willpark = 0; 186 self->pt_blocking++; 187 retval = _lwp_park(abstime, self->pt_unpark, 188 __UNVOLATILE(&mutex->ptm_waiters), 189 __UNVOLATILE(&mutex->ptm_waiters)); 190 self->pt_unpark = 0; 191 self->pt_blocking--; 192 membar_sync(); 193 pthread_mutex_lock(mutex); 194 195 /* 196 * If we have cancelled then exit. POSIX dictates that 197 * the mutex must be held when we action the cancellation. 198 * 199 * If we absorbed a pthread_cond_signal() and cannot take 200 * the wakeup, we must ensure that another thread does. 201 * 202 * If awoke early, we may still be on the sleep queue and 203 * must remove ourself. 204 */ 205 if (__predict_false(retval != 0)) { 206 switch (errno) { 207 case EINTR: 208 case EALREADY: 209 retval = 0; 210 break; 211 default: 212 retval = errno; 213 break; 214 } 215 } 216 if (__predict_false(self->pt_cancel | retval)) { 217 pthread_cond_signal(cond); 218 if (self->pt_cancel) { 219 pthread__cancelled(); 220 } 221 break; 222 } 223 } while (self->pt_sleepobj != NULL); 224 225 return retval; 226 } 227 228 int 229 pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex) 230 { 231 if (__predict_false(__uselibcstub)) 232 return __libc_cond_wait_stub(cond, mutex); 233 234 return pthread_cond_timedwait(cond, mutex, NULL); 235 } 236 237 static int __noinline 238 pthread__cond_wake_one(pthread_cond_t *cond) 239 { 240 pthread_t self, signaled; 241 pthread_mutex_t *mutex; 242 lwpid_t lid; 243 244 pthread__error(EINVAL, "Invalid condition variable", 245 cond->ptc_magic == _PT_COND_MAGIC); 246 247 /* 248 * Pull the first thread off the queue. If the current thread 249 * is associated with the condition variable, remove it without 250 * awakening (error case in pthread_cond_timedwait()). 251 */ 252 self = pthread__self(); 253 pthread__spinlock(self, &cond->ptc_lock); 254 if (self->pt_sleepobj == cond) { 255 PTQ_REMOVE(&cond->ptc_waiters, self, pt_sleep); 256 self->pt_sleepobj = NULL; 257 } 258 signaled = PTQ_FIRST(&cond->ptc_waiters); 259 if (__predict_false(signaled == NULL)) { 260 cond->ptc_mutex = NULL; 261 pthread__spinunlock(self, &cond->ptc_lock); 262 return 0; 263 } 264 mutex = cond->ptc_mutex; 265 if (PTQ_NEXT(signaled, pt_sleep) == NULL) { 266 cond->ptc_mutex = NULL; 267 PTQ_INIT(&cond->ptc_waiters); 268 } else { 269 PTQ_REMOVE(&cond->ptc_waiters, signaled, pt_sleep); 270 } 271 signaled->pt_sleepobj = NULL; 272 lid = signaled->pt_lid; 273 pthread__spinunlock(self, &cond->ptc_lock); 274 275 /* 276 * For all valid uses of pthread_cond_signal(), the caller will 277 * hold the mutex that the target is using to synchronize with. 278 * To avoid the target awakening and immediately blocking on the 279 * mutex, transfer the thread to be awoken to the current thread's 280 * deferred wakeup list. The waiter will be set running when the 281 * caller (this thread) releases the mutex. 282 */ 283 if (__predict_false(self->pt_nwaiters == (size_t)pthread__unpark_max)) { 284 (void)_lwp_unpark_all(self->pt_waiters, self->pt_nwaiters, 285 __UNVOLATILE(&mutex->ptm_waiters)); 286 self->pt_nwaiters = 0; 287 } 288 self->pt_waiters[self->pt_nwaiters++] = lid; 289 pthread__mutex_deferwake(self, mutex); 290 return 0; 291 } 292 293 int 294 pthread_cond_signal(pthread_cond_t *cond) 295 { 296 297 if (__predict_false(__uselibcstub)) 298 return __libc_cond_signal_stub(cond); 299 300 if (__predict_true(PTQ_EMPTY(&cond->ptc_waiters))) 301 return 0; 302 return pthread__cond_wake_one(cond); 303 } 304 305 static int __noinline 306 pthread__cond_wake_all(pthread_cond_t *cond) 307 { 308 pthread_t self, signaled; 309 pthread_mutex_t *mutex; 310 u_int max; 311 size_t nwaiters; 312 313 pthread__error(EINVAL, "Invalid condition variable", 314 cond->ptc_magic == _PT_COND_MAGIC); 315 316 /* 317 * Try to defer waking threads (see pthread_cond_signal()). 318 * Only transfer waiters for which there is no pending wakeup. 319 */ 320 self = pthread__self(); 321 pthread__spinlock(self, &cond->ptc_lock); 322 max = pthread__unpark_max; 323 mutex = cond->ptc_mutex; 324 nwaiters = self->pt_nwaiters; 325 PTQ_FOREACH(signaled, &cond->ptc_waiters, pt_sleep) { 326 if (__predict_false(nwaiters == max)) { 327 /* Overflow. */ 328 (void)_lwp_unpark_all(self->pt_waiters, 329 nwaiters, __UNVOLATILE(&mutex->ptm_waiters)); 330 nwaiters = 0; 331 } 332 signaled->pt_sleepobj = NULL; 333 self->pt_waiters[nwaiters++] = signaled->pt_lid; 334 } 335 PTQ_INIT(&cond->ptc_waiters); 336 self->pt_nwaiters = nwaiters; 337 cond->ptc_mutex = NULL; 338 pthread__spinunlock(self, &cond->ptc_lock); 339 pthread__mutex_deferwake(self, mutex); 340 341 return 0; 342 } 343 344 int 345 pthread_cond_broadcast(pthread_cond_t *cond) 346 { 347 if (__predict_false(__uselibcstub)) 348 return __libc_cond_broadcast_stub(cond); 349 350 if (__predict_true(PTQ_EMPTY(&cond->ptc_waiters))) 351 return 0; 352 return pthread__cond_wake_all(cond); 353 } 354 355 int 356 _pthread_cond_has_waiters_np(pthread_cond_t *cond) 357 { 358 359 return !PTQ_EMPTY(&cond->ptc_waiters); 360 } 361 362 int 363 pthread_condattr_init(pthread_condattr_t *attr) 364 { 365 366 attr->ptca_magic = _PT_CONDATTR_MAGIC; 367 attr->ptca_private = NULL; 368 369 return 0; 370 } 371 372 int 373 pthread_condattr_setclock(pthread_condattr_t *attr, clockid_t clck) 374 { 375 switch (clck) { 376 case CLOCK_MONOTONIC: 377 case CLOCK_REALTIME: 378 if (attr->ptca_private == NULL) 379 attr->ptca_private = malloc(sizeof(clockid_t)); 380 if (attr->ptca_private == NULL) 381 return errno; 382 *(clockid_t *)attr->ptca_private = clck; 383 return 0; 384 default: 385 return EINVAL; 386 } 387 } 388 389 int 390 pthread_condattr_destroy(pthread_condattr_t *attr) 391 { 392 393 pthread__error(EINVAL, "Invalid condition variable attribute", 394 attr->ptca_magic == _PT_CONDATTR_MAGIC); 395 396 attr->ptca_magic = _PT_CONDATTR_DEAD; 397 free(attr->ptca_private); 398 399 return 0; 400 } 401 402 /* Utility routine to hang out for a while if threads haven't started yet. */ 403 static int 404 pthread_cond_wait_nothread(pthread_t self, pthread_mutex_t *mutex, 405 pthread_cond_t *cond, const struct timespec *abstime) 406 { 407 struct timespec now, diff; 408 int retval; 409 410 if (abstime == NULL) { 411 diff.tv_sec = 99999999; 412 diff.tv_nsec = 0; 413 } else { 414 clockid_t clck = pthread_cond_getclock(cond); 415 clock_gettime(clck, &now); 416 if (timespeccmp(abstime, &now, <)) 417 timespecclear(&diff); 418 else 419 timespecsub(abstime, &now, &diff); 420 } 421 422 do { 423 pthread__testcancel(self); 424 pthread_mutex_unlock(mutex); 425 retval = _sys___nanosleep50(&diff, NULL); 426 pthread_mutex_lock(mutex); 427 } while (abstime == NULL && retval == 0); 428 pthread__testcancel(self); 429 430 if (retval == 0) 431 return ETIMEDOUT; 432 else 433 /* spurious wakeup */ 434 return 0; 435 } 436