Add restrict where required by AGd4.
[kopensolaris-gnu/glibc.git] / linuxthreads / sysdeps / pthread / pthread.h
1 /* Linuxthreads - a simple clone()-based implementation of Posix        */
2 /* threads for Linux.                                                   */
3 /* Copyright (C) 1996 Xavier Leroy (Xavier.Leroy@inria.fr)              */
4 /*                                                                      */
5 /* This program is free software; you can redistribute it and/or        */
6 /* modify it under the terms of the GNU Library General Public License  */
7 /* as published by the Free Software Foundation; either version 2       */
8 /* of the License, or (at your option) any later version.               */
9 /*                                                                      */
10 /* This program is distributed in the hope that it will be useful,      */
11 /* but WITHOUT ANY WARRANTY; without even the implied warranty of       */
12 /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the        */
13 /* GNU Library General Public License for more details.                 */
14
15 #ifndef _PTHREAD_H
16 #define _PTHREAD_H      1
17
18 #include <features.h>
19
20 #include <sched.h>
21 #include <time.h>
22
23 #define __need_sigset_t
24 #include <signal.h>
25 #include <bits/pthreadtypes.h>
26
27
28 __BEGIN_DECLS
29
30 /* Initializers.  */
31
32 #define PTHREAD_MUTEX_INITIALIZER \
33   {0, 0, 0, PTHREAD_MUTEX_TIMED_NP, {0, 0}}
34 #ifdef __USE_GNU
35 # define PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP \
36   {0, 0, 0, PTHREAD_MUTEX_RECURSIVE_NP, {0, 0}}
37 #endif
38
39 #define PTHREAD_COND_INITIALIZER {{0, 0}, 0}
40
41 #ifdef __USE_UNIX98
42 # define PTHREAD_RWLOCK_INITIALIZER \
43   { {0, 0}, 0, NULL, NULL, NULL,                                              \
44     PTHREAD_RWLOCK_DEFAULT_NP, PTHREAD_PROCESS_PRIVATE }
45 #endif
46 #ifdef __USE_GNU
47 # define PTHREAD_RWLOCK_WRITER_NONRECURSIVE_INITIALIZER_NP \
48   { {0, 0}, 0, NULL, NULL, NULL,                                              \
49     PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP, PTHREAD_PROCESS_PRIVATE }
50 #endif
51
52 /* Values for attributes.  */
53
54 enum
55 {
56   PTHREAD_CREATE_JOINABLE,
57 #define PTHREAD_CREATE_JOINABLE PTHREAD_CREATE_JOINABLE
58   PTHREAD_CREATE_DETACHED
59 #define PTHREAD_CREATE_DETACHED PTHREAD_CREATE_DETACHED
60 };
61
62 enum
63 {
64   PTHREAD_INHERIT_SCHED,
65 #define PTHREAD_INHERIT_SCHED   PTHREAD_INHERIT_SCHED
66   PTHREAD_EXPLICIT_SCHED
67 #define PTHREAD_EXPLICIT_SCHED  PTHREAD_EXPLICIT_SCHED
68 };
69
70 enum
71 {
72   PTHREAD_SCOPE_SYSTEM,
73 #define PTHREAD_SCOPE_SYSTEM    PTHREAD_SCOPE_SYSTEM
74   PTHREAD_SCOPE_PROCESS
75 #define PTHREAD_SCOPE_PROCESS   PTHREAD_SCOPE_PROCESS
76 };
77
78 enum
79 {
80   PTHREAD_MUTEX_TIMED_NP,
81   PTHREAD_MUTEX_RECURSIVE_NP,
82   PTHREAD_MUTEX_ERRORCHECK_NP,
83   PTHREAD_MUTEX_ADAPTIVE_NP
84 #ifdef __USE_UNIX98
85   ,
86   PTHREAD_MUTEX_NORMAL = PTHREAD_MUTEX_TIMED_NP,
87   PTHREAD_MUTEX_RECURSIVE = PTHREAD_MUTEX_RECURSIVE_NP,
88   PTHREAD_MUTEX_ERRORCHECK = PTHREAD_MUTEX_ERRORCHECK_NP,
89   PTHREAD_MUTEX_DEFAULT = PTHREAD_MUTEX_NORMAL
90 #endif
91 #ifdef __USE_GNU
92   /* For compatibility.  */
93   , PTHREAD_MUTEX_FAST_NP = PTHREAD_MUTEX_ADAPTIVE_NP
94 #endif
95 };
96
97 enum
98 {
99   PTHREAD_PROCESS_PRIVATE,
100 #define PTHREAD_PROCESS_PRIVATE PTHREAD_PROCESS_PRIVATE
101   PTHREAD_PROCESS_SHARED
102 #define PTHREAD_PROCESS_SHARED  PTHREAD_PROCESS_SHARED
103 };
104
105 #ifdef __USE_UNIX98
106 enum
107 {
108   PTHREAD_RWLOCK_PREFER_READER_NP,
109   PTHREAD_RWLOCK_PREFER_WRITER_NP,
110   PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP,
111   PTHREAD_RWLOCK_DEFAULT_NP = PTHREAD_RWLOCK_PREFER_WRITER_NP
112 };
113 #endif  /* Unix98 */
114
115 #define PTHREAD_ONCE_INIT 0
116
117 /* Special constants */
118
119 #ifdef __USE_XOPEN2K
120 /* -1 is distinct from 0 and all errno constants */
121 # define PTHREAD_BARRIER_SERIAL_THREAD -1
122 #endif
123
124 /* Cleanup buffers */
125
126 struct _pthread_cleanup_buffer
127 {
128   void (*__routine) (void *);             /* Function to call.  */
129   void *__arg;                            /* Its argument.  */
130   int __canceltype;                       /* Saved cancellation type. */
131   struct _pthread_cleanup_buffer *__prev; /* Chaining of cleanup functions.  */
132 };
133
134 /* Cancellation */
135
136 enum
137 {
138   PTHREAD_CANCEL_ENABLE,
139 #define PTHREAD_CANCEL_ENABLE   PTHREAD_CANCEL_ENABLE
140   PTHREAD_CANCEL_DISABLE
141 #define PTHREAD_CANCEL_DISABLE  PTHREAD_CANCEL_DISABLE
142 };
143 enum
144 {
145   PTHREAD_CANCEL_DEFERRED,
146 #define PTHREAD_CANCEL_DEFERRED PTHREAD_CANCEL_DEFERRED
147   PTHREAD_CANCEL_ASYNCHRONOUS
148 #define PTHREAD_CANCEL_ASYNCHRONOUS     PTHREAD_CANCEL_ASYNCHRONOUS
149 };
150 #define PTHREAD_CANCELED ((void *) -1)
151
152
153 /* Function for handling threads.  */
154
155 /* Create a thread with given attributes ATTR (or default attributes
156    if ATTR is NULL), and call function START_ROUTINE with given
157    arguments ARG.  */
158 extern int pthread_create (pthread_t *__restrict __thread,
159                            __const pthread_attr_t *__restrict __attr,
160                            void *(*__start_routine) (void *),
161                            void *__restrict __arg) __THROW;
162
163 /* Obtain the identifier of the current thread.  */
164 extern pthread_t pthread_self (void) __THROW;
165
166 /* Compare two thread identifiers.  */
167 extern int pthread_equal (pthread_t __thread1, pthread_t __thread2) __THROW;
168
169 /* Terminate calling thread.  */
170 extern void pthread_exit (void *__retval)
171      __THROW __attribute__ ((__noreturn__));
172
173 /* Make calling thread wait for termination of the thread TH.  The
174    exit status of the thread is stored in *THREAD_RETURN, if THREAD_RETURN
175    is not NULL.  */
176 extern int pthread_join (pthread_t __th, void **__thread_return) __THROW;
177
178 /* Indicate that the thread TH is never to be joined with PTHREAD_JOIN.
179    The resources of TH will therefore be freed immediately when it
180    terminates, instead of waiting for another thread to perform PTHREAD_JOIN
181    on it.  */
182 extern int pthread_detach (pthread_t __th) __THROW;
183
184
185 /* Functions for handling attributes.  */
186
187 /* Initialize thread attribute *ATTR with default attributes
188    (detachstate is PTHREAD_JOINABLE, scheduling policy is SCHED_OTHER,
189     no user-provided stack).  */
190 extern int pthread_attr_init (pthread_attr_t *__attr) __THROW;
191
192 /* Destroy thread attribute *ATTR.  */
193 extern int pthread_attr_destroy (pthread_attr_t *__attr) __THROW;
194
195 /* Set the `detachstate' attribute in *ATTR according to DETACHSTATE.  */
196 extern int pthread_attr_setdetachstate (pthread_attr_t *__attr,
197                                         int __detachstate) __THROW;
198
199 /* Return in *DETACHSTATE the `detachstate' attribute in *ATTR.  */
200 extern int pthread_attr_getdetachstate (__const pthread_attr_t *__attr,
201                                         int *__detachstate) __THROW;
202
203 /* Set scheduling parameters (priority, etc) in *ATTR according to PARAM.  */
204 extern int pthread_attr_setschedparam (pthread_attr_t *__restrict __attr,
205                                        __const struct sched_param *__restrict
206                                        __param) __THROW;
207
208 /* Return in *PARAM the scheduling parameters of *ATTR.  */
209 extern int pthread_attr_getschedparam (__const pthread_attr_t *__restrict
210                                        __attr,
211                                        struct sched_param *__restrict __param)
212      __THROW;
213
214 /* Set scheduling policy in *ATTR according to POLICY.  */
215 extern int pthread_attr_setschedpolicy (pthread_attr_t *__attr, int __policy)
216      __THROW;
217
218 /* Return in *POLICY the scheduling policy of *ATTR.  */
219 extern int pthread_attr_getschedpolicy (__const pthread_attr_t *__restrict
220                                         __attr, int *__restrict __policy)
221      __THROW;
222
223 /* Set scheduling inheritance mode in *ATTR according to INHERIT.  */
224 extern int pthread_attr_setinheritsched (pthread_attr_t *__attr,
225                                          int __inherit) __THROW;
226
227 /* Return in *INHERIT the scheduling inheritance mode of *ATTR.  */
228 extern int pthread_attr_getinheritsched (__const pthread_attr_t *__restrict
229                                          __attr, int *__restrict __inherit)
230      __THROW;
231
232 /* Set scheduling contention scope in *ATTR according to SCOPE.  */
233 extern int pthread_attr_setscope (pthread_attr_t *__attr, int __scope)
234      __THROW;
235
236 /* Return in *SCOPE the scheduling contention scope of *ATTR.  */
237 extern int pthread_attr_getscope (__const pthread_attr_t *__restrict __attr,
238                                   int *__restrict __scope) __THROW;
239
240 #ifdef __USE_UNIX98
241 /* Set the size of the guard area at the bottom of the thread.  */
242 extern int pthread_attr_setguardsize (pthread_attr_t *__attr,
243                                       size_t __guardsize) __THROW;
244
245 /* Get the size of the guard area at the bottom of the thread.  */
246 extern int pthread_attr_getguardsize (__const pthread_attr_t *__restrict
247                                       __attr, size_t *__restrict __guardsize)
248      __THROW;
249 #endif
250
251 /* Set the starting address of the stack of the thread to be created.
252    Depending on whether the stack grows up or down the value must either
253    be higher or lower than all the address in the memory block.  The
254    minimal size of the block must be PTHREAD_STACK_SIZE.  */
255 extern int pthread_attr_setstackaddr (pthread_attr_t *__attr,
256                                       void *__stackaddr) __THROW;
257
258 /* Return the previously set address for the stack.  */
259 extern int pthread_attr_getstackaddr (__const pthread_attr_t *__restrict
260                                       __attr, void **__restrict __stackaddr)
261      __THROW;
262
263 /* Add information about the minimum stack size needed for the thread
264    to be started.  This size must never be less than PTHREAD_STACK_SIZE
265    and must also not exceed the system limits.  */
266 extern int pthread_attr_setstacksize (pthread_attr_t *__attr,
267                                       size_t __stacksize) __THROW;
268
269 /* Return the currently used minimal stack size.  */
270 extern int pthread_attr_getstacksize (__const pthread_attr_t *__restrict
271                                       __attr, size_t *__restrict __stacksize)
272      __THROW;
273
274 /* Functions for scheduling control.  */
275
276 /* Set the scheduling parameters for TARGET_THREAD according to POLICY
277    and *PARAM.  */
278 extern int pthread_setschedparam (pthread_t __target_thread, int __policy,
279                                   __const struct sched_param *__param)
280      __THROW;
281
282 /* Return in *POLICY and *PARAM the scheduling parameters for TARGET_THREAD.  */
283 extern int pthread_getschedparam (pthread_t __target_thread,
284                                   int *__restrict __policy,
285                                   struct sched_param *__restrict __param)
286      __THROW;
287
288 #ifdef __USE_UNIX98
289 /* Determine level of concurrency.  */
290 extern int pthread_getconcurrency (void) __THROW;
291
292 /* Set new concurrency level to LEVEL.  */
293 extern int pthread_setconcurrency (int __level) __THROW;
294 #endif
295
296 #ifdef __USE_GNU
297 /* Yield the processor to another thread or process.
298    This function is similar to the POSIX `sched_yield' function but
299    might be differently implemented in the case of a m-on-n thread
300    implementation.  */
301 extern int pthread_yield (void) __THROW;
302 #endif
303
304 /* Functions for mutex handling.  */
305
306 /* Initialize MUTEX using attributes in *MUTEX_ATTR, or use the
307    default values if later is NULL.  */
308 extern int pthread_mutex_init (pthread_mutex_t *__restrict __mutex,
309                                __const pthread_mutexattr_t *__restrict
310                                __mutex_attr) __THROW;
311
312 /* Destroy MUTEX.  */
313 extern int pthread_mutex_destroy (pthread_mutex_t *__mutex) __THROW;
314
315 /* Try to lock MUTEX.  */
316 extern int pthread_mutex_trylock (pthread_mutex_t *__mutex) __THROW;
317
318 /* Wait until lock for MUTEX becomes available and lock it.  */
319 extern int pthread_mutex_lock (pthread_mutex_t *__mutex) __THROW;
320
321 #ifdef __USE_XOPEN2K
322 /* Wait until lock becomes available, or specified time passes. */
323 extern int pthread_mutex_timedlock (pthread_mutex_t *__restrict __mutex,
324                                     __const struct timespec *__restrict
325                                     __abstime) __THROW;
326 #endif
327
328 /* Unlock MUTEX.  */
329 extern int pthread_mutex_unlock (pthread_mutex_t *__mutex) __THROW;
330
331
332 /* Functions for handling mutex attributes.  */
333
334 /* Initialize mutex attribute object ATTR with default attributes
335    (kind is PTHREAD_MUTEX_TIMED_NP).  */
336 extern int pthread_mutexattr_init (pthread_mutexattr_t *__attr) __THROW;
337
338 /* Destroy mutex attribute object ATTR.  */
339 extern int pthread_mutexattr_destroy (pthread_mutexattr_t *__attr) __THROW;
340
341 /* Get the process-shared flag of the mutex attribute ATTR.  */
342 extern int pthread_mutexattr_getpshared (__const pthread_mutexattr_t *
343                                          __restrict __attr,
344                                          int *__restrict __pshared) __THROW;
345
346 /* Set the process-shared flag of the mutex attribute ATTR.  */
347 extern int pthread_mutexattr_setpshared (pthread_mutexattr_t *__attr,
348                                          int __pshared) __THROW;
349
350 #ifdef __USE_UNIX98
351 /* Set the mutex kind attribute in *ATTR to KIND (either PTHREAD_MUTEX_NORMAL,
352    PTHREAD_MUTEX_RECURSIVE, PTHREAD_MUTEX_ERRORCHECK, or
353    PTHREAD_MUTEX_DEFAULT).  */
354 extern int pthread_mutexattr_settype (pthread_mutexattr_t *__attr, int __kind)
355      __THROW;
356
357 /* Return in *KIND the mutex kind attribute in *ATTR.  */
358 extern int pthread_mutexattr_gettype (__const pthread_mutexattr_t *__restrict
359                                       __attr, int *__restrict __kind) __THROW;
360 #endif
361
362
363 /* Functions for handling conditional variables.  */
364
365 /* Initialize condition variable COND using attributes ATTR, or use
366    the default values if later is NULL.  */
367 extern int pthread_cond_init (pthread_cond_t *__restrict __cond,
368                               __const pthread_condattr_t *__restrict
369                               __cond_attr) __THROW;
370
371 /* Destroy condition variable COND.  */
372 extern int pthread_cond_destroy (pthread_cond_t *__cond) __THROW;
373
374 /* Wake up one thread waiting for condition variable COND.  */
375 extern int pthread_cond_signal (pthread_cond_t *__cond) __THROW;
376
377 /* Wake up all threads waiting for condition variables COND.  */
378 extern int pthread_cond_broadcast (pthread_cond_t *__cond) __THROW;
379
380 /* Wait for condition variable COND to be signaled or broadcast.
381    MUTEX is assumed to be locked before.  */
382 extern int pthread_cond_wait (pthread_cond_t *__restrict __cond,
383                               pthread_mutex_t *__restrict __mutex) __THROW;
384
385 /* Wait for condition variable COND to be signaled or broadcast until
386    ABSTIME.  MUTEX is assumed to be locked before.  ABSTIME is an
387    absolute time specification; zero is the beginning of the epoch
388    (00:00:00 GMT, January 1, 1970).  */
389 extern int pthread_cond_timedwait (pthread_cond_t *__restrict __cond,
390                                    pthread_mutex_t *__restrict __mutex,
391                                    __const struct timespec *__restrict
392                                    __abstime) __THROW;
393
394 /* Functions for handling condition variable attributes.  */
395
396 /* Initialize condition variable attribute ATTR.  */
397 extern int pthread_condattr_init (pthread_condattr_t *__attr) __THROW;
398
399 /* Destroy condition variable attribute ATTR.  */
400 extern int pthread_condattr_destroy (pthread_condattr_t *__attr) __THROW;
401
402 /* Get the process-shared flag of the condition variable attribute ATTR.  */
403 extern int pthread_condattr_getpshared (__const pthread_condattr_t *
404                                         __restrict __attr,
405                                         int *__restrict __pshared) __THROW;
406
407 /* Set the process-shared flag of the condition variable attribute ATTR.  */
408 extern int pthread_condattr_setpshared (pthread_condattr_t *__attr,
409                                         int __pshared) __THROW;
410
411
412 #ifdef __USE_UNIX98
413 /* Functions for handling read-write locks.  */
414
415 /* Initialize read-write lock RWLOCK using attributes ATTR, or use
416    the default values if later is NULL.  */
417 extern int pthread_rwlock_init (pthread_rwlock_t *__restrict __rwlock,
418                                 __const pthread_rwlockattr_t *__restrict
419                                 __attr) __THROW;
420
421 /* Destroy read-write lock RWLOCK.  */
422 extern int pthread_rwlock_destroy (pthread_rwlock_t *__rwlock) __THROW;
423
424 /* Acquire read lock for RWLOCK.  */
425 extern int pthread_rwlock_rdlock (pthread_rwlock_t *__rwlock) __THROW;
426
427 /* Try to acquire read lock for RWLOCK.  */
428 extern int pthread_rwlock_tryrdlock (pthread_rwlock_t *__rwlock) __THROW;
429
430 #ifdef __USE_XOPEN2K
431 /* Try to acquire read lock for RWLOCK or return after specfied time.  */
432 extern int pthread_rwlock_timedrdlock (pthread_rwlock_t *__restrict __rwlock,
433                                        __const struct timespec *__restrict
434                                        __abstime) __THROW;
435 #endif
436
437 /* Acquire write lock for RWLOCK.  */
438 extern int pthread_rwlock_wrlock (pthread_rwlock_t *__rwlock) __THROW;
439
440 /* Try to acquire write lock for RWLOCK.  */
441 extern int pthread_rwlock_trywrlock (pthread_rwlock_t *__rwlock) __THROW;
442
443 #ifdef __USE_XOPEN2K
444 /* Try to acquire write lock for RWLOCK or return after specfied time.  */
445 extern int pthread_rwlock_timedwrlock (pthread_rwlock_t *__restrict __rwlock,
446                                        __const struct timespec *__restrict
447                                        __abstime) __THROW;
448 #endif
449
450 /* Unlock RWLOCK.  */
451 extern int pthread_rwlock_unlock (pthread_rwlock_t *__rwlock) __THROW;
452
453
454 /* Functions for handling read-write lock attributes.  */
455
456 /* Initialize attribute object ATTR with default values.  */
457 extern int pthread_rwlockattr_init (pthread_rwlockattr_t *__attr) __THROW;
458
459 /* Destroy attribute object ATTR.  */
460 extern int pthread_rwlockattr_destroy (pthread_rwlockattr_t *__attr) __THROW;
461
462 /* Return current setting of process-shared attribute of ATTR in PSHARED.  */
463 extern int pthread_rwlockattr_getpshared (__const pthread_rwlockattr_t *
464                                           __restrict __attr,
465                                           int *__restrict __pshared) __THROW;
466
467 /* Set process-shared attribute of ATTR to PSHARED.  */
468 extern int pthread_rwlockattr_setpshared (pthread_rwlockattr_t *__attr,
469                                           int __pshared) __THROW;
470
471 /* Return current setting of reader/writer preference.  */
472 extern int pthread_rwlockattr_getkind_np (__const pthread_rwlockattr_t *__attr,
473                                           int *__pref) __THROW;
474
475 /* Set reader/write preference.  */
476 extern int pthread_rwlockattr_setkind_np (pthread_rwlockattr_t *__attr,
477                                           int __pref) __THROW;
478 #endif
479
480 #ifdef __USE_XOPEN2K
481 /* The IEEE Std. 1003.1j-2000 introduces functions to implement
482    spinlocks.  */
483
484 /* Initialize the spinlock LOCK.  If PSHARED is nonzero the spinlock can
485    be shared between different processes.  */
486 extern int pthread_spin_init (pthread_spinlock_t *__lock, int __pshared)
487      __THROW;
488
489 /* Destroy the spinlock LOCK.  */
490 extern int pthread_spin_destroy (pthread_spinlock_t *__lock) __THROW;
491
492 /* Wait until spinlock LOCK is retrieved.  */
493 extern int pthread_spin_lock (pthread_spinlock_t *__lock) __THROW;
494
495 /* Try to lock spinlock LOCK.  */
496 extern int pthread_spin_trylock (pthread_spinlock_t *__lock) __THROW;
497
498 /* Release spinlock LOCK.  */
499 extern int pthread_spin_unlock (pthread_spinlock_t *__lock) __THROW;
500
501
502 /* Barriers are a also a new feature in 1003.1j-2000. */
503
504 extern int pthread_barrier_init (pthread_barrier_t *__restrict __barrier,
505                                  __const pthread_barrierattr_t *__restrict
506                                  __attr, unsigned int __count) __THROW;
507
508 extern int pthread_barrier_destroy (pthread_barrier_t *__barrier) __THROW;
509
510 extern int pthread_barrierattr_init (pthread_barrierattr_t *__attr) __THROW;
511
512 extern int pthread_barrierattr_destroy (pthread_barrierattr_t *__attr) __THROW;
513
514 extern int pthread_barrierattr_getpshared (__const pthread_barrierattr_t *
515                                            __restrict __attr,
516                                            int *__restrict __pshared) __THROW;
517
518 extern int pthread_barrierattr_setpshared (pthread_barrierattr_t *__attr,
519                                            int __pshared) __THROW;
520
521 extern int pthread_barrier_wait (pthread_barrier_t *__barrier) __THROW;
522 #endif
523
524
525 /* Functions for handling thread-specific data.  */
526
527 /* Create a key value identifying a location in the thread-specific
528    data area.  Each thread maintains a distinct thread-specific data
529    area.  DESTR_FUNCTION, if non-NULL, is called with the value
530    associated to that key when the key is destroyed.
531    DESTR_FUNCTION is not called if the value associated is NULL when
532    the key is destroyed.  */
533 extern int pthread_key_create (pthread_key_t *__key,
534                                void (*__destr_function) (void *)) __THROW;
535
536 /* Destroy KEY.  */
537 extern int pthread_key_delete (pthread_key_t __key) __THROW;
538
539 /* Store POINTER in the thread-specific data slot identified by KEY. */
540 extern int pthread_setspecific (pthread_key_t __key,
541                                 __const void *__pointer) __THROW;
542
543 /* Return current value of the thread-specific data slot identified by KEY.  */
544 extern void *pthread_getspecific (pthread_key_t __key) __THROW;
545
546
547 /* Functions for handling initialization.  */
548
549 /* Guarantee that the initialization function INIT_ROUTINE will be called
550    only once, even if pthread_once is executed several times with the
551    same ONCE_CONTROL argument. ONCE_CONTROL must point to a static or
552    extern variable initialized to PTHREAD_ONCE_INIT.  */
553 extern int pthread_once (pthread_once_t *__once_control,
554                          void (*__init_routine) (void)) __THROW;
555
556
557 /* Functions for handling cancellation.  */
558
559 /* Set cancelability state of current thread to STATE, returning old
560    state in *OLDSTATE if OLDSTATE is not NULL.  */
561 extern int pthread_setcancelstate (int __state, int *__oldstate) __THROW;
562
563 /* Set cancellation state of current thread to TYPE, returning the old
564    type in *OLDTYPE if OLDTYPE is not NULL.  */
565 extern int pthread_setcanceltype (int __type, int *__oldtype) __THROW;
566
567 /* Cancel THREAD immediately or at the next possibility.  */
568 extern int pthread_cancel (pthread_t __thread) __THROW;
569
570 /* Test for pending cancellation for the current thread and terminate
571    the thread as per pthread_exit(PTHREAD_CANCELED) if it has been
572    cancelled.  */
573 extern void pthread_testcancel (void) __THROW;
574
575
576 /* Install a cleanup handler: ROUTINE will be called with arguments ARG
577    when the thread is cancelled or calls pthread_exit.  ROUTINE will also
578    be called with arguments ARG when the matching pthread_cleanup_pop
579    is executed with non-zero EXECUTE argument.
580    pthread_cleanup_push and pthread_cleanup_pop are macros and must always
581    be used in matching pairs at the same nesting level of braces. */
582
583 #define pthread_cleanup_push(routine,arg) \
584   { struct _pthread_cleanup_buffer _buffer;                                   \
585     _pthread_cleanup_push (&_buffer, (routine), (arg));
586
587 extern void _pthread_cleanup_push (struct _pthread_cleanup_buffer *__buffer,
588                                    void (*__routine) (void *),
589                                    void *__arg) __THROW;
590
591 /* Remove a cleanup handler installed by the matching pthread_cleanup_push.
592    If EXECUTE is non-zero, the handler function is called. */
593
594 #define pthread_cleanup_pop(execute) \
595     _pthread_cleanup_pop (&_buffer, (execute)); }
596
597 extern void _pthread_cleanup_pop (struct _pthread_cleanup_buffer *__buffer,
598                                   int __execute) __THROW;
599
600 /* Install a cleanup handler as pthread_cleanup_push does, but also
601    saves the current cancellation type and set it to deferred cancellation.  */
602
603 #ifdef __USE_GNU
604 # define pthread_cleanup_push_defer_np(routine,arg) \
605   { struct _pthread_cleanup_buffer _buffer;                                   \
606     _pthread_cleanup_push_defer (&_buffer, (routine), (arg));
607
608 extern void _pthread_cleanup_push_defer (struct _pthread_cleanup_buffer *__buffer,
609                                          void (*__routine) (void *),
610                                          void *__arg) __THROW;
611
612 /* Remove a cleanup handler as pthread_cleanup_pop does, but also
613    restores the cancellation type that was in effect when the matching
614    pthread_cleanup_push_defer was called.  */
615
616 # define pthread_cleanup_pop_restore_np(execute) \
617   _pthread_cleanup_pop_restore (&_buffer, (execute)); }
618
619 extern void _pthread_cleanup_pop_restore (struct _pthread_cleanup_buffer *__buffer,
620                                           int __execute) __THROW;
621 #endif
622
623
624 #ifdef __USE_XOPEN2K
625 /* Get ID of CPU-time clock for thread THREAD_ID.  */
626 extern int pthread_getcpuclockid (pthread_t __thread_id,
627                                   clockid_t *__clock_id) __THROW;
628 #endif
629
630
631 /* Functions for handling signals.  */
632 #include <bits/sigthread.h>
633
634
635 /* Functions for handling process creation and process execution.  */
636
637 /* Install handlers to be called when a new process is created with FORK.
638    The PREPARE handler is called in the parent process just before performing
639    FORK. The PARENT handler is called in the parent process just after FORK.
640    The CHILD handler is called in the child process.  Each of the three
641    handlers can be NULL, meaning that no handler needs to be called at that
642    point.
643    PTHREAD_ATFORK can be called several times, in which case the PREPARE
644    handlers are called in LIFO order (last added with PTHREAD_ATFORK,
645    first called before FORK), and the PARENT and CHILD handlers are called
646    in FIFO (first added, first called).  */
647
648 extern int pthread_atfork (void (*__prepare) (void),
649                            void (*__parent) (void),
650                            void (*__child) (void)) __THROW;
651
652 /* Terminate all threads in the program except the calling process.
653    Should be called just before invoking one of the exec*() functions.  */
654
655 extern void pthread_kill_other_threads_np (void) __THROW;
656
657
658 /* This function is called to initialize the pthread library.  */
659 extern void __pthread_initialize (void) __THROW;
660
661 __END_DECLS
662
663 #endif  /* pthread.h */