1 /* Copyright (C) 2002-2012 Free Software Foundation, Inc.
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
15 License along with the GNU C Library; if not, see
16 <http://www.gnu.org/licenses/>. */
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
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
48 #if defined __USE_UNIX98 || defined __USE_XOPEN2K8
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
74 #if defined __USE_POSIX199506 || defined __USE_UNIX98
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. */
86 #ifdef __PTHREAD_MUTEX_HAVE_PREV
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
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
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
134 # ifdef __PTHREAD_RWLOCK_INT_FLAGS_SHARED
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,
233 const pthread_attr_t *__restrict __attr,
234 void *(*__start_routine) (void *),
235 void *__restrict __arg) __THROWNL __nonnull ((1, 3));
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,
263 const struct timespec *__abstime);
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. */
277 extern int pthread_equal (pthread_t __thread1, pthread_t __thread2)
278 __THROW __attribute__ ((__const__));
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. */
293 extern int pthread_attr_getdetachstate (const pthread_attr_t *__attr,
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. */
304 extern int pthread_attr_getguardsize (const pthread_attr_t *__attr,
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. */
315 extern int pthread_attr_getschedparam (const pthread_attr_t *__restrict __attr,
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,
321 const struct sched_param *__restrict
322 __param) __THROW __nonnull ((1, 2));
323
324 /* Return in *POLICY the scheduling policy of *ATTR. */
325 extern int pthread_attr_getschedpolicy (const pthread_attr_t *__restrict
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. */
334 extern int pthread_attr_getinheritsched (const pthread_attr_t *__restrict
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. */
345 extern int pthread_attr_getscope (const pthread_attr_t *__restrict __attr,
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. */
354 extern int pthread_attr_getstackaddr (const pthread_attr_t *__restrict
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. */
367 extern int pthread_attr_getstacksize (const pthread_attr_t *__restrict
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. */
380 extern int pthread_attr_getstack (const pthread_attr_t *__restrict __attr,
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,
397 const cpu_set_t *__cpuset)
398 __THROW __nonnull ((1, 3));
399
400 /* Get bit set in CPUSET representing the processors threads created with
401 ATTR can run on. */
402 extern int pthread_attr_getaffinity_np (const pthread_attr_t *__attr,
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,
421 const struct sched_param *__param)
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
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. */
442 extern int pthread_setname_np (pthread_t __target_thread, const char *__name)
443 __THROW __nonnull ((2));
444 #endif
445
446
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,
466 const cpu_set_t *__cpuset)
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:
__pthread_cleanup_class(void (* __fct)(void *),void * __arg)550 __pthread_cleanup_class (void (*__fct) (void *), void *__arg)
551 : __cancel_routine (__fct), __cancel_arg (__arg), __do_it (1) { }
~__pthread_cleanup_class()552 ~__pthread_cleanup_class () { if (__do_it) __cancel_routine (__cancel_arg); }
__setdoit(int __newval)553 void __setdoit (int __newval) { __do_it = __newval; }
__defer()554 void __defer () { pthread_setcanceltype (PTHREAD_CANCEL_DEFERRED,
555 &__cancel_type); }
__restore()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
__pthread_cleanup_routine(struct __pthread_cleanup_frame * __frame)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); \
660 int __not_first_call = __sigsetjmp ((struct __jmp_buf_tag *) (void *) \
661 __cancel_buf.__cancel_jmp_buf, 0); \
662 if (__glibc_unlikely (__not_first_call)) \
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); \
695 int __not_first_call = __sigsetjmp ((struct __jmp_buf_tag *) (void *) \
696 __cancel_buf.__cancel_jmp_buf, 0); \
697 if (__glibc_unlikely (__not_first_call)) \
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;
734 extern int __sigsetjmp (struct __jmp_buf_tag *__env, int __savemask) __THROWNL;
735
736
737 /* Mutex handling. */
738
739 /* Initialize a mutex. */
740 extern int pthread_mutex_init (pthread_mutex_t *__mutex,
741 const pthread_mutexattr_t *__mutexattr)
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)
750 __THROWNL __nonnull ((1));
751
752 /* Lock a mutex. */
753 extern int pthread_mutex_lock (pthread_mutex_t *__mutex)
754 __THROWNL __nonnull ((1));
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,
759 const struct timespec *__restrict
760 __abstime) __THROWNL __nonnull ((1, 2));
761 #endif
762
763 /* Unlock a mutex. */
764 extern int pthread_mutex_unlock (pthread_mutex_t *__mutex)
765 __THROWNL __nonnull ((1));
766
767
768 /* Get the priority ceiling of MUTEX. */
769 extern int pthread_mutex_getprioceiling (const pthread_mutex_t *
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));
780
781
782 #ifdef __USE_XOPEN2K8
783 /* Declare the state protected by MUTEX as consistent. */
784 extern int pthread_mutex_consistent (pthread_mutex_t *__mutex)
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. */
805 extern int pthread_mutexattr_getpshared (const pthread_mutexattr_t *
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
815 #if defined __USE_UNIX98 || defined __USE_XOPEN2K8
816 /* Return in *KIND the mutex kind attribute in *ATTR. */
817 extern int pthread_mutexattr_gettype (const pthread_mutexattr_t *__restrict
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));
826 #endif
827
828 /* Return in *PROTOCOL the mutex protocol attribute in *ATTR. */
829 extern int pthread_mutexattr_getprotocol (const pthread_mutexattr_t *
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. */
841 extern int pthread_mutexattr_getprioceiling (const pthread_mutexattr_t *
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));
850
851 #ifdef __USE_XOPEN2K
852 /* Get the robustness flag of the mutex attribute ATTR. */
853 extern int pthread_mutexattr_getrobust (const pthread_mutexattr_t *__attr,
854 int *__robustness)
855 __THROW __nonnull ((1, 2));
856 # ifdef __USE_GNU
857 extern int pthread_mutexattr_getrobust_np (const pthread_mutexattr_t *__attr,
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,
880 const pthread_rwlockattr_t *__restrict
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)
889 __THROWNL __nonnull ((1));
890
891 /* Try to acquire read lock for RWLOCK. */
892 extern int pthread_rwlock_tryrdlock (pthread_rwlock_t *__rwlock)
893 __THROWNL __nonnull ((1));
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,
898 const struct timespec *__restrict
899 __abstime) __THROWNL __nonnull ((1, 2));
900 # endif
901
902 /* Acquire write lock for RWLOCK. */
903 extern int pthread_rwlock_wrlock (pthread_rwlock_t *__rwlock)
904 __THROWNL __nonnull ((1));
905
906 /* Try to acquire write lock for RWLOCK. */
907 extern int pthread_rwlock_trywrlock (pthread_rwlock_t *__rwlock)
908 __THROWNL __nonnull ((1));
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,
913 const struct timespec *__restrict
914 __abstime) __THROWNL __nonnull ((1, 2));
915 # endif
916
917 /* Unlock RWLOCK. */
918 extern int pthread_rwlock_unlock (pthread_rwlock_t *__rwlock)
919 __THROWNL __nonnull ((1));
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. */
933 extern int pthread_rwlockattr_getpshared (const pthread_rwlockattr_t *
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. */
944 extern int pthread_rwlockattr_getkind_np (const pthread_rwlockattr_t *
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,
960 const pthread_condattr_t *__restrict __cond_attr)
961 __THROW __nonnull ((1));
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)
969 __THROWNL __nonnull ((1));
970
971 /* Wake up all threads waiting for condition variables COND. */
972 extern int pthread_cond_broadcast (pthread_cond_t *__cond)
973 __THROWNL __nonnull ((1));
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,
993 const struct timespec *__restrict __abstime)
994 __nonnull ((1, 2, 3));
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. */
1007 extern int pthread_condattr_getpshared (const pthread_condattr_t *
1008 __restrict __attr,
1009 int *__restrict __pshared)
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,
1014 int __pshared) __THROW __nonnull ((1));
1015
1016 #ifdef __USE_XOPEN2K
1017 /* Get the clock selected for the conditon variable attribute ATTR. */
1018 extern int pthread_condattr_getclock (const pthread_condattr_t *
1019 __restrict __attr,
1020 __clockid_t *__restrict __clock_id)
1021 __THROW __nonnull ((1, 2));
1022
1023 /* Set the clock selected for the conditon variable attribute ATTR. */
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)
1044 __THROWNL __nonnull ((1));
1045
1046 /* Try to lock spinlock LOCK. */
1047 extern int pthread_spin_trylock (pthread_spinlock_t *__lock)
1048 __THROWNL __nonnull ((1));
1049
1050 /* Release spinlock LOCK. */
1051 extern int pthread_spin_unlock (pthread_spinlock_t *__lock)
1052 __THROWNL __nonnull ((1));
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,
1060 const pthread_barrierattr_t *__restrict
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)
1070 __THROWNL __nonnull ((1));
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. */
1082 extern int pthread_barrierattr_getpshared (const pthread_barrierattr_t *
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,
1089 int __pshared)
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,
1114 const void *__pointer) __THROW ;
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
__NTH(pthread_equal (pthread_t __thread1,pthread_t __thread2))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