Home | History | Annotate | Line # | Download | only in libpthread
pthread_int.h revision 1.56
      1 /*	$NetBSD: pthread_int.h,v 1.56 2007/09/24 12:19:39 skrll Exp $	*/
      2 
      3 /*-
      4  * Copyright (c) 2001, 2002, 2003, 2006, 2007 The NetBSD Foundation, Inc.
      5  * All rights reserved.
      6  *
      7  * This code is derived from software contributed to The NetBSD Foundation
      8  * by Nathan J. Williams and Andrew Doran.
      9  *
     10  * Redistribution and use in source and binary forms, with or without
     11  * modification, are permitted provided that the following conditions
     12  * are met:
     13  * 1. Redistributions of source code must retain the above copyright
     14  *    notice, this list of conditions and the following disclaimer.
     15  * 2. Redistributions in binary form must reproduce the above copyright
     16  *    notice, this list of conditions and the following disclaimer in the
     17  *    documentation and/or other materials provided with the distribution.
     18  * 3. All advertising materials mentioning features or use of this software
     19  *    must display the following acknowledgement:
     20  *        This product includes software developed by the NetBSD
     21  *        Foundation, Inc. and its contributors.
     22  * 4. Neither the name of The NetBSD Foundation nor the names of its
     23  *    contributors may be used to endorse or promote products derived
     24  *    from this software without specific prior written permission.
     25  *
     26  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
     27  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
     28  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     29  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
     30  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     31  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     32  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     33  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     34  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     35  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
     36  * POSSIBILITY OF SUCH DAMAGE.
     37  */
     38 
     39 #ifndef _LIB_PTHREAD_INT_H
     40 #define _LIB_PTHREAD_INT_H
     41 
     42 /* #define PTHREAD__DEBUG */
     43 #define ERRORCHECK
     44 
     45 #include "pthread_types.h"
     46 #include "pthread_queue.h"
     47 #include "pthread_debug.h"
     48 #include "pthread_md.h"
     49 
     50 #include <lwp.h>
     51 #include <signal.h>
     52 
     53 #define PTHREAD_KEYS_MAX 	256
     54 #define	PTHREAD__UNPARK_MAX	32
     55 
     56 /*
     57  * The size of this structure needs to be no larger than struct
     58  * __pthread_cleanup_store, defined in pthread.h.
     59  */
     60 struct pt_clean_t {
     61 	PTQ_ENTRY(pt_clean_t)	ptc_next;
     62 	void	(*ptc_cleanup)(void *);
     63 	void	*ptc_arg;
     64 };
     65 
     66 /* Private data for pthread_attr_t */
     67 struct pthread_attr_private {
     68 	char ptap_name[PTHREAD_MAX_NAMELEN_NP];
     69 	void *ptap_namearg;
     70 	void *ptap_stackaddr;
     71 	size_t ptap_stacksize;
     72 	size_t ptap_guardsize;
     73 };
     74 
     75 struct	__pthread_st {
     76 	unsigned int	pt_magic;	/* Magic number */
     77 	int		pt_num;		/* ID XXX should die */
     78 	int		pt_state;	/* running, blocked, etc. */
     79 	pthread_mutex_t	pt_lock;	/* lock on state */
     80 	int		pt_flags;	/* see PT_FLAG_* below */
     81 	int		pt_cancel;	/* Deferred cancellation */
     82 	int		pt_spinlocks;	/* Number of spinlocks held. */
     83 	int		pt_errno;	/* Thread-specific errno. */
     84 	stack_t		pt_stack;	/* Our stack */
     85 	void		*pt_exitval;	/* Read by pthread_join() */
     86 	char		*pt_name;	/* Thread's name, set by the app. */
     87 	int		pt_willpark;	/* About to park */
     88 	lwpid_t		pt_unpark;	/* Unpark this when parking */
     89 	void		*pt_unparkhint;	/* Hint for the above */
     90 
     91 	/* Threads to defer waking, usually until pthread_mutex_unlock(). */
     92 	lwpid_t		pt_waiters[PTHREAD__UNPARK_MAX];
     93 	size_t		pt_nwaiters;
     94 
     95 	/* Stack of cancellation cleanup handlers and their arguments */
     96 	PTQ_HEAD(, pt_clean_t)	pt_cleanup_stack;
     97 
     98 	/* For debugger: LWPs waiting to join. */
     99 	pthread_queue_t	pt_joiners;
    100 	PTQ_ENTRY(__pthread_st) pt_joinq;
    101 
    102 	/* LWP ID and entry on the list of all threads. */
    103 	lwpid_t		pt_lid;
    104 	PTQ_ENTRY(__pthread_st)	pt_allq;
    105 	PTQ_ENTRY(__pthread_st)	pt_deadq;
    106 
    107 	/*
    108 	 * General synchronization data.  We try to align, as threads
    109 	 * on other CPUs will access this data frequently.
    110 	 */
    111 	int		pt_dummy1 __aligned(128);
    112 	volatile int	pt_rwlocked;	/* Handed rwlock successfully */
    113 	volatile int	pt_sleeponq;	/* On a sleep queue */
    114 	volatile int	pt_signalled;	/* Received pthread_cond_signal() */
    115 	void * volatile	pt_sleepobj;	/* Object slept on */
    116 	PTQ_ENTRY(__pthread_st) pt_sleep;
    117 	void		(*pt_early)(void *);
    118 	int		pt_dummy2 __aligned(128);
    119 
    120 	/* Thread-specific data.  Large so it sits close to the end. */
    121 	int		pt_havespecific;
    122 	void		*pt_specific[PTHREAD_KEYS_MAX];
    123 
    124 	/*
    125 	 * Context for thread creation.  At the end as it's cached
    126 	 * and then only ever passed to _lwp_create().
    127 	 */
    128 	ucontext_t	pt_uc;
    129 };
    130 
    131 struct pthread_lock_ops {
    132 	void	(*plo_init)(__cpu_simple_lock_t *);
    133 	int	(*plo_try)(__cpu_simple_lock_t *);
    134 	void	(*plo_unlock)(__cpu_simple_lock_t *);
    135 };
    136 
    137 /* Thread states */
    138 #define PT_STATE_RUNNING	1
    139 #define PT_STATE_ZOMBIE		5
    140 #define PT_STATE_DEAD		6
    141 
    142 /* Flag values */
    143 
    144 #define PT_FLAG_DETACHED	0x0001
    145 #define PT_FLAG_CS_DISABLED	0x0004	/* Cancellation disabled */
    146 #define PT_FLAG_CS_ASYNC	0x0008  /* Cancellation is async */
    147 #define PT_FLAG_CS_PENDING	0x0010
    148 #define PT_FLAG_SCOPE_SYSTEM	0x0040
    149 #define PT_FLAG_EXPLICIT_SCHED	0x0080
    150 #define PT_FLAG_SUSPENDED	0x0100	/* In the suspended queue */
    151 
    152 #define PT_MAGIC	0x11110001
    153 #define PT_DEAD		0xDEAD0001
    154 
    155 #define PT_ATTR_MAGIC	0x22220002
    156 #define PT_ATTR_DEAD	0xDEAD0002
    157 
    158 extern int	pthread__stacksize_lg;
    159 extern size_t	pthread__stacksize;
    160 extern vaddr_t	pthread__stackmask;
    161 extern vaddr_t	pthread__threadmask;
    162 extern int	pthread__nspins;
    163 extern int	pthread__concurrency;
    164 extern int 	pthread__osrev;
    165 extern int 	pthread__unpark_max;
    166 
    167 /* Flag to be used in a ucontext_t's uc_flags indicating that
    168  * the saved register state is "user" state only, not full
    169  * trap state.
    170  */
    171 #define _UC_USER_BIT		30
    172 #define _UC_USER		(1LU << _UC_USER_BIT)
    173 
    174 void	pthread_init(void)  __attribute__ ((__constructor__));
    175 
    176 /* Utility functions */
    177 void	pthread__unpark_all(pthread_t self, pthread_spin_t *lock,
    178 			    pthread_queue_t *threadq);
    179 void	pthread__unpark(pthread_t self, pthread_spin_t *lock,
    180 			pthread_queue_t *queue, pthread_t target);
    181 int	pthread__park(pthread_t self, pthread_spin_t *lock,
    182 		      pthread_queue_t *threadq,
    183 		      const struct timespec *abs_timeout,
    184 		      int cancelpt, const void *hint);
    185 
    186 /* Internal locking primitives */
    187 void	pthread__lockprim_init(void);
    188 void	pthread_lockinit(pthread_spin_t *);
    189 void	pthread_spinlock(pthread_spin_t *);
    190 int	pthread_spintrylock(pthread_spin_t *);
    191 void	pthread_spinunlock(pthread_spin_t *);
    192 
    193 extern const struct pthread_lock_ops *pthread__lock_ops;
    194 
    195 int	pthread__simple_locked_p(__cpu_simple_lock_t *);
    196 #define	pthread__simple_lock_init(alp)	(*pthread__lock_ops->plo_init)(alp)
    197 #define	pthread__simple_lock_try(alp)	(*pthread__lock_ops->plo_try)(alp)
    198 #define	pthread__simple_unlock(alp)	(*pthread__lock_ops->plo_unlock)(alp)
    199 
    200 #ifndef _getcontext_u
    201 int	_getcontext_u(ucontext_t *);
    202 #endif
    203 #ifndef _setcontext_u
    204 int	_setcontext_u(const ucontext_t *);
    205 #endif
    206 #ifndef _swapcontext_u
    207 int	_swapcontext_u(ucontext_t *, const ucontext_t *);
    208 #endif
    209 
    210 void	pthread__testcancel(pthread_t);
    211 int	pthread__find(pthread_t);
    212 
    213 #ifndef PTHREAD_MD_INIT
    214 #define PTHREAD_MD_INIT
    215 #endif
    216 
    217 #ifndef _INITCONTEXT_U_MD
    218 #define _INITCONTEXT_U_MD(ucp)
    219 #endif
    220 
    221 #define _INITCONTEXT_U(ucp) do {					\
    222 	(ucp)->uc_flags = _UC_CPU | _UC_STACK;				\
    223 	_INITCONTEXT_U_MD(ucp)						\
    224 	} while (/*CONSTCOND*/0)
    225 
    226 #ifdef PTHREAD_MACHINE_HAS_ID_REGISTER
    227 #define pthread__id(reg) (reg)
    228 #else
    229 /* Stack location of pointer to a particular thread */
    230 #define pthread__id(sp) \
    231 	((pthread_t) (((vaddr_t)(sp)) & pthread__threadmask))
    232 
    233 #define pthread__id_reg() pthread__sp()
    234 #endif
    235 
    236 #define pthread__self() (pthread__id(pthread__id_reg()))
    237 
    238 #define pthread__abort()						\
    239 	pthread__assertfunc(__FILE__, __LINE__, __func__, "unreachable")
    240 
    241 #define pthread__assert(e) do {						\
    242 	if (__predict_false(!(e)))					\
    243        	       pthread__assertfunc(__FILE__, __LINE__, __func__, #e);	\
    244         } while (/*CONSTCOND*/0)
    245 
    246 #define pthread__error(err, msg, e) do {				\
    247 	if (__predict_false(!(e))) {					\
    248        	       pthread__errorfunc(__FILE__, __LINE__, __func__, msg);	\
    249 	       return (err);						\
    250 	} 								\
    251         } while (/*CONSTCOND*/0)
    252 
    253 void	pthread__destroy_tsd(pthread_t self);
    254 void	pthread__assertfunc(const char *file, int line, const char *function,
    255 		const char *expr);
    256 void	pthread__errorfunc(const char *file, int line, const char *function,
    257 		const char *msg);
    258 
    259 int	pthread__atomic_cas_ptr(volatile void *, void **, void *);
    260 void	*pthread__atomic_swap_ptr(volatile void *, void *);
    261 void	pthread__membar_full(void);
    262 void	pthread__membar_producer(void);
    263 void	pthread__membar_consumer(void);
    264 
    265 int	pthread__mutex_deferwake(pthread_t, pthread_mutex_t *);
    266 int	pthread__mutex_catchup(pthread_mutex_t *);
    267 
    268 #ifndef pthread__smt_pause
    269 #define	pthread__smt_pause()	/* nothing */
    270 #endif
    271 
    272 /*
    273  * Bits in the owner field of the lock that indicate lock state.  If the
    274  * WRITE_LOCKED bit is clear, then the owner field is actually a count of
    275  * the number of readers.
    276  */
    277 #define	RW_HAS_WAITERS		0x01	/* lock has waiters */
    278 #define	RW_WRITE_WANTED		0x02	/* >= 1 waiter is a writer */
    279 #define	RW_WRITE_LOCKED		0x04	/* lock is currently write locked */
    280 #define	RW_UNUSED		0x08	/* currently unused */
    281 
    282 #define	RW_FLAGMASK		0x0f
    283 
    284 #define	RW_READ_COUNT_SHIFT	4
    285 #define	RW_READ_INCR		(1 << RW_READ_COUNT_SHIFT)
    286 #define	RW_THREAD		((uintptr_t)-RW_READ_INCR)
    287 #define	RW_OWNER(rw)		((rw)->rw_owner & RW_THREAD)
    288 #define	RW_COUNT(rw)		((rw)->rw_owner & RW_THREAD)
    289 #define	RW_FLAGS(rw)		((rw)->rw_owner & ~RW_THREAD)
    290 
    291 #define	ptr_owner		ptr_writer
    292 
    293 #endif /* _LIB_PTHREAD_INT_H */
    294