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