17c478bd9Sstevel@tonic-gate /* 27c478bd9Sstevel@tonic-gate * CDDL HEADER START 37c478bd9Sstevel@tonic-gate * 47c478bd9Sstevel@tonic-gate * The contents of this file are subject to the terms of the 534709573Sraf * Common Development and Distribution License (the "License"). 634709573Sraf * You may not use this file except in compliance with the License. 77c478bd9Sstevel@tonic-gate * 87c478bd9Sstevel@tonic-gate * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 97c478bd9Sstevel@tonic-gate * or http://www.opensolaris.org/os/licensing. 107c478bd9Sstevel@tonic-gate * See the License for the specific language governing permissions 117c478bd9Sstevel@tonic-gate * and limitations under the License. 127c478bd9Sstevel@tonic-gate * 137c478bd9Sstevel@tonic-gate * When distributing Covered Code, include this CDDL HEADER in each 147c478bd9Sstevel@tonic-gate * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 157c478bd9Sstevel@tonic-gate * If applicable, add the following below this CDDL HEADER, with the 167c478bd9Sstevel@tonic-gate * fields enclosed by brackets "[]" replaced with your own identifying 177c478bd9Sstevel@tonic-gate * information: Portions Copyright [yyyy] [name of copyright owner] 187c478bd9Sstevel@tonic-gate * 197c478bd9Sstevel@tonic-gate * CDDL HEADER END 207c478bd9Sstevel@tonic-gate */ 210ec57554Sraf 227c478bd9Sstevel@tonic-gate /* 23ae115bc7Smrj * Copyright 2007 Sun Microsystems, Inc. All rights reserved. 247c478bd9Sstevel@tonic-gate * Use is subject to license terms. 257c478bd9Sstevel@tonic-gate */ 267c478bd9Sstevel@tonic-gate 277c478bd9Sstevel@tonic-gate #ifndef _THR_UBERDATA_H 287c478bd9Sstevel@tonic-gate #define _THR_UBERDATA_H 297c478bd9Sstevel@tonic-gate 307c478bd9Sstevel@tonic-gate #pragma ident "%Z%%M% %I% %E% SMI" 317c478bd9Sstevel@tonic-gate 327c478bd9Sstevel@tonic-gate #include <stdlib.h> 337c478bd9Sstevel@tonic-gate #include <unistd.h> 347c478bd9Sstevel@tonic-gate #include <sys/types.h> 357c478bd9Sstevel@tonic-gate #include <fcntl.h> 367c478bd9Sstevel@tonic-gate #include <string.h> 377c478bd9Sstevel@tonic-gate #include <signal.h> 387c478bd9Sstevel@tonic-gate #include <ucontext.h> 397c478bd9Sstevel@tonic-gate #include <thread.h> 407c478bd9Sstevel@tonic-gate #include <pthread.h> 417c478bd9Sstevel@tonic-gate #include <link.h> 427c478bd9Sstevel@tonic-gate #include <sys/resource.h> 437c478bd9Sstevel@tonic-gate #include <sys/lwp.h> 447c478bd9Sstevel@tonic-gate #include <errno.h> 457c478bd9Sstevel@tonic-gate #include <sys/asm_linkage.h> 467c478bd9Sstevel@tonic-gate #include <sys/regset.h> 477c478bd9Sstevel@tonic-gate #include <sys/fcntl.h> 487c478bd9Sstevel@tonic-gate #include <sys/mman.h> 497c478bd9Sstevel@tonic-gate #include <synch.h> 507c478bd9Sstevel@tonic-gate #include <door.h> 517c478bd9Sstevel@tonic-gate #include <limits.h> 527c478bd9Sstevel@tonic-gate #include <sys/synch32.h> 537c478bd9Sstevel@tonic-gate #include <schedctl.h> 547c478bd9Sstevel@tonic-gate #include <sys/priocntl.h> 557c478bd9Sstevel@tonic-gate #include <thread_db.h> 56f841f6adSraf #include <setjmp.h> 577c478bd9Sstevel@tonic-gate #include "libc_int.h" 587c478bd9Sstevel@tonic-gate #include "tdb_agent.h" 59f841f6adSraf #include "thr_debug.h" 6034709573Sraf 617c478bd9Sstevel@tonic-gate /* 627c478bd9Sstevel@tonic-gate * This is an implementation-specific include file for threading support. 637c478bd9Sstevel@tonic-gate * It is not to be seen by the clients of the library. 647c478bd9Sstevel@tonic-gate * 657c478bd9Sstevel@tonic-gate * This file also describes uberdata in libc. 667c478bd9Sstevel@tonic-gate * 677c478bd9Sstevel@tonic-gate * The term "uberdata" refers to data that is unique and visible across 687c478bd9Sstevel@tonic-gate * all link maps. The name is meant to imply that such data is truly 697c478bd9Sstevel@tonic-gate * global, not just locally global to a particular link map. 707c478bd9Sstevel@tonic-gate * 717c478bd9Sstevel@tonic-gate * See the Linker and Libraries Guide for a full description of alternate 727c478bd9Sstevel@tonic-gate * link maps and how they are set up and used. 737c478bd9Sstevel@tonic-gate * 747c478bd9Sstevel@tonic-gate * Alternate link maps implement multiple global namespaces within a single 757c478bd9Sstevel@tonic-gate * process. There may be multiple instances of identical dynamic libraries 767c478bd9Sstevel@tonic-gate * loaded in a process's address space at the same time, each on a different 777c478bd9Sstevel@tonic-gate * link map (as determined by the dynamic linker), each with its own set of 787c478bd9Sstevel@tonic-gate * global variables. Which particular instance of a global variable is seen 797c478bd9Sstevel@tonic-gate * by a thread running in the process is determined by the link map on which 807c478bd9Sstevel@tonic-gate * the thread happens to be executing at the time. 817c478bd9Sstevel@tonic-gate * 827c478bd9Sstevel@tonic-gate * However, there are aspects of a process that are unique across all 837c478bd9Sstevel@tonic-gate * link maps, in particular the structures used to implement threads 847c478bd9Sstevel@tonic-gate * of control (in Sparc terminology, there is only one %g7 regardless 857c478bd9Sstevel@tonic-gate * of the link map on which the thread is executing). 867c478bd9Sstevel@tonic-gate * 877c478bd9Sstevel@tonic-gate * All uberdata is referenced from a base pointer in the thread's ulwp_t 887c478bd9Sstevel@tonic-gate * structure (which is also uberdata). All allocations and deallocations 897c478bd9Sstevel@tonic-gate * of uberdata are made via the uberdata-aware lmalloc() and lfree() 907c478bd9Sstevel@tonic-gate * interfaces (malloc() and free() are simply locally-global). 917c478bd9Sstevel@tonic-gate */ 927c478bd9Sstevel@tonic-gate 937c478bd9Sstevel@tonic-gate /* 947c478bd9Sstevel@tonic-gate * Special libc-private access to errno. 957c478bd9Sstevel@tonic-gate * We do this so that references to errno do not invoke the dynamic linker. 967c478bd9Sstevel@tonic-gate */ 977c478bd9Sstevel@tonic-gate #undef errno 987c478bd9Sstevel@tonic-gate #define errno (*curthread->ul_errnop) 997c478bd9Sstevel@tonic-gate 1007c478bd9Sstevel@tonic-gate /* 1017c478bd9Sstevel@tonic-gate * See <sys/synch32.h> for the reasons for these values 1027c478bd9Sstevel@tonic-gate * and why they are different for sparc and intel. 1037c478bd9Sstevel@tonic-gate */ 1047c478bd9Sstevel@tonic-gate #if defined(__sparc) 1057c478bd9Sstevel@tonic-gate /* lock.lock64.pad[x] 4 5 6 7 */ 1067c478bd9Sstevel@tonic-gate #define LOCKMASK 0xff000000 1077c478bd9Sstevel@tonic-gate #define WAITERMASK 0x000000ff 1087c478bd9Sstevel@tonic-gate #define WAITER 0x00000001 1097c478bd9Sstevel@tonic-gate #define LOCKSET 0xff 1107c478bd9Sstevel@tonic-gate #define LOCKCLEAR 0 1110ec57554Sraf #elif defined(__x86) 1127c478bd9Sstevel@tonic-gate /* lock.lock64.pad[x] 7 6 5 4 */ 1137c478bd9Sstevel@tonic-gate #define LOCKMASK 0xff000000 1147c478bd9Sstevel@tonic-gate #define WAITERMASK 0x00ff0000 1157c478bd9Sstevel@tonic-gate #define WAITER 0x00010000 1167c478bd9Sstevel@tonic-gate #define LOCKSET 0x01 1177c478bd9Sstevel@tonic-gate #define LOCKCLEAR 0 1187c478bd9Sstevel@tonic-gate #else 1190ec57554Sraf #error "neither __sparc nor __x86 is defined" 1207c478bd9Sstevel@tonic-gate #endif 1217c478bd9Sstevel@tonic-gate 1227c478bd9Sstevel@tonic-gate /* 1237c478bd9Sstevel@tonic-gate * Fetch the owner of a USYNC_THREAD mutex. 1247c478bd9Sstevel@tonic-gate * Don't use this with process-shared mutexes; 1257c478bd9Sstevel@tonic-gate * the owing thread may be in a different process. 1267c478bd9Sstevel@tonic-gate */ 1277c478bd9Sstevel@tonic-gate #define MUTEX_OWNER(mp) ((ulwp_t *)(uintptr_t)(mp)->mutex_owner) 1287c478bd9Sstevel@tonic-gate 1297c478bd9Sstevel@tonic-gate /* 130883492d5Sraf * Test if a thread owns a process-private (USYNC_THREAD) mutex. 131883492d5Sraf * This is inappropriate for a process-shared (USYNC_PROCESS) mutex. 1327c478bd9Sstevel@tonic-gate * The 'mp' argument must not have side-effects since it is evaluated twice. 1337c478bd9Sstevel@tonic-gate */ 1347c478bd9Sstevel@tonic-gate #define MUTEX_OWNED(mp, thrp) \ 1357c478bd9Sstevel@tonic-gate ((mp)->mutex_lockw != 0 && MUTEX_OWNER(mp) == thrp) 1367c478bd9Sstevel@tonic-gate 1377c478bd9Sstevel@tonic-gate 1387c478bd9Sstevel@tonic-gate /* 1397c478bd9Sstevel@tonic-gate * uberflags.uf_tdb_register_sync is an interface with libc_db to enable the 1407c478bd9Sstevel@tonic-gate * collection of lock statistics by a debugger or other collecting tool. 1417c478bd9Sstevel@tonic-gate * 1427c478bd9Sstevel@tonic-gate * uberflags.uf_thread_error_detection is set by an environment variable: 1437c478bd9Sstevel@tonic-gate * _THREAD_ERROR_DETECTION 1447c478bd9Sstevel@tonic-gate * 0 == no detection of locking primitive errors. 1457c478bd9Sstevel@tonic-gate * 1 == detect errors and issue a warning message. 1467c478bd9Sstevel@tonic-gate * 2 == detect errors, issue a warning message, and dump core. 1477c478bd9Sstevel@tonic-gate * 1487c478bd9Sstevel@tonic-gate * We bundle these together in uberflags.uf_trs_ted to make a test of either 1497c478bd9Sstevel@tonic-gate * being non-zero a single memory reference (for speed of mutex_lock(), etc). 1507c478bd9Sstevel@tonic-gate * 1517c478bd9Sstevel@tonic-gate * uberflags.uf_mt is set non-zero when the first thread (in addition 1527c478bd9Sstevel@tonic-gate * to the main thread) is created. 1537c478bd9Sstevel@tonic-gate * 1547c478bd9Sstevel@tonic-gate * We bundle all these flags together in uberflags.uf_all to make a test 1557c478bd9Sstevel@tonic-gate * of any being non-zero a single memory reference (again, for speed). 1567c478bd9Sstevel@tonic-gate */ 1577c478bd9Sstevel@tonic-gate typedef union { 1587c478bd9Sstevel@tonic-gate int uf_all; /* combined all flags */ 1597c478bd9Sstevel@tonic-gate struct { 1607c478bd9Sstevel@tonic-gate short h_pad; 1617c478bd9Sstevel@tonic-gate short h_trs_ted; /* combined reg sync & error detect */ 1627c478bd9Sstevel@tonic-gate } uf_h; 1637c478bd9Sstevel@tonic-gate struct { 1647c478bd9Sstevel@tonic-gate char x_mt; 1657c478bd9Sstevel@tonic-gate char x_pad; 1667c478bd9Sstevel@tonic-gate char x_tdb_register_sync; 1677c478bd9Sstevel@tonic-gate char x_thread_error_detection; 1687c478bd9Sstevel@tonic-gate } uf_x; 1697c478bd9Sstevel@tonic-gate } uberflags_t; 1707c478bd9Sstevel@tonic-gate 1717c478bd9Sstevel@tonic-gate #define uf_mt uf_x.x_mt 1727c478bd9Sstevel@tonic-gate #define uf_tdb_register_sync uf_x.x_tdb_register_sync 1737c478bd9Sstevel@tonic-gate #define uf_thread_error_detection uf_x.x_thread_error_detection 1747c478bd9Sstevel@tonic-gate #define uf_trs_ted uf_h.h_trs_ted /* both of the above */ 1757c478bd9Sstevel@tonic-gate 1767c478bd9Sstevel@tonic-gate /* 1777c478bd9Sstevel@tonic-gate * NOTE WELL: 1787c478bd9Sstevel@tonic-gate * To enable further optimization, the "ul_schedctl_called" member 1797c478bd9Sstevel@tonic-gate * of the ulwp_t structure (below) serves double-duty: 1807c478bd9Sstevel@tonic-gate * 1. If NULL, it means that the thread must call __schedctl() 1817c478bd9Sstevel@tonic-gate * to set up its schedctl mappings before acquiring a mutex. 1827c478bd9Sstevel@tonic-gate * This is required by the implementation of adaptive mutex locking. 1837c478bd9Sstevel@tonic-gate * 2. If non-NULL, it points to uberdata.uberflags, so that tests of 1847c478bd9Sstevel@tonic-gate * uberflags can be made without additional memory references. 1857c478bd9Sstevel@tonic-gate * This allows the common case of _mutex_lock() and _mutex_unlock() for 1867c478bd9Sstevel@tonic-gate * USYNC_THREAD mutexes with no error detection and no lock statistics 1877c478bd9Sstevel@tonic-gate * to be optimized for speed. 1887c478bd9Sstevel@tonic-gate */ 1897c478bd9Sstevel@tonic-gate 1907c478bd9Sstevel@tonic-gate 1917c478bd9Sstevel@tonic-gate /* double the default stack size for 64-bit processes */ 1927c478bd9Sstevel@tonic-gate #ifdef _LP64 1937c478bd9Sstevel@tonic-gate #define MINSTACK (8 * 1024) 1947c478bd9Sstevel@tonic-gate #define DEFAULTSTACK (2 * 1024 * 1024) 1957c478bd9Sstevel@tonic-gate #else 1967c478bd9Sstevel@tonic-gate #define MINSTACK (4 * 1024) 1977c478bd9Sstevel@tonic-gate #define DEFAULTSTACK (1024 * 1024) 1987c478bd9Sstevel@tonic-gate #endif 1997c478bd9Sstevel@tonic-gate #define TSD_NKEYS _POSIX_THREAD_KEYS_MAX 2007c478bd9Sstevel@tonic-gate 2017c478bd9Sstevel@tonic-gate #define THREAD_MIN_PRIORITY 0 2027c478bd9Sstevel@tonic-gate #define THREAD_MAX_PRIORITY 127 2037c478bd9Sstevel@tonic-gate 2047c478bd9Sstevel@tonic-gate #define PRIO_SET 0 /* set priority and policy */ 2057c478bd9Sstevel@tonic-gate #define PRIO_SET_PRIO 1 /* set priority only */ 2067c478bd9Sstevel@tonic-gate #define PRIO_INHERIT 2 2077c478bd9Sstevel@tonic-gate #define PRIO_DISINHERIT 3 2087c478bd9Sstevel@tonic-gate 2097c478bd9Sstevel@tonic-gate #define MUTEX_TRY 0 2107c478bd9Sstevel@tonic-gate #define MUTEX_LOCK 1 2117c478bd9Sstevel@tonic-gate 2120ec57554Sraf #if defined(__x86) 2137c478bd9Sstevel@tonic-gate 2147c478bd9Sstevel@tonic-gate typedef struct { /* structure returned by fnstenv */ 2157c478bd9Sstevel@tonic-gate int fctrl; /* control word */ 2167c478bd9Sstevel@tonic-gate int fstat; /* status word (flags, etc) */ 2177c478bd9Sstevel@tonic-gate int ftag; /* tag of which regs busy */ 2187c478bd9Sstevel@tonic-gate int misc[4]; /* other stuff, 28 bytes total */ 2197c478bd9Sstevel@tonic-gate } fpuenv_t; 2207c478bd9Sstevel@tonic-gate 2217c478bd9Sstevel@tonic-gate #ifdef _SYSCALL32 2227c478bd9Sstevel@tonic-gate typedef fpuenv_t fpuenv32_t; 2237c478bd9Sstevel@tonic-gate #endif /* _SYSCALL32 */ 2247c478bd9Sstevel@tonic-gate 2257c478bd9Sstevel@tonic-gate #elif defined(__sparc) 2267c478bd9Sstevel@tonic-gate 2277c478bd9Sstevel@tonic-gate typedef struct { /* fp state structure */ 2287c478bd9Sstevel@tonic-gate greg_t fsr; 2297c478bd9Sstevel@tonic-gate greg_t fpu_en; 2307c478bd9Sstevel@tonic-gate } fpuenv_t; 2317c478bd9Sstevel@tonic-gate 2327c478bd9Sstevel@tonic-gate #ifdef _SYSCALL32 2337c478bd9Sstevel@tonic-gate typedef struct { 2347c478bd9Sstevel@tonic-gate greg32_t fsr; 2357c478bd9Sstevel@tonic-gate greg32_t fpu_en; 2367c478bd9Sstevel@tonic-gate } fpuenv32_t; 2377c478bd9Sstevel@tonic-gate #endif /* _SYSCALL32 */ 2387c478bd9Sstevel@tonic-gate 2390ec57554Sraf #endif /* __x86 */ 2407c478bd9Sstevel@tonic-gate 2410ec57554Sraf #if defined(__x86) 2427c478bd9Sstevel@tonic-gate extern void ht_pause(void); /* "pause" instruction */ 2437c478bd9Sstevel@tonic-gate #define SMT_PAUSE() ht_pause() 2447c478bd9Sstevel@tonic-gate #else 2457c478bd9Sstevel@tonic-gate #define SMT_PAUSE() 2460ec57554Sraf #endif /* __x86 */ 2477c478bd9Sstevel@tonic-gate 2487c478bd9Sstevel@tonic-gate /* 2497c478bd9Sstevel@tonic-gate * Cleanup handler related data. 2507c478bd9Sstevel@tonic-gate * This structure is exported as _cleanup_t in pthread.h. 2517c478bd9Sstevel@tonic-gate * pthread.h exports only the size of this structure, so check 2527c478bd9Sstevel@tonic-gate * _cleanup_t in pthread.h before making any change here. 2537c478bd9Sstevel@tonic-gate */ 2547c478bd9Sstevel@tonic-gate typedef struct __cleanup { 2557c478bd9Sstevel@tonic-gate struct __cleanup *next; /* pointer to next handler */ 2567c478bd9Sstevel@tonic-gate caddr_t fp; /* current frame pointer */ 2577c478bd9Sstevel@tonic-gate void (*func)(void *); /* cleanup handler address */ 2587c478bd9Sstevel@tonic-gate void *arg; /* handler's argument */ 2597c478bd9Sstevel@tonic-gate } __cleanup_t; 2607c478bd9Sstevel@tonic-gate 2617c478bd9Sstevel@tonic-gate /* 2627c478bd9Sstevel@tonic-gate * Thread-Specific Data (TSD) 2637c478bd9Sstevel@tonic-gate * TSD_NFAST includes the invalid key zero, so there 2647c478bd9Sstevel@tonic-gate * are really only (TSD_NFAST - 1) fast key slots. 2657c478bd9Sstevel@tonic-gate */ 2667c478bd9Sstevel@tonic-gate typedef void (*PFrV)(void *); 2677c478bd9Sstevel@tonic-gate #define TSD_UNALLOCATED ((PFrV)1) 2687c478bd9Sstevel@tonic-gate #define TSD_NFAST 9 2697c478bd9Sstevel@tonic-gate 2707c478bd9Sstevel@tonic-gate /* 2717c478bd9Sstevel@tonic-gate * The tsd union is designed to burn a little memory (9 words) to make 2727c478bd9Sstevel@tonic-gate * lookups blindingly fast. Note that tsd_nalloc could be placed at the 2737c478bd9Sstevel@tonic-gate * end of the pad region to increase the likelihood that it falls on the 2747c478bd9Sstevel@tonic-gate * same cache line as the data. 2757c478bd9Sstevel@tonic-gate */ 2767c478bd9Sstevel@tonic-gate typedef union tsd { 2777c478bd9Sstevel@tonic-gate uint_t tsd_nalloc; /* Amount of allocated storage */ 2787c478bd9Sstevel@tonic-gate void *tsd_pad[TSD_NFAST]; 2797c478bd9Sstevel@tonic-gate void *tsd_data[1]; 2807c478bd9Sstevel@tonic-gate } tsd_t; 2817c478bd9Sstevel@tonic-gate 2827c478bd9Sstevel@tonic-gate typedef struct { 2837c478bd9Sstevel@tonic-gate mutex_t tsdm_lock; /* Lock protecting the data */ 2847c478bd9Sstevel@tonic-gate uint_t tsdm_nkeys; /* Number of allocated keys */ 2857c478bd9Sstevel@tonic-gate uint_t tsdm_nused; /* Number of used keys */ 2867c478bd9Sstevel@tonic-gate PFrV *tsdm_destro; /* Per-key destructors */ 2877c478bd9Sstevel@tonic-gate char tsdm_pad[64 - /* pad to 64 bytes */ 2887c478bd9Sstevel@tonic-gate (sizeof (mutex_t) + 2 * sizeof (uint_t) + sizeof (PFrV *))]; 2897c478bd9Sstevel@tonic-gate } tsd_metadata_t; 2907c478bd9Sstevel@tonic-gate 2917c478bd9Sstevel@tonic-gate #ifdef _SYSCALL32 2927c478bd9Sstevel@tonic-gate typedef union tsd32 { 2937c478bd9Sstevel@tonic-gate uint_t tsd_nalloc; /* Amount of allocated storage */ 2947c478bd9Sstevel@tonic-gate caddr32_t tsd_pad[TSD_NFAST]; 2957c478bd9Sstevel@tonic-gate caddr32_t tsd_data[1]; 2967c478bd9Sstevel@tonic-gate } tsd32_t; 2977c478bd9Sstevel@tonic-gate 2987c478bd9Sstevel@tonic-gate typedef struct { 2997c478bd9Sstevel@tonic-gate mutex_t tsdm_lock; /* Lock protecting the data */ 3007c478bd9Sstevel@tonic-gate uint_t tsdm_nkeys; /* Number of allocated keys */ 3017c478bd9Sstevel@tonic-gate uint_t tsdm_nused; /* Number of used keys */ 3027c478bd9Sstevel@tonic-gate caddr32_t tsdm_destro; /* Per-key destructors */ 3037c478bd9Sstevel@tonic-gate char tsdm_pad[64 - /* pad to 64 bytes */ 3047c478bd9Sstevel@tonic-gate (sizeof (mutex_t) + 2 * sizeof (uint_t) + sizeof (caddr32_t))]; 3057c478bd9Sstevel@tonic-gate } tsd_metadata32_t; 3067c478bd9Sstevel@tonic-gate #endif /* _SYSCALL32 */ 3077c478bd9Sstevel@tonic-gate 3087c478bd9Sstevel@tonic-gate 3097c478bd9Sstevel@tonic-gate /* 3107c478bd9Sstevel@tonic-gate * Thread-Local Storage (TLS) 3117c478bd9Sstevel@tonic-gate */ 3127c478bd9Sstevel@tonic-gate typedef struct { 3137c478bd9Sstevel@tonic-gate void *tls_data; 3147c478bd9Sstevel@tonic-gate size_t tls_size; 3157c478bd9Sstevel@tonic-gate } tls_t; 3167c478bd9Sstevel@tonic-gate 3177c478bd9Sstevel@tonic-gate typedef struct { 3187c478bd9Sstevel@tonic-gate mutex_t tls_lock; /* Lock protecting the data */ 3197c478bd9Sstevel@tonic-gate tls_t tls_modinfo; /* Root of all TLS_modinfo data */ 3207c478bd9Sstevel@tonic-gate tls_t static_tls; /* Template for static TLS */ 3217c478bd9Sstevel@tonic-gate char tls_pad[64 - /* pad to 64 bytes */ 3227c478bd9Sstevel@tonic-gate (sizeof (mutex_t) + 2 * sizeof (tls_t))]; 3237c478bd9Sstevel@tonic-gate } tls_metadata_t; 3247c478bd9Sstevel@tonic-gate 3257c478bd9Sstevel@tonic-gate #ifdef _SYSCALL32 3267c478bd9Sstevel@tonic-gate typedef struct { 3277c478bd9Sstevel@tonic-gate caddr32_t tls_data; 3287c478bd9Sstevel@tonic-gate size32_t tls_size; 3297c478bd9Sstevel@tonic-gate } tls32_t; 3307c478bd9Sstevel@tonic-gate 3317c478bd9Sstevel@tonic-gate typedef struct { 3327c478bd9Sstevel@tonic-gate mutex_t tls_lock; /* Lock protecting the data */ 3337c478bd9Sstevel@tonic-gate tls32_t tls_modinfo; /* Root of all TLS_modinfo data */ 3347c478bd9Sstevel@tonic-gate tls32_t static_tls; /* Template for static TLS */ 3357c478bd9Sstevel@tonic-gate char tls_pad[64 - /* pad to 64 bytes */ 3367c478bd9Sstevel@tonic-gate (sizeof (mutex_t) + 2 * sizeof (tls32_t))]; 3377c478bd9Sstevel@tonic-gate } tls_metadata32_t; 3387c478bd9Sstevel@tonic-gate #endif /* _SYSCALL32 */ 3397c478bd9Sstevel@tonic-gate 3407c478bd9Sstevel@tonic-gate 3417c478bd9Sstevel@tonic-gate /* 3427c478bd9Sstevel@tonic-gate * Sleep queues for USYNC_THREAD condvars and mutexes. 3437c478bd9Sstevel@tonic-gate * The size and alignment is 64 bytes to reduce cache conflicts. 3447c478bd9Sstevel@tonic-gate */ 3457c478bd9Sstevel@tonic-gate typedef union { 3467c478bd9Sstevel@tonic-gate uint64_t qh_64[8]; 3477c478bd9Sstevel@tonic-gate struct { 3487c478bd9Sstevel@tonic-gate mutex_t q_lock; 3497c478bd9Sstevel@tonic-gate uint8_t q_qcnt; 3507c478bd9Sstevel@tonic-gate uint8_t q_pad[7]; 3517c478bd9Sstevel@tonic-gate uint64_t q_lockcount; 3527c478bd9Sstevel@tonic-gate uint32_t q_qlen; 3537c478bd9Sstevel@tonic-gate uint32_t q_qmax; 3547c478bd9Sstevel@tonic-gate struct ulwp *q_head; 3557c478bd9Sstevel@tonic-gate struct ulwp *q_tail; 3567c478bd9Sstevel@tonic-gate } qh_qh; 3577c478bd9Sstevel@tonic-gate } queue_head_t; 3587c478bd9Sstevel@tonic-gate 3597c478bd9Sstevel@tonic-gate #define qh_lock qh_qh.q_lock 3607c478bd9Sstevel@tonic-gate #define qh_qcnt qh_qh.q_qcnt 3617c478bd9Sstevel@tonic-gate #define qh_lockcount qh_qh.q_lockcount 3627c478bd9Sstevel@tonic-gate #define qh_qlen qh_qh.q_qlen 3637c478bd9Sstevel@tonic-gate #define qh_qmax qh_qh.q_qmax 3647c478bd9Sstevel@tonic-gate #define qh_head qh_qh.q_head 3657c478bd9Sstevel@tonic-gate #define qh_tail qh_qh.q_tail 3667c478bd9Sstevel@tonic-gate 3677c478bd9Sstevel@tonic-gate /* queue types passed to queue_lock() and enqueue() */ 3687c478bd9Sstevel@tonic-gate #define MX 0 3697c478bd9Sstevel@tonic-gate #define CV 1 3707c478bd9Sstevel@tonic-gate #define FIFOQ 0x10 /* or'ing with FIFOQ asks for FIFO queueing */ 371883492d5Sraf #define QHASHSHIFT 9 /* number of hashing bits */ 372883492d5Sraf #define QHASHSIZE (1 << QHASHSHIFT) /* power of 2 (1<<9 == 512) */ 373883492d5Sraf #define QUEUE_HASH(wchan, type) ((uint_t) \ 374883492d5Sraf ((((uintptr_t)(wchan) >> 3) \ 375883492d5Sraf ^ ((uintptr_t)(wchan) >> (QHASHSHIFT + 3))) \ 3767c478bd9Sstevel@tonic-gate & (QHASHSIZE - 1)) + (((type) == MX)? 0 : QHASHSIZE)) 3777c478bd9Sstevel@tonic-gate 3787c478bd9Sstevel@tonic-gate extern queue_head_t *queue_lock(void *, int); 3797c478bd9Sstevel@tonic-gate extern void queue_unlock(queue_head_t *); 3807c478bd9Sstevel@tonic-gate extern void enqueue(queue_head_t *, struct ulwp *, void *, int); 3817c478bd9Sstevel@tonic-gate extern struct ulwp *dequeue(queue_head_t *, void *, int *); 3827c478bd9Sstevel@tonic-gate extern struct ulwp *queue_waiter(queue_head_t *, void *); 38341efec22Sraf extern struct ulwp *queue_unlink(queue_head_t *, 38441efec22Sraf struct ulwp **, struct ulwp *); 3857c478bd9Sstevel@tonic-gate extern uint8_t dequeue_self(queue_head_t *, void *); 3867c478bd9Sstevel@tonic-gate extern void unsleep_self(void); 3877c478bd9Sstevel@tonic-gate extern void spin_lock_set(mutex_t *); 3887c478bd9Sstevel@tonic-gate extern void spin_lock_clear(mutex_t *); 3897c478bd9Sstevel@tonic-gate 3907c478bd9Sstevel@tonic-gate /* 3917c478bd9Sstevel@tonic-gate * Memory block for chain of owned ceiling mutexes. 3927c478bd9Sstevel@tonic-gate */ 3937c478bd9Sstevel@tonic-gate typedef struct mxchain { 3947c478bd9Sstevel@tonic-gate struct mxchain *mxchain_next; 3957c478bd9Sstevel@tonic-gate mutex_t *mxchain_mx; 3967c478bd9Sstevel@tonic-gate } mxchain_t; 3977c478bd9Sstevel@tonic-gate 3987c478bd9Sstevel@tonic-gate /* 3997c478bd9Sstevel@tonic-gate * Pointer to an rwlock that is held for reading. 4007c478bd9Sstevel@tonic-gate * Used in rw_rdlock() to allow a thread that already holds a read 4017c478bd9Sstevel@tonic-gate * lock to acquire another read lock on the same rwlock even if 4027c478bd9Sstevel@tonic-gate * there are writers waiting. This to avoid deadlock when acquiring 4037c478bd9Sstevel@tonic-gate * a read lock more than once in the presence of pending writers. 4047c478bd9Sstevel@tonic-gate * POSIX mandates this behavior. 4057c478bd9Sstevel@tonic-gate */ 4067c478bd9Sstevel@tonic-gate typedef struct { 4077c478bd9Sstevel@tonic-gate void *rd_rwlock; /* the rwlock held for reading */ 4087c478bd9Sstevel@tonic-gate size_t rd_count; /* count of read locks applied */ 4097c478bd9Sstevel@tonic-gate } readlock_t; 4107c478bd9Sstevel@tonic-gate 4117c478bd9Sstevel@tonic-gate #ifdef _SYSCALL32 4127c478bd9Sstevel@tonic-gate typedef struct { 4137c478bd9Sstevel@tonic-gate caddr32_t rd_rwlock; 4147c478bd9Sstevel@tonic-gate size32_t rd_count; 4157c478bd9Sstevel@tonic-gate } readlock32_t; 4167c478bd9Sstevel@tonic-gate #endif /* _SYSCALL32 */ 4177c478bd9Sstevel@tonic-gate 4187c478bd9Sstevel@tonic-gate /* 4197c478bd9Sstevel@tonic-gate * Maximum number of read locks allowed for one thread on one rwlock. 4207c478bd9Sstevel@tonic-gate * This could be as large as INT_MAX, but the SUSV3 test suite would 4217c478bd9Sstevel@tonic-gate * take an inordinately long time to complete. This is big enough. 4227c478bd9Sstevel@tonic-gate */ 4237c478bd9Sstevel@tonic-gate #define READ_LOCK_MAX 100000 4247c478bd9Sstevel@tonic-gate 4257c478bd9Sstevel@tonic-gate #define ul_tlsent ul_tls.tls_data /* array of pointers to dynamic TLS */ 4267c478bd9Sstevel@tonic-gate #define ul_ntlsent ul_tls.tls_size /* number of entries in ul_tlsent */ 4277c478bd9Sstevel@tonic-gate 4287c478bd9Sstevel@tonic-gate /* 4297c478bd9Sstevel@tonic-gate * Round up an integral value to a multiple of 64 4307c478bd9Sstevel@tonic-gate */ 4317c478bd9Sstevel@tonic-gate #define roundup64(x) (-(-(x) & -64)) 4327c478bd9Sstevel@tonic-gate 4337c478bd9Sstevel@tonic-gate /* 4347c478bd9Sstevel@tonic-gate * NOTE: Whatever changes are made to ulwp_t must be 4357c478bd9Sstevel@tonic-gate * reflected in $SRC/cmd/mdb/common/modules/libc/libc.c 4367c478bd9Sstevel@tonic-gate * 4377c478bd9Sstevel@tonic-gate * NOTE: ul_self *must* be the first member of ulwp_t on x86 4387c478bd9Sstevel@tonic-gate * Low-level x86 code relies on this. 4397c478bd9Sstevel@tonic-gate */ 4407c478bd9Sstevel@tonic-gate typedef struct ulwp { 4417c478bd9Sstevel@tonic-gate /* 4427c478bd9Sstevel@tonic-gate * These members always need to come first on sparc. 4437c478bd9Sstevel@tonic-gate * For dtrace, a ulwp_t must be aligned on a 64-byte boundary. 4447c478bd9Sstevel@tonic-gate */ 4457c478bd9Sstevel@tonic-gate #if defined(__sparc) 4467c478bd9Sstevel@tonic-gate uint32_t ul_dinstr; /* scratch space for dtrace */ 4477c478bd9Sstevel@tonic-gate uint32_t ul_padsparc0[15]; 4487c478bd9Sstevel@tonic-gate uint32_t ul_dsave; /* dtrace: save %g1, %g0, %sp */ 4497c478bd9Sstevel@tonic-gate uint32_t ul_drestore; /* dtrace: restore %g0, %g0, %g0 */ 4507c478bd9Sstevel@tonic-gate uint32_t ul_dftret; /* dtrace: return probe fasttrap */ 4517c478bd9Sstevel@tonic-gate uint32_t ul_dreturn; /* dtrace: return %o0 */ 4527c478bd9Sstevel@tonic-gate #endif 4537c478bd9Sstevel@tonic-gate struct ulwp *ul_self; /* pointer to self */ 4547c478bd9Sstevel@tonic-gate #if defined(__i386) 4557c478bd9Sstevel@tonic-gate uint8_t ul_dinstr[40]; /* scratch space for dtrace */ 4567c478bd9Sstevel@tonic-gate #elif defined(__amd64) 4577c478bd9Sstevel@tonic-gate uint8_t ul_dinstr[56]; /* scratch space for dtrace */ 4587c478bd9Sstevel@tonic-gate #endif 4597c478bd9Sstevel@tonic-gate struct uberdata *ul_uberdata; /* uber (super-global) data */ 4607c478bd9Sstevel@tonic-gate tls_t ul_tls; /* dynamic thread-local storage base */ 4617c478bd9Sstevel@tonic-gate struct ulwp *ul_forw; /* forw, back all_lwps list, */ 4627c478bd9Sstevel@tonic-gate struct ulwp *ul_back; /* protected by link_lock */ 4637c478bd9Sstevel@tonic-gate struct ulwp *ul_next; /* list to keep track of stacks */ 4647c478bd9Sstevel@tonic-gate struct ulwp *ul_hash; /* hash chain linked list */ 4657c478bd9Sstevel@tonic-gate void *ul_rval; /* return value from thr_exit() */ 4667c478bd9Sstevel@tonic-gate caddr_t ul_stk; /* mapping base of the stack */ 4677c478bd9Sstevel@tonic-gate size_t ul_mapsiz; /* mapping size of the stack */ 4687c478bd9Sstevel@tonic-gate size_t ul_guardsize; /* normally _lpagesize */ 4697c478bd9Sstevel@tonic-gate uintptr_t ul_stktop; /* broken thr_stksegment() interface */ 4707c478bd9Sstevel@tonic-gate size_t ul_stksiz; /* broken thr_stksegment() interface */ 4717c478bd9Sstevel@tonic-gate stack_t ul_ustack; /* current stack boundaries */ 4727c478bd9Sstevel@tonic-gate int ul_ix; /* hash index */ 4737c478bd9Sstevel@tonic-gate lwpid_t ul_lwpid; /* thread id, aka the lwp id */ 4747c478bd9Sstevel@tonic-gate pri_t ul_pri; /* priority known to the library */ 4757c478bd9Sstevel@tonic-gate pri_t ul_mappedpri; /* priority known to the application */ 4767c478bd9Sstevel@tonic-gate char ul_policy; /* scheduling policy */ 4777c478bd9Sstevel@tonic-gate char ul_pri_mapped; /* != 0 means ul_mappedpri is valid */ 4787c478bd9Sstevel@tonic-gate union { 4797c478bd9Sstevel@tonic-gate struct { 4807c478bd9Sstevel@tonic-gate char cursig; /* deferred signal number */ 4817c478bd9Sstevel@tonic-gate char pleasestop; /* lwp requested to stop itself */ 4827c478bd9Sstevel@tonic-gate } s; 4837c478bd9Sstevel@tonic-gate short curplease; /* for testing both at once */ 4847c478bd9Sstevel@tonic-gate } ul_cp; 4857c478bd9Sstevel@tonic-gate char ul_stop; /* reason for stopping */ 4867c478bd9Sstevel@tonic-gate char ul_signalled; /* this lwp was cond_signal()d */ 4877c478bd9Sstevel@tonic-gate char ul_dead; /* this lwp has called thr_exit */ 4887c478bd9Sstevel@tonic-gate char ul_unwind; /* posix: unwind C++ stack */ 4897c478bd9Sstevel@tonic-gate char ul_detached; /* THR_DETACHED at thread_create() */ 4907c478bd9Sstevel@tonic-gate /* or pthread_detach() was called */ 4917c478bd9Sstevel@tonic-gate char ul_writer; /* sleeping in rw_wrlock() */ 4927c478bd9Sstevel@tonic-gate char ul_stopping; /* set by curthread: stopping self */ 49334709573Sraf char ul_cancel_prologue; /* for _cancel_prologue() */ 4947c478bd9Sstevel@tonic-gate short ul_preempt; /* no_preempt()/preempt() */ 4957c478bd9Sstevel@tonic-gate short ul_savpreempt; /* pre-existing preempt value */ 4967c478bd9Sstevel@tonic-gate char ul_sigsuspend; /* thread is in sigsuspend/pollsys */ 4977c478bd9Sstevel@tonic-gate char ul_main; /* thread is the main thread */ 4987c478bd9Sstevel@tonic-gate char ul_fork; /* thread is performing a fork */ 4997c478bd9Sstevel@tonic-gate char ul_primarymap; /* primary link-map is initialized */ 5007c478bd9Sstevel@tonic-gate /* per-thread copies of the corresponding global variables */ 5017c478bd9Sstevel@tonic-gate uchar_t ul_max_spinners; /* thread_max_spinners */ 5027c478bd9Sstevel@tonic-gate char ul_door_noreserve; /* thread_door_noreserve */ 5037c478bd9Sstevel@tonic-gate char ul_queue_fifo; /* thread_queue_fifo */ 5047c478bd9Sstevel@tonic-gate char ul_cond_wait_defer; /* thread_cond_wait_defer */ 5057c478bd9Sstevel@tonic-gate char ul_error_detection; /* thread_error_detection */ 5067c478bd9Sstevel@tonic-gate char ul_async_safe; /* thread_async_safe */ 5077c478bd9Sstevel@tonic-gate char ul_pad1[2]; 5087c478bd9Sstevel@tonic-gate int ul_adaptive_spin; /* thread_adaptive_spin */ 5097c478bd9Sstevel@tonic-gate int ul_release_spin; /* thread_release_spin */ 5107c478bd9Sstevel@tonic-gate int ul_queue_spin; /* thread_queue_spin */ 5117c478bd9Sstevel@tonic-gate volatile int ul_critical; /* non-zero == in a critical region */ 5127c478bd9Sstevel@tonic-gate int ul_sigdefer; /* non-zero == defer signals */ 5137c478bd9Sstevel@tonic-gate int ul_vfork; /* thread is the child of vfork() */ 5147c478bd9Sstevel@tonic-gate int ul_cancelable; /* _cancelon()/_canceloff() */ 5157c478bd9Sstevel@tonic-gate char ul_cancel_pending; /* pthread_cancel() was called */ 5167c478bd9Sstevel@tonic-gate char ul_cancel_disabled; /* PTHREAD_CANCEL_DISABLE */ 5177c478bd9Sstevel@tonic-gate char ul_cancel_async; /* PTHREAD_CANCEL_ASYNCHRONOUS */ 5187c478bd9Sstevel@tonic-gate char ul_save_async; /* saved copy of ul_cancel_async */ 5197c478bd9Sstevel@tonic-gate char ul_mutator; /* lwp is a mutator (java interface) */ 5207c478bd9Sstevel@tonic-gate char ul_created; /* created suspended */ 5217c478bd9Sstevel@tonic-gate char ul_replace; /* replacement; must be free()d */ 5227c478bd9Sstevel@tonic-gate uchar_t ul_nocancel; /* cancellation can't happen */ 5237c478bd9Sstevel@tonic-gate int ul_errno; /* per-thread errno */ 5247c478bd9Sstevel@tonic-gate int *ul_errnop; /* pointer to errno or self->ul_errno */ 5257c478bd9Sstevel@tonic-gate __cleanup_t *ul_clnup_hdr; /* head of cleanup handlers list */ 5267c478bd9Sstevel@tonic-gate uberflags_t *volatile ul_schedctl_called; /* ul_schedctl is set up */ 5277c478bd9Sstevel@tonic-gate volatile sc_shared_t *volatile ul_schedctl; /* schedctl data */ 5287c478bd9Sstevel@tonic-gate int ul_bindflags; /* bind_guard() interface to ld.so.1 */ 529ae115bc7Smrj int ul_pad2; 5307c478bd9Sstevel@tonic-gate tsd_t *ul_stsd; /* slow TLS for keys >= TSD_NFAST */ 5317c478bd9Sstevel@tonic-gate void *ul_ftsd[TSD_NFAST]; /* fast TLS for keys < TSD_NFAST */ 5327c478bd9Sstevel@tonic-gate td_evbuf_t ul_td_evbuf; /* event buffer */ 5337c478bd9Sstevel@tonic-gate char ul_td_events_enable; /* event mechanism enabled */ 5347c478bd9Sstevel@tonic-gate char ul_sync_obj_reg; /* tdb_sync_obj_register() */ 5357c478bd9Sstevel@tonic-gate char ul_qtype; /* MX or CV */ 5367c478bd9Sstevel@tonic-gate char ul_cv_wake; /* != 0: just wake up, don't requeue */ 5377c478bd9Sstevel@tonic-gate int ul_usropts; /* flags given to thr_create() */ 5387c478bd9Sstevel@tonic-gate void *(*ul_startpc)(void *); /* start func (thr_create()) */ 5397c478bd9Sstevel@tonic-gate void *ul_startarg; /* argument for start function */ 5407c478bd9Sstevel@tonic-gate void *ul_wchan; /* synch object when sleeping */ 5417c478bd9Sstevel@tonic-gate struct ulwp *ul_link; /* sleep queue link */ 5427c478bd9Sstevel@tonic-gate queue_head_t *ul_sleepq; /* sleep queue thread is waiting on */ 5437c478bd9Sstevel@tonic-gate mutex_t *ul_cvmutex; /* mutex dropped when waiting on a cv */ 5447c478bd9Sstevel@tonic-gate mxchain_t *ul_mxchain; /* chain of owned ceiling mutexes */ 5457c478bd9Sstevel@tonic-gate pri_t ul_epri; /* effective scheduling priority */ 5467c478bd9Sstevel@tonic-gate pri_t ul_emappedpri; /* effective mapped priority */ 547883492d5Sraf uint_t ul_rdlockcnt; /* # entries in ul_readlock array */ 548883492d5Sraf /* 0 means there is but a single entry */ 549883492d5Sraf union { /* single entry or pointer to array */ 5507c478bd9Sstevel@tonic-gate readlock_t single; 5517c478bd9Sstevel@tonic-gate readlock_t *array; 5527c478bd9Sstevel@tonic-gate } ul_readlock; 553883492d5Sraf uint_t ul_heldlockcnt; /* # entries in ul_heldlocks array */ 554883492d5Sraf /* 0 means there is but a single entry */ 555883492d5Sraf union { /* single entry or pointer to array */ 556883492d5Sraf mutex_t *single; 557883492d5Sraf mutex_t **array; 558883492d5Sraf } ul_heldlocks; 5597c478bd9Sstevel@tonic-gate /* PROBE_SUPPORT begin */ 5607c478bd9Sstevel@tonic-gate void *ul_tpdp; 5617c478bd9Sstevel@tonic-gate /* PROBE_SUPPORT end */ 5627c478bd9Sstevel@tonic-gate ucontext_t *ul_siglink; /* pointer to previous context */ 5637c478bd9Sstevel@tonic-gate uint_t ul_spin_lock_spin; /* spin lock statistics */ 5647c478bd9Sstevel@tonic-gate uint_t ul_spin_lock_spin2; 5657c478bd9Sstevel@tonic-gate uint_t ul_spin_lock_sleep; 5667c478bd9Sstevel@tonic-gate uint_t ul_spin_lock_wakeup; 5677c478bd9Sstevel@tonic-gate /* the following members *must* be last in the structure */ 5687c478bd9Sstevel@tonic-gate /* they are discarded when ulwp is replaced on thr_exit() */ 5697c478bd9Sstevel@tonic-gate sigset_t ul_sigmask; /* thread's current signal mask */ 5707c478bd9Sstevel@tonic-gate sigset_t ul_tmpmask; /* signal mask for sigsuspend/pollsys */ 5717c478bd9Sstevel@tonic-gate siginfo_t ul_siginfo; /* deferred siginfo */ 5727c478bd9Sstevel@tonic-gate mutex_t ul_spinlock; /* used when suspending/continuing */ 5737c478bd9Sstevel@tonic-gate fpuenv_t ul_fpuenv; /* floating point state */ 5747c478bd9Sstevel@tonic-gate uintptr_t ul_sp; /* stack pointer when blocked */ 5757c478bd9Sstevel@tonic-gate void *ul_ex_unwind; /* address of _ex_unwind() or -1 */ 5767c478bd9Sstevel@tonic-gate #if defined(sparc) 5777c478bd9Sstevel@tonic-gate void *ul_unwind_ret; /* used only by _ex_clnup_handler() */ 5787c478bd9Sstevel@tonic-gate #endif 5797c478bd9Sstevel@tonic-gate } ulwp_t; 5807c478bd9Sstevel@tonic-gate 5817c478bd9Sstevel@tonic-gate #define ul_cursig ul_cp.s.cursig /* deferred signal number */ 5827c478bd9Sstevel@tonic-gate #define ul_pleasestop ul_cp.s.pleasestop /* lwp requested to stop */ 5837c478bd9Sstevel@tonic-gate #define ul_curplease ul_cp.curplease /* for testing both at once */ 5847c478bd9Sstevel@tonic-gate 5857c478bd9Sstevel@tonic-gate /* 5867c478bd9Sstevel@tonic-gate * This is the size of a replacement ulwp, retained only for the benefit 5877c478bd9Sstevel@tonic-gate * of thr_join(). The trailing members are unneeded for this purpose. 5887c478bd9Sstevel@tonic-gate */ 5897c478bd9Sstevel@tonic-gate #define REPLACEMENT_SIZE ((size_t)&((ulwp_t *)NULL)->ul_sigmask) 5907c478bd9Sstevel@tonic-gate 5917c478bd9Sstevel@tonic-gate /* 5927c478bd9Sstevel@tonic-gate * Definitions for static initialization of signal sets, 5937c478bd9Sstevel@tonic-gate * plus some sneaky optimizations in various places. 5947c478bd9Sstevel@tonic-gate */ 5957c478bd9Sstevel@tonic-gate 5967c478bd9Sstevel@tonic-gate #define SIGMASK(sig) ((uint32_t)1 << (((sig) - 1) & (32 - 1))) 5977c478bd9Sstevel@tonic-gate 5987c478bd9Sstevel@tonic-gate #if (MAXSIG > 32 && MAXSIG <= 64) 5997c478bd9Sstevel@tonic-gate #define FILLSET0 0xffffffffu 6007c478bd9Sstevel@tonic-gate #define FILLSET1 ((1u << (MAXSIG - 32)) - 1) 6017c478bd9Sstevel@tonic-gate #else 6027c478bd9Sstevel@tonic-gate #error "fix me: MAXSIG out of bounds" 6037c478bd9Sstevel@tonic-gate #endif 6047c478bd9Sstevel@tonic-gate 6057c478bd9Sstevel@tonic-gate #define CANTMASK0 (SIGMASK(SIGKILL) | SIGMASK(SIGSTOP)) 6067c478bd9Sstevel@tonic-gate #define CANTMASK1 0 6077c478bd9Sstevel@tonic-gate 6087c478bd9Sstevel@tonic-gate #define MASKSET0 (FILLSET0 & ~CANTMASK0) 6097c478bd9Sstevel@tonic-gate #define MASKSET1 (FILLSET1 & ~CANTMASK1) 6107c478bd9Sstevel@tonic-gate 611f841f6adSraf extern const sigset_t maskset; /* set of all maskable signals */ 6127c478bd9Sstevel@tonic-gate 6137c478bd9Sstevel@tonic-gate extern int thread_adaptive_spin; 6147c478bd9Sstevel@tonic-gate extern uint_t thread_max_spinners; 6157c478bd9Sstevel@tonic-gate extern int thread_release_spin; 6167c478bd9Sstevel@tonic-gate extern int thread_queue_spin; 6177c478bd9Sstevel@tonic-gate extern int thread_queue_fifo; 6187c478bd9Sstevel@tonic-gate extern int thread_queue_dump; 6197c478bd9Sstevel@tonic-gate extern int thread_cond_wait_defer; 6207c478bd9Sstevel@tonic-gate extern int thread_async_safe; 6217c478bd9Sstevel@tonic-gate extern int thread_queue_verify; 6227c478bd9Sstevel@tonic-gate 6237c478bd9Sstevel@tonic-gate /* 6247c478bd9Sstevel@tonic-gate * pthread_atfork() related data, used to store atfork handlers. 6257c478bd9Sstevel@tonic-gate */ 6267c478bd9Sstevel@tonic-gate typedef struct atfork { 6277c478bd9Sstevel@tonic-gate struct atfork *forw; /* forward pointer */ 6287c478bd9Sstevel@tonic-gate struct atfork *back; /* backward pointer */ 6297c478bd9Sstevel@tonic-gate void (*prepare)(void); /* pre-fork handler */ 6307c478bd9Sstevel@tonic-gate void (*parent)(void); /* post-fork parent handler */ 6317c478bd9Sstevel@tonic-gate void (*child)(void); /* post-fork child handler */ 6327c478bd9Sstevel@tonic-gate } atfork_t; 6337c478bd9Sstevel@tonic-gate 634883492d5Sraf /* 635883492d5Sraf * Element in the table of registered process robust locks. 636883492d5Sraf * We keep track of these to make sure that we only call 637883492d5Sraf * ___lwp_mutex_register() once for each such lock. 638883492d5Sraf */ 639883492d5Sraf typedef struct robust { 640883492d5Sraf struct robust *robust_next; 641883492d5Sraf mutex_t *robust_lock; 642883492d5Sraf } robust_t; 643883492d5Sraf 644883492d5Sraf /* 645883492d5Sraf * Parameters of the lock registration hash table. 646883492d5Sraf */ 647883492d5Sraf #define LOCKSHIFT 9 /* number of hashing bits */ 648883492d5Sraf #define LOCKHASHSZ (1 << LOCKSHIFT) /* power of 2 (1<<9 == 512) */ 649883492d5Sraf #define LOCK_HASH(addr) (uint_t) \ 650883492d5Sraf ((((uintptr_t)(addr) >> 3) \ 651883492d5Sraf ^ ((uintptr_t)(addr) >> (LOCKSHIFT + 3))) \ 652883492d5Sraf & (LOCKHASHSZ - 1)) 653883492d5Sraf 6547c478bd9Sstevel@tonic-gate /* 6557c478bd9Sstevel@tonic-gate * Make our hot locks reside on private cache lines (64 bytes). 6567c478bd9Sstevel@tonic-gate */ 6577c478bd9Sstevel@tonic-gate typedef struct { 6587c478bd9Sstevel@tonic-gate mutex_t pad_lock; 6592e145884Sraf char pad_pad[64 - sizeof (mutex_t)]; 6607c478bd9Sstevel@tonic-gate } pad_lock_t; 6617c478bd9Sstevel@tonic-gate 6622e145884Sraf /* 6632e145884Sraf * Make our semi-hot locks reside on semi-private cache lines (32 bytes). 6642e145884Sraf */ 6652e145884Sraf typedef struct { 6662e145884Sraf mutex_t pad_lock; 6672e145884Sraf char pad_pad[32 - sizeof (mutex_t)]; 6682e145884Sraf } pad32_lock_t; 6692e145884Sraf 6707c478bd9Sstevel@tonic-gate /* 6717c478bd9Sstevel@tonic-gate * The threads hash table is used for fast lookup and locking of an active 6727c478bd9Sstevel@tonic-gate * thread structure (ulwp_t) given a thread-id. It is an N-element array of 6737c478bd9Sstevel@tonic-gate * thr_hash_table_t structures, where N == 1 before the main thread creates 6747c478bd9Sstevel@tonic-gate * the first additional thread and N == 1024 afterwards. Each element of the 6757c478bd9Sstevel@tonic-gate * table is 64 bytes in size and alignment to reduce cache conflicts. 6767c478bd9Sstevel@tonic-gate */ 6777c478bd9Sstevel@tonic-gate typedef struct { 6787c478bd9Sstevel@tonic-gate mutex_t hash_lock; /* lock per bucket */ 6797c478bd9Sstevel@tonic-gate cond_t hash_cond; /* convar per bucket */ 6807c478bd9Sstevel@tonic-gate ulwp_t *hash_bucket; /* hash bucket points to the list of ulwps */ 6817c478bd9Sstevel@tonic-gate char hash_pad[64 - /* pad out to 64 bytes */ 6827c478bd9Sstevel@tonic-gate (sizeof (mutex_t) + sizeof (cond_t) + sizeof (ulwp_t *))]; 6837c478bd9Sstevel@tonic-gate } thr_hash_table_t; 6847c478bd9Sstevel@tonic-gate 6857c478bd9Sstevel@tonic-gate #ifdef _SYSCALL32 6867c478bd9Sstevel@tonic-gate typedef struct { 6877c478bd9Sstevel@tonic-gate mutex_t hash_lock; 6887c478bd9Sstevel@tonic-gate cond_t hash_cond; 6897c478bd9Sstevel@tonic-gate caddr32_t hash_bucket; 6907c478bd9Sstevel@tonic-gate char hash_pad[64 - 6917c478bd9Sstevel@tonic-gate (sizeof (mutex_t) + sizeof (cond_t) + sizeof (caddr32_t))]; 6927c478bd9Sstevel@tonic-gate } thr_hash_table32_t; 6937c478bd9Sstevel@tonic-gate #endif /* _SYSCALL32 */ 6947c478bd9Sstevel@tonic-gate 6957c478bd9Sstevel@tonic-gate 6967c478bd9Sstevel@tonic-gate /* 69741efec22Sraf * siguaction members have 128-byte size and 64-byte alignment. 69841efec22Sraf * We know that sizeof (struct sigaction) is 32 bytes for both 69941efec22Sraf * _ILP32 and _LP64 and that sizeof (rwlock_t) is 64 bytes. 7007c478bd9Sstevel@tonic-gate */ 7017c478bd9Sstevel@tonic-gate typedef struct { 70241efec22Sraf rwlock_t sig_lock; 7037c478bd9Sstevel@tonic-gate struct sigaction sig_uaction; 70441efec22Sraf char sig_pad[128 - sizeof (rwlock_t) - sizeof (struct sigaction)]; 7057c478bd9Sstevel@tonic-gate } siguaction_t; 7067c478bd9Sstevel@tonic-gate 7077c478bd9Sstevel@tonic-gate #ifdef _SYSCALL32 7087c478bd9Sstevel@tonic-gate typedef struct { 70941efec22Sraf rwlock_t sig_lock; 7107c478bd9Sstevel@tonic-gate struct sigaction32 sig_uaction; 71141efec22Sraf char sig_pad[128 - sizeof (rwlock_t) - sizeof (struct sigaction32)]; 7127c478bd9Sstevel@tonic-gate } siguaction32_t; 7137c478bd9Sstevel@tonic-gate #endif /* _SYSCALL32 */ 7147c478bd9Sstevel@tonic-gate 7157c478bd9Sstevel@tonic-gate 7167c478bd9Sstevel@tonic-gate /* 7177c478bd9Sstevel@tonic-gate * Bucket structures, used by lmalloc()/lfree(). 7187c478bd9Sstevel@tonic-gate * See port/threads/alloc.c for details. 7197c478bd9Sstevel@tonic-gate * A bucket's size and alignment is 64 bytes. 7207c478bd9Sstevel@tonic-gate */ 7217c478bd9Sstevel@tonic-gate typedef struct { 7227c478bd9Sstevel@tonic-gate mutex_t bucket_lock; /* protects the free list allocations */ 7237c478bd9Sstevel@tonic-gate void *free_list; /* LIFO list of blocks to allocate/free */ 7247c478bd9Sstevel@tonic-gate size_t chunks; /* number of 64K blocks mmap()ed last time */ 7257c478bd9Sstevel@tonic-gate char pad64[64 - /* pad out to 64 bytes */ 7267c478bd9Sstevel@tonic-gate (sizeof (mutex_t) + sizeof (void *) + sizeof (size_t))]; 7277c478bd9Sstevel@tonic-gate } bucket_t; 7287c478bd9Sstevel@tonic-gate 7297c478bd9Sstevel@tonic-gate #ifdef _SYSCALL32 7307c478bd9Sstevel@tonic-gate typedef struct { 7317c478bd9Sstevel@tonic-gate mutex_t bucket_lock; 7327c478bd9Sstevel@tonic-gate caddr32_t free_list; 7337c478bd9Sstevel@tonic-gate size32_t chunks; 7347c478bd9Sstevel@tonic-gate char pad64[64 - /* pad out to 64 bytes */ 7357c478bd9Sstevel@tonic-gate (sizeof (mutex_t) + sizeof (caddr32_t) + sizeof (size32_t))]; 7367c478bd9Sstevel@tonic-gate } bucket32_t; 7377c478bd9Sstevel@tonic-gate #endif /* _SYSCALL32 */ 7387c478bd9Sstevel@tonic-gate 7397c478bd9Sstevel@tonic-gate #define NBUCKETS 10 /* sizes ranging from 64 to 32768 */ 7407c478bd9Sstevel@tonic-gate 7417c478bd9Sstevel@tonic-gate 7427c478bd9Sstevel@tonic-gate /* 7437c478bd9Sstevel@tonic-gate * atexit() data structures. 7447c478bd9Sstevel@tonic-gate * See port/gen/atexit.c for details. 7457c478bd9Sstevel@tonic-gate */ 7467c478bd9Sstevel@tonic-gate typedef void (*_exithdlr_func_t) (void); 7477c478bd9Sstevel@tonic-gate 7487c478bd9Sstevel@tonic-gate typedef struct _exthdlr { 7497c478bd9Sstevel@tonic-gate struct _exthdlr *next; /* next in handler list */ 7507c478bd9Sstevel@tonic-gate _exithdlr_func_t hdlr; /* handler itself */ 7517c478bd9Sstevel@tonic-gate } _exthdlr_t; 7527c478bd9Sstevel@tonic-gate 7537c478bd9Sstevel@tonic-gate typedef struct { 7547c478bd9Sstevel@tonic-gate mutex_t exitfns_lock; 7557c478bd9Sstevel@tonic-gate _exthdlr_t *head; 7567c478bd9Sstevel@tonic-gate void *exit_frame_monitor; 7577c478bd9Sstevel@tonic-gate char exit_pad[64 - /* pad out to 64 bytes */ 7587c478bd9Sstevel@tonic-gate (sizeof (mutex_t) + sizeof (_exthdlr_t *) + sizeof (void *))]; 7597c478bd9Sstevel@tonic-gate } atexit_root_t; 7607c478bd9Sstevel@tonic-gate 7617c478bd9Sstevel@tonic-gate #ifdef _SYSCALL32 7627c478bd9Sstevel@tonic-gate typedef struct { 7637c478bd9Sstevel@tonic-gate mutex_t exitfns_lock; 7647c478bd9Sstevel@tonic-gate caddr32_t head; 7657c478bd9Sstevel@tonic-gate caddr32_t exit_frame_monitor; 7667c478bd9Sstevel@tonic-gate char exit_pad[64 - /* pad out to 64 bytes */ 7677c478bd9Sstevel@tonic-gate (sizeof (mutex_t) + sizeof (caddr32_t) + sizeof (caddr32_t))]; 7687c478bd9Sstevel@tonic-gate } atexit_root32_t; 7697c478bd9Sstevel@tonic-gate #endif /* _SYSCALL32 */ 7707c478bd9Sstevel@tonic-gate 7717c478bd9Sstevel@tonic-gate 7727c478bd9Sstevel@tonic-gate /* 7737c478bd9Sstevel@tonic-gate * This is data that is global to all link maps (uberdata, aka super-global). 7747c478bd9Sstevel@tonic-gate */ 7757c478bd9Sstevel@tonic-gate typedef struct uberdata { 7767c478bd9Sstevel@tonic-gate pad_lock_t _link_lock; 7772e145884Sraf pad32_lock_t _fork_lock; 7782e145884Sraf pad32_lock_t _atfork_lock; 779*98c1a6b4Sraf pad32_lock_t _callout_lock; 780*98c1a6b4Sraf pad32_lock_t _tdb_hash_lock; 7817c478bd9Sstevel@tonic-gate tdb_sync_stats_t tdb_hash_lock_stats; 7827c478bd9Sstevel@tonic-gate siguaction_t siguaction[NSIG]; 7837c478bd9Sstevel@tonic-gate bucket_t bucket[NBUCKETS]; 7847c478bd9Sstevel@tonic-gate atexit_root_t atexit_root; 7857c478bd9Sstevel@tonic-gate tsd_metadata_t tsd_metadata; 7867c478bd9Sstevel@tonic-gate tls_metadata_t tls_metadata; 7877c478bd9Sstevel@tonic-gate /* 7887c478bd9Sstevel@tonic-gate * Every object before this point has size and alignment of 64 bytes. 7897c478bd9Sstevel@tonic-gate * Don't add any other type of data before this point. 7907c478bd9Sstevel@tonic-gate */ 7917c478bd9Sstevel@tonic-gate char primary_map; /* set when primary link map is initialized */ 7927c478bd9Sstevel@tonic-gate char bucket_init; /* set when bucket[NBUCKETS] is initialized */ 7937c478bd9Sstevel@tonic-gate char pad[2]; 7947c478bd9Sstevel@tonic-gate uberflags_t uberflags; 7957c478bd9Sstevel@tonic-gate queue_head_t *queue_head; 7967c478bd9Sstevel@tonic-gate thr_hash_table_t *thr_hash_table; 7977c478bd9Sstevel@tonic-gate uint_t hash_size; /* # of entries in thr_hash_table[] */ 7987c478bd9Sstevel@tonic-gate uint_t hash_mask; /* hash_size - 1 */ 7997c478bd9Sstevel@tonic-gate ulwp_t *ulwp_one; /* main thread */ 8007c478bd9Sstevel@tonic-gate ulwp_t *all_lwps; /* circular ul_forw/ul_back list of live lwps */ 8017c478bd9Sstevel@tonic-gate ulwp_t *all_zombies; /* circular ul_forw/ul_back list of zombies */ 8027c478bd9Sstevel@tonic-gate int nthreads; /* total number of live threads/lwps */ 8037c478bd9Sstevel@tonic-gate int nzombies; /* total number of zombie threads */ 8047c478bd9Sstevel@tonic-gate int ndaemons; /* total number of THR_DAEMON threads/lwps */ 8057c478bd9Sstevel@tonic-gate pid_t pid; /* the current process's pid */ 8067c478bd9Sstevel@tonic-gate void (*sigacthandler)(int, siginfo_t *, void *); 8077c478bd9Sstevel@tonic-gate ulwp_t *lwp_stacks; 8087c478bd9Sstevel@tonic-gate ulwp_t *lwp_laststack; 8097c478bd9Sstevel@tonic-gate int nfreestack; 8107c478bd9Sstevel@tonic-gate int thread_stack_cache; 8117c478bd9Sstevel@tonic-gate ulwp_t *ulwp_freelist; 8127c478bd9Sstevel@tonic-gate ulwp_t *ulwp_lastfree; 8137c478bd9Sstevel@tonic-gate ulwp_t *ulwp_replace_free; 8147c478bd9Sstevel@tonic-gate ulwp_t *ulwp_replace_last; 8157c478bd9Sstevel@tonic-gate atfork_t *atforklist; /* circular Q for fork handlers */ 816883492d5Sraf robust_t **robustlocks; /* table of registered robust locks */ 8177c478bd9Sstevel@tonic-gate struct uberdata **tdb_bootstrap; 8187c478bd9Sstevel@tonic-gate tdb_t tdb; /* thread debug interfaces (for libc_db) */ 8197c478bd9Sstevel@tonic-gate } uberdata_t; 8207c478bd9Sstevel@tonic-gate 8217c478bd9Sstevel@tonic-gate #define link_lock _link_lock.pad_lock 8227c478bd9Sstevel@tonic-gate #define fork_lock _fork_lock.pad_lock 8232e145884Sraf #define atfork_lock _atfork_lock.pad_lock 824*98c1a6b4Sraf #define callout_lock _callout_lock.pad_lock 8257c478bd9Sstevel@tonic-gate #define tdb_hash_lock _tdb_hash_lock.pad_lock 8267c478bd9Sstevel@tonic-gate 8277c478bd9Sstevel@tonic-gate #pragma align 64(__uberdata) 8287c478bd9Sstevel@tonic-gate extern uberdata_t __uberdata; 8297c478bd9Sstevel@tonic-gate extern uberdata_t **__tdb_bootstrap; /* known to libc_db and mdb */ 8307c478bd9Sstevel@tonic-gate extern int primary_link_map; 8317c478bd9Sstevel@tonic-gate 8327c478bd9Sstevel@tonic-gate #define ulwp_mutex(ulwp, udp) \ 8337c478bd9Sstevel@tonic-gate (&(udp)->thr_hash_table[(ulwp)->ul_ix].hash_lock) 8347c478bd9Sstevel@tonic-gate #define ulwp_condvar(ulwp, udp) \ 8357c478bd9Sstevel@tonic-gate (&(udp)->thr_hash_table[(ulwp)->ul_ix].hash_cond) 8367c478bd9Sstevel@tonic-gate 8377c478bd9Sstevel@tonic-gate /* 8387c478bd9Sstevel@tonic-gate * Grab and release the hash table lock for the specified lwp. 8397c478bd9Sstevel@tonic-gate */ 8407c478bd9Sstevel@tonic-gate #define ulwp_lock(ulwp, udp) lmutex_lock(ulwp_mutex(ulwp, udp)) 8417c478bd9Sstevel@tonic-gate #define ulwp_unlock(ulwp, udp) lmutex_unlock(ulwp_mutex(ulwp, udp)) 8427c478bd9Sstevel@tonic-gate 8437c478bd9Sstevel@tonic-gate #ifdef _SYSCALL32 /* needed by libc_db */ 8447c478bd9Sstevel@tonic-gate 8457c478bd9Sstevel@tonic-gate typedef struct ulwp32 { 8467c478bd9Sstevel@tonic-gate #if defined(__sparc) 8477c478bd9Sstevel@tonic-gate uint32_t ul_dinstr; /* scratch space for dtrace */ 8487c478bd9Sstevel@tonic-gate uint32_t ul_padsparc0[15]; 8497c478bd9Sstevel@tonic-gate uint32_t ul_dsave; /* dtrace: save %g1, %g0, %sp */ 8507c478bd9Sstevel@tonic-gate uint32_t ul_drestore; /* dtrace: restore %g0, %g0, %g0 */ 8517c478bd9Sstevel@tonic-gate uint32_t ul_dftret; /* dtrace: return probe fasttrap */ 8527c478bd9Sstevel@tonic-gate uint32_t ul_dreturn; /* dtrace: return %o0 */ 8537c478bd9Sstevel@tonic-gate #endif 8547c478bd9Sstevel@tonic-gate caddr32_t ul_self; /* pointer to self */ 8550ec57554Sraf #if defined(__x86) 8567c478bd9Sstevel@tonic-gate uint8_t ul_dinstr[40]; /* scratch space for dtrace */ 8577c478bd9Sstevel@tonic-gate #endif 8587c478bd9Sstevel@tonic-gate caddr32_t ul_uberdata; /* uber (super-global) data */ 8597c478bd9Sstevel@tonic-gate tls32_t ul_tls; /* dynamic thread-local storage base */ 8607c478bd9Sstevel@tonic-gate caddr32_t ul_forw; /* forw, back all_lwps list, */ 8617c478bd9Sstevel@tonic-gate caddr32_t ul_back; /* protected by link_lock */ 8627c478bd9Sstevel@tonic-gate caddr32_t ul_next; /* list to keep track of stacks */ 8637c478bd9Sstevel@tonic-gate caddr32_t ul_hash; /* hash chain linked list */ 8647c478bd9Sstevel@tonic-gate caddr32_t ul_rval; /* return value from thr_exit() */ 8657c478bd9Sstevel@tonic-gate caddr32_t ul_stk; /* mapping base of the stack */ 8667c478bd9Sstevel@tonic-gate size32_t ul_mapsiz; /* mapping size of the stack */ 8677c478bd9Sstevel@tonic-gate size32_t ul_guardsize; /* normally _lpagesize */ 8687c478bd9Sstevel@tonic-gate caddr32_t ul_stktop; /* broken thr_stksegment() interface */ 8697c478bd9Sstevel@tonic-gate size32_t ul_stksiz; /* broken thr_stksegment() interface */ 8707c478bd9Sstevel@tonic-gate stack32_t ul_ustack; /* current stack boundaries */ 8717c478bd9Sstevel@tonic-gate int ul_ix; /* hash index */ 8727c478bd9Sstevel@tonic-gate lwpid_t ul_lwpid; /* thread id, aka the lwp id */ 8737c478bd9Sstevel@tonic-gate pri_t ul_pri; /* priority known to the library */ 8747c478bd9Sstevel@tonic-gate pri_t ul_mappedpri; /* priority known to the application */ 8757c478bd9Sstevel@tonic-gate char ul_policy; /* scheduling policy */ 8767c478bd9Sstevel@tonic-gate char ul_pri_mapped; /* != 0 means ul_mappedpri is valid */ 8777c478bd9Sstevel@tonic-gate union { 8787c478bd9Sstevel@tonic-gate struct { 8797c478bd9Sstevel@tonic-gate char cursig; /* deferred signal number */ 8807c478bd9Sstevel@tonic-gate char pleasestop; /* lwp requested to stop itself */ 8817c478bd9Sstevel@tonic-gate } s; 8827c478bd9Sstevel@tonic-gate short curplease; /* for testing both at once */ 8837c478bd9Sstevel@tonic-gate } ul_cp; 8847c478bd9Sstevel@tonic-gate char ul_stop; /* reason for stopping */ 8857c478bd9Sstevel@tonic-gate char ul_signalled; /* this lwp was cond_signal()d */ 8867c478bd9Sstevel@tonic-gate char ul_dead; /* this lwp has called thr_exit */ 8877c478bd9Sstevel@tonic-gate char ul_unwind; /* posix: unwind C++ stack */ 8887c478bd9Sstevel@tonic-gate char ul_detached; /* THR_DETACHED at thread_create() */ 8897c478bd9Sstevel@tonic-gate /* or pthread_detach() was called */ 8907c478bd9Sstevel@tonic-gate char ul_writer; /* sleeping in rw_wrlock() */ 8917c478bd9Sstevel@tonic-gate char ul_stopping; /* set by curthread: stopping self */ 89234709573Sraf char ul_cancel_prologue; /* for _cancel_prologue() */ 8937c478bd9Sstevel@tonic-gate short ul_preempt; /* no_preempt()/preempt() */ 8947c478bd9Sstevel@tonic-gate short ul_savpreempt; /* pre-existing preempt value */ 8957c478bd9Sstevel@tonic-gate char ul_sigsuspend; /* thread is in sigsuspend/pollsys */ 8967c478bd9Sstevel@tonic-gate char ul_main; /* thread is the main thread */ 8977c478bd9Sstevel@tonic-gate char ul_fork; /* thread is performing a fork */ 8987c478bd9Sstevel@tonic-gate char ul_primarymap; /* primary link-map is initialized */ 8997c478bd9Sstevel@tonic-gate /* per-thread copies of the corresponding global variables */ 9007c478bd9Sstevel@tonic-gate uchar_t ul_max_spinners; /* thread_max_spinners */ 9017c478bd9Sstevel@tonic-gate char ul_door_noreserve; /* thread_door_noreserve */ 9027c478bd9Sstevel@tonic-gate char ul_queue_fifo; /* thread_queue_fifo */ 9037c478bd9Sstevel@tonic-gate char ul_cond_wait_defer; /* thread_cond_wait_defer */ 9047c478bd9Sstevel@tonic-gate char ul_error_detection; /* thread_error_detection */ 9057c478bd9Sstevel@tonic-gate char ul_async_safe; /* thread_async_safe */ 9067c478bd9Sstevel@tonic-gate char ul_pad1[2]; 9077c478bd9Sstevel@tonic-gate int ul_adaptive_spin; /* thread_adaptive_spin */ 9087c478bd9Sstevel@tonic-gate int ul_release_spin; /* thread_release_spin */ 9097c478bd9Sstevel@tonic-gate int ul_queue_spin; /* thread_queue_spin */ 9107c478bd9Sstevel@tonic-gate int ul_critical; /* non-zero == in a critical region */ 9117c478bd9Sstevel@tonic-gate int ul_sigdefer; /* non-zero == defer signals */ 9127c478bd9Sstevel@tonic-gate int ul_vfork; /* thread is the child of vfork() */ 9137c478bd9Sstevel@tonic-gate int ul_cancelable; /* _cancelon()/_canceloff() */ 9147c478bd9Sstevel@tonic-gate char ul_cancel_pending; /* pthread_cancel() was called */ 9157c478bd9Sstevel@tonic-gate char ul_cancel_disabled; /* PTHREAD_CANCEL_DISABLE */ 9167c478bd9Sstevel@tonic-gate char ul_cancel_async; /* PTHREAD_CANCEL_ASYNCHRONOUS */ 9177c478bd9Sstevel@tonic-gate char ul_save_async; /* saved copy of ul_cancel_async */ 9187c478bd9Sstevel@tonic-gate char ul_mutator; /* lwp is a mutator (java interface) */ 9197c478bd9Sstevel@tonic-gate char ul_created; /* created suspended */ 9207c478bd9Sstevel@tonic-gate char ul_replace; /* replacement; must be free()d */ 9217c478bd9Sstevel@tonic-gate uchar_t ul_nocancel; /* cancellation can't happen */ 9227c478bd9Sstevel@tonic-gate int ul_errno; /* per-thread errno */ 9237c478bd9Sstevel@tonic-gate caddr32_t ul_errnop; /* pointer to errno or self->ul_errno */ 9247c478bd9Sstevel@tonic-gate caddr32_t ul_clnup_hdr; /* head of cleanup handlers list */ 9257c478bd9Sstevel@tonic-gate caddr32_t ul_schedctl_called; /* ul_schedctl is set up */ 9267c478bd9Sstevel@tonic-gate caddr32_t ul_schedctl; /* schedctl data */ 9277c478bd9Sstevel@tonic-gate int ul_bindflags; /* bind_guard() interface to ld.so.1 */ 928ae115bc7Smrj int ul_pad2; 9297c478bd9Sstevel@tonic-gate caddr32_t ul_stsd; /* slow TLS for keys >= TSD_NFAST */ 9307c478bd9Sstevel@tonic-gate caddr32_t ul_ftsd[TSD_NFAST]; /* fast TLS for keys < TSD_NFAST */ 9317c478bd9Sstevel@tonic-gate td_evbuf32_t ul_td_evbuf; /* event buffer */ 9327c478bd9Sstevel@tonic-gate char ul_td_events_enable; /* event mechanism enabled */ 9337c478bd9Sstevel@tonic-gate char ul_sync_obj_reg; /* tdb_sync_obj_register() */ 9347c478bd9Sstevel@tonic-gate char ul_qtype; /* MX or CV */ 9357c478bd9Sstevel@tonic-gate char ul_cv_wake; /* != 0: just wake up, don't requeue */ 9367c478bd9Sstevel@tonic-gate int ul_usropts; /* flags given to thr_create() */ 9377c478bd9Sstevel@tonic-gate caddr32_t ul_startpc; /* start func (thr_create()) */ 9387c478bd9Sstevel@tonic-gate caddr32_t ul_startarg; /* argument for start function */ 9397c478bd9Sstevel@tonic-gate caddr32_t ul_wchan; /* synch object when sleeping */ 9407c478bd9Sstevel@tonic-gate caddr32_t ul_link; /* sleep queue link */ 9417c478bd9Sstevel@tonic-gate caddr32_t ul_sleepq; /* sleep queue thread is waiting on */ 9427c478bd9Sstevel@tonic-gate caddr32_t ul_cvmutex; /* mutex dropped when waiting on a cv */ 9437c478bd9Sstevel@tonic-gate caddr32_t ul_mxchain; /* chain of owned ceiling mutexes */ 9447c478bd9Sstevel@tonic-gate pri_t ul_epri; /* effective scheduling priority */ 9457c478bd9Sstevel@tonic-gate pri_t ul_emappedpri; /* effective mapped priority */ 946883492d5Sraf uint_t ul_rdlockcnt; /* # entries in ul_readlock array */ 947883492d5Sraf /* 0 means there is but a single entry */ 948883492d5Sraf union { /* single entry or pointer to array */ 9497c478bd9Sstevel@tonic-gate readlock32_t single; 9507c478bd9Sstevel@tonic-gate caddr32_t array; 9517c478bd9Sstevel@tonic-gate } ul_readlock; 952883492d5Sraf uint_t ul_heldlockcnt; /* # entries in ul_heldlocks array */ 953883492d5Sraf /* 0 means there is but a single entry */ 954883492d5Sraf union { /* single entry or pointer to array */ 955883492d5Sraf caddr32_t single; 956883492d5Sraf caddr32_t array; 957883492d5Sraf } ul_heldlocks; 9587c478bd9Sstevel@tonic-gate /* PROBE_SUPPORT begin */ 9597c478bd9Sstevel@tonic-gate caddr32_t ul_tpdp; 9607c478bd9Sstevel@tonic-gate /* PROBE_SUPPORT end */ 9617c478bd9Sstevel@tonic-gate caddr32_t ul_siglink; /* pointer to previous context */ 9627c478bd9Sstevel@tonic-gate uint_t ul_spin_lock_spin; /* spin lock statistics */ 9637c478bd9Sstevel@tonic-gate uint_t ul_spin_lock_spin2; 9647c478bd9Sstevel@tonic-gate uint_t ul_spin_lock_sleep; 9657c478bd9Sstevel@tonic-gate uint_t ul_spin_lock_wakeup; 9667c478bd9Sstevel@tonic-gate /* the following members *must* be last in the structure */ 9677c478bd9Sstevel@tonic-gate /* they are discarded when ulwp is replaced on thr_exit() */ 9687c478bd9Sstevel@tonic-gate sigset32_t ul_sigmask; /* thread's current signal mask */ 9697c478bd9Sstevel@tonic-gate sigset32_t ul_tmpmask; /* signal mask for sigsuspend/pollsys */ 9707c478bd9Sstevel@tonic-gate siginfo32_t ul_siginfo; /* deferred siginfo */ 9717c478bd9Sstevel@tonic-gate mutex_t ul_spinlock; /* used when suspending/continuing */ 9727c478bd9Sstevel@tonic-gate fpuenv32_t ul_fpuenv; /* floating point state */ 9737c478bd9Sstevel@tonic-gate caddr32_t ul_sp; /* stack pointer when blocked */ 9747c478bd9Sstevel@tonic-gate #if defined(sparc) 9757c478bd9Sstevel@tonic-gate caddr32_t ul_unwind_ret; /* used only by _ex_clnup_handler() */ 9767c478bd9Sstevel@tonic-gate #endif 9777c478bd9Sstevel@tonic-gate } ulwp32_t; 9787c478bd9Sstevel@tonic-gate 9797c478bd9Sstevel@tonic-gate #define REPLACEMENT_SIZE32 ((size_t)&((ulwp32_t *)NULL)->ul_sigmask) 9807c478bd9Sstevel@tonic-gate 9817c478bd9Sstevel@tonic-gate typedef struct uberdata32 { 9827c478bd9Sstevel@tonic-gate pad_lock_t _link_lock; 9832e145884Sraf pad32_lock_t _fork_lock; 9842e145884Sraf pad32_lock_t _atfork_lock; 985*98c1a6b4Sraf pad32_lock_t _callout_lock; 986*98c1a6b4Sraf pad32_lock_t _tdb_hash_lock; 9877c478bd9Sstevel@tonic-gate tdb_sync_stats_t tdb_hash_lock_stats; 9887c478bd9Sstevel@tonic-gate siguaction32_t siguaction[NSIG]; 9897c478bd9Sstevel@tonic-gate bucket32_t bucket[NBUCKETS]; 9907c478bd9Sstevel@tonic-gate atexit_root32_t atexit_root; 9917c478bd9Sstevel@tonic-gate tsd_metadata32_t tsd_metadata; 9927c478bd9Sstevel@tonic-gate tls_metadata32_t tls_metadata; 9937c478bd9Sstevel@tonic-gate char primary_map; 9947c478bd9Sstevel@tonic-gate char bucket_init; 9957c478bd9Sstevel@tonic-gate char pad[2]; 9967c478bd9Sstevel@tonic-gate uberflags_t uberflags; 9977c478bd9Sstevel@tonic-gate caddr32_t queue_head; 9987c478bd9Sstevel@tonic-gate caddr32_t thr_hash_table; 9997c478bd9Sstevel@tonic-gate uint_t hash_size; 10007c478bd9Sstevel@tonic-gate uint_t hash_mask; 10017c478bd9Sstevel@tonic-gate caddr32_t ulwp_one; 10027c478bd9Sstevel@tonic-gate caddr32_t all_lwps; 10037c478bd9Sstevel@tonic-gate caddr32_t all_zombies; 10047c478bd9Sstevel@tonic-gate int nthreads; 10057c478bd9Sstevel@tonic-gate int nzombies; 10067c478bd9Sstevel@tonic-gate int ndaemons; 10077c478bd9Sstevel@tonic-gate int pid; 10087c478bd9Sstevel@tonic-gate caddr32_t sigacthandler; 10097c478bd9Sstevel@tonic-gate caddr32_t lwp_stacks; 10107c478bd9Sstevel@tonic-gate caddr32_t lwp_laststack; 10117c478bd9Sstevel@tonic-gate int nfreestack; 10127c478bd9Sstevel@tonic-gate int thread_stack_cache; 10137c478bd9Sstevel@tonic-gate caddr32_t ulwp_freelist; 10147c478bd9Sstevel@tonic-gate caddr32_t ulwp_lastfree; 10157c478bd9Sstevel@tonic-gate caddr32_t ulwp_replace_free; 10167c478bd9Sstevel@tonic-gate caddr32_t ulwp_replace_last; 10177c478bd9Sstevel@tonic-gate caddr32_t atforklist; 1018883492d5Sraf caddr32_t robustlocks; 10197c478bd9Sstevel@tonic-gate caddr32_t tdb_bootstrap; 10207c478bd9Sstevel@tonic-gate tdb32_t tdb; 10217c478bd9Sstevel@tonic-gate } uberdata32_t; 10227c478bd9Sstevel@tonic-gate 10237c478bd9Sstevel@tonic-gate #endif /* _SYSCALL32 */ 10247c478bd9Sstevel@tonic-gate 10257c478bd9Sstevel@tonic-gate /* ul_stop values */ 10267c478bd9Sstevel@tonic-gate #define TSTP_REGULAR 0x01 /* Stopped by thr_suspend() */ 10277c478bd9Sstevel@tonic-gate #define TSTP_MUTATOR 0x08 /* stopped by thr_suspend_*mutator*() */ 10287c478bd9Sstevel@tonic-gate #define TSTP_FORK 0x20 /* stopped by suspend_fork() */ 10297c478bd9Sstevel@tonic-gate 10307c478bd9Sstevel@tonic-gate /* 10317c478bd9Sstevel@tonic-gate * Implementation-specific attribute types for pthread_mutexattr_init() etc. 10327c478bd9Sstevel@tonic-gate */ 10337c478bd9Sstevel@tonic-gate 10347c478bd9Sstevel@tonic-gate typedef struct _cvattr { 10357c478bd9Sstevel@tonic-gate int pshared; 10367c478bd9Sstevel@tonic-gate clockid_t clockid; 10377c478bd9Sstevel@tonic-gate } cvattr_t; 10387c478bd9Sstevel@tonic-gate 10397c478bd9Sstevel@tonic-gate typedef struct _mattr { 10407c478bd9Sstevel@tonic-gate int pshared; 10417c478bd9Sstevel@tonic-gate int protocol; 10427c478bd9Sstevel@tonic-gate int prioceiling; 10437c478bd9Sstevel@tonic-gate int type; 10447c478bd9Sstevel@tonic-gate int robustness; 10457c478bd9Sstevel@tonic-gate } mattr_t; 10467c478bd9Sstevel@tonic-gate 10477c478bd9Sstevel@tonic-gate typedef struct _thrattr { 10487c478bd9Sstevel@tonic-gate size_t stksize; 10497c478bd9Sstevel@tonic-gate void *stkaddr; 10507c478bd9Sstevel@tonic-gate int detachstate; 105134709573Sraf int daemonstate; 10527c478bd9Sstevel@tonic-gate int scope; 10537c478bd9Sstevel@tonic-gate int prio; 10547c478bd9Sstevel@tonic-gate int policy; 10557c478bd9Sstevel@tonic-gate int inherit; 10567c478bd9Sstevel@tonic-gate size_t guardsize; 10577c478bd9Sstevel@tonic-gate } thrattr_t; 10587c478bd9Sstevel@tonic-gate 10597c478bd9Sstevel@tonic-gate typedef struct _rwlattr { 10607c478bd9Sstevel@tonic-gate int pshared; 10617c478bd9Sstevel@tonic-gate } rwlattr_t; 10627c478bd9Sstevel@tonic-gate 10637c478bd9Sstevel@tonic-gate /* _curthread() is inline for speed */ 10647c478bd9Sstevel@tonic-gate extern ulwp_t *_curthread(void); 10657c478bd9Sstevel@tonic-gate #define curthread (_curthread()) 10667c478bd9Sstevel@tonic-gate 10677c478bd9Sstevel@tonic-gate /* this version (also inline) can be tested for NULL */ 10687c478bd9Sstevel@tonic-gate extern ulwp_t *__curthread(void); 10697c478bd9Sstevel@tonic-gate 10707c478bd9Sstevel@tonic-gate /* get the current stack pointer (also inline) */ 10717c478bd9Sstevel@tonic-gate extern greg_t stkptr(void); 10727c478bd9Sstevel@tonic-gate 10737c478bd9Sstevel@tonic-gate /* 10747c478bd9Sstevel@tonic-gate * Suppress __attribute__((...)) if we are not compiling with gcc 10757c478bd9Sstevel@tonic-gate */ 10767c478bd9Sstevel@tonic-gate #if !defined(__GNUC__) 10777c478bd9Sstevel@tonic-gate #define __attribute__(string) 10787c478bd9Sstevel@tonic-gate #endif 10797c478bd9Sstevel@tonic-gate 10807c478bd9Sstevel@tonic-gate /* 10817c478bd9Sstevel@tonic-gate * Implementation functions. Not visible outside of the library itself. 10827c478bd9Sstevel@tonic-gate */ 1083f841f6adSraf extern int __nanosleep(const timespec_t *, timespec_t *); 10847c478bd9Sstevel@tonic-gate extern void getgregs(ulwp_t *, gregset_t); 10857c478bd9Sstevel@tonic-gate extern void setgregs(ulwp_t *, gregset_t); 10867c478bd9Sstevel@tonic-gate extern void thr_panic(const char *); 10877c478bd9Sstevel@tonic-gate #pragma rarely_called(thr_panic) 10887c478bd9Sstevel@tonic-gate extern ulwp_t *find_lwp(thread_t); 10897c478bd9Sstevel@tonic-gate extern int real_priority(ulwp_t *); 10907c478bd9Sstevel@tonic-gate extern void finish_init(void); 10917c478bd9Sstevel@tonic-gate extern void queue_alloc(void); 10927c478bd9Sstevel@tonic-gate extern void tsd_exit(void); 10937c478bd9Sstevel@tonic-gate extern void tsd_free(ulwp_t *); 10947c478bd9Sstevel@tonic-gate extern void tls_setup(void); 10957c478bd9Sstevel@tonic-gate extern void tls_exit(void); 10967c478bd9Sstevel@tonic-gate extern void tls_free(ulwp_t *); 10977c478bd9Sstevel@tonic-gate extern void rwl_free(ulwp_t *); 1098883492d5Sraf extern void heldlock_exit(void); 1099883492d5Sraf extern void heldlock_free(ulwp_t *); 11007c478bd9Sstevel@tonic-gate extern void sigacthandler(int, siginfo_t *, void *); 11017c478bd9Sstevel@tonic-gate extern void signal_init(void); 11027c478bd9Sstevel@tonic-gate extern int sigequalset(const sigset_t *, const sigset_t *); 11037c478bd9Sstevel@tonic-gate extern void mutex_setup(void); 11047c478bd9Sstevel@tonic-gate extern void take_deferred_signal(int); 11057c478bd9Sstevel@tonic-gate extern int setup_context(ucontext_t *, void *(*func)(ulwp_t *), 11067c478bd9Sstevel@tonic-gate ulwp_t *ulwp, caddr_t stk, size_t stksize); 11077c478bd9Sstevel@tonic-gate extern volatile sc_shared_t *setup_schedctl(void); 11087c478bd9Sstevel@tonic-gate extern void *lmalloc(size_t); 11097c478bd9Sstevel@tonic-gate extern void lfree(void *, size_t); 11107c478bd9Sstevel@tonic-gate extern void *libc_malloc(size_t); 11117c478bd9Sstevel@tonic-gate extern void *libc_realloc(void *, size_t); 11127c478bd9Sstevel@tonic-gate extern void libc_free(void *); 11137c478bd9Sstevel@tonic-gate extern char *libc_strdup(const char *); 11147c478bd9Sstevel@tonic-gate extern void ultos(uint64_t, int, char *); 11157c478bd9Sstevel@tonic-gate extern void lock_error(const mutex_t *, const char *, void *, const char *); 11167c478bd9Sstevel@tonic-gate extern void rwlock_error(const rwlock_t *, const char *, const char *); 11177c478bd9Sstevel@tonic-gate extern void thread_error(const char *); 11187c478bd9Sstevel@tonic-gate extern void grab_assert_lock(void); 11197c478bd9Sstevel@tonic-gate extern void dump_queue_statistics(void); 11207c478bd9Sstevel@tonic-gate extern void collect_queue_statistics(void); 11217c478bd9Sstevel@tonic-gate extern void record_spin_locks(ulwp_t *); 1122883492d5Sraf extern void remember_lock(mutex_t *); 1123883492d5Sraf extern void forget_lock(mutex_t *); 1124883492d5Sraf extern void register_lock(mutex_t *); 1125883492d5Sraf extern void unregister_locks(void); 11267c478bd9Sstevel@tonic-gate #if defined(__sparc) 11277c478bd9Sstevel@tonic-gate extern void _flush_windows(void); 11287c478bd9Sstevel@tonic-gate #else 11297c478bd9Sstevel@tonic-gate #define _flush_windows() 11307c478bd9Sstevel@tonic-gate #endif 11317c478bd9Sstevel@tonic-gate extern void set_curthread(void *); 11327c478bd9Sstevel@tonic-gate 113341efec22Sraf /* 1134883492d5Sraf * Utility function used when waking up many threads (more than MAXLWPS) 1135883492d5Sraf * all at once. See mutex_wakeup_all(), cond_broadcast(), and rw_unlock(). 113641efec22Sraf */ 113741efec22Sraf #define MAXLWPS 128 /* max remembered lwpids before overflow */ 113841efec22Sraf #define NEWLWPS 2048 /* max remembered lwpids at first overflow */ 113941efec22Sraf extern lwpid_t *alloc_lwpids(lwpid_t *, int *, int *); 114041efec22Sraf 11417c478bd9Sstevel@tonic-gate /* enter a critical section */ 11427c478bd9Sstevel@tonic-gate #define enter_critical(self) (self->ul_critical++) 11437c478bd9Sstevel@tonic-gate 11447c478bd9Sstevel@tonic-gate /* exit a critical section, take deferred actions if necessary */ 11457c478bd9Sstevel@tonic-gate extern void do_exit_critical(void); 11467c478bd9Sstevel@tonic-gate #define exit_critical(self) \ 11477c478bd9Sstevel@tonic-gate (void) (self->ul_critical--, \ 11487c478bd9Sstevel@tonic-gate ((self->ul_curplease && self->ul_critical == 0)? \ 11497c478bd9Sstevel@tonic-gate (do_exit_critical(), 0) : 0)) 11507c478bd9Sstevel@tonic-gate 11517c478bd9Sstevel@tonic-gate /* 11527c478bd9Sstevel@tonic-gate * Like enter_critical()/exit_critical() but just for deferring signals. 11537c478bd9Sstevel@tonic-gate * Unlike enter_critical()/exit_critical(), ul_sigdefer may be set while 11547c478bd9Sstevel@tonic-gate * calling application functions like constructors and destructors. 11557c478bd9Sstevel@tonic-gate * Care must be taken if the application function attempts to set 11567c478bd9Sstevel@tonic-gate * the signal mask while a deferred signal is present; the setting 11577c478bd9Sstevel@tonic-gate * of the signal mask must also be deferred. 11587c478bd9Sstevel@tonic-gate */ 11597c478bd9Sstevel@tonic-gate #define sigoff(self) (self->ul_sigdefer++) 11607c478bd9Sstevel@tonic-gate extern void sigon(ulwp_t *); 11617c478bd9Sstevel@tonic-gate 11627c478bd9Sstevel@tonic-gate /* these are exported functions */ 11637c478bd9Sstevel@tonic-gate extern void _sigoff(void); 11647c478bd9Sstevel@tonic-gate extern void _sigon(void); 11657c478bd9Sstevel@tonic-gate 11667c478bd9Sstevel@tonic-gate #define sigorset(s1, s2) \ 11677c478bd9Sstevel@tonic-gate (((s1)->__sigbits[0] |= (s2)->__sigbits[0]), \ 11687c478bd9Sstevel@tonic-gate ((s1)->__sigbits[1] |= (s2)->__sigbits[1]), \ 11697c478bd9Sstevel@tonic-gate ((s1)->__sigbits[2] |= (s2)->__sigbits[2]), \ 11707c478bd9Sstevel@tonic-gate ((s1)->__sigbits[3] |= (s2)->__sigbits[3])) 11717c478bd9Sstevel@tonic-gate 11727c478bd9Sstevel@tonic-gate #define sigandset(s1, s2) \ 11737c478bd9Sstevel@tonic-gate (((s1)->__sigbits[0] &= (s2)->__sigbits[0]), \ 11747c478bd9Sstevel@tonic-gate ((s1)->__sigbits[1] &= (s2)->__sigbits[1]), \ 11757c478bd9Sstevel@tonic-gate ((s1)->__sigbits[2] &= (s2)->__sigbits[2]), \ 11767c478bd9Sstevel@tonic-gate ((s1)->__sigbits[3] &= (s2)->__sigbits[3])) 11777c478bd9Sstevel@tonic-gate 11787c478bd9Sstevel@tonic-gate #define sigdiffset(s1, s2) \ 11797c478bd9Sstevel@tonic-gate (((s1)->__sigbits[0] &= ~(s2)->__sigbits[0]), \ 11807c478bd9Sstevel@tonic-gate ((s1)->__sigbits[1] &= ~(s2)->__sigbits[1]), \ 11817c478bd9Sstevel@tonic-gate ((s1)->__sigbits[2] &= ~(s2)->__sigbits[2]), \ 11827c478bd9Sstevel@tonic-gate ((s1)->__sigbits[3] &= ~(s2)->__sigbits[3])) 11837c478bd9Sstevel@tonic-gate 11847c478bd9Sstevel@tonic-gate #define delete_reserved_signals(s) \ 11857c478bd9Sstevel@tonic-gate (((s)->__sigbits[0] &= MASKSET0), \ 11867c478bd9Sstevel@tonic-gate ((s)->__sigbits[1] &= (MASKSET1 & ~SIGMASK(SIGCANCEL))),\ 11877c478bd9Sstevel@tonic-gate ((s)->__sigbits[2] = 0), \ 11887c478bd9Sstevel@tonic-gate ((s)->__sigbits[3] = 0)) 11897c478bd9Sstevel@tonic-gate 11907c478bd9Sstevel@tonic-gate extern void block_all_signals(ulwp_t *self); 11917c478bd9Sstevel@tonic-gate 11927c478bd9Sstevel@tonic-gate /* 11937c478bd9Sstevel@tonic-gate * When restoring the signal mask after having previously called 11947c478bd9Sstevel@tonic-gate * block_all_signals(), if we have a deferred signal present then 11957c478bd9Sstevel@tonic-gate * do nothing other than ASSERT() that we are in a critical region. 11967c478bd9Sstevel@tonic-gate * The signal mask will be set when we emerge from the critical region 11977c478bd9Sstevel@tonic-gate * and call take_deferred_signal(). There is no race condition here 11987c478bd9Sstevel@tonic-gate * because the kernel currently has all signals blocked for this thread. 11997c478bd9Sstevel@tonic-gate */ 12007c478bd9Sstevel@tonic-gate #define restore_signals(self) \ 12017c478bd9Sstevel@tonic-gate ((void) ((self)->ul_cursig? \ 12027c478bd9Sstevel@tonic-gate (ASSERT((self)->ul_critical + (self)->ul_sigdefer != 0), 0) : \ 12037c478bd9Sstevel@tonic-gate __lwp_sigmask(SIG_SETMASK, &(self)->ul_sigmask, NULL))) 12047c478bd9Sstevel@tonic-gate 12057c478bd9Sstevel@tonic-gate extern void set_parking_flag(ulwp_t *, int); 12067c478bd9Sstevel@tonic-gate 12077c478bd9Sstevel@tonic-gate extern void *_thr_setup(ulwp_t *); 12087c478bd9Sstevel@tonic-gate extern void _fpinherit(ulwp_t *); 12097c478bd9Sstevel@tonic-gate extern void _lwp_start(void); 12107c478bd9Sstevel@tonic-gate extern void _lwp_terminate(void); 12117c478bd9Sstevel@tonic-gate extern void lmutex_lock(mutex_t *); 1212f841f6adSraf extern void lmutex_unlock(mutex_t *); 121341efec22Sraf extern void lrw_rdlock(rwlock_t *); 121441efec22Sraf extern void lrw_wrlock(rwlock_t *); 121541efec22Sraf extern void lrw_unlock(rwlock_t *); 1216f841f6adSraf extern void sig_mutex_lock(mutex_t *); 1217f841f6adSraf extern void sig_mutex_unlock(mutex_t *); 1218f841f6adSraf extern int sig_mutex_trylock(mutex_t *); 1219f841f6adSraf extern int sig_cond_wait(cond_t *, mutex_t *); 1220f841f6adSraf extern int sig_cond_reltimedwait(cond_t *, mutex_t *, const timespec_t *); 12217c478bd9Sstevel@tonic-gate extern void _prefork_handler(void); 12227c478bd9Sstevel@tonic-gate extern void _postfork_parent_handler(void); 12237c478bd9Sstevel@tonic-gate extern void _postfork_child_handler(void); 1224f841f6adSraf extern void postfork1_child(void); 1225f841f6adSraf extern void postfork1_child_aio(void); 1226f841f6adSraf extern void postfork1_child_sigev_aio(void); 1227f841f6adSraf extern void postfork1_child_sigev_mq(void); 1228f841f6adSraf extern void postfork1_child_sigev_timer(void); 1229f841f6adSraf extern void postfork1_child_tpool(void); 12302e145884Sraf extern void fork_lock_enter(void); 12317c478bd9Sstevel@tonic-gate extern void fork_lock_exit(void); 12327c478bd9Sstevel@tonic-gate extern void suspend_fork(void); 12337c478bd9Sstevel@tonic-gate extern void continue_fork(int); 12347c478bd9Sstevel@tonic-gate extern void do_sigcancel(void); 1235f841f6adSraf extern void setup_cancelsig(int); 1236f841f6adSraf extern void init_sigev_thread(void); 1237f841f6adSraf extern void init_aio(void); 12387c478bd9Sstevel@tonic-gate extern void _cancelon(void); 12397c478bd9Sstevel@tonic-gate extern void _canceloff(void); 12407c478bd9Sstevel@tonic-gate extern void _canceloff_nocancel(void); 1241f841f6adSraf extern void _cancel_prologue(void); 1242f841f6adSraf extern void _cancel_epilogue(void); 12437c478bd9Sstevel@tonic-gate extern void no_preempt(ulwp_t *); 12447c478bd9Sstevel@tonic-gate extern void preempt(ulwp_t *); 12457c478bd9Sstevel@tonic-gate extern void _thrp_unwind(void *); 12467c478bd9Sstevel@tonic-gate 12477c478bd9Sstevel@tonic-gate /* 12487c478bd9Sstevel@tonic-gate * Prototypes for the strong versions of the interface functions 12497c478bd9Sstevel@tonic-gate */ 1250657b1f3dSraf extern pid_t __forkx(int); 1251657b1f3dSraf extern pid_t __forkallx(int); 12527c478bd9Sstevel@tonic-gate extern pid_t _private_getpid(void); 12537c478bd9Sstevel@tonic-gate extern uid_t _private_geteuid(void); 12547c478bd9Sstevel@tonic-gate extern int _kill(pid_t, int); 12557c478bd9Sstevel@tonic-gate extern int _open(const char *, int, ...); 12567c478bd9Sstevel@tonic-gate extern int _close(int); 12577c478bd9Sstevel@tonic-gate extern ssize_t _read(int, void *, size_t); 12587c478bd9Sstevel@tonic-gate extern ssize_t _write(int, const void *, size_t); 12597c478bd9Sstevel@tonic-gate extern void *_memcpy(void *, const void *, size_t); 12607c478bd9Sstevel@tonic-gate extern void *_memset(void *, int, size_t); 126134709573Sraf extern int _memcmp(const void *, const void *, size_t); 12627c478bd9Sstevel@tonic-gate extern void *_private_memcpy(void *, const void *, size_t); 12637c478bd9Sstevel@tonic-gate extern void *_private_memset(void *, int, size_t); 12647c478bd9Sstevel@tonic-gate extern int _private_sigfillset(sigset_t *); 12657c478bd9Sstevel@tonic-gate extern int _private_sigemptyset(sigset_t *); 12667c478bd9Sstevel@tonic-gate extern int _private_sigaddset(sigset_t *, int); 12677c478bd9Sstevel@tonic-gate extern int _private_sigdelset(sigset_t *, int); 12687c478bd9Sstevel@tonic-gate extern int _private_sigismember(sigset_t *, int); 12697c478bd9Sstevel@tonic-gate extern void *_private_mmap(void *, size_t, int, int, int, off_t); 12707c478bd9Sstevel@tonic-gate extern int _private_mprotect(void *, size_t, int); 12717c478bd9Sstevel@tonic-gate extern int _private_munmap(void *, size_t); 12727c478bd9Sstevel@tonic-gate extern int _private_getrlimit(int, struct rlimit *); 12737c478bd9Sstevel@tonic-gate extern int __lwp_continue(lwpid_t); 12747c478bd9Sstevel@tonic-gate extern int __lwp_create(ucontext_t *, uint_t, lwpid_t *); 12757c478bd9Sstevel@tonic-gate extern int __lwp_kill(lwpid_t, int); 12767c478bd9Sstevel@tonic-gate extern lwpid_t __lwp_self(void); 12777c478bd9Sstevel@tonic-gate extern int ___lwp_suspend(lwpid_t); 12787c478bd9Sstevel@tonic-gate extern void lwp_yield(void); 12797c478bd9Sstevel@tonic-gate extern int lwp_wait(lwpid_t, lwpid_t *); 12807c478bd9Sstevel@tonic-gate extern int __lwp_wait(lwpid_t, lwpid_t *); 12817c478bd9Sstevel@tonic-gate extern int __lwp_detach(lwpid_t); 12827c478bd9Sstevel@tonic-gate extern sc_shared_t *__schedctl(void); 12837c478bd9Sstevel@tonic-gate 12847c478bd9Sstevel@tonic-gate extern int _private_setcontext(const ucontext_t *); 12857c478bd9Sstevel@tonic-gate extern int _private_getcontext(ucontext_t *); 12867c478bd9Sstevel@tonic-gate #pragma unknown_control_flow(_private_getcontext) 12877c478bd9Sstevel@tonic-gate /* actual system call traps */ 12887c478bd9Sstevel@tonic-gate extern int __setcontext_syscall(const ucontext_t *); 12897c478bd9Sstevel@tonic-gate extern int __getcontext_syscall(ucontext_t *); 12907c478bd9Sstevel@tonic-gate extern int _private_setustack(stack_t *); 12917c478bd9Sstevel@tonic-gate extern int __clock_gettime(clockid_t, timespec_t *); 12927c478bd9Sstevel@tonic-gate extern void abstime_to_reltime(clockid_t, const timespec_t *, timespec_t *); 12937c478bd9Sstevel@tonic-gate extern void hrt2ts(hrtime_t, timespec_t *); 12947c478bd9Sstevel@tonic-gate 12957c478bd9Sstevel@tonic-gate extern int __sigaction(int, const struct sigaction *, struct sigaction *); 12967c478bd9Sstevel@tonic-gate extern int __lwp_sigmask(int, const sigset_t *, sigset_t *); 12977c478bd9Sstevel@tonic-gate extern void __sighndlr(int, siginfo_t *, ucontext_t *, void (*)()); 12987c478bd9Sstevel@tonic-gate extern caddr_t __sighndlrend; 12997c478bd9Sstevel@tonic-gate #pragma unknown_control_flow(__sighndlr) 1300f841f6adSraf extern void _siglongjmp(sigjmp_buf, int); 13017c478bd9Sstevel@tonic-gate 1302f841f6adSraf extern int _pthread_setspecific(pthread_key_t, const void *); 1303f841f6adSraf extern void *_pthread_getspecific(pthread_key_t); 13047c478bd9Sstevel@tonic-gate extern void _pthread_exit(void *); 1305f841f6adSraf extern void _private_testcancel(void); 1306f841f6adSraf 1307f841f6adSraf /* belongs in <pthread.h> */ 1308f841f6adSraf #define PTHREAD_CREATE_DAEMON_NP 0x100 /* = THR_DAEMON */ 1309f841f6adSraf #define PTHREAD_CREATE_NONDAEMON_NP 0 1310f841f6adSraf extern int _pthread_attr_setdaemonstate_np(pthread_attr_t *, int); 1311f841f6adSraf extern int _pthread_attr_getdaemonstate_np(const pthread_attr_t *, int *); 13127c478bd9Sstevel@tonic-gate 13137c478bd9Sstevel@tonic-gate /* these are private to the library */ 13147c478bd9Sstevel@tonic-gate extern int _private_mutex_init(mutex_t *, int, void *); 13157c478bd9Sstevel@tonic-gate extern int _private_mutex_destroy(mutex_t *); 13167c478bd9Sstevel@tonic-gate extern int _private_mutex_lock(mutex_t *); 13177c478bd9Sstevel@tonic-gate extern int _private_mutex_trylock(mutex_t *); 13187c478bd9Sstevel@tonic-gate extern int _private_mutex_unlock(mutex_t *); 13197c478bd9Sstevel@tonic-gate 13207c478bd9Sstevel@tonic-gate extern int _mutex_init(mutex_t *, int, void *); 13217c478bd9Sstevel@tonic-gate extern int _mutex_destroy(mutex_t *); 1322883492d5Sraf extern int _mutex_consistent(mutex_t *); 13237c478bd9Sstevel@tonic-gate extern int _mutex_lock(mutex_t *); 13247c478bd9Sstevel@tonic-gate extern int _mutex_trylock(mutex_t *); 13257c478bd9Sstevel@tonic-gate extern int _mutex_unlock(mutex_t *); 13267c478bd9Sstevel@tonic-gate extern int __mutex_init(mutex_t *, int, void *); 13277c478bd9Sstevel@tonic-gate extern int __mutex_destroy(mutex_t *); 1328883492d5Sraf extern int __mutex_consistent(mutex_t *); 13297c478bd9Sstevel@tonic-gate extern int __mutex_lock(mutex_t *); 13307c478bd9Sstevel@tonic-gate extern int __mutex_trylock(mutex_t *); 13317c478bd9Sstevel@tonic-gate extern int __mutex_unlock(mutex_t *); 13327c478bd9Sstevel@tonic-gate extern int mutex_is_held(mutex_t *); 13337c478bd9Sstevel@tonic-gate 13347c478bd9Sstevel@tonic-gate extern int _cond_init(cond_t *, int, void *); 13357c478bd9Sstevel@tonic-gate extern int _cond_wait(cond_t *, mutex_t *); 13367c478bd9Sstevel@tonic-gate extern int _cond_timedwait(cond_t *, mutex_t *, const timespec_t *); 13377c478bd9Sstevel@tonic-gate extern int _cond_reltimedwait(cond_t *, mutex_t *, const timespec_t *); 13387c478bd9Sstevel@tonic-gate extern int _cond_signal(cond_t *); 13397c478bd9Sstevel@tonic-gate extern int _cond_broadcast(cond_t *); 13407c478bd9Sstevel@tonic-gate extern int _cond_destroy(cond_t *); 13417c478bd9Sstevel@tonic-gate extern int cond_signal_internal(cond_t *); 13427c478bd9Sstevel@tonic-gate extern int cond_broadcast_internal(cond_t *); 13437c478bd9Sstevel@tonic-gate 13447c478bd9Sstevel@tonic-gate extern int __rwlock_init(rwlock_t *, int, void *); 13457c478bd9Sstevel@tonic-gate extern int rw_read_is_held(rwlock_t *); 13467c478bd9Sstevel@tonic-gate extern int rw_write_is_held(rwlock_t *); 13477c478bd9Sstevel@tonic-gate 1348cb620785Sraf extern void _membar_enter(void); 1349cb620785Sraf extern void _membar_exit(void); 1350cb620785Sraf extern void _membar_producer(void); 1351cb620785Sraf extern void _membar_consumer(void); 1352cb620785Sraf 13537c478bd9Sstevel@tonic-gate extern int _thr_continue(thread_t); 1354f841f6adSraf extern int _thr_create(void *, size_t, void *(*)(void *), void *, long, 1355f841f6adSraf thread_t *); 1356f841f6adSraf extern int _thrp_create(void *, size_t, void *(*)(void *), void *, long, 1357f841f6adSraf thread_t *, pri_t, int, size_t); 13587c478bd9Sstevel@tonic-gate extern int _thr_getprio(thread_t, int *); 13597c478bd9Sstevel@tonic-gate extern int _thr_getspecific(thread_key_t, void **); 13607c478bd9Sstevel@tonic-gate extern int _thr_join(thread_t, thread_t *, void **); 13617c478bd9Sstevel@tonic-gate extern int _thr_keycreate(thread_key_t *, PFrV); 1362cb620785Sraf extern int _thr_keycreate_once(thread_key_t *, PFrV); 13637c478bd9Sstevel@tonic-gate extern int _thr_key_delete(thread_key_t); 13647c478bd9Sstevel@tonic-gate extern int _thr_main(void); 13657c478bd9Sstevel@tonic-gate extern thread_t _thr_self(void); 13667c478bd9Sstevel@tonic-gate extern int _thr_getconcurrency(void); 13677c478bd9Sstevel@tonic-gate extern int _thr_setconcurrency(int); 13687c478bd9Sstevel@tonic-gate extern int _thr_setprio(thread_t, int); 13697c478bd9Sstevel@tonic-gate extern int _thr_setspecific(thread_key_t, void *); 13707c478bd9Sstevel@tonic-gate extern int _thr_stksegment(stack_t *); 13717c478bd9Sstevel@tonic-gate extern int _thrp_suspend(thread_t, uchar_t); 13727c478bd9Sstevel@tonic-gate extern int _thrp_continue(thread_t, uchar_t); 13737c478bd9Sstevel@tonic-gate extern int _thr_sigsetmask(int, const sigset_t *, sigset_t *); 13747c478bd9Sstevel@tonic-gate 13757c478bd9Sstevel@tonic-gate extern void _thr_terminate(void *); 13767c478bd9Sstevel@tonic-gate extern void _thr_exit(void *); 13777c478bd9Sstevel@tonic-gate extern void _thrp_exit(void); 13787c478bd9Sstevel@tonic-gate 137934709573Sraf extern const thrattr_t *def_thrattr(void); 13807c478bd9Sstevel@tonic-gate extern int _thread_setschedparam_main(pthread_t, int, 13817c478bd9Sstevel@tonic-gate const struct sched_param *, int); 13827c478bd9Sstevel@tonic-gate extern int _validate_rt_prio(int, int); 13837c478bd9Sstevel@tonic-gate extern int _thrp_setlwpprio(lwpid_t, int, int); 1384f841f6adSraf extern pri_t map_rtpri_to_gp(pri_t); 1385f841f6adSraf extern int get_info_by_policy(int); 13867c478bd9Sstevel@tonic-gate 13877c478bd9Sstevel@tonic-gate /* 13887c478bd9Sstevel@tonic-gate * System call wrappers (direct interfaces to the kernel) 13897c478bd9Sstevel@tonic-gate */ 1390883492d5Sraf extern int ___lwp_mutex_register(mutex_t *); 13917c478bd9Sstevel@tonic-gate extern int ___lwp_mutex_trylock(mutex_t *); 13927c478bd9Sstevel@tonic-gate extern int ___lwp_mutex_timedlock(mutex_t *, timespec_t *); 13937c478bd9Sstevel@tonic-gate extern int ___lwp_mutex_unlock(mutex_t *); 1394883492d5Sraf extern int ___lwp_mutex_wakeup(mutex_t *, int); 13957c478bd9Sstevel@tonic-gate extern int ___lwp_cond_wait(cond_t *, mutex_t *, timespec_t *, int); 13967c478bd9Sstevel@tonic-gate extern int __lwp_cond_signal(lwp_cond_t *); 13977c478bd9Sstevel@tonic-gate extern int __lwp_cond_broadcast(lwp_cond_t *); 13987c478bd9Sstevel@tonic-gate extern int ___lwp_sema_timedwait(lwp_sema_t *, timespec_t *, int); 13997c478bd9Sstevel@tonic-gate extern int __lwp_sema_trywait(lwp_sema_t *); 14007c478bd9Sstevel@tonic-gate extern int __lwp_sema_post(lwp_sema_t *); 14017c478bd9Sstevel@tonic-gate extern int __lwp_rwlock_rdlock(rwlock_t *, timespec_t *); 14027c478bd9Sstevel@tonic-gate extern int __lwp_rwlock_wrlock(rwlock_t *, timespec_t *); 14037c478bd9Sstevel@tonic-gate extern int __lwp_rwlock_tryrdlock(rwlock_t *); 14047c478bd9Sstevel@tonic-gate extern int __lwp_rwlock_trywrlock(rwlock_t *); 14057c478bd9Sstevel@tonic-gate extern int __lwp_rwlock_unlock(rwlock_t *); 14067c478bd9Sstevel@tonic-gate extern int __lwp_park(timespec_t *, lwpid_t); 14077c478bd9Sstevel@tonic-gate extern int __lwp_unpark(lwpid_t); 14087c478bd9Sstevel@tonic-gate extern int __lwp_unpark_all(lwpid_t *, int); 14090ec57554Sraf #if defined(__x86) 14107c478bd9Sstevel@tonic-gate extern int ___lwp_private(int, int, void *); 14110ec57554Sraf #endif /* __x86 */ 14127c478bd9Sstevel@tonic-gate 14137c478bd9Sstevel@tonic-gate extern int _private_lwp_mutex_lock(mutex_t *); 14147c478bd9Sstevel@tonic-gate extern int _private_lwp_mutex_unlock(mutex_t *); 14157c478bd9Sstevel@tonic-gate 14167c478bd9Sstevel@tonic-gate /* 14177c478bd9Sstevel@tonic-gate * inlines 14187c478bd9Sstevel@tonic-gate */ 14197c478bd9Sstevel@tonic-gate extern int set_lock_byte(volatile uint8_t *); 142041efec22Sraf extern uint32_t atomic_swap_32(volatile uint32_t *, uint32_t); 142141efec22Sraf extern uint32_t atomic_cas_32(volatile uint32_t *, uint32_t, uint32_t); 142241efec22Sraf extern void atomic_inc_32(volatile uint32_t *); 142341efec22Sraf extern void atomic_dec_32(volatile uint32_t *); 142441efec22Sraf extern void atomic_and_32(volatile uint32_t *, uint32_t); 142541efec22Sraf extern void atomic_or_32(volatile uint32_t *, uint32_t); 14260ec57554Sraf #if defined(__sparc) 14270ec57554Sraf extern ulong_t caller(void); 14280ec57554Sraf extern ulong_t getfp(void); 14290ec57554Sraf #endif /* __sparc */ 14300ec57554Sraf 14310ec57554Sraf #include "thr_inlines.h" 14327c478bd9Sstevel@tonic-gate 14337c478bd9Sstevel@tonic-gate #endif /* _THR_UBERDATA_H */ 1434