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 /* 23a574db85Sraf * Copyright 2008 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) 105*31db3c26Sraf 1067c478bd9Sstevel@tonic-gate /* lock.lock64.pad[x] 4 5 6 7 */ 1077c478bd9Sstevel@tonic-gate #define LOCKMASK 0xff000000 1087c478bd9Sstevel@tonic-gate #define WAITERMASK 0x000000ff 1095d1dd9a9Sraf #define SPINNERMASK 0x00ff0000 1105d1dd9a9Sraf #define SPINNERSHIFT 16 1117c478bd9Sstevel@tonic-gate #define WAITER 0x00000001 1127c478bd9Sstevel@tonic-gate #define LOCKSET 0xff 1137c478bd9Sstevel@tonic-gate #define LOCKCLEAR 0 114*31db3c26Sraf 115*31db3c26Sraf #define PIDSHIFT 32 116*31db3c26Sraf #define LOCKMASK64 0xffffffffff000000ULL 117*31db3c26Sraf #define LOCKBYTE64 0x00000000ff000000ULL 118*31db3c26Sraf #define WAITERMASK64 0x00000000000000ffULL 119*31db3c26Sraf #define SPINNERMASK64 0x0000000000ff0000ULL 120*31db3c26Sraf 1210ec57554Sraf #elif defined(__x86) 122*31db3c26Sraf 1237c478bd9Sstevel@tonic-gate /* lock.lock64.pad[x] 7 6 5 4 */ 1247c478bd9Sstevel@tonic-gate #define LOCKMASK 0xff000000 1257c478bd9Sstevel@tonic-gate #define WAITERMASK 0x00ff0000 1265d1dd9a9Sraf #define SPINNERMASK 0x0000ff00 1275d1dd9a9Sraf #define SPINNERSHIFT 8 1287c478bd9Sstevel@tonic-gate #define WAITER 0x00010000 1297c478bd9Sstevel@tonic-gate #define LOCKSET 0x01 1307c478bd9Sstevel@tonic-gate #define LOCKCLEAR 0 131*31db3c26Sraf 132*31db3c26Sraf #define PIDSHIFT 0 133*31db3c26Sraf #define LOCKMASK64 0xff000000ffffffffULL 134*31db3c26Sraf #define LOCKBYTE64 0x0100000000000000ULL 135*31db3c26Sraf #define WAITERMASK64 0x00ff000000000000ULL 136*31db3c26Sraf #define SPINNERMASK64 0x0000ff0000000000ULL 137*31db3c26Sraf 1387c478bd9Sstevel@tonic-gate #else 1390ec57554Sraf #error "neither __sparc nor __x86 is defined" 1407c478bd9Sstevel@tonic-gate #endif 1417c478bd9Sstevel@tonic-gate 1427c478bd9Sstevel@tonic-gate /* 1437c478bd9Sstevel@tonic-gate * Fetch the owner of a USYNC_THREAD mutex. 1447c478bd9Sstevel@tonic-gate * Don't use this with process-shared mutexes; 1457c478bd9Sstevel@tonic-gate * the owing thread may be in a different process. 1467c478bd9Sstevel@tonic-gate */ 1477c478bd9Sstevel@tonic-gate #define MUTEX_OWNER(mp) ((ulwp_t *)(uintptr_t)(mp)->mutex_owner) 1487c478bd9Sstevel@tonic-gate 1497c478bd9Sstevel@tonic-gate /* 150883492d5Sraf * Test if a thread owns a process-private (USYNC_THREAD) mutex. 151883492d5Sraf * This is inappropriate for a process-shared (USYNC_PROCESS) mutex. 1527c478bd9Sstevel@tonic-gate * The 'mp' argument must not have side-effects since it is evaluated twice. 1537c478bd9Sstevel@tonic-gate */ 1547c478bd9Sstevel@tonic-gate #define MUTEX_OWNED(mp, thrp) \ 1557c478bd9Sstevel@tonic-gate ((mp)->mutex_lockw != 0 && MUTEX_OWNER(mp) == thrp) 1567c478bd9Sstevel@tonic-gate 1577c478bd9Sstevel@tonic-gate 1587c478bd9Sstevel@tonic-gate /* 1597c478bd9Sstevel@tonic-gate * uberflags.uf_tdb_register_sync is an interface with libc_db to enable the 1607c478bd9Sstevel@tonic-gate * collection of lock statistics by a debugger or other collecting tool. 1617c478bd9Sstevel@tonic-gate * 1627c478bd9Sstevel@tonic-gate * uberflags.uf_thread_error_detection is set by an environment variable: 1637c478bd9Sstevel@tonic-gate * _THREAD_ERROR_DETECTION 1647c478bd9Sstevel@tonic-gate * 0 == no detection of locking primitive errors. 1657c478bd9Sstevel@tonic-gate * 1 == detect errors and issue a warning message. 1667c478bd9Sstevel@tonic-gate * 2 == detect errors, issue a warning message, and dump core. 1677c478bd9Sstevel@tonic-gate * 1687c478bd9Sstevel@tonic-gate * We bundle these together in uberflags.uf_trs_ted to make a test of either 1697c478bd9Sstevel@tonic-gate * being non-zero a single memory reference (for speed of mutex_lock(), etc). 1707c478bd9Sstevel@tonic-gate * 1717c478bd9Sstevel@tonic-gate * uberflags.uf_mt is set non-zero when the first thread (in addition 1727c478bd9Sstevel@tonic-gate * to the main thread) is created. 1737c478bd9Sstevel@tonic-gate * 1747c478bd9Sstevel@tonic-gate * We bundle all these flags together in uberflags.uf_all to make a test 1757c478bd9Sstevel@tonic-gate * of any being non-zero a single memory reference (again, for speed). 1767c478bd9Sstevel@tonic-gate */ 1777c478bd9Sstevel@tonic-gate typedef union { 1787c478bd9Sstevel@tonic-gate int uf_all; /* combined all flags */ 1797c478bd9Sstevel@tonic-gate struct { 1807c478bd9Sstevel@tonic-gate short h_pad; 1817c478bd9Sstevel@tonic-gate short h_trs_ted; /* combined reg sync & error detect */ 1827c478bd9Sstevel@tonic-gate } uf_h; 1837c478bd9Sstevel@tonic-gate struct { 1847c478bd9Sstevel@tonic-gate char x_mt; 1857c478bd9Sstevel@tonic-gate char x_pad; 1867c478bd9Sstevel@tonic-gate char x_tdb_register_sync; 1877c478bd9Sstevel@tonic-gate char x_thread_error_detection; 1887c478bd9Sstevel@tonic-gate } uf_x; 1897c478bd9Sstevel@tonic-gate } uberflags_t; 1907c478bd9Sstevel@tonic-gate 1917c478bd9Sstevel@tonic-gate #define uf_mt uf_x.x_mt 1927c478bd9Sstevel@tonic-gate #define uf_tdb_register_sync uf_x.x_tdb_register_sync 1937c478bd9Sstevel@tonic-gate #define uf_thread_error_detection uf_x.x_thread_error_detection 1947c478bd9Sstevel@tonic-gate #define uf_trs_ted uf_h.h_trs_ted /* both of the above */ 1957c478bd9Sstevel@tonic-gate 1967c478bd9Sstevel@tonic-gate /* 1977c478bd9Sstevel@tonic-gate * NOTE WELL: 1987c478bd9Sstevel@tonic-gate * To enable further optimization, the "ul_schedctl_called" member 1997c478bd9Sstevel@tonic-gate * of the ulwp_t structure (below) serves double-duty: 2007c478bd9Sstevel@tonic-gate * 1. If NULL, it means that the thread must call __schedctl() 2017c478bd9Sstevel@tonic-gate * to set up its schedctl mappings before acquiring a mutex. 2027c478bd9Sstevel@tonic-gate * This is required by the implementation of adaptive mutex locking. 2037c478bd9Sstevel@tonic-gate * 2. If non-NULL, it points to uberdata.uberflags, so that tests of 2047c478bd9Sstevel@tonic-gate * uberflags can be made without additional memory references. 2057c478bd9Sstevel@tonic-gate * This allows the common case of _mutex_lock() and _mutex_unlock() for 2067c478bd9Sstevel@tonic-gate * USYNC_THREAD mutexes with no error detection and no lock statistics 2077c478bd9Sstevel@tonic-gate * to be optimized for speed. 2087c478bd9Sstevel@tonic-gate */ 2097c478bd9Sstevel@tonic-gate 2107c478bd9Sstevel@tonic-gate 2117c478bd9Sstevel@tonic-gate /* double the default stack size for 64-bit processes */ 2127c478bd9Sstevel@tonic-gate #ifdef _LP64 2137c478bd9Sstevel@tonic-gate #define MINSTACK (8 * 1024) 2147c478bd9Sstevel@tonic-gate #define DEFAULTSTACK (2 * 1024 * 1024) 2157c478bd9Sstevel@tonic-gate #else 2167c478bd9Sstevel@tonic-gate #define MINSTACK (4 * 1024) 2177c478bd9Sstevel@tonic-gate #define DEFAULTSTACK (1024 * 1024) 2187c478bd9Sstevel@tonic-gate #endif 2197c478bd9Sstevel@tonic-gate #define TSD_NKEYS _POSIX_THREAD_KEYS_MAX 2207c478bd9Sstevel@tonic-gate 2217c478bd9Sstevel@tonic-gate #define THREAD_MIN_PRIORITY 0 2227c478bd9Sstevel@tonic-gate #define THREAD_MAX_PRIORITY 127 2237c478bd9Sstevel@tonic-gate 2247c478bd9Sstevel@tonic-gate #define PRIO_SET 0 /* set priority and policy */ 2257c478bd9Sstevel@tonic-gate #define PRIO_SET_PRIO 1 /* set priority only */ 2267c478bd9Sstevel@tonic-gate #define PRIO_INHERIT 2 2277c478bd9Sstevel@tonic-gate #define PRIO_DISINHERIT 3 2287c478bd9Sstevel@tonic-gate 2297c478bd9Sstevel@tonic-gate #define MUTEX_TRY 0 2307c478bd9Sstevel@tonic-gate #define MUTEX_LOCK 1 2317c478bd9Sstevel@tonic-gate 2320ec57554Sraf #if defined(__x86) 2337c478bd9Sstevel@tonic-gate 2347c478bd9Sstevel@tonic-gate typedef struct { /* structure returned by fnstenv */ 2357c478bd9Sstevel@tonic-gate int fctrl; /* control word */ 2367c478bd9Sstevel@tonic-gate int fstat; /* status word (flags, etc) */ 2377c478bd9Sstevel@tonic-gate int ftag; /* tag of which regs busy */ 2387c478bd9Sstevel@tonic-gate int misc[4]; /* other stuff, 28 bytes total */ 2397c478bd9Sstevel@tonic-gate } fpuenv_t; 2407c478bd9Sstevel@tonic-gate 2417c478bd9Sstevel@tonic-gate #ifdef _SYSCALL32 2427c478bd9Sstevel@tonic-gate typedef fpuenv_t fpuenv32_t; 2437c478bd9Sstevel@tonic-gate #endif /* _SYSCALL32 */ 2447c478bd9Sstevel@tonic-gate 2457c478bd9Sstevel@tonic-gate #elif defined(__sparc) 2467c478bd9Sstevel@tonic-gate 2477c478bd9Sstevel@tonic-gate typedef struct { /* fp state structure */ 2487c478bd9Sstevel@tonic-gate greg_t fsr; 2497c478bd9Sstevel@tonic-gate greg_t fpu_en; 2507c478bd9Sstevel@tonic-gate } fpuenv_t; 2517c478bd9Sstevel@tonic-gate 2527c478bd9Sstevel@tonic-gate #ifdef _SYSCALL32 2537c478bd9Sstevel@tonic-gate typedef struct { 2547c478bd9Sstevel@tonic-gate greg32_t fsr; 2557c478bd9Sstevel@tonic-gate greg32_t fpu_en; 2567c478bd9Sstevel@tonic-gate } fpuenv32_t; 2577c478bd9Sstevel@tonic-gate #endif /* _SYSCALL32 */ 2587c478bd9Sstevel@tonic-gate 2590ec57554Sraf #endif /* __x86 */ 2607c478bd9Sstevel@tonic-gate 2610ec57554Sraf #if defined(__x86) 2627c478bd9Sstevel@tonic-gate extern void ht_pause(void); /* "pause" instruction */ 2637c478bd9Sstevel@tonic-gate #define SMT_PAUSE() ht_pause() 2647c478bd9Sstevel@tonic-gate #else 2657c478bd9Sstevel@tonic-gate #define SMT_PAUSE() 2660ec57554Sraf #endif /* __x86 */ 2677c478bd9Sstevel@tonic-gate 2687c478bd9Sstevel@tonic-gate /* 2697c478bd9Sstevel@tonic-gate * Cleanup handler related data. 2707c478bd9Sstevel@tonic-gate * This structure is exported as _cleanup_t in pthread.h. 2717c478bd9Sstevel@tonic-gate * pthread.h exports only the size of this structure, so check 2727c478bd9Sstevel@tonic-gate * _cleanup_t in pthread.h before making any change here. 2737c478bd9Sstevel@tonic-gate */ 2747c478bd9Sstevel@tonic-gate typedef struct __cleanup { 2757c478bd9Sstevel@tonic-gate struct __cleanup *next; /* pointer to next handler */ 2767c478bd9Sstevel@tonic-gate caddr_t fp; /* current frame pointer */ 2777c478bd9Sstevel@tonic-gate void (*func)(void *); /* cleanup handler address */ 2787c478bd9Sstevel@tonic-gate void *arg; /* handler's argument */ 2797c478bd9Sstevel@tonic-gate } __cleanup_t; 2807c478bd9Sstevel@tonic-gate 2817c478bd9Sstevel@tonic-gate /* 2827c478bd9Sstevel@tonic-gate * Thread-Specific Data (TSD) 2837c478bd9Sstevel@tonic-gate * TSD_NFAST includes the invalid key zero, so there 2847c478bd9Sstevel@tonic-gate * are really only (TSD_NFAST - 1) fast key slots. 2857c478bd9Sstevel@tonic-gate */ 2867c478bd9Sstevel@tonic-gate typedef void (*PFrV)(void *); 2877c478bd9Sstevel@tonic-gate #define TSD_UNALLOCATED ((PFrV)1) 2887c478bd9Sstevel@tonic-gate #define TSD_NFAST 9 2897c478bd9Sstevel@tonic-gate 2907c478bd9Sstevel@tonic-gate /* 2917c478bd9Sstevel@tonic-gate * The tsd union is designed to burn a little memory (9 words) to make 2927c478bd9Sstevel@tonic-gate * lookups blindingly fast. Note that tsd_nalloc could be placed at the 2937c478bd9Sstevel@tonic-gate * end of the pad region to increase the likelihood that it falls on the 2947c478bd9Sstevel@tonic-gate * same cache line as the data. 2957c478bd9Sstevel@tonic-gate */ 2967c478bd9Sstevel@tonic-gate typedef union tsd { 2977c478bd9Sstevel@tonic-gate uint_t tsd_nalloc; /* Amount of allocated storage */ 2987c478bd9Sstevel@tonic-gate void *tsd_pad[TSD_NFAST]; 2997c478bd9Sstevel@tonic-gate void *tsd_data[1]; 3007c478bd9Sstevel@tonic-gate } tsd_t; 3017c478bd9Sstevel@tonic-gate 3027c478bd9Sstevel@tonic-gate typedef struct { 3037c478bd9Sstevel@tonic-gate mutex_t tsdm_lock; /* Lock protecting the data */ 3047c478bd9Sstevel@tonic-gate uint_t tsdm_nkeys; /* Number of allocated keys */ 3057c478bd9Sstevel@tonic-gate uint_t tsdm_nused; /* Number of used keys */ 3067c478bd9Sstevel@tonic-gate PFrV *tsdm_destro; /* Per-key destructors */ 3077c478bd9Sstevel@tonic-gate char tsdm_pad[64 - /* pad to 64 bytes */ 3087c478bd9Sstevel@tonic-gate (sizeof (mutex_t) + 2 * sizeof (uint_t) + sizeof (PFrV *))]; 3097c478bd9Sstevel@tonic-gate } tsd_metadata_t; 3107c478bd9Sstevel@tonic-gate 3117c478bd9Sstevel@tonic-gate #ifdef _SYSCALL32 3127c478bd9Sstevel@tonic-gate typedef union tsd32 { 3137c478bd9Sstevel@tonic-gate uint_t tsd_nalloc; /* Amount of allocated storage */ 3147c478bd9Sstevel@tonic-gate caddr32_t tsd_pad[TSD_NFAST]; 3157c478bd9Sstevel@tonic-gate caddr32_t tsd_data[1]; 3167c478bd9Sstevel@tonic-gate } tsd32_t; 3177c478bd9Sstevel@tonic-gate 3187c478bd9Sstevel@tonic-gate typedef struct { 3197c478bd9Sstevel@tonic-gate mutex_t tsdm_lock; /* Lock protecting the data */ 3207c478bd9Sstevel@tonic-gate uint_t tsdm_nkeys; /* Number of allocated keys */ 3217c478bd9Sstevel@tonic-gate uint_t tsdm_nused; /* Number of used keys */ 3227c478bd9Sstevel@tonic-gate caddr32_t tsdm_destro; /* Per-key destructors */ 3237c478bd9Sstevel@tonic-gate char tsdm_pad[64 - /* pad to 64 bytes */ 3247c478bd9Sstevel@tonic-gate (sizeof (mutex_t) + 2 * sizeof (uint_t) + sizeof (caddr32_t))]; 3257c478bd9Sstevel@tonic-gate } tsd_metadata32_t; 3267c478bd9Sstevel@tonic-gate #endif /* _SYSCALL32 */ 3277c478bd9Sstevel@tonic-gate 3287c478bd9Sstevel@tonic-gate 3297c478bd9Sstevel@tonic-gate /* 3307c478bd9Sstevel@tonic-gate * Thread-Local Storage (TLS) 3317c478bd9Sstevel@tonic-gate */ 3327c478bd9Sstevel@tonic-gate typedef struct { 3337c478bd9Sstevel@tonic-gate void *tls_data; 3347c478bd9Sstevel@tonic-gate size_t tls_size; 3357c478bd9Sstevel@tonic-gate } tls_t; 3367c478bd9Sstevel@tonic-gate 3377c478bd9Sstevel@tonic-gate typedef struct { 3387c478bd9Sstevel@tonic-gate mutex_t tls_lock; /* Lock protecting the data */ 3397c478bd9Sstevel@tonic-gate tls_t tls_modinfo; /* Root of all TLS_modinfo data */ 3407c478bd9Sstevel@tonic-gate tls_t static_tls; /* Template for static TLS */ 3417c478bd9Sstevel@tonic-gate char tls_pad[64 - /* pad to 64 bytes */ 3427c478bd9Sstevel@tonic-gate (sizeof (mutex_t) + 2 * sizeof (tls_t))]; 3437c478bd9Sstevel@tonic-gate } tls_metadata_t; 3447c478bd9Sstevel@tonic-gate 3457c478bd9Sstevel@tonic-gate #ifdef _SYSCALL32 3467c478bd9Sstevel@tonic-gate typedef struct { 3477c478bd9Sstevel@tonic-gate caddr32_t tls_data; 3487c478bd9Sstevel@tonic-gate size32_t tls_size; 3497c478bd9Sstevel@tonic-gate } tls32_t; 3507c478bd9Sstevel@tonic-gate 3517c478bd9Sstevel@tonic-gate typedef struct { 3527c478bd9Sstevel@tonic-gate mutex_t tls_lock; /* Lock protecting the data */ 3537c478bd9Sstevel@tonic-gate tls32_t tls_modinfo; /* Root of all TLS_modinfo data */ 3547c478bd9Sstevel@tonic-gate tls32_t static_tls; /* Template for static TLS */ 3557c478bd9Sstevel@tonic-gate char tls_pad[64 - /* pad to 64 bytes */ 3567c478bd9Sstevel@tonic-gate (sizeof (mutex_t) + 2 * sizeof (tls32_t))]; 3577c478bd9Sstevel@tonic-gate } tls_metadata32_t; 3587c478bd9Sstevel@tonic-gate #endif /* _SYSCALL32 */ 3597c478bd9Sstevel@tonic-gate 3607c478bd9Sstevel@tonic-gate 3617c478bd9Sstevel@tonic-gate /* 3627c478bd9Sstevel@tonic-gate * Sleep queues for USYNC_THREAD condvars and mutexes. 3637c478bd9Sstevel@tonic-gate * The size and alignment is 64 bytes to reduce cache conflicts. 3647c478bd9Sstevel@tonic-gate */ 3657c478bd9Sstevel@tonic-gate typedef union { 3667c478bd9Sstevel@tonic-gate uint64_t qh_64[8]; 3677c478bd9Sstevel@tonic-gate struct { 3687c478bd9Sstevel@tonic-gate mutex_t q_lock; 3697c478bd9Sstevel@tonic-gate uint8_t q_qcnt; 3707c478bd9Sstevel@tonic-gate uint8_t q_pad[7]; 3717c478bd9Sstevel@tonic-gate uint64_t q_lockcount; 3727c478bd9Sstevel@tonic-gate uint32_t q_qlen; 3737c478bd9Sstevel@tonic-gate uint32_t q_qmax; 3747c478bd9Sstevel@tonic-gate struct ulwp *q_head; 3757c478bd9Sstevel@tonic-gate struct ulwp *q_tail; 3767c478bd9Sstevel@tonic-gate } qh_qh; 3777c478bd9Sstevel@tonic-gate } queue_head_t; 3787c478bd9Sstevel@tonic-gate 3797c478bd9Sstevel@tonic-gate #define qh_lock qh_qh.q_lock 3807c478bd9Sstevel@tonic-gate #define qh_qcnt qh_qh.q_qcnt 3817c478bd9Sstevel@tonic-gate #define qh_lockcount qh_qh.q_lockcount 3827c478bd9Sstevel@tonic-gate #define qh_qlen qh_qh.q_qlen 3837c478bd9Sstevel@tonic-gate #define qh_qmax qh_qh.q_qmax 3847c478bd9Sstevel@tonic-gate #define qh_head qh_qh.q_head 3857c478bd9Sstevel@tonic-gate #define qh_tail qh_qh.q_tail 3867c478bd9Sstevel@tonic-gate 3877c478bd9Sstevel@tonic-gate /* queue types passed to queue_lock() and enqueue() */ 3887c478bd9Sstevel@tonic-gate #define MX 0 3897c478bd9Sstevel@tonic-gate #define CV 1 3907c478bd9Sstevel@tonic-gate #define FIFOQ 0x10 /* or'ing with FIFOQ asks for FIFO queueing */ 391883492d5Sraf #define QHASHSHIFT 9 /* number of hashing bits */ 392883492d5Sraf #define QHASHSIZE (1 << QHASHSHIFT) /* power of 2 (1<<9 == 512) */ 393883492d5Sraf #define QUEUE_HASH(wchan, type) ((uint_t) \ 394883492d5Sraf ((((uintptr_t)(wchan) >> 3) \ 395883492d5Sraf ^ ((uintptr_t)(wchan) >> (QHASHSHIFT + 3))) \ 3967c478bd9Sstevel@tonic-gate & (QHASHSIZE - 1)) + (((type) == MX)? 0 : QHASHSIZE)) 3977c478bd9Sstevel@tonic-gate 3987c478bd9Sstevel@tonic-gate extern queue_head_t *queue_lock(void *, int); 3997c478bd9Sstevel@tonic-gate extern void queue_unlock(queue_head_t *); 4007c478bd9Sstevel@tonic-gate extern void enqueue(queue_head_t *, struct ulwp *, void *, int); 4017c478bd9Sstevel@tonic-gate extern struct ulwp *dequeue(queue_head_t *, void *, int *); 4027c478bd9Sstevel@tonic-gate extern struct ulwp *queue_waiter(queue_head_t *, void *); 40341efec22Sraf extern struct ulwp *queue_unlink(queue_head_t *, 40441efec22Sraf struct ulwp **, struct ulwp *); 4057c478bd9Sstevel@tonic-gate extern uint8_t dequeue_self(queue_head_t *, void *); 4067c478bd9Sstevel@tonic-gate extern void unsleep_self(void); 4077c478bd9Sstevel@tonic-gate extern void spin_lock_set(mutex_t *); 4087c478bd9Sstevel@tonic-gate extern void spin_lock_clear(mutex_t *); 4097c478bd9Sstevel@tonic-gate 4107c478bd9Sstevel@tonic-gate /* 4117c478bd9Sstevel@tonic-gate * Memory block for chain of owned ceiling mutexes. 4127c478bd9Sstevel@tonic-gate */ 4137c478bd9Sstevel@tonic-gate typedef struct mxchain { 4147c478bd9Sstevel@tonic-gate struct mxchain *mxchain_next; 4157c478bd9Sstevel@tonic-gate mutex_t *mxchain_mx; 4167c478bd9Sstevel@tonic-gate } mxchain_t; 4177c478bd9Sstevel@tonic-gate 4187c478bd9Sstevel@tonic-gate /* 4197c478bd9Sstevel@tonic-gate * Pointer to an rwlock that is held for reading. 4207c478bd9Sstevel@tonic-gate * Used in rw_rdlock() to allow a thread that already holds a read 4217c478bd9Sstevel@tonic-gate * lock to acquire another read lock on the same rwlock even if 4227c478bd9Sstevel@tonic-gate * there are writers waiting. This to avoid deadlock when acquiring 4237c478bd9Sstevel@tonic-gate * a read lock more than once in the presence of pending writers. 4247c478bd9Sstevel@tonic-gate * POSIX mandates this behavior. 4257c478bd9Sstevel@tonic-gate */ 4267c478bd9Sstevel@tonic-gate typedef struct { 4277c478bd9Sstevel@tonic-gate void *rd_rwlock; /* the rwlock held for reading */ 4287c478bd9Sstevel@tonic-gate size_t rd_count; /* count of read locks applied */ 4297c478bd9Sstevel@tonic-gate } readlock_t; 4307c478bd9Sstevel@tonic-gate 4317c478bd9Sstevel@tonic-gate #ifdef _SYSCALL32 4327c478bd9Sstevel@tonic-gate typedef struct { 4337c478bd9Sstevel@tonic-gate caddr32_t rd_rwlock; 4347c478bd9Sstevel@tonic-gate size32_t rd_count; 4357c478bd9Sstevel@tonic-gate } readlock32_t; 4367c478bd9Sstevel@tonic-gate #endif /* _SYSCALL32 */ 4377c478bd9Sstevel@tonic-gate 4387c478bd9Sstevel@tonic-gate /* 4397c478bd9Sstevel@tonic-gate * Maximum number of read locks allowed for one thread on one rwlock. 4407c478bd9Sstevel@tonic-gate * This could be as large as INT_MAX, but the SUSV3 test suite would 4417c478bd9Sstevel@tonic-gate * take an inordinately long time to complete. This is big enough. 4427c478bd9Sstevel@tonic-gate */ 4437c478bd9Sstevel@tonic-gate #define READ_LOCK_MAX 100000 4447c478bd9Sstevel@tonic-gate 4457c478bd9Sstevel@tonic-gate #define ul_tlsent ul_tls.tls_data /* array of pointers to dynamic TLS */ 4467c478bd9Sstevel@tonic-gate #define ul_ntlsent ul_tls.tls_size /* number of entries in ul_tlsent */ 4477c478bd9Sstevel@tonic-gate 4487c478bd9Sstevel@tonic-gate /* 4497c478bd9Sstevel@tonic-gate * Round up an integral value to a multiple of 64 4507c478bd9Sstevel@tonic-gate */ 4517c478bd9Sstevel@tonic-gate #define roundup64(x) (-(-(x) & -64)) 4527c478bd9Sstevel@tonic-gate 4537c478bd9Sstevel@tonic-gate /* 4547c478bd9Sstevel@tonic-gate * NOTE: Whatever changes are made to ulwp_t must be 4557c478bd9Sstevel@tonic-gate * reflected in $SRC/cmd/mdb/common/modules/libc/libc.c 4567c478bd9Sstevel@tonic-gate * 4577c478bd9Sstevel@tonic-gate * NOTE: ul_self *must* be the first member of ulwp_t on x86 4587c478bd9Sstevel@tonic-gate * Low-level x86 code relies on this. 4597c478bd9Sstevel@tonic-gate */ 4607c478bd9Sstevel@tonic-gate typedef struct ulwp { 4617c478bd9Sstevel@tonic-gate /* 4627c478bd9Sstevel@tonic-gate * These members always need to come first on sparc. 4637c478bd9Sstevel@tonic-gate * For dtrace, a ulwp_t must be aligned on a 64-byte boundary. 4647c478bd9Sstevel@tonic-gate */ 4657c478bd9Sstevel@tonic-gate #if defined(__sparc) 4667c478bd9Sstevel@tonic-gate uint32_t ul_dinstr; /* scratch space for dtrace */ 4677c478bd9Sstevel@tonic-gate uint32_t ul_padsparc0[15]; 4687c478bd9Sstevel@tonic-gate uint32_t ul_dsave; /* dtrace: save %g1, %g0, %sp */ 4697c478bd9Sstevel@tonic-gate uint32_t ul_drestore; /* dtrace: restore %g0, %g0, %g0 */ 4707c478bd9Sstevel@tonic-gate uint32_t ul_dftret; /* dtrace: return probe fasttrap */ 4717c478bd9Sstevel@tonic-gate uint32_t ul_dreturn; /* dtrace: return %o0 */ 4727c478bd9Sstevel@tonic-gate #endif 4737c478bd9Sstevel@tonic-gate struct ulwp *ul_self; /* pointer to self */ 4747c478bd9Sstevel@tonic-gate #if defined(__i386) 4757c478bd9Sstevel@tonic-gate uint8_t ul_dinstr[40]; /* scratch space for dtrace */ 4767c478bd9Sstevel@tonic-gate #elif defined(__amd64) 4777c478bd9Sstevel@tonic-gate uint8_t ul_dinstr[56]; /* scratch space for dtrace */ 4787c478bd9Sstevel@tonic-gate #endif 4797c478bd9Sstevel@tonic-gate struct uberdata *ul_uberdata; /* uber (super-global) data */ 4807c478bd9Sstevel@tonic-gate tls_t ul_tls; /* dynamic thread-local storage base */ 4817c478bd9Sstevel@tonic-gate struct ulwp *ul_forw; /* forw, back all_lwps list, */ 4827c478bd9Sstevel@tonic-gate struct ulwp *ul_back; /* protected by link_lock */ 4837c478bd9Sstevel@tonic-gate struct ulwp *ul_next; /* list to keep track of stacks */ 4847c478bd9Sstevel@tonic-gate struct ulwp *ul_hash; /* hash chain linked list */ 4857c478bd9Sstevel@tonic-gate void *ul_rval; /* return value from thr_exit() */ 4867c478bd9Sstevel@tonic-gate caddr_t ul_stk; /* mapping base of the stack */ 4877c478bd9Sstevel@tonic-gate size_t ul_mapsiz; /* mapping size of the stack */ 4887c478bd9Sstevel@tonic-gate size_t ul_guardsize; /* normally _lpagesize */ 4897c478bd9Sstevel@tonic-gate uintptr_t ul_stktop; /* broken thr_stksegment() interface */ 4907c478bd9Sstevel@tonic-gate size_t ul_stksiz; /* broken thr_stksegment() interface */ 4917c478bd9Sstevel@tonic-gate stack_t ul_ustack; /* current stack boundaries */ 4927c478bd9Sstevel@tonic-gate int ul_ix; /* hash index */ 4937c478bd9Sstevel@tonic-gate lwpid_t ul_lwpid; /* thread id, aka the lwp id */ 4947c478bd9Sstevel@tonic-gate pri_t ul_pri; /* priority known to the library */ 4957c478bd9Sstevel@tonic-gate pri_t ul_mappedpri; /* priority known to the application */ 4967c478bd9Sstevel@tonic-gate char ul_policy; /* scheduling policy */ 4977c478bd9Sstevel@tonic-gate char ul_pri_mapped; /* != 0 means ul_mappedpri is valid */ 4987c478bd9Sstevel@tonic-gate union { 4997c478bd9Sstevel@tonic-gate struct { 5007c478bd9Sstevel@tonic-gate char cursig; /* deferred signal number */ 5017c478bd9Sstevel@tonic-gate char pleasestop; /* lwp requested to stop itself */ 5027c478bd9Sstevel@tonic-gate } s; 5037c478bd9Sstevel@tonic-gate short curplease; /* for testing both at once */ 5047c478bd9Sstevel@tonic-gate } ul_cp; 5057c478bd9Sstevel@tonic-gate char ul_stop; /* reason for stopping */ 5067c478bd9Sstevel@tonic-gate char ul_signalled; /* this lwp was cond_signal()d */ 5077c478bd9Sstevel@tonic-gate char ul_dead; /* this lwp has called thr_exit */ 5087c478bd9Sstevel@tonic-gate char ul_unwind; /* posix: unwind C++ stack */ 5097c478bd9Sstevel@tonic-gate char ul_detached; /* THR_DETACHED at thread_create() */ 5107c478bd9Sstevel@tonic-gate /* or pthread_detach() was called */ 5117c478bd9Sstevel@tonic-gate char ul_writer; /* sleeping in rw_wrlock() */ 5127c478bd9Sstevel@tonic-gate char ul_stopping; /* set by curthread: stopping self */ 51334709573Sraf char ul_cancel_prologue; /* for _cancel_prologue() */ 5147c478bd9Sstevel@tonic-gate short ul_preempt; /* no_preempt()/preempt() */ 5157c478bd9Sstevel@tonic-gate short ul_savpreempt; /* pre-existing preempt value */ 5167c478bd9Sstevel@tonic-gate char ul_sigsuspend; /* thread is in sigsuspend/pollsys */ 5177c478bd9Sstevel@tonic-gate char ul_main; /* thread is the main thread */ 5187c478bd9Sstevel@tonic-gate char ul_fork; /* thread is performing a fork */ 5197c478bd9Sstevel@tonic-gate char ul_primarymap; /* primary link-map is initialized */ 5207c478bd9Sstevel@tonic-gate /* per-thread copies of the corresponding global variables */ 5215d1dd9a9Sraf uint8_t ul_max_spinners; /* thread_max_spinners */ 5227c478bd9Sstevel@tonic-gate char ul_door_noreserve; /* thread_door_noreserve */ 5237c478bd9Sstevel@tonic-gate char ul_queue_fifo; /* thread_queue_fifo */ 5247c478bd9Sstevel@tonic-gate char ul_cond_wait_defer; /* thread_cond_wait_defer */ 5257c478bd9Sstevel@tonic-gate char ul_error_detection; /* thread_error_detection */ 5267c478bd9Sstevel@tonic-gate char ul_async_safe; /* thread_async_safe */ 527a574db85Sraf char ul_pad1; 528a574db85Sraf char ul_save_state; /* bind_guard() interface to ld.so.1 */ 5297c478bd9Sstevel@tonic-gate int ul_adaptive_spin; /* thread_adaptive_spin */ 5307c478bd9Sstevel@tonic-gate int ul_queue_spin; /* thread_queue_spin */ 5317c478bd9Sstevel@tonic-gate volatile int ul_critical; /* non-zero == in a critical region */ 5327c478bd9Sstevel@tonic-gate int ul_sigdefer; /* non-zero == defer signals */ 5337c478bd9Sstevel@tonic-gate int ul_vfork; /* thread is the child of vfork() */ 5347c478bd9Sstevel@tonic-gate int ul_cancelable; /* _cancelon()/_canceloff() */ 5357c478bd9Sstevel@tonic-gate char ul_cancel_pending; /* pthread_cancel() was called */ 5367c478bd9Sstevel@tonic-gate char ul_cancel_disabled; /* PTHREAD_CANCEL_DISABLE */ 5377c478bd9Sstevel@tonic-gate char ul_cancel_async; /* PTHREAD_CANCEL_ASYNCHRONOUS */ 5387c478bd9Sstevel@tonic-gate char ul_save_async; /* saved copy of ul_cancel_async */ 5397c478bd9Sstevel@tonic-gate char ul_mutator; /* lwp is a mutator (java interface) */ 5407c478bd9Sstevel@tonic-gate char ul_created; /* created suspended */ 5417c478bd9Sstevel@tonic-gate char ul_replace; /* replacement; must be free()d */ 5427c478bd9Sstevel@tonic-gate uchar_t ul_nocancel; /* cancellation can't happen */ 5437c478bd9Sstevel@tonic-gate int ul_errno; /* per-thread errno */ 5447c478bd9Sstevel@tonic-gate int *ul_errnop; /* pointer to errno or self->ul_errno */ 5457c478bd9Sstevel@tonic-gate __cleanup_t *ul_clnup_hdr; /* head of cleanup handlers list */ 5467c478bd9Sstevel@tonic-gate uberflags_t *volatile ul_schedctl_called; /* ul_schedctl is set up */ 5477c478bd9Sstevel@tonic-gate volatile sc_shared_t *volatile ul_schedctl; /* schedctl data */ 5487c478bd9Sstevel@tonic-gate int ul_bindflags; /* bind_guard() interface to ld.so.1 */ 549a574db85Sraf uint_t ul_libc_locks; /* count of cancel_safe_mutex_lock()s */ 5507c478bd9Sstevel@tonic-gate tsd_t *ul_stsd; /* slow TLS for keys >= TSD_NFAST */ 5517c478bd9Sstevel@tonic-gate void *ul_ftsd[TSD_NFAST]; /* fast TLS for keys < TSD_NFAST */ 5527c478bd9Sstevel@tonic-gate td_evbuf_t ul_td_evbuf; /* event buffer */ 5537c478bd9Sstevel@tonic-gate char ul_td_events_enable; /* event mechanism enabled */ 5547c478bd9Sstevel@tonic-gate char ul_sync_obj_reg; /* tdb_sync_obj_register() */ 5557c478bd9Sstevel@tonic-gate char ul_qtype; /* MX or CV */ 5567c478bd9Sstevel@tonic-gate char ul_cv_wake; /* != 0: just wake up, don't requeue */ 5577c478bd9Sstevel@tonic-gate int ul_usropts; /* flags given to thr_create() */ 5587c478bd9Sstevel@tonic-gate void *(*ul_startpc)(void *); /* start func (thr_create()) */ 5597c478bd9Sstevel@tonic-gate void *ul_startarg; /* argument for start function */ 5607c478bd9Sstevel@tonic-gate void *ul_wchan; /* synch object when sleeping */ 5617c478bd9Sstevel@tonic-gate struct ulwp *ul_link; /* sleep queue link */ 5627c478bd9Sstevel@tonic-gate queue_head_t *ul_sleepq; /* sleep queue thread is waiting on */ 5637c478bd9Sstevel@tonic-gate mutex_t *ul_cvmutex; /* mutex dropped when waiting on a cv */ 5647c478bd9Sstevel@tonic-gate mxchain_t *ul_mxchain; /* chain of owned ceiling mutexes */ 5657c478bd9Sstevel@tonic-gate pri_t ul_epri; /* effective scheduling priority */ 5667c478bd9Sstevel@tonic-gate pri_t ul_emappedpri; /* effective mapped priority */ 567883492d5Sraf uint_t ul_rdlockcnt; /* # entries in ul_readlock array */ 568883492d5Sraf /* 0 means there is but a single entry */ 569883492d5Sraf union { /* single entry or pointer to array */ 5707c478bd9Sstevel@tonic-gate readlock_t single; 5717c478bd9Sstevel@tonic-gate readlock_t *array; 5727c478bd9Sstevel@tonic-gate } ul_readlock; 573883492d5Sraf uint_t ul_heldlockcnt; /* # entries in ul_heldlocks array */ 574883492d5Sraf /* 0 means there is but a single entry */ 575883492d5Sraf union { /* single entry or pointer to array */ 576883492d5Sraf mutex_t *single; 577883492d5Sraf mutex_t **array; 578883492d5Sraf } ul_heldlocks; 5797c478bd9Sstevel@tonic-gate /* PROBE_SUPPORT begin */ 5807c478bd9Sstevel@tonic-gate void *ul_tpdp; 5817c478bd9Sstevel@tonic-gate /* PROBE_SUPPORT end */ 5827c478bd9Sstevel@tonic-gate ucontext_t *ul_siglink; /* pointer to previous context */ 5837c478bd9Sstevel@tonic-gate uint_t ul_spin_lock_spin; /* spin lock statistics */ 5847c478bd9Sstevel@tonic-gate uint_t ul_spin_lock_spin2; 5857c478bd9Sstevel@tonic-gate uint_t ul_spin_lock_sleep; 5867c478bd9Sstevel@tonic-gate uint_t ul_spin_lock_wakeup; 5877c478bd9Sstevel@tonic-gate /* the following members *must* be last in the structure */ 5887c478bd9Sstevel@tonic-gate /* they are discarded when ulwp is replaced on thr_exit() */ 5897c478bd9Sstevel@tonic-gate sigset_t ul_sigmask; /* thread's current signal mask */ 5907c478bd9Sstevel@tonic-gate sigset_t ul_tmpmask; /* signal mask for sigsuspend/pollsys */ 5917c478bd9Sstevel@tonic-gate siginfo_t ul_siginfo; /* deferred siginfo */ 5927c478bd9Sstevel@tonic-gate mutex_t ul_spinlock; /* used when suspending/continuing */ 5937c478bd9Sstevel@tonic-gate fpuenv_t ul_fpuenv; /* floating point state */ 5947c478bd9Sstevel@tonic-gate uintptr_t ul_sp; /* stack pointer when blocked */ 5957c478bd9Sstevel@tonic-gate void *ul_ex_unwind; /* address of _ex_unwind() or -1 */ 5967c478bd9Sstevel@tonic-gate #if defined(sparc) 5977c478bd9Sstevel@tonic-gate void *ul_unwind_ret; /* used only by _ex_clnup_handler() */ 5987c478bd9Sstevel@tonic-gate #endif 5997c478bd9Sstevel@tonic-gate } ulwp_t; 6007c478bd9Sstevel@tonic-gate 6017c478bd9Sstevel@tonic-gate #define ul_cursig ul_cp.s.cursig /* deferred signal number */ 6027c478bd9Sstevel@tonic-gate #define ul_pleasestop ul_cp.s.pleasestop /* lwp requested to stop */ 6037c478bd9Sstevel@tonic-gate #define ul_curplease ul_cp.curplease /* for testing both at once */ 6047c478bd9Sstevel@tonic-gate 6057c478bd9Sstevel@tonic-gate /* 6067c478bd9Sstevel@tonic-gate * This is the size of a replacement ulwp, retained only for the benefit 6077c478bd9Sstevel@tonic-gate * of thr_join(). The trailing members are unneeded for this purpose. 6087c478bd9Sstevel@tonic-gate */ 6097c478bd9Sstevel@tonic-gate #define REPLACEMENT_SIZE ((size_t)&((ulwp_t *)NULL)->ul_sigmask) 6107c478bd9Sstevel@tonic-gate 6117c478bd9Sstevel@tonic-gate /* 6127c478bd9Sstevel@tonic-gate * Definitions for static initialization of signal sets, 6137c478bd9Sstevel@tonic-gate * plus some sneaky optimizations in various places. 6147c478bd9Sstevel@tonic-gate */ 6157c478bd9Sstevel@tonic-gate 6167c478bd9Sstevel@tonic-gate #define SIGMASK(sig) ((uint32_t)1 << (((sig) - 1) & (32 - 1))) 6177c478bd9Sstevel@tonic-gate 6187c478bd9Sstevel@tonic-gate #if (MAXSIG > 32 && MAXSIG <= 64) 6197c478bd9Sstevel@tonic-gate #define FILLSET0 0xffffffffu 6207c478bd9Sstevel@tonic-gate #define FILLSET1 ((1u << (MAXSIG - 32)) - 1) 6217c478bd9Sstevel@tonic-gate #else 6227c478bd9Sstevel@tonic-gate #error "fix me: MAXSIG out of bounds" 6237c478bd9Sstevel@tonic-gate #endif 6247c478bd9Sstevel@tonic-gate 6257c478bd9Sstevel@tonic-gate #define CANTMASK0 (SIGMASK(SIGKILL) | SIGMASK(SIGSTOP)) 6267c478bd9Sstevel@tonic-gate #define CANTMASK1 0 6277c478bd9Sstevel@tonic-gate 6287c478bd9Sstevel@tonic-gate #define MASKSET0 (FILLSET0 & ~CANTMASK0) 6297c478bd9Sstevel@tonic-gate #define MASKSET1 (FILLSET1 & ~CANTMASK1) 6307c478bd9Sstevel@tonic-gate 631f841f6adSraf extern const sigset_t maskset; /* set of all maskable signals */ 6327c478bd9Sstevel@tonic-gate 6337c478bd9Sstevel@tonic-gate extern int thread_adaptive_spin; 6347c478bd9Sstevel@tonic-gate extern uint_t thread_max_spinners; 6357c478bd9Sstevel@tonic-gate extern int thread_queue_spin; 6367c478bd9Sstevel@tonic-gate extern int thread_queue_fifo; 6377c478bd9Sstevel@tonic-gate extern int thread_queue_dump; 6387c478bd9Sstevel@tonic-gate extern int thread_cond_wait_defer; 6397c478bd9Sstevel@tonic-gate extern int thread_async_safe; 6407c478bd9Sstevel@tonic-gate extern int thread_queue_verify; 6417c478bd9Sstevel@tonic-gate 6427c478bd9Sstevel@tonic-gate /* 6437c478bd9Sstevel@tonic-gate * pthread_atfork() related data, used to store atfork handlers. 6447c478bd9Sstevel@tonic-gate */ 6457c478bd9Sstevel@tonic-gate typedef struct atfork { 6467c478bd9Sstevel@tonic-gate struct atfork *forw; /* forward pointer */ 6477c478bd9Sstevel@tonic-gate struct atfork *back; /* backward pointer */ 6487c478bd9Sstevel@tonic-gate void (*prepare)(void); /* pre-fork handler */ 6497c478bd9Sstevel@tonic-gate void (*parent)(void); /* post-fork parent handler */ 6507c478bd9Sstevel@tonic-gate void (*child)(void); /* post-fork child handler */ 6517c478bd9Sstevel@tonic-gate } atfork_t; 6527c478bd9Sstevel@tonic-gate 653883492d5Sraf /* 654883492d5Sraf * Element in the table of registered process robust locks. 655883492d5Sraf * We keep track of these to make sure that we only call 656883492d5Sraf * ___lwp_mutex_register() once for each such lock. 657883492d5Sraf */ 658883492d5Sraf typedef struct robust { 659883492d5Sraf struct robust *robust_next; 660883492d5Sraf mutex_t *robust_lock; 661883492d5Sraf } robust_t; 662883492d5Sraf 663883492d5Sraf /* 664883492d5Sraf * Parameters of the lock registration hash table. 665883492d5Sraf */ 666883492d5Sraf #define LOCKSHIFT 9 /* number of hashing bits */ 667883492d5Sraf #define LOCKHASHSZ (1 << LOCKSHIFT) /* power of 2 (1<<9 == 512) */ 668883492d5Sraf #define LOCK_HASH(addr) (uint_t) \ 669883492d5Sraf ((((uintptr_t)(addr) >> 3) \ 670883492d5Sraf ^ ((uintptr_t)(addr) >> (LOCKSHIFT + 3))) \ 671883492d5Sraf & (LOCKHASHSZ - 1)) 672883492d5Sraf 6737c478bd9Sstevel@tonic-gate /* 6747c478bd9Sstevel@tonic-gate * Make our hot locks reside on private cache lines (64 bytes). 6757c478bd9Sstevel@tonic-gate */ 6767c478bd9Sstevel@tonic-gate typedef struct { 6777c478bd9Sstevel@tonic-gate mutex_t pad_lock; 6782e145884Sraf char pad_pad[64 - sizeof (mutex_t)]; 6797c478bd9Sstevel@tonic-gate } pad_lock_t; 6807c478bd9Sstevel@tonic-gate 6812e145884Sraf /* 6822e145884Sraf * Make our semi-hot locks reside on semi-private cache lines (32 bytes). 6832e145884Sraf */ 6842e145884Sraf typedef struct { 6852e145884Sraf mutex_t pad_lock; 6862e145884Sraf char pad_pad[32 - sizeof (mutex_t)]; 6872e145884Sraf } pad32_lock_t; 6882e145884Sraf 6897c478bd9Sstevel@tonic-gate /* 6907c478bd9Sstevel@tonic-gate * The threads hash table is used for fast lookup and locking of an active 6917c478bd9Sstevel@tonic-gate * thread structure (ulwp_t) given a thread-id. It is an N-element array of 6927c478bd9Sstevel@tonic-gate * thr_hash_table_t structures, where N == 1 before the main thread creates 6937c478bd9Sstevel@tonic-gate * the first additional thread and N == 1024 afterwards. Each element of the 6947c478bd9Sstevel@tonic-gate * table is 64 bytes in size and alignment to reduce cache conflicts. 6957c478bd9Sstevel@tonic-gate */ 6967c478bd9Sstevel@tonic-gate typedef struct { 6977c478bd9Sstevel@tonic-gate mutex_t hash_lock; /* lock per bucket */ 6987c478bd9Sstevel@tonic-gate cond_t hash_cond; /* convar per bucket */ 6997c478bd9Sstevel@tonic-gate ulwp_t *hash_bucket; /* hash bucket points to the list of ulwps */ 7007c478bd9Sstevel@tonic-gate char hash_pad[64 - /* pad out to 64 bytes */ 7017c478bd9Sstevel@tonic-gate (sizeof (mutex_t) + sizeof (cond_t) + sizeof (ulwp_t *))]; 7027c478bd9Sstevel@tonic-gate } thr_hash_table_t; 7037c478bd9Sstevel@tonic-gate 7047c478bd9Sstevel@tonic-gate #ifdef _SYSCALL32 7057c478bd9Sstevel@tonic-gate typedef struct { 7067c478bd9Sstevel@tonic-gate mutex_t hash_lock; 7077c478bd9Sstevel@tonic-gate cond_t hash_cond; 7087c478bd9Sstevel@tonic-gate caddr32_t hash_bucket; 7097c478bd9Sstevel@tonic-gate char hash_pad[64 - 7107c478bd9Sstevel@tonic-gate (sizeof (mutex_t) + sizeof (cond_t) + sizeof (caddr32_t))]; 7117c478bd9Sstevel@tonic-gate } thr_hash_table32_t; 7127c478bd9Sstevel@tonic-gate #endif /* _SYSCALL32 */ 7137c478bd9Sstevel@tonic-gate 7147c478bd9Sstevel@tonic-gate 7157c478bd9Sstevel@tonic-gate /* 71641efec22Sraf * siguaction members have 128-byte size and 64-byte alignment. 71741efec22Sraf * We know that sizeof (struct sigaction) is 32 bytes for both 71841efec22Sraf * _ILP32 and _LP64 and that sizeof (rwlock_t) is 64 bytes. 7197c478bd9Sstevel@tonic-gate */ 7207c478bd9Sstevel@tonic-gate typedef struct { 72141efec22Sraf rwlock_t sig_lock; 7227c478bd9Sstevel@tonic-gate struct sigaction sig_uaction; 72341efec22Sraf char sig_pad[128 - sizeof (rwlock_t) - sizeof (struct sigaction)]; 7247c478bd9Sstevel@tonic-gate } siguaction_t; 7257c478bd9Sstevel@tonic-gate 7267c478bd9Sstevel@tonic-gate #ifdef _SYSCALL32 7277c478bd9Sstevel@tonic-gate typedef struct { 72841efec22Sraf rwlock_t sig_lock; 7297c478bd9Sstevel@tonic-gate struct sigaction32 sig_uaction; 73041efec22Sraf char sig_pad[128 - sizeof (rwlock_t) - sizeof (struct sigaction32)]; 7317c478bd9Sstevel@tonic-gate } siguaction32_t; 7327c478bd9Sstevel@tonic-gate #endif /* _SYSCALL32 */ 7337c478bd9Sstevel@tonic-gate 7347c478bd9Sstevel@tonic-gate 7357c478bd9Sstevel@tonic-gate /* 7367c478bd9Sstevel@tonic-gate * Bucket structures, used by lmalloc()/lfree(). 7377c478bd9Sstevel@tonic-gate * See port/threads/alloc.c for details. 7387c478bd9Sstevel@tonic-gate * A bucket's size and alignment is 64 bytes. 7397c478bd9Sstevel@tonic-gate */ 7407c478bd9Sstevel@tonic-gate typedef struct { 7417c478bd9Sstevel@tonic-gate mutex_t bucket_lock; /* protects the free list allocations */ 7427c478bd9Sstevel@tonic-gate void *free_list; /* LIFO list of blocks to allocate/free */ 7437c478bd9Sstevel@tonic-gate size_t chunks; /* number of 64K blocks mmap()ed last time */ 7447c478bd9Sstevel@tonic-gate char pad64[64 - /* pad out to 64 bytes */ 7457c478bd9Sstevel@tonic-gate (sizeof (mutex_t) + sizeof (void *) + sizeof (size_t))]; 7467c478bd9Sstevel@tonic-gate } bucket_t; 7477c478bd9Sstevel@tonic-gate 7487c478bd9Sstevel@tonic-gate #ifdef _SYSCALL32 7497c478bd9Sstevel@tonic-gate typedef struct { 7507c478bd9Sstevel@tonic-gate mutex_t bucket_lock; 7517c478bd9Sstevel@tonic-gate caddr32_t free_list; 7527c478bd9Sstevel@tonic-gate size32_t chunks; 7537c478bd9Sstevel@tonic-gate char pad64[64 - /* pad out to 64 bytes */ 7547c478bd9Sstevel@tonic-gate (sizeof (mutex_t) + sizeof (caddr32_t) + sizeof (size32_t))]; 7557c478bd9Sstevel@tonic-gate } bucket32_t; 7567c478bd9Sstevel@tonic-gate #endif /* _SYSCALL32 */ 7577c478bd9Sstevel@tonic-gate 7587c478bd9Sstevel@tonic-gate #define NBUCKETS 10 /* sizes ranging from 64 to 32768 */ 7597c478bd9Sstevel@tonic-gate 7607c478bd9Sstevel@tonic-gate 7617c478bd9Sstevel@tonic-gate /* 7627c478bd9Sstevel@tonic-gate * atexit() data structures. 7637c478bd9Sstevel@tonic-gate * See port/gen/atexit.c for details. 7647c478bd9Sstevel@tonic-gate */ 7657c478bd9Sstevel@tonic-gate typedef void (*_exithdlr_func_t) (void); 7667c478bd9Sstevel@tonic-gate 7677c478bd9Sstevel@tonic-gate typedef struct _exthdlr { 7687c478bd9Sstevel@tonic-gate struct _exthdlr *next; /* next in handler list */ 7697c478bd9Sstevel@tonic-gate _exithdlr_func_t hdlr; /* handler itself */ 7707c478bd9Sstevel@tonic-gate } _exthdlr_t; 7717c478bd9Sstevel@tonic-gate 7727c478bd9Sstevel@tonic-gate typedef struct { 7737c478bd9Sstevel@tonic-gate mutex_t exitfns_lock; 7747c478bd9Sstevel@tonic-gate _exthdlr_t *head; 7757c478bd9Sstevel@tonic-gate void *exit_frame_monitor; 7767c478bd9Sstevel@tonic-gate char exit_pad[64 - /* pad out to 64 bytes */ 7777c478bd9Sstevel@tonic-gate (sizeof (mutex_t) + sizeof (_exthdlr_t *) + sizeof (void *))]; 7787c478bd9Sstevel@tonic-gate } atexit_root_t; 7797c478bd9Sstevel@tonic-gate 7807c478bd9Sstevel@tonic-gate #ifdef _SYSCALL32 7817c478bd9Sstevel@tonic-gate typedef struct { 7827c478bd9Sstevel@tonic-gate mutex_t exitfns_lock; 7837c478bd9Sstevel@tonic-gate caddr32_t head; 7847c478bd9Sstevel@tonic-gate caddr32_t exit_frame_monitor; 7857c478bd9Sstevel@tonic-gate char exit_pad[64 - /* pad out to 64 bytes */ 7867c478bd9Sstevel@tonic-gate (sizeof (mutex_t) + sizeof (caddr32_t) + sizeof (caddr32_t))]; 7877c478bd9Sstevel@tonic-gate } atexit_root32_t; 7887c478bd9Sstevel@tonic-gate #endif /* _SYSCALL32 */ 7897c478bd9Sstevel@tonic-gate 7907c478bd9Sstevel@tonic-gate 7917c478bd9Sstevel@tonic-gate /* 7927c478bd9Sstevel@tonic-gate * This is data that is global to all link maps (uberdata, aka super-global). 7937c478bd9Sstevel@tonic-gate */ 7947c478bd9Sstevel@tonic-gate typedef struct uberdata { 7957c478bd9Sstevel@tonic-gate pad_lock_t _link_lock; 7962e145884Sraf pad32_lock_t _fork_lock; 7972e145884Sraf pad32_lock_t _atfork_lock; 79898c1a6b4Sraf pad32_lock_t _callout_lock; 79998c1a6b4Sraf pad32_lock_t _tdb_hash_lock; 8007c478bd9Sstevel@tonic-gate tdb_sync_stats_t tdb_hash_lock_stats; 8017c478bd9Sstevel@tonic-gate siguaction_t siguaction[NSIG]; 8027c478bd9Sstevel@tonic-gate bucket_t bucket[NBUCKETS]; 8037c478bd9Sstevel@tonic-gate atexit_root_t atexit_root; 8047c478bd9Sstevel@tonic-gate tsd_metadata_t tsd_metadata; 8057c478bd9Sstevel@tonic-gate tls_metadata_t tls_metadata; 8067c478bd9Sstevel@tonic-gate /* 8077c478bd9Sstevel@tonic-gate * Every object before this point has size and alignment of 64 bytes. 8087c478bd9Sstevel@tonic-gate * Don't add any other type of data before this point. 8097c478bd9Sstevel@tonic-gate */ 8107c478bd9Sstevel@tonic-gate char primary_map; /* set when primary link map is initialized */ 8117c478bd9Sstevel@tonic-gate char bucket_init; /* set when bucket[NBUCKETS] is initialized */ 8127c478bd9Sstevel@tonic-gate char pad[2]; 8137c478bd9Sstevel@tonic-gate uberflags_t uberflags; 8147c478bd9Sstevel@tonic-gate queue_head_t *queue_head; 8157c478bd9Sstevel@tonic-gate thr_hash_table_t *thr_hash_table; 8167c478bd9Sstevel@tonic-gate uint_t hash_size; /* # of entries in thr_hash_table[] */ 8177c478bd9Sstevel@tonic-gate uint_t hash_mask; /* hash_size - 1 */ 8187c478bd9Sstevel@tonic-gate ulwp_t *ulwp_one; /* main thread */ 8197c478bd9Sstevel@tonic-gate ulwp_t *all_lwps; /* circular ul_forw/ul_back list of live lwps */ 8207c478bd9Sstevel@tonic-gate ulwp_t *all_zombies; /* circular ul_forw/ul_back list of zombies */ 8217c478bd9Sstevel@tonic-gate int nthreads; /* total number of live threads/lwps */ 8227c478bd9Sstevel@tonic-gate int nzombies; /* total number of zombie threads */ 8237c478bd9Sstevel@tonic-gate int ndaemons; /* total number of THR_DAEMON threads/lwps */ 8247c478bd9Sstevel@tonic-gate pid_t pid; /* the current process's pid */ 8257c478bd9Sstevel@tonic-gate void (*sigacthandler)(int, siginfo_t *, void *); 8267c478bd9Sstevel@tonic-gate ulwp_t *lwp_stacks; 8277c478bd9Sstevel@tonic-gate ulwp_t *lwp_laststack; 8287c478bd9Sstevel@tonic-gate int nfreestack; 8297c478bd9Sstevel@tonic-gate int thread_stack_cache; 8307c478bd9Sstevel@tonic-gate ulwp_t *ulwp_freelist; 8317c478bd9Sstevel@tonic-gate ulwp_t *ulwp_lastfree; 8327c478bd9Sstevel@tonic-gate ulwp_t *ulwp_replace_free; 8337c478bd9Sstevel@tonic-gate ulwp_t *ulwp_replace_last; 8347c478bd9Sstevel@tonic-gate atfork_t *atforklist; /* circular Q for fork handlers */ 835883492d5Sraf robust_t **robustlocks; /* table of registered robust locks */ 8367c478bd9Sstevel@tonic-gate struct uberdata **tdb_bootstrap; 8377c478bd9Sstevel@tonic-gate tdb_t tdb; /* thread debug interfaces (for libc_db) */ 8387c478bd9Sstevel@tonic-gate } uberdata_t; 8397c478bd9Sstevel@tonic-gate 8407c478bd9Sstevel@tonic-gate #define link_lock _link_lock.pad_lock 8417c478bd9Sstevel@tonic-gate #define fork_lock _fork_lock.pad_lock 8422e145884Sraf #define atfork_lock _atfork_lock.pad_lock 84398c1a6b4Sraf #define callout_lock _callout_lock.pad_lock 8447c478bd9Sstevel@tonic-gate #define tdb_hash_lock _tdb_hash_lock.pad_lock 8457c478bd9Sstevel@tonic-gate 8467c478bd9Sstevel@tonic-gate #pragma align 64(__uberdata) 8477c478bd9Sstevel@tonic-gate extern uberdata_t __uberdata; 8487c478bd9Sstevel@tonic-gate extern uberdata_t **__tdb_bootstrap; /* known to libc_db and mdb */ 8497c478bd9Sstevel@tonic-gate extern int primary_link_map; 8507c478bd9Sstevel@tonic-gate 8517c478bd9Sstevel@tonic-gate #define ulwp_mutex(ulwp, udp) \ 8527c478bd9Sstevel@tonic-gate (&(udp)->thr_hash_table[(ulwp)->ul_ix].hash_lock) 8537c478bd9Sstevel@tonic-gate #define ulwp_condvar(ulwp, udp) \ 8547c478bd9Sstevel@tonic-gate (&(udp)->thr_hash_table[(ulwp)->ul_ix].hash_cond) 8557c478bd9Sstevel@tonic-gate 8567c478bd9Sstevel@tonic-gate /* 8577c478bd9Sstevel@tonic-gate * Grab and release the hash table lock for the specified lwp. 8587c478bd9Sstevel@tonic-gate */ 8597c478bd9Sstevel@tonic-gate #define ulwp_lock(ulwp, udp) lmutex_lock(ulwp_mutex(ulwp, udp)) 8607c478bd9Sstevel@tonic-gate #define ulwp_unlock(ulwp, udp) lmutex_unlock(ulwp_mutex(ulwp, udp)) 8617c478bd9Sstevel@tonic-gate 8627c478bd9Sstevel@tonic-gate #ifdef _SYSCALL32 /* needed by libc_db */ 8637c478bd9Sstevel@tonic-gate 8647c478bd9Sstevel@tonic-gate typedef struct ulwp32 { 8657c478bd9Sstevel@tonic-gate #if defined(__sparc) 8667c478bd9Sstevel@tonic-gate uint32_t ul_dinstr; /* scratch space for dtrace */ 8677c478bd9Sstevel@tonic-gate uint32_t ul_padsparc0[15]; 8687c478bd9Sstevel@tonic-gate uint32_t ul_dsave; /* dtrace: save %g1, %g0, %sp */ 8697c478bd9Sstevel@tonic-gate uint32_t ul_drestore; /* dtrace: restore %g0, %g0, %g0 */ 8707c478bd9Sstevel@tonic-gate uint32_t ul_dftret; /* dtrace: return probe fasttrap */ 8717c478bd9Sstevel@tonic-gate uint32_t ul_dreturn; /* dtrace: return %o0 */ 8727c478bd9Sstevel@tonic-gate #endif 8737c478bd9Sstevel@tonic-gate caddr32_t ul_self; /* pointer to self */ 8740ec57554Sraf #if defined(__x86) 8757c478bd9Sstevel@tonic-gate uint8_t ul_dinstr[40]; /* scratch space for dtrace */ 8767c478bd9Sstevel@tonic-gate #endif 8777c478bd9Sstevel@tonic-gate caddr32_t ul_uberdata; /* uber (super-global) data */ 8787c478bd9Sstevel@tonic-gate tls32_t ul_tls; /* dynamic thread-local storage base */ 8797c478bd9Sstevel@tonic-gate caddr32_t ul_forw; /* forw, back all_lwps list, */ 8807c478bd9Sstevel@tonic-gate caddr32_t ul_back; /* protected by link_lock */ 8817c478bd9Sstevel@tonic-gate caddr32_t ul_next; /* list to keep track of stacks */ 8827c478bd9Sstevel@tonic-gate caddr32_t ul_hash; /* hash chain linked list */ 8837c478bd9Sstevel@tonic-gate caddr32_t ul_rval; /* return value from thr_exit() */ 8847c478bd9Sstevel@tonic-gate caddr32_t ul_stk; /* mapping base of the stack */ 8857c478bd9Sstevel@tonic-gate size32_t ul_mapsiz; /* mapping size of the stack */ 8867c478bd9Sstevel@tonic-gate size32_t ul_guardsize; /* normally _lpagesize */ 8877c478bd9Sstevel@tonic-gate caddr32_t ul_stktop; /* broken thr_stksegment() interface */ 8887c478bd9Sstevel@tonic-gate size32_t ul_stksiz; /* broken thr_stksegment() interface */ 8897c478bd9Sstevel@tonic-gate stack32_t ul_ustack; /* current stack boundaries */ 8907c478bd9Sstevel@tonic-gate int ul_ix; /* hash index */ 8917c478bd9Sstevel@tonic-gate lwpid_t ul_lwpid; /* thread id, aka the lwp id */ 8927c478bd9Sstevel@tonic-gate pri_t ul_pri; /* priority known to the library */ 8937c478bd9Sstevel@tonic-gate pri_t ul_mappedpri; /* priority known to the application */ 8947c478bd9Sstevel@tonic-gate char ul_policy; /* scheduling policy */ 8957c478bd9Sstevel@tonic-gate char ul_pri_mapped; /* != 0 means ul_mappedpri is valid */ 8967c478bd9Sstevel@tonic-gate union { 8977c478bd9Sstevel@tonic-gate struct { 8987c478bd9Sstevel@tonic-gate char cursig; /* deferred signal number */ 8997c478bd9Sstevel@tonic-gate char pleasestop; /* lwp requested to stop itself */ 9007c478bd9Sstevel@tonic-gate } s; 9017c478bd9Sstevel@tonic-gate short curplease; /* for testing both at once */ 9027c478bd9Sstevel@tonic-gate } ul_cp; 9037c478bd9Sstevel@tonic-gate char ul_stop; /* reason for stopping */ 9047c478bd9Sstevel@tonic-gate char ul_signalled; /* this lwp was cond_signal()d */ 9057c478bd9Sstevel@tonic-gate char ul_dead; /* this lwp has called thr_exit */ 9067c478bd9Sstevel@tonic-gate char ul_unwind; /* posix: unwind C++ stack */ 9077c478bd9Sstevel@tonic-gate char ul_detached; /* THR_DETACHED at thread_create() */ 9087c478bd9Sstevel@tonic-gate /* or pthread_detach() was called */ 9097c478bd9Sstevel@tonic-gate char ul_writer; /* sleeping in rw_wrlock() */ 9107c478bd9Sstevel@tonic-gate char ul_stopping; /* set by curthread: stopping self */ 91134709573Sraf char ul_cancel_prologue; /* for _cancel_prologue() */ 9127c478bd9Sstevel@tonic-gate short ul_preempt; /* no_preempt()/preempt() */ 9137c478bd9Sstevel@tonic-gate short ul_savpreempt; /* pre-existing preempt value */ 9147c478bd9Sstevel@tonic-gate char ul_sigsuspend; /* thread is in sigsuspend/pollsys */ 9157c478bd9Sstevel@tonic-gate char ul_main; /* thread is the main thread */ 9167c478bd9Sstevel@tonic-gate char ul_fork; /* thread is performing a fork */ 9177c478bd9Sstevel@tonic-gate char ul_primarymap; /* primary link-map is initialized */ 9187c478bd9Sstevel@tonic-gate /* per-thread copies of the corresponding global variables */ 9195d1dd9a9Sraf uint8_t ul_max_spinners; /* thread_max_spinners */ 9207c478bd9Sstevel@tonic-gate char ul_door_noreserve; /* thread_door_noreserve */ 9217c478bd9Sstevel@tonic-gate char ul_queue_fifo; /* thread_queue_fifo */ 9227c478bd9Sstevel@tonic-gate char ul_cond_wait_defer; /* thread_cond_wait_defer */ 9237c478bd9Sstevel@tonic-gate char ul_error_detection; /* thread_error_detection */ 9247c478bd9Sstevel@tonic-gate char ul_async_safe; /* thread_async_safe */ 925a574db85Sraf char ul_pad1; 926a574db85Sraf char ul_save_state; /* bind_guard() interface to ld.so.1 */ 9277c478bd9Sstevel@tonic-gate int ul_adaptive_spin; /* thread_adaptive_spin */ 9287c478bd9Sstevel@tonic-gate int ul_queue_spin; /* thread_queue_spin */ 9297c478bd9Sstevel@tonic-gate int ul_critical; /* non-zero == in a critical region */ 9307c478bd9Sstevel@tonic-gate int ul_sigdefer; /* non-zero == defer signals */ 9317c478bd9Sstevel@tonic-gate int ul_vfork; /* thread is the child of vfork() */ 9327c478bd9Sstevel@tonic-gate int ul_cancelable; /* _cancelon()/_canceloff() */ 9337c478bd9Sstevel@tonic-gate char ul_cancel_pending; /* pthread_cancel() was called */ 9347c478bd9Sstevel@tonic-gate char ul_cancel_disabled; /* PTHREAD_CANCEL_DISABLE */ 9357c478bd9Sstevel@tonic-gate char ul_cancel_async; /* PTHREAD_CANCEL_ASYNCHRONOUS */ 9367c478bd9Sstevel@tonic-gate char ul_save_async; /* saved copy of ul_cancel_async */ 9377c478bd9Sstevel@tonic-gate char ul_mutator; /* lwp is a mutator (java interface) */ 9387c478bd9Sstevel@tonic-gate char ul_created; /* created suspended */ 9397c478bd9Sstevel@tonic-gate char ul_replace; /* replacement; must be free()d */ 9407c478bd9Sstevel@tonic-gate uchar_t ul_nocancel; /* cancellation can't happen */ 9417c478bd9Sstevel@tonic-gate int ul_errno; /* per-thread errno */ 9427c478bd9Sstevel@tonic-gate caddr32_t ul_errnop; /* pointer to errno or self->ul_errno */ 9437c478bd9Sstevel@tonic-gate caddr32_t ul_clnup_hdr; /* head of cleanup handlers list */ 9447c478bd9Sstevel@tonic-gate caddr32_t ul_schedctl_called; /* ul_schedctl is set up */ 9457c478bd9Sstevel@tonic-gate caddr32_t ul_schedctl; /* schedctl data */ 9467c478bd9Sstevel@tonic-gate int ul_bindflags; /* bind_guard() interface to ld.so.1 */ 947a574db85Sraf uint_t ul_libc_locks; /* count of cancel_safe_mutex_lock()s */ 9487c478bd9Sstevel@tonic-gate caddr32_t ul_stsd; /* slow TLS for keys >= TSD_NFAST */ 9497c478bd9Sstevel@tonic-gate caddr32_t ul_ftsd[TSD_NFAST]; /* fast TLS for keys < TSD_NFAST */ 9507c478bd9Sstevel@tonic-gate td_evbuf32_t ul_td_evbuf; /* event buffer */ 9517c478bd9Sstevel@tonic-gate char ul_td_events_enable; /* event mechanism enabled */ 9527c478bd9Sstevel@tonic-gate char ul_sync_obj_reg; /* tdb_sync_obj_register() */ 9537c478bd9Sstevel@tonic-gate char ul_qtype; /* MX or CV */ 9547c478bd9Sstevel@tonic-gate char ul_cv_wake; /* != 0: just wake up, don't requeue */ 9557c478bd9Sstevel@tonic-gate int ul_usropts; /* flags given to thr_create() */ 9567c478bd9Sstevel@tonic-gate caddr32_t ul_startpc; /* start func (thr_create()) */ 9577c478bd9Sstevel@tonic-gate caddr32_t ul_startarg; /* argument for start function */ 9587c478bd9Sstevel@tonic-gate caddr32_t ul_wchan; /* synch object when sleeping */ 9597c478bd9Sstevel@tonic-gate caddr32_t ul_link; /* sleep queue link */ 9607c478bd9Sstevel@tonic-gate caddr32_t ul_sleepq; /* sleep queue thread is waiting on */ 9617c478bd9Sstevel@tonic-gate caddr32_t ul_cvmutex; /* mutex dropped when waiting on a cv */ 9627c478bd9Sstevel@tonic-gate caddr32_t ul_mxchain; /* chain of owned ceiling mutexes */ 9637c478bd9Sstevel@tonic-gate pri_t ul_epri; /* effective scheduling priority */ 9647c478bd9Sstevel@tonic-gate pri_t ul_emappedpri; /* effective mapped priority */ 965883492d5Sraf uint_t ul_rdlockcnt; /* # entries in ul_readlock array */ 966883492d5Sraf /* 0 means there is but a single entry */ 967883492d5Sraf union { /* single entry or pointer to array */ 9687c478bd9Sstevel@tonic-gate readlock32_t single; 9697c478bd9Sstevel@tonic-gate caddr32_t array; 9707c478bd9Sstevel@tonic-gate } ul_readlock; 971883492d5Sraf uint_t ul_heldlockcnt; /* # entries in ul_heldlocks array */ 972883492d5Sraf /* 0 means there is but a single entry */ 973883492d5Sraf union { /* single entry or pointer to array */ 974883492d5Sraf caddr32_t single; 975883492d5Sraf caddr32_t array; 976883492d5Sraf } ul_heldlocks; 9777c478bd9Sstevel@tonic-gate /* PROBE_SUPPORT begin */ 9787c478bd9Sstevel@tonic-gate caddr32_t ul_tpdp; 9797c478bd9Sstevel@tonic-gate /* PROBE_SUPPORT end */ 9807c478bd9Sstevel@tonic-gate caddr32_t ul_siglink; /* pointer to previous context */ 9817c478bd9Sstevel@tonic-gate uint_t ul_spin_lock_spin; /* spin lock statistics */ 9827c478bd9Sstevel@tonic-gate uint_t ul_spin_lock_spin2; 9837c478bd9Sstevel@tonic-gate uint_t ul_spin_lock_sleep; 9847c478bd9Sstevel@tonic-gate uint_t ul_spin_lock_wakeup; 9857c478bd9Sstevel@tonic-gate /* the following members *must* be last in the structure */ 9867c478bd9Sstevel@tonic-gate /* they are discarded when ulwp is replaced on thr_exit() */ 9877c478bd9Sstevel@tonic-gate sigset32_t ul_sigmask; /* thread's current signal mask */ 9887c478bd9Sstevel@tonic-gate sigset32_t ul_tmpmask; /* signal mask for sigsuspend/pollsys */ 9897c478bd9Sstevel@tonic-gate siginfo32_t ul_siginfo; /* deferred siginfo */ 9907c478bd9Sstevel@tonic-gate mutex_t ul_spinlock; /* used when suspending/continuing */ 9917c478bd9Sstevel@tonic-gate fpuenv32_t ul_fpuenv; /* floating point state */ 9927c478bd9Sstevel@tonic-gate caddr32_t ul_sp; /* stack pointer when blocked */ 9937c478bd9Sstevel@tonic-gate #if defined(sparc) 9947c478bd9Sstevel@tonic-gate caddr32_t ul_unwind_ret; /* used only by _ex_clnup_handler() */ 9957c478bd9Sstevel@tonic-gate #endif 9967c478bd9Sstevel@tonic-gate } ulwp32_t; 9977c478bd9Sstevel@tonic-gate 9987c478bd9Sstevel@tonic-gate #define REPLACEMENT_SIZE32 ((size_t)&((ulwp32_t *)NULL)->ul_sigmask) 9997c478bd9Sstevel@tonic-gate 10007c478bd9Sstevel@tonic-gate typedef struct uberdata32 { 10017c478bd9Sstevel@tonic-gate pad_lock_t _link_lock; 10022e145884Sraf pad32_lock_t _fork_lock; 10032e145884Sraf pad32_lock_t _atfork_lock; 100498c1a6b4Sraf pad32_lock_t _callout_lock; 100598c1a6b4Sraf pad32_lock_t _tdb_hash_lock; 10067c478bd9Sstevel@tonic-gate tdb_sync_stats_t tdb_hash_lock_stats; 10077c478bd9Sstevel@tonic-gate siguaction32_t siguaction[NSIG]; 10087c478bd9Sstevel@tonic-gate bucket32_t bucket[NBUCKETS]; 10097c478bd9Sstevel@tonic-gate atexit_root32_t atexit_root; 10107c478bd9Sstevel@tonic-gate tsd_metadata32_t tsd_metadata; 10117c478bd9Sstevel@tonic-gate tls_metadata32_t tls_metadata; 10127c478bd9Sstevel@tonic-gate char primary_map; 10137c478bd9Sstevel@tonic-gate char bucket_init; 10147c478bd9Sstevel@tonic-gate char pad[2]; 10157c478bd9Sstevel@tonic-gate uberflags_t uberflags; 10167c478bd9Sstevel@tonic-gate caddr32_t queue_head; 10177c478bd9Sstevel@tonic-gate caddr32_t thr_hash_table; 10187c478bd9Sstevel@tonic-gate uint_t hash_size; 10197c478bd9Sstevel@tonic-gate uint_t hash_mask; 10207c478bd9Sstevel@tonic-gate caddr32_t ulwp_one; 10217c478bd9Sstevel@tonic-gate caddr32_t all_lwps; 10227c478bd9Sstevel@tonic-gate caddr32_t all_zombies; 10237c478bd9Sstevel@tonic-gate int nthreads; 10247c478bd9Sstevel@tonic-gate int nzombies; 10257c478bd9Sstevel@tonic-gate int ndaemons; 10267c478bd9Sstevel@tonic-gate int pid; 10277c478bd9Sstevel@tonic-gate caddr32_t sigacthandler; 10287c478bd9Sstevel@tonic-gate caddr32_t lwp_stacks; 10297c478bd9Sstevel@tonic-gate caddr32_t lwp_laststack; 10307c478bd9Sstevel@tonic-gate int nfreestack; 10317c478bd9Sstevel@tonic-gate int thread_stack_cache; 10327c478bd9Sstevel@tonic-gate caddr32_t ulwp_freelist; 10337c478bd9Sstevel@tonic-gate caddr32_t ulwp_lastfree; 10347c478bd9Sstevel@tonic-gate caddr32_t ulwp_replace_free; 10357c478bd9Sstevel@tonic-gate caddr32_t ulwp_replace_last; 10367c478bd9Sstevel@tonic-gate caddr32_t atforklist; 1037883492d5Sraf caddr32_t robustlocks; 10387c478bd9Sstevel@tonic-gate caddr32_t tdb_bootstrap; 10397c478bd9Sstevel@tonic-gate tdb32_t tdb; 10407c478bd9Sstevel@tonic-gate } uberdata32_t; 10417c478bd9Sstevel@tonic-gate 10427c478bd9Sstevel@tonic-gate #endif /* _SYSCALL32 */ 10437c478bd9Sstevel@tonic-gate 10447c478bd9Sstevel@tonic-gate /* ul_stop values */ 10457c478bd9Sstevel@tonic-gate #define TSTP_REGULAR 0x01 /* Stopped by thr_suspend() */ 10467c478bd9Sstevel@tonic-gate #define TSTP_MUTATOR 0x08 /* stopped by thr_suspend_*mutator*() */ 10477c478bd9Sstevel@tonic-gate #define TSTP_FORK 0x20 /* stopped by suspend_fork() */ 10487c478bd9Sstevel@tonic-gate 10497c478bd9Sstevel@tonic-gate /* 10507c478bd9Sstevel@tonic-gate * Implementation-specific attribute types for pthread_mutexattr_init() etc. 10517c478bd9Sstevel@tonic-gate */ 10527c478bd9Sstevel@tonic-gate 10537c478bd9Sstevel@tonic-gate typedef struct _cvattr { 10547c478bd9Sstevel@tonic-gate int pshared; 10557c478bd9Sstevel@tonic-gate clockid_t clockid; 10567c478bd9Sstevel@tonic-gate } cvattr_t; 10577c478bd9Sstevel@tonic-gate 10587c478bd9Sstevel@tonic-gate typedef struct _mattr { 10597c478bd9Sstevel@tonic-gate int pshared; 10607c478bd9Sstevel@tonic-gate int protocol; 10617c478bd9Sstevel@tonic-gate int prioceiling; 10627c478bd9Sstevel@tonic-gate int type; 10637c478bd9Sstevel@tonic-gate int robustness; 10647c478bd9Sstevel@tonic-gate } mattr_t; 10657c478bd9Sstevel@tonic-gate 10667c478bd9Sstevel@tonic-gate typedef struct _thrattr { 10677c478bd9Sstevel@tonic-gate size_t stksize; 10687c478bd9Sstevel@tonic-gate void *stkaddr; 10697c478bd9Sstevel@tonic-gate int detachstate; 107034709573Sraf int daemonstate; 10717c478bd9Sstevel@tonic-gate int scope; 10727c478bd9Sstevel@tonic-gate int prio; 10737c478bd9Sstevel@tonic-gate int policy; 10747c478bd9Sstevel@tonic-gate int inherit; 10757c478bd9Sstevel@tonic-gate size_t guardsize; 10767c478bd9Sstevel@tonic-gate } thrattr_t; 10777c478bd9Sstevel@tonic-gate 10787c478bd9Sstevel@tonic-gate typedef struct _rwlattr { 10797c478bd9Sstevel@tonic-gate int pshared; 10807c478bd9Sstevel@tonic-gate } rwlattr_t; 10817c478bd9Sstevel@tonic-gate 10827c478bd9Sstevel@tonic-gate /* _curthread() is inline for speed */ 10837c478bd9Sstevel@tonic-gate extern ulwp_t *_curthread(void); 10847c478bd9Sstevel@tonic-gate #define curthread (_curthread()) 10857c478bd9Sstevel@tonic-gate 10867c478bd9Sstevel@tonic-gate /* this version (also inline) can be tested for NULL */ 10877c478bd9Sstevel@tonic-gate extern ulwp_t *__curthread(void); 10887c478bd9Sstevel@tonic-gate 10897c478bd9Sstevel@tonic-gate /* get the current stack pointer (also inline) */ 10907c478bd9Sstevel@tonic-gate extern greg_t stkptr(void); 10917c478bd9Sstevel@tonic-gate 10927c478bd9Sstevel@tonic-gate /* 10937c478bd9Sstevel@tonic-gate * Suppress __attribute__((...)) if we are not compiling with gcc 10947c478bd9Sstevel@tonic-gate */ 10957c478bd9Sstevel@tonic-gate #if !defined(__GNUC__) 10967c478bd9Sstevel@tonic-gate #define __attribute__(string) 10977c478bd9Sstevel@tonic-gate #endif 10987c478bd9Sstevel@tonic-gate 10997c478bd9Sstevel@tonic-gate /* 11007c478bd9Sstevel@tonic-gate * Implementation functions. Not visible outside of the library itself. 11017c478bd9Sstevel@tonic-gate */ 1102f841f6adSraf extern int __nanosleep(const timespec_t *, timespec_t *); 11037c478bd9Sstevel@tonic-gate extern void getgregs(ulwp_t *, gregset_t); 11047c478bd9Sstevel@tonic-gate extern void setgregs(ulwp_t *, gregset_t); 11057c478bd9Sstevel@tonic-gate extern void thr_panic(const char *); 11067c478bd9Sstevel@tonic-gate #pragma rarely_called(thr_panic) 11077c478bd9Sstevel@tonic-gate extern ulwp_t *find_lwp(thread_t); 11087c478bd9Sstevel@tonic-gate extern int real_priority(ulwp_t *); 11097c478bd9Sstevel@tonic-gate extern void finish_init(void); 11107c478bd9Sstevel@tonic-gate extern void queue_alloc(void); 11117c478bd9Sstevel@tonic-gate extern void tsd_exit(void); 11127c478bd9Sstevel@tonic-gate extern void tsd_free(ulwp_t *); 11137c478bd9Sstevel@tonic-gate extern void tls_setup(void); 11147c478bd9Sstevel@tonic-gate extern void tls_exit(void); 11157c478bd9Sstevel@tonic-gate extern void tls_free(ulwp_t *); 11167c478bd9Sstevel@tonic-gate extern void rwl_free(ulwp_t *); 1117883492d5Sraf extern void heldlock_exit(void); 1118883492d5Sraf extern void heldlock_free(ulwp_t *); 11197c478bd9Sstevel@tonic-gate extern void sigacthandler(int, siginfo_t *, void *); 11207c478bd9Sstevel@tonic-gate extern void signal_init(void); 11217c478bd9Sstevel@tonic-gate extern int sigequalset(const sigset_t *, const sigset_t *); 11227c478bd9Sstevel@tonic-gate extern void mutex_setup(void); 11237c478bd9Sstevel@tonic-gate extern void take_deferred_signal(int); 11247c478bd9Sstevel@tonic-gate extern int setup_context(ucontext_t *, void *(*func)(ulwp_t *), 11257c478bd9Sstevel@tonic-gate ulwp_t *ulwp, caddr_t stk, size_t stksize); 11267c478bd9Sstevel@tonic-gate extern volatile sc_shared_t *setup_schedctl(void); 11277c478bd9Sstevel@tonic-gate extern void *lmalloc(size_t); 11287c478bd9Sstevel@tonic-gate extern void lfree(void *, size_t); 11297c478bd9Sstevel@tonic-gate extern void *libc_malloc(size_t); 11307c478bd9Sstevel@tonic-gate extern void *libc_realloc(void *, size_t); 11317c478bd9Sstevel@tonic-gate extern void libc_free(void *); 11327c478bd9Sstevel@tonic-gate extern char *libc_strdup(const char *); 11337c478bd9Sstevel@tonic-gate extern void ultos(uint64_t, int, char *); 11347c478bd9Sstevel@tonic-gate extern void lock_error(const mutex_t *, const char *, void *, const char *); 11357c478bd9Sstevel@tonic-gate extern void rwlock_error(const rwlock_t *, const char *, const char *); 11367c478bd9Sstevel@tonic-gate extern void thread_error(const char *); 11377c478bd9Sstevel@tonic-gate extern void grab_assert_lock(void); 11387c478bd9Sstevel@tonic-gate extern void dump_queue_statistics(void); 11397c478bd9Sstevel@tonic-gate extern void collect_queue_statistics(void); 11407c478bd9Sstevel@tonic-gate extern void record_spin_locks(ulwp_t *); 1141883492d5Sraf extern void remember_lock(mutex_t *); 1142883492d5Sraf extern void forget_lock(mutex_t *); 1143883492d5Sraf extern void register_lock(mutex_t *); 1144883492d5Sraf extern void unregister_locks(void); 11457c478bd9Sstevel@tonic-gate #if defined(__sparc) 11467c478bd9Sstevel@tonic-gate extern void _flush_windows(void); 11477c478bd9Sstevel@tonic-gate #else 11487c478bd9Sstevel@tonic-gate #define _flush_windows() 11497c478bd9Sstevel@tonic-gate #endif 11507c478bd9Sstevel@tonic-gate extern void set_curthread(void *); 11517c478bd9Sstevel@tonic-gate 115241efec22Sraf /* 1153883492d5Sraf * Utility function used when waking up many threads (more than MAXLWPS) 1154883492d5Sraf * all at once. See mutex_wakeup_all(), cond_broadcast(), and rw_unlock(). 115541efec22Sraf */ 115641efec22Sraf #define MAXLWPS 128 /* max remembered lwpids before overflow */ 115741efec22Sraf #define NEWLWPS 2048 /* max remembered lwpids at first overflow */ 115841efec22Sraf extern lwpid_t *alloc_lwpids(lwpid_t *, int *, int *); 115941efec22Sraf 11607c478bd9Sstevel@tonic-gate /* enter a critical section */ 11617c478bd9Sstevel@tonic-gate #define enter_critical(self) (self->ul_critical++) 11627c478bd9Sstevel@tonic-gate 11637c478bd9Sstevel@tonic-gate /* exit a critical section, take deferred actions if necessary */ 11647c478bd9Sstevel@tonic-gate extern void do_exit_critical(void); 11657c478bd9Sstevel@tonic-gate #define exit_critical(self) \ 11667c478bd9Sstevel@tonic-gate (void) (self->ul_critical--, \ 11677c478bd9Sstevel@tonic-gate ((self->ul_curplease && self->ul_critical == 0)? \ 11687c478bd9Sstevel@tonic-gate (do_exit_critical(), 0) : 0)) 11697c478bd9Sstevel@tonic-gate 11707c478bd9Sstevel@tonic-gate /* 11717c478bd9Sstevel@tonic-gate * Like enter_critical()/exit_critical() but just for deferring signals. 11727c478bd9Sstevel@tonic-gate * Unlike enter_critical()/exit_critical(), ul_sigdefer may be set while 11737c478bd9Sstevel@tonic-gate * calling application functions like constructors and destructors. 11747c478bd9Sstevel@tonic-gate * Care must be taken if the application function attempts to set 11757c478bd9Sstevel@tonic-gate * the signal mask while a deferred signal is present; the setting 11767c478bd9Sstevel@tonic-gate * of the signal mask must also be deferred. 11777c478bd9Sstevel@tonic-gate */ 11787c478bd9Sstevel@tonic-gate #define sigoff(self) (self->ul_sigdefer++) 11797c478bd9Sstevel@tonic-gate extern void sigon(ulwp_t *); 11807c478bd9Sstevel@tonic-gate 11817c478bd9Sstevel@tonic-gate /* these are exported functions */ 11827c478bd9Sstevel@tonic-gate extern void _sigoff(void); 11837c478bd9Sstevel@tonic-gate extern void _sigon(void); 11847c478bd9Sstevel@tonic-gate 11857c478bd9Sstevel@tonic-gate #define sigorset(s1, s2) \ 11867c478bd9Sstevel@tonic-gate (((s1)->__sigbits[0] |= (s2)->__sigbits[0]), \ 11877c478bd9Sstevel@tonic-gate ((s1)->__sigbits[1] |= (s2)->__sigbits[1]), \ 11887c478bd9Sstevel@tonic-gate ((s1)->__sigbits[2] |= (s2)->__sigbits[2]), \ 11897c478bd9Sstevel@tonic-gate ((s1)->__sigbits[3] |= (s2)->__sigbits[3])) 11907c478bd9Sstevel@tonic-gate 11917c478bd9Sstevel@tonic-gate #define sigandset(s1, s2) \ 11927c478bd9Sstevel@tonic-gate (((s1)->__sigbits[0] &= (s2)->__sigbits[0]), \ 11937c478bd9Sstevel@tonic-gate ((s1)->__sigbits[1] &= (s2)->__sigbits[1]), \ 11947c478bd9Sstevel@tonic-gate ((s1)->__sigbits[2] &= (s2)->__sigbits[2]), \ 11957c478bd9Sstevel@tonic-gate ((s1)->__sigbits[3] &= (s2)->__sigbits[3])) 11967c478bd9Sstevel@tonic-gate 11977c478bd9Sstevel@tonic-gate #define sigdiffset(s1, s2) \ 11987c478bd9Sstevel@tonic-gate (((s1)->__sigbits[0] &= ~(s2)->__sigbits[0]), \ 11997c478bd9Sstevel@tonic-gate ((s1)->__sigbits[1] &= ~(s2)->__sigbits[1]), \ 12007c478bd9Sstevel@tonic-gate ((s1)->__sigbits[2] &= ~(s2)->__sigbits[2]), \ 12017c478bd9Sstevel@tonic-gate ((s1)->__sigbits[3] &= ~(s2)->__sigbits[3])) 12027c478bd9Sstevel@tonic-gate 12037c478bd9Sstevel@tonic-gate #define delete_reserved_signals(s) \ 12047c478bd9Sstevel@tonic-gate (((s)->__sigbits[0] &= MASKSET0), \ 12057c478bd9Sstevel@tonic-gate ((s)->__sigbits[1] &= (MASKSET1 & ~SIGMASK(SIGCANCEL))),\ 12067c478bd9Sstevel@tonic-gate ((s)->__sigbits[2] = 0), \ 12077c478bd9Sstevel@tonic-gate ((s)->__sigbits[3] = 0)) 12087c478bd9Sstevel@tonic-gate 12097c478bd9Sstevel@tonic-gate extern void block_all_signals(ulwp_t *self); 12107c478bd9Sstevel@tonic-gate 12117c478bd9Sstevel@tonic-gate /* 12127c478bd9Sstevel@tonic-gate * When restoring the signal mask after having previously called 12137c478bd9Sstevel@tonic-gate * block_all_signals(), if we have a deferred signal present then 12147c478bd9Sstevel@tonic-gate * do nothing other than ASSERT() that we are in a critical region. 12157c478bd9Sstevel@tonic-gate * The signal mask will be set when we emerge from the critical region 12167c478bd9Sstevel@tonic-gate * and call take_deferred_signal(). There is no race condition here 12177c478bd9Sstevel@tonic-gate * because the kernel currently has all signals blocked for this thread. 12187c478bd9Sstevel@tonic-gate */ 12197c478bd9Sstevel@tonic-gate #define restore_signals(self) \ 12207c478bd9Sstevel@tonic-gate ((void) ((self)->ul_cursig? \ 12217c478bd9Sstevel@tonic-gate (ASSERT((self)->ul_critical + (self)->ul_sigdefer != 0), 0) : \ 12227c478bd9Sstevel@tonic-gate __lwp_sigmask(SIG_SETMASK, &(self)->ul_sigmask, NULL))) 12237c478bd9Sstevel@tonic-gate 1224a574db85Sraf extern void set_cancel_pending_flag(ulwp_t *, int); 1225a574db85Sraf extern void set_cancel_eintr_flag(ulwp_t *); 12267c478bd9Sstevel@tonic-gate extern void set_parking_flag(ulwp_t *, int); 1227a574db85Sraf extern int cancel_active(void); 12287c478bd9Sstevel@tonic-gate 12297c478bd9Sstevel@tonic-gate extern void *_thr_setup(ulwp_t *); 12307c478bd9Sstevel@tonic-gate extern void _fpinherit(ulwp_t *); 12317c478bd9Sstevel@tonic-gate extern void _lwp_start(void); 12327c478bd9Sstevel@tonic-gate extern void _lwp_terminate(void); 12337c478bd9Sstevel@tonic-gate extern void lmutex_lock(mutex_t *); 1234f841f6adSraf extern void lmutex_unlock(mutex_t *); 123541efec22Sraf extern void lrw_rdlock(rwlock_t *); 123641efec22Sraf extern void lrw_wrlock(rwlock_t *); 123741efec22Sraf extern void lrw_unlock(rwlock_t *); 1238f841f6adSraf extern void sig_mutex_lock(mutex_t *); 1239f841f6adSraf extern void sig_mutex_unlock(mutex_t *); 1240f841f6adSraf extern int sig_mutex_trylock(mutex_t *); 1241f841f6adSraf extern int sig_cond_wait(cond_t *, mutex_t *); 1242f841f6adSraf extern int sig_cond_reltimedwait(cond_t *, mutex_t *, const timespec_t *); 1243a574db85Sraf extern void cancel_safe_mutex_lock(mutex_t *); 1244a574db85Sraf extern void cancel_safe_mutex_unlock(mutex_t *); 1245a574db85Sraf extern int cancel_safe_mutex_trylock(mutex_t *); 12467c478bd9Sstevel@tonic-gate extern void _prefork_handler(void); 12477c478bd9Sstevel@tonic-gate extern void _postfork_parent_handler(void); 12487c478bd9Sstevel@tonic-gate extern void _postfork_child_handler(void); 1249f841f6adSraf extern void postfork1_child(void); 1250f841f6adSraf extern void postfork1_child_aio(void); 1251f841f6adSraf extern void postfork1_child_sigev_aio(void); 1252f841f6adSraf extern void postfork1_child_sigev_mq(void); 1253f841f6adSraf extern void postfork1_child_sigev_timer(void); 1254f841f6adSraf extern void postfork1_child_tpool(void); 12552e145884Sraf extern void fork_lock_enter(void); 12567c478bd9Sstevel@tonic-gate extern void fork_lock_exit(void); 12577c478bd9Sstevel@tonic-gate extern void suspend_fork(void); 12587c478bd9Sstevel@tonic-gate extern void continue_fork(int); 12597c478bd9Sstevel@tonic-gate extern void do_sigcancel(void); 1260f841f6adSraf extern void setup_cancelsig(int); 1261f841f6adSraf extern void init_sigev_thread(void); 1262f841f6adSraf extern void init_aio(void); 12637c478bd9Sstevel@tonic-gate extern void _cancelon(void); 12647c478bd9Sstevel@tonic-gate extern void _canceloff(void); 12657c478bd9Sstevel@tonic-gate extern void _canceloff_nocancel(void); 1266f841f6adSraf extern void _cancel_prologue(void); 1267f841f6adSraf extern void _cancel_epilogue(void); 12687c478bd9Sstevel@tonic-gate extern void no_preempt(ulwp_t *); 12697c478bd9Sstevel@tonic-gate extern void preempt(ulwp_t *); 12707c478bd9Sstevel@tonic-gate extern void _thrp_unwind(void *); 12717c478bd9Sstevel@tonic-gate 12727c478bd9Sstevel@tonic-gate /* 12737c478bd9Sstevel@tonic-gate * Prototypes for the strong versions of the interface functions 12747c478bd9Sstevel@tonic-gate */ 1275657b1f3dSraf extern pid_t __forkx(int); 1276657b1f3dSraf extern pid_t __forkallx(int); 12777c478bd9Sstevel@tonic-gate extern pid_t _private_getpid(void); 12787c478bd9Sstevel@tonic-gate extern uid_t _private_geteuid(void); 12797c478bd9Sstevel@tonic-gate extern int _kill(pid_t, int); 1280a574db85Sraf extern int _private_open(const char *, int, ...); 1281a574db85Sraf extern int _private_close(int); 1282a574db85Sraf extern ssize_t __read(int, void *, size_t); 1283a574db85Sraf extern ssize_t __write(int, const void *, size_t); 12847c478bd9Sstevel@tonic-gate extern void *_memcpy(void *, const void *, size_t); 12857c478bd9Sstevel@tonic-gate extern void *_memset(void *, int, size_t); 128634709573Sraf extern int _memcmp(const void *, const void *, size_t); 12877c478bd9Sstevel@tonic-gate extern void *_private_memcpy(void *, const void *, size_t); 12887c478bd9Sstevel@tonic-gate extern void *_private_memset(void *, int, size_t); 12897c478bd9Sstevel@tonic-gate extern int _private_sigfillset(sigset_t *); 12907c478bd9Sstevel@tonic-gate extern int _private_sigemptyset(sigset_t *); 12917c478bd9Sstevel@tonic-gate extern int _private_sigaddset(sigset_t *, int); 12927c478bd9Sstevel@tonic-gate extern int _private_sigdelset(sigset_t *, int); 12937c478bd9Sstevel@tonic-gate extern int _private_sigismember(sigset_t *, int); 12947c478bd9Sstevel@tonic-gate extern void *_private_mmap(void *, size_t, int, int, int, off_t); 12957c478bd9Sstevel@tonic-gate extern int _private_mprotect(void *, size_t, int); 12967c478bd9Sstevel@tonic-gate extern int _private_munmap(void *, size_t); 12977c478bd9Sstevel@tonic-gate extern int _private_getrlimit(int, struct rlimit *); 12987c478bd9Sstevel@tonic-gate extern int __lwp_continue(lwpid_t); 12997c478bd9Sstevel@tonic-gate extern int __lwp_create(ucontext_t *, uint_t, lwpid_t *); 13007c478bd9Sstevel@tonic-gate extern int __lwp_kill(lwpid_t, int); 13017c478bd9Sstevel@tonic-gate extern lwpid_t __lwp_self(void); 13027c478bd9Sstevel@tonic-gate extern int ___lwp_suspend(lwpid_t); 13037c478bd9Sstevel@tonic-gate extern void lwp_yield(void); 13047c478bd9Sstevel@tonic-gate extern int lwp_wait(lwpid_t, lwpid_t *); 13057c478bd9Sstevel@tonic-gate extern int __lwp_wait(lwpid_t, lwpid_t *); 13067c478bd9Sstevel@tonic-gate extern int __lwp_detach(lwpid_t); 13077c478bd9Sstevel@tonic-gate extern sc_shared_t *__schedctl(void); 13087c478bd9Sstevel@tonic-gate 13097c478bd9Sstevel@tonic-gate extern int _private_setcontext(const ucontext_t *); 13107c478bd9Sstevel@tonic-gate extern int _private_getcontext(ucontext_t *); 13117c478bd9Sstevel@tonic-gate #pragma unknown_control_flow(_private_getcontext) 13127c478bd9Sstevel@tonic-gate /* actual system call traps */ 13137c478bd9Sstevel@tonic-gate extern int __setcontext_syscall(const ucontext_t *); 13147c478bd9Sstevel@tonic-gate extern int __getcontext_syscall(ucontext_t *); 13157c478bd9Sstevel@tonic-gate extern int _private_setustack(stack_t *); 13167c478bd9Sstevel@tonic-gate extern int __clock_gettime(clockid_t, timespec_t *); 13177c478bd9Sstevel@tonic-gate extern void abstime_to_reltime(clockid_t, const timespec_t *, timespec_t *); 13187c478bd9Sstevel@tonic-gate extern void hrt2ts(hrtime_t, timespec_t *); 13197c478bd9Sstevel@tonic-gate 13207c478bd9Sstevel@tonic-gate extern int __sigaction(int, const struct sigaction *, struct sigaction *); 13217c478bd9Sstevel@tonic-gate extern int __lwp_sigmask(int, const sigset_t *, sigset_t *); 13227c478bd9Sstevel@tonic-gate extern void __sighndlr(int, siginfo_t *, ucontext_t *, void (*)()); 13237c478bd9Sstevel@tonic-gate extern caddr_t __sighndlrend; 13247c478bd9Sstevel@tonic-gate #pragma unknown_control_flow(__sighndlr) 1325f841f6adSraf extern void _siglongjmp(sigjmp_buf, int); 13267c478bd9Sstevel@tonic-gate 1327f841f6adSraf extern int _pthread_setspecific(pthread_key_t, const void *); 1328f841f6adSraf extern void *_pthread_getspecific(pthread_key_t); 13297c478bd9Sstevel@tonic-gate extern void _pthread_exit(void *); 1330a574db85Sraf extern int _pthread_setcancelstate(int, int *); 1331f841f6adSraf extern void _private_testcancel(void); 1332f841f6adSraf 1333f841f6adSraf /* belongs in <pthread.h> */ 1334f841f6adSraf #define PTHREAD_CREATE_DAEMON_NP 0x100 /* = THR_DAEMON */ 1335f841f6adSraf #define PTHREAD_CREATE_NONDAEMON_NP 0 1336f841f6adSraf extern int _pthread_attr_setdaemonstate_np(pthread_attr_t *, int); 1337f841f6adSraf extern int _pthread_attr_getdaemonstate_np(const pthread_attr_t *, int *); 13387c478bd9Sstevel@tonic-gate 13397c478bd9Sstevel@tonic-gate /* these are private to the library */ 13407c478bd9Sstevel@tonic-gate extern int _private_mutex_init(mutex_t *, int, void *); 13417c478bd9Sstevel@tonic-gate extern int _private_mutex_destroy(mutex_t *); 13427c478bd9Sstevel@tonic-gate extern int _private_mutex_lock(mutex_t *); 13437c478bd9Sstevel@tonic-gate extern int _private_mutex_trylock(mutex_t *); 13447c478bd9Sstevel@tonic-gate extern int _private_mutex_unlock(mutex_t *); 13457c478bd9Sstevel@tonic-gate 13467c478bd9Sstevel@tonic-gate extern int _mutex_init(mutex_t *, int, void *); 13477c478bd9Sstevel@tonic-gate extern int _mutex_destroy(mutex_t *); 1348883492d5Sraf extern int _mutex_consistent(mutex_t *); 13497c478bd9Sstevel@tonic-gate extern int _mutex_lock(mutex_t *); 13507c478bd9Sstevel@tonic-gate extern int _mutex_trylock(mutex_t *); 13517c478bd9Sstevel@tonic-gate extern int _mutex_unlock(mutex_t *); 13527c478bd9Sstevel@tonic-gate extern int __mutex_init(mutex_t *, int, void *); 13537c478bd9Sstevel@tonic-gate extern int __mutex_destroy(mutex_t *); 1354883492d5Sraf extern int __mutex_consistent(mutex_t *); 13557c478bd9Sstevel@tonic-gate extern int __mutex_lock(mutex_t *); 13567c478bd9Sstevel@tonic-gate extern int __mutex_trylock(mutex_t *); 13577c478bd9Sstevel@tonic-gate extern int __mutex_unlock(mutex_t *); 13587c478bd9Sstevel@tonic-gate extern int mutex_is_held(mutex_t *); 13597c478bd9Sstevel@tonic-gate 13607c478bd9Sstevel@tonic-gate extern int _cond_init(cond_t *, int, void *); 13617c478bd9Sstevel@tonic-gate extern int _cond_signal(cond_t *); 13627c478bd9Sstevel@tonic-gate extern int _cond_broadcast(cond_t *); 13637c478bd9Sstevel@tonic-gate extern int _cond_destroy(cond_t *); 13647c478bd9Sstevel@tonic-gate extern int cond_signal_internal(cond_t *); 13657c478bd9Sstevel@tonic-gate extern int cond_broadcast_internal(cond_t *); 1366a574db85Sraf /* cancellation points: */ 1367a574db85Sraf extern int _cond_wait(cond_t *, mutex_t *); 1368a574db85Sraf extern int _cond_timedwait(cond_t *, mutex_t *, const timespec_t *); 1369a574db85Sraf extern int _cond_reltimedwait(cond_t *, mutex_t *, const timespec_t *); 1370a574db85Sraf /* not cancellation points: */ 1371a574db85Sraf extern int __cond_wait(cond_t *, mutex_t *); 1372a574db85Sraf extern int __cond_timedwait(cond_t *, mutex_t *, const timespec_t *); 1373a574db85Sraf extern int __cond_reltimedwait(cond_t *, mutex_t *, const timespec_t *); 13747c478bd9Sstevel@tonic-gate 13757c478bd9Sstevel@tonic-gate extern int __rwlock_init(rwlock_t *, int, void *); 13767c478bd9Sstevel@tonic-gate extern int rw_read_is_held(rwlock_t *); 13777c478bd9Sstevel@tonic-gate extern int rw_write_is_held(rwlock_t *); 13787c478bd9Sstevel@tonic-gate 1379cb620785Sraf extern void _membar_enter(void); 1380cb620785Sraf extern void _membar_exit(void); 1381cb620785Sraf extern void _membar_producer(void); 1382cb620785Sraf extern void _membar_consumer(void); 1383cb620785Sraf 13847c478bd9Sstevel@tonic-gate extern int _thr_continue(thread_t); 1385f841f6adSraf extern int _thr_create(void *, size_t, void *(*)(void *), void *, long, 1386f841f6adSraf thread_t *); 1387f841f6adSraf extern int _thrp_create(void *, size_t, void *(*)(void *), void *, long, 1388f841f6adSraf thread_t *, pri_t, int, size_t); 13897c478bd9Sstevel@tonic-gate extern int _thr_getprio(thread_t, int *); 13907c478bd9Sstevel@tonic-gate extern int _thr_getspecific(thread_key_t, void **); 13917c478bd9Sstevel@tonic-gate extern int _thr_join(thread_t, thread_t *, void **); 13927c478bd9Sstevel@tonic-gate extern int _thr_keycreate(thread_key_t *, PFrV); 1393cb620785Sraf extern int _thr_keycreate_once(thread_key_t *, PFrV); 13947c478bd9Sstevel@tonic-gate extern int _thr_key_delete(thread_key_t); 13957c478bd9Sstevel@tonic-gate extern int _thr_main(void); 13967c478bd9Sstevel@tonic-gate extern thread_t _thr_self(void); 13977c478bd9Sstevel@tonic-gate extern int _thr_getconcurrency(void); 13987c478bd9Sstevel@tonic-gate extern int _thr_setconcurrency(int); 13997c478bd9Sstevel@tonic-gate extern int _thr_setprio(thread_t, int); 14007c478bd9Sstevel@tonic-gate extern int _thr_setspecific(thread_key_t, void *); 14017c478bd9Sstevel@tonic-gate extern int _thr_stksegment(stack_t *); 14027c478bd9Sstevel@tonic-gate extern int _thrp_suspend(thread_t, uchar_t); 14037c478bd9Sstevel@tonic-gate extern int _thrp_continue(thread_t, uchar_t); 14047c478bd9Sstevel@tonic-gate extern int _thr_sigsetmask(int, const sigset_t *, sigset_t *); 14057c478bd9Sstevel@tonic-gate 14067c478bd9Sstevel@tonic-gate extern void _thr_terminate(void *); 14077c478bd9Sstevel@tonic-gate extern void _thr_exit(void *); 14087c478bd9Sstevel@tonic-gate extern void _thrp_exit(void); 14097c478bd9Sstevel@tonic-gate 141034709573Sraf extern const thrattr_t *def_thrattr(void); 14117c478bd9Sstevel@tonic-gate extern int _thread_setschedparam_main(pthread_t, int, 14127c478bd9Sstevel@tonic-gate const struct sched_param *, int); 14137c478bd9Sstevel@tonic-gate extern int _validate_rt_prio(int, int); 14147c478bd9Sstevel@tonic-gate extern int _thrp_setlwpprio(lwpid_t, int, int); 1415f841f6adSraf extern pri_t map_rtpri_to_gp(pri_t); 1416f841f6adSraf extern int get_info_by_policy(int); 14177c478bd9Sstevel@tonic-gate 14187c478bd9Sstevel@tonic-gate /* 14197c478bd9Sstevel@tonic-gate * System call wrappers (direct interfaces to the kernel) 14207c478bd9Sstevel@tonic-gate */ 1421883492d5Sraf extern int ___lwp_mutex_register(mutex_t *); 14227c478bd9Sstevel@tonic-gate extern int ___lwp_mutex_trylock(mutex_t *); 14237c478bd9Sstevel@tonic-gate extern int ___lwp_mutex_timedlock(mutex_t *, timespec_t *); 14247c478bd9Sstevel@tonic-gate extern int ___lwp_mutex_unlock(mutex_t *); 1425883492d5Sraf extern int ___lwp_mutex_wakeup(mutex_t *, int); 14267c478bd9Sstevel@tonic-gate extern int ___lwp_cond_wait(cond_t *, mutex_t *, timespec_t *, int); 14277c478bd9Sstevel@tonic-gate extern int __lwp_cond_signal(lwp_cond_t *); 14287c478bd9Sstevel@tonic-gate extern int __lwp_cond_broadcast(lwp_cond_t *); 14297c478bd9Sstevel@tonic-gate extern int ___lwp_sema_timedwait(lwp_sema_t *, timespec_t *, int); 14307c478bd9Sstevel@tonic-gate extern int __lwp_sema_trywait(lwp_sema_t *); 14317c478bd9Sstevel@tonic-gate extern int __lwp_sema_post(lwp_sema_t *); 14327c478bd9Sstevel@tonic-gate extern int __lwp_rwlock_rdlock(rwlock_t *, timespec_t *); 14337c478bd9Sstevel@tonic-gate extern int __lwp_rwlock_wrlock(rwlock_t *, timespec_t *); 14347c478bd9Sstevel@tonic-gate extern int __lwp_rwlock_tryrdlock(rwlock_t *); 14357c478bd9Sstevel@tonic-gate extern int __lwp_rwlock_trywrlock(rwlock_t *); 14367c478bd9Sstevel@tonic-gate extern int __lwp_rwlock_unlock(rwlock_t *); 14377c478bd9Sstevel@tonic-gate extern int __lwp_park(timespec_t *, lwpid_t); 14387c478bd9Sstevel@tonic-gate extern int __lwp_unpark(lwpid_t); 14397c478bd9Sstevel@tonic-gate extern int __lwp_unpark_all(lwpid_t *, int); 14400ec57554Sraf #if defined(__x86) 14417c478bd9Sstevel@tonic-gate extern int ___lwp_private(int, int, void *); 14420ec57554Sraf #endif /* __x86 */ 14437c478bd9Sstevel@tonic-gate 14447c478bd9Sstevel@tonic-gate extern int _private_lwp_mutex_lock(mutex_t *); 14457c478bd9Sstevel@tonic-gate extern int _private_lwp_mutex_unlock(mutex_t *); 14467c478bd9Sstevel@tonic-gate 14477c478bd9Sstevel@tonic-gate /* 14487c478bd9Sstevel@tonic-gate * inlines 14497c478bd9Sstevel@tonic-gate */ 14507c478bd9Sstevel@tonic-gate extern int set_lock_byte(volatile uint8_t *); 145141efec22Sraf extern uint32_t atomic_swap_32(volatile uint32_t *, uint32_t); 145241efec22Sraf extern uint32_t atomic_cas_32(volatile uint32_t *, uint32_t, uint32_t); 145341efec22Sraf extern void atomic_inc_32(volatile uint32_t *); 145441efec22Sraf extern void atomic_dec_32(volatile uint32_t *); 145541efec22Sraf extern void atomic_and_32(volatile uint32_t *, uint32_t); 145641efec22Sraf extern void atomic_or_32(volatile uint32_t *, uint32_t); 14570ec57554Sraf #if defined(__sparc) 14580ec57554Sraf extern ulong_t caller(void); 14590ec57554Sraf extern ulong_t getfp(void); 14600ec57554Sraf #endif /* __sparc */ 14610ec57554Sraf 14620ec57554Sraf #include "thr_inlines.h" 14637c478bd9Sstevel@tonic-gate 14647c478bd9Sstevel@tonic-gate #endif /* _THR_UBERDATA_H */ 1465