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