xref: /freebsd/include/pthread.h (revision 7fdf597e96a02165cfe22ff357b857d5fa15ed8a)
1  /*-
2   * SPDX-License-Identifier: BSD-4-Clause
3   *
4   * Copyright (c) 1993, 1994 by Chris Provenzano, proven@mit.edu
5   * Copyright (c) 1995-1998 by John Birrell <jb@cimlogic.com.au>
6   * All rights reserved.
7   *
8   * Redistribution and use in source and binary forms, with or without
9   * modification, are permitted provided that the following conditions
10   * are met:
11   * 1. Redistributions of source code must retain the above copyright
12   *    notice, this list of conditions and the following disclaimer.
13   * 2. Redistributions in binary form must reproduce the above copyright
14   *    notice, this list of conditions and the following disclaimer in the
15   *    documentation and/or other materials provided with the distribution.
16   * 3. All advertising materials mentioning features or use of this software
17   *    must display the following acknowledgement:
18   *  This product includes software developed by Chris Provenzano.
19   * 4. The name of Chris Provenzano may not be used to endorse or promote
20   *	  products derived from this software without specific prior written
21   *	  permission.
22   *
23   * THIS SOFTWARE IS PROVIDED BY CHRIS PROVENZANO ``AS IS'' AND
24   * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
25   * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
26   * ARE DISCLAIMED.  IN NO EVENT SHALL CHRIS PROVENZANO BE LIABLE FOR ANY
27   * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
28   * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
29   * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
30   * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
31   * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
32   * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
33   * SUCH DAMAGE.
34   */
35  #ifndef _PTHREAD_H_
36  #define	_PTHREAD_H_
37  
38  /*
39   * Header files.
40   */
41  #include <sys/cdefs.h>
42  #include <sys/_pthreadtypes.h>
43  #include <machine/_limits.h>
44  #include <sys/_types.h>
45  #include <sys/_sigset.h>
46  #if __BSD_VISIBLE
47  #include <sys/_sigval.h>
48  #endif
49  #include <sched.h>
50  #include <time.h>
51  
52  /*
53   * Run-time invariant values:
54   */
55  #define	PTHREAD_DESTRUCTOR_ITERATIONS		4
56  #define	PTHREAD_KEYS_MAX			256
57  #define	PTHREAD_STACK_MIN			__MINSIGSTKSZ
58  #define	PTHREAD_THREADS_MAX			__ULONG_MAX
59  #define	PTHREAD_BARRIER_SERIAL_THREAD		-1
60  
61  /*
62   * Flags for threads and thread attributes.
63   */
64  #define	PTHREAD_DETACHED		0x1
65  #define	PTHREAD_SCOPE_SYSTEM		0x2
66  #define	PTHREAD_INHERIT_SCHED		0x4
67  #define	PTHREAD_NOFLOAT			0x8
68  
69  #define	PTHREAD_CREATE_DETACHED		PTHREAD_DETACHED
70  #define	PTHREAD_CREATE_JOINABLE		0
71  #define	PTHREAD_SCOPE_PROCESS		0
72  #define	PTHREAD_EXPLICIT_SCHED		0
73  
74  /*
75   * Values for process shared/private attributes.
76   */
77  #define	PTHREAD_PROCESS_PRIVATE		0
78  #define	PTHREAD_PROCESS_SHARED		1
79  
80  /*
81   * Flags for cancelling threads
82   */
83  #define	PTHREAD_CANCEL_ENABLE		0
84  #define	PTHREAD_CANCEL_DISABLE		1
85  #define	PTHREAD_CANCEL_DEFERRED		0
86  #define	PTHREAD_CANCEL_ASYNCHRONOUS	2
87  #define	PTHREAD_CANCELED		((void *) 1)
88  
89  /*
90   * Flags for once initialization.
91   */
92  #define	PTHREAD_NEEDS_INIT	0
93  #define	PTHREAD_DONE_INIT	1
94  
95  /*
96   * Static once initialization values.
97   */
98  #define	PTHREAD_ONCE_INIT	{ PTHREAD_NEEDS_INIT, NULL }
99  
100  /*
101   * Static initialization values.
102   */
103  #define	PTHREAD_MUTEX_INITIALIZER	NULL
104  #define	PTHREAD_ADAPTIVE_MUTEX_INITIALIZER_NP	((pthread_mutex_t)1)
105  #define	PTHREAD_COND_INITIALIZER	NULL
106  #define	PTHREAD_RWLOCK_INITIALIZER	NULL
107  
108  /*
109   * Default attribute arguments (draft 4, deprecated).
110   */
111  #ifndef PTHREAD_KERNEL
112  #define	pthread_condattr_default	NULL
113  #define	pthread_mutexattr_default	NULL
114  #define	pthread_attr_default		NULL
115  #endif
116  
117  #define	PTHREAD_PRIO_NONE	0
118  #define	PTHREAD_PRIO_INHERIT	1
119  #define	PTHREAD_PRIO_PROTECT	2
120  
121  /*
122   * Mutex types (Single UNIX Specification, Version 2, 1997).
123   *
124   * Note that a mutex attribute with one of the following types:
125   *
126   *	PTHREAD_MUTEX_NORMAL
127   *	PTHREAD_MUTEX_RECURSIVE
128   *
129   * will deviate from POSIX specified semantics.
130   */
131  enum pthread_mutextype {
132  	PTHREAD_MUTEX_ERRORCHECK	= 1,	/* Default POSIX mutex */
133  	PTHREAD_MUTEX_RECURSIVE		= 2,	/* Recursive mutex */
134  	PTHREAD_MUTEX_NORMAL		= 3,	/* No error checking */
135  	PTHREAD_MUTEX_ADAPTIVE_NP	= 4,	/* Adaptive mutex, spins briefly before blocking on lock */
136  	PTHREAD_MUTEX_TYPE_MAX
137  };
138  
139  #define	PTHREAD_MUTEX_DEFAULT		PTHREAD_MUTEX_ERRORCHECK
140  
141  #define	PTHREAD_MUTEX_STALLED		0
142  #define	PTHREAD_MUTEX_ROBUST		1
143  
144  struct _pthread_cleanup_info {
145  	__uintptr_t	pthread_cleanup_pad[8];
146  };
147  
148  /*
149   * Thread function prototype definitions:
150   */
151  __BEGIN_DECLS
152  int		pthread_atfork(void (*)(void), void (*)(void), void (*)(void));
153  int		pthread_attr_destroy(pthread_attr_t *);
154  int		pthread_attr_getstack(
155  		    const pthread_attr_t * __restrict, void ** __restrict,
156  		    size_t * __restrict);
157  int		pthread_attr_getstacksize(const pthread_attr_t * __restrict,
158  		    size_t * __restrict);
159  int		pthread_attr_getguardsize(const pthread_attr_t * __restrict,
160  		    size_t * __restrict);
161  int		pthread_attr_getstackaddr(const pthread_attr_t *, void **);
162  int		pthread_attr_getdetachstate(const pthread_attr_t *,
163  		    int *);
164  int		pthread_attr_init(pthread_attr_t *);
165  int		pthread_attr_setstacksize(pthread_attr_t *, size_t);
166  int		pthread_attr_setguardsize(pthread_attr_t *, size_t);
167  int		pthread_attr_setstack(pthread_attr_t *, void *,
168  		    size_t);
169  int		pthread_attr_setstackaddr(pthread_attr_t *, void *);
170  int		pthread_attr_setdetachstate(pthread_attr_t *, int);
171  int		pthread_barrier_destroy(pthread_barrier_t *);
172  int		pthread_barrier_init(pthread_barrier_t * __restrict,
173  			const pthread_barrierattr_t * __restrict, unsigned);
174  int		pthread_barrier_wait(pthread_barrier_t *);
175  int		pthread_barrierattr_destroy(pthread_barrierattr_t *);
176  int		pthread_barrierattr_getpshared(
177  		    const pthread_barrierattr_t * __restrict, int * __restrict);
178  int		pthread_barrierattr_init(pthread_barrierattr_t *);
179  int		pthread_barrierattr_setpshared(pthread_barrierattr_t *, int);
180  
181  #define		pthread_cleanup_push(cleanup_routine, cleanup_arg)		\
182  		{								\
183  			struct _pthread_cleanup_info __cleanup_info__;		\
184  			__pthread_cleanup_push_imp(cleanup_routine, cleanup_arg,\
185  				&__cleanup_info__);				\
186  			{
187  
188  #define		pthread_cleanup_pop(execute)					\
189  				(void)0;					\
190  			}							\
191  			__pthread_cleanup_pop_imp(execute);			\
192  		}
193  
194  int		pthread_condattr_destroy(pthread_condattr_t *);
195  int		pthread_condattr_getclock(const pthread_condattr_t * __restrict,
196  		    clockid_t * __restrict);
197  int		pthread_condattr_getpshared(const pthread_condattr_t *, int *);
198  int		pthread_condattr_init(pthread_condattr_t *);
199  int		pthread_condattr_setclock(pthread_condattr_t *, clockid_t);
200  int		pthread_condattr_setpshared(pthread_condattr_t *, int);
201  int		pthread_cond_broadcast(pthread_cond_t *);
202  int		pthread_cond_destroy(pthread_cond_t *);
203  int		pthread_cond_init(pthread_cond_t * __restrict,
204  		    const pthread_condattr_t * __restrict);
205  int		pthread_cond_signal(pthread_cond_t *);
206  int		pthread_cond_timedwait(pthread_cond_t *,
207  		    pthread_mutex_t * __mutex,
208  		    const struct timespec *)
209  		    __requires_exclusive(*__mutex);
210  int		pthread_cond_wait(pthread_cond_t * __restrict,
211  		    pthread_mutex_t * __restrict __mutex)
212  		    __requires_exclusive(*__mutex);
213  int		pthread_create(pthread_t * __restrict,
214  		    const pthread_attr_t * __restrict, void *(*) (void *),
215  		    void * __restrict);
216  int		pthread_detach(pthread_t);
217  int		pthread_equal(pthread_t, pthread_t);
218  void		pthread_exit(void *) __dead2;
219  void		*pthread_getspecific(pthread_key_t);
220  int		pthread_getcpuclockid(pthread_t, clockid_t *);
221  int		pthread_join(pthread_t, void **);
222  int		pthread_key_create(pthread_key_t *, void (*) (void *));
223  int		pthread_key_delete(pthread_key_t);
224  int		pthread_mutexattr_init(pthread_mutexattr_t *);
225  int		pthread_mutexattr_destroy(pthread_mutexattr_t *);
226  int		pthread_mutexattr_getpshared(
227  		    const pthread_mutexattr_t * __restrict,
228  		    int * __restrict);
229  int		pthread_mutexattr_gettype(
230  		    const pthread_mutexattr_t * __restrict, int * __restrict);
231  int		pthread_mutexattr_settype(pthread_mutexattr_t *, int);
232  int		pthread_mutexattr_setpshared(pthread_mutexattr_t *, int);
233  int		pthread_mutex_consistent(pthread_mutex_t * __mutex)
234  		    __requires_exclusive(*__mutex);
235  int		pthread_mutex_destroy(pthread_mutex_t * __mutex)
236  		    __requires_unlocked(*__mutex);
237  int		pthread_mutex_init(pthread_mutex_t * __restrict __mutex,
238  		    const pthread_mutexattr_t * __restrict)
239  		    __requires_unlocked(*__mutex);
240  int		pthread_mutex_lock(pthread_mutex_t * __mutex)
241  		    __locks_exclusive(*__mutex);
242  int		pthread_mutex_trylock(pthread_mutex_t * __mutex)
243  		    __trylocks_exclusive(0, *__mutex);
244  int		pthread_mutex_timedlock(pthread_mutex_t * __restrict __mutex,
245  		    const struct timespec * __restrict)
246  		    __trylocks_exclusive(0, *__mutex);
247  int		pthread_mutex_unlock(pthread_mutex_t * __mutex)
248  		    __unlocks(*__mutex);
249  int		pthread_once(pthread_once_t *, void (*) (void));
250  int		pthread_rwlock_destroy(pthread_rwlock_t * __rwlock)
251  		    __requires_unlocked(*__rwlock);
252  int		pthread_rwlock_init(pthread_rwlock_t * __restrict __rwlock,
253  		    const pthread_rwlockattr_t * __restrict)
254  		    __requires_unlocked(*__rwlock);
255  int		pthread_rwlock_rdlock(pthread_rwlock_t * __rwlock)
256  		    __locks_shared(*__rwlock);
257  int		pthread_rwlock_timedrdlock(
258  		    pthread_rwlock_t * __restrict __rwlock,
259  		    const struct timespec * __restrict)
260  		    __trylocks_shared(0, *__rwlock);
261  int		pthread_rwlock_timedwrlock(
262  		    pthread_rwlock_t * __restrict __rwlock,
263  		    const struct timespec * __restrict)
264  		    __trylocks_exclusive(0, *__rwlock);
265  int		pthread_rwlock_tryrdlock(pthread_rwlock_t * __rwlock)
266  		    __trylocks_shared(0, *__rwlock);
267  int		pthread_rwlock_trywrlock(pthread_rwlock_t * __rwlock)
268  		    __trylocks_exclusive(0, *__rwlock);
269  int		pthread_rwlock_unlock(pthread_rwlock_t * __rwlock)
270  		    __unlocks(*__rwlock);
271  int		pthread_rwlock_wrlock(pthread_rwlock_t * __rwlock)
272  		    __locks_exclusive(*__rwlock);
273  int		pthread_rwlockattr_destroy(pthread_rwlockattr_t *);
274  int		pthread_rwlockattr_getkind_np(const pthread_rwlockattr_t *,
275  		    int *);
276  int		pthread_rwlockattr_getpshared(
277  		    const pthread_rwlockattr_t * __restrict,
278  		    int * __restrict);
279  int		pthread_rwlockattr_init(pthread_rwlockattr_t *);
280  int		pthread_rwlockattr_setkind_np(pthread_rwlockattr_t *,
281  		    int);
282  int		pthread_rwlockattr_setpshared(pthread_rwlockattr_t *, int);
283  pthread_t	pthread_self(void);
284  int		pthread_setspecific(pthread_key_t, const void *);
285  
286  int		pthread_spin_init(pthread_spinlock_t * __spin, int)
287  		    __requires_unlocked(*__spin);
288  int		pthread_spin_destroy(pthread_spinlock_t * __spin)
289  		    __requires_unlocked(*__spin);
290  int		pthread_spin_lock(pthread_spinlock_t * __spin)
291  			__locks_exclusive(*__spin);
292  int		pthread_spin_trylock(pthread_spinlock_t * __spin)
293  			__trylocks_exclusive(0, *__spin);
294  int		pthread_spin_unlock(pthread_spinlock_t * __spin)
295  			__unlocks(*__spin);
296  int		pthread_cancel(pthread_t);
297  int		pthread_setcancelstate(int, int *);
298  int		pthread_setcanceltype(int, int *);
299  void		pthread_testcancel(void);
300  
301  #if __BSD_VISIBLE
302  int		pthread_getprio(pthread_t);
303  int		pthread_setprio(pthread_t, int);
304  void		pthread_yield(void);
305  
306  int		pthread_getname_np(pthread_t, char *, size_t);
307  int		pthread_setname_np(pthread_t, const char *);
308  
309  int		pthread_sigqueue(pthread_t thread, int sig,
310  		    const union sigval value);
311  
312  #endif
313  
314  int		pthread_mutexattr_getprioceiling(
315  		    const pthread_mutexattr_t * __restrict,
316  		    int * __restrict);
317  int		pthread_mutexattr_setprioceiling(pthread_mutexattr_t *, int);
318  int		pthread_mutex_getprioceiling(const pthread_mutex_t * __restrict,
319  		    int * __restrict);
320  int		pthread_mutex_setprioceiling(pthread_mutex_t * __restrict, int,
321  		    int * __restrict);
322  
323  int		pthread_mutexattr_getprotocol(
324  		    const pthread_mutexattr_t * __restrict,
325  		    int * __restrict);
326  int		pthread_mutexattr_setprotocol(pthread_mutexattr_t *, int);
327  
328  int		pthread_mutexattr_getrobust(
329  		    pthread_mutexattr_t * __restrict, int * __restrict);
330  int		pthread_mutexattr_setrobust(pthread_mutexattr_t *, int);
331  
332  int		pthread_attr_getinheritsched(const pthread_attr_t * __restrict,
333  		    int * __restrict);
334  int		pthread_attr_getschedparam(const pthread_attr_t *,
335  		    struct sched_param *);
336  int		pthread_attr_getschedpolicy(const pthread_attr_t * __restrict,
337  		    int * __restrict);
338  int		pthread_attr_getscope(const pthread_attr_t * __restrict,
339  		    int * __restrict);
340  int		pthread_attr_setinheritsched(pthread_attr_t *, int);
341  int		pthread_attr_setschedparam(pthread_attr_t *,
342  		    const struct sched_param *);
343  int		pthread_attr_setschedpolicy(pthread_attr_t *, int);
344  int		pthread_attr_setscope(pthread_attr_t *, int);
345  int		pthread_getschedparam(pthread_t pthread, int * __restrict,
346  		    struct sched_param * __restrict);
347  int		pthread_setschedparam(pthread_t, int,
348  		    const struct sched_param *);
349  #if __XSI_VISIBLE
350  int		pthread_getconcurrency(void);
351  int		pthread_setconcurrency(int);
352  #endif
353  
354  void		__pthread_cleanup_push_imp(void (*)(void *), void *,
355  			struct _pthread_cleanup_info *);
356  void		__pthread_cleanup_pop_imp(int);
357  __END_DECLS
358  
359  #endif	/* !_PTHREAD_H_ */
360