]>
Commit | Line | Data |
---|---|---|
b168057a | 1 | /* Copyright (C) 2002-2015 Free Software Foundation, Inc. |
be0f2008 CD |
2 | This file is part of the GNU C Library. |
3 | ||
4 | The GNU C Library is free software; you can redistribute it and/or | |
5 | modify it under the terms of the GNU Lesser General Public | |
6 | License as published by the Free Software Foundation; either | |
7 | version 2.1 of the License, or (at your option) any later version. | |
8 | ||
9 | The GNU C Library is distributed in the hope that it will be useful, | |
10 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
12 | Lesser General Public License for more details. | |
13 | ||
14 | You should have received a copy of the GNU Lesser General Public | |
a64b8a46 CD |
15 | License along with the GNU C Library; if not, see |
16 | <http://www.gnu.org/licenses/>. */ | |
be0f2008 CD |
17 | |
18 | #ifndef _PTHREAD_H | |
19 | #define _PTHREAD_H 1 | |
20 | ||
21 | #include <features.h> | |
22 | #include <endian.h> | |
23 | #include <sched.h> | |
24 | #include <time.h> | |
25 | ||
be0f2008 CD |
26 | #include <bits/pthreadtypes.h> |
27 | #include <bits/setjmp.h> | |
28 | #include <bits/wordsize.h> | |
29 | ||
30 | ||
31 | /* Detach state. */ | |
32 | enum | |
33 | { | |
34 | PTHREAD_CREATE_JOINABLE, | |
35 | #define PTHREAD_CREATE_JOINABLE PTHREAD_CREATE_JOINABLE | |
36 | PTHREAD_CREATE_DETACHED | |
37 | #define PTHREAD_CREATE_DETACHED PTHREAD_CREATE_DETACHED | |
38 | }; | |
39 | ||
40 | ||
41 | /* Mutex types. */ | |
42 | enum | |
43 | { | |
44 | PTHREAD_MUTEX_TIMED_NP, | |
45 | PTHREAD_MUTEX_RECURSIVE_NP, | |
46 | PTHREAD_MUTEX_ERRORCHECK_NP, | |
47 | PTHREAD_MUTEX_ADAPTIVE_NP | |
c14e796f | 48 | #if defined __USE_UNIX98 || defined __USE_XOPEN2K8 |
be0f2008 CD |
49 | , |
50 | PTHREAD_MUTEX_NORMAL = PTHREAD_MUTEX_TIMED_NP, | |
51 | PTHREAD_MUTEX_RECURSIVE = PTHREAD_MUTEX_RECURSIVE_NP, | |
52 | PTHREAD_MUTEX_ERRORCHECK = PTHREAD_MUTEX_ERRORCHECK_NP, | |
53 | PTHREAD_MUTEX_DEFAULT = PTHREAD_MUTEX_NORMAL | |
54 | #endif | |
55 | #ifdef __USE_GNU | |
56 | /* For compatibility. */ | |
57 | , PTHREAD_MUTEX_FAST_NP = PTHREAD_MUTEX_TIMED_NP | |
58 | #endif | |
59 | }; | |
60 | ||
61 | ||
62 | #ifdef __USE_XOPEN2K | |
63 | /* Robust mutex or not flags. */ | |
64 | enum | |
65 | { | |
66 | PTHREAD_MUTEX_STALLED, | |
67 | PTHREAD_MUTEX_STALLED_NP = PTHREAD_MUTEX_STALLED, | |
68 | PTHREAD_MUTEX_ROBUST, | |
69 | PTHREAD_MUTEX_ROBUST_NP = PTHREAD_MUTEX_ROBUST | |
70 | }; | |
71 | #endif | |
72 | ||
73 | ||
a64b8a46 | 74 | #if defined __USE_POSIX199506 || defined __USE_UNIX98 |
be0f2008 CD |
75 | /* Mutex protocols. */ |
76 | enum | |
77 | { | |
78 | PTHREAD_PRIO_NONE, | |
79 | PTHREAD_PRIO_INHERIT, | |
80 | PTHREAD_PRIO_PROTECT | |
81 | }; | |
82 | #endif | |
83 | ||
84 | ||
85 | /* Mutex initializers. */ | |
9d9358f2 | 86 | #ifdef __PTHREAD_MUTEX_HAVE_PREV |
be0f2008 CD |
87 | # define PTHREAD_MUTEX_INITIALIZER \ |
88 | { { 0, 0, 0, 0, 0, 0, { 0, 0 } } } | |
89 | # ifdef __USE_GNU | |
90 | # define PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP \ | |
91 | { { 0, 0, 0, 0, PTHREAD_MUTEX_RECURSIVE_NP, 0, { 0, 0 } } } | |
92 | # define PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP \ | |
93 | { { 0, 0, 0, 0, PTHREAD_MUTEX_ERRORCHECK_NP, 0, { 0, 0 } } } | |
94 | # define PTHREAD_ADAPTIVE_MUTEX_INITIALIZER_NP \ | |
95 | { { 0, 0, 0, 0, PTHREAD_MUTEX_ADAPTIVE_NP, 0, { 0, 0 } } } | |
96 | # endif | |
97 | #else | |
98 | # define PTHREAD_MUTEX_INITIALIZER \ | |
99 | { { 0, 0, 0, 0, 0, { 0 } } } | |
100 | # ifdef __USE_GNU | |
101 | # define PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP \ | |
102 | { { 0, 0, 0, PTHREAD_MUTEX_RECURSIVE_NP, 0, { 0 } } } | |
103 | # define PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP \ | |
104 | { { 0, 0, 0, PTHREAD_MUTEX_ERRORCHECK_NP, 0, { 0 } } } | |
105 | # define PTHREAD_ADAPTIVE_MUTEX_INITIALIZER_NP \ | |
106 | { { 0, 0, 0, PTHREAD_MUTEX_ADAPTIVE_NP, 0, { 0 } } } | |
107 | # endif | |
108 | #endif | |
109 | ||
110 | ||
111 | /* Read-write lock types. */ | |
112 | #if defined __USE_UNIX98 || defined __USE_XOPEN2K | |
113 | enum | |
114 | { | |
115 | PTHREAD_RWLOCK_PREFER_READER_NP, | |
116 | PTHREAD_RWLOCK_PREFER_WRITER_NP, | |
117 | PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP, | |
118 | PTHREAD_RWLOCK_DEFAULT_NP = PTHREAD_RWLOCK_PREFER_READER_NP | |
119 | }; | |
120 | ||
9d9358f2 CD |
121 | /* Define __PTHREAD_RWLOCK_INT_FLAGS_SHARED to 1 if pthread_rwlock_t |
122 | has the shared field. All 64-bit architectures have the shared field | |
123 | in pthread_rwlock_t. */ | |
124 | #ifndef __PTHREAD_RWLOCK_INT_FLAGS_SHARED | |
125 | # if __WORDSIZE == 64 | |
126 | # define __PTHREAD_RWLOCK_INT_FLAGS_SHARED 1 | |
127 | # endif | |
128 | #endif | |
129 | ||
be0f2008 CD |
130 | /* Read-write lock initializers. */ |
131 | # define PTHREAD_RWLOCK_INITIALIZER \ | |
132 | { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } } | |
133 | # ifdef __USE_GNU | |
9d9358f2 | 134 | # ifdef __PTHREAD_RWLOCK_INT_FLAGS_SHARED |
be0f2008 CD |
135 | # define PTHREAD_RWLOCK_WRITER_NONRECURSIVE_INITIALIZER_NP \ |
136 | { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \ | |
137 | PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP } } | |
138 | # else | |
139 | # if __BYTE_ORDER == __LITTLE_ENDIAN | |
140 | # define PTHREAD_RWLOCK_WRITER_NONRECURSIVE_INITIALIZER_NP \ | |
141 | { { 0, 0, 0, 0, 0, 0, PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP, \ | |
142 | 0, 0, 0, 0 } } | |
143 | # else | |
144 | # define PTHREAD_RWLOCK_WRITER_NONRECURSIVE_INITIALIZER_NP \ | |
145 | { { 0, 0, 0, 0, 0, 0, 0, 0, 0, PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP,\ | |
146 | 0 } } | |
147 | # endif | |
148 | # endif | |
149 | # endif | |
150 | #endif /* Unix98 or XOpen2K */ | |
151 | ||
152 | ||
153 | /* Scheduler inheritance. */ | |
154 | enum | |
155 | { | |
156 | PTHREAD_INHERIT_SCHED, | |
157 | #define PTHREAD_INHERIT_SCHED PTHREAD_INHERIT_SCHED | |
158 | PTHREAD_EXPLICIT_SCHED | |
159 | #define PTHREAD_EXPLICIT_SCHED PTHREAD_EXPLICIT_SCHED | |
160 | }; | |
161 | ||
162 | ||
163 | /* Scope handling. */ | |
164 | enum | |
165 | { | |
166 | PTHREAD_SCOPE_SYSTEM, | |
167 | #define PTHREAD_SCOPE_SYSTEM PTHREAD_SCOPE_SYSTEM | |
168 | PTHREAD_SCOPE_PROCESS | |
169 | #define PTHREAD_SCOPE_PROCESS PTHREAD_SCOPE_PROCESS | |
170 | }; | |
171 | ||
172 | ||
173 | /* Process shared or private flag. */ | |
174 | enum | |
175 | { | |
176 | PTHREAD_PROCESS_PRIVATE, | |
177 | #define PTHREAD_PROCESS_PRIVATE PTHREAD_PROCESS_PRIVATE | |
178 | PTHREAD_PROCESS_SHARED | |
179 | #define PTHREAD_PROCESS_SHARED PTHREAD_PROCESS_SHARED | |
180 | }; | |
181 | ||
182 | ||
183 | ||
184 | /* Conditional variable handling. */ | |
185 | #define PTHREAD_COND_INITIALIZER { { 0, 0, 0, 0, 0, (void *) 0, 0, 0 } } | |
186 | ||
187 | ||
188 | /* Cleanup buffers */ | |
189 | struct _pthread_cleanup_buffer | |
190 | { | |
191 | void (*__routine) (void *); /* Function to call. */ | |
192 | void *__arg; /* Its argument. */ | |
193 | int __canceltype; /* Saved cancellation type. */ | |
194 | struct _pthread_cleanup_buffer *__prev; /* Chaining of cleanup functions. */ | |
195 | }; | |
196 | ||
197 | /* Cancellation */ | |
198 | enum | |
199 | { | |
200 | PTHREAD_CANCEL_ENABLE, | |
201 | #define PTHREAD_CANCEL_ENABLE PTHREAD_CANCEL_ENABLE | |
202 | PTHREAD_CANCEL_DISABLE | |
203 | #define PTHREAD_CANCEL_DISABLE PTHREAD_CANCEL_DISABLE | |
204 | }; | |
205 | enum | |
206 | { | |
207 | PTHREAD_CANCEL_DEFERRED, | |
208 | #define PTHREAD_CANCEL_DEFERRED PTHREAD_CANCEL_DEFERRED | |
209 | PTHREAD_CANCEL_ASYNCHRONOUS | |
210 | #define PTHREAD_CANCEL_ASYNCHRONOUS PTHREAD_CANCEL_ASYNCHRONOUS | |
211 | }; | |
212 | #define PTHREAD_CANCELED ((void *) -1) | |
213 | ||
214 | ||
215 | /* Single execution handling. */ | |
216 | #define PTHREAD_ONCE_INIT 0 | |
217 | ||
218 | ||
219 | #ifdef __USE_XOPEN2K | |
220 | /* Value returned by 'pthread_barrier_wait' for one of the threads after | |
221 | the required number of threads have called this function. | |
222 | -1 is distinct from 0 and all errno constants */ | |
223 | # define PTHREAD_BARRIER_SERIAL_THREAD -1 | |
224 | #endif | |
225 | ||
226 | ||
227 | __BEGIN_DECLS | |
228 | ||
229 | /* Create a new thread, starting with execution of START-ROUTINE | |
230 | getting passed ARG. Creation attributed come from ATTR. The new | |
231 | handle is stored in *NEWTHREAD. */ | |
232 | extern int pthread_create (pthread_t *__restrict __newthread, | |
c27dd89f | 233 | const pthread_attr_t *__restrict __attr, |
be0f2008 | 234 | void *(*__start_routine) (void *), |
c27dd89f | 235 | void *__restrict __arg) __THROWNL __nonnull ((1, 3)); |
be0f2008 CD |
236 | |
237 | /* Terminate calling thread. | |
238 | ||
239 | The registered cleanup handlers are called via exception handling | |
240 | so we cannot mark this function with __THROW.*/ | |
241 | extern void pthread_exit (void *__retval) __attribute__ ((__noreturn__)); | |
242 | ||
243 | /* Make calling thread wait for termination of the thread TH. The | |
244 | exit status of the thread is stored in *THREAD_RETURN, if THREAD_RETURN | |
245 | is not NULL. | |
246 | ||
247 | This function is a cancellation point and therefore not marked with | |
248 | __THROW. */ | |
249 | extern int pthread_join (pthread_t __th, void **__thread_return); | |
250 | ||
251 | #ifdef __USE_GNU | |
252 | /* Check whether thread TH has terminated. If yes return the status of | |
253 | the thread in *THREAD_RETURN, if THREAD_RETURN is not NULL. */ | |
254 | extern int pthread_tryjoin_np (pthread_t __th, void **__thread_return) __THROW; | |
255 | ||
256 | /* Make calling thread wait for termination of the thread TH, but only | |
257 | until TIMEOUT. The exit status of the thread is stored in | |
258 | *THREAD_RETURN, if THREAD_RETURN is not NULL. | |
259 | ||
260 | This function is a cancellation point and therefore not marked with | |
261 | __THROW. */ | |
262 | extern int pthread_timedjoin_np (pthread_t __th, void **__thread_return, | |
c27dd89f | 263 | const struct timespec *__abstime); |
be0f2008 CD |
264 | #endif |
265 | ||
266 | /* Indicate that the thread TH is never to be joined with PTHREAD_JOIN. | |
267 | The resources of TH will therefore be freed immediately when it | |
268 | terminates, instead of waiting for another thread to perform PTHREAD_JOIN | |
269 | on it. */ | |
270 | extern int pthread_detach (pthread_t __th) __THROW; | |
271 | ||
272 | ||
273 | /* Obtain the identifier of the current thread. */ | |
274 | extern pthread_t pthread_self (void) __THROW __attribute__ ((__const__)); | |
275 | ||
276 | /* Compare two thread identifiers. */ | |
a64b8a46 CD |
277 | extern int pthread_equal (pthread_t __thread1, pthread_t __thread2) |
278 | __THROW __attribute__ ((__const__)); | |
be0f2008 CD |
279 | |
280 | ||
281 | /* Thread attribute handling. */ | |
282 | ||
283 | /* Initialize thread attribute *ATTR with default attributes | |
284 | (detachstate is PTHREAD_JOINABLE, scheduling policy is SCHED_OTHER, | |
285 | no user-provided stack). */ | |
286 | extern int pthread_attr_init (pthread_attr_t *__attr) __THROW __nonnull ((1)); | |
287 | ||
288 | /* Destroy thread attribute *ATTR. */ | |
289 | extern int pthread_attr_destroy (pthread_attr_t *__attr) | |
290 | __THROW __nonnull ((1)); | |
291 | ||
292 | /* Get detach state attribute. */ | |
c27dd89f | 293 | extern int pthread_attr_getdetachstate (const pthread_attr_t *__attr, |
be0f2008 CD |
294 | int *__detachstate) |
295 | __THROW __nonnull ((1, 2)); | |
296 | ||
297 | /* Set detach state attribute. */ | |
298 | extern int pthread_attr_setdetachstate (pthread_attr_t *__attr, | |
299 | int __detachstate) | |
300 | __THROW __nonnull ((1)); | |
301 | ||
302 | ||
303 | /* Get the size of the guard area created for stack overflow protection. */ | |
c27dd89f | 304 | extern int pthread_attr_getguardsize (const pthread_attr_t *__attr, |
be0f2008 CD |
305 | size_t *__guardsize) |
306 | __THROW __nonnull ((1, 2)); | |
307 | ||
308 | /* Set the size of the guard area created for stack overflow protection. */ | |
309 | extern int pthread_attr_setguardsize (pthread_attr_t *__attr, | |
310 | size_t __guardsize) | |
311 | __THROW __nonnull ((1)); | |
312 | ||
313 | ||
314 | /* Return in *PARAM the scheduling parameters of *ATTR. */ | |
c27dd89f | 315 | extern int pthread_attr_getschedparam (const pthread_attr_t *__restrict __attr, |
be0f2008 CD |
316 | struct sched_param *__restrict __param) |
317 | __THROW __nonnull ((1, 2)); | |
318 | ||
319 | /* Set scheduling parameters (priority, etc) in *ATTR according to PARAM. */ | |
320 | extern int pthread_attr_setschedparam (pthread_attr_t *__restrict __attr, | |
c27dd89f | 321 | const struct sched_param *__restrict |
be0f2008 CD |
322 | __param) __THROW __nonnull ((1, 2)); |
323 | ||
324 | /* Return in *POLICY the scheduling policy of *ATTR. */ | |
c27dd89f | 325 | extern int pthread_attr_getschedpolicy (const pthread_attr_t *__restrict |
be0f2008 CD |
326 | __attr, int *__restrict __policy) |
327 | __THROW __nonnull ((1, 2)); | |
328 | ||
329 | /* Set scheduling policy in *ATTR according to POLICY. */ | |
330 | extern int pthread_attr_setschedpolicy (pthread_attr_t *__attr, int __policy) | |
331 | __THROW __nonnull ((1)); | |
332 | ||
333 | /* Return in *INHERIT the scheduling inheritance mode of *ATTR. */ | |
c27dd89f | 334 | extern int pthread_attr_getinheritsched (const pthread_attr_t *__restrict |
be0f2008 CD |
335 | __attr, int *__restrict __inherit) |
336 | __THROW __nonnull ((1, 2)); | |
337 | ||
338 | /* Set scheduling inheritance mode in *ATTR according to INHERIT. */ | |
339 | extern int pthread_attr_setinheritsched (pthread_attr_t *__attr, | |
340 | int __inherit) | |
341 | __THROW __nonnull ((1)); | |
342 | ||
343 | ||
344 | /* Return in *SCOPE the scheduling contention scope of *ATTR. */ | |
c27dd89f | 345 | extern int pthread_attr_getscope (const pthread_attr_t *__restrict __attr, |
be0f2008 CD |
346 | int *__restrict __scope) |
347 | __THROW __nonnull ((1, 2)); | |
348 | ||
349 | /* Set scheduling contention scope in *ATTR according to SCOPE. */ | |
350 | extern int pthread_attr_setscope (pthread_attr_t *__attr, int __scope) | |
351 | __THROW __nonnull ((1)); | |
352 | ||
353 | /* Return the previously set address for the stack. */ | |
c27dd89f | 354 | extern int pthread_attr_getstackaddr (const pthread_attr_t *__restrict |
be0f2008 CD |
355 | __attr, void **__restrict __stackaddr) |
356 | __THROW __nonnull ((1, 2)) __attribute_deprecated__; | |
357 | ||
358 | /* Set the starting address of the stack of the thread to be created. | |
359 | Depending on whether the stack grows up or down the value must either | |
360 | be higher or lower than all the address in the memory block. The | |
361 | minimal size of the block must be PTHREAD_STACK_MIN. */ | |
362 | extern int pthread_attr_setstackaddr (pthread_attr_t *__attr, | |
363 | void *__stackaddr) | |
364 | __THROW __nonnull ((1)) __attribute_deprecated__; | |
365 | ||
366 | /* Return the currently used minimal stack size. */ | |
c27dd89f | 367 | extern int pthread_attr_getstacksize (const pthread_attr_t *__restrict |
be0f2008 CD |
368 | __attr, size_t *__restrict __stacksize) |
369 | __THROW __nonnull ((1, 2)); | |
370 | ||
371 | /* Add information about the minimum stack size needed for the thread | |
372 | to be started. This size must never be less than PTHREAD_STACK_MIN | |
373 | and must also not exceed the system limits. */ | |
374 | extern int pthread_attr_setstacksize (pthread_attr_t *__attr, | |
375 | size_t __stacksize) | |
376 | __THROW __nonnull ((1)); | |
377 | ||
378 | #ifdef __USE_XOPEN2K | |
379 | /* Return the previously set address for the stack. */ | |
c27dd89f | 380 | extern int pthread_attr_getstack (const pthread_attr_t *__restrict __attr, |
be0f2008 CD |
381 | void **__restrict __stackaddr, |
382 | size_t *__restrict __stacksize) | |
383 | __THROW __nonnull ((1, 2, 3)); | |
384 | ||
385 | /* The following two interfaces are intended to replace the last two. They | |
386 | require setting the address as well as the size since only setting the | |
387 | address will make the implementation on some architectures impossible. */ | |
388 | extern int pthread_attr_setstack (pthread_attr_t *__attr, void *__stackaddr, | |
389 | size_t __stacksize) __THROW __nonnull ((1)); | |
390 | #endif | |
391 | ||
392 | #ifdef __USE_GNU | |
393 | /* Thread created with attribute ATTR will be limited to run only on | |
394 | the processors represented in CPUSET. */ | |
395 | extern int pthread_attr_setaffinity_np (pthread_attr_t *__attr, | |
396 | size_t __cpusetsize, | |
c27dd89f | 397 | const cpu_set_t *__cpuset) |
be0f2008 CD |
398 | __THROW __nonnull ((1, 3)); |
399 | ||
400 | /* Get bit set in CPUSET representing the processors threads created with | |
401 | ATTR can run on. */ | |
c27dd89f | 402 | extern int pthread_attr_getaffinity_np (const pthread_attr_t *__attr, |
be0f2008 CD |
403 | size_t __cpusetsize, |
404 | cpu_set_t *__cpuset) | |
405 | __THROW __nonnull ((1, 3)); | |
406 | ||
407 | ||
408 | /* Initialize thread attribute *ATTR with attributes corresponding to the | |
409 | already running thread TH. It shall be called on uninitialized ATTR | |
410 | and destroyed with pthread_attr_destroy when no longer needed. */ | |
411 | extern int pthread_getattr_np (pthread_t __th, pthread_attr_t *__attr) | |
412 | __THROW __nonnull ((2)); | |
413 | #endif | |
414 | ||
415 | ||
416 | /* Functions for scheduling control. */ | |
417 | ||
418 | /* Set the scheduling parameters for TARGET_THREAD according to POLICY | |
419 | and *PARAM. */ | |
420 | extern int pthread_setschedparam (pthread_t __target_thread, int __policy, | |
c27dd89f | 421 | const struct sched_param *__param) |
be0f2008 CD |
422 | __THROW __nonnull ((3)); |
423 | ||
424 | /* Return in *POLICY and *PARAM the scheduling parameters for TARGET_THREAD. */ | |
425 | extern int pthread_getschedparam (pthread_t __target_thread, | |
426 | int *__restrict __policy, | |
427 | struct sched_param *__restrict __param) | |
428 | __THROW __nonnull ((2, 3)); | |
429 | ||
430 | /* Set the scheduling priority for TARGET_THREAD. */ | |
431 | extern int pthread_setschedprio (pthread_t __target_thread, int __prio) | |
432 | __THROW; | |
433 | ||
434 | ||
c14e796f AS |
435 | #ifdef __USE_GNU |
436 | /* Get thread name visible in the kernel and its interfaces. */ | |
437 | extern int pthread_getname_np (pthread_t __target_thread, char *__buf, | |
438 | size_t __buflen) | |
439 | __THROW __nonnull ((2)); | |
440 | ||
441 | /* Set thread name visible in the kernel and its interfaces. */ | |
c27dd89f | 442 | extern int pthread_setname_np (pthread_t __target_thread, const char *__name) |
c14e796f AS |
443 | __THROW __nonnull ((2)); |
444 | #endif | |
445 | ||
446 | ||
be0f2008 CD |
447 | #ifdef __USE_UNIX98 |
448 | /* Determine level of concurrency. */ | |
449 | extern int pthread_getconcurrency (void) __THROW; | |
450 | ||
451 | /* Set new concurrency level to LEVEL. */ | |
452 | extern int pthread_setconcurrency (int __level) __THROW; | |
453 | #endif | |
454 | ||
455 | #ifdef __USE_GNU | |
456 | /* Yield the processor to another thread or process. | |
457 | This function is similar to the POSIX `sched_yield' function but | |
458 | might be differently implemented in the case of a m-on-n thread | |
459 | implementation. */ | |
460 | extern int pthread_yield (void) __THROW; | |
461 | ||
462 | ||
463 | /* Limit specified thread TH to run only on the processors represented | |
464 | in CPUSET. */ | |
465 | extern int pthread_setaffinity_np (pthread_t __th, size_t __cpusetsize, | |
c27dd89f | 466 | const cpu_set_t *__cpuset) |
be0f2008 CD |
467 | __THROW __nonnull ((3)); |
468 | ||
469 | /* Get bit set in CPUSET representing the processors TH can run on. */ | |
470 | extern int pthread_getaffinity_np (pthread_t __th, size_t __cpusetsize, | |
471 | cpu_set_t *__cpuset) | |
472 | __THROW __nonnull ((3)); | |
473 | #endif | |
474 | ||
475 | ||
476 | /* Functions for handling initialization. */ | |
477 | ||
478 | /* Guarantee that the initialization function INIT_ROUTINE will be called | |
479 | only once, even if pthread_once is executed several times with the | |
480 | same ONCE_CONTROL argument. ONCE_CONTROL must point to a static or | |
481 | extern variable initialized to PTHREAD_ONCE_INIT. | |
482 | ||
483 | The initialization functions might throw exception which is why | |
484 | this function is not marked with __THROW. */ | |
485 | extern int pthread_once (pthread_once_t *__once_control, | |
486 | void (*__init_routine) (void)) __nonnull ((1, 2)); | |
487 | ||
488 | ||
489 | /* Functions for handling cancellation. | |
490 | ||
491 | Note that these functions are explicitly not marked to not throw an | |
492 | exception in C++ code. If cancellation is implemented by unwinding | |
493 | this is necessary to have the compiler generate the unwind information. */ | |
494 | ||
495 | /* Set cancelability state of current thread to STATE, returning old | |
496 | state in *OLDSTATE if OLDSTATE is not NULL. */ | |
497 | extern int pthread_setcancelstate (int __state, int *__oldstate); | |
498 | ||
499 | /* Set cancellation state of current thread to TYPE, returning the old | |
500 | type in *OLDTYPE if OLDTYPE is not NULL. */ | |
501 | extern int pthread_setcanceltype (int __type, int *__oldtype); | |
502 | ||
503 | /* Cancel THREAD immediately or at the next possibility. */ | |
504 | extern int pthread_cancel (pthread_t __th); | |
505 | ||
506 | /* Test for pending cancellation for the current thread and terminate | |
507 | the thread as per pthread_exit(PTHREAD_CANCELED) if it has been | |
508 | cancelled. */ | |
509 | extern void pthread_testcancel (void); | |
510 | ||
511 | ||
512 | /* Cancellation handling with integration into exception handling. */ | |
513 | ||
514 | typedef struct | |
515 | { | |
516 | struct | |
517 | { | |
518 | __jmp_buf __cancel_jmp_buf; | |
519 | int __mask_was_saved; | |
520 | } __cancel_jmp_buf[1]; | |
521 | void *__pad[4]; | |
522 | } __pthread_unwind_buf_t __attribute__ ((__aligned__)); | |
523 | ||
524 | /* No special attributes by default. */ | |
525 | #ifndef __cleanup_fct_attribute | |
526 | # define __cleanup_fct_attribute | |
527 | #endif | |
528 | ||
529 | ||
530 | /* Structure to hold the cleanup handler information. */ | |
531 | struct __pthread_cleanup_frame | |
532 | { | |
533 | void (*__cancel_routine) (void *); | |
534 | void *__cancel_arg; | |
535 | int __do_it; | |
536 | int __cancel_type; | |
537 | }; | |
538 | ||
539 | #if defined __GNUC__ && defined __EXCEPTIONS | |
540 | # ifdef __cplusplus | |
541 | /* Class to handle cancellation handler invocation. */ | |
542 | class __pthread_cleanup_class | |
543 | { | |
544 | void (*__cancel_routine) (void *); | |
545 | void *__cancel_arg; | |
546 | int __do_it; | |
547 | int __cancel_type; | |
548 | ||
549 | public: | |
550 | __pthread_cleanup_class (void (*__fct) (void *), void *__arg) | |
551 | : __cancel_routine (__fct), __cancel_arg (__arg), __do_it (1) { } | |
552 | ~__pthread_cleanup_class () { if (__do_it) __cancel_routine (__cancel_arg); } | |
553 | void __setdoit (int __newval) { __do_it = __newval; } | |
554 | void __defer () { pthread_setcanceltype (PTHREAD_CANCEL_DEFERRED, | |
555 | &__cancel_type); } | |
556 | void __restore () const { pthread_setcanceltype (__cancel_type, 0); } | |
557 | }; | |
558 | ||
559 | /* Install a cleanup handler: ROUTINE will be called with arguments ARG | |
560 | when the thread is canceled or calls pthread_exit. ROUTINE will also | |
561 | be called with arguments ARG when the matching pthread_cleanup_pop | |
562 | is executed with non-zero EXECUTE argument. | |
563 | ||
564 | pthread_cleanup_push and pthread_cleanup_pop are macros and must always | |
565 | be used in matching pairs at the same nesting level of braces. */ | |
566 | # define pthread_cleanup_push(routine, arg) \ | |
567 | do { \ | |
568 | __pthread_cleanup_class __clframe (routine, arg) | |
569 | ||
570 | /* Remove a cleanup handler installed by the matching pthread_cleanup_push. | |
571 | If EXECUTE is non-zero, the handler function is called. */ | |
572 | # define pthread_cleanup_pop(execute) \ | |
573 | __clframe.__setdoit (execute); \ | |
574 | } while (0) | |
575 | ||
576 | # ifdef __USE_GNU | |
577 | /* Install a cleanup handler as pthread_cleanup_push does, but also | |
578 | saves the current cancellation type and sets it to deferred | |
579 | cancellation. */ | |
580 | # define pthread_cleanup_push_defer_np(routine, arg) \ | |
581 | do { \ | |
582 | __pthread_cleanup_class __clframe (routine, arg); \ | |
583 | __clframe.__defer () | |
584 | ||
585 | /* Remove a cleanup handler as pthread_cleanup_pop does, but also | |
586 | restores the cancellation type that was in effect when the matching | |
587 | pthread_cleanup_push_defer was called. */ | |
588 | # define pthread_cleanup_pop_restore_np(execute) \ | |
589 | __clframe.__restore (); \ | |
590 | __clframe.__setdoit (execute); \ | |
591 | } while (0) | |
592 | # endif | |
593 | # else | |
594 | /* Function called to call the cleanup handler. As an extern inline | |
595 | function the compiler is free to decide inlining the change when | |
596 | needed or fall back on the copy which must exist somewhere | |
597 | else. */ | |
598 | __extern_inline void | |
599 | __pthread_cleanup_routine (struct __pthread_cleanup_frame *__frame) | |
600 | { | |
601 | if (__frame->__do_it) | |
602 | __frame->__cancel_routine (__frame->__cancel_arg); | |
603 | } | |
604 | ||
605 | /* Install a cleanup handler: ROUTINE will be called with arguments ARG | |
606 | when the thread is canceled or calls pthread_exit. ROUTINE will also | |
607 | be called with arguments ARG when the matching pthread_cleanup_pop | |
608 | is executed with non-zero EXECUTE argument. | |
609 | ||
610 | pthread_cleanup_push and pthread_cleanup_pop are macros and must always | |
611 | be used in matching pairs at the same nesting level of braces. */ | |
612 | # define pthread_cleanup_push(routine, arg) \ | |
613 | do { \ | |
614 | struct __pthread_cleanup_frame __clframe \ | |
615 | __attribute__ ((__cleanup__ (__pthread_cleanup_routine))) \ | |
616 | = { .__cancel_routine = (routine), .__cancel_arg = (arg), \ | |
617 | .__do_it = 1 }; | |
618 | ||
619 | /* Remove a cleanup handler installed by the matching pthread_cleanup_push. | |
620 | If EXECUTE is non-zero, the handler function is called. */ | |
621 | # define pthread_cleanup_pop(execute) \ | |
622 | __clframe.__do_it = (execute); \ | |
623 | } while (0) | |
624 | ||
625 | # ifdef __USE_GNU | |
626 | /* Install a cleanup handler as pthread_cleanup_push does, but also | |
627 | saves the current cancellation type and sets it to deferred | |
628 | cancellation. */ | |
629 | # define pthread_cleanup_push_defer_np(routine, arg) \ | |
630 | do { \ | |
631 | struct __pthread_cleanup_frame __clframe \ | |
632 | __attribute__ ((__cleanup__ (__pthread_cleanup_routine))) \ | |
633 | = { .__cancel_routine = (routine), .__cancel_arg = (arg), \ | |
634 | .__do_it = 1 }; \ | |
635 | (void) pthread_setcanceltype (PTHREAD_CANCEL_DEFERRED, \ | |
636 | &__clframe.__cancel_type) | |
637 | ||
638 | /* Remove a cleanup handler as pthread_cleanup_pop does, but also | |
639 | restores the cancellation type that was in effect when the matching | |
640 | pthread_cleanup_push_defer was called. */ | |
641 | # define pthread_cleanup_pop_restore_np(execute) \ | |
642 | (void) pthread_setcanceltype (__clframe.__cancel_type, NULL); \ | |
643 | __clframe.__do_it = (execute); \ | |
644 | } while (0) | |
645 | # endif | |
646 | # endif | |
647 | #else | |
648 | /* Install a cleanup handler: ROUTINE will be called with arguments ARG | |
649 | when the thread is canceled or calls pthread_exit. ROUTINE will also | |
650 | be called with arguments ARG when the matching pthread_cleanup_pop | |
651 | is executed with non-zero EXECUTE argument. | |
652 | ||
653 | pthread_cleanup_push and pthread_cleanup_pop are macros and must always | |
654 | be used in matching pairs at the same nesting level of braces. */ | |
655 | # define pthread_cleanup_push(routine, arg) \ | |
656 | do { \ | |
657 | __pthread_unwind_buf_t __cancel_buf; \ | |
658 | void (*__cancel_routine) (void *) = (routine); \ | |
659 | void *__cancel_arg = (arg); \ | |
c27dd89f CD |
660 | int __not_first_call = __sigsetjmp ((struct __jmp_buf_tag *) (void *) \ |
661 | __cancel_buf.__cancel_jmp_buf, 0); \ | |
9d9358f2 | 662 | if (__glibc_unlikely (__not_first_call)) \ |
be0f2008 CD |
663 | { \ |
664 | __cancel_routine (__cancel_arg); \ | |
665 | __pthread_unwind_next (&__cancel_buf); \ | |
666 | /* NOTREACHED */ \ | |
667 | } \ | |
668 | \ | |
669 | __pthread_register_cancel (&__cancel_buf); \ | |
670 | do { | |
671 | extern void __pthread_register_cancel (__pthread_unwind_buf_t *__buf) | |
672 | __cleanup_fct_attribute; | |
673 | ||
674 | /* Remove a cleanup handler installed by the matching pthread_cleanup_push. | |
675 | If EXECUTE is non-zero, the handler function is called. */ | |
676 | # define pthread_cleanup_pop(execute) \ | |
677 | do { } while (0);/* Empty to allow label before pthread_cleanup_pop. */\ | |
678 | } while (0); \ | |
679 | __pthread_unregister_cancel (&__cancel_buf); \ | |
680 | if (execute) \ | |
681 | __cancel_routine (__cancel_arg); \ | |
682 | } while (0) | |
683 | extern void __pthread_unregister_cancel (__pthread_unwind_buf_t *__buf) | |
684 | __cleanup_fct_attribute; | |
685 | ||
686 | # ifdef __USE_GNU | |
687 | /* Install a cleanup handler as pthread_cleanup_push does, but also | |
688 | saves the current cancellation type and sets it to deferred | |
689 | cancellation. */ | |
690 | # define pthread_cleanup_push_defer_np(routine, arg) \ | |
691 | do { \ | |
692 | __pthread_unwind_buf_t __cancel_buf; \ | |
693 | void (*__cancel_routine) (void *) = (routine); \ | |
694 | void *__cancel_arg = (arg); \ | |
c27dd89f CD |
695 | int __not_first_call = __sigsetjmp ((struct __jmp_buf_tag *) (void *) \ |
696 | __cancel_buf.__cancel_jmp_buf, 0); \ | |
9d9358f2 | 697 | if (__glibc_unlikely (__not_first_call)) \ |
be0f2008 CD |
698 | { \ |
699 | __cancel_routine (__cancel_arg); \ | |
700 | __pthread_unwind_next (&__cancel_buf); \ | |
701 | /* NOTREACHED */ \ | |
702 | } \ | |
703 | \ | |
704 | __pthread_register_cancel_defer (&__cancel_buf); \ | |
705 | do { | |
706 | extern void __pthread_register_cancel_defer (__pthread_unwind_buf_t *__buf) | |
707 | __cleanup_fct_attribute; | |
708 | ||
709 | /* Remove a cleanup handler as pthread_cleanup_pop does, but also | |
710 | restores the cancellation type that was in effect when the matching | |
711 | pthread_cleanup_push_defer was called. */ | |
712 | # define pthread_cleanup_pop_restore_np(execute) \ | |
713 | do { } while (0);/* Empty to allow label before pthread_cleanup_pop. */\ | |
714 | } while (0); \ | |
715 | __pthread_unregister_cancel_restore (&__cancel_buf); \ | |
716 | if (execute) \ | |
717 | __cancel_routine (__cancel_arg); \ | |
718 | } while (0) | |
719 | extern void __pthread_unregister_cancel_restore (__pthread_unwind_buf_t *__buf) | |
720 | __cleanup_fct_attribute; | |
721 | # endif | |
722 | ||
723 | /* Internal interface to initiate cleanup. */ | |
724 | extern void __pthread_unwind_next (__pthread_unwind_buf_t *__buf) | |
725 | __cleanup_fct_attribute __attribute__ ((__noreturn__)) | |
726 | # ifndef SHARED | |
727 | __attribute__ ((__weak__)) | |
728 | # endif | |
729 | ; | |
730 | #endif | |
731 | ||
732 | /* Function used in the macros. */ | |
733 | struct __jmp_buf_tag; | |
9d9358f2 | 734 | extern int __sigsetjmp (struct __jmp_buf_tag *__env, int __savemask) __THROWNL; |
be0f2008 CD |
735 | |
736 | ||
737 | /* Mutex handling. */ | |
738 | ||
739 | /* Initialize a mutex. */ | |
740 | extern int pthread_mutex_init (pthread_mutex_t *__mutex, | |
c27dd89f | 741 | const pthread_mutexattr_t *__mutexattr) |
be0f2008 CD |
742 | __THROW __nonnull ((1)); |
743 | ||
744 | /* Destroy a mutex. */ | |
745 | extern int pthread_mutex_destroy (pthread_mutex_t *__mutex) | |
746 | __THROW __nonnull ((1)); | |
747 | ||
748 | /* Try locking a mutex. */ | |
749 | extern int pthread_mutex_trylock (pthread_mutex_t *__mutex) | |
c27dd89f | 750 | __THROWNL __nonnull ((1)); |
be0f2008 CD |
751 | |
752 | /* Lock a mutex. */ | |
753 | extern int pthread_mutex_lock (pthread_mutex_t *__mutex) | |
c27dd89f | 754 | __THROWNL __nonnull ((1)); |
be0f2008 CD |
755 | |
756 | #ifdef __USE_XOPEN2K | |
757 | /* Wait until lock becomes available, or specified time passes. */ | |
758 | extern int pthread_mutex_timedlock (pthread_mutex_t *__restrict __mutex, | |
c27dd89f CD |
759 | const struct timespec *__restrict |
760 | __abstime) __THROWNL __nonnull ((1, 2)); | |
be0f2008 CD |
761 | #endif |
762 | ||
763 | /* Unlock a mutex. */ | |
764 | extern int pthread_mutex_unlock (pthread_mutex_t *__mutex) | |
c27dd89f | 765 | __THROWNL __nonnull ((1)); |
be0f2008 CD |
766 | |
767 | ||
be0f2008 | 768 | /* Get the priority ceiling of MUTEX. */ |
c27dd89f | 769 | extern int pthread_mutex_getprioceiling (const pthread_mutex_t * |
be0f2008 CD |
770 | __restrict __mutex, |
771 | int *__restrict __prioceiling) | |
772 | __THROW __nonnull ((1, 2)); | |
773 | ||
774 | /* Set the priority ceiling of MUTEX to PRIOCEILING, return old | |
775 | priority ceiling value in *OLD_CEILING. */ | |
776 | extern int pthread_mutex_setprioceiling (pthread_mutex_t *__restrict __mutex, | |
777 | int __prioceiling, | |
778 | int *__restrict __old_ceiling) | |
779 | __THROW __nonnull ((1, 3)); | |
be0f2008 CD |
780 | |
781 | ||
782 | #ifdef __USE_XOPEN2K8 | |
783 | /* Declare the state protected by MUTEX as consistent. */ | |
c14e796f | 784 | extern int pthread_mutex_consistent (pthread_mutex_t *__mutex) |
be0f2008 CD |
785 | __THROW __nonnull ((1)); |
786 | # ifdef __USE_GNU | |
787 | extern int pthread_mutex_consistent_np (pthread_mutex_t *__mutex) | |
788 | __THROW __nonnull ((1)); | |
789 | # endif | |
790 | #endif | |
791 | ||
792 | ||
793 | /* Functions for handling mutex attributes. */ | |
794 | ||
795 | /* Initialize mutex attribute object ATTR with default attributes | |
796 | (kind is PTHREAD_MUTEX_TIMED_NP). */ | |
797 | extern int pthread_mutexattr_init (pthread_mutexattr_t *__attr) | |
798 | __THROW __nonnull ((1)); | |
799 | ||
800 | /* Destroy mutex attribute object ATTR. */ | |
801 | extern int pthread_mutexattr_destroy (pthread_mutexattr_t *__attr) | |
802 | __THROW __nonnull ((1)); | |
803 | ||
804 | /* Get the process-shared flag of the mutex attribute ATTR. */ | |
c27dd89f | 805 | extern int pthread_mutexattr_getpshared (const pthread_mutexattr_t * |
be0f2008 CD |
806 | __restrict __attr, |
807 | int *__restrict __pshared) | |
808 | __THROW __nonnull ((1, 2)); | |
809 | ||
810 | /* Set the process-shared flag of the mutex attribute ATTR. */ | |
811 | extern int pthread_mutexattr_setpshared (pthread_mutexattr_t *__attr, | |
812 | int __pshared) | |
813 | __THROW __nonnull ((1)); | |
814 | ||
c14e796f | 815 | #if defined __USE_UNIX98 || defined __USE_XOPEN2K8 |
be0f2008 | 816 | /* Return in *KIND the mutex kind attribute in *ATTR. */ |
c27dd89f | 817 | extern int pthread_mutexattr_gettype (const pthread_mutexattr_t *__restrict |
be0f2008 CD |
818 | __attr, int *__restrict __kind) |
819 | __THROW __nonnull ((1, 2)); | |
820 | ||
821 | /* Set the mutex kind attribute in *ATTR to KIND (either PTHREAD_MUTEX_NORMAL, | |
822 | PTHREAD_MUTEX_RECURSIVE, PTHREAD_MUTEX_ERRORCHECK, or | |
823 | PTHREAD_MUTEX_DEFAULT). */ | |
824 | extern int pthread_mutexattr_settype (pthread_mutexattr_t *__attr, int __kind) | |
825 | __THROW __nonnull ((1)); | |
c14e796f | 826 | #endif |
be0f2008 CD |
827 | |
828 | /* Return in *PROTOCOL the mutex protocol attribute in *ATTR. */ | |
c27dd89f | 829 | extern int pthread_mutexattr_getprotocol (const pthread_mutexattr_t * |
be0f2008 CD |
830 | __restrict __attr, |
831 | int *__restrict __protocol) | |
832 | __THROW __nonnull ((1, 2)); | |
833 | ||
834 | /* Set the mutex protocol attribute in *ATTR to PROTOCOL (either | |
835 | PTHREAD_PRIO_NONE, PTHREAD_PRIO_INHERIT, or PTHREAD_PRIO_PROTECT). */ | |
836 | extern int pthread_mutexattr_setprotocol (pthread_mutexattr_t *__attr, | |
837 | int __protocol) | |
838 | __THROW __nonnull ((1)); | |
839 | ||
840 | /* Return in *PRIOCEILING the mutex prioceiling attribute in *ATTR. */ | |
c27dd89f | 841 | extern int pthread_mutexattr_getprioceiling (const pthread_mutexattr_t * |
be0f2008 CD |
842 | __restrict __attr, |
843 | int *__restrict __prioceiling) | |
844 | __THROW __nonnull ((1, 2)); | |
845 | ||
846 | /* Set the mutex prioceiling attribute in *ATTR to PRIOCEILING. */ | |
847 | extern int pthread_mutexattr_setprioceiling (pthread_mutexattr_t *__attr, | |
848 | int __prioceiling) | |
849 | __THROW __nonnull ((1)); | |
be0f2008 CD |
850 | |
851 | #ifdef __USE_XOPEN2K | |
852 | /* Get the robustness flag of the mutex attribute ATTR. */ | |
c27dd89f | 853 | extern int pthread_mutexattr_getrobust (const pthread_mutexattr_t *__attr, |
be0f2008 CD |
854 | int *__robustness) |
855 | __THROW __nonnull ((1, 2)); | |
856 | # ifdef __USE_GNU | |
c27dd89f | 857 | extern int pthread_mutexattr_getrobust_np (const pthread_mutexattr_t *__attr, |
be0f2008 CD |
858 | int *__robustness) |
859 | __THROW __nonnull ((1, 2)); | |
860 | # endif | |
861 | ||
862 | /* Set the robustness flag of the mutex attribute ATTR. */ | |
863 | extern int pthread_mutexattr_setrobust (pthread_mutexattr_t *__attr, | |
864 | int __robustness) | |
865 | __THROW __nonnull ((1)); | |
866 | # ifdef __USE_GNU | |
867 | extern int pthread_mutexattr_setrobust_np (pthread_mutexattr_t *__attr, | |
868 | int __robustness) | |
869 | __THROW __nonnull ((1)); | |
870 | # endif | |
871 | #endif | |
872 | ||
873 | ||
874 | #if defined __USE_UNIX98 || defined __USE_XOPEN2K | |
875 | /* Functions for handling read-write locks. */ | |
876 | ||
877 | /* Initialize read-write lock RWLOCK using attributes ATTR, or use | |
878 | the default values if later is NULL. */ | |
879 | extern int pthread_rwlock_init (pthread_rwlock_t *__restrict __rwlock, | |
c27dd89f | 880 | const pthread_rwlockattr_t *__restrict |
be0f2008 CD |
881 | __attr) __THROW __nonnull ((1)); |
882 | ||
883 | /* Destroy read-write lock RWLOCK. */ | |
884 | extern int pthread_rwlock_destroy (pthread_rwlock_t *__rwlock) | |
885 | __THROW __nonnull ((1)); | |
886 | ||
887 | /* Acquire read lock for RWLOCK. */ | |
888 | extern int pthread_rwlock_rdlock (pthread_rwlock_t *__rwlock) | |
c27dd89f | 889 | __THROWNL __nonnull ((1)); |
be0f2008 CD |
890 | |
891 | /* Try to acquire read lock for RWLOCK. */ | |
892 | extern int pthread_rwlock_tryrdlock (pthread_rwlock_t *__rwlock) | |
c27dd89f | 893 | __THROWNL __nonnull ((1)); |
be0f2008 CD |
894 | |
895 | # ifdef __USE_XOPEN2K | |
896 | /* Try to acquire read lock for RWLOCK or return after specfied time. */ | |
897 | extern int pthread_rwlock_timedrdlock (pthread_rwlock_t *__restrict __rwlock, | |
c27dd89f CD |
898 | const struct timespec *__restrict |
899 | __abstime) __THROWNL __nonnull ((1, 2)); | |
be0f2008 CD |
900 | # endif |
901 | ||
902 | /* Acquire write lock for RWLOCK. */ | |
903 | extern int pthread_rwlock_wrlock (pthread_rwlock_t *__rwlock) | |
c27dd89f | 904 | __THROWNL __nonnull ((1)); |
be0f2008 CD |
905 | |
906 | /* Try to acquire write lock for RWLOCK. */ | |
907 | extern int pthread_rwlock_trywrlock (pthread_rwlock_t *__rwlock) | |
c27dd89f | 908 | __THROWNL __nonnull ((1)); |
be0f2008 CD |
909 | |
910 | # ifdef __USE_XOPEN2K | |
911 | /* Try to acquire write lock for RWLOCK or return after specfied time. */ | |
912 | extern int pthread_rwlock_timedwrlock (pthread_rwlock_t *__restrict __rwlock, | |
c27dd89f CD |
913 | const struct timespec *__restrict |
914 | __abstime) __THROWNL __nonnull ((1, 2)); | |
be0f2008 CD |
915 | # endif |
916 | ||
917 | /* Unlock RWLOCK. */ | |
918 | extern int pthread_rwlock_unlock (pthread_rwlock_t *__rwlock) | |
c27dd89f | 919 | __THROWNL __nonnull ((1)); |
be0f2008 CD |
920 | |
921 | ||
922 | /* Functions for handling read-write lock attributes. */ | |
923 | ||
924 | /* Initialize attribute object ATTR with default values. */ | |
925 | extern int pthread_rwlockattr_init (pthread_rwlockattr_t *__attr) | |
926 | __THROW __nonnull ((1)); | |
927 | ||
928 | /* Destroy attribute object ATTR. */ | |
929 | extern int pthread_rwlockattr_destroy (pthread_rwlockattr_t *__attr) | |
930 | __THROW __nonnull ((1)); | |
931 | ||
932 | /* Return current setting of process-shared attribute of ATTR in PSHARED. */ | |
c27dd89f | 933 | extern int pthread_rwlockattr_getpshared (const pthread_rwlockattr_t * |
be0f2008 CD |
934 | __restrict __attr, |
935 | int *__restrict __pshared) | |
936 | __THROW __nonnull ((1, 2)); | |
937 | ||
938 | /* Set process-shared attribute of ATTR to PSHARED. */ | |
939 | extern int pthread_rwlockattr_setpshared (pthread_rwlockattr_t *__attr, | |
940 | int __pshared) | |
941 | __THROW __nonnull ((1)); | |
942 | ||
943 | /* Return current setting of reader/writer preference. */ | |
c27dd89f | 944 | extern int pthread_rwlockattr_getkind_np (const pthread_rwlockattr_t * |
be0f2008 CD |
945 | __restrict __attr, |
946 | int *__restrict __pref) | |
947 | __THROW __nonnull ((1, 2)); | |
948 | ||
949 | /* Set reader/write preference. */ | |
950 | extern int pthread_rwlockattr_setkind_np (pthread_rwlockattr_t *__attr, | |
951 | int __pref) __THROW __nonnull ((1)); | |
952 | #endif | |
953 | ||
954 | ||
955 | /* Functions for handling conditional variables. */ | |
956 | ||
957 | /* Initialize condition variable COND using attributes ATTR, or use | |
958 | the default values if later is NULL. */ | |
959 | extern int pthread_cond_init (pthread_cond_t *__restrict __cond, | |
c27dd89f CD |
960 | const pthread_condattr_t *__restrict __cond_attr) |
961 | __THROW __nonnull ((1)); | |
be0f2008 CD |
962 | |
963 | /* Destroy condition variable COND. */ | |
964 | extern int pthread_cond_destroy (pthread_cond_t *__cond) | |
965 | __THROW __nonnull ((1)); | |
966 | ||
967 | /* Wake up one thread waiting for condition variable COND. */ | |
968 | extern int pthread_cond_signal (pthread_cond_t *__cond) | |
c27dd89f | 969 | __THROWNL __nonnull ((1)); |
be0f2008 CD |
970 | |
971 | /* Wake up all threads waiting for condition variables COND. */ | |
972 | extern int pthread_cond_broadcast (pthread_cond_t *__cond) | |
c27dd89f | 973 | __THROWNL __nonnull ((1)); |
be0f2008 CD |
974 | |
975 | /* Wait for condition variable COND to be signaled or broadcast. | |
976 | MUTEX is assumed to be locked before. | |
977 | ||
978 | This function is a cancellation point and therefore not marked with | |
979 | __THROW. */ | |
980 | extern int pthread_cond_wait (pthread_cond_t *__restrict __cond, | |
981 | pthread_mutex_t *__restrict __mutex) | |
982 | __nonnull ((1, 2)); | |
983 | ||
984 | /* Wait for condition variable COND to be signaled or broadcast until | |
985 | ABSTIME. MUTEX is assumed to be locked before. ABSTIME is an | |
986 | absolute time specification; zero is the beginning of the epoch | |
987 | (00:00:00 GMT, January 1, 1970). | |
988 | ||
989 | This function is a cancellation point and therefore not marked with | |
990 | __THROW. */ | |
991 | extern int pthread_cond_timedwait (pthread_cond_t *__restrict __cond, | |
992 | pthread_mutex_t *__restrict __mutex, | |
c27dd89f CD |
993 | const struct timespec *__restrict __abstime) |
994 | __nonnull ((1, 2, 3)); | |
be0f2008 CD |
995 | |
996 | /* Functions for handling condition variable attributes. */ | |
997 | ||
998 | /* Initialize condition variable attribute ATTR. */ | |
999 | extern int pthread_condattr_init (pthread_condattr_t *__attr) | |
1000 | __THROW __nonnull ((1)); | |
1001 | ||
1002 | /* Destroy condition variable attribute ATTR. */ | |
1003 | extern int pthread_condattr_destroy (pthread_condattr_t *__attr) | |
1004 | __THROW __nonnull ((1)); | |
1005 | ||
1006 | /* Get the process-shared flag of the condition variable attribute ATTR. */ | |
c27dd89f | 1007 | extern int pthread_condattr_getpshared (const pthread_condattr_t * |
c14e796f AS |
1008 | __restrict __attr, |
1009 | int *__restrict __pshared) | |
be0f2008 CD |
1010 | __THROW __nonnull ((1, 2)); |
1011 | ||
1012 | /* Set the process-shared flag of the condition variable attribute ATTR. */ | |
1013 | extern int pthread_condattr_setpshared (pthread_condattr_t *__attr, | |
c14e796f | 1014 | int __pshared) __THROW __nonnull ((1)); |
be0f2008 CD |
1015 | |
1016 | #ifdef __USE_XOPEN2K | |
382466e0 | 1017 | /* Get the clock selected for the condition variable attribute ATTR. */ |
c27dd89f | 1018 | extern int pthread_condattr_getclock (const pthread_condattr_t * |
be0f2008 CD |
1019 | __restrict __attr, |
1020 | __clockid_t *__restrict __clock_id) | |
1021 | __THROW __nonnull ((1, 2)); | |
1022 | ||
382466e0 | 1023 | /* Set the clock selected for the condition variable attribute ATTR. */ |
be0f2008 CD |
1024 | extern int pthread_condattr_setclock (pthread_condattr_t *__attr, |
1025 | __clockid_t __clock_id) | |
1026 | __THROW __nonnull ((1)); | |
1027 | #endif | |
1028 | ||
1029 | ||
1030 | #ifdef __USE_XOPEN2K | |
1031 | /* Functions to handle spinlocks. */ | |
1032 | ||
1033 | /* Initialize the spinlock LOCK. If PSHARED is nonzero the spinlock can | |
1034 | be shared between different processes. */ | |
1035 | extern int pthread_spin_init (pthread_spinlock_t *__lock, int __pshared) | |
1036 | __THROW __nonnull ((1)); | |
1037 | ||
1038 | /* Destroy the spinlock LOCK. */ | |
1039 | extern int pthread_spin_destroy (pthread_spinlock_t *__lock) | |
1040 | __THROW __nonnull ((1)); | |
1041 | ||
1042 | /* Wait until spinlock LOCK is retrieved. */ | |
1043 | extern int pthread_spin_lock (pthread_spinlock_t *__lock) | |
c27dd89f | 1044 | __THROWNL __nonnull ((1)); |
be0f2008 CD |
1045 | |
1046 | /* Try to lock spinlock LOCK. */ | |
1047 | extern int pthread_spin_trylock (pthread_spinlock_t *__lock) | |
c27dd89f | 1048 | __THROWNL __nonnull ((1)); |
be0f2008 CD |
1049 | |
1050 | /* Release spinlock LOCK. */ | |
1051 | extern int pthread_spin_unlock (pthread_spinlock_t *__lock) | |
c27dd89f | 1052 | __THROWNL __nonnull ((1)); |
be0f2008 CD |
1053 | |
1054 | ||
1055 | /* Functions to handle barriers. */ | |
1056 | ||
1057 | /* Initialize BARRIER with the attributes in ATTR. The barrier is | |
1058 | opened when COUNT waiters arrived. */ | |
1059 | extern int pthread_barrier_init (pthread_barrier_t *__restrict __barrier, | |
c27dd89f | 1060 | const pthread_barrierattr_t *__restrict |
be0f2008 CD |
1061 | __attr, unsigned int __count) |
1062 | __THROW __nonnull ((1)); | |
1063 | ||
1064 | /* Destroy a previously dynamically initialized barrier BARRIER. */ | |
1065 | extern int pthread_barrier_destroy (pthread_barrier_t *__barrier) | |
1066 | __THROW __nonnull ((1)); | |
1067 | ||
1068 | /* Wait on barrier BARRIER. */ | |
1069 | extern int pthread_barrier_wait (pthread_barrier_t *__barrier) | |
c27dd89f | 1070 | __THROWNL __nonnull ((1)); |
be0f2008 CD |
1071 | |
1072 | ||
1073 | /* Initialize barrier attribute ATTR. */ | |
1074 | extern int pthread_barrierattr_init (pthread_barrierattr_t *__attr) | |
1075 | __THROW __nonnull ((1)); | |
1076 | ||
1077 | /* Destroy previously dynamically initialized barrier attribute ATTR. */ | |
1078 | extern int pthread_barrierattr_destroy (pthread_barrierattr_t *__attr) | |
1079 | __THROW __nonnull ((1)); | |
1080 | ||
1081 | /* Get the process-shared flag of the barrier attribute ATTR. */ | |
c27dd89f | 1082 | extern int pthread_barrierattr_getpshared (const pthread_barrierattr_t * |
be0f2008 CD |
1083 | __restrict __attr, |
1084 | int *__restrict __pshared) | |
1085 | __THROW __nonnull ((1, 2)); | |
1086 | ||
1087 | /* Set the process-shared flag of the barrier attribute ATTR. */ | |
1088 | extern int pthread_barrierattr_setpshared (pthread_barrierattr_t *__attr, | |
c14e796f | 1089 | int __pshared) |
be0f2008 CD |
1090 | __THROW __nonnull ((1)); |
1091 | #endif | |
1092 | ||
1093 | ||
1094 | /* Functions for handling thread-specific data. */ | |
1095 | ||
1096 | /* Create a key value identifying a location in the thread-specific | |
1097 | data area. Each thread maintains a distinct thread-specific data | |
1098 | area. DESTR_FUNCTION, if non-NULL, is called with the value | |
1099 | associated to that key when the key is destroyed. | |
1100 | DESTR_FUNCTION is not called if the value associated is NULL when | |
1101 | the key is destroyed. */ | |
1102 | extern int pthread_key_create (pthread_key_t *__key, | |
1103 | void (*__destr_function) (void *)) | |
1104 | __THROW __nonnull ((1)); | |
1105 | ||
1106 | /* Destroy KEY. */ | |
1107 | extern int pthread_key_delete (pthread_key_t __key) __THROW; | |
1108 | ||
1109 | /* Return current value of the thread-specific data slot identified by KEY. */ | |
1110 | extern void *pthread_getspecific (pthread_key_t __key) __THROW; | |
1111 | ||
1112 | /* Store POINTER in the thread-specific data slot identified by KEY. */ | |
1113 | extern int pthread_setspecific (pthread_key_t __key, | |
c27dd89f | 1114 | const void *__pointer) __THROW ; |
be0f2008 CD |
1115 | |
1116 | ||
1117 | #ifdef __USE_XOPEN2K | |
1118 | /* Get ID of CPU-time clock for thread THREAD_ID. */ | |
1119 | extern int pthread_getcpuclockid (pthread_t __thread_id, | |
1120 | __clockid_t *__clock_id) | |
1121 | __THROW __nonnull ((2)); | |
1122 | #endif | |
1123 | ||
1124 | ||
1125 | /* Install handlers to be called when a new process is created with FORK. | |
1126 | The PREPARE handler is called in the parent process just before performing | |
1127 | FORK. The PARENT handler is called in the parent process just after FORK. | |
1128 | The CHILD handler is called in the child process. Each of the three | |
1129 | handlers can be NULL, meaning that no handler needs to be called at that | |
1130 | point. | |
1131 | PTHREAD_ATFORK can be called several times, in which case the PREPARE | |
1132 | handlers are called in LIFO order (last added with PTHREAD_ATFORK, | |
1133 | first called before FORK), and the PARENT and CHILD handlers are called | |
1134 | in FIFO (first added, first called). */ | |
1135 | ||
1136 | extern int pthread_atfork (void (*__prepare) (void), | |
1137 | void (*__parent) (void), | |
1138 | void (*__child) (void)) __THROW; | |
1139 | ||
1140 | ||
1141 | #ifdef __USE_EXTERN_INLINES | |
1142 | /* Optimizations. */ | |
1143 | __extern_inline int | |
1144 | __NTH (pthread_equal (pthread_t __thread1, pthread_t __thread2)) | |
1145 | { | |
1146 | return __thread1 == __thread2; | |
1147 | } | |
1148 | #endif | |
1149 | ||
1150 | __END_DECLS | |
1151 | ||
1152 | #endif /* pthread.h */ | |
1153 | ||
c14e796f | 1154 | #ifndef _PTHREAD_H_HPPA_ |
be0f2008 CD |
1155 | #define _PTHREAD_H_HPPA_ 1 |
1156 | ||
1157 | /* The pthread_cond_t initializer is compatible only with NPTL. We do not | |
c14e796f | 1158 | want to be forwards compatible, we eventually want to drop the code |
be0f2008 CD |
1159 | that has to clear the old LT initializer. */ |
1160 | #undef PTHREAD_COND_INITIALIZER | |
1161 | #define PTHREAD_COND_INITIALIZER { { 0, 0, 0, (void *) 0, 0, 0, 0, 0, 0 } } | |
1162 | ||
1163 | /* The pthread_mutex_t and pthread_rwlock_t initializers are compatible | |
1164 | only with NPTL. NPTL assumes pthread_rwlock_t is all zero. */ | |
1165 | #undef PTHREAD_MUTEX_INITIALIZER | |
1166 | #undef PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP | |
1167 | #undef PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP | |
1168 | #undef PTHREAD_ADAPTIVE_MUTEX_INITIALIZER_NP | |
1169 | /* Mutex initializers. */ | |
1170 | #define PTHREAD_MUTEX_INITIALIZER \ | |
1171 | { { 0, 0, 0, 0, { 0, 0, 0, 0 }, 0, { 0 }, 0, 0 } } | |
1172 | #ifdef __USE_GNU | |
1173 | # define PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP \ | |
1174 | { { 0, 0, 0, PTHREAD_MUTEX_RECURSIVE_NP, { 0, 0, 0, 0 }, 0, { 0 }, 0, 0 } } | |
1175 | # define PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP \ | |
1176 | { { 0, 0, 0, PTHREAD_MUTEX_ERRORCHECK_NP, { 0, 0, 0, 0 }, 0, { 0 }, 0, 0 } } | |
1177 | # define PTHREAD_ADAPTIVE_MUTEX_INITIALIZER_NP \ | |
1178 | { { 0, 0, 0, PTHREAD_MUTEX_ADAPTIVE_NP, { 0, 0, 0, 0 }, 0, { 0 }, 0, 0 } } | |
1179 | #endif | |
1180 | ||
1181 | #undef PTHREAD_RWLOCK_INITIALIZER | |
1182 | #undef PTHREAD_RWLOCK_WRITER_NONRECURSIVE_INITIALIZER_NP | |
1183 | /* Read-write lock initializers. */ | |
1184 | #define PTHREAD_RWLOCK_INITIALIZER \ | |
1185 | { { { 0, 0, 0, 0 }, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } } | |
1186 | #ifdef __USE_GNU | |
1187 | # define PTHREAD_RWLOCK_WRITER_NONRECURSIVE_INITIALIZER_NP \ | |
1188 | { { { 0, 0, 0, 0 }, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP,\ | |
1189 | 0, 0, 0 } } | |
1190 | #endif /* Unix98 or XOpen2K */ | |
be0f2008 | 1191 | |
c14e796f | 1192 | #endif |