thr_uberdata.h revision ae115bc77f6fcde83175c75b4206dc2e50747966
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (the "License").
* You may not use this file except in compliance with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright 2007 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#ifndef _THR_UBERDATA_H
#define _THR_UBERDATA_H
#pragma ident "%Z%%M% %I% %E% SMI"
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <string.h>
#include <signal.h>
#include <ucontext.h>
#include <thread.h>
#include <pthread.h>
#include <link.h>
#include <sys/resource.h>
#include <errno.h>
#include <sys/asm_linkage.h>
#include <synch.h>
#include <door.h>
#include <limits.h>
#include <schedctl.h>
#include <sys/priocntl.h>
#include <thread_db.h>
#include <setjmp.h>
#include "libc_int.h"
#include "tdb_agent.h"
#include "thr_debug.h"
/*
* This is an implementation-specific include file for threading support.
* It is not to be seen by the clients of the library.
*
* This file also describes uberdata in libc.
*
* The term "uberdata" refers to data that is unique and visible across
* all link maps. The name is meant to imply that such data is truly
* global, not just locally global to a particular link map.
*
* See the Linker and Libraries Guide for a full description of alternate
* link maps and how they are set up and used.
*
* Alternate link maps implement multiple global namespaces within a single
* process. There may be multiple instances of identical dynamic libraries
* loaded in a process's address space at the same time, each on a different
* link map (as determined by the dynamic linker), each with its own set of
* global variables. Which particular instance of a global variable is seen
* by a thread running in the process is determined by the link map on which
* the thread happens to be executing at the time.
*
* However, there are aspects of a process that are unique across all
* link maps, in particular the structures used to implement threads
* of control (in Sparc terminology, there is only one %g7 regardless
* of the link map on which the thread is executing).
*
* All uberdata is referenced from a base pointer in the thread's ulwp_t
* structure (which is also uberdata). All allocations and deallocations
* of uberdata are made via the uberdata-aware lmalloc() and lfree()
* interfaces (malloc() and free() are simply locally-global).
*/
/*
* Special libc-private access to errno.
* We do this so that references to errno do not invoke the dynamic linker.
*/
/*
* and why they are different for sparc and intel.
*/
#if defined(__sparc)
/* lock.lock64.pad[x] 4 5 6 7 */
#define LOCKMASK 0xff000000
#define WAITERMASK 0x000000ff
#define WAITER 0x00000001
#define LOCKSET 0xff
#define LOCKCLEAR 0
/* lock.lock64.pad[x] 7 6 5 4 */
#define LOCKMASK 0xff000000
#define WAITERMASK 0x00ff0000
#define WAITER 0x00010000
#define LOCKSET 0x01
#define LOCKCLEAR 0
#else
#error "neither __sparc nor __x86 is defined"
#endif
/*
* Fetch the owner of a USYNC_THREAD mutex.
* Don't use this with process-shared mutexes;
* the owing thread may be in a different process.
*/
/*
* Test if a thread owns a USYNC_THREAD mutex. This is inappropriate
* for a process-shared (USYNC_PROCESS | USYNC_PROCESS_ROBUST) mutex.
* The 'mp' argument must not have side-effects since it is evaluated twice.
*/
/*
* uberflags.uf_tdb_register_sync is an interface with libc_db to enable the
* collection of lock statistics by a debugger or other collecting tool.
*
* uberflags.uf_thread_error_detection is set by an environment variable:
* _THREAD_ERROR_DETECTION
* 0 == no detection of locking primitive errors.
* 1 == detect errors and issue a warning message.
* 2 == detect errors, issue a warning message, and dump core.
*
* We bundle these together in uberflags.uf_trs_ted to make a test of either
* being non-zero a single memory reference (for speed of mutex_lock(), etc).
*
* uberflags.uf_mt is set non-zero when the first thread (in addition
* to the main thread) is created.
*
* We bundle all these flags together in uberflags.uf_all to make a test
* of any being non-zero a single memory reference (again, for speed).
*/
typedef union {
int uf_all; /* combined all flags */
struct {
short h_pad;
short h_trs_ted; /* combined reg sync & error detect */
} uf_h;
struct {
char x_mt;
char x_pad;
char x_tdb_register_sync;
char x_thread_error_detection;
} uf_x;
} uberflags_t;
/*
* NOTE WELL:
* To enable further optimization, the "ul_schedctl_called" member
* of the ulwp_t structure (below) serves double-duty:
* 1. If NULL, it means that the thread must call __schedctl()
* to set up its schedctl mappings before acquiring a mutex.
* This is required by the implementation of adaptive mutex locking.
* 2. If non-NULL, it points to uberdata.uberflags, so that tests of
* uberflags can be made without additional memory references.
* This allows the common case of _mutex_lock() and _mutex_unlock() for
* USYNC_THREAD mutexes with no error detection and no lock statistics
* to be optimized for speed.
*/
/* double the default stack size for 64-bit processes */
#ifdef _LP64
#else
#endif
#define TSD_NKEYS _POSIX_THREAD_KEYS_MAX
#define THREAD_MIN_PRIORITY 0
#define THREAD_MAX_PRIORITY 127
#define PRIO_SET 0 /* set priority and policy */
#define PRIO_INHERIT 2
#define PRIO_DISINHERIT 3
#define MUTEX_TRY 0
#define MUTEX_LOCK 1
#if defined(__x86)
typedef struct { /* structure returned by fnstenv */
int fctrl; /* control word */
int fstat; /* status word (flags, etc) */
int ftag; /* tag of which regs busy */
} fpuenv_t;
#ifdef _SYSCALL32
typedef fpuenv_t fpuenv32_t;
#endif /* _SYSCALL32 */
typedef struct { /* fp state structure */
} fpuenv_t;
#ifdef _SYSCALL32
typedef struct {
} fpuenv32_t;
#endif /* _SYSCALL32 */
#endif /* __x86 */
#if defined(__x86)
extern void ht_pause(void); /* "pause" instruction */
#else
#define SMT_PAUSE()
#endif /* __x86 */
/*
* Cleanup handler related data.
* This structure is exported as _cleanup_t in pthread.h.
* pthread.h exports only the size of this structure, so check
* _cleanup_t in pthread.h before making any change here.
*/
typedef struct __cleanup {
void (*func)(void *); /* cleanup handler address */
void *arg; /* handler's argument */
} __cleanup_t;
/*
* Thread-Specific Data (TSD)
* TSD_NFAST includes the invalid key zero, so there
* are really only (TSD_NFAST - 1) fast key slots.
*/
typedef void (*PFrV)(void *);
#define TSD_NFAST 9
/*
* The tsd union is designed to burn a little memory (9 words) to make
* lookups blindingly fast. Note that tsd_nalloc could be placed at the
* end of the pad region to increase the likelihood that it falls on the
* same cache line as the data.
*/
typedef union tsd {
void *tsd_data[1];
} tsd_t;
typedef struct {
#ifdef _SYSCALL32
typedef union tsd32 {
} tsd32_t;
typedef struct {
#endif /* _SYSCALL32 */
/*
* Thread-Local Storage (TLS)
*/
typedef struct {
void *tls_data;
} tls_t;
typedef struct {
#ifdef _SYSCALL32
typedef struct {
} tls32_t;
typedef struct {
#endif /* _SYSCALL32 */
/*
* Sleep queues for USYNC_THREAD condvars and mutexes.
* The size and alignment is 64 bytes to reduce cache conflicts.
*/
typedef union {
struct {
} qh_qh;
} queue_head_t;
/* queue types passed to queue_lock() and enqueue() */
#define MX 0
#define CV 1
#define QHASHSIZE 512
extern queue_head_t *queue_lock(void *, int);
extern void queue_unlock(queue_head_t *);
extern void unsleep_self(void);
extern void spin_lock_set(mutex_t *);
extern void spin_lock_clear(mutex_t *);
/*
* Memory block for chain of owned ceiling mutexes.
*/
typedef struct mxchain {
struct mxchain *mxchain_next;
} mxchain_t;
/*
* Pointer to an rwlock that is held for reading.
* Used in rw_rdlock() to allow a thread that already holds a read
* lock to acquire another read lock on the same rwlock even if
* there are writers waiting. This to avoid deadlock when acquiring
* a read lock more than once in the presence of pending writers.
* POSIX mandates this behavior.
*/
typedef struct {
void *rd_rwlock; /* the rwlock held for reading */
} readlock_t;
#ifdef _SYSCALL32
typedef struct {
} readlock32_t;
#endif /* _SYSCALL32 */
/*
* Maximum number of read locks allowed for one thread on one rwlock.
* This could be as large as INT_MAX, but the SUSV3 test suite would
* take an inordinately long time to complete. This is big enough.
*/
#define READ_LOCK_MAX 100000
/*
* Round up an integral value to a multiple of 64
*/
#define roundup64(x) (-(-(x) & -64))
/*
* NOTE: Whatever changes are made to ulwp_t must be
*
* NOTE: ul_self *must* be the first member of ulwp_t on x86
* Low-level x86 code relies on this.
*/
typedef struct ulwp {
/*
* These members always need to come first on sparc.
* For dtrace, a ulwp_t must be aligned on a 64-byte boundary.
*/
#if defined(__sparc)
#endif
#if defined(__i386)
#endif
void *ul_rval; /* return value from thr_exit() */
int ul_ix; /* hash index */
char ul_policy; /* scheduling policy */
char ul_pri_mapped; /* != 0 means ul_mappedpri is valid */
union {
struct {
char cursig; /* deferred signal number */
char pleasestop; /* lwp requested to stop itself */
} s;
short curplease; /* for testing both at once */
} ul_cp;
char ul_stop; /* reason for stopping */
char ul_signalled; /* this lwp was cond_signal()d */
char ul_dead; /* this lwp has called thr_exit */
char ul_unwind; /* posix: unwind C++ stack */
char ul_detached; /* THR_DETACHED at thread_create() */
/* or pthread_detach() was called */
char ul_writer; /* sleeping in rw_wrlock() */
char ul_stopping; /* set by curthread: stopping self */
char ul_cancel_prologue; /* for _cancel_prologue() */
short ul_preempt; /* no_preempt()/preempt() */
short ul_savpreempt; /* pre-existing preempt value */
char ul_sigsuspend; /* thread is in sigsuspend/pollsys */
char ul_main; /* thread is the main thread */
char ul_fork; /* thread is performing a fork */
char ul_primarymap; /* primary link-map is initialized */
/* per-thread copies of the corresponding global variables */
char ul_door_noreserve; /* thread_door_noreserve */
char ul_queue_fifo; /* thread_queue_fifo */
char ul_cond_wait_defer; /* thread_cond_wait_defer */
char ul_error_detection; /* thread_error_detection */
char ul_async_safe; /* thread_async_safe */
char ul_pad1[2];
int ul_adaptive_spin; /* thread_adaptive_spin */
int ul_release_spin; /* thread_release_spin */
int ul_queue_spin; /* thread_queue_spin */
volatile int ul_critical; /* non-zero == in a critical region */
int ul_sigdefer; /* non-zero == defer signals */
int ul_vfork; /* thread is the child of vfork() */
int ul_cancelable; /* _cancelon()/_canceloff() */
char ul_cancel_pending; /* pthread_cancel() was called */
char ul_cancel_disabled; /* PTHREAD_CANCEL_DISABLE */
char ul_cancel_async; /* PTHREAD_CANCEL_ASYNCHRONOUS */
char ul_save_async; /* saved copy of ul_cancel_async */
char ul_mutator; /* lwp is a mutator (java interface) */
char ul_created; /* created suspended */
char ul_replace; /* replacement; must be free()d */
int ul_errno; /* per-thread errno */
int *ul_errnop; /* pointer to errno or self->ul_errno */
int ul_bindflags; /* bind_guard() interface to ld.so.1 */
int ul_pad2;
char ul_td_events_enable; /* event mechanism enabled */
char ul_sync_obj_reg; /* tdb_sync_obj_register() */
char ul_qtype; /* MX or CV */
char ul_cv_wake; /* != 0: just wake up, don't requeue */
int ul_usropts; /* flags given to thr_create() */
void *(*ul_startpc)(void *); /* start func (thr_create()) */
void *ul_startarg; /* argument for start function */
void *ul_wchan; /* synch object when sleeping */
/* 0 means there is but a single lock */
union { /* single rwlock or pointer to array */
} ul_readlock;
/* PROBE_SUPPORT begin */
void *ul_tpdp;
/* PROBE_SUPPORT end */
/* the following members *must* be last in the structure */
/* they are discarded when ulwp is replaced on thr_exit() */
void *ul_ex_unwind; /* address of _ex_unwind() or -1 */
#if defined(sparc)
void *ul_unwind_ret; /* used only by _ex_clnup_handler() */
#endif
} ulwp_t;
/*
* This is the size of a replacement ulwp, retained only for the benefit
* of thr_join(). The trailing members are unneeded for this purpose.
*/
/*
* Definitions for static initialization of signal sets,
* plus some sneaky optimizations in various places.
*/
#define FILLSET0 0xffffffffu
#else
#error "fix me: MAXSIG out of bounds"
#endif
#define CANTMASK1 0
extern int thread_adaptive_spin;
extern uint_t thread_max_spinners;
extern int thread_release_spin;
extern int thread_queue_spin;
extern int thread_queue_fifo;
extern int thread_queue_dump;
extern int thread_cond_wait_defer;
extern int thread_async_safe;
extern int thread_queue_verify;
/*
* pthread_atfork() related data, used to store atfork handlers.
*/
typedef struct atfork {
void (*prepare)(void); /* pre-fork handler */
void (*parent)(void); /* post-fork parent handler */
void (*child)(void); /* post-fork child handler */
} atfork_t;
/*
* Make our hot locks reside on private cache lines (64 bytes).
* pad_cond, pad_owner, and pad_count (aka fork_cond, fork_owner,
* and fork_count for _fork_lock) are used only in fork_lock_enter()
* to implement the special form of mutual exclusion therein.
*/
typedef struct {
} pad_lock_t;
/*
* The threads hash table is used for fast lookup and locking of an active
* thread structure (ulwp_t) given a thread-id. It is an N-element array of
* thr_hash_table_t structures, where N == 1 before the main thread creates
* the first additional thread and N == 1024 afterwards. Each element of the
* table is 64 bytes in size and alignment to reduce cache conflicts.
*/
typedef struct {
#ifdef _SYSCALL32
typedef struct {
char hash_pad[64 -
#endif /* _SYSCALL32 */
/*
* siguaction members have 64-byte size and alignment.
* We know that sizeof (struct sigaction) is 32 bytes for
* both _ILP32 and _LP64, so we put the padding in the middle.
*/
typedef struct {
struct sigaction sig_uaction;
} siguaction_t;
#ifdef _SYSCALL32
typedef struct {
struct sigaction32 sig_uaction;
#endif /* _SYSCALL32 */
/*
* Bucket structures, used by lmalloc()/lfree().
* A bucket's size and alignment is 64 bytes.
*/
typedef struct {
} bucket_t;
#ifdef _SYSCALL32
typedef struct {
} bucket32_t;
#endif /* _SYSCALL32 */
/*
* atexit() data structures.
*/
typedef void (*_exithdlr_func_t) (void);
typedef struct _exthdlr {
} _exthdlr_t;
typedef struct {
void *exit_frame_monitor;
(sizeof (mutex_t) + sizeof (_exthdlr_t *) + sizeof (void *))];
#ifdef _SYSCALL32
typedef struct {
#endif /* _SYSCALL32 */
/*
* This is data that is global to all link maps (uberdata, aka super-global).
*/
typedef struct uberdata {
/*
* Every object before this point has size and alignment of 64 bytes.
* Don't add any other type of data before this point.
*/
char primary_map; /* set when primary link map is initialized */
char bucket_init; /* set when bucket[NBUCKETS] is initialized */
char pad[2];
int nzombies; /* total number of zombie threads */
void (*sigacthandler)(int, siginfo_t *, void *);
int nfreestack;
int thread_stack_cache;
struct uberdata **tdb_bootstrap;
} uberdata_t;
extern uberdata_t __uberdata;
extern int primary_link_map;
/*
* Grab and release the hash table lock for the specified lwp.
*/
#ifdef _SYSCALL32 /* needed by libc_db */
typedef struct ulwp32 {
#if defined(__sparc)
#endif
#if defined(__x86)
#endif
int ul_ix; /* hash index */
char ul_policy; /* scheduling policy */
char ul_pri_mapped; /* != 0 means ul_mappedpri is valid */
union {
struct {
char cursig; /* deferred signal number */
char pleasestop; /* lwp requested to stop itself */
} s;
short curplease; /* for testing both at once */
} ul_cp;
char ul_stop; /* reason for stopping */
char ul_signalled; /* this lwp was cond_signal()d */
char ul_dead; /* this lwp has called thr_exit */
char ul_unwind; /* posix: unwind C++ stack */
char ul_detached; /* THR_DETACHED at thread_create() */
/* or pthread_detach() was called */
char ul_writer; /* sleeping in rw_wrlock() */
char ul_stopping; /* set by curthread: stopping self */
char ul_cancel_prologue; /* for _cancel_prologue() */
short ul_preempt; /* no_preempt()/preempt() */
short ul_savpreempt; /* pre-existing preempt value */
char ul_sigsuspend; /* thread is in sigsuspend/pollsys */
char ul_main; /* thread is the main thread */
char ul_fork; /* thread is performing a fork */
char ul_primarymap; /* primary link-map is initialized */
/* per-thread copies of the corresponding global variables */
char ul_door_noreserve; /* thread_door_noreserve */
char ul_queue_fifo; /* thread_queue_fifo */
char ul_cond_wait_defer; /* thread_cond_wait_defer */
char ul_error_detection; /* thread_error_detection */
char ul_async_safe; /* thread_async_safe */
char ul_pad1[2];
int ul_adaptive_spin; /* thread_adaptive_spin */
int ul_release_spin; /* thread_release_spin */
int ul_queue_spin; /* thread_queue_spin */
int ul_critical; /* non-zero == in a critical region */
int ul_sigdefer; /* non-zero == defer signals */
int ul_vfork; /* thread is the child of vfork() */
int ul_cancelable; /* _cancelon()/_canceloff() */
char ul_cancel_pending; /* pthread_cancel() was called */
char ul_cancel_disabled; /* PTHREAD_CANCEL_DISABLE */
char ul_cancel_async; /* PTHREAD_CANCEL_ASYNCHRONOUS */
char ul_save_async; /* saved copy of ul_cancel_async */
char ul_mutator; /* lwp is a mutator (java interface) */
char ul_created; /* created suspended */
char ul_replace; /* replacement; must be free()d */
int ul_errno; /* per-thread errno */
int ul_bindflags; /* bind_guard() interface to ld.so.1 */
int ul_pad2;
char ul_td_events_enable; /* event mechanism enabled */
char ul_sync_obj_reg; /* tdb_sync_obj_register() */
char ul_qtype; /* MX or CV */
char ul_cv_wake; /* != 0: just wake up, don't requeue */
int ul_usropts; /* flags given to thr_create() */
/* 0 means there is but a single lock */
union { /* single rwlock or pointer to array */
} ul_readlock;
/* PROBE_SUPPORT begin */
/* PROBE_SUPPORT end */
/* the following members *must* be last in the structure */
/* they are discarded when ulwp is replaced on thr_exit() */
#if defined(sparc)
#endif
} ulwp32_t;
typedef struct uberdata32 {
char primary_map;
char bucket_init;
char pad[2];
int nthreads;
int nzombies;
int ndaemons;
int pid;
int nfreestack;
int thread_stack_cache;
} uberdata32_t;
#endif /* _SYSCALL32 */
/* ul_stop values */
/*
* Implementation-specific attribute types for pthread_mutexattr_init() etc.
*/
typedef struct _cvattr {
int pshared;
} cvattr_t;
typedef struct _mattr {
int pshared;
int protocol;
int prioceiling;
int type;
int robustness;
} mattr_t;
typedef struct _thrattr {
void *stkaddr;
int detachstate;
int daemonstate;
int scope;
int prio;
int policy;
int inherit;
} thrattr_t;
typedef struct _rwlattr {
int pshared;
} rwlattr_t;
/* _curthread() is inline for speed */
extern ulwp_t *_curthread(void);
#define curthread (_curthread())
/* this version (also inline) can be tested for NULL */
extern ulwp_t *__curthread(void);
/* get the current stack pointer (also inline) */
/*
* Suppress __attribute__((...)) if we are not compiling with gcc
*/
#if !defined(__GNUC__)
#define __attribute__(string)
#endif
/*
* Implementation functions. Not visible outside of the library itself.
*/
extern void thr_panic(const char *);
#pragma rarely_called(thr_panic)
extern int real_priority(ulwp_t *);
extern void finish_init(void);
extern void queue_alloc(void);
extern void tsd_exit(void);
extern void tls_setup(void);
extern void tls_exit(void);
extern void sigacthandler(int, siginfo_t *, void *);
extern void signal_init(void);
extern void mutex_setup(void);
extern void take_deferred_signal(int);
extern volatile sc_shared_t *setup_schedctl(void);
extern void *libc_malloc(size_t);
extern void *libc_realloc(void *, size_t);
extern void libc_free(void *);
extern char *libc_strdup(const char *);
extern void lock_error(const mutex_t *, const char *, void *, const char *);
extern void rwlock_error(const rwlock_t *, const char *, const char *);
extern void thread_error(const char *);
extern void grab_assert_lock(void);
extern void dump_queue_statistics(void);
extern void collect_queue_statistics(void);
extern void record_spin_locks(ulwp_t *);
#if defined(__sparc)
extern void _flush_windows(void);
#else
#define _flush_windows()
#endif
extern void set_curthread(void *);
/* enter a critical section */
/* exit a critical section, take deferred actions if necessary */
extern void do_exit_critical(void);
#define exit_critical(self) \
(void) (self->ul_critical--, \
(do_exit_critical(), 0) : 0))
/*
* Like enter_critical()/exit_critical() but just for deferring signals.
* Unlike enter_critical()/exit_critical(), ul_sigdefer may be set while
* calling application functions like constructors and destructors.
* Care must be taken if the application function attempts to set
* the signal mask while a deferred signal is present; the setting
* of the signal mask must also be deferred.
*/
/* these are exported functions */
extern void _sigoff(void);
extern void _sigon(void);
#define delete_reserved_signals(s) \
((s)->__sigbits[2] = 0), \
((s)->__sigbits[3] = 0))
/*
* When restoring the signal mask after having previously called
* block_all_signals(), if we have a deferred signal present then
* do nothing other than ASSERT() that we are in a critical region.
* The signal mask will be set when we emerge from the critical region
* and call take_deferred_signal(). There is no race condition here
* because the kernel currently has all signals blocked for this thread.
*/
#define restore_signals(self) \
extern void set_parking_flag(ulwp_t *, int);
extern void *_thr_setup(ulwp_t *);
extern void _fpinherit(ulwp_t *);
extern void _lwp_start(void);
extern void _lwp_terminate(void);
extern void lmutex_lock(mutex_t *);
extern void lmutex_unlock(mutex_t *);
extern void sig_mutex_lock(mutex_t *);
extern void sig_mutex_unlock(mutex_t *);
extern int sig_mutex_trylock(mutex_t *);
extern void _prefork_handler(void);
extern void _postfork_parent_handler(void);
extern void _postfork_child_handler(void);
extern void postfork1_child(void);
extern void postfork1_child_aio(void);
extern void postfork1_child_sigev_aio(void);
extern void postfork1_child_sigev_mq(void);
extern void postfork1_child_sigev_timer(void);
extern void postfork1_child_tpool(void);
extern int fork_lock_enter(const char *);
extern void fork_lock_exit(void);
extern void suspend_fork(void);
extern void continue_fork(int);
extern void do_sigcancel(void);
extern void setup_cancelsig(int);
extern void init_sigev_thread(void);
extern void init_aio(void);
extern void _cancelon(void);
extern void _canceloff(void);
extern void _canceloff_nocancel(void);
extern void _cancel_prologue(void);
extern void _cancel_epilogue(void);
extern void no_preempt(ulwp_t *);
extern void _thrp_unwind(void *);
/*
* Prototypes for the strong versions of the interface functions
*/
extern pid_t __forkallx(int);
extern pid_t _private_getpid(void);
extern uid_t _private_geteuid(void);
extern int _open(const char *, int, ...);
extern int _close(int);
extern void *_private_memcpy(void *, const void *, size_t);
extern void *_private_memset(void *, int, size_t);
extern int _private_sigfillset(sigset_t *);
extern int _private_sigemptyset(sigset_t *);
extern int _private_sigaddset(sigset_t *, int);
extern int _private_sigdelset(sigset_t *, int);
extern int _private_sigismember(sigset_t *, int);
extern int _private_mprotect(void *, size_t, int);
extern int _private_munmap(void *, size_t);
extern int _private_getrlimit(int, struct rlimit *);
extern int __lwp_continue(lwpid_t);
extern int __lwp_kill(lwpid_t, int);
extern lwpid_t __lwp_self(void);
extern int ___lwp_suspend(lwpid_t);
extern void lwp_yield(void);
extern int __lwp_detach(lwpid_t);
extern sc_shared_t *__schedctl(void);
extern int _private_setcontext(const ucontext_t *);
extern int _private_getcontext(ucontext_t *);
#pragma unknown_control_flow(_private_getcontext)
/* actual system call traps */
extern int __setcontext_syscall(const ucontext_t *);
extern int __getcontext_syscall(ucontext_t *);
extern int _private_setustack(stack_t *);
extern caddr_t __sighndlrend;
#pragma unknown_control_flow(__sighndlr)
extern void _siglongjmp(sigjmp_buf, int);
extern int _pthread_setspecific(pthread_key_t, const void *);
extern void *_pthread_getspecific(pthread_key_t);
extern void _pthread_exit(void *);
extern void _private_testcancel(void);
/* belongs in <pthread.h> */
#define PTHREAD_CREATE_NONDAEMON_NP 0
extern int _pthread_attr_setdaemonstate_np(pthread_attr_t *, int);
extern int _pthread_attr_getdaemonstate_np(const pthread_attr_t *, int *);
/* these are private to the library */
extern int _private_mutex_init(mutex_t *, int, void *);
extern int _private_mutex_destroy(mutex_t *);
extern int _private_mutex_lock(mutex_t *);
extern int _private_mutex_trylock(mutex_t *);
extern int _private_mutex_unlock(mutex_t *);
extern int _mutex_init(mutex_t *, int, void *);
extern int _mutex_destroy(mutex_t *);
extern int _mutex_lock(mutex_t *);
extern int _mutex_trylock(mutex_t *);
extern int _mutex_unlock(mutex_t *);
extern void _mutex_set_typeattr(mutex_t *, int);
extern int __mutex_init(mutex_t *, int, void *);
extern int __mutex_destroy(mutex_t *);
extern int __mutex_lock(mutex_t *);
extern int __mutex_trylock(mutex_t *);
extern int __mutex_unlock(mutex_t *);
extern int mutex_is_held(mutex_t *);
extern int mutex_trylock_adaptive(mutex_t *);
extern int mutex_queuelock_adaptive(mutex_t *);
extern int _cond_init(cond_t *, int, void *);
extern int _cond_signal(cond_t *);
extern int _cond_broadcast(cond_t *);
extern int _cond_destroy(cond_t *);
extern int cond_signal_internal(cond_t *);
extern int cond_broadcast_internal(cond_t *);
extern int __rwlock_init(rwlock_t *, int, void *);
extern int rw_read_is_held(rwlock_t *);
extern int rw_write_is_held(rwlock_t *);
extern int _thr_continue(thread_t);
extern int _thr_create(void *, size_t, void *(*)(void *), void *, long,
thread_t *);
extern int _thrp_create(void *, size_t, void *(*)(void *), void *, long,
extern int _thr_getprio(thread_t, int *);
extern int _thr_getspecific(thread_key_t, void **);
extern int _thr_key_delete(thread_key_t);
extern int _thr_main(void);
extern int _thr_getconcurrency(void);
extern int _thr_setconcurrency(int);
extern int _thr_setprio(thread_t, int);
extern int _thr_setspecific(thread_key_t, void *);
extern int _thr_stksegment(stack_t *);
extern void _thr_terminate(void *);
extern void _thr_exit(void *);
extern void _thrp_exit(void);
extern const thrattr_t *def_thrattr(void);
extern int _thread_setschedparam_main(pthread_t, int,
const struct sched_param *, int);
extern int _validate_rt_prio(int, int);
extern int _thrp_setlwpprio(lwpid_t, int, int);
extern int get_info_by_policy(int);
/*
* System call wrappers (direct interfaces to the kernel)
*/
extern int ___lwp_mutex_init(mutex_t *, int);
extern int ___lwp_mutex_trylock(mutex_t *);
extern int ___lwp_mutex_unlock(mutex_t *);
extern int ___lwp_mutex_wakeup(mutex_t *);
extern int __lwp_cond_signal(lwp_cond_t *);
extern int __lwp_cond_broadcast(lwp_cond_t *);
extern int __lwp_sema_trywait(lwp_sema_t *);
extern int __lwp_sema_post(lwp_sema_t *);
extern int __lwp_rwlock_tryrdlock(rwlock_t *);
extern int __lwp_rwlock_trywrlock(rwlock_t *);
extern int __lwp_rwlock_unlock(rwlock_t *);
extern int __lwp_unpark(lwpid_t);
extern int __lwp_unpark_all(lwpid_t *, int);
#if defined(__x86)
extern int ___lwp_private(int, int, void *);
#endif /* __x86 */
extern int _private_lwp_mutex_lock(mutex_t *);
extern int _private_lwp_mutex_unlock(mutex_t *);
/*
* inlines
*/
extern int set_lock_byte(volatile uint8_t *);
#if defined(__sparc)
#endif /* __sparc */
#include "thr_inlines.h"
#endif /* _THR_UBERDATA_H */