1 /* $NetBSD: pthread_cond.c,v 1.63 2014/01/31 20:44:01 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.63 2014/01/31 20:44:01 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 clockid_t clkid = pthread_cond_getclock(cond); 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 146 self = pthread__self(); 147 148 /* Just hang out for a while if threads aren't running yet. */ 149 if (__predict_false(pthread__started == 0)) { 150 return pthread_cond_wait_nothread(self, mutex, cond, abstime); 151 } 152 if (__predict_false(self->pt_cancel)) { 153 pthread__cancelled(); 154 } 155 156 /* Note this thread as waiting on the CV. */ 157 pthread__spinlock(self, &cond->ptc_lock); 158 cond->ptc_mutex = mutex; 159 PTQ_INSERT_HEAD(&cond->ptc_waiters, self, pt_sleep); 160 self->pt_sleepobj = cond; 161 pthread__spinunlock(self, &cond->ptc_lock); 162 163 do { 164 self->pt_willpark = 1; 165 pthread_mutex_unlock(mutex); 166 self->pt_willpark = 0; 167 self->pt_blocking++; 168 do { 169 retval = _lwp_park(clkid, TIMER_ABSTIME, abstime, 170 self->pt_unpark, __UNVOLATILE(&mutex->ptm_waiters), 171 __UNVOLATILE(&mutex->ptm_waiters)); 172 self->pt_unpark = 0; 173 } while (retval == -1 && errno == ESRCH); 174 self->pt_blocking--; 175 membar_sync(); 176 pthread_mutex_lock(mutex); 177 178 /* 179 * If we have cancelled then exit. POSIX dictates that 180 * the mutex must be held when we action the cancellation. 181 * 182 * If we absorbed a pthread_cond_signal() and cannot take 183 * the wakeup, we must ensure that another thread does. 184 * 185 * If awoke early, we may still be on the sleep queue and 186 * must remove ourself. 187 */ 188 if (__predict_false(retval != 0)) { 189 switch (errno) { 190 case EINTR: 191 case EALREADY: 192 retval = 0; 193 break; 194 default: 195 retval = errno; 196 break; 197 } 198 } 199 if (__predict_false(self->pt_cancel | retval)) { 200 pthread_cond_signal(cond); 201 if (self->pt_cancel) { 202 pthread__cancelled(); 203 } 204 break; 205 } 206 } while (self->pt_sleepobj != NULL); 207 208 return retval; 209 } 210 211 int 212 pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex) 213 { 214 if (__predict_false(__uselibcstub)) 215 return __libc_cond_wait_stub(cond, mutex); 216 217 return pthread_cond_timedwait(cond, mutex, NULL); 218 } 219 220 static int __noinline 221 pthread__cond_wake_one(pthread_cond_t *cond) 222 { 223 pthread_t self, signaled; 224 pthread_mutex_t *mutex; 225 lwpid_t lid; 226 227 pthread__error(EINVAL, "Invalid condition variable", 228 cond->ptc_magic == _PT_COND_MAGIC); 229 230 /* 231 * Pull the first thread off the queue. If the current thread 232 * is associated with the condition variable, remove it without 233 * awakening (error case in pthread_cond_timedwait()). 234 */ 235 self = pthread__self(); 236 pthread__spinlock(self, &cond->ptc_lock); 237 if (self->pt_sleepobj == cond) { 238 PTQ_REMOVE(&cond->ptc_waiters, self, pt_sleep); 239 self->pt_sleepobj = NULL; 240 } 241 signaled = PTQ_FIRST(&cond->ptc_waiters); 242 if (__predict_false(signaled == NULL)) { 243 cond->ptc_mutex = NULL; 244 pthread__spinunlock(self, &cond->ptc_lock); 245 return 0; 246 } 247 mutex = cond->ptc_mutex; 248 if (PTQ_NEXT(signaled, pt_sleep) == NULL) { 249 cond->ptc_mutex = NULL; 250 PTQ_INIT(&cond->ptc_waiters); 251 } else { 252 PTQ_REMOVE(&cond->ptc_waiters, signaled, pt_sleep); 253 } 254 signaled->pt_sleepobj = NULL; 255 lid = signaled->pt_lid; 256 pthread__spinunlock(self, &cond->ptc_lock); 257 258 /* 259 * For all valid uses of pthread_cond_signal(), the caller will 260 * hold the mutex that the target is using to synchronize with. 261 * To avoid the target awakening and immediately blocking on the 262 * mutex, transfer the thread to be awoken to the current thread's 263 * deferred wakeup list. The waiter will be set running when the 264 * caller (this thread) releases the mutex. 265 */ 266 if (__predict_false(self->pt_nwaiters == (size_t)pthread__unpark_max)) { 267 (void)_lwp_unpark_all(self->pt_waiters, self->pt_nwaiters, 268 __UNVOLATILE(&mutex->ptm_waiters)); 269 self->pt_nwaiters = 0; 270 } 271 self->pt_waiters[self->pt_nwaiters++] = lid; 272 pthread__mutex_deferwake(self, mutex); 273 return 0; 274 } 275 276 int 277 pthread_cond_signal(pthread_cond_t *cond) 278 { 279 280 if (__predict_false(__uselibcstub)) 281 return __libc_cond_signal_stub(cond); 282 283 if (__predict_true(PTQ_EMPTY(&cond->ptc_waiters))) 284 return 0; 285 return pthread__cond_wake_one(cond); 286 } 287 288 static int __noinline 289 pthread__cond_wake_all(pthread_cond_t *cond) 290 { 291 pthread_t self, signaled; 292 pthread_mutex_t *mutex; 293 u_int max; 294 size_t nwaiters; 295 296 pthread__error(EINVAL, "Invalid condition variable", 297 cond->ptc_magic == _PT_COND_MAGIC); 298 299 /* 300 * Try to defer waking threads (see pthread_cond_signal()). 301 * Only transfer waiters for which there is no pending wakeup. 302 */ 303 self = pthread__self(); 304 pthread__spinlock(self, &cond->ptc_lock); 305 max = pthread__unpark_max; 306 mutex = cond->ptc_mutex; 307 nwaiters = self->pt_nwaiters; 308 PTQ_FOREACH(signaled, &cond->ptc_waiters, pt_sleep) { 309 if (__predict_false(nwaiters == max)) { 310 /* Overflow. */ 311 (void)_lwp_unpark_all(self->pt_waiters, 312 nwaiters, __UNVOLATILE(&mutex->ptm_waiters)); 313 nwaiters = 0; 314 } 315 signaled->pt_sleepobj = NULL; 316 self->pt_waiters[nwaiters++] = signaled->pt_lid; 317 } 318 PTQ_INIT(&cond->ptc_waiters); 319 self->pt_nwaiters = nwaiters; 320 cond->ptc_mutex = NULL; 321 pthread__spinunlock(self, &cond->ptc_lock); 322 pthread__mutex_deferwake(self, mutex); 323 324 return 0; 325 } 326 327 int 328 pthread_cond_broadcast(pthread_cond_t *cond) 329 { 330 if (__predict_false(__uselibcstub)) 331 return __libc_cond_broadcast_stub(cond); 332 333 if (__predict_true(PTQ_EMPTY(&cond->ptc_waiters))) 334 return 0; 335 return pthread__cond_wake_all(cond); 336 } 337 338 int 339 _pthread_cond_has_waiters_np(pthread_cond_t *cond) 340 { 341 342 return !PTQ_EMPTY(&cond->ptc_waiters); 343 } 344 345 int 346 pthread_condattr_init(pthread_condattr_t *attr) 347 { 348 349 attr->ptca_magic = _PT_CONDATTR_MAGIC; 350 attr->ptca_private = NULL; 351 352 return 0; 353 } 354 355 int 356 pthread_condattr_setclock(pthread_condattr_t *attr, clockid_t clck) 357 { 358 switch (clck) { 359 case CLOCK_MONOTONIC: 360 case CLOCK_REALTIME: 361 if (attr->ptca_private == NULL) 362 attr->ptca_private = malloc(sizeof(clockid_t)); 363 if (attr->ptca_private == NULL) 364 return errno; 365 *(clockid_t *)attr->ptca_private = clck; 366 return 0; 367 default: 368 return EINVAL; 369 } 370 } 371 372 int 373 pthread_condattr_destroy(pthread_condattr_t *attr) 374 { 375 376 pthread__error(EINVAL, "Invalid condition variable attribute", 377 attr->ptca_magic == _PT_CONDATTR_MAGIC); 378 379 attr->ptca_magic = _PT_CONDATTR_DEAD; 380 free(attr->ptca_private); 381 382 return 0; 383 } 384 385 /* Utility routine to hang out for a while if threads haven't started yet. */ 386 static int 387 pthread_cond_wait_nothread(pthread_t self, pthread_mutex_t *mutex, 388 pthread_cond_t *cond, const struct timespec *abstime) 389 { 390 struct timespec now, diff; 391 int retval; 392 393 if (abstime == NULL) { 394 diff.tv_sec = 99999999; 395 diff.tv_nsec = 0; 396 } else { 397 clockid_t clck = pthread_cond_getclock(cond); 398 clock_gettime(clck, &now); 399 if (timespeccmp(abstime, &now, <)) 400 timespecclear(&diff); 401 else 402 timespecsub(abstime, &now, &diff); 403 } 404 405 do { 406 pthread__testcancel(self); 407 pthread_mutex_unlock(mutex); 408 retval = _sys___nanosleep50(&diff, NULL); 409 pthread_mutex_lock(mutex); 410 } while (abstime == NULL && retval == 0); 411 pthread__testcancel(self); 412 413 if (retval == 0) 414 return ETIMEDOUT; 415 else 416 /* spurious wakeup */ 417 return 0; 418 } 419