1 0 stevel /* 2 0 stevel * CDDL HEADER START 3 0 stevel * 4 0 stevel * The contents of this file are subject to the terms of the 5 1672 raf * Common Development and Distribution License (the "License"). 6 1672 raf * You may not use this file except in compliance with the License. 7 0 stevel * 8 0 stevel * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 0 stevel * or http://www.opensolaris.org/os/licensing. 10 0 stevel * See the License for the specific language governing permissions 11 0 stevel * and limitations under the License. 12 0 stevel * 13 0 stevel * When distributing Covered Code, include this CDDL HEADER in each 14 0 stevel * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 0 stevel * If applicable, add the following below this CDDL HEADER, with the 16 0 stevel * fields enclosed by brackets "[]" replaced with your own identifying 17 0 stevel * information: Portions Copyright [yyyy] [name of copyright owner] 18 0 stevel * 19 0 stevel * CDDL HEADER END 20 0 stevel */ 21 1111 raf 22 0 stevel /* 23 8486 Roger * Copyright 2009 Sun Microsystems, Inc. All rights reserved. 24 0 stevel * Use is subject to license terms. 25 0 stevel */ 26 0 stevel 27 0 stevel #include "lint.h" 28 0 stevel #include "thr_uberdata.h" 29 5891 raf #include <pthread.h> 30 0 stevel #include <procfs.h> 31 0 stevel #include <sys/uio.h> 32 0 stevel #include <ctype.h> 33 5891 raf #include "libc.h" 34 6812 raf 35 6812 raf /* 36 6812 raf * These symbols should not be exported from libc, but 37 6812 raf * /lib/libm.so.2 references _thr_main. libm needs to be fixed. 38 6812 raf * Also, some older versions of the Studio compiler/debugger 39 6812 raf * components reference them. These need to be fixed, too. 40 6812 raf */ 41 6812 raf #pragma weak _thr_main = thr_main 42 6812 raf #pragma weak _thr_create = thr_create 43 6812 raf #pragma weak _thr_join = thr_join 44 6812 raf #pragma weak _thr_self = thr_self 45 0 stevel 46 0 stevel #undef errno 47 0 stevel extern int errno; 48 0 stevel 49 1672 raf /* 50 1672 raf * Between Solaris 2.5 and Solaris 9, __threaded was used to indicate 51 1672 raf * "we are linked with libthread". The Sun Workshop 6 update 1 compilation 52 1672 raf * system used it illegally (it is a consolidation private symbol). 53 1672 raf * To accommodate this and possibly other abusers of the symbol, 54 1672 raf * we make it always equal to 1 now that libthread has been folded 55 1672 raf * into libc. The new __libc_threaded symbol is used to indicate 56 1672 raf * the new meaning, "more than one thread exists". 57 1672 raf */ 58 1672 raf int __threaded = 1; /* always equal to 1 */ 59 1672 raf int __libc_threaded = 0; /* zero until first thr_create() */ 60 0 stevel 61 0 stevel /* 62 0 stevel * thr_concurrency and pthread_concurrency are not used by the library. 63 0 stevel * They exist solely to hold and return the values set by calls to 64 0 stevel * thr_setconcurrency() and pthread_setconcurrency(). 65 0 stevel * Because thr_concurrency is affected by the THR_NEW_LWP flag 66 0 stevel * to thr_create(), thr_concurrency is protected by link_lock. 67 0 stevel */ 68 0 stevel static int thr_concurrency = 1; 69 0 stevel static int pthread_concurrency; 70 0 stevel 71 0 stevel #define HASHTBLSZ 1024 /* must be a power of two */ 72 0 stevel #define TIDHASH(tid, udp) (tid & (udp)->hash_mask) 73 0 stevel 74 0 stevel /* initial allocation, just enough for one lwp */ 75 0 stevel #pragma align 64(init_hash_table) 76 0 stevel thr_hash_table_t init_hash_table[1] = { 77 0 stevel { DEFAULTMUTEX, DEFAULTCV, NULL }, 78 0 stevel }; 79 0 stevel 80 0 stevel extern const Lc_interface rtld_funcs[]; 81 0 stevel 82 0 stevel /* 83 0 stevel * The weak version is known to libc_db and mdb. 84 0 stevel */ 85 0 stevel #pragma weak _uberdata = __uberdata 86 0 stevel uberdata_t __uberdata = { 87 3512 raf { DEFAULTMUTEX, NULL, 0 }, /* link_lock */ 88 6515 raf { RECURSIVEMUTEX, NULL, 0 }, /* ld_lock */ 89 3512 raf { RECURSIVEMUTEX, NULL, 0 }, /* fork_lock */ 90 4843 raf { RECURSIVEMUTEX, NULL, 0 }, /* atfork_lock */ 91 5002 raf { RECURSIVEMUTEX, NULL, 0 }, /* callout_lock */ 92 3512 raf { DEFAULTMUTEX, NULL, 0 }, /* tdb_hash_lock */ 93 3512 raf { 0, }, /* tdb_hash_lock_stats */ 94 3512 raf { { 0 }, }, /* siguaction[NSIG] */ 95 0 stevel {{ DEFAULTMUTEX, NULL, 0 }, /* bucket[NBUCKETS] */ 96 0 stevel { DEFAULTMUTEX, NULL, 0 }, 97 0 stevel { DEFAULTMUTEX, NULL, 0 }, 98 0 stevel { DEFAULTMUTEX, NULL, 0 }, 99 0 stevel { DEFAULTMUTEX, NULL, 0 }, 100 0 stevel { DEFAULTMUTEX, NULL, 0 }, 101 0 stevel { DEFAULTMUTEX, NULL, 0 }, 102 0 stevel { DEFAULTMUTEX, NULL, 0 }, 103 0 stevel { DEFAULTMUTEX, NULL, 0 }, 104 0 stevel { DEFAULTMUTEX, NULL, 0 }}, 105 0 stevel { RECURSIVEMUTEX, NULL, NULL }, /* atexit_root */ 106 0 stevel { DEFAULTMUTEX, 0, 0, NULL }, /* tsd_metadata */ 107 0 stevel { DEFAULTMUTEX, {0, 0}, {0, 0} }, /* tls_metadata */ 108 0 stevel 0, /* primary_map */ 109 0 stevel 0, /* bucket_init */ 110 0 stevel 0, /* pad[0] */ 111 0 stevel 0, /* pad[1] */ 112 0 stevel { 0 }, /* uberflags */ 113 0 stevel NULL, /* queue_head */ 114 0 stevel init_hash_table, /* thr_hash_table */ 115 0 stevel 1, /* hash_size: size of the hash table */ 116 0 stevel 0, /* hash_mask: hash_size - 1 */ 117 0 stevel NULL, /* ulwp_one */ 118 0 stevel NULL, /* all_lwps */ 119 0 stevel NULL, /* all_zombies */ 120 0 stevel 0, /* nthreads */ 121 0 stevel 0, /* nzombies */ 122 0 stevel 0, /* ndaemons */ 123 0 stevel 0, /* pid */ 124 0 stevel sigacthandler, /* sigacthandler */ 125 0 stevel NULL, /* lwp_stacks */ 126 0 stevel NULL, /* lwp_laststack */ 127 0 stevel 0, /* nfreestack */ 128 0 stevel 10, /* thread_stack_cache */ 129 0 stevel NULL, /* ulwp_freelist */ 130 0 stevel NULL, /* ulwp_lastfree */ 131 0 stevel NULL, /* ulwp_replace_free */ 132 0 stevel NULL, /* ulwp_replace_last */ 133 0 stevel NULL, /* atforklist */ 134 4574 raf NULL, /* robustlocks */ 135 9170 Roger NULL, /* robustlist */ 136 0 stevel NULL, /* __tdb_bootstrap */ 137 0 stevel { /* tdb */ 138 0 stevel NULL, /* tdb_sync_addr_hash */ 139 0 stevel 0, /* tdb_register_count */ 140 0 stevel 0, /* tdb_hash_alloc_failed */ 141 0 stevel NULL, /* tdb_sync_addr_free */ 142 0 stevel NULL, /* tdb_sync_addr_last */ 143 0 stevel 0, /* tdb_sync_alloc */ 144 0 stevel { 0, 0 }, /* tdb_ev_global_mask */ 145 0 stevel tdb_events, /* tdb_events array */ 146 0 stevel }, 147 0 stevel }; 148 0 stevel 149 0 stevel /* 150 0 stevel * The weak version is known to libc_db and mdb. 151 0 stevel */ 152 0 stevel #pragma weak _tdb_bootstrap = __tdb_bootstrap 153 0 stevel uberdata_t **__tdb_bootstrap = NULL; 154 0 stevel 155 0 stevel int thread_queue_fifo = 4; 156 0 stevel int thread_queue_dump = 0; 157 0 stevel int thread_cond_wait_defer = 0; 158 0 stevel int thread_error_detection = 0; 159 0 stevel int thread_async_safe = 0; 160 0 stevel int thread_stack_cache = 10; 161 0 stevel int thread_door_noreserve = 0; 162 7255 raf int thread_locks_misaligned = 0; 163 0 stevel 164 0 stevel static ulwp_t *ulwp_alloc(void); 165 0 stevel static void ulwp_free(ulwp_t *); 166 0 stevel 167 0 stevel /* 168 0 stevel * Insert the lwp into the hash table. 169 0 stevel */ 170 0 stevel void 171 0 stevel hash_in_unlocked(ulwp_t *ulwp, int ix, uberdata_t *udp) 172 0 stevel { 173 0 stevel ulwp->ul_hash = udp->thr_hash_table[ix].hash_bucket; 174 0 stevel udp->thr_hash_table[ix].hash_bucket = ulwp; 175 0 stevel ulwp->ul_ix = ix; 176 0 stevel } 177 0 stevel 178 0 stevel void 179 0 stevel hash_in(ulwp_t *ulwp, uberdata_t *udp) 180 0 stevel { 181 0 stevel int ix = TIDHASH(ulwp->ul_lwpid, udp); 182 0 stevel mutex_t *mp = &udp->thr_hash_table[ix].hash_lock; 183 0 stevel 184 0 stevel lmutex_lock(mp); 185 0 stevel hash_in_unlocked(ulwp, ix, udp); 186 0 stevel lmutex_unlock(mp); 187 0 stevel } 188 0 stevel 189 0 stevel /* 190 0 stevel * Delete the lwp from the hash table. 191 0 stevel */ 192 0 stevel void 193 0 stevel hash_out_unlocked(ulwp_t *ulwp, int ix, uberdata_t *udp) 194 0 stevel { 195 0 stevel ulwp_t **ulwpp; 196 0 stevel 197 0 stevel for (ulwpp = &udp->thr_hash_table[ix].hash_bucket; 198 0 stevel ulwp != *ulwpp; 199 0 stevel ulwpp = &(*ulwpp)->ul_hash) 200 0 stevel ; 201 0 stevel *ulwpp = ulwp->ul_hash; 202 0 stevel ulwp->ul_hash = NULL; 203 0 stevel ulwp->ul_ix = -1; 204 0 stevel } 205 0 stevel 206 0 stevel void 207 0 stevel hash_out(ulwp_t *ulwp, uberdata_t *udp) 208 0 stevel { 209 0 stevel int ix; 210 0 stevel 211 0 stevel if ((ix = ulwp->ul_ix) >= 0) { 212 0 stevel mutex_t *mp = &udp->thr_hash_table[ix].hash_lock; 213 0 stevel 214 0 stevel lmutex_lock(mp); 215 0 stevel hash_out_unlocked(ulwp, ix, udp); 216 0 stevel lmutex_unlock(mp); 217 0 stevel } 218 0 stevel } 219 0 stevel 220 5891 raf /* 221 5891 raf * Retain stack information for thread structures that are being recycled for 222 5891 raf * new threads. All other members of the thread structure should be zeroed. 223 5891 raf */ 224 0 stevel static void 225 0 stevel ulwp_clean(ulwp_t *ulwp) 226 0 stevel { 227 5891 raf caddr_t stk = ulwp->ul_stk; 228 5891 raf size_t mapsiz = ulwp->ul_mapsiz; 229 5891 raf size_t guardsize = ulwp->ul_guardsize; 230 5891 raf uintptr_t stktop = ulwp->ul_stktop; 231 5891 raf size_t stksiz = ulwp->ul_stksiz; 232 5891 raf 233 6515 raf (void) memset(ulwp, 0, sizeof (*ulwp)); 234 5891 raf 235 5891 raf ulwp->ul_stk = stk; 236 5891 raf ulwp->ul_mapsiz = mapsiz; 237 5891 raf ulwp->ul_guardsize = guardsize; 238 5891 raf ulwp->ul_stktop = stktop; 239 5891 raf ulwp->ul_stksiz = stksiz; 240 0 stevel } 241 0 stevel 242 0 stevel static int stackprot; 243 0 stevel 244 0 stevel /* 245 0 stevel * Answer the question, "Is the lwp in question really dead?" 246 0 stevel * We must inquire of the operating system to be really sure 247 0 stevel * because the lwp may have called lwp_exit() but it has not 248 0 stevel * yet completed the exit. 249 0 stevel */ 250 0 stevel static int 251 0 stevel dead_and_buried(ulwp_t *ulwp) 252 0 stevel { 253 0 stevel if (ulwp->ul_lwpid == (lwpid_t)(-1)) 254 0 stevel return (1); 255 0 stevel if (ulwp->ul_dead && ulwp->ul_detached && 256 6812 raf _lwp_kill(ulwp->ul_lwpid, 0) == ESRCH) { 257 0 stevel ulwp->ul_lwpid = (lwpid_t)(-1); 258 0 stevel return (1); 259 0 stevel } 260 0 stevel return (0); 261 0 stevel } 262 0 stevel 263 0 stevel /* 264 0 stevel * Attempt to keep the stack cache within the specified cache limit. 265 0 stevel */ 266 0 stevel static void 267 0 stevel trim_stack_cache(int cache_limit) 268 0 stevel { 269 0 stevel ulwp_t *self = curthread; 270 0 stevel uberdata_t *udp = self->ul_uberdata; 271 0 stevel ulwp_t *prev = NULL; 272 0 stevel ulwp_t **ulwpp = &udp->lwp_stacks; 273 0 stevel ulwp_t *ulwp; 274 0 stevel 275 0 stevel ASSERT(udp->nthreads <= 1 || MUTEX_OWNED(&udp->link_lock, self)); 276 0 stevel 277 0 stevel while (udp->nfreestack > cache_limit && (ulwp = *ulwpp) != NULL) { 278 0 stevel if (dead_and_buried(ulwp)) { 279 0 stevel *ulwpp = ulwp->ul_next; 280 0 stevel if (ulwp == udp->lwp_laststack) 281 0 stevel udp->lwp_laststack = prev; 282 0 stevel hash_out(ulwp, udp); 283 0 stevel udp->nfreestack--; 284 6515 raf (void) munmap(ulwp->ul_stk, ulwp->ul_mapsiz); 285 0 stevel /* 286 0 stevel * Now put the free ulwp on the ulwp freelist. 287 0 stevel */ 288 0 stevel ulwp->ul_mapsiz = 0; 289 0 stevel ulwp->ul_next = NULL; 290 0 stevel if (udp->ulwp_freelist == NULL) 291 0 stevel udp->ulwp_freelist = udp->ulwp_lastfree = ulwp; 292 0 stevel else { 293 0 stevel udp->ulwp_lastfree->ul_next = ulwp; 294 0 stevel udp->ulwp_lastfree = ulwp; 295 0 stevel } 296 0 stevel } else { 297 0 stevel prev = ulwp; 298 0 stevel ulwpp = &ulwp->ul_next; 299 0 stevel } 300 0 stevel } 301 0 stevel } 302 0 stevel 303 0 stevel /* 304 0 stevel * Find an unused stack of the requested size 305 0 stevel * or create a new stack of the requested size. 306 0 stevel * Return a pointer to the ulwp_t structure referring to the stack, or NULL. 307 0 stevel * thr_exit() stores 1 in the ul_dead member. 308 0 stevel * thr_join() stores -1 in the ul_lwpid member. 309 0 stevel */ 310 8486 Roger static ulwp_t * 311 0 stevel find_stack(size_t stksize, size_t guardsize) 312 0 stevel { 313 1885 raf static size_t pagesize = 0; 314 1885 raf 315 0 stevel uberdata_t *udp = curthread->ul_uberdata; 316 0 stevel size_t mapsize; 317 0 stevel ulwp_t *prev; 318 0 stevel ulwp_t *ulwp; 319 0 stevel ulwp_t **ulwpp; 320 0 stevel void *stk; 321 0 stevel 322 0 stevel /* 323 0 stevel * The stack is allocated PROT_READ|PROT_WRITE|PROT_EXEC 324 0 stevel * unless overridden by the system's configuration. 325 0 stevel */ 326 0 stevel if (stackprot == 0) { /* do this once */ 327 0 stevel long lprot = _sysconf(_SC_STACK_PROT); 328 0 stevel if (lprot <= 0) 329 0 stevel lprot = (PROT_READ|PROT_WRITE|PROT_EXEC); 330 0 stevel stackprot = (int)lprot; 331 0 stevel } 332 1885 raf if (pagesize == 0) /* do this once */ 333 1885 raf pagesize = _sysconf(_SC_PAGESIZE); 334 1885 raf 335 0 stevel /* 336 0 stevel * One megabyte stacks by default, but subtract off 337 0 stevel * two pages for the system-created red zones. 338 0 stevel * Round up a non-zero stack size to a pagesize multiple. 339 0 stevel */ 340 0 stevel if (stksize == 0) 341 1885 raf stksize = DEFAULTSTACK - 2 * pagesize; 342 0 stevel else 343 1885 raf stksize = ((stksize + pagesize - 1) & -pagesize); 344 0 stevel 345 0 stevel /* 346 0 stevel * Round up the mapping size to a multiple of pagesize. 347 0 stevel * Note: mmap() provides at least one page of red zone 348 0 stevel * so we deduct that from the value of guardsize. 349 0 stevel */ 350 0 stevel if (guardsize != 0) 351 1885 raf guardsize = ((guardsize + pagesize - 1) & -pagesize) - pagesize; 352 0 stevel mapsize = stksize + guardsize; 353 0 stevel 354 0 stevel lmutex_lock(&udp->link_lock); 355 0 stevel for (prev = NULL, ulwpp = &udp->lwp_stacks; 356 0 stevel (ulwp = *ulwpp) != NULL; 357 0 stevel prev = ulwp, ulwpp = &ulwp->ul_next) { 358 0 stevel if (ulwp->ul_mapsiz == mapsize && 359 0 stevel ulwp->ul_guardsize == guardsize && 360 0 stevel dead_and_buried(ulwp)) { 361 0 stevel /* 362 0 stevel * The previous lwp is gone; reuse the stack. 363 0 stevel * Remove the ulwp from the stack list. 364 0 stevel */ 365 0 stevel *ulwpp = ulwp->ul_next; 366 0 stevel ulwp->ul_next = NULL; 367 0 stevel if (ulwp == udp->lwp_laststack) 368 0 stevel udp->lwp_laststack = prev; 369 0 stevel hash_out(ulwp, udp); 370 0 stevel udp->nfreestack--; 371 0 stevel lmutex_unlock(&udp->link_lock); 372 0 stevel ulwp_clean(ulwp); 373 0 stevel return (ulwp); 374 0 stevel } 375 0 stevel } 376 0 stevel 377 0 stevel /* 378 0 stevel * None of the cached stacks matched our mapping size. 379 0 stevel * Reduce the stack cache to get rid of possibly 380 0 stevel * very old stacks that will never be reused. 381 0 stevel */ 382 0 stevel if (udp->nfreestack > udp->thread_stack_cache) 383 0 stevel trim_stack_cache(udp->thread_stack_cache); 384 0 stevel else if (udp->nfreestack > 0) 385 0 stevel trim_stack_cache(udp->nfreestack - 1); 386 0 stevel lmutex_unlock(&udp->link_lock); 387 0 stevel 388 0 stevel /* 389 0 stevel * Create a new stack. 390 0 stevel */ 391 6515 raf if ((stk = mmap(NULL, mapsize, stackprot, 392 0 stevel MAP_PRIVATE|MAP_NORESERVE|MAP_ANON, -1, (off_t)0)) != MAP_FAILED) { 393 0 stevel /* 394 0 stevel * We have allocated our stack. Now allocate the ulwp. 395 0 stevel */ 396 0 stevel ulwp = ulwp_alloc(); 397 0 stevel if (ulwp == NULL) 398 6515 raf (void) munmap(stk, mapsize); 399 0 stevel else { 400 0 stevel ulwp->ul_stk = stk; 401 0 stevel ulwp->ul_mapsiz = mapsize; 402 0 stevel ulwp->ul_guardsize = guardsize; 403 0 stevel ulwp->ul_stktop = (uintptr_t)stk + mapsize; 404 0 stevel ulwp->ul_stksiz = stksize; 405 0 stevel if (guardsize) /* protect the extra red zone */ 406 6515 raf (void) mprotect(stk, guardsize, PROT_NONE); 407 0 stevel } 408 0 stevel } 409 0 stevel return (ulwp); 410 0 stevel } 411 0 stevel 412 0 stevel /* 413 0 stevel * Get a ulwp_t structure from the free list or allocate a new one. 414 0 stevel * Such ulwp_t's do not have a stack allocated by the library. 415 0 stevel */ 416 0 stevel static ulwp_t * 417 0 stevel ulwp_alloc(void) 418 0 stevel { 419 0 stevel ulwp_t *self = curthread; 420 0 stevel uberdata_t *udp = self->ul_uberdata; 421 0 stevel size_t tls_size; 422 0 stevel ulwp_t *prev; 423 0 stevel ulwp_t *ulwp; 424 0 stevel ulwp_t **ulwpp; 425 0 stevel caddr_t data; 426 0 stevel 427 0 stevel lmutex_lock(&udp->link_lock); 428 0 stevel for (prev = NULL, ulwpp = &udp->ulwp_freelist; 429 0 stevel (ulwp = *ulwpp) != NULL; 430 0 stevel prev = ulwp, ulwpp = &ulwp->ul_next) { 431 0 stevel if (dead_and_buried(ulwp)) { 432 0 stevel *ulwpp = ulwp->ul_next; 433 0 stevel ulwp->ul_next = NULL; 434 0 stevel if (ulwp == udp->ulwp_lastfree) 435 0 stevel udp->ulwp_lastfree = prev; 436 0 stevel hash_out(ulwp, udp); 437 0 stevel lmutex_unlock(&udp->link_lock); 438 0 stevel ulwp_clean(ulwp); 439 0 stevel return (ulwp); 440 0 stevel } 441 0 stevel } 442 0 stevel lmutex_unlock(&udp->link_lock); 443 0 stevel 444 0 stevel tls_size = roundup64(udp->tls_metadata.static_tls.tls_size); 445 0 stevel data = lmalloc(sizeof (*ulwp) + tls_size); 446 0 stevel if (data != NULL) { 447 0 stevel /* LINTED pointer cast may result in improper alignment */ 448 0 stevel ulwp = (ulwp_t *)(data + tls_size); 449 0 stevel } 450 0 stevel return (ulwp); 451 0 stevel } 452 0 stevel 453 0 stevel /* 454 0 stevel * Free a ulwp structure. 455 0 stevel * If there is an associated stack, put it on the stack list and 456 0 stevel * munmap() previously freed stacks up to the residual cache limit. 457 0 stevel * Else put it on the ulwp free list and never call lfree() on it. 458 0 stevel */ 459 0 stevel static void 460 0 stevel ulwp_free(ulwp_t *ulwp) 461 0 stevel { 462 0 stevel uberdata_t *udp = curthread->ul_uberdata; 463 0 stevel 464 0 stevel ASSERT(udp->nthreads <= 1 || MUTEX_OWNED(&udp->link_lock, curthread)); 465 0 stevel ulwp->ul_next = NULL; 466 0 stevel if (ulwp == udp->ulwp_one) /* don't reuse the primoridal stack */ 467 0 stevel /*EMPTY*/; 468 0 stevel else if (ulwp->ul_mapsiz != 0) { 469 0 stevel if (udp->lwp_stacks == NULL) 470 0 stevel udp->lwp_stacks = udp->lwp_laststack = ulwp; 471 0 stevel else { 472 0 stevel udp->lwp_laststack->ul_next = ulwp; 473 0 stevel udp->lwp_laststack = ulwp; 474 0 stevel } 475 0 stevel if (++udp->nfreestack > udp->thread_stack_cache) 476 0 stevel trim_stack_cache(udp->thread_stack_cache); 477 0 stevel } else { 478 0 stevel if (udp->ulwp_freelist == NULL) 479 0 stevel udp->ulwp_freelist = udp->ulwp_lastfree = ulwp; 480 0 stevel else { 481 0 stevel udp->ulwp_lastfree->ul_next = ulwp; 482 0 stevel udp->ulwp_lastfree = ulwp; 483 0 stevel } 484 0 stevel } 485 0 stevel } 486 0 stevel 487 0 stevel /* 488 0 stevel * Find a named lwp and return a pointer to its hash list location. 489 0 stevel * On success, returns with the hash lock held. 490 0 stevel */ 491 0 stevel ulwp_t ** 492 0 stevel find_lwpp(thread_t tid) 493 0 stevel { 494 0 stevel uberdata_t *udp = curthread->ul_uberdata; 495 0 stevel int ix = TIDHASH(tid, udp); 496 0 stevel mutex_t *mp = &udp->thr_hash_table[ix].hash_lock; 497 0 stevel ulwp_t *ulwp; 498 0 stevel ulwp_t **ulwpp; 499 0 stevel 500 0 stevel if (tid == 0) 501 0 stevel return (NULL); 502 0 stevel 503 0 stevel lmutex_lock(mp); 504 0 stevel for (ulwpp = &udp->thr_hash_table[ix].hash_bucket; 505 0 stevel (ulwp = *ulwpp) != NULL; 506 0 stevel ulwpp = &ulwp->ul_hash) { 507 0 stevel if (ulwp->ul_lwpid == tid) 508 0 stevel return (ulwpp); 509 0 stevel } 510 0 stevel lmutex_unlock(mp); 511 0 stevel return (NULL); 512 0 stevel } 513 0 stevel 514 0 stevel /* 515 0 stevel * Wake up all lwps waiting on this lwp for some reason. 516 0 stevel */ 517 0 stevel void 518 0 stevel ulwp_broadcast(ulwp_t *ulwp) 519 0 stevel { 520 0 stevel ulwp_t *self = curthread; 521 0 stevel uberdata_t *udp = self->ul_uberdata; 522 0 stevel 523 0 stevel ASSERT(MUTEX_OWNED(ulwp_mutex(ulwp, udp), self)); 524 6812 raf (void) cond_broadcast(ulwp_condvar(ulwp, udp)); 525 0 stevel } 526 0 stevel 527 0 stevel /* 528 0 stevel * Find a named lwp and return a pointer to it. 529 0 stevel * Returns with the hash lock held. 530 0 stevel */ 531 0 stevel ulwp_t * 532 0 stevel find_lwp(thread_t tid) 533 0 stevel { 534 0 stevel ulwp_t *self = curthread; 535 0 stevel uberdata_t *udp = self->ul_uberdata; 536 0 stevel ulwp_t *ulwp = NULL; 537 0 stevel ulwp_t **ulwpp; 538 0 stevel 539 0 stevel if (self->ul_lwpid == tid) { 540 0 stevel ulwp = self; 541 0 stevel ulwp_lock(ulwp, udp); 542 0 stevel } else if ((ulwpp = find_lwpp(tid)) != NULL) { 543 0 stevel ulwp = *ulwpp; 544 0 stevel } 545 0 stevel 546 0 stevel if (ulwp && ulwp->ul_dead) { 547 0 stevel ulwp_unlock(ulwp, udp); 548 0 stevel ulwp = NULL; 549 0 stevel } 550 0 stevel 551 0 stevel return (ulwp); 552 0 stevel } 553 0 stevel 554 0 stevel int 555 0 stevel _thrp_create(void *stk, size_t stksize, void *(*func)(void *), void *arg, 556 6247 raf long flags, thread_t *new_thread, size_t guardsize) 557 0 stevel { 558 0 stevel ulwp_t *self = curthread; 559 0 stevel uberdata_t *udp = self->ul_uberdata; 560 0 stevel ucontext_t uc; 561 0 stevel uint_t lwp_flags; 562 0 stevel thread_t tid; 563 7657 Roger int error; 564 0 stevel ulwp_t *ulwp; 565 0 stevel 566 0 stevel /* 567 0 stevel * Enforce the restriction of not creating any threads 568 0 stevel * until the primary link map has been initialized. 569 0 stevel * Also, disallow thread creation to a child of vfork(). 570 0 stevel */ 571 0 stevel if (!self->ul_primarymap || self->ul_vfork) 572 0 stevel return (ENOTSUP); 573 0 stevel 574 0 stevel if (udp->hash_size == 1) 575 0 stevel finish_init(); 576 0 stevel 577 6247 raf if ((stk || stksize) && stksize < MINSTACK) 578 0 stevel return (EINVAL); 579 0 stevel 580 0 stevel if (stk == NULL) { 581 0 stevel if ((ulwp = find_stack(stksize, guardsize)) == NULL) 582 0 stevel return (ENOMEM); 583 0 stevel stksize = ulwp->ul_mapsiz - ulwp->ul_guardsize; 584 0 stevel } else { 585 0 stevel /* initialize the private stack */ 586 0 stevel if ((ulwp = ulwp_alloc()) == NULL) 587 0 stevel return (ENOMEM); 588 0 stevel ulwp->ul_stk = stk; 589 0 stevel ulwp->ul_stktop = (uintptr_t)stk + stksize; 590 0 stevel ulwp->ul_stksiz = stksize; 591 0 stevel } 592 8486 Roger /* ulwp is not in the hash table; make sure hash_out() doesn't fail */ 593 8486 Roger ulwp->ul_ix = -1; 594 0 stevel ulwp->ul_errnop = &ulwp->ul_errno; 595 0 stevel 596 0 stevel lwp_flags = LWP_SUSPENDED; 597 0 stevel if (flags & (THR_DETACHED|THR_DAEMON)) { 598 0 stevel flags |= THR_DETACHED; 599 0 stevel lwp_flags |= LWP_DETACHED; 600 0 stevel } 601 0 stevel if (flags & THR_DAEMON) 602 0 stevel lwp_flags |= LWP_DAEMON; 603 0 stevel 604 6812 raf /* creating a thread: enforce mt-correctness in mutex_lock() */ 605 0 stevel self->ul_async_safe = 1; 606 0 stevel 607 0 stevel /* per-thread copies of global variables, for speed */ 608 0 stevel ulwp->ul_queue_fifo = self->ul_queue_fifo; 609 0 stevel ulwp->ul_cond_wait_defer = self->ul_cond_wait_defer; 610 0 stevel ulwp->ul_error_detection = self->ul_error_detection; 611 0 stevel ulwp->ul_async_safe = self->ul_async_safe; 612 0 stevel ulwp->ul_max_spinners = self->ul_max_spinners; 613 0 stevel ulwp->ul_adaptive_spin = self->ul_adaptive_spin; 614 0 stevel ulwp->ul_queue_spin = self->ul_queue_spin; 615 0 stevel ulwp->ul_door_noreserve = self->ul_door_noreserve; 616 7255 raf ulwp->ul_misaligned = self->ul_misaligned; 617 6247 raf 618 6247 raf /* new thread inherits creating thread's scheduling parameters */ 619 6247 raf ulwp->ul_policy = self->ul_policy; 620 6247 raf ulwp->ul_pri = (self->ul_epri? self->ul_epri : self->ul_pri); 621 6247 raf ulwp->ul_cid = self->ul_cid; 622 6247 raf ulwp->ul_rtclassid = self->ul_rtclassid; 623 0 stevel 624 0 stevel ulwp->ul_primarymap = self->ul_primarymap; 625 0 stevel ulwp->ul_self = ulwp; 626 0 stevel ulwp->ul_uberdata = udp; 627 0 stevel 628 0 stevel /* debugger support */ 629 0 stevel ulwp->ul_usropts = flags; 630 0 stevel 631 0 stevel #ifdef __sparc 632 0 stevel /* 633 0 stevel * We cache several instructions in the thread structure for use 634 0 stevel * by the fasttrap DTrace provider. When changing this, read the 635 0 stevel * comment in fasttrap.h for the all the other places that must 636 0 stevel * be changed. 637 0 stevel */ 638 0 stevel ulwp->ul_dsave = 0x9de04000; /* save %g1, %g0, %sp */ 639 0 stevel ulwp->ul_drestore = 0x81e80000; /* restore %g0, %g0, %g0 */ 640 0 stevel ulwp->ul_dftret = 0x91d0203a; /* ta 0x3a */ 641 0 stevel ulwp->ul_dreturn = 0x81ca0000; /* return %o0 */ 642 0 stevel #endif 643 0 stevel 644 0 stevel ulwp->ul_startpc = func; 645 0 stevel ulwp->ul_startarg = arg; 646 0 stevel _fpinherit(ulwp); 647 0 stevel /* 648 0 stevel * Defer signals on the new thread until its TLS constructors 649 6812 raf * have been called. _thrp_setup() will call sigon() after 650 0 stevel * it has called tls_setup(). 651 0 stevel */ 652 0 stevel ulwp->ul_sigdefer = 1; 653 0 stevel 654 7657 Roger error = setup_context(&uc, _thrp_setup, ulwp, 655 7657 Roger (caddr_t)ulwp->ul_stk + ulwp->ul_guardsize, stksize); 656 7657 Roger if (error != 0 && stk != NULL) /* inaccessible stack */ 657 7657 Roger error = EFAULT; 658 0 stevel 659 0 stevel /* 660 0 stevel * Call enter_critical() to avoid being suspended until we 661 0 stevel * have linked the new thread into the proper lists. 662 0 stevel * This is necessary because forkall() and fork1() must 663 0 stevel * suspend all threads and they must see a complete list. 664 0 stevel */ 665 0 stevel enter_critical(self); 666 0 stevel uc.uc_sigmask = ulwp->ul_sigmask = self->ul_sigmask; 667 0 stevel if (error != 0 || 668 0 stevel (error = __lwp_create(&uc, lwp_flags, &tid)) != 0) { 669 0 stevel exit_critical(self); 670 0 stevel ulwp->ul_lwpid = (lwpid_t)(-1); 671 0 stevel ulwp->ul_dead = 1; 672 0 stevel ulwp->ul_detached = 1; 673 0 stevel lmutex_lock(&udp->link_lock); 674 0 stevel ulwp_free(ulwp); 675 0 stevel lmutex_unlock(&udp->link_lock); 676 0 stevel return (error); 677 0 stevel } 678 0 stevel self->ul_nocancel = 0; /* cancellation is now possible */ 679 0 stevel udp->uberflags.uf_mt = 1; 680 0 stevel if (new_thread) 681 0 stevel *new_thread = tid; 682 0 stevel if (flags & THR_DETACHED) 683 0 stevel ulwp->ul_detached = 1; 684 0 stevel ulwp->ul_lwpid = tid; 685 0 stevel ulwp->ul_stop = TSTP_REGULAR; 686 3512 raf if (flags & THR_SUSPENDED) 687 3512 raf ulwp->ul_created = 1; 688 0 stevel 689 0 stevel lmutex_lock(&udp->link_lock); 690 0 stevel ulwp->ul_forw = udp->all_lwps; 691 0 stevel ulwp->ul_back = udp->all_lwps->ul_back; 692 0 stevel ulwp->ul_back->ul_forw = ulwp; 693 0 stevel ulwp->ul_forw->ul_back = ulwp; 694 0 stevel hash_in(ulwp, udp); 695 0 stevel udp->nthreads++; 696 0 stevel if (flags & THR_DAEMON) 697 0 stevel udp->ndaemons++; 698 0 stevel if (flags & THR_NEW_LWP) 699 0 stevel thr_concurrency++; 700 1672 raf __libc_threaded = 1; /* inform stdio */ 701 0 stevel lmutex_unlock(&udp->link_lock); 702 0 stevel 703 0 stevel if (__td_event_report(self, TD_CREATE, udp)) { 704 0 stevel self->ul_td_evbuf.eventnum = TD_CREATE; 705 0 stevel self->ul_td_evbuf.eventdata = (void *)(uintptr_t)tid; 706 0 stevel tdb_event(TD_CREATE, udp); 707 0 stevel } 708 0 stevel 709 0 stevel exit_critical(self); 710 3512 raf 711 3512 raf if (!(flags & THR_SUSPENDED)) 712 3512 raf (void) _thrp_continue(tid, TSTP_REGULAR); 713 3512 raf 714 0 stevel return (0); 715 0 stevel } 716 0 stevel 717 0 stevel int 718 6812 raf thr_create(void *stk, size_t stksize, void *(*func)(void *), void *arg, 719 0 stevel long flags, thread_t *new_thread) 720 0 stevel { 721 6247 raf return (_thrp_create(stk, stksize, func, arg, flags, new_thread, 0)); 722 0 stevel } 723 0 stevel 724 0 stevel /* 725 0 stevel * A special cancellation cleanup hook for DCE. 726 0 stevel * cleanuphndlr, when it is not NULL, will contain a callback 727 0 stevel * function to be called before a thread is terminated in 728 6812 raf * thr_exit() as a result of being cancelled. 729 0 stevel */ 730 0 stevel static void (*cleanuphndlr)(void) = NULL; 731 0 stevel 732 0 stevel /* 733 0 stevel * _pthread_setcleanupinit: sets the cleanup hook. 734 0 stevel */ 735 0 stevel int 736 0 stevel _pthread_setcleanupinit(void (*func)(void)) 737 0 stevel { 738 0 stevel cleanuphndlr = func; 739 0 stevel return (0); 740 0 stevel } 741 0 stevel 742 0 stevel void 743 0 stevel _thrp_exit() 744 0 stevel { 745 0 stevel ulwp_t *self = curthread; 746 0 stevel uberdata_t *udp = self->ul_uberdata; 747 0 stevel ulwp_t *replace = NULL; 748 0 stevel 749 0 stevel if (__td_event_report(self, TD_DEATH, udp)) { 750 0 stevel self->ul_td_evbuf.eventnum = TD_DEATH; 751 0 stevel tdb_event(TD_DEATH, udp); 752 0 stevel } 753 0 stevel 754 0 stevel ASSERT(self->ul_sigdefer != 0); 755 0 stevel 756 0 stevel lmutex_lock(&udp->link_lock); 757 0 stevel udp->nthreads--; 758 0 stevel if (self->ul_usropts & THR_NEW_LWP) 759 0 stevel thr_concurrency--; 760 0 stevel if (self->ul_usropts & THR_DAEMON) 761 0 stevel udp->ndaemons--; 762 0 stevel else if (udp->nthreads == udp->ndaemons) { 763 0 stevel /* 764 0 stevel * We are the last non-daemon thread exiting. 765 0 stevel * Exit the process. We retain our TSD and TLS so 766 0 stevel * that atexit() application functions can use them. 767 0 stevel */ 768 0 stevel lmutex_unlock(&udp->link_lock); 769 0 stevel exit(0); 770 0 stevel thr_panic("_thrp_exit(): exit(0) returned"); 771 0 stevel } 772 0 stevel lmutex_unlock(&udp->link_lock); 773 0 stevel 774 4574 raf tsd_exit(); /* deallocate thread-specific data */ 775 4574 raf tls_exit(); /* deallocate thread-local storage */ 776 4574 raf heldlock_exit(); /* deal with left-over held locks */ 777 0 stevel 778 0 stevel /* block all signals to finish exiting */ 779 0 stevel block_all_signals(self); 780 0 stevel /* also prevent ourself from being suspended */ 781 0 stevel enter_critical(self); 782 0 stevel rwl_free(self); 783 0 stevel lmutex_lock(&udp->link_lock); 784 0 stevel ulwp_free(self); 785 0 stevel (void) ulwp_lock(self, udp); 786 0 stevel 787 0 stevel if (self->ul_mapsiz && !self->ul_detached) { 788 0 stevel /* 789 0 stevel * We want to free the stack for reuse but must keep 790 0 stevel * the ulwp_t struct for the benefit of thr_join(). 791 0 stevel * For this purpose we allocate a replacement ulwp_t. 792 0 stevel */ 793 0 stevel if ((replace = udp->ulwp_replace_free) == NULL) 794 0 stevel replace = lmalloc(REPLACEMENT_SIZE); 795 0 stevel else if ((udp->ulwp_replace_free = replace->ul_next) == NULL) 796 0 stevel udp->ulwp_replace_last = NULL; 797 0 stevel } 798 0 stevel 799 0 stevel if (udp->all_lwps == self) 800 0 stevel udp->all_lwps = self->ul_forw; 801 0 stevel if (udp->all_lwps == self) 802 0 stevel udp->all_lwps = NULL; 803 0 stevel else { 804 0 stevel self->ul_forw->ul_back = self->ul_back; 805 0 stevel self->ul_back->ul_forw = self->ul_forw; 806 0 stevel } 807 0 stevel self->ul_forw = self->ul_back = NULL; 808 6247 raf #if defined(THREAD_DEBUG) 809 0 stevel /* collect queue lock statistics before marking ourself dead */ 810 0 stevel record_spin_locks(self); 811 6247 raf #endif 812 0 stevel self->ul_dead = 1; 813 0 stevel self->ul_pleasestop = 0; 814 0 stevel if (replace != NULL) { 815 0 stevel int ix = self->ul_ix; /* the hash index */ 816 6515 raf (void) memcpy(replace, self, REPLACEMENT_SIZE); 817 0 stevel replace->ul_self = replace; 818 0 stevel replace->ul_next = NULL; /* clone not on stack list */ 819 0 stevel replace->ul_mapsiz = 0; /* allows clone to be freed */ 820 0 stevel replace->ul_replace = 1; /* requires clone to be freed */ 821 0 stevel hash_out_unlocked(self, ix, udp); 822 0 stevel hash_in_unlocked(replace, ix, udp); 823 0 stevel ASSERT(!(self->ul_detached)); 824 0 stevel self->ul_detached = 1; /* this frees the stack */ 825 0 stevel self->ul_schedctl = NULL; 826 0 stevel self->ul_schedctl_called = &udp->uberflags; 827 0 stevel set_curthread(self = replace); 828 0 stevel /* 829 0 stevel * Having just changed the address of curthread, we 830 0 stevel * must reset the ownership of the locks we hold so 831 0 stevel * that assertions will not fire when we release them. 832 0 stevel */ 833 0 stevel udp->link_lock.mutex_owner = (uintptr_t)self; 834 0 stevel ulwp_mutex(self, udp)->mutex_owner = (uintptr_t)self; 835 0 stevel /* 836 0 stevel * NOTE: 837 0 stevel * On i386, %gs still references the original, not the 838 0 stevel * replacement, ulwp structure. Fetching the replacement 839 0 stevel * curthread pointer via %gs:0 works correctly since the 840 0 stevel * original ulwp structure will not be reallocated until 841 0 stevel * this lwp has completed its lwp_exit() system call (see 842 0 stevel * dead_and_buried()), but from here on out, we must make 843 0 stevel * no references to %gs:<offset> other than %gs:0. 844 0 stevel */ 845 0 stevel } 846 0 stevel /* 847 0 stevel * Put non-detached terminated threads in the all_zombies list. 848 0 stevel */ 849 0 stevel if (!self->ul_detached) { 850 0 stevel udp->nzombies++; 851 0 stevel if (udp->all_zombies == NULL) { 852 0 stevel ASSERT(udp->nzombies == 1); 853 0 stevel udp->all_zombies = self->ul_forw = self->ul_back = self; 854 0 stevel } else { 855 0 stevel self->ul_forw = udp->all_zombies; 856 0 stevel self->ul_back = udp->all_zombies->ul_back; 857 0 stevel self->ul_back->ul_forw = self; 858 0 stevel self->ul_forw->ul_back = self; 859 0 stevel } 860 0 stevel } 861 0 stevel /* 862 0 stevel * Notify everyone waiting for this thread. 863 0 stevel */ 864 0 stevel ulwp_broadcast(self); 865 0 stevel (void) ulwp_unlock(self, udp); 866 0 stevel /* 867 0 stevel * Prevent any more references to the schedctl data. 868 0 stevel * We are exiting and continue_fork() may not find us. 869 0 stevel * Do this just before dropping link_lock, since fork 870 0 stevel * serializes on link_lock. 871 0 stevel */ 872 0 stevel self->ul_schedctl = NULL; 873 0 stevel self->ul_schedctl_called = &udp->uberflags; 874 0 stevel lmutex_unlock(&udp->link_lock); 875 0 stevel 876 0 stevel ASSERT(self->ul_critical == 1); 877 0 stevel ASSERT(self->ul_preempt == 0); 878 0 stevel _lwp_terminate(); /* never returns */ 879 0 stevel thr_panic("_thrp_exit(): _lwp_terminate() returned"); 880 0 stevel } 881 0 stevel 882 6247 raf #if defined(THREAD_DEBUG) 883 0 stevel void 884 0 stevel collect_queue_statistics() 885 0 stevel { 886 0 stevel uberdata_t *udp = curthread->ul_uberdata; 887 0 stevel ulwp_t *ulwp; 888 0 stevel 889 0 stevel if (thread_queue_dump) { 890 0 stevel lmutex_lock(&udp->link_lock); 891 0 stevel if ((ulwp = udp->all_lwps) != NULL) { 892 0 stevel do { 893 0 stevel record_spin_locks(ulwp); 894 0 stevel } while ((ulwp = ulwp->ul_forw) != udp->all_lwps); 895 0 stevel } 896 0 stevel lmutex_unlock(&udp->link_lock); 897 0 stevel } 898 0 stevel } 899 6247 raf #endif 900 0 stevel 901 6812 raf static void __NORETURN 902 6812 raf _thrp_exit_common(void *status, int unwind) 903 0 stevel { 904 0 stevel ulwp_t *self = curthread; 905 0 stevel int cancelled = (self->ul_cancel_pending && status == PTHREAD_CANCELED); 906 0 stevel 907 0 stevel ASSERT(self->ul_critical == 0 && self->ul_preempt == 0); 908 0 stevel 909 0 stevel /* 910 0 stevel * Disable cancellation and call the special DCE cancellation 911 0 stevel * cleanup hook if it is enabled. Do nothing else before calling 912 0 stevel * the DCE cancellation cleanup hook; it may call longjmp() and 913 0 stevel * never return here. 914 0 stevel */ 915 0 stevel self->ul_cancel_disabled = 1; 916 0 stevel self->ul_cancel_async = 0; 917 0 stevel self->ul_save_async = 0; 918 0 stevel self->ul_cancelable = 0; 919 0 stevel self->ul_cancel_pending = 0; 920 5891 raf set_cancel_pending_flag(self, 1); 921 0 stevel if (cancelled && cleanuphndlr != NULL) 922 0 stevel (*cleanuphndlr)(); 923 0 stevel 924 0 stevel /* 925 0 stevel * Block application signals while we are exiting. 926 0 stevel * We call out to C++, TSD, and TLS destructors while exiting 927 0 stevel * and these are application-defined, so we cannot be assured 928 0 stevel * that they won't reset the signal mask. We use sigoff() to 929 0 stevel * defer any signals that may be received as a result of this 930 0 stevel * bad behavior. Such signals will be lost to the process 931 0 stevel * when the thread finishes exiting. 932 0 stevel */ 933 6812 raf (void) thr_sigsetmask(SIG_SETMASK, &maskset, NULL); 934 0 stevel sigoff(self); 935 0 stevel 936 0 stevel self->ul_rval = status; 937 0 stevel 938 0 stevel /* 939 0 stevel * If thr_exit is being called from the places where 940 0 stevel * C++ destructors are to be called such as cancellation 941 0 stevel * points, then set this flag. It is checked in _t_cancel() 942 0 stevel * to decide whether _ex_unwind() is to be called or not. 943 0 stevel */ 944 0 stevel if (unwind) 945 0 stevel self->ul_unwind = 1; 946 0 stevel 947 0 stevel /* 948 0 stevel * _thrp_unwind() will eventually call _thrp_exit(). 949 0 stevel * It never returns. 950 0 stevel */ 951 0 stevel _thrp_unwind(NULL); 952 6812 raf thr_panic("_thrp_exit_common(): _thrp_unwind() returned"); 953 6812 raf 954 6812 raf for (;;) /* to shut the compiler up about __NORETURN */ 955 6812 raf continue; 956 0 stevel } 957 0 stevel 958 0 stevel /* 959 0 stevel * Called when a thread returns from its start function. 960 0 stevel * We are at the top of the stack; no unwinding is necessary. 961 0 stevel */ 962 0 stevel void 963 6812 raf _thrp_terminate(void *status) 964 0 stevel { 965 6812 raf _thrp_exit_common(status, 0); 966 0 stevel } 967 0 stevel 968 6812 raf #pragma weak pthread_exit = thr_exit 969 6812 raf #pragma weak _thr_exit = thr_exit 970 0 stevel void 971 6812 raf thr_exit(void *status) 972 0 stevel { 973 6812 raf _thrp_exit_common(status, 1); 974 0 stevel } 975 0 stevel 976 0 stevel int 977 0 stevel _thrp_join(thread_t tid, thread_t *departed, void **status, int do_cancel) 978 0 stevel { 979 0 stevel uberdata_t *udp = curthread->ul_uberdata; 980 0 stevel mutex_t *mp; 981 0 stevel void *rval; 982 0 stevel thread_t found; 983 0 stevel ulwp_t *ulwp; 984 0 stevel ulwp_t **ulwpp; 985 0 stevel int replace; 986 0 stevel int error; 987 0 stevel 988 0 stevel if (do_cancel) 989 0 stevel error = lwp_wait(tid, &found); 990 0 stevel else { 991 0 stevel while ((error = __lwp_wait(tid, &found)) == EINTR) 992 0 stevel ; 993 0 stevel } 994 0 stevel if (error) 995 0 stevel return (error); 996 0 stevel 997 0 stevel /* 998 0 stevel * We must hold link_lock to avoid a race condition with find_stack(). 999 0 stevel */ 1000 0 stevel lmutex_lock(&udp->link_lock); 1001 0 stevel if ((ulwpp = find_lwpp(found)) == NULL) { 1002 0 stevel /* 1003 0 stevel * lwp_wait() found an lwp that the library doesn't know 1004 0 stevel * about. It must have been created with _lwp_create(). 1005 0 stevel * Just return its lwpid; we can't know its status. 1006 0 stevel */ 1007 0 stevel lmutex_unlock(&udp->link_lock); 1008 0 stevel rval = NULL; 1009 0 stevel } else { 1010 0 stevel /* 1011 0 stevel * Remove ulwp from the hash table. 1012 0 stevel */ 1013 0 stevel ulwp = *ulwpp; 1014 0 stevel *ulwpp = ulwp->ul_hash; 1015 0 stevel ulwp->ul_hash = NULL; 1016 0 stevel /* 1017 0 stevel * Remove ulwp from all_zombies list. 1018 0 stevel */ 1019 0 stevel ASSERT(udp->nzombies >= 1); 1020 0 stevel if (udp->all_zombies == ulwp) 1021 0 stevel udp->all_zombies = ulwp->ul_forw; 1022 0 stevel if (udp->all_zombies == ulwp) 1023 0 stevel udp->all_zombies = NULL; 1024 0 stevel else { 1025 0 stevel ulwp->ul_forw->ul_back = ulwp->ul_back; 1026 0 stevel ulwp->ul_back->ul_forw = ulwp->ul_forw; 1027 0 stevel } 1028 0 stevel ulwp->ul_forw = ulwp->ul_back = NULL; 1029 0 stevel udp->nzombies--; 1030 0 stevel ASSERT(ulwp->ul_dead && !ulwp->ul_detached && 1031 4843 raf !(ulwp->ul_usropts & (THR_DETACHED|THR_DAEMON))); 1032 0 stevel /* 1033 0 stevel * We can't call ulwp_unlock(ulwp) after we set 1034 0 stevel * ulwp->ul_ix = -1 so we have to get a pointer to the 1035 0 stevel * ulwp's hash table mutex now in order to unlock it below. 1036 0 stevel */ 1037 0 stevel mp = ulwp_mutex(ulwp, udp); 1038 0 stevel ulwp->ul_lwpid = (lwpid_t)(-1); 1039 0 stevel ulwp->ul_ix = -1; 1040 0 stevel rval = ulwp->ul_rval; 1041 0 stevel replace = ulwp->ul_replace; 1042 0 stevel lmutex_unlock(mp); 1043 0 stevel if (replace) { 1044 0 stevel ulwp->ul_next = NULL; 1045 0 stevel if (udp->ulwp_replace_free == NULL) 1046 0 stevel udp->ulwp_replace_free = 1047 4843 raf udp->ulwp_replace_last = ulwp; 1048 0 stevel else { 1049 0 stevel udp->ulwp_replace_last->ul_next = ulwp; 1050 0 stevel udp->ulwp_replace_last = ulwp; 1051 0 stevel } 1052 0 stevel } 1053 0 stevel lmutex_unlock(&udp->link_lock); 1054 0 stevel } 1055 0 stevel 1056 0 stevel if (departed != NULL) 1057 0 stevel *departed = found; 1058 0 stevel if (status != NULL) 1059 0 stevel *status = rval; 1060 0 stevel return (0); 1061 0 stevel } 1062 0 stevel 1063 0 stevel int 1064 6812 raf thr_join(thread_t tid, thread_t *departed, void **status) 1065 0 stevel { 1066 0 stevel int error = _thrp_join(tid, departed, status, 1); 1067 0 stevel return ((error == EINVAL)? ESRCH : error); 1068 0 stevel } 1069 0 stevel 1070 0 stevel /* 1071 0 stevel * pthread_join() differs from Solaris thr_join(): 1072 0 stevel * It does not return the departed thread's id 1073 0 stevel * and hence does not have a "departed" argument. 1074 0 stevel * It returns EINVAL if tid refers to a detached thread. 1075 0 stevel */ 1076 6812 raf #pragma weak _pthread_join = pthread_join 1077 0 stevel int 1078 6812 raf pthread_join(pthread_t tid, void **status) 1079 0 stevel { 1080 0 stevel return ((tid == 0)? ESRCH : _thrp_join(tid, NULL, status, 1)); 1081 0 stevel } 1082 0 stevel 1083 0 stevel int 1084 6812 raf pthread_detach(pthread_t tid) 1085 0 stevel { 1086 0 stevel uberdata_t *udp = curthread->ul_uberdata; 1087 0 stevel ulwp_t *ulwp; 1088 0 stevel ulwp_t **ulwpp; 1089 0 stevel int error = 0; 1090 0 stevel 1091 0 stevel if ((ulwpp = find_lwpp(tid)) == NULL) 1092 0 stevel return (ESRCH); 1093 0 stevel ulwp = *ulwpp; 1094 0 stevel 1095 0 stevel if (ulwp->ul_dead) { 1096 0 stevel ulwp_unlock(ulwp, udp); 1097 0 stevel error = _thrp_join(tid, NULL, NULL, 0); 1098 0 stevel } else { 1099 0 stevel error = __lwp_detach(tid); 1100 0 stevel ulwp->ul_detached = 1; 1101 0 stevel ulwp->ul_usropts |= THR_DETACHED; 1102 0 stevel ulwp_unlock(ulwp, udp); 1103 0 stevel } 1104 0 stevel return (error); 1105 0 stevel } 1106 0 stevel 1107 0 stevel static const char * 1108 0 stevel ematch(const char *ev, const char *match) 1109 0 stevel { 1110 0 stevel int c; 1111 0 stevel 1112 0 stevel while ((c = *match++) != '\0') { 1113 0 stevel if (*ev++ != c) 1114 0 stevel return (NULL); 1115 0 stevel } 1116 0 stevel if (*ev++ != '=') 1117 0 stevel return (NULL); 1118 0 stevel return (ev); 1119 0 stevel } 1120 0 stevel 1121 0 stevel static int 1122 0 stevel envvar(const char *ev, const char *match, int limit) 1123 0 stevel { 1124 0 stevel int val = -1; 1125 0 stevel const char *ename; 1126 0 stevel 1127 0 stevel if ((ename = ematch(ev, match)) != NULL) { 1128 0 stevel int c; 1129 0 stevel for (val = 0; (c = *ename) != '\0'; ename++) { 1130 0 stevel if (!isdigit(c)) { 1131 0 stevel val = -1; 1132 0 stevel break; 1133 0 stevel } 1134 0 stevel val = val * 10 + (c - '0'); 1135 0 stevel if (val > limit) { 1136 0 stevel val = limit; 1137 0 stevel break; 1138 0 stevel } 1139 0 stevel } 1140 0 stevel } 1141 0 stevel return (val); 1142 0 stevel } 1143 0 stevel 1144 0 stevel static void 1145 0 stevel etest(const char *ev) 1146 0 stevel { 1147 0 stevel int value; 1148 0 stevel 1149 0 stevel if ((value = envvar(ev, "QUEUE_SPIN", 1000000)) >= 0) 1150 0 stevel thread_queue_spin = value; 1151 5629 raf if ((value = envvar(ev, "ADAPTIVE_SPIN", 1000000)) >= 0) 1152 0 stevel thread_adaptive_spin = value; 1153 5629 raf if ((value = envvar(ev, "MAX_SPINNERS", 255)) >= 0) 1154 0 stevel thread_max_spinners = value; 1155 0 stevel if ((value = envvar(ev, "QUEUE_FIFO", 8)) >= 0) 1156 0 stevel thread_queue_fifo = value; 1157 0 stevel #if defined(THREAD_DEBUG) 1158 0 stevel if ((value = envvar(ev, "QUEUE_VERIFY", 1)) >= 0) 1159 0 stevel thread_queue_verify = value; 1160 0 stevel if ((value = envvar(ev, "QUEUE_DUMP", 1)) >= 0) 1161 0 stevel thread_queue_dump = value; 1162 6247 raf #endif 1163 0 stevel if ((value = envvar(ev, "STACK_CACHE", 10000)) >= 0) 1164 0 stevel thread_stack_cache = value; 1165 0 stevel if ((value = envvar(ev, "COND_WAIT_DEFER", 1)) >= 0) 1166 0 stevel thread_cond_wait_defer = value; 1167 0 stevel if ((value = envvar(ev, "ERROR_DETECTION", 2)) >= 0) 1168 0 stevel thread_error_detection = value; 1169 0 stevel if ((value = envvar(ev, "ASYNC_SAFE", 1)) >= 0) 1170 0 stevel thread_async_safe = value; 1171 0 stevel if ((value = envvar(ev, "DOOR_NORESERVE", 1)) >= 0) 1172 0 stevel thread_door_noreserve = value; 1173 7255 raf if ((value = envvar(ev, "LOCKS_MISALIGNED", 1)) >= 0) 1174 7255 raf thread_locks_misaligned = value; 1175 0 stevel } 1176 0 stevel 1177 0 stevel /* 1178 0 stevel * Look for and evaluate environment variables of the form "_THREAD_*". 1179 0 stevel * For compatibility with the past, we also look for environment 1180 0 stevel * names of the form "LIBTHREAD_*". 1181 0 stevel */ 1182 0 stevel static void 1183 0 stevel set_thread_vars() 1184 0 stevel { 1185 6879 raf extern const char **_environ; 1186 0 stevel const char **pev; 1187 0 stevel const char *ev; 1188 0 stevel char c; 1189 0 stevel 1190 6879 raf if ((pev = _environ) == NULL) 1191 0 stevel return; 1192 0 stevel while ((ev = *pev++) != NULL) { 1193 0 stevel c = *ev; 1194 6812 raf if (c == '_' && strncmp(ev, "_THREAD_", 8) == 0) 1195 0 stevel etest(ev + 8); 1196 6812 raf if (c == 'L' && strncmp(ev, "LIBTHREAD_", 10) == 0) 1197 0 stevel etest(ev + 10); 1198 0 stevel } 1199 0 stevel } 1200 0 stevel 1201 0 stevel /* PROBE_SUPPORT begin */ 1202 0 stevel #pragma weak __tnf_probe_notify 1203 0 stevel extern void __tnf_probe_notify(void); 1204 0 stevel /* PROBE_SUPPORT end */ 1205 0 stevel 1206 0 stevel /* same as atexit() but private to the library */ 1207 0 stevel extern int _atexit(void (*)(void)); 1208 0 stevel 1209 0 stevel /* same as _cleanup() but private to the library */ 1210 0 stevel extern void __cleanup(void); 1211 0 stevel 1212 0 stevel extern void atfork_init(void); 1213 0 stevel 1214 0 stevel #ifdef __amd64 1215 6320 bholler extern void __proc64id(void); 1216 0 stevel #endif 1217 0 stevel 1218 0 stevel /* 1219 0 stevel * libc_init() is called by ld.so.1 for library initialization. 1220 0 stevel * We perform minimal initialization; enough to work with the main thread. 1221 0 stevel */ 1222 0 stevel void 1223 0 stevel libc_init(void) 1224 0 stevel { 1225 0 stevel uberdata_t *udp = &__uberdata; 1226 0 stevel ulwp_t *oldself = __curthread(); 1227 0 stevel ucontext_t uc; 1228 0 stevel ulwp_t *self; 1229 0 stevel struct rlimit rl; 1230 0 stevel caddr_t data; 1231 0 stevel size_t tls_size; 1232 0 stevel int setmask; 1233 0 stevel 1234 0 stevel /* 1235 0 stevel * For the initial stage of initialization, we must be careful 1236 0 stevel * not to call any function that could possibly call _cerror(). 1237 0 stevel * For this purpose, we call only the raw system call wrappers. 1238 0 stevel */ 1239 0 stevel 1240 0 stevel #ifdef __amd64 1241 0 stevel /* 1242 0 stevel * Gather information about cache layouts for optimized 1243 6320 bholler * AMD and Intel assembler strfoo() and memfoo() functions. 1244 0 stevel */ 1245 6320 bholler __proc64id(); 1246 0 stevel #endif 1247 0 stevel 1248 0 stevel /* 1249 0 stevel * Every libc, regardless of which link map, must register __cleanup(). 1250 0 stevel */ 1251 0 stevel (void) _atexit(__cleanup); 1252 0 stevel 1253 0 stevel /* 1254 0 stevel * We keep our uberdata on one of (a) the first alternate link map 1255 0 stevel * or (b) the primary link map. We switch to the primary link map 1256 0 stevel * and stay there once we see it. All intermediate link maps are 1257 0 stevel * subject to being unloaded at any time. 1258 0 stevel */ 1259 0 stevel if (oldself != NULL && (oldself->ul_primarymap || !primary_link_map)) { 1260 0 stevel __tdb_bootstrap = oldself->ul_uberdata->tdb_bootstrap; 1261 0 stevel mutex_setup(); 1262 0 stevel atfork_init(); /* every link map needs atfork() processing */ 1263 0 stevel return; 1264 0 stevel } 1265 0 stevel 1266 0 stevel /* 1267 0 stevel * To establish the main stack information, we have to get our context. 1268 0 stevel * This is also convenient to use for getting our signal mask. 1269 0 stevel */ 1270 0 stevel uc.uc_flags = UC_ALL; 1271 6515 raf (void) __getcontext(&uc); 1272 0 stevel ASSERT(uc.uc_link == NULL); 1273 0 stevel 1274 0 stevel tls_size = roundup64(udp->tls_metadata.static_tls.tls_size); 1275 0 stevel ASSERT(primary_link_map || tls_size == 0); 1276 0 stevel data = lmalloc(sizeof (ulwp_t) + tls_size); 1277 0 stevel if (data == NULL) 1278 0 stevel thr_panic("cannot allocate thread structure for main thread"); 1279 0 stevel /* LINTED pointer cast may result in improper alignment */ 1280 0 stevel self = (ulwp_t *)(data + tls_size); 1281 0 stevel init_hash_table[0].hash_bucket = self; 1282 0 stevel 1283 0 stevel self->ul_sigmask = uc.uc_sigmask; 1284 0 stevel delete_reserved_signals(&self->ul_sigmask); 1285 0 stevel /* 1286 0 stevel * Are the old and new sets different? 1287 0 stevel * (This can happen if we are currently blocking SIGCANCEL.) 1288 0 stevel * If so, we must explicitly set our signal mask, below. 1289 0 stevel */ 1290 0 stevel setmask = 1291 0 stevel ((self->ul_sigmask.__sigbits[0] ^ uc.uc_sigmask.__sigbits[0]) | 1292 0 stevel (self->ul_sigmask.__sigbits[1] ^ uc.uc_sigmask.__sigbits[1])); 1293 0 stevel 1294 0 stevel #ifdef __sparc 1295 0 stevel /* 1296 0 stevel * We cache several instructions in the thread structure for use 1297 0 stevel * by the fasttrap DTrace provider. When changing this, read the 1298 0 stevel * comment in fasttrap.h for the all the other places that must 1299 0 stevel * be changed. 1300 0 stevel */ 1301 0 stevel self->ul_dsave = 0x9de04000; /* save %g1, %g0, %sp */ 1302 0 stevel self->ul_drestore = 0x81e80000; /* restore %g0, %g0, %g0 */ 1303 0 stevel self->ul_dftret = 0x91d0203a; /* ta 0x3a */ 1304 0 stevel self->ul_dreturn = 0x81ca0000; /* return %o0 */ 1305 0 stevel #endif 1306 0 stevel 1307 5891 raf self->ul_stktop = (uintptr_t)uc.uc_stack.ss_sp + uc.uc_stack.ss_size; 1308 6515 raf (void) getrlimit(RLIMIT_STACK, &rl); 1309 0 stevel self->ul_stksiz = rl.rlim_cur; 1310 0 stevel self->ul_stk = (caddr_t)(self->ul_stktop - self->ul_stksiz); 1311 0 stevel 1312 0 stevel self->ul_forw = self->ul_back = self; 1313 0 stevel self->ul_hash = NULL; 1314 0 stevel self->ul_ix = 0; 1315 6812 raf self->ul_lwpid = 1; /* _lwp_self() */ 1316 0 stevel self->ul_main = 1; 1317 0 stevel self->ul_self = self; 1318 6247 raf self->ul_policy = -1; /* initialize only when needed */ 1319 6247 raf self->ul_pri = 0; 1320 6247 raf self->ul_cid = 0; 1321 6296 raf self->ul_rtclassid = -1; 1322 0 stevel self->ul_uberdata = udp; 1323 0 stevel if (oldself != NULL) { 1324 0 stevel int i; 1325 0 stevel 1326 0 stevel ASSERT(primary_link_map); 1327 0 stevel ASSERT(oldself->ul_main == 1); 1328 0 stevel self->ul_stsd = oldself->ul_stsd; 1329 0 stevel for (i = 0; i < TSD_NFAST; i++) 1330 0 stevel self->ul_ftsd[i] = oldself->ul_ftsd[i]; 1331 0 stevel self->ul_tls = oldself->ul_tls; 1332 0 stevel /* 1333 0 stevel * Retrieve all pointers to uberdata allocated 1334 0 stevel * while running on previous link maps. 1335 1111 raf * We would like to do a structure assignment here, but 1336 1111 raf * gcc turns structure assignments into calls to memcpy(), 1337 1111 raf * a function exported from libc. We can't call any such 1338 1111 raf * external functions until we establish curthread, below, 1339 1111 raf * so we just call our private version of memcpy(). 1340 0 stevel */ 1341 6515 raf (void) memcpy(udp, oldself->ul_uberdata, sizeof (*udp)); 1342 0 stevel /* 1343 0 stevel * These items point to global data on the primary link map. 1344 0 stevel */ 1345 0 stevel udp->thr_hash_table = init_hash_table; 1346 0 stevel udp->sigacthandler = sigacthandler; 1347 0 stevel udp->tdb.tdb_events = tdb_events; 1348 0 stevel ASSERT(udp->nthreads == 1 && !udp->uberflags.uf_mt); 1349 0 stevel ASSERT(udp->lwp_stacks == NULL); 1350 0 stevel ASSERT(udp->ulwp_freelist == NULL); 1351 0 stevel ASSERT(udp->ulwp_replace_free == NULL); 1352 0 stevel ASSERT(udp->hash_size == 1); 1353 0 stevel } 1354 0 stevel udp->all_lwps = self; 1355 0 stevel udp->ulwp_one = self; 1356 6515 raf udp->pid = getpid(); 1357 0 stevel udp->nthreads = 1; 1358 0 stevel /* 1359 0 stevel * In every link map, tdb_bootstrap points to the same piece of 1360 0 stevel * allocated memory. When the primary link map is initialized, 1361 0 stevel * the allocated memory is assigned a pointer to the one true 1362 0 stevel * uberdata. This allows libc_db to initialize itself regardless 1363 0 stevel * of which instance of libc it finds in the address space. 1364 0 stevel */ 1365 0 stevel if (udp->tdb_bootstrap == NULL) 1366 0 stevel udp->tdb_bootstrap = lmalloc(sizeof (uberdata_t *)); 1367 0 stevel __tdb_bootstrap = udp->tdb_bootstrap; 1368 0 stevel if (primary_link_map) { 1369 0 stevel self->ul_primarymap = 1; 1370 0 stevel udp->primary_map = 1; 1371 0 stevel *udp->tdb_bootstrap = udp; 1372 0 stevel } 1373 0 stevel /* 1374 0 stevel * Cancellation can't happen until: 1375 0 stevel * pthread_cancel() is called 1376 0 stevel * or: 1377 0 stevel * another thread is created 1378 0 stevel * For now, as a single-threaded process, set the flag that tells 1379 0 stevel * PROLOGUE/EPILOGUE (in scalls.c) that cancellation can't happen. 1380 0 stevel */ 1381 0 stevel self->ul_nocancel = 1; 1382 0 stevel 1383 0 stevel #if defined(__amd64) 1384 3446 mrj (void) ___lwp_private(_LWP_SETPRIVATE, _LWP_FSBASE, self); 1385 0 stevel #elif defined(__i386) 1386 3446 mrj (void) ___lwp_private(_LWP_SETPRIVATE, _LWP_GSBASE, self); 1387 0 stevel #endif /* __i386 || __amd64 */ 1388 0 stevel set_curthread(self); /* redundant on i386 */ 1389 0 stevel /* 1390 0 stevel * Now curthread is established and it is safe to call any 1391 0 stevel * function in libc except one that uses thread-local storage. 1392 0 stevel */ 1393 0 stevel self->ul_errnop = &errno; 1394 0 stevel if (oldself != NULL) { 1395 0 stevel /* tls_size was zero when oldself was allocated */ 1396 0 stevel lfree(oldself, sizeof (ulwp_t)); 1397 0 stevel } 1398 0 stevel mutex_setup(); 1399 0 stevel atfork_init(); 1400 0 stevel signal_init(); 1401 0 stevel 1402 0 stevel /* 1403 0 stevel * If the stack is unlimited, we set the size to zero to disable 1404 0 stevel * stack checking. 1405 0 stevel * XXX: Work harder here. Get the stack size from /proc/self/rmap 1406 0 stevel */ 1407 0 stevel if (self->ul_stksiz == RLIM_INFINITY) { 1408 0 stevel self->ul_ustack.ss_sp = (void *)self->ul_stktop; 1409 0 stevel self->ul_ustack.ss_size = 0; 1410 0 stevel } else { 1411 0 stevel self->ul_ustack.ss_sp = self->ul_stk; 1412 0 stevel self->ul_ustack.ss_size = self->ul_stksiz; 1413 0 stevel } 1414 0 stevel self->ul_ustack.ss_flags = 0; 1415 6515 raf (void) setustack(&self->ul_ustack); 1416 0 stevel 1417 0 stevel /* 1418 0 stevel * Get the variables that affect thread behavior from the environment. 1419 0 stevel */ 1420 0 stevel set_thread_vars(); 1421 0 stevel udp->uberflags.uf_thread_error_detection = (char)thread_error_detection; 1422 0 stevel udp->thread_stack_cache = thread_stack_cache; 1423 0 stevel 1424 0 stevel /* 1425 0 stevel * Make per-thread copies of global variables, for speed. 1426 0 stevel */ 1427 0 stevel self->ul_queue_fifo = (char)thread_queue_fifo; 1428 0 stevel self->ul_cond_wait_defer = (char)thread_cond_wait_defer; 1429 0 stevel self->ul_error_detection = (char)thread_error_detection; 1430 0 stevel self->ul_async_safe = (char)thread_async_safe; 1431 0 stevel self->ul_door_noreserve = (char)thread_door_noreserve; 1432 7255 raf self->ul_misaligned = (char)thread_locks_misaligned; 1433 5629 raf self->ul_max_spinners = (uint8_t)thread_max_spinners; 1434 0 stevel self->ul_adaptive_spin = thread_adaptive_spin; 1435 0 stevel self->ul_queue_spin = thread_queue_spin; 1436 10629 Roger 1437 10629 Roger #if defined(__sparc) && !defined(_LP64) 1438 10629 Roger if (self->ul_misaligned) { 1439 10629 Roger /* 1440 10629 Roger * Tell the kernel to fix up ldx/stx instructions that 1441 10629 Roger * refer to non-8-byte aligned data instead of giving 1442 10629 Roger * the process an alignment trap and generating SIGBUS. 1443 10629 Roger * 1444 10629 Roger * Programs compiled for 32-bit sparc with the Studio SS12 1445 10629 Roger * compiler get this done for them automatically (in _init()). 1446 10629 Roger * We do it here for the benefit of programs compiled with 1447 10629 Roger * other compilers, like gcc. 1448 10629 Roger * 1449 10629 Roger * This is necessary for the _THREAD_LOCKS_MISALIGNED=1 1450 10629 Roger * environment variable horrible hack to work. 1451 10629 Roger */ 1452 10629 Roger extern void _do_fix_align(void); 1453 10629 Roger _do_fix_align(); 1454 10629 Roger } 1455 10629 Roger #endif 1456 0 stevel 1457 0 stevel /* 1458 0 stevel * When we have initialized the primary link map, inform 1459 0 stevel * the dynamic linker about our interface functions. 1460 0 stevel */ 1461 0 stevel if (self->ul_primarymap) 1462 0 stevel _ld_libc((void *)rtld_funcs); 1463 0 stevel 1464 0 stevel /* 1465 0 stevel * Defer signals until TLS constructors have been called. 1466 0 stevel */ 1467 0 stevel sigoff(self); 1468 0 stevel tls_setup(); 1469 0 stevel sigon(self); 1470 0 stevel if (setmask) 1471 0 stevel (void) restore_signals(self); 1472 5891 raf 1473 5891 raf /* 1474 5891 raf * Make private copies of __xpg4 and __xpg6 so libc can test 1475 5891 raf * them after this point without invoking the dynamic linker. 1476 5891 raf */ 1477 5891 raf libc__xpg4 = __xpg4; 1478 5891 raf libc__xpg6 = __xpg6; 1479 0 stevel 1480 0 stevel /* PROBE_SUPPORT begin */ 1481 0 stevel if (self->ul_primarymap && __tnf_probe_notify != NULL) 1482 0 stevel __tnf_probe_notify(); 1483 0 stevel /* PROBE_SUPPORT end */ 1484 2248 raf 1485 2248 raf init_sigev_thread(); 1486 2248 raf init_aio(); 1487 2692 nakanon 1488 2692 nakanon /* 1489 2692 nakanon * We need to reset __threaded dynamically at runtime, so that 1490 2692 nakanon * __threaded can be bound to __threaded outside libc which may not 1491 2692 nakanon * have initial value of 1 (without a copy relocation in a.out). 1492 2692 nakanon */ 1493 2692 nakanon __threaded = 1; 1494 0 stevel } 1495 0 stevel 1496 0 stevel #pragma fini(libc_fini) 1497 0 stevel void 1498 0 stevel libc_fini() 1499 0 stevel { 1500 0 stevel /* 1501 0 stevel * If we are doing fini processing for the instance of libc 1502 0 stevel * on the first alternate link map (this happens only when 1503 0 stevel * the dynamic linker rejects a bad audit library), then clear 1504 0 stevel * __curthread(). We abandon whatever memory was allocated by 1505 0 stevel * lmalloc() while running on this alternate link-map but we 1506 0 stevel * don't care (and can't find the memory in any case); we just 1507 0 stevel * want to protect the application from this bad audit library. 1508 0 stevel * No fini processing is done by libc in the normal case. 1509 0 stevel */ 1510 0 stevel 1511 0 stevel uberdata_t *udp = curthread->ul_uberdata; 1512 0 stevel 1513 0 stevel if (udp->primary_map == 0 && udp == &__uberdata) 1514 0 stevel set_curthread(NULL); 1515 0 stevel } 1516 0 stevel 1517 0 stevel /* 1518 0 stevel * finish_init is called when we are about to become multi-threaded, 1519 0 stevel * that is, on the first call to thr_create(). 1520 0 stevel */ 1521 0 stevel void 1522 0 stevel finish_init() 1523 0 stevel { 1524 0 stevel ulwp_t *self = curthread; 1525 0 stevel uberdata_t *udp = self->ul_uberdata; 1526 0 stevel thr_hash_table_t *htp; 1527 0 stevel void *data; 1528 0 stevel int i; 1529 0 stevel 1530 0 stevel /* 1531 0 stevel * No locks needed here; we are single-threaded on the first call. 1532 0 stevel * We can be called only after the primary link map has been set up. 1533 0 stevel */ 1534 0 stevel ASSERT(self->ul_primarymap); 1535 0 stevel ASSERT(self == udp->ulwp_one); 1536 0 stevel ASSERT(!udp->uberflags.uf_mt); 1537 0 stevel ASSERT(udp->hash_size == 1); 1538 0 stevel 1539 0 stevel /* 1540 6247 raf * Initialize self->ul_policy, self->ul_cid, and self->ul_pri. 1541 6247 raf */ 1542 6247 raf update_sched(self); 1543 6247 raf 1544 6247 raf /* 1545 6247 raf * Allocate the queue_head array if not already allocated. 1546 0 stevel */ 1547 0 stevel if (udp->queue_head == NULL) 1548 0 stevel queue_alloc(); 1549 0 stevel 1550 0 stevel /* 1551 0 stevel * Now allocate the thread hash table. 1552 0 stevel */ 1553 6515 raf if ((data = mmap(NULL, HASHTBLSZ * sizeof (thr_hash_table_t), 1554 0 stevel PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON, -1, (off_t)0)) 1555 0 stevel == MAP_FAILED) 1556 0 stevel thr_panic("cannot allocate thread hash table"); 1557 0 stevel 1558 0 stevel udp->thr_hash_table = htp = (thr_hash_table_t *)data; 1559 0 stevel udp->hash_size = HASHTBLSZ; 1560 0 stevel udp->hash_mask = HASHTBLSZ - 1; 1561 0 stevel 1562 0 stevel for (i = 0; i < HASHTBLSZ; i++, htp++) { 1563 4574 raf htp->hash_lock.mutex_flag = LOCK_INITED; 1564 0 stevel htp->hash_lock.mutex_magic = MUTEX_MAGIC; 1565 0 stevel htp->hash_cond.cond_magic = COND_MAGIC; 1566 0 stevel } 1567 0 stevel hash_in_unlocked(self, TIDHASH(self->ul_lwpid, udp), udp); 1568 0 stevel 1569 0 stevel /* 1570 0 stevel * Set up the SIGCANCEL handler for threads cancellation. 1571 0 stevel */ 1572 2248 raf setup_cancelsig(SIGCANCEL); 1573 0 stevel 1574 0 stevel /* 1575 0 stevel * Arrange to do special things on exit -- 1576 0 stevel * - collect queue statistics from all remaining active threads. 1577 6247 raf * - dump queue statistics to stderr if _THREAD_QUEUE_DUMP is set. 1578 0 stevel * - grab assert_lock to ensure that assertion failures 1579 0 stevel * and a core dump take precedence over _exit(). 1580 0 stevel * (Functions are called in the reverse order of their registration.) 1581 0 stevel */ 1582 6247 raf (void) _atexit(grab_assert_lock); 1583 6247 raf #if defined(THREAD_DEBUG) 1584 0 stevel (void) _atexit(dump_queue_statistics); 1585 0 stevel (void) _atexit(collect_queue_statistics); 1586 6247 raf #endif 1587 0 stevel } 1588 0 stevel 1589 0 stevel /* 1590 3235 raf * Used only by postfork1_child(), below. 1591 0 stevel */ 1592 0 stevel static void 1593 0 stevel mark_dead_and_buried(ulwp_t *ulwp) 1594 0 stevel { 1595 0 stevel ulwp->ul_dead = 1; 1596 0 stevel ulwp->ul_lwpid = (lwpid_t)(-1); 1597 0 stevel ulwp->ul_hash = NULL; 1598 0 stevel ulwp->ul_ix = -1; 1599 0 stevel ulwp->ul_schedctl = NULL; 1600 0 stevel ulwp->ul_schedctl_called = NULL; 1601 0 stevel } 1602 0 stevel 1603 0 stevel /* 1604 0 stevel * This is called from fork1() in the child. 1605 0 stevel * Reset our data structures to reflect one lwp. 1606 0 stevel */ 1607 0 stevel void 1608 2248 raf postfork1_child() 1609 0 stevel { 1610 0 stevel ulwp_t *self = curthread; 1611 0 stevel uberdata_t *udp = self->ul_uberdata; 1612 6247 raf queue_head_t *qp; 1613 0 stevel ulwp_t *next; 1614 0 stevel ulwp_t *ulwp; 1615 0 stevel int i; 1616 0 stevel 1617 0 stevel /* daemon threads shouldn't call fork1(), but oh well... */ 1618 0 stevel self->ul_usropts &= ~THR_DAEMON; 1619 0 stevel udp->nthreads = 1; 1620 0 stevel udp->ndaemons = 0; 1621 0 stevel udp->uberflags.uf_mt = 0; 1622 1672 raf __libc_threaded = 0; 1623 0 stevel for (i = 0; i < udp->hash_size; i++) 1624 0 stevel udp->thr_hash_table[i].hash_bucket = NULL; 1625 6812 raf self->ul_lwpid = _lwp_self(); 1626 0 stevel hash_in_unlocked(self, TIDHASH(self->ul_lwpid, udp), udp); 1627 0 stevel 1628 5002 raf /* 1629 6515 raf * Some thread in the parent might have been suspended 1630 6515 raf * while holding udp->callout_lock or udp->ld_lock. 1631 6515 raf * Reinitialize the child's copies. 1632 5002 raf */ 1633 6812 raf (void) mutex_init(&udp->callout_lock, 1634 6812 raf USYNC_THREAD | LOCK_RECURSIVE, NULL); 1635 6812 raf (void) mutex_init(&udp->ld_lock, 1636 6812 raf USYNC_THREAD | LOCK_RECURSIVE, NULL); 1637 5002 raf 1638 0 stevel /* no one in the child is on a sleep queue; reinitialize */ 1639 6247 raf if ((qp = udp->queue_head) != NULL) { 1640 6515 raf (void) memset(qp, 0, 2 * QHASHSIZE * sizeof (queue_head_t)); 1641 6247 raf for (i = 0; i < 2 * QHASHSIZE; qp++, i++) { 1642 6247 raf qp->qh_type = (i < QHASHSIZE)? MX : CV; 1643 6247 raf qp->qh_lock.mutex_flag = LOCK_INITED; 1644 6247 raf qp->qh_lock.mutex_magic = MUTEX_MAGIC; 1645 6247 raf qp->qh_hlist = &qp->qh_def_root; 1646 6247 raf #if defined(THREAD_DEBUG) 1647 6247 raf qp->qh_hlen = 1; 1648 6247 raf qp->qh_hmax = 1; 1649 6247 raf #endif 1650 4574 raf } 1651 0 stevel } 1652 0 stevel 1653 0 stevel /* 1654 0 stevel * All lwps except ourself are gone. Mark them so. 1655 0 stevel * First mark all of the lwps that have already been freed. 1656 0 stevel * Then mark and free all of the active lwps except ourself. 1657 0 stevel * Since we are single-threaded, no locks are required here. 1658 0 stevel */ 1659 0 stevel for (ulwp = udp->lwp_stacks; ulwp != NULL; ulwp = ulwp->ul_next) 1660 0 stevel mark_dead_and_buried(ulwp); 1661 0 stevel for (ulwp = udp->ulwp_freelist; ulwp != NULL; ulwp = ulwp->ul_next) 1662 0 stevel mark_dead_and_buried(ulwp); 1663 0 stevel for (ulwp = self->ul_forw; ulwp != self; ulwp = next) { 1664 0 stevel next = ulwp->ul_forw; 1665 0 stevel ulwp->ul_forw = ulwp->ul_back = NULL; 1666 0 stevel mark_dead_and_buried(ulwp); 1667 0 stevel tsd_free(ulwp); 1668 0 stevel tls_free(ulwp); 1669 0 stevel rwl_free(ulwp); 1670 4574 raf heldlock_free(ulwp); 1671 0 stevel ulwp_free(ulwp); 1672 0 stevel } 1673 0 stevel self->ul_forw = self->ul_back = udp->all_lwps = self; 1674 0 stevel if (self != udp->ulwp_one) 1675 0 stevel mark_dead_and_buried(udp->ulwp_one); 1676 0 stevel if ((ulwp = udp->all_zombies) != NULL) { 1677 0 stevel ASSERT(udp->nzombies != 0); 1678 0 stevel do { 1679 0 stevel next = ulwp->ul_forw; 1680 0 stevel ulwp->ul_forw = ulwp->ul_back = NULL; 1681 0 stevel mark_dead_and_buried(ulwp); 1682 0 stevel udp->nzombies--; 1683 0 stevel if (ulwp->ul_replace) { 1684 0 stevel ulwp->ul_next = NULL; 1685 0 stevel if (udp->ulwp_replace_free == NULL) { 1686 0 stevel udp->ulwp_replace_free = 1687 4843 raf udp->ulwp_replace_last = ulwp; 1688 0 stevel } else { 1689 0 stevel udp->ulwp_replace_last->ul_next = ulwp; 1690 0 stevel udp->ulwp_replace_last = ulwp; 1691 0 stevel } 1692 0 stevel } 1693 0 stevel } while ((ulwp = next) != udp->all_zombies); 1694 0 stevel ASSERT(udp->nzombies == 0); 1695 0 stevel udp->all_zombies = NULL; 1696 0 stevel udp->nzombies = 0; 1697 0 stevel } 1698 0 stevel trim_stack_cache(0); 1699 2248 raf 1700 2248 raf /* 1701 2248 raf * Do post-fork1 processing for subsystems that need it. 1702 2248 raf */ 1703 2248 raf postfork1_child_tpool(); 1704 2248 raf postfork1_child_sigev_aio(); 1705 2248 raf postfork1_child_sigev_mq(); 1706 2248 raf postfork1_child_sigev_timer(); 1707 2248 raf postfork1_child_aio(); 1708 0 stevel } 1709 0 stevel 1710 0 stevel lwpid_t 1711 0 stevel lwp_self(void) 1712 0 stevel { 1713 0 stevel return (curthread->ul_lwpid); 1714 0 stevel } 1715 0 stevel 1716 6812 raf #pragma weak _ti_thr_self = thr_self 1717 6812 raf #pragma weak pthread_self = thr_self 1718 0 stevel thread_t 1719 6812 raf thr_self() 1720 0 stevel { 1721 0 stevel return (curthread->ul_lwpid); 1722 0 stevel } 1723 0 stevel 1724 0 stevel int 1725 6812 raf thr_main() 1726 0 stevel { 1727 0 stevel ulwp_t *self = __curthread(); 1728 0 stevel 1729 0 stevel return ((self == NULL)? -1 : self->ul_main); 1730 3235 raf } 1731 3235 raf 1732 3235 raf int 1733 3235 raf _thrp_cancelled(void) 1734 3235 raf { 1735 3235 raf return (curthread->ul_rval == PTHREAD_CANCELED); 1736 0 stevel } 1737 0 stevel 1738 0 stevel int 1739 0 stevel _thrp_stksegment(ulwp_t *ulwp, stack_t *stk) 1740 0 stevel { 1741 0 stevel stk->ss_sp = (void *)ulwp->ul_stktop; 1742 0 stevel stk->ss_size = ulwp->ul_stksiz; 1743 0 stevel stk->ss_flags = 0; 1744 0 stevel return (0); 1745 0 stevel } 1746 0 stevel 1747 6812 raf #pragma weak _thr_stksegment = thr_stksegment 1748 0 stevel int 1749 6812 raf thr_stksegment(stack_t *stk) 1750 0 stevel { 1751 0 stevel return (_thrp_stksegment(curthread, stk)); 1752 0 stevel } 1753 0 stevel 1754 0 stevel void 1755 0 stevel force_continue(ulwp_t *ulwp) 1756 0 stevel { 1757 0 stevel #if defined(THREAD_DEBUG) 1758 0 stevel ulwp_t *self = curthread; 1759 0 stevel uberdata_t *udp = self->ul_uberdata; 1760 0 stevel #endif 1761 0 stevel int error; 1762 0 stevel timespec_t ts; 1763 0 stevel 1764 3512 raf ASSERT(MUTEX_OWNED(&udp->fork_lock, self)); 1765 0 stevel ASSERT(MUTEX_OWNED(ulwp_mutex(ulwp, udp), self)); 1766 0 stevel 1767 0 stevel for (;;) { 1768 6812 raf error = _lwp_continue(ulwp->ul_lwpid); 1769 0 stevel if (error != 0 && error != EINTR) 1770 0 stevel break; 1771 0 stevel error = 0; 1772 0 stevel if (ulwp->ul_stopping) { /* he is stopping himself */ 1773 0 stevel ts.tv_sec = 0; /* give him a chance to run */ 1774 0 stevel ts.tv_nsec = 100000; /* 100 usecs or clock tick */ 1775 2248 raf (void) __nanosleep(&ts, NULL); 1776 0 stevel } 1777 0 stevel if (!ulwp->ul_stopping) /* he is running now */ 1778 0 stevel break; /* so we are done */ 1779 0 stevel /* 1780 0 stevel * He is marked as being in the process of stopping 1781 0 stevel * himself. Loop around and continue him again. 1782 0 stevel * He may not have been stopped the first time. 1783 0 stevel */ 1784 0 stevel } 1785 0 stevel } 1786 0 stevel 1787 0 stevel /* 1788 10637 Roger * Suspend an lwp with lwp_suspend(), then move it to a safe point, 1789 10637 Roger * that is, to a point where ul_critical and ul_rtld are both zero. 1790 0 stevel * On return, the ulwp_lock() is dropped as with ulwp_unlock(). 1791 0 stevel * If 'link_dropped' is non-NULL, then 'link_lock' is held on entry. 1792 0 stevel * If we have to drop link_lock, we store 1 through link_dropped. 1793 0 stevel * If the lwp exits before it can be suspended, we return ESRCH. 1794 0 stevel */ 1795 0 stevel int 1796 0 stevel safe_suspend(ulwp_t *ulwp, uchar_t whystopped, int *link_dropped) 1797 0 stevel { 1798 0 stevel ulwp_t *self = curthread; 1799 0 stevel uberdata_t *udp = self->ul_uberdata; 1800 0 stevel cond_t *cvp = ulwp_condvar(ulwp, udp); 1801 0 stevel mutex_t *mp = ulwp_mutex(ulwp, udp); 1802 0 stevel thread_t tid = ulwp->ul_lwpid; 1803 0 stevel int ix = ulwp->ul_ix; 1804 0 stevel int error = 0; 1805 0 stevel 1806 0 stevel ASSERT(whystopped == TSTP_REGULAR || 1807 0 stevel whystopped == TSTP_MUTATOR || 1808 0 stevel whystopped == TSTP_FORK); 1809 0 stevel ASSERT(ulwp != self); 1810 0 stevel ASSERT(!ulwp->ul_stop); 1811 3512 raf ASSERT(MUTEX_OWNED(&udp->fork_lock, self)); 1812 0 stevel ASSERT(MUTEX_OWNED(mp, self)); 1813 0 stevel 1814 0 stevel if (link_dropped != NULL) 1815 0 stevel *link_dropped = 0; 1816 0 stevel 1817 0 stevel /* 1818 0 stevel * We must grab the target's spin lock before suspending it. 1819 0 stevel * See the comments below and in _thrp_suspend() for why. 1820 0 stevel */ 1821 0 stevel spin_lock_set(&ulwp->ul_spinlock); 1822 0 stevel (void) ___lwp_suspend(tid); 1823 0 stevel spin_lock_clear(&ulwp->ul_spinlock); 1824 0 stevel 1825 0 stevel top: 1826 10637 Roger if ((ulwp->ul_critical == 0 && ulwp->ul_rtld == 0) || 1827 10637 Roger ulwp->ul_stopping) { 1828 0 stevel /* thread is already safe */ 1829 0 stevel ulwp->ul_stop |= whystopped; 1830 0 stevel } else { 1831 0 stevel /* 1832 0 stevel * Setting ul_pleasestop causes the target thread to stop 1833 0 stevel * itself in _thrp_suspend(), below, after we drop its lock. 1834 0 stevel * We must continue the critical thread before dropping 1835 0 stevel * link_lock because the critical thread may be holding 1836 0 stevel * the queue lock for link_lock. This is delicate. 1837 0 stevel */ 1838 0 stevel ulwp->ul_pleasestop |= whystopped; 1839 0 stevel force_continue(ulwp); 1840 0 stevel if (link_dropped != NULL) { 1841 0 stevel *link_dropped = 1; 1842 0 stevel lmutex_unlock(&udp->link_lock); 1843 0 stevel /* be sure to drop link_lock only once */ 1844 0 stevel link_dropped = NULL; 1845 0 stevel } 1846 0 stevel 1847 0 stevel /* 1848 0 stevel * The thread may disappear by calling thr_exit() so we 1849 0 stevel * cannot rely on the ulwp pointer after dropping the lock. 1850 0 stevel * Instead, we search the hash table to find it again. 1851 0 stevel * When we return, we may find that the thread has been 1852 0 stevel * continued by some other thread. The suspend/continue 1853 0 stevel * interfaces are prone to such race conditions by design. 1854 0 stevel */ 1855 0 stevel while (ulwp && !ulwp->ul_dead && !ulwp->ul_stop && 1856 0 stevel (ulwp->ul_pleasestop & whystopped)) { 1857 5891 raf (void) __cond_wait(cvp, mp); 1858 0 stevel for (ulwp = udp->thr_hash_table[ix].hash_bucket; 1859 0 stevel ulwp != NULL; ulwp = ulwp->ul_hash) { 1860 0 stevel if (ulwp->ul_lwpid == tid) 1861 0 stevel break; 1862 0 stevel } 1863 0 stevel } 1864 0 stevel 1865 0 stevel if (ulwp == NULL || ulwp->ul_dead) 1866 0 stevel error = ESRCH; 1867 0 stevel else { 1868 0 stevel /* 1869 0 stevel * Do another lwp_suspend() to make sure we don't 1870 0 stevel * return until the target thread is fully stopped 1871 0 stevel * in the kernel. Don't apply lwp_suspend() until 1872 0 stevel * we know that the target is not holding any 1873 0 stevel * queue locks, that is, that it has completed 1874 0 stevel * ulwp_unlock(self) and has, or at least is 1875 0 stevel * about to, call lwp_suspend() on itself. We do 1876 0 stevel * this by grabbing the target's spin lock. 1877 0 stevel */ 1878 0 stevel ASSERT(ulwp->ul_lwpid == tid); 1879 0 stevel spin_lock_set(&ulwp->ul_spinlock); 1880 0 stevel (void) ___lwp_suspend(tid); 1881 0 stevel spin_lock_clear(&ulwp->ul_spinlock); 1882 0 stevel /* 1883 0 stevel * If some other thread did a thr_continue() 1884 0 stevel * on the target thread we have to start over. 1885 0 stevel */ 1886 0 stevel if (!ulwp->ul_stopping || !(ulwp->ul_stop & whystopped)) 1887 0 stevel goto top; 1888 0 stevel } 1889 0 stevel } 1890 0 stevel 1891 6812 raf (void) cond_broadcast(cvp); 1892 0 stevel lmutex_unlock(mp); 1893 0 stevel return (error); 1894 0 stevel } 1895 0 stevel 1896 0 stevel int 1897 0 stevel _thrp_suspend(thread_t tid, uchar_t whystopped) 1898 0 stevel { 1899 0 stevel ulwp_t *self = curthread; 1900 0 stevel uberdata_t *udp = self->ul_uberdata; 1901 0 stevel ulwp_t *ulwp; 1902 0 stevel int error = 0; 1903 0 stevel 1904 0 stevel ASSERT((whystopped & (TSTP_REGULAR|TSTP_MUTATOR|TSTP_FORK)) != 0); 1905 0 stevel ASSERT((whystopped & ~(TSTP_REGULAR|TSTP_MUTATOR|TSTP_FORK)) == 0); 1906 0 stevel 1907 0 stevel /* 1908 4561 raf * We can't suspend anyone except ourself while 1909 4561 raf * some other thread is performing a fork. 1910 4561 raf * This also allows only one suspension at a time. 1911 0 stevel */ 1912 4561 raf if (tid != self->ul_lwpid) 1913 4843 raf fork_lock_enter(); 1914 0 stevel 1915 0 stevel if ((ulwp = find_lwp(tid)) == NULL) 1916 0 stevel error = ESRCH; 1917 0 stevel else if (whystopped == TSTP_MUTATOR && !ulwp->ul_mutator) { 1918 0 stevel ulwp_unlock(ulwp, udp); 1919 0 stevel error = EINVAL; 1920 0 stevel } else if (ulwp->ul_stop) { /* already stopped */ 1921 0 stevel ulwp->ul_stop |= whystopped; 1922 0 stevel ulwp_broadcast(ulwp); 1923 0 stevel ulwp_unlock(ulwp, udp); 1924 0 stevel } else if (ulwp != self) { 1925 0 stevel /* 1926 0 stevel * After suspending the other thread, move it out of a 1927 0 stevel * critical section and deal with the schedctl mappings. 1928 0 stevel * safe_suspend() suspends the other thread, calls 1929 0 stevel * ulwp_broadcast(ulwp) and drops the ulwp lock. 1930 0 stevel */ 1931 0 stevel error = safe_suspend(ulwp, whystopped, NULL); 1932 0 stevel } else { 1933 0 stevel int schedctl_after_fork = 0; 1934 0 stevel 1935 0 stevel /* 1936 0 stevel * We are suspending ourself. We must not take a signal 1937 0 stevel * until we return from lwp_suspend() and clear ul_stopping. 1938 0 stevel * This is to guard against siglongjmp(). 1939 0 stevel */ 1940 0 stevel enter_critical(self); 1941 0 stevel self->ul_sp = stkptr(); 1942 0 stevel _flush_windows(); /* sparc */ 1943 0 stevel self->ul_pleasestop = 0; 1944 0 stevel self->ul_stop |= whystopped; 1945 0 stevel /* 1946 0 stevel * Grab our spin lock before dropping ulwp_mutex(self). 1947 0 stevel * This prevents the suspending thread from applying 1948 0 stevel * lwp_suspend() to us before we emerge from 1949 0 stevel * lmutex_unlock(mp) and have dropped mp's queue lock. 1950 0 stevel */ 1951 0 stevel spin_lock_set(&self->ul_spinlock); 1952 0 stevel self->ul_stopping = 1; 1953 0 stevel ulwp_broadcast(self); 1954 0 stevel ulwp_unlock(self, udp); 1955 0 stevel /* 1956 0 stevel * From this point until we return from lwp_suspend(), 1957 0 stevel * we must not call any function that might invoke the 1958 0 stevel * dynamic linker, that is, we can only call functions 1959 0 stevel * private to the library. 1960 0 stevel * 1961 0 stevel * Also, this is a nasty race condition for a process 1962 0 stevel * that is undergoing a forkall() operation: 1963 0 stevel * Once we clear our spinlock (below), we are vulnerable 1964 0 stevel * to being suspended by the forkall() thread before 1965 0 stevel * we manage to suspend ourself in ___lwp_suspend(). 1966 0 stevel * See safe_suspend() and force_continue(). 1967 0 stevel * 1968 0 stevel * To avoid a SIGSEGV due to the disappearance 1969 0 stevel * of the schedctl mappings in the child process, 1970 0 stevel * which can happen in spin_lock_clear() if we 1971 0 stevel * are suspended while we are in the middle of 1972 0 stevel * its call to preempt(), we preemptively clear 1973 0 stevel * our own schedctl pointer before dropping our 1974 0 stevel * spinlock. We reinstate it, in both the parent 1975 0 stevel * and (if this really is a forkall()) the child. 1976 0 stevel */ 1977 0 stevel if (whystopped & TSTP_FORK) { 1978 0 stevel schedctl_after_fork = 1; 1979 0 stevel self->ul_schedctl = NULL; 1980 0 stevel self->ul_schedctl_called = &udp->uberflags; 1981 0 stevel } 1982 0 stevel spin_lock_clear(&self->ul_spinlock); 1983 0 stevel (void) ___lwp_suspend(tid); 1984 0 stevel /* 1985 0 stevel * Somebody else continued us. 1986 0 stevel * We can't grab ulwp_lock(self) 1987 0 stevel * until after clearing ul_stopping. 1988 0 stevel * force_continue() relies on this. 1989 0 stevel */ 1990 0 stevel self->ul_stopping = 0; 1991 0 stevel self->ul_sp = 0; 1992 0 stevel if (schedctl_after_fork) { 1993 0 stevel self->ul_schedctl_called = NULL; 1994 0 stevel self->ul_schedctl = NULL; 1995 0 stevel (void) setup_schedctl(); 1996 0 stevel } 1997 0 stevel ulwp_lock(self, udp); 1998 0 stevel ulwp_broadcast(self); 1999 0 stevel ulwp_unlock(self, udp); 2000 0 stevel exit_critical(self); 2001 0 stevel } 2002 0 stevel 2003 0 stevel if (tid != self->ul_lwpid) 2004 0 stevel fork_lock_exit(); 2005 0 stevel 2006 0 stevel return (error); 2007 0 stevel } 2008 0 stevel 2009 0 stevel /* 2010 0 stevel * Suspend all lwps other than ourself in preparation for fork. 2011 0 stevel */ 2012 0 stevel void 2013 0 stevel suspend_fork() 2014 0 stevel { 2015 0 stevel ulwp_t *self = curthread; 2016 0 stevel uberdata_t *udp = self->ul_uberdata; 2017 0 stevel ulwp_t *ulwp; 2018 0 stevel int link_dropped; 2019 0 stevel 2020 3512 raf ASSERT(MUTEX_OWNED(&udp->fork_lock, self)); 2021 0 stevel top: 2022 0 stevel lmutex_lock(&udp->link_lock); 2023 0 stevel 2024 0 stevel for (ulwp = self->ul_forw; ulwp != self; ulwp = ulwp->ul_forw) { 2025 0 stevel ulwp_lock(ulwp, udp); 2026 0 stevel if (ulwp->ul_stop) { /* already stopped */ 2027 0 stevel ulwp->ul_stop |= TSTP_FORK; 2028 0 stevel ulwp_broadcast(ulwp); 2029 0 stevel ulwp_unlock(ulwp, udp); 2030 0 stevel } else { 2031 0 stevel /* 2032 0 stevel * Move the stopped lwp out of a critical section. 2033 0 stevel */ 2034 0 stevel if (safe_suspend(ulwp, TSTP_FORK, &link_dropped) || 2035 0 stevel link_dropped) 2036 0 stevel goto top; 2037 0 stevel } 2038 0 stevel } 2039 0 stevel 2040 0 stevel lmutex_unlock(&udp->link_lock); 2041 0 stevel } 2042 0 stevel 2043 0 stevel void 2044 0 stevel continue_fork(int child) 2045 0 stevel { 2046 0 stevel ulwp_t *self = curthread; 2047 0 stevel uberdata_t *udp = self->ul_uberdata; 2048 0 stevel ulwp_t *ulwp; 2049 3512 raf 2050 3512 raf ASSERT(MUTEX_OWNED(&udp->fork_lock, self)); 2051 0 stevel 2052 0 stevel /* 2053 0 stevel * Clear the schedctl pointers in the child of forkall(). 2054 0 stevel */ 2055 0 stevel if (child) { 2056 0 stevel for (ulwp = self->ul_forw; ulwp != self; ulwp = ulwp->ul_forw) { 2057 0 stevel ulwp->ul_schedctl_called = 2058 4843 raf ulwp->ul_dead? &udp->uberflags : NULL; 2059 0 stevel ulwp->ul_schedctl = NULL; 2060 0 stevel } 2061 0 stevel } 2062 0 stevel 2063 0 stevel /* 2064 0 stevel * Set all lwps that were stopped for fork() running again. 2065 0 stevel */ 2066 0 stevel lmutex_lock(&udp->link_lock); 2067 0 stevel for (ulwp = self->ul_forw; ulwp != self; ulwp = ulwp->ul_forw) { 2068 0 stevel mutex_t *mp = ulwp_mutex(ulwp, udp); 2069 0 stevel lmutex_lock(mp); 2070 0 stevel ASSERT(ulwp->ul_stop & TSTP_FORK); 2071 0 stevel ulwp->ul_stop &= ~TSTP_FORK; 2072 0 stevel ulwp_broadcast(ulwp); 2073 0 stevel if (!ulwp->ul_stop) 2074 0 stevel force_continue(ulwp); 2075 0 stevel lmutex_unlock(mp); 2076 0 stevel } 2077 0 stevel lmutex_unlock(&udp->link_lock); 2078 0 stevel } 2079 0 stevel 2080 0 stevel int 2081 0 stevel _thrp_continue(thread_t tid, uchar_t whystopped) 2082 0 stevel { 2083 0 stevel uberdata_t *udp = curthread->ul_uberdata; 2084 0 stevel ulwp_t *ulwp; 2085 0 stevel mutex_t *mp; 2086 0 stevel int error = 0; 2087 0 stevel 2088 0 stevel ASSERT(whystopped == TSTP_REGULAR || 2089 0 stevel whystopped == TSTP_MUTATOR); 2090 0 stevel 2091 3512 raf /* 2092 3512 raf * We single-thread the entire thread suspend/continue mechanism. 2093 3512 raf */ 2094 4843 raf fork_lock_enter(); 2095 3512 raf 2096 3512 raf if ((ulwp = find_lwp(tid)) == NULL) { 2097 3512 raf fork_lock_exit(); 2098 0 stevel return (ESRCH); 2099 3512 raf } 2100 0 stevel 2101 0 stevel mp = ulwp_mutex(ulwp, udp); 2102 0 stevel if ((whystopped == TSTP_MUTATOR && !ulwp->ul_mutator)) { 2103 0 stevel error = EINVAL; 2104 0 stevel } else if (ulwp->ul_stop & whystopped) { 2105 0 stevel ulwp->ul_stop &= ~whystopped; 2106 0 stevel ulwp_broadcast(ulwp); 2107 0 stevel if (!ulwp->ul_stop) { 2108 0 stevel if (whystopped == TSTP_REGULAR && ulwp->ul_created) { 2109 0 stevel ulwp->ul_sp = 0; 2110 0 stevel ulwp->ul_created = 0; 2111 0 stevel } 2112 0 stevel force_continue(ulwp); 2113 0 stevel } 2114 0 stevel } 2115 3512 raf lmutex_unlock(mp); 2116 0 stevel 2117 3512 raf fork_lock_exit(); 2118 0 stevel return (error); 2119 0 stevel } 2120 0 stevel 2121 0 stevel int 2122 6812 raf thr_suspend(thread_t tid) 2123 0 stevel { 2124 0 stevel return (_thrp_suspend(tid, TSTP_REGULAR)); 2125 0 stevel } 2126 0 stevel 2127 0 stevel int 2128 6812 raf thr_continue(thread_t tid) 2129 0 stevel { 2130 0 stevel return (_thrp_continue(tid, TSTP_REGULAR)); 2131 0 stevel } 2132 0 stevel 2133 0 stevel void 2134 6812 raf thr_yield() 2135 0 stevel { 2136 6515 raf yield(); 2137 0 stevel } 2138 0 stevel 2139 6812 raf #pragma weak pthread_kill = thr_kill 2140 6812 raf #pragma weak _thr_kill = thr_kill 2141 0 stevel int 2142 6812 raf thr_kill(thread_t tid, int sig) 2143 0 stevel { 2144 0 stevel if (sig == SIGCANCEL) 2145 0 stevel return (EINVAL); 2146 6812 raf return (_lwp_kill(tid, sig)); 2147 0 stevel } 2148 0 stevel 2149 0 stevel /* 2150 0 stevel * Exit a critical section, take deferred actions if necessary. 2151 10637 Roger * Called from exit_critical() and from sigon(). 2152 0 stevel */ 2153 0 stevel void 2154 0 stevel do_exit_critical() 2155 0 stevel { 2156 0 stevel ulwp_t *self = curthread; 2157 0 stevel int sig; 2158 0 stevel 2159 0 stevel ASSERT(self->ul_critical == 0); 2160 10637 Roger 2161 10637 Roger /* 2162 10637 Roger * Don't suspend ourself or take a deferred signal while dying 2163 10637 Roger * or while executing inside the dynamic linker (ld.so.1). 2164 10637 Roger */ 2165 10637 Roger if (self->ul_dead || self->ul_rtld) 2166 0 stevel return; 2167 0 stevel 2168 0 stevel while (self->ul_pleasestop || 2169 0 stevel (self->ul_cursig != 0 && self->ul_sigdefer == 0)) { 2170 0 stevel /* 2171 0 stevel * Avoid a recursive call to exit_critical() in _thrp_suspend() 2172 0 stevel * by keeping self->ul_critical == 1 here. 2173 0 stevel */ 2174 0 stevel self->ul_critical++; 2175 0 stevel while (self->ul_pleasestop) { 2176 0 stevel /* 2177 0 stevel * Guard against suspending ourself while on a sleep 2178 0 stevel * queue. See the comments in call_user_handler(). 2179 0 stevel */ 2180 0 stevel unsleep_self(); 2181 0 stevel set_parking_flag(self, 0); 2182 0 stevel (void) _thrp_suspend(self->ul_lwpid, 2183 4843 raf self->ul_pleasestop); 2184 0 stevel } 2185 0 stevel self->ul_critical--; 2186 0 stevel 2187 0 stevel if ((sig = self->ul_cursig) != 0 && self->ul_sigdefer == 0) { 2188 0 stevel /* 2189 0 stevel * Clear ul_cursig before proceeding. 2190 0 stevel * This protects us from the dynamic linker's 2191 0 stevel * calls to bind_guard()/bind_clear() in the 2192 0 stevel * event that it is invoked to resolve a symbol 2193 0 stevel * like take_deferred_signal() below. 2194 0 stevel */ 2195 0 stevel self->ul_cursig = 0; 2196 0 stevel take_deferred_signal(sig); 2197 0 stevel ASSERT(self->ul_cursig == 0); 2198 0 stevel } 2199 0 stevel } 2200 0 stevel ASSERT(self->ul_critical == 0); 2201 0 stevel } 2202 0 stevel 2203 5891 raf /* 2204 5891 raf * _ti_bind_guard() and _ti_bind_clear() are called by the dynamic linker 2205 5891 raf * (ld.so.1) when it has do do something, like resolve a symbol to be called 2206 5891 raf * by the application or one of its libraries. _ti_bind_guard() is called 2207 5891 raf * on entry to ld.so.1, _ti_bind_clear() on exit from ld.so.1 back to the 2208 5891 raf * application. The dynamic linker gets special dispensation from libc to 2209 5891 raf * run in a critical region (all signals deferred and no thread suspension 2210 5891 raf * or forking allowed), and to be immune from cancellation for the duration. 2211 5891 raf */ 2212 0 stevel int 2213 6515 raf _ti_bind_guard(int flags) 2214 0 stevel { 2215 0 stevel ulwp_t *self = curthread; 2216 6515 raf uberdata_t *udp = self->ul_uberdata; 2217 6515 raf int bindflag = (flags & THR_FLG_RTLD); 2218 0 stevel 2219 0 stevel if ((self->ul_bindflags & bindflag) == bindflag) 2220 0 stevel return (0); 2221 9569 Rod self->ul_bindflags |= bindflag; 2222 6515 raf if ((flags & (THR_FLG_NOLOCK | THR_FLG_REENTER)) == THR_FLG_NOLOCK) { 2223 6515 raf sigoff(self); /* see no signals while holding ld_lock */ 2224 10637 Roger self->ul_rtld++; /* don't suspend while in ld.so.1 */ 2225 6812 raf (void) mutex_lock(&udp->ld_lock); 2226 6515 raf } 2227 0 stevel enter_critical(self); 2228 5891 raf self->ul_save_state = self->ul_cancel_disabled; 2229 5891 raf self->ul_cancel_disabled = 1; 2230 5891 raf set_cancel_pending_flag(self, 0); 2231 0 stevel return (1); 2232 0 stevel } 2233 0 stevel 2234 0 stevel int 2235 6515 raf _ti_bind_clear(int flags) 2236 0 stevel { 2237 0 stevel ulwp_t *self = curthread; 2238 6515 raf uberdata_t *udp = self->ul_uberdata; 2239 6515 raf int bindflag = (flags & THR_FLG_RTLD); 2240 0 stevel 2241 0 stevel if ((self->ul_bindflags & bindflag) == 0) 2242 0 stevel return (self->ul_bindflags); 2243 0 stevel self->ul_bindflags &= ~bindflag; 2244 5891 raf self->ul_cancel_disabled = self->ul_save_state; 2245 5891 raf set_cancel_pending_flag(self, 0); 2246 0 stevel exit_critical(self); 2247 6515 raf if ((flags & (THR_FLG_NOLOCK | THR_FLG_REENTER)) == THR_FLG_NOLOCK) { 2248 6515 raf if (MUTEX_OWNED(&udp->ld_lock, self)) { 2249 6812 raf (void) mutex_unlock(&udp->ld_lock); 2250 10637 Roger self->ul_rtld--; 2251 6515 raf sigon(self); /* reenable signals */ 2252 6515 raf } 2253 6515 raf } 2254 0 stevel return (self->ul_bindflags); 2255 9569 Rod } 2256 9569 Rod 2257 9569 Rod /* 2258 9569 Rod * Tell the dynamic linker (ld.so.1) whether or not it was entered from 2259 9569 Rod * a critical region in libc. Return zero if not, else return non-zero. 2260 9569 Rod */ 2261 9569 Rod int 2262 9569 Rod _ti_critical(void) 2263 9569 Rod { 2264 9569 Rod ulwp_t *self = curthread; 2265 9569 Rod int level = self->ul_critical; 2266 9569 Rod 2267 9569 Rod if ((self->ul_bindflags & THR_FLG_RTLD) == 0 || level == 0) 2268 9569 Rod return (level); /* ld.so.1 hasn't (yet) called enter() */ 2269 9569 Rod return (level - 1); 2270 0 stevel } 2271 0 stevel 2272 0 stevel /* 2273 0 stevel * sigoff() and sigon() enable cond_wait() to behave (optionally) like 2274 0 stevel * it does in the old libthread (see the comments in cond_wait_queue()). 2275 0 stevel * Also, signals are deferred at thread startup until TLS constructors 2276 6812 raf * have all been called, at which time _thrp_setup() calls sigon(). 2277 1885 raf * 2278 2248 raf * _sigoff() and _sigon() are external consolidation-private interfaces to 2279 2248 raf * sigoff() and sigon(), respectively, in libc. These are used in libnsl. 2280 0 stevel * Also, _sigoff() and _sigon() are called from dbx's run-time checking 2281 0 stevel * (librtc.so) to defer signals during its critical sections (not to be 2282 0 stevel * confused with libc critical sections [see exit_critical() above]). 2283 0 stevel */ 2284 0 stevel void 2285 0 stevel _sigoff(void) 2286 0 stevel { 2287 10637 Roger ulwp_t *self = curthread; 2288 10637 Roger 2289 10637 Roger sigoff(self); 2290 0 stevel } 2291 0 stevel 2292 0 stevel void 2293 0 stevel _sigon(void) 2294 0 stevel { 2295 10637 Roger ulwp_t *self = curthread; 2296 0 stevel 2297 0 stevel ASSERT(self->ul_sigdefer > 0); 2298 10637 Roger sigon(self); 2299 0 stevel } 2300 0 stevel 2301 0 stevel int 2302 6812 raf thr_getconcurrency() 2303 0 stevel { 2304 0 stevel return (thr_concurrency); 2305 0 stevel } 2306 0 stevel 2307 0 stevel int 2308 6812 raf pthread_getconcurrency() 2309 0 stevel { 2310 0 stevel return (pthread_concurrency); 2311 0 stevel } 2312 0 stevel 2313 0 stevel int 2314 6812 raf thr_setconcurrency(int new_level) 2315 0 stevel { 2316 0 stevel uberdata_t *udp = curthread->ul_uberdata; 2317 0 stevel 2318 0 stevel if (new_level < 0) 2319 0 stevel return (EINVAL); 2320 0 stevel if (new_level > 65536) /* 65536 is totally arbitrary */ 2321 0 stevel return (EAGAIN); 2322 0 stevel lmutex_lock(&udp->link_lock); 2323 0 stevel if (new_level > thr_concurrency) 2324 0 stevel thr_concurrency = new_level; 2325 0 stevel lmutex_unlock(&udp->link_lock); 2326 0 stevel return (0); 2327 0 stevel } 2328 0 stevel 2329 0 stevel int 2330 6812 raf pthread_setconcurrency(int new_level) 2331 0 stevel { 2332 0 stevel if (new_level < 0) 2333 0 stevel return (EINVAL); 2334 0 stevel if (new_level > 65536) /* 65536 is totally arbitrary */ 2335 0 stevel return (EAGAIN); 2336 0 stevel pthread_concurrency = new_level; 2337 0 stevel return (0); 2338 0 stevel } 2339 0 stevel 2340 0 stevel size_t 2341 6812 raf thr_min_stack(void) 2342 0 stevel { 2343 0 stevel return (MINSTACK); 2344 0 stevel } 2345 0 stevel 2346 0 stevel int 2347 0 stevel __nthreads(void) 2348 0 stevel { 2349 0 stevel return (curthread->ul_uberdata->nthreads); 2350 0 stevel } 2351 0 stevel 2352 0 stevel /* 2353 0 stevel * XXX 2354 0 stevel * The remainder of this file implements the private interfaces to java for 2355 0 stevel * garbage collection. It is no longer used, at least by java 1.2. 2356 0 stevel * It can all go away once all old JVMs have disappeared. 2357 0 stevel */ 2358 0 stevel 2359 0 stevel int suspendingallmutators; /* when non-zero, suspending all mutators. */ 2360 0 stevel int suspendedallmutators; /* when non-zero, all mutators suspended. */ 2361 0 stevel int mutatorsbarrier; /* when non-zero, mutators barrier imposed. */ 2362 0 stevel mutex_t mutatorslock = DEFAULTMUTEX; /* used to enforce mutators barrier. */ 2363 0 stevel cond_t mutatorscv = DEFAULTCV; /* where non-mutators sleep. */ 2364 0 stevel 2365 0 stevel /* 2366 0 stevel * Get the available register state for the target thread. 2367 0 stevel * Return non-volatile registers: TRS_NONVOLATILE 2368 0 stevel */ 2369 6812 raf #pragma weak _thr_getstate = thr_getstate 2370 0 stevel int 2371 6812 raf thr_getstate(thread_t tid, int *flag, lwpid_t *lwp, stack_t *ss, gregset_t rs) 2372 0 stevel { 2373 0 stevel ulwp_t *self = curthread; 2374 0 stevel uberdata_t *udp = self->ul_uberdata; 2375 0 stevel ulwp_t **ulwpp; 2376 0 stevel ulwp_t *ulwp; 2377 0 stevel int error = 0; 2378 0 stevel int trs_flag = TRS_LWPID; 2379 0 stevel 2380 0 stevel if (tid == 0 || self->ul_lwpid == tid) { 2381 0 stevel ulwp = self; 2382 0 stevel ulwp_lock(ulwp, udp); 2383 0 stevel } else if ((ulwpp = find_lwpp(tid)) != NULL) { 2384 0 stevel ulwp = *ulwpp; 2385 0 stevel } else { 2386 0 stevel if (flag) 2387 0 stevel *flag = TRS_INVALID; 2388 0 stevel return (ESRCH); 2389 0 stevel } 2390 0 stevel 2391 0 stevel if (ulwp->ul_dead) { 2392 0 stevel trs_flag = TRS_INVALID; 2393 0 stevel } else if (!ulwp->ul_stop && !suspendedallmutators) { 2394 0 stevel error = EINVAL; 2395 0 stevel trs_flag = TRS_INVALID; 2396 0 stevel } else if (ulwp->ul_stop) { 2397 0 stevel trs_flag = TRS_NONVOLATILE; 2398 0 stevel getgregs(ulwp, rs); 2399 0 stevel } 2400 0 stevel 2401 0 stevel if (flag) 2402 0 stevel *flag = trs_flag; 2403 0 stevel if (lwp) 2404 0 stevel *lwp = tid; 2405 0 stevel if (ss != NULL) 2406 0 stevel (void) _thrp_stksegment(ulwp, ss); 2407 0 stevel 2408 0 stevel ulwp_unlock(ulwp, udp); 2409 0 stevel return (error); 2410 0 stevel } 2411 0 stevel 2412 0 stevel /* 2413 0 stevel * Set the appropriate register state for the target thread. 2414 0 stevel * This is not used by java. It exists solely for the MSTC test suite. 2415 0 stevel */ 2416 6812 raf #pragma weak _thr_setstate = thr_setstate 2417 0 stevel int 2418 6812 raf thr_setstate(thread_t tid, int flag, gregset_t rs) 2419 0 stevel { 2420 0 stevel uberdata_t *udp = curthread->ul_uberdata; 2421 0 stevel ulwp_t *ulwp; 2422 0 stevel int error = 0; 2423 0 stevel 2424 0 stevel if ((ulwp = find_lwp(tid)) == NULL) 2425 0 stevel return (ESRCH); 2426 0 stevel 2427 0 stevel if (!ulwp->ul_stop && !suspendedallmutators) 2428 0 stevel error = EINVAL; 2429 0 stevel else if (rs != NULL) { 2430 0 stevel switch (flag) { 2431 0 stevel case TRS_NONVOLATILE: 2432 0 stevel /* do /proc stuff here? */ 2433 0 stevel if (ulwp->ul_stop) 2434 0 stevel setgregs(ulwp, rs); 2435 0 stevel else 2436 0 stevel error = EINVAL; 2437 0 stevel break; 2438 0 stevel case TRS_LWPID: /* do /proc stuff here? */ 2439 0 stevel default: 2440 0 stevel error = EINVAL; 2441 0 stevel break; 2442 0 stevel } 2443 0 stevel } 2444 0 stevel 2445 0 stevel ulwp_unlock(ulwp, udp); 2446 0 stevel return (error); 2447 0 stevel } 2448 0 stevel 2449 0 stevel int 2450 0 stevel getlwpstatus(thread_t tid, struct lwpstatus *sp) 2451 0 stevel { 2452 5891 raf extern ssize_t __pread(int, void *, size_t, off_t); 2453 0 stevel char buf[100]; 2454 0 stevel int fd; 2455 0 stevel 2456 0 stevel /* "/proc/self/lwp/%u/lwpstatus" w/o stdio */ 2457 0 stevel (void) strcpy(buf, "/proc/self/lwp/"); 2458 0 stevel ultos((uint64_t)tid, 10, buf + strlen(buf)); 2459 0 stevel (void) strcat(buf, "/lwpstatus"); 2460 6515 raf if ((fd = __open(buf, O_RDONLY, 0)) >= 0) { 2461 5891 raf while (__pread(fd, sp, sizeof (*sp), 0) == sizeof (*sp)) { 2462 0 stevel if (sp->pr_flags & PR_STOPPED) { 2463 6515 raf (void) __close(fd); 2464 0 stevel return (0); 2465 0 stevel } 2466 6515 raf yield(); /* give him a chance to stop */ 2467 0 stevel } 2468 6515 raf (void) __close(fd); 2469 0 stevel } 2470 0 stevel return (-1); 2471 0 stevel } 2472 0 stevel 2473 0 stevel int 2474 0 stevel putlwpregs(thread_t tid, prgregset_t prp) 2475 0 stevel { 2476 5891 raf extern ssize_t __writev(int, const struct iovec *, int); 2477 0 stevel char buf[100]; 2478 0 stevel int fd; 2479 0 stevel long dstop_sreg[2]; 2480 0 stevel long run_null[2]; 2481 0 stevel iovec_t iov[3]; 2482 0 stevel 2483 0 stevel /* "/proc/self/lwp/%u/lwpctl" w/o stdio */ 2484 0 stevel (void) strcpy(buf, "/proc/self/lwp/"); 2485 0 stevel ultos((uint64_t)tid, 10, buf + strlen(buf)); 2486 0 stevel (void) strcat(buf, "/lwpctl"); 2487 6515 raf if ((fd = __open(buf, O_WRONLY, 0)) >= 0) { 2488 0 stevel dstop_sreg[0] = PCDSTOP; /* direct it to stop */ 2489 0 stevel dstop_sreg[1] = PCSREG; /* set the registers */ 2490 0 stevel iov[0].iov_base = (caddr_t)dstop_sreg; 2491 0 stevel iov[0].iov_len = sizeof (dstop_sreg); 2492 0 stevel iov[1].iov_base = (caddr_t)prp; /* from the register set */ 2493 0 stevel iov[1].iov_len = sizeof (prgregset_t); 2494 0 stevel run_null[0] = PCRUN; /* make it runnable again */ 2495 0 stevel run_null[1] = 0; 2496 0 stevel iov[2].iov_base = (caddr_t)run_null; 2497 0 stevel iov[2].iov_len = sizeof (run_null); 2498 5891 raf if (__writev(fd, iov, 3) >= 0) { 2499 6515 raf (void) __close(fd); 2500 0 stevel return (0); 2501 0 stevel } 2502 6515 raf (void) __close(fd); 2503 0 stevel } 2504 0 stevel return (-1); 2505 0 stevel } 2506 0 stevel 2507 0 stevel static ulong_t 2508 0 stevel gettsp_slow(thread_t tid) 2509 0 stevel { 2510 0 stevel char buf[100]; 2511 0 stevel struct lwpstatus status; 2512 0 stevel 2513 0 stevel if (getlwpstatus(tid, &status) != 0) { 2514 0 stevel /* "__gettsp(%u): can't read lwpstatus" w/o stdio */ 2515 0 stevel (void) strcpy(buf, "__gettsp("); 2516 0 stevel ultos((uint64_t)tid, 10, buf + strlen(buf)); 2517 0 stevel (void) strcat(buf, "): can't read lwpstatus"); 2518 0 stevel thr_panic(buf); 2519 0 stevel } 2520 0 stevel return (status.pr_reg[R_SP]); 2521 0 stevel } 2522 0 stevel 2523 0 stevel ulong_t 2524 0 stevel __gettsp(thread_t tid) 2525 0 stevel { 2526 0 stevel uberdata_t *udp = curthread->ul_uberdata; 2527 0 stevel ulwp_t *ulwp; 2528 0 stevel ulong_t result; 2529 0 stevel 2530 0 stevel if ((ulwp = find_lwp(tid)) == NULL) 2531 0 stevel return (0); 2532 0 stevel 2533 0 stevel if (ulwp->ul_stop && (result = ulwp->ul_sp) != 0) { 2534 0 stevel ulwp_unlock(ulwp, udp); 2535 0 stevel return (result); 2536 0 stevel } 2537 0 stevel 2538 0 stevel result = gettsp_slow(tid); 2539 0 stevel ulwp_unlock(ulwp, udp); 2540 0 stevel return (result); 2541 0 stevel } 2542 0 stevel 2543 0 stevel /* 2544 0 stevel * This tells java stack walkers how to find the ucontext 2545 0 stevel * structure passed to signal handlers. 2546 0 stevel */ 2547 6812 raf #pragma weak _thr_sighndlrinfo = thr_sighndlrinfo 2548 0 stevel void 2549 6812 raf thr_sighndlrinfo(void (**func)(), int *funcsize) 2550 0 stevel { 2551 0 stevel *func = &__sighndlr; 2552 0 stevel *funcsize = (char *)&__sighndlrend - (char *)&__sighndlr; 2553 0 stevel } 2554 0 stevel 2555 0 stevel /* 2556 0 stevel * Mark a thread a mutator or reset a mutator to being a default, 2557 0 stevel * non-mutator thread. 2558 0 stevel */ 2559 6812 raf #pragma weak _thr_setmutator = thr_setmutator 2560 0 stevel int 2561 6812 raf thr_setmutator(thread_t tid, int enabled) 2562 0 stevel { 2563 0 stevel ulwp_t *self = curthread; 2564 0 stevel uberdata_t *udp = self->ul_uberdata; 2565 0 stevel ulwp_t *ulwp; 2566 0 stevel int error; 2567 5891 raf int cancel_state; 2568 0 stevel 2569 5891 raf enabled = enabled? 1 : 0; 2570 0 stevel top: 2571 0 stevel if (tid == 0) { 2572 0 stevel ulwp = self; 2573 0 stevel ulwp_lock(ulwp, udp); 2574 0 stevel } else if ((ulwp = find_lwp(tid)) == NULL) { 2575 0 stevel return (ESRCH); 2576 0 stevel } 2577 0 stevel 2578 0 stevel /* 2579 0 stevel * The target thread should be the caller itself or a suspended thread. 2580 0 stevel * This prevents the target from also changing its ul_mutator field. 2581 0 stevel */ 2582 0 stevel error = 0; 2583 0 stevel if (ulwp != self && !ulwp->ul_stop && enabled) 2584 0 stevel error = EINVAL; 2585 0 stevel else if (ulwp->ul_mutator != enabled) { 2586 0 stevel lmutex_lock(&mutatorslock); 2587 0 stevel if (mutatorsbarrier) { 2588 0 stevel ulwp_unlock(ulwp, udp); 2589 6812 raf (void) pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, 2590 5891 raf &cancel_state); 2591 0 stevel while (mutatorsbarrier) 2592 6812 raf (void) cond_wait(&mutatorscv, &mutatorslock); 2593 6812 raf (void) pthread_setcancelstate(cancel_state, NULL); 2594 0 stevel lmutex_unlock(&mutatorslock); 2595 0 stevel goto top; 2596 0 stevel } 2597 0 stevel ulwp->ul_mutator = enabled; 2598 0 stevel lmutex_unlock(&mutatorslock); 2599 0 stevel } 2600 0 stevel 2601 0 stevel ulwp_unlock(ulwp, udp); 2602 0 stevel return (error); 2603 0 stevel } 2604 0 stevel 2605 0 stevel /* 2606 0 stevel * Establish a barrier against new mutators. Any non-mutator trying 2607 0 stevel * to become a mutator is suspended until the barrier is removed. 2608 0 stevel */ 2609 6812 raf #pragma weak _thr_mutators_barrier = thr_mutators_barrier 2610 0 stevel void 2611 6812 raf thr_mutators_barrier(int enabled) 2612 0 stevel { 2613 0 stevel int oldvalue; 2614 5891 raf int cancel_state; 2615 0 stevel 2616 0 stevel lmutex_lock(&mutatorslock); 2617 0 stevel 2618 0 stevel /* 2619 0 stevel * Wait if trying to set the barrier while it is already set. 2620 0 stevel */ 2621 6812 raf (void) pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &cancel_state); 2622 0 stevel while (mutatorsbarrier && enabled) 2623 6812 raf (void) cond_wait(&mutatorscv, &mutatorslock); 2624 6812 raf (void) pthread_setcancelstate(cancel_state, NULL); 2625 0 stevel 2626 0 stevel oldvalue = mutatorsbarrier; 2627 0 stevel mutatorsbarrier = enabled; 2628 0 stevel /* 2629 0 stevel * Wakeup any blocked non-mutators when barrier is removed. 2630 0 stevel */ 2631 0 stevel if (oldvalue && !enabled) 2632 6812 raf (void) cond_broadcast(&mutatorscv); 2633 0 stevel lmutex_unlock(&mutatorslock); 2634 0 stevel } 2635 0 stevel 2636 0 stevel /* 2637 0 stevel * Suspend the set of all mutators except for the caller. The list 2638 0 stevel * of actively running threads is searched and only the mutators 2639 0 stevel * in this list are suspended. Actively running non-mutators remain 2640 0 stevel * running. Any other thread is suspended. 2641 0 stevel */ 2642 6812 raf #pragma weak _thr_suspend_allmutators = thr_suspend_allmutators 2643 0 stevel int 2644 6812 raf thr_suspend_allmutators(void) 2645 0 stevel { 2646 0 stevel ulwp_t *self = curthread; 2647 0 stevel uberdata_t *udp = self->ul_uberdata; 2648 0 stevel ulwp_t *ulwp; 2649 0 stevel int link_dropped; 2650 0 stevel 2651 0 stevel /* 2652 3512 raf * We single-thread the entire thread suspend/continue mechanism. 2653 0 stevel */ 2654 4843 raf fork_lock_enter(); 2655 3512 raf 2656 0 stevel top: 2657 0 stevel lmutex_lock(&udp->link_lock); 2658 0 stevel 2659 0 stevel if (suspendingallmutators || suspendedallmutators) { 2660 0 stevel lmutex_unlock(&udp->link_lock); 2661 0 stevel fork_lock_exit(); 2662 0 stevel return (EINVAL); 2663 0 stevel } 2664 0 stevel suspendingallmutators = 1; 2665 0 stevel 2666 0 stevel for (ulwp = self->ul_forw; ulwp != self; ulwp = ulwp->ul_forw) { 2667 0 stevel ulwp_lock(ulwp, udp); 2668 0 stevel if (!ulwp->ul_mutator) { 2669 0 stevel ulwp_unlock(ulwp, udp); 2670 0 stevel } else if (ulwp->ul_stop) { /* already stopped */ 2671 0 stevel ulwp->ul_stop |= TSTP_MUTATOR; 2672 0 stevel ulwp_broadcast(ulwp); 2673 0 stevel ulwp_unlock(ulwp, udp); 2674 0 stevel } else { 2675 0 stevel /* 2676 0 stevel * Move the stopped lwp out of a critical section. 2677 0 stevel */ 2678 0 stevel if (safe_suspend(ulwp, TSTP_MUTATOR, &link_dropped) || 2679 0 stevel link_dropped) { 2680 0 stevel suspendingallmutators = 0; 2681 0 stevel goto top; 2682 0 stevel } 2683 0 stevel } 2684 0 stevel } 2685 0 stevel 2686 0 stevel suspendedallmutators = 1; 2687 0 stevel suspendingallmutators = 0; 2688 0 stevel lmutex_unlock(&udp->link_lock); 2689 0 stevel fork_lock_exit(); 2690 0 stevel return (0); 2691 0 stevel } 2692 0 stevel 2693 0 stevel /* 2694 0 stevel * Suspend the target mutator. The caller is permitted to suspend 2695 0 stevel * itself. If a mutator barrier is enabled, the caller will suspend 2696 0 stevel * itself as though it had been suspended by thr_suspend_allmutators(). 2697 0 stevel * When the barrier is removed, this thread will be resumed. Any 2698 0 stevel * suspended mutator, whether suspended by thr_suspend_mutator(), or by 2699 0 stevel * thr_suspend_allmutators(), can be resumed by thr_continue_mutator(). 2700 0 stevel */ 2701 6812 raf #pragma weak _thr_suspend_mutator = thr_suspend_mutator 2702 0 stevel int 2703 6812 raf thr_suspend_mutator(thread_t tid) 2704 0 stevel { 2705 0 stevel if (tid == 0) 2706 0 stevel tid = curthread->ul_lwpid; 2707 0 stevel return (_thrp_suspend(tid, TSTP_MUTATOR)); 2708 0 stevel } 2709 0 stevel 2710 0 stevel /* 2711 0 stevel * Resume the set of all suspended mutators. 2712 0 stevel */ 2713 6812 raf #pragma weak _thr_continue_allmutators = thr_continue_allmutators 2714 0 stevel int 2715 6812 raf thr_continue_allmutators() 2716 0 stevel { 2717 0 stevel ulwp_t *self = curthread; 2718 0 stevel uberdata_t *udp = self->ul_uberdata; 2719 0 stevel ulwp_t *ulwp; 2720 3512 raf 2721 3512 raf /* 2722 3512 raf * We single-thread the entire thread suspend/continue mechanism. 2723 3512 raf */ 2724 4843 raf fork_lock_enter(); 2725 0 stevel 2726 0 stevel lmutex_lock(&udp->link_lock); 2727 0 stevel if (!suspendedallmutators) { 2728 0 stevel lmutex_unlock(&udp->link_lock); 2729 3512 raf fork_lock_exit(); 2730 0 stevel return (EINVAL); 2731 0 stevel } 2732 0 stevel suspendedallmutators = 0; 2733 0 stevel 2734 0 stevel for (ulwp = self->ul_forw; ulwp != self; ulwp = ulwp->ul_forw) { 2735 0 stevel mutex_t *mp = ulwp_mutex(ulwp, udp); 2736 0 stevel lmutex_lock(mp); 2737 0 stevel if (ulwp->ul_stop & TSTP_MUTATOR) { 2738 0 stevel ulwp->ul_stop &= ~TSTP_MUTATOR; 2739 0 stevel ulwp_broadcast(ulwp); 2740 0 stevel if (!ulwp->ul_stop) 2741 0 stevel force_continue(ulwp); 2742 0 stevel } 2743 0 stevel lmutex_unlock(mp); 2744 0 stevel } 2745 0 stevel 2746 0 stevel lmutex_unlock(&udp->link_lock); 2747 3512 raf fork_lock_exit(); 2748 0 stevel return (0); 2749 0 stevel } 2750 0 stevel 2751 0 stevel /* 2752 0 stevel * Resume a suspended mutator. 2753 0 stevel */ 2754 6812 raf #pragma weak _thr_continue_mutator = thr_continue_mutator 2755 0 stevel int 2756 6812 raf thr_continue_mutator(thread_t tid) 2757 0 stevel { 2758 0 stevel return (_thrp_continue(tid, TSTP_MUTATOR)); 2759 0 stevel } 2760 0 stevel 2761 6812 raf #pragma weak _thr_wait_mutator = thr_wait_mutator 2762 0 stevel int 2763 6812 raf thr_wait_mutator(thread_t tid, int dontwait) 2764 0 stevel { 2765 0 stevel uberdata_t *udp = curthread->ul_uberdata; 2766 0 stevel ulwp_t *ulwp; 2767 5891 raf int cancel_state; 2768 0 stevel int error = 0; 2769 0 stevel 2770 6812 raf (void) pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &cancel_state); 2771 0 stevel top: 2772 5891 raf if ((ulwp = find_lwp(tid)) == NULL) { 2773 6812 raf (void) pthread_setcancelstate(cancel_state, NULL); 2774 0 stevel return (ESRCH); 2775 5891 raf } 2776 0 stevel 2777 0 stevel if (!ulwp->ul_mutator) 2778 0 stevel error = EINVAL; 2779 0 stevel else if (dontwait) { 2780 0 stevel if (!(ulwp->ul_stop & TSTP_MUTATOR)) 2781 0 stevel error = EWOULDBLOCK; 2782 0 stevel } else if (!(ulwp->ul_stop & TSTP_MUTATOR)) { 2783 0 stevel cond_t *cvp = ulwp_condvar(ulwp, udp); 2784 0 stevel mutex_t *mp = ulwp_mutex(ulwp, udp); 2785 0 stevel 2786 6812 raf (void) cond_wait(cvp, mp); 2787 0 stevel (void) lmutex_unlock(mp); 2788 0 stevel goto top; 2789 0 stevel } 2790 0 stevel 2791 0 stevel ulwp_unlock(ulwp, udp); 2792 6812 raf (void) pthread_setcancelstate(cancel_state, NULL); 2793 0 stevel return (error); 2794 0 stevel } 2795 0 stevel 2796 0 stevel /* PROBE_SUPPORT begin */ 2797 0 stevel 2798 0 stevel void 2799 0 stevel thr_probe_setup(void *data) 2800 0 stevel { 2801 0 stevel curthread->ul_tpdp = data; 2802 0 stevel } 2803 0 stevel 2804 0 stevel static void * 2805 0 stevel _thread_probe_getfunc() 2806 0 stevel { 2807 0 stevel return (curthread->ul_tpdp); 2808 0 stevel } 2809 0 stevel 2810 0 stevel void * (*thr_probe_getfunc_addr)(void) = _thread_probe_getfunc; 2811 0 stevel 2812 0 stevel /* ARGSUSED */ 2813 0 stevel void 2814 0 stevel _resume(ulwp_t *ulwp, caddr_t sp, int dontsave) 2815 0 stevel { 2816 0 stevel /* never called */ 2817 0 stevel } 2818 0 stevel 2819 0 stevel /* ARGSUSED */ 2820 0 stevel void 2821 0 stevel _resume_ret(ulwp_t *oldlwp) 2822 0 stevel { 2823 0 stevel /* never called */ 2824 0 stevel } 2825 0 stevel 2826 0 stevel /* PROBE_SUPPORT end */ 2827
Indexes created Sat Nov 28 12:39:51 UTC 2009
Terms of Use |
Privacy |
Trademarks |
Copyright Policy |
Site Guidelines |
Help
Your use of this web site or any of its content or software indicates your agreement to be bound by these Terms of Use.
Copyright © 1995-2008 Sun Microsystems, Inc.