xref: /freebsd/lib/libthr/thread/thr_private.h (revision f6a4109212fd8fbabc731f07b2dd5c7e07fbec33)
1 /*
2  * Copyright (c) 1995-1998 John Birrell <jb@cimlogic.com.au>.
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  * 3. All advertising materials mentioning features or use of this software
14  *    must display the following acknowledgement:
15  *	This product includes software developed by John Birrell.
16  * 4. Neither the name of the author nor the names of any co-contributors
17  *    may be used to endorse or promote products derived from this software
18  *    without specific prior written permission.
19  *
20  * THIS SOFTWARE IS PROVIDED BY JOHN BIRRELL AND CONTRIBUTORS ``AS IS'' AND
21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
24  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
30  * SUCH DAMAGE.
31  *
32  * Private thread definitions for the uthread kernel.
33  *
34  * $FreeBSD$
35  */
36 
37 #ifndef _THR_PRIVATE_H
38 #define _THR_PRIVATE_H
39 
40 /*
41  * Evaluate the storage class specifier.
42  */
43 #ifdef GLOBAL_PTHREAD_PRIVATE
44 #define SCLASS
45 #else
46 #define SCLASS extern
47 #endif
48 
49 /*
50  * Include files.
51  */
52 #include <sys/types.h>
53 #include <sys/cdefs.h>
54 #include <sys/errno.h>
55 #include <sys/time.h>
56 #include <sys/queue.h>
57 #include <pthread_np.h>
58 #include <sched.h>
59 #include <signal.h>
60 #include <spinlock.h>
61 #include <stdio.h>
62 #include <ucontext.h>
63 #include <unistd.h>
64 #if defined(_PTHREADS_INVARIANTS)
65 #include <assert.h>
66 #endif
67 
68 #include <machine/atomic.h>
69 #include <sys/thr.h>
70 #include <sys/umtx.h>
71 
72 #if defined(_PTHREADS_INVARIANTS)
73 /*
74  * Kernel fatal error handler macro.
75  */
76 #define PANIC(string)							     \
77 	do {								     \
78 		_thread_printf(STDOUT_FILENO, (string));		     \
79 		_thread_printf(STDOUT_FILENO,				     \
80 		    "\nAbnormal termination, file: %s, line: %d\n",	     \
81 		    __FILE__, __LINE__);				     \
82 		abort();						     \
83 	} while (0)
84 
85 #define PTHREAD_ASSERT(cond, msg) do {	\
86 	if (!(cond))			\
87 		PANIC(msg);		\
88 } while (0)
89 
90 #define PTHREAD_ASSERT_NOT_IN_SYNCQ(thrd) \
91 	PTHREAD_ASSERT((((thrd)->flags & PTHREAD_FLAGS_IN_SYNCQ) == 0),	\
92 	    "Illegal call from signal handler");
93 
94 #else /* !_PTHREADS_INVARIANTS */
95 #define PANIC(string)		_thread_exit(__FILE__, __LINE__, (string))
96 #define PTHREAD_ASSERT(cond, msg)
97 #define PTHREAD_ASSERT_NOT_IN_SYNCQ(thrd)
98 #endif /* _PTHREADS_INVARIANTS */
99 
100 /* Output debug messages like this: */
101 #define stdout_debug(args...)	_thread_printf(STDOUT_FILENO, args)
102 #define stderr_debug(args...)	_thread_printf(STDOUT_FILENO, args)
103 
104 /*
105  * Currently executing thread.
106  */
107 #define	curthread	_get_curthread()
108 
109 /*
110  * Locking macros
111  */
112 #define	UMTX_LOCK(m)							\
113 	do {								\
114 		if (umtx_lock((m), curthread->thr_id) != 0)		\
115 			abort();					\
116 	} while (0)
117 
118 #define UMTX_TRYLOCK(m, r)						\
119 	do {								\
120 		(r) = umtx_trylock((m), curthread->thr_id);		\
121 		if ((r) != 0 && (r) != EBUSY)				\
122 			abort();					\
123 	} while (0)
124 
125 #define	UMTX_UNLOCK(m)							\
126 	do {								\
127 		if (umtx_unlock((m), curthread->thr_id) != 0)		\
128 			abort();					\
129 	} while (0)
130 
131 
132 /*
133  * State change macro:
134  */
135 #define PTHREAD_SET_STATE(thrd, newstate) do {				\
136 	(thrd)->state = newstate;					\
137 	(thrd)->fname = __FILE__;					\
138 	(thrd)->lineno = __LINE__;					\
139 } while (0)
140 
141 #define PTHREAD_NEW_STATE(thrd, newstate) do {				\
142 	if (newstate == PS_RUNNING) { 					\
143 		if (thr_kill(thrd->thr_id, SIGTHR))			\
144 			abort();					\
145 	}								\
146 	PTHREAD_SET_STATE(thrd, newstate);				\
147 } while (0)
148 
149 /*
150  * TailQ initialization values.
151  */
152 #define TAILQ_INITIALIZER	{ NULL, NULL }
153 
154 #define	UMTX_INITIALIZER	{ NULL }
155 
156 struct pthread_mutex_attr {
157 	enum pthread_mutextype	m_type;
158 	int			m_protocol;
159 	int			m_ceiling;
160 	long			m_flags;
161 };
162 
163 /*
164  * Static mutex initialization values.
165  */
166 
167 #define PTHREAD_MUTEXATTR_STATIC_INITIALIZER \
168 	{ PTHREAD_MUTEX_DEFAULT, PTHREAD_PRIO_NONE, 0, MUTEX_FLAGS_PRIVATE }
169 
170 #define PTHREAD_MUTEX_STATIC_INITIALIZER   \
171 	{ PTHREAD_MUTEXATTR_STATIC_INITIALIZER, UMTX_INITIALIZER, NULL,	\
172 	0, 0, TAILQ_INITIALIZER }
173 
174 union pthread_mutex_data {
175         void    *m_ptr;
176         int     m_count;
177 };
178 
179 struct pthread_mutex {
180         enum pthread_mutextype          m_type;
181         int                             m_protocol;
182         TAILQ_HEAD(mutex_head, pthread) m_queue;
183         struct pthread                  *m_owner;
184         union pthread_mutex_data        m_data;
185         long                            m_flags;
186         int                             m_refcount;
187 
188         /*
189          * Used for priority inheritence and protection.
190          *
191          *   m_prio       - For priority inheritence, the highest active
192          *                  priority (threads locking the mutex inherit
193          *                  this priority).  For priority protection, the
194          *                  ceiling priority of this mutex.
195          *   m_saved_prio - mutex owners inherited priority before
196          *                  taking the mutex, restored when the owner
197          *                  unlocks the mutex.
198          */
199         int                             m_prio;
200         int                             m_saved_prio;
201 
202         /*
203          * Link for list of all mutexes a thread currently owns.
204          */
205         TAILQ_ENTRY(pthread_mutex)      m_qe;
206 
207         /*
208          * Lock for accesses to this structure.
209          */
210         spinlock_t                      lock;
211 };
212 
213 struct pthread_spinlock {
214 	void *s_owner;
215 	unsigned int  s_magic;
216 };
217 
218 /*
219  * Flags for mutexes.
220  */
221 #define MUTEX_FLAGS_PRIVATE	0x01
222 #define MUTEX_FLAGS_INITED	0x02
223 #define MUTEX_FLAGS_BUSY	0x04
224 
225 /*
226  * Condition variable definitions.
227  */
228 enum pthread_cond_type {
229 	COND_TYPE_FAST,
230 	COND_TYPE_MAX
231 };
232 
233 struct pthread_cond {
234 	enum pthread_cond_type		c_type;
235 	TAILQ_HEAD(cond_head, pthread)	c_queue;
236 	pthread_mutex_t			c_mutex;
237 	void				*c_data;
238 	long				c_flags;
239 	int				c_seqno;
240 
241 	/*
242 	 * Lock for accesses to this structure.
243 	 */
244 	struct umtx			c_lock;
245 };
246 
247 struct pthread_cond_attr {
248 	enum pthread_cond_type	c_type;
249 	long			c_flags;
250 };
251 
252 /*
253  * Flags for condition variables.
254  */
255 #define COND_FLAGS_INITED	0x01
256 
257 /*
258  * Static cond initialization values.
259  */
260 #define PTHREAD_COND_STATIC_INITIALIZER    \
261 	{ COND_TYPE_FAST, TAILQ_INITIALIZER, NULL, NULL, \
262 	0, 0, UMTX_INITIALIZER }
263 
264 /*
265  * Semaphore definitions.
266  */
267 struct sem {
268 #define	SEM_MAGIC	((u_int32_t) 0x09fa4012)
269 	u_int32_t	magic;
270 	pthread_mutex_t	lock;
271 	pthread_cond_t	gtzero;
272 	u_int32_t	count;
273 	u_int32_t	nwaiters;
274 };
275 
276 /*
277  * Cleanup definitions.
278  */
279 struct pthread_cleanup {
280 	struct pthread_cleanup	*next;
281 	void			(*routine) ();
282 	void			*routine_arg;
283 };
284 
285 struct pthread_attr {
286 	int	sched_policy;
287 	int	sched_inherit;
288 	int	sched_interval;
289 	int	prio;
290 	int	suspend;
291 	int	flags;
292 	void	*arg_attr;
293 	void	(*cleanup_attr) ();
294 	void	*stackaddr_attr;
295 	size_t	stacksize_attr;
296 	size_t	guardsize_attr;
297 };
298 
299 /*
300  * Thread creation state attributes.
301  */
302 #define PTHREAD_CREATE_RUNNING			0
303 #define PTHREAD_CREATE_SUSPENDED		1
304 
305 /*
306  * Miscellaneous definitions.
307  */
308 #define PTHREAD_STACK_DEFAULT			65536
309 /*
310  * Size of default red zone at the end of each stack.  In actuality, this "red
311  * zone" is merely an unmapped region, except in the case of the initial stack.
312  * Since mmap() makes it possible to specify the maximum growth of a MAP_STACK
313  * region, an unmapped gap between thread stacks achieves the same effect as
314  * explicitly mapped red zones.
315  * This is declared and initialized in uthread_init.c.
316  */
317 extern int _pthread_guard_default;
318 
319 extern int _pthread_page_size;
320 
321 /*
322  * Maximum size of initial thread's stack.  This perhaps deserves to be larger
323  * than the stacks of other threads, since many applications are likely to run
324  * almost entirely on this stack.
325  */
326 #define PTHREAD_STACK_INITIAL			0x100000
327 
328 /*
329  * Define the different priority ranges.  All applications have thread
330  * priorities constrained within 0-31.  The threads library raises the
331  * priority when delivering signals in order to ensure that signal
332  * delivery happens (from the POSIX spec) "as soon as possible".
333  * In the future, the threads library will also be able to map specific
334  * threads into real-time (cooperating) processes or kernel threads.
335  * The RT and SIGNAL priorities will be used internally and added to
336  * thread base priorities so that the scheduling queue can handle both
337  * normal and RT priority threads with and without signal handling.
338  *
339  * The approach taken is that, within each class, signal delivery
340  * always has priority over thread execution.
341  */
342 #define PTHREAD_DEFAULT_PRIORITY		15
343 #define PTHREAD_MIN_PRIORITY			0
344 #define PTHREAD_MAX_PRIORITY			31	/* 0x1F */
345 #define PTHREAD_SIGNAL_PRIORITY			32	/* 0x20 */
346 #define PTHREAD_RT_PRIORITY			64	/* 0x40 */
347 #define PTHREAD_FIRST_PRIORITY			PTHREAD_MIN_PRIORITY
348 #define PTHREAD_LAST_PRIORITY	\
349 	(PTHREAD_MAX_PRIORITY + PTHREAD_SIGNAL_PRIORITY + PTHREAD_RT_PRIORITY)
350 #define PTHREAD_BASE_PRIORITY(prio)	((prio) & PTHREAD_MAX_PRIORITY)
351 
352 /*
353  * Clock resolution in microseconds.
354  */
355 #define CLOCK_RES_USEC				10000
356 #define CLOCK_RES_USEC_MIN			1000
357 
358 /*
359  * Time slice period in microseconds.
360  */
361 #define TIMESLICE_USEC				20000
362 
363 /*
364  * XXX Define a thread-safe macro to get the current time of day
365  * which is updated at regular intervals by the scheduling signal
366  * handler.
367  */
368 #define	GET_CURRENT_TOD(tv)	gettimeofday(&(tv), NULL)
369 
370 struct pthread_barrierattr {
371 	int ba_pshared;
372 };
373 
374 /*
375  * POSIX Threads barrier object.
376  * Lock order:
377  *	1. pthread_barrier
378  *	2. pthread
379  */
380 struct pthread_barrier {
381 	TAILQ_HEAD(barrq_head, pthread) b_barrq;
382 	struct umtx b_lock;
383 	int	    b_total;
384 	int	    b_subtotal;
385 };
386 
387 struct pthread_rwlockattr {
388 	int		pshared;
389 };
390 
391 struct pthread_rwlock {
392 	pthread_mutex_t	lock;	/* monitor lock */
393 	int		state;	/* 0 = idle  >0 = # of readers  -1 = writer */
394 	pthread_cond_t	read_signal;
395 	pthread_cond_t	write_signal;
396 	int		blocked_writers;
397 };
398 
399 /*
400  * Thread states.
401  */
402 enum pthread_state {
403 	PS_RUNNING,
404 	PS_MUTEX_WAIT,
405 	PS_COND_WAIT,
406 	PS_BARRIER_WAIT,
407 	PS_SLEEP_WAIT,	/* XXX We need to wrap syscalls to set this state */
408 	PS_WAIT_WAIT,
409 	PS_JOIN,
410 	PS_DEAD,
411 	PS_DEADLOCK,
412 	PS_STATE_MAX
413 };
414 
415 
416 /*
417  * File descriptor locking definitions.
418  */
419 #define FD_READ             0x1
420 #define FD_WRITE            0x2
421 #define FD_RDWR             (FD_READ | FD_WRITE)
422 
423 union pthread_wait_data {
424 	pthread_mutex_t	mutex;
425 	pthread_cond_t	cond;
426 	spinlock_t	*spinlock;
427 	struct pthread	*thread;
428 };
429 
430 struct join_status {
431 	struct pthread	*thread;
432 	void		*ret;
433 	int		error;
434 };
435 
436 struct pthread_state_data {
437 	union pthread_wait_data psd_wait_data;
438 	enum pthread_state	psd_state;
439 	int			psd_flags;
440 };
441 
442 struct pthread_specific_elem {
443 	const void	*data;
444 	int		seqno;
445 };
446 
447 struct rwlock_held {
448 	LIST_ENTRY(rwlock_held)	rh_link;
449 	struct pthread_rwlock	*rh_rwlock;
450 	int rh_rdcount;
451 	int rh_wrcount;
452 };
453 
454 LIST_HEAD(rwlock_listhead, rwlock_held);
455 
456 /*
457  * Thread structure.
458  */
459 struct pthread {
460 	/*
461 	 * Magic value to help recognize a valid thread structure
462 	 * from an invalid one:
463 	 */
464 #define	PTHREAD_MAGIC		((u_int32_t) 0xd09ba115)
465 	u_int32_t		magic;
466 	char			*name;
467 	u_int64_t		uniqueid; /* for gdb */
468 	thr_id_t		thr_id;
469 	sigset_t		savedsig;
470 	int			signest; /* blocked signal netsting level */
471 
472 	/*
473 	 * Lock for accesses to this thread structure.
474 	 */
475 	struct umtx		lock;
476 
477 	/* Queue entry for list of all threads: */
478 	TAILQ_ENTRY(pthread)	tle;
479 
480 	/* Queue entry for list of dead threads: */
481 	TAILQ_ENTRY(pthread)	dle;
482 
483 	/*
484 	 * Thread start routine, argument, stack pointer and thread
485 	 * attributes.
486 	 */
487 	void			*(*start_routine)(void *);
488 	void			*arg;
489 	void			*stack;
490 	struct pthread_attr	attr;
491 
492 	/*
493 	 * Machine context, including signal state.
494 	 */
495 	ucontext_t		ctx;
496 
497 	/*
498 	 * Cancelability flags - the lower 2 bits are used by cancel
499 	 * definitions in pthread.h
500 	 */
501 #define PTHREAD_AT_CANCEL_POINT		0x0004
502 #define PTHREAD_CANCELLING		0x0008
503 
504 	/*
505 	 * Protected by Giant.
506 	 */
507 	int	cancelflags;
508 
509 	/* Thread state: */
510 	enum pthread_state	state;
511 
512 	/*
513 	 * Error variable used instead of errno. The function __error()
514 	 * returns a pointer to this.
515 	 */
516 	int	error;
517 
518 	/*
519 	 * The joiner is the thread that is joining to this thread.  The
520 	 * join status keeps track of a join operation to another thread.
521 	 */
522 	struct pthread		*joiner;
523 	struct join_status	join_status;
524 
525 	/*
526 	 * A thread can belong to:
527 	 *
528 	 *   o A queue of threads waiting for a mutex
529 	 *   o A queue of threads waiting for a condition variable
530 	 *
531 	 * A thread can also be joining a thread (the joiner field above).
532 	 *
533 	 * It must not be possible for a thread to belong to any of the
534 	 * above queues while it is handling a signal.  Signal handlers
535 	 * may longjmp back to previous stack frames circumventing normal
536 	 * control flow.  This could corrupt queue integrity if the thread
537 	 * retains membership in the queue.  Therefore, if a thread is a
538 	 * member of one of these queues when a signal handler is invoked,
539 	 * it must remove itself from the queue before calling the signal
540 	 * handler and reinsert itself after normal return of the handler.
541 	 *
542 	 * Use sqe for synchronization (mutex and condition variable) queue
543 	 * links.
544 	 */
545 	TAILQ_ENTRY(pthread)	sqe;	/* synchronization queue link */
546 
547 	/* Wait data. */
548 	union pthread_wait_data data;
549 
550 	/* Miscellaneous flags; only set with signals deferred. */
551 	int		flags;
552 #define PTHREAD_FLAGS_PRIVATE	0x0001
553 #define PTHREAD_EXITING		0x0002
554 #define PTHREAD_FLAGS_BARR_REL	0x0004	/* has been released from barrier */
555 #define PTHREAD_FLAGS_IN_CONDQ	0x0080	/* in condition queue using sqe link*/
556 #define PTHREAD_FLAGS_IN_MUTEXQ	0x0100	/* in mutex queue using sqe link */
557 #define	PTHREAD_FLAGS_SUSPENDED	0x0200	/* thread is suspended */
558 #define PTHREAD_FLAGS_TRACE	0x0400	/* for debugging purposes */
559 #define PTHREAD_FLAGS_IN_SYNCQ	\
560     (PTHREAD_FLAGS_IN_CONDQ | PTHREAD_FLAGS_IN_MUTEXQ)
561 
562 	/*
563 	 * Base priority is the user setable and retrievable priority
564 	 * of the thread.  It is only affected by explicit calls to
565 	 * set thread priority and upon thread creation via a thread
566 	 * attribute or default priority.
567 	 */
568 	char		base_priority;
569 
570 	/*
571 	 * Inherited priority is the priority a thread inherits by
572 	 * taking a priority inheritence or protection mutex.  It
573 	 * is not affected by base priority changes.  Inherited
574 	 * priority defaults to and remains 0 until a mutex is taken
575 	 * that is being waited on by any other thread whose priority
576 	 * is non-zero.
577 	 */
578 	char		inherited_priority;
579 
580 	/*
581 	 * Active priority is always the maximum of the threads base
582 	 * priority and inherited priority.  When there is a change
583 	 * in either the base or inherited priority, the active
584 	 * priority must be recalculated.
585 	 */
586 	char		active_priority;
587 
588 	/* Number of priority ceiling or protection mutexes owned. */
589 	int		prio_inherit_count;
590 	int		prio_protect_count;
591 
592 	/*
593 	 * Queue of currently owned mutexes.
594 	 */
595 	TAILQ_HEAD(, pthread_mutex)	mutexq;
596 
597 	/*
598 	 * List of read-write locks owned for reading _OR_ writing.
599 	 * This is accessed only by the current thread, so there's
600 	 * no need for mutual exclusion.
601 	 */
602 	struct rwlock_listhead		*rwlockList;
603 
604 	void				*ret;
605 	struct pthread_specific_elem	*specific;
606 	int				specific_data_count;
607 
608 	/*
609 	 * Architecture specific id field used for _{get, set}_curthread()
610 	 * interface.
611 	 */
612 	void			*arch_id;
613 
614 	/* Cleanup handlers Link List */
615 	struct pthread_cleanup *cleanup;
616 	char			*fname;	/* Ptr to source file name  */
617 	int			lineno;	/* Source line number.      */
618 };
619 
620 /*
621  * Global variables for the uthread kernel.
622  */
623 
624 SCLASS void *_usrstack
625 #ifdef GLOBAL_PTHREAD_PRIVATE
626 = (void *) USRSTACK;
627 #else
628 ;
629 #endif
630 
631 SCLASS spinlock_t stack_lock
632 #ifdef GLOBAL_PTHREAD_PRIVATE
633 = _SPINLOCK_INITIALIZER
634 #endif
635 ;
636 #define STACK_LOCK	_SPINLOCK(&stack_lock);
637 #define STACK_UNLOCK	_SPINUNLOCK(&stack_lock);
638 
639 /* List of all threads: */
640 SCLASS TAILQ_HEAD(, pthread)	_thread_list
641 #ifdef GLOBAL_PTHREAD_PRIVATE
642 = TAILQ_HEAD_INITIALIZER(_thread_list);
643 #else
644 ;
645 #endif
646 
647 /* Dead threads: */
648 SCLASS TAILQ_HEAD(, pthread) _dead_list
649 #ifdef GLOBAL_PTHREAD_PRIVATE
650 = TAILQ_HEAD_INITIALIZER(_dead_list);
651 #else
652 ;
653 #endif
654 
655 /*
656  * These two locks protect the global active threads list and
657  * the global dead threads list, respectively. Combining these
658  * into one lock for both lists doesn't seem wise, since it
659  * would likely increase contention during busy thread creation
660  * and destruction for very little savings in space.
661  *
662  * The lock for the "dead threads list" must be a pthread mutex
663  * because it is used with condition variables to synchronize
664  * the gc thread with active threads in the process of exiting or
665  * dead threads who have just been joined.
666  */
667 SCLASS spinlock_t thread_list_lock
668 #ifdef GLOBAL_PTHREAD_PRIVATE
669 = _SPINLOCK_INITIALIZER
670 #endif
671 ;
672 SCLASS pthread_mutex_t dead_list_lock
673 #ifdef GLOBAL_PTHREAD_PRIVATE
674 = NULL
675 #endif
676 ;
677 
678 #define THREAD_LIST_LOCK	_SPINLOCK(&thread_list_lock)
679 #define THREAD_LIST_UNLOCK	_SPINUNLOCK(&thread_list_lock)
680 #define DEAD_LIST_LOCK		_pthread_mutex_lock(&dead_list_lock)
681 #define DEAD_LIST_UNLOCK	_pthread_mutex_unlock(&dead_list_lock)
682 
683 /* Initial thread: */
684 SCLASS struct pthread *_thread_initial
685 #ifdef GLOBAL_PTHREAD_PRIVATE
686 = NULL;
687 #else
688 ;
689 #endif
690 
691 /* Default thread attributes: */
692 SCLASS struct pthread_attr pthread_attr_default
693 #ifdef GLOBAL_PTHREAD_PRIVATE
694 = { SCHED_RR, 0, TIMESLICE_USEC, PTHREAD_DEFAULT_PRIORITY,
695 	PTHREAD_CREATE_RUNNING, PTHREAD_CREATE_JOINABLE, NULL, NULL, NULL,
696 	PTHREAD_STACK_DEFAULT, -1 };
697 #else
698 ;
699 #endif
700 
701 /* Default mutex attributes: */
702 SCLASS struct pthread_mutex_attr pthread_mutexattr_default
703 #ifdef GLOBAL_PTHREAD_PRIVATE
704 = { PTHREAD_MUTEX_DEFAULT, PTHREAD_PRIO_NONE, 0, 0 };
705 #else
706 ;
707 #endif
708 
709 /* Default condition variable attributes: */
710 SCLASS struct pthread_cond_attr pthread_condattr_default
711 #ifdef GLOBAL_PTHREAD_PRIVATE
712 = { COND_TYPE_FAST, 0 };
713 #else
714 ;
715 #endif
716 
717 SCLASS int    _clock_res_usec		/* Clock resolution in usec.	*/
718 #ifdef GLOBAL_PTHREAD_PRIVATE
719 = CLOCK_RES_USEC;
720 #else
721 ;
722 #endif
723 
724 /* Garbage collector condition variable. */
725 SCLASS	pthread_cond_t  _gc_cond
726 #ifdef GLOBAL_PTHREAD_PRIVATE
727 = NULL
728 #endif
729 ;
730 
731 /*
732  * Array of signal actions for this process.
733  */
734 SCLASS struct  sigaction _thread_sigact[NSIG];
735 
736 /* Precomputed signal set for _thread_suspend. */
737 SCLASS sigset_t _thread_suspend_sigset;
738 
739 /* Tracks the number of threads blocked while waiting for a spinlock. */
740 SCLASS	volatile int	_spinblock_count
741 #ifdef GLOBAL_PTHREAD_PRIVATE
742 = 0
743 #endif
744 ;
745 
746 /* Undefine the storage class specifier: */
747 #undef  SCLASS
748 
749 /*
750  * Function prototype definitions.
751  */
752 __BEGIN_DECLS
753 char    *__ttyname_basic(int);
754 char    *__ttyname_r_basic(int, char *, size_t);
755 char    *ttyname_r(int, char *, size_t);
756 void	_cond_wait_backout(pthread_t);
757 int     _find_thread(pthread_t);
758 pthread_t _get_curthread(void);
759 void	*_set_curthread(ucontext_t *, struct pthread *, int *);
760 void	_retire_thread(void *arch_id);
761 void	*_thread_stack_alloc(size_t, size_t);
762 void	_thread_stack_free(void *, size_t, size_t);
763 int     _thread_create(pthread_t *,const pthread_attr_t *,void *(*start_routine)(void *),void *,pthread_t);
764 int	_mutex_cv_lock(pthread_mutex_t *);
765 int	_mutex_cv_unlock(pthread_mutex_t *);
766 void	_mutex_lock_backout(pthread_t);
767 void	_mutex_notify_priochange(pthread_t);
768 int	_mutex_reinit(pthread_mutex_t *);
769 void	_mutex_unlock_private(pthread_t);
770 int	_cond_reinit(pthread_cond_t *);
771 void	*_pthread_getspecific(pthread_key_t);
772 int	_pthread_key_create(pthread_key_t *, void (*) (void *));
773 int	_pthread_key_delete(pthread_key_t);
774 int	_pthread_mutex_destroy(pthread_mutex_t *);
775 int	_pthread_mutex_init(pthread_mutex_t *, const pthread_mutexattr_t *);
776 int	_pthread_mutex_lock(pthread_mutex_t *);
777 int	_pthread_mutex_trylock(pthread_mutex_t *);
778 int	_pthread_mutex_unlock(pthread_mutex_t *);
779 int	_pthread_mutexattr_init(pthread_mutexattr_t *);
780 int	_pthread_mutexattr_destroy(pthread_mutexattr_t *);
781 int	_pthread_mutexattr_settype(pthread_mutexattr_t *, int);
782 int	_pthread_once(pthread_once_t *, void (*) (void));
783 pthread_t _pthread_self(void);
784 int	_pthread_setspecific(pthread_key_t, const void *);
785 int	_spintrylock(spinlock_t *);
786 void    _thread_exit(char *, int, char *);
787 void    _thread_exit_cleanup(void);
788 void    *_thread_cleanup(pthread_t);
789 void    _thread_cleanupspecific(void);
790 void    _thread_dump_info(void);
791 void    _thread_init(void);
792 void	_thread_sig_wrapper(int sig, siginfo_t *info, void *context);
793 void	_thread_printf(int fd, const char *, ...);
794 void    _thread_start(void);
795 void	_thread_seterrno(pthread_t, int);
796 pthread_addr_t _thread_gc(pthread_addr_t);
797 void	_thread_enter_cancellation_point(void);
798 void	_thread_leave_cancellation_point(void);
799 void	_thread_cancellation_point(void);
800 int	_thread_suspend(pthread_t thread, const struct timespec *abstime);
801 void	_thread_critical_enter(pthread_t);
802 void	_thread_critical_exit(pthread_t);
803 void	_thread_sigblock();
804 void	_thread_sigunblock();
805 void	adjust_prio_inheritance(struct pthread *);
806 void	adjust_prio_protection(struct pthread *);
807 void	init_td_common(struct pthread *, struct pthread_attr *, int);
808 void	init_tdlist(struct pthread *, int);
809 void	proc_sigact_copyin(int, const struct sigaction *);
810 void	proc_sigact_copyout(int, struct sigaction *);
811 void	readjust_priorities(struct pthread *, struct pthread_mutex *);
812 struct sigaction *proc_sigact_sigaction(int);
813 
814 /* #include <sys/aio.h> */
815 #ifdef _SYS_AIO_H_
816 int	__sys_aio_suspend(const struct aiocb * const[], int, const struct timespec *);
817 #endif
818 
819 /* #include <sys/event.h> */
820 #ifdef _SYS_EVENT_H_
821 int	__sys_kevent(int, const struct kevent *, int, struct kevent *,
822 	    int, const struct timespec *);
823 #endif
824 
825 /* #include <sys/ioctl.h> */
826 #ifdef _SYS_IOCTL_H_
827 int	__sys_ioctl(int, unsigned long, ...);
828 #endif
829 
830 /* #include <sys/mman.h> */
831 #ifdef _SYS_MMAN_H_
832 int	__sys_msync(void *, size_t, int);
833 #endif
834 
835 /* #include <sys/mount.h> */
836 #ifdef _SYS_MOUNT_H_
837 int	__sys_fstatfs(int, struct statfs *);
838 #endif
839 
840 /* #include <sys/socket.h> */
841 #ifdef _SYS_SOCKET_H_
842 int	__sys_accept(int, struct sockaddr *, socklen_t *);
843 int	__sys_bind(int, const struct sockaddr *, socklen_t);
844 int	__sys_connect(int, const struct sockaddr *, socklen_t);
845 int	__sys_getpeername(int, struct sockaddr *, socklen_t *);
846 int	__sys_getsockname(int, struct sockaddr *, socklen_t *);
847 int	__sys_getsockopt(int, int, int, void *, socklen_t *);
848 int	__sys_listen(int, int);
849 ssize_t	__sys_recvfrom(int, void *, size_t, int, struct sockaddr *, socklen_t *);
850 ssize_t	__sys_recvmsg(int, struct msghdr *, int);
851 int	__sys_sendfile(int, int, off_t, size_t, struct sf_hdtr *, off_t *, int);
852 ssize_t	__sys_sendmsg(int, const struct msghdr *, int);
853 ssize_t	__sys_sendto(int, const void *,size_t, int, const struct sockaddr *, socklen_t);
854 int	__sys_setsockopt(int, int, int, const void *, socklen_t);
855 int	__sys_shutdown(int, int);
856 int	__sys_socket(int, int, int);
857 int	__sys_socketpair(int, int, int, int *);
858 #endif
859 
860 /* #include <sys/stat.h> */
861 #ifdef _SYS_STAT_H_
862 int	__sys_fchflags(int, u_long);
863 int	__sys_fchmod(int, mode_t);
864 int	__sys_fstat(int, struct stat *);
865 #endif
866 
867 /* #include <sys/uio.h> */
868 #ifdef _SYS_UIO_H_
869 ssize_t	__sys_readv(int, const struct iovec *, int);
870 ssize_t	__sys_writev(int, const struct iovec *, int);
871 #endif
872 
873 /* #include <sys/wait.h> */
874 #ifdef WNOHANG
875 pid_t	__sys_wait4(pid_t, int *, int, struct rusage *);
876 #endif
877 
878 /* #include <dirent.h> */
879 #ifdef _DIRENT_H_
880 int	__sys_getdirentries(int, char *, int, long *);
881 #endif
882 
883 /* #include <fcntl.h> */
884 #ifdef _SYS_FCNTL_H_
885 int	__sys_fcntl(int, int, ...);
886 int	__sys_flock(int, int);
887 int	__sys_open(const char *, int, ...);
888 #endif
889 
890 /* #include <poll.h> */
891 #ifdef _SYS_POLL_H_
892 int	__sys_poll(struct pollfd *, unsigned, int);
893 #endif
894 
895 /* #include <signal.h> */
896 #ifdef _SIGNAL_H_
897 int	__sys_sigaction(int, const struct sigaction *, struct sigaction *);
898 int	__sys_sigaltstack(const struct sigaltstack *, struct sigaltstack *);
899 int	__sys_sigprocmask(int, const sigset_t *, sigset_t *);
900 int	__sys_sigreturn(ucontext_t *);
901 #endif
902 
903 /* #include <unistd.h> */
904 #ifdef _UNISTD_H_
905 int	__sys_close(int);
906 int	__sys_dup(int);
907 int	__sys_dup2(int, int);
908 int	__sys_execve(const char *, char * const *, char * const *);
909 void	__sys_exit(int);
910 int	__sys_fchown(int, uid_t, gid_t);
911 pid_t	__sys_fork(void);
912 long	__sys_fpathconf(int, int);
913 int	__sys_fsync(int);
914 int	__sys_pipe(int *);
915 ssize_t	__sys_read(int, void *, size_t);
916 ssize_t	__sys_write(int, const void *, size_t);
917 #endif
918 
919 __END_DECLS
920 
921 #endif  /* !_PTHREAD_PRIVATE_H */
922