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 /* 23*8fd04b83SRoger A. Faulkner * Copyright 2010 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 #include <stdlib.h> 317c478bd9Sstevel@tonic-gate #include <unistd.h> 327c478bd9Sstevel@tonic-gate #include <sys/types.h> 337c478bd9Sstevel@tonic-gate #include <fcntl.h> 347c478bd9Sstevel@tonic-gate #include <string.h> 357c478bd9Sstevel@tonic-gate #include <signal.h> 367c478bd9Sstevel@tonic-gate #include <ucontext.h> 377c478bd9Sstevel@tonic-gate #include <thread.h> 387c478bd9Sstevel@tonic-gate #include <pthread.h> 397257d1b4Sraf #include <atomic.h> 407c478bd9Sstevel@tonic-gate #include <link.h> 417c478bd9Sstevel@tonic-gate #include <sys/resource.h> 427c478bd9Sstevel@tonic-gate #include <sys/lwp.h> 437c478bd9Sstevel@tonic-gate #include <errno.h> 447c478bd9Sstevel@tonic-gate #include <sys/asm_linkage.h> 457c478bd9Sstevel@tonic-gate #include <sys/regset.h> 467c478bd9Sstevel@tonic-gate #include <sys/fcntl.h> 477c478bd9Sstevel@tonic-gate #include <sys/mman.h> 487c478bd9Sstevel@tonic-gate #include <synch.h> 497c478bd9Sstevel@tonic-gate #include <door.h> 507c478bd9Sstevel@tonic-gate #include <limits.h> 517c478bd9Sstevel@tonic-gate #include <sys/synch32.h> 527c478bd9Sstevel@tonic-gate #include <schedctl.h> 537c478bd9Sstevel@tonic-gate #include <sys/priocntl.h> 547c478bd9Sstevel@tonic-gate #include <thread_db.h> 55f841f6adSraf #include <setjmp.h> 567c478bd9Sstevel@tonic-gate #include "libc_int.h" 577c478bd9Sstevel@tonic-gate #include "tdb_agent.h" 58f841f6adSraf #include "thr_debug.h" 5934709573Sraf 607c478bd9Sstevel@tonic-gate /* 617c478bd9Sstevel@tonic-gate * This is an implementation-specific include file for threading support. 627c478bd9Sstevel@tonic-gate * It is not to be seen by the clients of the library. 637c478bd9Sstevel@tonic-gate * 647c478bd9Sstevel@tonic-gate * This file also describes uberdata in libc. 657c478bd9Sstevel@tonic-gate * 667c478bd9Sstevel@tonic-gate * The term "uberdata" refers to data that is unique and visible across 677c478bd9Sstevel@tonic-gate * all link maps. The name is meant to imply that such data is truly 687c478bd9Sstevel@tonic-gate * global, not just locally global to a particular link map. 697c478bd9Sstevel@tonic-gate * 707c478bd9Sstevel@tonic-gate * See the Linker and Libraries Guide for a full description of alternate 717c478bd9Sstevel@tonic-gate * link maps and how they are set up and used. 727c478bd9Sstevel@tonic-gate * 737c478bd9Sstevel@tonic-gate * Alternate link maps implement multiple global namespaces within a single 747c478bd9Sstevel@tonic-gate * process. There may be multiple instances of identical dynamic libraries 757c478bd9Sstevel@tonic-gate * loaded in a process's address space at the same time, each on a different 767c478bd9Sstevel@tonic-gate * link map (as determined by the dynamic linker), each with its own set of 777c478bd9Sstevel@tonic-gate * global variables. Which particular instance of a global variable is seen 787c478bd9Sstevel@tonic-gate * by a thread running in the process is determined by the link map on which 797c478bd9Sstevel@tonic-gate * the thread happens to be executing at the time. 807c478bd9Sstevel@tonic-gate * 817c478bd9Sstevel@tonic-gate * However, there are aspects of a process that are unique across all 827c478bd9Sstevel@tonic-gate * link maps, in particular the structures used to implement threads 837c478bd9Sstevel@tonic-gate * of control (in Sparc terminology, there is only one %g7 regardless 847c478bd9Sstevel@tonic-gate * of the link map on which the thread is executing). 857c478bd9Sstevel@tonic-gate * 867c478bd9Sstevel@tonic-gate * All uberdata is referenced from a base pointer in the thread's ulwp_t 877c478bd9Sstevel@tonic-gate * structure (which is also uberdata). All allocations and deallocations 887c478bd9Sstevel@tonic-gate * of uberdata are made via the uberdata-aware lmalloc() and lfree() 897c478bd9Sstevel@tonic-gate * interfaces (malloc() and free() are simply locally-global). 907c478bd9Sstevel@tonic-gate */ 917c478bd9Sstevel@tonic-gate 927c478bd9Sstevel@tonic-gate /* 937c478bd9Sstevel@tonic-gate * Special libc-private access to errno. 947c478bd9Sstevel@tonic-gate * We do this so that references to errno do not invoke the dynamic linker. 957c478bd9Sstevel@tonic-gate */ 967c478bd9Sstevel@tonic-gate #undef errno 977c478bd9Sstevel@tonic-gate #define errno (*curthread->ul_errnop) 987c478bd9Sstevel@tonic-gate 997c478bd9Sstevel@tonic-gate /* 1007c478bd9Sstevel@tonic-gate * See <sys/synch32.h> for the reasons for these values 1017c478bd9Sstevel@tonic-gate * and why they are different for sparc and intel. 1027c478bd9Sstevel@tonic-gate */ 1037c478bd9Sstevel@tonic-gate #if defined(__sparc) 10431db3c26Sraf 1057c478bd9Sstevel@tonic-gate /* lock.lock64.pad[x] 4 5 6 7 */ 1067c478bd9Sstevel@tonic-gate #define LOCKMASK 0xff000000 1077c478bd9Sstevel@tonic-gate #define WAITERMASK 0x000000ff 1085d1dd9a9Sraf #define SPINNERMASK 0x00ff0000 1095d1dd9a9Sraf #define SPINNERSHIFT 16 1107c478bd9Sstevel@tonic-gate #define WAITER 0x00000001 1117c478bd9Sstevel@tonic-gate #define LOCKSET 0xff 1127c478bd9Sstevel@tonic-gate #define LOCKCLEAR 0 11331db3c26Sraf 11431db3c26Sraf #define PIDSHIFT 32 11531db3c26Sraf #define LOCKMASK64 0xffffffffff000000ULL 11631db3c26Sraf #define LOCKBYTE64 0x00000000ff000000ULL 11731db3c26Sraf #define WAITERMASK64 0x00000000000000ffULL 11831db3c26Sraf #define SPINNERMASK64 0x0000000000ff0000ULL 11931db3c26Sraf 1200ec57554Sraf #elif defined(__x86) 12131db3c26Sraf 1227c478bd9Sstevel@tonic-gate /* lock.lock64.pad[x] 7 6 5 4 */ 1237c478bd9Sstevel@tonic-gate #define LOCKMASK 0xff000000 1247c478bd9Sstevel@tonic-gate #define WAITERMASK 0x00ff0000 1255d1dd9a9Sraf #define SPINNERMASK 0x0000ff00 1265d1dd9a9Sraf #define SPINNERSHIFT 8 1277c478bd9Sstevel@tonic-gate #define WAITER 0x00010000 1287c478bd9Sstevel@tonic-gate #define LOCKSET 0x01 1297c478bd9Sstevel@tonic-gate #define LOCKCLEAR 0 13031db3c26Sraf 13131db3c26Sraf #define PIDSHIFT 0 13231db3c26Sraf #define LOCKMASK64 0xff000000ffffffffULL 13331db3c26Sraf #define LOCKBYTE64 0x0100000000000000ULL 13431db3c26Sraf #define WAITERMASK64 0x00ff000000000000ULL 13531db3c26Sraf #define SPINNERMASK64 0x0000ff0000000000ULL 13631db3c26Sraf 1377c478bd9Sstevel@tonic-gate #else 1380ec57554Sraf #error "neither __sparc nor __x86 is defined" 1397c478bd9Sstevel@tonic-gate #endif 1407c478bd9Sstevel@tonic-gate 1417c478bd9Sstevel@tonic-gate /* 1427c478bd9Sstevel@tonic-gate * Fetch the owner of a USYNC_THREAD mutex. 1437c478bd9Sstevel@tonic-gate * Don't use this with process-shared mutexes; 1447c478bd9Sstevel@tonic-gate * the owing thread may be in a different process. 1457c478bd9Sstevel@tonic-gate */ 1467c478bd9Sstevel@tonic-gate #define MUTEX_OWNER(mp) ((ulwp_t *)(uintptr_t)(mp)->mutex_owner) 1477c478bd9Sstevel@tonic-gate 1487c478bd9Sstevel@tonic-gate /* 149883492d5Sraf * Test if a thread owns a process-private (USYNC_THREAD) mutex. 150883492d5Sraf * This is inappropriate for a process-shared (USYNC_PROCESS) mutex. 1517c478bd9Sstevel@tonic-gate * The 'mp' argument must not have side-effects since it is evaluated twice. 1527c478bd9Sstevel@tonic-gate */ 1537c478bd9Sstevel@tonic-gate #define MUTEX_OWNED(mp, thrp) \ 1547c478bd9Sstevel@tonic-gate ((mp)->mutex_lockw != 0 && MUTEX_OWNER(mp) == thrp) 1557c478bd9Sstevel@tonic-gate 1567c478bd9Sstevel@tonic-gate 1577c478bd9Sstevel@tonic-gate /* 1587c478bd9Sstevel@tonic-gate * uberflags.uf_tdb_register_sync is an interface with libc_db to enable the 1597c478bd9Sstevel@tonic-gate * collection of lock statistics by a debugger or other collecting tool. 1607c478bd9Sstevel@tonic-gate * 1617c478bd9Sstevel@tonic-gate * uberflags.uf_thread_error_detection is set by an environment variable: 1627c478bd9Sstevel@tonic-gate * _THREAD_ERROR_DETECTION 1637c478bd9Sstevel@tonic-gate * 0 == no detection of locking primitive errors. 1647c478bd9Sstevel@tonic-gate * 1 == detect errors and issue a warning message. 1657c478bd9Sstevel@tonic-gate * 2 == detect errors, issue a warning message, and dump core. 1667c478bd9Sstevel@tonic-gate * 1677c478bd9Sstevel@tonic-gate * We bundle these together in uberflags.uf_trs_ted to make a test of either 1687c478bd9Sstevel@tonic-gate * being non-zero a single memory reference (for speed of mutex_lock(), etc). 1697c478bd9Sstevel@tonic-gate * 1707c478bd9Sstevel@tonic-gate * uberflags.uf_mt is set non-zero when the first thread (in addition 1717c478bd9Sstevel@tonic-gate * to the main thread) is created. 1727c478bd9Sstevel@tonic-gate * 1737c478bd9Sstevel@tonic-gate * We bundle all these flags together in uberflags.uf_all to make a test 1747c478bd9Sstevel@tonic-gate * of any being non-zero a single memory reference (again, for speed). 1757c478bd9Sstevel@tonic-gate */ 1767c478bd9Sstevel@tonic-gate typedef union { 1777c478bd9Sstevel@tonic-gate int uf_all; /* combined all flags */ 1787c478bd9Sstevel@tonic-gate struct { 1797c478bd9Sstevel@tonic-gate short h_pad; 1807c478bd9Sstevel@tonic-gate short h_trs_ted; /* combined reg sync & error detect */ 1817c478bd9Sstevel@tonic-gate } uf_h; 1827c478bd9Sstevel@tonic-gate struct { 1837c478bd9Sstevel@tonic-gate char x_mt; 1847c478bd9Sstevel@tonic-gate char x_pad; 1857c478bd9Sstevel@tonic-gate char x_tdb_register_sync; 1867c478bd9Sstevel@tonic-gate char x_thread_error_detection; 1877c478bd9Sstevel@tonic-gate } uf_x; 1887c478bd9Sstevel@tonic-gate } uberflags_t; 1897c478bd9Sstevel@tonic-gate 1907c478bd9Sstevel@tonic-gate #define uf_mt uf_x.x_mt 1917c478bd9Sstevel@tonic-gate #define uf_tdb_register_sync uf_x.x_tdb_register_sync 1927c478bd9Sstevel@tonic-gate #define uf_thread_error_detection uf_x.x_thread_error_detection 1937c478bd9Sstevel@tonic-gate #define uf_trs_ted uf_h.h_trs_ted /* both of the above */ 1947c478bd9Sstevel@tonic-gate 1957c478bd9Sstevel@tonic-gate /* 1967c478bd9Sstevel@tonic-gate * NOTE WELL: 1977c478bd9Sstevel@tonic-gate * To enable further optimization, the "ul_schedctl_called" member 1987c478bd9Sstevel@tonic-gate * of the ulwp_t structure (below) serves double-duty: 1997c478bd9Sstevel@tonic-gate * 1. If NULL, it means that the thread must call __schedctl() 2007c478bd9Sstevel@tonic-gate * to set up its schedctl mappings before acquiring a mutex. 2017c478bd9Sstevel@tonic-gate * This is required by the implementation of adaptive mutex locking. 2027c478bd9Sstevel@tonic-gate * 2. If non-NULL, it points to uberdata.uberflags, so that tests of 2037c478bd9Sstevel@tonic-gate * uberflags can be made without additional memory references. 2047c478bd9Sstevel@tonic-gate * This allows the common case of _mutex_lock() and _mutex_unlock() for 2057c478bd9Sstevel@tonic-gate * USYNC_THREAD mutexes with no error detection and no lock statistics 2067c478bd9Sstevel@tonic-gate * to be optimized for speed. 2077c478bd9Sstevel@tonic-gate */ 2087c478bd9Sstevel@tonic-gate 2097c478bd9Sstevel@tonic-gate /* double the default stack size for 64-bit processes */ 2107c478bd9Sstevel@tonic-gate #ifdef _LP64 2117c478bd9Sstevel@tonic-gate #define MINSTACK (8 * 1024) 2127c478bd9Sstevel@tonic-gate #define DEFAULTSTACK (2 * 1024 * 1024) 2137c478bd9Sstevel@tonic-gate #else 2147c478bd9Sstevel@tonic-gate #define MINSTACK (4 * 1024) 2157c478bd9Sstevel@tonic-gate #define DEFAULTSTACK (1024 * 1024) 2167c478bd9Sstevel@tonic-gate #endif 2177c478bd9Sstevel@tonic-gate 2187c478bd9Sstevel@tonic-gate #define MUTEX_TRY 0 2197c478bd9Sstevel@tonic-gate #define MUTEX_LOCK 1 220d4204c85Sraf #define MUTEX_NOCEIL 0x40 2217c478bd9Sstevel@tonic-gate 2220ec57554Sraf #if defined(__x86) 2237c478bd9Sstevel@tonic-gate 2247c478bd9Sstevel@tonic-gate typedef struct { /* structure returned by fnstenv */ 2257c478bd9Sstevel@tonic-gate int fctrl; /* control word */ 2267c478bd9Sstevel@tonic-gate int fstat; /* status word (flags, etc) */ 2277c478bd9Sstevel@tonic-gate int ftag; /* tag of which regs busy */ 2287c478bd9Sstevel@tonic-gate int misc[4]; /* other stuff, 28 bytes total */ 2297c478bd9Sstevel@tonic-gate } fpuenv_t; 2307c478bd9Sstevel@tonic-gate 2317c478bd9Sstevel@tonic-gate #ifdef _SYSCALL32 2327c478bd9Sstevel@tonic-gate typedef fpuenv_t fpuenv32_t; 2337c478bd9Sstevel@tonic-gate #endif /* _SYSCALL32 */ 2347c478bd9Sstevel@tonic-gate 2357c478bd9Sstevel@tonic-gate #elif defined(__sparc) 2367c478bd9Sstevel@tonic-gate 2377c478bd9Sstevel@tonic-gate typedef struct { /* fp state structure */ 2387c478bd9Sstevel@tonic-gate greg_t fsr; 2397c478bd9Sstevel@tonic-gate greg_t fpu_en; 2407c478bd9Sstevel@tonic-gate } fpuenv_t; 2417c478bd9Sstevel@tonic-gate 2427c478bd9Sstevel@tonic-gate #ifdef _SYSCALL32 2437c478bd9Sstevel@tonic-gate typedef struct { 2447c478bd9Sstevel@tonic-gate greg32_t fsr; 2457c478bd9Sstevel@tonic-gate greg32_t fpu_en; 2467c478bd9Sstevel@tonic-gate } fpuenv32_t; 2477c478bd9Sstevel@tonic-gate #endif /* _SYSCALL32 */ 2487c478bd9Sstevel@tonic-gate 2490ec57554Sraf #endif /* __x86 */ 2507c478bd9Sstevel@tonic-gate 2510ec57554Sraf #if defined(__x86) 2527c478bd9Sstevel@tonic-gate extern void ht_pause(void); /* "pause" instruction */ 2537c478bd9Sstevel@tonic-gate #define SMT_PAUSE() ht_pause() 254b1593d50SJason Beloro #elif defined(SMT_PAUSE_FUNCTION) 255b1593d50SJason Beloro extern void SMT_PAUSE_FUNCTION(void); 256b1593d50SJason Beloro #define SMT_PAUSE() SMT_PAUSE_FUNCTION() 2577c478bd9Sstevel@tonic-gate #else 2587c478bd9Sstevel@tonic-gate #define SMT_PAUSE() 2590ec57554Sraf #endif /* __x86 */ 2607c478bd9Sstevel@tonic-gate 2617c478bd9Sstevel@tonic-gate /* 2627c478bd9Sstevel@tonic-gate * Cleanup handler related data. 2637c478bd9Sstevel@tonic-gate * This structure is exported as _cleanup_t in pthread.h. 2647c478bd9Sstevel@tonic-gate * pthread.h exports only the size of this structure, so check 2657c478bd9Sstevel@tonic-gate * _cleanup_t in pthread.h before making any change here. 2667c478bd9Sstevel@tonic-gate */ 2677c478bd9Sstevel@tonic-gate typedef struct __cleanup { 2687c478bd9Sstevel@tonic-gate struct __cleanup *next; /* pointer to next handler */ 2697c478bd9Sstevel@tonic-gate caddr_t fp; /* current frame pointer */ 2707c478bd9Sstevel@tonic-gate void (*func)(void *); /* cleanup handler address */ 2717c478bd9Sstevel@tonic-gate void *arg; /* handler's argument */ 2727c478bd9Sstevel@tonic-gate } __cleanup_t; 2737c478bd9Sstevel@tonic-gate 2747c478bd9Sstevel@tonic-gate /* 2757c478bd9Sstevel@tonic-gate * Thread-Specific Data (TSD) 2767c478bd9Sstevel@tonic-gate * TSD_NFAST includes the invalid key zero, so there 2777c478bd9Sstevel@tonic-gate * are really only (TSD_NFAST - 1) fast key slots. 2787c478bd9Sstevel@tonic-gate */ 2797c478bd9Sstevel@tonic-gate typedef void (*PFrV)(void *); 2807c478bd9Sstevel@tonic-gate #define TSD_UNALLOCATED ((PFrV)1) 2817c478bd9Sstevel@tonic-gate #define TSD_NFAST 9 2827c478bd9Sstevel@tonic-gate 2837c478bd9Sstevel@tonic-gate /* 2847c478bd9Sstevel@tonic-gate * The tsd union is designed to burn a little memory (9 words) to make 2857c478bd9Sstevel@tonic-gate * lookups blindingly fast. Note that tsd_nalloc could be placed at the 2867c478bd9Sstevel@tonic-gate * end of the pad region to increase the likelihood that it falls on the 2877c478bd9Sstevel@tonic-gate * same cache line as the data. 2887c478bd9Sstevel@tonic-gate */ 2897c478bd9Sstevel@tonic-gate typedef union tsd { 2907c478bd9Sstevel@tonic-gate uint_t tsd_nalloc; /* Amount of allocated storage */ 2917c478bd9Sstevel@tonic-gate void *tsd_pad[TSD_NFAST]; 2927c478bd9Sstevel@tonic-gate void *tsd_data[1]; 2937c478bd9Sstevel@tonic-gate } tsd_t; 2947c478bd9Sstevel@tonic-gate 2957c478bd9Sstevel@tonic-gate typedef struct { 2967c478bd9Sstevel@tonic-gate mutex_t tsdm_lock; /* Lock protecting the data */ 2977c478bd9Sstevel@tonic-gate uint_t tsdm_nkeys; /* Number of allocated keys */ 2987c478bd9Sstevel@tonic-gate uint_t tsdm_nused; /* Number of used keys */ 2997c478bd9Sstevel@tonic-gate PFrV *tsdm_destro; /* Per-key destructors */ 3007c478bd9Sstevel@tonic-gate char tsdm_pad[64 - /* pad to 64 bytes */ 3017c478bd9Sstevel@tonic-gate (sizeof (mutex_t) + 2 * sizeof (uint_t) + sizeof (PFrV *))]; 3027c478bd9Sstevel@tonic-gate } tsd_metadata_t; 3037c478bd9Sstevel@tonic-gate 3047c478bd9Sstevel@tonic-gate #ifdef _SYSCALL32 3057c478bd9Sstevel@tonic-gate typedef union tsd32 { 3067c478bd9Sstevel@tonic-gate uint_t tsd_nalloc; /* Amount of allocated storage */ 3077c478bd9Sstevel@tonic-gate caddr32_t tsd_pad[TSD_NFAST]; 3087c478bd9Sstevel@tonic-gate caddr32_t tsd_data[1]; 3097c478bd9Sstevel@tonic-gate } tsd32_t; 3107c478bd9Sstevel@tonic-gate 3117c478bd9Sstevel@tonic-gate typedef struct { 3127c478bd9Sstevel@tonic-gate mutex_t tsdm_lock; /* Lock protecting the data */ 3137c478bd9Sstevel@tonic-gate uint_t tsdm_nkeys; /* Number of allocated keys */ 3147c478bd9Sstevel@tonic-gate uint_t tsdm_nused; /* Number of used keys */ 3157c478bd9Sstevel@tonic-gate caddr32_t tsdm_destro; /* Per-key destructors */ 3167c478bd9Sstevel@tonic-gate char tsdm_pad[64 - /* pad to 64 bytes */ 3177c478bd9Sstevel@tonic-gate (sizeof (mutex_t) + 2 * sizeof (uint_t) + sizeof (caddr32_t))]; 3187c478bd9Sstevel@tonic-gate } tsd_metadata32_t; 3197c478bd9Sstevel@tonic-gate #endif /* _SYSCALL32 */ 3207c478bd9Sstevel@tonic-gate 3217c478bd9Sstevel@tonic-gate 3227c478bd9Sstevel@tonic-gate /* 3237c478bd9Sstevel@tonic-gate * Thread-Local Storage (TLS) 3247c478bd9Sstevel@tonic-gate */ 3257c478bd9Sstevel@tonic-gate typedef struct { 3267c478bd9Sstevel@tonic-gate void *tls_data; 3277c478bd9Sstevel@tonic-gate size_t tls_size; 3287c478bd9Sstevel@tonic-gate } tls_t; 3297c478bd9Sstevel@tonic-gate 3307c478bd9Sstevel@tonic-gate typedef struct { 3317c478bd9Sstevel@tonic-gate mutex_t tls_lock; /* Lock protecting the data */ 3327c478bd9Sstevel@tonic-gate tls_t tls_modinfo; /* Root of all TLS_modinfo data */ 3337c478bd9Sstevel@tonic-gate tls_t static_tls; /* Template for static TLS */ 3347c478bd9Sstevel@tonic-gate char tls_pad[64 - /* pad to 64 bytes */ 3357c478bd9Sstevel@tonic-gate (sizeof (mutex_t) + 2 * sizeof (tls_t))]; 3367c478bd9Sstevel@tonic-gate } tls_metadata_t; 3377c478bd9Sstevel@tonic-gate 3387c478bd9Sstevel@tonic-gate #ifdef _SYSCALL32 3397c478bd9Sstevel@tonic-gate typedef struct { 3407c478bd9Sstevel@tonic-gate caddr32_t tls_data; 3417c478bd9Sstevel@tonic-gate size32_t tls_size; 3427c478bd9Sstevel@tonic-gate } tls32_t; 3437c478bd9Sstevel@tonic-gate 3447c478bd9Sstevel@tonic-gate typedef struct { 3457c478bd9Sstevel@tonic-gate mutex_t tls_lock; /* Lock protecting the data */ 3467c478bd9Sstevel@tonic-gate tls32_t tls_modinfo; /* Root of all TLS_modinfo data */ 3477c478bd9Sstevel@tonic-gate tls32_t static_tls; /* Template for static TLS */ 3487c478bd9Sstevel@tonic-gate char tls_pad[64 - /* pad to 64 bytes */ 3497c478bd9Sstevel@tonic-gate (sizeof (mutex_t) + 2 * sizeof (tls32_t))]; 3507c478bd9Sstevel@tonic-gate } tls_metadata32_t; 3517c478bd9Sstevel@tonic-gate #endif /* _SYSCALL32 */ 3527c478bd9Sstevel@tonic-gate 3537c478bd9Sstevel@tonic-gate 3547c478bd9Sstevel@tonic-gate /* 355d4204c85Sraf * Sleep queue root for USYNC_THREAD condvars and mutexes. 356d4204c85Sraf * There is a default queue root for each queue head (see below). 357d4204c85Sraf * Also, each ulwp_t contains a queue root that can be used 358d4204c85Sraf * when the thread is enqueued on the queue, if necessary 359d4204c85Sraf * (when more than one wchan hashes to the same queue head). 360d4204c85Sraf */ 361d4204c85Sraf typedef struct queue_root { 362d4204c85Sraf struct queue_root *qr_next; 363d4204c85Sraf struct queue_root *qr_prev; 364d4204c85Sraf struct ulwp *qr_head; 365d4204c85Sraf struct ulwp *qr_tail; 366d4204c85Sraf void *qr_wchan; 367d4204c85Sraf uint32_t qr_rtcount; 368d4204c85Sraf uint32_t qr_qlen; 369d4204c85Sraf uint32_t qr_qmax; 370d4204c85Sraf } queue_root_t; 371d4204c85Sraf 372d4204c85Sraf #ifdef _SYSCALL32 373d4204c85Sraf typedef struct queue_root32 { 374d4204c85Sraf caddr32_t qr_next; 375d4204c85Sraf caddr32_t qr_prev; 376d4204c85Sraf caddr32_t qr_head; 377d4204c85Sraf caddr32_t qr_tail; 378d4204c85Sraf caddr32_t qr_wchan; 379d4204c85Sraf uint32_t qr_rtcount; 380d4204c85Sraf uint32_t qr_qlen; 381d4204c85Sraf uint32_t qr_qmax; 382d4204c85Sraf } queue_root32_t; 383d4204c85Sraf #endif 384d4204c85Sraf 385d4204c85Sraf /* 386d4204c85Sraf * Sleep queue heads for USYNC_THREAD condvars and mutexes. 387d4204c85Sraf * The size and alignment is 128 bytes to reduce cache conflicts. 388d4204c85Sraf * Each queue head points to a list of queue roots, defined above. 389d4204c85Sraf * Each queue head contains a default queue root for use when only one 390d4204c85Sraf * is needed. It is always at the tail of the queue root hash chain. 3917c478bd9Sstevel@tonic-gate */ 3927c478bd9Sstevel@tonic-gate typedef union { 393d4204c85Sraf uint64_t qh_64[16]; 3947c478bd9Sstevel@tonic-gate struct { 3957c478bd9Sstevel@tonic-gate mutex_t q_lock; 3967c478bd9Sstevel@tonic-gate uint8_t q_qcnt; 397d4204c85Sraf uint8_t q_type; /* MX or CV */ 398d4204c85Sraf uint8_t q_pad1[2]; 399d4204c85Sraf uint32_t q_lockcount; 4007c478bd9Sstevel@tonic-gate uint32_t q_qlen; 4017c478bd9Sstevel@tonic-gate uint32_t q_qmax; 402d4204c85Sraf void *q_wchan; /* valid only while locked */ 403d4204c85Sraf struct queue_root *q_root; /* valid only while locked */ 404d4204c85Sraf struct queue_root *q_hlist; 405d4204c85Sraf #if !defined(_LP64) 406d4204c85Sraf caddr_t q_pad2[3]; 407d4204c85Sraf #endif 408d4204c85Sraf queue_root_t q_def_root; 409d4204c85Sraf uint32_t q_hlen; 410d4204c85Sraf uint32_t q_hmax; 4117c478bd9Sstevel@tonic-gate } qh_qh; 4127c478bd9Sstevel@tonic-gate } queue_head_t; 4137c478bd9Sstevel@tonic-gate 4147c478bd9Sstevel@tonic-gate #define qh_lock qh_qh.q_lock 4157c478bd9Sstevel@tonic-gate #define qh_qcnt qh_qh.q_qcnt 416d4204c85Sraf #define qh_type qh_qh.q_type 417d4204c85Sraf #if defined(THREAD_DEBUG) 4187c478bd9Sstevel@tonic-gate #define qh_lockcount qh_qh.q_lockcount 4197c478bd9Sstevel@tonic-gate #define qh_qlen qh_qh.q_qlen 4207c478bd9Sstevel@tonic-gate #define qh_qmax qh_qh.q_qmax 421d4204c85Sraf #endif 422d4204c85Sraf #define qh_wchan qh_qh.q_wchan 423d4204c85Sraf #define qh_root qh_qh.q_root 424d4204c85Sraf #define qh_hlist qh_qh.q_hlist 425d4204c85Sraf #define qh_def_root qh_qh.q_def_root 426d4204c85Sraf #define qh_hlen qh_qh.q_hlen 427d4204c85Sraf #define qh_hmax qh_qh.q_hmax 428d4204c85Sraf 429d4204c85Sraf /* queue types passed to queue_lock() */ 4307c478bd9Sstevel@tonic-gate #define MX 0 4317c478bd9Sstevel@tonic-gate #define CV 1 432883492d5Sraf #define QHASHSHIFT 9 /* number of hashing bits */ 433883492d5Sraf #define QHASHSIZE (1 << QHASHSHIFT) /* power of 2 (1<<9 == 512) */ 434883492d5Sraf #define QUEUE_HASH(wchan, type) ((uint_t) \ 435883492d5Sraf ((((uintptr_t)(wchan) >> 3) \ 436883492d5Sraf ^ ((uintptr_t)(wchan) >> (QHASHSHIFT + 3))) \ 4377c478bd9Sstevel@tonic-gate & (QHASHSIZE - 1)) + (((type) == MX)? 0 : QHASHSIZE)) 4387c478bd9Sstevel@tonic-gate 4397c478bd9Sstevel@tonic-gate extern queue_head_t *queue_lock(void *, int); 4407c478bd9Sstevel@tonic-gate extern void queue_unlock(queue_head_t *); 441d4204c85Sraf extern void enqueue(queue_head_t *, struct ulwp *, int); 442d4204c85Sraf extern struct ulwp *dequeue(queue_head_t *, int *); 443d4204c85Sraf extern struct ulwp **queue_slot(queue_head_t *, struct ulwp **, int *); 444d4204c85Sraf extern struct ulwp *queue_waiter(queue_head_t *); 445d4204c85Sraf extern int dequeue_self(queue_head_t *); 446d4204c85Sraf extern void queue_unlink(queue_head_t *, 44741efec22Sraf struct ulwp **, struct ulwp *); 4487c478bd9Sstevel@tonic-gate extern void unsleep_self(void); 4497c478bd9Sstevel@tonic-gate extern void spin_lock_set(mutex_t *); 4507c478bd9Sstevel@tonic-gate extern void spin_lock_clear(mutex_t *); 4517c478bd9Sstevel@tonic-gate 452d4204c85Sraf /* 453d4204c85Sraf * Scheduling class information structure. 454d4204c85Sraf */ 455d4204c85Sraf typedef struct { 456d4204c85Sraf short pcc_state; 457d4204c85Sraf short pcc_policy; 458d4204c85Sraf pri_t pcc_primin; 459d4204c85Sraf pri_t pcc_primax; 460d4204c85Sraf pcinfo_t pcc_info; 461d4204c85Sraf } pcclass_t; 462d4204c85Sraf 4637c478bd9Sstevel@tonic-gate /* 4647c478bd9Sstevel@tonic-gate * Memory block for chain of owned ceiling mutexes. 4657c478bd9Sstevel@tonic-gate */ 4667c478bd9Sstevel@tonic-gate typedef struct mxchain { 4677c478bd9Sstevel@tonic-gate struct mxchain *mxchain_next; 4687c478bd9Sstevel@tonic-gate mutex_t *mxchain_mx; 4697c478bd9Sstevel@tonic-gate } mxchain_t; 4707c478bd9Sstevel@tonic-gate 4717c478bd9Sstevel@tonic-gate /* 4727c478bd9Sstevel@tonic-gate * Pointer to an rwlock that is held for reading. 4737c478bd9Sstevel@tonic-gate * Used in rw_rdlock() to allow a thread that already holds a read 4747c478bd9Sstevel@tonic-gate * lock to acquire another read lock on the same rwlock even if 4757c478bd9Sstevel@tonic-gate * there are writers waiting. This to avoid deadlock when acquiring 4767c478bd9Sstevel@tonic-gate * a read lock more than once in the presence of pending writers. 4777c478bd9Sstevel@tonic-gate * POSIX mandates this behavior. 4787c478bd9Sstevel@tonic-gate */ 4797c478bd9Sstevel@tonic-gate typedef struct { 4807c478bd9Sstevel@tonic-gate void *rd_rwlock; /* the rwlock held for reading */ 4817c478bd9Sstevel@tonic-gate size_t rd_count; /* count of read locks applied */ 4827c478bd9Sstevel@tonic-gate } readlock_t; 4837c478bd9Sstevel@tonic-gate 4847c478bd9Sstevel@tonic-gate #ifdef _SYSCALL32 4857c478bd9Sstevel@tonic-gate typedef struct { 4867c478bd9Sstevel@tonic-gate caddr32_t rd_rwlock; 4877c478bd9Sstevel@tonic-gate size32_t rd_count; 4887c478bd9Sstevel@tonic-gate } readlock32_t; 4897c478bd9Sstevel@tonic-gate #endif /* _SYSCALL32 */ 4907c478bd9Sstevel@tonic-gate 4917c478bd9Sstevel@tonic-gate /* 4927c478bd9Sstevel@tonic-gate * Maximum number of read locks allowed for one thread on one rwlock. 4937c478bd9Sstevel@tonic-gate * This could be as large as INT_MAX, but the SUSV3 test suite would 4947c478bd9Sstevel@tonic-gate * take an inordinately long time to complete. This is big enough. 4957c478bd9Sstevel@tonic-gate */ 4967c478bd9Sstevel@tonic-gate #define READ_LOCK_MAX 100000 4977c478bd9Sstevel@tonic-gate 4987c478bd9Sstevel@tonic-gate #define ul_tlsent ul_tls.tls_data /* array of pointers to dynamic TLS */ 4997c478bd9Sstevel@tonic-gate #define ul_ntlsent ul_tls.tls_size /* number of entries in ul_tlsent */ 5007c478bd9Sstevel@tonic-gate 5017c478bd9Sstevel@tonic-gate /* 5027c478bd9Sstevel@tonic-gate * Round up an integral value to a multiple of 64 5037c478bd9Sstevel@tonic-gate */ 5047c478bd9Sstevel@tonic-gate #define roundup64(x) (-(-(x) & -64)) 5057c478bd9Sstevel@tonic-gate 5067c478bd9Sstevel@tonic-gate /* 5077c478bd9Sstevel@tonic-gate * NOTE: Whatever changes are made to ulwp_t must be 5087c478bd9Sstevel@tonic-gate * reflected in $SRC/cmd/mdb/common/modules/libc/libc.c 5097c478bd9Sstevel@tonic-gate * 5107c478bd9Sstevel@tonic-gate * NOTE: ul_self *must* be the first member of ulwp_t on x86 5117c478bd9Sstevel@tonic-gate * Low-level x86 code relies on this. 5127c478bd9Sstevel@tonic-gate */ 5137c478bd9Sstevel@tonic-gate typedef struct ulwp { 5147c478bd9Sstevel@tonic-gate /* 5157c478bd9Sstevel@tonic-gate * These members always need to come first on sparc. 5167c478bd9Sstevel@tonic-gate * For dtrace, a ulwp_t must be aligned on a 64-byte boundary. 5177c478bd9Sstevel@tonic-gate */ 5187c478bd9Sstevel@tonic-gate #if defined(__sparc) 5197c478bd9Sstevel@tonic-gate uint32_t ul_dinstr; /* scratch space for dtrace */ 5207c478bd9Sstevel@tonic-gate uint32_t ul_padsparc0[15]; 5217c478bd9Sstevel@tonic-gate uint32_t ul_dsave; /* dtrace: save %g1, %g0, %sp */ 5227c478bd9Sstevel@tonic-gate uint32_t ul_drestore; /* dtrace: restore %g0, %g0, %g0 */ 5237c478bd9Sstevel@tonic-gate uint32_t ul_dftret; /* dtrace: return probe fasttrap */ 5247c478bd9Sstevel@tonic-gate uint32_t ul_dreturn; /* dtrace: return %o0 */ 5257c478bd9Sstevel@tonic-gate #endif 5267c478bd9Sstevel@tonic-gate struct ulwp *ul_self; /* pointer to self */ 5277c478bd9Sstevel@tonic-gate #if defined(__i386) 5287c478bd9Sstevel@tonic-gate uint8_t ul_dinstr[40]; /* scratch space for dtrace */ 5297c478bd9Sstevel@tonic-gate #elif defined(__amd64) 5307c478bd9Sstevel@tonic-gate uint8_t ul_dinstr[56]; /* scratch space for dtrace */ 5317c478bd9Sstevel@tonic-gate #endif 5327c478bd9Sstevel@tonic-gate struct uberdata *ul_uberdata; /* uber (super-global) data */ 5337c478bd9Sstevel@tonic-gate tls_t ul_tls; /* dynamic thread-local storage base */ 5347c478bd9Sstevel@tonic-gate struct ulwp *ul_forw; /* forw, back all_lwps list, */ 5357c478bd9Sstevel@tonic-gate struct ulwp *ul_back; /* protected by link_lock */ 5367c478bd9Sstevel@tonic-gate struct ulwp *ul_next; /* list to keep track of stacks */ 5377c478bd9Sstevel@tonic-gate struct ulwp *ul_hash; /* hash chain linked list */ 5387c478bd9Sstevel@tonic-gate void *ul_rval; /* return value from thr_exit() */ 5397c478bd9Sstevel@tonic-gate caddr_t ul_stk; /* mapping base of the stack */ 5407c478bd9Sstevel@tonic-gate size_t ul_mapsiz; /* mapping size of the stack */ 5417c478bd9Sstevel@tonic-gate size_t ul_guardsize; /* normally _lpagesize */ 5427c478bd9Sstevel@tonic-gate uintptr_t ul_stktop; /* broken thr_stksegment() interface */ 5437c478bd9Sstevel@tonic-gate size_t ul_stksiz; /* broken thr_stksegment() interface */ 5447c478bd9Sstevel@tonic-gate stack_t ul_ustack; /* current stack boundaries */ 5457c478bd9Sstevel@tonic-gate int ul_ix; /* hash index */ 5467c478bd9Sstevel@tonic-gate lwpid_t ul_lwpid; /* thread id, aka the lwp id */ 547d4204c85Sraf pri_t ul_pri; /* scheduling priority */ 548d4204c85Sraf pri_t ul_epri; /* real-time ceiling priority */ 5497c478bd9Sstevel@tonic-gate char ul_policy; /* scheduling policy */ 550d4204c85Sraf char ul_cid; /* scheduling class id */ 5517c478bd9Sstevel@tonic-gate union { 5527c478bd9Sstevel@tonic-gate struct { 5537c478bd9Sstevel@tonic-gate char cursig; /* deferred signal number */ 5547c478bd9Sstevel@tonic-gate char pleasestop; /* lwp requested to stop itself */ 5557c478bd9Sstevel@tonic-gate } s; 5567c478bd9Sstevel@tonic-gate short curplease; /* for testing both at once */ 5577c478bd9Sstevel@tonic-gate } ul_cp; 5587c478bd9Sstevel@tonic-gate char ul_stop; /* reason for stopping */ 5597c478bd9Sstevel@tonic-gate char ul_signalled; /* this lwp was cond_signal()d */ 5607c478bd9Sstevel@tonic-gate char ul_dead; /* this lwp has called thr_exit */ 5617c478bd9Sstevel@tonic-gate char ul_unwind; /* posix: unwind C++ stack */ 5627c478bd9Sstevel@tonic-gate char ul_detached; /* THR_DETACHED at thread_create() */ 5637c478bd9Sstevel@tonic-gate /* or pthread_detach() was called */ 5647c478bd9Sstevel@tonic-gate char ul_writer; /* sleeping in rw_wrlock() */ 5657c478bd9Sstevel@tonic-gate char ul_stopping; /* set by curthread: stopping self */ 56634709573Sraf char ul_cancel_prologue; /* for _cancel_prologue() */ 5677c478bd9Sstevel@tonic-gate short ul_preempt; /* no_preempt()/preempt() */ 5687c478bd9Sstevel@tonic-gate short ul_savpreempt; /* pre-existing preempt value */ 5697c478bd9Sstevel@tonic-gate char ul_sigsuspend; /* thread is in sigsuspend/pollsys */ 5707c478bd9Sstevel@tonic-gate char ul_main; /* thread is the main thread */ 5717c478bd9Sstevel@tonic-gate char ul_fork; /* thread is performing a fork */ 5727c478bd9Sstevel@tonic-gate char ul_primarymap; /* primary link-map is initialized */ 5737c478bd9Sstevel@tonic-gate /* per-thread copies of the corresponding global variables */ 5745d1dd9a9Sraf uint8_t ul_max_spinners; /* thread_max_spinners */ 5757c478bd9Sstevel@tonic-gate char ul_door_noreserve; /* thread_door_noreserve */ 5767c478bd9Sstevel@tonic-gate char ul_queue_fifo; /* thread_queue_fifo */ 5777c478bd9Sstevel@tonic-gate char ul_cond_wait_defer; /* thread_cond_wait_defer */ 5787c478bd9Sstevel@tonic-gate char ul_error_detection; /* thread_error_detection */ 5797c478bd9Sstevel@tonic-gate char ul_async_safe; /* thread_async_safe */ 580d4204c85Sraf char ul_rt; /* found on an RT queue */ 581d4204c85Sraf char ul_rtqueued; /* was RT when queued */ 5827c5714f6Sraf char ul_misaligned; /* thread_locks_misaligned */ 5837c5714f6Sraf char ul_pad[3]; 5847c478bd9Sstevel@tonic-gate int ul_adaptive_spin; /* thread_adaptive_spin */ 5857c478bd9Sstevel@tonic-gate int ul_queue_spin; /* thread_queue_spin */ 5867c478bd9Sstevel@tonic-gate volatile int ul_critical; /* non-zero == in a critical region */ 5877c478bd9Sstevel@tonic-gate int ul_sigdefer; /* non-zero == defer signals */ 5887c478bd9Sstevel@tonic-gate int ul_vfork; /* thread is the child of vfork() */ 5897c478bd9Sstevel@tonic-gate int ul_cancelable; /* _cancelon()/_canceloff() */ 5907c478bd9Sstevel@tonic-gate char ul_cancel_pending; /* pthread_cancel() was called */ 5917c478bd9Sstevel@tonic-gate char ul_cancel_disabled; /* PTHREAD_CANCEL_DISABLE */ 5927c478bd9Sstevel@tonic-gate char ul_cancel_async; /* PTHREAD_CANCEL_ASYNCHRONOUS */ 5937c478bd9Sstevel@tonic-gate char ul_save_async; /* saved copy of ul_cancel_async */ 5947c478bd9Sstevel@tonic-gate char ul_mutator; /* lwp is a mutator (java interface) */ 5957c478bd9Sstevel@tonic-gate char ul_created; /* created suspended */ 5967c478bd9Sstevel@tonic-gate char ul_replace; /* replacement; must be free()d */ 5977c478bd9Sstevel@tonic-gate uchar_t ul_nocancel; /* cancellation can't happen */ 5987c478bd9Sstevel@tonic-gate int ul_errno; /* per-thread errno */ 5997c478bd9Sstevel@tonic-gate int *ul_errnop; /* pointer to errno or self->ul_errno */ 6007c478bd9Sstevel@tonic-gate __cleanup_t *ul_clnup_hdr; /* head of cleanup handlers list */ 601d4204c85Sraf uberflags_t *ul_schedctl_called; /* ul_schedctl is set up */ 602d4204c85Sraf volatile sc_shared_t *ul_schedctl; /* schedctl data */ 6037c478bd9Sstevel@tonic-gate int ul_bindflags; /* bind_guard() interface to ld.so.1 */ 604a574db85Sraf uint_t ul_libc_locks; /* count of cancel_safe_mutex_lock()s */ 6057c478bd9Sstevel@tonic-gate tsd_t *ul_stsd; /* slow TLS for keys >= TSD_NFAST */ 6067c478bd9Sstevel@tonic-gate void *ul_ftsd[TSD_NFAST]; /* fast TLS for keys < TSD_NFAST */ 6077c478bd9Sstevel@tonic-gate td_evbuf_t ul_td_evbuf; /* event buffer */ 6087c478bd9Sstevel@tonic-gate char ul_td_events_enable; /* event mechanism enabled */ 6097c478bd9Sstevel@tonic-gate char ul_sync_obj_reg; /* tdb_sync_obj_register() */ 6107c478bd9Sstevel@tonic-gate char ul_qtype; /* MX or CV */ 6117c478bd9Sstevel@tonic-gate char ul_cv_wake; /* != 0: just wake up, don't requeue */ 612e54ab87fSRoger A. Faulkner int ul_rtld; /* thread is running inside ld.so.1 */ 6137c478bd9Sstevel@tonic-gate int ul_usropts; /* flags given to thr_create() */ 6147c478bd9Sstevel@tonic-gate void *(*ul_startpc)(void *); /* start func (thr_create()) */ 6157c478bd9Sstevel@tonic-gate void *ul_startarg; /* argument for start function */ 6167c478bd9Sstevel@tonic-gate void *ul_wchan; /* synch object when sleeping */ 6177c478bd9Sstevel@tonic-gate struct ulwp *ul_link; /* sleep queue link */ 6187c478bd9Sstevel@tonic-gate queue_head_t *ul_sleepq; /* sleep queue thread is waiting on */ 6197c478bd9Sstevel@tonic-gate mutex_t *ul_cvmutex; /* mutex dropped when waiting on a cv */ 6207c478bd9Sstevel@tonic-gate mxchain_t *ul_mxchain; /* chain of owned ceiling mutexes */ 621d4204c85Sraf int ul_save_state; /* bind_guard() interface to ld.so.1 */ 622883492d5Sraf uint_t ul_rdlockcnt; /* # entries in ul_readlock array */ 623883492d5Sraf /* 0 means there is but a single entry */ 624883492d5Sraf union { /* single entry or pointer to array */ 6257c478bd9Sstevel@tonic-gate readlock_t single; 6267c478bd9Sstevel@tonic-gate readlock_t *array; 6277c478bd9Sstevel@tonic-gate } ul_readlock; 628883492d5Sraf uint_t ul_heldlockcnt; /* # entries in ul_heldlocks array */ 629883492d5Sraf /* 0 means there is but a single entry */ 630883492d5Sraf union { /* single entry or pointer to array */ 631883492d5Sraf mutex_t *single; 632883492d5Sraf mutex_t **array; 633883492d5Sraf } ul_heldlocks; 6347c478bd9Sstevel@tonic-gate /* PROBE_SUPPORT begin */ 6357c478bd9Sstevel@tonic-gate void *ul_tpdp; 6367c478bd9Sstevel@tonic-gate /* PROBE_SUPPORT end */ 6377c478bd9Sstevel@tonic-gate ucontext_t *ul_siglink; /* pointer to previous context */ 6387c478bd9Sstevel@tonic-gate uint_t ul_spin_lock_spin; /* spin lock statistics */ 6397c478bd9Sstevel@tonic-gate uint_t ul_spin_lock_spin2; 6407c478bd9Sstevel@tonic-gate uint_t ul_spin_lock_sleep; 6417c478bd9Sstevel@tonic-gate uint_t ul_spin_lock_wakeup; 642d4204c85Sraf queue_root_t ul_queue_root; /* root of a sleep queue */ 643d4204c85Sraf id_t ul_rtclassid; /* real-time class id */ 644d4204c85Sraf uint_t ul_pilocks; /* count of PI locks held */ 6457c478bd9Sstevel@tonic-gate /* the following members *must* be last in the structure */ 6467c478bd9Sstevel@tonic-gate /* they are discarded when ulwp is replaced on thr_exit() */ 6477c478bd9Sstevel@tonic-gate sigset_t ul_sigmask; /* thread's current signal mask */ 6487c478bd9Sstevel@tonic-gate sigset_t ul_tmpmask; /* signal mask for sigsuspend/pollsys */ 6497c478bd9Sstevel@tonic-gate siginfo_t ul_siginfo; /* deferred siginfo */ 6507c478bd9Sstevel@tonic-gate mutex_t ul_spinlock; /* used when suspending/continuing */ 6517c478bd9Sstevel@tonic-gate fpuenv_t ul_fpuenv; /* floating point state */ 6527c478bd9Sstevel@tonic-gate uintptr_t ul_sp; /* stack pointer when blocked */ 6537c478bd9Sstevel@tonic-gate void *ul_ex_unwind; /* address of _ex_unwind() or -1 */ 6547c478bd9Sstevel@tonic-gate #if defined(sparc) 6557c478bd9Sstevel@tonic-gate void *ul_unwind_ret; /* used only by _ex_clnup_handler() */ 6567c478bd9Sstevel@tonic-gate #endif 6577c478bd9Sstevel@tonic-gate } ulwp_t; 6587c478bd9Sstevel@tonic-gate 6597c478bd9Sstevel@tonic-gate #define ul_cursig ul_cp.s.cursig /* deferred signal number */ 6607c478bd9Sstevel@tonic-gate #define ul_pleasestop ul_cp.s.pleasestop /* lwp requested to stop */ 6617c478bd9Sstevel@tonic-gate #define ul_curplease ul_cp.curplease /* for testing both at once */ 6627c478bd9Sstevel@tonic-gate 6637c478bd9Sstevel@tonic-gate /* 6647c478bd9Sstevel@tonic-gate * This is the size of a replacement ulwp, retained only for the benefit 6657c478bd9Sstevel@tonic-gate * of thr_join(). The trailing members are unneeded for this purpose. 6667c478bd9Sstevel@tonic-gate */ 6677c478bd9Sstevel@tonic-gate #define REPLACEMENT_SIZE ((size_t)&((ulwp_t *)NULL)->ul_sigmask) 6687c478bd9Sstevel@tonic-gate 6697c478bd9Sstevel@tonic-gate /* 6707c478bd9Sstevel@tonic-gate * Definitions for static initialization of signal sets, 6717c478bd9Sstevel@tonic-gate * plus some sneaky optimizations in various places. 6727c478bd9Sstevel@tonic-gate */ 6737c478bd9Sstevel@tonic-gate 6747c478bd9Sstevel@tonic-gate #define SIGMASK(sig) ((uint32_t)1 << (((sig) - 1) & (32 - 1))) 6757c478bd9Sstevel@tonic-gate 6767c478bd9Sstevel@tonic-gate #if (MAXSIG > 32 && MAXSIG <= 64) 6777c478bd9Sstevel@tonic-gate #define FILLSET0 0xffffffffu 6787c478bd9Sstevel@tonic-gate #define FILLSET1 ((1u << (MAXSIG - 32)) - 1) 6797c478bd9Sstevel@tonic-gate #else 6807c478bd9Sstevel@tonic-gate #error "fix me: MAXSIG out of bounds" 6817c478bd9Sstevel@tonic-gate #endif 6827c478bd9Sstevel@tonic-gate 6837c478bd9Sstevel@tonic-gate #define CANTMASK0 (SIGMASK(SIGKILL) | SIGMASK(SIGSTOP)) 6847c478bd9Sstevel@tonic-gate #define CANTMASK1 0 6857c478bd9Sstevel@tonic-gate 6867c478bd9Sstevel@tonic-gate #define MASKSET0 (FILLSET0 & ~CANTMASK0) 6877c478bd9Sstevel@tonic-gate #define MASKSET1 (FILLSET1 & ~CANTMASK1) 6887c478bd9Sstevel@tonic-gate 689f841f6adSraf extern const sigset_t maskset; /* set of all maskable signals */ 6907c478bd9Sstevel@tonic-gate 6917c478bd9Sstevel@tonic-gate extern int thread_adaptive_spin; 6927c478bd9Sstevel@tonic-gate extern uint_t thread_max_spinners; 6937c478bd9Sstevel@tonic-gate extern int thread_queue_spin; 6947c478bd9Sstevel@tonic-gate extern int thread_queue_fifo; 6957c478bd9Sstevel@tonic-gate extern int thread_queue_dump; 6967c478bd9Sstevel@tonic-gate extern int thread_cond_wait_defer; 6977c478bd9Sstevel@tonic-gate extern int thread_async_safe; 6987c478bd9Sstevel@tonic-gate extern int thread_queue_verify; 6997c478bd9Sstevel@tonic-gate 7007c478bd9Sstevel@tonic-gate /* 7017c478bd9Sstevel@tonic-gate * pthread_atfork() related data, used to store atfork handlers. 7027c478bd9Sstevel@tonic-gate */ 7037c478bd9Sstevel@tonic-gate typedef struct atfork { 7047c478bd9Sstevel@tonic-gate struct atfork *forw; /* forward pointer */ 7057c478bd9Sstevel@tonic-gate struct atfork *back; /* backward pointer */ 7067c478bd9Sstevel@tonic-gate void (*prepare)(void); /* pre-fork handler */ 7077c478bd9Sstevel@tonic-gate void (*parent)(void); /* post-fork parent handler */ 7087c478bd9Sstevel@tonic-gate void (*child)(void); /* post-fork child handler */ 7097c478bd9Sstevel@tonic-gate } atfork_t; 7107c478bd9Sstevel@tonic-gate 711883492d5Sraf /* 71209ce0d4aSRoger A. Faulkner * Element in the table and in the list of registered process 71309ce0d4aSRoger A. Faulkner * robust locks. We keep track of these to make sure that we 71409ce0d4aSRoger A. Faulkner * only call ___lwp_mutex_register() once for each such lock 71509ce0d4aSRoger A. Faulkner * after it is first mapped in (or newly mapped in). 716883492d5Sraf */ 717883492d5Sraf typedef struct robust { 71809ce0d4aSRoger A. Faulkner struct robust *robust_next; /* hash table list */ 71909ce0d4aSRoger A. Faulkner struct robust *robust_list; /* global list */ 720883492d5Sraf mutex_t *robust_lock; 721883492d5Sraf } robust_t; 722883492d5Sraf 72309ce0d4aSRoger A. Faulkner /* 72409ce0d4aSRoger A. Faulkner * Invalid address, used to mark an unused element in the hash table. 72509ce0d4aSRoger A. Faulkner */ 72609ce0d4aSRoger A. Faulkner #define INVALID_ADDR ((void *)(uintptr_t)(-1L)) 72709ce0d4aSRoger A. Faulkner 728883492d5Sraf /* 729883492d5Sraf * Parameters of the lock registration hash table. 730883492d5Sraf */ 731daa03c95Sraf #define LOCKSHIFT 15 /* number of hashing bits */ 732daa03c95Sraf #define LOCKHASHSZ (1 << LOCKSHIFT) /* power of 2 (1<<15 == 32K) */ 733883492d5Sraf #define LOCK_HASH(addr) (uint_t) \ 734883492d5Sraf ((((uintptr_t)(addr) >> 3) \ 735883492d5Sraf ^ ((uintptr_t)(addr) >> (LOCKSHIFT + 3))) \ 736883492d5Sraf & (LOCKHASHSZ - 1)) 737883492d5Sraf 7387c478bd9Sstevel@tonic-gate /* 7397c478bd9Sstevel@tonic-gate * Make our hot locks reside on private cache lines (64 bytes). 7407c478bd9Sstevel@tonic-gate */ 7417c478bd9Sstevel@tonic-gate typedef struct { 7427c478bd9Sstevel@tonic-gate mutex_t pad_lock; 7432e145884Sraf char pad_pad[64 - sizeof (mutex_t)]; 7447c478bd9Sstevel@tonic-gate } pad_lock_t; 7457c478bd9Sstevel@tonic-gate 7462e145884Sraf /* 7472e145884Sraf * Make our semi-hot locks reside on semi-private cache lines (32 bytes). 7482e145884Sraf */ 7492e145884Sraf typedef struct { 7502e145884Sraf mutex_t pad_lock; 7512e145884Sraf char pad_pad[32 - sizeof (mutex_t)]; 7522e145884Sraf } pad32_lock_t; 7532e145884Sraf 7547c478bd9Sstevel@tonic-gate /* 7557c478bd9Sstevel@tonic-gate * The threads hash table is used for fast lookup and locking of an active 7567c478bd9Sstevel@tonic-gate * thread structure (ulwp_t) given a thread-id. It is an N-element array of 7577c478bd9Sstevel@tonic-gate * thr_hash_table_t structures, where N == 1 before the main thread creates 7587c478bd9Sstevel@tonic-gate * the first additional thread and N == 1024 afterwards. Each element of the 7597c478bd9Sstevel@tonic-gate * table is 64 bytes in size and alignment to reduce cache conflicts. 7607c478bd9Sstevel@tonic-gate */ 7617c478bd9Sstevel@tonic-gate typedef struct { 7627c478bd9Sstevel@tonic-gate mutex_t hash_lock; /* lock per bucket */ 7637c478bd9Sstevel@tonic-gate cond_t hash_cond; /* convar per bucket */ 7647c478bd9Sstevel@tonic-gate ulwp_t *hash_bucket; /* hash bucket points to the list of ulwps */ 7657c478bd9Sstevel@tonic-gate char hash_pad[64 - /* pad out to 64 bytes */ 7667c478bd9Sstevel@tonic-gate (sizeof (mutex_t) + sizeof (cond_t) + sizeof (ulwp_t *))]; 7677c478bd9Sstevel@tonic-gate } thr_hash_table_t; 7687c478bd9Sstevel@tonic-gate 7697c478bd9Sstevel@tonic-gate #ifdef _SYSCALL32 7707c478bd9Sstevel@tonic-gate typedef struct { 7717c478bd9Sstevel@tonic-gate mutex_t hash_lock; 7727c478bd9Sstevel@tonic-gate cond_t hash_cond; 7737c478bd9Sstevel@tonic-gate caddr32_t hash_bucket; 7747c478bd9Sstevel@tonic-gate char hash_pad[64 - 7757c478bd9Sstevel@tonic-gate (sizeof (mutex_t) + sizeof (cond_t) + sizeof (caddr32_t))]; 7767c478bd9Sstevel@tonic-gate } thr_hash_table32_t; 7777c478bd9Sstevel@tonic-gate #endif /* _SYSCALL32 */ 7787c478bd9Sstevel@tonic-gate 7797c478bd9Sstevel@tonic-gate 7807c478bd9Sstevel@tonic-gate /* 78141efec22Sraf * siguaction members have 128-byte size and 64-byte alignment. 78241efec22Sraf * We know that sizeof (struct sigaction) is 32 bytes for both 78341efec22Sraf * _ILP32 and _LP64 and that sizeof (rwlock_t) is 64 bytes. 7847c478bd9Sstevel@tonic-gate */ 7857c478bd9Sstevel@tonic-gate typedef struct { 78641efec22Sraf rwlock_t sig_lock; 7877c478bd9Sstevel@tonic-gate struct sigaction sig_uaction; 78841efec22Sraf char sig_pad[128 - sizeof (rwlock_t) - sizeof (struct sigaction)]; 7897c478bd9Sstevel@tonic-gate } siguaction_t; 7907c478bd9Sstevel@tonic-gate 7917c478bd9Sstevel@tonic-gate #ifdef _SYSCALL32 7927c478bd9Sstevel@tonic-gate typedef struct { 79341efec22Sraf rwlock_t sig_lock; 7947c478bd9Sstevel@tonic-gate struct sigaction32 sig_uaction; 79541efec22Sraf char sig_pad[128 - sizeof (rwlock_t) - sizeof (struct sigaction32)]; 7967c478bd9Sstevel@tonic-gate } siguaction32_t; 7977c478bd9Sstevel@tonic-gate #endif /* _SYSCALL32 */ 7987c478bd9Sstevel@tonic-gate 7997c478bd9Sstevel@tonic-gate 8007c478bd9Sstevel@tonic-gate /* 8017c478bd9Sstevel@tonic-gate * Bucket structures, used by lmalloc()/lfree(). 8027c478bd9Sstevel@tonic-gate * See port/threads/alloc.c for details. 8037c478bd9Sstevel@tonic-gate * A bucket's size and alignment is 64 bytes. 8047c478bd9Sstevel@tonic-gate */ 8057c478bd9Sstevel@tonic-gate typedef struct { 8067c478bd9Sstevel@tonic-gate mutex_t bucket_lock; /* protects the free list allocations */ 8077c478bd9Sstevel@tonic-gate void *free_list; /* LIFO list of blocks to allocate/free */ 8087c478bd9Sstevel@tonic-gate size_t chunks; /* number of 64K blocks mmap()ed last time */ 8097c478bd9Sstevel@tonic-gate char pad64[64 - /* pad out to 64 bytes */ 8107c478bd9Sstevel@tonic-gate (sizeof (mutex_t) + sizeof (void *) + sizeof (size_t))]; 8117c478bd9Sstevel@tonic-gate } bucket_t; 8127c478bd9Sstevel@tonic-gate 8137c478bd9Sstevel@tonic-gate #ifdef _SYSCALL32 8147c478bd9Sstevel@tonic-gate typedef struct { 8157c478bd9Sstevel@tonic-gate mutex_t bucket_lock; 8167c478bd9Sstevel@tonic-gate caddr32_t free_list; 8177c478bd9Sstevel@tonic-gate size32_t chunks; 8187c478bd9Sstevel@tonic-gate char pad64[64 - /* pad out to 64 bytes */ 8197c478bd9Sstevel@tonic-gate (sizeof (mutex_t) + sizeof (caddr32_t) + sizeof (size32_t))]; 8207c478bd9Sstevel@tonic-gate } bucket32_t; 8217c478bd9Sstevel@tonic-gate #endif /* _SYSCALL32 */ 8227c478bd9Sstevel@tonic-gate 8237c478bd9Sstevel@tonic-gate #define NBUCKETS 10 /* sizes ranging from 64 to 32768 */ 8247c478bd9Sstevel@tonic-gate 8257c478bd9Sstevel@tonic-gate 8267c478bd9Sstevel@tonic-gate /* 8277c478bd9Sstevel@tonic-gate * atexit() data structures. 8287c478bd9Sstevel@tonic-gate * See port/gen/atexit.c for details. 8297c478bd9Sstevel@tonic-gate */ 8307c478bd9Sstevel@tonic-gate typedef void (*_exithdlr_func_t) (void); 8317c478bd9Sstevel@tonic-gate 8327c478bd9Sstevel@tonic-gate typedef struct _exthdlr { 8337c478bd9Sstevel@tonic-gate struct _exthdlr *next; /* next in handler list */ 8347c478bd9Sstevel@tonic-gate _exithdlr_func_t hdlr; /* handler itself */ 8357c478bd9Sstevel@tonic-gate } _exthdlr_t; 8367c478bd9Sstevel@tonic-gate 8377c478bd9Sstevel@tonic-gate typedef struct { 8387c478bd9Sstevel@tonic-gate mutex_t exitfns_lock; 8397c478bd9Sstevel@tonic-gate _exthdlr_t *head; 8407c478bd9Sstevel@tonic-gate void *exit_frame_monitor; 8417c478bd9Sstevel@tonic-gate char exit_pad[64 - /* pad out to 64 bytes */ 8427c478bd9Sstevel@tonic-gate (sizeof (mutex_t) + sizeof (_exthdlr_t *) + sizeof (void *))]; 8437c478bd9Sstevel@tonic-gate } atexit_root_t; 8447c478bd9Sstevel@tonic-gate 8457c478bd9Sstevel@tonic-gate #ifdef _SYSCALL32 8467c478bd9Sstevel@tonic-gate typedef struct { 8477c478bd9Sstevel@tonic-gate mutex_t exitfns_lock; 8487c478bd9Sstevel@tonic-gate caddr32_t head; 8497c478bd9Sstevel@tonic-gate caddr32_t exit_frame_monitor; 8507c478bd9Sstevel@tonic-gate char exit_pad[64 - /* pad out to 64 bytes */ 8517c478bd9Sstevel@tonic-gate (sizeof (mutex_t) + sizeof (caddr32_t) + sizeof (caddr32_t))]; 8527c478bd9Sstevel@tonic-gate } atexit_root32_t; 8537c478bd9Sstevel@tonic-gate #endif /* _SYSCALL32 */ 8547c478bd9Sstevel@tonic-gate 8557c478bd9Sstevel@tonic-gate 8567c478bd9Sstevel@tonic-gate /* 8577c478bd9Sstevel@tonic-gate * This is data that is global to all link maps (uberdata, aka super-global). 8587c478bd9Sstevel@tonic-gate */ 8597c478bd9Sstevel@tonic-gate typedef struct uberdata { 8607c478bd9Sstevel@tonic-gate pad_lock_t _link_lock; 8618cd45542Sraf pad_lock_t _ld_lock; 8628cd45542Sraf pad_lock_t _fork_lock; 8638cd45542Sraf pad_lock_t _atfork_lock; 86498c1a6b4Sraf pad32_lock_t _callout_lock; 86598c1a6b4Sraf pad32_lock_t _tdb_hash_lock; 8667c478bd9Sstevel@tonic-gate tdb_sync_stats_t tdb_hash_lock_stats; 8677c478bd9Sstevel@tonic-gate siguaction_t siguaction[NSIG]; 8687c478bd9Sstevel@tonic-gate bucket_t bucket[NBUCKETS]; 8697c478bd9Sstevel@tonic-gate atexit_root_t atexit_root; 8707c478bd9Sstevel@tonic-gate tsd_metadata_t tsd_metadata; 8717c478bd9Sstevel@tonic-gate tls_metadata_t tls_metadata; 8727c478bd9Sstevel@tonic-gate /* 8737c478bd9Sstevel@tonic-gate * Every object before this point has size and alignment of 64 bytes. 8747c478bd9Sstevel@tonic-gate * Don't add any other type of data before this point. 8757c478bd9Sstevel@tonic-gate */ 8767c478bd9Sstevel@tonic-gate char primary_map; /* set when primary link map is initialized */ 8777c478bd9Sstevel@tonic-gate char bucket_init; /* set when bucket[NBUCKETS] is initialized */ 8787c478bd9Sstevel@tonic-gate char pad[2]; 8797c478bd9Sstevel@tonic-gate uberflags_t uberflags; 8807c478bd9Sstevel@tonic-gate queue_head_t *queue_head; 8817c478bd9Sstevel@tonic-gate thr_hash_table_t *thr_hash_table; 8827c478bd9Sstevel@tonic-gate uint_t hash_size; /* # of entries in thr_hash_table[] */ 8837c478bd9Sstevel@tonic-gate uint_t hash_mask; /* hash_size - 1 */ 8847c478bd9Sstevel@tonic-gate ulwp_t *ulwp_one; /* main thread */ 8857c478bd9Sstevel@tonic-gate ulwp_t *all_lwps; /* circular ul_forw/ul_back list of live lwps */ 8867c478bd9Sstevel@tonic-gate ulwp_t *all_zombies; /* circular ul_forw/ul_back list of zombies */ 8877c478bd9Sstevel@tonic-gate int nthreads; /* total number of live threads/lwps */ 8887c478bd9Sstevel@tonic-gate int nzombies; /* total number of zombie threads */ 8897c478bd9Sstevel@tonic-gate int ndaemons; /* total number of THR_DAEMON threads/lwps */ 8907c478bd9Sstevel@tonic-gate pid_t pid; /* the current process's pid */ 8917c478bd9Sstevel@tonic-gate void (*sigacthandler)(int, siginfo_t *, void *); 8927c478bd9Sstevel@tonic-gate ulwp_t *lwp_stacks; 8937c478bd9Sstevel@tonic-gate ulwp_t *lwp_laststack; 8947c478bd9Sstevel@tonic-gate int nfreestack; 8957c478bd9Sstevel@tonic-gate int thread_stack_cache; 8967c478bd9Sstevel@tonic-gate ulwp_t *ulwp_freelist; 8977c478bd9Sstevel@tonic-gate ulwp_t *ulwp_lastfree; 8987c478bd9Sstevel@tonic-gate ulwp_t *ulwp_replace_free; 8997c478bd9Sstevel@tonic-gate ulwp_t *ulwp_replace_last; 9007c478bd9Sstevel@tonic-gate atfork_t *atforklist; /* circular Q for fork handlers */ 901883492d5Sraf robust_t **robustlocks; /* table of registered robust locks */ 90209ce0d4aSRoger A. Faulkner robust_t *robustlist; /* list of registered robust locks */ 9037c478bd9Sstevel@tonic-gate struct uberdata **tdb_bootstrap; 9047c478bd9Sstevel@tonic-gate tdb_t tdb; /* thread debug interfaces (for libc_db) */ 9057c478bd9Sstevel@tonic-gate } uberdata_t; 9067c478bd9Sstevel@tonic-gate 9077c478bd9Sstevel@tonic-gate #define link_lock _link_lock.pad_lock 9088cd45542Sraf #define ld_lock _ld_lock.pad_lock 9097c478bd9Sstevel@tonic-gate #define fork_lock _fork_lock.pad_lock 9102e145884Sraf #define atfork_lock _atfork_lock.pad_lock 91198c1a6b4Sraf #define callout_lock _callout_lock.pad_lock 9127c478bd9Sstevel@tonic-gate #define tdb_hash_lock _tdb_hash_lock.pad_lock 9137c478bd9Sstevel@tonic-gate 9147c478bd9Sstevel@tonic-gate #pragma align 64(__uberdata) 9157c478bd9Sstevel@tonic-gate extern uberdata_t __uberdata; 9167c478bd9Sstevel@tonic-gate extern uberdata_t **__tdb_bootstrap; /* known to libc_db and mdb */ 9177c478bd9Sstevel@tonic-gate extern int primary_link_map; 9187c478bd9Sstevel@tonic-gate 9197c478bd9Sstevel@tonic-gate #define ulwp_mutex(ulwp, udp) \ 9207c478bd9Sstevel@tonic-gate (&(udp)->thr_hash_table[(ulwp)->ul_ix].hash_lock) 9217c478bd9Sstevel@tonic-gate #define ulwp_condvar(ulwp, udp) \ 9227c478bd9Sstevel@tonic-gate (&(udp)->thr_hash_table[(ulwp)->ul_ix].hash_cond) 9237c478bd9Sstevel@tonic-gate 9247c478bd9Sstevel@tonic-gate /* 9257c478bd9Sstevel@tonic-gate * Grab and release the hash table lock for the specified lwp. 9267c478bd9Sstevel@tonic-gate */ 9277c478bd9Sstevel@tonic-gate #define ulwp_lock(ulwp, udp) lmutex_lock(ulwp_mutex(ulwp, udp)) 9287c478bd9Sstevel@tonic-gate #define ulwp_unlock(ulwp, udp) lmutex_unlock(ulwp_mutex(ulwp, udp)) 9297c478bd9Sstevel@tonic-gate 9307c478bd9Sstevel@tonic-gate #ifdef _SYSCALL32 /* needed by libc_db */ 9317c478bd9Sstevel@tonic-gate 9327c478bd9Sstevel@tonic-gate typedef struct ulwp32 { 9337c478bd9Sstevel@tonic-gate #if defined(__sparc) 9347c478bd9Sstevel@tonic-gate uint32_t ul_dinstr; /* scratch space for dtrace */ 9357c478bd9Sstevel@tonic-gate uint32_t ul_padsparc0[15]; 9367c478bd9Sstevel@tonic-gate uint32_t ul_dsave; /* dtrace: save %g1, %g0, %sp */ 9377c478bd9Sstevel@tonic-gate uint32_t ul_drestore; /* dtrace: restore %g0, %g0, %g0 */ 9387c478bd9Sstevel@tonic-gate uint32_t ul_dftret; /* dtrace: return probe fasttrap */ 9397c478bd9Sstevel@tonic-gate uint32_t ul_dreturn; /* dtrace: return %o0 */ 9407c478bd9Sstevel@tonic-gate #endif 9417c478bd9Sstevel@tonic-gate caddr32_t ul_self; /* pointer to self */ 9420ec57554Sraf #if defined(__x86) 9437c478bd9Sstevel@tonic-gate uint8_t ul_dinstr[40]; /* scratch space for dtrace */ 9447c478bd9Sstevel@tonic-gate #endif 9457c478bd9Sstevel@tonic-gate caddr32_t ul_uberdata; /* uber (super-global) data */ 9467c478bd9Sstevel@tonic-gate tls32_t ul_tls; /* dynamic thread-local storage base */ 9477c478bd9Sstevel@tonic-gate caddr32_t ul_forw; /* forw, back all_lwps list, */ 9487c478bd9Sstevel@tonic-gate caddr32_t ul_back; /* protected by link_lock */ 9497c478bd9Sstevel@tonic-gate caddr32_t ul_next; /* list to keep track of stacks */ 9507c478bd9Sstevel@tonic-gate caddr32_t ul_hash; /* hash chain linked list */ 9517c478bd9Sstevel@tonic-gate caddr32_t ul_rval; /* return value from thr_exit() */ 9527c478bd9Sstevel@tonic-gate caddr32_t ul_stk; /* mapping base of the stack */ 9537c478bd9Sstevel@tonic-gate size32_t ul_mapsiz; /* mapping size of the stack */ 9547c478bd9Sstevel@tonic-gate size32_t ul_guardsize; /* normally _lpagesize */ 9557c478bd9Sstevel@tonic-gate caddr32_t ul_stktop; /* broken thr_stksegment() interface */ 9567c478bd9Sstevel@tonic-gate size32_t ul_stksiz; /* broken thr_stksegment() interface */ 9577c478bd9Sstevel@tonic-gate stack32_t ul_ustack; /* current stack boundaries */ 9587c478bd9Sstevel@tonic-gate int ul_ix; /* hash index */ 9597c478bd9Sstevel@tonic-gate lwpid_t ul_lwpid; /* thread id, aka the lwp id */ 960d4204c85Sraf pri_t ul_pri; /* scheduling priority */ 961d4204c85Sraf pri_t ul_epri; /* real-time ceiling priority */ 9627c478bd9Sstevel@tonic-gate char ul_policy; /* scheduling policy */ 963d4204c85Sraf char ul_cid; /* scheduling class id */ 9647c478bd9Sstevel@tonic-gate union { 9657c478bd9Sstevel@tonic-gate struct { 9667c478bd9Sstevel@tonic-gate char cursig; /* deferred signal number */ 9677c478bd9Sstevel@tonic-gate char pleasestop; /* lwp requested to stop itself */ 9687c478bd9Sstevel@tonic-gate } s; 9697c478bd9Sstevel@tonic-gate short curplease; /* for testing both at once */ 9707c478bd9Sstevel@tonic-gate } ul_cp; 9717c478bd9Sstevel@tonic-gate char ul_stop; /* reason for stopping */ 9727c478bd9Sstevel@tonic-gate char ul_signalled; /* this lwp was cond_signal()d */ 9737c478bd9Sstevel@tonic-gate char ul_dead; /* this lwp has called thr_exit */ 9747c478bd9Sstevel@tonic-gate char ul_unwind; /* posix: unwind C++ stack */ 9757c478bd9Sstevel@tonic-gate char ul_detached; /* THR_DETACHED at thread_create() */ 9767c478bd9Sstevel@tonic-gate /* or pthread_detach() was called */ 9777c478bd9Sstevel@tonic-gate char ul_writer; /* sleeping in rw_wrlock() */ 9787c478bd9Sstevel@tonic-gate char ul_stopping; /* set by curthread: stopping self */ 97934709573Sraf char ul_cancel_prologue; /* for _cancel_prologue() */ 9807c478bd9Sstevel@tonic-gate short ul_preempt; /* no_preempt()/preempt() */ 9817c478bd9Sstevel@tonic-gate short ul_savpreempt; /* pre-existing preempt value */ 9827c478bd9Sstevel@tonic-gate char ul_sigsuspend; /* thread is in sigsuspend/pollsys */ 9837c478bd9Sstevel@tonic-gate char ul_main; /* thread is the main thread */ 9847c478bd9Sstevel@tonic-gate char ul_fork; /* thread is performing a fork */ 9857c478bd9Sstevel@tonic-gate char ul_primarymap; /* primary link-map is initialized */ 9867c478bd9Sstevel@tonic-gate /* per-thread copies of the corresponding global variables */ 9875d1dd9a9Sraf uint8_t ul_max_spinners; /* thread_max_spinners */ 9887c478bd9Sstevel@tonic-gate char ul_door_noreserve; /* thread_door_noreserve */ 9897c478bd9Sstevel@tonic-gate char ul_queue_fifo; /* thread_queue_fifo */ 9907c478bd9Sstevel@tonic-gate char ul_cond_wait_defer; /* thread_cond_wait_defer */ 9917c478bd9Sstevel@tonic-gate char ul_error_detection; /* thread_error_detection */ 9927c478bd9Sstevel@tonic-gate char ul_async_safe; /* thread_async_safe */ 993d4204c85Sraf char ul_rt; /* found on an RT queue */ 994d4204c85Sraf char ul_rtqueued; /* was RT when queued */ 9957c5714f6Sraf char ul_misaligned; /* thread_locks_misaligned */ 9967c5714f6Sraf char ul_pad[3]; 9977c478bd9Sstevel@tonic-gate int ul_adaptive_spin; /* thread_adaptive_spin */ 9987c478bd9Sstevel@tonic-gate int ul_queue_spin; /* thread_queue_spin */ 9997c478bd9Sstevel@tonic-gate int ul_critical; /* non-zero == in a critical region */ 10007c478bd9Sstevel@tonic-gate int ul_sigdefer; /* non-zero == defer signals */ 10017c478bd9Sstevel@tonic-gate int ul_vfork; /* thread is the child of vfork() */ 10027c478bd9Sstevel@tonic-gate int ul_cancelable; /* _cancelon()/_canceloff() */ 10037c478bd9Sstevel@tonic-gate char ul_cancel_pending; /* pthread_cancel() was called */ 10047c478bd9Sstevel@tonic-gate char ul_cancel_disabled; /* PTHREAD_CANCEL_DISABLE */ 10057c478bd9Sstevel@tonic-gate char ul_cancel_async; /* PTHREAD_CANCEL_ASYNCHRONOUS */ 10067c478bd9Sstevel@tonic-gate char ul_save_async; /* saved copy of ul_cancel_async */ 10077c478bd9Sstevel@tonic-gate char ul_mutator; /* lwp is a mutator (java interface) */ 10087c478bd9Sstevel@tonic-gate char ul_created; /* created suspended */ 10097c478bd9Sstevel@tonic-gate char ul_replace; /* replacement; must be free()d */ 10107c478bd9Sstevel@tonic-gate uchar_t ul_nocancel; /* cancellation can't happen */ 10117c478bd9Sstevel@tonic-gate int ul_errno; /* per-thread errno */ 10127c478bd9Sstevel@tonic-gate caddr32_t ul_errnop; /* pointer to errno or self->ul_errno */ 10137c478bd9Sstevel@tonic-gate caddr32_t ul_clnup_hdr; /* head of cleanup handlers list */ 10147c478bd9Sstevel@tonic-gate caddr32_t ul_schedctl_called; /* ul_schedctl is set up */ 10157c478bd9Sstevel@tonic-gate caddr32_t ul_schedctl; /* schedctl data */ 10167c478bd9Sstevel@tonic-gate int ul_bindflags; /* bind_guard() interface to ld.so.1 */ 1017a574db85Sraf uint_t ul_libc_locks; /* count of cancel_safe_mutex_lock()s */ 10187c478bd9Sstevel@tonic-gate caddr32_t ul_stsd; /* slow TLS for keys >= TSD_NFAST */ 10197c478bd9Sstevel@tonic-gate caddr32_t ul_ftsd[TSD_NFAST]; /* fast TLS for keys < TSD_NFAST */ 10207c478bd9Sstevel@tonic-gate td_evbuf32_t ul_td_evbuf; /* event buffer */ 10217c478bd9Sstevel@tonic-gate char ul_td_events_enable; /* event mechanism enabled */ 10227c478bd9Sstevel@tonic-gate char ul_sync_obj_reg; /* tdb_sync_obj_register() */ 10237c478bd9Sstevel@tonic-gate char ul_qtype; /* MX or CV */ 10247c478bd9Sstevel@tonic-gate char ul_cv_wake; /* != 0: just wake up, don't requeue */ 1025e54ab87fSRoger A. Faulkner int ul_rtld; /* thread is running inside ld.so.1 */ 10267c478bd9Sstevel@tonic-gate int ul_usropts; /* flags given to thr_create() */ 10277c478bd9Sstevel@tonic-gate caddr32_t ul_startpc; /* start func (thr_create()) */ 10287c478bd9Sstevel@tonic-gate caddr32_t ul_startarg; /* argument for start function */ 10297c478bd9Sstevel@tonic-gate caddr32_t ul_wchan; /* synch object when sleeping */ 10307c478bd9Sstevel@tonic-gate caddr32_t ul_link; /* sleep queue link */ 10317c478bd9Sstevel@tonic-gate caddr32_t ul_sleepq; /* sleep queue thread is waiting on */ 10327c478bd9Sstevel@tonic-gate caddr32_t ul_cvmutex; /* mutex dropped when waiting on a cv */ 10337c478bd9Sstevel@tonic-gate caddr32_t ul_mxchain; /* chain of owned ceiling mutexes */ 1034d4204c85Sraf int ul_save_state; /* bind_guard() interface to ld.so.1 */ 1035883492d5Sraf uint_t ul_rdlockcnt; /* # entries in ul_readlock array */ 1036883492d5Sraf /* 0 means there is but a single entry */ 1037883492d5Sraf union { /* single entry or pointer to array */ 10387c478bd9Sstevel@tonic-gate readlock32_t single; 10397c478bd9Sstevel@tonic-gate caddr32_t array; 10407c478bd9Sstevel@tonic-gate } ul_readlock; 1041883492d5Sraf uint_t ul_heldlockcnt; /* # entries in ul_heldlocks array */ 1042883492d5Sraf /* 0 means there is but a single entry */ 1043883492d5Sraf union { /* single entry or pointer to array */ 1044883492d5Sraf caddr32_t single; 1045883492d5Sraf caddr32_t array; 1046883492d5Sraf } ul_heldlocks; 10477c478bd9Sstevel@tonic-gate /* PROBE_SUPPORT begin */ 10487c478bd9Sstevel@tonic-gate caddr32_t ul_tpdp; 10497c478bd9Sstevel@tonic-gate /* PROBE_SUPPORT end */ 10507c478bd9Sstevel@tonic-gate caddr32_t ul_siglink; /* pointer to previous context */ 10517c478bd9Sstevel@tonic-gate uint_t ul_spin_lock_spin; /* spin lock statistics */ 10527c478bd9Sstevel@tonic-gate uint_t ul_spin_lock_spin2; 10537c478bd9Sstevel@tonic-gate uint_t ul_spin_lock_sleep; 10547c478bd9Sstevel@tonic-gate uint_t ul_spin_lock_wakeup; 1055d4204c85Sraf queue_root32_t ul_queue_root; /* root of a sleep queue */ 1056d4204c85Sraf id_t ul_rtclassid; /* real-time class id */ 1057d4204c85Sraf uint_t ul_pilocks; /* count of PI locks held */ 10587c478bd9Sstevel@tonic-gate /* the following members *must* be last in the structure */ 10597c478bd9Sstevel@tonic-gate /* they are discarded when ulwp is replaced on thr_exit() */ 10607c478bd9Sstevel@tonic-gate sigset32_t ul_sigmask; /* thread's current signal mask */ 10617c478bd9Sstevel@tonic-gate sigset32_t ul_tmpmask; /* signal mask for sigsuspend/pollsys */ 10627c478bd9Sstevel@tonic-gate siginfo32_t ul_siginfo; /* deferred siginfo */ 10637c478bd9Sstevel@tonic-gate mutex_t ul_spinlock; /* used when suspending/continuing */ 10647c478bd9Sstevel@tonic-gate fpuenv32_t ul_fpuenv; /* floating point state */ 10657c478bd9Sstevel@tonic-gate caddr32_t ul_sp; /* stack pointer when blocked */ 10667c478bd9Sstevel@tonic-gate #if defined(sparc) 10677c478bd9Sstevel@tonic-gate caddr32_t ul_unwind_ret; /* used only by _ex_clnup_handler() */ 10687c478bd9Sstevel@tonic-gate #endif 10697c478bd9Sstevel@tonic-gate } ulwp32_t; 10707c478bd9Sstevel@tonic-gate 10717c478bd9Sstevel@tonic-gate #define REPLACEMENT_SIZE32 ((size_t)&((ulwp32_t *)NULL)->ul_sigmask) 10727c478bd9Sstevel@tonic-gate 10737c478bd9Sstevel@tonic-gate typedef struct uberdata32 { 10747c478bd9Sstevel@tonic-gate pad_lock_t _link_lock; 10758cd45542Sraf pad_lock_t _ld_lock; 10768cd45542Sraf pad_lock_t _fork_lock; 10778cd45542Sraf pad_lock_t _atfork_lock; 107898c1a6b4Sraf pad32_lock_t _callout_lock; 107998c1a6b4Sraf pad32_lock_t _tdb_hash_lock; 10807c478bd9Sstevel@tonic-gate tdb_sync_stats_t tdb_hash_lock_stats; 10817c478bd9Sstevel@tonic-gate siguaction32_t siguaction[NSIG]; 10827c478bd9Sstevel@tonic-gate bucket32_t bucket[NBUCKETS]; 10837c478bd9Sstevel@tonic-gate atexit_root32_t atexit_root; 10847c478bd9Sstevel@tonic-gate tsd_metadata32_t tsd_metadata; 10857c478bd9Sstevel@tonic-gate tls_metadata32_t tls_metadata; 10867c478bd9Sstevel@tonic-gate char primary_map; 10877c478bd9Sstevel@tonic-gate char bucket_init; 10887c478bd9Sstevel@tonic-gate char pad[2]; 10897c478bd9Sstevel@tonic-gate uberflags_t uberflags; 10907c478bd9Sstevel@tonic-gate caddr32_t queue_head; 10917c478bd9Sstevel@tonic-gate caddr32_t thr_hash_table; 10927c478bd9Sstevel@tonic-gate uint_t hash_size; 10937c478bd9Sstevel@tonic-gate uint_t hash_mask; 10947c478bd9Sstevel@tonic-gate caddr32_t ulwp_one; 10957c478bd9Sstevel@tonic-gate caddr32_t all_lwps; 10967c478bd9Sstevel@tonic-gate caddr32_t all_zombies; 10977c478bd9Sstevel@tonic-gate int nthreads; 10987c478bd9Sstevel@tonic-gate int nzombies; 10997c478bd9Sstevel@tonic-gate int ndaemons; 11007c478bd9Sstevel@tonic-gate int pid; 11017c478bd9Sstevel@tonic-gate caddr32_t sigacthandler; 11027c478bd9Sstevel@tonic-gate caddr32_t lwp_stacks; 11037c478bd9Sstevel@tonic-gate caddr32_t lwp_laststack; 11047c478bd9Sstevel@tonic-gate int nfreestack; 11057c478bd9Sstevel@tonic-gate int thread_stack_cache; 11067c478bd9Sstevel@tonic-gate caddr32_t ulwp_freelist; 11077c478bd9Sstevel@tonic-gate caddr32_t ulwp_lastfree; 11087c478bd9Sstevel@tonic-gate caddr32_t ulwp_replace_free; 11097c478bd9Sstevel@tonic-gate caddr32_t ulwp_replace_last; 11107c478bd9Sstevel@tonic-gate caddr32_t atforklist; 1111883492d5Sraf caddr32_t robustlocks; 111209ce0d4aSRoger A. Faulkner caddr32_t robustlist; 11137c478bd9Sstevel@tonic-gate caddr32_t tdb_bootstrap; 11147c478bd9Sstevel@tonic-gate tdb32_t tdb; 11157c478bd9Sstevel@tonic-gate } uberdata32_t; 11167c478bd9Sstevel@tonic-gate 11177c478bd9Sstevel@tonic-gate #endif /* _SYSCALL32 */ 11187c478bd9Sstevel@tonic-gate 11197c478bd9Sstevel@tonic-gate /* ul_stop values */ 11207c478bd9Sstevel@tonic-gate #define TSTP_REGULAR 0x01 /* Stopped by thr_suspend() */ 11217c478bd9Sstevel@tonic-gate #define TSTP_MUTATOR 0x08 /* stopped by thr_suspend_*mutator*() */ 11227c478bd9Sstevel@tonic-gate #define TSTP_FORK 0x20 /* stopped by suspend_fork() */ 11237c478bd9Sstevel@tonic-gate 11247c478bd9Sstevel@tonic-gate /* 11257c478bd9Sstevel@tonic-gate * Implementation-specific attribute types for pthread_mutexattr_init() etc. 11267c478bd9Sstevel@tonic-gate */ 11277c478bd9Sstevel@tonic-gate 11287c478bd9Sstevel@tonic-gate typedef struct _cvattr { 11297c478bd9Sstevel@tonic-gate int pshared; 11307c478bd9Sstevel@tonic-gate clockid_t clockid; 11317c478bd9Sstevel@tonic-gate } cvattr_t; 11327c478bd9Sstevel@tonic-gate 11337c478bd9Sstevel@tonic-gate typedef struct _mattr { 11347c478bd9Sstevel@tonic-gate int pshared; 11357c478bd9Sstevel@tonic-gate int protocol; 11367c478bd9Sstevel@tonic-gate int prioceiling; 11377c478bd9Sstevel@tonic-gate int type; 11387c478bd9Sstevel@tonic-gate int robustness; 11397c478bd9Sstevel@tonic-gate } mattr_t; 11407c478bd9Sstevel@tonic-gate 11417c478bd9Sstevel@tonic-gate typedef struct _thrattr { 11427c478bd9Sstevel@tonic-gate size_t stksize; 11437c478bd9Sstevel@tonic-gate void *stkaddr; 11447c478bd9Sstevel@tonic-gate int detachstate; 114534709573Sraf int daemonstate; 11467c478bd9Sstevel@tonic-gate int scope; 11477c478bd9Sstevel@tonic-gate int prio; 11487c478bd9Sstevel@tonic-gate int policy; 11497c478bd9Sstevel@tonic-gate int inherit; 11507c478bd9Sstevel@tonic-gate size_t guardsize; 11517c478bd9Sstevel@tonic-gate } thrattr_t; 11527c478bd9Sstevel@tonic-gate 11537c478bd9Sstevel@tonic-gate typedef struct _rwlattr { 11547c478bd9Sstevel@tonic-gate int pshared; 11557c478bd9Sstevel@tonic-gate } rwlattr_t; 11567c478bd9Sstevel@tonic-gate 11577c478bd9Sstevel@tonic-gate /* _curthread() is inline for speed */ 11587c478bd9Sstevel@tonic-gate extern ulwp_t *_curthread(void); 11597c478bd9Sstevel@tonic-gate #define curthread (_curthread()) 11607c478bd9Sstevel@tonic-gate 11617c478bd9Sstevel@tonic-gate /* this version (also inline) can be tested for NULL */ 11627c478bd9Sstevel@tonic-gate extern ulwp_t *__curthread(void); 11637c478bd9Sstevel@tonic-gate 11647c478bd9Sstevel@tonic-gate /* get the current stack pointer (also inline) */ 11657c478bd9Sstevel@tonic-gate extern greg_t stkptr(void); 11667c478bd9Sstevel@tonic-gate 11677c478bd9Sstevel@tonic-gate /* 11687c478bd9Sstevel@tonic-gate * Suppress __attribute__((...)) if we are not compiling with gcc 11697c478bd9Sstevel@tonic-gate */ 11707c478bd9Sstevel@tonic-gate #if !defined(__GNUC__) 11717c478bd9Sstevel@tonic-gate #define __attribute__(string) 11727c478bd9Sstevel@tonic-gate #endif 11737c478bd9Sstevel@tonic-gate 1174d4204c85Sraf /* Fetch the dispatch (kernel) priority of a thread */ 1175d4204c85Sraf #define real_priority(ulwp) \ 1176d4204c85Sraf ((ulwp)->ul_schedctl? (ulwp)->ul_schedctl->sc_priority : 0) 1177d4204c85Sraf 11787c478bd9Sstevel@tonic-gate /* 11797c478bd9Sstevel@tonic-gate * Implementation functions. Not visible outside of the library itself. 11807c478bd9Sstevel@tonic-gate */ 1181f841f6adSraf extern int __nanosleep(const timespec_t *, timespec_t *); 11827c478bd9Sstevel@tonic-gate extern void getgregs(ulwp_t *, gregset_t); 11837c478bd9Sstevel@tonic-gate extern void setgregs(ulwp_t *, gregset_t); 11847c478bd9Sstevel@tonic-gate extern void thr_panic(const char *); 11857c478bd9Sstevel@tonic-gate #pragma rarely_called(thr_panic) 11867c478bd9Sstevel@tonic-gate extern ulwp_t *find_lwp(thread_t); 11877c478bd9Sstevel@tonic-gate extern void finish_init(void); 1188d4204c85Sraf extern void update_sched(ulwp_t *); 11897c478bd9Sstevel@tonic-gate extern void queue_alloc(void); 11907c478bd9Sstevel@tonic-gate extern void tsd_exit(void); 11917c478bd9Sstevel@tonic-gate extern void tsd_free(ulwp_t *); 11927c478bd9Sstevel@tonic-gate extern void tls_setup(void); 11937c478bd9Sstevel@tonic-gate extern void tls_exit(void); 11947c478bd9Sstevel@tonic-gate extern void tls_free(ulwp_t *); 11957c478bd9Sstevel@tonic-gate extern void rwl_free(ulwp_t *); 1196883492d5Sraf extern void heldlock_exit(void); 1197883492d5Sraf extern void heldlock_free(ulwp_t *); 11987c478bd9Sstevel@tonic-gate extern void sigacthandler(int, siginfo_t *, void *); 11997c478bd9Sstevel@tonic-gate extern void signal_init(void); 12007c478bd9Sstevel@tonic-gate extern int sigequalset(const sigset_t *, const sigset_t *); 12017c478bd9Sstevel@tonic-gate extern void mutex_setup(void); 12027c478bd9Sstevel@tonic-gate extern void take_deferred_signal(int); 1203373d25a2SRoger A. Faulkner extern void *setup_top_frame(void *, size_t, ulwp_t *); 12047c478bd9Sstevel@tonic-gate extern int setup_context(ucontext_t *, void *(*func)(ulwp_t *), 12057c478bd9Sstevel@tonic-gate ulwp_t *ulwp, caddr_t stk, size_t stksize); 12067c478bd9Sstevel@tonic-gate extern volatile sc_shared_t *setup_schedctl(void); 12077c478bd9Sstevel@tonic-gate extern void *lmalloc(size_t); 12087c478bd9Sstevel@tonic-gate extern void lfree(void *, size_t); 12097c478bd9Sstevel@tonic-gate extern void *libc_malloc(size_t); 12107c478bd9Sstevel@tonic-gate extern void *libc_realloc(void *, size_t); 12117c478bd9Sstevel@tonic-gate extern void libc_free(void *); 12127c478bd9Sstevel@tonic-gate extern char *libc_strdup(const char *); 12137c478bd9Sstevel@tonic-gate extern void ultos(uint64_t, int, char *); 12147c478bd9Sstevel@tonic-gate extern void lock_error(const mutex_t *, const char *, void *, const char *); 12157c478bd9Sstevel@tonic-gate extern void rwlock_error(const rwlock_t *, const char *, const char *); 12167c478bd9Sstevel@tonic-gate extern void thread_error(const char *); 12177c478bd9Sstevel@tonic-gate extern void grab_assert_lock(void); 12187c478bd9Sstevel@tonic-gate extern void dump_queue_statistics(void); 12197c478bd9Sstevel@tonic-gate extern void collect_queue_statistics(void); 12207c478bd9Sstevel@tonic-gate extern void record_spin_locks(ulwp_t *); 1221883492d5Sraf extern void remember_lock(mutex_t *); 1222883492d5Sraf extern void forget_lock(mutex_t *); 1223883492d5Sraf extern void register_lock(mutex_t *); 1224c242ec1bSRoger A. Faulkner extern void unregister_locks(void); 12257c478bd9Sstevel@tonic-gate #if defined(__sparc) 12267c478bd9Sstevel@tonic-gate extern void _flush_windows(void); 12277c478bd9Sstevel@tonic-gate #else 12287c478bd9Sstevel@tonic-gate #define _flush_windows() 12297c478bd9Sstevel@tonic-gate #endif 12307c478bd9Sstevel@tonic-gate extern void set_curthread(void *); 12317c478bd9Sstevel@tonic-gate 123241efec22Sraf /* 1233883492d5Sraf * Utility function used when waking up many threads (more than MAXLWPS) 1234883492d5Sraf * all at once. See mutex_wakeup_all(), cond_broadcast(), and rw_unlock(). 123541efec22Sraf */ 123641efec22Sraf #define MAXLWPS 128 /* max remembered lwpids before overflow */ 123741efec22Sraf #define NEWLWPS 2048 /* max remembered lwpids at first overflow */ 123841efec22Sraf extern lwpid_t *alloc_lwpids(lwpid_t *, int *, int *); 123941efec22Sraf 12407c478bd9Sstevel@tonic-gate /* enter a critical section */ 12417c478bd9Sstevel@tonic-gate #define enter_critical(self) (self->ul_critical++) 12427c478bd9Sstevel@tonic-gate 12437c478bd9Sstevel@tonic-gate /* exit a critical section, take deferred actions if necessary */ 12447c478bd9Sstevel@tonic-gate extern void do_exit_critical(void); 12457c478bd9Sstevel@tonic-gate #define exit_critical(self) \ 12467c478bd9Sstevel@tonic-gate (void) (self->ul_critical--, \ 12477c478bd9Sstevel@tonic-gate ((self->ul_curplease && self->ul_critical == 0)? \ 12487c478bd9Sstevel@tonic-gate (do_exit_critical(), 0) : 0)) 12497c478bd9Sstevel@tonic-gate 12507c478bd9Sstevel@tonic-gate /* 12517c478bd9Sstevel@tonic-gate * Like enter_critical()/exit_critical() but just for deferring signals. 12527c478bd9Sstevel@tonic-gate * Unlike enter_critical()/exit_critical(), ul_sigdefer may be set while 12537c478bd9Sstevel@tonic-gate * calling application functions like constructors and destructors. 12547c478bd9Sstevel@tonic-gate * Care must be taken if the application function attempts to set 12557c478bd9Sstevel@tonic-gate * the signal mask while a deferred signal is present; the setting 12567c478bd9Sstevel@tonic-gate * of the signal mask must also be deferred. 12577c478bd9Sstevel@tonic-gate */ 12587c478bd9Sstevel@tonic-gate #define sigoff(self) (self->ul_sigdefer++) 1259e54ab87fSRoger A. Faulkner #define sigon(self) \ 1260e54ab87fSRoger A. Faulkner (void) ((--self->ul_sigdefer == 0 && \ 1261e54ab87fSRoger A. Faulkner self->ul_curplease && self->ul_critical == 0)? \ 1262e54ab87fSRoger A. Faulkner (do_exit_critical(), 0) : 0) 12637c478bd9Sstevel@tonic-gate 12647c478bd9Sstevel@tonic-gate /* these are exported functions */ 12657c478bd9Sstevel@tonic-gate extern void _sigoff(void); 12667c478bd9Sstevel@tonic-gate extern void _sigon(void); 12677c478bd9Sstevel@tonic-gate 12687c478bd9Sstevel@tonic-gate #define sigorset(s1, s2) \ 12697c478bd9Sstevel@tonic-gate (((s1)->__sigbits[0] |= (s2)->__sigbits[0]), \ 12707c478bd9Sstevel@tonic-gate ((s1)->__sigbits[1] |= (s2)->__sigbits[1]), \ 12717c478bd9Sstevel@tonic-gate ((s1)->__sigbits[2] |= (s2)->__sigbits[2]), \ 12727c478bd9Sstevel@tonic-gate ((s1)->__sigbits[3] |= (s2)->__sigbits[3])) 12737c478bd9Sstevel@tonic-gate 12747c478bd9Sstevel@tonic-gate #define sigandset(s1, s2) \ 12757c478bd9Sstevel@tonic-gate (((s1)->__sigbits[0] &= (s2)->__sigbits[0]), \ 12767c478bd9Sstevel@tonic-gate ((s1)->__sigbits[1] &= (s2)->__sigbits[1]), \ 12777c478bd9Sstevel@tonic-gate ((s1)->__sigbits[2] &= (s2)->__sigbits[2]), \ 12787c478bd9Sstevel@tonic-gate ((s1)->__sigbits[3] &= (s2)->__sigbits[3])) 12797c478bd9Sstevel@tonic-gate 12807c478bd9Sstevel@tonic-gate #define sigdiffset(s1, s2) \ 12817c478bd9Sstevel@tonic-gate (((s1)->__sigbits[0] &= ~(s2)->__sigbits[0]), \ 12827c478bd9Sstevel@tonic-gate ((s1)->__sigbits[1] &= ~(s2)->__sigbits[1]), \ 12837c478bd9Sstevel@tonic-gate ((s1)->__sigbits[2] &= ~(s2)->__sigbits[2]), \ 12847c478bd9Sstevel@tonic-gate ((s1)->__sigbits[3] &= ~(s2)->__sigbits[3])) 12857c478bd9Sstevel@tonic-gate 12867c478bd9Sstevel@tonic-gate #define delete_reserved_signals(s) \ 12877c478bd9Sstevel@tonic-gate (((s)->__sigbits[0] &= MASKSET0), \ 12887c478bd9Sstevel@tonic-gate ((s)->__sigbits[1] &= (MASKSET1 & ~SIGMASK(SIGCANCEL))),\ 12897c478bd9Sstevel@tonic-gate ((s)->__sigbits[2] = 0), \ 12907c478bd9Sstevel@tonic-gate ((s)->__sigbits[3] = 0)) 12917c478bd9Sstevel@tonic-gate 12927c478bd9Sstevel@tonic-gate extern void block_all_signals(ulwp_t *self); 12937c478bd9Sstevel@tonic-gate 12947c478bd9Sstevel@tonic-gate /* 12957c478bd9Sstevel@tonic-gate * When restoring the signal mask after having previously called 12967c478bd9Sstevel@tonic-gate * block_all_signals(), if we have a deferred signal present then 12977c478bd9Sstevel@tonic-gate * do nothing other than ASSERT() that we are in a critical region. 12987c478bd9Sstevel@tonic-gate * The signal mask will be set when we emerge from the critical region 12997c478bd9Sstevel@tonic-gate * and call take_deferred_signal(). There is no race condition here 13007c478bd9Sstevel@tonic-gate * because the kernel currently has all signals blocked for this thread. 13017c478bd9Sstevel@tonic-gate */ 13027c478bd9Sstevel@tonic-gate #define restore_signals(self) \ 13037c478bd9Sstevel@tonic-gate ((void) ((self)->ul_cursig? \ 13047c478bd9Sstevel@tonic-gate (ASSERT((self)->ul_critical + (self)->ul_sigdefer != 0), 0) : \ 13057c478bd9Sstevel@tonic-gate __lwp_sigmask(SIG_SETMASK, &(self)->ul_sigmask, NULL))) 13067c478bd9Sstevel@tonic-gate 1307a574db85Sraf extern void set_cancel_pending_flag(ulwp_t *, int); 1308a574db85Sraf extern void set_cancel_eintr_flag(ulwp_t *); 13097c478bd9Sstevel@tonic-gate extern void set_parking_flag(ulwp_t *, int); 1310a574db85Sraf extern int cancel_active(void); 13117c478bd9Sstevel@tonic-gate 13127257d1b4Sraf extern void *_thrp_setup(ulwp_t *); 13137c478bd9Sstevel@tonic-gate extern void _fpinherit(ulwp_t *); 13147c478bd9Sstevel@tonic-gate extern void _lwp_start(void); 13157c478bd9Sstevel@tonic-gate extern void _lwp_terminate(void); 13167c478bd9Sstevel@tonic-gate extern void lmutex_lock(mutex_t *); 1317f841f6adSraf extern void lmutex_unlock(mutex_t *); 131841efec22Sraf extern void lrw_rdlock(rwlock_t *); 131941efec22Sraf extern void lrw_wrlock(rwlock_t *); 132041efec22Sraf extern void lrw_unlock(rwlock_t *); 1321f841f6adSraf extern void sig_mutex_lock(mutex_t *); 1322f841f6adSraf extern void sig_mutex_unlock(mutex_t *); 1323f841f6adSraf extern int sig_mutex_trylock(mutex_t *); 1324f841f6adSraf extern int sig_cond_wait(cond_t *, mutex_t *); 1325f841f6adSraf extern int sig_cond_reltimedwait(cond_t *, mutex_t *, const timespec_t *); 1326a574db85Sraf extern void cancel_safe_mutex_lock(mutex_t *); 1327a574db85Sraf extern void cancel_safe_mutex_unlock(mutex_t *); 1328a574db85Sraf extern int cancel_safe_mutex_trylock(mutex_t *); 13297c478bd9Sstevel@tonic-gate extern void _prefork_handler(void); 13307c478bd9Sstevel@tonic-gate extern void _postfork_parent_handler(void); 13317c478bd9Sstevel@tonic-gate extern void _postfork_child_handler(void); 1332f841f6adSraf extern void postfork1_child(void); 1333f841f6adSraf extern void postfork1_child_aio(void); 1334f841f6adSraf extern void postfork1_child_sigev_aio(void); 1335f841f6adSraf extern void postfork1_child_sigev_mq(void); 1336f841f6adSraf extern void postfork1_child_sigev_timer(void); 1337f841f6adSraf extern void postfork1_child_tpool(void); 13382e145884Sraf extern void fork_lock_enter(void); 13397c478bd9Sstevel@tonic-gate extern void fork_lock_exit(void); 13407c478bd9Sstevel@tonic-gate extern void suspend_fork(void); 13417c478bd9Sstevel@tonic-gate extern void continue_fork(int); 13427c478bd9Sstevel@tonic-gate extern void do_sigcancel(void); 1343f841f6adSraf extern void setup_cancelsig(int); 1344f841f6adSraf extern void init_sigev_thread(void); 1345f841f6adSraf extern void init_aio(void); 13467c478bd9Sstevel@tonic-gate extern void _cancelon(void); 13477c478bd9Sstevel@tonic-gate extern void _canceloff(void); 13487c478bd9Sstevel@tonic-gate extern void _canceloff_nocancel(void); 1349f841f6adSraf extern void _cancel_prologue(void); 1350f841f6adSraf extern void _cancel_epilogue(void); 13517c478bd9Sstevel@tonic-gate extern void no_preempt(ulwp_t *); 13527c478bd9Sstevel@tonic-gate extern void preempt(ulwp_t *); 13537c478bd9Sstevel@tonic-gate extern void _thrp_unwind(void *); 13547c478bd9Sstevel@tonic-gate 1355657b1f3dSraf extern pid_t __forkx(int); 1356657b1f3dSraf extern pid_t __forkallx(int); 1357*8fd04b83SRoger A. Faulkner extern int __open(const char *, int, mode_t); 1358*8fd04b83SRoger A. Faulkner extern int __open64(const char *, int, mode_t); 1359*8fd04b83SRoger A. Faulkner extern int __openat(int, const char *, int, mode_t); 1360*8fd04b83SRoger A. Faulkner extern int __openat64(int, const char *, int, mode_t); 13618cd45542Sraf extern int __close(int); 1362a574db85Sraf extern ssize_t __read(int, void *, size_t); 1363a574db85Sraf extern ssize_t __write(int, const void *, size_t); 13648cd45542Sraf extern int __fcntl(int, int, ...); 13657c478bd9Sstevel@tonic-gate extern int __lwp_continue(lwpid_t); 13667c478bd9Sstevel@tonic-gate extern int __lwp_create(ucontext_t *, uint_t, lwpid_t *); 13677c478bd9Sstevel@tonic-gate extern int ___lwp_suspend(lwpid_t); 13687c478bd9Sstevel@tonic-gate extern int lwp_wait(lwpid_t, lwpid_t *); 13697c478bd9Sstevel@tonic-gate extern int __lwp_wait(lwpid_t, lwpid_t *); 13707c478bd9Sstevel@tonic-gate extern int __lwp_detach(lwpid_t); 13717c478bd9Sstevel@tonic-gate extern sc_shared_t *__schedctl(void); 13727c478bd9Sstevel@tonic-gate 13737c478bd9Sstevel@tonic-gate /* actual system call traps */ 13748cd45542Sraf extern int __setcontext(const ucontext_t *); 13758cd45542Sraf extern int __getcontext(ucontext_t *); 13767c478bd9Sstevel@tonic-gate extern int __clock_gettime(clockid_t, timespec_t *); 13777c478bd9Sstevel@tonic-gate extern void abstime_to_reltime(clockid_t, const timespec_t *, timespec_t *); 13787c478bd9Sstevel@tonic-gate extern void hrt2ts(hrtime_t, timespec_t *); 13797c478bd9Sstevel@tonic-gate 13807c478bd9Sstevel@tonic-gate extern int __sigaction(int, const struct sigaction *, struct sigaction *); 13817c478bd9Sstevel@tonic-gate extern int __lwp_sigmask(int, const sigset_t *, sigset_t *); 13827c478bd9Sstevel@tonic-gate extern void __sighndlr(int, siginfo_t *, ucontext_t *, void (*)()); 13837c478bd9Sstevel@tonic-gate extern caddr_t __sighndlrend; 13847c478bd9Sstevel@tonic-gate #pragma unknown_control_flow(__sighndlr) 1385f841f6adSraf 1386f841f6adSraf /* belongs in <pthread.h> */ 1387f841f6adSraf #define PTHREAD_CREATE_DAEMON_NP 0x100 /* = THR_DAEMON */ 1388f841f6adSraf #define PTHREAD_CREATE_NONDAEMON_NP 0 13897257d1b4Sraf extern int pthread_attr_setdaemonstate_np(pthread_attr_t *, int); 13907257d1b4Sraf extern int pthread_attr_getdaemonstate_np(const pthread_attr_t *, int *); 13917257d1b4Sraf 13927257d1b4Sraf extern int mutex_held(mutex_t *); 1393d4204c85Sraf extern int mutex_lock_internal(mutex_t *, timespec_t *, int); 1394d4204c85Sraf extern int mutex_unlock_internal(mutex_t *, int); 13957c478bd9Sstevel@tonic-gate 1396a574db85Sraf /* not cancellation points: */ 1397a574db85Sraf extern int __cond_wait(cond_t *, mutex_t *); 1398a574db85Sraf extern int __cond_timedwait(cond_t *, mutex_t *, const timespec_t *); 1399a574db85Sraf extern int __cond_reltimedwait(cond_t *, mutex_t *, const timespec_t *); 14007c478bd9Sstevel@tonic-gate 14017257d1b4Sraf extern int rw_read_held(rwlock_t *); 14027257d1b4Sraf extern int rw_write_held(rwlock_t *); 1403cb620785Sraf 1404f841f6adSraf extern int _thrp_create(void *, size_t, void *(*)(void *), void *, long, 1405d4204c85Sraf thread_t *, size_t); 14067c478bd9Sstevel@tonic-gate extern int _thrp_suspend(thread_t, uchar_t); 14077c478bd9Sstevel@tonic-gate extern int _thrp_continue(thread_t, uchar_t); 14087c478bd9Sstevel@tonic-gate 14097257d1b4Sraf extern void _thrp_terminate(void *); 14107c478bd9Sstevel@tonic-gate extern void _thrp_exit(void); 14117c478bd9Sstevel@tonic-gate 1412d4204c85Sraf extern const pcclass_t *get_info_by_class(id_t); 1413d4204c85Sraf extern const pcclass_t *get_info_by_policy(int); 141434709573Sraf extern const thrattr_t *def_thrattr(void); 1415d4204c85Sraf extern id_t setparam(idtype_t, id_t, int, int); 1416d4204c85Sraf extern id_t setprio(idtype_t, id_t, int, int *); 1417d4204c85Sraf extern id_t getparam(idtype_t, id_t, int *, struct sched_param *); 14187c478bd9Sstevel@tonic-gate 14197c478bd9Sstevel@tonic-gate /* 14207c478bd9Sstevel@tonic-gate * System call wrappers (direct interfaces to the kernel) 14217c478bd9Sstevel@tonic-gate */ 1422c242ec1bSRoger A. Faulkner extern int ___lwp_mutex_register(mutex_t *, mutex_t **); 1423db94676fSRoger A. Faulkner extern int ___lwp_mutex_trylock(mutex_t *, ulwp_t *); 1424db94676fSRoger A. Faulkner extern int ___lwp_mutex_timedlock(mutex_t *, timespec_t *, ulwp_t *); 14257c478bd9Sstevel@tonic-gate extern int ___lwp_mutex_unlock(mutex_t *); 1426883492d5Sraf extern int ___lwp_mutex_wakeup(mutex_t *, int); 14277c478bd9Sstevel@tonic-gate extern int ___lwp_cond_wait(cond_t *, mutex_t *, timespec_t *, int); 14287c478bd9Sstevel@tonic-gate extern int ___lwp_sema_timedwait(lwp_sema_t *, timespec_t *, int); 14297c478bd9Sstevel@tonic-gate extern int __lwp_rwlock_rdlock(rwlock_t *, timespec_t *); 14307c478bd9Sstevel@tonic-gate extern int __lwp_rwlock_wrlock(rwlock_t *, timespec_t *); 14317c478bd9Sstevel@tonic-gate extern int __lwp_rwlock_tryrdlock(rwlock_t *); 14327c478bd9Sstevel@tonic-gate extern int __lwp_rwlock_trywrlock(rwlock_t *); 14337c478bd9Sstevel@tonic-gate extern int __lwp_rwlock_unlock(rwlock_t *); 14347c478bd9Sstevel@tonic-gate extern int __lwp_park(timespec_t *, lwpid_t); 14357c478bd9Sstevel@tonic-gate extern int __lwp_unpark(lwpid_t); 14367c478bd9Sstevel@tonic-gate extern int __lwp_unpark_all(lwpid_t *, int); 14370ec57554Sraf #if defined(__x86) 14387c478bd9Sstevel@tonic-gate extern int ___lwp_private(int, int, void *); 14390ec57554Sraf #endif /* __x86 */ 14407c478bd9Sstevel@tonic-gate 14417c478bd9Sstevel@tonic-gate /* 14427c478bd9Sstevel@tonic-gate * inlines 14437c478bd9Sstevel@tonic-gate */ 14447c478bd9Sstevel@tonic-gate extern int set_lock_byte(volatile uint8_t *); 144541efec22Sraf extern uint32_t atomic_swap_32(volatile uint32_t *, uint32_t); 144641efec22Sraf extern uint32_t atomic_cas_32(volatile uint32_t *, uint32_t, uint32_t); 144741efec22Sraf extern void atomic_inc_32(volatile uint32_t *); 144841efec22Sraf extern void atomic_dec_32(volatile uint32_t *); 144941efec22Sraf extern void atomic_and_32(volatile uint32_t *, uint32_t); 145041efec22Sraf extern void atomic_or_32(volatile uint32_t *, uint32_t); 14510ec57554Sraf #if defined(__sparc) 14520ec57554Sraf extern ulong_t caller(void); 14530ec57554Sraf extern ulong_t getfp(void); 14540ec57554Sraf #endif /* __sparc */ 14550ec57554Sraf 14560ec57554Sraf #include "thr_inlines.h" 14577c478bd9Sstevel@tonic-gate 14587c478bd9Sstevel@tonic-gate #endif /* _THR_UBERDATA_H */ 1459