xref: /netbsd-src/lib/libpthread/pthread.h (revision aaf4ece63a859a04e37cf3a7229b5fab0157cc06)
1 /*	$NetBSD: pthread.h,v 1.21 2005/03/21 17:55:07 kleink Exp $	*/
2 
3 /*-
4  * Copyright (c) 2001 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_H
40 #define _LIB_PTHREAD_H
41 
42 #include <sys/cdefs.h>
43 
44 #include <time.h>	/* For timespec */
45 #include <sched.h>
46 
47 #include <pthread_types.h>
48 
49 __BEGIN_DECLS
50 int	pthread_atfork(void (*)(void), void (*)(void), void (*)(void));
51 int	pthread_create(pthread_t * __restrict,
52 	    const pthread_attr_t * __restrict, void *(*)(void *),
53 	    void * __restrict);
54 void	pthread_exit(void *) __attribute__((__noreturn__));
55 int	pthread_join(pthread_t, void **);
56 int	pthread_equal(pthread_t, pthread_t);
57 pthread_t	pthread_self(void);
58 int	pthread_detach(pthread_t);
59 
60 int	pthread_getrrtimer_np(void);
61 int	pthread_setrrtimer_np(int);
62 
63 int	pthread_attr_init(pthread_attr_t *);
64 int	pthread_attr_destroy(pthread_attr_t *);
65 int	pthread_attr_get_np(pthread_t, pthread_attr_t *);
66 int	pthread_attr_getguardsize(const pthread_attr_t * __restrict,
67 	    size_t * __restrict);
68 int	pthread_attr_setguardsize(pthread_attr_t *, size_t);
69 int	pthread_attr_getinheritsched(const pthread_attr_t * __restrict,
70 	    int * __restrict);
71 int	pthread_attr_setinheritsched(pthread_attr_t *, int);
72 int	pthread_attr_getschedparam(const pthread_attr_t * __restrict,
73 	    struct sched_param * __restrict);
74 int	pthread_attr_setschedparam(pthread_attr_t * __restrict,
75     const struct sched_param * __restrict);
76 int	pthread_attr_getschedpolicy(const pthread_attr_t * __restrict,
77 	    int * __restrict);
78 int	pthread_attr_setschedpolicy(pthread_attr_t *, int);
79 int	pthread_attr_getscope(const pthread_attr_t * __restrict,
80 	    int * __restrict);
81 int	pthread_attr_setscope(pthread_attr_t *, int);
82 int	pthread_attr_getstack(const pthread_attr_t * __restrict,
83 	    void ** __restrict, size_t * __restrict);
84 int	pthread_attr_setstack(pthread_attr_t *, void *, size_t);
85 int	pthread_attr_getstacksize(const pthread_attr_t * __restrict,
86 	    size_t * __restrict);
87 int	pthread_attr_setstacksize(pthread_attr_t *, size_t);
88 int	pthread_attr_getstackaddr(const pthread_attr_t * __restrict,
89 	    void ** __restrict);
90 int	pthread_attr_setstackaddr(pthread_attr_t *, void *);
91 int	pthread_attr_getdetachstate(const pthread_attr_t *, int *);
92 int	pthread_attr_setdetachstate(pthread_attr_t *, int);
93 int	pthread_attr_getname_np(const pthread_attr_t *, char *,
94 	    size_t, void **);
95 int	pthread_attr_setname_np(pthread_attr_t *, const char *, void *);
96 
97 int	pthread_mutex_init(pthread_mutex_t * __restrict,
98 	    const pthread_mutexattr_t * __restrict);
99 int	pthread_mutex_destroy(pthread_mutex_t *);
100 int	pthread_mutex_lock(pthread_mutex_t *);
101 int	pthread_mutex_trylock(pthread_mutex_t *);
102 int	pthread_mutex_unlock(pthread_mutex_t *);
103 int	pthread_mutexattr_init(pthread_mutexattr_t *);
104 int	pthread_mutexattr_destroy(pthread_mutexattr_t *);
105 int	pthread_mutexattr_gettype(const pthread_mutexattr_t * __restrict,
106 	    int * __restrict);
107 int	pthread_mutexattr_settype(pthread_mutexattr_t *attr, int);
108 
109 int	pthread_cond_init(pthread_cond_t * __restrict,
110 	    const pthread_condattr_t * __restrict);
111 int	pthread_cond_destroy(pthread_cond_t *);
112 int	pthread_cond_wait(pthread_cond_t * __restrict,
113 	    pthread_mutex_t * __restrict);
114 int	pthread_cond_timedwait(pthread_cond_t * __restrict,
115 	    pthread_mutex_t * __restrict, const struct timespec * __restrict);
116 int	pthread_cond_signal(pthread_cond_t *);
117 int	pthread_cond_broadcast(pthread_cond_t *);
118 int	pthread_condattr_init(pthread_condattr_t *);
119 int	pthread_condattr_destroy(pthread_condattr_t *);
120 
121 int	pthread_once(pthread_once_t *, void (*)(void));
122 
123 int	pthread_key_create(pthread_key_t *, void (*)(void *));
124 int	pthread_key_delete(pthread_key_t);
125 int	pthread_setspecific(pthread_key_t, const void *);
126 void*	pthread_getspecific(pthread_key_t);
127 
128 int	pthread_cancel(pthread_t);
129 int	pthread_setcancelstate(int, int *);
130 int	pthread_setcanceltype(int, int *);
131 void	pthread_testcancel(void);
132 
133 int	pthread_getname_np(pthread_t, char *, size_t);
134 int	pthread_setname_np(pthread_t, const char *, void *);
135 
136 int 	pthread_attr_setcreatesuspend_np(pthread_attr_t *);
137 int	pthread_suspend_np(pthread_t);
138 int	pthread_resume_np(pthread_t);
139 
140 struct pthread_cleanup_store {
141 	void	*pad[4];
142 };
143 
144 #define pthread_cleanup_push(routine, arg)			\
145         {							\
146 		struct pthread_cleanup_store __store;		\
147 		pthread__cleanup_push((routine),(arg), &__store);
148 
149 #define pthread_cleanup_pop(execute)				\
150 		pthread__cleanup_pop((execute), &__store);	\
151 	}
152 
153 void	pthread__cleanup_push(void (*)(void *), void *, void *);
154 void	pthread__cleanup_pop(int, void *);
155 
156 int	pthread_spin_init(pthread_spinlock_t *, int);
157 int	pthread_spin_destroy(pthread_spinlock_t *);
158 int	pthread_spin_lock(pthread_spinlock_t *);
159 int	pthread_spin_trylock(pthread_spinlock_t *);
160 int	pthread_spin_unlock(pthread_spinlock_t *);
161 
162 int	pthread_rwlock_init(pthread_rwlock_t * __restrict,
163 	    const pthread_rwlockattr_t * __restrict);
164 int	pthread_rwlock_destroy(pthread_rwlock_t *);
165 int	pthread_rwlock_rdlock(pthread_rwlock_t *);
166 int	pthread_rwlock_tryrdlock(pthread_rwlock_t *);
167 int	pthread_rwlock_wrlock(pthread_rwlock_t *);
168 int	pthread_rwlock_trywrlock(pthread_rwlock_t *);
169 int	pthread_rwlock_timedrdlock(pthread_rwlock_t * __restrict,
170 	    const struct timespec * __restrict);
171 int	pthread_rwlock_timedwrlock(pthread_rwlock_t * __restrict,
172 	    const struct timespec * __restrict);
173 int	pthread_rwlock_unlock(pthread_rwlock_t *);
174 int	pthread_rwlockattr_init(pthread_rwlockattr_t *);
175 int	pthread_rwlockattr_destroy(pthread_rwlockattr_t *);
176 
177 int	pthread_barrier_init(pthread_barrier_t * __restrict,
178 	    const pthread_barrierattr_t * __restrict, unsigned int);
179 int	pthread_barrier_wait(pthread_barrier_t *);
180 int	pthread_barrier_destroy(pthread_barrier_t *);
181 int	pthread_barrierattr_init(pthread_barrierattr_t *);
182 int	pthread_barrierattr_destroy(pthread_barrierattr_t *);
183 
184 int	pthread_getschedparam(pthread_t, int * __restrict,
185 	    struct sched_param * __restrict);
186 int	pthread_setschedparam(pthread_t, int, const struct sched_param *);
187 
188 int 	*pthread__errno(void);
189 __END_DECLS
190 
191 #define	PTHREAD_CREATE_JOINABLE	0
192 #define	PTHREAD_CREATE_DETACHED	1
193 
194 #define PTHREAD_INHERIT_SCHED	0
195 #define PTHREAD_EXPLICIT_SCHED	1
196 
197 #define PTHREAD_SCOPE_PROCESS	0
198 #define PTHREAD_SCOPE_SYSTEM	1
199 
200 #define PTHREAD_PROCESS_PRIVATE	0
201 #define PTHREAD_PROCESS_SHARED	1
202 
203 #define PTHREAD_CANCEL_DEFERRED		0
204 #define PTHREAD_CANCEL_ASYNCHRONOUS	1
205 
206 #define PTHREAD_CANCEL_ENABLE		0
207 #define PTHREAD_CANCEL_DISABLE		1
208 
209 #define PTHREAD_BARRIER_SERIAL_THREAD	1234567
210 
211 /*
212  * POSIX 1003.1-2001, section 2.5.9.3: "The symbolic constant
213  * PTHREAD_CANCELED expands to a constant expression of type (void *)
214  * whose value matches no pointer to an object in memory nor the value
215  * NULL."
216  */
217 #define PTHREAD_CANCELED	((void *) 1)
218 
219 /*
220  * Maximum length of a thread's name, including the terminating NUL.
221  */
222 #define	PTHREAD_MAX_NAMELEN_NP	32
223 
224 /*
225  * Mutex attributes.
226  */
227 #define	PTHREAD_MUTEX_NORMAL		0
228 #define	PTHREAD_MUTEX_ERRORCHECK	1
229 #define	PTHREAD_MUTEX_RECURSIVE		2
230 #define	PTHREAD_MUTEX_DEFAULT		PTHREAD_MUTEX_NORMAL
231 
232 #define PTHREAD_COND_INITIALIZER	_PTHREAD_COND_INITIALIZER
233 #define PTHREAD_MUTEX_INITIALIZER	_PTHREAD_MUTEX_INITIALIZER
234 #define PTHREAD_ONCE_INIT		_PTHREAD_ONCE_INIT
235 #define PTHREAD_RWLOCK_INITIALIZER	_PTHREAD_RWLOCK_INITIALIZER
236 #define PTHREAD_SPINLOCK_INITIALIZER	_PTHREAD_SPINLOCK_INITIALIZER
237 
238 /*
239  * Use macros to rename many pthread functions to the corresponding
240  * libc symbols which are either trivial/no-op stubs or the real
241  * thing, depending on whether libpthread is linked in to the
242  * program. This permits code, particularly libraries that do not
243  * directly use threads but want to be thread-safe in the presence of
244  * threaded callers, to use pthread mutexes and the like without
245  * unnecessairly including libpthread in their linkage.
246  *
247  * Left out of this list are functions that can't sensibly be trivial
248  * or no-op stubs in a single-threaded process (pthread_create,
249  * pthread_kill, pthread_detach), functions that normally block and
250  * wait for another thread to do something (pthread_join), and
251  * functions that don't make sense without the previous functions
252  * (pthread_attr_*). The pthread_cond_wait and pthread_cond_timedwait
253  * functions are useful in implementing certain protection mechanisms,
254  * though a non-buggy app shouldn't end up calling them in
255  * single-threaded mode.
256  *
257  * The rename is done as:
258  * #define pthread_foo	__libc_foo
259  * instead of
260  * #define pthread_foo(x) __libc_foo((x))
261  * in order that taking the address of the function ("func =
262  * &pthread_foo;") continue to work.
263  *
264  * POSIX/SUSv3 requires that its functions exist as functions (even if
265  * macro versions exist) and specifically that "#undef pthread_foo" is
266  * legal and should not break anything. Code that does such will not
267  * successfully get the stub behavior implemented here and will
268  * require libpthread to be linked in.
269  */
270 
271 #ifndef __LIBPTHREAD_SOURCE__
272 __BEGIN_DECLS
273 int	__libc_mutex_init(pthread_mutex_t * __restrict, const pthread_mutexattr_t * __restrict);
274 int	__libc_mutex_lock(pthread_mutex_t *);
275 int	__libc_mutex_trylock(pthread_mutex_t *);
276 int	__libc_mutex_unlock(pthread_mutex_t *);
277 int	__libc_mutex_destroy(pthread_mutex_t *);
278 
279 int	__libc_mutexattr_init(pthread_mutexattr_t *);
280 int	__libc_mutexattr_settype(pthread_mutexattr_t *, int);
281 int	__libc_mutexattr_destroy(pthread_mutexattr_t *);
282 __END_DECLS
283 
284 #define	pthread_mutex_init		__libc_mutex_init
285 #define	pthread_mutex_lock		__libc_mutex_lock
286 #define	pthread_mutex_trylock		__libc_mutex_trylock
287 #define	pthread_mutex_unlock		__libc_mutex_unlock
288 #define	pthread_mutex_destroy		__libc_mutex_destroy
289 
290 #define	pthread_mutexattr_init		__libc_mutexattr_init
291 #define	pthread_mutexattr_settype	__libc_mutexattr_settype
292 #define	pthread_mutexattr_destroy	__libc_mutexattr_destroy
293 
294 __BEGIN_DECLS
295 int	__libc_cond_init(pthread_cond_t * __restrict,
296 	    const pthread_condattr_t * __restrict);
297 int	__libc_cond_signal(pthread_cond_t *);
298 int	__libc_cond_broadcast(pthread_cond_t *);
299 int	__libc_cond_wait(pthread_cond_t * __restrict,
300 	    pthread_mutex_t * __restrict);
301 int	__libc_cond_timedwait(pthread_cond_t * __restrict,
302 	    pthread_mutex_t * __restrict, const struct timespec * __restrict);
303 int	__libc_cond_destroy(pthread_cond_t *);
304 __END_DECLS
305 
306 #define	pthread_cond_init	     	__libc_cond_init
307 #define	pthread_cond_signal		__libc_cond_signal
308 #define	pthread_cond_broadcast		__libc_cond_broadcast
309 #define	pthread_cond_wait		__libc_cond_wait
310 #define	pthread_cond_timedwait		__libc_cond_timedwait
311 #define	pthread_cond_destroy		__libc_cond_destroy
312 
313 __BEGIN_DECLS
314 int	__libc_rwlock_init(pthread_rwlock_t * __restrict,
315 	    const pthread_rwlockattr_t * __restrict);
316 int	__libc_rwlock_rdlock(pthread_rwlock_t *);
317 int	__libc_rwlock_wrlock(pthread_rwlock_t *);
318 int	__libc_rwlock_tryrdlock(pthread_rwlock_t *);
319 int	__libc_rwlock_trywrlock(pthread_rwlock_t *);
320 int	__libc_rwlock_unlock(pthread_rwlock_t *);
321 int	__libc_rwlock_destroy(pthread_rwlock_t *);
322 __END_DECLS
323 
324 #define	pthread_rwlock_init		__libc_rwlock_init
325 #define	pthread_rwlock_rdlock		__libc_rwlock_rdlock
326 #define	pthread_rwlock_wrlock		__libc_rwlock_wrlock
327 #define	pthread_rwlock_tryrdlock	__libc_rwlock_tryrdlock
328 #define	pthread_rwlock_trywrlock	__libc_rwlock_trywrlock
329 #define	pthread_rwlock_unlock		__libc_rwlock_unlock
330 #define	pthread_rwlock_destroy		__libc_rwlock_destroy
331 
332 __BEGIN_DECLS
333 int	__libc_thr_keycreate(pthread_key_t *, void (*)(void *));
334 int	__libc_thr_setspecific(pthread_key_t, const void *);
335 void	*__libc_thr_getspecific(pthread_key_t);
336 int	__libc_thr_keydelete(pthread_key_t);
337 __END_DECLS
338 
339 #define	pthread_key_create		__libc_thr_keycreate
340 #define	pthread_setspecific		__libc_thr_setspecific
341 #define	pthread_getspecific		__libc_thr_getspecific
342 #define	pthread_key_delete		__libc_thr_keydelete
343 
344 __BEGIN_DECLS
345 int	__libc_thr_once(pthread_once_t *, void (*)(void));
346 pthread_t	__libc_thr_self(void);
347 void	__libc_thr_exit(void *) __attribute__((__noreturn__));
348 int	__libc_thr_setcancelstate(int, int *);
349 __END_DECLS
350 
351 #define	pthread_once			__libc_thr_once
352 #define	pthread_self			__libc_thr_self
353 #define	pthread_exit			__libc_thr_exit
354 #define	pthread_setcancelstate		__libc_thr_setcancelstate
355 
356 #endif /* __LIBPTHREAD_SOURCE__ */
357 
358 #endif /* _LIB_PTHREAD_H */
359