1 /* $NetBSD: pthread_mutex.c,v 1.21 2005/10/19 02:15:03 chs Exp $ */ 2 3 /*- 4 * Copyright (c) 2001, 2003 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 by Jason R. Thorpe. 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 * 3. All advertising materials mentioning features or use of this software 19 * must display the following acknowledgement: 20 * This product includes software developed by the NetBSD 21 * Foundation, Inc. and its contributors. 22 * 4. Neither the name of The NetBSD Foundation nor the names of its 23 * contributors may be used to endorse or promote products derived 24 * from this software without specific prior written permission. 25 * 26 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 27 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 28 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 29 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 30 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 31 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 32 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 33 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 34 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 35 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 36 * POSSIBILITY OF SUCH DAMAGE. 37 */ 38 39 #include <sys/cdefs.h> 40 __RCSID("$NetBSD: pthread_mutex.c,v 1.21 2005/10/19 02:15:03 chs Exp $"); 41 42 #include <errno.h> 43 #include <limits.h> 44 #include <stdlib.h> 45 #include <string.h> 46 47 #include "pthread.h" 48 #include "pthread_int.h" 49 50 static int pthread_mutex_lock_slow(pthread_mutex_t *); 51 52 __strong_alias(__libc_mutex_init,pthread_mutex_init) 53 __strong_alias(__libc_mutex_lock,pthread_mutex_lock) 54 __strong_alias(__libc_mutex_trylock,pthread_mutex_trylock) 55 __strong_alias(__libc_mutex_unlock,pthread_mutex_unlock) 56 __strong_alias(__libc_mutex_destroy,pthread_mutex_destroy) 57 58 __strong_alias(__libc_mutexattr_init,pthread_mutexattr_init) 59 __strong_alias(__libc_mutexattr_destroy,pthread_mutexattr_destroy) 60 __strong_alias(__libc_mutexattr_settype,pthread_mutexattr_settype) 61 62 __strong_alias(__libc_thr_once,pthread_once) 63 64 struct mutex_private { 65 int type; 66 int recursecount; 67 }; 68 69 static const struct mutex_private mutex_private_default = { 70 PTHREAD_MUTEX_DEFAULT, 71 0, 72 }; 73 74 struct mutexattr_private { 75 int type; 76 }; 77 78 static const struct mutexattr_private mutexattr_private_default = { 79 PTHREAD_MUTEX_DEFAULT, 80 }; 81 82 /* 83 * If the mutex does not already have private data (i.e. was statically 84 * initialized), then give it the default. 85 */ 86 #define GET_MUTEX_PRIVATE(mutex, mp) \ 87 do { \ 88 if (__predict_false((mp = (mutex)->ptm_private) == NULL)) { \ 89 /* LINTED cast away const */ \ 90 mp = ((mutex)->ptm_private = \ 91 (void *)&mutex_private_default); \ 92 } \ 93 } while (/*CONSTCOND*/0) 94 95 int 96 pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr) 97 { 98 struct mutexattr_private *map; 99 struct mutex_private *mp; 100 101 pthread__error(EINVAL, "Invalid mutex attribute", 102 (attr == NULL) || (attr->ptma_magic == _PT_MUTEXATTR_MAGIC)); 103 104 if (attr != NULL && (map = attr->ptma_private) != NULL && 105 memcmp(map, &mutexattr_private_default, sizeof(*map)) != 0) { 106 mp = malloc(sizeof(*mp)); 107 if (mp == NULL) 108 return ENOMEM; 109 110 mp->type = map->type; 111 mp->recursecount = 0; 112 } else { 113 /* LINTED cast away const */ 114 mp = (struct mutex_private *) &mutex_private_default; 115 } 116 117 mutex->ptm_magic = _PT_MUTEX_MAGIC; 118 mutex->ptm_owner = NULL; 119 pthread_lockinit(&mutex->ptm_lock); 120 pthread_lockinit(&mutex->ptm_interlock); 121 PTQ_INIT(&mutex->ptm_blocked); 122 mutex->ptm_private = mp; 123 124 return 0; 125 } 126 127 128 int 129 pthread_mutex_destroy(pthread_mutex_t *mutex) 130 { 131 132 pthread__error(EINVAL, "Invalid mutex", 133 mutex->ptm_magic == _PT_MUTEX_MAGIC); 134 pthread__error(EBUSY, "Destroying locked mutex", 135 mutex->ptm_lock == __SIMPLELOCK_UNLOCKED); 136 137 mutex->ptm_magic = _PT_MUTEX_DEAD; 138 if (mutex->ptm_private != NULL && 139 mutex->ptm_private != (const void *)&mutex_private_default) 140 free(mutex->ptm_private); 141 142 return 0; 143 } 144 145 146 /* 147 * Note regarding memory visibility: Pthreads has rules about memory 148 * visibility and mutexes. Very roughly: Memory a thread can see when 149 * it unlocks a mutex can be seen by another thread that locks the 150 * same mutex. 151 * 152 * A memory barrier after a lock and before an unlock will provide 153 * this behavior. This code relies on pthread__simple_lock_try() to issue 154 * a barrier after obtaining a lock, and on pthread__simple_unlock() to 155 * issue a barrier before releasing a lock. 156 */ 157 158 int 159 pthread_mutex_lock(pthread_mutex_t *mutex) 160 { 161 int error; 162 163 PTHREADD_ADD(PTHREADD_MUTEX_LOCK); 164 /* 165 * Note that if we get the lock, we don't have to deal with any 166 * non-default lock type handling. 167 */ 168 if (__predict_false(pthread__simple_lock_try(&mutex->ptm_lock) == 0)) { 169 error = pthread_mutex_lock_slow(mutex); 170 if (error) 171 return error; 172 } 173 174 /* We have the lock! */ 175 /* 176 * Identifying ourselves may be slow, and this assignment is 177 * only needed for (a) debugging identity of the owning thread 178 * and (b) handling errorcheck and recursive mutexes. It's 179 * better to just stash our stack pointer here and let those 180 * slow exception cases compute the stack->thread mapping. 181 */ 182 mutex->ptm_owner = (pthread_t)pthread__sp(); 183 184 return 0; 185 } 186 187 188 static int 189 pthread_mutex_lock_slow(pthread_mutex_t *mutex) 190 { 191 pthread_t self; 192 extern int pthread__started; 193 194 pthread__error(EINVAL, "Invalid mutex", 195 mutex->ptm_magic == _PT_MUTEX_MAGIC); 196 197 self = pthread__self(); 198 199 PTHREADD_ADD(PTHREADD_MUTEX_LOCK_SLOW); 200 while (/*CONSTCOND*/1) { 201 if (pthread__simple_lock_try(&mutex->ptm_lock)) 202 break; /* got it! */ 203 204 /* Okay, didn't look free. Get the interlock... */ 205 pthread_spinlock(self, &mutex->ptm_interlock); 206 207 /* 208 * The mutex_unlock routine will get the interlock 209 * before looking at the list of sleepers, so if the 210 * lock is held we can safely put ourselves on the 211 * sleep queue. If it's not held, we can try taking it 212 * again. 213 */ 214 PTQ_INSERT_HEAD(&mutex->ptm_blocked, self, pt_sleep); 215 if (mutex->ptm_lock == __SIMPLELOCK_LOCKED) { 216 struct mutex_private *mp; 217 218 GET_MUTEX_PRIVATE(mutex, mp); 219 220 if (pthread__id(mutex->ptm_owner) == self) { 221 switch (mp->type) { 222 case PTHREAD_MUTEX_ERRORCHECK: 223 PTQ_REMOVE(&mutex->ptm_blocked, self, 224 pt_sleep); 225 pthread_spinunlock(self, 226 &mutex->ptm_interlock); 227 return EDEADLK; 228 229 case PTHREAD_MUTEX_RECURSIVE: 230 /* 231 * It's safe to do this without 232 * holding the interlock, because 233 * we only modify it if we know we 234 * own the mutex. 235 */ 236 PTQ_REMOVE(&mutex->ptm_blocked, self, 237 pt_sleep); 238 pthread_spinunlock(self, 239 &mutex->ptm_interlock); 240 if (mp->recursecount == INT_MAX) 241 return EAGAIN; 242 mp->recursecount++; 243 return 0; 244 } 245 } 246 247 if (pthread__started == 0) { 248 sigset_t ss; 249 250 /* 251 * The spec says we must deadlock, so... 252 */ 253 pthread__assert(mp->type == 254 PTHREAD_MUTEX_NORMAL); 255 (void) sigprocmask(SIG_SETMASK, NULL, &ss); 256 for (;;) { 257 sigsuspend(&ss); 258 } 259 /*NOTREACHED*/ 260 } 261 262 /* 263 * Locking a mutex is not a cancellation 264 * point, so we don't need to do the 265 * test-cancellation dance. We may get woken 266 * up spuriously by pthread_cancel or signals, 267 * but it's okay since we're just going to 268 * retry. 269 */ 270 pthread_spinlock(self, &self->pt_statelock); 271 self->pt_state = PT_STATE_BLOCKED_QUEUE; 272 self->pt_sleepobj = mutex; 273 self->pt_sleepq = &mutex->ptm_blocked; 274 self->pt_sleeplock = &mutex->ptm_interlock; 275 pthread_spinunlock(self, &self->pt_statelock); 276 277 pthread__block(self, &mutex->ptm_interlock); 278 /* interlock is not held when we return */ 279 } else { 280 PTQ_REMOVE(&mutex->ptm_blocked, self, pt_sleep); 281 pthread_spinunlock(self, &mutex->ptm_interlock); 282 } 283 /* Go around for another try. */ 284 } 285 286 return 0; 287 } 288 289 290 int 291 pthread_mutex_trylock(pthread_mutex_t *mutex) 292 { 293 294 pthread__error(EINVAL, "Invalid mutex", 295 mutex->ptm_magic == _PT_MUTEX_MAGIC); 296 297 PTHREADD_ADD(PTHREADD_MUTEX_TRYLOCK); 298 if (pthread__simple_lock_try(&mutex->ptm_lock) == 0) { 299 struct mutex_private *mp; 300 301 GET_MUTEX_PRIVATE(mutex, mp); 302 303 /* 304 * These tests can be performed without holding the 305 * interlock because these fields are only modified 306 * if we know we own the mutex. 307 */ 308 if ((mp->type == PTHREAD_MUTEX_RECURSIVE) && 309 (pthread__id(mutex->ptm_owner) == pthread__self())) { 310 if (mp->recursecount == INT_MAX) 311 return EAGAIN; 312 mp->recursecount++; 313 return 0; 314 } 315 316 return EBUSY; 317 } 318 319 /* see comment at the end of pthread_mutex_lock() */ 320 mutex->ptm_owner = (pthread_t)pthread__sp(); 321 322 return 0; 323 } 324 325 326 int 327 pthread_mutex_unlock(pthread_mutex_t *mutex) 328 { 329 struct mutex_private *mp; 330 pthread_t self, blocked; 331 int weown; 332 333 pthread__error(EINVAL, "Invalid mutex", 334 mutex->ptm_magic == _PT_MUTEX_MAGIC); 335 336 PTHREADD_ADD(PTHREADD_MUTEX_UNLOCK); 337 338 GET_MUTEX_PRIVATE(mutex, mp); 339 340 /* 341 * These tests can be performed without holding the 342 * interlock because these fields are only modified 343 * if we know we own the mutex. 344 */ 345 weown = (pthread__id(mutex->ptm_owner) == pthread__self()); 346 switch (mp->type) { 347 case PTHREAD_MUTEX_RECURSIVE: 348 if (!weown) 349 return EPERM; 350 if (mp->recursecount != 0) { 351 mp->recursecount--; 352 return 0; 353 } 354 break; 355 case PTHREAD_MUTEX_ERRORCHECK: 356 if (!weown) 357 return EPERM; 358 /*FALLTHROUGH*/ 359 default: 360 if (__predict_false(!weown)) { 361 pthread__error(EPERM, "Unlocking unlocked mutex", 362 (mutex->ptm_owner != 0)); 363 pthread__error(EPERM, 364 "Unlocking mutex owned by another thread", weown); 365 } 366 break; 367 } 368 369 mutex->ptm_owner = NULL; 370 pthread__simple_unlock(&mutex->ptm_lock); 371 /* 372 * Do a double-checked locking dance to see if there are any 373 * waiters. If we don't see any waiters, we can exit, because 374 * we've already released the lock. If we do see waiters, they 375 * were probably waiting on us... there's a slight chance that 376 * they are waiting on a different thread's ownership of the 377 * lock that happened between the unlock above and this 378 * examination of the queue; if so, no harm is done, as the 379 * waiter will loop and see that the mutex is still locked. 380 */ 381 if (!PTQ_EMPTY(&mutex->ptm_blocked)) { 382 self = pthread__self(); 383 pthread_spinlock(self, &mutex->ptm_interlock); 384 blocked = PTQ_FIRST(&mutex->ptm_blocked); 385 if (blocked) { 386 PTQ_REMOVE(&mutex->ptm_blocked, blocked, pt_sleep); 387 PTHREADD_ADD(PTHREADD_MUTEX_UNLOCK_UNBLOCK); 388 /* Give the head of the blocked queue another try. */ 389 pthread__sched(self, blocked); 390 } 391 pthread_spinunlock(self, &mutex->ptm_interlock); 392 } 393 return 0; 394 } 395 396 int 397 pthread_mutexattr_init(pthread_mutexattr_t *attr) 398 { 399 struct mutexattr_private *map; 400 401 map = malloc(sizeof(*map)); 402 if (map == NULL) 403 return ENOMEM; 404 405 *map = mutexattr_private_default; 406 407 attr->ptma_magic = _PT_MUTEXATTR_MAGIC; 408 attr->ptma_private = map; 409 410 return 0; 411 } 412 413 414 int 415 pthread_mutexattr_destroy(pthread_mutexattr_t *attr) 416 { 417 418 pthread__error(EINVAL, "Invalid mutex attribute", 419 attr->ptma_magic == _PT_MUTEXATTR_MAGIC); 420 421 attr->ptma_magic = _PT_MUTEXATTR_DEAD; 422 if (attr->ptma_private != NULL) 423 free(attr->ptma_private); 424 425 return 0; 426 } 427 428 429 int 430 pthread_mutexattr_gettype(const pthread_mutexattr_t *attr, int *typep) 431 { 432 struct mutexattr_private *map; 433 434 pthread__error(EINVAL, "Invalid mutex attribute", 435 attr->ptma_magic == _PT_MUTEXATTR_MAGIC); 436 437 map = attr->ptma_private; 438 439 *typep = map->type; 440 441 return 0; 442 } 443 444 445 int 446 pthread_mutexattr_settype(pthread_mutexattr_t *attr, int type) 447 { 448 struct mutexattr_private *map; 449 450 pthread__error(EINVAL, "Invalid mutex attribute", 451 attr->ptma_magic == _PT_MUTEXATTR_MAGIC); 452 453 map = attr->ptma_private; 454 455 switch (type) { 456 case PTHREAD_MUTEX_NORMAL: 457 case PTHREAD_MUTEX_ERRORCHECK: 458 case PTHREAD_MUTEX_RECURSIVE: 459 map->type = type; 460 break; 461 462 default: 463 return EINVAL; 464 } 465 466 return 0; 467 } 468 469 470 static void 471 once_cleanup(void *closure) 472 { 473 474 pthread_mutex_unlock((pthread_mutex_t *)closure); 475 } 476 477 478 int 479 pthread_once(pthread_once_t *once_control, void (*routine)(void)) 480 { 481 482 if (once_control->pto_done == 0) { 483 pthread_mutex_lock(&once_control->pto_mutex); 484 pthread_cleanup_push(&once_cleanup, &once_control->pto_mutex); 485 if (once_control->pto_done == 0) { 486 routine(); 487 once_control->pto_done = 1; 488 } 489 pthread_cleanup_pop(1); 490 } 491 492 return 0; 493 } 494