pthread_mutex.cpp revision 8641833b62e3b319796dc80ea16eb1592c05edf6
1/* 2 * Copyright (C) 2008 The Android Open Source Project 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * * Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * * Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in 12 * the documentation and/or other materials provided with the 13 * distribution. 14 * 15 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 16 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 17 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 18 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE 19 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 20 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 21 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS 22 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED 23 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 24 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT 25 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 26 * SUCH DAMAGE. 27 */ 28#include <sys/types.h> 29#include <unistd.h> 30#include <signal.h> 31#include <stdint.h> 32#include <stdio.h> 33#include <stdlib.h> 34#include <errno.h> 35#include <sys/atomics.h> 36#include <bionic_tls.h> 37#include <sys/mman.h> 38#include <pthread.h> 39#include <time.h> 40#include "pthread_internal.h" 41#include "thread_private.h" 42#include <limits.h> 43#include <memory.h> 44#include <assert.h> 45#include <malloc.h> 46 47extern int __pthread_clone(int (*fn)(void*), void *child_stack, int flags, void *arg); 48extern void _exit_with_stack_teardown(void * stackBase, int stackSize, int retCode); 49extern void _exit_thread(int retCode); 50extern int __set_errno(int); 51 52void _thread_created_hook(pid_t thread_id) __attribute__((noinline)); 53 54#define PTHREAD_ATTR_FLAG_DETACHED 0x00000001 55#define PTHREAD_ATTR_FLAG_USER_STACK 0x00000002 56 57#define DEFAULT_STACKSIZE (1024 * 1024) 58#define STACKBASE 0x10000000 59 60static uint8_t * gStackBase = (uint8_t *)STACKBASE; 61 62static pthread_mutex_t mmap_lock = PTHREAD_MUTEX_INITIALIZER; 63 64 65static const pthread_attr_t gDefaultPthreadAttr = { 66 .flags = 0, 67 .stack_base = NULL, 68 .stack_size = DEFAULT_STACKSIZE, 69 .guard_size = PAGE_SIZE, 70 .sched_policy = SCHED_NORMAL, 71 .sched_priority = 0 72}; 73 74#define INIT_THREADS 1 75 76static pthread_internal_t* gThreadList = NULL; 77static pthread_mutex_t gThreadListLock = PTHREAD_MUTEX_INITIALIZER; 78static pthread_mutex_t gDebuggerNotificationLock = PTHREAD_MUTEX_INITIALIZER; 79 80 81/* we simply malloc/free the internal pthread_internal_t structures. we may 82 * want to use a different allocation scheme in the future, but this one should 83 * be largely enough 84 */ 85static pthread_internal_t* 86_pthread_internal_alloc(void) 87{ 88 pthread_internal_t* thread; 89 90 thread = calloc( sizeof(*thread), 1 ); 91 if (thread) 92 thread->intern = 1; 93 94 return thread; 95} 96 97static void 98_pthread_internal_free( pthread_internal_t* thread ) 99{ 100 if (thread && thread->intern) { 101 thread->intern = 0; /* just in case */ 102 free (thread); 103 } 104} 105 106 107static void 108_pthread_internal_remove_locked( pthread_internal_t* thread ) 109{ 110 thread->next->pref = thread->pref; 111 thread->pref[0] = thread->next; 112} 113 114static void 115_pthread_internal_remove( pthread_internal_t* thread ) 116{ 117 pthread_mutex_lock(&gThreadListLock); 118 _pthread_internal_remove_locked(thread); 119 pthread_mutex_unlock(&gThreadListLock); 120} 121 122static void 123_pthread_internal_add( pthread_internal_t* thread ) 124{ 125 pthread_mutex_lock(&gThreadListLock); 126 thread->pref = &gThreadList; 127 thread->next = thread->pref[0]; 128 if (thread->next) 129 thread->next->pref = &thread->next; 130 thread->pref[0] = thread; 131 pthread_mutex_unlock(&gThreadListLock); 132} 133 134pthread_internal_t* 135__get_thread(void) 136{ 137 void** tls = (void**)__get_tls(); 138 139 return (pthread_internal_t*) tls[TLS_SLOT_THREAD_ID]; 140} 141 142 143void* 144__get_stack_base(int *p_stack_size) 145{ 146 pthread_internal_t* thread = __get_thread(); 147 148 *p_stack_size = thread->attr.stack_size; 149 return thread->attr.stack_base; 150} 151 152 153void __init_tls(void** tls, void* thread) 154{ 155 int nn; 156 157 ((pthread_internal_t*)thread)->tls = tls; 158 159 // slot 0 must point to the tls area, this is required by the implementation 160 // of the x86 Linux kernel thread-local-storage 161 tls[TLS_SLOT_SELF] = (void*)tls; 162 tls[TLS_SLOT_THREAD_ID] = thread; 163 for (nn = TLS_SLOT_ERRNO; nn < BIONIC_TLS_SLOTS; nn++) 164 tls[nn] = 0; 165 166 __set_tls( (void*)tls ); 167} 168 169 170/* 171 * This trampoline is called from the assembly clone() function 172 */ 173void __thread_entry(int (*func)(void*), void *arg, void **tls) 174{ 175 int retValue; 176 pthread_internal_t * thrInfo; 177 178 // Wait for our creating thread to release us. This lets it have time to 179 // notify gdb about this thread before it starts doing anything. 180 pthread_mutex_t * start_mutex = (pthread_mutex_t *)&tls[TLS_SLOT_SELF]; 181 pthread_mutex_lock(start_mutex); 182 pthread_mutex_destroy(start_mutex); 183 184 thrInfo = (pthread_internal_t *) tls[TLS_SLOT_THREAD_ID]; 185 186 __init_tls( tls, thrInfo ); 187 188 pthread_exit( (void*)func(arg) ); 189} 190 191void _init_thread(pthread_internal_t * thread, pid_t kernel_id, pthread_attr_t * attr, void * stack_base) 192{ 193 if (attr == NULL) { 194 thread->attr = gDefaultPthreadAttr; 195 } else { 196 thread->attr = *attr; 197 } 198 thread->attr.stack_base = stack_base; 199 thread->kernel_id = kernel_id; 200 201 // set the scheduling policy/priority of the thread 202 if (thread->attr.sched_policy != SCHED_NORMAL) { 203 struct sched_param param; 204 param.sched_priority = thread->attr.sched_priority; 205 sched_setscheduler(kernel_id, thread->attr.sched_policy, ¶m); 206 } 207 208 pthread_cond_init(&thread->join_cond, NULL); 209 thread->join_count = 0; 210 211 thread->cleanup_stack = NULL; 212 213 _pthread_internal_add(thread); 214} 215 216 217/* XXX stacks not reclaimed if thread spawn fails */ 218/* XXX stacks address spaces should be reused if available again */ 219 220static void *mkstack(size_t size, size_t guard_size) 221{ 222 void * stack; 223 224 pthread_mutex_lock(&mmap_lock); 225 226 stack = mmap((void *)gStackBase, size, 227 PROT_READ | PROT_WRITE, 228 MAP_PRIVATE | MAP_ANONYMOUS | MAP_NORESERVE, 229 -1, 0); 230 231 if(stack == MAP_FAILED) { 232 stack = NULL; 233 goto done; 234 } 235 236 if(mprotect(stack, guard_size, PROT_NONE)){ 237 munmap(stack, size); 238 stack = NULL; 239 goto done; 240 } 241 242done: 243 pthread_mutex_unlock(&mmap_lock); 244 return stack; 245} 246 247/* 248 * Create a new thread. The thread's stack is layed out like so: 249 * 250 * +---------------------------+ 251 * | pthread_internal_t | 252 * +---------------------------+ 253 * | | 254 * | TLS area | 255 * | | 256 * +---------------------------+ 257 * | | 258 * . . 259 * . stack area . 260 * . . 261 * | | 262 * +---------------------------+ 263 * | guard page | 264 * +---------------------------+ 265 * 266 * note that TLS[0] must be a pointer to itself, this is required 267 * by the thread-local storage implementation of the x86 Linux 268 * kernel, where the TLS pointer is read by reading fs:[0] 269 */ 270int pthread_create(pthread_t *thread_out, pthread_attr_t const * attr, 271 void *(*start_routine)(void *), void * arg) 272{ 273 char* stack; 274 void** tls; 275 int tid; 276 pthread_mutex_t * start_mutex; 277 pthread_internal_t * thread; 278 int madestack = 0; 279 int old_errno = errno; 280 281 /* this will inform the rest of the C library that at least one thread 282 * was created. this will enforce certain functions to acquire/release 283 * locks (e.g. atexit()) to protect shared global structures. 284 * 285 * this works because pthread_create() is not called by the C library 286 * initialization routine that sets up the main thread's data structures. 287 */ 288 __isthreaded = 1; 289 290 thread = _pthread_internal_alloc(); 291 if (thread == NULL) 292 return ENOMEM; 293 294 if (attr == NULL) { 295 attr = &gDefaultPthreadAttr; 296 } 297 298 // make sure the stack is PAGE_SIZE aligned 299 size_t stackSize = (attr->stack_size + 300 (PAGE_SIZE-1)) & ~(PAGE_SIZE-1); 301 302 if (!attr->stack_base) { 303 stack = mkstack(stackSize, attr->guard_size); 304 if(stack == NULL) { 305 _pthread_internal_free(thread); 306 return ENOMEM; 307 } 308 madestack = 1; 309 } else { 310 stack = attr->stack_base; 311 } 312 313 // Make room for TLS 314 tls = (void**)(stack + stackSize - BIONIC_TLS_SLOTS*sizeof(void*)); 315 316 // Create a mutex for the thread in TLS_SLOT_SELF to wait on once it starts so we can keep 317 // it from doing anything until after we notify the debugger about it 318 start_mutex = (pthread_mutex_t *) &tls[TLS_SLOT_SELF]; 319 pthread_mutex_init(start_mutex, NULL); 320 pthread_mutex_lock(start_mutex); 321 322 tls[TLS_SLOT_THREAD_ID] = thread; 323 324 tid = __pthread_clone((int(*)(void*))start_routine, tls, 325 CLONE_FILES | CLONE_FS | CLONE_VM | CLONE_SIGHAND 326 | CLONE_THREAD | CLONE_SYSVSEM | CLONE_DETACHED, 327 arg); 328 329 if(tid < 0) { 330 int result; 331 if (madestack) 332 munmap(stack, stackSize); 333 _pthread_internal_free(thread); 334 result = errno; 335 errno = old_errno; 336 return result; 337 } 338 339 _init_thread(thread, tid, (pthread_attr_t*)attr, stack); 340 341 if (!madestack) 342 thread->attr.flags |= PTHREAD_ATTR_FLAG_USER_STACK; 343 344 // Notify any debuggers about the new thread 345 pthread_mutex_lock(&gDebuggerNotificationLock); 346 _thread_created_hook(tid); 347 pthread_mutex_unlock(&gDebuggerNotificationLock); 348 349 // Let the thread do it's thing 350 pthread_mutex_unlock(start_mutex); 351 352 *thread_out = (pthread_t)thread; 353 return 0; 354} 355 356 357int pthread_attr_init(pthread_attr_t * attr) 358{ 359 *attr = gDefaultPthreadAttr; 360 return 0; 361} 362 363int pthread_attr_destroy(pthread_attr_t * attr) 364{ 365 memset(attr, 0x42, sizeof(pthread_attr_t)); 366 return 0; 367} 368 369int pthread_attr_setdetachstate(pthread_attr_t * attr, int state) 370{ 371 if (state == PTHREAD_CREATE_DETACHED) { 372 attr->flags |= PTHREAD_ATTR_FLAG_DETACHED; 373 } else if (state == PTHREAD_CREATE_JOINABLE) { 374 attr->flags &= ~PTHREAD_ATTR_FLAG_DETACHED; 375 } else { 376 return EINVAL; 377 } 378 return 0; 379} 380 381int pthread_attr_getdetachstate(pthread_attr_t const * attr, int * state) 382{ 383 *state = (attr->flags & PTHREAD_ATTR_FLAG_DETACHED) 384 ? PTHREAD_CREATE_DETACHED 385 : PTHREAD_CREATE_JOINABLE; 386 return 0; 387} 388 389int pthread_attr_setschedpolicy(pthread_attr_t * attr, int policy) 390{ 391 attr->sched_policy = policy; 392 return 0; 393} 394 395int pthread_attr_getschedpolicy(pthread_attr_t const * attr, int * policy) 396{ 397 *policy = attr->sched_policy; 398 return 0; 399} 400 401int pthread_attr_setschedparam(pthread_attr_t * attr, struct sched_param const * param) 402{ 403 attr->sched_priority = param->sched_priority; 404 return 0; 405} 406 407int pthread_attr_getschedparam(pthread_attr_t const * attr, struct sched_param * param) 408{ 409 param->sched_priority = attr->sched_priority; 410 return 0; 411} 412 413int pthread_attr_setstacksize(pthread_attr_t * attr, size_t stack_size) 414{ 415 if ((stack_size & (PAGE_SIZE - 1) || stack_size < PTHREAD_STACK_MIN)) { 416 return EINVAL; 417 } 418 attr->stack_size = stack_size; 419 return 0; 420} 421 422int pthread_attr_getstacksize(pthread_attr_t const * attr, size_t * stack_size) 423{ 424 *stack_size = attr->stack_size; 425 return 0; 426} 427 428int pthread_attr_setstackaddr(pthread_attr_t * attr, void * stack_addr) 429{ 430#if 1 431 // It's not clear if this is setting the top or bottom of the stack, so don't handle it for now. 432 return ENOSYS; 433#else 434 if ((uint32_t)stack_addr & (PAGE_SIZE - 1)) { 435 return EINVAL; 436 } 437 attr->stack_base = stack_addr; 438 return 0; 439#endif 440} 441 442int pthread_attr_getstackaddr(pthread_attr_t const * attr, void ** stack_addr) 443{ 444 *stack_addr = (char*)attr->stack_base + attr->stack_size; 445 return 0; 446} 447 448int pthread_attr_setstack(pthread_attr_t * attr, void * stack_base, size_t stack_size) 449{ 450 if ((stack_size & (PAGE_SIZE - 1) || stack_size < PTHREAD_STACK_MIN)) { 451 return EINVAL; 452 } 453 if ((uint32_t)stack_base & (PAGE_SIZE - 1)) { 454 return EINVAL; 455 } 456 attr->stack_base = stack_base; 457 attr->stack_size = stack_size; 458 return 0; 459} 460 461int pthread_attr_getstack(pthread_attr_t const * attr, void ** stack_base, size_t * stack_size) 462{ 463 *stack_base = attr->stack_base; 464 *stack_size = attr->stack_size; 465 return 0; 466} 467 468int pthread_attr_setguardsize(pthread_attr_t * attr, size_t guard_size) 469{ 470 if (guard_size & (PAGE_SIZE - 1) || guard_size < PAGE_SIZE) { 471 return EINVAL; 472 } 473 474 attr->guard_size = guard_size; 475 return 0; 476} 477 478int pthread_attr_getguardsize(pthread_attr_t const * attr, size_t * guard_size) 479{ 480 *guard_size = attr->guard_size; 481 return 0; 482} 483 484int pthread_getattr_np(pthread_t thid, pthread_attr_t * attr) 485{ 486 pthread_internal_t * thread = (pthread_internal_t *)thid; 487 *attr = thread->attr; 488 return 0; 489} 490 491int pthread_attr_setscope(pthread_attr_t *attr, int scope) 492{ 493 if (scope == PTHREAD_SCOPE_SYSTEM) 494 return 0; 495 if (scope == PTHREAD_SCOPE_PROCESS) 496 return ENOTSUP; 497 498 return EINVAL; 499} 500 501int pthread_attr_getscope(pthread_attr_t const *attr) 502{ 503 return PTHREAD_SCOPE_SYSTEM; 504} 505 506 507/* CAVEAT: our implementation of pthread_cleanup_push/pop doesn't support C++ exceptions 508 * and thread cancelation 509 */ 510 511void __pthread_cleanup_push( __pthread_cleanup_t* c, 512 __pthread_cleanup_func_t routine, 513 void* arg ) 514{ 515 pthread_internal_t* thread = __get_thread(); 516 517 c->__cleanup_routine = routine; 518 c->__cleanup_arg = arg; 519 c->__cleanup_prev = thread->cleanup_stack; 520 thread->cleanup_stack = c; 521} 522 523void __pthread_cleanup_pop( __pthread_cleanup_t* c, int execute ) 524{ 525 pthread_internal_t* thread = __get_thread(); 526 527 thread->cleanup_stack = c->__cleanup_prev; 528 if (execute) 529 c->__cleanup_routine(c->__cleanup_arg); 530} 531 532/* used by pthread_exit() to clean all TLS keys of the current thread */ 533static void pthread_key_clean_all(void); 534 535void pthread_exit(void * retval) 536{ 537 pthread_internal_t* thread = __get_thread(); 538 void* stack_base = thread->attr.stack_base; 539 int stack_size = thread->attr.stack_size; 540 int user_stack = (thread->attr.flags & PTHREAD_ATTR_FLAG_USER_STACK) != 0; 541 542 // call the cleanup handlers first 543 while (thread->cleanup_stack) { 544 __pthread_cleanup_t* c = thread->cleanup_stack; 545 thread->cleanup_stack = c->__cleanup_prev; 546 c->__cleanup_routine(c->__cleanup_arg); 547 } 548 549 // call the TLS destructors, it is important to do that before removing this 550 // thread from the global list. this will ensure that if someone else deletes 551 // a TLS key, the corresponding value will be set to NULL in this thread's TLS 552 // space (see pthread_key_delete) 553 pthread_key_clean_all(); 554 555 // if the thread is detached, destroy the pthread_internal_t 556 // otherwise, keep it in memory and signal any joiners 557 if (thread->attr.flags & PTHREAD_ATTR_FLAG_DETACHED) { 558 _pthread_internal_remove(thread); 559 _pthread_internal_free(thread); 560 } else { 561 /* the join_count field is used to store the number of threads waiting for 562 * the termination of this thread with pthread_join(), 563 * 564 * if it is positive we need to signal the waiters, and we do not touch 565 * the count (it will be decremented by the waiters, the last one will 566 * also remove/free the thread structure 567 * 568 * if it is zero, we set the count value to -1 to indicate that the 569 * thread is in 'zombie' state: it has stopped executing, and its stack 570 * is gone (as well as its TLS area). when another thread calls pthread_join() 571 * on it, it will immediately free the thread and return. 572 */ 573 pthread_mutex_lock(&gThreadListLock); 574 thread->return_value = retval; 575 if (thread->join_count > 0) { 576 pthread_cond_broadcast(&thread->join_cond); 577 } else { 578 thread->join_count = -1; /* zombie thread */ 579 } 580 pthread_mutex_unlock(&gThreadListLock); 581 } 582 583 // destroy the thread stack 584 if (user_stack) 585 _exit_thread((int)retval); 586 else 587 _exit_with_stack_teardown(stack_base, stack_size, (int)retval); 588} 589 590int pthread_join(pthread_t thid, void ** ret_val) 591{ 592 pthread_internal_t* thread = (pthread_internal_t*)thid; 593 int count; 594 595 // check that the thread still exists and is not detached 596 pthread_mutex_lock(&gThreadListLock); 597 598 for (thread = gThreadList; thread != NULL; thread = thread->next) 599 if (thread == (pthread_internal_t*)thid) 600 break; 601 602 if (!thread) { 603 pthread_mutex_unlock(&gThreadListLock); 604 return ESRCH; 605 } 606 607 if (thread->attr.flags & PTHREAD_ATTR_FLAG_DETACHED) { 608 pthread_mutex_unlock(&gThreadListLock); 609 return EINVAL; 610 } 611 612 /* wait for thread death when needed 613 * 614 * if the 'join_count' is negative, this is a 'zombie' thread that 615 * is already dead and without stack/TLS 616 * 617 * otherwise, we need to increment 'join-count' and wait to be signaled 618 */ 619 count = thread->join_count; 620 if (count >= 0) { 621 thread->join_count += 1; 622 pthread_cond_wait( &thread->join_cond, &gThreadListLock ); 623 count = --thread->join_count; 624 } 625 if (ret_val) 626 *ret_val = thread->return_value; 627 628 /* remove thread descriptor when we're the last joiner or when the 629 * thread was already a zombie. 630 */ 631 if (count <= 0) { 632 _pthread_internal_remove_locked(thread); 633 _pthread_internal_free(thread); 634 } 635 pthread_mutex_unlock(&gThreadListLock); 636 return 0; 637} 638 639int pthread_detach( pthread_t thid ) 640{ 641 pthread_internal_t* thread; 642 int result = 0; 643 int flags; 644 645 pthread_mutex_lock(&gThreadListLock); 646 for (thread = gThreadList; thread != NULL; thread = thread->next) 647 if (thread == (pthread_internal_t*)thid) 648 goto FoundIt; 649 650 result = ESRCH; 651 goto Exit; 652 653FoundIt: 654 do { 655 flags = thread->attr.flags; 656 657 if ( flags & PTHREAD_ATTR_FLAG_DETACHED ) { 658 /* thread is not joinable ! */ 659 result = EINVAL; 660 goto Exit; 661 } 662 } 663 while ( __atomic_cmpxchg( flags, flags | PTHREAD_ATTR_FLAG_DETACHED, 664 (volatile int*)&thread->attr.flags ) != 0 ); 665Exit: 666 pthread_mutex_unlock(&gThreadListLock); 667 return result; 668} 669 670pthread_t pthread_self(void) 671{ 672 return (pthread_t)__get_thread(); 673} 674 675int pthread_equal(pthread_t one, pthread_t two) 676{ 677 return (one == two ? 1 : 0); 678} 679 680int pthread_getschedparam(pthread_t thid, int * policy, 681 struct sched_param * param) 682{ 683 int old_errno = errno; 684 685 pthread_internal_t * thread = (pthread_internal_t *)thid; 686 int err = sched_getparam(thread->kernel_id, param); 687 if (!err) { 688 *policy = sched_getscheduler(thread->kernel_id); 689 } else { 690 err = errno; 691 errno = old_errno; 692 } 693 return err; 694} 695 696int pthread_setschedparam(pthread_t thid, int policy, 697 struct sched_param const * param) 698{ 699 pthread_internal_t * thread = (pthread_internal_t *)thid; 700 int old_errno = errno; 701 int ret; 702 703 ret = sched_setscheduler(thread->kernel_id, policy, param); 704 if (ret < 0) { 705 ret = errno; 706 errno = old_errno; 707 } 708 return ret; 709} 710 711 712int __futex_wait(volatile void *ftx, int val, const struct timespec *timeout); 713int __futex_wake(volatile void *ftx, int count); 714 715// mutex lock states 716// 717// 0: unlocked 718// 1: locked, no waiters 719// 2: locked, maybe waiters 720 721/* a mutex is implemented as a 32-bit integer holding the following fields 722 * 723 * bits: name description 724 * 31-16 tid owner thread's kernel id (recursive and errorcheck only) 725 * 15-14 type mutex type 726 * 13-2 counter counter of recursive mutexes 727 * 1-0 state lock state (0, 1 or 2) 728 */ 729 730 731#define MUTEX_OWNER(m) (((m)->value >> 16) & 0xffff) 732#define MUTEX_COUNTER(m) (((m)->value >> 2) & 0xfff) 733 734#define MUTEX_TYPE_MASK 0xc000 735#define MUTEX_TYPE_NORMAL 0x0000 736#define MUTEX_TYPE_RECURSIVE 0x4000 737#define MUTEX_TYPE_ERRORCHECK 0x8000 738 739#define MUTEX_COUNTER_SHIFT 2 740#define MUTEX_COUNTER_MASK 0x3ffc 741 742 743 744 745int pthread_mutexattr_init(pthread_mutexattr_t *attr) 746{ 747 if (attr) { 748 *attr = PTHREAD_MUTEX_DEFAULT; 749 return 0; 750 } else { 751 return EINVAL; 752 } 753} 754 755int pthread_mutexattr_destroy(pthread_mutexattr_t *attr) 756{ 757 if (attr) { 758 *attr = -1; 759 return 0; 760 } else { 761 return EINVAL; 762 } 763} 764 765int pthread_mutexattr_gettype(const pthread_mutexattr_t *attr, int *type) 766{ 767 if (attr && *attr >= PTHREAD_MUTEX_NORMAL && 768 *attr <= PTHREAD_MUTEX_ERRORCHECK ) { 769 *type = *attr; 770 return 0; 771 } 772 return EINVAL; 773} 774 775int pthread_mutexattr_settype(pthread_mutexattr_t *attr, int type) 776{ 777 if (attr && type >= PTHREAD_MUTEX_NORMAL && 778 type <= PTHREAD_MUTEX_ERRORCHECK ) { 779 *attr = type; 780 return 0; 781 } 782 return EINVAL; 783} 784 785/* process-shared mutexes are not supported at the moment */ 786 787int pthread_mutexattr_setpshared(pthread_mutexattr_t *attr, int pshared) 788{ 789 if (!attr) 790 return EINVAL; 791 792 switch (pshared) { 793 case PTHREAD_PROCESS_PRIVATE: 794 case PTHREAD_PROCESS_SHARED: 795 /* our current implementation of pthread actually supports shared 796 * mutexes but won't cleanup if a process dies with the mutex held. 797 * Nevertheless, it's better than nothing. Shared mutexes are used 798 * by surfaceflinger and audioflinger. 799 */ 800 return 0; 801 } 802 803 return ENOTSUP; 804} 805 806int pthread_mutexattr_getpshared(pthread_mutexattr_t *attr, int *pshared) 807{ 808 if (!attr) 809 return EINVAL; 810 811 *pshared = PTHREAD_PROCESS_PRIVATE; 812 return 0; 813} 814 815int pthread_mutex_init(pthread_mutex_t *mutex, 816 const pthread_mutexattr_t *attr) 817{ 818 if ( mutex ) { 819 if (attr == NULL) { 820 mutex->value = MUTEX_TYPE_NORMAL; 821 return 0; 822 } 823 switch ( *attr ) { 824 case PTHREAD_MUTEX_NORMAL: 825 mutex->value = MUTEX_TYPE_NORMAL; 826 return 0; 827 828 case PTHREAD_MUTEX_RECURSIVE: 829 mutex->value = MUTEX_TYPE_RECURSIVE; 830 return 0; 831 832 case PTHREAD_MUTEX_ERRORCHECK: 833 mutex->value = MUTEX_TYPE_ERRORCHECK; 834 return 0; 835 } 836 } 837 return EINVAL; 838} 839 840int pthread_mutex_destroy(pthread_mutex_t *mutex) 841{ 842 mutex->value = 0xdead10cc; 843 return 0; 844} 845 846 847/* 848 * Lock a non-recursive mutex. 849 * 850 * As noted above, there are three states: 851 * 0 (unlocked, no contention) 852 * 1 (locked, no contention) 853 * 2 (locked, contention) 854 * 855 * Non-recursive mutexes don't use the thread-id or counter fields, and the 856 * "type" value is zero, so the only bits that will be set are the ones in 857 * the lock state field. 858 */ 859static __inline__ void 860_normal_lock(pthread_mutex_t* mutex) 861{ 862 /* 863 * The common case is an unlocked mutex, so we begin by trying to 864 * change the lock's state from 0 to 1. __atomic_cmpxchg() returns 0 865 * if it made the swap successfully. If the result is nonzero, this 866 * lock is already held by another thread. 867 */ 868 if (__atomic_cmpxchg(0, 1, &mutex->value ) != 0) { 869 /* 870 * We want to go to sleep until the mutex is available, which 871 * requires promoting it to state 2. We need to swap in the new 872 * state value and then wait until somebody wakes us up. 873 * 874 * __atomic_swap() returns the previous value. We swap 2 in and 875 * see if we got zero back; if so, we have acquired the lock. If 876 * not, another thread still holds the lock and we wait again. 877 * 878 * The second argument to the __futex_wait() call is compared 879 * against the current value. If it doesn't match, __futex_wait() 880 * returns immediately (otherwise, it sleeps for a time specified 881 * by the third argument; 0 means sleep forever). This ensures 882 * that the mutex is in state 2 when we go to sleep on it, which 883 * guarantees a wake-up call. 884 */ 885 while (__atomic_swap(2, &mutex->value ) != 0) 886 __futex_wait(&mutex->value, 2, 0); 887 } 888} 889 890/* 891 * Release a non-recursive mutex. The caller is responsible for determining 892 * that we are in fact the owner of this lock. 893 */ 894static __inline__ void 895_normal_unlock(pthread_mutex_t* mutex) 896{ 897 /* 898 * The mutex value will be 1 or (rarely) 2. We use an atomic decrement 899 * to release the lock. __atomic_dec() returns the previous value; 900 * if it wasn't 1 we have to do some additional work. 901 */ 902 if (__atomic_dec(&mutex->value) != 1) { 903 /* 904 * Start by releasing the lock. The decrement changed it from 905 * "contended lock" to "uncontended lock", which means we still 906 * hold it, and anybody who tries to sneak in will push it back 907 * to state 2. 908 * 909 * Once we set it to zero the lock is up for grabs. We follow 910 * this with a __futex_wake() to ensure that one of the waiting 911 * threads has a chance to grab it. 912 * 913 * This doesn't cause a race with the swap/wait pair in 914 * _normal_lock(), because the __futex_wait() call there will 915 * return immediately if the mutex value isn't 2. 916 */ 917 mutex->value = 0; 918 919 /* 920 * Wake up one waiting thread. We don't know which thread will be 921 * woken or when it'll start executing -- futexes make no guarantees 922 * here. There may not even be a thread waiting. 923 * 924 * The newly-woken thread will replace the 0 we just set above 925 * with 2, which means that when it eventually releases the mutex 926 * it will also call FUTEX_WAKE. This results in one extra wake 927 * call whenever a lock is contended, but lets us avoid forgetting 928 * anyone without requiring us to track the number of sleepers. 929 * 930 * It's possible for another thread to sneak in and grab the lock 931 * between the zero assignment above and the wake call below. If 932 * the new thread is "slow" and holds the lock for a while, we'll 933 * wake up a sleeper, which will swap in a 2 and then go back to 934 * sleep since the lock is still held. If the new thread is "fast", 935 * running to completion before we call wake, the thread we 936 * eventually wake will find an unlocked mutex and will execute. 937 * Either way we have correct behavior and nobody is orphaned on 938 * the wait queue. 939 */ 940 __futex_wake(&mutex->value, 1); 941 } 942} 943 944static pthread_mutex_t __recursive_lock = PTHREAD_MUTEX_INITIALIZER; 945 946static void 947_recursive_lock(void) 948{ 949 _normal_lock( &__recursive_lock); 950} 951 952static void 953_recursive_unlock(void) 954{ 955 _normal_unlock( &__recursive_lock ); 956} 957 958#define __likely(cond) __builtin_expect(!!(cond), 1) 959#define __unlikely(cond) __builtin_expect(!!(cond), 0) 960 961int pthread_mutex_lock(pthread_mutex_t *mutex) 962{ 963 if (__likely(mutex != NULL)) 964 { 965 int mtype = (mutex->value & MUTEX_TYPE_MASK); 966 967 if ( __likely(mtype == MUTEX_TYPE_NORMAL) ) { 968 _normal_lock(mutex); 969 } 970 else 971 { 972 int tid = __get_thread()->kernel_id; 973 974 if ( tid == MUTEX_OWNER(mutex) ) 975 { 976 int oldv, counter; 977 978 if (mtype == MUTEX_TYPE_ERRORCHECK) { 979 /* trying to re-lock a mutex we already acquired */ 980 return EDEADLK; 981 } 982 /* 983 * We own the mutex, but other threads are able to change 984 * the contents (e.g. promoting it to "contended"), so we 985 * need to hold the global lock. 986 */ 987 _recursive_lock(); 988 oldv = mutex->value; 989 counter = (oldv + (1 << MUTEX_COUNTER_SHIFT)) & MUTEX_COUNTER_MASK; 990 mutex->value = (oldv & ~MUTEX_COUNTER_MASK) | counter; 991 _recursive_unlock(); 992 } 993 else 994 { 995 /* 996 * If the new lock is available immediately, we grab it in 997 * the "uncontended" state. 998 */ 999 int new_lock_type = 1; 1000 1001 for (;;) { 1002 int oldv; 1003 1004 _recursive_lock(); 1005 oldv = mutex->value; 1006 if (oldv == mtype) { /* uncontended released lock => 1 or 2 */ 1007 mutex->value = ((tid << 16) | mtype | new_lock_type); 1008 } else if ((oldv & 3) == 1) { /* locked state 1 => state 2 */ 1009 oldv ^= 3; 1010 mutex->value = oldv; 1011 } 1012 _recursive_unlock(); 1013 1014 if (oldv == mtype) 1015 break; 1016 1017 /* 1018 * The lock was held, possibly contended by others. From 1019 * now on, if we manage to acquire the lock, we have to 1020 * assume that others are still contending for it so that 1021 * we'll wake them when we unlock it. 1022 */ 1023 new_lock_type = 2; 1024 1025 __futex_wait( &mutex->value, oldv, 0 ); 1026 } 1027 } 1028 } 1029 return 0; 1030 } 1031 return EINVAL; 1032} 1033 1034 1035int pthread_mutex_unlock(pthread_mutex_t *mutex) 1036{ 1037 if (__likely(mutex != NULL)) 1038 { 1039 int mtype = (mutex->value & MUTEX_TYPE_MASK); 1040 1041 if (__likely(mtype == MUTEX_TYPE_NORMAL)) { 1042 _normal_unlock(mutex); 1043 } 1044 else 1045 { 1046 int tid = __get_thread()->kernel_id; 1047 1048 if ( tid == MUTEX_OWNER(mutex) ) 1049 { 1050 int oldv; 1051 1052 _recursive_lock(); 1053 oldv = mutex->value; 1054 if (oldv & MUTEX_COUNTER_MASK) { 1055 mutex->value = oldv - (1 << MUTEX_COUNTER_SHIFT); 1056 oldv = 0; 1057 } else { 1058 mutex->value = mtype; 1059 } 1060 _recursive_unlock(); 1061 1062 if ((oldv & 3) == 2) 1063 __futex_wake( &mutex->value, 1 ); 1064 } 1065 else { 1066 /* trying to unlock a lock we do not own */ 1067 return EPERM; 1068 } 1069 } 1070 return 0; 1071 } 1072 return EINVAL; 1073} 1074 1075 1076int pthread_mutex_trylock(pthread_mutex_t *mutex) 1077{ 1078 if (__likely(mutex != NULL)) 1079 { 1080 int mtype = (mutex->value & MUTEX_TYPE_MASK); 1081 1082 if ( __likely(mtype == MUTEX_TYPE_NORMAL) ) 1083 { 1084 if (__atomic_cmpxchg(0, 1, &mutex->value) == 0) 1085 return 0; 1086 1087 return EBUSY; 1088 } 1089 else 1090 { 1091 int tid = __get_thread()->kernel_id; 1092 int oldv; 1093 1094 if ( tid == MUTEX_OWNER(mutex) ) 1095 { 1096 int oldv, counter; 1097 1098 if (mtype == MUTEX_TYPE_ERRORCHECK) { 1099 /* already locked by ourselves */ 1100 return EDEADLK; 1101 } 1102 1103 _recursive_lock(); 1104 oldv = mutex->value; 1105 counter = (oldv + (1 << MUTEX_COUNTER_SHIFT)) & MUTEX_COUNTER_MASK; 1106 mutex->value = (oldv & ~MUTEX_COUNTER_MASK) | counter; 1107 _recursive_unlock(); 1108 return 0; 1109 } 1110 1111 /* try to lock it */ 1112 _recursive_lock(); 1113 oldv = mutex->value; 1114 if (oldv == mtype) /* uncontended released lock => state 1 */ 1115 mutex->value = ((tid << 16) | mtype | 1); 1116 _recursive_unlock(); 1117 1118 if (oldv != mtype) 1119 return EBUSY; 1120 1121 return 0; 1122 } 1123 } 1124 return EINVAL; 1125} 1126 1127 1128/* initialize 'ts' with the difference between 'abstime' and the current time 1129 * according to 'clock'. Returns -1 if abstime already expired, or 0 otherwise. 1130 */ 1131static int 1132__timespec_to_absolute(struct timespec* ts, const struct timespec* abstime, clockid_t clock) 1133{ 1134 clock_gettime(clock, ts); 1135 ts->tv_sec = abstime->tv_sec - ts->tv_sec; 1136 ts->tv_nsec = abstime->tv_nsec - ts->tv_nsec; 1137 if (ts->tv_nsec < 0) { 1138 ts->tv_sec--; 1139 ts->tv_nsec += 1000000000; 1140 } 1141 if ((ts->tv_nsec < 0) || (ts->tv_sec < 0)) 1142 return -1; 1143 1144 return 0; 1145} 1146 1147/* initialize 'abstime' to the current time according to 'clock' plus 'msecs' 1148 * milliseconds. 1149 */ 1150static void 1151__timespec_to_relative_msec(struct timespec* abstime, unsigned msecs, clockid_t clock) 1152{ 1153 clock_gettime(clock, abstime); 1154 abstime->tv_sec += msecs/1000; 1155 abstime->tv_nsec += (msecs%1000)*1000000; 1156 if (abstime->tv_nsec >= 1000000000) { 1157 abstime->tv_sec++; 1158 abstime->tv_nsec -= 1000000000; 1159 } 1160} 1161 1162int pthread_mutex_lock_timeout_np(pthread_mutex_t *mutex, unsigned msecs) 1163{ 1164 clockid_t clock = CLOCK_MONOTONIC; 1165 struct timespec abstime; 1166 struct timespec ts; 1167 1168 /* compute absolute expiration time */ 1169 __timespec_to_relative_msec(&abstime, msecs, clock); 1170 1171 if (__likely(mutex != NULL)) 1172 { 1173 int mtype = (mutex->value & MUTEX_TYPE_MASK); 1174 1175 if ( __likely(mtype == MUTEX_TYPE_NORMAL) ) 1176 { 1177 /* fast path for unconteded lock */ 1178 if (__atomic_cmpxchg(0, 1, &mutex->value) == 0) 1179 return 0; 1180 1181 /* loop while needed */ 1182 while (__atomic_swap(2, &mutex->value) != 0) { 1183 if (__timespec_to_absolute(&ts, &abstime, clock) < 0) 1184 return EBUSY; 1185 1186 __futex_wait(&mutex->value, 2, &ts); 1187 } 1188 return 0; 1189 } 1190 else 1191 { 1192 int tid = __get_thread()->kernel_id; 1193 int oldv; 1194 1195 if ( tid == MUTEX_OWNER(mutex) ) 1196 { 1197 int oldv, counter; 1198 1199 if (mtype == MUTEX_TYPE_ERRORCHECK) { 1200 /* already locked by ourselves */ 1201 return EDEADLK; 1202 } 1203 1204 _recursive_lock(); 1205 oldv = mutex->value; 1206 counter = (oldv + (1 << MUTEX_COUNTER_SHIFT)) & MUTEX_COUNTER_MASK; 1207 mutex->value = (oldv & ~MUTEX_COUNTER_MASK) | counter; 1208 _recursive_unlock(); 1209 return 0; 1210 } 1211 else 1212 { 1213 /* 1214 * If the new lock is available immediately, we grab it in 1215 * the "uncontended" state. 1216 */ 1217 int new_lock_type = 1; 1218 1219 for (;;) { 1220 int oldv; 1221 struct timespec ts; 1222 1223 _recursive_lock(); 1224 oldv = mutex->value; 1225 if (oldv == mtype) { /* uncontended released lock => 1 or 2 */ 1226 mutex->value = ((tid << 16) | mtype | new_lock_type); 1227 } else if ((oldv & 3) == 1) { /* locked state 1 => state 2 */ 1228 oldv ^= 3; 1229 mutex->value = oldv; 1230 } 1231 _recursive_unlock(); 1232 1233 if (oldv == mtype) 1234 break; 1235 1236 /* 1237 * The lock was held, possibly contended by others. From 1238 * now on, if we manage to acquire the lock, we have to 1239 * assume that others are still contending for it so that 1240 * we'll wake them when we unlock it. 1241 */ 1242 new_lock_type = 2; 1243 1244 if (__timespec_to_absolute(&ts, &abstime, clock) < 0) 1245 return EBUSY; 1246 1247 __futex_wait( &mutex->value, oldv, &ts ); 1248 } 1249 return 0; 1250 } 1251 } 1252 } 1253 return EINVAL; 1254} 1255 1256 1257/* XXX *technically* there is a race condition that could allow 1258 * XXX a signal to be missed. If thread A is preempted in _wait() 1259 * XXX after unlocking the mutex and before waiting, and if other 1260 * XXX threads call signal or broadcast UINT_MAX times (exactly), 1261 * XXX before thread A is scheduled again and calls futex_wait(), 1262 * XXX then the signal will be lost. 1263 */ 1264 1265int pthread_cond_init(pthread_cond_t *cond, 1266 const pthread_condattr_t *attr) 1267{ 1268 cond->value = 0; 1269 return 0; 1270} 1271 1272int pthread_cond_destroy(pthread_cond_t *cond) 1273{ 1274 cond->value = 0xdeadc04d; 1275 return 0; 1276} 1277 1278int pthread_cond_broadcast(pthread_cond_t *cond) 1279{ 1280 __atomic_dec(&cond->value); 1281 __futex_wake(&cond->value, INT_MAX); 1282 return 0; 1283} 1284 1285int pthread_cond_signal(pthread_cond_t *cond) 1286{ 1287 __atomic_dec(&cond->value); 1288 __futex_wake(&cond->value, 1); 1289 return 0; 1290} 1291 1292int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex) 1293{ 1294 return pthread_cond_timedwait(cond, mutex, NULL); 1295} 1296 1297int __pthread_cond_timedwait_relative(pthread_cond_t *cond, 1298 pthread_mutex_t * mutex, 1299 const struct timespec *reltime) 1300{ 1301 int status; 1302 int oldvalue = cond->value; 1303 1304 pthread_mutex_unlock(mutex); 1305 status = __futex_wait(&cond->value, oldvalue, reltime); 1306 pthread_mutex_lock(mutex); 1307 1308 if (status == (-ETIMEDOUT)) return ETIMEDOUT; 1309 return 0; 1310} 1311 1312int __pthread_cond_timedwait(pthread_cond_t *cond, 1313 pthread_mutex_t * mutex, 1314 const struct timespec *abstime, 1315 clockid_t clock) 1316{ 1317 struct timespec ts; 1318 struct timespec * tsp; 1319 1320 if (abstime != NULL) { 1321 if (__timespec_to_absolute(&ts, abstime, clock) < 0) 1322 return ETIMEDOUT; 1323 tsp = &ts; 1324 } else { 1325 tsp = NULL; 1326 } 1327 1328 return __pthread_cond_timedwait_relative(cond, mutex, tsp); 1329} 1330 1331int pthread_cond_timedwait(pthread_cond_t *cond, 1332 pthread_mutex_t * mutex, 1333 const struct timespec *abstime) 1334{ 1335 return __pthread_cond_timedwait(cond, mutex, abstime, CLOCK_REALTIME); 1336} 1337 1338 1339/* this one exists only for backward binary compatibility */ 1340int pthread_cond_timedwait_monotonic(pthread_cond_t *cond, 1341 pthread_mutex_t * mutex, 1342 const struct timespec *abstime) 1343{ 1344 return __pthread_cond_timedwait(cond, mutex, abstime, CLOCK_MONOTONIC); 1345} 1346 1347int pthread_cond_timedwait_monotonic_np(pthread_cond_t *cond, 1348 pthread_mutex_t * mutex, 1349 const struct timespec *abstime) 1350{ 1351 return __pthread_cond_timedwait(cond, mutex, abstime, CLOCK_MONOTONIC); 1352} 1353 1354int pthread_cond_timedwait_relative_np(pthread_cond_t *cond, 1355 pthread_mutex_t * mutex, 1356 const struct timespec *reltime) 1357{ 1358 return __pthread_cond_timedwait_relative(cond, mutex, reltime); 1359} 1360 1361int pthread_cond_timeout_np(pthread_cond_t *cond, 1362 pthread_mutex_t * mutex, 1363 unsigned msecs) 1364{ 1365 struct timespec ts; 1366 1367 ts.tv_sec = msecs / 1000; 1368 ts.tv_nsec = (msecs % 1000) * 1000000; 1369 1370 return __pthread_cond_timedwait_relative(cond, mutex, &ts); 1371} 1372 1373 1374 1375/* A technical note regarding our thread-local-storage (TLS) implementation: 1376 * 1377 * There can be up to TLSMAP_SIZE independent TLS keys in a given process, 1378 * though the first TLSMAP_START keys are reserved for Bionic to hold 1379 * special thread-specific variables like errno or a pointer to 1380 * the current thread's descriptor. 1381 * 1382 * while stored in the TLS area, these entries cannot be accessed through 1383 * pthread_getspecific() / pthread_setspecific() and pthread_key_delete() 1384 * 1385 * also, some entries in the key table are pre-allocated (see tlsmap_lock) 1386 * to greatly simplify and speedup some OpenGL-related operations. though the 1387 * initialy value will be NULL on all threads. 1388 * 1389 * you can use pthread_getspecific()/setspecific() on these, and in theory 1390 * you could also call pthread_key_delete() as well, though this would 1391 * probably break some apps. 1392 * 1393 * The 'tlsmap_t' type defined below implements a shared global map of 1394 * currently created/allocated TLS keys and the destructors associated 1395 * with them. You should use tlsmap_lock/unlock to access it to avoid 1396 * any race condition. 1397 * 1398 * the global TLS map simply contains a bitmap of allocated keys, and 1399 * an array of destructors. 1400 * 1401 * each thread has a TLS area that is a simple array of TLSMAP_SIZE void* 1402 * pointers. the TLS area of the main thread is stack-allocated in 1403 * __libc_init_common, while the TLS area of other threads is placed at 1404 * the top of their stack in pthread_create. 1405 * 1406 * when pthread_key_create() is called, it finds the first free key in the 1407 * bitmap, then set it to 1, saving the destructor altogether 1408 * 1409 * when pthread_key_delete() is called. it will erase the key's bitmap bit 1410 * and its destructor, and will also clear the key data in the TLS area of 1411 * all created threads. As mandated by Posix, it is the responsability of 1412 * the caller of pthread_key_delete() to properly reclaim the objects that 1413 * were pointed to by these data fields (either before or after the call). 1414 * 1415 */ 1416 1417/* TLS Map implementation 1418 */ 1419 1420#define TLSMAP_START (TLS_SLOT_MAX_WELL_KNOWN+1) 1421#define TLSMAP_SIZE BIONIC_TLS_SLOTS 1422#define TLSMAP_BITS 32 1423#define TLSMAP_WORDS ((TLSMAP_SIZE+TLSMAP_BITS-1)/TLSMAP_BITS) 1424#define TLSMAP_WORD(m,k) (m)->map[(k)/TLSMAP_BITS] 1425#define TLSMAP_MASK(k) (1U << ((k)&(TLSMAP_BITS-1))) 1426 1427/* this macro is used to quickly check that a key belongs to a reasonable range */ 1428#define TLSMAP_VALIDATE_KEY(key) \ 1429 ((key) >= TLSMAP_START && (key) < TLSMAP_SIZE) 1430 1431/* the type of tls key destructor functions */ 1432typedef void (*tls_dtor_t)(void*); 1433 1434typedef struct { 1435 int init; /* see comment in tlsmap_lock() */ 1436 uint32_t map[TLSMAP_WORDS]; /* bitmap of allocated keys */ 1437 tls_dtor_t dtors[TLSMAP_SIZE]; /* key destructors */ 1438} tlsmap_t; 1439 1440static pthread_mutex_t _tlsmap_lock = PTHREAD_MUTEX_INITIALIZER; 1441static tlsmap_t _tlsmap; 1442 1443/* lock the global TLS map lock and return a handle to it */ 1444static __inline__ tlsmap_t* tlsmap_lock(void) 1445{ 1446 tlsmap_t* m = &_tlsmap; 1447 1448 pthread_mutex_lock(&_tlsmap_lock); 1449 /* we need to initialize the first entry of the 'map' array 1450 * with the value TLS_DEFAULT_ALLOC_MAP. doing it statically 1451 * when declaring _tlsmap is a bit awkward and is going to 1452 * produce warnings, so do it the first time we use the map 1453 * instead 1454 */ 1455 if (__unlikely(!m->init)) { 1456 TLSMAP_WORD(m,0) = TLS_DEFAULT_ALLOC_MAP; 1457 m->init = 1; 1458 } 1459 return m; 1460} 1461 1462/* unlock the global TLS map */ 1463static __inline__ void tlsmap_unlock(tlsmap_t* m) 1464{ 1465 pthread_mutex_unlock(&_tlsmap_lock); 1466 (void)m; /* a good compiler is a happy compiler */ 1467} 1468 1469/* test to see wether a key is allocated */ 1470static __inline__ int tlsmap_test(tlsmap_t* m, int key) 1471{ 1472 return (TLSMAP_WORD(m,key) & TLSMAP_MASK(key)) != 0; 1473} 1474 1475/* set the destructor and bit flag on a newly allocated key */ 1476static __inline__ void tlsmap_set(tlsmap_t* m, int key, tls_dtor_t dtor) 1477{ 1478 TLSMAP_WORD(m,key) |= TLSMAP_MASK(key); 1479 m->dtors[key] = dtor; 1480} 1481 1482/* clear the destructor and bit flag on an existing key */ 1483static __inline__ void tlsmap_clear(tlsmap_t* m, int key) 1484{ 1485 TLSMAP_WORD(m,key) &= ~TLSMAP_MASK(key); 1486 m->dtors[key] = NULL; 1487} 1488 1489/* allocate a new TLS key, return -1 if no room left */ 1490static int tlsmap_alloc(tlsmap_t* m, tls_dtor_t dtor) 1491{ 1492 int key; 1493 1494 for ( key = TLSMAP_START; key < TLSMAP_SIZE; key++ ) { 1495 if ( !tlsmap_test(m, key) ) { 1496 tlsmap_set(m, key, dtor); 1497 return key; 1498 } 1499 } 1500 return -1; 1501} 1502 1503 1504int pthread_key_create(pthread_key_t *key, void (*destructor_function)(void *)) 1505{ 1506 uint32_t err = ENOMEM; 1507 tlsmap_t* map = tlsmap_lock(); 1508 int k = tlsmap_alloc(map, destructor_function); 1509 1510 if (k >= 0) { 1511 *key = k; 1512 err = 0; 1513 } 1514 tlsmap_unlock(map); 1515 return err; 1516} 1517 1518 1519/* This deletes a pthread_key_t. note that the standard mandates that this does 1520 * not call the destructor of non-NULL key values. Instead, it is the 1521 * responsability of the caller to properly dispose of the corresponding data 1522 * and resources, using any mean it finds suitable. 1523 * 1524 * On the other hand, this function will clear the corresponding key data 1525 * values in all known threads. this prevents later (invalid) calls to 1526 * pthread_getspecific() to receive invalid/stale values. 1527 */ 1528int pthread_key_delete(pthread_key_t key) 1529{ 1530 uint32_t err; 1531 pthread_internal_t* thr; 1532 tlsmap_t* map; 1533 1534 if (!TLSMAP_VALIDATE_KEY(key)) { 1535 return EINVAL; 1536 } 1537 1538 map = tlsmap_lock(); 1539 1540 if (!tlsmap_test(map, key)) { 1541 err = EINVAL; 1542 goto err1; 1543 } 1544 1545 /* clear value in all threads */ 1546 pthread_mutex_lock(&gThreadListLock); 1547 for ( thr = gThreadList; thr != NULL; thr = thr->next ) { 1548 /* avoid zombie threads with a negative 'join_count'. these are really 1549 * already dead and don't have a TLS area anymore. 1550 * 1551 * similarly, it is possible to have thr->tls == NULL for threads that 1552 * were just recently created through pthread_create() but whose 1553 * startup trampoline (__thread_entry) hasn't been run yet by the 1554 * scheduler. so check for this too. 1555 */ 1556 if (thr->join_count < 0 || !thr->tls) 1557 continue; 1558 1559 thr->tls[key] = NULL; 1560 } 1561 tlsmap_clear(map, key); 1562 1563 pthread_mutex_unlock(&gThreadListLock); 1564 err = 0; 1565 1566err1: 1567 tlsmap_unlock(map); 1568 return err; 1569} 1570 1571 1572int pthread_setspecific(pthread_key_t key, const void *ptr) 1573{ 1574 int err = EINVAL; 1575 tlsmap_t* map; 1576 1577 if (TLSMAP_VALIDATE_KEY(key)) { 1578 /* check that we're trying to set data for an allocated key */ 1579 map = tlsmap_lock(); 1580 if (tlsmap_test(map, key)) { 1581 ((uint32_t *)__get_tls())[key] = (uint32_t)ptr; 1582 err = 0; 1583 } 1584 tlsmap_unlock(map); 1585 } 1586 return err; 1587} 1588 1589void * pthread_getspecific(pthread_key_t key) 1590{ 1591 if (!TLSMAP_VALIDATE_KEY(key)) { 1592 return NULL; 1593 } 1594 1595 /* for performance reason, we do not lock/unlock the global TLS map 1596 * to check that the key is properly allocated. if the key was not 1597 * allocated, the value read from the TLS should always be NULL 1598 * due to pthread_key_delete() clearing the values for all threads. 1599 */ 1600 return (void *)(((unsigned *)__get_tls())[key]); 1601} 1602 1603/* Posix mandates that this be defined in <limits.h> but we don't have 1604 * it just yet. 1605 */ 1606#ifndef PTHREAD_DESTRUCTOR_ITERATIONS 1607# define PTHREAD_DESTRUCTOR_ITERATIONS 4 1608#endif 1609 1610/* this function is called from pthread_exit() to remove all TLS key data 1611 * from this thread's TLS area. this must call the destructor of all keys 1612 * that have a non-NULL data value (and a non-NULL destructor). 1613 * 1614 * because destructors can do funky things like deleting/creating other 1615 * keys, we need to implement this in a loop 1616 */ 1617static void pthread_key_clean_all(void) 1618{ 1619 tlsmap_t* map; 1620 void** tls = (void**)__get_tls(); 1621 int rounds = PTHREAD_DESTRUCTOR_ITERATIONS; 1622 1623 map = tlsmap_lock(); 1624 1625 for (rounds = PTHREAD_DESTRUCTOR_ITERATIONS; rounds > 0; rounds--) 1626 { 1627 int kk, count = 0; 1628 1629 for (kk = TLSMAP_START; kk < TLSMAP_SIZE; kk++) { 1630 if ( tlsmap_test(map, kk) ) 1631 { 1632 void* data = tls[kk]; 1633 tls_dtor_t dtor = map->dtors[kk]; 1634 1635 if (data != NULL && dtor != NULL) 1636 { 1637 /* we need to clear the key data now, this will prevent the 1638 * destructor (or a later one) from seeing the old value if 1639 * it calls pthread_getspecific() for some odd reason 1640 * 1641 * we do not do this if 'dtor == NULL' just in case another 1642 * destructor function might be responsible for manually 1643 * releasing the corresponding data. 1644 */ 1645 tls[kk] = NULL; 1646 1647 /* because the destructor is free to call pthread_key_create 1648 * and/or pthread_key_delete, we need to temporarily unlock 1649 * the TLS map 1650 */ 1651 tlsmap_unlock(map); 1652 (*dtor)(data); 1653 map = tlsmap_lock(); 1654 1655 count += 1; 1656 } 1657 } 1658 } 1659 1660 /* if we didn't call any destructor, there is no need to check the 1661 * TLS data again 1662 */ 1663 if (count == 0) 1664 break; 1665 } 1666 tlsmap_unlock(map); 1667} 1668 1669// man says this should be in <linux/unistd.h>, but it isn't 1670extern int tkill(int tid, int sig); 1671 1672int pthread_kill(pthread_t tid, int sig) 1673{ 1674 int ret; 1675 int old_errno = errno; 1676 pthread_internal_t * thread = (pthread_internal_t *)tid; 1677 1678 ret = tkill(thread->kernel_id, sig); 1679 if (ret < 0) { 1680 ret = errno; 1681 errno = old_errno; 1682 } 1683 1684 return ret; 1685} 1686 1687extern int __rt_sigprocmask(int, const sigset_t *, sigset_t *, size_t); 1688 1689int pthread_sigmask(int how, const sigset_t *set, sigset_t *oset) 1690{ 1691 /* pthread_sigmask must return the error code, but the syscall 1692 * will set errno instead and return 0/-1 1693 */ 1694 int ret, old_errno = errno; 1695 1696 ret = __rt_sigprocmask(how, set, oset, _NSIG / 8); 1697 if (ret < 0) 1698 ret = errno; 1699 1700 errno = old_errno; 1701 return ret; 1702} 1703 1704 1705int pthread_getcpuclockid(pthread_t tid, clockid_t *clockid) 1706{ 1707 const int CLOCK_IDTYPE_BITS = 3; 1708 pthread_internal_t* thread = (pthread_internal_t*)tid; 1709 1710 if (!thread) 1711 return ESRCH; 1712 1713 *clockid = CLOCK_THREAD_CPUTIME_ID | (thread->kernel_id << CLOCK_IDTYPE_BITS); 1714 return 0; 1715} 1716 1717 1718/* NOTE: this implementation doesn't support a init function that throws a C++ exception 1719 * or calls fork() 1720 */ 1721int pthread_once( pthread_once_t* once_control, void (*init_routine)(void) ) 1722{ 1723 static pthread_mutex_t once_lock = PTHREAD_MUTEX_INITIALIZER; 1724 1725 if (*once_control == PTHREAD_ONCE_INIT) { 1726 _normal_lock( &once_lock ); 1727 if (*once_control == PTHREAD_ONCE_INIT) { 1728 (*init_routine)(); 1729 *once_control = ~PTHREAD_ONCE_INIT; 1730 } 1731 _normal_unlock( &once_lock ); 1732 } 1733 return 0; 1734} 1735