4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
23 * Copyright (c) 1999, 2010, Oracle and/or its affiliates. All rights reserved.
24 * Copyright (c) 2016 by Delphix. All rights reserved.
25 * Copyright (c) 2017 by The MathWorks, Inc. All rights reserved.
28 * Copyright 2018 Joyent, Inc.
32 #include "thr_uberdata.h"
40 * These symbols should not be exported from libc, but
41 * /lib/libm.so.2 references _thr_main. libm needs to be fixed.
42 * Also, some older versions of the Studio compiler/debugger
43 * components reference them. These need to be fixed, too.
45 #pragma weak _thr_main = thr_main
46 #pragma weak _thr_create = thr_create
47 #pragma weak _thr_join = thr_join
48 #pragma weak _thr_self = thr_self
54 * Between Solaris 2.5 and Solaris 9, __threaded was used to indicate
55 * "we are linked with libthread". The Sun Workshop 6 update 1 compilation
56 * system used it illegally (it is a consolidation private symbol).
57 * To accommodate this and possibly other abusers of the symbol,
58 * we make it always equal to 1 now that libthread has been folded
59 * into libc. The new __libc_threaded symbol is used to indicate
60 * the new meaning, "more than one thread exists".
62 int __threaded
= 1; /* always equal to 1 */
63 int __libc_threaded
= 0; /* zero until first thr_create() */
66 * thr_concurrency and pthread_concurrency are not used by the library.
67 * They exist solely to hold and return the values set by calls to
68 * thr_setconcurrency() and pthread_setconcurrency().
69 * Because thr_concurrency is affected by the THR_NEW_LWP flag
70 * to thr_create(), thr_concurrency is protected by link_lock.
72 static int thr_concurrency
= 1;
73 static int pthread_concurrency
;
75 #define HASHTBLSZ 1024 /* must be a power of two */
76 #define TIDHASH(tid, udp) (tid & (udp)->hash_mask)
78 /* initial allocation, just enough for one lwp */
79 #pragma align 64(init_hash_table)
80 thr_hash_table_t init_hash_table
[1] = {
81 { DEFAULTMUTEX
, DEFAULTCV
, NULL
},
84 extern const Lc_interface rtld_funcs
[];
87 * The weak version is known to libc_db and mdb.
89 #pragma weak _uberdata = __uberdata
90 uberdata_t __uberdata
= {
91 { DEFAULTMUTEX
, NULL
, 0 }, /* link_lock */
92 { RECURSIVEMUTEX
, NULL
, 0 }, /* ld_lock */
93 { RECURSIVEMUTEX
, NULL
, 0 }, /* fork_lock */
94 { RECURSIVEMUTEX
, NULL
, 0 }, /* atfork_lock */
95 { RECURSIVEMUTEX
, NULL
, 0 }, /* callout_lock */
96 { DEFAULTMUTEX
, NULL
, 0 }, /* tdb_hash_lock */
97 { 0, }, /* tdb_hash_lock_stats */
98 { { 0 }, }, /* siguaction[NSIG] */
99 {{ DEFAULTMUTEX
, NULL
, 0 }, /* bucket[NBUCKETS] */
100 { DEFAULTMUTEX
, NULL
, 0 },
101 { DEFAULTMUTEX
, NULL
, 0 },
102 { DEFAULTMUTEX
, NULL
, 0 },
103 { DEFAULTMUTEX
, NULL
, 0 },
104 { DEFAULTMUTEX
, NULL
, 0 },
105 { DEFAULTMUTEX
, NULL
, 0 },
106 { DEFAULTMUTEX
, NULL
, 0 },
107 { DEFAULTMUTEX
, NULL
, 0 },
108 { DEFAULTMUTEX
, NULL
, 0 }},
109 { RECURSIVEMUTEX
, NULL
, NULL
}, /* atexit_root */
110 { RECURSIVEMUTEX
, NULL
}, /* quickexit_root */
111 { DEFAULTMUTEX
, 0, 0, NULL
}, /* tsd_metadata */
112 { DEFAULTMUTEX
, {0, 0}, {0, 0} }, /* tls_metadata */
117 { 0 }, /* uberflags */
118 NULL
, /* queue_head */
119 init_hash_table
, /* thr_hash_table */
120 1, /* hash_size: size of the hash table */
121 0, /* hash_mask: hash_size - 1 */
124 NULL
, /* all_zombies */
129 sigacthandler
, /* sigacthandler */
130 NULL
, /* lwp_stacks */
131 NULL
, /* lwp_laststack */
133 10, /* thread_stack_cache */
134 NULL
, /* ulwp_freelist */
135 NULL
, /* ulwp_lastfree */
136 NULL
, /* ulwp_replace_free */
137 NULL
, /* ulwp_replace_last */
138 NULL
, /* atforklist */
139 NULL
, /* robustlocks */
140 NULL
, /* robustlist */
142 NULL
, /* ub_comm_page */
143 NULL
, /* __tdb_bootstrap */
145 NULL
, /* tdb_sync_addr_hash */
146 0, /* tdb_register_count */
147 0, /* tdb_hash_alloc_failed */
148 NULL
, /* tdb_sync_addr_free */
149 NULL
, /* tdb_sync_addr_last */
150 0, /* tdb_sync_alloc */
151 { 0, 0 }, /* tdb_ev_global_mask */
152 tdb_events
, /* tdb_events array */
157 * The weak version is known to libc_db and mdb.
159 #pragma weak _tdb_bootstrap = __tdb_bootstrap
160 uberdata_t
**__tdb_bootstrap
= NULL
;
162 int thread_queue_fifo
= 4;
163 int thread_queue_dump
= 0;
164 int thread_cond_wait_defer
= 0;
165 int thread_error_detection
= 0;
166 int thread_async_safe
= 0;
167 int thread_stack_cache
= 10;
168 int thread_door_noreserve
= 0;
169 int thread_locks_misaligned
= 0;
171 static ulwp_t
*ulwp_alloc(void);
172 static void ulwp_free(ulwp_t
*);
175 * Insert the lwp into the hash table.
178 hash_in_unlocked(ulwp_t
*ulwp
, int ix
, uberdata_t
*udp
)
180 ulwp
->ul_hash
= udp
->thr_hash_table
[ix
].hash_bucket
;
181 udp
->thr_hash_table
[ix
].hash_bucket
= ulwp
;
186 hash_in(ulwp_t
*ulwp
, uberdata_t
*udp
)
188 int ix
= TIDHASH(ulwp
->ul_lwpid
, udp
);
189 mutex_t
*mp
= &udp
->thr_hash_table
[ix
].hash_lock
;
192 hash_in_unlocked(ulwp
, ix
, udp
);
197 * Delete the lwp from the hash table.
200 hash_out_unlocked(ulwp_t
*ulwp
, int ix
, uberdata_t
*udp
)
204 for (ulwpp
= &udp
->thr_hash_table
[ix
].hash_bucket
;
206 ulwpp
= &(*ulwpp
)->ul_hash
)
208 *ulwpp
= ulwp
->ul_hash
;
209 ulwp
->ul_hash
= NULL
;
214 hash_out(ulwp_t
*ulwp
, uberdata_t
*udp
)
218 if ((ix
= ulwp
->ul_ix
) >= 0) {
219 mutex_t
*mp
= &udp
->thr_hash_table
[ix
].hash_lock
;
222 hash_out_unlocked(ulwp
, ix
, udp
);
228 * Retain stack information for thread structures that are being recycled for
229 * new threads. All other members of the thread structure should be zeroed.
232 ulwp_clean(ulwp_t
*ulwp
)
234 caddr_t stk
= ulwp
->ul_stk
;
235 size_t mapsiz
= ulwp
->ul_mapsiz
;
236 size_t guardsize
= ulwp
->ul_guardsize
;
237 uintptr_t stktop
= ulwp
->ul_stktop
;
238 size_t stksiz
= ulwp
->ul_stksiz
;
240 (void) memset(ulwp
, 0, sizeof (*ulwp
));
243 ulwp
->ul_mapsiz
= mapsiz
;
244 ulwp
->ul_guardsize
= guardsize
;
245 ulwp
->ul_stktop
= stktop
;
246 ulwp
->ul_stksiz
= stksiz
;
249 static int stackprot
;
252 * Answer the question, "Is the lwp in question really dead?"
253 * We must inquire of the operating system to be really sure
254 * because the lwp may have called lwp_exit() but it has not
255 * yet completed the exit.
258 dead_and_buried(ulwp_t
*ulwp
)
260 if (ulwp
->ul_lwpid
== (lwpid_t
)(-1))
262 if (ulwp
->ul_dead
&& ulwp
->ul_detached
&&
263 _lwp_kill(ulwp
->ul_lwpid
, 0) == ESRCH
) {
264 ulwp
->ul_lwpid
= (lwpid_t
)(-1);
271 * Attempt to keep the stack cache within the specified cache limit.
274 trim_stack_cache(int cache_limit
)
276 ulwp_t
*self
= curthread
;
277 uberdata_t
*udp
= self
->ul_uberdata
;
279 ulwp_t
**ulwpp
= &udp
->lwp_stacks
;
282 ASSERT(udp
->nthreads
<= 1 || MUTEX_OWNED(&udp
->link_lock
, self
));
284 while (udp
->nfreestack
> cache_limit
&& (ulwp
= *ulwpp
) != NULL
) {
285 if (dead_and_buried(ulwp
)) {
286 *ulwpp
= ulwp
->ul_next
;
287 if (ulwp
== udp
->lwp_laststack
)
288 udp
->lwp_laststack
= prev
;
291 (void) munmap(ulwp
->ul_stk
, ulwp
->ul_mapsiz
);
293 * Now put the free ulwp on the ulwp freelist.
296 ulwp
->ul_next
= NULL
;
297 if (udp
->ulwp_freelist
== NULL
)
298 udp
->ulwp_freelist
= udp
->ulwp_lastfree
= ulwp
;
300 udp
->ulwp_lastfree
->ul_next
= ulwp
;
301 udp
->ulwp_lastfree
= ulwp
;
305 ulwpp
= &ulwp
->ul_next
;
311 * Find an unused stack of the requested size
312 * or create a new stack of the requested size.
313 * Return a pointer to the ulwp_t structure referring to the stack, or NULL.
314 * thr_exit() stores 1 in the ul_dead member.
315 * thr_join() stores -1 in the ul_lwpid member.
318 find_stack(size_t stksize
, size_t guardsize
)
320 static size_t pagesize
= 0;
322 uberdata_t
*udp
= curthread
->ul_uberdata
;
330 * The stack is allocated PROT_READ|PROT_WRITE|PROT_EXEC
331 * unless overridden by the system's configuration.
333 if (stackprot
== 0) { /* do this once */
334 long lprot
= _sysconf(_SC_STACK_PROT
);
336 lprot
= (PROT_READ
|PROT_WRITE
|PROT_EXEC
);
337 stackprot
= (int)lprot
;
339 if (pagesize
== 0) /* do this once */
340 pagesize
= _sysconf(_SC_PAGESIZE
);
343 * One megabyte stacks by default, but subtract off
344 * two pages for the system-created red zones.
345 * Round up a non-zero stack size to a pagesize multiple.
348 stksize
= DEFAULTSTACK
- 2 * pagesize
;
350 stksize
= ((stksize
+ pagesize
- 1) & -pagesize
);
353 * Round up the mapping size to a multiple of pagesize.
354 * Note: mmap() provides at least one page of red zone
355 * so we deduct that from the value of guardsize.
358 guardsize
= ((guardsize
+ pagesize
- 1) & -pagesize
) - pagesize
;
359 mapsize
= stksize
+ guardsize
;
361 lmutex_lock(&udp
->link_lock
);
362 for (prev
= NULL
, ulwpp
= &udp
->lwp_stacks
;
363 (ulwp
= *ulwpp
) != NULL
;
364 prev
= ulwp
, ulwpp
= &ulwp
->ul_next
) {
365 if (ulwp
->ul_mapsiz
== mapsize
&&
366 ulwp
->ul_guardsize
== guardsize
&&
367 dead_and_buried(ulwp
)) {
369 * The previous lwp is gone; reuse the stack.
370 * Remove the ulwp from the stack list.
372 *ulwpp
= ulwp
->ul_next
;
373 ulwp
->ul_next
= NULL
;
374 if (ulwp
== udp
->lwp_laststack
)
375 udp
->lwp_laststack
= prev
;
378 lmutex_unlock(&udp
->link_lock
);
385 * None of the cached stacks matched our mapping size.
386 * Reduce the stack cache to get rid of possibly
387 * very old stacks that will never be reused.
389 if (udp
->nfreestack
> udp
->thread_stack_cache
)
390 trim_stack_cache(udp
->thread_stack_cache
);
391 else if (udp
->nfreestack
> 0)
392 trim_stack_cache(udp
->nfreestack
- 1);
393 lmutex_unlock(&udp
->link_lock
);
396 * Create a new stack.
398 if ((stk
= mmap(NULL
, mapsize
, stackprot
,
399 MAP_PRIVATE
|MAP_NORESERVE
|MAP_ANON
, -1, (off_t
)0)) != MAP_FAILED
) {
401 * We have allocated our stack. Now allocate the ulwp.
405 (void) munmap(stk
, mapsize
);
408 ulwp
->ul_mapsiz
= mapsize
;
409 ulwp
->ul_guardsize
= guardsize
;
410 ulwp
->ul_stktop
= (uintptr_t)stk
+ mapsize
;
411 ulwp
->ul_stksiz
= stksize
;
412 if (guardsize
) /* protect the extra red zone */
413 (void) mprotect(stk
, guardsize
, PROT_NONE
);
420 * Get a ulwp_t structure from the free list or allocate a new one.
421 * Such ulwp_t's do not have a stack allocated by the library.
426 ulwp_t
*self
= curthread
;
427 uberdata_t
*udp
= self
->ul_uberdata
;
434 lmutex_lock(&udp
->link_lock
);
435 for (prev
= NULL
, ulwpp
= &udp
->ulwp_freelist
;
436 (ulwp
= *ulwpp
) != NULL
;
437 prev
= ulwp
, ulwpp
= &ulwp
->ul_next
) {
438 if (dead_and_buried(ulwp
)) {
439 *ulwpp
= ulwp
->ul_next
;
440 ulwp
->ul_next
= NULL
;
441 if (ulwp
== udp
->ulwp_lastfree
)
442 udp
->ulwp_lastfree
= prev
;
444 lmutex_unlock(&udp
->link_lock
);
449 lmutex_unlock(&udp
->link_lock
);
451 tls_size
= roundup64(udp
->tls_metadata
.static_tls
.tls_size
);
452 data
= lmalloc(sizeof (*ulwp
) + tls_size
);
454 /* LINTED pointer cast may result in improper alignment */
455 ulwp
= (ulwp_t
*)(data
+ tls_size
);
461 * Free a ulwp structure.
462 * If there is an associated stack, put it on the stack list and
463 * munmap() previously freed stacks up to the residual cache limit.
464 * Else put it on the ulwp free list and never call lfree() on it.
467 ulwp_free(ulwp_t
*ulwp
)
469 uberdata_t
*udp
= curthread
->ul_uberdata
;
471 ASSERT(udp
->nthreads
<= 1 || MUTEX_OWNED(&udp
->link_lock
, curthread
));
472 ulwp
->ul_next
= NULL
;
473 if (ulwp
== udp
->ulwp_one
) /* don't reuse the primoridal stack */
475 else if (ulwp
->ul_mapsiz
!= 0) {
476 if (udp
->lwp_stacks
== NULL
)
477 udp
->lwp_stacks
= udp
->lwp_laststack
= ulwp
;
479 udp
->lwp_laststack
->ul_next
= ulwp
;
480 udp
->lwp_laststack
= ulwp
;
482 if (++udp
->nfreestack
> udp
->thread_stack_cache
)
483 trim_stack_cache(udp
->thread_stack_cache
);
485 if (udp
->ulwp_freelist
== NULL
)
486 udp
->ulwp_freelist
= udp
->ulwp_lastfree
= ulwp
;
488 udp
->ulwp_lastfree
->ul_next
= ulwp
;
489 udp
->ulwp_lastfree
= ulwp
;
495 * Find a named lwp and return a pointer to its hash list location.
496 * On success, returns with the hash lock held.
499 find_lwpp(thread_t tid
)
501 uberdata_t
*udp
= curthread
->ul_uberdata
;
502 int ix
= TIDHASH(tid
, udp
);
503 mutex_t
*mp
= &udp
->thr_hash_table
[ix
].hash_lock
;
511 for (ulwpp
= &udp
->thr_hash_table
[ix
].hash_bucket
;
512 (ulwp
= *ulwpp
) != NULL
;
513 ulwpp
= &ulwp
->ul_hash
) {
514 if (ulwp
->ul_lwpid
== tid
)
522 * Wake up all lwps waiting on this lwp for some reason.
525 ulwp_broadcast(ulwp_t
*ulwp
)
527 ulwp_t
*self
= curthread
;
528 uberdata_t
*udp
= self
->ul_uberdata
;
530 ASSERT(MUTEX_OWNED(ulwp_mutex(ulwp
, udp
), self
));
531 (void) cond_broadcast(ulwp_condvar(ulwp
, udp
));
535 * Find a named lwp and return a pointer to it.
536 * Returns with the hash lock held.
539 find_lwp(thread_t tid
)
541 ulwp_t
*self
= curthread
;
542 uberdata_t
*udp
= self
->ul_uberdata
;
546 if (self
->ul_lwpid
== tid
) {
548 ulwp_lock(ulwp
, udp
);
549 } else if ((ulwpp
= find_lwpp(tid
)) != NULL
) {
553 if (ulwp
&& ulwp
->ul_dead
) {
554 ulwp_unlock(ulwp
, udp
);
562 _thrp_create(void *stk
, size_t stksize
, void *(*func
)(void *), void *arg
,
563 long flags
, thread_t
*new_thread
, size_t guardsize
, const char *name
)
565 ulwp_t
*self
= curthread
;
566 uberdata_t
*udp
= self
->ul_uberdata
;
574 * Enforce the restriction of not creating any threads
575 * until the primary link map has been initialized.
576 * Also, disallow thread creation to a child of vfork().
578 if (!self
->ul_primarymap
|| self
->ul_vfork
)
581 if (udp
->hash_size
== 1)
584 if ((stk
|| stksize
) && stksize
< MINSTACK
)
588 if ((ulwp
= find_stack(stksize
, guardsize
)) == NULL
)
590 stksize
= ulwp
->ul_mapsiz
- ulwp
->ul_guardsize
;
592 /* initialize the private stack */
593 if ((ulwp
= ulwp_alloc()) == NULL
)
596 ulwp
->ul_stktop
= (uintptr_t)stk
+ stksize
;
597 ulwp
->ul_stksiz
= stksize
;
599 /* ulwp is not in the hash table; make sure hash_out() doesn't fail */
601 ulwp
->ul_errnop
= &ulwp
->ul_errno
;
603 lwp_flags
= LWP_SUSPENDED
;
604 if (flags
& (THR_DETACHED
|THR_DAEMON
)) {
605 flags
|= THR_DETACHED
;
606 lwp_flags
|= LWP_DETACHED
;
608 if (flags
& THR_DAEMON
)
609 lwp_flags
|= LWP_DAEMON
;
611 /* creating a thread: enforce mt-correctness in mutex_lock() */
612 self
->ul_async_safe
= 1;
614 /* per-thread copies of global variables, for speed */
615 ulwp
->ul_queue_fifo
= self
->ul_queue_fifo
;
616 ulwp
->ul_cond_wait_defer
= self
->ul_cond_wait_defer
;
617 ulwp
->ul_error_detection
= self
->ul_error_detection
;
618 ulwp
->ul_async_safe
= self
->ul_async_safe
;
619 ulwp
->ul_max_spinners
= self
->ul_max_spinners
;
620 ulwp
->ul_adaptive_spin
= self
->ul_adaptive_spin
;
621 ulwp
->ul_queue_spin
= self
->ul_queue_spin
;
622 ulwp
->ul_door_noreserve
= self
->ul_door_noreserve
;
623 ulwp
->ul_misaligned
= self
->ul_misaligned
;
625 /* new thread inherits creating thread's scheduling parameters */
626 ulwp
->ul_policy
= self
->ul_policy
;
627 ulwp
->ul_pri
= (self
->ul_epri
? self
->ul_epri
: self
->ul_pri
);
628 ulwp
->ul_cid
= self
->ul_cid
;
629 ulwp
->ul_rtclassid
= self
->ul_rtclassid
;
631 ulwp
->ul_primarymap
= self
->ul_primarymap
;
632 ulwp
->ul_self
= ulwp
;
633 ulwp
->ul_uberdata
= udp
;
635 /* debugger support */
636 ulwp
->ul_usropts
= flags
;
640 * We cache several instructions in the thread structure for use
641 * by the fasttrap DTrace provider. When changing this, read the
642 * comment in fasttrap.h for the all the other places that must
645 ulwp
->ul_dsave
= 0x9de04000; /* save %g1, %g0, %sp */
646 ulwp
->ul_drestore
= 0x81e80000; /* restore %g0, %g0, %g0 */
647 ulwp
->ul_dftret
= 0x91d0203a; /* ta 0x3a */
648 ulwp
->ul_dreturn
= 0x81ca0000; /* return %o0 */
651 ulwp
->ul_startpc
= func
;
652 ulwp
->ul_startarg
= arg
;
655 * Defer signals on the new thread until its TLS constructors
656 * have been called. _thrp_setup() will call sigon() after
657 * it has called tls_setup().
659 ulwp
->ul_sigdefer
= 1;
661 error
= setup_context(&uc
, _thrp_setup
, ulwp
,
662 (caddr_t
)ulwp
->ul_stk
+ ulwp
->ul_guardsize
, stksize
);
663 if (error
!= 0 && stk
!= NULL
) /* inaccessible stack */
667 * Call enter_critical() to avoid being suspended until we
668 * have linked the new thread into the proper lists.
669 * This is necessary because forkall() and fork1() must
670 * suspend all threads and they must see a complete list.
672 enter_critical(self
);
673 uc
.uc_sigmask
= ulwp
->ul_sigmask
= self
->ul_sigmask
;
675 (error
= __lwp_create(&uc
, lwp_flags
, &tid
)) != 0) {
677 ulwp
->ul_lwpid
= (lwpid_t
)(-1);
679 ulwp
->ul_detached
= 1;
680 lmutex_lock(&udp
->link_lock
);
682 lmutex_unlock(&udp
->link_lock
);
685 self
->ul_nocancel
= 0; /* cancellation is now possible */
686 udp
->uberflags
.uf_mt
= 1;
689 if (flags
& THR_DETACHED
)
690 ulwp
->ul_detached
= 1;
691 ulwp
->ul_lwpid
= tid
;
692 ulwp
->ul_stop
= TSTP_REGULAR
;
693 if (flags
& THR_SUSPENDED
)
694 ulwp
->ul_created
= 1;
696 lmutex_lock(&udp
->link_lock
);
697 ulwp
->ul_forw
= udp
->all_lwps
;
698 ulwp
->ul_back
= udp
->all_lwps
->ul_back
;
699 ulwp
->ul_back
->ul_forw
= ulwp
;
700 ulwp
->ul_forw
->ul_back
= ulwp
;
703 if (flags
& THR_DAEMON
)
705 if (flags
& THR_NEW_LWP
)
707 __libc_threaded
= 1; /* inform stdio */
708 lmutex_unlock(&udp
->link_lock
);
710 if (__td_event_report(self
, TD_CREATE
, udp
)) {
711 self
->ul_td_evbuf
.eventnum
= TD_CREATE
;
712 self
->ul_td_evbuf
.eventdata
= (void *)(uintptr_t)tid
;
713 tdb_event(TD_CREATE
, udp
);
719 (void) pthread_setname_np(tid
, name
);
721 if (!(flags
& THR_SUSPENDED
))
722 (void) _thrp_continue(tid
, TSTP_REGULAR
);
728 thr_create(void *stk
, size_t stksize
, void *(*func
)(void *), void *arg
,
729 long flags
, thread_t
*new_thread
)
731 return (_thrp_create(stk
, stksize
, func
, arg
, flags
, new_thread
, 0,
736 * A special cancellation cleanup hook for DCE.
737 * cleanuphndlr, when it is not NULL, will contain a callback
738 * function to be called before a thread is terminated in
739 * thr_exit() as a result of being cancelled.
741 static void (*cleanuphndlr
)(void) = NULL
;
744 * _pthread_setcleanupinit: sets the cleanup hook.
747 _pthread_setcleanupinit(void (*func
)(void))
756 ulwp_t
*self
= curthread
;
757 uberdata_t
*udp
= self
->ul_uberdata
;
758 ulwp_t
*replace
= NULL
;
760 if (__td_event_report(self
, TD_DEATH
, udp
)) {
761 self
->ul_td_evbuf
.eventnum
= TD_DEATH
;
762 tdb_event(TD_DEATH
, udp
);
765 ASSERT(self
->ul_sigdefer
!= 0);
767 lmutex_lock(&udp
->link_lock
);
769 if (self
->ul_usropts
& THR_NEW_LWP
)
771 if (self
->ul_usropts
& THR_DAEMON
)
773 else if (udp
->nthreads
== udp
->ndaemons
) {
775 * We are the last non-daemon thread exiting.
776 * Exit the process. We retain our TSD and TLS so
777 * that atexit() application functions can use them.
779 lmutex_unlock(&udp
->link_lock
);
781 thr_panic("_thrp_exit(): exit(0) returned");
783 lmutex_unlock(&udp
->link_lock
);
786 * tsd_exit() may call its destructor free(), thus depending on
787 * tmem, therefore tmem_exit() needs to be called after tsd_exit()
790 tsd_exit(); /* deallocate thread-specific data */
791 tls_exit(); /* deallocate thread-local storage */
792 tmem_exit(); /* deallocate tmem allocations */
793 heldlock_exit(); /* deal with left-over held locks */
795 /* block all signals to finish exiting */
796 block_all_signals(self
);
797 /* also prevent ourself from being suspended */
798 enter_critical(self
);
800 lmutex_lock(&udp
->link_lock
);
802 (void) ulwp_lock(self
, udp
);
804 if (self
->ul_mapsiz
&& !self
->ul_detached
) {
806 * We want to free the stack for reuse but must keep
807 * the ulwp_t struct for the benefit of thr_join().
808 * For this purpose we allocate a replacement ulwp_t.
810 if ((replace
= udp
->ulwp_replace_free
) == NULL
)
811 replace
= lmalloc(REPLACEMENT_SIZE
);
812 else if ((udp
->ulwp_replace_free
= replace
->ul_next
) == NULL
)
813 udp
->ulwp_replace_last
= NULL
;
816 if (udp
->all_lwps
== self
)
817 udp
->all_lwps
= self
->ul_forw
;
818 if (udp
->all_lwps
== self
)
819 udp
->all_lwps
= NULL
;
821 self
->ul_forw
->ul_back
= self
->ul_back
;
822 self
->ul_back
->ul_forw
= self
->ul_forw
;
824 self
->ul_forw
= self
->ul_back
= NULL
;
825 #if defined(THREAD_DEBUG)
826 /* collect queue lock statistics before marking ourself dead */
827 record_spin_locks(self
);
830 self
->ul_pleasestop
= 0;
831 if (replace
!= NULL
) {
832 int ix
= self
->ul_ix
; /* the hash index */
833 (void) memcpy(replace
, self
, REPLACEMENT_SIZE
);
834 replace
->ul_self
= replace
;
835 replace
->ul_next
= NULL
; /* clone not on stack list */
836 replace
->ul_mapsiz
= 0; /* allows clone to be freed */
837 replace
->ul_replace
= 1; /* requires clone to be freed */
838 hash_out_unlocked(self
, ix
, udp
);
839 hash_in_unlocked(replace
, ix
, udp
);
840 ASSERT(!(self
->ul_detached
));
841 self
->ul_detached
= 1; /* this frees the stack */
842 self
->ul_schedctl
= NULL
;
843 self
->ul_schedctl_called
= &udp
->uberflags
;
844 set_curthread(self
= replace
);
846 * Having just changed the address of curthread, we
847 * must reset the ownership of the locks we hold so
848 * that assertions will not fire when we release them.
850 udp
->link_lock
.mutex_owner
= (uintptr_t)self
;
851 ulwp_mutex(self
, udp
)->mutex_owner
= (uintptr_t)self
;
854 * On i386, %gs still references the original, not the
855 * replacement, ulwp structure. Fetching the replacement
856 * curthread pointer via %gs:0 works correctly since the
857 * original ulwp structure will not be reallocated until
858 * this lwp has completed its lwp_exit() system call (see
859 * dead_and_buried()), but from here on out, we must make
860 * no references to %gs:<offset> other than %gs:0.
864 * Put non-detached terminated threads in the all_zombies list.
866 if (!self
->ul_detached
) {
868 if (udp
->all_zombies
== NULL
) {
869 ASSERT(udp
->nzombies
== 1);
870 udp
->all_zombies
= self
->ul_forw
= self
->ul_back
= self
;
872 self
->ul_forw
= udp
->all_zombies
;
873 self
->ul_back
= udp
->all_zombies
->ul_back
;
874 self
->ul_back
->ul_forw
= self
;
875 self
->ul_forw
->ul_back
= self
;
879 * Notify everyone waiting for this thread.
881 ulwp_broadcast(self
);
882 (void) ulwp_unlock(self
, udp
);
884 * Prevent any more references to the schedctl data.
885 * We are exiting and continue_fork() may not find us.
886 * Do this just before dropping link_lock, since fork
887 * serializes on link_lock.
889 self
->ul_schedctl
= NULL
;
890 self
->ul_schedctl_called
= &udp
->uberflags
;
891 lmutex_unlock(&udp
->link_lock
);
893 ASSERT(self
->ul_critical
== 1);
894 ASSERT(self
->ul_preempt
== 0);
895 _lwp_terminate(); /* never returns */
896 thr_panic("_thrp_exit(): _lwp_terminate() returned");
899 #if defined(THREAD_DEBUG)
901 collect_queue_statistics()
903 uberdata_t
*udp
= curthread
->ul_uberdata
;
906 if (thread_queue_dump
) {
907 lmutex_lock(&udp
->link_lock
);
908 if ((ulwp
= udp
->all_lwps
) != NULL
) {
910 record_spin_locks(ulwp
);
911 } while ((ulwp
= ulwp
->ul_forw
) != udp
->all_lwps
);
913 lmutex_unlock(&udp
->link_lock
);
918 static void __NORETURN
919 _thrp_exit_common(void *status
, int unwind
)
921 ulwp_t
*self
= curthread
;
922 int cancelled
= (self
->ul_cancel_pending
&& status
== PTHREAD_CANCELED
);
924 ASSERT(self
->ul_critical
== 0 && self
->ul_preempt
== 0);
927 * Disable cancellation and call the special DCE cancellation
928 * cleanup hook if it is enabled. Do nothing else before calling
929 * the DCE cancellation cleanup hook; it may call longjmp() and
932 self
->ul_cancel_disabled
= 1;
933 self
->ul_cancel_async
= 0;
934 self
->ul_save_async
= 0;
935 self
->ul_cancelable
= 0;
936 self
->ul_cancel_pending
= 0;
937 set_cancel_pending_flag(self
, 1);
938 if (cancelled
&& cleanuphndlr
!= NULL
)
942 * Block application signals while we are exiting.
943 * We call out to C++, TSD, and TLS destructors while exiting
944 * and these are application-defined, so we cannot be assured
945 * that they won't reset the signal mask. We use sigoff() to
946 * defer any signals that may be received as a result of this
947 * bad behavior. Such signals will be lost to the process
948 * when the thread finishes exiting.
950 (void) thr_sigsetmask(SIG_SETMASK
, &maskset
, NULL
);
953 self
->ul_rval
= status
;
956 * If thr_exit is being called from the places where
957 * C++ destructors are to be called such as cancellation
958 * points, then set this flag. It is checked in _t_cancel()
959 * to decide whether _ex_unwind() is to be called or not.
965 * _thrp_unwind() will eventually call _thrp_exit().
969 thr_panic("_thrp_exit_common(): _thrp_unwind() returned");
971 for (;;) /* to shut the compiler up about __NORETURN */
976 * Called when a thread returns from its start function.
977 * We are at the top of the stack; no unwinding is necessary.
980 _thrp_terminate(void *status
)
982 _thrp_exit_common(status
, 0);
985 #pragma weak pthread_exit = thr_exit
986 #pragma weak _thr_exit = thr_exit
988 thr_exit(void *status
)
990 _thrp_exit_common(status
, 1);
994 _thrp_join(thread_t tid
, thread_t
*departed
, void **status
, int do_cancel
)
996 uberdata_t
*udp
= curthread
->ul_uberdata
;
1006 error
= lwp_wait(tid
, &found
);
1008 while ((error
= __lwp_wait(tid
, &found
)) == EINTR
)
1015 * We must hold link_lock to avoid a race condition with find_stack().
1017 lmutex_lock(&udp
->link_lock
);
1018 if ((ulwpp
= find_lwpp(found
)) == NULL
) {
1020 * lwp_wait() found an lwp that the library doesn't know
1021 * about. It must have been created with _lwp_create().
1022 * Just return its lwpid; we can't know its status.
1024 lmutex_unlock(&udp
->link_lock
);
1028 * Remove ulwp from the hash table.
1031 *ulwpp
= ulwp
->ul_hash
;
1032 ulwp
->ul_hash
= NULL
;
1034 * Remove ulwp from all_zombies list.
1036 ASSERT(udp
->nzombies
>= 1);
1037 if (udp
->all_zombies
== ulwp
)
1038 udp
->all_zombies
= ulwp
->ul_forw
;
1039 if (udp
->all_zombies
== ulwp
)
1040 udp
->all_zombies
= NULL
;
1042 ulwp
->ul_forw
->ul_back
= ulwp
->ul_back
;
1043 ulwp
->ul_back
->ul_forw
= ulwp
->ul_forw
;
1045 ulwp
->ul_forw
= ulwp
->ul_back
= NULL
;
1047 ASSERT(ulwp
->ul_dead
&& !ulwp
->ul_detached
&&
1048 !(ulwp
->ul_usropts
& (THR_DETACHED
|THR_DAEMON
)));
1050 * We can't call ulwp_unlock(ulwp) after we set
1051 * ulwp->ul_ix = -1 so we have to get a pointer to the
1052 * ulwp's hash table mutex now in order to unlock it below.
1054 mp
= ulwp_mutex(ulwp
, udp
);
1055 ulwp
->ul_lwpid
= (lwpid_t
)(-1);
1057 rval
= ulwp
->ul_rval
;
1058 replace
= ulwp
->ul_replace
;
1061 ulwp
->ul_next
= NULL
;
1062 if (udp
->ulwp_replace_free
== NULL
)
1063 udp
->ulwp_replace_free
=
1064 udp
->ulwp_replace_last
= ulwp
;
1066 udp
->ulwp_replace_last
->ul_next
= ulwp
;
1067 udp
->ulwp_replace_last
= ulwp
;
1070 lmutex_unlock(&udp
->link_lock
);
1073 if (departed
!= NULL
)
1081 thr_join(thread_t tid
, thread_t
*departed
, void **status
)
1083 int error
= _thrp_join(tid
, departed
, status
, 1);
1084 return ((error
== EINVAL
)? ESRCH
: error
);
1088 * pthread_join() differs from Solaris thr_join():
1089 * It does not return the departed thread's id
1090 * and hence does not have a "departed" argument.
1091 * It returns EINVAL if tid refers to a detached thread.
1093 #pragma weak _pthread_join = pthread_join
1095 pthread_join(pthread_t tid
, void **status
)
1097 return ((tid
== 0)? ESRCH
: _thrp_join(tid
, NULL
, status
, 1));
1101 pthread_detach(pthread_t tid
)
1103 uberdata_t
*udp
= curthread
->ul_uberdata
;
1108 if ((ulwpp
= find_lwpp(tid
)) == NULL
)
1112 if (ulwp
->ul_dead
) {
1113 ulwp_unlock(ulwp
, udp
);
1114 error
= _thrp_join(tid
, NULL
, NULL
, 0);
1116 error
= __lwp_detach(tid
);
1117 ulwp
->ul_detached
= 1;
1118 ulwp
->ul_usropts
|= THR_DETACHED
;
1119 ulwp_unlock(ulwp
, udp
);
1125 ematch(const char *ev
, const char *match
)
1129 while ((c
= *match
++) != '\0') {
1139 envvar(const char *ev
, const char *match
, int limit
)
1144 if ((ename
= ematch(ev
, match
)) != NULL
) {
1146 for (val
= 0; (c
= *ename
) != '\0'; ename
++) {
1151 val
= val
* 10 + (c
- '0');
1162 etest(const char *ev
)
1166 if ((value
= envvar(ev
, "QUEUE_SPIN", 1000000)) >= 0)
1167 thread_queue_spin
= value
;
1168 if ((value
= envvar(ev
, "ADAPTIVE_SPIN", 1000000)) >= 0)
1169 thread_adaptive_spin
= value
;
1170 if ((value
= envvar(ev
, "MAX_SPINNERS", 255)) >= 0)
1171 thread_max_spinners
= value
;
1172 if ((value
= envvar(ev
, "QUEUE_FIFO", 8)) >= 0)
1173 thread_queue_fifo
= value
;
1174 #if defined(THREAD_DEBUG)
1175 if ((value
= envvar(ev
, "QUEUE_VERIFY", 1)) >= 0)
1176 thread_queue_verify
= value
;
1177 if ((value
= envvar(ev
, "QUEUE_DUMP", 1)) >= 0)
1178 thread_queue_dump
= value
;
1180 if ((value
= envvar(ev
, "STACK_CACHE", 10000)) >= 0)
1181 thread_stack_cache
= value
;
1182 if ((value
= envvar(ev
, "COND_WAIT_DEFER", 1)) >= 0)
1183 thread_cond_wait_defer
= value
;
1184 if ((value
= envvar(ev
, "ERROR_DETECTION", 2)) >= 0)
1185 thread_error_detection
= value
;
1186 if ((value
= envvar(ev
, "ASYNC_SAFE", 1)) >= 0)
1187 thread_async_safe
= value
;
1188 if ((value
= envvar(ev
, "DOOR_NORESERVE", 1)) >= 0)
1189 thread_door_noreserve
= value
;
1190 if ((value
= envvar(ev
, "LOCKS_MISALIGNED", 1)) >= 0)
1191 thread_locks_misaligned
= value
;
1195 * Look for and evaluate environment variables of the form "_THREAD_*".
1196 * For compatibility with the past, we also look for environment
1197 * names of the form "LIBTHREAD_*".
1202 extern const char **_environ
;
1207 if ((pev
= _environ
) == NULL
)
1209 while ((ev
= *pev
++) != NULL
) {
1211 if (c
== '_' && strncmp(ev
, "_THREAD_", 8) == 0)
1213 if (c
== 'L' && strncmp(ev
, "LIBTHREAD_", 10) == 0)
1218 /* PROBE_SUPPORT begin */
1219 #pragma weak __tnf_probe_notify
1220 extern void __tnf_probe_notify(void);
1221 /* PROBE_SUPPORT end */
1223 /* same as atexit() but private to the library */
1224 extern int _atexit(void (*)(void));
1226 /* same as _cleanup() but private to the library */
1227 extern void __cleanup(void);
1229 extern void atfork_init(void);
1232 extern void __proc64id(void);
1236 init_auxv_data(uberdata_t
*udp
)
1240 udp
->ub_comm_page
= NULL
;
1241 if (dlinfo(RTLD_SELF
, RTLD_DI_ARGSINFO
, &args
) < 0)
1244 while (args
.dla_auxv
->a_type
!= AT_NULL
) {
1245 if (args
.dla_auxv
->a_type
== AT_SUN_COMMPAGE
) {
1246 udp
->ub_comm_page
= args
.dla_auxv
->a_un
.a_ptr
;
1253 * libc_init() is called by ld.so.1 for library initialization.
1254 * We perform minimal initialization; enough to work with the main thread.
1259 uberdata_t
*udp
= &__uberdata
;
1260 ulwp_t
*oldself
= __curthread();
1269 * For the initial stage of initialization, we must be careful
1270 * not to call any function that could possibly call _cerror().
1271 * For this purpose, we call only the raw system call wrappers.
1276 * Gather information about cache layouts for optimized
1277 * AMD and Intel assembler strfoo() and memfoo() functions.
1283 * Every libc, regardless of which link map, must register __cleanup().
1285 (void) _atexit(__cleanup
);
1288 * Every libc, regardless of link map, needs to go through and check
1289 * its aux vectors. Doing so will indicate whether or not this has
1290 * been given a comm page (to optimize certain system actions).
1292 init_auxv_data(udp
);
1295 * We keep our uberdata on one of (a) the first alternate link map
1296 * or (b) the primary link map. We switch to the primary link map
1297 * and stay there once we see it. All intermediate link maps are
1298 * subject to being unloaded at any time.
1300 if (oldself
!= NULL
&& (oldself
->ul_primarymap
|| !primary_link_map
)) {
1301 __tdb_bootstrap
= oldself
->ul_uberdata
->tdb_bootstrap
;
1303 atfork_init(); /* every link map needs atfork() processing */
1309 * To establish the main stack information, we have to get our context.
1310 * This is also convenient to use for getting our signal mask.
1312 uc
.uc_flags
= UC_ALL
;
1313 (void) __getcontext(&uc
);
1314 ASSERT(uc
.uc_link
== NULL
);
1316 tls_size
= roundup64(udp
->tls_metadata
.static_tls
.tls_size
);
1317 ASSERT(primary_link_map
|| tls_size
== 0);
1318 data
= lmalloc(sizeof (ulwp_t
) + tls_size
);
1320 thr_panic("cannot allocate thread structure for main thread");
1321 /* LINTED pointer cast may result in improper alignment */
1322 self
= (ulwp_t
*)(data
+ tls_size
);
1323 init_hash_table
[0].hash_bucket
= self
;
1325 self
->ul_sigmask
= uc
.uc_sigmask
;
1326 delete_reserved_signals(&self
->ul_sigmask
);
1328 * Are the old and new sets different?
1329 * (This can happen if we are currently blocking SIGCANCEL.)
1330 * If so, we must explicitly set our signal mask, below.
1333 ((self
->ul_sigmask
.__sigbits
[0] ^ uc
.uc_sigmask
.__sigbits
[0]) |
1334 (self
->ul_sigmask
.__sigbits
[1] ^ uc
.uc_sigmask
.__sigbits
[1]) |
1335 (self
->ul_sigmask
.__sigbits
[2] ^ uc
.uc_sigmask
.__sigbits
[2]) |
1336 (self
->ul_sigmask
.__sigbits
[3] ^ uc
.uc_sigmask
.__sigbits
[3]));
1340 * We cache several instructions in the thread structure for use
1341 * by the fasttrap DTrace provider. When changing this, read the
1342 * comment in fasttrap.h for the all the other places that must
1345 self
->ul_dsave
= 0x9de04000; /* save %g1, %g0, %sp */
1346 self
->ul_drestore
= 0x81e80000; /* restore %g0, %g0, %g0 */
1347 self
->ul_dftret
= 0x91d0203a; /* ta 0x3a */
1348 self
->ul_dreturn
= 0x81ca0000; /* return %o0 */
1351 self
->ul_stktop
= (uintptr_t)uc
.uc_stack
.ss_sp
+ uc
.uc_stack
.ss_size
;
1352 (void) getrlimit(RLIMIT_STACK
, &rl
);
1353 self
->ul_stksiz
= rl
.rlim_cur
;
1354 self
->ul_stk
= (caddr_t
)(self
->ul_stktop
- self
->ul_stksiz
);
1356 self
->ul_forw
= self
->ul_back
= self
;
1357 self
->ul_hash
= NULL
;
1359 self
->ul_lwpid
= 1; /* _lwp_self() */
1361 self
->ul_self
= self
;
1362 self
->ul_policy
= -1; /* initialize only when needed */
1365 self
->ul_rtclassid
= -1;
1366 self
->ul_uberdata
= udp
;
1367 if (oldself
!= NULL
) {
1370 ASSERT(primary_link_map
);
1371 ASSERT(oldself
->ul_main
== 1);
1372 self
->ul_stsd
= oldself
->ul_stsd
;
1373 for (i
= 0; i
< TSD_NFAST
; i
++)
1374 self
->ul_ftsd
[i
] = oldself
->ul_ftsd
[i
];
1375 self
->ul_tls
= oldself
->ul_tls
;
1377 * Retrieve all pointers to uberdata allocated
1378 * while running on previous link maps.
1379 * We would like to do a structure assignment here, but
1380 * gcc turns structure assignments into calls to memcpy(),
1381 * a function exported from libc. We can't call any such
1382 * external functions until we establish curthread, below,
1383 * so we just call our private version of memcpy().
1385 (void) memcpy(udp
, oldself
->ul_uberdata
, sizeof (*udp
));
1387 * These items point to global data on the primary link map.
1389 udp
->thr_hash_table
= init_hash_table
;
1390 udp
->sigacthandler
= sigacthandler
;
1391 udp
->tdb
.tdb_events
= tdb_events
;
1392 ASSERT(udp
->nthreads
== 1 && !udp
->uberflags
.uf_mt
);
1393 ASSERT(udp
->lwp_stacks
== NULL
);
1394 ASSERT(udp
->ulwp_freelist
== NULL
);
1395 ASSERT(udp
->ulwp_replace_free
== NULL
);
1396 ASSERT(udp
->hash_size
== 1);
1398 udp
->all_lwps
= self
;
1399 udp
->ulwp_one
= self
;
1400 udp
->pid
= getpid();
1403 * In every link map, tdb_bootstrap points to the same piece of
1404 * allocated memory. When the primary link map is initialized,
1405 * the allocated memory is assigned a pointer to the one true
1406 * uberdata. This allows libc_db to initialize itself regardless
1407 * of which instance of libc it finds in the address space.
1409 if (udp
->tdb_bootstrap
== NULL
)
1410 udp
->tdb_bootstrap
= lmalloc(sizeof (uberdata_t
*));
1411 __tdb_bootstrap
= udp
->tdb_bootstrap
;
1412 if (primary_link_map
) {
1413 self
->ul_primarymap
= 1;
1414 udp
->primary_map
= 1;
1415 *udp
->tdb_bootstrap
= udp
;
1418 * Cancellation can't happen until:
1419 * pthread_cancel() is called
1421 * another thread is created
1422 * For now, as a single-threaded process, set the flag that tells
1423 * PROLOGUE/EPILOGUE (in scalls.c) that cancellation can't happen.
1425 self
->ul_nocancel
= 1;
1427 #if defined(__amd64)
1428 (void) ___lwp_private(_LWP_SETPRIVATE
, _LWP_FSBASE
, self
);
1429 #elif defined(__i386)
1430 (void) ___lwp_private(_LWP_SETPRIVATE
, _LWP_GSBASE
, self
);
1431 #endif /* __i386 || __amd64 */
1432 set_curthread(self
); /* redundant on i386 */
1434 * Now curthread is established and it is safe to call any
1435 * function in libc except one that uses thread-local storage.
1437 self
->ul_errnop
= &errno
;
1438 if (oldself
!= NULL
) {
1439 /* tls_size was zero when oldself was allocated */
1440 lfree(oldself
, sizeof (ulwp_t
));
1447 * If the stack is unlimited, we set the size to zero to disable
1449 * XXX: Work harder here. Get the stack size from /proc/self/rmap
1451 if (self
->ul_stksiz
== RLIM_INFINITY
) {
1452 self
->ul_ustack
.ss_sp
= (void *)self
->ul_stktop
;
1453 self
->ul_ustack
.ss_size
= 0;
1455 self
->ul_ustack
.ss_sp
= self
->ul_stk
;
1456 self
->ul_ustack
.ss_size
= self
->ul_stksiz
;
1458 self
->ul_ustack
.ss_flags
= 0;
1459 (void) setustack(&self
->ul_ustack
);
1462 * Get the variables that affect thread behavior from the environment.
1465 udp
->uberflags
.uf_thread_error_detection
= (char)thread_error_detection
;
1466 udp
->thread_stack_cache
= thread_stack_cache
;
1469 * Make per-thread copies of global variables, for speed.
1471 self
->ul_queue_fifo
= (char)thread_queue_fifo
;
1472 self
->ul_cond_wait_defer
= (char)thread_cond_wait_defer
;
1473 self
->ul_error_detection
= (char)thread_error_detection
;
1474 self
->ul_async_safe
= (char)thread_async_safe
;
1475 self
->ul_door_noreserve
= (char)thread_door_noreserve
;
1476 self
->ul_misaligned
= (char)thread_locks_misaligned
;
1477 self
->ul_max_spinners
= (uint8_t)thread_max_spinners
;
1478 self
->ul_adaptive_spin
= thread_adaptive_spin
;
1479 self
->ul_queue_spin
= thread_queue_spin
;
1481 #if defined(__sparc) && !defined(_LP64)
1482 if (self
->ul_misaligned
) {
1484 * Tell the kernel to fix up ldx/stx instructions that
1485 * refer to non-8-byte aligned data instead of giving
1486 * the process an alignment trap and generating SIGBUS.
1488 * Programs compiled for 32-bit sparc with the Studio SS12
1489 * compiler get this done for them automatically (in _init()).
1490 * We do it here for the benefit of programs compiled with
1491 * other compilers, like gcc.
1493 * This is necessary for the _THREAD_LOCKS_MISALIGNED=1
1494 * environment variable horrible hack to work.
1496 extern void _do_fix_align(void);
1502 * When we have initialized the primary link map, inform
1503 * the dynamic linker about our interface functions.
1504 * Set up our pointer to the program name.
1506 if (self
->ul_primarymap
)
1507 _ld_libc((void *)rtld_funcs
);
1511 * Defer signals until TLS constructors have been called.
1517 (void) restore_signals(self
);
1520 * Make private copies of __xpg4 and __xpg6 so libc can test
1521 * them after this point without invoking the dynamic linker.
1523 libc__xpg4
= __xpg4
;
1524 libc__xpg6
= __xpg6
;
1526 /* PROBE_SUPPORT begin */
1527 if (self
->ul_primarymap
&& __tnf_probe_notify
!= NULL
)
1528 __tnf_probe_notify();
1529 /* PROBE_SUPPORT end */
1531 init_sigev_thread();
1535 * We need to reset __threaded dynamically at runtime, so that
1536 * __threaded can be bound to __threaded outside libc which may not
1537 * have initial value of 1 (without a copy relocation in a.out).
1542 #pragma fini(libc_fini)
1547 * If we are doing fini processing for the instance of libc
1548 * on the first alternate link map (this happens only when
1549 * the dynamic linker rejects a bad audit library), then clear
1550 * __curthread(). We abandon whatever memory was allocated by
1551 * lmalloc() while running on this alternate link-map but we
1552 * don't care (and can't find the memory in any case); we just
1553 * want to protect the application from this bad audit library.
1554 * No fini processing is done by libc in the normal case.
1557 uberdata_t
*udp
= curthread
->ul_uberdata
;
1559 if (udp
->primary_map
== 0 && udp
== &__uberdata
)
1560 set_curthread(NULL
);
1564 * finish_init is called when we are about to become multi-threaded,
1565 * that is, on the first call to thr_create().
1570 ulwp_t
*self
= curthread
;
1571 uberdata_t
*udp
= self
->ul_uberdata
;
1572 thr_hash_table_t
*htp
;
1577 * No locks needed here; we are single-threaded on the first call.
1578 * We can be called only after the primary link map has been set up.
1580 ASSERT(self
->ul_primarymap
);
1581 ASSERT(self
== udp
->ulwp_one
);
1582 ASSERT(!udp
->uberflags
.uf_mt
);
1583 ASSERT(udp
->hash_size
== 1);
1586 * Initialize self->ul_policy, self->ul_cid, and self->ul_pri.
1591 * Allocate the queue_head array if not already allocated.
1593 if (udp
->queue_head
== NULL
)
1597 * Now allocate the thread hash table.
1599 if ((data
= mmap(NULL
, HASHTBLSZ
* sizeof (thr_hash_table_t
),
1600 PROT_READ
| PROT_WRITE
, MAP_PRIVATE
| MAP_ANON
, -1, (off_t
)0))
1602 thr_panic("cannot allocate thread hash table");
1604 udp
->thr_hash_table
= htp
= (thr_hash_table_t
*)data
;
1605 udp
->hash_size
= HASHTBLSZ
;
1606 udp
->hash_mask
= HASHTBLSZ
- 1;
1608 for (i
= 0; i
< HASHTBLSZ
; i
++, htp
++) {
1609 htp
->hash_lock
.mutex_flag
= LOCK_INITED
;
1610 htp
->hash_lock
.mutex_magic
= MUTEX_MAGIC
;
1611 htp
->hash_cond
.cond_magic
= COND_MAGIC
;
1613 hash_in_unlocked(self
, TIDHASH(self
->ul_lwpid
, udp
), udp
);
1616 * Set up the SIGCANCEL handler for threads cancellation.
1618 setup_cancelsig(SIGCANCEL
);
1621 * Arrange to do special things on exit --
1622 * - collect queue statistics from all remaining active threads.
1623 * - dump queue statistics to stderr if _THREAD_QUEUE_DUMP is set.
1624 * - grab assert_lock to ensure that assertion failures
1625 * and a core dump take precedence over _exit().
1626 * (Functions are called in the reverse order of their registration.)
1628 (void) _atexit(grab_assert_lock
);
1629 #if defined(THREAD_DEBUG)
1630 (void) _atexit(dump_queue_statistics
);
1631 (void) _atexit(collect_queue_statistics
);
1636 * Used only by postfork1_child(), below.
1639 mark_dead_and_buried(ulwp_t
*ulwp
)
1642 ulwp
->ul_lwpid
= (lwpid_t
)(-1);
1643 ulwp
->ul_hash
= NULL
;
1645 ulwp
->ul_schedctl
= NULL
;
1646 ulwp
->ul_schedctl_called
= NULL
;
1650 * This is called from fork1() in the child.
1651 * Reset our data structures to reflect one lwp.
1656 ulwp_t
*self
= curthread
;
1657 uberdata_t
*udp
= self
->ul_uberdata
;
1663 /* daemon threads shouldn't call fork1(), but oh well... */
1664 self
->ul_usropts
&= ~THR_DAEMON
;
1667 udp
->uberflags
.uf_mt
= 0;
1668 __libc_threaded
= 0;
1669 for (i
= 0; i
< udp
->hash_size
; i
++)
1670 udp
->thr_hash_table
[i
].hash_bucket
= NULL
;
1671 self
->ul_lwpid
= _lwp_self();
1672 hash_in_unlocked(self
, TIDHASH(self
->ul_lwpid
, udp
), udp
);
1675 * Some thread in the parent might have been suspended
1676 * while holding udp->callout_lock or udp->ld_lock.
1677 * Reinitialize the child's copies.
1679 (void) mutex_init(&udp
->callout_lock
,
1680 USYNC_THREAD
| LOCK_RECURSIVE
, NULL
);
1681 (void) mutex_init(&udp
->ld_lock
,
1682 USYNC_THREAD
| LOCK_RECURSIVE
, NULL
);
1684 /* no one in the child is on a sleep queue; reinitialize */
1685 if ((qp
= udp
->queue_head
) != NULL
) {
1686 (void) memset(qp
, 0, 2 * QHASHSIZE
* sizeof (queue_head_t
));
1687 for (i
= 0; i
< 2 * QHASHSIZE
; qp
++, i
++) {
1688 qp
->qh_type
= (i
< QHASHSIZE
)? MX
: CV
;
1689 qp
->qh_lock
.mutex_flag
= LOCK_INITED
;
1690 qp
->qh_lock
.mutex_magic
= MUTEX_MAGIC
;
1691 qp
->qh_hlist
= &qp
->qh_def_root
;
1692 #if defined(THREAD_DEBUG)
1700 * Do post-fork1 processing for subsystems that need it.
1701 * We need to do this before unmapping all of the abandoned
1702 * threads' stacks, below(), because the post-fork1 actions
1703 * might require access to those stacks.
1705 postfork1_child_sigev_aio();
1706 postfork1_child_sigev_mq();
1707 postfork1_child_sigev_timer();
1708 postfork1_child_aio();
1710 * The above subsystems use thread pools, so this action
1711 * must be performed after those actions.
1713 postfork1_child_tpool();
1716 * All lwps except ourself are gone. Mark them so.
1717 * First mark all of the lwps that have already been freed.
1718 * Then mark and free all of the active lwps except ourself.
1719 * Since we are single-threaded, no locks are required here.
1721 for (ulwp
= udp
->lwp_stacks
; ulwp
!= NULL
; ulwp
= ulwp
->ul_next
)
1722 mark_dead_and_buried(ulwp
);
1723 for (ulwp
= udp
->ulwp_freelist
; ulwp
!= NULL
; ulwp
= ulwp
->ul_next
)
1724 mark_dead_and_buried(ulwp
);
1725 for (ulwp
= self
->ul_forw
; ulwp
!= self
; ulwp
= next
) {
1726 next
= ulwp
->ul_forw
;
1727 ulwp
->ul_forw
= ulwp
->ul_back
= NULL
;
1728 mark_dead_and_buried(ulwp
);
1732 heldlock_free(ulwp
);
1735 self
->ul_forw
= self
->ul_back
= udp
->all_lwps
= self
;
1736 if (self
!= udp
->ulwp_one
)
1737 mark_dead_and_buried(udp
->ulwp_one
);
1738 if ((ulwp
= udp
->all_zombies
) != NULL
) {
1739 ASSERT(udp
->nzombies
!= 0);
1741 next
= ulwp
->ul_forw
;
1742 ulwp
->ul_forw
= ulwp
->ul_back
= NULL
;
1743 mark_dead_and_buried(ulwp
);
1745 if (ulwp
->ul_replace
) {
1746 ulwp
->ul_next
= NULL
;
1747 if (udp
->ulwp_replace_free
== NULL
) {
1748 udp
->ulwp_replace_free
=
1749 udp
->ulwp_replace_last
= ulwp
;
1751 udp
->ulwp_replace_last
->ul_next
= ulwp
;
1752 udp
->ulwp_replace_last
= ulwp
;
1755 } while ((ulwp
= next
) != udp
->all_zombies
);
1756 ASSERT(udp
->nzombies
== 0);
1757 udp
->all_zombies
= NULL
;
1760 trim_stack_cache(0);
1766 return (curthread
->ul_lwpid
);
1769 #pragma weak _ti_thr_self = thr_self
1770 #pragma weak pthread_self = thr_self
1774 return (curthread
->ul_lwpid
);
1780 ulwp_t
*self
= __curthread();
1782 return ((self
== NULL
)? -1 : self
->ul_main
);
1786 _thrp_cancelled(void)
1788 return (curthread
->ul_rval
== PTHREAD_CANCELED
);
1792 _thrp_stksegment(ulwp_t
*ulwp
, stack_t
*stk
)
1794 stk
->ss_sp
= (void *)ulwp
->ul_stktop
;
1795 stk
->ss_size
= ulwp
->ul_stksiz
;
1800 #pragma weak _thr_stksegment = thr_stksegment
1802 thr_stksegment(stack_t
*stk
)
1804 return (_thrp_stksegment(curthread
, stk
));
1808 force_continue(ulwp_t
*ulwp
)
1810 #if defined(THREAD_DEBUG)
1811 ulwp_t
*self
= curthread
;
1812 uberdata_t
*udp
= self
->ul_uberdata
;
1817 ASSERT(MUTEX_OWNED(&udp
->fork_lock
, self
));
1818 ASSERT(MUTEX_OWNED(ulwp_mutex(ulwp
, udp
), self
));
1821 error
= _lwp_continue(ulwp
->ul_lwpid
);
1822 if (error
!= 0 && error
!= EINTR
)
1825 if (ulwp
->ul_stopping
) { /* it is stopping itself */
1826 ts
.tv_sec
= 0; /* give it a chance to run */
1827 ts
.tv_nsec
= 100000; /* 100 usecs or clock tick */
1828 (void) __nanosleep(&ts
, NULL
);
1830 if (!ulwp
->ul_stopping
) /* it is running now */
1831 break; /* so we are done */
1833 * It is marked as being in the process of stopping
1834 * itself. Loop around and continue it again.
1835 * It may not have been stopped the first time.
1841 * Suspend an lwp with lwp_suspend(), then move it to a safe point,
1842 * that is, to a point where ul_critical and ul_rtld are both zero.
1843 * On return, the ulwp_lock() is dropped as with ulwp_unlock().
1844 * If 'link_dropped' is non-NULL, then 'link_lock' is held on entry.
1845 * If we have to drop link_lock, we store 1 through link_dropped.
1846 * If the lwp exits before it can be suspended, we return ESRCH.
1849 safe_suspend(ulwp_t
*ulwp
, uchar_t whystopped
, int *link_dropped
)
1851 ulwp_t
*self
= curthread
;
1852 uberdata_t
*udp
= self
->ul_uberdata
;
1853 cond_t
*cvp
= ulwp_condvar(ulwp
, udp
);
1854 mutex_t
*mp
= ulwp_mutex(ulwp
, udp
);
1855 thread_t tid
= ulwp
->ul_lwpid
;
1856 int ix
= ulwp
->ul_ix
;
1859 ASSERT(whystopped
== TSTP_REGULAR
||
1860 whystopped
== TSTP_MUTATOR
||
1861 whystopped
== TSTP_FORK
);
1862 ASSERT(ulwp
!= self
);
1863 ASSERT(!ulwp
->ul_stop
);
1864 ASSERT(MUTEX_OWNED(&udp
->fork_lock
, self
));
1865 ASSERT(MUTEX_OWNED(mp
, self
));
1867 if (link_dropped
!= NULL
)
1871 * We must grab the target's spin lock before suspending it.
1872 * See the comments below and in _thrp_suspend() for why.
1874 spin_lock_set(&ulwp
->ul_spinlock
);
1875 (void) ___lwp_suspend(tid
);
1876 spin_lock_clear(&ulwp
->ul_spinlock
);
1879 if ((ulwp
->ul_critical
== 0 && ulwp
->ul_rtld
== 0) ||
1880 ulwp
->ul_stopping
) {
1881 /* thread is already safe */
1882 ulwp
->ul_stop
|= whystopped
;
1885 * Setting ul_pleasestop causes the target thread to stop
1886 * itself in _thrp_suspend(), below, after we drop its lock.
1887 * We must continue the critical thread before dropping
1888 * link_lock because the critical thread may be holding
1889 * the queue lock for link_lock. This is delicate.
1891 ulwp
->ul_pleasestop
|= whystopped
;
1892 force_continue(ulwp
);
1893 if (link_dropped
!= NULL
) {
1895 lmutex_unlock(&udp
->link_lock
);
1896 /* be sure to drop link_lock only once */
1897 link_dropped
= NULL
;
1901 * The thread may disappear by calling thr_exit() so we
1902 * cannot rely on the ulwp pointer after dropping the lock.
1903 * Instead, we search the hash table to find it again.
1904 * When we return, we may find that the thread has been
1905 * continued by some other thread. The suspend/continue
1906 * interfaces are prone to such race conditions by design.
1908 while (ulwp
&& !ulwp
->ul_dead
&& !ulwp
->ul_stop
&&
1909 (ulwp
->ul_pleasestop
& whystopped
)) {
1910 (void) __cond_wait(cvp
, mp
);
1911 for (ulwp
= udp
->thr_hash_table
[ix
].hash_bucket
;
1912 ulwp
!= NULL
; ulwp
= ulwp
->ul_hash
) {
1913 if (ulwp
->ul_lwpid
== tid
)
1918 if (ulwp
== NULL
|| ulwp
->ul_dead
)
1922 * Do another lwp_suspend() to make sure we don't
1923 * return until the target thread is fully stopped
1924 * in the kernel. Don't apply lwp_suspend() until
1925 * we know that the target is not holding any
1926 * queue locks, that is, that it has completed
1927 * ulwp_unlock(self) and has, or at least is
1928 * about to, call lwp_suspend() on itself. We do
1929 * this by grabbing the target's spin lock.
1931 ASSERT(ulwp
->ul_lwpid
== tid
);
1932 spin_lock_set(&ulwp
->ul_spinlock
);
1933 (void) ___lwp_suspend(tid
);
1934 spin_lock_clear(&ulwp
->ul_spinlock
);
1936 * If some other thread did a thr_continue()
1937 * on the target thread we have to start over.
1939 if (!ulwp
->ul_stopping
|| !(ulwp
->ul_stop
& whystopped
))
1944 (void) cond_broadcast(cvp
);
1950 _thrp_suspend(thread_t tid
, uchar_t whystopped
)
1952 ulwp_t
*self
= curthread
;
1953 uberdata_t
*udp
= self
->ul_uberdata
;
1957 ASSERT((whystopped
& (TSTP_REGULAR
|TSTP_MUTATOR
|TSTP_FORK
)) != 0);
1958 ASSERT((whystopped
& ~(TSTP_REGULAR
|TSTP_MUTATOR
|TSTP_FORK
)) == 0);
1961 * We can't suspend anyone except ourself while
1962 * some other thread is performing a fork.
1963 * This also allows only one suspension at a time.
1965 if (tid
!= self
->ul_lwpid
)
1968 if ((ulwp
= find_lwp(tid
)) == NULL
)
1970 else if (whystopped
== TSTP_MUTATOR
&& !ulwp
->ul_mutator
) {
1971 ulwp_unlock(ulwp
, udp
);
1973 } else if (ulwp
->ul_stop
) { /* already stopped */
1974 ulwp
->ul_stop
|= whystopped
;
1975 ulwp_broadcast(ulwp
);
1976 ulwp_unlock(ulwp
, udp
);
1977 } else if (ulwp
!= self
) {
1979 * After suspending the other thread, move it out of a
1980 * critical section and deal with the schedctl mappings.
1981 * safe_suspend() suspends the other thread, calls
1982 * ulwp_broadcast(ulwp) and drops the ulwp lock.
1984 error
= safe_suspend(ulwp
, whystopped
, NULL
);
1986 int schedctl_after_fork
= 0;
1989 * We are suspending ourself. We must not take a signal
1990 * until we return from lwp_suspend() and clear ul_stopping.
1991 * This is to guard against siglongjmp().
1993 enter_critical(self
);
1994 self
->ul_sp
= stkptr();
1995 _flush_windows(); /* sparc */
1996 self
->ul_pleasestop
= 0;
1997 self
->ul_stop
|= whystopped
;
1999 * Grab our spin lock before dropping ulwp_mutex(self).
2000 * This prevents the suspending thread from applying
2001 * lwp_suspend() to us before we emerge from
2002 * lmutex_unlock(mp) and have dropped mp's queue lock.
2004 spin_lock_set(&self
->ul_spinlock
);
2005 self
->ul_stopping
= 1;
2006 ulwp_broadcast(self
);
2007 ulwp_unlock(self
, udp
);
2009 * From this point until we return from lwp_suspend(),
2010 * we must not call any function that might invoke the
2011 * dynamic linker, that is, we can only call functions
2012 * private to the library.
2014 * Also, this is a nasty race condition for a process
2015 * that is undergoing a forkall() operation:
2016 * Once we clear our spinlock (below), we are vulnerable
2017 * to being suspended by the forkall() thread before
2018 * we manage to suspend ourself in ___lwp_suspend().
2019 * See safe_suspend() and force_continue().
2021 * To avoid a SIGSEGV due to the disappearance
2022 * of the schedctl mappings in the child process,
2023 * which can happen in spin_lock_clear() if we
2024 * are suspended while we are in the middle of
2025 * its call to preempt(), we preemptively clear
2026 * our own schedctl pointer before dropping our
2027 * spinlock. We reinstate it, in both the parent
2028 * and (if this really is a forkall()) the child.
2030 if (whystopped
& TSTP_FORK
) {
2031 schedctl_after_fork
= 1;
2032 self
->ul_schedctl
= NULL
;
2033 self
->ul_schedctl_called
= &udp
->uberflags
;
2035 spin_lock_clear(&self
->ul_spinlock
);
2036 (void) ___lwp_suspend(tid
);
2038 * Somebody else continued us.
2039 * We can't grab ulwp_lock(self)
2040 * until after clearing ul_stopping.
2041 * force_continue() relies on this.
2043 self
->ul_stopping
= 0;
2045 if (schedctl_after_fork
) {
2046 self
->ul_schedctl_called
= NULL
;
2047 self
->ul_schedctl
= NULL
;
2048 (void) setup_schedctl();
2050 ulwp_lock(self
, udp
);
2051 ulwp_broadcast(self
);
2052 ulwp_unlock(self
, udp
);
2053 exit_critical(self
);
2056 if (tid
!= self
->ul_lwpid
)
2063 * Suspend all lwps other than ourself in preparation for fork.
2068 ulwp_t
*self
= curthread
;
2069 uberdata_t
*udp
= self
->ul_uberdata
;
2073 ASSERT(MUTEX_OWNED(&udp
->fork_lock
, self
));
2075 lmutex_lock(&udp
->link_lock
);
2077 for (ulwp
= self
->ul_forw
; ulwp
!= self
; ulwp
= ulwp
->ul_forw
) {
2078 ulwp_lock(ulwp
, udp
);
2079 if (ulwp
->ul_stop
) { /* already stopped */
2080 ulwp
->ul_stop
|= TSTP_FORK
;
2081 ulwp_broadcast(ulwp
);
2082 ulwp_unlock(ulwp
, udp
);
2085 * Move the stopped lwp out of a critical section.
2087 if (safe_suspend(ulwp
, TSTP_FORK
, &link_dropped
) ||
2093 lmutex_unlock(&udp
->link_lock
);
2097 continue_fork(int child
)
2099 ulwp_t
*self
= curthread
;
2100 uberdata_t
*udp
= self
->ul_uberdata
;
2103 ASSERT(MUTEX_OWNED(&udp
->fork_lock
, self
));
2106 * Clear the schedctl pointers in the child of forkall().
2109 for (ulwp
= self
->ul_forw
; ulwp
!= self
; ulwp
= ulwp
->ul_forw
) {
2110 ulwp
->ul_schedctl_called
=
2111 ulwp
->ul_dead
? &udp
->uberflags
: NULL
;
2112 ulwp
->ul_schedctl
= NULL
;
2117 * Set all lwps that were stopped for fork() running again.
2119 lmutex_lock(&udp
->link_lock
);
2120 for (ulwp
= self
->ul_forw
; ulwp
!= self
; ulwp
= ulwp
->ul_forw
) {
2121 mutex_t
*mp
= ulwp_mutex(ulwp
, udp
);
2123 ASSERT(ulwp
->ul_stop
& TSTP_FORK
);
2124 ulwp
->ul_stop
&= ~TSTP_FORK
;
2125 ulwp_broadcast(ulwp
);
2127 force_continue(ulwp
);
2130 lmutex_unlock(&udp
->link_lock
);
2134 _thrp_continue(thread_t tid
, uchar_t whystopped
)
2136 uberdata_t
*udp
= curthread
->ul_uberdata
;
2141 ASSERT(whystopped
== TSTP_REGULAR
||
2142 whystopped
== TSTP_MUTATOR
);
2145 * We single-thread the entire thread suspend/continue mechanism.
2149 if ((ulwp
= find_lwp(tid
)) == NULL
) {
2154 mp
= ulwp_mutex(ulwp
, udp
);
2155 if ((whystopped
== TSTP_MUTATOR
&& !ulwp
->ul_mutator
)) {
2157 } else if (ulwp
->ul_stop
& whystopped
) {
2158 ulwp
->ul_stop
&= ~whystopped
;
2159 ulwp_broadcast(ulwp
);
2160 if (!ulwp
->ul_stop
) {
2161 if (whystopped
== TSTP_REGULAR
&& ulwp
->ul_created
) {
2163 ulwp
->ul_created
= 0;
2165 force_continue(ulwp
);
2175 thr_suspend(thread_t tid
)
2177 return (_thrp_suspend(tid
, TSTP_REGULAR
));
2181 thr_continue(thread_t tid
)
2183 return (_thrp_continue(tid
, TSTP_REGULAR
));
2192 #pragma weak pthread_kill = thr_kill
2193 #pragma weak _thr_kill = thr_kill
2195 thr_kill(thread_t tid
, int sig
)
2197 if (sig
== SIGCANCEL
)
2199 return (_lwp_kill(tid
, sig
));
2203 * Exit a critical section, take deferred actions if necessary.
2204 * Called from exit_critical() and from sigon().
2209 ulwp_t
*self
= curthread
;
2212 ASSERT(self
->ul_critical
== 0);
2215 * Don't suspend ourself or take a deferred signal while dying
2216 * or while executing inside the dynamic linker (ld.so.1).
2218 if (self
->ul_dead
|| self
->ul_rtld
)
2221 while (self
->ul_pleasestop
||
2222 (self
->ul_cursig
!= 0 && self
->ul_sigdefer
== 0)) {
2224 * Avoid a recursive call to exit_critical() in _thrp_suspend()
2225 * by keeping self->ul_critical == 1 here.
2227 self
->ul_critical
++;
2228 while (self
->ul_pleasestop
) {
2230 * Guard against suspending ourself while on a sleep
2231 * queue. See the comments in call_user_handler().
2234 set_parking_flag(self
, 0);
2235 (void) _thrp_suspend(self
->ul_lwpid
,
2236 self
->ul_pleasestop
);
2238 self
->ul_critical
--;
2240 if ((sig
= self
->ul_cursig
) != 0 && self
->ul_sigdefer
== 0) {
2242 * Clear ul_cursig before proceeding.
2243 * This protects us from the dynamic linker's
2244 * calls to bind_guard()/bind_clear() in the
2245 * event that it is invoked to resolve a symbol
2246 * like take_deferred_signal() below.
2248 self
->ul_cursig
= 0;
2249 take_deferred_signal(sig
);
2250 ASSERT(self
->ul_cursig
== 0);
2253 ASSERT(self
->ul_critical
== 0);
2257 * _ti_bind_guard() and _ti_bind_clear() are called by the dynamic linker
2258 * (ld.so.1) when it has do do something, like resolve a symbol to be called
2259 * by the application or one of its libraries. _ti_bind_guard() is called
2260 * on entry to ld.so.1, _ti_bind_clear() on exit from ld.so.1 back to the
2261 * application. The dynamic linker gets special dispensation from libc to
2262 * run in a critical region (all signals deferred and no thread suspension
2263 * or forking allowed), and to be immune from cancellation for the duration.
2266 _ti_bind_guard(int flags
)
2268 ulwp_t
*self
= curthread
;
2269 uberdata_t
*udp
= self
->ul_uberdata
;
2270 int bindflag
= (flags
& THR_FLG_RTLD
);
2272 if ((self
->ul_bindflags
& bindflag
) == bindflag
)
2274 self
->ul_bindflags
|= bindflag
;
2275 if ((flags
& (THR_FLG_NOLOCK
| THR_FLG_REENTER
)) == THR_FLG_NOLOCK
) {
2276 sigoff(self
); /* see no signals while holding ld_lock */
2277 self
->ul_rtld
++; /* don't suspend while in ld.so.1 */
2278 (void) mutex_lock(&udp
->ld_lock
);
2280 enter_critical(self
);
2281 self
->ul_save_state
= self
->ul_cancel_disabled
;
2282 self
->ul_cancel_disabled
= 1;
2283 set_cancel_pending_flag(self
, 0);
2288 _ti_bind_clear(int flags
)
2290 ulwp_t
*self
= curthread
;
2291 uberdata_t
*udp
= self
->ul_uberdata
;
2292 int bindflag
= (flags
& THR_FLG_RTLD
);
2294 if ((self
->ul_bindflags
& bindflag
) == 0)
2295 return (self
->ul_bindflags
);
2296 self
->ul_bindflags
&= ~bindflag
;
2297 self
->ul_cancel_disabled
= self
->ul_save_state
;
2298 set_cancel_pending_flag(self
, 0);
2299 exit_critical(self
);
2300 if ((flags
& (THR_FLG_NOLOCK
| THR_FLG_REENTER
)) == THR_FLG_NOLOCK
) {
2301 if (MUTEX_OWNED(&udp
->ld_lock
, self
)) {
2302 (void) mutex_unlock(&udp
->ld_lock
);
2304 sigon(self
); /* reenable signals */
2307 return (self
->ul_bindflags
);
2311 * Tell the dynamic linker (ld.so.1) whether or not it was entered from
2312 * a critical region in libc. Return zero if not, else return non-zero.
2317 ulwp_t
*self
= curthread
;
2318 int level
= self
->ul_critical
;
2320 if ((self
->ul_bindflags
& THR_FLG_RTLD
) == 0 || level
== 0)
2321 return (level
); /* ld.so.1 hasn't (yet) called enter() */
2326 * sigoff() and sigon() enable cond_wait() to behave (optionally) like
2327 * it does in the old libthread (see the comments in cond_wait_queue()).
2328 * Also, signals are deferred at thread startup until TLS constructors
2329 * have all been called, at which time _thrp_setup() calls sigon().
2331 * _sigoff() and _sigon() are external consolidation-private interfaces to
2332 * sigoff() and sigon(), respectively, in libc. These are used in libnsl.
2333 * Also, _sigoff() and _sigon() are called from dbx's run-time checking
2334 * (librtc.so) to defer signals during its critical sections (not to be
2335 * confused with libc critical sections [see exit_critical() above]).
2340 ulwp_t
*self
= curthread
;
2348 ulwp_t
*self
= curthread
;
2350 ASSERT(self
->ul_sigdefer
> 0);
2355 thr_getconcurrency()
2357 return (thr_concurrency
);
2361 pthread_getconcurrency()
2363 return (pthread_concurrency
);
2367 thr_setconcurrency(int new_level
)
2369 uberdata_t
*udp
= curthread
->ul_uberdata
;
2373 if (new_level
> 65536) /* 65536 is totally arbitrary */
2375 lmutex_lock(&udp
->link_lock
);
2376 if (new_level
> thr_concurrency
)
2377 thr_concurrency
= new_level
;
2378 lmutex_unlock(&udp
->link_lock
);
2383 pthread_setconcurrency(int new_level
)
2387 if (new_level
> 65536) /* 65536 is totally arbitrary */
2389 pthread_concurrency
= new_level
;
2402 return (curthread
->ul_uberdata
->nthreads
);
2405 /* "/proc/self/lwp/%u/lwpname" w/o stdio */
2407 lwpname_path(pthread_t tid
, char *buf
, size_t bufsize
)
2409 (void) strlcpy(buf
, "/proc/self/lwp/", bufsize
);
2410 ultos((uint64_t)tid
, 10, buf
+ strlen(buf
));
2411 (void) strlcat(buf
, "/lwpname", bufsize
);
2414 #pragma weak pthread_setname_np = thr_setname
2416 thr_setname(pthread_t tid
, const char *name
)
2418 extern ssize_t
__write(int, const void *, size_t);
2419 char path
[PATH_MAX
];
2428 len
= strlen(name
) + 1;
2429 if (len
> THREAD_NAME_MAX
)
2432 lwpname_path(tid
, path
, sizeof (path
));
2434 if ((fd
= __open(path
, O_WRONLY
, 0)) < 0) {
2435 if (errno
== ENOENT
)
2440 n
= __write(fd
, name
, len
);
2441 saved_errno
= errno
;
2445 return (saved_errno
);
2451 #pragma weak pthread_getname_np = thr_getname
2453 thr_getname(pthread_t tid
, char *buf
, size_t bufsize
)
2455 extern ssize_t
__read(int, void *, size_t);
2456 char name
[THREAD_NAME_MAX
];
2457 char path
[PATH_MAX
];
2465 lwpname_path(tid
, path
, sizeof (path
));
2467 if ((fd
= __open(path
, O_RDONLY
, 0)) < 0) {
2468 if (errno
== ENOENT
)
2473 n
= __read(fd
, name
, sizeof (name
));
2474 saved_errno
= errno
;
2478 return (saved_errno
);
2479 if (n
!= sizeof (name
))
2481 if (strlcpy(buf
, name
, bufsize
) >= bufsize
)
2488 * The remainder of this file implements the private interfaces to java for
2489 * garbage collection. It is no longer used, at least by java 1.2.
2490 * It can all go away once all old JVMs have disappeared.
2493 int suspendingallmutators
; /* when non-zero, suspending all mutators. */
2494 int suspendedallmutators
; /* when non-zero, all mutators suspended. */
2495 int mutatorsbarrier
; /* when non-zero, mutators barrier imposed. */
2496 mutex_t mutatorslock
= DEFAULTMUTEX
; /* used to enforce mutators barrier. */
2497 cond_t mutatorscv
= DEFAULTCV
; /* where non-mutators sleep. */
2500 * Get the available register state for the target thread.
2501 * Return non-volatile registers: TRS_NONVOLATILE
2503 #pragma weak _thr_getstate = thr_getstate
2505 thr_getstate(thread_t tid
, int *flag
, lwpid_t
*lwp
, stack_t
*ss
, gregset_t rs
)
2507 ulwp_t
*self
= curthread
;
2508 uberdata_t
*udp
= self
->ul_uberdata
;
2512 int trs_flag
= TRS_LWPID
;
2514 if (tid
== 0 || self
->ul_lwpid
== tid
) {
2516 ulwp_lock(ulwp
, udp
);
2517 } else if ((ulwpp
= find_lwpp(tid
)) != NULL
) {
2521 *flag
= TRS_INVALID
;
2525 if (ulwp
->ul_dead
) {
2526 trs_flag
= TRS_INVALID
;
2527 } else if (!ulwp
->ul_stop
&& !suspendedallmutators
) {
2529 trs_flag
= TRS_INVALID
;
2530 } else if (ulwp
->ul_stop
) {
2531 trs_flag
= TRS_NONVOLATILE
;
2540 (void) _thrp_stksegment(ulwp
, ss
);
2542 ulwp_unlock(ulwp
, udp
);
2547 * Set the appropriate register state for the target thread.
2548 * This is not used by java. It exists solely for the MSTC test suite.
2550 #pragma weak _thr_setstate = thr_setstate
2552 thr_setstate(thread_t tid
, int flag
, gregset_t rs
)
2554 uberdata_t
*udp
= curthread
->ul_uberdata
;
2558 if ((ulwp
= find_lwp(tid
)) == NULL
)
2561 if (!ulwp
->ul_stop
&& !suspendedallmutators
)
2563 else if (rs
!= NULL
) {
2565 case TRS_NONVOLATILE
:
2566 /* do /proc stuff here? */
2572 case TRS_LWPID
: /* do /proc stuff here? */
2579 ulwp_unlock(ulwp
, udp
);
2584 getlwpstatus(thread_t tid
, struct lwpstatus
*sp
)
2586 extern ssize_t
__pread(int, void *, size_t, off_t
);
2590 /* "/proc/self/lwp/%u/lwpstatus" w/o stdio */
2591 (void) strcpy(buf
, "/proc/self/lwp/");
2592 ultos((uint64_t)tid
, 10, buf
+ strlen(buf
));
2593 (void) strcat(buf
, "/lwpstatus");
2594 if ((fd
= __open(buf
, O_RDONLY
, 0)) >= 0) {
2595 while (__pread(fd
, sp
, sizeof (*sp
), 0) == sizeof (*sp
)) {
2596 if (sp
->pr_flags
& PR_STOPPED
) {
2600 yield(); /* give it a chance to stop */
2608 putlwpregs(thread_t tid
, prgregset_t prp
)
2610 extern ssize_t
__writev(int, const struct iovec
*, int);
2617 /* "/proc/self/lwp/%u/lwpctl" w/o stdio */
2618 (void) strcpy(buf
, "/proc/self/lwp/");
2619 ultos((uint64_t)tid
, 10, buf
+ strlen(buf
));
2620 (void) strcat(buf
, "/lwpctl");
2621 if ((fd
= __open(buf
, O_WRONLY
, 0)) >= 0) {
2622 dstop_sreg
[0] = PCDSTOP
; /* direct it to stop */
2623 dstop_sreg
[1] = PCSREG
; /* set the registers */
2624 iov
[0].iov_base
= (caddr_t
)dstop_sreg
;
2625 iov
[0].iov_len
= sizeof (dstop_sreg
);
2626 iov
[1].iov_base
= (caddr_t
)prp
; /* from the register set */
2627 iov
[1].iov_len
= sizeof (prgregset_t
);
2628 run_null
[0] = PCRUN
; /* make it runnable again */
2630 iov
[2].iov_base
= (caddr_t
)run_null
;
2631 iov
[2].iov_len
= sizeof (run_null
);
2632 if (__writev(fd
, iov
, 3) >= 0) {
2642 gettsp_slow(thread_t tid
)
2645 struct lwpstatus status
;
2647 if (getlwpstatus(tid
, &status
) != 0) {
2648 /* "__gettsp(%u): can't read lwpstatus" w/o stdio */
2649 (void) strcpy(buf
, "__gettsp(");
2650 ultos((uint64_t)tid
, 10, buf
+ strlen(buf
));
2651 (void) strcat(buf
, "): can't read lwpstatus");
2654 return (status
.pr_reg
[R_SP
]);
2658 __gettsp(thread_t tid
)
2660 uberdata_t
*udp
= curthread
->ul_uberdata
;
2664 if ((ulwp
= find_lwp(tid
)) == NULL
)
2667 if (ulwp
->ul_stop
&& (result
= ulwp
->ul_sp
) != 0) {
2668 ulwp_unlock(ulwp
, udp
);
2672 result
= gettsp_slow(tid
);
2673 ulwp_unlock(ulwp
, udp
);
2678 * This tells java stack walkers how to find the ucontext
2679 * structure passed to signal handlers.
2681 #pragma weak _thr_sighndlrinfo = thr_sighndlrinfo
2683 thr_sighndlrinfo(void (**func
)(), int *funcsize
)
2685 *func
= &__sighndlr
;
2686 *funcsize
= (char *)&__sighndlrend
- (char *)&__sighndlr
;
2690 * Mark a thread a mutator or reset a mutator to being a default,
2691 * non-mutator thread.
2693 #pragma weak _thr_setmutator = thr_setmutator
2695 thr_setmutator(thread_t tid
, int enabled
)
2697 ulwp_t
*self
= curthread
;
2698 uberdata_t
*udp
= self
->ul_uberdata
;
2703 enabled
= enabled
? 1 : 0;
2707 ulwp_lock(ulwp
, udp
);
2708 } else if ((ulwp
= find_lwp(tid
)) == NULL
) {
2713 * The target thread should be the caller itself or a suspended thread.
2714 * This prevents the target from also changing its ul_mutator field.
2717 if (ulwp
!= self
&& !ulwp
->ul_stop
&& enabled
)
2719 else if (ulwp
->ul_mutator
!= enabled
) {
2720 lmutex_lock(&mutatorslock
);
2721 if (mutatorsbarrier
) {
2722 ulwp_unlock(ulwp
, udp
);
2723 (void) pthread_setcancelstate(PTHREAD_CANCEL_DISABLE
,
2725 while (mutatorsbarrier
)
2726 (void) cond_wait(&mutatorscv
, &mutatorslock
);
2727 (void) pthread_setcancelstate(cancel_state
, NULL
);
2728 lmutex_unlock(&mutatorslock
);
2731 ulwp
->ul_mutator
= enabled
;
2732 lmutex_unlock(&mutatorslock
);
2735 ulwp_unlock(ulwp
, udp
);
2740 * Establish a barrier against new mutators. Any non-mutator trying
2741 * to become a mutator is suspended until the barrier is removed.
2743 #pragma weak _thr_mutators_barrier = thr_mutators_barrier
2745 thr_mutators_barrier(int enabled
)
2750 lmutex_lock(&mutatorslock
);
2753 * Wait if trying to set the barrier while it is already set.
2755 (void) pthread_setcancelstate(PTHREAD_CANCEL_DISABLE
, &cancel_state
);
2756 while (mutatorsbarrier
&& enabled
)
2757 (void) cond_wait(&mutatorscv
, &mutatorslock
);
2758 (void) pthread_setcancelstate(cancel_state
, NULL
);
2760 oldvalue
= mutatorsbarrier
;
2761 mutatorsbarrier
= enabled
;
2763 * Wakeup any blocked non-mutators when barrier is removed.
2765 if (oldvalue
&& !enabled
)
2766 (void) cond_broadcast(&mutatorscv
);
2767 lmutex_unlock(&mutatorslock
);
2771 * Suspend the set of all mutators except for the caller. The list
2772 * of actively running threads is searched and only the mutators
2773 * in this list are suspended. Actively running non-mutators remain
2774 * running. Any other thread is suspended.
2776 #pragma weak _thr_suspend_allmutators = thr_suspend_allmutators
2778 thr_suspend_allmutators(void)
2780 ulwp_t
*self
= curthread
;
2781 uberdata_t
*udp
= self
->ul_uberdata
;
2786 * We single-thread the entire thread suspend/continue mechanism.
2791 lmutex_lock(&udp
->link_lock
);
2793 if (suspendingallmutators
|| suspendedallmutators
) {
2794 lmutex_unlock(&udp
->link_lock
);
2798 suspendingallmutators
= 1;
2800 for (ulwp
= self
->ul_forw
; ulwp
!= self
; ulwp
= ulwp
->ul_forw
) {
2801 ulwp_lock(ulwp
, udp
);
2802 if (!ulwp
->ul_mutator
) {
2803 ulwp_unlock(ulwp
, udp
);
2804 } else if (ulwp
->ul_stop
) { /* already stopped */
2805 ulwp
->ul_stop
|= TSTP_MUTATOR
;
2806 ulwp_broadcast(ulwp
);
2807 ulwp_unlock(ulwp
, udp
);
2810 * Move the stopped lwp out of a critical section.
2812 if (safe_suspend(ulwp
, TSTP_MUTATOR
, &link_dropped
) ||
2814 suspendingallmutators
= 0;
2820 suspendedallmutators
= 1;
2821 suspendingallmutators
= 0;
2822 lmutex_unlock(&udp
->link_lock
);
2828 * Suspend the target mutator. The caller is permitted to suspend
2829 * itself. If a mutator barrier is enabled, the caller will suspend
2830 * itself as though it had been suspended by thr_suspend_allmutators().
2831 * When the barrier is removed, this thread will be resumed. Any
2832 * suspended mutator, whether suspended by thr_suspend_mutator(), or by
2833 * thr_suspend_allmutators(), can be resumed by thr_continue_mutator().
2835 #pragma weak _thr_suspend_mutator = thr_suspend_mutator
2837 thr_suspend_mutator(thread_t tid
)
2840 tid
= curthread
->ul_lwpid
;
2841 return (_thrp_suspend(tid
, TSTP_MUTATOR
));
2845 * Resume the set of all suspended mutators.
2847 #pragma weak _thr_continue_allmutators = thr_continue_allmutators
2849 thr_continue_allmutators()
2851 ulwp_t
*self
= curthread
;
2852 uberdata_t
*udp
= self
->ul_uberdata
;
2856 * We single-thread the entire thread suspend/continue mechanism.
2860 lmutex_lock(&udp
->link_lock
);
2861 if (!suspendedallmutators
) {
2862 lmutex_unlock(&udp
->link_lock
);
2866 suspendedallmutators
= 0;
2868 for (ulwp
= self
->ul_forw
; ulwp
!= self
; ulwp
= ulwp
->ul_forw
) {
2869 mutex_t
*mp
= ulwp_mutex(ulwp
, udp
);
2871 if (ulwp
->ul_stop
& TSTP_MUTATOR
) {
2872 ulwp
->ul_stop
&= ~TSTP_MUTATOR
;
2873 ulwp_broadcast(ulwp
);
2875 force_continue(ulwp
);
2880 lmutex_unlock(&udp
->link_lock
);
2886 * Resume a suspended mutator.
2888 #pragma weak _thr_continue_mutator = thr_continue_mutator
2890 thr_continue_mutator(thread_t tid
)
2892 return (_thrp_continue(tid
, TSTP_MUTATOR
));
2895 #pragma weak _thr_wait_mutator = thr_wait_mutator
2897 thr_wait_mutator(thread_t tid
, int dontwait
)
2899 uberdata_t
*udp
= curthread
->ul_uberdata
;
2904 (void) pthread_setcancelstate(PTHREAD_CANCEL_DISABLE
, &cancel_state
);
2906 if ((ulwp
= find_lwp(tid
)) == NULL
) {
2907 (void) pthread_setcancelstate(cancel_state
, NULL
);
2911 if (!ulwp
->ul_mutator
)
2913 else if (dontwait
) {
2914 if (!(ulwp
->ul_stop
& TSTP_MUTATOR
))
2915 error
= EWOULDBLOCK
;
2916 } else if (!(ulwp
->ul_stop
& TSTP_MUTATOR
)) {
2917 cond_t
*cvp
= ulwp_condvar(ulwp
, udp
);
2918 mutex_t
*mp
= ulwp_mutex(ulwp
, udp
);
2920 (void) cond_wait(cvp
, mp
);
2921 (void) lmutex_unlock(mp
);
2925 ulwp_unlock(ulwp
, udp
);
2926 (void) pthread_setcancelstate(cancel_state
, NULL
);
2930 /* PROBE_SUPPORT begin */
2933 thr_probe_setup(void *data
)
2935 curthread
->ul_tpdp
= data
;
2939 _thread_probe_getfunc()
2941 return (curthread
->ul_tpdp
);
2944 void * (*thr_probe_getfunc_addr
)(void) = _thread_probe_getfunc
;
2948 _resume(ulwp_t
*ulwp
, caddr_t sp
, int dontsave
)
2955 _resume_ret(ulwp_t
*oldlwp
)
2960 /* PROBE_SUPPORT end */