1 /* 2 * Copyright (c) 1995 John Birrell <jb@cimlogic.com.au>. 3 * Copyright (c) 2006 David Xu <yfxu@corp.netease.com>. 4 * All rights reserved. 5 * 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions 8 * are met: 9 * 1. Redistributions of source code must retain the above copyright 10 * notice, this list of conditions and the following disclaimer. 11 * 2. Redistributions in binary form must reproduce the above copyright 12 * notice, this list of conditions and the following disclaimer in the 13 * documentation and/or other materials provided with the distribution. 14 * 3. All advertising materials mentioning features or use of this software 15 * must display the following acknowledgement: 16 * This product includes software developed by John Birrell. 17 * 4. Neither the name of the author nor the names of any co-contributors 18 * may be used to endorse or promote products derived from this software 19 * without specific prior written permission. 20 * 21 * THIS SOFTWARE IS PROVIDED BY JOHN BIRRELL AND CONTRIBUTORS ``AS IS'' AND 22 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 24 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 25 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 26 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 27 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 28 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 29 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 30 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 31 * SUCH DAMAGE. 32 * 33 * $DragonFly: src/lib/libthread_xu/thread/thr_mutex.c,v 1.14 2006/04/13 11:53:39 davidxu Exp $ 34 */ 35 36 #include "namespace.h" 37 #include <machine/tls.h> 38 39 #include <errno.h> 40 #include <stdlib.h> 41 #include <string.h> 42 #include <sys/queue.h> 43 #include <pthread.h> 44 #include "un-namespace.h" 45 46 #include "thr_private.h" 47 48 #if defined(_PTHREADS_INVARIANTS) 49 #define MUTEX_INIT_LINK(m) do { \ 50 (m)->m_qe.tqe_prev = NULL; \ 51 (m)->m_qe.tqe_next = NULL; \ 52 } while (0) 53 #define MUTEX_ASSERT_IS_OWNED(m) do { \ 54 if ((m)->m_qe.tqe_prev == NULL) \ 55 PANIC("mutex is not on list"); \ 56 } while (0) 57 #define MUTEX_ASSERT_NOT_OWNED(m) do { \ 58 if (((m)->m_qe.tqe_prev != NULL) || \ 59 ((m)->m_qe.tqe_next != NULL)) \ 60 PANIC("mutex is on list"); \ 61 } while (0) 62 #define THR_ASSERT_NOT_IN_SYNCQ(thr) do { \ 63 THR_ASSERT(((thr)->sflags & THR_FLAGS_IN_SYNCQ) == 0, \ 64 "thread in syncq when it shouldn't be."); \ 65 } while (0); 66 #else 67 #define MUTEX_INIT_LINK(m) 68 #define MUTEX_ASSERT_IS_OWNED(m) 69 #define MUTEX_ASSERT_NOT_OWNED(m) 70 #define THR_ASSERT_NOT_IN_SYNCQ(thr) 71 #endif 72 73 #define THR_IN_MUTEXQ(thr) (((thr)->sflags & THR_FLAGS_IN_SYNCQ) != 0) 74 #define MUTEX_DESTROY(m) do { \ 75 free(m); \ 76 } while (0) 77 78 umtx_t _mutex_static_lock; 79 80 /* 81 * Prototypes 82 */ 83 static int mutex_self_trylock(pthread_mutex_t); 84 static int mutex_self_lock(pthread_mutex_t, 85 const struct timespec *abstime); 86 static int mutex_unlock_common(pthread_mutex_t *); 87 88 int __pthread_mutex_init(pthread_mutex_t *mutex, 89 const pthread_mutexattr_t *mutex_attr); 90 int __pthread_mutex_trylock(pthread_mutex_t *mutex); 91 int __pthread_mutex_lock(pthread_mutex_t *mutex); 92 int __pthread_mutex_timedlock(pthread_mutex_t *mutex, 93 const struct timespec *abs_timeout); 94 95 static int 96 mutex_init(pthread_mutex_t *mutex, 97 const pthread_mutexattr_t *mutex_attr, int private) 98 { 99 const struct pthread_mutex_attr *attr; 100 struct pthread_mutex *pmutex; 101 102 if (mutex_attr == NULL) { 103 attr = &_pthread_mutexattr_default; 104 } else { 105 attr = *mutex_attr; 106 if (attr->m_type < PTHREAD_MUTEX_ERRORCHECK || 107 attr->m_type >= MUTEX_TYPE_MAX) 108 return (EINVAL); 109 if (attr->m_protocol < PTHREAD_PRIO_NONE || 110 attr->m_protocol > PTHREAD_PRIO_PROTECT) 111 return (EINVAL); 112 } 113 114 if ((pmutex = (pthread_mutex_t) 115 malloc(sizeof(struct pthread_mutex))) == NULL) 116 return (ENOMEM); 117 118 _thr_umtx_init(&pmutex->m_lock); 119 pmutex->m_type = attr->m_type; 120 pmutex->m_protocol = attr->m_protocol; 121 TAILQ_INIT(&pmutex->m_queue); 122 pmutex->m_owner = NULL; 123 pmutex->m_flags = attr->m_flags | MUTEX_FLAGS_INITED; 124 if (private) 125 pmutex->m_flags |= MUTEX_FLAGS_PRIVATE; 126 pmutex->m_count = 0; 127 pmutex->m_refcount = 0; 128 if (attr->m_protocol == PTHREAD_PRIO_PROTECT) 129 pmutex->m_prio = attr->m_ceiling; 130 else 131 pmutex->m_prio = -1; 132 pmutex->m_saved_prio = 0; 133 MUTEX_INIT_LINK(pmutex); 134 *mutex = pmutex; 135 return (0); 136 } 137 138 static int 139 init_static(struct pthread *thread, pthread_mutex_t *mutex) 140 { 141 int ret; 142 143 THR_LOCK_ACQUIRE(thread, &_mutex_static_lock); 144 145 if (*mutex == NULL) 146 ret = mutex_init(mutex, NULL, 0); 147 else 148 ret = 0; 149 150 THR_LOCK_RELEASE(thread, &_mutex_static_lock); 151 152 return (ret); 153 } 154 155 static int 156 init_static_private(struct pthread *thread, pthread_mutex_t *mutex) 157 { 158 int ret; 159 160 THR_LOCK_ACQUIRE(thread, &_mutex_static_lock); 161 162 if (*mutex == NULL) 163 ret = mutex_init(mutex, NULL, 1); 164 else 165 ret = 0; 166 167 THR_LOCK_RELEASE(thread, &_mutex_static_lock); 168 169 return (ret); 170 } 171 172 int 173 _pthread_mutex_init(pthread_mutex_t *mutex, 174 const pthread_mutexattr_t *mutex_attr) 175 { 176 return mutex_init(mutex, mutex_attr, 1); 177 } 178 179 int 180 __pthread_mutex_init(pthread_mutex_t *mutex, 181 const pthread_mutexattr_t *mutex_attr) 182 { 183 return mutex_init(mutex, mutex_attr, 0); 184 } 185 186 int 187 _mutex_reinit(pthread_mutex_t *mutex) 188 { 189 _thr_umtx_init(&(*mutex)->m_lock); 190 TAILQ_INIT(&(*mutex)->m_queue); 191 MUTEX_INIT_LINK(*mutex); 192 (*mutex)->m_owner = NULL; 193 (*mutex)->m_count = 0; 194 (*mutex)->m_refcount = 0; 195 (*mutex)->m_prio = 0; 196 (*mutex)->m_saved_prio = 0; 197 return (0); 198 } 199 200 void 201 _mutex_fork(struct pthread *curthread) 202 { 203 struct pthread_mutex *m; 204 205 TAILQ_FOREACH(m, &curthread->mutexq, m_qe) 206 m->m_lock = UMTX_LOCKED; 207 } 208 209 int 210 _pthread_mutex_destroy(pthread_mutex_t *mutex) 211 { 212 struct pthread *curthread = tls_get_curthread(); 213 pthread_mutex_t m; 214 int ret = 0; 215 216 if (mutex == NULL || *mutex == NULL) 217 ret = EINVAL; 218 else { 219 /* 220 * Try to lock the mutex structure, we only need to 221 * try once, if failed, the mutex is in used. 222 */ 223 ret = THR_UMTX_TRYLOCK(curthread, &(*mutex)->m_lock); 224 if (ret) 225 return (ret); 226 227 /* 228 * Check mutex other fields to see if this mutex is 229 * in use. Mostly for prority mutex types, or there 230 * are condition variables referencing it. 231 */ 232 if (((*mutex)->m_owner != NULL) || 233 (TAILQ_FIRST(&(*mutex)->m_queue) != NULL) || 234 ((*mutex)->m_refcount != 0)) { 235 THR_UMTX_UNLOCK(curthread, &(*mutex)->m_lock); 236 ret = EBUSY; 237 } else { 238 /* 239 * Save a pointer to the mutex so it can be free'd 240 * and set the caller's pointer to NULL: 241 */ 242 m = *mutex; 243 *mutex = NULL; 244 245 /* Unlock the mutex structure: */ 246 THR_UMTX_UNLOCK(curthread, &m->m_lock); 247 248 /* 249 * Free the memory allocated for the mutex 250 * structure: 251 */ 252 MUTEX_ASSERT_NOT_OWNED(m); 253 MUTEX_DESTROY(m); 254 } 255 } 256 257 /* Return the completion status: */ 258 return (ret); 259 } 260 261 static int 262 mutex_trylock_common(struct pthread *curthread, pthread_mutex_t *mutex) 263 { 264 struct pthread_mutex *m; 265 int ret; 266 267 m = *mutex; 268 ret = THR_UMTX_TRYLOCK(curthread, &m->m_lock); 269 if (ret == 0) { 270 m->m_owner = curthread; 271 /* Add to the list of owned mutexes: */ 272 MUTEX_ASSERT_NOT_OWNED(m); 273 TAILQ_INSERT_TAIL(&curthread->mutexq, 274 m, m_qe); 275 } else if (m->m_owner == curthread) { 276 ret = mutex_self_trylock(m); 277 } /* else {} */ 278 279 return (ret); 280 } 281 282 int 283 __pthread_mutex_trylock(pthread_mutex_t *m) 284 { 285 struct pthread *curthread = tls_get_curthread(); 286 int ret; 287 288 /* 289 * If the mutex is statically initialized, perform the dynamic 290 * initialization: 291 */ 292 if (__predict_false(*m == NULL)) { 293 ret = init_static(curthread, m); 294 if (__predict_false(ret != 0)) 295 return (ret); 296 } 297 return (mutex_trylock_common(curthread, m)); 298 } 299 300 int 301 _pthread_mutex_trylock(pthread_mutex_t *m) 302 { 303 struct pthread *curthread = tls_get_curthread(); 304 int ret = 0; 305 306 /* 307 * If the mutex is statically initialized, perform the dynamic 308 * initialization marking the mutex private (delete safe): 309 */ 310 if (__predict_false(*m == NULL)) { 311 ret = init_static_private(curthread, m); 312 if (__predict_false(ret != 0)) 313 return (ret); 314 } 315 return (mutex_trylock_common(curthread, m)); 316 } 317 318 static int 319 mutex_lock_common(struct pthread *curthread, pthread_mutex_t *mutex, 320 const struct timespec * abstime) 321 { 322 struct timespec ts, ts2; 323 struct pthread_mutex *m; 324 int ret = 0; 325 326 m = *mutex; 327 ret = THR_UMTX_TRYLOCK(curthread, &m->m_lock); 328 if (ret == 0) { 329 m->m_owner = curthread; 330 /* Add to the list of owned mutexes: */ 331 MUTEX_ASSERT_NOT_OWNED(m); 332 TAILQ_INSERT_TAIL(&curthread->mutexq, 333 m, m_qe); 334 } else if (m->m_owner == curthread) { 335 ret = mutex_self_lock(m, abstime); 336 } else { 337 if (abstime == NULL) { 338 THR_UMTX_LOCK(curthread, &m->m_lock); 339 ret = 0; 340 } else if (__predict_false( 341 abstime->tv_sec < 0 || abstime->tv_nsec < 0 || 342 abstime->tv_nsec >= 1000000000)) { 343 ret = EINVAL; 344 } else { 345 clock_gettime(CLOCK_REALTIME, &ts); 346 TIMESPEC_SUB(&ts2, abstime, &ts); 347 ret = THR_UMTX_TIMEDLOCK(curthread, 348 &m->m_lock, &ts2); 349 /* 350 * Timed out wait is not restarted if 351 * it was interrupted, not worth to do it. 352 */ 353 if (ret == EINTR) 354 ret = ETIMEDOUT; 355 } 356 if (ret == 0) { 357 m->m_owner = curthread; 358 /* Add to the list of owned mutexes: */ 359 MUTEX_ASSERT_NOT_OWNED(m); 360 TAILQ_INSERT_TAIL(&curthread->mutexq, 361 m, m_qe); 362 } 363 } 364 return (ret); 365 } 366 367 int 368 __pthread_mutex_lock(pthread_mutex_t *m) 369 { 370 struct pthread *curthread; 371 int ret; 372 373 _thr_check_init(); 374 375 curthread = tls_get_curthread(); 376 377 /* 378 * If the mutex is statically initialized, perform the dynamic 379 * initialization: 380 */ 381 if (__predict_false(*m == NULL)) { 382 ret = init_static(curthread, m); 383 if (__predict_false(ret)) 384 return (ret); 385 } 386 return (mutex_lock_common(curthread, m, NULL)); 387 } 388 389 int 390 _pthread_mutex_lock(pthread_mutex_t *m) 391 { 392 struct pthread *curthread; 393 int ret; 394 395 _thr_check_init(); 396 397 curthread = tls_get_curthread(); 398 399 /* 400 * If the mutex is statically initialized, perform the dynamic 401 * initialization marking it private (delete safe): 402 */ 403 if (__predict_false(*m == NULL)) { 404 ret = init_static_private(curthread, m); 405 if (__predict_false(ret)) 406 return (ret); 407 } 408 return (mutex_lock_common(curthread, m, NULL)); 409 } 410 411 int 412 __pthread_mutex_timedlock(pthread_mutex_t *m, 413 const struct timespec *abs_timeout) 414 { 415 struct pthread *curthread; 416 int ret; 417 418 _thr_check_init(); 419 420 curthread = tls_get_curthread(); 421 422 /* 423 * If the mutex is statically initialized, perform the dynamic 424 * initialization: 425 */ 426 if (__predict_false(*m == NULL)) { 427 ret = init_static(curthread, m); 428 if (__predict_false(ret)) 429 return (ret); 430 } 431 return (mutex_lock_common(curthread, m, abs_timeout)); 432 } 433 434 int 435 _pthread_mutex_timedlock(pthread_mutex_t *m, 436 const struct timespec *abs_timeout) 437 { 438 struct pthread *curthread; 439 int ret; 440 441 _thr_check_init(); 442 443 curthread = tls_get_curthread(); 444 445 /* 446 * If the mutex is statically initialized, perform the dynamic 447 * initialization marking it private (delete safe): 448 */ 449 if (__predict_false(*m == NULL)) { 450 ret = init_static_private(curthread, m); 451 if (__predict_false(ret)) 452 return (ret); 453 } 454 return (mutex_lock_common(curthread, m, abs_timeout)); 455 } 456 457 int 458 _pthread_mutex_unlock(pthread_mutex_t *m) 459 { 460 return (mutex_unlock_common(m)); 461 } 462 463 static int 464 mutex_self_trylock(pthread_mutex_t m) 465 { 466 int ret; 467 468 switch (m->m_type) { 469 /* case PTHREAD_MUTEX_DEFAULT: */ 470 case PTHREAD_MUTEX_ERRORCHECK: 471 case PTHREAD_MUTEX_NORMAL: 472 ret = EBUSY; 473 break; 474 475 case PTHREAD_MUTEX_RECURSIVE: 476 /* Increment the lock count: */ 477 if (m->m_count + 1 > 0) { 478 m->m_count++; 479 ret = 0; 480 } else 481 ret = EAGAIN; 482 break; 483 484 default: 485 /* Trap invalid mutex types; */ 486 ret = EINVAL; 487 } 488 489 return (ret); 490 } 491 492 static int 493 mutex_self_lock(pthread_mutex_t m, const struct timespec *abstime) 494 { 495 struct timespec ts1, ts2; 496 int ret; 497 498 switch (m->m_type) { 499 /* case PTHREAD_MUTEX_DEFAULT: */ 500 case PTHREAD_MUTEX_ERRORCHECK: 501 if (abstime) { 502 clock_gettime(CLOCK_REALTIME, &ts1); 503 TIMESPEC_SUB(&ts2, abstime, &ts1); 504 __sys_nanosleep(&ts2, NULL); 505 ret = ETIMEDOUT; 506 } else { 507 /* 508 * POSIX specifies that mutexes should return 509 * EDEADLK if a recursive lock is detected. 510 */ 511 ret = EDEADLK; 512 } 513 break; 514 515 case PTHREAD_MUTEX_NORMAL: 516 /* 517 * What SS2 define as a 'normal' mutex. Intentionally 518 * deadlock on attempts to get a lock you already own. 519 */ 520 ret = 0; 521 if (abstime) { 522 clock_gettime(CLOCK_REALTIME, &ts1); 523 TIMESPEC_SUB(&ts2, abstime, &ts1); 524 __sys_nanosleep(&ts2, NULL); 525 ret = ETIMEDOUT; 526 } else { 527 ts1.tv_sec = 30; 528 ts1.tv_nsec = 0; 529 for (;;) 530 __sys_nanosleep(&ts1, NULL); 531 } 532 break; 533 534 case PTHREAD_MUTEX_RECURSIVE: 535 /* Increment the lock count: */ 536 if (m->m_count + 1 > 0) { 537 m->m_count++; 538 ret = 0; 539 } else 540 ret = EAGAIN; 541 break; 542 543 default: 544 /* Trap invalid mutex types; */ 545 ret = EINVAL; 546 } 547 548 return (ret); 549 } 550 551 static int 552 mutex_unlock_common(pthread_mutex_t *mutex) 553 { 554 struct pthread *curthread = tls_get_curthread(); 555 struct pthread_mutex *m; 556 557 if (__predict_false((m = *mutex)== NULL)) 558 return (EINVAL); 559 560 if (__predict_false(m->m_owner != curthread)) 561 return (EPERM); 562 563 if (__predict_false( 564 m->m_type == PTHREAD_MUTEX_RECURSIVE && 565 m->m_count > 0)) { 566 m->m_count--; 567 } else { 568 /* 569 * Clear the count in case this is a recursive mutex. 570 */ 571 m->m_count = 0; 572 m->m_owner = NULL; 573 /* Remove the mutex from the threads queue. */ 574 MUTEX_ASSERT_IS_OWNED(m); 575 TAILQ_REMOVE(&curthread->mutexq, m, m_qe); 576 MUTEX_INIT_LINK(m); 577 /* 578 * Hand off the mutex to the next waiting thread. 579 */ 580 THR_UMTX_UNLOCK(curthread, &m->m_lock); 581 } 582 return (0); 583 } 584 585 int 586 _mutex_cv_lock(pthread_mutex_t *m, int count) 587 { 588 int ret; 589 590 if ((ret = _pthread_mutex_lock(m)) == 0) { 591 (*m)->m_refcount--; 592 (*m)->m_count += count; 593 } 594 return (ret); 595 } 596 597 int 598 _mutex_cv_unlock(pthread_mutex_t *mutex, int *count) 599 { 600 struct pthread *curthread = tls_get_curthread(); 601 struct pthread_mutex *m; 602 603 if (__predict_false((m = *mutex)== NULL)) 604 return (EINVAL); 605 606 if (__predict_false(m->m_owner != curthread)) 607 return (EPERM); 608 609 *count = m->m_count; 610 m->m_count = 0; 611 m->m_refcount++; 612 m->m_owner = NULL; 613 /* Remove the mutex from the threads queue. */ 614 MUTEX_ASSERT_IS_OWNED(m); 615 TAILQ_REMOVE(&curthread->mutexq, m, m_qe); 616 MUTEX_INIT_LINK(m); 617 THR_UMTX_UNLOCK(curthread, &m->m_lock); 618 return (0); 619 } 620 621 void 622 _mutex_unlock_private(pthread_t pthread) 623 { 624 struct pthread_mutex *m, *m_next; 625 626 for (m = TAILQ_FIRST(&pthread->mutexq); m != NULL; m = m_next) { 627 m_next = TAILQ_NEXT(m, m_qe); 628 if ((m->m_flags & MUTEX_FLAGS_PRIVATE) != 0) 629 _pthread_mutex_unlock(&m); 630 } 631 } 632 633 __strong_reference(__pthread_mutex_init, pthread_mutex_init); 634 __strong_reference(__pthread_mutex_lock, pthread_mutex_lock); 635 __strong_reference(__pthread_mutex_timedlock, pthread_mutex_timedlock); 636 __strong_reference(__pthread_mutex_trylock, pthread_mutex_trylock); 637 638 /* Single underscore versions provided for libc internal usage: */ 639 /* No difference between libc and application usage of these: */ 640 __strong_reference(_pthread_mutex_destroy, pthread_mutex_destroy); 641 __strong_reference(_pthread_mutex_unlock, pthread_mutex_unlock); 642