1/*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21
22/*
23 * Copyright (c) 1999, 2010, Oracle and/or its affiliates. All rights reserved.
24 */
25/*
26 * Copyright 2016 Joyent, Inc.
27 */
28
29#ifndef _THR_UBERDATA_H
30#define	_THR_UBERDATA_H
31
32#include <stdlib.h>
33#include <unistd.h>
34#include <sys/types.h>
35#include <fcntl.h>
36#include <string.h>
37#include <signal.h>
38#include <ucontext.h>
39#include <thread.h>
40#include <pthread.h>
41#include <atomic.h>
42#include <link.h>
43#include <sys/resource.h>
44#include <sys/lwp.h>
45#include <errno.h>
46#include <sys/asm_linkage.h>
47#include <sys/regset.h>
48#include <sys/fcntl.h>
49#include <sys/mman.h>
50#include <synch.h>
51#include <door.h>
52#include <limits.h>
53#include <sys/synch32.h>
54#include <schedctl.h>
55#include <sys/priocntl.h>
56#include <thread_db.h>
57#include <setjmp.h>
58#include "libc_int.h"
59#include "tdb_agent.h"
60#include "thr_debug.h"
61
62/*
63 * This is an implementation-specific include file for threading support.
64 * It is not to be seen by the clients of the library.
65 *
66 * This file also describes uberdata in libc.
67 *
68 * The term "uberdata" refers to data that is unique and visible across
69 * all link maps.  The name is meant to imply that such data is truly
70 * global, not just locally global to a particular link map.
71 *
72 * See the Linker and Libraries Guide for a full description of alternate
73 * link maps and how they are set up and used.
74 *
75 * Alternate link maps implement multiple global namespaces within a single
76 * process.  There may be multiple instances of identical dynamic libraries
77 * loaded in a process's address space at the same time, each on a different
78 * link map (as determined by the dynamic linker), each with its own set of
79 * global variables.  Which particular instance of a global variable is seen
80 * by a thread running in the process is determined by the link map on which
81 * the thread happens to be executing at the time.
82 *
83 * However, there are aspects of a process that are unique across all
84 * link maps, in particular the structures used to implement threads
85 * of control (in Sparc terminology, there is only one %g7 regardless
86 * of the link map on which the thread is executing).
87 *
88 * All uberdata is referenced from a base pointer in the thread's ulwp_t
89 * structure (which is also uberdata).  All allocations and deallocations
90 * of uberdata are made via the uberdata-aware lmalloc() and lfree()
91 * interfaces (malloc() and free() are simply locally-global).
92 */
93
94/*
95 * Special libc-private access to errno.
96 * We do this so that references to errno do not invoke the dynamic linker.
97 */
98#undef errno
99#define	errno (*curthread->ul_errnop)
100
101/*
102 * See <sys/synch32.h> for the reasons for these values
103 * and why they are different for sparc and intel.
104 */
105#if defined(__sparc)
106
107/* lock.lock64.pad[x]	   4 5 6 7 */
108#define	LOCKMASK	0xff000000
109#define	WAITERMASK	0x000000ff
110#define	SPINNERMASK	0x00ff0000
111#define	SPINNERSHIFT	16
112#define	WAITER		0x00000001
113#define	LOCKSET		0xff
114#define	LOCKCLEAR	0
115
116#define	PIDSHIFT	32
117#define	LOCKMASK64	0xffffffffff000000ULL
118#define	LOCKBYTE64	0x00000000ff000000ULL
119#define	WAITERMASK64	0x00000000000000ffULL
120#define	SPINNERMASK64	0x0000000000ff0000ULL
121
122#elif defined(__x86)
123
124/* lock.lock64.pad[x]	   7 6 5 4 */
125#define	LOCKMASK	0xff000000
126#define	WAITERMASK	0x00ff0000
127#define	SPINNERMASK	0x0000ff00
128#define	SPINNERSHIFT	8
129#define	WAITER		0x00010000
130#define	LOCKSET		0x01
131#define	LOCKCLEAR	0
132
133#define	PIDSHIFT	0
134#define	LOCKMASK64	0xff000000ffffffffULL
135#define	LOCKBYTE64	0x0100000000000000ULL
136#define	WAITERMASK64	0x00ff000000000000ULL
137#define	SPINNERMASK64	0x0000ff0000000000ULL
138
139#else
140#error "neither __sparc nor __x86 is defined"
141#endif
142
143/*
144 * Fetch the owner of a USYNC_THREAD mutex.
145 * Don't use this with process-shared mutexes;
146 * the owing thread may be in a different process.
147 */
148#define	MUTEX_OWNER(mp)	((ulwp_t *)(uintptr_t)(mp)->mutex_owner)
149
150/*
151 * Test if a thread owns a process-private (USYNC_THREAD) mutex.
152 * This is inappropriate for a process-shared (USYNC_PROCESS) mutex.
153 * The 'mp' argument must not have side-effects since it is evaluated twice.
154 */
155#define	MUTEX_OWNED(mp, thrp)	\
156	((mp)->mutex_lockw != 0 && MUTEX_OWNER(mp) == thrp)
157
158
159/*
160 * uberflags.uf_tdb_register_sync is an interface with libc_db to enable the
161 * collection of lock statistics by a debugger or other collecting tool.
162 *
163 * uberflags.uf_thread_error_detection is set by an environment variable:
164 *	_THREAD_ERROR_DETECTION
165 *		0 == no detection of locking primitive errors.
166 *		1 == detect errors and issue a warning message.
167 *		2 == detect errors, issue a warning message, and dump core.
168 *
169 * We bundle these together in uberflags.uf_trs_ted to make a test of either
170 * being non-zero a single memory reference (for speed of mutex_lock(), etc).
171 *
172 * uberflags.uf_mt is set non-zero when the first thread (in addition
173 * to the main thread) is created.
174 *
175 * We bundle all these flags together in uberflags.uf_all to make a test
176 * of any being non-zero a single memory reference (again, for speed).
177 */
178typedef union {
179	int	uf_all;			/* combined all flags */
180	struct {
181		short	h_pad;
182		short	h_trs_ted;	/* combined reg sync & error detect */
183	} uf_h;
184	struct {
185		char	x_mt;
186		char	x_pad;
187		char	x_tdb_register_sync;
188		char	x_thread_error_detection;
189	} uf_x;
190} uberflags_t;
191
192#define	uf_mt				uf_x.x_mt
193#define	uf_tdb_register_sync		uf_x.x_tdb_register_sync
194#define	uf_thread_error_detection	uf_x.x_thread_error_detection
195#define	uf_trs_ted			uf_h.h_trs_ted	/* both of the above */
196
197/*
198 * NOTE WELL:
199 * To enable further optimization, the "ul_schedctl_called" member
200 * of the ulwp_t structure (below) serves double-duty:
201 *	1. If NULL, it means that the thread must call __schedctl()
202 *	   to set up its schedctl mappings before acquiring a mutex.
203 *	   This is required by the implementation of adaptive mutex locking.
204 *	2. If non-NULL, it points to uberdata.uberflags, so that tests of
205 *	   uberflags can be made without additional memory references.
206 * This allows the common case of _mutex_lock() and _mutex_unlock() for
207 * USYNC_THREAD mutexes with no error detection and no lock statistics
208 * to be optimized for speed.
209 */
210
211/* double the default stack size for 64-bit processes */
212#ifdef _LP64
213#define	MINSTACK	(8 * 1024)
214#define	DEFAULTSTACK	(2 * 1024 * 1024)
215#else
216#define	MINSTACK	(4 * 1024)
217#define	DEFAULTSTACK	(1024 * 1024)
218#endif
219
220#define	MUTEX_TRY	0
221#define	MUTEX_LOCK	1
222#define	MUTEX_NOCEIL	0x40
223
224#if defined(__x86)
225
226typedef struct {	/* structure returned by fnstenv */
227	int	fctrl;		/* control word */
228	int	fstat;		/* status word (flags, etc) */
229	int	ftag;		/* tag of which regs busy */
230	int	misc[4];	/* other stuff, 28 bytes total */
231} fpuenv_t;
232
233#ifdef _SYSCALL32
234typedef fpuenv_t fpuenv32_t;
235#endif	/* _SYSCALL32 */
236
237#elif defined(__sparc)
238
239typedef struct {	/* fp state structure */
240	greg_t	fsr;
241	greg_t	fpu_en;
242} fpuenv_t;
243
244#ifdef _SYSCALL32
245typedef struct {
246	greg32_t	fsr;
247	greg32_t	fpu_en;
248} fpuenv32_t;
249#endif	/* _SYSCALL32 */
250
251#endif	/* __x86 */
252
253#if defined(__x86)
254extern	void	ht_pause(void);		/* "pause" instruction */
255#define	SMT_PAUSE()	ht_pause()
256#elif defined(SMT_PAUSE_FUNCTION)
257extern	void	SMT_PAUSE_FUNCTION(void);
258#define	SMT_PAUSE()	SMT_PAUSE_FUNCTION()
259#else
260#define	SMT_PAUSE()	smt_pause()
261#endif	/* __x86 */
262
263/*
264 * Cleanup handler related data.
265 * This structure is exported as _cleanup_t in pthread.h.
266 * pthread.h exports only the size of this structure, so check
267 * _cleanup_t in pthread.h before making any change here.
268 */
269typedef struct __cleanup {
270	struct __cleanup *next;		/* pointer to next handler */
271	caddr_t	fp;			/* current frame pointer */
272	void	(*func)(void *);	/* cleanup handler address */
273	void	*arg;			/* handler's argument */
274} __cleanup_t;
275
276/*
277 * Thread-Specific Data (TSD)
278 * TSD_NFAST includes the invalid key zero, so there
279 * are really only (TSD_NFAST - 1) fast key slots.
280 */
281typedef	void (*PFrV)(void *);
282#define	TSD_UNALLOCATED	((PFrV)1)
283#define	TSD_NFAST	9
284
285/*
286 * The tsd union is designed to burn a little memory (9 words) to make
287 * lookups blindingly fast.  Note that tsd_nalloc could be placed at the
288 * end of the pad region to increase the likelihood that it falls on the
289 * same cache line as the data.
290 */
291typedef union tsd {
292	uint_t tsd_nalloc;		/* Amount of allocated storage */
293	void *tsd_pad[TSD_NFAST];
294	void *tsd_data[1];
295} tsd_t;
296
297typedef struct {
298	mutex_t tsdm_lock;		/* Lock protecting the data */
299	uint_t tsdm_nkeys;		/* Number of allocated keys */
300	uint_t tsdm_nused;		/* Number of used keys */
301	PFrV *tsdm_destro;		/* Per-key destructors */
302	char tsdm_pad[64 -		/* pad to 64 bytes */
303		(sizeof (mutex_t) + 2 * sizeof (uint_t) + sizeof (PFrV *))];
304} tsd_metadata_t;
305
306#ifdef _SYSCALL32
307typedef union tsd32 {
308	uint_t tsd_nalloc;		/* Amount of allocated storage */
309	caddr32_t tsd_pad[TSD_NFAST];
310	caddr32_t tsd_data[1];
311} tsd32_t;
312
313typedef struct {
314	mutex_t tsdm_lock;		/* Lock protecting the data */
315	uint_t tsdm_nkeys;		/* Number of allocated keys */
316	uint_t tsdm_nused;		/* Number of used keys */
317	caddr32_t tsdm_destro;		/* Per-key destructors */
318	char tsdm_pad[64 -		/* pad to 64 bytes */
319		(sizeof (mutex_t) + 2 * sizeof (uint_t) + sizeof (caddr32_t))];
320} tsd_metadata32_t;
321#endif	/* _SYSCALL32 */
322
323
324/*
325 * Thread-Local Storage (TLS)
326 */
327typedef struct {
328	void		*tls_data;
329	size_t		tls_size;
330} tls_t;
331
332typedef struct {
333	mutex_t	tls_lock;		/* Lock protecting the data */
334	tls_t	tls_modinfo;		/* Root of all TLS_modinfo data */
335	tls_t	static_tls;		/* Template for static TLS */
336	char	tls_pad[64 -		/* pad to 64 bytes */
337		(sizeof (mutex_t) + 2 * sizeof (tls_t))];
338} tls_metadata_t;
339
340#ifdef _SYSCALL32
341typedef struct {
342	caddr32_t	tls_data;
343	size32_t	tls_size;
344} tls32_t;
345
346typedef struct {
347	mutex_t	tls_lock;		/* Lock protecting the data */
348	tls32_t	tls_modinfo;		/* Root of all TLS_modinfo data */
349	tls32_t	static_tls;		/* Template for static TLS */
350	char	tls_pad[64 -		/* pad to 64 bytes */
351		(sizeof (mutex_t) + 2 * sizeof (tls32_t))];
352} tls_metadata32_t;
353#endif	/* _SYSCALL32 */
354
355
356/*
357 * Sleep queue root for USYNC_THREAD condvars and mutexes.
358 * There is a default queue root for each queue head (see below).
359 * Also, each ulwp_t contains a queue root that can be used
360 * when the thread is enqueued on the queue, if necessary
361 * (when more than one wchan hashes to the same queue head).
362 */
363typedef struct queue_root {
364	struct queue_root	*qr_next;
365	struct queue_root	*qr_prev;
366	struct ulwp		*qr_head;
367	struct ulwp		*qr_tail;
368	void			*qr_wchan;
369	uint32_t		qr_rtcount;
370	uint32_t		qr_qlen;
371	uint32_t		qr_qmax;
372} queue_root_t;
373
374#ifdef _SYSCALL32
375typedef struct queue_root32 {
376	caddr32_t		qr_next;
377	caddr32_t		qr_prev;
378	caddr32_t		qr_head;
379	caddr32_t		qr_tail;
380	caddr32_t		qr_wchan;
381	uint32_t		qr_rtcount;
382	uint32_t		qr_qlen;
383	uint32_t		qr_qmax;
384} queue_root32_t;
385#endif
386
387/*
388 * Sleep queue heads for USYNC_THREAD condvars and mutexes.
389 * The size and alignment is 128 bytes to reduce cache conflicts.
390 * Each queue head points to a list of queue roots, defined above.
391 * Each queue head contains a default queue root for use when only one
392 * is needed.  It is always at the tail of the queue root hash chain.
393 */
394typedef union {
395	uint64_t		qh_64[16];
396	struct {
397		mutex_t		q_lock;
398		uint8_t		q_qcnt;
399		uint8_t		q_type;		/* MX or CV */
400		uint8_t		q_pad1[2];
401		uint32_t	q_lockcount;
402		uint32_t	q_qlen;
403		uint32_t	q_qmax;
404		void		*q_wchan;	/* valid only while locked */
405		struct queue_root *q_root;	/* valid only while locked */
406		struct queue_root *q_hlist;
407#if !defined(_LP64)
408		caddr_t		q_pad2[3];
409#endif
410		queue_root_t	q_def_root;
411		uint32_t	q_hlen;
412		uint32_t	q_hmax;
413	} qh_qh;
414} queue_head_t;
415
416#define	qh_lock		qh_qh.q_lock
417#define	qh_qcnt		qh_qh.q_qcnt
418#define	qh_type		qh_qh.q_type
419#if defined(THREAD_DEBUG)
420#define	qh_lockcount	qh_qh.q_lockcount
421#define	qh_qlen		qh_qh.q_qlen
422#define	qh_qmax		qh_qh.q_qmax
423#endif
424#define	qh_wchan	qh_qh.q_wchan
425#define	qh_root		qh_qh.q_root
426#define	qh_hlist	qh_qh.q_hlist
427#define	qh_def_root	qh_qh.q_def_root
428#define	qh_hlen		qh_qh.q_hlen
429#define	qh_hmax		qh_qh.q_hmax
430
431/* queue types passed to queue_lock() */
432#define	MX	0
433#define	CV	1
434#define	QHASHSHIFT	9			/* number of hashing bits */
435#define	QHASHSIZE	(1 << QHASHSHIFT)	/* power of 2 (1<<9 == 512) */
436#define	QUEUE_HASH(wchan, type)	((uint_t)			\
437	((((uintptr_t)(wchan) >> 3)				\
438	^ ((uintptr_t)(wchan) >> (QHASHSHIFT + 3)))		\
439	& (QHASHSIZE - 1)) + (((type) == MX)? 0 : QHASHSIZE))
440
441extern	queue_head_t	*queue_lock(void *, int);
442extern	void		queue_unlock(queue_head_t *);
443extern	void		enqueue(queue_head_t *, struct ulwp *, int);
444extern	struct ulwp	*dequeue(queue_head_t *, int *);
445extern	struct ulwp	**queue_slot(queue_head_t *, struct ulwp **, int *);
446extern	struct ulwp	*queue_waiter(queue_head_t *);
447extern	int		dequeue_self(queue_head_t *);
448extern	void		queue_unlink(queue_head_t *,
449				struct ulwp **, struct ulwp *);
450extern	void		unsleep_self(void);
451extern	void		spin_lock_set(mutex_t *);
452extern	void		spin_lock_clear(mutex_t *);
453
454/*
455 * Scheduling class information structure.
456 */
457typedef struct {
458	short		pcc_state;
459	short		pcc_policy;
460	pri_t		pcc_primin;
461	pri_t		pcc_primax;
462	pcinfo_t	pcc_info;
463} pcclass_t;
464
465/*
466 * Memory block for chain of owned ceiling mutexes.
467 */
468typedef struct mxchain {
469	struct mxchain	*mxchain_next;
470	mutex_t		*mxchain_mx;
471} mxchain_t;
472
473/*
474 * Pointer to an rwlock that is held for reading.
475 * Used in rw_rdlock() to allow a thread that already holds a read
476 * lock to acquire another read lock on the same rwlock even if
477 * there are writers waiting.  This to avoid deadlock when acquiring
478 * a read lock more than once in the presence of pending writers.
479 * POSIX mandates this behavior.
480 */
481typedef struct {
482	void	*rd_rwlock;	/* the rwlock held for reading */
483	size_t	rd_count;	/* count of read locks applied */
484} readlock_t;
485
486#ifdef _SYSCALL32
487typedef struct {
488	caddr32_t	rd_rwlock;
489	size32_t	rd_count;
490} readlock32_t;
491#endif	/* _SYSCALL32 */
492
493/*
494 * As part of per-thread caching libumem (ptcumem), we add a small amount to the
495 * thread's uberdata to facilitate it. The tm_roots are the roots of linked
496 * lists which is used by libumem to chain together allocations. tm_size is used
497 * to track the total amount of data stored across those linked lists. For more
498 * information, see libumem's big theory statement.
499 */
500#define	NTMEMBASE	16
501
502typedef struct {
503	size_t		tm_size;
504	void		*tm_roots[NTMEMBASE];
505} tumem_t;
506
507#ifdef _SYSCALL32
508typedef struct {
509	uint32_t	tm_size;
510	caddr32_t	tm_roots[NTMEMBASE];
511} tumem32_t;
512#endif
513
514typedef void (*tmem_func_t)(void *, int);
515
516/*
517 * Maximum number of read locks allowed for one thread on one rwlock.
518 * This could be as large as INT_MAX, but the SUSV3 test suite would
519 * take an inordinately long time to complete.  This is big enough.
520 */
521#define	READ_LOCK_MAX	100000
522
523#define	ul_tlsent	ul_tls.tls_data	/* array of pointers to dynamic TLS */
524#define	ul_ntlsent	ul_tls.tls_size	/* number of entries in ul_tlsent */
525
526/*
527 * Round up an integral value to a multiple of 64
528 */
529#define	roundup64(x)	(-(-(x) & -64))
530
531/*
532 * NOTE:  Whatever changes are made to ulwp_t must be
533 * reflected in $SRC/cmd/mdb/common/modules/libc/libc.c
534 *
535 * NOTE: ul_self *must* be the first member of ulwp_t on x86
536 * Low-level x86 code relies on this.
537 */
538typedef struct ulwp {
539	/*
540	 * These members always need to come first on sparc.
541	 * For dtrace, a ulwp_t must be aligned on a 64-byte boundary.
542	 */
543#if defined(__sparc)
544	uint32_t	ul_dinstr;	/* scratch space for dtrace */
545	uint32_t	ul_padsparc0[15];
546	uint32_t	ul_dsave;	/* dtrace: save %g1, %g0, %sp */
547	uint32_t	ul_drestore;	/* dtrace: restore %g0, %g0, %g0 */
548	uint32_t	ul_dftret;	/* dtrace: return probe fasttrap */
549	uint32_t	ul_dreturn;	/* dtrace: return %o0 */
550#endif
551	struct ulwp	*ul_self;	/* pointer to self */
552#if defined(__i386)
553	uint8_t		ul_dinstr[40];	/* scratch space for dtrace */
554#elif defined(__amd64)
555	uint8_t		ul_dinstr[56];	/* scratch space for dtrace */
556#endif
557	struct uberdata *ul_uberdata;	/* uber (super-global) data */
558	tls_t		ul_tls;		/* dynamic thread-local storage base */
559	struct ulwp	*ul_forw;	/* forw, back all_lwps list, */
560	struct ulwp	*ul_back;	/* protected by link_lock */
561	struct ulwp	*ul_next;	/* list to keep track of stacks */
562	struct ulwp	*ul_hash;	/* hash chain linked list */
563	void		*ul_rval;	/* return value from thr_exit() */
564	caddr_t		ul_stk;		/* mapping base of the stack */
565	size_t		ul_mapsiz;	/* mapping size of the stack */
566	size_t		ul_guardsize;	/* normally _lpagesize */
567	uintptr_t	ul_stktop;	/* broken thr_stksegment() interface */
568	size_t		ul_stksiz;	/* broken thr_stksegment() interface */
569	stack_t		ul_ustack;	/* current stack boundaries */
570	int		ul_ix;		/* hash index */
571	lwpid_t		ul_lwpid;	/* thread id, aka the lwp id */
572	pri_t		ul_pri;		/* scheduling priority */
573	pri_t		ul_epri;	/* real-time ceiling priority */
574	char		ul_policy;	/* scheduling policy */
575	char		ul_cid;		/* scheduling class id */
576	union {
577		struct {
578			char	cursig;	/* deferred signal number */
579			char	pleasestop; /* lwp requested to stop itself */
580		} s;
581		short	curplease;	/* for testing both at once */
582	} ul_cp;
583	char		ul_stop;	/* reason for stopping */
584	char		ul_signalled;	/* this lwp was cond_signal()d */
585	char		ul_dead;	/* this lwp has called thr_exit */
586	char		ul_unwind;	/* posix: unwind C++ stack */
587	char		ul_detached;	/* THR_DETACHED at thread_create() */
588					/* or pthread_detach() was called */
589	char		ul_writer;	/* sleeping in rw_wrlock() */
590	char		ul_stopping;	/* set by curthread: stopping self */
591	char		ul_cancel_prologue;	/* for _cancel_prologue() */
592	short		ul_preempt;	/* no_preempt()/preempt() */
593	short		ul_savpreempt;	/* pre-existing preempt value */
594	char		ul_sigsuspend;	/* thread is in sigsuspend/pollsys */
595	char		ul_main;	/* thread is the main thread */
596	char		ul_fork;	/* thread is performing a fork */
597	char		ul_primarymap;	/* primary link-map is initialized */
598	/* per-thread copies of the corresponding global variables */
599	uint8_t		ul_max_spinners;	/* thread_max_spinners */
600	char		ul_door_noreserve;	/* thread_door_noreserve */
601	char		ul_queue_fifo;		/* thread_queue_fifo */
602	char		ul_cond_wait_defer;	/* thread_cond_wait_defer */
603	char		ul_error_detection;	/* thread_error_detection */
604	char		ul_async_safe;		/* thread_async_safe */
605	char		ul_rt;			/* found on an RT queue */
606	char		ul_rtqueued;		/* was RT when queued */
607	char		ul_misaligned;		/* thread_locks_misaligned */
608	char		ul_pad[3];
609	int		ul_adaptive_spin;	/* thread_adaptive_spin */
610	int		ul_queue_spin;		/* thread_queue_spin */
611	volatile int	ul_critical;	/* non-zero == in a critical region */
612	int		ul_sigdefer;	/* non-zero == defer signals */
613	int		ul_vfork;	/* thread is the child of vfork() */
614	int		ul_cancelable;	/* _cancelon()/_canceloff() */
615	char		ul_cancel_pending;  /* pthread_cancel() was called */
616	char		ul_cancel_disabled; /* PTHREAD_CANCEL_DISABLE */
617	char		ul_cancel_async;    /* PTHREAD_CANCEL_ASYNCHRONOUS */
618	char		ul_save_async;	/* saved copy of ul_cancel_async */
619	char		ul_mutator;	/* lwp is a mutator (java interface) */
620	char		ul_created;	/* created suspended */
621	char		ul_replace;	/* replacement; must be free()d */
622	uchar_t		ul_nocancel;	/* cancellation can't happen */
623	int		ul_errno;	/* per-thread errno */
624	int		*ul_errnop;	/* pointer to errno or self->ul_errno */
625	__cleanup_t	*ul_clnup_hdr;	/* head of cleanup handlers list */
626	uberflags_t	*ul_schedctl_called;	/* ul_schedctl is set up */
627	volatile sc_shared_t *ul_schedctl;	/* schedctl data */
628	int		ul_bindflags;	/* bind_guard() interface to ld.so.1 */
629	uint_t		ul_libc_locks;	/* count of cancel_safe_mutex_lock()s */
630	tsd_t		*ul_stsd;	/* slow TLS for keys >= TSD_NFAST */
631	void		*ul_ftsd[TSD_NFAST]; /* fast TLS for keys < TSD_NFAST */
632	td_evbuf_t	ul_td_evbuf;	/* event buffer */
633	char		ul_td_events_enable;	/* event mechanism enabled */
634	char		ul_sync_obj_reg;	/* tdb_sync_obj_register() */
635	char		ul_qtype;	/* MX or CV */
636	char		ul_cv_wake;	/* != 0: just wake up, don't requeue */
637	int		ul_rtld;	/* thread is running inside ld.so.1 */
638	int		ul_usropts;	/* flags given to thr_create() */
639	void		*(*ul_startpc)(void *); /* start func (thr_create()) */
640	void		*ul_startarg;	/* argument for start function */
641	void		*ul_wchan;	/* synch object when sleeping */
642	struct ulwp	*ul_link;	/* sleep queue link */
643	queue_head_t	*ul_sleepq;	/* sleep queue thread is waiting on */
644	mutex_t		*ul_cvmutex;	/* mutex dropped when waiting on a cv */
645	mxchain_t	*ul_mxchain;	/* chain of owned ceiling mutexes */
646	int		ul_save_state;	/* bind_guard() interface to ld.so.1 */
647	uint_t		ul_rdlockcnt;	/* # entries in ul_readlock array */
648				/* 0 means there is but a single entry */
649	union {				/* single entry or pointer to array */
650		readlock_t	single;
651		readlock_t	*array;
652	} ul_readlock;
653	uint_t		ul_heldlockcnt;	/* # entries in ul_heldlocks array */
654				/* 0 means there is but a single entry */
655	union {				/* single entry or pointer to array */
656		mutex_t		*single;
657		mutex_t		**array;
658	} ul_heldlocks;
659	/* PROBE_SUPPORT begin */
660	void		*ul_tpdp;
661	/* PROBE_SUPPORT end */
662	ucontext_t	*ul_siglink;	/* pointer to previous context */
663	uint_t		ul_spin_lock_spin;	/* spin lock statistics */
664	uint_t		ul_spin_lock_spin2;
665	uint_t		ul_spin_lock_sleep;
666	uint_t		ul_spin_lock_wakeup;
667	queue_root_t	ul_queue_root;	/* root of a sleep queue */
668	id_t		ul_rtclassid;	/* real-time class id */
669	uint_t		ul_pilocks;	/* count of PI locks held */
670		/* the following members *must* be last in the structure */
671		/* they are discarded when ulwp is replaced on thr_exit() */
672	sigset_t	ul_sigmask;	/* thread's current signal mask */
673	sigset_t	ul_tmpmask;	/* signal mask for sigsuspend/pollsys */
674	siginfo_t	ul_siginfo;	/* deferred siginfo */
675	mutex_t		ul_spinlock;	/* used when suspending/continuing */
676	fpuenv_t	ul_fpuenv;	/* floating point state */
677	uintptr_t	ul_sp;		/* stack pointer when blocked */
678	void		*ul_ex_unwind;	/* address of _ex_unwind() or -1 */
679#if defined(sparc)
680	void		*ul_unwind_ret;	/* used only by _ex_clnup_handler() */
681#endif
682	tumem_t		ul_tmem;	/* used only by umem */
683	uint_t		ul_ptinherit;	/* pthreads sched inherit value */
684} ulwp_t;
685
686#define	ul_cursig	ul_cp.s.cursig		/* deferred signal number */
687#define	ul_pleasestop	ul_cp.s.pleasestop	/* lwp requested to stop */
688#define	ul_curplease	ul_cp.curplease		/* for testing both at once */
689
690/*
691 * This is the size of a replacement ulwp, retained only for the benefit
692 * of thr_join().  The trailing members are unneeded for this purpose.
693 */
694#define	REPLACEMENT_SIZE	((size_t)&((ulwp_t *)NULL)->ul_sigmask)
695
696/*
697 * Definitions for static initialization of signal sets,
698 * plus some sneaky optimizations in various places.
699 */
700
701#define	SIGMASK(sig)	((uint32_t)1 << (((sig) - 1) & (32 - 1)))
702
703#if (MAXSIG > (2 * 32) && MAXSIG <= (3 * 32))
704#define	FILLSET0	0xffffffffu
705#define	FILLSET1	0xffffffffu
706#define	FILLSET2	((1u << (MAXSIG - 64)) - 1)
707#define	FILLSET3	0
708#else
709#error "fix me: MAXSIG out of bounds"
710#endif
711
712#define	CANTMASK0	(SIGMASK(SIGKILL) | SIGMASK(SIGSTOP))
713#define	CANTMASK1	0
714#define	CANTMASK2	0
715#define	CANTMASK3	0
716
717#define	MASKSET0	(FILLSET0 & ~CANTMASK0)
718#define	MASKSET1	(FILLSET1 & ~CANTMASK1)
719#define	MASKSET2	(FILLSET2 & ~CANTMASK2)
720#define	MASKSET3	(FILLSET3 & ~CANTMASK3)
721
722extern	const sigset_t maskset;		/* set of all maskable signals */
723
724extern	int	thread_adaptive_spin;
725extern	uint_t	thread_max_spinners;
726extern	int	thread_queue_spin;
727extern	int	thread_queue_fifo;
728extern	int	thread_queue_dump;
729extern	int	thread_cond_wait_defer;
730extern	int	thread_async_safe;
731extern	int	thread_queue_verify;
732
733/*
734 * pthread_atfork() related data, used to store atfork handlers.
735 */
736typedef struct atfork {
737	struct atfork *forw;		/* forward pointer */
738	struct atfork *back;		/* backward pointer */
739	void (*prepare)(void);		/* pre-fork handler */
740	void (*parent)(void);		/* post-fork parent handler */
741	void (*child)(void);		/* post-fork child handler */
742} atfork_t;
743
744/*
745 * Element in the table and in the list of registered process
746 * robust locks.  We keep track of these to make sure that we
747 * only call ___lwp_mutex_register() once for each such lock
748 * after it is first mapped in (or newly mapped in).
749 */
750typedef struct robust {
751	struct robust	*robust_next;	/* hash table list */
752	struct robust	*robust_list;	/* global list */
753	mutex_t		*robust_lock;
754} robust_t;
755
756/*
757 * Invalid address, used to mark an unused element in the hash table.
758 */
759#define	INVALID_ADDR	((void *)(uintptr_t)(-1L))
760
761/*
762 * Parameters of the lock registration hash table.
763 */
764#define	LOCKSHIFT	15			/* number of hashing bits */
765#define	LOCKHASHSZ	(1 << LOCKSHIFT)	/* power of 2 (1<<15 == 32K) */
766#define	LOCK_HASH(addr)	(uint_t)			\
767	((((uintptr_t)(addr) >> 3)			\
768	^ ((uintptr_t)(addr) >> (LOCKSHIFT + 3)))	\
769	& (LOCKHASHSZ - 1))
770
771/*
772 * Make our hot locks reside on private cache lines (64 bytes).
773 */
774typedef struct {
775	mutex_t	pad_lock;
776	char	pad_pad[64 - sizeof (mutex_t)];
777} pad_lock_t;
778
779/*
780 * Make our semi-hot locks reside on semi-private cache lines (32 bytes).
781 */
782typedef struct {
783	mutex_t	pad_lock;
784	char	pad_pad[32 - sizeof (mutex_t)];
785} pad32_lock_t;
786
787/*
788 * The threads hash table is used for fast lookup and locking of an active
789 * thread structure (ulwp_t) given a thread-id.  It is an N-element array of
790 * thr_hash_table_t structures, where N == 1 before the main thread creates
791 * the first additional thread and N == 1024 afterwards.  Each element of the
792 * table is 64 bytes in size and alignment to reduce cache conflicts.
793 */
794typedef struct {
795	mutex_t	hash_lock;	/* lock per bucket */
796	cond_t	hash_cond;	/* convar per bucket */
797	ulwp_t	*hash_bucket;	/* hash bucket points to the list of ulwps */
798	char	hash_pad[64 -	/* pad out to 64 bytes */
799		(sizeof (mutex_t) + sizeof (cond_t) + sizeof (ulwp_t *))];
800} thr_hash_table_t;
801
802#ifdef _SYSCALL32
803typedef struct {
804	mutex_t	hash_lock;
805	cond_t	hash_cond;
806	caddr32_t hash_bucket;
807	char	hash_pad[64 -
808		(sizeof (mutex_t) + sizeof (cond_t) + sizeof (caddr32_t))];
809} thr_hash_table32_t;
810#endif	/* _SYSCALL32 */
811
812
813/*
814 * siguaction members have 128-byte size and 64-byte alignment.
815 * We know that sizeof (struct sigaction) is 32 bytes for both
816 * _ILP32 and _LP64 and that sizeof (rwlock_t) is 64 bytes.
817 */
818typedef struct {
819	rwlock_t	sig_lock;
820	struct sigaction sig_uaction;
821	char	sig_pad[128 - sizeof (rwlock_t) - sizeof (struct sigaction)];
822} siguaction_t;
823
824#ifdef _SYSCALL32
825typedef struct {
826	rwlock_t	sig_lock;
827	struct sigaction32 sig_uaction;
828	char	sig_pad[128 - sizeof (rwlock_t) - sizeof (struct sigaction32)];
829} siguaction32_t;
830#endif	/* _SYSCALL32 */
831
832
833/*
834 * Bucket structures, used by lmalloc()/lfree().
835 * See port/threads/alloc.c for details.
836 * A bucket's size and alignment is 64 bytes.
837 */
838typedef struct {
839	mutex_t	bucket_lock;	/* protects the free list allocations */
840	void	*free_list;	/* LIFO list of blocks to allocate/free */
841	size_t	chunks;		/* number of 64K blocks mmap()ed last time */
842	char	pad64[64 -	/* pad out to 64 bytes */
843		(sizeof (mutex_t) + sizeof (void *) + sizeof (size_t))];
844} bucket_t;
845
846#ifdef _SYSCALL32
847typedef struct {
848	mutex_t		bucket_lock;
849	caddr32_t	free_list;
850	size32_t	chunks;
851	char	pad64[64 -	/* pad out to 64 bytes */
852		(sizeof (mutex_t) + sizeof (caddr32_t) + sizeof (size32_t))];
853} bucket32_t;
854#endif	/* _SYSCALL32 */
855
856#define	NBUCKETS	10	/* sizes ranging from 64 to 32768 */
857
858
859/*
860 * atexit() data structures.
861 * See port/gen/atexit.c for details.
862 */
863typedef void (*_exithdlr_func_t) (void*);
864
865typedef struct _exthdlr {
866	struct _exthdlr 	*next;	/* next in handler list */
867	_exithdlr_func_t	hdlr;	/* handler itself */
868	void			*arg;	/* argument to handler */
869	void			*dso;	/* DSO associated with handler */
870} _exthdlr_t;
871
872typedef struct {
873	mutex_t		exitfns_lock;
874	_exthdlr_t	*head;
875	/*
876	 * exit_frame_monitor is part of a private contract between libc and
877	 * the Sun C++ runtime.
878	 *
879	 * It should be NULL until exit() is called, and thereafter hold the
880	 * frame pointer of the function implementing our exit processing.
881	 */
882	void		*exit_frame_monitor;
883	char		exit_pad[64 -	/* pad out to 64 bytes */
884		(sizeof (mutex_t) + sizeof (_exthdlr_t *) + sizeof (void *))];
885} atexit_root_t;
886
887#ifdef _SYSCALL32
888typedef struct {
889	mutex_t		exitfns_lock;
890	caddr32_t	head;
891	caddr32_t	exit_frame_monitor;
892	char		exit_pad[64 -	/* pad out to 64 bytes */
893		(sizeof (mutex_t) + sizeof (caddr32_t) + sizeof (caddr32_t))];
894} atexit_root32_t;
895#endif	/* _SYSCALL32 */
896
897/*
898 * at_quick_exit() and quick_exit() data structures. The ISO/IEC C11 odd
899 * siblings of atexit()
900 */
901typedef void (*_quick_exithdlr_func_t)(void);
902
903typedef struct _qexthdlr {
904	struct _qexthdlr 	*next;	/* next in handler list */
905	_quick_exithdlr_func_t	hdlr;	/* handler itself */
906} _qexthdlr_t;
907
908/*
909 * We add a pad on 32-bit systems to allow us to always have the structure size
910 * be 32-bytes which helps us deal with the compiler's alignment when building
911 * in ILP32 / LP64 systems.
912 */
913typedef struct {
914	mutex_t		exitfns_lock;
915	_qexthdlr_t	*head;
916#if !defined(_LP64)
917	uint32_t	pad;
918#endif
919} quickexit_root_t;
920
921#ifdef _SYSCALL32
922typedef struct {
923	mutex_t		exitfns_lock;
924	caddr32_t	head;
925	uint32_t	pad;
926} quickexit_root32_t;
927#endif /* _SYSCALL32 */
928
929/*
930 * This is data that is global to all link maps (uberdata, aka super-global).
931 * Note: When changing this, please be sure to keep the 32-bit variant of
932 * this in sync.  (see uberdata32_t below)
933 */
934typedef struct uberdata {
935	pad_lock_t	_link_lock;
936	pad_lock_t	_ld_lock;
937	pad_lock_t	_fork_lock;
938	pad_lock_t	_atfork_lock;
939	pad32_lock_t	_callout_lock;
940	pad32_lock_t	_tdb_hash_lock;
941	tdb_sync_stats_t tdb_hash_lock_stats;
942	siguaction_t	siguaction[NSIG];
943	bucket_t	bucket[NBUCKETS];
944	atexit_root_t	atexit_root;
945	quickexit_root_t quickexit_root;
946	tsd_metadata_t	tsd_metadata;
947	tls_metadata_t	tls_metadata;
948	/*
949	 * Every object before this point has size and alignment of 64 bytes.
950	 * Don't add any other type of data before this point.
951	 */
952	char	primary_map;	/* set when primary link map is initialized */
953	char	bucket_init;	/* set when bucket[NBUCKETS] is initialized */
954	char	pad[2];
955	uberflags_t	uberflags;
956	queue_head_t	*queue_head;
957	thr_hash_table_t *thr_hash_table;
958	uint_t		hash_size;	/* # of entries in thr_hash_table[] */
959	uint_t		hash_mask;	/* hash_size - 1 */
960	ulwp_t	*ulwp_one;	/* main thread */
961	ulwp_t	*all_lwps;	/* circular ul_forw/ul_back list of live lwps */
962	ulwp_t	*all_zombies;	/* circular ul_forw/ul_back list of zombies */
963	int	nthreads;	/* total number of live threads/lwps */
964	int	nzombies;	/* total number of zombie threads */
965	int	ndaemons;	/* total number of THR_DAEMON threads/lwps */
966	pid_t	pid;		/* the current process's pid */
967	void	(*sigacthandler)(int, siginfo_t *, void *);
968	ulwp_t	*lwp_stacks;
969	ulwp_t	*lwp_laststack;
970	int	nfreestack;
971	int	thread_stack_cache;
972	ulwp_t	*ulwp_freelist;
973	ulwp_t	*ulwp_lastfree;
974	ulwp_t	*ulwp_replace_free;
975	ulwp_t	*ulwp_replace_last;
976	atfork_t	*atforklist;	/* circular Q for fork handlers */
977	robust_t	**robustlocks;	/* table of registered robust locks */
978	robust_t	*robustlist;	/* list of registered robust locks */
979	char	*progname;	/* the basename of the program, from argv[0] */
980	void	*ub_comm_page;	/* arch-specific comm page of kernel data */
981	struct uberdata **tdb_bootstrap;
982	tdb_t	tdb;		/* thread debug interfaces (for libc_db) */
983} uberdata_t;
984
985#define	link_lock	_link_lock.pad_lock
986#define	ld_lock		_ld_lock.pad_lock
987#define	fork_lock	_fork_lock.pad_lock
988#define	atfork_lock	_atfork_lock.pad_lock
989#define	callout_lock	_callout_lock.pad_lock
990#define	tdb_hash_lock	_tdb_hash_lock.pad_lock
991
992#pragma align 64(__uberdata)
993extern	uberdata_t	__uberdata;
994extern	uberdata_t	**__tdb_bootstrap;	/* known to libc_db and mdb */
995extern	int		primary_link_map;
996
997#define	ulwp_mutex(ulwp, udp)	\
998	(&(udp)->thr_hash_table[(ulwp)->ul_ix].hash_lock)
999#define	ulwp_condvar(ulwp, udp)	\
1000	(&(udp)->thr_hash_table[(ulwp)->ul_ix].hash_cond)
1001
1002/*
1003 * Grab and release the hash table lock for the specified lwp.
1004 */
1005#define	ulwp_lock(ulwp, udp)	lmutex_lock(ulwp_mutex(ulwp, udp))
1006#define	ulwp_unlock(ulwp, udp)	lmutex_unlock(ulwp_mutex(ulwp, udp))
1007
1008#ifdef _SYSCALL32	/* needed by libc_db */
1009
1010typedef struct ulwp32 {
1011#if defined(__sparc)
1012	uint32_t	ul_dinstr;	/* scratch space for dtrace */
1013	uint32_t	ul_padsparc0[15];
1014	uint32_t	ul_dsave;	/* dtrace: save %g1, %g0, %sp */
1015	uint32_t	ul_drestore;	/* dtrace: restore %g0, %g0, %g0 */
1016	uint32_t	ul_dftret;	/* dtrace: return probe fasttrap */
1017	uint32_t	ul_dreturn;	/* dtrace: return %o0 */
1018#endif
1019	caddr32_t	ul_self;	/* pointer to self */
1020#if defined(__x86)
1021	uint8_t		ul_dinstr[40];	/* scratch space for dtrace */
1022#endif
1023	caddr32_t	ul_uberdata;	/* uber (super-global) data */
1024	tls32_t		ul_tls;		/* dynamic thread-local storage base */
1025	caddr32_t	ul_forw;	/* forw, back all_lwps list, */
1026	caddr32_t	ul_back;	/* protected by link_lock */
1027	caddr32_t	ul_next;	/* list to keep track of stacks */
1028	caddr32_t	ul_hash;	/* hash chain linked list */
1029	caddr32_t	ul_rval;	/* return value from thr_exit() */
1030	caddr32_t	ul_stk;		/* mapping base of the stack */
1031	size32_t	ul_mapsiz;	/* mapping size of the stack */
1032	size32_t	ul_guardsize;	/* normally _lpagesize */
1033	caddr32_t	ul_stktop;	/* broken thr_stksegment() interface */
1034	size32_t	ul_stksiz;	/* broken thr_stksegment() interface */
1035	stack32_t	ul_ustack;	/* current stack boundaries */
1036	int		ul_ix;		/* hash index */
1037	lwpid_t		ul_lwpid;	/* thread id, aka the lwp id */
1038	pri_t		ul_pri;		/* scheduling priority */
1039	pri_t		ul_epri;	/* real-time ceiling priority */
1040	char		ul_policy;	/* scheduling policy */
1041	char		ul_cid;		/* scheduling class id */
1042	union {
1043		struct {
1044			char	cursig;	/* deferred signal number */
1045			char	pleasestop; /* lwp requested to stop itself */
1046		} s;
1047		short	curplease;	/* for testing both at once */
1048	} ul_cp;
1049	char		ul_stop;	/* reason for stopping */
1050	char		ul_signalled;	/* this lwp was cond_signal()d */
1051	char		ul_dead;	/* this lwp has called thr_exit */
1052	char		ul_unwind;	/* posix: unwind C++ stack */
1053	char		ul_detached;	/* THR_DETACHED at thread_create() */
1054					/* or pthread_detach() was called */
1055	char		ul_writer;	/* sleeping in rw_wrlock() */
1056	char		ul_stopping;	/* set by curthread: stopping self */
1057	char		ul_cancel_prologue;	/* for _cancel_prologue() */
1058	short		ul_preempt;	/* no_preempt()/preempt() */
1059	short		ul_savpreempt;	/* pre-existing preempt value */
1060	char		ul_sigsuspend;	/* thread is in sigsuspend/pollsys */
1061	char		ul_main;	/* thread is the main thread */
1062	char		ul_fork;	/* thread is performing a fork */
1063	char		ul_primarymap;	/* primary link-map is initialized */
1064	/* per-thread copies of the corresponding global variables */
1065	uint8_t		ul_max_spinners;	/* thread_max_spinners */
1066	char		ul_door_noreserve;	/* thread_door_noreserve */
1067	char		ul_queue_fifo;		/* thread_queue_fifo */
1068	char		ul_cond_wait_defer;	/* thread_cond_wait_defer */
1069	char		ul_error_detection;	/* thread_error_detection */
1070	char		ul_async_safe;		/* thread_async_safe */
1071	char		ul_rt;			/* found on an RT queue */
1072	char		ul_rtqueued;		/* was RT when queued */
1073	char		ul_misaligned;		/* thread_locks_misaligned */
1074	char		ul_pad[3];
1075	int		ul_adaptive_spin;	/* thread_adaptive_spin */
1076	int		ul_queue_spin;		/* thread_queue_spin */
1077	int		ul_critical;	/* non-zero == in a critical region */
1078	int		ul_sigdefer;	/* non-zero == defer signals */
1079	int		ul_vfork;	/* thread is the child of vfork() */
1080	int		ul_cancelable;	/* _cancelon()/_canceloff() */
1081	char		ul_cancel_pending;  /* pthread_cancel() was called */
1082	char		ul_cancel_disabled; /* PTHREAD_CANCEL_DISABLE */
1083	char		ul_cancel_async;    /* PTHREAD_CANCEL_ASYNCHRONOUS */
1084	char		ul_save_async;	/* saved copy of ul_cancel_async */
1085	char		ul_mutator;	/* lwp is a mutator (java interface) */
1086	char		ul_created;	/* created suspended */
1087	char		ul_replace;	/* replacement; must be free()d */
1088	uchar_t		ul_nocancel;	/* cancellation can't happen */
1089	int		ul_errno;	/* per-thread errno */
1090	caddr32_t	ul_errnop;	/* pointer to errno or self->ul_errno */
1091	caddr32_t	ul_clnup_hdr;	/* head of cleanup handlers list */
1092	caddr32_t	ul_schedctl_called; /* ul_schedctl is set up */
1093	caddr32_t	ul_schedctl;	/* schedctl data */
1094	int		ul_bindflags;	/* bind_guard() interface to ld.so.1 */
1095	uint_t		ul_libc_locks;	/* count of cancel_safe_mutex_lock()s */
1096	caddr32_t	ul_stsd;	/* slow TLS for keys >= TSD_NFAST */
1097	caddr32_t	ul_ftsd[TSD_NFAST]; /* fast TLS for keys < TSD_NFAST */
1098	td_evbuf32_t	ul_td_evbuf;	/* event buffer */
1099	char		ul_td_events_enable;	/* event mechanism enabled */
1100	char		ul_sync_obj_reg;	/* tdb_sync_obj_register() */
1101	char		ul_qtype;	/* MX or CV */
1102	char		ul_cv_wake;	/* != 0: just wake up, don't requeue */
1103	int		ul_rtld;	/* thread is running inside ld.so.1 */
1104	int		ul_usropts;	/* flags given to thr_create() */
1105	caddr32_t	ul_startpc;	/* start func (thr_create()) */
1106	caddr32_t	ul_startarg;	/* argument for start function */
1107	caddr32_t	ul_wchan;	/* synch object when sleeping */
1108	caddr32_t	ul_link;	/* sleep queue link */
1109	caddr32_t	ul_sleepq;	/* sleep queue thread is waiting on */
1110	caddr32_t	ul_cvmutex;	/* mutex dropped when waiting on a cv */
1111	caddr32_t	ul_mxchain;	/* chain of owned ceiling mutexes */
1112	int		ul_save_state;	/* bind_guard() interface to ld.so.1 */
1113	uint_t		ul_rdlockcnt;	/* # entries in ul_readlock array */
1114				/* 0 means there is but a single entry */
1115	union {				/* single entry or pointer to array */
1116		readlock32_t	single;
1117		caddr32_t	array;
1118	} ul_readlock;
1119	uint_t		ul_heldlockcnt;	/* # entries in ul_heldlocks array */
1120				/* 0 means there is but a single entry */
1121	union {				/* single entry or pointer to array */
1122		caddr32_t	single;
1123		caddr32_t	array;
1124	} ul_heldlocks;
1125	/* PROBE_SUPPORT begin */
1126	caddr32_t	ul_tpdp;
1127	/* PROBE_SUPPORT end */
1128	caddr32_t	ul_siglink;	/* pointer to previous context */
1129	uint_t		ul_spin_lock_spin;	/* spin lock statistics */
1130	uint_t		ul_spin_lock_spin2;
1131	uint_t		ul_spin_lock_sleep;
1132	uint_t		ul_spin_lock_wakeup;
1133	queue_root32_t	ul_queue_root;	/* root of a sleep queue */
1134	id_t		ul_rtclassid;	/* real-time class id */
1135	uint_t		ul_pilocks;	/* count of PI locks held */
1136		/* the following members *must* be last in the structure */
1137		/* they are discarded when ulwp is replaced on thr_exit() */
1138	sigset_t	ul_sigmask;	/* thread's current signal mask */
1139	sigset_t	ul_tmpmask;	/* signal mask for sigsuspend/pollsys */
1140	siginfo32_t	ul_siginfo;	/* deferred siginfo */
1141	mutex_t		ul_spinlock;	/* used when suspending/continuing */
1142	fpuenv32_t	ul_fpuenv;	/* floating point state */
1143	caddr32_t	ul_sp;		/* stack pointer when blocked */
1144#if defined(sparc)
1145	caddr32_t	ul_unwind_ret;	/* used only by _ex_clnup_handler() */
1146#endif
1147	tumem32_t	ul_tmem;	/* used only by umem */
1148} ulwp32_t;
1149
1150#define	REPLACEMENT_SIZE32	((size_t)&((ulwp32_t *)NULL)->ul_sigmask)
1151
1152typedef struct uberdata32 {
1153	pad_lock_t	_link_lock;
1154	pad_lock_t	_ld_lock;
1155	pad_lock_t	_fork_lock;
1156	pad_lock_t	_atfork_lock;
1157	pad32_lock_t	_callout_lock;
1158	pad32_lock_t	_tdb_hash_lock;
1159	tdb_sync_stats_t tdb_hash_lock_stats;
1160	siguaction32_t	siguaction[NSIG];
1161	bucket32_t	bucket[NBUCKETS];
1162	atexit_root32_t	atexit_root;
1163	quickexit_root32_t quickexit_root;
1164	tsd_metadata32_t tsd_metadata;
1165	tls_metadata32_t tls_metadata;
1166	char		primary_map;
1167	char		bucket_init;
1168	char		pad[2];
1169	uberflags_t	uberflags;
1170	caddr32_t	queue_head;
1171	caddr32_t	thr_hash_table;
1172	uint_t		hash_size;
1173	uint_t		hash_mask;
1174	caddr32_t	ulwp_one;
1175	caddr32_t	all_lwps;
1176	caddr32_t	all_zombies;
1177	int		nthreads;
1178	int		nzombies;
1179	int		ndaemons;
1180	int		pid;
1181	caddr32_t	sigacthandler;
1182	caddr32_t	lwp_stacks;
1183	caddr32_t	lwp_laststack;
1184	int		nfreestack;
1185	int		thread_stack_cache;
1186	caddr32_t	ulwp_freelist;
1187	caddr32_t	ulwp_lastfree;
1188	caddr32_t	ulwp_replace_free;
1189	caddr32_t	ulwp_replace_last;
1190	caddr32_t	atforklist;
1191	caddr32_t	robustlocks;
1192	caddr32_t	robustlist;
1193	caddr32_t	progname;
1194	caddr32_t	ub_comm_page;
1195	caddr32_t	tdb_bootstrap;
1196	tdb32_t		tdb;
1197} uberdata32_t;
1198
1199#endif	/* _SYSCALL32 */
1200
1201/* ul_stop values */
1202#define	TSTP_REGULAR	0x01	/* Stopped by thr_suspend() */
1203#define	TSTP_MUTATOR	0x08	/* stopped by thr_suspend_*mutator*() */
1204#define	TSTP_FORK	0x20	/* stopped by suspend_fork() */
1205
1206/*
1207 * Implementation-specific attribute types for pthread_mutexattr_init() etc.
1208 */
1209
1210typedef	struct	_cvattr {
1211	int	pshared;
1212	clockid_t clockid;
1213} cvattr_t;
1214
1215typedef	struct	_mattr {
1216	int	pshared;
1217	int	protocol;
1218	int	prioceiling;
1219	int	type;
1220	int	robustness;
1221} mattr_t;
1222
1223typedef	struct	_thrattr {
1224	size_t	stksize;
1225	void	*stkaddr;
1226	int	detachstate;
1227	int	daemonstate;
1228	int	scope;
1229	int	prio;
1230	int	policy;
1231	int	inherit;
1232	size_t	guardsize;
1233} thrattr_t;
1234
1235typedef	struct	_rwlattr {
1236	int	pshared;
1237} rwlattr_t;
1238
1239/* _curthread() is inline for speed */
1240extern	ulwp_t		*_curthread(void);
1241#define	curthread	(_curthread())
1242
1243/* this version (also inline) can be tested for NULL */
1244extern	ulwp_t		*__curthread(void);
1245
1246/* get the current stack pointer (also inline) */
1247extern	greg_t		stkptr(void);
1248
1249/*
1250 * Suppress __attribute__((...)) if we are not compiling with gcc
1251 */
1252#if !defined(__GNUC__)
1253#define	__attribute__(string)
1254#endif
1255
1256/* Fetch the dispatch (kernel) priority of a thread */
1257#define	real_priority(ulwp)	\
1258	((ulwp)->ul_schedctl? (ulwp)->ul_schedctl->sc_priority : 0)
1259
1260/*
1261 * Implementation functions.  Not visible outside of the library itself.
1262 */
1263extern	int	__nanosleep(const timespec_t *, timespec_t *);
1264extern	void	getgregs(ulwp_t *, gregset_t);
1265extern	void	setgregs(ulwp_t *, gregset_t);
1266extern	void	thr_panic(const char *);
1267#pragma rarely_called(thr_panic)
1268extern	void	mutex_panic(mutex_t *, const char *);
1269#pragma rarely_called(mutex_panic)
1270extern	ulwp_t	*find_lwp(thread_t);
1271extern	void	finish_init(void);
1272extern	void	update_sched(ulwp_t *);
1273extern	void	queue_alloc(void);
1274extern	void	tmem_exit(void);
1275extern	void	tsd_exit(void);
1276extern	void	tsd_free(ulwp_t *);
1277extern	void	tls_setup(void);
1278extern	void	tls_exit(void);
1279extern	void	tls_free(ulwp_t *);
1280extern	void	rwl_free(ulwp_t *);
1281extern	void	heldlock_exit(void);
1282extern	void	heldlock_free(ulwp_t *);
1283extern	void	sigacthandler(int, siginfo_t *, void *);
1284extern	void	signal_init(void);
1285extern	int	sigequalset(const sigset_t *, const sigset_t *);
1286extern	void	mutex_setup(void);
1287extern	void	take_deferred_signal(int);
1288extern	void	*setup_top_frame(void *, size_t, ulwp_t *);
1289extern	int	setup_context(ucontext_t *, void *(*func)(ulwp_t *),
1290			ulwp_t *ulwp, caddr_t stk, size_t stksize);
1291extern	volatile sc_shared_t *setup_schedctl(void);
1292extern	void	*lmalloc(size_t);
1293extern	void	lfree(void *, size_t);
1294extern	void	*libc_malloc(size_t);
1295extern	void	*libc_realloc(void *, size_t);
1296extern	void	libc_free(void *);
1297extern	char	*libc_strdup(const char *);
1298extern	void	ultos(uint64_t, int, char *);
1299extern	void	lock_error(const mutex_t *, const char *, void *, const char *);
1300extern	void	rwlock_error(const rwlock_t *, const char *, const char *);
1301extern	void	thread_error(const char *);
1302extern	void	grab_assert_lock(void);
1303extern	void	dump_queue_statistics(void);
1304extern	void	collect_queue_statistics(void);
1305extern	void	record_spin_locks(ulwp_t *);
1306extern	void	remember_lock(mutex_t *);
1307extern	void	forget_lock(mutex_t *);
1308extern	void	register_lock(mutex_t *);
1309extern	void	unregister_locks(void);
1310#if defined(__sparc)
1311extern	void	_flush_windows(void);
1312#else
1313#define	_flush_windows()
1314#endif
1315extern	void	set_curthread(void *);
1316
1317/*
1318 * Utility function used when waking up many threads (more than MAXLWPS)
1319 * all at once.  See mutex_wakeup_all(), cond_broadcast(), and rw_unlock().
1320 */
1321#define	MAXLWPS	128	/* max remembered lwpids before overflow */
1322#define	NEWLWPS	2048	/* max remembered lwpids at first overflow */
1323extern	lwpid_t	*alloc_lwpids(lwpid_t *, int *, int *);
1324
1325/* enter a critical section */
1326#define	enter_critical(self)	(self->ul_critical++)
1327
1328/* exit a critical section, take deferred actions if necessary */
1329extern	void	do_exit_critical(void);
1330#define	exit_critical(self)					\
1331	(void) (self->ul_critical--,				\
1332	    ((self->ul_curplease && self->ul_critical == 0)?	\
1333	    (do_exit_critical(), 0) : 0))
1334
1335/*
1336 * Like enter_critical()/exit_critical() but just for deferring signals.
1337 * Unlike enter_critical()/exit_critical(), ul_sigdefer may be set while
1338 * calling application functions like constructors and destructors.
1339 * Care must be taken if the application function attempts to set
1340 * the signal mask while a deferred signal is present; the setting
1341 * of the signal mask must also be deferred.
1342 */
1343#define	sigoff(self)	(self->ul_sigdefer++)
1344#define	sigon(self)						\
1345	(void) ((--self->ul_sigdefer == 0 &&			\
1346	    self->ul_curplease && self->ul_critical == 0)?	\
1347	    (do_exit_critical(), 0) : 0)
1348
1349/* these are exported functions */
1350extern	void	_sigoff(void);
1351extern	void	_sigon(void);
1352
1353#define	sigorset(s1, s2)				\
1354	(((s1)->__sigbits[0] |= (s2)->__sigbits[0]),	\
1355	((s1)->__sigbits[1] |= (s2)->__sigbits[1]),	\
1356	((s1)->__sigbits[2] |= (s2)->__sigbits[2]),	\
1357	((s1)->__sigbits[3] |= (s2)->__sigbits[3]))
1358
1359#define	sigandset(s1, s2)				\
1360	(((s1)->__sigbits[0] &= (s2)->__sigbits[0]),	\
1361	((s1)->__sigbits[1] &= (s2)->__sigbits[1]),	\
1362	((s1)->__sigbits[2] &= (s2)->__sigbits[2]),	\
1363	((s1)->__sigbits[3] &= (s2)->__sigbits[3]))
1364
1365#define	sigdiffset(s1, s2)				\
1366	(((s1)->__sigbits[0] &= ~(s2)->__sigbits[0]),	\
1367	((s1)->__sigbits[1] &= ~(s2)->__sigbits[1]),	\
1368	((s1)->__sigbits[2] &= ~(s2)->__sigbits[2]),	\
1369	((s1)->__sigbits[3] &= ~(s2)->__sigbits[3]))
1370
1371#define	delete_reserved_signals(s)			\
1372	(((s)->__sigbits[0] &= MASKSET0),		\
1373	((s)->__sigbits[1] &= (MASKSET1 & ~SIGMASK(SIGCANCEL))),\
1374	((s)->__sigbits[2] &= MASKSET2),		\
1375	((s)->__sigbits[3] &= MASKSET3))
1376
1377extern	void	block_all_signals(ulwp_t *self);
1378
1379/*
1380 * When restoring the signal mask after having previously called
1381 * block_all_signals(), if we have a deferred signal present then
1382 * do nothing other than ASSERT() that we are in a critical region.
1383 * The signal mask will be set when we emerge from the critical region
1384 * and call take_deferred_signal().  There is no race condition here
1385 * because the kernel currently has all signals blocked for this thread.
1386 */
1387#define	restore_signals(self)						\
1388	((void) ((self)->ul_cursig?					\
1389	(ASSERT((self)->ul_critical + (self)->ul_sigdefer != 0), 0) :	\
1390	__lwp_sigmask(SIG_SETMASK, &(self)->ul_sigmask)))
1391
1392extern	void	set_cancel_pending_flag(ulwp_t *, int);
1393extern	void	set_cancel_eintr_flag(ulwp_t *);
1394extern	void	set_parking_flag(ulwp_t *, int);
1395extern	int	cancel_active(void);
1396
1397extern	void	*_thrp_setup(ulwp_t *);
1398extern	void	_fpinherit(ulwp_t *);
1399extern	void	_lwp_start(void);
1400extern	void	_lwp_terminate(void);
1401extern	void	lmutex_lock(mutex_t *);
1402extern	void	lmutex_unlock(mutex_t *);
1403extern	void	lrw_rdlock(rwlock_t *);
1404extern	void	lrw_wrlock(rwlock_t *);
1405extern	void	lrw_unlock(rwlock_t *);
1406extern	void	sig_mutex_lock(mutex_t *);
1407extern	void	sig_mutex_unlock(mutex_t *);
1408extern	int	sig_mutex_trylock(mutex_t *);
1409extern	int	sig_cond_wait(cond_t *, mutex_t *);
1410extern	int	sig_cond_reltimedwait(cond_t *, mutex_t *, const timespec_t *);
1411extern	void	cancel_safe_mutex_lock(mutex_t *);
1412extern	void	cancel_safe_mutex_unlock(mutex_t *);
1413extern	int	cancel_safe_mutex_trylock(mutex_t *);
1414extern	void	_prefork_handler(void);
1415extern	void	_postfork_parent_handler(void);
1416extern	void	_postfork_child_handler(void);
1417extern	void	postfork1_child(void);
1418extern	void	postfork1_child_aio(void);
1419extern	void	postfork1_child_sigev_aio(void);
1420extern	void	postfork1_child_sigev_mq(void);
1421extern	void	postfork1_child_sigev_timer(void);
1422extern	void	postfork1_child_tpool(void);
1423extern	void	fork_lock_enter(void);
1424extern	void	fork_lock_exit(void);
1425extern	void	suspend_fork(void);
1426extern	void	continue_fork(int);
1427extern	void	do_sigcancel(void);
1428extern	void	setup_cancelsig(int);
1429extern	void	init_sigev_thread(void);
1430extern	void	init_aio(void);
1431extern	void	init_progname(void);
1432extern	void	_cancelon(void);
1433extern	void	_canceloff(void);
1434extern	void	_canceloff_nocancel(void);
1435extern	void	_cancel_prologue(void);
1436extern	void	_cancel_epilogue(void);
1437extern	void	no_preempt(ulwp_t *);
1438extern	void	preempt(ulwp_t *);
1439extern	void	_thrp_unwind(void *);
1440
1441extern	pid_t	__forkx(int);
1442extern	pid_t	__forkallx(int);
1443extern	int	__open(const char *, int, mode_t);
1444extern	int	__open64(const char *, int, mode_t);
1445extern	int	__openat(int, const char *, int, mode_t);
1446extern	int	__openat64(int, const char *, int, mode_t);
1447extern	int	__close(int);
1448extern	ssize_t	__read(int, void *, size_t);
1449extern	ssize_t	__write(int, const void *, size_t);
1450extern	int	__fcntl(int, int, ...);
1451extern	int	__lwp_continue(lwpid_t);
1452extern	int	__lwp_create(ucontext_t *, uint_t, lwpid_t *);
1453extern	int	___lwp_suspend(lwpid_t);
1454extern	int	lwp_wait(lwpid_t, lwpid_t *);
1455extern	int	__lwp_wait(lwpid_t, lwpid_t *);
1456extern	int	__lwp_detach(lwpid_t);
1457extern	sc_shared_t *__schedctl(void);
1458
1459/* actual system call traps */
1460extern	int	__setcontext(const ucontext_t *);
1461extern	int	__getcontext(ucontext_t *);
1462extern	int	__clock_gettime(clockid_t, timespec_t *);
1463extern	void	abstime_to_reltime(clockid_t, const timespec_t *, timespec_t *);
1464extern	void	hrt2ts(hrtime_t, timespec_t *);
1465
1466extern	int	__sigaction(int, const struct sigaction *, struct sigaction *);
1467extern	int	__sigprocmask(int, const sigset_t *, sigset_t *);
1468extern	int	__lwp_sigmask(int, const sigset_t *);
1469extern	void	__sighndlr(int, siginfo_t *, ucontext_t *, void (*)());
1470extern	caddr_t	__sighndlrend;
1471#pragma unknown_control_flow(__sighndlr)
1472
1473/* belongs in <pthread.h> */
1474#define	PTHREAD_CREATE_DAEMON_NP	0x100	/* = THR_DAEMON */
1475#define	PTHREAD_CREATE_NONDAEMON_NP	0
1476extern	int	pthread_attr_setdaemonstate_np(pthread_attr_t *, int);
1477extern	int	pthread_attr_getdaemonstate_np(const pthread_attr_t *, int *);
1478
1479extern	int	mutex_held(mutex_t *);
1480extern	int	mutex_lock_internal(mutex_t *, timespec_t *, int);
1481extern	int	mutex_unlock_internal(mutex_t *, int);
1482
1483/* not cancellation points: */
1484extern	int	__cond_wait(cond_t *, mutex_t *);
1485extern	int	__cond_timedwait(cond_t *, mutex_t *, const timespec_t *);
1486extern	int	__cond_reltimedwait(cond_t *, mutex_t *, const timespec_t *);
1487
1488extern	int	rw_read_held(rwlock_t *);
1489extern	int	rw_write_held(rwlock_t *);
1490
1491extern	int	_thrp_create(void *, size_t, void *(*)(void *), void *, long,
1492			thread_t *, size_t);
1493extern	int	_thrp_suspend(thread_t, uchar_t);
1494extern	int	_thrp_continue(thread_t, uchar_t);
1495
1496extern	void	_thrp_terminate(void *);
1497extern	void	_thrp_exit(void);
1498
1499extern	const pcclass_t *get_info_by_class(id_t);
1500extern	const pcclass_t *get_info_by_policy(int);
1501extern	const thrattr_t *def_thrattr(void);
1502extern	id_t	setparam(idtype_t, id_t, int, int);
1503extern	id_t	setprio(idtype_t, id_t, int, int *);
1504extern	id_t	getparam(idtype_t, id_t, int *, struct sched_param *);
1505
1506/*
1507 * System call wrappers (direct interfaces to the kernel)
1508 */
1509extern	int	___lwp_mutex_register(mutex_t *, mutex_t **);
1510extern	int	___lwp_mutex_trylock(mutex_t *, ulwp_t *);
1511extern	int	___lwp_mutex_timedlock(mutex_t *, timespec_t *, ulwp_t *);
1512extern	int	___lwp_mutex_unlock(mutex_t *);
1513extern	int	___lwp_mutex_wakeup(mutex_t *, int);
1514extern	int	___lwp_cond_wait(cond_t *, mutex_t *, timespec_t *, int);
1515extern	int	___lwp_sema_timedwait(lwp_sema_t *, timespec_t *, int);
1516extern	int	__lwp_rwlock_rdlock(rwlock_t *, timespec_t *);
1517extern	int	__lwp_rwlock_wrlock(rwlock_t *, timespec_t *);
1518extern	int	__lwp_rwlock_tryrdlock(rwlock_t *);
1519extern	int	__lwp_rwlock_trywrlock(rwlock_t *);
1520extern	int	__lwp_rwlock_unlock(rwlock_t *);
1521extern	int	__lwp_park(timespec_t *, lwpid_t);
1522extern	int	__lwp_unpark(lwpid_t);
1523extern	int	__lwp_unpark_all(lwpid_t *, int);
1524#if defined(__x86)
1525extern	int	___lwp_private(int, int, void *);
1526#endif	/* __x86 */
1527
1528/*
1529 * inlines
1530 */
1531extern	int		set_lock_byte(volatile uint8_t *);
1532extern	uint32_t	atomic_swap_32(volatile uint32_t *, uint32_t);
1533extern	uint32_t	atomic_cas_32(volatile uint32_t *, uint32_t, uint32_t);
1534extern	void		atomic_inc_32(volatile uint32_t *);
1535extern	void		atomic_dec_32(volatile uint32_t *);
1536extern	void		atomic_and_32(volatile uint32_t *, uint32_t);
1537extern	void		atomic_or_32(volatile uint32_t *, uint32_t);
1538#if defined(__sparc)
1539extern	ulong_t		caller(void);
1540extern	ulong_t		getfp(void);
1541#endif	/* __sparc */
1542
1543#include "thr_inlines.h"
1544
1545#endif	/* _THR_UBERDATA_H */
1546