xref: /netbsd-src/lib/libpthread/pthread_int.h (revision da5f4674a3fc214be3572d358b66af40ab9401e7)
1 /*	$NetBSD: pthread_int.h,v 1.17 2003/07/21 22:21:07 nathanw Exp $	*/
2 
3 /*-
4  * Copyright (c) 2001,2002,2003 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.
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 <sa.h>
51 #include <signal.h>
52 
53 #define PTHREAD_KEYS_MAX 256
54 /*
55  * The size of this structure needs to be no larger than struct
56  * __pthread_cleanup_store, defined in pthread.h.
57  */
58 struct pt_clean_t {
59 	PTQ_ENTRY(pt_clean_t)	ptc_next;
60 	void	(*ptc_cleanup)(void *);
61 	void	*ptc_arg;
62 };
63 
64 struct pt_alarm_t {
65 	PTQ_ENTRY(pt_alarm_t)	pta_next;
66 	pthread_spin_t	pta_lock;
67 	const struct timespec	*pta_time;
68 	void	(*pta_func)(void *);
69 	void	*pta_arg;
70 	int	pta_fired;
71 };
72 
73 /* Private data for pthread_attr_t */
74 struct pthread_attr_private {
75 	char ptap_name[PTHREAD_MAX_NAMELEN_NP];
76 	void *ptap_namearg;
77 	void *ptap_stackaddr;
78 	size_t ptap_stacksize;
79 	size_t ptap_guardsize;
80 };
81 
82 struct	__pthread_st {
83 	unsigned int	pt_magic;
84 	/* Identifier, for debugging and for preventing recycling. */
85 	int		pt_num;
86 
87 	int	pt_type;	/* normal, upcall, or idle */
88 	int	pt_state;	/* running, blocked, etc. */
89 	pthread_spin_t pt_statelock;	/* lock on pt_state */
90 	int	pt_flags;	/* see PT_FLAG_* below */
91 	pthread_spin_t pt_flaglock;	/* lock on pt_flag */
92 	int	pt_cancel;	/* Deferred cancellation */
93 	int	pt_spinlocks;	/* Number of spinlocks held. */
94 	int	pt_blockedlwp;	/* LWP/SA number when blocked */
95 
96 	int	pt_errno;	/* Thread-specific errno. */
97 
98 	/* Entry on the run queue */
99 	PTQ_ENTRY(__pthread_st)	pt_runq;
100 	/* Entry on the list of all threads */
101 	PTQ_ENTRY(__pthread_st)	pt_allq;
102 	/* Entry on the sleep queue (xxx should be same as run queue?) */
103 	PTQ_ENTRY(__pthread_st)	pt_sleep;
104 	/* Object we're sleeping on */
105 	void			*pt_sleepobj;
106 	/* Queue we're sleeping on */
107 	struct pthread_queue_t	*pt_sleepq;
108 	/* Lock protecting that queue */
109 	pthread_spin_t		*pt_sleeplock;
110 
111 	stack_t		pt_stack;	/* Our stack */
112 	ucontext_t	*pt_uc;		/* Saved context when we're stopped */
113 	ucontext_t	*pt_trapuc;   	/* Kernel-saved context */
114 
115 	sigset_t	pt_sigmask;	/* Signals we won't take. */
116 	sigset_t	pt_siglist;	/* Signals pending for us. */
117 	sigset_t	pt_sigblocked;	/* Signals delivered while blocked. */
118 	sigset_t	*pt_sigwait;	/* Signals waited for in sigwait */
119 	siginfo_t	*pt_wsig;
120 	pthread_spin_t	pt_siglock;	/* Lock on above */
121 
122 	void *		pt_exitval;	/* Read by pthread_join() */
123 
124 	/* Stack of cancellation cleanup handlers and their arguments */
125 	PTQ_HEAD(, pt_clean_t)	pt_cleanup_stack;
126 
127 	/* Thread's name, set by the application. */
128 	char*		pt_name;
129 
130 	/* Other threads trying to pthread_join() us. */
131 	struct pthread_queue_t	pt_joiners;
132 	/* Lock for above, and for changing pt_state to ZOMBIE or DEAD,
133 	 * and for setting the DETACHED flag.  Also protects pt_name.
134 	 */
135 	pthread_spin_t	pt_join_lock;
136 
137 	/* Thread we were going to switch to before we were preempted
138 	 * ourselves. Will be used by the upcall that's continuing us.
139 	 */
140 	pthread_t	pt_switchto;
141 	ucontext_t*	pt_switchtouc;
142 
143 	/* Threads that are preempted with spinlocks held will be
144 	 * continued until they unlock their spinlock. When they do
145 	 * so, they should jump ship to the thread pointed to by
146 	 * pt_next.
147 	 */
148 	pthread_t	pt_next;
149 
150 	/* The upcall that is continuing this thread */
151 	pthread_t	pt_parent;
152 
153 	/* A queue lock that this thread held while trying to
154 	 * context switch to another process.
155 	 */
156 	pthread_spin_t*	pt_heldlock;
157 
158 	/* Thread-specific data */
159 	void*		pt_specific[PTHREAD_KEYS_MAX];
160 
161 #ifdef PTHREAD__DEBUG
162 	int	blocks;
163 	int	preempts;
164 	int	rescheds;
165 #endif
166 };
167 
168 struct pthread_lock_ops {
169 	void	(*plo_init)(__cpu_simple_lock_t *);
170 	int	(*plo_try)(__cpu_simple_lock_t *);
171 	void	(*plo_unlock)(__cpu_simple_lock_t *);
172 };
173 
174 /* Thread types */
175 #define PT_THREAD_NORMAL	1
176 #define PT_THREAD_UPCALL	2
177 #define PT_THREAD_IDLE		3
178 
179 /* Thread states */
180 #define PT_STATE_RUNNING	1
181 #define PT_STATE_RUNNABLE	2
182 #define PT_STATE_BLOCKED_SYS	3
183 #define PT_STATE_BLOCKED_QUEUE	4
184 #define PT_STATE_ZOMBIE		5
185 #define PT_STATE_DEAD		6
186 #define PT_STATE_RECYCLABLE	7
187 
188 /* Flag values */
189 
190 #define PT_FLAG_DETACHED	0x0001
191 #define PT_FLAG_IDLED		0x0002
192 #define PT_FLAG_CS_DISABLED	0x0004	/* Cancellation disabled */
193 #define PT_FLAG_CS_ASYNC	0x0008  /* Cancellation is async */
194 #define PT_FLAG_CS_PENDING	0x0010
195 #define PT_FLAG_SIGDEFERRED     0x0020	/* There are signals to take */
196 #define PT_FLAG_SCOPE_SYSTEM	0x0040
197 #define PT_FLAG_EXPLICIT_SCHED	0x0080
198 
199 #define PT_MAGIC	0x11110001
200 #define PT_DEAD		0xDEAD0001
201 
202 #define PT_ATTR_MAGIC	0x22220002
203 #define PT_ATTR_DEAD	0xDEAD0002
204 
205 #define PT_STACKSIZE_LG	18
206 #define PT_STACKSIZE	(1<<(PT_STACKSIZE_LG))
207 #define PT_STACKMASK	(PT_STACKSIZE-1)
208 
209 #define PT_UPCALLSTACKS	16
210 
211 #define PT_ALARMTIMER_MAGIC	0x88880010
212 #define PT_RRTIMER_MAGIC	0x88880020
213 #define NIDLETHREADS	4
214 #define IDLESPINS	1000
215 
216 /* Flag to be used in a ucontext_t's uc_flags indicating that
217  * the saved register state is "user" state only, not full
218  * trap state.
219  */
220 #define _UC_USER_BIT		30
221 #define _UC_USER		(1LU << _UC_USER_BIT)
222 
223 void	pthread_init(void)  __attribute__ ((__constructor__));
224 
225 /* Utility functions */
226 
227 /* Set up/clean up a thread's basic state. */
228 void	pthread__initthread(pthread_t self, pthread_t t);
229 
230 /* Go do something else. Don't go back on the run queue */
231 void	pthread__block(pthread_t self, pthread_spin_t* queuelock);
232 /* Put a thread back on the run queue */
233 void	pthread__sched(pthread_t self, pthread_t thread);
234 void	pthread__sched_sleepers(pthread_t self, struct pthread_queue_t *threadq);
235 void	pthread__sched_idle(pthread_t self, pthread_t thread);
236 void	pthread__sched_idle2(pthread_t self);
237 
238 void	pthread__sched_bulk(pthread_t self, pthread_t qhead);
239 
240 void	pthread__idle(void);
241 
242 /* Get the next thread */
243 pthread_t pthread__next(pthread_t self);
244 
245 int	pthread__stackalloc(pthread_t *t);
246 void	pthread__initmain(pthread_t *t);
247 
248 void	pthread__sa_start(void);
249 void	pthread__sa_recycle(pthread_t old, pthread_t new);
250 
251 /* Alarm code */
252 void	pthread__alarm_init(void);
253 void	pthread__alarm_add(pthread_t, struct pt_alarm_t *,
254     const struct timespec *, void (*)(void *), void *);
255 void	pthread__alarm_del(pthread_t, struct pt_alarm_t *);
256 int	pthread__alarm_fired(struct pt_alarm_t *);
257 void	pthread__alarm_process(pthread_t self, void *arg);
258 
259 /* Internal locking primitives */
260 void	pthread__lockprim_init(void);
261 void	pthread_lockinit(pthread_spin_t *lock);
262 void	pthread_spinlock(pthread_t thread, pthread_spin_t *lock);
263 int	pthread_spintrylock(pthread_t thread, pthread_spin_t *lock);
264 void	pthread_spinunlock(pthread_t thread, pthread_spin_t *lock);
265 
266 extern const struct pthread_lock_ops *pthread__lock_ops;
267 
268 #define	pthread__simple_lock_init(alp)	(*pthread__lock_ops->plo_init)(alp)
269 #define	pthread__simple_lock_try(alp)	(*pthread__lock_ops->plo_try)(alp)
270 #define	pthread__simple_unlock(alp)	(*pthread__lock_ops->plo_unlock)(alp)
271 
272 #ifndef _getcontext_u
273 int	_getcontext_u(ucontext_t *);
274 #endif
275 #ifndef _setcontext_u
276 int	_setcontext_u(const ucontext_t *);
277 #endif
278 #ifndef _swapcontext_u
279 int	_swapcontext_u(ucontext_t *, const ucontext_t *);
280 #endif
281 
282 void	pthread__testcancel(pthread_t self);
283 int	pthread__find(pthread_t self, pthread_t target);
284 
285 #ifndef PTHREAD_MD_INIT
286 #define PTHREAD_MD_INIT
287 #endif
288 
289 #ifndef _INITCONTEXT_U_MD
290 #define _INITCONTEXT_U_MD(ucp)
291 #endif
292 
293 #define _INITCONTEXT_U(ucp) do {					\
294 	(ucp)->uc_flags = _UC_CPU | _UC_STACK;				\
295 	_INITCONTEXT_U_MD(ucp)						\
296 	} while (/*CONSTCOND*/0)
297 
298 #ifdef __PTHREAD_SIGNAL_PRIVATE
299 
300 /*
301  * Macros for converting from ucontext to sigcontext and vice-versa.
302  * Note that going from sigcontext->ucontext is only safe for a
303  * sigcontext that was first created from a ucontext.
304  *
305  * Arch-specific code can override this, if necessary.  It may also
306  * be necessary for arch-specific code to include extra info along with
307  * the sigcontext.
308  */
309 #ifndef PTHREAD_SIGCONTEXT_EXTRA
310 #define	PTHREAD_SIGCONTEXT_EXTRA
311 #endif
312 
313 struct pthread__sigcontext {
314 	struct sigcontext	psc_context;
315 	PTHREAD_SIGCONTEXT_EXTRA
316 };
317 
318 #ifndef PTHREAD_UCONTEXT_TO_SIGCONTEXT
319 #define	PTHREAD_UCONTEXT_TO_SIGCONTEXT(mask, uc, psc)			\
320 do {									\
321 	(uc)->uc_sigmask = *(mask);					\
322 	/*								\
323 	 * XXX We may want to check for _UC_USER here and do a		\
324 	 * XXX _INITCONTEXT_U_MD() and clearing _UC_USER on such	\
325 	 * XXX contexts before converting to a signcontext, thus	\
326 	 * XXX allowing signal handlers to modify the non-_UC_USER	\
327 	 * XXX registers.  Hazy territory; ignore it for now.		\
328 	 */								\
329 	_UCONTEXT_TO_SIGCONTEXT((uc), &(psc)->psc_context);		\
330 } while (/*CONSTCOND*/0)
331 
332 #define	PTHREAD_SIGCONTEXT_TO_UCONTEXT(psc, uc)				\
333 do {									\
334 	_SIGCONTEXT_TO_UCONTEXT(&(psc)->psc_context, (uc));		\
335 	(uc)->uc_flags &= ~_UC_SIGMASK;					\
336 } while (/*CONSTCOND*/0)
337 #else
338 void	pthread__ucontext_to_sigcontext(const sigset_t *, ucontext_t *,
339 	    struct pthread__sigcontext *);
340 void	pthread__sigcontext_to_ucontext(const struct pthread__sigcontext *,
341 	    ucontext_t *);
342 #endif /* PTHREAD_UCONTEXT_TO_SIGCONTEXT */
343 
344 #endif /* __PTHREAD_SIGNAL_PRIVATE */
345 
346 #ifdef PTHREAD_MACHINE_HAS_ID_REGISTER
347 #define pthread__id(reg) (reg)
348 #else
349 /* Stack location of pointer to a particular thread */
350 #define pthread__id(sp) \
351 	((pthread_t) (((vaddr_t)(sp)) & ~PT_STACKMASK))
352 
353 #define pthread__id_reg() pthread__sp()
354 #endif
355 
356 #define pthread__self() (pthread__id(pthread__id_reg()))
357 
358 #define pthread__abort()						\
359 	pthread__assertfunc(__FILE__, __LINE__, __func__, "unreachable")
360 
361 #define pthread__assert(e) do {						\
362 	if (__predict_false(!(e)))					\
363        	       pthread__assertfunc(__FILE__, __LINE__, __func__, #e);	\
364         } while (/*CONSTCOND*/0)
365 
366 #define pthread__error(err, msg, e) do {				\
367 	if (__predict_false(!(e))) {					\
368        	       pthread__errorfunc(__FILE__, __LINE__, __func__, msg);	\
369 	       return (err);						\
370 	} 								\
371         } while (/*CONSTCOND*/0)
372 
373 
374 
375 /* These three routines are defined in processor-specific code. */
376 void	pthread__upcall_switch(pthread_t self, pthread_t next);
377 void	pthread__switch(pthread_t self, pthread_t next);
378 void	pthread__locked_switch(pthread_t self, pthread_t next,
379     pthread_spin_t *lock);
380 
381 void	pthread__signal_init(void);
382 
383 void	pthread__signal(pthread_t self, pthread_t t, int sig, int code);
384 void	pthread__deliver_signal(pthread_t self, pthread_t t, int sig, int code);
385 void	pthread__signal_deferred(pthread_t self, pthread_t t);
386 
387 void	pthread__destroy_tsd(pthread_t self);
388 void	pthread__assertfunc(char *file, int line, char *function, char *expr);
389 void	pthread__errorfunc(char *file, int line, char *function, char *msg);
390 
391 #endif /* _LIB_PTHREAD_INT_H */
392