1 /* $NetBSD: pthread.c,v 1.111 2009/06/25 13:38:43 joerg Exp $ */ 2 3 /*- 4 * Copyright (c) 2001, 2002, 2003, 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 #include <sys/cdefs.h> 33 __RCSID("$NetBSD: pthread.c,v 1.111 2009/06/25 13:38:43 joerg Exp $"); 34 35 #define __EXPOSE_STACK 1 36 37 #include <sys/param.h> 38 #include <sys/mman.h> 39 #include <sys/sysctl.h> 40 #include <sys/lwpctl.h> 41 42 #include <err.h> 43 #include <errno.h> 44 #include <lwp.h> 45 #include <signal.h> 46 #include <stdio.h> 47 #include <stdlib.h> 48 #include <string.h> 49 #include <syslog.h> 50 #include <ucontext.h> 51 #include <unistd.h> 52 #include <sched.h> 53 54 #include "pthread.h" 55 #include "pthread_int.h" 56 57 pthread_rwlock_t pthread__alltree_lock = PTHREAD_RWLOCK_INITIALIZER; 58 RB_HEAD(__pthread__alltree, __pthread_st) pthread__alltree; 59 60 #ifndef lint 61 static int pthread__cmp(struct __pthread_st *, struct __pthread_st *); 62 RB_PROTOTYPE_STATIC(__pthread__alltree, __pthread_st, pt_alltree, pthread__cmp) 63 #endif 64 65 static void pthread__create_tramp(void *); 66 static void pthread__initthread(pthread_t); 67 static void pthread__scrubthread(pthread_t, char *, int); 68 static int pthread__stackid_setup(void *, size_t, pthread_t *); 69 static int pthread__stackalloc(pthread_t *); 70 static void pthread__initmain(pthread_t *); 71 static void pthread__fork_callback(void); 72 static void pthread__reap(pthread_t); 73 static void pthread__child_callback(void); 74 static void pthread__start(void); 75 76 void pthread__init(void); 77 78 int pthread__started; 79 pthread_mutex_t pthread__deadqueue_lock = PTHREAD_MUTEX_INITIALIZER; 80 pthread_queue_t pthread__deadqueue; 81 pthread_queue_t pthread__allqueue; 82 83 static pthread_attr_t pthread_default_attr; 84 static lwpctl_t pthread__dummy_lwpctl = { .lc_curcpu = LWPCTL_CPU_NONE }; 85 static pthread_t pthread__first; 86 87 enum { 88 DIAGASSERT_ABORT = 1<<0, 89 DIAGASSERT_STDERR = 1<<1, 90 DIAGASSERT_SYSLOG = 1<<2 91 }; 92 93 static int pthread__diagassert; 94 95 int pthread__concurrency; 96 int pthread__nspins; 97 int pthread__unpark_max = PTHREAD__UNPARK_MAX; 98 99 /* 100 * We have to initialize the pthread_stack* variables here because 101 * mutexes are used before pthread_init() and thus pthread__initmain() 102 * are called. Since mutexes only save the stack pointer and not a 103 * pointer to the thread data, it is safe to change the mapping from 104 * stack pointer to thread data afterwards. 105 */ 106 #define _STACKSIZE_LG 18 107 int pthread__stacksize_lg = _STACKSIZE_LG; 108 size_t pthread__stacksize = 1 << _STACKSIZE_LG; 109 vaddr_t pthread__stackmask = (1 << _STACKSIZE_LG) - 1; 110 vaddr_t pthread__threadmask = (vaddr_t)~((1 << _STACKSIZE_LG) - 1); 111 #undef _STACKSIZE_LG 112 113 int _sys___sigprocmask14(int, const sigset_t *, sigset_t *); 114 115 __strong_alias(__libc_thr_self,pthread_self) 116 __strong_alias(__libc_thr_create,pthread_create) 117 __strong_alias(__libc_thr_exit,pthread_exit) 118 __strong_alias(__libc_thr_errno,pthread__errno) 119 __strong_alias(__libc_thr_setcancelstate,pthread_setcancelstate) 120 __strong_alias(__libc_thr_equal,pthread_equal) 121 __strong_alias(__libc_thr_init,pthread__init) 122 123 /* 124 * Static library kludge. Place a reference to a symbol any library 125 * file which does not already have a reference here. 126 */ 127 extern int pthread__cancel_stub_binder; 128 129 void *pthread__static_lib_binder[] = { 130 &pthread__cancel_stub_binder, 131 pthread_cond_init, 132 pthread_mutex_init, 133 pthread_rwlock_init, 134 pthread_barrier_init, 135 pthread_key_create, 136 pthread_setspecific, 137 }; 138 139 #define NHASHLOCK 64 140 141 static union hashlock { 142 pthread_mutex_t mutex; 143 char pad[64]; 144 } hashlocks[NHASHLOCK] __aligned(64); 145 146 /* 147 * This needs to be started by the library loading code, before main() 148 * gets to run, for various things that use the state of the initial thread 149 * to work properly (thread-specific data is an application-visible example; 150 * spinlock counts for mutexes is an internal example). 151 */ 152 void 153 pthread__init(void) 154 { 155 pthread_t first; 156 char *p; 157 int i, mib[2]; 158 size_t len; 159 extern int __isthreaded; 160 161 mib[0] = CTL_HW; 162 mib[1] = HW_NCPU; 163 164 len = sizeof(pthread__concurrency); 165 if (sysctl(mib, 2, &pthread__concurrency, &len, NULL, 0) == -1) 166 err(1, "sysctl(hw.ncpu"); 167 168 mib[0] = CTL_KERN; 169 mib[1] = KERN_OSREV; 170 171 /* Initialize locks first; they're needed elsewhere. */ 172 pthread__lockprim_init(); 173 for (i = 0; i < NHASHLOCK; i++) { 174 pthread_mutex_init(&hashlocks[i].mutex, NULL); 175 } 176 177 /* Fetch parameters. */ 178 i = (int)_lwp_unpark_all(NULL, 0, NULL); 179 if (i == -1) 180 err(1, "_lwp_unpark_all"); 181 if (i < pthread__unpark_max) 182 pthread__unpark_max = i; 183 184 /* Basic data structure setup */ 185 pthread_attr_init(&pthread_default_attr); 186 PTQ_INIT(&pthread__allqueue); 187 PTQ_INIT(&pthread__deadqueue); 188 RB_INIT(&pthread__alltree); 189 190 /* Create the thread structure corresponding to main() */ 191 pthread__initmain(&first); 192 pthread__initthread(first); 193 pthread__scrubthread(first, NULL, 0); 194 195 first->pt_lid = _lwp_self(); 196 PTQ_INSERT_HEAD(&pthread__allqueue, first, pt_allq); 197 RB_INSERT(__pthread__alltree, &pthread__alltree, first); 198 199 if (_lwp_ctl(LWPCTL_FEATURE_CURCPU, &first->pt_lwpctl) != 0) { 200 err(1, "_lwp_ctl"); 201 } 202 203 /* Start subsystems */ 204 PTHREAD_MD_INIT 205 206 for (p = pthread__getenv("PTHREAD_DIAGASSERT"); p && *p; p++) { 207 switch (*p) { 208 case 'a': 209 pthread__diagassert |= DIAGASSERT_ABORT; 210 break; 211 case 'A': 212 pthread__diagassert &= ~DIAGASSERT_ABORT; 213 break; 214 case 'e': 215 pthread__diagassert |= DIAGASSERT_STDERR; 216 break; 217 case 'E': 218 pthread__diagassert &= ~DIAGASSERT_STDERR; 219 break; 220 case 'l': 221 pthread__diagassert |= DIAGASSERT_SYSLOG; 222 break; 223 case 'L': 224 pthread__diagassert &= ~DIAGASSERT_SYSLOG; 225 break; 226 } 227 } 228 229 /* Tell libc that we're here and it should role-play accordingly. */ 230 pthread__first = first; 231 pthread_atfork(NULL, NULL, pthread__fork_callback); 232 __isthreaded = 1; 233 } 234 235 static void 236 pthread__fork_callback(void) 237 { 238 239 /* lwpctl state is not copied across fork. */ 240 if (_lwp_ctl(LWPCTL_FEATURE_CURCPU, &pthread__first->pt_lwpctl)) { 241 err(1, "_lwp_ctl"); 242 } 243 } 244 245 static void 246 pthread__child_callback(void) 247 { 248 249 /* 250 * Clean up data structures that a forked child process might 251 * trip over. Note that if threads have been created (causing 252 * this handler to be registered) the standards say that the 253 * child will trigger undefined behavior if it makes any 254 * pthread_* calls (or any other calls that aren't 255 * async-signal-safe), so we don't really have to clean up 256 * much. Anything that permits some pthread_* calls to work is 257 * merely being polite. 258 */ 259 pthread__started = 0; 260 } 261 262 static void 263 pthread__start(void) 264 { 265 266 /* 267 * Per-process timers are cleared by fork(); despite the 268 * various restrictions on fork() and threads, it's legal to 269 * fork() before creating any threads. 270 */ 271 pthread_atfork(NULL, NULL, pthread__child_callback); 272 } 273 274 275 /* General-purpose thread data structure sanitization. */ 276 /* ARGSUSED */ 277 static void 278 pthread__initthread(pthread_t t) 279 { 280 281 t->pt_self = t; 282 t->pt_magic = PT_MAGIC; 283 t->pt_willpark = 0; 284 t->pt_unpark = 0; 285 t->pt_nwaiters = 0; 286 t->pt_sleepobj = NULL; 287 t->pt_signalled = 0; 288 t->pt_havespecific = 0; 289 t->pt_early = NULL; 290 t->pt_lwpctl = &pthread__dummy_lwpctl; 291 t->pt_blocking = 0; 292 t->pt_droplock = NULL; 293 294 memcpy(&t->pt_lockops, pthread__lock_ops, sizeof(t->pt_lockops)); 295 pthread_mutex_init(&t->pt_lock, NULL); 296 PTQ_INIT(&t->pt_cleanup_stack); 297 pthread_cond_init(&t->pt_joiners, NULL); 298 memset(&t->pt_specific, 0, sizeof(t->pt_specific)); 299 } 300 301 static void 302 pthread__scrubthread(pthread_t t, char *name, int flags) 303 { 304 305 t->pt_state = PT_STATE_RUNNING; 306 t->pt_exitval = NULL; 307 t->pt_flags = flags; 308 t->pt_cancel = 0; 309 t->pt_errno = 0; 310 t->pt_name = name; 311 t->pt_lid = 0; 312 } 313 314 315 int 316 pthread_create(pthread_t *thread, const pthread_attr_t *attr, 317 void *(*startfunc)(void *), void *arg) 318 { 319 pthread_t newthread; 320 pthread_attr_t nattr; 321 struct pthread_attr_private *p; 322 char * volatile name; 323 unsigned long flag; 324 int ret; 325 326 /* 327 * It's okay to check this without a lock because there can 328 * only be one thread before it becomes true. 329 */ 330 if (pthread__started == 0) { 331 pthread__start(); 332 pthread__started = 1; 333 } 334 335 if (attr == NULL) 336 nattr = pthread_default_attr; 337 else if (attr->pta_magic == PT_ATTR_MAGIC) 338 nattr = *attr; 339 else 340 return EINVAL; 341 342 /* Fetch misc. attributes from the attr structure. */ 343 name = NULL; 344 if ((p = nattr.pta_private) != NULL) 345 if (p->ptap_name[0] != '\0') 346 if ((name = strdup(p->ptap_name)) == NULL) 347 return ENOMEM; 348 349 newthread = NULL; 350 351 /* 352 * Try to reclaim a dead thread. 353 */ 354 if (!PTQ_EMPTY(&pthread__deadqueue)) { 355 pthread_mutex_lock(&pthread__deadqueue_lock); 356 newthread = PTQ_FIRST(&pthread__deadqueue); 357 if (newthread != NULL) { 358 PTQ_REMOVE(&pthread__deadqueue, newthread, pt_deadq); 359 pthread_mutex_unlock(&pthread__deadqueue_lock); 360 /* Still running? */ 361 if (newthread->pt_lwpctl->lc_curcpu != 362 LWPCTL_CPU_EXITED && 363 (_lwp_kill(newthread->pt_lid, 0) == 0 || 364 errno != ESRCH)) { 365 pthread_mutex_lock(&pthread__deadqueue_lock); 366 PTQ_INSERT_TAIL(&pthread__deadqueue, 367 newthread, pt_deadq); 368 pthread_mutex_unlock(&pthread__deadqueue_lock); 369 newthread = NULL; 370 } 371 } else 372 pthread_mutex_unlock(&pthread__deadqueue_lock); 373 } 374 375 /* 376 * If necessary set up a stack, allocate space for a pthread_st, 377 * and initialize it. 378 */ 379 if (newthread == NULL) { 380 ret = pthread__stackalloc(&newthread); 381 if (ret != 0) { 382 if (name) 383 free(name); 384 return ret; 385 } 386 387 /* This is used only when creating the thread. */ 388 _INITCONTEXT_U(&newthread->pt_uc); 389 #ifdef PTHREAD_MACHINE_HAS_ID_REGISTER 390 pthread__uc_id(&newthread->pt_uc) = newthread; 391 #endif 392 newthread->pt_uc.uc_stack = newthread->pt_stack; 393 newthread->pt_uc.uc_link = NULL; 394 395 /* Add to list of all threads. */ 396 pthread_rwlock_wrlock(&pthread__alltree_lock); 397 PTQ_INSERT_TAIL(&pthread__allqueue, newthread, pt_allq); 398 RB_INSERT(__pthread__alltree, &pthread__alltree, newthread); 399 pthread_rwlock_unlock(&pthread__alltree_lock); 400 401 /* Will be reset by the thread upon exit. */ 402 pthread__initthread(newthread); 403 } 404 405 /* 406 * Create the new LWP. 407 */ 408 pthread__scrubthread(newthread, name, nattr.pta_flags); 409 newthread->pt_func = startfunc; 410 newthread->pt_arg = arg; 411 #if 0 412 _lwp_makecontext(&newthread->pt_uc, pthread__create_tramp, 413 newthread, newthread, newthread->pt_stack.ss_sp, 414 newthread->pt_stack.ss_size); 415 #else 416 makecontext(&newthread->pt_uc, pthread__create_tramp, 1, 417 newthread); 418 #endif 419 420 flag = LWP_DETACHED; 421 if ((newthread->pt_flags & PT_FLAG_SUSPENDED) != 0 || 422 (nattr.pta_flags & PT_FLAG_EXPLICIT_SCHED) != 0) 423 flag |= LWP_SUSPENDED; 424 ret = _lwp_create(&newthread->pt_uc, flag, &newthread->pt_lid); 425 if (ret != 0) { 426 free(name); 427 newthread->pt_state = PT_STATE_DEAD; 428 pthread_mutex_lock(&pthread__deadqueue_lock); 429 PTQ_INSERT_HEAD(&pthread__deadqueue, newthread, pt_deadq); 430 pthread_mutex_unlock(&pthread__deadqueue_lock); 431 return ret; 432 } 433 434 if ((nattr.pta_flags & PT_FLAG_EXPLICIT_SCHED) != 0) { 435 if (p != NULL) { 436 (void)pthread_setschedparam(newthread, p->ptap_policy, 437 &p->ptap_sp); 438 } 439 if ((newthread->pt_flags & PT_FLAG_SUSPENDED) == 0) { 440 (void)_lwp_continue(newthread->pt_lid); 441 } 442 } 443 444 *thread = newthread; 445 446 return 0; 447 } 448 449 450 static void 451 pthread__create_tramp(void *cookie) 452 { 453 pthread_t self; 454 void *retval; 455 456 self = cookie; 457 458 /* 459 * Throw away some stack in a feeble attempt to reduce cache 460 * thrash. May help for SMT processors. XXX We should not 461 * be allocating stacks on fixed 2MB boundaries. Needs a 462 * thread register or decent thread local storage. 463 * 464 * Note that we may race with the kernel in _lwp_create(), 465 * and so pt_lid can be unset at this point, but we don't 466 * care. 467 */ 468 (void)alloca(((unsigned)self->pt_lid & 7) << 8); 469 470 if (self->pt_name != NULL) { 471 pthread_mutex_lock(&self->pt_lock); 472 if (self->pt_name != NULL) 473 (void)_lwp_setname(0, self->pt_name); 474 pthread_mutex_unlock(&self->pt_lock); 475 } 476 477 if (_lwp_ctl(LWPCTL_FEATURE_CURCPU, &self->pt_lwpctl)) { 478 err(1, "_lwp_ctl"); 479 } 480 481 retval = (*self->pt_func)(self->pt_arg); 482 483 pthread_exit(retval); 484 485 /*NOTREACHED*/ 486 pthread__abort(); 487 } 488 489 int 490 pthread_suspend_np(pthread_t thread) 491 { 492 pthread_t self; 493 494 self = pthread__self(); 495 if (self == thread) { 496 return EDEADLK; 497 } 498 if (pthread__find(thread) != 0) 499 return ESRCH; 500 if (_lwp_suspend(thread->pt_lid) == 0) 501 return 0; 502 return errno; 503 } 504 505 int 506 pthread_resume_np(pthread_t thread) 507 { 508 509 if (pthread__find(thread) != 0) 510 return ESRCH; 511 if (_lwp_continue(thread->pt_lid) == 0) 512 return 0; 513 return errno; 514 } 515 516 void 517 pthread_exit(void *retval) 518 { 519 pthread_t self; 520 struct pt_clean_t *cleanup; 521 char *name; 522 523 self = pthread__self(); 524 525 /* Disable cancellability. */ 526 pthread_mutex_lock(&self->pt_lock); 527 self->pt_flags |= PT_FLAG_CS_DISABLED; 528 self->pt_cancel = 0; 529 530 /* Call any cancellation cleanup handlers */ 531 if (!PTQ_EMPTY(&self->pt_cleanup_stack)) { 532 pthread_mutex_unlock(&self->pt_lock); 533 while (!PTQ_EMPTY(&self->pt_cleanup_stack)) { 534 cleanup = PTQ_FIRST(&self->pt_cleanup_stack); 535 PTQ_REMOVE(&self->pt_cleanup_stack, cleanup, ptc_next); 536 (*cleanup->ptc_cleanup)(cleanup->ptc_arg); 537 } 538 pthread_mutex_lock(&self->pt_lock); 539 } 540 541 /* Perform cleanup of thread-specific data */ 542 pthread__destroy_tsd(self); 543 544 /* Signal our exit. */ 545 self->pt_exitval = retval; 546 if (self->pt_flags & PT_FLAG_DETACHED) { 547 self->pt_state = PT_STATE_DEAD; 548 name = self->pt_name; 549 self->pt_name = NULL; 550 pthread_mutex_unlock(&self->pt_lock); 551 if (name != NULL) 552 free(name); 553 pthread_mutex_lock(&pthread__deadqueue_lock); 554 PTQ_INSERT_TAIL(&pthread__deadqueue, self, pt_deadq); 555 pthread_mutex_unlock(&pthread__deadqueue_lock); 556 _lwp_exit(); 557 } else { 558 self->pt_state = PT_STATE_ZOMBIE; 559 pthread_cond_broadcast(&self->pt_joiners); 560 pthread_mutex_unlock(&self->pt_lock); 561 /* Note: name will be freed by the joiner. */ 562 _lwp_exit(); 563 } 564 565 /*NOTREACHED*/ 566 pthread__abort(); 567 exit(1); 568 } 569 570 571 int 572 pthread_join(pthread_t thread, void **valptr) 573 { 574 pthread_t self; 575 int error; 576 577 self = pthread__self(); 578 579 if (pthread__find(thread) != 0) 580 return ESRCH; 581 582 if (thread->pt_magic != PT_MAGIC) 583 return EINVAL; 584 585 if (thread == self) 586 return EDEADLK; 587 588 self->pt_droplock = &thread->pt_lock; 589 pthread_mutex_lock(&thread->pt_lock); 590 for (;;) { 591 if (thread->pt_state == PT_STATE_ZOMBIE) 592 break; 593 if (thread->pt_state == PT_STATE_DEAD) { 594 pthread_mutex_unlock(&thread->pt_lock); 595 self->pt_droplock = NULL; 596 return ESRCH; 597 } 598 if ((thread->pt_flags & PT_FLAG_DETACHED) != 0) { 599 pthread_mutex_unlock(&thread->pt_lock); 600 self->pt_droplock = NULL; 601 return EINVAL; 602 } 603 error = pthread_cond_wait(&thread->pt_joiners, 604 &thread->pt_lock); 605 if (error != 0) { 606 pthread__errorfunc(__FILE__, __LINE__, 607 __func__, "unexpected return from cond_wait()"); 608 } 609 610 } 611 pthread__testcancel(self); 612 if (valptr != NULL) 613 *valptr = thread->pt_exitval; 614 /* pthread__reap() will drop the lock. */ 615 pthread__reap(thread); 616 self->pt_droplock = NULL; 617 618 return 0; 619 } 620 621 static void 622 pthread__reap(pthread_t thread) 623 { 624 char *name; 625 626 name = thread->pt_name; 627 thread->pt_name = NULL; 628 thread->pt_state = PT_STATE_DEAD; 629 pthread_mutex_unlock(&thread->pt_lock); 630 631 pthread_mutex_lock(&pthread__deadqueue_lock); 632 PTQ_INSERT_HEAD(&pthread__deadqueue, thread, pt_deadq); 633 pthread_mutex_unlock(&pthread__deadqueue_lock); 634 635 if (name != NULL) 636 free(name); 637 } 638 639 int 640 pthread_equal(pthread_t t1, pthread_t t2) 641 { 642 643 /* Nothing special here. */ 644 return (t1 == t2); 645 } 646 647 648 int 649 pthread_detach(pthread_t thread) 650 { 651 652 if (pthread__find(thread) != 0) 653 return ESRCH; 654 655 if (thread->pt_magic != PT_MAGIC) 656 return EINVAL; 657 658 pthread_mutex_lock(&thread->pt_lock); 659 thread->pt_flags |= PT_FLAG_DETACHED; 660 if (thread->pt_state == PT_STATE_ZOMBIE) { 661 /* pthread__reap() will drop the lock. */ 662 pthread__reap(thread); 663 } else { 664 /* 665 * Not valid for threads to be waiting in 666 * pthread_join() (there are intractable 667 * sync issues from the application 668 * perspective), but give those threads 669 * a chance anyway. 670 */ 671 pthread_cond_broadcast(&thread->pt_joiners); 672 pthread_mutex_unlock(&thread->pt_lock); 673 } 674 675 return 0; 676 } 677 678 679 int 680 pthread_getname_np(pthread_t thread, char *name, size_t len) 681 { 682 683 if (pthread__find(thread) != 0) 684 return ESRCH; 685 686 if (thread->pt_magic != PT_MAGIC) 687 return EINVAL; 688 689 pthread_mutex_lock(&thread->pt_lock); 690 if (thread->pt_name == NULL) 691 name[0] = '\0'; 692 else 693 strlcpy(name, thread->pt_name, len); 694 pthread_mutex_unlock(&thread->pt_lock); 695 696 return 0; 697 } 698 699 700 int 701 pthread_setname_np(pthread_t thread, const char *name, void *arg) 702 { 703 char *oldname, *cp, newname[PTHREAD_MAX_NAMELEN_NP]; 704 int namelen; 705 706 if (pthread__find(thread) != 0) 707 return ESRCH; 708 709 if (thread->pt_magic != PT_MAGIC) 710 return EINVAL; 711 712 namelen = snprintf(newname, sizeof(newname), name, arg); 713 if (namelen >= PTHREAD_MAX_NAMELEN_NP) 714 return EINVAL; 715 716 cp = strdup(newname); 717 if (cp == NULL) 718 return ENOMEM; 719 720 pthread_mutex_lock(&thread->pt_lock); 721 oldname = thread->pt_name; 722 thread->pt_name = cp; 723 (void)_lwp_setname(thread->pt_lid, cp); 724 pthread_mutex_unlock(&thread->pt_lock); 725 726 if (oldname != NULL) 727 free(oldname); 728 729 return 0; 730 } 731 732 733 734 /* 735 * XXX There should be a way for applications to use the efficent 736 * inline version, but there are opacity/namespace issues. 737 */ 738 pthread_t 739 pthread_self(void) 740 { 741 742 return pthread__self(); 743 } 744 745 746 int 747 pthread_cancel(pthread_t thread) 748 { 749 750 if (pthread__find(thread) != 0) 751 return ESRCH; 752 pthread_mutex_lock(&thread->pt_lock); 753 thread->pt_flags |= PT_FLAG_CS_PENDING; 754 if ((thread->pt_flags & PT_FLAG_CS_DISABLED) == 0) { 755 thread->pt_cancel = 1; 756 pthread_mutex_unlock(&thread->pt_lock); 757 _lwp_wakeup(thread->pt_lid); 758 } else 759 pthread_mutex_unlock(&thread->pt_lock); 760 761 return 0; 762 } 763 764 765 int 766 pthread_setcancelstate(int state, int *oldstate) 767 { 768 pthread_t self; 769 int retval; 770 771 self = pthread__self(); 772 retval = 0; 773 774 pthread_mutex_lock(&self->pt_lock); 775 776 if (oldstate != NULL) { 777 if (self->pt_flags & PT_FLAG_CS_DISABLED) 778 *oldstate = PTHREAD_CANCEL_DISABLE; 779 else 780 *oldstate = PTHREAD_CANCEL_ENABLE; 781 } 782 783 if (state == PTHREAD_CANCEL_DISABLE) { 784 self->pt_flags |= PT_FLAG_CS_DISABLED; 785 if (self->pt_cancel) { 786 self->pt_flags |= PT_FLAG_CS_PENDING; 787 self->pt_cancel = 0; 788 } 789 } else if (state == PTHREAD_CANCEL_ENABLE) { 790 self->pt_flags &= ~PT_FLAG_CS_DISABLED; 791 /* 792 * If a cancellation was requested while cancellation 793 * was disabled, note that fact for future 794 * cancellation tests. 795 */ 796 if (self->pt_flags & PT_FLAG_CS_PENDING) { 797 self->pt_cancel = 1; 798 /* This is not a deferred cancellation point. */ 799 if (self->pt_flags & PT_FLAG_CS_ASYNC) { 800 pthread_mutex_unlock(&self->pt_lock); 801 pthread__cancelled(); 802 } 803 } 804 } else 805 retval = EINVAL; 806 807 pthread_mutex_unlock(&self->pt_lock); 808 809 return retval; 810 } 811 812 813 int 814 pthread_setcanceltype(int type, int *oldtype) 815 { 816 pthread_t self; 817 int retval; 818 819 self = pthread__self(); 820 retval = 0; 821 822 pthread_mutex_lock(&self->pt_lock); 823 824 if (oldtype != NULL) { 825 if (self->pt_flags & PT_FLAG_CS_ASYNC) 826 *oldtype = PTHREAD_CANCEL_ASYNCHRONOUS; 827 else 828 *oldtype = PTHREAD_CANCEL_DEFERRED; 829 } 830 831 if (type == PTHREAD_CANCEL_ASYNCHRONOUS) { 832 self->pt_flags |= PT_FLAG_CS_ASYNC; 833 if (self->pt_cancel) { 834 pthread_mutex_unlock(&self->pt_lock); 835 pthread__cancelled(); 836 } 837 } else if (type == PTHREAD_CANCEL_DEFERRED) 838 self->pt_flags &= ~PT_FLAG_CS_ASYNC; 839 else 840 retval = EINVAL; 841 842 pthread_mutex_unlock(&self->pt_lock); 843 844 return retval; 845 } 846 847 848 void 849 pthread_testcancel(void) 850 { 851 pthread_t self; 852 853 self = pthread__self(); 854 if (self->pt_cancel) 855 pthread__cancelled(); 856 } 857 858 859 /* 860 * POSIX requires that certain functions return an error rather than 861 * invoking undefined behavior even when handed completely bogus 862 * pthread_t values, e.g. stack garbage or (pthread_t)666. This 863 * utility routine searches the list of threads for the pthread_t 864 * value without dereferencing it. 865 */ 866 int 867 pthread__find(pthread_t id) 868 { 869 pthread_t target; 870 871 pthread_rwlock_rdlock(&pthread__alltree_lock); 872 /* LINTED */ 873 target = RB_FIND(__pthread__alltree, &pthread__alltree, id); 874 pthread_rwlock_unlock(&pthread__alltree_lock); 875 876 if (target == NULL || target->pt_state == PT_STATE_DEAD) 877 return ESRCH; 878 879 return 0; 880 } 881 882 883 void 884 pthread__testcancel(pthread_t self) 885 { 886 887 if (self->pt_cancel) 888 pthread__cancelled(); 889 } 890 891 892 void 893 pthread__cancelled(void) 894 { 895 pthread_mutex_t *droplock; 896 pthread_t self; 897 898 self = pthread__self(); 899 droplock = self->pt_droplock; 900 self->pt_droplock = NULL; 901 902 if (droplock != NULL && pthread_mutex_held_np(droplock)) 903 pthread_mutex_unlock(droplock); 904 905 pthread_exit(PTHREAD_CANCELED); 906 } 907 908 909 void 910 pthread__cleanup_push(void (*cleanup)(void *), void *arg, void *store) 911 { 912 pthread_t self; 913 struct pt_clean_t *entry; 914 915 self = pthread__self(); 916 entry = store; 917 entry->ptc_cleanup = cleanup; 918 entry->ptc_arg = arg; 919 PTQ_INSERT_HEAD(&self->pt_cleanup_stack, entry, ptc_next); 920 } 921 922 923 void 924 pthread__cleanup_pop(int ex, void *store) 925 { 926 pthread_t self; 927 struct pt_clean_t *entry; 928 929 self = pthread__self(); 930 entry = store; 931 932 PTQ_REMOVE(&self->pt_cleanup_stack, entry, ptc_next); 933 if (ex) 934 (*entry->ptc_cleanup)(entry->ptc_arg); 935 } 936 937 938 int * 939 pthread__errno(void) 940 { 941 pthread_t self; 942 943 self = pthread__self(); 944 945 return &(self->pt_errno); 946 } 947 948 ssize_t _sys_write(int, const void *, size_t); 949 950 void 951 pthread__assertfunc(const char *file, int line, const char *function, 952 const char *expr) 953 { 954 char buf[1024]; 955 int len; 956 957 /* 958 * snprintf should not acquire any locks, or we could 959 * end up deadlocked if the assert caller held locks. 960 */ 961 len = snprintf(buf, 1024, 962 "assertion \"%s\" failed: file \"%s\", line %d%s%s%s\n", 963 expr, file, line, 964 function ? ", function \"" : "", 965 function ? function : "", 966 function ? "\"" : ""); 967 968 _sys_write(STDERR_FILENO, buf, (size_t)len); 969 (void)kill(getpid(), SIGABRT); 970 971 _exit(1); 972 } 973 974 975 void 976 pthread__errorfunc(const char *file, int line, const char *function, 977 const char *msg) 978 { 979 char buf[1024]; 980 size_t len; 981 982 if (pthread__diagassert == 0) 983 return; 984 985 /* 986 * snprintf should not acquire any locks, or we could 987 * end up deadlocked if the assert caller held locks. 988 */ 989 len = snprintf(buf, 1024, 990 "%s: Error detected by libpthread: %s.\n" 991 "Detected by file \"%s\", line %d%s%s%s.\n" 992 "See pthread(3) for information.\n", 993 getprogname(), msg, file, line, 994 function ? ", function \"" : "", 995 function ? function : "", 996 function ? "\"" : ""); 997 998 if (pthread__diagassert & DIAGASSERT_STDERR) 999 _sys_write(STDERR_FILENO, buf, len); 1000 1001 if (pthread__diagassert & DIAGASSERT_SYSLOG) 1002 syslog(LOG_DEBUG | LOG_USER, "%s", buf); 1003 1004 if (pthread__diagassert & DIAGASSERT_ABORT) { 1005 (void)kill(getpid(), SIGABRT); 1006 _exit(1); 1007 } 1008 } 1009 1010 /* 1011 * Thread park/unpark operations. The kernel operations are 1012 * modelled after a brief description from "Multithreading in 1013 * the Solaris Operating Environment": 1014 * 1015 * http://www.sun.com/software/whitepapers/solaris9/multithread.pdf 1016 */ 1017 1018 #define OOPS(msg) \ 1019 pthread__errorfunc(__FILE__, __LINE__, __func__, msg) 1020 1021 int 1022 pthread__park(pthread_t self, pthread_mutex_t *lock, 1023 pthread_queue_t *queue, const struct timespec *abstime, 1024 int cancelpt, const void *hint) 1025 { 1026 int rv, error; 1027 void *obj; 1028 1029 /* 1030 * For non-interlocked release of mutexes we need a store 1031 * barrier before incrementing pt_blocking away from zero. 1032 * This is provided by pthread_mutex_unlock(). 1033 */ 1034 self->pt_willpark = 1; 1035 pthread_mutex_unlock(lock); 1036 self->pt_willpark = 0; 1037 self->pt_blocking++; 1038 1039 /* 1040 * Wait until we are awoken by a pending unpark operation, 1041 * a signal, an unpark posted after we have gone asleep, 1042 * or an expired timeout. 1043 * 1044 * It is fine to test the value of pt_sleepobj without 1045 * holding any locks, because: 1046 * 1047 * o Only the blocking thread (this thread) ever sets them 1048 * to a non-NULL value. 1049 * 1050 * o Other threads may set them NULL, but if they do so they 1051 * must also make this thread return from _lwp_park. 1052 * 1053 * o _lwp_park, _lwp_unpark and _lwp_unpark_all are system 1054 * calls and all make use of spinlocks in the kernel. So 1055 * these system calls act as full memory barriers, and will 1056 * ensure that the calling CPU's store buffers are drained. 1057 * In combination with the spinlock release before unpark, 1058 * this means that modification of pt_sleepobj/onq by another 1059 * thread will become globally visible before that thread 1060 * schedules an unpark operation on this thread. 1061 * 1062 * Note: the test in the while() statement dodges the park op if 1063 * we have already been awoken, unless there is another thread to 1064 * awaken. This saves a syscall - if we were already awakened, 1065 * the next call to _lwp_park() would need to return early in order 1066 * to eat the previous wakeup. 1067 */ 1068 rv = 0; 1069 do { 1070 /* 1071 * If we deferred unparking a thread, arrange to 1072 * have _lwp_park() restart it before blocking. 1073 */ 1074 error = _lwp_park(abstime, self->pt_unpark, hint, hint); 1075 self->pt_unpark = 0; 1076 if (error != 0) { 1077 switch (rv = errno) { 1078 case EINTR: 1079 case EALREADY: 1080 rv = 0; 1081 break; 1082 case ETIMEDOUT: 1083 break; 1084 default: 1085 OOPS("_lwp_park failed"); 1086 break; 1087 } 1088 } 1089 /* Check for cancellation. */ 1090 if (cancelpt && self->pt_cancel) 1091 rv = EINTR; 1092 } while (self->pt_sleepobj != NULL && rv == 0); 1093 1094 /* 1095 * If we have been awoken early but are still on the queue, 1096 * then remove ourself. Again, it's safe to do the test 1097 * without holding any locks. 1098 */ 1099 if (__predict_false(self->pt_sleepobj != NULL)) { 1100 pthread_mutex_lock(lock); 1101 if ((obj = self->pt_sleepobj) != NULL) { 1102 PTQ_REMOVE(queue, self, pt_sleep); 1103 self->pt_sleepobj = NULL; 1104 if (obj != NULL && self->pt_early != NULL) 1105 (*self->pt_early)(obj); 1106 } 1107 pthread_mutex_unlock(lock); 1108 } 1109 self->pt_early = NULL; 1110 self->pt_blocking--; 1111 membar_sync(); 1112 1113 return rv; 1114 } 1115 1116 void 1117 pthread__unpark(pthread_queue_t *queue, pthread_t self, 1118 pthread_mutex_t *interlock) 1119 { 1120 pthread_t target; 1121 u_int max; 1122 size_t nwaiters; 1123 1124 max = pthread__unpark_max; 1125 nwaiters = self->pt_nwaiters; 1126 target = PTQ_FIRST(queue); 1127 if (nwaiters == max) { 1128 /* Overflow. */ 1129 (void)_lwp_unpark_all(self->pt_waiters, nwaiters, 1130 __UNVOLATILE(&interlock->ptm_waiters)); 1131 nwaiters = 0; 1132 } 1133 target->pt_sleepobj = NULL; 1134 self->pt_waiters[nwaiters++] = target->pt_lid; 1135 PTQ_REMOVE(queue, target, pt_sleep); 1136 self->pt_nwaiters = nwaiters; 1137 pthread__mutex_deferwake(self, interlock); 1138 } 1139 1140 void 1141 pthread__unpark_all(pthread_queue_t *queue, pthread_t self, 1142 pthread_mutex_t *interlock) 1143 { 1144 pthread_t target; 1145 u_int max; 1146 size_t nwaiters; 1147 1148 max = pthread__unpark_max; 1149 nwaiters = self->pt_nwaiters; 1150 PTQ_FOREACH(target, queue, pt_sleep) { 1151 if (nwaiters == max) { 1152 /* Overflow. */ 1153 (void)_lwp_unpark_all(self->pt_waiters, nwaiters, 1154 __UNVOLATILE(&interlock->ptm_waiters)); 1155 nwaiters = 0; 1156 } 1157 target->pt_sleepobj = NULL; 1158 self->pt_waiters[nwaiters++] = target->pt_lid; 1159 } 1160 self->pt_nwaiters = nwaiters; 1161 PTQ_INIT(queue); 1162 pthread__mutex_deferwake(self, interlock); 1163 } 1164 1165 #undef OOPS 1166 1167 /* 1168 * Allocate a stack for a thread, and set it up. It needs to be aligned, so 1169 * that a thread can find itself by its stack pointer. 1170 */ 1171 static int 1172 pthread__stackalloc(pthread_t *newt) 1173 { 1174 void *addr; 1175 1176 addr = mmap(NULL, pthread__stacksize, PROT_READ|PROT_WRITE, 1177 MAP_ANON|MAP_PRIVATE | MAP_ALIGNED(pthread__stacksize_lg), 1178 -1, (off_t)0); 1179 1180 if (addr == MAP_FAILED) 1181 return ENOMEM; 1182 1183 pthread__assert(((intptr_t)addr & pthread__stackmask) == 0); 1184 1185 return pthread__stackid_setup(addr, pthread__stacksize, newt); 1186 } 1187 1188 1189 /* 1190 * Set up the slightly special stack for the "initial" thread, which 1191 * runs on the normal system stack, and thus gets slightly different 1192 * treatment. 1193 */ 1194 static void 1195 pthread__initmain(pthread_t *newt) 1196 { 1197 struct rlimit slimit; 1198 size_t pagesize; 1199 pthread_t t; 1200 void *base; 1201 size_t size; 1202 int error, ret; 1203 char *value; 1204 1205 pagesize = (size_t)sysconf(_SC_PAGESIZE); 1206 pthread__stacksize = 0; 1207 ret = getrlimit(RLIMIT_STACK, &slimit); 1208 if (ret == -1) 1209 err(1, "Couldn't get stack resource consumption limits"); 1210 1211 value = pthread__getenv("PTHREAD_STACKSIZE"); 1212 if (value != NULL) { 1213 pthread__stacksize = atoi(value) * 1024; 1214 if (pthread__stacksize > slimit.rlim_cur) 1215 pthread__stacksize = (size_t)slimit.rlim_cur; 1216 } 1217 if (pthread__stacksize == 0) 1218 pthread__stacksize = (size_t)slimit.rlim_cur; 1219 if (pthread__stacksize < 4 * pagesize) 1220 errx(1, "Stacksize limit is too low, minimum %zd kbyte.", 1221 4 * pagesize / 1024); 1222 1223 pthread__stacksize_lg = -1; 1224 while (pthread__stacksize) { 1225 pthread__stacksize >>= 1; 1226 pthread__stacksize_lg++; 1227 } 1228 1229 pthread__stacksize = (1 << pthread__stacksize_lg); 1230 pthread__stackmask = pthread__stacksize - 1; 1231 pthread__threadmask = ~pthread__stackmask; 1232 1233 base = (void *)(pthread__sp() & pthread__threadmask); 1234 size = pthread__stacksize; 1235 1236 error = pthread__stackid_setup(base, size, &t); 1237 if (error) { 1238 /* XXX */ 1239 errx(2, "failed to setup main thread: error=%d", error); 1240 } 1241 1242 *newt = t; 1243 1244 /* Set up identity register. */ 1245 (void)_lwp_setprivate(t); 1246 } 1247 1248 static int 1249 /*ARGSUSED*/ 1250 pthread__stackid_setup(void *base, size_t size, pthread_t *tp) 1251 { 1252 pthread_t t; 1253 void *redaddr; 1254 size_t pagesize; 1255 int ret; 1256 1257 t = base; 1258 pagesize = (size_t)sysconf(_SC_PAGESIZE); 1259 1260 /* 1261 * Put a pointer to the pthread in the bottom (but 1262 * redzone-protected section) of the stack. 1263 */ 1264 redaddr = STACK_SHRINK(STACK_MAX(base, size), pagesize); 1265 t->pt_stack.ss_size = size - 2 * pagesize; 1266 #ifdef __MACHINE_STACK_GROWS_UP 1267 t->pt_stack.ss_sp = (char *)(void *)base + pagesize; 1268 #else 1269 t->pt_stack.ss_sp = (char *)(void *)base + 2 * pagesize; 1270 #endif 1271 1272 /* Protect the next-to-bottom stack page as a red zone. */ 1273 ret = mprotect(redaddr, pagesize, PROT_NONE); 1274 if (ret == -1) { 1275 return errno; 1276 } 1277 *tp = t; 1278 return 0; 1279 } 1280 1281 #ifndef lint 1282 static int 1283 pthread__cmp(struct __pthread_st *a, struct __pthread_st *b) 1284 { 1285 1286 if ((uintptr_t)a < (uintptr_t)b) 1287 return (-1); 1288 else if (a == b) 1289 return 0; 1290 else 1291 return 1; 1292 } 1293 RB_GENERATE_STATIC(__pthread__alltree, __pthread_st, pt_alltree, pthread__cmp) 1294 #endif 1295 1296 /* Because getenv() wants to use locks. */ 1297 char * 1298 pthread__getenv(const char *name) 1299 { 1300 extern char *__findenv(const char *, int *); 1301 int off; 1302 1303 return __findenv(name, &off); 1304 } 1305 1306 pthread_mutex_t * 1307 pthread__hashlock(volatile const void *p) 1308 { 1309 uintptr_t v; 1310 1311 v = (uintptr_t)p; 1312 return &hashlocks[((v >> 9) ^ (v >> 3)) & (NHASHLOCK - 1)].mutex; 1313 } 1314 1315 int 1316 pthread__checkpri(int pri) 1317 { 1318 static int havepri; 1319 static long min, max; 1320 1321 if (!havepri) { 1322 min = sysconf(_SC_SCHED_PRI_MIN); 1323 max = sysconf(_SC_SCHED_PRI_MAX); 1324 havepri = 1; 1325 } 1326 return (pri < min || pri > max) ? EINVAL : 0; 1327 } 1328