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